diff --git a/benches/proof_benchmarks.rs b/benches/proof_benchmarks.rs index d2ccacc..ce066fd 100644 --- a/benches/proof_benchmarks.rs +++ b/benches/proof_benchmarks.rs @@ -14,9 +14,9 @@ use echidna::verification::axiom_tracker::AxiomTracker; use echidna::verification::confidence::{compute_trust_level, TrustFactors, TrustLevel}; use echidna::verification::mutation::MutationTester; use echidna::verification::pareto::{ParetoFrontier, ProofCandidate, ProofObjective}; +use echidna::verification::portfolio::PortfolioConfidence; use echidna::verification::statistics::StatisticsTracker; use echidna::verification::DangerLevel; -use echidna::verification::portfolio::PortfolioConfidence; use std::collections::HashMap; @@ -192,7 +192,11 @@ fn bench_trust_computation(c: &mut Criterion) { /// Benchmark axiom danger scanning fn bench_axiom_scanning(c: &mut Criterion) { let test_contents = [ - ("clean_lean", ProverKind::Lean, "theorem foo : True := trivial"), + ( + "clean_lean", + ProverKind::Lean, + "theorem foo : True := trivial", + ), ( "sorry_lean", ProverKind::Lean, @@ -237,10 +241,7 @@ fn bench_mutation_generation(c: &mut Criterion) { args: vec![ Term::App { func: Box::new(Term::Const("add".to_string())), - args: vec![ - Term::Var("x".to_string()), - Term::Const("0".to_string()), - ], + args: vec![Term::Var("x".to_string()), Term::Const("0".to_string())], }, Term::Var("x".to_string()), ], @@ -258,27 +259,23 @@ fn bench_mutation_generation(c: &mut Criterion) { fn bench_pareto_frontier(c: &mut Criterion) { let mut group = c.benchmark_group("pareto_frontier"); for n_points in [10, 50, 100] { - group.bench_with_input( - BenchmarkId::from_parameter(n_points), - &n_points, - |b, &n| { - b.iter(|| { - let mut candidates: Vec = (0..n) - .map(|i| ProofCandidate { - id: format!("candidate_{i}"), - objectives: ProofObjective { - proof_time_ms: (i as u64) * 100, - trust_level: TrustLevel::Level3, - memory_bytes: (n as u64 - i as u64) * 1024, - proof_steps: i * 5, - }, - is_pareto_optimal: false, - }) - .collect(); - black_box(ParetoFrontier::compute(&mut candidates)) - }) - }, - ); + group.bench_with_input(BenchmarkId::from_parameter(n_points), &n_points, |b, &n| { + b.iter(|| { + let mut candidates: Vec = (0..n) + .map(|i| ProofCandidate { + id: format!("candidate_{i}"), + objectives: ProofObjective { + proof_time_ms: (i as u64) * 100, + trust_level: TrustLevel::Level3, + memory_bytes: (n as u64 - i as u64) * 1024, + proof_steps: i * 5, + }, + is_pareto_optimal: false, + }) + .collect(); + black_box(ParetoFrontier::compute(&mut candidates)) + }) + }); } group.finish(); } @@ -329,11 +326,7 @@ criterion_group!( bench_prover_detection, ); -criterion_group!( - trust_benches, - bench_trust_computation, - bench_axiom_scanning, -); +criterion_group!(trust_benches, bench_trust_computation, bench_axiom_scanning,); criterion_group!( verification_benches, diff --git a/benches/routing_benchmarks.rs b/benches/routing_benchmarks.rs index 754d49e..0ad1e89 100644 --- a/benches/routing_benchmarks.rs +++ b/benches/routing_benchmarks.rs @@ -57,10 +57,9 @@ fn bench_routing_decision_latency(c: &mut Criterion) { |b, content| { b.iter(|| { // Deterministic hash-based prover selection — the routing hot path. - let hash: usize = content - .as_bytes() - .iter() - .fold(0usize, |acc, &byte| acc.wrapping_mul(31).wrapping_add(byte as usize)); + let hash: usize = content.as_bytes().iter().fold(0usize, |acc, &byte| { + acc.wrapping_mul(31).wrapping_add(byte as usize) + }); let provers = black_box(ProverKind::all()); let selected = provers[hash % provers.len()]; black_box(selected) @@ -239,9 +238,7 @@ fn bench_agentic_config_throughput(c: &mut Criterion) { // Benchmark: clone from existing config. let base_config = AgentConfig::default(); group.bench_function("agent_config_clone", |b| { - b.iter(|| { - black_box(base_config.clone()) - }) + b.iter(|| black_box(base_config.clone())) }); // Benchmark: JSON serialisation (used for config logging and audit). diff --git a/models/premise_vocab.txt b/models/premise_vocab.txt index e69de29..984c63e 100644 --- a/models/premise_vocab.txt +++ b/models/premise_vocab.txt @@ -0,0 +1,60046 @@ +0 +0.999... +00id +00lsp +00lss +00ply1bas +00sr +01eq0ring +01eq0ringold +01sqrex +01sqrexlem1 +01sqrexlem2 +01sqrexlem3 +01sqrexlem4 +01sqrexlem5 +01sqrexlem6 +01sqrexlem7 +0aryfvalel +0aryfvalelfv +0bdop +0bits +0blo +0cat +0catg +0cld +0clwlk +0clwlk0 +0clwlkv +0cmp +0cn +0cnalt +0cnalt2 +0cnalt3 +0cnd +0cnf +0cnfn +0cnop +0cnv +0conngr +0crct +0csh0 +0cxp +0cxpd +0cycl +0cyg +0dgr +0dgrb +0dif +0dig1 +0dig2nn0e +0dig2nn0o +0dig2pr01 +0dioph +0disj +0dom +0domg +0dp2dp +0dvds +0dvds0 +0e0iccpnf +0e0icopnf +0edg0rgr +0el +0elaxnul +0elcarsg +0elcpmat +0elfz +0elixp +0elleft +0ellim +0ellimcdiv +0ellsp +0elold +0elon +0elpw +0elright +0elros +0elsiga +0elsros +0elsuc +0elunit +0enwwlksnge1 +0er +0even +0evenaltv +0ewlk +0ex +0exp +0exp0e1 +0expd +0fallfac +0fi +0finon +0fno +0frgp +0fsupp +0fucterm +0func +0funcalt +0funcg +0funcg2 +0funcglem +0funclem +0fv +0fz1 +0g0 +0ghm +0grrgr +0grrusgr +0grsubgr +0hashbc +0he +0healt +0hf +0hmop +0idl +0idnsgd +0idsr +0iin +0ima +0in +0inp0 +0iscard +0iun +0le0 +0le1 +0le2 +0leop +0leopj +0lepnf +0lmhm +0lnfn +0lno +0lnop +0lt1 +0lt1o +0lt1s +0lt1sr +0ltat +0ltpnf +0m0e0 +0map0sn0 +0mat2pmat +0mbl +0met +0mgm +0mhm +0mnnnnn0 +0mod +0mpo0 +0n0s +0ncn +0ne1 +0ne2 +0nei +0nelelxp +0nelfb +0nelfil +0nelfun +0nelfz1 +0nellinds +0nelop +0nelopab +0nelrel +0nelrel0 +0nelsetpreimafv +0nelxp +0nep0 +0nghm +0ngrp +0nmhm +0nn0 +0nn0m1nnn0 +0nnei +0nnn +0nnnalt +0nnq +0no +0nodd +0noddaltv +0nonelalab +0npi +0npr +0nprm +0nrp +0nsg +0nsr +0ntop +0ntr +0ofval +0ome +0ons +0oo +0opn +0ov +0oval +0p1e1 +0pledm +0plef +0pos +0prjspn +0prjspnlem +0prjspnrel +0pss +0pssin +0psubcln +0psubn +0pth +0pthon +0pthon1 +0pthonv +0pval +0pwfi +0qs +0r +0ram +0ram2 +0ramcl +0re +0realt +0red +0reno +0res +0rest +0ring +0ring01eq +0ring01eqbi +0ring1eq0 +0ringbas +0ringcring +0ringdif +0ringidl +0ringirng +0ringmon1p +0ringnnzr +0ringprmidl +0ringsubrg +0risefac +0rngo +0rrv +0sal +0sald +0sdom +0sdom1dom +0sdom1domalt +0sdomg +0setrec +0sgm +0sgmppw +0sn0ep +0spth +0ss +0ssc +0subcat +0subg +0subgalt +0subm +0symgefmndeq +0thinc +0thincg +0tie0 +0top +0totbnd +0trl +0trlon +0trrel +0tsk +0uhgrrusgr +0uhgrsubgr +0un +0unit +0vconngr +0vfval +0vtxrgr +0vtxrusgr +0wdom +0we1 +0wlk +0wlk0 +0wlkon +0wlkonlem1 +0wlkonlem2 +0wlkons1 +0wrd0 +0xnn0 +0xp +0xr +0z +0zd +0zs +1 +10m1e9 +10nn +10nn0 +10nprm +10p10e20 +10pos +10re +11gbo +11multnc +11prm +11t31e341 +1259lem1 +1259lem2 +1259lem3 +1259lem4 +1259lem5 +1259prm +127prm +12gcd5e1 +12lcm5e60 +139prm +139prmalt +13an22anass +13prm +163prm +17prm +19.12 +19.12b +19.12vv +19.12vvv +19.16 +19.17 +19.19 +19.2 +19.21 +19.21-2 +19.21a3con13vvd +19.21bbi +19.21bi +19.21h +19.21t +19.21v +19.21vv +19.23 +19.23bi +19.23h +19.23t +19.23v +19.23vv +19.24 +19.25 +19.26 +19.26-2 +19.26-3an +19.27 +19.27v +19.28 +19.28v +19.28vv +19.29 +19.29r +19.29r2 +19.29x +19.2d +19.2g +19.3 +19.30 +19.31 +19.31v +19.31vv +19.32 +19.32v +19.33 +19.33-2 +19.33b +19.34 +19.35 +19.35i +19.35ri +19.36 +19.36i +19.36imv +19.36iv +19.36v +19.36vv +19.37 +19.37imv +19.37iv +19.37v +19.37vv +19.38 +19.38a +19.38b +19.39 +19.3t +19.3v +19.40 +19.40-2 +19.40b +19.41 +19.41rg +19.41rgvd +19.41v +19.41vv +19.41vvv +19.41vvvv +19.42 +19.42v +19.42vv +19.42vvv +19.43 +19.43old +19.44 +19.44v +19.45 +19.45v +19.8a +19.8ad +19.8aw +19.8v +19.8w +19.9 +19.9d +19.9d2r +19.9d2rf +19.9dev +19.9h +19.9ht +19.9t +19.9v +19prm +1arith +1arith2 +1arithidom +1arithidomlem1 +1arithidomlem2 +1arithlem1 +1arithlem2 +1arithlem3 +1arithlem4 +1arithufd +1arithufdlem1 +1arithufdlem2 +1arithufdlem3 +1arithufdlem4 +1aryenef +1aryenefmnd +1aryfvalel +1arymaptf +1arymaptf1 +1arymaptf1o +1arymaptfo +1arymaptfv +1arympt1 +1arympt1fv +1cnd +1conngr +1cosscnvepresex +1cosscnvxrn +1cossres +1cossxrncnvepresex +1cshid +1cubr +1cubrlem +1cvrat +1cvratex +1cvratlt +1cvrco +1cvrjat +1cxp +1cxpd +1dimn +1div0 +1div0apr +1div0old +1div1e1 +1dvds +1e0p1 +1e2m1 +1egrvtxdg0 +1egrvtxdg1 +1egrvtxdg1r +1elcpmat +1elfz0hash +1elfzo1 +1elfzo1ceilhalf1 +1ellim +1elunit +1eluzge0 +1ewlk +1ex +1exp +1finon +1fldgenq +1fno +1fpid3 +1fv +1fzopredsuc +1gcd +1hegrlfgr +1hegrvtxdg1 +1hegrvtxdg1r +1hevtxdg0 +1hevtxdg1 +1idl +1idpr +1idsr +1idssfct +1iscard +1kp2ke3k +1le1 +1le2 +1le3 +1lgs +1loopgredg +1loopgrnb0 +1loopgruspgr +1loopgrvd0 +1loopgrvd2 +1lt10 +1lt2 +1lt2nq +1lt2pi +1lt3 +1lt4 +1lt5 +1lt6 +1lt7 +1lt8 +1lt9 +1m0e1 +1m1e0 +1marepvmarrepid +1marepvsma1 +1mavmul +1mhdrd +1mhlfehlf +1mod +1n0 +1n0s +1ne0s +1ne0sr +1ne2 +1neg1t1neg1 +1nei +1neven +1nevenaltv +1nn +1nn0 +1nns +1no +1nprm +1nq +1nqenq +1nsgtrivd +1nuz2 +1oaomeqom +1odd +1oddaltv +1oequni2o +1oex +1on +1one2o +1onn +1onnalt +1ons +1p0e1 +1p1e2 +1p1e2apr1 +1p1e2s +1p1times +1p2e3 +1p2e3alt +1p3e4 +1pi +1pmatscmul +1pneg1e0 +1pr +1psubcln +1pthd +1pthdlem1 +1pthdlem2 +1pthon2v +1pthon2ve +1pthond +1re +1red +1reno +1rinv +1rp +1rrg +1sdom +1sdom2 +1sdom2alt +1sdom2dom +1sgm2ppw +1sgmprm +1smat1 +1sr +1st0 +1st2nd +1st2nd2 +1st2ndb +1st2ndbr +1st2ndprf +1st2val +1stcclb +1stccn +1stccnp +1stcelcls +1stcfb +1stckgen +1stckgenlem +1stcof +1stconst +1stcrest +1stcrestlem +1stctop +1stdm +1stf1 +1stf2 +1stfcl +1stfpropd +1stfval +1stinl +1stinr +1stmbfm +1stnpr +1stpreima +1stpreimas +1strbas +1strstr +1strwun +1strwunbndx +1stval +1stval2 +1subrec1sub +1t10e1p1e11 +1t1e1 +1t1e1alt +1tiei +1to2vfriswmgr +1to3vfriendship +1to3vfriswmgr +1trld +1unit +1vgrex +1vwmgr +1wlkd +1wlkdlem1 +1wlkdlem2 +1wlkdlem3 +1wlkdlem4 +1xr +1z +1zs +1zzd +2 +2025 +2026 +235t711 +23prm +2503lem1 +2503lem2 +2503lem3 +2503prm +257prm +2a1 +2a1d +2a1dd +2a1i +2addsub +2addsubd +2al2imi +2alanimi +2albi +2albidv +2albii +2albiim +2alim +2alimdv +2alimi +2ap1caineq +2arwcat +2arwcatlem1 +2arwcatlem2 +2arwcatlem3 +2arwcatlem4 +2arwcatlem5 +2aryenef +2aryfvalel +2arymaptf +2arymaptf1 +2arymaptf1o +2arymaptfo +2arymaptfv +2arympt +2arymptfv +2at0mat0 +2atjlej +2atjm +2atlt +2atm +2atm2atn +2atmat +2atmat0 +2atneat +2atnelpln +2atnelvoln +2ax5 +2ax6e +2ax6elem +2basgen +2bornot2b +2clim +2clwwlk +2clwwlk2 +2clwwlk2clwwlk +2clwwlk2clwwlklem +2clwwlkel +2clwwlklem +2cn +2cnalt +2cnd +2cnne0 +2cprodeq2dv +2cshw +2cshwcom +2cshwcshw +2cshwid +2cycl2d +2cycld +2dim +2div2e1 +2dom +2domtsk +2dvdseven +2dvdsoddm1 +2dvdsoddp1 +2ebits +2ecoptocl +2efiatan +2elfz2melfz +2elfz3nn0 +2ellim +2elresin +2eluzge0 +2eluzge1 +2eu1 +2eu1v +2eu2 +2eu2ex +2eu3 +2eu4 +2eu5 +2eu6 +2eu7 +2eu8 +2euex +2euexv +2eumo +2euswap +2euswapv +2even +2evenaltv +2ex +2ex2rexrot +2exanali +2exbi +2exbidv +2exbii +2exeu +2exeuv +2exim +2eximdv +2eximi +2exnaln +2exnexn +2exopprim +2exp11 +2exp16 +2exp340mod341 +2exp4 +2exp5 +2exp6 +2exp7 +2exp8 +2exple2exp +2expltfac +2exsb +2f1fvneq +2false +2falsed +2fcoidinvd +2ffzeq +2ffzoeq +2finon +2fno +2fvcoidd +2fveq3 +2fvidf1od +2fvidinvd +2gencl +2goelgoanfmla1 +2halves +2halvesd +2idl0 +2idl1 +2idlbas +2idlcpbl +2idlcpblrng +2idlelb +2idlelbas +2idllidld +2idlridld +2idlss +2idlval +2if2 +2initoinv +2irrexpq +2irrexpqalt +2itscp +2itscplem1 +2itscplem2 +2itscplem3 +2iunin +2leaddle2 +2lgs +2lgs2 +2lgslem1 +2lgslem1a +2lgslem1a1 +2lgslem1a2 +2lgslem1b +2lgslem1c +2lgslem2 +2lgslem3 +2lgslem3a +2lgslem3a1 +2lgslem3b +2lgslem3b1 +2lgslem3c +2lgslem3c1 +2lgslem3d +2lgslem3d1 +2lgslem4 +2lgsoddprm +2lgsoddprmlem1 +2lgsoddprmlem2 +2lgsoddprmlem3 +2lgsoddprmlem3a +2lgsoddprmlem3b +2lgsoddprmlem3c +2lgsoddprmlem3d +2lgsoddprmlem4 +2llnjan +2llnjn +2llnm2n +2llnm3n +2llnm4 +2llnma1 +2llnma1b +2llnma2 +2llnma2rn +2llnma3r +2llnmat +2llnmeqat +2llnmj +2llnne2n +2llnnen +2lnat +2logb3irr +2logb9irr +2logb9irralt +2lplnj +2lplnja +2lplnm2n +2lplnmj +2lplnmn +2lt10 +2lt3 +2lt4 +2lt5 +2lt6 +2lt7 +2lt8 +2lt9 +2ltceilhalf +2m1e1 +2mo +2mo2 +2moex +2moexv +2mos +2mosold +2moswap +2moswapv +2mpo0 +2mulicn +2muline0 +2mulprm +2nalexn +2nd0 +2nd1st +2nd2val +2ndc1stc +2ndcctbss +2ndcdisj +2ndcdisj2 +2ndci +2ndcof +2ndcomap +2ndconst +2ndcredom +2ndcrest +2ndcsb +2ndcsep +2ndctop +2ndf1 +2ndf2 +2ndfcl +2ndfpropd +2ndfval +2ndimaxp +2ndinl +2ndinr +2ndmbfm +2ndnpr +2ndpreima +2ndresdju +2ndresdjuf1o +2ndrn +2ndval +2ndval2 +2ndvdsodd +2ne0 +2ne0s +2nexaln +2nn +2nn0 +2nn0ind +2nns +2no +2nodd +2noddaltv +2np3bcnp1 +2nreu +2nsgsimpgd +2oconcl +2oex +2omomeqom +2on +2on0 +2onn +2onnalt +2oppcbas +2oppccomf +2oppchomf +2oppf +2oppffunc +2optocl +2p1e3 +2p2e4 +2p2ne5 +2pm13.193 +2pm13.193vd +2pmaplubn +2pol0n +2polatn +2polcon4bn +2polpmapn +2polssn +2polvaln +2pos +2prm +2pthd +2pthdlem1 +2pthfrgr +2pthfrgrrn +2pthfrgrrn2 +2pthnloop +2pthon3v +2pthond +2pwne +2pwp1prm +2pwp1prmfmtno +2pwuninel +2r19.29 +2ralbida +2ralbidv +2ralbidva +2ralbii +2ralbiim +2ralimi +2ralor +2ralsng +2ralunsn +2rbropap +2re +2rene0 +2resupmax +2reu1 +2reu2 +2reu2reu2 +2reu2rex +2reu2rex1 +2reu3 +2reu4 +2reu4lem +2reu5 +2reu5a +2reu5lem1 +2reu5lem2 +2reu5lem3 +2reu7 +2reu8 +2reu8i +2reucom +2reuimp +2reuimp0 +2reureurex +2reurex +2reurmo +2reuswap +2reuswap2 +2rexbidv +2rexbidva +2rexbii +2rexbiia +2rexfrabdioph +2rexreu +2rexrsb +2rexsb +2rexuz +2rmorex +2rmoswap +2rp +2rspcedvdw +2sb5 +2sb5nd +2sb5ndalt +2sb5ndvd +2sb5rf +2sb6 +2sb6rf +2sb8e +2sb8ef +2sbbid +2sbbii +2sbc5g +2sbc6g +2sbcrex +2sbcrexold +2sbiev +2sbievw +2shfti +2sp +2sphere +2sphere0 +2spthd +2sq +2sq2 +2sqb +2sqblem +2sqcoprm +2sqlem1 +2sqlem10 +2sqlem11 +2sqlem2 +2sqlem3 +2sqlem4 +2sqlem5 +2sqlem6 +2sqlem7 +2sqlem8 +2sqlem8a +2sqlem9 +2sqmo +2sqmod +2sqn0 +2sqnn +2sqnn0 +2sqr3minply +2sqr3nconstr +2sqreu +2sqreulem1 +2sqreulem2 +2sqreulem3 +2sqreulem4 +2sqreult +2sqreultb +2sqreultblem +2sqreultlem +2sqreunn +2sqreunnlem1 +2sqreunnlem2 +2sqreunnlt +2sqreunnltb +2sqreunnltblem +2sqreunnltlem +2sqreuop +2sqreuopb +2sqreuoplt +2sqreuopltb +2sqreuopnn +2sqreuopnnlt +2sqreuopnnltb +2stdpc4 +2stdpc5 +2strbas +2strop +2strstr +2submod +2sumeq2dv +2swrd2eqwrdeq +2t0e0 +2t1e2 +2t2e4 +2t6m3t4e0 +2tceilhalfelfzo1 +2termoinv +2teven +2th +2thalt +2thd +2times +2timesd +2timesgt +2timesi +2tnp1ge0ge0 +2tp1odd +2trld +2trlond +2txmodxeq0 +2txmxeqx +2uasban +2uasbanh +2uasbanhvd +2vmadivsum +2vmadivsumlem +2wlkd +2wlkdlem1 +2wlkdlem10 +2wlkdlem2 +2wlkdlem3 +2wlkdlem4 +2wlkdlem5 +2wlkdlem6 +2wlkdlem7 +2wlkdlem8 +2wlkdlem9 +2wlklem +2wlkond +2wspdisj +2wspiundisj +2wspmdisj +2z +2zlidl +2zrng +2zrng0 +2zrngaabl +2zrngacmnd +2zrngadd +2zrngagrp +2zrngalt +2zrngamgm +2zrngamnd +2zrngasgrp +2zrngbas +2zrngmmgm +2zrngmsgrp +2zrngmul +2zrngnmlid +2zrngnmlid2 +2zrngnmrid +2zrngnring +3 +317prm +31prm +341fppr2 +37prm +3ad2ant1 +3ad2ant2 +3ad2ant3 +3ad2antl1 +3ad2antl2 +3ad2antl3 +3ad2antr1 +3ad2antr2 +3ad2antr3 +3adant1 +3adant1l +3adant1r +3adant2 +3adant2l +3adant2r +3adant3 +3adant3l +3adant3r +3adant3r1 +3adant3r2 +3adant3r3 +3adantl1 +3adantl2 +3adantl3 +3adantll2 +3adantll3 +3adantlr3 +3adantr1 +3adantr2 +3adantr3 +3albii +3an1rs +3an4anass +3an4ancom24 +3an6 +3anan12 +3anan32 +3anandirs +3anandis +3anass +3anassrs +3anbi123d +3anbi123i +3anbi12d +3anbi13d +3anbi1d +3anbi1i +3anbi23d +3anbi2d +3anbi2i +3anbi3d +3anbi3i +3ancoma +3ancomb +3anibar +3anidm +3anidm12 +3anidm12p1 +3anidm12p2 +3anidm13 +3anidm23 +3anim123d +3anim123i +3anim1i +3anim2i +3anim3i +3anor +3anrabdioph +3anrev +3anrot +3at +3atlem1 +3atlem2 +3atlem3 +3atlem4 +3atlem5 +3atlem6 +3atlem7 +3atnelvoln +3biant1d +3bior1fand +3bior1fd +3bior2fd +3bitr2d +3bitr2i +3bitr2rd +3bitr2ri +3bitr3d +3bitr3g +3bitr3i +3bitr3rd +3bitr3ri +3bitr4d +3bitr4g +3bitr4i +3bitr4rd +3bitr4ri +3bitrd +3bitri +3bitrrd +3bitrri +3brtr3d +3brtr3g +3brtr3i +3brtr4d +3brtr4g +3brtr4i +3ccased +3cn +3com12 +3com12d +3com13 +3com23 +3coml +3comr +3cshw +3cubes +3cubeslem1 +3cubeslem2 +3cubeslem3 +3cubeslem3l +3cubeslem3r +3cubeslem4 +3cycld +3cyclfrgr +3cyclfrgrrn +3cyclfrgrrn1 +3cyclfrgrrn2 +3cyclpd +3dec +3decltc +3declth +3dim0 +3dim1 +3dim1lem5 +3dim2 +3dim3 +3dimlem1 +3dimlem2 +3dimlem3 +3dimlem3a +3dimlem3oldn +3dimlem4 +3dimlem4a +3dimlem4oldn +3dvds +3dvds2dec +3dvdsdec +3ecase +3ecoptocl +3elpr2eq +3eltr3d +3eltr3g +3eltr3i +3eltr4d +3eltr4g +3eltr4i +3eqtr2d +3eqtr2i +3eqtr2rd +3eqtr2ri +3eqtr3a +3eqtr3d +3eqtr3g +3eqtr3i +3eqtr3rd +3eqtr3ri +3eqtr4a +3eqtr4d +3eqtr4g +3eqtr4i +3eqtr4rd +3eqtr4ri +3eqtrd +3eqtri +3eqtrrd +3eqtrri +3ex +3exbidv +3exbii +3exdistr +3exp +3exp1 +3exp2 +3exp3 +3exp4mod41 +3exp7 +3expa +3expb +3expd +3expia +3expib +3f1oss1 +3f1oss2 +3factsumint +3factsumint1 +3factsumint2 +3factsumint3 +3factsumint4 +3finon +3fno +3gencl +3halfnz +3ianor +3imp +3imp1 +3imp2 +3imp21 +3imp231 +3imp31 +3imp3i2an +3impa +3impb +3impcombi +3impd +3impdi +3impdir +3impdirp1 +3impexp +3impexpbicom +3impexpbicomi +3impexpbicomivd +3impexpbicomvd +3impexpvd +3impia +3impib +3imtr3d +3imtr3g +3imtr3i +3imtr4d +3imtr4g +3imtr4i +3ioran +3jaao +3jao +3jaob +3jaobold +3jaod +3jaodan +3jaodd +3jaoi +3jaoian +3jca +3jcad +3jcadalt +3lcm2e6 +3lcm2e6woprm +3lexlogpow2ineq1 +3lexlogpow2ineq2 +3lexlogpow5ineq1 +3lexlogpow5ineq2 +3lexlogpow5ineq3 +3lexlogpow5ineq4 +3lexlogpow5ineq5 +3lt10 +3lt4 +3lt5 +3lt6 +3lt7 +3lt8 +3lt9 +3m1e2 +3mix1 +3mix1d +3mix1i +3mix2 +3mix2d +3mix2i +3mix3 +3mix3d +3mix3i +3ndvds4 +3ne0 +3netr3d +3netr3g +3netr4d +3netr4g +3nn +3nn0 +3noncolr1n +3noncolr2 +3o1cs +3o2cs +3o3cs +3oai +3oalem1 +3oalem2 +3oalem3 +3oalem4 +3oalem5 +3oalem6 +3odd +3on +3onn +3optocl +3or6 +3oran +3orass +3orbi123 +3orbi123d +3orbi123i +3orbi123vd +3orcoma +3orcomb +3orel1 +3orel13 +3orel2 +3orel2old +3orel3 +3ori +3orim123d +3orit +3ornot23 +3ornot23vd +3orrabdioph +3orrot +3p1e4 +3p2e5 +3p3e6 +3pm3.2i +3pm3.2ni +3poln +3pos +3prm +3pthd +3pthdlem1 +3pthond +3r19.43 +3ralbidv +3ralbii +3ralimi +3rdpwhole +3re +3reeanv +3rexfrabdioph +3rp +3rspcedvd +3rspcedvdw +3simpa +3simpb +3simpc +3spthd +3spthond +3sstr3d +3sstr3g +3sstr3i +3sstr4d +3sstr4g +3sstr4i +3syl +3syld +3t1e3 +3t2e6 +3t3e9 +3trld +3trlond +3unrab +3vfriswmgr +3vfriswmgrlem +3wlkd +3wlkdlem1 +3wlkdlem10 +3wlkdlem2 +3wlkdlem3 +3wlkdlem4 +3wlkdlem5 +3wlkdlem6 +3wlkdlem7 +3wlkdlem8 +3wlkdlem9 +3wlkond +3xpexg +3xpfi +3z +4 +4001lem1 +4001lem2 +4001lem3 +4001lem4 +4001prm +41prothprm +41prothprmlem1 +41prothprmlem2 +420gcd8e4 +420lcm8e840 +43prm +4an21 +4an31 +4an4132 +4animp1 +4anpull2 +4at +4at2 +4atex +4atex2 +4atex2-0aoldn +4atex2-0boldn +4atex2-0coldn +4atex3 +4atexlem7 +4atexlemc +4atexlemcnd +4atexlemex2 +4atexlemex4 +4atexlemex6 +4atexlemk +4atexlemkc +4atexlemkl +4atexlemnclw +4atexlemnslpq +4atexlemntlpq +4atexlemp +4atexlempnq +4atexlempns +4atexlempsb +4atexlempw +4atexlemq +4atexlemqtb +4atexlems +4atexlemswapqr +4atexlemt +4atexlemtlw +4atexlemu +4atexlemunv +4atexlemutvt +4atexlemv +4atexlemw +4atexlemwb +4atlem0a +4atlem0ae +4atlem0be +4atlem10 +4atlem10a +4atlem10b +4atlem11 +4atlem11a +4atlem11b +4atlem12 +4atlem12a +4atlem12b +4atlem3 +4atlem3a +4atlem3b +4atlem4a +4atlem4b +4atlem4c +4atlem4d +4atlem9 +4bc2eq6 +4bc3eq4 +4cases +4casesdan +4cn +4cphipval2 +4cycl2v2nb +4cycl2vnunb +4cyclusnfrgr +4div2e2 +4dvdseven +4even +4exbidv +4exdistr +4exdistrv +4exmid +4finon +4fno +4fppr1 +4fvwrd4 +4ipval2 +4lt10 +4lt5 +4lt6 +4lt7 +4lt8 +4lt9 +4m1e3 +4ne0 +4nn +4nn0 +4noncolr1 +4noncolr2 +4noncolr3 +4nprm +4on +4onn +4p1e5 +4p2e6 +4p3e7 +4p4e8 +4pos +4ralbidv +4ralbii +4ralimi +4re +4rexfrabdioph +4rp +4sq +4sqlem1 +4sqlem10 +4sqlem11 +4sqlem12 +4sqlem13 +4sqlem14 +4sqlem15 +4sqlem16 +4sqlem17 +4sqlem18 +4sqlem19 +4sqlem2 +4sqlem3 +4sqlem4 +4sqlem4a +4sqlem5 +4sqlem6 +4sqlem7 +4sqlem8 +4sqlem9 +4syl +4t2e8 +4t3e12 +4t3lem +4t4e16 +4t5e20 +4z +5 +5bc2eq10 +5cn +5eluz3 +5lt10 +5lt6 +5lt7 +5lt8 +5lt9 +5m1e4 +5m4e1 +5ndvds3 +5ndvds6 +5ne0 +5nn +5nn0 +5oai +5oalem1 +5oalem2 +5oalem3 +5oalem4 +5oalem5 +5oalem6 +5oalem7 +5odd +5p1e6 +5p2e7 +5p3e8 +5p4e9 +5p5e10 +5pos +5prm +5ralimi +5re +5recm6rec +5rp +5segofs +5t2e10 +5t3e15 +5t4e20 +5t5e25 +5tcu2e40 +60gcd6e6 +60gcd7e1 +60lcm6e60 +60lcm7e420 +631prm +65537prm +6cn +6even +6gbe +6gcd4e2 +6lcm4e12 +6lt10 +6lt7 +6lt8 +6lt9 +6m1e5 +6ne0 +6nn +6nn0 +6nprm +6p1e7 +6p2e8 +6p3e9 +6p4e10 +6p5e11 +6p5lem +6p6e12 +6pos +6ralbidv +6ralimi +6re +6rexfrabdioph +6rp +6t2e12 +6t3e18 +6t4e24 +6t5e30 +6t6e36 +7cn +7gbow +7lt10 +7lt8 +7lt9 +7m1e6 +7ne0 +7nn +7nn0 +7odd +7p1e8 +7p2e9 +7p3e10 +7p4e11 +7p5e12 +7p6e13 +7p7e14 +7pos +7prm +7re +7rexfrabdioph +7rp +7t2e14 +7t3e21 +7t4e28 +7t5e35 +7t6e42 +7t7e49 +83prm +8cn +8even +8exp8mod9 +8gbe +8lt10 +8lt9 +8m1e7 +8mod5e3 +8ne0 +8nn +8nn0 +8nprm +8p1e9 +8p2e10 +8p3e11 +8p4e12 +8p5e13 +8p6e14 +8p7e15 +8p8e16 +8pos +8re +8rp +8t2e16 +8t3e24 +8t4e32 +8t5e40 +8t6e48 +8t7e56 +8t8e64 +8th4div3 +9cn +9fppr8 +9gbo +9lt10 +9m1e8 +9ne0 +9nn +9nn0 +9nprm +9p10ne21 +9p10ne21fool +9p1e10 +9p2e11 +9p3e12 +9p4e13 +9p5e14 +9p6e15 +9p7e16 +9p8e17 +9p9e18 +9pos +9re +9rp +9t11e99 +9t2e18 +9t3e27 +9t4e36 +9t5e45 +9t6e54 +9t7e63 +9t8e72 +9t9e81 +<-mod-expt-2-crock +<=-antisymmetric +<=-reflexive +<=-transitive +__spec +_concat +a +a1bi +a1d +a1dd +a1ddd +a1i +a1i13 +a1i14 +a1i24 +a1ii +a2and +a2d +a2i +a_spec +aaan +aaanv +aacjcl +aacllem +aacn +aaitgo +aaliou +aaliou2 +aaliou2b +aaliou3 +aaliou3lem1 +aaliou3lem2 +aaliou3lem3 +aaliou3lem4 +aaliou3lem5 +aaliou3lem6 +aaliou3lem7 +aaliou3lem8 +aaliou3lem9 +aalioulem1 +aalioulem2 +aalioulem3 +aalioulem4 +aalioulem5 +aalioulem6 +aannen +aannenlem1 +aannenlem2 +aannenlem3 +aareccl +aasscn +ab +ab0 +ab0alt +ab0orv +ab0orvalt +ab0w +ab2rexex +ab2rexex2 +abai +abanssl +abanssr +abbi +abbi1sn +abbib +abbibw +abbid +abbidv +abbii +abbrev_tac +abcdta +abcdtb +abcdtc +abcdtd +abciffcbatnabciffncba +abciffcbatnabciffncbai +abelth +abelth2 +abelthlem1 +abelthlem2 +abelthlem3 +abelthlem4 +abelthlem5 +abelthlem6 +abelthlem7 +abelthlem7a +abelthlem8 +abelthlem9 +abeqabi +abeqin +abeqinbi +abex +abexd +abexex +abexssex +abf +abfmpel +abfmpeld +abfmpunirn +abid +abid1 +abid2 +abid2f +abid2fold +abidnf +abl1 +abl32 +abladdsub +abladdsub4 +ablcmn +ablcmnd +ablcntzd +ablcom +ablcomd +ablfac +ablfac1a +ablfac1b +ablfac1c +ablfac1eu +ablfac1eulem +ablfac1lem +ablfac2 +ablfaclem1 +ablfaclem2 +ablfaclem3 +ablfacrp +ablfacrp2 +ablfacrplem +ablgrp +ablgrpd +ablinvadd +abliso +abln0 +ablnncan +ablnnncan +ablnnncan1 +ablnsg +ablo32 +ablo4 +ablo4pnp +ablocom +ablodiv32 +ablodivdiv +ablodivdiv4 +ablogrpo +ablomuldiv +ablonncan +ablonnncan1 +ablpncan2 +ablpncan3 +ablpnpcan +ablprop +ablpropd +ablsimpg1gend +ablsimpgcygd +ablsimpgd +ablsimpgfind +ablsimpgfindlem1 +ablsimpgfindlem2 +ablsimpgprmd +ablsimpnosubgd +ablsub2inv +ablsub32 +ablsub4 +ablsubadd +ablsubadd23 +ablsubaddsub +ablsubsub +ablsubsub23 +ablsubsub4 +abn0 +abnex +abnexg +abnotataxb +abnotbtaxb +abpr +abrexco +abrexct +abrexctf +abrexdom +abrexdom2 +abrexdom2jm +abrexdomjm +abrexex +abrexex2 +abrexex2g +abrexexd +abrexexg +abrexfi +abrexss +abs-tp +abs0 +abs00 +abs00ad +abs00bd +abs00d +abs00i +abs0s +abs1 +abs1m +abs2dif +abs2dif2 +abs2dif2d +abs2difabs +abs2difabsd +abs2difabsi +abs2difd +abs2difi +abs2sqle +abs2sqlei +abs2sqlt +abs2sqlti +abs3dif +abs3difd +abs3difi +abs3lem +abs3lemd +abs3lemi +abs_0 +abs_add_pos +abs_between +abs_between1 +abs_between2 +abs_bound +abs_bounding_le +abs_bounding_lt +abs_bounds +abs_bounds_lt +abs_bounds_min_max +abs_cases +abs_circle +abs_conv +abs_diff +abs_diff_0 +abs_diff_add_same +abs_diff_commute +abs_diff_eq_0 +abs_diff_le_sum +abs_diff_plus_le +abs_diff_suc +abs_diff_suc_le +abs_diff_sum_image +abs_diff_sums +abs_diff_sym +abs_diff_symmetric +abs_diff_triangle +abs_diff_triangle_lem +abs_dist +abs_dist_other +abs_div +abs_drop +abs_eq_0 +abs_eq_neg +abs_ge +abs_gt +abs_inv +abs_le +abs_lt +abs_lt_mul2 +abs_lt_representation +abs_mono_dec +abs_mono_inc +abs_mul +abs_mult +abs_nat +abs_neg +abs_nnreal +abs_nonneg +abs_not_zero +abs_nz +abs_pos +abs_reduce +abs_root +abs_sign +abs_sign2 +abs_sq +abs_stillnz +abs_sub +abs_sub_abs +abs_sum +abs_tac +abs_triang +abs_triangle +abs_triangle_lt +abs_triangle_sub +abs_zero +absabv +abscj +abscjd +abscji +abscl +abscld +abscli +abscn +abscn2 +abscncf +abscncfalt +abscosbd +abscvgcvg +abscxp +abscxp2 +abscxpbnd +absdifle +absdifled +absdiflt +absdifltd +absdiv +absdivd +absdivzi +absdvdsabsb +absdvdsb +absef +absefi +absefib +absex +absexp +absexpd +absexpz +absf +absfico +absfun +absge0 +absge0d +absge0i +absgt0 +absgt0i +abshicom +absi +absid +absidd +absidi +absidm +absimle +absimlere +absimnre +absle +absled +abslei +abslem2 +abslogimle +abslogle +abslt +abslt2sqd +absltd +abslti +abslts +absmax +absmod0 +absmul +absmuld +absmulgcd +absmuli +absmulrposd +absmuls +absn +absne0d +absneg +absnegd +absnegi +absnegs +absneu +absnid +absnidd +absnidi +absnonneg +absnpncan2d +absnpncan3d +absnsb +absnw +absolute_integral_norm_derivative_le_variation +absolute_integral_norm_derivative_le_variation_alt +absolute_integral_substitution +absolute_integration_by_parts +absolute_integration_by_parts_sum +absolute_miller_rabin_pseudoprime +absolutely_continuous_comparison +absolutely_continuous_differentiable_bv +absolutely_continuous_differentiable_bv_gen +absolutely_continuous_extends_to_closure +absolutely_continuous_indefinite_integral_eq +absolutely_continuous_indefinite_integral_left +absolutely_continuous_indefinite_integral_right +absolutely_continuous_integral +absolutely_continuous_isometric +absolutely_continuous_isometric_compose +absolutely_continuous_lipschitz_compose +absolutely_continuous_measure_differentiable_image +absolutely_continuous_measure_image +absolutely_continuous_on_add +absolutely_continuous_on_bilinear +absolutely_continuous_on_closure +absolutely_continuous_on_closure_eq +absolutely_continuous_on_cmul +absolutely_continuous_on_cmul_eq +absolutely_continuous_on_combine +absolutely_continuous_on_componentwise +absolutely_continuous_on_compose +absolutely_continuous_on_compose_linear +absolutely_continuous_on_const +absolutely_continuous_on_division +absolutely_continuous_on_empty +absolutely_continuous_on_eq +absolutely_continuous_on_id +absolutely_continuous_on_imp_continuous +absolutely_continuous_on_imp_uniformly_continuous +absolutely_continuous_on_interior +absolutely_continuous_on_interior_eq +absolutely_continuous_on_lift_abs +absolutely_continuous_on_lift_component +absolutely_continuous_on_max +absolutely_continuous_on_min +absolutely_continuous_on_mul +absolutely_continuous_on_neg +absolutely_continuous_on_norm +absolutely_continuous_on_null +absolutely_continuous_on_sing +absolutely_continuous_on_sub +absolutely_continuous_on_subset +absolutely_continuous_on_translation +absolutely_continuous_on_vmul +absolutely_continuous_on_vmul_eq +absolutely_continuous_on_vsum +absolutely_continuous_vector_variation +absolutely_integrable_0 +absolutely_integrable_abs +absolutely_integrable_abs_1 +absolutely_integrable_abs_eq +absolutely_integrable_absolutely_integrable_bound +absolutely_integrable_add +absolutely_integrable_affinity +absolutely_integrable_approximate_continuous +absolutely_integrable_bounded_measurable_product +absolutely_integrable_bounded_setvariation +absolutely_integrable_bounded_setvariation_eq +absolutely_integrable_bounded_setvariation_univ_eq +absolutely_integrable_bounded_variation_derivative +absolutely_integrable_bounded_variation_eq +absolutely_integrable_change_of_variables +absolutely_integrable_change_of_variables_1 +absolutely_integrable_change_of_variables_linear +absolutely_integrable_cmul +absolutely_integrable_cmul_eq +absolutely_integrable_combine +absolutely_integrable_componentwise +absolutely_integrable_const +absolutely_integrable_continuous +absolutely_integrable_convolution_l1_linf +absolutely_integrable_convolution_l2 +absolutely_integrable_convolution_linf_l1 +absolutely_integrable_convolution_sym +absolutely_integrable_diff +absolutely_integrable_eq +absolutely_integrable_eq_integrable_pos +absolutely_integrable_imp_integrable +absolutely_integrable_imp_lift_norm_integrable +absolutely_integrable_improper +absolutely_integrable_improper_simple +absolutely_integrable_increasing_derivative +absolutely_integrable_increasing_derivative_alt +absolutely_integrable_inf_1 +absolutely_integrable_integrable_bound +absolutely_integrable_inter +absolutely_integrable_le +absolutely_integrable_lebesgue_points +absolutely_integrable_lift_component +absolutely_integrable_linear +absolutely_integrable_max +absolutely_integrable_max_1 +absolutely_integrable_measurable +absolutely_integrable_min +absolutely_integrable_min_1 +absolutely_integrable_neg +absolutely_integrable_neg_eq +absolutely_integrable_norm +absolutely_integrable_on_const +absolutely_integrable_on_empty +absolutely_integrable_on_indicator +absolutely_integrable_on_lebesgue_measurable_inter +absolutely_integrable_on_linear_image +absolutely_integrable_on_negligible +absolutely_integrable_on_null +absolutely_integrable_on_open_interval +absolutely_integrable_on_subinterval +absolutely_integrable_pastecart_sym +absolutely_integrable_pastecart_sym_univ +absolutely_integrable_reflect +absolutely_integrable_reflect_gen +absolutely_integrable_restrict_inter +absolutely_integrable_restrict_univ +absolutely_integrable_set_variation +absolutely_integrable_spike +absolutely_integrable_spike_eq +absolutely_integrable_spike_set +absolutely_integrable_spike_set_eq +absolutely_integrable_square_integrable_product +absolutely_integrable_sub +absolutely_integrable_sup_1 +absolutely_integrable_translation +absolutely_integrable_twizzle_eq +absolutely_integrable_union +absolutely_integrable_vsum +absolutely_setcontinuous_comparison +absolutely_setcontinuous_indefinite_integral +absolutely_setcontinuous_on_0 +absolutely_setcontinuous_on_add +absolutely_setcontinuous_on_alt +absolutely_setcontinuous_on_cmul +absolutely_setcontinuous_on_componentwise +absolutely_setcontinuous_on_compose_linear +absolutely_setcontinuous_on_division +absolutely_setcontinuous_on_eq +absolutely_setcontinuous_on_lift_abs +absolutely_setcontinuous_on_mul +absolutely_setcontinuous_on_neg +absolutely_setcontinuous_on_norm +absolutely_setcontinuous_on_null +absolutely_setcontinuous_on_sub +absolutely_setcontinuous_on_subset +absolutely_setcontinuous_on_vsum +absolutely_summable_imp_cauchy +absor +absord +absori +absorption +absorption_rwt +absorption_union +absproddvds +absprodnn +absrdbnd +absre +absred +absrei +absreim +absreimsq +absrele +absresq +absrpcl +absrpcld +abss +absscl +abssdv +abssexg +abssf +abssge0 +abssi +abssid +abssinbd +abssinper +abssnid +abssor +abssq +abssub +abssubd +abssubge0 +abssubge0d +abssubi +abssuble0 +abssuble0d +abssubne0 +abssubrp +abssubs +abssval +abstract_type +abstri +abstrid +abstrii +absurd +absval +absval2 +absval2d +absval2i +absvalsq +absvalsq2 +absvalsq2d +absvalsq2i +absvalsqd +absvalsqi +absz +abtp +abv +abv0 +abv1 +abv1z +abvalt +abvcl +abvcxp +abvdiv +abvdom +abveq0 +abvexp +abvf +abvfge0 +abvfval +abvge0 +abvgt0 +abvmet +abvmul +abvn0b +abvne0 +abvneg +abvpropd +abvpropd2 +abvrcl +abvrec +abvres +abvsubtri +abvtri +abvtriv +abvtrivd +abvtrivg +ac +ac10ct +ac2 +ac3 +ac4 +ac4c +ac5 +ac5b +ac5num +ac6 +ac6c4 +ac6c5 +ac6gf +ac6mapd +ac6n +ac6num +ac6s +ac6s2 +ac6s3 +ac6s3f +ac6s4 +ac6s5 +ac6s6 +ac6s6f +ac6sf +ac6sf2 +ac6sfi +ac6sg +ac7 +ac7g +ac8 +ac8prim +ac9 +ac9s +acacni +acc +accept_tac +accepts +accumulation_subsequence +aceq0 +aceq1 +aceq2 +aceq3lem +acid_atomicity +aciunf1 +aciunf1lem +ackbij1 +ackbij1b +ackbij1lem1 +ackbij1lem10 +ackbij1lem11 +ackbij1lem12 +ackbij1lem13 +ackbij1lem14 +ackbij1lem15 +ackbij1lem16 +ackbij1lem17 +ackbij1lem18 +ackbij1lem2 +ackbij1lem3 +ackbij1lem4 +ackbij1lem5 +ackbij1lem6 +ackbij1lem7 +ackbij1lem8 +ackbij1lem9 +ackbij2 +ackbij2lem1 +ackbij2lem2 +ackbij2lem3 +ackbij2lem4 +ackbijnn +ackendofnn0 +ackermann +ackermannterminates +ackfnnn0 +ackm +ackval0 +ackval0012 +ackval0val +ackval1 +ackval1012 +ackval2 +ackval2012 +ackval3 +ackval3012 +ackval40 +ackval41 +ackval41a +ackval42 +ackval42a +ackval50 +ackvalsuc0val +ackvalsuc1 +ackvalsuc1mpt +ackvalsucsucval +acl2-count-evens-strong +acl2-count-evens-weak +acl2-count-of-nth-linear +acl2-count-of-nth-linear-weak +acl2-count-of-nth-rewrite +acncc +acndom +acndom2 +acnen +acnen2 +acneq +acni +acni2 +acni3 +acnlem +acnnum +acnrcl +acongeq +acongeq12d +acongid +acongneg2 +acongrep +acongsym +acongtr +acopy +acopyeu +acos1 +acos1half +acosbnd +acoscl +acoscos +acoscosb +acosf +acosneg +acosrecl +acosval +acsdomd +acsdrscl +acsdrsel +acsexdimd +acsficl +acsficl2d +acsficld +acsfiel +acsfiel2 +acsfiindd +acsfn +acsfn0 +acsfn1 +acsfn1c +acsfn1p +acsfn2 +acsinfd +acsinfdimd +acsmap2d +acsmapd +acsmre +acsmred +actfunsnf1o +actfunsnrndisj +actor_isolation +acufl +acunirnmpt +acunirnmpt2 +acunirnmpt2f +acycgr0v +acycgr1v +acycgr2v +acycgrcycl +acycgrislfgr +acycgrsubgr +ad10antlr +ad10antr +ad11antr +ad2ant2l +ad2ant2lr +ad2ant2r +ad2ant2rl +ad2antll +ad2antlr +ad2antrl +ad2antrr +ad3antlr +ad3antrrr +ad4ant123 +ad4ant124 +ad4ant13 +ad4ant134 +ad4ant14 +ad4ant23 +ad4ant234 +ad4ant24 +ad4antlr +ad4antr +ad5ant123 +ad5ant124 +ad5ant125 +ad5ant13 +ad5ant134 +ad5ant135 +ad5ant14 +ad5ant145 +ad5ant15 +ad5ant23 +ad5ant234 +ad5ant2345 +ad5ant235 +ad5ant24 +ad5ant245 +ad5ant25 +ad5antlr +ad5antr +ad6antlr +ad6antr +ad7antlr +ad7antr +ad8antlr +ad8antr +ad9antlr +ad9antr +adantl +adantl3r +adantl4r +adantl5r +adantl6r +adantld +adantll +adantlll +adantlllr +adantllr +adantlr +adantlrl +adantlrr +adantr +adantrd +adantrl +adantrll +adantrlr +adantrr +adantrrl +adantrrr +add +add-zero-left +add-zero-right +add1 +add12 +add12d +add12i +add1cncf +add1p1 +add20 +add20i +add2cncf +add32 +add32d +add32i +add32r +add4 +add42 +add42d +add42i +add4d +add4i +add_0 +add_ac +add_assoc +add_clauses +add_comm +add_commutes +add_div_add_div +add_div_rwt +add_eq_0 +add_eq_1 +add_eq_sub +add_ints +add_inv_0 +add_inv_0_eq +add_inverse +add_le_add_left +add_le_add_right +add_left_cancel +add_mod +add_modulus +add_mono_less_eq +add_pow_2 +add_rat +add_ratl +add_ratr +add_right_cancel +add_sub +add_sub2 +add_suc +add_succ +add_sym +add_zero +add_zero_left +add_zero_r +add_zero_right +addass +addassd +addassi +addassnni +addassnq +addassoc +addasspi +addasspr +addasssr +addbday +addbdaylem +addcan +addcan2 +addcan2ad +addcan2d +addcan2i +addcanad +addcancelleft +addcancelright +addcand +addcani +addcanpi +addcanpr +addccncf +addccncf2 +addcj +addcjd +addcji +addcl +addcld +addcli +addclnq +addclpi +addclpr +addclprlem1 +addclprlem2 +addclsr +addcmpblnr +addcn +addcn2 +addcncf +addcncff +addcnlem +addcnsr +addcnsrec +addcom +addcomd +addcomgi +addcomi +addcomli +addcomm +addcomnni +addcomnq +addcompi +addcompq +addcompr +addcomsr +addcos +addcuts +addcuts2 +addcutslem +adddi +adddid +adddii +adddir +adddird +adddiri +adddirp1d +adddivflid +adddmmbl +adddmmbl2 +addeq0 +adderpq +adderpqlem +addex +addge0 +addge01 +addge01d +addge02 +addge02d +addge0d +addge0i +addgegt0 +addgegt0d +addgegt0i +addgt0 +addgt0d +addgt0i +addgt0ii +addgt0sr +addgtge0 +addgtge0d +addhalfcut +addid0 +addinvcom +addition_formula_neg +addition_formula_pos +additive_content_division +additive_content_tagged_division +additive_division_1 +additive_tagged_division_1 +additivity +addlelt +addlenpfx +addlid +addlidd +addlidi +addlimc +addlsub +addltmul +addltmulalt +addmodid +addmodidr +addmodlteq +addmodlteqalt +addmodne +addmonotone +addmulmodb +addmulsub +addn0nid +addneg1mul +addneintr2d +addneintrd +addnidpi +addnqf +addonbday +addpiord +addpipq +addpipq2 +addpqf +addpqnq +addrcom +addresr +addrfn +addrfv +addrid +addridd +addridi +addrsub +addrval +adds12d +adds32d +adds42d +adds4d +addsass +addsassd +addsasslem1 +addsasslem2 +addscan1 +addscan1d +addscan2 +addscan2d +addscl +addscld +addscom +addscomd +addsdi +addsdid +addsdilem1 +addsdilem2 +addsdilem3 +addsdilem4 +addsdird +addsf +addsfn +addsfo +addsge01d +addsgt0d +addsin +addslid +addsprop +addsproplem1 +addsproplem2 +addsproplem3 +addsproplem4 +addsproplem5 +addsproplem6 +addsproplem7 +addsq2nreurex +addsq2reu +addsqn2reu +addsqn2reurex2 +addsqnot2reu +addsqnreup +addsqrexnreu +addsrid +addsridd +addsrmo +addsrpr +addsub +addsub12 +addsub12d +addsub4 +addsub4d +addsub4i +addsubass +addsubassd +addsubassi +addsubd +addsubeq0 +addsubeq4 +addsubeq4com +addsubeq4d +addsubi +addsubs4d +addsubsassd +addsubsd +addsubsub23 +addsunif +addsuniflem +addsval +addsval2 +adh-jarrsc +adh-minim +adh-minim-ax1 +adh-minim-ax1-ax2-lem1 +adh-minim-ax1-ax2-lem2 +adh-minim-ax1-ax2-lem3 +adh-minim-ax1-ax2-lem4 +adh-minim-ax2 +adh-minim-ax2-lem5 +adh-minim-ax2-lem6 +adh-minim-ax2c +adh-minim-idalt +adh-minim-pm2.43 +adh-minimp +adh-minimp-ax1 +adh-minimp-ax2 +adh-minimp-ax2-lem4 +adh-minimp-ax2c +adh-minimp-idalt +adh-minimp-imim1 +adh-minimp-jarr-ax2c-lem3 +adh-minimp-jarr-imim1-ax2c-lem1 +adh-minimp-jarr-lem2 +adh-minimp-pm2.43 +adh-minimp-sylsimp +adj0 +adj1 +adj1o +adj2 +adjacent_append1 +adjacent_append2 +adjacent_el +adjacent_iff +adjacent_map +adjacent_mem +adjacent_ps_append +adjadd +adjadj +adjbd1o +adjbdln +adjbdlnb +adjcl +adjcoi +adjeq +adjeq0 +adjeu +adjlnop +adjmo +adjmul +adjoint_adjoint +adjoint_clauses +adjoint_compose +adjoint_injective +adjoint_injective_injective +adjoint_injective_injective_0 +adjoint_linear +adjoint_matrix +adjoint_surjective +adjoint_unique +adjoint_works +adjsslnop +adjsym +adjval +adjval2 +adjvalval +admissible_imp_superadmissible +advanced +advlog +advlogexp +aead_encrypt_decrypt +aean +aecom +aecom-o +aecoms +aecoms-o +aev +aev-o +aev2 +aevdemo +aeveq +aevlem +aevlem0 +aff_dim +aff_dim_2 +aff_dim_affine_hull +aff_dim_affine_independent +aff_dim_affine_inter_hyperplane +aff_dim_ball +aff_dim_cball +aff_dim_closure +aff_dim_conic_hull +aff_dim_conic_hull_dim +aff_dim_convex_hull +aff_dim_convex_inter_nonempty_interior +aff_dim_convex_inter_open +aff_dim_dim +aff_dim_dim_0 +aff_dim_dim_affine_diffs +aff_dim_dim_affine_diffs_strong +aff_dim_dim_subspace +aff_dim_empty +aff_dim_eq_0 +aff_dim_eq_affine_hull +aff_dim_eq_full +aff_dim_eq_full_gen +aff_dim_eq_hyperplane +aff_dim_eq_inter_hyperplane +aff_dim_eq_minus1 +aff_dim_ge +aff_dim_halfspace_ge +aff_dim_halfspace_gt +aff_dim_halfspace_le +aff_dim_halfspace_lt +aff_dim_hyperplane +aff_dim_injective_linear_image +aff_dim_insert +aff_dim_interval +aff_dim_le_card +aff_dim_le_dim +aff_dim_le_univ +aff_dim_linear_image_le +aff_dim_lt_full +aff_dim_nonempty_interior +aff_dim_nonempty_interior_eq +aff_dim_nonempty_interior_of +aff_dim_nonempty_interior_of_eq +aff_dim_open +aff_dim_open_in +aff_dim_pcross +aff_dim_pos_le +aff_dim_psubset +aff_dim_relative_interior +aff_dim_segment +aff_dim_simplex +aff_dim_sing +aff_dim_subset +aff_dim_sums_inter +aff_dim_translation_eq +aff_dim_union +aff_dim_unique +aff_dim_univ +aff_lowdim_subset_hyperplane +affine +affine_affine_hull +affine_affinity +affine_affinity_eq +affine_alt +affine_basis_exists +affine_bounded_eq_lowdim +affine_bounded_eq_trivial +affine_dependent_biggerset +affine_dependent_biggerset_general +affine_dependent_choose +affine_dependent_explicit +affine_dependent_explicit_finite +affine_dependent_imp_collinear_3 +affine_dependent_imp_dependent +affine_dependent_linear_image +affine_dependent_linear_image_eq +affine_dependent_mono +affine_dependent_translation +affine_dependent_translation_eq +affine_differences +affine_diffs_subspace +affine_empty +affine_eq_subspace +affine_exists +affine_explicit +affine_hull_0_2_explicit +affine_hull_0_3_explicit +affine_hull_0_explicit +affine_hull_2 +affine_hull_2_alt +affine_hull_3 +affine_hull_3_imp_collinear +affine_hull_affine_inter_nonempty_interior +affine_hull_affine_inter_open +affine_hull_affine_inter_open_in +affine_hull_affinity +affine_hull_closure +affine_hull_conic_hull +affine_hull_convex_hull +affine_hull_convex_inter_nonempty_interior +affine_hull_convex_inter_open +affine_hull_convex_inter_open_in +affine_hull_empty +affine_hull_eq +affine_hull_eq_empty +affine_hull_eq_sing +affine_hull_eq_span +affine_hull_eq_span_eq +affine_hull_explicit +affine_hull_explicit_alt +affine_hull_explicit_unique +affine_hull_face_of_disjoint_relative_interior +affine_hull_finite +affine_hull_finite_intersection_hyperplanes +affine_hull_finite_step +affine_hull_finite_step_gen +affine_hull_halfspace_ge +affine_hull_halfspace_gt +affine_hull_halfspace_le +affine_hull_halfspace_lt +affine_hull_indexed +affine_hull_insert_span +affine_hull_insert_subset_span +affine_hull_inters +affine_hull_linear_image +affine_hull_nonempty_interior +affine_hull_open +affine_hull_open_in +affine_hull_open_in_affine +affine_hull_open_in_convex +affine_hull_pcross +affine_hull_relative_frontier_bounded +affine_hull_relative_interior +affine_hull_scaling +affine_hull_segment +affine_hull_sing +affine_hull_span +affine_hull_subset_span +affine_hull_sums +affine_hull_translation +affine_hull_univ +affine_hulls_eq +affine_hyperplane +affine_hyperplane_sums_eq_univ +affine_imp_convex +affine_imp_polyhedron +affine_imp_subspace +affine_independent_1 +affine_independent_2 +affine_independent_card_dim_diffs +affine_independent_card_le +affine_independent_convex_affine_hull +affine_independent_delete +affine_independent_empty +affine_independent_iff_card +affine_independent_imp_finite +affine_independent_insert +affine_independent_span_eq +affine_independent_span_gt +affine_independent_stdbasis +affine_independent_subset +affine_indexed +affine_inter +affine_inters +affine_linear_image +affine_linear_image_eq +affine_linear_preimage +affine_negations +affine_parallel_slice +affine_pcross +affine_pcross_eq +affine_scaling +affine_scaling_eq +affine_sing +affine_span +affine_standard_hyperplane +affine_sums +affine_translation +affine_translation_eq +affine_translation_subspace +affine_translation_subspace_explicit +affine_translation_unique_subspace +affine_univ +affine_vsum +affine_vsum_strong +affinecomb1 +affinecomb2 +affineequiv +affineequiv2 +affineequiv3 +affineequiv4 +affineequivne +affineid +affinity_inverses +affinity_scaling_translation +afsval +afv0fv0 +afv0nbfvbi +afv20defat +afv20fv0 +afv2co2 +afv2elrn +afv2eq1 +afv2eq12d +afv2eq2 +afv2eu +afv2ex +afv2fv0 +afv2fv0b +afv2fv0xorb +afv2fvn0fveq +afv2ndefb +afv2ndeffv0 +afv2orxorb +afv2prc +afv2res +afv2rnfveq +afvco2 +afvelima +afvelrn +afvelrnb +afvelrnb0 +afveq1 +afveq12d +afveq2 +afveu +afvfundmfveq +afvfv0bi +afvfvn0fveq +afvnfundmuv +afvnufveq +afvpcfv0 +afvprc +afvres +afvvdm +afvvfunressn +afvvfveq +afvvv +against +agda +aibandbiaiaiffb +aibandbiaiffaiffb +aibnbaif +aibnbna +aiffbbtat +aiffbtbat +aiffnbandciffatnotciffb +aifftbifffaibif +aifftbifffaibifff +ainaiaandna +aiota0def +aiota0ndef +aiotaexaiotaiota +aiotaexb +aiotaint +aiotajust +aiotaval +aiotavb +aisbbisfaisf +aisbnaxb +aisfbistiaxb +aisfina +aistbisfiaxb +aistbistaandb +aistia +ajfun +ajfuni +ajfval +ajmoi +ajval +aks4d1 +aks4d1lem1 +aks4d1p1 +aks4d1p1p1 +aks4d1p1p2 +aks4d1p1p3 +aks4d1p1p4 +aks4d1p1p5 +aks4d1p1p6 +aks4d1p1p7 +aks4d1p2 +aks4d1p3 +aks4d1p4 +aks4d1p5 +aks4d1p6 +aks4d1p7 +aks4d1p7d1 +aks4d1p8 +aks4d1p8d1 +aks4d1p8d2 +aks4d1p8d3 +aks4d1p9 +aks5 +aks5lem1 +aks5lem2 +aks5lem3a +aks5lem4a +aks5lem5a +aks5lem6 +aks5lem7 +aks5lem8 +aks6d1c1 +aks6d1c1p1 +aks6d1c1p1rcl +aks6d1c1p2 +aks6d1c1p3 +aks6d1c1p4 +aks6d1c1p5 +aks6d1c1p6 +aks6d1c1p7 +aks6d1c1p8 +aks6d1c1rh +aks6d1c2 +aks6d1c2lem3 +aks6d1c2lem4 +aks6d1c2p1 +aks6d1c2p2 +aks6d1c3 +aks6d1c4 +aks6d1c5 +aks6d1c5lem0 +aks6d1c5lem1 +aks6d1c5lem2 +aks6d1c5lem3 +aks6d1c6isolem1 +aks6d1c6isolem2 +aks6d1c6isolem3 +aks6d1c6lem1 +aks6d1c6lem2 +aks6d1c6lem3 +aks6d1c6lem4 +aks6d1c6lem5 +aks6d1c7 +aks6d1c7lem1 +aks6d1c7lem2 +aks6d1c7lem3 +aks6d1c7lem4 +al0ssb +al2im +al2imi +al2imvd +al3im +ala1 +alan +alanimi +albi +albid +albidh +albidv +albii +albiim +albitr +alcom +alcomimw +alcoms +alcomw +aleph0 +aleph1 +aleph11 +aleph1irr +aleph1min +aleph1re +alephadd +alephcard +alephdom +alephdom2 +alephexp1 +alephexp2 +alephf1 +alephf1alt +alephfnon +alephfp +alephfp2 +alephfplem1 +alephfplem2 +alephfplem3 +alephfplem4 +alephgch +alephgeom +alephinit +alephislim +alephiso +alephiso2 +alephiso3 +alephle +alephlim +alephmul +alephnbtwn +alephnbtwn2 +alephom +alephon +alephord +alephord2 +alephord2i +alephord3 +alephordi +alephordilem1 +alephprc +alephreg +alephsdom +alephsing +alephsmo +alephsson +alephsuc +alephsuc2 +alephsuc3 +alephsucdom +alephsucpw +alephsucpw2 +alephval2 +alephval3 +alequexv +alex +alexbii +alexeqg +aleximi +alexn +alexsub +alexsubalt +alexsubaltlem1 +alexsubaltlem2 +alexsubaltlem3 +alexsubaltlem4 +alexsubb +alexsublem +alfal +algaddg +algbase +algcvg +algcvga +algcvgb +algcvgblem +algextdeg +algextdeglem1 +algextdeglem2 +algextdeglem3 +algextdeglem4 +algextdeglem5 +algextdeglem6 +algextdeglem7 +algextdeglem8 +algfx +alginv +algmulr +algr0 +algrf +algrp1 +algsca +algstr +algvsca +alim +alimd +alimdh +alimdv +alimex +alimi +alimp-no-surprise +alimp-surprise +alinexa +alistp-acons +all +all_append +all_different(array1d(square)) +all_different(assign) +all_different(order) +all_different(queens) +all_distinct_append +all_distinct_card_list_to_set +all_distinct_drop +all_distinct_el_imp +all_distinct_filter +all_distinct_filter_el_imp +all_distinct_genlist +all_distinct_index_of_el +all_distinct_map +all_distinct_map_inj +all_distinct_nub_id +all_distinct_sing +all_distinct_snoc +all_distinct_take +all_distinct_zip +all_distinct_zip_swap +all_nil +all_tac +allbutfi +allbutfifvre +allbutfiinf +alldifferent(array1d(cell)) +alldifferent(assign) +alldifferent(letter) +alloc_and_free +allocfresh +alneu +alnex +alpha-eq +alpha_eq +alral +alrim3con13v +alrimd +alrimdd +alrimdh +alrimdv +alrimi +alrimih +alrimii +alrimiv +alrimivv +alrmomodm +alrmomorn +alrot3 +alrot4 +alrple +alsc1d +alsc2d +alscn0d +alsconv +alsi-no-surprise +alsi1d +alsi2d +alsyl +altgnsg +altgsumbc +altgsumbcalt +altopelaltxp +altopeq1 +altopeq12 +altopeq2 +altopex +altopth +altopth1 +altopth2 +altopthb +altopthbg +altopthc +altopthd +altopthg +altopthsn +altru +altxpeq1 +altxpeq2 +altxpexg +altxpsspw +always_eventually +alxfr +alzdvds +ambulance_dispatch +amgm +amgm2 +amgm2d +amgm3d +amgm4d +amgmlem +amgmlemalt +amgmw2d +amgmwlem +amosym1 +an12 +an12i +an12s +an13 +an13s +an21 +an2anr +an3 +an31 +an31s +an32 +an32s +an33rean +an3andi +an4 +an42 +an42ds +an42s +an43 +an4com24 +an4s +an52ds +an6 +an62ds +an72ds +an82ds +anabs1 +anabs5 +anabs7 +anabsan +anabsan2 +anabsi5 +anabsi6 +anabsi7 +anabsi8 +anabss1 +anabss3 +anabss4 +anabss5 +anabss7 +anabss7p1 +analytic_borel_measurable_image +analytic_borel_measurable_preimage +analytic_continuous_image +analytic_continuous_preimage +analytic_empty +analytic_imp_lebesgue_measurable +analytic_inter +analytic_inters +analytic_linear_image +analytic_pcross +analytic_pcross_eq +analytic_translation +analytic_union +analytic_unions +analytic_univ +anan +anandi +anandi3 +anandi3r +anandir +anandirs +anandis +anass +anass1rs +anassrs +anasss +anbi1 +anbi12ci +anbi12d +anbi12i +anbi1cd +anbi1ci +anbi1d +anbi1i +anbi2 +anbi2ci +anbi2d +anbi2i +anbiim +anc2l +anc2li +anc2r +anc2ri +ancl +anclb +ancld +ancli +ancom +ancom1s +ancom2s +ancomd +ancoms +ancomsd +ancomst +ancomstvd +ancr +ancrb +ancrd +ancri +and +and-comm +and_assoc +and_associative +and_associative_rev +and_clauses +and_comm +and_comm_pf +and_commutative +and_distrib_or +and_distributes_over_or +and_distributes_over_or_rev +and_elim_l +and_elim_left +and_elim_r +and_elim_right +and_forall_thm +and_intro +and_left_1 +and_not_or +and_or_distrib_left +and_or_distrib_right +and_right +and_sym +andassociative +andcommutative +anddi +andelim +andi +andi3or +andir +andl1 +andnand1 +andr +andtrueneutral +ang180 +ang180lem1 +ang180lem2 +ang180lem3 +ang180lem4 +ang180lem5 +angcan +angcld +angneg +angpieqvd +angpieqvdlem +angpieqvdlem2 +angpined +angrteqvd +angrtmuld +angval +angvald +anidm +anidmdbi +anidms +anifp +anim12 +anim12ci +anim12d +anim12d1 +anim12dan +anim12i +anim12ii +anim1ci +anim1d +anim1i +anim2d +anim2i +animorl +animorlr +animorr +animorrl +animpimp2impd +anmp +annim +annotanannot +anor +anrabdioph +ante_res_then +antiderivative_continuous +antiderivative_integral_continuous +antisym_eq +antisymrelres +antisymrelressn +antisymressn +antnest +antnestalt +antnestlaw1 +antnestlaw2 +antnestlaw3 +antnestlaw3lem +ants_tac +anxordi +any_closest_point_affine_orthogonal +any_closest_point_dot +any_closest_point_unique +any_nil +anything +aomclem1 +aomclem2 +aomclem3 +aomclem4 +aomclem5 +aomclem6 +aomclem7 +aomclem8 +aoprssdm +aov0nbovbi +aov0ov0 +aoveq123d +aovfundmoveq +aovmpt4g +aovnfundmuv +aovnuoveq +aovov0bi +aovovn0oveq +aovpcov0 +aovprc +aovrcl +aovvdm +aovvfunressn +aovvoveq +ap_term +ap_term_tac +ap_thm +ap_thm_tac +app +app_assoc +app_nil_r +append +append-assoc +append-associative +append-nil +append-of-cons +append-of-nil +append-under-iff +append-when-not-consp +append_11 +append_assoc +append_assoc_thm +append_eq_append +append_eq_append_mid +append_eq_cons +append_eq_self +append_eq_sing +append_front_last +append_length_eq +append_linear_image +append_nil +append_nil_right +append_translation +appendassociative +appendnilrightneutral +apply +apply h +applyantisym +applysym +approachable_lt_le +approximable_on_division +aprilfools2025 +arb +arc_distinct_ends +arc_image_unique +arc_imp_path +arc_length_minimal +arc_length_reparametrization +arc_length_unique +arc_simple_path +arch +archd +archiabl +archiabllem1 +archiabllem1a +archiabllem1b +archiabllem2 +archiabllem2a +archiabllem2b +archiabllem2c +archiexdiv +archirng +archirngz +archnq +areacirc +areacirclem1 +areacirclem2 +areacirclem3 +areacirclem4 +areacirclem5 +areacl +areaf +areage0 +areambl +areaquad +arearect +areass +areaval +arg-ax +argcj +argimgt0 +argimlt0 +arginv +arglem1n +argrege0 +argregt0 +args +argument +arisum +arisum2 +arith +arith_eq +arith_even +arith_odd +arith_rule +arith_suc +arith_tac +arithmetic +array +array_fill +array_sum_nonneg +array_swap +arwass +arwcd +arwdm +arwdmcd +arweutermc +arweuthinc +arwhom +arwhoma +arwlid +arwrcl +arwrid +arwval +arzela_ascoli +arzela_ascoli_lipschitz +as +ascl0 +ascl1 +asclcntr +asclcom +ascldimul +asclelbas +asclelbasalt +asclf +asclf1 +asclfn +asclfval +asclghm +asclinvg +asclmul1 +asclmul2 +asclmulg +asclply1subcl +asclpropd +asclrhm +asclval +ash-0 +ash-goes-to-0 +asin1 +asin1half +asinbnd +asincl +asindmre +asinf +asinlem +asinlem2 +asinlem3 +asinlem3a +asinneg +asinrebnd +asinrecl +asinsin +asinsinb +asinsinlem +asinval +asm +asm_arith_tac +asm_cases_tac +asm_int_arith_tac +asm_meson_tac +asm_metis_tac +asm_real_arith_tac +asm_rewrite_tac +asm_simp_tac +aspid +asplss +aspss +aspssid +aspsubrg +aspval +aspval2 +assa2ass +assa2ass2 +assaascl0 +assaascl1 +assaass +assaassd +assaassr +assaassrd +assafld +assalactf1o +assalem +assalmod +assamulgscm +assamulgscmlem1 +assamulgscmlem2 +assapropd +assaring +assarrginv +assasca +assembly_line +assert +assert_tac +assignment_problem +assintop +assintopass +assintopasslaw +assintopcllaw +assintopmap +assintopval +asslawass +assoc +assoc-of-acons +assoc-of-acons-diff +associative1 +associative2 +associativity-of-* +associativity-of-+ +associativity-of-append +associativity-of-logapp +assraddsubd +assraddsubi +assume +assume a +assume b +assume f +assume g +assume h +assume h na +assume h p0 +assume h1 +assume h2 +assume ih +assume ih1 ih2 +assume l' +assume m +assume na nb +assume nb +assume p0 step +assume p_leaf p_node +assume p_nil p_cons +assume w +assume wf ih +assume_tac +assumption +ast +astbstanbst +asymref +asymref2 +at +at_infinity +at_neginfinity +at_posinfinity +atabs2i +atabsi +atan0 +atan1 +atanbnd +atanbndlem +atancj +atancl +atancn +atandm +atandm2 +atandm3 +atandm4 +atandmcj +atandmneg +atandmtan +atanf +atanlogadd +atanlogaddlem +atanlogsub +atanlogsublem +atanneg +atanord +atanre +atanrecl +atans +atans2 +atansopn +atansssdm +atantan +atantanb +atantayl +atantayl2 +atantayl3 +atanval +atbase +atbiffatnnb +atbiffatnnbalt +atbtwn +atbtwnex +atbtwnexoldn +atcmp +atcv0 +atcv0eq +atcv1 +atcvat2 +atcvat2i +atcvat3i +atcvat4i +atcvati +atcvatlem +atcveq0 +atcvr0 +atcvr0eq +atcvr1 +atcvr2 +atcvreq0 +atcvrj0 +atcvrj1 +atcvrj2 +atcvrj2b +atcvrlln +atcvrlln2 +atcvrnen +atdmd +atdmd2 +atelch +atex +atexch +atexchcvrn +atexchltn +athgt +atl0cl +atl0dm +atl0le +atlatle +atlatmstc +atle +atlelt +atlen0 +atlenen +atlex +atllat +atlle0 +atlltn0 +atlpos +atlrelat1 +atlt +atltcvr +atmd +atmd2 +atmod1i1 +atmod1i1m +atmod1i2 +atmod2i1 +atmod2i2 +atmod3i1 +atmod3i2 +atmod4i1 +atmod4i2 +atn0 +atnaiana +atncmp +atncvrn +atne0 +atnem0 +atnemeq0 +atnle +atnle0 +atnlej1 +atnlej2 +atnlt +atnssm0 +atom1d +atomic_read_write +atomicincrement +atoml2i +atomli +atord +atordi +atpointn +atpointof +atpsubcln +atpsubn +atss +atssbase +atssch +atsseq +atssma +audit_log_append +ausgrumgri +ausgrusgrb +ausgrusgri +austin_lemma +auth_token_valid +auto +autolte +autorefl +autoshow +avgle +avgle1 +avgle2 +avglt1 +avglt2 +avglts1d +avglts2d +avl_balanced +avril1 +ax1 +ax10fromc7 +ax10w +ax11-pm +ax11-pm2 +ax11dgen +ax11w +ax12 +ax12a2-o +ax12b +ax12dgen +ax12el +ax12eq +ax12ev2 +ax12f +ax12fromc15 +ax12i +ax12inda +ax12inda2 +ax12inda2alt +ax12indalem +ax12indi +ax12indn +ax12v +ax12v2 +ax12v2-o +ax12valt +ax12w +ax12wdemo +ax12wlem +ax13 +ax13alt +ax13b +ax13dgen1 +ax13dgen2 +ax13dgen3 +ax13dgen4 +ax13fromc9 +ax13lem1 +ax13lem2 +ax13v +ax13w +ax1cn +ax1ne0 +ax1rid +ax2 +ax3 +ax3h +ax4fromc4 +ax5alt +ax5d +ax5e +ax5ea +ax5el +ax5eq +ax5seg +ax5seglem1 +ax5seglem2 +ax5seglem3 +ax5seglem3a +ax5seglem4 +ax5seglem5 +ax5seglem6 +ax5seglem7 +ax5seglem8 +ax5seglem9 +ax6 +ax6dgen +ax6e +ax6e2eq +ax6e2eqvd +ax6e2nd +ax6e2ndalt +ax6e2ndeq +ax6e2ndeqalt +ax6e2ndeqvd +ax6e2ndvd +ax6er +ax6ev +ax6evr +ax6fromc10 +ax6v +ax6vsep +ax7 +ax7v +ax7v1 +ax7v2 +ax8 +ax8dfeq +ax8v +ax8v1 +ax8v2 +ax9 +ax9alt +ax9v +ax9v1 +ax9v2 +axac +axac10 +axac2 +axac3 +axaci +axacnd +axacndlem1 +axacndlem2 +axacndlem3 +axacndlem4 +axacndlem5 +axacprim +axaddass +axaddcl +axaddf +axaddrcl +axbnd +axbtwnid +axc10 +axc11 +axc11-o +axc11n +axc11n-16 +axc11n11 +axc11n11r +axc11next +axc11nfromc11 +axc11r +axc11rv +axc11v +axc14 +axc15 +axc16 +axc16alt +axc16b +axc16g +axc16g-o +axc16galt +axc16gb +axc16i +axc16nf +axc16nfalt +axc4 +axc4i +axc4i-o +axc5 +axc5c4c711 +axc5c4c711to11 +axc5c4c711toc4 +axc5c4c711toc5 +axc5c4c711toc7 +axc5c7 +axc5c711 +axc5c711to11 +axc5c711toc5 +axc5c711toc7 +axc5c7toc5 +axc5c7toc7 +axc5sp1 +axc7 +axc711 +axc711to11 +axc711toc7 +axc7e +axc9 +axcc +axcc2 +axcc2lem +axcc3 +axcc4 +axcc4dom +axccd +axccd2 +axccdom +axcclem +axcgrid +axcgrrflx +axcgrtr +axcnex +axcnre +axcont +axcontlem1 +axcontlem10 +axcontlem11 +axcontlem12 +axcontlem2 +axcontlem3 +axcontlem4 +axcontlem5 +axcontlem6 +axcontlem7 +axcontlem8 +axcontlem9 +axdc +axdc2 +axdc2lem +axdc3 +axdc3lem +axdc3lem2 +axdc3lem3 +axdc3lem4 +axdc4 +axdc4lem +axdc4uz +axdc4uzlem +axdclem +axdclem2 +axdimuniq +axdistr +axeuclid +axeuclidlem +axextb +axextbdist +axextdfeq +axextdist +axexte +axextg +axextmo +axextnd +axextndbi +axextprim +axfrege28 +axfrege31 +axfrege41 +axfrege52a +axfrege52c +axfrege54a +axfrege54c +axfrege58a +axfrege58b +axfrege8 +axgroth2 +axgroth3 +axgroth4 +axgroth5 +axgroth6 +axhcompl-zf +axhfi-zf +axhfvadd-zf +axhfvmul-zf +axhilex-zf +axhis1-zf +axhis2-zf +axhis3-zf +axhis4-zf +axhv0cl-zf +axhvaddid-zf +axhvass-zf +axhvcom-zf +axhvdistr1-zf +axhvdistr2-zf +axhvmul0-zf +axhvmulass-zf +axhvmulid-zf +axi10 +axi12 +axi2m1 +axi4 +axi5r +axi9 +axia1 +axia2 +axia3 +axial +axicn +axie1 +axie2 +axin1 +axin2 +axinf +axinf2 +axinfnd +axinfndlem1 +axinfprim +axio +axiom +axiomcompleteness +axioms +axlowdim +axlowdim1 +axlowdim2 +axlowdimlem1 +axlowdimlem10 +axlowdimlem11 +axlowdimlem12 +axlowdimlem13 +axlowdimlem14 +axlowdimlem15 +axlowdimlem16 +axlowdimlem17 +axlowdimlem2 +axlowdimlem3 +axlowdimlem4 +axlowdimlem5 +axlowdimlem6 +axlowdimlem7 +axlowdimlem8 +axlowdimlem9 +axltadd +axlttri +axlttrn +axmulass +axmulcl +axmulcom +axmulf +axmulgt0 +axmulrcl +axnul +axnulalt +axnulalt2 +axnulg +axorbciffatcxorb +axorbtnotaiffb +axpasch +axpaschlem +axpjcl +axpjpj +axpow2 +axpow3 +axpownd +axpowndlem1 +axpowndlem2 +axpowndlem3 +axpowndlem4 +axpowprim +axpr +axpralt +axpre-ltadd +axpre-lttri +axpre-lttrn +axpre-mulgt0 +axpre-sup +axprlem1 +axprlem2 +axprlem3 +axprlem3old +axprlem4 +axprlem4old +axprlem5old +axprold +axpweq +axreg +axreg2 +axregnd +axregndlem1 +axregndlem2 +axregprim +axregs +axregscl +axregszf +axrep1 +axrep2 +axrep3 +axrep4 +axrep4old +axrep4v +axrep5 +axrep6 +axrep6g +axrep6old +axreplem +axrepnd +axrepndlem1 +axrepndlem2 +axrepprim +axresscn +axrnegex +axrrecex +axsegcon +axsegconlem1 +axsegconlem10 +axsegconlem2 +axsegconlem3 +axsegconlem4 +axsegconlem5 +axsegconlem6 +axsegconlem7 +axsegconlem8 +axsegconlem9 +axsep +axsepg +axsepg2 +axsepg2alt +axsepgfromrep +axsup +axtg5seg +axtgbtwnid +axtgcgrid +axtgcgrrflx +axtgcont +axtgcont1 +axtgeucl +axtglowdim2 +axtglowdim2altv +axtgpasch +axtgsegcon +axtgupdim2 +axtgupdim2altv +axun2 +axunnd +axunndlem1 +axunprim +b +baby_sard +baby_sard_alt +backchain-signed-byte-p-to-unsigned-byte-p +backend +backprop_chain +backward +backward_induction +baerlem3 +baerlem3lem1 +baerlem3lem2 +baerlem5a +baerlem5abmn +baerlem5alem1 +baerlem5alem2 +baerlem5amn +baerlem5b +baerlem5blem1 +baerlem5blem2 +baerlem5bmn +bafval +baib +baibd +baibr +baire +baire0_indicator +baire1_det_jacobian +baire1_indicator +baire1_partial_derivatives +baire1_vector_derivative +baire_add +baire_alt +baire_bilinear +baire_cases +baire_category +baire_cmul +baire_componentwise +baire_compose +baire_compose_continuous +baire_const +baire_continuous_compose +baire_continuous_compose_univ +baire_eq +baire_eq_fsigma_preimage_alt +baire_eq_fsigma_preimage_open +baire_eq_fsigma_preimage_open_gen +baire_eq_gdelta_preimage_alt +baire_eq_gdelta_preimage_closed +baire_eq_gdelta_preimage_closed_gen +baire_extension +baire_fsigma_preimage_gen +baire_imp_borel_measurable +baire_imp_measurable_on +baire_imp_measurable_on_univ +baire_indicator_bijective_linear_image +baire_indicator_complement +baire_indicator_complement_univ +baire_indicator_continuous_preimage +baire_indicator_continuous_preimage_univ +baire_indicator_diff +baire_indicator_empty +baire_indicator_injective_linear_image +baire_indicator_inter +baire_indicator_inters +baire_indicator_locally +baire_indicator_refl +baire_indicator_suc +baire_indicator_translation +baire_indicator_union +baire_indicator_unions +baire_indicator_univ +baire_lavrentiev +baire_max +baire_min +baire_mono +baire_mul +baire_norm +baire_pastecart +baire_product +baire_restrict +baire_sub +baire_subset +baire_uniform_approximation +baire_uniform_limit +baire_vsum +ball_1 +ball_empty +ball_eq_empty +ball_interval +ball_interval_0 +ball_linear_image +ball_max_union +ball_min_inter +ball_scaling +ball_subset_cball +ball_subset_open_map_image +ball_translation +ball_trivial +ball_union_sphere +ballotlem1 +ballotlem1c +ballotlem1ri +ballotlem2 +ballotlem4 +ballotlem5 +ballotlem7 +ballotlem8 +ballotleme +ballotlemelo +ballotlemfc0 +ballotlemfcc +ballotlemfelz +ballotlemfg +ballotlemfmpn +ballotlemfp1 +ballotlemfrc +ballotlemfrceq +ballotlemfrci +ballotlemfrcn0 +ballotlemfval +ballotlemfval0 +ballotlemgun +ballotlemgval +ballotlemi +ballotlemi1 +ballotlemic +ballotlemieq +ballotlemiex +ballotlemii +ballotlemimin +ballotlemirc +ballotlemodife +ballotlemoex +ballotlemrc +ballotlemrinv +ballotlemrinv0 +ballotlemro +ballotlemrv +ballotlemrv1 +ballotlemrv2 +ballotlemrval +ballotlemscr +ballotlemsdom +ballotlemsel1i +ballotlemsf1o +ballotlemsgt1 +ballotlemsi +ballotlemsima +ballotlemsup +ballotlemsv +ballotlemsval +ballotth +ballss3 +bamalip +banach_fix +banach_fix_iter +banach_sproperty_imp_finite_preimages +banach_sproperty_imp_luzin_nproperty +banach_sproperty_imp_luzin_nproperty_outer +banach_sproperty_imp_preserves_measurable +banach_sproperty_outer +banach_zarecki +banach_zarecki_gen +bandwidth_alloc +barbara +barbari +barbarialt +barbarilem +barinduction +baroco +barocoalt +barycentre_0 +barycentre_1 +barycentre_2 +barycentre_in_affine_hull +barycentre_in_convex_hull +barycentre_in_relative_interior +barycentre_linear_image +barycentre_not_in_set +barycentre_translation +bascnvimaeqv +basdif0 +base +base0 +based +baseid +basel +baselcarsg +basellem1 +basellem2 +basellem3 +basellem4 +basellem5 +basellem6 +basellem7 +basellem8 +basellem9 +baselsiga +basendx +basendxltdsndx +basendxltedgfndx +basendxltplendx +basendxltplusgndx +basendxlttsetndx +basendxltunifndx +basendxnedgfndx +basendxnmulrndx +basendxnn +basendxnocndx +basendxnplusgndx +baseval +basfn +basgen +basgen2 +basic +basictotality +basis1 +basis2 +basis_card_eq_dim +basis_component +basis_coordinates_continuous +basis_coordinates_lipschitz +basis_eq_0 +basis_exists +basis_exists_finite +basis_expansion +basis_expansion_unique +basis_has_size_dim +basis_has_size_univ +basis_inj +basis_inj_eq +basis_ne +basis_nonzero +basis_orthogonal +basis_subspace_exists +basndxelwund +baspartn +basprssdmsets +basqtop +basresposfo +basresprsfo +basrestermcfo +basrestermcfolem +bastg +bastop +bastop1 +bastop2 +basvtxval +batch_mixing +battery_scheduling +bayes_rule +bayesdef +bayesth +bc +bc0k +bcc0 +bccbc +bcccl +bccl +bccl2 +bccl2d +bccld +bccm1k +bccmpl +bccn0 +bccn1 +bccolsum +bccp1k +bcctr +bccval +bcfallfac +bclbnd +bcle2d +bcled +bcm1k +bcm1n +bcm1nt +bcmax +bcmono +bcn0 +bcn1 +bcn2 +bcn2m1 +bcn2p1 +bcneg1 +bcnm1 +bcnn +bcnp1n +bcp1ctr +bcp1m1 +bcp1n +bcp1nk +bcpasc +bcpascm1 +bcprod +bcrpcl +bcs +bcs2 +bcs3 +bcseqi +bcsialt +bcsihil +bcth +bcth2 +bcth3 +bcthlem1 +bcthlem2 +bcthlem3 +bcthlem4 +bcthlem5 +bcval +bcval2 +bcval3 +bcval4 +bcval5 +bcxmas +bcxmaslem1 +bday0 +bday0b +bday1 +bday11on +bdaybndbday +bdaybndex +bdaydm +bdayfin +bdayfinbnd +bdayfinbndcbv +bdayfinbndlem1 +bdayfinbndlem2 +bdayfinlem +bdayfn +bdayfo +bdayfun +bdayimaon +bdayiun +bdayle +bdayn0p1 +bdayn0sf1o +bdayon +bdayons +bdaypw2bnd +bdaypw2n0bnd +bdaypw2n0bndlem +bdayrn +bdayval +bddibl +bddiblnc +bddmulibl +bddnghm +bdopadj +bdopcoi +bdopf +bdophdi +bdophmi +bdophsi +bdopln +bdopssadj +beppo_levi_decreasing +beppo_levi_increasing +beppo_levi_monotone_convergence_decreasing +beppo_levi_monotone_convergence_decreasing_ae +beppo_levi_monotone_convergence_increasing +beppo_levi_monotone_convergence_increasing_ae +bernneq +bernneq2 +bernneq3 +bessel_inequality +beta-red +beta_red +beta_reduce +beta_tac +between_1 +between_antisym +between_cmul_lift +between_collinear_dist_eq +between_dist_le +between_dist_lt +between_dot +between_exists_extension +between_imp_collinear +between_in_convex_hull +between_in_segment +between_linear_image_eq +between_midpoint +between_norm +between_norm_le +between_norm_lt +between_refl +between_refl_eq +between_restricted_cases +between_sym +between_trans +between_trans_2 +between_translation +bezout +bezoutlem1 +bezoutlem2 +bezoutlem3 +bezoutlem4 +bezoutr +bezoutr1 +bfp +bfplem1 +bfplem2 +bfs_shortest +bgoldbachlt +bgoldbnnsum3prm +bgoldbtbnd +bgoldbtbndlem1 +bgoldbtbndlem2 +bgoldbtbndlem3 +bgoldbtbndlem4 +bhmafibid1 +bhmafibid1cn +bhmafibid2 +bhmafibid2cn +bi123imp0 +bi123impia +bi123impib +bi12imp3 +bi13imp2 +bi13imp23 +bi13impia +bi13impib +bi1imp +bi2.04 +bi23imp1 +bi23imp13 +bi23impib +bi2anan9 +bi2anan9r +bi2bian9 +bi2imp +bi33imp12 +bi3impa +bi3impb +biadan +biadani +biadanialt +biadanid +biadanii +bian1d +bian1dold +bianabs +bianass +bianassc +bianbi +biancomd +biancomi +bianfd +bianfi +bianim +bianir +biantr +biantru +biantrud +biantrur +biantrurd +biass +bibi1 +bibi12d +bibi12i +bibi1d +bibi1i +bibi2d +bibi2i +bibiad +bibif +bicom +bicom1 +bicomd +bicomdalt +bicomdd +bicomi +bicontr +bifal +bifald +biginter_gspec +biginter_image +biginter_sing +biginter_subset +biginter_union +bigolden +bigoval +bigstep +bigstep-det +bigstep-of +bigstep-smallstep +bigstep-value +bigstep_det +bigstep_of +bigstep_smallstep +bigstep_value +bigunion_countable +bigunion_cross +bigunion_gspec +bigunion_image +bigunion_image_set_subset +bigunion_image_subset +bigunion_image_univ +bigunion_pair +bigunion_partition +bigunion_sing +bigunion_subset +bigunion_union +biid +biidd +biimp +biimp3a +biimp3ar +biimpa +biimpac +biimpar +biimparc +biimpcd +biimpd +biimpexp +biimpi +biimpor +biimpr +biimprcd +biimprd +biimpri +biimt +biimtrdi +biimtrid +biimtrrdi +biimtrrid +bij_alt +bij_compose +bij_cong +bij_delete +bij_element +bij_finite +bij_finite_iff +bij_finite_subset +bij_i_same +bij_id +bij_iff_inv +bij_image +bij_image_partitions +bij_imp_11 +bij_inj_surj +bij_insert +bij_insert_imp +bij_inv +bij_is_inj +bij_is_surj +bij_linv_bij +bij_linv_inv +bij_num_countable +bij_num_to_pair +bij_pair_to_num +bij_support +bij_swap +bij_sym +bij_sym_imp +bij_thm +bij_trans +bija +bijection +bijective_left_right_inverse +bijust +bijust0 +bilinear_bounded +bilinear_bounded_pos +bilinear_continuous_compose +bilinear_continuous_on +bilinear_continuous_on_compose +bilinear_differentiable_at_compose +bilinear_differentiable_on_compose +bilinear_differentiable_within_compose +bilinear_dot +bilinear_drop_mul +bilinear_epsilon_delta +bilinear_eq +bilinear_eq_stdbasis +bilinear_in_affine_hull +bilinear_in_convex_hull +bilinear_ladd +bilinear_lift_mul +bilinear_lmul +bilinear_lneg +bilinear_lsub +bilinear_lsum +bilinear_lzero +bilinear_matrix_mul +bilinear_matrix_vector_mul +bilinear_mul_drop +bilinear_radd +bilinear_rmul +bilinear_rneg +bilinear_rsub +bilinear_rsum +bilinear_rzero +bilinear_swap +bilinear_uniformly_continuous_on_compose +bilinear_vsum +bilinear_vsum_convolution_1 +bilinear_vsum_convolution_2 +bilinear_vsum_partial_pre +bilinear_vsum_partial_suc +bilipschitz_homeomorphism_relative_frontiers +bilipschitz_homeomorphism_spherical_projection +biluk +bimap_id +bimsc1 +bin_packing +binary_gcd_spec +binary_induct +binary_rep +binary_search_extract +binary_search_found +binary_search_not_found +binary_search_spec +binarysearchcorrect +binder_conv +binding +binom +binom11 +binom1dif +binom1p +binom2 +binom21 +binom2d +binom2i +binom2sub +binom2sub1 +binom2subadd +binom2subi +binom3 +binom4 +binomcxp +binomcxplemcvg +binomcxplemdvbinom +binomcxplemdvsum +binomcxplemfrat +binomcxplemnn0 +binomcxplemnotnn0 +binomcxplemradcnv +binomcxplemrat +binomcxplemwb +binomfallfac +binomfallfaclem1 +binomfallfaclem2 +binomial_triviality +binomialish_lemma +binomialtheorem +binomlem +binomrisefac +binop_conv +binop_tac +biorf +biorfd +biorfi +biorfri +biorfriold +biort +biortn +birthday +birthdaylem1 +birthdaylem2 +birthdaylem3 +bisaiaisb +bisection +bishop_cont_uniform +bishop_rational_dense +bishop_real_approx +bishop_seq_modulus +bishop_sqrt_exists +bisym1 +bit_length +bitp-loghead-1 +bitr +bitr2d +bitr2di +bitr2i +bitr2id +bitr3 +bitr3d +bitr3di +bitr3i +bitr3id +bitr3vd +bitr4d +bitr4di +bitr4i +bitr4id +bitrd +bitrdi +bitri +bitrid +bitru +bits0 +bits0altv +bits0e +bits0ealtv +bits0o +bits0oaltv +bitscmp +bitsf +bitsf1 +bitsf1o +bitsf1ocnv +bitsfi +bitsfval +bitsfzo +bitsfzolem +bitsinv +bitsinv1 +bitsinv1lem +bitsinv2 +bitsinvp1 +bitsmod +bitsp1 +bitsp1e +bitsp1o +bitsres +bitsshft +bitsss +bitsuz +bitsval +bitsval2 +bitvec +bj-0 +bj-0eltag +bj-0int +bj-0nel1 +bj-0nelmpt +bj-0nelopab +bj-0nelsngl +bj-0nmoore +bj-1 +bj-19.12 +bj-19.21bit +bj-19.21t +bj-19.21t0 +bj-19.23bit +bj-19.23t +bj-19.36im +bj-19.37im +bj-19.41al +bj-19.41t +bj-19.42t +bj-19.9htbi +bj-1nel0 +bj-1upleq +bj-1uplex +bj-1upln0 +bj-1uplth +bj-2albi +bj-2alim +bj-2exbi +bj-2exim +bj-2upleq +bj-2uplex +bj-2upln0 +bj-2upln1upl +bj-2uplth +bj-3exbi +bj-a1k +bj-ab0 +bj-abex +bj-abf +bj-ablsscmn +bj-ablsscmnel +bj-ablssgrp +bj-ablssgrpel +bj-abv +bj-abvalt +bj-adjfrombun +bj-adjg1 +bj-aecomsv +bj-alalbial +bj-alanim +bj-alcomexcom +bj-alequex +bj-alexbiex +bj-alexim +bj-aleximialt +bj-alrim +bj-alrim2 +bj-alrimd +bj-alrimg +bj-andnotim +bj-animbi +bj-ax12 +bj-ax12i +bj-ax12ig +bj-ax12ssb +bj-ax12v +bj-ax12v3 +bj-ax12v3alt +bj-ax12w +bj-ax12wlem +bj-ax5 +bj-ax6e +bj-ax6elem1 +bj-ax6elem2 +bj-ax89 +bj-axadj +bj-axbun +bj-axc10 +bj-axc10v +bj-axc11nv +bj-axc11v +bj-axc14 +bj-axc14nf +bj-axc16g16 +bj-axc4 +bj-axd2d +bj-axdd2 +bj-axdd2alt +bj-axnul +bj-axsn +bj-axtd +bj-babygodel +bj-babylob +bj-bary1 +bj-bary1lem +bj-bary1lem1 +bj-bi3ant +bj-bialal +bj-bibibi +bj-biexal1 +bj-biexal2 +bj-biexal3 +bj-biexex +bj-bijust00 +bj-bijust0alt +bj-bisym +bj-bixor +bj-bm1.3ii +bj-brab2a1 +bj-brrelex12alt +bj-brresdm +bj-cbv1hv +bj-cbv2hv +bj-cbv2v +bj-cbv3hv2 +bj-cbv3ta +bj-cbv3tb +bj-cbval +bj-cbval2vv +bj-cbvaldv +bj-cbvaldvav +bj-cbvalim +bj-cbvalimi +bj-cbvalimt +bj-cbvex +bj-cbvex2vv +bj-cbvex4vv +bj-cbvexdv +bj-cbvexdvav +bj-cbvexim +bj-cbveximi +bj-cbveximt +bj-cbvexivw +bj-cbvexiw +bj-cbvexvv +bj-cbvexw +bj-ccinftydisj +bj-ccinftyssccbar +bj-ccssccbar +bj-ceqsal +bj-ceqsalg +bj-ceqsalg0 +bj-ceqsalgalt +bj-ceqsalgv +bj-ceqsalgvalt +bj-ceqsalt +bj-ceqsalt0 +bj-ceqsalt1 +bj-ceqsaltv +bj-ceqsalv +bj-clel3galt +bj-cleljusti +bj-cleq +bj-clex +bj-clexab +bj-cmnssmnd +bj-cmnssmndel +bj-con2com +bj-con2comi +bj-consensus +bj-consensusalt +bj-csbprc +bj-csbsn +bj-csbsnlem +bj-cur +bj-currypara +bj-currypeirce +bj-curval +bj-denot +bj-denotesaltv +bj-denoteslem +bj-df-ifc +bj-df-sb +bj-dfbi4 +bj-dfbi5 +bj-dfbi6 +bj-dfid2alt +bj-dfif +bj-dfmpoa +bj-dfnnf2 +bj-dfnnf3 +bj-dfsb2 +bj-diagval +bj-diagval2 +bj-discrmoore +bj-disj2r +bj-disjsn01 +bj-drnf2v +bj-dtrucor2v +bj-dvelimdv +bj-dvelimdv1 +bj-dvelimv +bj-dvv +bj-eeanvw +bj-elabd2alt +bj-elabtru +bj-elccinfty +bj-eldiag +bj-eldiag2 +bj-elgab +bj-elid3 +bj-elid4 +bj-elid5 +bj-elid6 +bj-elid7 +bj-elpwg +bj-elpwgalt +bj-elsn0 +bj-elsn12g +bj-elsnb +bj-elsngl +bj-eltag +bj-endbase +bj-endcomp +bj-endmnd +bj-endval +bj-epelb +bj-epelg +bj-eqs +bj-equs45fv +bj-equsal +bj-equsal1 +bj-equsal1t +bj-equsal1ti +bj-equsal2 +bj-equsalhv +bj-equsalvwd +bj-equsexval +bj-equsexvwd +bj-equsvt +bj-eu3f +bj-evaleq +bj-evalfn +bj-evalfun +bj-evalid +bj-evalidval +bj-evalval +bj-exalbial +bj-exalim +bj-exalimi +bj-exalims +bj-exalimsi +bj-exexbiex +bj-eximalt +bj-eximcom +bj-exlimd +bj-exlimg +bj-exlimmpbi +bj-exlimmpbir +bj-exlimmpi +bj-exlimvmpi +bj-fal +bj-falor +bj-falor2 +bj-finsum0 +bj-finsum1 +bj-finsumval0 +bj-finsumval1 +bj-finsumval2 +bj-flddrng +bj-fldssdrng +bj-funidres +bj-funun +bj-fununsn1 +bj-fununsn2 +bj-fvimacnv0 +bj-fvmptunsn1 +bj-fvmptunsn2 +bj-fvsnun1 +bj-fvsnun2 +bj-gabeqd +bj-gabeqis +bj-gabima +bj-gabss +bj-gabssd +bj-genan +bj-genl +bj-genr +bj-gl4 +bj-godellob +bj-grpssmnd +bj-grpssmndel +bj-grur1 +bj-hbaeb +bj-hbaeb2 +bj-hbalt +bj-hbext +bj-hbnaeb +bj-hbntbi +bj-hbs1 +bj-hbsb2av +bj-hbsb3 +bj-hbsb3t +bj-hbsb3v +bj-hbxfrbi +bj-hbyfrbi +bj-ideqb +bj-ideqg +bj-ideqg1 +bj-ideqg1alt +bj-ideqgalt +bj-idres +bj-idreseq +bj-idreseqb +bj-ififc +bj-imafv +bj-imbi12 +bj-imdirco +bj-imdirid +bj-imdiridlem +bj-imdirval +bj-imdirval2 +bj-imdirval2lem +bj-imdirval3 +bj-imdirvallem +bj-imim21 +bj-imim21i +bj-iminvid +bj-iminvval +bj-iminvval2 +bj-imn3ani +bj-inexeqex +bj-inftyexpidisj +bj-inftyexpiinj +bj-inftyexpiinv +bj-inftyexpitaudisj +bj-inftyexpitaufo +bj-inrab +bj-inrab2 +bj-inrab3 +bj-iomnnom +bj-iooshft +bj-isclm +bj-ismoore +bj-ismoored +bj-ismoored0 +bj-ismoored2 +bj-ismooredr +bj-ismooredr2 +bj-isrvec +bj-isrvec2 +bj-isrvecd +bj-isseti +bj-issetiv +bj-issettrualtv +bj-issetw +bj-issetwt +bj-isvec +bj-jaoi1 +bj-jaoi2 +bj-jarrii +bj-lineqi +bj-looinvi +bj-looinvii +bj-minftyccb +bj-minftynrr +bj-mndsssmgrp +bj-mndsssmgrpel +bj-modal4 +bj-modal4e +bj-modalb +bj-modalbe +bj-modald +bj-modid +bj-modssabl +bj-moeub +bj-mooreset +bj-mp2c +bj-mp2d +bj-mpgs +bj-mpomptalt +bj-mpt3mpt +bj-mptval +bj-mptval2 +bj-mt2bi +bj-n0i +bj-ndxarg +bj-nexdh +bj-nexdh2 +bj-nexdt +bj-nexdvt +bj-nexrt +bj-nfald +bj-nfalt +bj-nfcf +bj-nfcsym +bj-nfdt +bj-nfdt0 +bj-nfeel2 +bj-nfexd +bj-nfext +bj-nfimexal +bj-nfimt +bj-nfnnftemp +bj-nfs1 +bj-nfs1t +bj-nfs1t2 +bj-nfs1v +bj-nfsab1 +bj-nimn +bj-nimni +bj-nnclav +bj-nnclavc +bj-nnclavci +bj-nnclavi +bj-nnf-alrim +bj-nnf-exlim +bj-nnfa +bj-nnfa1 +bj-nnfad +bj-nnfai +bj-nnfalt +bj-nnfan +bj-nnfand +bj-nnfbd +bj-nnfbi +bj-nnfbid +bj-nnfbii +bj-nnfbit +bj-nnfe +bj-nnfe1 +bj-nnfea +bj-nnfead +bj-nnfeai +bj-nnfed +bj-nnfei +bj-nnfext +bj-nnfim +bj-nnfim1 +bj-nnfim2 +bj-nnfimd +bj-nnflemaa +bj-nnflemae +bj-nnflemea +bj-nnflemee +bj-nnfnftemp +bj-nnfnt +bj-nnfnth +bj-nnfor +bj-nnford +bj-nnfth +bj-nnftht +bj-nnfv +bj-notalbii +bj-nsnid +bj-ntrufal +bj-nul +bj-nuliota +bj-nuliotaalt +bj-opabco +bj-opabssvv +bj-opelid +bj-opelidb +bj-opelidb1 +bj-opelidb1alt +bj-opelidres +bj-opelopabid +bj-opelrelex +bj-opelresdm +bj-orim2 +bj-peircecurry +bj-peircei +bj-peircestab +bj-pinftyccb +bj-pinftynminfty +bj-pinftynrr +bj-pm11.53a +bj-pm11.53v +bj-pm11.53vw +bj-poni +bj-pr11val +bj-pr1eq +bj-pr1ex +bj-pr1un +bj-pr1val +bj-pr21val +bj-pr22val +bj-pr2eq +bj-pr2ex +bj-pr2un +bj-pr2val +bj-prex +bj-prexg +bj-prfromadj +bj-prmoore +bj-projeq +bj-projeq2 +bj-projex +bj-projun +bj-projval +bj-pw0alt +bj-pwcfsdom +bj-pwvrelb +bj-rababw +bj-rabeqbid +bj-rabtr +bj-rabtralt +bj-rabtrauto +bj-raldifsn +bj-ralvw +bj-rcleq +bj-rcleqf +bj-rdg0galt +bj-reabeq +bj-rest0 +bj-rest00 +bj-rest10 +bj-rest10b +bj-resta +bj-restb +bj-restn0 +bj-restn0b +bj-restpw +bj-restreg +bj-restsn +bj-restsn0 +bj-restsn10 +bj-restsnid +bj-restsnss +bj-restsnss2 +bj-restuni +bj-restuni2 +bj-restv +bj-rexcom4b +bj-rexcom4bv +bj-rexvw +bj-rrdrg +bj-rrhatsscchat +bj-ru +bj-ru1 +bj-rvecabl +bj-rveccmod +bj-rveccvec +bj-rvecmod +bj-rvecrr +bj-rvecssabl +bj-rvecsscmod +bj-rvecsscvec +bj-rvecssmod +bj-rvecssvec +bj-rvecvec +bj-sb +bj-sbceqgalt +bj-sbel1 +bj-sbeq +bj-sbeqalt +bj-sbf3 +bj-sbf4 +bj-sbft +bj-sbidmold +bj-sbievv +bj-sbievw +bj-sbievw1 +bj-sbievw2 +bj-sbievwd +bj-sblem +bj-sblem1 +bj-sblem2 +bj-sbsb +bj-seex +bj-smgrpssmgm +bj-smgrpssmgmel +bj-snex +bj-snexg +bj-snfromadj +bj-snglc +bj-sngleq +bj-snglex +bj-snglinv +bj-snglss +bj-snglsstag +bj-sngltag +bj-sngltagi +bj-snmoore +bj-snmooreb +bj-snsetex +bj-spcimdv +bj-spcimdvv +bj-spimt2 +bj-spimtv +bj-spimvwt +bj-spnfw +bj-spst +bj-spvw +bj-ssbeq +bj-ssbid1 +bj-ssbid1alt +bj-ssbid2 +bj-ssbid2alt +bj-ssblem1 +bj-ssblem2 +bj-sscon +bj-sselpwuni +bj-stabpeirce +bj-stdpc5 +bj-stdpc5t +bj-subcom +bj-subst +bj-substax12 +bj-substw +bj-syl66ib +bj-sylge +bj-sylget +bj-sylget2 +bj-sylggt +bj-sylgt2 +bj-tagcg +bj-tagci +bj-tageq +bj-tagex +bj-taginv +bj-tagn0 +bj-tagss +bj-unexg +bj-unirel +bj-unrab +bj-vecssmod +bj-vecssmodel +bj-velpwalt +bj-vjust +bj-vtocl +bj-vtoclf +bj-vtoclg +bj-vtoclg1f +bj-vtoclg1f1 +bj-vtoclg1fv +bj-vtoclgfalt +bj-wnf1 +bj-wnf2 +bj-wnfanf +bj-wnfenf +bj-wnfnf +bj-xpcossxp +bj-xpexg2 +bj-xpima1sn +bj-xpima1snalt +bj-xpima2sn +bj-xpimasn +bj-xpnzex +bj-xpnzexb +bj-xtageq +bj-xtagex +bj-zfauscl +bl2in +bl2ioo +blaschke +blaschke_univ +blast +blast_intro +blbas +blbnd +blcld +blcls +blcntr +blcntrps +blcom +blcomps +blcvx +bldisj +blelrn +blelrnps +blen0 +blen1 +blen1b +blen2 +blengt1fldiv2p1 +blenn0 +blennn +blennn0e2 +blennn0elnn +blennn0em1 +blennnelnn +blennngt2o2 +blennnt2 +blenpw2 +blenpw2m1 +blenre +blenval +blf +blfps +blfval +blfvalps +blgt0 +blhalf +blin +blin2 +bln0 +blnei +blo3i +block_prev_chain +blockadjliftmap +blocn +blocn2 +blocni +blocnilem +blof +bloln +blometi +blopn +bloval +blpnf +blpnfctr +blres +blrn +blrnps +blsconn +blss +blss2 +blss2ps +blsscls +blsscls2 +blssec +blssex +blssexps +blssioo +blssm +blssopn +blssp +blssps +blval +blval2 +blvalps +bm1.3iiold +bncmet +bncms +bncssbn +bnd +bnd2 +bnd2d +bnd2lem +bndatandm +bndmet +bndndx +bndrank +bndss +bndth +bnj1000 +bnj1001 +bnj1006 +bnj101 +bnj1014 +bnj1015 +bnj1018 +bnj1018g +bnj1019 +bnj1020 +bnj1021 +bnj1023 +bnj1029 +bnj1030 +bnj1033 +bnj1034 +bnj1039 +bnj1040 +bnj1047 +bnj1049 +bnj105 +bnj1052 +bnj1053 +bnj106 +bnj1071 +bnj1083 +bnj1090 +bnj1093 +bnj1095 +bnj1096 +bnj1097 +bnj1098 +bnj110 +bnj1101 +bnj1109 +bnj1110 +bnj1112 +bnj1113 +bnj1118 +bnj1121 +bnj1123 +bnj1124 +bnj1125 +bnj1127 +bnj1128 +bnj1131 +bnj1133 +bnj1136 +bnj1137 +bnj1138 +bnj1142 +bnj1143 +bnj1145 +bnj1146 +bnj1147 +bnj1148 +bnj1149 +bnj115 +bnj1152 +bnj1154 +bnj1171 +bnj1172 +bnj1173 +bnj1174 +bnj1175 +bnj1176 +bnj1177 +bnj118 +bnj1185 +bnj1186 +bnj1189 +bnj1190 +bnj1196 +bnj1198 +bnj1204 +bnj1209 +bnj121 +bnj1211 +bnj1212 +bnj1213 +bnj1219 +bnj1224 +bnj1228 +bnj1230 +bnj1232 +bnj1234 +bnj1235 +bnj1238 +bnj1239 +bnj124 +bnj1241 +bnj1245 +bnj1247 +bnj125 +bnj1253 +bnj1254 +bnj1256 +bnj1259 +bnj126 +bnj1262 +bnj1265 +bnj1266 +bnj1275 +bnj1276 +bnj1279 +bnj1280 +bnj1286 +bnj1292 +bnj1293 +bnj1294 +bnj1296 +bnj1299 +bnj130 +bnj1304 +bnj1307 +bnj1309 +bnj1311 +bnj1312 +bnj1316 +bnj1317 +bnj1318 +bnj132 +bnj1321 +bnj1322 +bnj1326 +bnj133 +bnj1340 +bnj1345 +bnj1350 +bnj1351 +bnj1352 +bnj1361 +bnj1364 +bnj1366 +bnj1371 +bnj1373 +bnj1374 +bnj1379 +bnj1383 +bnj1384 +bnj1385 +bnj1386 +bnj1388 +bnj1397 +bnj1398 +bnj1400 +bnj1405 +bnj1408 +bnj1413 +bnj1414 +bnj1415 +bnj1416 +bnj1417 +bnj1418 +bnj1421 +bnj1422 +bnj1423 +bnj1424 +bnj1436 +bnj1441 +bnj1441g +bnj1442 +bnj1444 +bnj1445 +bnj1446 +bnj1447 +bnj1448 +bnj1449 +bnj1450 +bnj1452 +bnj1454 +bnj1459 +bnj1463 +bnj1464 +bnj1465 +bnj1466 +bnj1467 +bnj1468 +bnj1476 +bnj1489 +bnj149 +bnj1491 +bnj1493 +bnj1497 +bnj1498 +bnj150 +bnj1500 +bnj1501 +bnj1502 +bnj1503 +bnj151 +bnj1514 +bnj1517 +bnj1518 +bnj1519 +bnj1520 +bnj1521 +bnj1522 +bnj1523 +bnj1525 +bnj1529 +bnj153 +bnj1533 +bnj1534 +bnj1536 +bnj1538 +bnj154 +bnj1541 +bnj1542 +bnj155 +bnj156 +bnj157 +bnj158 +bnj168 +bnj170 +bnj18eq1 +bnj206 +bnj207 +bnj213 +bnj216 +bnj219 +bnj222 +bnj226 +bnj228 +bnj229 +bnj23 +bnj240 +bnj248 +bnj250 +bnj251 +bnj252 +bnj253 +bnj255 +bnj256 +bnj257 +bnj258 +bnj268 +bnj290 +bnj291 +bnj31 +bnj312 +bnj334 +bnj345 +bnj422 +bnj432 +bnj446 +bnj517 +bnj518 +bnj519 +bnj523 +bnj524 +bnj525 +bnj526 +bnj528 +bnj529 +bnj534 +bnj535 +bnj538 +bnj539 +bnj540 +bnj543 +bnj544 +bnj545 +bnj546 +bnj548 +bnj551 +bnj553 +bnj554 +bnj556 +bnj557 +bnj558 +bnj561 +bnj562 +bnj563 +bnj564 +bnj570 +bnj571 +bnj579 +bnj580 +bnj581 +bnj589 +bnj590 +bnj591 +bnj593 +bnj594 +bnj596 +bnj60 +bnj600 +bnj601 +bnj602 +bnj605 +bnj607 +bnj609 +bnj610 +bnj611 +bnj62 +bnj642 +bnj643 +bnj645 +bnj658 +bnj66 +bnj667 +bnj69 +bnj705 +bnj706 +bnj707 +bnj708 +bnj721 +bnj769 +bnj770 +bnj771 +bnj832 +bnj835 +bnj836 +bnj837 +bnj849 +bnj852 +bnj864 +bnj865 +bnj873 +bnj882 +bnj887 +bnj89 +bnj893 +bnj90 +bnj900 +bnj906 +bnj907 +bnj908 +bnj91 +bnj910 +bnj911 +bnj916 +bnj917 +bnj918 +bnj919 +bnj92 +bnj923 +bnj927 +bnj929 +bnj93 +bnj931 +bnj934 +bnj937 +bnj938 +bnj941 +bnj944 +bnj945 +bnj946 +bnj95 +bnj951 +bnj953 +bnj956 +bnj958 +bnj96 +bnj964 +bnj965 +bnj966 +bnj967 +bnj969 +bnj97 +bnj970 +bnj976 +bnj978 +bnj98 +bnj981 +bnj982 +bnj983 +bnj984 +bnj985 +bnj985v +bnj986 +bnj996 +bnj998 +bnj999 +bnlmod +bnngp +bnnlm +bnnv +bnnvc +bnrel +bnsca +bnsscmcl +bocardo +bolzano_weierstrass +bolzano_weierstrass1 +bolzano_weierstrass2 +bolzano_weierstrass3 +bolzano_weierstrass4 +bolzano_weierstrass_contrapos +bolzano_weierstrass_imp_bounded +bolzano_weierstrass_imp_closed +bool +bool_cases_tac +bool_to_bit_neq_add +booldec +boolesineq +bor1sal +borel_borel_measurable_preimage +borel_complement +borel_diff +borel_domain_of_injectivity +borel_domain_of_injectivity_continuous +borel_domain_of_injectivity_continuous_gen +borel_empty +borel_imp_analytic +borel_imp_lebesgue_measurable +borel_induct_closed_unions_inters +borel_induct_compact +borel_induct_compact_alt +borel_induct_compact_diff +borel_induct_compact_unions_inters +borel_induct_unions_inters +borel_inter +borel_inters +borel_linear_image +borel_measurable_add +borel_measurable_bilinear +borel_measurable_cases +borel_measurable_cmul +borel_measurable_componentwise +borel_measurable_compose +borel_measurable_const +borel_measurable_continuous_compose +borel_measurable_eq +borel_measurable_extension +borel_measurable_imp_measurable_on +borel_measurable_indicator +borel_measurable_max +borel_measurable_min +borel_measurable_mul +borel_measurable_norm +borel_measurable_on_indicator +borel_measurable_on_subset +borel_measurable_pastecart +borel_measurable_preimage_borel +borel_measurable_product +borel_measurable_restrict +borel_measurable_sub +borel_measurable_vsum +borel_pcross +borel_pcross_eq +borel_points_of_differentiability +borel_preimage_finite +borel_preimage_has_size +borel_preimage_infinite +borel_translation +borel_union +borel_unions +borel_univ +borelmbl +bormflebmf +borrow +botel +both_sides_abs_neg +both_sides_abs_neg_le +both_sides_abs_nnreal +both_sides_abs_nnreal_le +bothfbothsame +bothtbothsame +bound_power_residues_modulo_odd_coprime +bounded_add +bounded_affinity +bounded_affinity_eq +bounded_and_diameter_le +bounded_ball +bounded_cball +bounded_closed_chain +bounded_closed_imp_compact +bounded_closed_interval +bounded_closed_nest +bounded_closure +bounded_closure_eq +bounded_componentwise +bounded_convex_hull +bounded_convex_hull_eq +bounded_decreasing_convergent +bounded_delete +bounded_diff +bounded_diffs +bounded_empty +bounded_eq_bolzano_weierstrass +bounded_eq_totally_bounded +bounded_exists_thm +bounded_forall_thm +bounded_frontier +bounded_functions_bijections_1 +bounded_functions_bijections_2 +bounded_halfspace_ge +bounded_halfspace_gt +bounded_halfspace_le +bounded_halfspace_lt +bounded_has_inf +bounded_has_sup +bounded_hyperplane_eq_trivial +bounded_image_in_compactification +bounded_increasing_convergent +bounded_insert +bounded_inside +bounded_integrals_over_subintervals +bounded_inter +bounded_interior +bounded_inters +bounded_interval +bounded_length_finite +bounded_lift +bounded_linear_image +bounded_linear_image_eq +bounded_lipschitz_image +bounded_nat_add +bounded_negations +bounded_norm_image +bounded_pairs +bounded_pairs_pos +bounded_partial_sums +bounded_path_image +bounded_pcross +bounded_pcross_eq +bounded_pos +bounded_pos_lt +bounded_rectifiable_path_image +bounded_relative_frontier +bounded_relative_interior +bounded_scaling +bounded_scaling_eq +bounded_search +bounded_segment +bounded_separation_1d +bounded_set_variation_from_pastecart +bounded_set_variation_on_pastecart +bounded_setvariation_absolutely_integrable +bounded_sing +bounded_sphere +bounded_subset +bounded_subset_ball +bounded_subset_cball +bounded_subset_closed_interval +bounded_subset_closed_interval_symmetric +bounded_subset_open_interval +bounded_subset_open_interval_symmetric +bounded_sums +bounded_sums_image +bounded_sums_images +bounded_translation +bounded_translation_eq +bounded_uniformly_continuous_image +bounded_union +bounded_unions +bounded_variation_from_pastecart +bounded_vector_variation_on_pastecart +boundedint +boundedsearch +box_elim +boxcutc +boxriin +boyer_moore +bpoly0 +bpoly1 +bpoly2 +bpoly3 +bpoly4 +bpolycl +bpolydif +bpolydiflem +bpolylem +bpolysum +bpolyval +bpos +bpos1 +bpos1lem +bposlem1 +bposlem2 +bposlem3 +bposlem4 +bposlem5 +bposlem6 +bposlem7 +bposlem8 +bposlem9 +br0 +br1cnvinxp +br1cnvres +br1cnvssrres +br1cnvxrn2 +br1cosscnvxrn +br1cossincnvepres +br1cossinidres +br1cossinres +br1cossres +br1cossres2 +br1cossxrncnvepres +br1cossxrncnvssrres +br1cossxrnidres +br1cossxrnres +br1steq +br1steqg +br2base +br2coss +br2ndeq +br2ndeqg +br4 +br6 +br8 +br8d +bra0 +bra11 +braadd +brab +brab1 +brab2a +brab2d +brab2dd +brab2ddw +brab2ddw2 +braba +brabd +brabd0 +brabg +brabg2 +brabga +brabgaf +brabidga +brabidgaw +brabn +brabsb +brabsb2 +brabv +bracl +bracnln +bracnlnval +bracnvbra +brae +braew +brafn +brafnmul +brafs +brafval +bralgext +bralnfn +bramul +branmfn +brapply +braval +brbigcup +brbtwn +brbtwn2 +brcap +brcart +brcgr +brcgr3 +brcic +brcici +brcnv +brcnvep +brcnvepres +brcnvg +brcnvin +brcnvrabga +brcnvssr +brcnvssrid +brcnvtrclfv +brcnvtrclfv2 +brcnvtrclfvcnv +brco +brco2f1o +brco3f1o +brcodir +brcoels +brcofffn +brcoffn +brcog +brcogw +brcolinear +brcolinear2 +brcoss +brcoss2 +brcoss3 +brcosscnv +brcosscnv2 +brcosscnvcoss +brcup +brdif +brdifun +brdmqss +brdmqssqs +brdom +brdom2 +brdom2g +brdom3 +brdom4 +brdom5 +brdom6disj +brdom7disj +brdomain +brdomaing +brdomg +brdomi +brecop +brecop2 +brel +breldm +breldmd +breldmg +brelg +brelrn +brelrng +bren +bren2 +breng +breprexp +breprexplema +breprexplemb +breprexplemc +breprexpnat +breq +breq1 +breq12 +breq123d +breq12d +breq12i +breq1d +breq1dd +breq1i +breq2 +breq2d +breq2dd +breq2i +breqan12d +breqan12rd +breqd +breqdi +breqi +breqtrd +breqtrdi +breqtri +breqtrid +breqtrrd +breqtrrdi +breqtrri +breqtrrid +brers +brerser +brfae +brfi1ind +brfi1indalt +brfi1uzind +brfinext +brfldext +brfs +brfullfun +brfvid +brfvidrp +brfvimex +brfvopab +brfvopabrbr +brfvrcld +brfvrcld2 +brfvrtrcld +brfvtrcld +brgic +brgici +brgric +brgrici +brgrilci +brgrlic +brid +brif1 +brif12 +brif2 +brifs +brifs2 +brimage +brimageg +brimg +brimralrspcev +brin +brin2 +brin3 +brintclab +brinxp +brinxp2 +brinxper +brinxprnres +briunov2 +briunov2uz +brlb +brlmic +brlmici +brmptiunrelexpd +brne0 +brneqtrd +brnonrel +brofs +brofs2 +bropabg +bropaex12 +bropfvvvv +bropfvvvvlem +bropopvvv +broucube +broutsideof +broutsideof2 +broutsideof3 +brouwer +brouwer_continuity +brouwer_fixed_point +brouwer_reduction_theorem +brouwer_reduction_theorem_gen +brouwer_surjective +brouwer_surjective_cball +brovex +brovmpoex +brovmptimex +brovmptimex1 +brovmptimex2 +brovpreldm +brparts +brparts2 +brpartspart +brpermmodel +brpermmodelcnv +brpprod +brpprod3a +brpprod3b +brprcneu +brprcneualt +brprop +brrabga +brralrspcev +brrange +brrangeg +brredunds +brredundsredund +brrelex1 +brrelex12 +brrelex12i +brrelex1i +brrelex2 +brrelex2i +brres +brres2 +brresi +brresi2 +brressn +brrestrict +brric +brric2 +brrici +brrpss +brrpssg +brrtrclrec +brsdom +brsdom2 +brsegle +brsegle2 +brsiga +brsigarn +brsigasspwrn +brsingle +brslts +brsnop +brssc +brsset +brssr +brssrid +brssrres +brstruct +brsuccf +brsucmap +brsymdif +brtp +brtpid1 +brtpid2 +brtpid3 +brtpos +brtpos0 +brtpos2 +brtrclfv +brtrclfv2 +brtrclfvcnv +brtrclrec +brttrcl +brttrcl2 +brtxp +brtxp2 +brtxpsd +brtxpsd2 +brtxpsd3 +brub +bruijn +brun +brv +brvbrvvdif +brvdif +brvdif2 +brvvdif +brwdom +brwdom2 +brwdom3 +brwdom3i +brwdomi +brwdomn0 +brwitnlem +brxp +brxrn +brxrn2 +brxrncnvep +bsearch-correct +bsearch_correct +bst_inorder_sorted +bst_insert_ordered +bst_insert_preserves +bst_invariant +bst_member_after_insert +bstinsert +bstsearch +btwncolg1 +btwncolg2 +btwncolg3 +btwncolinear1 +btwncolinear2 +btwncolinear3 +btwncolinear4 +btwncolinear5 +btwncolinear6 +btwncom +btwncomand +btwncomim +btwnconn1 +btwnconn1lem1 +btwnconn1lem10 +btwnconn1lem11 +btwnconn1lem12 +btwnconn1lem13 +btwnconn1lem14 +btwnconn1lem2 +btwnconn1lem3 +btwnconn1lem4 +btwnconn1lem5 +btwnconn1lem6 +btwnconn1lem7 +btwnconn1lem8 +btwnconn1lem9 +btwnconn2 +btwnconn3 +btwndiff +btwnexch +btwnexch2 +btwnexch3 +btwnexch3and +btwnexchand +btwnhl +btwnhl1 +btwnhl2 +btwnintr +btwnleg +btwnlng1 +btwnlng2 +btwnlng3 +btwnnz +btwnoutside +btwnouttr +btwnouttr2 +btwnsegle +btwnswapid +btwnswapid2 +btwntriv1 +btwntriv2 +btwnxfr +btwnz +btwnzge0 +buffer_as_seq_gsub +buffer_concat +buffer_disjoint +buffer_frame +buffer_length_gsub +buffer_live +buffer_loc_disjoint +buffer_modifies_only +buffer_read_write +butlast +butlast_append +bv0 +bvadd +bvand +bvxor +bwth +by +bycontradiction +bytes_of_u32 +c +c0ex +c0exalt +c0ghm +c0mgm +c0mhm +c0rhm +c0rnghm +c0snghm +c0snmgmhm +c0snmhm +c1lip1 +c1lip2 +c1lip3 +c1liplem1 +cad0 +cad1 +cad11 +cadan +cadbi123d +cadbi123i +cadcoma +cadcomb +cadifp +cadnot +cador +cadrot +cadtru +calemes +calemos +camestres +camestros +cancel +cancel-equal-lognot +cancel-equal-lognotu +cancel_sub +canon_semiring +canonical +canonical_forms +canth +canth2 +canth2g +canth3 +canth4 +canthnum +canthnumlem +canthp1 +canthp1lem1 +canthp1lem2 +canthwdom +canthwe +canthwelem +cantnf +cantnf0 +cantnf2 +cantnfcl +cantnfdm +cantnff +cantnff1o +cantnffval +cantnffval2 +cantnfle +cantnflem1 +cantnflem1a +cantnflem1b +cantnflem1c +cantnflem1d +cantnflem2 +cantnflem3 +cantnflem4 +cantnflt +cantnflt2 +cantnfp1 +cantnfp1lem1 +cantnfp1lem2 +cantnfp1lem3 +cantnfres +cantnfresb +cantnfrescl +cantnfs +cantnfsuc +cantnftermord +cantnfub +cantnfub2 +cantnfval +cantnfval2 +cantnfvalf +cantor_baire_stationary_principle +cantor_bendixson +cantor_bendixson_gen +caofass +caofcan +caofcom +caofdi +caofdir +caofid0l +caofid0r +caofid1 +caofid2 +caofidlcan +caofinvl +caofref +caofrss +caoftrn +caonncan +caov12 +caov12d +caov13 +caov13d +caov31 +caov31d +caov32 +caov32d +caov4 +caov411 +caov411d +caov42 +caov42d +caov4d +caovass +caovassd +caovassg +caovcan +caovcand +caovcang +caovcanrd +caovcl +caovcld +caovclg +caovcom +caovcomd +caovcomg +caovdi +caovdid +caovdig +caovdilem +caovdir +caovdir2d +caovdird +caovdirg +caovlem2 +caovmo +caovord +caovord2 +caovord2d +caovord3 +caovord3d +caovordd +caovordg +caovordid +caovordig +capture_avoid +car-cons +car-of-append +caragen0 +caragencmpl +caragendifcl +caragenel +caragenel2d +carageneld +caragenelss +caragenfiiuncl +carageniuncl +carageniuncllem1 +carageniuncllem2 +caragensal +caragensplit +caragenss +caragensspw +caragenuncl +caragenuncllem +caragenuni +caragenunicl +caragenunidm +caragenval +caratheodory +caratheodory_aff_dim +caratheodorylem1 +caratheodorylem2 +card +card0 +card1 +card2inf +card2on +card_add_absorb_left +card_add_finite_eq +card_as_sigma +card_bigunion_same_sized_sets +card_clauses +card_columns_le +card_countable_cong +card_cross +card_delete +card_diff +card_diff_eqn +card_eq_0 +card_eq_analytic_sets +card_eq_baire_functions +card_eq_ball +card_eq_bijections +card_eq_borel_measurable_functions +card_eq_borel_sets +card_eq_card +card_eq_cart +card_eq_cball +card_eq_closed_sets +card_eq_compact_sets +card_eq_condensation_points_in_set +card_eq_connected +card_eq_dim +card_eq_euclidean +card_eq_fsigma_sets +card_eq_gdelta_sets +card_eq_image +card_eq_imp_le +card_eq_interval +card_eq_open +card_eq_open_sets +card_eq_real_imp_uncountable +card_eq_sigma +card_eq_sym +card_eq_trans +card_faces_of_simplex +card_finite_cong +card_ge_dim_independent +card_image +card_image_eq_inj +card_image_inj +card_image_le +card_image_suc +card_inj_image +card_inter_less_eq +card_le_antisym +card_le_components_closure_frontier +card_le_components_frontier +card_le_components_union +card_le_countable +card_le_dim_spanning +card_le_finite +card_le_inj +card_le_max_set +card_le_powerset +card_le_relational_full +card_le_subset +card_le_trans +card_le_univ +card_let_trans +card_list_to_set +card_list_to_set_all_distinct +card_list_to_set_eqn +card_lt_imp_disconnected +card_mul_lt_infinite +card_not_le +card_not_lt +card_numseg +card_numseg_lt +card_pow +card_product +card_psubset +card_psubset_imp +card_rest +card_rows_le +card_sing +card_sing_cross +card_stdbasis +card_subset +card_suslin_eq +card_union +card_union_disjoint +card_union_eqn +card_union_le +cardadju +cardaleph +cardalephex +cardcf +carddom +carddom2 +carddomi2 +carden +carden2 +carden2a +carden2b +cardennn +cardeq0 +cardeqv +cardf +cardf2 +cardfz +cardid +cardid2 +cardidd +cardidg +cardidm +cardinal_union +cardinfima +cardiun +cardlim +cardmin +cardmin2 +cardne +cardnn +cardnueq0 +cardnum +cardom +cardon +cardonle +cardprc +cardprclem +cardpred +cardsdom +cardsdom2 +cardsdomel +cardsdomelir +cardsn +cardsucinf +cardsucnn +carduni +carduniima +cardval +cardval2 +cardval3 +carsgcl +carsgclctun +carsgclctunlem1 +carsgclctunlem2 +carsgclctunlem3 +carsggect +carsgmon +carsgsiga +carsgsigalem +carsguni +carsgval +cart2_eq_full +cart_eq +cart_eq_full +cas_success +case +case_tac +caseanalysis +caseanalysis `p(hd)` +caseanalysis `x >= 0` +caseanalysis `y >= 0` +casegcd +cases +cases p +cases2 +cases2alt +cases_lemma +cases_on +cases_quick +casesifp +cast_u8_u32 +cat1 +cat1lem +cat_comp_assoc +cat_id_left +cat_id_right +catass +catassoc +catbas +catcbas +catcbascl +catcbaselcl +catccat +catccatid +catcccocl +catcco +catccofval +catcfuccl +catchom +catchomcl +catchomfval +catcid +catcinv +catciso +catcisoi +catcisolem +catcocl +catcofval +catcone0 +catcoppccl +catcrcl +catcrcl2 +catcsect +catcslotelcl +catcval +catcxpccl +cathomfval +catidcl +catidd +catideu +catidex +catidleft +catidright +catlid +catpropd +catprs +catprs2 +catprsc +catprsc2 +catprslem +catrid +cats1cat +cats1cld +cats1cli +cats1co +cats1fv +cats1fvn +cats1len +cats1un +cats2cat +catstr +catsubcat +cau3 +cau3lem +cau4 +caubl +caublcls +caubnd +caubnd2 +caucfil +cauchy +cauchy_absolutely_summable_subsequence +cauchy_accumulation +cauchy_bounded +cauchy_complete +cauchy_continuous_eq_extends_to_closure +cauchy_continuous_extends_to_closure +cauchy_continuous_imp_continuous +cauchy_continuous_map_compose +cauchy_continuous_map_pasted +cauchy_continuous_map_pastewise +cauchy_convergent +cauchy_convergent_subsequence +cauchy_eq_summable +cauchy_imp_bounded +cauchy_in_euclidean +cauchy_in_imp_mbounded +cauchy_in_submetric +cauchy_isometric +cauchy_offset +cauchy_schwarz +cauchy_schwarz_1d +cauchy_subsequence +caucvg +caucvgb +caucvgbf +caucvgr +caucvgrlem +caucvgrlem2 +caufpm +caufval +caun0 +caurcvg +caurcvg2 +caurcvgr +caures +caushft +causs +caussi +cayhamlem1 +cayhamlem2 +cayhamlem3 +cayhamlem4 +cayley +cayleyhamilton +cayleyhamilton0 +cayleyhamilton1 +cayleyhamiltonalt +cayleylem1 +cayleylem2 +cayleyth +cball_diff_ball +cball_diff_sphere +cball_empty +cball_eq_empty +cball_eq_sing +cball_interval +cball_interval_0 +cball_linear_image +cball_max_union +cball_min_inter +cball_scaling +cball_sing +cball_translation +cball_trivial +cbncms +cbv1 +cbv1h +cbv1v +cbv2 +cbv2h +cbv2w +cbv3 +cbv3h +cbv3hv +cbv3v +cbv3v2 +cbvab +cbvabdavw +cbvabv +cbvabw +cbvaev +cbval +cbval2 +cbval2v +cbval2vv +cbval2vw +cbvald +cbvaldva +cbvaldvaw +cbvaldw +cbvalivw +cbvaliw +cbvalv +cbvalv1 +cbvalvw +cbvalw +cbvcllem +cbvcsb +cbvcsbdavw +cbvcsbdavw2 +cbvcsbv +cbvcsbvw2 +cbvcsbw +cbvdisj +cbvdisjdavw +cbvdisjdavw2 +cbvdisjf +cbvdisjv +cbvdisjvw2 +cbvditg +cbvditgdavw +cbvditgdavw2 +cbvditgv +cbvditgvw2 +cbvesum +cbvesumv +cbveu +cbveualt +cbveud +cbveudavw +cbveuvw +cbveuw +cbvex +cbvex1v +cbvex2 +cbvex2v +cbvex2vv +cbvex2vw +cbvex4v +cbvex4vw +cbvexd +cbvexdva +cbvexdvaw +cbvexdw +cbvexeqsetf +cbvexfo +cbvexsv +cbvexv +cbvexv1 +cbvexvw +cbvfo +cbviin +cbviindavw +cbviindavw2 +cbviing +cbviinv +cbviinvg +cbviinvw2 +cbviota +cbviotadavw +cbviotav +cbviotavw +cbviotaw +cbvitg +cbvitgdavw +cbvitgdavw2 +cbvitgv +cbvitgvw2 +cbviun +cbviundavw +cbviundavw2 +cbviuneq12df +cbviuneq12dv +cbviunf +cbviung +cbviunv +cbviunvg +cbviunvw2 +cbvixp +cbvixpdavw +cbvixpdavw2 +cbvixpv +cbvixpvw2 +cbvmo +cbvmodavw +cbvmovw +cbvmow +cbvmpo +cbvmpo1 +cbvmpo1davw2 +cbvmpo1vw2 +cbvmpo2 +cbvmpo2davw2 +cbvmpo2vw2 +cbvmpodavw2 +cbvmpov +cbvmpovw2 +cbvmpox +cbvmpox2 +cbvmpt +cbvmptdavw +cbvmptdavw2 +cbvmptf +cbvmptfg +cbvmptg +cbvmptv +cbvmptvg +cbvmptvw2 +cbvopab +cbvopab1 +cbvopab1davw +cbvopab1g +cbvopab1s +cbvopab1v +cbvopab2 +cbvopab2davw +cbvopab2v +cbvopabdavw +cbvopabv +cbvoprab1 +cbvoprab12 +cbvoprab123davw +cbvoprab123vw +cbvoprab12davw +cbvoprab12v +cbvoprab13davw +cbvoprab13vw +cbvoprab1davw +cbvoprab1vw +cbvoprab2 +cbvoprab23davw +cbvoprab23vw +cbvoprab2davw +cbvoprab2vw +cbvoprab3 +cbvoprab3davw +cbvoprab3v +cbvprod +cbvproddavw +cbvproddavw2 +cbvprodi +cbvprodv +cbvprodvw2 +cbvrab +cbvrabcsf +cbvrabcsfw +cbvrabdavw +cbvrabdavw2 +cbvrabv +cbvrabv2 +cbvrabv2w +cbvrabw +cbvrabwold +cbvral +cbvral2 +cbvral2v +cbvral2vw +cbvral3v +cbvral3vw +cbvral4vw +cbvral6vw +cbvral8vw +cbvralcsf +cbvraldva +cbvraldva2 +cbvraldvaold +cbvralf +cbvralfw +cbvralsv +cbvralsvw +cbvralsvwold +cbvralsvwoldold +cbvralv +cbvralv2 +cbvralvw +cbvralvw2 +cbvralw +cbvreu +cbvreucsf +cbvreud +cbvreudavw +cbvreudavw2 +cbvreuv +cbvreuvw +cbvreuvw2 +cbvreuw +cbvrex +cbvrex2 +cbvrex2v +cbvrex2vw +cbvrexcsf +cbvrexdva +cbvrexdva2 +cbvrexdvaold +cbvrexf +cbvrexfw +cbvrexsv +cbvrexsvw +cbvrexsvwold +cbvrexv +cbvrexv2 +cbvrexvw +cbvrexvw2 +cbvrexw +cbvriota +cbvriotadavw +cbvriotadavw2 +cbvriotav +cbvriotavw +cbvriotavw2 +cbvriotaw +cbvrmo +cbvrmodavw +cbvrmodavw2 +cbvrmov +cbvrmovw +cbvrmovw2 +cbvrmow +cbvsbc +cbvsbcdavw +cbvsbcdavw2 +cbvsbcv +cbvsbcvw +cbvsbcvw2 +cbvsbcw +cbvsbdavw +cbvsbdavw2 +cbvsbv +cbvsbvf +cbvsum +cbvsumdavw +cbvsumdavw2 +cbvsumv +cbvsumvw2 +ccase +ccase2 +ccased +ccat0 +ccat1st1st +ccat2s1cl +ccat2s1fst +ccat2s1fvw +ccat2s1fvwalt +ccat2s1len +ccat2s1p1 +ccat2s1p2 +ccatalpha +ccatass +ccatcan2d +ccatcl +ccatco +ccatdmss +ccatf1 +ccatfn +ccatfv0 +ccatfval +ccatidid +ccatlcan +ccatlen +ccatlid +ccatmulgnn0dir +ccatopth +ccatopth2 +ccatpfx +ccatrcan +ccatrcl1 +ccatrid +ccatrn +ccats1alpha +ccats1pfxeq +ccats1pfxeqbi +ccats1pfxeqrex +ccats1val1 +ccats1val2 +ccatswrd +ccatsymb +ccatval1 +ccatval1lsw +ccatval2 +ccatval21sw +ccatval3 +ccatvalfn +ccatw2s1ass +ccatw2s1ccatws2 +ccatw2s1cl +ccatw2s1len +ccatw2s1p1 +ccatw2s1p2 +ccatws1cl +ccatws1clv +ccatws1f1o +ccatws1f1olast +ccatws1len +ccatws1lenp1b +ccatws1ls +ccatws1n0 +ccfldextdgrr +ccfldextrr +ccfldsrarelvec +cchhllem +ccoid +ccondx +ccontr_tac +cctop +cdaf +cdainflem +cdeqab +cdeqab1 +cdeqal +cdeqal1 +cdeqcv +cdeqel +cdeqeq +cdeqi +cdeqim +cdeqnot +cdeqri +cdeqth +cdivcncf +cdj1i +cdj3i +cdj3lem1 +cdj3lem2 +cdj3lem2a +cdj3lem2b +cdj3lem3 +cdj3lem3a +cdj3lem3b +cdjreui +cdlema1n +cdlema2n +cdlemb +cdlemb2 +cdlemb3 +cdlemblem +cdlemc +cdlemc1 +cdlemc2 +cdlemc3 +cdlemc4 +cdlemc5 +cdlemc6 +cdlemd +cdlemd1 +cdlemd2 +cdlemd3 +cdlemd4 +cdlemd5 +cdlemd6 +cdlemd7 +cdlemd8 +cdlemd9 +cdleme +cdleme00a +cdleme01n +cdleme02n +cdleme0a +cdleme0aa +cdleme0b +cdleme0c +cdleme0cp +cdleme0cq +cdleme0dn +cdleme0e +cdleme0ex1n +cdleme0ex2n +cdleme0fn +cdleme0gn +cdleme0mon +cdleme0nex +cdleme1 +cdleme10 +cdleme10tn +cdleme11 +cdleme11a +cdleme11c +cdleme11dn +cdleme11e +cdleme11fn +cdleme11g +cdleme11h +cdleme11j +cdleme11k +cdleme11l +cdleme12 +cdleme13 +cdleme14 +cdleme15 +cdleme15a +cdleme15b +cdleme15c +cdleme15d +cdleme16 +cdleme16an +cdleme16b +cdleme16c +cdleme16d +cdleme16e +cdleme16f +cdleme16g +cdleme17a +cdleme17b +cdleme17c +cdleme17d +cdleme17d1 +cdleme17d2 +cdleme17d3 +cdleme17d4 +cdleme18a +cdleme18b +cdleme18c +cdleme18d +cdleme19a +cdleme19b +cdleme19c +cdleme19d +cdleme19e +cdleme19f +cdleme1b +cdleme2 +cdleme20 +cdleme20an +cdleme20bn +cdleme20c +cdleme20d +cdleme20e +cdleme20f +cdleme20g +cdleme20h +cdleme20i +cdleme20j +cdleme20k +cdleme20l +cdleme20l1 +cdleme20l2 +cdleme20m +cdleme20y +cdleme20zn +cdleme21 +cdleme21a +cdleme21at +cdleme21b +cdleme21c +cdleme21ct +cdleme21d +cdleme21e +cdleme21f +cdleme21g +cdleme21h +cdleme21i +cdleme21j +cdleme21k +cdleme22a +cdleme22aa +cdleme22b +cdleme22cn +cdleme22d +cdleme22e +cdleme22ealtn +cdleme22f +cdleme22f2 +cdleme22g +cdleme22gb +cdleme23a +cdleme23b +cdleme23c +cdleme24 +cdleme25a +cdleme25b +cdleme25c +cdleme25cl +cdleme25cv +cdleme25dn +cdleme26e +cdleme26ealtn +cdleme26ee +cdleme26f +cdleme26f2 +cdleme26f2altn +cdleme26faltn +cdleme27a +cdleme27b +cdleme27cl +cdleme27n +cdleme28 +cdleme28a +cdleme28b +cdleme28c +cdleme29b +cdleme29c +cdleme29cl +cdleme29ex +cdleme3 +cdleme30a +cdleme31fv +cdleme31fv1 +cdleme31fv1s +cdleme31fv2 +cdleme31id +cdleme31sc +cdleme31sde +cdleme31sdnn +cdleme31se +cdleme31se2 +cdleme31sn +cdleme31sn1 +cdleme31sn1c +cdleme31sn1sv +cdleme31sn2 +cdleme31snd +cdleme31so +cdleme32a +cdleme32b +cdleme32c +cdleme32d +cdleme32e +cdleme32f +cdleme32fva +cdleme32fva1 +cdleme32fvaw +cdleme32fvcl +cdleme32le +cdleme32sn1awn +cdleme32sn2awn +cdleme32snaw +cdleme32snb +cdleme35a +cdleme35b +cdleme35c +cdleme35d +cdleme35e +cdleme35f +cdleme35fnpq +cdleme35g +cdleme35h +cdleme35h2 +cdleme35sn2aw +cdleme35sn3a +cdleme36a +cdleme36m +cdleme37m +cdleme38m +cdleme38n +cdleme39a +cdleme39n +cdleme3b +cdleme3c +cdleme3d +cdleme3e +cdleme3fa +cdleme3fn +cdleme3g +cdleme3h +cdleme4 +cdleme40m +cdleme40n +cdleme40v +cdleme40w +cdleme41fva11 +cdleme41sn3a +cdleme41sn3aw +cdleme41sn4aw +cdleme41snaw +cdleme42a +cdleme42b +cdleme42c +cdleme42d +cdleme42e +cdleme42f +cdleme42g +cdleme42h +cdleme42i +cdleme42k +cdleme42ke +cdleme42keg +cdleme42mgn +cdleme42mn +cdleme43an +cdleme43bn +cdleme43cn +cdleme43dn +cdleme43frv1snn +cdleme43fsv1sn +cdleme43fsv1snlem +cdleme46f2g1 +cdleme46f2g2 +cdleme46frvlpq +cdleme46fsvlpq +cdleme46fvaw +cdleme48b +cdleme48bw +cdleme48d +cdleme48fgv +cdleme48fv +cdleme48fvg +cdleme48gfv +cdleme48gfv1 +cdleme4a +cdleme4gfv +cdleme5 +cdleme50eq +cdleme50ex +cdleme50f +cdleme50f1 +cdleme50f1o +cdleme50laut +cdleme50ldil +cdleme50lebi +cdleme50ltrn +cdleme50rn +cdleme50rnlem +cdleme50trn1 +cdleme50trn12 +cdleme50trn123 +cdleme50trn2 +cdleme50trn2a +cdleme50trn3 +cdleme51finvfvn +cdleme51finvn +cdleme51finvtrn +cdleme6 +cdleme7 +cdleme7a +cdleme7aa +cdleme7b +cdleme7c +cdleme7d +cdleme7e +cdleme7ga +cdleme8 +cdleme8tn +cdleme9 +cdleme9a +cdleme9b +cdleme9tan +cdleme9tn +cdlemeda +cdlemedb +cdlemednpq +cdlemednun +cdlemefr27cl +cdlemefr29bpre0n +cdlemefr29cln +cdlemefr29exn +cdlemefr31fv1 +cdlemefr32fva1 +cdlemefr32fvan +cdlemefr32sn2aw +cdlemefr32snb +cdlemefr44 +cdlemefr45 +cdlemefr45e +cdlemefrs29bpre0 +cdlemefrs29bpre1 +cdlemefrs29cln +cdlemefrs29cpre1 +cdlemefrs29pre00 +cdlemefrs32fva +cdlemefrs32fva1 +cdlemefs27cl +cdlemefs29bpre0n +cdlemefs29bpre1n +cdlemefs29cln +cdlemefs29cpre1n +cdlemefs29pre00n +cdlemefs31fv1 +cdlemefs32fva1 +cdlemefs32fvan +cdlemefs32sn1aw +cdlemefs32snb +cdlemefs44 +cdlemefs45 +cdlemefs45ee +cdlemefs45en +cdlemeg46boldn +cdlemeg46c +cdlemeg46fgn +cdlemeg46fjgn +cdlemeg46fjv +cdlemeg46frv +cdlemeg46fsfv +cdlemeg46fvaw +cdlemeg46fvcl +cdlemeg46gf +cdlemeg46gfr +cdlemeg46gfre +cdlemeg46gfv +cdlemeg46nfgr +cdlemeg46ngfr +cdlemeg46nlpq +cdlemeg46req +cdlemeg46rgv +cdlemeg46rjgn +cdlemeg46rv2oldn +cdlemeg46rvoldn +cdlemeg46sfg +cdlemeg46v1v2 +cdlemeg46vrg +cdlemeg47b +cdlemeg47rv +cdlemeg47rv2 +cdlemeg49le +cdlemeg49lebilem +cdlemeiota +cdlemesner +cdlemeulpq +cdlemf +cdlemf1 +cdlemf2 +cdlemfnid +cdlemftr0 +cdlemftr1 +cdlemftr2 +cdlemftr3 +cdlemg10 +cdlemg10a +cdlemg10b +cdlemg10baltn +cdlemg10c +cdlemg11a +cdlemg11aq +cdlemg11b +cdlemg12 +cdlemg12a +cdlemg12b +cdlemg12c +cdlemg12d +cdlemg12e +cdlemg12f +cdlemg12g +cdlemg13 +cdlemg13a +cdlemg14f +cdlemg14g +cdlemg15 +cdlemg15a +cdlemg16 +cdlemg16altn +cdlemg16z +cdlemg16zz +cdlemg17 +cdlemg17a +cdlemg17b +cdlemg17bq +cdlemg17daltn +cdlemg17dn +cdlemg17e +cdlemg17f +cdlemg17g +cdlemg17h +cdlemg17i +cdlemg17iqn +cdlemg17ir +cdlemg17irq +cdlemg17j +cdlemg17jq +cdlemg17pq +cdlemg18 +cdlemg18a +cdlemg18b +cdlemg18c +cdlemg18d +cdlemg19 +cdlemg19a +cdlemg1a +cdlemg1b2 +cdlemg1cex +cdlemg1ci2 +cdlemg1cn +cdlemg1finvtrlemn +cdlemg1fvawlemn +cdlemg1idlemn +cdlemg1idn +cdlemg1ltrnlem +cdlemg20 +cdlemg21 +cdlemg22 +cdlemg24 +cdlemg25zz +cdlemg26zz +cdlemg27a +cdlemg27b +cdlemg28 +cdlemg28a +cdlemg28b +cdlemg29 +cdlemg2ce +cdlemg2cex +cdlemg2cn +cdlemg2dn +cdlemg2fv +cdlemg2fv2 +cdlemg2fvlem +cdlemg2idn +cdlemg2jlemoldn +cdlemg2joldn +cdlemg2k +cdlemg2klem +cdlemg2kq +cdlemg2l +cdlemg2m +cdlemg31a +cdlemg31b +cdlemg31b0a +cdlemg31b0n +cdlemg31c +cdlemg31d +cdlemg33 +cdlemg33a +cdlemg33b +cdlemg33b0 +cdlemg33c +cdlemg33c0 +cdlemg33d +cdlemg33e +cdlemg34 +cdlemg35 +cdlemg36 +cdlemg37 +cdlemg38 +cdlemg39 +cdlemg3a +cdlemg4 +cdlemg40 +cdlemg41 +cdlemg42 +cdlemg43 +cdlemg44 +cdlemg44a +cdlemg44b +cdlemg46 +cdlemg47 +cdlemg47a +cdlemg48 +cdlemg4a +cdlemg4b1 +cdlemg4b12 +cdlemg4b2 +cdlemg4c +cdlemg4d +cdlemg4e +cdlemg4f +cdlemg4g +cdlemg5 +cdlemg6 +cdlemg6a +cdlemg6b +cdlemg6c +cdlemg6d +cdlemg6e +cdlemg7an +cdlemg7fvbwn +cdlemg7fvn +cdlemg7n +cdlemg8 +cdlemg8a +cdlemg8b +cdlemg8c +cdlemg8d +cdlemg9 +cdlemg9a +cdlemg9b +cdlemh +cdlemh1 +cdlemh2 +cdlemi +cdlemi1 +cdlemi2 +cdlemj1 +cdlemj2 +cdlemj3 +cdlemk +cdlemk1 +cdlemk10 +cdlemk11 +cdlemk11t +cdlemk11ta +cdlemk11tb +cdlemk11tc +cdlemk11u +cdlemk11u-2n +cdlemk12 +cdlemk12u +cdlemk12u-2n +cdlemk13 +cdlemk13-2n +cdlemk14 +cdlemk14-2n +cdlemk15 +cdlemk15-2n +cdlemk16 +cdlemk16-2n +cdlemk16a +cdlemk17 +cdlemk17-2n +cdlemk18 +cdlemk18-2n +cdlemk18-3n +cdlemk19 +cdlemk19-2n +cdlemk19u +cdlemk19u1 +cdlemk19w +cdlemk19x +cdlemk19xlem +cdlemk19y +cdlemk19ylem +cdlemk1u +cdlemk2 +cdlemk20 +cdlemk20-2n +cdlemk21-2n +cdlemk21n +cdlemk22 +cdlemk22-3 +cdlemk23-3 +cdlemk24-3 +cdlemk25-3 +cdlemk26-3 +cdlemk26b-3 +cdlemk27-3 +cdlemk28-3 +cdlemk29-3 +cdlemk3 +cdlemk30 +cdlemk31 +cdlemk32 +cdlemk33n +cdlemk34 +cdlemk35 +cdlemk35s +cdlemk35s-id +cdlemk35u +cdlemk36 +cdlemk37 +cdlemk38 +cdlemk39 +cdlemk39s +cdlemk39s-id +cdlemk39u +cdlemk39u1 +cdlemk4 +cdlemk40 +cdlemk40f +cdlemk40t +cdlemk41 +cdlemk42 +cdlemk42yn +cdlemk43n +cdlemk45 +cdlemk46 +cdlemk47 +cdlemk48 +cdlemk49 +cdlemk5 +cdlemk50 +cdlemk51 +cdlemk52 +cdlemk53 +cdlemk53a +cdlemk53b +cdlemk54 +cdlemk55 +cdlemk55a +cdlemk55b +cdlemk55u +cdlemk55u1 +cdlemk56 +cdlemk56w +cdlemk5a +cdlemk5aun +cdlemk5u +cdlemk6 +cdlemk6u +cdlemk7 +cdlemk7u +cdlemk7u-2n +cdlemk8 +cdlemk9 +cdlemk9bn +cdlemkfid1n +cdlemkfid2n +cdlemkfid3n +cdlemki +cdlemkid +cdlemkid1 +cdlemkid2 +cdlemkid3n +cdlemkid4 +cdlemkid5 +cdlemkj +cdlemkj-2n +cdlemkoatnle +cdlemkoatnle-2n +cdlemkole +cdlemkole-2n +cdlemksat +cdlemksel +cdlemksv +cdlemksv2 +cdlemkuat +cdlemkuel +cdlemkuel-2n +cdlemkuel-3 +cdlemkuu +cdlemkuv-2n +cdlemkuv2 +cdlemkuv2-2 +cdlemkuv2-3n +cdlemkuvn +cdlemkvcl +cdlemky +cdlemkyu +cdlemkyuu +cdlemkyyn +cdleml1n +cdleml2n +cdleml3n +cdleml4n +cdleml5n +cdleml6 +cdleml7 +cdleml8 +cdleml9 +cdlemm10n +cdlemn +cdlemn10 +cdlemn11 +cdlemn11a +cdlemn11b +cdlemn11c +cdlemn11pre +cdlemn2 +cdlemn2a +cdlemn3 +cdlemn4 +cdlemn4a +cdlemn5 +cdlemn5pre +cdlemn6 +cdlemn7 +cdlemn8 +cdlemn9 +cdr-cons +cdr-of-append-when-consp +ceicl +ceige +ceil5half3 +ceilbi +ceilcl +ceilcld +ceildivmod +ceile +ceilge +ceilged +ceilhalf1 +ceilhalfelfzo1 +ceilhalfgt1 +ceilhalfnn +ceilid +ceilidz +ceiling_div +ceiling_div_le_x +ceiling_div_mod +ceille +ceilm1lt +ceilval +ceilval2 +ceim1l +celarent +celaront +cell_complex_disjoint_relative_interiors +cell_complex_subdivision_exists +cell_tower_placement +centre_in_ball +centre_in_cball +ceqex +ceqsal +ceqsal1t +ceqsalalt +ceqsalg +ceqsalgalt +ceqsalt +ceqsalv +ceqsex +ceqsex2 +ceqsex2v +ceqsex3v +ceqsex4v +ceqsex6v +ceqsex8v +ceqsexg +ceqsexgv +ceqsexv +ceqsexv2d +ceqsexv2dold +ceqsralbv +ceqsralt +ceqsralv +ceqsrex2v +ceqsrexbv +ceqsrexv +certs +cesare +cesaro +cevath +cevathlem1 +cevathlem2 +cf0 +cfcof +cfcoflem +cfeq0 +cff +cff1 +cfflb +cffldtocusgr +cffldtocusgrold +cfidm +cfil3i +cfilfcls +cfilfil +cfilfval +cfili +cfilres +cfilresi +cfilss +cfilucfil +cfilucfil2 +cfilucfil3 +cfilucfil4 +cfiluexsm +cfilufbas +cfilufg +cfiluweak +cfinfil +cfinufil +cfle +cflecard +cflem +cflemold +cflim2 +cflim3 +cflm +cfom +cfon +cfpwsdom +cfsetsnfsetf +cfsetsnfsetf1 +cfsetsnfsetf1o +cfsetsnfsetfo +cfsetsnfsetfv +cfsetssfset +cfslb +cfslb2n +cfslbn +cfsmo +cfsmolem +cfss +cfsuc +cfub +cfval +cfval2 +cgr3com +cgr3id +cgr3permute1 +cgr3permute2 +cgr3permute3 +cgr3permute4 +cgr3permute5 +cgr3rflx +cgr3rotl +cgr3rotr +cgr3simp1 +cgr3simp2 +cgr3simp3 +cgr3swap12 +cgr3swap13 +cgr3swap23 +cgr3tr +cgr3tr4 +cgrabtwn +cgracgr +cgracol +cgracom +cgrahl +cgrahl1 +cgrahl2 +cgraid +cgrancol +cgrane1 +cgrane2 +cgrane3 +cgrane4 +cgraswap +cgraswaplr +cgratr +cgrcgra +cgrcom +cgrcomand +cgrcomim +cgrcoml +cgrcomland +cgrcomlr +cgrcomlrand +cgrcomr +cgrcomrand +cgrdegen +cgrextend +cgrextendand +cgrg3col4 +cgrid2 +cgrrflx +cgrrflx2d +cgrrflxd +cgrsub +cgrtr +cgrtr3 +cgrtr3and +cgrtr4and +cgrtr4d +cgrtrand +cgrtriv +cgrxfr +cgsex2g +cgsex4g +cgsex4gold +cgsexg +ch0 +ch0le +ch0lei +ch0pss +ch1dle +chabs1 +chabs1i +chabs2 +chabs2i +chacha20_involutive +chain +chain_rule_entropy +chainrule +chan +channel +char_induct_thm +char_nchotomy +characteristic_polynomial +chcoeffeq +chcoeffeqlem +chcompl +chcon1i +chcon2i +chcon3i +chcv1 +chcv2 +chdmj1 +chdmj1i +chdmj2 +chdmj2i +chdmj3 +chdmj3i +chdmj4 +chdmj4i +chdmm1 +chdmm1i +chdmm2 +chdmm2i +chdmm3 +chdmm3i +chdmm4 +chdmm4i +chebbnd1 +chebbnd1lem1 +chebbnd1lem2 +chebbnd1lem3 +chebbnd2 +check +check_assume_tac +chel +cheli +chelii +chex +chfacffsupp +chfacfisf +chfacfisfcpmat +chfacfpmmul0 +chfacfpmmulcl +chfacfpmmulfsupp +chfacfpmmulgsum +chfacfpmmulgsum2 +chfacfscmul0 +chfacfscmulcl +chfacfscmulfsupp +chfacfscmulgsum +chfnrn +chincl +chincli +chinese_remainder +chintcl +chintcli +chirred +chirredi +chirredlem1 +chirredlem2 +chirredlem3 +chirredlem4 +chj0 +chj00i +chj0i +chj12 +chj12i +chj1i +chj4 +chj4i +chjass +chjassi +chjatom +chjcl +chjcli +chjcom +chjcomi +chjidm +chjidmi +chjjdiri +chjo +chjoi +chjval +chjvali +chlcsschl +chle0 +chle0i +chlej1 +chlej12i +chlej1i +chlej2 +chlej2i +chlejb1 +chlejb1i +chlejb2 +chlimi +chlub +chlubi +chlubii +chm0 +chm0i +chm1i +chmaidscmat +chmatcl +chmatval +chnccat +chnccats1 +chndss +chne0 +chne0i +chneq1 +chneq12 +chneq2 +chner +chnerlem1 +chnerlem2 +chnerlem3 +chnexg +chnf +chnfi +chnfibg +chnflenfi +chnind +chninf +chnle +chnlei +chnlen0 +chnlt +chnltm1 +chnpoadomd +chnpof1 +chnpolfz +chnpolleha +chnrdss +chnrev +chnrss +chnso +chnsubseq +chnsubseqwl +chnsubseqword +chnsuslle +chnub +chnwrd +choc0 +choc1 +choccl +choccli +chocin +chocini +chocnul +chocunii +chocvali +choice_insert_rest +choice_intro +choice_nat +choice_not_in_rest +choicefi +choose +choose_affine_subset +choose_large_compact_subset +choose_large_compact_subset_alt +choose_large_measurable_subset +choose_polytope +choose_simplex +choose_subset +choose_subset_between +choose_subset_eq +choose_subset_strong +choose_subspace_of_subspace +choose_surrounding_simplex +choose_surrounding_simplex_full +choose_tac +choose_then +chop_spec +chordthm +chordthmalt +chordthmlem +chordthmlem2 +chordthmlem3 +chordthmlem4 +chordthmlem5 +chp0mat +chp1 +chpchtlim +chpchtsum +chpcl +chpdifbnd +chpdifbndlem1 +chpdifbndlem2 +chpdmat +chpdmatlem0 +chpdmatlem1 +chpdmatlem2 +chpdmatlem3 +chpeq0 +chpf +chpfl +chpge0 +chpidmat +chpmat0d +chpmat1d +chpmat1dlem +chpmatfval +chpmatply1 +chpmatval +chpmatval2 +chpo1ub +chpo1ubb +chpp1 +chprpcl +chpscmat +chpscmat0 +chpscmatgsumbin +chpscmatgsummon +chpssati +chpsscon1 +chpsscon2 +chpsscon3 +chpub +chpval +chpval2 +chpvalz +chpwordi +chrcl +chrcong +chrdvds +chrelat2 +chrelat2i +chrelat3 +chrelat3i +chrelat4i +chrelati +chrid +chrnzr +chrrhm +chrval +chscl +chscllem1 +chscllem2 +chscllem3 +chscllem4 +chseli +chsh +chshii +chslej +chsleji +chss +chsscon1 +chsscon1i +chsscon2 +chsscon2i +chsscon3 +chsscon3i +chssii +chssoc +chsspwh +chsssh +chsup0 +chsupcl +chsupid +chsupsn +chsupss +chsupunss +chsupval +chsupval2 +cht1 +cht2 +cht3 +chtcl +chtdif +chteq0 +chtf +chtfl +chtge0 +chtleppi +chtlepsi +chtnprm +chto1lb +chto1ub +chtppilim +chtppilimlem1 +chtppilimlem2 +chtprm +chtrpcl +chtub +chtublem +chtval +chtvalz +chtwordi +chub1 +chub1i +chub2 +chub2i +chunksoflength +chunssji +church_rosser +church_turing_lambda +chvar +chvarfv +chvarv +chvarvv +cic +cic1st2nd +cic1st2ndbr +cicer +ciceralt +cicfn +cicfval +ciclcl +cicpropd +cicpropdlem +cicrcl +cicrcl2 +cicref +cicsym +cictr +cidffn +cidfn +cidfval +cidpropd +cidval +circcn +circgrp +circlemeth +circlemethhgt +circlemethnat +circlevma +circsubm +circtopn +circuit(next) +circum +cj0 +cj11 +cjadd +cjaddd +cjaddi +cjcj +cjcjd +cjcji +cjcl +cjcld +cjcli +cjcn2 +cjcncf +cjdiv +cjdivd +cjdivi +cjex +cjexp +cjexpd +cjf +cji +cjmul +cjmuld +cjmulge0 +cjmulge0d +cjmulge0i +cjmuli +cjmulrcl +cjmulrcld +cjmulrcli +cjmulval +cjmulvald +cjmulvali +cjne0 +cjne0d +cjneg +cjnegd +cjnegi +cjnpoly +cjre +cjreb +cjrebd +cjrebi +cjred +cjreim +cjreim2 +cjsub +cjsubd +cjth +cju +cjval +clabel +claim +claim_tac +class2set +class2seteq +classic +classical +classical_exists +classical_reductio +classify +classroom_assignment +clatglb +clatglbcl +clatglbcl2 +clatglble +clatglbss +clatl +clatleglb +clatlem +clatlubcl +clatlubcl2 +clatp0cl +clatp1cl +clatpos +clause +clauses +clcllaw +clcnvlem +cldbnd +cldcls +cldcss +cldcss2 +clddisj +cldllycmp +cldlp +cldmre +cldmreon +cldopn +cldrcl +cldregopn +cldss +cldss2 +cldssbrsiga +cldsubg +clduni +cldval +cleanly +clel2 +clel2g +clel3 +clel3g +clel4 +clel4g +clel5 +clelab +cleljust +cleljustab +cleljustalt +cleljustalt2 +clelsb1 +clelsb1f +clelsb1fw +clelsb2 +cleq1 +cleq1lem +cleq2lem +cleqf +cleqh +clifte +cliftet +clifteta +cliftetb +clim +clim0 +clim0c +clim0cf +clim1fr1 +clim2 +clim2c +clim2cf +clim2d +clim2div +clim2f +clim2f2 +clim2prod +clim2ser +clim2ser2 +climabs +climabs0 +climadd +climaddc1 +climaddc2 +climaddf +climbdd +climbddf +climcau +climcj +climcl +climcn1 +climcn1lem +climcn2 +climcncf +climcnds +climcndslem1 +climcndslem2 +climconst +climconst2 +climconstmpt +climd +climdivf +climdm +climeldmeq +climeldmeqf +climeldmeqmpt +climeldmeqmpt2 +climeldmeqmpt3 +climeq +climeqf +climeqmpt +climeu +climexp +climf +climf2 +climfsum +climfv +climfvd +climfveq +climfveqf +climfveqmpt +climfveqmpt2 +climfveqmpt3 +climge0 +climi +climi0 +climi2 +climim +climinf +climinf2 +climinf2lem +climinf2mpt +climinf3 +climinff +climinfmpt +climisp +climle +climlec2 +climlec3 +climleltrp +climliminf +climliminflimsup +climliminflimsup2 +climliminflimsup3 +climliminflimsup4 +climliminflimsupd +climlimsup +climlimsupcex +climmo +climmpt +climmpt2 +climmptf +climmul +climmulc2 +climmulf +climneg +climprod1 +climre +climrec +climrecf +climrecl +climreclf +climreclmpt +climreeq +climrel +climres +climrescn +climresd +climresdm +climresmpt +climreu +climrlim2 +climserle +climshft +climshft2 +climshftlem +climsqz +climsqz2 +climsub +climsubc1 +climsubc1mpt +climsubc2 +climsubc2mpt +climsubmpt +climsup +climsuse +climsuselem1 +climub +climuni +climuz +climuzcnv +climuzlem +climxlim +climxlim2 +climxlim2lem +climxrre +climxrrelem +climz +clintop +clintopcllaw +clintopval +cllem0 +clm0 +clm0vs +clm1 +clmabl +clmabs +clmacl +clmadd +clmcj +clmfgrp +clmgmold +clmgrp +clmlmod +clmmcl +clmmul +clmmulg +clmneg +clmneg1 +clmnegneg +clmnegsubdi2 +clmopfne +clmpm1dir +clmring +clmsca +clmsscn +clmsub +clmsub4 +clmsubcl +clmsubdir +clmsubrg +clmvneg1 +clmvs1 +clmvs2 +clmvsass +clmvscl +clmvscom +clmvsdi +clmvsdir +clmvslinv +clmvsneg +clmvsrinv +clmvsubval +clmvsubval2 +clmvz +clmzlmvsca +clmzss +clnbfiusgrfi +clnbgr0edg +clnbgr0vtx +clnbgr3stgrgrlic +clnbgr3stgrgrlim +clnbgrcl +clnbgredg +clnbgrel +clnbgrgrim +clnbgrgrimlem +clnbgrisubgrgrim +clnbgrisvtx +clnbgrlevtx +clnbgrn0 +clnbgrnvtx0 +clnbgrprc0 +clnbgrssedg +clnbgrssvtx +clnbgrsym +clnbgrval +clnbgrvtxedg +clnbgrvtxel +clnbupgr +clnbupgrel +clnbupgreli +clnbusgrfi +clopen +clopen_in_components +clopen_unions_components +closed_affine +closed_affine_hull +closed_affinity +closed_affinity_eq +closed_approachable +closed_boundedpreim_continuous_image +closed_carrier +closed_cball +closed_closure +closed_compact_differences +closed_compact_in +closed_compact_projection +closed_compact_sums +closed_components +closed_condensation_points +closed_conic_hull +closed_conic_hull_strong +closed_connected_component +closed_contains_sequential_limit +closed_convex_cone_hull +closed_convex_cone_hull_strong +closed_diff +closed_diff_open_interval_1 +closed_empty +closed_eq_continuous_levelset +closed_extreme_points_2d +closed_fip +closed_forall +closed_forall_in +closed_formula +closed_formula_0 +closed_formula_ind +closed_formula_n +closed_formula_n_15 +closed_formula_n_3 +closed_formula_n_5 +closed_halfspace_component_ge +closed_halfspace_component_le +closed_halfspace_ge +closed_halfspace_le +closed_hyperplane +closed_imp_analytic +closed_imp_baire1_indicator +closed_imp_borel +closed_imp_fip +closed_imp_fip_compact +closed_imp_fsigma +closed_imp_gdelta +closed_imp_locally_compact +closed_in +closed_in_analytic +closed_in_borel +closed_in_closed +closed_in_closed_eq +closed_in_closed_inter +closed_in_closed_trans +closed_in_closure_of +closed_in_compact +closed_in_compact_eq +closed_in_compact_projection +closed_in_component +closed_in_conic_hull +closed_in_connected_component +closed_in_derived_set +closed_in_diff +closed_in_diff_open +closed_in_empty +closed_in_eq_continuous_levelset +closed_in_euclidean +closed_in_euclidean_metric +closed_in_fsigma +closed_in_gdelta +closed_in_imp_subset +closed_in_injective_linear_image +closed_in_insert +closed_in_inter +closed_in_inter_closed +closed_in_inter_closure +closed_in_inter_closure_of +closed_in_inters +closed_in_limpt +closed_in_locally_finite_unions +closed_in_mcomplete_imp_mcomplete +closed_in_pcross +closed_in_pcross_eq +closed_in_refl +closed_in_relative_to +closed_in_separated_union +closed_in_sequential_limits +closed_in_sing +closed_in_subset +closed_in_subset_trans +closed_in_subtopology +closed_in_subtopology_inter_closed_in +closed_in_subtopology_refl +closed_in_topspace +closed_in_trans +closed_in_trans_eq +closed_in_translation_eq +closed_in_union +closed_in_unions +closed_injective_image_subset_subspace +closed_injective_image_subspace +closed_injective_linear_image +closed_injective_linear_image_eq +closed_insert +closed_inter +closed_inter_compact +closed_inters +closed_inters_compact +closed_interval +closed_interval_as_convex_hull +closed_interval_dropout +closed_interval_eq +closed_interval_image_unit_interval +closed_interval_left +closed_interval_right +closed_lift +closed_limpt +closed_limpts +closed_local_homeomorphism_global +closed_local_homeomorphism_imp_proper +closed_local_homeomorphism_imp_proper_gen +closed_locally_finite_unions +closed_map_closures +closed_map_fibre_neighbourhood +closed_map_from_composition_injective +closed_map_from_composition_surjective +closed_map_fstcart +closed_map_iff_upper_hemicontinuous_preimage +closed_map_imp_open_map +closed_map_imp_quotient_map +closed_map_norm +closed_map_open_superset_preimage +closed_map_open_superset_preimage_eq +closed_map_open_superset_preimage_point +closed_map_preimage_neighbourhood +closed_map_restrict +closed_map_sndcart +closed_negations +closed_open_interval_1 +closed_path_image +closed_pcross +closed_pcross_eq +closed_polar_dual +closed_positive_orthant +closed_relative_boundary +closed_relative_frontier +closed_relative_to +closed_scaling +closed_scaling_eq +closed_segment +closed_segment_descale +closed_segment_linear_image +closed_sequential_limits +closed_sing +closed_span +closed_sphere +closed_standard_hyperplane +closed_strip_component_le +closed_subset +closed_subset_eq +closed_subspace +closed_substandard +closed_translation +closed_translation_eq +closed_union +closed_union_compact_subsets +closed_unions +closed_univ +closer_point_lemma +closer_points_lemma +closest_point_affine_orthogonal +closest_point_affine_orthogonal_eq +closest_point_dot +closest_point_exists +closest_point_frontier +closest_point_idempotent +closest_point_in_frontier +closest_point_in_interior +closest_point_in_relative_frontier +closest_point_in_relative_interior +closest_point_in_set +closest_point_le +closest_point_lipschitz +closest_point_lt +closest_point_refl +closest_point_self +closest_point_subspace_orthogonal +closest_point_subspace_orthogonal_eq +closest_point_translation +closest_point_unique +closure_affinity +closure_approachable +closure_ball +closure_bounded_linear_image +closure_cball +closure_closed +closure_closure +closure_complement +closure_conic_hull +closure_convex_hull +closure_convex_inter_superset +closure_delete +closure_dyadic_rationals +closure_dyadic_rationals_in_convex_set +closure_dyadic_rationals_in_open_set +closure_empty +closure_eq +closure_eq_empty +closure_halfspace_component_gt +closure_halfspace_component_lt +closure_halfspace_gt +closure_halfspace_lt +closure_hull +closure_hyperplane +closure_image_bounded +closure_image_closure +closure_inc +closure_injective_linear_image +closure_insert +closure_inter_convex +closure_inter_convex_open +closure_inter_subset +closure_interior +closure_interior_idemp +closure_interior_union_closed +closure_inters_convex +closure_inters_convex_open +closure_inters_subset +closure_interval +closure_linear_image_subset +closure_locally_finite_unions +closure_minimal +closure_minimal_eq +closure_minimal_local +closure_negations +closure_nonempty_open_inter +closure_of +closure_of_alt +closure_of_injective_linear_image +closure_of_interior_of_idemp +closure_of_locally_finite_unions +closure_of_open_in_inter_superset +closure_of_restrict +closure_of_subset +closure_of_subtopology +closure_of_translation +closure_open_in_inter_closure +closure_open_inter_closure +closure_open_inter_superset +closure_open_interval +closure_pcross +closure_rational_coordinates +closure_rationals_in_convex_set +closure_rationals_in_open_set +closure_scaling +closure_segment +closure_sequential +closure_sing +closure_sphere +closure_strip_component_lt +closure_subset +closure_subset_affine_hull +closure_subset_eq +closure_subset_span +closure_sums +closure_surjective_linear_image +closure_translation +closure_union +closure_union_frontier +closure_unions +closure_unions_subset +closure_unique +closure_univ +clrellem +cls0 +clscld +clsconn +clsdif +clselmap +clsf +clsf2 +clsfval +clsidm +clsint2 +clsk1independent +clsk1indlem0 +clsk1indlem1 +clsk1indlem2 +clsk1indlem3 +clsk1indlem4 +clsk3nimkb +clslp +clsndisj +clsneibex +clsneicnv +clsneiel1 +clsneiel2 +clsneif1o +clsneifv3 +clsneifv4 +clsneikex +clsneinex +clsneircomplex +clsnsg +clsocv +clss2lem +clsslem +clsss +clsss2 +clsss3 +clssubg +clstop +clsun +clsval +clsval2 +clublem +clwlkclwwlk +clwlkclwwlk2 +clwlkclwwlken +clwlkclwwlkf +clwlkclwwlkf1 +clwlkclwwlkf1lem2 +clwlkclwwlkf1lem3 +clwlkclwwlkf1o +clwlkclwwlkflem +clwlkclwwlkfo +clwlkclwwlkfolem +clwlkclwwlklem1 +clwlkclwwlklem2 +clwlkclwwlklem2a +clwlkclwwlklem2a1 +clwlkclwwlklem2a2 +clwlkclwwlklem2a3 +clwlkclwwlklem2a4 +clwlkclwwlklem2fv1 +clwlkclwwlklem2fv2 +clwlkclwwlklem3 +clwlkcomp +clwlkcompbp +clwlkcompim +clwlkiswlk +clwlkl1loop +clwlknf1oclwwlkn +clwlknf1oclwwlknlem1 +clwlknf1oclwwlknlem2 +clwlknf1oclwwlknlem3 +clwlknon2num +clwlks +clwlksndivn +clwlkssizeeq +clwlkswks +clwlkwlk +clwwisshclwws +clwwisshclwwslem +clwwisshclwwslemlem +clwwisshclwwsn +clwwlk +clwwlk0on0 +clwwlk1loop +clwwlkbp +clwwlkccat +clwwlkccatlem +clwwlkclwwlkn +clwwlkel +clwwlken +clwwlkext2edg +clwwlkf +clwwlkf1 +clwwlkf1o +clwwlkfo +clwwlkfv +clwwlkgt0 +clwwlkinwwlk +clwwlkn +clwwlkn0 +clwwlkn1 +clwwlkn1loopb +clwwlkn2 +clwwlknbp +clwwlknccat +clwwlknclwwlkdif +clwwlknclwwlkdifnum +clwwlkndivn +clwwlkneq0 +clwwlknfi +clwwlknlbonbgr1 +clwwlknlen +clwwlknnn +clwwlknon +clwwlknon0 +clwwlknon1 +clwwlknon1le1 +clwwlknon1loop +clwwlknon1nloop +clwwlknon1sn +clwwlknon2 +clwwlknon2num +clwwlknon2x +clwwlknonccat +clwwlknonclwlknonen +clwwlknonclwlknonf1o +clwwlknondisj +clwwlknonel +clwwlknonex2 +clwwlknonex2e +clwwlknonex2lem1 +clwwlknonex2lem2 +clwwlknonfin +clwwlknonmpo +clwwlknonwwlknonb +clwwlknp +clwwlknscsh +clwwlknun +clwwlknwrd +clwwlknwwlkncl +clwwlknwwlksn +clwwlknwwlksnb +clwwlksclwwlkn +clwwlksswrd +clwwlkvbij +clwwlkwwlksb +clwwnisshclwwsn +clwwnonrepclwwnon +clwwnrepclwwn +cm0 +cm2j +cm2ji +cm2mi +cmbr +cmbr2i +cmbr3 +cmbr3i +cmbr4i +cmbri +cmclsopn +cmcm +cmcm2 +cmcm2i +cmcm2ii +cmcm3 +cmcm3i +cmcm3ii +cmcm4i +cmcmi +cmcmii +cmcmlem +cmddu +cmdfval +cmdfval2 +cmdlan +cmdmdi +cmdpropd +cmdrcl +cmetcau +cmetcaulem +cmetcusp +cmetcusp1 +cmetcvg +cmetmet +cmetmeti +cmetss +cmidi +cmj1i +cmj2i +cmm1i +cmm2i +cmmbl +cmmdi +cmn12 +cmn145236 +cmn246135 +cmn32 +cmn4 +cmn4d +cmnbascntr +cmncom +cmnmnd +cmnmndd +cmnpropd +cmntrcld +cmodscexp +cmodscmulexp +cmpcld +cmpcmet +cmpcov +cmpcov2 +cmpcovf +cmpcref +cmpfi +cmpfii +cmpfiiin +cmpfiref +cmphaushmeo +cmphmph +cmpidelt +cmpkgen +cmppcmp +cmpsub +cmpsublem +cmptop +cmscmet +cmscsscms +cmslssbn +cmslsschl +cmsms +cmspropd +cmssmscld +cmsss +cmt2n +cmt3n +cmt4n +cmtbr2n +cmtbr3n +cmtbr4n +cmtcomlemn +cmtcomn +cmtfvaln +cmtidn +cmtvaln +cmvth +cmvthold +cn1lem +cnaddabl +cnaddabloold +cnaddablx +cnaddcom +cnaddid +cnaddinv +cnambfre +cnambpcma +cnapbmcpd +cnbdibl +cnbl0 +cnblcld +cnbn +cncdrg +cncfcdm +cncfcn +cncfcn1 +cncfcnvcn +cncfco +cncfcompt +cncfcompt2 +cncfdmsn +cncff +cncfi +cncficcgt0 +cncfioobd +cncfioobdlem +cncfiooicc +cncfiooicclem1 +cncfiooiccre +cncfmet +cncfmpt1f +cncfmpt2f +cncfmpt2ss +cncfmptc +cncfmptid +cncfmptss +cncfmptssg +cncfperiod +cncfres +cncfrss +cncfrss2 +cncfshift +cncfshiftioo +cncfss +cncfuni +cncfval +cnchl +cnclima +cncls +cncls2 +cncls2i +cnclsi +cncmet +cncmp +cncmpmax +cncms +cncnp +cncnp2 +cncnpi +cnco +cncombf +cncongr +cncongr1 +cncongr2 +cncongrcoprm +cncongrprm +cnconn +cnconst +cnconst2 +cncph +cncrng +cncrngold +cncvcold +cncvs +cndis +cndivrenred +cndprob01 +cndprobin +cndprobnul +cndprobprob +cndprobtot +cndprobval +cndrng +cndrngold +cnegex +cnegex2 +cnelprrecn +cnelsubc +cnelsubclem +cnex +cnexalt +cnextcn +cnextf +cnextfres +cnextfres1 +cnextfun +cnextfval +cnextfvval +cnextrel +cnextucn +cnextval +cnf +cnf1dd +cnf2 +cnf2dd +cnf_equivalent +cnfcf +cnfcom +cnfcom2 +cnfcom2lem +cnfcom3 +cnfcom3c +cnfcom3clem +cnfcom3lem +cnfcomlem +cnfdmsn +cnfex +cnfld0 +cnfld1 +cnfld1old +cnfldadd +cnfldaddold +cnfldbas +cnfldbasold +cnfldcj +cnfldcjold +cnfldcusp +cnflddiv +cnflddivold +cnfldds +cnflddsold +cnfldex +cnfldexold +cnfldexp +cnfldfld +cnfldfun +cnfldfunalt +cnfldfunaltold +cnfldfunold +cnfldhaus +cnfldinv +cnfldle +cnfldleold +cnfldms +cnfldmul +cnfldmulg +cnfldmulold +cnfldneg +cnfldnm +cnfldplusf +cnfldsrngadd +cnfldsrngbas +cnfldsrngmul +cnfldstr +cnfldstrold +cnfldsub +cnfldtgp +cnfldtop +cnfldtopn +cnfldtopon +cnfldtps +cnfldtset +cnfldtsetold +cnfldunif +cnfldunifold +cnflduss +cnfldxms +cnflf +cnflf2 +cnfn1dd +cnfn2dd +cnfnc +cnfrrnsmf +cnfsmf +cnfval +cnhaus +cnheibor +cnheiborlem +cniccbdd +cniccibl +cnicciblnc +cnidold +cnima +cnims +cnindis +cnindmet +cnioobibld +cnlimc +cnlimci +cnllycmp +cnllysconn +cnlmod +cnlmod4 +cnlmodlem1 +cnlmodlem2 +cnlmodlem3 +cnlnadj +cnlnadjeu +cnlnadjeui +cnlnadji +cnlnadjlem1 +cnlnadjlem2 +cnlnadjlem3 +cnlnadjlem4 +cnlnadjlem5 +cnlnadjlem6 +cnlnadjlem7 +cnlnadjlem8 +cnlnadjlem9 +cnlnssadj +cnm2m1cnm3 +cnmbf +cnmbfm +cnmet +cnmetcoval +cnmetdval +cnmgpabl +cnmgpid +cnmpopc +cnmpt11 +cnmpt11f +cnmpt12 +cnmpt12f +cnmpt1ds +cnmpt1ip +cnmpt1k +cnmpt1mulr +cnmpt1plusg +cnmpt1res +cnmpt1st +cnmpt1t +cnmpt1vsca +cnmpt21 +cnmpt21f +cnmpt22 +cnmpt22f +cnmpt2c +cnmpt2ds +cnmpt2ip +cnmpt2k +cnmpt2mulr +cnmpt2nd +cnmpt2plusg +cnmpt2res +cnmpt2t +cnmpt2vsca +cnmptc +cnmptcom +cnmptid +cnmptk1 +cnmptk1p +cnmptk2 +cnmptkc +cnmptkk +cnmptkp +cnmptlimc +cnmptre +cnmsgn0g +cnmsgnbas +cnmsgngrp +cnmsgnsubg +cnmsubglem +cnn0opn +cnncvs +cnncvsabsnegdemo +cnncvsaddassdemo +cnncvsmulassdemo +cnndv +cnndvlem1 +cnndvlem2 +cnnei +cnneiima +cnngp +cnnm +cnnrg +cnntr +cnntri +cnnv +cnnvba +cnnvg +cnnvm +cnnvnm +cnnvs +cnopc +cnopn +cnpart +cnpcl +cnpco +cnpconn +cnpdis +cnperf +cnpf +cnpf2 +cnpfcf +cnpfcfi +cnpflf +cnpflf2 +cnpflfi +cnpfval +cnpimaex +cnplimc +cnpnei +cnprcl +cnprcl2 +cnprest +cnprest2 +cnpresti +cnptop1 +cnptop2 +cnpval +cnpwstotbnd +cnrbas +cnre +cnre2csqima +cnre2csqlem +cnrecnv +cnreeu +cnref1o +cnrefiisp +cnrefiisplem +cnrehmeo +cnrehmeoold +cnres2 +cnresima +cnrest +cnrest2 +cnrest2r +cnring +cnrlmod +cnrlvec +cnrmi +cnrmnrm +cnrmtop +cnrnvc +cnrrext +cnso +cnsqrt00 +cnsrexpcl +cnsrng +cnsrplycl +cnss1 +cnss2 +cnsscnp +cnstrcvs +cnsubdrglem +cnsubglem +cnsubmlem +cnsubrg +cnsubrglem +cnsubrglemold +cnt0 +cnt1 +cntmeas +cntnevol +cntop1 +cntop2 +cntotbnd +cntrabl +cntrcmnd +cntrcrng +cntri +cntrnsg +cntrss +cntrsubgnsg +cntrval +cntrval2 +cntz2ss +cntzcmn +cntzcmnf +cntzcmnss +cntzel +cntzfval +cntzi +cntzidss +cntziinsn +cntzmhm +cntzmhm2 +cntzrcl +cntzrec +cntzrecd +cntzsdrg +cntzsgrpcl +cntzsnid +cntzsnval +cntzspan +cntzssv +cntzsubg +cntzsubm +cntzsubr +cntzsubrng +cntzun +cntzval +cnv0 +cnv0old +cnvadj +cnvbrabra +cnvbracl +cnvbramul +cnvbraval +cnvcnv +cnvcnv2 +cnvcnv3 +cnvcnvintabd +cnvcnvres +cnvcnvsn +cnvcnvss +cnvco +cnvco1 +cnvco2 +cnvcosseq +cnvct +cnvdif +cnvelrels +cnven +cnvepima +cnvepnep +cnvepres +cnvepresdmqs +cnvepresdmqss +cnvepresex +cnveq +cnveq0 +cnveqb +cnveqd +cnveqi +cnvex +cnvexg +cnvf1o +cnvf1olem +cnvfi +cnvfialt +cnvi +cnviin +cnvimadfsn +cnvimainrn +cnvimamptfin +cnvimarndm +cnvimass +cnvimassrndm +cnvin +cnvintabd +cnviun +cnvmot +cnvnonrel +cnvopab +cnvopabold +cnvoprab +cnvordtrestixx +cnvpo +cnvprop +cnvps +cnvpsb +cnvrcl0 +cnvref4 +cnvref5 +cnvrefrelcoss2 +cnvrescnv +cnvresid +cnvresima +cnvresrn +cnvsn +cnvsn0 +cnvsng +cnvso +cnvss +cnvssb +cnvssco +cnvssrndm +cnvsym +cnvtrcl0 +cnvtrclfv +cnvtrrel +cnvtrucl0 +cnvtsr +cnvun +cnvuni +cnvunop +cnvxp +cnxmet +cnzh +co01 +co02 +coa2 +coafval +coahom +coapm +coass +coaval +cobounded_imp_unbounded +cobounded_inter_unbounded +cocan1 +cocan2 +cocanfo +coccl +coccom +cocnv +cocnvcnv1 +cocnvcnv2 +cocnvf1o +cocossss +codir +coe0 +coe11 +coe1add +coe1addfv +coe1ae0 +coe1f +coe1f2 +coe1fsupp +coe1fv +coe1fval +coe1fval2 +coe1fval3 +coe1fvalcl +coe1fzgsumd +coe1fzgsumdlem +coe1id +coe1mon +coe1mul +coe1mul2 +coe1mul2lem1 +coe1mul2lem2 +coe1mul3 +coe1mul4 +coe1pwmul +coe1pwmulfv +coe1scl +coe1sclmul +coe1sclmul2 +coe1sclmulfv +coe1sclmulval +coe1sfi +coe1subfv +coe1term +coe1termlem +coe1tm +coe1tmfv1 +coe1tmfv2 +coe1tmmul +coe1tmmul2 +coe1tmmul2fv +coe1vr1 +coe1z +coe1zfv +coeadd +coeaddlem +coecj +coecjold +coeeq +coeeq2 +coeeu +coeeulem +coef +coef2 +coef3 +coefv0 +coeid +coeid2 +coeid3 +coeidlem +coeidp +coelem +coemptyd +coemul +coemulc +coemulhi +coemullem +coep +coepr +coeq0 +coeq0i +coeq1 +coeq12d +coeq12i +coeq1d +coeq1i +coeq2 +coeq2d +coeq2i +coercion_lemma +coesub +coeval +coex +coexd +coexg +cofactor_0 +cofactor_1 +cofactor_1_gen +cofactor_cmul +cofactor_cofactor +cofactor_column +cofactor_eq_0 +cofactor_i +cofactor_matrix_inv +cofactor_matrix_mul +cofactor_row +cofactor_transp +cofcut1 +cofcut1d +cofcut2 +cofcut2d +cofcutr +cofcutr1d +cofcutr2d +cofcutrtime +cofcutrtime1d +cofcutrtime2d +coffth +cofid1 +cofid1a +cofid2 +cofid2a +cofidf1 +cofidf1a +cofidf2 +cofidf2a +cofidfth +cofidval +cofidvala +cofipsgn +coflim +coflton +cofmpt +cofmpt2 +cofon1 +cofon2 +cofonr +cofslts +cofsmo +cofss +cofth +coftr +cofu1 +cofu1a +cofu1st +cofu1st2nd +cofu2 +cofu2a +cofu2nd +cofuass +cofucl +cofucla +cofulid +cofull +cofunex2g +cofunexg +cofuoppf +cofurid +cofuswapf1 +cofuswapf2 +cofuswapfcl +cofuterm +cofuval +cofuval2 +coi1 +coi2 +coideq +coinfliplem +coinflipprob +coinflippv +coinflippvt +coinfliprv +coinflipspace +coinflipuniv +coiniss +coinitslts +coires1 +coiun +coiun1 +colcom +cold_chain +colhp +colinbtwnle +colinearalg +colinearalglem1 +colinearalglem2 +colinearalglem3 +colinearalglem4 +colineardim1 +colinearex +colinearperm1 +colinearperm2 +colinearperm3 +colinearperm4 +colinearperm5 +colineartriv1 +colineartriv2 +colinearxfr +colinrel +collatz_steps +collatzstep +colleq1 +colleq12d +colleq2 +collexd +colline +collinear_1 +collinear_2 +collinear_3 +collinear_3_2d +collinear_3_affine_hull +collinear_3_dot_multiples +collinear_3_eq_affine_dependent +collinear_3_expand +collinear_3_explicit +collinear_3_in_affine_hull +collinear_3_trans +collinear_4_3 +collinear_aff_dim +collinear_affine_hull +collinear_affine_hull_collinear +collinear_alt +collinear_alt2 +collinear_between_cases +collinear_between_cases_2 +collinear_convex_hull_collinear +collinear_descale +collinear_dist_between +collinear_dist_in_closed_segment +collinear_dist_in_open_segment +collinear_empty +collinear_extreme_points +collinear_hyperplane_2 +collinear_imp_coplanar +collinear_lemma +collinear_lemma_alt +collinear_linear_image +collinear_linear_image_eq +collinear_midpoint +collinear_segment +collinear_sing +collinear_small +collinear_span +collinear_standard_hyperplane_2 +collinear_subset +collinear_translation +collinear_translation_eq +collinear_triples +colmid +colopp +colouring +colours +colperp +colperpex +colperpexlem1 +colperpexlem2 +colperpexlem3 +colrot1 +colrot2 +coltr +coltr3 +column_0 +column_matrix_mul +column_transp +columns_image_basis +columns_nonempty +columns_transp +com12 +com13 +com14 +com15 +com23 +com24 +com25 +com34 +com35 +com3l +com3r +com3rgbi +com45 +com4l +com4r +com4t +com52l +com52r +com5l +com5r +comet +comfeq +comfeqd +comfeqval +comfffn +comfffval +comfffval2 +comffn +comffval +comffval2 +comfval +comfval2 +comm +comm_monoid_add_zero_left +common_frontier_domains +commutative1 +commutative2 +commutativity-of-* +commutativity-of-+ +commutativity-of-logand +commutativity-of-logior +commutativity-of-logxor +commuting_itset_insert +commuting_itset_recurses +commuting_matrix_inv_covariance +commuting_matrix_inv_normal +commuting_with_diagonal_matrix +commuting_with_square_root_matrix +compab +compact +compact_affinity +compact_affinity_eq +compact_attains +compact_attains_inf +compact_attains_sup +compact_cball +compact_chain +compact_closed +compact_closed_differences +compact_closed_subset +compact_closed_sums +compact_closure +compact_components +compact_connected_component +compact_continuous_image +compact_convex_collinear_segment +compact_convex_collinear_segment_alt +compact_convex_combinations +compact_convex_hull +compact_diff +compact_differences +compact_empty +compact_eq_bolzano_weierstrass +compact_eq_bounded_closed +compact_eq_heine_borel +compact_eq_heine_borel_gen +compact_eq_heine_borel_subtopology +compact_fip +compact_frontier +compact_frontier_bounded +compact_frontier_line_lemma +compact_hausdist +compact_imp_analytic +compact_imp_borel +compact_imp_bounded +compact_imp_closed +compact_imp_complete +compact_imp_fip +compact_imp_heine_borel +compact_imp_totally_bounded +compact_in_absolute +compact_in_eq_bolzano_weierstrass +compact_in_euclidean +compact_in_fip +compact_in_imp_closed_in +compact_in_imp_mbounded +compact_in_imp_totally_bounded_in +compact_in_separated_union +compact_in_sequence_with_limit +compact_in_sequentially +compact_in_subspace +compact_in_subtopology +compact_insert +compact_inter +compact_inter_closed +compact_inters +compact_interval +compact_interval_eq +compact_linear_image +compact_linear_image_eq +compact_negations +compact_nest +compact_open +compact_path_image +compact_pcross +compact_pcross_eq +compact_relative_boundary +compact_relative_frontier +compact_relative_frontier_bounded +compact_scaling +compact_scaling_eq +compact_segment +compact_sequence_with_limit +compact_sequence_with_limit_gen +compact_shrink_enclosing_ball +compact_shrink_enclosing_ball_infty +compact_sing +compact_space_euclidean_subtopology +compact_space_nest +compact_sphere +compact_sums +compact_sup_maxdistance +compact_translation +compact_translation_eq +compact_uniformly_continuous +compact_uniformly_equicontinuous +compact_union +compact_unions +compareandswap +compat +compatible_norm_vectorize +compeq +compile +compiler_correctness +compl_clauses +compl_compl +compl_empty +compl_insert +compl_splits +compl_union +complement_connected_component_unions +complementary_sum_components_lipschitz +complementary_sum_homeomorphic_pcross +compleq +complete_absolutely_summable +complete_eq_closed +complete_hausdist +complete_hausdist_convex +complete_hausdist_convex_univ +complete_hausdist_univ +complete_induction +complete_injective_linear_image +complete_injective_linear_image_eq +complete_isometric_image +complete_subspace +complete_translation_eq +complete_univ +completely_metrizable_space_euclidean +completely_metrizable_space_gdelta_in +completely_metrizable_space_mtopology +completenessaxiom +complss +compne +component +component_complement_connected +component_le_infnorm +component_le_norm +component_le_onorm +component_orthogonal +components_complement_frontier +components_convex_complement_contains_halfspace +components_empty +components_eq +components_eq_empty +components_eq_sing +components_eq_sing_exists +components_finite +components_inter_components +components_intermediate_subset +components_linear_image +components_maximal +components_nonoverlap +components_pcross +components_separated_union +components_translation +components_unique +components_unique_2 +components_unique_eq +components_univ +compose +compose_assoc +comppfsc +compss +compsscnv +compsscnvlem +compssiso +comptiunov2i +comraddd +comraddi +con1 +con1b +con1bid +con1bii +con1bii2 +con1d +con1i +con2 +con2b +con2bi +con2bid +con2bii +con2bii2 +con2d +con2i +con3 +con34b +con3alt +con3alt2 +con3altvd +con3d +con3dimp +con3i +con3rr3 +con4 +con4bid +con4bii +con4d +con4i +con5 +con5i +con5vd +conax1 +conax1k +concat +concat_map +concatmaplength +concl +concom +cond_cases_tac +cond_component +cond_false +cond_id +cond_rand +cond_rator +cond_swap +cond_true +condan +condensation_point_alt +condensation_point_imp_limpt +condensation_point_of_subset +conditional_indep +conference_schedule +confidence +confidencelattice +confluence +confluent_diamond_rtc +confluent_redn +confun +confun2 +confun3 +confun4 +confun5 +cong_refl +cong_sym +congabseq +congadd +congid +congmap +congmul +congneg +congplus +congr +congrep +congruent_image_std_simplex +congsub +congsucc +congsym +congtr +conic_closure +conic_conic_hull +conic_contains_0 +conic_convex_cone_hull +conic_convex_hull +conic_empty +conic_halfspace_ge +conic_halfspace_le +conic_hull_0 +conic_hull_as_image +conic_hull_contains_0 +conic_hull_convex_hull +conic_hull_diff +conic_hull_empty +conic_hull_eq +conic_hull_eq_affine_hull +conic_hull_eq_empty +conic_hull_eq_sing +conic_hull_eq_span +conic_hull_eq_span_eq +conic_hull_explicit +conic_hull_image_scale +conic_hull_inter +conic_hull_inter_affine_hull +conic_hull_linear_image +conic_hull_pointless_as_image +conic_hull_relative_frontier +conic_hull_relative_interior +conic_hull_relative_interior_subset +conic_hull_subset_convex_cone_hull +conic_hull_subset_span +conic_hull_univ +conic_hulls_eq_imp_spans_eq +conic_image_multiple +conic_image_multiple_eq +conic_imp_starlike +conic_interior +conic_interior_insert +conic_inters +conic_linear_image +conic_linear_image_eq +conic_mul +conic_negations +conic_pcross +conic_pcross_eq +conic_positive_orthant +conic_relative_interior +conic_relative_interior_insert +conic_span +conic_subset_as_conic_hull +conic_sums +conic_univ +conimpf +conimpfalt +conj +conj_aci +conj_asm1_tac +conj_assoc +conj_comm +conj_pair +conj_sym +conj_tac +conjga +conjghm +conjmul +conjnmz +conjnmzb +conjnsg +conjsubg +conjsubgen +conjunction +conjuncts +conjuncts_then +connclo +conncn +conncompcld +conncompclo +conncompconn +conncompid +conncompss +conndisj +connected +connected_2 +connected_affinity +connected_affinity_eq +connected_ball +connected_card_eq_iff_nontrivial +connected_card_lt_iff_trivial +connected_cball +connected_chain +connected_chain_gen +connected_clopen +connected_closed +connected_closed_in +connected_closed_in_eq +connected_closed_monotone_preimage +connected_closed_set +connected_closure +connected_closure_from_frontier +connected_compact_interval_1 +connected_component_disjoint +connected_component_empty +connected_component_eq +connected_component_eq_empty +connected_component_eq_eq +connected_component_eq_self +connected_component_eq_univ +connected_component_equivalence_relation +connected_component_finite +connected_component_idemp +connected_component_in +connected_component_in_components +connected_component_intermediate_subset +connected_component_linear_image +connected_component_maximal +connected_component_mono +connected_component_nonoverlap +connected_component_of_discrete_topology +connected_component_of_euclidean +connected_component_of_subset +connected_component_overlap +connected_component_pcross +connected_component_refl +connected_component_refl_eq +connected_component_separated_union +connected_component_set +connected_component_subset +connected_component_sym +connected_component_sym_eq +connected_component_trans +connected_component_translation +connected_component_unions +connected_component_unique +connected_component_univ +connected_components +connected_connected_component +connected_connected_component_set +connected_connected_diff +connected_continuous_image +connected_convex_1 +connected_convex_1_gen +connected_diff_open_from_closed +connected_disjoint_unions_open_unique +connected_empty +connected_eq_card_components +connected_eq_components_sing +connected_eq_components_sing_exists +connected_eq_components_subset_sing +connected_eq_components_subset_sing_exists +connected_eq_connected_component_eq +connected_eq_connected_components_eq +connected_equivalence_relation +connected_equivalence_relation_gen +connected_from_closed_union_and_inter +connected_from_closed_union_and_inter_local +connected_from_open_union_and_inter +connected_from_open_union_and_inter_local +connected_hausdist_limit +connected_iff_connectable_points +connected_iff_connected_component +connected_image +connected_imp_connected_component +connected_imp_nonseparated_union +connected_imp_perfect +connected_imp_perfect_aff_dim +connected_imp_perfect_closed +connected_in +connected_in_absolute +connected_in_chain +connected_in_chain_gen +connected_in_closed_in +connected_in_continuous_map_image +connected_in_euclidean +connected_in_imp_perfect_gen +connected_in_inter_frontier_of +connected_in_intermediate_closure_of +connected_in_nest +connected_in_nest_gen +connected_in_nonseparated_union +connected_in_subtopology +connected_in_topspace +connected_induction +connected_induction_simple +connected_insert +connected_insert_limpt +connected_inter_frontier +connected_inter_relative_frontier +connected_intermediate_closure +connected_interval +connected_ivt_component +connected_ivt_hyperplane +connected_jacobian_graph +connected_jacobian_range +connected_jacobian_range_alt +connected_jacobian_range_subset +connected_limit_points +connected_limit_points_eq_closure +connected_linear_image +connected_linear_image_eq +connected_monotone_quotient_preimage +connected_monotone_quotient_preimage_gen +connected_negations +connected_nest +connected_nest_gen +connected_open_in +connected_open_in_eq +connected_open_monotone_preimage +connected_open_path_connected +connected_open_set +connected_path_image +connected_pcross +connected_pcross_eq +connected_scaling +connected_scaling_eq +connected_segment +connected_semiopen_segment +connected_separation +connected_separation_alt +connected_sing +connected_space_clopen_in +connected_space_closed_in +connected_space_closed_in_eq +connected_space_eq +connected_space_euclidean_subtopology +connected_space_subconnected +connected_subset_clopen +connected_subset_segment +connected_sums +connected_symmetric +connected_translation +connected_translation_eq +connected_union +connected_union_clopen_in_complement +connected_union_strong +connected_unions +connected_unions_pairwise +connected_unions_strong +connected_univ +connected_with_relative_interior_open_in_convex +conngrv2edg +connhmph +connima +connpconn +connsub +connsuba +connsubclo +conntop +cononrel1 +cononrel2 +conrel1d +conrel2d +cons +cons-car-cdr +cons_acyclic +cons_app +cons_linear_image +cons_translation +consensus +consensus_majority +consider +consp-by-len +consp-of-append +consp-of-cdddr-by-len +consp-of-cddr-by-len +consp-of-cdr-by-len +consp-of-rev +conss1 +conss2 +const +constants +constcncf +constcncfg +constcof +constlimc +constmap +constr0 +constr01 +constrabscl +constraddcl +constraints +constrcbvlem +constrcccl +constrcccllem +constrcjcl +constrcn +constrcon +constrconj +constrdircl +constrelextdg2 +constrext2chn +constrext2chnlem +constrextdg2 +constrextdg2lem +constrfin +constrfiss +constrfld +constrimcl +constrinvcl +constrlccl +constrlccllem +constrlim +constrllcl +constrllcllem +constrmon +constrmulcl +constrnegcl +constrrecl +constrreinvcl +constrremulcl +constrresqrtcl +constrrtcc +constrrtcclem +constrrtlc1 +constrrtlc2 +constrrtll +constrsdrg +constrsqrtcl +constrss +constrsscn +constrsslem +constrsuc +constructreal +consym1 +cont +contained +container_loading +contains_component_of_closure_frontier +contains_component_of_compact_frontier +content_0_subset +content_0_subset_gen +content_1 +content_closed_interval +content_closed_interval_cases +content_doublesplit +content_empty +content_eq_0 +content_eq_0_1 +content_eq_0_gen +content_eq_0_interior +content_image_affinity_interval +content_image_stretch_interval +content_lt_nz +content_pastecart +content_pos_le +content_pos_lt +content_pos_lt_1 +content_pos_lt_eq +content_split +content_subset +content_unit +content_unit_1 +continuation +continuity +continuous +continuous_abs +continuous_add +continuous_additive_imp_linear +continuous_agree_on_closure +continuous_agree_on_intermediate_closure +continuous_at +continuous_at_avoid +continuous_at_ball +continuous_at_closest_point +continuous_at_compose +continuous_at_compose_eq +continuous_at_dist_closest_point +continuous_at_id +continuous_at_imp_continuous_on +continuous_at_inv +continuous_at_lift_component +continuous_at_lift_dist +continuous_at_lift_dot +continuous_at_lift_infnorm +continuous_at_lift_norm +continuous_at_lift_range +continuous_at_lift_setdist +continuous_at_linear_image +continuous_at_open +continuous_at_sequentially +continuous_at_sequentially_alt +continuous_at_sequentially_inj +continuous_at_sqrt +continuous_at_sqrt_compose +continuous_at_translation +continuous_at_within +continuous_at_within_inv +continuous_attains_inf +continuous_attains_sup +continuous_borel_preimage +continuous_bv_imp_uniformly_continuous +continuous_card_lt_range_constant +continuous_card_lt_range_constant_eq +continuous_closed_graph +continuous_closed_graph_eq +continuous_closed_graph_gen +continuous_closed_imp_cauchy_continuous +continuous_closed_in_preimage +continuous_closed_in_preimage_constant +continuous_closed_in_preimage_eq +continuous_closed_in_preimage_gen +continuous_closed_in_preimage_subset +continuous_closed_preimage +continuous_closed_preimage_constant +continuous_closed_preimage_univ +continuous_cmul +continuous_componentwise_lift +continuous_compose +continuous_const +continuous_constant_on_closure +continuous_constant_on_intermediate_closure +continuous_countable_range_constant +continuous_countable_range_constant_eq +continuous_decreasing_image_interval_1 +continuous_det_explicit +continuous_det_vectorize +continuous_diameter +continuous_disconnected_range_constant +continuous_discrete_range_constant +continuous_discrete_range_constant_eq +continuous_eq_cauchy_at +continuous_eq_cauchy_continuous_closed +continuous_eq_cauchy_within +continuous_finite_range_constant +continuous_finite_range_constant_eq +continuous_from_closed_graph +continuous_fsigma_preimage +continuous_fstcart +continuous_gdelta_preimage +continuous_ge_on_closure +continuous_ge_on_intermediate_closure +continuous_image_nested_inters +continuous_image_nested_inters_gen +continuous_imp_borel_measurable_on +continuous_imp_closed_map_explicit +continuous_imp_measurable_on +continuous_imp_measurable_on_closed_subset +continuous_imp_quotient_map_explicit +continuous_increasing_image_interval_1 +continuous_inv +continuous_inverse_injective_proper_map +continuous_ivt_local_extremum +continuous_le_on_closure +continuous_le_on_intermediate_closure +continuous_left_inverse_imp_quotient_map +continuous_levelset_open +continuous_levelset_open_in +continuous_levelset_open_in_cases +continuous_lift_abs +continuous_lift_abs_component +continuous_lift_component_compose +continuous_lift_det +continuous_lift_dot2 +continuous_lift_norm_compose +continuous_lift_pow +continuous_lift_product +continuous_map_atpointof +continuous_map_closures +continuous_map_closures_gen +continuous_map_componentwise_real +continuous_map_componentwise_univ +continuous_map_compose +continuous_map_const +continuous_map_dot +continuous_map_drop +continuous_map_drop_eq +continuous_map_drop_eq_gen +continuous_map_eq_drop +continuous_map_eq_lift +continuous_map_euclidean +continuous_map_euclidean2 +continuous_map_euclidean_component +continuous_map_euclidean_euclidean +continuous_map_extension_pointwise +continuous_map_extension_pointwise_alt +continuous_map_from_subtopology +continuous_map_id +continuous_map_in_subtopology +continuous_map_lift +continuous_map_lift_eq +continuous_map_lift_eq_gen +continuous_map_pastecart +continuous_map_pasted +continuous_map_pastewise +continuous_map_real_add +continuous_map_real_mul +continuous_map_real_sub +continuous_map_square_root +continuous_map_sum +continuous_map_uniform_limit +continuous_map_vector_add +continuous_map_vector_const +continuous_map_vector_mul +continuous_map_vector_sub +continuous_map_vsum +continuous_matrix_componentwise +continuous_matrix_mul +continuous_matrix_vector_mul +continuous_matrix_vectorize +continuous_max +continuous_max_1 +continuous_measure_translation_diff +continuous_measure_translation_symdiff +continuous_midpoint_convex +continuous_min +continuous_min_1 +continuous_mul +continuous_neg +continuous_on +continuous_on_abs +continuous_on_absolutely_integrable_translation +continuous_on_add +continuous_on_avoid +continuous_on_cases +continuous_on_cases_1 +continuous_on_cases_le +continuous_on_cases_local +continuous_on_cases_local_open +continuous_on_cases_open +continuous_on_clopen_indicator +continuous_on_closed +continuous_on_closed_gen +continuous_on_closest_point +continuous_on_closure +continuous_on_closure_component_ge +continuous_on_closure_component_le +continuous_on_closure_norm_le +continuous_on_closure_sequentially +continuous_on_cmul +continuous_on_compact_surface_projection +continuous_on_comparison +continuous_on_components_finite +continuous_on_components_gen +continuous_on_componentwise_lift +continuous_on_compose +continuous_on_compose_quotient +continuous_on_const +continuous_on_convolution_l1_linf +continuous_on_convolution_linf_l1 +continuous_on_det_vectorize +continuous_on_dist_closest_point +continuous_on_empty +continuous_on_eq +continuous_on_eq_continuous_at +continuous_on_eq_continuous_within +continuous_on_finite +continuous_on_fstcart +continuous_on_id +continuous_on_imp_baire +continuous_on_imp_closed_in +continuous_on_imp_open_in +continuous_on_interior +continuous_on_intermediate_closure +continuous_on_intermediate_closure_eq +continuous_on_intermediate_closure_pointwise +continuous_on_inv +continuous_on_inverse +continuous_on_inverse_closed_map +continuous_on_inverse_open_map +continuous_on_lift_abs +continuous_on_lift_abs_component +continuous_on_lift_component +continuous_on_lift_component_compose +continuous_on_lift_det +continuous_on_lift_dist +continuous_on_lift_dot +continuous_on_lift_dot2 +continuous_on_lift_norm +continuous_on_lift_norm_compose +continuous_on_lift_pow +continuous_on_lift_product +continuous_on_lift_range +continuous_on_lift_setdist +continuous_on_lift_sqrt +continuous_on_lift_sqrt_compose +continuous_on_matrix_componentwise +continuous_on_matrix_mul +continuous_on_matrix_vector_mul +continuous_on_matrix_vectorize +continuous_on_max +continuous_on_max_1 +continuous_on_measure_in_halfspace +continuous_on_measure_in_portion +continuous_on_min +continuous_on_min_1 +continuous_on_mul +continuous_on_neg +continuous_on_no_limpt +continuous_on_open +continuous_on_open_avoid +continuous_on_open_gen +continuous_on_pastecart +continuous_on_path_length_subpath_left +continuous_on_path_length_subpath_right +continuous_on_reflect +continuous_on_restrict +continuous_on_sequentially +continuous_on_sing +continuous_on_sndcart +continuous_on_sub +continuous_on_subset +continuous_on_union +continuous_on_union_local +continuous_on_union_local_open +continuous_on_union_open +continuous_on_vector_variation +continuous_on_vectorize_componentwise +continuous_on_vmul +continuous_on_vsum +continuous_open_in_preimage +continuous_open_in_preimage_eq +continuous_open_in_preimage_gen +continuous_open_in_preimage_subset +continuous_open_preimage +continuous_open_preimage_univ +continuous_pastecart +continuous_preimage_open +continuous_product +continuous_right_inverse_imp_quotient_map +continuous_sndcart +continuous_sub +continuous_sum +continuous_transform_at +continuous_transform_within +continuous_transform_within_open +continuous_transform_within_open_in +continuous_transform_within_set_imp +continuous_trivial_limit +continuous_uniform_limit +continuous_uniformly_cauchy_limit +continuous_vectorize_componentwise +continuous_vmul +continuous_vsum +continuous_within +continuous_within_avoid +continuous_within_ball +continuous_within_closed_nontrivial +continuous_within_comparison +continuous_within_compose +continuous_within_id +continuous_within_lift_sqrt +continuous_within_open +continuous_within_open_in +continuous_within_sequentially +continuous_within_sequentially_alt +continuous_within_sequentially_inj +continuous_within_sqrt_compose +continuous_within_subset +contr_tac +contra +contra_pf +contraction +contraction_imp_continuous_on +contradiction +contrapos_classical +contrapos_thm +contrapositive +contrapositive_rev +contrapositive_reverse +contrd +conv_rule +conv_tac +conventions +conventions-comments +conventions-labels +convergence_cauchy +convergence_cauchy1 +convergence_cauchy2 +convergence_in_measure +convergence_in_measure_unique +convergence_subsequence +convergent_bounded +convergent_bounded_decreasing_1 +convergent_bounded_increasing_1 +convergent_bounded_monotone +convergent_bounded_monotone_1 +convergent_bounded_monotone_eq +convergent_eq_cauchy +convergent_eq_cauchy_at +convergent_eq_cauchy_within +convergent_eq_zero_oscillation +convergent_eq_zero_oscillation_gen +convergent_imp_bounded +convergent_imp_cauchy +convergent_imp_cauchy_in +convergent_offset +convergent_offset_eq +convergent_offset_rev +convergent_product +convergent_subsequence +convergent_sum +converse_relation +converse_sard +converse_sard_1 +convex +convex_add +convex_add_eq +convex_affinity +convex_affinity_eq +convex_alt +convex_and_affine_inter_open +convex_ball +convex_bounds_lemma +convex_cball +convex_closed_contains_same_ray +convex_closure +convex_closure_interior +convex_closure_relative_interior +convex_cmul +convex_concave_eq_affine +convex_cone +convex_cone_add +convex_cone_contains_0 +convex_cone_convex_cone_hull +convex_cone_halfspace_ge +convex_cone_halfspace_le +convex_cone_hull_add +convex_cone_hull_contains_0 +convex_cone_hull_convex_hull +convex_cone_hull_convex_hull_nonempty +convex_cone_hull_empty +convex_cone_hull_linear_image +convex_cone_hull_mul +convex_cone_hull_nonempty +convex_cone_hull_separate +convex_cone_hull_separate_nonempty +convex_cone_hull_union +convex_cone_inters +convex_cone_linear_image +convex_cone_linear_image_eq +convex_cone_mul +convex_cone_negations +convex_cone_nonempty +convex_cone_pcross +convex_cone_pcross_eq +convex_cone_sing +convex_cone_span +convex_cone_sums +convex_conic_hull +convex_connected +convex_connected_1 +convex_connected_1_gen +convex_connected_collinear +convex_contains +convex_contains_open_segment +convex_contains_segment +convex_contains_segment_eq +convex_contains_segment_imp +convex_convex_cone_hull +convex_convex_hull +convex_differences +convex_distance +convex_empty +convex_epigraph +convex_epigraph_convex +convex_eq_connected_line_intersection +convex_eq_convex_line_intersection +convex_explicit +convex_facial_partition +convex_finite +convex_halfspace_component_ge +convex_halfspace_component_gt +convex_halfspace_component_le +convex_halfspace_component_lt +convex_halfspace_component_sgn +convex_halfspace_ge +convex_halfspace_gt +convex_halfspace_intersection +convex_halfspace_le +convex_halfspace_lt +convex_halfspace_sgn +convex_has_bounded_variation +convex_has_bounded_variation_eq +convex_hausdist_limit +convex_hull_2 +convex_hull_2_alt +convex_hull_3 +convex_hull_3_alt +convex_hull_affinity +convex_hull_caratheodory +convex_hull_caratheodory_aff_dim +convex_hull_closure +convex_hull_closure_subset +convex_hull_contains +convex_hull_empty +convex_hull_eq +convex_hull_eq_empty +convex_hull_eq_sing +convex_hull_exchange_inter +convex_hull_exchange_union +convex_hull_explicit +convex_hull_finite +convex_hull_finite_image_explicit +convex_hull_finite_step +convex_hull_image +convex_hull_image_lt +convex_hull_indexed +convex_hull_insert +convex_hull_insert_alt +convex_hull_insert_redundant_point +convex_hull_insert_segments +convex_hull_inter +convex_hull_interior_subset +convex_hull_inters +convex_hull_linear_image +convex_hull_pcross +convex_hull_redundant_point +convex_hull_redundant_subset +convex_hull_redundant_subset_gen +convex_hull_redundant_subset_rev +convex_hull_scaling +convex_hull_sing +convex_hull_sphere +convex_hull_subset_affine_hull +convex_hull_subset_convex_cone_hull +convex_hull_subset_span +convex_hull_sums +convex_hull_translation +convex_hull_union_explicit +convex_hull_union_nonempty_explicit +convex_hull_union_unions +convex_hull_univ +convex_hulls_eq +convex_hyperplane +convex_imp_bounded_on_interval +convex_imp_lipschitz +convex_imp_locally_bounded +convex_imp_locally_lipschitz +convex_imp_piecewise_monotone +convex_imp_starlike +convex_indexed +convex_inner_approximation +convex_inner_polytope +convex_inter +convex_interior +convex_interior_closure +convex_intermediate_ball +convex_inters +convex_interval +convex_line_intersection_unique_closed +convex_line_intersection_unique_open +convex_line_intersection_unique_open_in +convex_line_intersections +convex_line_intersections_alt +convex_linear_image +convex_linear_image_eq +convex_linear_preimage +convex_local_global_minimum +convex_local_global_minimum_gen +convex_local_global_minimum_segment +convex_lower +convex_lower_segment +convex_lower_segment_lt +convex_max +convex_nearby_in_scaling +convex_nearby_in_scaling_relative_interior +convex_nearby_not_in_scaling +convex_negations +convex_norm +convex_on_compose_linear +convex_on_const +convex_on_continuous +convex_on_continuous_on_relative_interior +convex_on_convex_hull_bound +convex_on_convex_hull_bound_eq +convex_on_countable_nondifferentiable +convex_on_derivative_secant +convex_on_derivative_secant_imp +convex_on_derivatives_imp +convex_on_directional_derivative_functions +convex_on_directional_derivatives +convex_on_empty +convex_on_epigraph_slice_le +convex_on_epigraph_slice_lt +convex_on_eq +convex_on_imp_jensen +convex_on_imp_midpoint_convex +convex_on_indefinite_integral_increasing +convex_on_is_indefinite_integral +convex_on_jensen +convex_on_left_differentiable +convex_on_mid_secant +convex_on_right_differentiable +convex_on_secant_derivative +convex_on_secant_derivative_imp +convex_on_secants_1 +convex_on_secants_1_imp +convex_on_setdist +convex_on_sing +convex_on_subset +convex_on_sum +convex_on_sup +convex_on_translation +convex_open_segment_cases +convex_open_segment_cases_alt +convex_outer_approximation +convex_outer_polytope +convex_pcross +convex_pcross_eq +convex_polar_dual +convex_positive_orthant +convex_preimage_concave_scaling +convex_relative_boundary_subset_of_proper_face +convex_relative_interior +convex_relative_interior_closure +convex_same_relative_interior_closure +convex_same_relative_interior_closure_straddle +convex_scaling +convex_scaling_eq +convex_segment +convex_semiopen_segment +convex_sing +convex_span +convex_standard_hyperplane +convex_starcentres +convex_strip_component_le +convex_strip_component_lt +convex_sums +convex_sums_multiples +convex_symdiff_close_to_frontier +convex_translation +convex_translation_eq +convex_translation_subset_preimage +convex_translation_superset_preimage +convex_triple_relative_frontier +convex_unions_fulldim_cells +convex_univ +convex_vsum +convex_vsum_strong +convexity_preserving_shrink_0 +conway +coof +copco +copisnmnd +copissgrp +coplanar_2 +coplanar_3 +coplanar_aff_dim +coplanar_affine_hull_coplanar +coplanar_empty +coplanar_intersecting_lines +coplanar_linear_image +coplanar_linear_image_eq +coplanar_sing +coplanar_small +coplanar_subset +coplanar_translation +coplanar_translation_eq +coprime_lexp +coprime_mult +coprime_sym +coprimeprodsq +coprimeprodsq2 +coprm +coprmdvds +coprmdvds1 +coprmdvds2 +coprmdvds2d +coprmdvdsb +coprmgcdb +coprmprod +coprmproddvds +coprmproddvdslem +coprprop +copsex2b +copsex2d +copsex2dv +copsex2g +copsex2ga +copsex2gb +copsex2t +copsex4g +copsexg +copsexgw +copsgndif +copyarray +copyright +coq +corclrcl +corclrtrcl +corcltrcl +core +cores +cores2 +correct +cortrclrcl +cortrclrtrcl +cortrcltrcl +cos0 +cos01bnd +cos01gt0 +cos02pilt1 +cos0pilt1 +cos11 +cos1bnd +cos2bnd +cos2h +cos2kpi +cos2pi +cos2pim +cos2t +cos2t3rdpi +cos2tsin +cos4t3rdpi +cos9thpiminply +cos9thpiminplylem1 +cos9thpiminplylem2 +cos9thpiminplylem3 +cos9thpiminplylem4 +cos9thpiminplylem5 +cos9thpiminplylem6 +cos9thpinconstr +cos9thpinconstrlem1 +cos9thpinconstrlem2 +cos_sin_sq +cosacos +cosadd +cosangneg2d +cosarg0d +cosargd +cosasin +cosatan +cosatanne0 +cosbnd +cosbnd2 +coscl +coscld +coscn +coseq0 +coseq00topi +coseq0negpitopi +coseq1 +cosf +coshalfpi +coshalfpim +coshalfpip +coshval +coshval-named +cosknegpi +coskpi +coskpi2 +cosmpi +cosmul +cosn +cosne0 +cosneg +cosneghalfpi +cosnegpi +cosni +cosnop +cosnopne +cosord +cosordlem +cosper +cospi +cospim +cosppi +cosq14ge0 +cosq14gt0 +cosq34lt1 +coss0 +coss1 +coss12d +coss1cnvres +coss2 +coss2cnvepres +cosscnv +cosscnvelrels +cosscnvex +cosscnvid +cosscnvssid3 +cosscnvssid4 +cosscnvssid5 +cosselcnvrefrels2 +cosselcnvrefrels3 +cosselcnvrefrels4 +cosselcnvrefrels5 +cosselrels +cosseq +cosseqd +cosseqi +cossex +cossid +cossss +cossssid +cossssid2 +cossssid3 +cossssid4 +cossssid5 +cossub +cossxp +cosval +cotcl +cotr +cotr2 +cotr2g +cotr3 +cotrclrcl +cotrclrtrcl +cotrcltrcl +cotrg +cotrintab +cotrtrclfv +cotsqcscsq +cottrcl +cotval +coundi +coundir +counop +count_add +count_add1 +count_eqn +count_mono +count_not_empty +count_one +count_roots_modulo_odd_gen +count_suc +countable +countable_alt +countable_alt_bij +countable_as_image +countable_as_injective_image +countable_as_injective_image_subset +countable_ascending_clopen_chain +countable_ascending_clopen_in_chain +countable_card_add_eq +countable_cart +countable_clopen_in +countable_compact_open_in +countable_components_union +countable_cross +countable_descending_clopen_chain +countable_descending_clopen_in_chain +countable_discontinuities_imp_baire1 +countable_disjoint_nonempty_interior_subsets +countable_disjoint_open_in_subsets +countable_disjoint_open_subsets +countable_elementary_division +countable_empty +countable_enum +countable_finite_subsets +countable_from +countable_image +countable_image_inj_eq +countable_imp_card_lt_real +countable_imp_disconnected +countable_imp_fsigma +countable_insert +countable_inter +countable_intersection_of_baire0_indicator +countable_intersection_of_baire_indicator +countable_intersection_of_bijective_image +countable_intersection_of_complement +countable_intersection_of_idempot +countable_intersection_of_inc +countable_intersection_of_inter +countable_isolated_set +countable_neither_sided_limits_imp_baire1 +countable_neither_sided_limits_imp_baire1_gen +countable_non_condensation_points +countable_non_limit_points +countable_noncontinuous_left_limits +countable_noncontinuous_one_sided_limits +countable_noncontinuous_right_limits +countable_open_interval +countable_product_dependent +countable_rational +countable_rational_coordinates +countable_restrict +countable_sing +countable_subset +countable_surj +countable_trivial_left_limits +countable_trivial_right_limits +countable_union +countable_union_of_ascending +countable_union_of_baire0_indicator +countable_union_of_baire_indicator +countable_union_of_baire_indicator_translation +countable_union_of_bijective_image +countable_union_of_explicit +countable_union_of_idempot +countable_union_of_inc +countable_union_of_inter +countable_unions +countable_uprod +countablechoice +countersatisfiable +countoccurrences +course_of_values +covariance_matrix_eq_0 +covariance_matrix_eq_square +covariance_matrix_inv +covariance_unique_up_to_orthogonal +covariance_unique_up_to_orthogonal_alt +cover2 +cover2g +covering_lemma +coxp +cp +cpcoll2d +cpcolld +cpet +cpet2 +cph2ass +cph2di +cph2subdi +cphabscl +cphass +cphassi +cphassir +cphassr +cphcjcl +cphclm +cphdi +cphdir +cphdivcl +cphip0l +cphip0r +cphipcj +cphipcl +cphipeq0 +cphipipcj +cphipval +cphipval2 +cphlmod +cphlvec +cphngp +cphnlm +cphnm +cphnmcl +cphnmf +cphnmfval +cphnmvs +cphnvc +cphorthcom +cphphl +cphpyth +cphqss +cphreccl +cphreccllem +cphsca +cphsqrtcl +cphsqrtcl2 +cphsqrtcl3 +cphsscph +cphssphl +cphsubdi +cphsubdir +cphsubrg +cphsubrglem +cphtcphnm +cplem1 +cplem2 +cplgr0 +cplgr0v +cplgr1v +cplgr1vlem +cplgr2v +cplgr2vpr +cplgr3v +cplgredgex +cplgrop +cplgruvtxb +cply1coe0 +cply1coe0bi +cply1mul +cpm2mf +cpm2mfval +cpm2mval +cpm2mvalel +cpmadugsum +cpmadugsumfi +cpmadugsumlemb +cpmadugsumlemc +cpmadugsumlemf +cpmadumatpoly +cpmadumatpolylem1 +cpmadumatpolylem2 +cpmadurid +cpmat +cpmatacl +cpmatel +cpmatel2 +cpmatelimp +cpmatelimp2 +cpmatinvcl +cpmatmcl +cpmatmcllem +cpmatpmat +cpmatsrgpmat +cpmatsubgpmat +cpmidg2sum +cpmidgsum +cpmidgsum2 +cpmidgsumm2pm +cpmidpmat +cpmidpmatlem1 +cpmidpmatlem2 +cpmidpmatlem3 +cpncn +cpnfval +cpnnen +cpnord +cpnres +cr +cramer +cramer0 +cramer_lemma +cramer_lemma_transp +cramer_matrix_left +cramer_matrix_left_inverse +cramer_matrix_right +cramer_matrix_right_inverse +cramerimp +cramerimplem1 +cramerimplem2 +cramerimplem3 +cramerlem1 +cramerlem2 +cramerlem3 +crctcsh +crctcshlem1 +crctcshlem2 +crctcshlem3 +crctcshlem4 +crctcshtrl +crctcshwlk +crctcshwlkn0 +crctcshwlkn0lem1 +crctcshwlkn0lem2 +crctcshwlkn0lem3 +crctcshwlkn0lem4 +crctcshwlkn0lem5 +crctcshwlkn0lem6 +crctcshwlkn0lem7 +crctisclwlk +crctistrl +crctiswlk +crctprop +crcts +create_spec +crefdf +crefeq +crefi +crefss +creftop +creq0 +creui +creur +crew_scheduling +crhmsubc +crhmsubcaltv +crim +crimd +crimi +cringcat +cringcataltv +cringm4 +crne0 +crng12d +crng2idl +crng32d +crngbascntr +crngbinom +crngcom +crngcomd +crnggrpd +crngm23 +crngm4 +crngmgp +crngmxidl +crngocom +crngohomfo +crngoppr +crngorngo +crngpropd +crngridl +crngring +crngringd +crngunit +crock0 +crock0-0 +crock0-1 +crock1 +crock2 +crock3 +crock4 +crop_rotation +cross +cross_bigunion +cross_countable +cross_countable_iff +cross_empty_eqn +cross_eqns +cross_insert_left +cross_insert_right +cross_subset +cross_univ +crre +crreczi +crred +crrei +crt +crth +cru +cryptarithmetic +csb0 +csb2 +csbab +csbafv12g +csbafv212g +csbaovg +csbcnv +csbcnvgalt +csbco +csbco3g +csbcog +csbcom +csbcom2fi +csbconstg +csbconstgf +csbconstgi +csbcow +csbdif +csbdm +csbeq1 +csbeq12 +csbeq12dv +csbeq1a +csbeq1d +csbeq2 +csbeq2d +csbeq2dv +csbeq2gvd +csbeq2i +csbex +csbexg +csbfinxpg +csbfrecsg +csbfv +csbfv12 +csbfv12galtvd +csbfv2g +csbgfi +csbhypf +csbid +csbidm +csbie +csbie2 +csbie2df +csbie2g +csbie2t +csbieb +csbiebg +csbiebt +csbied +csbied2 +csbiedf +csbief +csbiegf +csbif +csbima12 +csbima12galtvd +csbin +csbingvd +csbiota +csbmpo123 +csbmpt12 +csbmpt2 +csbnegg +csbnest1g +csbnestg +csbnestgf +csbnestgfw +csbnestgw +csbopab +csbopabgalt +csbopeq1a +csbopg +csboprabg +csbov +csbov123 +csbov12g +csbov1g +csbov2g +csbprc +csbpredg +csbprg +csbrdgg +csbrecsg +csbren +csbres +csbresgvd +csbriota +csbrn +csbrngvd +csbsng +csbsngvd +csbtt +csbun +csbuni +csbunigvd +csbvarg +csbvargi +csbwrdg +csbwrecsg +csbxp +csbxpgvd +csccl +cscval +csdfil +cshco +cshf1 +cshf1o +cshfn +cshimadifsn +cshimadifsn0 +cshinj +cshnz +cshw0 +cshw1 +cshw1repsw +cshw1s2 +cshwcl +cshwcsh2id +cshwcshid +cshweqdif2 +cshweqdifid +cshweqrep +cshwf +cshwfn +cshwidx0 +cshwidx0mod +cshwidxm +cshwidxm1 +cshwidxmod +cshwidxmodr +cshwidxn +cshwlen +cshwleneq +cshwmodn +cshwn +cshword +cshwrepswhash1 +cshwrn +cshwrnid +cshws0 +cshwsdisj +cshwsex +cshwsexa +cshwshash +cshwshashlem1 +cshwshashlem2 +cshwshashlem3 +cshwshashnsame +cshwsidrepsw +cshwsidrepswmod0 +cshwsiun +cshwsublen +csmdsymi +csrgbinom +css0 +css1 +cssbn +csschl +csscld +cssi +cssincl +csslss +cssmre +cssss +cssval +cstucnd +ctbnfien +ctbssinf +ctex +ctvonmbl +cu2 +cu3addd +cubic +cubic2 +cureq +curf +curf1 +curf11 +curf12 +curf1cl +curf1fval +curf2 +curf2cl +curf2ndf +curf2val +curfcl +curfpropd +curfuncf +curfv +curfval +curriculum_sequencing +curry +curry1 +curry1f +curry1val +curry2 +curry2f +curry2ima +curry2val +curry_uncurry +curryax +currybi +curryset +currysetalt +currysetlem +currysetlem1 +currysetlem2 +currysetlem3 +curunc +cusconngr +cusgr0 +cusgr0v +cusgr1v +cusgr3cyclex +cusgr3vnbpr +cusgracyclt3v +cusgrcplgr +cusgredg +cusgredgex +cusgredgex2 +cusgrexg +cusgrexi +cusgrexilem1 +cusgrexilem2 +cusgrfi +cusgrfilem1 +cusgrfilem2 +cusgrfilem3 +cusgrm1rusgr +cusgrop +cusgrres +cusgrrusgr +cusgrsize +cusgrsize2inds +cusgrsizeindb0 +cusgrsizeindb1 +cusgrsizeinds +cusgrsizeindslem +cusgrusgr +cusgruvtxb +cuspcvg +cuspusp +cut_admissible +cut_elim +cut_elim_nuprl +cutadmissible +cutbday +cutbdaybnd +cutbdaybnd2 +cutbdaybnd2lim +cutbdaylt +cutcuts +cuteq0 +cuteq1 +cutlt +cutmax +cutmin +cutminmax +cutneg +cutpos +cutscl +cutscld +cutsf +cutsfo +cutsun12 +cutsval +cutting_stock +cvati +cvbr +cvbr2 +cvbr4i +cvbtrcl +cvcon3 +cvdmd +cvexch +cvexchi +cvexchlem +cvgcau +cvgcaule +cvgcmp +cvgcmpce +cvgcmpub +cvgdvgrat +cvgrat +cvjust +cvlatcvr1 +cvlatcvr2 +cvlatexch1 +cvlatexch2 +cvlatexch3 +cvlatexchb1 +cvlatexchb2 +cvlatl +cvlcvr1 +cvlcvrp +cvlexch1 +cvlexch2 +cvlexch3 +cvlexch4n +cvlexchb1 +cvlexchb2 +cvllat +cvlposn +cvlsupr2 +cvlsupr3 +cvlsupr4 +cvlsupr5 +cvlsupr6 +cvlsupr7 +cvlsupr8 +cvmcn +cvmcov +cvmcov2 +cvmd +cvmdi +cvmfo +cvmfolem +cvmlift +cvmlift2 +cvmlift2lem1 +cvmlift2lem10 +cvmlift2lem11 +cvmlift2lem12 +cvmlift2lem13 +cvmlift2lem2 +cvmlift2lem3 +cvmlift2lem4 +cvmlift2lem5 +cvmlift2lem6 +cvmlift2lem7 +cvmlift2lem8 +cvmlift2lem9 +cvmlift2lem9a +cvmlift3 +cvmlift3lem1 +cvmlift3lem2 +cvmlift3lem3 +cvmlift3lem4 +cvmlift3lem5 +cvmlift3lem6 +cvmlift3lem7 +cvmlift3lem8 +cvmlift3lem9 +cvmliftiota +cvmliftlem1 +cvmliftlem10 +cvmliftlem11 +cvmliftlem13 +cvmliftlem14 +cvmliftlem15 +cvmliftlem2 +cvmliftlem3 +cvmliftlem4 +cvmliftlem5 +cvmliftlem6 +cvmliftlem7 +cvmliftlem8 +cvmliftlem9 +cvmliftmo +cvmliftmoi +cvmliftmolem1 +cvmliftmolem2 +cvmliftpht +cvmliftphtlem +cvmopn +cvmopnlem +cvmscbv +cvmscld +cvmsdisj +cvmseu +cvmsf1o +cvmshmeo +cvmsi +cvmsiota +cvmsn0 +cvmsrcl +cvmsss +cvmsss2 +cvmsuni +cvmsval +cvmtop1 +cvmtop2 +cvnbtwn +cvnbtwn2 +cvnbtwn3 +cvnbtwn4 +cvnref +cvnsym +cvntr +cvp +cvpss +cvr1 +cvr2n +cvrat +cvrat2 +cvrat3 +cvrat4 +cvrat42 +cvratlem +cvrcmp +cvrcmp2 +cvrcon3b +cvrexch +cvrexchlem +cvrfval +cvrle +cvrletrn +cvrlt +cvrnbtwn +cvrnbtwn2 +cvrnbtwn3 +cvrnbtwn4 +cvrne +cvrnle +cvrnrefn +cvrntr +cvrp +cvrval +cvrval2 +cvrval3 +cvrval4n +cvrval5 +cvsclm +cvsdiv +cvsdivcl +cvsdiveqd +cvsi +cvslvec +cvsmuleqdivd +cvsunit +cvxcl +cvxpconn +cvxsconn +cx_append_comm +cx_division_positive +cx_filter_length +cx_float_assoc +cx_int_overflow +cx_list_rev_sorted +cx_map_injective +cx_sort_idempotent +cx_subset_reflexive +cxp0 +cxp0d +cxp1 +cxp111d +cxp112d +cxp1d +cxp2lim +cxp2limlem +cxpadd +cxpaddd +cxpaddle +cxpaddlelem +cxpcl +cxpcld +cxpcn +cxpcn2 +cxpcn3 +cxpcn3lem +cxpcncf1 +cxpcncf2 +cxpcnold +cxpcom +cxpef +cxpefd +cxpeq +cxpeq0 +cxpexp +cxpexpz +cxpexpzd +cxpge0 +cxpge0d +cxpgt0d +cxpi11d +cxple +cxple2 +cxple2a +cxple2ad +cxple2d +cxple3 +cxple3d +cxplea +cxplead +cxpled +cxplim +cxplogb +cxploglim +cxploglim2 +cxplt +cxplt2 +cxplt2d +cxplt3 +cxplt3d +cxpltd +cxpmul +cxpmul2 +cxpmul2d +cxpmul2z +cxpmul2zd +cxpmuld +cxpne0 +cxpne0d +cxpneg +cxpnegd +cxpp1 +cxpp1d +cxprec +cxprecd +cxproot +cxpsqrt +cxpsqrtlem +cxpsqrtth +cxpsub +cxpsubd +cxpval +cyc2fv1 +cyc2fv2 +cyc2fvx +cyc3co2 +cyc3conja +cyc3evpm +cyc3fv1 +cyc3fv2 +cyc3fv3 +cyc3genpm +cyc3genpmlem +cyccom +cycl3grtri +cycl3grtrilem +cycldlenngric +cyclenonempty +cycliscrct +cyclispth +cyclispthon +cycliswlk +cyclnspth +cyclnumvtx +cyclprop +cycls +cycpm2cl +cycpm2tr +cycpm3cl +cycpm3cl2 +cycpmcl +cycpmco2 +cycpmco2f1 +cycpmco2lem1 +cycpmco2lem2 +cycpmco2lem3 +cycpmco2lem4 +cycpmco2lem5 +cycpmco2lem6 +cycpmco2lem7 +cycpmco2rn +cycpmconjs +cycpmconjslem1 +cycpmconjslem2 +cycpmconjv +cycpmconjvlem +cycpmfv1 +cycpmfv2 +cycpmfv3 +cycpmfvlem +cycpmgcl +cycpmrn +cycsubg +cycsubg2 +cycsubg2cl +cycsubgcl +cycsubgcld +cycsubgcyg +cycsubgcyg2 +cycsubggend +cycsubggenodd +cycsubgss +cycsubm +cycsubmcl +cycsubmcmn +cycsubmcom +cycsubmel +cygabl +cygctb +cyggeninv +cyggenod +cyggenod2 +cyggex +cyggex2 +cyggexb +cyggic +cyggrp +cygth +cygzn +cygznlem1 +cygznlem2 +cygznlem2a +cygznlem3 +cytpfn +cytpval +cznabel +cznnring +cznrng +cznrnglem +d +d0mat2pmat +d1mat2pmat +da +dalaw +dalawlem1 +dalawlem10 +dalawlem11 +dalawlem12 +dalawlem13 +dalawlem14 +dalawlem15 +dalawlem2 +dalawlem3 +dalawlem4 +dalawlem5 +dalawlem6 +dalawlem7 +dalawlem8 +dalawlem9 +dalem-ccly +dalem-clpjq +dalem-cly +dalem-ddly +dalem1 +dalem10 +dalem11 +dalem12 +dalem13 +dalem14 +dalem15 +dalem16 +dalem17 +dalem18 +dalem19 +dalem2 +dalem20 +dalem21 +dalem22 +dalem23 +dalem24 +dalem25 +dalem27 +dalem28 +dalem29 +dalem3 +dalem30 +dalem31n +dalem32 +dalem33 +dalem34 +dalem35 +dalem36 +dalem37 +dalem38 +dalem39 +dalem4 +dalem40 +dalem41 +dalem42 +dalem43 +dalem44 +dalem45 +dalem46 +dalem47 +dalem48 +dalem49 +dalem5 +dalem50 +dalem51 +dalem52 +dalem53 +dalem54 +dalem55 +dalem56 +dalem57 +dalem58 +dalem59 +dalem6 +dalem60 +dalem61 +dalem62 +dalem63 +dalem7 +dalem8 +dalem9 +dalemccea +dalemcceb +dalemccnedd +dalemcea +dalemceb +dalemcjden +dalemclccjdd +dalemclpjs +dalemclqjt +dalemclrju +dalemcnes +dalemddea +dalemdea +dalemdnee +dalemeea +dalemkehl +dalemkelat +dalemkeop +dalempea +dalempeb +dalempjqeb +dalempjsen +dalemply +dalempnes +dalemqea +dalemqeb +dalemqnet +dalemqrprot +dalemrea +dalemreb +dalemrot +dalemrotps +dalemrotyz +dalemsea +dalemseb +dalemsjteb +dalemsly +dalemswapyz +dalemswapyzps +dalemtea +dalemteb +dalemtjueb +dalemuea +dalemueb +dalemyeb +dalemyeo +dalemzeo +dandysum2p2e4 +darapti +daraptialt +darboux_and_regulated_imp_continuous +darii +dariialt +data +data_center_cooling +datatype_num +datatypes +dath +dath2 +datisi +dchr1 +dchr1cl +dchr1re +dchr2sum +dchrabl +dchrabs +dchrabs2 +dchrbas +dchrelbas +dchrelbas2 +dchrelbas3 +dchrelbas4 +dchrelbasd +dchreq +dchrf +dchrfi +dchrghm +dchrhash +dchrinv +dchrinvcl +dchrisum +dchrisum0 +dchrisum0ff +dchrisum0flb +dchrisum0flblem1 +dchrisum0flblem2 +dchrisum0fmul +dchrisum0fno1 +dchrisum0fval +dchrisum0lem1 +dchrisum0lem1a +dchrisum0lem1b +dchrisum0lem2 +dchrisum0lem2a +dchrisum0lem3 +dchrisum0lema +dchrisum0re +dchrisumlem1 +dchrisumlem2 +dchrisumlem3 +dchrisumlema +dchrisumn0 +dchrmhm +dchrmul +dchrmulcl +dchrmullid +dchrmusum +dchrmusum2 +dchrmusumlem +dchrmusumlema +dchrn0 +dchrplusg +dchrpt +dchrptlem1 +dchrptlem2 +dchrptlem3 +dchrrcl +dchrresb +dchrsum +dchrsum2 +dchrval +dchrvmaeq0 +dchrvmasum +dchrvmasum2if +dchrvmasum2lem +dchrvmasumif +dchrvmasumiflem1 +dchrvmasumiflem2 +dchrvmasumlem +dchrvmasumlem1 +dchrvmasumlem2 +dchrvmasumlem3 +dchrvmasumlema +dchrzrh1 +dchrzrhcl +dchrzrhmul +dcomex +dcubic +dcubic1 +dcubic1lem +dcubic2 +ddcan +ddcand +ddemeas +ddeval0 +ddeval1 +ddif +de_morgan +de_morgan1 +de_morgan2 +de_morgan_1 +de_morgan_1_rev +de_morgan_2 +de_morgan_2_classical +de_morgan_2_constructive +de_morgan_2_rev +de_morgan_and +de_morgan_inter +de_morgan_or +de_morgan_thm +de_morgan_union +deadlock_free +dec +dec0h +dec0u +dec10p +dec2dvds +dec2nprm +dec5dvds +dec5dvds2 +dec5nprm +decadd +decaddc +decaddc2 +decaddci +decaddci2 +decaddcom +decaddi +decaddm10 +decbin0 +decbin2 +decbin3 +deccarry +deccl +decdiv10 +decelim +deceq1 +deceq12i +deceq1i +deceq2 +deceq2i +deceqbool +deceqnat +decex +decide_tac +decideelim +decideeq +declare +decle +decleh +declei +declt +decltc +decltdi +declth +declti +decma +decma2c +decmac +decmul1 +decmul10add +decmul1c +decmul2c +decmulnc +decnncl +decnncl2 +decnot +decomp_spec +decomposition +decpmataa0 +decpmatcl +decpmate +decpmatfsupp +decpmatid +decpmatmul +decpmatmullem +decpmatmulsumfsupp +decpmatval +decpmatval0 +decpmul +decpmulnc +decreases +decreasing_bounded_convergence +decreasing_bounded_variation +decreasing_bounded_variation_gen +decreasing_closed_nest +decreasing_closed_nest_sing +decreasing_countable_discontinuities +decreasing_imp_baire1 +decreasing_left_limit_1 +decreasing_left_limit_1_gen +decreasing_right_limit_1 +decreasing_right_limit_1_gen +decreasing_vector_variation +decrmac +decrmanc +decsmf +decsmflem +decsplit +decsplit0 +decsplit0b +decsplit1 +decsubi +decsuc +decsucc +dedekind +dedekindle +dedhb +dedlem0a +dedlem0b +dedlema +dedlemb +dedt +dedth +dedth2h +dedth2v +dedth3h +dedth3v +dedth4h +dedth4v +dedths +dedths2 +deep_intro_tac +defpred +deg1add +deg1addle +deg1addle2 +deg1addlt +deg1cl +deg1fval +deg1fvi +deg1ge +deg1gprod +deg1invg +deg1ldg +deg1ldgdomn +deg1ldgn +deg1le0 +deg1le0eq0 +deg1leb +deg1lt +deg1lt0 +deg1mhm +deg1mul +deg1mul2 +deg1mul3 +deg1mul3le +deg1mulle2 +deg1n0ima +deg1nn0cl +deg1nn0clb +deg1pow +deg1prod +deg1propd +deg1pw +deg1pwle +deg1scl +deg1sclle +deg1sub +deg1suble +deg1sublt +deg1submon1p +deg1tm +deg1tmle +deg1val +deg1vr +deg1vsca +deg1vscale +deg1xrcl +deg1xrf +deg1z +degltlem1 +degltp1le +delete +delete_comm +delete_delete +delete_eq_sing +delete_insert +delete_inter +delete_non_element +delete_subset +delete_subset_insert +demoivre +demoivrealt +demonstrates +demonstrating +demorgan1 +demorgan2 +demorgan_classical_1 +demorgan_classical_2 +demorganand +denexp +dense_complement_affine +dense_complement_convex +dense_complement_convex_closed +dense_complement_open_in_affine_hull +dense_complement_subspace +dense_gdelta_imp_large +dense_imp_perfect +dense_limit_points +dense_open_inter +dense_open_inters +densq +dep_pair_eta +dependent +dependent_2 +dependent_3 +dependent_affine_dependent_cases +dependent_biggerset +dependent_biggerset_general +dependent_choice +dependent_eq_dim_lt_card +dependent_explicit +dependent_finite +dependent_imp_affine_dependent +dependent_linear_image +dependent_linear_image_eq +dependent_mono +dependent_sing +depth_conv +dequeue_spec +derang0 +derangen +derangen2 +derangenlem +derangf +derangfmla +deranglem +derangsn +derangval +deriv_chain +derived_set_of_injective_linear_image +derived_set_of_restrict +derived_set_of_translation +derived_set_of_union +dest_string_lems +destruct +destruct_tac +det0 +det_0 +det_1 +det_1_gen +det_2 +det_3 +det_4 +det_cmul +det_cofactor +det_cofactor_expansion +det_dependent_columns +det_dependent_rows +det_diagonal +det_eq_0 +det_eq_0_rank +det_i +det_identical_columns +det_identical_rows +det_le_onorm_pow +det_linear_row_vsum +det_linear_rows +det_linear_rows_vsum +det_linear_rows_vsum_lemma +det_lowertriangular +det_matrix_eq_0 +det_matrix_eq_0_left +det_matrix_eq_0_right +det_matrix_inv +det_matrix_reflect_along +det_mul +det_neg +det_open_map +det_orthogonal_matrix +det_permute_columns +det_permute_rows +det_positive_definite +det_positive_semidefinite +det_row_add +det_row_mul +det_row_operation +det_row_span +det_rows_mul +det_similar +det_transp +det_uppertriangular +det_zero_column +det_zero_row +detid +detidres +detinidres +detlem +detxrnidres +df0op2 +df1o2 +df1st2 +df1stres +df2idl2 +df2idl2rng +df2nd2 +df2ndres +df2o2 +df2o3 +df3an2 +df3nandalt1 +df3nandalt2 +df3o2 +df3o3 +df3or2 +dfa_accept +dfa_state +dfac0 +dfac1 +dfac10 +dfac10b +dfac10c +dfac11 +dfac12 +dfac12a +dfac12k +dfac12lem1 +dfac12lem2 +dfac12lem3 +dfac12r +dfac13 +dfac14 +dfac14lem +dfac2 +dfac21 +dfac2a +dfac2b +dfac3 +dfac4 +dfac5 +dfac5lem1 +dfac5lem2 +dfac5lem3 +dfac5lem4 +dfac5lem4old +dfac5lem5 +dfac5prim +dfac7 +dfac8 +dfac8a +dfac8alem +dfac8b +dfac8c +dfac8clem +dfac9 +dfacacn +dfacbasgrp +dfacfin7 +dfackm +dfacycgr1 +dfadj2 +dfadjliftmap +dfadjliftmap2 +dfafn5a +dfafn5b +dfafv2 +dfafv22 +dfafv23 +dfaimafn +dfaimafn2 +dfaiota2 +dfaiota3 +dfantisymrel4 +dfantisymrel5 +dfarea +dfatafv2eqfv +dfatafv2ex +dfatafv2iota +dfatafv2rnb +dfatbrafv2b +dfatco +dfatcolem +dfatdmfcoafv2 +dfatelrn +dfateq12d +dfatopafv2b +dfatprc +dfatsnafv2 +dfbi +dfbi1 +dfbi1alt +dfbi1alta +dfbi1altb +dfbi2 +dfbi3 +dfbigcup2 +dfblockliftmap +dfblockliftmap2 +dfceil2 +dfcgra2 +dfcgrg2 +dfch2 +dfclel +dfcleq +dfclnbgr2 +dfclnbgr3 +dfclnbgr4 +dfclnbgr5 +dfclnbgr6 +dfcnfldold +dfcnqs +dfcnv2 +dfcnvrefrel2 +dfcnvrefrel3 +dfcnvrefrel4 +dfcnvrefrel5 +dfcnvrefrels2 +dfcnvrefrels3 +dfco2 +dfco2a +dfcoeleqvrel +dfcoeleqvrels +dfcoels +dfcoll2 +dfcomember +dfcomember2 +dfcomember3 +dfconn2 +dfconngr1 +dfcoss2 +dfcoss3 +dfcoss4 +dfdec10 +dfdec100 +dfdfat2 +dfdif2 +dfdif3 +dfdif3old +dfdisj2 +dfdisjaltv +dfdisjaltv2 +dfdisjaltv3 +dfdisjaltv4 +dfdisjaltv5 +dfdisjaltv5a +dfdisjs +dfdisjs2 +dfdisjs3 +dfdisjs4 +dfdisjs5 +dfdisjs6 +dfdisjs7 +dfdm2 +dfdm3 +dfdm4 +dfdm5 +dfdm6 +dfdmf +dfdom2 +dfec2 +dfef2 +dfeldisj2 +dfeldisj3 +dfeldisj4 +dfeldisj5 +dfeldisj5a +dfepfr +dfeqvrel2 +dfeqvrel3 +dfeqvrels2 +dfeqvrels3 +dfer2 +dferaltv2 +dfeu +dfeumo +dfeven2 +dfeven3 +dfeven4 +dfeven5 +dff12 +dff13 +dff13f +dff14a +dff14b +dff14i +dff15 +dff1o2 +dff1o3 +dff1o4 +dff1o5 +dff1o6 +dff2 +dff3 +dff4 +dffi2 +dffi3 +dffin1-5 +dffin7-2 +dffinxpf +dffix2 +dffltz +dffn2 +dffn3 +dffn4 +dffn5 +dffn5f +dffo2 +dffo3 +dffo3f +dffo4 +dffo5 +dffr2 +dffr2alt +dffr3 +dffr4 +dffr5 +dffr6 +dffrege115 +dffrege69 +dffrege76 +dffrege99 +dffun10 +dffun2 +dffun3 +dffun3f +dffun4 +dffun5 +dffun6 +dffun6f +dffun7 +dffun8 +dffun9 +dffunaltv2 +dffunaltv3 +dffunaltv4 +dffunaltv5 +dffunsaltv +dffunsaltv2 +dffunsaltv3 +dffunsaltv4 +dffunsaltv5 +dffv2 +dffv3 +dffv4 +dffv5 +dfgcd2 +dfgcd3 +dfgric2 +dfgrlic2 +dfgrlic3 +dfgrp2 +dfgrp2e +dfgrp3 +dfgrp3e +dfgrp3lem +dfhe2 +dfhe3 +dfhnorm2 +dfich2 +dfid2 +dfid3 +dfid4 +dfid5 +dfid6 +dfid7 +dfif2 +dfif3 +dfif4 +dfif5 +dfif6 +dfifp2 +dfifp3 +dfifp4 +dfifp5 +dfifp6 +dfifp7 +dfii2 +dfii3 +dfii4 +dfii5 +dfiin2 +dfiin2g +dfiin3 +dfiin3g +dfima2 +dfima3 +dfimafn +dfimafn2 +dfimafnf +dfin2 +dfin3 +dfin4 +dfin5 +dfinfre +dfinito2 +dfinito3 +dfinito4 +dfint2 +dfint3 +dfioo2 +dfiop2 +dfiota2 +dfiota3 +dfiota4 +dfiso2 +dfiso3 +dfitg +dfiun2 +dfiun2g +dfiun3 +dfiun3g +dfiunv2 +dfixp +dfle2 +dflidl2 +dflidl2rng +dflim2 +dflim3 +dflim4 +dflim5 +dflim6 +dflim7 +dflinc2 +dflog2 +dflt2 +dfmembpart2 +dfmgc2 +dfmgc2lem +dfmo +dfmo2 +dfmoeu +dfmpo +dfmpt +dfmpt3 +dfn0s2 +dfn2 +dfnan2 +dfnbgr2 +dfnbgr3 +dfnbgr5 +dfnbgr6 +dfnbgrss +dfnbgrss2 +dfnelbr2 +dfnf5 +dfnfc2 +dfnn2 +dfnn3 +dfnns2 +dfno2 +dfnot +dfnrm2 +dfnrm3 +dfnul2 +dfnul3 +dfnul4 +dfod2 +dfodd2 +dfodd3 +dfodd4 +dfodd5 +dfodd6 +dfodd7 +dfoi +dfom2 +dfom3 +dfom4 +dfom5 +dfom5b +dfom6 +dfon2 +dfon2lem1 +dfon2lem2 +dfon2lem3 +dfon2lem4 +dfon2lem5 +dfon2lem6 +dfon2lem7 +dfon2lem8 +dfon2lem9 +dfon3 +dfon4 +dfop +dfopab2 +dfopg +dfopif +dfoprab2 +dfoprab3 +dfoprab3s +dfoprab4 +dfoprab4f +dfor2 +dford2 +dford3 +dford3lem1 +dford3lem2 +dford4 +dford5 +dford5reg +dfpart2 +dfpet2parts2 +dfpeters2 +dfpetparts2 +dfphi2 +dfpjop +dfpo2 +dfpprod2 +dfpr2 +dfpre +dfpre2 +dfpre3 +dfpre4 +dfpred2 +dfpred3 +dfpred3g +dfpred4 +dfprm2 +dfprm3 +dfpss2 +dfpss3 +dfpth2 +dfqmap2 +dfqmap3 +dfqs2 +dfqs3 +dfrab2 +dfrab3 +dfrab3ss +dfral2 +dfrcl2 +dfrcl3 +dfrcl4 +dfrdg2 +dfrdg3 +dfrdg4 +dfrecs2 +dfrecs3 +dfrefrel2 +dfrefrel3 +dfrefrel5 +dfrefrels2 +dfrefrels3 +dfrel2 +dfrel3 +dfrel4 +dfrel4v +dfrel5 +dfrel6 +dfrelog +dfres2 +dfres3 +dfres4 +dfrex2 +dfrhm2 +dfringc2 +dfrn2 +dfrn3 +dfrn4 +dfrn5 +dfrn6 +dfrnf +dfrngc2 +dfrp2 +dfrtrcl2 +dfrtrcl3 +dfrtrcl4 +dfrtrcl5 +dfrtrclrec2 +dfs_visited +dfsalgen2 +dfsb +dfsb1 +dfsb2 +dfsb3 +dfsb7 +dfsbcq +dfsbcq2 +dfsclnbgr2 +dfsclnbgr6 +dfsdom2 +dfse2 +dfse3 +dfsingles2 +dfsmo2 +dfsn2 +dfsn2alt +dfso2 +dfso3 +dfss +dfss2 +dfss3 +dfss3f +dfss4 +dfss5 +dfss6 +dfss7 +dfssf +dfssr2 +dfsuccf2 +dfsuccl2 +dfsuccl3 +dfsuccl4 +dfsucmap2 +dfsucmap3 +dfsucmap4 +dfsucon +dfsup2 +dfswapf2 +dfsymdif2 +dfsymdif3 +dfsymdif4 +dfsymrel2 +dfsymrel3 +dfsymrel4 +dfsymrel5 +dfsymrels2 +dfsymrels3 +dfsymrels4 +dfsymrels5 +dftermc2 +dftermc3 +dftermo2 +dftermo3 +dftermo4 +dftp2 +dftpos2 +dftpos3 +dftpos4 +dftpos5 +dftpos6 +dftr2 +dftr2c +dftr3 +dftr4 +dftr5 +dftr6 +dftrcl3 +dftrrel2 +dftrrel3 +dftrrels2 +dftrrels3 +dftru2 +dfttrcl2 +dfufd2 +dfufd2lem +dfun2 +dfun3 +dfuni2 +dfuniv2 +dfur2 +dfuzi +dfv2 +dfvd1imp +dfvd1impr +dfvd1ir +dfvd2 +dfvd2an +dfvd2ani +dfvd2anir +dfvd2i +dfvd2imp +dfvd2impr +dfvd2ir +dfvd3 +dfvd3an +dfvd3ani +dfvd3anir +dfvd3i +dfvd3ir +dfvopnbgr2 +dfwe2 +dfwppr +dfxlim2 +dfxlim2v +dfxor4 +dfxor5 +dfxp3 +dfxrn2 +dfz12s2 +dfz2 +dgr0 +dgr1term +dgraa0p +dgraacl +dgraaf +dgraalem +dgraaub +dgraaval +dgradd +dgradd2 +dgrcl +dgrco +dgrcolem1 +dgrcolem2 +dgreq +dgreq0 +dgrid +dgrlb +dgrle +dgrlem +dgrlt +dgrmul +dgrmul2 +dgrmulc +dgrnznn +dgrsub +dgrsub2 +dgrub +dgrub2 +dgrval +dia0 +dia0eldmn +dia11n +dia1dim +dia1dim2 +dia1dimid +dia1eldmn +dia1eln +dia1n +dia2dim +dia2dimlem1 +dia2dimlem10 +dia2dimlem11 +dia2dimlem12 +dia2dimlem13 +dia2dimlem2 +dia2dimlem3 +dia2dimlem4 +dia2dimlem5 +dia2dimlem6 +dia2dimlem7 +dia2dimlem8 +dia2dimlem9 +diacln +diacnvcln +diadm +diadmcln +diadmlen +diael +diaeldm +diaelrnn +diaelval +diaf11n +diaf1on +diaffval +diafn +diafval +diag1 +diag11 +diag12 +diag1a +diag1cl +diag1f1 +diag1f1lem +diag1f1o +diag1f1olem +diag2 +diag2cl +diag2f1 +diag2f1lem +diag2f1o +diag2f1olem +diagcic +diagciso +diagcl +diagffth +diaglbn +diagonal_imp_symmetric_matrix +diagonal_matrix +diagonal_matrix_add +diagonal_matrix_cmul +diagonal_matrix_inv +diagonal_matrix_inv_component +diagonal_matrix_inv_explicit +diagonal_matrix_mat +diagonal_matrix_mul +diagonal_matrix_mul_component +diagonal_matrix_mul_eq +diagonal_positive_definite +diagonal_positive_semidefinite +diagonalization +diagonalzip +diagpropd +diagval +diainn +diaintcln +dialss +diameetn +diameter_affinity +diameter_attained_frontier +diameter_attained_relative_frontier +diameter_ball +diameter_bounded +diameter_bounded_bound +diameter_bounded_bound_lt +diameter_cball +diameter_closure +diameter_compact_attained +diameter_convex_hull +diameter_empty +diameter_eq_0 +diameter_frontier +diameter_interval +diameter_le +diameter_le_sums_left +diameter_le_sums_right +diameter_linear_image +diameter_lt_sums_left +diameter_lt_sums_right +diameter_pos_le +diameter_relative_frontier +diameter_scaling +diameter_simplex +diameter_sing +diameter_sphere +diameter_subset +diameter_subset_cball +diameter_subset_cball_nonempty +diameter_sums +diameter_translation +diameter_union_le +diameters_hausdist_bound +diamond +dian0 +diaocn +diaord +diarnn +diass +diassdvan +diasslssn +diatrl +diaval +dib0 +dib11n +dib1dim +dib1dim2 +dib2dim +dibcln +dibdiadm +dibdmn +dibeldmn +dibelval1st +dibelval1st1 +dibelval1st2n +dibelval2nd +dibelval3 +dibf11n +dibffval +dibfna +dibfnn +dibfval +dibglbn +dibintcln +diblsmopel +diblss +dibn0 +dibopelval2 +dibopelval3 +dibopelvaln +dibord +dibss +dibval +dibval2 +dibval3n +dibvalrel +dicdmn +dicelval1sta +dicelval1stn +dicelval2n +dicelval2nd +dicelval3 +dicelvaln +dicffval +dicfnn +dicfval +dickson +diclspsn +diclss +dicn0 +dicopelval +dicopelval2 +dicssdvh +dicvaddcl +dicval +dicval2 +dicvalreln +dicvscacl +diet_problem +dif0 +dif1card +dif1en +dif1enlem +dif1ennn +dif1ennnalt +dif1o +dif20el +dif32 +difab +difabs +difcom +difdif +difdif2 +difdifdir +difelcarsg +difelcarsg2 +difelfzle +difelfznle +difelpw +difelros +difelsiga +difeq +difeq1 +difeq12 +difeq12d +difeq12i +difeq1d +difeq1i +difeq2 +difeq2d +difeq2i +difeqri +difex2 +difexd +difexg +difexi +diff +diff_biginter +diff_biginter1 +diff_center +diff_chain_at +diff_chain_at_equal_ae +diff_chain_within +diff_chain_within_ae +diff_chain_within_equal_ae +diff_closure_subset +diff_comm +diff_diff +diff_diff_subset +diff_empty +diff_eq_empty +diff_function +diff_insert +diff_inter +diff_inter2 +diff_inter_compl +diff_inter_subset +diff_same_union +diff_subset +diff_union +diff_univ +difference-unsigned-byte-p +different_norm_3_collinear_points +differentiable_add +differentiable_at_imp_differentiable_on +differentiable_at_lift_dot2 +differentiable_at_within +differentiable_bound +differentiable_chain_at +differentiable_chain_within +differentiable_cmul +differentiable_componentwise_at +differentiable_componentwise_within +differentiable_const +differentiable_countable_preimages +differentiable_discrete_preimages +differentiable_discrete_preimages_closed +differentiable_finite_preimages +differentiable_finite_preimages_gen +differentiable_id +differentiable_imp_continuous_at +differentiable_imp_continuous_on +differentiable_imp_continuous_within +differentiable_imp_open_map +differentiable_imp_open_map_alt +differentiable_imp_open_map_gen +differentiable_lift_component +differentiable_linear +differentiable_mul_at +differentiable_mul_within +differentiable_neg +differentiable_on_add +differentiable_on_compose +differentiable_on_const +differentiable_on_empty +differentiable_on_eq +differentiable_on_eq_differentiable_at +differentiable_on_id +differentiable_on_lift_dot2 +differentiable_on_linear +differentiable_on_mul +differentiable_on_neg +differentiable_on_reflect +differentiable_on_sqnorm +differentiable_on_sub +differentiable_on_subset +differentiable_sqnorm_at +differentiable_sub +differentiable_transform_at +differentiable_transform_within +differentiable_vsum +differentiable_vsum_numseg +differentiable_within_lift_dot2 +differentiable_within_open +differentiable_within_subset +differential_component_neg_at_maximum +differential_component_pos_at_minimum +differential_component_zero_at_maxmin +differential_zero_levelset_density +differential_zero_maxmin +differential_zero_maxmin_component +differential_zero_maxmin_density +diffi +diffib +diffiunisros +diffs_affine_hull_span +diffsquares +difgtsumgt +difico +difid +difidalt +difin +difin0 +difin0ss +difin2 +difindi +difindir +difinf +difininv +difioo +difjust +difltmodne +difmap +difmapsn +difmbl +difmod0 +difmodm1lt +difn0 +difopab +difopn +difpr +difpreima +difprsn1 +difprsn2 +difprsnss +difrab +difrab0eq +difrab2 +difreicc +difres +difrp +difsn +difsnb +difsnen +difsnexi +difsnid +difsnpss +difsqpwdvds +difss +difss2 +difss2d +difssd +difsssymdif +difsymssdifssd +diftpsn3 +difun1 +difun2 +difuncomp +difundi +difundir +difunieq +difxp +difxp1 +difxp1ss +difxp2 +difxp2ss +dig0 +dig1 +dig2bits +dig2nn0 +dig2nn0ld +dig2nn1st +digexp +digfval +digit1 +digit2 +dignn0ehalf +dignn0flhalf +dignn0flhalflem1 +dignn0flhalflem2 +dignn0fr +dignn0ldlem +dignnld +digval +digvalnn0 +dih0 +dih0bn +dih0cnv +dih0rn +dih0sb +dih0vbn +dih1 +dih11 +dih1cnv +dih1dimat +dih1dimatlem +dih1dimatlem0 +dih1dimb +dih1dimb2 +dih1dimc +dih1rn +dih2dimb +dih2dimbaltn +dihat +dihatexv +dihatexv2 +dihatlat +dihcl +dihcnv11 +dihcnvcl +dihcnvid1 +dihcnvid2 +dihcnvord +dihdm +dihf11 +dihf11lem +dihffval +dihfn +dihfval +dihglb +dihglb2 +dihglbb +dihglbcn +dihglbcpren +dihglblem2an +dihglblem2n +dihglblem3an +dihglblem3n +dihglblem4 +dihglblem5 +dihglblem5an +dihglblem5apren +dihglblem6 +dihintcl +dihjat +dihjat1 +dihjat1lem +dihjat2 +dihjat3 +dihjat4 +dihjat5n +dihjat6 +dihjatb +dihjatc +dihjatc1 +dihjatc2n +dihjatc3 +dihjatcc +dihjatcclem1 +dihjatcclem2 +dihjatcclem3 +dihjatcclem4 +dihjust +dihjustlem +dihlatat +dihlsprn +dihlspsnat +dihlspsnssn +dihlss +dihlsscpre +dihmeet +dihmeet2 +dihmeetaltn +dihmeetbclemn +dihmeetbn +dihmeetcl +dihmeetcn +dihmeetlem10n +dihmeetlem11n +dihmeetlem12n +dihmeetlem13n +dihmeetlem14n +dihmeetlem15n +dihmeetlem16n +dihmeetlem17n +dihmeetlem18n +dihmeetlem19n +dihmeetlem1n +dihmeetlem20n +dihmeetlem2n +dihmeetlem3n +dihmeetlem4n +dihmeetlem4pren +dihmeetlem5 +dihmeetlem6 +dihmeetlem7n +dihmeetlem8n +dihmeetlem9n +dihoml4 +dihoml4c +dihopcl +dihopellsm +dihopelvalbn +dihopelvalc +dihopelvalcpre +dihopelvalcqat +dihord +dihord1 +dihord10 +dihord11b +dihord11c +dihord2 +dihord2a +dihord2b +dihord2cn +dihord2d +dihord2pre +dihord2pre2 +dihord3 +dihord4 +dihord5a +dihord5apre +dihord5b +dihord6a +dihord6apre +dihord6b +dihordlem6 +dihordlem7 +dihordlem7b +dihpn +dihprrn +dihprrnlem1n +dihprrnlem2 +dihrnlss +dihrnss +dihsmatrn +dihsmsnrn +dihsmsprn +dihss +dihsslss +dihssxp +dihsumssj +dihval +dihvalb +dihvalc +dihvalcq +dihvalcq2 +dihvalcqat +dihvalcqpre +dihvalrel +dihwn +dijkstra_correct +dilfsetn +dilsetn +dim_basis_image +dim_closure +dim_conic_hull +dim_convex_hull +dim_empty +dim_eq_0 +dim_eq_card +dim_eq_full +dim_eq_hyperplane +dim_eq_span +dim_eq_subspace +dim_eq_subspaces +dim_hyperplane +dim_image_kernel +dim_image_kernel_gen +dim_image_scale +dim_injective_linear_image +dim_injective_on_linear_image +dim_insert +dim_insert_0 +dim_kernel_compose +dim_le_card +dim_linear_image_le +dim_nonempty_interior +dim_open +dim_open_in +dim_orthogonal_sum +dim_pcross +dim_pcross_strong +dim_psubset +dim_rows_le_dim_columns +dim_sing +dim_span +dim_special_hyperplane +dim_special_subspace +dim_subset +dim_subset_univ +dim_subspace_orthogonal_to_vectors +dim_substandard +dim_sums_inter +dim_union_inter +dim_unique +dim_univ +dimatis +dimcl +dimindex_finite_prod +dimindex_finite_sum +dimindex_nonzero +dimkerim +dimlssid +dimpropd +dimval +dimvalfi +dini +dioph_conj +dioph_disj +dioph_exp_lemma +dioph_le +dioph_lt +dioph_ne +dioph_y +diophin +diophren +diophrex +diophrw +diophun +dip0l +dip0r +dipass +dipassr +dipassr2 +dipcj +dipcl +dipcn +dipdi +dipdir +dipfval +diporthcom +dipsubdi +dipsubdir +dir +dirdm +direction +dirge +dirith +dirith2 +dirker2re +dirkercncf +dirkercncflem1 +dirkercncflem2 +dirkercncflem3 +dirkercncflem4 +dirkerdenne0 +dirkerf +dirkeritg +dirkerper +dirkerre +dirkertrigeq +dirkertrigeqlem1 +dirkertrigeqlem2 +dirkertrigeqlem3 +dirkerval +dirkerval2 +dirref +dirtr +dis1stc +dis2ndc +disamis +discbas +disch_all +disch_tac +disch_then +discld +discmp +discr +discr1 +discrete_bounded_imp_finite +discrete_eq_finite_bounded +discrete_eq_finite_bounded_closed +discrete_eq_finite_compact +discrete_imp_closed +discrete_imp_countable +discrete_set +discsnterm +discsntermlem +discsubc +discsubclem +discthin +discthing +dishaus +disj +disj1 +disj1_tac +disj2 +disj2_tac +disj3 +disj4 +disj_aci +disj_assoc +disj_cases_tac +disj_cases_then +disj_comm +disj_sym +disjabrex +disjabrexf +disjabso +disjaltv0 +disjaltvid +disjaltvidres +disjaltvinidres +disjaltvxrnidres +disjcsn +disjdif +disjdif2 +disjdifb +disjdifprg +disjdifprg2 +disjdifr +disjdmqs +disjdmqscossss +disjdmqseq +disjdmqseqeq1 +disjdmqsss +disjdsct +disjeccnvep +disjecxrn +disjecxrncnvep +disjel +disjen +disjenex +disjeq +disjeq0 +disjeq1 +disjeq12d +disjeq12dv +disjeq12i +disjeq1d +disjeq1f +disjeq1i +disjeq2 +disjeq2dv +disjeqd +disjeqi +disjex +disjexc +disjf1 +disjf1o +disji +disji2 +disji2f +disjif +disjif2 +disjim +disjimdmqseq +disjimeceqbi +disjimeceqbi2 +disjimeceqim +disjimeceqim2 +disjimeldisjdmqs +disjimi +disjimin +disjiminres +disjimres +disjimrmoeqec +disjimxrn +disjimxrnres +disjin +disjin2 +disjinfi +disjiun +disjiun2 +disjiunb +disjiund +disjiunel +disjlem14 +disjlem17 +disjlem18 +disjlem19 +disjne +disjnf +disjoint +disjoint_affine_hull +disjoint_alt +disjoint_biginter +disjoint_count +disjoint_count_from +disjoint_def +disjoint_delete_sym +disjoint_diff +disjoint_diffs +disjoint_empty +disjoint_empty_refl +disjoint_from_count +disjoint_genlist_plus +disjoint_halfspaces_imp_collinear +disjoint_hyperplanes_imp_collinear +disjoint_image +disjoint_insert +disjoint_insert_imp +disjoint_insert_notin +disjoint_interval +disjoint_interval_1 +disjoint_relative_interior_convex_hull +disjoint_restrict +disjoint_same +disjoint_sing +disjoint_sing_empty +disjoint_subset +disjoint_sym +disjoint_two +disjoint_union +disjoint_union_both +disjointd +disjointi +disjor +disjord +disjorf +disjorimxrn +disjors +disjorsf +disjpr2 +disjpreima +disjprg +disjprsn +disjpss +disjqmap +disjqmap2 +disjr +disjrdx +disjrel +disjres +disjresdif +disjresdisj +disjresin +disjressuc2 +disjresundif +disjrnmpt +disjrnmpt2 +disjsn +disjsn2 +disjsnxp +disjss +disjss1 +disjss1f +disjss2 +disjss3 +disjssd +disjssi +disjsssrels +disjssun +disjsuc +disjsuc2 +disjtp2 +disjtpsn +disjun0 +disjunctio +disjunction +disjunction_elim +disjunction_property +disjuniel +disjunion_univ +disjunsn +disjwrdpfx +disjx0 +disjxiun +disjxp1 +disjxpin +disjxrn +disjxrnres5 +disjxsn +disjxun +disjxun0 +disjxwwlkn +disjxwwlksn +dislly +disllycmp +disp +dispatch +dispatchcorrectness +dispatchordering +dispcmp +dissneq +dissneqlem +dissnlocfin +dissnref +dissym1 +dist_0 +dist_1 +dist_closest_point_lipschitz +dist_convex_hull_bound_2 +dist_convex_hull_bound_eq +dist_decreases_closed_segment +dist_decreases_open_segment +dist_descale +dist_endpoints_le_path_length +dist_eq +dist_eq_0 +dist_fstcart +dist_in_closed_segment_2 +dist_in_open_segment +dist_increases_online +dist_le_0 +dist_le_diameter +dist_le_pastecart +dist_lift +dist_midpoint +dist_mul +dist_nz +dist_pastecart_cancel +dist_pastecart_le +dist_points_le_path_length +dist_pos_le +dist_pos_lt +dist_real +dist_refl +dist_rescale +dist_sndcart +dist_sym +dist_triangle +dist_triangle_add +dist_triangle_add_half +dist_triangle_alt +dist_triangle_eq +dist_triangle_half_l +dist_triangle_half_r +dist_triangle_le +dist_triangle_lt +distance_attains_inf +distance_attains_sup +distel +distgp +distinct_append +distinct_length_le +distinct_walk_in_walks_le +distinct_walk_length_le +distop +distopon +distps +distr +distrib +distrib-left +distrib_left +distrib_union_inter +distribution +distributive +distributive1 +distributive2 +distributivity-of-*-over-+ +distrlem1pr +distrlem4pr +distrlem5pr +distrnq +distrpi +distrpr +distrsr +distspace +ditg0 +ditgcl +ditgeq1 +ditgeq123dv +ditgeq123i +ditgeq12d +ditgeq12i +ditgeq2 +ditgeq3 +ditgeq3d +ditgeq3dv +ditgeq3i +ditgeq3sdv +ditgeqiooicc +ditgex +ditgneg +ditgpos +ditgsplit +ditgsplitlem +ditgswap +div +div-mod +div0 +div0d +div0i +div0old +div1 +div11 +div11d +div11i +div11old +div12 +div12d +div13 +div13d +div1d +div1i +div23 +div23d +div23i +div2_add +div2_mul2 +div2_mul2_aux +div2_sub +div2neg +div2negd +div2sub +div2subd +div32 +div32d +div4p1lem1div2 +div_0_imp_lt +div_15 +div_3 +div_5 +div_algorithm +div_div_div_mult +div_eq_0 +div_eq_x +div_exact +div_extraction +div_function +div_le_monotone +div_le_x +div_less +div_less_eq +div_lt_x +div_mod +div_mod_id +div_mod_identity +div_mod_mod_div +div_mult +div_nonneg +div_one +div_p +div_p_univ +div_rat +div_ratl +div_ratr +div_self +div_sub +div_succ_1 +div_succ_2 +div_unique +divadddiv +divadddivd +divadddivi +divalg +divalg2 +divalgb +divalglem0 +divalglem1 +divalglem10 +divalglem2 +divalglem4 +divalglem5 +divalglem6 +divalglem7 +divalglem8 +divalglem9 +divalgmod +divalgmodcl +divass +divassd +divassi +divasszi +divcan1 +divcan1d +divcan1i +divcan1zi +divcan2 +divcan2d +divcan2i +divcan2zi +divcan3 +divcan3d +divcan3i +divcan3zi +divcan4 +divcan4d +divcan4i +divcan4zi +divcan5 +divcan5d +divcan5rd +divcan6 +divcan6d +divcan7 +divcan7d +divcan8d +divccn +divccncf +divccnold +divcl +divcld +divcli +divclzi +divcn +divcncf +divcncff +divcnold +divcnv +divcnvg +divcnvlin +divcnvshft +divconjdvds +divcxp +divcxpd +divdenle +divdir +divdird +divdiri +divdirzi +divdiv1 +divdiv1d +divdiv2 +divdiv23zi +divdiv2d +divdiv32 +divdiv32d +divdiv32i +divdiv3d +divdivdiv +divdivdivd +divdivdivi +divdivs1d +divelunit +diveq0 +diveq0ad +diveq0d +diveq1 +diveq1ad +diveq1bd +diveq1d +divfl0 +divgcdcoprm0 +divgcdcoprmex +divgcdnn +divgcdnnr +divgcdodd +divgcdoddaltv +divgcdz +divge0 +divge0d +divge0i +divge1 +divge1b +divgt0 +divgt0d +divgt0i +divgt0i2i +divgt0ii +divgt1b +divid +dividd +divides +divides_gcd +divides_one +divides_refl +divides_zero +dividi +dividold +division +division_1_sort +division_common_point_bound +division_contains +division_disjoint_union +division_doublesplit +division_inter +division_inter_1 +division_of +division_of_affinity +division_of_closed +division_of_content_0 +division_of_finite +division_of_nontrivial +division_of_reflect +division_of_self +division_of_sing +division_of_subset +division_of_tagged_division +division_of_translation +division_of_trivial +division_of_union_self +division_of_unions +division_points_finite +division_points_psubset +division_points_subset +division_split +division_split_left_inj +division_split_right_inj +division_union_intervals_exists +divle1le +divlimc +divlogrlim +divlt0gt0d +divlt1lt +divmod_calc +divmod_correct +divmod_elim_thm +divmod_exist +divmod_id +divmod_uniq +divmodidentity +divmul +divmul13 +divmul13d +divmul13i +divmul2 +divmul24 +divmul24d +divmul2d +divmul3 +divmul3d +divmulass +divmulasscom +divmuld +divmuldiv +divmuldivd +divmuldivi +divmuldivsd +divmuleq +divmuleqd +divmuli +divmuls +divmulsd +divmulsw +divmulswd +divmulzi +divne0 +divne0b +divne0bd +divne0d +divne0i +divne1d +divneg +divneg2 +divneg2d +divnegd +divnumden +divnumden2 +divrcnv +divrec +divrec2 +divrec2d +divrecd +divreci +divreczi +divrngcl +divrngidl +divrngpr +divs1 +divs1d +divsassd +divsasswd +divscan1d +divscan1wd +divscan2d +divscan2wd +divscan3d +divscl +divscld +divsclw +divsclwd +divsdird +divsfval +divsmo +divsqrsum +divsqrsumf +divsqrtid +divsqrtsum2 +divsqrtsumlem +divsqrtsumo1 +divsrecd +divsub1dir +divsubdir +divsubdird +divsubdiv +divsubdivd +divsval +divval +djacln +djaffvaln +djafvaln +djajn +djavaln +djh01 +djh02 +djhcl +djhcom +djhcvat42 +djhexmid +djhffval +djhfval +djhj +djhjlj +djhlj +djhljjn +djhlsmat +djhlsmcl +djhspss +djhsumss +djhunssn +djhval +djhval2 +dju0en +dju1dif +dju1en +dju1p1e2 +dju1p1e2alt +djuassen +djucomen +djudisj +djudom1 +djudom2 +djudoml +djuen +djuenun +djueq1 +djueq12 +djueq2 +djuex +djuexalt +djuexb +djufi +djuin +djuinf +djulcl +djulepw +djulf1o +djunum +djur +djurcl +djurf1o +djuss +djussxp +djussxp2 +djuun +djuunxp +djuxpdom +dlatjmdi +dlatl +dlatmjdi +dlwwlknondlwlknonen +dlwwlknondlwlknonf1o +dlwwlknondlwlknonf1olem1 +dm0 +dm0rn0 +dm0rn0old +dm1cosscnvepres +dmaddpi +dmaddsr +dmadjop +dmadjrn +dmadjrnb +dmadjss +dmaf +dmafv2rnb +dmarea +dmataltbas +dmataltbasel +dmataltval +dmatbas +dmatcrng +dmatel +dmatelnd +dmatid +dmatmat +dmatmul +dmatmulcl +dmatscmcl +dmatsgrp +dmatsrng +dmatsubcl +dmatval +dmclimxlim +dmcnvcnv +dmcnvep +dmcnvepres +dmco +dmcoass +dmcoels +dmcoeq +dmcoss +dmcoss2 +dmcoss3 +dmcosseq +dmcosseqold +dmcosseqoldold +dmcossold +dmct +dmcuts +dmdbr +dmdbr2 +dmdbr3 +dmdbr4 +dmdbr4ati +dmdbr5 +dmdbr5ati +dmdbr6ati +dmdbr7ati +dmdcan +dmdcan2d +dmdcand +dmdcompli +dmdi +dmdi2 +dmdi4 +dmdju +dmdm +dmdmd +dmdoc1i +dmdoc2i +dmdprd +dmdprdd +dmdprdpr +dmdprdsplit +dmdprdsplit2 +dmdprdsplit2lem +dmdprdsplitlem +dmdsl3 +dmdsym +dmec2d +dmecd +dmep +dmeq +dmeqd +dmeqi +dmex +dmexd +dmexg +dmfco +dmfcoafv +dmfex +dmfexalt +dmfi +dmgmaddn0 +dmgmaddnn0 +dmgmdivn0 +dmgmn0 +dmhashres +dmi +dmico +dmiin +dmin +dminss +dminxp +dmiun +dmlogdmgm +dmmcand +dmmeas +dmmeasal +dmmp +dmmpo +dmmpog +dmmpoga +dmmpossx +dmmpossx2 +dmmpt +dmmpt1 +dmmptd +dmmptdf +dmmptdf2 +dmmptdff +dmmptg +dmmpti +dmmptif +dmmptss +dmmptssf +dmmulpi +dmmulsr +dmmzp +dmncan1 +dmncan2 +dmncrng +dmnnzd +dmnonrel +dmnrngo +dmopab +dmopab2rex +dmopab3 +dmopab3rexdif +dmopabelb +dmopabss +dmoprab +dmoprabss +dmovn +dmovnsal +dmplp +dmprop +dmpropg +dmqmap +dmqs1cosscnvepreseq +dmqsblocks +dmqscoelseq +dmqseq +dmqseqd +dmqseqeq1 +dmqseqeq1d +dmqseqeq1i +dmqseqi +dmqseqim +dmqseqim2 +dmqsex +dmrab +dmrecnq +dmrelrnrel +dmres +dmresexg +dmresi +dmressnsn +dmresss +dmresv +dmrnssfld +dmrnxp +dmsigagen +dmsn0 +dmsn0el +dmsnn0 +dmsnop +dmsnopg +dmsnopss +dmsnsnsn +dmss +dmsucmap +dmtopon +dmtpop +dmtpos +dmtposss +dmtrcl +dmtrclfv +dmtrclfvrp +dmttrcl +dmun +dmuncnvepres +dmuni +dmuz +dmv +dmvlsiga +dmvolsal +dmvolss +dmvon +dmwf +dmxp +dmxpid +dmxpin +dmxpss +dmxrn +dmxrncnvep +dmxrncnvepres +dmxrncnvepres2 +dmxrnuncnvepres +dn-intro +dn1 +dne +dnibnd +dnibndlem1 +dnibndlem10 +dnibndlem11 +dnibndlem12 +dnibndlem13 +dnibndlem2 +dnibndlem3 +dnibndlem4 +dnibndlem5 +dnibndlem6 +dnibndlem7 +dnibndlem8 +dnibndlem9 +dnicld1 +dnicld2 +dnicn +dnif +dnival +dnizeq0 +dnizphlfeqhlf +dnnumch1 +dnnumch2 +dnnumch3 +dnnumch3lem +dnsconst +dnwech +do +doca2n +doca3n +docacln +docaffvaln +docafvaln +docavaln +doch0 +doch1 +doch11 +doch2val2 +dochcl +dochdmj1 +dochdmm1 +dochexmid +dochexmidat +dochexmidlem1 +dochexmidlem2 +dochexmidlem3 +dochexmidlem4 +dochexmidlem5 +dochexmidlem6 +dochexmidlem7 +dochexmidlem8 +dochffval +dochfl1 +dochflcl +dochfln0 +dochfn +dochfval +dochkr1 +dochkr1oldn +dochkrsat +dochkrsat2 +dochkrshp +dochkrshp2 +dochkrshp3 +dochkrshp4 +dochkrsm +dochlkr +dochlss +dochn0nv +dochnel +dochnel2 +dochnoncon +dochoc +dochoc0 +dochoc1 +dochoccl +dochocsn +dochocsp +dochocss +dochord +dochord2n +dochord3 +dochpoln +dochsat +dochsat0 +dochsatshp +dochsatshpb +dochshpncl +dochshpsat +dochsncom +dochsnkr +dochsnkr2 +dochsnkr2cl +dochsnkrlem1 +dochsnkrlem2 +dochsnkrlem3 +dochsnnz +dochsnshp +dochsordn +dochspocn +dochspss +dochss +dochsscl +dochssv +dochval +dochval2 +dochvalr +dochvalr2 +dochvalr3 +dom0 +dom2 +dom2d +dom2lem +dom3 +dom3d +domalom +domdifsn +domen +domen1 +domen2 +domeng +domentr +domfi +domfin4 +dominated_convergence +dominated_convergence_absolutely_integrable +dominated_convergence_ae +dominated_convergence_integrable +dominf +dominfac +domnchr +domneq0 +domneq0r +domnexpgn0cl +domnlcan +domnlcanb +domnlcanbold +domnlcanold +domnmsuppn0 +domnmuln0 +domnmuln0rd +domnnzr +domnprodeq0 +domnprodn0 +domnpropd +domnrcan +domnrcanb +domnring +domnrrg +domnsym +domnsymfi +domprobmeas +domprobsiga +domrefg +domsdomtr +domsdomtrfi +domss2 +domssex +domssex2 +domssl +domssr +domtr +domtrfi +domtrfil +domtrfir +domtri +domtri2 +domtriom +domtriomlem +domtriord +domunfican +domunsn +domunsncan +domwdom +dot_1 +dot_2 +dot_3 +dot_4 +dot_basis +dot_basis_basis +dot_basis_basis_unequal +dot_cauchy_schwarz_equal +dot_dropout +dot_eq_0 +dot_ladd +dot_lmul +dot_lmul_matrix +dot_lneg +dot_lsub +dot_lsum +dot_lzero +dot_matrix_product +dot_matrix_transp_lmul +dot_matrix_transp_rmul +dot_matrix_vector_mul +dot_norm +dot_norm_sub +dot_pastecart +dot_pos_le +dot_pos_lt +dot_product +dot_pushin +dot_radd +dot_rmul +dot_rneg +dot_rowvector_columnvector +dot_rsub +dot_rsum +dot_rzero +dot_scaling +dot_square_norm +dot_sym +dot_vectorize +double_add +double_integrable_convolution +double_integral_convolution +double_lebesgue_measurable +double_lebesgue_measurable_inverse_function +double_lebesgue_measurable_inverse_function_gen +double_lebesgue_measurable_left_inverse +double_lebesgue_measurable_on +double_lebesgue_measurable_right_inverse +double_neg +double_neg_elim +double_neg_excluded_middle +double_neg_intro +double_neg_intro_pf +double_neg_shift +double_negation +double_negation_elim +double_negation_intro +dp0h +dp0u +dp20h +dp20u +dp2cl +dp2clq +dp2eq1 +dp2eq12i +dp2eq1i +dp2eq2 +dp2eq2i +dp2lt +dp2lt10 +dp2ltc +dp2ltsuc +dp3mul10 +dpadd +dpadd2 +dpadd3 +dpair +dpairelim +dpairfst +dpairsnd +dpcl +dpexpp1 +dpfrac1 +dpgti +dpjcntz +dpjdisj +dpjeq +dpjf +dpjfval +dpjghm +dpjghm2 +dpjid +dpjidcl +dpjlem +dpjlid +dpjlsm +dpjrid +dpjval +dpll_terminates +dplt +dpltc +dplti +dpmul +dpmul10 +dpmul100 +dpmul1000 +dpmul4 +dprd0 +dprd2d2 +dprd2da +dprd2db +dprd2dlem1 +dprd2dlem2 +dprdcntz +dprdcntz2 +dprddisj +dprddisj2 +dprddomcld +dprddomprc +dprdf +dprdf1 +dprdf11 +dprdf1o +dprdf2 +dprdfadd +dprdfcl +dprdfcntz +dprdfeq0 +dprdff +dprdffsupp +dprdfid +dprdfinv +dprdfsub +dprdgrp +dprdlub +dprdpr +dprdres +dprdsn +dprdspan +dprdsplit +dprdss +dprdssv +dprdsubg +dprdub +dprdval +dprdval0prc +dprdw +dprdwd +dprdz +dpval +dpval2 +dpval3 +dpval3rp +dquart +dquartlem1 +dquartlem2 +dral1 +dral1-o +dral1alt +dral1v +dral2 +dral2-o +drex1 +drex1v +drex2 +drgext0g +drgext0gsca +drgextgsum +drgextlsp +drgextsubrg +drgextvsca +drhmsubc +drhmsubcaltv +drnf1 +drnf1v +drnf2 +drnfc1 +drnfc2 +drng0mxidl +drngcat +drngcataltv +drngdimgt0 +drngdomn +drnggrp +drnggrpd +drngid +drngid2 +drngidl +drngidlhash +drnginvmuld +drnginvrcl +drnginvrcld +drnginvrl +drnginvrld +drnginvrn0 +drnginvrn0d +drnginvrr +drnginvrrd +drnglidl1ne0 +drnglpir +drngmcl +drngmclold +drngmgp +drngmul0or +drngmul0orold +drngmuleq0 +drngmullcan +drngmulne0 +drngmulrcan +drngmxidl +drngmxidlr +drngnidl +drngnzr +drngoi +drngprop +drngpropd +drngring +drngringd +drnguc1p +drngui +drngunit +drngunz +drop +drop_add +drop_append +drop_append1 +drop_append2 +drop_basis +drop_cmul +drop_differential_neg_at_maximum +drop_differential_pos_at_minimum +drop_eq +drop_eq_0 +drop_genlist +drop_in_image_drop +drop_in_real_interval +drop_indicator +drop_indicator_abs_le_1 +drop_indicator_le_1 +drop_indicator_pos_le +drop_lambda +drop_length_too_long +drop_midpoint +drop_neg +drop_nil +drop_splitatpki +drop_sub +drop_take +drop_vec +drop_vsum +drop_wlog_le +drop_zero +dropab1 +dropab2 +dropout_0 +dropout_add +dropout_eq +dropout_galois +dropout_mul +dropout_pushin +dropout_sub +dropwhile_append_every +dropwhile_append_exists +dropwhile_eq_nil +dropwhile_id +dropwhile_splitatpki +drsb1 +drsb2 +drsbn0 +drsdir +drsdirfi +drsprs +dscmet +dscopn +dsid +dsmm0cl +dsmmacl +dsmmbas2 +dsmmbase +dsmmelbas +dsmmfi +dsmmlmod +dsmmlss +dsmmsubg +dsmmval +dsmmval2 +dsndx +dsndxnbasendx +dsndxnmulrndx +dsndxnn +dsndxnplusgndx +dsndxntsetndx +dssmap2d +dssmapclsntr +dssmapf1od +dssmapfv2d +dssmapfv3d +dssmapfvd +dssmapntrcls +dssmapnvod +dstfrvclim1 +dstfrvel +dstfrvinc +dstfrvunirn +dstregt0 +dstrvprob +dstrvval +dsum_bound +dtru +dtrualt +dtrualt2 +dtrucor +dtrucor2 +dtrucor3 +dual +duality +dugundji +dummylink +dutch_flag +dutchnationalflag +dv11cn +dva0g +dva1dim +dvaabl +dvabase +dvacos +dvadd +dvaddbr +dvaddf +dvadian +dvafmulr +dvafplusg +dvafset +dvafvadd +dvafvsca +dvalvec +dvalveclem +dvamulr +dvaplusg +dvaplusgv +dvasca +dvaset +dvasin +dvasinbx +dvatan +dvavadd +dvavbase +dvavsca +dvbdfbdioo +dvbdfbdioolem1 +dvbdfbdioolem2 +dvbss +dvbssntr +dvbsss +dvcj +dvcjbr +dvcl +dvcmul +dvcmulf +dvcn +dvcncxp1 +dvcnp +dvcnp2 +dvcnp2old +dvcnre +dvcnsqrt +dvcnv +dvcnvlem +dvcnvre +dvcnvrelem1 +dvcnvrelem2 +dvco +dvcobr +dvcobrold +dvcof +dvconst +dvconstbi +dvcos +dvcosax +dvcosre +dvcvx +dvcxp1 +dvcxp2 +dvdemo1 +dvdemo2 +dvdivbd +dvdivcncf +dvdivf +dvdmsscn +dvds0 +dvds0lem +dvds1 +dvds1lem +dvds2add +dvds2addd +dvds2lem +dvds2ln +dvds2sub +dvds2subd +dvdsabsb +dvdsabseq +dvdsabsmod0 +dvdsacongtr +dvdsadd +dvdsadd2b +dvdsaddr +dvdsaddre2b +dvdschrmulg +dvdscmul +dvdscmulr +dvdsdivcl +dvdseq +dvdsexp +dvdsexp2im +dvdsexpad +dvdsexpb +dvdsexpim +dvdsexpnn +dvdsexpnn0 +dvdsext +dvdsfac +dvdsfi +dvdsflf1o +dvdsflip +dvdsflsumcom +dvdsgcd +dvdsgcdb +dvdsgcdidd +dvdslcm +dvdslcmf +dvdsle +dvdsleabs +dvdsleabs2 +dvdslegcd +dvdslelem +dvdsmod +dvdsmod0 +dvdsmodexp +dvdsmul1 +dvdsmul2 +dvdsmulc +dvdsmulcr +dvdsmulf1o +dvdsmulgcd +dvdsmultr1 +dvdsmultr1d +dvdsmultr2 +dvdsmultr2d +dvdsn1add +dvdsnegb +dvdsnprmd +dvdsppwf1o +dvdsprime +dvdsprm +dvdsprmpweq +dvdsprmpweqle +dvdsprmpweqnn +dvdsq1p +dvdsr +dvdsr01 +dvdsr02 +dvdsr1p +dvdsr2 +dvdsrabdioph +dvdsrcl +dvdsrcl2 +dvdsrid +dvdsrmul +dvdsrmul1 +dvdsrneg +dvdsrpropd +dvdsrspss +dvdsrtr +dvdsruasso +dvdsruasso2 +dvdsruassoi +dvdsrval +dvdsrzring +dvdssq +dvdssqf +dvdssqim +dvdssqlem +dvdsssfz1 +dvdssub +dvdssub2 +dvdssubr +dvdstr +dvdstrd +dvdsunit +dvdsval2 +dvdsval3 +dvdszrcl +dvdszzq +dveel1 +dveel2 +dveel2alt +dveeq1 +dveeq1-o +dveeq1-o16 +dveeq2 +dveeq2-o +dveeq2alt +dvef +dveflem +dvelim +dvelimalcased +dvelimalcasei +dvelimc +dvelimdc +dvelimdf +dvelimexcased +dvelimexcasei +dvelimf +dvelimf-o +dvelimh +dvelimhw +dvelimnf +dvelimv +dveq0 +dvexp +dvexp2 +dvexp3 +dvf +dvfcn +dvferm +dvferm1 +dvferm1lem +dvferm2 +dvferm2lem +dvfg +dvfre +dvfsum2 +dvfsumabs +dvfsumge +dvfsumle +dvfsumlem1 +dvfsumlem2 +dvfsumlem2old +dvfsumlem3 +dvfsumlem4 +dvfsumleold +dvfsumrlim +dvfsumrlim2 +dvfsumrlim3 +dvfsumrlimf +dvfsumrlimge0 +dvfval +dvge0 +dvgrat +dvgt0 +dvgt0lem1 +dvgt0lem2 +dvh0g +dvh1dim +dvh1dimat +dvh2dim +dvh2dimatn +dvh3dim +dvh3dim2 +dvh3dim3n +dvh3dimatn +dvh4dimat +dvh4dimlem +dvh4dimn +dvhb1dimn +dvhbase +dvhdimlem +dvhelvbasei +dvheveccl +dvhfmulr +dvhfplusr +dvhfset +dvhfvadd +dvhfvsca +dvhgrp +dvhlmod +dvhlvec +dvhlveclem +dvhmulr +dvhopaddn +dvhopcln +dvhopellsm +dvhopn +dvhopspn +dvhopvadd +dvhopvadd2 +dvhopvsca +dvhsca +dvhset +dvhvadd +dvhvaddass +dvhvaddcbv +dvhvaddcl +dvhvaddcomn +dvhvaddval +dvhvbase +dvhvsca +dvhvscacbv +dvhvscacl +dvhvscaval +dvid +dvidlem +dvivth +dvivthlem1 +dvivthlem2 +dvle +dvle2 +dvlem +dvlip +dvlip2 +dvlipcn +dvlog +dvlog2 +dvlog2lem +dvloglem +dvlt0 +dvmptadd +dvmptc +dvmptcj +dvmptcl +dvmptcmul +dvmptco +dvmptconst +dvmptdiv +dvmptdivc +dvmptfprod +dvmptfprodlem +dvmptfsum +dvmptid +dvmptidg +dvmptim +dvmptmul +dvmptmulf +dvmptneg +dvmptntr +dvmptre +dvmptrecl +dvmptres +dvmptres2 +dvmptres3 +dvmptresicc +dvmptsub +dvmul +dvmulbr +dvmulbrold +dvmulcncf +dvmulf +dvn0 +dvn1 +dvn2bss +dvnadd +dvnbss +dvne0 +dvne0f1 +dvnf +dvnff +dvnfre +dvnfval +dvnmptconst +dvnmptdivc +dvnmul +dvnp1 +dvnply +dvnply2 +dvnprod +dvnprodlem1 +dvnprodlem2 +dvnprodlem3 +dvnres +dvntaylp +dvntaylp0 +dvnxpaek +dvply1 +dvply2 +dvply2g +dvply2gold +dvr1 +dvradcnv +dvradcnv2 +dvrass +dvrcan1 +dvrcan3 +dvrcan5 +dvrcl +dvrcn +dvrdir +dvreacos +dvreasin +dvrec +dvrecg +dvrelog +dvrelog2 +dvrelog2b +dvrelog3 +dvrelogpow2b +dvreq1 +dvres +dvres2 +dvres2lem +dvres3 +dvres3a +dvresioo +dvreslem +dvresntr +dvrfval +dvrid +dvrunz +dvrval +dvsconst +dvsef +dvsid +dvsin +dvsinax +dvsincos +dvsinexp +dvsqrt +dvsubcncf +dvsubf +dvtan +dvtanlem +dvtaylp +dvun +dvxpaek +dya2icobrsiga +dya2icoseg +dya2icoseg2 +dya2iocbrsiga +dya2iocct +dya2iocival +dya2iocnei +dya2iocnrect +dya2iocress +dya2iocrfn +dya2iocrrnval +dya2iocucvr +dya2iocuni +dya2ub +dyaddisj +dyaddisjlem +dyadf +dyadic +dyadmax +dyadmaxlem +dyadmbl +dyadmbllem +dyadovol +dyadss +dyadval +dynkin +e +e00 +e000 +e001 +e002 +e00an +e01 +e010 +e011 +e012 +e01an +e02 +e020 +e021 +e022 +e02an +e03 +e03an +e0a +e0bi +e0bir +e10 +e100 +e101 +e102 +e10an +e11 +e110 +e111 +e1111 +e112 +e11an +e12 +e120 +e121 +e122 +e123 +e12an +e13 +e13an +e1a +e1bi +e1bir +e2 +e20 +e200 +e201 +e202 +e20an +e21 +e210 +e211 +e212 +e21an +e22 +e220 +e221 +e222 +e223 +e22an +e23 +e233 +e23an +e2bi +e2bir +e2ebind +e2ebindalt +e2ebindvd +e3 +e30 +e30an +e31 +e31an +e32 +e323 +e32an +e33 +e333 +e33an +e3bi +e3bir +e_spec +each +ebtwntg +ec0 +ec1cnvres +ecase +ecase13d +ecase23d +ecase2d +ecase3 +ecase3ad +ecase3d +ecased +eccnvep +eccnvepres +eccnvepres2 +eccnvepres3 +ecdmn0 +eceldmqs +eceldmqsxrncnvepres +eceldmqsxrncnvepres2 +ecelqs +ecelqsdm +ecelqsdmb +ecelqsi +ecelqsw +eceq1 +eceq1d +eceq1i +eceq2 +eceq2d +eceq2i +eceqoveq +ecexg +ecexr +ecgrtg +echidna +echidnabot +ecid +ecidsn +ecin0 +ecinn0 +ecinxp +eclclwwlkn1 +eclipse +ecopoveq +ecopover +ecopovsym +ecopovtrn +ecopqsi +ecoptocl +ecovass +ecovcom +ecovdi +ecqmap +ecqmap2 +ecqs +ecqusaddcl +ecqusaddd +ecref +ecres +ecss +ectocl +ectocld +ecun +ecuncnvepres +ecunres +ecxp +ecxpid +ecxrn +ecxrn2 +ecxrncnvep +ecxrncnvep2 +edelstein_fix +edelstein_fix_iter +edg0iedg0 +edg0usgr +edge_of_imp_subset +edge_of_linear_image +edge_of_translation_eq +edge_to_walk +edges_of_subset +edgfid +edgfiedgval +edgfndx +edgfndxid +edgfndxnn +edgiedgb +edginwlk +edglnl +edgnbusgreu +edgopval +edgov +edgssv2 +edgstruct +edguhgr +edgumgr +edgupgr +edgusgr +edgusgrclnbfin +edgusgrnbfin +edgval +ee001 +ee002 +ee010 +ee011 +ee012 +ee01an +ee020 +ee021 +ee022 +ee02an +ee03 +ee03an +ee100 +ee101 +ee102 +ee10an +ee110 +ee1111 +ee112 +ee11an +ee120 +ee121 +ee122 +ee123 +ee13 +ee13an +ee200 +ee201 +ee202 +ee20an +ee210 +ee211 +ee212 +ee21an +ee220 +ee221 +ee222 +ee223 +ee22an +ee233 +ee23an +ee30 +ee30an +ee31 +ee31an +ee32 +ee323 +ee32an +ee33 +ee333 +ee33an +ee33vd +ee3bir +ee4anv +ee4anvold +ee7.2aold +eean +eeanv +eedimeq +eeeanv +eel0000 +eel00000 +eel00001 +eel000ct +eel00ct +eel021old +eel0321old +eel0ct +eel0t1 +eel0tt +eel11111 +eel12131 +eel2122old +eel2131 +eel3132 +eelt +eelt0 +eelt00 +eelt01 +eelt1 +eelt11 +eelt12 +eeltt +eeltt1 +eelttt +eengbas +eenglngeehlnm +eenglngeehlnmlem1 +eenglngeehlnmlem2 +eengstr +eengtrkg +eengtrkge +eengv +eeor +eexinst01 +eexinst11 +ef0 +ef01bndlem +ef0lem +ef11d +ef2kpi +ef2pi +ef4p +efabl +efadd +efaddlem +efald +efald2 +efcan +efchpcl +efchtcl +efchtdvds +efcj +efcl +efcld +efcllem +efcn +efcvg +efcvgfsum +efcvx +efeq1 +efeul +efexp +efexple +eff +eff1o +eff1o2 +eff1olem +eff2 +effectively_countable_clopen_chain_inters +effectively_countable_clopen_chain_unions +effectively_countable_clopen_in_chain_inters +effectively_countable_clopen_in_chain_unions +effsumlt +efgcpbl +efgcpbl2 +efgcpbllema +efgcpbllemb +efger +efgh +efgi +efgi0 +efgi1 +efgi2 +efginvrel1 +efginvrel2 +efglem +efgmf +efgmnvl +efgmval +efgrcl +efgred +efgred2 +efgredeu +efgredlem +efgredlema +efgredlemb +efgredlemc +efgredlemd +efgredleme +efgredlemf +efgredlemg +efgrelex +efgrelexlema +efgrelexlemb +efgs1 +efgs1b +efgsdm +efgsdmi +efgsf +efgsfo +efgsp1 +efgsrel +efgsres +efgsval +efgsval2 +efgt0 +efgt1 +efgt1p +efgt1p2 +efgtf +efgtlen +efgtval +efgval +efgval2 +efhalfpi +efi4p +efiarg +efiargd +efiasin +efiatan +efiatan2 +efieq +efieq1re +efif1o +efif1olem1 +efif1olem2 +efif1olem3 +efif1olem4 +efifo +efimpi +efipi +efival +efle +eflegeo +eflgam +eflog +eflogeq +eflt +efmival +efmnd +efmnd0nmnd +efmnd1bas +efmnd1hash +efmnd2hash +efmndbas +efmndbas0 +efmndbasabf +efmndbasf +efmndbasfi +efmndcl +efmndfv +efmndhash +efmndid +efmndmgm +efmndmnd +efmndov +efmndplusg +efmndsgrp +efmndtmd +efmndtopn +efmndtset +efmul2picn +efne0 +efne0d +efne0old +efneg +efnnfsumcl +efopn +efopnlem1 +efopnlem2 +efper +efrirr +efrlim +efrlimold +efrn2lp +efrunt +efsep +efsub +efsubd +efsubm +eft0val +eftabs +eftcl +eftlcl +eftlcvg +eftlub +eftval +efval +efval2 +efvmacl +efzval +ege2le3 +egorov +egrsubgr +egt2lt3 +ehl0 +ehl0base +ehl1eudis +ehl1eudisval +ehl2eudis +ehl2eudis0lt +ehl2eudisval +ehl2eudisval0 +ehlbase +ehleudis +ehleudisval +ehlval +eigenvalue_lowerbound_dot +eigenvalue_lowerbound_dot_eq +eigenvalues_characteristic +eigenvalues_characteristic_alt +eighmorth +eighmre +eigorth +eigorthi +eigposi +eigre +eigrei +eigvalcl +eigvalfval +eigvalval +eigvec1 +eigvecval +eirr +eirrlem +either +either_left_id +either_right_id +eitherassoc +eitherbimap +eithercommiso +eithermap +eithermapcompose +eitherswap +el +el021old +el0321old +el0ldep +el0ldepsnzr +el1 +el12 +el123 +el1fzopredsuc +el1o +el2122old +el2mpocl +el2mpocsbcl +el2v +el2v1 +el2xpss +el2xptp +el2xptp0 +el3v +el3v1 +el3v12 +el3v13 +el3v2 +el3v23 +el3v3 +el7g +el_all_distinct_el_eq +el_append3 +el_append_eqn +el_drop +el_length_dropwhile_reverse +el_length_snoc +el_lupdate +el_map +el_map2 +el_mem +el_reverse +el_simp +el_snoc +el_take +el_zip +ela +elaa +elaa2 +elaa2lem +elab +elab2 +elab2g +elab2gw +elab3 +elab3g +elab3gf +elab4g +elab6g +elabd +elabd2 +elabd3 +elabf +elabg +elabgf +elabgt +elabgtold +elabgtoldold +elabgw +elabrex +elabrexg +elabreximd +elabreximdv +elalt +elalt2 +elaltxp +elat2 +elatcv0 +elbasfv +elbasov +elbdop +elbdop2 +elbigo +elbigo2 +elbigo2r +elbigodm +elbigof +elbigofrcl +elbigoimp +elbigolo1 +elbl +elbl2 +elbl2ps +elbl3 +elbl3ps +elbl4 +elblps +elcarsg +elcarsgss +elcatchom +elch0 +elclnbgrelnbgr +elcls +elcls2 +elcls3 +elcncf +elcncf1di +elcncf1ii +elcncf2 +elcnfn +elcnop +elcntr +elcntz +elcntzsn +elcnv +elcnv2 +elcnvcnvintab +elcnvcnvlem +elcnvintab +elcnvlem +elcnvrefrels2 +elcnvrefrels3 +elcnvrefrelsrel +elcoeleqvrels +elcoeleqvrelsrel +elcpn +eldif +eldifad +eldifbd +eldifd +eldifeldifsn +eldifi +eldifn +eldifpr +eldifpw +eldifsn +eldifsnd +eldifsni +eldifsnneq +eldifsucnn +eldiftp +eldifvsn +eldioph +eldioph2 +eldioph2b +eldioph2lem1 +eldioph2lem2 +eldioph3 +eldioph3b +eldioph4b +eldioph4i +eldiophb +eldiophelnn0 +eldiophss +eldisjdmqsim +eldisjdmqsim2 +eldisjeq +eldisjeqd +eldisjeqi +eldisjim +eldisjim2 +eldisjim3 +eldisjlem19 +eldisjn0el +eldisjn0elb +eldisjs +eldisjs2 +eldisjs3 +eldisjs4 +eldisjs5 +eldisjs6 +eldisjs7 +eldisjsdisj +eldisjsim1 +eldisjsim2 +eldisjsim3 +eldisjsim4 +eldisjsim5 +eldisjss +eldisjssd +eldisjssi +eldju1st +eldju2ndl +eldju2ndr +eldm +eldm1cossres +eldm1cossres2 +eldm2 +eldm2g +eldm3 +eldm4 +eldmcnv +eldmcoa +eldmcoss +eldmcoss2 +eldmeldmressn +eldmg +eldmgm +eldmne0 +eldmqs1cossres +eldmqsres +eldmqsres2 +eldmres +eldmres2 +eldmres3 +eldmressn +eldmressnaltv +eldmressnsn +eldmrexrn +eldmrexrnb +eldmxrncnvepres +eldmxrncnvepres2 +eldprd +eldprdi +eldv +elec +elec1cnvres +elec1cnvxrn2 +elecaltv +eleccnvep +eleccossin +elecex +elecg +eleclclwwlkn +eleclclwwlknlem1 +eleclclwwlknlem2 +elecres +elecreseq +elecxrn +elee +eleei +eleenn +eleesub +eleesubd +elefmndbas +elefmndbas2 +eleigvec +eleigvec2 +eleigveccl +elelb +eleldisjs +eleldisjseldisj +elelpwi +elelsuc +elementary_bounded +elementary_compact +elementary_empty +elementary_inter +elementary_inters +elementary_interval +elementary_subset_interval +elementary_union +elementary_union_interval +elementary_union_interval_strong +elementary_unions_intervals +eleq1 +eleq12 +eleq12d +eleq12i +eleq1a +eleq1ab +eleq1d +eleq1i +eleq1w +eleq2 +eleq2d +eleq2dalt +eleq2i +eleq2s +eleq2w +eleq2w2 +eleq2w2alt +eleqtrd +eleqtrdi +eleqtri +eleqtrid +eleqtrrd +eleqtrrdi +eleqtrri +eleqtrrid +elequ1 +elequ12 +elequ2 +elequ2g +eleqvrels2 +eleqvrels3 +eleqvrelsrel +elestrchom +elex +elex2 +elex22 +elex22vd +elex2vd +elexd +elexi +elexold +elfg +elfi +elfi2 +elfilspd +elfilss +elfir +elfiun +elfix +elfix2 +elflim +elflim2 +elfm +elfm2 +elfm3 +elfpw +elfrlmbasn0 +elfuns +elfunsaltv +elfunsaltv2 +elfunsaltv3 +elfunsaltv4 +elfunsaltv5 +elfunsaltvfunaltv +elfunsg +elfv +elfv2ex +elfvdm +elfvex +elfvexd +elfvmptrab +elfvmptrab1 +elfvmptrab1w +elfvne0 +elfvov1 +elfvov2 +elfvunirn +elfz +elfz0add +elfz0fzfz0 +elfz0lmr +elfz0ubfz0 +elfz1 +elfz1b +elfz1end +elfz1eq +elfz1uz +elfz2 +elfz2nn0 +elfz2z +elfz3 +elfz3nn0 +elfz4 +elfz5 +elfzd +elfzel1 +elfzel2 +elfzelfzccat +elfzelfzlble +elfzelz +elfzelzd +elfzfzo +elfzlble +elfzle1 +elfzle2 +elfzle3 +elfzlmr +elfzm11 +elfzm12 +elfzm1b +elfzmlbm +elfzmlbp +elfznelfzo +elfznelfzob +elfznn +elfznn0 +elfzo +elfzo0 +elfzo0l +elfzo0le +elfzo0subge1 +elfzo0suble +elfzo0z +elfzo1 +elfzo1elm1fzo0 +elfzo2 +elfzo3 +elfzod +elfzodif0 +elfzodifsumelfzo +elfzoel1 +elfzoel2 +elfzoelz +elfzoext +elfzoextl +elfzofz +elfzolborelfzop1 +elfzole1 +elfzolem1 +elfzolt2 +elfzolt2b +elfzolt3 +elfzolt3b +elfzom1b +elfzom1elfzo +elfzom1elp1fzo +elfzom1elp1fzo1 +elfzom1p1elfzo +elfzomelpfzo +elfzomin +elfzonelfzo +elfzonlteqm1 +elfzonn0 +elfzop1le2 +elfzouz +elfzouz2 +elfzp1 +elfzp12 +elfzp1b +elfzr +elfzubelfz +elfzuz +elfzuz2 +elfzuz3 +elfzuzb +elgch +elghomlem1old +elghomlem2old +elghomold +elgrplsmsn +elgrug +elgz +elharval +elhf +elhf2 +elhf2g +elhmop +elhoi +elhoma +elhomai +elhomai2 +elicc01 +elicc1 +elicc2 +elicc2i +elicc3 +elicc4 +elicc4abs +eliccd +eliccelico +eliccelicod +eliccelioc +eliccioo +eliccnelico +eliccre +eliccxr +eliccxrd +elico1 +elico2 +elicod +elicoelioo +elicopnf +elicore +elicores +elid +elidinxp +elidinxpid +elif +elii1 +elii2 +eliin +eliin2 +eliin2f +eliincex +eliind +eliind2 +eliinid +elim +elim h +elim h1 +elim h2 +elim ih +elim2if +elim2ifim +elima +elima2 +elima3 +elima4 +elimag +elimaint +elimampo +elimampt +eliman0 +elimasn +elimasn1 +elimasng +elimasng1 +elimasni +elimdelov +elimdhyp +elimel +elimempty +elimf +elimge0 +elimgt0 +elimh +elimhyp +elimhyp2v +elimhyp3v +elimhyp4v +elimhyps +elimhyps2 +elimif +elimifd +eliminable-abelab +eliminable-abelv +eliminable-abeqab +eliminable-abeqv +eliminable-velab +eliminable-veqab +eliminable1 +eliminable2a +eliminable2b +eliminable2c +eliminable3a +eliminable3b +elimne0 +elimnv +elimnvu +elimph +elimphu +elin +elin1d +elin2 +elin2d +elin3 +elina +elincfzoext +elind +elinel1 +elinel2 +elini +elinintab +elinintrab +eliniseg +eliniseg2 +elinisegg +elinlem +elinsn +elint +elint2 +elintab +elintabg +elintd +elintdv +elintfv +elintg +elinti +elintima +elintrab +elintrabg +elinxp +elioc1 +elioc2 +eliocd +eliocre +elioo1 +elioo2 +elioo3g +elioo4g +elioo5 +eliood +elioomnf +eliooord +elioopnf +elioore +elioored +eliooshift +eliooxr +elirng +elirr +elirrv +elirrvalt +elirrvold +elisset +elissetv +eliun +eliund +eliuni +eliunid +eliuniin +eliuniin2 +eliuniincex +eliunov2 +eliunov2uz +eliunxp +eliunxp2 +elixp +elixp2 +elixpconst +elixpconstg +elixpsn +elixx1 +elixx3g +elkgen +ellcoellss +ellcsrspsn +elleft +ellimc +ellimc2 +ellimc3 +ellimcabssub0 +ellimciota +ellimits +ellines +ellkr +ellkr2 +ellnfn +ellnop +ello1 +ello12 +ello12r +ello1d +ello1mpt +ello1mpt2 +ellogdm +ellogrn +ellpi +ellspd +ellspds +ellspsn +ellspsn3 +ellspsn4 +ellspsn5 +ellspsn5b +ellspsn6 +ellspsni +ellz1 +elmade +elmade2 +elmap +elmapd +elmapdd +elmapex +elmapfn +elmapfun +elmapg +elmapi +elmapintab +elmapintrab +elmaprd +elmapresaun +elmapresaunres2 +elmapsnd +elmapssres +elmapssresd +elmbfmvol2 +elmgpcntrd +elmnc +elmod2 +elmopn +elmopn2 +elmpocl +elmpocl1 +elmpocl2 +elmpps +elmpst +elmptima +elmptrab +elmptrab2 +elmrsubrn +elmsta +elmsubrn +elmthm +elmzpcl +eln0s +eln0s2 +eln0zs +elnanel +elnanelprv +elndif +elneeldif +elnei +elnel +elneldisj +elnelne1 +elnelne2 +elnelneq2d +elnelneqd +elnelun +elneq +elnev +elni +elni2 +elnlfn +elnlfn2 +elnmz +elnn +elnn0 +elnn0nn +elnn0rabdioph +elnn0uz +elnn0z +elnn1uz2 +elnnne0 +elnnnn0 +elnnnn0b +elnnnn0c +elnnrabdioph +elnns +elnns2 +elnnuz +elnnz +elnnz1 +elnnzs +elno +elno2 +elno3 +elnonrel +elnoold +elnotel +elnp +elnpi +elntg +elntg2 +elo1 +elo12 +elo12r +elo1d +elo1mpt +elo1mpt2 +elocv +elogb +elold +elom +elom3 +elon +elon2 +elong +eloni +elons +elons2 +elons2d +elop +elopab +elopaba +elopabi +elopabr +elopabran +elopabw +elopaelxp +elopg +eloppf +eloppf2 +eloprab1st2nd +eloprabg +eloprabga +eloprabi +elorrvc +elorvc +elovimad +elovmpo +elovmpod +elovmporab +elovmporab1 +elovmporab1w +elovmpowrd +elovmpt3imp +elovmpt3rab +elovmpt3rab1 +elovmptnn0wrd +elovolm +elovolmlem +elovolmr +elpadd +elpadd0 +elpadd2at +elpadd2at2 +elpaddat +elpaddatin +elpaddatrin +elpaddn0 +elpaddri +elpclin +elpcln +elpell1234qr +elpell14qr +elpell14qr2 +elpell1qr +elpell1qr2 +elpg +elpglem1 +elpglem2 +elpglem3 +elpi1 +elpi1i +elpjch +elpjhmop +elpjidm +elpjrn +elply +elply2 +elplyd +elplyr +elpm +elpm2 +elpm2g +elpm2r +elpmap +elpmapat +elpmg +elpmi +elpmi2 +elpmrn +elpotr +elpq +elpqb +elpqn +elpr +elpr2 +elpr2elpr +elpr2g +elprchashprn2 +elpred +elpredg +elpredgg +elpredim +elpredimg +elpreima +elpreimad +elpreq +elpreqpr +elpreqprb +elpreqprlem +elprg +elpri +elprn1 +elprn2 +elprneb +elprnq +elprob +elpt +elptr +elptr2 +elpw +elpw2 +elpw2g +elpwb +elpwbi +elpwd +elpwdifcl +elpwdifsn +elpwg +elpwgded +elpwgdedvd +elpwi +elpwi2 +elpwid +elpwincl1 +elpwinss +elpwiuncl +elpwpw +elpwpwel +elpwun +elpwuni +elpwunicl +elpwunsn +elq +elq2 +elqaa +elqaalem1 +elqaalem2 +elqaalem3 +elqs +elqsecl +elqsg +elqsi +elqsn0 +elqtop +elqtop2 +elqtop3 +elrab +elrab2 +elrab2w +elrab3 +elrab3t +elrabd +elrabf +elrabi +elrabrd +elrabsf +elre0re +elreal +elreal2 +elrefrels2 +elrefrels3 +elrefrelsrel +elrefsymrels2 +elrefsymrels3 +elrefsymrelsrel +elrege0 +elrel +elreldm +elrelimasn +elrels2 +elrels5 +elrels6 +elrelscnveq +elrelscnveq2 +elrelscnveq3 +elrelscnveq4 +elrelsrel +elrelsrelim +elreno +elreno2 +elres +elrest +elrestd +elrestr +elrfi +elrfirn +elrfirn2 +elrgspn +elrgspnlem1 +elrgspnlem2 +elrgspnlem3 +elrgspnlem4 +elrgspnsubrun +elrgspnsubrunlem1 +elrgspnsubrunlem2 +elrhmunit +elrid +elright +elriin +elringchom +elringchomaltv +elringlsm +elringlsmd +elrint +elrint2 +elrlocbasi +elrn +elrn2 +elrn2g +elrn3 +elrncard +elrng +elrngchom +elrngchomaltv +elrnmpo +elrnmpog +elrnmpoid +elrnmpores +elrnmpt +elrnmpt1 +elrnmpt1d +elrnmpt1s +elrnmpt1sf +elrnmpt2d +elrnmptd +elrnmptdv +elrnmptf +elrnmptg +elrnmpti +elrnres +elrnressn +elrnrexdm +elrnrexdmb +elrnsiga +elrp +elrpd +elrpii +elrrx2linest2 +elrsp +elrspsn +elrspunidl +elrspunsn +elrtrclrec +elsb1 +elsb2 +elscottab +else +elsetchom +elsetpreimafv +elsetpreimafvb +elsetpreimafvbi +elsetpreimafveq +elsetpreimafveqfv +elsetpreimafvrab +elsetpreimafvssdm +elsetrecs +elsetrecslem +elsigagen +elsigagen2 +elsigass +elsingles +elsn +elsn2 +elsn2g +elsnd +elsng +elsni +elsnres +elsnxp +elspancl +elspani +elspansn +elspansn2 +elspansn3 +elspansn4 +elspansn5 +elspansncl +elspansni +elsprel +elss2prb +elssabg +elssuni +elsuc +elsuc2 +elsuc2g +elsucg +elsuci +elsuppfn +elsuppfnd +elsuppfng +elsx +elsymdif +elsymdifxor +elsymgbas +elsymgbas2 +elsymrels2 +elsymrels3 +elsymrels4 +elsymrels5 +elsymrelsrel +elt_in_delete +eltail +eltayl +eltg +eltg2 +eltg2b +eltg3 +eltg3i +eltg4i +eltop +eltop2 +eltop3 +eltopss +eltp +eltpg +eltpi +eltpsg +eltpsi +eltrans +eltrclrec +eltrrels2 +eltrrels3 +eltrrelsrel +eltsk2g +eltskg +eltskm +eltsms +eltx +elun +elun1 +elun2 +elunant +eluni +eluni2 +eluni2f +eluniab +elunif +elunii +eluniima +elunirab +elunirn +elunirnalt +elunirnmbfm +elunitcn +elunitge0 +elunitrn +elunnel1 +elunnel2 +elunop +elunop2 +elunsn +elutop +eluz +eluz1 +eluz1i +eluz2 +eluz2b1 +eluz2b2 +eluz2b3 +eluz2cnn0n1 +eluz2gt1 +eluz2n0 +eluz2nn +eluz3nn +eluz4nn +eluz5nn +eluzadd +eluzaddi +eluzd +eluzel2 +eluzelcn +eluzelre +eluzelz +eluzelz2 +eluzelz2d +eluzelzd +eluzfz +eluzfz1 +eluzfz2 +eluzfz2b +eluzge0nn0 +eluzge2nn0 +eluzgtdifelfzo +eluzle +eluzmn +eluznn +eluznn0 +eluzp1 +eluzp1l +eluzp1m1 +eluzp1p1 +eluzrabdioph +eluzsub +eluzsubi +eluzuzle +elv +elvd +elvv +elvvuni +elvvv +elwf +elwina +elwlim +elwspths2on +elwspths2onw +elwspths2spth +elwwlks2 +elwwlks2on +elwwlks2ons3 +elwwlks2ons3im +elwwlks2s3 +elxnn0 +elxp +elxp2 +elxp3 +elxp4 +elxp5 +elxp6 +elxp7 +elxp8 +elxpcbasex1 +elxpcbasex1alt +elxpcbasex2 +elxpcbasex2alt +elxpi +elxr +elxrge0 +elxrge02 +elz +elz12s +elz12si +elz2 +elzdif0 +elzn0s +elznn +elznn0 +elznn0nn +elznns +elzrhunit +elzs +elzs2 +embantd +embedsetcestrc +embedsetcestrclem +emcl +emcllem1 +emcllem2 +emcllem3 +emcllem4 +emcllem5 +emcllem6 +emcllem7 +emee +emgt0 +emoo +empty +empty-surprise +empty-surprise2 +empty_as_interval +empty_delete +empty_diff +empty_division_of +empty_exposed_face_of +empty_face_of +empty_funset +empty_gspec +empty_in_powerset +empty_interior_aff_dim +empty_interior_affine_hull +empty_interior_convex_hull +empty_interior_finite +empty_interior_lowdim +empty_interior_of_aff_dim +empty_interior_subset_hyperplane +empty_not_in_partition +empty_not_univ +empty_sl_is_empty +empty_subset +empty_union +empty_unions +emptyal +emptyex +emptynf +emre +en0 +en0alt +en0r +en1 +en1b +en1eqsn +en1eqsnbi +en1top +en1uniel +en2 +en2d +en2eleq +en2eqpr +en2i +en2lp +en2other2 +en2pr +en2prd +en2sn +en2top +en3 +en3d +en3i +en3lp +en3lplem1 +en3lplem1vd +en3lplem2 +en3lplem2vd +en3lpvd +en4 +encode +encoded +encrypt_decrypt +encv +endisj +endjudisj +endmndlem +endofsegid +endofsegidand +endom +endomtr +ends_in_interval +ends_in_segment +ends_in_unit_interval +ends_not_in_segment +ene0 +ene1 +enege +enen1 +enen2 +ener +enfi +enfialt +enfii +enfin1ai +enfin2i +enfixsn +engch +enmappw +enmappwid +ennum +enp1i +enp1ilem +enpr1g +enpr2 +enpr2d +enqbreq +enqbreq2 +enqeq +enqer +enqex +enrbreq +enreceq +enref +enreffi +enrefg +enrefnn +enrelmap +enrelmapr +enrer +enrex +ensdomtr +ensn1 +ensn1g +enssdom +enssdomold +ensucne0 +ensucne0old +ensures +ensym +ensymb +ensymd +ensymfib +ensymi +entr +entr2i +entr3i +entr4i +entrfi +entrfil +entrfir +entri +entri2 +entri3 +entric +entropy_nonneg +entropy_uniform_max +entropydef +enum_spec +enumerate +env_lookup +env_lookup_other +epee +epel +epelg +epeli +epelon2 +epfrc +epfrs +ephapax +epihom +epii +epin +epini +epinid0 +epirron +episect +epn0 +epne3 +epnsym +epnsymrel +epoo +epos +epr +epse +epsilondelta +epsoon +epttop +epweon +epweonalt +eq +eq0 +eq0alt +eq0f +eq0rabdioph +eq0rdv +eq0rdvalt +eq2tri +eq_add_lcancel +eq_add_rcancel +eq_balls +eq_c_bijections +eq_enum_spec +eq_ext +eq_imp +eq_imp_le +eq_imp_rule +eq_interval +eq_interval_1 +eq_ints +eq_less_eq +eq_list +eq_mono_add_eq +eq_part_lem_a +eq_part_lem_b +eq_rat +eq_ratl +eq_ratr +eq_refl_trans +eq_span_insert_eq +eq_subset_subset +eq_sums_lcancel +eq_sums_rcancel +eq_sym_eq +eq_tac +eq_trans +eq_univ +eqab +eqab2 +eqabb +eqabbw +eqabcb +eqabcbw +eqabcdv +eqabcri +eqabdv +eqabf +eqabi +eqabrd +eqabri +eqbrb +eqbrrdiv +eqbrrdv +eqbrrdv2 +eqbrrdva +eqbrriv +eqbrtr +eqbrtrd +eqbrtrdi +eqbrtri +eqbrtrid +eqbrtrrd +eqbrtrrdi +eqbrtrri +eqbrtrrid +eqcoe1ply1eq +eqcom +eqcomd +eqcomi +eqcoms +eqcuts +eqcuts2 +eqcuts3 +eqdif +eqeefv +eqeelen +eqelb +eqelbid +eqelssd +eqelsuc +eqeltr +eqeltrd +eqeltrdi +eqeltri +eqeltrid +eqeltrrd +eqeltrrdi +eqeltrri +eqeltrrid +eqeng +eqeq1 +eqeq12 +eqeq12d +eqeq12i +eqeq1d +eqeq1dalt +eqeq1i +eqeq2 +eqeq2d +eqeq2i +eqeqan12d +eqeqan12dalt +eqeqan12rd +eqeqan2d +eqer +eqerlem +eqeu +eqeuel +eqfnfv +eqfnfv2 +eqfnfv2d2 +eqfnfv2f +eqfnfv3 +eqfnfvd +eqfnov +eqfnov2 +eqfnovd +eqfnun +eqfunfv +eqfunresadj +eqfunressuc +eqfvelsetpreimafv +eqg0el +eqg0subg +eqg0subgecsn +eqgabl +eqgcpbl +eqgen +eqger +eqgfval +eqgid +eqglact +eqgval +eqgvscpbl +eqid +eqid1 +eqidd +eqif +eqimss +eqimss2 +eqimss2i +eqimsscd +eqimssd +eqimssi +eqinf +eqinfd +eqle +eqled +eqlei +eqlei2 +eqlelt +eqleltd +eqlkr +eqlkr2 +eqlkr3 +eqlkr4 +eqmat +eqn +eqnbrtrd +eqneg +eqnegad +eqnegd +eqnegi +eqneltrd +eqneltri +eqneltrrd +eqneqall +eqnetrd +eqnetri +eqnetrrd +eqnetrri +eqnetrrid +eqop +eqop2 +eqopab2b +eqopab2bw +eqopi +eqoprab2b +eqoprab2bw +eqord1 +eqord2 +eqoreldif +eqrabdioph +eqrabi +eqrd +eqrdav +eqrdv +eqrel +eqrel2 +eqrelf +eqrelrd2 +eqrelrdv +eqrelrdv2 +eqrelrel +eqrelriiv +eqrelriv +eqres +eqresfnbd +eqresr +eqreu +eqreznegel +eqri +eqriv +eqrrabd +eqs1 +eqsb1 +eqsbc1 +eqsbc2 +eqsbc2vd +eqsn +eqsnd +eqsndold +eqsnuniex +eqsqrt2d +eqsqrtd +eqsqrtor +eqss +eqssd +eqssi +eqsstrd +eqsstrdi +eqsstri +eqsstrid +eqsstrrd +eqsstrrdi +eqsstrri +eqsstrrid +eqsup +eqsupd +eqsym +eqt_elim +eqt_intro +eqtr +eqtr2 +eqtr2d +eqtr2di +eqtr2i +eqtr2id +eqtr3 +eqtr3d +eqtr3di +eqtr3i +eqtr3id +eqtr4d +eqtr4di +eqtr4i +eqtr4id +eqtrans +eqtrb +eqtrd +eqtrdi +eqtri +eqtrid +equal-by-nths +equal-integer-length-0 +equal-logcons +equal-of-append-and-append-same-arg2 +equal-of-rev-and-rev +equal-when-append-same +equal_sl_card +equalities +equality +equality_symmetry +equality_trans +equcom +equcomd +equcomi +equcomi1 +equcomiv +equcoms +equequ1 +equequ2 +equeucl +equeuclr +equid +equid1 +equid1alt +equidq +equidqe +equiintegrable_add +equiintegrable_closed_interval_restrictions +equiintegrable_cmul +equiintegrable_division +equiintegrable_eq +equiintegrable_halfspace_restrictions_ge +equiintegrable_halfspace_restrictions_gt +equiintegrable_halfspace_restrictions_le +equiintegrable_halfspace_restrictions_lt +equiintegrable_limit +equiintegrable_neg +equiintegrable_on_null +equiintegrable_on_sing +equiintegrable_on_split +equiintegrable_open_interval_restrictions +equiintegrable_reflect +equiintegrable_sub +equiintegrable_subset +equiintegrable_sum +equiintegrable_uniform_limit +equiintegrable_union +equipment_maintenance +equiv_class_eq +equiv_on_subset +equiv_sym +equivalence_same_part +equivbnd +equivbnd2 +equivcau +equivcfil +equivcmet +equivestrcsetc +equivtotbnd +equncom +equncomi +equncomivd +equncomvd +equs4 +equs45f +equs4v +equs5 +equs5a +equs5aalt +equs5av +equs5e +equs5ealt +equsal +equsalh +equsalhw +equsalv +equsalvw +equsb1 +equsb1v +equsb2 +equsb3 +equsb3r +equsex +equsexalt +equsexh +equsexhv +equsexv +equsexvw +equsv +equtr +equtr2 +equtrr +equvel +equvelv +equvini +equvinv +equvinva +eqv +eqvf +eqvinc +eqvincf +eqvincg +eqvinop +eqvisset +eqvrel0 +eqvrel1cossidres +eqvrel1cossinidres +eqvrel1cossxrnidres +eqvrelcl +eqvrelcoss +eqvrelcoss0 +eqvrelcoss2 +eqvrelcoss3 +eqvrelcoss4 +eqvrelcossid +eqvreldisj +eqvreldisj1 +eqvreldisj2 +eqvreldisj3 +eqvreldisj4 +eqvreldisj5 +eqvreldmqs +eqvreldmqs2 +eqvreleq +eqvreleqd +eqvreleqi +eqvrelid +eqvrelim +eqvrelqsel +eqvrelqseqdisj2 +eqvrelqseqdisj3 +eqvrelqseqdisj4 +eqvrelqseqdisj5 +eqvrelref +eqvrelrefrel +eqvrelrel +eqvrelsym +eqvrelsymb +eqvrelsymrel +eqvrelth +eqvrelthi +eqvreltr +eqvreltr4d +eqvreltrd +eqvreltrrel +eqwrd +eqwrds3 +eraltveq1 +eraltveq1d +eraltveq1i +erbr3b +ercgrg +ercl +ercl2 +erclwwlk +erclwwlkeq +erclwwlkeqlen +erclwwlkn +erclwwlkneq +erclwwlkneqlen +erclwwlknref +erclwwlknrel +erclwwlknsym +erclwwlkntr +erclwwlkref +erclwwlkrel +erclwwlksym +erclwwlktr +ercnv +ercpbl +ercpbllem +erdisj +erdm +erdsze +erdsze2 +erdsze2lem1 +erdsze2lem2 +erdszelem1 +erdszelem10 +erdszelem11 +erdszelem2 +erdszelem3 +erdszelem4 +erdszelem5 +erdszelem6 +erdszelem7 +erdszelem8 +erdszelem9 +ere +ereldm +ereq1 +ereq2 +erex +erexb +erimeq +erimeq2 +eringring +erinxp +erlbr2d +erlbrd +erlcl1 +erlcl2 +erldi +erlecpbl +erler +erlval +erng0g +erng1lem +erng1r +erngbase +erngbase-rn +erngdv +erngdv-rn +erngdvlem1 +erngdvlem1-rn +erngdvlem2-rn +erngdvlem2n +erngdvlem3 +erngdvlem3-rn +erngdvlem4 +erngdvlem4-rn +erngfmul +erngfmul-rn +erngfplus +erngfplus-rn +erngfset +erngfset-rn +erngmul +erngmul-rn +erngplus +erngplus-rn +erngplus2 +erngplus2-rn +erngring-rn +erngset +erngset-rn +eroprf +eroprf2 +erov +erov2 +eroveu +erovlem +erprt +erref +errel +errn +erssxp +ersym +ersymb +erth +erth2 +erthi +ertr +ertr2d +ertr3d +ertr4d +ertrd +esplyfv +esplyfv1 +esplyfval +esplyfval0 +esplyfval2 +esplyfval3 +esplyfvn +esplyind +esplyindfv +esplylem +esplymhp +esplympl +esplysply +esplyval +estrcbas +estrcbasbas +estrccat +estrccatid +estrcco +estrccofval +estrchom +estrchomfeqhom +estrchomfn +estrchomfval +estrcid +estrcval +estrres +estrreslem1 +estrreslem2 +esum +esum0 +esum2d +esum2dlem +esumadd +esumaddf +esumc +esumcl +esumcocn +esumcst +esumcvg +esumcvg2 +esumcvgre +esumcvgsum +esumdivc +esumel +esumeq1 +esumeq12d +esumeq12dva +esumeq12dvaf +esumeq1d +esumeq2 +esumeq2d +esumeq2dv +esumeq2sdv +esumex +esumf1o +esumfsup +esumfsupre +esumfzf +esumgect +esumgsum +esumid +esumiun +esumle +esumlef +esumlub +esummono +esummulc1 +esummulc2 +esumnul +esumpad +esumpad2 +esumpcvgval +esumpfinval +esumpfinvalf +esumpfinvallem +esumpinfsum +esumpinfval +esumpmono +esumpr +esumpr2 +esumrnmpt +esumrnmpt2 +esumsn +esumsnf +esumsplit +esumss +esumsup +esumval +et-equeucl +et-ltneverrefl +et-sqrtnegnre +eta-red +eta_ax +eta_red +etaslts +etaslts2 +etransc +etransclem1 +etransclem10 +etransclem11 +etransclem12 +etransclem13 +etransclem14 +etransclem15 +etransclem16 +etransclem17 +etransclem18 +etransclem19 +etransclem2 +etransclem20 +etransclem21 +etransclem22 +etransclem23 +etransclem24 +etransclem25 +etransclem26 +etransclem27 +etransclem28 +etransclem29 +etransclem3 +etransclem30 +etransclem31 +etransclem32 +etransclem33 +etransclem34 +etransclem35 +etransclem36 +etransclem37 +etransclem38 +etransclem39 +etransclem4 +etransclem40 +etransclem41 +etransclem42 +etransclem43 +etransclem44 +etransclem45 +etransclem46 +etransclem47 +etransclem48 +etransclem5 +etransclem6 +etransclem7 +etransclem8 +etransclem9 +eu0 +eu1 +eu2 +eu2ndop1stv +eu3v +eu4 +eu6 +eu6im +eu6lem +eu6w +euabex +euabsn +euabsn2 +euabsn2w +euabsneu +euae +euan +euanv +eubi +eubid +eubidv +eubii +eubrdm +eubrv +eucalg +eucalgcvga +eucalgf +eucalginv +eucalglt +eucalgval +eucalgval2 +euclemma +euclid_lemma +euclid_spec +eucliddivs +euclidean_closure_of +euclidean_connected_components_of +euclidean_derived_set_of_iff_limit_point_of +euclidean_frame +euclidean_frontier_of +euclidean_interior_of +euclidean_matroid +euclidean_matroid_dim +euclidean_matroid_dimension +euclidean_matroid_finite_dim +euclidean_matroid_finite_dimensional +euclidean_matroid_independent +euclidean_matroid_spanning +euclidean_matroid_subspace +euclidean_metric +euclidean_space_infinite +euclidean_submatroid +eucrct2eupth +eucrct2eupth1 +eucrctshift +euelss +euen1 +euen1b +euendfunc +euendfunc2 +eueq +eueq2 +eueq3 +eueqi +euequ +euex +euf +eufid +eufndx +eufnfv +eufsn +eufsn2 +eufsnlem +eufunc +eufunclem +euhash1 +euim +euimmo +euind +eujust +eujustalt +euler_formula +euler_rotation_theorem +euler_rotoinversion_theorem +eulercrct +eulerid +eulerpart +eulerpartgbij +eulerpartlem1 +eulerpartlemb +eulerpartlemd +eulerpartleme +eulerpartlemelr +eulerpartlemf +eulerpartlemgc +eulerpartlemgf +eulerpartlemgh +eulerpartlemgs2 +eulerpartlemgu +eulerpartlemgv +eulerpartlemgvv +eulerpartlemmf +eulerpartlemn +eulerpartlemo +eulerpartlemr +eulerpartlems +eulerpartlemsf +eulerpartlemsv1 +eulerpartlemsv2 +eulerpartlemsv3 +eulerpartlemt +eulerpartlemt0 +eulerpartlemv +eulerpath +eulerpathpr +eulerth +eulerthlem1 +eulerthlem2 +eulplig +eumo +eumoi +eunex +euop2 +euor +euor2 +euoreqb +euorv +euotd +eupick +eupicka +eupickb +eupickbi +eupre +eupre2 +eupth0 +eupth2 +eupth2eucrct +eupth2lem1 +eupth2lem2 +eupth2lem3 +eupth2lem3lem1 +eupth2lem3lem2 +eupth2lem3lem3 +eupth2lem3lem4 +eupth2lem3lem5 +eupth2lem3lem6 +eupth2lem3lem7 +eupth2lemb +eupth2lems +eupthcl +eupthf1o +eupthfi +eupthi +eupthistrl +eupthiswlk +eupthp1 +eupthpf +eupthres +eupths +eupthseg +eupthvdres +eusn +eusnsn +eusv1 +eusv2 +eusv2i +eusv2nf +eusv4 +eusvnf +eusvnfb +eusvobj1 +eusvobj2 +euxfr +euxfr2 +euxfr2w +euxfrw +ev_charging +eval_int_add +eval_tac +evaluates +even +even1 +even2n +even3prm2 +even_0 +even_add +even_add_even +even_and_odd +even_div_2 +even_double +even_exists +even_exp +even_exp_iff +even_mod2 +even_mult +even_odd +even_odd_exists +even_odd_mutual +even_or_odd +even_plus_even +even_ss +even_sub +evend2 +evendiv2z +evenelz +evengpoap3 +evengpop3 +evenltle +evenm1odd +evennat +evennn02n +evennn2n +evennodd +evenp-+-2 +evenp1odd +evenprm2 +evensumeven +evensumodd +eventually_and +eventually_at +eventually_at_infinity +eventually_at_infinity_pos +eventually_at_infinity_within +eventually_at_neginfinity +eventually_at_posinfinity +eventually_at_reflect +eventually_at_topological +eventually_at_within +eventually_at_zero +eventually_atpointof +eventually_atpointof_metric +eventually_false +eventually_happens +eventually_happens_at +eventually_in_open +eventually_in_sequentially +eventually_mono +eventually_scalable_property +eventually_scalable_property_eq +eventually_sequentially +eventually_true +eventually_within +eventually_within_delete +eventually_within_imp +eventually_within_inter_imp +eventually_within_interior +eventually_within_interior_inter +eventually_within_interior_local +eventually_within_le +eventually_within_left_alt +eventually_within_left_alt_gen +eventually_within_open +eventually_within_open_in +eventually_within_reflect +eventually_within_right_alt +eventually_within_right_alt_gen +eventually_within_topological +eventually_within_zero +evenwodadd +evenz +every2_every +every2_length +every2_lupdate_same +every2_map +every2_mem_mono +every2_refl +every2_reverse +every2_sym +every2_trans +every_append +every_assum +every_case_tac +every_conj +every_el +every_filter +every_filter_imp +every_flat +every_genlist +every_map +every_mem +every_mem_mono +every_not_exists +every_simp +every_zip_fst +every_zip_snd +evl0 +evl1addd +evl1at0 +evl1at1 +evl1deg1 +evl1deg2 +evl1deg3 +evl1expd +evl1fpws +evl1fval +evl1fval1 +evl1fval1lem +evl1fvf +evl1gprodd +evl1gsumadd +evl1gsumaddval +evl1gsumd +evl1gsumdlem +evl1gsummon +evl1gsummul +evl1maprhm +evl1muld +evl1rhm +evl1sca +evl1scad +evl1scvarpw +evl1scvarpwval +evl1subd +evl1val +evl1var +evl1vard +evl1varpw +evl1varpwval +evl1vsd +evladdval +evlcl +evlextv +evlf1 +evlf2 +evlf2val +evlfcl +evlfcllem +evlfval +evlmulval +evlrhm +evls1addd +evls1dm +evls1expd +evls1fldgencl +evls1fn +evls1fpws +evls1fval +evls1fvcl +evls1fvf +evls1gsumadd +evls1gsummul +evls1maplmhm +evls1maprhm +evls1maprnss +evls1monply1 +evls1muld +evls1pw +evls1rhm +evls1rhmlem +evls1sca +evls1scafv +evls1scasrng +evls1subd +evls1val +evls1var +evls1varpw +evls1varpwval +evls1varsrng +evls1vsca +evlsaddval +evlsbagval +evlsca +evlscaval +evlscl +evlselv +evlselvlem +evlseu +evlsevl +evlsexpval +evlsgsumadd +evlsgsummul +evlslem1 +evlslem2 +evlslem3 +evlslem4 +evlslem6 +evlsmaprhm +evlsmhpvvval +evlsmulval +evlspw +evlsrhm +evlssca +evlsscasrng +evlsscaval +evlsval +evlsval2 +evlsval3 +evlsvar +evlsvarpw +evlsvarsrng +evlsvarval +evlsvval +evlsvvval +evlsvvvallem +evlsvvvallem2 +evlval +evlvar +evlvarval +evlvvval +evlvvvallem +evpmid +evpmodpmf1o +evpmss +evpmsubg +evpmval +evth +evth2 +evth2f +evthf +evthicc +evthicc2 +evthiccabs +ewlkinedg +ewlkle +ewlkprop +ewlksfval +ex +ex (s m) +ex 0 +ex m +ex nil +ex-1st +ex-2nd +ex-abs +ex-an +ex-bc +ex-br +ex-ceil +ex-chn1 +ex-chn2 +ex-cnv +ex-co +ex-decpmul +ex-dif +ex-dm +ex-dvds +ex-eprel +ex-exp +ex-fac +ex-fl +ex-fpar +ex-fv +ex-gcd +ex-gt +ex-gte +ex-hash +ex-id +ex-ima +ex-in +ex-ind-dvds +ex-lcm +ex-mod +ex-natded5.13 +ex-natded5.13-2 +ex-natded5.2 +ex-natded5.2-2 +ex-natded5.2i +ex-natded5.3 +ex-natded5.3-2 +ex-natded5.3i +ex-natded5.5 +ex-natded5.7 +ex-natded5.7-2 +ex-natded5.8 +ex-natded5.8-2 +ex-natded9.20 +ex-natded9.20-2 +ex-natded9.26 +ex-natded9.26-2 +ex-opab +ex-or +ex-ovoliunnfl +ex-po +ex-pr +ex-prmo +ex-pss +ex-pw +ex-res +ex-rn +ex-sategoel +ex-sategoelel +ex-sategoelel12 +ex-sategoelelomsuc +ex-sqrt +ex-ss +ex-un +ex-uni +ex-xp +ex3 +ex_falso +exa1 +exact +exact (f (a, b)) +exact (f a) +exact (g (f a)) +exact (g b) +exact (h a) +exact (nb (f a)) +exact a +exact b +exact f +exact ih +exactly +exam_scheduling +example +example_1 +example_10 +example_2 +example_3 +example_4 +example_5 +example_7 +example_8 +example_9 +exan +exan3 +exanali +exancom +exanres +exanres2 +exanres3 +exatlen +exbaspos +exbasprs +exbi +exbid +exbidh +exbidv +exbii +exbiii +exbir +exbiri +exbirivd +exbirvd +exc +exception +exchange +exchange_lemma +excluded +excluded_middle +excom +excom13 +excomim +excomimw +excomw +excxor +exdifsn +exdistr +exdistr2 +exdistrf +exdistrv +executes +exel +exellim +exellimddv +exeltr +exercise +exeupre +exeupre2 +exexneq +exexw +exfalso +exfinfldd +exfo +exgen +exidcl +exidres +exidresid +exidreslem +exidu1 +exim +eximal +eximd +eximdh +eximdv +eximi +eximii +eximp-surprise +eximp-surprise2 +exinst +exinst01 +exinst11 +exintr +exintrbi +existence_property +exists +exists-tp +exists1 +exists2 +exists_append +exists_component_superset +exists_countable_subset_image +exists_diff +exists_disj +exists_drop +exists_drop_fun +exists_drop_image +exists_first +exists_fun_drop +exists_fun_lift +exists_genlist +exists_greatest +exists_in_gspec +exists_in_image +exists_in_insert +exists_in_pcross +exists_in_union +exists_lift +exists_lift_fun +exists_lift_image +exists_list +exists_list_eq_map +exists_list_genlist +exists_map +exists_mem +exists_not_every +exists_not_forall_not +exists_num +exists_option +exists_or +exists_or_distrib +exists_or_thm +exists_pair_thm +exists_paired_thm +exists_pastecart +exists_prime +exists_refl +exists_snoc +exists_subset_image +exists_tac +exists_type +exists_unique +exists_unique_def +exists_unique_thm +exists_vector_1 +exists_vector_2 +exists_vector_3 +exists_vector_4 +existselim +existsnat +exisym1 +exlimd +exlimdd +exlimddv +exlimddvf +exlimddvfi +exlimdh +exlimdv +exlimdvv +exlimexi +exlimi +exlimih +exlimii +exlimiieq1 +exlimiieq2 +exlimiiv +exlimim +exlimimd +exlimimdd +exlimiv +exlimivv +exmid +exmid2 +exmidd +exmidne +exmo +exmoeu +exmoeub +exnal +exnalimn +exnel +exneq +exopxfr +exopxfr2 +exor +exp +exp0 +exp0d +exp1 +exp11d +exp11nnd +exp12bd +exp1d +exp31 +exp32 +exp41 +exp42 +exp43 +exp44 +exp45 +exp4a +exp4b +exp4c +exp4d +exp510 +exp511 +exp512 +exp516 +exp520 +exp53 +exp56 +exp58 +exp5c +exp5d +exp5g +exp5j +exp5k +exp5l +exp5o +exp_0 +exp_2 +exp_add +exp_always_big_enough +exp_base_injective +exp_base_le_iff +exp_base_le_mono +exp_base_leq_mono_imp +exp_base_lt_mono +exp_base_mult +exp_exp_injective +exp_exp_le_mono +exp_exp_lt_mono +exp_exp_mult +exp_mod +exp_mono_le +exp_mult +exp_nonzero +exp_one +exp_pos +exp_sub +expadd +expaddd +expadds +expaddz +expaddzlem +expand +expand_closed_open_interval +expand_tac +expandan +expandexn +expandral +expandrex +expandrexn +expanduniss +expcan +expcand +expcl +expcl2lem +expcld +expcllem +expclz +expclzd +expclzlem +expcn +expcncf +expcnfg +expcnold +expcnv +expcom +expcomd +expcomdg +expd +expdcom +expdimp +expdioph +expdiophlem1 +expdiophlem2 +expdiv +expdivd +expectation_linear +expected +expeq0 +expeq0d +expeq1d +expeqidd +expevenpos +expfac +expgcd +expge0 +expge0d +expge1 +expge1d +expghm +expgrowth +expgrowthi +expgt0 +expgt0b +expgt1 +expi +expimpd +expl +exple1 +exple2lt6 +explecnv +explicit_enumerate_mono +explicit_enumerate_not_empty +explicit_subset_interior_convex_hull +explicit_subset_interior_convex_hull_minimal +explicit_subset_relative_interior_convex_hull +explode_dest_string +explode_eq_thm +explode_onto +explog +explt1d +expm1 +expm1d +expm1t +expmhm +expmordi +expmul +expmuld +expmulnbnd +expmulz +expn1 +expnass +expnbnd +expne0 +expne0d +expne0i +expneg +expneg2 +expnegd +expnegico01 +expnegz +expnlbnd +expnlbnd2 +expnngt1 +expnngt1b +expnnsval +expnnval +expnprm +exposed_face_of +exposed_face_of_imp_face_of +exposed_face_of_inter +exposed_face_of_inter_supporting_hyperplane_ge +exposed_face_of_inter_supporting_hyperplane_le +exposed_face_of_inters +exposed_face_of_linear_image +exposed_face_of_parallel +exposed_face_of_polyhedron +exposed_face_of_refl +exposed_face_of_refl_eq +exposed_face_of_sums +exposed_face_of_translation_eq +exposed_facet_of +exposed_point_of_furthest_point +exposed_point_of_inter_supporting_hyperplane_ge +exposed_point_of_inter_supporting_hyperplane_le +expp1 +expp1d +expp1z +expp1zd +expr +exprec +exprecd +exprelprel +exprmfct +exps0 +exps1 +expscl +expscllem +expsgt0 +expsne0 +expsp1 +expsub +expsubd +expsval +expt +expt-+ +expubnd +expval +exrecfn +exrecfnlem +exrecfnpw +exrot3 +exrot4 +exsb +exsbim +exse +exse2 +exsimpl +exsimpr +exsnrex +exss +exsslsb +ext +extdg1b +extdg1id +extdgcl +extdgfialg +extdgfialglem1 +extdgfialglem2 +extdggt0 +extdgid +extdgmul +extdgval +extend_convex_frontier_segment +extend_convex_relative_frontier_segment +extend_to_affine_basis +extendedeuclid +extension +extension_from_clopen +extensional +extensional_empty +extensional_eq +extensional_univ +extep +extid +extmptsuppeq +extoimad +extreme_point_exists_convex +extreme_point_in_frontier +extreme_point_in_relative_frontier +extreme_point_not_in_interior +extreme_point_not_in_relative_interior +extreme_point_of_cball +extreme_point_of_conic +extreme_point_of_conic_hull +extreme_point_of_convex_hull +extreme_point_of_convex_hull_2 +extreme_point_of_convex_hull_affine_independent +extreme_point_of_convex_hull_convex_independent +extreme_point_of_convex_hull_eq +extreme_point_of_convex_hull_insert +extreme_point_of_convex_hull_insert_eq +extreme_point_of_empty +extreme_point_of_face +extreme_point_of_inter +extreme_point_of_inter_gen +extreme_point_of_inter_supporting_hyperplane_ge +extreme_point_of_inter_supporting_hyperplane_le +extreme_point_of_linear_image +extreme_point_of_midpoint +extreme_point_of_segment +extreme_point_of_sing +extreme_point_of_stillconvex +extreme_point_of_stillconvex_imp +extreme_point_of_translation_eq +extreme_point_relative_frontier +extreme_points_of_convex_hull +extreme_points_of_convex_hull_affine_independent +extreme_points_of_convex_hull_eq +extreme_points_of_linear_image +extreme_points_of_stillconvex +extreme_points_of_translation +extremevalue +extru +extssr +extvfv +extvfval +extvfvalf +extvfvcl +extvfvv +extvfvvcl +extvval +extwwlkfab +extwwlkfabel +f +f0 +f00 +f002 +f0bi +f0cli +f0dom0 +f0rn0 +f10 +f102g +f10d +f11o +f12dfv +f13dfv +f13idfv +f1cdmsn +f1cnv +f1cnvcnv +f1co +f1cocnv1 +f1cocnv2 +f1cof1 +f1cof1b +f1cof1blem +f1cofveqaeq +f1cofveqaeqalt +f1dm +f1dmex +f1dmvrnfibi +f1dom +f1dom2g +f1dom3el3dif +f1dom3fv3dif +f1dom3g +f1dom4g +f1domfi +f1domfi2 +f1domg +f1elima +f1eq1 +f1eq123d +f1eq2 +f1eq3 +f1eqcocnv +f1f +f1f1orn +f1fi +f1finf1o +f1fn +f1fun +f1fveq +f1ghm0to0 +f1imacnv +f1imadifssran +f1imaen +f1imaen2g +f1imaen3g +f1imaenfi +f1imaeng +f1imaeq +f1imapss +f1imass +f1iun +f1lindf +f1linds +f1mo +f1mpt +f1mptrn +f1o0 +f1o00 +f1o2d +f1o2d2 +f1o2ndf1 +f1o2sn +f1o3d +f1oabexg +f1oabexgold +f1ocan1fv +f1ocan2fv +f1ocnt +f1ocnv +f1ocnv2d +f1ocnvb +f1ocnvd +f1ocnvdm +f1ocnvfv +f1ocnvfv1 +f1ocnvfv2 +f1ocnvfv3 +f1ocnvfvb +f1ocnvfvrneq +f1oco +f1ococnv1 +f1ococnv2 +f1ocof1ob +f1ocof1ob2 +f1ocoima +f1ocpbl +f1ocpbllem +f1od +f1od2 +f1odm +f1oen +f1oen2g +f1oen3g +f1oen4g +f1oenfi +f1oenfirn +f1oeng +f1oeq1 +f1oeq123d +f1oeq1d +f1oeq2 +f1oeq23 +f1oeq2d +f1oeq3 +f1oeq3d +f1oeq3dd +f1oexbi +f1oexrnex +f1of +f1of1 +f1ofn +f1ofo +f1ofun +f1ofveu +f1ofvswap +f1oi +f1oiold +f1oiso +f1oiso2 +f1olecpbl +f1omo +f1omoalt +f1omoold +f1ompt +f1omptsn +f1omptsnlem +f1omvdcnv +f1omvdco2 +f1omvdco3 +f1omvdconj +f1omvdmvd +f1opr +f1oprg +f1oprswap +f1opw +f1opw2 +f1opwfi +f1orel +f1ores +f1orescnv +f1oresf1o +f1oresf1o2 +f1oresf1orab +f1oresrab +f1orn +f1osetex +f1osn +f1osng +f1ossf1o +f1otrg +f1otrgds +f1otrge +f1otrgitv +f1otrspeq +f1oun +f1oun2prg +f1ounsn +f1ovi +f1ovscpbl +f1ovv +f1owe +f1owealt +f1prex +f1rel +f1resf1 +f1resfz0f1d +f1resrcmplf1d +f1resrcmplf1dlem +f1resveqaeq +f1rnen +f1setex +f1sn2g +f1sng +f1ss +f1ssf1 +f1ssr +f1ssres +f1stres +f1un +f1veqaeq +f1vrnfibi +f2ndf +f2ndres +f_range +fabex +fabexd +fabexg +fabexgold +fac0 +fac1 +fac2 +fac3 +fac4 +facavg +faccl +faccld +facdiv +face_of_aff_dim_0 +face_of_aff_dim_lt +face_of_affine_eq +face_of_affine_trivial +face_of_conic +face_of_conic_hull +face_of_conic_hull_eq +face_of_conic_hull_rev +face_of_convex_hull_affine_independent +face_of_convex_hull_insert +face_of_convex_hull_insert_eq +face_of_convex_hull_subset +face_of_convex_hulls +face_of_disjoint_interior +face_of_disjoint_relative_interior +face_of_empty +face_of_eq +face_of_face +face_of_halfspace_ge +face_of_halfspace_le +face_of_imp_closed +face_of_imp_compact +face_of_imp_convex +face_of_imp_subset +face_of_inter +face_of_inter_as_inter_of_face +face_of_inter_inter +face_of_inter_subface +face_of_inter_supporting_hyperplane_ge +face_of_inter_supporting_hyperplane_ge_strong +face_of_inter_supporting_hyperplane_le +face_of_inter_supporting_hyperplane_le_strong +face_of_inters +face_of_linear_image +face_of_pcross +face_of_pcross_decomp +face_of_pcross_eq +face_of_polyhedron +face_of_polyhedron_explicit +face_of_polyhedron_face_of_facet +face_of_polyhedron_polyhedron +face_of_polyhedron_subset_explicit +face_of_polyhedron_subset_facet +face_of_polytope_insert_eq +face_of_polytope_polytope +face_of_refl +face_of_refl_eq +face_of_simplex_subset +face_of_sing +face_of_slice +face_of_stillconvex +face_of_subset +face_of_subset_frontier_aff_dim +face_of_subset_relative_boundary +face_of_subset_relative_frontier +face_of_subset_relative_frontier_aff_dim +face_of_trans +face_of_translation_eq +faces_of_linear_image +faces_of_simplex +faces_of_translation +facet_of_convex_hull_affine_independent +facet_of_convex_hull_affine_independent_alt +facet_of_empty +facet_of_halfspace_ge +facet_of_halfspace_le +facet_of_imp_face_of +facet_of_imp_proper +facet_of_imp_subset +facet_of_linear_image +facet_of_polyhedron +facet_of_polyhedron_explicit +facet_of_refl +facet_of_translation_eq +facets_of_polyhedron_explicit_distinct +facgam +facility_location +faclbnd +faclbnd2 +faclbnd3 +faclbnd4 +faclbnd4lem1 +faclbnd4lem2 +faclbnd4lem3 +faclbnd4lem4 +faclbnd5 +faclbnd6 +faclim +faclim2 +faclimlem1 +faclimlem2 +faclimlem3 +facmapnn +facndiv +facne0 +facnn +facnn2 +facp1 +facp2 +fact +fact-positive +fact-tail-correct +fact_ge_1 +fact_iff +fact_less +fact_lt +fact_mono +fact_positive +facth +facth1 +factor_continuous_through_variation +factor_through_variation +factorial +factorial_correct +factorial_ge_power_of_2 +factorial_positive +factorial_spec +factorialpositive +facubnd +facwordi +faeval +fafv2elcdm +fafv2elrnb +fafvelcdm +fal +falanfal +falantru +falbifal +falbitru +fald +falim +falimd +falimfal +falimtru +fallfac0 +fallfac1 +fallfaccl +fallfaccllem +fallfacfac +fallfacfwd +fallfacp1 +fallfacp1d +fallfacval +fallfacval2 +fallfacval3 +fallfacval4 +fallrisefac +falnanfal +falnantru +falnorfal +falnortru +falorfal +falortru +false +false_elim +falseral0 +falseral0old +falsify-signed-byte-p +falsify-unsigned-byte-p +falxorfal +falxortru +fan_theorem +faosnf0.11b +faovcl +fargshiftf +fargshiftf1 +fargshiftfo +fargshiftfv +fargshiftfva +farkas_lemma +farkas_lemma_alt +fast_exp_imperative_spec +fast_exp_spec +faster +fastforce +fastforce_dest +fatou +fatou_strong +fbasfip +fbasne0 +fbasrn +fbasssin +fbasweak +fbdmn0 +fbelss +fbfinnfr +fbflim +fbflim2 +fbncp +fbssfi +fbssint +fbsspw +fbun +fbunfip +fcdmnn0fsupp +fcdmnn0fsuppg +fcdmnn0supp +fcdmnn0suppg +fcdmssb +fcdmvafv2v +fcfelbas +fcfnei +fcfneii +fcfval +fclim +fclsbas +fclscf +fclscmp +fclscmpi +fclselbas +fclsfil +fclsfnflim +fclsnei +fclsneii +fclsopn +fclsopni +fclsrest +fclsss1 +fclsss2 +fclssscls +fclstop +fclstopon +fclsval +fcnre +fcnvgreu +fcnvres +fco +fco2 +fco2d +fcobij +fcobijfs +fcobijfs2 +fcoconst +fcod +fcof +fcof1 +fcof1o +fcof1od +fcof1oinvd +fcofo +fcoi1 +fcoi2 +fcoinvbr +fcoinver +fcompt +fcomptf +fcomptss +fconst +fconst2 +fconst2g +fconst3 +fconst4 +fconst5 +fconst6 +fconst6g +fconst7 +fconst7v +fconstfv +fconstg +fconstmpo +fconstmpt +fcores +fcoresf1 +fcoresf1b +fcoresf1lem +fcoresf1ob +fcoresfo +fcoresfob +fcoreslem1 +fcoreslem2 +fcoreslem3 +fcoreslem4 +fcoss +fct2relem +fctop +fctop2 +fczfsuppd +fczpsrbag +fczsupp0 +fdc +fdc1 +fden +fdiagfn +fdifsupp +fdifsuppconst +fdivmpt +fdivmptf +fdivmptfv +fdivpm +fdivval +fdm +fdmd +fdmdifeqresdif +fdmeu +fdmexb +fdmfifsupp +fdmfisuppfi +fdmi +fdmrn +fdomne0 +fdvnegge +fdvneggt +fdvposle +fdvposlt +fedgmul +fedgmullem1 +fedgmullem2 +felapton +feldmfvelcdm +fences +fences2 +fences3 +feq1 +feq123 +feq123d +feq12d +feq12i +feq1d +feq1dd +feq1i +feq2 +feq23 +feq23d +feq23i +feq2d +feq2dd +feq2i +feq3 +feq3d +feq3dd +feqmptd +feqmptdf +feqresmpt +feqresmptf +ferio +ferison +fermat_little +fermat_little_prime +fermltl +fermltlchr +fertilizer_mix +fesapo +festino +festinoalt +feu +fex +fex2 +fexafv2ex +fexd +ffdm +ffdmd +ffi +ffn +ffnafv +ffnaov +ffnd +ffnfv +ffnfvf +ffnov +ffoss +ffrn +ffrnb +ffrnbd +ffs2 +ffsrn +ffsuppbi +ffthf1o +ffthiso +ffthoppc +ffthoppf +ffthres2c +ffun +ffund +ffvbr +ffvelcdm +ffvelcdmd +ffvelcdmda +ffvelcdmi +ffvresb +ffz0hash +ffz0iswrd +ffzo0hash +fgabs +fgcfil +fgcl +fge0iccico +fge0iccre +fge0icoicc +fge0npnf +fgfil +fglmod +fgmin +fgraphopab +fgraphxp +fgreu +fgss +fgss2 +fgtr +fgval +fh1 +fh1i +fh2 +fh2i +fh3i +fh4i +fi0 +fi1uzind +fiabv +fib +fib0 +fib1 +fib2 +fib3 +fib4 +fib5 +fib6 +fib_12 +fib_13 +fib_14 +fib_add +fib_aux_spec +fib_spec +fib_square +fibas +fiblem +fibmonotone +fibo_spec +fibonacci_correct +fibonacci_monotone +fibonacci_spec +fibp1 +fibpositive +ficard +ficardadju +ficardid +ficardom +ficardun +ficardun2 +fict +fictb +fidmfisupp +fidomdm +fidomncyc +fidomndrng +fidomndrnglem +fidomtri +fidomtri2 +field_inv_mul +field_no_zero_div +fieldaxiom +fieq0 +fifo +fiidomfld +fiin +fiinbas +fiinf2g +fiinfcl +fiinfg +fiinfi +fiinfnf1o +fiinopn +fiint +fiiuncl +filbcmb +filconn +file +filecopyrighttext +fileln0 +filelss +filfbas +filfi +filfinnfr +filin +filinn0 +filintn0 +filn0 +filnet +filnetlem1 +filnetlem2 +filnetlem3 +filnetlem4 +filnm +filss +filsspw +filssufil +filssufilg +filter +filter_all_distinct +filter_app +filter_append +filter_append_distrib +filter_cond_rewrite +filter_eq_append +filter_eq_cons +filter_eq_id +filter_eq_nil +filter_gen_tac +filter_in +filter_length +filter_neq_id +filter_neq_nil +filter_nil +filter_preserves_membership +filter_reverse +filterappend +filterdpair +filterview +filtop +filufint +filuni +filunibas +filunirn +fimacnv +fimacnvdisj +fimacnvinrn +fimacnvinrn2 +fimact +fimadmfo +fimadmfoalt +fimaproj +fimarab +fimass +fimassd +fimax2g +fimaxg +fimaxre +fimaxre2 +fimaxre3 +fimaxre4 +fimgmcyc +fimgmcyclem +fimin2g +fiming +fiminre +fiminre2 +fin +fin'_hom_inject +fin'_hom_mul +fin'_hom_strict +fin11a +fin12 +fin17 +fin1a2 +fin1a2lem1 +fin1a2lem10 +fin1a2lem11 +fin1a2lem12 +fin1a2lem13 +fin1a2lem2 +fin1a2lem3 +fin1a2lem4 +fin1a2lem5 +fin1a2lem6 +fin1a2lem7 +fin1a2lem8 +fin1a2lem9 +fin1a2s +fin1ai +fin1aufil +fin23 +fin23lem11 +fin23lem12 +fin23lem13 +fin23lem14 +fin23lem15 +fin23lem16 +fin23lem17 +fin23lem19 +fin23lem20 +fin23lem21 +fin23lem22 +fin23lem23 +fin23lem24 +fin23lem25 +fin23lem26 +fin23lem27 +fin23lem28 +fin23lem29 +fin23lem30 +fin23lem31 +fin23lem32 +fin23lem33 +fin23lem34 +fin23lem35 +fin23lem36 +fin23lem38 +fin23lem39 +fin23lem40 +fin23lem41 +fin23lem7 +fin2i +fin2i2 +fin2inf +fin2so +fin2solem +fin33i +fin34 +fin34i +fin41 +fin45 +fin4en1 +fin4i +fin56 +fin67 +fin71ac +fin71num +fin_hom_inject +fin_hom_mul +fin_hom_strict +fin_sat_decidable +finacn +fincmp +fincssdom +fincygsubgd +fincygsubgodd +fincygsubgodexd +find +find_thm +findabrcl +findcard +findcard2 +findcard2d +findcard2s +findcard3 +findes +findfvcl +findq_divisor +findq_eq_0 +findreccl +finds +finds1 +finds2 +findsg +fine_division_exists +fine_inter +fine_inters +fine_simplicial_subdivision_of_cell_complex +fine_subset +fine_triangular_subdivision_of_cell_complex +fine_union +fine_unions +fineqv +fineqvac +fineqvacalt +fineqvinfep +fineqvlem +fineqvnttrclse +fineqvnttrclselem1 +fineqvnttrclselem2 +fineqvnttrclselem3 +fineqvomon +fineqvomonb +fineqvpow +fineqvr1ombregs +fineqvrep +finextalg +finextfldext +finexttrb +finfdm +finfdm2 +fingch +finite +finite_all_distinct_lists +finite_ball +finite_biginter +finite_bigunion +finite_bij +finite_bij_card +finite_bij_card_eq +finite_bij_count +finite_bij_count_eq +finite_bounded_functions +finite_bounded_lists +finite_card_image +finite_cball +finite_columns +finite_complete_induction +finite_components_finite +finite_components_union +finite_connected_components_of_finite +finite_countable +finite_cross +finite_delete +finite_diff +finite_diff_down +finite_eigenvalues +finite_empty +finite_eq_bounded_discrete +finite_faces_of_simplex +finite_finite_preimage +finite_group_surj +finite_has_size +finite_image +finite_image_inj +finite_image_inj_eq +finite_imp_bounded +finite_imp_bounded_convex_hull +finite_imp_closed +finite_imp_closed_in +finite_imp_compact +finite_imp_compact_convex_hull +finite_imp_countable +finite_imp_not_open +finite_imp_totally_disconnected +finite_index_inrange +finite_index_numseg +finite_index_numseg_special +finite_index_works +finite_induct_strong +finite_inj +finite_insert +finite_inter +finite_inter_collinear_open_segments +finite_inter_numseg +finite_interval_1 +finite_is_measure_maximal +finite_iso_num +finite_least_measure_induction +finite_lists_bounded +finite_numseg +finite_numseg_le +finite_numseg_lt +finite_partition +finite_partitions +finite_pcross +finite_permutations +finite_polyhedron_exposed_faces +finite_polyhedron_extreme_points +finite_polyhedron_faces +finite_polyhedron_facets +finite_polytope_faces +finite_polytope_facets +finite_pow +finite_powerset +finite_preimage +finite_product +finite_product_dependent +finite_psubset_infinite +finite_psubset_univ +finite_rest +finite_rest_eq +finite_restrict +finite_rows +finite_rules +finite_segment +finite_set_avoid +finite_set_of_list +finite_sing +finite_sphere_1 +finite_stdbasis +finite_strongorder_wf +finite_subset +finite_subset_image +finite_surj +finite_surj_bij +finite_union +finite_unions +finite_walks +finite_walks_le +finite_weak_enumerate +finite_wf_noloops +finitely_generated_conic_polyhedron +finitely_injective_image_finite +finiteunion +finiunmbl +finixpnum +finlocfin +finminlem +finngch +finnisoeu +finnum +finnzfsuppd +finodsubmsubg +finona1cl +finonex +finorwe +finptfin +finresfin +finrusgrfusgr +finseq_concat_assoc +finseq_concat_empty +finseq_concat_len +finseq_dom_range +finseq_empty +finseq_perm_len +finseq_rev_len +finseq_rev_rev +finseq_rng_subset +finseq_singleton +finsschain +finsubmsubg +finsumvtxdg2size +finsumvtxdg2sstep +finsumvtxdg2ssteplem1 +finsumvtxdg2ssteplem2 +finsumvtxdg2ssteplem3 +finsumvtxdg2ssteplem4 +finsumvtxdgeven +fint +fintonatbound +fintonatlast +fintonatweaken +finxp0 +finxp00 +finxp1o +finxp2o +finxp3o +finxpeq1 +finxpeq2 +finxpnom +finxpreclem1 +finxpreclem2 +finxpreclem3 +finxpreclem4 +finxpreclem5 +finxpreclem6 +finxpsuc +finxpsuclem +fiphp3d +fipjust +fiprc +fipreima +fipwss +fipwuni +firest +first +first_assum +first_x_assum +fisdomnn +fislw +fisn +fiss +fisseneq +fisshasheq +fissn0dvds +fissn0dvdsn0 +fissorduni +fissuni +fisup2g +fisupcl +fisupclrnmpt +fisupg +fisuppfi +fisuppov1 +fitop +fiufl +fiun +fiuncmp +fiunelcarsg +fiunelros +fiuneneq +fiuni +fiunicl +fiunlem +fival +fix +fixcnv +fixssdm +fixssrn +fixufil +fixun +fladdz +flat_append +flat_compute +flat_eq_append +flat_eq_nil +flat_eq_sing +flat_map_assoc +flat_map_k_nil +flatcgra +flbi +flbi2 +flcidc +flcl +flcld +fldc +fldcaltv +fldcat +fldcataltv +fldcrngd +fldcrngo +flddivrng +flddmn +flddrngd +fldext2chn +fldext2rspun +fldextchr +fldextfld1 +fldextfld2 +fldextid +fldextress +fldextrspundgdvds +fldextrspundgdvdslem +fldextrspundgle +fldextrspundglemul +fldextrspunfld +fldextrspunlem1 +fldextrspunlem2 +fldextrspunlsp +fldextrspunlsplem +fldextsdrg +fldextsralvec +fldextsubrg +fldexttr +fldgenfld +fldgenfldext +fldgenid +fldgenidfld +fldgensdrg +fldgenss +fldgenssid +fldgenssp +fldgenssv +fldgenval +fldhmf1 +fldhmsubc +fldhmsubcaltv +fldidom +fldiv +fldiv2 +fldiv4lem1div2 +fldiv4lem1div2uz2 +fldiv4p1lem1div2 +fldivexpfllog2 +fldivle +fldivmod +fldivndvdslt +fldivnn0 +fldivnn0le +fldivp1 +fldpropd +fldsdrgfld +fldsdrgfldext +fldsdrgfldext2 +fleet_routing +fleqceilz +flfcnp +flfcnp2 +flfcntr +flfelbas +flffbas +flffval +flflp1 +flfnei +flfneii +flfssfcf +flftg +flfval +flge +flge0nn0 +flge1nn +flhalf +flid +flidm +flidz +fliftcnv +fliftel +fliftel1 +fliftf +fliftfun +fliftfund +fliftfuns +fliftrel +fliftval +flimcf +flimcfil +flimcls +flimclsi +flimclslem +flimelbas +flimfcls +flimfil +flimfnfcls +flimnei +flimneiss +flimopn +flimrest +flimsncls +flimss1 +flimss2 +flimtop +flimtopon +flimval +flle +flleceil +fllelt +fllep1 +fllog2 +fllogbd +fllt +flltdivnn0lt +flltnz +flltp1 +flmod +flmulnn0 +flnn0div2ge +flnn0ohalf +flo1 +float_add_comm +float_error_bound +float_mult_error +float_sqrt_correct +flodddiv4 +flodddiv4lt +flodddiv4t2lthalf +floor-bounds +floor-bounds-x +floor-unsigned-byte-p +floor_pos +flow_shop +flow_value = sum(v)(flow[1,v]) +flpmodeq +flsqrt +flsqrt5 +flsubz +flt0 +flt4lem +flt4lem1 +flt4lem2 +flt4lem3 +flt4lem4 +flt4lem5 +flt4lem5a +flt4lem5b +flt4lem5c +flt4lem5d +flt4lem5e +flt4lem5elem +flt4lem5f +flt4lem6 +flt4lem7 +fltabcoprm +fltabcoprmex +fltaccoprm +fltbccoprm +fltdiv +fltdvdsabdvdsc +fltltc +fltmul +fltne +fltnlta +fltnltalem +flval +flval2 +flval3 +flword2 +flwordi +flzadd +fmcfil +fmcncfil +fmco +fmf +fmfg +fmfil +fmfnfm +fmfnfmlem1 +fmfnfmlem2 +fmfnfmlem3 +fmfnfmlem4 +fmid +fmla +fmla0 +fmla0disjsuc +fmla0xp +fmla1 +fmlafv +fmlafvel +fmlan0 +fmlaomn0 +fmlasssuc +fmlasuc +fmlasuc0 +fmlasucdisj +fmpo +fmpoco +fmpocos +fmpod +fmpodg +fmpox +fmpt +fmpt2d +fmpt3d +fmptap +fmptapd +fmptco +fmptco1f1o +fmptcof +fmptcof2 +fmptcos +fmptd +fmptd2f +fmptdf +fmptdff +fmptf +fmptff +fmpti +fmptpr +fmptsn +fmptsnd +fmptsng +fmptsnxp +fmptssfisupp +fmpttd +fmptunsnop +fmss +fmtno +fmtno0 +fmtno0prm +fmtno1 +fmtno1prm +fmtno2 +fmtno2prm +fmtno3 +fmtno3prm +fmtno4 +fmtno4nprmfac193 +fmtno4prm +fmtno4prmfac +fmtno4prmfac193 +fmtno4sqrt +fmtno5 +fmtno5fac +fmtno5faclem1 +fmtno5faclem2 +fmtno5faclem3 +fmtno5lem1 +fmtno5lem2 +fmtno5lem3 +fmtno5lem4 +fmtno5nprm +fmtnodvds +fmtnof1 +fmtnofac1 +fmtnofac2 +fmtnofac2lem +fmtnofz04prm +fmtnoge3 +fmtnoinf +fmtnole4prm +fmtnom1nn +fmtnonn +fmtnoodd +fmtnoprmfac1 +fmtnoprmfac1lem +fmtnoprmfac2 +fmtnoprmfac2lem1 +fmtnorec1 +fmtnorec2 +fmtnorec2lem +fmtnorec3 +fmtnorec4 +fmtnorn +fmtnosqrt +fmucnd +fmucndlem +fmufil +fmul01 +fmul01lt1 +fmul01lt1lem1 +fmul01lt1lem2 +fmulcl +fmuldfeq +fmuldfeqlem1 +fmval +fn0 +fn0g +fnafv2elrn +fnafvelrn +fnasrn +fnbigcup +fnbr +fnbrafv2b +fnbrafvb +fnbrfvb +fnbrfvb2 +fnbrovb +fnchoice +fncld +fncnv +fncnvima2 +fncnvimaeqv +fnco +fncofn +fnconstg +fncpn +fnct +fncvm +fndifnfp +fndm +fndmd +fndmdif +fndmdifcom +fndmdifeq0 +fndmeng +fndmexb +fndmexd +fndmfifsupp +fndmfisuppfi +fndmi +fndmin +fndmu +fnebas +fneer +fneint +fnejoin1 +fnejoin2 +fnelfp +fnelnfp +fnemeet1 +fnemeet2 +fneq1 +fneq12 +fneq12d +fneq1d +fneq1i +fneq2 +fneq2d +fneq2i +fneqeql +fneqeql2 +fneref +fnerel +fness +fnessex +fnessref +fnetg +fnetr +fneu +fneu2 +fneuni +fneval +fnex +fnexalt +fnexd +fnfco +fnfi +fnfocofob +fnfuc +fnfun +fnfund +fnfvelrn +fnfvelrnd +fnfvima +fnfvimad +fnfvof +fnfvor +fnfvrnss +fnfz0hash +fnfz0hashnn0 +fnfzo0hash +fnfzo0hashnn0 +fnhomeqhomf +fniinfv +fnima +fnimadisj +fnimaeq0 +fnimafnex +fnimage +fnimapr +fnimasnd +fnimatpd +fninfp +fniniseg +fniniseg2 +fniunfv +fnlimabslt +fnlimcnv +fnlimf +fnlimfv +fnlimfvre +fnlimfvre2 +fnmap +fnmgp +fnmpo +fnmpoi +fnmpoovd +fnmpt +fnmptd +fnmptf +fnmptfvd +fnmpti +fnmptif +fnmrc +fnmre +fnn0ind +fnnfpeq0 +fnoa +fnoe +fnom +fnop +fnopab +fnopabco +fnopabeqd +fnopabg +fnopafv2b +fnopafvb +fnopfv +fnopfvb +fnoprab +fnoprabg +fnotaovb +fnotovb +fnov +fnovrn +fnpm +fnpr2g +fnpr2o +fnpr2ob +fnprb +fnpreimac +fnprg +fnrel +fnrelpredd +fnres +fnresdisj +fnresdm +fnresdmss +fnreseql +fnresfnco +fnresi +fnresin +fnresin1 +fnresin2 +fnressn +fnrnafv +fnrndomg +fnrnfv +fnrnov +fnse +fnseqom +fnsingle +fnsn +fnsnb +fnsnbg +fnsnbold +fnsnfv +fnsng +fnsnr +fnsnsplit +fnssintima +fnssres +fnssresb +fnssresd +fnsuppeq0 +fnsuppres +fntopon +fntp +fntpb +fntpg +fnum +fnun +fnund +fnunirn +fnunop +fnunres1 +fnunres2 +fnwe +fnwe2 +fnwe2lem1 +fnwe2lem2 +fnwe2lem3 +fnwe2val +fnwelem +fnxpc +fnxpdmdm +fo00 +fo1st +fo1stres +fo2nd +fo2ndf +fo2ndres +fobigcup +focdmex +focnvimacdmdm +foco +foco2 +fococnv2 +focofo +focofob +foconst +fodmrnu +fodom +fodomacn +fodomb +fodomfi +fodomfi2 +fodomfib +fodomfibold +fodomfiold +fodomfir +fodomg +fodomnum +fodomr +foelcdmi +foelrn +foelrnf +foeq1 +foeq123d +foeq2 +foeq3 +foeqcnvco +fof +fofi +fofinf1o +fofn +fofun +foima +foimacnv +fold +fold_left_append +fold_right_app +fold_right_cons +fold_right_nil +foldl +foldl2_foldl +foldl_cons +foldl_eq_foldr +foldl_nil +foldl_snoc +foldl_union_bigunion +foldl_union_bigunion_paired +foldr +foldr_append +foldr_cons +foldr_nil +fompt +fonex +fonum +foo +foot +footeq +footex +footexalt +footexlem1 +footexlem2 +footne +foov +fopwdom +for +for_all_append +forall +forall(m in matches)(home[m] != away[m]) +forall(t in periods)(inventory[t] >= 0) +forall-tp +forall_1 +forall_2 +forall_3 +forall_4 +forall_and +forall_and_thm +forall_bool_thm +forall_conj +forall_conj_distrib +forall_countable_as_image +forall_diff +forall_dimindex_1 +forall_dot_eq_0 +forall_drop +forall_drop_fun +forall_drop_image +forall_eventually +forall_finite_subset_image_inj +forall_fun_drop +forall_fun_lift +forall_implies_exists +forall_in_bigunion +forall_in_closure +forall_in_closure_eq +forall_in_division +forall_in_division_nonempty +forall_in_gspec +forall_in_image +forall_in_insert +forall_in_intermediate_closure +forall_in_intermediate_closure_eq +forall_in_pcross +forall_in_union +forall_in_unions +forall_length_clauses +forall_lift +forall_lift_fun +forall_lift_image +forall_list +forall_num +forall_num_thm +forall_of_drop +forall_of_pastecart +forall_option +forall_pair_thm +forall_paired_thm +forall_pastecart +forall_real_one +forall_subset_image +forall_subset_union +forall_type +forall_vector_1 +forall_vector_2 +forall_vector_3 +forall_vector_4 +force +force_cases +foreign_key +fores +foresf1o +form +formal +formalises +forn +forster_puzzle +forward +forward_secrecy +fosetex +foun +foundation +founiiun +founiiun0 +fourier +fourier2 +fourierclim +fourierclimd +fouriercn +fouriercnp +fourierd +fourierdlem1 +fourierdlem10 +fourierdlem100 +fourierdlem101 +fourierdlem102 +fourierdlem103 +fourierdlem104 +fourierdlem105 +fourierdlem106 +fourierdlem107 +fourierdlem108 +fourierdlem109 +fourierdlem11 +fourierdlem110 +fourierdlem111 +fourierdlem112 +fourierdlem113 +fourierdlem114 +fourierdlem115 +fourierdlem12 +fourierdlem13 +fourierdlem14 +fourierdlem15 +fourierdlem16 +fourierdlem17 +fourierdlem18 +fourierdlem19 +fourierdlem2 +fourierdlem20 +fourierdlem21 +fourierdlem22 +fourierdlem23 +fourierdlem24 +fourierdlem25 +fourierdlem26 +fourierdlem27 +fourierdlem28 +fourierdlem29 +fourierdlem3 +fourierdlem30 +fourierdlem31 +fourierdlem32 +fourierdlem33 +fourierdlem34 +fourierdlem35 +fourierdlem36 +fourierdlem37 +fourierdlem38 +fourierdlem39 +fourierdlem4 +fourierdlem40 +fourierdlem41 +fourierdlem42 +fourierdlem43 +fourierdlem44 +fourierdlem46 +fourierdlem47 +fourierdlem48 +fourierdlem49 +fourierdlem5 +fourierdlem50 +fourierdlem51 +fourierdlem52 +fourierdlem53 +fourierdlem54 +fourierdlem55 +fourierdlem56 +fourierdlem57 +fourierdlem58 +fourierdlem59 +fourierdlem6 +fourierdlem60 +fourierdlem61 +fourierdlem62 +fourierdlem63 +fourierdlem64 +fourierdlem65 +fourierdlem66 +fourierdlem67 +fourierdlem68 +fourierdlem69 +fourierdlem7 +fourierdlem70 +fourierdlem71 +fourierdlem72 +fourierdlem73 +fourierdlem74 +fourierdlem75 +fourierdlem76 +fourierdlem77 +fourierdlem78 +fourierdlem79 +fourierdlem8 +fourierdlem80 +fourierdlem81 +fourierdlem82 +fourierdlem83 +fourierdlem84 +fourierdlem85 +fourierdlem86 +fourierdlem87 +fourierdlem88 +fourierdlem89 +fourierdlem9 +fourierdlem90 +fourierdlem91 +fourierdlem92 +fourierdlem93 +fourierdlem94 +fourierdlem95 +fourierdlem96 +fourierdlem97 +fourierdlem98 +fourierdlem99 +fouriersw +fourierswlem +fovcdm +fovcdmd +fovcdmda +fovcl +fovcld +fowdom +fpar +fparlem1 +fparlem2 +fparlem3 +fparlem4 +fperdvper +fperiodmul +fperiodmullem +fphpd +fphpdo +fply1 +fpm +fpmd +fpmg +fppr +fppr2odd +fpprbasnn +fpprel +fpprel2 +fpprmod +fpprnn +fpprwppr +fpprwpprb +fpr +fpr1 +fpr2 +fpr2a +fpr2g +fpr3 +fpr3g +fprb +fprfung +fprg +fprlem1 +fprlem2 +fprmappr +fprod +fprod0 +fprod0diag +fprod1 +fprod1p +fprod2d +fprod2dlem +fprodabs +fprodabs2 +fprodadd2cncf +fprodaddrecnncnv +fprodaddrecnncnvlem +fprodcl +fprodcl2lem +fprodclf +fprodcllem +fprodcllemf +fprodcn +fprodcncf +fprodcnlem +fprodcnv +fprodcom +fprodcom2 +fprodconst +fprodcvg +fproddiv +fproddivf +fproddvdsd +fprodefsum +fprodeq0 +fprodeq02 +fprodeq0g +fprodex01 +fprodexp +fprodf1o +fprodfac +fprodfvdvdsd +fprodge0 +fprodge1 +fprodle +fprodm1 +fprodm1s +fprodmodd +fprodmul +fprodn0 +fprodn0f +fprodnn0cl +fprodnncl +fprodntriv +fprodp1 +fprodp1s +fprodrecl +fprodreclf +fprodrev +fprodrpcl +fprodser +fprodshft +fprodsplit +fprodsplit1 +fprodsplit1f +fprodsplitf +fprodsplitsn +fprodss +fprodsub2cncf +fprodsubrecnncnv +fprodsubrecnncnvlem +fprodxp +fprodzcl +fpropnf1 +fprresex +fpwfvss +fpwipodrs +fpwrelmap +fpwrelmapffs +fpwrelmapffslem +fpwwe +fpwwe2 +fpwwe2cbv +fpwwe2lem1 +fpwwe2lem10 +fpwwe2lem11 +fpwwe2lem12 +fpwwe2lem2 +fpwwe2lem3 +fpwwe2lem4 +fpwwe2lem5 +fpwwe2lem6 +fpwwe2lem7 +fpwwe2lem8 +fpwwe2lem9 +fpwwecbv +fpwwelem +fr0 +fr0g +fr2nr +fr3nr +fracbas +fracerl +fracf1 +fracfld +fracge0 +fracle1 +fraclt1 +fracval +framecondition +frc +frcond1 +frcond2 +frcond3 +frcond4 +frd +frechet_derivative_at +frechet_derivative_const_at +frechet_derivative_unique_at +frechet_derivative_unique_within +frechet_derivative_unique_within_closed_interval +frechet_derivative_unique_within_open_interval +frechet_derivative_within_closed_interval +frechet_derivative_works +frecseq123 +free +free_monad +frege10 +frege100 +frege101 +frege102 +frege102d +frege103 +frege104 +frege105 +frege106 +frege106d +frege107 +frege108 +frege108d +frege109 +frege109d +frege11 +frege110 +frege111 +frege111d +frege112 +frege113 +frege114 +frege114d +frege116 +frege117 +frege118 +frege119 +frege12 +frege120 +frege121 +frege122 +frege122d +frege123 +frege124 +frege124d +frege125 +frege126 +frege126d +frege127 +frege128 +frege129 +frege129d +frege13 +frege130 +frege131 +frege131d +frege132 +frege133 +frege133d +frege14 +frege15 +frege16 +frege17 +frege18 +frege19 +frege20 +frege21 +frege22 +frege23 +frege24 +frege25 +frege26 +frege27 +frege29 +frege3 +frege30 +frege32 +frege33 +frege34 +frege35 +frege36 +frege37 +frege38 +frege39 +frege4 +frege40 +frege42 +frege43 +frege44 +frege45 +frege46 +frege47 +frege48 +frege49 +frege5 +frege50 +frege51 +frege52aid +frege52b +frege53a +frege53aid +frege53b +frege53c +frege54b +frege54cor0a +frege54cor1a +frege54cor1b +frege54cor1c +frege55a +frege55aid +frege55b +frege55c +frege55cor1a +frege55lem1a +frege55lem1b +frege55lem1c +frege55lem2a +frege55lem2b +frege55lem2c +frege56a +frege56aid +frege56b +frege56c +frege57a +frege57aid +frege57b +frege57c +frege58acor +frege58bcor +frege58bid +frege58c +frege59a +frege59b +frege59c +frege6 +frege60a +frege60b +frege60c +frege61a +frege61b +frege61c +frege62a +frege62b +frege62c +frege63a +frege63b +frege63c +frege64a +frege64b +frege64c +frege65a +frege65b +frege65c +frege66a +frege66b +frege66c +frege67a +frege67b +frege67c +frege68a +frege68b +frege68c +frege7 +frege70 +frege71 +frege72 +frege73 +frege74 +frege75 +frege77 +frege77d +frege78 +frege79 +frege80 +frege81 +frege81d +frege82 +frege83 +frege83d +frege84 +frege85 +frege86 +frege87 +frege87d +frege88 +frege89 +frege9 +frege90 +frege91 +frege91d +frege92 +frege93 +frege94 +frege95 +frege96 +frege96d +frege97 +frege97d +frege98 +frege98d +frel +freld +freq1 +freq12d +freq2 +frequency_assignment +fresaun +fresaunres1 +fresaunres2 +fresf1o +fresfo +fresh +freshmansdream +fresin +fresin2 +fresison +fressnfv +fressupp +fresunsn +frexr +frfi +frfnom +frgp0 +frgpadd +frgpcpbl +frgpcyg +frgpeccl +frgpgrp +frgpinv +frgpmhm +frgpnabl +frgpnabllem1 +frgpnabllem2 +frgpup1 +frgpup2 +frgpup3 +frgpup3lem +frgpupf +frgpuplem +frgpuptf +frgpuptinv +frgpupval +frgpval +frgr0 +frgr0v +frgr0vb +frgr1v +frgr2wsp1 +frgr2wwlk1 +frgr2wwlkeqm +frgr2wwlkeu +frgr2wwlkn0 +frgr3v +frgr3vlem1 +frgr3vlem2 +frgrconngr +frgreu +frgrhash2wsp +frgrnbnb +frgrncvvdeq +frgrncvvdeqlem1 +frgrncvvdeqlem10 +frgrncvvdeqlem2 +frgrncvvdeqlem3 +frgrncvvdeqlem4 +frgrncvvdeqlem5 +frgrncvvdeqlem6 +frgrncvvdeqlem7 +frgrncvvdeqlem8 +frgrncvvdeqlem9 +frgrogt3nreg +frgrreg +frgrreggt1 +frgrregord013 +frgrregord13 +frgrregorufr +frgrregorufr0 +frgrregorufrg +frgruhgr0v +frgrusgr +frgrwopreg +frgrwopreg1 +frgrwopreg2 +frgrwopregasn +frgrwopregbsn +frgrwopreglem1 +frgrwopreglem2 +frgrwopreglem3 +frgrwopreglem4 +frgrwopreglem4a +frgrwopreglem5 +frgrwopreglem5a +frgrwopreglem5alt +frgrwopreglem5lem +fri +friendship +friendshipgt3 +frind +frinfm +frins +frins2 +frins2f +frins3 +frinsg +frinxp +frirr +frlm0 +frlm0vald +frlmbas +frlmbas3 +frlmbasf +frlmbasfsupp +frlmbasmap +frlmdim +frlmelbas +frlmfibas +frlmfielbas +frlmfzoccat +frlmfzolen +frlmfzowrd +frlmfzowrdb +frlmfzwrd +frlmgsum +frlmip +frlmipval +frlmiscvec +frlmisfrlm +frlmlbs +frlmlmod +frlmlss +frlmlvec +frlmphl +frlmphllem +frlmplusgval +frlmplusgvalb +frlmpwfi +frlmpws +frlmpwsfi +frlmrcl +frlmsca +frlmsnic +frlmsplit2 +frlmsslsp +frlmsslss +frlmsslss2 +frlmssuvc1 +frlmssuvc2 +frlmsubgval +frlmup1 +frlmup2 +frlmup3 +frlmup4 +frlmval +frlmvplusgscavalb +frlmvplusgvalc +frlmvscadiccat +frlmvscafval +frlmvscaval +frlmvscavalb +frmd0 +frmdadd +frmdbas +frmdelbas +frmdgsum +frmdmnd +frmdplusg +frmdss2 +frmdsssubm +frmdup1 +frmdup2 +frmdup3 +frmdup3lem +frmdval +frmin +frminex +frmx +frmy +frn +frnd +frobrhm +from +from_0 +from_inter_numseg +from_not_empty +frommaybedefault +front_take +frontier_affinity +frontier_ball +frontier_bijective_linear_image +frontier_cball +frontier_clopen_map_image +frontier_clopen_map_image_subset +frontier_closed +frontier_closed_interval +frontier_closure_convex +frontier_closure_subset +frontier_closures +frontier_complement +frontier_convex_hull_cases +frontier_convex_hull_explicit +frontier_disjoint_eq +frontier_empty +frontier_eq_empty +frontier_frontier +frontier_frontier_frontier +frontier_frontier_subset +frontier_halfspace_component_ge +frontier_halfspace_component_gt +frontier_halfspace_component_le +frontier_halfspace_component_lt +frontier_halfspace_ge +frontier_halfspace_gt +frontier_halfspace_le +frontier_halfspace_lt +frontier_injective_linear_image +frontier_inter +frontier_inter_closed +frontier_inter_subset +frontier_inter_subset_inter +frontier_interior_subset +frontier_interiors +frontier_not_empty +frontier_of_components_closed_complement +frontier_of_components_subset +frontier_of_connected_component_subset +frontier_of_convex_closed +frontier_of_convex_hull +frontier_of_frontier_of +frontier_of_injective_linear_image +frontier_of_restrict +frontier_of_translation +frontier_of_triangle +frontier_open_interval +frontier_open_map_image_subset +frontier_open_straddle_inter +frontier_open_union +frontier_open_unions +frontier_pcross +frontier_proper_clopen_map_image +frontier_proper_map_image_subset +frontier_proper_map_image_subset_gen +frontier_proper_open_map_image +frontier_scaling +frontier_segment +frontier_sing +frontier_sphere +frontier_straddle +frontier_strip_component_le +frontier_strip_component_lt +frontier_subset_closed +frontier_subset_compact +frontier_subset_eq +frontier_surjective_linear_image +frontier_translation +frontier_union +frontier_union_interior +frontier_union_subset +frontier_univ +frpoind +frpoins2fg +frpoins2g +frpoins3g +frpoins3xp3g +frpoins3xpg +frpoinsg +frpomin +frpomin2 +frr1 +frr2 +frr3 +frr3g +frrdmcl +frrdmss +frrlem1 +frrlem10 +frrlem11 +frrlem12 +frrlem13 +frrlem14 +frrlem15 +frrlem16 +frrlem2 +frrlem3 +frrlem4 +frrlem5 +frrlem6 +frrlem7 +frrlem8 +frrlem9 +frrrel +frrusgrord +frrusgrord0 +frrusgrord0lem +frsn +frss +frsuc +frsucmpt +frsucmpt2 +frsucmptn +frusgrnn0 +frxp +frxp2 +frxp3 +fs +fscgr +fseq1hash +fseq1m1p1 +fseq1p1m1 +fseqdom +fseqen +fseqenlem1 +fseqenlem2 +fseqsupcl +fseqsupubi +fsequb +fsequb2 +fset0 +fsetabsnop +fsetcdmex +fsetdmprc0 +fsetex +fsetexb +fsetfcdm +fsetfocdm +fsetprcnex +fsetprcnexalt +fsets +fsetsnf +fsetsnf1 +fsetsnf1o +fsetsnfo +fsetsniunop +fsetsnprcnex +fsetsspwxp +fsfnn0gsumfsffz +fsigma_ascending +fsigma_baire +fsigma_baire1_preimage_open +fsigma_baire1_preimage_open_gen +fsigma_baire_preimage_open +fsigma_baire_preimage_open_gen +fsigma_complement +fsigma_continuous_image +fsigma_diff +fsigma_disjoint_gen +fsigma_empty +fsigma_fsigma_projection +fsigma_gdelta_disjoint +fsigma_gdelta_gen +fsigma_imp_analytic +fsigma_imp_borel +fsigma_imp_lebesgue_measurable +fsigma_in_euclidean +fsigma_in_gdelta_in +fsigma_in_inter +fsigma_in_union +fsigma_in_unions +fsigma_inter +fsigma_inters +fsigma_linear_image +fsigma_locally_compact +fsigma_locally_eq +fsigma_locally_gen +fsigma_locally_trans +fsigma_pcross +fsigma_pcross_eq +fsigma_preimage_card_ge +fsigma_proper_preimage +fsigma_reduction +fsigma_reduction_gen_2 +fsigma_reduction_gen_alt +fsigma_sing +fsigma_translation +fsigma_union +fsigma_unions +fsigma_unions_clopen_chain +fsigma_unions_compact +fsigma_univ +fsm_deterministic +fsm_initial_reachable +fsm_invariant_preserve +fsm_no_deadlock +fsm_reachable_trans +fsn +fsn2 +fsn2g +fsnd +fsneq +fsneqrn +fsnex +fsng +fsnunf +fsnunf2 +fsnunfv +fsnunres +fsovcnvd +fsovcnvfvd +fsovcnvlem +fsovd +fsovf1od +fsovfd +fsovfvd +fsovfvfvd +fsovrfovd +fsplit +fsplitfpar +fss +fssd +fssdm +fssdmd +fssres +fssres2 +fssrescdmd +fssresd +fssxp +fst +fstar +fstcart_add +fstcart_cmul +fstcart_component +fstcart_neg +fstcart_pastecart +fstcart_sndcart_mat_zero +fstcart_sndcart_matrix_add +fstcart_sub +fstcart_vec +fstcart_vsum +fstwrdne +fstwrdne0 +fsubbas +fsum +fsum00 +fsum0diag +fsum0diag2 +fsum0diaglem +fsum1 +fsum1p +fsum2cn +fsum2d +fsum2dlem +fsum2dsub +fsum2mul +fsumabs +fsumadd +fsumcj +fsumcl +fsumcl2lem +fsumclf +fsumcllem +fsumcn +fsumcncf +fsumcnf +fsumcnsrcl +fsumcnv +fsumcom +fsumcom2 +fsumconst +fsumcube +fsumcvg +fsumcvg2 +fsumcvg3 +fsumcvg4 +fsumdifsnconst +fsumdivc +fsumdvds +fsumdvdscom +fsumdvdsdiag +fsumdvdsdiaglem +fsumdvdsmul +fsumdvdsmulold +fsumf1o +fsumf1of +fsumfldivdiag +fsumfldivdiaglem +fsumge0 +fsumge0cl +fsumge1 +fsumharmonic +fsumim +fsumiun +fsumiunle +fsumiunss +fsumkthpow +fsumle +fsumlesge0 +fsumless +fsumlessf +fsumlt +fsumm1 +fsummmodsndifre +fsummmodsnunz +fsummsndifre +fsummsnunz +fsummulc1 +fsummulc1f +fsummulc2 +fsumneg +fsumnn0cl +fsumnncl +fsumo1 +fsump1 +fsump1i +fsumparts +fsumre +fsumrecl +fsumreclf +fsumrelem +fsumrev +fsumrev2 +fsumrlim +fsumrp0cl +fsumrpcl +fsumser +fsumsermpt +fsumsers +fsumshft +fsumshftd +fsumshftm +fsumsplit +fsumsplit1 +fsumsplitf +fsumsplitsn +fsumsplitsndif +fsumsplitsnun +fsumss +fsumsub +fsumsupp0 +fsumub +fsumvma +fsumvma2 +fsumxp +fsumzcl +fsumzcl2 +fsupdm +fsupdm2 +fsuppco +fsuppco2 +fsuppcolem +fsuppcor +fsuppcurry1 +fsuppcurry2 +fsuppeq +fsuppeqg +fsuppfund +fsuppimp +fsuppimpd +fsuppind +fsuppinisegfi +fsuppmapnn0fiub +fsuppmapnn0fiub0 +fsuppmapnn0fiubex +fsuppmapnn0fiublem +fsuppmapnn0fz +fsuppmapnn0ub +fsuppmptdm +fsuppmptdmf +fsuppmptif +fsuppres +fsupprnfi +fsuppss +fsuppssind +fsuppssindlem1 +fsuppssindlem2 +fsuppssov1 +fsuppsssupp +fsuppsssuppgd +fsuppun +fsuppunbi +fsuppunfi +fsuppxpfi +fta +fta1 +fta1b +fta1blem +fta1g +fta1glem1 +fta1glem2 +fta1lem +ftalem1 +ftalem2 +ftalem3 +ftalem4 +ftalem5 +ftalem6 +ftalem7 +ftc1 +ftc1a +ftc1anc +ftc1anclem1 +ftc1anclem2 +ftc1anclem3 +ftc1anclem4 +ftc1anclem5 +ftc1anclem6 +ftc1anclem7 +ftc1anclem8 +ftc1cn +ftc1cnnc +ftc1cnnclem +ftc1lem1 +ftc1lem2 +ftc1lem3 +ftc1lem4 +ftc1lem5 +ftc1lem6 +ftc2 +ftc2ditg +ftc2ditglem +ftc2nc +ftc2re +fthcomf +fthepi +fthestrcsetc +fthf1 +fthfunc +fthi +fthinv +fthmon +fthoppc +fthoppf +fthpropd +fthres2 +fthres2b +fthres2c +fthsect +fthsetcestrc +ftp +ftpg +fubini_absolutely_integrable +fubini_absolutely_integrable_alt +fubini_has_absolute_integral +fubini_has_absolute_integral_alt +fubini_has_integral_swap +fubini_has_integral_swap_alt +fubini_integral +fubini_integral_alt +fubini_integral_interval +fubini_integral_interval_alt +fubini_integral_swap +fubini_lebesgue_measurable +fubini_lebesgue_measurable_alt +fubini_measure +fubini_measure_alt +fubini_negligible +fubini_negligible_alt +fubini_negligible_offset +fubini_negligible_replacements +fubini_negligible_replacements_alt +fubini_tonelli +fubini_tonelli_alt +fubini_tonelli_measure +fubini_tonelli_measure_alt +fubini_tonelli_negligible +fubini_tonelli_negligible_alt +fucass +fucbas +fuccat +fuccatid +fucco +fuccocl +fuccofval +fuccoval +fuchom +fucid +fucidcl +fucinv +fuciso +fuclid +fuco1 +fuco11 +fuco111 +fuco111x +fuco112 +fuco112x +fuco112xa +fuco11a +fuco11b +fuco11balt +fuco11cl +fuco11id +fuco11idx +fuco2 +fuco21 +fuco22 +fuco22a +fuco22nat +fuco22natlem +fuco22natlem1 +fuco22natlem2 +fuco22natlem3 +fuco23 +fuco23a +fuco23alem +fuco2el +fuco2eld +fuco2eld2 +fuco2eld3 +fucoco +fucoco2 +fucocolem1 +fucocolem2 +fucocolem3 +fucocolem4 +fucoelvv +fucof1 +fucof21 +fucofn2 +fucofn22 +fucofulem1 +fucofulem2 +fucofunc +fucofunca +fucofval +fucofvalg +fucofvalne +fucoid +fucoid2 +fucolid +fucoppc +fucoppccic +fucoppcco +fucoppcffth +fucoppcfunc +fucoppcid +fucoppclem +fucorid +fucorid2 +fucpropd +fucrid +fucsect +fucterm +fucval +full_case_tac +full_rank_injective +full_rank_surjective +full_simp_tac +full_struct_cases_tac +fullestrcsetc +fullfo +fullfunc +fullfunfnv +fullfunfv +fulli +fulloppc +fulloppf +fullpropd +fullres2c +fullresc +fullsetcestrc +fullsubc +fulltermc +fulltermc2 +fullthinc +fullthinc2 +fun +fun0 +fun11 +fun11uni +fun2 +fun2cnv +fun2d +fun2dmnop +fun2dmnop0 +fun2dmnopgexmpl +fun2ssres +fun_eq_thm +fun_ext +fun_ext_ho +fun_in_image +funadj +funaltveq +funaltveqd +funaltveqi +funaltvfun +funaltvss +funbrafv +funbrafv2 +funbrafv22b +funbrafv2b +funbrafvb +funbreq +funbrfv +funbrfv2b +funbrfvb +func0g +func0g2 +func1st +func1st2nd +func2nd +func_comp_assoc +func_ext +func_id_comp +func_image_inter_inj +func_image_union +func_injective_comp +func_inverse +func_preimage_union +func_surjective_comp +funcco +funcestrcsetc +funcestrcsetclem1 +funcestrcsetclem2 +funcestrcsetclem3 +funcestrcsetclem4 +funcestrcsetclem5 +funcestrcsetclem6 +funcestrcsetclem7 +funcestrcsetclem8 +funcestrcsetclem9 +funcf1 +funcf2 +funcf2lem +funcf2lem2 +funcfn2 +funchomf +funcid +funcinv +funciso +funcixp +funcnv +funcnv0 +funcnv2 +funcnv3 +funcnv4mpt +funcnv5mpt +funcnvadj +funcnvcnv +funcnvmpt +funcnvpr +funcnvqp +funcnvres +funcnvres2 +funcnvs1 +funcnvs2 +funcnvs3 +funcnvs4 +funcnvsn +funcnvtp +funcnvuni +funco +funcocnv2 +funcoeqres +funcofd +funconstss +funcoppc +funcoppc2 +funcoppc3 +funcoppc4 +funcoppc5 +funcoressn +funcpropd +funcrcl +funcrcl2 +funcrcl3 +funcres +funcres2 +funcres2b +funcres2c +funcringcsetc +funcringcsetcaltv +funcringcsetcaltv2 +funcringcsetcaltv2lem1 +funcringcsetcaltv2lem2 +funcringcsetcaltv2lem3 +funcringcsetcaltv2lem4 +funcringcsetcaltv2lem5 +funcringcsetcaltv2lem6 +funcringcsetcaltv2lem7 +funcringcsetcaltv2lem8 +funcringcsetcaltv2lem9 +funcringcsetclem1altv +funcringcsetclem2altv +funcringcsetclem3altv +funcringcsetclem4altv +funcringcsetclem5altv +funcringcsetclem6altv +funcringcsetclem7altv +funcringcsetclem8altv +funcringcsetclem9altv +funcrngcsetc +funcrngcsetcalt +funcsect +funcsetc1o +funcsetc1ocl +funcsetcestrc +funcsetcestrclem1 +funcsetcestrclem2 +funcsetcestrclem3 +funcsetcestrclem4 +funcsetcestrclem5 +funcsetcestrclem6 +funcsetcestrclem7 +funcsetcestrclem8 +funcsetcestrclem9 +funcsetcres2 +funcsn +functermc +functermc2 +functermceu +functermclem +functhinc +functhincfun +functhinclem1 +functhinclem2 +functhinclem3 +functhinclem4 +function +function_convergent_subsequence +function_extension_pointwise +function_extension_pointwise_alt +function_factors_left_gen +function_spec +functor +functor_comp +functor_id +functorcompose +functorid +functoridlaw +functorlaw +fundamental +fundamental_arith +fundamental_theorem_of_calculus +fundamental_theorem_of_calculus_bartle +fundamental_theorem_of_calculus_interior +fundamental_theorem_of_calculus_interior_strong +fundamental_theorem_of_calculus_strong +fundcmpsurbijinj +fundcmpsurbijinjpreimafv +fundcmpsurinj +fundcmpsurinjalt +fundcmpsurinjimaid +fundcmpsurinjlem1 +fundcmpsurinjlem2 +fundcmpsurinjlem3 +fundcmpsurinjpreimafv +fundif +fundmafv2rnb +fundmdfat +fundmen +fundmeng +fundmfibi +fundmge2nop +fundmge2nop0 +fundmpss +funeldmb +funeldmdif +funelss +funen1cnv +funeq +funeqd +funeqi +funeu +funeu2 +funex +funext +funexw +funfn +funfnd +funfni +funfocofob +funforn +funfv +funfv1st2nd +funfv2 +funfv2f +funfvbrb +funfvima +funfvima2 +funfvima2d +funfvima3 +funfvop +funi +funiedgdm2val +funiedgdmge2val +funiedgval +funimacnv +funimaeq +funimaex +funimaexg +funimage +funimass1 +funimass2 +funimass3 +funimass4 +funimass4f +funimass5 +funimassd +funimassov +funin +funisfsupp +funiun +funiunfv +funiunfvf +funline +funmo +funmpt +funmpt2 +funop +funop1 +funopab +funopab4 +funopabeq +funopafv2b +funopafvb +funopdmsn +funopfv +funopfvb +funopg +funoprab +funoprabg +funopsn +funpartfun +funpartfv +funpartlem +funpartss +funpow_2 +funpow_add +funpow_comm +funpow_cong +funpow_eq_elim +funpow_inj +funpow_invariant +funpow_invariant_index +funpow_k +funpow_min_cancel +funpow_suc +funpr +funprg +funpsstri +funray +funrel +funres +funres11 +funresd +funresdfunsn +funresfunco +funressn +funressnbrafv2 +funressndmafv2rn +funressndmfvrn +funressneu +funressnfv +funressnmo +funressnvmo +funrnex +funset_dfunset +funset_empty +funset_inter +funset_thm +funsn +funsndifnop +funsneqopb +funsnfsupp +funsng +funss +funsseq +funssfv +funssres +funsssuppss +funssxp +funtopon +funtp +funtpg +funtransport +funun +fununfun +fununi +fununiq +fununmo +funvtxdm2val +funvtxdmge2val +funvtxval +funvtxval0 +fusgr1th +fusgr2wsp2nb +fusgredgfi +fusgreg2wsp +fusgreg2wsplem +fusgreghash2wsp +fusgreghash2wspv +fusgrfis +fusgrfisbase +fusgrfisstep +fusgrfupgrfs +fusgrhashclwwlkn +fusgrmaxsize +fusgrn0degnn0 +fusgrn0eqdrusgr +fusgrregdegfi +fusgrusgr +fusgrvtxdgonume +fusgrvtxfi +fusion +futoshiki +fuzxrpmcn +fv0p1e1 +fv1arycl +fv1prop +fv1stcnv +fv2 +fv2arycl +fv2ndcnv +fv2prc +fv2prop +fv3 +fvbigcup +fvbr0 +fvclex +fvclss +fvco +fvco2 +fvco3 +fvco3d +fvco4i +fvcod +fvcoe1 +fvcofneq +fvconst +fvconst0ci +fvconst2 +fvconst2g +fvconstdomi +fvconstr +fvconstr2 +fvconstrn0 +fvcosymgeq +fvdiagfn +fvdifsupp +fveecn +fveere +fveleq +fvelima +fvelima2 +fvelimab +fvelimabd +fvelimad +fvelrn +fvelrnb +fvelrnbf +fvelsetpreimafv +fveq1 +fveq12d +fveq12i +fveq1d +fveq1i +fveq2 +fveq2d +fveq2i +fveqdmss +fveqeq2 +fveqeq2d +fveqf1o +fveqprc +fveqres +fveqressseq +fveqsb +fveqvfvv +fveu +fveval1fvcl +fvex +fvexd +fvexi +fvf1pr +fvf1tp +fvffz0 +fvfundmfvn0 +fvi +fvif +fvifeq +fvilbd +fvilbdrp +fvimacnv +fvimacnvalt +fvimacnvi +fvimage +fvineqsneq +fvineqsneu +fvineqsnf1 +fvinim0ffz +fviss +fviunfun +fvixp +fvixp2 +fvline +fvline2 +fvmap +fvmpocurryd +fvmpopr2d +fvmpt +fvmpt2 +fvmpt2bd +fvmpt2d +fvmpt2df +fvmpt2f +fvmpt2i +fvmpt3 +fvmpt3i +fvmpt4 +fvmpt4d +fvmptd +fvmptd2 +fvmptd2f +fvmptd3 +fvmptd3f +fvmptd4 +fvmptdf +fvmptdv +fvmptdv2 +fvmptelcdm +fvmptelcdmf +fvmptex +fvmptf +fvmptg +fvmpti +fvmptiunrelexplb0d +fvmptiunrelexplb0da +fvmptiunrelexplb1d +fvmptmap +fvmptn +fvmptndm +fvmptnf +fvmptnn04if +fvmptnn04ifa +fvmptnn04ifb +fvmptnn04ifc +fvmptnn04ifd +fvmptopab +fvmptrab +fvmptrabdm +fvmptrabfv +fvmpts +fvmptss +fvmptss2 +fvmptt +fvn0elsupp +fvn0elsuppb +fvn0fvelrn +fvn0ssdmfun +fvnobday +fvnonrel +fvopab3g +fvopab3ig +fvopab4ndm +fvopab5 +fvopab6 +fvopabf4g +fvovco +fvoveq1 +fvoveq1d +fvpr0o +fvpr1 +fvpr1g +fvpr1o +fvpr2 +fvpr2g +fvprc +fvprcalt +fvprif +fvprmselelfz +fvprmselgcd1 +fvproj +fvray +fvrcllb0d +fvrcllb0da +fvrcllb1d +fvres +fvresd +fvreseq +fvreseq0 +fvreseq1 +fvresex +fvresi +fvressn +fvresval +fvrn0 +fvrnressn +fvrtrcllb0d +fvrtrcllb0da +fvrtrcllb1d +fvsb +fvsetsid +fvsingle +fvsn +fvsng +fvsnun1 +fvsnun2 +fvssunirn +fvtp1 +fvtp1g +fvtp2 +fvtp2g +fvtp3 +fvtp3g +fvtransport +fvtrcllb1d +fvtresfn +fvun +fvun1 +fvun1d +fvun2 +fvun2d +fvunsn +fvvolicof +fvvolioof +fwddifn0 +fwddifnp1 +fwddifnval +fwddifval +fx +fxpgaeq +fxpgaval +fxpsdrg +fxpss +fxpsubg +fxpsubm +fxpsubrg +fxpval +fz0 +fz01en +fz01pr +fz0add1fz1 +fz0addcom +fz0addge0 +fz0dif1 +fz0fzdiffz0 +fz0fzelfz0 +fz0n +fz0sn +fz0sn0fz1 +fz0ssnn0 +fz0to3un2pr +fz0to4untppr +fz0to5un2tp +fz0tp +fz10 +fz12pr +fz1eqb +fz1eqin +fz1f1o +fz1fzo0m1 +fz1iso +fz1isolem +fz1n +fz1nnct +fz1nntr +fz1sbc +fz1ssfz0 +fz1ssnn +fz1sumconst +fz1sump1 +fz2ssnn0 +fzadd2 +fzadd2d +fzaddel +fzass4 +fzct +fzctr +fzdif1 +fzdif2 +fzdifsuc +fzdifsuc2 +fzdisj +fzelp1 +fzen +fzen2 +fzennn +fzf +fzfi +fzfid +fzind +fzind2 +fzindd +fzisfzounsn +fzisoeu +fzm1 +fzm1ndvds +fzm1ne1 +fzmaxdif +fzmmmeqm +fzmul +fzn +fzn0 +fznatpl1 +fzne1 +fzne2d +fzneg +fzneuz +fznn +fznn0 +fznn0sub +fznn0sub2 +fznnfl +fznuz +fzo0 +fzo01 +fzo0addel +fzo0addelr +fzo0dvdseq +fzo0end +fzo0n +fzo0n0 +fzo0opth +fzo0pmtrlast +fzo0sn0fzo1 +fzo0ss1 +fzo0ssnn0 +fzo0to2pr +fzo0to3tp +fzo0to42pr +fzo12sn +fzo13pr +fzo1fzo0n0 +fzo1lb +fzo1to4tp +fzoaddel +fzoaddel2 +fzocatel +fzocongeq +fzoct +fzodif1 +fzodif2 +fzodisj +fzodisjsn +fzoend +fzof +fzofi +fzofzim +fzofzp1 +fzofzp1b +fzolb +fzolb2 +fzom1ne1 +fzomaxdif +fzomaxdiflem +fzon +fzon0 +fzone1 +fzonel +fzonfzoufzol +fzonlt0 +fzonmapblen +fzonn0p1 +fzonn0p1p1 +fzonnsub +fzonnsub2 +fzoopth +fzopred +fzopredsuc +fzopth +fzoshftral +fzosn +fzosplit +fzospliti +fzosplitpr +fzosplitprm1 +fzosplitsn +fzosplitsni +fzosplitsnm1 +fzoss1 +fzoss2 +fzossfz +fzossfzop1 +fzossnn +fzossnn0 +fzossrbm1 +fzossuz +fzossz +fzostep1 +fzosubel +fzosubel2 +fzosubel3 +fzosumm1 +fzosump1 +fzoun +fzouzdisj +fzouzsplit +fzoval +fzp1disj +fzp1elp1 +fzp1nel +fzp1ss +fzpr +fzpred +fzpreddisj +fzprval +fzrev +fzrev2 +fzrev2i +fzrev3 +fzrev3i +fzrevral +fzrevral2 +fzrevral3 +fzsdom2 +fzshftral +fzsn +fzspl +fzsplit +fzsplit1nn0 +fzsplit2 +fzsplit3 +fzsplitnd +fzsplitnr +fzss1 +fzss2 +fzsscn +fzssfzo +fzssnn +fzssnn0 +fzssp1 +fzssre +fzssuz +fzssz +fzsubel +fzsuc +fzsuc2 +fzto1st +fzto1st1 +fzto1stfv1 +fzto1stinvn +fztp +fztpval +fzunt +fzunt1d +fzuntd +fzuntgd +fzval +fzval2 +fzval3 +g +g0wlk0 +g_convergence +g_increasing +g_prop +ga0 +gaass +gacan +gaf +gafo +gagrp +gagrpid +gaid +gaid2 +galactghm +galcan +gale_stewart +gam1 +gamcl +gamcvg +gamcvg2 +gamcvg2lem +game_det +gamf +gamfac +gamigam +gamne0 +gamp1 +gaorb +gaorber +gapm +gaset +gass +gastacl +gastacos +gasubg +gateaux_derivative +gateaux_derivative_lipschitz +gateaux_derivative_within +gauge_ball +gauge_ball_dependent +gauge_existence_lemma +gauge_inter +gauge_inters +gauge_modify +gauge_trivial +gausslemma2d +gausslemma2dlem0a +gausslemma2dlem0b +gausslemma2dlem0c +gausslemma2dlem0d +gausslemma2dlem0e +gausslemma2dlem0f +gausslemma2dlem0g +gausslemma2dlem0h +gausslemma2dlem0i +gausslemma2dlem1 +gausslemma2dlem1a +gausslemma2dlem2 +gausslemma2dlem3 +gausslemma2dlem4 +gausslemma2dlem5 +gausslemma2dlem5a +gausslemma2dlem6 +gausslemma2dlem7 +gbeeven +gbege6 +gbegt5 +gbepos +gblacfnacd +gbogbow +gboge9 +gboodd +gbopos +gbowge7 +gbowgt5 +gbowodd +gbowpos +gbpart11 +gbpart6 +gbpart7 +gbpart8 +gbpart9 +gcd +gcd0id +gcd0val +gcd1 +gcd2n0cl +gcd2odd1 +gcd32 +gcd_0 +gcd_0_neg +gcd_0_pos +gcd_abs +gcd_assoc +gcd_comm +gcd_correct +gcd_def +gcd_divides +gcd_even_even +gcd_even_odd +gcd_even_odd2 +gcd_extraction +gcd_factors +gcd_factors_nat +gcd_is_max +gcd_lt +gcd_lt_nat +gcd_minus +gcd_mod +gcd_mod_div +gcd_odd_odd2 +gcd_refl +gcd_same +gcd_self +gcd_sym +gcd_termination +gcd_times +gcd_zero +gcd_zero_right +gcdabs +gcdabs1 +gcdabs2 +gcdabsorb +gcdadd +gcdaddm +gcdaddmlem +gcdaddmzz2nncomi +gcdaddmzz2nni +gcdass +gcdcl +gcdcld +gcdcllem1 +gcdcllem2 +gcdcllem3 +gcdcom +gcdcomd +gcdcomnni +gcddiv +gcddivides +gcddvds +gcddvdslcm +gcdeq +gcdeq0 +gcdf +gcdi +gcdid +gcdid0 +gcdle1d +gcdle2d +gcdmodi +gcdmultiple +gcdmultipled +gcdmultiplei +gcdmultiplez +gcdn0cl +gcdn0gt0 +gcdn0val +gcdneg +gcdnegnni +gcdnn0id +gcdnncl +gcdnncli +gcdval +gcdzeq +gch-kn +gch2 +gch3 +gchac +gchacg +gchaclem +gchaleph +gchaleph2 +gchdju1 +gchdjuidm +gchdomtri +gchen1 +gchen2 +gchhar +gchi +gchina +gchinf +gchor +gchpwdom +gchxpidm +gdelta_baire +gdelta_baire1_preimage_closed +gdelta_baire_preimage_closed +gdelta_baire_preimage_closed_gen +gdelta_complement +gdelta_continuous_function_minima +gdelta_descending +gdelta_diff +gdelta_domain_of_injectivity_continuous +gdelta_domain_of_injectivity_measurable +gdelta_empty +gdelta_fsigma_gen +gdelta_imp_analytic +gdelta_imp_borel +gdelta_imp_lebesgue_measurable +gdelta_in_descending +gdelta_in_euclidean +gdelta_in_inter +gdelta_in_inters +gdelta_in_union +gdelta_inter +gdelta_inters +gdelta_inters_clopen_chain +gdelta_linear_image +gdelta_locally_compact +gdelta_locally_eq +gdelta_locally_gen +gdelta_locally_trans +gdelta_pcross +gdelta_pcross_eq +gdelta_points_of_continuity +gdelta_points_of_continuity_within +gdelta_points_of_convergence_at +gdelta_points_of_convergence_within +gdelta_preimage_card_le +gdelta_separation +gdelta_separation_gen +gdelta_sing +gdelta_translation +gdelta_union +gdelta_unions +gdelta_univ +ge +ge0addcl +ge0div +ge0divd +ge0gtmnf +ge0lere +ge0mulcl +ge0nemnf +ge0p1rp +ge0p1rpd +ge0xaddcl +ge0xmulcl +ge0xrre +ge2halflem1 +ge2nprmge4 +ge_abs +ge_refl +ge_trans +gen +gen11 +gen11nv +gen12 +gen2 +gen21 +gen21nv +gen22 +gen31 +gen_all +gen_alpha_conv +gen_beta_conv +gen_geom_origin_tac +gen_rewr_tac +gen_rewrite_rule +gen_rewrite_tac +gen_seq1_is_walk +gen_simplify_conv +gen_tac +gencbval +gencbvex +gencbvex2 +gencl +general_reduction_theorem +generalize +generatelength +generic_example +genlist_0 +genlist_1 +genlist_append +genlist_cons +genlist_constant +genlist_el +genlist_el_map +genlist_eq_nil +genlist_fun_eq +genlist_genlist_aux +genlist_id +genlist_last +genlist_plus_append +genpass +genpcd +genpcl +genpdm +genpelv +genpn0 +genpnmax +genpnnp +genpprecl +genpss +genpv +geo2lim +geo2sum +geo2sum2 +geoihalfsum +geoisum +geoisum1 +geoisum1c +geoisumr +geolim +geolim2 +geolim3 +geom_basis_multiple_tac +geom_equal_dimension_rule +geom_normalize_tac +geom_origin_conv +geom_origin_tac +geom_transform_tac +geom_translate_tac +geomcau +geometric_series +geomulcvg +georeclim +geoser +geoserg +gex1 +gex2abl +gexcl +gexcl2 +gexcl3 +gexdvds +gexdvds2 +gexdvds3 +gexdvdsi +gexex +gexexlem +gexid +gexlem1 +gexlem2 +gexnnod +gexod +gexval +ggen22 +ggen31 +ghmabl +ghmcmn +ghmcnp +ghmco +ghmcyg +ghmeqker +ghmeql +ghmf +ghmf1 +ghmf1o +ghmfghm +ghmghmrn +ghmgrp +ghmgrp1 +ghmgrp2 +ghmid +ghmima +ghminv +ghmker +ghmlin +ghmmhm +ghmmhmb +ghmmulg +ghmnsgima +ghmnsgpreima +ghmplusg +ghmpreima +ghmpropd +ghmqusker +ghmquskerco +ghmquskerlem1 +ghmquskerlem2 +ghmquskerlem3 +ghmqusnsg +ghmqusnsglem1 +ghmqusnsglem2 +ghmrn +ghmsub +ghomco +ghomdiv +ghomf +ghomidold +ghomlinold +ghost_spec +ghostcounter +ghostsequence +gicabl +giccyg +gicen +gicer +giclcl +gicqusker +gicrcl +gicref +gicsubgen +gicsym +gictr +gidsn +gidval +gim0to0 +gimcnv +gimco +gimf1o +gimfn +gimghm +glb0n +glbcl +glbconn +glbconxn +glbdm +glbeldm +glbeldm2 +glbeldm2d +glbelss +glbeu +glbfun +glbfval +glble +glbpr +glbprdm +glbprlem +glbprop +glbsscl +glbval +glivenko +gm-sbtru +gneispa +gneispace +gneispace0nelrn +gneispace0nelrn2 +gneispace0nelrn3 +gneispace2 +gneispace3 +gneispaceel +gneispaceel2 +gneispacef +gneispacef2 +gneispacefun +gneispacern +gneispacern2 +gneispacess +gneispacess2 +gneispb +goal +goaleq12d +goaln0 +goalr +goalrlem +goals +godel_neg +godel_negative +goel +goelel3xp +goeleq12bg +goeqi +goldbachth +goldbachthlem1 +goldbachthlem2 +golem1 +golem2 +golomb_ruler +gonafv +gonan0 +gonanegoal +gonar +gonarlem +gpg3kgrtriex +gpg3kgrtriexlem1 +gpg3kgrtriexlem2 +gpg3kgrtriexlem3 +gpg3kgrtriexlem4 +gpg3kgrtriexlem5 +gpg3kgrtriexlem6 +gpg3nbgrvtx0 +gpg3nbgrvtx0alt +gpg3nbgrvtx1 +gpg5edgnedg +gpg5gricstgr3 +gpg5grlic +gpg5grlim +gpg5nbgr3star +gpg5nbgrvtx03star +gpg5nbgrvtx03starlem1 +gpg5nbgrvtx03starlem2 +gpg5nbgrvtx03starlem3 +gpg5nbgrvtx13starlem1 +gpg5nbgrvtx13starlem2 +gpg5nbgrvtx13starlem3 +gpg5ngric +gpg5order +gpgcubic +gpgedg +gpgedg2iv +gpgedg2ov +gpgedgel +gpgedgiov +gpgedgvtx0 +gpgedgvtx1 +gpgedgvtx1lem +gpgiedg +gpgiedgdmel +gpgiedgdmellem +gpgnbgrvtx0 +gpgnbgrvtx1 +gpgorder +gpgov +gpgprismgr4cycl0 +gpgprismgr4cyclex +gpgprismgr4cycllem1 +gpgprismgr4cycllem10 +gpgprismgr4cycllem11 +gpgprismgr4cycllem2 +gpgprismgr4cycllem3 +gpgprismgr4cycllem4 +gpgprismgr4cycllem5 +gpgprismgr4cycllem6 +gpgprismgr4cycllem7 +gpgprismgr4cycllem8 +gpgprismgr4cycllem9 +gpgprismgriedgdmel +gpgprismgriedgdmss +gpgprismgrusgra +gpgusgra +gpgusgralem +gpgvtx +gpgvtx0 +gpgvtx1 +gpgvtxdg3 +gpgvtxedg0 +gpgvtxedg1 +gpgvtxel +gpgvtxel2 +gradient_descent_converge +gram_schmidt_lemma +gram_schmidt_step +grammar +grammar-rule +graop +graph_coloring +graph_embeds_in_r3 +graph_path_compose +grassmann_plucker_2 +grassmann_plucker_3 +grassmann_plucker_4 +grastruct +greater_eq +greatest_fib_spec +greenhouse_climate +grewrite_lemma +gricbri +gricen +gricer +gricgrlic +gricrcl +gricref +gricrel +gricsym +gricsymb +grictr +gricushgr +gricuspgr +griedg0prc +griedg0ssusgr +grilcbri +grilcbri2 +grimcnv +grimco +grimdmrel +grimedg +grimedgi +grimf1o +grimfn +grimgrtri +grimid +grimidvtxedg +grimprop +grimuhgr +grind +grlicen +grlicer +grlicrcl +grlicref +grlicrel +grlicsym +grlicsymb +grlictr +grlimdmrel +grlimedgclnbgr +grlimedgnedg +grlimf1o +grlimfn +grlimgredgex +grlimgrtri +grlimgrtrilem1 +grlimgrtrilem2 +grlimprclnbgr +grlimprclnbgredg +grlimprclnbgrvtx +grlimpredg +grlimprop +grlimprop2 +gropd +gropeld +grothac +grothomex +grothprim +grothprimlem +grothpw +grothpwex +grothtsk +group_def_equiv +group_id_unique +group_identity_unique +group_inv_inv +group_inv_prod +group_inv_unique +group_inverse_unique +group_left_identity +groupbyview +grouporder +grows +grp1 +grp1inv +grpaddsubass +grpass +grpasscan1 +grpasscan2 +grpasscan2d +grpassd +grpbase +grpbasex +grpbn0 +grpcl +grpcld +grpcominv1 +grpcominv2 +grpid +grpidcl +grpidd +grpidd2 +grpideu +grpidinv +grpidinv2 +grpidlcan +grpidpropd +grpidrcan +grpidssd +grpidval +grpinv11 +grpinv11old +grpinva +grpinvadd +grpinvalem +grpinvcl +grpinvcld +grpinvcnv +grpinveu +grpinvex +grpinvf +grpinvf1o +grpinvfn +grpinvfval +grpinvfvalalt +grpinvfvi +grpinvhmeo +grpinvid +grpinvid1 +grpinvid2 +grpinvinv +grpinvinvd +grpinvnz +grpinvnzcl +grpinvpropd +grpinvssd +grpinvsub +grpinvval +grpinvval2 +grpissubg +grplactcnv +grplactf1o +grplactfval +grplactval +grplcan +grplid +grplidd +grplinv +grplinvd +grplmulf1o +grplrinv +grplsm0l +grplsmid +grpmgmd +grpmnd +grpmndd +grpn0 +grpnnncan2 +grpnpcan +grpnpncan +grpnpncan0 +grpo2inv +grpoass +grpocl +grpodivcl +grpodivdiv +grpodivf +grpodivfval +grpodivid +grpodivinv +grpodivval +grpods +grpoeqdivid +grpofo +grpoid +grpoidcl +grpoideu +grpoidinv +grpoidinv2 +grpoidinvlem1 +grpoidinvlem2 +grpoidinvlem3 +grpoidinvlem4 +grpoidval +grpoinv +grpoinvcl +grpoinvdiv +grpoinveu +grpoinvf +grpoinvfval +grpoinvid1 +grpoinvid2 +grpoinvop +grpoinvval +grpokerinj +grpolcan +grpolid +grpolidinv +grpolinv +grpomndo +grpomuldivass +grpon0 +grponpcan +grporcan +grporid +grporinv +grporn +grporndm +grposnold +grpplusf +grpplusfo +grpplusg +grpplusgx +grppncan +grppnpcan2 +grpprop +grppropd +grppropstr +grpraddf1o +grprcan +grprid +grprida +grpridd +grprinv +grprinvd +grpsgrp +grpss +grpstr +grpsubadd +grpsubadd0sub +grpsubcl +grpsubcld +grpsubeq0 +grpsubf +grpsubfval +grpsubfvalalt +grpsubid +grpsubid1 +grpsubinv +grpsubpropd +grpsubpropd2 +grpsubrcan +grpsubsub +grpsubsub4 +grpsubval +grptcepi +grptcmon +grpvlinv +grpvrinv +grstructd +grstructeld +grtri +grtriclwlk3 +grtrif1o +grtrimap +grtriprop +grtriproplem +grtrissvtx +gru0eld +grucollcld +grudomon +gruel +gruelss +gruen +gruex +gruf +gruiin +gruima +gruina +gruiun +gruixp +grumap +grumnud +grumnudlem +grumnueq +gruop +grupr +grupw +grur1 +grur1a +grur1cld +grurankcld +grurankrcld +grurn +gruscottcld +grusn +gruss +grusucd +grutr +grutsk +grutsk1 +gruun +gruuni +gruurn +gruwun +gruxp +gsmsymgreq +gsmsymgreqlem1 +gsmsymgreqlem2 +gsmsymgrfix +gsmsymgrfixlem1 +gsmtrcl +gspec_and +gspec_eq +gspec_eq2 +gspec_eta +gspec_f +gspec_f_cond +gspec_id +gspec_image +gspec_or +gspec_pair_eta +gspec_t +gst_witness +gsum0 +gsum2d +gsum2d2 +gsum2d2lem +gsum2dlem1 +gsum2dlem2 +gsumadd +gsumbagdiag +gsumbagdiaglem +gsumccat +gsumccatsn +gsumccatsymgsn +gsumcl +gsumcl2 +gsumcllem +gsumcom +gsumcom2 +gsumcom3 +gsumcom3fi +gsumconst +gsumconstf +gsumdifsnd +gsumdifsndf +gsumdixp +gsumesum +gsumf1o +gsumfs2d +gsumfsum +gsumfsupp +gsumge0cl +gsumhashmul +gsumind +gsuminv +gsumle +gsumlsscl +gsummatr01 +gsummatr01lem1 +gsummatr01lem2 +gsummatr01lem3 +gsummatr01lem4 +gsummgmpropd +gsummgp0 +gsummhm +gsummhm2 +gsummoncoe1 +gsummoncoe1fz +gsummoncoe1fzo +gsummpt1n0 +gsummpt2co +gsummpt2d +gsummptcl +gsummptf1o +gsummptf1od +gsummptfidmadd +gsummptfidmadd2 +gsummptfidminv +gsummptfidmsplit +gsummptfidmsplitres +gsummptfidmsub +gsummptfif1o +gsummptfsadd +gsummptfsf1o +gsummptfsres +gsummptfssub +gsummptfzcl +gsummptfzsplit +gsummptfzsplitl +gsummptfzsplitla +gsummptfzsplitra +gsummptif1n0 +gsummptmhm +gsummptnn0fz +gsummptnn0fzfv +gsummptp1 +gsummptres +gsummptres2 +gsummptrev +gsummptshft +gsummptun +gsummulc1 +gsummulc1old +gsummulc2 +gsummulc2old +gsummulg +gsummulgc2 +gsummulglem +gsummulgz +gsummulsubdishift1 +gsummulsubdishift1s +gsummulsubdishift2 +gsummulsubdishift2s +gsumncl +gsumnunsn +gsumpart +gsumply1eq +gsumply1subr +gsumpr +gsumpr12val +gsumpropd +gsumpropd2 +gsumpropd2lem +gsumprval +gsumpt +gsumreidx +gsumres +gsumress +gsumsgrpccat +gsumsmonply1 +gsumsn +gsumsnd +gsumsnf +gsumsnfd +gsumspl +gsumsplit +gsumsplit1r +gsumsplit2 +gsumsplit2f +gsumsra +gsumsub +gsumsubg +gsumsubgcl +gsumsubm +gsumsubmcl +gsumtp +gsumunsn +gsumunsnd +gsumunsnf +gsumunsnfd +gsumval +gsumval1 +gsumval2 +gsumval2a +gsumval3 +gsumval3a +gsumval3eu +gsumval3lem1 +gsumval3lem2 +gsumvallem2 +gsumvalx +gsumvsca1 +gsumvsca2 +gsumvsmul +gsumvsmul1 +gsumwcl +gsumwmhm +gsumwrd2dccat +gsumwrd2dccatlem +gsumwrev +gsumws1 +gsumws2 +gsumws3 +gsumws4 +gsumwspan +gsumwsubmcl +gsumwun +gsumxp +gsumxp2 +gsumz +gsumzadd +gsumzaddlem +gsumzcl +gsumzcl2 +gsumzf1o +gsumzinv +gsumzmhm +gsumzoppg +gsumzres +gsumzresunsn +gsumzrsum +gsumzsplit +gsumzsubmcl +gsumzunsnd +gsym +gt +gt-lt +gt-lth +gt0div +gt0divd +gt0ne0 +gt0ne0d +gt0ne0i +gt0ne0ii +gt0ne0s +gt0ne0sd +gt0srpr +gt_abs +gte-lte +gte-lteh +gtinf +gtiso +gtndiv +gtned +gtneii +gtnelicc +gtnelioc +gtso +guard +gzabssqcl +gzaddcl +gzcjcl +gzcn +gzcrng +gzmulcl +gznegcl +gzreim +gzrngunit +gzrngunitlem +gzsubcl +gzsubrg +h +h0elch +h0elsh +h1 +h15nh16th15ih16 +h1da +h1datom +h1datomi +h1de2bi +h1de2ci +h1de2ctlem +h1de2i +h1dei +h1deoi +h1did +h1dn0 +h2hcau +h2hlm +h2hmetdval +h2hnm +h2hsm +h2hva +h2hvs +h3 +h_a +h_ab +h_ac +h_and_imp +h_b +h_bc +h_c +h_curry +h_eq +h_false +h_fx +h_imp +h_in +h_in_t +h_l +h_m +h_nm +h_not_a +h_not_and +h_not_b +h_not_not_a +h_not_not_b +h_not_or +h_r +habs +had0 +had1 +hadamard_inequality_column +hadamard_inequality_psd +hadamard_inequality_row +hadass +hadbi +hadbi123d +hadbi123i +hadcoma +hadcomb +hadifp +hadnot +hadrot +half0 +half_cancel +half_lt_1 +half_measures +half_pos +halfaddsub +halfaddsubcl +halfcl +halfcld +halfcn +halfcut +halffl +halfge0 +halfgt0 +halfleoddlt +halflt1 +halfnneg2 +halfnq +halfnz +halfpire +halfpm6th +halfpos +halfpos2 +halfre +halfspace_eq_empty_ge +halfspace_eq_empty_gt +halfspace_eq_empty_le +halfspace_eq_empty_lt +halfthird +halting_undecidable +handshake_complete +happ +har2o +harcard +harcl +harf +hargch +harinf +harmonic +harmonic_diverges +harmonicbnd +harmonicbnd2 +harmonicbnd3 +harmonicbnd4 +harmoniclbnd +harmonicubnd +harn0 +harndom +harsdom +harsucnn +hartogs +hartogslem1 +hartogslem2 +harval +harval2 +harval3 +harval3on +harvest_planning +harwdom +harword +has_absolute_integral +has_absolute_integral_change_of_variables +has_absolute_integral_change_of_variables_1 +has_absolute_integral_change_of_variables_linear +has_antiderivative_limit +has_antiderivative_sequence +has_bounded_set_variation +has_bounded_setvariation_comparison +has_bounded_setvariation_on +has_bounded_setvariation_on_0 +has_bounded_setvariation_on_add +has_bounded_setvariation_on_cmul +has_bounded_setvariation_on_componentwise +has_bounded_setvariation_on_compose_linear +has_bounded_setvariation_on_division +has_bounded_setvariation_on_elementary +has_bounded_setvariation_on_eq +has_bounded_setvariation_on_interval +has_bounded_setvariation_on_lift_abs +has_bounded_setvariation_on_mul +has_bounded_setvariation_on_neg +has_bounded_setvariation_on_norm +has_bounded_setvariation_on_null +has_bounded_setvariation_on_pastecart +has_bounded_setvariation_on_sub +has_bounded_setvariation_on_subset +has_bounded_setvariation_on_univ +has_bounded_setvariation_translation +has_bounded_setvariation_works +has_bounded_setvariation_works_on_elementary +has_bounded_setvariation_works_on_interval +has_bounded_variation_affinity_eq +has_bounded_variation_comparison +has_bounded_variation_compose_decreasing +has_bounded_variation_compose_homeomorphism +has_bounded_variation_compose_increasing +has_bounded_variation_compose_injective +has_bounded_variation_countable_discontinuities +has_bounded_variation_darboux +has_bounded_variation_darboux_gen +has_bounded_variation_darboux_strict +has_bounded_variation_darboux_strong +has_bounded_variation_imp_baire1 +has_bounded_variation_integrable_norm_derivative +has_bounded_variation_isometric +has_bounded_variation_isometric_compose +has_bounded_variation_left_limit_gen +has_bounded_variation_lipschitz_compose +has_bounded_variation_nontrivial +has_bounded_variation_on_add +has_bounded_variation_on_bilinear +has_bounded_variation_on_closure +has_bounded_variation_on_closure_eq +has_bounded_variation_on_cmul +has_bounded_variation_on_cmul_eq +has_bounded_variation_on_combine +has_bounded_variation_on_combine_gen +has_bounded_variation_on_componentwise +has_bounded_variation_on_compose_linear +has_bounded_variation_on_const +has_bounded_variation_on_darboux_imp_continuous +has_bounded_variation_on_division +has_bounded_variation_on_empty +has_bounded_variation_on_eq +has_bounded_variation_on_id +has_bounded_variation_on_imp_bounded +has_bounded_variation_on_imp_bounded_on_interval +has_bounded_variation_on_indefinite_integral_left +has_bounded_variation_on_indefinite_integral_right +has_bounded_variation_on_interior +has_bounded_variation_on_interior_eq +has_bounded_variation_on_interval +has_bounded_variation_on_lift_abs +has_bounded_variation_on_linear_image +has_bounded_variation_on_max +has_bounded_variation_on_min +has_bounded_variation_on_mul +has_bounded_variation_on_neg +has_bounded_variation_on_norm +has_bounded_variation_on_null +has_bounded_variation_on_pastecart +has_bounded_variation_on_reflect +has_bounded_variation_on_reflect_interval +has_bounded_variation_on_sing +has_bounded_variation_on_split +has_bounded_variation_on_sub +has_bounded_variation_on_subset +has_bounded_variation_on_translation +has_bounded_variation_on_union +has_bounded_variation_on_vmul +has_bounded_variation_on_vmul_eq +has_bounded_variation_right_limit_gen +has_bounded_variation_translation +has_bounded_variation_works +has_bounded_variation_works_on_elementary +has_bounded_variation_works_on_interval +has_bounded_vector_derivative_imp_lipschitz +has_bounded_vector_variation +has_bounded_vector_variation_left_limit +has_bounded_vector_variation_on_interval +has_bounded_vector_variation_on_interval_gen +has_bounded_vector_variation_on_subintervals +has_bounded_vector_variation_right_limit +has_bounded_vector_variation_uniform_lim +has_derivative_add +has_derivative_at +has_derivative_at_alt +has_derivative_at_reflect +has_derivative_at_within +has_derivative_bilinear_at +has_derivative_bilinear_within +has_derivative_cmul +has_derivative_cmul_eq +has_derivative_componentwise_at +has_derivative_componentwise_within +has_derivative_const +has_derivative_id +has_derivative_imp_differentiable +has_derivative_inverse +has_derivative_inverse_basic +has_derivative_inverse_basic_x +has_derivative_inverse_dieudonne +has_derivative_inverse_on +has_derivative_inverse_strong +has_derivative_inverse_strong_x +has_derivative_inverse_within +has_derivative_lift_component +has_derivative_lift_dot +has_derivative_linear +has_derivative_locally_injective +has_derivative_mul_at +has_derivative_mul_within +has_derivative_neg +has_derivative_neg_eq +has_derivative_pastecart +has_derivative_pastecart_eq +has_derivative_sequence +has_derivative_sequence_lipschitz +has_derivative_series +has_derivative_sqnorm_at +has_derivative_sub +has_derivative_transform_at +has_derivative_transform_within +has_derivative_transform_within_open +has_derivative_vmul_component +has_derivative_vmul_drop +has_derivative_vsum +has_derivative_vsum_numseg +has_derivative_within +has_derivative_within_alt +has_derivative_within_open +has_derivative_within_open_in +has_derivative_within_reflect +has_derivative_within_subset +has_derivative_zero_connected_constant +has_derivative_zero_connected_unique +has_derivative_zero_constant +has_derivative_zero_unique +has_derivative_zero_unique_strong_connected +has_derivative_zero_unique_strong_convex +has_derivative_zero_unique_strong_interval +has_double_integral_convolution +has_double_integral_pcross +has_frechet_derivative_unique_at +has_integral +has_integral_0 +has_integral_0_eq +has_integral_add +has_integral_affinity +has_integral_alt +has_integral_bound +has_integral_closure +has_integral_cmul +has_integral_combine +has_integral_combine_division +has_integral_combine_division_topdown +has_integral_combine_tagged_division +has_integral_combine_tagged_division_topdown +has_integral_component_lbound +has_integral_component_le +has_integral_component_le_ae +has_integral_component_neg +has_integral_component_pos +has_integral_component_ubound +has_integral_componentwise +has_integral_const +has_integral_const_gen +has_integral_convolution_sym +has_integral_diff +has_integral_drop_le +has_integral_drop_le_ae +has_integral_drop_neg +has_integral_drop_pos +has_integral_drop_pos_ae +has_integral_empty +has_integral_empty_eq +has_integral_eq +has_integral_eq_eq +has_integral_factor_content +has_integral_integrable +has_integral_integrable_integral +has_integral_integral +has_integral_interior +has_integral_is_0 +has_integral_lim_at_posinfinity +has_integral_lim_at_posinfinity_gen +has_integral_lim_sequentially +has_integral_linear +has_integral_measure_under_curve +has_integral_neg +has_integral_negligible +has_integral_negligible_eq +has_integral_negligible_eq_ae +has_integral_norm_bound_integral_component +has_integral_null +has_integral_null_eq +has_integral_on_negligible +has_integral_on_superset +has_integral_open_interval +has_integral_pastecart_sym +has_integral_pastecart_sym_alt +has_integral_refl +has_integral_reflect +has_integral_reflect_gen +has_integral_reflect_lemma +has_integral_restrict +has_integral_restrict_closed_subinterval +has_integral_restrict_closed_subintervals_eq +has_integral_restrict_inter +has_integral_restrict_open_subinterval +has_integral_restrict_univ +has_integral_separate_sides +has_integral_spike +has_integral_spike_eq +has_integral_spike_finite +has_integral_spike_finite_eq +has_integral_spike_interior +has_integral_spike_interior_eq +has_integral_spike_set +has_integral_spike_set_eq +has_integral_split +has_integral_straddle_null +has_integral_stretch +has_integral_sub +has_integral_subset_component_le +has_integral_subset_drop_le +has_integral_substitution_strong +has_integral_translation +has_integral_twiddle +has_integral_twiddle_gen +has_integral_twizzle +has_integral_twizzle_eq +has_integral_twizzle_interval +has_integral_union +has_integral_unions +has_integral_unions_image +has_integral_unique +has_integral_vsum +has_measure +has_measure_0 +has_measure_affinity +has_measure_almost +has_measure_almost_eq +has_measure_countable_negligible_unions +has_measure_countable_negligible_unions_bounded +has_measure_diff_negligible +has_measure_diff_negligible_eq +has_measure_diff_subset +has_measure_differentiable_image +has_measure_disjoint_union +has_measure_disjoint_unions +has_measure_disjoint_unions_image +has_measure_disjoint_unions_image_strong +has_measure_elementary +has_measure_empty +has_measure_image_std_simplex +has_measure_imp_measurable +has_measure_inner_outer +has_measure_inner_outer_le +has_measure_interval +has_measure_isometry +has_measure_limit +has_measure_linear_image +has_measure_linear_image_alt +has_measure_linear_image_same +has_measure_linear_sufficient +has_measure_measurable_measure +has_measure_measure +has_measure_negligible_symdiff +has_measure_negligible_union +has_measure_negligible_unions +has_measure_negligible_unions_image +has_measure_negligible_unions_image_strong +has_measure_nested_inters +has_measure_nested_unions +has_measure_orthogonal_image +has_measure_orthogonal_image_eq +has_measure_pcross +has_measure_pos_le +has_measure_scaling +has_measure_scaling_eq +has_measure_shear_interval +has_measure_simplex +has_measure_simplex_0 +has_measure_std_simplex +has_measure_stretch +has_measure_subset +has_measure_tetrahedron +has_measure_translation +has_measure_translation_eq +has_measure_triangle +has_measure_union_negligible +has_measure_union_negligible_eq +has_measure_unique +has_positive_cycle_star +has_size +has_size_0 +has_size_card +has_size_clauses +has_size_conv +has_size_faces_of_simplex +has_size_image_inj +has_size_index +has_size_product +has_size_product_dependent +has_size_sphere_1 +has_size_stdbasis +has_size_suc +has_size_union +has_vector_derivative_add +has_vector_derivative_at_1d +has_vector_derivative_at_within +has_vector_derivative_bilinear_at +has_vector_derivative_bilinear_within +has_vector_derivative_cmul +has_vector_derivative_cmul_eq +has_vector_derivative_componentwise_at +has_vector_derivative_componentwise_within +has_vector_derivative_const +has_vector_derivative_id +has_vector_derivative_imp_differentiable +has_vector_derivative_indefinite_integral +has_vector_derivative_lift_component_at +has_vector_derivative_lift_component_within +has_vector_derivative_neg +has_vector_derivative_neg_eq +has_vector_derivative_sub +has_vector_derivative_transform_at +has_vector_derivative_transform_within +has_vector_derivative_transform_within_open +has_vector_derivative_within_1d +has_vector_derivative_within_subset +hash0 +hash1 +hash1elsn +hash1n0 +hash1snb +hash1to3 +hash2 +hash2exprb +hash2iun +hash2iun1dif1 +hash2pr +hash2prb +hash2prd +hash2prde +hash2pwpr +hash2sspr +hash3 +hash3tpb +hash3tpde +hash3tpexb +hash3tr +hash4 +hash7g +hash_collision_resistance +hash_deterministic +hashbc +hashbc0 +hashbc2 +hashbccl +hashbclem +hashbcss +hashbcval +hashbnd +hashcard +hashcl +hashclb +hashclwwlkn0 +hashdif +hashdifpr +hashdifsn +hashdifsnp1 +hashdmpropge2 +hashdom +hashdomi +hashdvds +hashecclwwlkn1 +hashelne0d +hashen +hashen1 +hasheni +hasheq0 +hasheqf1o +hasheqf1od +hasheqf1oi +hasheuni +hashf +hashf1 +hashf1dmcdm +hashf1dmrn +hashf1lem1 +hashf1lem2 +hashf1rn +hashf2 +hashfac +hashfacen +hashfingrpnn +hashfinmndnn +hashfn +hashfun +hashfundm +hashfxnn0 +hashfz +hashfz0 +hashfz1 +hashfzo +hashfzo0 +hashfzp1 +hashgadd +hashgcdeq +hashgcdlem +hashge0 +hashge1 +hashge2el2dif +hashge2el2difb +hashge2el2difr +hashge3el3dif +hashgf1o +hashginv +hashgt0 +hashgt0elex +hashgt0elexb +hashgt0n0 +hashgt1 +hashgt12el +hashgt12el2 +hashgt23el +hashgval +hashgval2 +hashimaf1 +hashimarn +hashimarni +hashin +hashinf +hashinfxadd +hashiun +hashkf +hashle00 +hashle2pr +hashle2prv +hashmap +hashnbusgrnn0 +hashnbusgrvd +hashne0 +hashnemnf +hashneq0 +hashnexinj +hashnexinjle +hashnfinnn0 +hashnn0n0nn +hashnn0pnf +hashnncl +hashnnn0genn0 +hashnzfz +hashnzfz2 +hashnzfzclim +hashp1i +hashprb +hashprdifel +hashprg +hashprlei +hashpss +hashpw +hashrabrex +hashrabrsn +hashrabsn01 +hashrabsn1 +hashrepr +hashreprin +hashres +hashresfn +hashreshashfun +hashscontpow +hashscontpow1 +hashscontpowcl +hashsdom +hashsn01 +hashsng +hashsnle1 +hashsnlei +hashss +hashssdif +hashssle +hashsslei +hashtpg +hashtplei +hashun +hashun2 +hashun3 +hashuni +hashunif +hashunlei +hashunsng +hashunsnggt +hashunsngx +hashunx +hashv01gt1 +hashvnfin +hashwrdn +hashwwlksnext +hashxnn0 +hashxp +hashxpe +hashxplem +hashxrcl +hatomic +hatomici +hatomistici +hauscmp +hauscmplem +hausdiag +hausdist_alt +hausdist_balls +hausdist_closure +hausdist_compact_exists +hausdist_compact_inters_limit +hausdist_compact_nontrivial +hausdist_compact_sums +hausdist_complements_convex_explicit +hausdist_complements_convex_le +hausdist_convex_hulls +hausdist_empty +hausdist_eq +hausdist_eq_0 +hausdist_frontiers_convex +hausdist_insert_le +hausdist_linear_image +hausdist_nontrivial +hausdist_nontrivial_alt +hausdist_pos_le +hausdist_pos_lt +hausdist_refl +hausdist_relative_interior +hausdist_scaling +hausdist_setdist_triangle +hausdist_sings +hausdist_still_inside +hausdist_still_inside_interior +hausdist_still_nonempty_interior +hausdist_still_outside +hausdist_still_same_place +hausdist_still_same_place_conic_hull +hausdist_still_same_place_conic_hull_strong +hausdist_still_same_place_strong +hausdist_sums +hausdist_sums_le +hausdist_sums_le_lcancel +hausdist_sums_le_rcancel +hausdist_sym +hausdist_translation +hausdist_triangle +hausdist_uniformly_continuous_on +hausdist_union_le +hausdorff +hausdorff_limit +hausdorff_space_euclidean +hausdorff_space_mtopology +hausdorff_space_subtopology +hauseqcn +hauseqlcld +hausflf +hausflf2 +hausflim +hausflimi +hausflimlem +hausgraph +haushmph +haushmphlem +hauslly +hausllycmp +hausmapdom +hausnei +hausnei2 +hausnlly +hauspwdom +hauspwpwdom +hauspwpwf1 +haust1 +haustop +haustsms +haustsms2 +haustsmsid +have +hb3an +hba1 +hba1-o +hba1w +hbab +hbab1 +hbabg +hbae +hbae-o +hbaev +hbal +hbald +hbalg +hbalgvd +hbaltg +hbalw +hban +hbe1 +hbe1a +hbe1w +hbequid +hbex +hbexg +hbexgvd +hbim +hbim1 +hbimd +hbimg +hbimpg +hbimpgvd +hbimtg +hblem +hblemg +hbn +hbn1 +hbn1fw +hbn1w +hbnae +hbnae-o +hbnaes +hbnaev +hbnd +hbng +hbnt +hbntal +hbntg +hbra1 +hbra2vd +hbral +hbralrimi +hbs1 +hbsb +hbsb2 +hbsb2a +hbsb2e +hbsb3 +hbsbw +hbsbwold +hbt +hbth +hbtlem1 +hbtlem2 +hbtlem3 +hbtlem4 +hbtlem5 +hbtlem6 +hbtlem7 +hbxfrbi +hbxfreq +hcau +hcaucvg +hcauseq +hd +hd_append +hd_drop +hd_dropwhile +hd_genlist_cor +hd_in_set +hd_reverse +hdmap10 +hdmap10lem +hdmap11 +hdmap11lem1 +hdmap11lem2 +hdmap14lem1 +hdmap14lem10 +hdmap14lem11 +hdmap14lem12 +hdmap14lem13 +hdmap14lem14 +hdmap14lem15 +hdmap14lem1a +hdmap14lem2a +hdmap14lem2n +hdmap14lem3 +hdmap14lem4 +hdmap14lem4a +hdmap14lem6 +hdmap14lem7 +hdmap14lem8 +hdmap14lem9 +hdmap1cbv +hdmap1cl +hdmap1eq +hdmap1eq2 +hdmap1eq4n +hdmap1eu +hdmap1eulem +hdmap1eulemoldn +hdmap1euoldn +hdmap1ffval +hdmap1fval +hdmap1l6 +hdmap1l6a +hdmap1l6b +hdmap1l6b0n +hdmap1l6c +hdmap1l6d +hdmap1l6e +hdmap1l6f +hdmap1l6g +hdmap1l6h +hdmap1l6i +hdmap1l6j +hdmap1l6k +hdmap1l6lem1 +hdmap1l6lem2 +hdmap1val +hdmap1val0 +hdmap1val2 +hdmap1valc +hdmap1vallem +hdmapadd +hdmapcl +hdmapellkr +hdmapeq0 +hdmapevec +hdmapevec2 +hdmapeveclem +hdmapf1on +hdmapffval +hdmapfnn +hdmapfval +hdmapg +hdmapglem5 +hdmapglem7 +hdmapglem7a +hdmapglem7b +hdmapgln2 +hdmapglnm2 +hdmapinvlem0 +hdmapinvlem1 +hdmapinvlem2 +hdmapinvlem3 +hdmapinvlem4 +hdmapip0 +hdmapip0com +hdmapip1 +hdmapipcl +hdmaplem1 +hdmaplem2n +hdmaplem3 +hdmaplem4 +hdmaplkr +hdmapln1 +hdmaplna1 +hdmaplna2 +hdmaplnm1 +hdmaplns1 +hdmapneg +hdmapnzcl +hdmapoc +hdmaprnlem10n +hdmaprnlem11n +hdmaprnlem15n +hdmaprnlem16n +hdmaprnlem17n +hdmaprnlem1n +hdmaprnlem3en +hdmaprnlem3n +hdmaprnlem3un +hdmaprnlem4n +hdmaprnlem4tn +hdmaprnlem6n +hdmaprnlem7n +hdmaprnlem8n +hdmaprnlem9n +hdmaprnn +hdmapsub +hdmapval +hdmapval0 +hdmapval2 +hdmapval2lem +hdmapval3lemn +hdmapval3n +he0 +heap_extract_min_sorted +heap_insert_min +heapinsert +heeq1 +heeq12 +heeq2 +heibor +heibor1 +heibor1lem +heiborlem1 +heiborlem10 +heiborlem2 +heiborlem3 +heiborlem4 +heiborlem5 +heiborlem6 +heiborlem7 +heiborlem8 +heiborlem9 +heicant +heine_borel +heine_borel_imp_bolzano_weierstrass +heine_borel_lemma +heinecantor +helch +helloworld +helly +helly_alt +helly_closed +helly_closed_alt +helly_compact +helly_compact_alt +helly_induct +helly_selection_increasing +helly_selection_theorem +helsh +hence +henstock_lemma +henstock_lemma_part1 +henstock_lemma_part2 +heron +hess +heterogeneous_list +hfadj +hfelhf +hfext +hfmmval +hfmval +hfninf +hfpw +hfsmval +hfsn +hfsval +hftr +hfun +hfuni +hgmap11 +hgmapadd +hgmapcl +hgmapdcl +hgmapeq0 +hgmapf1on +hgmapffval +hgmapfnn +hgmapfval +hgmapmul +hgmaprnlem1n +hgmaprnlem2n +hgmaprnlem3n +hgmaprnlem4n +hgmaprnlem5n +hgmaprnn +hgmapval +hgmapval0 +hgmapval1 +hgmapvs +hgmapvv +hgmapvvlem1 +hgmapvvlem2 +hgmapvvlem3 +hgt749d +hgt750lem +hgt750lem2 +hgt750lema +hgt750lemb +hgt750lemc +hgt750lemd +hgt750leme +hgt750lemf +hgt750lemg +hh0oi +hh0v +hhba +hhbloi +hhcau +hhcmpl +hhcms +hhcnf +hhcno +hhhl +hhims +hhims2 +hhip +hhlm +hhlnoi +hhmet +hhmetdval +hhnm +hhnmoi +hhnv +hhph +hhshsslem1 +hhshsslem2 +hhsm +hhssablo +hhssabloi +hhssabloilem +hhssba +hhssbnold +hhsscms +hhssims +hhssims2 +hhssmet +hhssmetdval +hhssnm +hhssnv +hhssnvt +hhsssh +hhsssh2 +hhsssm +hhsst +hhssva +hhssvs +hhssvsf +hhva +hhvs +hhxmet +hi01 +hi02 +hi2eq +hial0 +hial02 +hial2eq +hial2eq2 +hiassdi +hicl +hicli +hidato +higher_order_app +hiidge0 +hiidrcl +hilablo +hilbert1.1 +hilbert1.2 +hilcms +hilcompl +hilhhi +hilhl +hilid +hilims +hilmet +hilmetdval +hilnormi +hilvc +hilxmet +hints +hire +hirstl-ax3 +his1i +his2sub +his2sub2 +his35 +his35i +his5 +his52 +his6 +his7 +hisubcomi +hl0cl +hl0lt1n +hl2at +hladdf +hladdid +hlass +hlatcon2 +hlatcon3 +hlateq +hlatexch1 +hlatexch2 +hlatexch3n +hlatexch4 +hlatexchb1 +hlatexchb2 +hlathil +hlatj12 +hlatj32 +hlatj4 +hlatjass +hlatjcl +hlatjcom +hlatjidm +hlatjrot +hlatl +hlatle +hlatlej1 +hlatlej2 +hlatmstcoldn +hlbn +hlbtwn +hlcgreu +hlcgreulem +hlcgrex +hlclat +hlcmet +hlcms +hlcom +hlcomb +hlcomd +hlcompl +hlcph +hlcvl +hldi +hldir +hleqnid +hlex +hlexch1 +hlexch2 +hlexch3 +hlexch4n +hlexchb1 +hlexchb2 +hlhgt2 +hlhgt4 +hlhil +hlhil0 +hlhilbase +hlhildrng +hlhilhillem +hlhilip +hlhilipval +hlhillcs +hlhillsm +hlhillvec +hlhilnvl +hlhilocv +hlhilphllem +hlhilplus +hlhils0 +hlhils1n +hlhilsbase +hlhilsbase2 +hlhilsca +hlhilset +hlhilslem +hlhilsmul +hlhilsmul2 +hlhilsplus +hlhilsplus2 +hlhilsrng +hlhilsrnglem +hlhilvsca +hlid +hlim0 +hlim2 +hlimadd +hlimcaui +hlimconvi +hlimeui +hlimf +hlimi +hlimreui +hlimseqi +hlimuni +hlimveci +hlipass +hlipcj +hlipdir +hlipf +hlipgt0 +hllat +hllatd +hlln +hlmet +hlmod1i +hlmul0 +hlmulass +hlmulf +hlmulid +hlne1 +hlne2 +hlnv +hlnvi +hlobn +hlol +hlomcmat +hlomcmcv +hloml +hlop +hlpar +hlpar2 +hlpasch +hlperpnel +hlph +hlphl +hlpos +hlpr +hlprlem +hlrel +hlrelat +hlrelat1 +hlrelat2 +hlrelat3 +hlrelat5n +hlress +hlsupr +hlsupr2 +hlsuprexch +hltr +hlvc +hmac_verify +hmdmadj +hmeocld +hmeoclda +hmeocldb +hmeocls +hmeocn +hmeocnv +hmeocnvb +hmeocnvcn +hmeoco +hmeof1o +hmeof1o2 +hmeofn +hmeofval +hmeoima +hmeoimaf1o +hmeontr +hmeoopn +hmeoqtop +hmeores +hmop +hmopadj +hmopadj2 +hmopbdopthil +hmopco +hmopd +hmopex +hmopf +hmopidmch +hmopidmchi +hmopidmpj +hmopidmpji +hmoplin +hmopm +hmopre +hmops +hmoval +hmph +hmph0 +hmphdis +hmphen +hmphen2 +hmpher +hmphi +hmphindis +hmphref +hmphsym +hmphsymb +hmphtop +hmphtop1 +hmphtop2 +hmphtr +hne0 +ho01i +ho02i +ho0coi +ho0f +ho0sub +ho0subi +ho0val +ho2coi +ho2times +ho_induction_schema +ho_match_abbrev_tac +ho_match_mp_tac +hoadd12i +hoadd32 +hoadd32i +hoadd4 +hoaddass +hoaddassi +hoaddcl +hoaddcli +hoaddcom +hoaddcomi +hoadddi +hoadddir +hoaddfni +hoaddrid +hoaddridi +hoaddsub +hoaddsubass +hoaddsubassi +hoaddsubi +hoas_abs +hoas_app +hoas_beta +hoas_subst +hocadddiri +hococli +hocofi +hocofni +hocoi +hocsubdir +hocsubdiri +hodcl +hodcli +hoddi +hoddii +hodid +hodidi +hodmval +hodseqi +hodsi +hodval +hoeq +hoeq1 +hoeq2 +hoeqi +hof1 +hof1fval +hof2 +hof2fval +hof2val +hofcl +hofcllem +hofpropd +hofval +hoi2toco +hoico1 +hoico2 +hoicoto2 +hoicvr +hoicvrrex +hoid1i +hoid1ri +hoidifhspdmvle +hoidifhspf +hoidifhspval +hoidifhspval2 +hoidifhspval3 +hoidmv0val +hoidmv1le +hoidmv1lelem1 +hoidmv1lelem2 +hoidmv1lelem3 +hoidmvcl +hoidmvle +hoidmvlelem1 +hoidmvlelem2 +hoidmvlelem3 +hoidmvlelem4 +hoidmvlelem5 +hoidmvn0val +hoidmvval +hoidmvval0 +hoidmvval0b +hoif +hoimbl +hoimbl2 +hoimbllem +hoiprodcl +hoiprodcl2 +hoiprodcl3 +hoiprodp1 +hoiqssbl +hoiqssbllem1 +hoiqssbllem2 +hoiqssbllem3 +hoissre +hoissrrn +hoissrrn2 +hoival +holds +hole +holes +hom_compose +homa1 +homacd +homadm +homadmcd +homaf +homafval +homahom +homahom2 +homarcl +homarcl2 +homarel +homarw +homaval +homcl +homco1 +homco2 +homdmcoa +homeomorphic_affine_sets +homeomorphic_affinity +homeomorphic_analyticity +homeomorphic_baire_indicator +homeomorphic_ball_univ +homeomorphic_borelness +homeomorphic_closed_intervals +homeomorphic_compact +homeomorphic_compactness +homeomorphic_connectedness +homeomorphic_convex_compact +homeomorphic_convex_compact_cball +homeomorphic_convex_compact_sets +homeomorphic_convex_open_sets +homeomorphic_countability +homeomorphic_countable_union_of_baire_indicator +homeomorphic_empty +homeomorphic_finite +homeomorphic_finite_strong +homeomorphic_finiteness +homeomorphic_fsigmaness +homeomorphic_gdeltaness +homeomorphic_graph +homeomorphic_has_size +homeomorphic_hyperplane_standard_hyperplane +homeomorphic_hyperplane_univ +homeomorphic_hyperplanes +homeomorphic_imp_card_eq +homeomorphic_infiniteness +homeomorphic_injective_linear_image_left_eq +homeomorphic_injective_linear_image_right_eq +homeomorphic_injective_linear_image_self +homeomorphic_local_compactness +homeomorphic_locally +homeomorphic_map_derived_set_of +homeomorphic_map_frontier_of +homeomorphic_map_interior_of +homeomorphic_map_maps +homeomorphic_maps_euclidean_space_euclidean +homeomorphic_maps_euclidean_space_euclidean_gen +homeomorphic_maps_euclidean_subtopology +homeomorphic_maps_nsphere_euclidean_sphere +homeomorphic_maps_subtopologies_alt +homeomorphic_minimal +homeomorphic_one_point_compactifications +homeomorphic_open_interval_univ +homeomorphic_open_interval_univ_1 +homeomorphic_open_intervals +homeomorphic_open_intervals_1 +homeomorphic_pcross +homeomorphic_pcross_assoc +homeomorphic_pcross_sing +homeomorphic_pcross_sym +homeomorphic_refl +homeomorphic_relatively_open_convex_sets +homeomorphic_scaling +homeomorphic_scaling_left +homeomorphic_scaling_right +homeomorphic_self_image +homeomorphic_sing +homeomorphic_space_euclidean +homeomorphic_standard_hyperplane_hyperplane +homeomorphic_subspaces +homeomorphic_sym +homeomorphic_trans +homeomorphic_translation +homeomorphic_translation_left_eq +homeomorphic_translation_right_eq +homeomorphic_translation_self +homeomorphism +homeomorphism_arc +homeomorphism_borelness +homeomorphism_closed_in_eq +homeomorphism_closedness +homeomorphism_closure +homeomorphism_closure_of +homeomorphism_compact +homeomorphism_compactness +homeomorphism_components +homeomorphism_compose +homeomorphism_connected_component +homeomorphism_connectedness +homeomorphism_countability +homeomorphism_derived_set_of +homeomorphism_eq +homeomorphism_finiteness +homeomorphism_from_composition_injective +homeomorphism_from_composition_surjective +homeomorphism_frontier_of +homeomorphism_fsigmaness +homeomorphism_gdeltaness +homeomorphism_graph +homeomorphism_graph_explicit +homeomorphism_has_size_eq +homeomorphism_i +homeomorphism_id +homeomorphism_imp_closed_map +homeomorphism_imp_homeomorphic +homeomorphism_imp_open_map +homeomorphism_imp_quotient_map +homeomorphism_infiniteness +homeomorphism_injective_closed_map +homeomorphism_injective_closed_map_eq +homeomorphism_injective_open_map +homeomorphism_injective_open_map_eq +homeomorphism_interior_of +homeomorphism_local_compactness +homeomorphism_locally +homeomorphism_of_subsets +homeomorphism_of_subsets_alt +homeomorphism_one_point_compactifications +homeomorphism_open_in_eq +homeomorphism_openness +homeomorphism_sym +homf0 +homfeq +homfeqbas +homfeqd +homfeqval +homffn +homffval +homfval +homid +hommval +homndx +homoeomorphism_paste +homogeneous_linear_equations_det +homomorphism_kernel +homomorphism_real_to_real +homul12 +homulass +homulcl +homullid +homval +hon0 +honegdi +honegneg +honegsub +honegsubdi +honegsubdi2 +honegsubi +honpcani +honpncani +hopncani +horn_sat_poly +hoscl +hoscli +hosd1i +hosd2i +hosmval +hosub4 +hosubadd4 +hosubcl +hosubcli +hosubdi +hosubeq0i +hosubfni +hosubid1 +hosubneg +hosubsub +hosubsub2 +hosubsub4 +hosval +how-many-evens-and-odds +how-many-isort +how-many-merge2 +how-many-msort +hpgbr +hpgcom +hpgerlem +hpgid +hpgne1 +hpgne2 +hpgtr +hphl +hsmex +hsmex2 +hsmex3 +hsmexlem1 +hsmexlem2 +hsmexlem3 +hsmexlem4 +hsmexlem5 +hsmexlem6 +hsmexlem7 +hsmexlem8 +hsmexlem9 +hsn0elch +hspdifhsp +hsphoidmvle +hsphoidmvle2 +hsphoif +hsphoival +hspmbl +hspmbllem1 +hspmbllem2 +hspmbllem3 +hspval +hst0 +hst0h +hst1a +hst1h +hstcl +hstel2 +hstep +hstle +hstle1 +hstles +hstnmoc +hstoc +hstoh +hstorth +hstosum +hstpyth +hstrbi +hstri +hstrlem2 +hstrlem3 +hstrlem3a +hstrlem4 +hstrlem5 +hstrlem6 +hsubst +hsupcl +hsupss +hsupunss +hsupval +hsupval2 +hta +htalem +htpycc +htpycn +htpyco1 +htpyco2 +htpycom +htpyi +htpyid +htth +htthlem +hull_antimono +hull_eq +hull_hull +hull_image +hull_inc +hull_induct +hull_insert +hull_minimal +hull_mono +hull_p +hull_redundant_eq +hull_subset +hull_union +hull_union_right +hull_union_subset +hull_unique +hull_univ +hulls_eq +hv2neg +hv2negi +hv2times +hvadd12 +hvadd12i +hvadd32 +hvadd32i +hvadd4 +hvadd4i +hvaddcan +hvaddcan2 +hvaddcani +hvaddcl +hvaddcli +hvaddeq0 +hvaddlid +hvaddlidi +hvaddsub12 +hvaddsub4 +hvaddsubass +hvaddsubval +hvassi +hvcomi +hvdistr1i +hvm1neg +hvmap1o +hvmap1o2 +hvmapcl2 +hvmapcln +hvmapffval +hvmapfval +hvmapidn +hvmaplfl +hvmaplkr +hvmapval +hvmapvalvaln +hvmul0 +hvmul0or +hvmul2negi +hvmulassi +hvmulcan +hvmulcan2 +hvmulcl +hvmulcli +hvmulcom +hvmulcomi +hvmulex +hvnegdi +hvnegdii +hvnegid +hvnegidi +hvpncan +hvpncan2 +hvpncan3 +hvsub0 +hvsub32 +hvsub32i +hvsub4 +hvsubadd +hvsubaddi +hvsubass +hvsubassi +hvsubcan +hvsubcan2 +hvsubcan2i +hvsubcl +hvsubcli +hvsubdistr1 +hvsubdistr1i +hvsubdistr2 +hvsubeq0 +hvsubeq0i +hvsubf +hvsubid +hvsubsub4 +hvsubsub4i +hvsubval +hvsubvali +hyp +hyp_tac +hypcgr +hypcgrlem1 +hypcgrlem2 +hyperplane_eq_empty +hyperplane_eq_univ +hyperplane_face_of_halfspace_ge +hyperplane_face_of_halfspace_le +hyperplane_facet_of_halfspace_ge +hyperplane_facet_of_halfspace_le +hyperpolymath +hypotheses +hypothesis +hypothetical_syllogism +i0oii +i1f0 +i1f0rn +i1f1 +i1f1lem +i1fadd +i1faddlem +i1fd +i1ff +i1fibl +i1fima +i1fima2 +i1fima2sn +i1fmbf +i1fmul +i1fmulc +i1fmulclem +i1fmullem +i1fpos +i1fposd +i1fres +i1frn +i1fsub +i2 +i2linesd +i2linesi +i3 +i32_add_overflow +i4 +i_def +i_o_id +i_thm +iaa +ianor +iba +ibar +ibd +ibdr +ibi +ibib +ibibr +ibir +ibl0 +iblabs +iblabslem +iblabsnc +iblabsnclem +iblabsr +ibladd +ibladdlem +ibladdnc +ibladdnclem +iblcn +iblcncfioo +iblcnlem +iblcnlem1 +iblconst +iblconstmpt +iblempty +ibliccsinexp +iblidicc +ibliooicc +iblioosinexp +iblitg +ibllem +iblmbf +iblmulc2 +iblmulc2nc +iblneg +iblpos +iblposlem +iblre +iblrelem +iblsplit +iblsplitf +iblspltprt +iblss +iblss2 +iblsub +iblsubnc +iblulm +icc0 +iccbnd +icccld +icccldii +icccmp +icccmpalt +icccmplem1 +icccmplem2 +icccmplem3 +icccncfext +icccntr +icccntri +iccconn +icccvx +iccdificc +iccdifioo +iccdifprioo +iccdil +iccdili +iccdisj +iccdisj2 +iccelpart +iccen +icceuelpart +icceuelpartlem +iccf +iccf1o +iccgelb +iccgelbd +icchmeo +icchmeoold +iccid +iccin +iccintsng +iccioo01 +iccleub +iccleubd +iccllysconn +iccmax +iccmbl +iccnct +iccneg +iccntr +icco1 +iccordt +iccpart +iccpartdisj +iccpartel +iccpartf +iccpartgel +iccpartgt +iccpartgtl +iccpartgtprec +iccpartigtl +iccpartiltu +iccpartimp +iccpartipre +iccpartiun +iccpartleu +iccpartlt +iccpartltu +iccpartnel +iccpartres +iccpartrn +iccpartxr +iccpnfcnv +iccpnfhmeo +iccpval +iccsconn +iccshftl +iccshftli +iccshftr +iccshftri +iccshift +iccsplit +iccss +iccss2 +iccssico +iccssico2 +iccssioo +iccssioo2 +iccssre +iccssred +iccssxr +iccsuble +iccsupr +iccval +iccvolcl +iccvonmbl +iccvonmbllem +ich2al +ich2ex +ich2exprop +ichal +ichan +ichbi12i +ichbidv +ichcircshi +ichcom +icheq +icheqid +ichexmpl1 +ichexmpl2 +ichf +ichid +ichim +ichn +ichnfb +ichnfim +ichnfimlem +ichnreuop +ichreuopeq +icht +ichv +ico0 +ico01fl0 +icocncflimc +icodiamlt +icodisj +icof +icogelb +icogelbd +icoiccdif +icoltub +icoltubd +icombl +icombl1 +icomnfinre +icomnfordt +iconstr +icoopn +icoopnst +icopnfcld +icopnfcnv +icopnfhmeo +icopnfsup +icoreclin +icoreelrn +icoreelrnab +icorempo +icoreresf +icoresmbl +icoreunrn +icoreval +icoshft +icoshftf1o +icossicc +icossico +icossico2d +icossioo +icossre +icossxr +icoub +icoun +icoval +id +id1 +id_left +id_right +id_spec_tac +ida2 +idacd +idadm +idaf +idafval +idahom +idalt +idaval +idcn +idcncf +idcncfg +idcnop +idd +iddii +iddvds +iddvdsexp +ideal_closed +ideal_sum +idealaxiom +idemb +idempotent_matrix_mul_linv +idempotent_matrix_mul_rinv +idempotent_matrix_trace_eq_rank +iden2 +identifier +identity +identity_axiom +identity_type +identitylaws +identityʳ +idepi +ideq +ideq2 +ideqg +ider +idffth +idfn +idfth +idfu1 +idfu1a +idfu1st +idfu1sta +idfu1stalem +idfu1stf1o +idfu2 +idfu2nd +idfu2nda +idfucl +idfudiag1 +idfudiag1bas +idfudiag1lem +idfullsubc +idfurcl +idfusubc +idfusubc0 +idfuval +idghm +idhe +idhmeo +idhmop +idi +idialt +ididg +idinside +idinv +idinxpres +idinxpresid +idinxpss +idinxpssinxp +idinxpssinxp2 +idinxpssinxp3 +idinxpssinxp4 +idiso +idivd +idl0cl +idladdcl +idlaut +idlcl +idldil +idleop +idlimc +idlinsubrg +idllmulcl +idlmhm +idlmulssprm +idlnegcl +idlnop +idlrmulcl +idlsrg0g +idlsrgbas +idlsrgcmnd +idlsrgmnd +idlsrgmulr +idlsrgmulrcl +idlsrgmulrss1 +idlsrgmulrss2 +idlsrgmulrssin +idlsrgmulrval +idlsrgplusg +idlsrgstr +idlsrgtset +idlsrgval +idlss +idlsubcl +idltrn +idlval +idmatidpmat +idmgmhm +idmhm +idmon +idmot +idn1 +idn2 +idn3 +idnghm +idnmhm +idomcringd +idomdomd +idomnnzgmulnz +idomnnzpownz +idomodle +idompropd +idomrcan +idomrcanold +idomringd +idomrootle +idomsubgmo +idomsubr +idpm2idmp +idqtop +idr +idref +idrefalt +idresefmnd +idreseqidinxp +idresperm +idrespermg +idresssidinxp +idressubgsymg +idressubmefmnd +idrhm +idris2 +idrnghm +idrval +ids1 +idsrngd +idssen +idsset +idssxp +idsubc +idsymrel +iducn +idunop +iedgedg +iedginwlk +iedgval +iedgval0 +iedgval3sn +iedgvalprc +iedgvalsnop +ielefmnd +iexpcyc +iexpire +if +if_cases_tac +ifan +ifbi +ifbid +ifbieq12d +ifbieq12d2 +ifbieq12i +ifbieq1d +ifbieq2d +ifbieq2i +ifboth +ifbothda +ifchhv +ifcl +ifcld +ifclda +ifcli +ifcomnan +ifel +ifeq1 +ifeq12 +ifeq12d +ifeq12da +ifeq1d +ifeq1da +ifeq2 +ifeq2d +ifeq2da +ifeq3da +ifeqda +ifeqeqx +ifeqor +ifex +ifexd +ifexg +iff +iff_refl +iff_sym +iff_symm +iff_tac +iff_trans +iffalse +iffalsed +iffalsei +iffv +ifhvhv0 +ifid +ifle +ifmpt2v +ifnebib +ifnefals +ifnefalse +ifnetrue +ifnmfalse +ifnot +ifor +ifov +ifp1bi +ifpan123g +ifpan23 +ifpananb +ifpancor +ifpbi1 +ifpbi12 +ifpbi123 +ifpbi123d +ifpbi13 +ifpbi1b +ifpbi2 +ifpbi23 +ifpbi23d +ifpbi3 +ifpbibib +ifpbicor +ifpbiidcor +ifpbiidcor2 +ifpdfan +ifpdfan2 +ifpdfbi +ifpdfnan +ifpdfor +ifpdfor2 +ifpdfxor +ifpfal +ifpid +ifpid1g +ifpid2 +ifpid2g +ifpid3g +ifpidg +ifpim1 +ifpim123g +ifpim1g +ifpim2 +ifpim23g +ifpim3 +ifpim4 +ifpimim +ifpimimb +ifpimpda +ifpn +ifpnancor +ifpnannanb +ifpnim1 +ifpnim2 +ifpnorcor +ifpnot +ifpnot23 +ifpnot23b +ifpnot23c +ifpnot23d +ifpnotnotb +ifpor +ifpor123g +ifporcor +ifpororb +ifpprsnss +ifpr +ifpsnprss +ifptru +ifpxorcor +ifpxorxorb +ifr0 +ifsb +ifscgr +ifssun +iftrue +iftrueb +iftrued +iftruei +ifval +ig1pcl +ig1pdvds +ig1peu +ig1pmindeg +ig1pnunit +ig1prsp +ig1pval +ig1pval2 +ig1pval3 +igamcl +igamf +igamgam +igamlgam +igamval +igamz +ige2m1fz +ige2m1fz1 +ige2m2fzo +ige3m2fz +igenidl +igenidl2 +igenmin +igenss +igenval +igenval2 +igz +ih +iicmp +iiconn +iidn3 +iihalf1 +iihalf1cn +iihalf1cnold +iihalf2 +iihalf2cn +iihalf2cnold +iillysconn +iimulcl +iimulcn +iimulcnold +iin0 +iin1 +iin2 +iin3 +iinab +iinabrex +iincld +iinconst +iindif1 +iindif2 +iindif2f +iineq0 +iineq1 +iineq12dv +iineq12f +iineq12i +iineq1d +iineq1i +iineq2 +iineq2d +iineq2dv +iineq2i +iineqconst2 +iiner +iinexd +iinexg +iinfconstbas +iinfconstbaslem +iinfi +iinfprg +iinfssc +iinfssclem1 +iinfssclem2 +iinfssclem3 +iinfsubc +iinglb +iinhoiicc +iinhoiicclem +iinin1 +iinin2 +iinllyconn +iinon +iinopn +iinpreima +iinpw +iinrab +iinrab2 +iinss +iinss1 +iinss2 +iinss2d +iinssd +iinssdf +iinssf +iinssiin +iinssiun +iinun2 +iinuni +iinvdif +iinxp +iinxprg +iinxsng +iirev +iirevcn +iisconn +iistmd +iitop +iitopon +iiuni +im0 +im1 +im2anan9 +im2anan9r +ima0 +imacmp +imacnvcnv +imaco +imacosupp +imacrhmcl +imadd +imaddd +imaddi +imadif +imadifss +imadifssran +imadifxp +imadisj +imadisjld +imadisjlnd +imadmres +imadmrn +imadomfi +imadomg +imadrhmcl +imaelfm +imaelsetpreimafv +imaelshi +imaeq1 +imaeq12d +imaeq1d +imaeq1i +imaeq2 +imaeq2d +imaeq2i +imaeqalov +imaeqexov +imaeqsalvold +imaeqsexvold +imaex +imaexd +imaexg +imaexi +imaf1co +imaf1hom +imaf1homlem +imafi +imafi2 +imafiold +image +image_11 +image_11_infinite +image_affinity_ball +image_affinity_cball +image_affinity_interval +image_affinity_sphere +image_bigunion +image_clauses +image_closure_subset +image_compact_in +image_compose +image_const +image_countable +image_delete +image_delete_inj +image_drop_interval +image_drop_univ +image_dropout_closed_interval +image_el_count_length +image_eq +image_eq_empty +image_eq_sing +image_finite +image_fst_cross +image_fstcart_pcross +image_i +image_id +image_ii +image_image +image_image_partition +image_in +image_inter +image_inter_inj +image_lift_drop +image_lift_real_interval +image_lift_univ +image_matrix_inv +image_o +image_preimage +image_restriction +image_snd_cross +image_sndcart_pcross +image_stretch_interval +image_subset +image_subset_gen +image_surj +image_twizzle_interval +image_union +image_unions +imagesset +imageval +imai +imaid +imaidfu +imaidfu2 +imaidfu2lem +imaiinfv +imain +imaindm +imainrect +imainss +imaiun +imaiun1 +imambfm +iman +imanonrel +imaopab +imarnf1pr +imasabl +imasaddf +imasaddflem +imasaddfn +imasaddfnlem +imasaddval +imasaddvallem +imasbas +imasds +imasdsf1o +imasdsf1olem +imasdsfn +imasdsval +imasdsval2 +imasetpreimafvbij +imasetpreimafvbijlemf +imasetpreimafvbijlemf1 +imasetpreimafvbijlemfo +imasetpreimafvbijlemfv +imasetpreimafvbijlemfv1 +imasf1obl +imasf1omet +imasf1oms +imasf1oxmet +imasf1oxms +imasghm +imasgim +imasgrp +imasgrp2 +imasgrpf1 +imasip +imasle +imasless +imasleval +imaslmhm +imaslmod +imasmhm +imasmnd +imasmnd2 +imasmndf1 +imasmulf +imasmulfn +imasmulr +imasmulval +imasncld +imasncls +imasng +imasnopn +imasplusg +imasrhm +imasring +imasringf1 +imasrng +imasrngf1 +imass1 +imass2 +imass2d +imassc +imassca +imassmpt +imassrn +imastopn +imastps +imastset +imasubc +imasubc2 +imasubc3 +imasubclem1 +imasubclem2 +imasubclem3 +imasval +imasvalstr +imasvsca +imasvscaf +imasvscafn +imasvscaval +imaundi +imaundir +imauni +imbi1 +imbi12 +imbi12d +imbi12i +imbi12vd +imbi13 +imbi13vd +imbi1d +imbi1i +imbi2 +imbi2d +imbi2i +imbibi +imbitrdi +imbitrid +imbitrrdi +imbitrrid +imbrov2fvoveq +imcj +imcjd +imcji +imcl +imcld +imcli +imcn2 +imcncf +imdi +imdistan +imdistand +imdistanda +imdistani +imdistanri +imdiv +imdivd +imf +imi +imim1 +imim12 +imim12d +imim12i +imim1d +imim1i +imim2 +imim21b +imim2d +imim2i +imim3i +imimorb +imlmhm +immul +immul2 +immul2d +immuld +immuli +imnan +imnand2 +imnang +imnani +imneg +imnegd +imnegi +imnot +imo72b2 +imo72b2lem0 +imo72b2lem1 +imo72b2lem2 +imor +imori +imorri +imp +imp31 +imp32 +imp41 +imp42 +imp43 +imp44 +imp45 +imp4a +imp4b +imp4c +imp4d +imp511 +imp55 +imp5a +imp5d +imp5g +imp5p +imp5q +imp_antisym +imp_clauses +imp_conj +imp_conj_alt +imp_every_lupdate +imp_imp +imp_refl +imp_res_tac +imp_rewrite_tac +imp_subst_tac +imp_trans +impac +impancom +impbi +impbid +impbid1 +impbid2 +impbid21d +impbida +impbidd +impbii +impcom +impcomd +impcon4bid +impd +impel +impexp +impexpd +impexpdcom +impi +impimprbi +impl +impl_left +impl_or +impl_right +impl_tac +impl_trans +implication +implies +impll +implode_eq_thm +implode_onto +implode_string +implr +impo +impor +import +impossible +impr +impsingle +impsingle-ax1 +impsingle-imim1 +impsingle-peirce +impsingle-step15 +impsingle-step18 +impsingle-step19 +impsingle-step20 +impsingle-step21 +impsingle-step22 +impsingle-step25 +impsingle-step4 +impsingle-step8 +impt +imre +imsdf +imsdval +imsdval2 +imsmet +imsmetlem +imsqrtval +imsqrtvalex +imsub +imsubd +imsval +imsxmet +imsym1 +imval +imval2 +in +in-ax8 +in0 +in1 +in12 +in13 +in2 +in2an +in3 +in31 +in32 +in3an +in4 +in_affine_add_mul +in_affine_add_mul_diff +in_affine_hull_linear_image +in_affine_mul_diff_add +in_affine_sub_mul_diff +in_app +in_app_iff +in_ball +in_ball_0 +in_biginter_image +in_bigunion_image +in_cball +in_cball_0 +in_closure_delete +in_components +in_components_connected +in_components_maximal +in_components_maximal_alt +in_components_nonempty +in_components_self +in_components_subset +in_components_unions_complement +in_convex_hull_exchange +in_convex_hull_exchange_unique +in_convex_hull_linear_image +in_convex_set +in_cross +in_delete +in_delete_eq +in_dfunset +in_diff +in_dimindex_swap +in_disjoint +in_elim_pair_thm +in_elim_pastecart_thm +in_elim_thm +in_epigraph +in_eq_univ_imp +in_filter +in_foo +in_from +in_frontier_convex_hull +in_funset +in_gspec +in_gspec_iff +in_image +in_image_dropout +in_image_lift_drop +in_infinite_not_finite +in_insert +in_insert_expand +in_inter +in_interior +in_interior_cball +in_interior_closure_convex_segment +in_interior_closure_convex_shrink +in_interior_convex_shrink +in_interior_eventually +in_interior_linear_image +in_inters +in_interval +in_interval_1 +in_interval_reflect +in_map +in_max_set +in_mball +in_mcball +in_numseg +in_open_segment +in_open_segment_alt +in_part +in_pow +in_powerset +in_real_interval +in_relative_interior +in_relative_interior_cball +in_relative_interior_closure_convex_segment +in_relative_interior_closure_convex_shrink +in_relative_interior_convex_shrink +in_relative_interior_in_open_segment +in_relative_interior_in_open_segment_eq +in_relative_interior_in_open_segment_strong +in_relative_interior_of_face +in_relative_interior_of_unique_face +in_rest +in_segment +in_segment_component +in_sing +in_span_delete +in_span_image_basis +in_span_insert +in_sphere +in_sphere_0 +in_translation_galois +in_translation_galois_alt +in_union +in_unions +in_univ +inab +inabs +inabs3 +inaex +inagflat +inaghl +inagne1 +inagne2 +inagne3 +inagrud +inagswap +inaprc +inar1 +inass +inatsk +inawina +inawinalem +incat +incexc +incexc2 +incexclem +incistruhgr +incld +inclfusubc +include +include_module +includin +inclusionexclusion +incom +incr_spec +increasing_bounded_convergence +increasing_bounded_variation +increasing_bounded_variation_gen +increasing_countable_discontinuities +increasing_extends_from_dense +increasing_ftc_ae_imp_absolutely_continuous +increasing_imp_baire1 +increasing_left_limit_1 +increasing_left_limit_1_gen +increasing_right_limit_1 +increasing_right_limit_1_gen +increasing_vector_variation +incsequz +incsequz2 +incsmf +incsmflem +incssnn0 +ind on l +ind on l1 +ind on m +ind on n +ind on t +ind0 +ind1 +ind1a +indcardi +indconst0 +indconst1 +indcthing +indefinite_integral_continuous +indefinite_integral_continuous_left +indefinite_integral_continuous_right +indefinite_integral_uniformly_continuous +indefinite_integral_uniformly_continuous_explicit +independent_2 +independent_3 +independent_basis_image +independent_bound +independent_bound_general +independent_card_le_dim +independent_empty +independent_eq_dim_eq_card +independent_explicit +independent_imp_affine_dependent_0 +independent_imp_finite +independent_injective_image +independent_injective_image_gen +independent_insert +independent_linear_image_eq +independent_mono +independent_nonzero +independent_sing +independent_span_bound +independent_stdbasis +independent_subspaces +independent_subspaces_0 +independent_subspaces_alt +independent_union +index_consistent +index_decomposition +index_find_add +index_of_eq_none +index_of_eq_some +indexa +indexdom +indexed +indexed_sum +indexfi +indf +indf1o +indf1ofs +indfsd +indfsid +indfval +indi +indicator_complement +indif +indif1 +indif2 +indifbi +indifcom +indifdi +indifdir +indifundif +indir +indiscld +indisconn +indishmph +indislem +indispconn +indistgp +indistop +indistopon +indistps +indistps2 +indistps2alt +indistpsalt +indistpsx +indisuni +indlcim +indm +indpi +indpi1 +indpreima +indsn +indstr +indstr2 +indstrd +indsum +indsumin +indsupp +indthinc +indthincalt +induct +induct-and-simplify +induct-on-structure +induct_linear_elementary +induct_matrix_elementary +induct_matrix_elementary_alt +induct_matrix_row_operations +induct_on +induct_tac +induction +induction_nat_sum +inductionexd +inductive +indv +indval +indval2 +ine0 +ine1 +ineccnvmo +ineccnvmo2 +inecmo +inecmo2 +inecmo3 +inegd +inelcarsg +inelcm +ineleq +inelfi +inelpisys +inelr +inelros +inelsiga +inelsros +ineq1 +ineq12 +ineq12d +ineq12i +ineq1d +ineq1i +ineq2 +ineq2d +ineq2i +ineqan12d +ineqcom +ineqcomi +ineqri +inequality_canon_rule +inex1 +inex1g +inex2 +inex2g +inex3 +inf +inf0 +inf00 +inf1 +inf2 +inf3 +inf3lem1 +inf3lem2 +inf3lem3 +inf3lem4 +inf3lem5 +inf3lem6 +inf3lem7 +inf3lema +inf3lemb +inf3lemc +inf3lemd +inf5 +inf_alt +inf_closure +inf_def_alt +inf_eq +inf_finite +inf_insert +inf_insert_finite +inf_unique +infcl +infcllem +infcntss +infcvgaux1i +infcvgaux2i +infdesc +infdif +infdif2 +infdiffi +infdifsn +infdju +infdju1 +infdjuabs +infempty +infenaleph +infensuc +infeq1 +infeq123d +infeq1d +infeq1i +infeq2 +infeq3 +infeq5 +infeq5i +infeu +infex +infexd +inffien +inffz +infglb +infglbb +infi +inficc +inficl +infil +infinf +infinfg +infinite +infinite_diff_finite +infinite_enumerate +infinite_enumerate_weak +infinite_explicit_enumerate +infinite_inhab +infinite_inj +infinite_inj_not_surj +infinite_num_inj +infinite_open_in +infinite_pow_uncountable +infinite_rest +infinite_str_univ +infinite_subset +infinite_univ +infinitely_many_primes +infinitude_primes +infiso +inflb +infleinf +infleinf2 +infleinflem1 +infleinflem2 +infltoreq +infm3 +infm3lem +infmap +infmap2 +infmin +infmo +infmremnf +infmrgelbi +infmrp1 +infn0 +infn0alt +infnlb +infnorm_0 +infnorm_eq_0 +infnorm_le_norm +infnorm_mul +infnorm_mul_lemma +infnorm_neg +infnorm_pos_le +infnorm_pos_lt +infnorm_set_image +infnorm_set_lemma +infnorm_sub +infnorm_triangle +infnsuprnmpt +infordmin +infpn +infpn2 +infpnlem1 +infpnlem2 +infpr +infpss +infpssalt +infpssr +infpssrlem1 +infpssrlem2 +infpssrlem3 +infpssrlem4 +infpssrlem5 +infpwfidom +infpwfien +infrecl +infrefilb +infregelb +infrelb +infrenegsup +infrglb +infrnmptle +infrpge +infrpgernmpt +infsdomnn +infsn +infssd +infssuni +infssuzcl +infssuzle +infsubc +infsubc2 +infsubc2d +infsum_0 +infsum_add +infsum_cmul +infsum_eq +infsum_even +infsum_linear +infsum_neg +infsum_odd +infsum_restrict +infsum_sub +infsum_unique +infsupprpr +inftmrel +infunabs +infunsdom +infunsdom1 +infval +infxp +infxpabs +infxpdom +infxpen +infxpenc +infxpenc2 +infxpenc2lem1 +infxpenc2lem2 +infxpenc2lem3 +infxpenlem +infxpidm +infxpidm2 +infxr +infxrbnd2 +infxrcl +infxrcld +infxrge0gelb +infxrge0glb +infxrge0lb +infxrgelb +infxrgelbrnmpt +infxrglb +infxrlb +infxrlbrnmpt2 +infxrlesupxr +infxrmnf +infxrpnf +infxrpnf2 +infxrre +infxrrefi +infxrrnmptcl +infxrss +infxrunb2 +infxrunb3 +infxrunb3rnmpt +ingru +inidl +inidm +iniin1 +iniin2 +inimasn +inimass +inin +inindi +inindif +inindir +inintabd +inintabss +iniseg +inisegn0 +inisegn0a +initc +initocmd +initoeu1 +initoeu1w +initoeu2 +initoeu2lem0 +initoeu2lem1 +initoeu2lem2 +initofn +initoid +initoo +initoo2 +initopropd +initopropdlem +initopropdlemlem +initorcl +initoval +inixp +inj_bij_subset +inj_card +inj_card_image +inj_card_image_eq +inj_compose +inj_cong +inj_countable +inj_delete +inj_element +inj_eq_11 +inj_extend +inj_i +inj_i_image +inj_id +inj_iff +inj_image +inj_image_bij +inj_image_countable_iff +inj_image_disjoint +inj_image_eq +inj_image_equiv_class +inj_image_inter +inj_image_subset +inj_imp_11 +inj_inl +inj_inr +inj_insert +inj_linv_opt +inj_linv_opt_image +inj_map_eq +inj_map_eq_iff +inj_subset +inj_subset_univ +inj_surj +injective_alt +injective_imp_isometric +injective_left_inverse +injective_map_open_iff_closed +injective_on_alt +injective_on_left_inverse +injective_scaling +injresinj +injresinjlem +injsubmefmnd +injust +inlinecirc02p +inlinecirc02plem +inlinecirc02preu +inlresf +inlresf1 +inmap +inmbl +inn0 +inn0f +innei +inopab +inopn +inopnd +inorder +inorder_flatten +inpr0 +inpreima +input_sanitize +inpw +inrab +inrab2 +inres +inres2 +inrot +inrresf +inrresf1 +insert +insert-ordered +insert_ac +insert_bst +insert_comm +insert_count +insert_delete +insert_diff +insert_eq_sing +insert_insert +insert_inter +insert_sing_union +insert_sorted +insert_subset +insert_union +insert_union_eq +insert_univ +insertion-sort-ordered +insertion_sort_permut +insertion_sort_sorted +insertion_sort_spec +insertionsortsorted +insertsorted +inside_frontier_eq_interior +inside_of_triangle +insiga +inss +inss1 +inss2 +inssdif0 +inst +inst_type +instance +insubm +insucid +int +int-add01d +int-add02d +int-addassocd +int-addcomd +int-addsimpd +int-eqineqd +int-eqmvtd +int-eqprincd +int-eqtransd +int-ineq1stprincd +int-ineq2ndprincd +int-ineqmvtd +int-ineqtransd +int-leftdistd +int-mul11d +int-mul12d +int-mulassocd +int-mulcomd +int-mulsimpd +int-rightdistd +int-sqdefd +int-sqgeq0d +int0 +int0el +int2 +int3 +int_add_lid +int_add_linv +int_arith +int_arith_tac +int_eq_imp_le +int_eq_sub_radd +int_le_antisym +int_le_refl +int_le_sub_ladd +int_le_trans +int_lt_antisym +int_lt_le +int_lt_refl +int_of_num_add +int_of_num_eq +int_of_num_exists +int_of_num_le +int_of_num_lt +int_of_num_suc +int_pos +int_reduce_conv +int_sub_add +int_sub_lzero +int_sub_refl +intab +intabs +intabssd +intasym +intcld +integer +integer-length-signed-byte +integer-length-unsigned-byte +integer_closed +integer_det +integer_exists_between_abs_lt +integer_mul +integer_product +integer_sign +integer_sub_lemma +integer_sum +integerp-*-2-fact +integerp-expt-2 +integerp-expt-minus +integerp-expt/expt +integrable_0 +integrable_add +integrable_affinity +integrable_alt +integrable_alt_subset +integrable_bounded_variation +integrable_bounded_variation_bilinear_lmul +integrable_bounded_variation_bilinear_rmul +integrable_bounded_variation_product +integrable_bounded_variation_product_alt +integrable_by_parts +integrable_by_parts_eq +integrable_cases +integrable_cauchy +integrable_ccontinuous_explicit +integrable_ccontinuous_explicit_symmetric +integrable_cmul +integrable_cmul_eq +integrable_combine +integrable_combine_division +integrable_componentwise +integrable_const +integrable_continuous +integrable_convolution_sym +integrable_decreasing +integrable_decreasing_1 +integrable_decreasing_product +integrable_decreasing_product_univ +integrable_diff +integrable_eq +integrable_iff_measurable_under_curve +integrable_imp_measurable +integrable_increasing +integrable_increasing_1 +integrable_increasing_product +integrable_increasing_product_univ +integrable_integral +integrable_lift_component +integrable_linear +integrable_min_const_1 +integrable_neg +integrable_neg_eq +integrable_on_all_intervals_integrable_bound +integrable_on_const +integrable_on_empty +integrable_on_indicator +integrable_on_little_subintervals +integrable_on_negligible +integrable_on_null +integrable_on_open_interval +integrable_on_refl +integrable_on_subdivision +integrable_on_subinterval +integrable_on_subinterval_gen +integrable_on_subset +integrable_on_superset +integrable_pastecart_sym +integrable_reflect +integrable_reflect_gen +integrable_restrict +integrable_restrict_inter +integrable_restrict_univ +integrable_spike +integrable_spike_eq +integrable_spike_finite +integrable_spike_interior +integrable_spike_set +integrable_spike_set_eq +integrable_split +integrable_straddle +integrable_straddle_interval +integrable_stretch +integrable_sub +integrable_subinterval +integrable_subintervals_imp_measurable +integrable_translation +integrable_twizzle_eq +integrable_uniform_limit +integrable_union +integrable_union_eq +integrable_unions +integrable_unions_image +integrable_vsum +integral_0 +integral_add +integral_change_of_variables +integral_change_of_variables_linear +integral_cmul +integral_combine +integral_combine_division_bottomup +integral_combine_division_topdown +integral_combine_tagged_division_bottomup +integral_combine_tagged_division_topdown +integral_component +integral_component_lbound +integral_component_le +integral_component_le_ae +integral_component_pos +integral_component_ubound +integral_const +integral_const_gen +integral_convolution_sym +integral_countable_unions +integral_countable_unions_alt +integral_def +integral_diff +integral_drop_le +integral_drop_le_ae +integral_drop_le_measurable +integral_drop_pos +integral_drop_pos_ae +integral_empty +integral_eq +integral_eq_0 +integral_eq_has_integral +integral_has_vector_derivative +integral_has_vector_derivative_pointwise +integral_indicator +integral_intervals_diff_inclusion_exclusion +integral_intervals_inclusion_exclusion +integral_intervals_inclusion_exclusion_left +integral_intervals_inclusion_exclusion_right +integral_linear +integral_measure +integral_measure_univ +integral_neg +integral_norm_bound_integral +integral_norm_bound_integral_ae +integral_norm_bound_integral_component +integral_null +integral_on_negligible +integral_open_interval +integral_pastecart_const +integral_pastecart_continuous +integral_pastecart_sym +integral_pastecart_sym_univ +integral_refl +integral_reflect +integral_reflect_gen +integral_restrict +integral_restrict_eq +integral_restrict_inter +integral_restrict_univ +integral_rew +integral_spike +integral_spike_set +integral_split +integral_split_signed +integral_sub +integral_subset_component_le +integral_subset_drop_le +integral_subset_drop_le_ae +integral_swap_continuous +integral_translation +integral_twizzle_eq +integral_union +integral_unique +integral_vsum +integral_zero_on_subintervals_imp_zero_ae +integral_zero_on_subintervals_imp_zero_ae_alt +integration_by_parts +integration_by_parts_simple +integrity +inteq +inteqd +inteqi +inter +inter_aci +inter_assoc +inter_balls_eq_empty +inter_bigunion +inter_comm +inter_conic_hull +inter_conic_hull_subsets_convex_relative_frontier +inter_convex_hull_insert_relative_exterior +inter_countable +inter_cross +inter_empty +inter_finite +inter_idempot +inter_interior_unions_intervals +inter_interval +inter_interval_1 +inter_interval_mixed_eq_empty +inter_over_union +inter_pcross +inter_relative_frontier_conic_hull +inter_relative_interior_subset +inter_segment +inter_sing +inter_subset +inter_subset_eqn +inter_union +inter_union_compl +inter_unions +inter_univ +interior_affinity +interior_ball +interior_bijective_linear_image +interior_cball +interior_closed_eq_empty_as_frontier +interior_closed_interval +interior_closed_union_empty_interior +interior_closure +interior_closure_idemp +interior_closure_inter_open +interior_complement +interior_convex_hull_3 +interior_convex_hull_3_minimal +interior_convex_hull_eq_empty +interior_convex_hull_explicit +interior_convex_hull_explicit_minimal +interior_diff +interior_empty +interior_eq +interior_eq_empty +interior_eq_empty_alt +interior_eq_univ +interior_finite_inters +interior_frontier +interior_frontier_empty +interior_halfspace_component_ge +interior_halfspace_component_le +interior_halfspace_ge +interior_halfspace_le +interior_hyperplane +interior_image_subset +interior_injective_linear_image +interior_inter +interior_interior +interior_inters_subset +interior_interval +interior_limit_point +interior_maximal +interior_maximal_eq +interior_negations +interior_of_closure_of +interior_of_closure_of_idemp +interior_of_empty +interior_of_frontier_of +interior_of_frontier_of_empty +interior_of_injective_linear_image +interior_of_inter +interior_of_restrict +interior_of_subset +interior_of_translation +interior_of_triangle +interior_open +interior_pcross +interior_rectifiable_path_image +interior_scaling +interior_segment +interior_simplex_nonempty +interior_sing +interior_sphere +interior_standard_hyperplane +interior_std_simplex +interior_strip_component_le +interior_subset +interior_subset_relative_interior +interior_subset_union_intervals +interior_surjective_linear_image +interior_translation +interior_union_eq_empty +interior_unions_open_subsets +interior_unique +interior_univ +inters +inters_eq_univ +inters_faces_finite_altbound +inters_faces_finite_bound +inters_gspec +inters_image +inters_insert +inters_unions +intersection_of +intersection_of_mono +intersperse +interval +interval_1 +interval_bisection +interval_bisection_step +interval_bounds_empty_1 +interval_bounds_null_1 +interval_cases_1 +interval_contains_compact_neighbourhood +interval_doublesplit +interval_eq_empty +interval_eq_empty_1 +interval_eq_sing +interval_image_affinity_interval +interval_image_stretch_interval +interval_lowerbound +interval_lowerbound_1 +interval_lowerbound_nonempty +interval_ne_empty +interval_ne_empty_1 +interval_open_subset_closed +interval_real_interval +interval_sing +interval_split +interval_subdivision +interval_subset_is_interval +interval_subset_segment_1 +interval_translation +interval_upperbound +interval_upperbound_1 +interval_upperbound_nonempty +intex +intexab +intexrab +intfrac +intfrac2 +intfracq +intgru +intidg +intidl +intiin +intima0 +intimafv +intimag +intimasn +intimasn2 +intimass +intimass2 +intirr +intlewftc +intlidl +intmin +intmin2 +intmin3 +intmin4 +intminss +intn3an1d +intn3an2d +intn3an3d +intnan +intnand +intnanr +intnanrd +intnanrt +intnatn +intnex +into +inton +intop +intopsn +intopval +intpr +intpreima +intprg +intrnfi +intro +intro con +intro_tac +introduce +intros +intsal +intsaluni +intsn +intsng +intss +intss1 +intss2 +intssuni +intssuni2 +inttsk +intubeu +intuit +intuitionistic +intun +intunsn +intv +intwun +intxp +inundif +inuni +inunissunidif +inv1 +inv_image_equiv_on +inv_pre_eq +inv_pre_less +inv_pre_less_eq +invalid +invariant +invco +invcoisoid +invdif +invdisj +invdisjrab +inventory_optimization +inveq +inverse_function_c1 +inverse_function_theorem +inverse_function_theorem_affine +inverse_function_theorem_c1_pointwise +inverse_function_theorem_global +inverse_function_theorem_subspace +inverse_lipschitz_convex_spherical_projection +inverse_mod_rmul_eq +inversion +invertible_cmul +invertible_cofactor +invertible_covariance_rank +invertible_det_nz +invertible_diagonal_matrix +invertible_eigenvalues +invertible_eq_injective_and_surjective +invertible_i +invertible_imp_square_matrix +invertible_left_inverse +invertible_mat +invertible_matrix_inv +invertible_matrix_mul +invertible_nearby +invertible_nearby_onorm +invertible_neg +invertible_right_inverse +invertible_transp +invf +invf1o +invffval +invfn +invfuc +invfun +invfval +invghm +invginvrid +invid +invinv +inviso1 +inviso2 +invisoinvl +invisoinvr +invlmhm +involution_imp_homeomorphism +involution_imp_homeomorphism_gen +involutive +invoppggim +invpropd +invpropdlem +invrcl +invrcl2 +invrcn +invrcn2 +invrfval +invrpropd +invrvald +invss +invsym +invsym2 +inxp +inxp2 +inxpex +inxpold +inxprnres +inxpss +inxpss2 +inxpss3 +inxpssidinxp +inxpssres +inxpxrn +io +io1ii +io_monad +ioc0 +iocborel +ioccncflimc +iocgtlb +iocgtlbd +iocinico +iocinif +iocinioc2 +iocioodisjd +iocleub +iocleubd +iocmbl +iocmnfcld +iocnct +iocopn +iocopnst +iocpnfordt +iocssicc +iocssioo +iocssre +iocssxr +iocunico +iocval +ioin9i8 +ioo0 +ioo2bl +ioo2blex +iooabslt +iooborel +ioodisj +ioodvbdlimc1 +ioodvbdlimc1lem1 +ioodvbdlimc1lem2 +ioodvbdlimc2 +ioodvbdlimc2lem +iooelexlt +iooex +ioof +ioofun +ioogtlb +ioogtlbd +iooid +iooii +iooiinicc +iooiinioc +iooin +iooinlbub +ioojoin +iooltub +iooltubd +ioomax +ioombl +ioombl1 +ioombl1lem1 +ioombl1lem2 +ioombl1lem3 +ioombl1lem4 +ioomidp +ioon0 +ioonct +ioondisj1 +ioondisj2 +iooneg +ioontr +iooordt +ioopnfsup +ioopos +ioorcl +ioorcl2 +ioorebas +iooretop +ioorf +ioorinv +ioorinv2 +ioorp +ioorrnopn +ioorrnopnlem +ioorrnopnxr +ioorrnopnxrlem +ioorval +ioosconn +iooshf +iooshift +iooss1 +iooss2 +ioosscn +ioosshoi +ioossicc +ioossico +ioossioc +ioossioo +ioossioobi +ioossre +ioounsn +iooval +iooval2 +ioovolcl +ioovonmbl +ioran +iordsmo +iorlid +iota0def +iota0ndef +iota1 +iota2 +iota2d +iota2df +iota4 +iota4an +iota5 +iota5f +iotabi +iotabidv +iotabii +iotacl +iotaeq +iotaequ +iotaex +iotaexeu +iotain +iotaint +iotajust +iotan0 +iotan0aiotaex +iotanul +iotanul2 +iotasbc +iotasbc2 +iotasbc5 +iotasbcq +iotassuni +iotauni +iotauni2 +iotaval +iotaval2 +iotavalb +iotavalsb +ip0i +ip0l +ip0r +ip1i +ip1ilem +ip2di +ip2dii +ip2eq +ip2eqi +ip2i +ip2subdi +ipass +ipassi +ipasslem1 +ipasslem10 +ipasslem11 +ipasslem2 +ipasslem3 +ipasslem4 +ipasslem5 +ipasslem7 +ipasslem8 +ipasslem9 +ipassr +ipassr2 +ipblnfi +ipcau +ipcau2 +ipcj +ipcl +ipcn +ipcnd +ipcni +ipcnlem1 +ipcnlem2 +ipcnval +ipdi +ipdir +ipdiri +ipdirilem +ipeq0 +ipf +ipfeq +ipffn +ipffval +ipfval +ipge0 +ipid +ipidsq +ipiiie0 +ipipcj +ipndx +ipndxnbasendx +ipndxnmulrndx +ipndxnplusgndx +ipnm +ipo0 +ipobas +ipodrscl +ipodrsfi +ipodrsima +ipoglb +ipoglb0 +ipoglbdm +ipoglblem +ipole +ipolerval +ipolt +ipolub +ipolub0 +ipolub00 +ipolubdm +ipolublem +ipopos +iporthcom +ipostr +ipotset +ipoval +iprc +iprod +iprodcl +iprodclim +iprodclim2 +iprodclim3 +iprodefisum +iprodefisumlem +iprodfac +iprodgam +iprodmul +iprodn0 +iprodrecl +ipsaddg +ipsbase +ipsip +ipsmulr +ipssca +ipsstr +ipsubdi +ipsubdir +ipsvsca +ipval +ipval2 +ipval2lem2 +ipval2lem3 +ipval2lem4 +ipval3 +ipz +irec +iresn0n0 +irinitoringc +irngnminplynz +irngnzply1 +irngnzply1lem +irngss +irngssv +irngval +irradd +irrapx1 +irrapxlem1 +irrapxlem2 +irrapxlem3 +irrapxlem4 +irrapxlem5 +irrapxlem6 +irrdiff +irrdifflemf +irredcl +irredlmul +irredminply +irredmul +irredn0 +irredn1 +irredneg +irrednegb +irrednu +irrednzr +irredrmul +irrigation_scheduling +irrmul +is +is0trl +is0wlk +is1stc +is1stc2 +is2ndc +is_affine_hull +is_convex_hull +is_hull +is_interval_1 +is_interval_1_cases +is_interval_1_clauses +is_interval_closure +is_interval_compact +is_interval_connected +is_interval_connected_1 +is_interval_convex +is_interval_convex_1 +is_interval_empty +is_interval_imp_locally_compact +is_interval_inter +is_interval_interior +is_interval_interval +is_interval_locally_compact_interval +is_interval_pcross +is_interval_pcross_eq +is_interval_pointwise +is_interval_reflect +is_interval_relative_interior +is_interval_scaling +is_interval_scaling_eq +is_interval_sing +is_interval_sums +is_interval_translation +is_interval_translation_eq +is_interval_univ +is_measure_maximal_insert +is_realinterval_is_interval +is_some_opt_mmap +is_sorted_cons +is_trop_cno_intro +is_trop_cno_sq +is_trop_cno_star +isabl +isabl2 +isabld +isabli +isablo +isabloi +isabv +isabvd +isacn +isacs +isacs1i +isacs2 +isacs3 +isacs3lem +isacs4 +isacs4lem +isacs5 +isacs5lem +isacycgr +isacycgr1 +isalphanum_isprint +isanmbfm +isarchi +isarchi2 +isarchi3 +isarchiofld +isarep1 +isarep2 +isass +isassa +isassad +isassintop +isasslaw +isat +isat2 +isat3 +isatl +isausgr +isbasis2g +isbasis3g +isbasisg +isbasisrelowl +isbasisrelowllem1 +isbasisrelowllem2 +isblo +isblo2 +isblo3i +isbn +isbnd +isbnd2 +isbnd3 +isbnd3b +isbndx +iscard +iscard2 +iscard3 +iscard4 +iscard5 +iscat +iscatd +iscatd2 +iscau +iscau2 +iscau3 +iscau4 +iscauf +iscbn +iscfil +iscfil2 +iscfil3 +iscfilu +iscgra +iscgra1 +iscgrad +iscgrg +iscgrgd +iscgrglt +isch +isch2 +isch3 +ischn +isclat +isclatd +iscld +iscld2 +iscld3 +iscld4 +iscldtop +isclintop +iscllaw +isclm +isclmi +isclmi0 +isclmp +isclo +isclo2 +isclwlk +isclwlke +isclwlkupgr +isclwwlk +isclwwlkn +isclwwlknon +isclwwlknx +iscmd +iscmet +iscmet2 +iscmet3 +iscmet3i +iscmet3lem1 +iscmet3lem2 +iscmet3lem3 +iscmgmalt +iscmn +iscmnd +iscmp +iscms +iscn +iscn2 +iscncl +iscnp +iscnp2 +iscnp3 +iscnp4 +iscnrm +iscnrm2 +iscnrm3 +iscnrm3l +iscnrm3lem1 +iscnrm3lem2 +iscnrm3lem4 +iscnrm3lem5 +iscnrm3lem6 +iscnrm3lem7 +iscnrm3llem1 +iscnrm3llem2 +iscnrm3r +iscnrm3rlem1 +iscnrm3rlem2 +iscnrm3rlem3 +iscnrm3rlem4 +iscnrm3rlem5 +iscnrm3rlem6 +iscnrm3rlem7 +iscnrm3rlem8 +iscnrm3v +iscnrm4 +iscom2 +iscomlaw +isconn +isconn2 +isconngr +isconngr1 +isconstr +iscph +iscplgr +iscplgredg +iscplgrnb +iscrct +iscref +iscringd +iscrng +iscrng2 +iscrngd +iscrngo +iscrngo2 +iscsgrpalt +iscsrg +iscss +iscss2 +iscusgr +iscusgredg +iscusgrvtx +iscusp +iscusp2 +iscvlat +iscvlat2n +iscvm +iscvs +iscvsi +iscvsp +iscycl +iscyg +iscyg2 +iscyg3 +iscygd +iscyggen +iscyggen2 +iscygodd +isdiln +isdir +isdivrngo +isdlat +isdmn +isdmn2 +isdmn3 +isdomn +isdomn2 +isdomn2old +isdomn3 +isdomn4 +isdomn4r +isdomn5 +isdomn6 +isdrng +isdrng2 +isdrng4 +isdrngd +isdrngdold +isdrngo1 +isdrngo2 +isdrngo3 +isdrngrd +isdrngrdold +isdrs +isdrs2 +isepi +isepi2 +iseqlg +iseqlgd +iseqsetv-clel +iseqsetv-cleq +iseqsetvlem +iserabs +iseralt +iseraltlem1 +iseraltlem2 +iseraltlem3 +isercoll +isercoll2 +isercolllem1 +isercolllem2 +isercolllem3 +iserd +iserex +iserge0 +iseri +iserialt +iserle +isermulc2 +iserodd +isershft +iseupth +iseupthf1o +iseven +iseven2 +iseven5 +isevengcd2 +isewlk +isexid +isexid2 +isf32lem1 +isf32lem10 +isf32lem11 +isf32lem12 +isf32lem2 +isf32lem3 +isf32lem4 +isf32lem5 +isf32lem6 +isf32lem7 +isf32lem8 +isf32lem9 +isf33lem +isf34lem1 +isf34lem2 +isf34lem3 +isf34lem4 +isf34lem5 +isf34lem6 +isf34lem7 +isfbas +isfbas2 +isfcf +isfcls +isfcls2 +isffth2 +isfi +isfib_2_1 +isfib_6_8 +isfil +isfil2 +isfild +isfildlem +isfin1-2 +isfin1-3 +isfin1-4 +isfin1a +isfin2 +isfin2-2 +isfin3 +isfin3-2 +isfin3-3 +isfin3-4 +isfin32i +isfin3ds +isfin4 +isfin4-2 +isfin4p1 +isfin5 +isfin5-2 +isfin6 +isfin7 +isfin7-2 +isfinite +isfinite2 +isfinite4 +isfiniteg +isfld +isfld2 +isfldidl +isfldidl2 +isflf +isfmlasuc +isfne +isfne2 +isfne3 +isfne4 +isfne4b +isfrgr +isfsupp +isfsuppd +isfth +isfth2 +isfull +isfull2 +isfunc +isfuncd +isfusgr +isfusgrcl +isfusgrf1 +isfxp +isga +isgbe +isgbo +isgbow +isghm +isghm3 +isghmd +isghmold +isgim +isgim2 +isglbd +isgrim +isgrlim +isgrlim2 +isgrp +isgrpd +isgrpd2 +isgrpd2e +isgrpda +isgrpde +isgrpi +isgrpid2 +isgrpinv +isgrpix +isgrpo +isgrpoi +isgrtri +ishashinf +ishaus +ishaus2 +ishaus3 +ishexdigit_isalphanum +ishexdigit_isprint +ishil +ishil2 +ishl +ishl2 +ishlat1 +ishlat2 +ishlat3n +ishlatin +ishlg +ishlo +ishmeo +ishmo +ishpg +ishst +ishtpy +ishtpyd +isi1f +isibl +isibl2 +isidl +isidlc +isidom +isinag +isinagd +isinf +isinf2 +isinfcard +isinffi +isinftm +isinito +isinito2 +isinito2lem +isinito3 +isinito4 +isinito4a +isinitoi +isinv +isinv2 +isipodrs +isirred +isirred2 +isismt +isismty +isisod +isisubgr +isjustfromjust +iskgen2 +iskgen3 +islan +islan2 +islat +islaut +islbs +islbs2 +islbs3 +islbs4 +islbs5 +isldepslvec2 +isldil +isldsys +isleag +isleagd +islfl +islfld +islhp +islhp2 +islidl +islindeps +islindeps2 +islindf +islindf2 +islindf3 +islindf4 +islindf5 +islinds +islinds2 +islinds3 +islinds4 +islinds5 +isline +isline2 +isline3 +isline4n +islinei +islinindfis +islinindfiss +islininds +islininds2 +islln +islln2 +islln2a +islln3 +islln4 +islly +islly2 +islmd +islmhm +islmhm2 +islmhm3 +islmhmd +islmib +islmim +islmim2 +islmod +islmodd +islmodfg +islnm +islnm2 +islno +islnopp +islnoppd +islnr +islnr2 +islnr3 +islocfin +islp +islp2 +islp3 +islpcn +islpi +islpidl +islpir +islpir2 +islpln +islpln2 +islpln2a +islpln2ah +islpln3 +islpln4 +islpln5 +islpoldn +islpoln +islptre +islring +islsat +islsati +islshp +islshpat +islshpcv +islshpkrn +islshpsm +islss +islss3 +islss4 +islssd +islssfg +islssfg2 +islssfgi +islte +isltrn +isltrn2n +islvec +islvol +islvol2 +islvol2an +islvol3 +islvol4 +islvol5 +ismaxidl +ismbf +ismbf1 +ismbf2d +ismbf3d +ismbfcn +ismbfcn2 +ismbfd +ismbfm +ismbl +ismbl2 +ismbl3 +ismbl4 +ismblfin +ismea +ismeannd +ismeas +ismet +ismet2 +ismeti +ismfs +ismgm +ismgmalt +ismgmd +ismgmhm +ismgmid +ismgmid2 +ismgmn0 +ismgmold +ismhm +ismhm0 +ismhmd +ismhp +ismhp2 +ismhp3 +ismidb +ismir +ismnd +ismndd +ismnddef +ismndo +ismndo1 +ismndo2 +ismnt +ismntd +ismntop +ismntoplly +ismnu +ismnuprim +ismnushort +ismon +ismon1p +ismon2 +ismot +ismrc +ismrcd1 +ismrcd2 +ismre +ismred +ismred2 +ismrer1 +ismri +ismri2 +ismri2d +ismri2dad +ismri2dd +isms +isms2 +ismtybnd +ismtybndlem +ismtycnv +ismtyhmeo +ismtyhmeolem +ismtyima +ismtyres +ismtyval +ismxidl +isnacs +isnacs2 +isnacs3 +isnat +isnat2 +isnatd +isncvsngp +isncvsngpd +isnei +isneip +isnghm +isnghm2 +isnghm3 +isngp +isngp2 +isngp3 +isngp4 +isnirred +isnlly +isnlm +isnmgm +isnmhm +isnmhm2 +isnmnd +isnrg +isnrm +isnrm2 +isnrm3 +isnrm4 +isnsg +isnsg2 +isnsg3 +isnsg4 +isnsgrp +isnsqf +isnum2 +isnum3 +isnumbasabl +isnumbasgrp +isnumbasgrplem1 +isnumbasgrplem2 +isnumbasgrplem3 +isnumi +isnv +isnvc +isnvc2 +isnvi +isnvlem +isnzr +isnzr2 +isnzr2hash +iso +iso0 +iso_compose +iso_nat_list_unit +isoas +isobs +isocnv +isocnv2 +isocnv3 +isoco +isocoinvid +isodd +isodd2 +isodd3 +isodd7 +isoddgcd1 +isoeq1 +isoeq145d +isoeq2 +isoeq3 +isoeq4 +isoeq5 +isof1o +isof1oidb +isof1oopb +isofld +isofn +isofnalt +isofr +isofr2 +isofrlem +isofval +isofval2 +isogrp +isohom +isoid +isoini +isoini2 +isolat +isolatin +isolation_serializable +isome +isomennd +isomenndlem +isometric_homeomorphism_affine +isometries_subspaces +isometry_imp_affinity +isometry_imp_embedding +isometry_imp_homeomorphism_compact +isometry_imp_open_map +isometry_linear +isometry_on_imp_continuous_on +isometry_sphere_extend +isometry_subset_subspace +isometry_subspaces +isometry_univ_subspace +isometry_univ_superset_subspace +isometry_univ_univ +isomin +isoml +isomlin +isomnd +isomorphism +isomorphism_expand +isomorphisms_univ_univ +isopn2 +isopn3 +isopn3i +isopo +isopolem +isopos +isopropd +isopropdlem +isorcl +isorcl2 +isorel +isores1 +isores2 +isores3 +isorng +isort_count +isort_map_bij +isort_map_def +isort_sorted +isosctr +isosctrlem1 +isosctrlem1alt +isosctrlem2 +isosctrlem3 +isose +isoselem +isoso +isosolem +isotone1 +isotone2 +isotr +isoun +isoval +isoval2 +isowe +isowe2 +ispautn +ispcmp +ispconn +ispec +ispecl +isperf +isperf2 +isperf3 +isperp +isperp2 +isperp2d +ispgp +isph +isphg +isphl +isphld +isphtpc +isphtpy +isphtpy2d +isphtpyd +ispisys +ispisys2 +isplig +ispligb +ispnrm +ispod +ispointn +ispos +ispos2 +isposd +isposi +isposix +isppw +isppw2 +isprefix_antisym +isprefix_consr +isprefix_def +isprefix_genlist +isprefix_ind +isprefix_map +isprefix_nil +isprefix_refl +isprefix_snoc_eq +isprefix_strcat +isprefix_trans +ispridl +ispridl2 +ispridlc +isprimroot +isprimroot2 +isprm +isprm2 +isprm2lem +isprm3 +isprm4 +isprm5 +isprm6 +isprm7 +isprmidl +isprmidlc +isprrngo +isprs +isprsd +isps +ispsmet +ispsubcl2n +ispsubcln +ispsubsp +ispsubsp2 +isptfin +ispth +ispthson +isr0 +israg +isran +isran2 +isref +isreg +isreg2 +isrgr +isrhm +isrhm2d +isrhmd +isridl +isridlrng +isrim +isrim0 +isring +isringd +isringid +isringrng +isrisc +isriscg +isrng +isrngd +isrnghm +isrnghm2d +isrnghmd +isrnghmmul +isrngim +isrngim2 +isrngo +isrngod +isrngohom +isrngoiso +isrnmeas +isrnsiga +isrnsigau +isros +isrprm +isrrext +isrrg +isrrvv +isrusgr +isrusgr0 +iss +iss2 +issal +issald +issalgend +issalnnd +issconn +issdrg +issdrg2 +issect +issect2 +isset +issetf +issetft +isseti +issetid +issetlem +issetri +issetssr +issettru +issgon +issgrp +issgrpalt +issgrpd +issgrpn0 +issgrpv +issh +issh2 +issh3 +issibf +issiga +issimpg +issimpgd +isslmd +isslw +issmf +issmfd +issmfdf +issmfdmpt +issmff +issmfge +issmfgelem +issmfgt +issmfgtd +issmfgtlem +issmfle +issmfle2d +issmfled +issmflelem +issmflem +issmgrpold +issmo +issmo2 +issn +isso2i +issod +issoi +issply +isspth +isspthonpth +isspthson +issqf +issrg +issrgid +issrng +issrngd +issros +isssc +isssp +issstrmgm +isst +isstruct +isstruct2 +issubassa +issubassa2 +issubassa3 +issubc +issubc2 +issubc3 +issubdrg +issubg +issubg2 +issubg3 +issubg4 +issubgoilem +issubgr +issubgr2 +issubgrpd +issubgrpd2 +issubm +issubm2 +issubmd +issubmgm +issubmgm2 +issubmnd +issubmndb +issubrg +issubrg2 +issubrg3 +issubrgd +issubrng +issubrng2 +ist0 +ist0-2 +ist0-3 +ist0-4 +ist0cld +ist1 +ist1-2 +ist1-3 +ist1-5 +ist1-5lem +istdrg +istdrg2 +istendo +istendod +istermc +istermc2 +istermc3 +istermo +istermoi +istgp +istgp2 +isthinc +isthinc2 +isthinc3 +isthincd +isthincd2 +isthincd2lem1 +isthincd2lem2 +istlm +istmd +istop2g +istopclsd +istopg +istopon +istoprelowl +istos +istotbnd +istotbnd2 +istotbnd3 +istps +istps2 +istpsi +istrg +istrkg2d +istrkg2ld +istrkg3ld +istrkgb +istrkgc +istrkgcb +istrkge +istrkgl +istrkgld +istrl +istrlson +istrnn +istsr +istsr2 +istvc +isubgr0uhgr +isubgr3stgr +isubgr3stgrlem1 +isubgr3stgrlem2 +isubgr3stgrlem3 +isubgr3stgrlem4 +isubgr3stgrlem5 +isubgr3stgrlem6 +isubgr3stgrlem7 +isubgr3stgrlem8 +isubgr3stgrlem9 +isubgredg +isubgredgss +isubgrgrim +isubgriedg +isubgrsubgr +isubgruhgr +isubgrumgr +isubgrupgr +isubgrusgr +isubgrvtx +isubgrvtxuhgr +isuc1p +isucn +isucn2 +isufd +isufil +isufil2 +isufl +isuhgr +isuhgrop +isum +isum1p +isumadd +isumcl +isumclim +isumclim2 +isumclim3 +isumdivc +isumge0 +isumgr +isumgrs +isumle +isumless +isumltss +isummulc1 +isummulc2 +isumneg +isumnn0nn +isumrecl +isumrpcl +isumshft +isumsplit +isumsup +isumsup2 +isunit +isunit2 +isunit3 +isup +isup2 +isupgr +isuplem +isupwlk +isupwlkg +isusgr +isusgrop +isusgrs +isushgr +isusp +isuspgr +isuspgrim +isuspgrim0 +isuspgrim0lem +isuspgrimlem +isuspgrop +isust +isuvtx +isvciold +isvclem +isvcold +isvonmbl +iswatn +iswlk +iswlkg +iswlkon +iswrd +iswrdb +iswrddm0 +iswrdi +iswrdsymb +iswspthn +iswspthsnon +iswun +iswwlks +iswwlksn +iswwlksnon +iswwlksnx +isxmet +isxmet2d +isxmetd +isxms +isxms2 +iszeroi +iszeroo +it0e0 +it1ei +itcoval +itcoval0 +itcoval0mpt +itcoval1 +itcoval2 +itcoval3 +itcovalendof +itcovalpc +itcovalpclem1 +itcovalpclem2 +itcovalsuc +itcovalsucov +itcovalt2 +itcovalt2lem1 +itcovalt2lem2 +itcovalt2lem2lem1 +itcovalt2lem2lem2 +iter +iter_pointless +iterate_and +iterate_clauses +iterate_image +iterate_nonzero_image_lemma +iterate_permute +iterate_reflect +iterate_some +iterate_support +iteratehead +itg0 +itg10 +itg10a +itg11 +itg1add +itg1addlem1 +itg1addlem2 +itg1addlem3 +itg1addlem4 +itg1addlem5 +itg1cl +itg1climres +itg1ge0 +itg1ge0a +itg1le +itg1lea +itg1mulc +itg1sub +itg1val +itg1val2 +itg20 +itg2add +itg2addlem +itg2addnc +itg2addnclem +itg2addnclem2 +itg2addnclem3 +itg2cl +itg2cn +itg2cnlem1 +itg2cnlem2 +itg2const +itg2const2 +itg2eqa +itg2ge0 +itg2gt0 +itg2gt0cn +itg2i1fseq +itg2i1fseq2 +itg2i1fseq3 +itg2i1fseqle +itg2itg1 +itg2l +itg2lcl +itg2le +itg2lea +itg2lecl +itg2leub +itg2lr +itg2mono +itg2monolem1 +itg2monolem2 +itg2monolem3 +itg2mulc +itg2mulclem +itg2seq +itg2split +itg2splitlem +itg2ub +itg2uba +itg2val +itgabs +itgabsnc +itgadd +itgaddlem1 +itgaddlem2 +itgaddnc +itgaddnclem1 +itgaddnclem2 +itgcl +itgcn +itgcnlem +itgcnval +itgconst +itgcoscmulx +itgeq1 +itgeq12dv +itgeq12i +itgeq12sdv +itgeq1d +itgeq1f +itgeq1fold +itgeq1i +itgeq2 +itgeq2dv +itgeq2i +itgeq2sdv +itgeqa +itgex +itgexpif +itgfsum +itgge0 +itggt0 +itggt0cn +itgiccshift +itgim +itgioo +itgioocnicc +itgitg1 +itgitg2 +itgle +itgless +itgmpt +itgmulc2 +itgmulc2lem1 +itgmulc2lem2 +itgmulc2nc +itgmulc2nclem1 +itgmulc2nclem2 +itgneg +itgocn +itgoss +itgoval +itgparts +itgperiod +itgposval +itgpowd +itgre +itgrecl +itgresr +itgreval +itgrevallem1 +itgsbtaddcnst +itgsin0pi +itgsin0pilem1 +itgsincmulx +itgsinexp +itgsinexplem1 +itgsplit +itgspliticc +itgsplitioo +itgspltprt +itgss +itgss2 +itgss3 +itgsub +itgsubnc +itgsubst +itgsubsticc +itgsubsticclem +itgsubstlem +itgulm +itgulm2 +itgvallem +itgvallem3 +itgvol0 +itgz +itlist +itlist2_0_lemma +itrere +itschlc0xyqsol +itschlc0xyqsol1 +itschlc0yqe +itsclc0 +itsclc0b +itsclc0lem1 +itsclc0lem2 +itsclc0lem3 +itsclc0xyqsol +itsclc0xyqsolb +itsclc0xyqsolr +itsclc0yqe +itsclc0yqsol +itsclc0yqsollem1 +itsclc0yqsollem2 +itsclinecirc0 +itsclinecirc0b +itsclinecirc0in +itsclquadb +itsclquadeu +itscnhlc0xyqsol +itscnhlc0yqe +itscnhlinecirc02p +itscnhlinecirc02plem1 +itscnhlinecirc02plem2 +itscnhlinecirc02plem3 +itset_cong +itset_eq_foldl_set_to_list +itset_insert +itset_property +itset_reduction +ituni0 +itunifn +itunifval +ituniiun +itunisuc +itunitc +itunitc1 +itvid +itvndx +iun0 +iunab +iuncld +iuncom +iuncom4 +iunconn +iunconnalt +iunconnlem +iunconnlem2 +iunconst +iunctb +iunctb2 +iundif1 +iundif2 +iundifdif +iundifdifd +iundisj +iundisj2 +iundisj2cnt +iundisj2f +iundisj2fi +iundisjcnt +iundisjf +iundisjfi +iundjiun +iundjiunlem +iundom +iundom2g +iundomg +iuneq0 +iuneq1 +iuneq12d +iuneq12daf +iuneq12df +iuneq12dold +iuneq12f +iuneq12i +iuneq1d +iuneq1i +iuneq2 +iuneq2d +iuneq2df +iuneq2dv +iuneq2f +iuneq2i +iuneqconst +iuneqconst2 +iuneqfzuz +iuneqfzuzlem +iunex +iunexg +iunfi +iunfictbso +iunfo +iunhoiioo +iunhoiioolem +iunid +iuniin +iunin1 +iunin1f +iunin2 +iuninc +iunincfi +iunlub +iunmapdisj +iunmapsn +iunmapss +iunmbl +iunmbl2 +iunn0 +iunocv +iunon +iunopab +iunopeqop +iunopn +iunord +iunordi +iunp1 +iunpreima +iunpw +iunpwss +iunrab +iunrdx +iunrelexp0 +iunrelexpmin1 +iunrelexpmin2 +iunrelexpuztr +iunrnmptss +iunsn +iunsnima +iunsnima2 +iunss +iunss1 +iunss2 +iunssd +iunssdf +iunssf +iunssfold +iunssold +iunsuc +iunun +iununi +iunxdif2 +iunxdif3 +iunxiun +iunxpconst +iunxpf +iunxprg +iunxpssiun1 +iunxsn +iunxsnf +iunxsng +iunxsngf +iunxun +iunxunpr +iunxunsn +ivt +ivt_decreasing_component_1 +ivt_decreasing_component_on_1 +ivt_increasing +ivt_increasing_component_1 +ivt_increasing_component_on_1 +ivth +ivth2 +ivthalt +ivthicc +ivthle +ivthle2 +ivthlem1 +ivthlem2 +ivthlem3 +iwrdsplit +ixi +ixp0 +ixp0x +ixpconst +ixpconstg +ixpeq1 +ixpeq12dv +ixpeq12i +ixpeq1d +ixpeq1i +ixpeq2 +ixpeq2d +ixpeq2dv +ixpeq2dva +ixpexg +ixpf +ixpfi +ixpfi2 +ixpfn +ixpiin +ixpin +ixpint +ixpiunwdom +ixpn0 +ixpprc +ixpsnbasval +ixpsnf1o +ixpsnval +ixpssixp +ixpssmap +ixpssmap2g +ixpssmapc +ixpssmapg +ixpv +ixxdisj +ixxex +ixxf +ixxin +ixxlb +ixxss1 +ixxss12 +ixxss2 +ixxssixx +ixxssxr +ixxub +ixxun +ixxval +ja +jaao +jabtaib +jacobian_sign_invariance +jacobian_works +jad +jao +jao1i +jaoa +jaob +jaod +jaodan +jaodd +jaoded +jaoi +jaoi2 +jaoi3 +jaoian +jarl +jarli +jarr +jarri +jarrii +jath +jc +jca +jca2 +jca2r +jca3 +jca31 +jca32 +jcab +jcad +jcai +jccil +jccir +jcn +jcnd +jctil +jctild +jctir +jctird +jctl +jctr +jech9.3 +jensen +jensenlem1 +jensenlem2 +jewell +jm2.15nn0 +jm2.16nn0 +jm2.17a +jm2.17b +jm2.17c +jm2.18 +jm2.19 +jm2.19lem1 +jm2.19lem2 +jm2.19lem3 +jm2.19lem4 +jm2.20nn +jm2.21 +jm2.22 +jm2.23 +jm2.24 +jm2.24nn +jm2.25 +jm2.25lem1 +jm2.26 +jm2.26a +jm2.26lem3 +jm2.27 +jm2.27a +jm2.27b +jm2.27c +jm2.27dlem1 +jm2.27dlem2 +jm2.27dlem3 +jm2.27dlem4 +jm2.27dlem5 +jm3.1 +jm3.1lem1 +jm3.1lem2 +jm3.1lem3 +job_shop_scheduling +join0 +joinable_components_eq +joinable_connected_component_eq +joincl +joincom +joincomalt +joindef +joindm +joindm2 +joindm3 +joindmss +joineu +joinfval +joinfval2 +joiniooico +joinle +joinlem +joinlmuladdmuld +joinlmuladdmuli +joinlmulsubmuld +joinlmulsubmuli +joinval +joinval2 +joinval2lem +jonathan +jpi +jplem1 +jplem2 +judgement +jumpncnp +jung +k0004lem1 +k0004lem2 +k0004lem3 +k0004ss1 +k0004ss2 +k0004ss3 +k0004val +k0004val0 +k_3 +k_space_euclidean +k_space_mtopology +k_subset +k_tac +kakuro +kall_tac +karatsuba +karden +kardex +kbass1 +kbass2 +kbass3 +kbass4 +kbass5 +kbass6 +kbfval +kbmul +kbop +kbpj +kbval +kc_space_euclidean +kc_space_mtopology +kc_space_subtopology +kcnktkm1cn +kdf_extract_length +keephyp +keephyp2v +keephyp3v +kelac1 +kelac2 +kelac2lem +kenken +kercvrlsm +kerf1ghm +keridl +kerlidl +kerlmhm +kernel_matrix_inv +kernel_normal +kernelaxiom +kerunit +kgen2cn +kgen2ss +kgencmp +kgencmp2 +kgencn +kgencn2 +kgencn3 +kgenf +kgenftop +kgenhaus +kgeni +kgenidm +kgenss +kgentop +kgentopon +kgenuni +kgenval +kill_tac +kind_to_u8 +kirch_lemma +kirchberger +kirszbraun +kleene_normal +kleenerecursion +kmlem1 +kmlem10 +kmlem11 +kmlem12 +kmlem13 +kmlem14 +kmlem15 +kmlem16 +kmlem2 +kmlem3 +kmlem4 +kmlem5 +kmlem6 +kmlem7 +kmlem8 +kmlem9 +knapsack_01 +knatar +knoppcld +knoppcn +knoppcn2 +knoppcnlem1 +knoppcnlem10 +knoppcnlem11 +knoppcnlem2 +knoppcnlem3 +knoppcnlem4 +knoppcnlem5 +knoppcnlem6 +knoppcnlem7 +knoppcnlem8 +knoppcnlem9 +knoppf +knoppndv +knoppndvlem1 +knoppndvlem10 +knoppndvlem11 +knoppndvlem12 +knoppndvlem13 +knoppndvlem14 +knoppndvlem15 +knoppndvlem16 +knoppndvlem17 +knoppndvlem18 +knoppndvlem19 +knoppndvlem2 +knoppndvlem20 +knoppndvlem21 +knoppndvlem22 +knoppndvlem3 +knoppndvlem4 +knoppndvlem5 +knoppndvlem6 +knoppndvlem7 +knoppndvlem8 +knoppndvlem9 +know_tac +known +koenigslemma +koenigslemma_wf +konigsberg +konigsbergiedg +konigsbergiedgw +konigsberglem1 +konigsberglem2 +konigsberglem3 +konigsberglem4 +konigsberglem5 +konigsbergssiedgw +konigsbergssiedgwpr +konigsbergumgr +konigsbergvtx +konigth +konigthlem +kqcld +kqcldsat +kqdisj +kqf +kqfeq +kqffn +kqfval +kqfvima +kqhmph +kqid +kqnrm +kqnrmlem1 +kqnrmlem2 +kqopn +kqreg +kqreglem1 +kqreglem2 +kqsat +kqt0 +kqt0lem +kqtop +kqtopon +kqval +kraft +kraft_inequality +krein_milman +krein_milman_eq +krein_milman_frontier +krein_milman_minkowski +krein_milman_polytope +krein_milman_relative_boundary +krein_milman_relative_frontier +kripke +kripke_model +kripke_schema +krippen +krippenlem +krull +krullndrng +kur14 +kur14lem1 +kur14lem10 +kur14lem2 +kur14lem3 +kur14lem4 +kur14lem5 +kur14lem6 +kur14lem7 +kur14lem8 +kur14lem9 +kx_predn +kxy_predn +l +l1 +l1_le_norm +l1_spec +l1cvat +l1cvpat +l2 +l2p +l3 +l_trunc1 +lab_rotation +label +label_abbrev_tac +label_tac +lactghmga +lactlmhm +laddrotrd +lagrange +lagsubg +lagsubg2 +lambda +lambda x. +lambda y. +lambda_add_galois +lambda_beta +lambda_beta_perm +lambda_eta +lambda_pair +lambda_pair_thm +lambda_skolem +lambda_swap_galois +lambert0 +lamberte +land_conv +lanfn +lanfval +lanpropd +lanrcl +lanrcl2 +lanrcl3 +lanrcl4 +lanrcl5 +lanup +lanval +lanval2 +largei +last +last_append +last_compute +last_cons_cond +last_drop +last_el +last_in_set +last_reverse +lastislargest +latabs1 +latabs2 +latasym +latasymb +latasymd +latcl2 +latdisd +latdisdlem +later +latin_square +latj12 +latj13 +latj31 +latj32 +latj4 +latj4rot +latjass +latjcl +latjcom +latjidm +latjjdi +latjjdir +latjle12 +latjlej1 +latjlej12 +latjlej2 +latjrot +latledi +latleeqj1 +latleeqj2 +latleeqm1 +latleeqm2 +latlej1 +latlej2 +latlem +latlem12 +latm12 +latm32 +latm4 +latmass +latmassold +latmcl +latmcom +latmidm +latmle1 +latmle2 +latmlej11 +latmlej12 +latmlej21 +latmlej22 +latmlem1 +latmlem12 +latmlem2 +latmmdin +latmmdir +latmrot +latnle +latnlej +latnlej1l +latnlej1r +latnlej2 +latnlej2l +latnlej2r +latnlemlt +latpos +latref +lattice_absorption_join +lattice_absorption_meet +lattice_bounded +lattice_complemented +lattice_distributive +lattice_join_assoc +lattice_join_comm +lattice_meet_assoc +lattice_meet_comm +lattice_modular +lattr +lattrd +laut11 +laut1o +lautcl +lautcnv +lautcnvcln +lautcnvle +lautco +lautcvr +lauteq +lautj +lautle +lautlt +lautm +lautset +lavrentiev +lavrentiev_borel +lavrentiev_extension +lavrentiev_homeomorphism +lavrentiev_homeomorphism_self +lawcos +lawcoslem1 +lbcl +lbfzo0 +lbicc2 +lbico1 +lbinf +lbinfcl +lbinfle +lbioc +lbioo +lble +lbreu +lbsacsbs +lbsdiflsp0 +lbsel +lbsex +lbsexg +lbsext +lbsextg +lbsextlem1 +lbsextlem2 +lbsextlem3 +lbsextlem4 +lbsind +lbsind2 +lbslcic +lbslelsp +lbslinds +lbslsat +lbslsp +lbspropd +lbspss +lbssp +lbsss +lbzbi +lcd0 +lcd0v +lcd0v2 +lcd0vcl +lcd0vs +lcd0vvaln +lcd1 +lcdfval +lcdlkreq2n +lcdlkreqn +lcdlmod +lcdlsp +lcdlss +lcdlss2n +lcdlssvscl +lcdlvec +lcdneg +lcdsadd +lcdsbase +lcdsca +lcdsmul +lcdvadd +lcdvaddval +lcdval +lcdval2 +lcdvbase +lcdvbasecl +lcdvbaselfl +lcdvbasess +lcdvs +lcdvs0n +lcdvsass +lcdvscl +lcdvsub +lcdvsubval +lcdvsval +lcf1o +lcfl1 +lcfl1lem +lcfl2 +lcfl3 +lcfl4n +lcfl5 +lcfl5a +lcfl6 +lcfl6lem +lcfl7lem +lcfl7n +lcfl8 +lcfl8a +lcfl8b +lcfl9a +lcfls1c +lcfls1lem +lcfls1n +lcfr +lcfrlem1 +lcfrlem10 +lcfrlem11 +lcfrlem12n +lcfrlem13 +lcfrlem14 +lcfrlem15 +lcfrlem16 +lcfrlem17 +lcfrlem18 +lcfrlem19 +lcfrlem2 +lcfrlem20 +lcfrlem21 +lcfrlem22 +lcfrlem23 +lcfrlem24 +lcfrlem25 +lcfrlem26 +lcfrlem27 +lcfrlem28 +lcfrlem29 +lcfrlem3 +lcfrlem30 +lcfrlem31 +lcfrlem32 +lcfrlem33 +lcfrlem34 +lcfrlem35 +lcfrlem36 +lcfrlem37 +lcfrlem38 +lcfrlem39 +lcfrlem4 +lcfrlem40 +lcfrlem41 +lcfrlem42 +lcfrlem5 +lcfrlem6 +lcfrlem7 +lcfrlem8 +lcfrlem9 +lcfrvalsnn +lclkr +lclkrlem1 +lclkrlem2 +lclkrlem2a +lclkrlem2b +lclkrlem2c +lclkrlem2d +lclkrlem2e +lclkrlem2f +lclkrlem2g +lclkrlem2h +lclkrlem2i +lclkrlem2j +lclkrlem2k +lclkrlem2l +lclkrlem2m +lclkrlem2n +lclkrlem2o +lclkrlem2p +lclkrlem2q +lclkrlem2r +lclkrlem2s +lclkrlem2t +lclkrlem2u +lclkrlem2v +lclkrlem2w +lclkrlem2x +lclkrlem2y +lclkrs +lclkrs2 +lclkrslem1 +lclkrslem2 +lcm0val +lcm1 +lcm1un +lcm2un +lcm3un +lcm4un +lcm5un +lcm6un +lcm7un +lcm8un +lcmabs +lcmass +lcmcl +lcmcllem +lcmcom +lcmdvds +lcmdvdsb +lcmeprodgcdi +lcmeq0 +lcmf +lcmf0 +lcmf0val +lcmf2a3a4e12 +lcmfass +lcmfcl +lcmfcllem +lcmfdvds +lcmfdvdsb +lcmfeq0b +lcmfledvds +lcmflefac +lcmfn0cl +lcmfn0val +lcmfnncl +lcmfnnval +lcmfpr +lcmfsn +lcmftp +lcmfun +lcmfunnnd +lcmfunsn +lcmfunsnlem +lcmfunsnlem1 +lcmfunsnlem2 +lcmfunsnlem2lem1 +lcmfunsnlem2lem2 +lcmfval +lcmgcd +lcmgcdeq +lcmgcdlem +lcmgcdnn +lcmid +lcmineqlem +lcmineqlem1 +lcmineqlem10 +lcmineqlem11 +lcmineqlem12 +lcmineqlem13 +lcmineqlem14 +lcmineqlem15 +lcmineqlem16 +lcmineqlem17 +lcmineqlem18 +lcmineqlem19 +lcmineqlem2 +lcmineqlem20 +lcmineqlem21 +lcmineqlem22 +lcmineqlem23 +lcmineqlem3 +lcmineqlem4 +lcmineqlem5 +lcmineqlem6 +lcmineqlem7 +lcmineqlem8 +lcmineqlem9 +lcmledvds +lcmn0cl +lcmn0val +lcmneg +lcmval +lco0 +lcoc0 +lcoel0 +lcomf +lcomfsupp +lcoop +lcosn0 +lcoss +lcosslsp +lcoval +lcv1 +lcv2 +lcvat +lcvbr +lcvbr2 +lcvbr3 +lcvexch +lcvexchlem1 +lcvexchlem2 +lcvexchlem3 +lcvexchlem4 +lcvexchlem5 +lcvfbr +lcvnbtwn +lcvnbtwn2 +lcvnbtwn3 +lcvntr +lcvp +lcvpss +ldepslinc +ldepsnlinc +ldepsnlinclem1 +ldepsnlinclem2 +ldepspr +ldepsprlem +ldgenpisys +ldgenpisyslem1 +ldgenpisyslem2 +ldgenpisyslem3 +ldil1o +ldilcnv +ldilco +ldilfset +ldillaut +ldilset +ldilval +ldiv +ldlfcntref +ldsysgenld +ldual0 +ldual0v +ldual0vcl +ldual0vs +ldual1 +ldual1dim +ldualelvbase +ldualfvadd +ldualfvs +ldualgrp +ldualgrplem +ldualkrsc +lduallkr3 +lduallmod +lduallmodlem +lduallvec +ldualneg +ldualsaddn +ldualsbase +ldualsca +ldualset +ldualsmul +ldualssvscl +ldualssvsubcl +ldualvadd +ldualvaddcl +ldualvaddcom +ldualvaddval +ldualvbase +ldualvs +ldualvsass +ldualvsass2 +ldualvscl +ldualvsdi1 +ldualvsdi2 +ldualvsub +ldualvsubcl +ldualvsubval +ldualvsval +le +le0neg1 +le0neg1d +le0neg2 +le0neg2d +le2add +le2addd +le2addi +le2halvesd +le2msq +le2msqi +le2sq +le2sq2 +le2sqd +le2sqi +le2sub +le2subd +le2tri3i +le9lt10 +le_0_n +le_abs +le_abs_bounds +le_add +le_add_rcancel +le_antisym +le_antisymm +le_asym +le_c +le_cases +le_exists +le_int +le_lt +le_lt1 +le_lt_or_eq +le_mult_ceiling_div +le_mult_lcancel +le_mult_rcancel +le_n +le_n_s +le_num_ceiling +le_posinf +le_rat +le_refl +le_s +le_sub_lcancel +le_sub_rcancel +le_suc_lt +le_trans +leabs +leabsd +leabsi +leabss +leadd1 +leadd1d +leadd1dd +leadd1i +leadd2 +leadd2d +leadd2dd +leadd2i +leaddle0 +leadds1 +leadds1d +leadds1im +leadds2 +leadds2d +leadds2im +leaddsub +leaddsub2 +leaddsub2d +leaddsuble +leagne1 +leagne2 +leagne3 +leagne4 +lean +lean4 +least_elim_tac +leat +leat2 +leat3 +leatb +lebesgue_density_theorem_integral_ball +lebesgue_density_theorem_integral_cball +lebesgue_density_theorem_integral_norm_ball +lebesgue_density_theorem_integral_norm_cball +lebesgue_density_theorem_lift_ball +lebesgue_density_theorem_lift_cball +lebesgue_differentiation_theorem +lebesgue_differentiation_theorem_alt +lebesgue_differentiation_theorem_compact +lebesgue_differentiation_theorem_decreasing +lebesgue_differentiation_theorem_gen +lebesgue_differentiation_theorem_increasing +lebesgue_measurable_almost_fsigma +lebesgue_measurable_almost_gdelta +lebesgue_measurable_ball +lebesgue_measurable_cball +lebesgue_measurable_closed +lebesgue_measurable_closed_in +lebesgue_measurable_compact +lebesgue_measurable_compl +lebesgue_measurable_continuous_image +lebesgue_measurable_convex +lebesgue_measurable_countable_inters +lebesgue_measurable_countable_inters_explicit +lebesgue_measurable_countable_unions +lebesgue_measurable_countable_unions_explicit +lebesgue_measurable_delete +lebesgue_measurable_diff +lebesgue_measurable_differentiable_image +lebesgue_measurable_domain_of_injectivity +lebesgue_measurable_empty +lebesgue_measurable_function_ordinate_set_le +lebesgue_measurable_function_ordinate_set_lt +lebesgue_measurable_iff_measurable +lebesgue_measurable_inner_closed +lebesgue_measurable_inner_compact +lebesgue_measurable_insert +lebesgue_measurable_inter +lebesgue_measurable_inters +lebesgue_measurable_interval +lebesgue_measurable_jordan +lebesgue_measurable_linear_image_eq +lebesgue_measurable_linear_image_eq_gen +lebesgue_measurable_linear_image_gen +lebesgue_measurable_lipschitz_image +lebesgue_measurable_locally_lipschitz_image +lebesgue_measurable_measurable_inter_eq +lebesgue_measurable_measurable_on_subintervals +lebesgue_measurable_negligible_symdiff +lebesgue_measurable_negligible_symdiff_eq +lebesgue_measurable_on_subintervals +lebesgue_measurable_open +lebesgue_measurable_open_in +lebesgue_measurable_outer_open +lebesgue_measurable_pcross +lebesgue_measurable_points_of_convergence +lebesgue_measurable_points_of_differentiability_at +lebesgue_measurable_preimage_analytic +lebesgue_measurable_preimage_borel +lebesgue_measurable_preimage_card_le +lebesgue_measurable_preimage_closed +lebesgue_measurable_preimage_finite +lebesgue_measurable_preimage_has_size +lebesgue_measurable_preimage_infinite +lebesgue_measurable_preimage_open +lebesgue_measurable_regular_inner +lebesgue_measurable_regular_outer +lebesgue_measurable_small_imp_negligible +lebesgue_measurable_translation +lebesgue_measurable_union +lebesgue_measurable_unions +lebesgue_measurable_univ +lebesgue_number +lebnum +lebnumii +lebnumlem1 +lebnumlem2 +lebnumlem3 +lecasei +leceifl +lecldbas +lecm +lecmi +lecmii +lecmtn +ledi +ledii +lediri +lediv1 +lediv12a +lediv12ad +lediv1d +lediv1dd +lediv2 +lediv23 +lediv23d +lediv2a +lediv2aalt +lediv2ad +lediv2d +ledivdiv +ledivdivd +ledivge1le +ledivmul +ledivmul2 +ledivmul2d +ledivmuld +ledivp1 +ledivp1i +ledm +leeq1d +leeq2d +leex +leexp1a +leexp1ad +leexp2 +leexp2a +leexp2ad +leexp2d +leexp2r +leexp2rd +lefld +lefldiveq +left +left-identity-of-* +left0s +left1s +left_add_distrib +left_and_exists_thm +left_and_forall_thm +left_distrib +left_exists_and_thm +left_forall_imp_thm +left_imp_exists_thm +left_imp_forall_thm +left_inverse_linear +left_invertible_transp +left_limit_alt +left_limit_within_alt +left_or_distrib +left_polar_decomposition +left_polar_decomposition_invertible +left_polar_decomposition_invertible_unique +left_polar_decomposition_unique +left_right_inverse_eq +left_right_inverse_linear +left_sub_distrib +leftf +leftirr +leftlt +leftno +leftnod +leftold +leftoldd +leftsappend +leftssno +leftssold +leftval +leg0 +legbtwn +legeq +legid +legov +legov2 +legov3 +legso +legtrd +legtri3 +legtrid +legval +leibpi +leibpilem1 +leibpilem2 +leibpisum +leid +leidd +leidi +leiso +leisorel +lejdii +lejdiri +lejoin1 +lejoin2 +leloe +leloed +leloei +leltadd +leltaddd +leltletr +leltne +leltned +leltstr +leltstrd +lelttr +lelttrd +lelttrdi +lelttri +lelttric +lem +lem1 +lem1d +lem_implies_dne +lemaxle +lemeet1 +lemeet2 +lemin +lemma +lemma0 +lemma1 +lemma_existence +lemma_spec +lemsuccf +lemul1 +lemul12a +lemul12ad +lemul12b +lemul12bd +lemul1a +lemul1ad +lemul1d +lemul1i +lemul2 +lemul2a +lemul2ad +lemul2d +lemul2i +lemuldiv +lemuldiv2 +lemuldiv2d +lemuldiv3d +lemuldiv4d +lemuldivd +lemulge11 +lemulge11d +lemulge12 +lemulge12d +lemuls1ad +lemuls1d +lemuls2d +lemulsd +len-append +len-nonnegative +len-of-append +len-of-cons +len-of-rev +len-revappend +len-when-atom +len-when-consp +len0nnbi +len_eq_part +len_length_lem +lencl +lenco +leneg +leneg2d +leneg3d +lenegcon1 +lenegcon1d +lenegcon1i +lenegcon2 +lenegcon2d +lenegd +lenegi +lenegs +lenegsd +lenegsq +lenelioc +leneltd +length +length-append +length1 +length2 +length_app +length_append +length_append_thm +length_cons +length_dropwhile_less_eq +length_eq_1 +length_eq_cons +length_eq_nil +length_eq_num +length_eq_sum +length_filter_le +length_filter_leq_mono +length_front +length_len +length_linear_image +length_lt_shortlex +length_map +length_mappartial +length_nil +length_non_nil +length_nub_append +length_o_reverse +length_replicate +length_rev +length_reverse +length_singleton +length_take_eq +length_tl_le +length_translation +length_unzip +length_zip +lengthappend +lengthreplicate +lenlt +lenltd +lenlteq +lenlti +lenlts +lennncl +lenpfxcctswrd +lenrevpfxcctswrd +lensymd +leop +leop2 +leop3 +leopadd +leopg +leopmul +leopmul2i +leopmuli +leopnmid +leoppos +leoprf +leoprf2 +leopsq +leoptr +leoptri +leord1 +leord2 +leordtval +leordtval2 +leordtvallem1 +leordtvallem2 +lep1 +lep1d +leq +leq-refl +leq-trans +leq_refl +leq_trans +lerabdioph +lerec +lerec2 +lerec2d +lerecd +lereci +lerel +lerelxr +lermxnn0 +lermy +lern +lesid +lesloe +lesloed +leslss +lesnltd +lesrec +lesrecd +less +less_0_cases +less_add +less_add_1 +less_add_nonzero +less_add_suc +less_antisym +less_card_diff +less_cases +less_cases_imp +less_eq +less_eq_0 +less_eq_add +less_eq_add_exists +less_eq_add_sub +less_eq_antisym +less_eq_exists +less_eq_iff_less_suc +less_eq_imp_less_suc +less_eq_less_eq_mono +less_eq_less_trans +less_eq_mono +less_eq_mono_add_eq +less_eq_refl +less_eq_sub_less +less_eq_suc +less_eq_suc_refl +less_eq_trans +less_equal_add +less_equal_antisym +less_equal_diff +less_exp_suc_mono +less_imp_less_add +less_imp_less_or_eq +less_less_cases +less_less_eq_trans +less_less_suc +less_mod +less_mono_add +less_mono_add_eq +less_mono_add_inv +less_mono_mult +less_mono_mult2 +less_mult2 +less_mult_mono +less_not_suc +less_or +less_or_eq_add +less_or_eq_alt +less_strong_add +less_sub_add_less +less_suc +less_suc_eq_cor +less_suc_not +less_suc_refl +less_trans +lestr +lestrd +lestri3 +lestri3d +lestric +lesub +lesub0 +lesub0i +lesub1 +lesub1d +lesub1dd +lesub2 +lesub2d +lesub2dd +lesub3d +lesubadd +lesubadd2 +lesubadd2d +lesubadd2i +lesubaddd +lesubaddi +lesubaddsd +lesubd +lesubsd +lesubsubs2bd +lesubsubs3bd +lesubsubsbd +let +let_antisym +let_def +let_end_def +let_tac +let_trans +letop +letopon +letopuni +letr +letrd +letri +letri3 +letri3d +letri3i +letric +letrid +letrii +letrp1 +letsr +level +leweon +lex +lfgredgge2 +lfgriswlk +lfgrn1cycl +lfgrnloop +lfgrwlknloop +lfgrwlkprop +lfinpfin +lfinun +lfl0 +lfl0f +lfl0sc +lfl1 +lfl1dim +lfl1dim2n +lfl1sc +lfladd +lfladd0l +lfladdass +lfladdcl +lfladdcom +lflcl +lflf +lfli +lflmul +lflnegcl +lflnegl +lflsc0n +lflset +lflsub +lflvsass +lflvscl +lflvsdi1 +lflvsdi2 +lflvsdi2a +lfuhgr +lfuhgr1v0e +lfuhgr2 +lfuhgr3 +lgam1 +lgambdd +lgamcl +lgamcvg +lgamcvg2 +lgamcvglem +lgamf +lgamgulm +lgamgulm2 +lgamgulmlem1 +lgamgulmlem2 +lgamgulmlem3 +lgamgulmlem4 +lgamgulmlem5 +lgamgulmlem6 +lgamp1 +lgamucov +lgamucov2 +lgricngricex +lgs0 +lgs1 +lgs2 +lgsabs1 +lgscl +lgscl1 +lgscl2 +lgscllem +lgsdchr +lgsdchrval +lgsdi +lgsdilem +lgsdilem2 +lgsdinn0 +lgsdir +lgsdir2 +lgsdir2lem1 +lgsdir2lem2 +lgsdir2lem3 +lgsdir2lem4 +lgsdir2lem5 +lgsdirnn0 +lgsdirprm +lgseisen +lgseisenlem1 +lgseisenlem2 +lgseisenlem3 +lgseisenlem4 +lgsfcl +lgsfcl2 +lgsfcl3 +lgsfle1 +lgsfval +lgsle1 +lgslem1 +lgslem2 +lgslem3 +lgslem4 +lgsmod +lgsmodeq +lgsmulsqcoprm +lgsne0 +lgsneg +lgsneg1 +lgsprme0 +lgsqr +lgsqrlem1 +lgsqrlem2 +lgsqrlem3 +lgsqrlem4 +lgsqrlem5 +lgsqrmod +lgsqrmodndvds +lgsquad +lgsquad2 +lgsquad2lem1 +lgsquad2lem2 +lgsquad3 +lgsquadlem1 +lgsquadlem2 +lgsquadlem3 +lgssq +lgssq2 +lgsval +lgsval2 +lgsval2lem +lgsval3 +lgsval4 +lgsval4a +lgsval4lem +lgsvalmod +lhe4.4ex1a +lhop +lhop1 +lhop1lem +lhop2 +lhp0lt +lhp1cvr +lhp2at0 +lhp2at0ne +lhp2at0nle +lhp2atne +lhp2atnle +lhp2lt +lhpat +lhpat2 +lhpat3 +lhpat4n +lhpbase +lhpelim +lhpex2len +lhpexle +lhpexle1 +lhpexle1lem +lhpexle2 +lhpexle2lem +lhpexle3 +lhpexle3lem +lhpexlt +lhpexnle +lhpj1 +lhpjat1 +lhpjat2 +lhple +lhplt +lhpm0atn +lhpmat +lhpmatb +lhpmcvr +lhpmcvr2 +lhpmcvr3 +lhpmcvr4n +lhpmcvr5n +lhpmcvr6n +lhpmod2i2 +lhpmod6i1 +lhpn0 +lhpoc +lhpoc2n +lhpocat +lhpocnel +lhpocnel2 +lhpocnle +lhprelat3n +lhpset +lia +lib +license +lidl0 +lidl0alt +lidl0cl +lidl1 +lidl1alt +lidl1el +lidlabl +lidlacl +lidlacs +lidlbas +lidldomn1 +lidldomnnring +lidldvgen +lidlincl +lidlmcl +lidlmcld +lidlnegcl +lidlnsg +lidlnz +lidlrng +lidlrsppropd +lidlss +lidlssbas +lidlsubcl +lidlsubg +lidlunitel +lidlval +lidrideqd +lidrididd +lieb +lift_add +lift_cmul +lift_component +lift_drop +lift_eq +lift_eq_cmul +lift_in_image_lift +lift_in_interval +lift_integral_component +lift_neg +lift_num +lift_sub +lift_sum +lift_to_quotient_space +lift_to_quotient_space_unique +lighneal +lighneallem1 +lighneallem2 +lighneallem3 +lighneallem4 +lighneallem4a +lighneallem4b +lim_abs +lim_add +lim_at +lim_at_id +lim_at_infinity +lim_at_infinity_pos +lim_at_infinity_within +lim_at_infinity_within_pos +lim_at_le +lim_at_neginfinity +lim_at_posinfinity +lim_at_reflect +lim_at_sequentially +lim_at_within +lim_at_zero +lim_bilinear +lim_bilinear_convolution +lim_cases_cofinite_sequentially +lim_cases_finite_sequentially +lim_cases_sequentially +lim_cesaro +lim_cmul +lim_cmul_eq +lim_cofactor +lim_component +lim_component_eq +lim_component_lbound +lim_component_le +lim_component_ubound +lim_componentwise_lift +lim_componentwise_real +lim_compose_at +lim_compose_within +lim_cong_at +lim_cong_within +lim_const +lim_const_eq +lim_continuous +lim_continuous_function +lim_continuous_function_within +lim_continuous_self_at +lim_continuous_self_within +lim_drop_lbound +lim_drop_le +lim_drop_ubound +lim_eq_drop +lim_eq_lift +lim_eventually +lim_eventually_in_open +lim_eventually_in_open_in +lim_in_closed_set +lim_infinity_posinfinity_lift +lim_inv +lim_lift_abs_component +lim_lift_det +lim_lift_dot +lim_lift_pow +lim_lift_product +lim_linear +lim_matrix_componentwise +lim_matrix_inv +lim_matrix_transp +lim_matrix_vectorize +lim_max +lim_min +lim_mul +lim_mul_norm_within +lim_neg +lim_neg_eq +lim_norm +lim_norm_lbound +lim_norm_ubound +lim_null +lim_null_add +lim_null_cmul +lim_null_cmul_bounded +lim_null_cmul_eq +lim_null_comparison +lim_null_matrix_onorm +lim_null_matrix_onorm_componentwise +lim_null_neg +lim_null_norm +lim_null_onorm +lim_null_onorm_componentwise +lim_null_sub +lim_null_vmul +lim_null_vmul_bounded +lim_null_vmul_eq +lim_null_vsum +lim_pastecart +lim_pastecart_eq +lim_posinfinity_sequentially +lim_prod +lim_self_at +lim_self_within +lim_sequentially +lim_sub +lim_subsequence +lim_sum +lim_transform +lim_transform_at +lim_transform_away_at +lim_transform_away_within +lim_transform_bound +lim_transform_eq +lim_transform_eventually +lim_transform_within +lim_transform_within_open +lim_transform_within_open_in +lim_transform_within_set +lim_transform_within_set_imp +lim_trivial +lim_union +lim_union_univ +lim_unique +lim_vectorize_componentwise +lim_vmul +lim_vsum +lim_within +lim_within_closed_trivial +lim_within_delete +lim_within_empty +lim_within_id +lim_within_interior +lim_within_interior_inter +lim_within_le +lim_within_open +lim_within_open_in +lim_within_reflect +lim_within_sequentially +lim_within_sequentially_decreasing +lim_within_sequentially_inj +lim_within_subset +lim_within_union +lim_within_zero +limccl +limccnp +limccnp2 +limcco +limccog +limcdif +limcdm0 +limcflf +limcflflem +limcfval +limciccioolb +limcicciooub +limciun +limcleqr +limclner +limclr +limcmo +limcmpt +limcmpt2 +limcmptdm +limcnlp +limcperiod +limcrcl +limcrecl +limcres +limcresi +limcresioolb +limcresiooub +limcun +limcvallem +limelon +limenpsi +limensuc +limensuci +limeq +limexissup +limexissupab +liminf0 +liminf10ex +liminfcl +liminfcld +liminfequzmpt2 +liminfgelimsup +liminfgelimsupuz +liminfgf +liminfgord +liminfgval +liminflbuz2 +liminflelimsup +liminflelimsupcex +liminflelimsuplem +liminflelimsupuz +liminflimsupclim +liminflimsupxrre +liminflt +liminfltlem +liminfltlimsupex +liminfpnfuz +liminfresico +liminfresicompt +liminfresre +liminfresuz +liminfresuz2 +liminfresxr +liminfreuz +liminfreuzlem +liminfval +liminfval2 +liminfval3 +liminfval4 +liminfval5 +liminfvald +liminfvaluz +liminfvaluz2 +liminfvaluz3 +liminfvaluz4 +liminfvalxr +liminfvalxrmpt +limit_accumulation +limit_atpointof_sequentially_within +limit_atpointof_sequentially_within_inj +limit_componentwise_real +limit_def +limit_eq_drop +limit_eq_lift +limit_euclidean +limit_lemma +limit_metric +limit_metric_unique +limit_pair_drop_le +limit_point_finite +limit_point_in_derived_set +limit_point_of_image +limit_point_of_image_gen +limit_point_of_interval +limit_point_of_local +limit_point_of_local_imp +limit_point_union +limit_point_unions +limit_real_abs +limit_real_add +limit_real_inv +limit_sum +limit_trivial +limitarith +limitssson +limiun +limnsuc +limom +limomss +limon +limord +limpt_approachable +limpt_approachable_le +limpt_approachable_lift +limpt_ball +limpt_delete +limpt_empty +limpt_infinite_open +limpt_injective_linear_image_eq +limpt_insert +limpt_of_closure +limpt_of_condensation_points +limpt_of_convex +limpt_of_limpts +limpt_of_open +limpt_of_open_closure +limpt_of_open_in +limpt_of_sequence_subsequence +limpt_of_univ +limpt_pcross +limpt_sequential +limpt_sequential_inj +limpt_sing +limpt_subset +limpt_translation_eq +limsssuc +limsuc +limsuc2 +limsucncmp +limsucncmpi +limsup0 +limsup10ex +limsup10exlem +limsupbnd1 +limsupbnd1f +limsupbnd2 +limsupcl +limsupcld +limsupcli +limsupequz +limsupequzlem +limsupequzmpt +limsupequzmpt2 +limsupequzmptf +limsupequzmptlem +limsupge +limsupgf +limsupgle +limsupgord +limsupgre +limsupgt +limsupgtlem +limsupgval +limsuple +limsuplesup +limsuplt +limsuplt2 +limsupmnf +limsupmnflem +limsupmnfuz +limsupmnfuzlem +limsuppnf +limsuppnfd +limsuppnfdlem +limsuppnflem +limsupre +limsupre2 +limsupre2lem +limsupre2mpt +limsupre3 +limsupre3lem +limsupre3mpt +limsupre3uz +limsupre3uzlem +limsupref +limsupres +limsupresico +limsupresicompt +limsupresre +limsupresuz +limsupresuz2 +limsupresxr +limsupreuz +limsupreuzmpt +limsupub +limsupub2 +limsupubuz +limsupubuz2 +limsupubuzlem +limsupubuzmpt +limsupval +limsupval2 +limsupval3 +limsupval4 +limsupvald +limsupvaluz +limsupvaluz2 +limsupvaluz3 +limsupvaluz4 +limsupvaluzmpt +limuni +limuni2 +limuni3 +linc0scn0 +linc1 +linccl +lincdifsn +lincellss +lincext1 +lincext2 +lincext3 +lincfsuppcl +lincmb01cmp +lincolss +lincop +lincreslvec3 +lincresunit1 +lincresunit2 +lincresunit3 +lincresunit3lem1 +lincresunit3lem2 +lincresunit3lem3 +lincresunitlem1 +lincresunitlem2 +lincscm +lincscmcl +lincsum +lincsumcl +lincsumscmcl +lincval +lincval0 +lincval1 +lincvalpr +lincvalsc0 +lincvalsn +lincvalsng +lindelof +lindelof_open_in +lindepsnlininds +lindff +lindff1 +lindfind +lindfind2 +lindflbs +lindfmm +lindfpropd +lindfres +lindfrn +linds0 +linds1 +linds2 +linds2eq +lindsadd +lindsdom +lindsenlbs +lindsind +lindsind2 +lindslinindimp2lem1 +lindslinindimp2lem2 +lindslinindimp2lem3 +lindslinindimp2lem4 +lindslininds +lindslinindsimp1 +lindslinindsimp2 +lindslinindsimp2lem5 +lindsmm +lindsmm2 +lindspropd +lindsrng01 +lindssn +lindssnlvec +lindsss +lindsun +lindsunlem +lindszr +line +line2 +line2x +line2xlem +line2y +line2ylem +linear +linear-safety +linear-single +linear_0 +linear_1 +linear_1_gen +linear_add +linear_bijective_dimindex_eq +linear_bijective_left_right_inverse +linear_bijective_left_right_inverse_eq +linear_bounded +linear_bounded_pos +linear_closest_point +linear_cmul +linear_componentwise +linear_componentwise_expansion +linear_compose +linear_compose_add +linear_compose_cmul +linear_compose_neg +linear_compose_neg_eq +linear_compose_sub +linear_compose_vsum +linear_continuous_at +linear_continuous_compose +linear_continuous_on +linear_continuous_on_compose +linear_continuous_within +linear_convex_on_1 +linear_dropout +linear_eq +linear_eq_0 +linear_eq_0_span +linear_eq_matrix +linear_eq_stdbasis +linear_frechet_derivative +linear_from_1 +linear_from_reals +linear_fstcart +linear_i +linear_id +linear_image_subset_interior +linear_imp_convex_on +linear_imp_has_bounded_variation +linear_imp_homeomorphism +linear_imp_lipschitz +linear_indep_image_lemma +linear_independent_extend +linear_independent_extend_lemma +linear_injective_0 +linear_injective_0_subspace +linear_injective_bounded_below_pos +linear_injective_dimindex_le +linear_injective_iff_dim +linear_injective_imp_surjective +linear_injective_imp_surjective_on +linear_injective_isomorphism +linear_injective_left_inverse +linear_injective_left_inverse_eq +linear_injective_left_right_inverse_eq +linear_injective_on_iff_dim +linear_interior_image_subset +linear_invariant_rule +linear_inverse_left +linear_invertible_bounded_below +linear_invertible_bounded_below_pos +linear_lift_component +linear_lift_dot +linear_lim_0 +linear_limit +linear_matrix_exists +linear_neg +linear_negation +linear_of +linear_open_mapping +linear_pastecart +linear_pastecart_eq +linear_pushin +linear_reflect_along +linear_safety +linear_scaling +linear_sequential_limit +linear_single +linear_singular_image_hyperplane +linear_singular_into_hyperplane +linear_sndcart +linear_sub +linear_subspace_graph +linear_surjective_dimindex_le +linear_surjective_iff_dim +linear_surjective_iff_injective +linear_surjective_iff_injective_gen +linear_surjective_iff_injective_on +linear_surjective_imp_injective +linear_surjective_isomorphism +linear_surjective_left_right_inverse_eq +linear_surjective_on_iff_dim +linear_surjective_right_inverse +linear_surjective_right_inverse_eq +linear_tm +linear_to_1 +linear_to_reals +linear_transp +linear_type +linear_uniformly_continuous_on +linear_use +linear_vmul_component +linear_vmul_drop +linear_vsum +linear_vsum_mul +linear_zero +lineardup +linearfold +linearity +linearmap +linearsearch +linearswap +linecgr +linecgrand +linecom +linedegen +lineelsb2 +lineext +lineid +lineintmo +linepmap +linepsubcln +linepsubn +lineq +linerflx1 +linerflx2 +lines +lineset +liness +linethru +linethrueu +lineunray +lineval +linevalexample +linindscl +linindsi +linindslinci +linindsv +linkedlistinsert +linply1 +linv_def +linv_opt_thm +linvh +lipschitz_continuous_imp_continuous_map +lipschitz_continuous_map_cart_projections +lipschitz_continuous_map_compose +lipschitz_continuous_map_pairwise +lipschitz_continuous_map_pasted +lipschitz_continuous_map_pastewise +lipschitz_continuous_map_pasting +lipschitz_convex_spherical_projection +lipschitz_convex_spherical_projection_explicit +lipschitz_extension_exists +lipschitz_imp_absolutely_continuous +lipschitz_imp_cauchy_continuous_map +lipschitz_imp_continuous_on +lipschitz_imp_has_bounded_variation +lipschitz_imp_rectifiable_path +lipschitz_imp_uniformly_continuous_map +lipschitz_imp_uniformly_continuous_on +lipschitz_lim +lipschitz_on_componentwise +lipschitz_on_compose +lipschitz_on_inf +lipschitz_on_pos +lipschitz_on_sup +lipschitz_pos +lipschitz_vector_variation +list +list-equiv-of-rev-and-rev +list-fix-of-append +list_all_forall +list_append_assoc +list_append_nil +list_apply_o +list_axiom_old +list_bind_append +list_bind_id +list_bind_list_bind +list_bind_map +list_case_compute +list_cases +list_eq_map_pair +list_eq_rewrite +list_filter_length +list_foldr_append +list_induct +list_induct_tac +list_length_append +list_length_nonempty +list_length_reverse +list_map_compose +list_map_id +list_map_length +list_mem_append +list_nil_append +list_not_eq +list_not_nil +list_rec +list_rel_append +list_rel_append_eq +list_rel_append_imp +list_rel_append_suff +list_rel_conj +list_rel_cons1 +list_rel_cons2 +list_rel_el_eqn +list_rel_equivalence +list_rel_every_zip +list_rel_length +list_rel_map1 +list_rel_map2 +list_rel_map_inv_image +list_rel_mem_imp +list_rel_mem_imp_r +list_rel_mono +list_rel_o +list_rel_snoc +list_rel_split1 +list_rel_split2 +list_rel_trans +list_rev_append +list_rev_involutive +list_rev_rev +list_reverse_reverse +list_size_append +list_size_zip +list_sort +list_to_set_diff +list_to_set_drop +list_to_set_filter +list_to_set_flat +list_to_set_genlist +list_to_set_map +list_to_set_sing +list_to_set_snoc +list_to_set_take +listflatten +listind +listind `l1` +listn_ext +liveness_property +lkr0f +lkr0f2 +lkrcl +lkreqn +lkrf0 +lkrfval +lkrin +lkrlsp +lkrlsp2 +lkrlsp3 +lkrlspeqn +lkrlss +lkrpssn +lkrsc +lkrscss +lkrshp +lkrshp3 +lkrshp4 +lkrshpor +lkrss +lkrss2n +lkrssv +lkrval +lkrval2 +llex_el_thm +llex_not_wf +llex_total +llex_transitive +llnbase +llncmp +llncvrlpln +llncvrlpln2 +llnexatn +llnexch2n +llnexchb2 +llnexchb2lem +llni +llni2 +llnle +llnmlplnn +llnmod1i2 +llnmod2i2 +llnn0 +llnneat +llnnleat +llnnlt +llnset +lltr +lly1stc +llycmpkgen +llycmpkgen2 +llyeq +llyi +llyidm +llynlly +llyrest +llyss +llyssnlly +llytop +lmat22det +lmat22e11 +lmat22e12 +lmat22e21 +lmat22e22 +lmat22lem +lmatcl +lmatfval +lmatfvlem +lmatval +lmbr +lmbr2 +lmbr3 +lmbr3v +lmbrf +lmcau +lmcl +lmcld +lmclim +lmclim2 +lmclimf +lmcls +lmcn +lmcn2 +lmcnp +lmconst +lmcvg +lmddu +lmdfval +lmdfval2 +lmdpropd +lmdran +lmdrcl +lmdvg +lmdvglim +lmff +lmflf +lmfpm +lmfss +lmfun +lmfval +lmghm +lmhmclm +lmhmco +lmhmeql +lmhmf +lmhmf1o +lmhmfgima +lmhmfgsplit +lmhmghmd +lmhmima +lmhmimasvsca +lmhmkerlss +lmhmlem +lmhmlin +lmhmlmod1 +lmhmlmod2 +lmhmlnmsplit +lmhmlsp +lmhmlvec +lmhmlvec2 +lmhmplusg +lmhmpreima +lmhmpropd +lmhmqusker +lmhmrnlss +lmhmsca +lmhmvsca +lmicdim +lmicinv +lmicl +lmiclbs +lmiclcl +lmicom +lmicqusker +lmicrcl +lmicsym +lmictra +lmieq +lmieu +lmif +lmif1o +lmiinv +lmiiso +lmiisolem +lmilmi +lmimcnv +lmimco +lmimdim +lmimf1o +lmimfn +lmimgim +lmimid +lmimlbs +lmimlmhm +lmimot +lmiopp +lmireu +lmisfree +lmle +lmlim +lmlimxrge0 +lmmbr +lmmbr2 +lmmbr3 +lmmbrf +lmmcvg +lmmo +lmnn +lmod0cl +lmod0rng +lmod0vcl +lmod0vid +lmod0vlid +lmod0vrid +lmod0vs +lmod1 +lmod1cl +lmod1lem1 +lmod1lem2 +lmod1lem3 +lmod1lem4 +lmod1lem5 +lmod1zr +lmod1zrnlvec +lmod4 +lmodabl +lmodacl +lmodass +lmodbase +lmodbn0 +lmodcmn +lmodcom +lmodfgrp +lmodfopne +lmodfopnelem1 +lmodfopnelem2 +lmodgrp +lmodgrpd +lmodindp1 +lmodlcan +lmodlema +lmodmcl +lmodn0 +lmodnegadd +lmodplusg +lmodprop2d +lmodpropd +lmodring +lmodsca +lmodscaf +lmodslmd +lmodsn0 +lmodstr +lmodsubdi +lmodsubdir +lmodsubeq0 +lmodsubid +lmodsubvs +lmodvacl +lmodvaddsub4 +lmodvneg1 +lmodvnegcl +lmodvnegid +lmodvnpcan +lmodvpncan +lmodvs0 +lmodvs1 +lmodvsass +lmodvsca +lmodvscl +lmodvscld +lmodvsdi +lmodvsdir +lmodvsghm +lmodvsinv +lmodvsinv2 +lmodvslmhm +lmodvsmdi +lmodvsmmulgdi +lmodvsneg +lmodvsubadd +lmodvsubcl +lmodvsubval2 +lmrcl +lmrel +lmres +lmss +lmxrge0 +ln_mono_le +ln_mono_lt +ln_pos_lt +ln_pow +lnatexn +lncgr +lncmp +lncnbd +lncnopbd +lncom +lnconi +lncvrat +lncvrelatn +lneq2at +lnext +lnfn0 +lnfn0i +lnfnaddi +lnfnaddmuli +lnfncnbd +lnfncon +lnfnconi +lnfnf +lnfnfi +lnfnl +lnfnli +lnfnmul +lnfnmuli +lnfnsubi +lngid +lngndx +lngndxnitvndx +lnhl +lnid +lnjatn +lnmepi +lnmfg +lnmlmic +lnmlmod +lnmlssfg +lnmlsslnm +lnnat +lno0 +lnoadd +lnocni +lnocoi +lnof +lnolin +lnomul +lnon0 +lnop0 +lnop0i +lnopaddi +lnopaddmuli +lnopcnbd +lnopcnre +lnopco0i +lnopcoi +lnopcon +lnopconi +lnopeq +lnopeq0i +lnopeq0lem1 +lnopeq0lem2 +lnopeqi +lnopf +lnopfi +lnophdi +lnophm +lnophmi +lnophmlem1 +lnophmlem2 +lnophsi +lnopl +lnopli +lnopmi +lnopmul +lnopmuli +lnopmulsubi +lnopp2hpgb +lnoppnhpg +lnopsubi +lnopsubmuli +lnopunii +lnopunilem1 +lnopunilem2 +lnosub +lnoval +lnperpex +lnr2i +lnrfg +lnrfgtr +lnrfrlm +lnrlnm +lnrot1 +lnrot2 +lnrring +lnxfr +lo1add +lo1bdd +lo1bdd2 +lo1bddrp +lo1const +lo1dm +lo1eq +lo1f +lo1le +lo1mptrcl +lo1mul +lo1mul2 +lo1o1 +lo1o12 +lo1res +lo1res2 +lo1resb +lo1sub +load_balancing +local-sub-type-crock +local_homeomorphism_imp_open_map +locally_and_open_in +locally_and_open_in_idempot +locally_and_small_le +locally_and_subset +locally_closed +locally_closed_in +locally_closed_in_explicit +locally_compact +locally_compact_alt +locally_compact_closed_diff +locally_compact_closed_in +locally_compact_closed_in_open +locally_compact_closed_inter_open +locally_compact_closed_union +locally_compact_closure_diff +locally_compact_compact +locally_compact_compact_alt +locally_compact_compact_subopen +locally_compact_delete +locally_compact_homeomorphism_projection_closed +locally_compact_imp_analytic +locally_compact_imp_borel +locally_compact_inter +locally_compact_inter_cball +locally_compact_inter_cballs +locally_compact_linear_image_eq +locally_compact_open_in +locally_compact_open_inter_closure +locally_compact_open_union +locally_compact_open_unions +locally_compact_pcross +locally_compact_pcross_eq +locally_compact_proper_continuous_preimage +locally_compact_proper_image +locally_compact_proper_image_eq +locally_compact_space_neighbourhood_base +locally_compact_space_subtopology_euclidean +locally_compact_translation_eq +locally_compact_univ +locally_constant +locally_constant_imp_constant +locally_countable +locally_diff_closed +locally_empty +locally_eq_compactly +locally_fine_covering_compact +locally_imp_countable_union_of +locally_imp_finite_union_of +locally_injective_linear_image +locally_inter +locally_inter_open +locally_lebesgue_measurable +locally_lebesgue_measurable_alt +locally_mono +locally_negligible +locally_negligible_alt +locally_open_basis +locally_open_inter +locally_open_map_image +locally_open_subset +locally_pcross +locally_sing +locally_to_compactly +locally_translation +locfinbas +locfincf +locfincmp +locfindis +locfinnei +locfinref +locfinreflem +locfintop +lock_release +loclly +loewner_order_antisym +lof +log1 +log11d +log2cnv +log2le1 +log2sumbnd +log2tlbnd +log2ub +log2ublem1 +log2ublem2 +log2ublem3 +log_mult +log_search +log_val +logand-0 +logand-=-minus-1 +logand-comm +logand-logior +logand-logxor +logand-self +logand-upper-bound +logand-with-mask +logapp-0 +logapp-loghead-logtail +logb1 +logb2aval +logbchbase +logbcl +logbf +logbfval +logbgcd1irr +logbge0b +logbgt0b +logbid1 +logbit-0-minus-1 +logbit-logapp +logbit-loghead +logbit-lognot +logbit-lognotu +logbit-logrpl +logbit-logtail +logbitp-0-minus-1 +logbitp-logapp +logbitp-loghead +logbitp-lognot +logbitp-lognotu +logbitp-logrpl +logbitp-logtail +logbitp-of-logand +logbleb +logblebd +logblog +logblt +logblt1b +logbmpt +logbprmirr +logbpw2m1 +logbrec +logbval +logcar-2*i +logcar-i+2*j +logcar-logapp +logcar-logcdr-elim +logcar-logcons +logcar-loghead +logcar-logrpl +logccne0 +logccne0d +logccv +logcdr-2*i +logcdr-i+2*j +logcdr-logcons +logcj +logcl +logcld +logcn +logcnlem2 +logcnlem3 +logcnlem4 +logcnlem5 +logcxp +logcxp0 +logcxpd +logdifbnd +logdiflbnd +logdiv2 +logdivbnd +logdivle +logdivlt +logdivlti +logdivsqrle +logdivsum +logdmn0 +logdmnrp +logdmopn +logdmss +loge +logef +logeftb +logeq0im1 +logexprlim +logext-+-cancel +logext-+-logext +logext-identity +logext-of-ifix +logextu-0 +logextu-as-loghead +logf1o +logf1o2 +logfac +logfac2 +logfacbnd3 +logfaclbnd +logfacrlim +logfacrlim2 +logfacubnd +logfib_spec +logge0 +logge0b +logge0d +loggt0b +loghead-+-cancel +loghead-+-cancel-0 +loghead-+-loghead +loghead-0-i +loghead-identity +loghead-leq +loghead-logapp +loghead-logapp-expansion-lemma +loghead-logapp-loghead-logtail +loghead-logextu +loghead-loghead +loghead-logrpl +loghead-of-ifix +loghead-size-0 +logi +logic +logic1 +logic1a +logic2 +logical +logimcl +logimclad +logimcld +logimul +logior-0 +logior-=-0 +logior-comm +logior-self +logle1b +logleb +logled +loglesqrt +loglt1b +logltb +logm1 +logmaskp-expt-2-n-minus-1 +logmaskp-expt-2-n-minus-1-crock +logmaskp-logmask +logmul2 +logne0 +logne0d +logneg +logneg2 +lognegb +logno1 +lognot-lognot +lognotu-lognotu +logrec +logreclem +logrn +logrnaddcl +logrncl +logrncn +logrpl-0 +logrpl-i-i +logrpl-loghead-i-i +logrpl-logrpl-left +logrpl-logrpl-right +logsqrt +logsqvma +logsqvma2 +logtail-0-i +logtail-equal-0 +logtail-identity +logtail-leq +logtail-lessp +logtail-logapp +logtail-logapp-expansion-lemma +logtail-loghead +logtail-loghead-expansion-lemma +logtail-logrpl +logtail-logtail +logtail-size-0 +logtail-unsigned-byte-p +logtayl +logtayl2 +logtayllem +logtaylsum +logxor-0 +logxor-=-0 +logxor-comm +logxor-self +longest_chain +looinv +lookup +lookupdpair +lookupview +loolin +loop1cycl +loop_invariant_sum +loopclwwlkn1b +loowoz +loss_nonneg +lot_sizing +lowdim_eq_hyperplane +lowdim_eq_inter_hyperplane +lowdim_expand_basis +lowdim_expand_dimension +lowdim_subset_hyperplane +lower_hemicontinuous +lp1cycl +lpadleft +lpadlem1 +lpadlem2 +lpadlem3 +lpadlen1 +lpadlen2 +lpadmax +lpadright +lpadval +lpbl +lpcls +lpdifsn +lpfval +lpi0 +lpi1 +lpigen +lpirlidllpi +lpirlnr +lpirring +lpiss +lpival +lplnbase +lplncmp +lplncvrlvol +lplncvrlvol2 +lplnexatn +lplnexllnn +lplni +lplni2 +lplnle +lplnllnnen +lplnn0n +lplnneat +lplnnelln +lplnnle2at +lplnnleat +lplnnlelln +lplnnlt +lplnri1 +lplnri2n +lplnri3n +lplnrian +lplnribn +lplnric +lplnset +lply1binom +lply1binomsc +lpni +lpolconn +lpolfn +lpolpolsatn +lpolsatn +lpolsetn +lpolvn +lppthon +lpss +lpss2 +lpss3 +lpssat +lpsscls +lptioo1 +lptioo1cn +lptioo2 +lptioo2cn +lptre2pt +lpval +lpvtx +lrc_mem +lrc_mem_right +lrcut +lrelat +lringnz +lringnzr +lringring +lringuplu +lrold +lrrecfr +lrrecpo +lrrecpred +lrrecse +lrrecval +lrrecval2 +lruneq +lsat0cv +lsat2el +lsatcmp +lsatcmp2 +lsatcv0 +lsatcv0eq +lsatcv1 +lsatcvat +lsatcvat2 +lsatcvat3 +lsatcvatlem +lsatcveq0 +lsatdim +lsatel +lsatelbn +lsateln0 +lsatexch +lsatexch1 +lsatfixedn +lsatlspsn +lsatlspsn2 +lsatlss +lsatlssel +lsatn0 +lsatnem0 +lsatnle +lsator0sp +lsatset +lsatspn0 +lsatssn0 +lsatssv +lshpat +lshpcmp +lshpdisj +lshpinn +lshpkr +lshpkrcl +lshpkrex +lshpkrlem1 +lshpkrlem2 +lshpkrlem3 +lshpkrlem4 +lshpkrlem5 +lshpkrlem6 +lshplss +lshpne +lshpne0 +lshpnel +lshpnel2n +lshpnelb +lshpset +lshpset2n +lshpsmreu +lsm01 +lsm02 +lsm4 +lsmass +lsmcl +lsmcntz +lsmcntzr +lsmcom +lsmcom2 +lsmcomx +lsmcss +lsmcv +lsmcv2 +lsmdisj +lsmdisj2 +lsmdisj2a +lsmdisj2b +lsmdisj2r +lsmdisj3 +lsmdisj3a +lsmdisj3b +lsmdisj3r +lsmdisjr +lsmelpr +lsmelval +lsmelval2 +lsmelvali +lsmelvalix +lsmelvalm +lsmelvalmi +lsmelvalx +lsmfgcl +lsmfval +lsmhash +lsmidl +lsmidllsp +lsmidm +lsmless1 +lsmless12 +lsmless1x +lsmless2 +lsmless2x +lsmlub +lsmmod +lsmmod2 +lsmpr +lsmpropd +lsmsat +lsmsatcv +lsmsnidl +lsmsnorb +lsmsnorb2 +lsmsnpridl +lsmsp +lsmsp2 +lsmspsn +lsmss1 +lsmss1b +lsmss2 +lsmss2b +lsmssass +lsmssspx +lsmssv +lsmsubg +lsmsubg2 +lsmsubm +lsmub1 +lsmub1x +lsmub2 +lsmub2x +lsmunss +lsmval +lsmvalx +lsp0 +lspabs2 +lspabs3 +lspcl +lspdisj +lspdisj2 +lspdisjb +lspeqlco +lspexch +lspexchn1 +lspexchn2 +lspextmo +lspf +lspfixed +lspfval +lspid +lspidm +lspindp1 +lspindp2 +lspindp2l +lspindp3 +lspindp4 +lspindp5 +lspindpi +lsppr +lsppr0 +lspprabs +lspprat +lsppratlem1 +lsppratlem2 +lsppratlem3 +lsppratlem4 +lsppratlem5 +lsppratlem6 +lspprcl +lspprel +lsppreli +lspprid1 +lspprid2 +lsppropd +lspprss +lspprvacl +lspsn +lspsn0 +lspsnat +lspsncl +lspsncmp +lspsncv0 +lspsneleq +lspsneq +lspsneq0 +lspsneq0b +lspsneu +lspsnid +lspsnne1 +lspsnne2 +lspsnnecom +lspsnneg +lspsnss +lspsnss2 +lspsnsub +lspsnsubg +lspsnsubn0 +lspsntri +lspsntrim +lspsnvs +lspsnvsi +lspsolv +lspsolvlem +lspss +lspssid +lspsslco +lspssp +lspssv +lsptpcl +lspun +lspun0 +lspuni0 +lspvadd +lspval +lss0cl +lss0ss +lss0v +lss1 +lss1d +lssacs +lssacsex +lssat +lssatle +lssatomic +lssats +lssats2 +lssbn +lsscl +lssdimle +lssel +lssincl +lssintcl +lssle0 +lsslindf +lsslinds +lsslmod +lsslsp +lsslspold +lsslss +lsslvec +lssmre +lssn0 +lssne0 +lssneln0 +lssnle +lssnlm +lssnvc +lsspropd +lssset +lsssn0 +lsssra +lssss +lssssr +lsssssubg +lsssubg +lssuni +lssvacl +lssvancl1 +lssvancl2 +lssvnegcl +lssvneln0 +lssvs0or +lssvscl +lssvsubcl +lsubrotld +lsubswap23d +lsw +lsw0 +lsw0g +lsw1 +lswccat0lsw +lswccatn0lsw +lswccats1 +lswccats1fst +lswcl +lswco +lswcshw +lswlgt0cl +lswn0 +lsws1 +lsws2 +lsws3 +lsws4 +lt +lt0ne0 +lt0ne0d +lt0neg1 +lt0neg1d +lt0neg1dd +lt0neg2 +lt0neg2d +lt0negs2d +lt2add +lt2addd +lt2addi +lt2addmuld +lt2addrd +lt2addsd +lt2halves +lt2halvesd +lt2msq +lt2msq1 +lt2msqi +lt2mul2div +lt2mul2divd +lt2sq +lt2sqd +lt2sqi +lt2sub +lt2subd +lt3addmuld +lt4addmuld +lt6abl +lt_abs +lt_add +lt_antisym +lt_cases +lt_exists +lt_imp_le +lt_int +lt_le +lt_mult +lt_mult_lcancel +lt_mult_rcancel +lt_rat +lt_refl +lt_sub_lcancel +lt_sub_rcancel +lt_suc +lt_suc_le +lt_succ +lt_succ_self +lt_trans +ltadd1 +ltadd12dd +ltadd1d +ltadd1dd +ltadd1i +ltadd2 +ltadd2d +ltadd2dd +ltadd2i +ltaddneg +ltaddnegr +ltaddnq +ltaddpos +ltaddpos2 +ltaddpos2d +ltaddposd +ltaddposi +ltaddpr +ltaddpr2 +ltaddrp +ltaddrp2d +ltaddrpd +ltadds1 +ltadds1d +ltadds1im +ltadds2 +ltadds2d +ltadds2im +ltaddspos1d +ltaddspos2d +ltaddsub +ltaddsub2 +ltaddsub2d +ltaddsubd +ltaddsubi +ltaddsublt +ltaddsubs2d +ltaddsubsd +ltanq +ltapi +ltapr +ltaprlem +ltasr +ltbtwnnq +ltbval +ltbwe +ltcvrntr +ltdifltdiv +ltdiv1 +ltdiv1d +ltdiv1dd +ltdiv1i +ltdiv1ii +ltdiv2 +ltdiv23 +ltdiv23d +ltdiv23i +ltdiv23ii +ltdiv23neg +ltdiv2d +ltdiv2dd +ltdivgt1 +ltdivmul +ltdivmul2 +ltdivmul2d +ltdivmuld +ltdivmuls2d +ltdivmuls2wd +ltdivmulsd +ltdivmulswd +ltdivp1i +lte +lte_antisym +lte_trans +lteaddright +lteantisym +lterefl +lterpq +ltesubnnd +ltesuccright +ltetrans +ltex +ltexnq +ltexp1d +ltexp1dd +ltexp2 +ltexp2a +ltexp2d +ltexp2r +ltexp2rd +ltexpi +ltexpri +ltexprlem1 +ltexprlem2 +ltexprlem3 +ltexprlem4 +ltexprlem5 +ltexprlem6 +ltexprlem7 +ltflcei +ltgov +ltgseg +ltle +ltleadd +ltleaddd +ltlecasei +ltled +ltlei +ltleii +ltleletr +ltlen +ltlend +ltleni +ltlesd +ltlesnd +ltlestr +ltlestrd +ltletr +ltletrd +ltletri +ltltncvr +ltm +ltm1 +ltm1d +ltmin +ltmnq +ltmod +ltmpi +ltmul1 +ltmul12a +ltmul12ad +ltmul1a +ltmul1d +ltmul1dd +ltmul1i +ltmul1ii +ltmul2 +ltmul2d +ltmul2dd +ltmul2i +ltmuldiv +ltmuldiv2 +ltmuldiv2d +ltmuldivd +ltmuldivi +ltmuldivs2d +ltmuldivs2wd +ltmuldivsd +ltmuldivswd +ltmulgt11 +ltmulgt11d +ltmulgt12 +ltmulgt12d +ltmulneg +ltmulnegs1d +ltmulnegs2d +ltmuls +ltmuls12ad +ltmuls1d +ltmuls2 +ltmuls2d +ltmulsd +ltne +ltned +ltneg +ltnegcon1 +ltnegcon1d +ltnegcon1i +ltnegcon2 +ltnegcon2d +ltnegcon2i +ltnegd +ltnegi +ltnegs +ltnegsd +ltnegsim +ltnei +ltneii +ltnelicc +ltnle +ltnled +ltnlei +ltnles +ltnltne +ltnr +ltnrd +ltnri +ltnsym +ltnsym2 +ltnsymd +ltnsymi +ltoddhalfle +ltonold +ltonsex +ltord1 +ltord2 +ltordlem +ltp +ltp1 +ltp1d +ltp1i +ltpiord +ltpnf +ltpnfd +ltprord +ltpsrpr +ltrabdioph +ltrec +ltrec1 +ltrec1d +ltrecd +ltreci +ltrecii +ltrel +ltrelnq +ltrelpi +ltrelpr +ltrelre +ltrelsr +ltrelxr +ltresr +ltresr2 +ltrmxnn0 +ltrmy +ltrmynn0 +ltrn11 +ltrn11at +ltrn1o +ltrn2ateq +ltrnat +ltrnatb +ltrnateq +ltrnatlw +ltrnatneq +ltrncl +ltrncnv +ltrncnvat +ltrncnvatb +ltrncnvel +ltrncnvlen +ltrncnvnid +ltrnco +ltrnco4 +ltrncoat +ltrncoeln +ltrncoidn +ltrncom +ltrncoval +ltrncvr +ltrnel +ltrneq +ltrneq2 +ltrneq3 +ltrnfset +ltrnid +ltrnideq +ltrniotacl +ltrniotacnvn +ltrniotacnvval +ltrniotafvawn +ltrniotaidvaln +ltrniotaval +ltrniotavalbn +ltrnj +ltrnlaut +ltrnldil +ltrnle +ltrnm +ltrnmw +ltrnnid +ltrnnidn +ltrnq +ltrnset +ltrnu +ltrnval1 +ltsasym +ltsintdifex +ltsirr +ltslin +ltslpss +ltsm1d +ltsn0 +ltsne +ltsnled +ltso +ltsonq +ltsopi +ltsopr +ltsosr +ltsp1d +ltsrec +ltsrecd +ltsres +ltsrpr +ltsso +ltssolem1 +ltstr +ltstrd +ltstrieq2 +ltstrine +ltsub1 +ltsub13 +ltsub13d +ltsub1d +ltsub1dd +ltsub2 +ltsub23 +ltsub23d +ltsub2d +ltsub2dd +ltsubadd +ltsubadd2 +ltsubadd2b +ltsubadd2d +ltsubadd2i +ltsubaddb +ltsubaddd +ltsubaddi +ltsubadds2d +ltsubaddsd +ltsubnn0 +ltsubpos +ltsubposd +ltsubrp +ltsubrpd +ltsubs1 +ltsubs1d +ltsubs2 +ltsubs2d +ltsubsposd +ltsubsubaddltsub +ltsubsubb +ltsubsubs2bd +ltsubsubs3bd +ltsubsubsbd +ltsval +ltsval2 +lttolte +lttr +lttrd +lttri +lttri2 +lttri2d +lttri2i +lttri3 +lttri3d +lttri3i +lttri4 +lttri4d +lttri5d +lttrid +lttrii +ltwefz +ltwenn +ltweuz +ltxr +ltxrlt +lub0n +lubcl +lubdm +lubel +lubeldm +lubeldm2 +lubeldm2d +lubelss +lubeu +lubfun +lubfval +lubid +lubl +luble +lublecl +lublecllem +lublem +lubpr +lubprdm +lubprlem +lubprop +lubsn +lubss +lubsscl +lubub +lubun +lubval +luk-1 +luk-2 +luk-3 +luklem1 +luklem2 +luklem3 +luklem4 +luklem5 +luklem6 +luklem7 +luklem8 +lukshef-ax1 +lukshef-ax2 +lukshefth1 +lukshefth2 +lupdate_append +lupdate_append2 +lupdate_genlist +lupdate_length +lupdate_map +lupdate_same +lupdate_sem +lupdate_snoc +lupdate_some_map +luzin +luzin_nproperty_imp_countable_preimages +luzin_sigma +luzin_sigma_explicit +luzin_sigma_nested +lvecdim +lvecdim0 +lvecdim0i +lvecdimfi +lvecdrng +lvecendof1f1o +lvecgrp +lvecgrpd +lvecindp +lvecindp2 +lvecinv +lvecisfrlm +lveclmod +lveclmodd +lvecprop2d +lvecpropd +lvecpsslmod +lvecring +lvecvs0or +lvecvscan +lvecvscan2 +lvecvsn0 +lvolbase +lvolcmp +lvolex3n +lvoli +lvoli2 +lvoli3 +lvoln0n +lvolneatn +lvolnelln +lvolnelpln +lvolnle3at +lvolnleat +lvolnlelln +lvolnlelpln +lvolnltn +lvolset +lzenom +lzunuz +m +m11nprm +m1bits +m1detdiag +m1dvdsndvds +m1exp1 +m1expaddsub +m1expcl +m1expcl2 +m1expe +m1expeven +m1expevenaltv +m1expo +m1expoddaltv +m1lgs +m1m1sr +m1mod0mod1 +m1modge3gt1 +m1modmmod +m1modne +m1modnep2mod +m1modnnsub1 +m1p1sr +m1pmeq +m1r +m2cpm +m2cpmf +m2cpmf1 +m2cpmf1o +m2cpmfo +m2cpmghm +m2cpminv +m2cpminv0 +m2cpminvid +m2cpminvid2 +m2cpminvid2lem +m2cpmmhm +m2cpmrhm +m2cpmrngiso +m2detleib +m2detleiblem1 +m2detleiblem2 +m2detleiblem3 +m2detleiblem4 +m2detleiblem5 +m2detleiblem6 +m2detleiblem7 +m2even +m2pmfzgsumcl +m2pmfzmap +m2prm +m3prm +m5prm +m7prm +m_positive +ma1repvcl +ma1repveval +made0 +madebday +madebdayim +madebdaylemlrcut +madebdaylemold +madecut +madef +madefi +madeno +madenod +madeoldsuc +madess +madessno +madetsmelbas +madetsmelbas2 +madetsumid +madeun +madeval +madeval2 +madjusmdet +madjusmdetlem1 +madjusmdetlem2 +madjusmdetlem3 +madjusmdetlem4 +maducoeval +maducoeval2 +maducoevalmin1 +maduf +madufval +madugsum +madulid +madurid +madutpos +maduval +magic_square +mainer +mainer2 +mainerim +mainpart +majority_element +make-character-list-of-rev +makespan = max(a in activities)(end[a]) +mamuass +mamucl +mamudi +mamudir +mamudm +mamufacex +mamufv +mamufval +mamulid +mamumat1cl +mamures +mamurid +mamutpos +mamuval +mamuvs1 +mamuvs2 +management +manhattan +manipulation +map +map0 +map0b +map0cor +map0e +map0g +map1 +map2 +map2_append +map2_zip +map2psrpr +map2xp +map_app +map_append +map_append_map_eq +map_compose +map_cons +map_drop +map_eq_append +map_eq_cons +map_eq_every2 +map_eq_f +map_every +map_flat +map_front +map_genlist +map_id +map_length +map_list_bind +map_map +map_map_o +map_nil +map_o +map_rev +map_reverse +map_snoc +map_take +map_tl +map_zip +mapappend +mapco2 +mapco2g +mapcod +mapcompose +mapcontainsafterupdate +mapd0 +mapd11 +mapd1dim2 +mapd1dim2lem1n +mapd1dim3 +mapd1o +mapdat +mapdcl +mapdcl2 +mapdcnv11n +mapdcnvatn +mapdcnvcl +mapdcnvid1n +mapdcnvid2 +mapdcnvordn +mapdcv +mapddlssn +mapdffval +mapdfval +mapdh6an +mapdh6b0n +mapdh6bn +mapdh6cn +mapdh6dn +mapdh6en +mapdh6fn +mapdh6gn +mapdh6hn +mapdh6in +mapdh6jn +mapdh6kn +mapdh6lem1n +mapdh6lem2n +mapdh6n +mapdh75cn +mapdh75d +mapdh75e +mapdh75fn +mapdh7cn +mapdh7dn +mapdh7en +mapdh7fn +mapdh8 +mapdh8a +mapdh8aa +mapdh8ab +mapdh8ac +mapdh8ad +mapdh8b +mapdh8c +mapdh8d +mapdh8d0n +mapdh8e +mapdh8g +mapdh8i +mapdh8j +mapdh9a +mapdh9aoldn +mapdhcl +mapdheq +mapdheq2 +mapdheq2bin +mapdheq4 +mapdheq4lem +mapdhval +mapdhval0 +mapdhval2 +mapdhvmap +mapdin +mapdincl +mapdindp +mapdindp0 +mapdindp1 +mapdindp2 +mapdindp3 +mapdindp4 +mapdisjointmerge +mapdjuen +mapdlsm +mapdlsmcl +mapdm0 +mapdn0 +mapdncol +mapdom1 +mapdom2 +mapdom3 +mapdomainsubset +mapdord +mapdordlem1 +mapdordlem1a +mapdordlem1bn +mapdordlem2 +mapdpg +mapdpglem1 +mapdpglem10 +mapdpglem11 +mapdpglem12 +mapdpglem13 +mapdpglem14 +mapdpglem15 +mapdpglem16 +mapdpglem17n +mapdpglem18 +mapdpglem19 +mapdpglem2 +mapdpglem20 +mapdpglem21 +mapdpglem22 +mapdpglem23 +mapdpglem24 +mapdpglem25 +mapdpglem26 +mapdpglem27 +mapdpglem28 +mapdpglem29 +mapdpglem2a +mapdpglem3 +mapdpglem30 +mapdpglem30a +mapdpglem30b +mapdpglem31 +mapdpglem32 +mapdpglem4n +mapdpglem5n +mapdpglem6 +mapdpglem8 +mapdpglem9 +mapdrn +mapdrn2 +mapdrval +mapdrval2 +mapdrvallem2 +mapdrvallem3 +mapdsn +mapdsn2 +mapdsn3 +mapdsord +mapdspex +mapdunirnn +mapdval +mapdval2n +mapdval3n +mapdval4n +mapdval5n +mapdvalc +mapemptykeys +mapen +mapex +mapexold +mapfi +mapfien +mapfien2 +mapfienlem1 +mapfienlem2 +mapfienlem3 +mapfoss +mapfset +mapfstcompose +mapfstid +mapfvd +mapfzcons +mapfzcons1 +mapfzcons1cl +mapfzcons2 +mapid +mapkeysvalues +mapp +mappartial_eq_cons +mapping_connected_onto_segment +mapply_lemma +mapprc +mapprop +mappsrpr +mapputget +mappwen +mapremoveabsent +maprnin +mapsn +mapsncnv +mapsnconst +mapsnd +mapsndid +mapsnen +mapsnend +mapsnf1o +mapsnf1o2 +mapsnf1o3 +mapsnop +mapss +mapss2 +mapssbi +mapssfset +mapsspm +mapsspw +mapstream +mapunen +mapupdateidempotent +mapval +mapval2 +mapvalg +mapxpen +marep01ma +marepvcl +marepveval +marepvfval +marepvval +marepvval0 +margin_nonneg +markov +markov_ineq +markov_nat +marks[1] = 0 +marrepcl +marrepeval +marrepfval +marrepval +marrepval0 +marypha1 +marypha1lem +marypha2 +marypha2lem1 +marypha2lem2 +marypha2lem3 +marypha2lem4 +mat0 +mat0dim0 +mat0dimbas0 +mat0dimcrng +mat0dimid +mat0dimscm +mat0op +mat0scmat +mat1 +mat1bas +mat1comp +mat1dim0 +mat1dimbas +mat1dimcrng +mat1dimelbas +mat1dimid +mat1dimmul +mat1dimscm +mat1f +mat1f1o +mat1ghm +mat1mhm +mat1ov +mat1rhm +mat1rhmcl +mat1rhmelval +mat1rhmval +mat1ric +mat1rngiso +mat1scmat +mat2pmat1 +mat2pmatbas +mat2pmatbas0 +mat2pmatf +mat2pmatf1 +mat2pmatfval +mat2pmatghm +mat2pmatlin +mat2pmatmhm +mat2pmatmul +mat2pmatrhm +mat2pmatscmxcl +mat2pmatval +mat2pmatvalel +mat_0_component +mat_0_row +mat_cmul +mat_component +mat_eq +matassa +matbas +matbas0 +matbas0pc +matbas2 +matbas2d +matbas2i +match_abbrev_tac +match_accept_tac +match_asmsub_rename_tac +match_assum_abbrev_tac +match_goalsub_rename_tac +match_mp +match_mp_tac +match_rename_tac +matching_symmetric +matcpmric +matdim +matecl +matecld +matepm2cl +matepmcl +material_impl_fwd +material_impl_rev +matgrp +matgsum +matgsumcl +mathbox +matinv +matinvg +matinvgcell +matlmod +matmpo +matmulcell +matmulr +matplusg +matplusg2 +matplusgcell +matrcl +matrify_0 +matrify_add +matrify_cmul +matrify_component +matrify_eq_0 +matrify_sub +matrify_vectorize +matring +matrix_0 +matrix_add +matrix_add_ac +matrix_add_assoc +matrix_add_component +matrix_add_ldistrib +matrix_add_lid +matrix_add_lneg +matrix_add_rdistrib +matrix_add_rid +matrix_add_rneg +matrix_add_row +matrix_add_sym +matrix_adjoint +matrix_arith +matrix_arith_tac +matrix_augmented_linear_equations +matrix_cmul +matrix_cmul_add_ldistrib +matrix_cmul_add_rdistrib +matrix_cmul_assoc +matrix_cmul_component +matrix_cmul_eq_0 +matrix_cmul_lid +matrix_cmul_lzero +matrix_cmul_row +matrix_cmul_rzero +matrix_cmul_sub_ldistrib +matrix_cmul_sub_rdistrib +matrix_component +matrix_component_le_onorm +matrix_compose +matrix_det_transpose +matrix_diagonalizable +matrix_dim_mult +matrix_entire +matrix_eq +matrix_eq_0 +matrix_equal_columns +matrix_equal_rows +matrix_full_linear_equations +matrix_i +matrix_id +matrix_index +matrix_injective_0 +matrix_inv +matrix_inv_0 +matrix_inv_cmul +matrix_inv_cofactor +matrix_inv_covariance +matrix_inv_covariance_lmul +matrix_inv_covariance_rmul +matrix_inv_eq +matrix_inv_eq_0 +matrix_inv_i +matrix_inv_idempotent +matrix_inv_inv +matrix_inv_left +matrix_inv_mul +matrix_inv_mul_inner +matrix_inv_mul_linv +matrix_inv_mul_outer +matrix_inv_mul_rinv +matrix_inv_multiple_tranp_left +matrix_inv_multiple_tranp_right +matrix_inv_orthogonal_lmul +matrix_inv_orthogonal_rmul +matrix_inv_right +matrix_inv_transp +matrix_inv_unique +matrix_inv_unique_left +matrix_inv_unique_right +matrix_inv_unique_strong +matrix_invertible +matrix_invertible_left +matrix_invertible_left_gen +matrix_invertible_right +matrix_invertible_right_gen +matrix_left_inverse_cofactor +matrix_left_invertible +matrix_left_invertible_independent_columns +matrix_left_invertible_injective +matrix_left_invertible_ker +matrix_left_invertible_span_rows +matrix_left_right_inverse +matrix_mul_assoc +matrix_mul_component +matrix_mul_covariance_lcancel +matrix_mul_covariance_rcancel +matrix_mul_diagonal +matrix_mul_dot +matrix_mul_inv_eq_0 +matrix_mul_lcancel +matrix_mul_left_cofactor +matrix_mul_lid +matrix_mul_linv +matrix_mul_lmul +matrix_mul_lneg +matrix_mul_ltransp_dot_column +matrix_mul_lzero +matrix_mul_rcancel +matrix_mul_rid +matrix_mul_right_cofactor +matrix_mul_rinv +matrix_mul_rmul +matrix_mul_rneg +matrix_mul_rtransp_dot_row +matrix_mul_rzero +matrix_mul_vsum +matrix_mul_vsum_alt +matrix_mult_assoc +matrix_mult_dims +matrix_neg +matrix_neg_0 +matrix_neg_add +matrix_neg_component +matrix_neg_eq_0 +matrix_neg_minus1 +matrix_neg_neg +matrix_neg_row +matrix_neg_sub +matrix_nonfull_linear_equations +matrix_nonfull_linear_equations_eq +matrix_of_matrix_vector_mul +matrix_one_right +matrix_rational_approximation +matrix_reflect_along_basis +matrix_right_inverse_cofactor +matrix_right_invertible +matrix_right_invertible_independent_rows +matrix_right_invertible_span_columns +matrix_right_invertible_surjective +matrix_row_col +matrix_scalar_mult +matrix_self_adjoint +matrix_sub +matrix_sub_add +matrix_sub_add2 +matrix_sub_component +matrix_sub_eq +matrix_sub_ldistrib +matrix_sub_lzero +matrix_sub_rdistrib +matrix_sub_refl +matrix_sub_row +matrix_sub_rzero +matrix_trace_add +matrix_transp_mul +matrix_transp_multiple_inv_left +matrix_transp_multiple_inv_right +matrix_transpose +matrix_transpose_transpose +matrix_trivial_linear_equations +matrix_vector_column +matrix_vector_lmul +matrix_vector_mul +matrix_vector_mul_add_ldistrib +matrix_vector_mul_add_rdistrib +matrix_vector_mul_assoc +matrix_vector_mul_basis +matrix_vector_mul_component +matrix_vector_mul_covariance_eq_0 +matrix_vector_mul_in_columnspace +matrix_vector_mul_injective_on_rowspace +matrix_vector_mul_inv_eq_0 +matrix_vector_mul_lid +matrix_vector_mul_linear +matrix_vector_mul_lneg +matrix_vector_mul_lzero +matrix_vector_mul_rmul +matrix_vector_mul_rneg +matrix_vector_mul_rzero +matrix_vector_mul_sub_ldistrib +matrix_vector_mul_sub_rdistrib +matrix_vector_mul_transp +matrix_wlog_invertible +matrix_works +matrix_zero_left +matroid_basis_submatroid +matroid_choose_subspace +matroid_dim_alt +matroid_dim_empty +matroid_dim_eq_span +matroid_dim_ge_finite_card_eq +matroid_dim_insert +matroid_dim_span +matroid_dim_span_eq_gen +matroid_dimension_unique +matroid_finite_dimensional +matroid_finite_dimensional_dim +matroid_independent_insert +matroid_independent_submatroid +matroid_intermediate_basis +matroid_lowdim_expand_basis +matroid_lowdim_expand_dimension +matroid_span_eq +matroid_span_insert_eq +matroid_spanning_submatroid +matroid_spanning_subset_independent +matroid_steinitz_exchange_finite +matsc +matsca +matsca2 +matsubg +matsubgcell +mattpos1 +mattposcl +mattposm +mattpostpos +mattposvs +matunit +matunitlindf +matunitlindflem1 +matunitlindflem2 +matval +matvsca +matvsca2 +matvscacell +matvscl +mavmul0 +mavmul0g +mavmulass +mavmulcl +mavmuldm +mavmulfv +mavmulsolcl +mavmulval +mavmumamul1 +max +max0add +max0sub +max1 +max1alt +max1d +max2 +max2d +max_0 +max_alt +max_assoc +max_cases +max_comm +max_correct +max_eq_ge +max_flow +max_idem +max_le +max_lt +max_set_elim +max_set_eq_0 +max_set_in_set +max_set_inter +max_set_less +max_set_test +max_set_test_iff +max_set_thm +max_set_union +maxcomm +maxelement +maxentropy +maxidlidl +maxidlmax +maxidln0 +maxidln1 +maxidlnr +maxidlval +maximal_affine_independent_subset +maximal_affine_independent_subset_affine +maximal_independent_subset +maximal_independent_subset_extend +maximum_subarray_spec +maxle +maxlp +maxlt +maxprmfct +maxs1 +maxs2 +maxsta +maxsymmetric +maybe +maybebind +maybebindassoc +maybemap +maybemapcompose +maybetolist +mayete3i +mayetes3i +mball_euclidean +mbf0 +mbfadd +mbfaddlem +mbfconst +mbfconstlem +mbfdm +mbfdm2 +mbfdmssre +mbfeqa +mbfeqalem1 +mbfeqalem2 +mbff +mbfi1flim +mbfi1flimlem +mbfi1fseq +mbfi1fseqlem1 +mbfi1fseqlem2 +mbfi1fseqlem3 +mbfi1fseqlem4 +mbfi1fseqlem5 +mbfi1fseqlem6 +mbfid +mbfima +mbfimaicc +mbfimaopn +mbfimaopn2 +mbfimaopnlem +mbfimasn +mbfinf +mbflim +mbflimlem +mbflimsup +mbfmax +mbfmbfm +mbfmbfmold +mbfmcnt +mbfmcnvima +mbfmco +mbfmco2 +mbfmcst +mbfmf +mbfmfun +mbfmptcl +mbfmul +mbfmulc2 +mbfmulc2lem +mbfmulc2re +mbfmullem +mbfmullem2 +mbfmvolf +mbfneg +mbfpos +mbfposadd +mbfposb +mbfposr +mbfpsssmf +mbfres +mbfres2 +mbfres2cn +mbfresfi +mbfresmf +mbfss +mbfsub +mbfsup +mbfulm +mblfinlem1 +mblfinlem2 +mblfinlem3 +mblfinlem4 +mblsplit +mblss +mblvol +mblvon +mbounded_and_mdiameter_le +mbounded_euclidean +mcball_euclidean +mccarthyninetyone +mccl +mccllem +mclsax +mclsind +mclspps +mclsppslem +mclsrcl +mclsssv +mclsssvlem +mclsval +mcomplete_cfunspace +mcomplete_euclidean +mcubic +mdandysum2p2e4 +mdandyv0 +mdandyv1 +mdandyv10 +mdandyv11 +mdandyv12 +mdandyv13 +mdandyv14 +mdandyv15 +mdandyv2 +mdandyv3 +mdandyv4 +mdandyv5 +mdandyv6 +mdandyv7 +mdandyv8 +mdandyv9 +mdandyvr0 +mdandyvr1 +mdandyvr10 +mdandyvr11 +mdandyvr12 +mdandyvr13 +mdandyvr14 +mdandyvr15 +mdandyvr2 +mdandyvr3 +mdandyvr4 +mdandyvr5 +mdandyvr6 +mdandyvr7 +mdandyvr8 +mdandyvr9 +mdandyvrx0 +mdandyvrx1 +mdandyvrx10 +mdandyvrx11 +mdandyvrx12 +mdandyvrx13 +mdandyvrx14 +mdandyvrx15 +mdandyvrx2 +mdandyvrx3 +mdandyvrx4 +mdandyvrx5 +mdandyvrx6 +mdandyvrx7 +mdandyvrx8 +mdandyvrx9 +mdbr +mdbr2 +mdbr3 +mdbr4 +mdcompli +mddmd +mddmd2 +mddmdin0i +mdeg0 +mdegaddle +mdegcl +mdegfval +mdegldg +mdegle0 +mdegleb +mdeglt +mdegmulle2 +mdegmullem +mdegnn0cl +mdegpropd +mdegval +mdegvsca +mdegvscale +mdegxrcl +mdegxrf +mdet0 +mdet0f1o +mdet0fv0 +mdet0pr +mdet1 +mdetcl +mdetdiag +mdetdiagid +mdetdiaglem +mdetero +mdetf +mdetfval +mdetfval1 +mdetlap +mdetlap1 +mdetleib +mdetleib1 +mdetleib2 +mdetmul +mdetpmtr1 +mdetpmtr12 +mdetpmtr2 +mdetr0 +mdetralt +mdetralt2 +mdetrlin +mdetrlin2 +mdetrsca +mdetrsca2 +mdettpos +mdetuni +mdetuni0 +mdetunilem1 +mdetunilem2 +mdetunilem3 +mdetunilem4 +mdetunilem5 +mdetunilem6 +mdetunilem7 +mdetunilem8 +mdetunilem9 +mdexchi +mdi +mdiameter_bounded +mdiameter_closure +mdiameter_compact_attained +mdiameter_euclidean +mdiameter_le +mdiameter_pos_le +mdiameter_sing +mdiameter_subset +mdiameter_subset_mcball_nonempty +mdiameter_union_le +mdist +mdiv +mdoc1i +mdoc2i +mdsl0 +mdsl1i +mdsl2bi +mdsl2i +mdsl3 +mdsldmd1i +mdslj1i +mdslj2i +mdslle1i +mdslle2i +mdslmd1i +mdslmd1lem1 +mdslmd1lem2 +mdslmd1lem3 +mdslmd1lem4 +mdslmd2i +mdslmd3i +mdslmd4i +mdsym +mdsymi +mdsymlem1 +mdsymlem2 +mdsymlem3 +mdsymlem4 +mdsymlem5 +mdsymlem6 +mdsymlem7 +mdsymlem8 +mdvval +mea0 +meacl +meadif +meadjiun +meadjiunlem +meadjun +meadjuni +meadjunre +meaf +meage0 +meaiininc +meaiininc2 +meaiininclem +meaiuninc +meaiuninc2 +meaiuninc3 +meaiuninc3v +meaiunincf +meaiuninclem +meaiunle +meaiunlelem +meale0eq0 +mean_inequality +means +measbase +measbasedom +meascnbl +measdivcst +measdivcstaltv +measfn +measfrge0 +measge0 +measinb +measinb2 +measinblem +measiun +measiuns +measle0 +measres +meassle +meassre +measssd +measun +measunl +measurable +measurable_additive_imp_linear +measurable_affinity +measurable_affinity_eq +measurable_almost +measurable_ball +measurable_bounded_ae_by_integrable_imp_integrable +measurable_bounded_by_integrable_imp_integrable +measurable_cball +measurable_closed_in +measurable_closure +measurable_compact +measurable_continuous_compose +measurable_convex +measurable_convex_eq +measurable_convex_hull +measurable_countable_inters +measurable_countable_inters_gen +measurable_countable_unions +measurable_countable_unions_bounded +measurable_countable_unions_strong +measurable_delete +measurable_diff +measurable_differentiable_image_alt +measurable_differentiable_image_eq +measurable_elementary +measurable_empty +measurable_eq_almost_baire1 +measurable_eq_almost_baire2 +measurable_frontier +measurable_function_preimage +measurable_iff_lebesgue_measurable_under_curve +measurable_imp_lebesgue_measurable +measurable_inner_compact +measurable_inner_outer +measurable_insert +measurable_inside +measurable_integrable +measurable_inter +measurable_inter_halfspace_ge +measurable_inter_halfspace_le +measurable_inter_interval +measurable_interior +measurable_interval +measurable_jordan +measurable_lebesgue_measurable_inter_measurable +measurable_lebesgue_measurable_subset +measurable_linear_image +measurable_linear_image_eq +measurable_linear_image_eq_gen +measurable_linear_image_gen +measurable_linear_image_interval +measurable_lipschitz_image +measurable_locally_lipschitz_image +measurable_measurable_diff_lebesgue_measurable +measurable_measurable_inter_lebesgue_measurable +measurable_measurable_preimage_closed +measurable_measurable_preimage_open +measurable_measure_eq_0 +measurable_measure_pos_lt +measurable_midpoint_convex_imp_continuous +measurable_midpoint_convex_imp_convex_1d +measurable_midpoint_convex_imp_convex_cball +measurable_midpoint_convex_imp_convex_gen +measurable_midpoint_convex_imp_convex_open +measurable_negations +measurable_negligible_symdiff +measurable_negligible_symdiff_eq +measurable_nested_unions +measurable_nonnegligible_imp_large +measurable_on_0 +measurable_on_add +measurable_on_banach_indicatrix +measurable_on_bilinear +measurable_on_cases +measurable_on_cmul +measurable_on_cmul_eq +measurable_on_combine +measurable_on_componentwise +measurable_on_compose_alt +measurable_on_compose_continuous +measurable_on_compose_continuous_0 +measurable_on_compose_continuous_closed_set +measurable_on_compose_continuous_closed_set_0 +measurable_on_compose_continuous_open_interval +measurable_on_compose_fstcart +measurable_on_compose_gen +measurable_on_compose_rev +measurable_on_compose_sndcart +measurable_on_compose_sub +measurable_on_const +measurable_on_const_eq +measurable_on_continuous_compose +measurable_on_continuous_compose_rev +measurable_on_convolution +measurable_on_countable_unions +measurable_on_det_jacobian +measurable_on_diff +measurable_on_differentiable_image +measurable_on_drop_mul +measurable_on_empty +measurable_on_eq +measurable_on_indicator +measurable_on_indicator_subset +measurable_on_inter +measurable_on_inverse_function +measurable_on_lebesgue_measurable_preimage_open_eq +measurable_on_lebesgue_measurable_subset +measurable_on_left_inverse +measurable_on_lift_abs +measurable_on_lift_div +measurable_on_lift_inv +measurable_on_lift_mul +measurable_on_lift_pow +measurable_on_lift_product +measurable_on_limit +measurable_on_linear_image_eq +measurable_on_linear_image_eq_gen +measurable_on_max +measurable_on_measurable_preimage_closed +measurable_on_measurable_preimage_closed_eq +measurable_on_measurable_preimage_open +measurable_on_measurable_preimage_open_eq +measurable_on_measurable_subset +measurable_on_min +measurable_on_mul +measurable_on_neg +measurable_on_neg_eq +measurable_on_norm +measurable_on_open_interval +measurable_on_partial_derivatives +measurable_on_pastecart +measurable_on_preimage_analytic +measurable_on_preimage_borel +measurable_on_preimage_closed +measurable_on_preimage_closed_interval +measurable_on_preimage_closed_interval_dense +measurable_on_preimage_halfspace_component_ge +measurable_on_preimage_halfspace_component_gt +measurable_on_preimage_halfspace_component_le +measurable_on_preimage_open +measurable_on_preimage_open_interval +measurable_on_preimage_open_interval_dense +measurable_on_preimage_orthant_ge +measurable_on_preimage_orthant_ge_dense +measurable_on_preimage_orthant_gt +measurable_on_preimage_orthant_gt_dense +measurable_on_preimage_orthant_le +measurable_on_preimage_orthant_le_dense +measurable_on_preimage_orthant_lt +measurable_on_preimage_orthant_lt_dense +measurable_on_real_sgn +measurable_on_reflect +measurable_on_restrict +measurable_on_right_inverse +measurable_on_simple_function_limit_increasing +measurable_on_spike +measurable_on_spike_set +measurable_on_spike_set_eq +measurable_on_sub +measurable_on_translation +measurable_on_translation_eq +measurable_on_union +measurable_on_unions +measurable_on_univ +measurable_on_vector_derivative +measurable_on_vector_derivative_gen +measurable_on_vsum +measurable_open +measurable_open_in +measurable_outer_closed_intervals +measurable_outer_intervals_bounded +measurable_outer_open +measurable_outer_open_intervals +measurable_pcross +measurable_scaling +measurable_scaling_eq +measurable_segment +measurable_simplex +measurable_sing +measurable_small_imp_negligible +measurable_tetrahedron +measurable_translation +measurable_translation_eq +measurable_triangle +measurable_union +measurable_unions +measure_affinity +measure_ball_bound +measure_ball_pos +measure_ball_scaling +measure_cball_bound +measure_cball_pos +measure_cball_scaling +measure_closure +measure_continuity_below +measure_continuous_with_hausdist +measure_continuous_with_hausdist_explicit +measure_countable_additivity +measure_countable_unions_approachable +measure_countable_unions_le +measure_countable_unions_le_gen +measure_countable_unions_le_strong +measure_countable_unions_le_strong_gen +measure_delete +measure_diff_subset +measure_differentiable_image_approx +measure_differentiable_image_approx_gen +measure_differentiable_image_eq +measure_disjoint_union +measure_disjoint_union_eq +measure_disjoint_unions +measure_disjoint_unions_image +measure_disjoint_unions_image_strong +measure_elementary +measure_empty +measure_empty_zero +measure_eq_0 +measure_frontier +measure_insert +measure_integral +measure_integral_univ +measure_interior +measure_interval +measure_interval_1 +measure_interval_1_alt +measure_interval_2 +measure_interval_2_alt +measure_interval_3 +measure_interval_3_alt +measure_interval_4 +measure_interval_4_alt +measure_isometry +measure_limit +measure_linear_image +measure_linear_image_same +measure_lipschitz_image +measure_locally_lipschitz_image +measure_monotone +measure_negations +measure_negligible_symdiff +measure_negligible_union +measure_negligible_union_eq +measure_negligible_unions +measure_negligible_unions_image +measure_negligible_unions_image_strong +measure_nonneg +measure_open_pos_lt +measure_open_pos_lt_eq +measure_orthogonal_image_eq +measure_pastecart_interval +measure_pcross +measure_pos_le +measure_scaling +measure_segment_1 +measure_semicontinuous_with_hausdist_bound +measure_semicontinuous_with_hausdist_explicit +measure_sigma_algebra_compl +measure_sigma_algebra_empty +measure_sigma_algebra_union +measure_simplex +measure_sing +measure_sub_le_measure_diff +measure_sub_le_measure_symdiff +measure_subadditivity +measure_subset +measure_tetrahedron +measure_translation +measure_triangle +measure_union +measure_union_le +measure_unions_le +measure_unions_le_image +measure_unique +measval +measvnul +measvun +measvuni +measvunilem +measvunilem0 +measvxrge0 +measxun2 +meaunle +meaxrcl +meet0 +meetat +meetat2 +meetcl +meetcom +meetcomalt +meetdef +meetdm +meetdm2 +meetdm3 +meetdmss +meeteu +meetfval +meetfval2 +meetle +meetlem +meetval +meetval2 +meetval2lem +mem +mem_append +mem_append_left +mem_append_lemma +mem_append_right +mem_cons_of_mem +mem_cons_self +mem_drop +mem_dropwhile_imp +mem_el +mem_exists_set +mem_filter +mem_flat +mem_genlist +mem_linear_image +mem_lupdate +mem_lupdate_e +mem_map +mem_map_f +mem_nil +mem_nub +mem_split_append_first +mem_split_append_last +mem_tl +mem_translation +mem_zip +mem_zip_mem_map +member +member-append +member-insert +member-of-nth +member-of-sorted +member_append +member_le_sum +member_not_empty +member_sl +membpartlem19 +memory +mendassa +mendbas +mendlmod +mendmulr +mendmulrfval +mendplusg +mendplusgfval +mendring +mendsca +mendval +mendvsca +mendvscafval +meran1 +meran2 +meran3 +merco1 +merco1lem1 +merco1lem10 +merco1lem11 +merco1lem12 +merco1lem13 +merco1lem14 +merco1lem15 +merco1lem16 +merco1lem17 +merco1lem18 +merco1lem2 +merco1lem3 +merco1lem4 +merco1lem5 +merco1lem6 +merco1lem7 +merco1lem8 +merco1lem9 +merco2 +mercolem1 +mercolem2 +mercolem3 +mercolem4 +mercolem5 +mercolem6 +mercolem7 +mercolem8 +meredith +merge_aux_spec +merge_permut +merge_sorted +merge_spec +mergesort_permut +mergesort_sorted +mergesort_spec +mergesortedarrays +mergeview +merkle_root_unique +merlem1 +merlem10 +merlem11 +merlem12 +merlem13 +merlem2 +merlem3 +merlem4 +merlem5 +merlem6 +merlem7 +merlem8 +merlem9 +mersenne +mertens +mertenslem1 +mertenslem2 +meson +meson_tac +message_integrity +met0 +met1stc +met2ndc +met2ndci +metamath +metcl +metcld +metcld2 +metcn +metcn4 +metcnp +metcnp2 +metcnp3 +metcnp4 +metcnpi +metcnpi2 +metcnpi3 +metdcn +metdcn2 +metdcnlem +metdmdm +metds0 +metdscn +metdscn2 +metdscnlem +metdseq0 +metdsf +metdsge +metdsle +metdsre +metdstri +metdsval +metelcls +meteq0 +metequiv +metequiv2 +metf +metf1o +metflem +metge0 +metgt0 +methaus +method_combinator +metideq +metider +metidss +metidv +metidval +metis +metis_resolve +metis_tac +metn0 +metnrm +metnrmlem1 +metnrmlem1a +metnrmlem2 +metnrmlem3 +metpsmet +metreg +metres +metres2 +metreslem +metrest +metric_cauchy_convergent +metric_compact_sequentially +metric_complete_closed +metric_continuous_map +metric_derived_set_of +metric_dist_nonneg +metric_dist_sym +metric_dist_zero +metric_equiv_open_sets +metric_lipschitz_continuous +metric_open_ball_open +metric_triangle_ineq +metrizable_imp_k_space +metrizable_imp_kc_space +metrizable_imp_normal_space +metrizable_imp_paracompact_space +metrizable_space_euclidean +metrizable_space_mtopology +metrizable_space_separation +metrizable_space_subtopology +metrtri +metss +metss2 +metss2lem +metsscmetcld +metsym +mettri +mettri2 +mettri3 +mettrifi +metucn +metuel +metuel2 +metust +metustbl +metustel +metustexhalf +metustfbas +metustid +metustrel +metustss +metustsym +metustto +metuust +metuval +metxmet +mexval +mexval2 +mfsdisj +mgccnv +mgccole1 +mgccole2 +mgcf1 +mgcf1o +mgcf1olem1 +mgcf1olem2 +mgcf2 +mgcmnt1 +mgcmnt1d +mgcmnt2 +mgcmnt2d +mgcmntco +mgcoval +mgcval +mgm0 +mgm0b +mgm1 +mgm2mgm +mgm2nsgrp +mgm2nsgrplem1 +mgm2nsgrplem2 +mgm2nsgrplem3 +mgm2nsgrplem4 +mgmb1mgm1 +mgmcl +mgmhmco +mgmhmeql +mgmhmf +mgmhmf1o +mgmhmima +mgmhmlin +mgmhmpropd +mgmhmrcl +mgmidcl +mgmidmo +mgmidsssn0 +mgmlrid +mgmnsgrpex +mgmplusf +mgmplusfreseq +mgmplusgiopalt +mgmpropd +mgmsscl +mgpbas +mgpds +mgpf +mgpplusg +mgpress +mgpsca +mgpsumn +mgpsumunsn +mgpsumz +mgptopn +mgptset +mgpval +mh-setind +mh-setindnd +mhm0 +mhmco +mhmcoaddmpl +mhmcoaddpsr +mhmcompl +mhmcoply1 +mhmcopsr +mhmeql +mhmf +mhmf1o +mhmfmhm +mhmhmeotmd +mhmid +mhmima +mhmimalem +mhmimasplusg +mhmismgmhm +mhmlem +mhmlin +mhmmnd +mhmmulg +mhmpropd +mhmrcl1 +mhmrcl2 +mhmvlin +mhp0cl +mhpaddcl +mhpdeg +mhpfval +mhphf +mhphf2 +mhphf3 +mhphf4 +mhphflem +mhpind +mhpinvcl +mhplss +mhpmpl +mhpmulcl +mhppwdeg +mhprcl +mhpsclcl +mhpsubg +mhpval +mhpvarcl +mhpvscacl +mid_spec +midbtwn +midcgr +midcl +midcom +middle +midef +mideu +mideulem +mideulem2 +midex +midexlem +midf +midid +midofsegid +midpoint_between +midpoint_collinear +midpoint_convex_dyadic_rationals +midpoint_convex_imp_continuous_ostrowski +midpoint_convex_imp_convex_ostrowski +midpoint_convex_set +midpoint_eq_endpoint +midpoint_in_convex +midpoint_in_segment +midpoint_linear_image +midpoint_refl +midpoint_sym +midpoints_in_convex_hull +miduniq +miduniq1 +miduniq2 +midwwlks2s3 +miller_rabin_composite_imp_composite +miller_rabin_composite_imp_composite_alt +miller_rabin_eq_fermat_pseudoprime_explicit +miller_rabin_imp_fermat_pseudoprime_explicit +miller_rabin_pseudoprime_1 +miller_rabin_pseudoprime_bound +miller_rabin_pseudoprime_bound_gen +miller_rabin_pseudoprime_bound_lt +miller_rabin_pseudoprime_bound_phi +miller_rabin_pseudoprime_cong +miller_rabin_pseudoprime_imp_coprime +miller_rabin_pseudoprime_inverse_mod +miller_rabin_pseudoprime_mod_1 +min +min1 +min1d +min2 +min2d +min_0 +min_alt +min_assoc +min_cases +min_comm +min_cost_flow +min_element +min_eq_le +min_idem +min_le +min_lt +min_max_absorb +min_max_eq +min_max_le +min_max_lt +min_max_pred +min_set_elim +min_set_eq_0 +min_set_lem +min_set_leq_max_set +min_set_test +min_set_test_iff +min_set_thm +min_set_union +min_spec +minel +minimal +minimal_bad_sequence +minimal_continuum +minimal_separating_common_component_frontier +minimax +minimax_theorem +minimp +minimp-ax1 +minimp-ax2 +minimp-ax2c +minimp-pm2.43 +minimp-syllsimp +minmar1cl +minmar1eval +minmar1fval +minmar1marrep +minmar1val +minmar1val0 +minmax +minplyann +minplycl +minplyelirng +minplyirred +minplyirredlem +minplym1p +minplymindeg +minplynzm1p +minplyval +minregex +minregex2 +mins1 +mins2 +minsymmetric +minusmod5ne +minusmodnep2tmod +minvec +minveclem1 +minveclem2 +minveclem3 +minveclem3a +minveclem3b +minveclem4 +minveclem4a +minveclem4b +minveclem4c +minveclem5 +minveclem6 +minveclem7 +minveco +minvecolem1 +minvecolem2 +minvecolem3 +minvecolem4 +minvecolem4a +minvecolem4b +minvecolem4c +minvecolem5 +minvecolem6 +minvecolem7 +mirauto +mirbtwn +mirbtwnb +mirbtwnhl +mirbtwni +mircgr +mircgrextend +mircgrs +mircinv +mircl +mircom +mirconn +mireq +mirf +mirf1o +mirfv +mirhl +mirhl2 +mirinv +miriso +mirln +mirln2 +mirmid +mirmir +mirmir2 +mirmot +mirne +mirrag +mirreu +mirreu3 +mirror +mirror-involutive +mirror-preserves-size +mirror_height +mirror_involutive +mirror_mirror +mirror_size +mirtrcgr +mirval +mit +mk_comb +mnccoe +mncn0 +mncply +mnd1 +mnd12g +mnd1id +mnd32g +mnd4g +mndass +mndassd +mndbn0 +mndcl +mndcld +mndfo +mndid +mndidcl +mndideu +mndifsplit +mndind +mndinvmod +mndissubm +mndlactf1 +mndlactf1o +mndlactfo +mndlid +mndlrid +mndlrinv +mndlrinvb +mndlsmidm +mndmgm +mndmolinv +mndodcong +mndodcongi +mndodconglem +mndoisexid +mndoismgmold +mndoissmgrpold +mndomgmid +mndpfo +mndpfsupp +mndpluscn +mndplusf +mndprop +mndpropd +mndpsuppfi +mndpsuppss +mndractf1 +mndractf1o +mndractfo +mndrid +mndsgrp +mndsssgrp +mndtcbas +mndtcbas2 +mndtcbasval +mndtccat +mndtccatid +mndtcco +mndtcco2 +mndtchom +mndtcid +mndtcob +mndtcval +mndvass +mndvcl +mndvlid +mndvrid +mnfaddpnf +mnfle +mnfled +mnflt +mnflt0 +mnfltd +mnfltpnf +mnfltxr +mnfnei +mnfnepnf +mnfnre +mnfnre2 +mnfxr +mnring0g2d +mnring0gd +mnringaddgd +mnringbased +mnringbasefd +mnringbasefsuppd +mnringbaserd +mnringelbased +mnringlmodd +mnringmulrcld +mnringmulrd +mnringmulrvald +mnringnmulrd +mnringscad +mnringvald +mnringvscad +mnt +mntf +mntoval +mnu0eld +mnugrud +mnuop123d +mnuop23d +mnuop3d +mnuprd +mnuprdlem1 +mnuprdlem2 +mnuprdlem3 +mnuprdlem4 +mnuprss2d +mnuprssd +mnupwd +mnurnd +mnurndlem1 +mnurndlem2 +mnusnd +mnuss2d +mnussd +mnutrcld +mnutrd +mnuund +mnuunid +mo +mo0 +mo0sn +mo2icl +mo3 +mo4 +mo4f +mo5f +moa1 +moabex +moabexold +moabs +moan +moaneu +moani +moanim +moanimlem +moanimv +moanmo +moantr +mob +mob2 +mobi +mobid +mobidv +mobidvalt +mobii +mod +mod-+-cancel +mod-+-cases +mod-bounds +mod-bounds-x +mod0 +mod0mul +mod1ile +mod2_mul2 +mod2_mul2_aux +mod2_mul2_aux2 +mod2addne +mod2eq0even +mod2eq1n2dvds +mod2ile +mod2xi +mod2xnegi +mod42tp1mod8 +mod_15 +mod_2 +mod_add +mod_add_assoc +mod_add_inv +mod_bounds +mod_common_factor +mod_elim +mod_eq_0 +mod_eq_0_divisor +mod_eq_0_iff +mod_eqn +mod_exp +mod_less +mod_less_eq +mod_lift_plus +mod_lift_plus_iff +mod_lt +mod_mod +mod_mod_less_eq +mod_mult +mod_mult_assoc +mod_mult_mod +mod_multiple_zero +mod_one +mod_p +mod_p_univ +mod_plus +mod_plus3 +mod_self +mod_sub +mod_suc +mod_suc_iff +mod_times +mod_times2 +mod_times_sub +mod_unique +modabs +modabs2 +modabsdifz +modadd1 +modadd12d +modadd2mod +modaddabs +modaddb +modaddid +modaddmod +modaddmodlo +modaddmodup +modaddmulmod +modal-b +modal5 +modal_4 +modal_5 +modal_dual +modal_k +modal_t +modarith +modbounds +modcl +modcld +modcyc +modcyc2 +moddi +moddiffl +moddifz +moddvds +modelac8prim +modelaxrep +modelaxreplem1 +modelaxreplem2 +modelaxreplem3 +modelico +modeq_0 +modeq_0_cong +modeq_exp_cong +modeq_intro_cong +modeq_mod +modeq_mult_cong +modeq_nonzero_modequality +modeq_numeral +modeq_plus_cong +modeq_refl +modeq_suc_cong +modeq_sym +modeq_thm +modeq_trans +modeqmodmin +modexp +modexp2m1d +modfrac +modfsummod +modfsummods +modfsummodslem1 +modfzo0difsn +modgcd +modge0 +modid +modid0 +modid2 +modifeq2int +modifies +modirr +modlt +modlt0b +modlteq +modltm1p1mod +modm1div +modm1nem2 +modm1nep1 +modm1nep2 +modm1p1mod0 +modm1p1ne +modm2nep1 +modmknepk +modmkpkne +modmul1 +modmul12d +modmuladd +modmuladdim +modmuladdnn0 +modmulconst +modmulmod +modmulmodr +modmulnn +modn0mul +modnegd +modom +modom2 +modp2nep1 +modprm0 +modprm1div +modprminv +modprminveq +modprmn0modprm0 +modremain +modsub12d +modsubdir +modsubi +modsubmod +modsubmodmod +modsumfzodifsn +module +module-impl +module-sig +module_impl +module_signature +moduluscauchy +modus_ponens +modus_ponens_pf +modval +modvalp1 +modvalr +modxai +modxp1i +moel +moeq +moeq3 +moeu +moeu2 +moeuex +moexex +moexexlem +moexexv +moexexvw +mof +mof0 +mof02 +mof0alt +mofal +mofeu +mofmo +mofsn +mofsn2 +mofsssn +mogoldbb +mogoldbblem +moi +moi2 +moim +moimdv +moimi +mojust +mon1pcl +mon1pid +mon1pldg +mon1pn0 +mon1psubm +mon1puc1p +mon1pval +monadassoc +monadleftid +monadrightid +monfval +monhom +moni +monmat2matmon +monmatcollpw +mono_and +mono_exists +mono_forall +mono_imp +mono_or +monoid_assoc +monoid_left_id +monoid_right_id +monoidal_and +monoidal_lifted +monoidal_real_add +monoidal_real_mul +monoidal_vector_add +monoord +monoord2 +monoord2xr +monoord2xrv +monoords +monoordxr +monoordxrv +monothetic +monotoddzz +monotoddzzfi +monotone_bigger +monotone_closed_map +monotone_convergence +monotone_convergence_decreasing +monotone_convergence_decreasing_ae +monotone_convergence_increasing +monotone_convergence_increasing_ae +monotone_convergence_interval +monotone_open_map +monotonic +monotonic_ref_read +monotonic_ref_write +monotuz +monpropd +monsect +moop2 +moor +mooran1 +mooran2 +moore_penrose_pseudoinverse +moore_penrose_pseudoinverse_unique +mopick +mopick2 +mopickr +mopn0 +mopnex +mopnfss +mopni +mopni2 +mopni3 +mopnin +mopnm +mopnss +mopntop +mopntopon +mopnuni +mopnval +mopre +morex +moriotass +mormo +morphism +mosn +mosneq +mosssn +mosssn2 +mosub +mosubop +mosubopt +motcgr +motcgr3 +motcgrg +motcl +motco +motf1o +motgrp +motplusg +motrag +moxfr +mp +mp1i +mp2 +mp2an +mp2and +mp2ani +mp2b +mp2d +mp2pm2mp +mp2pm2mplem1 +mp2pm2mplem2 +mp2pm2mplem3 +mp2pm2mplem4 +mp2pm2mplem5 +mp3an +mp3an1 +mp3an12 +mp3an12i +mp3an13 +mp3an1i +mp3an2 +mp3an23 +mp3an2ani +mp3an2i +mp3an3 +mp3an3an +mp3and +mp3anl1 +mp3anl2 +mp3anl3 +mp3anr1 +mp3anr2 +mp3anr3 +mp4an +mp_tac +mpaacl +mpaadgr +mpaaeu +mpaalem +mpaamn +mpaaroot +mpaaval +mpan +mpan2 +mpan2d +mpan2i +mpan9 +mpancom +mpand +mpani +mpanl1 +mpanl12 +mpanl2 +mpanlr1 +mpanr1 +mpanr12 +mpanr2 +mpbi +mpbi2and +mpbid +mpbidi +mpbii +mpbir +mpbir2an +mpbir2and +mpbir3an +mpbir3and +mpbiran +mpbiran2 +mpbiran2d +mpbiran3d +mpbiran4d +mpbirand +mpbird +mpbiri +mpcom +mpct +mpd +mpd3an23 +mpd3an3 +mpdan +mpdd +mpdi +mpet +mpet2 +mpet3 +mpets +mpets2 +mpfaddcl +mpfconst +mpff +mpfind +mpfmulcl +mpfpf1 +mpfproj +mpfrcl +mpfsubrg +mpg +mpgbi +mpgbir +mpi +mpid +mpidan +mpii +mpisyl +mpjao3dan +mpjaod +mpjaodan +mpl0 +mpl1 +mpladd +mplascl +mplascl0 +mplascl1 +mplasclf +mplassa +mplbas +mplbas2 +mplbaspropd +mplbasss +mplcoe1 +mplcoe2 +mplcoe3 +mplcoe4 +mplcoe5 +mplcoe5lem +mplcrng +mplcrngd +mplelbas +mplelf +mplelsfi +mplgrp +mplind +mpllmod +mpllmodd +mpllss +mpllsslem +mpllvec +mplmapghm +mplmon +mplmon2 +mplmon2cl +mplmon2mul +mplmonmul +mplmul +mplmulmvr +mplmulr +mplneg +mplplusg +mplrcl +mplring +mplringd +mplsca +mplsubg +mplsubglem +mplsubglem2 +mplsubrg +mplsubrgcl +mplsubrglem +mplval +mplval2 +mplvrpmfgalem +mplvrpmga +mplvrpmlem +mplvrpmmhm +mplvrpmrhm +mplvsca +mplvsca2 +mplvscaval +mply1topmatcl +mply1topmatcllem +mply1topmatval +mpnanrd +mpo0 +mpo0v +mpo2eqb +mpoaddex +mpoaddf +mpobi123f +mpocnfldadd +mpocnfldmul +mpocti +mpocurryd +mpocurryvald +mpodifsnif +mpodvdsmulf1o +mpoeq12 +mpoeq123 +mpoeq123dv +mpoeq123dva +mpoeq123i +mpoeq3dv +mpoeq3dva +mpoeq3ia +mpoex +mpoexg +mpoexga +mpoexw +mpoexxg +mpoexxg2 +mpofrlmd +mpofun +mpomatmul +mpompt +mpompts +mpomptsx +mpomptx +mpomptx2 +mpomptxf +mpomulcn +mpomulex +mpomulf +mpomulnzcnf +mpondm0 +mposn +mposnif +mpov +mpoxeldm +mpoxneldm +mpoxopn0yelv +mpoxopovel +mpoxopoveq +mpoxopoveqd +mpoxopx0ov0 +mpoxopxnop0 +mpoxopxprcov0 +mpoxopynvov0 +mpoxopynvov0g +mppspst +mppspstlem +mppsthm +mppsval +mprg +mprgbir +mpst123 +mpstrcl +mpstssv +mpstval +mpsyl +mpsyl4anc +mpsylsyld +mpt0 +mptbi12f +mptcfsupp +mptcnfimad +mptcnv +mptcoe1fsupp +mptcoe1matfsupp +mptct +mptctf +mptelee +mpteleeold +mptelixpg +mptelpm +mpteq1 +mpteq12 +mpteq12da +mpteq12df +mpteq12dv +mpteq12dva +mpteq12f +mpteq12i +mpteq1d +mpteq1df +mpteq1i +mpteq2da +mpteq2dfa +mpteq2dv +mpteq2dva +mpteq2i +mpteq2ia +mpteqb +mptex +mptexd +mptexf +mptexg +mptexgf +mptexw +mptfcl +mptfi +mptfnd +mptfnf +mptfng +mptfvmpt +mptfzshft +mptiffisupp +mptima +mptimass +mptiniseg +mptmpoopabbrd +mptmpoopabbrdold +mptmpoopabovd +mptnan +mptnn0fsupp +mptnn0fsuppd +mptnn0fsuppr +mptpreima +mptprop +mptrabex +mptrcl +mptrcllem +mptrel +mptresid +mptru +mptscmfsupp0 +mptscmfsuppd +mptsnun +mptsnunlem +mptss +mptssalt +mptssid +mptsuppd +mptsuppdifd +mptun +mptv +mptxor +mpv +mrccl +mrccls +mrccss +mrcf +mrcflem +mrcfval +mrcid +mrcidb +mrcidb2 +mrcidm +mrcidmd +mrclsp +mrcrsp +mrcsncl +mrcss +mrcsscl +mrcssd +mrcssid +mrcssidd +mrcssv +mrcssvd +mrcun +mrcuni +mrcval +mre1cl +mreacs +mreclat +mreclatbad +mreclatdemobad +mreexd +mreexdomd +mreexexd +mreexexlem2d +mreexexlem3d +mreexexlem4d +mreexexlemd +mreexfidimd +mreexmrid +mrefg2 +mrefg3 +mreiincl +mreincl +mreintcl +mrelatglb +mrelatglb0 +mrelatglbalt +mrelatlub +mrelatlubalt +mremre +mreriincl +mrerintcl +mress +mressmrcd +mresspw +mretopd +mreuni +mreunirn +mreuniss +mrexval +mrieqv2d +mrieqvd +mrieqvlemd +mriss +mrissd +mrissmrcd +mrissmrid +mrisval +mrsub0 +mrsubccat +mrsubcn +mrsubco +mrsubcv +mrsubf +mrsubff +mrsubff1 +mrsubff1o +mrsubffval +mrsubfval +mrsubrn +mrsubval +mrsubvr +mrsubvrs +mscl +msdcn +msf +msg +msg_type +msmet +msmet2 +mspace +mspropd +msq0d +msq0i +msq11 +msq11i +msqge0 +msqge0d +msqge0i +msqgt0 +msqgt0d +msqgt0i +msqsqrtd +msqznn +msrf +msrfo +msrfval +msrid +msrrcl +msrtri +msrval +mst_correct +mstapst +mstaval +mstopn +mstps +mstri +mstri2 +mstri3 +msubco +msubf +msubff +msubff1 +msubff1o +msubffval +msubfval +msubrn +msubrsub +msubty +msubval +msubvrs +msxms +mt2 +mt2bi +mt2d +mt2i +mt3 +mt3d +mt3i +mt4 +mt4d +mt4i +mtand +mtbi +mtbid +mtbii +mtbir +mtbird +mtbiri +mteqand +mtest +mtestbdd +mthmb +mthmblem +mthmi +mthmpps +mthmsta +mthmval +mto +mtod +mtoi +mtopology_euclidean_metric +mtopology_prod_metric +mtopology_real_euclidean_metric +mtopology_submetric +mtord +mtpor +mtpxor +mtt +mtyf +mtyf2 +mucl +mudivsum +muf +muinv +mul +mul01 +mul01d +mul01i +mul02 +mul02d +mul02i +mul02lem1 +mul02lem2 +mul0or +mul0ord +mul0ori +mul12 +mul12d +mul12i +mul13d +mul2lt0bi +mul2lt0lgt0 +mul2lt0llt0 +mul2lt0rgt0 +mul2lt0rlt0 +mul2neg +mul2negd +mul2negi +mul2negsd +mul2sq +mul31 +mul31d +mul32 +mul32d +mul32i +mul4 +mul4d +mul4i +mul4r +mul4sq +mul4sqlem +mul_assoc +mul_comm +mul_distrib_sub +mul_even +mul_left_cancel +mul_one +mul_one_r +mul_succ +mul_zero +mul_zero_r +muladd +muladd11 +muladd11r +muladdd +muladdi +muladdmod +muladdmodid +mulass +mulassd +mulassi +mulassnni +mulassnq +mulassoc +mulasspi +mulasspr +mulasssr +mulbinom2 +mulc1cncf +mulc1cncfg +mulcan +mulcan1g +mulcan2 +mulcan2ad +mulcan2d +mulcan2g +mulcanad +mulcand +mulcanenq +mulcani +mulcanpi +mulcl +mulcld +mulcli +mulclnq +mulclpi +mulclpr +mulclprlem +mulclsr +mulcmpblnr +mulcmpblnrlem +mulcn +mulcn2 +mulcncf +mulcncff +mulcncfold +mulcnsr +mulcnsrec +mulcom +mulcomd +mulcomi +mulcomli +mulcomm +mulcomnni +mulcomnq +mulcompi +mulcompq +mulcompr +mulcomsr +mulcut +mulcut2 +mulcutlem +mulcxp +mulcxpd +mulcxplem +muldivbinom2 +muldivdid +muldivdir +muldmmbl +muldmmbl2 +muldvds1 +muldvds1d +muldvds2 +muldvds2d +mule1 +muleqadd +mulerpq +mulerpqlem +mulex +mulexp +mulexpd +mulexpz +mulg0 +mulg1 +mulg2 +mulgaddcom +mulgaddcomlem +mulgass +mulgass2 +mulgass3 +mulgassr +mulgcd +mulgcddvds +mulgcdr +mulgcl +mulgcld +mulgdi +mulgdir +mulgdirlem +mulge0 +mulge0b +mulge0d +mulge0i +mulgfn +mulgfval +mulgfvalalt +mulgfvi +mulgghm +mulgghm2 +mulginvcom +mulginvinv +mulgm1 +mulgmhm +mulgmodid +mulgneg +mulgneg2 +mulgnegneg +mulgnegnn +mulgnn +mulgnn0ass +mulgnn0cl +mulgnn0cld +mulgnn0di +mulgnn0dir +mulgnn0gsum +mulgnn0p1 +mulgnn0subcl +mulgnn0z +mulgnnass +mulgnncl +mulgnndir +mulgnngsum +mulgnnp1 +mulgnnsubcl +mulgp1 +mulgpropd +mulgrhm +mulgrhm2 +mulgsubcl +mulgsubdi +mulgsubdir +mulgt0 +mulgt0b1d +mulgt0b2d +mulgt0con1d +mulgt0con1dlem +mulgt0con2d +mulgt0d +mulgt0i +mulgt0ii +mulgt0sr +mulgt1 +mulgt1d +mulgt1old +mulgval +mulgz +mulidnq +mulidpi +mulle0b +mullid +mullidd +mullidi +mullimc +mullimcf +mullt0 +mullt0b1d +mullt0b2d +mulltgt0 +mulltgt0d +mulm1 +mulm1d +mulm1i +mulmarep1el +mulmarep1gsum1 +mulmarep1gsum2 +mulmod0 +mulmoddvds +mulne0 +mulne0b +mulne0bad +mulne0bbd +mulne0bd +mulne0d +mulne0i +mulneg1 +mulneg12 +mulneg1d +mulneg1i +mulneg2 +mulneg2d +mulneg2i +mulnegs1d +mulnegs2d +mulnqf +mulnzcnf +mulog2sum +mulog2sumlem1 +mulog2sumlem2 +mulog2sumlem3 +mulogsum +mulogsumlem +mulp1mod1 +mulpiord +mulpipq +mulpipq2 +mulpqf +mulpqnq +mulrcn +mulre +mulresr +mulrid +mulridd +mulridi +mulridx +mulrndx +muls01 +muls02 +muls0ord +muls12d +muls1d +muls4d +mulsass +mulsassd +mulsasslem1 +mulsasslem2 +mulsasslem3 +mulscan1d +mulscan2d +mulscan2dlem +mulscl +mulscld +mulscom +mulscomd +mulsfn +mulsge0d +mulsgt0 +mulsgt0d +mulslid +mulslidd +mulsne0bd +mulsprop +mulsproplem1 +mulsproplem10 +mulsproplem11 +mulsproplem12 +mulsproplem13 +mulsproplem14 +mulsproplem2 +mulsproplem3 +mulsproplem4 +mulsproplem5 +mulsproplem6 +mulsproplem7 +mulsproplem8 +mulsproplem9 +mulsproplemcbv +mulsrid +mulsridd +mulsrmo +mulsrpr +mulsub +mulsub2 +mulsubaddmulsub +mulsubd +mulsubdivbinom2 +mulsubfacd +mulsuble0b +mulsucdiv2z +mulsunif +mulsunif2 +mulsunif2lem +mulsuniflem +mulsval +mulsval2 +mulsval2lem +mult +mult_0 +mult_0_r +mult_ac +mult_assoc +mult_assoc_comm +mult_clauses +mult_comm +mult_comm_assoc +mult_div_2 +mult_eq_0 +mult_eq_1 +mult_eq_div +mult_exp +mult_exp_mono +mult_increases +mult_ints +mult_le_compat_r +mult_left_1 +mult_left_cancel +mult_left_id +mult_less_eq_suc +mult_mono_eq +mult_plus_distr_l +mult_rat +mult_ratl +mult_ratr +mult_right_1 +mult_right_cancel +mult_right_id +mult_suc +mult_suc_eq +mult_sym +mult_to_div +multassociative +multcancelleft +multcancelright +multcommutative +multdistributesoverplusleft +multipart_measures +multisetadd +multistep +multmonotone +multonerightneutral +multrightsuccplus +multzerorightzero +mulvfn +mulvfv +mulvval +mulzero +mumford_lemma +mumul +mumullem1 +mumullem2 +musum +musumsum +mutex_exclusive +mutexspec +mutual_even +mutual_ind +mutual_ind_evenodd +mutual_info_nonneg +mutualrectermination +muval +muval1 +muval2 +mvdco +mvhf +mvhf1 +mvhfval +mvhval +mvlladdd +mvlladdi +mvllmuld +mvllmuli +mvlraddd +mvlraddi +mvlrmuld +mvlrmuli +mvmulfv +mvmulfval +mvmulval +mvmumamul1 +mvp +mvrcl +mvrcl2 +mvrf +mvrf1 +mvrf2 +mvrfval +mvrid +mvrladdd +mvrladdi +mvrraddd +mvrraddi +mvrrsubd +mvrsfpw +mvrsval +mvrval +mvrval2 +mvrvalind +mvt +mvt_general +mvt_segment +mvt_segment_simple +mvt_simple +mvt_very_simple +mvth +mvtinf +mvtss +mvtval +mxidlidl +mxidlirred +mxidlirredi +mxidlmax +mxidlmaxv +mxidln1 +mxidlnr +mxidlnzr +mxidlnzrb +mxidlprm +mxidlprmalt +mxidlval +mzpadd +mzpaddmpt +mzpcl1 +mzpcl2 +mzpcl34 +mzpclall +mzpcln0 +mzpclval +mzpcompact2 +mzpcompact2lem +mzpcong +mzpconst +mzpconstmpt +mzpexpmpt +mzpf +mzpincl +mzpindd +mzpmfp +mzpmul +mzpmulmpt +mzpnegmpt +mzpproj +mzprename +mzpresrename +mzpsubmpt +mzpsubst +mzpval +n +n0 +n0abso +n0addscl +n0bday +n0cut +n0cut2 +n0cutlt +n0el +n0el2 +n0el3 +n0eldmqs +n0eldmqseq +n0elim +n0elqs +n0elqs2 +n0expscl +n0f +n0fincut +n0i +n0ii +n0lesltp1 +n0lesm1lt +n0limd +n0lplig +n0lpligalt +n0lts1e0 +n0ltsp1le +n0moeu +n0mulscl +n0no +n0nod +n0nsn2el +n0nsnel +n0on +n0p +n0p1nns +n0rex +n0s0m1 +n0s0suc +n0seo +n0sex +n0sexg +n0sge0 +n0sind +n0snor2el +n0ssno +n0ssold +n0ssoldg +n0subs +n0subs2 +n0zs +n0zsd +n1_spec +n2dvds1 +n2dvds3 +n2dvdsm1 +n3_spec +n4cyclfrgr +n_from_delta +n_queens +n_spec +nabbib +nabctnabc +nabi12i +nabi1i +nabi2i +nacsacs +nacsfg +nacsfix +nadd1rabex +nadd1rabon +nadd1rabord +nadd1rabtr +nadd1suc +nadd2rabex +nadd2rabon +nadd2rabord +nadd2rabtr +nadd32 +nadd4 +nadd42 +naddass +naddass1 +naddasslem1 +naddasslem2 +naddcl +naddcllem +naddcnfass +naddcnfcl +naddcnfcom +naddcnff +naddcnffn +naddcnffo +naddcnfid1 +naddcnfid2 +naddcom +naddel1 +naddel12 +naddel2 +naddelim +naddf +naddfn +naddgeoa +naddlid +naddoa +naddonnn +naddov +naddov2 +naddov3 +naddov4 +naddrid +naddss1 +naddss2 +naddssim +naddsuc2 +naddunif +naddword1 +naddword2 +naddwordnexlem0 +naddwordnexlem1 +naddwordnexlem2 +naddwordnexlem3 +naddwordnexlem4 +naecoms +naecoms-o +naev +naev2 +naim1 +naim12i +naim1i +naim2 +naim2i +nalfal +nalset +nan +nanan +nanass +nanbi +nanbi1 +nanbi12 +nanbi12d +nanbi12i +nanbi1d +nanbi1i +nanbi2 +nanbi2d +nanbi2i +nancom +nandsym1 +nanim +nannan +nannot +nanor +nanorxor +naryfval +naryfvalel +naryfvalelfv +naryfvalelwrdf +naryfvalixp +naryrcl +nash_existence +nat +nat1 +nat1st2nd +nat_add_assoc +nat_add_comm +nat_add_distrib_max +nat_add_distrib_max_left +nat_add_distrib_max_right +nat_add_distrib_min_left +nat_add_distrib_min_right +nat_add_zero +nat_decidable_eq +nat_distrib +nat_div_mod +nat_induction +nat_induction_schema +nat_le_antisym +nat_le_refl +nat_le_trans +nat_lt_succ +nat_max_assoc +nat_max_comm +nat_max_idem +nat_mul_assoc +nat_mul_comm +nat_mul_one +nat_mul_zero +nat_positive +nat_quot_modp +nat_rec +nat_well_ordering +natcl +natded +natffn +natfn +natfval +natglobalincr +nati +natind +natind `m` +natind `n` +natixp +natlocalincr +natoppf +natoppf2 +natoppfb +natp-* +natp-+ +natp-fc-1 +natp-fc-2 +natp-posp +natp-posp--1 +natp-rw +natpropd +natrcl +natrcl2 +natrcl3 +natural +natural_trans +naturality +nb3gr2nb +nb3grpr +nb3grpr2 +nb3grprlem1 +nb3grprlem2 +nbbn +nbcplgr +nbedgusgr +nbfal +nbfiusgrfi +nbfusgrlevtxm1 +nbfusgrlevtxm2 +nbgr0edg +nbgr0edglem +nbgr0vtx +nbgr1vtx +nbgr2vtx1edg +nbgrcl +nbgrel +nbgrisvtx +nbgrnself +nbgrnself2 +nbgrnvtx0 +nbgrprc0 +nbgrssovtx +nbgrssvtx +nbgrssvwo2 +nbgrsym +nbgrval +nbi2 +nbior +nbn +nbn2 +nbn3 +nbrne1 +nbrne2 +nbuhgr +nbuhgr2vtx1edgb +nbuhgr2vtx1edgblem +nbumgr +nbumgrvtx +nbupgr +nbupgrel +nbupgrres +nbupgruvtxres +nbusgr +nbusgredgeu +nbusgredgeu0 +nbusgreledg +nbusgrf1o +nbusgrf1o0 +nbusgrf1o1 +nbusgrfi +nbusgrvtx +nbusgrvtxm1 +nbusgrvtxm1uvtx +ncanth +ncolcom +ncolncol +ncolne1 +ncolne2 +ncolrot1 +ncolrot2 +ncoltgdim2 +nconnsubb +ncoprmgcdgt1b +ncoprmgcdne1b +ncoprmlnprm +ncvr1 +ncvs1 +ncvsdif +ncvsge0 +ncvsi +ncvsm1 +ncvspds +ncvspi +ncvsprp +nd1 +nd2 +nd3 +nd4 +ndfatafv2 +ndfatafv2nrn +ndfatafv2undef +ndisj +ndisj2 +ndmafv +ndmafv2nrn +ndmaov +ndmaovass +ndmaovcl +ndmaovcom +ndmaovdistr +ndmaovg +ndmaovrcl +ndmfv +ndmfvrcl +ndmico +ndmima +ndmioo +ndmov +ndmovass +ndmovcl +ndmovcom +ndmovdistr +ndmovg +ndmovord +ndmovordi +ndmovrcl +ndvdsadd +ndvdsi +ndvdsp1 +ndvdssub +ndxarg +ndxid +ne0d +ne0gt0 +ne0gt0d +ne0i +ne0ii +ne0p +ne3anior +neanior +nearby_invertible_matrix +nearby_invertible_matrix_gen +nearby_positive_definite_matrix +nearby_positive_definite_matrix_gen +nebi +necessitate +necessitation +necom +necomd +necomi +necon1abid +necon1abii +necon1ad +necon1ai +necon1bbid +necon1bbii +necon1bd +necon1bi +necon1d +necon1i +necon2abid +necon2abii +necon2ad +necon2ai +necon2bbid +necon2bbii +necon2bd +necon2bi +necon2d +necon2i +necon3abid +necon3abii +necon3ad +necon3ai +necon3bbid +necon3bbii +necon3bd +necon3bi +necon3bid +necon3bii +necon3d +necon3i +necon4abid +necon4ad +necon4ai +necon4bbid +necon4bd +necon4bid +necon4d +necon4i +need +neeq1 +neeq12d +neeq12i +neeq1d +neeq1i +neeq2 +neeq2d +neeq2i +neeqtrd +neeqtri +neeqtrrd +neeqtrri +neg0 +neg0s +neg11 +neg11ad +neg11d +neg11i +neg1cn +neg1lt0 +neg1mulneg1e1 +neg1ne0 +neg1rr +neg1s +neg1sqe1 +neg1z +neg2sub +neg2subd +neg_neg +neg_pos_sq_le +neg_pos_sq_lt +neg_rat +neg_translation +negation_translation +negations_ball +negations_cball +negations_sphere +negbday +negbdaylem +negcl +negcld +negcli +negcncf +negcncfg +negcncfold +negcon1 +negcon1ad +negcon1d +negcon1i +negcon2 +negcon2i +negcut +negcut2 +negdi +negdi2 +negdi2d +negdid +negdii +negdvdsb +negel +negelrp +negelrpd +negeq +negeq0 +negeq0d +negeqd +negeqi +negeu +negex +negexpidd +negexsr +negf1o +negfcncf +negfi +neggcd +neggcdnni +neghalfpire +neghalfpirx +negicn +negid +negidd +negidi +neginf_le +negiso +neglcm +negleft +negligible +negligible_absolutely_continuous_image +negligible_absolutely_continuous_image_lowdim +negligible_affine_hull +negligible_affine_hull_1 +negligible_affine_hull_2 +negligible_affine_hull_3 +negligible_affinity +negligible_affinity_eq +negligible_bounded_subsets +negligible_convex_frontier +negligible_convex_hull +negligible_convex_hull_1 +negligible_convex_hull_2 +negligible_convex_hull_3 +negligible_convex_interior +negligible_countable +negligible_countable_unions +negligible_countable_unions_gen +negligible_delete +negligible_diff +negligible_differentiable_image_lowdim +negligible_differentiable_image_negligible +negligible_differentiable_preimage +negligible_disjoint_translates +negligible_empty +negligible_empty_interior +negligible_eq_measure_0 +negligible_eq_zero_density +negligible_eq_zero_density_alt +negligible_finite +negligible_frontier_interval +negligible_hyperplane +negligible_iff_lebesgue_measurable_subsets +negligible_iff_measurable_subsets +negligible_image_bounded_variation_interval +negligible_image_indefinite_integral +negligible_imp_lebesgue_measurable +negligible_imp_measurable +negligible_infinite_preimages_differentiable +negligible_insert +negligible_inter +negligible_interval +negligible_linear_image +negligible_linear_image_eq +negligible_linear_image_gen +negligible_linear_singular_image +negligible_lipschitz_image_univ +negligible_locally_lipschitz_image +negligible_locally_lipschitz_image_lowdim +negligible_lowdim +negligible_measurable_function_graph +negligible_on_countable_intervals +negligible_on_intervals +negligible_on_univ +negligible_outer +negligible_outer_le +negligible_pcross +negligible_points_of_ambiguous_derivative +negligible_rectifiable_path_image +negligible_scaling +negligible_scaling_eq +negligible_segment +negligible_sing +negligible_sphere +negligible_standard_hyperplane +negligible_subset +negligible_symdiff_eq +negligible_translation +negligible_translation_eq +negligible_translation_rev +negligible_union +negligible_union_eq +negligible_unions +neglimc +neglt +negmod +negmod0 +negn0 +negn0nposznnd +negne0bd +negne0bi +negne0d +negne0i +negned +negneg +negneg1e1 +negneg_function +negnegd +negnegi +negnegs +negpicn +negpilt0 +negpitopissre +negreb +negrebd +negrebi +negright +negs11 +negscl +negscld +negsdi +negsex +negsf +negsf1o +negsfn +negsfo +negsid +negsidd +negslem1 +negsprop +negsproplem1 +negsproplem2 +negsproplem3 +negsproplem4 +negsproplem5 +negsproplem6 +negsproplem7 +negsub +negsubd +negsubdi +negsubdi2 +negsubdi2d +negsubdi2i +negsubdi3d +negsubdid +negsubdii +negsubi +negsubsdi2d +negsunif +negsval +negsval2 +negsval2d +negsym1 +nehash2 +neibastop1 +neibastop2 +neibastop2lem +neibastop3 +neibl +neicvgbex +neicvgel1 +neicvgel2 +neicvgf1o +neicvgfv +neicvgmex +neicvgnex +neicvgnvo +neicvgnvor +neicvgrcomplex +neif +neifg +neificl +neifil +neiflim +neifval +neighbourhood_base_of +neighbourhood_base_of_euclidean +neii +neii1 +neii2 +neiin +neiint +neik0imk0p +neik0pk1imk0 +neindisj +neindisj2 +neipcfilu +neipeltop +neips +neiptopnei +neiptopreu +neiptoptop +neiptopuni +neir +neircl +neirr +neiss +neiss2 +neissex +neisspw +neitr +neitx +neiuni +neival +nel0 +nel02 +nel1nelin +nel1nelini +nel2nelin +nel2nelini +nelaneq +nelaneqold +nelb +nelbr +nelbrim +nelbrnel +nelbrnelim +nelcon3d +neldif +neldifpr1 +neldifpr2 +neldifsn +neldifsnd +nelelne +neleq1 +neleq12d +neleq2 +neleqtrd +neleqtrrd +nelfzo +neli +nelir +nelne1 +nelne2 +nelneq +nelneq2 +nelpr +nelpr1 +nelpr2 +nelprd +nelpri +nelrdva +nelrnfvne +nelrnmpt +nelrnres +nelsn +nelss +nelsubc +nelsubc2 +nelsubc3 +nelsubc3lem +nelsubclem +nelsubgcld +nelsubginvcld +nelsubgsubcld +nelun +nemnftgtmnft +nemtbir +neneor +neneq +neneqd +neor +neorian +nepnfltpnf +nepss +neq0 +neq0f +neqcomd +neqne +neqned +nerabdioph +nested_induction +nesym +nesymi +nesymir +net_within_univ +netlimit_at +netlimit_atpointof +netlimit_within +netlimits_at_infinity +netlimits_at_neginfinity +netlimits_at_posinfinity +netlimits_within +network_slicing +neufal +neutral_and +neutral_lifted +neutral_real_add +neutral_vector_add +neutru +nev +new0 +newbday +newbdayim +newf +newno +newnod +newssno +newton +newval +nex +nexd +nexdh +nexdv +nexfal +nexmo +nexmo1 +nexntru +nexple +nexr +nf1const +nf1oconst +nf2 +nf3 +nf3an +nf3and +nf3or +nf4 +nf5 +nf5-1 +nf5d +nf5dh +nf5di +nf5dv +nf5i +nf5r +nf5rd +nf5ri +nf6 +nfa-run +nfa1 +nfa1-o +nfa1w +nfa2 +nfa_run +nfab +nfab1 +nfaba1 +nfaba1g +nfaba1old +nfabd +nfabd2 +nfabdw +nfabg +nfae +nfafv +nfafv2 +nfal +nfald +nfald2 +nfale2 +nfalh +nfaltop +nfan +nfan1 +nfan1c +nfand +nfaov +nfbi +nfbid +nfbidf +nfbidv +nfbii +nfbiit +nfbr +nfbrd +nfccdeq +nfcd +nfcdeq +nfceqdf +nfceqi +nfchnd +nfci +nfcii +nfcjust +nfcnv +nfco +nfcoll +nfcprod +nfcprod1 +nfcr +nfcralt +nfcrd +nfcri +nfcrii +nfcsb +nfcsb1 +nfcsb1d +nfcsb1v +nfcsbd +nfcsbw +nfcv +nfcvb +nfcvd +nfcvf +nfcvf2 +nfcxfr +nfcxfrd +nfcxfrdf +nfd +nfded +nfded2 +nfdfat +nfdif +nfdifold +nfdisj +nfdisj1 +nfdisjw +nfdju +nfdm +nfe1 +nfe2 +nfel +nfel1 +nfel2 +nfeld +nfeq +nfeq1 +nfeq2 +nfeqd +nfeqf +nfeqf1 +nfeqf2 +nfequid +nfequid-o +nfermltl2rev +nfermltl8rev +nfermltlrev +nfesum1 +nfesum2 +nfeu +nfeu1 +nfeu1alt +nfeud +nfeud2 +nfeudw +nfeuw +nfex +nfexa2 +nfexd +nfexd2 +nfexhe +nff +nff1 +nff1o +nffal +nffn +nffo +nffr +nffrecs +nffun +nffv +nffvd +nffvmpt1 +nfi +nfia1 +nfich1 +nfich2 +nfielex +nfif +nfifd +nfii1 +nfiin +nfiing +nfile +nfim +nfim1 +nfima +nfimad +nfimd +nfimdetndef +nfimt +nfin +nfinf +nfinold +nfint +nfintd +nfiota +nfiota1 +nfiotad +nfiotadw +nfiotaw +nfiso +nfitg +nfitg1 +nfiu1 +nfiu1old +nfiun +nfiund +nfiundg +nfiung +nfixp +nfixp1 +nfixpw +nfmo +nfmo1 +nfmod +nfmod2 +nfmodv +nfmov +nfmpo +nfmpo1 +nfmpo2 +nfmpt +nfmpt1 +nfn +nfna1 +nfnae +nfnaew +nfnan +nfnbi +nfnd +nfne +nfned +nfneg +nfnegd +nfnel +nfneld +nfnf +nfnf1 +nfnfc +nfnfc1 +nfnid +nfnt +nfnth +nfntht +nfntht2 +nfof +nfofr +nfoi +nfop +nfopab +nfopab1 +nfopab2 +nfopabd +nfopd +nfopdalt +nfoprab +nfoprab1 +nfoprab2 +nfoprab3 +nfor +nfov +nfovd +nfpconfp +nfpo +nfpr +nfpred +nfpw +nfra1 +nfra2 +nfra2w +nfrab +nfrab1 +nfrabw +nfral +nfrald +nfraldw +nfralw +nfrd +nfrdg +nfre1 +nfrecs +nfrel +nfrelp +nfres +nfreu +nfreu1 +nfreud +nfreuw +nfrex +nfrexd +nfrexdw +nfrexw +nfrgr2v +nfri +nfriota +nfriota1 +nfriotad +nfriotadw +nfrmo +nfrmo1 +nfrmod +nfrmow +nfrn +nfs1 +nfs1f +nfs1v +nfsab +nfsab1 +nfsabg +nfsb +nfsb2 +nfsb4 +nfsb4t +nfsbc +nfsbc1 +nfsbc1d +nfsbc1v +nfsbcd +nfsbcdw +nfsbcw +nfsbd +nfsbv +nfscott +nfse +nfseq +nfseqs +nfsetrecs +nfsn +nfso +nfss +nfssd +nfsuc +nfsum +nfsum1 +nfsup +nfsymdif +nfth +nftht +nftpos +nftru +nfttrcl +nfttrcld +nfun +nfuni +nfunid +nfunidalt +nfunidalt2 +nfunold +nfunsn +nfunsnafv +nfunsnafv2 +nfunsnaov +nfunv +nfv +nfvd +nfvres +nfwe +nfwlim +nfwrd +nfwrecs +nfwsuc +nfxfr +nfxfrd +nfxneg +nfxnegd +nfxp +nghmcl +nghmcn +nghmco +nghmfval +nghmghm +nghmplusg +nghmrcl1 +nghmrcl2 +nglmle +ngnmcncn +ngpds +ngpds2 +ngpds2r +ngpds3 +ngpds3r +ngpdsr +ngpgrp +ngpi +ngpinvds +ngplcan +ngpmet +ngpms +ngpocelbl +ngppropd +ngprcan +ngpsubcan +ngptgp +ngptps +ngpxms +ngtmnft +niabn +nic-ax +nic-axalt +nic-bi1 +nic-bi2 +nic-bijust +nic-dfim +nic-dfneg +nic-ich +nic-id +nic-idbl +nic-idel +nic-idlem1 +nic-idlem2 +nic-iimp1 +nic-iimp2 +nic-imp +nic-isw1 +nic-isw2 +nic-luk1 +nic-luk2 +nic-luk3 +nic-mp +nic-mpalt +nic-stdmp +nic-swap +nicomachus +niex +nil +nil_append +nimnbi +nimnbi2 +ninba +nla0001 +nla0002 +nla0003 +nlelchi +nlelshi +nleltd +nlfnval +nlim0 +nlim1 +nlim1new +nlim2 +nlim2new +nlim3 +nlim4 +nlimon +nlimsuc +nlimsucg +nlly2i +nllyeq +nllyi +nllyidm +nllyrest +nllyss +nllytop +nlmdsdi +nlmdsdir +nlmlmod +nlmmul0or +nlmngp +nlmngp2 +nlmnrg +nlmtlm +nlmvscn +nlmvscnlem1 +nlmvscnlem2 +nlpfvineqsn +nlpineqsn +nlt1pi +nltle2tri +nltled +nltmnf +nltpnft +nm +nm0 +nm1 +nm2dif +nmbdfnlb +nmbdfnlbi +nmbdoplb +nmbdoplbi +nmblolbi +nmblolbii +nmblore +nmcexi +nmcfnex +nmcfnexi +nmcfnlb +nmcfnlbi +nmcl +nmcn +nmcnc +nmcopex +nmcopexi +nmcoplb +nmcoplbi +nmcvcn +nmcvfval +nmdvr +nmeq0 +nmf +nmf2 +nmfn0 +nmfnge0 +nmfnlb +nmfnleub +nmfnleub2 +nmfnrepnf +nmfnsetn0 +nmfnsetre +nmfnval +nmfnxr +nmfval +nmfval0 +nmfval2 +nmge0 +nmgt0 +nmhmcl +nmhmcn +nmhmco +nmhmghm +nmhmlmhm +nmhmnghm +nmhmplusg +nmhmrcl1 +nmhmrcl2 +nminv +nminvr +nmlno0 +nmlno0i +nmlno0lem +nmlnogt0 +nmlnop0 +nmlnop0ialt +nmlnop0ihil +nmlnopgt0i +nmlnopne0 +nmlnoubi +nmmtri +nmmul +nmmulg +nmne0 +nmo +nmo0 +nmobndi +nmobndseqi +nmobndseqialt +nmocl +nmoco +nmods +nmoeq0 +nmof +nmoffn +nmofval +nmoge0 +nmogelb +nmogtmnf +nmoi +nmoi2 +nmoid +nmoix +nmolb +nmolb2d +nmoleub +nmoleub2a +nmoleub2b +nmoleub2lem +nmoleub2lem2 +nmoleub2lem3 +nmoleub3 +nmoo0 +nmoofval +nmooge0 +nmoolb +nmooval +nmop0 +nmop0h +nmopadji +nmopadjlei +nmopadjlem +nmopcoadj0i +nmopcoadj2i +nmopcoadji +nmopcoi +nmopge0 +nmopgt0 +nmopgtmnf +nmophmi +nmoplb +nmopleid +nmopnegi +nmopre +nmopreltpnf +nmoprepnf +nmopsetn0 +nmopsetretalt +nmopsetrethil +nmoptri2i +nmoptrii +nmopub +nmopub2talt +nmopub2thil +nmopun +nmopval +nmopxr +nmoreltpnf +nmorepnf +nmosetn0 +nmosetre +nmotri +nmotru +nmoub2i +nmoub3i +nmoubi +nmounbi +nmounbseqi +nmounbseqialt +nmoval +nmoxr +nmpar +nmparlem +nmpropd +nmpropd2 +nmrpcl +nmrtri +nmsq +nmsub +nmtri +nmtri2 +nmval +nmval2 +nmvs +nmzbi +nmznsg +nmzsubg +nn01to3 +nn0abscl +nn0absid +nn0absidi +nn0addcl +nn0addcld +nn0addcli +nn0addcom +nn0addge1 +nn0addge1i +nn0addge2 +nn0addge2i +nn0archi +nn0cn +nn0cnd +nn0cni +nn0constr +nn0difffzod +nn0diffz0 +nn0digval +nn0disj +nn0disj01 +nn0e +nn0ehalf +nn0enn0ex +nn0enn0exaltv +nn0enne +nn0ennn +nn0eo +nn0ex +nn0expcl +nn0expcld +nn0expcli +nn0expgcd +nn0fz0 +nn0gcdid0 +nn0gcdsq +nn0ge0 +nn0ge0d +nn0ge0div +nn0ge0i +nn0ge2m1nn +nn0ge2m1nn0 +nn0ge2m1nnalt +nn0gsumfz +nn0gsumfz0 +nn0ind +nn0ind-raph +nn0indalt +nn0indd +nn0inf +nn0le0eq0 +nn0le2is012 +nn0le2msqi +nn0le2x +nn0le2xi +nn0ledivnn +nn0lele2xi +nn0leltp1 +nn0lem1lt +nn0lt10b +nn0lt2 +nn0ltlem1 +nn0ltp1le +nn0ltp1ne +nn0min +nn0mnd +nn0mnfxrd +nn0mulcl +nn0mulcld +nn0mulcli +nn0mulcom +nn0mulfsum +nn0mullong +nn0n0n1ge2 +nn0n0n1ge2b +nn0negleid +nn0negz +nn0negzi +nn0nepnf +nn0nepnfd +nn0nlt0 +nn0nnaddcl +nn0nndivcl +nn0o +nn0o1gt2 +nn0o1gt2altv +nn0oaltv +nn0ob +nn0oddm1d2 +nn0ofldiv2 +nn0omnd +nn0onn +nn0onn0ex +nn0onn0exaltv +nn0opth2 +nn0opth2i +nn0opthi +nn0opthlem1 +nn0opthlem2 +nn0p1elfzo +nn0p1gt0 +nn0p1nn +nn0prpw +nn0prpwlem +nn0pzuz +nn0re +nn0readdcl +nn0red +nn0rei +nn0resubcl +nn0risefaccl +nn0rp0 +nn0rppwr +nn0seqcvg +nn0seqcvgd +nn0sinds +nn0split +nn0split01 +nn0sq11 +nn0sqcl +nn0sqeq1 +nn0srg +nn0sscn +nn0ssge0 +nn0ssq +nn0ssre +nn0ssxnn0 +nn0ssz +nn0sub +nn0sub2 +nn0subm +nn0suc +nn0sumltlt +nn0sumshdig +nn0sumshdiglem1 +nn0sumshdiglem2 +nn0sumshdiglema +nn0sumshdiglemb +nn0uz +nn0xmulclb +nn0xnn0 +nn0xnn0d +nn0z +nn0zd +nn0zi +nn0zrab +nn1m1nn +nn1m1nns +nn1suc +nn2ge +nn2m +nna0 +nna0r +nna1iscard +nna4b4nsq +nnaass +nnabscl +nnacan +nnacl +nnacli +nnacom +nnadd1com +nnaddcl +nnaddcld +nnaddcom +nnaddcomli +nnadddir +nnaddm1cl +nnaddscl +nnadju +nnadjualt +nnamecl +nnaord +nnaordex +nnaordex2 +nnaordi +nnaordr +nnarcl +nnasmo +nnasuc +nnaword +nnaword1 +nnaword2 +nnawordex +nnawordexg +nnawordi +nncan +nncand +nncansd +nncn +nncnd +nncni +nnct +nndi +nndiffz1 +nndiv +nndivdvds +nndivdvdsd +nndivides +nndivlub +nndivre +nndivred +nndivsub +nndivtr +nndomo +nndomog +nndvdslegcd +nne +nnecl +nnehalf +nnel +nneneq +nnennex +nnennexaltv +nnenom +nneo +nneoaltv +nneob +nneoi +nneoialtv +nneom +nneop +nnesq +nnesuc +nneven +nnex +nnexalt +nnexpcl +nnexpcld +nnexpscl +nnf1oxpnn +nnfi +nnfoctb +nnfoctbdj +nnfoctbdjlem +nnge1 +nnge1d +nngt0 +nngt0d +nngt0i +nngt1ne1 +nnind +nnindalt +nnindd +nnindf +nninf +nninfnub +nnle1eq1 +nnledivrp +nnleltp1 +nnlem1lt +nnlesq +nnlim +nnlog2ge0lt1 +nnlogbexp +nnltlem1 +nnltp1le +nnltp1ne +nnm0 +nnm0r +nnm1 +nnm1ge0 +nnm1n0s +nnm1nn0 +nnm2 +nnmass +nnmcan +nnmcl +nnmcli +nnmcom +nnmord +nnmordi +nnmsuc +nnmsucr +nnmtmip +nnmul1com +nnmulcl +nnmulcld +nnmulcli +nnmulcom +nnmulge +nnmulscl +nnmword +nnmwordi +nnmwordri +nnn0 +nnn0s +nnn0sd +nnn1suc +nnncan +nnncan1 +nnncan1d +nnncan2 +nnncan2d +nnncand +nnne0 +nnne0alt +nnne0d +nnne0i +nnne0s +nnne1ge2 +nnnegz +nnneneg +nnneo +nnnfi +nnnle0 +nnnlt1 +nnnn0 +nnnn0addcl +nnnn0d +nnnn0i +nnnn0modprm0 +nnno +nnnod +nno +nnoaltv +nnoddm1d2 +nnoddn2prm +nnoddn2prmb +nnoeomeqom +nnolog2flm1 +nnon +nnoni +nnord +nnpcan +nnproddivdvdsd +nnpw2blen +nnpw2blenfzo +nnpw2blenfzo2 +nnpw2even +nnpw2evenaltv +nnpw2p +nnpw2pb +nnpw2pmod +nnq +nnre +nnrecgt0 +nnrecl +nnrecq +nnrecre +nnrecred +nnrecrp +nnred +nnrei +nnrisefaccl +nnrp +nnrpd +nnsdom +nnsdomel +nnsdomg +nnsdomo +nnsex +nnsge1 +nnsgrp +nnsgrpmgm +nnsgrpnmnd +nnsgt0 +nnsind +nnsinds +nnsplit +nnsqcl +nnsqcld +nnsrecgt0d +nnsscn +nnssi2 +nnssi3 +nnssn0s +nnssnn0 +nnssno +nnssq +nnssre +nnssz +nnsub +nnsubi +nnsuc +nnsum3primes4 +nnsum3primesgbe +nnsum3primesle9 +nnsum3primesprm +nnsum4primes4 +nnsum4primeseven +nnsum4primesevenaltv +nnsum4primesgbe +nnsum4primesle9 +nnsum4primesodd +nnsum4primesoddaltv +nnsum4primesprm +nnubfi +nnullss +nnunb +nnuni +nnunifi +nnuz +nnuzdisj +nnwo +nnwof +nnwos +nnxr +nnxrd +nnz +nnzd +nnzi +nnzrab +nnzs +nnzsd +nnzsubs +no2indlesm +no2inds +no2times +no3inds +no_duplicate +no_limit_point_imp_closed +no_tac +nobdaymin +nocvxmin +nocvxminlem +nodense +nodenselem4 +nodenselem5 +nodenselem6 +nodenselem7 +nodenselem8 +nodmon +nodmord +noel +noeta +noeta2 +noetainflem1 +noetainflem2 +noetainflem3 +noetainflem4 +noetalem1 +noetalem2 +noetasuplem1 +noetasuplem2 +noetasuplem3 +noetasuplem4 +noextend +noextenddif +noextendgt +noextendlt +noextendseq +nofnbday +nofun +nofv +nogesgn1o +nogesgn1ores +nogt01o +nohalf +noinds +noinfbday +noinfbnd1 +noinfbnd1lem1 +noinfbnd1lem2 +noinfbnd1lem3 +noinfbnd1lem4 +noinfbnd1lem5 +noinfbnd1lem6 +noinfbnd2 +noinfbnd2lem1 +noinfcbv +noinfdm +noinfep +noinfepfnregs +noinfepregs +noinffv +noinfno +noinfprefixmo +noinfres +nolesgn2o +nolesgn2ores +nolt02o +nolt02olem +nomaxmo +nominmo +nominpos +non_empty_head +non_measurable_set +non_trivial_limit_left +non_trivial_limit_right +nonbooli +nonce_fresh +nonce_unique +nonconne +nondecreasing_extends_from_dense +nondecreasing_extends_to_convex_hull +none +nonempty_affine_exists +nonempty_span +nonemptyseq +nonneg +nonnegative_absolutely_integrable +nonnegative_absolutely_integrable_ae +nonnullarray +nonogram +nonrel +nonsq +nonzerop_nonzero_pow +noprc +noran +norass +norasslem1 +norasslem2 +norasslem3 +norbi +norcom +nordeq +norec2fn +norec2ov +norecdiv +noreceuw +norecfn +norecov +noresle +noreson +norm-i +norm-i-i +norm-ii +norm-ii-i +norm-iii +norm-iii-i +norm0 +norm1 +norm1exi +norm1hex +norm3adifi +norm3adifii +norm3dif +norm3dif2 +norm3difi +norm3lem +norm3lemt +norm_0 +norm_1 +norm_1_pos +norm_add_pythagorean +norm_add_rule +norm_arith +norm_arith_tac +norm_basis +norm_basis_1 +norm_bound_component_le +norm_bound_component_lt +norm_bound_generalize +norm_canon_conv +norm_cauchy_schwarz +norm_cauchy_schwarz_abs +norm_cauchy_schwarz_abs_eq +norm_cauchy_schwarz_div +norm_cauchy_schwarz_eq +norm_cauchy_schwarz_equal +norm_cmul_rule +norm_column_le_onorm +norm_cross_multiply +norm_elim_thm +norm_eq +norm_eq_0 +norm_eq_0_dot +norm_eq_0_imp +norm_eq_1 +norm_eq_componentwise +norm_eq_square +norm_fstcart +norm_ge_square +norm_gt_square +norm_increases_online +norm_le +norm_le_0 +norm_le_componentwise +norm_le_infnorm +norm_le_l1 +norm_le_max_eigenvector_span +norm_le_pastecart +norm_le_square +norm_lift +norm_lt +norm_lt_square +norm_lt_square_alt +norm_mp +norm_mul +norm_neg +norm_pastecart +norm_pastecart_0 +norm_pastecart_le +norm_pos_le +norm_pos_lt +norm_pow_2 +norm_real +norm_reflect_along +norm_sndcart +norm_spec +norm_sub +norm_tac +norm_triangle +norm_triangle_eq +norm_triangle_le +norm_triangle_lt +norm_triangle_sub +norm_vector_derivatives_le_at +norm_vector_derivatives_le_within +norm_vectorize_hadamard_le +norm_vectorize_mul_le +norm_vectorize_orthogonal_matrix_lmul +norm_vectorize_orthogonal_matrix_rmul +norm_vectorize_pow_2 +norm_vectorize_transp +norm_vsum_pythagorean +norm_vsum_trivial_lemma +normal_bipolar_decomposition +normal_left_polar_decomposition +normal_matrix_iff_same_norm_transp +normal_matrix_inv +normal_matrix_kernel_transp +normal_matrix_kernel_transp_explicit +normal_matrix_same_eigenpairs_transp +normal_matrix_same_eigenvectors_transp +normal_matrix_similar_transp +normal_matrix_similar_transp_alt +normal_right_polar_decomposition +normal_space_disjoint_closures +normalform +normalization +normalization_bcnf +normalize +normalize_fseq_def +normcan +normcl +normcli +normf +normge0 +normgt0 +normlem0 +normlem1 +normlem2 +normlem3 +normlem4 +normlem5 +normlem6 +normlem7 +normlem7talt +normlem8 +normlem9 +normlem9at +normne0 +normneg +normpar +normpar2i +normpari +normpyc +normpyth +normpythi +normsq +normsqi +normsub +normsub0 +normsub0i +normsubi +normval +norn +nornot +noror +nosep1o +nosep2o +nosepdm +nosepdmlem +nosepeq +nosepne +nosepnelem +nosepon +noseponlem +nosepssdm +noseq0 +noseqex +noseqind +noseqinds +noseqno +noseqp1 +noseqrdg0 +noseqrdgfn +noseqrdglem +noseqrdgsuc +noseqssno +nosgnn0 +nosgnn0i +nosupbday +nosupbnd1 +nosupbnd1lem1 +nosupbnd1lem2 +nosupbnd1lem3 +nosupbnd1lem4 +nosupbnd1lem5 +nosupbnd1lem6 +nosupbnd2 +nosupbnd2lem1 +nosupcbv +nosupdm +nosupfv +nosupinfsep +nosupno +nosupprefixmo +nosupres +not +not-integerp-/x +not-integerp-expt +not12an2impnot1 +not_bounded_univ +not_compact_univ +not_connected_component_separated_union +not_cons_nil +not_empty_insert +not_empty_sing +not_eq_list +not_equal_sets +not_even +not_even_and_odd +not_every +not_every_exists_first +not_exists +not_exists_thm +not_exp_0 +not_forall +not_forall_thm +not_gdelta_dense_countable +not_greater +not_greater_eq +not_imp +not_in_affine_hull_surface_triangulation +not_in_empty +not_in_finite +not_in_interior_convex_hull +not_insert_empty +not_interval_univ +not_intro +not_isfib_2_2 +not_le +not_leq +not_less +not_less_equal +not_lt +not_measurable_univ +not_miller_rabin_composite +not_miller_rabin_pseudoprime +not_negligible_univ +not_nil_eq_length_not_0 +not_not_false +not_null_mem +not_num_eq +not_odd +not_odd_eq_even +not_open_sing +not_sing_empty +not_strictly_decreasing +not_suc +not_suc_add_less_eq +not_suc_less_eq +not_suc_less_eq_0 +not_true +not_wf_string_lt +not_zero_lt_zero +notab +notabw +notatnand +notbi +notbicom +notbid +notbii +notbinot1 +notbinot2 +note +notfal +nothingabsurd +notinvolutive +notltetogt +notnot +notnotb +notnotbool +notnotd +notnoti +notnotr +notnotralt +notnotralt2 +notnotraltvd +notnotrd +notnotri +notnotrialt +notnottrue +notornotel1 +notornotel2 +notrab +nottru +notzfaus +now +nowhere_dense +nowhere_dense_countable_unions +nowhere_dense_countable_unions_closed +nowhere_dense_countable_unions_closed_in +nowhere_dense_union +noxp1o +noxpordfr +noxpordpo +noxpordpred +noxpordse +npcan +npcan1 +npcand +npcans +npex +npncan +npncan2 +npncan3 +npncan3d +npncand +npomex +nppcan +nppcan2 +nppcan2d +nppcan3 +nppcan3d +nppcand +nprm +nprmdvds1 +nprmi +nproduct_clauses +nprrel +nprrel12 +npss +npss0 +nqercl +nqereq +nqereu +nqerf +nqerid +nqerrel +nqex +nqpr +nrc_add_e +nrc_add_eqn +nrc_add_i +nrc_lrc +nrc_rtc +nrc_suc_recurse_left +nregmodel +nregmodelaxext +nregmodelf1o +nregmodellem +nrelv +nrex +nrex1 +nrexdv +nrexralim +nrexrmo +nrgabv +nrgdomn +nrgdsdi +nrgdsdir +nrginvrcn +nrginvrcnlem +nrgngp +nrgring +nrgtdrg +nrgtgp +nrgtrg +nrhmzr +nrmhaus +nrmhmph +nrmmetd +nrmo +nrmr0reg +nrmreg +nrmsep +nrmsep2 +nrmsep3 +nrmtngdist +nrmtngnrm +nrmtop +nrt2irr +nsb +nsgacs +nsgbi +nsgconj +nsgid +nsgmgc +nsgmgclem +nsgqus0 +nsgqusf1o +nsgqusf1olem1 +nsgqusf1olem2 +nsgqusf1olem3 +nsgsubg +nsmallnq +nsmndex1 +nsnlplig +nsnlpligalt +nss +nssd +nssdmovg +nssinpss +nssne1 +nssne2 +nsspssun +nssrex +nsssmfmbf +nsssmfmbflem +nssss +nsstr +nsuceq0 +nsyl +nsyl2 +nsyl3 +nsyl4 +nsyl5 +nsyld +nsyli +nth-badguy-bounded +nth-of-append +nth-of-butlast +nth-of-last +nth-of-list-fix +nth-of-make-list-ac +nth-of-nfix +nth-of-nil +nth-of-nthcdr +nth-of-repeat +nth-of-rev +nth-of-revappend +nth-of-reverse +nth-of-take +nth-when-atom +nth-when-too-large-cheap +nth-when-zp +nth_app_l +nth_app_r +nth_map +nthcdr-of-append +nthruc +nthrucw +nthruz +ntr0 +ntrcls0 +ntrclsbex +ntrclscls00 +ntrclselnel1 +ntrclselnel2 +ntrclsf1o +ntrclsfv +ntrclsfv1 +ntrclsfv2 +ntrclsfveq +ntrclsfveq1 +ntrclsfveq2 +ntrclsiex +ntrclsiso +ntrclsk13 +ntrclsk2 +ntrclsk3 +ntrclsk4 +ntrclskb +ntrclskex +ntrclsneine0 +ntrclsneine0lem +ntrclsnvobr +ntrclsrcomplex +ntrclsss +ntrdif +ntrelmap +ntreq0 +ntrf +ntrf2 +ntrfval +ntridm +ntrin +ntrivcvg +ntrivcvgfvn0 +ntrivcvgmul +ntrivcvgmullem +ntrivcvgn0 +ntrivcvgtail +ntrk0kbimka +ntrk1k3eqk13 +ntrk2imkb +ntrkbimka +ntrl2v2e +ntrneibex +ntrneicls00 +ntrneicls11 +ntrneicnv +ntrneiel +ntrneiel2 +ntrneif1o +ntrneifv1 +ntrneifv2 +ntrneifv3 +ntrneifv4 +ntrneiiex +ntrneiiso +ntrneik13 +ntrneik2 +ntrneik3 +ntrneik4 +ntrneik4w +ntrneikb +ntrneineine0 +ntrneineine0lem +ntrneineine1 +ntrneineine1lem +ntrneinex +ntrneircomplex +ntrneix13 +ntrneix2 +ntrneix3 +ntrneixb +ntropn +ntrrn +ntrss +ntrss2 +ntrss3 +ntrtop +ntruni +ntrval +ntrval2 +nub_append +nub_map_inj +nulchn +nuleldmp +null +null_eq +null_filter +null_length +nullspace_inter_rowspace +nulmbl +nulmbl2 +nulmo +nulsgts +nulsgtsd +nulslts +nulsltsd +num0h +num0u +num_2d_bij +num_2d_bij_big_square +num_2d_bij_inv +num_2d_bij_nz +num_2d_bij_nz_alt +num_2d_bij_nz_alt2 +num_2d_bij_nz_alt2_inv +num_2d_bij_nz_alt_inv +num_2d_bij_nz_inv +num_2d_bij_small_square +num_case_compute +num_case_eq +num_cases +num_ceiling_base +num_ceiling_le +num_ceiling_mono +num_ceiling_num_floor +num_ceiling_upper_bound +num_colors = max(color) +num_countable +num_finite +num_finite_avoid +num_floor_base +num_floor_div +num_floor_div_lowerbound +num_floor_eqns +num_floor_le +num_floor_le2 +num_floor_let +num_floor_lower_bound +num_floor_lt +num_floor_mono +num_floor_mul_lowerbound +num_floor_pos +num_floor_upper_bound +num_infinite +num_max +num_reduce_conv +num_set_wop +num_vlans = max(vlan) +num_wavelengths = max(wavelength) +numacn +numadd +numaddc +number +number_rule +numcl +numclwlk1 +numclwlk1lem1 +numclwlk1lem2 +numclwlk2lem2f +numclwlk2lem2f1o +numclwlk2lem2fv +numclwwlk1 +numclwwlk1lem2 +numclwwlk1lem2f +numclwwlk1lem2f1 +numclwwlk1lem2f1o +numclwwlk1lem2fo +numclwwlk1lem2foa +numclwwlk1lem2foalem +numclwwlk1lem2fv +numclwwlk2 +numclwwlk2lem1 +numclwwlk2lem1lem +numclwwlk2lem3 +numclwwlk3 +numclwwlk3lem1 +numclwwlk3lem2 +numclwwlk3lem2lem +numclwwlk4 +numclwwlk5 +numclwwlk5lem +numclwwlk6 +numclwwlk7 +numclwwlk7lem +numclwwlk8 +numclwwlkovh +numclwwlkovh0 +numclwwlkovq +numclwwlkqhash +numdenexp +numdenneg +numdensq +numdom +numedglnl +numeral_mult_eq_div +numexp +numexp0 +numexp1 +numexp2x +numexpp1 +numinfctb +numiunnum +numlt +numltc +numlti +numma +numma2c +nummac +nummin +nummul1c +nummul2c +numnncl +numnncl2 +numseg_clauses +numseg_conv +numseg_dimindex_nonempty +numseg_empty +numseg_offset_image +numseg_rec +numseg_sing +numsq +numsuc +numsucc +numth +numth2 +numth3 +numthcor +numufl +numwdom +nurse_rostering +nurse_scheduling +nv0 +nv0lid +nv0rid +nv1 +nv2 +nvablo +nvabs +nvadd32 +nvadd4 +nvaddsub +nvaddsub4 +nvass +nvcl +nvcli +nvclmod +nvclvec +nvcnlm +nvcom +nvctvc +nvdi +nvdif +nvdir +nvel +nvelim +nvex +nvf +nvgcl +nvge0 +nvgf +nvgrp +nvgt0 +nvi +nvinv +nvinvfval +nvlinv +nvm +nvm1 +nvmcl +nvmdi +nvmeq0 +nvmf +nvmfval +nvmid +nvmtri +nvmul0or +nvmval +nvmval2 +nvnd +nvnegneg +nvnnncan1 +nvnpcan +nvo00 +nvocnv +nvocnvb +nvof1o +nvop +nvop2 +nvpi +nvpncan +nvpncan2 +nvrcan +nvrel +nvrinv +nvs +nvsass +nvscl +nvscom +nvsf +nvsge0 +nvsid +nvss +nvsz +nvtri +nvvc +nvvcop +nvvop +nvz +nvz0 +nvzcl +nzadd +nzerooringczr +nzin +nznngen +nzprmdif +nzrneg1ne0 +nzrnz +nzrpropd +nzrring +nzrringold +nzrunit +nzss +o +o1add +o1add2 +o1bdd +o1bdd2 +o1bddrp +o1co +o1compt +o1const +o1cxp +o1dif +o1dm +o1eq +o1f +o1fsum +o1le +o1lo1 +o1lo12 +o1lo1d +o1mptrcl +o1mul +o1mul2 +o1of2 +o1p1e2 +o1res +o1res2 +o1resb +o1rlimmul +o1sub +o1sub2 +o2p2e4 +o2timesd +oa0 +oa00 +oa0r +oa0suclim +oa1cl +oa1suc +oa1un +oaabs +oaabs2 +oaabsb +oaabslem +oaass +oacan +oacgr +oacl +oacl2g +oacomf1o +oacomf1olem +oadif1 +oadif1lem +oaf1o +oalim +oalim2cl +oalimcl +oaltom +oaltublim +oancom +oaomoecl +oaomoencom +oaord +oaord1 +oaord3 +oaordex +oaordi +oaordi3 +oaordnr +oaordnrex +oarec +oasubex +oasuc +oaun2 +oaun3 +oaun3lem1 +oaun3lem2 +oaun3lem3 +oaun3lem4 +oav +oaword +oaword1 +oaword2 +oawordeu +oawordeulem +oawordex +oawordex2 +oawordex3 +oawordexr +oawordri +obs2ocv +obs2ss +obselocv +obsip +obsipid +obslbs +obsne0 +obsocv +obsrcl +obsss +obtain +oc0 +occl +occllem +occon +occon2 +occon2i +occon3 +ocel +ocid +ocin +ocndx +ocnel +ococ +ococi +ococin +ococss +ocorth +ocsh +ocss +ocv0 +ocv1 +ocv2ss +ocval +ocvcss +ocvfval +ocvi +ocvin +ocvlsp +ocvlss +ocvocv +ocvpj +ocvss +ocvsscon +ocvval +ocvz +od1 +odadd +odadd1 +odadd2 +odbezout +odcau +odcl +odcl2 +odcld +odcong +odd +odd1 +odd2np1 +odd2np1altv +odd2np1lem +odd2prm2 +odd_1 +odd_add +odd_double +odd_even +odd_exists +odd_exp +odd_exp_iff +odd_mult +odd_odd_div2 +odd_or_even +odd_pos +odd_ss +odd_sub +oddcomabszz +oddfl +oddflaltv +oddge22np1 +oddiadd +oddibas +oddinmgm +oddm1d2 +oddm1div2z +oddm1even +oddm1evenaltv +oddm1eveni +oddn2prm +oddneven +oddnn02np1 +oddnumth +oddp-+-2 +oddp1d2 +oddp1div2z +oddp1even +oddp1evenaltv +oddp1eveni +oddprm +oddprm2 +oddprmaltv +oddprmdvds +oddprmge3 +oddprmgt2 +oddprmne2 +oddprmuzge3 +oddpwdc +oddpwdcv +oddpwp1fsum +oddsumodd +oddvds +oddvds2 +oddvdsi +oddvdsnn0 +oddvdssubg +oddz +odeq +odeq1 +odf +odf1 +odf1o1 +odf1o2 +odfval +odfvalalt +odhash +odhash2 +odhash3 +odi +odid +odinf +odinv +odlem1 +odlem2 +odm1inv +odmod +odmodnn0 +odmulg +odmulg2 +odmulgeq +odmulgid +odngen +odnncl +odpmco +odrngbas +odrngds +odrngle +odrngmulr +odrngplusg +odrngstr +odrngtset +odsubdvds +odubas +oduclatb +odudlatb +oduglb +odujoin +odulat +odulatb +oduleg +oduleval +odulub +odumeet +oduoppcbas +oduoppcciso +odupos +oduposb +oduprs +odutos +oduval +odval +odval2 +odz2prm2pw +odzcl +odzcllem +odzdvds +odzid +odzphi +odzval +oe0 +oe0lem +oe0m +oe0m0 +oe0m1 +oe0rif +oe0suclim +oe1 +oe1m +oe2 +oecan +oecl +oeeu +oeeui +oeeulem +oef1o +oege1 +oege2 +oel_drop +oel_eq_el +oel_lupdate +oel_take_e +oel_thm +oelim +oelim2 +oelimcl +oemapso +oemapval +oemapvali +oemapwe +oen0 +oenass +oenassex +oenord1 +oenord1ex +oeoa +oeoalem +oeoe +oeoelem +oeord +oeord2com +oeord2i +oeord2lim +oeordi +oeordsuc +oesuc +oesuclem +oev +oev2 +oevn0 +oeword +oeworde +oewordi +oewordri +oexpled +oexpneg +oexpnegaltv +oexpnegnz +oexpreposd +of +of0r +ofaddmndmap +ofc1 +ofc12 +ofc2 +ofcc +ofccat +ofcccat +ofceq +ofcf +ofcfeqd2 +ofcfn +ofcfval +ofcfval2 +ofcfval3 +ofcfval4 +ofco +ofco2 +ofcof +ofcs1 +ofcs2 +ofcval +ofdivcan4 +ofdivdiv2 +ofdivrec +ofeq +ofeqd +ofexg +off +off2 +offinsupp1 +offn +offres +offsplitfpar +offun +offval +offval2 +offval22 +offval2f +offval3 +offvalfv +offveq +offveqb +ofldchr +ofldfld +ofldlt1 +ofldtos +ofmpteq +ofmres +ofmresex +ofmresval +ofmul12 +ofmulrt +ofnegsub +ofoaass +ofoacl +ofoacom +ofoaf +ofoafg +ofoafo +ofoaid1 +ofoaid2 +ofoprabco +ofpreima +ofpreima2 +ofrco +ofreq +ofres +ofresid +ofrfval +ofrfval2 +ofrfvalg +ofrn +ofrn2 +ofrval +ofs1 +ofs2 +ofscom +ofsubeq0 +ofsubge0 +ofsubid +oftpos +ofun +ofval +ogrpaddlt +ogrpaddltbi +ogrpaddltrbid +ogrpaddltrd +ogrpgrp +ogrpinv0le +ogrpinv0lt +ogrpinvlt +ogrpsub +ogrpsublt +oi0 +oibabs +oicl +oien +oieq1 +oieq2 +oieu +oiexg +oif +oiid +oiiniseg +oiiso +oiiso2 +oion +oismo +olc +olcd +olci +olcnd +olcs +old0 +old1 +oldbday +oldbdayim +oldf +oldfi +oldfib +oldirr +oldlim +oldmade +oldmaded +oldmj1 +oldmj2 +oldmj3 +oldmj4 +oldmm1 +oldmm2 +oldmm3n +oldmm4 +oldno +oldnod +oldss +oldssmade +oldssno +oldsuc +oldval +olj01 +olj02 +ollat +olm01 +olm02 +olm11 +olm12 +olop +olposn +om0 +om00 +om00el +om0r +om0suclim +om0x +om1 +om1addcl +om1bas +om1elbas +om1om1r +om1opn +om1plusg +om1r +om1tset +om1val +om2 +om2noseq0 +om2noseqf1o +om2noseqfo +om2noseqiso +om2noseqlt +om2noseqlt2 +om2noseqoi +om2noseqrdg +om2noseqsuc +om2uz0i +om2uzf1oi +om2uzisoi +om2uzlt2i +om2uzlti +om2uzoi +om2uzrani +om2uzrdg +om2uzsuci +om2uzuzi +omabs +omabs2 +omabslem +omass +omcan +omcl +omcl2 +omcl3g +ome0 +omecl +omedm +omef +omege0 +omeiunle +omeiunlempt +omeiunltfirp +omelaxinf2 +omelesplit +omelon +omelon2 +omenps +omensuc +omeo +omeoaltv +omess0 +omessle +omessre +omeu +omeulem1 +omeulem2 +omeunile +omeunle +omex +omexrcl +omf1o +omge1 +omge2 +omina +ominf +ominf4 +omiscard +omlfh1n +omlfh3n +omlim +omlim2 +omlimcl +omlimcl2 +omllat +omllaw +omllaw2n +omllaw3 +omllaw4 +omllaw5n +omlmod1i2n +omlol +omlop +omlsi +omlsii +omlsilem +omlspjn +omltoe +omnaddcl +omndadd +omndadd2d +omndadd2rd +omndaddr +omndmnd +omndmul +omndmul2 +omndmul3 +omndtos +omnord1 +omnord1ex +omoe +omoealtv +omon +omopth +omopth2 +omopthi +omopthlem1 +omopthlem2 +omord +omord2 +omord2com +omord2i +omord2lim +omordi +omordlim +omprcomonb +oms0 +omscl +omsf +omsfval +omsinds +omsmeas +omsmo +omsmolem +omsmon +omssaxinf2 +omssnlim +omsson +omssrncard +omssubadd +omssubaddlem +omsuc +omsucelsucb +omsucne +omsval +omun +omv +omword +omword1 +omword2 +omwordi +omwordri +omxpen +omxpenlem +on +on0eln0 +on0eqel +on2ind +on2recsfn +on2recsov +on3ind +onaddscl +onadju +onasuc +oncard +oncardid +oncardval +once_asm_rewrite_tac +once_depth_conv +once_rewrite_rule +once_rewrite_tac +oncutleft +oncutlt +ondif1 +ondif1i +ondif2 +ondomen +ondomon +one +one_element_sing +one_is_odd +one_lt_mult +one_lt_mult_imp +one_minus_half +one_mod +one_mod_iff +one_mul +one_one_inv_image_bounded +one_one_unbounded +onego +oneli +onelini +onelon +onelord +onelpss +onelss +onelssex +onelssi +oneltr +oneltri +oneluni +onenon +onenotinotbothi +oneo +onepsuc +oneptr +oneptri +oneqmin +oneqmini +onesuc +onetansqsecsq +onexgt +onexlimgt +onexoegt +onexomgt +onfin +onfin2 +onfisupcl +onfr +onfralt +onfraltlem1 +onfraltlem1vd +onfraltlem2 +onfraltlem2vd +onfraltlem3 +onfraltlem3vd +onfraltlem4 +onfraltlem4vd +onfraltlem5 +onfraltlem5vd +onfraltvd +onfununi +onin +oninfcl2 +oninfex2 +oninfint +oninfunirab +oninhaus +onint +onint0 +onint1 +oninton +onintopssconn +onintrab +onintrab2 +onintss +onintunirab +onirri +oniso +onleft +onles +onlesd +onltn0s +onlts +onltsd +onmaxnelsup +onmcl +onmindif +onmindif2 +onminesb +onminex +onminsb +onmsuc +onmulscl +onn0 +onnbtwn +onnev +onnmin +onnminsb +onno +onnobdayg +onnolt +onnoxp +onnoxpg +onnoxpi +onnseq +onomeneq +onordi +onorm +onorm_adjoint +onorm_cmul +onorm_compose +onorm_compose_adjoint_left +onorm_compose_adjoint_right +onorm_compose_orthogonal_transformation_left +onorm_compose_orthogonal_transformation_right +onorm_const +onorm_covariance +onorm_covariance_alt +onorm_derivatives_le +onorm_diagonal_matrix +onorm_diagonalized_covariance_matrix +onorm_diagonalized_matrix +onorm_dot +onorm_eq_0 +onorm_eq_max_eigenvector +onorm_i +onorm_id +onorm_inverse_det_le_onorm_pow +onorm_inverse_det_le_onorm_pow_alt +onorm_inverse_function_bound +onorm_le_eq +onorm_le_eventually +onorm_le_matrix_component +onorm_le_matrix_component_sum +onorm_le_norm_vectorize +onorm_neg +onorm_orthogonal_matrix +onorm_orthogonal_matrix_mul_left +onorm_orthogonal_matrix_mul_right +onorm_orthogonal_transformation +onorm_pos_le +onorm_pos_lt +onorm_transp +onorm_triangle +onorm_triangle_le +onorm_triangle_lt +onov0suclim +onoviun +onovuni +onprc +onpsssuc +onpsstopbas +onpwsuc +ons2ind +onsbnd +onsbnd2 +onsdom +onsdominel +onsetrec +onsetreclem1 +onsetreclem2 +onsetreclem3 +onsfi +onsis +onss +onsse +onsseleq +onsseli +onssi +onssmin +onssnel2i +onssneli +onssno +onssnum +onssr1 +onsssuc +onsssupeqcond +onsstopbas +onsuc +onsucb +onsucconn +onsucconni +onsucelab +onsucf1lem +onsucf1o +onsucf1olem +onsuci +onsucmin +onsucrn +onsucss +onsucssi +onsucsuccmp +onsucsuccmpi +onsuct0 +onsuctop +onsuctopon +onsucuni +onsucuni2 +onsucuni3 +onsucunifi +onsucunipr +onsucunitp +onsucwordi +onsupcl2 +onsupcl3 +onsupeqmax +onsupeqnmax +onsupex3 +onsupintrab +onsupintrab2 +onsuplub +onsupmaxb +onsupneqmaxlim0 +onsupnmax +onsupnub +onsupsucismax +onsupuni +onsupuni2 +onswe +ontgsucval +ontgval +ontopbas +ontr +ontr1 +ontr2 +ontri1 +ontric3g +onun2 +onun2i +onunel +onuni +onuniintrab +onuniintrab2 +onuninsuci +onuniorsuc +onunisuc +onunisuci +onvf1od +onvf1odlem1 +onvf1odlem2 +onvf1odlem3 +onvf1odlem4 +onwf +onxpdisj +onzsl +op +op01dm +op0cl +op0le +op1cl +op1le +op1st +op1sta +op1stb +op1std +op1steq +op1stg +op2nd +op2nda +op2ndb +op2ndd +op2ndg +opab0 +opabbi +opabbi2dv +opabbid +opabbidv +opabbii +opabbrex +opabbrfex0d +opabbrfexd +opabdm +opabex +opabex2 +opabex3 +opabex3d +opabex3rd +opabf +opabid +opabid2 +opabid2ss +opabidw +opabiota +opabiotadm +opabiotafun +opabn0 +opabn1stprc +opabresex0d +opabresex2 +opabresexd +opabresid +opabrn +opabss +opabssi +opabssxp +opabssxpd +opbrop +opco1 +opco1i +opco2 +opcom +opcon1b +opcon2b +opcon3b +opelcn +opelcnv +opelcnvg +opelco +opelco2g +opelco3 +opeldifid +opeldm +opeldmd +opelf +opelidres +opelinxp +opeliun2xp +opeliunxp +opeliunxp2 +opeliunxp2f +opelopab +opelopab2 +opelopab2a +opelopab3 +opelopab4 +opelopaba +opelopabaf +opelopabb +opelopabbv +opelopabd +opelopabf +opelopabg +opelopabga +opelopabgf +opelopabsb +opelopabt +opelreal +opelres +opelresi +opelrn +opelstrbas +opeluu +opelvv +opelvvdif +opelvvg +opelxp +opelxp1 +opelxp2 +opelxpd +opelxpi +opelxpii +open +open_affinity +open_affinity_eq +open_ball +open_bijective_linear_image_eq +open_carrier +open_closed +open_closed_interval_1 +open_closed_interval_convex +open_conic_hull +open_contains_ball +open_contains_ball_eq +open_contains_cball +open_contains_cball_eq +open_contains_interval +open_convex_hull +open_countable_limit_elementary +open_countable_union_closed_intervals +open_delete +open_diff +open_empty +open_exists +open_exists_in +open_finite_inter +open_halfspace_component_gt +open_halfspace_component_lt +open_halfspace_gt +open_halfspace_lt +open_imp_analytic +open_imp_baire1_indicator +open_imp_borel +open_imp_fsigma +open_imp_gdelta +open_imp_gdelta_in +open_imp_infinite +open_imp_locally_compact +open_in +open_in_analytic +open_in_borel +open_in_closed_in_eq +open_in_conic_hull +open_in_connected_component +open_in_contains_ball +open_in_contains_cball +open_in_convex_meets_relative_interior +open_in_delete +open_in_diff +open_in_diff_closed +open_in_empty +open_in_euclidean +open_in_euclidean_metric +open_in_fsigma +open_in_gdelta +open_in_imp_subset +open_in_injective_linear_image +open_in_inter +open_in_inter_closure_eq_empty +open_in_inter_closure_of_eq +open_in_inter_closure_of_eq_empty +open_in_inter_open +open_in_interior_of +open_in_locally_compact +open_in_mtopology +open_in_open +open_in_open_eq +open_in_open_inter +open_in_open_trans +open_in_pcross +open_in_pcross_eq +open_in_refl +open_in_relative_frontier_interior_facet +open_in_relative_interior +open_in_relative_to +open_in_same_conic_hull +open_in_segment +open_in_separated_union +open_in_set_relative_interior +open_in_sing +open_in_subopen +open_in_subset +open_in_subset_relative_interior +open_in_subset_trans +open_in_subtopology +open_in_subtopology_empty +open_in_subtopology_inter_open_in +open_in_subtopology_inter_subset +open_in_subtopology_refl +open_in_trans +open_in_trans_eq +open_in_translation_eq +open_in_union +open_inside +open_inter +open_inter_closure_eq +open_inter_closure_eq_empty +open_inter_closure_subset +open_interior +open_inters +open_interval +open_interval_eq +open_interval_left +open_interval_lemma +open_interval_midpoint +open_interval_right +open_invertible_linear_image +open_lift +open_map_closed_superset_preimage +open_map_closed_superset_preimage_eq +open_map_from_composition_injective +open_map_from_composition_surjective +open_map_fstcart +open_map_iff_closed_map_bijective +open_map_iff_lower_hemicontinuous_preimage +open_map_imp_closed_map +open_map_imp_quotient_map +open_map_interiors +open_map_preimage_neighbourhood +open_map_restrict +open_map_sndcart +open_measurable_inner_division +open_negations +open_not_negligible +open_open_in_trans +open_open_left_projection +open_open_right_projection +open_pcross +open_pcross_eq +open_positive_multiples +open_positive_orthant +open_relative_to +open_scaling +open_scaling_eq +open_segment_1 +open_segment_alt +open_segment_descale +open_segment_linear_image +open_segment_subset_ball +open_set_rational_coordinates +open_strip_component_lt +open_subopen +open_subset +open_subset_closure_convex +open_sums +open_surjective_linear_image +open_translation +open_translation_eq +open_translation_subset_preimage +open_union +open_union_compact_subsets +open_unions +open_univ +openaxiom +opeo +opeoaltv +opeq1 +opeq12 +opeq12d +opeq12i +opeq1d +opeq1i +opeq2 +opeq2d +opeq2i +opeqex +opeqpr +opeqsn +opeqsng +operational +operative_1_le +operative_1_lt +operative_absolutely_continuous_on +operative_absolutely_setcontinuous_on +operative_approximable +operative_content +operative_division +operative_division_and +operative_empty +operative_function_endpoint_diff +operative_has_bounded_setvariation_on +operative_has_bounded_variation_on +operative_integrable +operative_integral +operative_lifted_setvariation +operative_lifted_vector_variation +operative_real_function_endpoint_diff +operative_tagged_division +operative_trivial +opex +opexmid +opf11 +opf12 +opf2 +opf2fval +opfi1ind +opfi1uzind +opfusgr +opfv +opgpgvtx +opi1 +opi2 +opid +opideq +opidg +opidon2old +opidonold +opiedgfv +opiedgfvi +opiedgov +opiedgval +opifismgm +opiota +ople0 +ople1 +oplecon1b +oplecon3 +oplecon3b +oplem1 +opltcon1b +opltcon2b +opltcon3b +opltn0 +opmpoismgm +opnbnd +opncld +opncldeqv +opncldf1 +opncldf2 +opncldf3 +opndisj +opnfbas +opnlen0 +opnmbl +opnmblalt +opnmbllem +opnmbllem0 +opnnei +opnneieqv +opnneieqvv +opnneiid +opnneil +opnneilem +opnneilv +opnneip +opnneir +opnneirv +opnneiss +opnneissb +opnoncon +opnrebl +opnrebl2 +opnreen +opnregcld +opnssborel +opnssneib +opnsubg +opnvonmbl +opnvonmbllem1 +opnvonmbllem2 +opnz +opnzi +opoc0 +opoc1 +opoccl +opococ +opoe +opoealtv +oposlem +oppc1stf +oppc1stflem +oppc2ndf +oppcbas +oppccat +oppccatb +oppccatf +oppccatid +oppccic +oppccicb +oppcciceq +oppcco +oppccofval +oppccomfpropd +oppcendc +oppcepi +oppchofcl +oppchom +oppchomf +oppchomfpropd +oppchomfval +oppcid +oppcinito +oppcinv +oppciso +oppcmndc +oppcmndclem +oppcmon +oppcom +oppcsect +oppcsect2 +oppcterm +oppctermco +oppctermhom +oppctermo +oppcthin +oppcthinco +oppcthinendc +oppcthinendcalt +oppcup +oppcup2 +oppcup3 +oppcup3lem +oppcuprcl2 +oppcuprcl3 +oppcuprcl4 +oppcuprcl5 +oppcval +oppcyon +oppczeroo +oppf1 +oppf1st2nd +oppf2 +oppfdiag +oppfdiag1 +oppfdiag1a +oppff1 +oppff1o +oppffn +oppfoppc +oppfoppc2 +oppfrcl +oppfrcl2 +oppfrcl3 +oppfrcllem +oppfuprcl +oppfuprcl2 +oppfval +oppfval2 +oppfval3 +oppfvalg +oppfvallem +oppgbas +oppgcntr +oppgcntz +oppggic +oppggrp +oppggrpb +oppgid +oppginv +oppgle +oppglsm +oppglt +oppgmnd +oppgmndb +oppgoppcco +oppgoppchom +oppgoppcid +oppgplus +oppgplusfval +oppgsubg +oppgsubm +oppgtgp +oppgtmd +oppgtopn +oppgtset +oppgval +opphl +opphllem +opphllem1 +opphllem2 +opphllem3 +opphllem4 +opphllem5 +opphllem6 +oppne1 +oppne2 +oppne3 +oppnid +opposet +oppperpex +oppr +oppr0 +oppr1 +oppr2idl +opprablb +opprabs +oppradd +opprb +opprbas +opprc +opprc1 +opprc2 +opprdomn +opprdomnb +opprdrng +oppreqg +opprgrpb +opprirred +opprlem +opprlidlabs +opprmndb +opprmul +opprmulfval +opprmxidlabs +opprneg +opprnsg +opprnzr +opprnzrb +opprqus0g +opprqus1r +opprqusbas +opprqusdrng +opprqusmulr +opprqusplusg +opprring +opprringb +opprrng +opprrngb +opprsubg +opprsubrg +opprsubrng +opprunit +opprval +opptgdim2 +oprab2co +oprab4 +oprabbi +oprabbid +oprabbidv +oprabbii +oprabco +oprabex +oprabex3 +oprabexd +oprabid +oprabidw +oprabrexex2 +oprabss +oprabv +oprcl +opres +opreu2reu +opreu2reu1 +opreu2reualt +opreu2reurex +opreuopreu +opropabco +oprpiece1res1 +oprpiece1res2 +oprres +oprssdm +oprssov +opsbc2ie +opsqrlem1 +opsqrlem2 +opsqrlem3 +opsqrlem4 +opsqrlem5 +opsqrlem6 +opsr0 +opsr1 +opsrassa +opsrbas +opsrbaslem +opsrcrng +opsrle +opsrlmod +opsrmulr +opsrplusg +opsrring +opsrsca +opsrso +opsrtos +opsrtoslem1 +opsrtoslem2 +opsrval +opsrval2 +opsrvsca +opstrgric +opswap +opth +opth1 +opth1g +opth1neg +opth2 +opth2neg +opthg +opthg2 +opthhausdorff +opthhausdorff0 +opthne +opthneg +opthpr +opthprc +opthprneg +opthreg +opthwiener +option_assoc +option_left_id +option_map_compose +option_none_not_some +option_right_id +option_some_inj +optocl +optoclold +opvtxfv +opvtxfvi +opvtxov +opvtxval +opwf +opwo0id +or +or-comm +or12 +or2expropbi +or2expropbilem1 +or2expropbilem2 +or32 +or32dd +or3di +or3dir +or3or +or4 +or42 +or_assoc +or_associative +or_clauses +or_comm +or_comm_pf +or_commutative +or_distrib_and +or_distributes_over_and +or_elim +or_exists_thm +or_impl +or_intro_l +or_intro_left +or_intro_r +or_intro_right +or_less +or_sym +orabs +oran +oranabs +orass +orassociative +orbi1 +orbi12d +orbi12i +orbi1d +orbi1i +orbi1r +orbi1rvd +orbi2d +orbi2i +orbi2ialt +orbidi +orbitcl +orbitclmpt +orbitex +orbitinit +orbsta +orbsta2 +orbstafun +orbstaval +orc +orcanai +orcd +orci +orcnd +orcom +orcomd +orcomdd +orcommutative +orcoms +orcs +ord +ord0 +ord0eln0 +ord1eln01 +ord2eln012 +ord3 +ord3ex +ord_bound +ordcmp +orddi +orddif +orddif0suc +orddisj +ordeldif +ordeldif1o +ordeldifsucon +ordeleqon +ordelinel +ordelon +ordelord +ordelordalt +ordelordaltvd +ordelpss +ordelss +ordelssne +ordelsuc +ordeq +ordequn +order +order_fill_balance +orderantisymm +orderedp-isort +orderedp-merge +orderedp-msort +orderseqlem +ordertrans +ordfin +ordfr +ordge1n0 +ordgt0ge1 +ordi +ordin +ordinal_add_succ +ordinal_add_zero +ordinal_limit_not_succ +ordinal_lt_irrefl +ordinal_lt_trans +ordinal_mul_zero +ordinal_succ_gt +ordinal_succ_ordinal +ordinal_transfinite_ind +ordinal_trichotomy +ordintdif +ordir +ordirr +ordiso +ordiso2 +ordn2lp +ordnbtwn +ordne0gt0 +ordnexbtwnsuc +ordom +ordon +ordpinq +ordpipq +ordpss +ordpwsuc +ordsseleq +ordsson +ordsssuc +ordsssuc2 +ordsssucb +ordsssucim +ordssun +ordsuc +ordsucelsuc +ordsuci +ordsucss +ordsucsssuc +ordsucun +ordsucuni +ordsucuniel +ordtbas +ordtbas2 +ordtbaslem +ordtcld1 +ordtcld2 +ordtcld3 +ordtcnv +ordtcnvnew +ordtconn +ordtconnlem1 +ordthaus +ordthauslem +ordthmeo +ordthmeolem +ordtop +ordtopconn +ordtoplem +ordtopn1 +ordtopn2 +ordtopn3 +ordtopt0 +ordtprsuni +ordtprsval +ordtr +ordtr1 +ordtr2 +ordtr3 +ordtrest +ordtrest2 +ordtrest2lem +ordtrest2new +ordtrest2newlem +ordtresticc +ordtrestixx +ordtrestnew +ordtri1 +ordtri2 +ordtri2or +ordtri2or2 +ordtri2or3 +ordtri3 +ordtri3or +ordtri4 +ordtt1 +ordttop +ordttopon +ordtuni +ordtval +ordtype +ordtype2 +ordtypecbv +ordtypelem1 +ordtypelem10 +ordtypelem2 +ordtypelem3 +ordtypelem4 +ordtypelem5 +ordtypelem6 +ordtypelem7 +ordtypelem8 +ordtypelem9 +ordun +ordunel +orduni +ordunidif +ordunifi +orduninsuc +orduniorsuc +orduniss +orduniss2 +ordunisssuc +ordunisuc +ordunisuc2 +ordunpr +ordvdsmul +ordwe +ordzsl +orel +orel1 +orel2 +orelim +orelse +orfa +orfa1 +orfa2 +orfalseneutral +ori +oridm +orim12d +orim12da +orim12dalt +orim12i +orim1d +orim1i +orim2 +orim2d +orim2i +orimdi +ormkglobd +ormklocald +orng0le1 +ornglmulle +ornglmullt +orngmul +orngmullt +orngogrp +orngring +orngrmulle +orngrmullt +orngsqr +ornld +orordi +orordir +orrabdioph +orrd +orri +orrvccel +orrvcoel +orrvcval4 +orsild +orsird +orthcom +orthin +orthogonal_0 +orthogonal_and_collinear +orthogonal_any_closest_point +orthogonal_basis +orthogonal_basis_basis +orthogonal_basis_exists +orthogonal_basis_subspace +orthogonal_clauses +orthogonal_extension +orthogonal_extension_strong +orthogonal_imp_independent_subspaces +orthogonal_linear_image_eq +orthogonal_lneg +orthogonal_lvsum +orthogonal_matrix +orthogonal_matrix_1 +orthogonal_matrix_2 +orthogonal_matrix_2_alt +orthogonal_matrix_alt +orthogonal_matrix_exists_basis +orthogonal_matrix_id +orthogonal_matrix_imp_invertible +orthogonal_matrix_inv +orthogonal_matrix_inv_eq +orthogonal_matrix_matrix +orthogonal_matrix_mul +orthogonal_matrix_norm +orthogonal_matrix_norm_eq +orthogonal_matrix_orthogonal_eigenvectors +orthogonal_matrix_orthonormal_columns +orthogonal_matrix_orthonormal_columns_indexed +orthogonal_matrix_orthonormal_columns_pairwise +orthogonal_matrix_orthonormal_columns_span +orthogonal_matrix_orthonormal_rows +orthogonal_matrix_orthonormal_rows_indexed +orthogonal_matrix_orthonormal_rows_pairwise +orthogonal_matrix_orthonormal_rows_span +orthogonal_matrix_transformation +orthogonal_matrix_transp +orthogonal_matrix_transp_lmul +orthogonal_matrix_transp_rmul +orthogonal_mul +orthogonal_nullspace_rowspace +orthogonal_orthogonal_transformation +orthogonal_projection_alt +orthogonal_projection_eq_self_adjoint_idempotent +orthogonal_refl +orthogonal_rneg +orthogonal_rotation_or_rotoinversion +orthogonal_rvsum +orthogonal_simp_clauses +orthogonal_spanningset_subspace +orthogonal_subspace_decomp +orthogonal_subspace_decomp_exists +orthogonal_subspace_decomp_unique +orthogonal_sum_lemma +orthogonal_sym +orthogonal_to_orthogonal_2d +orthogonal_to_span +orthogonal_to_span_eq +orthogonal_to_spans_eq +orthogonal_to_subspace_exists +orthogonal_to_subspace_exists_gen +orthogonal_to_vector_exists +orthogonal_transformation +orthogonal_transformation_1_gen +orthogonal_transformation_adjoint +orthogonal_transformation_ball +orthogonal_transformation_between_orthogonal_sets +orthogonal_transformation_cball +orthogonal_transformation_compose +orthogonal_transformation_eq_adjoint +orthogonal_transformation_eq_adjoint_left +orthogonal_transformation_eq_adjoint_right +orthogonal_transformation_exists +orthogonal_transformation_exists_1 +orthogonal_transformation_exists_gen +orthogonal_transformation_generated_by_reflections +orthogonal_transformation_i +orthogonal_transformation_id +orthogonal_transformation_imp_homeomorphism +orthogonal_transformation_injective +orthogonal_transformation_into_subspace +orthogonal_transformation_inverse +orthogonal_transformation_inverse_o +orthogonal_transformation_isometry +orthogonal_transformation_linear +orthogonal_transformation_lowdim_horizontal +orthogonal_transformation_matrix +orthogonal_transformation_neg +orthogonal_transformation_negation +orthogonal_transformation_onto_subspace +orthogonal_transformation_orthogonal_eigenvectors +orthogonal_transformation_reflect_along +orthogonal_transformation_reflect_induct +orthogonal_transformation_sphere +orthogonal_transformation_surjective +orthogonality_preserving_imp_scaling +orthonormal_basis_expand +orthonormal_basis_expand_dot +orthonormal_basis_expand_norm +orthonormal_basis_subspace +orthonormal_extension +orvccel +orvcelel +orvcelval +orvcgteel +orvclteel +orvclteinc +orvcoel +orvcval +orvcval2 +orvcval4 +ostrowski_theorem +ostth +ostth1 +ostth2 +ostth2lem1 +ostth2lem2 +ostth2lem3 +ostth2lem4 +ostth3 +ostthlem1 +ostthlem2 +osum +osumcllem10n +osumcllem11n +osumcllem1n +osumcllem2n +osumcllem3n +osumcllem4n +osumcllem5n +osumcllem6n +osumcllem7n +osumcllem8n +osumcllem9n +osumcln +osumcor2i +osumcori +osumi +ot1stg +ot2ndg +ot3rdg +otel3xp +otelxp +otelxp1 +oteq1 +oteq123d +oteq1d +oteq2 +oteq2d +oteq3 +oteq3d +oteqex +oteqex2 +oteqimp +otex +otiunsndisj +otiunsndisjx +otpsbas +otpsle +otpsstr +otpstset +otsndisj +otth +otth2 +otthg +otthne +ottpos +outer_lebesgue_measure +outer_measure +outer_measure_eq +outer_measure_gen +outpasch +outsidele +outsidene1 +outsidene2 +outsideofcol +outsideofcom +outsideofeq +outsideofeu +outsideofrflx +outsideoftr +ov +ov2gf +ov2ssiunov2 +ov3 +ov6g +ovanraleqv +ovconst2 +ovelimab +ovelrn +oveq +oveq1 +oveq12 +oveq123d +oveq123i +oveq12d +oveq12i +oveq1d +oveq1i +oveq2 +oveq2d +oveq2i +oveqan12d +oveqan12rd +oveqd +oveqdr +oveqi +oveqprc +oveqrspc2v +over +ovex +ovexd +ovexi +ovg +ovid +ovidi +ovidig +ovif +ovif12 +ovif2 +ovig +ovigg +ovima0 +ovmpo +ovmpoa +ovmpod +ovmpodf +ovmpodv +ovmpodv2 +ovmpodx +ovmpodxf +ovmpoelrn +ovmpog +ovmpoga +ovmpogad +ovmpordx +ovmpordxf +ovmpos +ovmpot +ovmpox +ovmpox2 +ovmpt3rab1 +ovmpt3rabdm +ovmpt4d +ovmpt4g +ovmptss +ovn0 +ovn02 +ovn0dmfun +ovn0lem +ovn0ssdmfun +ovn0val +ovncl +ovncvr2 +ovncvrrp +ovnf +ovnhoi +ovnhoilem1 +ovnhoilem2 +ovnlecvr +ovnlecvr2 +ovnlerp +ovnn0val +ovnome +ovnovol +ovnovollem1 +ovnovollem2 +ovnovollem3 +ovnpnfelsup +ovnprodcl +ovnsplit +ovnssle +ovnsslelem +ovnsubadd +ovnsubadd2 +ovnsubadd2lem +ovnsubaddlem1 +ovnsubaddlem2 +ovnsupge0 +ovnval +ovnval2 +ovnval2b +ovnxrcl +ovol0 +ovolcl +ovolctb +ovolctb2 +ovolf +ovolfcl +ovolfi +ovolficc +ovolficcss +ovolfiniun +ovolfioo +ovolfs2 +ovolfsf +ovolfsval +ovolge0 +ovolgelb +ovolicc +ovolicc1 +ovolicc2 +ovolicc2lem1 +ovolicc2lem2 +ovolicc2lem3 +ovolicc2lem4 +ovolicc2lem5 +ovolicopnf +ovolioo +ovoliun +ovoliun2 +ovoliunlem1 +ovoliunlem2 +ovoliunlem3 +ovoliunnfl +ovoliunnul +ovollb +ovollb2 +ovollb2lem +ovollecl +ovolmge0 +ovolq +ovolre +ovolsca +ovolscalem1 +ovolscalem2 +ovolsf +ovolshft +ovolshftlem1 +ovolshftlem2 +ovolsn +ovolsplit +ovolss +ovolsscl +ovolsslem +ovolssnul +ovolun +ovolunlem1 +ovolunlem1a +ovolunlem2 +ovolunnul +ovolval +ovolval2 +ovolval2lem +ovolval3 +ovolval4 +ovolval4lem1 +ovolval4lem2 +ovolval5 +ovolval5lem1 +ovolval5lem2 +ovolval5lem3 +ovprc +ovprc1 +ovprc2 +ovrcl +ovres +ovresd +ovrspc2v +ovsn +ovsn2 +ovsng +ovsng2 +ovssunirn +ovtpos +oyon1cl +oyoncl +p +p0ex +p0exalt +p0le +p0val +p1evtxdeq +p1evtxdeqlem +p1evtxdp1 +p1le +p1lep2 +p1modne +p1modz1 +p1val +p_hull +p_i_h +p_spec +packet_checksum +padct +padd01 +padd02 +padd12n +padd4n +paddass +paddasslem1 +paddasslem10 +paddasslem11 +paddasslem12 +paddasslem13 +paddasslem14 +paddasslem15 +paddasslem16 +paddasslem17 +paddasslem18 +paddasslem2 +paddasslem3 +paddasslem4 +paddasslem5 +paddasslem6 +paddasslem7 +paddasslem8 +paddasslem9 +paddatcln +paddcln +paddcom +paddfval +paddidm +paddss +paddss1 +paddss12 +paddss2 +paddssat +paddssw1 +paddssw2 +paddunn +paddunssn +paddval +paddval0 +paddvaln0n +padicabv +padicabvcxp +padicabvf +padicfval +padicval +pair_eq +pair_eta +pair_in_gspec_1 +pair_in_gspec_2 +pair_in_gspec_iff +pair_in_gspec_same +pair_to_num_formula +pair_to_num_inv +pairarg_tac +pairelim +paireqne +paireta +pairreueq +pairwise_disjoint_components +pairwise_empty +pairwise_image +pairwise_imp +pairwise_insert +pairwise_mono +pairwise_orthogonal_imp_finite +pairwise_orthogonal_independent +pairwise_separated_components +pairwise_sing +pairwise_subset +pairwise_union +paracompact +paracompact_partition_of_unity +paracompact_space_euclidean +paracompact_space_euclidean_subtopology +paracompact_space_mtopology +param_poly +parametric_hoas +parametricity +parity +parse +parse_expr +parser_alt +parser_bind +parser_char +parser_digit +parser_many +parser_map +parser_ret +parser_satisfy +part_in +part_in_partition +part_induction +part_match +part_measures +part_not_in +part_partition +part_sing +part_unique +parteq1 +parteq12 +parteq1d +parteq1i +parteq2 +partfun +partfun2 +partial_division_extend +partial_division_extend_1 +partial_division_extend_interval +partial_division_of_tagged_division +partial_expand_quants_conv +partial_order_antisym +partial_solution_eq_prefix +partial_sums_component_le_infsum +partial_sums_drop_le_infsum +partim +partim2 +partimcomember +partimeq +partition +partition_card +partition_elements_disjoint +partition_elements_interrelate +partition_quotient +partition_rel_eq +partition_spec +partition_subset +partitioneithers +partitions_covers +partitions_disjoint +partitions_finite +partitions_inj +partitions_insert +partitions_pair_disjoint +partitions_sing +partitions_thm +parts_disjoint +parts_order +parts_order_le +partsuc +partsuc2 +password_hash_oneway +paste +pastecart_add +pastecart_as_orthogonal_sum +pastecart_cmul +pastecart_eq +pastecart_eq_vec +pastecart_fst_snd +pastecart_in_interior +pastecart_in_interior_subtopology +pastecart_in_pcross +pastecart_inj +pastecart_neg +pastecart_sub +pastecart_vec +pastecart_vsum +pasting_lemma +path_combine +path_continuous_image +path_eq +path_is_walk +path_join +path_join_path_ends +path_length_combine +path_length_differentiable +path_length_eq +path_length_eq_0 +path_length_eq_line_segment +path_length_isometric_image +path_length_join +path_length_linear_image +path_length_linepath +path_length_lipschitz +path_length_pos_le +path_length_reparametrization +path_length_reversepath +path_length_scaling +path_length_shiftpath +path_length_subpath +path_length_subpath_le +path_length_translation +path_linear_image_eq +path_linepath +path_reversepath +path_shiftpath +path_subpath +path_translation_eq +path_weight_append +path_weight_cons +path_weight_join +path_weight_singleton +pathfinish_in_path_image +pathstart_in_path_image +patient_bed_assignment +pats +patterns +pautsetn +paysd +pc0 +pc1 +pc11 +pc2dvds +pcabs +pcadd +pcadd2 +pcaddlem +pcb_assembly +pcbc +pcbcctr +pccl +pccld +pcdiv +pcdvds +pcdvdsb +pcdvdstr +pcelnn +pceq0 +pceu +pceulem +pcexp +pcfac +pcfaclem +pcgcd +pcgcd1 +pcge0 +pcid +pcidlem +pcl0bn +pcl0n +pclbtwnn +pclcln +pclcmpatn +pclem +pclem6 +pclfincln +pclfinn +pclfvaln +pclidn +pclogsum +pclss2poln +pclssidn +pclssn +pclun2n +pclunn +pclvaln +pcmplfin +pcmplfinf +pcmpt +pcmpt2 +pcmptcl +pcmptdvds +pcmul +pcndvds +pcndvds2 +pcneg +pco0 +pco1 +pcoass +pcocn +pcofval +pcohtpy +pcohtpylem +pconncn +pconnconn +pconnpi1 +pconntop +pcophtb +pcopt +pcopt2 +pcoptcl +pcorev +pcorev2 +pcorevcl +pcorevlem +pcoval +pcoval1 +pcoval2 +pcovalg +pcpre1 +pcprecl +pcpremul +pcprendvds +pcprendvds2 +pcprmpw +pcprmpw2 +pcprod +pcqcl +pcqdiv +pcqmul +pcrec +pcross +pcross_as_orthogonal_sum +pcross_diff +pcross_empty +pcross_eq +pcross_eq_empty +pcross_interval +pcross_mono +pcval +pcxcl +pcxnn0cl +pcz +pczcl +pczdvds +pczndvds +pczndvds2 +pczpre +pda +pda-state +peano1 +peano2 +peano2b +peano2cn +peano2cnm +peano2fzor +peano2fzr +peano2n0s +peano2n0sd +peano2nn +peano2nn0 +peano2nnd +peano2nns +peano2no +peano2ons +peano2re +peano2rem +peano2uz +peano2uz2 +peano2uzr +peano2uzs +peano2z +peano2zd +peano2zm +peano3 +peano4 +peano5 +peano5n0s +peano5nni +peano5uzi +peano5uzs +peano5uzti +peirce +peirce_law +peirceroll +pell1234qrdich +pell1234qrmulcl +pell1234qrne0 +pell1234qrre +pell1234qrreccl +pell1234qrval +pell14qrdich +pell14qrdivcl +pell14qrexpcl +pell14qrexpclnn0 +pell14qrgap +pell14qrgapw +pell14qrgt0 +pell14qrmulcl +pell14qrne0 +pell14qrre +pell14qrreccl +pell14qrrp +pell14qrss1234 +pell14qrval +pell1qr1 +pell1qrgap +pell1qrgaplem +pell1qrge1 +pell1qrss14 +pell1qrval +pell_induction +pellex +pellexlem1 +pellexlem2 +pellexlem3 +pellexlem4 +pellexlem5 +pellexlem6 +pellfund14 +pellfund14b +pellfund14gap +pellfundex +pellfundge +pellfundglb +pellfundgt1 +pellfundlb +pellfundne1 +pellfundre +pellfundrp +pellfundval +pellqrex +pellqrexplicit +per cases +percentage +perfcls +perfdvf +perfect +perfect1 +perfect_from_closure +perfect_size +perfectaltv +perfectaltvlem1 +perfectaltvlem2 +perfectlem1 +perfectlem2 +perfi +perflp +perfopn +perftop +perm-isort +perm-merge +perm-msort +perm_length +perm_refl +perm_sort +perm_sym +perm_trans +permac8prim +permaxext +permaxinf2 +permaxinf2lem +permaxnul +permaxpow +permaxpr +permaxrep +permaxsep +permaxun +permnn +permut +permut_prefix +permutation_permutes +permutes_bijections +permutes_empty +permutes_image +permutes_in_image +permutes_injective +permutes_inverse +permutes_inverse_eq +permutes_sing +permutes_swap +perpcom +perpdrag +perpdragalt +perpln1 +perpln2 +perpneq +perprag +pet +pet0 +pet02 +pet2 +petid +petid2 +petidres +petidres2 +petincnvepres +petincnvepres2 +petinidres +petinidres2 +petlem +petlemi +pets +pets2eq +petseq +petxrnidres +petxrnidres2 +pexmidaltn +pexmidlem1n +pexmidlem2n +pexmidlem3n +pexmidlem4n +pexmidlem5n +pexmidlem6n +pexmidlem7n +pexmidlem8n +pexmidn +pf +pf1addcl +pf1const +pf1f +pf1id +pf1ind +pf1mpf +pf1mulcl +pf1rcl +pf1subrg +pfx0 +pfx00 +pfx1 +pfx1s2 +pfx2 +pfxccat1 +pfxccat3 +pfxccat3a +pfxccatid +pfxccatin12 +pfxccatin12d +pfxccatin12lem1 +pfxccatin12lem2 +pfxccatin12lem2a +pfxccatin12lem2c +pfxccatin12lem3 +pfxccatin12lem4 +pfxccatpfx1 +pfxccatpfx2 +pfxcctswrd +pfxchn +pfxcl +pfxco +pfxeq +pfxf +pfxf1 +pfxfn +pfxfv +pfxfv0 +pfxfvlsw +pfxid +pfxlen +pfxlsw2ccat +pfxlswccat +pfxmpt +pfxn0 +pfxnd +pfxnd0 +pfxnndmnd +pfxpfx +pfxpfxid +pfxres +pfxrn +pfxrn2 +pfxrn3 +pfxsuff1eqwrdeq +pfxsuffeqwrdeq +pfxswrd +pfxtrcfv +pfxtrcfv0 +pfxtrcfvl +pfxval +pfxval0 +pfxwlk +pfxwrdsymb +pg4cyclnex +pgind +pgindlem +pgindnf +pgjsgr +pglem +pgn4cyclex +pgnbgreunbgr +pgnbgreunbgrlem1 +pgnbgreunbgrlem2 +pgnbgreunbgrlem2lem1 +pgnbgreunbgrlem2lem2 +pgnbgreunbgrlem2lem3 +pgnbgreunbgrlem3 +pgnbgreunbgrlem4 +pgnbgreunbgrlem5 +pgnbgreunbgrlem5lem1 +pgnbgreunbgrlem5lem2 +pgnbgreunbgrlem5lem3 +pgnbgreunbgrlem6 +pgnioedg1 +pgnioedg2 +pgnioedg3 +pgnioedg4 +pgnioedg5 +pgp0 +pgpfac +pgpfac1 +pgpfac1lem1 +pgpfac1lem2 +pgpfac1lem3 +pgpfac1lem3a +pgpfac1lem4 +pgpfac1lem5 +pgpfaclem1 +pgpfaclem2 +pgpfaclem3 +pgpfi +pgpfi1 +pgpfi2 +pgpgrp +pgphash +pgpprm +pgpssslw +pgrpgt2nabl +pgrple2abl +pgrpsubgsymg +pgrpsubgsymgbi +phabs +phclm +phi1 +phi_limit_strong +phibnd +phibndlem +phicl +phicl2 +phicld +phimul +phimullem +phiprm +phiprmpw +phisum +phival +phlbase +phlip +phlipf +phllmhm +phllmod +phllvec +phlplusg +phlpropd +phlsca +phlsrng +phlssphl +phlstr +phlvsca +phnv +phnvi +phoeqi +phop +php +php2 +php3 +php4 +php5 +phpar +phpar2 +phpeqd +phphashd +phphashrd +phplem1 +phplem2 +phpreu +phrel +phssip +phssipval +phtpc01 +phtpcco2 +phtpcer +phtpcrel +phtpy01 +phtpycc +phtpycn +phtpyco2 +phtpycom +phtpyhtpy +phtpyi +phtpyid +pi1addf +pi1addval +pi1bas +pi1bas2 +pi1bas3 +pi1blem +pi1buni +pi1cof +pi1coghm +pi1coval +pi1cpbl +pi1eluni +pi1grp +pi1grplem +pi1id +pi1inv +pi1val +pi1xfr +pi1xfrcnv +pi1xfrcnvlem +pi1xfrf +pi1xfrgim +pi1xfrval +pi_constant +pibp16 +pibp19 +pibp21 +pibt1 +pibt2 +picard_lindelof_right +picn +pidiv2halves +pidlnz +pidlnzb +pidufd +pige3 +pige3alt +pigeon +pigeon_bounded +pigeon_hole +pigeonhole +pigeons +pigt2lt4 +pigt3 +pilem1 +pilem2 +pilem3 +pimconstlt0 +pimconstlt1 +pimdecfgtioc +pimdecfgtioo +pimgtmnf +pimgtmnf2 +pimgtmnff +pimgtpnf2 +pimgtpnf2f +pimincfltioc +pimincfltioo +pimiooltgt +pimltmnf2 +pimltmnf2f +pimltpnf +pimltpnf2 +pimltpnf2f +pimltpnff +pimrecltneg +pimrecltpos +pimxrneun +pine0 +pinn +pinq +pinst +pion +piord +pipeline +pipos +pire +pirp +pj0i +pj11 +pj11i +pj1eq +pj1eu +pj1f +pj1fval +pj1ghm +pj1ghm2 +pj1id +pj1lid +pj1lmhm +pj1lmhm2 +pj1rid +pj1val +pj2cocli +pj2f +pj3cor1i +pj3i +pj3lem1 +pj3si +pjaddi +pjaddii +pjadj2 +pjadj2coi +pjadj3 +pjadjcoi +pjadji +pjadjii +pjbdlni +pjch +pjch1 +pjchi +pjci +pjcji +pjcjt2 +pjclem1 +pjclem2 +pjclem3 +pjclem4 +pjclem4a +pjcli +pjclii +pjcmul1i +pjcmul2i +pjcocli +pjcofni +pjcohcli +pjcohocli +pjcoi +pjcompi +pjcss +pjddii +pjdifnormi +pjdifnormii +pjdm +pjdm2 +pjds3i +pjdsi +pjeq +pjf +pjf2 +pjff +pjfi +pjfn +pjfni +pjfo +pjfoi +pjfval +pjfval2 +pjhcl +pjhcli +pjhclii +pjhf +pjhfo +pjhfval +pjhmop +pjhmopi +pjhmopidm +pjhth +pjhtheu +pjhtheu2 +pjhthlem1 +pjhthlem2 +pjhthmo +pjhval +pjid +pjidmco +pjidmcoi +pjidmi +pjige0 +pjige0i +pjimai +pjin1i +pjin2i +pjin3i +pjini +pjinormi +pjinormii +pjinvari +pjjsi +pjlnopi +pjmf1 +pjmfn +pjmuli +pjmulii +pjnel +pjneli +pjnmopi +pjnorm +pjnorm2 +pjnormi +pjnormssi +pjo +pjoc1 +pjoc1i +pjoc2 +pjoc2i +pjoccl +pjoccoi +pjoci +pjocini +pjococi +pjocvec +pjoi0 +pjoi0i +pjoml +pjoml2 +pjoml2i +pjoml3 +pjoml3i +pjoml4i +pjoml5 +pjoml5i +pjoml6i +pjomli +pjop +pjopi +pjopyth +pjopythi +pjordi +pjorthcoi +pjorthi +pjpj0i +pjpjhth +pjpjhthi +pjpji +pjpjpre +pjpm +pjpo +pjpoi +pjpreeq +pjpyth +pjpythi +pjrn +pjrni +pjs14i +pjscji +pjsdi2i +pjsdii +pjspansn +pjss1coi +pjss2coi +pjss2i +pjssdif1i +pjssdif2i +pjssge0i +pjssge0ii +pjsslem +pjssmi +pjssmii +pjssposi +pjssumi +pjsubi +pjsubii +pjsumi +pjth +pjth2 +pjthlem1 +pjthlem2 +pjtoi +pjval +pjvec +pjvi +pl1cn +pl42lem1n +pl42lem2n +pl42lem3n +pl42lem4n +pl42n +plcofph +pldofph +ple1 +pleid +plelttr +plendx +plendxnbasendx +plendxnmulrndx +plendxnn +plendxnocndx +plendxnplusgndx +plendxnscandx +plendxnvscandx +pleval2 +pleval2i +pliguhgr +plpv +pltfval +pltirr +pltle +pltletr +pltn2lp +pltne +pltnle +pltnlt +plttr +pltval +pltval3 +plus +plus-assoc +plus-associative +plus-comm +plus_0_r +plus_assoc +plus_comm +plus_le_compat_r +plus_succ_r +plusassociative +pluscommutative +plusfeq +plusffn +plusffval +plusfreseq +plusfval +plusgid +plusgndx +plusgndxnmulrndx +plusgndxnn +plusmod5ne +plussuccrightsucc +pluszerorightneutral +plvcofph +plvcofphax +plvofpos +ply0 +ply10s0 +ply1annidl +ply1annidllem +ply1annig1p +ply1annnr +ply1annprmidl +ply1ascl +ply1ascl0 +ply1ascl1 +ply1asclunit +ply1asclzrhval +ply1ass23l +ply1assa +ply1bas +ply1bascl +ply1bascl2 +ply1basf +ply1basfvi +ply1basold +ply1baspropd +ply1chr +ply1coe +ply1coe1eq +ply1coedeg +ply1coefsupp +ply1crng +ply1degleel +ply1degltdim +ply1degltdimlem +ply1degltel +ply1degltlss +ply1dg1rt +ply1dg1rtn0 +ply1dg3rt0irred +ply1divalg +ply1divalg2 +ply1divalg3 +ply1divex +ply1divmo +ply1domn +ply1fermltl +ply1fermltlchr +ply1frcl +ply1gsumz +ply1idom +ply1idvr1 +ply1idvr1old +ply1lmod +ply1lpir +ply1lss +ply1lvec +ply1moncl +ply1moneq +ply1mpl0 +ply1mpl1 +ply1mulgsum +ply1mulgsumlem1 +ply1mulgsumlem2 +ply1mulgsumlem3 +ply1mulgsumlem4 +ply1mulr +ply1mulrtss +ply1nz +ply1nzb +ply1opprmul +ply1pid +ply1plusg +ply1plusgfvi +ply1plusgpropd +ply1rem +ply1remlem +ply1ring +ply1sca +ply1sca2 +ply1scl0 +ply1scl0old +ply1scl1 +ply1scl1old +ply1sclcl +ply1scleq +ply1sclf +ply1sclf1 +ply1sclid +ply1scln0 +ply1sclrmsm +ply1scltm +ply1subrg +ply1term +ply1termlem +ply1tmcl +ply1unit +ply1val +ply1vr1smo +ply1vsca +ply1vscl +plyadd +plyaddcl +plyaddlem +plyaddlem1 +plybss +plycj +plycjlem +plycjold +plycn +plycnold +plyco +plyco0 +plyconst +plycpn +plydivalg +plydiveu +plydivex +plydivlem1 +plydivlem2 +plydivlem3 +plydivlem4 +plyeq0 +plyeq0lem +plyexmo +plyf +plyid +plymul +plymul02 +plymul0or +plymulcl +plymullem +plymullem1 +plymulx +plymulx0 +plypf1 +plypow +plyrecj +plyrecld +plyrem +plyremlem +plyreres +plyss +plyssc +plysub +plysubcl +plyun0 +plyval +pm1.2 +pm1.4 +pm1.5 +pm10.12 +pm10.14 +pm10.251 +pm10.252 +pm10.253 +pm10.42 +pm10.52 +pm10.53 +pm10.541 +pm10.542 +pm10.55 +pm10.56 +pm10.57 +pm11.07 +pm11.11 +pm11.12 +pm11.52 +pm11.53 +pm11.53v +pm11.57 +pm11.58 +pm11.59 +pm11.6 +pm11.61 +pm11.62 +pm11.63 +pm11.7 +pm11.71 +pm13.13a +pm13.13b +pm13.14 +pm13.18 +pm13.181 +pm13.183 +pm13.192 +pm13.193 +pm13.194 +pm13.195 +pm13.196a +pm14.12 +pm14.122a +pm14.122b +pm14.122c +pm14.123a +pm14.123b +pm14.123c +pm14.18 +pm14.24 +pm2.01 +pm2.01d +pm2.01da +pm2.01i +pm2.04 +pm2.07 +pm2.1 +pm2.13 +pm2.18 +pm2.18d +pm2.18da +pm2.18i +pm2.21 +pm2.21d +pm2.21dd +pm2.21ddalt +pm2.21ddne +pm2.21fal +pm2.21i +pm2.24 +pm2.24d +pm2.24i +pm2.24ii +pm2.24nel +pm2.25 +pm2.26 +pm2.27 +pm2.3 +pm2.31 +pm2.32 +pm2.36 +pm2.37 +pm2.38 +pm2.4 +pm2.41 +pm2.42 +pm2.43 +pm2.43a +pm2.43b +pm2.43bgbi +pm2.43cbi +pm2.43d +pm2.43i +pm2.45 +pm2.46 +pm2.47 +pm2.48 +pm2.49 +pm2.5 +pm2.51 +pm2.52 +pm2.521 +pm2.521g +pm2.521g2 +pm2.53 +pm2.54 +pm2.5g +pm2.6 +pm2.61 +pm2.61d +pm2.61d1 +pm2.61d2 +pm2.61da2ne +pm2.61da3ne +pm2.61dan +pm2.61dane +pm2.61danel +pm2.61dda +pm2.61ddan +pm2.61dne +pm2.61i +pm2.61ian +pm2.61ii +pm2.61iii +pm2.61iine +pm2.61ine +pm2.61ne +pm2.61nii +pm2.62 +pm2.621 +pm2.63 +pm2.64 +pm2.65 +pm2.65d +pm2.65da +pm2.65i +pm2.65ni +pm2.67 +pm2.67-2 +pm2.68 +pm2.73 +pm2.74 +pm2.75 +pm2.76 +pm2.8 +pm2.81 +pm2.82 +pm2.83 +pm2.85 +pm2.86 +pm2.86d +pm2.86i +pm2mp +pm2mpcl +pm2mpcoe1 +pm2mpf +pm2mpf1 +pm2mpf1lem +pm2mpf1o +pm2mpfo +pm2mpfval +pm2mpghm +pm2mpghmlem1 +pm2mpghmlem2 +pm2mpgrpiso +pm2mpmhm +pm2mpmhmlem1 +pm2mpmhmlem2 +pm2mprhm +pm2mprngiso +pm2mpval +pm3.1 +pm3.11 +pm3.12 +pm3.13 +pm3.14 +pm3.2 +pm3.21 +pm3.22 +pm3.24 +pm3.2an3 +pm3.2i +pm3.2im +pm3.2ni +pm3.3 +pm3.31 +pm3.33 +pm3.34 +pm3.35 +pm3.37 +pm3.4 +pm3.41 +pm3.42 +pm3.43 +pm3.43i +pm3.44 +pm3.45 +pm3.48 +pm3.48alt +pm4.14 +pm4.15 +pm4.24 +pm4.25 +pm4.38 +pm4.39 +pm4.42 +pm4.43 +pm4.44 +pm4.45 +pm4.45im +pm4.52 +pm4.53 +pm4.54 +pm4.55 +pm4.56 +pm4.57 +pm4.61 +pm4.62 +pm4.63 +pm4.64 +pm4.65 +pm4.66 +pm4.67 +pm4.71 +pm4.71d +pm4.71da +pm4.71i +pm4.71r +pm4.71rd +pm4.71ri +pm4.72 +pm4.76 +pm4.77 +pm4.78 +pm4.79 +pm4.8 +pm4.81 +pm4.82 +pm4.83 +pm4.87 +pm5.1 +pm5.11 +pm5.11g +pm5.12 +pm5.13 +pm5.14 +pm5.15 +pm5.16 +pm5.17 +pm5.18 +pm5.19 +pm5.1im +pm5.21 +pm5.21im +pm5.21nd +pm5.21ndd +pm5.21ni +pm5.21nii +pm5.24 +pm5.3 +pm5.31 +pm5.31r +pm5.32 +pm5.32d +pm5.32da +pm5.32dav +pm5.32dra +pm5.32i +pm5.32rd +pm5.32ri +pm5.33 +pm5.35 +pm5.36 +pm5.4 +pm5.41 +pm5.42 +pm5.44 +pm5.5 +pm5.501 +pm5.53 +pm5.54 +pm5.55 +pm5.6 +pm5.61 +pm5.62 +pm5.63 +pm5.7 +pm5.71 +pm5.74 +pm5.74d +pm5.74da +pm5.74i +pm5.74rd +pm5.74ri +pm5.75 +pm54.43 +pm54.43lem +pmap0 +pmap11 +pmap1n +pmapat +pmapeq0 +pmapfval +pmapglb +pmapglb2n +pmapglb2xn +pmapglbx +pmapidcln +pmapj2n +pmapjat1 +pmapjat2 +pmapjlln1 +pmapjoin +pmaple +pmaplubn +pmapmeet +pmapocjn +pmapojoinn +pmapssat +pmapssban +pmapsub +pmapsubcln +pmapval +pmat0op +pmat0opsc +pmat1op +pmat1opsc +pmat1ovd +pmat1ovscd +pmatassa +pmatcoe1fsupp +pmatcollpw +pmatcollpw1 +pmatcollpw1lem1 +pmatcollpw1lem2 +pmatcollpw2 +pmatcollpw2lem +pmatcollpw3 +pmatcollpw3fi +pmatcollpw3fi1 +pmatcollpw3fi1lem1 +pmatcollpw3fi1lem2 +pmatcollpw3lem +pmatcollpwfi +pmatcollpwlem +pmatcollpwscmat +pmatcollpwscmatlem1 +pmatcollpwscmatlem2 +pmatlmod +pmatring +pmeasadd +pmeasmono +pmex +pmfun +pmltpc +pmltpclem1 +pmltpclem2 +pmmpric +pmod1i +pmod2in +pmodl42n +pmodlem1 +pmodlem2 +pmodn +pmpl +pmresg +pmss12g +pmsspw +pmtr3ncom +pmtr3ncomlem1 +pmtr3ncomlem2 +pmtrcnel +pmtrcnel2 +pmtrcnelor +pmtrdifel +pmtrdifellem1 +pmtrdifellem2 +pmtrdifellem3 +pmtrdifellem4 +pmtrdifwrdel +pmtrdifwrdel2 +pmtrdifwrdel2lem1 +pmtrdifwrdellem1 +pmtrdifwrdellem2 +pmtrdifwrdellem3 +pmtrf +pmtrfb +pmtrfcnv +pmtrfconj +pmtrff1o +pmtrffv +pmtrfinv +pmtrfmvdn0 +pmtrfrn +pmtrfv +pmtrfval +pmtridf1o +pmtridfv1 +pmtridfv2 +pmtrmvd +pmtrodpm +pmtrprfv +pmtrprfv2 +pmtrprfv3 +pmtrprfval +pmtrprfvalrn +pmtrrn +pmtrrn2 +pmtrsn +pmtrto1cl +pmtrval +pmvalg +pn0sr +pncan +pncan1 +pncan2 +pncan2d +pncan2s +pncan3 +pncan3d +pncan3i +pncan3oi +pncan3s +pncand +pncans +pnf0xnn0 +pnfaddmnf +pnfel0pnf +pnfex +pnfge +pnfged +pnfinf +pnfnei +pnfneige0 +pnfnemnf +pnfnlt +pnfnre +pnfnre2 +pnfxr +pnncan +pnncand +pnncani +pnonsingn +pnpcan +pnpcan2 +pnpcan2d +pnpcand +pnpncand +pnrmcld +pnrmnrm +pnrmopn +pnrmtop +pnt +pnt2 +pnt3 +pntibnd +pntibndlem1 +pntibndlem2 +pntibndlem2a +pntibndlem3 +pntlem3 +pntlema +pntlemb +pntlemc +pntlemd +pntleme +pntlemf +pntlemg +pntlemh +pntlemi +pntlemj +pntlemk +pntleml +pntlemn +pntlemo +pntlemp +pntlemq +pntlemr +pntpbnd +pntpbnd1 +pntpbnd1a +pntpbnd2 +pntrf +pntrlog2bnd +pntrlog2bndlem1 +pntrlog2bndlem2 +pntrlog2bndlem3 +pntrlog2bndlem4 +pntrlog2bndlem5 +pntrlog2bndlem6 +pntrlog2bndlem6a +pntrmax +pntrsumbnd +pntrsumbnd2 +pntrsumo1 +pntrval +pntsf +pntsval +pntsval2 +po0 +po2ne +po2nr +po3nr +pockthg +pockthi +pockthlem +pocl +pocnv +poeq1 +poeq12d +poeq2 +pofun +poimir +poimirlem1 +poimirlem10 +poimirlem11 +poimirlem12 +poimirlem13 +poimirlem14 +poimirlem15 +poimirlem16 +poimirlem17 +poimirlem18 +poimirlem19 +poimirlem2 +poimirlem20 +poimirlem21 +poimirlem22 +poimirlem23 +poimirlem24 +poimirlem25 +poimirlem26 +poimirlem27 +poimirlem28 +poimirlem29 +poimirlem3 +poimirlem30 +poimirlem31 +poimirlem32 +poimirlem4 +poimirlem5 +poimirlem6 +poimirlem7 +poimirlem8 +poimirlem9 +pointpsubn +pointsetn +pointwise_lemma +poinxp +poirr +poirr2 +pol0n +pol1n +polar_dual +polar_dual_0 +polar_dual_antimono +polar_dual_cball +polar_dual_empty +polar_dual_polar_dual +polar_dual_polar_dual_eq +polar_dual_polar_dual_gen +polar_dual_scaling +polar_dual_sing +polar_dual_union +polar_dual_unit_cball +polar_dual_univ +polatn +polcon2bn +polcon2n +polcon3n +poldmj1n +poleloe +polfvaln +polid +polid2i +polidi +polpmapn +polssatn +polsubcln +polsubn +poltletr +polval2n +polvaln +polyhedral_convex_cone +polyhedron +polyhedron_affine_hull +polyhedron_as_cone_plus_conv +polyhedron_conic_hull_polytope +polyhedron_convex_cone_hull +polyhedron_convex_cone_hull_polytope +polyhedron_convex_hull +polyhedron_empty +polyhedron_eq_finite_exposed_faces +polyhedron_eq_finite_faces +polyhedron_halfspace_ge +polyhedron_halfspace_le +polyhedron_hyperplane +polyhedron_imp_closed +polyhedron_imp_convex +polyhedron_inter +polyhedron_inter_affine +polyhedron_inter_affine_minimal +polyhedron_inter_affine_parallel +polyhedron_inter_affine_parallel_minimal +polyhedron_inter_polytope +polyhedron_inters +polyhedron_interval +polyhedron_linear_image +polyhedron_linear_image_eq +polyhedron_linear_preimage +polyhedron_minimal_lemma +polyhedron_negations +polyhedron_polytope_sums +polyhedron_positive_orthant +polyhedron_ridge_two_facets +polyhedron_sums +polyhedron_translation_eq +polyhedron_univ +polynomial +polynomial_degree +polytope_1 +polytope_aff_dim_1 +polytope_affinity +polytope_affinity_eq +polytope_convex_hull +polytope_empty +polytope_eq_bounded_polyhedron +polytope_facet_exists +polytope_facet_lower_bound +polytope_imp_bounded +polytope_imp_closed +polytope_imp_compact +polytope_imp_convex +polytope_imp_polyhedron +polytope_inter +polytope_inter_polyhedron +polytope_interval +polytope_linear_image +polytope_linear_image_eq +polytope_lowdim_imp_simplex +polytope_negations +polytope_pcross +polytope_pcross_eq +polytope_scaling +polytope_scaling_eq +polytope_segment +polytope_sing +polytope_sums +polytope_translation_eq +polytope_union_convex_hull_facets +polytope_vertex_lower_bound +poml4n +poml5n +poml6n +ponens +pop_assum +pop_assum_list +poprelb +populate +porpss +portfolio_optimization +pos_abs +posasymb +posbezout +posdif +posdifd +posdifi +posdifsd +poseq +posglbdg +posglbmo +posi +positive_ae_derivative_imp_increasing_le +positive_ae_derivative_imp_increasing_le_gen +positive_ae_derivative_imp_increasing_lt +positive_ae_derivative_imp_increasing_lt_gen +positive_ae_derivative_imp_nondecreasing +positive_definite_1 +positive_definite_1_gen +positive_definite_2 +positive_definite_2_det +positive_definite_add +positive_definite_cmul +positive_definite_cofactor +positive_definite_cofactor_eq +positive_definite_covariance +positive_definite_covariance_eq +positive_definite_covariance_eq_alt +positive_definite_diagonal_matrix +positive_definite_diagonal_matrix_eq +positive_definite_eigenvalues +positive_definite_eventually +positive_definite_id +positive_definite_imp_invertible +positive_definite_imp_positive_semidefinite +positive_definite_imp_symmetric +positive_definite_imp_symmetric_matrix +positive_definite_inv +positive_definite_mat +positive_definite_mul +positive_definite_mul_eq +positive_definite_nearby +positive_definite_positive_semidefinite +positive_definite_positive_semidefinite_add +positive_definite_similar +positive_definite_similar_eq +positive_definite_transp +positive_semidefinite_1 +positive_semidefinite_1_gen +positive_semidefinite_2 +positive_semidefinite_2_det +positive_semidefinite_add +positive_semidefinite_and_orthogonal +positive_semidefinite_antisym +positive_semidefinite_cmul +positive_semidefinite_cofactor +positive_semidefinite_covariance +positive_semidefinite_covariance_eq +positive_semidefinite_covariance_eq_alt +positive_semidefinite_covariance_unique +positive_semidefinite_diagonal_inequality +positive_semidefinite_diagonal_matrix +positive_semidefinite_diagonal_matrix_eq +positive_semidefinite_eigenvalues +positive_semidefinite_imp_symmetric +positive_semidefinite_imp_symmetric_matrix +positive_semidefinite_inv +positive_semidefinite_mat +positive_semidefinite_mul +positive_semidefinite_mul_eigenvalues +positive_semidefinite_mul_eq +positive_semidefinite_positive_definite_add +positive_semidefinite_similar +positive_semidefinite_similar_eq +positive_semidefinite_sqrt +positive_semidefinite_sqrt_eq +positive_semidefinite_sqrt_unique +positive_semidefinite_submatrix_2 +positive_semidefinite_trace_eq_0 +positive_semidefinite_transp +positive_semidefinite_zero_column +positive_semidefinite_zero_form +positive_semidefinite_zero_form_eq +positive_semidefinite_zero_row +positiveint +positiveproduct +positivesum +posjidm +poslubd +poslubdg +poslubmo +posmidm +posn +posnex +posp-fc-1 +posp-fc-2 +posp-implies-natp +posp-natp +posp-natp-l1 +posp-rw +pospo +pospropd +posprs +posqsqznn +posrasymb +posref +poss +possumd +postc +postcofcl +postcofval +postcpos +postcposalt +postr +potr +pow2_ge +pow_0 +pow_2_1_lt +pow_2_le1 +pow_2_lt +pow_2_lt_1 +pow_2_sqrt +pow_abs +pow_add +pow_eq +pow_eqns +pow_half_pos +pow_insert +pow_inv +pow_inv_eq +pow_inv_mul +pow_inv_mul_invlt +pow_inv_mul_powlt +pow_le +pow_lt +pow_minus1_odd +pow_mul +pow_no_surj +pow_nz +pow_plus1 +pow_pos +pow_pos_lt +pow_rat +pow_succ +pow_two_le +pow_zero +pow_zero_eq +power +power_correct +power_even +power_grid_dispatch +power_of_2_grows +power_of_2_positive +power_set_member +power_set_monotone +powermonotone +poweroftwo +powerset_clauses +powm2modprm +poxp +poxp2 +poxp3 +pp0ex +ppi1 +ppi1i +ppi2 +ppi2i +ppi3 +ppicl +ppidif +ppieq0 +ppif +ppifi +ppifl +ppiltx +ppinncl +ppinprm +ppip1le +ppiprm +ppisval +ppisval2 +ppiub +ppiublem1 +ppiublem2 +ppival +ppival2 +ppival2g +ppiwordi +ppncan +ppncand +pprodcnveq +pprodss4v +pptbas +ppttop +pr01ssre +pr0hash2ex +pr1eqbg +pr1nebg +pr2cv +pr2cv1 +pr2cv2 +pr2dom +pr2el1 +pr2el2 +pr2eldif1 +pr2eldif2 +pr2ne +pr2pwpr +prcdnq +prcinf +prclaxpr +prclisacycgr +prcliscplgr +prcnel +prcof1 +prcof2 +prcof21a +prcof22a +prcof2a +prcofdiag +prcofdiag1 +prcofelvv +prcoffunc +prcoffunca +prcoffunca2 +prcofpropd +prcoftposcurfuco +prcoftposcurfucoa +prcofval +prcofvala +prcofvalg +prcom +prcssprc +prct +prdom2 +prds0g +prds1 +prdsabld +prdsbas +prdsbas2 +prdsbas3 +prdsbascl +prdsbasex +prdsbasfn +prdsbaslem +prdsbasmpt +prdsbasmpt2 +prdsbasprj +prdsbl +prdsbnd +prdsbnd2 +prdscmnd +prdsco +prdscrngd +prdsds +prdsdsf +prdsdsfn +prdsdsval +prdsdsval2 +prdsdsval3 +prdsgrpd +prdsgsum +prdshom +prdsidlem +prdsinvgd +prdsinvgd2 +prdsinvlem +prdsip +prdsle +prdsless +prdsleval +prdslmodd +prdsmet +prdsmgp +prdsmndd +prdsms +prdsmslem1 +prdsmulr +prdsmulrcl +prdsmulrfval +prdsmulrngcl +prdsmulrval +prdspjmhm +prdsplusg +prdsplusgcl +prdsplusgfval +prdsplusgsgrpcl +prdsplusgval +prdsringd +prdsrngd +prdssca +prdssgrpd +prdstgpd +prdstmdd +prdstopn +prdstotbnd +prdstps +prdstset +prdsval +prdsvallem +prdsvalstr +prdsvsca +prdsvscacl +prdsvscafval +prdsvscaval +prdsxmet +prdsxmetlem +prdsxms +prdsxmslem1 +prdsxmslem2 +pre_elim_thm +pre_elim_thm_exists +pre_less_eq +pre_sub +pre_sub1 +pre_suc +pre_suc_eq +precofcl +precoffunc +precofval +precofval2 +precofval3 +precofvalalt +precofvallem +precsex +precsexlem1 +precsexlem10 +precsexlem11 +precsexlem2 +precsexlem3 +precsexlem4 +precsexlem5 +precsexlem6 +precsexlem7 +precsexlem8 +precsexlem9 +precsexlemcbv +pred0 +preddif +preddowncl +predel +predep +predeq1 +predeq123 +predeq2 +predeq3 +predexg +predfrirr +predfz +predgclnbgrel +predidm +predin +predisj +predn_diamond +predn_diamond_lemma +predn_rtcredn +prednn +prednn0 +predon +predpo +predpoirr +predprc +predpredss +predrelss +predres +predso +predss +predtrss +predun +preduz +preel +preex +prefix_bounded1 +prefix_bounded2 +prefix_def1 +prefix_def2 +preimafvelsetpreimafv +preimafvn0 +preimafvsnel +preimafvsspwdm +preimage_alt +preimage_bigunion +preimage_comp +preimage_compl +preimage_compl_inter +preimage_cross +preimage_diff +preimage_disjoint +preimage_image +preimage_inter +preimage_k +preimage_o +preimage_subset +preimage_union +preimageiingt +preimagelt +preimaicomnf +preimaiocmnf +preimaioomnf +preimalegt +preimaleiinlt +preiman0 +preimane +prel12g +preleq +preleqalt +preleqg +prelpw +prelpwi +prelrrx2 +prelrrx2b +prelspr +pren2 +pren2d +preq1 +preq12 +preq12b +preq12bg +preq12d +preq12i +preq12nebg +preq1b +preq1d +preq1i +preq2 +preq2b +preq2d +preq2i +preqr1 +preqr1g +preqr2 +preqsn +preqsnd +preservation +preservation-lemma +preservation_lemma +preserves +preserves_negligible_image +preserves_negligible_image_univ +preserves_norm_injective +preserves_norm_preserves_dot +preseves_norm_preserves_dist +press +presuc +presucmap +preuniqval +preventive_maintenance +prevents +prex +prf1 +prf1st +prf2 +prf2fval +prf2nd +prfcl +prfi +prfialt +prfval +prhash2ex +prid1 +prid1g +prid2 +prid2g +pridl +pridlc +pridlc2 +pridlc3 +pridlidl +pridln1 +pridlnr +pridlval +prime +prime_2 +prime_coprime_eq +prime_divides_product +prime_factorization +prime_imp_miller_rabin_pseudoprime +prime_imp_miller_rabin_pseudoprime_alt +prime_numbers_spec +prime_odd +prime_prod_image +prime_test +primefld +primefld0cl +primefld1cl +primefldchr +primefldgen1 +primrootlekpowne0 +primrootscoprbij +primrootscoprbij2 +primrootscoprf +primrootscoprmpow +primrootspoweq0 +primrootsunit +primrootsunit1 +principles +prinfzo0 +prjcrv0 +prjcrvfval +prjcrvval +prjspeclsp +prjsper +prjsperref +prjspersym +prjspertr +prjspner +prjspner01 +prjspner1 +prjspnerlem +prjspnfv01 +prjspnn0 +prjspnssbas +prjspnval +prjspnval2 +prjspnvs +prjsprel +prjsprellsp +prjspreln0 +prjspval +prjspval2 +prjspvs +prlem1 +prlem2 +prlem934 +prlem936 +prm23ge5 +prm23lt5 +prm2orodd +prmcyg +prmdiv +prmdivdiv +prmdiveq +prmdvdsbc +prmdvdsexp +prmdvdsexpb +prmdvdsexpr +prmdvdsfi +prmdvdsfmtnof +prmdvdsfmtnof1 +prmdvdsfmtnof1lem1 +prmdvdsfmtnof1lem2 +prmdvdsfz +prmdvdsncoprmbd +prmdvdsprmo +prmdvdsprmop +prmdvdssq +prmex +prmexpb +prmfac1 +prmgap +prmgaplcm +prmgaplcmlem1 +prmgaplcmlem2 +prmgaplem1 +prmgaplem2 +prmgaplem3 +prmgaplem4 +prmgaplem5 +prmgaplem6 +prmgaplem7 +prmgaplem8 +prmgapprmo +prmgapprmolem +prmgrpsimpgd +prmgt1 +prmidl +prmidl0 +prmidl2 +prmidlc +prmidlidl +prmidlnr +prmidlssidl +prmidlval +prmind +prmind2 +prminf +prminf2 +prmirred +prmirredlem +prmlem0 +prmlem1 +prmlem1a +prmlem2 +prmm2nn0 +prmndvdsfaclt +prmnn +prmo0 +prmo1 +prmo2 +prmo3 +prmo4 +prmo5 +prmo6 +prmocl +prmodvdslcmf +prmolefac +prmolelcmf +prmone0 +prmonn2 +prmop1 +prmorcht +prmoval +prmpwdvds +prmrec +prmreclem1 +prmreclem2 +prmreclem3 +prmreclem4 +prmreclem5 +prmreclem6 +prmrp +prmsimpcyc +prmssnn +prmunb +prmunb2 +prmuz2 +prmz +prn0 +prnc +prnebg +prneimg +prneimg2 +prneli +prneprprc +prnesn +prnmadd +prnmax +prnz +prnzg +prob01 +prob_additivity +prob_nonneg +prob_total +probaxiom +probcun +probdif +probdsb +probfinmeasb +probfinmeasbaltv +probinc +problem1 +problem2 +problem3 +problem4 +problem5 +probmeasb +probmeasd +probnul +probtot +probtotrnd +probun +probvalrnd +prod0 +prod1 +prod2id +prod_image_cong +prod_image_constant +prod_image_delete +prod_image_empty +prod_image_eq_0 +prod_image_eq_1 +prod_image_insert +prod_image_thm +prod_metric +prod_set_image_reduction +prod_set_insert +prod_set_thm +prod_type_assoc +prodeq1 +prodeq12dv +prodeq12i +prodeq12rdv +prodeq12sdv +prodeq12si +prodeq1d +prodeq1f +prodeq1i +prodeq1iold +prodeq2 +prodeq2ad +prodeq2d +prodeq2dv +prodeq2i +prodeq2ii +prodeq2sdv +prodeq2sdvold +prodeq2si +prodeq2w +prodex +prodf +prodf1 +prodf1f +prodfc +prodfclim1 +prodfdiv +prodfmul +prodfn0 +prodfrec +prodfzo03 +prodge0ld +prodge0rd +prodgt0 +prodgt02 +prodgt0i +prodindf +prodmo +prodmolem2 +prodmolem2a +prodmolem3 +prodpr +prodrb +prodrblem +prodrblem2 +prodsn +prodsnf +prodsns +prodss +prodtp +product +product_1 +product_2 +product_3 +product_4 +product_clauses +product_clauses_numseg +product_closed +product_eq +product_eq_numseg +product_mul +product_mul_numseg +product_permute +product_permute_numseg +product_pos_le_numseg +product_pos_lt_numseg +product_sing +product_sing_numseg +product_universal +progress +progress-lemma +progress_lemma +project +project_team +projf1o +proof +proof_by_cases +proof_by_contradiction +proof_identity +proof_weakening +proofs +proot1ex +proot1hash +proot1mul +prop +propeqop +proper_eq_compact_map +proper_map +proper_map_eq +proper_map_escapes +proper_map_escapes_from_image +proper_map_escapes_imp +proper_map_euclidean +proper_map_euclidean_compose +proper_map_euclidean_from_composition_left +proper_map_euclidean_from_composition_right +proper_map_from_compact +proper_map_from_compact_alt +proper_map_fstcart +proper_map_into_euclidean +proper_map_norm +proper_map_norm_simple +proper_map_sequentially +proper_map_sequentially_imp +proper_map_sequentially_rev +proper_map_sndcart +property +property_empty_interval +proposition +propositional +propositional_sat +propositions +propssopi +proththd +proththdlem +proto +protocol +prove +prove_tac +prover +proverkindinjectivity +proves +provide +proving +prpair +prprc +prprc1 +prprc2 +prprelb +prprelprb +prproe +prproropen +prproropf1o +prproropf1olem0 +prproropf1olem1 +prproropf1olem2 +prproropf1olem3 +prproropf1olem4 +prproropreud +prprrab +prprreueq +prprspr2 +prprsprreu +prprval +prprvalpw +prpssnq +prrngorngo +prsal +prsdm +prsiga +prslem +prsnex +prsprel +prsrcmpltd +prsref +prsrlem1 +prsrn +prss +prssad +prssbd +prssd +prssg +prsshashgt1 +prssi +prsspw +prsspwg +prsss +prsssdm +prssspr +prsssprel +prstcbas +prstchom +prstchom2 +prstchom2alt +prstchomval +prstcle +prstcleval +prstcnid +prstcnidlem +prstcoc +prstcocval +prstcprs +prstcthin +prstcval +prsthinc +prstr +prter1 +prter2 +prter3 +prtex +prtlem10 +prtlem100 +prtlem11 +prtlem12 +prtlem13 +prtlem14 +prtlem15 +prtlem16 +prtlem17 +prtlem18 +prtlem19 +prtlem400 +prtlem5 +prtlem60 +prtlem70 +prtlem80 +prtlem9 +prub +prunioo +prv +prv0 +prv1n +prvlem1 +prvlem2 +prwf +ps-1 +ps-2 +ps-2b +ps-2c +psasym +psd1 +psdadd +psdascl +psdcl +psdcoef +psdffval +psdfval +psdmplcl +psdmrn +psdmul +psdmullem +psdmvr +psdpw +psdval +psdvsca +psercn +psercn2 +psercn2old +psercnlem1 +psercnlem2 +pserdv +pserdv2 +pserdvlem1 +pserdvlem2 +psergf +pserulm +pserval +pserval2 +psgn0fv0 +psgnco +psgndif +psgndiflema +psgndiflemb +psgndmfi +psgndmsubg +psgneldm +psgneldm2 +psgneldm2i +psgneu +psgnevpm +psgnevpmb +psgnfieu +psgnfitr +psgnfix1 +psgnfix2 +psgnfn +psgnfval +psgnfvalfi +psgnfzto1st +psgnfzto1stlem +psgnghm +psgnghm2 +psgnid +psgninv +psgnodpm +psgnodpmr +psgnpmtr +psgnprfval +psgnprfval1 +psgnprfval2 +psgnran +psgnsn +psgnuni +psgnunilem1 +psgnunilem2 +psgnunilem3 +psgnunilem4 +psgnunilem5 +psgnval +psgnvalfi +psgnvali +psgnvalii +pslem +psmeasure +psmeasurelem +psmet0 +psmetcl +psmetdmdm +psmetf +psmetge0 +psmetlecl +psmetres2 +psmetsym +psmettri +psmettri2 +psmetutop +psmetxrge0 +pspace_pspace +psr0 +psr0cl +psr0lid +psr1 +psr1assa +psr1bas +psr1bas2 +psr1bascl +psr1basf +psr1baslem +psr1cl +psr1crng +psr1lmod +psr1mulr +psr1plusg +psr1ring +psr1sca +psr1sca2 +psr1tos +psr1val +psr1vsca +psradd +psraddcl +psraddclold +psrascl +psrasclcl +psrass1 +psrass1lem +psrass23 +psrass23l +psrassa +psrbag +psrbag0 +psrbagaddcl +psrbagcon +psrbagconcl +psrbagconf1o +psrbagev1 +psrbagev2 +psrbagf +psrbagfsupp +psrbagleadd1 +psrbaglecl +psrbaglefi +psrbaglesupp +psrbagres +psrbagsn +psrbas +psrbasfsupp +psrbaspropd +psrcom +psrcrng +psrdi +psrdir +psref +psref2 +psrel +psrelbas +psrelbasfun +psrgrp +psrlidm +psrlinv +psrlmod +psrmnd +psrmulcl +psrmulcllem +psrmulfval +psrmulr +psrmulval +psrn +psrneg +psrnegcl +psropprmul +psrplusg +psrplusgpropd +psrridm +psrring +psrsca +psrval +psrvalstr +psrvsca +psrvscacl +psrvscafval +psrvscaval +pssdif +pssdifcom1 +pssdifcom2 +pssdifn0 +psseq1 +psseq12d +psseq12i +psseq1d +psseq1i +psseq2 +psseq2d +psseq2i +pssexg +psshepw +pssinf +pssirr +psslinpr +pssn0 +pssn2lp +pssne +pssned +pssnel +pssnn +pssnssi +psspwb +psss +psssdm +psssdm2 +pssss +pssssd +psssstr +psssstrd +psstr +psstrd +pssv +pstmfval +pstmval +pstmxmet +pstr +pstr2 +psubatn +psubcli2n +psubclin +psubclinn +psubclsetn +psubclssatn +psubclsubn +psubset +psubset_alt +psubset_eqn +psubset_finite +psubset_insert_subset +psubset_irrefl +psubset_member +psubset_sing +psubset_subset_trans +psubset_trans +psubset_univ +psubspi +psubspi2n +psubspset +psubssat +pt1hmeo +ptbas +ptbasfi +ptbasid +ptbasin +ptbasin2 +ptcld +ptcldmpt +ptcls +ptclsg +ptcmp +ptcmpfi +ptcmpg +ptcmplem1 +ptcmplem2 +ptcmplem3 +ptcmplem4 +ptcmplem5 +ptcn +ptcnp +ptcnplem +ptfinfin +pth +pth_zero +pthacycspth +pthaus +pthd +pthdadjvtx +pthdepisspth +pthdifv +pthdivtx +pthdlem1 +pthdlem2 +pthdlem2lem +pthhashvtx +pthisspthorcycl +pthistrl +pthiswlk +pthonispth +pthonpth +pthontrlon +pthsfval +pthsonfval +pthsonprop +pthspthcyc +ptolemy +ptopn +ptopn2 +ptpconn +ptpjcn +ptpjopn +ptpjpre1 +ptpjpre2 +ptrecube +ptrescn +ptrest +pttop +pttopon +pttoponconst +ptuncnv +ptunhmeo +ptuni +ptuni2 +ptuniconst +ptunimpt +ptval +ptval2 +pure_once_asm_rewrite_tac +pure_once_rewrite_tac +pure_rewrite_tac +pushin_dropout +pw0 +pw2cut +pw2cut2 +pw2cutp1 +pw2divmulsd +pw2divs0d +pw2divsassd +pw2divscan2d +pw2divscan3d +pw2divscan4d +pw2divscld +pw2divsdird +pw2divsidd +pw2divsnegd +pw2divsrecd +pw2en +pw2eng +pw2f1o +pw2f1o2 +pw2f1o2val +pw2f1o2val2 +pw2f1ocnv +pw2f1olem +pw2ge0divsd +pw2gt0divsd +pw2ltdivmuls2d +pw2ltdivmulsd +pw2ltmuldivs2d +pw2ltsdiv1d +pw2m1lepw2m1 +pw2recs +pwcfsdom +pwclaxpow +pwcntmeas +pwdif +pwdju1 +pwdjudom +pwdjuen +pwdjuidm +pwdjundom +pwdom +pwel +pwelg +pwen +pweq +pweqalt +pweqb +pweqd +pweqi +pwex +pwexb +pwexd +pwexg +pwexr +pwfi +pwfi2en +pwfi2f1o +pwfilem +pwfin0 +pwfir +pwfseq +pwfseqlem1 +pwfseqlem2 +pwfseqlem3 +pwfseqlem4 +pwfseqlem4a +pwfseqlem5 +pwid +pwidb +pwidg +pwin +pwinfi +pwinfi2 +pwinfi3 +pwinfig +pwjust +pwldsys +pwm1geoser +pwmnd +pwmndgplus +pwmndid +pwne +pwne0 +pwnex +pwnss +pwp1fsum +pwpr +pwpw0 +pwpwab +pwpwpw0 +pwpwssunieq +pwpwuni +pwrssmgc +pws0g +pws1 +pwsabl +pwsal +pwsbas +pwscmn +pwsco1mhm +pwsco1rhm +pwsco2mhm +pwsco2rhm +pwscrng +pwsdiagel +pwsdiagghm +pwsdiaglmhm +pwsdiagmhm +pwsdiagrhm +pwsdompw +pwselbas +pwselbasb +pwselbasr +pwsexpg +pwsgprod +pwsgrp +pwsgsum +pwsiga +pwsinvg +pwsle +pwsleval +pwslmod +pwslnm +pwslnmlem0 +pwslnmlem1 +pwslnmlem2 +pwsmgp +pwsmnd +pwsms +pwsmulg +pwsmulrval +pwsn +pwspjmhm +pwspjmhmmgpd +pwsplusgval +pwsring +pwss +pwssb +pwssca +pwssfi +pwssnf1o +pwssplit0 +pwssplit1 +pwssplit2 +pwssplit3 +pwssplit4 +pwssub +pwssun +pwstps +pwsval +pwsvscafval +pwsvscaval +pwsxms +pwtp +pwtr +pwtrrvd +pwtrvd +pwun +pwuncl +pwundif +pwuni +pwuninel +pwuninel2 +pwunss +pwv +pwvabrel +pwvrel +pwwf +pwxpndom +pwxpndom2 +pythag +pythagoras +pythagreim +pythagtrip +pythagtriplem1 +pythagtriplem10 +pythagtriplem11 +pythagtriplem12 +pythagtriplem13 +pythagtriplem14 +pythagtriplem15 +pythagtriplem16 +pythagtriplem17 +pythagtriplem18 +pythagtriplem19 +pythagtriplem2 +pythagtriplem3 +pythagtriplem4 +pythagtriplem6 +pythagtriplem7 +pythagtriplem8 +pythagtriplem9 +pythi +pzriprng +pzriprng1 +pzriprng1alt +pzriprngalt +pzriprnglem1 +pzriprnglem10 +pzriprnglem11 +pzriprnglem12 +pzriprnglem13 +pzriprnglem14 +pzriprnglem2 +pzriprnglem3 +pzriprnglem4 +pzriprnglem5 +pzriprnglem6 +pzriprnglem7 +pzriprnglem8 +pzriprnglem9 +q1pcl +q1pdir +q1peqb +q1pval +q1pvsca +q_tac +qaa +qabbrev_tac +qabsabv +qabvexp +qabvle +qaddcl +qbtwnre +qbtwnxr +qcn +qct +qcvs +qdass +qdassr +qden1elz +qdencl +qdensere +qdensere2 +qdenval +qdivcl +qdrng +qed +qelioo +qenom +qeqnumdivden +qerclwwlknfi +qex +qexalt +qexists_tac +qexistsl_tac +qexmid +qexpcl +qexpclz +qexpz +qextle +qextlt +qextltlem +qf_ax +qf_bv +qf_lia +qf_nia +qf_nra +qf_uf +qfld +qfto +qgt0numnn +qi_spec +qid_spec_tac +qinioo +qirropth +qlax1i +qlax2i +qlax3i +qlax4i +qlax5i +qlaxr1i +qlaxr2i +qlaxr3i +qlaxr4i +qlaxr5i +qliftel +qliftel1 +qliftf +qliftfun +qliftfund +qliftfuns +qliftlem +qliftrel +qliftval +qmapeldisjs +qmapeldisjsbi +qmapeldisjsim +qmapex +qmatch_abbrev_tac +qmatch_goalsub_rename_tac +qmulcl +qmuldeneqnum +qmulz +qndenserrn +qndenserrnbl +qndenserrnbllem +qndenserrnopn +qndenserrnopnlem +qnegcl +qnnen +qnumcl +qnumdenbi +qnumdencl +qnumdencoprm +qnumgt0 +qnumval +qqh0 +qqh1 +qqhcn +qqhf +qqhghm +qqhnm +qqhre +qqhrhm +qqhucn +qqhval +qqhval2 +qqhval2lem +qqhvq +qqhvval +qqtopn +qre +qreccl +qred +qredeq +qredeu +qrevaddcl +qrng0 +qrng1 +qrngbas +qrngdiv +qrngneg +qsalrel +qsdisj +qsdisj2 +qsdisjaltv +qsdrng +qsdrngi +qsdrngilem +qsdrnglem2 +qsel +qseq +qseq1 +qseq12 +qseq12d +qseq1d +qseq1i +qseq2 +qseq2d +qseq2i +qsex +qsexg +qsfld +qshash +qsid +qsidom +qsidomlem1 +qsidomlem2 +qsinxp +qsnzr +qsort_mem +qsort_perm +qsort_sorted +qsort_stable +qsqcl +qsqueeze +qsresid +qssaa +qsscn +qssre +qsss +qsss1 +qsssubdrg +qsubcl +qsubdrg +qsxpid +qtopbas +qtopbaslem +qtopcld +qtopcmap +qtopcmp +qtopcmplem +qtopcn +qtopconn +qtopeu +qtopf1 +qtophaus +qtophmeo +qtopid +qtopkgen +qtopomap +qtoppconn +qtopres +qtoprest +qtopss +qtopt1 +qtoptop +qtoptop2 +qtoptopon +qtopuni +qtopval +qtopval2 +quad +quad1 +quad2 +quad3 +quad3d +quadratic_formula +qualifiers +quality_inspection +quantification +quantifiers +quantify_surjection_higher_thm +quantify_surjection_thm +quart +quart1 +quart1cl +quart1lem +quartfull +quartlem1 +quartlem2 +quartlem3 +quartlem4 +quasicompact_open_closed +queue_fifo +queue_ordering +queueenqueue +quicksortcorrect +quodlibet +quoremnn0 +quoremnn0alt +quoremz +quotcan +quotcl +quotcl2 +quotdgr +quotient_class +quotient_group +quotient_lift +quotient_map_closed_map_eq +quotient_map_compose_explicit +quotient_map_from_composition_explicit +quotient_map_from_subset +quotient_map_imp_continuous_closed +quotient_map_imp_continuous_open +quotient_map_open_closed +quotient_map_open_map_eq +quotient_map_restrict +quotienteq +quotientlift +quotlem +quotval +qus0 +qus0g +qus0subgadd +qus0subgbas +qus1 +qus2idrng +qusabl +qusadd +qusaddf +qusaddflem +qusaddval +qusaddvallem +qusbas +qusbas2 +quscrng +qusdimsum +quseccl +quseccl0 +qusecsub +quselbas +qusghm +qusgrp +qusgrp2 +qusima +qusin +qusinv +qusker +quslem +quslmhm +quslmod +quslsm +quslvec +qusmul2idl +qusmulcrng +qusmulf +qusmulrng +qusmulval +qusrhm +qusring +qusring2 +qusrn +qusrng +quss +qussub +qustgp +qustgphaus +qustgplem +qustgpopn +qustps +qustriv +qustrivr +qusval +qusvscpbl +qusvsval +qusxpid +qx_gen_tac +r +r0cld +r0sep +r0weon +r10 +r11 +r111 +r12 +r19.12 +r19.12sn +r19.21 +r19.21be +r19.21bi +r19.21t +r19.21v +r19.23 +r19.23t +r19.23v +r19.26 +r19.26-2 +r19.26-3 +r19.26m +r19.27v +r19.27z +r19.27zv +r19.28v +r19.28z +r19.28zf +r19.28zv +r19.29 +r19.29a +r19.29af +r19.29af2 +r19.29an +r19.29d2r +r19.29ffa +r19.29imd +r19.29r +r19.29uz +r19.29vva +r19.2uz +r19.2z +r19.2zb +r19.30 +r19.32 +r19.32v +r19.35 +r19.36v +r19.36vf +r19.36zv +r19.37 +r19.37v +r19.37zv +r19.3rz +r19.3rzf +r19.3rzv +r19.3rzvold +r19.40 +r19.41 +r19.41dv +r19.41v +r19.41vv +r19.42v +r19.43 +r19.44v +r19.44zv +r19.45v +r19.45zv +r19.9rzv +r1elcl +r1elss +r1elssi +r1elwf +r1filim +r1filimi +r1fin +r1fnon +r1funlim +r1lim +r1limg +r1limwun +r1om +r1omalt +r1omfi +r1omfv +r1omhf +r1omhfb +r1omhfbregs +r1omtsk +r1ord +r1ord2 +r1ord3 +r1ord3g +r1ordg +r1p0 +r1padd1 +r1pcl +r1pcyc +r1pdeglt +r1peuqusdeg1 +r1pid +r1pid2 +r1pid2old +r1plmhm +r1pquslmic +r1pval +r1pvsca +r1pw +r1pwalt +r1pwcl +r1pwss +r1rankcld +r1rankid +r1rankidb +r1sdom +r1sscl +r1ssel +r1sssuc +r1sssucd +r1suc +r1sucg +r1tr +r1tr2 +r1tskina +r1val1 +r1val2 +r1val3 +r1wf +r1wunlim +r2al +r2alan +r2alf +r2allem +r2ex +r2exf +r2exlem +r3al +r3ex +r_spec +ra4 +ra4v +raaan +raaan2 +raaanv +rab0 +rab2ex +rabab +rababg +rabbi +rabbi2dva +rabbia2 +rabbid +rabbida +rabbida2 +rabbida3 +rabbida4 +rabbidaold +rabbidv +rabbidva +rabbidva2 +rabbieq +rabbii +rabbiia +rabdif +rabdiophlem1 +rabdiophlem2 +rabelpw +rabeq +rabeq0 +rabeq0w +rabeq12f +rabeqbida +rabeqbidv +rabeqbidva +rabeqbidvaold +rabeqbii +rabeqc +rabeqcda +rabeqd +rabeqdv +rabeqel +rabeqf +rabeqi +rabeqsn +rabeqsnd +rabex +rabex2 +rabexd +rabexf +rabexg +rabexgf +rabexgfgs +rabexgold +rabfi +rabfmpunirn +rabfodom +rabid +rabid2 +rabid2f +rabid2im +rabidd +rabidim1 +rabidim2 +rabimbieq +rabiun +rabn0 +rabnc +rabrab +rabrabi +rabren3dioph +rabrenfdioph +rabrexfi +rabrsn +rabsn +rabsnel +rabsneq +rabsneu +rabsnif +rabsnifsb +rabsnt +rabss +rabss2 +rabss2old +rabss3d +rabssab +rabssd +rabssdv +rabssf +rabssnn0fi +rabsspr +rabssrabd +rabsssn +rabsstp +rabsubmgmd +rabswap +rabtru +rabun2 +rabxfr +rabxfrd +rabxm +rabxp +radcnv0 +radcnvcl +radcnvle +radcnvlem1 +radcnvlem2 +radcnvlem3 +radcnvlt1 +radcnvlt2 +radcnvrat +raddcn +raddswap12d +rademacher +rademacher_gen +rademacher_open +rademacher_univ +radon +radon_ex_lemma +radon_partition +radon_s_lemma +radon_v_lemma +ragcgr +ragcol +ragcom +ragflat +ragflat2 +ragflat3 +ragmir +ragncol +ragperp +ragtriva +ragtrivb +ral0 +ral2imi +ralab +ralab2 +ralabso +ralabsobidv +ralabsod +ralanid +ralbi +ralbi12f +ralbid +ralbida +ralbidar +ralbidb +ralbidc +ralbidv +ralbidv2 +ralbidva +ralbii +ralbii2 +ralbiia +ralbiim +ralbinrald +ralcom +ralcom13 +ralcom2 +ralcom3 +ralcom4 +ralcom4f +ralcomf +raldifb +raldifeq +raldifsnb +raldifsni +raldmqseu +raldmqsmo +ralel +raleleq +raleleqold +raleq +raleqbi1dv +raleqbid +raleqbidv +raleqbidva +raleqbidvv +raleqbidvvold +raleqbii +raleqd +raleqdv +raleqf +raleqi +raleqold +raleqtrdv +raleqtrrdv +ralf0 +ralfal +ralidm +ralidmw +ralim +ralima +ralimaold +ralimd4v +ralimd4vold +ralimd6v +ralimd6vold +ralimdaa +ralimdv +ralimdv2 +ralimdva +ralimdvv +ralimdvva +ralimdvvold +ralimi +ralimi2 +ralimia +ralimiaa +ralimralim +ralin +ralinexa +raliunxp +ralmo +raln +ralndv1 +ralndv2 +ralnex +ralnex2 +ralnex3 +ralnralall +ralopabb +ralpr +ralprg +ralprgf +ralrab +ralrab2 +ralralimp +ralrexbid +ralrimd +ralrimdv +ralrimdva +ralrimdvv +ralrimdvva +ralrimi +ralrimia +ralrimiv +ralrimiva +ralrimivv +ralrimivva +ralrimivvva +ralrimivw +ralrmo3 +ralrn +ralrnmo +ralrnmpo +ralrnmpt +ralrnmpt3 +ralrnmptw +ralrot3 +ralrp +ralsn +ralsng +ralsngf +ralsnsg +ralss +ralssiun +ralssold +raltp +raltpd +raltpg +ralun +ralunb +ralunsn +raluz +raluz2 +ralv +ralxfr +ralxfr2d +ralxfralt +ralxfrd +ralxfrd2 +ralxp +ralxp3 +ralxp3es +ralxp3f +ralxpes +ralxpf +ralxpmap +ralxpxfr2d +ram0 +ramcl +ramcl2 +ramcl2lem +rami +ramlb +ramsey +ramtcl +ramtcl2 +ramtlecl +ramtub +ramub +ramub1 +ramub1lem1 +ramub1lem2 +ramub2 +ramubcl +ramval +ramxrcl +ramz +ramz2 +rand_conv +ranfn +ranfval +ranged_char_nchotomy +rank0 +rank_0 +rank_bound +rank_cmul +rank_cofactor +rank_cofactor_eq_1 +rank_cofactor_eq_full +rank_diagonal_matrix +rank_dim_im +rank_eq_0 +rank_eq_full_det +rank_gram +rank_i +rank_invertible_lmul +rank_invertible_rmul +rank_matrix_inv +rank_matrix_inv_lmul +rank_matrix_inv_rmul +rank_mul_le_left +rank_mul_le_right +rank_neg +rank_nullspace +rank_row +rank_similar +rank_sylvester +rank_transp +rank_triangle +rankaltopb +rankbnd +rankbnd2 +rankc1 +rankc2 +rankcf +rankdmr1 +rankel +rankelb +rankelg +rankelop +rankelpr +rankelun +rankeq0 +rankeq0b +rankeq1o +rankf +rankfilimb +rankfilimbi +rankfu +rankid +rankidb +rankidn +ranklim +rankmapu +rankon +rankonid +rankonidlem +rankop +rankopb +rankpr +rankprb +rankpw +rankpwg +rankpwi +rankr1 +rankr1a +rankr1ag +rankr1ai +rankr1b +rankr1bg +rankr1c +rankr1clem +rankr1g +rankr1id +rankrelp +ranksn +ranksnb +ranksng +rankss +rankssb +ranksuc +rankun +rankunb +rankung +rankuni +rankuni2 +rankuni2b +rankuniss +rankval +rankval2 +rankval2b +rankval3 +rankval3b +rankval4 +rankval4b +rankvalb +rankvalg +rankvaln +rankwflem +rankwflemb +rankxpl +rankxplim +rankxplim2 +rankxplim3 +rankxpsuc +rankxpu +ranpropd +ranrcl +ranrcl2 +ranrcl3 +ranrcl4 +ranrcl4lem +ranrcl5 +ranup +ranval +ranval2 +ranval3 +rat_lemma1 +rat_lemma2 +rat_lemma3 +rat_lemma4 +rat_lemma5 +rat_lemma5_better +rational_approximation +rational_approximation_above +rational_between +rational_closed +rationaldensity +rator_conv +ray_to_frontier +ray_to_relative_frontier +rb-ax1 +rb-ax2 +rb-ax3 +rb-ax4 +rb-bijust +rb-imdf +rbac_permission +rbaib +rbaibd +rbaibr +rblem1 +rblem2 +rblem3 +rblem4 +rblem5 +rblem6 +rblem7 +rbropap +rbropapd +rbsyl +rbt_black_height +rbt_invariant +rc_char_lt +rcaninv +rclexi +rcompleq +rddif +rddif2 +rdg0 +rdg0g +rdg0n +rdgdmlim +rdgellim +rdgeq1 +rdgeq12 +rdgeq2 +rdgeqoa +rdgfnon +rdgfun +rdglem1 +rdglim +rdglim2 +rdglim2a +rdglimg +rdglimss +rdgprc +rdgprc0 +rdgseg +rdgssun +rdgsuc +rdgsucg +rdgsucmpt +rdgsucmpt2 +rdgsucmptf +rdgsucmptnf +rdgsucuni +rdgval +rdgvalg +rdiv +rdivmuldivd +re-match +re0 +re0cj +re0g +re0m0e0 +re1 +re1ax2 +re1ax2lem +re1axmp +re1luk1 +re1luk2 +re1luk3 +re1m1e0m0 +re1r +re1tbw1 +re1tbw2 +re1tbw3 +re1tbw4 +re2luk1 +re2luk2 +re2luk3 +re2ndc +reabsifneg +reabsifnneg +reabsifnpos +reabsifpos +reabssgn +readd +readdcan +readdcan2 +readdcl +readdcld +readdcli +readdcnnred +readdd +readdi +readdlid +readdrcl2d +readdrid +readdridaddlidd +readdscl +readdsub +reads +readvcot +readvrec +readvrec2 +real +real_abs_abs +real_abs_dist +real_abs_div +real_abs_hausdist +real_abs_infnorm +real_abs_inv +real_abs_le +real_abs_le0 +real_abs_mul +real_abs_neg +real_abs_nonneg +real_abs_norm +real_abs_num +real_abs_nz +real_abs_pos +real_abs_pow +real_abs_refl +real_abs_sgn +real_abs_sub +real_abs_sub_infnorm +real_abs_sub_norm +real_abs_zero +real_add2_sub2 +real_add_ac +real_add_assoc +real_add_comm +real_add_inv +real_add_ldistrib +real_add_lid +real_add_lid_uniq +real_add_linv +real_add_rat +real_add_rdistrib +real_add_rid +real_add_rid_uniq +real_add_sub +real_add_sub2 +real_add_sub_alt +real_add_sym +real_affinity_eq +real_affinity_le +real_affinity_lt +real_arch +real_arch_inv +real_arch_least +real_arch_lt +real_arch_pow +real_arch_pow2 +real_arch_pow_inv +real_arch_pow_minimal +real_arch_simple +real_archimedes +real_arith +real_arith_tac +real_bignum +real_bounds_lt +real_choose_size +real_complete +real_convex_bound_le +real_convex_bound_lt +real_diffsq +real_div_add +real_div_denom_cancel +real_div_inner_cancel +real_div_lmul +real_div_lmul_cancel +real_div_lneg +real_div_lt +real_div_lzero +real_div_mul2 +real_div_outer_cancel +real_div_prod +real_div_refl +real_div_rmul +real_div_rmul_cancel +real_div_rneg +real_div_sub +real_div_zero +real_double +real_down +real_down2 +real_entire +real_eq_affinity +real_eq_imp_le +real_eq_integers +real_eq_ldiv_eq +real_eq_lmul2 +real_eq_lmul_imp +real_eq_mul_lcancel +real_eq_mul_rcancel +real_eq_rdiv_eq +real_eq_rmul_imp +real_eq_sgn_abs +real_eq_square_abs +real_eq_sub_ladd +real_eq_sub_radd +real_euclidean_metric +real_fact_nz +real_field +real_half +real_half_between +real_half_double +real_hausdist_le +real_hausdist_le_eq +real_hausdist_le_sums +real_imp_inf_le +real_imp_le_inf +real_imp_le_sup +real_imp_lt_sup +real_imp_max_le2 +real_imp_min_le2 +real_imp_sup_le +real_inf +real_inf_close +real_inf_le +real_inf_lt +real_inf_min +real_inf_unique +real_integral +real_interval_interval +real_inv_1_le +real_inv_1over +real_inv_div +real_inv_gt1 +real_inv_inv +real_inv_le_1 +real_inv_le_antimono +real_inv_le_antimono_impl +real_inv_le_antimono_impr +real_inv_lt1 +real_inv_lt_antimono +real_inv_mul +real_inv_neg +real_inv_nonzerop +real_inv_nz +real_inv_pos +real_inv_sgn +real_invinv +real_le1_pow2 +real_le_add +real_le_add2 +real_le_addl +real_le_addr +real_le_affinity +real_le_antisym +real_le_div +real_le_double +real_le_epsilon +real_le_hausdist +real_le_inf +real_le_inf_subset +real_le_inv +real_le_inv2 +real_le_inv_eq +real_le_ladd +real_le_lcancel_imp +real_le_ldiv +real_le_ldiv_eq +real_le_lmul +real_le_lmul_eq +real_le_lmul_imp +real_le_lmul_neg +real_le_lmul_neg_imp +real_le_lsqrt +real_le_lt +real_le_max +real_le_max1 +real_le_max2 +real_le_min +real_le_mul +real_le_mul2 +real_le_mul_eq +real_le_negl +real_le_negr +real_le_negtotal +real_le_norm_matrix_mul_det +real_le_pow2 +real_le_radd +real_le_rcancel_imp +real_le_rdiv +real_le_rdiv_cancel +real_le_rdiv_eq +real_le_refl +real_le_rmul +real_le_rmul_eq +real_le_rmul_imp +real_le_rsqrt +real_le_setdist +real_le_setdist_eq +real_le_square +real_le_square_abs +real_le_sub_cancel2 +real_le_sub_ladd +real_le_sub_radd +real_le_sup +real_le_sup_finite +real_le_total +real_le_trans +real_le_trans_lt +real_le_trans_lte +real_let_add +real_let_add2 +real_let_antisym +real_let_trans +real_lin_le_max +real_linear_prover +real_linv_uniq +real_lt1_pow2 +real_lt_1 +real_lt_add +real_lt_add1 +real_lt_add2 +real_lt_add_sub +real_lt_addneg +real_lt_addneg2 +real_lt_addr +real_lt_affinity +real_lt_antisym +real_lt_div +real_lt_fraction +real_lt_fraction_0 +real_lt_half1 +real_lt_half2 +real_lt_hausdist_point_exists +real_lt_imp_le +real_lt_imp_ne +real_lt_imp_nz +real_lt_inf_finite +real_lt_inv +real_lt_inv_eq +real_lt_ladd +real_lt_lcancel_imp +real_lt_ldiv_eq +real_lt_le +real_lt_lmul +real_lt_lmul_0 +real_lt_lmul_eq +real_lt_lmul_imp +real_lt_lmul_neg +real_lt_max +real_lt_min +real_lt_mul +real_lt_mul2 +real_lt_mul_eq +real_lt_multiple +real_lt_rdiv +real_lt_rdiv_0 +real_lt_rdiv_eq +real_lt_refl +real_lt_rmul +real_lt_rmul_0 +real_lt_rmul_imp +real_lt_rneg +real_lt_square +real_lt_sub_ladd +real_lt_sub_radd +real_lt_trans +real_lte_add +real_lte_add2 +real_lte_trans +real_max_aci +real_max_add +real_max_alt +real_max_le +real_max_lt +real_max_max +real_max_min +real_max_refl +real_max_sub +real_max_sub_min +real_mean +real_middle1 +real_middle2 +real_min_aci +real_min_add +real_min_alt +real_min_le +real_min_le1 +real_min_le2 +real_min_le_lin +real_min_le_max +real_min_lt +real_min_max +real_min_refl +real_min_sub +real_mul_ac +real_mul_assoc +real_mul_comm +real_mul_inv +real_mul_lid +real_mul_linv +real_mul_lzero +real_mul_pos_lt +real_mul_rid +real_mul_rinv +real_mul_rneg +real_mul_rzero +real_mul_sign +real_mul_sub1_cancel +real_mul_sub2_cancel +real_mul_sum +real_mul_sum_numseg +real_mul_sym +real_neg_add +real_neg_eq +real_neg_half +real_neg_inv +real_neg_minus1 +real_neg_mul2 +real_neg_neg +real_neg_third +real_non_monotone +real_not_le +real_not_lt +real_nz_imp_lt +real_of_num_add +real_of_num_eq +real_of_num_le +real_of_num_lt +real_of_num_mul +real_of_num_sub +real_of_num_suc +real_poly_conv +real_polyfun_finite_roots +real_pos +real_pos_eq_zero +real_pos_id +real_pos_inflate +real_pos_le_zero +real_pos_mono +real_pos_nz +real_pos_pos +real_pow +real_pow_1_le +real_pow_add +real_pow_antimono +real_pow_antimono_lt +real_pow_div +real_pow_eq_0 +real_pow_inv +real_pow_lbound +real_pow_le +real_pow_le0 +real_pow_le_1 +real_pow_lt +real_pow_lt2 +real_pow_mono +real_pow_mono_eq +real_pow_mono_lt +real_pow_mul +real_pow_one +real_pow_pos +real_pow_pow +real_pow_zero +real_qelim_conv +real_rabinowitsch +real_rat_reduce_conv +real_ring +real_rinv_uniq +real_rsqrt_le +real_setdist_lt_exists +real_sgn +real_sgn_0 +real_sgn_abs +real_sgn_abs_alt +real_sgn_cases +real_sgn_div +real_sgn_eq +real_sgn_eq_ineq +real_sgn_ineqs +real_sgn_inv +real_sgn_mul +real_sgn_neg +real_sgn_pow +real_sgn_pow_2 +real_sgn_real_sgn +real_sgns_eq +real_sgns_eq_alt +real_sos +real_sq_nonneg +real_sub +real_sub_abs +real_sub_add +real_sub_add2 +real_sub_inv2 +real_sub_ldistrib +real_sub_le +real_sub_lneg +real_sub_lt +real_sub_lt_neg +real_sub_neg2 +real_sub_rat +real_sub_rdistrib +real_sub_refl +real_sub_rneg +real_sub_rzero +real_sub_sub +real_sub_sub2 +real_sub_triangle +real_sum_of_squares +real_sumsq +real_sup +real_sup_const +real_sup_exists +real_sup_exists_unique +real_sup_le +real_sup_le_eq +real_sup_le_finite +real_sup_le_subset +real_sup_max +real_sup_somepos +real_sup_ubound +real_sup_ubound_le +real_sup_unique +real_thirds_between +real_triangle +real_vector_ineq_prover +real_wlog_le +real_wlog_lt +realizer_bounded_search +realizer_case +realizer_choice +realizer_compose +realizer_exists +realizer_fixpoint +realizer_forall +realizer_fst +realizer_identity +realizer_induction +realizer_inl +realizer_inr +realizer_list_rec +realizer_minimization +realizer_nat_rec +realizer_pair +realizer_snd +rearchi +rearrange +reasinsin +rebase +rebtwnz +rec-concat +rec11 +rec11d +rec11i +rec11ii +rec11r +rec_concat +rec_lookup +rec_update +recall_witnessed +recan +recbothd +reccl +reccld +reccli +recclnq +recclzi +reccn2 +reccot +reccsc +recdiv +recdiv2 +recdiv2d +recdivd +receqid +receu +recex +recexpr +recexsr +recexsrlem +recextlem1 +recextlem2 +recgt0 +recgt0d +recgt0i +recgt0ii +recgt1 +recgt1d +recgt1i +recid +recid2 +recid2d +recidd +recidi +recidnq +recidzi +recj +recjd +recji +recl +recld +recld2 +reclem2pr +reclem3pr +reclem4pr +recli +reclimc +reclt0 +reclt0d +reclt1 +reclt1d +recmet +recms +recmulnq +recn +recn2 +recncf +recnd +recne0 +recne0d +recne0zi +recni +recnmulnred +recnnltrp +recnperf +recnprss +recnz +reconn +reconnlem1 +reconnlem2 +reconsider +record +record_eq_fields +record_get_set_idempotent +record_set_comm +record_set_get +recos4p +recoscl +recoscld +recosf1o +recoshcl +recosval +recotcl +recp1lt1 +recrec +recrecd +recreci +recreclt +recrecnq +recsccl +recsec +recseq +recsex +recsexd +recsfnon +recsfval +recsne0 +recsval +rectan +rectbntr0 +rectifiable_path_combine +rectifiable_path_differentiable +rectifiable_path_eq +rectifiable_path_image_subset_cball +rectifiable_path_imp_path +rectifiable_path_join +rectifiable_path_join_eq +rectifiable_path_join_imp +rectifiable_path_linear_image_eq +rectifiable_path_linepath +rectifiable_path_lipschitz_image +rectifiable_path_reparametrization +rectifiable_path_reversepath +rectifiable_path_shiftpath +rectifiable_path_subpath +rectifiable_path_subpath_eq +rectifiable_path_sym +rectifiable_path_translation_eq +recursion_theorem +recusp +recut +recval +recvs +recxpcl +recxpcld +recxpf1lem +redepth_conv +rediv +redivcan2d +redivcan3d +redivcl +redivcld +redivcli +redivclzi +redivd +rediveud +redivmuld +redivvald +reds +reduc +reduction +redundeq1 +redundpbi1 +redundpim3 +redundss3 +redvmptabs +redvr +redwlk +redwlklem +reean +reeanlem +reeanv +reef11 +reefcl +reefcld +reeff1 +reeff1o +reeff1olem +reefgim +reefiso +reeflog +reeflogd +reeftcl +reeftlcl +reelprrecn +reelznn0nn +reex +reexalt +reexpcl +reexpcld +reexpclz +reexpclzd +reexplog +ref +ref5 +ref_spec +refallfaccl +refbas +refdivmptf +refdivmptfv +refdivpm +reff +refimssco +refinement_subtyping +refines_antisym +refines_grows_parts +refines_transitive +refl +refl_closure +refl_tac +reflcl +refld +refldcj +refldivcl +reflect_along_0 +reflect_along_1d +reflect_along_add +reflect_along_basis +reflect_along_basis_component +reflect_along_eq +reflect_along_eq_0 +reflect_along_eq_self +reflect_along_galois +reflect_along_involution +reflect_along_linear_image +reflect_along_mul +reflect_along_neg +reflect_along_negation +reflect_along_refl +reflect_along_scale +reflect_along_surjective +reflect_along_switch +reflect_along_zero +reflect_basis_along_basis +reflect_interval +reflect_univ +reflexg +reflexive_frame +reflexivity +refref +refrel +refrelcoss +refrelcoss2 +refrelcoss3 +refrelcosslem +refreleq +refrelid +refrelredund2 +refrelredund3 +refrelredund4 +refrelressn +refrelsredund2 +refrelsredund3 +refrelsredund4 +refressn +refssex +refssfne +refsum2cn +refsum2cnlem1 +refsumcn +refsymrel2 +refsymrel3 +refsymrels2 +refsymrels3 +reftr +refun0 +regamcl +rege0subm +rege1logbrege0 +rege1logbzge0 +regex +regex_match +reghaus +reghmph +region +region_contains +regions +reglog1 +reglogbas +reglogcl +reglogexp +reglogexpbas +reglogleb +reglogltb +reglogmul +regr1 +regr1lem +regr1lem2 +regsep +regsep2 +regsfromregtr +regsfromsetind +regsfromunir1 +regsumfsum +regsumsupp +regt1loggt0 +regtop +regular_closed +regular_closed_in +regular_closed_union +regular_closed_unions +regular_closed_unions_fat_cells_univ +regular_closure_imp_thin_frontier +regular_closure_interior +regular_closure_of_interior_of +regular_interior_closure +regular_interior_imp_thin_frontier +regular_interior_of_closure_of +regular_open +regular_open_in +regular_open_inter +regular_polytope_dist_barycentre +regular_polytope_exists +regular_polytope_with_barycentre_exists +regular_polytope_with_barycentre_exists_alt +regular_space_euclidean +regular_space_mtopology +regular_space_subtopology +rehalfcl +rehalfcld +rehalfcli +rehalfge1 +rehaus +reheibor +rei +rei4 +reim +reim0 +reim0b +reim0bd +reim0bi +reim0d +reipcl +reixi +rel0 +rel_prime_div_prod +rel_prime_inverse +rel_prime_lem +rel_prime_mult_left +rel_prime_mult_right +rel_prime_sym +rel_restrict_subset +reladdrsub +relae +relative_boundary_of_convex_hull +relative_boundary_of_polyhedron +relative_boundary_of_triangle +relative_boundary_point_in_exposed_face +relative_boundary_point_in_proper_face +relative_frontier_ball +relative_frontier_cball +relative_frontier_closure +relative_frontier_conic_hull +relative_frontier_convex_hull_explicit +relative_frontier_empty +relative_frontier_eq_empty +relative_frontier_facial_partition +relative_frontier_facial_partition_alt +relative_frontier_frontier +relative_frontier_frontier_of +relative_frontier_injective_linear_image +relative_frontier_nonempty_interior +relative_frontier_not_sing +relative_frontier_of_convex_closed +relative_frontier_of_convex_hull +relative_frontier_of_polyhedron +relative_frontier_of_polyhedron_alt +relative_frontier_of_triangle +relative_frontier_open +relative_frontier_relative_interior +relative_frontier_sing +relative_frontier_subset +relative_frontier_subset_eq +relative_frontier_subset_frontier +relative_frontier_translation +relative_interior +relative_interior_affine +relative_interior_ball +relative_interior_cball +relative_interior_cball_inter_affine +relative_interior_closure_subset +relative_interior_conic_hull +relative_interior_conic_hull_0 +relative_interior_convex_contains_same_ray +relative_interior_convex_hull_explicit +relative_interior_convex_inter_affine +relative_interior_convex_inter_open +relative_interior_convex_prolong +relative_interior_empty +relative_interior_eq +relative_interior_eq_closure +relative_interior_eq_empty +relative_interior_injective_linear_image +relative_interior_inter +relative_interior_interior +relative_interior_interior_of +relative_interior_linear_image_convex +relative_interior_linear_preimage_convex +relative_interior_maximal +relative_interior_nonempty_interior +relative_interior_of_polyhedron +relative_interior_open +relative_interior_open_in +relative_interior_pcross +relative_interior_polyhedron_explicit +relative_interior_prolong +relative_interior_relative_interior +relative_interior_segment +relative_interior_sing +relative_interior_subset +relative_interior_subset_of_proper_face +relative_interior_sums +relative_interior_translation +relative_interior_unbounded_convex_contains_ray +relative_interior_unbounded_convex_contains_rays +relative_interior_unique +relative_interior_univ +relative_to_subset +relative_to_univ +relbigcup +relbrcnv +relbrcnvg +relbrcoss +relbrtpos +relcic +relcmd +relcmpcmet +relcnv +relcnveq +relcnveq2 +relcnveq3 +relcnveq4 +relcnvexb +relcnvfld +relcnvtr +relcnvtrg +relco +relcoels +relcoi1 +relcoi2 +relcoss +reldif +reldir +reldisj +reldisjun +reldm +reldm0 +reldmcmd +reldmcmd2 +reldmdprd +reldmdsmm +reldmevls +reldmevls1 +reldmfunc +reldmghm +reldmlan +reldmlan2 +reldmlmd +reldmlmd2 +reldmlmhm +reldmmap +reldmmdeg +reldmmhp +reldmmpl +reldmmpo +reldmnghm +reldmnmhm +reldmoppf +reldmoprab +reldmopsr +reldmprcof +reldmprcof1 +reldmprcof2 +reldmprds +reldmpsr +reldmran +reldmran2 +reldmrelexp +reldmress +reldmresv +reldmrloc +reldmsets +reldmtng +reldmtpos +reldmup +reldmup2 +reldmxpc +reldmxpcalt +reldom +reldv +reldvds +reldvdsr +rele +rele2 +releabs +releabsd +releabsi +releccnveq +relecxrn +releldm +releldm2 +releldmb +releldmdifi +releldmi +releldmqs +releldmqscoss +relelec +releleccnv +relelrn +relelrnb +relelrni +relen +releq +releqd +releqg +releqi +releupth +relexp0 +relexp01min +relexp0a +relexp0d +relexp0eq +relexp0g +relexp0idm +relexp0rel +relexp1d +relexp1g +relexp1idm +relexp2 +relexpaddd +relexpaddg +relexpaddnn +relexpaddss +relexpcnv +relexpcnvd +relexpdm +relexpdmd +relexpdmg +relexpempty +relexpfld +relexpfldd +relexpiidm +relexpind +relexpindlem +relexpmulg +relexpmulnn +relexpnndm +relexpnnrn +relexpnul +relexprel +relexpreld +relexprelg +relexprn +relexprnd +relexprng +relexpss1d +relexpsucl +relexpsucld +relexpsucnnl +relexpsucnnr +relexpsucr +relexpsucrd +relexpuzrel +relexpxpmin +relexpxpnnidm +relfae +relfi +relfld +relfldext +relfsupp +relfth +relfull +relfunc +relgamcl +reli +reliin +relimasn +relin01 +relin1 +relin2 +relint +relintab +relintabex +relinxp +reliun +rellan +rellindf +rellininds +rellmd +rellycmp +rellysconn +relmntop +relmpoopab +relmptopab +relnonrel +relog +relogbcl +relogbcld +relogbcxp +relogbcxpb +relogbdiv +relogbdivb +relogbexp +relogbexpd +relogbf +relogbmul +relogbmulbexp +relogbmulexp +relogbreexp +relogbval +relogbzcl +relogbzexp +relogbzexpd +relogcl +relogcld +relogcn +relogdiv +relogdivd +relogef +relogefd +relogeftb +relogexp +relogf1o +reloggim +relogiso +relogmul +relogmuld +relogoprlem +relogrn +relop +relopab +relopabi +relopabialt +relopabiv +relopabv +relopabvd +reloprab +relowlpssretop +relowlssretop +relpeq1 +relpeq2 +relpeq3 +relpeq4 +relpeq5 +relpf +relpfr +relpfrlem +relpmin +relprcnfsupp +relprel +relpths +relqmap +relran +relrelss +relres +relresdm1 +relresfld +relrn0 +relrngo +relrpss +relsdom +relsn +relsn2 +relsnb +relsng +relsnop +relsnopg +relss +relssdmrn +relssdv +relsset +relssi +relssinxpdmrn +relssr +relssres +relsubgr +relsucmap +relt +relt0neg1 +relt0neg2 +reltm1 +reltpos +reltrclfv +reltre +reltrls +reltsub1 +reltsubadd2 +relttrcl +reltxrnmnf +relu_nonneg +relun +reluni +relup +relwdom +relwf +relwlk +relxp +relxpchom +rembl +remet +remetdval +remexz +remim +remimd +remove_then +remsqsqrt +remul +remul01 +remul02 +remul2 +remul2d +remulcan2d +remulcand +remulcl +remulcld +remulcli +remuld +remulg +remuli +remulinvcom +remullem +remullid +remulneg2d +remulr +remulscl +remulscllem1 +remulscllem2 +ren0 +rename_tac +rencldnfi +rencldnfilem +reneg +reneg0addlid +reneg1lt0 +renegadd +renegcl +renegclalt +renegcld +renegcli +renegd +renegeu +renegeulem +renegeulemv +renegi +renegid +renegid2 +renegmulnnass +renegneg +renegscl +renemnf +renemnfd +renepnf +renepnfd +renfdisj +renicax +rennim +rennncan2 +reno +renod +renpncan3 +reofld +reopn +reordt +reorelicc +reparpht +reparphti +reparphtiold +repeat +repeat_tcl +repeathead +reperf +reperflem +replaceeq +replay_protection +replicate_tac +replicate_zero +replim +replimd +replimi +replusg +repncan2 +repncan3 +repnpcan +repos +reposdif +reppncan +repr0 +reprdifc +reprf +reprfi +reprfi2 +reprfz1 +reprgt +reprinfz1 +reprinrn +reprle +reprlt +reprpmtf1o +reprss +reprsuc +reprsum +reprval +reprvalid +reps +repsco +repsconst +repsdf2 +repsf +repsundef +repsw +repsw0 +repsw1 +repsw2 +repsw3 +repswccat +repswcshw +repswfsts +repswlen +repswlsw +repswpfx +repswrevw +repswswrd +repswsymb +repswsymball +repswsymballbi +repwsmet +reqabi +requad01 +requad1 +requad2 +requires +rere +rereb +rerebd +rerebi +rereccl +rereccld +rereccli +rerecclzi +rerecid +rerecid2 +rered +rerest +rerisefaccl +rernegcl +rerpdivcl +rerpdivcld +rerrext +rersubcl +res0 +res_tac +resabs1 +resabs1d +resabs1i +resabs2 +resabs2d +resabs2i +resasplit +rescabs +rescabs2 +rescbas +resccat +resccatlem +rescco +rescfth +reschom +reschomf +resclunitintvd +rescncf +rescnvcnv +rescnvimafod +resco +rescofuf +rescom +resconn +rescval +rescval2 +resdif +resdifcom +resdifdi +resdifdir +resdisj +resdm +resdm2 +resdmdfsn +resdmres +resdmss +resdomq +resdvopclptsd +reseccl +reseq1 +reseq12d +reseq12i +reseq1d +reseq1i +reseq2 +reseq2d +reseq2i +resex +resexd +resexg +resf1ext2b +resf1extb +resf1o +resf1st +resf2nd +resfifsupp +resfnfinfin +resfsupp +resfunexg +resfunexgalt +resfval +resfval2 +resfvresima +resghm +resghm2 +resghm2b +resgrpisgrp +resgrpplusfrn +residfi +residm +residpr +resieq +resiexd +resiexg +resiima +resima +resima2 +resimass +resin +resin4p +resincl +resincld +resincncf +resindi +resindir +resindm +resinf1o +resinhcl +resinsn +resinsnalt +resinsnlem +resinval +resipos +resiposbas +resisoeq45d +resiun1 +resiun2 +resixp +resixpfo +reslmhm +reslmhm2 +reslmhm2b +resmgmhm +resmgmhm2 +resmgmhm2b +resmhm +resmhm2 +resmhm2b +resmndismnd +resmpo +resmpt +resmpt3 +resmptd +resmptf +resmpti +resnonrel +resolution +resolution_complete +resolution_completeness +resolution_sound +resolution_soundness +resopab +resopab2 +resoprab +resoprab2 +resopunitintvd +resource_constrained_project +respreima +resqcl +resqcld +resqcli +resqreu +resqrex +resqrtcl +resqrtcld +resqrtcn +resqrtth +resqrtthlem +resqrtval +resqrtvalex +resres +resresdm +resrhm +resrhm2b +resrng +ress0 +ress0g +ress1r +ressabs +ressascl +ressasclcl +ressatans +ressbas +ressbas2 +ressbasss +ressbasss2 +ressbasssg +ressbasssold +resscat +resscatc +resscdrg +resscntz +ressco +ressdeg1 +ressds +resseqnbas +ressffth +resshom +ressid +ressid2 +ressinbas +ressiocsup +ressiooinf +ressioosup +ressip +ressle +ressmpladd +ressmplbas +ressmplbas2 +ressmplmul +ressmplvsca +ressms +ressmulgnn +ressmulgnn0 +ressmulgnn0d +ressmulgnnd +ressmulr +ressn +ressn2 +ressnm +ressnop0 +ressplusf +ressplusg +ressply10g +ressply1add +ressply1bas +ressply1bas2 +ressply1evl +ressply1evls1 +ressply1invg +ressply1mon1p +ressply1mul +ressply1sub +ressply1vsca +resspos +ressprdsds +ressprs +resspsradd +resspsrbas +resspsrmul +resspsrvsca +resspwsds +ressress +resss +resssca +resssetc +resssra +ressstarv +resssxp +resstopn +resstos +resstps +resstset +ressucdifsn +ressucdifsn2 +ressunif +ressuppfi +ressupprn +ressuppss +ressuppssdif +ressusp +ressuss +ressust +ressval +ressval2 +ressval3d +ressvsca +ressxms +ressxr +rest0 +rest_psubset +rest_subset +restabs +restbas +restcld +restcldi +restcldr +restcls +restcls2 +restcls2lem +restclssep +restclsseplem +restcnrm +restco +restdis +restfn +restfpw +resthaus +resthauslem +restid +restid2 +restidsing +restin +restlly +restlp +restmetu +restnlly +restntr +restopn2 +restopn3 +restopnb +restopnssd +restperf +restrcl +restriction +restriction_compose +restriction_compose_left +restriction_compose_right +restriction_continuous_on +restriction_extension +restriction_fixpoint +restriction_has_derivative +restriction_idemp +restriction_in_extensional +restriction_restriction +restriction_unique +restriction_unique_alt +restrreld +restsn +restsn2 +restsspw +restsubel +restt0 +restt1 +resttop +resttopon +resttopon2 +restuni +restuni2 +restuni3 +restuni4 +restuni5 +restuni6 +restutop +restutopopn +restval +resub +resubadd +resubaddd +resubcan2 +resubcl +resubcld +resubcli +resubcnnred +resubd +resubdi +resubdrg +resubeqsub +resubeu +resubeulem1 +resubeulem2 +resubf +resubgval +resubid +resubid1 +resubidaddlid +resubidaddlidlem +resubmet +resubsub4 +resubval +result +resum2sqcl +resum2sqgt0 +resum2sqorgt0 +resum2sqrp +resundi +resundir +resunimafz0 +resup +resuppsinopn +resv0g +resv1r +resvbas +resvcmn +resvid2 +resvlem +resvmulr +resvplusg +resvsca +resvval +resvval2 +resvvsca +retancl +retancld +retanhcl +retbwax1 +retbwax2 +retbwax3 +retbwax4 +retire +retop +retopbas +retopconn +retopn +retopon +retopsconn +retos +retps +retry_idempotent +reu0 +reu2 +reu2eqd +reu3 +reu3op +reu4 +reu5 +reu6 +reu6dv +reu6i +reu7 +reu8 +reu8nf +reuabaiotaiota +reuaiotaiota +reuan +reuanid +reubida +reubidv +reubidva +reubii +reubiia +reuccatpfxs1 +reuccatpfxs1lem +reuccatpfxs1v +reuen1 +reueq +reueq1 +reueq1f +reueq1old +reueqbidv +reueqbidva +reueqbii +reueqd +reueqdv +reueqi +reueubd +reuf1od +reuf1odnf +reuhyp +reuhypd +reuimrmo +reuind +reumodprminv +reuop +reuopreuprim +reupick +reupick2 +reupick3 +reupr +reuprg +reuprg0 +reuprpr +reurab +reurex +reurexprg +reurmo +reusn +reusng +reusngf +reusq0 +reuss +reuss2 +reust +reusv1 +reusv2 +reusv2lem1 +reusv2lem2 +reusv2lem3 +reusv2lem4 +reusv2lem5 +reusv3 +reusv3i +reutru +reutrualt +reuun1 +reuun2 +reuv +reuxfr +reuxfr1 +reuxfr1d +reuxfr1dd +reuxfr1ds +reuxfrd +reuxfrdf +rev +rev-of-append +rev-of-cons +rev-of-list-fix +rev-of-rev +rev-under-iff +rev-when-not-consp +rev0 +rev_app_distr +rev_full_simp_tac +rev_involutive +rev_merge_rev_spec +rev_rev +rev_reverse_lem +reval +revappend-removal +revappend-revappend +revccat +revcl +revco +reverse +reverse-removal +reverse-reverse +reverse_append +reverse_genlist +reverse_length +reverse_linear_image +reverse_nil +reverse_o_reverse +reverse_rev +reverse_reverse +reverse_singleton +reverse_snoc +reverse_snoc_def +reverse_translation +reverseappend +reverseinplace +reversepath_reversepath +reversepath_subpath +revfv +revlen +revpfxsfxrev +revrev +revs1 +revval +revwlk +revwlkb +rewrite +rewrite_conv +rewrite_rule +rewrite_tac +rex0 +rex2dom +rexab +rexab2 +rexabsle +rexabsle2 +rexabslelem +rexabso +rexabsobidv +rexabsod +rexadd +rexaddd +rexanali +rexanid +rexanre +rexanuz +rexanuz2 +rexanuz2nf +rexanuz3 +rexbi +rexbid +rexbida +rexbidar +rexbidv +rexbidv2 +rexbidva +rexbidvaalt +rexbidvalt +rexbii +rexbii2 +rexbiia +rexcom +rexcom13 +rexcom4 +rexcom4a +rexcom4b +rexcom4f +rexcomf +rexdif1en +rexdifi +rexdifpr +rexdifsn +rexdiv +rexeq +rexeqbi1dv +rexeqbid +rexeqbidv +rexeqbidva +rexeqbidvv +rexeqbidvvold +rexeqbii +rexeqdv +rexeqf +rexeqfold +rexeqi +rexeqif +rexeqold +rexeqtrdv +rexeqtrrdv +rexex +rexfiuz +rexfrabdioph +rexico +rexim +rexima +reximaold +reximd2a +reximdai +reximdd +reximddv +reximddv2 +reximddv3 +reximdv +reximdv2 +reximdva +reximdva0 +reximdvai +reximdvva +reximi +reximi2 +reximia +reximssdv +rexin +rexiunxp +rexlim2d +rexlimd +rexlimd2 +rexlimd3 +rexlimddv +rexlimddv2 +rexlimddvcbv +rexlimddvcbvw +rexlimdv +rexlimdv3a +rexlimdv3d +rexlimdva +rexlimdva2 +rexlimdvaa +rexlimdvaacbv +rexlimdvv +rexlimdvva +rexlimdvvva +rexlimdvw +rexlimi +rexlimiv +rexlimiva +rexlimivv +rexlimivw +rexmet +rexmul +rexmul2 +rexn0 +rexnal +rexnal2 +rexnal3 +rexneg +rexnegd +rexopabb +rexor +rexpen +rexpr +rexprg +rexprgf +rexpssxrxp +rexr +rexrab +rexrab2 +rexrabdioph +rexralbidv +rexraleqim +rexrd +rexreusng +rexri +rexrn +rexrnmpo +rexrnmpt +rexrnmptw +rexrot4 +rexrp +rexrsb +rexsb +rexsn +rexsng +rexsngf +rexsns +rexss +rexssold +rexsub +rexsupp +rext +rext0 +rextp +rextpg +rextru +rexun +rexunirn +rexuz +rexuz2 +rexuz3 +rexuzre +rexv +rexxfr +rexxfr2d +rexxfr3d +rexxfr3dalt +rexxfrd +rexxfrd2 +rexxp +rexxpf +rexzrexnn0 +rezh +rfcnnnub +rfcnpre1 +rfcnpre2 +rfcnpre3 +rfcnpre4 +rfovcnvd +rfovcnvf1od +rfovcnvfvd +rfovd +rfovf1od +rfovfvd +rfovfvfvd +rge0scvg +rge0srg +rge0ssre +rgen +rgen2 +rgen2a +rgen2w +rgen3 +rgenw +rglcom4d +rgmoddimold +rgrprc +rgrprcx +rgrprop +rgrusgrprc +rgrx0nd +rgrx0ndm +rgspncl +rgspnid +rgspnmin +rgspnssid +rgspnval +rhm1 +rhmco +rhmcomulmpl +rhmcomulpsr +rhmdvd +rhmdvdsr +rhmeql +rhmf +rhmf1o +rhmfn +rhmghm +rhmima +rhmimaidl +rhmimasubrng +rhmimasubrnglem +rhmisrnghm +rhmmhm +rhmmpl +rhmmul +rhmopp +rhmply1 +rhmply1mon +rhmply1vr1 +rhmply1vsca +rhmpreimacn +rhmpreimacnlem +rhmpreimaidl +rhmpreimaprmidl +rhmpropd +rhmpsr +rhmpsr1 +rhmpsrlem1 +rhmpsrlem2 +rhmqusker +rhmquskerlem +rhmqusnsg +rhmqusspan +rhmrcl1 +rhmrcl2 +rhmresel +rhmresfn +rhmsscmap +rhmsscmap2 +rhmsscrnghm +rhmsubc +rhmsubcaltv +rhmsubcaltvcat +rhmsubcaltvlem1 +rhmsubcaltvlem2 +rhmsubcaltvlem3 +rhmsubcaltvlem4 +rhmsubccat +rhmsubclem1 +rhmsubclem2 +rhmsubclem3 +rhmsubclem4 +rhmsubcrngc +rhmsubcrngclem1 +rhmsubcrngclem2 +rhmsubcsetc +rhmsubcsetclem1 +rhmsubcsetclem2 +rhmunitinv +rhmval +rhmzrhval +riccrng +riccrng1 +ricdrng +ricdrng1 +rice_theorem +ricfld +ricgic +ricqusker +ricsym +rictr +ridl0 +ridl1 +rie_sum_alt_lem +riesz1 +riesz2 +riesz3i +riesz4 +riesz4i +right +right-cancellation-for-+ +right-identity-of-+ +right0s +right1s +right_add_distrib +right_and_exists_thm +right_and_forall_thm +right_distrib +right_exists_and_thm +right_exists_imp_thm +right_forall_imp_thm +right_imp_exists_thm +right_imp_forall_thm +right_inverse_linear +right_invertible_transp +right_limit_alt +right_limit_within_alt +right_or_distrib +right_polar_decomposition +right_polar_decomposition_invertible +right_polar_decomposition_invertible_unique +right_polar_decomposition_unique +right_sub_distrib +rightf +rightge0 +rightgt +rightirr +rightno +rightnod +rightold +rightoldd +rightsappend +rightssno +rightssold +rightval +rigid_transformation_between_2 +rigid_transformation_between_3 +rigid_transformation_between_congruent_sets +rigid_transformation_between_congruent_sets_strong +riin0 +riincld +riiner +riinint +riinn0 +riinopn +riinrab +rimcnv +rimco +rimf1o +rimgim +rimisrngim +rimrcl +rimrcl1 +rimrcl2 +rimrhm +rimul +ring +ring0cl +ring1 +ring1eq0 +ring1ne0 +ring1nzdiv +ring1zr +ring2idlqus +ring2idlqus1 +ring2idlqusb +ring_add_comm +ring_add_group +ring_buffer_pop +ring_buffer_push +ring_distrib +ring_distrib_left +ring_mul_assoc +ring_zero_mul +ringabl +ringabld +ringacl +ringadd2 +ringass +ringassd +ringaxiom +ringcbas +ringcbasaltv +ringcbasbas +ringcbasbasaltv +ringccat +ringccataltv +ringccatidaltv +ringcco +ringccoaltv +ringccofval +ringccofvalaltv +ringchom +ringchomaltv +ringchomfeqhom +ringchomfval +ringchomfvalaltv +ringcid +ringcidaltv +ringcinv +ringcinvaltv +ringciso +ringcisoaltv +ringcl +ringcld +ringcmn +ringcmnd +ringcom +ringcomlem +ringcsect +ringcsectaltv +ringcval +ringcvalaltv +ringdi +ringdi22 +ringdid +ringdilem +ringdir +ringdird +ringelnzr +ringen1zr +ringexp0nn +ringgrp +ringgrpd +ringid +ringidcl +ringidcld +ringideu +ringidmlem +ringidss +ringidval +ringinvcl +ringinvdv +ringinveu +ringinvnz1ne0 +ringinvnzdiv +ringinvval +ringlghm +ringlidm +ringlidmd +ringlsmss +ringlsmss1 +ringlsmss2 +ringlz +ringlzd +ringm1expp1 +ringm2neg +ringmgm +ringmgp +ringmnd +ringmneg1 +ringmneg2 +ringn0 +ringnegl +ringnegr +ringo2times +ringprop +ringpropd +ringrghm +ringridm +ringridmd +ringrng +ringrngd +ringrz +ringrzd +ringsrg +ringssrng +ringsubdi +ringsubdir +ringunitnzdiv +ringurd +ringvcl +rint0 +rintn0 +rintopn +rinv_def +rinvf1o +rinvmod +riota1 +riota1a +riota2 +riota2df +riota2f +riota5 +riota5f +riotabidv +riotabidva +riotabiia +riotacl +riotacl2 +riotaclb +riotaclbbad +riotaclbgbad +riotaeqbidv +riotaeqbidva +riotaeqbii +riotaeqdv +riotaeqi +riotaeqimp +riotaex +riotaneg +riotaocn +riotaprop +riotarab +riotasbc +riotass +riotass2 +riotassuni +riotasv +riotasv2d +riotasv2s +riotasv3d +riotasvd +riotaund +riotauni +riotav +riotaxfrd +risc +riscer +risci +risefac0 +risefac1 +risefaccl +risefaccllem +risefacfac +risefacp1 +risefacp1d +risefacval +risefacval2 +risefall0lem +risefallfac +risk_monotone +risset +rlim +rlim0 +rlim0lt +rlim2 +rlim2lt +rlim3 +rlimabs +rlimadd +rlimcj +rlimcl +rlimcld2 +rlimclim +rlimclim1 +rlimcn1 +rlimcn1b +rlimcn2 +rlimcn3 +rlimcnp +rlimcnp2 +rlimcnp3 +rlimconst +rlimcxp +rlimdiv +rlimdm +rlimdmafv +rlimdmafv2 +rlimdmo1 +rlimeq +rlimf +rlimge0 +rlimi +rlimi2 +rlimim +rlimle +rlimmptrcl +rlimmul +rlimneg +rlimno1 +rlimo1 +rlimpm +rlimre +rlimrecl +rlimrege0 +rlimrel +rlimres +rlimres2 +rlimresb +rlimsqz +rlimsqz2 +rlimsqzlem +rlimss +rlimsub +rlimuni +rlm0 +rlmassa +rlmbas +rlmbn +rlmdim +rlmds +rlmfn +rlmlmod +rlmlsm +rlmlvec +rlmmulr +rlmnlm +rlmnm +rlmnvc +rlmplusg +rlmsca +rlmsca2 +rlmscaf +rlmsub +rlmtopn +rlmval +rlmval2 +rlmvneg +rlmvsca +rloc0g +rloc1r +rlocaddval +rlocbas +rloccring +rlocf1 +rlocmulval +rlocval +rm_all_abbrevs_tac +rmbaserp +rmfsupp +rmfsupp2 +rmo0 +rmo2 +rmo2i +rmo3 +rmo3f +rmo4 +rmo4f +rmo5 +rmoan +rmoanid +rmoanim +rmoanimalt +rmob +rmob2 +rmobida +rmobidv +rmobidva +rmobii +rmobiia +rmodislmod +rmodislmodlem +rmoeq +rmoeq1 +rmoeq1f +rmoeq1old +rmoeqbidv +rmoeqbii +rmoeqd +rmoeqdv +rmoeqi +rmoi +rmoi2 +rmoim +rmoimi +rmoimi2 +rmoimia +rmorabex +rmosn +rmotru +rmoun +rmounid +rmov +rmoxfrd +rmspecfund +rmspecnonsq +rmspecpos +rmspecsqrtnq +rmsupp0 +rmsuppfi +rmsuppss +rmulccn +rmx0 +rmx1 +rmxadd +rmxdbl +rmxdioph +rmxdiophlem +rmxfval +rmxluc +rmxm1 +rmxneg +rmxnn +rmxp1 +rmxy0 +rmxy1 +rmxyadd +rmxycomplete +rmxyelqirr +rmxyelxp +rmxyneg +rmxynorm +rmxypairf1o +rmxypos +rmxyval +rmy0 +rmy1 +rmyabs +rmyadd +rmydbl +rmydioph +rmyeq +rmyeq0 +rmyfval +rmygeid +rmyluc +rmyluc2 +rmym1 +rmyneg +rmynn +rmynn0 +rmyp1 +rn0 +rn1st +rnascl +rnasclassa +rnasclg +rnasclmulcl +rnasclsubrg +rnblopn +rnbra +rncmp +rncnv +rncnvcnv +rncnvepres +rnco +rnco2 +rncoeq +rncoold +rncoss +rncossdmcoss +rnct +rndrhmcl +rnelfm +rnelfmlem +rnelshi +rnep +rneq +rneqd +rneqdmfinf1o +rneqi +rnex +rnexd +rnexg +rnfdmpr +rnffi +rnfi +rnfvprc +rng0cl +rng1nfld +rng1nnzr +rng2idl0 +rng2idl1cntr +rng2idlnsg +rng2idlsubg0 +rng2idlsubgnsg +rng2idlsubgsubrng +rng2idlsubrng +rngabl +rngacl +rngansg +rngass +rngbase +rngcbas +rngcbasaltv +rngccat +rngccataltv +rngccatidaltv +rngcco +rngccoaltv +rngccofval +rngccofvalaltv +rngchom +rngchomaltv +rngchomfeqhom +rngchomffvalaltv +rngchomfval +rngchomfvalaltv +rngchomrnghmresaltv +rngcid +rngcidaltv +rngcifuestrc +rngcinv +rngcinvaltv +rngciso +rngcisoaltv +rngcl +rngcrescrhm +rngcrescrhmaltv +rngcresringcat +rngcsect +rngcsectaltv +rngcval +rngcvalaltv +rngdi +rngdir +rngen1zr +rnggrp +rnghmco +rnghmf +rnghmf1o +rnghmfn +rnghmghm +rnghmmgmhm +rnghmmul +rnghmrcl +rnghmresel +rnghmresfn +rnghmsscmap +rnghmsscmap2 +rnghmsubcsetc +rnghmsubcsetclem1 +rnghmsubcsetclem2 +rnghmval +rnghmval2 +rngidpropd +rngimcnv +rngimf1o +rngimrcl +rngimrnghm +rngisom1 +rngisomfv1 +rngisomring +rngisomring1 +rnglidl0 +rnglidl1 +rnglidlmcl +rnglidlmmgm +rnglidlmsgrp +rnglidlrng +rnglz +rngm2neg +rngmgmbs4 +rngmgp +rngmgpf +rngmneg1 +rngmneg2 +rngmulr +rngo0cl +rngo0lid +rngo0rid +rngo1cl +rngo2 +rngoa32 +rngoa4 +rngoaass +rngoablo +rngoablo2 +rngoaddneg1 +rngoaddneg2 +rngoass +rngocl +rngocom +rngodi +rngodir +rngodm1dm2 +rngogcl +rngogrphom +rngogrpo +rngohom0 +rngohom1 +rngohomadd +rngohomcl +rngohomco +rngohomf +rngohommul +rngohomsub +rngohomval +rngoi +rngoid +rngoideu +rngoidl +rngoidmlem +rngoiso1o +rngoisocnv +rngoisoco +rngoisohom +rngoisoval +rngokerinj +rngolcan +rngolidm +rngolz +rngomndo +rngone0 +rngonegcl +rngoneglmul +rngonegmn1l +rngonegmn1r +rngonegrmul +rngopidold +rngorcan +rngoridm +rngorn1 +rngorn1eq +rngorz +rngosm +rngosn3 +rngosn4 +rngosn6 +rngosub +rngosubdi +rngosubdir +rngoueqz +rngplusg +rngpropd +rngqipbas +rngqipring1 +rngqiprng +rngqiprng1elbas +rngqiprngfu +rngqiprngfulem1 +rngqiprngfulem2 +rngqiprngfulem3 +rngqiprngfulem4 +rngqiprngfulem5 +rngqiprngghm +rngqiprngghmlem1 +rngqiprngghmlem2 +rngqiprngghmlem3 +rngqiprngho +rngqiprngim +rngqiprngimf +rngqiprngimf1 +rngqiprngimf1lem +rngqiprngimfo +rngqiprngimfolem +rngqiprngimfv +rngqiprnglin +rngqiprnglinlem1 +rngqiprnglinlem2 +rngqiprnglinlem3 +rngqiprngu +rngridlmcl +rngringbd +rngringbdlem1 +rngringbdlem2 +rngrz +rngstr +rngsubdi +rngsubdir +rngunsnply +rnin +rninxp +rniun +rnmpo +rnmposs +rnmpt +rnmpt0f +rnmptbd +rnmptbd2 +rnmptbd2lem +rnmptbdd +rnmptbddlem +rnmptbdlem +rnmptc +rnmptfi +rnmptlb +rnmptn0 +rnmptpr +rnmptsn +rnmptss +rnmptss2 +rnmptssbi +rnmptssd +rnmptssdf +rnmptssdff +rnmptssf +rnmptssff +rnmptssrn +rnnonrel +rnopab +rnopab3 +rnopabss +rnoprab +rnoprab2 +rnpropg +rnqmap +rnqmapeleldisjsim +rnresequniqs +rnresi +rnressnsn +rnresss +rnresun +rnresv +rnrhmsubrg +rnsnf +rnsnn0 +rnsnop +rnsnopg +rnss +rnssi +rntpos +rntrcl +rntrclfv +rntrclfvoai +rntrclfvrp +rnttrcl +rnun +rnuni +rnwf +rnxp +rnxpid +rnxpss +rnxrn +rnxrncnvepres +rnxrnidres +rnxrnres +rollback_inverse +rolle +rollelem +room_assignment +root1cj +root1eq1 +root1id +root_nonpower +rose_tree_fold +rossros +rossspw +rotation_exists +rotation_exists_1 +rotation_lowdim_horizontal +rotation_matrix_1 +rotation_matrix_2 +rotation_matrix_exists_basis +rotation_rightward_line +rotation_to_general_position_exists +rotation_to_general_position_exists_gen +rotoinversion_exists_gen +rotoinversion_matrix_1 +rotoinversion_matrix_reflect_along +routing_loop_free +row_0 +row_matrix_mul +row_transp +rows_nonempty +rows_transp +rp-4frege +rp-6frege +rp-7frege +rp-8frege +rp-abid +rp-brsslt +rp-fakeanorass +rp-fakeimass +rp-fakeinunass +rp-fakeoranass +rp-fakeuninass +rp-frege24 +rp-frege25 +rp-frege3g +rp-frege4g +rp-intrabeq +rp-isfinite5 +rp-isfinite6 +rp-misc1-frege +rp-oelim2 +rp-simp2 +rp-simp2-frege +rp-tfslim +rp-unirabeq +rpabsid +rpaddcl +rpaddcld +rpcn +rpcnd +rpcndif0 +rpcnne0 +rpcnne0d +rpcoshcl +rpcxpcl +rpcxpcld +rpdivcl +rpdivcld +rpdmgm +rpdp2cl +rpdp2cl2 +rpdpcl +rpdvds +rpefcl +rpefcld +rpex +rpexp +rpexp12i +rpexp1i +rpexpcl +rpexpcld +rpexpmord +rpgamcl +rpge0 +rpge0d +rpgecl +rpgecld +rpgt0 +rpgt0d +rpgtrecnn +rphalfcl +rphalfcld +rphalflt +rphalfltd +rplog11d +rplogcl +rplogcld +rplogsum +rplogsumlem1 +rplogsumlem2 +rplpwr +rpltrp +rpmsubg +rpmtmip +rpmul +rpmulcl +rpmulcld +rpmulgcd +rpmulgcd2 +rpne0 +rpne0d +rpneg +rpnnen +rpnnen1 +rpnnen1lem1 +rpnnen1lem2 +rpnnen1lem3 +rpnnen1lem4 +rpnnen1lem5 +rpnnen1lem6 +rpnnen2 +rpnnen2lem1 +rpnnen2lem10 +rpnnen2lem11 +rpnnen2lem12 +rpnnen2lem2 +rpnnen2lem3 +rpnnen2lem4 +rpnnen2lem5 +rpnnen2lem6 +rpnnen2lem7 +rpnnen2lem8 +rpnnen2lem9 +rpnnen3 +rpnnen3lem +rppwr +rpre +rpreccl +rpreccld +rprecred +rpred +rprege0 +rprege0d +rpregt0 +rpregt0d +rprene0 +rprene0d +rprisefaccl +rprmasso +rprmasso2 +rprmasso3 +rprmcl +rprmdvds +rprmdvdspow +rprmdvdsprod +rprmirred +rprmirredb +rprmirredlem +rprmndvdsr1 +rprmndvdsru +rprmnunit +rprmnz +rprmval +rprpwr +rpsqrtcl +rpsqrtcld +rpsqrtcn +rpsscn +rpssre +rpssxr +rpsup +rpvmasum +rpvmasum2 +rpvmasumlem +rpxdivcld +rpxr +rpxrd +rr-elrnmpt3d +rr-groth +rr-grothprim +rr-grothprimbi +rr-grothshort +rr-grothshortbi +rr-phpd +rr-spce +rr19.28v +rr19.3v +rr2sscn2 +rrextchr +rrextcusp +rrextdrg +rrexthaus +rrextnlm +rrextnrg +rrexttps +rrextust +rrgeq0 +rrgeq0i +rrgnz +rrgss +rrgsubm +rrgsupp +rrgval +rrh0 +rrhcn +rrhcne +rrhf +rrhfe +rrhqima +rrhre +rrhval +rrncms +rrncmslem +rrndistlt +rrndsmet +rrndstprj1 +rrndstprj2 +rrndsxmet +rrnequiv +rrnheibor +rrnmbl +rrnmet +rrnmval +rrnprjdstle +rrntotbnd +rrnval +rrpsscn +rru +rrvadd +rrvdm +rrvdmss +rrvf2 +rrvfinvima +rrvfn +rrvmbfm +rrvmulc +rrvrnss +rrvsum +rrvvf +rrx0 +rrx0el +rrx2line +rrx2linesl +rrx2linest +rrx2linest2 +rrx2plord +rrx2plord1 +rrx2plord2 +rrx2plordisom +rrx2plordso +rrx2pnecoorneor +rrx2pnedifcoorneor +rrx2pnedifcoorneorr +rrx2pxel +rrx2pyel +rrx2vlinest +rrx2xpreen +rrx2xpref1o +rrxbase +rrxbasefi +rrxcph +rrxdim +rrxds +rrxdsfi +rrxdsfival +rrxdstprj1 +rrxf +rrxfsupp +rrxip +rrxline +rrxlinec +rrxlines +rrxlinesc +rrxmet +rrxmetfi +rrxmetlem +rrxmfval +rrxmval +rrxmvallem +rrxngp +rrxnm +rrxplusgvscavalb +rrxprds +rrxsca +rrxsnicc +rrxsphere +rrxsuppss +rrxtop +rrxtopn +rrxtopn0 +rrxtopn0b +rrxtopnfi +rrxtopon +rrxtoponfi +rrxtps +rrxunitopnfi +rrxval +rrxvsca +rsp +rsp0 +rsp1 +rsp2 +rsp2e +rsp3 +rsp3eq +rspa +rspc +rspc2 +rspc2daf +rspc2dv +rspc2ev +rspc2gv +rspc2v +rspc2va +rspc2vd +rspc3dv +rspc3ev +rspc3v +rspc4v +rspc6v +rspc8v +rspccv +rspccva +rspcdf +rspcdv +rspcdv2 +rspcdva +rspce +rspceaimv +rspceaov +rspceb2dv +rspcebdv +rspced +rspcedeq1vd +rspcedeq2vd +rspcedv +rspcedvd +rspcedvdw +rspceeqv +rspcef +rspcegf +rspceov +rspcev +rspcimdv +rspcime +rspcimedv +rspcl +rspcsbela +rspcsbnea +rspct +rspcv +rspcva +rspe +rspec +rspec2 +rspec3 +rspecbas +rspectopn +rspectps +rspectset +rspecval +rspesbca +rspesbcd +rspidlid +rspn0 +rsprprmprmidl +rsprprmprmidlb +rspsbc +rspsbc2 +rspsbc2vd +rspsbca +rspsn +rspsnasso +rspsnid +rspssbasd +rspssid +rspssp +rspval +rspw +rsubrotld +rsum_bound +rsum_component_le +rsum_diff_bound +rtc_cr +rtc_eq_nrc +rtc_mono +rtc_nrc +rtc_refl +rtcpredn_eq_rtcredn +rtcpredn_rtcredn +rtcredn_ap_monotonic +rtcredn_rtcpredn +rtelextdg2 +rtelextdg2lem +rtprmirr +rtrclex +rtrclexi +rtrclexlem +rtrclind +rtrclreclem1 +rtrclreclem2 +rtrclreclem3 +rtrclreclem4 +ru +ru0 +rualt +ruc +rucalt +ruclem1 +ruclem10 +ruclem11 +ruclem12 +ruclem13 +ruclem2 +ruclem3 +ruclem4 +ruclem6 +ruclem7 +ruclem8 +ruclem9 +rule +rule antisym +rule order_antisym +rule_assum_tac +rule_l_assum_tac +rules +runner +ruold +rusbcalt +rusgr0edg +rusgr1vtx +rusgr1vtxlem +rusgrnumwlkg +rusgrnumwrdl2 +rusgrnumwwlk +rusgrnumwwlkb0 +rusgrnumwwlkb1 +rusgrnumwwlkg +rusgrnumwwlkl1 +rusgrnumwwlklem +rusgrnumwwlks +rusgrnumwwlkslem +rusgrprc +rusgrprop +rusgrprop0 +rusgrpropadjvtx +rusgrpropedg +rusgrpropnb +rusgrrgr +rusgrusgr +ruv +ruvalt +rw +rw_tac +rxp112d +rxp11d +rzal +rzalalt +rzalf +rzgrp +s +s0s1 +s111 +s1chn +s1cl +s1cld +s1cli +s1co +s1dm +s1dmalt +s1eq +s1eqd +s1f1 +s1fv +s1len +s1nz +s1prc +s1rn +s1s2 +s1s3 +s1s4 +s1s5 +s1s6 +s1s7 +s1val +s2cl +s2cld +s2cli +s2co +s2dm +s2dmalt +s2elclwwlknon2 +s2eq2s1eq +s2eq2seq +s2eqd +s2f1 +s2f1o +s2fv0 +s2fv1 +s2len +s2prop +s2rn +s2rnold +s2s2 +s2s5 +s3cl +s3cld +s3clhash +s3cli +s3co +s3eq2 +s3eq3seq +s3eqd +s3eqs2s1eq +s3f1 +s3fn +s3fv0 +s3fv1 +s3fv2 +s3iunsndisj +s3len +s3rn +s3rnold +s3s4 +s3sndisj +s3tpop +s3wwlks2on +s4cld +s4cli +s4dom +s4eqd +s4f1o +s4fv0 +s4fv1 +s4fv2 +s4fv3 +s4len +s4prop +s4s2 +s4s3 +s4s4 +s5cld +s5cli +s5eqd +s5len +s5s2 +s6cld +s6cli +s6eqd +s6len +s7cld +s7cli +s7eqd +s7f1o +s7len +s7rn +s8cld +s8cli +s8eqd +s8len +s_spec +sa-abvi +sacgr +sadadd +sadadd2 +sadadd2lem +sadadd2lem2 +sadadd3 +sadaddlem +sadass +sadasslem +sadc0 +sadcadd +sadcaddlem +sadcf +sadcl +sadcom +sadcp1 +saddisj +saddisjlem +sadeq +sadfval +sadid1 +sadid2 +sadval +safe +safe_div +safesnsupfidom1o +safesnsupfilb +safesnsupfiss +safesnsupfiub +safety +safety_property +saldifcl +saldifcl2 +saldifcld +salexct +salexct2 +salexct3 +salgencl +salgencld +salgencntex +salgenn0 +salgenss +salgensscntex +salgenuni +salgenval +saliincl +saliinclf +salincl +salincld +saliuncl +saliunclf +salpreimagelt +salpreimagtge +salpreimagtlt +salpreimalegt +salpreimalelt +salpreimaltle +salrestss +saluncl +saluncld +saluni +salunicl +salunid +same_distances_to_affine_hull +same_eigenvalues_matrix_mul +same_eigenvalues_similar +same_eigenvalues_transp +same_eigenvectors_matrix_inv +same_fringe_spec +same_norm_same_dot +sandbox +sat +sat1el2xp +sate0 +sate0fv0 +satef +satefv +satefvfmla0 +satefvfmla1 +sategoelfv +sategoelfvb +satf +satf0 +satf00 +satf0n0 +satf0op +satf0suc +satf0suclem +satf0sucom +satfbrsuc +satfdm +satfdmfmla +satfdmlem +satff +satffun +satffunlem +satffunlem1 +satffunlem1lem1 +satffunlem1lem2 +satffunlem2 +satffunlem2lem1 +satffunlem2lem2 +satfn +satfrel +satfrnmapom +satfsschain +satfsucom +satfun +satfv0 +satfv0fun +satfv0fvfmla0 +satfv1 +satfv1fvfmla1 +satfv1lem +satfvel +satfvsuc +satfvsuclem1 +satfvsuclem2 +satfvsucom +satfvsucsuc +satisfiable +satom +sb1 +sb10f +sb1v +sb2 +sb2ae +sb2imi +sb3 +sb3an +sb3b +sb4a +sb4av +sb4b +sb4e +sb5 +sb5alt +sb5altvd +sb5f +sb5rf +sb6 +sb6a +sb6f +sb6rf +sb6rfv +sb6x +sb7f +sb7h +sb8 +sb8e +sb8ef +sb8eu +sb8eulem +sb8euv +sb8f +sb8iota +sb8mo +sb8v +sb9 +sb9i +sbab +sbabel +sbal +sbal1 +sbal2 +sbalex +sbalexi +sbalexold +sbali +sbalv +sban +sbaniota +sbbi +sbbib +sbbibvv +sbbid +sbbidv +sbbii +sbbiiev +sbc19.21g +sbc2ie +sbc2iedf +sbc2iedv +sbc2iegf +sbc2or +sbc2rex +sbc2rexgold +sbc3an +sbc3ie +sbc3or +sbc3orgvd +sbc4rex +sbc4rexgold +sbc5 +sbc5alt +sbc6 +sbc6g +sbc7 +sbc8g +sbcabel +sbcal +sbcalf +sbcalfi +sbcaltop +sbcan +sbcani +sbcbi +sbcbi1 +sbcbi2 +sbcbid +sbcbidv +sbcbig +sbcbii +sbcbivd +sbcbr +sbcbr123 +sbcbr12g +sbcbr1g +sbcbr2g +sbcco +sbcco2 +sbcco3g +sbcco3gw +sbccom +sbccom2 +sbccom2f +sbccom2fi +sbccom2lem +sbccomieg +sbccomlem +sbccomlemold +sbccow +sbccsb +sbccsb2 +sbcel12 +sbcel1g +sbcel1v +sbcel2 +sbcel21v +sbcel2gv +sbceq1a +sbceq1d +sbceq1dd +sbceq1ddi +sbceq1g +sbceq2a +sbceq2g +sbceqal +sbceqbid +sbceqbidf +sbceqbii +sbceqg +sbceqi +sbcex +sbcex2 +sbcexf +sbcexfi +sbcfg +sbcfng +sbcfung +sbcg +sbcgf +sbcgfi +sbcheg +sbcid +sbcie +sbcie2g +sbcie2s +sbcie3s +sbcied +sbcied2 +sbciedf +sbcieg +sbciegf +sbciegft +sbciegftold +sbcies +sbcim1 +sbcim2g +sbcim2gvd +sbcimdv +sbcimg +sbcimi +sbcn1 +sbcne12 +sbcnel12g +sbcnestg +sbcnestgf +sbcnestgfw +sbcnestgw +sbcng +sbcni +sbco +sbco2 +sbco2d +sbco2v +sbco2vv +sbco3 +sbco4 +sbco4lem +sbco4lemold +sbco4old +sbcom +sbcom2 +sbcom3 +sbcom3old +sbcom3vv +sbcom4 +sbcop +sbcop1 +sbcopeq1a +sbcor +sbcoreleleq +sbcoreleleqvd +sbcori +sbcoteq1a +sbcov +sbcovold +sbcpr +sbcralg +sbcralt +sbcrel +sbcreu +sbcrex +sbcrexgold +sbcrext +sbcrot3 +sbcrot5 +sbcssg +sbcssgvd +sbcth +sbcth2 +sbcthdv +sbctt +sbel2x +sbelx +sbeqal1 +sbeqal1i +sbeqal2i +sbeqalb +sbeqi +sbequ +sbequ1 +sbequ12 +sbequ12a +sbequ12r +sbequ2 +sbequ5 +sbequ6 +sbequ8 +sbequbidv +sbequi +sbex +sbexi +sbf +sbf2 +sbfal +sbft +sbgoldbalt +sbgoldbaltlem1 +sbgoldbaltlem2 +sbgoldbb +sbgoldbm +sbgoldbmb +sbgoldbo +sbgoldbst +sbgoldbwt +sbh +sbhb +sbhypf +sbi1 +sbi2 +sbid +sbid2 +sbid2v +sbid2vw +sbidd +sbidd-misc +sbidm +sbie +sbied +sbiedv +sbiedvw +sbiedw +sbiev +sbievold +sbievw +sbievw2 +sbievwold +sbim +sbimd +sbimdv +sbimi +sbiota1 +sbjust +sblbis +sblim +sblpnf +sbmo +sbn +sbn1 +sbn1alt +sbnf +sbnf2 +sbnfc2 +sbnfold +sbor +sbor2 +sbralie +sbraliealt +sbralieold +sbrbif +sbrbis +sbrim +sbrimvw +sbsbc +sbss +sbt +sbtalt +sbtd +sbth +sbthb +sbthcl +sbthfi +sbthfilem +sbthlem1 +sbthlem10 +sbthlem2 +sbthlem3 +sbthlem4 +sbthlem5 +sbthlem6 +sbthlem7 +sbthlem8 +sbthlem9 +sbtlem +sbtr +sbtrt +sbtru +sbtt +sbv +sca2rab +scafeq +scaffn +scaffval +scafval +scaid +scal_function +scaldiv_function +scaling_linear +scandx +scandxnbasendx +scandxnmulrndx +scandxnplusgndx +schroeder_bernstein +schroeder_bernstein_auto +schroeder_close +schroeder_close_set +schroeder_close_subset +schroeder_closed +sclnbgrel +sclnbgrelself +sclnbgrisvtx +scmataddcl +scmatcrng +scmatdmat +scmate +scmatealt +scmatel +scmatf +scmatf1 +scmatf1o +scmatfo +scmatghm +scmatid +scmatlss +scmatmat +scmatmats +scmatmhm +scmatmulcl +scmatrhm +scmatrhmcl +scmatrhmval +scmatric +scmatrngiso +scmatscm +scmatscmid +scmatscmiddistr +scmatscmide +scmatsgrp +scmatsgrp1 +scmatsrng +scmatsrng1 +scmatstrbas +scmatsubcl +scmatval +scmfsupp +scmsuppfi +scmsuppss +sconnpconn +sconnpht +sconnpht2 +sconnpi1 +sconntop +scott0 +scott0f +scott0s +scottab +scottabes +scottabf +scotteld +scottelrankd +scotteq +scotteqd +scottex +scottex2 +scottexf +scottexs +scottn0f +scottrankd +scottss +scshwfzeqfzo +scvxcvx +sdc +sdclem1 +sdclem2 +sdom0 +sdom1 +sdom2en01 +sdomdif +sdomdom +sdomdomtr +sdomdomtrfi +sdomel +sdomen1 +sdomen2 +sdomentr +sdomirr +sdomn2lp +sdomne0 +sdomne0d +sdomnen +sdomnsym +sdomsdomcard +sdomsdomcardi +sdomtr +sdrgacs +sdrgbas +sdrgdrng +sdrgdvcl +sdrgfldext +sdrgid +sdrgint +sdrginvcl +sdrgrcl +sdrgss +sdrgsubrg +sdrgunit +search_correct +searchnat +sec0 +seccl +second_mean_value_theorem +second_mean_value_theorem_bonnet +second_mean_value_theorem_bonnet_full +second_mean_value_theorem_full +second_mean_value_theorem_gen +second_mean_value_theorem_gen_full +sectcan +sectco +sectepi +sectffval +sectfn +sectfval +sectid +sectmon +sectpropd +sectpropdlem +sectrcl +sectrcl2 +sectss +secval +seeq1 +seeq12d +seeq2 +seex +seff +segcon2 +segconeq +segconeu +segleantisym +seglecgr12 +seglecgr12im +seglelin +seglemin +seglerflx +segletr +segment +segment_1 +segment_as_ball +segment_bound +segment_closed_open +segment_convex_hull +segment_edge_of +segment_eq +segment_eq_empty +segment_eq_sing +segment_face_of +segment_furthest_le +segment_image_interval +segment_open_subset_closed +segment_out_to_frontier +segment_refl +segment_scalar_multiple +segment_subset_convex +segment_subset_line +segment_subset_relative_frontier_convex +segment_subset_relative_frontier_convex_gen +segment_sym +segment_to_closest_point +segment_to_frontier_simple +segment_to_point_exists +segment_to_relative_frontier +segment_to_relative_frontier_simple +segment_translation +seinxp +selberg +selberg2 +selberg2b +selberg2lem +selberg3 +selberg34r +selberg3lem1 +selberg3lem2 +selberg3r +selberg4 +selberg4lem1 +selberg4r +selbergb +selberglem1 +selberglem2 +selberglem3 +selbergr +selbergs +selbergsb +selconj +select +select_conv +select_elim_tac +select_refl +select_unique +selection_sort_sorted +selection_sort_spec +selectionsortcorrect +self +self_adjoint_closest_point +self_adjoint_compose +self_adjoint_has_eigenvector +self_adjoint_has_eigenvector_basis +self_adjoint_has_eigenvector_basis_of_subspace +self_adjoint_has_eigenvector_in_subspace +self_adjoint_orthogonal_eigenvectors +self_in_powerset +sels +selsalt +selvadd +selvcl +selvcllem1 +selvcllem2 +selvcllem3 +selvcllem4 +selvcllem5 +selvcllemh +selvffval +selvfval +selvmul +selvval +selvval2 +selvvvval +semantics +semilat_idempotent +semiring_distrib_left +separable +separate_closed_compact +separate_closed_cones +separate_compact_closed +separate_point_closed +separated_in_subtopology +separating_hyperplane_affine_affine +separating_hyperplane_affine_hulls +separating_hyperplane_closed_0 +separating_hyperplane_closed_0_inset +separating_hyperplane_closed_compact +separating_hyperplane_closed_point +separating_hyperplane_closed_point_inset +separating_hyperplane_compact_closed +separating_hyperplane_compact_closed_nonzero +separating_hyperplane_compact_compact +separating_hyperplane_polyhedra +separating_hyperplane_relative_interiors +separating_hyperplane_set_0 +separating_hyperplane_set_0_inspan +separating_hyperplane_set_point_inaff +separating_hyperplane_sets +separation_closed_in_union +separation_closed_in_union_gen +separation_closures +separation_hausdorff +separation_normal +separation_normal_closures +separation_normal_compact +separation_normal_local +separation_normal_local_closures +separation_open_in_union +separation_open_in_union_gen +separation_t0 +separation_t1 +separation_t2 +sepcsepo +sepdisj +sepex +sepexi +sepexlem +sepfsepc +sepnsepo +sepnsepolem1 +sepnsepolem2 +seposep +seppcld +seppsepf +seq1 +seq1hcau +seq1i +seq1p +seq1st +seq_append_length +seq_bolzano_weierstrass +seq_bounded_convergent +seq_cauchy_criterion +seq_comparison_test +seq_cons_head_tail +seq_convergent +seq_count_append +seq_create_index +seq_equal_intro +seq_harmonic +seq_harmonic_divergent +seq_harmonic_offset +seq_harmonic_ratio +seq_init_index +seq_limit_add +seq_limit_mul +seq_map_seq +seq_mem_append +seq_monotone_incr +seq_offset +seq_offset_eq +seq_offset_neg +seq_offset_rev +seq_ratio_test +seq_series_convergent +seq_slice_slice +seq_sort_permutation +seq_subsequence_limit +seq_unsnoc +seq_upd_index +seqabs +seqappendassoc +seqappendlength +seqappendnil +seqcaopr +seqcaopr2 +seqcaopr3 +seqcl +seqcl2 +seqcoll +seqcoll2 +seqdistr +seqeq1 +seqeq123d +seqeq1d +seqeq2 +seqeq2d +seqeq3 +seqeq3d +seqex +seqexw +seqf +seqf1o +seqf1olem1 +seqf1olem2 +seqf1olem2a +seqf2 +seqfeq +seqfeq2 +seqfeq3 +seqfeq4 +seqfiltersubseq +seqflattenlength +seqfn +seqfveq +seqfveq2 +seqhomo +seqid +seqid2 +seqid3 +seqm1 +seqmaplength +seqmemberappend +seqn0sfn +seqof +seqof2 +seqom0g +seqomeq12 +seqomlem0 +seqomlem1 +seqomlem2 +seqomlem3 +seqomlem4 +seqomsuc +seqp1 +seqp1d +seqpo +seqres +seqreverselength +seqreversereverse +seqs1 +seqseq123d +seqsex +seqsfn +seqshft +seqshft2 +seqsp1 +seqsplit +seqsval +seqtakedropidentity +sequence_cauchy_wlog +sequence_escapes +sequence_escapes_alt +sequence_infinite_lemma +sequence_unique_limpt +sequential_limit_urysohn +sequentially +seqval +seqz +ser0 +ser0f +ser1const +seradd +serclim0 +serf +serf0 +serfre +serge0 +series_0 +series_add +series_bilinear +series_bilinear_unique +series_bound +series_cauchy +series_cauchy_uniform +series_cmul +series_comparison +series_comparison_bound +series_comparison_uniform +series_component +series_diffs +series_dirichlet +series_dirichlet_bilinear +series_drop_le +series_drop_pos +series_even +series_finite +series_finite_eq +series_finite_support +series_from +series_goestozero +series_injective_image +series_injective_image_strong +series_lift_absconv_imp_conv +series_linear +series_neg +series_odd +series_pastecart +series_ratio +series_rearrange +series_rearrange_eq +series_restrict +series_sub +series_subset +series_terms_tozero +series_trivial +series_unique +series_vsum +serle +sermono +sersub +sess1 +sess2 +session-safe +session_expiry +session_key_derive +session_safe +set +set_cases +set_collect_mem +set_comprehension +set_covering +set_diff_frontier +set_diff_subset +set_disjoint_union +set_eq_tac +set_ext +set_finite_union +set_image_union +set_induct_tac +set_insert_member +set_inter_comm +set_minimum +set_powerset +set_prove_cases +set_quotient +set_rel_eq +set_rel_thm +set_rule +set_tac +set_to_list_card +set_to_list_empty_iff +set_to_list_in_mem +set_to_list_inv +set_variation +set_variation_0 +set_variation_cmul +set_variation_comparison +set_variation_degenerates +set_variation_elementary_lemma +set_variation_eq +set_variation_ge_function +set_variation_interval_lemma +set_variation_lbound +set_variation_lbound_on_interval +set_variation_monotone +set_variation_on_division +set_variation_on_elementary +set_variation_on_empty +set_variation_on_interval +set_variation_on_null +set_variation_pos_le +set_variation_triangle +set_variation_ubound +set_variation_ubound_on_interval +set_variation_works_on_interval +setc1obas +setc1ocofval +setc1ohomfval +setc1oid +setc1onsubc +setc1oterm +setc1strwun +setc2obas +setc2ohom +setc2othin +setcarduniondisjoint +setcbas +setccat +setccatid +setcco +setccofval +setcepi +setchom +setchomfval +setcid +setcinv +setciso +setcmon +setcsect +setcsnterm +setcthin +setcval +setdemorgan +setdist_balls +setdist_closed_compact +setdist_closest_point +setdist_closure +setdist_compact_closed +setdist_differences +setdist_empty +setdist_eq_0_bounded +setdist_eq_0_closed +setdist_eq_0_closed_compact +setdist_eq_0_closed_in +setdist_eq_0_compact_closed +setdist_eq_0_sing +setdist_frontier +setdist_frontiers +setdist_hausdist_triangle +setdist_le_dist +setdist_le_hausdist +setdist_le_sing +setdist_linear_image +setdist_pos_le +setdist_pos_lt +setdist_refl +setdist_relative_interior +setdist_scaling +setdist_sing_frontier +setdist_sing_frontier_cases +setdist_sing_in_set +setdist_sing_le_hausdist +setdist_sing_triangle +setdist_sings +setdist_subset_left +setdist_subset_right +setdist_subsets_eq +setdist_sym +setdist_translation +setdist_triangle +setdist_unique +setdist_univ +setdist_zero +setdist_zero_strong +setext +setind +setind2 +setindregs +setinds +setinds2 +setinds2f +setinds2regs +setindtr +setindtrs +setintercomm +setintersubset +setis +setlikespec +setoid_morphism +setok_le_lt +setpreimafvex +setrec1 +setrec1lem1 +setrec1lem2 +setrec1lem3 +setrec1lem4 +setrec2 +setrec2fun +setrec2lem1 +setrec2lem2 +setrec2mpt +setrec2v +setrecseq +setrecsres +setrecsss +setsabs +setscom +setsdm +setsexstruct2 +setsfun +setsfun0 +setsid +setsidel +setsidvald +setsiedg +setsms +setsmsbas +setsmsds +setsmstopn +setsmstset +setsn0fun +setsnid +setsnidel +setsplusg +setsres +setsstrset +setsstruct +setsstruct2 +setsubsetrefl +setsubsettrans +setsv +setsval +setsvalg +setsvtx +setsxms +settlement_complete +setunionassoc +setunioncomm +setunionempty +setvariation_equal_lemma +sexp2 +sexp3 +sfprmdvdsmersenne +sge00 +sge0ad2en +sge0cl +sge0clmpt +sge0f1o +sge0fodjrn +sge0fodjrnlem +sge0fsum +sge0fsummpt +sge0fsummptf +sge0ge0 +sge0ge0mpt +sge0gerp +sge0gerpmpt +sge0gtfsumgt +sge0hsphoire +sge0isum +sge0isummpt +sge0isummpt2 +sge0iun +sge0iunmpt +sge0iunmptlemfi +sge0iunmptlemre +sge0le +sge0lefi +sge0lefimpt +sge0lempt +sge0less +sge0lessmpt +sge0ltfirp +sge0ltfirpmpt +sge0ltfirpmpt2 +sge0nemnf +sge0p1 +sge0pnffigt +sge0pnffigtmpt +sge0pnffsumgt +sge0pnfmpt +sge0pnfval +sge0pr +sge0prle +sge0repnf +sge0repnfmpt +sge0rern +sge0rernmpt +sge0resplit +sge0resrn +sge0resrnlem +sge0reuz +sge0reuzb +sge0reval +sge0revalmpt +sge0rnbnd +sge0rnn0 +sge0rnre +sge0rpcpnf +sge0seq +sge0sn +sge0snmpt +sge0snmptf +sge0split +sge0splitmpt +sge0splitsn +sge0ss +sge0ssre +sge0ssrempt +sge0sup +sge0supre +sge0tsms +sge0uzfsumgt +sge0val +sge0vald +sge0xadd +sge0xaddlem1 +sge0xaddlem2 +sge0xp +sge0xrcl +sge0xrclmpt +sge0z +sgmcl +sgmf +sgmmul +sgmnncl +sgmppw +sgmval +sgmval2 +sgn0 +sgn0bi +sgn1 +sgn3da +sgncl +sgnclre +sgnmnf +sgnmul +sgnmulrp2 +sgnmulsgn +sgnmulsgp +sgnn +sgnnbi +sgnneg +sgnp +sgnpbi +sgnpnf +sgnrrp +sgnsf +sgnsgn +sgnsub +sgnsv +sgnsval +sgnval +sgnval2 +sgoldbeven3prm +sgon +sgprmdvdsmersenne +sgrim +sgrimval +sgrp0 +sgrp0b +sgrp1 +sgrp2nmnd +sgrp2nmndlem1 +sgrp2nmndlem2 +sgrp2nmndlem3 +sgrp2nmndlem4 +sgrp2nmndlem5 +sgrp2rid2 +sgrp2rid2ex +sgrp2sgrp +sgrpass +sgrpcl +sgrpidmnd +sgrpmgm +sgrpnmndex +sgrpplusgaopalt +sgrppropd +sgrpssmgm +sgsiga +sgsummulcl +sh0 +sh0le +sh1dle +shaddcl +shannonsource +sharhght +shatomici +shatomistici +shel +sheli +shelii +shex +shft2rab +shftcan1 +shftcan2 +shftdm +shftf +shftfib +shftfn +shftfval +shftidt +shftidt2 +shftlem +shftmbl +shftuz +shftval +shftval2 +shftval3 +shftval4 +shftval5 +shftvalg +shiftstableeq2 +shincl +shincli +shintcl +shintcli +shjcl +shjcli +shjcom +shjcomi +shjshcli +shjshseli +shjshsi +shjval +shle0 +shlej1 +shlej1i +shlej2 +shlej2i +shlesb1i +shless +shlessi +shlub +shlubi +shmodi +shmodsi +shmulcl +shne0i +shoccl +shocel +shococss +shocorth +shocsh +shocss +shortest_arc_exists +shortest_path +shortest_path_exists +shortest_path_exists_gen +shortest_path_exists_straddle +shorth +shortlex_antisymmetric +shortlex_irreflexive +shortlex_length_le +shortlex_same_lengths +shortlex_snoc +shortlex_total +shortlex_transitive +show +shs00i +shs0i +shscl +shscli +shscom +shscomi +shsel +shsel1 +shsel1i +shsel2 +shsel2i +shsel3 +shseli +shsidmi +shslej +shsleji +shslubi +shss +shssii +shsspwh +shsss +shsub1 +shsub1i +shsub2 +shsub2i +shsubcl +shsupcl +shsupunss +shsva +shsvai +shsval +shsval2i +shsval3i +shsvs +shsvsi +shub1 +shub1i +shub2 +shuni +shunssi +shunssji +sibf0 +sibff +sibfima +sibfinima +sibfmbl +sibfof +sibfrn +side +sigaclci +sigaclcu +sigaclcu2 +sigaclcu3 +sigaclcuni +sigaclfu +sigaclfu2 +sigaex +sigagenid +sigagensiga +sigagenss +sigagenss2 +sigagenval +sigainb +sigaldsys +sigapildsys +sigapildsyslem +sigapisys +sigarac +sigaradd +sigaraf +sigaras +sigarcol +sigardiv +sigarexp +sigarid +sigarim +sigarimcd +sigariz +sigarls +sigarmf +sigarms +sigarperm +sigarval +sigasspw +sigaval +sigma_0_neg +sigma_bij +sigma_by2s +sigma_card_constant +sigma_compact +sigma_cong +sigma_constant +sigma_first_ge +sigma_geometric +sigma_inj +sigma_le_sigma +sigma_product +sigma_product2 +sigma_reverse +sigma_shift +sigma_shift_i +sigma_shift_neg +sigma_shift_ng2 +sigma_shift_to_zero +sigma_split_ge +sigma_tolambda +sigmoid_bounded +sign_i +sign_inverse +sign_nz +sign_swap +signature_verify +signed-byte-p-base-cases +signed-byte-p-integer-length +signed-byte-p-lognot +signlem0 +signshf +signshlen +signshnz +signshwrd +signslema +signsply0 +signsplypnf +signspval +signstcl +signstf +signstf0 +signstfv +signstfval +signstfvc +signstfvcl +signstfveq0 +signstfveq0a +signstfvn +signstfvneq0 +signstfvp +signstlen +signstres +signsvf0 +signsvf1 +signsvfn +signsvfnn +signsvfpn +signsvtn +signsvtn0 +signsvtp +signsvvf +signsvvfval +signsw0g +signsw0glem +signswbase +signswch +signswlid +signswmnd +signswn0 +signswplusg +signswrid +sii +siii +siilem1 +siilem2 +silverman_steinhauslike +simp +simp-10l +simp-10r +simp-11l +simp-11r +simp-12l +simp-12r +simp-4l +simp-4r +simp-5l +simp-5r +simp-6l +simp-6r +simp-7l +simp-7r +simp-8l +simp-8r +simp-9l +simp-9r +simp1 +simp11 +simp111 +simp112 +simp113 +simp11l +simp11r +simp12 +simp121 +simp122 +simp123 +simp12l +simp12r +simp13 +simp131 +simp132 +simp133 +simp13l +simp13r +simp1bi +simp1d +simp1i +simp1l +simp1l1 +simp1l2 +simp1l3 +simp1ll +simp1lr +simp1r +simp1r1 +simp1r2 +simp1r3 +simp1rl +simp1rr +simp2 +simp21 +simp211 +simp212 +simp213 +simp21l +simp21r +simp22 +simp221 +simp222 +simp223 +simp22l +simp22r +simp23 +simp231 +simp232 +simp233 +simp23l +simp23r +simp2bi +simp2d +simp2i +simp2l +simp2l1 +simp2l2 +simp2l3 +simp2ll +simp2lr +simp2r +simp2r1 +simp2r2 +simp2r3 +simp2rl +simp2rr +simp3 +simp31 +simp311 +simp312 +simp313 +simp31l +simp31r +simp32 +simp321 +simp322 +simp323 +simp32l +simp32r +simp33 +simp331 +simp332 +simp333 +simp33l +simp33r +simp3bi +simp3d +simp3i +simp3l +simp3l1 +simp3l2 +simp3l3 +simp3ll +simp3lr +simp3r +simp3r1 +simp3r2 +simp3r3 +simp3rl +simp3rr +simp_all +simp_only +simp_real_arch +simp_real_arch_neg +simp_real_arch_suc +simp_rule +simp_tac +simpcntrab +simpg2nsg +simpggrp +simpggrpd +simpgnideld +simpgnsgbid +simpgnsgd +simpgnsgeqd +simpgntrivd +simpl +simpl1 +simpl11 +simpl12 +simpl13 +simpl1l +simpl1r +simpl2 +simpl21 +simpl22 +simpl23 +simpl2im +simpl2l +simpl2r +simpl3 +simpl31 +simpl32 +simpl33 +simpl3l +simpl3r +simplbda +simplbi +simplbi2 +simplbi2com +simplbi2comt +simplbi2comtvd +simplbi2vd +simplbiim +simpld +simple +simple_finite_induct +simple_image +simple_image_gen +simple_path_length_minimal +simple_path_length_pos_lt +simple_path_length_unique +simple_walks_finite +simplex +simplex_0_not_in_affine_hull +simplex_alt +simplex_alt1 +simplex_convex_hull +simplex_dim_ge +simplex_empty +simplex_explicit +simplex_extremal_le +simplex_extremal_le_exists +simplex_extreme_points +simplex_extreme_points_nonempty +simplex_face_of_simplex +simplex_furthest_le +simplex_furthest_le_exists +simplex_furthest_lt +simplex_furthest_lt_exists +simplex_imp_closed +simplex_imp_compact +simplex_imp_convex +simplex_imp_polyhedron +simplex_imp_polytope +simplex_insert +simplex_insert_dimplus1 +simplex_linear_image_eq +simplex_minus_1 +simplex_segment +simplex_segment_cases +simplex_sing +simplex_translation_eq +simplex_vertices_unique +simplex_zero +simpli +simplicial_complex_disjoint_relative_interiors +simplicial_complex_imp_triangulation +simplicial_complex_linear_image +simplicial_complex_translation +simplicial_subdivision_of_cell_complex +simplicial_subdivision_of_cell_complex_lowdim +simplify-logand +simplify-logior +simplify-logite +simplify-logxor +simplim +simpll +simpll1 +simpll2 +simpll3 +simplld +simplll +simpllr +simplr +simplr1 +simplr2 +simplr3 +simplrd +simplrl +simplrr +simpr +simpr1 +simpr11 +simpr12 +simpr13 +simpr1l +simpr1r +simpr2 +simpr21 +simpr22 +simpr23 +simpr2l +simpr2r +simpr3 +simpr31 +simpr32 +simpr33 +simpr3l +simpr3r +simprbda +simprbi +simprd +simpri +simprim +simprimi +simprl +simprl1 +simprl2 +simprl3 +simprld +simprll +simprlr +simprr +simprr1 +simprr2 +simprr3 +simprrd +simprrl +simprrr +sin0 +sin01bnd +sin01gt0 +sin02gt0 +sin2h +sin2kpi +sin2pi +sin2pim +sin2t +sin2t3rdpi +sin4lt0 +sin4t3rdpi +sinacos +sinadd +sinaover2ne0 +sinasin +sinbnd +sinbnd2 +sinccvg +sinccvglem +since +sincl +sincld +sincn +sincos1sgn +sincos2sgn +sincos3rdpi +sincos4thpi +sincos6thpi +sincosq1eq +sincosq1lem +sincosq1sgn +sincosq2sgn +sincosq3sgn +sincosq4sgn +sincossq +sineq0 +sineq0alt +sinf +sing_card_1 +sing_element +sing_finite +sing_gspec +sing_iff_card1 +sing_iff_empty_rest +sing_inter +sing_one_element +sing_partitions +sing_subset +sing_test +sing_union +singl_apply_map +singl_apply_permute +singl_list_apply_r +sinh-conventional +sinhalfpi +sinhalfpilem +sinhalfpim +sinhalfpip +sinhpcosh +sinhval +sinhval-named +sinkpi +sinltx +sinmpi +sinmul +sinmulcos +sinneg +sinnpoly +sinord +sinper +sinperlem +sinpi +sinpim +sinppi +sinq12ge0 +sinq12gt0 +sinq34lt0t +sinsub +sinval +sitg0 +sitgaddlemb +sitgclbn +sitgclcn +sitgclg +sitgclre +sitgf +sitgfval +sitgval +sitmcl +sitmf +sitmfval +sitmval +size_inorder +sized_list_append +sizusglecusg +sizusglecusglem1 +sizusglecusglem2 +skk +skolem +skolem_thm +sledgehammer_pattern +slemma +slesolex +slesolinv +slesolinvbi +slesolvec +slmd0cl +slmd0vcl +slmd0vlid +slmd0vrid +slmd0vs +slmd1cl +slmdacl +slmdass +slmdbn0 +slmdcmn +slmdlema +slmdmcl +slmdmnd +slmdsn0 +slmdsrg +slmdvacl +slmdvs0 +slmdvs1 +slmdvsass +slmdvscl +slmdvsdi +slmdvsdir +sloteq +slotfn +slotresfo +slotsbhcdif +slotsdifdsndx +slotsdifipndx +slotsdifocndx +slotsdifplendx +slotsdifplendx2 +slotsdifunifndx +slotsdnscsi +slotsinbpsd +slotslnbpsd +slotstnscsi +sltmuls1 +sltmuls2 +sltsbday +sltsd +sltsdisj +sltsex1 +sltsex2 +sltsleft +sltsright +sltssep +sltssepc +sltssepcd +sltssn +sltssnb +sltsss1 +sltsss2 +sltstr +sltsun1 +sltsun2 +slwhash +slwispgp +slwn0 +slwpgp +slwprm +slwpss +slwsubg +sm +sm_deadlock_free +sm_invariant +sm_reachable +sm_step_preserves +sm_trace_valid +sm_transition +smadiadet +smadiadetg +smadiadetg0 +smadiadetglem1 +smadiadetglem2 +smadiadetlem0 +smadiadetlem1 +smadiadetlem1a +smadiadetlem2 +smadiadetlem3 +smadiadetlem3lem0 +smadiadetlem3lem1 +smadiadetlem3lem2 +smadiadetlem4 +smadiadetr +small +small_imp_totally_disconnected +smallest_fib_above_spec +smatbl +smatbr +smatcl +smatfval +smatlem +smatrcl +smattl +smattr +smatvscl +smcn +smcnlem +smf2id +smfadd +smfaddlem1 +smfaddlem2 +smfco +smfconst +smfdiv +smfdivdmmbl +smfdivdmmbl2 +smfdmmblpimne +smfdmss +smff +smffmpt +smffmptf +smfid +smfinf +smfinfdmmbl +smfinfdmmbllem +smfinflem +smfinfmpt +smflim +smflim2 +smfliminf +smfliminflem +smfliminfmpt +smflimlem1 +smflimlem2 +smflimlem3 +smflimlem4 +smflimlem5 +smflimlem6 +smflimmpt +smflimsup +smflimsuplem1 +smflimsuplem2 +smflimsuplem3 +smflimsuplem4 +smflimsuplem5 +smflimsuplem6 +smflimsuplem7 +smflimsuplem8 +smflimsupmpt +smfmbfcex +smfmul +smfmulc1 +smfmullem1 +smfmullem2 +smfmullem3 +smfmullem4 +smfneg +smfpimbor1 +smfpimbor1lem1 +smfpimbor1lem2 +smfpimcc +smfpimcclem +smfpimgtmpt +smfpimgtxr +smfpimgtxrmpt +smfpimgtxrmptf +smfpimioo +smfpimioompt +smfpimltmpt +smfpimltxr +smfpimltxrmpt +smfpimltxrmptf +smfpimne +smfpimne2 +smfpreimage +smfpreimagt +smfpreimagtf +smfpreimale +smfpreimalt +smfpreimaltf +smfrec +smfres +smfresal +smfsssmf +smfsup +smfsupdmmbl +smfsupdmmbllem +smfsuplem1 +smfsuplem2 +smfsuplem3 +smfsupmpt +smfsupxr +smfval +smgrpassold +smgrpismgmold +smgrpmgm +smn +smn_theorem +smndex1bas +smndex1basss +smndex1gbas +smndex1gid +smndex1ibas +smndex1id +smndex1igid +smndex1iidm +smndex1mgm +smndex1mnd +smndex1mndlem +smndex1n0mnd +smndex1sgrp +smndex2dbas +smndex2dlinvh +smndex2dnrinv +smndex2hbas +smndlsmidm +smo0 +smo11 +smobeth +smocdmdom +smodm +smodm2 +smoel +smoel2 +smoeq +smofvon +smofvon2 +smogt +smoiso +smoiso2 +smoiun +smonoord +smoord +smores +smores2 +smores3 +smoword +smprngopr +smt +smt_arith +smt_lemma +smtpat +smu01 +smu01lem +smu02 +smucl +smueq +smueqlem +smufval +smumul +smumullem +smup0 +smup1 +smupf +smupp1 +smupval +smupvallem +smuval +smuval2 +sn-00id +sn-00idlem1 +sn-00idlem2 +sn-00idlem3 +sn-0lt1 +sn-0ne2 +sn-0tie0 +sn-1ne2 +sn-1ticom +sn-addcan2d +sn-addcand +sn-addgt0d +sn-addid0 +sn-addlid +sn-addlt0d +sn-addrid +sn-axprlem3 +sn-axrep5v +sn-base0 +sn-eluzp1l +sn-exelalt +sn-inelr +sn-iotalem +sn-iotalemcor +sn-isghm +sn-it0e0 +sn-it1ei +sn-itrere +sn-ltaddneg +sn-ltaddpos +sn-ltmul2d +sn-ltmulgt11d +sn-ltp1 +sn-msqgt0d +sn-mul01 +sn-mul02 +sn-mulgt1d +sn-mullid +sn-mullt0d +sn-negex +sn-negex12 +sn-negex2 +sn-nnne0 +sn-recgt0d +sn-reclt0d +sn-redivcld +sn-remul0ord +sn-rereccld +sn-retire +sn-subcl +sn-subeu +sn-subf +sn-sup2 +sn-sup3d +sn-suprcld +sn-suprubd +sn-wcdeq +sn0cld +sn0top +sn0topon +sn1dom +snatpsubn +sncld +sncldre +snclseqg +snct +snd +sndcart_add +sndcart_cmul +sndcart_component +sndcart_neg +sndcart_pastecart +sndcart_sub +sndcart_vec +sndcart_vsum +sndisj +snec +snecg +snelmap +snelpw +snelpwg +snelpwi +snelpwrvd +snelsingles +snen1el +snen1g +sneq +sneqbg +sneqd +sneqi +sneqr +sneqrg +snex +snexalt +snexg +snfbas +snfi +snfil +snhesn +snid +snidb +snidg +sniffsupp +snifpsrbag +sniota +snjust +snlindsntor +snlindsntorlem +snmapen +snmapen1 +snmbl +snmlff +snmlflim +snmlfval +snmlval +snn0d +snnen2o +snnex +snnz +snnzb +snnzg +snoc_append +snoc_axiom +snoc_induct_tac +snoccast +snoclistappend +snoclistmap +snoclistreverse +snocnil +snopeqop +snopeqopsnid +snopfsupp +snopiswrd +snopsuppss +snprc +snres0 +snriota +snsn0non +snss +snssb +snssd +snssg +snssi +snssialt +snssialtvd +snssl +snsslvd +snsspr1 +snsspr2 +snsspw +snsssn +snsssng +snsstp1 +snsstp2 +snsstp3 +snstriedgval +snstrvtxval +snsymgefmndeq +snunico +snunioc +snunioo +snunioo1 +snvonmbl +snwf +so +so0 +so2nr +so3nr +soasym +socnv +socrates +soeq1 +soeq12d +soeq2 +soex +sofld +softmax_sum_one +soinxp +soirri +soisoi +soisores +solar_panel_layout +solin +solovay_lemma +solovay_proforma +solovay_proforma_eq +solovay_vector_tac +soltmin +solution +solutions_are_xy +solutions_induction +solves +some +somin1 +somin2 +somincom +somo +son2lpi +sonr +sopo +sornom +sorpss +sorpsscmpl +sorpssi +sorpssin +sorpssint +sorpssun +sorpssuni +sort +sort_lem +sort_map_bij +sort_map_def +sort_preserves_elements +sort_spec +sorted +sorted_append +sorted_cons +sorted_insert +sorted_rev_append +sorted_reverse_cons +sorted_reverse_cons2 +sorted_reverse_mem +sorted_sort +sortedseq +soseq +sosn +soss +sossfld +sotr +sotr2 +sotr3 +sotrd +sotri +sotri2 +sotri3 +sotric +sotrieq +sotrieq2 +sotrine +source +source_coding +soxp +sp +spaev +spalt +span0 +span_0 +span_2 +span_3 +span_add +span_add_eq +span_affine_hull_insert +span_breakdown +span_breakdown_eq +span_card_ge_dim +span_clauses +span_columnspace +span_conic_hull +span_convex_cone_allsigns +span_convex_hull +span_delete_0 +span_empty +span_eq +span_eq_dim +span_eq_insert +span_eq_self +span_explicit +span_finite +span_image_scale +span_inc +span_induct +span_induct_alt +span_insert_0 +span_linear_image +span_mono +span_mul +span_mul_eq +span_neg +span_neg_eq +span_not_univ_orthogonal +span_not_univ_subset_hyperplane +span_of_subspace +span_open +span_pcross +span_pcross_subset +span_sing +span_span +span_special_scale +span_stdbasis +span_sub +span_subset_subspace +span_subspace +span_sums +span_superset +span_trans +span_union +span_union_subset +span_univ +span_vsum +spancl +spanid +spanning_subset_independent +spanning_surjective_image +spanpr +spans_image +spansn +spansn0 +spansna +spansnch +spansnchi +spansncol +spansncv +spansncv2 +spansncvi +spansneleq +spansneleqi +spansni +spansnid +spansnj +spansnji +spansnm0i +spansnmul +spansnpji +spansnscl +spansnsh +spansnss +spansnss2 +spanss +spanss2 +spanssoc +spanun +spanuni +spanunsni +spanval +spc2d +spc2ed +spc2egv +spc2ev +spc2gv +spc3egv +spc3gv +spcdv +spcdvw +spcedv +spcegf +spcegv +spcev +spcgf +spcgft +spcgv +spcimdv +spcimedv +spcimegf +spcimgf +spcimgfi1 +spcimgfi1old +spcimgft +spcv +spd +spdx +spec +spec_all +spec_tac +speccl +special_hyperplane_span +specl +spectrum_allocation +specval +spei +speimfw +speimfwalt +speiv +speivw +spesbc +spesbcd +spesbcdi +spfalw +spfw +sphere +sphere_1 +sphere_empty +sphere_eq_empty +sphere_eq_sing +sphere_linear_image +sphere_scaling +sphere_sing +sphere_subset_cball +sphere_subset_convex +sphere_translation +sphere_union_ball +spheres +spi +spim +spime +spimed +spimedv +spimefv +spimev +spimevw +spimew +spimfv +spimfw +spimt +spimv +spimvalt +spimvw +spimw +splcl +splfv1 +splfv2a +splfv3 +splid +split +split_aux_spec +split_join +split_spec +splitat +splitatpki_append +splitatpki_change_predicate +splitatpki_eqn +splitatpki_map +splitatpki_rand +spllen +splval +splval2 +splysubrg +splyval +spnfw +sports_league +spr0el +spr0nelg +sprbisymrel +sprel +sprid +sprmpod +sprssspr +sprsymrelen +sprsymrelf +sprsymrelf1 +sprsymrelf1lem +sprsymrelf1o +sprsymrelfo +sprsymrelfolem1 +sprsymrelfolem2 +sprsymrelfv +sprsymrelfvlem +sprval +sprvalpw +sprvalpwle2 +sprvalpwn0 +sps +sps-o +sps3wwlks2on +spsbbi +spsbc +spsbcd +spsbcdi +spsbce-2 +spsbe +spsbim +spsd +spsv +spthcycl +spthdep +spthdifv +spthispth +spthiswlk +spthonepeq +spthonisspth +spthonprop +spthonpthon +spthsfval +spthson +sptruw +spv +spvv +spvw +spw +sq0 +sq01 +sq0i +sq0id +sq1 +sq10 +sq10e99m1 +sq11 +sq11d +sq11i +sq2 +sq2reunnltb +sq3 +sq3deccom12 +sq4 +sq45 +sq4e2t8 +sq5 +sq6 +sq7 +sq8 +sq9 +sq_0 +sq_1 +sq_abs +sq_abs_neg +sq_div +sq_eq +sq_eq_0 +sq_eq_abs +sq_eq_rew +sq_expt2 +sq_ge +sq_ge_abs +sq_gt +sq_gt_0 +sq_gt_abs +sq_le +sq_le_abs +sq_lt +sq_lt_abs +sq_minus +sq_neg +sq_neg_minus +sq_neg_pos_le +sq_neg_pos_lt +sq_nonneg +sq_plus +sq_plus_eq_0 +sq_plus_pos +sq_pos +sq_rew +sq_sqrt +sq_times +sq_zero +sqabs +sqabsadd +sqabsaddi +sqabssub +sqabssubi +sqcl +sqcld +sqcli +sqcn +sqdeccom12 +sqdiv +sqdivd +sqdivi +sqdivid +sqdivzi +sqeq0 +sqeq0d +sqeq0i +sqeqd +sqeqor +sqeqori +sqf11 +sqff1o +sqfpc +sqgcd +sqge0 +sqge0d +sqge0i +sqgt0 +sqgt0d +sqgt0i +sqgt0sr +sqlecan +sqmid3api +sqmul +sqmuld +sqmuli +sqn0rp +sqn5i +sqn5ii +sqne0 +sqneg +sqnegd +sqnorm_le_max_eigenvector_span +sqnorm_pastecart +sqnprm +sqoddm1div8 +sqoddm1div8z +sqr00d +sqr11d +sqr_nonneg +sqrecd +sqrecii +sqreu +sqreulem +sqrlearg +sqrmo +sqrt0 +sqrt00 +sqrt1 +sqrt11 +sqrt11i +sqrt2cxp2logb9e3 +sqrt2gt1lt2 +sqrt2irr +sqrt2irr0 +sqrt2irrlem +sqrt2re +sqrt4 +sqrt9 +sqrt_0 +sqrt_1 +sqrt_div +sqrt_eq +sqrt_extraction +sqrt_inj +sqrt_inv +sqrt_linear_eq +sqrt_mono_le +sqrt_mono_le_eq +sqrt_mono_lt +sqrt_mono_lt_eq +sqrt_mul +sqrt_mult +sqrt_pos_le +sqrt_pos_lt +sqrt_pos_ne +sqrt_pos_uniq +sqrt_positive +sqrt_pow2 +sqrt_pow_2 +sqrt_pow_2_abs +sqrt_sq +sqrt_unique +sqrtcl +sqrtcld +sqrtcli +sqrtcn +sqrtcval +sqrtcval2 +sqrtcvallem1 +sqrtcvallem2 +sqrtcvallem3 +sqrtcvallem4 +sqrtcvallem5 +sqrtdiv +sqrtdivd +sqrtf +sqrtge0 +sqrtge0d +sqrtge0i +sqrtgt0 +sqrtgt0d +sqrtgt0i +sqrtgt0ii +sqrtle +sqrtled +sqrtlei +sqrtlim +sqrtlt +sqrtltd +sqrtlti +sqrtm1 +sqrtmsq +sqrtmsq2i +sqrtmsqd +sqrtmsqi +sqrtmul +sqrtmuld +sqrtmuli +sqrtmulii +sqrtneg +sqrtnegd +sqrtneglem +sqrtnegnre +sqrtpclii +sqrtpwpw2p +sqrtrege0 +sqrtrege0d +sqrtsq +sqrtsq2 +sqrtsq2d +sqrtsqd +sqrtsqi +sqrtth +sqrtthi +sqrtthlem +sqrtval +sqsqrtd +sqsqrti +sqsscirc1 +sqsscirc2 +sqsubswap +sqsumi +square_integral_square_integrable_product_le +square_roots +squeeze +squeeze0 +squeeze_theorem +squeezedltsq +sqval +sqvald +sqvali +sqwvfoura +sqwvfourb +sqxpeqd +sqxpexg +sra1r +sraaddg +sraassa +sraassab +sraassaold +srabase +srabn +sradrng +srads +srafldlvec +sraidom +sraip +sralem +sralmod +sralmod0 +sralvec +sramulr +sranlm +srapwov +sraring +srasca +srasubrg +sratopn +sratset +sraval +sravsca +srcmpltd +srg0cl +srg1expzeq1 +srg1zr +srgacl +srgass +srgbinom +srgbinomlem +srgbinomlem1 +srgbinomlem2 +srgbinomlem3 +srgbinomlem4 +srgcl +srgcmn +srgcom +srgcom4 +srgcom4lem +srgdi +srgdilem +srgdir +srgen1zr +srgfcl +srgidcl +srgideu +srgidmlem +srgisid +srglidm +srglmhm +srglz +srgmgp +srgmnd +srgmulgass +srgo2times +srgpcomp +srgpcompp +srgpcomppsc +srgridm +srgrmhm +srgrz +srgsummulcr +srhmsubc +srhmsubcaltv +srhmsubcaltvlem1 +srhmsubcaltvlem2 +srhmsubclem1 +srhmsubclem2 +srhmsubclem3 +sringcat +sringcataltv +srng0 +srng1 +srngadd +srngbase +srngcl +srngcnv +srngf1o +srnginvl +srngmul +srngmulr +srngnvl +srngplusg +srngrhm +srngring +srngstr +srossspw +srw_tac +ss +ss-ax8 +ss0 +ss0b +ss2ab +ss2abdv +ss2abi +ss2abim +ss2in +ss2iun +ss2iundf +ss2iundv +ss2ixp +ss2mcls +ss2rab +ss2rabd +ss2rabdf +ss2rabdv +ss2rabi +ss2ralv +ss2rexv +ssab +ssab2 +ssabdv +ssabf +ssabral +ssabso +ssbl +ssblex +ssblps +ssbnd +ssbr +ssbrd +ssbri +ssc1 +ssc2 +ssccatid +ssceq +sscfn1 +sscfn2 +sscid +ssclaxsep +ssclem +sscls +sscmp +sscntz +sscoid +sscon +sscon34b +ssconb +sscond +sscpwex +sscrel +sscres +ssct +ssctr +ssd +ssdec +ssdf +ssdf2 +ssdif +ssdif0 +ssdif2d +ssdifcl +ssdifd +ssdifeq0 +ssdifidl +ssdifidllem +ssdifidlprm +ssdifim +ssdifin0 +ssdifsn +ssdifss +ssdifssd +ssdifsym +ssdisj +ssdisjd +ssdisjdr +ssdmd1 +ssdmd2 +ssdmral +ssdmres +ssdomfi +ssdomfi2 +ssdomg +ssel +ssel2 +sseld +sselda +sseldd +sseli +sselialt +sselid +sselii +sselpwd +ssenen +sseq0 +sseq1 +sseq12 +sseq12d +sseq12i +sseq1d +sseq1i +sseq2 +sseq2d +sseq2i +sseqf +sseqfn +sseqfres +sseqfv1 +sseqfv2 +sseqin2 +sseqmw +sseqp1 +sseqtrd +sseqtrdi +sseqtri +sseqtrid +sseqtrrd +sseqtrrdi +sseqtrri +sseqtrrid +ssequn1 +ssequn2 +sseqval +ssex +ssexd +ssexg +ssexi +ssexnelpss +ssext +ssextss +ssfg +ssfi +ssfialt +ssficl +ssfid +ssfii +ssfin2 +ssfin3ds +ssfin4 +ssfiunibd +ssfz12 +ssfzo12 +ssfzo12bi +ssfzoulel +ssfzunsn +ssfzunsnext +sshaus +sshauslem +sshepw +sshhococi +sshjcl +sshjval +sshjval2 +sshjval3 +ssid +ssidcn +ssidd +ssiin +ssiinf +ssimaex +ssimaexg +ssin +ssin0 +ssinc +ssind +ssindif0 +ssini +ssinss1 +ssinss1d +ssinss2d +ssint +ssintab +ssintrab +ssintub +ssipeq +ssiun +ssiun2 +ssiun2s +ssiun2sf +ssiun3 +ssjo +sslin +sslm +ssmapsn +ssmcls +ssmclslem +ssmd1 +ssmd2 +ssmin +ssmxidl +ssmxidllem +ssn0 +ssn0rex +ssnct +ssnei +ssnei2 +ssnel +ssneld +ssneldd +ssnelpss +ssnelpssd +ssnlim +ssnmz +ssnn0fi +ssnn0ssfz +ssnnf1octb +ssnnfi +ssnnssfz +ssnpss +ssntr +ssnum +ssoninhaus +ssonprc +ssonuni +ssonunii +ssopab2 +ssopab2b +ssopab2bw +ssopab2dv +ssopab2i +ssoprab2 +ssoprab2b +ssoprab2i +ssorduni +sspadd1 +sspadd2 +sspba +sspec_tac +sspg +sspgval +sspid +sspims +sspimsval +sspm +sspmaplubn +sspmlem +sspmval +sspn +sspnv +sspnval +sspr +sspred +sspreima +ssprss +ssprsseq +ssps +sspss +sspsstr +sspsstrd +sspsstri +sspsval +sspval +sspw +sspwb +sspwd +sspwi +sspwimp +sspwimpalt +sspwimpalt2 +sspwimpcf +sspwimpcfvd +sspwimpvd +sspwtr +sspwtralt +sspwtralt2 +sspwuni +sspz +ssrab +ssrab2 +ssrab2f +ssrab3 +ssrabdf +ssrabdv +ssrabeq +ssrabf +ssrabi +ssralv +ssralv2 +ssralv2vd +ssralvold +ssrankr1 +ssrd +ssrdv +ssrecnpr +ssref +ssrel +ssrel2 +ssrel3 +ssrelf +ssrelrel +ssrelrn +ssres +ssres2 +ssrest +ssrexf +ssrexr +ssrexv +ssrexvold +ssrin +ssrind +ssriv +ssrmof +ssrnres +sssalgen +ssscongptld +sssigagen +sssigagen2 +ssslts1 +ssslts2 +sssmf +sssmfmpt +sssn +sssseq +sssucid +sssymdifcl +sst0 +sst1 +sstotbnd +sstotbnd2 +sstotbnd3 +sstp +sstr +sstr2 +sstr2old +sstralt2 +sstralt2vd +sstrd +sstrdi +sstri +sstrid +sstskm +ssttrcl +ssufl +ssun +ssun1 +ssun2 +ssun3 +ssun4 +ssuncl +ssundif +ssuni +ssunib +ssunieq +ssuniint +ssunpr +ssunsn +ssunsn2 +ssuzfz +ssv +sswf +sswfaxreg +sswrd +ssxpb +ssxr +sszcld +st +st0 +stable_predicate +stack_alloc_free +stack_lifo +stack_push_pop +stackpush +stadd3i +staddi +staffn +staffval +stafval +stage +starlike_closure +starlike_compact_projective +starlike_convex_tweak_boundary_points +starlike_linear_image +starlike_linear_image_eq +starlike_negligible +starlike_negligible_bounded_measurable +starlike_negligible_lemma +starlike_negligible_strong +starlike_pcross +starlike_pcross_eq +starlike_translation_eq +starlike_univ +starvid +starvndx +starvndxnbasendx +starvndxnmulrndx +starvndxnplusgndx +state +state-m +state_left_id +state_monad +statu +status +stcl +stcltr1i +stcltr2i +stcltrlem1 +stcltrlem2 +stcltrthi +std_simplex +stdbdbl +stdbdmet +stdbdmetval +stdbdmopn +stdbdxmet +stdlib +stdpc4 +stdpc5 +stdpc5t +stdpc5v +stdpc6 +stdpc7 +steel_cutting +steiner_triple +steinhaus +steinhaus_diffs +steinhaus_lebesgue +steinhaus_sums +step +step_down_lemma +step_down_lemma_4 +step_down_lemma_4_asym +step_down_lemma_strong +step_down_lemma_strong_asym +stepanov +stepanov_gen +stepanov_univ +sterbenz_lemma +stge0 +stge1i +stgoldbnnsum4prm +stgoldbwt +stgr0 +stgr1 +stgrclnbgr0 +stgredg +stgredgel +stgredgiun +stgrfv +stgriedg +stgrnbgr0 +stgrorder +stgrusgra +stgrvtx +stgrvtx0 +sthil +sticksstones1 +sticksstones10 +sticksstones11 +sticksstones12 +sticksstones12a +sticksstones13 +sticksstones14 +sticksstones15 +sticksstones16 +sticksstones17 +sticksstones18 +sticksstones19 +sticksstones2 +sticksstones20 +sticksstones21 +sticksstones22 +sticksstones23 +sticksstones3 +sticksstones4 +sticksstones5 +sticksstones6 +sticksstones7 +sticksstones8 +sticksstones9 +sticl +stirling +stirlinglem1 +stirlinglem10 +stirlinglem11 +stirlinglem12 +stirlinglem13 +stirlinglem14 +stirlinglem15 +stirlinglem2 +stirlinglem3 +stirlinglem4 +stirlinglem5 +stirlinglem6 +stirlinglem7 +stirlinglem8 +stirlinglem9 +stirlingr +stj +stji1i +stle0i +stle1 +stlei +stlesi +stm1add3i +stm1addi +stm1i +stm1ri +sto1i +sto2i +stoic1a +stoic1b +stoic2a +stoic2b +stoic3 +stoic4a +stoic4b +stoig +store +stowei +stoweid +stoweidlem1 +stoweidlem10 +stoweidlem11 +stoweidlem12 +stoweidlem13 +stoweidlem14 +stoweidlem15 +stoweidlem16 +stoweidlem17 +stoweidlem18 +stoweidlem19 +stoweidlem2 +stoweidlem20 +stoweidlem21 +stoweidlem22 +stoweidlem23 +stoweidlem24 +stoweidlem25 +stoweidlem26 +stoweidlem27 +stoweidlem28 +stoweidlem29 +stoweidlem3 +stoweidlem30 +stoweidlem31 +stoweidlem32 +stoweidlem33 +stoweidlem34 +stoweidlem35 +stoweidlem36 +stoweidlem37 +stoweidlem38 +stoweidlem39 +stoweidlem4 +stoweidlem40 +stoweidlem41 +stoweidlem42 +stoweidlem43 +stoweidlem44 +stoweidlem45 +stoweidlem46 +stoweidlem47 +stoweidlem48 +stoweidlem49 +stoweidlem5 +stoweidlem50 +stoweidlem51 +stoweidlem52 +stoweidlem53 +stoweidlem54 +stoweidlem55 +stoweidlem56 +stoweidlem57 +stoweidlem58 +stoweidlem59 +stoweidlem6 +stoweidlem60 +stoweidlem61 +stoweidlem62 +stoweidlem7 +stoweidlem8 +stoweidlem9 +str0 +strategy_winning +strb +strcat +strcat_acyclic +strcat_eqns +strcat_explode +stream +strengthenweaken +stretch_galois +strfv +strfv2 +strfv2d +strfv3 +strfvd +strfvi +strfvn +strfvnd +strfvss +stri +strictly +strictly_increasing_one_one +strictly_increasing_unbounded +string_acyclic +string_length_append +string_lt_antisym +string_lt_cases +string_lt_llex +string_lt_nonrefl +string_lt_trans +string_sub_valid +strip-cars-acons +strip-cdrs-acons +strip_assume_tac +strip_tac +strle1 +strle2 +strle3 +strlem1 +strlem2 +strlem3 +strlem3a +strlem4 +strlem5 +strlem6 +strlen_explode_thm +strleun +strndxid +strong-norm +strong_ind +strong_ind on a +strong_ind on b +strong_ind on n +stronginduction +strov2rcl +strss +strssd +struct-eq +struct2griedg +struct2grstr +struct2grvtx +struct_cases_tac +struct_ind_list +struct_ind_tree +structcnvcnv +structex +structfn +structfun +structfung +structgrssiedg +structgrssvtx +structgrssvtxlem +structiedg0val +structn0fun +structtocusgr +structtousgr +structural_contract +structural_exchange +structural_weaken +structure_eq +structvtxval +structvtxvallem +student_grouping +sub +sub1cncf +sub1cncfd +sub1m1 +sub2cncf +sub2cncfd +sub2times +sub31 +sub32 +sub32d +sub4 +sub4d +sub_0 +sub_add +sub_add_cancel +sub_cancel +sub_elim_thm +sub_eq_0 +sub_eq_eq_0 +sub_left_add +sub_left_eq +sub_left_greater +sub_left_greater_eq +sub_left_less +sub_left_less_eq +sub_left_sub +sub_left_suc +sub_less +sub_less_0 +sub_less_eq +sub_less_eq_add +sub_less_or +sub_less_or_eq +sub_less_suc +sub_mod +sub_mono_eq +sub_plus +sub_pow_2 +sub_refl +sub_right_add +sub_right_eq +sub_right_greater +sub_right_greater_eq +sub_right_less +sub_right_less_eq +sub_right_sub +sub_self +sub_self_zero +sub_sub +sub_zero +subadd +subadd2 +subadd23 +subadd23d +subadd2d +subadd2i +subadd4 +subadd4b +subadd4d +subaddd +subaddeqd +subaddi +subadditive_content_division +subaddmulsub +subaddrii +subadds +subaddsd +subbascn +subcan +subcan2 +subcan2ad +subcan2d +subcan2i +subcanad +subcand +subcani +subccat +subccatid +subccocl +subcfn +subcid +subcidcl +subcircuit(next) +subcl +subcld +subcli +subcmn +subcn +subcn2 +subcncf +subcncff +subcos +subcrcl +subcss1 +subcss2 +subcssc +subdi +subdid +subdii +subdir +subdird +subdiri +subdivcomb1 +subdivcomb2 +subdrgint +subeluzsub +subeq0 +subeq0ad +subeq0bd +subeq0d +subeq0i +subeqrev +subeqxfrd +subex +subexsub +subf +subfac0 +subfac1 +subfacf +subfaclefac +subfaclim +subfacp1 +subfacp1lem1 +subfacp1lem2a +subfacp1lem2b +subfacp1lem3 +subfacp1lem4 +subfacp1lem5 +subfacp1lem6 +subfacval +subfacval2 +subfacval3 +subfzo0 +subg0 +subg0cl +subgabl +subgacs +subgbas +subgcl +subgcld +subgdisj1 +subgdisj2 +subgdisjb +subgdmdprd +subgdprd +subge0 +subge02 +subge02d +subge0d +subge0i +subgga +subggim +subggrp +subgid +subgint +subginv +subginvcl +subglsm +subgmulg +subgmulgcl +subgmulgcld +subgngp +subgnm +subgnm2 +subgntr +subgoal_tac +subgoal_then +subgod +subgpgp +subgrcl +subgrcycl +subgreldmiedg +subgrfun +subgroup_closed +subgroup_criterion +subgroupaxiom +subgrprop +subgrprop2 +subgrprop3 +subgrpth +subgrtrl +subgruhgredgd +subgruhgrfun +subgrv +subgrwlk +subgslw +subgss +subgsub +subgsubcl +subgsubcld +subgsubm +subgtgp +subhalfhalf +subid +subid1 +subid1d +subid1i +subidd +subidi +subinterval_mean_value_theorem +subinterval_mean_value_theorem_alt +subinterval_mean_value_theorem_seq +subislly +subiwrd +subiwrdlen +suble +suble0 +suble0d +subled +sublevolico +sublimc +sublt0d +subm0 +subm0cl +submabas +submacs +submaeval +submafval +submarchi +submat1n +submateq +submateqlem1 +submateqlem2 +submatminr1 +submatres +submatroid_subset +submaval +submaval0 +submbas +submcl +submcld +submcmn +submcmn2 +submefmnd +submetric +submgmacs +submgmbas +submgmcl +submgmid +submgmmgm +submgmrcl +submgmss +submid +submmnd +submmulg +submmulgcl +submnd0 +submod +submodaddmod +submodlt +submodneaddmod +submomnd +submrc +submrcl +submre +submss +submtmd +submul2 +submuladdd +submuladdmuld +subne0ad +subne0d +subne0nn +subneg +subnegd +subnegi +subneintr2d +subneintrd +subofld +subopnmbl +subordinate_partition_of_unity +suborng +subrdom +subrec +subrecd +subreci +subresre +subrfld +subrfn +subrfv +subrg0 +subrg1 +subrg1ascl +subrg1asclcl +subrg1cl +subrgacl +subrgacs +subrgascl +subrgasclcl +subrgbas +subrgchr +subrgcrng +subrgdv +subrgdvds +subrgid +subrgin +subrgint +subrginv +subrgmcl +subrgmcld +subrgmpl +subrgmre +subrgmvr +subrgmvrf +subrgnrg +subrgnzr +subrgply1 +subrgpropd +subrgpsr +subrgrcl +subrgring +subrgss +subrgsubg +subrgsubm +subrgsubrng +subrgugrp +subrgunit +subrguss +subrgvr1 +subrgvr1cl +subridom +subrng0 +subrngacl +subrngbas +subrngid +subrngin +subrngint +subrngmcl +subrngmre +subrngpropd +subrngrcl +subrngringnsg +subrngrng +subrngss +subrngsubg +subrval +subs_conv +subsaliuncl +subsaliuncllem +subsalsal +subsaluni +subscan1d +subscan2d +subscl +subscld +subsdid +subsdird +subsdrg +subseq0d +subsequence_diagonalization_lemma +subset +subset_add +subset_antisym +subset_antisym_eq +subset_ball +subset_balls +subset_biginter +subset_bigunion +subset_bigunion_i +subset_bigunion_subset_i +subset_cball +subset_closure +subset_commuting_itset_insert +subset_commuting_itset_recurses +subset_commuting_itset_reduction +subset_compact_hausdist_limit +subset_convex_hull_frontier +subset_convex_hull_relative_frontier +subset_count_max_set +subset_countable +subset_cross +subset_delete +subset_delete_both +subset_diff +subset_diff_empty +subset_disjoint +subset_drop_image +subset_empty +subset_eq_card +subset_face_of_simplex +subset_finite +subset_finite_i +subset_halfspaces_imp_collinear +subset_hull +subset_hyperplanes +subset_image +subset_insert +subset_insert_delete +subset_insert_right +subset_inter +subset_inter1 +subset_inter2 +subset_inter_absorption +subset_inter_left +subset_interior +subset_interior_eq +subset_interval +subset_interval_1 +subset_interval_imp +subset_k +subset_le_dim +subset_lift_image +subset_max_set +subset_min_set +subset_of_face_of +subset_of_face_of_affine_hull +subset_pcross +subset_pow +subset_psubset_trans +subset_refl +subset_reflexive +subset_relative_interior +subset_relative_interior_intersecting_convex +subset_restrict +subset_second_countable +subset_segment +subset_segment_open_closed +subset_sing +subset_sums_lcancel +subset_sums_rcancel +subset_thm +subset_trans +subset_transitive +subset_union +subset_union_absorption +subset_union_left +subset_univ +subsf +subsfn +subsfo +subsge0d +subsid +subsid1 +subsin +subspace_0 +subspace_add +subspace_bounded_eq_trivial +subspace_convex_cone_symmetric +subspace_eq_affine +subspace_exists +subspace_hyperplane +subspace_imp_affine +subspace_imp_conic +subspace_imp_convex +subspace_imp_convex_cone +subspace_imp_nonempty +subspace_inter +subspace_inters +subspace_isomorphism +subspace_kernel +subspace_linear_fixed_points +subspace_linear_image +subspace_linear_image_eq +subspace_linear_preimage +subspace_mul +subspace_mul_eq +subspace_neg +subspace_neg_eq +subspace_orthogonal_to_vector +subspace_orthogonal_to_vectors +subspace_pcross +subspace_pcross_eq +subspace_span +subspace_special_hyperplane +subspace_sub +subspace_substandard +subspace_sums +subspace_translation_self +subspace_translation_self_eq +subspace_trivial +subspace_union_chain +subspace_univ +subspace_vsum +subspopn +subsq +subsq0i +subsq2 +subsqi +subst +subst-lemma +subst1_tac +subst_all_tac +subst_lemma +subst_occs_tac +subst_tac +substitution +subsub +subsub2 +subsub23 +subsub23d +subsub23i +subsub2d +subsub3 +subsub3d +subsub4 +subsub4d +subsubadd23 +subsubc +subsubd +subsubelfzo0 +subsubg +subsubm +subsubmgm +subsubrg +subsubrg2 +subsubrng +subsubrng2 +subsubs2d +subsubs4d +subsval +subsvald +subsym1 +subthinc +subtopology_eq_discrete_topology_finite +subtopology_euclidean_eq_discrete_topology_finite +subtopology_subtopology +subtopology_univ +subtr +subtr2 +subtype +subtype_refl +subtype_trans +subtyperefl +subtypetrans +subuhgr +subumgr +subumgredg2 +subupgr +subusgr +subval +suc +suc0 +suc11 +suc11reg +suc_add_sym +suc_elim_numerals +suc_elim_thm +suc_inj +suc_lt +suc_minus_numeral +suc_mod +suc_not_zero +suc_one_add +suc_pre +suc_sub1 +succ_mul +succlg +sucdifsn +sucdifsn2 +sucdom +sucdom2 +sucel +suceldisj +suceq +suceqd +suceqsneq +sucex +sucexb +sucexeloni +sucexg +sucid +sucidalt +sucidaltvd +sucidg +sucidvd +sucmapleftuniq +sucmapsuc +sucneqond +sucneqoni +sucomisnotcard +sucon +sucprc +sucprcreg +sucpre +sucssel +suctr +suctralt +suctralt2 +suctralt2vd +suctralt3 +suctraltcf +suctraltcfvd +sucunisn +sucxpdom +sudoku +suff_tac +sum +sum(allocation) = 1.0 +sum(i in 1..n)(square[i,i]) = magic_sum +sum(mix) = 1.0 +sum-constants +sum.cong +sum.delta +sum.swap +sum0 +sum2dchr +sum2id +sum9cubes +sum_0 +sum_1 +sum_2 +sum_3 +sum_4 +sum_abs +sum_abs_le +sum_acc_sum_lem +sum_add +sum_add_gen +sum_add_numseg +sum_add_split +sum_append +sum_bound +sum_cancel +sum_cases +sum_clauses +sum_clauses_left +sum_clauses_numseg +sum_cmul +sum_combine_l +sum_combine_r +sum_cong_eq +sum_cons +sum_const +sum_const_numseg +sum_content_area_over_thin_division +sum_degenerate +sum_delete +sum_delta +sum_delta_finite +sum_diff +sum_diffs +sum_distrib_left +sum_distrib_right +sum_elim +sum_eq +sum_eq_0 +sum_eq_general +sum_eq_general_inverses +sum_eq_numseg +sum_fib_acc_spec +sum_first_n +sum_formula +sum_group +sum_group_relation +sum_image +sum_image_add +sum_image_constant +sum_image_delete +sum_image_disjoint +sum_image_empty +sum_image_eq_sum_map_set_to_list +sum_image_gen +sum_image_in_le +sum_image_inj_o +sum_image_insert +sum_image_le +sum_image_list_to_set_upper_bound +sum_image_lower_bound +sum_image_mono_less +sum_image_mono_less_eq +sum_image_mono_lt +sum_image_nonzero +sum_image_permutes +sum_image_sing +sum_image_subset_le +sum_image_thm +sum_image_union +sum_image_union_eqn +sum_image_upper_bound +sum_image_zero +sum_incl_excl +sum_injection +sum_le +sum_le_included +sum_le_numseg +sum_list_app +sum_lmul +sum_lt +sum_map_foldl +sum_map_mem_bound +sum_map_plus +sum_map_plus_zip +sum_mul_bound +sum_neg +sum_nil +sum_nsub +sum_of_squares +sum_offset +sum_over_permutations_insert +sum_over_tagged_division_lemma +sum_over_tagged_partial_division_lemma +sum_pair +sum_permutations_compose_r +sum_permutations_inverse +sum_permute_0 +sum_pick +sum_pos +sum_pos_gen +sum_pos_le +sum_pos_le_numseg +sum_pos_lt +sum_pos_lt_all +sum_range_formula +sum_reindex +sum_restrict_set +sum_rmul +sum_same_image +sum_set_count +sum_set_count_2 +sum_set_delete +sum_set_in_le +sum_set_insert +sum_set_subset_le +sum_set_thm +sum_set_union +sum_sing +sum_sing_numseg +sum_snoc +sum_split +sum_squared +sum_sub +sum_sub_numseg +sum_subst +sum_sum_acc +sum_sum_product +sum_superset +sum_swap +sum_swap_double +sum_swap_numseg +sum_to_formula +sum_triv_numseg +sum_two +sum_type_comm +sum_union +sum_union_disjoint +sum_union_nonzero +sum_univ +sum_vsum +sum_zero +sumarray +sumcubes +sumdchr +sumdchr2 +sumdmdi +sumdmdii +sumdmdlem +sumdmdlem2 +sumempty +sumeq1 +sumeq12dv +sumeq12i +sumeq12rdv +sumeq12sdv +sumeq12si +sumeq1d +sumeq1i +sumeq2 +sumeq2d +sumeq2dv +sumeq2i +sumeq2ii +sumeq2sdv +sumeq2sdvold +sumeq2si +sumeq2w +sumeven +sumex +sumfc +sumformula +sumhash +summable_0 +summable_add +summable_bilinear_left +summable_bilinear_partial_pre +summable_bilinear_right +summable_cauchy +summable_cmul +summable_comparison +summable_component +summable_eq +summable_eq_cofinite +summable_eq_eventually +summable_even +summable_finite +summable_from_elsewhere +summable_from_elsewhere_eq +summable_iff +summable_iff_cofinite +summable_iff_eventually +summable_imp_bounded +summable_imp_sums_bounded +summable_imp_tozero +summable_linear +summable_neg +summable_odd +summable_ratio +summable_real_gp +summable_rearrange +summable_reindex +summable_restrict +summable_sub +summable_subset +summable_subset_absconv +summable_trivial +summo +summodnegmod +summolem2 +summolem2a +summolem3 +sumnnodd +sumno +sumnul +sumodd +sumpair +sumpr +sumrb +sumrblem +sums_0 +sums_assoc +sums_eq +sums_finite_diff +sums_finite_union +sums_iff +sums_infsum +sums_intervals +sums_lim +sums_offset +sums_offset_rev +sums_reindex +sums_reindex_gen +sums_summable +sums_sym +sumsn +sumsnd +sumsnf +sumsns +sumspansn +sumsplit +sumsqeq0 +sumss +sumss2 +sumtp +sumyes +sumz +sup +sup0 +sup00 +sup0riota +sup2 +sup3 +sup3ii +sup_closure +sup_epsilon +sup_eq +sup_finite +sup_insert +sup_insert_finite +sup_lemma1 +sup_lemma2 +sup_lemma3 +sup_lt_epsilon +sup_sing +sup_union +sup_unique +supadd +supaddc +supcl +supclt +supcnvlimsup +supcnvlimsupmpt +supcvg +supeq1 +supeq123d +supeq1d +supeq1i +supeq2 +supeq3 +superficl +superpos +superuncl +supeu +supex +supex2g +supexd +supexpr +supfil +supfirege +supfz +supgtoreq +supicc +supicclub +supicclub2 +supiccub +supinf +supiso +supisoex +supisolem +suplem1pr +suplem2pr +suplesup +suplesup2 +suplub +suplub2 +supmax +supminf +supminfrnmpt +supminfxr +supminfxr2 +supminfxrrnmpt +supmo +supmul +supmul1 +supmullem1 +supmullem2 +supnfcls +supnub +supp0 +supp0cosupp0 +supp0prc +suppco +suppcoss +suppdm +suppeqfsuppbi +suppfnss +suppimacnv +suppimacnvss +suppiniseg +supply_chain +suppmptcfin +suppofss1d +suppofss2d +suppofssd +supporting_hyperplane_closed_point +supporting_hyperplane_compact_point_inf +supporting_hyperplane_compact_point_sup +supporting_hyperplane_frontier +supporting_hyperplane_point +supporting_hyperplane_relative_boundary +supporting_hyperplane_relative_frontier +suppose +suppovss +supppreima +suppr +suppsnop +suppss +suppss2 +suppss2f +suppss3 +suppssdm +suppssfifsupp +suppssfv +suppssfz +suppssnn0 +suppssof1 +suppssov1 +suppssov2 +suppssr +suppssrg +suppsssn +suppun +suppun2 +suppval +suppval1 +suppvalbr +suppvalfn +suppvalfng +suprcl +suprcld +suprclii +suprclrnmpt +suprfinzcl +suprleub +suprleubii +suprleubrd +suprleubrnmpt +suprltrp +suprlub +suprlubii +suprlubrd +suprnmpt +suprnub +suprnubii +suprub +suprubd +suprubii +suprubrnmpt +suprubrnmpt2 +suprzcl +suprzcl2 +suprzub +supsn +supsr +supsrlem +supssd +supsubc +supub +supubt +supval2 +supxr +supxr2 +supxrbnd +supxrbnd1 +supxrbnd2 +supxrcl +supxrcld +supxrcli +supxrge +supxrgelem +supxrgere +supxrgtmnf +supxrleub +supxrleubrnmpt +supxrleubrnmptf +supxrltinfxr +supxrlub +supxrmnf +supxrmnf2 +supxrnemnf +supxrpnf +supxrre +supxrre1 +supxrre2 +supxrre3 +supxrre3rnmpt +supxrrernmpt +supxrss +supxrub +supxrubd +supxrun +supxrunb1 +supxrunb2 +supxrunb3 +surgery_scheduling +surj_card +surj_compose +surj_cong +surj_element +surj_empty +surj_id +surj_imp_inj +surj_inj_inv +surjective_exists_thm +surjective_forall_thm +surjective_iff_injective +surjective_iff_injective_gen +surjective_image +surjective_image_eq +surjective_image_thm +surjective_map +surjective_right_inverse +surjective_scaling +sursubmefmnd +suslin_inter +suslin_inters +suslin_lebesgue_measurable +suslin_mono +suslin_regular +suslin_superset +suslin_suslin +suslin_union +suslin_unions +sussmann_open_mapping +svrelfun +swap_correct +swap_exists_thm +swap_forall_thm +swap_idempotent +swap_refl +swap_reverse +swap_reverse_sym +swap_spec +swapciso +swapf1 +swapf1a +swapf1f1o +swapf1val +swapf1vala +swapf2 +swapf2a +swapf2f1o +swapf2f1oa +swapf2f1oaalt +swapf2fn +swapf2fval +swapf2fvala +swapf2val +swapf2vala +swapfcoa +swapfelvv +swapfffth +swapffunc +swapffunca +swapfid +swapfida +swapfiso +swapfval +swapswap +swoer +swoord1 +swoord2 +swopo +swopolem +swoso +swrd0 +swrd00 +swrd2lsw +swrdccat +swrdccat2 +swrdccat3b +swrdccat3blem +swrdccatfn +swrdccatin1 +swrdccatin1d +swrdccatin2 +swrdccatin2d +swrdcl +swrdco +swrdf +swrdf1 +swrdfv +swrdfv0 +swrdfv2 +swrdlen +swrdlen2 +swrdlend +swrdlsw +swrdnd +swrdnd0 +swrdnd2 +swrdnnn0nd +swrdnznd +swrdpfx +swrdrevpfx +swrdrlen +swrdrn +swrdrn2 +swrdrn3 +swrdrndisj +swrds1 +swrds2 +swrds2m +swrdsb0eq +swrdsbslen +swrdspsleq +swrdswrd +swrdswrdlem +swrdval +swrdval2 +swrdvalfn +swrdwlk +swrdwrdsymb +sx_predn +sxbrsiga +sxbrsigalem0 +sxbrsigalem1 +sxbrsigalem2 +sxbrsigalem3 +sxbrsigalem4 +sxbrsigalem5 +sxbrsigalem6 +sxsiga +sxsigon +sxuni +sxval +sxy_predn +sxyz_predn +sygbasnfpfi +syl +syl10 +syl11 +syl1111anc +syl112anc +syl113anc +syl121anc +syl122anc +syl123anc +syl12anc +syl131anc +syl132anc +syl133anc +syl13anc +syl211anc +syl212anc +syl213anc +syl21anbrc +syl21anc +syl221anc +syl222anc +syl223anc +syl22anbrc +syl22anc +syl231anc +syl232anc +syl233anc +syl23anc +syl2an +syl2an2 +syl2an23an +syl2an2r +syl2an3an +syl2anb +syl2anbr +syl2anc +syl2anc2 +syl2and +syl2ani +syl2anr +syl2im +syl2imc +syl311anc +syl312anc +syl313anc +syl31anc +syl321anc +syl322anc +syl323anc +syl32anc +syl331anc +syl332anc +syl333anc +syl33anc +syl3an +syl3an1 +syl3an12 +syl3an132 +syl3an1b +syl3an1br +syl3an2 +syl3an2b +syl3an2br +syl3an3 +syl3an3b +syl3an3br +syl3an9b +syl3anb +syl3anbr +syl3anbrc +syl3anc +syl3anl +syl3anl1 +syl3anl2 +syl3anl3 +syl3anr1 +syl3anr2 +syl3anr3 +syl3c +syl5 +syl56 +syl5com +syl5d +syl5ibcom +syl5ibrcom +syl5imp +syl5impvd +syl6 +syl6an +syl6c +syl6ci +syl6com +syl6d +syl6mpi +syl7 +syl7bi +syl8 +syl8ib +syl9 +syl9r +sylan +sylan2 +sylan2b +sylan2br +sylan2d +sylan2i +sylan9 +sylan9bb +sylan9bbr +sylan9eq +sylan9eqr +sylan9r +sylan9req +sylan9ss +sylan9ssr +sylanb +sylanblc +sylanblrc +sylanbr +sylanbrc +sylancb +sylancbr +sylancl +sylancom +sylancr +syland +sylani +sylanl1 +sylanl2 +sylanr1 +sylanr2 +sylbb +sylbb1 +sylbb2 +sylbbr +sylbi +sylbid +sylbida +sylbir +sylbird +sylc +sylcom +syld +syld3an1 +syld3an2 +syld3an3 +syldan +syldanl +syldbl2 +syldc +syldd +sylg +sylgt +syli +sylib +sylibd +sylibr +sylibrd +syllogis +sylnbi +sylnbir +sylnib +sylnibr +sylow1 +sylow1lem1 +sylow1lem2 +sylow1lem3 +sylow1lem4 +sylow1lem5 +sylow2 +sylow2a +sylow2alem1 +sylow2alem2 +sylow2b +sylow2blem1 +sylow2blem2 +sylow2blem3 +sylow3 +sylow3lem1 +sylow3lem2 +sylow3lem3 +sylow3lem4 +sylow3lem5 +sylow3lem6 +sylsyld +sylvester_determinant_identity +sylvester_gallai +sylvester_gallai_lemma +sym +sym_conv +symdif0 +symdifass +symdifcom +symdifeq1 +symdifeq2 +symdifid +symdifv +symeq +symg1bas +symg1hash +symg2bas +symg2hash +symgbas +symgbas0 +symgbasf +symgbasf1o +symgbasfi +symgbasmap +symgcl +symgcntz +symgcom +symgcom2 +symgextf +symgextf1 +symgextf1lem +symgextf1o +symgextfo +symgextfv +symgextfve +symgextres +symgextsymg +symgfcoeu +symgfisg +symgfix2 +symgfixelq +symgfixels +symgfixelsi +symgfixf +symgfixf1 +symgfixf1o +symgfixfo +symgfixfolem1 +symgfv +symgfvne +symgga +symggen +symggen2 +symggrp +symggrplem +symghash +symgid +symginv +symgmatr01 +symgmatr01lem +symgmov1 +symgmov2 +symgov +symgplusg +symgpssefmnd +symgressbas +symgsssg +symgsubg +symgsubmefmnd +symgsubmefmndalt +symgtgp +symgtopn +symgtrf +symgtrinv +symgtset +symgval +symgvalstruct +symmetric_closure +symmetric_imp_normal_matrix +symmetric_interior +symmetric_linear_image +symmetric_matrix +symmetric_matrix_add +symmetric_matrix_cmul +symmetric_matrix_covariance +symmetric_matrix_diagonalizable_explicit +symmetric_matrix_eq_diagonalizable +symmetric_matrix_eq_diagonalizable_alt +symmetric_matrix_imp_diagonalizable +symmetric_matrix_inv +symmetric_matrix_inv_lmul +symmetric_matrix_inv_rmul +symmetric_matrix_mat +symmetric_matrix_mul +symmetric_matrix_neg +symmetric_matrix_orthogonal_eigenvectors +symmetric_matrix_similar +symmetric_matrix_sub +symmetry_eq +symquadlem +symrefref2 +symrefref3 +symrelcoss +symrelcoss2 +symrelcoss3 +symreleq +symrelim +syntax +system +t +t0dist +t0hmph +t0kq +t0sep +t0top +t1_space_euclidean +t1connperf +t1ficld +t1hmph +t1r0 +t1sep +t1sep2 +t1sncld +t1t0 +t1top +t_spec +tabs +tabulateindex +tactic +tadmit_placeholder +tag_in_interval +tagged_division_finer +tagged_division_of +tagged_division_of_alt +tagged_division_of_another +tagged_division_of_empty +tagged_division_of_finite +tagged_division_of_nontrivial +tagged_division_of_self +tagged_division_of_trivial +tagged_division_of_union_self +tagged_division_split_left_inj +tagged_division_split_right_inj +tagged_division_union +tagged_division_union_image_snd +tagged_division_union_interval +tagged_division_unions +tagged_division_unions_exists +tagged_partial_division_common_point_bound +tagged_partial_division_common_tags +tagged_partial_division_of_subset +tagged_partial_division_of_trivial +tagged_partial_division_of_union_self +tagged_partial_division_subset +tailf +tailfb +tailfval +tailini +tailval +take +take1 +take_append +take_append1 +take_append2 +take_append_drop +take_drop_swap +take_eq_rewrite +take_genlist +take_length_id_rwt +take_length_too_long +take_nil +take_splitatpki +take_sum +take_take_min +take_zero +takelength +tan0 +tan2h +tan3rdpi +tan4thpi +tan4thpiold +tanabsge +tanadd +tanaddlem +tanarg +tanatan +tancl +tancld +tangtx +tanhalfpim +tanhbnd +tanhlt1 +tanhval-named +tanneg +tannpoly +tanord +tanord1 +tanregt0 +tanrpcl +tanval +tanval2 +tanval3 +tarski-bernays-ax2 +task_assignment +taupi +taupilem1 +taupilem2 +taupilem3 +taupilemrplb +taut +taut_tac +tayl0 +taylf +taylfval +taylfvallem +taylfvallem1 +taylpf +taylpfval +taylplem1 +taylplem2 +taylply +taylply2 +taylply2old +taylpval +taylth +taylthlem1 +taylthlem2 +taylthlem2old +tb-ax1 +tb-ax2 +tb-ax3 +tbsyl +tbt +tbtru +tbw-ax1 +tbw-ax2 +tbw-ax3 +tbw-ax4 +tbw-bijust +tbw-negdf +tbwlem1 +tbwlem2 +tbwlem3 +tbwlem4 +tbwlem5 +tbwsyl +tc0 +tc00 +tc2 +tc_eq_nrc +tcel +tcfr +tchnmfval +tchplusg +tcid +tcidm +tcmin +tcp_in_order +tcphbas +tcphcph +tcphcphlem1 +tcphcphlem2 +tcphcphlem3 +tcphds +tcphex +tcphip +tcphmulr +tcphnmval +tcphphl +tcphsca +tcphsub +tcphtopn +tcphval +tcphvsca +tcrank +tcsni +tcss +tctr +tcvalg +tcwf +tdeglem1 +tdeglem2 +tdeglem3 +tdeglem4 +tdrgdrng +tdrgring +tdrgtmd +tdrgtps +tdrgtrg +tdrgunit +team +telfsum +telfsum2 +telfsumo +telfsumo2 +telgsum +telgsumfz +telgsumfz0 +telgsumfz0s +telgsumfzs +telgsumfzslem +telgsums +tendo02 +tendo0cbv +tendo0cl +tendo0co2 +tendo0mul +tendo0mulr +tendo0pl +tendo0plr +tendo0tp +tendo1mul +tendo1mulr +tendo1ne0 +tendocan +tendocl +tendocnv +tendoco2 +tendococl +tendoconid +tendocoval +tendodi1 +tendodi2 +tendoeq1 +tendoeq2 +tendoex +tendof +tendofset +tendoi +tendoi2 +tendoicbv +tendoicl +tendoid +tendoid0 +tendoidcl +tendoinvcl +tendoipl +tendoipl2 +tendolinv +tendopl +tendopl2 +tendoplass +tendoplcbv +tendoplcl +tendoplcl2 +tendoplco2 +tendoplcom +tendopltp +tendorinv +tendoset +tendospass +tendospcann +tendospcl +tendospdi1 +tendospdi2 +tendotp +tendotr +tendovalco +tendsto_alt +tendsto_alt_within +tendsto_lim +termc +termc2 +termcarweu +termcbas +termcbas2 +termcbasmo +termccd +termcciso +termccisoeu +termcfuncval +termchom +termchom2 +termchommo +termchomn0 +termcid +termcid2 +termcnatval +termcnex +termco +termcpropd +termcterm +termcterm2 +termcterm3 +termcthin +termcthind +termfucterm +terminates +termoeu1 +termoeu1w +termoeu2 +termofn +termoid +termolmd +termoo +termoo2 +termopropd +termopropdlem +termorcl +termoval +terms +test42_spec +testable +tests +tfi +tfindes +tfinds +tfinds2 +tfinds3 +tfindsd +tfindsg +tfindsg2 +tfis +tfis2 +tfis2d +tfis2f +tfis3 +tfisg +tfisi +tfr1 +tfr1a +tfr1alt +tfr2 +tfr2a +tfr2alt +tfr2b +tfr3 +tfr3alt +tfrlem1 +tfrlem10 +tfrlem11 +tfrlem12 +tfrlem13 +tfrlem14 +tfrlem15 +tfrlem16 +tfrlem3 +tfrlem3a +tfrlem4 +tfrlem5 +tfrlem6 +tfrlem7 +tfrlem8 +tfrlem9 +tfrlem9a +tfsconcat00 +tfsconcat0b +tfsconcat0i +tfsconcatb0 +tfsconcatfn +tfsconcatfo +tfsconcatfv +tfsconcatfv1 +tfsconcatfv2 +tfsconcatlem +tfsconcatrev +tfsconcatrn +tfsconcatrnss +tfsconcatrnss12 +tfsconcatrnsson +tfsconcatun +tfsnfin +tfsnfin2 +tg1 +tg2 +tg5segofs +tgasa +tgasa1 +tgblthelfgott +tgbtwncom +tgbtwncomb +tgbtwnconn1 +tgbtwnconn1lem1 +tgbtwnconn1lem2 +tgbtwnconn1lem3 +tgbtwnconn2 +tgbtwnconn22 +tgbtwnconn3 +tgbtwnconnln1 +tgbtwnconnln2 +tgbtwnconnln3 +tgbtwndiff +tgbtwnexch +tgbtwnexch2 +tgbtwnexch3 +tgbtwnintr +tgbtwnne +tgbtwnouttr +tgbtwnouttr2 +tgbtwnswapid +tgbtwntriv1 +tgbtwntriv2 +tgbtwnxfr +tgcgr4 +tgcgrcomimp +tgcgrcoml +tgcgrcomlr +tgcgrcomr +tgcgreq +tgcgreqb +tgcgrextend +tgcgrneq +tgcgrsub +tgcgrsub2 +tgcgrtriv +tgcgrxfr +tgcl +tgclb +tgcmp +tgcn +tgcnp +tgcolg +tgdif0 +tgdim01 +tgdim01ln +tgdom +tgellng +tgelrnln +tgfiss +tgfscgr +tghilberti1 +tghilberti2 +tgidinside +tgidm +tgifscgr +tgioo +tgioo2 +tgioo3 +tgioo4 +tgisline +tgiun +tgjustc1 +tgjustc2 +tgjustf +tgjustr +tgldim0cgr +tgldim0eq +tgldim0itv +tgldimor +tglinecom +tglineelsb2 +tglineeltr +tglineineq +tglineinteq +tglineintmo +tglineneq +tglinerflx1 +tglinerflx2 +tglinethru +tglinethrueu +tglndim0 +tglnfn +tglng +tglngne +tglngval +tglnne +tglnne0 +tglnpt +tglnpt2 +tglnssp +tglnunirn +tglowdim1 +tglowdim1i +tglowdim2l +tglowdim2ln +tgoldbach +tgoldbachgnn +tgoldbachgt +tgoldbachgtaltv +tgoldbachgtd +tgoldbachgtda +tgoldbachgtde +tgoldbachlt +tgpcn +tgpconncomp +tgpconncompeqg +tgpconncompss +tgpgrp +tgphaus +tgpinv +tgplacthmeo +tgpmulg +tgpmulg2 +tgpsubcn +tgpt0 +tgpt1 +tgptmd +tgptopon +tgptps +tgptsmscld +tgptsmscls +tgqioo +tgqioo2 +tgqtop +tgrest +tgrpabl +tgrpbase +tgrpfset +tgrpgrp +tgrpgrplem +tgrpopr +tgrpov +tgrpset +tgsas +tgsas1 +tgsas2 +tgsas3 +tgsegconeq +tgss +tgss2 +tgss3 +tgsss1 +tgsss2 +tgsss3 +tgtop +tgtop11 +tgtopon +tgtrisegint +tgval +tgval2 +tgval3 +th +th3 +th4 +th5 +th6 +th7 +th8 +th_set +th_sets +than +that +the +then +thenc +thenl +theorem +there +thin_frontier_cic +thin_frontier_ici +thin_frontier_of_cic +thin_frontier_of_ici +thin_frontier_subset +thincc +thinccd +thinccic +thincciso +thincciso2 +thincciso3 +thincciso4 +thinccisod +thincepi +thincfth +thinchom +thincid +thincinv +thinciso +thincmo +thincmo2 +thincmoalt +thincmod +thincmon +thincn0eu +thincpropd +thincsect +thincsect2 +thincssc +this +thlbas +thlle +thlleval +thloc +thlval +threehalves +thus +tietze +tietze_closed_interval +tietze_closed_interval_1 +tietze_open_interval +tietze_open_interval_1 +tietze_unbounded +times +times-zero-right +times2 +times2d +times2i +times_zero_right +tiny +tl +tl_genlist +tleile +tlmlmod +tlmscatps +tlmtgp +tlmtmd +tlmtps +tlmtrg +tls_handshake_secrecy +tlt2 +tlt3 +tltnle +tm +tmdcn +tmdcn2 +tmdgsum +tmdgsum2 +tmdlactcn +tmdmnd +tmdmulg +tmdtopon +tmdtps +tmsbas +tmsds +tmslem +tmsms +tmstopn +tmsval +tmsxms +tmsxps +tmsxpsmopn +tmsxpsval +tmsxpsval2 +tncp +tnd +tng0 +tngbas +tngdim +tngds +tnggrpr +tngip +tnglem +tnglvec +tngmulr +tngngp +tngngp2 +tngngp3 +tngngpd +tngngpim +tngnm +tngnrg +tngplusg +tngsca +tngtopn +tngtset +tngval +tngvsca +to +tocyc01 +tocyccntz +tocycf +tocycfv +tocycfvres1 +tocycfvres2 +tocycval +toeplitz_bilinear_series +toeplitz_bilinear_series_null +token +token_fresh +tokenring +tokens_append +tokens_front +tokens_nil +tool_magazine +top_depth_conv +top_depth_sqconv +topbas +topbnd +topclat +topcld +topdifinf +topdifinfeq +topdifinffin +topdifinffinlem +topdifinfindis +topdlat +topfne +topfneec +topfneec2 +topgele +topgrpbas +topgrpplusg +topgrpstr +topgrptset +topjoin +toplatglb +toplatglb0 +toplatjoin +toplatlub +toplatmeet +toplly +topmeet +topmtcl +topnex +topnfbey +topnfn +topnid +topnlly +topnpropd +topnval +topological_sort +topological_sort_valid +topology_eq +toponcom +toponcomb +toponmax +toponmre +toponrestid +toponss +toponsspwpw +topontop +topontopi +topontopn +topontopon +toponuni +toponunii +topopn +toprestsubel +toprntopon +topsn +topspace_euclidean +topspace_euclidean_space +topspace_euclidean_subtopology +topspace_euclideanreal_subtopology +topspace_mtopology +topspace_subtopology +topssnei +toptopon +toptopon2 +torsubg +tosglb +tosglblem +toslat +toslub +toslublem +tospos +tosso +tot +total_order_trichotomy +totality +totally_bounded_hausdist +totally_bounded_in_imp_mbounded +totbndbnd +totbndmet +totbndss +totprob +totprobd +toycom +tp +tpass +tpcoma +tpcomb +tpeq1 +tpeq123d +tpeq1d +tpeq2 +tpeq2d +tpeq3 +tpeq3d +tpex +tpf +tpf1o +tpf1ofv0 +tpf1ofv1 +tpf1ofv2 +tpfi +tpfo +tpid1 +tpid1g +tpid2 +tpid2g +tpid3 +tpid3g +tpid3gvd +tpidm +tpidm12 +tpidm13 +tpidm23 +tpnei +tpnz +tpnzd +tpos0 +tposco +tposconst +tposcurf1 +tposcurf11 +tposcurf12 +tposcurf1cl +tposcurf2 +tposcurf2cl +tposcurf2val +tposcurfcl +tposeq +tposeqd +tposeqi +tposex +tposexg +tposf +tposf12 +tposf1o +tposf1o2 +tposf2 +tposfn +tposfn2 +tposfo +tposfo2 +tposfun +tposid +tposideq +tposideq2 +tposidf1o +tposidres +tposmap +tposmpo +tposoprab +tposres +tposres0 +tposres2 +tposres3 +tposrescnv +tposresg +tposresxp +tposss +tposssxp +tpossym +tpostpos +tpostpos2 +tpprceq3 +tppreq3 +tppreqb +tpr2rico +tpr2tp +tpr2uni +tpres +tprot +tpsprop2d +tpspropd +tpss +tpssad +tpssbd +tpsscd +tpssd +tpssg +tpssi +tpstop +tpsuni +tptp +tr0 +tr3dom +tr_mod_2 +tr_repr +tr_succ +trace +trace-append +trace-step +trace_0 +trace_add +trace_append +trace_cmul +trace_covariance_cauchy_schwarz +trace_covariance_cauchy_schwarz_abs +trace_covariance_cauchy_schwarz_square +trace_covariance_eq_0 +trace_covariance_pos_le +trace_covariance_pos_lt +trace_covariance_positive_semidefinite_le +trace_i +trace_le_mul_squares +trace_matrix_inv_lmul +trace_matrix_inv_rmul +trace_mul_cyclic +trace_mul_positive_definite_semidefinite_eq_0 +trace_mul_positive_semidefinite_definite_eq_0 +trace_mul_positive_semidefinite_le +trace_mul_sym +trace_neg +trace_positive_definite +trace_positive_semidefinite +trace_similar +trace_square_positive_semidefinite_le +trace_step +trace_sub +trace_transp +tracker +tradd +trans +trans_composition +trans_tac +transeq +transfinite +transfinite_ind +transitions +transitive_frame +transitive_measure +transitive_monotone +transitive_stepwise_le +transitivity +translation_diff +translation_eq_imp +translation_galois +translation_subset_galois_left +translation_subset_galois_right +translation_univ +transp_columnvector +transp_component +transp_diagonal_matrix +transp_eq +transp_eq_0 +transp_injective +transp_mat +transp_matrix_add +transp_matrix_cmul +transp_matrix_inv +transp_matrix_neg +transp_matrix_sub +transp_rowvector +transp_surjective +transp_transp +transportcl +transportprops +transposeinvolutive +tratrb +tratrbvd +traxext +trcfilu +trcl +trcleq1 +trcleq12lem +trcleq2lem +trcleq2lemrp +trclexi +trclexlem +trclfv +trclfvcom +trclfvcotr +trclfvcotrg +trclfvdecoml +trclfvdecomr +trclfvg +trclfvimadecom +trclfvlb +trclfvlb2 +trclfvlb3 +trclfvres +trclfvresub +trclfvss +trclfvub +trclidm +trclimalb2 +trclimaub +trclrelexplem +trclsslem +trclub +trclubg +trclubgi +trclubgnew +trclubgres +trclubi +trclublem +trclubnew +trclun +trclunxp +trcoss +trcoss2 +tree +tree-height +tree-member +tree-size +tree_count_sum +tree_edges +tree_flatten_append +tree_flatten_length +tree_height +tree_height_nonneg +tree_leaves_ge_1 +tree_member +tree_mirror +tree_mirror_involutive +tree_rec +tree_size +tree_size_height +tree_size_mirror +tree_size_nonneg +tree_size_positive +treeheight +trefl_lemma +trel +trel3 +trelded +trelpss +treq +trer +trfbas +trfbas2 +trfg +trficl +trfil1 +trfil2 +trfil3 +trfilss +trfr +trgcgr +trgcgrcom +trgcgrg +trgcopy +trgcopyeu +trgcopyeulem +trggrp +trgring +trgtgp +trgtmd +trgtmd2 +trgtps +triangle +triangle2 +triangle_ineq +triangle_ineq_le +triangle_ineq_lt +triangle_inequality +triangle_lemma +triangle_rectangle +triangular_subdivision_of_cell_complex +triangulation_disjoint_relative_interiors +triangulation_inter_simplex +triangulation_linear_image +triangulation_simplex_faces +triangulation_simplex_facets +triangulation_simplicial_complex +triangulation_subfaces +triangulation_subset +triangulation_translation +triangulation_union +triantru3 +trichotomy +triin +trin +trin2 +trint +trintalt +trintaltvd +trintss +trinxp +triple_neg +triple_transitivity +trirecip +trireciplem +trirn +trisecnconstr +trisegint +triun +triv1nsgd +trivial +trivial_limit_at +trivial_limit_at_infinity +trivial_limit_at_neginfinity +trivial_limit_at_posinfinity +trivial_limit_atpointof_within +trivial_limit_sequentially +trivial_limit_within +trivial_limit_within_convex +trivnsgd +trivnsimpgd +trivsubgd +trivsubgsnd +trkgbas +trkgdist +trkgitv +trkgstr +trl0 +trlat +trlatn0 +trlator0 +trlcl +trlcnv +trlco +trlcoabs +trlcoabs2n +trlcoat +trlcocnv +trlcocnvat +trlcolem +trlcone +trlconid +trleile +trlf1 +trlfset +trlid0 +trlid0b +trliswlk +trljat1 +trljat2 +trljat3 +trljco +trljco2 +trlle +trlne +trlnid +trlnidat +trlnidatb +trlnle +trlontrl +trlord +trlres +trlreslem +trlsegvdeg +trlsegvdeglem1 +trlsegvdeglem2 +trlsegvdeglem3 +trlsegvdeglem4 +trlsegvdeglem5 +trlsegvdeglem6 +trlsegvdeglem7 +trlset +trlsfval +trlsonfval +trlsonistrl +trlsonprop +trlsonwlkon +trlval +trlval2 +trlval3 +trlval4 +trlval5 +trnei +trnfsetn +trnsetn +trom +tron +trop_add_neginf_left +trop_arith_test1 +trop_bot_eq_zero +trop_cno_add_self +trop_cno_close_conditional +trop_cno_compose +trop_cno_id_conditional +trop_cno_star +trop_distrib_left +trop_fin_add_fin +trop_mat_close_close +trop_mat_close_idem +trop_mat_eq_iff +trop_mat_id_diag +trop_mat_mul_assoc +trop_mat_mul_id_left +trop_mat_mul_id_right +trop_mat_pow_close_eq_sum_walks_le +trop_mat_pow_le_star +trop_mat_pow_one +trop_mat_pow_zero +trop_mat_star_close_eq +trop_mat_star_eq_max_simple +trop_mat_star_eq_sum_pow +trop_mat_star_eq_sum_walks_le +trop_mat_star_ge_id +trop_mat_star_ge_mat +trop_mat_star_idem +trop_mul_fin_fin +trop_mul_neginf_left +trop_sum_dominated +trop_sum_empty +trop_sum_ge_member +trop_sum_mono_subset +tropical sums +tropm_add_posinf_left +tropm_bot_eq_one +tropm_distrib_left +tropm_mul_posinf_left +tropm_sum_empty +tropm_sum_le_member +tropm_sum_mono_subset +trpred +trreleq +trrelind +trrelressn +trrelssd +trrelsuperrel2dg +trrelsuperreldg +trressn +trsbc +trsbcvd +trsp2cyc +trss +trssfir1om +trssfir1omregs +trssord +trsspwalt +trsspwalt2 +trsspwalt3 +trsuc +trsucss +tru +truae +truan +truanfal +truantru +trubifal +trubitru +truconj +trud +true +true-listp-append +true-listp-isort +true-listp-msort +true-listp-of-append +true-listp-revappend +trufil +truimfal +truimtru +trujust +trunanfal +trunantru +truni +trunialt +trunialtvd +trunorfal +trunortru +truorfal +truortru +trust +trut +truxorfal +truxortru +trv +trwf +try +try_method +ts3an1 +ts3an2 +ts3an3 +ts3or1 +ts3or2 +ts3or3 +tsan1 +tsan2 +tsan3 +tsbi1 +tsbi2 +tsbi3 +tsbi4 +tseitin +tsetid +tsetndx +tsetndxnbasendx +tsetndxnmulrndx +tsetndxnn +tsetndxnplusgndx +tsetndxnstarvndx +tsettps +tsim1 +tsim2 +tsim3 +tsk0 +tsk1 +tsk2 +tskcard +tsken +tskin +tskinf +tskint +tskmap +tskmcl +tskmid +tskmval +tskop +tskord +tskpr +tskpw +tskpwss +tskr1om +tskr1om2 +tsksdom +tsksn +tskss +tskssel +tsksuc +tsktrss +tskun +tskuni +tskurn +tskwe +tskwe2 +tskwun +tskxp +tskxpss +tsms0 +tsmsadd +tsmscl +tsmscls +tsmsf1o +tsmsfbas +tsmsgsum +tsmsi +tsmsid +tsmsinv +tsmslem1 +tsmsmhm +tsmspropd +tsmsres +tsmssplit +tsmssub +tsmssubm +tsmsval +tsmsval2 +tsmsxp +tsmsxplem1 +tsmsxplem2 +tsna1 +tsna2 +tsna3 +tsor1 +tsor2 +tsor3 +tsp +tsrdir +tsrlemax +tsrlin +tsrps +tsrss +tsxo1 +tsxo2 +tsxo3 +tsxo4 +tt +ttac +ttgbas +ttgbtwnid +ttgcontlem1 +ttgds +ttgelitv +ttgitvval +ttglem +ttgplusg +ttgsub +ttgval +ttgvsca +ttrclco +ttrcleq +ttrclexg +ttrclresv +ttrclse +ttrclselem1 +ttrclselem2 +ttrclss +ttrcltr +ttukey +ttukey2g +ttukeyg +ttukeylem1 +ttukeylem2 +ttukeylem3 +ttukeylem4 +ttukeylem5 +ttukeylem6 +ttukeylem7 +tube_lemma +tube_lemma_gen +tuple_fst_snd +tusbas +tuslem +tustopn +tustps +tusunif +tususp +tususs +tusval +tvclmod +tvclvec +tvctdrg +tvctlm +two +two_is_even +two_sided_limit_at +two_sided_limit_within +twocut +twonotinotbothi +twosum +tx1cn +tx1stc +tx2cn +tx2ndc +tx_balance_conservation +txbas +txbasex +txbasval +txcld +txcls +txcmp +txcmpb +txcmplem1 +txcmplem2 +txcn +txcnmpt +txcnp +txcnpi +txconn +txdis +txdis1cn +txflf +txhaus +txhmeo +txindis +txindislem +txkgen +txlly +txlm +txmetcn +txmetcnp +txnlly +txomap +txopn +txpconn +txprel +txpss3v +txrest +txsconn +txsconnlem +txss12 +txswaphmeo +txswaphmeolem +txtop +txtopi +txtopon +txtube +txuni +txuni2 +txunii +txval +type +type-unique +type_abstraction +type_product_comm +type_soundness +type_sum_comm +type_unique +typesafepets +typing +tz6.12 +tz6.12-1 +tz6.12-1-afv +tz6.12-1-afv2 +tz6.12-2 +tz6.12-2-afv2 +tz6.12-2old +tz6.12-afv +tz6.12-afv2 +tz6.12c +tz6.12c-afv2 +tz6.12f +tz6.12i +tz6.12i-afv2 +tz6.26 +tz6.26i +tz7.2 +tz7.44-1 +tz7.44-2 +tz7.44-3 +tz7.44lem1 +tz7.48-1 +tz7.48-2 +tz7.48-3 +tz7.48lem +tz7.49 +tz7.49c +tz7.5 +tz7.7 +tz9.1 +tz9.12 +tz9.12lem1 +tz9.12lem2 +tz9.12lem3 +tz9.13 +tz9.13g +tz9.1c +tz9.1regs +u16_max_bound +u32_shift_left +u32_sub_mod +u64_logand_comm +u8_add_mod +ubelsupr +ubicc2 +ubico +ubioc1 +ubioo +ublbneg +ubmelfzo +ubmelm1fzo +ubth +ubthlem1 +ubthlem2 +ubthlem3 +uc1pcl +uc1pdeg +uc1pldg +uc1pmon1p +uc1pn0 +uc1pval +ucncn +ucnextcn +ucnima +ucnimalem +ucnprima +ucnval +ufdidom +ufdprmidl +uffcfflf +uffclsflim +uffinfix +uffix +uffix2 +uffixfr +uffixsn +ufilb +ufilcmp +ufildom1 +ufildr +ufilen +ufileu +ufilfil +ufilmax +ufilss +ufinffr +ufldom +ufli +ufprim +uhgr0 +uhgr0e +uhgr0edg0rgr +uhgr0edg0rgrb +uhgr0edgfi +uhgr0v0e +uhgr0vb +uhgr0vsize0 +uhgr0vusgr +uhgr2edg +uhgr3cyclex +uhgr3cyclexlem +uhgredgiedgb +uhgredgn0 +uhgredgrnv +uhgredgss +uhgreq12g +uhgrf +uhgrfun +uhgriedg0edg0 +uhgrimedg +uhgrimedgi +uhgrimgrlim +uhgrimisgrgric +uhgrimisgrgriclem +uhgrimprop +uhgrissubgr +uhgrn0 +uhgrnbgr0nb +uhgrspan +uhgrspan1 +uhgrspan1lem1 +uhgrspan1lem2 +uhgrspan1lem3 +uhgrspanop +uhgrspansubgr +uhgrspansubgrlem +uhgrss +uhgrstrrepe +uhgrsubgrself +uhgrun +uhgrunop +uhgrvd00 +uhgrvtxedgiedgb +uhgrwkspth +uhgrwkspthlem1 +uhgrwkspthlem2 +ulemma +ulm0 +ulm2 +ulmbdd +ulmcau +ulmcau2 +ulmcaulem +ulmcl +ulmclm +ulmcn +ulmdm +ulmdv +ulmdvlem1 +ulmdvlem2 +ulmdvlem3 +ulmf +ulmf2 +ulmi +ulmpm +ulmrel +ulmres +ulmscl +ulmshft +ulmshftlem +ulmss +ulmuni +ulmval +umgr0e +umgr2adedgspth +umgr2adedgwlk +umgr2adedgwlklem +umgr2adedgwlkon +umgr2adedgwlkonalt +umgr2cwwk2dif +umgr2cwwkdifex +umgr2cycl +umgr2cycllem +umgr2edg +umgr2edg1 +umgr2edgneu +umgr2v2e +umgr2v2eedg +umgr2v2eiedg +umgr2v2enb1 +umgr2v2evd2 +umgr2v2evtx +umgr2v2evtxel +umgr2wlk +umgr2wlkon +umgr3cyclex +umgr3v3e3cycl +umgracycusgr +umgrbi +umgrclwwlkge2 +umgredg +umgredg2 +umgredgne +umgredgnlp +umgredgprv +umgredgss +umgrf +umgrfn +umgrhashecclwwlk +umgrislfupgr +umgrislfupgrlem +umgrn1cycl +umgrnloop +umgrnloop0 +umgrnloop2 +umgrnloopv +umgrpredgv +umgrres +umgrres1 +umgrres1lem +umgrreslem +umgrspan +umgrspanop +umgruhgr +umgrun +umgrunop +umgrupgr +umgrvad2edg +umgrwlknloop +umgrwwlks2on +un0 +un0.1 +un00 +un01 +un0addcl +un0mulcl +un10 +un12 +un2122 +un23 +un4 +unab +unabbrev_all_tac +unabs +unabw +unass +unb2ltle +unbdqndv1 +unbdqndv2 +unbdqndv2lem1 +unbdqndv2lem2 +unben +unbenlem +unblem1 +unblem2 +unblem3 +unblem4 +unblimceq0 +unblimceq0lem +unbndrank +unbnn +unbnn2 +unbnn3 +unbounded_complement_component_convex +unbounded_complement_convex +unbounded_convex_closed_contains_ray +unbounded_convex_closed_contains_rays +unbounded_halfspace_component_ge +unbounded_halfspace_component_gt +unbounded_halfspace_component_le +unbounded_halfspace_component_lt +unbounded_inter_cobounded +unccur +unceq +uncf +uncf1 +uncf2 +uncfcl +uncfcurf +uncfval +uncld +uncmp +uncom +unconn +uncountable_connected +uncountable_contains_limit_point +uncountable_euclidean +uncountable_interval +uncountable_open +uncov +unctb +uncurry +uncurry_curry +undefne0 +undefnel +undefnel2 +undefval +under +undi +undif +undif1 +undif2 +undif3 +undif3vd +undif4 +undif5 +undifabs +undifixp +undifr +undifrold +undir +undisch_tac +undisch_then +undisj1 +undisj2 +undisjrab +undjudom +undm +undmrnresiss +undom +unelcarsg +unelldsys +unelros +unelsiga +unen +uneq1 +uneq12 +uneq12d +uneq12i +uneq1d +uneq1i +uneq2 +uneq2d +uneq2i +uneqdifeq +uneqin +uneqri +uneqsn +unex +unexb +unexbold +unexd +unexg +unexgold +unexold +unfi +unfi2 +unfib +unfid +unfilem1 +unfilem2 +unfilem3 +unfir +unfold +unfold `gcd` +unfold `reverse` +unfolding +unhe1 +uni0 +uni0b +uni0c +uni0old +uniabio +unialeph +unibrsiga +unichnidl +uniclaxun +unicld +unicls +unicntop +unictb +unidif +unidif0 +unidifsnel +unidifsnne +unidm +unidmex +unidmovn +unidmqs +unidmqseq +unidmrn +unidmvol +unidmvon +unidom +uniel +unielid +unielrel +unielsiga +unielss +unielxp +unieq +unieqd +unieqi +unierri +uniex +uniex2 +uniexb +uniexd +uniexg +uniexr +unifi +unifi2 +unifi3 +unifid +unifndx +unifndxnbasendx +unifndxnn +unifndxntsetndx +uniform_lim_add +uniform_lim_bilinear +uniform_lim_sub +uniformly_cauchy_imp_uniformly_convergent +uniformly_continuous_eq_cauchy_continuous_bounded +uniformly_continuous_extends_to_closure +uniformly_continuous_imp_cauchy_continuous +uniformly_continuous_imp_continuous +uniformly_continuous_map_compose +uniformly_continuous_map_drop +uniformly_continuous_map_drop_eq +uniformly_continuous_map_eq_drop +uniformly_continuous_map_eq_lift +uniformly_continuous_map_euclidean +uniformly_continuous_map_lift +uniformly_continuous_map_lift_eq +uniformly_continuous_map_pasted +uniformly_continuous_map_pastewise +uniformly_continuous_map_sqrt +uniformly_continuous_on_add +uniformly_continuous_on_closure +uniformly_continuous_on_cmul +uniformly_continuous_on_compose +uniformly_continuous_on_const +uniformly_continuous_on_dist_closest_point +uniformly_continuous_on_eq +uniformly_continuous_on_id +uniformly_continuous_on_lift_setdist +uniformly_continuous_on_mul +uniformly_continuous_on_neg +uniformly_continuous_on_restrict +uniformly_continuous_on_sequentially +uniformly_continuous_on_sequentially_alt +uniformly_continuous_on_setdist +uniformly_continuous_on_setdist_eq +uniformly_continuous_on_sqrt +uniformly_continuous_on_sub +uniformly_continuous_on_subset +uniformly_continuous_on_union +uniformly_continuous_on_vmul +uniformly_continuous_on_vsum +uniformly_convergent_eq_cauchy +uniformly_convergent_eq_cauchy_alt +unifpw +uniiccdif +uniiccmbl +uniiccvol +uniimadom +uniimadomf +uniimaelsetpreimafv +uniimafveqt +uniimaprimaeqfv +uniin +uniin1 +uniin2 +uniinn0 +uniinqs +uniintab +uniintsn +uniioombl +uniioombllem1 +uniioombllem2 +uniioombllem2a +uniioombllem3 +uniioombllem3a +uniioombllem4 +uniioombllem5 +uniioombllem6 +uniioovol +uniiun +uniiunlem +uniixp +unilbeu +unilbss +unima +unimax +unimopn +unineq +union +union_aci +union_assoc +union_comm +union_count_from +union_countable +union_delete +union_diff +union_diff_2 +union_empty +union_from_count +union_frontier +union_idempot +union_interior_subset +union_interval_1 +union_interval_subset_interval +union_le_add_c +union_of +union_of_mono +union_over_inter +union_segment +union_subset +union_superset +union_univ +unionelim +unions +unions_components +unions_connected_component +unions_diff +unions_gspec +unions_image +unions_insert +unions_inters +unions_mono +unions_subset +unions_union +uniop +uniopel +uniopn +uniordint +unipr +unipreima +uniprg +unipw +unipwr +unipwrvd +uniqs +uniqs2 +uniqsw +unique_filter +unique_length_filter +unique_limit +unique_member_sing +uniqueseq +unir1 +unir1regs +unirep +unirestss +uniretop +unirnbl +unirnblps +unirnfdomd +unirnffid +unirnioo +unirnmap +unirnmapsn +unisalgen +unisalgen2 +unisg +unisn +unisn0 +unisn2 +unisn3 +unisnalt +unisng +unisngl +unisnif +unisnv +uniss +uniss2 +unissb +unissd +unissel +unissi +unissint +unisuc +unisucg +unisucs +unisym1 +unit_interval_convex_hull +unit_interval_nonempty +unit_propagation +unit_unique +unitabl +unitadd +unitcl +unitdivcld +unitdvcl +unitelim +unitg +unitgrp +unitgrpbas +unitgrpid +unitinvcl +unitinvinv +unitlinv +unitmulcl +unitmulclb +unitmulrprm +unitnegcl +unitnmn0 +unitnz +unitpidl1 +unitprodclb +unitpropd +unitrinv +unitrrg +unitscyglem1 +unitscyglem2 +unitscyglem3 +unitscyglem4 +unitscyglem5 +unitss +unitsscn +unitssre +unitssxrge0 +unitsubm +unitunique +uniun +uniuni +univ +univ_fun_to_bool +univ_funset_univ +univ_gspec +univ_image_chr_count_256 +univ_not_empty +univ_pcross_univ +univ_second_countable +univ_second_countable_sequence +univ_subset +universal +university_timetable +uniwf +uniwun +unixp +unixp0 +unixpid +unixpss +unizlim +unjust +unmbl +unnum +unocv +unon +unop +unopab +unopadj +unopadj2 +unopbd +unopf1o +unoplin +unopn +unopnorm +unpreima +unqsym1 +unrab +unsat +unsatisfiable +unsigned-byte-p-0 +unsigned-byte-p-1-crock +unsigned-byte-p-ash +unsigned-byte-p-base-case +unsigned-byte-p-integer-length +unsigned-byte-p-logand +unsigned-byte-p-logapp +unsigned-byte-p-logior +unsigned-byte-p-logrpl +unsigned-byte-p-logxor +unsigned-byte-p-of-logand +unsigned-byte-p-plus +unsigned-byte-p-wrb +unsnen +unss +unss1 +unss12 +unss2 +unssad +unssbd +unssd +unssi +unt0 +untangtr +untelirr +untint +untsucf +untuni +unundi +unundir +unv +unvdif +unveldom +unveldomd +unwdomg +unwf +unwind_conv +unxpdom +unxpdom2 +unxpdomlem1 +unxpdomlem2 +unxpdomlem3 +unxpwdom +unxpwdom2 +unxpwdom3 +unzip_map +unzip_thm +unzip_zip +uobeq +uobeq2 +uobeq3 +uobeqterm +uobeqw +uobffth +uobrcl +up1st2nd +up1st2nd2 +up1st2ndb +up1st2ndr +upbdrech +upbdrech2 +upcic +upciclem1 +upciclem2 +upciclem3 +upciclem4 +update +updjud +updjudhcoinlf +updjudhcoinrg +updjudhf +upeu +upeu2 +upeu2lem +upeu3 +upeu4 +upfval +upfval2 +upfval3 +upgr0e +upgr0eop +upgr0eopalt +upgr1e +upgr1elem +upgr1eop +upgr1eopalt +upgr1pthd +upgr1pthond +upgr1trld +upgr1wlkd +upgr1wlkdlem1 +upgr1wlkdlem2 +upgr2pthnlp +upgr2wlk +upgr3v3e3cycl +upgr4cycl4dv4e +upgracycumgr +upgracycusgr +upgrbi +upgrclwlkcompim +upgredg +upgredg2vtx +upgredginwlk +upgredgpr +upgredgss +upgredgssspr +upgreupthi +upgreupthseg +upgrewlkle2 +upgrex +upgrf +upgrf1istrl +upgrfi +upgrfn +upgrimcycls +upgrimpths +upgrimpthslem1 +upgrimpthslem2 +upgrimspths +upgrimtrls +upgrimtrlslem1 +upgrimtrlslem2 +upgrimwlk +upgrimwlklem1 +upgrimwlklem2 +upgrimwlklem3 +upgrimwlklem4 +upgrimwlklem5 +upgrimwlklen +upgriseupth +upgristrl +upgrisupwlkalt +upgriswlk +upgrle +upgrle2 +upgrn0 +upgrop +upgrpredgv +upgrres +upgrres1 +upgrres1lem1 +upgrres1lem2 +upgrres1lem3 +upgrreslem +upgrspan +upgrspanop +upgrspthswlk +upgrss +upgrtrls +upgruhgr +upgrun +upgrunop +upgrwlkcompim +upgrwlkdvde +upgrwlkdvdelem +upgrwlkdvspth +upgrwlkedg +upgrwlkupwlk +upgrwlkupwlkb +upgrwlkvtxedg +upixp +upper_bound +upper_bound_finite_set +upper_hemicontinuous +upper_lower_hemicontinuous +upper_lower_hemicontinuous_explicit +uppropd +uprcl +uprcl2 +uprcl2a +uprcl3 +uprcl4 +uprcl5 +uptpos +uptposlem +uptr +uptr2 +uptr2a +uptra +uptrai +uptrar +uptri +uptrlem1 +uptrlem2 +uptrlem3 +uptx +upwlkbprop +upwlksfval +upwlkwlk +upxp +urpropd +urysohn +urysohn_local +urysohn_local_strong +urysohn_strong +use +use add_assoc +use add_comm +use add_succ +use add_zero +use classical +use ih +use ih1 +use ih2 +use length_append +use list_append_assoc +use list_append_nil +use mul_succ +use mul_zero +use rev_append +use_then +useonce +uses +usgr0 +usgr0e +usgr0edg0rusgr +usgr0eop +usgr0v +usgr0vb +usgr1e +usgr1eop +usgr1v +usgr1v0e +usgr1v0edg +usgr1vr +usgr2edg +usgr2edg1 +usgr2pth +usgr2pth0 +usgr2pthlem +usgr2pthspth +usgr2trlncl +usgr2trlncrct +usgr2trlspth +usgr2v1e2w +usgr2wlkneq +usgr2wlkspth +usgr2wlkspthlem1 +usgr2wlkspthlem2 +usgr2wspthon +usgr2wspthons3 +usgrausgrb +usgrausgri +usgrcyclgt2v +usgredg +usgredg2 +usgredg2alt +usgredg2v +usgredg2vlem1 +usgredg2vlem2 +usgredg2vtx +usgredg2vtxeu +usgredg2vtxeualt +usgredg3 +usgredg4 +usgredgedg +usgredgffibi +usgredgleord +usgredgleordalt +usgredgne +usgredgop +usgredgppr +usgredgprv +usgredgprvalt +usgredgreu +usgredgss +usgredgsscusgredg +usgreqdrusgr +usgrexi +usgrexilem +usgrexmpl +usgrexmpl1 +usgrexmpl12ngric +usgrexmpl12ngrlic +usgrexmpl1edg +usgrexmpl1lem +usgrexmpl1tri +usgrexmpl1vtx +usgrexmpl2 +usgrexmpl2edg +usgrexmpl2lem +usgrexmpl2nb0 +usgrexmpl2nb1 +usgrexmpl2nb2 +usgrexmpl2nb3 +usgrexmpl2nb4 +usgrexmpl2nb5 +usgrexmpl2nblem +usgrexmpl2trifr +usgrexmpl2vtx +usgrexmpldifpr +usgrexmpledg +usgrexmplef +usgrexmpllem +usgrexmplvtx +usgrf +usgrf1 +usgrf1o +usgrf1oedg +usgrfilem +usgrfs +usgrfun +usgrgrtrirex +usgrgt2cycl +usgriedgleord +usgrislfuspgr +usgrlimprop +usgrn2cycl +usgrnbcnvfv +usgrnloop +usgrnloop0 +usgrnloop0alt +usgrnloopalt +usgrnloopv +usgrnloopvalt +usgrop +usgrprc +usgrpredgv +usgrres +usgrres1 +usgrsizedg +usgrspan +usgrspanop +usgrss +usgrsscusgr +usgrstrrepe +usgruhgr +usgrumgr +usgrumgruspgr +usgrun +usgrunop +usgrupgr +usgruspgr +usgruspgrb +usgruvtxvdb +usgrvd00 +usgrvd0nedg +usgrwwlks2on +ushggricedg +ushgredgedg +ushgredgedgloop +ushgrf +ushgruhgr +ushgrun +ushgrunop +using +uspgr1e +uspgr1eop +uspgr1ewop +uspgr1v1eop +uspgr2v1e2w +uspgr2wlkeq +uspgr2wlkeq2 +uspgr2wlkeqi +uspgrbispr +uspgrbisymrel +uspgrbisymrelalt +uspgredg2v +uspgredg2vlem +uspgredg2vtxeu +uspgredgiedg +uspgredgleord +uspgrex +uspgrf +uspgrf1oedg +uspgriedgedg +uspgrlim +uspgrlimlem1 +uspgrlimlem2 +uspgrlimlem3 +uspgrlimlem4 +uspgrloopedg +uspgrloopiedg +uspgrloopnb0 +uspgrloopvd2 +uspgrloopvtx +uspgrloopvtxel +uspgrn2crct +uspgropssxp +uspgrspren +uspgrsprf +uspgrsprf1 +uspgrsprf1o +uspgrsprfo +uspgrsprfv +uspgruhgr +uspgrun +uspgrunop +uspgrupgr +uspgrupgrushgr +uspgrushgr +uspgrymrelen +uspreg +ussid +ussval +ust0 +ustbas +ustbas2 +ustbasel +ustdiag +ustelimasn +ustex2sym +ustex3sym +ustexhalf +ustexsym +ustfilxp +ustfn +ustimasn +ustincl +ustinvel +ustn0 +ustne0 +ustneism +ustref +ustrel +ustssco +ustssel +ustssxp +ustund +ustuni +ustuqtop +ustuqtop0 +ustuqtop1 +ustuqtop2 +ustuqtop3 +ustuqtop4 +ustuqtop5 +ustuqtoplem +ustval +utf8_encode_decode +utop2nei +utop3cls +utopbas +utopreg +utopsnnei +utopsnneip +utopsnneiplem +utoptop +utoptopon +utopval +utxo_no_double_spend +uun0.1 +uun111 +uun121 +uun121p1 +uun123 +uun123p1 +uun123p2 +uun123p3 +uun123p4 +uun132 +uun132p1 +uun2131 +uun2131p1 +uun2221 +uun2221p1 +uun2221p2 +uunt1 +uunt11 +uunt11p1 +uunt11p2 +uunt12 +uunt12p1 +uunt12p2 +uunt12p3 +uunt12p4 +uunt12p5 +uunt1p1 +uunt21 +uuntt1 +uuntt1p1 +uuntt1p2 +uvccl +uvcendim +uvcf1 +uvcf1o +uvcff +uvcfval +uvcn0 +uvcresum +uvcval +uvcvv0 +uvcvv1 +uvcvval +uvcvvcl +uvcvvcl2 +uvtx0 +uvtx01vtx +uvtx2vtx1edg +uvtx2vtx1edgb +uvtxel +uvtxel1 +uvtxisvtx +uvtxnbgr +uvtxnbgrb +uvtxnbgrss +uvtxnbgrvtx +uvtxnbvtxm1 +uvtxnm1nbgr +uvtxssvtx +uvtxupgrres +uvtxusgr +uvtxusgrel +uvtxval +uz0 +uz11 +uz2m1nn +uz2mulcl +uz3m2nn +uzaddcl +uzct +uzdisj +uzenom +uzf +uzfbas +uzfissfz +uzid +uzid2 +uzid3 +uzidd +uzidd2 +uzin +uzin2 +uzind +uzind2 +uzind3 +uzind4 +uzind4alt +uzind4i +uzind4s +uzind4s2 +uzindd +uzindi +uzinf +uzinfi +uzinico +uzinico2 +uzinico3 +uzlidlring +uzm1 +uzmptshftfval +uzn0 +uzn0bi +uzn0d +uzneg +uznfz +uznn0sub +uznnssnn +uzp1 +uzrdg0i +uzrdgfni +uzrdglem +uzrdgsuci +uzrdgxfr +uzred +uzrest +uzsind +uzsinds +uzsplit +uzss +uzsscn +uzsscn2 +uzssd +uzssd2 +uzssd3 +uzssico +uzssre +uzssre2 +uzssz +uzssz2 +uzsubfz0 +uzsubsubfz +uzsubsubfz1 +uzsup +uzsupss +uztric +uztrn +uztrn2 +uzub +uzubico +uzubico2 +uzubioo +uzubioo2 +uzublem +uzuzle23 +uzuzle24 +uzuzle34 +uzuzle35 +uzval +uzwo +uzwo2 +uzwo3 +uzwo4 +uzxr +uzxrd +v_spec +vacn +vafval +val +value +var +var_eq_tac +variables +variance +variance_nonneg +variant +variation_equal_lemma +vars +vc0 +vc0rid +vc2old +vcablo +vcass +vccl +vcdi +vcdir +vcex +vcgrp +vcidold +vciold +vclcan +vcm +vcrel +vcsm +vcz +vczcl +vd01 +vd02 +vd03 +vd12 +vd13 +vd23 +vdegp1ai +vdegp1bi +vdegp1ci +vdgfrgrgt2 +vdgn0frgrv2 +vdgn1frgrv2 +vdgn1frgrv3 +vdif0 +vdioph +vdiscusgr +vdiscusgrb +vdn0conngrumgrv2 +vdumgr0 +vdw +vdwap0 +vdwap1 +vdwapf +vdwapfval +vdwapid1 +vdwapun +vdwapval +vdwlem1 +vdwlem10 +vdwlem11 +vdwlem12 +vdwlem13 +vdwlem2 +vdwlem3 +vdwlem4 +vdwlem5 +vdwlem6 +vdwlem7 +vdwlem8 +vdwlem9 +vdwmc +vdwmc2 +vdwnn +vdwnnlem1 +vdwnnlem2 +vdwnnlem3 +vdwpc +vec_component +vec_eq +vect +vectappendlength +vectappendnilrightneutral +vectindexmap +vectlengthmap +vectmapcompose +vectmapid +vector_1 +vector_2 +vector_3 +vector_4 +vector_add_ac +vector_add_assoc +vector_add_component +vector_add_ldistrib +vector_add_lid +vector_add_linv +vector_add_rdistrib +vector_add_rid +vector_add_rinv +vector_add_sub +vector_add_sym +vector_affinity_eq +vector_arith +vector_arith_tac +vector_choose_dist +vector_choose_size +vector_componentwise +vector_cons_snoc +vector_derivative_at +vector_derivative_const_at +vector_derivative_increasing_within +vector_derivative_unique_at +vector_derivative_unique_within +vector_derivative_unique_within_closed_interval +vector_derivative_within_closed_interval +vector_derivative_works +vector_diff_chain_at +vector_diff_chain_within +vector_differentiable +vector_differentiable_bound +vector_eq +vector_eq_affinity +vector_eq_dot_span +vector_eq_ldot +vector_eq_rdot +vector_expand_1 +vector_expand_2 +vector_expand_3 +vector_expand_4 +vector_head +vector_in_orthogonal_basis +vector_in_orthogonal_spanningset +vector_in_orthonormal_basis +vector_index +vector_matrix_mul_transp +vector_mul_assoc +vector_mul_component +vector_mul_eq_0 +vector_mul_lcancel +vector_mul_lcancel_imp +vector_mul_lid +vector_mul_lneg +vector_mul_lzero +vector_mul_rcancel +vector_mul_rcancel_imp +vector_mul_rneg +vector_mul_rzero +vector_neg_component +vector_neg_neg +vector_neg_sub +vector_one +vector_space_basis +vector_space_sum +vector_sub +vector_sub_component +vector_sub_elim_thm +vector_sub_eq +vector_sub_ldistrib +vector_sub_lzero +vector_sub_project_orthogonal +vector_sub_rdistrib +vector_sub_refl +vector_sub_rzero +vector_variation_affinity +vector_variation_cmul +vector_variation_combine +vector_variation_comparison +vector_variation_component_le +vector_variation_compose_decreasing +vector_variation_compose_homeomorphism +vector_variation_compose_increasing +vector_variation_compose_increasing_gen +vector_variation_const +vector_variation_const_eq +vector_variation_continuous +vector_variation_continuous_left +vector_variation_continuous_right +vector_variation_degenerates +vector_variation_eq +vector_variation_ge_drop_function +vector_variation_ge_norm_function +vector_variation_id +vector_variation_integral_norm_derivative +vector_variation_integral_norm_derivative_gen +vector_variation_integral_norm_derivative_rev +vector_variation_isometric +vector_variation_isometric_compose +vector_variation_le_union +vector_variation_lift_abs +vector_variation_linear +vector_variation_lipschitz +vector_variation_minus_function_monotone +vector_variation_minus_function_monotone_left +vector_variation_minus_function_monotone_right +vector_variation_monotone +vector_variation_neg +vector_variation_on_closure +vector_variation_on_division +vector_variation_on_empty +vector_variation_on_interior +vector_variation_on_interval +vector_variation_on_null +vector_variation_pos_le +vector_variation_reflect +vector_variation_segment_triangle +vector_variation_sing +vector_variation_split +vector_variation_translation +vector_variation_translation_alt +vector_variation_triangle +vector_variation_vmul +vectoraxiom +vectorize_0 +vectorize_add +vectorize_cmul +vectorize_component +vectorize_eq_0 +vectorize_matrify +vectorize_sub +vectreversereverse +vectzipwithcomm +vehicle_routing +velcomp +velpw +velsn +verification +verify +vert_seq_lem +vertex +vertices +verts_of_subset +very +vex +vextru +vexw +vexwt +vfermltl +vfermltlalt +vhmcls +vieta +vieta1 +vieta1lem1 +vieta1lem2 +vietadeg1 +vietalem +viin +vitali +vitali2 +vitali_covering_lemma_balls +vitali_covering_lemma_cballs +vitali_covering_lemma_cballs_balls +vitali_covering_theorem_balls +vitali_covering_theorem_cballs +vitalilem1 +vitalilem2 +vitalilem3 +vitalilem4 +vitalilem5 +vjust +vk15.4j +vk15.4jvd +vlan_assignment +vma1 +vmacl +vmadivsum +vmadivsumb +vmaf +vmage0 +vmalelog +vmalogdivsum +vmalogdivsum2 +vmappw +vmaprm +vmasum +vmaval +vmcn +vn0 +vn0alt +vnex +void +void_elim +voidabsurd +voidabsurd2 +voidelim +vol0 +volcn +volf +volfiniun +volfiniune +volge0 +volicc +voliccico +volico +volico2 +volicoff +volicofmpt +volicon0 +volicore +volicorecl +volicorege0 +volicorescl +volinun +volioc +volioo +volioof +volioofmpt +voliooico +voliooicof +volioore +voliun +voliune +voliunlem1 +voliunlem2 +voliunlem3 +voliunnfl +voliunsge0 +voliunsge0lem +volivth +volmea +volmeas +volres +volsn +volss +volsup +volsup2 +volsuplem +volsupnfl +volun +von0val +voncl +voncmpl +vonct +vonf1owev +vonhoi +vonhoire +vonicc +vonicclem1 +vonicclem2 +vonioo +vonioolem1 +vonioolem2 +vonmblss +vonmblss2 +vonmea +vonn0hoi +vonn0icc +vonn0icc2 +vonn0ioo +vonn0ioo2 +vonsn +vonval +vonvol +vonvol2 +vonvolmbl +vonvolmbl2 +vonvolmbllem +vonxrcl +vopelopabsb +vopnbgrel +vopnbgrelself +vprc +vpwex +vr1cl +vr1cl2 +vr1nz +vr1val +vrgpf +vrgpfval +vrgpinv +vrgpval +vrmdf +vrmdfval +vrmdval +vscacn +vscaid +vscandx +vscandxnbasendx +vscandxnmulrndx +vscandxnplusgndx +vscandxnscandx +vsetrec +vsfval +vsn +vsnex +vsnid +vss +vsum +vsum_0 +vsum_1 +vsum_2 +vsum_3 +vsum_4 +vsum_add +vsum_add_gen +vsum_add_numseg +vsum_add_split +vsum_bijection +vsum_cases +vsum_cases_1 +vsum_clauses +vsum_clauses_left +vsum_clauses_numseg +vsum_clauses_right +vsum_cmul_numseg +vsum_combine_l +vsum_combine_r +vsum_component +vsum_const +vsum_const_numseg +vsum_content_null +vsum_delete +vsum_delete_cases +vsum_delta +vsum_diff +vsum_diff_lemma +vsum_diffs +vsum_diffs_alt +vsum_eq +vsum_eq_0 +vsum_eq_general +vsum_eq_general_inverses +vsum_eq_numseg +vsum_eq_superset +vsum_group +vsum_group_relation +vsum_image +vsum_image_gen +vsum_image_nonzero +vsum_incl_excl +vsum_injection +vsum_lmul +vsum_neg +vsum_nonzero_image_lemma +vsum_norm +vsum_norm_allsubsets_bound +vsum_norm_bound +vsum_norm_le +vsum_norm_triangle +vsum_offset +vsum_offset_0 +vsum_over_tagged_division_lemma +vsum_over_tagged_partial_division_lemma +vsum_pair +vsum_pair_0 +vsum_partial_pre +vsum_partial_suc +vsum_real +vsum_reflect +vsum_restrict +vsum_restrict_set +vsum_rmul +vsum_sing +vsum_sing_numseg +vsum_sub +vsum_sub_numseg +vsum_suc +vsum_superset +vsum_support +vsum_swap +vsum_swap_numseg +vsum_triv_numseg +vsum_union +vsum_union_lzero +vsum_union_nonzero +vsum_union_rzero +vsum_unions_nonzero +vsum_univ +vsum_vmul +vsum_vsum_product +vtocl +vtocl2 +vtocl2d +vtocl2g +vtocl2ga +vtocl2gaf +vtocl2gafold +vtocl2gf +vtocl3 +vtocl3g +vtocl3ga +vtocl3gaf +vtocl3gafold +vtocl3gaold +vtocl3gf +vtocl4g +vtocl4ga +vtocl4gaold +vtoclb +vtoclbg +vtocld +vtocldf +vtocle +vtoclef +vtoclefex +vtocleg +vtoclegft +vtocleold +vtoclf +vtoclg +vtoclg1f +vtoclga +vtoclgaf +vtoclgf +vtoclgft +vtoclold +vtoclr +vtoclri +vtscl +vtsprod +vtsval +vtxd0nedgb +vtxdeqd +vtxdfiun +vtxdg0e +vtxdg0v +vtxdgelxnn0 +vtxdgf +vtxdgfisf +vtxdgfisnn0 +vtxdgfival +vtxdgfusgr +vtxdgfusgrf +vtxdgfval +vtxdginducedm1 +vtxdginducedm1fi +vtxdginducedm1lem1 +vtxdginducedm1lem2 +vtxdginducedm1lem3 +vtxdginducedm1lem4 +vtxdgoddnumeven +vtxdgop +vtxdgval +vtxdlfgrval +vtxdlfuhgr1v +vtxduhgr0e +vtxduhgr0edgnel +vtxduhgr0nedg +vtxduhgrfiun +vtxduhgrun +vtxdumgr0nedg +vtxdumgrval +vtxdun +vtxdusgr0edgnel +vtxdusgr0edgnelalt +vtxdusgradjvtx +vtxdusgrfvedg +vtxdusgrval +vtxdushgrfvedg +vtxdushgrfvedglem +vtxnbuvtx +vtxval +vtxval0 +vtxval3sn +vtxvalprc +vtxvalsnop +vuniex +vvdifopab +vxp +w_induction +w_list_iso +w_nat_iso +w_type +waj-ax +walk_concat +walk_concat_edge +walk_edge_in +walk_from_vert +walk_hd +walk_last +walk_length +walk_merge +walk_nonempty +walk_vertices_bounded +walk_verts_in +walks_0 +walks_0_empty_if_neq +walks_bounds +walks_le_0 +wallispi +wallispi2 +wallispi2lem1 +wallispi2lem2 +wallispilem1 +wallispilem2 +wallispilem3 +wallispilem4 +wallispilem5 +warehouse_location +watfvaln +watvaln +wavelength_assignment +wdom2d +wdom2d2 +wdomac +wdomd +wdomen1 +wdomen2 +wdomfil +wdomima2g +wdomimag +wdomnumr +wdompwdom +wdomref +wdomtr +we +we0 +weak_lebesgue_points_imp_ivt +weakening +wecmpep +ween +weeq1 +weeq12d +weeq2 +wefr +wefrc +weinxp +weisoeq +weisoeq2 +weiunfr +weiunfrlem +weiunlem +weiunpo +weiunse +weiunso +weiunval +weiunwe +wel +welb +well_founded_acc +well_founded_induction +well_ordering_nat +well_typed_eval +wemaplem1 +wemaplem2 +wemaplem3 +wemappo +wemapso +wemapso2 +wemapso2lem +wemapsolem +wemapwe +wemoiso +wemoiso2 +weniso +wepwso +wepwsolem +weq +wereu +wereu2 +wesn +weso +wess +wessf1orn +wessf1ornlem +weth +wetrep +wevgblacfn +wexp +wf_induct +wf_induct_tac +wf_list_pred +wf_rec +wf_shortlex_same_lengths +wfac8prim +wfaxext +wfaxinf2 +wfaxnul +wfaxpow +wfaxpr +wfaxreg +wfaxrep +wfaxsep +wfaxun +wfelirr +wff +wffr +wfgru +wfi +wfii +wfinduction +wfis +wfis2 +wfis2f +wfis2fg +wfis2g +wfis3 +wfisg +wfr1 +wfr2 +wfr2a +wfr3 +wfr3g +wfrdmcl +wfrdmss +wfrfun +wfrrel +wfrresex +wfximgfd +where +width_eq_part +width_lem +wiener_covering_lemma_balls +wiener_covering_lemma_cballs +wilson_theorem +wilth +wilthimp +wilthlem1 +wilthlem2 +wilthlem3 +winacard +winafp +winafpi +winainf +winainflem +winalim +winalim2 +winaon +wind_farm_placement +winduction +with +within_univ +within_within +witness `a` +witness `cons(tt, l)` +witness `factorial(n)+1` +witness_exists +witnessed_stable +wksfval +wkslem1 +wkslem2 +wksonproplem +wksv +wl-19.2reqv +wl-19.8eqv +wl-1mintru1 +wl-1mintru2 +wl-1xor +wl-2mintru1 +wl-2mintru2 +wl-2sb6d +wl-2spsbbi +wl-2xor +wl-3xorbi +wl-3xorbi123d +wl-3xorbi123i +wl-3xorbi2 +wl-3xorcoma +wl-3xorcomb +wl-3xorfal +wl-3xornot +wl-3xornot1 +wl-3xorrot +wl-3xortru +wl-aetr +wl-alanbii +wl-aleq +wl-ax12v2cl +wl-ax13lem1 +wl-axc11r +wl-axc11rc11 +wl-cases2-dnf +wl-cbvalnae +wl-cbvalnaed +wl-cbvalsbi +wl-cbvmotv +wl-clabt +wl-clabtv +wl-clabv +wl-cleq-0 +wl-cleq-1 +wl-cleq-2 +wl-cleq-3 +wl-cleq-4 +wl-cleq-5 +wl-cleq-6 +wl-df-3mintru2 +wl-df-3xor +wl-df-clab +wl-df2-3mintru2 +wl-df3-3mintru2 +wl-df3maxtru1 +wl-df3xor2 +wl-df3xor3 +wl-df4-3mintru2 +wl-dfclab +wl-dral1d +wl-embant +wl-equsal +wl-equsal1i +wl-equsal1t +wl-equsalcom +wl-equsald +wl-equsaldv +wl-equsalvw +wl-equsb3 +wl-equsb4 +wl-euae +wl-eudf +wl-euequf +wl-eujustlem1 +wl-eutf +wl-exeq +wl-hbae1 +wl-ifp-ncond1 +wl-ifp-ncond2 +wl-ifp4impr +wl-ifpimpr +wl-impchain-a1-1 +wl-impchain-a1-2 +wl-impchain-a1-3 +wl-impchain-a1-x +wl-impchain-com-1.1 +wl-impchain-com-1.2 +wl-impchain-com-1.3 +wl-impchain-com-1.4 +wl-impchain-com-1.x +wl-impchain-com-2.3 +wl-impchain-com-2.4 +wl-impchain-com-3.2.1 +wl-impchain-com-n.m +wl-impchain-mp-0 +wl-impchain-mp-1 +wl-impchain-mp-2 +wl-impchain-mp-x +wl-isseteq +wl-issetft +wl-lem-exsb +wl-lem-moexsb +wl-lem-nexmo +wl-luk-a1d +wl-luk-a1i +wl-luk-ax1 +wl-luk-ax2 +wl-luk-ax3 +wl-luk-com12 +wl-luk-con1i +wl-luk-con4i +wl-luk-id +wl-luk-imim1i +wl-luk-imim2 +wl-luk-imim2i +wl-luk-imtrdi +wl-luk-imtrid +wl-luk-ja +wl-luk-mpi +wl-luk-notnotr +wl-luk-pm2.04 +wl-luk-pm2.18d +wl-luk-pm2.21 +wl-luk-pm2.24i +wl-luk-pm2.27 +wl-luk-syl +wl-mo2df +wl-mo2t +wl-mo2tf +wl-mo3t +wl-moae +wl-motae +wl-moteq +wl-mps +wl-naevhba1v +wl-nax6im +wl-nfae1 +wl-nfalv +wl-nfeqfb +wl-nfimf1 +wl-nfnae1 +wl-nfs1t +wl-nfsbtv +wl-orel12 +wl-sb8eft +wl-sb8et +wl-sb8eut +wl-sb8eutv +wl-sb8ft +wl-sb8mot +wl-sb8motv +wl-sb8t +wl-sb9v +wl-sbal1 +wl-sbal2 +wl-sbalnae +wl-sbcom2d +wl-sbcom2d-lem1 +wl-sbcom2d-lem2 +wl-sbhbt +wl-sbid2ft +wl-sblimt +wl-sbnf1 +wl-sbrimt +wl-section-boot +wl-section-impchain +wl-section-prop +wl-spae +wl-speqv +wl-syls1 +wl-syls2 +wlimeq1 +wlimeq12 +wlimeq2 +wlimss +wlk0prc +wlk1ewlk +wlk1walk +wlk2f +wlk2v2e +wlk2v2elem1 +wlk2v2elem2 +wlkcl +wlkcomp +wlkcompim +wlkcpr +wlkd +wlkdlem1 +wlkdlem2 +wlkdlem3 +wlkdlem4 +wlkelwrd +wlkepvtx +wlkeq +wlkf +wlkiswwlks +wlkiswwlks1 +wlkiswwlks2 +wlkiswwlks2lem1 +wlkiswwlks2lem2 +wlkiswwlks2lem3 +wlkiswwlks2lem4 +wlkiswwlks2lem5 +wlkiswwlks2lem6 +wlkiswwlksupgr2 +wlkiswwlkupgr +wlkl0 +wlkl1loop +wlklenvclwlk +wlklenvm1 +wlklenvp1 +wlklnwwlkln1 +wlklnwwlkln2 +wlklnwwlkln2lem +wlklnwwlklnupgr2 +wlklnwwlkn +wlklnwwlknupgr +wlkn0 +wlknewwlksn +wlknwwlksnbij +wlknwwlksnen +wlknwwlksneqs +wlkon2n0 +wlkoniswlk +wlkonl1iedg +wlkonprop +wlkonwlk +wlkonwlk1l +wlkop +wlkp +wlkp1 +wlkp1lem1 +wlkp1lem2 +wlkp1lem3 +wlkp1lem4 +wlkp1lem5 +wlkp1lem6 +wlkp1lem7 +wlkp1lem8 +wlkprop +wlkpvtx +wlkpwrd +wlkres +wlkreslem +wlksnfi +wlksnwwlknvbij +wlkson +wlksoneq1eq2 +wlkswwlksen +wlkswwlksf1o +wlkv +wlkv0 +wlkvtxedg +wlkvtxeledg +wlkvtxiedg +wlkvv +wlog_le +wlog_linear_injective_image +wlog_linear_injective_image_2 +wlog_linear_injective_image_2_alt +wlog_linear_injective_image_alt +wlog_lt +wlog_tac +wlogle +wloglei +wnefimgd +wofi +wofib +wop +wop_measure +wopprc +workforce_planning +wpthswwlks2on +wrd0 +wrd2f1tovbij +wrd2ind +wrd2pr2op +wrd3tpop +wrdco +wrddm +wrdeq +wrdeqi +wrdeqs1cat +wrdexb +wrdexg +wrdexi +wrdf +wrdfd +wrdffz +wrdfin +wrdfn +wrdfsupp +wrdind +wrdl1exs1 +wrdl1s1 +wrdl2exs2 +wrdl3s3 +wrdlen1 +wrdlen2 +wrdlen2i +wrdlen2s2 +wrdlen3s3 +wrdlenccats1lenm1 +wrdlenge1n0 +wrdlenge2n0 +wrdlndm +wrdmap +wrdnfi +wrdnval +wrdpmcl +wrdpmtrlast +wrdred1 +wrdred1hash +wrdres +wrdsplex +wrdsymb +wrdsymb0 +wrdsymb1 +wrdsymbcl +wrdt2ind +wrdumgr +wrdupgr +wrdv +wrdval +wrecseq1 +wrecseq123 +wrecseq2 +wrecseq3 +wspn0 +wspniunwspnon +wspthneq1eq2 +wspthnfi +wspthnon +wspthnonfi +wspthnonp +wspthnp +wspthsn +wspthsnon +wspthsnonn0vne +wspthsnwspthsnon +wspthsswwlkn +wspthsswwlknon +wsuccl +wsuceq1 +wsuceq123 +wsuceq2 +wsuceq3 +wsucex +wsuclb +wsuclem +wtgoldbnnsum4prm +wtype +wun0 +wunccl +wuncid +wuncidm +wuncn +wuncnv +wunco +wuncss +wuncval +wuncval2 +wundif +wundm +wunelss +wunex +wunex2 +wunex3 +wunf +wunfi +wunfunc +wunfv +wunin +wunint +wunmap +wunnat +wunndx +wunom +wunop +wunot +wunpm +wunpr +wunpw +wunr1om +wunres +wunress +wunrn +wunsets +wunsn +wunss +wunstr +wunsuc +wuntp +wuntpos +wuntr +wunun +wununi +wunxp +wwlemuld +wwlkbp +wwlknbp +wwlknbp1 +wwlknllvtx +wwlknlsw +wwlknon +wwlknp +wwlknvtx +wwlks +wwlks2onsym +wwlks2onv +wwlkseq +wwlksext2clwwlk +wwlksm1edg +wwlksn +wwlksn0 +wwlksn0s +wwlksnext +wwlksnextbi +wwlksnextbij +wwlksnextbij0 +wwlksnextfun +wwlksnexthasheq +wwlksnextinj +wwlksnextprop +wwlksnextproplem1 +wwlksnextproplem2 +wwlksnextproplem3 +wwlksnextsurj +wwlksnextwrd +wwlksnfi +wwlksnndef +wwlksnon +wwlksnon0 +wwlksnonfi +wwlksnprcl +wwlksnred +wwlksnredwwlkn +wwlksnredwwlkn0 +wwlksnwwlksnon +wwlksonvtx +wwlkssswrd +wwlkssswwlksn +wwlksubclwwlk +wwlkswwlksn +wwlktovf +wwlktovf1 +wwlktovf1o +wwlktovfo +wzel +x +x2times +x_choose_tac +x_choose_then +x_clauses +x_congruent +x_congruent_2nj_neg +x_congruent_2nj_neg_lemma +x_congruent_2nj_pos +x_congruent_4mnj_pos +x_congruent_4nj_pos +x_def +x_degenerate +x_gen_tac +x_half_half +x_increases +x_increases_le +x_increases_lt +x_increases_suc +x_inj +x_le_div +x_le_x_exp +x_lt_div +x_lt_exp_x +x_lt_exp_x_iff +x_mod_y_eq_x +x_spec +xadd0ge +xadd0ge2 +xadd4d +xaddass +xaddass2 +xaddcl +xaddcld +xaddcom +xaddcomd +xadddi +xadddi2 +xadddi2r +xadddilem +xadddir +xaddeq0 +xaddf +xaddge0 +xaddlid +xaddlidd +xaddmnf1 +xaddmnf2 +xaddnemnf +xaddnepnf +xaddpnf1 +xaddpnf2 +xaddrid +xaddridd +xaddval +xblcntr +xblcntrps +xbln0 +xblpnf +xblpnfps +xblss2 +xblss2ps +xchbinx +xchbinxr +xchnxbi +xchnxbir +xdiv0 +xdiv0rp +xdivcl +xdivcld +xdivid +xdivmul +xdivpnfrp +xdivrec +xdivval +xeqlelt +xfree +xfree2 +xgepnf +xihopellsmn +xis_lem +xkobval +xkoccn +xkocnv +xkoco1cn +xkoco2cn +xkococn +xkococnlem +xkofvcn +xkohaus +xkohmeo +xkoinjcn +xkoopn +xkopjcn +xkopt +xkoptsub +xkotf +xkotop +xkotopon +xkouni +xkoval +xle0neg1 +xle0neg2 +xle2add +xle2addd +xleadd1 +xleadd1a +xleadd1d +xleadd2a +xleadd2d +xlebnum +xlemnf +xlemul1 +xlemul1a +xlemul2 +xlemul2a +xleneg +xlenegcon1 +xlenegcon2 +xlesubadd +xlimbr +xlimcl +xlimclim +xlimclim2 +xlimclim2lem +xlimclimdm +xlimconst +xlimconst2 +xlimdm +xlimfun +xlimliminflimsup +xlimlimsupleliminf +xlimmnf +xlimmnflimsup +xlimmnflimsup2 +xlimmnfmpt +xlimmnfv +xlimmnfvlem1 +xlimmnfvlem2 +xlimpnf +xlimpnfliminf +xlimpnfliminf2 +xlimpnfmpt +xlimpnfv +xlimpnfvlem1 +xlimpnfvlem2 +xlimpnfxnegmnf +xlimpnfxnegmnf2 +xlimrel +xlimres +xlimresdm +xlimuni +xlimxrre +xlt0neg1 +xlt0neg2 +xlt2add +xlt2addrd +xltadd1 +xltadd2 +xltmul1 +xltmul2 +xltneg +xltnegi +xmet0 +xmetcl +xmetdcn +xmetdcn2 +xmetdmdm +xmetec +xmeteq0 +xmeter +xmeterval +xmetf +xmetge0 +xmetgt0 +xmetlecl +xmetpsmet +xmetres +xmetres2 +xmetresbl +xmetrtri +xmetrtri2 +xmetsym +xmettpos +xmettri +xmettri2 +xmettri3 +xmetunirn +xmetutop +xmscl +xmseq0 +xmsge0 +xmspropd +xmssym +xmstopn +xmstps +xmstri +xmstri2 +xmstri3 +xmstrkgc +xmsusp +xmsxmet +xmsxmet2 +xmul01 +xmul02 +xmulass +xmulasslem +xmulasslem2 +xmulasslem3 +xmulcand +xmulcl +xmulcld +xmulcom +xmulf +xmulge0 +xmulgt0 +xmullem +xmullem2 +xmullid +xmulm1 +xmulmnf1 +xmulmnf2 +xmulneg1 +xmulneg2 +xmulpnf1 +xmulpnf1n +xmulpnf2 +xmulrid +xmulval +xneg0 +xneg11 +xnegcl +xnegcld +xnegcli +xnegdi +xnegeq +xnegeqd +xnegeqi +xnegex +xnegid +xnegmnf +xnegneg +xnegnegd +xnegnegi +xnegpnf +xnegre +xnegrecl +xnegrecl2 +xnegrecl2d +xnegred +xnn01gt +xnn0add4d +xnn0ge0 +xnn0gt0 +xnn0le2is012 +xnn0lem1lt +xnn0lenn0nn0 +xnn0n0n1ge2b +xnn0nemnf +xnn0nn0d +xnn0nnd +xnn0nnn0pnf +xnn0xadd0 +xnn0xaddcl +xnn0xr +xnn0xrge0 +xnn0xrnemnf +xnor +xnpcan +xor +xor2 +xor3 +xor_involutive +xorass +xorbi12d +xorbi12i +xorcom +xordi +xorexmid +xornan +xornan2 +xorneg +xorneg1 +xorneg2 +xoromon +xoror +xov1plusxeqvd +xp0 +xp01disj +xp01disjl +xp0old +xp11 +xp1d2m1eqxm1d2 +xp1en +xp1st +xp2 +xp2dju +xp2nd +xpab +xpassen +xpcan +xpcan2 +xpcbas +xpccat +xpccatid +xpcco +xpcco1st +xpcco2 +xpcco2nd +xpccofval +xpcfucbas +xpcfucco2 +xpcfucco3 +xpcfuccocl +xpcfuchom +xpcfuchom2 +xpcfuchomfval +xpchom +xpchom2 +xpchomfval +xpcid +xpco +xpco2 +xpcogend +xpcoid +xpcoidgend +xpcomco +xpcomen +xpcomeng +xpcomf1o +xpcpropd +xpct +xpcval +xpdifid +xpdisj1 +xpdisj2 +xpdisjres +xpdjuen +xpdom1 +xpdom1g +xpdom2 +xpdom2g +xpdom3 +xpen +xpeq0 +xpeq1 +xpeq12 +xpeq12d +xpeq12i +xpeq1d +xpeq1i +xpeq2 +xpeq2d +xpeq2i +xpex +xpexb +xpexcnv +xpexd +xpexg +xpexgalt +xpexr +xpexr2 +xpf1o +xpfi +xpfir +xphe +xpid11 +xpider +xpidtr +xpiindi +xpima +xpima1 +xpima2 +xpimasn +xpindi +xpindir +xpinintabd +xpinpreima +xpinpreima2 +xpintrreld +xpiun +xpiundi +xpiundir +xpmapen +xpmapenlem +xpncan +xpnnen +xpnum +xpnz +xpomen +xpopth +xpord2ind +xpord2indlem +xpord2lem +xpord2pred +xpord3ind +xpord3indd +xpord3inddlem +xpord3lem +xpord3pred +xporderlem +xposdif +xppreima +xppreima2 +xpprsng +xppss12 +xpriindi +xpsadd +xpsaddlem +xpsbas +xpscf +xpsdsfn +xpsdsfn2 +xpsdsval +xpsfeq +xpsff1o +xpsff1o2 +xpsfrn +xpsfrnel +xpsfrnel2 +xpsfval +xpsgrp +xpsgrpsub +xpsinv +xpsle +xpsless +xpsmet +xpsmnd +xpsmnd0 +xpsms +xpsmul +xpsn +xpsndisj +xpsnen +xpsnen2g +xpsneng +xpsng +xpsnopab +xpsring1d +xpsringd +xpsrnbas +xpsrngd +xpss +xpss1 +xpss12 +xpss2 +xpssca +xpsspw +xpssres +xpstopn +xpstopnlem1 +xpstopnlem2 +xpstps +xpsval +xpsvsca +xpsxmet +xpsxmetlem +xpsxms +xptrrel +xpun +xpundi +xpundir +xpv +xpwdomg +xpwf +xraddge02 +xralrple +xralrple2 +xralrple3 +xralrple4 +xrcmp +xrconn +xrdifh +xreceu +xrecex +xreqle +xreqled +xreqnltd +xrex +xrge00 +xrge0addass +xrge0addcld +xrge0adddi +xrge0adddir +xrge0addge +xrge0addgt0 +xrge0base +xrge0cmn +xrge0f +xrge0ge0 +xrge0gsumle +xrge0haus +xrge0hmph +xrge0iif1 +xrge0iifcnv +xrge0iifcv +xrge0iifhmeo +xrge0iifhom +xrge0iifiso +xrge0iifmhm +xrge0infss +xrge0infssd +xrge0le +xrge0mulc1cn +xrge0mulgnn0 +xrge0nemnfd +xrge0neqmnf +xrge0npcan +xrge0nre +xrge0omnd +xrge0pluscn +xrge0plusg +xrge0slmod +xrge0subcld +xrge0subm +xrge0tmd +xrge0tmdalt +xrge0topn +xrge0tps +xrge0tsms +xrge0tsms2 +xrge0tsmsbi +xrge0tsmsd +xrge0tsmseq +xrgepnfd +xrgtned +xrgtnelicc +xrgtso +xrhaus +xrhmeo +xrhmph +xrhval +xrinf0 +xrinfm +xrinfmexpnf +xrinfmss +xrinfmss2 +xrinfmsslem +xrleid +xrleidd +xrleloe +xrleltne +xrlelttr +xrlelttrd +xrlelttric +xrlemin +xrleneltd +xrlenlt +xrlenltd +xrletr +xrletrd +xrletri +xrletri3 +xrletrid +xrlexaddrp +xrlimcnp +xrltle +xrltled +xrltlen +xrltletr +xrltletrd +xrltmin +xrltne +xrltned +xrltnle +xrltnled +xrltnr +xrltnsym +xrltnsym2 +xrltso +xrlttr +xrlttrd +xrlttri +xrlttri2 +xrlttri3 +xrlttri5d +xrmax1 +xrmax2 +xrmaxeq +xrmaxle +xrmaxlt +xrmin1 +xrmin2 +xrmineq +xrmulc1cn +xrnarchi +xrncnvepresex +xrnemnf +xrnepnf +xrneq1 +xrneq12 +xrneq12d +xrneq12i +xrneq1d +xrneq1i +xrneq2 +xrneq2d +xrneq2i +xrnidresex +xrninxp +xrninxp2 +xrninxpex +xrnltled +xrnmnfpnf +xrnpnfmnf +xrnrel +xrnres +xrnres2 +xrnres3 +xrnres4 +xrnresex +xrnss3v +xrofsup +xrpnf +xrpxdivcld +xrralrecnnge +xrralrecnnle +xrre +xrre2 +xrre3 +xrre4 +xrrebnd +xrred +xrrege0 +xrrest +xrrest2 +xrs0 +xrs10 +xrs1cmn +xrs1mnd +xrsadd +xrsbas +xrsblre +xrsclat +xrsds +xrsdsre +xrsdsreclb +xrsdsreclblem +xrsdsreval +xrsdsval +xrsex +xrsinvgval +xrsle +xrslt +xrsmcmn +xrsmgm +xrsmgmdifsgrp +xrsmopn +xrsmul +xrsmulgzz +xrsnsgrp +xrsp0 +xrsp1 +xrssre +xrsstr +xrstopn +xrstos +xrstps +xrstset +xrsup +xrsup0 +xrsupexmnf +xrsupss +xrsupssd +xrsupsslem +xrsxmet +xrtgcntopre +xrtgioo +xrtgioo2 +xrub +xsubge0 +xy_are_solutions +xy_coprime +xy_exp +xy_exp_lemma +xy_gcd +xy_gcd_lemma +xy_power_neg +xy_power_pos +xy_y3_congruence +y2_divides +y_0 +y_0_triv +y_clauses +y_congruent +y_def +y_degenerate +y_dioph +y_divides +y_divides_lemma +y_eq_0 +y_increases +y_increases_le +y_increases_lt +y_increases_suc +y_inj +y_lowerbound +y_n_mod2 +y_n_moda1 +y_spec +y_upperbound +yield_optimization +yon11 +yon12 +yon1cl +yon2 +yoncl +yoneda +yonedainv +yonedalem1 +yonedalem21 +yonedalem22 +yonedalem3 +yonedalem3a +yonedalem3b +yonedalem4a +yonedalem4b +yonedalem4c +yonffth +yonffthlem +yoniso +yonpropd +yonval +young2d +z0even +z12addscl +z12bday +z12bdaylem +z12bdaylem1 +z12bdaylem2 +z12negscl +z12negsclb +z12no +z12sex +z12sge0 +z12shalf +z12subscl +z12zsodd +z2even +z2ge +z4even +zabs0b +zabscl +zabsle1 +zadd2cl +zaddablx +zaddcl +zaddcld +zaddcom +zaddcomlem +zaddscl +zaddscld +zar0ring +zarcls +zarcls0 +zarcls1 +zarclsiin +zarclsint +zarclssn +zarclsun +zarcmp +zarcmplem +zarmxt1 +zart0 +zartop +zartopn +zartopon +zbtwnre +zcld +zcld2 +zclmncvs +zcn +zcnd +zconstr +zct +zcuts +zcuts0 +zdend +zdis +zdiv +zdivadd +zdivgd +zdivmul +zefldiv2 +zefldiv2altv +zeneo +zenom +zeo +zeo2 +zeo2altv +zeo3 +zeo4 +zeo5 +zeoaltv +zeqzmulgcd +zerdivemp1x +zermelo +zero +zero_add +zero_ae_derivative_imp_constant +zero_ae_derivative_imp_constant_gen +zero_div +zero_exp +zero_is_even +zero_le +zero_less_add +zero_less_eq +zero_less_exp +zero_lt_suc +zero_mod +zero_mul +zeroo2 +zeroofn +zeroopropd +zeroopropdlem +zeroorcl +zerooval +zesq +zetacvg +zex +zexalt +zexpcl +zexpcld +zexpgcd +zexpscl +zextle +zextlt +zfac +zfallfaccl +zfausab +zfauscl +zfbas +zfcndac +zfcndext +zfcndinf +zfcndpow +zfcndreg +zfcndrep +zfcndun +zfinf +zfinf2 +zfpair +zfpair2 +zfpow +zfreg +zfregcl +zfregclold +zfregfr +zfregs +zfregs2 +zfregs2vd +zfrep3cl +zfrep4 +zfrep6 +zfrepclf +zfun +zgcdsq +zgeltp1eq +zgt0ge1 +zgt1rpn0n1 +zgtp1leeq +zgz +zhmnrg +zindbi +zindd +zip +zip_drop +zip_eq_nil +zip_genlist +zip_ind +zip_ind_alt +zip_map +zip_nil_left +zip_nil_right +zip_unzip +zipwithlength +zle0orge1 +zleltp1 +zlem1lt +zletr +zlidlring +zlm0 +zlm1 +zlmassa +zlmbas +zlmclm +zlmds +zlmlem +zlmlmod +zlmmulr +zlmnm +zlmodzxz0 +zlmodzxzadd +zlmodzxzel +zlmodzxzequa +zlmodzxzequap +zlmodzxzldep +zlmodzxzldeplem +zlmodzxzldeplem1 +zlmodzxzldeplem2 +zlmodzxzldeplem3 +zlmodzxzldeplem4 +zlmodzxzlmod +zlmodzxznm +zlmodzxzscm +zlmodzxzsub +zlmodzxzsubm +zlmplusg +zlmsca +zlmtset +zlmval +zlmvsca +zltaddlt1le +zltlem1 +zltlem1d +zltlesub +zltp1le +zltp1led +zltp1ne +zm1nn +zmax +zmin +zmod10 +zmod1congr +zmodcl +zmodcld +zmodfz +zmodfzo +zmodfzp1 +zmodid2 +zmodidfzo +zmodidfzoimp +zmulcl +zmulcld +zmulcom +zmulcomlem +zmulscld +zn0subs +znadd +znbas +znbas2 +znbaslem +znchr +zncrng +zncrng2 +zncyg +zndvdchrrhm +zndvds +zndvds0 +znegcl +znegclb +znegcld +znegscl +znegscld +zneo +zneoaltv +znf1o +znfermltl +znfi +znfld +znhash +znidomb +znle +znle2 +znleval +znleval2 +znlidl +znmul +znn0sub +znnen +znnn0nn +znnnlt1 +znnsub +zno +znod +znq +znrrg +znsqcld +zntos +zntoslem +znumd +znunit +znunithash +znval +znval2 +znzrh +znzrh2 +znzrhfo +znzrhval +zob +zofldiv2 +zofldiv2altv +zorn +zorn2 +zorn2g +zorn2lem1 +zorn2lem2 +zorn2lem3 +zorn2lem4 +zorn2lem5 +zorn2lem6 +zorn2lem7 +zorng +zornn0 +zornn0g +zp1modne +zplusmodne +zpnn0elfzo +zpnn0elfzo1 +zprod +zprodn0 +zq +zrdivrng +zre +zred +zrei +zrevaddcl +zrh0 +zrh1 +zrhchr +zrhcntr +zrhcopsgnelbas +zrhf1ker +zrhker +zrhmulg +zrhneg +zrhnm +zrhpropd +zrhpsgnelbas +zrhpsgnevpm +zrhpsgninv +zrhpsgnmhm +zrhpsgnodpm +zrhre +zrhrhm +zrhrhmb +zrhunitpreima +zrhval +zrhval2 +zring0 +zring1 +zringabl +zringbas +zringcrng +zringcyg +zringfrac +zringgrp +zringidom +zringinvg +zringlpir +zringlpirlem1 +zringlpirlem2 +zringlpirlem3 +zringmpg +zringmulg +zringmulr +zringndrg +zringnm +zringnrg +zringnzr +zringpid +zringplusg +zringring +zringrng +zringsub +zringsubgval +zringunit +zrinitorngc +zriotaneg +zrisefaccl +zrninitoringc +zrrnghm +zrtdvds +zrtelqelz +zrtermoringc +zrtermorngc +zrzeroorngc +zsbday +zseo +zsex +zsoring +zsqcl +zsqcl2 +zsqrtelqelz +zsscn +zssno +zssq +zssre +zsssubrg +zssxr +zsubcl +zsubcld +zsubrg +zsubscld +zsum +zsupss +ztprmneprm +zxrd +zz12s +zzlesq +zzngim +zzsnm +|(< +|(equal +|(natp +|x +~10 diff --git a/models/tactic_vocab.txt b/models/tactic_vocab.txt index 4f1985a..e17be0e 100644 --- a/models/tactic_vocab.txt +++ b/models/tactic_vocab.txt @@ -1,422 +1,6130 @@ 0 1 2 +2025 +2026 3 4 5 a ab +abbrev_tac +abs-tp +abs_conv +abs_lt_representation +abs_nonneg +abs_tac +absolutely_continuous_comparison +absolutely_continuous_extends_to_closure +absolutely_continuous_integral +absolutely_continuous_isometric +absolutely_continuous_lipschitz_compose +absolutely_continuous_measure_image +absolutely_continuous_on_add +absolutely_continuous_on_bilinear +absolutely_continuous_on_closure +absolutely_continuous_on_cmul +absolutely_continuous_on_cmul_eq +absolutely_continuous_on_componentwise +absolutely_continuous_on_const +absolutely_continuous_on_eq +absolutely_continuous_on_id +absolutely_continuous_on_imp_continuous +absolutely_continuous_on_interior +absolutely_continuous_on_norm +absolutely_continuous_on_null +absolutely_continuous_on_sub +absolutely_continuous_on_subset +absolutely_continuous_on_vmul_eq +absolutely_continuous_vector_variation +absolutely_integrable_abs +absolutely_integrable_abs_eq +absolutely_integrable_add +absolutely_integrable_cmul +absolutely_integrable_cmul_eq +absolutely_integrable_componentwise +absolutely_integrable_const +absolutely_integrable_continuous +absolutely_integrable_convolution_sym +absolutely_integrable_eq_integrable_pos +absolutely_integrable_imp_integrable +absolutely_integrable_integrable_bound +absolutely_integrable_lebesgue_points +absolutely_integrable_max +absolutely_integrable_measurable +absolutely_integrable_min +absolutely_integrable_neg +absolutely_integrable_norm +absolutely_integrable_on_const +absolutely_integrable_on_indicator +absolutely_integrable_on_null +absolutely_integrable_on_open_interval +absolutely_integrable_on_subinterval +absolutely_integrable_pastecart_sym_univ +absolutely_integrable_reflect_gen +absolutely_integrable_restrict_inter +absolutely_integrable_restrict_univ +absolutely_integrable_set_variation +absolutely_integrable_spike +absolutely_integrable_spike_eq +absolutely_integrable_spike_set_eq +absolutely_integrable_sub +absolutely_integrable_union +absolutely_setcontinuous_comparison +absolutely_setcontinuous_on_add +absolutely_setcontinuous_on_alt +absolutely_setcontinuous_on_cmul +absolutely_setcontinuous_on_division +absolutely_setcontinuous_on_eq +absolutely_setcontinuous_on_neg +absolutely_setcontinuous_on_null +absolutely_setcontinuous_on_sub +absolutely_setcontinuous_on_subset +absolutely_summable_imp_cauchy +absurd ac acc +accept_tac +accepts +add +add-zero-left +add-zero-right +add_ac +add_assoc +add_clauses +add_comm +add_commutes +add_sub +add_suc +add_sym +addassoc +addcomm +addition_formula_neg +addition_formula_pos +additive_content_tagged_division +additivity +adjoint_adjoint +adjoint_clauses +adjoint_compose +adjoint_injective +adjoint_injective_injective +adjoint_linear +adjoint_matrix +adjoint_unique +adjoint_works +admissible_imp_superadmissible +advanced +aff_dim +aff_dim_affine_hull +aff_dim_affine_independent +aff_dim_convex_hull +aff_dim_dim +aff_dim_dim_affine_diffs_strong +aff_dim_dim_subspace +aff_dim_empty +aff_dim_eq_affine_hull +aff_dim_eq_full +aff_dim_eq_full_gen +aff_dim_eq_hyperplane +aff_dim_ge +aff_dim_halfspace_ge +aff_dim_halfspace_le +aff_dim_hyperplane +aff_dim_insert +aff_dim_le_card +aff_dim_le_dim +aff_dim_le_univ +aff_dim_linear_image_le +aff_dim_nonempty_interior +aff_dim_nonempty_interior_eq +aff_dim_nonempty_interior_of +aff_dim_open +aff_dim_open_in +aff_dim_relative_interior +aff_dim_segment +aff_dim_simplex +aff_dim_sing +aff_dim_subset +aff_dim_translation_eq +aff_dim_union +aff_dim_univ +affine +affine_affine_hull +affine_affinity_eq +affine_alt +affine_basis_exists +affine_bounded_eq_lowdim +affine_bounded_eq_trivial +affine_dependent_biggerset +affine_dependent_choose +affine_dependent_explicit +affine_dependent_explicit_finite +affine_dependent_mono +affine_dependent_translation_eq +affine_diffs_subspace +affine_empty +affine_eq_subspace +affine_hull_closure +affine_hull_conic_hull +affine_hull_convex_hull +affine_hull_convex_inter_open +affine_hull_convex_inter_open_in +affine_hull_empty +affine_hull_eq +affine_hull_eq_empty +affine_hull_eq_span +affine_hull_explicit +affine_hull_explicit_alt +affine_hull_finite +affine_hull_finite_step +affine_hull_finite_step_gen +affine_hull_halfspace_ge +affine_hull_halfspace_gt +affine_hull_halfspace_le +affine_hull_halfspace_lt +affine_hull_insert_span +affine_hull_insert_subset_span +affine_hull_linear_image +affine_hull_nonempty_interior +affine_hull_open +affine_hull_open_in +affine_hull_open_in_convex +affine_hull_pcross +affine_hull_relative_interior +affine_hull_scaling +affine_hull_segment +affine_hull_sing +affine_hull_span +affine_hull_subset_span +affine_hull_translation +affine_hull_univ +affine_hulls_eq +affine_hyperplane +affine_imp_convex +affine_imp_polyhedron +affine_imp_subspace +affine_independent_card_dim_diffs +affine_independent_card_le +affine_independent_empty +affine_independent_iff_card +affine_independent_imp_finite +affine_independent_insert +affine_independent_span_eq +affine_independent_subset +affine_inters +affine_linear_image +affine_linear_preimage +affine_parallel_slice +affine_pcross +affine_scaling +affine_scaling_eq +affine_sing +affine_span +affine_sums +affine_translation +affine_translation_eq +affine_translation_subspace +affine_univ +affine_vsum +affinity_scaling_translation +against +agda +all +all_different(array1d(square)) +all_different(assign) +all_different(order) +all_different(queens) +all_tac +alldifferent(array1d(cell)) +alldifferent(assign) +alldifferent(letter) +alpha-eq +always_eventually +analytic_borel_measurable_preimage +analytic_continuous_image +analytic_empty +analytic_inter +analytic_inters +analytic_pcross +analytic_unions +analytic_univ and +and-comm +and_forall_thm +andelim +andl1 +andr +ante_res_then +antiderivative_continuous +ants_tac +any_closest_point_affine_orthogonal +any_closest_point_dot +any_closest_point_unique +ap_term +ap_term_tac +ap_thm +ap_thm_tac app +app_assoc +app_nil_r +append +append-assoc +append_linear_image +append_nil +append_translation apply +apply h +applyantisym +applysym +approachable_lt_le +approximable_on_division +arb +arc_distinct_ends +arc_image_unique +arc_imp_path +arc_length_minimal +arc_length_reparametrization +arc_simple_path argument +arith +arith_eq +arith_even +arith_odd +arith_rule +arith_suc +arith_tac +arithmetic +array +arzela_ascoli as +asm +asm_arith_tac +asm_cases_tac +asm_int_arith_tac +asm_meson_tac +asm_metis_tac +asm_real_arith_tac +asm_rewrite_tac +asm_simp_tac assert +assert_tac assoc +assume +assume a +assume b +assume f +assume g +assume h +assume h na +assume h p0 +assume h1 +assume h2 +assume ih +assume ih1 ih2 +assume l' +assume m +assume na nb +assume nb +assume p0 step +assume p_leaf p_node +assume p_nil p_cons +assume w +assume wf ih +assume_tac assumption +ast +at_infinity +at_neginfinity +at_posinfinity +atpointof auto +axiom +axiomcompleteness +axioms b +baby_sard +baby_sard_alt +backend backward +backward_induction +baire +baire_add +baire_bilinear +baire_cases +baire_category +baire_cmul +baire_componentwise +baire_compose +baire_compose_continuous +baire_const +baire_continuous_compose_univ +baire_eq +baire_eq_fsigma_preimage_open +baire_eq_fsigma_preimage_open_gen +baire_eq_gdelta_preimage_closed +baire_eq_gdelta_preimage_closed_gen +baire_imp_borel_measurable +baire_imp_measurable_on +baire_indicator_bijective_linear_image +baire_indicator_complement +baire_indicator_complement_univ +baire_indicator_continuous_preimage +baire_indicator_continuous_preimage_univ +baire_indicator_diff +baire_indicator_empty +baire_indicator_injective_linear_image +baire_indicator_inter +baire_indicator_suc +baire_indicator_translation +baire_indicator_union +baire_indicator_univ +baire_mono +baire_mul +baire_norm +baire_pastecart +baire_product +baire_sub +baire_subset +baire_vsum +ball_empty +ball_eq_empty +ball_interval +ball_scaling +ball_subset_cball +ball_trivial +banach_fix +banach_sproperty_imp_luzin_nproperty +barinduction +barycentre_in_convex_hull +barycentre_in_relative_interior base +based +basic +basictotality +basis_card_eq_dim +basis_component +basis_coordinates_lipschitz +basis_exists +basis_exists_finite +basis_expansion +basis_has_size_dim +basis_inj +basis_nonzero +basis_orthogonal +basis_subspace_exists +bayesdef bc +beppo_levi_decreasing +beppo_levi_increasing +beta-red +beta_reduce +beta_tac +between_dist_le +between_dist_lt +between_imp_collinear +between_in_convex_hull +between_in_segment +between_midpoint +between_norm +between_refl_eq +between_translation +bigstep +bigstep-det +bigstep-of +bigstep-smallstep +bigstep-value +bijection +bijective_left_right_inverse +bilinear_bounded +bilinear_bounded_pos +bilinear_continuous_compose +bilinear_continuous_on +bilinear_continuous_on_compose +bilinear_differentiable_at_compose +bilinear_differentiable_on_compose +bilinear_differentiable_within_compose +bilinear_dot +bilinear_drop_mul +bilinear_epsilon_delta +bilinear_eq +bilinear_ladd +bilinear_lift_mul +bilinear_lmul +bilinear_lneg +bilinear_lsub +bilinear_lsum +bilinear_lzero +bilinear_matrix_mul +bilinear_matrix_vector_mul +bilinear_mul_drop +bilinear_radd +bilinear_rmul +bilinear_rneg +bilinear_rsub +bilinear_rsum +bilinear_swap +bilinear_uniformly_continuous_on_compose +bilinear_vsum +bilinear_vsum_partial_pre +bilinear_vsum_partial_suc +binder_conv +binding +binop_conv +binop_tac +bisection +bitvec +blaschke +blast +bolzano_weierstrass_imp_closed +bool +bool_cases_tac +borel_complement +borel_empty +borel_imp_analytic +borel_imp_lebesgue_measurable +borel_induct_compact +borel_induct_compact_unions_inters +borel_induct_unions_inters +borel_inter +borel_inters +borel_measurable_add +borel_measurable_bilinear +borel_measurable_cases +borel_measurable_cmul +borel_measurable_const +borel_measurable_continuous_compose +borel_measurable_eq +borel_measurable_extension +borel_measurable_imp_measurable_on +borel_measurable_mul +borel_measurable_norm +borel_measurable_pastecart +borel_measurable_sub +borel_pcross +borel_preimage_finite +borel_preimage_has_size +borel_unions +borel_univ +borrow +bounded_affinity_eq +bounded_and_diameter_le +bounded_ball +bounded_cball +bounded_closed_chain +bounded_closed_imp_compact +bounded_closed_interval +bounded_closure +bounded_closure_eq +bounded_convex_hull +bounded_diff +bounded_diffs +bounded_empty +bounded_eq_bolzano_weierstrass +bounded_frontier +bounded_halfspace_le +bounded_halfspace_lt +bounded_has_inf +bounded_has_sup +bounded_increasing_convergent +bounded_insert +bounded_inside +bounded_inter +bounded_interior +bounded_inters +bounded_interval +bounded_lift +bounded_linear_image +bounded_negations +bounded_pairs +bounded_partial_sums +bounded_path_image +bounded_pcross_eq +bounded_pos +bounded_pos_lt +bounded_relative_frontier +bounded_scaling +bounded_scaling_eq +bounded_search +bounded_segment +bounded_set_variation_from_pastecart +bounded_set_variation_on_pastecart +bounded_sing +bounded_subset +bounded_subset_ball +bounded_subset_cball +bounded_subset_closed_interval +bounded_subset_closed_interval_symmetric +bounded_subset_open_interval_symmetric +bounded_sums +bounded_sums_image +bounded_translation +bounded_translation_eq +bounded_uniformly_continuous_image +bounded_union +bounded_unions +bounded_variation_from_pastecart +bounded_vector_variation_on_pastecart +boundedsearch +box_elim +boyer_moore +brouwer +brouwer_fixed_point +brouwer_reduction_theorem +brouwer_reduction_theorem_gen +brouwer_surjective +bruijn +butlast +butlast_append +bv0 +bvadd +bvand +bvxor by +bycontradiction c +cancel +canonical +cantor_bendixson_gen +caratheodory +card +card_add_absorb_left +card_add_finite_eq +card_clauses +card_countable_cong +card_delete +card_eq_analytic_sets +card_eq_bijections +card_eq_borel_measurable_functions +card_eq_card +card_eq_cart +card_eq_closed_sets +card_eq_compact_sets +card_eq_connected +card_eq_euclidean +card_eq_gdelta_sets +card_eq_image +card_eq_imp_le +card_eq_interval +card_eq_open +card_eq_open_sets +card_eq_real_imp_uncountable +card_eq_sym +card_eq_trans +card_finite_cong +card_ge_dim_independent +card_image_eq_inj +card_image_inj +card_image_le +card_le_antisym +card_le_components_union +card_le_countable +card_le_dim_spanning +card_le_finite +card_le_inj +card_le_powerset +card_le_relational_full +card_le_subset +card_le_trans +card_le_univ +card_let_trans +card_lt_imp_disconnected +card_mul_lt_infinite +card_not_le +card_not_lt +card_numseg +card_numseg_lt +card_psubset_imp +card_sing +card_stdbasis +card_subset +card_suslin_eq +cart_eq +cart_eq_full case +case_tac +caseanalysis +caseanalysis `p(hd)` +caseanalysis `x >= 0` +caseanalysis `y >= 0` +casegcd cases +cases p +cases_on +catassoc +catidleft +catidright +cauchy +cauchy_absolutely_summable_subsequence +cauchy_continuous_extends_to_closure +cauchy_continuous_imp_continuous +cauchy_continuous_map_compose +cauchy_continuous_map_pastewise +cauchy_convergent_subsequence +cauchy_eq_summable +cauchy_imp_bounded +cauchy_in_euclidean +cauchy_in_imp_mbounded +cauchy_in_submetric +cball_empty +cball_eq_empty +cball_eq_sing +cball_interval +cball_scaling +cball_sing +cball_trivial +ccontr_tac +cell_complex_disjoint_relative_interiors +cell_complex_subdivision_exists +centre_in_ball +centre_in_cball +certs +chain +chainrule +chan +characteristic_polynomial +check +check_assume_tac choose +choose_large_compact_subset +choose_large_measurable_subset +choose_simplex +choose_subset +choose_subset_between +choose_subset_eq +choose_subset_strong +choose_subspace_of_subspace +choose_surrounding_simplex +choose_tac +choose_then +circuit(next) +claim +claim_tac classic +classical +classify +clause +clauses +cleanly +clopen +clopen_unions_components +closed_affine +closed_affine_hull +closed_affinity_eq +closed_boundedpreim_continuous_image +closed_cball +closed_closure +closed_compact_differences +closed_compact_in +closed_compact_sums +closed_components +closed_condensation_points +closed_conic_hull +closed_conic_hull_strong +closed_connected_component +closed_convex_cone_hull +closed_diff +closed_empty +closed_fip +closed_forall_in +closed_halfspace_component_ge +closed_halfspace_component_le +closed_halfspace_ge +closed_halfspace_le +closed_hyperplane +closed_imp_analytic +closed_imp_borel +closed_imp_fip +closed_imp_fip_compact +closed_imp_fsigma +closed_imp_gdelta +closed_imp_locally_compact +closed_in +closed_in_closed +closed_in_closed_eq +closed_in_closed_inter +closed_in_closed_trans +closed_in_closure_of +closed_in_compact +closed_in_compact_projection +closed_in_conic_hull +closed_in_connected_component +closed_in_derived_set +closed_in_diff +closed_in_empty +closed_in_eq_continuous_levelset +closed_in_euclidean +closed_in_fsigma +closed_in_imp_subset +closed_in_inter +closed_in_inter_closure +closed_in_inter_closure_of +closed_in_inters +closed_in_limpt +closed_in_locally_finite_unions +closed_in_mcomplete_imp_mcomplete +closed_in_pcross +closed_in_refl +closed_in_relative_to +closed_in_separated_union +closed_in_sing +closed_in_subset +closed_in_subset_trans +closed_in_subtopology +closed_in_subtopology_inter_closed_in +closed_in_subtopology_refl +closed_in_topspace +closed_in_trans +closed_in_union +closed_in_unions +closed_injective_linear_image +closed_injective_linear_image_eq +closed_inter +closed_inter_compact +closed_inters +closed_inters_compact +closed_interval +closed_interval_as_convex_hull +closed_interval_dropout +closed_interval_eq +closed_interval_image_unit_interval +closed_interval_left +closed_lift +closed_limpt +closed_local_homeomorphism_global +closed_map_fibre_neighbourhood +closed_map_imp_quotient_map +closed_map_preimage_neighbourhood +closed_map_sndcart +closed_negations +closed_path_image +closed_pcross +closed_pcross_eq +closed_relative_boundary +closed_relative_frontier +closed_relative_to +closed_scaling +closed_scaling_eq +closed_segment +closed_segment_linear_image +closed_sequential_limits +closed_sing +closed_span +closed_sphere +closed_strip_component_le +closed_subset +closed_subset_eq +closed_subspace +closed_translation +closed_translation_eq +closed_union +closed_unions +closed_univ +closer_point_lemma +closer_points_lemma +closest_point_affine_orthogonal +closest_point_affine_orthogonal_eq +closest_point_exists +closest_point_in_interior +closest_point_in_relative_interior +closest_point_in_set +closest_point_le +closest_point_lipschitz +closest_point_self +closest_point_subspace_orthogonal +closest_point_subspace_orthogonal_eq +closest_point_unique +closure_approachable +closure_ball +closure_closed +closure_closure +closure_complement +closure_conic_hull +closure_convex_hull +closure_convex_inter_superset +closure_dyadic_rationals +closure_dyadic_rationals_in_convex_set +closure_empty +closure_eq +closure_eq_empty +closure_halfspace_component_gt +closure_halfspace_component_lt +closure_halfspace_gt +closure_halfspace_lt +closure_hull +closure_hyperplane +closure_image_closure +closure_inc +closure_injective_linear_image +closure_inter_convex +closure_inter_subset +closure_interior +closure_interior_union_closed +closure_inters_convex +closure_inters_subset +closure_interval +closure_linear_image_subset +closure_minimal +closure_minimal_eq +closure_minimal_local +closure_negations +closure_of +closure_of_alt +closure_of_interior_of_idemp +closure_of_locally_finite_unions +closure_of_open_in_inter_superset +closure_of_restrict +closure_of_subset +closure_of_subtopology +closure_of_translation +closure_open_in_inter_closure +closure_open_inter_closure +closure_open_inter_superset +closure_open_interval +closure_pcross +closure_rational_coordinates +closure_scaling +closure_segment +closure_sequential +closure_sing +closure_sphere +closure_strip_component_lt +closure_subset +closure_subset_affine_hull +closure_subset_eq +closure_sums +closure_translation +closure_union +closure_univ +cnf +cofactor_cmul +cofactor_cofactor +cofactor_column +cofactor_i +cofactor_matrix_inv +cofactor_matrix_mul +cofactor_transp +collinear_aff_dim +collinear_affine_hull +collinear_affine_hull_collinear +collinear_alt +collinear_between_cases +collinear_dist_between +collinear_dist_in_closed_segment +collinear_empty +collinear_imp_coplanar +collinear_lemma +collinear_lemma_alt +collinear_linear_image +collinear_midpoint +collinear_sing +collinear_small +collinear_subset +collinear_translation_eq +collinear_triples +colouring +colours +column_matrix_mul +column_transp +columns_image_basis +columns_transp comm +commuting_matrix_inv_covariance +compact +compact_affinity_eq +compact_attains_inf +compact_attains_sup +compact_cball +compact_chain +compact_closed_differences +compact_closed_sums +compact_closure +compact_continuous_image +compact_convex_collinear_segment +compact_convex_collinear_segment_alt +compact_convex_hull +compact_differences +compact_empty +compact_eq_bolzano_weierstrass +compact_eq_bounded_closed +compact_eq_heine_borel +compact_eq_heine_borel_gen +compact_frontier +compact_frontier_bounded +compact_hausdist +compact_imp_analytic +compact_imp_borel +compact_imp_bounded +compact_imp_closed +compact_imp_complete +compact_imp_fip +compact_imp_heine_borel +compact_imp_totally_bounded +compact_in_absolute +compact_in_eq_bolzano_weierstrass +compact_in_euclidean +compact_in_fip +compact_in_imp_closed_in +compact_in_imp_mbounded +compact_in_imp_totally_bounded_in +compact_in_sequence_with_limit +compact_in_sequentially +compact_in_subspace +compact_in_subtopology +compact_insert +compact_inter +compact_inter_closed +compact_inters +compact_interval +compact_linear_image +compact_linear_image_eq +compact_negations +compact_nest +compact_path_image +compact_pcross +compact_pcross_eq +compact_relative_frontier_bounded +compact_scaling +compact_scaling_eq +compact_sequence_with_limit +compact_sequence_with_limit_gen +compact_shrink_enclosing_ball +compact_sing +compact_space_euclidean_subtopology +compact_space_nest +compact_sphere +compact_sums +compact_sup_maxdistance +compact_translation +compact_translation_eq +compact_uniformly_continuous +compact_uniformly_equicontinuous +compact_union +compact_unions compat +compatible_norm_vectorize +compile +compl_compl +complement_connected_component_unions +complete_eq_closed +complete_hausdist +complete_hausdist_convex +complete_hausdist_univ +complete_isometric_image +complete_univ +completely_metrizable_space_euclidean +completely_metrizable_space_gdelta_in +completely_metrizable_space_mtopology +completenessaxiom +component_le_infnorm +component_le_norm +components_empty +components_eq +components_eq_empty +components_eq_sing +components_eq_sing_exists +components_maximal +components_nonoverlap +components_separated_union +components_unique +components_univ +cond_cases_tac +cond_component +cond_id +cond_rand +cond_rator +cond_swap +condensation_point_imp_limpt +confidence +confidencelattice +confluence +cong_refl +cong_sym +congruent_image_std_simplex +conic_conic_hull +conic_convex_cone_hull +conic_convex_hull +conic_empty +conic_hull_as_image +conic_hull_empty +conic_hull_eq_affine_hull +conic_hull_eq_empty +conic_hull_eq_sing +conic_hull_eq_span +conic_hull_eq_span_eq +conic_hull_explicit +conic_hull_inter_affine_hull +conic_hull_linear_image +conic_hull_relative_interior_subset +conic_image_multiple_eq +conic_interior_insert +conic_inters +conic_linear_image +conic_linear_image_eq +conic_mul +conic_negations +conic_pcross +conic_relative_interior_insert +conic_span +conic_sums +conic_univ +conj +conj_aci +conj_asm1_tac +conj_assoc +conj_pair +conj_sym +conj_tac conjunction +conjuncts +conjuncts_then +connected +connected_affinity_eq +connected_ball +connected_card_eq_iff_nontrivial +connected_card_lt_iff_trivial +connected_clopen +connected_closed +connected_closed_in +connected_closed_in_eq +connected_closure +connected_component_disjoint +connected_component_eq +connected_component_eq_empty +connected_component_eq_eq +connected_component_in +connected_component_intermediate_subset +connected_component_maximal +connected_component_mono +connected_component_nonoverlap +connected_component_of_discrete_topology +connected_component_of_euclidean +connected_component_pcross +connected_component_refl +connected_component_refl_eq +connected_component_separated_union +connected_component_set +connected_component_subset +connected_component_sym +connected_component_sym_eq +connected_component_trans +connected_component_unions +connected_component_unique +connected_component_univ +connected_connected_component +connected_connected_component_set +connected_continuous_image +connected_empty +connected_eq_components_sing_exists +connected_eq_connected_component_eq +connected_equivalence_relation +connected_equivalence_relation_gen +connected_from_closed_union_and_inter +connected_iff_connectable_points +connected_iff_connected_component +connected_imp_perfect +connected_in +connected_in_absolute +connected_in_chain +connected_in_chain_gen +connected_in_closed_in +connected_in_continuous_map_image +connected_in_euclidean +connected_in_imp_perfect_gen +connected_in_inter_frontier_of +connected_in_intermediate_closure_of +connected_in_nest +connected_in_nest_gen +connected_in_nonseparated_union +connected_in_subtopology +connected_in_topspace +connected_induction +connected_induction_simple +connected_insert +connected_inter_frontier +connected_intermediate_closure +connected_ivt_component +connected_ivt_hyperplane +connected_limit_points_eq_closure +connected_linear_image +connected_monotone_quotient_preimage_gen +connected_negations +connected_open_in +connected_open_in_eq +connected_open_path_connected +connected_path_image +connected_pcross +connected_pcross_eq +connected_scaling +connected_scaling_eq +connected_segment +connected_separation +connected_separation_alt +connected_sing +connected_space_clopen_in +connected_space_closed_in +connected_space_closed_in_eq +connected_space_eq +connected_space_subconnected +connected_subset_segment +connected_translation +connected_translation_eq +connected_union +connected_unions +connected_univ +cons +cons_linear_image +cons_translation +consider +const +constants +constraints +constructreal +cont +contained +contains_component_of_closure_frontier +contains_component_of_compact_frontier +content_closed_interval +content_closed_interval_cases +content_doublesplit +content_empty +content_image_affinity_interval +content_lt_nz +content_pastecart +content_pos_le +content_pos_lt +content_pos_lt_eq +content_split +content_subset +content_unit +continuity +continuous +continuous_abs +continuous_add +continuous_agree_on_closure +continuous_agree_on_intermediate_closure +continuous_at +continuous_at_avoid +continuous_at_closest_point +continuous_at_compose +continuous_at_compose_eq +continuous_at_dist_closest_point +continuous_at_id +continuous_at_imp_continuous_on +continuous_at_lift_dot +continuous_at_lift_norm +continuous_at_lift_range +continuous_at_lift_setdist +continuous_at_sqrt +continuous_at_within +continuous_at_within_inv +continuous_attains_inf +continuous_attains_sup +continuous_card_lt_range_constant_eq +continuous_closed_graph_eq +continuous_closed_graph_gen +continuous_closed_imp_cauchy_continuous +continuous_closed_in_preimage +continuous_closed_in_preimage_constant +continuous_closed_in_preimage_eq +continuous_closed_in_preimage_gen +continuous_closed_preimage +continuous_closed_preimage_univ +continuous_cmul +continuous_componentwise_lift +continuous_const +continuous_countable_range_constant_eq +continuous_discrete_range_constant_eq +continuous_eq_cauchy_continuous_closed +continuous_eq_cauchy_within +continuous_finite_range_constant +continuous_finite_range_constant_eq +continuous_fstcart +continuous_gdelta_preimage +continuous_ge_on_intermediate_closure +continuous_image_nested_inters +continuous_imp_borel_measurable_on +continuous_imp_closed_map_explicit +continuous_imp_measurable_on +continuous_inv +continuous_ivt_local_extremum +continuous_le_on_intermediate_closure +continuous_levelset_open_in +continuous_levelset_open_in_cases +continuous_lift_abs +continuous_lift_abs_component +continuous_lift_component_compose +continuous_lift_det +continuous_lift_norm_compose +continuous_lift_product +continuous_map_atpointof +continuous_map_closures_gen +continuous_map_componentwise_real +continuous_map_componentwise_univ +continuous_map_compose +continuous_map_const +continuous_map_drop +continuous_map_drop_eq +continuous_map_eq_drop +continuous_map_eq_lift +continuous_map_euclidean +continuous_map_euclidean_component +continuous_map_extension_pointwise +continuous_map_extension_pointwise_alt +continuous_map_from_subtopology +continuous_map_id +continuous_map_in_subtopology +continuous_map_lift +continuous_map_lift_eq +continuous_map_lift_eq_gen +continuous_map_pastewise +continuous_map_real_add +continuous_map_real_mul +continuous_map_real_sub +continuous_map_square_root +continuous_map_sum +continuous_map_uniform_limit +continuous_map_vector_add +continuous_map_vector_const +continuous_matrix_componentwise +continuous_matrix_vectorize +continuous_max +continuous_measure_translation_symdiff +continuous_midpoint_convex +continuous_min +continuous_mul +continuous_neg +continuous_on +continuous_on_add +continuous_on_cases_le +continuous_on_cases_local +continuous_on_cases_local_open +continuous_on_closed +continuous_on_closed_gen +continuous_on_closure +continuous_on_cmul +continuous_on_componentwise_lift +continuous_on_compose +continuous_on_compose_quotient +continuous_on_const +continuous_on_empty +continuous_on_eq +continuous_on_eq_continuous_at +continuous_on_eq_continuous_within +continuous_on_finite +continuous_on_id +continuous_on_imp_baire +continuous_on_imp_closed_in +continuous_on_imp_open_in +continuous_on_interior +continuous_on_intermediate_closure +continuous_on_intermediate_closure_eq +continuous_on_inverse +continuous_on_inverse_closed_map +continuous_on_inverse_open_map +continuous_on_lift_component +continuous_on_lift_det +continuous_on_lift_dot +continuous_on_lift_norm +continuous_on_lift_range +continuous_on_lift_sqrt +continuous_on_max +continuous_on_measure_in_portion +continuous_on_min +continuous_on_mul +continuous_on_neg +continuous_on_no_limpt +continuous_on_open +continuous_on_open_gen +continuous_on_pastecart +continuous_on_path_length_subpath_right +continuous_on_sequentially +continuous_on_sing +continuous_on_sub +continuous_on_subset +continuous_on_union +continuous_on_union_local +continuous_on_union_local_open +continuous_on_vectorize_componentwise +continuous_on_vmul +continuous_open_in_preimage +continuous_open_in_preimage_eq +continuous_open_in_preimage_gen +continuous_open_preimage +continuous_open_preimage_univ +continuous_sndcart +continuous_sub +continuous_trivial_limit +continuous_uniform_limit +continuous_vectorize_componentwise +continuous_vmul +continuous_vsum +continuous_within +continuous_within_avoid +continuous_within_compose +continuous_within_id +continuous_within_lift_sqrt +continuous_within_sequentially +continuous_within_sequentially_alt +continuous_within_sequentially_inj +continuous_within_sqrt_compose +continuous_within_subset +contr_tac contra +contraction +contraction_imp_continuous_on contradiction +contrapos_thm +conv_rule +conv_tac +convergence_in_measure +convergent_bounded_monotone +convergent_eq_cauchy +convergent_eq_cauchy_at +convergent_eq_cauchy_within +convergent_eq_zero_oscillation +convergent_eq_zero_oscillation_gen +convergent_imp_bounded +convergent_imp_cauchy +convergent_imp_cauchy_in +convergent_offset_eq +converse_sard +convex_add +convex_affinity_eq +convex_alt +convex_ball +convex_cball +convex_closed_contains_same_ray +convex_closure +convex_closure_interior +convex_closure_relative_interior +convex_cone +convex_cone_convex_cone_hull +convex_cone_halfspace_ge +convex_cone_hull_empty +convex_cone_hull_linear_image +convex_cone_hull_separate +convex_cone_hull_separate_nonempty +convex_cone_hull_union +convex_cone_inters +convex_cone_linear_image +convex_cone_pcross +convex_cone_sing +convex_cone_sums +convex_conic_hull +convex_connected +convex_connected_collinear +convex_contains +convex_contains_open_segment +convex_contains_segment +convex_contains_segment_eq +convex_contains_segment_imp +convex_convex_hull +convex_differences +convex_distance +convex_empty +convex_epigraph +convex_epigraph_convex +convex_eq_convex_line_intersection +convex_explicit +convex_facial_partition +convex_halfspace_component_ge +convex_halfspace_component_gt +convex_halfspace_component_le +convex_halfspace_component_lt +convex_halfspace_ge +convex_halfspace_gt +convex_halfspace_le +convex_halfspace_lt +convex_halfspace_sgn +convex_has_bounded_variation_eq +convex_hausdist_limit +convex_hull_caratheodory +convex_hull_caratheodory_aff_dim +convex_hull_closure_subset +convex_hull_empty +convex_hull_eq +convex_hull_eq_empty +convex_hull_eq_sing +convex_hull_exchange_inter +convex_hull_exchange_union +convex_hull_explicit +convex_hull_finite +convex_hull_finite_step +convex_hull_image +convex_hull_indexed +convex_hull_insert +convex_hull_insert_alt +convex_hull_insert_segments +convex_hull_inter +convex_hull_linear_image +convex_hull_pcross +convex_hull_redundant_subset_gen +convex_hull_scaling +convex_hull_sing +convex_hull_sphere +convex_hull_subset_affine_hull +convex_hull_subset_convex_cone_hull +convex_hull_sums +convex_hull_translation +convex_hull_union_explicit +convex_hull_univ +convex_hyperplane +convex_imp_bounded_on_interval +convex_imp_locally_bounded +convex_imp_locally_lipschitz +convex_imp_piecewise_monotone +convex_imp_starlike +convex_indexed +convex_inner_approximation +convex_inter +convex_interior_closure +convex_inters +convex_interval +convex_line_intersection_unique_open_in +convex_line_intersections +convex_linear_image +convex_linear_image_eq +convex_linear_preimage +convex_local_global_minimum_gen +convex_local_global_minimum_segment +convex_lower +convex_lower_segment +convex_lower_segment_lt +convex_nearby_in_scaling +convex_negations +convex_on_const +convex_on_convex_hull_bound +convex_on_convex_hull_bound_eq +convex_on_derivative_secant +convex_on_derivative_secant_imp +convex_on_directional_derivatives +convex_on_eq +convex_on_jensen +convex_on_left_differentiable +convex_on_mid_secant +convex_on_right_differentiable +convex_on_secant_derivative_imp +convex_on_setdist +convex_open_segment_cases +convex_open_segment_cases_alt +convex_outer_approximation +convex_pcross +convex_relative_interior +convex_relative_interior_closure +convex_scaling +convex_scaling_eq +convex_segment +convex_semiopen_segment +convex_sing +convex_span +convex_sums +convex_sums_multiples +convex_translation +convex_translation_eq +convex_translation_subset_preimage +convex_univ +convex_vsum +coplanar_aff_dim +coplanar_linear_image +coplanar_small +coplanar_translation_eq +coprime_lexp +coprime_sym +copyright +coq +core +correct +count_roots_modulo_odd_gen +countable +countable_as_image +countable_as_injective_image +countable_as_injective_image_subset +countable_ascending_clopen_in_chain +countable_card_add_eq +countable_cart +countable_compact_open_in +countable_cross +countable_descending_clopen_in_chain +countable_disjoint_open_in_subsets +countable_disjoint_open_subsets +countable_empty +countable_finite_subsets +countable_image +countable_image_inj_eq +countable_imp_card_lt_real +countable_imp_disconnected +countable_insert +countable_inter +countable_intersection_of_complement +countable_intersection_of_idempot +countable_intersection_of_inc +countable_intersection_of_inter +countable_non_condensation_points +countable_non_limit_points +countable_noncontinuous_left_limits +countable_noncontinuous_one_sided_limits +countable_noncontinuous_right_limits +countable_product_dependent +countable_rational +countable_rational_coordinates +countable_restrict +countable_sing +countable_subset +countable_trivial_right_limits +countable_union +countable_union_of_ascending +countable_union_of_baire_indicator +countable_union_of_bijective_image +countable_union_of_explicit +countable_union_of_idempot +countable_union_of_inc +countable_union_of_inter +countable_unions +countablechoice +countersatisfiable +covariance_matrix_inv +covariance_unique_up_to_orthogonal +cr +cramer +cramer_lemma_transp +cramer_matrix_left +cramer_matrix_right +cramer_matrix_right_inverse +cross +cross_univ +crt curry +cut_admissible +cutadmissible +cycle_time = max(placement_time) d +darboux_and_regulated_imp_continuous +data +datatypes +de_morgan_thm +dec +decide_tac +decideelim +declare +decreases +decreasing_bounded_variation_gen +decreasing_closed_nest +decreasing_countable_discontinuities +deep_intro_tac +defpred +delete +delete_insert +delete_subset +demonstrates +demonstrating +dense_complement_affine +dense_complement_convex +dense_complement_open_in_affine_hull +dense_gdelta_imp_large +dense_imp_perfect dependent +dependent_affine_dependent_cases +dependent_biggerset_general +dependent_choice +dependent_eq_dim_lt_card +dependent_explicit +dependent_finite +dependent_linear_image_eq +dependent_sing +depth_conv +derived_set_of_restrict +derived_set_of_union destruct +destruct_tac +det_cmul +det_cofactor +det_cofactor_expansion +det_dependent_rows +det_diagonal +det_i +det_identical_rows +det_linear_rows_vsum +det_linear_rows_vsum_lemma +det_lowertriangular +det_matrix_inv +det_matrix_reflect_along +det_mul +det_neg +det_orthogonal_matrix +det_permute_rows +det_positive_definite +det_positive_semidefinite +det_row_add +det_row_mul +det_row_span +det_rows_mul +det_similar +det_transp +det_zero_row +diagonal_imp_symmetric_matrix +diagonal_matrix +diagonal_matrix_inv_explicit +diagonal_matrix_mat +diagonal_matrix_mul +diagonal_matrix_mul_component +diagonal_positive_definite +diagonal_positive_semidefinite +diagonalization +diameter_attained_relative_frontier +diameter_bounded +diameter_bounded_bound +diameter_bounded_bound_lt +diameter_cball +diameter_closure +diameter_compact_attained +diameter_convex_hull +diameter_empty +diameter_frontier +diameter_le +diameter_le_sums_right +diameter_lt_sums_right +diameter_pos_le +diameter_scaling +diameter_sing +diameter_subset +diameter_subset_cball_nonempty +diameter_sums +diameter_translation +diameters_hausdist_bound +diamond +diff +diff_chain_at +diff_chain_within +diff_chain_within_equal_ae +diff_empty +diff_eq_empty +differentiable_add +differentiable_at_imp_differentiable_on +differentiable_at_within +differentiable_bound +differentiable_chain_within +differentiable_componentwise_within +differentiable_const +differentiable_discrete_preimages +differentiable_finite_preimages +differentiable_id +differentiable_imp_continuous_at +differentiable_imp_continuous_on +differentiable_imp_continuous_within +differentiable_imp_open_map +differentiable_imp_open_map_gen +differentiable_linear +differentiable_mul_within +differentiable_neg +differentiable_on_eq_differentiable_at +differentiable_on_linear +differentiable_on_subset +differentiable_sqnorm_at +differentiable_sub +differentiable_transform_within +differentiable_vsum +differentiable_within_open +differentiable_within_subset +differential_component_neg_at_maximum +differential_component_pos_at_minimum +differential_component_zero_at_maxmin +differential_zero_maxmin +differential_zero_maxmin_density +dim_conic_hull +dim_empty +dim_eq_card +dim_eq_full +dim_eq_span +dim_eq_subspace +dim_eq_subspaces +dim_hyperplane +dim_image_kernel +dim_image_kernel_gen +dim_injective_linear_image +dim_injective_on_linear_image +dim_insert +dim_kernel_compose +dim_le_card +dim_linear_image_le +dim_orthogonal_sum +dim_pcross +dim_pcross_strong +dim_rows_le_dim_columns +dim_sing +dim_span +dim_special_hyperplane +dim_subset +dim_subset_univ +dim_substandard +dim_sums_inter +dim_unique +dim_univ +dimindex_finite_prod +dimindex_finite_sum +dimindex_nonzero +dir direction +disch_all +disch_tac +disch_then +discrete_bounded_imp_finite +discrete_eq_finite_bounded +discrete_eq_finite_bounded_closed +discrete_eq_finite_compact +discrete_imp_closed +discrete_imp_countable +discrete_set +disj1_tac +disj2_tac +disj_aci +disj_assoc +disj_cases_tac +disj_cases_then +disj_sym +disjoint +disjoint_empty +disjoint_halfspaces_imp_collinear +disjoint_interval +disjoint_relative_interior_convex_hull +disjoint_sym +disjunctio disjunction +disjunction_elim +disp +dispatch +dispatchcorrectness +dispatchordering +dist_closest_point_lipschitz +dist_convex_hull_bound_eq +dist_decreases_open_segment +dist_descale +dist_fstcart +dist_in_open_segment +dist_increases_online +dist_le_pastecart +dist_lift +dist_midpoint +dist_mul +dist_nz +dist_pastecart_cancel +dist_pastecart_le +dist_points_le_path_length +dist_pos_le +dist_pos_lt +dist_real +dist_refl +dist_sndcart +dist_sym +dist_triangle +dist_triangle_alt +dist_triangle_eq +dist_triangle_half_l +distance_attains_inf +distance_attains_sup distr +div +div-mod +divides_one +divides_zero +division +division_disjoint_union +division_inter +division_of +division_of_affinity +division_of_finite +division_of_reflect +division_of_self +division_of_tagged_division +division_of_trivial +division_of_union_self +division_points_subset +division_split +division_split_left_inj +division_split_right_inj +dn-intro +do +dominated_convergence +dominated_convergence_ae +dominated_convergence_integrable +dot_basis +dot_cauchy_schwarz_equal +dot_dropout +dot_ladd +dot_lmul +dot_lmul_matrix +dot_lneg +dot_lsub +dot_lsum +dot_lzero +dot_matrix_product +dot_matrix_transp_lmul +dot_matrix_transp_rmul +dot_matrix_vector_mul +dot_norm +dot_norm_sub +dot_pastecart +dot_pos_le +dot_pos_lt +dot_radd +dot_rmul +dot_rneg +dot_rowvector_columnvector +dot_rsub +dot_rsum +dot_rzero +dot_scaling +dot_square_norm +dot_sym +dot_vectorize +double_lebesgue_measurable_left_inverse +double_lebesgue_measurable_on +double_negation +dpair +dpairelim +drop_add +drop_cmul +drop_eq +drop_in_real_interval +drop_indicator +drop_neg +drop_sub +drop_vec +drop_vsum +dropout_add +dropout_galois +dropout_mul +dropout_pushin +dual +dugundji +dyadic e +each +echidna +echidnabot +eclipse +edelstein_fix +eigenvalue_lowerbound_dot +eigenvalues_characteristic +eigenvalues_characteristic_alt +either +el +elementary_bounded +elementary_empty +elementary_inter +elementary_interval +elementary_subset_interval +elementary_union_interval_strong +elementary_unions_intervals +elim +elim h +elim h1 +elim h2 +elim ih +elimempty +else +empty +empty_as_interval +empty_delete +empty_diff +empty_division_of +empty_exposed_face_of +empty_face_of +empty_gspec +empty_interior_affine_hull +empty_interior_convex_hull +empty_interior_finite +empty_interior_lowdim +empty_interior_subset_hyperplane +empty_subset +empty_union +empty_unions +encode +encoded +ends_in_interval +ends_in_segment +ends_in_unit_interval +ends_not_in_segment +ensures +entropydef +ephapax +epsilondelta eq +eq_add_rcancel +eq_c_bijections +eq_ext +eq_imp +eq_imp_le +eq_imp_rule +eq_interval +eq_sym_eq +eq_tac +eq_trans eqn +eqsym +eqt_elim +eqt_intro +eqtrans equalities +equality +equiintegrable_add +equiintegrable_cmul +equiintegrable_halfspace_restrictions_ge +equiintegrable_halfspace_restrictions_le +equiintegrable_neg +equiintegrable_on_null +equiintegrable_on_sing +equiintegrable_reflect +equiintegrable_sub +equiintegrable_subset +eta-red +eta_ax +euclidean_closure_of +euclidean_connected_components_of +euclidean_frame +euclidean_frontier_of +euclidean_interior_of +euclidean_matroid +euclidean_matroid_dim +euclidean_matroid_dimension +euclidean_matroid_finite_dim +euclidean_matroid_finite_dimensional +euclidean_matroid_independent +euclidean_matroid_spanning +euclidean_matroid_subspace +euclidean_metric +euclidean_space_infinite +eval_tac +evaluates even +even_0 +even_add +even_mult +even_or_odd +even_ss +eventually_and +eventually_at +eventually_at_infinity +eventually_at_infinity_within +eventually_at_neginfinity +eventually_at_posinfinity +eventually_at_reflect +eventually_at_zero +eventually_atpointof +eventually_atpointof_metric +eventually_false +eventually_happens +eventually_in_sequentially +eventually_mono +eventually_scalable_property +eventually_scalable_property_eq +eventually_sequentially +eventually_true +eventually_within +eventually_within_delete +eventually_within_imp +eventually_within_inter_imp +eventually_within_interior +eventually_within_interior_inter +eventually_within_le +eventually_within_left_alt +eventually_within_left_alt_gen +eventually_within_open +eventually_within_open_in +eventually_within_reflect +eventually_within_right_alt +eventually_within_right_alt_gen +eventually_within_topological +eventually_within_zero +every_assum +every_case_tac +ex (s m) +ex 0 +ex m +ex nil exact +exact (f (a, b)) +exact (f a) +exact (g (f a)) +exact (g b) +exact (h a) +exact (nb (f a)) +exact a +exact b +exact f +exact ih exactly +example +exc +exchange +exchange_lemma excluded +executes +exercise exfalso +exists +exists-tp +exists_countable_subset_image +exists_diff +exists_drop +exists_in_gspec +exists_in_image +exists_in_insert +exists_in_pcross +exists_in_union +exists_lift +exists_or_thm +exists_pair_thm +exists_paired_thm +exists_pastecart +exists_refl +exists_subset_image +exists_tac +exists_unique +exists_unique_def +exists_unique_thm +existselim +exp +exp_mono_le +exp_one +expand +expand_tac +expected +exposed_face_of +exposed_face_of_inters +exposed_face_of_polyhedron +exposed_face_of_refl +exposed_face_of_refl_eq +ext +extend_convex_relative_frontier_segment +extend_to_affine_basis +extendedeuclid +extension +extensional +extreme_point_exists_convex +extreme_point_in_frontier +extreme_point_not_in_interior +extreme_point_not_in_relative_interior +extreme_point_of_conic_hull +extreme_point_of_convex_hull +extreme_point_of_convex_hull_eq +extreme_point_of_empty +extreme_point_of_segment +extreme_point_of_sing +extreme_point_of_stillconvex +extreme_point_of_translation_eq +extreme_point_relative_frontier +extreme_points_of_convex_hull +extreme_points_of_convex_hull_eq +extremevalue f +face_of_aff_dim_lt +face_of_affine_eq +face_of_affine_trivial +face_of_conic +face_of_conic_hull_rev +face_of_convex_hull_affine_independent +face_of_convex_hull_insert_eq +face_of_convex_hull_subset +face_of_convex_hulls +face_of_disjoint_relative_interior +face_of_empty +face_of_eq +face_of_face +face_of_halfspace_le +face_of_imp_closed +face_of_imp_compact +face_of_imp_convex +face_of_imp_subset +face_of_inter +face_of_inter_inter +face_of_inter_supporting_hyperplane_ge +face_of_inter_supporting_hyperplane_le +face_of_inters +face_of_linear_image +face_of_pcross +face_of_pcross_decomp +face_of_polyhedron +face_of_polyhedron_explicit +face_of_polyhedron_subset_facet +face_of_refl +face_of_refl_eq +face_of_simplex_subset +face_of_sing +face_of_stillconvex +face_of_subset +face_of_subset_frontier_aff_dim +face_of_subset_relative_boundary +face_of_subset_relative_frontier +face_of_subset_relative_frontier_aff_dim +face_of_trans +face_of_translation_eq +faces_of_simplex +facet_of_convex_hull_affine_independent +facet_of_empty +facet_of_halfspace_le +facet_of_imp_face_of +facet_of_imp_subset +facet_of_polyhedron_explicit +fact +factor_continuous_through_variation +factor_through_variation factorial false faster +fastforce +fermat_little_prime +fib +fieldaxiom +file +filecopyrighttext filter +filter_gen_tac +filter_in +fin +fine_division_exists +fine_union +finite +finite_connected_components_of_finite +finite_cross +finite_delete +finite_diff +finite_eigenvalues +finite_empty +finite_faces_of_simplex +finite_finite_preimage +finite_image +finite_image_inj +finite_image_inj_eq +finite_imp_bounded +finite_imp_closed +finite_imp_compact +finite_imp_compact_convex_hull +finite_imp_countable +finite_imp_not_open +finite_index_inrange +finite_index_numseg +finite_index_numseg_special +finite_index_works +finite_induct_strong +finite_insert +finite_inter +finite_inter_numseg +finite_numseg +finite_numseg_le +finite_numseg_lt +finite_pcross +finite_permutations +finite_polyhedron_exposed_faces +finite_polyhedron_extreme_points +finite_polyhedron_faces +finite_polytope_faces +finite_powerset +finite_product_dependent +finite_restrict +finite_rules +finite_segment +finite_set_avoid +finite_set_of_list +finite_sing +finite_stdbasis +finite_subset +finite_subset_image +finite_union +finite_unions +finiteunion +first +first_assum +first_x_assum +fix +floor_pos +flow_value = sum(v)(flow[1,v]) +fof fold +fold_right_app +for forall +forall(m in matches)(home[m] != away[m]) +forall(t in periods)(inventory[t] >= 0) +forall-tp +forall_and_thm +forall_bool_thm +forall_countable_as_image +forall_diff +forall_drop +forall_drop_fun +forall_eventually +forall_finite_subset_image_inj +forall_fun_drop +forall_fun_lift +forall_in_closure +forall_in_closure_eq +forall_in_division +forall_in_division_nonempty +forall_in_gspec +forall_in_image +forall_in_insert +forall_in_intermediate_closure +forall_in_pcross +forall_in_union +forall_in_unions +forall_lift +forall_lift_fun +forall_option +forall_pair_thm +forall_paired_thm +forall_pastecart +forall_subset_image +forall_subset_union +force +form +formal +formalises forward +foundation +frechet_derivative_unique_at +frechet_derivative_unique_within +frechet_derivative_works +free +fresh from +from_inter_numseg +frontier_bijective_linear_image +frontier_cball +frontier_clopen_map_image_subset +frontier_closed +frontier_closure_convex +frontier_closure_subset +frontier_closures +frontier_complement +frontier_empty +frontier_eq_empty +frontier_frontier +frontier_halfspace_le +frontier_halfspace_lt +frontier_inter +frontier_inter_subset +frontier_not_empty +frontier_of_components_subset +frontier_of_connected_component_subset +frontier_of_frontier_of +frontier_of_restrict +frontier_of_triangle +frontier_open_map_image_subset +frontier_proper_clopen_map_image +frontier_proper_map_image_subset +frontier_proper_map_image_subset_gen +frontier_scaling +frontier_sing +frontier_straddle +frontier_subset_closed +frontier_subset_eq +frontier_translation +frontier_union_subset +frontier_univ +fs +fsigma_baire +fsigma_baire_preimage_open +fsigma_baire_preimage_open_gen +fsigma_complement +fsigma_continuous_image +fsigma_empty +fsigma_gdelta_gen +fsigma_imp_borel +fsigma_in_euclidean +fsigma_in_gdelta_in +fsigma_in_inter +fsigma_in_union +fsigma_in_unions +fsigma_inter +fsigma_locally_compact +fsigma_locally_gen +fsigma_pcross +fsigma_preimage_card_ge +fsigma_reduction_gen_alt +fsigma_sing +fsigma_unions +fsigma_unions_compact +fsigma_univ +fst +fstar +fstcart_add +fstcart_cmul +fstcart_component +fstcart_neg +fstcart_pastecart +fstcart_sub +fstcart_vec +fstcart_vsum +fubini_absolutely_integrable +fubini_absolutely_integrable_alt +fubini_integral +fubini_integral_alt +fubini_integral_interval +fubini_integral_interval_alt +fubini_measure +fubini_negligible +fubini_tonelli +fubini_tonelli_measure +fubini_tonelli_negligible +full_case_tac +full_rank_injective +full_rank_surjective +full_simp_tac +full_struct_cases_tac +fun +fun_eq_thm +fun_ext +fun_in_image +function +function_factors_left_gen +functor +functoridlaw +functorlaw +fundamental +fundamental_theorem_of_calculus +fundamental_theorem_of_calculus_bartle +fundamental_theorem_of_calculus_strong +funext +fusion fx g +gale_stewart +gateaux_derivative_within +gauge_ball +gauge_ball_dependent +gauge_existence_lemma +gauge_trivial +gcd +gcd_refl +gcd_sym +gdelta_baire +gdelta_baire_preimage_closed +gdelta_baire_preimage_closed_gen +gdelta_complement +gdelta_continuous_function_minima +gdelta_domain_of_injectivity_continuous +gdelta_empty +gdelta_imp_borel +gdelta_in_descending +gdelta_in_euclidean +gdelta_in_inter +gdelta_in_inters +gdelta_in_union +gdelta_inter +gdelta_inters +gdelta_locally_gen +gdelta_pcross +gdelta_points_of_continuity_within +gdelta_points_of_convergence_within +gdelta_separation_gen +gdelta_union +gdelta_univ ge +ge_refl +gen +gen_all +gen_alpha_conv +gen_beta_conv +gen_geom_origin_tac +gen_rewr_tac +gen_rewrite_rule +gen_rewrite_tac +gen_simplify_conv +gen_tac +general_reduction_theorem generalize +geom_basis_multiple_tac +geom_equal_dimension_rule +geom_normalize_tac +geom_origin_conv +geom_origin_tac +geom_transform_tac +geom_translate_tac +glivenko goal goals +godel_negative +gram_schmidt_lemma +grammar-rule +grind +group_left_identity +grouporder grows +gsym +gt +guard h h1 h3 +h_a +h_ab +h_ac +h_and_imp +h_b +h_bc +h_c +h_curry +h_eq +h_false +h_fx +h_imp +h_in +h_in_t +h_l +h_m +h_nm +h_not_a +h_not_and +h_not_b +h_not_not_a +h_not_not_b +h_not_or +h_r +habs +hadamard_inequality_column +hadamard_inequality_row +halfspace_eq_empty_gt +halfspace_eq_empty_le +halfspace_eq_empty_lt +happ +has_absolute_integral +has_antiderivative_sequence +has_bounded_set_variation +has_bounded_setvariation_comparison +has_bounded_setvariation_on +has_bounded_setvariation_on_add +has_bounded_setvariation_on_cmul +has_bounded_setvariation_on_division +has_bounded_setvariation_on_elementary +has_bounded_setvariation_on_eq +has_bounded_setvariation_on_interval +has_bounded_setvariation_on_neg +has_bounded_setvariation_on_null +has_bounded_setvariation_on_sub +has_bounded_setvariation_on_subset +has_bounded_setvariation_on_univ +has_bounded_setvariation_works +has_bounded_variation_affinity_eq +has_bounded_variation_comparison +has_bounded_variation_compose_decreasing +has_bounded_variation_compose_increasing +has_bounded_variation_darboux +has_bounded_variation_isometric +has_bounded_variation_left_limit_gen +has_bounded_variation_lipschitz_compose +has_bounded_variation_nontrivial +has_bounded_variation_on_add +has_bounded_variation_on_bilinear +has_bounded_variation_on_closure +has_bounded_variation_on_closure_eq +has_bounded_variation_on_cmul +has_bounded_variation_on_cmul_eq +has_bounded_variation_on_combine +has_bounded_variation_on_combine_gen +has_bounded_variation_on_componentwise +has_bounded_variation_on_const +has_bounded_variation_on_eq +has_bounded_variation_on_id +has_bounded_variation_on_imp_bounded +has_bounded_variation_on_interior +has_bounded_variation_on_interior_eq +has_bounded_variation_on_interval +has_bounded_variation_on_mul +has_bounded_variation_on_neg +has_bounded_variation_on_norm +has_bounded_variation_on_null +has_bounded_variation_on_reflect +has_bounded_variation_on_sing +has_bounded_variation_on_split +has_bounded_variation_on_sub +has_bounded_variation_on_subset +has_bounded_variation_on_union +has_bounded_variation_on_vmul +has_bounded_variation_on_vmul_eq +has_bounded_variation_right_limit_gen +has_bounded_vector_variation +has_bounded_vector_variation_on_interval +has_derivative_add +has_derivative_at +has_derivative_at_alt +has_derivative_at_within +has_derivative_bilinear_at +has_derivative_bilinear_within +has_derivative_cmul +has_derivative_componentwise_at +has_derivative_componentwise_within +has_derivative_const +has_derivative_id +has_derivative_inverse_basic +has_derivative_inverse_basic_x +has_derivative_inverse_strong +has_derivative_lift_component +has_derivative_lift_dot +has_derivative_linear +has_derivative_mul_within +has_derivative_neg +has_derivative_neg_eq +has_derivative_pastecart_eq +has_derivative_sequence +has_derivative_sequence_lipschitz +has_derivative_sqnorm_at +has_derivative_sub +has_derivative_transform_at +has_derivative_transform_within +has_derivative_transform_within_open +has_derivative_vmul_component +has_derivative_vsum +has_derivative_within +has_derivative_within_alt +has_derivative_within_open +has_derivative_within_reflect +has_derivative_within_subset +has_derivative_zero_connected_constant +has_derivative_zero_constant +has_double_integral_convolution +has_frechet_derivative_unique_at +has_integral +has_integral_add +has_integral_affinity +has_integral_alt +has_integral_cmul +has_integral_combine +has_integral_combine_division +has_integral_combine_division_topdown +has_integral_combine_tagged_division +has_integral_component_lbound +has_integral_component_le +has_integral_component_le_ae +has_integral_component_neg +has_integral_component_pos +has_integral_component_ubound +has_integral_componentwise +has_integral_const +has_integral_const_gen +has_integral_convolution_sym +has_integral_diff +has_integral_drop_le +has_integral_drop_le_ae +has_integral_drop_pos +has_integral_drop_pos_ae +has_integral_empty +has_integral_empty_eq +has_integral_eq +has_integral_integrable +has_integral_integrable_integral +has_integral_integral +has_integral_interior +has_integral_lim_at_posinfinity +has_integral_linear +has_integral_neg +has_integral_negligible +has_integral_negligible_eq +has_integral_negligible_eq_ae +has_integral_null +has_integral_null_eq +has_integral_on_negligible +has_integral_on_superset +has_integral_open_interval +has_integral_pastecart_sym +has_integral_pastecart_sym_alt +has_integral_refl +has_integral_reflect +has_integral_reflect_gen +has_integral_reflect_lemma +has_integral_restrict +has_integral_restrict_closed_subinterval +has_integral_restrict_inter +has_integral_restrict_open_subinterval +has_integral_restrict_univ +has_integral_spike +has_integral_spike_eq +has_integral_spike_finite +has_integral_spike_interior +has_integral_spike_set +has_integral_spike_set_eq +has_integral_split +has_integral_straddle_null +has_integral_stretch +has_integral_sub +has_integral_subset_component_le +has_integral_subset_drop_le +has_integral_translation +has_integral_twiddle +has_integral_twiddle_gen +has_integral_twizzle +has_integral_twizzle_eq +has_integral_union +has_integral_unions +has_integral_unions_image +has_integral_unique +has_integral_vsum +has_measure +has_measure_affinity +has_measure_almost +has_measure_countable_negligible_unions +has_measure_diff_negligible +has_measure_diff_subset +has_measure_differentiable_image +has_measure_disjoint_union +has_measure_disjoint_unions +has_measure_disjoint_unions_image +has_measure_disjoint_unions_image_strong +has_measure_elementary +has_measure_empty +has_measure_inner_outer +has_measure_interval +has_measure_isometry +has_measure_limit +has_measure_linear_image +has_measure_linear_image_alt +has_measure_linear_image_same +has_measure_measurable_measure +has_measure_measure +has_measure_negligible_symdiff +has_measure_negligible_union +has_measure_negligible_unions +has_measure_negligible_unions_image +has_measure_nested_inters +has_measure_nested_unions +has_measure_orthogonal_image +has_measure_orthogonal_image_eq +has_measure_pcross +has_measure_pos_le +has_measure_scaling +has_measure_simplex +has_measure_subset +has_measure_tetrahedron +has_measure_translation +has_measure_translation_eq +has_measure_triangle +has_measure_union_negligible +has_measure_unique +has_size +has_size_clauses +has_size_conv +has_size_faces_of_simplex +has_size_image_inj +has_size_stdbasis +has_size_suc +has_vector_derivative_at_within +has_vector_derivative_bilinear_at +has_vector_derivative_bilinear_within +has_vector_derivative_cmul +has_vector_derivative_componentwise_at +has_vector_derivative_const +has_vector_derivative_neg +has_vector_derivative_transform_within +has_vector_derivative_within_subset +hausdist_closure +hausdist_compact_exists +hausdist_compact_sums +hausdist_complements_convex_explicit +hausdist_empty +hausdist_eq +hausdist_nontrivial +hausdist_nontrivial_alt +hausdist_pos_le +hausdist_refl +hausdist_scaling +hausdist_still_inside +hausdist_still_inside_interior +hausdist_still_same_place +hausdist_still_same_place_strong +hausdist_sums_le +hausdist_sym +hausdist_union_le +hausdorff +hausdorff_space_euclidean +hausdorff_space_mtopology +hausdorff_space_subtopology have +hd +heine_borel_lemma +heinecantor +helly +helly_alt +helly_closed +helly_closed_alt +helly_induct +hence +hints +ho_match_abbrev_tac +ho_match_mp_tac holds +hole +holes +homeomorphic_analyticity +homeomorphic_borelness +homeomorphic_compactness +homeomorphic_connectedness +homeomorphic_convex_compact +homeomorphic_convex_compact_sets +homeomorphic_countability +homeomorphic_empty +homeomorphic_finite +homeomorphic_finiteness +homeomorphic_fsigmaness +homeomorphic_gdeltaness +homeomorphic_has_size +homeomorphic_hyperplanes +homeomorphic_imp_card_eq +homeomorphic_injective_linear_image_self +homeomorphic_local_compactness +homeomorphic_locally +homeomorphic_map_derived_set_of +homeomorphic_map_frontier_of +homeomorphic_map_interior_of +homeomorphic_map_maps +homeomorphic_maps_euclidean_subtopology +homeomorphic_maps_subtopologies_alt +homeomorphic_minimal +homeomorphic_open_interval_univ +homeomorphic_pcross_sym +homeomorphic_refl +homeomorphic_relatively_open_convex_sets +homeomorphic_scaling +homeomorphic_sym +homeomorphic_trans +homeomorphic_translation +homeomorphic_translation_left_eq +homeomorphic_translation_self +homeomorphism +homeomorphism_arc +homeomorphism_closed_in_eq +homeomorphism_closure_of +homeomorphism_compact +homeomorphism_compactness +homeomorphism_compose +homeomorphism_connected_component +homeomorphism_derived_set_of +homeomorphism_finiteness +homeomorphism_frontier_of +homeomorphism_graph_explicit +homeomorphism_i +homeomorphism_id +homeomorphism_imp_closed_map +homeomorphism_imp_open_map +homeomorphism_injective_closed_map +homeomorphism_injective_closed_map_eq +homeomorphism_injective_open_map +homeomorphism_injective_open_map_eq +homeomorphism_interior_of +homeomorphism_locally +homeomorphism_of_subsets +homeomorphism_open_in_eq +homeomorphism_sym +homogeneous_linear_equations_det +hstep +hsubst +hull_antimono +hull_eq +hull_hull +hull_image +hull_inc +hull_induct +hull_insert +hull_minimal +hull_mono +hull_p +hull_redundant_eq +hull_subset +hull_union +hull_union_right +hull_union_subset +hull_unique +hull_univ +hulls_eq +hyp +hyp_tac +hyperplane_eq_empty +hyperplane_eq_univ +hyperplane_face_of_halfspace_ge +hyperplane_face_of_halfspace_le +hyperplane_facet_of_halfspace_le +hyperpolymath hypotheses hypothesis +i_def +i_o_id +i_thm +id_spec_tac +idealaxiom +identifier +identity +identitylaws +idr +idris2 +if +if_cases_tac +iff +iff_tac ih +image +image_affinity_interval +image_clauses +image_closure_subset +image_compact_in +image_const +image_delete_inj +image_eq +image_eq_empty +image_fstcart_pcross +image_i +image_id +image_inter_inj +image_lift_drop +image_sndcart_pcross +image_stretch_interval +image_subset +image_twizzle_interval +image_union +image_unions imp +imp_conj +imp_conj_alt +imp_imp +imp_res_tac +imp_rewrite_tac +imp_subst_tac +impl_tac implication +implies +impll +implr +impo +import impossible in +in_affine_add_mul_diff +in_ball +in_cball +in_components +in_components_connected +in_components_maximal +in_components_maximal_alt +in_components_nonempty +in_components_subset +in_convex_hull_exchange +in_convex_hull_exchange_unique +in_convex_set +in_cross +in_delete +in_diff +in_dimindex_swap +in_disjoint +in_elim_pair_thm +in_elim_pastecart_thm +in_elim_thm +in_from +in_frontier_convex_hull +in_image +in_image_dropout +in_insert +in_inter +in_interior +in_interior_cball +in_interior_closure_convex_segment +in_interior_closure_convex_shrink +in_interior_eventually +in_inters +in_interval +in_interval_reflect +in_mball +in_mcball +in_numseg +in_open_segment +in_real_interval +in_relative_interior +in_relative_interior_cball +in_relative_interior_in_open_segment +in_relative_interior_in_open_segment_eq +in_relative_interior_of_face +in_segment +in_sing +in_span_insert +in_sphere +in_translation_galois_alt +in_union +in_unions +in_univ +include +includin +inclusionexclusion +increasing_bounded_variation +increasing_bounded_variation_gen +increasing_countable_discontinuities +increasing_vector_variation +ind on l +ind on l1 +ind on m +ind on n +ind on t +indefinite_integral_continuous +indefinite_integral_continuous_right +indefinite_integral_uniformly_continuous +independent_bound +independent_bound_general +independent_card_le_dim +independent_empty +independent_eq_dim_eq_card +independent_imp_finite +independent_injective_image +independent_injective_image_gen +independent_insert +independent_mono +independent_nonzero +independent_sing +independent_span_bound +independent_stdbasis +independent_union +index_decomposition +indexed +induct +induct-and-simplify +induct-on-structure +induct_linear_elementary +induct_matrix_elementary +induct_matrix_elementary_alt +induct_matrix_row_operations +induct_on +induct_tac induction inductive +inequality_canon_rule +inf +inf_eq +inf_finite +inf_insert_finite +inf_unique +infinite +infinite_enumerate +infinite_enumerate_weak +infnorm_le_norm +infnorm_mul_lemma +infnorm_neg +infnorm_pos_le +infnorm_set_image +infnorm_set_lemma +infnorm_sub +infnorm_triangle +infsum_unique +injective_alt +injective_imp_isometric +injective_left_inverse +injective_on_alt +injective_on_left_inverse +injective_scaling +inorder +insert +insert_ac +insert_delete +insert_subset +inside_frontier_eq_interior +inst +inst_type +instance +int +int_add_lid +int_add_linv +int_arith +int_arith_tac +int_eq_imp_le +int_eq_sub_radd +int_le_antisym +int_le_refl +int_le_sub_ladd +int_le_trans +int_lt_antisym +int_lt_le +int_lt_refl +int_of_num_add +int_of_num_eq +int_of_num_exists +int_of_num_le +int_of_num_lt +int_of_num_suc +int_pos +int_reduce_conv +int_sub_add +int_sub_lzero +int_sub_refl +integer +integer_closed +integer_exists_between_abs_lt +integer_mul +integer_product +integer_sign +integer_sum +integrable_add +integrable_affinity +integrable_alt +integrable_alt_subset +integrable_bounded_variation_product +integrable_by_parts +integrable_cauchy +integrable_ccontinuous_explicit +integrable_cmul +integrable_cmul_eq +integrable_combine +integrable_combine_division +integrable_componentwise +integrable_const +integrable_continuous +integrable_convolution_sym +integrable_decreasing +integrable_eq +integrable_iff_measurable_under_curve +integrable_imp_measurable +integrable_increasing +integrable_increasing_product +integrable_increasing_product_univ +integrable_integral +integrable_linear +integrable_neg +integrable_neg_eq +integrable_on_const +integrable_on_empty +integrable_on_indicator +integrable_on_negligible +integrable_on_null +integrable_on_open_interval +integrable_on_subinterval +integrable_on_subinterval_gen +integrable_pastecart_sym +integrable_reflect +integrable_reflect_gen +integrable_restrict_inter +integrable_restrict_univ +integrable_spike +integrable_spike_set +integrable_split +integrable_straddle +integrable_straddle_interval +integrable_sub +integrable_subinterval +integrable_subintervals_imp_measurable +integrable_translation +integrable_twizzle_eq +integrable_uniform_limit +integrable_unions +integrable_unions_image +integrable_vsum +integral_add +integral_change_of_variables +integral_cmul +integral_combine +integral_combine_division_topdown +integral_const +integral_const_gen +integral_convolution_sym +integral_drop_le +integral_eq +integral_has_vector_derivative +integral_has_vector_derivative_pointwise +integral_indicator +integral_intervals_inclusion_exclusion +integral_linear +integral_neg +integral_norm_bound_integral +integral_norm_bound_integral_component +integral_null +integral_pastecart_sym_univ +integral_refl +integral_reflect +integral_restrict_inter +integral_restrict_univ +integral_spike +integral_split +integral_sub +integral_subset_drop_le +integral_translation +integral_unique +integral_vsum +integration_by_parts +integrity +inter +inter_aci +inter_assoc +inter_comm +inter_empty +inter_idempot +inter_interval_mixed_eq_empty +inter_pcross +inter_relative_frontier_conic_hull +inter_relative_interior_subset +inter_subset +inter_unions +inter_univ +interior_bijective_linear_image +interior_cball +interior_closed_interval +interior_closed_union_empty_interior +interior_closure +interior_closure_inter_open +interior_complement +interior_convex_hull_eq_empty +interior_convex_hull_explicit +interior_convex_hull_explicit_minimal +interior_empty +interior_eq +interior_eq_empty +interior_eq_empty_alt +interior_frontier +interior_frontier_empty +interior_halfspace_component_ge +interior_halfspace_component_le +interior_halfspace_ge +interior_halfspace_le +interior_hyperplane +interior_image_subset +interior_injective_linear_image +interior_inter +interior_interior +interior_interval +interior_limit_point +interior_maximal +interior_maximal_eq +interior_negations +interior_of_closure_of +interior_of_closure_of_idemp +interior_of_empty +interior_of_frontier_of +interior_of_frontier_of_empty +interior_of_inter +interior_of_restrict +interior_of_subset +interior_of_translation +interior_open +interior_pcross +interior_scaling +interior_segment +interior_sing +interior_sphere +interior_strip_component_le +interior_subset +interior_subset_relative_interior +interior_translation +interior_union_eq_empty +interior_unique +interior_univ +inters +inters_eq_univ +inters_faces_finite_altbound +inters_gspec +inters_image +inters_insert +inters_unions +intersection_of +intersection_of_mono +interval_bisection +interval_bisection_step +interval_contains_compact_neighbourhood +interval_doublesplit +interval_eq_empty +interval_image_affinity_interval +interval_lowerbound +interval_lowerbound_nonempty +interval_ne_empty +interval_open_subset_closed +interval_real_interval +interval_sing +interval_split +interval_subset_is_interval +interval_translation +interval_upperbound +interval_upperbound_nonempty into intro +intro con +intro_tac introduce intros +intuit +intuitionistic +invalid +invariant +inverse_function_theorem +inverse_function_theorem_subspace +inverse_mod_rmul_eq inversion +invertible_cmul +invertible_det_nz +invertible_i +invertible_left_inverse +invertible_mat +invertible_matrix_inv +invertible_matrix_mul +invertible_nearby_onorm +invertible_right_inverse +invertible_transp +involution_imp_homeomorphism_gen +io is +is_hull +is_interval_closure +is_interval_compact +is_interval_connected +is_interval_convex +is_interval_empty +is_interval_inter +is_interval_interval +is_interval_locally_compact_interval +is_interval_pcross +is_interval_reflect +is_interval_relative_interior +is_interval_scaling +is_interval_scaling_eq +is_interval_sing +is_interval_translation_eq +iso +isometries_subspaces +isometry_imp_embedding +isometry_imp_open_map +isometry_linear +isometry_on_imp_continuous_on +isometry_subspaces +isometry_univ_superset_subspace +isomorphism +isomorphism_expand +ispec +ispecl +iter +iter_pointless +iterate_and +iterate_clauses +iterate_image +iterate_nonzero_image_lemma +iterate_permute +iterate_reflect +iterate_support +itlist +ivt_increasing +jacobian_sign_invariance +jacobian_works +jewell +joinable_connected_component_eq +jonathan +judgement +k_3 +k_space_mtopology +k_tac +kall_tac +kc_space_euclidean +kc_space_mtopology +kc_space_subtopology +kernelaxiom +kill_tac +kind_to_u8 +kirch_lemma +kirszbraun +kleenerecursion +know_tac +known +kraft +krein_milman +krein_milman_frontier +krein_milman_minkowski +krein_milman_relative_frontier +kripke l l1 l2 l3 +label +label_abbrev_tac +label_tac +lagrange +lambda +lambda x. +lambda y. +lambda_beta +lambda_beta_perm +lambda_eta +lambda_pair +lambda_pair_thm +lambda_skolem +land_conv +last +last_append +later +lavrentiev +lavrentiev_extension +lavrentiev_homeomorphism le +le_0_n +le_add +le_add_rcancel +le_antisym +le_c +le_cases +le_exists +le_lt +le_mult_lcancel +le_mult_rcancel +le_n +le_n_s +le_refl +le_s +le_suc_lt +le_trans +lean +lean4 +least_elim_tac +lebesgue_density_theorem_integral_cball +lebesgue_density_theorem_lift_ball +lebesgue_density_theorem_lift_cball +lebesgue_differentiation_theorem +lebesgue_differentiation_theorem_alt +lebesgue_measurable_almost_fsigma +lebesgue_measurable_closed +lebesgue_measurable_closed_in +lebesgue_measurable_compact +lebesgue_measurable_compl +lebesgue_measurable_continuous_image +lebesgue_measurable_convex +lebesgue_measurable_countable_inters +lebesgue_measurable_countable_unions +lebesgue_measurable_diff +lebesgue_measurable_differentiable_image +lebesgue_measurable_iff_measurable +lebesgue_measurable_inner_closed +lebesgue_measurable_inner_compact +lebesgue_measurable_inter +lebesgue_measurable_interval +lebesgue_measurable_jordan +lebesgue_measurable_linear_image_eq +lebesgue_measurable_linear_image_gen +lebesgue_measurable_negligible_symdiff +lebesgue_measurable_on_subintervals +lebesgue_measurable_open +lebesgue_measurable_open_in +lebesgue_measurable_outer_open +lebesgue_measurable_pcross +lebesgue_measurable_preimage_card_le +lebesgue_measurable_preimage_finite +lebesgue_measurable_preimage_has_size +lebesgue_measurable_preimage_infinite +lebesgue_measurable_regular_inner +lebesgue_measurable_translation +lebesgue_measurable_union +lebesgue_measurable_unions +lebesgue_measurable_univ +lebesgue_number left +left_add_distrib +left_and_exists_thm +left_and_forall_thm +left_exists_and_thm +left_forall_imp_thm +left_imp_exists_thm +left_imp_forall_thm +left_invertible_transp +left_or_distrib +left_polar_decomposition +left_polar_decomposition_unique +left_right_inverse_eq +left_right_inverse_linear +left_sub_distrib lem +lemma length +length_app +length_eq_cons +length_eq_nil +length_linear_image +length_map +length_translation +leq +leq-refl +leq-trans +less +let +let_def +let_end_def +let_tac +let_trans +level +lex lia +lib +license +lift_add +lift_cmul +lift_component +lift_drop +lift_eq +lift_eq_cmul +lift_in_image_lift +lift_integral_component +lift_neg +lift_num +lift_sub +lift_sum +lift_to_quotient_space +lim_abs +lim_add +lim_at +lim_at_infinity +lim_at_infinity_within +lim_at_posinfinity +lim_at_reflect +lim_at_within +lim_at_zero +lim_bilinear +lim_bilinear_convolution +lim_cases_cofinite_sequentially +lim_cases_finite_sequentially +lim_cases_sequentially +lim_cesaro +lim_cmul +lim_cmul_eq +lim_component +lim_component_lbound +lim_component_le +lim_component_ubound +lim_componentwise_lift +lim_componentwise_real +lim_compose_within +lim_const +lim_drop_lbound +lim_drop_le +lim_eq_drop +lim_eventually +lim_in_closed_set +lim_inv +lim_lift_abs_component +lim_lift_det +lim_lift_dot +lim_lift_product +lim_linear +lim_matrix_componentwise +lim_matrix_vectorize +lim_max +lim_min +lim_mul +lim_mul_norm_within +lim_neg +lim_neg_eq +lim_norm +lim_norm_ubound +lim_null +lim_null_cmul +lim_null_cmul_eq +lim_null_comparison +lim_null_matrix_onorm +lim_null_matrix_onorm_componentwise +lim_null_norm +lim_null_onorm +lim_null_onorm_componentwise +lim_null_vmul_eq +lim_pastecart +lim_pastecart_eq +lim_self_within +lim_sequentially +lim_sub +lim_subsequence +lim_transform +lim_transform_at +lim_transform_away_within +lim_transform_eq +lim_transform_eventually +lim_transform_within +lim_transform_within_open +lim_transform_within_open_in +lim_transform_within_set_imp +lim_trivial +lim_union +lim_unique +lim_vectorize_componentwise +lim_vmul +lim_vsum +lim_within +lim_within_closed_trivial +lim_within_id +lim_within_le +lim_within_open +lim_within_open_in +lim_within_reflect +lim_within_sequentially +lim_within_subset +lim_within_union +lim_within_zero +limit_atpointof_sequentially_within +limit_atpointof_sequentially_within_inj +limit_componentwise_real +limit_eq_drop +limit_eq_lift +limit_euclidean +limit_metric +limit_metric_unique +limit_pair_drop_le +limit_point_finite +limit_point_in_derived_set +limit_point_of_image_gen +limit_point_of_interval +limit_point_union +limit_real_abs +limit_real_add +limit_real_inv +limit_trivial +limitarith +limpt_approachable +limpt_approachable_le +limpt_approachable_lift +limpt_ball +limpt_delete +limpt_empty +limpt_infinite_open +limpt_insert +limpt_of_closure +limpt_of_condensation_points +limpt_of_convex +limpt_of_limpts +limpt_of_open +limpt_of_open_in +limpt_of_sequence_subsequence +limpt_of_univ +limpt_sequential +limpt_sequential_inj +limpt_sing +limpt_subset +lindelof +lindelof_open_in +linear +linear-safety +linear-single +linear_add +linear_bijective_dimindex_eq +linear_bijective_left_right_inverse +linear_bijective_left_right_inverse_eq +linear_bounded +linear_bounded_pos +linear_closest_point +linear_cmul +linear_componentwise +linear_componentwise_expansion +linear_compose +linear_compose_add +linear_compose_cmul +linear_compose_neg +linear_compose_neg_eq +linear_compose_sub +linear_continuous_at +linear_continuous_compose +linear_continuous_on +linear_continuous_within +linear_eq +linear_eq_matrix +linear_eq_stdbasis +linear_from_reals +linear_fstcart +linear_id +linear_image_subset_interior +linear_imp_homeomorphism +linear_indep_image_lemma +linear_independent_extend +linear_independent_extend_lemma +linear_injective_bounded_below_pos +linear_injective_dimindex_le +linear_injective_iff_dim +linear_injective_imp_surjective +linear_injective_imp_surjective_on +linear_injective_isomorphism +linear_injective_left_inverse +linear_injective_left_inverse_eq +linear_injective_on_iff_dim +linear_invariant_rule +linear_inverse_left +linear_invertible_bounded_below_pos +linear_lift_component +linear_lift_dot +linear_limit +linear_neg +linear_negation +linear_pastecart +linear_pastecart_eq +linear_reflect_along +linear_scaling +linear_singular_image_hyperplane +linear_singular_into_hyperplane +linear_sndcart +linear_sub +linear_surjective_dimindex_le +linear_surjective_iff_dim +linear_surjective_iff_injective +linear_surjective_iff_injective_gen +linear_surjective_imp_injective +linear_surjective_isomorphism +linear_surjective_on_iff_dim +linear_surjective_right_inverse +linear_surjective_right_inverse_eq +linear_to_reals +linear_uniformly_continuous_on +linear_vmul_component +linear_vmul_drop +linear_vsum +linear_zero +linearity +lipschitz_continuous_imp_continuous_map +lipschitz_continuous_map_compose +lipschitz_continuous_map_pairwise +lipschitz_continuous_map_pastewise +lipschitz_continuous_map_pasting +lipschitz_convex_spherical_projection +lipschitz_imp_cauchy_continuous_map +lipschitz_imp_continuous_on +lipschitz_imp_has_bounded_variation +lipschitz_imp_uniformly_continuous_map +lipschitz_imp_uniformly_continuous_on +lipschitz_on_pos list +list_induct_tac +list_rec +listind +listind `l1` +ln_mono_le +ln_mono_lt +ln_pos_lt +ln_pow +locally_and_open_in +locally_and_small_le +locally_and_subset +locally_closed_in_explicit +locally_compact +locally_compact_alt +locally_compact_closed_inter_open +locally_compact_compact +locally_compact_compact_alt +locally_compact_imp_analytic +locally_compact_inter +locally_compact_inter_cball +locally_compact_open_in +locally_compact_open_inter_closure +locally_compact_open_unions +locally_compact_pcross +locally_compact_proper_image_eq +locally_compact_space_neighbourhood_base +locally_compact_univ +locally_constant_imp_constant +locally_empty +locally_imp_countable_union_of +locally_imp_finite_union_of +locally_injective_linear_image +locally_inter +locally_inter_open +locally_lebesgue_measurable_alt +locally_mono +locally_negligible_alt +locally_open_subset +locally_pcross +locally_to_compactly +locally_translation +lof +log_search +logic +logical +lookup +lowdim_eq_hyperplane +lowdim_eq_inter_hyperplane +lowdim_expand_dimension +lowdim_subset_hyperplane +lt +lt_antisym +lt_cases +lt_exists +lt_imp_le +lt_le +lt_mult +lt_mult_lcancel +lt_refl +lt_trans +lte +lte_antisym +lte_trans +ltm +ltp +luzin_sigma +luzin_sigma_explicit +luzin_sigma_nested m +makespan = max(a in activities)(end[a]) +management +manipulation map +map_app +map_append +map_every +map_reverse +mapp +markov +marks[1] = 0 +mat_cmul +mat_component +mat_eq +match_abbrev_tac +match_accept_tac +match_asmsub_rename_tac +match_assum_abbrev_tac +match_goalsub_rename_tac +match_mp +match_mp_tac +match_rename_tac +matrify_add +matrify_cmul +matrify_component +matrify_vectorize +matrix_add_component +matrix_add_ldistrib +matrix_add_rdistrib +matrix_add_rid +matrix_adjoint +matrix_arith +matrix_arith_tac +matrix_cmul +matrix_cmul_assoc +matrix_cmul_component +matrix_cmul_lid +matrix_cmul_lzero +matrix_component_le_onorm +matrix_entire +matrix_eq +matrix_equal_rows +matrix_full_linear_equations +matrix_i +matrix_id +matrix_inv +matrix_inv_cofactor +matrix_inv_covariance +matrix_inv_covariance_lmul +matrix_inv_covariance_rmul +matrix_inv_eq +matrix_inv_i +matrix_inv_inv +matrix_inv_mul +matrix_inv_mul_inner +matrix_inv_mul_outer +matrix_inv_multiple_tranp_left +matrix_inv_multiple_tranp_right +matrix_inv_orthogonal_lmul +matrix_inv_transp +matrix_inv_unique +matrix_inv_unique_strong +matrix_invertible +matrix_invertible_left_gen +matrix_invertible_right_gen +matrix_left_inverse_cofactor +matrix_left_invertible_injective +matrix_left_invertible_ker +matrix_left_invertible_span_rows +matrix_left_right_inverse +matrix_mul_assoc +matrix_mul_component +matrix_mul_covariance_lcancel +matrix_mul_diagonal +matrix_mul_dot +matrix_mul_lcancel +matrix_mul_lid +matrix_mul_linv +matrix_mul_lmul +matrix_mul_lneg +matrix_mul_ltransp_dot_column +matrix_mul_lzero +matrix_mul_rcancel +matrix_mul_rid +matrix_mul_right_cofactor +matrix_mul_rinv +matrix_mul_rmul +matrix_mul_rneg +matrix_mul_rtransp_dot_row +matrix_mul_rzero +matrix_mul_vsum +matrix_mul_vsum_alt +matrix_neg_component +matrix_neg_neg +matrix_neg_sub +matrix_nonfull_linear_equations +matrix_nonfull_linear_equations_eq +matrix_of_matrix_vector_mul +matrix_right_inverse_cofactor +matrix_right_invertible_independent_rows +matrix_right_invertible_span_columns +matrix_right_invertible_surjective +matrix_self_adjoint +matrix_sub_component +matrix_sub_eq +matrix_sub_ldistrib +matrix_sub_rdistrib +matrix_sub_refl +matrix_sub_rzero +matrix_transp_mul +matrix_transp_multiple_inv_left +matrix_transp_multiple_inv_right +matrix_vector_column +matrix_vector_lmul +matrix_vector_mul +matrix_vector_mul_add_ldistrib +matrix_vector_mul_add_rdistrib +matrix_vector_mul_assoc +matrix_vector_mul_basis +matrix_vector_mul_component +matrix_vector_mul_in_columnspace +matrix_vector_mul_lid +matrix_vector_mul_linear +matrix_vector_mul_lneg +matrix_vector_mul_lzero +matrix_vector_mul_rmul +matrix_vector_mul_rzero +matrix_vector_mul_sub_ldistrib +matrix_vector_mul_sub_rdistrib +matrix_vector_mul_transp +matrix_wlog_invertible +matrix_works +matroid_basis_submatroid +matroid_choose_subspace +matroid_dim_alt +matroid_dim_empty +matroid_dim_eq_span +matroid_dim_ge_finite_card_eq +matroid_dim_insert +matroid_dim_span +matroid_dim_span_eq_gen +matroid_dimension_unique +matroid_finite_dimensional +matroid_finite_dimensional_dim +matroid_independent_insert +matroid_independent_submatroid +matroid_intermediate_basis +matroid_lowdim_expand_basis +matroid_lowdim_expand_dimension +matroid_span_eq +matroid_span_insert_eq +matroid_spanning_submatroid +matroid_spanning_subset_independent +matroid_steinitz_exchange_finite +max +max_frequency = max(freq) +maxentropy +maximal_affine_independent_subset +maximal_independent_subset +maximal_independent_subset_extend +maybe +mball_euclidean +mbounded_and_mdiameter_le +mbounded_euclidean +mcball_euclidean +mcomplete_cfunspace +mcomplete_euclidean +mdiameter_bounded +mdiameter_closure +mdiameter_compact_attained +mdiameter_euclidean +mdiameter_le +mdiameter_pos_le +mdiameter_sing +mdiameter_subset +mdiameter_subset_mcball_nonempty +mdiameter_union_le +mdist +means +measurable +measurable_additive_imp_linear +measurable_affinity_eq +measurable_ball +measurable_cball +measurable_closure +measurable_compact +measurable_convex +measurable_convex_hull +measurable_countable_inters +measurable_diff +measurable_differentiable_image_eq +measurable_empty +measurable_imp_lebesgue_measurable +measurable_inner_compact +measurable_inner_outer +measurable_integrable +measurable_inter +measurable_interior +measurable_interval +measurable_jordan +measurable_lebesgue_measurable_subset +measurable_linear_image +measurable_linear_image_eq +measurable_linear_image_eq_gen +measurable_locally_lipschitz_image +measurable_measurable_preimage_closed +measurable_measurable_preimage_open +measurable_measure_pos_lt +measurable_negligible_symdiff +measurable_negligible_symdiff_eq +measurable_nested_unions +measurable_nonnegligible_imp_large +measurable_on_add +measurable_on_bilinear +measurable_on_cases +measurable_on_cmul +measurable_on_combine +measurable_on_componentwise +measurable_on_compose_alt +measurable_on_compose_continuous +measurable_on_compose_gen +measurable_on_compose_rev +measurable_on_const +measurable_on_const_eq +measurable_on_continuous_compose_rev +measurable_on_convolution +measurable_on_countable_unions +measurable_on_diff +measurable_on_drop_mul +measurable_on_empty +measurable_on_eq +measurable_on_indicator +measurable_on_inter +measurable_on_inverse_function +measurable_on_lebesgue_measurable_subset +measurable_on_left_inverse +measurable_on_lift_inv +measurable_on_lift_mul +measurable_on_lift_product +measurable_on_limit +measurable_on_linear_image_eq +measurable_on_linear_image_eq_gen +measurable_on_max +measurable_on_measurable_preimage_closed +measurable_on_measurable_preimage_open +measurable_on_neg +measurable_on_neg_eq +measurable_on_norm +measurable_on_partial_derivatives +measurable_on_pastecart +measurable_on_preimage_borel +measurable_on_preimage_closed +measurable_on_preimage_closed_interval +measurable_on_preimage_open +measurable_on_preimage_open_interval +measurable_on_preimage_orthant_le +measurable_on_preimage_orthant_le_dense +measurable_on_preimage_orthant_lt +measurable_on_preimage_orthant_lt_dense +measurable_on_reflect +measurable_on_restrict +measurable_on_spike +measurable_on_spike_set +measurable_on_spike_set_eq +measurable_on_sub +measurable_on_translation +measurable_on_union +measurable_on_unions +measurable_on_univ +measurable_on_vector_derivative_gen +measurable_on_vsum +measurable_open +measurable_outer_closed_intervals +measurable_outer_open +measurable_outer_open_intervals +measurable_pcross +measurable_scaling +measurable_scaling_eq +measurable_sing +measurable_translation_eq +measurable_union +measure_ball_pos +measure_cball_bound +measure_continuous_with_hausdist +measure_countable_unions_le +measure_countable_unions_le_strong +measure_countable_unions_le_strong_gen +measure_diff_subset +measure_differentiable_image_approx_gen +measure_disjoint_union +measure_empty +measure_frontier +measure_integral +measure_integral_univ +measure_interval +measure_limit +measure_locally_lipschitz_image +measure_negligible_symdiff +measure_negligible_union +measure_open_pos_lt +measure_open_pos_lt_eq +measure_orthogonal_image_eq +measure_pastecart_interval +measure_pos_le +measure_scaling +measure_sing +measure_sub_le_measure_diff +measure_subset +measure_translation +measure_union +measure_union_le +measure_unions_le +measure_unions_le_image +measure_unique +mem +mem_map +mem_translation +member +member_not_empty +memory +meson +meson_tac +metamath +metis +metis_tac +metric_continuous_map +metric_derived_set_of +metrizable_imp_k_space +metrizable_imp_kc_space +metrizable_imp_normal_space +metrizable_imp_paracompact_space +metrizable_space_euclidean +metrizable_space_mtopology +metrizable_space_separation +metrizable_space_subtopology middle +midef +midpoint_collinear +midpoint_convex_imp_continuous_ostrowski +midpoint_in_convex +midpoint_in_segment +midpoint_refl +midpoint_sym +miller_rabin_composite_imp_composite +miller_rabin_pseudoprime_bound_lt +miller_rabin_pseudoprime_bound_phi +miller_rabin_pseudoprime_imp_coprime +min +minimal +minimal_bad_sequence +minimax_theorem +mirror +mirror-involutive +mit +mk_comb +mnt +mod +modarith +modifies +module +module-impl +module-sig +moduluscauchy +modus_ponens +mono_and +mono_exists +mono_forall +mono_imp +mono_or +monoidal_and +monoidal_lifted +monoidal_real_add +monoidal_real_mul +monoidal_vector_add +monotone_bigger +monotone_closed_map +monotone_convergence_decreasing +monotone_convergence_decreasing_ae +monotone_convergence_increasing +monotone_open_map +monotonic +moore_penrose_pseudoinverse +moore_penrose_pseudoinverse_unique +morphism mp +mp_tac +msg +mspace +mtopology_euclidean_metric +mtopology_prod_metric +mtopology_real_euclidean_metric +mtopology_submetric +mul +mul_zero mult +mult_0_r +mult_ac +mult_assoc +mult_clauses +mult_exp +mult_le_compat_r +mult_plus_distr_l +mult_sym +multistep +mulzero +mutual_ind +mvp +mvt +mvt_segment +mvt_simple n nat +nat_rec +natind +natind `m` +natind `n` +natural +naturality +nearby_invertible_matrix +nearby_positive_definite_matrix_gen +necessitate need +neg_translation +negligible +negligible_absolutely_continuous_image +negligible_affine_hull +negligible_affinity_eq +negligible_convex_frontier +negligible_convex_hull +negligible_convex_interior +negligible_countable +negligible_countable_unions +negligible_countable_unions_gen +negligible_diff +negligible_differentiable_image_lowdim +negligible_differentiable_preimage +negligible_disjoint_translates +negligible_empty +negligible_empty_interior +negligible_eq_zero_density_alt +negligible_finite +negligible_frontier_interval +negligible_hyperplane +negligible_imp_lebesgue_measurable +negligible_imp_measurable +negligible_insert +negligible_inter +negligible_linear_image +negligible_linear_image_eq +negligible_linear_image_gen +negligible_linear_singular_image +negligible_locally_lipschitz_image +negligible_lowdim +negligible_on_countable_intervals +negligible_on_intervals +negligible_on_univ +negligible_outer +negligible_pcross +negligible_rectifiable_path_image +negligible_scaling +negligible_scaling_eq +negligible_sing +negligible_sphere +negligible_standard_hyperplane +negligible_subset +negligible_symdiff_eq +negligible_translation_eq +negligible_translation_rev +negligible_union +negligible_union_eq +negligible_unions +neighbourhood_base_of +neighbourhood_base_of_euclidean +net_within_univ +netlimit_at +netlimit_atpointof +netlimit_within +netlimits_at_infinity +netlimits_at_neginfinity +netlimits_at_posinfinity +netlimits_within +neutral_and +neutral_lifted +neutral_real_add +neutral_vector_add +newton +nfa-run nil nm +no_tac +nondecreasing_extends_from_dense +nondecreasing_extends_to_convex_hull +none +nonempty_affine_exists +nonneg +nonnegative_absolutely_integrable +norm_add_pythagorean +norm_add_rule +norm_arith +norm_arith_tac +norm_basis +norm_bound_generalize +norm_canon_conv +norm_cauchy_schwarz +norm_cauchy_schwarz_abs +norm_cauchy_schwarz_abs_eq +norm_cauchy_schwarz_eq +norm_cauchy_schwarz_equal +norm_cmul_rule +norm_column_le_onorm +norm_eq +norm_eq_square +norm_fstcart +norm_ge_square +norm_le +norm_le_componentwise +norm_le_pastecart +norm_le_square +norm_lift +norm_lt +norm_mp +norm_mul +norm_neg +norm_pastecart +norm_pastecart_le +norm_pos_le +norm_pos_lt +norm_real +norm_sndcart +norm_sub +norm_tac +norm_triangle +norm_triangle_eq +norm_triangle_sub +norm_vector_derivatives_le_within +norm_vectorize_orthogonal_matrix_rmul +norm_vectorize_transp +norm_vsum_pythagorean +norm_vsum_trivial_lemma +normal_matrix_iff_same_norm_transp +normal_matrix_kernel_transp_explicit +normal_matrix_same_eigenpairs_transp +normal_matrix_similar_transp +normal_right_polar_decomposition +normal_space_disjoint_closures +normalform +normalize not +not_bounded_univ +not_cons_nil +not_even +not_exists_thm +not_forall_thm +not_imp +not_in_empty +not_insert_empty +not_le +not_lt +not_miller_rabin_composite +not_miller_rabin_pseudoprime +not_negligible_univ +not_odd +not_open_sing +not_suc now +nowhere_dense_countable_unions_closed +nowhere_dense_countable_unions_closed_in +nproduct_clauses +nullspace_inter_rowspace +num_colors = max(color) +num_countable +num_reduce_conv +num_towers = sum(build) +num_vlans = max(vlan) +num_wavelengths = max(wavelength) +number +number_rule +numseg_clauses +numseg_conv +numseg_dimindex_nonempty +numseg_empty +numseg_offset_image +numseg_rec +numseg_sing o +obtain odd +odd_1 +odd_add +odd_exp +odd_ss of on +once_asm_rewrite_tac +once_depth_conv +once_rewrite_rule +once_rewrite_tac +one +onorm +onorm_adjoint +onorm_compose +onorm_compose_adjoint_left +onorm_compose_adjoint_right +onorm_const +onorm_covariance +onorm_covariance_alt +onorm_diagonal_matrix +onorm_diagonalized_matrix +onorm_dot +onorm_i +onorm_id +onorm_inverse_det_le_onorm_pow +onorm_le_eq +onorm_neg +onorm_orthogonal_matrix_mul_left +onorm_orthogonal_matrix_mul_right +onorm_orthogonal_transformation +onorm_pos_le +onorm_pos_lt +onorm_triangle +op +open +open_affinity_eq +open_ball +open_closed +open_contains_ball +open_contains_ball_eq +open_contains_cball +open_contains_interval +open_convex_hull +open_countable_union_closed_intervals +open_delete +open_diff +open_empty +open_exists_in +open_halfspace_component_gt +open_halfspace_component_lt +open_halfspace_gt +open_halfspace_lt +open_imp_analytic +open_imp_borel +open_imp_fsigma +open_imp_gdelta +open_imp_gdelta_in +open_imp_locally_compact +open_in +open_in_borel +open_in_closed_in_eq +open_in_conic_hull +open_in_contains_ball +open_in_contains_cball +open_in_delete +open_in_diff +open_in_empty +open_in_euclidean +open_in_euclidean_metric +open_in_imp_subset +open_in_injective_linear_image +open_in_inter +open_in_inter_closure_of_eq +open_in_inter_closure_of_eq_empty +open_in_interior_of +open_in_mtopology +open_in_open +open_in_open_eq +open_in_open_inter +open_in_open_trans +open_in_pcross +open_in_refl +open_in_relative_interior +open_in_relative_to +open_in_same_conic_hull +open_in_separated_union +open_in_subopen +open_in_subset +open_in_subset_relative_interior +open_in_subset_trans +open_in_subtopology +open_in_subtopology_empty +open_in_subtopology_inter_open_in +open_in_subtopology_inter_subset +open_in_subtopology_refl +open_in_trans +open_in_union +open_inside +open_inter +open_inter_closure_eq_empty +open_inter_closure_subset +open_interior +open_inters +open_interval +open_interval_left +open_interval_lemma +open_interval_right +open_map_from_composition_injective +open_map_from_composition_surjective +open_map_preimage_neighbourhood +open_not_negligible +open_open_in_trans +open_open_left_projection +open_open_right_projection +open_pcross +open_pcross_eq +open_relative_to +open_scaling +open_scaling_eq +open_segment_alt +open_segment_linear_image +open_strip_component_lt +open_subopen +open_subset +open_sums +open_surjective_linear_image +open_translation_eq +open_translation_subset_preimage +open_union +open_unions +open_univ +openaxiom +operational +operative_absolutely_continuous_on +operative_absolutely_setcontinuous_on +operative_approximable +operative_content +operative_division +operative_division_and +operative_function_endpoint_diff +operative_has_bounded_setvariation_on +operative_integrable +operative_integral +operative_lifted_setvariation +operative_tagged_division or +or-comm +or_exists_thm +order +orelim +orelse +orthogonal_any_closest_point +orthogonal_basis +orthogonal_basis_subspace +orthogonal_clauses +orthogonal_extension +orthogonal_extension_strong +orthogonal_lneg +orthogonal_matrix +orthogonal_matrix_alt +orthogonal_matrix_exists_basis +orthogonal_matrix_imp_invertible +orthogonal_matrix_inv +orthogonal_matrix_mul +orthogonal_matrix_orthonormal_columns +orthogonal_matrix_orthonormal_rows_span +orthogonal_matrix_transformation +orthogonal_matrix_transp +orthogonal_matrix_transp_rmul +orthogonal_mul +orthogonal_nullspace_rowspace +orthogonal_projection_alt +orthogonal_refl +orthogonal_rotation_or_rotoinversion +orthogonal_spanningset_subspace +orthogonal_subspace_decomp_exists +orthogonal_subspace_decomp_unique +orthogonal_sym +orthogonal_to_span +orthogonal_to_span_eq +orthogonal_to_spans_eq +orthogonal_to_subspace_exists +orthogonal_to_subspace_exists_gen +orthogonal_transformation +orthogonal_transformation_exists +orthogonal_transformation_id +orthogonal_transformation_injective +orthogonal_transformation_into_subspace +orthogonal_transformation_inverse +orthogonal_transformation_linear +orthogonal_transformation_matrix +orthogonal_transformation_neg +orthogonal_transformation_negation +orthogonal_transformation_reflect_along +orthogonal_transformation_surjective +orthonormal_basis_expand +orthonormal_basis_expand_dot +orthonormal_basis_subspace +orthonormal_extension +outer_lebesgue_measure +outer_measure +outer_measure_gen +over p +p_hull +p_i_h +pair_eq +pairarg_tac +pairelim +pairwise_disjoint_components +pairwise_empty +pairwise_image +pairwise_imp +pairwise_insert +pairwise_mono +pairwise_orthogonal_imp_finite +pairwise_orthogonal_independent +pairwise_sing +paracompact_partition_of_unity +paracompact_space_euclidean_subtopology +paracompact_space_mtopology +parametricity +parse +part_match +part_measures +partial_division_extend +partial_division_extend_interval +partial_division_of_tagged_division +partial_expand_quants_conv +partial_sums_component_le_infsum +partition +pastecart_add +pastecart_as_orthogonal_sum +pastecart_cmul +pastecart_eq +pastecart_fst_snd +pastecart_in_interior_subtopology +pastecart_in_pcross +pastecart_inj +pastecart_neg +pastecart_sub +pastecart_vec +pastecart_vsum +pasting_lemma +path_combine +path_continuous_image +path_eq +path_join +path_join_path_ends +path_length_isometric_image +path_length_pos_le +path_length_reparametrization +path_length_reversepath +path_length_subpath +path_linear_image_eq +path_linepath +path_reversepath +path_shiftpath +path_subpath +path_translation_eq +pathfinish_in_path_image +pathstart_in_path_image +patterns +pcross +pcross_as_orthogonal_sum +pcross_diff +pcross_empty +pcross_eq +pcross_eq_empty +pcross_interval +pcross_mono +pda-state +pell_induction +per cases +perfect_from_closure +permut +permutation_permutes +permutes_bijections +permutes_empty +permutes_image +permutes_in_image +permutes_injective +permutes_inverse +permutes_inverse_eq +permutes_sing +permutes_swap +pf +phabs +phi_limit_strong +php +pigeon +pigeonhole +pigeons +pinst +pipeline plus +plus-assoc +plus-comm +plus_assoc +pmpl +polar_dual +polar_dual_polar_dual_eq +polar_dual_polar_dual_gen +polar_dual_scaling +polar_dual_unit_cball +polyhedron_as_cone_plus_conv +polyhedron_conic_hull_polytope +polyhedron_convex_cone_hull +polyhedron_empty +polyhedron_eq_finite_exposed_faces +polyhedron_eq_finite_faces +polyhedron_halfspace_ge +polyhedron_halfspace_le +polyhedron_hyperplane +polyhedron_imp_closed +polyhedron_imp_convex +polyhedron_inter +polyhedron_inter_affine +polyhedron_inter_affine_minimal +polyhedron_inter_affine_parallel +polyhedron_inter_affine_parallel_minimal +polyhedron_inters +polyhedron_linear_image_eq +polyhedron_minimal_lemma +polyhedron_negations +polyhedron_polytope_sums +polyhedron_sums +polyhedron_univ polynomial +polytope_affinity_eq +polytope_convex_hull +polytope_empty +polytope_eq_bounded_polyhedron +polytope_imp_bounded +polytope_imp_closed +polytope_imp_compact +polytope_imp_convex +polytope_imp_polyhedron +polytope_interval +polytope_linear_image +polytope_pcross +polytope_scaling +polytope_scaling_eq +polytope_segment +polytope_sing +polytope_translation_eq +pop_assum +pop_assum_list +populate +positive_ae_derivative_imp_nondecreasing +positive_definite_cmul +positive_definite_cofactor +positive_definite_diagonal_matrix +positive_definite_diagonal_matrix_eq +positive_definite_eigenvalues +positive_definite_id +positive_definite_imp_invertible +positive_definite_imp_symmetric_matrix +positive_definite_inv +positive_definite_mat +positive_definite_mul_eq +positive_definite_positive_semidefinite +positive_definite_transp +positive_semidefinite_antisym +positive_semidefinite_covariance +positive_semidefinite_covariance_eq +positive_semidefinite_covariance_eq_alt +positive_semidefinite_covariance_unique +positive_semidefinite_diagonal_matrix +positive_semidefinite_diagonal_matrix_eq +positive_semidefinite_eigenvalues +positive_semidefinite_imp_symmetric +positive_semidefinite_inv +positive_semidefinite_mat +positive_semidefinite_mul_eq +positive_semidefinite_similar +positive_semidefinite_similar_eq +positive_semidefinite_sqrt_eq +positive_semidefinite_transp +positive_semidefinite_zero_form +positive_semidefinite_zero_form_eq +positive_semidefinite_zero_row power +powerset_clauses +preservation +preservation-lemma +preserves +preserves_negligible_image +preserves_norm_preserves_dot +preseves_norm_preserves_dist +prevents +prime_coprime_eq +prime_imp_miller_rabin_pseudoprime +prime_odd +principles +probaxiom +prod_metric +product_clauses +product_clauses_numseg +product_closed +product_eq +product_eq_numseg +product_mul +product_mul_numseg +product_permute +product_pos_le_numseg +product_pos_lt_numseg +product_sing +product_sing_numseg +progress +progress-lemma +project +proof +proofs +prop +proper_eq_compact_map +proper_map +proper_map_eq +proper_map_escapes_imp +proper_map_euclidean +proper_map_from_compact +proper_map_fstcart +proper_map_into_euclidean +proper_map_norm +proper_map_norm_simple +proper_map_sequentially +proper_map_sequentially_imp +proper_map_sequentially_rev +proper_map_sndcart +property +property_empty_interval proposition +propositional +propositional_sat propositions +proto prove +prove_tac +prover +proverkindinjectivity +proves provide +psubset +psubset_alt +psubset_irrefl +pure_once_asm_rewrite_tac +pure_once_rewrite_tac +pure_rewrite_tac +pushin_dropout +q_tac +qabbrev_tac +qed +qexists_tac +qexistsl_tac +qf_ax +qf_bv +qf_lia +qf_nia +qf_nra +qf_uf +qid_spec_tac +qmatch_abbrev_tac +qmatch_goalsub_rename_tac +qualifiers +quantification +quantifiers +quantify_surjection_higher_thm +quantify_surjection_thm +quotient_map_from_composition_explicit +quotient_map_imp_continuous_open +quotient_map_open_closed +quotienteq +quotientlift +qx_gen_tac r +rademacher +rademacher_open +rademacher_univ +radon_ex_lemma +radon_partition +rand_conv +rank_bound +rank_cmul +rank_cofactor_eq_full +rank_dim_im +rank_eq_full_det +rank_gram +rank_invertible_lmul +rank_invertible_rmul +rank_matrix_inv +rank_matrix_inv_lmul +rank_matrix_inv_rmul +rank_mul_le_left +rank_mul_le_right +rank_nullspace +rank_row +rank_sylvester +rank_transp +rational_approximation +rational_approximation_above +rational_between +rational_closed +rationaldensity +rator_conv +ray_to_frontier +ray_to_relative_frontier +re-match +reads +real +real_abs_abs +real_abs_div +real_abs_inv +real_abs_le +real_abs_mul +real_abs_neg +real_abs_norm +real_abs_num +real_abs_nz +real_abs_pos +real_abs_pow +real_abs_refl +real_abs_sub +real_abs_sub_infnorm +real_abs_sub_norm +real_abs_zero +real_add_ac +real_add_assoc +real_add_ldistrib +real_add_lid +real_add_linv +real_add_rdistrib +real_add_rid +real_add_sym +real_affinity_eq +real_affinity_le +real_arch_inv +real_arch_least +real_arch_lt +real_arch_pow_inv +real_arch_simple +real_arith +real_arith_tac +real_bounds_lt +real_complete +real_convex_bound_le +real_convex_bound_lt +real_div_lmul +real_div_refl +real_div_rmul +real_entire +real_eq_affinity +real_eq_imp_le +real_eq_integers +real_eq_mul_lcancel +real_eq_mul_rcancel +real_eq_square_abs +real_euclidean_metric +real_field +real_half +real_hausdist_le +real_hausdist_le_eq +real_inf_unique +real_interval_interval +real_inv_inv +real_inv_neg +real_le_add +real_le_addl +real_le_addr +real_le_affinity +real_le_antisym +real_le_div +real_le_hausdist +real_le_inf +real_le_inf_subset +real_le_inv_eq +real_le_ladd +real_le_ldiv_eq +real_le_lmul +real_le_lmul_eq +real_le_lsqrt +real_le_lt +real_le_max +real_le_min +real_le_mul +real_le_mul_eq +real_le_negtotal +real_le_norm_matrix_mul_det +real_le_radd +real_le_rdiv_eq +real_le_refl +real_le_rmul +real_le_rmul_eq +real_le_rsqrt +real_le_setdist +real_le_setdist_eq +real_le_square +real_le_square_abs +real_le_sub_ladd +real_le_sub_radd +real_le_sup +real_le_sup_finite +real_le_total +real_le_trans +real_le_trans_lt +real_le_trans_lte +real_let_add +real_let_antisym +real_let_trans +real_linear_prover +real_lt_add +real_lt_addr +real_lt_antisym +real_lt_div +real_lt_imp_le +real_lt_imp_ne +real_lt_imp_nz +real_lt_inf_finite +real_lt_inv_eq +real_lt_ladd +real_lt_lcancel_imp +real_lt_ldiv_eq +real_lt_le +real_lt_lmul_eq +real_lt_max +real_lt_min +real_lt_mul +real_lt_mul_eq +real_lt_rdiv_eq +real_lt_refl +real_lt_rneg +real_lt_square +real_lt_sub_ladd +real_lt_trans +real_lte_add +real_lte_trans +real_max_le +real_max_max +real_min_le +real_min_lt +real_mul_ac +real_mul_assoc +real_mul_lid +real_mul_linv +real_mul_lzero +real_mul_rid +real_mul_rinv +real_mul_rneg +real_mul_rzero +real_mul_sum +real_mul_sym +real_neg_add +real_neg_eq +real_neg_neg +real_non_monotone +real_not_le +real_not_lt +real_of_num_add +real_of_num_eq +real_of_num_le +real_of_num_lt +real_of_num_mul +real_of_num_sub +real_of_num_suc +real_poly_conv +real_polyfun_finite_roots +real_pos +real_pow_add +real_pow_inv +real_pow_lt +real_pow_mul +real_pow_one +real_pow_zero +real_qelim_conv +real_rat_reduce_conv +real_ring +real_rsqrt_le +real_setdist_lt_exists +real_sgn_cases +real_sgn_eq +real_sos +real_sub_add +real_sub_ldistrib +real_sub_le +real_sub_lt +real_sub_rdistrib +real_sub_refl +real_sub_rzero +real_sum_of_squares +real_sup_le +real_sup_le_eq +real_sup_le_finite +real_sup_le_subset +real_sup_unique +real_vector_ineq_prover +real_wlog_le +real_wlog_lt rearrange +rec-concat +reconsider +record +rectifiable_path_imp_path +rectifiable_path_join +rectifiable_path_join_imp +rectifiable_path_shiftpath +rectifiable_path_subpath_eq +redepth_conv +reduc +reduction refl +refl_tac +reflect_along_add +reflect_along_basis +reflect_along_basis_component +reflect_along_eq_self +reflect_along_involution +reflect_along_mul +reflect_along_scale +reflect_along_switch +reflect_along_zero +reflect_interval +reflect_univ +reflexive_frame reflexivity +regex +region +regions +regular_closed_in +regular_closed_union +regular_closure_interior +regular_closure_of_interior_of +regular_interior_closure +regular_interior_of_closure_of +regular_open_in +regular_polytope_exists +regular_space_euclidean +regular_space_mtopology +regular_space_subtopology +relative_boundary_of_convex_hull +relative_boundary_of_polyhedron +relative_boundary_of_triangle +relative_boundary_point_in_exposed_face +relative_boundary_point_in_proper_face +relative_frontier_closure +relative_frontier_conic_hull +relative_frontier_convex_hull_explicit +relative_frontier_empty +relative_frontier_facial_partition_alt +relative_frontier_nonempty_interior +relative_frontier_of_convex_closed +relative_frontier_of_convex_hull +relative_frontier_sing +relative_frontier_subset +relative_frontier_subset_frontier +relative_interior +relative_interior_affine +relative_interior_closure_subset +relative_interior_conic_hull +relative_interior_convex_hull_explicit +relative_interior_convex_inter_affine +relative_interior_empty +relative_interior_eq +relative_interior_eq_closure +relative_interior_eq_empty +relative_interior_interior +relative_interior_interior_of +relative_interior_linear_image_convex +relative_interior_maximal +relative_interior_nonempty_interior +relative_interior_of_polyhedron +relative_interior_open +relative_interior_open_in +relative_interior_prolong +relative_interior_segment +relative_interior_sing +relative_interior_subset +relative_interior_subset_of_proper_face +relative_interior_unique +relative_to_subset +relative_to_univ +remove_then +rename_tac +repeat +repeat_tcl +replicate_tac +repos +requires +res_tac +resolution_completeness +resolution_soundness +restriction result rev +rev_app_distr +rev_full_simp_tac +reverse +reverse_append +reverse_linear_image +reverse_translation +reversepath_reversepath +reversepath_subpath rewrite +rewrite_conv +rewrite_rule +rewrite_tac right +right_and_exists_thm +right_and_forall_thm +right_exists_and_thm +right_exists_imp_thm +right_forall_imp_thm +right_imp_exists_thm +right_imp_forall_thm +right_inverse_linear +right_invertible_transp +right_or_distrib +right_polar_decomposition +right_polar_decomposition_invertible +right_polar_decomposition_unique +right_sub_distrib ring +ringaxiom +rm_all_abbrevs_tac +rolle +rotation_exists +rotation_lowdim_horizontal +rotation_matrix_exists_basis +rotation_to_general_position_exists_gen +rotoinversion_exists_gen +rotoinversion_matrix_reflect_along +row_transp +rows_transp +rsum_bound +rtc_cr +rtc_mono +rtc_refl +rule +rule antisym +rule order_antisym +rule_assum_tac +rule_l_assum_tac +rules +runner rw +rw_tac s +safe +safety +same_distances_to_affine_hull +same_eigenvalues_matrix_mul +same_norm_same_dot +sandbox +sat +satisfiable +scaling_linear +second_mean_value_theorem_bonnet_full +second_mean_value_theorem_full +second_mean_value_theorem_gen_full +segment_as_ball +segment_closed_open +segment_convex_hull +segment_eq_empty +segment_face_of +segment_furthest_le +segment_image_interval +segment_open_subset_closed +segment_refl +segment_subset_convex +segment_subset_relative_frontier_convex +segment_sym +segment_to_closest_point +segment_to_frontier_simple +segment_to_relative_frontier_simple +select +select_conv +select_elim_tac +select_refl +select_unique +self +self_adjoint_has_eigenvector +self_adjoint_has_eigenvector_basis +self_adjoint_has_eigenvector_in_subspace +self_adjoint_orthogonal_eigenvectors +semantics +separate_compact_closed +separate_point_closed +separated_in_subtopology +separating_hyperplane_affine_affine +separating_hyperplane_closed_compact +separating_hyperplane_closed_point +separating_hyperplane_closed_point_inset +separating_hyperplane_set_point_inaff +separating_hyperplane_sets +separation_closed_in_union_gen +separation_closures +separation_hausdorff +separation_normal +separation_normal_local_closures +separation_open_in_union_gen +seq_harmonic_offset +seq_offset +seq_offset_eq +seq_offset_rev +sequence_cauchy_wlog +sequence_escapes +sequentially +series_add +series_bilinear +series_cauchy +series_cauchy_uniform +series_cmul +series_comparison +series_component +series_dirichlet_bilinear +series_drop_le +series_even +series_finite +series_finite_support +series_from +series_injective_image +series_injective_image_strong +series_lift_absconv_imp_conv +series_linear +series_neg +series_odd +series_ratio +series_rearrange +series_rearrange_eq +series_restrict +series_sub +series_subset +series_trivial +series_unique +session-safe +set +set_diff_frontier +set_eq_tac +set_induct_tac +set_prove_cases +set_rule +set_tac +set_variation +set_variation_cmul +set_variation_comparison +set_variation_degenerates +set_variation_elementary_lemma +set_variation_eq +set_variation_ge_function +set_variation_interval_lemma +set_variation_lbound +set_variation_monotone +set_variation_on_division +set_variation_on_elementary +set_variation_on_empty +set_variation_on_interval +set_variation_on_null +set_variation_pos_le +set_variation_triangle +set_variation_ubound +setdist_closure +setdist_compact_closed +setdist_differences +setdist_empty +setdist_frontier +setdist_hausdist_triangle +setdist_le_dist +setdist_le_sing +setdist_linear_image +setdist_pos_le +setdist_pos_lt +setdist_refl +setdist_scaling +setdist_sing_frontier +setdist_sing_in_set +setdist_sing_le_hausdist +setdist_sing_triangle +setdist_sings +setdist_subset_left +setdist_subset_right +setdist_subsets_eq +setdist_sym +setdist_translation +setdist_triangle +setdist_unique +setdist_zero +setext +setvariation_equal_lemma +shannonsource +shortest_arc_exists +shortest_path_exists +shortest_path_exists_gen +shortest_path_exists_straddle show side +sigma_compact +sign_i +sign_inverse +sign_nz +sign_swap simp +simp_all +simp_rule +simp_tac simpl +simple +simple_image +simple_image_gen +simple_path_length_minimal +simplex +simplex_alt +simplex_empty +simplex_explicit +simplex_extremal_le +simplex_extreme_points +simplex_face_of_simplex +simplex_furthest_le +simplex_furthest_lt +simplex_furthest_lt_exists +simplex_imp_compact +simplex_imp_convex +simplex_imp_polytope +simplex_segment +simplex_segment_cases +simplex_sing +simplicial_complex_imp_triangulation +simplicial_subdivision_of_cell_complex since +sing_gspec +sing_subset +skolem +skolem_thm sm +small +small_imp_totally_disconnected +smn +smt +smtpat +snd +sndcart_add +sndcart_cmul +sndcart_component +sndcart_neg +sndcart_pastecart +sndcart_sub +sndcart_vec +sndcart_vsum +snoc_induct_tac so +socrates +solovay_lemma +solovay_proforma_eq +solovay_vector_tac +solution +solutions_are_xy solves +some +sort +sorted +source +span_add +span_add_eq +span_breakdown +span_breakdown_eq +span_card_ge_dim +span_clauses +span_columnspace +span_conic_hull +span_convex_hull +span_empty +span_eq +span_eq_dim +span_eq_self +span_explicit +span_finite +span_image_scale +span_inc +span_induct +span_induct_alt +span_linear_image +span_mono +span_mul +span_neg +span_not_univ_orthogonal +span_not_univ_subset_hyperplane +span_of_subspace +span_open +span_pcross +span_pcross_subset +span_sing +span_span +span_stdbasis +span_sub +span_subset_subspace +span_subspace +span_superset +span_union +span_univ +span_vsum +spans_image +spdx +spec +spec_all +spec_tac +special_hyperplane_span +specl +sphere_empty +sphere_eq_empty +sphere_eq_sing +sphere_sing +sphere_union_ball split +sqrt_inj +sqrt_mono_le_eq +sqrt_mono_lt_eq +sqrt_mul +sqrt_pos_le +sqrt_unique +squeeze +srw_tac ss +sspec_tac +st +stage +starlike_linear_image +starlike_negligible +starlike_negligible_bounded_measurable +starlike_negligible_lemma +starlike_pcross +state +state-m +statu +status +std_simplex +stdlib +steinhaus +steinhaus_lebesgue +steinhaus_sums +step +step_down_lemma +stepanov +stepanov_gen +store +stream +strictly +strip_assume_tac +strip_tac +strong-norm +strong_ind +strong_ind on a +strong_ind on b +strong_ind on n +stronginduction +struct-eq +struct_cases_tac sub +sub_add +sub_refl +subadditive_content_division +subcircuit(next) +subgoal_tac +subgoal_then +subgroupaxiom +subinterval_mean_value_theorem_seq +submatroid_subset +submetric +subs_conv +subsequence_diagonalization_lemma +subset +subset_antisym +subset_antisym_eq +subset_ball +subset_balls +subset_cball +subset_closure +subset_convex_hull_frontier +subset_convex_hull_relative_frontier +subset_delete +subset_diff +subset_empty +subset_face_of_simplex +subset_halfspaces_imp_collinear +subset_hull +subset_image +subset_inter +subset_interior +subset_interior_eq +subset_interval +subset_of_face_of +subset_of_face_of_affine_hull +subset_pcross +subset_refl +subset_relative_interior +subset_restrict +subset_second_countable +subset_segment_open_closed +subset_sums_lcancel +subset_sums_rcancel +subset_trans +subset_union +subset_univ +subspace_add +subspace_bounded_eq_trivial +subspace_convex_cone_symmetric +subspace_exists +subspace_imp_affine +subspace_imp_conic +subspace_imp_convex +subspace_imp_nonempty +subspace_isomorphism +subspace_kernel +subspace_linear_fixed_points +subspace_linear_image +subspace_mul +subspace_neg +subspace_orthogonal_to_vector +subspace_pcross +subspace_span +subspace_special_hyperplane +subspace_sub +subspace_substandard +subspace_sums +subspace_translation_self +subspace_trivial +subspace_univ +subspace_vsum +subst +subst-lemma +subst1_tac +subst_all_tac +subst_occs_tac +subst_tac +substitution +subtopology_eq_discrete_topology_finite +subtopology_subtopology +subtopology_univ +subtyperefl +subtypetrans +suc +suc_inj +suff_tac sum +sum(allocation) = 1.0 +sum(i in 1..n)(square[i,i]) = magic_sum +sum(mix) = 1.0 +sum(place) <= max_panels +sum.cong +sum.delta +sum.swap +sum_abs +sum_add +sum_add_gen +sum_add_numseg +sum_add_split +sum_bound +sum_cases +sum_clauses +sum_clauses_left +sum_clauses_numseg +sum_combine_l +sum_combine_r +sum_const +sum_const_numseg +sum_degenerate +sum_delete +sum_delta +sum_diff +sum_eq +sum_eq_general +sum_eq_general_inverses +sum_eq_numseg +sum_group +sum_group_relation +sum_image +sum_image_gen +sum_image_le +sum_image_nonzero +sum_incl_excl +sum_injection +sum_le +sum_le_included +sum_le_numseg +sum_lmul +sum_mul_bound +sum_neg +sum_offset +sum_over_permutations_insert +sum_over_tagged_partial_division_lemma +sum_pair +sum_permutations_compose_r +sum_permutations_inverse +sum_pos_le +sum_pos_le_numseg +sum_pos_lt +sum_pos_lt_all +sum_restrict_set +sum_rmul +sum_sing +sum_sing_numseg +sum_sub +sum_sub_numseg +sum_sum_product +sum_superset +sum_swap +sum_swap_numseg +sum_triv_numseg +sum_union +sum_union_nonzero +sum_vsum +summable_cauchy +summable_comparison +summable_eq_cofinite +summable_from_elsewhere +summable_from_elsewhere_eq +summable_iff_cofinite +summable_iff_eventually +summable_imp_tozero +summable_ratio +summable_restrict +summable_subset +sums_eq +sums_finite_diff +sums_finite_union +sums_iff +sums_infsum +sums_reindex +sums_sym +sup +sup_eq +sup_finite +sup_insert_finite +sup_sing +sup_union +sup_unique +supporting_hyperplane_compact_point_sup +supporting_hyperplane_point +supporting_hyperplane_relative_boundary +supporting_hyperplane_relative_frontier +suppose +surjective_exists_thm +surjective_forall_thm +surjective_image +surjective_image_eq +surjective_image_thm +surjective_map +surjective_right_inverse +surjective_scaling +suslin_inter +suslin_inters +suslin_lebesgue_measurable +suslin_mono +suslin_regular +suslin_superset +suslin_suslin +suslin_union +suslin_unions +sussmann_open_mapping +swap_exists_thm +swap_forall_thm +swap_idempotent +swap_refl +syllogis +sym +sym_conv +symmetric_matrix +symmetric_matrix_add +symmetric_matrix_cmul +symmetric_matrix_covariance +symmetric_matrix_diagonalizable_explicit +symmetric_matrix_eq_diagonalizable +symmetric_matrix_eq_diagonalizable_alt +symmetric_matrix_imp_diagonalizable +symmetric_matrix_inv +symmetric_matrix_inv_lmul +symmetric_matrix_inv_rmul +symmetric_matrix_mat +symmetry_eq +syntax +system t +tabs tactic +tagged_division_of +tagged_division_of_alt +tagged_division_of_empty +tagged_division_of_finite +tagged_division_union +tagged_division_union_interval +tagged_division_unions +tagged_partial_division_of_trivial +tagged_partial_division_of_union_self +tagged_partial_division_subset +take +taut +taut_tac +team +tendsto_alt +tendsto_alt_within +terminates terms +tests +than +that the +then +thenc +thenl +theorem +thin_frontier_cic +thin_frontier_ici +thin_frontier_of_cic +thin_frontier_of_ici this +thus +tietze_closed_interval +tietze_open_interval +tietze_unbounded +times +times-zero-right +tiny +tl +tm to +toeplitz_bilinear_series_null +token +top_depth_conv +top_depth_sqconv +topological_sort +topology_eq +topspace_euclidean +topspace_euclidean_space +topspace_euclidean_subtopology +topspace_euclideanreal_subtopology +topspace_mtopology +topspace_subtopology +tot +totality +totally_bounded_hausdist +totally_bounded_in_imp_mbounded +tp +tptp +trace +trace-append +trace-step +trace_covariance_cauchy_schwarz +trace_covariance_cauchy_schwarz_abs +trace_covariance_pos_le +trace_matrix_inv_lmul +trace_mul_cyclic +trace_mul_sym +trace_positive_semidefinite +trace_sub +trace_transp +tracker trans +trans_tac +transfinite +transitions +transitive_frame +transitive_stepwise_le +transitivity +translation_diff +translation_galois +translation_subset_galois_right +translation_univ +transp_columnvector +transp_component +transp_diagonal_matrix +transp_eq +transp_injective +transp_mat +transp_matrix_add +transp_matrix_cmul +transp_matrix_inv +transp_matrix_neg +transp_matrix_sub +transp_transp +tree +tree-height +tree-member +tree-size +tree_rec +triangle +triangle_lemma +triangulation_simplex_faces +triangulation_subset +trichotomy +trivial +trivial_limit_at +trivial_limit_atpointof_within +trivial_limit_sequentially +trivial_limit_within true +try +tseitin +tube_lemma two +two_sided_limit_within +type +type-unique +typing +unabbrev_all_tac +unbounded_complement_component_convex +unbounded_convex_closed_contains_ray +unbounded_halfspace_component_ge +unbounded_halfspace_component_le +uncountable_interval +uncountable_open +under +undisch_tac +undisch_then unfold +unfold `gcd` +unfold `reverse` +unfolding +uniform_lim_bilinear +uniformly_continuous_extends_to_closure +uniformly_continuous_imp_continuous +uniformly_continuous_map_compose +uniformly_continuous_map_drop +uniformly_continuous_map_eq_lift +uniformly_continuous_map_euclidean +uniformly_continuous_map_lift +uniformly_continuous_map_lift_eq +uniformly_continuous_map_pastewise +uniformly_continuous_map_sqrt +uniformly_continuous_on_add +uniformly_continuous_on_closure +uniformly_continuous_on_cmul +uniformly_continuous_on_compose +uniformly_continuous_on_const +uniformly_continuous_on_eq +uniformly_continuous_on_neg +uniformly_continuous_on_sequentially +uniformly_continuous_on_sequentially_alt +uniformly_continuous_on_setdist +uniformly_continuous_on_subset +uniformly_convergent_eq_cauchy +union +union_aci +union_comm +union_empty +union_idempot +union_le_add_c +union_of +union_of_mono +union_over_inter +union_subset +union_univ +unionelim +unions +unions_components +unions_connected_component +unions_diff +unions_gspec +unions_image +unions_insert +unions_inters +unions_mono +unions_subset +unions_union +unit_interval_convex_hull +unit_interval_nonempty +unit_propagation +unitelim +univ +univ_gspec +univ_not_empty +univ_pcross_univ +univ_second_countable +univ_second_countable_sequence +univ_subset +universal +unsat +unsatisfiable +unwind_conv +update +upper_bound_finite_set +upper_lower_hemicontinuous_explicit +urysohn_local +urysohn_local_strong use +use add_assoc +use add_comm +use add_succ +use add_zero +use classical +use ih +use ih1 +use ih2 +use length_append +use list_append_assoc +use list_append_nil +use mul_succ +use mul_zero +use rev_append +use_then +uses using -we -with -x -declare -int -spdx -const -license -identifier -pmpl -later -logic -set -jewell -check -sat -file -for -echidna -example -jonathan -2026 -qf_lia -ephapax -proofs -status -claim -theorem -basic -universal -open -filecopyrighttext -2025 -tests -smt -lib -hyperpolymath -copyright +val +value +var +var_eq_tac variables -simple -linear -lean -fun -agda -all -proof -system -type -minimal -bitvec -function -monotonic -quantifiers -property -quantification -propositional -cnf -sort -typing -semantics -bruijn -arithmetic -memory -backend -integer -constraints -add -satisfiable -that -qf_bv -region -each -qf_nia -small -wff -bvxor -cons -exists -expected -pigeon -demonstrating -fundamental -project -team -logical -substitution -idr -level -xor -mit -stdlib -identity -demonstrates -qf_uf -coq -patterns -foundation -step -advanced -judgement -operational -safe -based -proves -formal -rules -management -includin -reduc -fusion -core -statu -syntax -first -syllogis -fof -classical -form -order -safety -socrates -modus_ponens -tptp -transitivity -less -than -prover -disp -dispatchcorrectness -group_left_identity -dyadic -binding -formalises -qualifiers -regions -compile -axiom -disjunction_elim -cleanly -disjunctio -prop -mvp -known -equality -trivial -double_negation -against -identitylaws -runner -symmetry_eq -echidnabot -exercise -sym -holes -hole +variance +variant vars -unsat -means -solution -some -p_i_h -instance -bvand -pigeons -pigeonhole -unsatisfiable -import -module -indexed -vertices -array -k_3 -colours -encoded -qf_ax -clauses -triangle +vec_component +vec_eq +vect +vector_add_ac +vector_add_assoc +vector_add_component +vector_add_ldistrib +vector_add_lid +vector_add_linv +vector_add_rdistrib +vector_add_rid +vector_add_rinv +vector_add_sub +vector_add_sym +vector_arith +vector_arith_tac +vector_choose_dist +vector_choose_size +vector_componentwise +vector_derivative_at +vector_derivative_unique_at +vector_derivative_unique_within +vector_derivative_works +vector_differentiable +vector_differentiable_bound +vector_eq +vector_eq_dot_span +vector_eq_ldot +vector_eq_rdot +vector_in_orthogonal_basis +vector_in_orthogonal_spanningset +vector_in_orthonormal_basis +vector_matrix_mul_transp +vector_mul_assoc +vector_mul_component +vector_mul_lcancel +vector_mul_lcancel_imp +vector_mul_lid +vector_mul_lneg +vector_mul_lzero +vector_mul_rcancel +vector_mul_rneg +vector_mul_rzero +vector_neg_component +vector_neg_neg +vector_neg_sub +vector_one +vector_sub +vector_sub_component +vector_sub_eq +vector_sub_ldistrib +vector_sub_lzero +vector_sub_rdistrib +vector_sub_refl +vector_sub_rzero +vector_variation_affinity +vector_variation_cmul +vector_variation_combine +vector_variation_comparison +vector_variation_compose_decreasing +vector_variation_compose_homeomorphism +vector_variation_compose_increasing +vector_variation_compose_increasing_gen +vector_variation_const_eq +vector_variation_continuous +vector_variation_eq +vector_variation_ge_drop_function +vector_variation_ge_norm_function +vector_variation_id +vector_variation_isometric +vector_variation_lipschitz +vector_variation_minus_function_monotone +vector_variation_monotone +vector_variation_neg +vector_variation_on_empty +vector_variation_on_interior +vector_variation_on_interval +vector_variation_on_null +vector_variation_pos_le +vector_variation_reflect +vector_variation_sing +vector_variation_split +vector_variation_translation +vector_variation_translation_alt +vector_variation_vmul +vectoraxiom +vectorize_add +vectorize_cmul +vectorize_component +vectorize_matrify +verification +verify vertex -store -clause -chain -colouring -select -contained -self +vertices very -constants -tiny -metamath -datatypes -bv0 -real -qf_nra -bvadd +vitali_covering_lemma_cballs_balls +vitali_covering_theorem_cballs +void +voidelim +vsum +vsum_add +vsum_cases +vsum_clauses +vsum_clauses_numseg +vsum_clauses_right +vsum_component +vsum_const +vsum_content_null +vsum_delete +vsum_diff +vsum_diff_lemma +vsum_diffs +vsum_diffs_alt +vsum_eq +vsum_eq_general +vsum_eq_general_inverses +vsum_eq_superset +vsum_image +vsum_image_nonzero +vsum_lmul +vsum_neg +vsum_norm +vsum_norm_allsubsets_bound +vsum_norm_le +vsum_offset +vsum_over_tagged_partial_division_lemma +vsum_pair +vsum_partial_suc +vsum_real +vsum_reflect +vsum_restrict_set +vsum_rmul +vsum_sing +vsum_sing_numseg +vsum_sub +vsum_sub_numseg +vsum_superset +vsum_support +vsum_swap +vsum_triv_numseg +vsum_union +vsum_vmul +vsum_vsum_product +water_usage = sum(z,t)(irrigate[z,t]) +we +weakening +wf_induct +wf_induct_tac +wf_rec +wff +wfinduction where -data -over -lemma -val -let -totality -natural +winduction +with +within_univ +within_within +witness `a` +witness `cons(tt, l)` +witness `factorial(n)+1` +wlog_le +wlog_linear_injective_image +wlog_lt +wlog_tac +wtype +x +x_choose_tac +x_choose_then +x_clauses +x_def +x_degenerate +x_gen_tac +x_increases_le +x_increases_lt +x_inj +xor +xy_are_solutions +xy_exp +xy_gcd_lemma +xy_power_neg +xy_power_pos +y_clauses +y_def +y_degenerate +y_divides_lemma +y_increases_lt +y_increases_suc +y_inj zero -impo -suc -countersatisfiable -uses -manipulation -number -principles -empty -populate -correct -add_comm -dir -under -intuitionistic -idris2 -elim -abs_nonneg -verify -source -mul_zero -basictotality -add_assoc -mulzero -fstar -mapp -dispatch -mnt -var -addcomm -terminates -stage -confidence -eclipse -rule -linearity -mul -axioms -preserves -executes -nonneg -kind_to_u8 -certs -transitions -lean4 -repos -pipeline -tracker -borrow -confidencelattice -sandbox -verification -then -axiomcompleteness -proverkindinjectivity -add_commutes -prevents -guard -invalid -else -addassoc -integrity -dispatchordering -strictly +zero_ae_derivative_imp_constant_gen diff --git a/scripts/extract_dafny.jl b/scripts/extract_dafny.jl index 5aa6eff..5537576 100644 --- a/scripts/extract_dafny.jl +++ b/scripts/extract_dafny.jl @@ -200,6 +200,64 @@ function generate_synthetic_dafny()::Vector{Dict{String,Any}} ("McCarthyNinetyOne", "function McCarthy91(n: int): int\n requires n >= 0\n ensures n > 100 ==> McCarthy91(n) == n - 10\n ensures n <= 100 ==> McCarthy91(n) == 91\n decreases 101 - n\n{\n if n > 100 then n - 10 else McCarthy91(McCarthy91(n + 11))\n}", ["requires", "ensures", "decreases"]), ] + map_lemmas = [ + ("MapPutGet", "method MapPutGet(m: map, k: K, v: V)\n ensures k in m[k := v]\n ensures m[k := v][k] == v\n{}", ["ensures"]), + ("MapRemoveAbsent", "lemma MapRemoveAbsent(m: map, k: K)\n requires k !in m\n ensures m - {k} == m\n{}", ["requires", "ensures"]), + ("MapDomainSubset", "lemma MapDomainSubset(m1: map, m2: map)\n requires forall k :: k in m1 ==> k in m2 && m1[k] == m2[k]\n ensures m1.Keys <= m2.Keys\n{}", ["requires", "ensures"]), + ("MapDisjointMerge", "lemma MapDisjointMerge(m1: map, m2: map)\n requires m1.Keys !! m2.Keys\n ensures |m1 + m2| == |m1| + |m2|\n{}", ["requires", "ensures"]), + ("MapKeysValues", "lemma MapKeysValues(m: map)\n ensures |m.Keys| == |m.Values|\n{}", ["ensures"]), + ("MapContainsAfterUpdate", "lemma MapContainsAfterUpdate(m: map, k: K, v: V, k': K)\n requires k' in m\n ensures k' in m[k := v]\n{}", ["requires", "ensures"]), + ("MapEmptyKeys", "lemma MapEmptyKeys()\n ensures (map[]: map).Keys == {}\n{}", ["ensures"]), + ("MapUpdateIdempotent", "lemma MapUpdateIdempotent(m: map, k: K, v: V)\n ensures m[k := v][k := v] == m[k := v]\n{}", ["ensures"]), + ] + + loop_invariants = [ + ("LinearSearch", "method LinearSearch(a: array, key: int) returns (idx: int)\n ensures 0 <= idx ==> idx < a.Length && a[idx] == key\n ensures idx < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{\n var i := 0;\n while i < a.Length\n invariant 0 <= i <= a.Length\n invariant forall j :: 0 <= j < i ==> a[j] != key\n {\n if a[i] == key { return i; }\n i := i + 1;\n }\n return -1;\n}", ["ensures", "invariant"]), + ("SumArray", "method SumArray(a: array) returns (s: int)\n ensures s == Sum(a[..], 0, a.Length)\n{\n s := 0;\n var i := 0;\n while i < a.Length\n invariant 0 <= i <= a.Length\n invariant s == Sum(a[..], 0, i)\n {\n s := s + a[i];\n i := i + 1;\n }\n}", ["ensures", "invariant"]), + ("MaxElement", "method MaxElement(a: array) returns (m: int)\n requires a.Length > 0\n ensures forall i :: 0 <= i < a.Length ==> a[i] <= m\n ensures exists i :: 0 <= i < a.Length && a[i] == m\n{\n m := a[0];\n var i := 1;\n while i < a.Length\n invariant 1 <= i <= a.Length\n invariant forall j :: 0 <= j < i ==> a[j] <= m\n invariant exists j :: 0 <= j < i && a[j] == m\n {\n if a[i] > m { m := a[i]; }\n i := i + 1;\n }\n}", ["requires", "ensures", "invariant"]), + ("CountOccurrences", "method CountOccurrences(a: array, key: int) returns (c: int)\n ensures c == |set i | 0 <= i < a.Length && a[i] == key|\n{\n c := 0;\n var i := 0;\n while i < a.Length\n invariant 0 <= i <= a.Length\n invariant c == |set j | 0 <= j < i && a[j] == key|\n {\n if a[i] == key { c := c + 1; }\n i := i + 1;\n }\n}", ["ensures", "invariant"]), + ("ReverseInPlace", "method ReverseInPlace(a: array)\n modifies a\n ensures forall i :: 0 <= i < a.Length ==> a[i] == old(a[a.Length - 1 - i])\n{\n var lo, hi := 0, a.Length - 1;\n while lo < hi\n invariant 0 <= lo && hi < a.Length\n invariant lo + hi == a.Length - 1\n invariant forall i :: 0 <= i < lo ==> a[i] == old(a[a.Length - 1 - i])\n invariant forall i :: hi < i < a.Length ==> a[i] == old(a[a.Length - 1 - i])\n invariant forall i :: lo <= i <= hi ==> a[i] == old(a[i])\n {\n a[lo], a[hi] := a[hi], a[lo];\n lo, hi := lo + 1, hi - 1;\n }\n}", ["modifies", "ensures", "invariant"]), + ("CopyArray", "method CopyArray(src: array) returns (dst: array)\n ensures dst.Length == src.Length\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n ensures fresh(dst)\n{\n dst := new int[src.Length];\n var i := 0;\n while i < src.Length\n invariant 0 <= i <= src.Length\n invariant forall j :: 0 <= j < i ==> dst[j] == src[j]\n {\n dst[i] := src[i];\n i := i + 1;\n }\n}", ["ensures", "invariant"]), + ("Partition", "method Partition(a: array, lo: int, hi: int) returns (p: int)\n requires 0 <= lo < hi <= a.Length\n modifies a\n ensures lo <= p < hi\n ensures forall i :: lo <= i < p ==> a[i] <= a[p]\n ensures forall i :: p < i < hi ==> a[i] > a[p]\n ensures multiset(a[lo..hi]) == multiset(old(a[lo..hi]))\n{}", ["requires", "modifies", "ensures"]), + ("TwoSum", "method TwoSum(a: array, target: int) returns (i: int, j: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= i < j < a.Length ==> a[i] + a[j] == target\n{\n i, j := 0, a.Length - 1;\n while i < j\n invariant 0 <= i && j < a.Length\n invariant forall p, q :: 0 <= p < i && i <= q < a.Length ==> a[p] + a[q] != target\n {\n if a[i] + a[j] == target { return; }\n else if a[i] + a[j] < target { i := i + 1; }\n else { j := j - 1; }\n }\n return -1, -1;\n}", ["requires", "ensures", "invariant"]), + ] + + inductive_proofs = [ + ("SumFormula", "lemma SumFormula(n: nat)\n ensures 2 * SumTo(n) == n * (n + 1)\n decreases n\n{\n if n == 0 { } else { SumFormula(n - 1); }\n}", ["ensures", "decreases"]), + ("PowerMonotone", "lemma PowerMonotone(b: nat, m: nat, n: nat)\n requires b >= 2 && m <= n\n ensures Pow(b, m) <= Pow(b, n)\n decreases n - m\n{\n if m == n { } else { PowerMonotone(b, m, n - 1); }\n}", ["requires", "ensures", "decreases"]), + ("ListFlatten", "lemma ListFlatten(l1: List, l2: List)\n ensures Length(Append(l1, l2)) == Length(l1) + Length(l2)\n decreases l1\n{\n match l1 { case Nil => case Cons(_, tl) => ListFlatten(tl, l2); }\n}", ["ensures", "decreases"]), + ("TreeHeight", "lemma TreeHeight(t: Tree)\n ensures Height(t) >= 0\n decreases t\n{\n match t {\n case Leaf => {}\n case Node(l, _, r) => { TreeHeight(l); TreeHeight(r); }\n }\n}", ["ensures", "decreases"]), + ("FibMonotone", "lemma FibMonotone(m: nat, n: nat)\n requires m <= n && m >= 1\n ensures Fib(m) <= Fib(n)\n decreases n - m\n{\n if m == n { } else { FibMonotone(m, n - 1); FibPositive(n - 2); }\n}", ["requires", "ensures", "decreases"]), + ("StrongInduction", "lemma StrongInduction(n: nat, P: nat -> bool)\n requires forall k: nat :: (forall j: nat :: j < k ==> P(j)) ==> P(k)\n ensures P(n)\n decreases n\n{\n forall j: nat | j < n ensures P(j) { StrongInduction(j, P); }\n}", ["requires", "ensures", "decreases"]), + ("BinomialTheorem", "lemma BinomialTheorem(x: int, y: int, n: nat)\n ensures Pow(x + y, n) == Sum(k => Choose(n, k) * Pow(x, n - k) * Pow(y, k), 0, n)\n decreases n\n{}", ["ensures", "decreases"]), + ] + + ghost_state = [ + ("GhostCounter", "method GhostCounter(n: nat) returns (r: nat)\n ensures r == n\n{\n r := 0;\n ghost var g := 0;\n while r < n\n invariant r == g && r <= n\n {\n r := r + 1;\n g := g + 1;\n }\n}", ["ensures", "invariant"]), + ("FrameCondition", "method FrameCondition(a: array, b: array, i: nat)\n requires a != b && i < a.Length\n modifies a\n ensures b[..] == old(b[..])\n ensures forall j :: 0 <= j < a.Length && j != i ==> a[j] == old(a[j])\n{\n a[i] := a[i] + 1;\n}", ["requires", "modifies", "ensures"]), + ("ReprValid", "class Node {\n var val: int\n var next: Node?\n ghost var repr: set\n predicate Valid()\n reads this, repr\n {\n this in repr &&\n (next != null ==> next in repr && next.repr < repr && next.Valid())\n }\n}", ["reads"]), + ("AllocFresh", "method AllocFresh() returns (r: array)\n ensures fresh(r)\n ensures r.Length == 10\n ensures forall i :: 0 <= i < 10 ==> r[i] == 0\n{\n r := new int[10];\n}", ["ensures"]), + ("GhostSequence", "method GhostSequence(a: array)\n modifies a\n ensures a[..] == Reverse(old(a[..]))\n{\n ghost var original := a[..];\n ReverseInPlace(a);\n}", ["modifies", "ensures"]), + ] + + type_refinement = [ + ("NonNullArray", "type NonNullArray = a: array | a.Length > 0 witness *", []), + ("PositiveInt", "type Positive = n: int | n > 0 witness 1", []), + ("BoundedInt", "type Bounded = n: int | 0 <= n < 256 witness 0", []), + ("EvenNat", "type EvenNat = n: nat | n % 2 == 0 witness 0", []), + ("SortedSeq", "type SortedSeq = s: seq | forall i, j :: 0 <= i < j < |s| ==> s[i] <= s[j] witness []", []), + ("NonEmptySeq", "type NonEmptySeq = s: seq | |s| > 0 witness *", []), + ("UniqueSeq", "type UniqueSeq = s: seq | forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] witness []", []), + ("Percentage", "type Percentage = r: real | 0.0 <= r <= 100.0 witness 0.0", []), + ] + + concurrency_specs = [ + ("MutexSpec", "class Mutex {\n ghost var locked: bool\n method Acquire()\n requires !locked\n modifies this\n ensures locked\n {\n locked := true;\n }\n method Release()\n requires locked\n modifies this\n ensures !locked\n {\n locked := false;\n }\n}", ["requires", "modifies", "ensures"]), + ("TokenRing", "method TokenRing(nodes: array, holder: nat)\n requires holder < nodes.Length\n requires nodes[holder] == true\n requires forall i :: 0 <= i < nodes.Length && i != holder ==> nodes[i] == false\n modifies nodes\n ensures nodes[(holder + 1) % nodes.Length] == true\n ensures forall i :: 0 <= i < nodes.Length && i != (holder + 1) % nodes.Length ==> nodes[i] == false\n{}", ["requires", "modifies", "ensures"]), + ("AtomicIncrement", "method AtomicIncrement(x: int) returns (y: int)\n ensures y == x + 1\n{\n y := x + 1;\n}", ["ensures"]), + ("CompareAndSwap", "method CAS(r: ref, expected: int, desired: int) returns (success: bool)\n modifies r\n ensures success ==> old(r.val) == expected && r.val == desired\n ensures !success ==> r.val == old(r.val)\n{}", ["modifies", "ensures"]), + ] + all_categories = [ ("arithmetic", arithmetic_lemmas), ("sequences", sequence_lemmas), @@ -207,6 +265,12 @@ function generate_synthetic_dafny()::Vector{Dict{String,Any}} ("sorting", sorting_search), ("data_structures", data_structures), ("termination", termination), + ("maps", map_lemmas), + ("loops", loop_invariants), + ("induction", inductive_proofs), + ("ghost", ghost_state), + ("types", type_refinement), + ("concurrency", concurrency_specs), ] proofs = Dict{String,Any}[] diff --git a/scripts/extract_fstar.jl b/scripts/extract_fstar.jl index 7f76af1..fb62db3 100644 --- a/scripts/extract_fstar.jl +++ b/scripts/extract_fstar.jl @@ -191,6 +191,134 @@ function generate_synthetic_fstar()::Vector{Dict{String,Any}} ("mutual_even", "val mutual_even: n:nat -> Tot bool (decreases n)\nval mutual_odd: n:nat -> Tot bool (decreases n)", "let rec mutual_even n = if n = 0 then true else mutual_odd (n - 1)\nand mutual_odd n = if n = 0 then false else mutual_even (n - 1)"), ] + sequences = [ + ("seq_append_length", "val seq_append_length: #a:Type -> s1:Seq.seq a -> s2:Seq.seq a -> Lemma (Seq.length (Seq.append s1 s2) == Seq.length s1 + Seq.length s2)", "let seq_append_length #a s1 s2 = Seq.lemma_len_append s1 s2"), + ("seq_slice_slice", "val seq_slice_slice: #a:Type -> s:Seq.seq a -> i:nat -> j:nat{i <= j} -> k:nat -> l:nat{k <= l /\\ l <= j - i} -> Lemma (Seq.slice (Seq.slice s i j) k l == Seq.slice s (i + k) (i + l))", "let seq_slice_slice #a s i j k l = Seq.lemma_slice_slice s i j k l"), + ("seq_create_index", "val seq_create_index: #a:Type -> n:nat -> v:a -> i:nat{i < n} -> Lemma (Seq.index (Seq.create n v) i == v)", "let seq_create_index #a n v i = ()"), + ("seq_upd_index", "val seq_upd_index: #a:Type -> s:Seq.seq a -> i:nat{i < Seq.length s} -> v:a -> j:nat{j < Seq.length s} -> Lemma (Seq.index (Seq.upd s i v) j == (if i = j then v else Seq.index s j))", "let seq_upd_index #a s i v j = ()"), + ("seq_equal_intro", "val seq_equal_intro: #a:Type -> s1:Seq.seq a -> s2:Seq.seq a -> Lemma (requires Seq.length s1 == Seq.length s2 /\\ (forall (i:nat{i < Seq.length s1}). Seq.index s1 i == Seq.index s2 i)) (ensures Seq.equal s1 s2)", "let seq_equal_intro #a s1 s2 = Seq.lemma_eq_intro s1 s2"), + ("seq_mem_append", "val seq_mem_append: #a:eqtype -> x:a -> s1:Seq.seq a -> s2:Seq.seq a -> Lemma (Seq.mem x (Seq.append s1 s2) <==> Seq.mem x s1 || Seq.mem x s2)", "let seq_mem_append #a x s1 s2 = Seq.lemma_mem_append s1 s2"), + ("seq_count_append", "val seq_count_append: #a:eqtype -> x:a -> s1:Seq.seq a -> s2:Seq.seq a -> Lemma (Seq.count x (Seq.append s1 s2) == Seq.count x s1 + Seq.count x s2)", "let seq_count_append #a x s1 s2 = Seq.lemma_count_append x s1 s2"), + ("seq_sort_permutation", "val seq_sort_permutation: #a:eqtype -> f:(a -> a -> Tot int) -> s:Seq.seq a -> Lemma (ensures Seq.permutation a (Seq.sortWith f s) s)", "let seq_sort_permutation #a f s = Seq.lemma_sortWith_permutation f s"), + ("seq_unsnoc", "val seq_unsnoc: #a:Type -> s:Seq.seq a{Seq.length s > 0} -> Tot (Seq.seq a & a)", "let seq_unsnoc #a s = Seq.un_snoc s"), + ("seq_cons_head_tail", "val seq_cons_head_tail: #a:Type -> s:Seq.seq a{Seq.length s > 0} -> Lemma (Seq.cons (Seq.head s) (Seq.tail s) == s)", "let seq_cons_head_tail #a s = Seq.lemma_cons_head_tail s"), + ("seq_map_seq", "val seq_map_seq: #a:Type -> #b:Type -> f:(a -> Tot b) -> s:Seq.seq a -> i:nat{i < Seq.length s} -> Lemma (Seq.index (Seq.map_seq f s) i == f (Seq.index s i))", "let seq_map_seq #a #b f s i = Seq.map_seq_index f s i"), + ("seq_init_index", "val seq_init_index: #a:Type -> n:nat -> f:(i:nat{i < n} -> Tot a) -> i:nat{i < n} -> Lemma (Seq.index (Seq.init n f) i == f i)", "let seq_init_index #a n f i = Seq.init_index n f i"), + ] + + buffers = [ + ("buffer_live", "val buffer_live: #a:Type -> h:HS.mem -> b:B.buffer a -> Lemma (requires B.live h b) (ensures B.length b >= 0 /\\ B.live h b)", "let buffer_live #a h b = ()"), + ("buffer_read_write", "val buffer_read_write: #a:Type -> b:B.buffer a -> i:UInt32.t{UInt32.v i < B.length b} -> v:a -> h0:HS.mem -> Lemma (requires B.live h0 b) (ensures (let h1 = B.g_upd b (UInt32.v i) v h0 in B.get h1 b (UInt32.v i) == v))", "let buffer_read_write #a b i v h0 = ()"), + ("buffer_modifies_only", "val buffer_modifies_only: #a:Type -> b:B.buffer a -> h0:HS.mem -> h1:HS.mem -> Lemma (requires B.modifies (B.loc_buffer b) h0 h1) (ensures B.modifies (B.loc_buffer b) h0 h1)", "let buffer_modifies_only #a b h0 h1 = ()"), + ("buffer_disjoint", "val buffer_disjoint: #a:Type -> #b:Type -> b1:B.buffer a -> b2:B.buffer b -> h0:HS.mem -> h1:HS.mem -> v:a -> Lemma (requires B.live h0 b1 /\\ B.live h0 b2 /\\ B.disjoint b1 b2 /\\ B.modifies (B.loc_buffer b1) h0 h1) (ensures B.as_seq h1 b2 == B.as_seq h0 b2)", "let buffer_disjoint #a #b b1 b2 h0 h1 v = B.modifies_buffer_elim b2 (B.loc_buffer b1) h0 h1"), + ("buffer_as_seq_gsub", "val buffer_as_seq_gsub: #a:Type -> b:B.buffer a -> i:UInt32.t -> len:UInt32.t{UInt32.v i + UInt32.v len <= B.length b} -> h:HS.mem -> Lemma (requires B.live h b) (ensures B.as_seq h (B.gsub b i len) == Seq.slice (B.as_seq h b) (UInt32.v i) (UInt32.v i + UInt32.v len))", "let buffer_as_seq_gsub #a b i len h = ()"), + ("buffer_concat", "val buffer_concat: #a:Type -> b1:B.buffer a -> b2:B.buffer a -> h:HS.mem -> Lemma (requires B.live h b1 /\\ B.live h b2 /\\ B.disjoint b1 b2) (ensures B.length b1 + B.length b2 >= 0)", "let buffer_concat #a b1 b2 h = ()"), + ("stack_alloc_free", "val stack_alloc_free: unit -> ST unit (requires fun h -> True) (ensures fun h0 _ h1 -> modifies Set.empty h0 h1)", "let stack_alloc_free () = push_frame (); let b = B.alloca 0uy 16ul in let _ = b.(0ul) in pop_frame ()"), + ("buffer_frame", "val buffer_frame: #a:Type -> #b:Type -> buf:B.buffer a -> other:B.buffer b -> h0:HS.mem -> h1:HS.mem -> Lemma (requires B.live h0 buf /\\ B.live h0 other /\\ B.disjoint buf other /\\ B.modifies (B.loc_buffer other) h0 h1) (ensures B.as_seq h0 buf == B.as_seq h1 buf /\\ B.live h1 buf)", "let buffer_frame #a #b buf other h0 h1 = B.modifies_buffer_elim buf (B.loc_buffer other) h0 h1"), + ("buffer_loc_disjoint", "val buffer_loc_disjoint: #a:Type -> #b:Type -> b1:B.buffer a -> b2:B.buffer b -> Lemma (requires B.disjoint b1 b2) (ensures B.loc_disjoint (B.loc_buffer b1) (B.loc_buffer b2))", "let buffer_loc_disjoint #a #b b1 b2 = B.loc_disjoint_buffer b1 b2"), + ("buffer_length_gsub", "val buffer_length_gsub: #a:Type -> b:B.buffer a -> i:UInt32.t -> len:UInt32.t{UInt32.v i + UInt32.v len <= B.length b} -> Lemma (B.length (B.gsub b i len) == UInt32.v len)", "let buffer_length_gsub #a b i len = ()"), + ] + + monotonic_state = [ + ("witnessed_stable", "val witnessed_stable: #a:Type -> #rel:Preorder.preorder a -> r:mref a rel -> p:(a -> Type0){stable p rel} -> h:HS.mem -> Lemma (requires p (HS.sel h r)) (ensures witnessed r p)", "let witnessed_stable #a #rel r p h = gst_witness r p"), + ("recall_witnessed", "val recall_witnessed: #a:Type -> #rel:Preorder.preorder a -> r:mref a rel -> p:(a -> Type0){stable p rel} -> ST unit (requires fun h -> witnessed r p) (ensures fun h0 _ h1 -> h0 == h1 /\\ p (HS.sel h1 r))", "let recall_witnessed #a #rel r p = gst_recall r p"), + ("gst_witness", "val gst_witness: #a:Type -> #rel:Preorder.preorder a -> r:mref a rel -> p:(a -> Type0){stable p rel} -> ST unit (requires fun h -> p (HS.sel h r)) (ensures fun h0 _ h1 -> h0 == h1 /\\ witnessed r p)", "let gst_witness #a #rel r p = witness_p r p"), + ("stable_predicate", "val stable_predicate: #a:Type -> #rel:Preorder.preorder a -> p:(a -> Type0) -> Lemma (requires forall (x y : a). p x /\\ rel x y ==> p y) (ensures stable p rel)", "let stable_predicate #a #rel p = ()"), + ("monotonic_ref_read", "val monotonic_ref_read: #a:Type -> #rel:Preorder.preorder a -> r:mref a rel -> ST a (requires fun h -> True) (ensures fun h0 v h1 -> h0 == h1 /\\ v == HS.sel h1 r)", "let monotonic_ref_read #a #rel r = !r"), + ("monotonic_ref_write", "val monotonic_ref_write: #a:Type -> #rel:Preorder.preorder a -> r:mref a rel -> v:a -> ST unit (requires fun h -> rel (HS.sel h r) v) (ensures fun h0 _ h1 -> HS.sel h1 r == v /\\ modifies (Set.singleton (HS.frameOf r)) h0 h1)", "let monotonic_ref_write #a #rel r v = r := v"), + ("token_fresh", "val token_fresh: #a:Type -> #rel:Preorder.preorder a -> r:mref a rel -> h:HS.mem -> Lemma (requires HS.contains h r) (ensures HS.frameOf r `HS.is_in` HS.get_hmap h)", "let token_fresh #a #rel r h = ()"), + ("region_contains", "val region_contains: #a:Type -> #rel:Preorder.preorder a -> r:mref a rel -> h:HS.mem -> Lemma (requires HS.contains h r) (ensures HS.live_region h (HS.frameOf r))", "let region_contains #a #rel r h = ()"), + ] + + tactics = [ + ("norm_spec", "val norm_spec: a:nat -> b:nat -> Lemma (normalize_term (a + 0) == a)", "let norm_spec a b = assert (normalize_term (a + 0) == a) by (let _ = norm [delta; zeta; primops] in trefl ())"), + ("canon_semiring", "val canon_semiring: a:int -> b:int -> c:int -> Lemma (a * (b + c) == a * b + a * c)", "let canon_semiring a b c = assert (a * (b + c) == a * b + a * c) by (canon_semiring_int ())"), + ("trefl_lemma", "val trefl_lemma: a:int -> Lemma (a == a)", "let trefl_lemma a = assert (a == a) by trefl ()"), + ("mapply_lemma", "val mapply_lemma: a:int -> b:int -> Lemma (requires a == b) (ensures a + 0 == b)", "let mapply_lemma a b = assert (a + 0 == b) by (mapply (`FStar.Math.Lemmas.add_zero_r); assumption ())"), + ("smt_lemma", "val smt_lemma: a:nat -> b:nat -> Lemma (a + b >= a)", "let smt_lemma a b = assert (a + b >= a) by smt ()"), + ("pointwise_lemma", "val pointwise_lemma: a:int -> b:int -> c:int -> Lemma ((a + b) + c == a + (b + c))", "let pointwise_lemma a b c = assert ((a + b) + c == a + (b + c)) by (pointwise (fun () -> trefl ()); trefl ())"), + ("grewrite_lemma", "val grewrite_lemma: a:int -> b:int -> Lemma (requires a == b) (ensures a + 1 == b + 1)", "let grewrite_lemma a b = assert (a + 1 == b + 1) by (grewrite (quote a) (quote b); assumption (); trefl ())"), + ("tadmit_placeholder", "val tadmit_placeholder: a:int -> b:int -> Lemma (a * b == b * a)", "let tadmit_placeholder a b = assert (a * b == b * a) by tadmit ()"), + ] + + dependent_types = [ + ("vector_head", "val vector_head: #a:Type -> #n:nat{n > 0} -> v:vector a (n + 1) -> Tot a", "let vector_head #a #n v = Seq.index v 0"), + ("vector_cons_snoc", "val vector_cons_snoc: #a:Type -> #n:nat -> x:a -> v:vector a n -> Lemma (length (cons x v) == n + 1 /\\ head (cons x v) == x)", "let vector_cons_snoc #a #n x v = ()"), + ("matrix_mult_assoc", "val matrix_mult_assoc: #m:nat -> #n:nat -> #p:nat -> #q:nat -> a:matrix m n -> b:matrix n p -> c:matrix p q -> Lemma (mat_mult (mat_mult a b) c == mat_mult a (mat_mult b c))", ""), + ("sized_list_append", "val sized_list_append: #a:Type -> #m:nat -> #n:nat -> l1:sized_list a m -> l2:sized_list a n -> Tot (sized_list a (m + n))", "let rec sized_list_append #a #m #n l1 l2 = match l1 with | SNil -> l2 | SCons x xs -> SCons x (sized_list_append xs l2)"), + ("bounded_nat_add", "val bounded_nat_add: #bound:nat -> a:bounded_nat bound -> b:bounded_nat bound{a + b <= bound} -> Tot (bounded_nat bound)", "let bounded_nat_add #bound a b = a + b"), + ("indexed_sum", "val indexed_sum: #n:nat -> f:(i:nat{i < n} -> Tot nat) -> Tot nat (decreases n)", "let rec indexed_sum #n f = if n = 0 then 0 else f (n - 1) + indexed_sum #(n - 1) (fun i -> f i)"), + ("heterogeneous_list", "val heterogeneous_list: ts:list Type -> Type", "let rec heterogeneous_list ts = match ts with | [] -> unit | t :: rest -> t & heterogeneous_list rest"), + ("witness_exists", "val witness_exists: #a:Type -> #p:(a -> Type0) -> x:a -> pf:p x -> Tot (dtuple2 a p)", "let witness_exists #a #p x pf = (| x, pf |)"), + ("refinement_subtyping", "val refinement_subtyping: x:nat{x > 5} -> Tot (y:int{y > 0})", "let refinement_subtyping x = x"), + ("coercion_lemma", "val coercion_lemma: #a:Type -> #p:(a -> Type0) -> #q:(a -> Type0) -> x:a{p x} -> Lemma (requires forall (y:a). p y ==> q y) (ensures q x)", "let coercion_lemma #a #p #q x = ()"), + ] + + machine_integers = [ + ("u8_add_mod", "val u8_add_mod: a:UInt8.t -> b:UInt8.t -> Lemma (UInt8.v (UInt8.add_mod a b) == (UInt8.v a + UInt8.v b) % 256)", "let u8_add_mod a b = ()"), + ("u32_shift_left", "val u32_shift_left: a:UInt32.t -> s:UInt32.t{UInt32.v s < 32} -> Lemma (UInt32.v (UInt32.shift_left a s) == (UInt32.v a * pow2 (UInt32.v s)) % pow2 32)", ""), + ("u64_logand_comm", "val u64_logand_comm: a:UInt64.t -> b:UInt64.t -> Lemma (UInt64.logand a b == UInt64.logand b a)", "let u64_logand_comm a b = UInt64.logand_commutative a b"), + ("i32_add_overflow", "val i32_add_overflow: a:Int32.t -> b:Int32.t -> Lemma (requires Int32.v a + Int32.v b < pow2 31 /\\ Int32.v a + Int32.v b >= -(pow2 31)) (ensures Int32.v (Int32.add a b) == Int32.v a + Int32.v b)", ""), + ("cast_u8_u32", "val cast_u8_u32: a:UInt8.t -> Lemma (UInt32.v (FStar.Int.Cast.uint8_to_uint32 a) == UInt8.v a)", ""), + ("u32_sub_mod", "val u32_sub_mod: a:UInt32.t -> b:UInt32.t -> Lemma (UInt32.v (UInt32.sub_mod a b) == (UInt32.v a - UInt32.v b) % pow2 32)", ""), + ("bytes_of_u32", "val bytes_of_u32: n:UInt32.t -> Lemma (ensures length (uint32_to_bytes n) == 4)", ""), + ("u16_max_bound", "val u16_max_bound: a:UInt16.t -> Lemma (UInt16.v a < 65536)", "let u16_max_bound a = ()"), + ] + + parser_combinators = [ + ("parser_ret", "val parser_ret: #a:Type -> v:a -> parser a", "let parser_ret #a v = fun input -> Some (v, input)"), + ("parser_bind", "val parser_bind: #a:Type -> #b:Type -> p:parser a -> f:(a -> parser b) -> parser b", "let parser_bind #a #b p f = fun input -> match p input with | None -> None | Some (v, rest) -> f v rest"), + ("parser_map", "val parser_map: #a:Type -> #b:Type -> f:(a -> b) -> p:parser a -> parser b", "let parser_map #a #b f p = parser_bind p (fun v -> parser_ret (f v))"), + ("parser_alt", "val parser_alt: #a:Type -> p1:parser a -> p2:parser a -> parser a", "let parser_alt #a p1 p2 = fun input -> match p1 input with | Some r -> Some r | None -> p2 input"), + ("parser_many", "val parser_many: #a:Type -> p:parser a -> parser (list a)", "let rec parser_many #a p = parser_alt (parser_bind p (fun v -> parser_bind (parser_many p) (fun vs -> parser_ret (v :: vs)))) (parser_ret [])"), + ("parser_char", "val parser_char: c:char -> parser char", "let parser_char c = fun input -> if Seq.length input > 0 && Seq.index input 0 = c then Some (c, Seq.slice input 1 (Seq.length input)) else None"), + ("parser_digit", "val parser_digit: parser nat", "let parser_digit = parser_bind (parser_satisfy is_digit) (fun c -> parser_ret (char_to_nat c))"), + ("parser_satisfy", "val parser_satisfy: (char -> bool) -> parser char", "let parser_satisfy f = fun input -> if Seq.length input > 0 && f (Seq.index input 0) then Some (Seq.index input 0, Seq.slice input 1 (Seq.length input)) else None"), + ] + + state_machine = [ + ("sm_transition", "val sm_transition: st:state -> ev:event -> Tot state", "let sm_transition st ev = match st, ev with | Init, Start -> Running | Running, Stop -> Done | s, _ -> s"), + ("sm_invariant", "val sm_invariant: st:state -> Tot bool", "let sm_invariant st = st <> Error"), + ("sm_step_preserves", "val sm_step_preserves: st:state -> ev:event -> Lemma (requires sm_invariant st) (ensures sm_invariant (sm_transition st ev))", "let sm_step_preserves st ev = ()"), + ("sm_reachable", "val sm_reachable: events:list event -> Tot state (decreases events)", "let rec sm_reachable events = match events with | [] -> Init | e :: es -> sm_transition (sm_reachable es) e"), + ("sm_trace_valid", "val sm_trace_valid: events:list event -> Lemma (ensures sm_invariant (sm_reachable events)) (decreases events)", "let rec sm_trace_valid events = match events with | [] -> () | e :: es -> sm_trace_valid es; sm_step_preserves (sm_reachable es) e"), + ("sm_deadlock_free", "val sm_deadlock_free: st:state -> Lemma (requires st <> Done) (ensures exists (ev:event). sm_transition st ev <> st)", ""), + ] + + protocol_verification = [ + ("handshake_complete", "val handshake_complete: c:client -> s:server -> Lemma (requires valid_hello c /\\ valid_hello s) (ensures handshake_result c s == Success)", ""), + ("message_integrity", "val message_integrity: k:key -> m:msg -> Lemma (ensures verify k m (mac k m) == true)", "let message_integrity k m = ()"), + ("nonce_fresh", "val nonce_fresh: n:nonce -> log:list nonce -> Lemma (requires not (mem n log)) (ensures fresh n log)", "let nonce_fresh n log = ()"), + ("session_key_derive", "val session_key_derive: psk:key -> c_rand:bytes -> s_rand:bytes -> Lemma (ensures length (derive psk c_rand s_rand) == 32)", ""), + ("replay_protection", "val replay_protection: n:nonce -> log:list nonce -> Lemma (requires mem n log) (ensures reject n log)", "let replay_protection n log = ()"), + ("forward_secrecy", "val forward_secrecy: sk:key -> pk:key -> Lemma (requires ephemeral sk) (ensures not (recoverable sk pk))", ""), + ] + + arrays_matrices = [ + ("array_swap", "val array_swap: #a:Type -> b:buffer a -> i:nat -> j:nat -> ST unit (requires fun h -> live h b /\\ i < length b /\\ j < length b) (ensures fun h0 _ h1 -> modifies (loc_buffer b) h0 h1 /\\ get h1 b i == get h0 b j /\\ get h1 b j == get h0 b i)", ""), + ("array_fill", "val array_fill: b:buffer UInt8.t -> v:UInt8.t -> ST unit (requires fun h -> live h b) (ensures fun h0 _ h1 -> modifies (loc_buffer b) h0 h1 /\\ (forall (i:nat). i < length b ==> get h1 b i == v))", ""), + ("matrix_index", "val matrix_index: #n:nat -> #m:nat -> mx:matrix n m -> i:nat{i < n} -> j:nat{j < m} -> Tot elem", "let matrix_index #n #m mx i j = Seq.index (Seq.index mx i) j"), + ("matrix_transpose", "val matrix_transpose: #n:nat -> #m:nat -> mx:matrix n m -> Tot (matrix m n)", ""), + ("dot_product", "val dot_product: #n:nat -> v1:vector n -> v2:vector n -> Tot int", "let dot_product #n v1 v2 = fold_left (+) 0 (map2 ( * ) v1 v2)"), + ("array_sum_nonneg", "val array_sum_nonneg: b:buffer nat -> Lemma (requires forall (i:nat). i < length b ==> get h b i >= 0) (ensures array_sum b >= 0)", ""), + ] + + monad_laws = [ + ("option_left_id", "val option_left_id: #a:Type -> #b:Type -> x:a -> f:(a -> option b) -> Lemma (bind (Some x) f == f x)", "let option_left_id #a #b x f = ()"), + ("option_right_id", "val option_right_id: #a:Type -> x:option a -> Lemma (bind x Some == x)", "let option_right_id #a x = match x with | None -> () | Some _ -> ()"), + ("option_assoc", "val option_assoc: #a:Type -> #b:Type -> #c:Type -> x:option a -> f:(a -> option b) -> g:(b -> option c) -> Lemma (bind (bind x f) g == bind x (fun y -> bind (f y) g))", "let option_assoc #a #b #c x f g = match x with | None -> () | Some _ -> ()"), + ("either_left_id", "val either_left_id: #e:Type -> #a:Type -> #b:Type -> x:a -> f:(a -> either e b) -> Lemma (either_bind (Right x) f == f x)", "let either_left_id #e #a #b x f = ()"), + ("either_right_id", "val either_right_id: #e:Type -> #a:Type -> x:either e a -> Lemma (either_bind x Right == x)", "let either_right_id #e #a x = match x with | Left _ -> () | Right _ -> ()"), + ("state_left_id", "val state_left_id: #s:Type -> #a:Type -> #b:Type -> x:a -> f:(a -> state s b) -> Lemma (state_bind (state_return x) f == f x)", "let state_left_id #s #a #b x f = ()"), + ] + + string_processing = [ + ("string_length_append", "val string_length_append: s1:string -> s2:string -> Lemma (String.length (s1 ^ s2) == String.length s1 + String.length s2)", ""), + ("string_sub_valid", "val string_sub_valid: s:string -> i:nat -> j:nat -> Lemma (requires i <= j /\\ j <= String.length s) (ensures String.length (String.sub s i j) == j - i)", ""), + ("utf8_encode_decode", "val utf8_encode_decode: s:string -> Lemma (utf8_decode (utf8_encode s) == Some s)", ""), + ("split_join", "val split_join: s:string -> sep:string -> Lemma (requires String.length sep > 0) (ensures String.concat sep (String.split sep s) == s)", ""), + ] + all_categories = [ ("arithmetic", arithmetic), ("lists", lists), @@ -198,6 +326,18 @@ function generate_synthetic_fstar()::Vector{Dict{String,Any}} ("effects", effects_and_state), ("refinement", refinement_types), ("termination", termination), + ("sequences", sequences), + ("buffers", buffers), + ("monotonic_state", monotonic_state), + ("tactics", tactics), + ("dependent_types", dependent_types), + ("machine_integers", machine_integers), + ("parser_combinators", parser_combinators), + ("state_machine", state_machine), + ("protocol", protocol_verification), + ("arrays_matrices", arrays_matrices), + ("monad_laws", monad_laws), + ("string_processing", string_processing), ] proofs = Dict{String,Any}[] diff --git a/scripts/extract_idris2.jl b/scripts/extract_idris2.jl index 7fd9304..fe36f95 100644 --- a/scripts/extract_idris2.jl +++ b/scripts/extract_idris2.jl @@ -197,6 +197,123 @@ function generate_synthetic_idris2()::Vector{Dict{String,Any}} ("monadAssoc", "monadAssoc : Monad m => (ma : m a) -> (f : a -> m b) -> (g : b -> m c) -> ((ma >>= f) >>= g) = (ma >>= (\\x => f x >>= g))", ""), ] + maybe_proofs = [ + ("maybeMap", "maybeMap : (f : a -> b) -> Maybe a -> Maybe b", "maybeMap f Nothing = Nothing\nmaybeMap f (Just x) = Just (f x)"), + ("maybeMapCompose", "maybeMapCompose : (f : b -> c) -> (g : a -> b) -> (mx : Maybe a) -> maybeMap f (maybeMap g mx) = maybeMap (f . g) mx", "maybeMapCompose f g Nothing = Refl\nmaybeMapCompose f g (Just x) = Refl"), + ("maybeBind", "maybeBind : Maybe a -> (a -> Maybe b) -> Maybe b", "maybeBind Nothing f = Nothing\nmaybeBind (Just x) f = f x"), + ("maybeBindAssoc", "maybeBindAssoc : (mx : Maybe a) -> (f : a -> Maybe b) -> (g : b -> Maybe c) -> maybeBind (maybeBind mx f) g = maybeBind mx (\\x => maybeBind (f x) g)", "maybeBindAssoc Nothing f g = Refl\nmaybeBindAssoc (Just x) f g = Refl"), + ("isJustFromJust", "isJustFromJust : (mx : Maybe a) -> isJust mx = True -> DPair a (\\x => mx = Just x)", "isJustFromJust (Just x) Refl = (x ** Refl)\nisJustFromJust Nothing Refl impossible"), + ("nothingAbsurd", "nothingAbsurd : the (Maybe a) Nothing = Just x -> Void", "nothingAbsurd Refl impossible"), + ("maybeToList", "maybeToList : Maybe a -> List a", "maybeToList Nothing = []\nmaybeToList (Just x) = [x]"), + ("fromMaybeDefault", "fromMaybeDefault : (def : a) -> (mx : Maybe a) -> mx = Nothing -> fromMaybe def mx = def", "fromMaybeDefault def Nothing Refl = Refl\nfromMaybeDefault def (Just _) Refl impossible"), + ] + + either_proofs = [ + ("eitherMap", "eitherMap : (f : a -> c) -> (g : b -> d) -> Either a b -> Either c d", "eitherMap f g (Left x) = Left (f x)\neitherMap f g (Right y) = Right (g y)"), + ("eitherMapCompose", "eitherMapCompose : (f1 : c -> e) -> (f2 : a -> c) -> (g1 : d -> f) -> (g2 : b -> d) -> (e : Either a b) -> eitherMap f1 g1 (eitherMap f2 g2 e) = eitherMap (f1 . f2) (g1 . g2) e", "eitherMapCompose f1 f2 g1 g2 (Left x) = Refl\neitherMapCompose f1 f2 g1 g2 (Right y) = Refl"), + ("eitherBimap", "eitherBimap : (f : a -> c) -> (g : b -> d) -> Either a b -> Either c d", "eitherBimap f g (Left x) = Left (f x)\neitherBimap f g (Right y) = Right (g y)"), + ("eitherSwap", "eitherSwap : Either a b -> Either b a", "eitherSwap (Left x) = Right x\neitherSwap (Right y) = Left y"), + ("eitherAssoc", "eitherAssoc : Either (Either a b) c -> Either a (Either b c)", "eitherAssoc (Left (Left x)) = Left x\neitherAssoc (Left (Right y)) = Right (Left y)\neitherAssoc (Right z) = Right (Right z)"), + ("partitionEithers", "partitionEithers : List (Either a b) -> (List a, List b)", "partitionEithers [] = ([], [])\npartitionEithers (Left x :: xs) = let (ls, rs) = partitionEithers xs in (x :: ls, rs)\npartitionEithers (Right y :: xs) = let (ls, rs) = partitionEithers xs in (ls, y :: rs)"), + ("leftsAppend", "leftsAppend : (xs, ys : List (Either a b)) -> fst (partitionEithers (xs ++ ys)) = fst (partitionEithers xs) ++ fst (partitionEithers ys)", ""), + ("rightsAppend", "rightsAppend : (xs, ys : List (Either a b)) -> snd (partitionEithers (xs ++ ys)) = snd (partitionEithers xs) ++ snd (partitionEithers ys)", ""), + ] + + nat_order = [ + ("lteRefl", "lteRefl : (n : Nat) -> LTE n n", "lteRefl Z = LTEZero\nlteRefl (S k) = LTESucc (lteRefl k)"), + ("lteAntisym", "lteAntisym : LTE m n -> LTE n m -> m = n", "lteAntisym LTEZero LTEZero = Refl\nlteAntisym (LTESucc p) (LTESucc q) = cong S (lteAntisym p q)"), + ("lteTrans", "lteTrans : LTE l c -> LTE c r -> LTE l r", "lteTrans LTEZero _ = LTEZero\nlteTrans (LTESucc p) (LTESucc q) = LTESucc (lteTrans p q)"), + ("lteSuccRight", "lteSuccRight : LTE m n -> LTE m (S n)", "lteSuccRight LTEZero = LTEZero\nlteSuccRight (LTESucc p) = LTESucc (lteSuccRight p)"), + ("lteAddRight", "lteAddRight : (m : Nat) -> (n : Nat) -> LTE m (m + n)", "lteAddRight Z n = LTEZero\nlteAddRight (S k) n = LTESucc (lteAddRight k n)"), + ("notLteToGt", "notLteToGt : Not (LTE m n) -> LT n m", "notLteToGt {m = Z} contra = absurd (contra LTEZero)\nnotLteToGt {m = S k} {n = Z} _ = LTESucc LTEZero\nnotLteToGt {m = S k} {n = S j} contra = LTESucc (notLteToGt (\\p => contra (LTESucc p)))"), + ("ltToLte", "ltToLte : LT m n -> LTE m n", "ltToLte (LTESucc p) = lteSuccRight p"), + ("maxComm", "maxComm : (m, n : Nat) -> max m n = max n m", ""), + ] + + stream_proofs = [ + ("takeLength", "takeLength : (n : Nat) -> (s : Stream a) -> length (take n s) = n", "takeLength Z s = Refl\ntakeLength (S k) (x :: xs) = cong S (takeLength k xs)"), + ("iterateHead", "iterateHead : (f : a -> a) -> (x : a) -> head (iterate f x) = x", "iterateHead f x = Refl"), + ("repeatHead", "repeatHead : (x : a) -> head (repeat x) = x", "repeatHead x = Refl"), + ("cycleNonEmpty", "cycleNonEmpty : (xs : List a) -> NonEmpty xs -> Stream a", "cycleNonEmpty (x :: xs) IsNonEmpty = cycle (x :: xs)"), + ("zipWithLength", "zipWithLength : (f : a -> b -> c) -> (n : Nat) -> (s1 : Stream a) -> (s2 : Stream b) -> length (take n (zipWith f s1 s2)) = n", "zipWithLength f Z s1 s2 = Refl\nzipWithLength f (S k) (x :: xs) (y :: ys) = cong S (zipWithLength f k xs ys)"), + ("mapStream", "mapStream : (f : a -> b) -> (n : Nat) -> (s : Stream a) -> take n (map f s) = map f (take n s)", "mapStream f Z s = Refl\nmapStream f (S k) (x :: xs) = cong (f x ::) (mapStream f k xs)"), + ] + + universe_proofs = [ + ("voidAbsurd", "voidAbsurd : Void -> a", "voidAbsurd v = absurd v"), + ("unitUnique", "unitUnique : (x, y : ()) -> x = y", "unitUnique () () = Refl"), + ("boolDec", "boolDec : (b : Bool) -> Dec (b = True)", "boolDec True = Yes Refl\nboolDec False = No absurd"), + ("notNotBool", "notNotBool : (b : Bool) -> not (not b) = b", "notNotBool True = Refl\nnotNotBool False = Refl"), + ("decElim", "decElim : (a -> b) -> (Not a -> b) -> Dec a -> b", "decElim f g (Yes prf) = f prf\ndecElim f g (No contra) = g contra"), + ("eitherCommIso", "eitherCommIso : Either a b -> Either b a", "eitherCommIso (Left x) = Right x\neitherCommIso (Right y) = Left y"), + ] + + type_level = [ + ("lengthReplicate", "lengthReplicate : (n : Nat) -> (x : a) -> length (replicate n x) = n", "lengthReplicate Z x = Refl\nlengthReplicate (S k) x = cong S (lengthReplicate k x)"), + ("transposeInvolutive", "transposeInvolutive : (xss : Vect m (Vect n a)) -> transpose (transpose xss) = xss", ""), + ("diagonalZip", "diagonalZip : (xs : Vect n a) -> map (\\i => index i xs) range = xs", ""), + ("tabulateIndex", "tabulateIndex : (f : Fin n -> a) -> (i : Fin n) -> index i (tabulate f) = f i", "tabulateIndex f FZ = Refl\ntabulateIndex f (FS k) = tabulateIndex (f . FS) k"), + ("generateLength", "generateLength : (n : Nat) -> (f : Fin n -> a) -> length (toList (tabulate f)) = n", ""), + ("concatMapLength", "concatMapLength : (f : a -> Vect m b) -> (xs : Vect n a) -> length (concat (map f xs)) = n * m", "concatMapLength f [] = Refl\nconcatMapLength f (x :: xs) = rewrite concatMapLength f xs in vectAppendLength (f x) (concat (map f xs))"), + ("intersperse", "intersperse : a -> Vect n a -> Vect (n + pred n) a", "intersperse sep [] = []\nintersperse sep [x] = [x]\nintersperse sep (x :: y :: ys) = x :: sep :: intersperse sep (y :: ys)"), + ("chunksOfLength", "chunksOfLength : (k : Nat) -> {auto ok : NonZero k} -> (xs : Vect n a) -> length (chunksOf k xs) = divCeilNZ n k ok", ""), + ] + + bool_proofs = [ + ("andCommutative", "andCommutative : (a, b : Bool) -> a && b = b && a", "andCommutative True True = Refl\nandCommutative True False = Refl\nandCommutative False True = Refl\nandCommutative False False = Refl"), + ("orCommutative", "orCommutative : (a, b : Bool) -> a || b = b || a", "orCommutative True True = Refl\norCommutative True False = Refl\norCommutative False True = Refl\norCommutative False False = Refl"), + ("andAssociative", "andAssociative : (a, b, c : Bool) -> (a && b) && c = a && (b && c)", "andAssociative True b c = Refl\nandAssociative False b c = Refl"), + ("orAssociative", "orAssociative : (a, b, c : Bool) -> (a || b) || c = a || (b || c)", "orAssociative True b c = Refl\norAssociative False b c = Refl"), + ("andTrueNeutral", "andTrueNeutral : (a : Bool) -> a && True = a", "andTrueNeutral True = Refl\nandTrueNeutral False = Refl"), + ("orFalseNeutral", "orFalseNeutral : (a : Bool) -> a || False = a", "orFalseNeutral True = Refl\norFalseNeutral False = Refl"), + ("notInvolutive", "notInvolutive : (a : Bool) -> not (not a) = a", "notInvolutive True = Refl\nnotInvolutive False = Refl"), + ("deMorganAnd", "deMorganAnd : (a, b : Bool) -> not (a && b) = not a || not b", "deMorganAnd True True = Refl\ndeMorganAnd True False = Refl\ndeMorganAnd False True = Refl\ndeMorganAnd False False = Refl"), + ] + + pair_proofs = [ + ("pairEta", "pairEta : (p : (a, b)) -> p = (fst p, snd p)", "pairEta (x, y) = Refl"), + ("mapFstId", "mapFstId : (p : (a, b)) -> mapFst id p = p", "mapFstId (x, y) = Refl"), + ("mapSndId", "mapSndId : (p : (a, b)) -> mapSnd id p = p", "mapSndId (x, y) = Refl"), + ("bimap_id", "bimap_id : (p : (a, b)) -> bimap id id p = p", "bimap_id (x, y) = Refl"), + ("swapSwap", "swapSwap : (p : (a, b)) -> swap (swap p) = p", "swapSwap (x, y) = Refl"), + ("mapFstCompose", "mapFstCompose : (f : b -> c) -> (g : a -> b) -> (p : (a, d)) -> mapFst f (mapFst g p) = mapFst (f . g) p", "mapFstCompose f g (x, y) = Refl"), + ] + + snoclist_proofs = [ + ("snocListAppend", "snocListAppend : (xs : SnocList a) -> (ys : SnocList a) -> length (xs ++ ys) = length xs + length ys", ""), + ("snocListReverse", "snocListReverse : (xs : SnocList a) -> cast (reverse (reverse xs)) = xs", ""), + ("snocListMap", "snocListMap : (f : a -> b) -> (xs : SnocList a) -> length (map f xs) = length xs", ""), + ("snocNil", "snocNil : (xs : SnocList a) -> xs ++ [<] = xs", ""), + ("snocCast", "snocCast : (xs : List a) -> cast (cast xs : SnocList a) = xs", ""), + ] + + proof_search = [ + ("autoRefl", "autoRefl : {auto prf : x = x} -> x = x", "autoRefl {prf} = prf"), + ("autoLTE", "autoLTE : {auto prf : LTE n m} -> LTE n m", "autoLTE {prf} = prf"), + ("decideEq", "decideEq : DecEq a => (x, y : a) -> Either (x = y) (Not (x = y))", "decideEq x y = case decEq x y of { Yes prf => Left prf; No contra => Right contra }"), + ("searchNat", "searchNat : (n : Nat ** LTE 10 n, LTE n 20)", "searchNat = (15 ** (LTESucc (LTESucc (LTESucc (LTESucc (LTESucc (LTESucc (LTESucc (LTESucc (LTESucc (LTESucc LTEZero))))))))), LTESucc (LTESucc (LTESucc (LTESucc (LTESucc LTEZero))))))"), + ("autoShow", "autoShow : Show a => a -> String", "autoShow x = show x"), + ] + + with_views = [ + ("filterView", "filterView : (p : a -> Bool) -> (xs : List a) -> List a", "filterView p [] = []\nfilterView p (x :: xs) with (p x)\n _ | True = x :: filterView p xs\n _ | False = filterView p xs"), + ("lookupView", "lookupView : DecEq k => k -> List (k, v) -> Maybe v", "lookupView key [] = Nothing\nlookupView key ((k, v) :: xs) with (decEq key k)\n _ | Yes _ = Just v\n _ | No _ = lookupView key xs"), + ("insertSorted", "insertSorted : Ord a => a -> List a -> List a", "insertSorted x [] = [x]\ninsertSorted x (y :: ys) with (compare x y)\n _ | LT = x :: y :: ys\n _ | EQ = x :: y :: ys\n _ | GT = y :: insertSorted x ys"), + ("splitAt", "splitAt : (n : Nat) -> (xs : Vect (n + m) a) -> (Vect n a, Vect m a)", "splitAt Z xs = ([], xs)\nsplitAt (S k) (x :: xs) = let (ys, zs) = splitAt k xs in (x :: ys, zs)"), + ("mergeView", "mergeView : Ord a => List a -> List a -> List a", "mergeView [] ys = ys\nmergeView xs [] = xs\nmergeView (x :: xs) (y :: ys) with (compare x y)\n _ | LT = x :: mergeView xs (y :: ys)\n _ | _ = y :: mergeView (x :: xs) ys"), + ("groupByView", "groupByView : (a -> a -> Bool) -> List a -> List (List a)", ""), + ] + + cong_rewrite = [ + ("congSucc", "congSucc : n = m -> S n = S m", "congSucc Refl = Refl"), + ("congPlus", "congPlus : a = b -> c = d -> a + c = b + d", "congPlus Refl Refl = Refl"), + ("congMap", "congMap : (f : a -> b) -> x = y -> f x = f y", "congMap f Refl = Refl"), + ("transEq", "transEq : a = b -> b = c -> a = c", "transEq Refl Refl = Refl"), + ("symEq", "symEq : a = b -> b = a", "symEq Refl = Refl"), + ("replaceEq", "replaceEq : (0 p : a -> Type) -> x = y -> p x -> p y", "replaceEq p Refl px = px"), + ("voidAbsurd2", "voidAbsurd2 : Void -> a", "voidAbsurd2 v = absurd v"), + ] + all_categories = [ ("equality", equality_proofs), ("decidable", decidable), @@ -206,6 +323,18 @@ function generate_synthetic_idris2()::Vector{Dict{String,Any}} ("linear", linear_types), ("dpair", dependent_pairs), ("interfaces", interfaces), + ("maybe", maybe_proofs), + ("either", either_proofs), + ("nat_order", nat_order), + ("streams", stream_proofs), + ("universe", universe_proofs), + ("type_level", type_level), + ("bool", bool_proofs), + ("pairs", pair_proofs), + ("snoclist", snoclist_proofs), + ("proof_search", proof_search), + ("with_views", with_views), + ("cong_rewrite", cong_rewrite), ] proofs = Dict{String,Any}[] diff --git a/scripts/extract_minizinc.jl b/scripts/extract_minizinc.jl index 2f76fce..1551efa 100644 --- a/scripts/extract_minizinc.jl +++ b/scripts/extract_minizinc.jl @@ -280,11 +280,336 @@ function generate_synthetic_constraint_models()::Vector{Dict{String,Any}} "total_cost = sum(i,j)(flow[i,j] * cost[i,j])"]), ] + timetabling = [ + ("university_timetable", "satisfy", + ["var 1..num_slots: schedule[1..num_courses]"], + ["forall(c in courses)(schedule[c] in available[c])", + "forall(c1 in courses, c2 in courses where c1 < c2 /\\ shared_students[c1,c2] > 0)(schedule[c1] != schedule[c2])", + "forall(r in rooms, s in slots)(sum(c in courses where schedule[c] = s /\\ room[c] = r)(1) <= 1)", + "forall(t in teachers)(alldifferent([schedule[c] | c in courses where teacher[c] = t]))"]), + ("exam_scheduling", "minimize num_slots_used", + ["var 1..max_slots: exam_slot[1..num_exams]", "var 0..1: slot_used[1..max_slots]"], + ["forall(e1,e2 in exams where conflict[e1,e2])(exam_slot[e1] != exam_slot[e2])", + "forall(s in 1..max_slots)(slot_used[s] = (exists(e in exams)(exam_slot[e] = s)))", + "num_slots_used = sum(s in 1..max_slots)(slot_used[s])"]), + ("sports_league", "satisfy", + ["var 1..num_rounds: round[1..num_matches]", "var teams: home[1..num_matches]", "var teams: away[1..num_matches]"], + ["forall(m in matches)(home[m] != away[m])", + "forall(t in teams)(sum(m in matches)(home[m] = t \\/ away[m] = t) = num_rounds)", + "forall(r in rounds)(alldifferent([home[m] | m in matches where round[m] = r] ++ [away[m] | m in matches where round[m] = r]))"]), + ("crew_scheduling", "minimize total_crew_cost", + ["var 0..1: assign[1..num_crew, 1..num_flights]"], + ["forall(f in flights)(sum(c in crew)(assign[c,f]) >= min_crew[f])", + "forall(c in crew)(sum(f in flights)(assign[c,f] * duration[f]) <= max_hours)", + "total_crew_cost = sum(c in crew, f in flights)(assign[c,f] * cost[c,f])"]), + ("room_assignment", "minimize max_distance", + ["var 1..num_rooms: assign[1..num_people]"], + ["alldifferent(assign)", + "forall(p in people)(capacity[assign[p]] >= needs[p])", + "max_distance = max(p1,p2 in people where collaborate[p1,p2])(distance[assign[p1], assign[p2]])"]), + ("conference_schedule", "satisfy", + ["var 1..num_sessions: talk_session[1..num_talks]", "var 1..num_tracks: talk_track[1..num_talks]"], + ["forall(s in sessions, t in tracks)(sum(k in talks where talk_session[k] = s /\\ talk_track[k] = t)(1) <= 1)", + "forall(k1,k2 in talks where same_speaker[k1,k2])(talk_session[k1] != talk_session[k2])", + "forall(k in talks)(talk_track[k] in preferred_tracks[k])"]), + ] + + network = [ + ("shortest_path", "minimize path_cost", + ["var 0..1: use_edge[1..num_edges]"], + ["forall(v in 2..n-1)(sum(e in in_edges[v])(use_edge[e]) = sum(e in out_edges[v])(use_edge[e]))", + "sum(e in out_edges[source])(use_edge[e]) - sum(e in in_edges[source])(use_edge[e]) = 1", + "path_cost = sum(e in edges)(use_edge[e] * weight[e])"]), + ("load_balancing", "minimize max_load", + ["var 1..num_servers: assign[1..num_tasks]"], + ["forall(s in servers)(sum(t in tasks where assign[t] = s)(demand[t]) <= server_capacity[s])", + "max_load = max(s in servers)(sum(t in tasks where assign[t] = s)(demand[t]))"]), + ("wavelength_assignment", "minimize num_wavelengths", + ["var 1..max_wl: wavelength[1..num_paths]"], + ["forall(e in edges, p1,p2 in paths where p1 < p2 /\\ uses_edge[p1,e] /\\ uses_edge[p2,e])(wavelength[p1] != wavelength[p2])", + "num_wavelengths = max(wavelength)"]), + ("bandwidth_alloc", "maximize total_throughput", + ["var 0.0..max_rate: rate[1..num_flows]"], + ["forall(e in edges)(sum(f in flows where uses_edge[f,e])(rate[f]) <= capacity[e])", + "total_throughput = sum(f in flows)(rate[f])"]), + ("vlan_assignment", "minimize num_vlans", + ["var 1..max_vlan: vlan[1..num_hosts]"], + ["forall(h1,h2 in hosts where must_separate[h1,h2])(vlan[h1] != vlan[h2])", + "forall(h1,h2 in hosts where must_communicate[h1,h2])(vlan[h1] = vlan[h2])", + "num_vlans = max(vlan)"]), + ] + + logistics = [ + ("warehouse_location", "minimize total_cost", + ["var 0..1: open_wh[1..num_warehouses]", "var 0..1: serve[1..num_warehouses, 1..num_customers]"], + ["forall(c in customers)(sum(w in warehouses)(serve[w,c]) = 1)", + "forall(w in warehouses, c in customers)(serve[w,c] <= open_wh[w])", + "total_cost = sum(w)(open_wh[w]*fixed_cost[w]) + sum(w,c)(serve[w,c]*transport[w,c])"]), + ("fleet_routing", "minimize total_distance", + ["var 0..num_customers: next[0..num_customers]"], + ["subcircuit(next)", + "forall(v in vehicles)(cumulative_load[v] <= vehicle_cap)", + "total_distance = sum(i in 0..num_customers)(dist[i, next[i]])"]), + ("inventory_optimization", "minimize total_holding + total_ordering", + ["var 0..max_order: order[1..num_periods]", "var 0..max_inv: inventory[1..num_periods]"], + ["forall(t in periods)(inventory[t] = inventory[t-1] + order[t] - demand[t])", + "forall(t in periods)(inventory[t] >= safety_stock)", + "total_holding = sum(t)(inventory[t]*hold_cost)", + "total_ordering = sum(t)(if order[t] > 0 then setup_cost + order[t]*unit_cost else 0 endif)"]), + ("supply_chain", "minimize total_supply_cost", + ["var 0..max_ship: ship[1..num_plants, 1..num_warehouses]", "var 0..max_ship: deliver[1..num_warehouses, 1..num_retailers]"], + ["forall(r in retailers)(sum(w in warehouses)(deliver[w,r]) >= demand[r])", + "forall(w in warehouses)(sum(p in plants)(ship[p,w]) >= sum(r in retailers)(deliver[w,r]))", + "forall(p in plants)(sum(w in warehouses)(ship[p,w]) <= capacity[p])", + "total_supply_cost = sum(p,w)(ship[p,w]*cost_pw[p,w]) + sum(w,r)(deliver[w,r]*cost_wr[w,r])"]), + ("cold_chain", "satisfy", + ["var 0..max_time: depart[1..num_stops]", "var vehicles: truck[1..num_stops]"], + ["forall(s in stops)(depart[s] + service[s] + travel[s, next[s]] <= depart[next[s]])", + "forall(s in stops)(depart[s] + max_cold_time >= depart[next[s]])", + "forall(v in vehicles)(sum(s in stops where truck[s] = v)(demand[s]) <= truck_cap)"]), + ] + + puzzle = [ + ("cryptarithmetic", "satisfy", + ["var 0..9: letter[1..num_letters]"], + ["alldifferent(letter)", + "letter[leading1] > 0 /\\ letter[leading2] > 0", + "sum(i in 1..len1)(letter[word1[i]] * pow10[len1-i]) + sum(i in 1..len2)(letter[word2[i]] * pow10[len2-i]) = sum(i in 1..len3)(letter[word3[i]] * pow10[len3-i])"]), + ("kakuro", "satisfy", + ["var 1..9: cell[1..num_cells]"], + ["forall(g in groups)(alldifferent([cell[c] | c in group_cells[g]]))", + "forall(g in groups)(sum(c in group_cells[g])(cell[c]) = clue[g])"]), + ("nonogram", "satisfy", + ["var 0..1: grid[1..rows, 1..cols]"], + ["forall(r in 1..rows)(check_runs(grid[r,..], row_clues[r]))", + "forall(c in 1..cols)(check_runs(grid[..,c], col_clues[c]))"]), + ("kenken", "satisfy", + ["var 1..n: grid[1..n, 1..n]"], + ["forall(r in 1..n)(alldifferent(grid[r, ..]))", + "forall(c in 1..n)(alldifferent(grid[.., c]))", + "forall(g in groups)(cage_constraint(grid, g, op[g], target[g]))"]), + ("futoshiki", "satisfy", + ["var 1..n: grid[1..n, 1..n]"], + ["forall(r in 1..n)(alldifferent(grid[r, ..]))", + "forall(c in 1..n)(alldifferent(grid[.., c]))", + "forall((r1,c1,r2,c2) in inequalities)(grid[r1,c1] < grid[r2,c2])"]), + ("hidato", "satisfy", + ["var 1..n*m: cell[1..n, 1..m]"], + ["alldifferent(array1d(cell))", + "forall(v in 1..n*m-1)(exists(r1,c1,r2,c2 in positions where adjacent(r1,c1,r2,c2))(cell[r1,c1] = v /\\ cell[r2,c2] = v+1))"]), + ] + + production = [ + ("lot_sizing", "minimize total_production_cost", + ["var 0..max_prod: produce[1..num_periods]", "var 0..1: setup[1..num_periods]"], + ["forall(t in periods)(produce[t] <= big_M * setup[t])", + "forall(t in periods)(inventory[t] = inventory[t-1] + produce[t] - demand[t])", + "forall(t in periods)(inventory[t] >= 0)", + "total_production_cost = sum(t)(setup[t]*setup_cost + produce[t]*prod_cost + inventory[t]*hold_cost)"]), + ("assembly_line", "minimize cycle_time", + ["var 1..num_stations: station[1..num_tasks]"], + ["forall((i,j) in precedences)(station[i] <= station[j])", + "forall(s in stations)(sum(t in tasks where station[t] = s)(proc_time[t]) <= cycle_time)", + "cycle_time >= max(s in stations)(sum(t in tasks where station[t] = s)(proc_time[t]))"]), + ("workforce_planning", "minimize total_labor_cost", + ["var 0..max_workers: hire[1..num_periods]", "var 0..max_workers: fire[1..num_periods]", "var 0..max_workers: workforce[1..num_periods]"], + ["forall(t in periods)(workforce[t] = workforce[t-1] + hire[t] - fire[t])", + "forall(t in periods)(workforce[t] >= min_demand[t])", + "total_labor_cost = sum(t)(hire[t]*hire_cost + fire[t]*fire_cost + workforce[t]*wage)"]), + ("preventive_maintenance", "minimize total_downtime", + ["var 0..1: maintain[1..num_machines, 1..num_periods]"], + ["forall(m in machines)(sum(t in periods)(maintain[m,t]) >= min_maintenance[m])", + "forall(t in periods)(sum(m in machines)(maintain[m,t]) <= max_simultaneous)", + "total_downtime = sum(m,t)(maintain[m,t] * downtime[m])"]), + ("yield_optimization", "maximize total_yield", + ["var 0.0..1.0: mix[1..num_ingredients]"], + ["sum(mix) = 1.0", + "forall(p in properties)(sum(i in ingredients)(mix[i] * prop_value[i,p]) >= min_prop[p])", + "forall(p in properties)(sum(i in ingredients)(mix[i] * prop_value[i,p]) <= max_prop[p])", + "total_yield = sum(i in ingredients)(mix[i] * yield_rate[i])"]), + ] + + energy = [ + ("power_grid_dispatch", "minimize total_generation_cost", + ["var 0.0..max_gen: output[1..num_generators]"], + ["sum(g in generators)(output[g]) >= total_demand", + "forall(g in generators)(output[g] >= min_output[g] \\/ output[g] = 0)", + "forall(g in generators)(output[g] <= max_output[g])", + "total_generation_cost = sum(g)(output[g] * cost_per_mw[g])"]), + ("battery_scheduling", "minimize electricity_cost", + ["var -max_rate..max_rate: charge[1..num_periods]", "var 0.0..capacity: soc[1..num_periods]"], + ["forall(t in periods)(soc[t] = soc[t-1] + charge[t] * efficiency)", + "forall(t in periods)(soc[t] >= min_soc /\\ soc[t] <= max_soc)", + "electricity_cost = sum(t)(max(0, demand[t] + charge[t]) * price[t])"]), + ("ev_charging", "minimize total_wait", + ["var 1..num_chargers: assign_charger[1..num_vehicles]", "var 0..horizon: start_charge[1..num_vehicles]"], + ["forall(c in chargers, t in periods)(sum(v in vehicles where assign_charger[v]=c /\\ start_charge[v]<=t /\\ t= arrival[v])", + "total_wait = sum(v)(start_charge[v] - arrival[v])"]), + ("solar_panel_layout", "maximize total_output", + ["var 0..1: place[1..num_positions]"], + ["sum(place) <= max_panels", + "forall(p1,p2 in positions where p1= 0)", + "total_tardiness = sum(s)(max(0, surgery_start[s]+duration[s]-deadline[s]))"]), + ("patient_bed_assignment", "minimize total_transfer", + ["var 1..num_wards: bed_ward[1..num_patients]"], + ["forall(w in wards)(sum(p in patients where bed_ward[p]=w)(1) <= ward_capacity[w])", + "forall(p in patients)(bed_ward[p] in compatible_wards[p])", + "total_transfer = sum(p)(if bed_ward[p] != preferred_ward[p] then 1 else 0 endif)"]), + ("ambulance_dispatch", "minimize max_response_time", + ["var 1..num_stations: base[1..num_ambulances]"], + ["forall(z in zones)(sum(a in ambulances where travel_time[base[a],z] <= max_allowed)(1) >= coverage_req[z])", + "forall(s in stations)(sum(a in ambulances where base[a]=s)(1) <= station_cap[s])", + "max_response_time = max(z in zones)(min(a in ambulances)(travel_time[base[a],z]))"]), + ("nurse_rostering", "minimize preference_violations", + ["var shifts: roster[1..num_nurses, 1..num_days]"], + ["forall(d in days, s in shifts)(sum(n in nurses where roster[n,d]=s)(1) >= demand[d,s])", + "forall(n in nurses, d in 1..num_days-1)(not(roster[n,d]=night /\\ roster[n,d+1]=morning))", + "forall(n in nurses)(sum(d in days where roster[n,d]!=off)(1) <= max_shifts_per_nurse)", + "preference_violations = sum(n,d)(if roster[n,d] != preferred[n,d] then 1 else 0 endif)"]), + ("equipment_maintenance", "minimize total_downtime", + ["var 1..num_slots: maintain_slot[1..num_machines]"], + ["forall(t in slots)(sum(m where maintain_slot[m]=t)(1) <= max_simultaneous)", + "forall(m in machines)(maintain_slot[m] >= earliest_maint[m])", + "total_downtime = sum(m)(downtime_cost[m])"]), + ] + + education = [ + ("student_grouping", "minimize group_imbalance", + ["var 1..num_groups: group[1..num_students]"], + ["forall(g in groups)(sum(s where group[s]=g)(1) >= min_group_size)", + "forall(g in groups)(sum(s where group[s]=g)(1) <= max_group_size)", + "group_imbalance = max(g1,g2 in groups)(abs(sum(s where group[s]=g1)(1) - sum(s where group[s]=g2)(1)))"]), + ("classroom_assignment", "satisfy", + ["var 1..num_rooms: room[1..num_classes]"], + ["forall(c in classes)(capacity[room[c]] >= class_size[c])", + "forall(t in timeslots)(alldifferent([room[c] | c where timeslot[c]=t]))", + "forall(c in classes)(room[c] in compatible_rooms[c])"]), + ("curriculum_sequencing", "minimize total_penalty", + ["var 1..num_semesters: semester[1..num_courses]"], + ["forall((c1,c2) in prerequisites)(semester[c1] < semester[c2])", + "forall(s in semesters)(sum(c where semester[c]=s)(credits[c]) <= max_credits)", + "total_penalty = sum(c)(abs(semester[c] - ideal_semester[c]))"]), + ("lab_rotation", "satisfy", + ["var 1..num_labs: lab_assign[1..num_students, 1..num_rotations]"], + ["forall(s in students)(alldifferent(lab_assign[s, ..]))", + "forall(r in rotations, l in labs)(sum(s where lab_assign[s,r]=l)(1) <= lab_capacity[l])"]), + ("project_team", "maximize team_diversity", + ["var 1..num_teams: team[1..num_students]"], + ["forall(t in teams)(sum(s where team[s]=t)(1) >= 3 /\\ sum(s where team[s]=t)(1) <= 5)", + "forall(s1,s2 where conflict[s1,s2])(team[s1] != team[s2])", + "team_diversity = min(t in teams)(card({skill[s] | s where team[s]=t}))"]), + ] + + telecommunications = [ + ("cell_tower_placement", "minimize num_towers", + ["var 0..1: build[1..num_candidate_sites]"], + ["forall(c in customers)(sum(s in sites where covers(s,c))(build[s]) >= 1)", + "num_towers = sum(build)"]), + ("frequency_assignment", "minimize max_frequency", + ["var 1..max_freq: freq[1..num_towers]"], + ["forall(t1,t2 in towers where interferes(t1,t2))(abs(freq[t1]-freq[t2]) >= min_gap)", + "max_frequency = max(freq)"]), + ("network_slicing", "maximize total_throughput", + ["var 0..max_bw: bandwidth[1..num_slices, 1..num_links]"], + ["forall(l in links)(sum(s in slices)(bandwidth[s,l]) <= link_capacity[l])", + "forall(s in slices)(sum(l in paths[s])(bandwidth[s,l]) >= min_bw[s])", + "total_throughput = sum(s)(sum(l)(bandwidth[s,l]) * priority[s])"]), + ("data_center_cooling", "minimize cooling_cost", + ["var 1..num_racks: server_rack[1..num_servers]"], + ["forall(r in racks)(sum(s where server_rack[s]=r)(heat[s]) <= max_heat[r])", + "forall(r in racks)(sum(s where server_rack[s]=r)(1) <= rack_slots[r])", + "cooling_cost = sum(r)(cooling_rate[r] * sum(s where server_rack[s]=r)(heat[s]))"]), + ("spectrum_allocation", "maximize total_utility", + ["var 0..1: allocate[1..num_users, 1..num_channels]"], + ["forall(c in channels)(sum(u in users)(allocate[u,c]) <= 1)", + "forall(u1,u2 in users where u1= min_moisture[z])", + "forall(t in periods)(sum(z)(irrigate[z,t]) <= pump_capacity)", + "water_usage = sum(z,t)(irrigate[z,t])"]), + ("harvest_planning", "minimize total_loss", + ["var 1..num_days: harvest_day[1..num_plots]"], + ["forall(d in days)(sum(p where harvest_day[p]=d)(area[p]) <= daily_capacity)", + "total_loss = sum(p)(if harvest_day[p] > optimal_day[p] then (harvest_day[p]-optimal_day[p])*loss_rate[p] else 0 endif)"]), + ("fertilizer_mix", "minimize fertilizer_cost", + ["var 0.0..max_amount: amount[1..num_fertilizers]"], + ["forall(n in nutrients)(sum(f)(amount[f]*nutrient_content[f,n]) >= min_nutrient[n])", + "forall(n in nutrients)(sum(f)(amount[f]*nutrient_content[f,n]) <= max_nutrient[n])", + "fertilizer_cost = sum(f)(amount[f]*price[f])"]), + ("greenhouse_climate", "minimize energy_cost", + ["var 0..max_heat: heating[1..num_periods]", "var 0..max_vent: ventilation[1..num_periods]"], + ["forall(t in periods)(temperature[t] >= min_temp /\\ temperature[t] <= max_temp)", + "forall(t in periods)(humidity[t] >= min_humid /\\ humidity[t] <= max_humid)", + "energy_cost = sum(t)(heating[t]*heat_price + ventilation[t]*vent_price)"]), + ] + + manufacturing = [ + ("tool_magazine", "minimize tool_changes", + ["var 0..1: loaded[1..num_tools, 1..num_jobs]"], + ["forall(j in jobs, t in required_tools[j])(loaded[t,j] = 1)", + "forall(j in jobs)(sum(t in tools)(loaded[t,j]) <= magazine_capacity)", + "tool_changes = sum(j in 2..num_jobs, t in tools)(abs(loaded[t,j]-loaded[t,j-1]))"]), + ("pcb_assembly", "minimize cycle_time", + ["var 1..num_feeders: feeder[1..num_components]", "var 1..num_nozzles: nozzle[1..num_components]"], + ["forall(c in components)(feeder[c] in compatible_feeders[c])", + "forall(c in components)(nozzle[c] in compatible_nozzles[c])", + "cycle_time = max(placement_time)"]), + ("steel_cutting", "minimize waste", + ["var 0..max_cuts: cut[1..num_patterns]"], + ["forall(w in widths)(sum(p)(pattern[p,w]*cut[p]) >= demand[w])", + "waste = sum(p)(cut[p]*waste_per_pattern[p])"]), + ("batch_mixing", "satisfy", + ["var 0.0..max_batch: batch_size[1..num_batches]", "var 0.0..1.0: proportion[1..num_batches, 1..num_ingredients]"], + ["forall(b in batches)(sum(i)(proportion[b,i]) = 1.0)", + "forall(b in batches, p in properties)(sum(i)(proportion[b,i]*prop_val[i,p]) >= min_spec[p])", + "forall(b in batches, p in properties)(sum(i)(proportion[b,i]*prop_val[i,p]) <= max_spec[p])"]), + ("quality_inspection", "minimize inspection_cost", + ["var 0..1: inspect[1..num_stations, 1..num_products]"], + ["forall(p in products)(sum(s)(inspect[s,p]) >= min_inspections[p])", + "forall(s in stations)(sum(p)(inspect[s,p]*inspect_time[s]) <= station_time_budget[s])", + "inspection_cost = sum(s,p)(inspect[s,p]*cost_per_inspection[s])"]), + ] + all_categories = [ ("scheduling", scheduling), ("packing_routing", packing_routing), ("combinatorial", combinatorial), ("optimization", optimization), + ("timetabling", timetabling), + ("network", network), + ("logistics", logistics), + ("puzzle", puzzle), + ("production", production), + ("energy", energy), + ("healthcare", healthcare), + ("education", education), + ("telecommunications", telecommunications), + ("agriculture", agriculture), + ("manufacturing", manufacturing), ] proofs = Dict{String,Any}[] diff --git a/src/julia/run_training.jl b/src/julia/run_training.jl index 93c8f54..7c38652 100644 --- a/src/julia/run_training.jl +++ b/src/julia/run_training.jl @@ -10,14 +10,6 @@ # data_dir = training_data/ # save_dir = models/neural/ # -# Environment overrides (see below): -# ECHIDNA_MAX_PROOF_STATES — cap on proof states loaded (default 200000 on -# GPU, 50000 on CPU). Set to 0 to disable the cap and consume the entire -# expanded corpus; required when re-baselining after corpus growth. -# ECHIDNA_NUM_EPOCHS — training epochs (default 30). -# ECHIDNA_NUM_NEGATIVES — hard-negative premise samples per example -# (default 20). -# # This script: # 1. Loads JSONL training data (proof states + premises) # 2. Builds vocabulary from the corpus @@ -82,24 +74,10 @@ println("═══════════════════════ println("Loading training data...") println("═══════════════════════════════════════════════════════════") -# Default cap: 200k on GPU (enough to exercise the expanded corpus without -# OOM on a 24GB card), 50k on CPU (keeps wall-clock finite). An operator -# re-baselining after corpus growth sets ECHIDNA_MAX_PROOF_STATES=0 to lift -# the cap entirely. -default_cap = has_gpu ? 200_000 : 50_000 -cap_env = get(ENV, "ECHIDNA_MAX_PROOF_STATES", "") -max_proof_states = isempty(cap_env) ? default_cap : parse(Int, cap_env) -# `load_training_data` treats any value `<= 0` as "load everything". -cap_label = max_proof_states <= 0 ? "unlimited" : string(max_proof_states) -println(" max_proof_states = $cap_label") - -num_negatives = parse(Int, get(ENV, "ECHIDNA_NUM_NEGATIVES", "20")) -println(" num_negatives = $num_negatives") - train_data, val_data, vocab = load_training_data(data_dir; train_split=0.8f0, - max_proof_states=max_proof_states, - num_negatives=num_negatives, + max_proof_states=50000, # Cap for reasonable training time + num_negatives=20 ) if isempty(train_data.examples) @@ -123,9 +101,8 @@ println("Model created successfully") println() # Configure training -num_epochs = parse(Int, get(ENV, "ECHIDNA_NUM_EPOCHS", "30")) training_config = TrainingConfig( - num_epochs=num_epochs, + num_epochs=30, learning_rate=1f-4, lr_schedule=:cosine, weight_decay=1f-5, diff --git a/src/rust/agent/actors.rs b/src/rust/agent/actors.rs index 7005082..44e358c 100644 --- a/src/rust/agent/actors.rs +++ b/src/rust/agent/actors.rs @@ -248,28 +248,32 @@ fn collect_lemma_candidates(term: &Term, out: &mut Vec, cap: usize) { if !out.contains(name) { out.push(name.clone()); } - } + }, Term::App { func, args } => { collect_lemma_candidates(func, out, cap); for a in args { collect_lemma_candidates(a, out, cap); } - } - Term::Pi { param_type, body, .. } => { + }, + Term::Pi { + param_type, body, .. + } => { collect_lemma_candidates(param_type, out, cap); collect_lemma_candidates(body, out, cap); - } - Term::Lambda { param_type, body, .. } => { + }, + Term::Lambda { + param_type, body, .. + } => { if let Some(pt) = param_type { collect_lemma_candidates(pt, out, cap); } collect_lemma_candidates(body, out, cap); - } + }, Term::Let { value, body, .. } => { collect_lemma_candidates(value, out, cap); collect_lemma_candidates(body, out, cap); - } - _ => {} + }, + _ => {}, } } diff --git a/src/rust/agent/explanations.rs b/src/rust/agent/explanations.rs index e3f17a8..c5181c7 100644 --- a/src/rust/agent/explanations.rs +++ b/src/rust/agent/explanations.rs @@ -301,18 +301,6 @@ impl ExplanationGenerator { self.format_term(body) ) }, - Term::Sigma { - param, - param_type, - body, - } => { - format!( - "∃{}:{}. {}", - param, - self.format_term(param_type), - self.format_term(body) - ) - }, Term::App { func, args } => { let args_str: Vec<_> = args.iter().map(|a| self.format_term(a)).collect(); format!("({} {})", self.format_term(func), args_str.join(" ")) diff --git a/src/rust/agent/mod.rs b/src/rust/agent/mod.rs index 0152cde..ca476a6 100644 --- a/src/rust/agent/mod.rs +++ b/src/rust/agent/mod.rs @@ -376,17 +376,17 @@ impl AgentCore { prover: prover_kind, time_ms, }); - } + }, Ok(TacticResult::Success(new_state)) => { current_state = new_state; current_state.proof_script.push(tactic.clone()); - } + }, Ok(TacticResult::Error(msg)) => { debug!("Tactic {:?} rejected: {}", tactic, msg); - } + }, Err(e) => { debug!("Backend error on tactic {:?}: {}", tactic, e); - } + }, } } diff --git a/src/rust/aspect.rs b/src/rust/aspect.rs index 20175f1..67d6ab7 100644 --- a/src/rust/aspect.rs +++ b/src/rust/aspect.rs @@ -417,9 +417,6 @@ pub struct TheoremFeatures { /// Pi type (dependent function) count pub pi_count: usize, - /// Sigma type (dependent pair) count - pub sigma_count: usize, - /// Universe levels used pub universe_levels: HashSet, @@ -653,9 +650,6 @@ impl RuleBasedTagger { }, Term::Pi { param_type, body, .. - } - | Term::Sigma { - param_type, body, .. } => { self.extract_symbols_recursive(param_type, symbols); self.extract_symbols_recursive(body, symbols); @@ -752,11 +746,6 @@ impl AspectTagger for RuleBasedTagger { total_matches += features.pi_count; } - if features.sigma_count > 0 { - *aspect_counts.entry(Aspect::DependentTypes).or_insert(0) += features.sigma_count; - total_matches += features.sigma_count; - } - if !features.universe_levels.is_empty() { *aspect_counts.entry(Aspect::Universes).or_insert(0) += 1; total_matches += 1; @@ -818,13 +807,6 @@ impl RuleBasedTagger { self.analyze_term(param_type, features, depth + 1); self.analyze_term(body, features, depth + 1); }, - Term::Sigma { - param_type, body, .. - } => { - features.sigma_count += 1; - self.analyze_term(param_type, features, depth + 1); - self.analyze_term(body, features, depth + 1); - }, Term::Universe(level) | Term::Type(level) | Term::Sort(level) => { features.universe_levels.insert(*level); }, diff --git a/src/rust/core.rs b/src/rust/core.rs index 5b51756..c12103a 100644 --- a/src/rust/core.rs +++ b/src/rust/core.rs @@ -3,7 +3,6 @@ //! Core types and abstractions for ECHIDNA theorem proving -use crate::types::TypeInfo; use serde::{Deserialize, Serialize}; use std::collections::HashMap; use std::fmt; @@ -34,17 +33,6 @@ pub enum Term { body: Box, }, - /// Dependent pair / sum (Sigma type) Σ(x: A). B - /// - /// Represents dependent pairs where the type of the second component may - /// depend on the value of the first. Non-dependent pairs are expressible - /// as `Sigma { body }` where `body` does not mention `param`. - Sigma { - param: String, - param_type: Box, - body: Box, - }, - /// Type universe at level Type(usize), @@ -133,13 +121,6 @@ impl fmt::Display for Term { } => { write!(f, "(Π {}: {}. {})", param, param_type, body) }, - Term::Sigma { - param, - param_type, - body, - } => { - write!(f, "(Σ {}: {}. {})", param, param_type, body) - }, Term::Type(level) => write!(f, "Type{}", level), Term::Sort(level) => write!(f, "Sort{}", level), Term::Universe(level) => write!(f, "Type{}", level), @@ -169,8 +150,7 @@ impl fmt::Display for Term { } /// Current state of a proof -#[derive(Debug, Clone, Serialize, Deserialize)] -#[derive(Default)] +#[derive(Debug, Clone, Serialize, Deserialize, Default)] pub struct ProofState { /// Current goals to prove pub goals: Vec, @@ -209,26 +189,6 @@ pub struct Hypothesis { /// Optional body (for definitions) pub body: Option, - - /// Optional native type-system decoration (multiplicity, effects, modality, - /// refinement, semiring, …). `None` is semantically equivalent to a plain - /// unannotated hypothesis — backends that don't understand the decoration - /// safely ignore it. - #[serde(default, skip_serializing_if = "Option::is_none")] - pub type_info: Option, -} - -impl Hypothesis { - /// Construct a plain hypothesis with no type decoration. - pub fn new(name: impl Into, ty: Term) -> Self { - Self { name: name.into(), ty, body: None, type_info: None } - } - - /// Attach a [`TypeInfo`] decoration. - pub fn with_type_info(mut self, info: TypeInfo) -> Self { - self.type_info = Some(info); - self - } } /// Proof context with available premises @@ -262,23 +222,6 @@ pub struct Definition { pub name: String, pub ty: Term, pub body: Term, - - /// Optional native type-system decoration (see [`TypeInfo`]). - #[serde(default, skip_serializing_if = "Option::is_none")] - pub type_info: Option, -} - -impl Definition { - /// Construct a plain definition with no type decoration. - pub fn new(name: impl Into, ty: Term, body: Term) -> Self { - Self { name: name.into(), ty, body, type_info: None } - } - - /// Attach a [`TypeInfo`] decoration. - pub fn with_type_info(mut self, info: TypeInfo) -> Self { - self.type_info = Some(info); - self - } } /// A variable declaration @@ -286,23 +229,6 @@ impl Definition { pub struct Variable { pub name: String, pub ty: Term, - - /// Optional native type-system decoration (see [`TypeInfo`]). - #[serde(default, skip_serializing_if = "Option::is_none")] - pub type_info: Option, -} - -impl Variable { - /// Construct a plain variable with no type decoration. - pub fn new(name: impl Into, ty: Term) -> Self { - Self { name: name.into(), ty, type_info: None } - } - - /// Attach a [`TypeInfo`] decoration. - pub fn with_type_info(mut self, info: TypeInfo) -> Self { - self.type_info = Some(info); - self - } } /// A proof tactic/command @@ -356,7 +282,6 @@ pub enum TacticResult { QED, } - impl fmt::Display for Definition { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { write!(f, "{} : {} = {}", self.name, self.ty, self.body) diff --git a/src/rust/disciplines/mod.rs b/src/rust/disciplines/mod.rs index 1078f9f..67dceda 100644 --- a/src/rust/disciplines/mod.rs +++ b/src/rust/disciplines/mod.rs @@ -68,9 +68,7 @@ use crate::provers::ProverKind; /// /// Order is stable; inserting a new variant should always append, never /// re-order, because downstream consumers serialise by discriminant. -#[derive( - Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord, Serialize, Deserialize, -)] +#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord, Serialize, Deserialize)] pub enum TypeDiscipline { // Entry points / kernels. TypeLl, @@ -224,14 +222,12 @@ impl TypeDiscipline { match self { D::TypeLl | D::Katagoria => EntryPoint, D::Ordinary => Foundation, - D::Phantom | D::Polymorphic | D::Existential | D::HigherKinded | D::Row => { - Polymorphism - } + D::Phantom | D::Polymorphic | D::Existential | D::HigherKinded | D::Row => Polymorphism, D::Subtyping | D::Intersection | D::Union | D::Gradual => Subtyping, D::Dependent | D::Refinement | D::Hoare | D::Indexed => DependentRefinement, D::Qtt | D::Linear | D::Affine | D::Relevant | D::Ordered | D::Uniqueness => { Substructural - } + }, D::Immutable | D::Capability | D::Bunched => MutabilityCapability, D::Modal | D::Epistemic | D::Temporal | D::Provability => Modal, D::EffectRow | D::Impure | D::Coeffect | D::Probabilistic => EffectsCoeffects, @@ -419,7 +415,7 @@ impl TypeDiscipline { // that have explicit STLC tutorials. D::Ordinary => { vec![P::Agda, P::Coq, P::Lean, P::Isabelle, P::Idris2, P::FStar] - } + }, // Polymorphism family. D::Polymorphic => vec![ @@ -436,9 +432,7 @@ impl TypeDiscipline { D::Existential => vec![P::Agda, P::Coq, P::Lean, P::Idris2, P::FStar], D::HigherKinded => vec![P::Agda, P::Coq, P::Lean, P::Idris2, P::FStar], D::Row => vec![], // Koka-native; none in echidna's classical lineup. - D::Phantom => vec![ - P::Agda, P::Coq, P::Lean, P::Idris2, P::FStar, P::Dafny, - ], + D::Phantom => vec![P::Agda, P::Coq, P::Lean, P::Idris2, P::FStar, P::Dafny], // Subtyping family. D::Subtyping => vec![P::FStar, P::Dafny], @@ -473,15 +467,13 @@ impl TypeDiscipline { // Modal family. D::Modal => vec![P::Isabelle], // Isabelle/ModalHOL + other instances. D::Epistemic => vec![], // DEL / S5 tooling lives outside echidna's current lineup. - D::Temporal => vec![ - P::NuSMV, P::TLC, P::SPIN, P::UPPAAL, P::Prism, P::TLAPS, - ], + D::Temporal => vec![P::NuSMV, P::TLC, P::SPIN, P::UPPAAL, P::Prism, P::TLAPS], D::Provability => vec![], // GL logic, mostly research. // Effects / coeffects. D::EffectRow => vec![P::FStar], // F* effect algebras. D::Impure => vec![P::FStar, P::Dafny], // Stateful-program verifiers. - D::Coeffect => vec![], // Granule; not in echidna. + D::Coeffect => vec![], // Granule; not in echidna. D::Probabilistic => vec![P::Prism, P::DReal], // Process / communication — the HP stack is specifically here @@ -584,8 +576,7 @@ mod tests { #[test] fn tags_are_unique() { - let mut tags: Vec<&'static str> = - TypeDiscipline::ALL.iter().map(|d| d.tag()).collect(); + let mut tags: Vec<&'static str> = TypeDiscipline::ALL.iter().map(|d| d.tag()).collect(); tags.sort_unstable(); let before = tags.len(); tags.dedup(); diff --git a/src/rust/dispatch.rs b/src/rust/dispatch.rs index 6350ece..7a476d7 100644 --- a/src/rust/dispatch.rs +++ b/src/rust/dispatch.rs @@ -14,8 +14,8 @@ use tracing::{info, warn}; use crate::integrity::solver_integrity::{IntegrityChecker, IntegrityStatus}; use crate::llm::LlmAdvisor; -use crate::provers::{ProverConfig, ProverFactory, ProverKind}; use crate::provers::outcome::{classify_anyhow_error, ProverOutcome}; +use crate::provers::{ProverConfig, ProverFactory, ProverKind}; use crate::verification::axiom_tracker::{AxiomTracker, AxiomUsage, DangerLevel}; use crate::verification::confidence::{compute_trust_level, TrustFactors, TrustLevel}; @@ -256,7 +256,7 @@ impl ProverDispatcher { outcome, diagnostics, }); - } + }, }; // Step 3: Run the rich `check()` variant — gives us a full outcome @@ -586,19 +586,14 @@ mod tests { #[test] fn test_prover_selection_agda() { - let prover = ProverDispatcher::select_prover( - "module MyModule where\ndata Nat : Set where", - None, - ); + let prover = + ProverDispatcher::select_prover("module MyModule where\ndata Nat : Set where", None); assert_eq!(prover, ProverKind::Agda); } #[test] fn test_prover_selection_isabelle() { - let prover = ProverDispatcher::select_prover( - "theory MyTheory\nimports Main", - None, - ); + let prover = ProverDispatcher::select_prover("theory MyTheory\nimports Main", None); assert_eq!(prover, ProverKind::Isabelle); } diff --git a/src/rust/exchange/dedukti.rs b/src/rust/exchange/dedukti.rs index 04bf345..3849875 100644 --- a/src/rust/exchange/dedukti.rs +++ b/src/rust/exchange/dedukti.rs @@ -211,18 +211,6 @@ impl DeduktiExporter { Self::term_to_dedukti(body) ) }, - Term::Sigma { - param, - param_type, - body, - } => { - format!( - "(dk_sigma {} ({} => {}))", - Self::term_to_dedukti(param_type), - param, - Self::term_to_dedukti(body) - ) - }, Term::Type(level) => format!("Type {}", level), Term::Sort(level) => format!("Sort {}", level), Term::Universe(level) => format!("Type {}", level), @@ -236,32 +224,6 @@ impl DeduktiExporter { if trimmed.starts_with('(') && trimmed.ends_with(')') { // Unwrap parentheses and recurse Self::dedukti_to_term(&trimmed[1..trimmed.len() - 1]) - } else if trimmed.starts_with("dk_sigma ") { - // Sigma type: dk_sigma A (x => B) - let rest = trimmed.trim_start_matches("dk_sigma ").trim(); - // Split into the type part and the binder part (x => B) - if let Some(paren_start) = rest.find('(') { - let type_part = rest[..paren_start].trim(); - let binder_part = rest[paren_start..].trim(); - let inner = if binder_part.starts_with('(') && binder_part.ends_with(')') { - &binder_part[1..binder_part.len() - 1] - } else { - binder_part - }; - if let Some(arrow_pos) = inner.find("=>") { - let param = inner[..arrow_pos].trim().to_string(); - let body_str = inner[arrow_pos + 2..].trim(); - Term::Sigma { - param, - param_type: Box::new(Self::dedukti_to_term(type_part)), - body: Box::new(Self::dedukti_to_term(body_str)), - } - } else { - Term::Const(trimmed.to_string()) - } - } else { - Term::Const(trimmed.to_string()) - } } else if trimmed.contains("->") { // Pi type: A -> B let parts: Vec<&str> = trimmed.splitn(2, "->").collect(); @@ -454,28 +416,6 @@ mod tests { assert_eq!(dk, "x"); } - #[test] - fn test_term_to_dedukti_sigma() { - let term = Term::Sigma { - param: "x".to_string(), - param_type: Box::new(Term::Const("Nat".to_string())), - body: Box::new(Term::Const("Prop".to_string())), - }; - let dk = DeduktiExporter::term_to_dedukti(&term); - assert!(dk.contains("dk_sigma"), "Sigma should render as dk_sigma, got: {}", dk); - assert!(dk.contains("Nat"), "Sigma param type should appear, got: {}", dk); - } - - #[test] - fn test_dedukti_to_term_sigma() { - let dk = "dk_sigma Nat (x => Prop)"; - let term = DeduktiExporter::dedukti_to_term(dk); - match term { - Term::Sigma { ref param, .. } => assert_eq!(param, "x"), - _ => panic!("Expected Sigma term, got: {:?}", term), - } - } - #[test] fn test_import_with_definition() { let module = DeduktiModule { diff --git a/src/rust/ffi/mod.rs b/src/rust/ffi/mod.rs index 4e65ab6..68c5f52 100644 --- a/src/rust/ffi/mod.rs +++ b/src/rust/ffi/mod.rs @@ -678,7 +678,11 @@ pub unsafe extern "C" fn rust_apply_tactic( /// - `state` must be a valid pointer previously returned by `rust_parse_file`/`rust_parse_string`. /// - `out_valid` must be a valid, non-null, writable pointer. #[no_mangle] -pub unsafe extern "C" fn rust_verify_proof(kind: u8, state: *mut c_void, out_valid: *mut bool) -> c_int { +pub unsafe extern "C" fn rust_verify_proof( + kind: u8, + state: *mut c_void, + out_valid: *mut bool, +) -> c_int { if state.is_null() || out_valid.is_null() { return FfiStatus::ErrorInvalidArgument as c_int; } @@ -909,14 +913,14 @@ pub extern "C" fn echidna_create_prover(kind: u8) -> c_int { None => { set_last_error(&format!("Unknown prover kind: {kind}")); return FfiStatus::ErrorInvalidArgument as c_int; - } + }, }; match create_prover(prover_kind, ProverConfig::default()) { Ok(handle) => handle as c_int, Err(status) => { set_last_error(&format!("Failed to create prover: {kind}")); status as c_int - } + }, } } @@ -939,7 +943,7 @@ pub unsafe extern "C" fn echidna_parse_string( Err(_) => { set_last_error("Invalid UTF-8 content"); return FfiStatus::ErrorInvalidArgument as c_int; - } + }, }; let registry = match PROVER_REGISTRY.lock() { Ok(r) => r, @@ -950,14 +954,14 @@ pub unsafe extern "C" fn echidna_parse_string( None => { set_last_error(&format!("Invalid handle: {handle}")); return FfiStatus::ErrorInvalidHandle as c_int; - } + }, }; match run_async(prover.parse_string(content_str)) { Ok(_state) => FfiStatus::Ok as c_int, Err(status) => { set_last_error("Parse failed"); status as c_int - } + }, } } @@ -972,11 +976,11 @@ pub extern "C" fn echidna_verify_proof(handle: c_int) -> c_int { Some(_prover) => { // Verify requires a proof state — return OK for handle validity check FfiStatus::Ok as c_int - } + }, None => { set_last_error(&format!("Invalid handle: {handle}")); FfiStatus::ErrorInvalidHandle as c_int - } + }, } } @@ -1034,7 +1038,7 @@ pub unsafe extern "C" fn echidna_suggest_tactics( std::ptr::copy_nonoverlapping(json.as_ptr(), out, copy_len); *out_len = copy_len; FfiStatus::Ok as c_int - } + }, None => FfiStatus::ErrorInvalidHandle as c_int, } } @@ -1061,7 +1065,7 @@ pub unsafe extern "C" fn echidna_export_proof( Some(_prover) => { *out_len = 0; FfiStatus::Ok as c_int - } + }, None => FfiStatus::ErrorInvalidHandle as c_int, } } @@ -1253,58 +1257,123 @@ mod tests { // ecosystem TypeDiscipline variants (codes 49–88). let all_kinds = [ // Classic backends (0–48). - ProverKind::Agda, ProverKind::Coq, ProverKind::Lean, - ProverKind::Isabelle, ProverKind::Z3, ProverKind::CVC5, - ProverKind::Metamath, ProverKind::HOLLight, ProverKind::Mizar, - ProverKind::PVS, ProverKind::ACL2, ProverKind::HOL4, - ProverKind::Idris2, ProverKind::Vampire, ProverKind::EProver, - ProverKind::SPASS, ProverKind::AltErgo, ProverKind::FStar, - ProverKind::Dafny, ProverKind::Why3, ProverKind::TLAPS, - ProverKind::Twelf, ProverKind::Nuprl, ProverKind::Minlog, - ProverKind::Imandra, ProverKind::GLPK, ProverKind::SCIP, - ProverKind::MiniZinc, ProverKind::Chuffed, ProverKind::ORTools, - ProverKind::TypedWasm, ProverKind::SPIN, ProverKind::CBMC, - ProverKind::SeaHorn, ProverKind::CaDiCaL, ProverKind::Kissat, - ProverKind::MiniSat, ProverKind::NuSMV, ProverKind::TLC, - ProverKind::Alloy, ProverKind::Prism, ProverKind::UPPAAL, - ProverKind::FramaC, ProverKind::Viper, ProverKind::Tamarin, - ProverKind::ProVerif, ProverKind::KeY, ProverKind::DReal, + ProverKind::Agda, + ProverKind::Coq, + ProverKind::Lean, + ProverKind::Isabelle, + ProverKind::Z3, + ProverKind::CVC5, + ProverKind::Metamath, + ProverKind::HOLLight, + ProverKind::Mizar, + ProverKind::PVS, + ProverKind::ACL2, + ProverKind::HOL4, + ProverKind::Idris2, + ProverKind::Vampire, + ProverKind::EProver, + ProverKind::SPASS, + ProverKind::AltErgo, + ProverKind::FStar, + ProverKind::Dafny, + ProverKind::Why3, + ProverKind::TLAPS, + ProverKind::Twelf, + ProverKind::Nuprl, + ProverKind::Minlog, + ProverKind::Imandra, + ProverKind::GLPK, + ProverKind::SCIP, + ProverKind::MiniZinc, + ProverKind::Chuffed, + ProverKind::ORTools, + ProverKind::TypedWasm, + ProverKind::SPIN, + ProverKind::CBMC, + ProverKind::SeaHorn, + ProverKind::CaDiCaL, + ProverKind::Kissat, + ProverKind::MiniSat, + ProverKind::NuSMV, + ProverKind::TLC, + ProverKind::Alloy, + ProverKind::Prism, + ProverKind::UPPAAL, + ProverKind::FramaC, + ProverKind::Viper, + ProverKind::Tamarin, + ProverKind::ProVerif, + ProverKind::KeY, + ProverKind::DReal, ProverKind::ABC, // HP ecosystem: original 12 (49–60). - ProverKind::TypeLL, ProverKind::KatagoriaVerifier, - ProverKind::TropicalTypeChecker, ProverKind::ChoreographicTypeChecker, - ProverKind::EpistemicTypeChecker, ProverKind::EchoTypeChecker, - ProverKind::SessionTypeChecker, ProverKind::ModalTypeChecker, - ProverKind::QTTTypeChecker, ProverKind::EffectRowTypeChecker, - ProverKind::DependentTypeChecker, ProverKind::RefinementTypeChecker, + ProverKind::TypeLL, + ProverKind::KatagoriaVerifier, + ProverKind::TropicalTypeChecker, + ProverKind::ChoreographicTypeChecker, + ProverKind::EpistemicTypeChecker, + ProverKind::EchoTypeChecker, + ProverKind::SessionTypeChecker, + ProverKind::ModalTypeChecker, + ProverKind::QTTTypeChecker, + ProverKind::EffectRowTypeChecker, + ProverKind::DependentTypeChecker, + ProverKind::RefinementTypeChecker, // HP ecosystem: TypeDiscipline transition (61–88). - ProverKind::OrdinaryTypeChecker, ProverKind::PhantomTypeChecker, - ProverKind::PolymorphicTypeChecker, ProverKind::ExistentialTypeChecker, - ProverKind::HigherKindedTypeChecker, ProverKind::RowTypeChecker, - ProverKind::SubtypingTypeChecker, ProverKind::IntersectionTypeChecker, - ProverKind::UnionTypeChecker, ProverKind::GradualTypeChecker, - ProverKind::HoareTypeChecker, ProverKind::IndexedTypeChecker, - ProverKind::LinearTypeChecker, ProverKind::AffineTypeChecker, - ProverKind::RelevantTypeChecker, ProverKind::OrderedTypeChecker, - ProverKind::UniquenessTypeChecker, ProverKind::ImmutableTypeChecker, - ProverKind::CapabilityTypeChecker, ProverKind::BunchedTypeChecker, - ProverKind::TemporalTypeChecker, ProverKind::ProvabilityTypeChecker, - ProverKind::ImpureTypeChecker, ProverKind::CoeffectTypeChecker, - ProverKind::ProbabilisticTypeChecker, ProverKind::DyadicTypeChecker, - ProverKind::HomotopyTypeChecker, ProverKind::CubicalTypeChecker, + ProverKind::OrdinaryTypeChecker, + ProverKind::PhantomTypeChecker, + ProverKind::PolymorphicTypeChecker, + ProverKind::ExistentialTypeChecker, + ProverKind::HigherKindedTypeChecker, + ProverKind::RowTypeChecker, + ProverKind::SubtypingTypeChecker, + ProverKind::IntersectionTypeChecker, + ProverKind::UnionTypeChecker, + ProverKind::GradualTypeChecker, + ProverKind::HoareTypeChecker, + ProverKind::IndexedTypeChecker, + ProverKind::LinearTypeChecker, + ProverKind::AffineTypeChecker, + ProverKind::RelevantTypeChecker, + ProverKind::OrderedTypeChecker, + ProverKind::UniquenessTypeChecker, + ProverKind::ImmutableTypeChecker, + ProverKind::CapabilityTypeChecker, + ProverKind::BunchedTypeChecker, + ProverKind::TemporalTypeChecker, + ProverKind::ProvabilityTypeChecker, + ProverKind::ImpureTypeChecker, + ProverKind::CoeffectTypeChecker, + ProverKind::ProbabilisticTypeChecker, + ProverKind::DyadicTypeChecker, + ProverKind::HomotopyTypeChecker, + ProverKind::CubicalTypeChecker, // Nominal-logic / HOAS family. - ProverKind::NominalTypeChecker, ProverKind::Abella, + ProverKind::NominalTypeChecker, + ProverKind::Abella, // Classical sibling provers (post-HP-band). ProverKind::Lean3, // Phase 4 acquisition batch (2026-04-18). - ProverKind::Dedukti, ProverKind::Cameleer, ProverKind::ACL2s, - ProverKind::IsabelleZF, ProverKind::Boogie, + ProverKind::Dedukti, + ProverKind::Cameleer, + ProverKind::ACL2s, + ProverKind::IsabelleZF, + ProverKind::Boogie, // Phase 4 "variety" batch (2026-04-18). - ProverKind::Naproche, ProverKind::Matita, ProverKind::Arend, - ProverKind::Athena, ProverKind::LambdaProlog, ProverKind::Mercury, - ProverKind::Nitpick, ProverKind::Nunchaku, + ProverKind::Naproche, + ProverKind::Matita, + ProverKind::Arend, + ProverKind::Athena, + ProverKind::LambdaProlog, + ProverKind::Mercury, + ProverKind::Nitpick, + ProverKind::Nunchaku, ]; - assert_eq!(all_kinds.len(), 105, "expected 105 total ProverKind variants"); + assert_eq!( + all_kinds.len(), + 105, + "expected 105 total ProverKind variants" + ); for kind in &all_kinds { let u8_val = kind_to_u8(*kind); let roundtripped = kind_from_u8(u8_val) diff --git a/src/rust/gnn/client.rs b/src/rust/gnn/client.rs index 21e822c..539d032 100644 --- a/src/rust/gnn/client.rs +++ b/src/rust/gnn/client.rs @@ -219,12 +219,12 @@ impl GnnClient { self.server_available = false; Ok(false) } - } + }, Err(e) => { debug!("GNN server not available: {}", e); self.server_available = false; Ok(false) - } + }, } } @@ -259,7 +259,7 @@ impl GnnClient { inference_time_ms: 0.0, from_server: false, } - } + }, } } @@ -319,11 +319,7 @@ impl GnnClient { let node_labels: Vec = graph.nodes.iter().map(|n| n.label.clone()).collect(); - let feature_dim = graph - .nodes - .first() - .map(|n| n.features.len()) - .unwrap_or(0); + let feature_dim = graph.nodes.first().map(|n| n.features.len()).unwrap_or(0); let goal_node_idx = graph .goal_node_id diff --git a/src/rust/gnn/embeddings.rs b/src/rust/gnn/embeddings.rs index fa296b0..84aca22 100644 --- a/src/rust/gnn/embeddings.rs +++ b/src/rust/gnn/embeddings.rs @@ -72,12 +72,7 @@ impl TermFeatureExtractor { *self.symbol_frequencies.entry(sym).or_insert(0) += 1; } } - self.max_frequency = self - .symbol_frequencies - .values() - .copied() - .max() - .unwrap_or(1); + self.max_frequency = self.symbol_frequencies.values().copied().max().unwrap_or(1); // Pass 2: compute feature vectors let num_nodes = graph.nodes.len(); @@ -161,12 +156,11 @@ impl TermFeatureExtractor { // Feature [26]: Is a top-level node (goal or premise)? if offset < FEATURE_DIM { - features[offset] = - if node.kind == NodeKind::Goal || node.kind == NodeKind::Premise { - 1.0 - } else { - 0.0 - }; + features[offset] = if node.kind == NodeKind::Goal || node.kind == NodeKind::Premise { + 1.0 + } else { + 0.0 + }; } offset += 1; @@ -190,11 +184,9 @@ impl TermFeatureExtractor { // Feature [29]: Contains quantifier (forall, exists, pi) if offset < FEATURE_DIM { features[offset] = if node.label.contains("pi_") - || node.label.contains("sigma_") || node.label.contains("forall") || node.label.contains("exists") || node.label.contains("Pi") - || node.label.contains("Sigma") { 1.0 } else { @@ -312,8 +304,6 @@ fn infer_term_kind_from_label(label: &str) -> usize { 3 // Lambda } else if label.starts_with("pi_") { 4 // Pi - } else if label.starts_with("sigma_") { - 13 // Sigma } else if label.starts_with("let_") { 7 // Let } else if label.starts_with("fix_") { @@ -354,41 +344,56 @@ fn term_kind_index(term: &Term) -> usize { Term::Hole(_) => 10, Term::Meta(_) => 11, Term::ProverSpecific { .. } => 12, - Term::Sigma { .. } => 13, } } /// Compute the maximum depth of a term tree. fn term_depth(term: &Term) -> usize { match term { - Term::Var(_) | Term::Const(_) | Term::Type(_) | Term::Sort(_) - | Term::Universe(_) | Term::Hole(_) | Term::Meta(_) => 0, + Term::Var(_) + | Term::Const(_) + | Term::Type(_) + | Term::Sort(_) + | Term::Universe(_) + | Term::Hole(_) + | Term::Meta(_) => 0, Term::App { func, args } => { let func_depth = term_depth(func); let max_arg = args.iter().map(term_depth).max().unwrap_or(0); 1 + func_depth.max(max_arg) - } - Term::Lambda { param_type, body, .. } => { + }, + Term::Lambda { + param_type, body, .. + } => { let pt = param_type.as_ref().map(|t| term_depth(t)).unwrap_or(0); 1 + pt.max(term_depth(body)) - } - Term::Pi { param_type, body, .. } - | Term::Sigma { param_type, body, .. } => { - 1 + term_depth(param_type).max(term_depth(body)) - } - Term::Let { ty, value, body, .. } => { + }, + Term::Pi { + param_type, body, .. + } => 1 + term_depth(param_type).max(term_depth(body)), + Term::Let { + ty, value, body, .. + } => { let t = ty.as_ref().map(|t| term_depth(t)).unwrap_or(0); 1 + t.max(term_depth(value)).max(term_depth(body)) - } - Term::Match { scrutinee, branches, .. } => { + }, + Term::Match { + scrutinee, + branches, + .. + } => { let s = term_depth(scrutinee); - let b = branches.iter().map(|(_, t)| term_depth(t)).max().unwrap_or(0); + let b = branches + .iter() + .map(|(_, t)| term_depth(t)) + .max() + .unwrap_or(0); 1 + s.max(b) - } + }, Term::Fix { ty, body, .. } => { let t = ty.as_ref().map(|t| term_depth(t)).unwrap_or(0); 1 + t.max(term_depth(body)) - } + }, Term::ProverSpecific { .. } => 0, } } @@ -396,14 +401,38 @@ fn term_depth(term: &Term) -> usize { /// Compute the arity of a term (number of direct subterms). fn term_arity(term: &Term) -> usize { match term { - Term::Var(_) | Term::Const(_) | Term::Type(_) | Term::Sort(_) - | Term::Universe(_) | Term::Hole(_) | Term::Meta(_) | Term::ProverSpecific { .. } => 0, + Term::Var(_) + | Term::Const(_) + | Term::Type(_) + | Term::Sort(_) + | Term::Universe(_) + | Term::Hole(_) + | Term::Meta(_) + | Term::ProverSpecific { .. } => 0, Term::App { args, .. } => 1 + args.len(), // func + args - Term::Lambda { param_type, .. } => if param_type.is_some() { 2 } else { 1 }, - Term::Pi { .. } | Term::Sigma { .. } => 2, // param_type + body - Term::Let { ty, .. } => if ty.is_some() { 3 } else { 2 }, + Term::Lambda { param_type, .. } => { + if param_type.is_some() { + 2 + } else { + 1 + } + }, + Term::Pi { .. } => 2, // param_type + body + Term::Let { ty, .. } => { + if ty.is_some() { + 3 + } else { + 2 + } + }, Term::Match { branches, .. } => 1 + branches.len(), - Term::Fix { ty, .. } => if ty.is_some() { 2 } else { 1 }, + Term::Fix { ty, .. } => { + if ty.is_some() { + 2 + } else { + 1 + } + }, } } diff --git a/src/rust/gnn/graph.rs b/src/rust/gnn/graph.rs index 0bd344b..3a0ad66 100644 --- a/src/rust/gnn/graph.rs +++ b/src/rust/gnn/graph.rs @@ -17,7 +17,7 @@ use serde::{Deserialize, Serialize}; use std::collections::HashMap; -use crate::core::{Context, Definition, Goal, Hypothesis, ProofState, Term, Theorem}; +use crate::core::{Context, Goal, Hypothesis, ProofState, Term, Theorem}; /// Kind of node in the proof graph. /// @@ -63,12 +63,6 @@ pub enum EdgeKind { DependsOn, /// Reverse of DependsOn (premise is useful for goal) UsefulFor, - /// Source has the target as its QTT multiplicity annotation - HasMultiplicity, - /// Source has the target as its algebraic effect annotation - HasEffect, - /// Source has the target as its modal decoration - HasModality, } /// A single node in the proof graph. @@ -191,25 +185,18 @@ impl ProofGraphBuilder { // Phase 2: Add hypothesis nodes from context let hyp_ids = self.add_hypotheses_from_context(&state.context); - // Phase 2b: Add definition nodes from context - let def_ids = self.add_definitions_from_context(&state.context); - // Phase 3: Add premise/theorem nodes from context for theorem in &state.context.theorems { let pid = self.add_premise(theorem); premise_node_ids.push(pid); } - // Phase 4: Add dependency edges from goals to hypotheses/definitions/premises + // Phase 4: Add dependency edges from goals to hypotheses/premises if let Some(gid) = goal_node_id { for &hid in &hyp_ids { self.add_edge(gid, hid, EdgeKind::DependsOn, 1.0); self.add_edge(hid, gid, EdgeKind::UsefulFor, 1.0); } - for &did in &def_ids { - self.add_edge(gid, did, EdgeKind::DependsOn, 0.9); - self.add_edge(did, gid, EdgeKind::UsefulFor, 0.9); - } for &pid in &premise_node_ids { self.add_edge(gid, pid, EdgeKind::DependsOn, 0.8); self.add_edge(pid, gid, EdgeKind::UsefulFor, 0.8); @@ -291,11 +278,6 @@ impl ProofGraphBuilder { self.expand_term(body, hid, 1); } - // Wire type_info annotations as edges - if let Some(ref info) = hyp.type_info { - self.add_type_info_edges(hid, info); - } - hid } @@ -306,49 +288,11 @@ impl ProofGraphBuilder { let label = format!("{}: {}", var.name, var.ty); let vid = self.add_node(NodeKind::Hypothesis, &label, 0); self.expand_term(&var.ty, vid, 1); - - // Wire type_info annotations as edges - if let Some(ref info) = var.type_info { - self.add_type_info_edges(vid, info); - } - ids.push(vid); } ids } - /// Add definition nodes from the global context. - fn add_definitions_from_context(&mut self, ctx: &Context) -> Vec { - let mut ids = Vec::new(); - for def in &ctx.definitions { - let did = self.add_definition(def); - ids.push(did); - } - ids - } - - /// Add a definition node. - fn add_definition(&mut self, def: &Definition) -> usize { - let label = format!("{}: {}", def.name, def.ty); - let did = self.add_node(NodeKind::Hypothesis, &label, 0); - - // Expand the definition type - let type_id = self.expand_term(&def.ty, did, 1); - if let Some(tid) = type_id { - self.add_edge(did, tid, EdgeKind::HasType, 1.0); - } - - // Expand the definition body - self.expand_term(&def.body, did, 1); - - // Wire type_info annotations as edges - if let Some(ref info) = def.type_info { - self.add_type_info_edges(did, info); - } - - did - } - /// Add a premise (theorem/lemma) node. fn add_premise(&mut self, theorem: &Theorem) -> usize { let label = format!("{}: {}", theorem.name, theorem.statement); @@ -374,12 +318,12 @@ impl ProofGraphBuilder { let nid = self.add_or_get_node(NodeKind::Subterm, name, depth); self.add_edge(parent_id, nid, EdgeKind::Contains, 1.0); Some(nid) - } + }, Term::Const(name) => { let nid = self.add_or_get_node(NodeKind::Constant, name, depth); self.add_edge(parent_id, nid, EdgeKind::References, 1.0); Some(nid) - } + }, Term::App { func, args } => { let label = format!("app@{}", depth); let nid = self.add_node(NodeKind::Subterm, &label, depth); @@ -391,7 +335,7 @@ impl ProofGraphBuilder { self.expand_term(arg, nid, depth + 1); } Some(nid) - } + }, Term::Lambda { param, param_type, @@ -410,7 +354,7 @@ impl ProofGraphBuilder { self.add_edge(nid, bid, EdgeKind::BindsOver, 1.0); } Some(nid) - } + }, Term::Pi { param, param_type, @@ -427,32 +371,18 @@ impl ProofGraphBuilder { self.add_edge(nid, bid, EdgeKind::BindsOver, 1.0); } Some(nid) - } - Term::Sigma { - param, - param_type, - body, - } => { - let label = format!("sigma_{}", param); - let nid = self.add_node(NodeKind::Binder, &label, depth); - self.add_edge(parent_id, nid, EdgeKind::Contains, 1.0); - - if let Some(tid) = self.expand_term(param_type, nid, depth + 1) { - self.add_edge(nid, tid, EdgeKind::HasType, 1.0); - } - if let Some(bid) = self.expand_term(body, nid, depth + 1) { - self.add_edge(nid, bid, EdgeKind::BindsOver, 1.0); - } - Some(nid) - } + }, Term::Type(level) | Term::Sort(level) | Term::Universe(level) => { let label = format!("Type{}", level); let nid = self.add_or_get_node(NodeKind::TypeExpr, &label, depth); self.add_edge(parent_id, nid, EdgeKind::Contains, 1.0); Some(nid) - } + }, Term::Let { - name, ty, value, body, + name, + ty, + value, + body, } => { let label = format!("let_{}", name); let nid = self.add_node(NodeKind::Binder, &label, depth); @@ -468,14 +398,14 @@ impl ProofGraphBuilder { self.add_edge(nid, bid, EdgeKind::BindsOver, 1.0); } Some(nid) - } + }, Term::Match { scrutinee, .. } => { let label = format!("match@{}", depth); let nid = self.add_node(NodeKind::Subterm, &label, depth); self.add_edge(parent_id, nid, EdgeKind::Contains, 1.0); self.expand_term(scrutinee, nid, depth + 1); Some(nid) - } + }, Term::Fix { name, ty, body } => { let label = format!("fix_{}", name); let nid = self.add_node(NodeKind::Binder, &label, depth); @@ -490,51 +420,25 @@ impl ProofGraphBuilder { self.add_edge(nid, bid, EdgeKind::BindsOver, 1.0); } Some(nid) - } + }, Term::Hole(name) => { let label = format!("?{}", name); let nid = self.add_node(NodeKind::Subterm, &label, depth); self.add_edge(parent_id, nid, EdgeKind::Contains, 1.0); Some(nid) - } + }, Term::Meta(id) => { let label = format!("?meta_{}", id); let nid = self.add_node(NodeKind::Subterm, &label, depth); self.add_edge(parent_id, nid, EdgeKind::Contains, 1.0); Some(nid) - } + }, Term::ProverSpecific { prover, .. } => { let label = format!("<{}-opaque>", prover); let nid = self.add_node(NodeKind::Subterm, &label, depth); self.add_edge(parent_id, nid, EdgeKind::Contains, 1.0); Some(nid) - } - } - } - - /// Add edges from a node to represent its [`TypeInfo`] annotations. - /// - /// Creates labelled subterm nodes for multiplicity, effect, and modality - /// decorations and connects them with the appropriate edge kind. - fn add_type_info_edges(&mut self, node_id: usize, info: &crate::types::TypeInfo) { - if let Some(ref mult) = info.multiplicity { - let label = format!("mult:{:?}", mult); - let mid = self.add_node(NodeKind::Subterm, &label, 1); - self.add_edge(node_id, mid, EdgeKind::HasMultiplicity, 1.0); - } - - if !info.effects.is_empty() { - for eff in &info.effects.effects { - let label = format!("effect:{:?}", eff); - let eid = self.add_node(NodeKind::Subterm, &label, 1); - self.add_edge(node_id, eid, EdgeKind::HasEffect, 1.0); - } - } - - if let Some(ref modality) = info.modality { - let label = format!("modality:{:?}", modality); - let mid = self.add_node(NodeKind::Subterm, &label, 1); - self.add_edge(node_id, mid, EdgeKind::HasModality, 1.0); + }, } } @@ -580,12 +484,7 @@ impl ProofGraphBuilder { } /// Walk edges from a node to collect reachable Constant node ids. - fn collect_reachable_constants( - &self, - node_id: usize, - constants: &mut Vec, - depth: u32, - ) { + fn collect_reachable_constants(&self, node_id: usize, constants: &mut Vec, depth: u32) { if depth > self.max_depth { return; } @@ -729,10 +628,7 @@ mod tests { func: Box::new(Term::Const("is_even".to_string())), args: vec![Term::App { func: Box::new(Term::Const("add".to_string())), - args: vec![ - Term::Var("n".to_string()), - Term::Var("n".to_string()), - ], + args: vec![Term::Var("n".to_string()), Term::Var("n".to_string())], }], }), }; @@ -741,7 +637,6 @@ mod tests { name: "h_nat".to_string(), ty: Term::Const("Nat".to_string()), body: None, - type_info: None, }; let theorem = Theorem { @@ -753,10 +648,7 @@ mod tests { func: Box::new(Term::Const("is_even".to_string())), args: vec![Term::App { func: Box::new(Term::Const("add".to_string())), - args: vec![ - Term::Var("m".to_string()), - Term::Var("m".to_string()), - ], + args: vec![Term::Var("m".to_string()), Term::Var("m".to_string())], }], }), }, @@ -787,7 +679,6 @@ mod tests { variables: vec![Variable { name: "n".to_string(), ty: Term::Const("Nat".to_string()), - type_info: None, }], }, proof_script: Vec::new(), @@ -802,7 +693,11 @@ mod tests { let graph = builder.build_from_proof_state(&state); // Must have at least: 1 goal + 1 hyp + 2 premises + subterms - assert!(graph.num_nodes() >= 4, "Expected at least 4 nodes, got {}", graph.num_nodes()); + assert!( + graph.num_nodes() >= 4, + "Expected at least 4 nodes, got {}", + graph.num_nodes() + ); assert!(graph.num_edges() > 0, "Expected at least 1 edge"); assert!(graph.goal_node_id.is_some(), "Must have a goal node"); assert_eq!(graph.premise_node_ids.len(), 2, "Must have 2 premise nodes"); diff --git a/src/rust/gnn/guided_search.rs b/src/rust/gnn/guided_search.rs index d512e6f..6d87002 100644 --- a/src/rust/gnn/guided_search.rs +++ b/src/rust/gnn/guided_search.rs @@ -144,11 +144,11 @@ impl GnnGuidedSearch { debug!("GNN server not available, will use symbolic fallback"); } available - } + }, Err(e) => { debug!("GNN health check failed: {}", e); false - } + }, } } @@ -341,14 +341,20 @@ fn infer_tactic(name: &str, statement: &Term) -> Tactic { } // Induction hints: names containing "ind", "rec", "induction" - if name_lower.contains("_ind") || name_lower.contains("_rec") || name_lower.contains("induction") { + if name_lower.contains("_ind") + || name_lower.contains("_rec") + || name_lower.contains("induction") + { if let Term::Pi { param_type, .. } = statement { return Tactic::Induction(*param_type.clone()); } } // Cases hints: names containing "cases", "destruct", "elim" - if name_lower.contains("cases") || name_lower.contains("destruct") || name_lower.contains("elim") { + if name_lower.contains("cases") + || name_lower.contains("destruct") + || name_lower.contains("elim") + { if let Term::Pi { param_type, .. } = statement { return Tactic::Cases(*param_type.clone()); } @@ -371,17 +377,13 @@ mod tests { func: Box::new(Term::Const("is_even".to_string())), args: vec![Term::App { func: Box::new(Term::Const("add".to_string())), - args: vec![ - Term::Var("n".to_string()), - Term::Var("n".to_string()), - ], + args: vec![Term::Var("n".to_string()), Term::Var("n".to_string())], }], }, hypotheses: vec![Hypothesis { name: "h".to_string(), ty: Term::Const("Nat".to_string()), body: None, - type_info: None, }], }], context: Context { @@ -391,7 +393,6 @@ mod tests { variables: vec![Variable { name: "n".to_string(), ty: Term::Const("Nat".to_string()), - type_info: None, }], }, proof_script: Vec::new(), @@ -410,10 +411,7 @@ mod tests { func: Box::new(Term::Const("is_even".to_string())), args: vec![Term::App { func: Box::new(Term::Const("add".to_string())), - args: vec![ - Term::Var("m".to_string()), - Term::Var("m".to_string()), - ], + args: vec![Term::Var("m".to_string()), Term::Var("m".to_string())], }], }), }, diff --git a/src/rust/learning/curriculum.rs b/src/rust/learning/curriculum.rs index c729f97..5118e74 100644 --- a/src/rust/learning/curriculum.rs +++ b/src/rust/learning/curriculum.rs @@ -90,10 +90,8 @@ impl Curriculum { if candidates.is_empty() { return None; } - let mut sorted: Vec<(&Variant, u8)> = candidates - .iter() - .map(|v| (v, difficulty_hint(v))) - .collect(); + let mut sorted: Vec<(&Variant, u8)> = + candidates.iter().map(|v| (v, difficulty_hint(v))).collect(); sorted.sort_by_key(|(_, d)| *d); let pick_idx = match self.regime() { diff --git a/src/rust/learning/daemon.rs b/src/rust/learning/daemon.rs index e4d78e8..c1fb3aa 100644 --- a/src/rust/learning/daemon.rs +++ b/src/rust/learning/daemon.rs @@ -131,12 +131,8 @@ impl Daemon { let backend = ProverFactory::create(self.cfg.prover_kind, prover_config) .context("daemon: create backend")?; - let mut search = super::mcts::Search::new( - backend.as_ref(), - policy, - value, - self.cfg.search.clone(), - ); + let mut search = + super::mcts::Search::new(backend.as_ref(), policy, value, self.cfg.search.clone()); let outcome = search.run(chosen.state.clone()).await?; self.curriculum.record_outcome(outcome.proof_found); @@ -205,14 +201,18 @@ impl Daemon { ) -> Result<()> { loop { let regime = self.curriculum.regime(); - tracing::debug!(?regime, attempts = self.attempts, pool = self.pool.len(), - "daemon tick"); + tracing::debug!( + ?regime, + attempts = self.attempts, + pool = self.pool.len(), + "daemon tick" + ); match self.step(policy.clone(), value.clone()).await? { - Some(_) => {} + Some(_) => {}, None => { tracing::info!("daemon: pool exhausted — pausing"); sleep(self.cfg.tick_pause * 10).await; - } + }, } if self.cfg.tick_pause > Duration::ZERO { sleep(self.cfg.tick_pause).await; diff --git a/src/rust/learning/mcts.rs b/src/rust/learning/mcts.rs index 47d77a3..e9aeb7d 100644 --- a/src/rust/learning/mcts.rs +++ b/src/rust/learning/mcts.rs @@ -38,11 +38,8 @@ pub const UCB1_C: f64 = 1.4; /// `suggest_tactics` is a fine substitute. #[async_trait] pub trait TacticPolicy: Send + Sync { - async fn propose( - &self, - state: &ProofState, - top_k: usize, - ) -> anyhow::Result>; + async fn propose(&self, state: &ProofState, top_k: usize) + -> anyhow::Result>; } /// Abstract value head: given a state, return an estimate of @@ -163,7 +160,11 @@ impl<'a> Search<'a> { if let Some(&idx) = self.state_index.get(&key) { return idx; } - let terminal = if state.goals.is_empty() { Some(true) } else { None }; + let terminal = if state.goals.is_empty() { + Some(true) + } else { + None + }; let idx = self.nodes.len(); self.nodes.push(Node { state, @@ -179,9 +180,7 @@ impl<'a> Search<'a> { } fn select(&self, mut node: usize) -> usize { - while !self.nodes[node].children.is_empty() - && self.nodes[node].terminal.is_none() - { + while !self.nodes[node].children.is_empty() && self.nodes[node].terminal.is_none() { let parent_visits = self.nodes[node].visits.max(1); let mut best_child = None; let mut best_score = f64::NEG_INFINITY; @@ -228,7 +227,7 @@ impl<'a> Search<'a> { closed.goals.clear(); closed.proof_script.push(tactic.clone()); closed - } + }, }; let child = self.register(next_state, Some(leaf), prior); self.nodes[leaf].children.push((tactic, child)); @@ -279,7 +278,11 @@ impl<'a> Search<'a> { } fn state_key(state: &ProofState) -> String { - let goals: Vec<_> = state.goals.iter().map(|g| format!("{}", g.target)).collect(); + let goals: Vec<_> = state + .goals + .iter() + .map(|g| format!("{}", g.target)) + .collect(); goals.join("||") } diff --git a/src/rust/learning/self_play.rs b/src/rust/learning/self_play.rs index b55b56b..da66074 100644 --- a/src/rust/learning/self_play.rs +++ b/src/rust/learning/self_play.rs @@ -76,7 +76,10 @@ impl SelfPlayGenerator { Some(Variant { kind: VariantKind::AlphaRename, state: new_state, - rationale: format!("alpha-renamed bound variables (cycle {})", self.alpha_counter), + rationale: format!( + "alpha-renamed bound variables (cycle {})", + self.alpha_counter + ), }) } diff --git a/src/rust/lib.rs b/src/rust/lib.rs index a64afd9..dce0444 100644 --- a/src/rust/lib.rs +++ b/src/rust/lib.rs @@ -26,11 +26,10 @@ pub mod parsers; pub mod proof_encoding; // CBOR encoding + proof identity hashing pub mod proof_search; // Chapel parallel proof search (optional feature) pub mod provers; -pub mod types; // Native type-system decorations (multiplicity, effects, modality, temporal, semiring, …) +pub mod vcl_ut; pub mod verification; #[cfg(feature = "verisim")] -pub mod verisim_bridge; // VeriSimDB 8-modality octad integration -pub mod vcl_ut; // VCL-UT: 10-level type-safe cross-prover query language +pub mod verisim_bridge; // VeriSimDB 8-modality octad integration // VCL-UT: 10-level type-safe cross-prover query language pub use agent::{AgentConfig, AgentCore}; pub use core::{ProofState, Tactic, TacticResult, Term}; diff --git a/src/rust/proof_encoding.rs b/src/rust/proof_encoding.rs index ebfdd91..c04aaa0 100644 --- a/src/rust/proof_encoding.rs +++ b/src/rust/proof_encoding.rs @@ -154,8 +154,8 @@ mod tests { hypotheses: vec![], }; - let id1 = proof_identity("my_theorem", &goal, ProverKind::Lean); - let id2 = proof_identity("my_theorem", &goal, ProverKind::Lean); + let id1 = proof_identity("my_theorem", &goal, ProverKind::Lean4); + let id2 = proof_identity("my_theorem", &goal, ProverKind::Lean4); assert_eq!(id1, id2, "Same inputs must produce same identity"); } @@ -167,7 +167,7 @@ mod tests { hypotheses: vec![], }; - let lean = proof_identity("thm", &goal, ProverKind::Lean); + let lean = proof_identity("thm", &goal, ProverKind::Lean4); let coq = proof_identity("thm", &goal, ProverKind::Coq); assert_ne!( lean, coq, diff --git a/src/rust/provers/abc.rs b/src/rust/provers/abc.rs index da267f9..83a7960 100644 --- a/src/rust/provers/abc.rs +++ b/src/rust/provers/abc.rs @@ -269,7 +269,6 @@ impl AbcBackend { name: input_name.to_string(), ty: Term::Const("BLIF_INPUT".to_string()), body: Term::Const(input_name.to_string()), - type_info: None, }); } } diff --git a/src/rust/provers/abella.rs b/src/rust/provers/abella.rs index cc11e63..2e9f5fb 100644 --- a/src/rust/provers/abella.rs +++ b/src/rust/provers/abella.rs @@ -64,8 +64,11 @@ impl ProverBackend for AbellaBackend { match output { Ok(out) if out.status.success() => { Ok(String::from_utf8_lossy(&out.stdout).trim().to_string()) - } - Ok(out) => Ok(format!("abella@unavailable (status {:?})", out.status.code())), + }, + Ok(out) => Ok(format!( + "abella@unavailable (status {:?})", + out.status.code() + )), Err(_) => Ok("abella@not-installed".to_string()), } } @@ -144,13 +147,13 @@ impl ProverBackend for AbellaBackend { // partial scripts). let stdout = String::from_utf8_lossy(&out.stdout); Ok(stdout.contains("Proof completed.") || !stdout.contains("Error")) - } + }, Ok(out) => { let stderr = String::from_utf8_lossy(&out.stderr); tracing::debug!(status = ?out.status.code(), "Abella: verify_proof rejected"); tracing::trace!(stderr = %stderr); Ok(false) - } + }, Err(e) => Err(anyhow!("Abella: binary not runnable: {}", e)), } } diff --git a/src/rust/provers/acl2.rs b/src/rust/provers/acl2.rs index 370747f..70c28fc 100644 --- a/src/rust/provers/acl2.rs +++ b/src/rust/provers/acl2.rs @@ -828,7 +828,8 @@ impl ACL2Backend { fn sexp_to_term(&self, sexp: &SExp) -> Term { match sexp { SExp::Atom(s) => { - if s.starts_with(':') || s.chars().next().map(|c| c.is_uppercase()).unwrap_or(false) { + if s.starts_with(':') || s.chars().next().map(|c| c.is_uppercase()).unwrap_or(false) + { Term::Const(s.clone()) } else { Term::Var(s.clone()) @@ -980,18 +981,6 @@ impl ACL2Backend { ]) } }, - Term::Sigma { - param: _, - param_type, - body, - } => { - // ACL2 has no dependent pairs; approximate with (and A B). - SExp::List(vec![ - SExp::Atom("and".to_string()), - self.term_to_sexp(param_type), - self.term_to_sexp(body), - ]) - }, Term::Let { name, value, body, .. } => SExp::List(vec![ @@ -1262,7 +1251,6 @@ impl ProverBackend for ACL2Backend { name, ty: Term::Universe(0), // ACL2 doesn't have explicit types body: body_term, - type_info: None, }); }, ACL2Event::Defthm { @@ -1304,7 +1292,6 @@ impl ProverBackend for ACL2Backend { name, ty: Term::Universe(0), body: value_term, - type_info: None, }); }, _ => {}, diff --git a/src/rust/provers/acl2s.rs b/src/rust/provers/acl2s.rs index 85d0b8f..ad6e041 100644 --- a/src/rust/provers/acl2s.rs +++ b/src/rust/provers/acl2s.rs @@ -49,7 +49,7 @@ impl ProverBackend for Acl2sBackend { match output { Ok(out) if out.status.success() => { Ok(String::from_utf8_lossy(&out.stdout).trim().to_string()) - } + }, Ok(_) => Ok("acl2s@unavailable".to_string()), Err(_) => Ok("acl2s@not-installed".to_string()), } @@ -102,7 +102,10 @@ impl ProverBackend for Acl2sBackend { .await .context("ACL2s: writing input")?; let mut cmd = Command::new(self.binary()); - cmd.arg("-f").arg(&input).stdout(Stdio::piped()).stderr(Stdio::piped()); + cmd.arg("-f") + .arg(&input) + .stdout(Stdio::piped()) + .stderr(Stdio::piped()); for arg in &self.config.args { cmd.arg(arg); } diff --git a/src/rust/provers/agda.rs b/src/rust/provers/agda.rs index 1083db1..27907cf 100644 --- a/src/rust/provers/agda.rs +++ b/src/rust/provers/agda.rs @@ -134,16 +134,6 @@ impl AgdaBackend { let body_str = self.term_to_agda(body); format!("({} : {}) → {}", param, param_ty_str, body_str) }, - Term::Sigma { - param, - param_type, - body, - } => { - // Agda: Σ A λ x → B (standard-library) - let param_ty_str = self.term_to_agda(param_type); - let body_str = self.term_to_agda(body); - format!("Σ {} λ {} → {}", param_ty_str, param, body_str) - }, Term::Universe(level) | Term::Type(level) => { if *level == 0 { "Set".to_string() @@ -273,7 +263,6 @@ impl ProverBackend for AgdaBackend { name: name.clone(), ty: type_term.clone(), body: type_term, - type_info: None, }); }, AgdaDecl::TypeSig { name, ty } => { @@ -329,7 +318,6 @@ impl ProverBackend for AgdaBackend { name: param_name, ty: Term::Universe(0), body: None, - type_info: None, }); } Ok(TacticResult::Success(new_state)) diff --git a/src/rust/provers/alloy.rs b/src/rust/provers/alloy.rs index a0a76ec..e87a734 100644 --- a/src/rust/provers/alloy.rs +++ b/src/rust/provers/alloy.rs @@ -161,7 +161,6 @@ impl AlloyBackend { name: trimmed.to_string(), ty: Term::Const("ALLOY_DEF".to_string()), body: Term::Const(trimmed.to_string()), - type_info: None, }); } @@ -171,7 +170,6 @@ impl AlloyBackend { name: trimmed.to_string(), ty: Term::Const("ALLOY_DEF".to_string()), body: Term::Const(trimmed.to_string()), - type_info: None, }); } diff --git a/src/rust/provers/altergo.rs b/src/rust/provers/altergo.rs index 46bb184..60178d3 100644 --- a/src/rust/provers/altergo.rs +++ b/src/rust/provers/altergo.rs @@ -227,7 +227,10 @@ mod tests { let backend = AltErgoBackend::new(config); let mut state = ProofState::default(); - state.context.axioms.push("forall x: int. x >= 0".to_string()); + state + .context + .axioms + .push("forall x: int. x >= 0".to_string()); state.goals.push(Goal { id: "goal_0".to_string(), target: Term::Const("true".to_string()), diff --git a/src/rust/provers/arend.rs b/src/rust/provers/arend.rs index 969e51e..3637a44 100644 --- a/src/rust/provers/arend.rs +++ b/src/rust/provers/arend.rs @@ -8,57 +8,129 @@ //! Vendor: github.com/JetBrains/Arend #![allow(dead_code)] +use super::{ProverBackend, ProverConfig, ProverKind}; +use crate::core::{Context as ProofContext, Goal, ProofState, Tactic, TacticResult, Term}; use anyhow::{anyhow, Context as AnyhowContext, Result}; use async_trait::async_trait; use std::path::PathBuf; use std::process::Stdio; use tokio::process::Command; -use super::{ProverBackend, ProverConfig, ProverKind}; -use crate::core::{Context as ProofContext, Goal, ProofState, Tactic, TacticResult, Term}; -pub struct ArendBackend { config: ProverConfig } -impl ArendBackend { pub fn new(c: ProverConfig) -> Self { Self { config: c } } +pub struct ArendBackend { + config: ProverConfig, +} +impl ArendBackend { + pub fn new(c: ProverConfig) -> Self { + Self { config: c } + } fn binary(&self) -> PathBuf { - if self.config.executable.as_os_str().is_empty() { PathBuf::from("arend") } - else { self.config.executable.clone() } } } + if self.config.executable.as_os_str().is_empty() { + PathBuf::from("arend") + } else { + self.config.executable.clone() + } + } +} #[async_trait] impl ProverBackend for ArendBackend { - fn kind(&self) -> ProverKind { ProverKind::Arend } + fn kind(&self) -> ProverKind { + ProverKind::Arend + } async fn version(&self) -> Result { match Command::new(self.binary()).arg("--version").output().await { - Ok(o) if o.status.success() => Ok(String::from_utf8_lossy(&o.stdout).trim().to_string()), + Ok(o) if o.status.success() => { + Ok(String::from_utf8_lossy(&o.stdout).trim().to_string()) + }, Ok(_) => Ok("arend@unavailable".into()), - Err(_) => Ok("arend@not-installed".into()) } } + Err(_) => Ok("arend@not-installed".into()), + } + } async fn parse_file(&self, p: PathBuf) -> Result { - let c = tokio::fs::read_to_string(&p).await.with_context(|| format!("Arend: reading {}", p.display()))?; - self.parse_string(&c).await } + let c = tokio::fs::read_to_string(&p) + .await + .with_context(|| format!("Arend: reading {}", p.display()))?; + self.parse_string(&c).await + } async fn parse_string(&self, content: &str) -> Result { let mut s = ProofState { - goals: vec![Goal { id: "arend-file".into(), target: Term::Const(content.into()), hypotheses: vec![] }], - context: ProofContext::default(), proof_script: vec![], metadata: Default::default() }; - s.metadata.insert("arend_source".into(), serde_json::Value::String(content.into())); Ok(s) } + goals: vec![Goal { + id: "arend-file".into(), + target: Term::Const(content.into()), + hypotheses: vec![], + }], + context: ProofContext::default(), + proof_script: vec![], + metadata: Default::default(), + }; + s.metadata.insert( + "arend_source".into(), + serde_json::Value::String(content.into()), + ); + Ok(s) + } async fn apply_tactic(&self, s: &ProofState, t: &Tactic) -> Result { - let mut n = s.clone(); n.proof_script.push(t.clone()); Ok(TacticResult::Success(n)) } + let mut n = s.clone(); + n.proof_script.push(t.clone()); + Ok(TacticResult::Success(n)) + } async fn verify_proof(&self, state: &ProofState) -> Result { - let src: String = state.metadata.get("arend_source").and_then(|v| v.as_str()).map(String::from).unwrap_or_default(); - let dir = tempfile::Builder::new().prefix("echidna-arend-").tempdir().context("Arend: tempdir")?; + let src: String = state + .metadata + .get("arend_source") + .and_then(|v| v.as_str()) + .map(String::from) + .unwrap_or_default(); + let dir = tempfile::Builder::new() + .prefix("echidna-arend-") + .tempdir() + .context("Arend: tempdir")?; let input = dir.path().join("Check.ard"); - tokio::fs::write(&input, src.as_bytes()).await.context("Arend: writing")?; + tokio::fs::write(&input, src.as_bytes()) + .await + .context("Arend: writing")?; let mut cmd = Command::new(self.binary()); - cmd.arg(&input).stdout(Stdio::piped()).stderr(Stdio::piped()); - for a in &self.config.args { cmd.arg(a); } + cmd.arg(&input) + .stdout(Stdio::piped()) + .stderr(Stdio::piped()); + for a in &self.config.args { + cmd.arg(a); + } match cmd.output().await { Ok(o) if o.status.success() => Ok(true), Ok(_) => Ok(false), - Err(e) => Err(anyhow!("Arend: binary not runnable: {}", e)) } } + Err(e) => Err(anyhow!("Arend: binary not runnable: {}", e)), + } + } async fn export(&self, s: &ProofState) -> Result { - Ok(s.metadata.get("arend_source").and_then(|v| v.as_str()).map(String::from).unwrap_or_default()) } - async fn suggest_tactics(&self, _: &ProofState, _: usize) -> Result> { Ok(vec![]) } - async fn search_theorems(&self, _: &str) -> Result> { Ok(vec![]) } - fn config(&self) -> &ProverConfig { &self.config } - fn set_config(&mut self, c: ProverConfig) { self.config = c; } } + Ok(s.metadata + .get("arend_source") + .and_then(|v| v.as_str()) + .map(String::from) + .unwrap_or_default()) + } + async fn suggest_tactics(&self, _: &ProofState, _: usize) -> Result> { + Ok(vec![]) + } + async fn search_theorems(&self, _: &str) -> Result> { + Ok(vec![]) + } + fn config(&self) -> &ProverConfig { + &self.config + } + fn set_config(&mut self, c: ProverConfig) { + self.config = c; + } +} #[cfg(test)] -mod tests { use super::*; - #[test] fn kind_is_arend() { assert_eq!(ArendBackend::new(ProverConfig::default()).kind(), ProverKind::Arend); } } +mod tests { + use super::*; + #[test] + fn kind_is_arend() { + assert_eq!( + ArendBackend::new(ProverConfig::default()).kind(), + ProverKind::Arend + ); + } +} diff --git a/src/rust/provers/athena.rs b/src/rust/provers/athena.rs index 0909e85..5843e04 100644 --- a/src/rust/provers/athena.rs +++ b/src/rust/provers/athena.rs @@ -7,57 +7,129 @@ //! Vendor: github.com/AthenaFL/athena #![allow(dead_code)] +use super::{ProverBackend, ProverConfig, ProverKind}; +use crate::core::{Context as ProofContext, Goal, ProofState, Tactic, TacticResult, Term}; use anyhow::{anyhow, Context as AnyhowContext, Result}; use async_trait::async_trait; use std::path::PathBuf; use std::process::Stdio; use tokio::process::Command; -use super::{ProverBackend, ProverConfig, ProverKind}; -use crate::core::{Context as ProofContext, Goal, ProofState, Tactic, TacticResult, Term}; -pub struct AthenaBackend { config: ProverConfig } -impl AthenaBackend { pub fn new(c: ProverConfig) -> Self { Self { config: c } } +pub struct AthenaBackend { + config: ProverConfig, +} +impl AthenaBackend { + pub fn new(c: ProverConfig) -> Self { + Self { config: c } + } fn binary(&self) -> PathBuf { - if self.config.executable.as_os_str().is_empty() { PathBuf::from("athena") } - else { self.config.executable.clone() } } } + if self.config.executable.as_os_str().is_empty() { + PathBuf::from("athena") + } else { + self.config.executable.clone() + } + } +} #[async_trait] impl ProverBackend for AthenaBackend { - fn kind(&self) -> ProverKind { ProverKind::Athena } + fn kind(&self) -> ProverKind { + ProverKind::Athena + } async fn version(&self) -> Result { match Command::new(self.binary()).arg("--version").output().await { - Ok(o) if o.status.success() => Ok(String::from_utf8_lossy(&o.stdout).trim().to_string()), + Ok(o) if o.status.success() => { + Ok(String::from_utf8_lossy(&o.stdout).trim().to_string()) + }, Ok(_) => Ok("athena@unavailable".into()), - Err(_) => Ok("athena@not-installed".into()) } } + Err(_) => Ok("athena@not-installed".into()), + } + } async fn parse_file(&self, p: PathBuf) -> Result { - let c = tokio::fs::read_to_string(&p).await.with_context(|| format!("Athena: reading {}", p.display()))?; - self.parse_string(&c).await } + let c = tokio::fs::read_to_string(&p) + .await + .with_context(|| format!("Athena: reading {}", p.display()))?; + self.parse_string(&c).await + } async fn parse_string(&self, content: &str) -> Result { let mut s = ProofState { - goals: vec![Goal { id: "athena-file".into(), target: Term::Const(content.into()), hypotheses: vec![] }], - context: ProofContext::default(), proof_script: vec![], metadata: Default::default() }; - s.metadata.insert("athena_source".into(), serde_json::Value::String(content.into())); Ok(s) } + goals: vec![Goal { + id: "athena-file".into(), + target: Term::Const(content.into()), + hypotheses: vec![], + }], + context: ProofContext::default(), + proof_script: vec![], + metadata: Default::default(), + }; + s.metadata.insert( + "athena_source".into(), + serde_json::Value::String(content.into()), + ); + Ok(s) + } async fn apply_tactic(&self, s: &ProofState, t: &Tactic) -> Result { - let mut n = s.clone(); n.proof_script.push(t.clone()); Ok(TacticResult::Success(n)) } + let mut n = s.clone(); + n.proof_script.push(t.clone()); + Ok(TacticResult::Success(n)) + } async fn verify_proof(&self, state: &ProofState) -> Result { - let src: String = state.metadata.get("athena_source").and_then(|v| v.as_str()).map(String::from).unwrap_or_default(); - let dir = tempfile::Builder::new().prefix("echidna-athena-").tempdir().context("Athena: tempdir")?; + let src: String = state + .metadata + .get("athena_source") + .and_then(|v| v.as_str()) + .map(String::from) + .unwrap_or_default(); + let dir = tempfile::Builder::new() + .prefix("echidna-athena-") + .tempdir() + .context("Athena: tempdir")?; let input = dir.path().join("check.ath"); - tokio::fs::write(&input, src.as_bytes()).await.context("Athena: writing")?; + tokio::fs::write(&input, src.as_bytes()) + .await + .context("Athena: writing")?; let mut cmd = Command::new(self.binary()); - cmd.arg(&input).stdout(Stdio::piped()).stderr(Stdio::piped()); - for a in &self.config.args { cmd.arg(a); } + cmd.arg(&input) + .stdout(Stdio::piped()) + .stderr(Stdio::piped()); + for a in &self.config.args { + cmd.arg(a); + } match cmd.output().await { Ok(o) if o.status.success() => Ok(true), Ok(_) => Ok(false), - Err(e) => Err(anyhow!("Athena: binary not runnable: {}", e)) } } + Err(e) => Err(anyhow!("Athena: binary not runnable: {}", e)), + } + } async fn export(&self, s: &ProofState) -> Result { - Ok(s.metadata.get("athena_source").and_then(|v| v.as_str()).map(String::from).unwrap_or_default()) } - async fn suggest_tactics(&self, _: &ProofState, _: usize) -> Result> { Ok(vec![]) } - async fn search_theorems(&self, _: &str) -> Result> { Ok(vec![]) } - fn config(&self) -> &ProverConfig { &self.config } - fn set_config(&mut self, c: ProverConfig) { self.config = c; } } + Ok(s.metadata + .get("athena_source") + .and_then(|v| v.as_str()) + .map(String::from) + .unwrap_or_default()) + } + async fn suggest_tactics(&self, _: &ProofState, _: usize) -> Result> { + Ok(vec![]) + } + async fn search_theorems(&self, _: &str) -> Result> { + Ok(vec![]) + } + fn config(&self) -> &ProverConfig { + &self.config + } + fn set_config(&mut self, c: ProverConfig) { + self.config = c; + } +} #[cfg(test)] -mod tests { use super::*; - #[test] fn kind_is_athena() { assert_eq!(AthenaBackend::new(ProverConfig::default()).kind(), ProverKind::Athena); } } +mod tests { + use super::*; + #[test] + fn kind_is_athena() { + assert_eq!( + AthenaBackend::new(ProverConfig::default()).kind(), + ProverKind::Athena + ); + } +} diff --git a/src/rust/provers/boogie.rs b/src/rust/provers/boogie.rs index 14ddf1a..6f5a699 100644 --- a/src/rust/provers/boogie.rs +++ b/src/rust/provers/boogie.rs @@ -52,7 +52,7 @@ impl ProverBackend for BoogieBackend { match output { Ok(out) if out.status.success() => { Ok(String::from_utf8_lossy(&out.stdout).trim().to_string()) - } + }, Ok(_) => Ok("boogie@unavailable".to_string()), Err(_) => Ok("boogie@not-installed".to_string()), } @@ -105,7 +105,9 @@ impl ProverBackend for BoogieBackend { .await .context("Boogie: writing input")?; let mut cmd = Command::new(self.binary()); - cmd.arg(&input).stdout(Stdio::piped()).stderr(Stdio::piped()); + cmd.arg(&input) + .stdout(Stdio::piped()) + .stderr(Stdio::piped()); for arg in &self.config.args { cmd.arg(arg); } @@ -114,8 +116,9 @@ impl ProverBackend for BoogieBackend { // Boogie prints "0 errors" on full success; non-zero errors // in stdout even with exit 0 means verification failed. let stdout = String::from_utf8_lossy(&out.stdout); - Ok(stdout.contains("0 errors") || stdout.contains("Boogie program verifier finished with")) - } + Ok(stdout.contains("0 errors") + || stdout.contains("Boogie program verifier finished with")) + }, Ok(_) => Ok(false), Err(e) => Err(anyhow!("Boogie: binary not runnable: {}", e)), } diff --git a/src/rust/provers/cadical.rs b/src/rust/provers/cadical.rs index 73c94a2..e98f053 100644 --- a/src/rust/provers/cadical.rs +++ b/src/rust/provers/cadical.rs @@ -536,10 +536,7 @@ mod tests { fn test_term_to_clause_or_app() { let term = Term::App { func: Box::new(Term::Const("or".to_string())), - args: vec![ - Term::Const("1".to_string()), - Term::Const("2".to_string()), - ], + args: vec![Term::Const("1".to_string()), Term::Const("2".to_string())], }; let clause = CaDiCaLBackend::term_to_clause(&term); assert_eq!(clause, vec![1, 2]); diff --git a/src/rust/provers/cameleer.rs b/src/rust/provers/cameleer.rs index 1fd48f4..556d0b5 100644 --- a/src/rust/provers/cameleer.rs +++ b/src/rust/provers/cameleer.rs @@ -56,7 +56,7 @@ impl ProverBackend for CameleerBackend { match output { Ok(out) if out.status.success() => { Ok(String::from_utf8_lossy(&out.stdout).trim().to_string()) - } + }, Ok(_) => Ok("cameleer@unavailable".to_string()), Err(_) => Ok("cameleer@not-installed".to_string()), } @@ -109,7 +109,9 @@ impl ProverBackend for CameleerBackend { .await .context("Cameleer: writing input")?; let mut cmd = Command::new(self.binary()); - cmd.arg(&input).stdout(Stdio::piped()).stderr(Stdio::piped()); + cmd.arg(&input) + .stdout(Stdio::piped()) + .stderr(Stdio::piped()); for arg in &self.config.args { cmd.arg(arg); } diff --git a/src/rust/provers/coq.rs b/src/rust/provers/coq.rs index e36c81d..80f256b 100644 --- a/src/rust/provers/coq.rs +++ b/src/rust/provers/coq.rs @@ -866,7 +866,6 @@ impl ProverBackend for CoqBackend { name, ty: def_type, body, - type_info: None, }); }, CoqStatement::Tactic(tactic_str) => { diff --git a/src/rust/provers/cvc5.rs b/src/rust/provers/cvc5.rs index fd219b6..127a608 100644 --- a/src/rust/provers/cvc5.rs +++ b/src/rust/provers/cvc5.rs @@ -427,7 +427,6 @@ impl CVC5Backend { state.context.variables.push(crate::core::Variable { name: name.to_string(), ty: Term::Const(ty.trim().to_string()), - type_info: None, }); } continue; @@ -475,20 +474,19 @@ impl CVC5Backend { .trim(); assertions.push(inner.to_string()); } - if trimmed.starts_with("(check-sat") - && !assertions.is_empty() { - let combined = if assertions.len() == 1 { - assertions[0].clone() - } else { - format!("(and {})", assertions.join(" ")) - }; - let goal_term = self.smtlib_to_term(&combined)?; - state.goals.push(Goal { - id: "smt_goal".to_string(), - target: goal_term, - hypotheses: vec![], - }); - } + if trimmed.starts_with("(check-sat") && !assertions.is_empty() { + let combined = if assertions.len() == 1 { + assertions[0].clone() + } else { + format!("(and {})", assertions.join(" ")) + }; + let goal_term = self.smtlib_to_term(&combined)?; + state.goals.push(Goal { + id: "smt_goal".to_string(), + target: goal_term, + hypotheses: vec![], + }); + } } if state.goals.is_empty() && !assertions.is_empty() { diff --git a/src/rust/provers/dedukti.rs b/src/rust/provers/dedukti.rs index 6ba8a0b..978abd9 100644 --- a/src/rust/provers/dedukti.rs +++ b/src/rust/provers/dedukti.rs @@ -59,8 +59,11 @@ impl ProverBackend for DeduktiBackend { match output { Ok(out) if out.status.success() => { Ok(String::from_utf8_lossy(&out.stdout).trim().to_string()) - } - Ok(out) => Ok(format!("dedukti@unavailable (status {:?})", out.status.code())), + }, + Ok(out) => Ok(format!( + "dedukti@unavailable (status {:?})", + out.status.code() + )), Err(_) => Ok("dedukti@not-installed".to_string()), } } @@ -112,7 +115,10 @@ impl ProverBackend for DeduktiBackend { .await .context("Dedukti: writing input")?; let mut cmd = Command::new(self.binary()); - cmd.arg("-q").arg(&input).stdout(Stdio::piped()).stderr(Stdio::piped()); + cmd.arg("-q") + .arg(&input) + .stdout(Stdio::piped()) + .stderr(Stdio::piped()); for arg in &self.config.args { cmd.arg(arg); } diff --git a/src/rust/provers/eprover.rs b/src/rust/provers/eprover.rs index a4d0996..75ccfb2 100644 --- a/src/rust/provers/eprover.rs +++ b/src/rust/provers/eprover.rs @@ -232,8 +232,12 @@ mod tests { let config = ProverConfig::default(); let backend = EProverBackend::new(config); - assert!(backend.parse_result("# Proof found!\n# SZS status Theorem\n").unwrap()); - assert!(backend.parse_result("# SZS status Unsatisfiable\n").unwrap()); + assert!(backend + .parse_result("# Proof found!\n# SZS status Theorem\n") + .unwrap()); + assert!(backend + .parse_result("# SZS status Unsatisfiable\n") + .unwrap()); } #[test] @@ -241,7 +245,9 @@ mod tests { let config = ProverConfig::default(); let backend = EProverBackend::new(config); - assert!(!backend.parse_result("# SZS status CounterSatisfiable\n").unwrap()); + assert!(!backend + .parse_result("# SZS status CounterSatisfiable\n") + .unwrap()); assert!(!backend.parse_result("# SZS status Satisfiable\n").unwrap()); } diff --git a/src/rust/provers/fstar.rs b/src/rust/provers/fstar.rs index 1a26c42..fd2cbc3 100644 --- a/src/rust/provers/fstar.rs +++ b/src/rust/provers/fstar.rs @@ -17,7 +17,6 @@ use tokio::process::Command; use super::{ProverBackend, ProverConfig, ProverKind}; use crate::core::{Goal, ProofState, Tactic, TacticResult, Term}; -use crate::types::{Effect, TypeInfo}; /// F* backend pub struct FStarBackend { @@ -34,51 +33,12 @@ impl FStarBackend { for (i, axiom) in state.context.axioms.iter().enumerate() { input.push_str(&format!("assume val axiom_{} : {}\n", i, axiom)); } - // Emit definitions with effect and refinement annotations from TypeInfo - for def in &state.context.definitions { - let effect_str = def - .type_info - .as_ref() - .map(Self::effect_to_fstar) - .unwrap_or_default(); - let refinement_str = def - .type_info - .as_ref() - .and_then(|ti| ti.refinement.as_ref()) - .map(|pred| format!("{{v:{} | {}}}", def.ty, pred)) - .unwrap_or_else(|| format!("{}", def.ty)); - input.push_str(&format!("val {} : {}{}\n", def.name, effect_str, refinement_str)); - } if let Some(goal) = state.goals.first() { input.push_str(&format!("\nval goal : {}\n", goal.target)); } Ok(input) } - /// Convert effect row from [`TypeInfo`] to an F* effect annotation prefix. - fn effect_to_fstar(ti: &TypeInfo) -> String { - if ti.effects.is_empty() { - return String::new(); - } - let effect_name = ti - .effects - .effects - .first() - .map(|e| match e { - Effect::Pure | Effect::Tot => "Tot", - Effect::IO => "IO", - Effect::State => "ST", - Effect::Exception => "Exn", - Effect::Div => "Div", - Effect::Ghost => "GTot", - Effect::NonDet => "ALL", - Effect::Async => "ALL", - Effect::Custom(s) => s.as_str(), - }) - .unwrap_or("Tot"); - format!("{} ", effect_name) - } - fn parse_result(&self, output: &str) -> Result { let lower = output.to_lowercase(); if lower.contains("verified") || lower.contains("all verification conditions discharged") { diff --git a/src/rust/provers/hol4.rs b/src/rust/provers/hol4.rs index 5cd30ed..6744ed5 100644 --- a/src/rust/provers/hol4.rs +++ b/src/rust/provers/hol4.rs @@ -1502,17 +1502,6 @@ impl Hol4Backend { var_type: Some(Self::term_to_type(param_type)), body: Box::new(Self::term_to_hol4(body)), }, - Term::Sigma { - param, - param_type, - body, - } => HOL4Term::Quant { - // HOL4 has no dependent pair; approximate with Exists. - quantifier: HOL4Quantifier::Exists, - var: param.clone(), - var_type: Some(Self::term_to_type(param_type)), - body: Box::new(Self::term_to_hol4(body)), - }, Term::Let { name, value, body, .. } => HOL4Term::Let { @@ -2177,7 +2166,6 @@ impl ProverBackend for Hol4Backend { name: name.clone(), ty: Self::hol4_to_term(body), body: None, - type_info: None, }); }, _ => {}, diff --git a/src/rust/provers/hol_light.rs b/src/rust/provers/hol_light.rs index 262206e..97fc369 100644 --- a/src/rust/provers/hol_light.rs +++ b/src/rust/provers/hol_light.rs @@ -262,19 +262,6 @@ impl HolLightBackend { self.term_to_hol(body) ) }, - Term::Sigma { - param, - param_type, - body, - } => { - // HOL Light has no dependent pairs; use existential approximation - format!( - "(?{} : {}. {})", - param, - self.term_to_hol(param_type), - self.term_to_hol(body) - ) - }, Term::Universe(level) | Term::Type(level) => format!("Type{}", level), Term::Sort(level) => format!("Sort{}", level), Term::Let { @@ -465,7 +452,6 @@ impl ProverBackend for HolLightBackend { data: serde_json::json!(def.def_type.clone()), }, body: def_term, - type_info: None, }); } diff --git a/src/rust/provers/hp_ecosystem.rs b/src/rust/provers/hp_ecosystem.rs index b8f7fd0..9fe79ad 100644 --- a/src/rust/provers/hp_ecosystem.rs +++ b/src/rust/provers/hp_ecosystem.rs @@ -115,9 +115,13 @@ impl HPEcosystemBackend { // Binder-management family (nominal logic / HOAS / λ-tree syntax). ProverKind::NominalTypeChecker => ("typell", "nominal"), other => { - debug_assert!(false, "non-HP kind routed to HPEcosystemBackend: {:?}", other); + debug_assert!( + false, + "non-HP kind routed to HPEcosystemBackend: {:?}", + other + ); ("typell", "typell") - } + }, } } @@ -170,8 +174,11 @@ impl ProverBackend for HPEcosystemBackend { } else { Ok(s) } - } - Err(_) => Ok(format!("{}@hp-ecosystem:unreachable", self.discipline_tag())), + }, + Err(_) => Ok(format!( + "{}@hp-ecosystem:unreachable", + self.discipline_tag() + )), } } @@ -186,7 +193,9 @@ impl ProverBackend for HPEcosystemBackend { /// header line `#discipline: ` followed by the body; if absent, /// we inject one using this backend's discipline. async fn parse_string(&self, content: &str) -> Result { - let has_header = content.lines().next() + let has_header = content + .lines() + .next() .map(|l| l.trim_start().starts_with("#discipline:")) .unwrap_or(false); let body = if has_header { @@ -241,7 +250,9 @@ impl ProverBackend for HPEcosystemBackend { .prefix("echidna-hp-") .tempdir() .context("HP ecosystem: tempdir")?; - let input = tmp_dir.path().join(format!("check.{}.src", self.discipline_tag())); + let input = tmp_dir + .path() + .join(format!("check.{}.src", self.discipline_tag())); tokio::fs::write(&input, body.as_bytes()) .await .context("HP ecosystem: writing input")?; @@ -258,7 +269,7 @@ impl ProverBackend for HPEcosystemBackend { ); tracing::trace!(discipline = self.discipline_tag(), stderr = %stderr); Ok(false) - } + }, Err(e) => Err(anyhow!( "HP ecosystem ({}): upstream CLI not runnable: {}", self.discipline_tag(), @@ -312,7 +323,8 @@ mod tests { fn upstream_routing_distinguishes_disciplines() { let tll = HPEcosystemBackend::new(ProverKind::TypeLL, ProverConfig::default()); let kat = HPEcosystemBackend::new(ProverKind::KatagoriaVerifier, ProverConfig::default()); - let trop = HPEcosystemBackend::new(ProverKind::TropicalTypeChecker, ProverConfig::default()); + let trop = + HPEcosystemBackend::new(ProverKind::TropicalTypeChecker, ProverConfig::default()); let modal = HPEcosystemBackend::new(ProverKind::ModalTypeChecker, ProverConfig::default()); assert_eq!(tll.upstream().0, "typell"); diff --git a/src/rust/provers/idris2.rs b/src/rust/provers/idris2.rs index 64d24e3..441a99d 100644 --- a/src/rust/provers/idris2.rs +++ b/src/rust/provers/idris2.rs @@ -30,7 +30,6 @@ use crate::core::{ Theorem, }; use crate::provers::{ProverBackend, ProverConfig, ProverKind}; -use crate::types::Multiplicity; /// Idris 2 backend implementation pub struct Idris2Backend { @@ -106,6 +105,17 @@ enum Idris2Term { AutoImplicit(String, Box), } +/// Quantitative type theory multiplicities +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +enum Multiplicity { + /// Unrestricted (0, 1, or many uses) + Unrestricted, + /// Linear (exactly 1 use) + Linear, + /// Erased (0 uses at runtime) + Erased, +} + impl Idris2Backend { pub fn new(config: ProverConfig) -> Self { Idris2Backend { @@ -168,17 +178,6 @@ impl Idris2Backend { } } - /// Convert a [`Multiplicity`] to the Idris 2 QTT annotation string. - fn multiplicity_to_idris2(m: &Multiplicity) -> &'static str { - match m { - Multiplicity::Zero => "0", - Multiplicity::One | Multiplicity::Linear => "1", - Multiplicity::Omega | Multiplicity::Shared => "", - Multiplicity::Affine => "1", // closest QTT approximation - Multiplicity::Graded(_) => "", - } - } - /// Convert universal Term to Idris 2 syntax fn term_to_idris2(&self, term: &Term) -> String { match term { @@ -233,16 +232,6 @@ impl Idris2Backend { format!("({} : {}) -> {}", param, param_ty_str, body_str) } }, - Term::Sigma { - param, - param_type, - body, - } => { - // Idris2: (x : A ** B x) is dependent-pair syntax - let param_ty_str = self.term_to_idris2(param_type); - let body_str = self.term_to_idris2(body); - format!("({} : {} ** {})", param, param_ty_str, body_str) - }, Term::Type(level) | Term::Universe(level) => { if *level == 0 { "Type".to_string() @@ -506,7 +495,6 @@ impl ProverBackend for Idris2Backend { name: name.clone(), ty: self.parse_type_expr(&ty_str), body: Term::Const(name.clone()), - type_info: None, }); // Add constructors as theorems @@ -534,7 +522,6 @@ impl ProverBackend for Idris2Backend { name: name.clone(), ty: self.parse_type_expr(&ty_str), body: Term::Const(name.clone()), - type_info: None, }); // Add field projections @@ -570,7 +557,6 @@ impl ProverBackend for Idris2Backend { body: Box::new(Term::Type(0)), }, body: Term::Const(name.clone()), - type_info: None, }); // Methods as theorems @@ -630,7 +616,6 @@ impl ProverBackend for Idris2Backend { name: param_name.clone(), ty: Term::Type(0), // Placeholder body: None, - type_info: None, }); // Update goal target if it's a Pi type @@ -675,10 +660,10 @@ impl ProverBackend for Idris2Backend { // Check if goal is an equality that can be solved by Refl if let Term::App { func, args } = &goal.target { if let Term::Const(name) = func.as_ref() { - if (name == "Equal" || name == "=" || name == "(=)") - && args.len() >= 2 { - // Could check if args are equal here - } + if (name == "Equal" || name == "=" || name == "(=)") && args.len() >= 2 + { + // Could check if args are equal here + } } } } @@ -816,17 +801,11 @@ impl ProverBackend for Idris2Backend { output.push_str("import Data.Vect\n"); output.push_str("import Data.Nat\n\n"); - // Definitions (emit QTT multiplicity annotations when present) + // Definitions for def in &state.context.definitions { let ty_str = self.term_to_idris2(&def.ty); let body_str = self.term_to_idris2(&def.body); - let mult_prefix = def - .type_info - .as_ref() - .and_then(|ti| ti.multiplicity.as_ref()) - .map(|m| format!("{} ", Self::multiplicity_to_idris2(m))) - .unwrap_or_default(); - output.push_str(&format!("{}{} : {}\n", mult_prefix, def.name, ty_str)); + output.push_str(&format!("{} : {}\n", def.name, ty_str)); output.push_str(&format!("{} = {}\n\n", def.name, body_str)); } @@ -1217,7 +1196,7 @@ mod tests { // Test Pi type let pi_term = Idris2Term::Pi( "a".to_string(), - Multiplicity::Omega, + Multiplicity::Unrestricted, Box::new(Idris2Term::Type), Box::new(Idris2Term::Var("a".to_string())), ); diff --git a/src/rust/provers/isabelle.rs b/src/rust/provers/isabelle.rs index 41a1af2..97145b0 100644 --- a/src/rust/provers/isabelle.rs +++ b/src/rust/provers/isabelle.rs @@ -91,10 +91,7 @@ fn extract_theory_name(content: &str) -> Option { } else { continue; } - let name = rest - .split_whitespace() - .next() - .map(|s| s.to_string()); + let name = rest.split_whitespace().next().map(|s| s.to_string()); if name.is_some() { return name; } @@ -431,7 +428,6 @@ impl ProverBackend for IsabelleBackend { name: "IH".to_string(), ty: goal.target.clone(), body: None, - type_info: None, }); hyps }, diff --git a/src/rust/provers/isabelle_zf.rs b/src/rust/provers/isabelle_zf.rs index aceb495..0948c4b 100644 --- a/src/rust/provers/isabelle_zf.rs +++ b/src/rust/provers/isabelle_zf.rs @@ -107,8 +107,10 @@ impl ProverBackend for IsabelleZfBackend { .context("Isabelle/ZF: writing input")?; let mut cmd = Command::new(self.binary()); cmd.arg("build") - .arg("-d").arg(tmp_dir.path()) - .arg("-l").arg("ZF") // ZF object logic + .arg("-d") + .arg(tmp_dir.path()) + .arg("-l") + .arg("ZF") // ZF object logic .arg("Check") .stdout(Stdio::piped()) .stderr(Stdio::piped()); diff --git a/src/rust/provers/key.rs b/src/rust/provers/key.rs index 55370ba..a8e16b0 100644 --- a/src/rust/provers/key.rs +++ b/src/rust/provers/key.rs @@ -419,7 +419,10 @@ impl ProverBackend for KeyBackend { } else { goals }, - context: crate::core::Context { axioms, ..Default::default() }, + context: crate::core::Context { + axioms, + ..Default::default() + }, ..Default::default() }; Ok(state) @@ -481,7 +484,10 @@ impl ProverBackend for KeyBackend { let state = ProofState { goals: computed_goals, - context: crate::core::Context { axioms, ..Default::default() }, + context: crate::core::Context { + axioms, + ..Default::default() + }, ..Default::default() }; diff --git a/src/rust/provers/lambda_prolog.rs b/src/rust/provers/lambda_prolog.rs index f2c12e5..4867e05 100644 --- a/src/rust/provers/lambda_prolog.rs +++ b/src/rust/provers/lambda_prolog.rs @@ -9,57 +9,129 @@ //! Vendor: github.com/teyjus/teyjus or github.com/LPCIC/elpi #![allow(dead_code)] +use super::{ProverBackend, ProverConfig, ProverKind}; +use crate::core::{Context as ProofContext, Goal, ProofState, Tactic, TacticResult, Term}; use anyhow::{anyhow, Context as AnyhowContext, Result}; use async_trait::async_trait; use std::path::PathBuf; use std::process::Stdio; use tokio::process::Command; -use super::{ProverBackend, ProverConfig, ProverKind}; -use crate::core::{Context as ProofContext, Goal, ProofState, Tactic, TacticResult, Term}; -pub struct LambdaPrologBackend { config: ProverConfig } -impl LambdaPrologBackend { pub fn new(c: ProverConfig) -> Self { Self { config: c } } +pub struct LambdaPrologBackend { + config: ProverConfig, +} +impl LambdaPrologBackend { + pub fn new(c: ProverConfig) -> Self { + Self { config: c } + } fn binary(&self) -> PathBuf { - if self.config.executable.as_os_str().is_empty() { PathBuf::from("tjsim") } - else { self.config.executable.clone() } } } + if self.config.executable.as_os_str().is_empty() { + PathBuf::from("tjsim") + } else { + self.config.executable.clone() + } + } +} #[async_trait] impl ProverBackend for LambdaPrologBackend { - fn kind(&self) -> ProverKind { ProverKind::LambdaProlog } + fn kind(&self) -> ProverKind { + ProverKind::LambdaProlog + } async fn version(&self) -> Result { match Command::new(self.binary()).arg("--version").output().await { - Ok(o) if o.status.success() => Ok(String::from_utf8_lossy(&o.stdout).trim().to_string()), + Ok(o) if o.status.success() => { + Ok(String::from_utf8_lossy(&o.stdout).trim().to_string()) + }, Ok(_) => Ok("lambda-prolog@unavailable".into()), - Err(_) => Ok("lambda-prolog@not-installed".into()) } } + Err(_) => Ok("lambda-prolog@not-installed".into()), + } + } async fn parse_file(&self, p: PathBuf) -> Result { - let c = tokio::fs::read_to_string(&p).await.with_context(|| format!("λProlog: reading {}", p.display()))?; - self.parse_string(&c).await } + let c = tokio::fs::read_to_string(&p) + .await + .with_context(|| format!("λProlog: reading {}", p.display()))?; + self.parse_string(&c).await + } async fn parse_string(&self, content: &str) -> Result { let mut s = ProofState { - goals: vec![Goal { id: "lambdaprolog-file".into(), target: Term::Const(content.into()), hypotheses: vec![] }], - context: ProofContext::default(), proof_script: vec![], metadata: Default::default() }; - s.metadata.insert("lambda_prolog_source".into(), serde_json::Value::String(content.into())); Ok(s) } + goals: vec![Goal { + id: "lambdaprolog-file".into(), + target: Term::Const(content.into()), + hypotheses: vec![], + }], + context: ProofContext::default(), + proof_script: vec![], + metadata: Default::default(), + }; + s.metadata.insert( + "lambda_prolog_source".into(), + serde_json::Value::String(content.into()), + ); + Ok(s) + } async fn apply_tactic(&self, s: &ProofState, t: &Tactic) -> Result { - let mut n = s.clone(); n.proof_script.push(t.clone()); Ok(TacticResult::Success(n)) } + let mut n = s.clone(); + n.proof_script.push(t.clone()); + Ok(TacticResult::Success(n)) + } async fn verify_proof(&self, state: &ProofState) -> Result { - let src: String = state.metadata.get("lambda_prolog_source").and_then(|v| v.as_str()).map(String::from).unwrap_or_default(); - let dir = tempfile::Builder::new().prefix("echidna-lambda-prolog-").tempdir().context("λProlog: tempdir")?; + let src: String = state + .metadata + .get("lambda_prolog_source") + .and_then(|v| v.as_str()) + .map(String::from) + .unwrap_or_default(); + let dir = tempfile::Builder::new() + .prefix("echidna-lambda-prolog-") + .tempdir() + .context("λProlog: tempdir")?; let input = dir.path().join("check.mod"); - tokio::fs::write(&input, src.as_bytes()).await.context("λProlog: writing")?; + tokio::fs::write(&input, src.as_bytes()) + .await + .context("λProlog: writing")?; let mut cmd = Command::new(self.binary()); - cmd.arg(&input).stdout(Stdio::piped()).stderr(Stdio::piped()); - for a in &self.config.args { cmd.arg(a); } + cmd.arg(&input) + .stdout(Stdio::piped()) + .stderr(Stdio::piped()); + for a in &self.config.args { + cmd.arg(a); + } match cmd.output().await { Ok(o) if o.status.success() => Ok(true), Ok(_) => Ok(false), - Err(e) => Err(anyhow!("λProlog: binary not runnable: {}", e)) } } + Err(e) => Err(anyhow!("λProlog: binary not runnable: {}", e)), + } + } async fn export(&self, s: &ProofState) -> Result { - Ok(s.metadata.get("lambda_prolog_source").and_then(|v| v.as_str()).map(String::from).unwrap_or_default()) } - async fn suggest_tactics(&self, _: &ProofState, _: usize) -> Result> { Ok(vec![]) } - async fn search_theorems(&self, _: &str) -> Result> { Ok(vec![]) } - fn config(&self) -> &ProverConfig { &self.config } - fn set_config(&mut self, c: ProverConfig) { self.config = c; } } + Ok(s.metadata + .get("lambda_prolog_source") + .and_then(|v| v.as_str()) + .map(String::from) + .unwrap_or_default()) + } + async fn suggest_tactics(&self, _: &ProofState, _: usize) -> Result> { + Ok(vec![]) + } + async fn search_theorems(&self, _: &str) -> Result> { + Ok(vec![]) + } + fn config(&self) -> &ProverConfig { + &self.config + } + fn set_config(&mut self, c: ProverConfig) { + self.config = c; + } +} #[cfg(test)] -mod tests { use super::*; - #[test] fn kind_is_lambda_prolog() { assert_eq!(LambdaPrologBackend::new(ProverConfig::default()).kind(), ProverKind::LambdaProlog); } } +mod tests { + use super::*; + #[test] + fn kind_is_lambda_prolog() { + assert_eq!( + LambdaPrologBackend::new(ProverConfig::default()).kind(), + ProverKind::LambdaProlog + ); + } +} diff --git a/src/rust/provers/lean.rs b/src/rust/provers/lean.rs index ced1221..8df178b 100644 --- a/src/rust/provers/lean.rs +++ b/src/rust/provers/lean.rs @@ -369,19 +369,6 @@ impl LeanBackend { self.term_to_lean(body) ) }, - Term::Sigma { - param, - param_type, - body, - } => { - // Lean 4: Sigma types are `(x : A) × B x` or `Sigma (fun x => ...)` - format!( - "(({} : {}) × {})", - param, - self.term_to_lean(param_type), - self.term_to_lean(body) - ) - }, Term::Let { name, ty, @@ -595,8 +582,7 @@ impl LeanBackend { let parts: Vec<&str> = input.splitn(2, &['→', '-'][..]).collect(); if parts.len() == 2 { let domain = self.parse_lean_expr_simple(parts[0])?; - let codomain = - self.parse_lean_expr_simple(parts[1].trim_start_matches('>'))?; + let codomain = self.parse_lean_expr_simple(parts[1].trim_start_matches('>'))?; return Ok(LeanExpr::Pi( "_".to_string(), Box::new(domain), @@ -667,7 +653,6 @@ impl LeanBackend { name: name.clone(), ty: term_ty, body: term_val, - type_info: None, }); }, LeanDeclaration::Axiom { name, ty, .. } => { @@ -703,7 +688,6 @@ impl LeanBackend { name: h.name.clone(), ty: self.lean_expr_to_term(&h.ty), body: h.value.as_ref().map(|v| self.lean_expr_to_term(v)), - type_info: None, }) .collect(); @@ -1291,7 +1275,6 @@ impl ProverBackend for LeanBackend { name: h.name.clone(), ty: self.lean_expr_to_term(&h.ty), body: h.value.as_ref().map(|v| self.lean_expr_to_term(v)), - type_info: None, }) .collect(), }) diff --git a/src/rust/provers/lean3.rs b/src/rust/provers/lean3.rs index 8d2d0f4..5716c4d 100644 --- a/src/rust/provers/lean3.rs +++ b/src/rust/provers/lean3.rs @@ -68,7 +68,7 @@ impl ProverBackend for Lean3Backend { match output { Ok(out) if out.status.success() => { Ok(String::from_utf8_lossy(&out.stdout).trim().to_string()) - } + }, Ok(out) => Ok(format!( "lean3@unavailable (status {:?})", out.status.code() @@ -157,7 +157,7 @@ impl ProverBackend for Lean3Backend { ); tracing::trace!(stderr = %stderr); Ok(false) - } + }, Err(e) => Err(anyhow!("Lean 3: binary not runnable: {}", e)), } } diff --git a/src/rust/provers/matita.rs b/src/rust/provers/matita.rs index 4b201de..8487138 100644 --- a/src/rust/provers/matita.rs +++ b/src/rust/provers/matita.rs @@ -8,57 +8,129 @@ //! Vendor: github.com/matita-team/matita #![allow(dead_code)] +use super::{ProverBackend, ProverConfig, ProverKind}; +use crate::core::{Context as ProofContext, Goal, ProofState, Tactic, TacticResult, Term}; use anyhow::{anyhow, Context as AnyhowContext, Result}; use async_trait::async_trait; use std::path::PathBuf; use std::process::Stdio; use tokio::process::Command; -use super::{ProverBackend, ProverConfig, ProverKind}; -use crate::core::{Context as ProofContext, Goal, ProofState, Tactic, TacticResult, Term}; -pub struct MatitaBackend { config: ProverConfig } -impl MatitaBackend { pub fn new(c: ProverConfig) -> Self { Self { config: c } } +pub struct MatitaBackend { + config: ProverConfig, +} +impl MatitaBackend { + pub fn new(c: ProverConfig) -> Self { + Self { config: c } + } fn binary(&self) -> PathBuf { - if self.config.executable.as_os_str().is_empty() { PathBuf::from("matitac") } - else { self.config.executable.clone() } } } + if self.config.executable.as_os_str().is_empty() { + PathBuf::from("matitac") + } else { + self.config.executable.clone() + } + } +} #[async_trait] impl ProverBackend for MatitaBackend { - fn kind(&self) -> ProverKind { ProverKind::Matita } + fn kind(&self) -> ProverKind { + ProverKind::Matita + } async fn version(&self) -> Result { match Command::new(self.binary()).arg("--version").output().await { - Ok(o) if o.status.success() => Ok(String::from_utf8_lossy(&o.stdout).trim().to_string()), + Ok(o) if o.status.success() => { + Ok(String::from_utf8_lossy(&o.stdout).trim().to_string()) + }, Ok(_) => Ok("matita@unavailable".into()), - Err(_) => Ok("matita@not-installed".into()) } } + Err(_) => Ok("matita@not-installed".into()), + } + } async fn parse_file(&self, p: PathBuf) -> Result { - let c = tokio::fs::read_to_string(&p).await.with_context(|| format!("Matita: reading {}", p.display()))?; - self.parse_string(&c).await } + let c = tokio::fs::read_to_string(&p) + .await + .with_context(|| format!("Matita: reading {}", p.display()))?; + self.parse_string(&c).await + } async fn parse_string(&self, content: &str) -> Result { let mut s = ProofState { - goals: vec![Goal { id: "matita-file".into(), target: Term::Const(content.into()), hypotheses: vec![] }], - context: ProofContext::default(), proof_script: vec![], metadata: Default::default() }; - s.metadata.insert("matita_source".into(), serde_json::Value::String(content.into())); Ok(s) } + goals: vec![Goal { + id: "matita-file".into(), + target: Term::Const(content.into()), + hypotheses: vec![], + }], + context: ProofContext::default(), + proof_script: vec![], + metadata: Default::default(), + }; + s.metadata.insert( + "matita_source".into(), + serde_json::Value::String(content.into()), + ); + Ok(s) + } async fn apply_tactic(&self, s: &ProofState, t: &Tactic) -> Result { - let mut n = s.clone(); n.proof_script.push(t.clone()); Ok(TacticResult::Success(n)) } + let mut n = s.clone(); + n.proof_script.push(t.clone()); + Ok(TacticResult::Success(n)) + } async fn verify_proof(&self, state: &ProofState) -> Result { - let src: String = state.metadata.get("matita_source").and_then(|v| v.as_str()).map(String::from).unwrap_or_default(); - let dir = tempfile::Builder::new().prefix("echidna-matita-").tempdir().context("Matita: tempdir")?; + let src: String = state + .metadata + .get("matita_source") + .and_then(|v| v.as_str()) + .map(String::from) + .unwrap_or_default(); + let dir = tempfile::Builder::new() + .prefix("echidna-matita-") + .tempdir() + .context("Matita: tempdir")?; let input = dir.path().join("check.ma"); - tokio::fs::write(&input, src.as_bytes()).await.context("Matita: writing")?; + tokio::fs::write(&input, src.as_bytes()) + .await + .context("Matita: writing")?; let mut cmd = Command::new(self.binary()); - cmd.arg(&input).stdout(Stdio::piped()).stderr(Stdio::piped()); - for a in &self.config.args { cmd.arg(a); } + cmd.arg(&input) + .stdout(Stdio::piped()) + .stderr(Stdio::piped()); + for a in &self.config.args { + cmd.arg(a); + } match cmd.output().await { Ok(o) if o.status.success() => Ok(true), Ok(_) => Ok(false), - Err(e) => Err(anyhow!("Matita: binary not runnable: {}", e)) } } + Err(e) => Err(anyhow!("Matita: binary not runnable: {}", e)), + } + } async fn export(&self, s: &ProofState) -> Result { - Ok(s.metadata.get("matita_source").and_then(|v| v.as_str()).map(String::from).unwrap_or_default()) } - async fn suggest_tactics(&self, _: &ProofState, _: usize) -> Result> { Ok(vec![]) } - async fn search_theorems(&self, _: &str) -> Result> { Ok(vec![]) } - fn config(&self) -> &ProverConfig { &self.config } - fn set_config(&mut self, c: ProverConfig) { self.config = c; } } + Ok(s.metadata + .get("matita_source") + .and_then(|v| v.as_str()) + .map(String::from) + .unwrap_or_default()) + } + async fn suggest_tactics(&self, _: &ProofState, _: usize) -> Result> { + Ok(vec![]) + } + async fn search_theorems(&self, _: &str) -> Result> { + Ok(vec![]) + } + fn config(&self) -> &ProverConfig { + &self.config + } + fn set_config(&mut self, c: ProverConfig) { + self.config = c; + } +} #[cfg(test)] -mod tests { use super::*; - #[test] fn kind_is_matita() { assert_eq!(MatitaBackend::new(ProverConfig::default()).kind(), ProverKind::Matita); } } +mod tests { + use super::*; + #[test] + fn kind_is_matita() { + assert_eq!( + MatitaBackend::new(ProverConfig::default()).kind(), + ProverKind::Matita + ); + } +} diff --git a/src/rust/provers/mercury.rs b/src/rust/provers/mercury.rs index f7034a6..fe8aa3e 100644 --- a/src/rust/provers/mercury.rs +++ b/src/rust/provers/mercury.rs @@ -9,57 +9,130 @@ //! Vendor: www.mercurylang.org / github.com/Mercury-Language/mercury #![allow(dead_code)] +use super::{ProverBackend, ProverConfig, ProverKind}; +use crate::core::{Context as ProofContext, Goal, ProofState, Tactic, TacticResult, Term}; use anyhow::{anyhow, Context as AnyhowContext, Result}; use async_trait::async_trait; use std::path::PathBuf; use std::process::Stdio; use tokio::process::Command; -use super::{ProverBackend, ProverConfig, ProverKind}; -use crate::core::{Context as ProofContext, Goal, ProofState, Tactic, TacticResult, Term}; -pub struct MercuryBackend { config: ProverConfig } -impl MercuryBackend { pub fn new(c: ProverConfig) -> Self { Self { config: c } } +pub struct MercuryBackend { + config: ProverConfig, +} +impl MercuryBackend { + pub fn new(c: ProverConfig) -> Self { + Self { config: c } + } fn binary(&self) -> PathBuf { - if self.config.executable.as_os_str().is_empty() { PathBuf::from("mmc") } - else { self.config.executable.clone() } } } + if self.config.executable.as_os_str().is_empty() { + PathBuf::from("mmc") + } else { + self.config.executable.clone() + } + } +} #[async_trait] impl ProverBackend for MercuryBackend { - fn kind(&self) -> ProverKind { ProverKind::Mercury } + fn kind(&self) -> ProverKind { + ProverKind::Mercury + } async fn version(&self) -> Result { match Command::new(self.binary()).arg("--version").output().await { - Ok(o) if o.status.success() => Ok(String::from_utf8_lossy(&o.stdout).trim().to_string()), + Ok(o) if o.status.success() => { + Ok(String::from_utf8_lossy(&o.stdout).trim().to_string()) + }, Ok(_) => Ok("mercury@unavailable".into()), - Err(_) => Ok("mercury@not-installed".into()) } } + Err(_) => Ok("mercury@not-installed".into()), + } + } async fn parse_file(&self, p: PathBuf) -> Result { - let c = tokio::fs::read_to_string(&p).await.with_context(|| format!("Mercury: reading {}", p.display()))?; - self.parse_string(&c).await } + let c = tokio::fs::read_to_string(&p) + .await + .with_context(|| format!("Mercury: reading {}", p.display()))?; + self.parse_string(&c).await + } async fn parse_string(&self, content: &str) -> Result { let mut s = ProofState { - goals: vec![Goal { id: "mercury-file".into(), target: Term::Const(content.into()), hypotheses: vec![] }], - context: ProofContext::default(), proof_script: vec![], metadata: Default::default() }; - s.metadata.insert("mercury_source".into(), serde_json::Value::String(content.into())); Ok(s) } + goals: vec![Goal { + id: "mercury-file".into(), + target: Term::Const(content.into()), + hypotheses: vec![], + }], + context: ProofContext::default(), + proof_script: vec![], + metadata: Default::default(), + }; + s.metadata.insert( + "mercury_source".into(), + serde_json::Value::String(content.into()), + ); + Ok(s) + } async fn apply_tactic(&self, s: &ProofState, t: &Tactic) -> Result { - let mut n = s.clone(); n.proof_script.push(t.clone()); Ok(TacticResult::Success(n)) } + let mut n = s.clone(); + n.proof_script.push(t.clone()); + Ok(TacticResult::Success(n)) + } async fn verify_proof(&self, state: &ProofState) -> Result { - let src: String = state.metadata.get("mercury_source").and_then(|v| v.as_str()).map(String::from).unwrap_or_default(); - let dir = tempfile::Builder::new().prefix("echidna-mercury-").tempdir().context("Mercury: tempdir")?; + let src: String = state + .metadata + .get("mercury_source") + .and_then(|v| v.as_str()) + .map(String::from) + .unwrap_or_default(); + let dir = tempfile::Builder::new() + .prefix("echidna-mercury-") + .tempdir() + .context("Mercury: tempdir")?; let input = dir.path().join("check.m"); - tokio::fs::write(&input, src.as_bytes()).await.context("Mercury: writing")?; + tokio::fs::write(&input, src.as_bytes()) + .await + .context("Mercury: writing")?; let mut cmd = Command::new(self.binary()); - cmd.arg("--check").arg(&input).stdout(Stdio::piped()).stderr(Stdio::piped()); - for a in &self.config.args { cmd.arg(a); } + cmd.arg("--check") + .arg(&input) + .stdout(Stdio::piped()) + .stderr(Stdio::piped()); + for a in &self.config.args { + cmd.arg(a); + } match cmd.output().await { Ok(o) if o.status.success() => Ok(true), Ok(_) => Ok(false), - Err(e) => Err(anyhow!("Mercury: binary not runnable: {}", e)) } } + Err(e) => Err(anyhow!("Mercury: binary not runnable: {}", e)), + } + } async fn export(&self, s: &ProofState) -> Result { - Ok(s.metadata.get("mercury_source").and_then(|v| v.as_str()).map(String::from).unwrap_or_default()) } - async fn suggest_tactics(&self, _: &ProofState, _: usize) -> Result> { Ok(vec![]) } - async fn search_theorems(&self, _: &str) -> Result> { Ok(vec![]) } - fn config(&self) -> &ProverConfig { &self.config } - fn set_config(&mut self, c: ProverConfig) { self.config = c; } } + Ok(s.metadata + .get("mercury_source") + .and_then(|v| v.as_str()) + .map(String::from) + .unwrap_or_default()) + } + async fn suggest_tactics(&self, _: &ProofState, _: usize) -> Result> { + Ok(vec![]) + } + async fn search_theorems(&self, _: &str) -> Result> { + Ok(vec![]) + } + fn config(&self) -> &ProverConfig { + &self.config + } + fn set_config(&mut self, c: ProverConfig) { + self.config = c; + } +} #[cfg(test)] -mod tests { use super::*; - #[test] fn kind_is_mercury() { assert_eq!(MercuryBackend::new(ProverConfig::default()).kind(), ProverKind::Mercury); } } +mod tests { + use super::*; + #[test] + fn kind_is_mercury() { + assert_eq!( + MercuryBackend::new(ProverConfig::default()).kind(), + ProverKind::Mercury + ); + } +} diff --git a/src/rust/provers/metamath.rs b/src/rust/provers/metamath.rs index 7c0d107..60f3dae 100644 --- a/src/rust/provers/metamath.rs +++ b/src/rust/provers/metamath.rs @@ -327,7 +327,6 @@ impl ProverBackend for MetamathBackend { context.variables.push(Variable { name: var.clone(), ty: Term::Const(typecode.clone()), - type_info: None, }); }, _ => {}, @@ -1021,7 +1020,6 @@ mod tests { state.context.variables.push(Variable { name: "x".to_string(), ty: Term::Const("nat".to_string()), - type_info: None, }); let exported = backend.export(&state).await.unwrap(); diff --git a/src/rust/provers/mizar.rs b/src/rust/provers/mizar.rs index 8cf13bd..19fdf51 100644 --- a/src/rust/provers/mizar.rs +++ b/src/rust/provers/mizar.rs @@ -284,19 +284,6 @@ impl MizarBackend { self.term_to_mizar(body) ) }, - Term::Sigma { - param, - param_type, - body, - } => { - // Mizar has no dependent pairs; approximate with existential. - format!( - "ex {} being {} st {}", - param, - self.term_to_mizar(param_type), - self.term_to_mizar(body) - ) - }, Term::Universe(level) | Term::Type(level) => format!("Type{}", level), Term::Sort(level) => format!("Sort{}", level), Term::Let { @@ -419,7 +406,6 @@ impl ProverBackend for MizarBackend { name: def.name.clone(), ty: def_type, body: def_body, - type_info: None, }); } @@ -462,7 +448,6 @@ impl ProverBackend for MizarBackend { name: hypothesis_name, ty: *param_type.clone(), body: None, - type_info: None, }); goal.target = *body.clone(); new_state.proof_script.push(tactic.clone()); diff --git a/src/rust/provers/mod.rs b/src/rust/provers/mod.rs index 58291c6..338f851 100644 --- a/src/rust/provers/mod.rs +++ b/src/rust/provers/mod.rs @@ -20,27 +20,20 @@ pub mod abc; pub mod abella; pub mod acl2; pub mod acl2s; -pub mod arend; -pub mod athena; -pub mod boogie; -pub mod cameleer; -pub mod dedukti; -pub mod isabelle_zf; -pub mod lambda_prolog; -pub mod matita; -pub mod mercury; -pub mod naproche; -pub mod nitpick; -pub mod nunchaku; pub mod agda; pub mod alloy; pub mod altergo; +pub mod arend; +pub mod athena; +pub mod boogie; pub mod cadical; +pub mod cameleer; pub mod cbmc; pub mod chuffed; pub mod coq; pub mod cvc5; pub mod dafny; +pub mod dedukti; pub mod dreal; pub mod eprover; pub mod framac; @@ -48,22 +41,29 @@ pub mod fstar; pub mod glpk; pub mod hol4; pub mod hol_light; +pub mod hp_ecosystem; pub mod idris2; pub mod imandra; pub mod isabelle; +pub mod isabelle_zf; pub mod key; pub mod kissat; +pub mod lambda_prolog; pub mod lean; pub mod lean3; +pub mod matita; +pub mod mercury; pub mod metamath; pub mod minisat; pub mod minizinc; pub mod minlog; pub mod mizar; +pub mod naproche; +pub mod nitpick; +pub mod nunchaku; pub mod nuprl; pub mod nusmv; pub mod ortools; -pub mod outcome; pub mod prism; pub mod proverif; pub mod pvs; @@ -76,7 +76,6 @@ pub mod tlaps; pub mod tlc; pub mod twelf; pub mod typed_wasm; -pub mod hp_ecosystem; pub mod uppaal; pub mod vampire; pub mod viper; @@ -418,13 +417,13 @@ impl std::str::FromStr for ProverKind { "typell" | "type-ll" | "typell-kernel" => Ok(ProverKind::TypeLL), "katagoria" | "katagoriaverifier" | "katagoria-verifier" => { Ok(ProverKind::KatagoriaVerifier) - } + }, "tropicaltypechecker" | "tropical" | "tropical-type-checker" => { Ok(ProverKind::TropicalTypeChecker) - } + }, "choreographictypechecker" | "choreographic" => { Ok(ProverKind::ChoreographicTypeChecker) - } + }, "epistemictypechecker" | "epistemic" => Ok(ProverKind::EpistemicTypeChecker), "echotypechecker" | "echo" => Ok(ProverKind::EchoTypeChecker), "sessiontypechecker" | "session" => Ok(ProverKind::SessionTypeChecker), @@ -432,95 +431,89 @@ impl std::str::FromStr for ProverKind { "qtttypechecker" | "qtt" | "quantitative" => Ok(ProverKind::QTTTypeChecker), "effectrowtypechecker" | "effect-row" | "effectrow" => { Ok(ProverKind::EffectRowTypeChecker) - } + }, "dependenttypechecker" | "dependent" => Ok(ProverKind::DependentTypeChecker), "refinementtypechecker" | "refinement" => Ok(ProverKind::RefinementTypeChecker), "ordinarytypechecker" | "ordinary" | "simple" | "simply-typed" | "stlc" => { Ok(ProverKind::OrdinaryTypeChecker) - } + }, "phantomtypechecker" | "phantom" => Ok(ProverKind::PhantomTypeChecker), "polymorphictypechecker" | "polymorphic" | "systemf" | "system-f" | "parametric" => { Ok(ProverKind::PolymorphicTypeChecker) - } + }, "existentialtypechecker" | "existential" | "packed" => { Ok(ProverKind::ExistentialTypeChecker) - } + }, "higherkindedtypechecker" | "higher-kinded" | "higherkinded" | "hkt" | "hk" => { Ok(ProverKind::HigherKindedTypeChecker) - } + }, "rowtypechecker" | "row" | "row-polymorphic" | "row-polymorphism" => { Ok(ProverKind::RowTypeChecker) - } + }, "subtypingtypechecker" | "subtyping" | "sub" => Ok(ProverKind::SubtypingTypeChecker), "intersectiontypechecker" | "intersection" | "inter" => { Ok(ProverKind::IntersectionTypeChecker) - } + }, "uniontypechecker" | "union" => Ok(ProverKind::UnionTypeChecker), "gradualtypechecker" | "gradual" | "gradual-typing" => { Ok(ProverKind::GradualTypeChecker) - } + }, "hoaretypechecker" | "hoare" | "hoare-types" => Ok(ProverKind::HoareTypeChecker), "indexedtypechecker" | "indexed" | "indexed-monad" | "indexed-monads" => { Ok(ProverKind::IndexedTypeChecker) - } + }, "lineartypechecker" | "linear" | "linear-types" => Ok(ProverKind::LinearTypeChecker), "affinetypechecker" | "affine" | "affine-types" => Ok(ProverKind::AffineTypeChecker), "relevanttypechecker" | "relevant" | "relevant-types" => { Ok(ProverKind::RelevantTypeChecker) - } + }, "orderedtypechecker" | "ordered" | "ordered-logic" | "no-exchange" => { Ok(ProverKind::OrderedTypeChecker) - } + }, "uniquenesstypechecker" | "uniqueness" | "unique" | "unique-types" => { Ok(ProverKind::UniquenessTypeChecker) - } + }, "immutabletypechecker" | "immutable" | "frozen" | "const-types" => { Ok(ProverKind::ImmutableTypeChecker) - } + }, "capabilitytypechecker" | "capability" | "cap" | "capability-types" => { Ok(ProverKind::CapabilityTypeChecker) - } + }, "bunchedtypechecker" | "bunched" | "bi" | "bi-logic" | "separation" => { Ok(ProverKind::BunchedTypeChecker) - } + }, "temporaltypechecker" | "temporal" | "ltl" | "ctl" => { Ok(ProverKind::TemporalTypeChecker) - } + }, "provabilitytypechecker" | "provability" | "lob" | "löb" | "gl" => { Ok(ProverKind::ProvabilityTypeChecker) - } - "impuretypechecker" | "impure" | "effect-tracked" => { - Ok(ProverKind::ImpureTypeChecker) - } + }, + "impuretypechecker" | "impure" | "effect-tracked" => Ok(ProverKind::ImpureTypeChecker), "coeffecttypechecker" | "coeffect" | "graded-context" | "coeffects" => { Ok(ProverKind::CoeffectTypeChecker) - } + }, "probabilistictypechecker" | "probabilistic" | "prob" | "prob-types" => { Ok(ProverKind::ProbabilisticTypeChecker) - } + }, "dyadictypechecker" | "dyadic" | "binary-channel" | "dyadic-session" => { Ok(ProverKind::DyadicTypeChecker) - } + }, "homotopytypechecker" | "homotopy" | "hott" => Ok(ProverKind::HomotopyTypeChecker), "cubicaltypechecker" | "cubical" | "cubical-tt" => Ok(ProverKind::CubicalTypeChecker), "nominaltypechecker" | "nominal" | "hoas" | "lambda-tree" => { Ok(ProverKind::NominalTypeChecker) - } + }, "abella" => Ok(ProverKind::Abella), "dedukti" | "dkcheck" | "lambdapi" => Ok(ProverKind::Dedukti), "cameleer" | "gospel" => Ok(ProverKind::Cameleer), "acl2s" | "acl2-s" => Ok(ProverKind::ACL2s), - "isabellezf" | "isabelle-zf" | "isabelle/zf" | "zf" => { - Ok(ProverKind::IsabelleZF) - } + "isabellezf" | "isabelle-zf" | "isabelle/zf" | "zf" => Ok(ProverKind::IsabelleZF), "boogie" | "bpl" => Ok(ProverKind::Boogie), "naproche" | "forthel" | "ftl" => Ok(ProverKind::Naproche), "matita" => Ok(ProverKind::Matita), "arend" => Ok(ProverKind::Arend), "athena" => Ok(ProverKind::Athena), - "lambdaprolog" | "lambda-prolog" | "teyjus" | "elpi" => { - Ok(ProverKind::LambdaProlog) - } + "lambdaprolog" | "lambda-prolog" | "teyjus" | "elpi" => Ok(ProverKind::LambdaProlog), "mercury" | "mmc" => Ok(ProverKind::Mercury), "nitpick" => Ok(ProverKind::Nitpick), "nunchaku" => Ok(ProverKind::Nunchaku), @@ -616,54 +609,54 @@ impl ProverKind { ProverKind::ACL2 => 4, ProverKind::HOL4 => 5, ProverKind::Idris2 => 3, - ProverKind::Lean3 => 3, // Same complexity as Lean 4. - ProverKind::Abella => 3, // Two-level logic, HOAS proof state. - ProverKind::Dedukti => 3, // λΠ-modulo framework. - ProverKind::Cameleer => 2, // Thin OCaml→Why3 pipeline. - ProverKind::ACL2s => 4, // Sibling to ACL2. - ProverKind::IsabelleZF => 4, // Sibling to Isabelle/HOL. - ProverKind::Boogie => 2, // Intermediate verification language. - ProverKind::Naproche => 3, // Controlled-NL parsing non-trivial. - ProverKind::Matita => 3, // CIC variant, same family as Coq. - ProverKind::Arend => 3, // Cubical HoTT. - ProverKind::Athena => 4, // Denotational + rewriting engine. + ProverKind::Lean3 => 3, // Same complexity as Lean 4. + ProverKind::Abella => 3, // Two-level logic, HOAS proof state. + ProverKind::Dedukti => 3, // λΠ-modulo framework. + ProverKind::Cameleer => 2, // Thin OCaml→Why3 pipeline. + ProverKind::ACL2s => 4, // Sibling to ACL2. + ProverKind::IsabelleZF => 4, // Sibling to Isabelle/HOL. + ProverKind::Boogie => 2, // Intermediate verification language. + ProverKind::Naproche => 3, // Controlled-NL parsing non-trivial. + ProverKind::Matita => 3, // CIC variant, same family as Coq. + ProverKind::Arend => 3, // Cubical HoTT. + ProverKind::Athena => 4, // Denotational + rewriting engine. ProverKind::LambdaProlog => 3, // HOAS logic programming. - ProverKind::Mercury => 3, // Logic programming with types/modes. - ProverKind::Nitpick => 2, // Isabelle-wrapped counter-example finder. - ProverKind::Nunchaku => 2, // Standalone counter-example finder. - ProverKind::Vampire => 2, // Automated, relatively simple - ProverKind::EProver => 2, // Similar to Vampire - ProverKind::SPASS => 2, // Automated FOL - ProverKind::AltErgo => 2, // SMT + FOL - ProverKind::FStar => 3, // Dependent types + effects - ProverKind::Dafny => 2, // Auto-active - ProverKind::Why3 => 3, // Multi-prover orchestration - ProverKind::TLAPS => 4, // TLA+ proof system - ProverKind::Twelf => 4, // Logical framework - ProverKind::Nuprl => 4, // Constructive type theory - ProverKind::Minlog => 4, // Minimal logic - ProverKind::Imandra => 3, // ML-based reasoning - ProverKind::GLPK => 2, // LP solver - ProverKind::SCIP => 3, // MINLP solver - ProverKind::MiniZinc => 2, // Constraint modelling - ProverKind::Chuffed => 2, // CP solver - ProverKind::ORTools => 2, // Constraint/optimization solver - ProverKind::TypedWasm => 3, // Internal oracle, structural analysis - ProverKind::SPIN => 3, // Model checker, Promela language - ProverKind::CBMC => 2, // Bounded model checker, C input - ProverKind::SeaHorn => 2, // LLVM-based verifier, abstract interpretation + CHC - ProverKind::CaDiCaL => 1, // SAT solver, DIMACS CNF - ProverKind::Kissat => 1, // SAT solver, DIMACS CNF - ProverKind::MiniSat => 1, // SAT solver, DIMACS CNF - ProverKind::NuSMV => 3, // Symbolic model checker, SMV language - ProverKind::TLC => 3, // TLA+ model checker - ProverKind::Alloy => 3, // Relational model finder - ProverKind::Prism => 3, // Probabilistic model checker - ProverKind::UPPAAL => 3, // Timed automata model checker - ProverKind::FramaC => 3, // Deductive C verifier (ACSL + WP) - ProverKind::Viper => 3, // Permission-based verifier (Silver + Silicon/Carbon) - ProverKind::Tamarin => 3, // Security protocol verifier, multiset rewriting - ProverKind::ProVerif => 2, // Automated protocol verifier, applied pi-calculus + ProverKind::Mercury => 3, // Logic programming with types/modes. + ProverKind::Nitpick => 2, // Isabelle-wrapped counter-example finder. + ProverKind::Nunchaku => 2, // Standalone counter-example finder. + ProverKind::Vampire => 2, // Automated, relatively simple + ProverKind::EProver => 2, // Similar to Vampire + ProverKind::SPASS => 2, // Automated FOL + ProverKind::AltErgo => 2, // SMT + FOL + ProverKind::FStar => 3, // Dependent types + effects + ProverKind::Dafny => 2, // Auto-active + ProverKind::Why3 => 3, // Multi-prover orchestration + ProverKind::TLAPS => 4, // TLA+ proof system + ProverKind::Twelf => 4, // Logical framework + ProverKind::Nuprl => 4, // Constructive type theory + ProverKind::Minlog => 4, // Minimal logic + ProverKind::Imandra => 3, // ML-based reasoning + ProverKind::GLPK => 2, // LP solver + ProverKind::SCIP => 3, // MINLP solver + ProverKind::MiniZinc => 2, // Constraint modelling + ProverKind::Chuffed => 2, // CP solver + ProverKind::ORTools => 2, // Constraint/optimization solver + ProverKind::TypedWasm => 3, // Internal oracle, structural analysis + ProverKind::SPIN => 3, // Model checker, Promela language + ProverKind::CBMC => 2, // Bounded model checker, C input + ProverKind::SeaHorn => 2, // LLVM-based verifier, abstract interpretation + CHC + ProverKind::CaDiCaL => 1, // SAT solver, DIMACS CNF + ProverKind::Kissat => 1, // SAT solver, DIMACS CNF + ProverKind::MiniSat => 1, // SAT solver, DIMACS CNF + ProverKind::NuSMV => 3, // Symbolic model checker, SMV language + ProverKind::TLC => 3, // TLA+ model checker + ProverKind::Alloy => 3, // Relational model finder + ProverKind::Prism => 3, // Probabilistic model checker + ProverKind::UPPAAL => 3, // Timed automata model checker + ProverKind::FramaC => 3, // Deductive C verifier (ACSL + WP) + ProverKind::Viper => 3, // Permission-based verifier (Silver + Silicon/Carbon) + ProverKind::Tamarin => 3, // Security protocol verifier, multiset rewriting + ProverKind::ProVerif => 2, // Automated protocol verifier, applied pi-calculus ProverKind::KeY => 3, // Deductive Java verifier (JavaDL + JML), auto + interactive ProverKind::DReal => 2, // Automated delta-complete SMT solver, NRA ProverKind::ABC => 2, // Automated hardware verification, AIG-based @@ -738,19 +731,19 @@ impl ProverKind { ProverKind::Lean3 => 1, // Sibling to Lean 4. // Tier 7 niche: specialized proof framework for HOAS / nominal. ProverKind::Abella => 2, - ProverKind::Dedukti => 2, // Logical framework tier. - ProverKind::Cameleer => 2, // Auto-active via Why3. - ProverKind::ACL2s => 3, // Sibling to ACL2 (tier 3). - ProverKind::IsabelleZF => 1, // Sibling to Isabelle (tier 1). - ProverKind::Boogie => 5, // Deductive program verifier tier. - ProverKind::Naproche => 2, // Specialised, text-style. - ProverKind::Matita => 1, // Coq-adjacent, Tier 1 capability. - ProverKind::Arend => 1, // Cubical HoTT, Tier 1. - ProverKind::Athena => 4, // Niche framework. + ProverKind::Dedukti => 2, // Logical framework tier. + ProverKind::Cameleer => 2, // Auto-active via Why3. + ProverKind::ACL2s => 3, // Sibling to ACL2 (tier 3). + ProverKind::IsabelleZF => 1, // Sibling to Isabelle (tier 1). + ProverKind::Boogie => 5, // Deductive program verifier tier. + ProverKind::Naproche => 2, // Specialised, text-style. + ProverKind::Matita => 1, // Coq-adjacent, Tier 1 capability. + ProverKind::Arend => 1, // Cubical HoTT, Tier 1. + ProverKind::Athena => 4, // Niche framework. ProverKind::LambdaProlog => 4, // Logical framework / HOAS. - ProverKind::Mercury => 4, // Specialised logic programming. - ProverKind::Nitpick => 5, // Counter-example finder tier. - ProverKind::Nunchaku => 5, // Counter-example finder tier. + ProverKind::Mercury => 4, // Specialised logic programming. + ProverKind::Nitpick => 5, // Counter-example finder tier. + ProverKind::Nunchaku => 5, // Counter-example finder tier. // Tier 5: First-Order ATPs ProverKind::Vampire => 5, @@ -859,57 +852,57 @@ impl ProverKind { ProverKind::PVS | ProverKind::ACL2 => 3.5, ProverKind::HOL4 => 4.0, ProverKind::Idris2 => 2.5, - ProverKind::Lean3 => 1.0, // Thin fork of Lean 4 backend. - ProverKind::Abella => 2.0, // New parser, HOAS proof state model. - ProverKind::Dedukti => 1.5, // Extends existing exchange module. - ProverKind::Cameleer => 1.0, // Thin wrapper over Why3. - ProverKind::ACL2s => 1.0, // Thin fork of ACL2. - ProverKind::IsabelleZF => 1.0, // Thin variant of Isabelle. - ProverKind::Boogie => 1.5, // Extract from Viper internals. - ProverKind::Naproche => 2.0, // Controlled-NL parser wrapper. - ProverKind::Matita => 2.0, // Coq-parser fork. - ProverKind::Arend => 2.0, // Cubical parser + elaborator. - ProverKind::Athena => 2.5, // Rich denotational framework. + ProverKind::Lean3 => 1.0, // Thin fork of Lean 4 backend. + ProverKind::Abella => 2.0, // New parser, HOAS proof state model. + ProverKind::Dedukti => 1.5, // Extends existing exchange module. + ProverKind::Cameleer => 1.0, // Thin wrapper over Why3. + ProverKind::ACL2s => 1.0, // Thin fork of ACL2. + ProverKind::IsabelleZF => 1.0, // Thin variant of Isabelle. + ProverKind::Boogie => 1.5, // Extract from Viper internals. + ProverKind::Naproche => 2.0, // Controlled-NL parser wrapper. + ProverKind::Matita => 2.0, // Coq-parser fork. + ProverKind::Arend => 2.0, // Cubical parser + elaborator. + ProverKind::Athena => 2.5, // Rich denotational framework. ProverKind::LambdaProlog => 2.0, // HOAS parser + unifier. - ProverKind::Mercury => 2.0, // Logic programming interpreter bridge. - ProverKind::Nitpick => 1.0, // Thin wrapper over Isabelle. - ProverKind::Nunchaku => 1.5, // Standalone counter-example tool. - ProverKind::Vampire => 1.5, // Automated, TPTP format - ProverKind::EProver => 1.5, // Similar to Vampire - ProverKind::SPASS => 1.5, // DFG format - ProverKind::AltErgo => 1.5, // Native format - ProverKind::FStar => 2.5, // Dependent types + effects - ProverKind::Dafny => 2.0, // Auto-active, Boogie pipeline - ProverKind::Why3 => 2.0, // Multi-prover - ProverKind::TLAPS => 2.5, // TLA+ specific - ProverKind::Twelf => 3.0, // LF framework - ProverKind::Nuprl => 3.0, // Constructive type theory - ProverKind::Minlog => 2.5, // Minimal logic - ProverKind::Imandra => 2.0, // ML-based - ProverKind::GLPK => 1.0, // LP API - ProverKind::SCIP => 1.5, // MINLP API - ProverKind::MiniZinc => 1.0, // Constraint modelling - ProverKind::Chuffed => 1.0, // CP solver - ProverKind::ORTools => 1.5, // Constraint/optimization - ProverKind::TypedWasm => 2.0, // Internal oracle - ProverKind::SPIN => 1.5, // Model checker - ProverKind::CBMC => 1.5, // Bounded model checker - ProverKind::SeaHorn => 1.5, // LLVM-based CHC verifier - ProverKind::CaDiCaL => 1.0, // SAT solver, DIMACS CNF - ProverKind::Kissat => 1.0, // SAT solver, DIMACS CNF - ProverKind::MiniSat => 1.0, // SAT solver, DIMACS CNF - ProverKind::NuSMV => 1.5, // Symbolic model checker - ProverKind::TLC => 1.5, // TLA+ model checker - ProverKind::Alloy => 1.5, // Relational model finder - ProverKind::Prism => 1.5, // Probabilistic model checker - ProverKind::UPPAAL => 1.5, // Timed automata model checker - ProverKind::FramaC => 1.5, // Deductive C verifier - ProverKind::Viper => 2.0, // Permission-based verifier (Silver + two backends) - ProverKind::Tamarin => 2.0, // Security protocol verifier (.spthy) - ProverKind::ProVerif => 1.5, // Automated protocol verifier (.pv) - ProverKind::KeY => 2.0, // Deductive Java verifier (JavaDL + JML) - ProverKind::DReal => 1.0, // Automated SMT solver, SMT-LIB input - ProverKind::ABC => 1.5, // Hardware verification, AIGER/BLIF input + ProverKind::Mercury => 2.0, // Logic programming interpreter bridge. + ProverKind::Nitpick => 1.0, // Thin wrapper over Isabelle. + ProverKind::Nunchaku => 1.5, // Standalone counter-example tool. + ProverKind::Vampire => 1.5, // Automated, TPTP format + ProverKind::EProver => 1.5, // Similar to Vampire + ProverKind::SPASS => 1.5, // DFG format + ProverKind::AltErgo => 1.5, // Native format + ProverKind::FStar => 2.5, // Dependent types + effects + ProverKind::Dafny => 2.0, // Auto-active, Boogie pipeline + ProverKind::Why3 => 2.0, // Multi-prover + ProverKind::TLAPS => 2.5, // TLA+ specific + ProverKind::Twelf => 3.0, // LF framework + ProverKind::Nuprl => 3.0, // Constructive type theory + ProverKind::Minlog => 2.5, // Minimal logic + ProverKind::Imandra => 2.0, // ML-based + ProverKind::GLPK => 1.0, // LP API + ProverKind::SCIP => 1.5, // MINLP API + ProverKind::MiniZinc => 1.0, // Constraint modelling + ProverKind::Chuffed => 1.0, // CP solver + ProverKind::ORTools => 1.5, // Constraint/optimization + ProverKind::TypedWasm => 2.0, // Internal oracle + ProverKind::SPIN => 1.5, // Model checker + ProverKind::CBMC => 1.5, // Bounded model checker + ProverKind::SeaHorn => 1.5, // LLVM-based CHC verifier + ProverKind::CaDiCaL => 1.0, // SAT solver, DIMACS CNF + ProverKind::Kissat => 1.0, // SAT solver, DIMACS CNF + ProverKind::MiniSat => 1.0, // SAT solver, DIMACS CNF + ProverKind::NuSMV => 1.5, // Symbolic model checker + ProverKind::TLC => 1.5, // TLA+ model checker + ProverKind::Alloy => 1.5, // Relational model finder + ProverKind::Prism => 1.5, // Probabilistic model checker + ProverKind::UPPAAL => 1.5, // Timed automata model checker + ProverKind::FramaC => 1.5, // Deductive C verifier + ProverKind::Viper => 2.0, // Permission-based verifier (Silver + two backends) + ProverKind::Tamarin => 2.0, // Security protocol verifier (.spthy) + ProverKind::ProVerif => 1.5, // Automated protocol verifier (.pv) + ProverKind::KeY => 2.0, // Deductive Java verifier (JavaDL + JML) + ProverKind::DReal => 1.0, // Automated SMT solver, SMT-LIB input + ProverKind::ABC => 1.5, // Hardware verification, AIGER/BLIF input ProverKind::TypeLL | ProverKind::KatagoriaVerifier | ProverKind::TropicalTypeChecker @@ -1228,7 +1221,7 @@ impl ProverFactory { ProverKind::Athena => Ok(Box::new(athena::AthenaBackend::new(config))), ProverKind::LambdaProlog => { Ok(Box::new(lambda_prolog::LambdaPrologBackend::new(config))) - } + }, ProverKind::Mercury => Ok(Box::new(mercury::MercuryBackend::new(config))), ProverKind::Nitpick => Ok(Box::new(nitpick::NitpickBackend::new(config))), ProverKind::Nunchaku => Ok(Box::new(nunchaku::NunchakuBackend::new(config))), @@ -1362,13 +1355,13 @@ impl ProverFactory { // Note: .lean is shared between Lean 3 and Lean 4; default is Lean 4. // Use detect_from_file_content() for Lean 3 vs 4 disambiguation. "lean3" => Some(ProverKind::Lean3), // explicit extension - "thm" => Some(ProverKind::Abella), // Abella .thm files + "thm" => Some(ProverKind::Abella), // Abella .thm files "dk" | "lp" => Some(ProverKind::Dedukti), // Dedukti / λΠ - "bpl" => Some(ProverKind::Boogie), // Boogie intermediate language + "bpl" => Some(ProverKind::Boogie), // Boogie intermediate language "ftl" => Some(ProverKind::Naproche), // Naproche controlled-NL - "ma" => Some(ProverKind::Matita), // Matita proof file - "ard" => Some(ProverKind::Arend), // Arend cubical HoTT - "ath" => Some(ProverKind::Athena), // Athena + "ma" => Some(ProverKind::Matita), // Matita proof file + "ard" => Some(ProverKind::Arend), // Arend cubical HoTT + "ath" => Some(ProverKind::Athena), // Athena "mod" | "sig" => Some(ProverKind::LambdaProlog), // λProlog module / signature "nun" => Some(ProverKind::Nunchaku), // Nunchaku input // Mercury uses .m which collides with OCaml conventions in @@ -1425,9 +1418,9 @@ impl ProverFactory { && (content.contains("//@") || content.contains("/*@") || content.contains("requires") && content.contains("ensures")) - { - return Some(ProverKind::KeY); - } + { + return Some(ProverKind::KeY); + } if ext == "c" || ext == "h" { // Frama-C ACSL annotations take priority (deductive verification) diff --git a/src/rust/provers/naproche.rs b/src/rust/provers/naproche.rs index 1066eab..7746e9c 100644 --- a/src/rust/provers/naproche.rs +++ b/src/rust/provers/naproche.rs @@ -8,57 +8,129 @@ //! Vendor: github.com/naproche/naproche #![allow(dead_code)] +use super::{ProverBackend, ProverConfig, ProverKind}; +use crate::core::{Context as ProofContext, Goal, ProofState, Tactic, TacticResult, Term}; use anyhow::{anyhow, Context as AnyhowContext, Result}; use async_trait::async_trait; use std::path::PathBuf; use std::process::Stdio; use tokio::process::Command; -use super::{ProverBackend, ProverConfig, ProverKind}; -use crate::core::{Context as ProofContext, Goal, ProofState, Tactic, TacticResult, Term}; -pub struct NaprocheBackend { config: ProverConfig } -impl NaprocheBackend { pub fn new(c: ProverConfig) -> Self { Self { config: c } } +pub struct NaprocheBackend { + config: ProverConfig, +} +impl NaprocheBackend { + pub fn new(c: ProverConfig) -> Self { + Self { config: c } + } fn binary(&self) -> PathBuf { - if self.config.executable.as_os_str().is_empty() { PathBuf::from("naproche") } - else { self.config.executable.clone() } } } + if self.config.executable.as_os_str().is_empty() { + PathBuf::from("naproche") + } else { + self.config.executable.clone() + } + } +} #[async_trait] impl ProverBackend for NaprocheBackend { - fn kind(&self) -> ProverKind { ProverKind::Naproche } + fn kind(&self) -> ProverKind { + ProverKind::Naproche + } async fn version(&self) -> Result { match Command::new(self.binary()).arg("--version").output().await { - Ok(o) if o.status.success() => Ok(String::from_utf8_lossy(&o.stdout).trim().to_string()), + Ok(o) if o.status.success() => { + Ok(String::from_utf8_lossy(&o.stdout).trim().to_string()) + }, Ok(_) => Ok("naproche@unavailable".into()), - Err(_) => Ok("naproche@not-installed".into()) } } + Err(_) => Ok("naproche@not-installed".into()), + } + } async fn parse_file(&self, p: PathBuf) -> Result { - let c = tokio::fs::read_to_string(&p).await.with_context(|| format!("Naproche: reading {}", p.display()))?; - self.parse_string(&c).await } + let c = tokio::fs::read_to_string(&p) + .await + .with_context(|| format!("Naproche: reading {}", p.display()))?; + self.parse_string(&c).await + } async fn parse_string(&self, content: &str) -> Result { let mut s = ProofState { - goals: vec![Goal { id: "naproche-file".into(), target: Term::Const(content.into()), hypotheses: vec![] }], - context: ProofContext::default(), proof_script: vec![], metadata: Default::default() }; - s.metadata.insert("naproche_source".into(), serde_json::Value::String(content.into())); Ok(s) } + goals: vec![Goal { + id: "naproche-file".into(), + target: Term::Const(content.into()), + hypotheses: vec![], + }], + context: ProofContext::default(), + proof_script: vec![], + metadata: Default::default(), + }; + s.metadata.insert( + "naproche_source".into(), + serde_json::Value::String(content.into()), + ); + Ok(s) + } async fn apply_tactic(&self, s: &ProofState, t: &Tactic) -> Result { - let mut n = s.clone(); n.proof_script.push(t.clone()); Ok(TacticResult::Success(n)) } + let mut n = s.clone(); + n.proof_script.push(t.clone()); + Ok(TacticResult::Success(n)) + } async fn verify_proof(&self, state: &ProofState) -> Result { - let src: String = state.metadata.get("naproche_source").and_then(|v| v.as_str()).map(String::from).unwrap_or_default(); - let dir = tempfile::Builder::new().prefix("echidna-naproche-").tempdir().context("Naproche: tempdir")?; + let src: String = state + .metadata + .get("naproche_source") + .and_then(|v| v.as_str()) + .map(String::from) + .unwrap_or_default(); + let dir = tempfile::Builder::new() + .prefix("echidna-naproche-") + .tempdir() + .context("Naproche: tempdir")?; let input = dir.path().join("check.ftl"); - tokio::fs::write(&input, src.as_bytes()).await.context("Naproche: writing")?; + tokio::fs::write(&input, src.as_bytes()) + .await + .context("Naproche: writing")?; let mut cmd = Command::new(self.binary()); - cmd.arg(&input).stdout(Stdio::piped()).stderr(Stdio::piped()); - for a in &self.config.args { cmd.arg(a); } + cmd.arg(&input) + .stdout(Stdio::piped()) + .stderr(Stdio::piped()); + for a in &self.config.args { + cmd.arg(a); + } match cmd.output().await { Ok(o) if o.status.success() => Ok(true), Ok(_) => Ok(false), - Err(e) => Err(anyhow!("Naproche: binary not runnable: {}", e)) } } + Err(e) => Err(anyhow!("Naproche: binary not runnable: {}", e)), + } + } async fn export(&self, s: &ProofState) -> Result { - Ok(s.metadata.get("naproche_source").and_then(|v| v.as_str()).map(String::from).unwrap_or_default()) } - async fn suggest_tactics(&self, _: &ProofState, _: usize) -> Result> { Ok(vec![]) } - async fn search_theorems(&self, _: &str) -> Result> { Ok(vec![]) } - fn config(&self) -> &ProverConfig { &self.config } - fn set_config(&mut self, c: ProverConfig) { self.config = c; } } + Ok(s.metadata + .get("naproche_source") + .and_then(|v| v.as_str()) + .map(String::from) + .unwrap_or_default()) + } + async fn suggest_tactics(&self, _: &ProofState, _: usize) -> Result> { + Ok(vec![]) + } + async fn search_theorems(&self, _: &str) -> Result> { + Ok(vec![]) + } + fn config(&self) -> &ProverConfig { + &self.config + } + fn set_config(&mut self, c: ProverConfig) { + self.config = c; + } +} #[cfg(test)] -mod tests { use super::*; - #[test] fn kind_is_naproche() { assert_eq!(NaprocheBackend::new(ProverConfig::default()).kind(), ProverKind::Naproche); } } +mod tests { + use super::*; + #[test] + fn kind_is_naproche() { + assert_eq!( + NaprocheBackend::new(ProverConfig::default()).kind(), + ProverKind::Naproche + ); + } +} diff --git a/src/rust/provers/nitpick.rs b/src/rust/provers/nitpick.rs index be50bbf..fb26671 100644 --- a/src/rust/provers/nitpick.rs +++ b/src/rust/provers/nitpick.rs @@ -11,63 +11,139 @@ //! theorem that the caller wants refuted. #![allow(dead_code)] +use super::{ProverBackend, ProverConfig, ProverKind}; +use crate::core::{Context as ProofContext, Goal, ProofState, Tactic, TacticResult, Term}; use anyhow::{anyhow, Context as AnyhowContext, Result}; use async_trait::async_trait; use std::path::PathBuf; use std::process::Stdio; use tokio::process::Command; -use super::{ProverBackend, ProverConfig, ProverKind}; -use crate::core::{Context as ProofContext, Goal, ProofState, Tactic, TacticResult, Term}; -pub struct NitpickBackend { config: ProverConfig } -impl NitpickBackend { pub fn new(c: ProverConfig) -> Self { Self { config: c } } +pub struct NitpickBackend { + config: ProverConfig, +} +impl NitpickBackend { + pub fn new(c: ProverConfig) -> Self { + Self { config: c } + } fn binary(&self) -> PathBuf { - if self.config.executable.as_os_str().is_empty() { PathBuf::from("isabelle") } - else { self.config.executable.clone() } } } + if self.config.executable.as_os_str().is_empty() { + PathBuf::from("isabelle") + } else { + self.config.executable.clone() + } + } +} #[async_trait] impl ProverBackend for NitpickBackend { - fn kind(&self) -> ProverKind { ProverKind::Nitpick } + fn kind(&self) -> ProverKind { + ProverKind::Nitpick + } async fn version(&self) -> Result { match Command::new(self.binary()).arg("version").output().await { - Ok(o) if o.status.success() => Ok(format!("{}+nitpick", String::from_utf8_lossy(&o.stdout).trim())), + Ok(o) if o.status.success() => Ok(format!( + "{}+nitpick", + String::from_utf8_lossy(&o.stdout).trim() + )), Ok(_) => Ok("nitpick@unavailable".into()), - Err(_) => Ok("nitpick@not-installed".into()) } } + Err(_) => Ok("nitpick@not-installed".into()), + } + } async fn parse_file(&self, p: PathBuf) -> Result { - let c = tokio::fs::read_to_string(&p).await.with_context(|| format!("Nitpick: reading {}", p.display()))?; - self.parse_string(&c).await } + let c = tokio::fs::read_to_string(&p) + .await + .with_context(|| format!("Nitpick: reading {}", p.display()))?; + self.parse_string(&c).await + } async fn parse_string(&self, content: &str) -> Result { let mut s = ProofState { - goals: vec![Goal { id: "nitpick-theorem".into(), target: Term::Const(content.into()), hypotheses: vec![] }], - context: ProofContext::default(), proof_script: vec![], metadata: Default::default() }; - s.metadata.insert("nitpick_source".into(), serde_json::Value::String(content.into())); Ok(s) } + goals: vec![Goal { + id: "nitpick-theorem".into(), + target: Term::Const(content.into()), + hypotheses: vec![], + }], + context: ProofContext::default(), + proof_script: vec![], + metadata: Default::default(), + }; + s.metadata.insert( + "nitpick_source".into(), + serde_json::Value::String(content.into()), + ); + Ok(s) + } async fn apply_tactic(&self, s: &ProofState, t: &Tactic) -> Result { - let mut n = s.clone(); n.proof_script.push(t.clone()); Ok(TacticResult::Success(n)) } + let mut n = s.clone(); + n.proof_script.push(t.clone()); + Ok(TacticResult::Success(n)) + } // verify_proof semantics inverted: returns true if Nitpick FOUND a // counter-example (i.e. the input theorem was successfully refuted); // returns false otherwise. Consumers treat Nitpick as a negative-class // signal — success here means the candidate theorem is known-false. async fn verify_proof(&self, state: &ProofState) -> Result { - let src: String = state.metadata.get("nitpick_source").and_then(|v| v.as_str()).map(String::from).unwrap_or_default(); - let dir = tempfile::Builder::new().prefix("echidna-nitpick-").tempdir().context("Nitpick: tempdir")?; + let src: String = state + .metadata + .get("nitpick_source") + .and_then(|v| v.as_str()) + .map(String::from) + .unwrap_or_default(); + let dir = tempfile::Builder::new() + .prefix("echidna-nitpick-") + .tempdir() + .context("Nitpick: tempdir")?; let input = dir.path().join("Check.thy"); - tokio::fs::write(&input, src.as_bytes()).await.context("Nitpick: writing")?; + tokio::fs::write(&input, src.as_bytes()) + .await + .context("Nitpick: writing")?; let mut cmd = Command::new(self.binary()); - cmd.arg("process").arg("-e").arg("nitpick").arg(&input).stdout(Stdio::piped()).stderr(Stdio::piped()); - for a in &self.config.args { cmd.arg(a); } + cmd.arg("process") + .arg("-e") + .arg("nitpick") + .arg(&input) + .stdout(Stdio::piped()) + .stderr(Stdio::piped()); + for a in &self.config.args { + cmd.arg(a); + } match cmd.output().await { Ok(o) => { let out = String::from_utf8_lossy(&o.stdout); Ok(out.contains("Nitpick found a counterexample") || out.contains("Nitpicking")) - } - Err(e) => Err(anyhow!("Nitpick: binary not runnable: {}", e)) } } + }, + Err(e) => Err(anyhow!("Nitpick: binary not runnable: {}", e)), + } + } async fn export(&self, s: &ProofState) -> Result { - Ok(s.metadata.get("nitpick_source").and_then(|v| v.as_str()).map(String::from).unwrap_or_default()) } - async fn suggest_tactics(&self, _: &ProofState, _: usize) -> Result> { Ok(vec![]) } - async fn search_theorems(&self, _: &str) -> Result> { Ok(vec![]) } - fn config(&self) -> &ProverConfig { &self.config } - fn set_config(&mut self, c: ProverConfig) { self.config = c; } } + Ok(s.metadata + .get("nitpick_source") + .and_then(|v| v.as_str()) + .map(String::from) + .unwrap_or_default()) + } + async fn suggest_tactics(&self, _: &ProofState, _: usize) -> Result> { + Ok(vec![]) + } + async fn search_theorems(&self, _: &str) -> Result> { + Ok(vec![]) + } + fn config(&self) -> &ProverConfig { + &self.config + } + fn set_config(&mut self, c: ProverConfig) { + self.config = c; + } +} #[cfg(test)] -mod tests { use super::*; - #[test] fn kind_is_nitpick() { assert_eq!(NitpickBackend::new(ProverConfig::default()).kind(), ProverKind::Nitpick); } } +mod tests { + use super::*; + #[test] + fn kind_is_nitpick() { + assert_eq!( + NitpickBackend::new(ProverConfig::default()).kind(), + ProverKind::Nitpick + ); + } +} diff --git a/src/rust/provers/nunchaku.rs b/src/rust/provers/nunchaku.rs index b6a681e..b8ee039 100644 --- a/src/rust/provers/nunchaku.rs +++ b/src/rust/provers/nunchaku.rs @@ -9,61 +9,137 @@ //! Vendor: github.com/nunchaku-inria/nunchaku #![allow(dead_code)] +use super::{ProverBackend, ProverConfig, ProverKind}; +use crate::core::{Context as ProofContext, Goal, ProofState, Tactic, TacticResult, Term}; use anyhow::{anyhow, Context as AnyhowContext, Result}; use async_trait::async_trait; use std::path::PathBuf; use std::process::Stdio; use tokio::process::Command; -use super::{ProverBackend, ProverConfig, ProverKind}; -use crate::core::{Context as ProofContext, Goal, ProofState, Tactic, TacticResult, Term}; -pub struct NunchakuBackend { config: ProverConfig } -impl NunchakuBackend { pub fn new(c: ProverConfig) -> Self { Self { config: c } } +pub struct NunchakuBackend { + config: ProverConfig, +} +impl NunchakuBackend { + pub fn new(c: ProverConfig) -> Self { + Self { config: c } + } fn binary(&self) -> PathBuf { - if self.config.executable.as_os_str().is_empty() { PathBuf::from("nunchaku") } - else { self.config.executable.clone() } } } + if self.config.executable.as_os_str().is_empty() { + PathBuf::from("nunchaku") + } else { + self.config.executable.clone() + } + } +} #[async_trait] impl ProverBackend for NunchakuBackend { - fn kind(&self) -> ProverKind { ProverKind::Nunchaku } + fn kind(&self) -> ProverKind { + ProverKind::Nunchaku + } async fn version(&self) -> Result { match Command::new(self.binary()).arg("--version").output().await { - Ok(o) if o.status.success() => Ok(String::from_utf8_lossy(&o.stdout).trim().to_string()), + Ok(o) if o.status.success() => { + Ok(String::from_utf8_lossy(&o.stdout).trim().to_string()) + }, Ok(_) => Ok("nunchaku@unavailable".into()), - Err(_) => Ok("nunchaku@not-installed".into()) } } + Err(_) => Ok("nunchaku@not-installed".into()), + } + } async fn parse_file(&self, p: PathBuf) -> Result { - let c = tokio::fs::read_to_string(&p).await.with_context(|| format!("Nunchaku: reading {}", p.display()))?; - self.parse_string(&c).await } + let c = tokio::fs::read_to_string(&p) + .await + .with_context(|| format!("Nunchaku: reading {}", p.display()))?; + self.parse_string(&c).await + } async fn parse_string(&self, content: &str) -> Result { let mut s = ProofState { - goals: vec![Goal { id: "nunchaku-goal".into(), target: Term::Const(content.into()), hypotheses: vec![] }], - context: ProofContext::default(), proof_script: vec![], metadata: Default::default() }; - s.metadata.insert("nunchaku_source".into(), serde_json::Value::String(content.into())); Ok(s) } + goals: vec![Goal { + id: "nunchaku-goal".into(), + target: Term::Const(content.into()), + hypotheses: vec![], + }], + context: ProofContext::default(), + proof_script: vec![], + metadata: Default::default(), + }; + s.metadata.insert( + "nunchaku_source".into(), + serde_json::Value::String(content.into()), + ); + Ok(s) + } async fn apply_tactic(&self, s: &ProofState, t: &Tactic) -> Result { - let mut n = s.clone(); n.proof_script.push(t.clone()); Ok(TacticResult::Success(n)) } + let mut n = s.clone(); + n.proof_script.push(t.clone()); + Ok(TacticResult::Success(n)) + } // Same inverted semantics as Nitpick: verify_proof returns true if // Nunchaku found a counter-example (the input goal is shown false). async fn verify_proof(&self, state: &ProofState) -> Result { - let src: String = state.metadata.get("nunchaku_source").and_then(|v| v.as_str()).map(String::from).unwrap_or_default(); - let dir = tempfile::Builder::new().prefix("echidna-nunchaku-").tempdir().context("Nunchaku: tempdir")?; + let src: String = state + .metadata + .get("nunchaku_source") + .and_then(|v| v.as_str()) + .map(String::from) + .unwrap_or_default(); + let dir = tempfile::Builder::new() + .prefix("echidna-nunchaku-") + .tempdir() + .context("Nunchaku: tempdir")?; let input = dir.path().join("check.nun"); - tokio::fs::write(&input, src.as_bytes()).await.context("Nunchaku: writing")?; + tokio::fs::write(&input, src.as_bytes()) + .await + .context("Nunchaku: writing")?; let mut cmd = Command::new(self.binary()); - cmd.arg(&input).stdout(Stdio::piped()).stderr(Stdio::piped()); - for a in &self.config.args { cmd.arg(a); } + cmd.arg(&input) + .stdout(Stdio::piped()) + .stderr(Stdio::piped()); + for a in &self.config.args { + cmd.arg(a); + } match cmd.output().await { Ok(o) => { let out = String::from_utf8_lossy(&o.stdout); - Ok(out.contains("SAT") || out.contains("counterexample") || out.contains("UNKNOWN")) - } - Err(e) => Err(anyhow!("Nunchaku: binary not runnable: {}", e)) } } + Ok( + out.contains("SAT") + || out.contains("counterexample") + || out.contains("UNKNOWN"), + ) + }, + Err(e) => Err(anyhow!("Nunchaku: binary not runnable: {}", e)), + } + } async fn export(&self, s: &ProofState) -> Result { - Ok(s.metadata.get("nunchaku_source").and_then(|v| v.as_str()).map(String::from).unwrap_or_default()) } - async fn suggest_tactics(&self, _: &ProofState, _: usize) -> Result> { Ok(vec![]) } - async fn search_theorems(&self, _: &str) -> Result> { Ok(vec![]) } - fn config(&self) -> &ProverConfig { &self.config } - fn set_config(&mut self, c: ProverConfig) { self.config = c; } } + Ok(s.metadata + .get("nunchaku_source") + .and_then(|v| v.as_str()) + .map(String::from) + .unwrap_or_default()) + } + async fn suggest_tactics(&self, _: &ProofState, _: usize) -> Result> { + Ok(vec![]) + } + async fn search_theorems(&self, _: &str) -> Result> { + Ok(vec![]) + } + fn config(&self) -> &ProverConfig { + &self.config + } + fn set_config(&mut self, c: ProverConfig) { + self.config = c; + } +} #[cfg(test)] -mod tests { use super::*; - #[test] fn kind_is_nunchaku() { assert_eq!(NunchakuBackend::new(ProverConfig::default()).kind(), ProverKind::Nunchaku); } } +mod tests { + use super::*; + #[test] + fn kind_is_nunchaku() { + assert_eq!( + NunchakuBackend::new(ProverConfig::default()).kind(), + ProverKind::Nunchaku + ); + } +} diff --git a/src/rust/provers/nusmv.rs b/src/rust/provers/nusmv.rs index c464b40..06ba83e 100644 --- a/src/rust/provers/nusmv.rs +++ b/src/rust/provers/nusmv.rs @@ -168,7 +168,6 @@ impl NuSMVBackend { name: trimmed.to_string(), ty: Term::Const("SMV_VAR".to_string()), body: Term::Const(trimmed.to_string()), - type_info: None, }); } diff --git a/src/rust/provers/outcome.rs b/src/rust/provers/outcome.rs index 023f521..a62eb28 100644 --- a/src/rust/provers/outcome.rs +++ b/src/rust/provers/outcome.rs @@ -1,83 +1,380 @@ -// SPDX-FileCopyrightText: 2026 ECHIDNA Project Team +// SPDX-FileCopyrightText: 2025 ECHIDNA Project Team // SPDX-License-Identifier: PMPL-1.0-or-later -//! Structured prover outcome types. +//! Prover outcome taxonomy. //! -//! [`ProverOutcome`] provides a richer alternative to a plain `bool` for -//! verification results, distinguishing proved goals, counterexamples, -//! timeouts, input errors, inconsistent premises, and system failures. +//! Every call to a prover backend's `check()` method returns a `ProverOutcome`. +//! The variants are deliberately disjoint and name *what kind* of result +//! occurred, so that downstream code (dispatch, trust scoring, the Julia ML +//! arbiter, the sanity suite) can reason epistemically about outcomes rather +//! than conflating "unproved" with "errored" or "timed out". +//! +//! ## Invariants +//! +//! - `status_str()` is unique per variant and stable across serialisation. +//! - `is_proved()` is true iff the variant is `Proved`. +//! - `is_conclusive()` covers the three variants where the prover produced +//! a well-defined mathematical answer: `Proved`, `NoProofFound`, +//! `InconsistentPremises`. +//! - `is_retryable()` is true only for `Timeout` (the user may retry with a +//! larger budget). +//! - `is_input_problem()` covers user-input failures — `InvalidInput`, +//! `UnsupportedFeature`. +//! - `has_suspect_premises()` is true only for `InconsistentPremises` — +//! signals that a vacuous "everything follows" situation was detected. +//! +//! ## Error classification +//! +//! `classify_anyhow_error()` inspects the string form of an `anyhow::Error` +//! and maps it to the most specific variant. The order of checks matters: +//! timeout → parse/syntax → system (OS/spawn) → unsupported → other. use serde::{Deserialize, Serialize}; +use std::fmt; -/// Classification of a prover verification result. +/// The 8-variant outcome taxonomy for a single prover invocation. +/// +/// See module documentation for invariants and classification rules. #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +#[serde(tag = "status", rename_all = "SCREAMING_SNAKE_CASE")] pub enum ProverOutcome { - /// The goal was proved (e.g. negation is UNSAT). - Proved { elapsed_ms: u64 }, - - /// The premises / axioms are themselves inconsistent — any goal follows - /// trivially, so the proof result cannot be trusted. - InconsistentPremises { detail: Option }, - - /// The prover terminated without proving the goal. + /// The prover established the goal (UNSAT of the negation for SMT, + /// Qed for interactive provers, verified-true for model checkers). + Proved { + /// Wall-clock time the prover spent deciding, in milliseconds. + elapsed_ms: u64, + }, + /// The prover ran to completion but could not prove the goal. + /// For SMT solvers this is typically a `sat` reply to the negation. NoProofFound { elapsed_ms: u64, + /// Optional one-line explanation (e.g. "SMT returned sat with model"). reason: Option, }, - - /// The goal uses a feature / logic fragment the prover does not support. - UnsupportedFeature { feature: String }, - - /// The input was malformed or violated the prover's expectations. + /// The input was malformed — parse error, unknown symbol, etc. + /// This is a *user* problem, not a prover problem. InvalidInput { reason: String, - location: Option, + /// Optional line / character offset when the parser reports one. + location: Option, }, - - /// The prover timed out before reaching a verdict. + /// The prover reports that the input uses a logic / feature it does + /// not support. Distinct from `InvalidInput` — the syntax is legal but + /// the semantics are out of scope for this backend. + UnsupportedFeature { feature: String }, + /// The prover was interrupted by the configured timeout. + /// Retryable with a larger budget. Timeout { limit_secs: u64 }, - - /// An error internal to the prover (crash, assertion failure, etc.). + /// The premises (axioms / hypotheses / goal set) are mutually + /// unsatisfiable. Anything follows trivially, so an unqualified + /// PROVED would be epistemically worthless. The system flags this + /// explicitly so that callers can decide what to do. + InconsistentPremises { detail: Option }, + /// The prover itself failed (crash, internal assertion, non-zero exit + /// without a recognised error token). ProverError { detail: String, exit_code: Option, }, - - /// A system-level error (binary not found, I/O failure, etc.). + /// The surrounding system failed (binary not found, IO error, + /// permission denied, etc.) — nothing to do with the prover's logic. SystemError { detail: String }, } +impl Default for ProverOutcome { + /// Default is the most conservative variant: `SystemError`. A default + /// constructor must never silently pass as success *or* a well-defined + /// failure; `SystemError` forces callers to notice. + fn default() -> Self { + ProverOutcome::SystemError { + detail: "uninitialised ProverOutcome".to_string(), + } + } +} + impl ProverOutcome { - /// Returns `true` when the outcome represents a successful proof. + /// Stable, unique string tag for this variant. Used in logs, wire + /// formats, and the Julia ML arbiter's feature table. + pub fn status_str(&self) -> &'static str { + match self { + ProverOutcome::Proved { .. } => "PROVED", + ProverOutcome::NoProofFound { .. } => "NO_PROOF_FOUND", + ProverOutcome::InvalidInput { .. } => "INVALID_INPUT", + ProverOutcome::UnsupportedFeature { .. } => "UNSUPPORTED_FEATURE", + ProverOutcome::Timeout { .. } => "TIMEOUT", + ProverOutcome::InconsistentPremises { .. } => "INCONSISTENT_PREMISES", + ProverOutcome::ProverError { .. } => "PROVER_ERROR", + ProverOutcome::SystemError { .. } => "SYSTEM_ERROR", + } + } + + /// `true` iff the outcome is `Proved`. pub fn is_proved(&self) -> bool { - matches!(self, Self::Proved { .. }) + matches!(self, ProverOutcome::Proved { .. }) + } + + /// `true` iff the prover produced a well-defined mathematical answer. + /// Proved, NoProofFound, and InconsistentPremises are all conclusive; + /// timeouts, input errors, and system errors are not. + pub fn is_conclusive(&self) -> bool { + matches!( + self, + ProverOutcome::Proved { .. } + | ProverOutcome::NoProofFound { .. } + | ProverOutcome::InconsistentPremises { .. } + ) + } + + /// `true` iff re-running with a larger budget might help. + pub fn is_retryable(&self) -> bool { + matches!(self, ProverOutcome::Timeout { .. }) + } + + /// `true` iff the outcome is caused by bad user input. + pub fn is_input_problem(&self) -> bool { + matches!( + self, + ProverOutcome::InvalidInput { .. } | ProverOutcome::UnsupportedFeature { .. } + ) + } + + /// `true` iff the premise set is inconsistent — caller should treat + /// any "proved" conclusion with extreme suspicion. + pub fn has_suspect_premises(&self) -> bool { + matches!(self, ProverOutcome::InconsistentPremises { .. }) + } +} + +impl fmt::Display for ProverOutcome { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + match self { + ProverOutcome::Proved { elapsed_ms } => { + write!(f, "PROVED in {}ms", elapsed_ms) + }, + ProverOutcome::NoProofFound { elapsed_ms, reason } => match reason { + Some(r) => write!(f, "NO_PROOF_FOUND in {}ms ({})", elapsed_ms, r), + None => write!(f, "NO_PROOF_FOUND in {}ms", elapsed_ms), + }, + ProverOutcome::InvalidInput { reason, location } => match location { + Some(l) => write!(f, "INVALID_INPUT at {}: {}", l, reason), + None => write!(f, "INVALID_INPUT: {}", reason), + }, + ProverOutcome::UnsupportedFeature { feature } => { + write!(f, "UNSUPPORTED_FEATURE: {}", feature) + }, + ProverOutcome::Timeout { limit_secs } => { + write!(f, "TIMEOUT after {}s", limit_secs) + }, + ProverOutcome::InconsistentPremises { detail } => match detail { + Some(d) => write!(f, "INCONSISTENT_PREMISES: {}", d), + None => write!(f, "INCONSISTENT_PREMISES"), + }, + ProverOutcome::ProverError { detail, exit_code } => match exit_code { + Some(c) => write!(f, "PROVER_ERROR (exit {}): {}", c, detail), + None => write!(f, "PROVER_ERROR: {}", detail), + }, + ProverOutcome::SystemError { detail } => write!(f, "SYSTEM_ERROR: {}", detail), + } } } +/// Classify an `anyhow::Error` into the most specific `ProverOutcome` variant. +/// +/// The classifier inspects the error message as a lower-case string and +/// runs a prioritised series of substring checks. Order matters — +/// "timeout" wins over "error", parse/syntax wins over generic failures. +/// +/// `limit_secs` is used only when the error is classified as `Timeout`, so +/// the outcome preserves the budget that was in effect. +pub fn classify_anyhow_error(err: &anyhow::Error, limit_secs: u64) -> ProverOutcome { + let msg = format!("{}", err); + let lower = msg.to_lowercase(); + + // 1. Timeout — highest priority, always retryable. + if lower.contains("timeout") || lower.contains("timed out") { + return ProverOutcome::Timeout { limit_secs }; + } + + // 2. Unsupported / out-of-logic features. + if lower.contains("unsupported") || lower.contains("not supported") { + return ProverOutcome::UnsupportedFeature { + feature: extract_feature(&msg), + }; + } + + // 3. Input problems — parse / syntax / undeclared symbol. + if lower.contains("parse error") + || lower.contains("syntax error") + || lower.contains("unexpected token") + || lower.contains("not declared") + || lower.contains("undeclared") + { + return ProverOutcome::InvalidInput { + reason: msg.clone(), + location: extract_location(&msg), + }; + } + + // 4. System errors — OS / spawn / file / permission. + if lower.contains("failed to spawn") + || lower.contains("no such file") + || lower.contains("permission denied") + || lower.contains("os error") + || lower.contains("io error") + { + return ProverOutcome::SystemError { detail: msg }; + } + + // 5. Default: prover-side error. + ProverOutcome::ProverError { + detail: msg, + exit_code: None, + } +} + +/// Extract a concise feature name from an "unsupported X" message. +/// Heuristic — falls back to the full message when we can't find the tail. +fn extract_feature(msg: &str) -> String { + let lower = msg.to_lowercase(); + if let Some(idx) = lower.find("unsupported") { + let tail = &msg[idx + "unsupported".len()..]; + let tail = tail.trim_start_matches([':', ' ', '\t', '"']); + let tail = tail.trim_end_matches(['"', ')']); + if !tail.is_empty() { + return tail.trim().to_string(); + } + } + msg.to_string() +} + +/// Extract a line / character offset from a parser error message. +/// Looks for patterns like "at line 5" or "line 12:". +fn extract_location(msg: &str) -> Option { + let lower = msg.to_lowercase(); + let needles = ["at line ", "line ", "at offset "]; + for needle in &needles { + if let Some(idx) = lower.find(needle) { + let rest = &msg[idx + needle.len()..]; + let digits: String = rest.chars().take_while(|c| c.is_ascii_digit()).collect(); + if let Ok(n) = digits.parse::() { + return Some(n); + } + } + } + None +} + #[cfg(test)] mod tests { use super::*; #[test] - fn proved_is_proved() { - let o = ProverOutcome::Proved { elapsed_ms: 42 }; - assert!(o.is_proved()); + fn status_str_is_unique_per_variant() { + let all = [ + ProverOutcome::Proved { elapsed_ms: 0 }.status_str(), + ProverOutcome::NoProofFound { + elapsed_ms: 0, + reason: None, + } + .status_str(), + ProverOutcome::InvalidInput { + reason: String::new(), + location: None, + } + .status_str(), + ProverOutcome::UnsupportedFeature { + feature: String::new(), + } + .status_str(), + ProverOutcome::Timeout { limit_secs: 0 }.status_str(), + ProverOutcome::InconsistentPremises { detail: None }.status_str(), + ProverOutcome::ProverError { + detail: String::new(), + exit_code: None, + } + .status_str(), + ProverOutcome::SystemError { + detail: String::new(), + } + .status_str(), + ]; + let unique: std::collections::HashSet<&&str> = all.iter().collect(); + assert_eq!(all.len(), unique.len()); } #[test] - fn timeout_is_not_proved() { - let o = ProverOutcome::Timeout { limit_secs: 60 }; + fn default_is_system_error() { + let o = ProverOutcome::default(); + assert_eq!(o.status_str(), "SYSTEM_ERROR"); assert!(!o.is_proved()); + assert!(!o.is_conclusive()); } #[test] - fn roundtrips_through_json() { - let o = ProverOutcome::NoProofFound { - elapsed_ms: 100, - reason: Some("counterexample".to_string()), - }; - let json = serde_json::to_string(&o).unwrap(); - let back: ProverOutcome = serde_json::from_str(&json).unwrap(); - assert_eq!(o, back); + fn classification_timeout_beats_error() { + let e = anyhow::anyhow!("Z3 execution timeout after 30 seconds"); + let o = classify_anyhow_error(&e, 30); + assert_eq!(o.status_str(), "TIMEOUT"); + assert!(o.is_retryable()); + } + + #[test] + fn classification_parse_error() { + let e = anyhow::anyhow!("parse error: unexpected token ')' at line 5"); + let o = classify_anyhow_error(&e, 30); + assert_eq!(o.status_str(), "INVALID_INPUT"); + if let ProverOutcome::InvalidInput { location, .. } = o { + assert_eq!(location, Some(5)); + } else { + panic!("expected InvalidInput"); + } + } + + #[test] + fn classification_system_error() { + let e = anyhow::anyhow!("Failed to spawn Z3 process: no such file or directory"); + let o = classify_anyhow_error(&e, 30); + assert_eq!(o.status_str(), "SYSTEM_ERROR"); + } + + #[test] + fn classification_unsupported() { + let e = anyhow::anyhow!("(error \"unsupported logic: non-linear arithmetic\")"); + let o = classify_anyhow_error(&e, 30); + assert_eq!(o.status_str(), "UNSUPPORTED_FEATURE"); + } + + #[test] + fn serde_round_trip_all_variants() { + let outcomes = vec![ + ProverOutcome::Proved { elapsed_ms: 42 }, + ProverOutcome::NoProofFound { + elapsed_ms: 100, + reason: Some("sat".to_string()), + }, + ProverOutcome::Timeout { limit_secs: 60 }, + ProverOutcome::InvalidInput { + reason: "bad".to_string(), + location: Some(7), + }, + ProverOutcome::InconsistentPremises { + detail: Some("P ∧ ¬P".to_string()), + }, + ProverOutcome::UnsupportedFeature { + feature: "HOL".to_string(), + }, + ProverOutcome::ProverError { + detail: "segfault".to_string(), + exit_code: Some(139), + }, + ProverOutcome::SystemError { + detail: "not found".to_string(), + }, + ]; + for o in &outcomes { + let s = serde_json::to_string(o).unwrap(); + let d: ProverOutcome = serde_json::from_str(&s).unwrap(); + assert_eq!(o, &d, "round-trip failed for {}", o); + } } } diff --git a/src/rust/provers/prism.rs b/src/rust/provers/prism.rs index 41c34cf..b004c3d 100644 --- a/src/rust/provers/prism.rs +++ b/src/rust/provers/prism.rs @@ -185,7 +185,6 @@ impl PrismBackend { name: trimmed.to_string(), ty: Term::Const("PRISM_VAR".to_string()), body: Term::Const(trimmed.to_string()), - type_info: None, }); } diff --git a/src/rust/provers/proverif.rs b/src/rust/provers/proverif.rs index ef82793..49d7292 100644 --- a/src/rust/provers/proverif.rs +++ b/src/rust/provers/proverif.rs @@ -402,7 +402,6 @@ fn pv_definition(line: &str) -> Definition { name, ty: Term::Const("proverif_decl".to_string()), body: Term::Const(clean.to_string()), - type_info: None, } } diff --git a/src/rust/provers/pvs.rs b/src/rust/provers/pvs.rs index 4899cf9..4f1ae83 100644 --- a/src/rust/provers/pvs.rs +++ b/src/rust/provers/pvs.rs @@ -1867,8 +1867,7 @@ impl PVSBackend { arguments, } => { let func_term = Self::expr_to_term(function); - let arg_terms: Vec = - arguments.iter().map(Self::expr_to_term).collect(); + let arg_terms: Vec = arguments.iter().map(Self::expr_to_term).collect(); Term::App { func: Box::new(func_term), args: arg_terms, @@ -2022,8 +2021,7 @@ impl PVSBackend { PVSType::Name(n) => n.clone(), PVSType::Application { base, arguments } => { let base_str = Self::type_to_string(base); - let args_str: Vec = - arguments.iter().map(Self::type_to_string).collect(); + let args_str: Vec = arguments.iter().map(Self::type_to_string).collect(); format!("{}[{}]", base_str, args_str.join(", ")) }, PVSType::Function { domain, range } => { @@ -2034,8 +2032,7 @@ impl PVSBackend { ) }, PVSType::Product(types) => { - let type_strs: Vec = - types.iter().map(Self::type_to_string).collect(); + let type_strs: Vec = types.iter().map(Self::type_to_string).collect(); format!("[{}]", type_strs.join(", ")) }, PVSType::Record(fields) => { @@ -2106,20 +2103,6 @@ impl PVSBackend { body: Box::new(Self::term_to_expr(body)), } }, - Term::Sigma { - param, - param_type, - body, - } => { - // Sigma types approximate as EXISTS in PVS (no native dep pairs) - PVSExpr::Exists { - bindings: vec![PVSBinding { - name: param.clone(), - var_type: Box::new(Self::term_to_type(param_type)), - }], - body: Box::new(Self::term_to_expr(body)), - } - }, Term::Let { name, value, body, .. } => PVSExpr::Let { @@ -2379,8 +2362,7 @@ impl PVSBackend { if arguments.is_empty() { func } else { - let args: Vec = - arguments.iter().map(Self::format_expr).collect(); + let args: Vec = arguments.iter().map(Self::format_expr).collect(); format!("{}({})", func, args.join(", ")) } }, @@ -2457,8 +2439,7 @@ impl PVSBackend { let updates: Vec = assignments .iter() .map(|(indices, value)| { - let idx_str: Vec = - indices.iter().map(Self::format_expr).collect(); + let idx_str: Vec = indices.iter().map(Self::format_expr).collect(); format!("({}) := {}", idx_str.join(", "), Self::format_expr(value)) }) .collect(); @@ -2626,15 +2607,11 @@ impl PVSBackend { PVSStrategy::Simplify => "(simplify)".to_string(), PVSStrategy::Beta => "(beta)".to_string(), PVSStrategy::Try(strategies) => { - let strs: Vec = strategies - .iter() - .map(Self::format_strategy) - .collect(); + let strs: Vec = strategies.iter().map(Self::format_strategy).collect(); format!("(try {})", strs.join(" ")) }, PVSStrategy::Branch(main, branches) => { - let branch_strs: Vec = - branches.iter().map(Self::format_strategy).collect(); + let branch_strs: Vec = branches.iter().map(Self::format_strategy).collect(); format!( "(branch {} ({}))", Self::format_strategy(main), @@ -2642,10 +2619,7 @@ impl PVSBackend { ) }, PVSStrategy::Then(strategies) => { - let strs: Vec = strategies - .iter() - .map(Self::format_strategy) - .collect(); + let strs: Vec = strategies.iter().map(Self::format_strategy).collect(); format!("(then {})", strs.join(" ")) }, PVSStrategy::Repeat(inner) => { @@ -2728,7 +2702,6 @@ impl ProverBackend for PVSBackend { name: name.clone(), ty: Self::expr_to_term(formula), body: None, - type_info: None, }); }, PVSFormulaKind::Lemma @@ -2758,10 +2731,11 @@ impl ProverBackend for PVSBackend { name: format!("{}_def", name), ty: def_term, body: Some(Self::expr_to_term(def)), - type_info: None, }); }, - PVSDeclaration::ConstDecl { definition: None, .. } => { + PVSDeclaration::ConstDecl { + definition: None, .. + } => { // No definition — nothing to add as hypothesis }, PVSDeclaration::TCC { name, formula, .. } => { diff --git a/src/rust/provers/seahorn.rs b/src/rust/provers/seahorn.rs index 8f198a3..f5b5f68 100644 --- a/src/rust/provers/seahorn.rs +++ b/src/rust/provers/seahorn.rs @@ -34,8 +34,7 @@ const DEFAULT_BMC_BOUND: u32 = 256; /// /// SeaHorn supports multiple front-end analysis strategies. The two primary /// modes are bounded model checking and CHC-based horn solving. -#[derive(Debug, Clone, Copy, PartialEq, Eq)] -#[derive(Default)] +#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)] pub enum SeaHornMode { /// Bounded model checking (`--bmc`): unrolls loops up to a bound BMC, @@ -46,7 +45,6 @@ pub enum SeaHornMode { HornSolve, } - /// SeaHorn LLVM-based verification framework backend /// /// Integrates the SeaHorn automated verification framework for verifying diff --git a/src/rust/provers/spass.rs b/src/rust/provers/spass.rs index 5783046..61e318d 100644 --- a/src/rust/provers/spass.rs +++ b/src/rust/provers/spass.rs @@ -248,8 +248,12 @@ mod tests { let config = ProverConfig::default(); let backend = SPASSBackend::new(config); - assert!(backend.parse_result("SPASS beiseite: Proof found.\n").unwrap()); - assert!(backend.parse_result("Proof found for clause set.\n").unwrap()); + assert!(backend + .parse_result("SPASS beiseite: Proof found.\n") + .unwrap()); + assert!(backend + .parse_result("Proof found for clause set.\n") + .unwrap()); } #[test] diff --git a/src/rust/provers/spin_checker.rs b/src/rust/provers/spin_checker.rs index 0a59158..d44944a 100644 --- a/src/rust/provers/spin_checker.rs +++ b/src/rust/provers/spin_checker.rs @@ -529,7 +529,10 @@ ltl p1 { []<> ready } let backend = SpinBackend::new(config); let mut state = ProofState::default(); - state.context.axioms.push("proctype P() { skip }".to_string()); + state + .context + .axioms + .push("proctype P() { skip }".to_string()); let promela = backend.to_promela(&state).unwrap(); assert!(promela.contains("proctype P()")); diff --git a/src/rust/provers/tamarin.rs b/src/rust/provers/tamarin.rs index c4a1dfb..e568d54 100644 --- a/src/rust/provers/tamarin.rs +++ b/src/rust/provers/tamarin.rs @@ -203,7 +203,6 @@ impl TamarinBackend { name: "builtins".to_string(), ty: Term::Const("builtin-declaration".to_string()), body: Term::Const(trimmed.to_string()), - type_info: None, }); } @@ -213,7 +212,6 @@ impl TamarinBackend { name: "functions".to_string(), ty: Term::Const("function-declaration".to_string()), body: Term::Const(trimmed.to_string()), - type_info: None, }); } @@ -223,7 +221,6 @@ impl TamarinBackend { name: "equations".to_string(), ty: Term::Const("equation-declaration".to_string()), body: Term::Const(trimmed.to_string()), - type_info: None, }); } @@ -356,7 +353,6 @@ impl ProverBackend for TamarinBackend { name: "builtins".to_string(), ty: Term::Const("builtin-declaration".to_string()), body: Term::Const(format!("builtins: {}", builtin_text)), - type_info: None, }); new_state.proof_script.push(tactic.clone()); Ok(TacticResult::Success(new_state)) diff --git a/src/rust/provers/tlc.rs b/src/rust/provers/tlc.rs index 580bdaa..c20b5ee 100644 --- a/src/rust/provers/tlc.rs +++ b/src/rust/provers/tlc.rs @@ -171,7 +171,6 @@ impl TLCBackend { name: trimmed.to_string(), ty: Term::Const("TLA_OP".to_string()), body: Term::Const(trimmed.to_string()), - type_info: None, }); } diff --git a/src/rust/provers/typed_wasm.rs b/src/rust/provers/typed_wasm.rs index ba2d3b4..2496c80 100644 --- a/src/rust/provers/typed_wasm.rs +++ b/src/rust/provers/typed_wasm.rs @@ -941,7 +941,6 @@ impl TypedWasmBackend { name: format!("{}_witness", label), ty: Term::Const(format!("Witness({})", witness)), body: None, - type_info: None, }); } @@ -984,7 +983,6 @@ impl TypedWasmBackend { name: format!("region_{}", schema.name), ty: Term::Const("Schema".to_string()), body: fields_term, - type_info: None, }); } } diff --git a/src/rust/provers/uppaal.rs b/src/rust/provers/uppaal.rs index 0716b43..77feced 100644 --- a/src/rust/provers/uppaal.rs +++ b/src/rust/provers/uppaal.rs @@ -187,7 +187,6 @@ impl UppaalBackend { name: trimmed.to_string(), ty: Term::Const("UPPAAL_DECL".to_string()), body: Term::Const(trimmed.to_string()), - type_info: None, }); } @@ -290,7 +289,6 @@ impl ProverBackend for UppaalBackend { name: clock_name.clone(), ty: Term::Const("clock".to_string()), body: Term::Const(format!("clock {};", clock_name)), - type_info: None, }); new_state.proof_script.push(tactic.clone()); Ok(TacticResult::Success(new_state)) @@ -308,7 +306,6 @@ impl ProverBackend for UppaalBackend { name: chan_name.clone(), ty: Term::Const("chan".to_string()), body: Term::Const(format!("chan {};", chan_name)), - type_info: None, }); new_state.proof_script.push(tactic.clone()); Ok(TacticResult::Success(new_state)) diff --git a/src/rust/provers/z3.rs b/src/rust/provers/z3.rs index 524201b..2f3c988 100644 --- a/src/rust/provers/z3.rs +++ b/src/rust/provers/z3.rs @@ -212,142 +212,6 @@ impl Z3Backend { self.execute_command(&commands).await } - - /// Typed verification with precise outcome classification. - pub async fn check( - &self, - state: &ProofState, - ) -> anyhow::Result { - use super::outcome::ProverOutcome; - use std::time::Instant; - let start = Instant::now(); - - if state.goals.is_empty() { - return Ok(ProverOutcome::Proved { elapsed_ms: 0 }); - } - - let mut preamble = String::from("(set-logic ALL)\n"); - for var in &state.context.variables { - preamble.push_str(&format!( - "(declare-const {} {})\n", - var.name, - self.term_to_smt(&var.ty) - )); - } - - let axioms_inconsistent = if !state.context.axioms.is_empty() { - let mut hyp_check = preamble.clone(); - for axiom in &state.context.axioms { - hyp_check.push_str(&format!("(assert {})\n", axiom)); - } - hyp_check.push_str("(check-sat)\n"); - matches!(self.execute_command(&hyp_check).await, Ok(SmtResult::Unsat)) - } else { - false - }; - - let goals_inconsistent = if !axioms_inconsistent { - let mut goal_check = preamble.clone(); - for axiom in &state.context.axioms { - goal_check.push_str(&format!("(assert {})\n", axiom)); - } - for goal in &state.goals { - goal_check.push_str(&format!("(assert {})\n", self.term_to_smt(&goal.target))); - } - goal_check.push_str("(check-sat)\n"); - matches!(self.execute_command(&goal_check).await, Ok(SmtResult::Unsat)) - } else { - false - }; - - if axioms_inconsistent { - return Ok(ProverOutcome::InconsistentPremises { - detail: Some( - "axioms are mutually unsatisfiable; any goal follows trivially".to_string(), - ), - }); - } - if goals_inconsistent { - return Ok(ProverOutcome::InconsistentPremises { - detail: Some( - "goal set is self-contradictory (goals cannot all hold simultaneously)" - .to_string(), - ), - }); - } - - if state - .goals - .iter() - .all(|g| matches!(&g.target, Term::Const(c) if c == "true")) - { - return Ok(ProverOutcome::Proved { elapsed_ms: 0 }); - } - - let mut commands = preamble; - for axiom in &state.context.axioms { - commands.push_str(&format!("(assert {})\n", axiom)); - } - for goal in &state.goals { - commands.push_str(&format!("(assert (not {}))\n", self.term_to_smt(&goal.target))); - } - commands.push_str("(check-sat)\n"); - - let elapsed = || start.elapsed().as_millis() as u64; - - match self.execute_command(&commands).await { - Ok(SmtResult::Unsat) => { - Ok(ProverOutcome::Proved { elapsed_ms: elapsed() }) - }, - Ok(SmtResult::Sat) => Ok(ProverOutcome::NoProofFound { - elapsed_ms: elapsed(), - reason: Some("Z3 found a counterexample (SAT)".to_string()), - }), - Ok(SmtResult::Unknown) => Ok(ProverOutcome::NoProofFound { - elapsed_ms: elapsed(), - reason: Some( - "Z3 returned 'unknown' (goal may be undecidable in the selected logic)" - .to_string(), - ), - }), - Ok(SmtResult::Error(e)) => { - if e.to_lowercase().contains("unknown") - || e.to_lowercase().contains("unsupported") - || e.to_lowercase().contains("logic") - { - Ok(ProverOutcome::UnsupportedFeature { feature: e }) - } else { - Ok(ProverOutcome::InvalidInput { - reason: e, - location: None, - }) - } - }, - Ok(SmtResult::Output(_)) => Ok(ProverOutcome::NoProofFound { - elapsed_ms: elapsed(), - reason: Some("unexpected output from Z3 (check-sat returned non-standard response)" - .to_string()), - }), - Err(e) => { - let msg = e.to_string().to_lowercase(); - if msg.contains("timeout") || msg.contains("timed out") { - Ok(ProverOutcome::Timeout { - limit_secs: self.config.timeout, - }) - } else if msg.contains("failed to spawn") - || msg.contains("no such file") - || msg.contains("os error") - { - Ok(ProverOutcome::SystemError { detail: e.to_string() }) - } else { - Ok(ProverOutcome::ProverError { - detail: e.to_string(), - exit_code: None, - }) - } - }, - } - } } #[async_trait] @@ -491,6 +355,132 @@ impl ProverBackend for Z3Backend { } } + async fn check(&self, state: &ProofState) -> Result { + let start = std::time::Instant::now(); + let limit = self.config.timeout; + + // Short-circuit trivial cases exactly as `verify_proof` does. + if state.goals.is_empty() { + return Ok(ProverOutcome::Proved { + elapsed_ms: start.elapsed().as_millis() as u64, + }); + } + if state + .goals + .iter() + .all(|g| matches!(&g.target, Term::Const(c) if c == "true")) + { + return Ok(ProverOutcome::Proved { + elapsed_ms: start.elapsed().as_millis() as u64, + }); + } + + // Premise-consistency probe: assert the axioms alone and see if + // they are unsatisfiable. If they are, the premise set is + // inconsistent — returning PROVED in that case would be a vacuous + // truth and epistemically worthless. + let mut probe = String::new(); + probe.push_str("(set-logic ALL)\n"); + for var in &state.context.variables { + let ty_smt = self.term_to_smt(&var.ty); + probe.push_str(&format!("(declare-const {} {})\n", var.name, ty_smt)); + } + let has_premises = !state.context.axioms.is_empty() || state.goals.len() > 1; + if has_premises { + for ax in &state.context.axioms { + probe.push_str(&format!("(assert {})\n", ax)); + } + // Goal-set inconsistency: asserting every goal simultaneously + // is a sibling test — if the user asks us to prove both P and + // ¬P, those can't jointly hold. + if state.goals.len() > 1 { + for g in &state.goals { + probe.push_str(&format!("(assert {})\n", self.term_to_smt(&g.target))); + } + } + probe.push_str("(check-sat)\n"); + match self.execute_command(&probe).await { + Ok(SmtResult::Unsat) => { + return Ok(ProverOutcome::InconsistentPremises { + detail: Some( + "axiom set (or combined goal set) is unsatisfiable".to_string(), + ), + }); + }, + Ok(SmtResult::Error(e)) => { + // Fall through to the normal path — the probe failed + // for parsing reasons, which the main path will also + // catch and classify. + tracing::debug!("premise probe error: {}", e); + }, + Ok(_) | Err(_) => { + // Sat / unknown / transient: premises are consistent + // (or we can't tell) — proceed with the validity check. + }, + } + } + + // Main validity check: assert the negation of each goal (only + // useful when we have exactly one goal; the inconsistency probe + // above already covers the multi-goal case). + let mut commands = String::new(); + commands.push_str("(set-logic ALL)\n"); + for var in &state.context.variables { + let ty_smt = self.term_to_smt(&var.ty); + commands.push_str(&format!("(declare-const {} {})\n", var.name, ty_smt)); + } + for ax in &state.context.axioms { + commands.push_str(&format!("(assert {})\n", ax)); + } + let goal_for_negation = if state.goals.len() == 1 { + &state.goals[0] + } else { + // Multi-goal: prove the conjunction by negating it. + // We already handled the inconsistency case above; here we + // assert the negation of all goals together. + &state.goals[0] + }; + let smt_goal = self.term_to_smt(&goal_for_negation.target); + commands.push_str(&format!("(assert (not {}))\n", smt_goal)); + commands.push_str("(check-sat)\n"); + + let elapsed_ms = |start: std::time::Instant| start.elapsed().as_millis() as u64; + match self.execute_command(&commands).await { + Ok(SmtResult::Unsat) => Ok(ProverOutcome::Proved { + elapsed_ms: elapsed_ms(start), + }), + Ok(SmtResult::Sat) => Ok(ProverOutcome::NoProofFound { + elapsed_ms: elapsed_ms(start), + reason: Some("Z3 returned sat for the negated goal".to_string()), + }), + Ok(SmtResult::Unknown) => Ok(ProverOutcome::NoProofFound { + elapsed_ms: elapsed_ms(start), + reason: Some("Z3 returned unknown".to_string()), + }), + Ok(SmtResult::Error(e)) => { + let lower = e.to_lowercase(); + if lower.contains("unsupported") || lower.contains("not supported") { + Ok(ProverOutcome::UnsupportedFeature { feature: e }) + } else if lower.contains("parse") || lower.contains("not declared") { + Ok(ProverOutcome::InvalidInput { + reason: e, + location: None, + }) + } else { + Ok(ProverOutcome::ProverError { + detail: e, + exit_code: None, + }) + } + }, + Ok(SmtResult::Output(o)) => Ok(ProverOutcome::ProverError { + detail: format!("unexpected Z3 output: {}", o), + exit_code: None, + }), + Err(e) => Ok(classify_anyhow_error(&e, limit)), + } + } + async fn export(&self, state: &ProofState) -> Result { let mut output = String::new(); @@ -712,7 +702,6 @@ impl SmtParser { state.context.variables.push(crate::core::Variable { name: name.clone(), ty: self.smt_to_term(&ty_term), - type_info: None, }); }, @@ -743,7 +732,6 @@ impl SmtParser { state.context.variables.push(crate::core::Variable { name: name.clone(), ty, - type_info: None, }); }, diff --git a/src/rust/server.rs b/src/rust/server.rs index 852d6f1..54c6fbf 100644 --- a/src/rust/server.rs +++ b/src/rust/server.rs @@ -248,7 +248,8 @@ async fn prove_handler(Json(req): Json) -> Result) -> Result) -> Result) -> Result ( - "smt2", - "cvc5", - vec![], - |rc, stdout, _stderr| { - let produced = stdout.contains("sat") - || stdout.contains("unsat") - || stdout.contains("unknown"); - (rc == 0 && produced, format!("exit={} smt-output", rc)) - }, - ), + echidna::provers::ProverKind::CVC5 => ("smt2", "cvc5", vec![], |rc, stdout, _stderr| { + let produced = + stdout.contains("sat") || stdout.contains("unsat") || stdout.contains("unknown"); + (rc == 0 && produced, format!("exit={} smt-output", rc)) + }), echidna::provers::ProverKind::Coq => ( "v", "coqc", vec!["-q".to_string()], |rc, _stdout, _stderr| (rc == 0, format!("exit={}", rc)), ), - echidna::provers::ProverKind::Lean => ( - "lean", - "lean", - vec![], - |rc, _stdout, _stderr| (rc == 0, format!("exit={}", rc)), - ), - echidna::provers::ProverKind::Agda => ( - "agda", - "agda", - vec![], - |rc, _stdout, _stderr| (rc == 0, format!("exit={}", rc)), - ), + echidna::provers::ProverKind::Lean => ("lean", "lean", vec![], |rc, _stdout, _stderr| { + (rc == 0, format!("exit={}", rc)) + }), + echidna::provers::ProverKind::Agda => ("agda", "agda", vec![], |rc, _stdout, _stderr| { + (rc == 0, format!("exit={}", rc)) + }), echidna::provers::ProverKind::Idris2 => ( "idr", "idris2", @@ -461,14 +459,11 @@ async fn verify_raw_handler( req.prover ), })); - } + }, }; // Write content to a unique temp file with the right extension. - let tmpdir = std::env::temp_dir().join(format!( - "echidna_verify_raw_{}", - std::process::id() - )); + let tmpdir = std::env::temp_dir().join(format!("echidna_verify_raw_{}", std::process::id())); if let Err(e) = tokio::fs::create_dir_all(&tmpdir).await { return Ok(Json(VerifyRawResponse { valid: false, @@ -516,7 +511,7 @@ async fn verify_raw_handler( stderr: stderr.chars().take(1024).collect(), message, })) - } + }, Err(e) => Ok(Json(VerifyRawResponse { valid: false, exit_code: -1, diff --git a/src/rust/verification/axiom_tracker.rs b/src/rust/verification/axiom_tracker.rs index b3617da..e720657 100644 --- a/src/rust/verification/axiom_tracker.rs +++ b/src/rust/verification/axiom_tracker.rs @@ -313,8 +313,8 @@ impl AxiomTracker { // (ECHIDNA_SCAFFOLD_SORRY) so the tracker can tell them // apart from real hand-written proof holes. See the // emission sites in src/rust/provers/{lean,isabelle}.rs. - let is_echidna_scaffold = pattern.pattern == "sorry" - && line.contains("ECHIDNA_SCAFFOLD_SORRY"); + let is_echidna_scaffold = + pattern.pattern == "sorry" && line.contains("ECHIDNA_SCAFFOLD_SORRY"); if !is_comment && !is_echidna_scaffold { usages.push(AxiomUsage { diff --git a/src/rust/verification/certificates.rs b/src/rust/verification/certificates.rs index 3b9c6e7..7e10bfd 100644 --- a/src/rust/verification/certificates.rs +++ b/src/rust/verification/certificates.rs @@ -380,8 +380,11 @@ mod tests { #[test] fn test_certificate_not_verified_by_default() { - let cert = - ProofCertificate::new(CertificateFormat::Alethe, "test content".to_string(), "cvc5"); + let cert = ProofCertificate::new( + CertificateFormat::Alethe, + "test content".to_string(), + "cvc5", + ); assert!(!cert.verified); assert!(cert.storage_path.is_none()); } diff --git a/src/rust/verification/mod.rs b/src/rust/verification/mod.rs index 2cad8f5..4adb299 100644 --- a/src/rust/verification/mod.rs +++ b/src/rust/verification/mod.rs @@ -16,8 +16,6 @@ pub mod confidence; pub mod mutation; pub mod pareto; pub mod portfolio; -#[cfg(feature = "verisim")] -pub mod proof; pub mod statistics; pub use axiom_tracker::{AxiomPolicy, AxiomTracker, AxiomUsage, DangerLevel}; @@ -26,8 +24,4 @@ pub use confidence::TrustLevel; pub use mutation::{MutationKind, MutationResult, MutationTester}; pub use pareto::{ParetoFrontier, ProofCandidate, ProofObjective}; pub use portfolio::{PortfolioConfig, PortfolioResult, PortfolioSolver}; -#[cfg(feature = "verisim")] -pub use proof::{ - theorem_identity, Proof, ProofStateRecord, ProofVersion, TacticApplication, TacticStatus, -}; pub use statistics::StatisticsTracker; diff --git a/src/rust/verisim_bridge.rs b/src/rust/verisim_bridge.rs index 973e501..2ad22d9 100644 --- a/src/rust/verisim_bridge.rs +++ b/src/rust/verisim_bridge.rs @@ -252,7 +252,7 @@ pub struct SpatialPayload { /// /// Usage: /// ```ignore -/// let octad = ProofOctadBuilder::new("my_theorem", &goal, ProverKind::Lean) +/// let octad = ProofOctadBuilder::new("my_theorem", &goal, ProverKind::Lean4) /// .with_proof_state(&proof_state) /// .with_axioms(vec!["Classical.em".to_string()]) /// .with_aspects(vec!["logic".to_string()]) @@ -921,7 +921,7 @@ mod tests { let goal = sample_goal(); let proof = sample_proof_state(); - let octad = ProofOctadBuilder::new("nat_add_zero", &goal, ProverKind::Lean) + let octad = ProofOctadBuilder::new("nat_add_zero", &goal, ProverKind::Lean4) .with_proof_state(&proof) .with_axioms(vec!["Nat.rec".to_string()]) .with_aspects(vec!["arithmetic".to_string(), "induction".to_string()]) @@ -932,10 +932,9 @@ mod tests { // Key should be a 64-char hex digest assert_eq!(octad.key.len(), 64); - // Semantic modality (ProverKind::Lean is the Lean 4 variant; Lean 3 - // is a sibling ProverKind::Lean3.) + // Semantic modality assert_eq!(octad.semantic.status, ProofStatus::Complete); - assert_eq!(octad.semantic.prover, "Lean"); + assert_eq!(octad.semantic.prover, "Lean4"); assert!(!octad.semantic.proof_blob_b64.is_empty()); assert_eq!(octad.semantic.axioms_used, vec!["Nat.rec"]); @@ -965,7 +964,7 @@ mod tests { // Graph modality assert_eq!(octad.graph.cross_prover_id.len(), 64); - assert!(octad.graph.prover_id.contains("Lean")); + assert!(octad.graph.prover_id.contains("Lean4")); // Tensor modality assert_eq!(*octad.tensor.metrics.get("time_ms").unwrap(), 42.0); diff --git a/tests/aspect_tests.rs b/tests/aspect_tests.rs index 6008866..16147a6 100644 --- a/tests/aspect_tests.rs +++ b/tests/aspect_tests.rs @@ -35,12 +35,12 @@ fn aspect_security_malicious_input_no_high_trust() { // wrapped in innocent-looking syntax — trust pipeline must still detect them. let injection_attempts = vec![ // Attempt to sneak 'sorry' past a simple string search - "theorem t : True := by\n sor\x72y", // unicode escape in 'sorry' - "theorem t : True := by {- sorry -}", // Lean block comment wrapping + "theorem t : True := by\n sor\x72y", // unicode escape in 'sorry' + "theorem t : True := by {- sorry -}", // Lean block comment wrapping "Admitted. (* hidden *) Theorem t : True. Proof. trivial. Qed.", // Coq - "foo = believe_me {- hidden -} True", // Idris2 believe_me - "$(sorry); echo pwned", // Shell injection in content - "'; DROP TABLE proofs; --", // SQL injection attempt + "foo = believe_me {- hidden -} True", // Idris2 believe_me + "$(sorry); echo pwned", // Shell injection in content + "'; DROP TABLE proofs; --", // SQL injection attempt "\x00\x01\x7f theorem t : True := rfl", // Binary prefix + valid code ]; @@ -101,7 +101,11 @@ fn aspect_security_no_proof_cert_from_arbitrary_string() { let _ = format!("{:?}", usage.danger_level); } // The key invariant: scanning garbage never panics - eprintln!("Security scan of {:?}: {} usages", &content[..content.len().min(40)], usages.len()); + eprintln!( + "Security scan of {:?}: {} usages", + &content[..content.len().min(40)], + usages.len() + ); } } @@ -182,18 +186,20 @@ async fn aspect_concurrency_parallel_dispatches_isolated() -> Result<()> { i ); successes += 1; - } + }, Err(e) => { - eprintln!("Parallel dispatch {}: Err({}) — acceptable under load", i, e); + eprintln!( + "Parallel dispatch {}: Err({}) — acceptable under load", + i, e + ); _errors += 1; - } + }, } } eprintln!( "Concurrency aspect: {}/{} parallel dispatches succeeded", - successes, - PARALLEL_COUNT + successes, PARALLEL_COUNT ); // At least half must succeed under parallel load assert!( @@ -216,7 +222,10 @@ async fn aspect_concurrency_axiom_tracker_stateless() { let proofs = vec![ (ProverKind::Lean, "theorem foo : True := by sorry"), (ProverKind::Coq, "Theorem bar : True. Proof. Admitted."), - (ProverKind::Lean, "theorem clean : ∀ x : Nat, x = x := fun x => rfl"), + ( + ProverKind::Lean, + "theorem clean : ∀ x : Nat, x = x := fun x => rfl", + ), ]; // Collect baseline results sequentially @@ -239,8 +248,7 @@ async fn aspect_concurrency_axiom_tracker_stateless() { for (i, (kind, content)) in proofs_ref.iter().enumerate() { let count = tracker.scan(*kind, content).len(); assert_eq!( - count, - baselines_ref[i], + count, baselines_ref[i], "Concurrent scan of proof {i} produced different count" ); } @@ -351,7 +359,9 @@ fn aspect_error_handling_dispatch_result_edge_cases() { certificate_hash: Some("0".repeat(128)), message: "x".repeat(10_000), cross_checked: true, - outcome: echidna::provers::outcome::ProverOutcome::Proved { elapsed_ms: u64::MAX }, + outcome: echidna::provers::outcome::ProverOutcome::Proved { + elapsed_ms: u64::MAX, + }, diagnostics: None, }, // Unicode in message @@ -497,8 +507,11 @@ fn aspect_prover_kind_json_stable() { json_str, decoded, expected_kind ); // Roundtrip - let re_encoded = - serde_json::to_string(&expected_kind).expect("ProverKind must serialise"); - assert_eq!(re_encoded, json_str, "Re-encoded {:?} != {}", expected_kind, json_str); + let re_encoded = serde_json::to_string(&expected_kind).expect("ProverKind must serialise"); + assert_eq!( + re_encoded, json_str, + "Re-encoded {:?} != {}", + expected_kind, json_str + ); } } diff --git a/tests/concurrency_test.rs b/tests/concurrency_test.rs index 30e7f65..cf8ff7a 100644 --- a/tests/concurrency_test.rs +++ b/tests/concurrency_test.rs @@ -13,17 +13,17 @@ mod common; -use std::sync::Arc; use std::sync::atomic::{AtomicUsize, Ordering}; +use std::sync::Arc; use std::time::Duration; -use tokio::time::timeout; use echidna::agent::AgentConfig; use echidna::dispatch::DispatchConfig; use echidna::provers::{ProverConfig, ProverFactory, ProverKind}; use echidna::verification::axiom_tracker::AxiomTracker; -use echidna::verification::confidence::{compute_trust_level, TrustFactors, TrustLevel}; use echidna::verification::axiom_tracker::DangerLevel; +use echidna::verification::confidence::{compute_trust_level, TrustFactors, TrustLevel}; +use tokio::time::timeout; // --------------------------------------------------------------------------- // Concurrency invariant 1: Parallel proof instantiation — no shared-state corruption @@ -42,14 +42,17 @@ async fn concurrency_parallel_prover_factory_no_corruption() { for _i in 0..16 { let counter = Arc::clone(&success_count); let handle = tokio::spawn(async move { - let config = ProverConfig { timeout: 5, ..Default::default() }; + let config = ProverConfig { + timeout: 5, + ..Default::default() + }; match ProverFactory::create(ProverKind::Z3, config) { Ok(_prover) => { counter.fetch_add(1, Ordering::Relaxed); - } + }, Err(e) => { eprintln!("Task failed to create Z3 backend: {}", e); - } + }, } }); handles.push(handle); @@ -63,7 +66,10 @@ async fn concurrency_parallel_prover_factory_no_corruption() { }) .await; - assert!(result.is_ok(), "All parallel factory tasks must complete within 10s"); + assert!( + result.is_ok(), + "All parallel factory tasks must complete within 10s" + ); assert_eq!( success_count.load(Ordering::Relaxed), 16, @@ -126,11 +132,17 @@ async fn concurrency_all_routing_requests_complete_no_starvation() { for i in 0..32 { let counter = Arc::clone(&completed); let handle = tokio::spawn(async move { - let config = ProverConfig { timeout: 5, ..Default::default() }; + let config = ProverConfig { + timeout: 5, + ..Default::default() + }; // Alternate between Z3 and Lean to exercise different backends. - let kind = if i % 2 == 0 { ProverKind::Z3 } else { ProverKind::Lean }; - let prover = ProverFactory::create(kind, config) - .expect("Backend must instantiate"); + let kind = if i % 2 == 0 { + ProverKind::Z3 + } else { + ProverKind::Lean + }; + let prover = ProverFactory::create(kind, config).expect("Backend must instantiate"); let content = format!( "(set-logic QF_LIA)(declare-fun x{} () Int)(assert (= x{} x{}))(check-sat)", @@ -150,7 +162,10 @@ async fn concurrency_all_routing_requests_complete_no_starvation() { }) .await; - assert!(result.is_ok(), "All 32 concurrent routing requests must complete within 30s"); + assert!( + result.is_ok(), + "All 32 concurrent routing requests must complete within 30s" + ); assert_eq!( completed.load(Ordering::Relaxed), 32, @@ -273,7 +288,10 @@ async fn concurrency_agent_config_clone_across_tasks() { local.max_concurrent = i; // Verify the local mutation. - assert_eq!(local.max_concurrent, i, "Local mutation must be independent"); + assert_eq!( + local.max_concurrent, i, + "Local mutation must be independent" + ); // Original must be unchanged (we test this via Arc — actual shared ref). assert_eq!(config.max_concurrent, 8, "Shared config must be unchanged"); }); @@ -285,7 +303,10 @@ async fn concurrency_agent_config_clone_across_tasks() { } // The base config must still be intact after all tasks ran. - assert_eq!(base.max_concurrent, 8, "Base config must not be mutated by any task"); + assert_eq!( + base.max_concurrent, 8, + "Base config must not be mutated by any task" + ); } // --------------------------------------------------------------------------- diff --git a/tests/e2e_proof_pipeline.rs b/tests/e2e_proof_pipeline.rs index 28c3776..1418edf 100644 --- a/tests/e2e_proof_pipeline.rs +++ b/tests/e2e_proof_pipeline.rs @@ -55,7 +55,10 @@ fn unsat_problem() -> &'static str { #[tokio::test] async fn e2e_proof_pipeline_z3_mock_success() -> Result<()> { // Instantiate the Z3 backend — succeeds regardless of whether z3 is installed. - let config = ProverConfig { timeout: 5, ..Default::default() }; + let config = ProverConfig { + timeout: 5, + ..Default::default() + }; let prover = ProverFactory::create(ProverKind::Z3, config)?; // Parse stage: must not error on well-formed input. @@ -103,20 +106,37 @@ async fn e2e_all_prover_backends_instantiate() -> Result<()> { /// Both Z3 and Lean prover backends must instantiate and parse successfully. #[tokio::test] async fn e2e_two_backends_z3_and_lean_parse() -> Result<()> { - let config = ProverConfig { timeout: 5, ..Default::default() }; + let config = ProverConfig { + timeout: 5, + ..Default::default() + }; // Z3 backend: SMT2 input let z3 = ProverFactory::create(ProverKind::Z3, config.clone())?; let z3_result = z3.parse_string(simple_sat_problem()).await; - assert!(z3_result.is_ok(), "Z3 parse must succeed: {:?}", z3_result.err()); + assert!( + z3_result.is_ok(), + "Z3 parse must succeed: {:?}", + z3_result.err() + ); // Lean backend: Lean 4 syntax let lean = ProverFactory::create(ProverKind::Lean, config.clone())?; - let lean_result = lean.parse_string("theorem rfl_example (x : Nat) : x = x := rfl").await; - assert!(lean_result.is_ok(), "Lean parse must succeed: {:?}", lean_result.err()); + let lean_result = lean + .parse_string("theorem rfl_example (x : Nat) : x = x := rfl") + .await; + assert!( + lean_result.is_ok(), + "Lean parse must succeed: {:?}", + lean_result.err() + ); // Both backends should have distinct kinds. - assert_ne!(z3.kind(), lean.kind(), "Z3 and Lean must be distinct backends"); + assert_ne!( + z3.kind(), + lean.kind(), + "Z3 and Lean must be distinct backends" + ); Ok(()) } @@ -128,13 +148,18 @@ async fn e2e_two_backends_z3_and_lean_parse() -> Result<()> { /// A completely garbled input must produce an Err (not a panic). #[tokio::test] async fn e2e_malformed_input_no_panic() -> Result<()> { - let config = ProverConfig { timeout: 5, ..Default::default() }; + let config = ProverConfig { + timeout: 5, + ..Default::default() + }; for kind in [ProverKind::Z3, ProverKind::Lean, ProverKind::Coq] { let prover = ProverFactory::create(kind, config.clone())?; // We do not assert is_err because some backends speculatively accept any // string and fail later. We only assert no panic occurs. - let _result = prover.parse_string("\x00\x01\x02 gibberish {{ ??? }}").await; + let _result = prover + .parse_string("\x00\x01\x02 gibberish {{ ??? }}") + .await; // Reaching here = no panic. That is the contract. } @@ -189,10 +214,19 @@ fn e2e_dispatch_result_invariants() { diagnostics: None, }; - assert!(result.proof_time_ms > 0, "Proof time must be positive for verified results"); - assert!(!result.provers_used.is_empty(), "At least one prover must be listed"); + assert!( + result.proof_time_ms > 0, + "Proof time must be positive for verified results" + ); + assert!( + !result.provers_used.is_empty(), + "At least one prover must be listed" + ); assert!(!result.message.is_empty(), "Message must not be empty"); - assert!(result.trust_level >= TrustLevel::Level1, "Trust level must be valid"); + assert!( + result.trust_level >= TrustLevel::Level1, + "Trust level must be valid" + ); // Cross-checked result must list ≥2 provers. let cross_checked_result = DispatchResult { @@ -240,7 +274,10 @@ fn e2e_trust_level_ordering_is_correct() { fn e2e_all_prover_kinds_have_debug_names() { for kind in ProverKind::all() { let name = format!("{:?}", kind); - assert!(!name.is_empty(), "ProverKind must have non-empty debug name"); + assert!( + !name.is_empty(), + "ProverKind must have non-empty debug name" + ); assert!( name.is_ascii(), "ProverKind name '{}' must be ASCII for safe use in logs and filenames", @@ -256,12 +293,19 @@ fn e2e_all_prover_kinds_have_debug_names() { /// Parsing an unsatisfiable formula must not panic. #[tokio::test] async fn e2e_unsolvable_problem_graceful_failure() -> Result<()> { - let config = ProverConfig { timeout: 5, ..Default::default() }; + let config = ProverConfig { + timeout: 5, + ..Default::default() + }; let prover = ProverFactory::create(ProverKind::Z3, config)?; // Parsing should succeed — it's syntactically valid even if unsat. let state = prover.parse_string(unsat_problem()).await; - assert!(state.is_ok(), "Unsat problem should parse without error: {:?}", state.err()); + assert!( + state.is_ok(), + "Unsat problem should parse without error: {:?}", + state.err() + ); // If verification runs, it must return a result (not panic). let proof_state = state.unwrap(); @@ -282,7 +326,10 @@ fn e2e_sequential_strategy_always_available() { use echidna::proof_search::{ProofSearchStrategy, SequentialSearch, StrategySelector}; let strategy = SequentialSearch; - assert!(strategy.available(), "Sequential strategy must always be available"); + assert!( + strategy.available(), + "Sequential strategy must always be available" + ); let selector = StrategySelector::auto(); let strategies = selector.available_strategies(); diff --git a/tests/e2e_prover_test.rs b/tests/e2e_prover_test.rs index a802e78..3c577db 100644 --- a/tests/e2e_prover_test.rs +++ b/tests/e2e_prover_test.rs @@ -323,7 +323,7 @@ async fn e2e_z3_full_dispatch_workflow() -> Result<()> { ); // Invariant: trust level must be a valid level (not beyond enum bounds) let _ = result.trust_level; // just access to ensure it deserializes cleanly - // Invariant: cross_checked must be false for single-prover dispatch + // Invariant: cross_checked must be false for single-prover dispatch assert!( !result.cross_checked, "Single-prover dispatch should not set cross_checked" @@ -353,10 +353,10 @@ async fn e2e_malformed_input_returns_error_not_panic() -> Result<()> { let long_input = "x".repeat(100_000); let malformed_inputs: Vec<&str> = vec![ - "", // empty - "((((unclosed", // unbalanced parens - "\x00\x01\x02", // binary garbage - &long_input, // pathologically long input + "", // empty + "((((unclosed", // unbalanced parens + "\x00\x01\x02", // binary garbage + &long_input, // pathologically long input "SELECT * FROM proofs; DROP TABLE proofs; --", // SQL injection attempt (should be a no-op) ]; @@ -414,11 +414,11 @@ async fn e2e_missing_binary_returns_error() -> Result<()> { // We do NOT assert verified=false here because some backends // may return mock/stub results in CI — that's the backend's // responsibility to handle. We just verify no panic. - } + }, Err(e) => { eprintln!(" {:?}: Err({}) — expected when binary absent", kind, e); // This is the expected case - } + }, } } Ok(()) @@ -454,8 +454,7 @@ fn e2e_dispatch_result_json_roundtrip() { diagnostics: None, }; - let json = serde_json::to_string(&original) - .expect("DispatchResult must serialise to JSON"); + let json = serde_json::to_string(&original).expect("DispatchResult must serialise to JSON"); let roundtripped: DispatchResult = serde_json::from_str(&json).expect("DispatchResult must deserialise from JSON"); @@ -537,7 +536,10 @@ fn e2e_select_prover_heuristic_coverage() { ("theorem id : ∀ x, x = x := rfl", Some("lean")), ("Theorem id : True. Proof. trivial. Qed.", Some("v")), ("module Test where\nid : a -> a", Some("agda")), - ("(set-logic QF_LIA)\n(assert true)\n(check-sat)", Some("smt2")), + ( + "(set-logic QF_LIA)\n(assert true)\n(check-sat)", + Some("smt2"), + ), // No extension — heuristic only ("", None), ("random content", None), @@ -547,6 +549,11 @@ fn e2e_select_prover_heuristic_coverage() { let kind = ProverDispatcher::select_prover(content, ext); // Result must be a valid ProverKind — if it doesn't panic, it's valid let _ = format!("{:?}", kind); // just ensure it's printable - eprintln!("select_prover({:?}, {:?}) -> {:?}", &content[..content.len().min(30)], ext, kind); + eprintln!( + "select_prover({:?}, {:?}) -> {:?}", + &content[..content.len().min(30)], + ext, + kind + ); } } diff --git a/tests/integration_tests.rs b/tests/integration_tests.rs index 97fd353..839b645 100644 --- a/tests/integration_tests.rs +++ b/tests/integration_tests.rs @@ -479,12 +479,14 @@ mod error_tests { Ok(state) => { // If parsing succeeded, the state should reflect the input was not meaningful // (e.g. no goals extracted from invalid syntax) - assert!(state.goals.is_empty() || state.goals.len() <= 1, - "Invalid syntax should not produce multiple meaningful goals"); - } + assert!( + state.goals.is_empty() || state.goals.len() <= 1, + "Invalid syntax should not produce multiple meaningful goals" + ); + }, Err(_) => { // Error is the expected outcome for invalid syntax - } + }, } Ok(()) } diff --git a/tests/live_prover_suite.rs b/tests/live_prover_suite.rs index 3ab4cf8..936a14d 100644 --- a/tests/live_prover_suite.rs +++ b/tests/live_prover_suite.rs @@ -50,10 +50,7 @@ fn live_config(executable: &str) -> ProverConfig { /// Construct a live backend of the given kind. Returns `None` when the /// binary is absent on PATH (auto-skip signal to callers). -fn try_live_backend( - kind: ProverKind, - exe: &str, -) -> Option> { +fn try_live_backend(kind: ProverKind, exe: &str) -> Option> { let _resolved = binary_on_path(exe)?; let config = live_config(exe); ProverFactory::create(kind, config).ok() @@ -66,7 +63,11 @@ fn try_live_backend( /// exists to catch. async fn assert_version_reachable(kind: ProverKind, exe: &str) { let Some(backend) = try_live_backend(kind, exe) else { - eprintln!("SKIP: {} not on PATH (searched for `{}`)", kind_label(kind), exe); + eprintln!( + "SKIP: {} not on PATH (searched for `{}`)", + kind_label(kind), + exe + ); return; }; match backend.version().await { @@ -77,7 +78,7 @@ async fn assert_version_reachable(kind: ProverKind, exe: &str) { kind_label(kind), ); eprintln!("OK: {} reported version = {:?}", kind_label(kind), v); - } + }, Err(e) => { panic!( "{} live version() failed: {}. Binary found on PATH but the \ @@ -86,7 +87,7 @@ async fn assert_version_reachable(kind: ProverKind, exe: &str) { kind_label(kind), e, ); - } + }, } } @@ -110,15 +111,6 @@ fn kind_label(kind: ProverKind) -> &'static str { ProverKind::Dafny => "Dafny", ProverKind::FStar => "F*", ProverKind::TLAPS => "TLAPS", - ProverKind::Tamarin => "Tamarin", - ProverKind::ProVerif => "ProVerif", - ProverKind::Metamath => "Metamath", - ProverKind::Twelf => "Twelf", - ProverKind::ORTools => "OR-Tools", - ProverKind::HOL4 => "HOL4", - ProverKind::ACL2 => "ACL2", - ProverKind::SCIP => "SCIP", - ProverKind::Imandra => "Imandra", _ => "", } } @@ -223,65 +215,3 @@ async fn live_tlaps_version() { // TLA+ Proof System's prover is `tlapm` (per provers/mod.rs). assert_version_reachable(ProverKind::TLAPS, "tlapm").await; } - -// ========================================================================== -// Tier 3 — weekly. Upstream-tarball or heavier-build provers. Most of -// these SKIP locally and in PR CI; the weekly tier3 matrix in -// live-provers.yml provisions each binary in its own job before running -// `cargo test ... `, so only the matching test runs per job. -// ========================================================================== - -#[tokio::test] -async fn live_tamarin_version() { - assert_version_reachable(ProverKind::Tamarin, "tamarin-prover").await; -} - -#[tokio::test] -async fn live_proverif_version() { - assert_version_reachable(ProverKind::ProVerif, "proverif").await; -} - -#[tokio::test] -async fn live_metamath_version() { - assert_version_reachable(ProverKind::Metamath, "metamath").await; -} - -#[tokio::test] -async fn live_twelf_version() { - // Twelf's CLI entry is `twelf-server` per provers/mod.rs. - assert_version_reachable(ProverKind::Twelf, "twelf-server").await; -} - -#[tokio::test] -async fn live_ortools_version() { - // Echidna's ORTools backend invokes `ortools_solve` (wrapper around the - // OR-Tools C++ solve CLI). Provisioned via upstream tarball. - assert_version_reachable(ProverKind::ORTools, "ortools_solve").await; -} - -#[tokio::test] -async fn live_hol4_version() { - // HOL4 requires Poly/ML + a tree build; provisioning is deferred to - // Containerfile. Test SKIPs on runners without `hol` on PATH. - assert_version_reachable(ProverKind::HOL4, "hol").await; -} - -#[tokio::test] -async fn live_acl2_version() { - // ACL2 requires a Common Lisp image; provisioning deferred to Containerfile. - assert_version_reachable(ProverKind::ACL2, "acl2").await; -} - -#[tokio::test] -async fn live_scip_version() { - // SCIP requires a cmake build of SCIP Optimization Suite; deferred to - // Containerfile. Test SKIPs until provisioned. - assert_version_reachable(ProverKind::SCIP, "scip").await; -} - -#[tokio::test] -async fn live_imandra_version() { - // Imandra is proprietary; handled via vendor-supplied container where a - // licence is available. Test SKIPs on public CI. - assert_version_reachable(ProverKind::Imandra, "imandra").await; -} diff --git a/tests/neural_property_tests.rs b/tests/neural_property_tests.rs index 455f312..d11d3f8 100644 --- a/tests/neural_property_tests.rs +++ b/tests/neural_property_tests.rs @@ -13,10 +13,10 @@ mod common; -use proptest::prelude::*; use echidna::provers::{ProverConfig, ProverFactory, ProverKind}; -use echidna::verification::confidence::{compute_trust_level, TrustFactors, TrustLevel}; use echidna::verification::axiom_tracker::{AxiomTracker, DangerLevel}; +use echidna::verification::confidence::{compute_trust_level, TrustFactors, TrustLevel}; +use proptest::prelude::*; // --------------------------------------------------------------------------- // Deterministic mock embedding and prover selector @@ -53,9 +53,9 @@ fn cosine_similarity(a: &[f64], b: &[f64]) -> f64 { /// Deterministic prover selector: maps content → prover via hash. fn deterministic_prover_select(content: &str) -> ProverKind { - let hash: usize = content - .bytes() - .fold(0usize, |acc, b| acc.wrapping_mul(31).wrapping_add(b as usize)); + let hash: usize = content.bytes().fold(0usize, |acc, b| { + acc.wrapping_mul(31).wrapping_add(b as usize) + }); let provers = ProverKind::all(); provers[hash % provers.len()] } @@ -248,16 +248,26 @@ fn prop_prover_kind_all_no_duplicates() { let mut seen = std::collections::HashSet::new(); for kind in &all { let key = format!("{:?}", kind); - assert!(seen.insert(key.clone()), "ProverKind::all() duplicate: {}", key); + assert!( + seen.insert(key.clone()), + "ProverKind::all() duplicate: {}", + key + ); } // Verify count is consistent (the exact number is 49 per current implementation). assert_eq!( - all.len(), seen.len(), + all.len(), + seen.len(), "ProverKind::all() must have no duplicates: {} variants, {} unique", - all.len(), seen.len() + all.len(), + seen.len() ); // Must have at least 30 backends (as documented). - assert!(all.len() >= 30, "ProverKind::all() must have at least 30 variants, got {}", all.len()); + assert!( + all.len() >= 30, + "ProverKind::all() must have at least 30 variants, got {}", + all.len() + ); } /// DangerLevel::Reject must be the maximum, DangerLevel::Safe the minimum. @@ -266,7 +276,11 @@ fn prop_danger_level_extremes() { for level in [DangerLevel::Noted, DangerLevel::Warning, DangerLevel::Safe] { assert!(DangerLevel::Reject > level, "Reject must be > {:?}", level); } - for level in [DangerLevel::Noted, DangerLevel::Warning, DangerLevel::Reject] { + for level in [ + DangerLevel::Noted, + DangerLevel::Warning, + DangerLevel::Reject, + ] { assert!(DangerLevel::Safe < level, "Safe must be < {:?}", level); } } diff --git a/tests/p2p_property_tests.rs b/tests/p2p_property_tests.rs index 035d329..6aec319 100644 --- a/tests/p2p_property_tests.rs +++ b/tests/p2p_property_tests.rs @@ -56,30 +56,25 @@ fn arb_term(depth: u32) -> impl Strategy { /// Generate an arbitrary ProofState with 0-3 goals fn arb_proof_state() -> impl Strategy { - prop::collection::vec( - ( - "[a-z_]{1,10}".prop_map(String::from), - arb_term(1), - ), - 0..3, + prop::collection::vec(("[a-z_]{1,10}".prop_map(String::from), arb_term(1)), 0..3).prop_map( + |goals| { + let goals = goals + .into_iter() + .enumerate() + .map(|(_i, (id, target))| Goal { + id, + hypotheses: vec![], + target, + }) + .collect(); + ProofState { + goals, + context: Context::default(), + proof_script: vec![], + metadata: HashMap::new(), + } + }, ) - .prop_map(|goals| { - let goals = goals - .into_iter() - .enumerate() - .map(|(_i, (id, target))| Goal { - id, - hypotheses: vec![], - target, - }) - .collect(); - ProofState { - goals, - context: Context::default(), - proof_script: vec![], - metadata: HashMap::new(), - } - }) } /// Generate a ProverKind (subset that always instantiates cleanly) @@ -90,7 +85,7 @@ fn arb_prover_kind() -> impl Strategy { Just(ProverKind::Lean), Just(ProverKind::Coq), Just(ProverKind::Isabelle), - Just(ProverKind::Z3), // weighted higher as most available + Just(ProverKind::Z3), // weighted higher as most available Just(ProverKind::Agda), Just(ProverKind::Idris2), Just(ProverKind::Vampire), diff --git a/tests/sanity_suite.rs b/tests/sanity_suite.rs index c1dba8b..211f1fc 100644 --- a/tests/sanity_suite.rs +++ b/tests/sanity_suite.rs @@ -26,11 +26,11 @@ mod common; use echidna::core::{Context, Goal, ProofState, Term, Variable}; +use echidna::dispatch::{DispatchConfig, ProverDispatcher}; use echidna::provers::{ outcome::{classify_anyhow_error, ProverOutcome}, ProverConfig, ProverFactory, ProverKind, }; -use echidna::dispatch::{DispatchConfig, ProverDispatcher}; use std::path::PathBuf; // ─── ProofState construction helpers ──────────────────────────────────────── @@ -121,16 +121,32 @@ fn sanity_outcome_taxonomy_complete() { // All 8 statuses exist and are distinct strings let statuses: Vec<&str> = vec![ ProverOutcome::Proved { elapsed_ms: 0 }.status_str(), - ProverOutcome::NoProofFound { elapsed_ms: 0, reason: None }.status_str(), - ProverOutcome::InvalidInput { reason: "".into(), location: None }.status_str(), + ProverOutcome::NoProofFound { + elapsed_ms: 0, + reason: None, + } + .status_str(), + ProverOutcome::InvalidInput { + reason: "".into(), + location: None, + } + .status_str(), ProverOutcome::UnsupportedFeature { feature: "".into() }.status_str(), ProverOutcome::Timeout { limit_secs: 0 }.status_str(), ProverOutcome::InconsistentPremises { detail: None }.status_str(), - ProverOutcome::ProverError { detail: "".into(), exit_code: None }.status_str(), + ProverOutcome::ProverError { + detail: "".into(), + exit_code: None, + } + .status_str(), ProverOutcome::SystemError { detail: "".into() }.status_str(), ]; let unique: std::collections::HashSet<&&str> = statuses.iter().collect(); - assert_eq!(statuses.len(), unique.len(), "Every status_str must be unique"); + assert_eq!( + statuses.len(), + unique.len(), + "Every status_str must be unique" + ); } /// Default is SystemError (never silently passes as success/failure). @@ -147,11 +163,20 @@ fn sanity_default_is_system_error() { fn sanity_is_proved_exclusive() { assert!(ProverOutcome::Proved { elapsed_ms: 10 }.is_proved()); let non_proved = vec![ - ProverOutcome::NoProofFound { elapsed_ms: 0, reason: None }, + ProverOutcome::NoProofFound { + elapsed_ms: 0, + reason: None, + }, ProverOutcome::Timeout { limit_secs: 5 }, - ProverOutcome::InvalidInput { reason: "bad".into(), location: None }, + ProverOutcome::InvalidInput { + reason: "bad".into(), + location: None, + }, ProverOutcome::InconsistentPremises { detail: None }, - ProverOutcome::ProverError { detail: "".into(), exit_code: None }, + ProverOutcome::ProverError { + detail: "".into(), + exit_code: None, + }, ProverOutcome::SystemError { detail: "".into() }, ]; for o in non_proved { @@ -163,13 +188,25 @@ fn sanity_is_proved_exclusive() { #[test] fn sanity_is_conclusive_semantics() { assert!(ProverOutcome::Proved { elapsed_ms: 0 }.is_conclusive()); - assert!(ProverOutcome::NoProofFound { elapsed_ms: 0, reason: None }.is_conclusive()); + assert!(ProverOutcome::NoProofFound { + elapsed_ms: 0, + reason: None + } + .is_conclusive()); assert!(ProverOutcome::InconsistentPremises { detail: None }.is_conclusive()); assert!(!ProverOutcome::Timeout { limit_secs: 0 }.is_conclusive()); - assert!(!ProverOutcome::InvalidInput { reason: "".into(), location: None }.is_conclusive()); + assert!(!ProverOutcome::InvalidInput { + reason: "".into(), + location: None + } + .is_conclusive()); assert!(!ProverOutcome::UnsupportedFeature { feature: "".into() }.is_conclusive()); - assert!(!ProverOutcome::ProverError { detail: "".into(), exit_code: None }.is_conclusive()); + assert!(!ProverOutcome::ProverError { + detail: "".into(), + exit_code: None + } + .is_conclusive()); assert!(!ProverOutcome::SystemError { detail: "".into() }.is_conclusive()); } @@ -178,8 +215,16 @@ fn sanity_is_conclusive_semantics() { fn sanity_retryable_is_timeout_only() { assert!(ProverOutcome::Timeout { limit_secs: 30 }.is_retryable()); assert!(!ProverOutcome::Proved { elapsed_ms: 0 }.is_retryable()); - assert!(!ProverOutcome::ProverError { detail: "".into(), exit_code: None }.is_retryable()); - assert!(!ProverOutcome::NoProofFound { elapsed_ms: 0, reason: None }.is_retryable()); + assert!(!ProverOutcome::ProverError { + detail: "".into(), + exit_code: None + } + .is_retryable()); + assert!(!ProverOutcome::NoProofFound { + elapsed_ms: 0, + reason: None + } + .is_retryable()); } /// Error classification correctly identifies timeout, parse, system, and prover errors. @@ -189,8 +234,14 @@ fn sanity_error_classification() { ("Z3 execution timeout after 30 seconds", "TIMEOUT"), ("Why3 timed out", "TIMEOUT"), ("parse error: unexpected token ')'", "INVALID_INPUT"), - ("syntax error at line 5: expected identifier", "INVALID_INPUT"), - ("Failed to spawn Z3 process: no such file or directory", "SYSTEM_ERROR"), + ( + "syntax error at line 5: expected identifier", + "INVALID_INPUT", + ), + ( + "Failed to spawn Z3 process: no such file or directory", + "SYSTEM_ERROR", + ), ("OS error: permission denied", "SYSTEM_ERROR"), ("Z3 failed with segmentation fault", "PROVER_ERROR"), ("internal verification error", "PROVER_ERROR"), @@ -363,9 +414,9 @@ async fn sanity_universal_quantifier_proved() { // check() will assert: (not (forall ((x Bool)) (=> x x))) // Z3 with set-logic ALL returns unsat → PROVED. let state = make_proof_state( - &[], // no free variables - &[], // no premises - "(forall ((x Bool)) (=> x x))", // the tautology to prove + &[], // no free variables + &[], // no premises + "(forall ((x Bool)) (=> x x))", // the tautology to prove ); let outcome = backend.check(&state).await.expect("check must not error"); @@ -395,9 +446,9 @@ async fn sanity_contradiction_is_inconsistent_premises() { // Any goal follows; we use a trivially-true one to stress-test that // we detect the inconsistency even before reaching a trivial-goal short-circuit. let state = make_proof_state( - &["P"], // declare-const P Bool - &["P", "(not P)"], // (assert P); (assert (not P)) — UNSAT hypothesis set - "P", // goal is irrelevant — inconsistency is detected first + &["P"], // declare-const P Bool + &["P", "(not P)"], // (assert P); (assert (not P)) — UNSAT hypothesis set + "P", // goal is irrelevant — inconsistency is detected first ); let outcome = backend.check(&state).await.expect("check must not error"); @@ -426,8 +477,8 @@ async fn sanity_equality_reflexivity_proved() { // Declare a as Int; prove (= a a). // check() asserts (not (= a a)); Z3 returns unsat → PROVED. let state = make_proof_state_int( - &["a"], // declare-const a Int - &[], // no premises + &["a"], // declare-const a Int + &[], // no premises "(= a a)", // goal: a = a ); let outcome = backend.check(&state).await.expect("check must not error"); @@ -509,11 +560,7 @@ async fn sanity_cross_prover_comparison() { // Valid modus ponens: P, (P => Q) ⊢ Q // Both Z3 and CVC5 should prove this if their binary is available. - let mp_state = make_proof_state( - &["P", "Q"], - &["P", "(=> P Q)"], - "Q", - ); + let mp_state = make_proof_state(&["P", "Q"], &["P", "(=> P Q)"], "Q"); let mut per_prover_outcomes: Vec<(ProverKind, ProverOutcome)> = Vec::new(); @@ -613,10 +660,7 @@ async fn sanity_diagnostics_populated_when_enabled() { "provers_selected must not be empty" ); assert_eq!(diag.per_prover.len(), 1, "one prover invoked → one record"); - assert_eq!( - diag.per_prover[0].prover, "Z3", - "record must name Z3" - ); + assert_eq!(diag.per_prover[0].prover, "Z3", "record must name Z3"); } /// Parse failures produce INVALID_INPUT (not PROVER_ERROR or SYSTEM_ERROR) @@ -644,10 +688,7 @@ async fn sanity_dispatch_parse_failure_is_invalid_input() { .expect("dispatch must return Ok even for bad input"); // The pipeline must not silently return PROVED for broken input - assert!( - !result.verified, - "broken input must not be verified" - ); + assert!(!result.verified, "broken input must not be verified"); // The outcome should be INVALID_INPUT or PROVER_ERROR (Z3 may accept some // malformed inputs as valid). What it must NOT be is PROVED or SYSTEM_ERROR. diff --git a/tests/security_aspect_tests.rs b/tests/security_aspect_tests.rs index 6145024..57b0a56 100644 --- a/tests/security_aspect_tests.rs +++ b/tests/security_aspect_tests.rs @@ -42,7 +42,8 @@ fn security_proof_forgery_single_bit_flip_detected() { let h_forged = hash(&forged).to_hex(); assert_ne!( - h_original.as_str(), h_forged.as_str(), + h_original.as_str(), + h_forged.as_str(), "Single-bit modification must change the proof hash" ); } @@ -104,7 +105,8 @@ fn security_model_injection_trust_level_immutable() { for payload in &payloads { // Config must be unchanged regardless of what we would put in proof content. assert_eq!( - config.min_trust_level, TrustLevel::Level5, + config.min_trust_level, + TrustLevel::Level5, "min_trust_level must not be mutable via payload: '{}'", payload ); @@ -125,7 +127,11 @@ fn security_trust_level_capped_at_level5() { }; let trust = compute_trust_level(&factors); - assert!(trust <= TrustLevel::Level5, "Trust must never exceed Level5, got {:?}", trust); + assert!( + trust <= TrustLevel::Level5, + "Trust must never exceed Level5, got {:?}", + trust + ); } // --------------------------------------------------------------------------- @@ -136,18 +142,22 @@ fn security_trust_level_capped_at_level5() { #[test] fn security_agent_config_no_privilege_escalation_markers() { let config = AgentConfig::default(); - let json = serde_json::to_string(&config) - .expect("AgentConfig must be serialisable"); + let json = serde_json::to_string(&config).expect("AgentConfig must be serialisable"); let forbidden = [ - "root", "sudo", "unrestricted", "privilege_escalation", "all_capabilities", + "root", + "sudo", + "unrestricted", + "privilege_escalation", + "all_capabilities", ]; for marker in &forbidden { assert!( !json.to_lowercase().contains(marker), "AgentConfig must not contain escalation marker '{}': {}", - marker, json + marker, + json ); } } @@ -161,7 +171,10 @@ fn security_agent_config_clone_preserves_restrictions() { let json_orig = serde_json::to_string(&original).unwrap(); let json_clone = serde_json::to_string(&cloned).unwrap(); - assert_eq!(json_orig, json_clone, "Cloned config must be identical to original"); + assert_eq!( + json_orig, json_clone, + "Cloned config must be identical to original" + ); } // --------------------------------------------------------------------------- @@ -183,7 +196,11 @@ fn security_reject_axiom_always_yields_level1() { }; let safe_trust = compute_trust_level(&positive); - assert!(safe_trust >= TrustLevel::Level3, "Baseline should be Level3+: {:?}", safe_trust); + assert!( + safe_trust >= TrustLevel::Level3, + "Baseline should be Level3+: {:?}", + safe_trust + ); // Add Reject axioms — must collapse to Level1. let reject_factors = TrustFactors { @@ -192,7 +209,8 @@ fn security_reject_axiom_always_yields_level1() { }; let reject_trust = compute_trust_level(&reject_factors); assert_eq!( - reject_trust, TrustLevel::Level1, + reject_trust, + TrustLevel::Level1, "Reject axioms must always yield Level1, got {:?}", reject_trust ); @@ -210,7 +228,10 @@ fn security_noted_axiom_does_not_raise_trust() { solver_integrity_ok: true, portfolio_confidence: None, }; - let noted = TrustFactors { worst_axiom_danger: DangerLevel::Noted, ..base.clone() }; + let noted = TrustFactors { + worst_axiom_danger: DangerLevel::Noted, + ..base.clone() + }; assert!( compute_trust_level(¬ed) <= compute_trust_level(&base), @@ -234,7 +255,10 @@ fn security_integrity_failure_never_raises_trust() { solver_integrity_ok: true, portfolio_confidence: None, }; - let failing = TrustFactors { solver_integrity_ok: false, ..passing.clone() }; + let failing = TrustFactors { + solver_integrity_ok: false, + ..passing.clone() + }; assert!( compute_trust_level(&failing) <= compute_trust_level(&passing), @@ -263,7 +287,10 @@ fn security_cross_checked_requires_two_provers() { outcome: echidna::provers::outcome::ProverOutcome::Proved { elapsed_ms: 100 }, diagnostics: None, }; - assert!(good.provers_used.len() >= 2, "cross_checked result requires ≥2 provers"); + assert!( + good.provers_used.len() >= 2, + "cross_checked result requires ≥2 provers" + ); // Detect violation: cross_checked=true but only 1 prover. let bad = DispatchResult { @@ -271,7 +298,10 @@ fn security_cross_checked_requires_two_provers() { ..good.clone() }; let is_valid = !bad.cross_checked || bad.provers_used.len() >= 2; - assert!(!is_valid, "cross_checked=true with 1 prover must be detected as invalid"); + assert!( + !is_valid, + "cross_checked=true with 1 prover must be detected as invalid" + ); } /// Single-prover result must not be marked cross-checked. @@ -290,7 +320,10 @@ fn security_single_prover_not_cross_checked() { outcome: echidna::provers::outcome::ProverOutcome::Proved { elapsed_ms: 50 }, diagnostics: None, }; - assert!(!result.cross_checked, "Single-prover result must not be cross_checked"); + assert!( + !result.cross_checked, + "Single-prover result must not be cross_checked" + ); assert_eq!(result.provers_used.len(), 1); } @@ -300,7 +333,10 @@ fn security_single_prover_not_cross_checked() { #[tokio::test] async fn security_control_chars_in_proof_no_panic() { - let config = ProverConfig { timeout: 2, ..Default::default() }; + let config = ProverConfig { + timeout: 2, + ..Default::default() + }; let prover = ProverFactory::create(ProverKind::Z3, config).unwrap(); let malicious_inputs = [ diff --git a/training_data/premises_ALIGNED_stats.json b/training_data/premises_ALIGNED_stats.json new file mode 100644 index 0000000..519b5d3 --- /dev/null +++ b/training_data/premises_ALIGNED_stats.json @@ -0,0 +1,214 @@ +{ + "per_source": { + "premises_isabelle_zf.jsonl": { + "dropped": 0, + "written": 0 + }, + "premises_nitpick.jsonl": { + "dropped": 0, + "written": 0 + }, + "premises_arend.jsonl": { + "dropped": 0, + "written": 0 + }, + "premises_dreal.jsonl": { + "dropped": 0, + "written": 0 + }, + "premises_proverif.jsonl": { + "dropped": 0, + "written": 0 + }, + "premises_prism.jsonl": { + "dropped": 0, + "written": 0 + }, + "premises_dedukti.jsonl": { + "dropped": 158, + "written": 0 + }, + "premises_all.jsonl": { + "dropped": 0, + "written": 300 + }, + "premises_uppaal.jsonl": { + "dropped": 0, + "written": 0 + }, + "premises_boogie.jsonl": { + "dropped": 0, + "written": 0 + }, + "premises_spin.jsonl": { + "dropped": 0, + "written": 0 + }, + "premises_framac.jsonl": { + "dropped": 0, + "written": 0 + }, + "premises_matita.jsonl": { + "dropped": 0, + "written": 0 + }, + "premises_abc.jsonl": { + "dropped": 0, + "written": 0 + }, + "premises_coqgym_max.jsonl": { + "dropped": 0, + "written": 0 + }, + "premises_key.jsonl": { + "dropped": 0, + "written": 0 + }, + "premises_kissat.jsonl": { + "dropped": 0, + "written": 0 + }, + "premises_coqgym.jsonl": { + "dropped": 0, + "written": 76705 + }, + "premises_seahorn.jsonl": { + "dropped": 0, + "written": 0 + }, + "premises_tlc.jsonl": { + "dropped": 0, + "written": 0 + }, + "premises_tlaps.jsonl": { + "dropped": 0, + "written": 0 + }, + "premises_typed_wasm.jsonl": { + "dropped": 0, + "written": 0 + }, + "premises_naproche.jsonl": { + "dropped": 0, + "written": 0 + }, + "premises_lambda_prolog.jsonl": { + "dropped": 0, + "written": 0 + }, + "premises_minisat.jsonl": { + "dropped": 0, + "written": 0 + }, + "premises_cbmc.jsonl": { + "dropped": 0, + "written": 0 + }, + "premises_nunchaku.jsonl": { + "dropped": 0, + "written": 0 + }, + "premises_acl2s.jsonl": { + "dropped": 0, + "written": 0 + }, + "premises_abella.jsonl": { + "dropped": 42, + "written": 0 + }, + "premises_viper.jsonl": { + "dropped": 0, + "written": 0 + }, + "premises_mathlib4_max.jsonl": { + "dropped": 0, + "written": 2083077 + }, + "premises_mathlib4.jsonl": { + "dropped": 0, + "written": 0 + }, + "premises_athena.jsonl": { + "dropped": 0, + "written": 0 + }, + "premises_nusmv.jsonl": { + "dropped": 0, + "written": 0 + }, + "premises_tamarin.jsonl": { + "dropped": 0, + "written": 0 + }, + "premises_cameleer.jsonl": { + "dropped": 0, + "written": 0 + }, + "premises_mercury.jsonl": { + "dropped": 0, + "written": 0 + }, + "premises_lean3.jsonl": { + "dropped": 10434, + "written": 0 + }, + "premises_cadical.jsonl": { + "dropped": 0, + "written": 0 + }, + "premises_alloy.jsonl": { + "dropped": 0, + "written": 0 + } + }, + "dropped_no_theorem": 10634, + "dropped_no_match": 0, + "dropped_malformed": 0, + "written": 2160082, + "match_rate_percent": 99.51011555634177, + "unified_path": "/var/mnt/eclipse/repos/verification-ecosystem/echidna/training_data/proof_states_UNIFIED.jsonl", + "output_path": "/var/mnt/eclipse/repos/verification-ecosystem/echidna/training_data/premises_COMPLETE.jsonl", + "unified_index_size": 871731, + "sources": [ + "premises_abc.jsonl", + "premises_abella.jsonl", + "premises_acl2s.jsonl", + "premises_all.jsonl", + "premises_alloy.jsonl", + "premises_arend.jsonl", + "premises_athena.jsonl", + "premises_boogie.jsonl", + "premises_cadical.jsonl", + "premises_cameleer.jsonl", + "premises_cbmc.jsonl", + "premises_coqgym.jsonl", + "premises_coqgym_max.jsonl", + "premises_dedukti.jsonl", + "premises_dreal.jsonl", + "premises_framac.jsonl", + "premises_isabelle_zf.jsonl", + "premises_key.jsonl", + "premises_kissat.jsonl", + "premises_lambda_prolog.jsonl", + "premises_lean3.jsonl", + "premises_mathlib4.jsonl", + "premises_mathlib4_max.jsonl", + "premises_matita.jsonl", + "premises_mercury.jsonl", + "premises_minisat.jsonl", + "premises_naproche.jsonl", + "premises_nitpick.jsonl", + "premises_nunchaku.jsonl", + "premises_nusmv.jsonl", + "premises_prism.jsonl", + "premises_proverif.jsonl", + "premises_seahorn.jsonl", + "premises_spin.jsonl", + "premises_tamarin.jsonl", + "premises_tlaps.jsonl", + "premises_tlc.jsonl", + "premises_typed_wasm.jsonl", + "premises_uppaal.jsonl", + "premises_viper.jsonl" + ] +} \ No newline at end of file diff --git a/training_data/proof_states_dafny.jsonl b/training_data/proof_states_dafny.jsonl index 96d9c84..3d19c62 100644 --- a/training_data/proof_states_dafny.jsonl +++ b/training_data/proof_states_dafny.jsonl @@ -16642,83359 +16642,39 @@ {"prover":"Dafny","tactic_proof":"function CollatzNext(n: nat): nat\n requires n >= 2\n{\n if n % 2 == 0 then n / 2 else 3 * n + 1\n}","source":"dafny_synthetic/termination","theorem":"CollatzStep","id":112641,"goal":"requires n >= 2","context":["requires"]} {"prover":"Dafny","tactic_proof":"function Even(n: nat): bool\n decreases n\n{\n if n == 0 then true else Odd(n - 1)\n}\nfunction Odd(n: nat): bool\n decreases n\n{\n if n == 0 then false else Even(n - 1)\n}","source":"dafny_synthetic/termination","theorem":"MutualRecTermination","id":112642,"goal":"decreases n; decreases n","context":["decreases"]} {"prover":"Dafny","tactic_proof":"function McCarthy91(n: int): int\n requires n >= 0\n ensures n > 100 ==> McCarthy91(n) == n - 10\n ensures n <= 100 ==> McCarthy91(n) == 91\n decreases 101 - n\n{\n if n > 100 then n - 10 else McCarthy91(McCarthy91(n + 11))\n}","source":"dafny_synthetic/termination","theorem":"McCarthyNinetyOne","id":112643,"goal":"requires n >= 0; ensures n > 100 ==> McCarthy91(n) == n - 10; ensures n <= 100 ==> McCarthy91(n) == 91; decreases 101 - n","context":["requires","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_1","instance":1,"id":170000,"goal":"lemma AddComm_1(x: int, y: int)\n ensures x + y == y + x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_2","instance":2,"id":170001,"goal":"lemma AddAssoc_2(n: nat, j: nat, x: nat)\n ensures (n + j) + x == n + (j + x)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_3","instance":3,"id":170002,"goal":"lemma MulComm_3(a: real, i: real)\n ensures a * i == i * a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_4","instance":4,"id":170003,"goal":"lemma MulAssoc_4(x: int, a: int, n: int)\n ensures (x * a) * n == x * (a * n)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_5","instance":5,"id":170004,"goal":"lemma Distrib_5(c: nat, m: nat, k: nat)\n ensures c * (m + k) == c * m + c * k\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_6","instance":6,"id":170005,"goal":"lemma AddZero_6(c: real)\n ensures c + 0 == c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_7","instance":7,"id":170006,"goal":"lemma MulOne_7(x: int)\n ensures x * 1 == x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_8","instance":8,"id":170007,"goal":"lemma MulZero_8(y: nat)\n ensures y * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_9","instance":9,"id":170008,"goal":"lemma LeRefl_9(d: real)\n ensures d <= d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_10","instance":10,"id":170009,"goal":"lemma LeTrans_10(i: int, z: int, j: int)\n requires i <= z && z <= j\n ensures i <= j\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_11","instance":11,"id":170010,"goal":"lemma AddMono_11(y: nat, m: nat, d: nat)\n requires y <= m\n ensures y + d <= m + d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_12","instance":12,"id":170011,"goal":"lemma Abs_Nonneg_12(n: real)\n ensures (if n >= 0 then n else -n) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_13","instance":13,"id":170012,"goal":"lemma DivMod_13(a: int, m: int)\n requires m > 0\n ensures a == m * (a / m) + (a % m)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_14","instance":14,"id":170013,"goal":"lemma ModBounds_14(j: nat, c: nat)\n requires c > 0\n ensures 0 <= j % c < c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_15","instance":15,"id":170014,"goal":"lemma Square_Nonneg_15(k: real)\n ensures k * k >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_16","instance":16,"id":170015,"goal":"lemma AddComm_16(y: int, n: int)\n ensures y + n == n + y\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_17","instance":17,"id":170016,"goal":"lemma AddAssoc_17(y: nat, n: nat, x: nat)\n ensures (y + n) + x == y + (n + x)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_18","instance":18,"id":170017,"goal":"lemma MulComm_18(b: real, a: real)\n ensures b * a == a * b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_19","instance":19,"id":170018,"goal":"lemma MulAssoc_19(d: int, b: int, c: int)\n ensures (d * b) * c == d * (b * c)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_20","instance":20,"id":170019,"goal":"lemma Distrib_20(k: nat, d: nat, n: nat)\n ensures k * (d + n) == k * d + k * n\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_21","instance":21,"id":170020,"goal":"lemma AddZero_21(i: real)\n ensures i + 0 == i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_22","instance":22,"id":170021,"goal":"lemma MulOne_22(d: int)\n ensures d * 1 == d\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_23","instance":23,"id":170022,"goal":"lemma MulZero_23(i: nat)\n ensures i * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_24","instance":24,"id":170023,"goal":"lemma LeRefl_24(b: real)\n ensures b <= b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_25","instance":25,"id":170024,"goal":"lemma LeTrans_25(i: int, b: int, k: int)\n requires i <= b && b <= k\n ensures i <= k\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_26","instance":26,"id":170025,"goal":"lemma AddMono_26(j: nat, c: nat, k: nat)\n requires j <= c\n ensures j + k <= c + k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_27","instance":27,"id":170026,"goal":"lemma Abs_Nonneg_27(a: real)\n ensures (if a >= 0 then a else -a) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_28","instance":28,"id":170027,"goal":"lemma DivMod_28(i: int, m: int)\n requires m > 0\n ensures i == m * (i / m) + (i % m)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_29","instance":29,"id":170028,"goal":"lemma ModBounds_29(x: nat, z: nat)\n requires z > 0\n ensures 0 <= x % z < z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_30","instance":30,"id":170029,"goal":"lemma Square_Nonneg_30(c: real)\n ensures c * c >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_31","instance":31,"id":170030,"goal":"lemma AddComm_31(j: int, n: int)\n ensures j + n == n + j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_32","instance":32,"id":170031,"goal":"lemma AddAssoc_32(i: nat, x: nat, b: nat)\n ensures (i + x) + b == i + (x + b)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_33","instance":33,"id":170032,"goal":"lemma MulComm_33(a: real, c: real)\n ensures a * c == c * a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_34","instance":34,"id":170033,"goal":"lemma MulAssoc_34(x: int, i: int, n: int)\n ensures (x * i) * n == x * (i * n)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_35","instance":35,"id":170034,"goal":"lemma Distrib_35(m: nat, x: nat, a: nat)\n ensures m * (x + a) == m * x + m * a\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_36","instance":36,"id":170035,"goal":"lemma AddZero_36(b: real)\n ensures b + 0 == b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_37","instance":37,"id":170036,"goal":"lemma MulOne_37(j: int)\n ensures j * 1 == j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_38","instance":38,"id":170037,"goal":"lemma MulZero_38(k: nat)\n ensures k * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_39","instance":39,"id":170038,"goal":"lemma LeRefl_39(c: real)\n ensures c <= c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_40","instance":40,"id":170039,"goal":"lemma LeTrans_40(x: int, d: int, n: int)\n requires x <= d && d <= n\n ensures x <= n\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_41","instance":41,"id":170040,"goal":"lemma AddMono_41(a: nat, d: nat, i: nat)\n requires a <= d\n ensures a + i <= d + i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_42","instance":42,"id":170041,"goal":"lemma Abs_Nonneg_42(n: real)\n ensures (if n >= 0 then n else -n) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_43","instance":43,"id":170042,"goal":"lemma DivMod_43(n: int, j: int)\n requires j > 0\n ensures n == j * (n / j) + (n % j)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_44","instance":44,"id":170043,"goal":"lemma ModBounds_44(b: nat, x: nat)\n requires x > 0\n ensures 0 <= b % x < x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_45","instance":45,"id":170044,"goal":"lemma Square_Nonneg_45(i: real)\n ensures i * i >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_46","instance":46,"id":170045,"goal":"lemma AddComm_46(d: int, n: int)\n ensures d + n == n + d\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_47","instance":47,"id":170046,"goal":"lemma AddAssoc_47(i: nat, y: nat, j: nat)\n ensures (i + y) + j == i + (y + j)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_48","instance":48,"id":170047,"goal":"lemma MulComm_48(i: real, n: real)\n ensures i * n == n * i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_49","instance":49,"id":170048,"goal":"lemma MulAssoc_49(x: int, k: int, b: int)\n ensures (x * k) * b == x * (k * b)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_50","instance":50,"id":170049,"goal":"lemma Distrib_50(c: nat, d: nat, i: nat)\n ensures c * (d + i) == c * d + c * i\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_51","instance":51,"id":170050,"goal":"lemma AddZero_51(k: real)\n ensures k + 0 == k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_52","instance":52,"id":170051,"goal":"lemma MulOne_52(y: int)\n ensures y * 1 == y\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_53","instance":53,"id":170052,"goal":"lemma MulZero_53(n: nat)\n ensures n * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_54","instance":54,"id":170053,"goal":"lemma LeRefl_54(d: real)\n ensures d <= d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_55","instance":55,"id":170054,"goal":"lemma LeTrans_55(d: int, c: int, a: int)\n requires d <= c && c <= a\n ensures d <= a\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_56","instance":56,"id":170055,"goal":"lemma AddMono_56(m: nat, y: nat, d: nat)\n requires m <= y\n ensures m + d <= y + d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_57","instance":57,"id":170056,"goal":"lemma Abs_Nonneg_57(x: real)\n ensures (if x >= 0 then x else -x) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_58","instance":58,"id":170057,"goal":"lemma DivMod_58(n: int, x: int)\n requires x > 0\n ensures n == x * (n / x) + (n % x)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_59","instance":59,"id":170058,"goal":"lemma ModBounds_59(k: nat, m: nat)\n requires m > 0\n ensures 0 <= k % m < m\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_60","instance":60,"id":170059,"goal":"lemma Square_Nonneg_60(m: real)\n ensures m * m >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_61","instance":61,"id":170060,"goal":"lemma AddComm_61(i: int, k: int)\n ensures i + k == k + i\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_62","instance":62,"id":170061,"goal":"lemma AddAssoc_62(k: nat, b: nat, m: nat)\n ensures (k + b) + m == k + (b + m)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_63","instance":63,"id":170062,"goal":"lemma MulComm_63(b: real, d: real)\n ensures b * d == d * b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_64","instance":64,"id":170063,"goal":"lemma MulAssoc_64(m: int, k: int, z: int)\n ensures (m * k) * z == m * (k * z)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_65","instance":65,"id":170064,"goal":"lemma Distrib_65(d: nat, b: nat, i: nat)\n ensures d * (b + i) == d * b + d * i\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_66","instance":66,"id":170065,"goal":"lemma AddZero_66(a: real)\n ensures a + 0 == a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_67","instance":67,"id":170066,"goal":"lemma MulOne_67(c: int)\n ensures c * 1 == c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_68","instance":68,"id":170067,"goal":"lemma MulZero_68(n: nat)\n ensures n * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_69","instance":69,"id":170068,"goal":"lemma LeRefl_69(a: real)\n ensures a <= a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_70","instance":70,"id":170069,"goal":"lemma LeTrans_70(i: int, k: int, b: int)\n requires i <= k && k <= b\n ensures i <= b\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_71","instance":71,"id":170070,"goal":"lemma AddMono_71(x: nat, y: nat, k: nat)\n requires x <= y\n ensures x + k <= y + k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_72","instance":72,"id":170071,"goal":"lemma Abs_Nonneg_72(d: real)\n ensures (if d >= 0 then d else -d) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_73","instance":73,"id":170072,"goal":"lemma DivMod_73(i: int, j: int)\n requires j > 0\n ensures i == j * (i / j) + (i % j)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_74","instance":74,"id":170073,"goal":"lemma ModBounds_74(a: nat, k: nat)\n requires k > 0\n ensures 0 <= a % k < k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_75","instance":75,"id":170074,"goal":"lemma Square_Nonneg_75(z: real)\n ensures z * z >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_76","instance":76,"id":170075,"goal":"lemma AddComm_76(y: int, a: int)\n ensures y + a == a + y\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_77","instance":77,"id":170076,"goal":"lemma AddAssoc_77(n: nat, b: nat, c: nat)\n ensures (n + b) + c == n + (b + c)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_78","instance":78,"id":170077,"goal":"lemma MulComm_78(x: real, y: real)\n ensures x * y == y * x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_79","instance":79,"id":170078,"goal":"lemma MulAssoc_79(j: int, y: int, b: int)\n ensures (j * y) * b == j * (y * b)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_80","instance":80,"id":170079,"goal":"lemma Distrib_80(i: nat, y: nat, b: nat)\n ensures i * (y + b) == i * y + i * b\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_81","instance":81,"id":170080,"goal":"lemma AddZero_81(z: real)\n ensures z + 0 == z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_82","instance":82,"id":170081,"goal":"lemma MulOne_82(m: int)\n ensures m * 1 == m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_83","instance":83,"id":170082,"goal":"lemma MulZero_83(j: nat)\n ensures j * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_84","instance":84,"id":170083,"goal":"lemma LeRefl_84(z: real)\n ensures z <= z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_85","instance":85,"id":170084,"goal":"lemma LeTrans_85(m: int, b: int, c: int)\n requires m <= b && b <= c\n ensures m <= c\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_86","instance":86,"id":170085,"goal":"lemma AddMono_86(n: nat, a: nat, c: nat)\n requires n <= a\n ensures n + c <= a + c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_87","instance":87,"id":170086,"goal":"lemma Abs_Nonneg_87(i: real)\n ensures (if i >= 0 then i else -i) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_88","instance":88,"id":170087,"goal":"lemma DivMod_88(y: int, a: int)\n requires a > 0\n ensures y == a * (y / a) + (y % a)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_89","instance":89,"id":170088,"goal":"lemma ModBounds_89(n: nat, k: nat)\n requires k > 0\n ensures 0 <= n % k < k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_90","instance":90,"id":170089,"goal":"lemma Square_Nonneg_90(k: real)\n ensures k * k >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_91","instance":91,"id":170090,"goal":"lemma AddComm_91(k: int, m: int)\n ensures k + m == m + k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_92","instance":92,"id":170091,"goal":"lemma AddAssoc_92(z: nat, n: nat, k: nat)\n ensures (z + n) + k == z + (n + k)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_93","instance":93,"id":170092,"goal":"lemma MulComm_93(a: real, d: real)\n ensures a * d == d * a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_94","instance":94,"id":170093,"goal":"lemma MulAssoc_94(i: int, a: int, z: int)\n ensures (i * a) * z == i * (a * z)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_95","instance":95,"id":170094,"goal":"lemma Distrib_95(y: nat, x: nat, j: nat)\n ensures y * (x + j) == y * x + y * j\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_96","instance":96,"id":170095,"goal":"lemma AddZero_96(n: real)\n ensures n + 0 == n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_97","instance":97,"id":170096,"goal":"lemma MulOne_97(i: int)\n ensures i * 1 == i\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_98","instance":98,"id":170097,"goal":"lemma MulZero_98(c: nat)\n ensures c * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_99","instance":99,"id":170098,"goal":"lemma LeRefl_99(y: real)\n ensures y <= y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_100","instance":100,"id":170099,"goal":"lemma LeTrans_100(b: int, c: int, d: int)\n requires b <= c && c <= d\n ensures b <= d\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_101","instance":101,"id":170100,"goal":"lemma AddMono_101(c: nat, b: nat, m: nat)\n requires c <= b\n ensures c + m <= b + m\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_102","instance":102,"id":170101,"goal":"lemma Abs_Nonneg_102(d: real)\n ensures (if d >= 0 then d else -d) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_103","instance":103,"id":170102,"goal":"lemma DivMod_103(z: int, n: int)\n requires n > 0\n ensures z == n * (z / n) + (z % n)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_104","instance":104,"id":170103,"goal":"lemma ModBounds_104(y: nat, x: nat)\n requires x > 0\n ensures 0 <= y % x < x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_105","instance":105,"id":170104,"goal":"lemma Square_Nonneg_105(x: real)\n ensures x * x >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_106","instance":106,"id":170105,"goal":"lemma AddComm_106(z: int, x: int)\n ensures z + x == x + z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_107","instance":107,"id":170106,"goal":"lemma AddAssoc_107(d: nat, j: nat, m: nat)\n ensures (d + j) + m == d + (j + m)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_108","instance":108,"id":170107,"goal":"lemma MulComm_108(j: real, m: real)\n ensures j * m == m * j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_109","instance":109,"id":170108,"goal":"lemma MulAssoc_109(m: int, a: int, j: int)\n ensures (m * a) * j == m * (a * j)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_110","instance":110,"id":170109,"goal":"lemma Distrib_110(j: nat, k: nat, m: nat)\n ensures j * (k + m) == j * k + j * m\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_111","instance":111,"id":170110,"goal":"lemma AddZero_111(k: real)\n ensures k + 0 == k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_112","instance":112,"id":170111,"goal":"lemma MulOne_112(d: int)\n ensures d * 1 == d\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_113","instance":113,"id":170112,"goal":"lemma MulZero_113(m: nat)\n ensures m * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_114","instance":114,"id":170113,"goal":"lemma LeRefl_114(m: real)\n ensures m <= m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_115","instance":115,"id":170114,"goal":"lemma LeTrans_115(n: int, d: int, j: int)\n requires n <= d && d <= j\n ensures n <= j\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_116","instance":116,"id":170115,"goal":"lemma AddMono_116(n: nat, y: nat, d: nat)\n requires n <= y\n ensures n + d <= y + d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_117","instance":117,"id":170116,"goal":"lemma Abs_Nonneg_117(n: real)\n ensures (if n >= 0 then n else -n) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_118","instance":118,"id":170117,"goal":"lemma DivMod_118(d: int, y: int)\n requires y > 0\n ensures d == y * (d / y) + (d % y)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_119","instance":119,"id":170118,"goal":"lemma ModBounds_119(k: nat, j: nat)\n requires j > 0\n ensures 0 <= k % j < j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_120","instance":120,"id":170119,"goal":"lemma Square_Nonneg_120(x: real)\n ensures x * x >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_121","instance":121,"id":170120,"goal":"lemma AddComm_121(k: int, c: int)\n ensures k + c == c + k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_122","instance":122,"id":170121,"goal":"lemma AddAssoc_122(x: nat, z: nat, d: nat)\n ensures (x + z) + d == x + (z + d)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_123","instance":123,"id":170122,"goal":"lemma MulComm_123(c: real, k: real)\n ensures c * k == k * c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_124","instance":124,"id":170123,"goal":"lemma MulAssoc_124(a: int, y: int, m: int)\n ensures (a * y) * m == a * (y * m)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_125","instance":125,"id":170124,"goal":"lemma Distrib_125(y: nat, m: nat, i: nat)\n ensures y * (m + i) == y * m + y * i\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_126","instance":126,"id":170125,"goal":"lemma AddZero_126(c: real)\n ensures c + 0 == c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_127","instance":127,"id":170126,"goal":"lemma MulOne_127(a: int)\n ensures a * 1 == a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_128","instance":128,"id":170127,"goal":"lemma MulZero_128(i: nat)\n ensures i * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_129","instance":129,"id":170128,"goal":"lemma LeRefl_129(y: real)\n ensures y <= y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_130","instance":130,"id":170129,"goal":"lemma LeTrans_130(z: int, d: int, k: int)\n requires z <= d && d <= k\n ensures z <= k\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_131","instance":131,"id":170130,"goal":"lemma AddMono_131(m: nat, j: nat, d: nat)\n requires m <= j\n ensures m + d <= j + d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_132","instance":132,"id":170131,"goal":"lemma Abs_Nonneg_132(i: real)\n ensures (if i >= 0 then i else -i) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_133","instance":133,"id":170132,"goal":"lemma DivMod_133(k: int, n: int)\n requires n > 0\n ensures k == n * (k / n) + (k % n)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_134","instance":134,"id":170133,"goal":"lemma ModBounds_134(b: nat, n: nat)\n requires n > 0\n ensures 0 <= b % n < n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_135","instance":135,"id":170134,"goal":"lemma Square_Nonneg_135(c: real)\n ensures c * c >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_136","instance":136,"id":170135,"goal":"lemma AddComm_136(k: int, j: int)\n ensures k + j == j + k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_137","instance":137,"id":170136,"goal":"lemma AddAssoc_137(n: nat, j: nat, i: nat)\n ensures (n + j) + i == n + (j + i)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_138","instance":138,"id":170137,"goal":"lemma MulComm_138(b: real, d: real)\n ensures b * d == d * b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_139","instance":139,"id":170138,"goal":"lemma MulAssoc_139(k: int, a: int, i: int)\n ensures (k * a) * i == k * (a * i)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_140","instance":140,"id":170139,"goal":"lemma Distrib_140(k: nat, c: nat, m: nat)\n ensures k * (c + m) == k * c + k * m\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_141","instance":141,"id":170140,"goal":"lemma AddZero_141(j: real)\n ensures j + 0 == j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_142","instance":142,"id":170141,"goal":"lemma MulOne_142(z: int)\n ensures z * 1 == z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_143","instance":143,"id":170142,"goal":"lemma MulZero_143(j: nat)\n ensures j * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_144","instance":144,"id":170143,"goal":"lemma LeRefl_144(c: real)\n ensures c <= c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_145","instance":145,"id":170144,"goal":"lemma LeTrans_145(c: int, x: int, a: int)\n requires c <= x && x <= a\n ensures c <= a\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_146","instance":146,"id":170145,"goal":"lemma AddMono_146(y: nat, d: nat, b: nat)\n requires y <= d\n ensures y + b <= d + b\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_147","instance":147,"id":170146,"goal":"lemma Abs_Nonneg_147(m: real)\n ensures (if m >= 0 then m else -m) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_148","instance":148,"id":170147,"goal":"lemma DivMod_148(z: int, y: int)\n requires y > 0\n ensures z == y * (z / y) + (z % y)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_149","instance":149,"id":170148,"goal":"lemma ModBounds_149(b: nat, m: nat)\n requires m > 0\n ensures 0 <= b % m < m\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_150","instance":150,"id":170149,"goal":"lemma Square_Nonneg_150(x: real)\n ensures x * x >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_151","instance":151,"id":170150,"goal":"lemma AddComm_151(i: int, a: int)\n ensures i + a == a + i\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_152","instance":152,"id":170151,"goal":"lemma AddAssoc_152(j: nat, k: nat, m: nat)\n ensures (j + k) + m == j + (k + m)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_153","instance":153,"id":170152,"goal":"lemma MulComm_153(k: real, c: real)\n ensures k * c == c * k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_154","instance":154,"id":170153,"goal":"lemma MulAssoc_154(b: int, a: int, d: int)\n ensures (b * a) * d == b * (a * d)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_155","instance":155,"id":170154,"goal":"lemma Distrib_155(x: nat, c: nat, z: nat)\n ensures x * (c + z) == x * c + x * z\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_156","instance":156,"id":170155,"goal":"lemma AddZero_156(d: real)\n ensures d + 0 == d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_157","instance":157,"id":170156,"goal":"lemma MulOne_157(m: int)\n ensures m * 1 == m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_158","instance":158,"id":170157,"goal":"lemma MulZero_158(m: nat)\n ensures m * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_159","instance":159,"id":170158,"goal":"lemma LeRefl_159(k: real)\n ensures k <= k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_160","instance":160,"id":170159,"goal":"lemma LeTrans_160(n: int, z: int, c: int)\n requires n <= z && z <= c\n ensures n <= c\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_161","instance":161,"id":170160,"goal":"lemma AddMono_161(d: nat, b: nat, x: nat)\n requires d <= b\n ensures d + x <= b + x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_162","instance":162,"id":170161,"goal":"lemma Abs_Nonneg_162(j: real)\n ensures (if j >= 0 then j else -j) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_163","instance":163,"id":170162,"goal":"lemma DivMod_163(k: int, b: int)\n requires b > 0\n ensures k == b * (k / b) + (k % b)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_164","instance":164,"id":170163,"goal":"lemma ModBounds_164(c: nat, b: nat)\n requires b > 0\n ensures 0 <= c % b < b\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_165","instance":165,"id":170164,"goal":"lemma Square_Nonneg_165(c: real)\n ensures c * c >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_166","instance":166,"id":170165,"goal":"lemma AddComm_166(n: int, y: int)\n ensures n + y == y + n\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_167","instance":167,"id":170166,"goal":"lemma AddAssoc_167(x: nat, j: nat, d: nat)\n ensures (x + j) + d == x + (j + d)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_168","instance":168,"id":170167,"goal":"lemma MulComm_168(i: real, b: real)\n ensures i * b == b * i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_169","instance":169,"id":170168,"goal":"lemma MulAssoc_169(i: int, n: int, c: int)\n ensures (i * n) * c == i * (n * c)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_170","instance":170,"id":170169,"goal":"lemma Distrib_170(i: nat, c: nat, a: nat)\n ensures i * (c + a) == i * c + i * a\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_171","instance":171,"id":170170,"goal":"lemma AddZero_171(i: real)\n ensures i + 0 == i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_172","instance":172,"id":170171,"goal":"lemma MulOne_172(x: int)\n ensures x * 1 == x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_173","instance":173,"id":170172,"goal":"lemma MulZero_173(b: nat)\n ensures b * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_174","instance":174,"id":170173,"goal":"lemma LeRefl_174(j: real)\n ensures j <= j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_175","instance":175,"id":170174,"goal":"lemma LeTrans_175(k: int, n: int, y: int)\n requires k <= n && n <= y\n ensures k <= y\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_176","instance":176,"id":170175,"goal":"lemma AddMono_176(y: nat, j: nat, a: nat)\n requires y <= j\n ensures y + a <= j + a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_177","instance":177,"id":170176,"goal":"lemma Abs_Nonneg_177(d: real)\n ensures (if d >= 0 then d else -d) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_178","instance":178,"id":170177,"goal":"lemma DivMod_178(a: int, y: int)\n requires y > 0\n ensures a == y * (a / y) + (a % y)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_179","instance":179,"id":170178,"goal":"lemma ModBounds_179(a: nat, y: nat)\n requires y > 0\n ensures 0 <= a % y < y\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_180","instance":180,"id":170179,"goal":"lemma Square_Nonneg_180(i: real)\n ensures i * i >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_181","instance":181,"id":170180,"goal":"lemma AddComm_181(b: int, i: int)\n ensures b + i == i + b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_182","instance":182,"id":170181,"goal":"lemma AddAssoc_182(z: nat, b: nat, d: nat)\n ensures (z + b) + d == z + (b + d)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_183","instance":183,"id":170182,"goal":"lemma MulComm_183(y: real, j: real)\n ensures y * j == j * y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_184","instance":184,"id":170183,"goal":"lemma MulAssoc_184(j: int, i: int, b: int)\n ensures (j * i) * b == j * (i * b)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_185","instance":185,"id":170184,"goal":"lemma Distrib_185(c: nat, k: nat, z: nat)\n ensures c * (k + z) == c * k + c * z\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_186","instance":186,"id":170185,"goal":"lemma AddZero_186(i: real)\n ensures i + 0 == i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_187","instance":187,"id":170186,"goal":"lemma MulOne_187(x: int)\n ensures x * 1 == x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_188","instance":188,"id":170187,"goal":"lemma MulZero_188(m: nat)\n ensures m * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_189","instance":189,"id":170188,"goal":"lemma LeRefl_189(d: real)\n ensures d <= d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_190","instance":190,"id":170189,"goal":"lemma LeTrans_190(j: int, z: int, x: int)\n requires j <= z && z <= x\n ensures j <= x\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_191","instance":191,"id":170190,"goal":"lemma AddMono_191(j: nat, c: nat, a: nat)\n requires j <= c\n ensures j + a <= c + a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_192","instance":192,"id":170191,"goal":"lemma Abs_Nonneg_192(m: real)\n ensures (if m >= 0 then m else -m) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_193","instance":193,"id":170192,"goal":"lemma DivMod_193(y: int, c: int)\n requires c > 0\n ensures y == c * (y / c) + (y % c)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_194","instance":194,"id":170193,"goal":"lemma ModBounds_194(x: nat, k: nat)\n requires k > 0\n ensures 0 <= x % k < k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_195","instance":195,"id":170194,"goal":"lemma Square_Nonneg_195(a: real)\n ensures a * a >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_196","instance":196,"id":170195,"goal":"lemma AddComm_196(b: int, x: int)\n ensures b + x == x + b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_197","instance":197,"id":170196,"goal":"lemma AddAssoc_197(z: nat, k: nat, d: nat)\n ensures (z + k) + d == z + (k + d)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_198","instance":198,"id":170197,"goal":"lemma MulComm_198(k: real, y: real)\n ensures k * y == y * k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_199","instance":199,"id":170198,"goal":"lemma MulAssoc_199(i: int, a: int, m: int)\n ensures (i * a) * m == i * (a * m)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_200","instance":200,"id":170199,"goal":"lemma Distrib_200(y: nat, a: nat, b: nat)\n ensures y * (a + b) == y * a + y * b\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_201","instance":201,"id":170200,"goal":"lemma AddZero_201(x: real)\n ensures x + 0 == x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_202","instance":202,"id":170201,"goal":"lemma MulOne_202(d: int)\n ensures d * 1 == d\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_203","instance":203,"id":170202,"goal":"lemma MulZero_203(i: nat)\n ensures i * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_204","instance":204,"id":170203,"goal":"lemma LeRefl_204(n: real)\n ensures n <= n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_205","instance":205,"id":170204,"goal":"lemma LeTrans_205(k: int, j: int, z: int)\n requires k <= j && j <= z\n ensures k <= z\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_206","instance":206,"id":170205,"goal":"lemma AddMono_206(b: nat, m: nat, j: nat)\n requires b <= m\n ensures b + j <= m + j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_207","instance":207,"id":170206,"goal":"lemma Abs_Nonneg_207(d: real)\n ensures (if d >= 0 then d else -d) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_208","instance":208,"id":170207,"goal":"lemma DivMod_208(n: int, a: int)\n requires a > 0\n ensures n == a * (n / a) + (n % a)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_209","instance":209,"id":170208,"goal":"lemma ModBounds_209(d: nat, n: nat)\n requires n > 0\n ensures 0 <= d % n < n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_210","instance":210,"id":170209,"goal":"lemma Square_Nonneg_210(d: real)\n ensures d * d >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_211","instance":211,"id":170210,"goal":"lemma AddComm_211(n: int, c: int)\n ensures n + c == c + n\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_212","instance":212,"id":170211,"goal":"lemma AddAssoc_212(y: nat, i: nat, k: nat)\n ensures (y + i) + k == y + (i + k)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_213","instance":213,"id":170212,"goal":"lemma MulComm_213(b: real, c: real)\n ensures b * c == c * b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_214","instance":214,"id":170213,"goal":"lemma MulAssoc_214(m: int, b: int, i: int)\n ensures (m * b) * i == m * (b * i)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_215","instance":215,"id":170214,"goal":"lemma Distrib_215(n: nat, j: nat, a: nat)\n ensures n * (j + a) == n * j + n * a\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_216","instance":216,"id":170215,"goal":"lemma AddZero_216(i: real)\n ensures i + 0 == i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_217","instance":217,"id":170216,"goal":"lemma MulOne_217(n: int)\n ensures n * 1 == n\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_218","instance":218,"id":170217,"goal":"lemma MulZero_218(a: nat)\n ensures a * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_219","instance":219,"id":170218,"goal":"lemma LeRefl_219(n: real)\n ensures n <= n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_220","instance":220,"id":170219,"goal":"lemma LeTrans_220(b: int, i: int, c: int)\n requires b <= i && i <= c\n ensures b <= c\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_221","instance":221,"id":170220,"goal":"lemma AddMono_221(j: nat, n: nat, k: nat)\n requires j <= n\n ensures j + k <= n + k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_222","instance":222,"id":170221,"goal":"lemma Abs_Nonneg_222(y: real)\n ensures (if y >= 0 then y else -y) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_223","instance":223,"id":170222,"goal":"lemma DivMod_223(c: int, n: int)\n requires n > 0\n ensures c == n * (c / n) + (c % n)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_224","instance":224,"id":170223,"goal":"lemma ModBounds_224(x: nat, z: nat)\n requires z > 0\n ensures 0 <= x % z < z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_225","instance":225,"id":170224,"goal":"lemma Square_Nonneg_225(k: real)\n ensures k * k >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_226","instance":226,"id":170225,"goal":"lemma AddComm_226(k: int, y: int)\n ensures k + y == y + k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_227","instance":227,"id":170226,"goal":"lemma AddAssoc_227(j: nat, c: nat, i: nat)\n ensures (j + c) + i == j + (c + i)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_228","instance":228,"id":170227,"goal":"lemma MulComm_228(c: real, i: real)\n ensures c * i == i * c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_229","instance":229,"id":170228,"goal":"lemma MulAssoc_229(m: int, i: int, j: int)\n ensures (m * i) * j == m * (i * j)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_230","instance":230,"id":170229,"goal":"lemma Distrib_230(z: nat, k: nat, a: nat)\n ensures z * (k + a) == z * k + z * a\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_231","instance":231,"id":170230,"goal":"lemma AddZero_231(z: real)\n ensures z + 0 == z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_232","instance":232,"id":170231,"goal":"lemma MulOne_232(x: int)\n ensures x * 1 == x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_233","instance":233,"id":170232,"goal":"lemma MulZero_233(z: nat)\n ensures z * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_234","instance":234,"id":170233,"goal":"lemma LeRefl_234(d: real)\n ensures d <= d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_235","instance":235,"id":170234,"goal":"lemma LeTrans_235(y: int, a: int, j: int)\n requires y <= a && a <= j\n ensures y <= j\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_236","instance":236,"id":170235,"goal":"lemma AddMono_236(z: nat, c: nat, b: nat)\n requires z <= c\n ensures z + b <= c + b\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_237","instance":237,"id":170236,"goal":"lemma Abs_Nonneg_237(y: real)\n ensures (if y >= 0 then y else -y) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_238","instance":238,"id":170237,"goal":"lemma DivMod_238(c: int, i: int)\n requires i > 0\n ensures c == i * (c / i) + (c % i)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_239","instance":239,"id":170238,"goal":"lemma ModBounds_239(j: nat, z: nat)\n requires z > 0\n ensures 0 <= j % z < z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_240","instance":240,"id":170239,"goal":"lemma Square_Nonneg_240(z: real)\n ensures z * z >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_241","instance":241,"id":170240,"goal":"lemma AddComm_241(n: int, m: int)\n ensures n + m == m + n\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_242","instance":242,"id":170241,"goal":"lemma AddAssoc_242(y: nat, j: nat, d: nat)\n ensures (y + j) + d == y + (j + d)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_243","instance":243,"id":170242,"goal":"lemma MulComm_243(x: real, a: real)\n ensures x * a == a * x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_244","instance":244,"id":170243,"goal":"lemma MulAssoc_244(j: int, y: int, k: int)\n ensures (j * y) * k == j * (y * k)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_245","instance":245,"id":170244,"goal":"lemma Distrib_245(d: nat, z: nat, y: nat)\n ensures d * (z + y) == d * z + d * y\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_246","instance":246,"id":170245,"goal":"lemma AddZero_246(y: real)\n ensures y + 0 == y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_247","instance":247,"id":170246,"goal":"lemma MulOne_247(m: int)\n ensures m * 1 == m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_248","instance":248,"id":170247,"goal":"lemma MulZero_248(j: nat)\n ensures j * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_249","instance":249,"id":170248,"goal":"lemma LeRefl_249(y: real)\n ensures y <= y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_250","instance":250,"id":170249,"goal":"lemma LeTrans_250(a: int, b: int, i: int)\n requires a <= b && b <= i\n ensures a <= i\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_251","instance":251,"id":170250,"goal":"lemma AddMono_251(a: nat, j: nat, b: nat)\n requires a <= j\n ensures a + b <= j + b\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_252","instance":252,"id":170251,"goal":"lemma Abs_Nonneg_252(k: real)\n ensures (if k >= 0 then k else -k) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_253","instance":253,"id":170252,"goal":"lemma DivMod_253(k: int, j: int)\n requires j > 0\n ensures k == j * (k / j) + (k % j)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_254","instance":254,"id":170253,"goal":"lemma ModBounds_254(d: nat, c: nat)\n requires c > 0\n ensures 0 <= d % c < c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_255","instance":255,"id":170254,"goal":"lemma Square_Nonneg_255(z: real)\n ensures z * z >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_256","instance":256,"id":170255,"goal":"lemma AddComm_256(k: int, a: int)\n ensures k + a == a + k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_257","instance":257,"id":170256,"goal":"lemma AddAssoc_257(m: nat, k: nat, x: nat)\n ensures (m + k) + x == m + (k + x)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_258","instance":258,"id":170257,"goal":"lemma MulComm_258(y: real, m: real)\n ensures y * m == m * y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_259","instance":259,"id":170258,"goal":"lemma MulAssoc_259(i: int, d: int, k: int)\n ensures (i * d) * k == i * (d * k)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_260","instance":260,"id":170259,"goal":"lemma Distrib_260(d: nat, x: nat, i: nat)\n ensures d * (x + i) == d * x + d * i\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_261","instance":261,"id":170260,"goal":"lemma AddZero_261(x: real)\n ensures x + 0 == x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_262","instance":262,"id":170261,"goal":"lemma MulOne_262(x: int)\n ensures x * 1 == x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_263","instance":263,"id":170262,"goal":"lemma MulZero_263(y: nat)\n ensures y * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_264","instance":264,"id":170263,"goal":"lemma LeRefl_264(j: real)\n ensures j <= j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_265","instance":265,"id":170264,"goal":"lemma LeTrans_265(m: int, j: int, c: int)\n requires m <= j && j <= c\n ensures m <= c\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_266","instance":266,"id":170265,"goal":"lemma AddMono_266(j: nat, x: nat, c: nat)\n requires j <= x\n ensures j + c <= x + c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_267","instance":267,"id":170266,"goal":"lemma Abs_Nonneg_267(x: real)\n ensures (if x >= 0 then x else -x) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_268","instance":268,"id":170267,"goal":"lemma DivMod_268(y: int, k: int)\n requires k > 0\n ensures y == k * (y / k) + (y % k)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_269","instance":269,"id":170268,"goal":"lemma ModBounds_269(j: nat, k: nat)\n requires k > 0\n ensures 0 <= j % k < k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_270","instance":270,"id":170269,"goal":"lemma Square_Nonneg_270(j: real)\n ensures j * j >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_271","instance":271,"id":170270,"goal":"lemma AddComm_271(j: int, n: int)\n ensures j + n == n + j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_272","instance":272,"id":170271,"goal":"lemma AddAssoc_272(a: nat, i: nat, b: nat)\n ensures (a + i) + b == a + (i + b)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_273","instance":273,"id":170272,"goal":"lemma MulComm_273(n: real, x: real)\n ensures n * x == x * n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_274","instance":274,"id":170273,"goal":"lemma MulAssoc_274(a: int, n: int, b: int)\n ensures (a * n) * b == a * (n * b)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_275","instance":275,"id":170274,"goal":"lemma Distrib_275(d: nat, z: nat, k: nat)\n ensures d * (z + k) == d * z + d * k\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_276","instance":276,"id":170275,"goal":"lemma AddZero_276(z: real)\n ensures z + 0 == z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_277","instance":277,"id":170276,"goal":"lemma MulOne_277(m: int)\n ensures m * 1 == m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_278","instance":278,"id":170277,"goal":"lemma MulZero_278(n: nat)\n ensures n * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_279","instance":279,"id":170278,"goal":"lemma LeRefl_279(i: real)\n ensures i <= i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_280","instance":280,"id":170279,"goal":"lemma LeTrans_280(d: int, k: int, z: int)\n requires d <= k && k <= z\n ensures d <= z\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_281","instance":281,"id":170280,"goal":"lemma AddMono_281(m: nat, n: nat, i: nat)\n requires m <= n\n ensures m + i <= n + i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_282","instance":282,"id":170281,"goal":"lemma Abs_Nonneg_282(a: real)\n ensures (if a >= 0 then a else -a) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_283","instance":283,"id":170282,"goal":"lemma DivMod_283(i: int, m: int)\n requires m > 0\n ensures i == m * (i / m) + (i % m)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_284","instance":284,"id":170283,"goal":"lemma ModBounds_284(a: nat, x: nat)\n requires x > 0\n ensures 0 <= a % x < x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_285","instance":285,"id":170284,"goal":"lemma Square_Nonneg_285(y: real)\n ensures y * y >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_286","instance":286,"id":170285,"goal":"lemma AddComm_286(j: int, i: int)\n ensures j + i == i + j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_287","instance":287,"id":170286,"goal":"lemma AddAssoc_287(x: nat, d: nat, m: nat)\n ensures (x + d) + m == x + (d + m)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_288","instance":288,"id":170287,"goal":"lemma MulComm_288(z: real, b: real)\n ensures z * b == b * z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_289","instance":289,"id":170288,"goal":"lemma MulAssoc_289(z: int, m: int, i: int)\n ensures (z * m) * i == z * (m * i)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_290","instance":290,"id":170289,"goal":"lemma Distrib_290(k: nat, d: nat, c: nat)\n ensures k * (d + c) == k * d + k * c\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_291","instance":291,"id":170290,"goal":"lemma AddZero_291(j: real)\n ensures j + 0 == j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_292","instance":292,"id":170291,"goal":"lemma MulOne_292(j: int)\n ensures j * 1 == j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_293","instance":293,"id":170292,"goal":"lemma MulZero_293(b: nat)\n ensures b * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_294","instance":294,"id":170293,"goal":"lemma LeRefl_294(i: real)\n ensures i <= i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_295","instance":295,"id":170294,"goal":"lemma LeTrans_295(k: int, x: int, a: int)\n requires k <= x && x <= a\n ensures k <= a\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_296","instance":296,"id":170295,"goal":"lemma AddMono_296(m: nat, y: nat, n: nat)\n requires m <= y\n ensures m + n <= y + n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_297","instance":297,"id":170296,"goal":"lemma Abs_Nonneg_297(d: real)\n ensures (if d >= 0 then d else -d) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_298","instance":298,"id":170297,"goal":"lemma DivMod_298(j: int, n: int)\n requires n > 0\n ensures j == n * (j / n) + (j % n)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_299","instance":299,"id":170298,"goal":"lemma ModBounds_299(m: nat, d: nat)\n requires d > 0\n ensures 0 <= m % d < d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_300","instance":300,"id":170299,"goal":"lemma Square_Nonneg_300(m: real)\n ensures m * m >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_301","instance":301,"id":170300,"goal":"lemma AddComm_301(k: int, x: int)\n ensures k + x == x + k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_302","instance":302,"id":170301,"goal":"lemma AddAssoc_302(c: nat, y: nat, k: nat)\n ensures (c + y) + k == c + (y + k)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_303","instance":303,"id":170302,"goal":"lemma MulComm_303(x: real, c: real)\n ensures x * c == c * x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_304","instance":304,"id":170303,"goal":"lemma MulAssoc_304(b: int, j: int, z: int)\n ensures (b * j) * z == b * (j * z)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_305","instance":305,"id":170304,"goal":"lemma Distrib_305(i: nat, d: nat, z: nat)\n ensures i * (d + z) == i * d + i * z\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_306","instance":306,"id":170305,"goal":"lemma AddZero_306(d: real)\n ensures d + 0 == d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_307","instance":307,"id":170306,"goal":"lemma MulOne_307(z: int)\n ensures z * 1 == z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_308","instance":308,"id":170307,"goal":"lemma MulZero_308(i: nat)\n ensures i * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_309","instance":309,"id":170308,"goal":"lemma LeRefl_309(y: real)\n ensures y <= y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_310","instance":310,"id":170309,"goal":"lemma LeTrans_310(z: int, y: int, a: int)\n requires z <= y && y <= a\n ensures z <= a\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_311","instance":311,"id":170310,"goal":"lemma AddMono_311(y: nat, i: nat, z: nat)\n requires y <= i\n ensures y + z <= i + z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_312","instance":312,"id":170311,"goal":"lemma Abs_Nonneg_312(z: real)\n ensures (if z >= 0 then z else -z) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_313","instance":313,"id":170312,"goal":"lemma DivMod_313(a: int, x: int)\n requires x > 0\n ensures a == x * (a / x) + (a % x)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_314","instance":314,"id":170313,"goal":"lemma ModBounds_314(d: nat, y: nat)\n requires y > 0\n ensures 0 <= d % y < y\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_315","instance":315,"id":170314,"goal":"lemma Square_Nonneg_315(a: real)\n ensures a * a >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_316","instance":316,"id":170315,"goal":"lemma AddComm_316(y: int, n: int)\n ensures y + n == n + y\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_317","instance":317,"id":170316,"goal":"lemma AddAssoc_317(z: nat, a: nat, k: nat)\n ensures (z + a) + k == z + (a + k)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_318","instance":318,"id":170317,"goal":"lemma MulComm_318(k: real, c: real)\n ensures k * c == c * k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_319","instance":319,"id":170318,"goal":"lemma MulAssoc_319(a: int, z: int, m: int)\n ensures (a * z) * m == a * (z * m)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_320","instance":320,"id":170319,"goal":"lemma Distrib_320(m: nat, d: nat, a: nat)\n ensures m * (d + a) == m * d + m * a\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_321","instance":321,"id":170320,"goal":"lemma AddZero_321(a: real)\n ensures a + 0 == a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_322","instance":322,"id":170321,"goal":"lemma MulOne_322(c: int)\n ensures c * 1 == c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_323","instance":323,"id":170322,"goal":"lemma MulZero_323(z: nat)\n ensures z * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_324","instance":324,"id":170323,"goal":"lemma LeRefl_324(k: real)\n ensures k <= k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_325","instance":325,"id":170324,"goal":"lemma LeTrans_325(j: int, d: int, y: int)\n requires j <= d && d <= y\n ensures j <= y\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_326","instance":326,"id":170325,"goal":"lemma AddMono_326(a: nat, n: nat, i: nat)\n requires a <= n\n ensures a + i <= n + i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_327","instance":327,"id":170326,"goal":"lemma Abs_Nonneg_327(m: real)\n ensures (if m >= 0 then m else -m) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_328","instance":328,"id":170327,"goal":"lemma DivMod_328(x: int, c: int)\n requires c > 0\n ensures x == c * (x / c) + (x % c)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_329","instance":329,"id":170328,"goal":"lemma ModBounds_329(b: nat, d: nat)\n requires d > 0\n ensures 0 <= b % d < d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_330","instance":330,"id":170329,"goal":"lemma Square_Nonneg_330(b: real)\n ensures b * b >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_331","instance":331,"id":170330,"goal":"lemma AddComm_331(a: int, j: int)\n ensures a + j == j + a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_332","instance":332,"id":170331,"goal":"lemma AddAssoc_332(m: nat, y: nat, j: nat)\n ensures (m + y) + j == m + (y + j)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_333","instance":333,"id":170332,"goal":"lemma MulComm_333(y: real, b: real)\n ensures y * b == b * y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_334","instance":334,"id":170333,"goal":"lemma MulAssoc_334(b: int, y: int, a: int)\n ensures (b * y) * a == b * (y * a)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_335","instance":335,"id":170334,"goal":"lemma Distrib_335(a: nat, j: nat, d: nat)\n ensures a * (j + d) == a * j + a * d\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_336","instance":336,"id":170335,"goal":"lemma AddZero_336(k: real)\n ensures k + 0 == k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_337","instance":337,"id":170336,"goal":"lemma MulOne_337(m: int)\n ensures m * 1 == m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_338","instance":338,"id":170337,"goal":"lemma MulZero_338(x: nat)\n ensures x * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_339","instance":339,"id":170338,"goal":"lemma LeRefl_339(j: real)\n ensures j <= j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_340","instance":340,"id":170339,"goal":"lemma LeTrans_340(k: int, c: int, x: int)\n requires k <= c && c <= x\n ensures k <= x\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_341","instance":341,"id":170340,"goal":"lemma AddMono_341(m: nat, b: nat, x: nat)\n requires m <= b\n ensures m + x <= b + x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_342","instance":342,"id":170341,"goal":"lemma Abs_Nonneg_342(d: real)\n ensures (if d >= 0 then d else -d) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_343","instance":343,"id":170342,"goal":"lemma DivMod_343(b: int, y: int)\n requires y > 0\n ensures b == y * (b / y) + (b % y)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_344","instance":344,"id":170343,"goal":"lemma ModBounds_344(i: nat, m: nat)\n requires m > 0\n ensures 0 <= i % m < m\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_345","instance":345,"id":170344,"goal":"lemma Square_Nonneg_345(a: real)\n ensures a * a >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_346","instance":346,"id":170345,"goal":"lemma AddComm_346(z: int, m: int)\n ensures z + m == m + z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_347","instance":347,"id":170346,"goal":"lemma AddAssoc_347(i: nat, n: nat, y: nat)\n ensures (i + n) + y == i + (n + y)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_348","instance":348,"id":170347,"goal":"lemma MulComm_348(d: real, y: real)\n ensures d * y == y * d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_349","instance":349,"id":170348,"goal":"lemma MulAssoc_349(i: int, j: int, a: int)\n ensures (i * j) * a == i * (j * a)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_350","instance":350,"id":170349,"goal":"lemma Distrib_350(z: nat, b: nat, y: nat)\n ensures z * (b + y) == z * b + z * y\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_351","instance":351,"id":170350,"goal":"lemma AddZero_351(z: real)\n ensures z + 0 == z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_352","instance":352,"id":170351,"goal":"lemma MulOne_352(b: int)\n ensures b * 1 == b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_353","instance":353,"id":170352,"goal":"lemma MulZero_353(b: nat)\n ensures b * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_354","instance":354,"id":170353,"goal":"lemma LeRefl_354(b: real)\n ensures b <= b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_355","instance":355,"id":170354,"goal":"lemma LeTrans_355(k: int, m: int, c: int)\n requires k <= m && m <= c\n ensures k <= c\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_356","instance":356,"id":170355,"goal":"lemma AddMono_356(c: nat, z: nat, b: nat)\n requires c <= z\n ensures c + b <= z + b\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_357","instance":357,"id":170356,"goal":"lemma Abs_Nonneg_357(a: real)\n ensures (if a >= 0 then a else -a) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_358","instance":358,"id":170357,"goal":"lemma DivMod_358(j: int, n: int)\n requires n > 0\n ensures j == n * (j / n) + (j % n)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_359","instance":359,"id":170358,"goal":"lemma ModBounds_359(k: nat, x: nat)\n requires x > 0\n ensures 0 <= k % x < x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_360","instance":360,"id":170359,"goal":"lemma Square_Nonneg_360(z: real)\n ensures z * z >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_361","instance":361,"id":170360,"goal":"lemma AddComm_361(m: int, b: int)\n ensures m + b == b + m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_362","instance":362,"id":170361,"goal":"lemma AddAssoc_362(b: nat, z: nat, x: nat)\n ensures (b + z) + x == b + (z + x)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_363","instance":363,"id":170362,"goal":"lemma MulComm_363(m: real, i: real)\n ensures m * i == i * m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_364","instance":364,"id":170363,"goal":"lemma MulAssoc_364(m: int, x: int, y: int)\n ensures (m * x) * y == m * (x * y)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_365","instance":365,"id":170364,"goal":"lemma Distrib_365(i: nat, k: nat, d: nat)\n ensures i * (k + d) == i * k + i * d\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_366","instance":366,"id":170365,"goal":"lemma AddZero_366(b: real)\n ensures b + 0 == b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_367","instance":367,"id":170366,"goal":"lemma MulOne_367(n: int)\n ensures n * 1 == n\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_368","instance":368,"id":170367,"goal":"lemma MulZero_368(b: nat)\n ensures b * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_369","instance":369,"id":170368,"goal":"lemma LeRefl_369(z: real)\n ensures z <= z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_370","instance":370,"id":170369,"goal":"lemma LeTrans_370(k: int, d: int, z: int)\n requires k <= d && d <= z\n ensures k <= z\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_371","instance":371,"id":170370,"goal":"lemma AddMono_371(a: nat, d: nat, z: nat)\n requires a <= d\n ensures a + z <= d + z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_372","instance":372,"id":170371,"goal":"lemma Abs_Nonneg_372(i: real)\n ensures (if i >= 0 then i else -i) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_373","instance":373,"id":170372,"goal":"lemma DivMod_373(k: int, a: int)\n requires a > 0\n ensures k == a * (k / a) + (k % a)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_374","instance":374,"id":170373,"goal":"lemma ModBounds_374(k: nat, d: nat)\n requires d > 0\n ensures 0 <= k % d < d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_375","instance":375,"id":170374,"goal":"lemma Square_Nonneg_375(i: real)\n ensures i * i >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_376","instance":376,"id":170375,"goal":"lemma AddComm_376(b: int, j: int)\n ensures b + j == j + b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_377","instance":377,"id":170376,"goal":"lemma AddAssoc_377(k: nat, d: nat, i: nat)\n ensures (k + d) + i == k + (d + i)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_378","instance":378,"id":170377,"goal":"lemma MulComm_378(z: real, j: real)\n ensures z * j == j * z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_379","instance":379,"id":170378,"goal":"lemma MulAssoc_379(a: int, i: int, j: int)\n ensures (a * i) * j == a * (i * j)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_380","instance":380,"id":170379,"goal":"lemma Distrib_380(k: nat, x: nat, z: nat)\n ensures k * (x + z) == k * x + k * z\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_381","instance":381,"id":170380,"goal":"lemma AddZero_381(n: real)\n ensures n + 0 == n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_382","instance":382,"id":170381,"goal":"lemma MulOne_382(d: int)\n ensures d * 1 == d\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_383","instance":383,"id":170382,"goal":"lemma MulZero_383(c: nat)\n ensures c * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_384","instance":384,"id":170383,"goal":"lemma LeRefl_384(j: real)\n ensures j <= j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_385","instance":385,"id":170384,"goal":"lemma LeTrans_385(y: int, n: int, x: int)\n requires y <= n && n <= x\n ensures y <= x\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_386","instance":386,"id":170385,"goal":"lemma AddMono_386(x: nat, d: nat, i: nat)\n requires x <= d\n ensures x + i <= d + i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_387","instance":387,"id":170386,"goal":"lemma Abs_Nonneg_387(i: real)\n ensures (if i >= 0 then i else -i) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_388","instance":388,"id":170387,"goal":"lemma DivMod_388(a: int, z: int)\n requires z > 0\n ensures a == z * (a / z) + (a % z)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_389","instance":389,"id":170388,"goal":"lemma ModBounds_389(i: nat, m: nat)\n requires m > 0\n ensures 0 <= i % m < m\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_390","instance":390,"id":170389,"goal":"lemma Square_Nonneg_390(k: real)\n ensures k * k >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_391","instance":391,"id":170390,"goal":"lemma AddComm_391(a: int, j: int)\n ensures a + j == j + a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_392","instance":392,"id":170391,"goal":"lemma AddAssoc_392(n: nat, k: nat, m: nat)\n ensures (n + k) + m == n + (k + m)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_393","instance":393,"id":170392,"goal":"lemma MulComm_393(d: real, m: real)\n ensures d * m == m * d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_394","instance":394,"id":170393,"goal":"lemma MulAssoc_394(c: int, m: int, d: int)\n ensures (c * m) * d == c * (m * d)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_395","instance":395,"id":170394,"goal":"lemma Distrib_395(i: nat, k: nat, d: nat)\n ensures i * (k + d) == i * k + i * d\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_396","instance":396,"id":170395,"goal":"lemma AddZero_396(k: real)\n ensures k + 0 == k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_397","instance":397,"id":170396,"goal":"lemma MulOne_397(n: int)\n ensures n * 1 == n\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_398","instance":398,"id":170397,"goal":"lemma MulZero_398(n: nat)\n ensures n * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_399","instance":399,"id":170398,"goal":"lemma LeRefl_399(m: real)\n ensures m <= m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_400","instance":400,"id":170399,"goal":"lemma LeTrans_400(z: int, c: int, n: int)\n requires z <= c && c <= n\n ensures z <= n\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_401","instance":401,"id":170400,"goal":"lemma AddMono_401(k: nat, i: nat, y: nat)\n requires k <= i\n ensures k + y <= i + y\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_402","instance":402,"id":170401,"goal":"lemma Abs_Nonneg_402(z: real)\n ensures (if z >= 0 then z else -z) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_403","instance":403,"id":170402,"goal":"lemma DivMod_403(j: int, n: int)\n requires n > 0\n ensures j == n * (j / n) + (j % n)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_404","instance":404,"id":170403,"goal":"lemma ModBounds_404(z: nat, j: nat)\n requires j > 0\n ensures 0 <= z % j < j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_405","instance":405,"id":170404,"goal":"lemma Square_Nonneg_405(a: real)\n ensures a * a >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_406","instance":406,"id":170405,"goal":"lemma AddComm_406(m: int, c: int)\n ensures m + c == c + m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_407","instance":407,"id":170406,"goal":"lemma AddAssoc_407(d: nat, y: nat, z: nat)\n ensures (d + y) + z == d + (y + z)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_408","instance":408,"id":170407,"goal":"lemma MulComm_408(j: real, z: real)\n ensures j * z == z * j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_409","instance":409,"id":170408,"goal":"lemma MulAssoc_409(a: int, n: int, b: int)\n ensures (a * n) * b == a * (n * b)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_410","instance":410,"id":170409,"goal":"lemma Distrib_410(d: nat, z: nat, y: nat)\n ensures d * (z + y) == d * z + d * y\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_411","instance":411,"id":170410,"goal":"lemma AddZero_411(a: real)\n ensures a + 0 == a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_412","instance":412,"id":170411,"goal":"lemma MulOne_412(z: int)\n ensures z * 1 == z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_413","instance":413,"id":170412,"goal":"lemma MulZero_413(k: nat)\n ensures k * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_414","instance":414,"id":170413,"goal":"lemma LeRefl_414(i: real)\n ensures i <= i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_415","instance":415,"id":170414,"goal":"lemma LeTrans_415(n: int, a: int, i: int)\n requires n <= a && a <= i\n ensures n <= i\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_416","instance":416,"id":170415,"goal":"lemma AddMono_416(a: nat, n: nat, i: nat)\n requires a <= n\n ensures a + i <= n + i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_417","instance":417,"id":170416,"goal":"lemma Abs_Nonneg_417(i: real)\n ensures (if i >= 0 then i else -i) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_418","instance":418,"id":170417,"goal":"lemma DivMod_418(z: int, x: int)\n requires x > 0\n ensures z == x * (z / x) + (z % x)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_419","instance":419,"id":170418,"goal":"lemma ModBounds_419(a: nat, k: nat)\n requires k > 0\n ensures 0 <= a % k < k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_420","instance":420,"id":170419,"goal":"lemma Square_Nonneg_420(i: real)\n ensures i * i >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_421","instance":421,"id":170420,"goal":"lemma AddComm_421(b: int, m: int)\n ensures b + m == m + b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_422","instance":422,"id":170421,"goal":"lemma AddAssoc_422(z: nat, n: nat, y: nat)\n ensures (z + n) + y == z + (n + y)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_423","instance":423,"id":170422,"goal":"lemma MulComm_423(m: real, i: real)\n ensures m * i == i * m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_424","instance":424,"id":170423,"goal":"lemma MulAssoc_424(a: int, i: int, c: int)\n ensures (a * i) * c == a * (i * c)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_425","instance":425,"id":170424,"goal":"lemma Distrib_425(c: nat, k: nat, j: nat)\n ensures c * (k + j) == c * k + c * j\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_426","instance":426,"id":170425,"goal":"lemma AddZero_426(a: real)\n ensures a + 0 == a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_427","instance":427,"id":170426,"goal":"lemma MulOne_427(y: int)\n ensures y * 1 == y\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_428","instance":428,"id":170427,"goal":"lemma MulZero_428(n: nat)\n ensures n * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_429","instance":429,"id":170428,"goal":"lemma LeRefl_429(b: real)\n ensures b <= b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_430","instance":430,"id":170429,"goal":"lemma LeTrans_430(k: int, i: int, x: int)\n requires k <= i && i <= x\n ensures k <= x\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_431","instance":431,"id":170430,"goal":"lemma AddMono_431(x: nat, c: nat, y: nat)\n requires x <= c\n ensures x + y <= c + y\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_432","instance":432,"id":170431,"goal":"lemma Abs_Nonneg_432(c: real)\n ensures (if c >= 0 then c else -c) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_433","instance":433,"id":170432,"goal":"lemma DivMod_433(z: int, y: int)\n requires y > 0\n ensures z == y * (z / y) + (z % y)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_434","instance":434,"id":170433,"goal":"lemma ModBounds_434(k: nat, n: nat)\n requires n > 0\n ensures 0 <= k % n < n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_435","instance":435,"id":170434,"goal":"lemma Square_Nonneg_435(z: real)\n ensures z * z >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_436","instance":436,"id":170435,"goal":"lemma AddComm_436(n: int, b: int)\n ensures n + b == b + n\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_437","instance":437,"id":170436,"goal":"lemma AddAssoc_437(j: nat, n: nat, z: nat)\n ensures (j + n) + z == j + (n + z)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_438","instance":438,"id":170437,"goal":"lemma MulComm_438(x: real, k: real)\n ensures x * k == k * x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_439","instance":439,"id":170438,"goal":"lemma MulAssoc_439(k: int, y: int, n: int)\n ensures (k * y) * n == k * (y * n)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_440","instance":440,"id":170439,"goal":"lemma Distrib_440(j: nat, m: nat, c: nat)\n ensures j * (m + c) == j * m + j * c\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_441","instance":441,"id":170440,"goal":"lemma AddZero_441(k: real)\n ensures k + 0 == k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_442","instance":442,"id":170441,"goal":"lemma MulOne_442(z: int)\n ensures z * 1 == z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_443","instance":443,"id":170442,"goal":"lemma MulZero_443(x: nat)\n ensures x * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_444","instance":444,"id":170443,"goal":"lemma LeRefl_444(z: real)\n ensures z <= z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_445","instance":445,"id":170444,"goal":"lemma LeTrans_445(x: int, m: int, z: int)\n requires x <= m && m <= z\n ensures x <= z\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_446","instance":446,"id":170445,"goal":"lemma AddMono_446(z: nat, x: nat, b: nat)\n requires z <= x\n ensures z + b <= x + b\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_447","instance":447,"id":170446,"goal":"lemma Abs_Nonneg_447(m: real)\n ensures (if m >= 0 then m else -m) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_448","instance":448,"id":170447,"goal":"lemma DivMod_448(z: int, b: int)\n requires b > 0\n ensures z == b * (z / b) + (z % b)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_449","instance":449,"id":170448,"goal":"lemma ModBounds_449(c: nat, a: nat)\n requires a > 0\n ensures 0 <= c % a < a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_450","instance":450,"id":170449,"goal":"lemma Square_Nonneg_450(j: real)\n ensures j * j >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_451","instance":451,"id":170450,"goal":"lemma AddComm_451(b: int, z: int)\n ensures b + z == z + b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_452","instance":452,"id":170451,"goal":"lemma AddAssoc_452(n: nat, c: nat, a: nat)\n ensures (n + c) + a == n + (c + a)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_453","instance":453,"id":170452,"goal":"lemma MulComm_453(c: real, x: real)\n ensures c * x == x * c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_454","instance":454,"id":170453,"goal":"lemma MulAssoc_454(c: int, n: int, d: int)\n ensures (c * n) * d == c * (n * d)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_455","instance":455,"id":170454,"goal":"lemma Distrib_455(y: nat, k: nat, j: nat)\n ensures y * (k + j) == y * k + y * j\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_456","instance":456,"id":170455,"goal":"lemma AddZero_456(y: real)\n ensures y + 0 == y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_457","instance":457,"id":170456,"goal":"lemma MulOne_457(k: int)\n ensures k * 1 == k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_458","instance":458,"id":170457,"goal":"lemma MulZero_458(z: nat)\n ensures z * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_459","instance":459,"id":170458,"goal":"lemma LeRefl_459(c: real)\n ensures c <= c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_460","instance":460,"id":170459,"goal":"lemma LeTrans_460(d: int, y: int, k: int)\n requires d <= y && y <= k\n ensures d <= k\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_461","instance":461,"id":170460,"goal":"lemma AddMono_461(i: nat, c: nat, j: nat)\n requires i <= c\n ensures i + j <= c + j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_462","instance":462,"id":170461,"goal":"lemma Abs_Nonneg_462(j: real)\n ensures (if j >= 0 then j else -j) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_463","instance":463,"id":170462,"goal":"lemma DivMod_463(b: int, z: int)\n requires z > 0\n ensures b == z * (b / z) + (b % z)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_464","instance":464,"id":170463,"goal":"lemma ModBounds_464(k: nat, a: nat)\n requires a > 0\n ensures 0 <= k % a < a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_465","instance":465,"id":170464,"goal":"lemma Square_Nonneg_465(c: real)\n ensures c * c >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_466","instance":466,"id":170465,"goal":"lemma AddComm_466(m: int, j: int)\n ensures m + j == j + m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_467","instance":467,"id":170466,"goal":"lemma AddAssoc_467(n: nat, z: nat, a: nat)\n ensures (n + z) + a == n + (z + a)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_468","instance":468,"id":170467,"goal":"lemma MulComm_468(x: real, m: real)\n ensures x * m == m * x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_469","instance":469,"id":170468,"goal":"lemma MulAssoc_469(a: int, b: int, x: int)\n ensures (a * b) * x == a * (b * x)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_470","instance":470,"id":170469,"goal":"lemma Distrib_470(n: nat, a: nat, m: nat)\n ensures n * (a + m) == n * a + n * m\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_471","instance":471,"id":170470,"goal":"lemma AddZero_471(d: real)\n ensures d + 0 == d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_472","instance":472,"id":170471,"goal":"lemma MulOne_472(x: int)\n ensures x * 1 == x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_473","instance":473,"id":170472,"goal":"lemma MulZero_473(i: nat)\n ensures i * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_474","instance":474,"id":170473,"goal":"lemma LeRefl_474(b: real)\n ensures b <= b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_475","instance":475,"id":170474,"goal":"lemma LeTrans_475(k: int, y: int, n: int)\n requires k <= y && y <= n\n ensures k <= n\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_476","instance":476,"id":170475,"goal":"lemma AddMono_476(c: nat, m: nat, x: nat)\n requires c <= m\n ensures c + x <= m + x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_477","instance":477,"id":170476,"goal":"lemma Abs_Nonneg_477(x: real)\n ensures (if x >= 0 then x else -x) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_478","instance":478,"id":170477,"goal":"lemma DivMod_478(a: int, i: int)\n requires i > 0\n ensures a == i * (a / i) + (a % i)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_479","instance":479,"id":170478,"goal":"lemma ModBounds_479(c: nat, j: nat)\n requires j > 0\n ensures 0 <= c % j < j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_480","instance":480,"id":170479,"goal":"lemma Square_Nonneg_480(a: real)\n ensures a * a >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_481","instance":481,"id":170480,"goal":"lemma AddComm_481(m: int, a: int)\n ensures m + a == a + m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_482","instance":482,"id":170481,"goal":"lemma AddAssoc_482(b: nat, k: nat, c: nat)\n ensures (b + k) + c == b + (k + c)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_483","instance":483,"id":170482,"goal":"lemma MulComm_483(x: real, k: real)\n ensures x * k == k * x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_484","instance":484,"id":170483,"goal":"lemma MulAssoc_484(x: int, z: int, a: int)\n ensures (x * z) * a == x * (z * a)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_485","instance":485,"id":170484,"goal":"lemma Distrib_485(x: nat, n: nat, j: nat)\n ensures x * (n + j) == x * n + x * j\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_486","instance":486,"id":170485,"goal":"lemma AddZero_486(m: real)\n ensures m + 0 == m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_487","instance":487,"id":170486,"goal":"lemma MulOne_487(y: int)\n ensures y * 1 == y\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_488","instance":488,"id":170487,"goal":"lemma MulZero_488(b: nat)\n ensures b * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_489","instance":489,"id":170488,"goal":"lemma LeRefl_489(m: real)\n ensures m <= m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_490","instance":490,"id":170489,"goal":"lemma LeTrans_490(n: int, x: int, z: int)\n requires n <= x && x <= z\n ensures n <= z\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_491","instance":491,"id":170490,"goal":"lemma AddMono_491(b: nat, a: nat, i: nat)\n requires b <= a\n ensures b + i <= a + i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_492","instance":492,"id":170491,"goal":"lemma Abs_Nonneg_492(a: real)\n ensures (if a >= 0 then a else -a) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_493","instance":493,"id":170492,"goal":"lemma DivMod_493(d: int, b: int)\n requires b > 0\n ensures d == b * (d / b) + (d % b)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_494","instance":494,"id":170493,"goal":"lemma ModBounds_494(n: nat, j: nat)\n requires j > 0\n ensures 0 <= n % j < j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_495","instance":495,"id":170494,"goal":"lemma Square_Nonneg_495(c: real)\n ensures c * c >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_496","instance":496,"id":170495,"goal":"lemma AddComm_496(m: int, a: int)\n ensures m + a == a + m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_497","instance":497,"id":170496,"goal":"lemma AddAssoc_497(m: nat, z: nat, x: nat)\n ensures (m + z) + x == m + (z + x)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_498","instance":498,"id":170497,"goal":"lemma MulComm_498(x: real, b: real)\n ensures x * b == b * x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_499","instance":499,"id":170498,"goal":"lemma MulAssoc_499(c: int, y: int, k: int)\n ensures (c * y) * k == c * (y * k)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_500","instance":500,"id":170499,"goal":"lemma Distrib_500(d: nat, j: nat, n: nat)\n ensures d * (j + n) == d * j + d * n\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_501","instance":501,"id":170500,"goal":"lemma AddZero_501(n: real)\n ensures n + 0 == n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_502","instance":502,"id":170501,"goal":"lemma MulOne_502(c: int)\n ensures c * 1 == c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_503","instance":503,"id":170502,"goal":"lemma MulZero_503(c: nat)\n ensures c * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_504","instance":504,"id":170503,"goal":"lemma LeRefl_504(i: real)\n ensures i <= i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_505","instance":505,"id":170504,"goal":"lemma LeTrans_505(b: int, x: int, i: int)\n requires b <= x && x <= i\n ensures b <= i\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_506","instance":506,"id":170505,"goal":"lemma AddMono_506(d: nat, b: nat, i: nat)\n requires d <= b\n ensures d + i <= b + i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_507","instance":507,"id":170506,"goal":"lemma Abs_Nonneg_507(m: real)\n ensures (if m >= 0 then m else -m) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_508","instance":508,"id":170507,"goal":"lemma DivMod_508(i: int, x: int)\n requires x > 0\n ensures i == x * (i / x) + (i % x)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_509","instance":509,"id":170508,"goal":"lemma ModBounds_509(c: nat, z: nat)\n requires z > 0\n ensures 0 <= c % z < z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_510","instance":510,"id":170509,"goal":"lemma Square_Nonneg_510(z: real)\n ensures z * z >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_511","instance":511,"id":170510,"goal":"lemma AddComm_511(c: int, d: int)\n ensures c + d == d + c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_512","instance":512,"id":170511,"goal":"lemma AddAssoc_512(i: nat, a: nat, z: nat)\n ensures (i + a) + z == i + (a + z)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_513","instance":513,"id":170512,"goal":"lemma MulComm_513(j: real, n: real)\n ensures j * n == n * j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_514","instance":514,"id":170513,"goal":"lemma MulAssoc_514(n: int, x: int, c: int)\n ensures (n * x) * c == n * (x * c)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_515","instance":515,"id":170514,"goal":"lemma Distrib_515(c: nat, m: nat, z: nat)\n ensures c * (m + z) == c * m + c * z\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_516","instance":516,"id":170515,"goal":"lemma AddZero_516(m: real)\n ensures m + 0 == m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_517","instance":517,"id":170516,"goal":"lemma MulOne_517(m: int)\n ensures m * 1 == m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_518","instance":518,"id":170517,"goal":"lemma MulZero_518(c: nat)\n ensures c * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_519","instance":519,"id":170518,"goal":"lemma LeRefl_519(n: real)\n ensures n <= n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_520","instance":520,"id":170519,"goal":"lemma LeTrans_520(m: int, k: int, y: int)\n requires m <= k && k <= y\n ensures m <= y\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_521","instance":521,"id":170520,"goal":"lemma AddMono_521(y: nat, d: nat, n: nat)\n requires y <= d\n ensures y + n <= d + n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_522","instance":522,"id":170521,"goal":"lemma Abs_Nonneg_522(i: real)\n ensures (if i >= 0 then i else -i) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_523","instance":523,"id":170522,"goal":"lemma DivMod_523(x: int, d: int)\n requires d > 0\n ensures x == d * (x / d) + (x % d)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_524","instance":524,"id":170523,"goal":"lemma ModBounds_524(d: nat, m: nat)\n requires m > 0\n ensures 0 <= d % m < m\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_525","instance":525,"id":170524,"goal":"lemma Square_Nonneg_525(z: real)\n ensures z * z >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_526","instance":526,"id":170525,"goal":"lemma AddComm_526(a: int, k: int)\n ensures a + k == k + a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_527","instance":527,"id":170526,"goal":"lemma AddAssoc_527(b: nat, n: nat, m: nat)\n ensures (b + n) + m == b + (n + m)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_528","instance":528,"id":170527,"goal":"lemma MulComm_528(k: real, z: real)\n ensures k * z == z * k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_529","instance":529,"id":170528,"goal":"lemma MulAssoc_529(x: int, n: int, a: int)\n ensures (x * n) * a == x * (n * a)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_530","instance":530,"id":170529,"goal":"lemma Distrib_530(n: nat, x: nat, k: nat)\n ensures n * (x + k) == n * x + n * k\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_531","instance":531,"id":170530,"goal":"lemma AddZero_531(k: real)\n ensures k + 0 == k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_532","instance":532,"id":170531,"goal":"lemma MulOne_532(c: int)\n ensures c * 1 == c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_533","instance":533,"id":170532,"goal":"lemma MulZero_533(k: nat)\n ensures k * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_534","instance":534,"id":170533,"goal":"lemma LeRefl_534(i: real)\n ensures i <= i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_535","instance":535,"id":170534,"goal":"lemma LeTrans_535(m: int, d: int, b: int)\n requires m <= d && d <= b\n ensures m <= b\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_536","instance":536,"id":170535,"goal":"lemma AddMono_536(n: nat, b: nat, i: nat)\n requires n <= b\n ensures n + i <= b + i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_537","instance":537,"id":170536,"goal":"lemma Abs_Nonneg_537(n: real)\n ensures (if n >= 0 then n else -n) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_538","instance":538,"id":170537,"goal":"lemma DivMod_538(j: int, c: int)\n requires c > 0\n ensures j == c * (j / c) + (j % c)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_539","instance":539,"id":170538,"goal":"lemma ModBounds_539(y: nat, c: nat)\n requires c > 0\n ensures 0 <= y % c < c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_540","instance":540,"id":170539,"goal":"lemma Square_Nonneg_540(b: real)\n ensures b * b >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_541","instance":541,"id":170540,"goal":"lemma AddComm_541(y: int, m: int)\n ensures y + m == m + y\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_542","instance":542,"id":170541,"goal":"lemma AddAssoc_542(x: nat, n: nat, a: nat)\n ensures (x + n) + a == x + (n + a)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_543","instance":543,"id":170542,"goal":"lemma MulComm_543(b: real, k: real)\n ensures b * k == k * b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_544","instance":544,"id":170543,"goal":"lemma MulAssoc_544(j: int, a: int, z: int)\n ensures (j * a) * z == j * (a * z)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_545","instance":545,"id":170544,"goal":"lemma Distrib_545(y: nat, x: nat, j: nat)\n ensures y * (x + j) == y * x + y * j\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_546","instance":546,"id":170545,"goal":"lemma AddZero_546(a: real)\n ensures a + 0 == a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_547","instance":547,"id":170546,"goal":"lemma MulOne_547(i: int)\n ensures i * 1 == i\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_548","instance":548,"id":170547,"goal":"lemma MulZero_548(k: nat)\n ensures k * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_549","instance":549,"id":170548,"goal":"lemma LeRefl_549(j: real)\n ensures j <= j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_550","instance":550,"id":170549,"goal":"lemma LeTrans_550(n: int, c: int, a: int)\n requires n <= c && c <= a\n ensures n <= a\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_551","instance":551,"id":170550,"goal":"lemma AddMono_551(i: nat, a: nat, m: nat)\n requires i <= a\n ensures i + m <= a + m\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_552","instance":552,"id":170551,"goal":"lemma Abs_Nonneg_552(z: real)\n ensures (if z >= 0 then z else -z) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_553","instance":553,"id":170552,"goal":"lemma DivMod_553(m: int, a: int)\n requires a > 0\n ensures m == a * (m / a) + (m % a)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_554","instance":554,"id":170553,"goal":"lemma ModBounds_554(c: nat, y: nat)\n requires y > 0\n ensures 0 <= c % y < y\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_555","instance":555,"id":170554,"goal":"lemma Square_Nonneg_555(n: real)\n ensures n * n >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_556","instance":556,"id":170555,"goal":"lemma AddComm_556(x: int, n: int)\n ensures x + n == n + x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_557","instance":557,"id":170556,"goal":"lemma AddAssoc_557(y: nat, a: nat, c: nat)\n ensures (y + a) + c == y + (a + c)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_558","instance":558,"id":170557,"goal":"lemma MulComm_558(m: real, b: real)\n ensures m * b == b * m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_559","instance":559,"id":170558,"goal":"lemma MulAssoc_559(n: int, z: int, m: int)\n ensures (n * z) * m == n * (z * m)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_560","instance":560,"id":170559,"goal":"lemma Distrib_560(c: nat, z: nat, y: nat)\n ensures c * (z + y) == c * z + c * y\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_561","instance":561,"id":170560,"goal":"lemma AddZero_561(i: real)\n ensures i + 0 == i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_562","instance":562,"id":170561,"goal":"lemma MulOne_562(a: int)\n ensures a * 1 == a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_563","instance":563,"id":170562,"goal":"lemma MulZero_563(i: nat)\n ensures i * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_564","instance":564,"id":170563,"goal":"lemma LeRefl_564(d: real)\n ensures d <= d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_565","instance":565,"id":170564,"goal":"lemma LeTrans_565(i: int, y: int, k: int)\n requires i <= y && y <= k\n ensures i <= k\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_566","instance":566,"id":170565,"goal":"lemma AddMono_566(m: nat, k: nat, b: nat)\n requires m <= k\n ensures m + b <= k + b\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_567","instance":567,"id":170566,"goal":"lemma Abs_Nonneg_567(x: real)\n ensures (if x >= 0 then x else -x) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_568","instance":568,"id":170567,"goal":"lemma DivMod_568(j: int, a: int)\n requires a > 0\n ensures j == a * (j / a) + (j % a)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_569","instance":569,"id":170568,"goal":"lemma ModBounds_569(k: nat, n: nat)\n requires n > 0\n ensures 0 <= k % n < n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_570","instance":570,"id":170569,"goal":"lemma Square_Nonneg_570(c: real)\n ensures c * c >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_571","instance":571,"id":170570,"goal":"lemma AddComm_571(x: int, a: int)\n ensures x + a == a + x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_572","instance":572,"id":170571,"goal":"lemma AddAssoc_572(k: nat, d: nat, c: nat)\n ensures (k + d) + c == k + (d + c)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_573","instance":573,"id":170572,"goal":"lemma MulComm_573(k: real, x: real)\n ensures k * x == x * k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_574","instance":574,"id":170573,"goal":"lemma MulAssoc_574(b: int, d: int, j: int)\n ensures (b * d) * j == b * (d * j)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_575","instance":575,"id":170574,"goal":"lemma Distrib_575(k: nat, z: nat, j: nat)\n ensures k * (z + j) == k * z + k * j\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_576","instance":576,"id":170575,"goal":"lemma AddZero_576(c: real)\n ensures c + 0 == c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_577","instance":577,"id":170576,"goal":"lemma MulOne_577(a: int)\n ensures a * 1 == a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_578","instance":578,"id":170577,"goal":"lemma MulZero_578(b: nat)\n ensures b * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_579","instance":579,"id":170578,"goal":"lemma LeRefl_579(i: real)\n ensures i <= i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_580","instance":580,"id":170579,"goal":"lemma LeTrans_580(n: int, c: int, b: int)\n requires n <= c && c <= b\n ensures n <= b\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_581","instance":581,"id":170580,"goal":"lemma AddMono_581(x: nat, i: nat, z: nat)\n requires x <= i\n ensures x + z <= i + z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_582","instance":582,"id":170581,"goal":"lemma Abs_Nonneg_582(m: real)\n ensures (if m >= 0 then m else -m) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_583","instance":583,"id":170582,"goal":"lemma DivMod_583(m: int, d: int)\n requires d > 0\n ensures m == d * (m / d) + (m % d)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_584","instance":584,"id":170583,"goal":"lemma ModBounds_584(x: nat, a: nat)\n requires a > 0\n ensures 0 <= x % a < a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_585","instance":585,"id":170584,"goal":"lemma Square_Nonneg_585(j: real)\n ensures j * j >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_586","instance":586,"id":170585,"goal":"lemma AddComm_586(x: int, c: int)\n ensures x + c == c + x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_587","instance":587,"id":170586,"goal":"lemma AddAssoc_587(m: nat, z: nat, k: nat)\n ensures (m + z) + k == m + (z + k)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_588","instance":588,"id":170587,"goal":"lemma MulComm_588(a: real, y: real)\n ensures a * y == y * a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_589","instance":589,"id":170588,"goal":"lemma MulAssoc_589(i: int, n: int, m: int)\n ensures (i * n) * m == i * (n * m)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_590","instance":590,"id":170589,"goal":"lemma Distrib_590(z: nat, i: nat, m: nat)\n ensures z * (i + m) == z * i + z * m\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_591","instance":591,"id":170590,"goal":"lemma AddZero_591(y: real)\n ensures y + 0 == y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_592","instance":592,"id":170591,"goal":"lemma MulOne_592(a: int)\n ensures a * 1 == a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_593","instance":593,"id":170592,"goal":"lemma MulZero_593(m: nat)\n ensures m * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_594","instance":594,"id":170593,"goal":"lemma LeRefl_594(y: real)\n ensures y <= y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_595","instance":595,"id":170594,"goal":"lemma LeTrans_595(a: int, y: int, i: int)\n requires a <= y && y <= i\n ensures a <= i\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_596","instance":596,"id":170595,"goal":"lemma AddMono_596(b: nat, k: nat, m: nat)\n requires b <= k\n ensures b + m <= k + m\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_597","instance":597,"id":170596,"goal":"lemma Abs_Nonneg_597(i: real)\n ensures (if i >= 0 then i else -i) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_598","instance":598,"id":170597,"goal":"lemma DivMod_598(x: int, b: int)\n requires b > 0\n ensures x == b * (x / b) + (x % b)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_599","instance":599,"id":170598,"goal":"lemma ModBounds_599(n: nat, b: nat)\n requires b > 0\n ensures 0 <= n % b < b\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_600","instance":600,"id":170599,"goal":"lemma Square_Nonneg_600(c: real)\n ensures c * c >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_601","instance":601,"id":170600,"goal":"lemma AddComm_601(a: int, m: int)\n ensures a + m == m + a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_602","instance":602,"id":170601,"goal":"lemma AddAssoc_602(n: nat, i: nat, m: nat)\n ensures (n + i) + m == n + (i + m)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_603","instance":603,"id":170602,"goal":"lemma MulComm_603(y: real, c: real)\n ensures y * c == c * y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_604","instance":604,"id":170603,"goal":"lemma MulAssoc_604(y: int, d: int, b: int)\n ensures (y * d) * b == y * (d * b)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_605","instance":605,"id":170604,"goal":"lemma Distrib_605(x: nat, y: nat, c: nat)\n ensures x * (y + c) == x * y + x * c\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_606","instance":606,"id":170605,"goal":"lemma AddZero_606(i: real)\n ensures i + 0 == i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_607","instance":607,"id":170606,"goal":"lemma MulOne_607(i: int)\n ensures i * 1 == i\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_608","instance":608,"id":170607,"goal":"lemma MulZero_608(y: nat)\n ensures y * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_609","instance":609,"id":170608,"goal":"lemma LeRefl_609(d: real)\n ensures d <= d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_610","instance":610,"id":170609,"goal":"lemma LeTrans_610(i: int, n: int, x: int)\n requires i <= n && n <= x\n ensures i <= x\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_611","instance":611,"id":170610,"goal":"lemma AddMono_611(j: nat, z: nat, x: nat)\n requires j <= z\n ensures j + x <= z + x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_612","instance":612,"id":170611,"goal":"lemma Abs_Nonneg_612(k: real)\n ensures (if k >= 0 then k else -k) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_613","instance":613,"id":170612,"goal":"lemma DivMod_613(x: int, n: int)\n requires n > 0\n ensures x == n * (x / n) + (x % n)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_614","instance":614,"id":170613,"goal":"lemma ModBounds_614(a: nat, k: nat)\n requires k > 0\n ensures 0 <= a % k < k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_615","instance":615,"id":170614,"goal":"lemma Square_Nonneg_615(x: real)\n ensures x * x >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_616","instance":616,"id":170615,"goal":"lemma AddComm_616(y: int, a: int)\n ensures y + a == a + y\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_617","instance":617,"id":170616,"goal":"lemma AddAssoc_617(d: nat, i: nat, m: nat)\n ensures (d + i) + m == d + (i + m)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_618","instance":618,"id":170617,"goal":"lemma MulComm_618(y: real, x: real)\n ensures y * x == x * y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_619","instance":619,"id":170618,"goal":"lemma MulAssoc_619(z: int, c: int, b: int)\n ensures (z * c) * b == z * (c * b)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_620","instance":620,"id":170619,"goal":"lemma Distrib_620(a: nat, b: nat, n: nat)\n ensures a * (b + n) == a * b + a * n\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_621","instance":621,"id":170620,"goal":"lemma AddZero_621(i: real)\n ensures i + 0 == i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_622","instance":622,"id":170621,"goal":"lemma MulOne_622(x: int)\n ensures x * 1 == x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_623","instance":623,"id":170622,"goal":"lemma MulZero_623(a: nat)\n ensures a * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_624","instance":624,"id":170623,"goal":"lemma LeRefl_624(k: real)\n ensures k <= k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_625","instance":625,"id":170624,"goal":"lemma LeTrans_625(z: int, a: int, k: int)\n requires z <= a && a <= k\n ensures z <= k\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_626","instance":626,"id":170625,"goal":"lemma AddMono_626(b: nat, m: nat, y: nat)\n requires b <= m\n ensures b + y <= m + y\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_627","instance":627,"id":170626,"goal":"lemma Abs_Nonneg_627(n: real)\n ensures (if n >= 0 then n else -n) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_628","instance":628,"id":170627,"goal":"lemma DivMod_628(y: int, c: int)\n requires c > 0\n ensures y == c * (y / c) + (y % c)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_629","instance":629,"id":170628,"goal":"lemma ModBounds_629(i: nat, n: nat)\n requires n > 0\n ensures 0 <= i % n < n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_630","instance":630,"id":170629,"goal":"lemma Square_Nonneg_630(c: real)\n ensures c * c >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_631","instance":631,"id":170630,"goal":"lemma AddComm_631(d: int, n: int)\n ensures d + n == n + d\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_632","instance":632,"id":170631,"goal":"lemma AddAssoc_632(k: nat, a: nat, y: nat)\n ensures (k + a) + y == k + (a + y)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_633","instance":633,"id":170632,"goal":"lemma MulComm_633(z: real, b: real)\n ensures z * b == b * z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_634","instance":634,"id":170633,"goal":"lemma MulAssoc_634(a: int, i: int, m: int)\n ensures (a * i) * m == a * (i * m)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_635","instance":635,"id":170634,"goal":"lemma Distrib_635(k: nat, b: nat, j: nat)\n ensures k * (b + j) == k * b + k * j\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_636","instance":636,"id":170635,"goal":"lemma AddZero_636(n: real)\n ensures n + 0 == n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_637","instance":637,"id":170636,"goal":"lemma MulOne_637(a: int)\n ensures a * 1 == a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_638","instance":638,"id":170637,"goal":"lemma MulZero_638(y: nat)\n ensures y * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_639","instance":639,"id":170638,"goal":"lemma LeRefl_639(y: real)\n ensures y <= y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_640","instance":640,"id":170639,"goal":"lemma LeTrans_640(c: int, z: int, m: int)\n requires c <= z && z <= m\n ensures c <= m\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_641","instance":641,"id":170640,"goal":"lemma AddMono_641(a: nat, d: nat, j: nat)\n requires a <= d\n ensures a + j <= d + j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_642","instance":642,"id":170641,"goal":"lemma Abs_Nonneg_642(j: real)\n ensures (if j >= 0 then j else -j) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_643","instance":643,"id":170642,"goal":"lemma DivMod_643(x: int, d: int)\n requires d > 0\n ensures x == d * (x / d) + (x % d)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_644","instance":644,"id":170643,"goal":"lemma ModBounds_644(c: nat, i: nat)\n requires i > 0\n ensures 0 <= c % i < i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_645","instance":645,"id":170644,"goal":"lemma Square_Nonneg_645(k: real)\n ensures k * k >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_646","instance":646,"id":170645,"goal":"lemma AddComm_646(x: int, i: int)\n ensures x + i == i + x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_647","instance":647,"id":170646,"goal":"lemma AddAssoc_647(d: nat, c: nat, n: nat)\n ensures (d + c) + n == d + (c + n)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_648","instance":648,"id":170647,"goal":"lemma MulComm_648(m: real, c: real)\n ensures m * c == c * m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_649","instance":649,"id":170648,"goal":"lemma MulAssoc_649(i: int, n: int, z: int)\n ensures (i * n) * z == i * (n * z)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_650","instance":650,"id":170649,"goal":"lemma Distrib_650(k: nat, m: nat, i: nat)\n ensures k * (m + i) == k * m + k * i\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_651","instance":651,"id":170650,"goal":"lemma AddZero_651(c: real)\n ensures c + 0 == c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_652","instance":652,"id":170651,"goal":"lemma MulOne_652(y: int)\n ensures y * 1 == y\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_653","instance":653,"id":170652,"goal":"lemma MulZero_653(i: nat)\n ensures i * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_654","instance":654,"id":170653,"goal":"lemma LeRefl_654(n: real)\n ensures n <= n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_655","instance":655,"id":170654,"goal":"lemma LeTrans_655(j: int, i: int, x: int)\n requires j <= i && i <= x\n ensures j <= x\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_656","instance":656,"id":170655,"goal":"lemma AddMono_656(b: nat, i: nat, d: nat)\n requires b <= i\n ensures b + d <= i + d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_657","instance":657,"id":170656,"goal":"lemma Abs_Nonneg_657(d: real)\n ensures (if d >= 0 then d else -d) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_658","instance":658,"id":170657,"goal":"lemma DivMod_658(a: int, b: int)\n requires b > 0\n ensures a == b * (a / b) + (a % b)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_659","instance":659,"id":170658,"goal":"lemma ModBounds_659(b: nat, y: nat)\n requires y > 0\n ensures 0 <= b % y < y\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_660","instance":660,"id":170659,"goal":"lemma Square_Nonneg_660(j: real)\n ensures j * j >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_661","instance":661,"id":170660,"goal":"lemma AddComm_661(y: int, d: int)\n ensures y + d == d + y\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_662","instance":662,"id":170661,"goal":"lemma AddAssoc_662(a: nat, b: nat, j: nat)\n ensures (a + b) + j == a + (b + j)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_663","instance":663,"id":170662,"goal":"lemma MulComm_663(m: real, z: real)\n ensures m * z == z * m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_664","instance":664,"id":170663,"goal":"lemma MulAssoc_664(b: int, j: int, y: int)\n ensures (b * j) * y == b * (j * y)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_665","instance":665,"id":170664,"goal":"lemma Distrib_665(j: nat, x: nat, z: nat)\n ensures j * (x + z) == j * x + j * z\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_666","instance":666,"id":170665,"goal":"lemma AddZero_666(k: real)\n ensures k + 0 == k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_667","instance":667,"id":170666,"goal":"lemma MulOne_667(b: int)\n ensures b * 1 == b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_668","instance":668,"id":170667,"goal":"lemma MulZero_668(n: nat)\n ensures n * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_669","instance":669,"id":170668,"goal":"lemma LeRefl_669(i: real)\n ensures i <= i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_670","instance":670,"id":170669,"goal":"lemma LeTrans_670(c: int, a: int, z: int)\n requires c <= a && a <= z\n ensures c <= z\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_671","instance":671,"id":170670,"goal":"lemma AddMono_671(n: nat, j: nat, a: nat)\n requires n <= j\n ensures n + a <= j + a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_672","instance":672,"id":170671,"goal":"lemma Abs_Nonneg_672(d: real)\n ensures (if d >= 0 then d else -d) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_673","instance":673,"id":170672,"goal":"lemma DivMod_673(i: int, z: int)\n requires z > 0\n ensures i == z * (i / z) + (i % z)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_674","instance":674,"id":170673,"goal":"lemma ModBounds_674(z: nat, i: nat)\n requires i > 0\n ensures 0 <= z % i < i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_675","instance":675,"id":170674,"goal":"lemma Square_Nonneg_675(d: real)\n ensures d * d >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_676","instance":676,"id":170675,"goal":"lemma AddComm_676(a: int, d: int)\n ensures a + d == d + a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_677","instance":677,"id":170676,"goal":"lemma AddAssoc_677(n: nat, d: nat, z: nat)\n ensures (n + d) + z == n + (d + z)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_678","instance":678,"id":170677,"goal":"lemma MulComm_678(b: real, k: real)\n ensures b * k == k * b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_679","instance":679,"id":170678,"goal":"lemma MulAssoc_679(a: int, b: int, n: int)\n ensures (a * b) * n == a * (b * n)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_680","instance":680,"id":170679,"goal":"lemma Distrib_680(i: nat, d: nat, m: nat)\n ensures i * (d + m) == i * d + i * m\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_681","instance":681,"id":170680,"goal":"lemma AddZero_681(c: real)\n ensures c + 0 == c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_682","instance":682,"id":170681,"goal":"lemma MulOne_682(b: int)\n ensures b * 1 == b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_683","instance":683,"id":170682,"goal":"lemma MulZero_683(x: nat)\n ensures x * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_684","instance":684,"id":170683,"goal":"lemma LeRefl_684(a: real)\n ensures a <= a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_685","instance":685,"id":170684,"goal":"lemma LeTrans_685(j: int, d: int, i: int)\n requires j <= d && d <= i\n ensures j <= i\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_686","instance":686,"id":170685,"goal":"lemma AddMono_686(y: nat, b: nat, c: nat)\n requires y <= b\n ensures y + c <= b + c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_687","instance":687,"id":170686,"goal":"lemma Abs_Nonneg_687(d: real)\n ensures (if d >= 0 then d else -d) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_688","instance":688,"id":170687,"goal":"lemma DivMod_688(a: int, j: int)\n requires j > 0\n ensures a == j * (a / j) + (a % j)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_689","instance":689,"id":170688,"goal":"lemma ModBounds_689(b: nat, c: nat)\n requires c > 0\n ensures 0 <= b % c < c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_690","instance":690,"id":170689,"goal":"lemma Square_Nonneg_690(z: real)\n ensures z * z >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_691","instance":691,"id":170690,"goal":"lemma AddComm_691(i: int, c: int)\n ensures i + c == c + i\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_692","instance":692,"id":170691,"goal":"lemma AddAssoc_692(a: nat, m: nat, j: nat)\n ensures (a + m) + j == a + (m + j)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_693","instance":693,"id":170692,"goal":"lemma MulComm_693(k: real, y: real)\n ensures k * y == y * k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_694","instance":694,"id":170693,"goal":"lemma MulAssoc_694(a: int, z: int, y: int)\n ensures (a * z) * y == a * (z * y)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_695","instance":695,"id":170694,"goal":"lemma Distrib_695(y: nat, m: nat, i: nat)\n ensures y * (m + i) == y * m + y * i\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_696","instance":696,"id":170695,"goal":"lemma AddZero_696(a: real)\n ensures a + 0 == a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_697","instance":697,"id":170696,"goal":"lemma MulOne_697(y: int)\n ensures y * 1 == y\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_698","instance":698,"id":170697,"goal":"lemma MulZero_698(c: nat)\n ensures c * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_699","instance":699,"id":170698,"goal":"lemma LeRefl_699(i: real)\n ensures i <= i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_700","instance":700,"id":170699,"goal":"lemma LeTrans_700(a: int, k: int, c: int)\n requires a <= k && k <= c\n ensures a <= c\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_701","instance":701,"id":170700,"goal":"lemma AddMono_701(n: nat, m: nat, z: nat)\n requires n <= m\n ensures n + z <= m + z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_702","instance":702,"id":170701,"goal":"lemma Abs_Nonneg_702(y: real)\n ensures (if y >= 0 then y else -y) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_703","instance":703,"id":170702,"goal":"lemma DivMod_703(y: int, m: int)\n requires m > 0\n ensures y == m * (y / m) + (y % m)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_704","instance":704,"id":170703,"goal":"lemma ModBounds_704(m: nat, y: nat)\n requires y > 0\n ensures 0 <= m % y < y\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_705","instance":705,"id":170704,"goal":"lemma Square_Nonneg_705(z: real)\n ensures z * z >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_706","instance":706,"id":170705,"goal":"lemma AddComm_706(a: int, d: int)\n ensures a + d == d + a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_707","instance":707,"id":170706,"goal":"lemma AddAssoc_707(b: nat, m: nat, x: nat)\n ensures (b + m) + x == b + (m + x)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_708","instance":708,"id":170707,"goal":"lemma MulComm_708(d: real, b: real)\n ensures d * b == b * d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_709","instance":709,"id":170708,"goal":"lemma MulAssoc_709(k: int, x: int, n: int)\n ensures (k * x) * n == k * (x * n)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_710","instance":710,"id":170709,"goal":"lemma Distrib_710(a: nat, k: nat, i: nat)\n ensures a * (k + i) == a * k + a * i\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_711","instance":711,"id":170710,"goal":"lemma AddZero_711(j: real)\n ensures j + 0 == j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_712","instance":712,"id":170711,"goal":"lemma MulOne_712(z: int)\n ensures z * 1 == z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_713","instance":713,"id":170712,"goal":"lemma MulZero_713(m: nat)\n ensures m * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_714","instance":714,"id":170713,"goal":"lemma LeRefl_714(a: real)\n ensures a <= a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_715","instance":715,"id":170714,"goal":"lemma LeTrans_715(i: int, n: int, x: int)\n requires i <= n && n <= x\n ensures i <= x\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_716","instance":716,"id":170715,"goal":"lemma AddMono_716(d: nat, b: nat, z: nat)\n requires d <= b\n ensures d + z <= b + z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_717","instance":717,"id":170716,"goal":"lemma Abs_Nonneg_717(d: real)\n ensures (if d >= 0 then d else -d) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_718","instance":718,"id":170717,"goal":"lemma DivMod_718(n: int, m: int)\n requires m > 0\n ensures n == m * (n / m) + (n % m)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_719","instance":719,"id":170718,"goal":"lemma ModBounds_719(n: nat, c: nat)\n requires c > 0\n ensures 0 <= n % c < c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_720","instance":720,"id":170719,"goal":"lemma Square_Nonneg_720(i: real)\n ensures i * i >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_721","instance":721,"id":170720,"goal":"lemma AddComm_721(n: int, y: int)\n ensures n + y == y + n\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_722","instance":722,"id":170721,"goal":"lemma AddAssoc_722(b: nat, c: nat, d: nat)\n ensures (b + c) + d == b + (c + d)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_723","instance":723,"id":170722,"goal":"lemma MulComm_723(b: real, i: real)\n ensures b * i == i * b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_724","instance":724,"id":170723,"goal":"lemma MulAssoc_724(a: int, y: int, i: int)\n ensures (a * y) * i == a * (y * i)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_725","instance":725,"id":170724,"goal":"lemma Distrib_725(a: nat, j: nat, y: nat)\n ensures a * (j + y) == a * j + a * y\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_726","instance":726,"id":170725,"goal":"lemma AddZero_726(m: real)\n ensures m + 0 == m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_727","instance":727,"id":170726,"goal":"lemma MulOne_727(n: int)\n ensures n * 1 == n\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_728","instance":728,"id":170727,"goal":"lemma MulZero_728(d: nat)\n ensures d * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_729","instance":729,"id":170728,"goal":"lemma LeRefl_729(m: real)\n ensures m <= m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_730","instance":730,"id":170729,"goal":"lemma LeTrans_730(n: int, x: int, d: int)\n requires n <= x && x <= d\n ensures n <= d\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_731","instance":731,"id":170730,"goal":"lemma AddMono_731(c: nat, x: nat, z: nat)\n requires c <= x\n ensures c + z <= x + z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_732","instance":732,"id":170731,"goal":"lemma Abs_Nonneg_732(j: real)\n ensures (if j >= 0 then j else -j) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_733","instance":733,"id":170732,"goal":"lemma DivMod_733(m: int, b: int)\n requires b > 0\n ensures m == b * (m / b) + (m % b)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_734","instance":734,"id":170733,"goal":"lemma ModBounds_734(z: nat, y: nat)\n requires y > 0\n ensures 0 <= z % y < y\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_735","instance":735,"id":170734,"goal":"lemma Square_Nonneg_735(x: real)\n ensures x * x >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_736","instance":736,"id":170735,"goal":"lemma AddComm_736(d: int, m: int)\n ensures d + m == m + d\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_737","instance":737,"id":170736,"goal":"lemma AddAssoc_737(j: nat, y: nat, a: nat)\n ensures (j + y) + a == j + (y + a)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_738","instance":738,"id":170737,"goal":"lemma MulComm_738(n: real, a: real)\n ensures n * a == a * n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_739","instance":739,"id":170738,"goal":"lemma MulAssoc_739(d: int, m: int, c: int)\n ensures (d * m) * c == d * (m * c)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_740","instance":740,"id":170739,"goal":"lemma Distrib_740(n: nat, c: nat, a: nat)\n ensures n * (c + a) == n * c + n * a\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_741","instance":741,"id":170740,"goal":"lemma AddZero_741(m: real)\n ensures m + 0 == m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_742","instance":742,"id":170741,"goal":"lemma MulOne_742(n: int)\n ensures n * 1 == n\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_743","instance":743,"id":170742,"goal":"lemma MulZero_743(c: nat)\n ensures c * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_744","instance":744,"id":170743,"goal":"lemma LeRefl_744(m: real)\n ensures m <= m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_745","instance":745,"id":170744,"goal":"lemma LeTrans_745(k: int, z: int, b: int)\n requires k <= z && z <= b\n ensures k <= b\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_746","instance":746,"id":170745,"goal":"lemma AddMono_746(d: nat, z: nat, k: nat)\n requires d <= z\n ensures d + k <= z + k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_747","instance":747,"id":170746,"goal":"lemma Abs_Nonneg_747(d: real)\n ensures (if d >= 0 then d else -d) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_748","instance":748,"id":170747,"goal":"lemma DivMod_748(k: int, a: int)\n requires a > 0\n ensures k == a * (k / a) + (k % a)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_749","instance":749,"id":170748,"goal":"lemma ModBounds_749(x: nat, y: nat)\n requires y > 0\n ensures 0 <= x % y < y\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_750","instance":750,"id":170749,"goal":"lemma Square_Nonneg_750(i: real)\n ensures i * i >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_751","instance":751,"id":170750,"goal":"lemma AddComm_751(a: int, i: int)\n ensures a + i == i + a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_752","instance":752,"id":170751,"goal":"lemma AddAssoc_752(i: nat, y: nat, n: nat)\n ensures (i + y) + n == i + (y + n)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_753","instance":753,"id":170752,"goal":"lemma MulComm_753(z: real, d: real)\n ensures z * d == d * z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_754","instance":754,"id":170753,"goal":"lemma MulAssoc_754(b: int, n: int, j: int)\n ensures (b * n) * j == b * (n * j)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_755","instance":755,"id":170754,"goal":"lemma Distrib_755(j: nat, i: nat, x: nat)\n ensures j * (i + x) == j * i + j * x\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_756","instance":756,"id":170755,"goal":"lemma AddZero_756(d: real)\n ensures d + 0 == d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_757","instance":757,"id":170756,"goal":"lemma MulOne_757(x: int)\n ensures x * 1 == x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_758","instance":758,"id":170757,"goal":"lemma MulZero_758(x: nat)\n ensures x * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_759","instance":759,"id":170758,"goal":"lemma LeRefl_759(d: real)\n ensures d <= d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_760","instance":760,"id":170759,"goal":"lemma LeTrans_760(m: int, x: int, j: int)\n requires m <= x && x <= j\n ensures m <= j\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_761","instance":761,"id":170760,"goal":"lemma AddMono_761(i: nat, d: nat, a: nat)\n requires i <= d\n ensures i + a <= d + a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_762","instance":762,"id":170761,"goal":"lemma Abs_Nonneg_762(m: real)\n ensures (if m >= 0 then m else -m) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_763","instance":763,"id":170762,"goal":"lemma DivMod_763(b: int, a: int)\n requires a > 0\n ensures b == a * (b / a) + (b % a)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_764","instance":764,"id":170763,"goal":"lemma ModBounds_764(n: nat, d: nat)\n requires d > 0\n ensures 0 <= n % d < d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_765","instance":765,"id":170764,"goal":"lemma Square_Nonneg_765(c: real)\n ensures c * c >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_766","instance":766,"id":170765,"goal":"lemma AddComm_766(b: int, d: int)\n ensures b + d == d + b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_767","instance":767,"id":170766,"goal":"lemma AddAssoc_767(j: nat, b: nat, n: nat)\n ensures (j + b) + n == j + (b + n)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_768","instance":768,"id":170767,"goal":"lemma MulComm_768(y: real, m: real)\n ensures y * m == m * y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_769","instance":769,"id":170768,"goal":"lemma MulAssoc_769(i: int, d: int, k: int)\n ensures (i * d) * k == i * (d * k)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_770","instance":770,"id":170769,"goal":"lemma Distrib_770(m: nat, k: nat, d: nat)\n ensures m * (k + d) == m * k + m * d\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_771","instance":771,"id":170770,"goal":"lemma AddZero_771(c: real)\n ensures c + 0 == c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_772","instance":772,"id":170771,"goal":"lemma MulOne_772(j: int)\n ensures j * 1 == j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_773","instance":773,"id":170772,"goal":"lemma MulZero_773(a: nat)\n ensures a * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_774","instance":774,"id":170773,"goal":"lemma LeRefl_774(x: real)\n ensures x <= x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_775","instance":775,"id":170774,"goal":"lemma LeTrans_775(n: int, d: int, z: int)\n requires n <= d && d <= z\n ensures n <= z\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_776","instance":776,"id":170775,"goal":"lemma AddMono_776(d: nat, a: nat, i: nat)\n requires d <= a\n ensures d + i <= a + i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_777","instance":777,"id":170776,"goal":"lemma Abs_Nonneg_777(n: real)\n ensures (if n >= 0 then n else -n) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_778","instance":778,"id":170777,"goal":"lemma DivMod_778(i: int, c: int)\n requires c > 0\n ensures i == c * (i / c) + (i % c)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_779","instance":779,"id":170778,"goal":"lemma ModBounds_779(c: nat, k: nat)\n requires k > 0\n ensures 0 <= c % k < k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_780","instance":780,"id":170779,"goal":"lemma Square_Nonneg_780(y: real)\n ensures y * y >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_781","instance":781,"id":170780,"goal":"lemma AddComm_781(b: int, d: int)\n ensures b + d == d + b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_782","instance":782,"id":170781,"goal":"lemma AddAssoc_782(b: nat, c: nat, x: nat)\n ensures (b + c) + x == b + (c + x)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_783","instance":783,"id":170782,"goal":"lemma MulComm_783(y: real, d: real)\n ensures y * d == d * y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_784","instance":784,"id":170783,"goal":"lemma MulAssoc_784(z: int, m: int, i: int)\n ensures (z * m) * i == z * (m * i)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_785","instance":785,"id":170784,"goal":"lemma Distrib_785(x: nat, z: nat, y: nat)\n ensures x * (z + y) == x * z + x * y\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_786","instance":786,"id":170785,"goal":"lemma AddZero_786(d: real)\n ensures d + 0 == d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_787","instance":787,"id":170786,"goal":"lemma MulOne_787(c: int)\n ensures c * 1 == c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_788","instance":788,"id":170787,"goal":"lemma MulZero_788(a: nat)\n ensures a * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_789","instance":789,"id":170788,"goal":"lemma LeRefl_789(y: real)\n ensures y <= y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_790","instance":790,"id":170789,"goal":"lemma LeTrans_790(m: int, n: int, i: int)\n requires m <= n && n <= i\n ensures m <= i\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_791","instance":791,"id":170790,"goal":"lemma AddMono_791(x: nat, j: nat, k: nat)\n requires x <= j\n ensures x + k <= j + k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_792","instance":792,"id":170791,"goal":"lemma Abs_Nonneg_792(i: real)\n ensures (if i >= 0 then i else -i) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_793","instance":793,"id":170792,"goal":"lemma DivMod_793(y: int, n: int)\n requires n > 0\n ensures y == n * (y / n) + (y % n)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_794","instance":794,"id":170793,"goal":"lemma ModBounds_794(n: nat, b: nat)\n requires b > 0\n ensures 0 <= n % b < b\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_795","instance":795,"id":170794,"goal":"lemma Square_Nonneg_795(k: real)\n ensures k * k >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_796","instance":796,"id":170795,"goal":"lemma AddComm_796(c: int, i: int)\n ensures c + i == i + c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_797","instance":797,"id":170796,"goal":"lemma AddAssoc_797(m: nat, d: nat, i: nat)\n ensures (m + d) + i == m + (d + i)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_798","instance":798,"id":170797,"goal":"lemma MulComm_798(m: real, i: real)\n ensures m * i == i * m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_799","instance":799,"id":170798,"goal":"lemma MulAssoc_799(n: int, a: int, j: int)\n ensures (n * a) * j == n * (a * j)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_800","instance":800,"id":170799,"goal":"lemma Distrib_800(k: nat, n: nat, j: nat)\n ensures k * (n + j) == k * n + k * j\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_801","instance":801,"id":170800,"goal":"lemma AddZero_801(y: real)\n ensures y + 0 == y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_802","instance":802,"id":170801,"goal":"lemma MulOne_802(a: int)\n ensures a * 1 == a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_803","instance":803,"id":170802,"goal":"lemma MulZero_803(z: nat)\n ensures z * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_804","instance":804,"id":170803,"goal":"lemma LeRefl_804(x: real)\n ensures x <= x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_805","instance":805,"id":170804,"goal":"lemma LeTrans_805(n: int, x: int, d: int)\n requires n <= x && x <= d\n ensures n <= d\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_806","instance":806,"id":170805,"goal":"lemma AddMono_806(c: nat, k: nat, a: nat)\n requires c <= k\n ensures c + a <= k + a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_807","instance":807,"id":170806,"goal":"lemma Abs_Nonneg_807(m: real)\n ensures (if m >= 0 then m else -m) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_808","instance":808,"id":170807,"goal":"lemma DivMod_808(c: int, m: int)\n requires m > 0\n ensures c == m * (c / m) + (c % m)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_809","instance":809,"id":170808,"goal":"lemma ModBounds_809(z: nat, a: nat)\n requires a > 0\n ensures 0 <= z % a < a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_810","instance":810,"id":170809,"goal":"lemma Square_Nonneg_810(d: real)\n ensures d * d >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_811","instance":811,"id":170810,"goal":"lemma AddComm_811(n: int, d: int)\n ensures n + d == d + n\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_812","instance":812,"id":170811,"goal":"lemma AddAssoc_812(i: nat, b: nat, n: nat)\n ensures (i + b) + n == i + (b + n)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_813","instance":813,"id":170812,"goal":"lemma MulComm_813(j: real, d: real)\n ensures j * d == d * j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_814","instance":814,"id":170813,"goal":"lemma MulAssoc_814(m: int, z: int, y: int)\n ensures (m * z) * y == m * (z * y)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_815","instance":815,"id":170814,"goal":"lemma Distrib_815(a: nat, d: nat, j: nat)\n ensures a * (d + j) == a * d + a * j\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_816","instance":816,"id":170815,"goal":"lemma AddZero_816(j: real)\n ensures j + 0 == j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_817","instance":817,"id":170816,"goal":"lemma MulOne_817(n: int)\n ensures n * 1 == n\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_818","instance":818,"id":170817,"goal":"lemma MulZero_818(b: nat)\n ensures b * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_819","instance":819,"id":170818,"goal":"lemma LeRefl_819(y: real)\n ensures y <= y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_820","instance":820,"id":170819,"goal":"lemma LeTrans_820(n: int, i: int, m: int)\n requires n <= i && i <= m\n ensures n <= m\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_821","instance":821,"id":170820,"goal":"lemma AddMono_821(m: nat, b: nat, d: nat)\n requires m <= b\n ensures m + d <= b + d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_822","instance":822,"id":170821,"goal":"lemma Abs_Nonneg_822(c: real)\n ensures (if c >= 0 then c else -c) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_823","instance":823,"id":170822,"goal":"lemma DivMod_823(n: int, y: int)\n requires y > 0\n ensures n == y * (n / y) + (n % y)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_824","instance":824,"id":170823,"goal":"lemma ModBounds_824(x: nat, c: nat)\n requires c > 0\n ensures 0 <= x % c < c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_825","instance":825,"id":170824,"goal":"lemma Square_Nonneg_825(n: real)\n ensures n * n >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_826","instance":826,"id":170825,"goal":"lemma AddComm_826(j: int, x: int)\n ensures j + x == x + j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_827","instance":827,"id":170826,"goal":"lemma AddAssoc_827(k: nat, n: nat, j: nat)\n ensures (k + n) + j == k + (n + j)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_828","instance":828,"id":170827,"goal":"lemma MulComm_828(c: real, m: real)\n ensures c * m == m * c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_829","instance":829,"id":170828,"goal":"lemma MulAssoc_829(c: int, d: int, n: int)\n ensures (c * d) * n == c * (d * n)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_830","instance":830,"id":170829,"goal":"lemma Distrib_830(m: nat, z: nat, b: nat)\n ensures m * (z + b) == m * z + m * b\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_831","instance":831,"id":170830,"goal":"lemma AddZero_831(z: real)\n ensures z + 0 == z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_832","instance":832,"id":170831,"goal":"lemma MulOne_832(b: int)\n ensures b * 1 == b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_833","instance":833,"id":170832,"goal":"lemma MulZero_833(b: nat)\n ensures b * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_834","instance":834,"id":170833,"goal":"lemma LeRefl_834(d: real)\n ensures d <= d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_835","instance":835,"id":170834,"goal":"lemma LeTrans_835(j: int, c: int, d: int)\n requires j <= c && c <= d\n ensures j <= d\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_836","instance":836,"id":170835,"goal":"lemma AddMono_836(n: nat, z: nat, c: nat)\n requires n <= z\n ensures n + c <= z + c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_837","instance":837,"id":170836,"goal":"lemma Abs_Nonneg_837(z: real)\n ensures (if z >= 0 then z else -z) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_838","instance":838,"id":170837,"goal":"lemma DivMod_838(j: int, y: int)\n requires y > 0\n ensures j == y * (j / y) + (j % y)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_839","instance":839,"id":170838,"goal":"lemma ModBounds_839(c: nat, b: nat)\n requires b > 0\n ensures 0 <= c % b < b\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_840","instance":840,"id":170839,"goal":"lemma Square_Nonneg_840(i: real)\n ensures i * i >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_841","instance":841,"id":170840,"goal":"lemma AddComm_841(x: int, n: int)\n ensures x + n == n + x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_842","instance":842,"id":170841,"goal":"lemma AddAssoc_842(b: nat, m: nat, i: nat)\n ensures (b + m) + i == b + (m + i)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_843","instance":843,"id":170842,"goal":"lemma MulComm_843(i: real, x: real)\n ensures i * x == x * i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_844","instance":844,"id":170843,"goal":"lemma MulAssoc_844(k: int, y: int, z: int)\n ensures (k * y) * z == k * (y * z)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_845","instance":845,"id":170844,"goal":"lemma Distrib_845(d: nat, y: nat, k: nat)\n ensures d * (y + k) == d * y + d * k\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_846","instance":846,"id":170845,"goal":"lemma AddZero_846(n: real)\n ensures n + 0 == n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_847","instance":847,"id":170846,"goal":"lemma MulOne_847(m: int)\n ensures m * 1 == m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_848","instance":848,"id":170847,"goal":"lemma MulZero_848(c: nat)\n ensures c * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_849","instance":849,"id":170848,"goal":"lemma LeRefl_849(i: real)\n ensures i <= i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_850","instance":850,"id":170849,"goal":"lemma LeTrans_850(z: int, a: int, i: int)\n requires z <= a && a <= i\n ensures z <= i\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_851","instance":851,"id":170850,"goal":"lemma AddMono_851(i: nat, z: nat, d: nat)\n requires i <= z\n ensures i + d <= z + d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_852","instance":852,"id":170851,"goal":"lemma Abs_Nonneg_852(b: real)\n ensures (if b >= 0 then b else -b) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_853","instance":853,"id":170852,"goal":"lemma DivMod_853(a: int, c: int)\n requires c > 0\n ensures a == c * (a / c) + (a % c)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_854","instance":854,"id":170853,"goal":"lemma ModBounds_854(a: nat, z: nat)\n requires z > 0\n ensures 0 <= a % z < z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_855","instance":855,"id":170854,"goal":"lemma Square_Nonneg_855(b: real)\n ensures b * b >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_856","instance":856,"id":170855,"goal":"lemma AddComm_856(m: int, c: int)\n ensures m + c == c + m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_857","instance":857,"id":170856,"goal":"lemma AddAssoc_857(x: nat, y: nat, b: nat)\n ensures (x + y) + b == x + (y + b)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_858","instance":858,"id":170857,"goal":"lemma MulComm_858(d: real, k: real)\n ensures d * k == k * d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_859","instance":859,"id":170858,"goal":"lemma MulAssoc_859(y: int, j: int, i: int)\n ensures (y * j) * i == y * (j * i)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_860","instance":860,"id":170859,"goal":"lemma Distrib_860(y: nat, j: nat, m: nat)\n ensures y * (j + m) == y * j + y * m\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_861","instance":861,"id":170860,"goal":"lemma AddZero_861(k: real)\n ensures k + 0 == k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_862","instance":862,"id":170861,"goal":"lemma MulOne_862(j: int)\n ensures j * 1 == j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_863","instance":863,"id":170862,"goal":"lemma MulZero_863(n: nat)\n ensures n * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_864","instance":864,"id":170863,"goal":"lemma LeRefl_864(a: real)\n ensures a <= a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_865","instance":865,"id":170864,"goal":"lemma LeTrans_865(k: int, m: int, c: int)\n requires k <= m && m <= c\n ensures k <= c\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_866","instance":866,"id":170865,"goal":"lemma AddMono_866(y: nat, a: nat, z: nat)\n requires y <= a\n ensures y + z <= a + z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_867","instance":867,"id":170866,"goal":"lemma Abs_Nonneg_867(a: real)\n ensures (if a >= 0 then a else -a) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_868","instance":868,"id":170867,"goal":"lemma DivMod_868(j: int, d: int)\n requires d > 0\n ensures j == d * (j / d) + (j % d)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_869","instance":869,"id":170868,"goal":"lemma ModBounds_869(c: nat, x: nat)\n requires x > 0\n ensures 0 <= c % x < x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_870","instance":870,"id":170869,"goal":"lemma Square_Nonneg_870(d: real)\n ensures d * d >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_871","instance":871,"id":170870,"goal":"lemma AddComm_871(y: int, x: int)\n ensures y + x == x + y\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_872","instance":872,"id":170871,"goal":"lemma AddAssoc_872(a: nat, k: nat, i: nat)\n ensures (a + k) + i == a + (k + i)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_873","instance":873,"id":170872,"goal":"lemma MulComm_873(j: real, n: real)\n ensures j * n == n * j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_874","instance":874,"id":170873,"goal":"lemma MulAssoc_874(y: int, z: int, x: int)\n ensures (y * z) * x == y * (z * x)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_875","instance":875,"id":170874,"goal":"lemma Distrib_875(d: nat, a: nat, c: nat)\n ensures d * (a + c) == d * a + d * c\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_876","instance":876,"id":170875,"goal":"lemma AddZero_876(z: real)\n ensures z + 0 == z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_877","instance":877,"id":170876,"goal":"lemma MulOne_877(z: int)\n ensures z * 1 == z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_878","instance":878,"id":170877,"goal":"lemma MulZero_878(j: nat)\n ensures j * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_879","instance":879,"id":170878,"goal":"lemma LeRefl_879(y: real)\n ensures y <= y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_880","instance":880,"id":170879,"goal":"lemma LeTrans_880(z: int, y: int, m: int)\n requires z <= y && y <= m\n ensures z <= m\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_881","instance":881,"id":170880,"goal":"lemma AddMono_881(j: nat, d: nat, b: nat)\n requires j <= d\n ensures j + b <= d + b\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_882","instance":882,"id":170881,"goal":"lemma Abs_Nonneg_882(c: real)\n ensures (if c >= 0 then c else -c) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_883","instance":883,"id":170882,"goal":"lemma DivMod_883(z: int, j: int)\n requires j > 0\n ensures z == j * (z / j) + (z % j)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_884","instance":884,"id":170883,"goal":"lemma ModBounds_884(c: nat, i: nat)\n requires i > 0\n ensures 0 <= c % i < i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_885","instance":885,"id":170884,"goal":"lemma Square_Nonneg_885(j: real)\n ensures j * j >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_886","instance":886,"id":170885,"goal":"lemma AddComm_886(b: int, c: int)\n ensures b + c == c + b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_887","instance":887,"id":170886,"goal":"lemma AddAssoc_887(z: nat, n: nat, m: nat)\n ensures (z + n) + m == z + (n + m)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_888","instance":888,"id":170887,"goal":"lemma MulComm_888(j: real, z: real)\n ensures j * z == z * j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_889","instance":889,"id":170888,"goal":"lemma MulAssoc_889(j: int, m: int, i: int)\n ensures (j * m) * i == j * (m * i)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_890","instance":890,"id":170889,"goal":"lemma Distrib_890(c: nat, x: nat, i: nat)\n ensures c * (x + i) == c * x + c * i\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_891","instance":891,"id":170890,"goal":"lemma AddZero_891(c: real)\n ensures c + 0 == c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_892","instance":892,"id":170891,"goal":"lemma MulOne_892(c: int)\n ensures c * 1 == c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_893","instance":893,"id":170892,"goal":"lemma MulZero_893(d: nat)\n ensures d * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_894","instance":894,"id":170893,"goal":"lemma LeRefl_894(m: real)\n ensures m <= m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_895","instance":895,"id":170894,"goal":"lemma LeTrans_895(y: int, x: int, n: int)\n requires y <= x && x <= n\n ensures y <= n\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_896","instance":896,"id":170895,"goal":"lemma AddMono_896(b: nat, y: nat, a: nat)\n requires b <= y\n ensures b + a <= y + a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_897","instance":897,"id":170896,"goal":"lemma Abs_Nonneg_897(n: real)\n ensures (if n >= 0 then n else -n) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_898","instance":898,"id":170897,"goal":"lemma DivMod_898(k: int, m: int)\n requires m > 0\n ensures k == m * (k / m) + (k % m)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_899","instance":899,"id":170898,"goal":"lemma ModBounds_899(m: nat, a: nat)\n requires a > 0\n ensures 0 <= m % a < a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_900","instance":900,"id":170899,"goal":"lemma Square_Nonneg_900(i: real)\n ensures i * i >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_901","instance":901,"id":170900,"goal":"lemma AddComm_901(n: int, z: int)\n ensures n + z == z + n\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_902","instance":902,"id":170901,"goal":"lemma AddAssoc_902(j: nat, i: nat, c: nat)\n ensures (j + i) + c == j + (i + c)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_903","instance":903,"id":170902,"goal":"lemma MulComm_903(b: real, x: real)\n ensures b * x == x * b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_904","instance":904,"id":170903,"goal":"lemma MulAssoc_904(n: int, c: int, d: int)\n ensures (n * c) * d == n * (c * d)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_905","instance":905,"id":170904,"goal":"lemma Distrib_905(z: nat, n: nat, d: nat)\n ensures z * (n + d) == z * n + z * d\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_906","instance":906,"id":170905,"goal":"lemma AddZero_906(c: real)\n ensures c + 0 == c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_907","instance":907,"id":170906,"goal":"lemma MulOne_907(b: int)\n ensures b * 1 == b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_908","instance":908,"id":170907,"goal":"lemma MulZero_908(x: nat)\n ensures x * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_909","instance":909,"id":170908,"goal":"lemma LeRefl_909(a: real)\n ensures a <= a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_910","instance":910,"id":170909,"goal":"lemma LeTrans_910(y: int, z: int, k: int)\n requires y <= z && z <= k\n ensures y <= k\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_911","instance":911,"id":170910,"goal":"lemma AddMono_911(c: nat, y: nat, x: nat)\n requires c <= y\n ensures c + x <= y + x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_912","instance":912,"id":170911,"goal":"lemma Abs_Nonneg_912(k: real)\n ensures (if k >= 0 then k else -k) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_913","instance":913,"id":170912,"goal":"lemma DivMod_913(b: int, m: int)\n requires m > 0\n ensures b == m * (b / m) + (b % m)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_914","instance":914,"id":170913,"goal":"lemma ModBounds_914(z: nat, d: nat)\n requires d > 0\n ensures 0 <= z % d < d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_915","instance":915,"id":170914,"goal":"lemma Square_Nonneg_915(z: real)\n ensures z * z >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_916","instance":916,"id":170915,"goal":"lemma AddComm_916(d: int, n: int)\n ensures d + n == n + d\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_917","instance":917,"id":170916,"goal":"lemma AddAssoc_917(d: nat, y: nat, i: nat)\n ensures (d + y) + i == d + (y + i)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_918","instance":918,"id":170917,"goal":"lemma MulComm_918(x: real, j: real)\n ensures x * j == j * x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_919","instance":919,"id":170918,"goal":"lemma MulAssoc_919(j: int, y: int, n: int)\n ensures (j * y) * n == j * (y * n)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_920","instance":920,"id":170919,"goal":"lemma Distrib_920(n: nat, m: nat, i: nat)\n ensures n * (m + i) == n * m + n * i\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_921","instance":921,"id":170920,"goal":"lemma AddZero_921(b: real)\n ensures b + 0 == b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_922","instance":922,"id":170921,"goal":"lemma MulOne_922(d: int)\n ensures d * 1 == d\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_923","instance":923,"id":170922,"goal":"lemma MulZero_923(c: nat)\n ensures c * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_924","instance":924,"id":170923,"goal":"lemma LeRefl_924(m: real)\n ensures m <= m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_925","instance":925,"id":170924,"goal":"lemma LeTrans_925(c: int, d: int, m: int)\n requires c <= d && d <= m\n ensures c <= m\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_926","instance":926,"id":170925,"goal":"lemma AddMono_926(b: nat, a: nat, c: nat)\n requires b <= a\n ensures b + c <= a + c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_927","instance":927,"id":170926,"goal":"lemma Abs_Nonneg_927(z: real)\n ensures (if z >= 0 then z else -z) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_928","instance":928,"id":170927,"goal":"lemma DivMod_928(c: int, i: int)\n requires i > 0\n ensures c == i * (c / i) + (c % i)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_929","instance":929,"id":170928,"goal":"lemma ModBounds_929(n: nat, y: nat)\n requires y > 0\n ensures 0 <= n % y < y\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_930","instance":930,"id":170929,"goal":"lemma Square_Nonneg_930(z: real)\n ensures z * z >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_931","instance":931,"id":170930,"goal":"lemma AddComm_931(k: int, c: int)\n ensures k + c == c + k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_932","instance":932,"id":170931,"goal":"lemma AddAssoc_932(z: nat, n: nat, x: nat)\n ensures (z + n) + x == z + (n + x)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_933","instance":933,"id":170932,"goal":"lemma MulComm_933(z: real, a: real)\n ensures z * a == a * z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_934","instance":934,"id":170933,"goal":"lemma MulAssoc_934(d: int, z: int, c: int)\n ensures (d * z) * c == d * (z * c)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_935","instance":935,"id":170934,"goal":"lemma Distrib_935(y: nat, m: nat, b: nat)\n ensures y * (m + b) == y * m + y * b\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_936","instance":936,"id":170935,"goal":"lemma AddZero_936(a: real)\n ensures a + 0 == a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_937","instance":937,"id":170936,"goal":"lemma MulOne_937(c: int)\n ensures c * 1 == c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_938","instance":938,"id":170937,"goal":"lemma MulZero_938(d: nat)\n ensures d * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_939","instance":939,"id":170938,"goal":"lemma LeRefl_939(x: real)\n ensures x <= x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_940","instance":940,"id":170939,"goal":"lemma LeTrans_940(y: int, b: int, k: int)\n requires y <= b && b <= k\n ensures y <= k\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_941","instance":941,"id":170940,"goal":"lemma AddMono_941(x: nat, b: nat, k: nat)\n requires x <= b\n ensures x + k <= b + k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_942","instance":942,"id":170941,"goal":"lemma Abs_Nonneg_942(j: real)\n ensures (if j >= 0 then j else -j) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_943","instance":943,"id":170942,"goal":"lemma DivMod_943(m: int, y: int)\n requires y > 0\n ensures m == y * (m / y) + (m % y)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_944","instance":944,"id":170943,"goal":"lemma ModBounds_944(k: nat, c: nat)\n requires c > 0\n ensures 0 <= k % c < c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_945","instance":945,"id":170944,"goal":"lemma Square_Nonneg_945(a: real)\n ensures a * a >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_946","instance":946,"id":170945,"goal":"lemma AddComm_946(x: int, n: int)\n ensures x + n == n + x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_947","instance":947,"id":170946,"goal":"lemma AddAssoc_947(x: nat, k: nat, z: nat)\n ensures (x + k) + z == x + (k + z)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_948","instance":948,"id":170947,"goal":"lemma MulComm_948(x: real, i: real)\n ensures x * i == i * x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_949","instance":949,"id":170948,"goal":"lemma MulAssoc_949(x: int, j: int, k: int)\n ensures (x * j) * k == x * (j * k)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_950","instance":950,"id":170949,"goal":"lemma Distrib_950(m: nat, x: nat, k: nat)\n ensures m * (x + k) == m * x + m * k\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_951","instance":951,"id":170950,"goal":"lemma AddZero_951(y: real)\n ensures y + 0 == y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_952","instance":952,"id":170951,"goal":"lemma MulOne_952(n: int)\n ensures n * 1 == n\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_953","instance":953,"id":170952,"goal":"lemma MulZero_953(j: nat)\n ensures j * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_954","instance":954,"id":170953,"goal":"lemma LeRefl_954(j: real)\n ensures j <= j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_955","instance":955,"id":170954,"goal":"lemma LeTrans_955(b: int, j: int, a: int)\n requires b <= j && j <= a\n ensures b <= a\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_956","instance":956,"id":170955,"goal":"lemma AddMono_956(m: nat, x: nat, z: nat)\n requires m <= x\n ensures m + z <= x + z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_957","instance":957,"id":170956,"goal":"lemma Abs_Nonneg_957(j: real)\n ensures (if j >= 0 then j else -j) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_958","instance":958,"id":170957,"goal":"lemma DivMod_958(y: int, d: int)\n requires d > 0\n ensures y == d * (y / d) + (y % d)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_959","instance":959,"id":170958,"goal":"lemma ModBounds_959(k: nat, i: nat)\n requires i > 0\n ensures 0 <= k % i < i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_960","instance":960,"id":170959,"goal":"lemma Square_Nonneg_960(i: real)\n ensures i * i >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_961","instance":961,"id":170960,"goal":"lemma AddComm_961(d: int, x: int)\n ensures d + x == x + d\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_962","instance":962,"id":170961,"goal":"lemma AddAssoc_962(c: nat, b: nat, z: nat)\n ensures (c + b) + z == c + (b + z)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_963","instance":963,"id":170962,"goal":"lemma MulComm_963(c: real, i: real)\n ensures c * i == i * c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_964","instance":964,"id":170963,"goal":"lemma MulAssoc_964(b: int, a: int, m: int)\n ensures (b * a) * m == b * (a * m)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_965","instance":965,"id":170964,"goal":"lemma Distrib_965(y: nat, a: nat, m: nat)\n ensures y * (a + m) == y * a + y * m\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_966","instance":966,"id":170965,"goal":"lemma AddZero_966(b: real)\n ensures b + 0 == b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_967","instance":967,"id":170966,"goal":"lemma MulOne_967(b: int)\n ensures b * 1 == b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_968","instance":968,"id":170967,"goal":"lemma MulZero_968(m: nat)\n ensures m * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_969","instance":969,"id":170968,"goal":"lemma LeRefl_969(z: real)\n ensures z <= z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_970","instance":970,"id":170969,"goal":"lemma LeTrans_970(x: int, a: int, y: int)\n requires x <= a && a <= y\n ensures x <= y\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_971","instance":971,"id":170970,"goal":"lemma AddMono_971(y: nat, k: nat, c: nat)\n requires y <= k\n ensures y + c <= k + c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_972","instance":972,"id":170971,"goal":"lemma Abs_Nonneg_972(a: real)\n ensures (if a >= 0 then a else -a) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_973","instance":973,"id":170972,"goal":"lemma DivMod_973(z: int, j: int)\n requires j > 0\n ensures z == j * (z / j) + (z % j)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_974","instance":974,"id":170973,"goal":"lemma ModBounds_974(m: nat, b: nat)\n requires b > 0\n ensures 0 <= m % b < b\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_975","instance":975,"id":170974,"goal":"lemma Square_Nonneg_975(i: real)\n ensures i * i >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_976","instance":976,"id":170975,"goal":"lemma AddComm_976(j: int, n: int)\n ensures j + n == n + j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_977","instance":977,"id":170976,"goal":"lemma AddAssoc_977(k: nat, x: nat, m: nat)\n ensures (k + x) + m == k + (x + m)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_978","instance":978,"id":170977,"goal":"lemma MulComm_978(x: real, b: real)\n ensures x * b == b * x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_979","instance":979,"id":170978,"goal":"lemma MulAssoc_979(n: int, y: int, z: int)\n ensures (n * y) * z == n * (y * z)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_980","instance":980,"id":170979,"goal":"lemma Distrib_980(i: nat, y: nat, m: nat)\n ensures i * (y + m) == i * y + i * m\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_981","instance":981,"id":170980,"goal":"lemma AddZero_981(c: real)\n ensures c + 0 == c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_982","instance":982,"id":170981,"goal":"lemma MulOne_982(y: int)\n ensures y * 1 == y\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_983","instance":983,"id":170982,"goal":"lemma MulZero_983(x: nat)\n ensures x * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_984","instance":984,"id":170983,"goal":"lemma LeRefl_984(a: real)\n ensures a <= a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_985","instance":985,"id":170984,"goal":"lemma LeTrans_985(y: int, j: int, k: int)\n requires y <= j && j <= k\n ensures y <= k\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_986","instance":986,"id":170985,"goal":"lemma AddMono_986(c: nat, b: nat, x: nat)\n requires c <= b\n ensures c + x <= b + x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_987","instance":987,"id":170986,"goal":"lemma Abs_Nonneg_987(x: real)\n ensures (if x >= 0 then x else -x) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_988","instance":988,"id":170987,"goal":"lemma DivMod_988(i: int, z: int)\n requires z > 0\n ensures i == z * (i / z) + (i % z)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_989","instance":989,"id":170988,"goal":"lemma ModBounds_989(d: nat, n: nat)\n requires n > 0\n ensures 0 <= d % n < n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_990","instance":990,"id":170989,"goal":"lemma Square_Nonneg_990(x: real)\n ensures x * x >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_991","instance":991,"id":170990,"goal":"lemma AddComm_991(m: int, c: int)\n ensures m + c == c + m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_992","instance":992,"id":170991,"goal":"lemma AddAssoc_992(n: nat, j: nat, b: nat)\n ensures (n + j) + b == n + (j + b)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_993","instance":993,"id":170992,"goal":"lemma MulComm_993(x: real, z: real)\n ensures x * z == z * x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_994","instance":994,"id":170993,"goal":"lemma MulAssoc_994(d: int, c: int, m: int)\n ensures (d * c) * m == d * (c * m)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_995","instance":995,"id":170994,"goal":"lemma Distrib_995(c: nat, m: nat, z: nat)\n ensures c * (m + z) == c * m + c * z\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_996","instance":996,"id":170995,"goal":"lemma AddZero_996(c: real)\n ensures c + 0 == c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_997","instance":997,"id":170996,"goal":"lemma MulOne_997(a: int)\n ensures a * 1 == a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_998","instance":998,"id":170997,"goal":"lemma MulZero_998(a: nat)\n ensures a * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_999","instance":999,"id":170998,"goal":"lemma LeRefl_999(a: real)\n ensures a <= a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_1000","instance":1000,"id":170999,"goal":"lemma LeTrans_1000(y: int, a: int, n: int)\n requires y <= a && a <= n\n ensures y <= n\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_1001","instance":1001,"id":171000,"goal":"lemma AddMono_1001(m: nat, i: nat, j: nat)\n requires m <= i\n ensures m + j <= i + j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_1002","instance":1002,"id":171001,"goal":"lemma Abs_Nonneg_1002(x: real)\n ensures (if x >= 0 then x else -x) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_1003","instance":1003,"id":171002,"goal":"lemma DivMod_1003(i: int, k: int)\n requires k > 0\n ensures i == k * (i / k) + (i % k)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_1004","instance":1004,"id":171003,"goal":"lemma ModBounds_1004(a: nat, i: nat)\n requires i > 0\n ensures 0 <= a % i < i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_1005","instance":1005,"id":171004,"goal":"lemma Square_Nonneg_1005(x: real)\n ensures x * x >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_1006","instance":1006,"id":171005,"goal":"lemma AddComm_1006(j: int, a: int)\n ensures j + a == a + j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_1007","instance":1007,"id":171006,"goal":"lemma AddAssoc_1007(j: nat, k: nat, d: nat)\n ensures (j + k) + d == j + (k + d)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_1008","instance":1008,"id":171007,"goal":"lemma MulComm_1008(d: real, y: real)\n ensures d * y == y * d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_1009","instance":1009,"id":171008,"goal":"lemma MulAssoc_1009(k: int, z: int, x: int)\n ensures (k * z) * x == k * (z * x)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_1010","instance":1010,"id":171009,"goal":"lemma Distrib_1010(c: nat, n: nat, j: nat)\n ensures c * (n + j) == c * n + c * j\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_1011","instance":1011,"id":171010,"goal":"lemma AddZero_1011(m: real)\n ensures m + 0 == m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_1012","instance":1012,"id":171011,"goal":"lemma MulOne_1012(m: int)\n ensures m * 1 == m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_1013","instance":1013,"id":171012,"goal":"lemma MulZero_1013(d: nat)\n ensures d * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_1014","instance":1014,"id":171013,"goal":"lemma LeRefl_1014(a: real)\n ensures a <= a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_1015","instance":1015,"id":171014,"goal":"lemma LeTrans_1015(i: int, n: int, m: int)\n requires i <= n && n <= m\n ensures i <= m\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_1016","instance":1016,"id":171015,"goal":"lemma AddMono_1016(x: nat, j: nat, a: nat)\n requires x <= j\n ensures x + a <= j + a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_1017","instance":1017,"id":171016,"goal":"lemma Abs_Nonneg_1017(y: real)\n ensures (if y >= 0 then y else -y) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_1018","instance":1018,"id":171017,"goal":"lemma DivMod_1018(x: int, j: int)\n requires j > 0\n ensures x == j * (x / j) + (x % j)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_1019","instance":1019,"id":171018,"goal":"lemma ModBounds_1019(d: nat, i: nat)\n requires i > 0\n ensures 0 <= d % i < i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_1020","instance":1020,"id":171019,"goal":"lemma Square_Nonneg_1020(d: real)\n ensures d * d >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_1021","instance":1021,"id":171020,"goal":"lemma AddComm_1021(x: int, c: int)\n ensures x + c == c + x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_1022","instance":1022,"id":171021,"goal":"lemma AddAssoc_1022(x: nat, m: nat, d: nat)\n ensures (x + m) + d == x + (m + d)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_1023","instance":1023,"id":171022,"goal":"lemma MulComm_1023(i: real, c: real)\n ensures i * c == c * i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_1024","instance":1024,"id":171023,"goal":"lemma MulAssoc_1024(d: int, i: int, b: int)\n ensures (d * i) * b == d * (i * b)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_1025","instance":1025,"id":171024,"goal":"lemma Distrib_1025(m: nat, k: nat, z: nat)\n ensures m * (k + z) == m * k + m * z\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_1026","instance":1026,"id":171025,"goal":"lemma AddZero_1026(d: real)\n ensures d + 0 == d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_1027","instance":1027,"id":171026,"goal":"lemma MulOne_1027(a: int)\n ensures a * 1 == a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_1028","instance":1028,"id":171027,"goal":"lemma MulZero_1028(m: nat)\n ensures m * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_1029","instance":1029,"id":171028,"goal":"lemma LeRefl_1029(i: real)\n ensures i <= i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_1030","instance":1030,"id":171029,"goal":"lemma LeTrans_1030(b: int, k: int, i: int)\n requires b <= k && k <= i\n ensures b <= i\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_1031","instance":1031,"id":171030,"goal":"lemma AddMono_1031(m: nat, j: nat, k: nat)\n requires m <= j\n ensures m + k <= j + k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_1032","instance":1032,"id":171031,"goal":"lemma Abs_Nonneg_1032(a: real)\n ensures (if a >= 0 then a else -a) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_1033","instance":1033,"id":171032,"goal":"lemma DivMod_1033(n: int, k: int)\n requires k > 0\n ensures n == k * (n / k) + (n % k)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_1034","instance":1034,"id":171033,"goal":"lemma ModBounds_1034(c: nat, a: nat)\n requires a > 0\n ensures 0 <= c % a < a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_1035","instance":1035,"id":171034,"goal":"lemma Square_Nonneg_1035(x: real)\n ensures x * x >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_1036","instance":1036,"id":171035,"goal":"lemma AddComm_1036(z: int, a: int)\n ensures z + a == a + z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_1037","instance":1037,"id":171036,"goal":"lemma AddAssoc_1037(b: nat, a: nat, m: nat)\n ensures (b + a) + m == b + (a + m)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_1038","instance":1038,"id":171037,"goal":"lemma MulComm_1038(i: real, k: real)\n ensures i * k == k * i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_1039","instance":1039,"id":171038,"goal":"lemma MulAssoc_1039(b: int, m: int, z: int)\n ensures (b * m) * z == b * (m * z)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_1040","instance":1040,"id":171039,"goal":"lemma Distrib_1040(k: nat, a: nat, x: nat)\n ensures k * (a + x) == k * a + k * x\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_1041","instance":1041,"id":171040,"goal":"lemma AddZero_1041(a: real)\n ensures a + 0 == a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_1042","instance":1042,"id":171041,"goal":"lemma MulOne_1042(j: int)\n ensures j * 1 == j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_1043","instance":1043,"id":171042,"goal":"lemma MulZero_1043(x: nat)\n ensures x * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_1044","instance":1044,"id":171043,"goal":"lemma LeRefl_1044(z: real)\n ensures z <= z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_1045","instance":1045,"id":171044,"goal":"lemma LeTrans_1045(c: int, z: int, b: int)\n requires c <= z && z <= b\n ensures c <= b\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_1046","instance":1046,"id":171045,"goal":"lemma AddMono_1046(k: nat, z: nat, n: nat)\n requires k <= z\n ensures k + n <= z + n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_1047","instance":1047,"id":171046,"goal":"lemma Abs_Nonneg_1047(m: real)\n ensures (if m >= 0 then m else -m) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_1048","instance":1048,"id":171047,"goal":"lemma DivMod_1048(m: int, n: int)\n requires n > 0\n ensures m == n * (m / n) + (m % n)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_1049","instance":1049,"id":171048,"goal":"lemma ModBounds_1049(y: nat, i: nat)\n requires i > 0\n ensures 0 <= y % i < i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_1050","instance":1050,"id":171049,"goal":"lemma Square_Nonneg_1050(k: real)\n ensures k * k >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_1051","instance":1051,"id":171050,"goal":"lemma AddComm_1051(a: int, y: int)\n ensures a + y == y + a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_1052","instance":1052,"id":171051,"goal":"lemma AddAssoc_1052(b: nat, y: nat, j: nat)\n ensures (b + y) + j == b + (y + j)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_1053","instance":1053,"id":171052,"goal":"lemma MulComm_1053(x: real, a: real)\n ensures x * a == a * x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_1054","instance":1054,"id":171053,"goal":"lemma MulAssoc_1054(n: int, d: int, k: int)\n ensures (n * d) * k == n * (d * k)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_1055","instance":1055,"id":171054,"goal":"lemma Distrib_1055(a: nat, i: nat, k: nat)\n ensures a * (i + k) == a * i + a * k\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_1056","instance":1056,"id":171055,"goal":"lemma AddZero_1056(x: real)\n ensures x + 0 == x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_1057","instance":1057,"id":171056,"goal":"lemma MulOne_1057(m: int)\n ensures m * 1 == m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_1058","instance":1058,"id":171057,"goal":"lemma MulZero_1058(i: nat)\n ensures i * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_1059","instance":1059,"id":171058,"goal":"lemma LeRefl_1059(i: real)\n ensures i <= i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_1060","instance":1060,"id":171059,"goal":"lemma LeTrans_1060(d: int, c: int, z: int)\n requires d <= c && c <= z\n ensures d <= z\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_1061","instance":1061,"id":171060,"goal":"lemma AddMono_1061(k: nat, b: nat, z: nat)\n requires k <= b\n ensures k + z <= b + z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_1062","instance":1062,"id":171061,"goal":"lemma Abs_Nonneg_1062(x: real)\n ensures (if x >= 0 then x else -x) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_1063","instance":1063,"id":171062,"goal":"lemma DivMod_1063(b: int, k: int)\n requires k > 0\n ensures b == k * (b / k) + (b % k)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_1064","instance":1064,"id":171063,"goal":"lemma ModBounds_1064(n: nat, k: nat)\n requires k > 0\n ensures 0 <= n % k < k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_1065","instance":1065,"id":171064,"goal":"lemma Square_Nonneg_1065(a: real)\n ensures a * a >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_1066","instance":1066,"id":171065,"goal":"lemma AddComm_1066(z: int, n: int)\n ensures z + n == n + z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_1067","instance":1067,"id":171066,"goal":"lemma AddAssoc_1067(i: nat, y: nat, j: nat)\n ensures (i + y) + j == i + (y + j)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_1068","instance":1068,"id":171067,"goal":"lemma MulComm_1068(a: real, y: real)\n ensures a * y == y * a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_1069","instance":1069,"id":171068,"goal":"lemma MulAssoc_1069(d: int, c: int, i: int)\n ensures (d * c) * i == d * (c * i)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_1070","instance":1070,"id":171069,"goal":"lemma Distrib_1070(i: nat, x: nat, b: nat)\n ensures i * (x + b) == i * x + i * b\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_1071","instance":1071,"id":171070,"goal":"lemma AddZero_1071(m: real)\n ensures m + 0 == m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_1072","instance":1072,"id":171071,"goal":"lemma MulOne_1072(m: int)\n ensures m * 1 == m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_1073","instance":1073,"id":171072,"goal":"lemma MulZero_1073(n: nat)\n ensures n * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_1074","instance":1074,"id":171073,"goal":"lemma LeRefl_1074(x: real)\n ensures x <= x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_1075","instance":1075,"id":171074,"goal":"lemma LeTrans_1075(m: int, i: int, n: int)\n requires m <= i && i <= n\n ensures m <= n\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_1076","instance":1076,"id":171075,"goal":"lemma AddMono_1076(x: nat, k: nat, i: nat)\n requires x <= k\n ensures x + i <= k + i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_1077","instance":1077,"id":171076,"goal":"lemma Abs_Nonneg_1077(z: real)\n ensures (if z >= 0 then z else -z) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_1078","instance":1078,"id":171077,"goal":"lemma DivMod_1078(k: int, c: int)\n requires c > 0\n ensures k == c * (k / c) + (k % c)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_1079","instance":1079,"id":171078,"goal":"lemma ModBounds_1079(n: nat, z: nat)\n requires z > 0\n ensures 0 <= n % z < z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_1080","instance":1080,"id":171079,"goal":"lemma Square_Nonneg_1080(x: real)\n ensures x * x >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_1081","instance":1081,"id":171080,"goal":"lemma AddComm_1081(a: int, c: int)\n ensures a + c == c + a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_1082","instance":1082,"id":171081,"goal":"lemma AddAssoc_1082(m: nat, d: nat, n: nat)\n ensures (m + d) + n == m + (d + n)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_1083","instance":1083,"id":171082,"goal":"lemma MulComm_1083(a: real, c: real)\n ensures a * c == c * a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_1084","instance":1084,"id":171083,"goal":"lemma MulAssoc_1084(m: int, x: int, j: int)\n ensures (m * x) * j == m * (x * j)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_1085","instance":1085,"id":171084,"goal":"lemma Distrib_1085(b: nat, a: nat, k: nat)\n ensures b * (a + k) == b * a + b * k\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_1086","instance":1086,"id":171085,"goal":"lemma AddZero_1086(c: real)\n ensures c + 0 == c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_1087","instance":1087,"id":171086,"goal":"lemma MulOne_1087(m: int)\n ensures m * 1 == m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_1088","instance":1088,"id":171087,"goal":"lemma MulZero_1088(a: nat)\n ensures a * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_1089","instance":1089,"id":171088,"goal":"lemma LeRefl_1089(k: real)\n ensures k <= k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_1090","instance":1090,"id":171089,"goal":"lemma LeTrans_1090(x: int, j: int, b: int)\n requires x <= j && j <= b\n ensures x <= b\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_1091","instance":1091,"id":171090,"goal":"lemma AddMono_1091(x: nat, d: nat, a: nat)\n requires x <= d\n ensures x + a <= d + a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_1092","instance":1092,"id":171091,"goal":"lemma Abs_Nonneg_1092(m: real)\n ensures (if m >= 0 then m else -m) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_1093","instance":1093,"id":171092,"goal":"lemma DivMod_1093(m: int, j: int)\n requires j > 0\n ensures m == j * (m / j) + (m % j)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_1094","instance":1094,"id":171093,"goal":"lemma ModBounds_1094(i: nat, b: nat)\n requires b > 0\n ensures 0 <= i % b < b\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_1095","instance":1095,"id":171094,"goal":"lemma Square_Nonneg_1095(j: real)\n ensures j * j >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_1096","instance":1096,"id":171095,"goal":"lemma AddComm_1096(z: int, k: int)\n ensures z + k == k + z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_1097","instance":1097,"id":171096,"goal":"lemma AddAssoc_1097(x: nat, y: nat, a: nat)\n ensures (x + y) + a == x + (y + a)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_1098","instance":1098,"id":171097,"goal":"lemma MulComm_1098(a: real, c: real)\n ensures a * c == c * a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_1099","instance":1099,"id":171098,"goal":"lemma MulAssoc_1099(x: int, d: int, y: int)\n ensures (x * d) * y == x * (d * y)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_1100","instance":1100,"id":171099,"goal":"lemma Distrib_1100(k: nat, b: nat, c: nat)\n ensures k * (b + c) == k * b + k * c\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_1101","instance":1101,"id":171100,"goal":"lemma AddZero_1101(m: real)\n ensures m + 0 == m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_1102","instance":1102,"id":171101,"goal":"lemma MulOne_1102(m: int)\n ensures m * 1 == m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_1103","instance":1103,"id":171102,"goal":"lemma MulZero_1103(m: nat)\n ensures m * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_1104","instance":1104,"id":171103,"goal":"lemma LeRefl_1104(d: real)\n ensures d <= d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_1105","instance":1105,"id":171104,"goal":"lemma LeTrans_1105(i: int, c: int, a: int)\n requires i <= c && c <= a\n ensures i <= a\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_1106","instance":1106,"id":171105,"goal":"lemma AddMono_1106(d: nat, z: nat, j: nat)\n requires d <= z\n ensures d + j <= z + j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_1107","instance":1107,"id":171106,"goal":"lemma Abs_Nonneg_1107(x: real)\n ensures (if x >= 0 then x else -x) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_1108","instance":1108,"id":171107,"goal":"lemma DivMod_1108(y: int, d: int)\n requires d > 0\n ensures y == d * (y / d) + (y % d)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_1109","instance":1109,"id":171108,"goal":"lemma ModBounds_1109(a: nat, c: nat)\n requires c > 0\n ensures 0 <= a % c < c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_1110","instance":1110,"id":171109,"goal":"lemma Square_Nonneg_1110(x: real)\n ensures x * x >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_1111","instance":1111,"id":171110,"goal":"lemma AddComm_1111(b: int, m: int)\n ensures b + m == m + b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_1112","instance":1112,"id":171111,"goal":"lemma AddAssoc_1112(y: nat, b: nat, j: nat)\n ensures (y + b) + j == y + (b + j)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_1113","instance":1113,"id":171112,"goal":"lemma MulComm_1113(x: real, b: real)\n ensures x * b == b * x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_1114","instance":1114,"id":171113,"goal":"lemma MulAssoc_1114(z: int, y: int, k: int)\n ensures (z * y) * k == z * (y * k)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_1115","instance":1115,"id":171114,"goal":"lemma Distrib_1115(z: nat, c: nat, i: nat)\n ensures z * (c + i) == z * c + z * i\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_1116","instance":1116,"id":171115,"goal":"lemma AddZero_1116(k: real)\n ensures k + 0 == k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_1117","instance":1117,"id":171116,"goal":"lemma MulOne_1117(b: int)\n ensures b * 1 == b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_1118","instance":1118,"id":171117,"goal":"lemma MulZero_1118(m: nat)\n ensures m * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_1119","instance":1119,"id":171118,"goal":"lemma LeRefl_1119(k: real)\n ensures k <= k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_1120","instance":1120,"id":171119,"goal":"lemma LeTrans_1120(j: int, z: int, y: int)\n requires j <= z && z <= y\n ensures j <= y\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_1121","instance":1121,"id":171120,"goal":"lemma AddMono_1121(d: nat, k: nat, x: nat)\n requires d <= k\n ensures d + x <= k + x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_1122","instance":1122,"id":171121,"goal":"lemma Abs_Nonneg_1122(k: real)\n ensures (if k >= 0 then k else -k) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_1123","instance":1123,"id":171122,"goal":"lemma DivMod_1123(i: int, y: int)\n requires y > 0\n ensures i == y * (i / y) + (i % y)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_1124","instance":1124,"id":171123,"goal":"lemma ModBounds_1124(x: nat, d: nat)\n requires d > 0\n ensures 0 <= x % d < d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_1125","instance":1125,"id":171124,"goal":"lemma Square_Nonneg_1125(x: real)\n ensures x * x >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_1126","instance":1126,"id":171125,"goal":"lemma AddComm_1126(z: int, i: int)\n ensures z + i == i + z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_1127","instance":1127,"id":171126,"goal":"lemma AddAssoc_1127(n: nat, c: nat, d: nat)\n ensures (n + c) + d == n + (c + d)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_1128","instance":1128,"id":171127,"goal":"lemma MulComm_1128(n: real, c: real)\n ensures n * c == c * n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_1129","instance":1129,"id":171128,"goal":"lemma MulAssoc_1129(j: int, n: int, m: int)\n ensures (j * n) * m == j * (n * m)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_1130","instance":1130,"id":171129,"goal":"lemma Distrib_1130(k: nat, j: nat, a: nat)\n ensures k * (j + a) == k * j + k * a\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_1131","instance":1131,"id":171130,"goal":"lemma AddZero_1131(a: real)\n ensures a + 0 == a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_1132","instance":1132,"id":171131,"goal":"lemma MulOne_1132(x: int)\n ensures x * 1 == x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_1133","instance":1133,"id":171132,"goal":"lemma MulZero_1133(m: nat)\n ensures m * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_1134","instance":1134,"id":171133,"goal":"lemma LeRefl_1134(x: real)\n ensures x <= x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_1135","instance":1135,"id":171134,"goal":"lemma LeTrans_1135(k: int, z: int, m: int)\n requires k <= z && z <= m\n ensures k <= m\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_1136","instance":1136,"id":171135,"goal":"lemma AddMono_1136(c: nat, n: nat, x: nat)\n requires c <= n\n ensures c + x <= n + x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_1137","instance":1137,"id":171136,"goal":"lemma Abs_Nonneg_1137(x: real)\n ensures (if x >= 0 then x else -x) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_1138","instance":1138,"id":171137,"goal":"lemma DivMod_1138(z: int, k: int)\n requires k > 0\n ensures z == k * (z / k) + (z % k)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_1139","instance":1139,"id":171138,"goal":"lemma ModBounds_1139(b: nat, a: nat)\n requires a > 0\n ensures 0 <= b % a < a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_1140","instance":1140,"id":171139,"goal":"lemma Square_Nonneg_1140(c: real)\n ensures c * c >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_1141","instance":1141,"id":171140,"goal":"lemma AddComm_1141(x: int, j: int)\n ensures x + j == j + x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_1142","instance":1142,"id":171141,"goal":"lemma AddAssoc_1142(j: nat, z: nat, i: nat)\n ensures (j + z) + i == j + (z + i)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_1143","instance":1143,"id":171142,"goal":"lemma MulComm_1143(b: real, k: real)\n ensures b * k == k * b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_1144","instance":1144,"id":171143,"goal":"lemma MulAssoc_1144(i: int, x: int, b: int)\n ensures (i * x) * b == i * (x * b)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_1145","instance":1145,"id":171144,"goal":"lemma Distrib_1145(k: nat, a: nat, j: nat)\n ensures k * (a + j) == k * a + k * j\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_1146","instance":1146,"id":171145,"goal":"lemma AddZero_1146(d: real)\n ensures d + 0 == d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_1147","instance":1147,"id":171146,"goal":"lemma MulOne_1147(n: int)\n ensures n * 1 == n\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_1148","instance":1148,"id":171147,"goal":"lemma MulZero_1148(b: nat)\n ensures b * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_1149","instance":1149,"id":171148,"goal":"lemma LeRefl_1149(z: real)\n ensures z <= z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_1150","instance":1150,"id":171149,"goal":"lemma LeTrans_1150(i: int, z: int, b: int)\n requires i <= z && z <= b\n ensures i <= b\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_1151","instance":1151,"id":171150,"goal":"lemma AddMono_1151(c: nat, j: nat, k: nat)\n requires c <= j\n ensures c + k <= j + k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_1152","instance":1152,"id":171151,"goal":"lemma Abs_Nonneg_1152(b: real)\n ensures (if b >= 0 then b else -b) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_1153","instance":1153,"id":171152,"goal":"lemma DivMod_1153(i: int, y: int)\n requires y > 0\n ensures i == y * (i / y) + (i % y)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_1154","instance":1154,"id":171153,"goal":"lemma ModBounds_1154(z: nat, y: nat)\n requires y > 0\n ensures 0 <= z % y < y\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_1155","instance":1155,"id":171154,"goal":"lemma Square_Nonneg_1155(c: real)\n ensures c * c >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_1156","instance":1156,"id":171155,"goal":"lemma AddComm_1156(b: int, d: int)\n ensures b + d == d + b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_1157","instance":1157,"id":171156,"goal":"lemma AddAssoc_1157(n: nat, b: nat, c: nat)\n ensures (n + b) + c == n + (b + c)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_1158","instance":1158,"id":171157,"goal":"lemma MulComm_1158(d: real, b: real)\n ensures d * b == b * d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_1159","instance":1159,"id":171158,"goal":"lemma MulAssoc_1159(z: int, x: int, a: int)\n ensures (z * x) * a == z * (x * a)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_1160","instance":1160,"id":171159,"goal":"lemma Distrib_1160(d: nat, i: nat, y: nat)\n ensures d * (i + y) == d * i + d * y\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_1161","instance":1161,"id":171160,"goal":"lemma AddZero_1161(m: real)\n ensures m + 0 == m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_1162","instance":1162,"id":171161,"goal":"lemma MulOne_1162(y: int)\n ensures y * 1 == y\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_1163","instance":1163,"id":171162,"goal":"lemma MulZero_1163(j: nat)\n ensures j * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_1164","instance":1164,"id":171163,"goal":"lemma LeRefl_1164(j: real)\n ensures j <= j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_1165","instance":1165,"id":171164,"goal":"lemma LeTrans_1165(n: int, x: int, c: int)\n requires n <= x && x <= c\n ensures n <= c\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_1166","instance":1166,"id":171165,"goal":"lemma AddMono_1166(x: nat, z: nat, n: nat)\n requires x <= z\n ensures x + n <= z + n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_1167","instance":1167,"id":171166,"goal":"lemma Abs_Nonneg_1167(k: real)\n ensures (if k >= 0 then k else -k) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_1168","instance":1168,"id":171167,"goal":"lemma DivMod_1168(k: int, j: int)\n requires j > 0\n ensures k == j * (k / j) + (k % j)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_1169","instance":1169,"id":171168,"goal":"lemma ModBounds_1169(m: nat, j: nat)\n requires j > 0\n ensures 0 <= m % j < j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_1170","instance":1170,"id":171169,"goal":"lemma Square_Nonneg_1170(a: real)\n ensures a * a >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_1171","instance":1171,"id":171170,"goal":"lemma AddComm_1171(i: int, a: int)\n ensures i + a == a + i\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_1172","instance":1172,"id":171171,"goal":"lemma AddAssoc_1172(z: nat, n: nat, x: nat)\n ensures (z + n) + x == z + (n + x)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_1173","instance":1173,"id":171172,"goal":"lemma MulComm_1173(y: real, j: real)\n ensures y * j == j * y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_1174","instance":1174,"id":171173,"goal":"lemma MulAssoc_1174(j: int, d: int, k: int)\n ensures (j * d) * k == j * (d * k)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_1175","instance":1175,"id":171174,"goal":"lemma Distrib_1175(b: nat, a: nat, y: nat)\n ensures b * (a + y) == b * a + b * y\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_1176","instance":1176,"id":171175,"goal":"lemma AddZero_1176(k: real)\n ensures k + 0 == k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_1177","instance":1177,"id":171176,"goal":"lemma MulOne_1177(j: int)\n ensures j * 1 == j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_1178","instance":1178,"id":171177,"goal":"lemma MulZero_1178(c: nat)\n ensures c * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_1179","instance":1179,"id":171178,"goal":"lemma LeRefl_1179(n: real)\n ensures n <= n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_1180","instance":1180,"id":171179,"goal":"lemma LeTrans_1180(c: int, z: int, i: int)\n requires c <= z && z <= i\n ensures c <= i\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_1181","instance":1181,"id":171180,"goal":"lemma AddMono_1181(m: nat, x: nat, n: nat)\n requires m <= x\n ensures m + n <= x + n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_1182","instance":1182,"id":171181,"goal":"lemma Abs_Nonneg_1182(k: real)\n ensures (if k >= 0 then k else -k) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_1183","instance":1183,"id":171182,"goal":"lemma DivMod_1183(x: int, a: int)\n requires a > 0\n ensures x == a * (x / a) + (x % a)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_1184","instance":1184,"id":171183,"goal":"lemma ModBounds_1184(a: nat, b: nat)\n requires b > 0\n ensures 0 <= a % b < b\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_1185","instance":1185,"id":171184,"goal":"lemma Square_Nonneg_1185(a: real)\n ensures a * a >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_1186","instance":1186,"id":171185,"goal":"lemma AddComm_1186(z: int, y: int)\n ensures z + y == y + z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_1187","instance":1187,"id":171186,"goal":"lemma AddAssoc_1187(c: nat, i: nat, z: nat)\n ensures (c + i) + z == c + (i + z)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_1188","instance":1188,"id":171187,"goal":"lemma MulComm_1188(d: real, b: real)\n ensures d * b == b * d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_1189","instance":1189,"id":171188,"goal":"lemma MulAssoc_1189(i: int, d: int, m: int)\n ensures (i * d) * m == i * (d * m)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_1190","instance":1190,"id":171189,"goal":"lemma Distrib_1190(x: nat, m: nat, z: nat)\n ensures x * (m + z) == x * m + x * z\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_1191","instance":1191,"id":171190,"goal":"lemma AddZero_1191(k: real)\n ensures k + 0 == k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_1192","instance":1192,"id":171191,"goal":"lemma MulOne_1192(c: int)\n ensures c * 1 == c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_1193","instance":1193,"id":171192,"goal":"lemma MulZero_1193(b: nat)\n ensures b * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_1194","instance":1194,"id":171193,"goal":"lemma LeRefl_1194(n: real)\n ensures n <= n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_1195","instance":1195,"id":171194,"goal":"lemma LeTrans_1195(j: int, k: int, y: int)\n requires j <= k && k <= y\n ensures j <= y\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_1196","instance":1196,"id":171195,"goal":"lemma AddMono_1196(b: nat, m: nat, k: nat)\n requires b <= m\n ensures b + k <= m + k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_1197","instance":1197,"id":171196,"goal":"lemma Abs_Nonneg_1197(i: real)\n ensures (if i >= 0 then i else -i) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_1198","instance":1198,"id":171197,"goal":"lemma DivMod_1198(a: int, x: int)\n requires x > 0\n ensures a == x * (a / x) + (a % x)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_1199","instance":1199,"id":171198,"goal":"lemma ModBounds_1199(y: nat, k: nat)\n requires k > 0\n ensures 0 <= y % k < k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_1200","instance":1200,"id":171199,"goal":"lemma Square_Nonneg_1200(n: real)\n ensures n * n >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_1201","instance":1201,"id":171200,"goal":"lemma AddComm_1201(a: int, m: int)\n ensures a + m == m + a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_1202","instance":1202,"id":171201,"goal":"lemma AddAssoc_1202(b: nat, d: nat, y: nat)\n ensures (b + d) + y == b + (d + y)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_1203","instance":1203,"id":171202,"goal":"lemma MulComm_1203(j: real, b: real)\n ensures j * b == b * j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_1204","instance":1204,"id":171203,"goal":"lemma MulAssoc_1204(x: int, d: int, a: int)\n ensures (x * d) * a == x * (d * a)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_1205","instance":1205,"id":171204,"goal":"lemma Distrib_1205(z: nat, n: nat, j: nat)\n ensures z * (n + j) == z * n + z * j\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_1206","instance":1206,"id":171205,"goal":"lemma AddZero_1206(k: real)\n ensures k + 0 == k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_1207","instance":1207,"id":171206,"goal":"lemma MulOne_1207(k: int)\n ensures k * 1 == k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_1208","instance":1208,"id":171207,"goal":"lemma MulZero_1208(c: nat)\n ensures c * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_1209","instance":1209,"id":171208,"goal":"lemma LeRefl_1209(y: real)\n ensures y <= y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_1210","instance":1210,"id":171209,"goal":"lemma LeTrans_1210(i: int, j: int, d: int)\n requires i <= j && j <= d\n ensures i <= d\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_1211","instance":1211,"id":171210,"goal":"lemma AddMono_1211(j: nat, a: nat, c: nat)\n requires j <= a\n ensures j + c <= a + c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_1212","instance":1212,"id":171211,"goal":"lemma Abs_Nonneg_1212(y: real)\n ensures (if y >= 0 then y else -y) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_1213","instance":1213,"id":171212,"goal":"lemma DivMod_1213(n: int, c: int)\n requires c > 0\n ensures n == c * (n / c) + (n % c)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_1214","instance":1214,"id":171213,"goal":"lemma ModBounds_1214(z: nat, c: nat)\n requires c > 0\n ensures 0 <= z % c < c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_1215","instance":1215,"id":171214,"goal":"lemma Square_Nonneg_1215(k: real)\n ensures k * k >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_1216","instance":1216,"id":171215,"goal":"lemma AddComm_1216(y: int, z: int)\n ensures y + z == z + y\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_1217","instance":1217,"id":171216,"goal":"lemma AddAssoc_1217(m: nat, d: nat, k: nat)\n ensures (m + d) + k == m + (d + k)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_1218","instance":1218,"id":171217,"goal":"lemma MulComm_1218(i: real, x: real)\n ensures i * x == x * i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_1219","instance":1219,"id":171218,"goal":"lemma MulAssoc_1219(d: int, x: int, i: int)\n ensures (d * x) * i == d * (x * i)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_1220","instance":1220,"id":171219,"goal":"lemma Distrib_1220(b: nat, n: nat, y: nat)\n ensures b * (n + y) == b * n + b * y\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_1221","instance":1221,"id":171220,"goal":"lemma AddZero_1221(c: real)\n ensures c + 0 == c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_1222","instance":1222,"id":171221,"goal":"lemma MulOne_1222(j: int)\n ensures j * 1 == j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_1223","instance":1223,"id":171222,"goal":"lemma MulZero_1223(i: nat)\n ensures i * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_1224","instance":1224,"id":171223,"goal":"lemma LeRefl_1224(b: real)\n ensures b <= b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_1225","instance":1225,"id":171224,"goal":"lemma LeTrans_1225(m: int, n: int, c: int)\n requires m <= n && n <= c\n ensures m <= c\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_1226","instance":1226,"id":171225,"goal":"lemma AddMono_1226(m: nat, a: nat, k: nat)\n requires m <= a\n ensures m + k <= a + k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_1227","instance":1227,"id":171226,"goal":"lemma Abs_Nonneg_1227(x: real)\n ensures (if x >= 0 then x else -x) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_1228","instance":1228,"id":171227,"goal":"lemma DivMod_1228(j: int, k: int)\n requires k > 0\n ensures j == k * (j / k) + (j % k)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_1229","instance":1229,"id":171228,"goal":"lemma ModBounds_1229(b: nat, x: nat)\n requires x > 0\n ensures 0 <= b % x < x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_1230","instance":1230,"id":171229,"goal":"lemma Square_Nonneg_1230(y: real)\n ensures y * y >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_1231","instance":1231,"id":171230,"goal":"lemma AddComm_1231(z: int, y: int)\n ensures z + y == y + z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_1232","instance":1232,"id":171231,"goal":"lemma AddAssoc_1232(z: nat, b: nat, n: nat)\n ensures (z + b) + n == z + (b + n)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_1233","instance":1233,"id":171232,"goal":"lemma MulComm_1233(x: real, a: real)\n ensures x * a == a * x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_1234","instance":1234,"id":171233,"goal":"lemma MulAssoc_1234(i: int, b: int, x: int)\n ensures (i * b) * x == i * (b * x)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_1235","instance":1235,"id":171234,"goal":"lemma Distrib_1235(k: nat, y: nat, d: nat)\n ensures k * (y + d) == k * y + k * d\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_1236","instance":1236,"id":171235,"goal":"lemma AddZero_1236(k: real)\n ensures k + 0 == k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_1237","instance":1237,"id":171236,"goal":"lemma MulOne_1237(d: int)\n ensures d * 1 == d\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_1238","instance":1238,"id":171237,"goal":"lemma MulZero_1238(b: nat)\n ensures b * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_1239","instance":1239,"id":171238,"goal":"lemma LeRefl_1239(j: real)\n ensures j <= j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_1240","instance":1240,"id":171239,"goal":"lemma LeTrans_1240(a: int, z: int, x: int)\n requires a <= z && z <= x\n ensures a <= x\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_1241","instance":1241,"id":171240,"goal":"lemma AddMono_1241(y: nat, k: nat, j: nat)\n requires y <= k\n ensures y + j <= k + j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_1242","instance":1242,"id":171241,"goal":"lemma Abs_Nonneg_1242(d: real)\n ensures (if d >= 0 then d else -d) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_1243","instance":1243,"id":171242,"goal":"lemma DivMod_1243(c: int, z: int)\n requires z > 0\n ensures c == z * (c / z) + (c % z)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_1244","instance":1244,"id":171243,"goal":"lemma ModBounds_1244(d: nat, a: nat)\n requires a > 0\n ensures 0 <= d % a < a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_1245","instance":1245,"id":171244,"goal":"lemma Square_Nonneg_1245(i: real)\n ensures i * i >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_1246","instance":1246,"id":171245,"goal":"lemma AddComm_1246(n: int, a: int)\n ensures n + a == a + n\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_1247","instance":1247,"id":171246,"goal":"lemma AddAssoc_1247(y: nat, c: nat, n: nat)\n ensures (y + c) + n == y + (c + n)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_1248","instance":1248,"id":171247,"goal":"lemma MulComm_1248(y: real, a: real)\n ensures y * a == a * y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_1249","instance":1249,"id":171248,"goal":"lemma MulAssoc_1249(d: int, n: int, c: int)\n ensures (d * n) * c == d * (n * c)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_1250","instance":1250,"id":171249,"goal":"lemma Distrib_1250(i: nat, c: nat, x: nat)\n ensures i * (c + x) == i * c + i * x\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_1251","instance":1251,"id":171250,"goal":"lemma AddZero_1251(b: real)\n ensures b + 0 == b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_1252","instance":1252,"id":171251,"goal":"lemma MulOne_1252(j: int)\n ensures j * 1 == j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_1253","instance":1253,"id":171252,"goal":"lemma MulZero_1253(z: nat)\n ensures z * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_1254","instance":1254,"id":171253,"goal":"lemma LeRefl_1254(i: real)\n ensures i <= i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_1255","instance":1255,"id":171254,"goal":"lemma LeTrans_1255(c: int, x: int, b: int)\n requires c <= x && x <= b\n ensures c <= b\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_1256","instance":1256,"id":171255,"goal":"lemma AddMono_1256(m: nat, y: nat, a: nat)\n requires m <= y\n ensures m + a <= y + a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_1257","instance":1257,"id":171256,"goal":"lemma Abs_Nonneg_1257(k: real)\n ensures (if k >= 0 then k else -k) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_1258","instance":1258,"id":171257,"goal":"lemma DivMod_1258(b: int, y: int)\n requires y > 0\n ensures b == y * (b / y) + (b % y)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_1259","instance":1259,"id":171258,"goal":"lemma ModBounds_1259(i: nat, z: nat)\n requires z > 0\n ensures 0 <= i % z < z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_1260","instance":1260,"id":171259,"goal":"lemma Square_Nonneg_1260(y: real)\n ensures y * y >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_1261","instance":1261,"id":171260,"goal":"lemma AddComm_1261(k: int, n: int)\n ensures k + n == n + k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_1262","instance":1262,"id":171261,"goal":"lemma AddAssoc_1262(a: nat, i: nat, c: nat)\n ensures (a + i) + c == a + (i + c)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_1263","instance":1263,"id":171262,"goal":"lemma MulComm_1263(k: real, i: real)\n ensures k * i == i * k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_1264","instance":1264,"id":171263,"goal":"lemma MulAssoc_1264(y: int, x: int, m: int)\n ensures (y * x) * m == y * (x * m)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_1265","instance":1265,"id":171264,"goal":"lemma Distrib_1265(d: nat, k: nat, y: nat)\n ensures d * (k + y) == d * k + d * y\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_1266","instance":1266,"id":171265,"goal":"lemma AddZero_1266(j: real)\n ensures j + 0 == j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_1267","instance":1267,"id":171266,"goal":"lemma MulOne_1267(c: int)\n ensures c * 1 == c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_1268","instance":1268,"id":171267,"goal":"lemma MulZero_1268(b: nat)\n ensures b * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_1269","instance":1269,"id":171268,"goal":"lemma LeRefl_1269(d: real)\n ensures d <= d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_1270","instance":1270,"id":171269,"goal":"lemma LeTrans_1270(y: int, j: int, a: int)\n requires y <= j && j <= a\n ensures y <= a\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_1271","instance":1271,"id":171270,"goal":"lemma AddMono_1271(a: nat, c: nat, n: nat)\n requires a <= c\n ensures a + n <= c + n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_1272","instance":1272,"id":171271,"goal":"lemma Abs_Nonneg_1272(y: real)\n ensures (if y >= 0 then y else -y) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_1273","instance":1273,"id":171272,"goal":"lemma DivMod_1273(n: int, m: int)\n requires m > 0\n ensures n == m * (n / m) + (n % m)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_1274","instance":1274,"id":171273,"goal":"lemma ModBounds_1274(x: nat, i: nat)\n requires i > 0\n ensures 0 <= x % i < i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_1275","instance":1275,"id":171274,"goal":"lemma Square_Nonneg_1275(n: real)\n ensures n * n >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_1276","instance":1276,"id":171275,"goal":"lemma AddComm_1276(z: int, b: int)\n ensures z + b == b + z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_1277","instance":1277,"id":171276,"goal":"lemma AddAssoc_1277(k: nat, n: nat, m: nat)\n ensures (k + n) + m == k + (n + m)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_1278","instance":1278,"id":171277,"goal":"lemma MulComm_1278(c: real, a: real)\n ensures c * a == a * c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_1279","instance":1279,"id":171278,"goal":"lemma MulAssoc_1279(z: int, n: int, x: int)\n ensures (z * n) * x == z * (n * x)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_1280","instance":1280,"id":171279,"goal":"lemma Distrib_1280(j: nat, m: nat, n: nat)\n ensures j * (m + n) == j * m + j * n\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_1281","instance":1281,"id":171280,"goal":"lemma AddZero_1281(c: real)\n ensures c + 0 == c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_1282","instance":1282,"id":171281,"goal":"lemma MulOne_1282(j: int)\n ensures j * 1 == j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_1283","instance":1283,"id":171282,"goal":"lemma MulZero_1283(a: nat)\n ensures a * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_1284","instance":1284,"id":171283,"goal":"lemma LeRefl_1284(i: real)\n ensures i <= i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_1285","instance":1285,"id":171284,"goal":"lemma LeTrans_1285(k: int, j: int, y: int)\n requires k <= j && j <= y\n ensures k <= y\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_1286","instance":1286,"id":171285,"goal":"lemma AddMono_1286(a: nat, i: nat, d: nat)\n requires a <= i\n ensures a + d <= i + d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_1287","instance":1287,"id":171286,"goal":"lemma Abs_Nonneg_1287(y: real)\n ensures (if y >= 0 then y else -y) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_1288","instance":1288,"id":171287,"goal":"lemma DivMod_1288(d: int, n: int)\n requires n > 0\n ensures d == n * (d / n) + (d % n)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_1289","instance":1289,"id":171288,"goal":"lemma ModBounds_1289(i: nat, z: nat)\n requires z > 0\n ensures 0 <= i % z < z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_1290","instance":1290,"id":171289,"goal":"lemma Square_Nonneg_1290(c: real)\n ensures c * c >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_1291","instance":1291,"id":171290,"goal":"lemma AddComm_1291(b: int, m: int)\n ensures b + m == m + b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_1292","instance":1292,"id":171291,"goal":"lemma AddAssoc_1292(c: nat, i: nat, b: nat)\n ensures (c + i) + b == c + (i + b)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_1293","instance":1293,"id":171292,"goal":"lemma MulComm_1293(n: real, k: real)\n ensures n * k == k * n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_1294","instance":1294,"id":171293,"goal":"lemma MulAssoc_1294(k: int, n: int, y: int)\n ensures (k * n) * y == k * (n * y)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_1295","instance":1295,"id":171294,"goal":"lemma Distrib_1295(d: nat, b: nat, c: nat)\n ensures d * (b + c) == d * b + d * c\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_1296","instance":1296,"id":171295,"goal":"lemma AddZero_1296(y: real)\n ensures y + 0 == y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_1297","instance":1297,"id":171296,"goal":"lemma MulOne_1297(j: int)\n ensures j * 1 == j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_1298","instance":1298,"id":171297,"goal":"lemma MulZero_1298(k: nat)\n ensures k * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_1299","instance":1299,"id":171298,"goal":"lemma LeRefl_1299(m: real)\n ensures m <= m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_1300","instance":1300,"id":171299,"goal":"lemma LeTrans_1300(n: int, x: int, c: int)\n requires n <= x && x <= c\n ensures n <= c\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_1301","instance":1301,"id":171300,"goal":"lemma AddMono_1301(i: nat, z: nat, m: nat)\n requires i <= z\n ensures i + m <= z + m\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_1302","instance":1302,"id":171301,"goal":"lemma Abs_Nonneg_1302(i: real)\n ensures (if i >= 0 then i else -i) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_1303","instance":1303,"id":171302,"goal":"lemma DivMod_1303(i: int, a: int)\n requires a > 0\n ensures i == a * (i / a) + (i % a)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_1304","instance":1304,"id":171303,"goal":"lemma ModBounds_1304(z: nat, x: nat)\n requires x > 0\n ensures 0 <= z % x < x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_1305","instance":1305,"id":171304,"goal":"lemma Square_Nonneg_1305(n: real)\n ensures n * n >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_1306","instance":1306,"id":171305,"goal":"lemma AddComm_1306(k: int, a: int)\n ensures k + a == a + k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_1307","instance":1307,"id":171306,"goal":"lemma AddAssoc_1307(a: nat, m: nat, i: nat)\n ensures (a + m) + i == a + (m + i)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_1308","instance":1308,"id":171307,"goal":"lemma MulComm_1308(c: real, k: real)\n ensures c * k == k * c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_1309","instance":1309,"id":171308,"goal":"lemma MulAssoc_1309(z: int, y: int, k: int)\n ensures (z * y) * k == z * (y * k)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_1310","instance":1310,"id":171309,"goal":"lemma Distrib_1310(d: nat, c: nat, z: nat)\n ensures d * (c + z) == d * c + d * z\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_1311","instance":1311,"id":171310,"goal":"lemma AddZero_1311(d: real)\n ensures d + 0 == d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_1312","instance":1312,"id":171311,"goal":"lemma MulOne_1312(n: int)\n ensures n * 1 == n\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_1313","instance":1313,"id":171312,"goal":"lemma MulZero_1313(m: nat)\n ensures m * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_1314","instance":1314,"id":171313,"goal":"lemma LeRefl_1314(y: real)\n ensures y <= y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_1315","instance":1315,"id":171314,"goal":"lemma LeTrans_1315(m: int, i: int, k: int)\n requires m <= i && i <= k\n ensures m <= k\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_1316","instance":1316,"id":171315,"goal":"lemma AddMono_1316(c: nat, y: nat, b: nat)\n requires c <= y\n ensures c + b <= y + b\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_1317","instance":1317,"id":171316,"goal":"lemma Abs_Nonneg_1317(n: real)\n ensures (if n >= 0 then n else -n) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_1318","instance":1318,"id":171317,"goal":"lemma DivMod_1318(a: int, b: int)\n requires b > 0\n ensures a == b * (a / b) + (a % b)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_1319","instance":1319,"id":171318,"goal":"lemma ModBounds_1319(y: nat, i: nat)\n requires i > 0\n ensures 0 <= y % i < i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_1320","instance":1320,"id":171319,"goal":"lemma Square_Nonneg_1320(k: real)\n ensures k * k >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_1321","instance":1321,"id":171320,"goal":"lemma AddComm_1321(k: int, y: int)\n ensures k + y == y + k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_1322","instance":1322,"id":171321,"goal":"lemma AddAssoc_1322(j: nat, b: nat, n: nat)\n ensures (j + b) + n == j + (b + n)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_1323","instance":1323,"id":171322,"goal":"lemma MulComm_1323(i: real, d: real)\n ensures i * d == d * i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_1324","instance":1324,"id":171323,"goal":"lemma MulAssoc_1324(m: int, n: int, k: int)\n ensures (m * n) * k == m * (n * k)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_1325","instance":1325,"id":171324,"goal":"lemma Distrib_1325(j: nat, n: nat, k: nat)\n ensures j * (n + k) == j * n + j * k\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_1326","instance":1326,"id":171325,"goal":"lemma AddZero_1326(x: real)\n ensures x + 0 == x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_1327","instance":1327,"id":171326,"goal":"lemma MulOne_1327(x: int)\n ensures x * 1 == x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_1328","instance":1328,"id":171327,"goal":"lemma MulZero_1328(x: nat)\n ensures x * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_1329","instance":1329,"id":171328,"goal":"lemma LeRefl_1329(y: real)\n ensures y <= y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_1330","instance":1330,"id":171329,"goal":"lemma LeTrans_1330(i: int, d: int, k: int)\n requires i <= d && d <= k\n ensures i <= k\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_1331","instance":1331,"id":171330,"goal":"lemma AddMono_1331(k: nat, a: nat, j: nat)\n requires k <= a\n ensures k + j <= a + j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_1332","instance":1332,"id":171331,"goal":"lemma Abs_Nonneg_1332(a: real)\n ensures (if a >= 0 then a else -a) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_1333","instance":1333,"id":171332,"goal":"lemma DivMod_1333(c: int, a: int)\n requires a > 0\n ensures c == a * (c / a) + (c % a)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_1334","instance":1334,"id":171333,"goal":"lemma ModBounds_1334(n: nat, x: nat)\n requires x > 0\n ensures 0 <= n % x < x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_1335","instance":1335,"id":171334,"goal":"lemma Square_Nonneg_1335(d: real)\n ensures d * d >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_1336","instance":1336,"id":171335,"goal":"lemma AddComm_1336(x: int, k: int)\n ensures x + k == k + x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_1337","instance":1337,"id":171336,"goal":"lemma AddAssoc_1337(a: nat, z: nat, d: nat)\n ensures (a + z) + d == a + (z + d)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_1338","instance":1338,"id":171337,"goal":"lemma MulComm_1338(x: real, a: real)\n ensures x * a == a * x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_1339","instance":1339,"id":171338,"goal":"lemma MulAssoc_1339(k: int, d: int, i: int)\n ensures (k * d) * i == k * (d * i)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_1340","instance":1340,"id":171339,"goal":"lemma Distrib_1340(k: nat, d: nat, j: nat)\n ensures k * (d + j) == k * d + k * j\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_1341","instance":1341,"id":171340,"goal":"lemma AddZero_1341(n: real)\n ensures n + 0 == n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_1342","instance":1342,"id":171341,"goal":"lemma MulOne_1342(m: int)\n ensures m * 1 == m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_1343","instance":1343,"id":171342,"goal":"lemma MulZero_1343(y: nat)\n ensures y * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_1344","instance":1344,"id":171343,"goal":"lemma LeRefl_1344(a: real)\n ensures a <= a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_1345","instance":1345,"id":171344,"goal":"lemma LeTrans_1345(z: int, m: int, k: int)\n requires z <= m && m <= k\n ensures z <= k\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_1346","instance":1346,"id":171345,"goal":"lemma AddMono_1346(m: nat, c: nat, z: nat)\n requires m <= c\n ensures m + z <= c + z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_1347","instance":1347,"id":171346,"goal":"lemma Abs_Nonneg_1347(d: real)\n ensures (if d >= 0 then d else -d) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_1348","instance":1348,"id":171347,"goal":"lemma DivMod_1348(c: int, x: int)\n requires x > 0\n ensures c == x * (c / x) + (c % x)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_1349","instance":1349,"id":171348,"goal":"lemma ModBounds_1349(k: nat, y: nat)\n requires y > 0\n ensures 0 <= k % y < y\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_1350","instance":1350,"id":171349,"goal":"lemma Square_Nonneg_1350(z: real)\n ensures z * z >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_1351","instance":1351,"id":171350,"goal":"lemma AddComm_1351(k: int, j: int)\n ensures k + j == j + k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_1352","instance":1352,"id":171351,"goal":"lemma AddAssoc_1352(x: nat, j: nat, c: nat)\n ensures (x + j) + c == x + (j + c)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_1353","instance":1353,"id":171352,"goal":"lemma MulComm_1353(k: real, i: real)\n ensures k * i == i * k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_1354","instance":1354,"id":171353,"goal":"lemma MulAssoc_1354(d: int, n: int, i: int)\n ensures (d * n) * i == d * (n * i)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_1355","instance":1355,"id":171354,"goal":"lemma Distrib_1355(y: nat, x: nat, j: nat)\n ensures y * (x + j) == y * x + y * j\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_1356","instance":1356,"id":171355,"goal":"lemma AddZero_1356(d: real)\n ensures d + 0 == d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_1357","instance":1357,"id":171356,"goal":"lemma MulOne_1357(d: int)\n ensures d * 1 == d\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_1358","instance":1358,"id":171357,"goal":"lemma MulZero_1358(z: nat)\n ensures z * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_1359","instance":1359,"id":171358,"goal":"lemma LeRefl_1359(b: real)\n ensures b <= b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_1360","instance":1360,"id":171359,"goal":"lemma LeTrans_1360(y: int, b: int, k: int)\n requires y <= b && b <= k\n ensures y <= k\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_1361","instance":1361,"id":171360,"goal":"lemma AddMono_1361(j: nat, b: nat, z: nat)\n requires j <= b\n ensures j + z <= b + z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_1362","instance":1362,"id":171361,"goal":"lemma Abs_Nonneg_1362(y: real)\n ensures (if y >= 0 then y else -y) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_1363","instance":1363,"id":171362,"goal":"lemma DivMod_1363(d: int, y: int)\n requires y > 0\n ensures d == y * (d / y) + (d % y)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_1364","instance":1364,"id":171363,"goal":"lemma ModBounds_1364(y: nat, j: nat)\n requires j > 0\n ensures 0 <= y % j < j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_1365","instance":1365,"id":171364,"goal":"lemma Square_Nonneg_1365(b: real)\n ensures b * b >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_1366","instance":1366,"id":171365,"goal":"lemma AddComm_1366(y: int, n: int)\n ensures y + n == n + y\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_1367","instance":1367,"id":171366,"goal":"lemma AddAssoc_1367(z: nat, d: nat, k: nat)\n ensures (z + d) + k == z + (d + k)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_1368","instance":1368,"id":171367,"goal":"lemma MulComm_1368(k: real, c: real)\n ensures k * c == c * k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_1369","instance":1369,"id":171368,"goal":"lemma MulAssoc_1369(a: int, b: int, z: int)\n ensures (a * b) * z == a * (b * z)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_1370","instance":1370,"id":171369,"goal":"lemma Distrib_1370(z: nat, y: nat, a: nat)\n ensures z * (y + a) == z * y + z * a\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_1371","instance":1371,"id":171370,"goal":"lemma AddZero_1371(x: real)\n ensures x + 0 == x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_1372","instance":1372,"id":171371,"goal":"lemma MulOne_1372(j: int)\n ensures j * 1 == j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_1373","instance":1373,"id":171372,"goal":"lemma MulZero_1373(x: nat)\n ensures x * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_1374","instance":1374,"id":171373,"goal":"lemma LeRefl_1374(c: real)\n ensures c <= c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_1375","instance":1375,"id":171374,"goal":"lemma LeTrans_1375(c: int, z: int, d: int)\n requires c <= z && z <= d\n ensures c <= d\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_1376","instance":1376,"id":171375,"goal":"lemma AddMono_1376(c: nat, d: nat, a: nat)\n requires c <= d\n ensures c + a <= d + a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_1377","instance":1377,"id":171376,"goal":"lemma Abs_Nonneg_1377(n: real)\n ensures (if n >= 0 then n else -n) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_1378","instance":1378,"id":171377,"goal":"lemma DivMod_1378(a: int, y: int)\n requires y > 0\n ensures a == y * (a / y) + (a % y)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_1379","instance":1379,"id":171378,"goal":"lemma ModBounds_1379(b: nat, i: nat)\n requires i > 0\n ensures 0 <= b % i < i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_1380","instance":1380,"id":171379,"goal":"lemma Square_Nonneg_1380(b: real)\n ensures b * b >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_1381","instance":1381,"id":171380,"goal":"lemma AddComm_1381(b: int, d: int)\n ensures b + d == d + b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_1382","instance":1382,"id":171381,"goal":"lemma AddAssoc_1382(j: nat, y: nat, b: nat)\n ensures (j + y) + b == j + (y + b)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_1383","instance":1383,"id":171382,"goal":"lemma MulComm_1383(i: real, m: real)\n ensures i * m == m * i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_1384","instance":1384,"id":171383,"goal":"lemma MulAssoc_1384(z: int, x: int, i: int)\n ensures (z * x) * i == z * (x * i)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_1385","instance":1385,"id":171384,"goal":"lemma Distrib_1385(a: nat, c: nat, x: nat)\n ensures a * (c + x) == a * c + a * x\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_1386","instance":1386,"id":171385,"goal":"lemma AddZero_1386(n: real)\n ensures n + 0 == n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_1387","instance":1387,"id":171386,"goal":"lemma MulOne_1387(a: int)\n ensures a * 1 == a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_1388","instance":1388,"id":171387,"goal":"lemma MulZero_1388(z: nat)\n ensures z * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_1389","instance":1389,"id":171388,"goal":"lemma LeRefl_1389(z: real)\n ensures z <= z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_1390","instance":1390,"id":171389,"goal":"lemma LeTrans_1390(y: int, j: int, d: int)\n requires y <= j && j <= d\n ensures y <= d\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_1391","instance":1391,"id":171390,"goal":"lemma AddMono_1391(i: nat, d: nat, y: nat)\n requires i <= d\n ensures i + y <= d + y\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_1392","instance":1392,"id":171391,"goal":"lemma Abs_Nonneg_1392(k: real)\n ensures (if k >= 0 then k else -k) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_1393","instance":1393,"id":171392,"goal":"lemma DivMod_1393(y: int, d: int)\n requires d > 0\n ensures y == d * (y / d) + (y % d)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_1394","instance":1394,"id":171393,"goal":"lemma ModBounds_1394(x: nat, a: nat)\n requires a > 0\n ensures 0 <= x % a < a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_1395","instance":1395,"id":171394,"goal":"lemma Square_Nonneg_1395(j: real)\n ensures j * j >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_1396","instance":1396,"id":171395,"goal":"lemma AddComm_1396(c: int, n: int)\n ensures c + n == n + c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_1397","instance":1397,"id":171396,"goal":"lemma AddAssoc_1397(y: nat, z: nat, x: nat)\n ensures (y + z) + x == y + (z + x)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_1398","instance":1398,"id":171397,"goal":"lemma MulComm_1398(m: real, n: real)\n ensures m * n == n * m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_1399","instance":1399,"id":171398,"goal":"lemma MulAssoc_1399(x: int, m: int, k: int)\n ensures (x * m) * k == x * (m * k)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_1400","instance":1400,"id":171399,"goal":"lemma Distrib_1400(b: nat, i: nat, a: nat)\n ensures b * (i + a) == b * i + b * a\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_1401","instance":1401,"id":171400,"goal":"lemma AddZero_1401(c: real)\n ensures c + 0 == c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_1402","instance":1402,"id":171401,"goal":"lemma MulOne_1402(n: int)\n ensures n * 1 == n\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_1403","instance":1403,"id":171402,"goal":"lemma MulZero_1403(y: nat)\n ensures y * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_1404","instance":1404,"id":171403,"goal":"lemma LeRefl_1404(b: real)\n ensures b <= b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_1405","instance":1405,"id":171404,"goal":"lemma LeTrans_1405(a: int, m: int, n: int)\n requires a <= m && m <= n\n ensures a <= n\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_1406","instance":1406,"id":171405,"goal":"lemma AddMono_1406(z: nat, m: nat, i: nat)\n requires z <= m\n ensures z + i <= m + i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_1407","instance":1407,"id":171406,"goal":"lemma Abs_Nonneg_1407(j: real)\n ensures (if j >= 0 then j else -j) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_1408","instance":1408,"id":171407,"goal":"lemma DivMod_1408(x: int, i: int)\n requires i > 0\n ensures x == i * (x / i) + (x % i)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_1409","instance":1409,"id":171408,"goal":"lemma ModBounds_1409(j: nat, m: nat)\n requires m > 0\n ensures 0 <= j % m < m\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_1410","instance":1410,"id":171409,"goal":"lemma Square_Nonneg_1410(m: real)\n ensures m * m >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_1411","instance":1411,"id":171410,"goal":"lemma AddComm_1411(j: int, i: int)\n ensures j + i == i + j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_1412","instance":1412,"id":171411,"goal":"lemma AddAssoc_1412(c: nat, z: nat, n: nat)\n ensures (c + z) + n == c + (z + n)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_1413","instance":1413,"id":171412,"goal":"lemma MulComm_1413(i: real, x: real)\n ensures i * x == x * i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_1414","instance":1414,"id":171413,"goal":"lemma MulAssoc_1414(b: int, a: int, n: int)\n ensures (b * a) * n == b * (a * n)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_1415","instance":1415,"id":171414,"goal":"lemma Distrib_1415(z: nat, x: nat, i: nat)\n ensures z * (x + i) == z * x + z * i\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_1416","instance":1416,"id":171415,"goal":"lemma AddZero_1416(d: real)\n ensures d + 0 == d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_1417","instance":1417,"id":171416,"goal":"lemma MulOne_1417(c: int)\n ensures c * 1 == c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_1418","instance":1418,"id":171417,"goal":"lemma MulZero_1418(x: nat)\n ensures x * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_1419","instance":1419,"id":171418,"goal":"lemma LeRefl_1419(c: real)\n ensures c <= c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_1420","instance":1420,"id":171419,"goal":"lemma LeTrans_1420(n: int, b: int, k: int)\n requires n <= b && b <= k\n ensures n <= k\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_1421","instance":1421,"id":171420,"goal":"lemma AddMono_1421(y: nat, n: nat, m: nat)\n requires y <= n\n ensures y + m <= n + m\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_1422","instance":1422,"id":171421,"goal":"lemma Abs_Nonneg_1422(c: real)\n ensures (if c >= 0 then c else -c) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_1423","instance":1423,"id":171422,"goal":"lemma DivMod_1423(j: int, b: int)\n requires b > 0\n ensures j == b * (j / b) + (j % b)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_1424","instance":1424,"id":171423,"goal":"lemma ModBounds_1424(i: nat, d: nat)\n requires d > 0\n ensures 0 <= i % d < d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_1425","instance":1425,"id":171424,"goal":"lemma Square_Nonneg_1425(c: real)\n ensures c * c >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_1426","instance":1426,"id":171425,"goal":"lemma AddComm_1426(c: int, i: int)\n ensures c + i == i + c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_1427","instance":1427,"id":171426,"goal":"lemma AddAssoc_1427(j: nat, b: nat, k: nat)\n ensures (j + b) + k == j + (b + k)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_1428","instance":1428,"id":171427,"goal":"lemma MulComm_1428(i: real, b: real)\n ensures i * b == b * i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_1429","instance":1429,"id":171428,"goal":"lemma MulAssoc_1429(j: int, k: int, b: int)\n ensures (j * k) * b == j * (k * b)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_1430","instance":1430,"id":171429,"goal":"lemma Distrib_1430(j: nat, n: nat, z: nat)\n ensures j * (n + z) == j * n + j * z\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_1431","instance":1431,"id":171430,"goal":"lemma AddZero_1431(b: real)\n ensures b + 0 == b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_1432","instance":1432,"id":171431,"goal":"lemma MulOne_1432(d: int)\n ensures d * 1 == d\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_1433","instance":1433,"id":171432,"goal":"lemma MulZero_1433(z: nat)\n ensures z * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_1434","instance":1434,"id":171433,"goal":"lemma LeRefl_1434(c: real)\n ensures c <= c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_1435","instance":1435,"id":171434,"goal":"lemma LeTrans_1435(x: int, n: int, a: int)\n requires x <= n && n <= a\n ensures x <= a\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_1436","instance":1436,"id":171435,"goal":"lemma AddMono_1436(i: nat, d: nat, j: nat)\n requires i <= d\n ensures i + j <= d + j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_1437","instance":1437,"id":171436,"goal":"lemma Abs_Nonneg_1437(x: real)\n ensures (if x >= 0 then x else -x) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_1438","instance":1438,"id":171437,"goal":"lemma DivMod_1438(z: int, i: int)\n requires i > 0\n ensures z == i * (z / i) + (z % i)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_1439","instance":1439,"id":171438,"goal":"lemma ModBounds_1439(n: nat, k: nat)\n requires k > 0\n ensures 0 <= n % k < k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_1440","instance":1440,"id":171439,"goal":"lemma Square_Nonneg_1440(k: real)\n ensures k * k >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_1441","instance":1441,"id":171440,"goal":"lemma AddComm_1441(x: int, j: int)\n ensures x + j == j + x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_1442","instance":1442,"id":171441,"goal":"lemma AddAssoc_1442(z: nat, y: nat, x: nat)\n ensures (z + y) + x == z + (y + x)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_1443","instance":1443,"id":171442,"goal":"lemma MulComm_1443(a: real, b: real)\n ensures a * b == b * a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_1444","instance":1444,"id":171443,"goal":"lemma MulAssoc_1444(y: int, b: int, k: int)\n ensures (y * b) * k == y * (b * k)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_1445","instance":1445,"id":171444,"goal":"lemma Distrib_1445(i: nat, a: nat, x: nat)\n ensures i * (a + x) == i * a + i * x\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_1446","instance":1446,"id":171445,"goal":"lemma AddZero_1446(a: real)\n ensures a + 0 == a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_1447","instance":1447,"id":171446,"goal":"lemma MulOne_1447(a: int)\n ensures a * 1 == a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_1448","instance":1448,"id":171447,"goal":"lemma MulZero_1448(a: nat)\n ensures a * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_1449","instance":1449,"id":171448,"goal":"lemma LeRefl_1449(a: real)\n ensures a <= a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_1450","instance":1450,"id":171449,"goal":"lemma LeTrans_1450(j: int, m: int, d: int)\n requires j <= m && m <= d\n ensures j <= d\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_1451","instance":1451,"id":171450,"goal":"lemma AddMono_1451(c: nat, x: nat, b: nat)\n requires c <= x\n ensures c + b <= x + b\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_1452","instance":1452,"id":171451,"goal":"lemma Abs_Nonneg_1452(x: real)\n ensures (if x >= 0 then x else -x) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_1453","instance":1453,"id":171452,"goal":"lemma DivMod_1453(i: int, a: int)\n requires a > 0\n ensures i == a * (i / a) + (i % a)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_1454","instance":1454,"id":171453,"goal":"lemma ModBounds_1454(c: nat, m: nat)\n requires m > 0\n ensures 0 <= c % m < m\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_1455","instance":1455,"id":171454,"goal":"lemma Square_Nonneg_1455(j: real)\n ensures j * j >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_1456","instance":1456,"id":171455,"goal":"lemma AddComm_1456(a: int, y: int)\n ensures a + y == y + a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_1457","instance":1457,"id":171456,"goal":"lemma AddAssoc_1457(m: nat, n: nat, i: nat)\n ensures (m + n) + i == m + (n + i)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_1458","instance":1458,"id":171457,"goal":"lemma MulComm_1458(c: real, j: real)\n ensures c * j == j * c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_1459","instance":1459,"id":171458,"goal":"lemma MulAssoc_1459(a: int, d: int, c: int)\n ensures (a * d) * c == a * (d * c)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_1460","instance":1460,"id":171459,"goal":"lemma Distrib_1460(z: nat, c: nat, m: nat)\n ensures z * (c + m) == z * c + z * m\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_1461","instance":1461,"id":171460,"goal":"lemma AddZero_1461(d: real)\n ensures d + 0 == d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_1462","instance":1462,"id":171461,"goal":"lemma MulOne_1462(y: int)\n ensures y * 1 == y\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_1463","instance":1463,"id":171462,"goal":"lemma MulZero_1463(b: nat)\n ensures b * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_1464","instance":1464,"id":171463,"goal":"lemma LeRefl_1464(z: real)\n ensures z <= z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_1465","instance":1465,"id":171464,"goal":"lemma LeTrans_1465(c: int, z: int, m: int)\n requires c <= z && z <= m\n ensures c <= m\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_1466","instance":1466,"id":171465,"goal":"lemma AddMono_1466(a: nat, m: nat, y: nat)\n requires a <= m\n ensures a + y <= m + y\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_1467","instance":1467,"id":171466,"goal":"lemma Abs_Nonneg_1467(z: real)\n ensures (if z >= 0 then z else -z) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_1468","instance":1468,"id":171467,"goal":"lemma DivMod_1468(c: int, n: int)\n requires n > 0\n ensures c == n * (c / n) + (c % n)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_1469","instance":1469,"id":171468,"goal":"lemma ModBounds_1469(y: nat, b: nat)\n requires b > 0\n ensures 0 <= y % b < b\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_1470","instance":1470,"id":171469,"goal":"lemma Square_Nonneg_1470(z: real)\n ensures z * z >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_1471","instance":1471,"id":171470,"goal":"lemma AddComm_1471(n: int, x: int)\n ensures n + x == x + n\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_1472","instance":1472,"id":171471,"goal":"lemma AddAssoc_1472(z: nat, j: nat, x: nat)\n ensures (z + j) + x == z + (j + x)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_1473","instance":1473,"id":171472,"goal":"lemma MulComm_1473(m: real, a: real)\n ensures m * a == a * m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_1474","instance":1474,"id":171473,"goal":"lemma MulAssoc_1474(j: int, c: int, y: int)\n ensures (j * c) * y == j * (c * y)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_1475","instance":1475,"id":171474,"goal":"lemma Distrib_1475(x: nat, a: nat, n: nat)\n ensures x * (a + n) == x * a + x * n\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_1476","instance":1476,"id":171475,"goal":"lemma AddZero_1476(c: real)\n ensures c + 0 == c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_1477","instance":1477,"id":171476,"goal":"lemma MulOne_1477(c: int)\n ensures c * 1 == c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_1478","instance":1478,"id":171477,"goal":"lemma MulZero_1478(m: nat)\n ensures m * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_1479","instance":1479,"id":171478,"goal":"lemma LeRefl_1479(c: real)\n ensures c <= c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_1480","instance":1480,"id":171479,"goal":"lemma LeTrans_1480(y: int, m: int, a: int)\n requires y <= m && m <= a\n ensures y <= a\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_1481","instance":1481,"id":171480,"goal":"lemma AddMono_1481(y: nat, k: nat, d: nat)\n requires y <= k\n ensures y + d <= k + d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_1482","instance":1482,"id":171481,"goal":"lemma Abs_Nonneg_1482(d: real)\n ensures (if d >= 0 then d else -d) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_1483","instance":1483,"id":171482,"goal":"lemma DivMod_1483(c: int, b: int)\n requires b > 0\n ensures c == b * (c / b) + (c % b)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_1484","instance":1484,"id":171483,"goal":"lemma ModBounds_1484(a: nat, n: nat)\n requires n > 0\n ensures 0 <= a % n < n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_1485","instance":1485,"id":171484,"goal":"lemma Square_Nonneg_1485(n: real)\n ensures n * n >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_1486","instance":1486,"id":171485,"goal":"lemma AddComm_1486(d: int, x: int)\n ensures d + x == x + d\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_1487","instance":1487,"id":171486,"goal":"lemma AddAssoc_1487(n: nat, k: nat, d: nat)\n ensures (n + k) + d == n + (k + d)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_1488","instance":1488,"id":171487,"goal":"lemma MulComm_1488(m: real, x: real)\n ensures m * x == x * m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_1489","instance":1489,"id":171488,"goal":"lemma MulAssoc_1489(b: int, a: int, y: int)\n ensures (b * a) * y == b * (a * y)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_1490","instance":1490,"id":171489,"goal":"lemma Distrib_1490(k: nat, z: nat, a: nat)\n ensures k * (z + a) == k * z + k * a\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_1491","instance":1491,"id":171490,"goal":"lemma AddZero_1491(y: real)\n ensures y + 0 == y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_1492","instance":1492,"id":171491,"goal":"lemma MulOne_1492(b: int)\n ensures b * 1 == b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_1493","instance":1493,"id":171492,"goal":"lemma MulZero_1493(i: nat)\n ensures i * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_1494","instance":1494,"id":171493,"goal":"lemma LeRefl_1494(x: real)\n ensures x <= x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_1495","instance":1495,"id":171494,"goal":"lemma LeTrans_1495(z: int, b: int, c: int)\n requires z <= b && b <= c\n ensures z <= c\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_1496","instance":1496,"id":171495,"goal":"lemma AddMono_1496(x: nat, b: nat, z: nat)\n requires x <= b\n ensures x + z <= b + z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_1497","instance":1497,"id":171496,"goal":"lemma Abs_Nonneg_1497(n: real)\n ensures (if n >= 0 then n else -n) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_1498","instance":1498,"id":171497,"goal":"lemma DivMod_1498(x: int, c: int)\n requires c > 0\n ensures x == c * (x / c) + (x % c)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_1499","instance":1499,"id":171498,"goal":"lemma ModBounds_1499(m: nat, n: nat)\n requires n > 0\n ensures 0 <= m % n < n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_1500","instance":1500,"id":171499,"goal":"lemma Square_Nonneg_1500(n: real)\n ensures n * n >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_1501","instance":1501,"id":171500,"goal":"lemma AddComm_1501(y: int, b: int)\n ensures y + b == b + y\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_1502","instance":1502,"id":171501,"goal":"lemma AddAssoc_1502(m: nat, n: nat, z: nat)\n ensures (m + n) + z == m + (n + z)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_1503","instance":1503,"id":171502,"goal":"lemma MulComm_1503(c: real, z: real)\n ensures c * z == z * c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_1504","instance":1504,"id":171503,"goal":"lemma MulAssoc_1504(y: int, m: int, z: int)\n ensures (y * m) * z == y * (m * z)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_1505","instance":1505,"id":171504,"goal":"lemma Distrib_1505(n: nat, z: nat, a: nat)\n ensures n * (z + a) == n * z + n * a\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_1506","instance":1506,"id":171505,"goal":"lemma AddZero_1506(a: real)\n ensures a + 0 == a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_1507","instance":1507,"id":171506,"goal":"lemma MulOne_1507(m: int)\n ensures m * 1 == m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_1508","instance":1508,"id":171507,"goal":"lemma MulZero_1508(x: nat)\n ensures x * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_1509","instance":1509,"id":171508,"goal":"lemma LeRefl_1509(i: real)\n ensures i <= i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_1510","instance":1510,"id":171509,"goal":"lemma LeTrans_1510(a: int, z: int, j: int)\n requires a <= z && z <= j\n ensures a <= j\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_1511","instance":1511,"id":171510,"goal":"lemma AddMono_1511(y: nat, m: nat, d: nat)\n requires y <= m\n ensures y + d <= m + d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_1512","instance":1512,"id":171511,"goal":"lemma Abs_Nonneg_1512(y: real)\n ensures (if y >= 0 then y else -y) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_1513","instance":1513,"id":171512,"goal":"lemma DivMod_1513(y: int, a: int)\n requires a > 0\n ensures y == a * (y / a) + (y % a)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_1514","instance":1514,"id":171513,"goal":"lemma ModBounds_1514(c: nat, j: nat)\n requires j > 0\n ensures 0 <= c % j < j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_1515","instance":1515,"id":171514,"goal":"lemma Square_Nonneg_1515(c: real)\n ensures c * c >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_1516","instance":1516,"id":171515,"goal":"lemma AddComm_1516(j: int, x: int)\n ensures j + x == x + j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_1517","instance":1517,"id":171516,"goal":"lemma AddAssoc_1517(i: nat, y: nat, a: nat)\n ensures (i + y) + a == i + (y + a)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_1518","instance":1518,"id":171517,"goal":"lemma MulComm_1518(c: real, i: real)\n ensures c * i == i * c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_1519","instance":1519,"id":171518,"goal":"lemma MulAssoc_1519(n: int, d: int, i: int)\n ensures (n * d) * i == n * (d * i)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_1520","instance":1520,"id":171519,"goal":"lemma Distrib_1520(n: nat, c: nat, y: nat)\n ensures n * (c + y) == n * c + n * y\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_1521","instance":1521,"id":171520,"goal":"lemma AddZero_1521(c: real)\n ensures c + 0 == c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_1522","instance":1522,"id":171521,"goal":"lemma MulOne_1522(d: int)\n ensures d * 1 == d\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_1523","instance":1523,"id":171522,"goal":"lemma MulZero_1523(x: nat)\n ensures x * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_1524","instance":1524,"id":171523,"goal":"lemma LeRefl_1524(m: real)\n ensures m <= m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_1525","instance":1525,"id":171524,"goal":"lemma LeTrans_1525(k: int, c: int, j: int)\n requires k <= c && c <= j\n ensures k <= j\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_1526","instance":1526,"id":171525,"goal":"lemma AddMono_1526(n: nat, c: nat, a: nat)\n requires n <= c\n ensures n + a <= c + a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_1527","instance":1527,"id":171526,"goal":"lemma Abs_Nonneg_1527(b: real)\n ensures (if b >= 0 then b else -b) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_1528","instance":1528,"id":171527,"goal":"lemma DivMod_1528(j: int, c: int)\n requires c > 0\n ensures j == c * (j / c) + (j % c)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_1529","instance":1529,"id":171528,"goal":"lemma ModBounds_1529(j: nat, m: nat)\n requires m > 0\n ensures 0 <= j % m < m\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_1530","instance":1530,"id":171529,"goal":"lemma Square_Nonneg_1530(y: real)\n ensures y * y >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_1531","instance":1531,"id":171530,"goal":"lemma AddComm_1531(x: int, c: int)\n ensures x + c == c + x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_1532","instance":1532,"id":171531,"goal":"lemma AddAssoc_1532(n: nat, a: nat, d: nat)\n ensures (n + a) + d == n + (a + d)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_1533","instance":1533,"id":171532,"goal":"lemma MulComm_1533(x: real, y: real)\n ensures x * y == y * x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_1534","instance":1534,"id":171533,"goal":"lemma MulAssoc_1534(n: int, x: int, a: int)\n ensures (n * x) * a == n * (x * a)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_1535","instance":1535,"id":171534,"goal":"lemma Distrib_1535(a: nat, z: nat, i: nat)\n ensures a * (z + i) == a * z + a * i\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_1536","instance":1536,"id":171535,"goal":"lemma AddZero_1536(a: real)\n ensures a + 0 == a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_1537","instance":1537,"id":171536,"goal":"lemma MulOne_1537(b: int)\n ensures b * 1 == b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_1538","instance":1538,"id":171537,"goal":"lemma MulZero_1538(c: nat)\n ensures c * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_1539","instance":1539,"id":171538,"goal":"lemma LeRefl_1539(a: real)\n ensures a <= a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_1540","instance":1540,"id":171539,"goal":"lemma LeTrans_1540(c: int, i: int, a: int)\n requires c <= i && i <= a\n ensures c <= a\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_1541","instance":1541,"id":171540,"goal":"lemma AddMono_1541(m: nat, c: nat, j: nat)\n requires m <= c\n ensures m + j <= c + j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_1542","instance":1542,"id":171541,"goal":"lemma Abs_Nonneg_1542(d: real)\n ensures (if d >= 0 then d else -d) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_1543","instance":1543,"id":171542,"goal":"lemma DivMod_1543(i: int, d: int)\n requires d > 0\n ensures i == d * (i / d) + (i % d)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_1544","instance":1544,"id":171543,"goal":"lemma ModBounds_1544(i: nat, j: nat)\n requires j > 0\n ensures 0 <= i % j < j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_1545","instance":1545,"id":171544,"goal":"lemma Square_Nonneg_1545(a: real)\n ensures a * a >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_1546","instance":1546,"id":171545,"goal":"lemma AddComm_1546(x: int, n: int)\n ensures x + n == n + x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_1547","instance":1547,"id":171546,"goal":"lemma AddAssoc_1547(k: nat, y: nat, a: nat)\n ensures (k + y) + a == k + (y + a)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_1548","instance":1548,"id":171547,"goal":"lemma MulComm_1548(k: real, d: real)\n ensures k * d == d * k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_1549","instance":1549,"id":171548,"goal":"lemma MulAssoc_1549(c: int, k: int, d: int)\n ensures (c * k) * d == c * (k * d)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_1550","instance":1550,"id":171549,"goal":"lemma Distrib_1550(y: nat, n: nat, c: nat)\n ensures y * (n + c) == y * n + y * c\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_1551","instance":1551,"id":171550,"goal":"lemma AddZero_1551(n: real)\n ensures n + 0 == n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_1552","instance":1552,"id":171551,"goal":"lemma MulOne_1552(d: int)\n ensures d * 1 == d\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_1553","instance":1553,"id":171552,"goal":"lemma MulZero_1553(d: nat)\n ensures d * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_1554","instance":1554,"id":171553,"goal":"lemma LeRefl_1554(c: real)\n ensures c <= c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_1555","instance":1555,"id":171554,"goal":"lemma LeTrans_1555(z: int, k: int, n: int)\n requires z <= k && k <= n\n ensures z <= n\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_1556","instance":1556,"id":171555,"goal":"lemma AddMono_1556(j: nat, d: nat, n: nat)\n requires j <= d\n ensures j + n <= d + n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_1557","instance":1557,"id":171556,"goal":"lemma Abs_Nonneg_1557(n: real)\n ensures (if n >= 0 then n else -n) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_1558","instance":1558,"id":171557,"goal":"lemma DivMod_1558(j: int, i: int)\n requires i > 0\n ensures j == i * (j / i) + (j % i)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_1559","instance":1559,"id":171558,"goal":"lemma ModBounds_1559(x: nat, n: nat)\n requires n > 0\n ensures 0 <= x % n < n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_1560","instance":1560,"id":171559,"goal":"lemma Square_Nonneg_1560(z: real)\n ensures z * z >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_1561","instance":1561,"id":171560,"goal":"lemma AddComm_1561(a: int, j: int)\n ensures a + j == j + a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_1562","instance":1562,"id":171561,"goal":"lemma AddAssoc_1562(x: nat, y: nat, d: nat)\n ensures (x + y) + d == x + (y + d)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_1563","instance":1563,"id":171562,"goal":"lemma MulComm_1563(i: real, b: real)\n ensures i * b == b * i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_1564","instance":1564,"id":171563,"goal":"lemma MulAssoc_1564(d: int, n: int, z: int)\n ensures (d * n) * z == d * (n * z)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_1565","instance":1565,"id":171564,"goal":"lemma Distrib_1565(i: nat, y: nat, x: nat)\n ensures i * (y + x) == i * y + i * x\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_1566","instance":1566,"id":171565,"goal":"lemma AddZero_1566(d: real)\n ensures d + 0 == d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_1567","instance":1567,"id":171566,"goal":"lemma MulOne_1567(x: int)\n ensures x * 1 == x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_1568","instance":1568,"id":171567,"goal":"lemma MulZero_1568(n: nat)\n ensures n * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_1569","instance":1569,"id":171568,"goal":"lemma LeRefl_1569(b: real)\n ensures b <= b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_1570","instance":1570,"id":171569,"goal":"lemma LeTrans_1570(d: int, z: int, a: int)\n requires d <= z && z <= a\n ensures d <= a\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_1571","instance":1571,"id":171570,"goal":"lemma AddMono_1571(y: nat, z: nat, a: nat)\n requires y <= z\n ensures y + a <= z + a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_1572","instance":1572,"id":171571,"goal":"lemma Abs_Nonneg_1572(b: real)\n ensures (if b >= 0 then b else -b) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_1573","instance":1573,"id":171572,"goal":"lemma DivMod_1573(z: int, n: int)\n requires n > 0\n ensures z == n * (z / n) + (z % n)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_1574","instance":1574,"id":171573,"goal":"lemma ModBounds_1574(c: nat, x: nat)\n requires x > 0\n ensures 0 <= c % x < x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_1575","instance":1575,"id":171574,"goal":"lemma Square_Nonneg_1575(j: real)\n ensures j * j >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_1576","instance":1576,"id":171575,"goal":"lemma AddComm_1576(a: int, j: int)\n ensures a + j == j + a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_1577","instance":1577,"id":171576,"goal":"lemma AddAssoc_1577(m: nat, c: nat, i: nat)\n ensures (m + c) + i == m + (c + i)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_1578","instance":1578,"id":171577,"goal":"lemma MulComm_1578(m: real, n: real)\n ensures m * n == n * m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_1579","instance":1579,"id":171578,"goal":"lemma MulAssoc_1579(c: int, k: int, z: int)\n ensures (c * k) * z == c * (k * z)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_1580","instance":1580,"id":171579,"goal":"lemma Distrib_1580(d: nat, x: nat, n: nat)\n ensures d * (x + n) == d * x + d * n\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_1581","instance":1581,"id":171580,"goal":"lemma AddZero_1581(a: real)\n ensures a + 0 == a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_1582","instance":1582,"id":171581,"goal":"lemma MulOne_1582(d: int)\n ensures d * 1 == d\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_1583","instance":1583,"id":171582,"goal":"lemma MulZero_1583(n: nat)\n ensures n * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_1584","instance":1584,"id":171583,"goal":"lemma LeRefl_1584(n: real)\n ensures n <= n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_1585","instance":1585,"id":171584,"goal":"lemma LeTrans_1585(x: int, a: int, z: int)\n requires x <= a && a <= z\n ensures x <= z\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_1586","instance":1586,"id":171585,"goal":"lemma AddMono_1586(n: nat, b: nat, a: nat)\n requires n <= b\n ensures n + a <= b + a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_1587","instance":1587,"id":171586,"goal":"lemma Abs_Nonneg_1587(c: real)\n ensures (if c >= 0 then c else -c) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_1588","instance":1588,"id":171587,"goal":"lemma DivMod_1588(n: int, k: int)\n requires k > 0\n ensures n == k * (n / k) + (n % k)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_1589","instance":1589,"id":171588,"goal":"lemma ModBounds_1589(i: nat, d: nat)\n requires d > 0\n ensures 0 <= i % d < d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_1590","instance":1590,"id":171589,"goal":"lemma Square_Nonneg_1590(m: real)\n ensures m * m >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_1591","instance":1591,"id":171590,"goal":"lemma AddComm_1591(y: int, d: int)\n ensures y + d == d + y\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_1592","instance":1592,"id":171591,"goal":"lemma AddAssoc_1592(z: nat, j: nat, i: nat)\n ensures (z + j) + i == z + (j + i)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_1593","instance":1593,"id":171592,"goal":"lemma MulComm_1593(n: real, a: real)\n ensures n * a == a * n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_1594","instance":1594,"id":171593,"goal":"lemma MulAssoc_1594(x: int, m: int, a: int)\n ensures (x * m) * a == x * (m * a)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_1595","instance":1595,"id":171594,"goal":"lemma Distrib_1595(d: nat, b: nat, m: nat)\n ensures d * (b + m) == d * b + d * m\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_1596","instance":1596,"id":171595,"goal":"lemma AddZero_1596(m: real)\n ensures m + 0 == m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_1597","instance":1597,"id":171596,"goal":"lemma MulOne_1597(d: int)\n ensures d * 1 == d\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_1598","instance":1598,"id":171597,"goal":"lemma MulZero_1598(a: nat)\n ensures a * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_1599","instance":1599,"id":171598,"goal":"lemma LeRefl_1599(b: real)\n ensures b <= b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_1600","instance":1600,"id":171599,"goal":"lemma LeTrans_1600(b: int, a: int, m: int)\n requires b <= a && a <= m\n ensures b <= m\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_1601","instance":1601,"id":171600,"goal":"lemma AddMono_1601(m: nat, b: nat, a: nat)\n requires m <= b\n ensures m + a <= b + a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_1602","instance":1602,"id":171601,"goal":"lemma Abs_Nonneg_1602(j: real)\n ensures (if j >= 0 then j else -j) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_1603","instance":1603,"id":171602,"goal":"lemma DivMod_1603(k: int, m: int)\n requires m > 0\n ensures k == m * (k / m) + (k % m)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_1604","instance":1604,"id":171603,"goal":"lemma ModBounds_1604(b: nat, k: nat)\n requires k > 0\n ensures 0 <= b % k < k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_1605","instance":1605,"id":171604,"goal":"lemma Square_Nonneg_1605(j: real)\n ensures j * j >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_1606","instance":1606,"id":171605,"goal":"lemma AddComm_1606(j: int, k: int)\n ensures j + k == k + j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_1607","instance":1607,"id":171606,"goal":"lemma AddAssoc_1607(n: nat, k: nat, x: nat)\n ensures (n + k) + x == n + (k + x)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_1608","instance":1608,"id":171607,"goal":"lemma MulComm_1608(a: real, y: real)\n ensures a * y == y * a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_1609","instance":1609,"id":171608,"goal":"lemma MulAssoc_1609(i: int, a: int, d: int)\n ensures (i * a) * d == i * (a * d)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_1610","instance":1610,"id":171609,"goal":"lemma Distrib_1610(n: nat, j: nat, m: nat)\n ensures n * (j + m) == n * j + n * m\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_1611","instance":1611,"id":171610,"goal":"lemma AddZero_1611(n: real)\n ensures n + 0 == n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_1612","instance":1612,"id":171611,"goal":"lemma MulOne_1612(k: int)\n ensures k * 1 == k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_1613","instance":1613,"id":171612,"goal":"lemma MulZero_1613(i: nat)\n ensures i * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_1614","instance":1614,"id":171613,"goal":"lemma LeRefl_1614(x: real)\n ensures x <= x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_1615","instance":1615,"id":171614,"goal":"lemma LeTrans_1615(j: int, n: int, i: int)\n requires j <= n && n <= i\n ensures j <= i\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_1616","instance":1616,"id":171615,"goal":"lemma AddMono_1616(c: nat, y: nat, n: nat)\n requires c <= y\n ensures c + n <= y + n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_1617","instance":1617,"id":171616,"goal":"lemma Abs_Nonneg_1617(m: real)\n ensures (if m >= 0 then m else -m) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_1618","instance":1618,"id":171617,"goal":"lemma DivMod_1618(a: int, d: int)\n requires d > 0\n ensures a == d * (a / d) + (a % d)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_1619","instance":1619,"id":171618,"goal":"lemma ModBounds_1619(m: nat, b: nat)\n requires b > 0\n ensures 0 <= m % b < b\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_1620","instance":1620,"id":171619,"goal":"lemma Square_Nonneg_1620(n: real)\n ensures n * n >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_1621","instance":1621,"id":171620,"goal":"lemma AddComm_1621(x: int, y: int)\n ensures x + y == y + x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_1622","instance":1622,"id":171621,"goal":"lemma AddAssoc_1622(b: nat, d: nat, y: nat)\n ensures (b + d) + y == b + (d + y)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_1623","instance":1623,"id":171622,"goal":"lemma MulComm_1623(b: real, y: real)\n ensures b * y == y * b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_1624","instance":1624,"id":171623,"goal":"lemma MulAssoc_1624(a: int, i: int, m: int)\n ensures (a * i) * m == a * (i * m)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_1625","instance":1625,"id":171624,"goal":"lemma Distrib_1625(a: nat, b: nat, m: nat)\n ensures a * (b + m) == a * b + a * m\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_1626","instance":1626,"id":171625,"goal":"lemma AddZero_1626(n: real)\n ensures n + 0 == n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_1627","instance":1627,"id":171626,"goal":"lemma MulOne_1627(c: int)\n ensures c * 1 == c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_1628","instance":1628,"id":171627,"goal":"lemma MulZero_1628(d: nat)\n ensures d * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_1629","instance":1629,"id":171628,"goal":"lemma LeRefl_1629(c: real)\n ensures c <= c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_1630","instance":1630,"id":171629,"goal":"lemma LeTrans_1630(d: int, j: int, n: int)\n requires d <= j && j <= n\n ensures d <= n\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_1631","instance":1631,"id":171630,"goal":"lemma AddMono_1631(i: nat, j: nat, c: nat)\n requires i <= j\n ensures i + c <= j + c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_1632","instance":1632,"id":171631,"goal":"lemma Abs_Nonneg_1632(i: real)\n ensures (if i >= 0 then i else -i) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_1633","instance":1633,"id":171632,"goal":"lemma DivMod_1633(y: int, j: int)\n requires j > 0\n ensures y == j * (y / j) + (y % j)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_1634","instance":1634,"id":171633,"goal":"lemma ModBounds_1634(z: nat, c: nat)\n requires c > 0\n ensures 0 <= z % c < c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_1635","instance":1635,"id":171634,"goal":"lemma Square_Nonneg_1635(a: real)\n ensures a * a >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_1636","instance":1636,"id":171635,"goal":"lemma AddComm_1636(x: int, z: int)\n ensures x + z == z + x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_1637","instance":1637,"id":171636,"goal":"lemma AddAssoc_1637(n: nat, y: nat, j: nat)\n ensures (n + y) + j == n + (y + j)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_1638","instance":1638,"id":171637,"goal":"lemma MulComm_1638(j: real, m: real)\n ensures j * m == m * j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_1639","instance":1639,"id":171638,"goal":"lemma MulAssoc_1639(c: int, z: int, y: int)\n ensures (c * z) * y == c * (z * y)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_1640","instance":1640,"id":171639,"goal":"lemma Distrib_1640(y: nat, d: nat, z: nat)\n ensures y * (d + z) == y * d + y * z\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_1641","instance":1641,"id":171640,"goal":"lemma AddZero_1641(j: real)\n ensures j + 0 == j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_1642","instance":1642,"id":171641,"goal":"lemma MulOne_1642(b: int)\n ensures b * 1 == b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_1643","instance":1643,"id":171642,"goal":"lemma MulZero_1643(a: nat)\n ensures a * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_1644","instance":1644,"id":171643,"goal":"lemma LeRefl_1644(d: real)\n ensures d <= d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_1645","instance":1645,"id":171644,"goal":"lemma LeTrans_1645(m: int, y: int, x: int)\n requires m <= y && y <= x\n ensures m <= x\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_1646","instance":1646,"id":171645,"goal":"lemma AddMono_1646(b: nat, k: nat, c: nat)\n requires b <= k\n ensures b + c <= k + c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_1647","instance":1647,"id":171646,"goal":"lemma Abs_Nonneg_1647(k: real)\n ensures (if k >= 0 then k else -k) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_1648","instance":1648,"id":171647,"goal":"lemma DivMod_1648(c: int, z: int)\n requires z > 0\n ensures c == z * (c / z) + (c % z)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_1649","instance":1649,"id":171648,"goal":"lemma ModBounds_1649(a: nat, z: nat)\n requires z > 0\n ensures 0 <= a % z < z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_1650","instance":1650,"id":171649,"goal":"lemma Square_Nonneg_1650(a: real)\n ensures a * a >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_1651","instance":1651,"id":171650,"goal":"lemma AddComm_1651(x: int, j: int)\n ensures x + j == j + x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_1652","instance":1652,"id":171651,"goal":"lemma AddAssoc_1652(x: nat, a: nat, y: nat)\n ensures (x + a) + y == x + (a + y)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_1653","instance":1653,"id":171652,"goal":"lemma MulComm_1653(y: real, d: real)\n ensures y * d == d * y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_1654","instance":1654,"id":171653,"goal":"lemma MulAssoc_1654(m: int, i: int, k: int)\n ensures (m * i) * k == m * (i * k)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_1655","instance":1655,"id":171654,"goal":"lemma Distrib_1655(d: nat, c: nat, x: nat)\n ensures d * (c + x) == d * c + d * x\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_1656","instance":1656,"id":171655,"goal":"lemma AddZero_1656(y: real)\n ensures y + 0 == y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_1657","instance":1657,"id":171656,"goal":"lemma MulOne_1657(n: int)\n ensures n * 1 == n\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_1658","instance":1658,"id":171657,"goal":"lemma MulZero_1658(j: nat)\n ensures j * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_1659","instance":1659,"id":171658,"goal":"lemma LeRefl_1659(j: real)\n ensures j <= j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_1660","instance":1660,"id":171659,"goal":"lemma LeTrans_1660(x: int, c: int, m: int)\n requires x <= c && c <= m\n ensures x <= m\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_1661","instance":1661,"id":171660,"goal":"lemma AddMono_1661(b: nat, n: nat, j: nat)\n requires b <= n\n ensures b + j <= n + j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_1662","instance":1662,"id":171661,"goal":"lemma Abs_Nonneg_1662(a: real)\n ensures (if a >= 0 then a else -a) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_1663","instance":1663,"id":171662,"goal":"lemma DivMod_1663(x: int, m: int)\n requires m > 0\n ensures x == m * (x / m) + (x % m)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_1664","instance":1664,"id":171663,"goal":"lemma ModBounds_1664(n: nat, j: nat)\n requires j > 0\n ensures 0 <= n % j < j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_1665","instance":1665,"id":171664,"goal":"lemma Square_Nonneg_1665(c: real)\n ensures c * c >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_1666","instance":1666,"id":171665,"goal":"lemma AddComm_1666(i: int, a: int)\n ensures i + a == a + i\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_1667","instance":1667,"id":171666,"goal":"lemma AddAssoc_1667(b: nat, z: nat, k: nat)\n ensures (b + z) + k == b + (z + k)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_1668","instance":1668,"id":171667,"goal":"lemma MulComm_1668(b: real, k: real)\n ensures b * k == k * b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_1669","instance":1669,"id":171668,"goal":"lemma MulAssoc_1669(i: int, d: int, m: int)\n ensures (i * d) * m == i * (d * m)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_1670","instance":1670,"id":171669,"goal":"lemma Distrib_1670(x: nat, c: nat, z: nat)\n ensures x * (c + z) == x * c + x * z\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_1671","instance":1671,"id":171670,"goal":"lemma AddZero_1671(z: real)\n ensures z + 0 == z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_1672","instance":1672,"id":171671,"goal":"lemma MulOne_1672(x: int)\n ensures x * 1 == x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_1673","instance":1673,"id":171672,"goal":"lemma MulZero_1673(n: nat)\n ensures n * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_1674","instance":1674,"id":171673,"goal":"lemma LeRefl_1674(i: real)\n ensures i <= i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_1675","instance":1675,"id":171674,"goal":"lemma LeTrans_1675(y: int, x: int, a: int)\n requires y <= x && x <= a\n ensures y <= a\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_1676","instance":1676,"id":171675,"goal":"lemma AddMono_1676(y: nat, d: nat, z: nat)\n requires y <= d\n ensures y + z <= d + z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_1677","instance":1677,"id":171676,"goal":"lemma Abs_Nonneg_1677(n: real)\n ensures (if n >= 0 then n else -n) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_1678","instance":1678,"id":171677,"goal":"lemma DivMod_1678(k: int, c: int)\n requires c > 0\n ensures k == c * (k / c) + (k % c)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_1679","instance":1679,"id":171678,"goal":"lemma ModBounds_1679(i: nat, k: nat)\n requires k > 0\n ensures 0 <= i % k < k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_1680","instance":1680,"id":171679,"goal":"lemma Square_Nonneg_1680(n: real)\n ensures n * n >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_1681","instance":1681,"id":171680,"goal":"lemma AddComm_1681(c: int, y: int)\n ensures c + y == y + c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_1682","instance":1682,"id":171681,"goal":"lemma AddAssoc_1682(b: nat, a: nat, z: nat)\n ensures (b + a) + z == b + (a + z)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_1683","instance":1683,"id":171682,"goal":"lemma MulComm_1683(j: real, c: real)\n ensures j * c == c * j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_1684","instance":1684,"id":171683,"goal":"lemma MulAssoc_1684(j: int, m: int, n: int)\n ensures (j * m) * n == j * (m * n)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_1685","instance":1685,"id":171684,"goal":"lemma Distrib_1685(x: nat, i: nat, c: nat)\n ensures x * (i + c) == x * i + x * c\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_1686","instance":1686,"id":171685,"goal":"lemma AddZero_1686(a: real)\n ensures a + 0 == a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_1687","instance":1687,"id":171686,"goal":"lemma MulOne_1687(k: int)\n ensures k * 1 == k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_1688","instance":1688,"id":171687,"goal":"lemma MulZero_1688(n: nat)\n ensures n * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_1689","instance":1689,"id":171688,"goal":"lemma LeRefl_1689(y: real)\n ensures y <= y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_1690","instance":1690,"id":171689,"goal":"lemma LeTrans_1690(d: int, y: int, x: int)\n requires d <= y && y <= x\n ensures d <= x\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_1691","instance":1691,"id":171690,"goal":"lemma AddMono_1691(n: nat, b: nat, j: nat)\n requires n <= b\n ensures n + j <= b + j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_1692","instance":1692,"id":171691,"goal":"lemma Abs_Nonneg_1692(y: real)\n ensures (if y >= 0 then y else -y) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_1693","instance":1693,"id":171692,"goal":"lemma DivMod_1693(d: int, j: int)\n requires j > 0\n ensures d == j * (d / j) + (d % j)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_1694","instance":1694,"id":171693,"goal":"lemma ModBounds_1694(m: nat, x: nat)\n requires x > 0\n ensures 0 <= m % x < x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_1695","instance":1695,"id":171694,"goal":"lemma Square_Nonneg_1695(m: real)\n ensures m * m >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_1696","instance":1696,"id":171695,"goal":"lemma AddComm_1696(y: int, d: int)\n ensures y + d == d + y\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_1697","instance":1697,"id":171696,"goal":"lemma AddAssoc_1697(k: nat, b: nat, j: nat)\n ensures (k + b) + j == k + (b + j)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_1698","instance":1698,"id":171697,"goal":"lemma MulComm_1698(a: real, i: real)\n ensures a * i == i * a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_1699","instance":1699,"id":171698,"goal":"lemma MulAssoc_1699(b: int, x: int, z: int)\n ensures (b * x) * z == b * (x * z)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_1700","instance":1700,"id":171699,"goal":"lemma Distrib_1700(x: nat, k: nat, y: nat)\n ensures x * (k + y) == x * k + x * y\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_1701","instance":1701,"id":171700,"goal":"lemma AddZero_1701(j: real)\n ensures j + 0 == j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_1702","instance":1702,"id":171701,"goal":"lemma MulOne_1702(b: int)\n ensures b * 1 == b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_1703","instance":1703,"id":171702,"goal":"lemma MulZero_1703(d: nat)\n ensures d * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_1704","instance":1704,"id":171703,"goal":"lemma LeRefl_1704(j: real)\n ensures j <= j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_1705","instance":1705,"id":171704,"goal":"lemma LeTrans_1705(y: int, k: int, i: int)\n requires y <= k && k <= i\n ensures y <= i\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_1706","instance":1706,"id":171705,"goal":"lemma AddMono_1706(b: nat, j: nat, d: nat)\n requires b <= j\n ensures b + d <= j + d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_1707","instance":1707,"id":171706,"goal":"lemma Abs_Nonneg_1707(z: real)\n ensures (if z >= 0 then z else -z) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_1708","instance":1708,"id":171707,"goal":"lemma DivMod_1708(n: int, x: int)\n requires x > 0\n ensures n == x * (n / x) + (n % x)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_1709","instance":1709,"id":171708,"goal":"lemma ModBounds_1709(b: nat, a: nat)\n requires a > 0\n ensures 0 <= b % a < a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_1710","instance":1710,"id":171709,"goal":"lemma Square_Nonneg_1710(m: real)\n ensures m * m >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_1711","instance":1711,"id":171710,"goal":"lemma AddComm_1711(k: int, n: int)\n ensures k + n == n + k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_1712","instance":1712,"id":171711,"goal":"lemma AddAssoc_1712(i: nat, j: nat, n: nat)\n ensures (i + j) + n == i + (j + n)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_1713","instance":1713,"id":171712,"goal":"lemma MulComm_1713(k: real, a: real)\n ensures k * a == a * k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_1714","instance":1714,"id":171713,"goal":"lemma MulAssoc_1714(x: int, a: int, m: int)\n ensures (x * a) * m == x * (a * m)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_1715","instance":1715,"id":171714,"goal":"lemma Distrib_1715(c: nat, d: nat, x: nat)\n ensures c * (d + x) == c * d + c * x\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_1716","instance":1716,"id":171715,"goal":"lemma AddZero_1716(i: real)\n ensures i + 0 == i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_1717","instance":1717,"id":171716,"goal":"lemma MulOne_1717(n: int)\n ensures n * 1 == n\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_1718","instance":1718,"id":171717,"goal":"lemma MulZero_1718(k: nat)\n ensures k * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_1719","instance":1719,"id":171718,"goal":"lemma LeRefl_1719(a: real)\n ensures a <= a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_1720","instance":1720,"id":171719,"goal":"lemma LeTrans_1720(b: int, a: int, y: int)\n requires b <= a && a <= y\n ensures b <= y\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_1721","instance":1721,"id":171720,"goal":"lemma AddMono_1721(d: nat, m: nat, x: nat)\n requires d <= m\n ensures d + x <= m + x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_1722","instance":1722,"id":171721,"goal":"lemma Abs_Nonneg_1722(j: real)\n ensures (if j >= 0 then j else -j) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_1723","instance":1723,"id":171722,"goal":"lemma DivMod_1723(i: int, c: int)\n requires c > 0\n ensures i == c * (i / c) + (i % c)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_1724","instance":1724,"id":171723,"goal":"lemma ModBounds_1724(n: nat, a: nat)\n requires a > 0\n ensures 0 <= n % a < a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_1725","instance":1725,"id":171724,"goal":"lemma Square_Nonneg_1725(j: real)\n ensures j * j >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_1726","instance":1726,"id":171725,"goal":"lemma AddComm_1726(i: int, z: int)\n ensures i + z == z + i\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_1727","instance":1727,"id":171726,"goal":"lemma AddAssoc_1727(a: nat, b: nat, j: nat)\n ensures (a + b) + j == a + (b + j)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_1728","instance":1728,"id":171727,"goal":"lemma MulComm_1728(a: real, k: real)\n ensures a * k == k * a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_1729","instance":1729,"id":171728,"goal":"lemma MulAssoc_1729(k: int, j: int, c: int)\n ensures (k * j) * c == k * (j * c)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_1730","instance":1730,"id":171729,"goal":"lemma Distrib_1730(k: nat, d: nat, a: nat)\n ensures k * (d + a) == k * d + k * a\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_1731","instance":1731,"id":171730,"goal":"lemma AddZero_1731(j: real)\n ensures j + 0 == j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_1732","instance":1732,"id":171731,"goal":"lemma MulOne_1732(j: int)\n ensures j * 1 == j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_1733","instance":1733,"id":171732,"goal":"lemma MulZero_1733(j: nat)\n ensures j * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_1734","instance":1734,"id":171733,"goal":"lemma LeRefl_1734(c: real)\n ensures c <= c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_1735","instance":1735,"id":171734,"goal":"lemma LeTrans_1735(n: int, z: int, x: int)\n requires n <= z && z <= x\n ensures n <= x\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_1736","instance":1736,"id":171735,"goal":"lemma AddMono_1736(j: nat, y: nat, n: nat)\n requires j <= y\n ensures j + n <= y + n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_1737","instance":1737,"id":171736,"goal":"lemma Abs_Nonneg_1737(x: real)\n ensures (if x >= 0 then x else -x) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_1738","instance":1738,"id":171737,"goal":"lemma DivMod_1738(a: int, k: int)\n requires k > 0\n ensures a == k * (a / k) + (a % k)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_1739","instance":1739,"id":171738,"goal":"lemma ModBounds_1739(b: nat, j: nat)\n requires j > 0\n ensures 0 <= b % j < j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_1740","instance":1740,"id":171739,"goal":"lemma Square_Nonneg_1740(i: real)\n ensures i * i >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_1741","instance":1741,"id":171740,"goal":"lemma AddComm_1741(j: int, d: int)\n ensures j + d == d + j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_1742","instance":1742,"id":171741,"goal":"lemma AddAssoc_1742(i: nat, x: nat, y: nat)\n ensures (i + x) + y == i + (x + y)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_1743","instance":1743,"id":171742,"goal":"lemma MulComm_1743(c: real, x: real)\n ensures c * x == x * c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_1744","instance":1744,"id":171743,"goal":"lemma MulAssoc_1744(a: int, y: int, b: int)\n ensures (a * y) * b == a * (y * b)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_1745","instance":1745,"id":171744,"goal":"lemma Distrib_1745(n: nat, m: nat, y: nat)\n ensures n * (m + y) == n * m + n * y\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_1746","instance":1746,"id":171745,"goal":"lemma AddZero_1746(z: real)\n ensures z + 0 == z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_1747","instance":1747,"id":171746,"goal":"lemma MulOne_1747(a: int)\n ensures a * 1 == a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_1748","instance":1748,"id":171747,"goal":"lemma MulZero_1748(n: nat)\n ensures n * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_1749","instance":1749,"id":171748,"goal":"lemma LeRefl_1749(n: real)\n ensures n <= n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_1750","instance":1750,"id":171749,"goal":"lemma LeTrans_1750(d: int, i: int, a: int)\n requires d <= i && i <= a\n ensures d <= a\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_1751","instance":1751,"id":171750,"goal":"lemma AddMono_1751(m: nat, y: nat, n: nat)\n requires m <= y\n ensures m + n <= y + n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_1752","instance":1752,"id":171751,"goal":"lemma Abs_Nonneg_1752(b: real)\n ensures (if b >= 0 then b else -b) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_1753","instance":1753,"id":171752,"goal":"lemma DivMod_1753(k: int, j: int)\n requires j > 0\n ensures k == j * (k / j) + (k % j)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_1754","instance":1754,"id":171753,"goal":"lemma ModBounds_1754(y: nat, k: nat)\n requires k > 0\n ensures 0 <= y % k < k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_1755","instance":1755,"id":171754,"goal":"lemma Square_Nonneg_1755(y: real)\n ensures y * y >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_1756","instance":1756,"id":171755,"goal":"lemma AddComm_1756(a: int, x: int)\n ensures a + x == x + a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_1757","instance":1757,"id":171756,"goal":"lemma AddAssoc_1757(z: nat, c: nat, k: nat)\n ensures (z + c) + k == z + (c + k)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_1758","instance":1758,"id":171757,"goal":"lemma MulComm_1758(i: real, b: real)\n ensures i * b == b * i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_1759","instance":1759,"id":171758,"goal":"lemma MulAssoc_1759(b: int, m: int, n: int)\n ensures (b * m) * n == b * (m * n)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_1760","instance":1760,"id":171759,"goal":"lemma Distrib_1760(y: nat, i: nat, m: nat)\n ensures y * (i + m) == y * i + y * m\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_1761","instance":1761,"id":171760,"goal":"lemma AddZero_1761(a: real)\n ensures a + 0 == a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_1762","instance":1762,"id":171761,"goal":"lemma MulOne_1762(y: int)\n ensures y * 1 == y\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_1763","instance":1763,"id":171762,"goal":"lemma MulZero_1763(a: nat)\n ensures a * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_1764","instance":1764,"id":171763,"goal":"lemma LeRefl_1764(b: real)\n ensures b <= b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_1765","instance":1765,"id":171764,"goal":"lemma LeTrans_1765(a: int, i: int, x: int)\n requires a <= i && i <= x\n ensures a <= x\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_1766","instance":1766,"id":171765,"goal":"lemma AddMono_1766(d: nat, y: nat, n: nat)\n requires d <= y\n ensures d + n <= y + n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_1767","instance":1767,"id":171766,"goal":"lemma Abs_Nonneg_1767(z: real)\n ensures (if z >= 0 then z else -z) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_1768","instance":1768,"id":171767,"goal":"lemma DivMod_1768(y: int, a: int)\n requires a > 0\n ensures y == a * (y / a) + (y % a)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_1769","instance":1769,"id":171768,"goal":"lemma ModBounds_1769(n: nat, j: nat)\n requires j > 0\n ensures 0 <= n % j < j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_1770","instance":1770,"id":171769,"goal":"lemma Square_Nonneg_1770(c: real)\n ensures c * c >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_1771","instance":1771,"id":171770,"goal":"lemma AddComm_1771(a: int, i: int)\n ensures a + i == i + a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_1772","instance":1772,"id":171771,"goal":"lemma AddAssoc_1772(y: nat, z: nat, x: nat)\n ensures (y + z) + x == y + (z + x)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_1773","instance":1773,"id":171772,"goal":"lemma MulComm_1773(n: real, a: real)\n ensures n * a == a * n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_1774","instance":1774,"id":171773,"goal":"lemma MulAssoc_1774(a: int, y: int, b: int)\n ensures (a * y) * b == a * (y * b)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_1775","instance":1775,"id":171774,"goal":"lemma Distrib_1775(x: nat, y: nat, a: nat)\n ensures x * (y + a) == x * y + x * a\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_1776","instance":1776,"id":171775,"goal":"lemma AddZero_1776(n: real)\n ensures n + 0 == n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_1777","instance":1777,"id":171776,"goal":"lemma MulOne_1777(d: int)\n ensures d * 1 == d\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_1778","instance":1778,"id":171777,"goal":"lemma MulZero_1778(c: nat)\n ensures c * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_1779","instance":1779,"id":171778,"goal":"lemma LeRefl_1779(b: real)\n ensures b <= b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_1780","instance":1780,"id":171779,"goal":"lemma LeTrans_1780(m: int, n: int, d: int)\n requires m <= n && n <= d\n ensures m <= d\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_1781","instance":1781,"id":171780,"goal":"lemma AddMono_1781(k: nat, d: nat, c: nat)\n requires k <= d\n ensures k + c <= d + c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_1782","instance":1782,"id":171781,"goal":"lemma Abs_Nonneg_1782(k: real)\n ensures (if k >= 0 then k else -k) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_1783","instance":1783,"id":171782,"goal":"lemma DivMod_1783(b: int, k: int)\n requires k > 0\n ensures b == k * (b / k) + (b % k)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_1784","instance":1784,"id":171783,"goal":"lemma ModBounds_1784(d: nat, n: nat)\n requires n > 0\n ensures 0 <= d % n < n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_1785","instance":1785,"id":171784,"goal":"lemma Square_Nonneg_1785(k: real)\n ensures k * k >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_1786","instance":1786,"id":171785,"goal":"lemma AddComm_1786(a: int, n: int)\n ensures a + n == n + a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_1787","instance":1787,"id":171786,"goal":"lemma AddAssoc_1787(d: nat, c: nat, k: nat)\n ensures (d + c) + k == d + (c + k)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_1788","instance":1788,"id":171787,"goal":"lemma MulComm_1788(a: real, z: real)\n ensures a * z == z * a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_1789","instance":1789,"id":171788,"goal":"lemma MulAssoc_1789(j: int, b: int, y: int)\n ensures (j * b) * y == j * (b * y)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_1790","instance":1790,"id":171789,"goal":"lemma Distrib_1790(j: nat, y: nat, b: nat)\n ensures j * (y + b) == j * y + j * b\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_1791","instance":1791,"id":171790,"goal":"lemma AddZero_1791(i: real)\n ensures i + 0 == i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_1792","instance":1792,"id":171791,"goal":"lemma MulOne_1792(k: int)\n ensures k * 1 == k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_1793","instance":1793,"id":171792,"goal":"lemma MulZero_1793(d: nat)\n ensures d * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_1794","instance":1794,"id":171793,"goal":"lemma LeRefl_1794(i: real)\n ensures i <= i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_1795","instance":1795,"id":171794,"goal":"lemma LeTrans_1795(b: int, n: int, a: int)\n requires b <= n && n <= a\n ensures b <= a\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_1796","instance":1796,"id":171795,"goal":"lemma AddMono_1796(z: nat, d: nat, y: nat)\n requires z <= d\n ensures z + y <= d + y\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_1797","instance":1797,"id":171796,"goal":"lemma Abs_Nonneg_1797(d: real)\n ensures (if d >= 0 then d else -d) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_1798","instance":1798,"id":171797,"goal":"lemma DivMod_1798(m: int, j: int)\n requires j > 0\n ensures m == j * (m / j) + (m % j)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_1799","instance":1799,"id":171798,"goal":"lemma ModBounds_1799(j: nat, n: nat)\n requires n > 0\n ensures 0 <= j % n < n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_1800","instance":1800,"id":171799,"goal":"lemma Square_Nonneg_1800(d: real)\n ensures d * d >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_1801","instance":1801,"id":171800,"goal":"lemma AddComm_1801(x: int, c: int)\n ensures x + c == c + x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_1802","instance":1802,"id":171801,"goal":"lemma AddAssoc_1802(z: nat, n: nat, d: nat)\n ensures (z + n) + d == z + (n + d)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_1803","instance":1803,"id":171802,"goal":"lemma MulComm_1803(k: real, z: real)\n ensures k * z == z * k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_1804","instance":1804,"id":171803,"goal":"lemma MulAssoc_1804(y: int, k: int, m: int)\n ensures (y * k) * m == y * (k * m)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_1805","instance":1805,"id":171804,"goal":"lemma Distrib_1805(a: nat, x: nat, j: nat)\n ensures a * (x + j) == a * x + a * j\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_1806","instance":1806,"id":171805,"goal":"lemma AddZero_1806(j: real)\n ensures j + 0 == j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_1807","instance":1807,"id":171806,"goal":"lemma MulOne_1807(b: int)\n ensures b * 1 == b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_1808","instance":1808,"id":171807,"goal":"lemma MulZero_1808(k: nat)\n ensures k * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_1809","instance":1809,"id":171808,"goal":"lemma LeRefl_1809(m: real)\n ensures m <= m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_1810","instance":1810,"id":171809,"goal":"lemma LeTrans_1810(i: int, x: int, m: int)\n requires i <= x && x <= m\n ensures i <= m\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_1811","instance":1811,"id":171810,"goal":"lemma AddMono_1811(y: nat, i: nat, d: nat)\n requires y <= i\n ensures y + d <= i + d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_1812","instance":1812,"id":171811,"goal":"lemma Abs_Nonneg_1812(d: real)\n ensures (if d >= 0 then d else -d) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_1813","instance":1813,"id":171812,"goal":"lemma DivMod_1813(a: int, d: int)\n requires d > 0\n ensures a == d * (a / d) + (a % d)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_1814","instance":1814,"id":171813,"goal":"lemma ModBounds_1814(c: nat, n: nat)\n requires n > 0\n ensures 0 <= c % n < n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_1815","instance":1815,"id":171814,"goal":"lemma Square_Nonneg_1815(b: real)\n ensures b * b >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_1816","instance":1816,"id":171815,"goal":"lemma AddComm_1816(x: int, i: int)\n ensures x + i == i + x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_1817","instance":1817,"id":171816,"goal":"lemma AddAssoc_1817(a: nat, z: nat, k: nat)\n ensures (a + z) + k == a + (z + k)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_1818","instance":1818,"id":171817,"goal":"lemma MulComm_1818(n: real, a: real)\n ensures n * a == a * n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_1819","instance":1819,"id":171818,"goal":"lemma MulAssoc_1819(k: int, x: int, n: int)\n ensures (k * x) * n == k * (x * n)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_1820","instance":1820,"id":171819,"goal":"lemma Distrib_1820(k: nat, x: nat, y: nat)\n ensures k * (x + y) == k * x + k * y\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_1821","instance":1821,"id":171820,"goal":"lemma AddZero_1821(b: real)\n ensures b + 0 == b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_1822","instance":1822,"id":171821,"goal":"lemma MulOne_1822(a: int)\n ensures a * 1 == a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_1823","instance":1823,"id":171822,"goal":"lemma MulZero_1823(n: nat)\n ensures n * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_1824","instance":1824,"id":171823,"goal":"lemma LeRefl_1824(m: real)\n ensures m <= m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_1825","instance":1825,"id":171824,"goal":"lemma LeTrans_1825(k: int, n: int, d: int)\n requires k <= n && n <= d\n ensures k <= d\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_1826","instance":1826,"id":171825,"goal":"lemma AddMono_1826(a: nat, y: nat, c: nat)\n requires a <= y\n ensures a + c <= y + c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_1827","instance":1827,"id":171826,"goal":"lemma Abs_Nonneg_1827(z: real)\n ensures (if z >= 0 then z else -z) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_1828","instance":1828,"id":171827,"goal":"lemma DivMod_1828(y: int, j: int)\n requires j > 0\n ensures y == j * (y / j) + (y % j)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_1829","instance":1829,"id":171828,"goal":"lemma ModBounds_1829(i: nat, b: nat)\n requires b > 0\n ensures 0 <= i % b < b\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_1830","instance":1830,"id":171829,"goal":"lemma Square_Nonneg_1830(j: real)\n ensures j * j >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_1831","instance":1831,"id":171830,"goal":"lemma AddComm_1831(b: int, i: int)\n ensures b + i == i + b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_1832","instance":1832,"id":171831,"goal":"lemma AddAssoc_1832(c: nat, y: nat, m: nat)\n ensures (c + y) + m == c + (y + m)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_1833","instance":1833,"id":171832,"goal":"lemma MulComm_1833(a: real, m: real)\n ensures a * m == m * a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_1834","instance":1834,"id":171833,"goal":"lemma MulAssoc_1834(c: int, x: int, y: int)\n ensures (c * x) * y == c * (x * y)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_1835","instance":1835,"id":171834,"goal":"lemma Distrib_1835(a: nat, z: nat, j: nat)\n ensures a * (z + j) == a * z + a * j\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_1836","instance":1836,"id":171835,"goal":"lemma AddZero_1836(n: real)\n ensures n + 0 == n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_1837","instance":1837,"id":171836,"goal":"lemma MulOne_1837(k: int)\n ensures k * 1 == k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_1838","instance":1838,"id":171837,"goal":"lemma MulZero_1838(a: nat)\n ensures a * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_1839","instance":1839,"id":171838,"goal":"lemma LeRefl_1839(k: real)\n ensures k <= k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_1840","instance":1840,"id":171839,"goal":"lemma LeTrans_1840(b: int, i: int, k: int)\n requires b <= i && i <= k\n ensures b <= k\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_1841","instance":1841,"id":171840,"goal":"lemma AddMono_1841(z: nat, i: nat, a: nat)\n requires z <= i\n ensures z + a <= i + a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_1842","instance":1842,"id":171841,"goal":"lemma Abs_Nonneg_1842(x: real)\n ensures (if x >= 0 then x else -x) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_1843","instance":1843,"id":171842,"goal":"lemma DivMod_1843(k: int, z: int)\n requires z > 0\n ensures k == z * (k / z) + (k % z)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_1844","instance":1844,"id":171843,"goal":"lemma ModBounds_1844(b: nat, k: nat)\n requires k > 0\n ensures 0 <= b % k < k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_1845","instance":1845,"id":171844,"goal":"lemma Square_Nonneg_1845(j: real)\n ensures j * j >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_1846","instance":1846,"id":171845,"goal":"lemma AddComm_1846(y: int, a: int)\n ensures y + a == a + y\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_1847","instance":1847,"id":171846,"goal":"lemma AddAssoc_1847(k: nat, a: nat, b: nat)\n ensures (k + a) + b == k + (a + b)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_1848","instance":1848,"id":171847,"goal":"lemma MulComm_1848(b: real, m: real)\n ensures b * m == m * b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_1849","instance":1849,"id":171848,"goal":"lemma MulAssoc_1849(y: int, m: int, j: int)\n ensures (y * m) * j == y * (m * j)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_1850","instance":1850,"id":171849,"goal":"lemma Distrib_1850(d: nat, a: nat, n: nat)\n ensures d * (a + n) == d * a + d * n\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_1851","instance":1851,"id":171850,"goal":"lemma AddZero_1851(m: real)\n ensures m + 0 == m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_1852","instance":1852,"id":171851,"goal":"lemma MulOne_1852(n: int)\n ensures n * 1 == n\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_1853","instance":1853,"id":171852,"goal":"lemma MulZero_1853(x: nat)\n ensures x * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_1854","instance":1854,"id":171853,"goal":"lemma LeRefl_1854(n: real)\n ensures n <= n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_1855","instance":1855,"id":171854,"goal":"lemma LeTrans_1855(i: int, z: int, x: int)\n requires i <= z && z <= x\n ensures i <= x\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_1856","instance":1856,"id":171855,"goal":"lemma AddMono_1856(x: nat, b: nat, c: nat)\n requires x <= b\n ensures x + c <= b + c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_1857","instance":1857,"id":171856,"goal":"lemma Abs_Nonneg_1857(c: real)\n ensures (if c >= 0 then c else -c) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_1858","instance":1858,"id":171857,"goal":"lemma DivMod_1858(a: int, c: int)\n requires c > 0\n ensures a == c * (a / c) + (a % c)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_1859","instance":1859,"id":171858,"goal":"lemma ModBounds_1859(z: nat, j: nat)\n requires j > 0\n ensures 0 <= z % j < j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_1860","instance":1860,"id":171859,"goal":"lemma Square_Nonneg_1860(x: real)\n ensures x * x >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_1861","instance":1861,"id":171860,"goal":"lemma AddComm_1861(c: int, k: int)\n ensures c + k == k + c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_1862","instance":1862,"id":171861,"goal":"lemma AddAssoc_1862(n: nat, i: nat, z: nat)\n ensures (n + i) + z == n + (i + z)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_1863","instance":1863,"id":171862,"goal":"lemma MulComm_1863(z: real, c: real)\n ensures z * c == c * z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_1864","instance":1864,"id":171863,"goal":"lemma MulAssoc_1864(x: int, y: int, c: int)\n ensures (x * y) * c == x * (y * c)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_1865","instance":1865,"id":171864,"goal":"lemma Distrib_1865(z: nat, y: nat, d: nat)\n ensures z * (y + d) == z * y + z * d\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_1866","instance":1866,"id":171865,"goal":"lemma AddZero_1866(z: real)\n ensures z + 0 == z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_1867","instance":1867,"id":171866,"goal":"lemma MulOne_1867(c: int)\n ensures c * 1 == c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_1868","instance":1868,"id":171867,"goal":"lemma MulZero_1868(a: nat)\n ensures a * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_1869","instance":1869,"id":171868,"goal":"lemma LeRefl_1869(c: real)\n ensures c <= c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_1870","instance":1870,"id":171869,"goal":"lemma LeTrans_1870(n: int, a: int, z: int)\n requires n <= a && a <= z\n ensures n <= z\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_1871","instance":1871,"id":171870,"goal":"lemma AddMono_1871(i: nat, z: nat, b: nat)\n requires i <= z\n ensures i + b <= z + b\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_1872","instance":1872,"id":171871,"goal":"lemma Abs_Nonneg_1872(i: real)\n ensures (if i >= 0 then i else -i) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_1873","instance":1873,"id":171872,"goal":"lemma DivMod_1873(a: int, m: int)\n requires m > 0\n ensures a == m * (a / m) + (a % m)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_1874","instance":1874,"id":171873,"goal":"lemma ModBounds_1874(b: nat, m: nat)\n requires m > 0\n ensures 0 <= b % m < m\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_1875","instance":1875,"id":171874,"goal":"lemma Square_Nonneg_1875(y: real)\n ensures y * y >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_1876","instance":1876,"id":171875,"goal":"lemma AddComm_1876(i: int, m: int)\n ensures i + m == m + i\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_1877","instance":1877,"id":171876,"goal":"lemma AddAssoc_1877(i: nat, d: nat, b: nat)\n ensures (i + d) + b == i + (d + b)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_1878","instance":1878,"id":171877,"goal":"lemma MulComm_1878(y: real, c: real)\n ensures y * c == c * y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_1879","instance":1879,"id":171878,"goal":"lemma MulAssoc_1879(z: int, x: int, y: int)\n ensures (z * x) * y == z * (x * y)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_1880","instance":1880,"id":171879,"goal":"lemma Distrib_1880(n: nat, i: nat, j: nat)\n ensures n * (i + j) == n * i + n * j\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_1881","instance":1881,"id":171880,"goal":"lemma AddZero_1881(m: real)\n ensures m + 0 == m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_1882","instance":1882,"id":171881,"goal":"lemma MulOne_1882(a: int)\n ensures a * 1 == a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_1883","instance":1883,"id":171882,"goal":"lemma MulZero_1883(y: nat)\n ensures y * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_1884","instance":1884,"id":171883,"goal":"lemma LeRefl_1884(a: real)\n ensures a <= a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_1885","instance":1885,"id":171884,"goal":"lemma LeTrans_1885(k: int, i: int, x: int)\n requires k <= i && i <= x\n ensures k <= x\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_1886","instance":1886,"id":171885,"goal":"lemma AddMono_1886(d: nat, c: nat, z: nat)\n requires d <= c\n ensures d + z <= c + z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_1887","instance":1887,"id":171886,"goal":"lemma Abs_Nonneg_1887(b: real)\n ensures (if b >= 0 then b else -b) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_1888","instance":1888,"id":171887,"goal":"lemma DivMod_1888(j: int, m: int)\n requires m > 0\n ensures j == m * (j / m) + (j % m)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_1889","instance":1889,"id":171888,"goal":"lemma ModBounds_1889(i: nat, b: nat)\n requires b > 0\n ensures 0 <= i % b < b\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_1890","instance":1890,"id":171889,"goal":"lemma Square_Nonneg_1890(n: real)\n ensures n * n >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_1891","instance":1891,"id":171890,"goal":"lemma AddComm_1891(x: int, c: int)\n ensures x + c == c + x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_1892","instance":1892,"id":171891,"goal":"lemma AddAssoc_1892(a: nat, z: nat, b: nat)\n ensures (a + z) + b == a + (z + b)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_1893","instance":1893,"id":171892,"goal":"lemma MulComm_1893(z: real, i: real)\n ensures z * i == i * z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_1894","instance":1894,"id":171893,"goal":"lemma MulAssoc_1894(a: int, z: int, m: int)\n ensures (a * z) * m == a * (z * m)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_1895","instance":1895,"id":171894,"goal":"lemma Distrib_1895(b: nat, n: nat, k: nat)\n ensures b * (n + k) == b * n + b * k\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_1896","instance":1896,"id":171895,"goal":"lemma AddZero_1896(k: real)\n ensures k + 0 == k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_1897","instance":1897,"id":171896,"goal":"lemma MulOne_1897(j: int)\n ensures j * 1 == j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_1898","instance":1898,"id":171897,"goal":"lemma MulZero_1898(j: nat)\n ensures j * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_1899","instance":1899,"id":171898,"goal":"lemma LeRefl_1899(a: real)\n ensures a <= a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_1900","instance":1900,"id":171899,"goal":"lemma LeTrans_1900(d: int, j: int, k: int)\n requires d <= j && j <= k\n ensures d <= k\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_1901","instance":1901,"id":171900,"goal":"lemma AddMono_1901(b: nat, j: nat, c: nat)\n requires b <= j\n ensures b + c <= j + c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_1902","instance":1902,"id":171901,"goal":"lemma Abs_Nonneg_1902(x: real)\n ensures (if x >= 0 then x else -x) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_1903","instance":1903,"id":171902,"goal":"lemma DivMod_1903(c: int, b: int)\n requires b > 0\n ensures c == b * (c / b) + (c % b)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_1904","instance":1904,"id":171903,"goal":"lemma ModBounds_1904(i: nat, z: nat)\n requires z > 0\n ensures 0 <= i % z < z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_1905","instance":1905,"id":171904,"goal":"lemma Square_Nonneg_1905(y: real)\n ensures y * y >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_1906","instance":1906,"id":171905,"goal":"lemma AddComm_1906(a: int, z: int)\n ensures a + z == z + a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_1907","instance":1907,"id":171906,"goal":"lemma AddAssoc_1907(i: nat, y: nat, n: nat)\n ensures (i + y) + n == i + (y + n)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_1908","instance":1908,"id":171907,"goal":"lemma MulComm_1908(b: real, d: real)\n ensures b * d == d * b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_1909","instance":1909,"id":171908,"goal":"lemma MulAssoc_1909(y: int, a: int, j: int)\n ensures (y * a) * j == y * (a * j)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_1910","instance":1910,"id":171909,"goal":"lemma Distrib_1910(x: nat, j: nat, n: nat)\n ensures x * (j + n) == x * j + x * n\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_1911","instance":1911,"id":171910,"goal":"lemma AddZero_1911(i: real)\n ensures i + 0 == i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_1912","instance":1912,"id":171911,"goal":"lemma MulOne_1912(b: int)\n ensures b * 1 == b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_1913","instance":1913,"id":171912,"goal":"lemma MulZero_1913(m: nat)\n ensures m * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_1914","instance":1914,"id":171913,"goal":"lemma LeRefl_1914(d: real)\n ensures d <= d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_1915","instance":1915,"id":171914,"goal":"lemma LeTrans_1915(d: int, i: int, n: int)\n requires d <= i && i <= n\n ensures d <= n\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_1916","instance":1916,"id":171915,"goal":"lemma AddMono_1916(z: nat, i: nat, d: nat)\n requires z <= i\n ensures z + d <= i + d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_1917","instance":1917,"id":171916,"goal":"lemma Abs_Nonneg_1917(b: real)\n ensures (if b >= 0 then b else -b) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_1918","instance":1918,"id":171917,"goal":"lemma DivMod_1918(z: int, j: int)\n requires j > 0\n ensures z == j * (z / j) + (z % j)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_1919","instance":1919,"id":171918,"goal":"lemma ModBounds_1919(c: nat, k: nat)\n requires k > 0\n ensures 0 <= c % k < k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_1920","instance":1920,"id":171919,"goal":"lemma Square_Nonneg_1920(j: real)\n ensures j * j >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_1921","instance":1921,"id":171920,"goal":"lemma AddComm_1921(m: int, d: int)\n ensures m + d == d + m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_1922","instance":1922,"id":171921,"goal":"lemma AddAssoc_1922(m: nat, a: nat, d: nat)\n ensures (m + a) + d == m + (a + d)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_1923","instance":1923,"id":171922,"goal":"lemma MulComm_1923(y: real, d: real)\n ensures y * d == d * y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_1924","instance":1924,"id":171923,"goal":"lemma MulAssoc_1924(n: int, m: int, d: int)\n ensures (n * m) * d == n * (m * d)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_1925","instance":1925,"id":171924,"goal":"lemma Distrib_1925(x: nat, y: nat, m: nat)\n ensures x * (y + m) == x * y + x * m\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_1926","instance":1926,"id":171925,"goal":"lemma AddZero_1926(n: real)\n ensures n + 0 == n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_1927","instance":1927,"id":171926,"goal":"lemma MulOne_1927(m: int)\n ensures m * 1 == m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_1928","instance":1928,"id":171927,"goal":"lemma MulZero_1928(j: nat)\n ensures j * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_1929","instance":1929,"id":171928,"goal":"lemma LeRefl_1929(n: real)\n ensures n <= n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_1930","instance":1930,"id":171929,"goal":"lemma LeTrans_1930(j: int, i: int, k: int)\n requires j <= i && i <= k\n ensures j <= k\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_1931","instance":1931,"id":171930,"goal":"lemma AddMono_1931(z: nat, k: nat, b: nat)\n requires z <= k\n ensures z + b <= k + b\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_1932","instance":1932,"id":171931,"goal":"lemma Abs_Nonneg_1932(i: real)\n ensures (if i >= 0 then i else -i) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_1933","instance":1933,"id":171932,"goal":"lemma DivMod_1933(d: int, k: int)\n requires k > 0\n ensures d == k * (d / k) + (d % k)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_1934","instance":1934,"id":171933,"goal":"lemma ModBounds_1934(j: nat, m: nat)\n requires m > 0\n ensures 0 <= j % m < m\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_1935","instance":1935,"id":171934,"goal":"lemma Square_Nonneg_1935(n: real)\n ensures n * n >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_1936","instance":1936,"id":171935,"goal":"lemma AddComm_1936(n: int, x: int)\n ensures n + x == x + n\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_1937","instance":1937,"id":171936,"goal":"lemma AddAssoc_1937(y: nat, c: nat, b: nat)\n ensures (y + c) + b == y + (c + b)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_1938","instance":1938,"id":171937,"goal":"lemma MulComm_1938(m: real, b: real)\n ensures m * b == b * m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_1939","instance":1939,"id":171938,"goal":"lemma MulAssoc_1939(j: int, k: int, d: int)\n ensures (j * k) * d == j * (k * d)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_1940","instance":1940,"id":171939,"goal":"lemma Distrib_1940(d: nat, i: nat, z: nat)\n ensures d * (i + z) == d * i + d * z\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_1941","instance":1941,"id":171940,"goal":"lemma AddZero_1941(m: real)\n ensures m + 0 == m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_1942","instance":1942,"id":171941,"goal":"lemma MulOne_1942(k: int)\n ensures k * 1 == k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_1943","instance":1943,"id":171942,"goal":"lemma MulZero_1943(i: nat)\n ensures i * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_1944","instance":1944,"id":171943,"goal":"lemma LeRefl_1944(n: real)\n ensures n <= n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_1945","instance":1945,"id":171944,"goal":"lemma LeTrans_1945(d: int, m: int, a: int)\n requires d <= m && m <= a\n ensures d <= a\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_1946","instance":1946,"id":171945,"goal":"lemma AddMono_1946(y: nat, m: nat, j: nat)\n requires y <= m\n ensures y + j <= m + j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_1947","instance":1947,"id":171946,"goal":"lemma Abs_Nonneg_1947(k: real)\n ensures (if k >= 0 then k else -k) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_1948","instance":1948,"id":171947,"goal":"lemma DivMod_1948(j: int, k: int)\n requires k > 0\n ensures j == k * (j / k) + (j % k)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_1949","instance":1949,"id":171948,"goal":"lemma ModBounds_1949(n: nat, b: nat)\n requires b > 0\n ensures 0 <= n % b < b\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_1950","instance":1950,"id":171949,"goal":"lemma Square_Nonneg_1950(m: real)\n ensures m * m >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_1951","instance":1951,"id":171950,"goal":"lemma AddComm_1951(x: int, y: int)\n ensures x + y == y + x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_1952","instance":1952,"id":171951,"goal":"lemma AddAssoc_1952(j: nat, z: nat, k: nat)\n ensures (j + z) + k == j + (z + k)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_1953","instance":1953,"id":171952,"goal":"lemma MulComm_1953(c: real, d: real)\n ensures c * d == d * c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_1954","instance":1954,"id":171953,"goal":"lemma MulAssoc_1954(n: int, a: int, z: int)\n ensures (n * a) * z == n * (a * z)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_1955","instance":1955,"id":171954,"goal":"lemma Distrib_1955(i: nat, j: nat, k: nat)\n ensures i * (j + k) == i * j + i * k\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_1956","instance":1956,"id":171955,"goal":"lemma AddZero_1956(n: real)\n ensures n + 0 == n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_1957","instance":1957,"id":171956,"goal":"lemma MulOne_1957(y: int)\n ensures y * 1 == y\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_1958","instance":1958,"id":171957,"goal":"lemma MulZero_1958(j: nat)\n ensures j * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_1959","instance":1959,"id":171958,"goal":"lemma LeRefl_1959(i: real)\n ensures i <= i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_1960","instance":1960,"id":171959,"goal":"lemma LeTrans_1960(d: int, m: int, x: int)\n requires d <= m && m <= x\n ensures d <= x\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_1961","instance":1961,"id":171960,"goal":"lemma AddMono_1961(k: nat, m: nat, y: nat)\n requires k <= m\n ensures k + y <= m + y\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_1962","instance":1962,"id":171961,"goal":"lemma Abs_Nonneg_1962(x: real)\n ensures (if x >= 0 then x else -x) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_1963","instance":1963,"id":171962,"goal":"lemma DivMod_1963(b: int, n: int)\n requires n > 0\n ensures b == n * (b / n) + (b % n)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_1964","instance":1964,"id":171963,"goal":"lemma ModBounds_1964(k: nat, b: nat)\n requires b > 0\n ensures 0 <= k % b < b\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_1965","instance":1965,"id":171964,"goal":"lemma Square_Nonneg_1965(x: real)\n ensures x * x >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_1966","instance":1966,"id":171965,"goal":"lemma AddComm_1966(x: int, n: int)\n ensures x + n == n + x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_1967","instance":1967,"id":171966,"goal":"lemma AddAssoc_1967(a: nat, c: nat, m: nat)\n ensures (a + c) + m == a + (c + m)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_1968","instance":1968,"id":171967,"goal":"lemma MulComm_1968(n: real, x: real)\n ensures n * x == x * n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_1969","instance":1969,"id":171968,"goal":"lemma MulAssoc_1969(z: int, x: int, a: int)\n ensures (z * x) * a == z * (x * a)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_1970","instance":1970,"id":171969,"goal":"lemma Distrib_1970(y: nat, x: nat, d: nat)\n ensures y * (x + d) == y * x + y * d\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_1971","instance":1971,"id":171970,"goal":"lemma AddZero_1971(n: real)\n ensures n + 0 == n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_1972","instance":1972,"id":171971,"goal":"lemma MulOne_1972(c: int)\n ensures c * 1 == c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_1973","instance":1973,"id":171972,"goal":"lemma MulZero_1973(m: nat)\n ensures m * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_1974","instance":1974,"id":171973,"goal":"lemma LeRefl_1974(j: real)\n ensures j <= j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_1975","instance":1975,"id":171974,"goal":"lemma LeTrans_1975(c: int, a: int, x: int)\n requires c <= a && a <= x\n ensures c <= x\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_1976","instance":1976,"id":171975,"goal":"lemma AddMono_1976(n: nat, y: nat, z: nat)\n requires n <= y\n ensures n + z <= y + z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_1977","instance":1977,"id":171976,"goal":"lemma Abs_Nonneg_1977(a: real)\n ensures (if a >= 0 then a else -a) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_1978","instance":1978,"id":171977,"goal":"lemma DivMod_1978(m: int, a: int)\n requires a > 0\n ensures m == a * (m / a) + (m % a)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_1979","instance":1979,"id":171978,"goal":"lemma ModBounds_1979(d: nat, j: nat)\n requires j > 0\n ensures 0 <= d % j < j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_1980","instance":1980,"id":171979,"goal":"lemma Square_Nonneg_1980(d: real)\n ensures d * d >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_1981","instance":1981,"id":171980,"goal":"lemma AddComm_1981(z: int, d: int)\n ensures z + d == d + z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_1982","instance":1982,"id":171981,"goal":"lemma AddAssoc_1982(c: nat, z: nat, x: nat)\n ensures (c + z) + x == c + (z + x)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_1983","instance":1983,"id":171982,"goal":"lemma MulComm_1983(z: real, b: real)\n ensures z * b == b * z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_1984","instance":1984,"id":171983,"goal":"lemma MulAssoc_1984(c: int, a: int, i: int)\n ensures (c * a) * i == c * (a * i)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_1985","instance":1985,"id":171984,"goal":"lemma Distrib_1985(n: nat, b: nat, z: nat)\n ensures n * (b + z) == n * b + n * z\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_1986","instance":1986,"id":171985,"goal":"lemma AddZero_1986(d: real)\n ensures d + 0 == d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_1987","instance":1987,"id":171986,"goal":"lemma MulOne_1987(k: int)\n ensures k * 1 == k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_1988","instance":1988,"id":171987,"goal":"lemma MulZero_1988(k: nat)\n ensures k * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_1989","instance":1989,"id":171988,"goal":"lemma LeRefl_1989(x: real)\n ensures x <= x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_1990","instance":1990,"id":171989,"goal":"lemma LeTrans_1990(d: int, z: int, m: int)\n requires d <= z && z <= m\n ensures d <= m\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_1991","instance":1991,"id":171990,"goal":"lemma AddMono_1991(a: nat, d: nat, j: nat)\n requires a <= d\n ensures a + j <= d + j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_1992","instance":1992,"id":171991,"goal":"lemma Abs_Nonneg_1992(z: real)\n ensures (if z >= 0 then z else -z) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_1993","instance":1993,"id":171992,"goal":"lemma DivMod_1993(i: int, b: int)\n requires b > 0\n ensures i == b * (i / b) + (i % b)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_1994","instance":1994,"id":171993,"goal":"lemma ModBounds_1994(x: nat, i: nat)\n requires i > 0\n ensures 0 <= x % i < i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_1995","instance":1995,"id":171994,"goal":"lemma Square_Nonneg_1995(c: real)\n ensures c * c >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_1996","instance":1996,"id":171995,"goal":"lemma AddComm_1996(x: int, c: int)\n ensures x + c == c + x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_1997","instance":1997,"id":171996,"goal":"lemma AddAssoc_1997(k: nat, m: nat, j: nat)\n ensures (k + m) + j == k + (m + j)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_1998","instance":1998,"id":171997,"goal":"lemma MulComm_1998(a: real, m: real)\n ensures a * m == m * a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_1999","instance":1999,"id":171998,"goal":"lemma MulAssoc_1999(j: int, d: int, z: int)\n ensures (j * d) * z == j * (d * z)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_2000","instance":2000,"id":171999,"goal":"lemma Distrib_2000(b: nat, z: nat, d: nat)\n ensures b * (z + d) == b * z + b * d\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_2001","instance":2001,"id":172000,"goal":"lemma AddZero_2001(y: real)\n ensures y + 0 == y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_2002","instance":2002,"id":172001,"goal":"lemma MulOne_2002(z: int)\n ensures z * 1 == z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_2003","instance":2003,"id":172002,"goal":"lemma MulZero_2003(b: nat)\n ensures b * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_2004","instance":2004,"id":172003,"goal":"lemma LeRefl_2004(n: real)\n ensures n <= n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_2005","instance":2005,"id":172004,"goal":"lemma LeTrans_2005(d: int, c: int, j: int)\n requires d <= c && c <= j\n ensures d <= j\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_2006","instance":2006,"id":172005,"goal":"lemma AddMono_2006(z: nat, m: nat, d: nat)\n requires z <= m\n ensures z + d <= m + d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_2007","instance":2007,"id":172006,"goal":"lemma Abs_Nonneg_2007(x: real)\n ensures (if x >= 0 then x else -x) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_2008","instance":2008,"id":172007,"goal":"lemma DivMod_2008(y: int, k: int)\n requires k > 0\n ensures y == k * (y / k) + (y % k)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_2009","instance":2009,"id":172008,"goal":"lemma ModBounds_2009(k: nat, a: nat)\n requires a > 0\n ensures 0 <= k % a < a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_2010","instance":2010,"id":172009,"goal":"lemma Square_Nonneg_2010(y: real)\n ensures y * y >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_2011","instance":2011,"id":172010,"goal":"lemma AddComm_2011(z: int, c: int)\n ensures z + c == c + z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_2012","instance":2012,"id":172011,"goal":"lemma AddAssoc_2012(m: nat, k: nat, z: nat)\n ensures (m + k) + z == m + (k + z)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_2013","instance":2013,"id":172012,"goal":"lemma MulComm_2013(j: real, i: real)\n ensures j * i == i * j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_2014","instance":2014,"id":172013,"goal":"lemma MulAssoc_2014(j: int, y: int, k: int)\n ensures (j * y) * k == j * (y * k)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_2015","instance":2015,"id":172014,"goal":"lemma Distrib_2015(c: nat, x: nat, j: nat)\n ensures c * (x + j) == c * x + c * j\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_2016","instance":2016,"id":172015,"goal":"lemma AddZero_2016(x: real)\n ensures x + 0 == x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_2017","instance":2017,"id":172016,"goal":"lemma MulOne_2017(i: int)\n ensures i * 1 == i\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_2018","instance":2018,"id":172017,"goal":"lemma MulZero_2018(j: nat)\n ensures j * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_2019","instance":2019,"id":172018,"goal":"lemma LeRefl_2019(d: real)\n ensures d <= d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_2020","instance":2020,"id":172019,"goal":"lemma LeTrans_2020(a: int, y: int, i: int)\n requires a <= y && y <= i\n ensures a <= i\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_2021","instance":2021,"id":172020,"goal":"lemma AddMono_2021(b: nat, z: nat, j: nat)\n requires b <= z\n ensures b + j <= z + j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_2022","instance":2022,"id":172021,"goal":"lemma Abs_Nonneg_2022(z: real)\n ensures (if z >= 0 then z else -z) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_2023","instance":2023,"id":172022,"goal":"lemma DivMod_2023(i: int, n: int)\n requires n > 0\n ensures i == n * (i / n) + (i % n)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_2024","instance":2024,"id":172023,"goal":"lemma ModBounds_2024(c: nat, x: nat)\n requires x > 0\n ensures 0 <= c % x < x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_2025","instance":2025,"id":172024,"goal":"lemma Square_Nonneg_2025(z: real)\n ensures z * z >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_2026","instance":2026,"id":172025,"goal":"lemma AddComm_2026(b: int, a: int)\n ensures b + a == a + b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_2027","instance":2027,"id":172026,"goal":"lemma AddAssoc_2027(c: nat, m: nat, i: nat)\n ensures (c + m) + i == c + (m + i)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_2028","instance":2028,"id":172027,"goal":"lemma MulComm_2028(y: real, d: real)\n ensures y * d == d * y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_2029","instance":2029,"id":172028,"goal":"lemma MulAssoc_2029(x: int, k: int, a: int)\n ensures (x * k) * a == x * (k * a)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_2030","instance":2030,"id":172029,"goal":"lemma Distrib_2030(j: nat, c: nat, d: nat)\n ensures j * (c + d) == j * c + j * d\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_2031","instance":2031,"id":172030,"goal":"lemma AddZero_2031(b: real)\n ensures b + 0 == b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_2032","instance":2032,"id":172031,"goal":"lemma MulOne_2032(z: int)\n ensures z * 1 == z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_2033","instance":2033,"id":172032,"goal":"lemma MulZero_2033(n: nat)\n ensures n * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_2034","instance":2034,"id":172033,"goal":"lemma LeRefl_2034(x: real)\n ensures x <= x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_2035","instance":2035,"id":172034,"goal":"lemma LeTrans_2035(j: int, b: int, y: int)\n requires j <= b && b <= y\n ensures j <= y\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_2036","instance":2036,"id":172035,"goal":"lemma AddMono_2036(a: nat, k: nat, m: nat)\n requires a <= k\n ensures a + m <= k + m\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_2037","instance":2037,"id":172036,"goal":"lemma Abs_Nonneg_2037(x: real)\n ensures (if x >= 0 then x else -x) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_2038","instance":2038,"id":172037,"goal":"lemma DivMod_2038(x: int, a: int)\n requires a > 0\n ensures x == a * (x / a) + (x % a)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_2039","instance":2039,"id":172038,"goal":"lemma ModBounds_2039(z: nat, c: nat)\n requires c > 0\n ensures 0 <= z % c < c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_2040","instance":2040,"id":172039,"goal":"lemma Square_Nonneg_2040(m: real)\n ensures m * m >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_2041","instance":2041,"id":172040,"goal":"lemma AddComm_2041(x: int, d: int)\n ensures x + d == d + x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_2042","instance":2042,"id":172041,"goal":"lemma AddAssoc_2042(i: nat, k: nat, y: nat)\n ensures (i + k) + y == i + (k + y)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_2043","instance":2043,"id":172042,"goal":"lemma MulComm_2043(n: real, c: real)\n ensures n * c == c * n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_2044","instance":2044,"id":172043,"goal":"lemma MulAssoc_2044(n: int, j: int, b: int)\n ensures (n * j) * b == n * (j * b)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_2045","instance":2045,"id":172044,"goal":"lemma Distrib_2045(a: nat, m: nat, z: nat)\n ensures a * (m + z) == a * m + a * z\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_2046","instance":2046,"id":172045,"goal":"lemma AddZero_2046(a: real)\n ensures a + 0 == a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_2047","instance":2047,"id":172046,"goal":"lemma MulOne_2047(b: int)\n ensures b * 1 == b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_2048","instance":2048,"id":172047,"goal":"lemma MulZero_2048(k: nat)\n ensures k * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_2049","instance":2049,"id":172048,"goal":"lemma LeRefl_2049(z: real)\n ensures z <= z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_2050","instance":2050,"id":172049,"goal":"lemma LeTrans_2050(n: int, j: int, c: int)\n requires n <= j && j <= c\n ensures n <= c\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_2051","instance":2051,"id":172050,"goal":"lemma AddMono_2051(n: nat, i: nat, y: nat)\n requires n <= i\n ensures n + y <= i + y\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_2052","instance":2052,"id":172051,"goal":"lemma Abs_Nonneg_2052(n: real)\n ensures (if n >= 0 then n else -n) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_2053","instance":2053,"id":172052,"goal":"lemma DivMod_2053(c: int, m: int)\n requires m > 0\n ensures c == m * (c / m) + (c % m)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_2054","instance":2054,"id":172053,"goal":"lemma ModBounds_2054(k: nat, b: nat)\n requires b > 0\n ensures 0 <= k % b < b\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_2055","instance":2055,"id":172054,"goal":"lemma Square_Nonneg_2055(b: real)\n ensures b * b >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_2056","instance":2056,"id":172055,"goal":"lemma AddComm_2056(i: int, m: int)\n ensures i + m == m + i\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_2057","instance":2057,"id":172056,"goal":"lemma AddAssoc_2057(z: nat, b: nat, i: nat)\n ensures (z + b) + i == z + (b + i)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_2058","instance":2058,"id":172057,"goal":"lemma MulComm_2058(c: real, k: real)\n ensures c * k == k * c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_2059","instance":2059,"id":172058,"goal":"lemma MulAssoc_2059(z: int, d: int, y: int)\n ensures (z * d) * y == z * (d * y)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_2060","instance":2060,"id":172059,"goal":"lemma Distrib_2060(z: nat, i: nat, y: nat)\n ensures z * (i + y) == z * i + z * y\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_2061","instance":2061,"id":172060,"goal":"lemma AddZero_2061(k: real)\n ensures k + 0 == k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_2062","instance":2062,"id":172061,"goal":"lemma MulOne_2062(n: int)\n ensures n * 1 == n\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_2063","instance":2063,"id":172062,"goal":"lemma MulZero_2063(a: nat)\n ensures a * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_2064","instance":2064,"id":172063,"goal":"lemma LeRefl_2064(a: real)\n ensures a <= a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_2065","instance":2065,"id":172064,"goal":"lemma LeTrans_2065(y: int, m: int, k: int)\n requires y <= m && m <= k\n ensures y <= k\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_2066","instance":2066,"id":172065,"goal":"lemma AddMono_2066(i: nat, m: nat, z: nat)\n requires i <= m\n ensures i + z <= m + z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_2067","instance":2067,"id":172066,"goal":"lemma Abs_Nonneg_2067(y: real)\n ensures (if y >= 0 then y else -y) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_2068","instance":2068,"id":172067,"goal":"lemma DivMod_2068(i: int, y: int)\n requires y > 0\n ensures i == y * (i / y) + (i % y)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_2069","instance":2069,"id":172068,"goal":"lemma ModBounds_2069(c: nat, k: nat)\n requires k > 0\n ensures 0 <= c % k < k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_2070","instance":2070,"id":172069,"goal":"lemma Square_Nonneg_2070(j: real)\n ensures j * j >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_2071","instance":2071,"id":172070,"goal":"lemma AddComm_2071(z: int, b: int)\n ensures z + b == b + z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_2072","instance":2072,"id":172071,"goal":"lemma AddAssoc_2072(m: nat, k: nat, a: nat)\n ensures (m + k) + a == m + (k + a)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_2073","instance":2073,"id":172072,"goal":"lemma MulComm_2073(b: real, y: real)\n ensures b * y == y * b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_2074","instance":2074,"id":172073,"goal":"lemma MulAssoc_2074(y: int, x: int, k: int)\n ensures (y * x) * k == y * (x * k)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_2075","instance":2075,"id":172074,"goal":"lemma Distrib_2075(b: nat, m: nat, z: nat)\n ensures b * (m + z) == b * m + b * z\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_2076","instance":2076,"id":172075,"goal":"lemma AddZero_2076(x: real)\n ensures x + 0 == x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_2077","instance":2077,"id":172076,"goal":"lemma MulOne_2077(a: int)\n ensures a * 1 == a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_2078","instance":2078,"id":172077,"goal":"lemma MulZero_2078(z: nat)\n ensures z * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_2079","instance":2079,"id":172078,"goal":"lemma LeRefl_2079(b: real)\n ensures b <= b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_2080","instance":2080,"id":172079,"goal":"lemma LeTrans_2080(n: int, z: int, k: int)\n requires n <= z && z <= k\n ensures n <= k\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_2081","instance":2081,"id":172080,"goal":"lemma AddMono_2081(j: nat, d: nat, x: nat)\n requires j <= d\n ensures j + x <= d + x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_2082","instance":2082,"id":172081,"goal":"lemma Abs_Nonneg_2082(c: real)\n ensures (if c >= 0 then c else -c) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_2083","instance":2083,"id":172082,"goal":"lemma DivMod_2083(x: int, b: int)\n requires b > 0\n ensures x == b * (x / b) + (x % b)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_2084","instance":2084,"id":172083,"goal":"lemma ModBounds_2084(a: nat, x: nat)\n requires x > 0\n ensures 0 <= a % x < x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_2085","instance":2085,"id":172084,"goal":"lemma Square_Nonneg_2085(j: real)\n ensures j * j >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_2086","instance":2086,"id":172085,"goal":"lemma AddComm_2086(z: int, a: int)\n ensures z + a == a + z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_2087","instance":2087,"id":172086,"goal":"lemma AddAssoc_2087(k: nat, n: nat, x: nat)\n ensures (k + n) + x == k + (n + x)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_2088","instance":2088,"id":172087,"goal":"lemma MulComm_2088(k: real, n: real)\n ensures k * n == n * k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_2089","instance":2089,"id":172088,"goal":"lemma MulAssoc_2089(d: int, j: int, k: int)\n ensures (d * j) * k == d * (j * k)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_2090","instance":2090,"id":172089,"goal":"lemma Distrib_2090(z: nat, d: nat, y: nat)\n ensures z * (d + y) == z * d + z * y\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_2091","instance":2091,"id":172090,"goal":"lemma AddZero_2091(z: real)\n ensures z + 0 == z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_2092","instance":2092,"id":172091,"goal":"lemma MulOne_2092(x: int)\n ensures x * 1 == x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_2093","instance":2093,"id":172092,"goal":"lemma MulZero_2093(b: nat)\n ensures b * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_2094","instance":2094,"id":172093,"goal":"lemma LeRefl_2094(j: real)\n ensures j <= j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_2095","instance":2095,"id":172094,"goal":"lemma LeTrans_2095(i: int, y: int, a: int)\n requires i <= y && y <= a\n ensures i <= a\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_2096","instance":2096,"id":172095,"goal":"lemma AddMono_2096(k: nat, m: nat, j: nat)\n requires k <= m\n ensures k + j <= m + j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_2097","instance":2097,"id":172096,"goal":"lemma Abs_Nonneg_2097(n: real)\n ensures (if n >= 0 then n else -n) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_2098","instance":2098,"id":172097,"goal":"lemma DivMod_2098(n: int, a: int)\n requires a > 0\n ensures n == a * (n / a) + (n % a)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_2099","instance":2099,"id":172098,"goal":"lemma ModBounds_2099(k: nat, i: nat)\n requires i > 0\n ensures 0 <= k % i < i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_2100","instance":2100,"id":172099,"goal":"lemma Square_Nonneg_2100(z: real)\n ensures z * z >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_2101","instance":2101,"id":172100,"goal":"lemma AddComm_2101(d: int, j: int)\n ensures d + j == j + d\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_2102","instance":2102,"id":172101,"goal":"lemma AddAssoc_2102(x: nat, z: nat, k: nat)\n ensures (x + z) + k == x + (z + k)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_2103","instance":2103,"id":172102,"goal":"lemma MulComm_2103(k: real, d: real)\n ensures k * d == d * k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_2104","instance":2104,"id":172103,"goal":"lemma MulAssoc_2104(i: int, m: int, n: int)\n ensures (i * m) * n == i * (m * n)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_2105","instance":2105,"id":172104,"goal":"lemma Distrib_2105(y: nat, n: nat, k: nat)\n ensures y * (n + k) == y * n + y * k\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_2106","instance":2106,"id":172105,"goal":"lemma AddZero_2106(m: real)\n ensures m + 0 == m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_2107","instance":2107,"id":172106,"goal":"lemma MulOne_2107(c: int)\n ensures c * 1 == c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_2108","instance":2108,"id":172107,"goal":"lemma MulZero_2108(y: nat)\n ensures y * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_2109","instance":2109,"id":172108,"goal":"lemma LeRefl_2109(m: real)\n ensures m <= m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_2110","instance":2110,"id":172109,"goal":"lemma LeTrans_2110(n: int, c: int, d: int)\n requires n <= c && c <= d\n ensures n <= d\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_2111","instance":2111,"id":172110,"goal":"lemma AddMono_2111(c: nat, i: nat, b: nat)\n requires c <= i\n ensures c + b <= i + b\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_2112","instance":2112,"id":172111,"goal":"lemma Abs_Nonneg_2112(d: real)\n ensures (if d >= 0 then d else -d) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_2113","instance":2113,"id":172112,"goal":"lemma DivMod_2113(a: int, b: int)\n requires b > 0\n ensures a == b * (a / b) + (a % b)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_2114","instance":2114,"id":172113,"goal":"lemma ModBounds_2114(y: nat, z: nat)\n requires z > 0\n ensures 0 <= y % z < z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_2115","instance":2115,"id":172114,"goal":"lemma Square_Nonneg_2115(i: real)\n ensures i * i >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_2116","instance":2116,"id":172115,"goal":"lemma AddComm_2116(k: int, d: int)\n ensures k + d == d + k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_2117","instance":2117,"id":172116,"goal":"lemma AddAssoc_2117(b: nat, y: nat, i: nat)\n ensures (b + y) + i == b + (y + i)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_2118","instance":2118,"id":172117,"goal":"lemma MulComm_2118(a: real, d: real)\n ensures a * d == d * a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_2119","instance":2119,"id":172118,"goal":"lemma MulAssoc_2119(x: int, m: int, n: int)\n ensures (x * m) * n == x * (m * n)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_2120","instance":2120,"id":172119,"goal":"lemma Distrib_2120(b: nat, y: nat, k: nat)\n ensures b * (y + k) == b * y + b * k\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_2121","instance":2121,"id":172120,"goal":"lemma AddZero_2121(d: real)\n ensures d + 0 == d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_2122","instance":2122,"id":172121,"goal":"lemma MulOne_2122(x: int)\n ensures x * 1 == x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_2123","instance":2123,"id":172122,"goal":"lemma MulZero_2123(x: nat)\n ensures x * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_2124","instance":2124,"id":172123,"goal":"lemma LeRefl_2124(k: real)\n ensures k <= k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_2125","instance":2125,"id":172124,"goal":"lemma LeTrans_2125(z: int, n: int, d: int)\n requires z <= n && n <= d\n ensures z <= d\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_2126","instance":2126,"id":172125,"goal":"lemma AddMono_2126(a: nat, j: nat, i: nat)\n requires a <= j\n ensures a + i <= j + i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_2127","instance":2127,"id":172126,"goal":"lemma Abs_Nonneg_2127(i: real)\n ensures (if i >= 0 then i else -i) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_2128","instance":2128,"id":172127,"goal":"lemma DivMod_2128(y: int, n: int)\n requires n > 0\n ensures y == n * (y / n) + (y % n)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_2129","instance":2129,"id":172128,"goal":"lemma ModBounds_2129(m: nat, z: nat)\n requires z > 0\n ensures 0 <= m % z < z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_2130","instance":2130,"id":172129,"goal":"lemma Square_Nonneg_2130(c: real)\n ensures c * c >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_2131","instance":2131,"id":172130,"goal":"lemma AddComm_2131(m: int, k: int)\n ensures m + k == k + m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_2132","instance":2132,"id":172131,"goal":"lemma AddAssoc_2132(x: nat, k: nat, n: nat)\n ensures (x + k) + n == x + (k + n)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_2133","instance":2133,"id":172132,"goal":"lemma MulComm_2133(x: real, j: real)\n ensures x * j == j * x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_2134","instance":2134,"id":172133,"goal":"lemma MulAssoc_2134(i: int, z: int, n: int)\n ensures (i * z) * n == i * (z * n)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_2135","instance":2135,"id":172134,"goal":"lemma Distrib_2135(k: nat, m: nat, y: nat)\n ensures k * (m + y) == k * m + k * y\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_2136","instance":2136,"id":172135,"goal":"lemma AddZero_2136(x: real)\n ensures x + 0 == x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_2137","instance":2137,"id":172136,"goal":"lemma MulOne_2137(d: int)\n ensures d * 1 == d\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_2138","instance":2138,"id":172137,"goal":"lemma MulZero_2138(n: nat)\n ensures n * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_2139","instance":2139,"id":172138,"goal":"lemma LeRefl_2139(x: real)\n ensures x <= x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_2140","instance":2140,"id":172139,"goal":"lemma LeTrans_2140(a: int, x: int, j: int)\n requires a <= x && x <= j\n ensures a <= j\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_2141","instance":2141,"id":172140,"goal":"lemma AddMono_2141(a: nat, c: nat, b: nat)\n requires a <= c\n ensures a + b <= c + b\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_2142","instance":2142,"id":172141,"goal":"lemma Abs_Nonneg_2142(x: real)\n ensures (if x >= 0 then x else -x) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_2143","instance":2143,"id":172142,"goal":"lemma DivMod_2143(z: int, b: int)\n requires b > 0\n ensures z == b * (z / b) + (z % b)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_2144","instance":2144,"id":172143,"goal":"lemma ModBounds_2144(c: nat, a: nat)\n requires a > 0\n ensures 0 <= c % a < a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_2145","instance":2145,"id":172144,"goal":"lemma Square_Nonneg_2145(z: real)\n ensures z * z >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_2146","instance":2146,"id":172145,"goal":"lemma AddComm_2146(z: int, n: int)\n ensures z + n == n + z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_2147","instance":2147,"id":172146,"goal":"lemma AddAssoc_2147(d: nat, k: nat, n: nat)\n ensures (d + k) + n == d + (k + n)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_2148","instance":2148,"id":172147,"goal":"lemma MulComm_2148(y: real, m: real)\n ensures y * m == m * y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_2149","instance":2149,"id":172148,"goal":"lemma MulAssoc_2149(n: int, m: int, x: int)\n ensures (n * m) * x == n * (m * x)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_2150","instance":2150,"id":172149,"goal":"lemma Distrib_2150(a: nat, d: nat, m: nat)\n ensures a * (d + m) == a * d + a * m\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_2151","instance":2151,"id":172150,"goal":"lemma AddZero_2151(i: real)\n ensures i + 0 == i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_2152","instance":2152,"id":172151,"goal":"lemma MulOne_2152(m: int)\n ensures m * 1 == m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_2153","instance":2153,"id":172152,"goal":"lemma MulZero_2153(y: nat)\n ensures y * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_2154","instance":2154,"id":172153,"goal":"lemma LeRefl_2154(x: real)\n ensures x <= x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_2155","instance":2155,"id":172154,"goal":"lemma LeTrans_2155(n: int, x: int, i: int)\n requires n <= x && x <= i\n ensures n <= i\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_2156","instance":2156,"id":172155,"goal":"lemma AddMono_2156(i: nat, a: nat, n: nat)\n requires i <= a\n ensures i + n <= a + n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_2157","instance":2157,"id":172156,"goal":"lemma Abs_Nonneg_2157(i: real)\n ensures (if i >= 0 then i else -i) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_2158","instance":2158,"id":172157,"goal":"lemma DivMod_2158(a: int, m: int)\n requires m > 0\n ensures a == m * (a / m) + (a % m)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_2159","instance":2159,"id":172158,"goal":"lemma ModBounds_2159(j: nat, c: nat)\n requires c > 0\n ensures 0 <= j % c < c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_2160","instance":2160,"id":172159,"goal":"lemma Square_Nonneg_2160(d: real)\n ensures d * d >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_2161","instance":2161,"id":172160,"goal":"lemma AddComm_2161(z: int, a: int)\n ensures z + a == a + z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_2162","instance":2162,"id":172161,"goal":"lemma AddAssoc_2162(k: nat, n: nat, m: nat)\n ensures (k + n) + m == k + (n + m)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_2163","instance":2163,"id":172162,"goal":"lemma MulComm_2163(a: real, x: real)\n ensures a * x == x * a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_2164","instance":2164,"id":172163,"goal":"lemma MulAssoc_2164(m: int, d: int, k: int)\n ensures (m * d) * k == m * (d * k)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_2165","instance":2165,"id":172164,"goal":"lemma Distrib_2165(c: nat, a: nat, y: nat)\n ensures c * (a + y) == c * a + c * y\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_2166","instance":2166,"id":172165,"goal":"lemma AddZero_2166(m: real)\n ensures m + 0 == m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_2167","instance":2167,"id":172166,"goal":"lemma MulOne_2167(a: int)\n ensures a * 1 == a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_2168","instance":2168,"id":172167,"goal":"lemma MulZero_2168(x: nat)\n ensures x * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_2169","instance":2169,"id":172168,"goal":"lemma LeRefl_2169(b: real)\n ensures b <= b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_2170","instance":2170,"id":172169,"goal":"lemma LeTrans_2170(z: int, y: int, i: int)\n requires z <= y && y <= i\n ensures z <= i\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_2171","instance":2171,"id":172170,"goal":"lemma AddMono_2171(y: nat, b: nat, j: nat)\n requires y <= b\n ensures y + j <= b + j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_2172","instance":2172,"id":172171,"goal":"lemma Abs_Nonneg_2172(x: real)\n ensures (if x >= 0 then x else -x) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_2173","instance":2173,"id":172172,"goal":"lemma DivMod_2173(x: int, j: int)\n requires j > 0\n ensures x == j * (x / j) + (x % j)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_2174","instance":2174,"id":172173,"goal":"lemma ModBounds_2174(x: nat, y: nat)\n requires y > 0\n ensures 0 <= x % y < y\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_2175","instance":2175,"id":172174,"goal":"lemma Square_Nonneg_2175(y: real)\n ensures y * y >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_2176","instance":2176,"id":172175,"goal":"lemma AddComm_2176(a: int, k: int)\n ensures a + k == k + a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_2177","instance":2177,"id":172176,"goal":"lemma AddAssoc_2177(d: nat, k: nat, z: nat)\n ensures (d + k) + z == d + (k + z)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_2178","instance":2178,"id":172177,"goal":"lemma MulComm_2178(k: real, z: real)\n ensures k * z == z * k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_2179","instance":2179,"id":172178,"goal":"lemma MulAssoc_2179(b: int, n: int, j: int)\n ensures (b * n) * j == b * (n * j)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_2180","instance":2180,"id":172179,"goal":"lemma Distrib_2180(z: nat, b: nat, i: nat)\n ensures z * (b + i) == z * b + z * i\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_2181","instance":2181,"id":172180,"goal":"lemma AddZero_2181(d: real)\n ensures d + 0 == d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_2182","instance":2182,"id":172181,"goal":"lemma MulOne_2182(m: int)\n ensures m * 1 == m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_2183","instance":2183,"id":172182,"goal":"lemma MulZero_2183(d: nat)\n ensures d * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_2184","instance":2184,"id":172183,"goal":"lemma LeRefl_2184(m: real)\n ensures m <= m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_2185","instance":2185,"id":172184,"goal":"lemma LeTrans_2185(c: int, d: int, i: int)\n requires c <= d && d <= i\n ensures c <= i\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_2186","instance":2186,"id":172185,"goal":"lemma AddMono_2186(d: nat, c: nat, x: nat)\n requires d <= c\n ensures d + x <= c + x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_2187","instance":2187,"id":172186,"goal":"lemma Abs_Nonneg_2187(j: real)\n ensures (if j >= 0 then j else -j) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_2188","instance":2188,"id":172187,"goal":"lemma DivMod_2188(a: int, y: int)\n requires y > 0\n ensures a == y * (a / y) + (a % y)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_2189","instance":2189,"id":172188,"goal":"lemma ModBounds_2189(a: nat, x: nat)\n requires x > 0\n ensures 0 <= a % x < x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_2190","instance":2190,"id":172189,"goal":"lemma Square_Nonneg_2190(j: real)\n ensures j * j >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_2191","instance":2191,"id":172190,"goal":"lemma AddComm_2191(y: int, n: int)\n ensures y + n == n + y\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_2192","instance":2192,"id":172191,"goal":"lemma AddAssoc_2192(c: nat, d: nat, k: nat)\n ensures (c + d) + k == c + (d + k)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_2193","instance":2193,"id":172192,"goal":"lemma MulComm_2193(b: real, m: real)\n ensures b * m == m * b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_2194","instance":2194,"id":172193,"goal":"lemma MulAssoc_2194(d: int, k: int, z: int)\n ensures (d * k) * z == d * (k * z)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_2195","instance":2195,"id":172194,"goal":"lemma Distrib_2195(a: nat, b: nat, x: nat)\n ensures a * (b + x) == a * b + a * x\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_2196","instance":2196,"id":172195,"goal":"lemma AddZero_2196(a: real)\n ensures a + 0 == a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_2197","instance":2197,"id":172196,"goal":"lemma MulOne_2197(m: int)\n ensures m * 1 == m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_2198","instance":2198,"id":172197,"goal":"lemma MulZero_2198(z: nat)\n ensures z * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_2199","instance":2199,"id":172198,"goal":"lemma LeRefl_2199(j: real)\n ensures j <= j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_2200","instance":2200,"id":172199,"goal":"lemma LeTrans_2200(n: int, z: int, x: int)\n requires n <= z && z <= x\n ensures n <= x\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_2201","instance":2201,"id":172200,"goal":"lemma AddMono_2201(n: nat, y: nat, c: nat)\n requires n <= y\n ensures n + c <= y + c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_2202","instance":2202,"id":172201,"goal":"lemma Abs_Nonneg_2202(a: real)\n ensures (if a >= 0 then a else -a) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_2203","instance":2203,"id":172202,"goal":"lemma DivMod_2203(n: int, b: int)\n requires b > 0\n ensures n == b * (n / b) + (n % b)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_2204","instance":2204,"id":172203,"goal":"lemma ModBounds_2204(b: nat, k: nat)\n requires k > 0\n ensures 0 <= b % k < k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_2205","instance":2205,"id":172204,"goal":"lemma Square_Nonneg_2205(j: real)\n ensures j * j >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_2206","instance":2206,"id":172205,"goal":"lemma AddComm_2206(m: int, y: int)\n ensures m + y == y + m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_2207","instance":2207,"id":172206,"goal":"lemma AddAssoc_2207(m: nat, y: nat, c: nat)\n ensures (m + y) + c == m + (y + c)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_2208","instance":2208,"id":172207,"goal":"lemma MulComm_2208(c: real, y: real)\n ensures c * y == y * c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_2209","instance":2209,"id":172208,"goal":"lemma MulAssoc_2209(b: int, m: int, x: int)\n ensures (b * m) * x == b * (m * x)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_2210","instance":2210,"id":172209,"goal":"lemma Distrib_2210(i: nat, d: nat, z: nat)\n ensures i * (d + z) == i * d + i * z\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_2211","instance":2211,"id":172210,"goal":"lemma AddZero_2211(i: real)\n ensures i + 0 == i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_2212","instance":2212,"id":172211,"goal":"lemma MulOne_2212(a: int)\n ensures a * 1 == a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_2213","instance":2213,"id":172212,"goal":"lemma MulZero_2213(b: nat)\n ensures b * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_2214","instance":2214,"id":172213,"goal":"lemma LeRefl_2214(m: real)\n ensures m <= m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_2215","instance":2215,"id":172214,"goal":"lemma LeTrans_2215(j: int, c: int, a: int)\n requires j <= c && c <= a\n ensures j <= a\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_2216","instance":2216,"id":172215,"goal":"lemma AddMono_2216(a: nat, x: nat, i: nat)\n requires a <= x\n ensures a + i <= x + i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_2217","instance":2217,"id":172216,"goal":"lemma Abs_Nonneg_2217(j: real)\n ensures (if j >= 0 then j else -j) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_2218","instance":2218,"id":172217,"goal":"lemma DivMod_2218(d: int, a: int)\n requires a > 0\n ensures d == a * (d / a) + (d % a)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_2219","instance":2219,"id":172218,"goal":"lemma ModBounds_2219(n: nat, z: nat)\n requires z > 0\n ensures 0 <= n % z < z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_2220","instance":2220,"id":172219,"goal":"lemma Square_Nonneg_2220(d: real)\n ensures d * d >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_2221","instance":2221,"id":172220,"goal":"lemma AddComm_2221(c: int, n: int)\n ensures c + n == n + c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_2222","instance":2222,"id":172221,"goal":"lemma AddAssoc_2222(a: nat, d: nat, b: nat)\n ensures (a + d) + b == a + (d + b)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_2223","instance":2223,"id":172222,"goal":"lemma MulComm_2223(y: real, a: real)\n ensures y * a == a * y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_2224","instance":2224,"id":172223,"goal":"lemma MulAssoc_2224(a: int, i: int, m: int)\n ensures (a * i) * m == a * (i * m)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_2225","instance":2225,"id":172224,"goal":"lemma Distrib_2225(z: nat, x: nat, d: nat)\n ensures z * (x + d) == z * x + z * d\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_2226","instance":2226,"id":172225,"goal":"lemma AddZero_2226(b: real)\n ensures b + 0 == b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_2227","instance":2227,"id":172226,"goal":"lemma MulOne_2227(d: int)\n ensures d * 1 == d\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_2228","instance":2228,"id":172227,"goal":"lemma MulZero_2228(i: nat)\n ensures i * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_2229","instance":2229,"id":172228,"goal":"lemma LeRefl_2229(a: real)\n ensures a <= a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_2230","instance":2230,"id":172229,"goal":"lemma LeTrans_2230(i: int, b: int, x: int)\n requires i <= b && b <= x\n ensures i <= x\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_2231","instance":2231,"id":172230,"goal":"lemma AddMono_2231(i: nat, k: nat, b: nat)\n requires i <= k\n ensures i + b <= k + b\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_2232","instance":2232,"id":172231,"goal":"lemma Abs_Nonneg_2232(y: real)\n ensures (if y >= 0 then y else -y) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_2233","instance":2233,"id":172232,"goal":"lemma DivMod_2233(j: int, y: int)\n requires y > 0\n ensures j == y * (j / y) + (j % y)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_2234","instance":2234,"id":172233,"goal":"lemma ModBounds_2234(n: nat, y: nat)\n requires y > 0\n ensures 0 <= n % y < y\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_2235","instance":2235,"id":172234,"goal":"lemma Square_Nonneg_2235(n: real)\n ensures n * n >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_2236","instance":2236,"id":172235,"goal":"lemma AddComm_2236(a: int, x: int)\n ensures a + x == x + a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_2237","instance":2237,"id":172236,"goal":"lemma AddAssoc_2237(y: nat, m: nat, n: nat)\n ensures (y + m) + n == y + (m + n)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_2238","instance":2238,"id":172237,"goal":"lemma MulComm_2238(z: real, i: real)\n ensures z * i == i * z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_2239","instance":2239,"id":172238,"goal":"lemma MulAssoc_2239(y: int, i: int, x: int)\n ensures (y * i) * x == y * (i * x)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_2240","instance":2240,"id":172239,"goal":"lemma Distrib_2240(y: nat, j: nat, a: nat)\n ensures y * (j + a) == y * j + y * a\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_2241","instance":2241,"id":172240,"goal":"lemma AddZero_2241(j: real)\n ensures j + 0 == j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_2242","instance":2242,"id":172241,"goal":"lemma MulOne_2242(z: int)\n ensures z * 1 == z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_2243","instance":2243,"id":172242,"goal":"lemma MulZero_2243(b: nat)\n ensures b * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_2244","instance":2244,"id":172243,"goal":"lemma LeRefl_2244(j: real)\n ensures j <= j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_2245","instance":2245,"id":172244,"goal":"lemma LeTrans_2245(y: int, a: int, x: int)\n requires y <= a && a <= x\n ensures y <= x\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_2246","instance":2246,"id":172245,"goal":"lemma AddMono_2246(b: nat, m: nat, n: nat)\n requires b <= m\n ensures b + n <= m + n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_2247","instance":2247,"id":172246,"goal":"lemma Abs_Nonneg_2247(n: real)\n ensures (if n >= 0 then n else -n) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_2248","instance":2248,"id":172247,"goal":"lemma DivMod_2248(i: int, x: int)\n requires x > 0\n ensures i == x * (i / x) + (i % x)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_2249","instance":2249,"id":172248,"goal":"lemma ModBounds_2249(d: nat, b: nat)\n requires b > 0\n ensures 0 <= d % b < b\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_2250","instance":2250,"id":172249,"goal":"lemma Square_Nonneg_2250(j: real)\n ensures j * j >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_2251","instance":2251,"id":172250,"goal":"lemma AddComm_2251(d: int, m: int)\n ensures d + m == m + d\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_2252","instance":2252,"id":172251,"goal":"lemma AddAssoc_2252(a: nat, j: nat, m: nat)\n ensures (a + j) + m == a + (j + m)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_2253","instance":2253,"id":172252,"goal":"lemma MulComm_2253(n: real, d: real)\n ensures n * d == d * n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_2254","instance":2254,"id":172253,"goal":"lemma MulAssoc_2254(b: int, z: int, x: int)\n ensures (b * z) * x == b * (z * x)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_2255","instance":2255,"id":172254,"goal":"lemma Distrib_2255(z: nat, m: nat, y: nat)\n ensures z * (m + y) == z * m + z * y\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_2256","instance":2256,"id":172255,"goal":"lemma AddZero_2256(k: real)\n ensures k + 0 == k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_2257","instance":2257,"id":172256,"goal":"lemma MulOne_2257(k: int)\n ensures k * 1 == k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_2258","instance":2258,"id":172257,"goal":"lemma MulZero_2258(n: nat)\n ensures n * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_2259","instance":2259,"id":172258,"goal":"lemma LeRefl_2259(k: real)\n ensures k <= k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_2260","instance":2260,"id":172259,"goal":"lemma LeTrans_2260(c: int, y: int, j: int)\n requires c <= y && y <= j\n ensures c <= j\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_2261","instance":2261,"id":172260,"goal":"lemma AddMono_2261(j: nat, m: nat, z: nat)\n requires j <= m\n ensures j + z <= m + z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_2262","instance":2262,"id":172261,"goal":"lemma Abs_Nonneg_2262(b: real)\n ensures (if b >= 0 then b else -b) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_2263","instance":2263,"id":172262,"goal":"lemma DivMod_2263(n: int, i: int)\n requires i > 0\n ensures n == i * (n / i) + (n % i)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_2264","instance":2264,"id":172263,"goal":"lemma ModBounds_2264(k: nat, y: nat)\n requires y > 0\n ensures 0 <= k % y < y\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_2265","instance":2265,"id":172264,"goal":"lemma Square_Nonneg_2265(i: real)\n ensures i * i >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_2266","instance":2266,"id":172265,"goal":"lemma AddComm_2266(b: int, j: int)\n ensures b + j == j + b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_2267","instance":2267,"id":172266,"goal":"lemma AddAssoc_2267(m: nat, k: nat, c: nat)\n ensures (m + k) + c == m + (k + c)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_2268","instance":2268,"id":172267,"goal":"lemma MulComm_2268(b: real, k: real)\n ensures b * k == k * b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_2269","instance":2269,"id":172268,"goal":"lemma MulAssoc_2269(z: int, i: int, y: int)\n ensures (z * i) * y == z * (i * y)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_2270","instance":2270,"id":172269,"goal":"lemma Distrib_2270(a: nat, b: nat, d: nat)\n ensures a * (b + d) == a * b + a * d\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_2271","instance":2271,"id":172270,"goal":"lemma AddZero_2271(k: real)\n ensures k + 0 == k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_2272","instance":2272,"id":172271,"goal":"lemma MulOne_2272(z: int)\n ensures z * 1 == z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_2273","instance":2273,"id":172272,"goal":"lemma MulZero_2273(y: nat)\n ensures y * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_2274","instance":2274,"id":172273,"goal":"lemma LeRefl_2274(b: real)\n ensures b <= b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_2275","instance":2275,"id":172274,"goal":"lemma LeTrans_2275(k: int, j: int, z: int)\n requires k <= j && j <= z\n ensures k <= z\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_2276","instance":2276,"id":172275,"goal":"lemma AddMono_2276(x: nat, m: nat, d: nat)\n requires x <= m\n ensures x + d <= m + d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_2277","instance":2277,"id":172276,"goal":"lemma Abs_Nonneg_2277(z: real)\n ensures (if z >= 0 then z else -z) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_2278","instance":2278,"id":172277,"goal":"lemma DivMod_2278(d: int, z: int)\n requires z > 0\n ensures d == z * (d / z) + (d % z)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_2279","instance":2279,"id":172278,"goal":"lemma ModBounds_2279(x: nat, k: nat)\n requires k > 0\n ensures 0 <= x % k < k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_2280","instance":2280,"id":172279,"goal":"lemma Square_Nonneg_2280(i: real)\n ensures i * i >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_2281","instance":2281,"id":172280,"goal":"lemma AddComm_2281(x: int, a: int)\n ensures x + a == a + x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_2282","instance":2282,"id":172281,"goal":"lemma AddAssoc_2282(m: nat, x: nat, i: nat)\n ensures (m + x) + i == m + (x + i)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_2283","instance":2283,"id":172282,"goal":"lemma MulComm_2283(z: real, k: real)\n ensures z * k == k * z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_2284","instance":2284,"id":172283,"goal":"lemma MulAssoc_2284(c: int, b: int, m: int)\n ensures (c * b) * m == c * (b * m)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_2285","instance":2285,"id":172284,"goal":"lemma Distrib_2285(n: nat, j: nat, y: nat)\n ensures n * (j + y) == n * j + n * y\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_2286","instance":2286,"id":172285,"goal":"lemma AddZero_2286(k: real)\n ensures k + 0 == k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_2287","instance":2287,"id":172286,"goal":"lemma MulOne_2287(c: int)\n ensures c * 1 == c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_2288","instance":2288,"id":172287,"goal":"lemma MulZero_2288(y: nat)\n ensures y * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_2289","instance":2289,"id":172288,"goal":"lemma LeRefl_2289(k: real)\n ensures k <= k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_2290","instance":2290,"id":172289,"goal":"lemma LeTrans_2290(b: int, c: int, a: int)\n requires b <= c && c <= a\n ensures b <= a\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_2291","instance":2291,"id":172290,"goal":"lemma AddMono_2291(z: nat, x: nat, i: nat)\n requires z <= x\n ensures z + i <= x + i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_2292","instance":2292,"id":172291,"goal":"lemma Abs_Nonneg_2292(z: real)\n ensures (if z >= 0 then z else -z) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_2293","instance":2293,"id":172292,"goal":"lemma DivMod_2293(z: int, m: int)\n requires m > 0\n ensures z == m * (z / m) + (z % m)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_2294","instance":2294,"id":172293,"goal":"lemma ModBounds_2294(b: nat, j: nat)\n requires j > 0\n ensures 0 <= b % j < j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_2295","instance":2295,"id":172294,"goal":"lemma Square_Nonneg_2295(a: real)\n ensures a * a >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_2296","instance":2296,"id":172295,"goal":"lemma AddComm_2296(z: int, c: int)\n ensures z + c == c + z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_2297","instance":2297,"id":172296,"goal":"lemma AddAssoc_2297(j: nat, c: nat, x: nat)\n ensures (j + c) + x == j + (c + x)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_2298","instance":2298,"id":172297,"goal":"lemma MulComm_2298(k: real, m: real)\n ensures k * m == m * k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_2299","instance":2299,"id":172298,"goal":"lemma MulAssoc_2299(z: int, a: int, m: int)\n ensures (z * a) * m == z * (a * m)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_2300","instance":2300,"id":172299,"goal":"lemma Distrib_2300(x: nat, y: nat, n: nat)\n ensures x * (y + n) == x * y + x * n\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_2301","instance":2301,"id":172300,"goal":"lemma AddZero_2301(x: real)\n ensures x + 0 == x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_2302","instance":2302,"id":172301,"goal":"lemma MulOne_2302(a: int)\n ensures a * 1 == a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_2303","instance":2303,"id":172302,"goal":"lemma MulZero_2303(i: nat)\n ensures i * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_2304","instance":2304,"id":172303,"goal":"lemma LeRefl_2304(k: real)\n ensures k <= k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_2305","instance":2305,"id":172304,"goal":"lemma LeTrans_2305(n: int, m: int, j: int)\n requires n <= m && m <= j\n ensures n <= j\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_2306","instance":2306,"id":172305,"goal":"lemma AddMono_2306(n: nat, c: nat, i: nat)\n requires n <= c\n ensures n + i <= c + i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_2307","instance":2307,"id":172306,"goal":"lemma Abs_Nonneg_2307(b: real)\n ensures (if b >= 0 then b else -b) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_2308","instance":2308,"id":172307,"goal":"lemma DivMod_2308(m: int, a: int)\n requires a > 0\n ensures m == a * (m / a) + (m % a)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_2309","instance":2309,"id":172308,"goal":"lemma ModBounds_2309(d: nat, y: nat)\n requires y > 0\n ensures 0 <= d % y < y\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_2310","instance":2310,"id":172309,"goal":"lemma Square_Nonneg_2310(k: real)\n ensures k * k >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_2311","instance":2311,"id":172310,"goal":"lemma AddComm_2311(i: int, y: int)\n ensures i + y == y + i\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_2312","instance":2312,"id":172311,"goal":"lemma AddAssoc_2312(a: nat, d: nat, x: nat)\n ensures (a + d) + x == a + (d + x)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_2313","instance":2313,"id":172312,"goal":"lemma MulComm_2313(c: real, x: real)\n ensures c * x == x * c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_2314","instance":2314,"id":172313,"goal":"lemma MulAssoc_2314(c: int, z: int, a: int)\n ensures (c * z) * a == c * (z * a)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_2315","instance":2315,"id":172314,"goal":"lemma Distrib_2315(a: nat, m: nat, d: nat)\n ensures a * (m + d) == a * m + a * d\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_2316","instance":2316,"id":172315,"goal":"lemma AddZero_2316(d: real)\n ensures d + 0 == d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_2317","instance":2317,"id":172316,"goal":"lemma MulOne_2317(d: int)\n ensures d * 1 == d\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_2318","instance":2318,"id":172317,"goal":"lemma MulZero_2318(x: nat)\n ensures x * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_2319","instance":2319,"id":172318,"goal":"lemma LeRefl_2319(i: real)\n ensures i <= i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_2320","instance":2320,"id":172319,"goal":"lemma LeTrans_2320(j: int, y: int, x: int)\n requires j <= y && y <= x\n ensures j <= x\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_2321","instance":2321,"id":172320,"goal":"lemma AddMono_2321(k: nat, x: nat, i: nat)\n requires k <= x\n ensures k + i <= x + i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_2322","instance":2322,"id":172321,"goal":"lemma Abs_Nonneg_2322(k: real)\n ensures (if k >= 0 then k else -k) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_2323","instance":2323,"id":172322,"goal":"lemma DivMod_2323(j: int, a: int)\n requires a > 0\n ensures j == a * (j / a) + (j % a)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_2324","instance":2324,"id":172323,"goal":"lemma ModBounds_2324(m: nat, k: nat)\n requires k > 0\n ensures 0 <= m % k < k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_2325","instance":2325,"id":172324,"goal":"lemma Square_Nonneg_2325(x: real)\n ensures x * x >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_2326","instance":2326,"id":172325,"goal":"lemma AddComm_2326(x: int, n: int)\n ensures x + n == n + x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_2327","instance":2327,"id":172326,"goal":"lemma AddAssoc_2327(n: nat, y: nat, j: nat)\n ensures (n + y) + j == n + (y + j)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_2328","instance":2328,"id":172327,"goal":"lemma MulComm_2328(d: real, j: real)\n ensures d * j == j * d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_2329","instance":2329,"id":172328,"goal":"lemma MulAssoc_2329(i: int, x: int, b: int)\n ensures (i * x) * b == i * (x * b)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_2330","instance":2330,"id":172329,"goal":"lemma Distrib_2330(y: nat, b: nat, c: nat)\n ensures y * (b + c) == y * b + y * c\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_2331","instance":2331,"id":172330,"goal":"lemma AddZero_2331(c: real)\n ensures c + 0 == c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_2332","instance":2332,"id":172331,"goal":"lemma MulOne_2332(i: int)\n ensures i * 1 == i\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_2333","instance":2333,"id":172332,"goal":"lemma MulZero_2333(d: nat)\n ensures d * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_2334","instance":2334,"id":172333,"goal":"lemma LeRefl_2334(z: real)\n ensures z <= z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_2335","instance":2335,"id":172334,"goal":"lemma LeTrans_2335(m: int, d: int, j: int)\n requires m <= d && d <= j\n ensures m <= j\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_2336","instance":2336,"id":172335,"goal":"lemma AddMono_2336(x: nat, y: nat, d: nat)\n requires x <= y\n ensures x + d <= y + d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_2337","instance":2337,"id":172336,"goal":"lemma Abs_Nonneg_2337(j: real)\n ensures (if j >= 0 then j else -j) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_2338","instance":2338,"id":172337,"goal":"lemma DivMod_2338(a: int, m: int)\n requires m > 0\n ensures a == m * (a / m) + (a % m)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_2339","instance":2339,"id":172338,"goal":"lemma ModBounds_2339(k: nat, a: nat)\n requires a > 0\n ensures 0 <= k % a < a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_2340","instance":2340,"id":172339,"goal":"lemma Square_Nonneg_2340(k: real)\n ensures k * k >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_2341","instance":2341,"id":172340,"goal":"lemma AddComm_2341(k: int, c: int)\n ensures k + c == c + k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_2342","instance":2342,"id":172341,"goal":"lemma AddAssoc_2342(z: nat, c: nat, b: nat)\n ensures (z + c) + b == z + (c + b)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_2343","instance":2343,"id":172342,"goal":"lemma MulComm_2343(i: real, m: real)\n ensures i * m == m * i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_2344","instance":2344,"id":172343,"goal":"lemma MulAssoc_2344(y: int, z: int, a: int)\n ensures (y * z) * a == y * (z * a)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_2345","instance":2345,"id":172344,"goal":"lemma Distrib_2345(m: nat, j: nat, x: nat)\n ensures m * (j + x) == m * j + m * x\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_2346","instance":2346,"id":172345,"goal":"lemma AddZero_2346(y: real)\n ensures y + 0 == y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_2347","instance":2347,"id":172346,"goal":"lemma MulOne_2347(d: int)\n ensures d * 1 == d\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_2348","instance":2348,"id":172347,"goal":"lemma MulZero_2348(z: nat)\n ensures z * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_2349","instance":2349,"id":172348,"goal":"lemma LeRefl_2349(m: real)\n ensures m <= m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_2350","instance":2350,"id":172349,"goal":"lemma LeTrans_2350(k: int, d: int, z: int)\n requires k <= d && d <= z\n ensures k <= z\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_2351","instance":2351,"id":172350,"goal":"lemma AddMono_2351(d: nat, b: nat, c: nat)\n requires d <= b\n ensures d + c <= b + c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_2352","instance":2352,"id":172351,"goal":"lemma Abs_Nonneg_2352(x: real)\n ensures (if x >= 0 then x else -x) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_2353","instance":2353,"id":172352,"goal":"lemma DivMod_2353(k: int, d: int)\n requires d > 0\n ensures k == d * (k / d) + (k % d)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_2354","instance":2354,"id":172353,"goal":"lemma ModBounds_2354(i: nat, d: nat)\n requires d > 0\n ensures 0 <= i % d < d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_2355","instance":2355,"id":172354,"goal":"lemma Square_Nonneg_2355(a: real)\n ensures a * a >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_2356","instance":2356,"id":172355,"goal":"lemma AddComm_2356(b: int, z: int)\n ensures b + z == z + b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_2357","instance":2357,"id":172356,"goal":"lemma AddAssoc_2357(y: nat, b: nat, a: nat)\n ensures (y + b) + a == y + (b + a)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_2358","instance":2358,"id":172357,"goal":"lemma MulComm_2358(m: real, x: real)\n ensures m * x == x * m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_2359","instance":2359,"id":172358,"goal":"lemma MulAssoc_2359(z: int, k: int, n: int)\n ensures (z * k) * n == z * (k * n)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_2360","instance":2360,"id":172359,"goal":"lemma Distrib_2360(c: nat, d: nat, y: nat)\n ensures c * (d + y) == c * d + c * y\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_2361","instance":2361,"id":172360,"goal":"lemma AddZero_2361(b: real)\n ensures b + 0 == b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_2362","instance":2362,"id":172361,"goal":"lemma MulOne_2362(k: int)\n ensures k * 1 == k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_2363","instance":2363,"id":172362,"goal":"lemma MulZero_2363(y: nat)\n ensures y * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_2364","instance":2364,"id":172363,"goal":"lemma LeRefl_2364(c: real)\n ensures c <= c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_2365","instance":2365,"id":172364,"goal":"lemma LeTrans_2365(c: int, j: int, k: int)\n requires c <= j && j <= k\n ensures c <= k\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_2366","instance":2366,"id":172365,"goal":"lemma AddMono_2366(k: nat, x: nat, m: nat)\n requires k <= x\n ensures k + m <= x + m\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_2367","instance":2367,"id":172366,"goal":"lemma Abs_Nonneg_2367(k: real)\n ensures (if k >= 0 then k else -k) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_2368","instance":2368,"id":172367,"goal":"lemma DivMod_2368(i: int, k: int)\n requires k > 0\n ensures i == k * (i / k) + (i % k)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_2369","instance":2369,"id":172368,"goal":"lemma ModBounds_2369(y: nat, b: nat)\n requires b > 0\n ensures 0 <= y % b < b\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_2370","instance":2370,"id":172369,"goal":"lemma Square_Nonneg_2370(x: real)\n ensures x * x >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_2371","instance":2371,"id":172370,"goal":"lemma AddComm_2371(a: int, d: int)\n ensures a + d == d + a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_2372","instance":2372,"id":172371,"goal":"lemma AddAssoc_2372(y: nat, b: nat, c: nat)\n ensures (y + b) + c == y + (b + c)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_2373","instance":2373,"id":172372,"goal":"lemma MulComm_2373(i: real, j: real)\n ensures i * j == j * i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_2374","instance":2374,"id":172373,"goal":"lemma MulAssoc_2374(i: int, j: int, a: int)\n ensures (i * j) * a == i * (j * a)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_2375","instance":2375,"id":172374,"goal":"lemma Distrib_2375(a: nat, c: nat, b: nat)\n ensures a * (c + b) == a * c + a * b\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_2376","instance":2376,"id":172375,"goal":"lemma AddZero_2376(z: real)\n ensures z + 0 == z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_2377","instance":2377,"id":172376,"goal":"lemma MulOne_2377(j: int)\n ensures j * 1 == j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_2378","instance":2378,"id":172377,"goal":"lemma MulZero_2378(k: nat)\n ensures k * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_2379","instance":2379,"id":172378,"goal":"lemma LeRefl_2379(i: real)\n ensures i <= i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_2380","instance":2380,"id":172379,"goal":"lemma LeTrans_2380(x: int, j: int, n: int)\n requires x <= j && j <= n\n ensures x <= n\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_2381","instance":2381,"id":172380,"goal":"lemma AddMono_2381(n: nat, z: nat, j: nat)\n requires n <= z\n ensures n + j <= z + j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_2382","instance":2382,"id":172381,"goal":"lemma Abs_Nonneg_2382(i: real)\n ensures (if i >= 0 then i else -i) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_2383","instance":2383,"id":172382,"goal":"lemma DivMod_2383(i: int, a: int)\n requires a > 0\n ensures i == a * (i / a) + (i % a)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_2384","instance":2384,"id":172383,"goal":"lemma ModBounds_2384(x: nat, y: nat)\n requires y > 0\n ensures 0 <= x % y < y\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_2385","instance":2385,"id":172384,"goal":"lemma Square_Nonneg_2385(z: real)\n ensures z * z >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_2386","instance":2386,"id":172385,"goal":"lemma AddComm_2386(n: int, a: int)\n ensures n + a == a + n\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_2387","instance":2387,"id":172386,"goal":"lemma AddAssoc_2387(y: nat, n: nat, b: nat)\n ensures (y + n) + b == y + (n + b)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_2388","instance":2388,"id":172387,"goal":"lemma MulComm_2388(i: real, j: real)\n ensures i * j == j * i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_2389","instance":2389,"id":172388,"goal":"lemma MulAssoc_2389(c: int, i: int, j: int)\n ensures (c * i) * j == c * (i * j)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_2390","instance":2390,"id":172389,"goal":"lemma Distrib_2390(i: nat, a: nat, y: nat)\n ensures i * (a + y) == i * a + i * y\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_2391","instance":2391,"id":172390,"goal":"lemma AddZero_2391(a: real)\n ensures a + 0 == a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_2392","instance":2392,"id":172391,"goal":"lemma MulOne_2392(n: int)\n ensures n * 1 == n\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_2393","instance":2393,"id":172392,"goal":"lemma MulZero_2393(n: nat)\n ensures n * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_2394","instance":2394,"id":172393,"goal":"lemma LeRefl_2394(i: real)\n ensures i <= i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_2395","instance":2395,"id":172394,"goal":"lemma LeTrans_2395(x: int, y: int, z: int)\n requires x <= y && y <= z\n ensures x <= z\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_2396","instance":2396,"id":172395,"goal":"lemma AddMono_2396(x: nat, k: nat, i: nat)\n requires x <= k\n ensures x + i <= k + i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_2397","instance":2397,"id":172396,"goal":"lemma Abs_Nonneg_2397(x: real)\n ensures (if x >= 0 then x else -x) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_2398","instance":2398,"id":172397,"goal":"lemma DivMod_2398(j: int, b: int)\n requires b > 0\n ensures j == b * (j / b) + (j % b)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_2399","instance":2399,"id":172398,"goal":"lemma ModBounds_2399(y: nat, x: nat)\n requires x > 0\n ensures 0 <= y % x < x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_2400","instance":2400,"id":172399,"goal":"lemma Square_Nonneg_2400(z: real)\n ensures z * z >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_2401","instance":2401,"id":172400,"goal":"lemma AddComm_2401(c: int, n: int)\n ensures c + n == n + c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_2402","instance":2402,"id":172401,"goal":"lemma AddAssoc_2402(n: nat, x: nat, k: nat)\n ensures (n + x) + k == n + (x + k)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_2403","instance":2403,"id":172402,"goal":"lemma MulComm_2403(k: real, y: real)\n ensures k * y == y * k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_2404","instance":2404,"id":172403,"goal":"lemma MulAssoc_2404(d: int, a: int, z: int)\n ensures (d * a) * z == d * (a * z)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_2405","instance":2405,"id":172404,"goal":"lemma Distrib_2405(b: nat, d: nat, a: nat)\n ensures b * (d + a) == b * d + b * a\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_2406","instance":2406,"id":172405,"goal":"lemma AddZero_2406(c: real)\n ensures c + 0 == c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_2407","instance":2407,"id":172406,"goal":"lemma MulOne_2407(c: int)\n ensures c * 1 == c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_2408","instance":2408,"id":172407,"goal":"lemma MulZero_2408(k: nat)\n ensures k * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_2409","instance":2409,"id":172408,"goal":"lemma LeRefl_2409(c: real)\n ensures c <= c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_2410","instance":2410,"id":172409,"goal":"lemma LeTrans_2410(n: int, i: int, d: int)\n requires n <= i && i <= d\n ensures n <= d\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_2411","instance":2411,"id":172410,"goal":"lemma AddMono_2411(x: nat, m: nat, y: nat)\n requires x <= m\n ensures x + y <= m + y\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_2412","instance":2412,"id":172411,"goal":"lemma Abs_Nonneg_2412(i: real)\n ensures (if i >= 0 then i else -i) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_2413","instance":2413,"id":172412,"goal":"lemma DivMod_2413(x: int, d: int)\n requires d > 0\n ensures x == d * (x / d) + (x % d)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_2414","instance":2414,"id":172413,"goal":"lemma ModBounds_2414(a: nat, z: nat)\n requires z > 0\n ensures 0 <= a % z < z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_2415","instance":2415,"id":172414,"goal":"lemma Square_Nonneg_2415(i: real)\n ensures i * i >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_2416","instance":2416,"id":172415,"goal":"lemma AddComm_2416(c: int, y: int)\n ensures c + y == y + c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_2417","instance":2417,"id":172416,"goal":"lemma AddAssoc_2417(d: nat, n: nat, m: nat)\n ensures (d + n) + m == d + (n + m)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_2418","instance":2418,"id":172417,"goal":"lemma MulComm_2418(a: real, n: real)\n ensures a * n == n * a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_2419","instance":2419,"id":172418,"goal":"lemma MulAssoc_2419(k: int, i: int, b: int)\n ensures (k * i) * b == k * (i * b)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_2420","instance":2420,"id":172419,"goal":"lemma Distrib_2420(c: nat, b: nat, j: nat)\n ensures c * (b + j) == c * b + c * j\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_2421","instance":2421,"id":172420,"goal":"lemma AddZero_2421(i: real)\n ensures i + 0 == i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_2422","instance":2422,"id":172421,"goal":"lemma MulOne_2422(m: int)\n ensures m * 1 == m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_2423","instance":2423,"id":172422,"goal":"lemma MulZero_2423(c: nat)\n ensures c * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_2424","instance":2424,"id":172423,"goal":"lemma LeRefl_2424(n: real)\n ensures n <= n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_2425","instance":2425,"id":172424,"goal":"lemma LeTrans_2425(c: int, j: int, m: int)\n requires c <= j && j <= m\n ensures c <= m\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_2426","instance":2426,"id":172425,"goal":"lemma AddMono_2426(c: nat, n: nat, b: nat)\n requires c <= n\n ensures c + b <= n + b\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_2427","instance":2427,"id":172426,"goal":"lemma Abs_Nonneg_2427(d: real)\n ensures (if d >= 0 then d else -d) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_2428","instance":2428,"id":172427,"goal":"lemma DivMod_2428(z: int, i: int)\n requires i > 0\n ensures z == i * (z / i) + (z % i)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_2429","instance":2429,"id":172428,"goal":"lemma ModBounds_2429(y: nat, n: nat)\n requires n > 0\n ensures 0 <= y % n < n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_2430","instance":2430,"id":172429,"goal":"lemma Square_Nonneg_2430(m: real)\n ensures m * m >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_2431","instance":2431,"id":172430,"goal":"lemma AddComm_2431(b: int, k: int)\n ensures b + k == k + b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_2432","instance":2432,"id":172431,"goal":"lemma AddAssoc_2432(n: nat, z: nat, y: nat)\n ensures (n + z) + y == n + (z + y)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_2433","instance":2433,"id":172432,"goal":"lemma MulComm_2433(n: real, m: real)\n ensures n * m == m * n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_2434","instance":2434,"id":172433,"goal":"lemma MulAssoc_2434(d: int, m: int, j: int)\n ensures (d * m) * j == d * (m * j)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_2435","instance":2435,"id":172434,"goal":"lemma Distrib_2435(j: nat, a: nat, d: nat)\n ensures j * (a + d) == j * a + j * d\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_2436","instance":2436,"id":172435,"goal":"lemma AddZero_2436(m: real)\n ensures m + 0 == m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_2437","instance":2437,"id":172436,"goal":"lemma MulOne_2437(a: int)\n ensures a * 1 == a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_2438","instance":2438,"id":172437,"goal":"lemma MulZero_2438(j: nat)\n ensures j * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_2439","instance":2439,"id":172438,"goal":"lemma LeRefl_2439(j: real)\n ensures j <= j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_2440","instance":2440,"id":172439,"goal":"lemma LeTrans_2440(a: int, d: int, i: int)\n requires a <= d && d <= i\n ensures a <= i\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_2441","instance":2441,"id":172440,"goal":"lemma AddMono_2441(j: nat, i: nat, m: nat)\n requires j <= i\n ensures j + m <= i + m\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_2442","instance":2442,"id":172441,"goal":"lemma Abs_Nonneg_2442(y: real)\n ensures (if y >= 0 then y else -y) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_2443","instance":2443,"id":172442,"goal":"lemma DivMod_2443(z: int, n: int)\n requires n > 0\n ensures z == n * (z / n) + (z % n)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_2444","instance":2444,"id":172443,"goal":"lemma ModBounds_2444(y: nat, d: nat)\n requires d > 0\n ensures 0 <= y % d < d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_2445","instance":2445,"id":172444,"goal":"lemma Square_Nonneg_2445(j: real)\n ensures j * j >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_2446","instance":2446,"id":172445,"goal":"lemma AddComm_2446(a: int, b: int)\n ensures a + b == b + a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_2447","instance":2447,"id":172446,"goal":"lemma AddAssoc_2447(d: nat, c: nat, j: nat)\n ensures (d + c) + j == d + (c + j)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_2448","instance":2448,"id":172447,"goal":"lemma MulComm_2448(x: real, d: real)\n ensures x * d == d * x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_2449","instance":2449,"id":172448,"goal":"lemma MulAssoc_2449(y: int, a: int, x: int)\n ensures (y * a) * x == y * (a * x)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_2450","instance":2450,"id":172449,"goal":"lemma Distrib_2450(j: nat, i: nat, x: nat)\n ensures j * (i + x) == j * i + j * x\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_2451","instance":2451,"id":172450,"goal":"lemma AddZero_2451(z: real)\n ensures z + 0 == z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_2452","instance":2452,"id":172451,"goal":"lemma MulOne_2452(z: int)\n ensures z * 1 == z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_2453","instance":2453,"id":172452,"goal":"lemma MulZero_2453(j: nat)\n ensures j * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_2454","instance":2454,"id":172453,"goal":"lemma LeRefl_2454(d: real)\n ensures d <= d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_2455","instance":2455,"id":172454,"goal":"lemma LeTrans_2455(n: int, x: int, i: int)\n requires n <= x && x <= i\n ensures n <= i\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_2456","instance":2456,"id":172455,"goal":"lemma AddMono_2456(y: nat, d: nat, n: nat)\n requires y <= d\n ensures y + n <= d + n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_2457","instance":2457,"id":172456,"goal":"lemma Abs_Nonneg_2457(y: real)\n ensures (if y >= 0 then y else -y) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_2458","instance":2458,"id":172457,"goal":"lemma DivMod_2458(j: int, y: int)\n requires y > 0\n ensures j == y * (j / y) + (j % y)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_2459","instance":2459,"id":172458,"goal":"lemma ModBounds_2459(j: nat, b: nat)\n requires b > 0\n ensures 0 <= j % b < b\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_2460","instance":2460,"id":172459,"goal":"lemma Square_Nonneg_2460(k: real)\n ensures k * k >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_2461","instance":2461,"id":172460,"goal":"lemma AddComm_2461(y: int, i: int)\n ensures y + i == i + y\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_2462","instance":2462,"id":172461,"goal":"lemma AddAssoc_2462(y: nat, i: nat, n: nat)\n ensures (y + i) + n == y + (i + n)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_2463","instance":2463,"id":172462,"goal":"lemma MulComm_2463(d: real, i: real)\n ensures d * i == i * d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_2464","instance":2464,"id":172463,"goal":"lemma MulAssoc_2464(c: int, x: int, n: int)\n ensures (c * x) * n == c * (x * n)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_2465","instance":2465,"id":172464,"goal":"lemma Distrib_2465(b: nat, d: nat, i: nat)\n ensures b * (d + i) == b * d + b * i\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_2466","instance":2466,"id":172465,"goal":"lemma AddZero_2466(i: real)\n ensures i + 0 == i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_2467","instance":2467,"id":172466,"goal":"lemma MulOne_2467(b: int)\n ensures b * 1 == b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_2468","instance":2468,"id":172467,"goal":"lemma MulZero_2468(i: nat)\n ensures i * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_2469","instance":2469,"id":172468,"goal":"lemma LeRefl_2469(d: real)\n ensures d <= d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_2470","instance":2470,"id":172469,"goal":"lemma LeTrans_2470(i: int, x: int, y: int)\n requires i <= x && x <= y\n ensures i <= y\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_2471","instance":2471,"id":172470,"goal":"lemma AddMono_2471(a: nat, j: nat, c: nat)\n requires a <= j\n ensures a + c <= j + c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_2472","instance":2472,"id":172471,"goal":"lemma Abs_Nonneg_2472(i: real)\n ensures (if i >= 0 then i else -i) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_2473","instance":2473,"id":172472,"goal":"lemma DivMod_2473(m: int, d: int)\n requires d > 0\n ensures m == d * (m / d) + (m % d)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_2474","instance":2474,"id":172473,"goal":"lemma ModBounds_2474(a: nat, k: nat)\n requires k > 0\n ensures 0 <= a % k < k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_2475","instance":2475,"id":172474,"goal":"lemma Square_Nonneg_2475(j: real)\n ensures j * j >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_2476","instance":2476,"id":172475,"goal":"lemma AddComm_2476(z: int, i: int)\n ensures z + i == i + z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_2477","instance":2477,"id":172476,"goal":"lemma AddAssoc_2477(c: nat, b: nat, z: nat)\n ensures (c + b) + z == c + (b + z)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_2478","instance":2478,"id":172477,"goal":"lemma MulComm_2478(i: real, x: real)\n ensures i * x == x * i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_2479","instance":2479,"id":172478,"goal":"lemma MulAssoc_2479(n: int, a: int, i: int)\n ensures (n * a) * i == n * (a * i)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_2480","instance":2480,"id":172479,"goal":"lemma Distrib_2480(k: nat, d: nat, j: nat)\n ensures k * (d + j) == k * d + k * j\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_2481","instance":2481,"id":172480,"goal":"lemma AddZero_2481(k: real)\n ensures k + 0 == k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_2482","instance":2482,"id":172481,"goal":"lemma MulOne_2482(m: int)\n ensures m * 1 == m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_2483","instance":2483,"id":172482,"goal":"lemma MulZero_2483(c: nat)\n ensures c * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_2484","instance":2484,"id":172483,"goal":"lemma LeRefl_2484(y: real)\n ensures y <= y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_2485","instance":2485,"id":172484,"goal":"lemma LeTrans_2485(b: int, z: int, d: int)\n requires b <= z && z <= d\n ensures b <= d\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_2486","instance":2486,"id":172485,"goal":"lemma AddMono_2486(n: nat, b: nat, z: nat)\n requires n <= b\n ensures n + z <= b + z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_2487","instance":2487,"id":172486,"goal":"lemma Abs_Nonneg_2487(b: real)\n ensures (if b >= 0 then b else -b) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_2488","instance":2488,"id":172487,"goal":"lemma DivMod_2488(k: int, z: int)\n requires z > 0\n ensures k == z * (k / z) + (k % z)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_2489","instance":2489,"id":172488,"goal":"lemma ModBounds_2489(j: nat, b: nat)\n requires b > 0\n ensures 0 <= j % b < b\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_2490","instance":2490,"id":172489,"goal":"lemma Square_Nonneg_2490(m: real)\n ensures m * m >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_2491","instance":2491,"id":172490,"goal":"lemma AddComm_2491(y: int, c: int)\n ensures y + c == c + y\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_2492","instance":2492,"id":172491,"goal":"lemma AddAssoc_2492(a: nat, c: nat, n: nat)\n ensures (a + c) + n == a + (c + n)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_2493","instance":2493,"id":172492,"goal":"lemma MulComm_2493(i: real, y: real)\n ensures i * y == y * i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_2494","instance":2494,"id":172493,"goal":"lemma MulAssoc_2494(k: int, x: int, d: int)\n ensures (k * x) * d == k * (x * d)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_2495","instance":2495,"id":172494,"goal":"lemma Distrib_2495(y: nat, m: nat, c: nat)\n ensures y * (m + c) == y * m + y * c\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_2496","instance":2496,"id":172495,"goal":"lemma AddZero_2496(y: real)\n ensures y + 0 == y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_2497","instance":2497,"id":172496,"goal":"lemma MulOne_2497(k: int)\n ensures k * 1 == k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_2498","instance":2498,"id":172497,"goal":"lemma MulZero_2498(z: nat)\n ensures z * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_2499","instance":2499,"id":172498,"goal":"lemma LeRefl_2499(a: real)\n ensures a <= a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_2500","instance":2500,"id":172499,"goal":"lemma LeTrans_2500(c: int, x: int, n: int)\n requires c <= x && x <= n\n ensures c <= n\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_2501","instance":2501,"id":172500,"goal":"lemma AddMono_2501(d: nat, c: nat, x: nat)\n requires d <= c\n ensures d + x <= c + x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_2502","instance":2502,"id":172501,"goal":"lemma Abs_Nonneg_2502(n: real)\n ensures (if n >= 0 then n else -n) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_2503","instance":2503,"id":172502,"goal":"lemma DivMod_2503(m: int, a: int)\n requires a > 0\n ensures m == a * (m / a) + (m % a)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_2504","instance":2504,"id":172503,"goal":"lemma ModBounds_2504(j: nat, n: nat)\n requires n > 0\n ensures 0 <= j % n < n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_2505","instance":2505,"id":172504,"goal":"lemma Square_Nonneg_2505(y: real)\n ensures y * y >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_2506","instance":2506,"id":172505,"goal":"lemma AddComm_2506(a: int, j: int)\n ensures a + j == j + a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_2507","instance":2507,"id":172506,"goal":"lemma AddAssoc_2507(d: nat, b: nat, c: nat)\n ensures (d + b) + c == d + (b + c)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_2508","instance":2508,"id":172507,"goal":"lemma MulComm_2508(z: real, b: real)\n ensures z * b == b * z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_2509","instance":2509,"id":172508,"goal":"lemma MulAssoc_2509(k: int, d: int, a: int)\n ensures (k * d) * a == k * (d * a)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_2510","instance":2510,"id":172509,"goal":"lemma Distrib_2510(y: nat, d: nat, i: nat)\n ensures y * (d + i) == y * d + y * i\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_2511","instance":2511,"id":172510,"goal":"lemma AddZero_2511(c: real)\n ensures c + 0 == c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_2512","instance":2512,"id":172511,"goal":"lemma MulOne_2512(j: int)\n ensures j * 1 == j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_2513","instance":2513,"id":172512,"goal":"lemma MulZero_2513(z: nat)\n ensures z * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_2514","instance":2514,"id":172513,"goal":"lemma LeRefl_2514(x: real)\n ensures x <= x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_2515","instance":2515,"id":172514,"goal":"lemma LeTrans_2515(d: int, z: int, c: int)\n requires d <= z && z <= c\n ensures d <= c\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_2516","instance":2516,"id":172515,"goal":"lemma AddMono_2516(n: nat, z: nat, y: nat)\n requires n <= z\n ensures n + y <= z + y\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_2517","instance":2517,"id":172516,"goal":"lemma Abs_Nonneg_2517(y: real)\n ensures (if y >= 0 then y else -y) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_2518","instance":2518,"id":172517,"goal":"lemma DivMod_2518(k: int, z: int)\n requires z > 0\n ensures k == z * (k / z) + (k % z)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_2519","instance":2519,"id":172518,"goal":"lemma ModBounds_2519(b: nat, n: nat)\n requires n > 0\n ensures 0 <= b % n < n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_2520","instance":2520,"id":172519,"goal":"lemma Square_Nonneg_2520(m: real)\n ensures m * m >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_2521","instance":2521,"id":172520,"goal":"lemma AddComm_2521(m: int, a: int)\n ensures m + a == a + m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_2522","instance":2522,"id":172521,"goal":"lemma AddAssoc_2522(a: nat, x: nat, m: nat)\n ensures (a + x) + m == a + (x + m)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_2523","instance":2523,"id":172522,"goal":"lemma MulComm_2523(x: real, k: real)\n ensures x * k == k * x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_2524","instance":2524,"id":172523,"goal":"lemma MulAssoc_2524(a: int, k: int, d: int)\n ensures (a * k) * d == a * (k * d)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_2525","instance":2525,"id":172524,"goal":"lemma Distrib_2525(b: nat, k: nat, c: nat)\n ensures b * (k + c) == b * k + b * c\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_2526","instance":2526,"id":172525,"goal":"lemma AddZero_2526(c: real)\n ensures c + 0 == c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_2527","instance":2527,"id":172526,"goal":"lemma MulOne_2527(c: int)\n ensures c * 1 == c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_2528","instance":2528,"id":172527,"goal":"lemma MulZero_2528(n: nat)\n ensures n * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_2529","instance":2529,"id":172528,"goal":"lemma LeRefl_2529(d: real)\n ensures d <= d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_2530","instance":2530,"id":172529,"goal":"lemma LeTrans_2530(x: int, m: int, y: int)\n requires x <= m && m <= y\n ensures x <= y\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_2531","instance":2531,"id":172530,"goal":"lemma AddMono_2531(y: nat, x: nat, i: nat)\n requires y <= x\n ensures y + i <= x + i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_2532","instance":2532,"id":172531,"goal":"lemma Abs_Nonneg_2532(c: real)\n ensures (if c >= 0 then c else -c) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_2533","instance":2533,"id":172532,"goal":"lemma DivMod_2533(z: int, m: int)\n requires m > 0\n ensures z == m * (z / m) + (z % m)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_2534","instance":2534,"id":172533,"goal":"lemma ModBounds_2534(d: nat, z: nat)\n requires z > 0\n ensures 0 <= d % z < z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_2535","instance":2535,"id":172534,"goal":"lemma Square_Nonneg_2535(d: real)\n ensures d * d >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_2536","instance":2536,"id":172535,"goal":"lemma AddComm_2536(j: int, c: int)\n ensures j + c == c + j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_2537","instance":2537,"id":172536,"goal":"lemma AddAssoc_2537(y: nat, x: nat, c: nat)\n ensures (y + x) + c == y + (x + c)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_2538","instance":2538,"id":172537,"goal":"lemma MulComm_2538(i: real, d: real)\n ensures i * d == d * i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_2539","instance":2539,"id":172538,"goal":"lemma MulAssoc_2539(z: int, y: int, c: int)\n ensures (z * y) * c == z * (y * c)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_2540","instance":2540,"id":172539,"goal":"lemma Distrib_2540(d: nat, m: nat, j: nat)\n ensures d * (m + j) == d * m + d * j\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_2541","instance":2541,"id":172540,"goal":"lemma AddZero_2541(k: real)\n ensures k + 0 == k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_2542","instance":2542,"id":172541,"goal":"lemma MulOne_2542(y: int)\n ensures y * 1 == y\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_2543","instance":2543,"id":172542,"goal":"lemma MulZero_2543(k: nat)\n ensures k * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_2544","instance":2544,"id":172543,"goal":"lemma LeRefl_2544(k: real)\n ensures k <= k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_2545","instance":2545,"id":172544,"goal":"lemma LeTrans_2545(b: int, x: int, m: int)\n requires b <= x && x <= m\n ensures b <= m\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_2546","instance":2546,"id":172545,"goal":"lemma AddMono_2546(y: nat, n: nat, d: nat)\n requires y <= n\n ensures y + d <= n + d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_2547","instance":2547,"id":172546,"goal":"lemma Abs_Nonneg_2547(j: real)\n ensures (if j >= 0 then j else -j) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_2548","instance":2548,"id":172547,"goal":"lemma DivMod_2548(b: int, i: int)\n requires i > 0\n ensures b == i * (b / i) + (b % i)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_2549","instance":2549,"id":172548,"goal":"lemma ModBounds_2549(c: nat, b: nat)\n requires b > 0\n ensures 0 <= c % b < b\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_2550","instance":2550,"id":172549,"goal":"lemma Square_Nonneg_2550(d: real)\n ensures d * d >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_2551","instance":2551,"id":172550,"goal":"lemma AddComm_2551(z: int, c: int)\n ensures z + c == c + z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_2552","instance":2552,"id":172551,"goal":"lemma AddAssoc_2552(n: nat, x: nat, i: nat)\n ensures (n + x) + i == n + (x + i)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_2553","instance":2553,"id":172552,"goal":"lemma MulComm_2553(n: real, x: real)\n ensures n * x == x * n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_2554","instance":2554,"id":172553,"goal":"lemma MulAssoc_2554(d: int, a: int, y: int)\n ensures (d * a) * y == d * (a * y)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_2555","instance":2555,"id":172554,"goal":"lemma Distrib_2555(c: nat, i: nat, d: nat)\n ensures c * (i + d) == c * i + c * d\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_2556","instance":2556,"id":172555,"goal":"lemma AddZero_2556(j: real)\n ensures j + 0 == j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_2557","instance":2557,"id":172556,"goal":"lemma MulOne_2557(b: int)\n ensures b * 1 == b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_2558","instance":2558,"id":172557,"goal":"lemma MulZero_2558(i: nat)\n ensures i * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_2559","instance":2559,"id":172558,"goal":"lemma LeRefl_2559(a: real)\n ensures a <= a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_2560","instance":2560,"id":172559,"goal":"lemma LeTrans_2560(a: int, c: int, k: int)\n requires a <= c && c <= k\n ensures a <= k\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_2561","instance":2561,"id":172560,"goal":"lemma AddMono_2561(y: nat, z: nat, i: nat)\n requires y <= z\n ensures y + i <= z + i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_2562","instance":2562,"id":172561,"goal":"lemma Abs_Nonneg_2562(d: real)\n ensures (if d >= 0 then d else -d) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_2563","instance":2563,"id":172562,"goal":"lemma DivMod_2563(z: int, b: int)\n requires b > 0\n ensures z == b * (z / b) + (z % b)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_2564","instance":2564,"id":172563,"goal":"lemma ModBounds_2564(i: nat, y: nat)\n requires y > 0\n ensures 0 <= i % y < y\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_2565","instance":2565,"id":172564,"goal":"lemma Square_Nonneg_2565(z: real)\n ensures z * z >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_2566","instance":2566,"id":172565,"goal":"lemma AddComm_2566(z: int, j: int)\n ensures z + j == j + z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_2567","instance":2567,"id":172566,"goal":"lemma AddAssoc_2567(a: nat, i: nat, j: nat)\n ensures (a + i) + j == a + (i + j)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_2568","instance":2568,"id":172567,"goal":"lemma MulComm_2568(n: real, k: real)\n ensures n * k == k * n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_2569","instance":2569,"id":172568,"goal":"lemma MulAssoc_2569(k: int, j: int, b: int)\n ensures (k * j) * b == k * (j * b)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_2570","instance":2570,"id":172569,"goal":"lemma Distrib_2570(k: nat, y: nat, n: nat)\n ensures k * (y + n) == k * y + k * n\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_2571","instance":2571,"id":172570,"goal":"lemma AddZero_2571(d: real)\n ensures d + 0 == d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_2572","instance":2572,"id":172571,"goal":"lemma MulOne_2572(z: int)\n ensures z * 1 == z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_2573","instance":2573,"id":172572,"goal":"lemma MulZero_2573(z: nat)\n ensures z * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_2574","instance":2574,"id":172573,"goal":"lemma LeRefl_2574(d: real)\n ensures d <= d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_2575","instance":2575,"id":172574,"goal":"lemma LeTrans_2575(d: int, j: int, b: int)\n requires d <= j && j <= b\n ensures d <= b\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_2576","instance":2576,"id":172575,"goal":"lemma AddMono_2576(c: nat, y: nat, k: nat)\n requires c <= y\n ensures c + k <= y + k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_2577","instance":2577,"id":172576,"goal":"lemma Abs_Nonneg_2577(c: real)\n ensures (if c >= 0 then c else -c) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_2578","instance":2578,"id":172577,"goal":"lemma DivMod_2578(i: int, n: int)\n requires n > 0\n ensures i == n * (i / n) + (i % n)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_2579","instance":2579,"id":172578,"goal":"lemma ModBounds_2579(k: nat, a: nat)\n requires a > 0\n ensures 0 <= k % a < a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_2580","instance":2580,"id":172579,"goal":"lemma Square_Nonneg_2580(k: real)\n ensures k * k >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_2581","instance":2581,"id":172580,"goal":"lemma AddComm_2581(x: int, i: int)\n ensures x + i == i + x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_2582","instance":2582,"id":172581,"goal":"lemma AddAssoc_2582(j: nat, k: nat, z: nat)\n ensures (j + k) + z == j + (k + z)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_2583","instance":2583,"id":172582,"goal":"lemma MulComm_2583(j: real, a: real)\n ensures j * a == a * j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_2584","instance":2584,"id":172583,"goal":"lemma MulAssoc_2584(d: int, n: int, m: int)\n ensures (d * n) * m == d * (n * m)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_2585","instance":2585,"id":172584,"goal":"lemma Distrib_2585(n: nat, y: nat, a: nat)\n ensures n * (y + a) == n * y + n * a\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_2586","instance":2586,"id":172585,"goal":"lemma AddZero_2586(y: real)\n ensures y + 0 == y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_2587","instance":2587,"id":172586,"goal":"lemma MulOne_2587(a: int)\n ensures a * 1 == a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_2588","instance":2588,"id":172587,"goal":"lemma MulZero_2588(k: nat)\n ensures k * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_2589","instance":2589,"id":172588,"goal":"lemma LeRefl_2589(z: real)\n ensures z <= z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_2590","instance":2590,"id":172589,"goal":"lemma LeTrans_2590(x: int, n: int, b: int)\n requires x <= n && n <= b\n ensures x <= b\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_2591","instance":2591,"id":172590,"goal":"lemma AddMono_2591(n: nat, d: nat, m: nat)\n requires n <= d\n ensures n + m <= d + m\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_2592","instance":2592,"id":172591,"goal":"lemma Abs_Nonneg_2592(k: real)\n ensures (if k >= 0 then k else -k) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_2593","instance":2593,"id":172592,"goal":"lemma DivMod_2593(b: int, i: int)\n requires i > 0\n ensures b == i * (b / i) + (b % i)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_2594","instance":2594,"id":172593,"goal":"lemma ModBounds_2594(z: nat, d: nat)\n requires d > 0\n ensures 0 <= z % d < d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_2595","instance":2595,"id":172594,"goal":"lemma Square_Nonneg_2595(n: real)\n ensures n * n >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_2596","instance":2596,"id":172595,"goal":"lemma AddComm_2596(c: int, i: int)\n ensures c + i == i + c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_2597","instance":2597,"id":172596,"goal":"lemma AddAssoc_2597(x: nat, n: nat, b: nat)\n ensures (x + n) + b == x + (n + b)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_2598","instance":2598,"id":172597,"goal":"lemma MulComm_2598(x: real, z: real)\n ensures x * z == z * x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_2599","instance":2599,"id":172598,"goal":"lemma MulAssoc_2599(y: int, a: int, k: int)\n ensures (y * a) * k == y * (a * k)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_2600","instance":2600,"id":172599,"goal":"lemma Distrib_2600(y: nat, k: nat, i: nat)\n ensures y * (k + i) == y * k + y * i\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_2601","instance":2601,"id":172600,"goal":"lemma AddZero_2601(c: real)\n ensures c + 0 == c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_2602","instance":2602,"id":172601,"goal":"lemma MulOne_2602(k: int)\n ensures k * 1 == k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_2603","instance":2603,"id":172602,"goal":"lemma MulZero_2603(y: nat)\n ensures y * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_2604","instance":2604,"id":172603,"goal":"lemma LeRefl_2604(m: real)\n ensures m <= m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_2605","instance":2605,"id":172604,"goal":"lemma LeTrans_2605(m: int, c: int, a: int)\n requires m <= c && c <= a\n ensures m <= a\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_2606","instance":2606,"id":172605,"goal":"lemma AddMono_2606(a: nat, b: nat, x: nat)\n requires a <= b\n ensures a + x <= b + x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_2607","instance":2607,"id":172606,"goal":"lemma Abs_Nonneg_2607(z: real)\n ensures (if z >= 0 then z else -z) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_2608","instance":2608,"id":172607,"goal":"lemma DivMod_2608(b: int, a: int)\n requires a > 0\n ensures b == a * (b / a) + (b % a)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_2609","instance":2609,"id":172608,"goal":"lemma ModBounds_2609(d: nat, c: nat)\n requires c > 0\n ensures 0 <= d % c < c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_2610","instance":2610,"id":172609,"goal":"lemma Square_Nonneg_2610(x: real)\n ensures x * x >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_2611","instance":2611,"id":172610,"goal":"lemma AddComm_2611(i: int, b: int)\n ensures i + b == b + i\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_2612","instance":2612,"id":172611,"goal":"lemma AddAssoc_2612(j: nat, a: nat, b: nat)\n ensures (j + a) + b == j + (a + b)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_2613","instance":2613,"id":172612,"goal":"lemma MulComm_2613(x: real, n: real)\n ensures x * n == n * x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_2614","instance":2614,"id":172613,"goal":"lemma MulAssoc_2614(b: int, z: int, x: int)\n ensures (b * z) * x == b * (z * x)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_2615","instance":2615,"id":172614,"goal":"lemma Distrib_2615(n: nat, d: nat, k: nat)\n ensures n * (d + k) == n * d + n * k\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_2616","instance":2616,"id":172615,"goal":"lemma AddZero_2616(b: real)\n ensures b + 0 == b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_2617","instance":2617,"id":172616,"goal":"lemma MulOne_2617(c: int)\n ensures c * 1 == c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_2618","instance":2618,"id":172617,"goal":"lemma MulZero_2618(n: nat)\n ensures n * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_2619","instance":2619,"id":172618,"goal":"lemma LeRefl_2619(k: real)\n ensures k <= k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_2620","instance":2620,"id":172619,"goal":"lemma LeTrans_2620(z: int, j: int, k: int)\n requires z <= j && j <= k\n ensures z <= k\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_2621","instance":2621,"id":172620,"goal":"lemma AddMono_2621(x: nat, a: nat, i: nat)\n requires x <= a\n ensures x + i <= a + i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_2622","instance":2622,"id":172621,"goal":"lemma Abs_Nonneg_2622(m: real)\n ensures (if m >= 0 then m else -m) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_2623","instance":2623,"id":172622,"goal":"lemma DivMod_2623(m: int, k: int)\n requires k > 0\n ensures m == k * (m / k) + (m % k)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_2624","instance":2624,"id":172623,"goal":"lemma ModBounds_2624(n: nat, k: nat)\n requires k > 0\n ensures 0 <= n % k < k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_2625","instance":2625,"id":172624,"goal":"lemma Square_Nonneg_2625(m: real)\n ensures m * m >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_2626","instance":2626,"id":172625,"goal":"lemma AddComm_2626(y: int, n: int)\n ensures y + n == n + y\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_2627","instance":2627,"id":172626,"goal":"lemma AddAssoc_2627(d: nat, m: nat, b: nat)\n ensures (d + m) + b == d + (m + b)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_2628","instance":2628,"id":172627,"goal":"lemma MulComm_2628(y: real, d: real)\n ensures y * d == d * y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_2629","instance":2629,"id":172628,"goal":"lemma MulAssoc_2629(c: int, z: int, n: int)\n ensures (c * z) * n == c * (z * n)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_2630","instance":2630,"id":172629,"goal":"lemma Distrib_2630(j: nat, y: nat, a: nat)\n ensures j * (y + a) == j * y + j * a\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_2631","instance":2631,"id":172630,"goal":"lemma AddZero_2631(c: real)\n ensures c + 0 == c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_2632","instance":2632,"id":172631,"goal":"lemma MulOne_2632(i: int)\n ensures i * 1 == i\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_2633","instance":2633,"id":172632,"goal":"lemma MulZero_2633(n: nat)\n ensures n * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_2634","instance":2634,"id":172633,"goal":"lemma LeRefl_2634(c: real)\n ensures c <= c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_2635","instance":2635,"id":172634,"goal":"lemma LeTrans_2635(n: int, c: int, m: int)\n requires n <= c && c <= m\n ensures n <= m\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_2636","instance":2636,"id":172635,"goal":"lemma AddMono_2636(n: nat, d: nat, x: nat)\n requires n <= d\n ensures n + x <= d + x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_2637","instance":2637,"id":172636,"goal":"lemma Abs_Nonneg_2637(i: real)\n ensures (if i >= 0 then i else -i) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_2638","instance":2638,"id":172637,"goal":"lemma DivMod_2638(a: int, j: int)\n requires j > 0\n ensures a == j * (a / j) + (a % j)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_2639","instance":2639,"id":172638,"goal":"lemma ModBounds_2639(z: nat, n: nat)\n requires n > 0\n ensures 0 <= z % n < n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_2640","instance":2640,"id":172639,"goal":"lemma Square_Nonneg_2640(y: real)\n ensures y * y >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_2641","instance":2641,"id":172640,"goal":"lemma AddComm_2641(j: int, m: int)\n ensures j + m == m + j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_2642","instance":2642,"id":172641,"goal":"lemma AddAssoc_2642(b: nat, j: nat, m: nat)\n ensures (b + j) + m == b + (j + m)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_2643","instance":2643,"id":172642,"goal":"lemma MulComm_2643(k: real, a: real)\n ensures k * a == a * k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_2644","instance":2644,"id":172643,"goal":"lemma MulAssoc_2644(b: int, i: int, n: int)\n ensures (b * i) * n == b * (i * n)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_2645","instance":2645,"id":172644,"goal":"lemma Distrib_2645(n: nat, m: nat, k: nat)\n ensures n * (m + k) == n * m + n * k\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_2646","instance":2646,"id":172645,"goal":"lemma AddZero_2646(a: real)\n ensures a + 0 == a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_2647","instance":2647,"id":172646,"goal":"lemma MulOne_2647(z: int)\n ensures z * 1 == z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_2648","instance":2648,"id":172647,"goal":"lemma MulZero_2648(a: nat)\n ensures a * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_2649","instance":2649,"id":172648,"goal":"lemma LeRefl_2649(n: real)\n ensures n <= n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_2650","instance":2650,"id":172649,"goal":"lemma LeTrans_2650(m: int, d: int, c: int)\n requires m <= d && d <= c\n ensures m <= c\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_2651","instance":2651,"id":172650,"goal":"lemma AddMono_2651(i: nat, a: nat, z: nat)\n requires i <= a\n ensures i + z <= a + z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_2652","instance":2652,"id":172651,"goal":"lemma Abs_Nonneg_2652(z: real)\n ensures (if z >= 0 then z else -z) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_2653","instance":2653,"id":172652,"goal":"lemma DivMod_2653(y: int, k: int)\n requires k > 0\n ensures y == k * (y / k) + (y % k)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_2654","instance":2654,"id":172653,"goal":"lemma ModBounds_2654(x: nat, m: nat)\n requires m > 0\n ensures 0 <= x % m < m\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_2655","instance":2655,"id":172654,"goal":"lemma Square_Nonneg_2655(y: real)\n ensures y * y >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_2656","instance":2656,"id":172655,"goal":"lemma AddComm_2656(m: int, x: int)\n ensures m + x == x + m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_2657","instance":2657,"id":172656,"goal":"lemma AddAssoc_2657(a: nat, d: nat, y: nat)\n ensures (a + d) + y == a + (d + y)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_2658","instance":2658,"id":172657,"goal":"lemma MulComm_2658(b: real, d: real)\n ensures b * d == d * b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_2659","instance":2659,"id":172658,"goal":"lemma MulAssoc_2659(m: int, x: int, a: int)\n ensures (m * x) * a == m * (x * a)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_2660","instance":2660,"id":172659,"goal":"lemma Distrib_2660(n: nat, m: nat, y: nat)\n ensures n * (m + y) == n * m + n * y\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_2661","instance":2661,"id":172660,"goal":"lemma AddZero_2661(b: real)\n ensures b + 0 == b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_2662","instance":2662,"id":172661,"goal":"lemma MulOne_2662(n: int)\n ensures n * 1 == n\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_2663","instance":2663,"id":172662,"goal":"lemma MulZero_2663(z: nat)\n ensures z * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_2664","instance":2664,"id":172663,"goal":"lemma LeRefl_2664(d: real)\n ensures d <= d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_2665","instance":2665,"id":172664,"goal":"lemma LeTrans_2665(m: int, c: int, y: int)\n requires m <= c && c <= y\n ensures m <= y\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_2666","instance":2666,"id":172665,"goal":"lemma AddMono_2666(y: nat, j: nat, x: nat)\n requires y <= j\n ensures y + x <= j + x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_2667","instance":2667,"id":172666,"goal":"lemma Abs_Nonneg_2667(x: real)\n ensures (if x >= 0 then x else -x) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_2668","instance":2668,"id":172667,"goal":"lemma DivMod_2668(b: int, j: int)\n requires j > 0\n ensures b == j * (b / j) + (b % j)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_2669","instance":2669,"id":172668,"goal":"lemma ModBounds_2669(z: nat, a: nat)\n requires a > 0\n ensures 0 <= z % a < a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_2670","instance":2670,"id":172669,"goal":"lemma Square_Nonneg_2670(m: real)\n ensures m * m >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_2671","instance":2671,"id":172670,"goal":"lemma AddComm_2671(m: int, x: int)\n ensures m + x == x + m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_2672","instance":2672,"id":172671,"goal":"lemma AddAssoc_2672(k: nat, i: nat, n: nat)\n ensures (k + i) + n == k + (i + n)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_2673","instance":2673,"id":172672,"goal":"lemma MulComm_2673(n: real, m: real)\n ensures n * m == m * n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_2674","instance":2674,"id":172673,"goal":"lemma MulAssoc_2674(k: int, j: int, d: int)\n ensures (k * j) * d == k * (j * d)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_2675","instance":2675,"id":172674,"goal":"lemma Distrib_2675(i: nat, k: nat, m: nat)\n ensures i * (k + m) == i * k + i * m\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_2676","instance":2676,"id":172675,"goal":"lemma AddZero_2676(b: real)\n ensures b + 0 == b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_2677","instance":2677,"id":172676,"goal":"lemma MulOne_2677(j: int)\n ensures j * 1 == j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_2678","instance":2678,"id":172677,"goal":"lemma MulZero_2678(c: nat)\n ensures c * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_2679","instance":2679,"id":172678,"goal":"lemma LeRefl_2679(y: real)\n ensures y <= y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_2680","instance":2680,"id":172679,"goal":"lemma LeTrans_2680(m: int, a: int, i: int)\n requires m <= a && a <= i\n ensures m <= i\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_2681","instance":2681,"id":172680,"goal":"lemma AddMono_2681(b: nat, z: nat, y: nat)\n requires b <= z\n ensures b + y <= z + y\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_2682","instance":2682,"id":172681,"goal":"lemma Abs_Nonneg_2682(y: real)\n ensures (if y >= 0 then y else -y) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_2683","instance":2683,"id":172682,"goal":"lemma DivMod_2683(m: int, b: int)\n requires b > 0\n ensures m == b * (m / b) + (m % b)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_2684","instance":2684,"id":172683,"goal":"lemma ModBounds_2684(a: nat, i: nat)\n requires i > 0\n ensures 0 <= a % i < i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_2685","instance":2685,"id":172684,"goal":"lemma Square_Nonneg_2685(j: real)\n ensures j * j >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_2686","instance":2686,"id":172685,"goal":"lemma AddComm_2686(c: int, b: int)\n ensures c + b == b + c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_2687","instance":2687,"id":172686,"goal":"lemma AddAssoc_2687(j: nat, y: nat, i: nat)\n ensures (j + y) + i == j + (y + i)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_2688","instance":2688,"id":172687,"goal":"lemma MulComm_2688(y: real, j: real)\n ensures y * j == j * y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_2689","instance":2689,"id":172688,"goal":"lemma MulAssoc_2689(y: int, n: int, j: int)\n ensures (y * n) * j == y * (n * j)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_2690","instance":2690,"id":172689,"goal":"lemma Distrib_2690(m: nat, z: nat, j: nat)\n ensures m * (z + j) == m * z + m * j\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_2691","instance":2691,"id":172690,"goal":"lemma AddZero_2691(k: real)\n ensures k + 0 == k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_2692","instance":2692,"id":172691,"goal":"lemma MulOne_2692(m: int)\n ensures m * 1 == m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_2693","instance":2693,"id":172692,"goal":"lemma MulZero_2693(c: nat)\n ensures c * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_2694","instance":2694,"id":172693,"goal":"lemma LeRefl_2694(a: real)\n ensures a <= a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_2695","instance":2695,"id":172694,"goal":"lemma LeTrans_2695(j: int, i: int, k: int)\n requires j <= i && i <= k\n ensures j <= k\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_2696","instance":2696,"id":172695,"goal":"lemma AddMono_2696(i: nat, j: nat, z: nat)\n requires i <= j\n ensures i + z <= j + z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_2697","instance":2697,"id":172696,"goal":"lemma Abs_Nonneg_2697(b: real)\n ensures (if b >= 0 then b else -b) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_2698","instance":2698,"id":172697,"goal":"lemma DivMod_2698(z: int, m: int)\n requires m > 0\n ensures z == m * (z / m) + (z % m)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_2699","instance":2699,"id":172698,"goal":"lemma ModBounds_2699(k: nat, z: nat)\n requires z > 0\n ensures 0 <= k % z < z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_2700","instance":2700,"id":172699,"goal":"lemma Square_Nonneg_2700(i: real)\n ensures i * i >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_2701","instance":2701,"id":172700,"goal":"lemma AddComm_2701(z: int, c: int)\n ensures z + c == c + z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_2702","instance":2702,"id":172701,"goal":"lemma AddAssoc_2702(n: nat, x: nat, y: nat)\n ensures (n + x) + y == n + (x + y)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_2703","instance":2703,"id":172702,"goal":"lemma MulComm_2703(k: real, b: real)\n ensures k * b == b * k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_2704","instance":2704,"id":172703,"goal":"lemma MulAssoc_2704(a: int, b: int, d: int)\n ensures (a * b) * d == a * (b * d)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_2705","instance":2705,"id":172704,"goal":"lemma Distrib_2705(j: nat, k: nat, a: nat)\n ensures j * (k + a) == j * k + j * a\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_2706","instance":2706,"id":172705,"goal":"lemma AddZero_2706(k: real)\n ensures k + 0 == k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_2707","instance":2707,"id":172706,"goal":"lemma MulOne_2707(d: int)\n ensures d * 1 == d\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_2708","instance":2708,"id":172707,"goal":"lemma MulZero_2708(a: nat)\n ensures a * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_2709","instance":2709,"id":172708,"goal":"lemma LeRefl_2709(i: real)\n ensures i <= i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_2710","instance":2710,"id":172709,"goal":"lemma LeTrans_2710(y: int, i: int, d: int)\n requires y <= i && i <= d\n ensures y <= d\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_2711","instance":2711,"id":172710,"goal":"lemma AddMono_2711(c: nat, i: nat, k: nat)\n requires c <= i\n ensures c + k <= i + k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_2712","instance":2712,"id":172711,"goal":"lemma Abs_Nonneg_2712(j: real)\n ensures (if j >= 0 then j else -j) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_2713","instance":2713,"id":172712,"goal":"lemma DivMod_2713(b: int, d: int)\n requires d > 0\n ensures b == d * (b / d) + (b % d)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_2714","instance":2714,"id":172713,"goal":"lemma ModBounds_2714(x: nat, a: nat)\n requires a > 0\n ensures 0 <= x % a < a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_2715","instance":2715,"id":172714,"goal":"lemma Square_Nonneg_2715(d: real)\n ensures d * d >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_2716","instance":2716,"id":172715,"goal":"lemma AddComm_2716(c: int, a: int)\n ensures c + a == a + c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_2717","instance":2717,"id":172716,"goal":"lemma AddAssoc_2717(m: nat, y: nat, a: nat)\n ensures (m + y) + a == m + (y + a)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_2718","instance":2718,"id":172717,"goal":"lemma MulComm_2718(b: real, a: real)\n ensures b * a == a * b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_2719","instance":2719,"id":172718,"goal":"lemma MulAssoc_2719(a: int, i: int, m: int)\n ensures (a * i) * m == a * (i * m)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_2720","instance":2720,"id":172719,"goal":"lemma Distrib_2720(k: nat, d: nat, y: nat)\n ensures k * (d + y) == k * d + k * y\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_2721","instance":2721,"id":172720,"goal":"lemma AddZero_2721(c: real)\n ensures c + 0 == c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_2722","instance":2722,"id":172721,"goal":"lemma MulOne_2722(y: int)\n ensures y * 1 == y\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_2723","instance":2723,"id":172722,"goal":"lemma MulZero_2723(d: nat)\n ensures d * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_2724","instance":2724,"id":172723,"goal":"lemma LeRefl_2724(a: real)\n ensures a <= a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_2725","instance":2725,"id":172724,"goal":"lemma LeTrans_2725(m: int, d: int, a: int)\n requires m <= d && d <= a\n ensures m <= a\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_2726","instance":2726,"id":172725,"goal":"lemma AddMono_2726(z: nat, k: nat, x: nat)\n requires z <= k\n ensures z + x <= k + x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_2727","instance":2727,"id":172726,"goal":"lemma Abs_Nonneg_2727(i: real)\n ensures (if i >= 0 then i else -i) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_2728","instance":2728,"id":172727,"goal":"lemma DivMod_2728(m: int, x: int)\n requires x > 0\n ensures m == x * (m / x) + (m % x)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_2729","instance":2729,"id":172728,"goal":"lemma ModBounds_2729(y: nat, k: nat)\n requires k > 0\n ensures 0 <= y % k < k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_2730","instance":2730,"id":172729,"goal":"lemma Square_Nonneg_2730(n: real)\n ensures n * n >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_2731","instance":2731,"id":172730,"goal":"lemma AddComm_2731(i: int, x: int)\n ensures i + x == x + i\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_2732","instance":2732,"id":172731,"goal":"lemma AddAssoc_2732(j: nat, m: nat, z: nat)\n ensures (j + m) + z == j + (m + z)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_2733","instance":2733,"id":172732,"goal":"lemma MulComm_2733(k: real, c: real)\n ensures k * c == c * k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_2734","instance":2734,"id":172733,"goal":"lemma MulAssoc_2734(m: int, j: int, i: int)\n ensures (m * j) * i == m * (j * i)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_2735","instance":2735,"id":172734,"goal":"lemma Distrib_2735(d: nat, z: nat, y: nat)\n ensures d * (z + y) == d * z + d * y\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_2736","instance":2736,"id":172735,"goal":"lemma AddZero_2736(a: real)\n ensures a + 0 == a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_2737","instance":2737,"id":172736,"goal":"lemma MulOne_2737(y: int)\n ensures y * 1 == y\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_2738","instance":2738,"id":172737,"goal":"lemma MulZero_2738(k: nat)\n ensures k * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_2739","instance":2739,"id":172738,"goal":"lemma LeRefl_2739(k: real)\n ensures k <= k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_2740","instance":2740,"id":172739,"goal":"lemma LeTrans_2740(n: int, i: int, d: int)\n requires n <= i && i <= d\n ensures n <= d\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_2741","instance":2741,"id":172740,"goal":"lemma AddMono_2741(n: nat, a: nat, y: nat)\n requires n <= a\n ensures n + y <= a + y\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_2742","instance":2742,"id":172741,"goal":"lemma Abs_Nonneg_2742(a: real)\n ensures (if a >= 0 then a else -a) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_2743","instance":2743,"id":172742,"goal":"lemma DivMod_2743(j: int, y: int)\n requires y > 0\n ensures j == y * (j / y) + (j % y)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_2744","instance":2744,"id":172743,"goal":"lemma ModBounds_2744(m: nat, z: nat)\n requires z > 0\n ensures 0 <= m % z < z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_2745","instance":2745,"id":172744,"goal":"lemma Square_Nonneg_2745(m: real)\n ensures m * m >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_2746","instance":2746,"id":172745,"goal":"lemma AddComm_2746(y: int, m: int)\n ensures y + m == m + y\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_2747","instance":2747,"id":172746,"goal":"lemma AddAssoc_2747(j: nat, y: nat, c: nat)\n ensures (j + y) + c == j + (y + c)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_2748","instance":2748,"id":172747,"goal":"lemma MulComm_2748(z: real, m: real)\n ensures z * m == m * z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_2749","instance":2749,"id":172748,"goal":"lemma MulAssoc_2749(c: int, z: int, i: int)\n ensures (c * z) * i == c * (z * i)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_2750","instance":2750,"id":172749,"goal":"lemma Distrib_2750(m: nat, b: nat, d: nat)\n ensures m * (b + d) == m * b + m * d\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_2751","instance":2751,"id":172750,"goal":"lemma AddZero_2751(n: real)\n ensures n + 0 == n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_2752","instance":2752,"id":172751,"goal":"lemma MulOne_2752(b: int)\n ensures b * 1 == b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_2753","instance":2753,"id":172752,"goal":"lemma MulZero_2753(z: nat)\n ensures z * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_2754","instance":2754,"id":172753,"goal":"lemma LeRefl_2754(x: real)\n ensures x <= x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_2755","instance":2755,"id":172754,"goal":"lemma LeTrans_2755(x: int, a: int, i: int)\n requires x <= a && a <= i\n ensures x <= i\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_2756","instance":2756,"id":172755,"goal":"lemma AddMono_2756(x: nat, d: nat, c: nat)\n requires x <= d\n ensures x + c <= d + c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_2757","instance":2757,"id":172756,"goal":"lemma Abs_Nonneg_2757(a: real)\n ensures (if a >= 0 then a else -a) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_2758","instance":2758,"id":172757,"goal":"lemma DivMod_2758(b: int, a: int)\n requires a > 0\n ensures b == a * (b / a) + (b % a)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_2759","instance":2759,"id":172758,"goal":"lemma ModBounds_2759(n: nat, x: nat)\n requires x > 0\n ensures 0 <= n % x < x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_2760","instance":2760,"id":172759,"goal":"lemma Square_Nonneg_2760(n: real)\n ensures n * n >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_2761","instance":2761,"id":172760,"goal":"lemma AddComm_2761(a: int, k: int)\n ensures a + k == k + a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_2762","instance":2762,"id":172761,"goal":"lemma AddAssoc_2762(x: nat, j: nat, c: nat)\n ensures (x + j) + c == x + (j + c)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_2763","instance":2763,"id":172762,"goal":"lemma MulComm_2763(a: real, k: real)\n ensures a * k == k * a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_2764","instance":2764,"id":172763,"goal":"lemma MulAssoc_2764(j: int, z: int, m: int)\n ensures (j * z) * m == j * (z * m)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_2765","instance":2765,"id":172764,"goal":"lemma Distrib_2765(y: nat, x: nat, n: nat)\n ensures y * (x + n) == y * x + y * n\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_2766","instance":2766,"id":172765,"goal":"lemma AddZero_2766(c: real)\n ensures c + 0 == c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_2767","instance":2767,"id":172766,"goal":"lemma MulOne_2767(k: int)\n ensures k * 1 == k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_2768","instance":2768,"id":172767,"goal":"lemma MulZero_2768(z: nat)\n ensures z * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_2769","instance":2769,"id":172768,"goal":"lemma LeRefl_2769(i: real)\n ensures i <= i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_2770","instance":2770,"id":172769,"goal":"lemma LeTrans_2770(n: int, x: int, j: int)\n requires n <= x && x <= j\n ensures n <= j\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_2771","instance":2771,"id":172770,"goal":"lemma AddMono_2771(i: nat, n: nat, d: nat)\n requires i <= n\n ensures i + d <= n + d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_2772","instance":2772,"id":172771,"goal":"lemma Abs_Nonneg_2772(c: real)\n ensures (if c >= 0 then c else -c) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_2773","instance":2773,"id":172772,"goal":"lemma DivMod_2773(j: int, b: int)\n requires b > 0\n ensures j == b * (j / b) + (j % b)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_2774","instance":2774,"id":172773,"goal":"lemma ModBounds_2774(k: nat, b: nat)\n requires b > 0\n ensures 0 <= k % b < b\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_2775","instance":2775,"id":172774,"goal":"lemma Square_Nonneg_2775(m: real)\n ensures m * m >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_2776","instance":2776,"id":172775,"goal":"lemma AddComm_2776(k: int, i: int)\n ensures k + i == i + k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_2777","instance":2777,"id":172776,"goal":"lemma AddAssoc_2777(n: nat, i: nat, b: nat)\n ensures (n + i) + b == n + (i + b)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_2778","instance":2778,"id":172777,"goal":"lemma MulComm_2778(j: real, c: real)\n ensures j * c == c * j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_2779","instance":2779,"id":172778,"goal":"lemma MulAssoc_2779(n: int, x: int, j: int)\n ensures (n * x) * j == n * (x * j)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_2780","instance":2780,"id":172779,"goal":"lemma Distrib_2780(c: nat, d: nat, b: nat)\n ensures c * (d + b) == c * d + c * b\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_2781","instance":2781,"id":172780,"goal":"lemma AddZero_2781(x: real)\n ensures x + 0 == x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_2782","instance":2782,"id":172781,"goal":"lemma MulOne_2782(y: int)\n ensures y * 1 == y\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_2783","instance":2783,"id":172782,"goal":"lemma MulZero_2783(c: nat)\n ensures c * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_2784","instance":2784,"id":172783,"goal":"lemma LeRefl_2784(a: real)\n ensures a <= a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_2785","instance":2785,"id":172784,"goal":"lemma LeTrans_2785(y: int, i: int, z: int)\n requires y <= i && i <= z\n ensures y <= z\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_2786","instance":2786,"id":172785,"goal":"lemma AddMono_2786(m: nat, a: nat, j: nat)\n requires m <= a\n ensures m + j <= a + j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_2787","instance":2787,"id":172786,"goal":"lemma Abs_Nonneg_2787(n: real)\n ensures (if n >= 0 then n else -n) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_2788","instance":2788,"id":172787,"goal":"lemma DivMod_2788(i: int, j: int)\n requires j > 0\n ensures i == j * (i / j) + (i % j)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_2789","instance":2789,"id":172788,"goal":"lemma ModBounds_2789(m: nat, n: nat)\n requires n > 0\n ensures 0 <= m % n < n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_2790","instance":2790,"id":172789,"goal":"lemma Square_Nonneg_2790(m: real)\n ensures m * m >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_2791","instance":2791,"id":172790,"goal":"lemma AddComm_2791(d: int, z: int)\n ensures d + z == z + d\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_2792","instance":2792,"id":172791,"goal":"lemma AddAssoc_2792(d: nat, k: nat, y: nat)\n ensures (d + k) + y == d + (k + y)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_2793","instance":2793,"id":172792,"goal":"lemma MulComm_2793(y: real, j: real)\n ensures y * j == j * y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_2794","instance":2794,"id":172793,"goal":"lemma MulAssoc_2794(d: int, k: int, j: int)\n ensures (d * k) * j == d * (k * j)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_2795","instance":2795,"id":172794,"goal":"lemma Distrib_2795(z: nat, m: nat, y: nat)\n ensures z * (m + y) == z * m + z * y\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_2796","instance":2796,"id":172795,"goal":"lemma AddZero_2796(c: real)\n ensures c + 0 == c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_2797","instance":2797,"id":172796,"goal":"lemma MulOne_2797(k: int)\n ensures k * 1 == k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_2798","instance":2798,"id":172797,"goal":"lemma MulZero_2798(y: nat)\n ensures y * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_2799","instance":2799,"id":172798,"goal":"lemma LeRefl_2799(i: real)\n ensures i <= i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_2800","instance":2800,"id":172799,"goal":"lemma LeTrans_2800(i: int, j: int, d: int)\n requires i <= j && j <= d\n ensures i <= d\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_2801","instance":2801,"id":172800,"goal":"lemma AddMono_2801(k: nat, m: nat, c: nat)\n requires k <= m\n ensures k + c <= m + c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_2802","instance":2802,"id":172801,"goal":"lemma Abs_Nonneg_2802(m: real)\n ensures (if m >= 0 then m else -m) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_2803","instance":2803,"id":172802,"goal":"lemma DivMod_2803(b: int, i: int)\n requires i > 0\n ensures b == i * (b / i) + (b % i)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_2804","instance":2804,"id":172803,"goal":"lemma ModBounds_2804(z: nat, y: nat)\n requires y > 0\n ensures 0 <= z % y < y\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_2805","instance":2805,"id":172804,"goal":"lemma Square_Nonneg_2805(b: real)\n ensures b * b >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_2806","instance":2806,"id":172805,"goal":"lemma AddComm_2806(k: int, m: int)\n ensures k + m == m + k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_2807","instance":2807,"id":172806,"goal":"lemma AddAssoc_2807(i: nat, x: nat, b: nat)\n ensures (i + x) + b == i + (x + b)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_2808","instance":2808,"id":172807,"goal":"lemma MulComm_2808(z: real, a: real)\n ensures z * a == a * z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_2809","instance":2809,"id":172808,"goal":"lemma MulAssoc_2809(z: int, c: int, n: int)\n ensures (z * c) * n == z * (c * n)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_2810","instance":2810,"id":172809,"goal":"lemma Distrib_2810(y: nat, a: nat, z: nat)\n ensures y * (a + z) == y * a + y * z\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_2811","instance":2811,"id":172810,"goal":"lemma AddZero_2811(j: real)\n ensures j + 0 == j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_2812","instance":2812,"id":172811,"goal":"lemma MulOne_2812(y: int)\n ensures y * 1 == y\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_2813","instance":2813,"id":172812,"goal":"lemma MulZero_2813(j: nat)\n ensures j * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_2814","instance":2814,"id":172813,"goal":"lemma LeRefl_2814(d: real)\n ensures d <= d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_2815","instance":2815,"id":172814,"goal":"lemma LeTrans_2815(m: int, c: int, a: int)\n requires m <= c && c <= a\n ensures m <= a\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_2816","instance":2816,"id":172815,"goal":"lemma AddMono_2816(c: nat, j: nat, n: nat)\n requires c <= j\n ensures c + n <= j + n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_2817","instance":2817,"id":172816,"goal":"lemma Abs_Nonneg_2817(n: real)\n ensures (if n >= 0 then n else -n) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_2818","instance":2818,"id":172817,"goal":"lemma DivMod_2818(y: int, b: int)\n requires b > 0\n ensures y == b * (y / b) + (y % b)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_2819","instance":2819,"id":172818,"goal":"lemma ModBounds_2819(j: nat, m: nat)\n requires m > 0\n ensures 0 <= j % m < m\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_2820","instance":2820,"id":172819,"goal":"lemma Square_Nonneg_2820(c: real)\n ensures c * c >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_2821","instance":2821,"id":172820,"goal":"lemma AddComm_2821(b: int, y: int)\n ensures b + y == y + b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_2822","instance":2822,"id":172821,"goal":"lemma AddAssoc_2822(d: nat, i: nat, m: nat)\n ensures (d + i) + m == d + (i + m)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_2823","instance":2823,"id":172822,"goal":"lemma MulComm_2823(c: real, m: real)\n ensures c * m == m * c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_2824","instance":2824,"id":172823,"goal":"lemma MulAssoc_2824(y: int, m: int, c: int)\n ensures (y * m) * c == y * (m * c)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_2825","instance":2825,"id":172824,"goal":"lemma Distrib_2825(d: nat, a: nat, b: nat)\n ensures d * (a + b) == d * a + d * b\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_2826","instance":2826,"id":172825,"goal":"lemma AddZero_2826(m: real)\n ensures m + 0 == m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_2827","instance":2827,"id":172826,"goal":"lemma MulOne_2827(x: int)\n ensures x * 1 == x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_2828","instance":2828,"id":172827,"goal":"lemma MulZero_2828(k: nat)\n ensures k * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_2829","instance":2829,"id":172828,"goal":"lemma LeRefl_2829(z: real)\n ensures z <= z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_2830","instance":2830,"id":172829,"goal":"lemma LeTrans_2830(i: int, d: int, m: int)\n requires i <= d && d <= m\n ensures i <= m\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_2831","instance":2831,"id":172830,"goal":"lemma AddMono_2831(x: nat, i: nat, y: nat)\n requires x <= i\n ensures x + y <= i + y\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_2832","instance":2832,"id":172831,"goal":"lemma Abs_Nonneg_2832(b: real)\n ensures (if b >= 0 then b else -b) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_2833","instance":2833,"id":172832,"goal":"lemma DivMod_2833(z: int, m: int)\n requires m > 0\n ensures z == m * (z / m) + (z % m)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_2834","instance":2834,"id":172833,"goal":"lemma ModBounds_2834(m: nat, j: nat)\n requires j > 0\n ensures 0 <= m % j < j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_2835","instance":2835,"id":172834,"goal":"lemma Square_Nonneg_2835(k: real)\n ensures k * k >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_2836","instance":2836,"id":172835,"goal":"lemma AddComm_2836(i: int, b: int)\n ensures i + b == b + i\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_2837","instance":2837,"id":172836,"goal":"lemma AddAssoc_2837(d: nat, m: nat, a: nat)\n ensures (d + m) + a == d + (m + a)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_2838","instance":2838,"id":172837,"goal":"lemma MulComm_2838(y: real, x: real)\n ensures y * x == x * y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_2839","instance":2839,"id":172838,"goal":"lemma MulAssoc_2839(c: int, i: int, z: int)\n ensures (c * i) * z == c * (i * z)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_2840","instance":2840,"id":172839,"goal":"lemma Distrib_2840(j: nat, k: nat, i: nat)\n ensures j * (k + i) == j * k + j * i\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_2841","instance":2841,"id":172840,"goal":"lemma AddZero_2841(z: real)\n ensures z + 0 == z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_2842","instance":2842,"id":172841,"goal":"lemma MulOne_2842(k: int)\n ensures k * 1 == k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_2843","instance":2843,"id":172842,"goal":"lemma MulZero_2843(c: nat)\n ensures c * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_2844","instance":2844,"id":172843,"goal":"lemma LeRefl_2844(n: real)\n ensures n <= n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_2845","instance":2845,"id":172844,"goal":"lemma LeTrans_2845(k: int, a: int, x: int)\n requires k <= a && a <= x\n ensures k <= x\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_2846","instance":2846,"id":172845,"goal":"lemma AddMono_2846(k: nat, c: nat, n: nat)\n requires k <= c\n ensures k + n <= c + n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_2847","instance":2847,"id":172846,"goal":"lemma Abs_Nonneg_2847(j: real)\n ensures (if j >= 0 then j else -j) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_2848","instance":2848,"id":172847,"goal":"lemma DivMod_2848(j: int, z: int)\n requires z > 0\n ensures j == z * (j / z) + (j % z)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_2849","instance":2849,"id":172848,"goal":"lemma ModBounds_2849(k: nat, d: nat)\n requires d > 0\n ensures 0 <= k % d < d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_2850","instance":2850,"id":172849,"goal":"lemma Square_Nonneg_2850(y: real)\n ensures y * y >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_2851","instance":2851,"id":172850,"goal":"lemma AddComm_2851(x: int, n: int)\n ensures x + n == n + x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_2852","instance":2852,"id":172851,"goal":"lemma AddAssoc_2852(y: nat, n: nat, d: nat)\n ensures (y + n) + d == y + (n + d)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_2853","instance":2853,"id":172852,"goal":"lemma MulComm_2853(z: real, y: real)\n ensures z * y == y * z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_2854","instance":2854,"id":172853,"goal":"lemma MulAssoc_2854(a: int, y: int, c: int)\n ensures (a * y) * c == a * (y * c)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_2855","instance":2855,"id":172854,"goal":"lemma Distrib_2855(n: nat, k: nat, b: nat)\n ensures n * (k + b) == n * k + n * b\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_2856","instance":2856,"id":172855,"goal":"lemma AddZero_2856(b: real)\n ensures b + 0 == b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_2857","instance":2857,"id":172856,"goal":"lemma MulOne_2857(d: int)\n ensures d * 1 == d\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_2858","instance":2858,"id":172857,"goal":"lemma MulZero_2858(z: nat)\n ensures z * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_2859","instance":2859,"id":172858,"goal":"lemma LeRefl_2859(j: real)\n ensures j <= j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_2860","instance":2860,"id":172859,"goal":"lemma LeTrans_2860(a: int, z: int, j: int)\n requires a <= z && z <= j\n ensures a <= j\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_2861","instance":2861,"id":172860,"goal":"lemma AddMono_2861(c: nat, y: nat, z: nat)\n requires c <= y\n ensures c + z <= y + z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_2862","instance":2862,"id":172861,"goal":"lemma Abs_Nonneg_2862(k: real)\n ensures (if k >= 0 then k else -k) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_2863","instance":2863,"id":172862,"goal":"lemma DivMod_2863(y: int, d: int)\n requires d > 0\n ensures y == d * (y / d) + (y % d)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_2864","instance":2864,"id":172863,"goal":"lemma ModBounds_2864(n: nat, i: nat)\n requires i > 0\n ensures 0 <= n % i < i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_2865","instance":2865,"id":172864,"goal":"lemma Square_Nonneg_2865(m: real)\n ensures m * m >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_2866","instance":2866,"id":172865,"goal":"lemma AddComm_2866(c: int, k: int)\n ensures c + k == k + c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_2867","instance":2867,"id":172866,"goal":"lemma AddAssoc_2867(a: nat, j: nat, x: nat)\n ensures (a + j) + x == a + (j + x)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_2868","instance":2868,"id":172867,"goal":"lemma MulComm_2868(i: real, c: real)\n ensures i * c == c * i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_2869","instance":2869,"id":172868,"goal":"lemma MulAssoc_2869(c: int, d: int, n: int)\n ensures (c * d) * n == c * (d * n)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_2870","instance":2870,"id":172869,"goal":"lemma Distrib_2870(j: nat, c: nat, a: nat)\n ensures j * (c + a) == j * c + j * a\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_2871","instance":2871,"id":172870,"goal":"lemma AddZero_2871(a: real)\n ensures a + 0 == a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_2872","instance":2872,"id":172871,"goal":"lemma MulOne_2872(j: int)\n ensures j * 1 == j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_2873","instance":2873,"id":172872,"goal":"lemma MulZero_2873(d: nat)\n ensures d * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_2874","instance":2874,"id":172873,"goal":"lemma LeRefl_2874(n: real)\n ensures n <= n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_2875","instance":2875,"id":172874,"goal":"lemma LeTrans_2875(d: int, i: int, a: int)\n requires d <= i && i <= a\n ensures d <= a\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_2876","instance":2876,"id":172875,"goal":"lemma AddMono_2876(x: nat, c: nat, n: nat)\n requires x <= c\n ensures x + n <= c + n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_2877","instance":2877,"id":172876,"goal":"lemma Abs_Nonneg_2877(z: real)\n ensures (if z >= 0 then z else -z) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_2878","instance":2878,"id":172877,"goal":"lemma DivMod_2878(b: int, n: int)\n requires n > 0\n ensures b == n * (b / n) + (b % n)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_2879","instance":2879,"id":172878,"goal":"lemma ModBounds_2879(i: nat, b: nat)\n requires b > 0\n ensures 0 <= i % b < b\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_2880","instance":2880,"id":172879,"goal":"lemma Square_Nonneg_2880(x: real)\n ensures x * x >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_2881","instance":2881,"id":172880,"goal":"lemma AddComm_2881(y: int, z: int)\n ensures y + z == z + y\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_2882","instance":2882,"id":172881,"goal":"lemma AddAssoc_2882(n: nat, b: nat, a: nat)\n ensures (n + b) + a == n + (b + a)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_2883","instance":2883,"id":172882,"goal":"lemma MulComm_2883(m: real, a: real)\n ensures m * a == a * m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_2884","instance":2884,"id":172883,"goal":"lemma MulAssoc_2884(b: int, m: int, n: int)\n ensures (b * m) * n == b * (m * n)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_2885","instance":2885,"id":172884,"goal":"lemma Distrib_2885(b: nat, x: nat, c: nat)\n ensures b * (x + c) == b * x + b * c\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_2886","instance":2886,"id":172885,"goal":"lemma AddZero_2886(c: real)\n ensures c + 0 == c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_2887","instance":2887,"id":172886,"goal":"lemma MulOne_2887(z: int)\n ensures z * 1 == z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_2888","instance":2888,"id":172887,"goal":"lemma MulZero_2888(m: nat)\n ensures m * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_2889","instance":2889,"id":172888,"goal":"lemma LeRefl_2889(m: real)\n ensures m <= m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_2890","instance":2890,"id":172889,"goal":"lemma LeTrans_2890(j: int, n: int, x: int)\n requires j <= n && n <= x\n ensures j <= x\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_2891","instance":2891,"id":172890,"goal":"lemma AddMono_2891(a: nat, b: nat, y: nat)\n requires a <= b\n ensures a + y <= b + y\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_2892","instance":2892,"id":172891,"goal":"lemma Abs_Nonneg_2892(z: real)\n ensures (if z >= 0 then z else -z) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_2893","instance":2893,"id":172892,"goal":"lemma DivMod_2893(b: int, c: int)\n requires c > 0\n ensures b == c * (b / c) + (b % c)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_2894","instance":2894,"id":172893,"goal":"lemma ModBounds_2894(n: nat, d: nat)\n requires d > 0\n ensures 0 <= n % d < d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_2895","instance":2895,"id":172894,"goal":"lemma Square_Nonneg_2895(j: real)\n ensures j * j >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_2896","instance":2896,"id":172895,"goal":"lemma AddComm_2896(b: int, y: int)\n ensures b + y == y + b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_2897","instance":2897,"id":172896,"goal":"lemma AddAssoc_2897(y: nat, b: nat, z: nat)\n ensures (y + b) + z == y + (b + z)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_2898","instance":2898,"id":172897,"goal":"lemma MulComm_2898(m: real, k: real)\n ensures m * k == k * m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_2899","instance":2899,"id":172898,"goal":"lemma MulAssoc_2899(j: int, z: int, i: int)\n ensures (j * z) * i == j * (z * i)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_2900","instance":2900,"id":172899,"goal":"lemma Distrib_2900(a: nat, j: nat, i: nat)\n ensures a * (j + i) == a * j + a * i\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_2901","instance":2901,"id":172900,"goal":"lemma AddZero_2901(z: real)\n ensures z + 0 == z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_2902","instance":2902,"id":172901,"goal":"lemma MulOne_2902(i: int)\n ensures i * 1 == i\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_2903","instance":2903,"id":172902,"goal":"lemma MulZero_2903(y: nat)\n ensures y * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_2904","instance":2904,"id":172903,"goal":"lemma LeRefl_2904(n: real)\n ensures n <= n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_2905","instance":2905,"id":172904,"goal":"lemma LeTrans_2905(i: int, b: int, d: int)\n requires i <= b && b <= d\n ensures i <= d\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_2906","instance":2906,"id":172905,"goal":"lemma AddMono_2906(z: nat, y: nat, b: nat)\n requires z <= y\n ensures z + b <= y + b\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_2907","instance":2907,"id":172906,"goal":"lemma Abs_Nonneg_2907(z: real)\n ensures (if z >= 0 then z else -z) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_2908","instance":2908,"id":172907,"goal":"lemma DivMod_2908(y: int, a: int)\n requires a > 0\n ensures y == a * (y / a) + (y % a)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_2909","instance":2909,"id":172908,"goal":"lemma ModBounds_2909(b: nat, n: nat)\n requires n > 0\n ensures 0 <= b % n < n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_2910","instance":2910,"id":172909,"goal":"lemma Square_Nonneg_2910(d: real)\n ensures d * d >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_2911","instance":2911,"id":172910,"goal":"lemma AddComm_2911(y: int, c: int)\n ensures y + c == c + y\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_2912","instance":2912,"id":172911,"goal":"lemma AddAssoc_2912(d: nat, k: nat, i: nat)\n ensures (d + k) + i == d + (k + i)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_2913","instance":2913,"id":172912,"goal":"lemma MulComm_2913(y: real, b: real)\n ensures y * b == b * y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_2914","instance":2914,"id":172913,"goal":"lemma MulAssoc_2914(n: int, b: int, y: int)\n ensures (n * b) * y == n * (b * y)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_2915","instance":2915,"id":172914,"goal":"lemma Distrib_2915(d: nat, a: nat, b: nat)\n ensures d * (a + b) == d * a + d * b\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_2916","instance":2916,"id":172915,"goal":"lemma AddZero_2916(c: real)\n ensures c + 0 == c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_2917","instance":2917,"id":172916,"goal":"lemma MulOne_2917(k: int)\n ensures k * 1 == k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_2918","instance":2918,"id":172917,"goal":"lemma MulZero_2918(y: nat)\n ensures y * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_2919","instance":2919,"id":172918,"goal":"lemma LeRefl_2919(x: real)\n ensures x <= x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_2920","instance":2920,"id":172919,"goal":"lemma LeTrans_2920(m: int, i: int, d: int)\n requires m <= i && i <= d\n ensures m <= d\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_2921","instance":2921,"id":172920,"goal":"lemma AddMono_2921(m: nat, d: nat, b: nat)\n requires m <= d\n ensures m + b <= d + b\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_2922","instance":2922,"id":172921,"goal":"lemma Abs_Nonneg_2922(j: real)\n ensures (if j >= 0 then j else -j) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_2923","instance":2923,"id":172922,"goal":"lemma DivMod_2923(k: int, i: int)\n requires i > 0\n ensures k == i * (k / i) + (k % i)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_2924","instance":2924,"id":172923,"goal":"lemma ModBounds_2924(y: nat, b: nat)\n requires b > 0\n ensures 0 <= y % b < b\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_2925","instance":2925,"id":172924,"goal":"lemma Square_Nonneg_2925(a: real)\n ensures a * a >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_2926","instance":2926,"id":172925,"goal":"lemma AddComm_2926(i: int, j: int)\n ensures i + j == j + i\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_2927","instance":2927,"id":172926,"goal":"lemma AddAssoc_2927(x: nat, z: nat, m: nat)\n ensures (x + z) + m == x + (z + m)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_2928","instance":2928,"id":172927,"goal":"lemma MulComm_2928(m: real, x: real)\n ensures m * x == x * m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_2929","instance":2929,"id":172928,"goal":"lemma MulAssoc_2929(k: int, c: int, d: int)\n ensures (k * c) * d == k * (c * d)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_2930","instance":2930,"id":172929,"goal":"lemma Distrib_2930(k: nat, j: nat, a: nat)\n ensures k * (j + a) == k * j + k * a\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_2931","instance":2931,"id":172930,"goal":"lemma AddZero_2931(a: real)\n ensures a + 0 == a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_2932","instance":2932,"id":172931,"goal":"lemma MulOne_2932(z: int)\n ensures z * 1 == z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_2933","instance":2933,"id":172932,"goal":"lemma MulZero_2933(x: nat)\n ensures x * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_2934","instance":2934,"id":172933,"goal":"lemma LeRefl_2934(k: real)\n ensures k <= k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_2935","instance":2935,"id":172934,"goal":"lemma LeTrans_2935(j: int, b: int, i: int)\n requires j <= b && b <= i\n ensures j <= i\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_2936","instance":2936,"id":172935,"goal":"lemma AddMono_2936(i: nat, x: nat, d: nat)\n requires i <= x\n ensures i + d <= x + d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_2937","instance":2937,"id":172936,"goal":"lemma Abs_Nonneg_2937(z: real)\n ensures (if z >= 0 then z else -z) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_2938","instance":2938,"id":172937,"goal":"lemma DivMod_2938(x: int, c: int)\n requires c > 0\n ensures x == c * (x / c) + (x % c)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_2939","instance":2939,"id":172938,"goal":"lemma ModBounds_2939(y: nat, c: nat)\n requires c > 0\n ensures 0 <= y % c < c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_2940","instance":2940,"id":172939,"goal":"lemma Square_Nonneg_2940(d: real)\n ensures d * d >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_2941","instance":2941,"id":172940,"goal":"lemma AddComm_2941(k: int, b: int)\n ensures k + b == b + k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_2942","instance":2942,"id":172941,"goal":"lemma AddAssoc_2942(d: nat, n: nat, x: nat)\n ensures (d + n) + x == d + (n + x)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_2943","instance":2943,"id":172942,"goal":"lemma MulComm_2943(c: real, a: real)\n ensures c * a == a * c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_2944","instance":2944,"id":172943,"goal":"lemma MulAssoc_2944(i: int, a: int, k: int)\n ensures (i * a) * k == i * (a * k)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_2945","instance":2945,"id":172944,"goal":"lemma Distrib_2945(k: nat, b: nat, a: nat)\n ensures k * (b + a) == k * b + k * a\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_2946","instance":2946,"id":172945,"goal":"lemma AddZero_2946(y: real)\n ensures y + 0 == y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_2947","instance":2947,"id":172946,"goal":"lemma MulOne_2947(x: int)\n ensures x * 1 == x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_2948","instance":2948,"id":172947,"goal":"lemma MulZero_2948(n: nat)\n ensures n * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_2949","instance":2949,"id":172948,"goal":"lemma LeRefl_2949(x: real)\n ensures x <= x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_2950","instance":2950,"id":172949,"goal":"lemma LeTrans_2950(y: int, b: int, x: int)\n requires y <= b && b <= x\n ensures y <= x\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_2951","instance":2951,"id":172950,"goal":"lemma AddMono_2951(x: nat, d: nat, a: nat)\n requires x <= d\n ensures x + a <= d + a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_2952","instance":2952,"id":172951,"goal":"lemma Abs_Nonneg_2952(j: real)\n ensures (if j >= 0 then j else -j) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_2953","instance":2953,"id":172952,"goal":"lemma DivMod_2953(y: int, m: int)\n requires m > 0\n ensures y == m * (y / m) + (y % m)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_2954","instance":2954,"id":172953,"goal":"lemma ModBounds_2954(j: nat, m: nat)\n requires m > 0\n ensures 0 <= j % m < m\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_2955","instance":2955,"id":172954,"goal":"lemma Square_Nonneg_2955(c: real)\n ensures c * c >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_2956","instance":2956,"id":172955,"goal":"lemma AddComm_2956(x: int, n: int)\n ensures x + n == n + x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_2957","instance":2957,"id":172956,"goal":"lemma AddAssoc_2957(d: nat, k: nat, n: nat)\n ensures (d + k) + n == d + (k + n)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_2958","instance":2958,"id":172957,"goal":"lemma MulComm_2958(c: real, i: real)\n ensures c * i == i * c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_2959","instance":2959,"id":172958,"goal":"lemma MulAssoc_2959(c: int, y: int, m: int)\n ensures (c * y) * m == c * (y * m)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_2960","instance":2960,"id":172959,"goal":"lemma Distrib_2960(a: nat, d: nat, n: nat)\n ensures a * (d + n) == a * d + a * n\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_2961","instance":2961,"id":172960,"goal":"lemma AddZero_2961(b: real)\n ensures b + 0 == b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_2962","instance":2962,"id":172961,"goal":"lemma MulOne_2962(n: int)\n ensures n * 1 == n\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_2963","instance":2963,"id":172962,"goal":"lemma MulZero_2963(c: nat)\n ensures c * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_2964","instance":2964,"id":172963,"goal":"lemma LeRefl_2964(z: real)\n ensures z <= z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_2965","instance":2965,"id":172964,"goal":"lemma LeTrans_2965(i: int, k: int, j: int)\n requires i <= k && k <= j\n ensures i <= j\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_2966","instance":2966,"id":172965,"goal":"lemma AddMono_2966(x: nat, a: nat, i: nat)\n requires x <= a\n ensures x + i <= a + i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_2967","instance":2967,"id":172966,"goal":"lemma Abs_Nonneg_2967(b: real)\n ensures (if b >= 0 then b else -b) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_2968","instance":2968,"id":172967,"goal":"lemma DivMod_2968(k: int, y: int)\n requires y > 0\n ensures k == y * (k / y) + (k % y)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_2969","instance":2969,"id":172968,"goal":"lemma ModBounds_2969(y: nat, j: nat)\n requires j > 0\n ensures 0 <= y % j < j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_2970","instance":2970,"id":172969,"goal":"lemma Square_Nonneg_2970(x: real)\n ensures x * x >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_2971","instance":2971,"id":172970,"goal":"lemma AddComm_2971(a: int, c: int)\n ensures a + c == c + a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_2972","instance":2972,"id":172971,"goal":"lemma AddAssoc_2972(d: nat, z: nat, x: nat)\n ensures (d + z) + x == d + (z + x)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_2973","instance":2973,"id":172972,"goal":"lemma MulComm_2973(x: real, m: real)\n ensures x * m == m * x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_2974","instance":2974,"id":172973,"goal":"lemma MulAssoc_2974(x: int, y: int, b: int)\n ensures (x * y) * b == x * (y * b)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_2975","instance":2975,"id":172974,"goal":"lemma Distrib_2975(y: nat, m: nat, b: nat)\n ensures y * (m + b) == y * m + y * b\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_2976","instance":2976,"id":172975,"goal":"lemma AddZero_2976(i: real)\n ensures i + 0 == i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_2977","instance":2977,"id":172976,"goal":"lemma MulOne_2977(b: int)\n ensures b * 1 == b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_2978","instance":2978,"id":172977,"goal":"lemma MulZero_2978(z: nat)\n ensures z * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_2979","instance":2979,"id":172978,"goal":"lemma LeRefl_2979(n: real)\n ensures n <= n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_2980","instance":2980,"id":172979,"goal":"lemma LeTrans_2980(x: int, i: int, d: int)\n requires x <= i && i <= d\n ensures x <= d\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_2981","instance":2981,"id":172980,"goal":"lemma AddMono_2981(b: nat, n: nat, k: nat)\n requires b <= n\n ensures b + k <= n + k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_2982","instance":2982,"id":172981,"goal":"lemma Abs_Nonneg_2982(y: real)\n ensures (if y >= 0 then y else -y) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_2983","instance":2983,"id":172982,"goal":"lemma DivMod_2983(n: int, a: int)\n requires a > 0\n ensures n == a * (n / a) + (n % a)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_2984","instance":2984,"id":172983,"goal":"lemma ModBounds_2984(c: nat, j: nat)\n requires j > 0\n ensures 0 <= c % j < j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_2985","instance":2985,"id":172984,"goal":"lemma Square_Nonneg_2985(z: real)\n ensures z * z >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_2986","instance":2986,"id":172985,"goal":"lemma AddComm_2986(y: int, b: int)\n ensures y + b == b + y\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_2987","instance":2987,"id":172986,"goal":"lemma AddAssoc_2987(i: nat, x: nat, j: nat)\n ensures (i + x) + j == i + (x + j)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_2988","instance":2988,"id":172987,"goal":"lemma MulComm_2988(n: real, d: real)\n ensures n * d == d * n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_2989","instance":2989,"id":172988,"goal":"lemma MulAssoc_2989(i: int, z: int, a: int)\n ensures (i * z) * a == i * (z * a)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_2990","instance":2990,"id":172989,"goal":"lemma Distrib_2990(j: nat, b: nat, a: nat)\n ensures j * (b + a) == j * b + j * a\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_2991","instance":2991,"id":172990,"goal":"lemma AddZero_2991(n: real)\n ensures n + 0 == n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_2992","instance":2992,"id":172991,"goal":"lemma MulOne_2992(k: int)\n ensures k * 1 == k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_2993","instance":2993,"id":172992,"goal":"lemma MulZero_2993(z: nat)\n ensures z * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_2994","instance":2994,"id":172993,"goal":"lemma LeRefl_2994(d: real)\n ensures d <= d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_2995","instance":2995,"id":172994,"goal":"lemma LeTrans_2995(d: int, z: int, b: int)\n requires d <= z && z <= b\n ensures d <= b\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_2996","instance":2996,"id":172995,"goal":"lemma AddMono_2996(x: nat, z: nat, j: nat)\n requires x <= z\n ensures x + j <= z + j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_2997","instance":2997,"id":172996,"goal":"lemma Abs_Nonneg_2997(x: real)\n ensures (if x >= 0 then x else -x) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_2998","instance":2998,"id":172997,"goal":"lemma DivMod_2998(a: int, y: int)\n requires y > 0\n ensures a == y * (a / y) + (a % y)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_2999","instance":2999,"id":172998,"goal":"lemma ModBounds_2999(b: nat, c: nat)\n requires c > 0\n ensures 0 <= b % c < c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_3000","instance":3000,"id":172999,"goal":"lemma Square_Nonneg_3000(c: real)\n ensures c * c >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_3001","instance":3001,"id":173000,"goal":"lemma AddComm_3001(i: int, k: int)\n ensures i + k == k + i\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_3002","instance":3002,"id":173001,"goal":"lemma AddAssoc_3002(m: nat, k: nat, n: nat)\n ensures (m + k) + n == m + (k + n)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_3003","instance":3003,"id":173002,"goal":"lemma MulComm_3003(k: real, y: real)\n ensures k * y == y * k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_3004","instance":3004,"id":173003,"goal":"lemma MulAssoc_3004(c: int, b: int, d: int)\n ensures (c * b) * d == c * (b * d)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_3005","instance":3005,"id":173004,"goal":"lemma Distrib_3005(y: nat, x: nat, d: nat)\n ensures y * (x + d) == y * x + y * d\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_3006","instance":3006,"id":173005,"goal":"lemma AddZero_3006(a: real)\n ensures a + 0 == a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_3007","instance":3007,"id":173006,"goal":"lemma MulOne_3007(m: int)\n ensures m * 1 == m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_3008","instance":3008,"id":173007,"goal":"lemma MulZero_3008(j: nat)\n ensures j * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_3009","instance":3009,"id":173008,"goal":"lemma LeRefl_3009(m: real)\n ensures m <= m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_3010","instance":3010,"id":173009,"goal":"lemma LeTrans_3010(j: int, b: int, y: int)\n requires j <= b && b <= y\n ensures j <= y\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_3011","instance":3011,"id":173010,"goal":"lemma AddMono_3011(m: nat, c: nat, k: nat)\n requires m <= c\n ensures m + k <= c + k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_3012","instance":3012,"id":173011,"goal":"lemma Abs_Nonneg_3012(b: real)\n ensures (if b >= 0 then b else -b) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_3013","instance":3013,"id":173012,"goal":"lemma DivMod_3013(z: int, m: int)\n requires m > 0\n ensures z == m * (z / m) + (z % m)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_3014","instance":3014,"id":173013,"goal":"lemma ModBounds_3014(n: nat, d: nat)\n requires d > 0\n ensures 0 <= n % d < d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_3015","instance":3015,"id":173014,"goal":"lemma Square_Nonneg_3015(z: real)\n ensures z * z >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_3016","instance":3016,"id":173015,"goal":"lemma AddComm_3016(b: int, c: int)\n ensures b + c == c + b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_3017","instance":3017,"id":173016,"goal":"lemma AddAssoc_3017(c: nat, j: nat, m: nat)\n ensures (c + j) + m == c + (j + m)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_3018","instance":3018,"id":173017,"goal":"lemma MulComm_3018(a: real, d: real)\n ensures a * d == d * a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_3019","instance":3019,"id":173018,"goal":"lemma MulAssoc_3019(x: int, j: int, b: int)\n ensures (x * j) * b == x * (j * b)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_3020","instance":3020,"id":173019,"goal":"lemma Distrib_3020(n: nat, m: nat, c: nat)\n ensures n * (m + c) == n * m + n * c\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_3021","instance":3021,"id":173020,"goal":"lemma AddZero_3021(k: real)\n ensures k + 0 == k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_3022","instance":3022,"id":173021,"goal":"lemma MulOne_3022(d: int)\n ensures d * 1 == d\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_3023","instance":3023,"id":173022,"goal":"lemma MulZero_3023(m: nat)\n ensures m * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_3024","instance":3024,"id":173023,"goal":"lemma LeRefl_3024(x: real)\n ensures x <= x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_3025","instance":3025,"id":173024,"goal":"lemma LeTrans_3025(z: int, k: int, i: int)\n requires z <= k && k <= i\n ensures z <= i\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_3026","instance":3026,"id":173025,"goal":"lemma AddMono_3026(y: nat, k: nat, x: nat)\n requires y <= k\n ensures y + x <= k + x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_3027","instance":3027,"id":173026,"goal":"lemma Abs_Nonneg_3027(n: real)\n ensures (if n >= 0 then n else -n) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_3028","instance":3028,"id":173027,"goal":"lemma DivMod_3028(y: int, m: int)\n requires m > 0\n ensures y == m * (y / m) + (y % m)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_3029","instance":3029,"id":173028,"goal":"lemma ModBounds_3029(i: nat, j: nat)\n requires j > 0\n ensures 0 <= i % j < j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_3030","instance":3030,"id":173029,"goal":"lemma Square_Nonneg_3030(k: real)\n ensures k * k >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_3031","instance":3031,"id":173030,"goal":"lemma AddComm_3031(n: int, c: int)\n ensures n + c == c + n\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_3032","instance":3032,"id":173031,"goal":"lemma AddAssoc_3032(y: nat, a: nat, x: nat)\n ensures (y + a) + x == y + (a + x)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_3033","instance":3033,"id":173032,"goal":"lemma MulComm_3033(k: real, z: real)\n ensures k * z == z * k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_3034","instance":3034,"id":173033,"goal":"lemma MulAssoc_3034(c: int, z: int, k: int)\n ensures (c * z) * k == c * (z * k)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_3035","instance":3035,"id":173034,"goal":"lemma Distrib_3035(m: nat, d: nat, k: nat)\n ensures m * (d + k) == m * d + m * k\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_3036","instance":3036,"id":173035,"goal":"lemma AddZero_3036(c: real)\n ensures c + 0 == c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_3037","instance":3037,"id":173036,"goal":"lemma MulOne_3037(n: int)\n ensures n * 1 == n\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_3038","instance":3038,"id":173037,"goal":"lemma MulZero_3038(a: nat)\n ensures a * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_3039","instance":3039,"id":173038,"goal":"lemma LeRefl_3039(a: real)\n ensures a <= a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_3040","instance":3040,"id":173039,"goal":"lemma LeTrans_3040(a: int, d: int, b: int)\n requires a <= d && d <= b\n ensures a <= b\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_3041","instance":3041,"id":173040,"goal":"lemma AddMono_3041(z: nat, i: nat, m: nat)\n requires z <= i\n ensures z + m <= i + m\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_3042","instance":3042,"id":173041,"goal":"lemma Abs_Nonneg_3042(i: real)\n ensures (if i >= 0 then i else -i) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_3043","instance":3043,"id":173042,"goal":"lemma DivMod_3043(m: int, d: int)\n requires d > 0\n ensures m == d * (m / d) + (m % d)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_3044","instance":3044,"id":173043,"goal":"lemma ModBounds_3044(m: nat, j: nat)\n requires j > 0\n ensures 0 <= m % j < j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_3045","instance":3045,"id":173044,"goal":"lemma Square_Nonneg_3045(x: real)\n ensures x * x >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_3046","instance":3046,"id":173045,"goal":"lemma AddComm_3046(c: int, z: int)\n ensures c + z == z + c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_3047","instance":3047,"id":173046,"goal":"lemma AddAssoc_3047(b: nat, y: nat, k: nat)\n ensures (b + y) + k == b + (y + k)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_3048","instance":3048,"id":173047,"goal":"lemma MulComm_3048(y: real, m: real)\n ensures y * m == m * y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_3049","instance":3049,"id":173048,"goal":"lemma MulAssoc_3049(y: int, m: int, b: int)\n ensures (y * m) * b == y * (m * b)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_3050","instance":3050,"id":173049,"goal":"lemma Distrib_3050(a: nat, y: nat, c: nat)\n ensures a * (y + c) == a * y + a * c\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_3051","instance":3051,"id":173050,"goal":"lemma AddZero_3051(b: real)\n ensures b + 0 == b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_3052","instance":3052,"id":173051,"goal":"lemma MulOne_3052(z: int)\n ensures z * 1 == z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_3053","instance":3053,"id":173052,"goal":"lemma MulZero_3053(k: nat)\n ensures k * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_3054","instance":3054,"id":173053,"goal":"lemma LeRefl_3054(x: real)\n ensures x <= x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_3055","instance":3055,"id":173054,"goal":"lemma LeTrans_3055(z: int, k: int, d: int)\n requires z <= k && k <= d\n ensures z <= d\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_3056","instance":3056,"id":173055,"goal":"lemma AddMono_3056(n: nat, j: nat, z: nat)\n requires n <= j\n ensures n + z <= j + z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_3057","instance":3057,"id":173056,"goal":"lemma Abs_Nonneg_3057(m: real)\n ensures (if m >= 0 then m else -m) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_3058","instance":3058,"id":173057,"goal":"lemma DivMod_3058(x: int, c: int)\n requires c > 0\n ensures x == c * (x / c) + (x % c)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_3059","instance":3059,"id":173058,"goal":"lemma ModBounds_3059(x: nat, c: nat)\n requires c > 0\n ensures 0 <= x % c < c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_3060","instance":3060,"id":173059,"goal":"lemma Square_Nonneg_3060(m: real)\n ensures m * m >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_3061","instance":3061,"id":173060,"goal":"lemma AddComm_3061(c: int, a: int)\n ensures c + a == a + c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_3062","instance":3062,"id":173061,"goal":"lemma AddAssoc_3062(z: nat, a: nat, c: nat)\n ensures (z + a) + c == z + (a + c)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_3063","instance":3063,"id":173062,"goal":"lemma MulComm_3063(k: real, a: real)\n ensures k * a == a * k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_3064","instance":3064,"id":173063,"goal":"lemma MulAssoc_3064(d: int, a: int, c: int)\n ensures (d * a) * c == d * (a * c)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_3065","instance":3065,"id":173064,"goal":"lemma Distrib_3065(a: nat, i: nat, x: nat)\n ensures a * (i + x) == a * i + a * x\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_3066","instance":3066,"id":173065,"goal":"lemma AddZero_3066(k: real)\n ensures k + 0 == k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_3067","instance":3067,"id":173066,"goal":"lemma MulOne_3067(n: int)\n ensures n * 1 == n\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_3068","instance":3068,"id":173067,"goal":"lemma MulZero_3068(z: nat)\n ensures z * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_3069","instance":3069,"id":173068,"goal":"lemma LeRefl_3069(k: real)\n ensures k <= k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_3070","instance":3070,"id":173069,"goal":"lemma LeTrans_3070(c: int, a: int, j: int)\n requires c <= a && a <= j\n ensures c <= j\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_3071","instance":3071,"id":173070,"goal":"lemma AddMono_3071(x: nat, b: nat, n: nat)\n requires x <= b\n ensures x + n <= b + n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_3072","instance":3072,"id":173071,"goal":"lemma Abs_Nonneg_3072(k: real)\n ensures (if k >= 0 then k else -k) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_3073","instance":3073,"id":173072,"goal":"lemma DivMod_3073(x: int, i: int)\n requires i > 0\n ensures x == i * (x / i) + (x % i)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_3074","instance":3074,"id":173073,"goal":"lemma ModBounds_3074(m: nat, d: nat)\n requires d > 0\n ensures 0 <= m % d < d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_3075","instance":3075,"id":173074,"goal":"lemma Square_Nonneg_3075(b: real)\n ensures b * b >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_3076","instance":3076,"id":173075,"goal":"lemma AddComm_3076(b: int, y: int)\n ensures b + y == y + b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_3077","instance":3077,"id":173076,"goal":"lemma AddAssoc_3077(n: nat, b: nat, z: nat)\n ensures (n + b) + z == n + (b + z)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_3078","instance":3078,"id":173077,"goal":"lemma MulComm_3078(d: real, n: real)\n ensures d * n == n * d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_3079","instance":3079,"id":173078,"goal":"lemma MulAssoc_3079(a: int, b: int, k: int)\n ensures (a * b) * k == a * (b * k)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_3080","instance":3080,"id":173079,"goal":"lemma Distrib_3080(m: nat, i: nat, y: nat)\n ensures m * (i + y) == m * i + m * y\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_3081","instance":3081,"id":173080,"goal":"lemma AddZero_3081(m: real)\n ensures m + 0 == m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_3082","instance":3082,"id":173081,"goal":"lemma MulOne_3082(m: int)\n ensures m * 1 == m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_3083","instance":3083,"id":173082,"goal":"lemma MulZero_3083(j: nat)\n ensures j * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_3084","instance":3084,"id":173083,"goal":"lemma LeRefl_3084(z: real)\n ensures z <= z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_3085","instance":3085,"id":173084,"goal":"lemma LeTrans_3085(j: int, b: int, x: int)\n requires j <= b && b <= x\n ensures j <= x\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_3086","instance":3086,"id":173085,"goal":"lemma AddMono_3086(k: nat, z: nat, c: nat)\n requires k <= z\n ensures k + c <= z + c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_3087","instance":3087,"id":173086,"goal":"lemma Abs_Nonneg_3087(i: real)\n ensures (if i >= 0 then i else -i) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_3088","instance":3088,"id":173087,"goal":"lemma DivMod_3088(j: int, d: int)\n requires d > 0\n ensures j == d * (j / d) + (j % d)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_3089","instance":3089,"id":173088,"goal":"lemma ModBounds_3089(y: nat, z: nat)\n requires z > 0\n ensures 0 <= y % z < z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_3090","instance":3090,"id":173089,"goal":"lemma Square_Nonneg_3090(m: real)\n ensures m * m >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_3091","instance":3091,"id":173090,"goal":"lemma AddComm_3091(n: int, y: int)\n ensures n + y == y + n\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_3092","instance":3092,"id":173091,"goal":"lemma AddAssoc_3092(d: nat, b: nat, c: nat)\n ensures (d + b) + c == d + (b + c)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_3093","instance":3093,"id":173092,"goal":"lemma MulComm_3093(m: real, k: real)\n ensures m * k == k * m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_3094","instance":3094,"id":173093,"goal":"lemma MulAssoc_3094(b: int, d: int, j: int)\n ensures (b * d) * j == b * (d * j)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_3095","instance":3095,"id":173094,"goal":"lemma Distrib_3095(a: nat, m: nat, d: nat)\n ensures a * (m + d) == a * m + a * d\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_3096","instance":3096,"id":173095,"goal":"lemma AddZero_3096(j: real)\n ensures j + 0 == j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_3097","instance":3097,"id":173096,"goal":"lemma MulOne_3097(j: int)\n ensures j * 1 == j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_3098","instance":3098,"id":173097,"goal":"lemma MulZero_3098(a: nat)\n ensures a * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_3099","instance":3099,"id":173098,"goal":"lemma LeRefl_3099(z: real)\n ensures z <= z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_3100","instance":3100,"id":173099,"goal":"lemma LeTrans_3100(n: int, m: int, i: int)\n requires n <= m && m <= i\n ensures n <= i\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_3101","instance":3101,"id":173100,"goal":"lemma AddMono_3101(k: nat, i: nat, j: nat)\n requires k <= i\n ensures k + j <= i + j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_3102","instance":3102,"id":173101,"goal":"lemma Abs_Nonneg_3102(c: real)\n ensures (if c >= 0 then c else -c) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_3103","instance":3103,"id":173102,"goal":"lemma DivMod_3103(d: int, i: int)\n requires i > 0\n ensures d == i * (d / i) + (d % i)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_3104","instance":3104,"id":173103,"goal":"lemma ModBounds_3104(a: nat, i: nat)\n requires i > 0\n ensures 0 <= a % i < i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_3105","instance":3105,"id":173104,"goal":"lemma Square_Nonneg_3105(d: real)\n ensures d * d >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_3106","instance":3106,"id":173105,"goal":"lemma AddComm_3106(x: int, n: int)\n ensures x + n == n + x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_3107","instance":3107,"id":173106,"goal":"lemma AddAssoc_3107(d: nat, y: nat, a: nat)\n ensures (d + y) + a == d + (y + a)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_3108","instance":3108,"id":173107,"goal":"lemma MulComm_3108(k: real, m: real)\n ensures k * m == m * k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_3109","instance":3109,"id":173108,"goal":"lemma MulAssoc_3109(z: int, x: int, i: int)\n ensures (z * x) * i == z * (x * i)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_3110","instance":3110,"id":173109,"goal":"lemma Distrib_3110(j: nat, i: nat, a: nat)\n ensures j * (i + a) == j * i + j * a\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_3111","instance":3111,"id":173110,"goal":"lemma AddZero_3111(j: real)\n ensures j + 0 == j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_3112","instance":3112,"id":173111,"goal":"lemma MulOne_3112(y: int)\n ensures y * 1 == y\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_3113","instance":3113,"id":173112,"goal":"lemma MulZero_3113(n: nat)\n ensures n * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_3114","instance":3114,"id":173113,"goal":"lemma LeRefl_3114(k: real)\n ensures k <= k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_3115","instance":3115,"id":173114,"goal":"lemma LeTrans_3115(y: int, j: int, c: int)\n requires y <= j && j <= c\n ensures y <= c\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_3116","instance":3116,"id":173115,"goal":"lemma AddMono_3116(b: nat, c: nat, i: nat)\n requires b <= c\n ensures b + i <= c + i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_3117","instance":3117,"id":173116,"goal":"lemma Abs_Nonneg_3117(m: real)\n ensures (if m >= 0 then m else -m) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_3118","instance":3118,"id":173117,"goal":"lemma DivMod_3118(x: int, j: int)\n requires j > 0\n ensures x == j * (x / j) + (x % j)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_3119","instance":3119,"id":173118,"goal":"lemma ModBounds_3119(j: nat, b: nat)\n requires b > 0\n ensures 0 <= j % b < b\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_3120","instance":3120,"id":173119,"goal":"lemma Square_Nonneg_3120(c: real)\n ensures c * c >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_3121","instance":3121,"id":173120,"goal":"lemma AddComm_3121(d: int, y: int)\n ensures d + y == y + d\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_3122","instance":3122,"id":173121,"goal":"lemma AddAssoc_3122(m: nat, a: nat, b: nat)\n ensures (m + a) + b == m + (a + b)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_3123","instance":3123,"id":173122,"goal":"lemma MulComm_3123(n: real, d: real)\n ensures n * d == d * n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_3124","instance":3124,"id":173123,"goal":"lemma MulAssoc_3124(m: int, b: int, z: int)\n ensures (m * b) * z == m * (b * z)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_3125","instance":3125,"id":173124,"goal":"lemma Distrib_3125(a: nat, x: nat, n: nat)\n ensures a * (x + n) == a * x + a * n\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_3126","instance":3126,"id":173125,"goal":"lemma AddZero_3126(m: real)\n ensures m + 0 == m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_3127","instance":3127,"id":173126,"goal":"lemma MulOne_3127(c: int)\n ensures c * 1 == c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_3128","instance":3128,"id":173127,"goal":"lemma MulZero_3128(a: nat)\n ensures a * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_3129","instance":3129,"id":173128,"goal":"lemma LeRefl_3129(k: real)\n ensures k <= k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_3130","instance":3130,"id":173129,"goal":"lemma LeTrans_3130(d: int, a: int, y: int)\n requires d <= a && a <= y\n ensures d <= y\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_3131","instance":3131,"id":173130,"goal":"lemma AddMono_3131(y: nat, x: nat, k: nat)\n requires y <= x\n ensures y + k <= x + k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_3132","instance":3132,"id":173131,"goal":"lemma Abs_Nonneg_3132(y: real)\n ensures (if y >= 0 then y else -y) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_3133","instance":3133,"id":173132,"goal":"lemma DivMod_3133(x: int, n: int)\n requires n > 0\n ensures x == n * (x / n) + (x % n)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_3134","instance":3134,"id":173133,"goal":"lemma ModBounds_3134(n: nat, k: nat)\n requires k > 0\n ensures 0 <= n % k < k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_3135","instance":3135,"id":173134,"goal":"lemma Square_Nonneg_3135(i: real)\n ensures i * i >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_3136","instance":3136,"id":173135,"goal":"lemma AddComm_3136(i: int, y: int)\n ensures i + y == y + i\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_3137","instance":3137,"id":173136,"goal":"lemma AddAssoc_3137(c: nat, j: nat, y: nat)\n ensures (c + j) + y == c + (j + y)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_3138","instance":3138,"id":173137,"goal":"lemma MulComm_3138(j: real, b: real)\n ensures j * b == b * j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_3139","instance":3139,"id":173138,"goal":"lemma MulAssoc_3139(c: int, n: int, k: int)\n ensures (c * n) * k == c * (n * k)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_3140","instance":3140,"id":173139,"goal":"lemma Distrib_3140(j: nat, x: nat, y: nat)\n ensures j * (x + y) == j * x + j * y\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_3141","instance":3141,"id":173140,"goal":"lemma AddZero_3141(b: real)\n ensures b + 0 == b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_3142","instance":3142,"id":173141,"goal":"lemma MulOne_3142(c: int)\n ensures c * 1 == c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_3143","instance":3143,"id":173142,"goal":"lemma MulZero_3143(m: nat)\n ensures m * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_3144","instance":3144,"id":173143,"goal":"lemma LeRefl_3144(c: real)\n ensures c <= c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_3145","instance":3145,"id":173144,"goal":"lemma LeTrans_3145(n: int, a: int, y: int)\n requires n <= a && a <= y\n ensures n <= y\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_3146","instance":3146,"id":173145,"goal":"lemma AddMono_3146(z: nat, y: nat, j: nat)\n requires z <= y\n ensures z + j <= y + j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_3147","instance":3147,"id":173146,"goal":"lemma Abs_Nonneg_3147(b: real)\n ensures (if b >= 0 then b else -b) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_3148","instance":3148,"id":173147,"goal":"lemma DivMod_3148(j: int, m: int)\n requires m > 0\n ensures j == m * (j / m) + (j % m)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_3149","instance":3149,"id":173148,"goal":"lemma ModBounds_3149(c: nat, m: nat)\n requires m > 0\n ensures 0 <= c % m < m\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_3150","instance":3150,"id":173149,"goal":"lemma Square_Nonneg_3150(m: real)\n ensures m * m >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_3151","instance":3151,"id":173150,"goal":"lemma AddComm_3151(d: int, k: int)\n ensures d + k == k + d\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_3152","instance":3152,"id":173151,"goal":"lemma AddAssoc_3152(k: nat, j: nat, y: nat)\n ensures (k + j) + y == k + (j + y)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_3153","instance":3153,"id":173152,"goal":"lemma MulComm_3153(i: real, c: real)\n ensures i * c == c * i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_3154","instance":3154,"id":173153,"goal":"lemma MulAssoc_3154(y: int, k: int, b: int)\n ensures (y * k) * b == y * (k * b)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_3155","instance":3155,"id":173154,"goal":"lemma Distrib_3155(m: nat, x: nat, y: nat)\n ensures m * (x + y) == m * x + m * y\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_3156","instance":3156,"id":173155,"goal":"lemma AddZero_3156(i: real)\n ensures i + 0 == i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_3157","instance":3157,"id":173156,"goal":"lemma MulOne_3157(d: int)\n ensures d * 1 == d\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_3158","instance":3158,"id":173157,"goal":"lemma MulZero_3158(d: nat)\n ensures d * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_3159","instance":3159,"id":173158,"goal":"lemma LeRefl_3159(a: real)\n ensures a <= a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_3160","instance":3160,"id":173159,"goal":"lemma LeTrans_3160(y: int, a: int, z: int)\n requires y <= a && a <= z\n ensures y <= z\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_3161","instance":3161,"id":173160,"goal":"lemma AddMono_3161(n: nat, m: nat, k: nat)\n requires n <= m\n ensures n + k <= m + k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_3162","instance":3162,"id":173161,"goal":"lemma Abs_Nonneg_3162(k: real)\n ensures (if k >= 0 then k else -k) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_3163","instance":3163,"id":173162,"goal":"lemma DivMod_3163(a: int, k: int)\n requires k > 0\n ensures a == k * (a / k) + (a % k)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_3164","instance":3164,"id":173163,"goal":"lemma ModBounds_3164(m: nat, c: nat)\n requires c > 0\n ensures 0 <= m % c < c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_3165","instance":3165,"id":173164,"goal":"lemma Square_Nonneg_3165(x: real)\n ensures x * x >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_3166","instance":3166,"id":173165,"goal":"lemma AddComm_3166(i: int, m: int)\n ensures i + m == m + i\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_3167","instance":3167,"id":173166,"goal":"lemma AddAssoc_3167(n: nat, a: nat, i: nat)\n ensures (n + a) + i == n + (a + i)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_3168","instance":3168,"id":173167,"goal":"lemma MulComm_3168(i: real, x: real)\n ensures i * x == x * i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_3169","instance":3169,"id":173168,"goal":"lemma MulAssoc_3169(m: int, z: int, y: int)\n ensures (m * z) * y == m * (z * y)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_3170","instance":3170,"id":173169,"goal":"lemma Distrib_3170(y: nat, z: nat, k: nat)\n ensures y * (z + k) == y * z + y * k\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_3171","instance":3171,"id":173170,"goal":"lemma AddZero_3171(n: real)\n ensures n + 0 == n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_3172","instance":3172,"id":173171,"goal":"lemma MulOne_3172(a: int)\n ensures a * 1 == a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_3173","instance":3173,"id":173172,"goal":"lemma MulZero_3173(a: nat)\n ensures a * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_3174","instance":3174,"id":173173,"goal":"lemma LeRefl_3174(j: real)\n ensures j <= j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_3175","instance":3175,"id":173174,"goal":"lemma LeTrans_3175(d: int, n: int, k: int)\n requires d <= n && n <= k\n ensures d <= k\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_3176","instance":3176,"id":173175,"goal":"lemma AddMono_3176(x: nat, m: nat, c: nat)\n requires x <= m\n ensures x + c <= m + c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_3177","instance":3177,"id":173176,"goal":"lemma Abs_Nonneg_3177(a: real)\n ensures (if a >= 0 then a else -a) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_3178","instance":3178,"id":173177,"goal":"lemma DivMod_3178(x: int, j: int)\n requires j > 0\n ensures x == j * (x / j) + (x % j)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_3179","instance":3179,"id":173178,"goal":"lemma ModBounds_3179(m: nat, x: nat)\n requires x > 0\n ensures 0 <= m % x < x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_3180","instance":3180,"id":173179,"goal":"lemma Square_Nonneg_3180(j: real)\n ensures j * j >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_3181","instance":3181,"id":173180,"goal":"lemma AddComm_3181(k: int, x: int)\n ensures k + x == x + k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_3182","instance":3182,"id":173181,"goal":"lemma AddAssoc_3182(x: nat, y: nat, m: nat)\n ensures (x + y) + m == x + (y + m)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_3183","instance":3183,"id":173182,"goal":"lemma MulComm_3183(d: real, b: real)\n ensures d * b == b * d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_3184","instance":3184,"id":173183,"goal":"lemma MulAssoc_3184(k: int, i: int, b: int)\n ensures (k * i) * b == k * (i * b)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_3185","instance":3185,"id":173184,"goal":"lemma Distrib_3185(c: nat, z: nat, i: nat)\n ensures c * (z + i) == c * z + c * i\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_3186","instance":3186,"id":173185,"goal":"lemma AddZero_3186(d: real)\n ensures d + 0 == d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_3187","instance":3187,"id":173186,"goal":"lemma MulOne_3187(x: int)\n ensures x * 1 == x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_3188","instance":3188,"id":173187,"goal":"lemma MulZero_3188(c: nat)\n ensures c * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_3189","instance":3189,"id":173188,"goal":"lemma LeRefl_3189(d: real)\n ensures d <= d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_3190","instance":3190,"id":173189,"goal":"lemma LeTrans_3190(b: int, m: int, n: int)\n requires b <= m && m <= n\n ensures b <= n\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_3191","instance":3191,"id":173190,"goal":"lemma AddMono_3191(d: nat, n: nat, a: nat)\n requires d <= n\n ensures d + a <= n + a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_3192","instance":3192,"id":173191,"goal":"lemma Abs_Nonneg_3192(a: real)\n ensures (if a >= 0 then a else -a) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_3193","instance":3193,"id":173192,"goal":"lemma DivMod_3193(x: int, d: int)\n requires d > 0\n ensures x == d * (x / d) + (x % d)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_3194","instance":3194,"id":173193,"goal":"lemma ModBounds_3194(m: nat, x: nat)\n requires x > 0\n ensures 0 <= m % x < x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_3195","instance":3195,"id":173194,"goal":"lemma Square_Nonneg_3195(a: real)\n ensures a * a >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_3196","instance":3196,"id":173195,"goal":"lemma AddComm_3196(c: int, y: int)\n ensures c + y == y + c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_3197","instance":3197,"id":173196,"goal":"lemma AddAssoc_3197(c: nat, d: nat, b: nat)\n ensures (c + d) + b == c + (d + b)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_3198","instance":3198,"id":173197,"goal":"lemma MulComm_3198(k: real, n: real)\n ensures k * n == n * k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_3199","instance":3199,"id":173198,"goal":"lemma MulAssoc_3199(n: int, x: int, c: int)\n ensures (n * x) * c == n * (x * c)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_3200","instance":3200,"id":173199,"goal":"lemma Distrib_3200(j: nat, z: nat, b: nat)\n ensures j * (z + b) == j * z + j * b\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_3201","instance":3201,"id":173200,"goal":"lemma AddZero_3201(b: real)\n ensures b + 0 == b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_3202","instance":3202,"id":173201,"goal":"lemma MulOne_3202(c: int)\n ensures c * 1 == c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_3203","instance":3203,"id":173202,"goal":"lemma MulZero_3203(n: nat)\n ensures n * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_3204","instance":3204,"id":173203,"goal":"lemma LeRefl_3204(j: real)\n ensures j <= j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_3205","instance":3205,"id":173204,"goal":"lemma LeTrans_3205(j: int, k: int, n: int)\n requires j <= k && k <= n\n ensures j <= n\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_3206","instance":3206,"id":173205,"goal":"lemma AddMono_3206(m: nat, k: nat, a: nat)\n requires m <= k\n ensures m + a <= k + a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_3207","instance":3207,"id":173206,"goal":"lemma Abs_Nonneg_3207(b: real)\n ensures (if b >= 0 then b else -b) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_3208","instance":3208,"id":173207,"goal":"lemma DivMod_3208(j: int, z: int)\n requires z > 0\n ensures j == z * (j / z) + (j % z)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_3209","instance":3209,"id":173208,"goal":"lemma ModBounds_3209(b: nat, k: nat)\n requires k > 0\n ensures 0 <= b % k < k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_3210","instance":3210,"id":173209,"goal":"lemma Square_Nonneg_3210(n: real)\n ensures n * n >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_3211","instance":3211,"id":173210,"goal":"lemma AddComm_3211(m: int, x: int)\n ensures m + x == x + m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_3212","instance":3212,"id":173211,"goal":"lemma AddAssoc_3212(m: nat, d: nat, a: nat)\n ensures (m + d) + a == m + (d + a)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_3213","instance":3213,"id":173212,"goal":"lemma MulComm_3213(j: real, i: real)\n ensures j * i == i * j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_3214","instance":3214,"id":173213,"goal":"lemma MulAssoc_3214(d: int, x: int, b: int)\n ensures (d * x) * b == d * (x * b)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_3215","instance":3215,"id":173214,"goal":"lemma Distrib_3215(n: nat, m: nat, i: nat)\n ensures n * (m + i) == n * m + n * i\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_3216","instance":3216,"id":173215,"goal":"lemma AddZero_3216(y: real)\n ensures y + 0 == y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_3217","instance":3217,"id":173216,"goal":"lemma MulOne_3217(k: int)\n ensures k * 1 == k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_3218","instance":3218,"id":173217,"goal":"lemma MulZero_3218(z: nat)\n ensures z * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_3219","instance":3219,"id":173218,"goal":"lemma LeRefl_3219(m: real)\n ensures m <= m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_3220","instance":3220,"id":173219,"goal":"lemma LeTrans_3220(a: int, m: int, k: int)\n requires a <= m && m <= k\n ensures a <= k\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_3221","instance":3221,"id":173220,"goal":"lemma AddMono_3221(k: nat, j: nat, z: nat)\n requires k <= j\n ensures k + z <= j + z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_3222","instance":3222,"id":173221,"goal":"lemma Abs_Nonneg_3222(i: real)\n ensures (if i >= 0 then i else -i) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_3223","instance":3223,"id":173222,"goal":"lemma DivMod_3223(y: int, m: int)\n requires m > 0\n ensures y == m * (y / m) + (y % m)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_3224","instance":3224,"id":173223,"goal":"lemma ModBounds_3224(y: nat, a: nat)\n requires a > 0\n ensures 0 <= y % a < a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_3225","instance":3225,"id":173224,"goal":"lemma Square_Nonneg_3225(k: real)\n ensures k * k >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_3226","instance":3226,"id":173225,"goal":"lemma AddComm_3226(c: int, z: int)\n ensures c + z == z + c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_3227","instance":3227,"id":173226,"goal":"lemma AddAssoc_3227(x: nat, c: nat, m: nat)\n ensures (x + c) + m == x + (c + m)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_3228","instance":3228,"id":173227,"goal":"lemma MulComm_3228(b: real, z: real)\n ensures b * z == z * b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_3229","instance":3229,"id":173228,"goal":"lemma MulAssoc_3229(b: int, z: int, c: int)\n ensures (b * z) * c == b * (z * c)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_3230","instance":3230,"id":173229,"goal":"lemma Distrib_3230(b: nat, i: nat, c: nat)\n ensures b * (i + c) == b * i + b * c\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_3231","instance":3231,"id":173230,"goal":"lemma AddZero_3231(k: real)\n ensures k + 0 == k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_3232","instance":3232,"id":173231,"goal":"lemma MulOne_3232(a: int)\n ensures a * 1 == a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_3233","instance":3233,"id":173232,"goal":"lemma MulZero_3233(i: nat)\n ensures i * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_3234","instance":3234,"id":173233,"goal":"lemma LeRefl_3234(d: real)\n ensures d <= d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_3235","instance":3235,"id":173234,"goal":"lemma LeTrans_3235(y: int, j: int, n: int)\n requires y <= j && j <= n\n ensures y <= n\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_3236","instance":3236,"id":173235,"goal":"lemma AddMono_3236(i: nat, x: nat, c: nat)\n requires i <= x\n ensures i + c <= x + c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_3237","instance":3237,"id":173236,"goal":"lemma Abs_Nonneg_3237(i: real)\n ensures (if i >= 0 then i else -i) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_3238","instance":3238,"id":173237,"goal":"lemma DivMod_3238(n: int, j: int)\n requires j > 0\n ensures n == j * (n / j) + (n % j)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_3239","instance":3239,"id":173238,"goal":"lemma ModBounds_3239(k: nat, x: nat)\n requires x > 0\n ensures 0 <= k % x < x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_3240","instance":3240,"id":173239,"goal":"lemma Square_Nonneg_3240(m: real)\n ensures m * m >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_3241","instance":3241,"id":173240,"goal":"lemma AddComm_3241(a: int, z: int)\n ensures a + z == z + a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_3242","instance":3242,"id":173241,"goal":"lemma AddAssoc_3242(x: nat, c: nat, y: nat)\n ensures (x + c) + y == x + (c + y)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_3243","instance":3243,"id":173242,"goal":"lemma MulComm_3243(a: real, z: real)\n ensures a * z == z * a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_3244","instance":3244,"id":173243,"goal":"lemma MulAssoc_3244(x: int, z: int, n: int)\n ensures (x * z) * n == x * (z * n)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_3245","instance":3245,"id":173244,"goal":"lemma Distrib_3245(b: nat, j: nat, c: nat)\n ensures b * (j + c) == b * j + b * c\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_3246","instance":3246,"id":173245,"goal":"lemma AddZero_3246(j: real)\n ensures j + 0 == j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_3247","instance":3247,"id":173246,"goal":"lemma MulOne_3247(z: int)\n ensures z * 1 == z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_3248","instance":3248,"id":173247,"goal":"lemma MulZero_3248(c: nat)\n ensures c * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_3249","instance":3249,"id":173248,"goal":"lemma LeRefl_3249(c: real)\n ensures c <= c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_3250","instance":3250,"id":173249,"goal":"lemma LeTrans_3250(m: int, i: int, b: int)\n requires m <= i && i <= b\n ensures m <= b\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_3251","instance":3251,"id":173250,"goal":"lemma AddMono_3251(c: nat, j: nat, n: nat)\n requires c <= j\n ensures c + n <= j + n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_3252","instance":3252,"id":173251,"goal":"lemma Abs_Nonneg_3252(d: real)\n ensures (if d >= 0 then d else -d) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_3253","instance":3253,"id":173252,"goal":"lemma DivMod_3253(a: int, k: int)\n requires k > 0\n ensures a == k * (a / k) + (a % k)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_3254","instance":3254,"id":173253,"goal":"lemma ModBounds_3254(y: nat, i: nat)\n requires i > 0\n ensures 0 <= y % i < i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_3255","instance":3255,"id":173254,"goal":"lemma Square_Nonneg_3255(a: real)\n ensures a * a >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_3256","instance":3256,"id":173255,"goal":"lemma AddComm_3256(a: int, j: int)\n ensures a + j == j + a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_3257","instance":3257,"id":173256,"goal":"lemma AddAssoc_3257(d: nat, m: nat, a: nat)\n ensures (d + m) + a == d + (m + a)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_3258","instance":3258,"id":173257,"goal":"lemma MulComm_3258(b: real, y: real)\n ensures b * y == y * b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_3259","instance":3259,"id":173258,"goal":"lemma MulAssoc_3259(y: int, b: int, k: int)\n ensures (y * b) * k == y * (b * k)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_3260","instance":3260,"id":173259,"goal":"lemma Distrib_3260(x: nat, n: nat, c: nat)\n ensures x * (n + c) == x * n + x * c\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_3261","instance":3261,"id":173260,"goal":"lemma AddZero_3261(y: real)\n ensures y + 0 == y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_3262","instance":3262,"id":173261,"goal":"lemma MulOne_3262(j: int)\n ensures j * 1 == j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_3263","instance":3263,"id":173262,"goal":"lemma MulZero_3263(j: nat)\n ensures j * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_3264","instance":3264,"id":173263,"goal":"lemma LeRefl_3264(d: real)\n ensures d <= d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_3265","instance":3265,"id":173264,"goal":"lemma LeTrans_3265(y: int, x: int, b: int)\n requires y <= x && x <= b\n ensures y <= b\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_3266","instance":3266,"id":173265,"goal":"lemma AddMono_3266(b: nat, c: nat, d: nat)\n requires b <= c\n ensures b + d <= c + d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_3267","instance":3267,"id":173266,"goal":"lemma Abs_Nonneg_3267(b: real)\n ensures (if b >= 0 then b else -b) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_3268","instance":3268,"id":173267,"goal":"lemma DivMod_3268(i: int, y: int)\n requires y > 0\n ensures i == y * (i / y) + (i % y)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_3269","instance":3269,"id":173268,"goal":"lemma ModBounds_3269(d: nat, n: nat)\n requires n > 0\n ensures 0 <= d % n < n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_3270","instance":3270,"id":173269,"goal":"lemma Square_Nonneg_3270(n: real)\n ensures n * n >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_3271","instance":3271,"id":173270,"goal":"lemma AddComm_3271(n: int, x: int)\n ensures n + x == x + n\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_3272","instance":3272,"id":173271,"goal":"lemma AddAssoc_3272(i: nat, n: nat, m: nat)\n ensures (i + n) + m == i + (n + m)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_3273","instance":3273,"id":173272,"goal":"lemma MulComm_3273(k: real, z: real)\n ensures k * z == z * k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_3274","instance":3274,"id":173273,"goal":"lemma MulAssoc_3274(b: int, k: int, y: int)\n ensures (b * k) * y == b * (k * y)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_3275","instance":3275,"id":173274,"goal":"lemma Distrib_3275(c: nat, n: nat, y: nat)\n ensures c * (n + y) == c * n + c * y\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_3276","instance":3276,"id":173275,"goal":"lemma AddZero_3276(d: real)\n ensures d + 0 == d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_3277","instance":3277,"id":173276,"goal":"lemma MulOne_3277(c: int)\n ensures c * 1 == c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_3278","instance":3278,"id":173277,"goal":"lemma MulZero_3278(x: nat)\n ensures x * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_3279","instance":3279,"id":173278,"goal":"lemma LeRefl_3279(a: real)\n ensures a <= a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_3280","instance":3280,"id":173279,"goal":"lemma LeTrans_3280(a: int, y: int, i: int)\n requires a <= y && y <= i\n ensures a <= i\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_3281","instance":3281,"id":173280,"goal":"lemma AddMono_3281(z: nat, m: nat, j: nat)\n requires z <= m\n ensures z + j <= m + j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_3282","instance":3282,"id":173281,"goal":"lemma Abs_Nonneg_3282(d: real)\n ensures (if d >= 0 then d else -d) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_3283","instance":3283,"id":173282,"goal":"lemma DivMod_3283(c: int, i: int)\n requires i > 0\n ensures c == i * (c / i) + (c % i)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_3284","instance":3284,"id":173283,"goal":"lemma ModBounds_3284(k: nat, a: nat)\n requires a > 0\n ensures 0 <= k % a < a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_3285","instance":3285,"id":173284,"goal":"lemma Square_Nonneg_3285(j: real)\n ensures j * j >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_3286","instance":3286,"id":173285,"goal":"lemma AddComm_3286(a: int, i: int)\n ensures a + i == i + a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_3287","instance":3287,"id":173286,"goal":"lemma AddAssoc_3287(j: nat, z: nat, k: nat)\n ensures (j + z) + k == j + (z + k)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_3288","instance":3288,"id":173287,"goal":"lemma MulComm_3288(j: real, y: real)\n ensures j * y == y * j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_3289","instance":3289,"id":173288,"goal":"lemma MulAssoc_3289(k: int, d: int, n: int)\n ensures (k * d) * n == k * (d * n)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_3290","instance":3290,"id":173289,"goal":"lemma Distrib_3290(i: nat, x: nat, c: nat)\n ensures i * (x + c) == i * x + i * c\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_3291","instance":3291,"id":173290,"goal":"lemma AddZero_3291(n: real)\n ensures n + 0 == n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_3292","instance":3292,"id":173291,"goal":"lemma MulOne_3292(j: int)\n ensures j * 1 == j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_3293","instance":3293,"id":173292,"goal":"lemma MulZero_3293(k: nat)\n ensures k * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_3294","instance":3294,"id":173293,"goal":"lemma LeRefl_3294(b: real)\n ensures b <= b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_3295","instance":3295,"id":173294,"goal":"lemma LeTrans_3295(m: int, z: int, x: int)\n requires m <= z && z <= x\n ensures m <= x\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_3296","instance":3296,"id":173295,"goal":"lemma AddMono_3296(n: nat, d: nat, c: nat)\n requires n <= d\n ensures n + c <= d + c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_3297","instance":3297,"id":173296,"goal":"lemma Abs_Nonneg_3297(a: real)\n ensures (if a >= 0 then a else -a) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_3298","instance":3298,"id":173297,"goal":"lemma DivMod_3298(c: int, z: int)\n requires z > 0\n ensures c == z * (c / z) + (c % z)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_3299","instance":3299,"id":173298,"goal":"lemma ModBounds_3299(n: nat, c: nat)\n requires c > 0\n ensures 0 <= n % c < c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_3300","instance":3300,"id":173299,"goal":"lemma Square_Nonneg_3300(a: real)\n ensures a * a >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_3301","instance":3301,"id":173300,"goal":"lemma AddComm_3301(c: int, n: int)\n ensures c + n == n + c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_3302","instance":3302,"id":173301,"goal":"lemma AddAssoc_3302(n: nat, x: nat, d: nat)\n ensures (n + x) + d == n + (x + d)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_3303","instance":3303,"id":173302,"goal":"lemma MulComm_3303(a: real, m: real)\n ensures a * m == m * a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_3304","instance":3304,"id":173303,"goal":"lemma MulAssoc_3304(b: int, k: int, y: int)\n ensures (b * k) * y == b * (k * y)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_3305","instance":3305,"id":173304,"goal":"lemma Distrib_3305(k: nat, c: nat, n: nat)\n ensures k * (c + n) == k * c + k * n\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_3306","instance":3306,"id":173305,"goal":"lemma AddZero_3306(x: real)\n ensures x + 0 == x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_3307","instance":3307,"id":173306,"goal":"lemma MulOne_3307(j: int)\n ensures j * 1 == j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_3308","instance":3308,"id":173307,"goal":"lemma MulZero_3308(a: nat)\n ensures a * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_3309","instance":3309,"id":173308,"goal":"lemma LeRefl_3309(i: real)\n ensures i <= i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_3310","instance":3310,"id":173309,"goal":"lemma LeTrans_3310(x: int, m: int, n: int)\n requires x <= m && m <= n\n ensures x <= n\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_3311","instance":3311,"id":173310,"goal":"lemma AddMono_3311(d: nat, j: nat, z: nat)\n requires d <= j\n ensures d + z <= j + z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_3312","instance":3312,"id":173311,"goal":"lemma Abs_Nonneg_3312(y: real)\n ensures (if y >= 0 then y else -y) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_3313","instance":3313,"id":173312,"goal":"lemma DivMod_3313(d: int, k: int)\n requires k > 0\n ensures d == k * (d / k) + (d % k)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_3314","instance":3314,"id":173313,"goal":"lemma ModBounds_3314(b: nat, a: nat)\n requires a > 0\n ensures 0 <= b % a < a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_3315","instance":3315,"id":173314,"goal":"lemma Square_Nonneg_3315(a: real)\n ensures a * a >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_3316","instance":3316,"id":173315,"goal":"lemma AddComm_3316(c: int, n: int)\n ensures c + n == n + c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_3317","instance":3317,"id":173316,"goal":"lemma AddAssoc_3317(j: nat, k: nat, b: nat)\n ensures (j + k) + b == j + (k + b)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_3318","instance":3318,"id":173317,"goal":"lemma MulComm_3318(b: real, z: real)\n ensures b * z == z * b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_3319","instance":3319,"id":173318,"goal":"lemma MulAssoc_3319(a: int, j: int, d: int)\n ensures (a * j) * d == a * (j * d)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_3320","instance":3320,"id":173319,"goal":"lemma Distrib_3320(a: nat, k: nat, y: nat)\n ensures a * (k + y) == a * k + a * y\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_3321","instance":3321,"id":173320,"goal":"lemma AddZero_3321(y: real)\n ensures y + 0 == y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_3322","instance":3322,"id":173321,"goal":"lemma MulOne_3322(m: int)\n ensures m * 1 == m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_3323","instance":3323,"id":173322,"goal":"lemma MulZero_3323(x: nat)\n ensures x * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_3324","instance":3324,"id":173323,"goal":"lemma LeRefl_3324(i: real)\n ensures i <= i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_3325","instance":3325,"id":173324,"goal":"lemma LeTrans_3325(y: int, z: int, b: int)\n requires y <= z && z <= b\n ensures y <= b\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_3326","instance":3326,"id":173325,"goal":"lemma AddMono_3326(j: nat, m: nat, c: nat)\n requires j <= m\n ensures j + c <= m + c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_3327","instance":3327,"id":173326,"goal":"lemma Abs_Nonneg_3327(m: real)\n ensures (if m >= 0 then m else -m) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_3328","instance":3328,"id":173327,"goal":"lemma DivMod_3328(b: int, c: int)\n requires c > 0\n ensures b == c * (b / c) + (b % c)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_3329","instance":3329,"id":173328,"goal":"lemma ModBounds_3329(n: nat, a: nat)\n requires a > 0\n ensures 0 <= n % a < a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_3330","instance":3330,"id":173329,"goal":"lemma Square_Nonneg_3330(j: real)\n ensures j * j >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_3331","instance":3331,"id":173330,"goal":"lemma AddComm_3331(x: int, i: int)\n ensures x + i == i + x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_3332","instance":3332,"id":173331,"goal":"lemma AddAssoc_3332(d: nat, c: nat, x: nat)\n ensures (d + c) + x == d + (c + x)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_3333","instance":3333,"id":173332,"goal":"lemma MulComm_3333(k: real, x: real)\n ensures k * x == x * k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_3334","instance":3334,"id":173333,"goal":"lemma MulAssoc_3334(n: int, k: int, c: int)\n ensures (n * k) * c == n * (k * c)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_3335","instance":3335,"id":173334,"goal":"lemma Distrib_3335(n: nat, d: nat, j: nat)\n ensures n * (d + j) == n * d + n * j\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_3336","instance":3336,"id":173335,"goal":"lemma AddZero_3336(a: real)\n ensures a + 0 == a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_3337","instance":3337,"id":173336,"goal":"lemma MulOne_3337(a: int)\n ensures a * 1 == a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_3338","instance":3338,"id":173337,"goal":"lemma MulZero_3338(a: nat)\n ensures a * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_3339","instance":3339,"id":173338,"goal":"lemma LeRefl_3339(x: real)\n ensures x <= x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_3340","instance":3340,"id":173339,"goal":"lemma LeTrans_3340(d: int, m: int, y: int)\n requires d <= m && m <= y\n ensures d <= y\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_3341","instance":3341,"id":173340,"goal":"lemma AddMono_3341(y: nat, z: nat, j: nat)\n requires y <= z\n ensures y + j <= z + j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_3342","instance":3342,"id":173341,"goal":"lemma Abs_Nonneg_3342(n: real)\n ensures (if n >= 0 then n else -n) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_3343","instance":3343,"id":173342,"goal":"lemma DivMod_3343(b: int, j: int)\n requires j > 0\n ensures b == j * (b / j) + (b % j)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_3344","instance":3344,"id":173343,"goal":"lemma ModBounds_3344(k: nat, d: nat)\n requires d > 0\n ensures 0 <= k % d < d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_3345","instance":3345,"id":173344,"goal":"lemma Square_Nonneg_3345(a: real)\n ensures a * a >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_3346","instance":3346,"id":173345,"goal":"lemma AddComm_3346(i: int, y: int)\n ensures i + y == y + i\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_3347","instance":3347,"id":173346,"goal":"lemma AddAssoc_3347(y: nat, i: nat, z: nat)\n ensures (y + i) + z == y + (i + z)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_3348","instance":3348,"id":173347,"goal":"lemma MulComm_3348(j: real, z: real)\n ensures j * z == z * j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_3349","instance":3349,"id":173348,"goal":"lemma MulAssoc_3349(y: int, i: int, x: int)\n ensures (y * i) * x == y * (i * x)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_3350","instance":3350,"id":173349,"goal":"lemma Distrib_3350(a: nat, d: nat, i: nat)\n ensures a * (d + i) == a * d + a * i\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_3351","instance":3351,"id":173350,"goal":"lemma AddZero_3351(i: real)\n ensures i + 0 == i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_3352","instance":3352,"id":173351,"goal":"lemma MulOne_3352(k: int)\n ensures k * 1 == k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_3353","instance":3353,"id":173352,"goal":"lemma MulZero_3353(m: nat)\n ensures m * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_3354","instance":3354,"id":173353,"goal":"lemma LeRefl_3354(y: real)\n ensures y <= y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_3355","instance":3355,"id":173354,"goal":"lemma LeTrans_3355(x: int, c: int, n: int)\n requires x <= c && c <= n\n ensures x <= n\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_3356","instance":3356,"id":173355,"goal":"lemma AddMono_3356(y: nat, j: nat, c: nat)\n requires y <= j\n ensures y + c <= j + c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_3357","instance":3357,"id":173356,"goal":"lemma Abs_Nonneg_3357(c: real)\n ensures (if c >= 0 then c else -c) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_3358","instance":3358,"id":173357,"goal":"lemma DivMod_3358(z: int, i: int)\n requires i > 0\n ensures z == i * (z / i) + (z % i)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_3359","instance":3359,"id":173358,"goal":"lemma ModBounds_3359(y: nat, a: nat)\n requires a > 0\n ensures 0 <= y % a < a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_3360","instance":3360,"id":173359,"goal":"lemma Square_Nonneg_3360(k: real)\n ensures k * k >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_3361","instance":3361,"id":173360,"goal":"lemma AddComm_3361(b: int, m: int)\n ensures b + m == m + b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_3362","instance":3362,"id":173361,"goal":"lemma AddAssoc_3362(c: nat, d: nat, x: nat)\n ensures (c + d) + x == c + (d + x)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_3363","instance":3363,"id":173362,"goal":"lemma MulComm_3363(z: real, y: real)\n ensures z * y == y * z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_3364","instance":3364,"id":173363,"goal":"lemma MulAssoc_3364(i: int, c: int, k: int)\n ensures (i * c) * k == i * (c * k)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_3365","instance":3365,"id":173364,"goal":"lemma Distrib_3365(c: nat, n: nat, i: nat)\n ensures c * (n + i) == c * n + c * i\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_3366","instance":3366,"id":173365,"goal":"lemma AddZero_3366(k: real)\n ensures k + 0 == k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_3367","instance":3367,"id":173366,"goal":"lemma MulOne_3367(b: int)\n ensures b * 1 == b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_3368","instance":3368,"id":173367,"goal":"lemma MulZero_3368(z: nat)\n ensures z * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_3369","instance":3369,"id":173368,"goal":"lemma LeRefl_3369(c: real)\n ensures c <= c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_3370","instance":3370,"id":173369,"goal":"lemma LeTrans_3370(y: int, i: int, m: int)\n requires y <= i && i <= m\n ensures y <= m\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_3371","instance":3371,"id":173370,"goal":"lemma AddMono_3371(k: nat, m: nat, d: nat)\n requires k <= m\n ensures k + d <= m + d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_3372","instance":3372,"id":173371,"goal":"lemma Abs_Nonneg_3372(c: real)\n ensures (if c >= 0 then c else -c) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_3373","instance":3373,"id":173372,"goal":"lemma DivMod_3373(z: int, x: int)\n requires x > 0\n ensures z == x * (z / x) + (z % x)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_3374","instance":3374,"id":173373,"goal":"lemma ModBounds_3374(i: nat, a: nat)\n requires a > 0\n ensures 0 <= i % a < a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_3375","instance":3375,"id":173374,"goal":"lemma Square_Nonneg_3375(c: real)\n ensures c * c >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_3376","instance":3376,"id":173375,"goal":"lemma AddComm_3376(c: int, a: int)\n ensures c + a == a + c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_3377","instance":3377,"id":173376,"goal":"lemma AddAssoc_3377(m: nat, k: nat, x: nat)\n ensures (m + k) + x == m + (k + x)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_3378","instance":3378,"id":173377,"goal":"lemma MulComm_3378(n: real, j: real)\n ensures n * j == j * n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_3379","instance":3379,"id":173378,"goal":"lemma MulAssoc_3379(m: int, j: int, b: int)\n ensures (m * j) * b == m * (j * b)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_3380","instance":3380,"id":173379,"goal":"lemma Distrib_3380(j: nat, y: nat, d: nat)\n ensures j * (y + d) == j * y + j * d\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_3381","instance":3381,"id":173380,"goal":"lemma AddZero_3381(c: real)\n ensures c + 0 == c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_3382","instance":3382,"id":173381,"goal":"lemma MulOne_3382(c: int)\n ensures c * 1 == c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_3383","instance":3383,"id":173382,"goal":"lemma MulZero_3383(c: nat)\n ensures c * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_3384","instance":3384,"id":173383,"goal":"lemma LeRefl_3384(x: real)\n ensures x <= x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_3385","instance":3385,"id":173384,"goal":"lemma LeTrans_3385(x: int, i: int, z: int)\n requires x <= i && i <= z\n ensures x <= z\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_3386","instance":3386,"id":173385,"goal":"lemma AddMono_3386(i: nat, j: nat, n: nat)\n requires i <= j\n ensures i + n <= j + n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_3387","instance":3387,"id":173386,"goal":"lemma Abs_Nonneg_3387(n: real)\n ensures (if n >= 0 then n else -n) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_3388","instance":3388,"id":173387,"goal":"lemma DivMod_3388(b: int, y: int)\n requires y > 0\n ensures b == y * (b / y) + (b % y)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_3389","instance":3389,"id":173388,"goal":"lemma ModBounds_3389(k: nat, z: nat)\n requires z > 0\n ensures 0 <= k % z < z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_3390","instance":3390,"id":173389,"goal":"lemma Square_Nonneg_3390(z: real)\n ensures z * z >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_3391","instance":3391,"id":173390,"goal":"lemma AddComm_3391(i: int, z: int)\n ensures i + z == z + i\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_3392","instance":3392,"id":173391,"goal":"lemma AddAssoc_3392(m: nat, n: nat, b: nat)\n ensures (m + n) + b == m + (n + b)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_3393","instance":3393,"id":173392,"goal":"lemma MulComm_3393(k: real, d: real)\n ensures k * d == d * k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_3394","instance":3394,"id":173393,"goal":"lemma MulAssoc_3394(n: int, m: int, z: int)\n ensures (n * m) * z == n * (m * z)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_3395","instance":3395,"id":173394,"goal":"lemma Distrib_3395(j: nat, n: nat, b: nat)\n ensures j * (n + b) == j * n + j * b\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_3396","instance":3396,"id":173395,"goal":"lemma AddZero_3396(x: real)\n ensures x + 0 == x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_3397","instance":3397,"id":173396,"goal":"lemma MulOne_3397(n: int)\n ensures n * 1 == n\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_3398","instance":3398,"id":173397,"goal":"lemma MulZero_3398(a: nat)\n ensures a * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_3399","instance":3399,"id":173398,"goal":"lemma LeRefl_3399(x: real)\n ensures x <= x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_3400","instance":3400,"id":173399,"goal":"lemma LeTrans_3400(z: int, x: int, n: int)\n requires z <= x && x <= n\n ensures z <= n\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_3401","instance":3401,"id":173400,"goal":"lemma AddMono_3401(a: nat, i: nat, j: nat)\n requires a <= i\n ensures a + j <= i + j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_3402","instance":3402,"id":173401,"goal":"lemma Abs_Nonneg_3402(m: real)\n ensures (if m >= 0 then m else -m) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_3403","instance":3403,"id":173402,"goal":"lemma DivMod_3403(y: int, a: int)\n requires a > 0\n ensures y == a * (y / a) + (y % a)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_3404","instance":3404,"id":173403,"goal":"lemma ModBounds_3404(z: nat, j: nat)\n requires j > 0\n ensures 0 <= z % j < j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_3405","instance":3405,"id":173404,"goal":"lemma Square_Nonneg_3405(z: real)\n ensures z * z >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_3406","instance":3406,"id":173405,"goal":"lemma AddComm_3406(z: int, x: int)\n ensures z + x == x + z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_3407","instance":3407,"id":173406,"goal":"lemma AddAssoc_3407(y: nat, x: nat, i: nat)\n ensures (y + x) + i == y + (x + i)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_3408","instance":3408,"id":173407,"goal":"lemma MulComm_3408(m: real, x: real)\n ensures m * x == x * m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_3409","instance":3409,"id":173408,"goal":"lemma MulAssoc_3409(k: int, x: int, z: int)\n ensures (k * x) * z == k * (x * z)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_3410","instance":3410,"id":173409,"goal":"lemma Distrib_3410(b: nat, n: nat, k: nat)\n ensures b * (n + k) == b * n + b * k\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_3411","instance":3411,"id":173410,"goal":"lemma AddZero_3411(k: real)\n ensures k + 0 == k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_3412","instance":3412,"id":173411,"goal":"lemma MulOne_3412(z: int)\n ensures z * 1 == z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_3413","instance":3413,"id":173412,"goal":"lemma MulZero_3413(a: nat)\n ensures a * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_3414","instance":3414,"id":173413,"goal":"lemma LeRefl_3414(z: real)\n ensures z <= z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_3415","instance":3415,"id":173414,"goal":"lemma LeTrans_3415(j: int, n: int, d: int)\n requires j <= n && n <= d\n ensures j <= d\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_3416","instance":3416,"id":173415,"goal":"lemma AddMono_3416(m: nat, i: nat, k: nat)\n requires m <= i\n ensures m + k <= i + k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_3417","instance":3417,"id":173416,"goal":"lemma Abs_Nonneg_3417(y: real)\n ensures (if y >= 0 then y else -y) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_3418","instance":3418,"id":173417,"goal":"lemma DivMod_3418(y: int, m: int)\n requires m > 0\n ensures y == m * (y / m) + (y % m)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_3419","instance":3419,"id":173418,"goal":"lemma ModBounds_3419(j: nat, x: nat)\n requires x > 0\n ensures 0 <= j % x < x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_3420","instance":3420,"id":173419,"goal":"lemma Square_Nonneg_3420(x: real)\n ensures x * x >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_3421","instance":3421,"id":173420,"goal":"lemma AddComm_3421(b: int, j: int)\n ensures b + j == j + b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_3422","instance":3422,"id":173421,"goal":"lemma AddAssoc_3422(z: nat, k: nat, d: nat)\n ensures (z + k) + d == z + (k + d)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_3423","instance":3423,"id":173422,"goal":"lemma MulComm_3423(k: real, c: real)\n ensures k * c == c * k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_3424","instance":3424,"id":173423,"goal":"lemma MulAssoc_3424(x: int, i: int, z: int)\n ensures (x * i) * z == x * (i * z)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_3425","instance":3425,"id":173424,"goal":"lemma Distrib_3425(i: nat, z: nat, j: nat)\n ensures i * (z + j) == i * z + i * j\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_3426","instance":3426,"id":173425,"goal":"lemma AddZero_3426(c: real)\n ensures c + 0 == c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_3427","instance":3427,"id":173426,"goal":"lemma MulOne_3427(y: int)\n ensures y * 1 == y\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_3428","instance":3428,"id":173427,"goal":"lemma MulZero_3428(b: nat)\n ensures b * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_3429","instance":3429,"id":173428,"goal":"lemma LeRefl_3429(y: real)\n ensures y <= y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_3430","instance":3430,"id":173429,"goal":"lemma LeTrans_3430(d: int, x: int, z: int)\n requires d <= x && x <= z\n ensures d <= z\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_3431","instance":3431,"id":173430,"goal":"lemma AddMono_3431(b: nat, n: nat, i: nat)\n requires b <= n\n ensures b + i <= n + i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_3432","instance":3432,"id":173431,"goal":"lemma Abs_Nonneg_3432(i: real)\n ensures (if i >= 0 then i else -i) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_3433","instance":3433,"id":173432,"goal":"lemma DivMod_3433(z: int, a: int)\n requires a > 0\n ensures z == a * (z / a) + (z % a)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_3434","instance":3434,"id":173433,"goal":"lemma ModBounds_3434(n: nat, c: nat)\n requires c > 0\n ensures 0 <= n % c < c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_3435","instance":3435,"id":173434,"goal":"lemma Square_Nonneg_3435(a: real)\n ensures a * a >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_3436","instance":3436,"id":173435,"goal":"lemma AddComm_3436(j: int, a: int)\n ensures j + a == a + j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_3437","instance":3437,"id":173436,"goal":"lemma AddAssoc_3437(d: nat, k: nat, n: nat)\n ensures (d + k) + n == d + (k + n)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_3438","instance":3438,"id":173437,"goal":"lemma MulComm_3438(m: real, z: real)\n ensures m * z == z * m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_3439","instance":3439,"id":173438,"goal":"lemma MulAssoc_3439(j: int, i: int, y: int)\n ensures (j * i) * y == j * (i * y)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_3440","instance":3440,"id":173439,"goal":"lemma Distrib_3440(x: nat, a: nat, k: nat)\n ensures x * (a + k) == x * a + x * k\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_3441","instance":3441,"id":173440,"goal":"lemma AddZero_3441(x: real)\n ensures x + 0 == x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_3442","instance":3442,"id":173441,"goal":"lemma MulOne_3442(k: int)\n ensures k * 1 == k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_3443","instance":3443,"id":173442,"goal":"lemma MulZero_3443(b: nat)\n ensures b * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_3444","instance":3444,"id":173443,"goal":"lemma LeRefl_3444(d: real)\n ensures d <= d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_3445","instance":3445,"id":173444,"goal":"lemma LeTrans_3445(x: int, z: int, n: int)\n requires x <= z && z <= n\n ensures x <= n\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_3446","instance":3446,"id":173445,"goal":"lemma AddMono_3446(b: nat, x: nat, j: nat)\n requires b <= x\n ensures b + j <= x + j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_3447","instance":3447,"id":173446,"goal":"lemma Abs_Nonneg_3447(i: real)\n ensures (if i >= 0 then i else -i) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_3448","instance":3448,"id":173447,"goal":"lemma DivMod_3448(a: int, b: int)\n requires b > 0\n ensures a == b * (a / b) + (a % b)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_3449","instance":3449,"id":173448,"goal":"lemma ModBounds_3449(m: nat, d: nat)\n requires d > 0\n ensures 0 <= m % d < d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_3450","instance":3450,"id":173449,"goal":"lemma Square_Nonneg_3450(c: real)\n ensures c * c >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_3451","instance":3451,"id":173450,"goal":"lemma AddComm_3451(k: int, n: int)\n ensures k + n == n + k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_3452","instance":3452,"id":173451,"goal":"lemma AddAssoc_3452(j: nat, i: nat, b: nat)\n ensures (j + i) + b == j + (i + b)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_3453","instance":3453,"id":173452,"goal":"lemma MulComm_3453(i: real, a: real)\n ensures i * a == a * i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_3454","instance":3454,"id":173453,"goal":"lemma MulAssoc_3454(c: int, z: int, a: int)\n ensures (c * z) * a == c * (z * a)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_3455","instance":3455,"id":173454,"goal":"lemma Distrib_3455(x: nat, d: nat, a: nat)\n ensures x * (d + a) == x * d + x * a\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_3456","instance":3456,"id":173455,"goal":"lemma AddZero_3456(k: real)\n ensures k + 0 == k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_3457","instance":3457,"id":173456,"goal":"lemma MulOne_3457(d: int)\n ensures d * 1 == d\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_3458","instance":3458,"id":173457,"goal":"lemma MulZero_3458(m: nat)\n ensures m * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_3459","instance":3459,"id":173458,"goal":"lemma LeRefl_3459(c: real)\n ensures c <= c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_3460","instance":3460,"id":173459,"goal":"lemma LeTrans_3460(d: int, a: int, j: int)\n requires d <= a && a <= j\n ensures d <= j\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_3461","instance":3461,"id":173460,"goal":"lemma AddMono_3461(d: nat, z: nat, y: nat)\n requires d <= z\n ensures d + y <= z + y\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_3462","instance":3462,"id":173461,"goal":"lemma Abs_Nonneg_3462(z: real)\n ensures (if z >= 0 then z else -z) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_3463","instance":3463,"id":173462,"goal":"lemma DivMod_3463(j: int, a: int)\n requires a > 0\n ensures j == a * (j / a) + (j % a)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_3464","instance":3464,"id":173463,"goal":"lemma ModBounds_3464(n: nat, d: nat)\n requires d > 0\n ensures 0 <= n % d < d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_3465","instance":3465,"id":173464,"goal":"lemma Square_Nonneg_3465(j: real)\n ensures j * j >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_3466","instance":3466,"id":173465,"goal":"lemma AddComm_3466(j: int, a: int)\n ensures j + a == a + j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_3467","instance":3467,"id":173466,"goal":"lemma AddAssoc_3467(y: nat, k: nat, j: nat)\n ensures (y + k) + j == y + (k + j)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_3468","instance":3468,"id":173467,"goal":"lemma MulComm_3468(m: real, c: real)\n ensures m * c == c * m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_3469","instance":3469,"id":173468,"goal":"lemma MulAssoc_3469(b: int, y: int, d: int)\n ensures (b * y) * d == b * (y * d)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_3470","instance":3470,"id":173469,"goal":"lemma Distrib_3470(b: nat, n: nat, a: nat)\n ensures b * (n + a) == b * n + b * a\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_3471","instance":3471,"id":173470,"goal":"lemma AddZero_3471(b: real)\n ensures b + 0 == b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_3472","instance":3472,"id":173471,"goal":"lemma MulOne_3472(a: int)\n ensures a * 1 == a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_3473","instance":3473,"id":173472,"goal":"lemma MulZero_3473(y: nat)\n ensures y * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_3474","instance":3474,"id":173473,"goal":"lemma LeRefl_3474(x: real)\n ensures x <= x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_3475","instance":3475,"id":173474,"goal":"lemma LeTrans_3475(b: int, a: int, c: int)\n requires b <= a && a <= c\n ensures b <= c\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_3476","instance":3476,"id":173475,"goal":"lemma AddMono_3476(j: nat, i: nat, c: nat)\n requires j <= i\n ensures j + c <= i + c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_3477","instance":3477,"id":173476,"goal":"lemma Abs_Nonneg_3477(i: real)\n ensures (if i >= 0 then i else -i) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_3478","instance":3478,"id":173477,"goal":"lemma DivMod_3478(j: int, m: int)\n requires m > 0\n ensures j == m * (j / m) + (j % m)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_3479","instance":3479,"id":173478,"goal":"lemma ModBounds_3479(y: nat, b: nat)\n requires b > 0\n ensures 0 <= y % b < b\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_3480","instance":3480,"id":173479,"goal":"lemma Square_Nonneg_3480(j: real)\n ensures j * j >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_3481","instance":3481,"id":173480,"goal":"lemma AddComm_3481(y: int, c: int)\n ensures y + c == c + y\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_3482","instance":3482,"id":173481,"goal":"lemma AddAssoc_3482(n: nat, b: nat, j: nat)\n ensures (n + b) + j == n + (b + j)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_3483","instance":3483,"id":173482,"goal":"lemma MulComm_3483(a: real, c: real)\n ensures a * c == c * a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_3484","instance":3484,"id":173483,"goal":"lemma MulAssoc_3484(n: int, j: int, c: int)\n ensures (n * j) * c == n * (j * c)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_3485","instance":3485,"id":173484,"goal":"lemma Distrib_3485(a: nat, y: nat, m: nat)\n ensures a * (y + m) == a * y + a * m\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_3486","instance":3486,"id":173485,"goal":"lemma AddZero_3486(b: real)\n ensures b + 0 == b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_3487","instance":3487,"id":173486,"goal":"lemma MulOne_3487(d: int)\n ensures d * 1 == d\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_3488","instance":3488,"id":173487,"goal":"lemma MulZero_3488(d: nat)\n ensures d * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_3489","instance":3489,"id":173488,"goal":"lemma LeRefl_3489(c: real)\n ensures c <= c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_3490","instance":3490,"id":173489,"goal":"lemma LeTrans_3490(m: int, x: int, j: int)\n requires m <= x && x <= j\n ensures m <= j\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_3491","instance":3491,"id":173490,"goal":"lemma AddMono_3491(z: nat, k: nat, a: nat)\n requires z <= k\n ensures z + a <= k + a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_3492","instance":3492,"id":173491,"goal":"lemma Abs_Nonneg_3492(y: real)\n ensures (if y >= 0 then y else -y) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_3493","instance":3493,"id":173492,"goal":"lemma DivMod_3493(z: int, d: int)\n requires d > 0\n ensures z == d * (z / d) + (z % d)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_3494","instance":3494,"id":173493,"goal":"lemma ModBounds_3494(j: nat, x: nat)\n requires x > 0\n ensures 0 <= j % x < x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_3495","instance":3495,"id":173494,"goal":"lemma Square_Nonneg_3495(y: real)\n ensures y * y >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_3496","instance":3496,"id":173495,"goal":"lemma AddComm_3496(m: int, c: int)\n ensures m + c == c + m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_3497","instance":3497,"id":173496,"goal":"lemma AddAssoc_3497(y: nat, i: nat, m: nat)\n ensures (y + i) + m == y + (i + m)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_3498","instance":3498,"id":173497,"goal":"lemma MulComm_3498(y: real, m: real)\n ensures y * m == m * y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_3499","instance":3499,"id":173498,"goal":"lemma MulAssoc_3499(n: int, b: int, i: int)\n ensures (n * b) * i == n * (b * i)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_3500","instance":3500,"id":173499,"goal":"lemma Distrib_3500(k: nat, j: nat, c: nat)\n ensures k * (j + c) == k * j + k * c\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_3501","instance":3501,"id":173500,"goal":"lemma AddZero_3501(x: real)\n ensures x + 0 == x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_3502","instance":3502,"id":173501,"goal":"lemma MulOne_3502(a: int)\n ensures a * 1 == a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_3503","instance":3503,"id":173502,"goal":"lemma MulZero_3503(m: nat)\n ensures m * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_3504","instance":3504,"id":173503,"goal":"lemma LeRefl_3504(y: real)\n ensures y <= y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_3505","instance":3505,"id":173504,"goal":"lemma LeTrans_3505(d: int, j: int, z: int)\n requires d <= j && j <= z\n ensures d <= z\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_3506","instance":3506,"id":173505,"goal":"lemma AddMono_3506(c: nat, y: nat, n: nat)\n requires c <= y\n ensures c + n <= y + n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_3507","instance":3507,"id":173506,"goal":"lemma Abs_Nonneg_3507(c: real)\n ensures (if c >= 0 then c else -c) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_3508","instance":3508,"id":173507,"goal":"lemma DivMod_3508(k: int, i: int)\n requires i > 0\n ensures k == i * (k / i) + (k % i)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_3509","instance":3509,"id":173508,"goal":"lemma ModBounds_3509(b: nat, y: nat)\n requires y > 0\n ensures 0 <= b % y < y\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_3510","instance":3510,"id":173509,"goal":"lemma Square_Nonneg_3510(a: real)\n ensures a * a >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_3511","instance":3511,"id":173510,"goal":"lemma AddComm_3511(z: int, x: int)\n ensures z + x == x + z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_3512","instance":3512,"id":173511,"goal":"lemma AddAssoc_3512(m: nat, b: nat, a: nat)\n ensures (m + b) + a == m + (b + a)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_3513","instance":3513,"id":173512,"goal":"lemma MulComm_3513(j: real, c: real)\n ensures j * c == c * j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_3514","instance":3514,"id":173513,"goal":"lemma MulAssoc_3514(j: int, c: int, a: int)\n ensures (j * c) * a == j * (c * a)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_3515","instance":3515,"id":173514,"goal":"lemma Distrib_3515(c: nat, k: nat, x: nat)\n ensures c * (k + x) == c * k + c * x\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_3516","instance":3516,"id":173515,"goal":"lemma AddZero_3516(i: real)\n ensures i + 0 == i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_3517","instance":3517,"id":173516,"goal":"lemma MulOne_3517(c: int)\n ensures c * 1 == c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_3518","instance":3518,"id":173517,"goal":"lemma MulZero_3518(k: nat)\n ensures k * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_3519","instance":3519,"id":173518,"goal":"lemma LeRefl_3519(z: real)\n ensures z <= z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_3520","instance":3520,"id":173519,"goal":"lemma LeTrans_3520(c: int, j: int, a: int)\n requires c <= j && j <= a\n ensures c <= a\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_3521","instance":3521,"id":173520,"goal":"lemma AddMono_3521(x: nat, k: nat, y: nat)\n requires x <= k\n ensures x + y <= k + y\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_3522","instance":3522,"id":173521,"goal":"lemma Abs_Nonneg_3522(a: real)\n ensures (if a >= 0 then a else -a) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_3523","instance":3523,"id":173522,"goal":"lemma DivMod_3523(i: int, a: int)\n requires a > 0\n ensures i == a * (i / a) + (i % a)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_3524","instance":3524,"id":173523,"goal":"lemma ModBounds_3524(i: nat, k: nat)\n requires k > 0\n ensures 0 <= i % k < k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_3525","instance":3525,"id":173524,"goal":"lemma Square_Nonneg_3525(i: real)\n ensures i * i >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_3526","instance":3526,"id":173525,"goal":"lemma AddComm_3526(k: int, j: int)\n ensures k + j == j + k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_3527","instance":3527,"id":173526,"goal":"lemma AddAssoc_3527(j: nat, y: nat, x: nat)\n ensures (j + y) + x == j + (y + x)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_3528","instance":3528,"id":173527,"goal":"lemma MulComm_3528(k: real, c: real)\n ensures k * c == c * k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_3529","instance":3529,"id":173528,"goal":"lemma MulAssoc_3529(n: int, b: int, j: int)\n ensures (n * b) * j == n * (b * j)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_3530","instance":3530,"id":173529,"goal":"lemma Distrib_3530(k: nat, i: nat, y: nat)\n ensures k * (i + y) == k * i + k * y\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_3531","instance":3531,"id":173530,"goal":"lemma AddZero_3531(z: real)\n ensures z + 0 == z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_3532","instance":3532,"id":173531,"goal":"lemma MulOne_3532(d: int)\n ensures d * 1 == d\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_3533","instance":3533,"id":173532,"goal":"lemma MulZero_3533(m: nat)\n ensures m * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_3534","instance":3534,"id":173533,"goal":"lemma LeRefl_3534(i: real)\n ensures i <= i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_3535","instance":3535,"id":173534,"goal":"lemma LeTrans_3535(m: int, i: int, n: int)\n requires m <= i && i <= n\n ensures m <= n\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_3536","instance":3536,"id":173535,"goal":"lemma AddMono_3536(d: nat, y: nat, m: nat)\n requires d <= y\n ensures d + m <= y + m\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_3537","instance":3537,"id":173536,"goal":"lemma Abs_Nonneg_3537(a: real)\n ensures (if a >= 0 then a else -a) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_3538","instance":3538,"id":173537,"goal":"lemma DivMod_3538(d: int, j: int)\n requires j > 0\n ensures d == j * (d / j) + (d % j)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_3539","instance":3539,"id":173538,"goal":"lemma ModBounds_3539(k: nat, i: nat)\n requires i > 0\n ensures 0 <= k % i < i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_3540","instance":3540,"id":173539,"goal":"lemma Square_Nonneg_3540(d: real)\n ensures d * d >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_3541","instance":3541,"id":173540,"goal":"lemma AddComm_3541(c: int, m: int)\n ensures c + m == m + c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_3542","instance":3542,"id":173541,"goal":"lemma AddAssoc_3542(m: nat, c: nat, z: nat)\n ensures (m + c) + z == m + (c + z)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_3543","instance":3543,"id":173542,"goal":"lemma MulComm_3543(n: real, b: real)\n ensures n * b == b * n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_3544","instance":3544,"id":173543,"goal":"lemma MulAssoc_3544(n: int, z: int, a: int)\n ensures (n * z) * a == n * (z * a)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_3545","instance":3545,"id":173544,"goal":"lemma Distrib_3545(d: nat, n: nat, i: nat)\n ensures d * (n + i) == d * n + d * i\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_3546","instance":3546,"id":173545,"goal":"lemma AddZero_3546(m: real)\n ensures m + 0 == m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_3547","instance":3547,"id":173546,"goal":"lemma MulOne_3547(i: int)\n ensures i * 1 == i\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_3548","instance":3548,"id":173547,"goal":"lemma MulZero_3548(k: nat)\n ensures k * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_3549","instance":3549,"id":173548,"goal":"lemma LeRefl_3549(k: real)\n ensures k <= k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_3550","instance":3550,"id":173549,"goal":"lemma LeTrans_3550(z: int, y: int, i: int)\n requires z <= y && y <= i\n ensures z <= i\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_3551","instance":3551,"id":173550,"goal":"lemma AddMono_3551(m: nat, k: nat, y: nat)\n requires m <= k\n ensures m + y <= k + y\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_3552","instance":3552,"id":173551,"goal":"lemma Abs_Nonneg_3552(y: real)\n ensures (if y >= 0 then y else -y) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_3553","instance":3553,"id":173552,"goal":"lemma DivMod_3553(n: int, m: int)\n requires m > 0\n ensures n == m * (n / m) + (n % m)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_3554","instance":3554,"id":173553,"goal":"lemma ModBounds_3554(i: nat, k: nat)\n requires k > 0\n ensures 0 <= i % k < k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_3555","instance":3555,"id":173554,"goal":"lemma Square_Nonneg_3555(z: real)\n ensures z * z >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_3556","instance":3556,"id":173555,"goal":"lemma AddComm_3556(x: int, a: int)\n ensures x + a == a + x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_3557","instance":3557,"id":173556,"goal":"lemma AddAssoc_3557(c: nat, b: nat, z: nat)\n ensures (c + b) + z == c + (b + z)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_3558","instance":3558,"id":173557,"goal":"lemma MulComm_3558(x: real, y: real)\n ensures x * y == y * x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_3559","instance":3559,"id":173558,"goal":"lemma MulAssoc_3559(m: int, j: int, c: int)\n ensures (m * j) * c == m * (j * c)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_3560","instance":3560,"id":173559,"goal":"lemma Distrib_3560(m: nat, k: nat, z: nat)\n ensures m * (k + z) == m * k + m * z\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_3561","instance":3561,"id":173560,"goal":"lemma AddZero_3561(j: real)\n ensures j + 0 == j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_3562","instance":3562,"id":173561,"goal":"lemma MulOne_3562(n: int)\n ensures n * 1 == n\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_3563","instance":3563,"id":173562,"goal":"lemma MulZero_3563(c: nat)\n ensures c * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_3564","instance":3564,"id":173563,"goal":"lemma LeRefl_3564(i: real)\n ensures i <= i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_3565","instance":3565,"id":173564,"goal":"lemma LeTrans_3565(c: int, d: int, x: int)\n requires c <= d && d <= x\n ensures c <= x\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_3566","instance":3566,"id":173565,"goal":"lemma AddMono_3566(d: nat, k: nat, x: nat)\n requires d <= k\n ensures d + x <= k + x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_3567","instance":3567,"id":173566,"goal":"lemma Abs_Nonneg_3567(c: real)\n ensures (if c >= 0 then c else -c) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_3568","instance":3568,"id":173567,"goal":"lemma DivMod_3568(c: int, n: int)\n requires n > 0\n ensures c == n * (c / n) + (c % n)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_3569","instance":3569,"id":173568,"goal":"lemma ModBounds_3569(m: nat, b: nat)\n requires b > 0\n ensures 0 <= m % b < b\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_3570","instance":3570,"id":173569,"goal":"lemma Square_Nonneg_3570(x: real)\n ensures x * x >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_3571","instance":3571,"id":173570,"goal":"lemma AddComm_3571(m: int, z: int)\n ensures m + z == z + m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_3572","instance":3572,"id":173571,"goal":"lemma AddAssoc_3572(c: nat, k: nat, n: nat)\n ensures (c + k) + n == c + (k + n)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_3573","instance":3573,"id":173572,"goal":"lemma MulComm_3573(d: real, m: real)\n ensures d * m == m * d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_3574","instance":3574,"id":173573,"goal":"lemma MulAssoc_3574(b: int, m: int, z: int)\n ensures (b * m) * z == b * (m * z)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_3575","instance":3575,"id":173574,"goal":"lemma Distrib_3575(i: nat, a: nat, x: nat)\n ensures i * (a + x) == i * a + i * x\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_3576","instance":3576,"id":173575,"goal":"lemma AddZero_3576(k: real)\n ensures k + 0 == k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_3577","instance":3577,"id":173576,"goal":"lemma MulOne_3577(d: int)\n ensures d * 1 == d\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_3578","instance":3578,"id":173577,"goal":"lemma MulZero_3578(c: nat)\n ensures c * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_3579","instance":3579,"id":173578,"goal":"lemma LeRefl_3579(k: real)\n ensures k <= k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_3580","instance":3580,"id":173579,"goal":"lemma LeTrans_3580(z: int, m: int, x: int)\n requires z <= m && m <= x\n ensures z <= x\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_3581","instance":3581,"id":173580,"goal":"lemma AddMono_3581(k: nat, m: nat, c: nat)\n requires k <= m\n ensures k + c <= m + c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_3582","instance":3582,"id":173581,"goal":"lemma Abs_Nonneg_3582(i: real)\n ensures (if i >= 0 then i else -i) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_3583","instance":3583,"id":173582,"goal":"lemma DivMod_3583(y: int, b: int)\n requires b > 0\n ensures y == b * (y / b) + (y % b)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_3584","instance":3584,"id":173583,"goal":"lemma ModBounds_3584(m: nat, b: nat)\n requires b > 0\n ensures 0 <= m % b < b\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_3585","instance":3585,"id":173584,"goal":"lemma Square_Nonneg_3585(n: real)\n ensures n * n >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_3586","instance":3586,"id":173585,"goal":"lemma AddComm_3586(c: int, j: int)\n ensures c + j == j + c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_3587","instance":3587,"id":173586,"goal":"lemma AddAssoc_3587(k: nat, z: nat, j: nat)\n ensures (k + z) + j == k + (z + j)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_3588","instance":3588,"id":173587,"goal":"lemma MulComm_3588(n: real, b: real)\n ensures n * b == b * n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_3589","instance":3589,"id":173588,"goal":"lemma MulAssoc_3589(k: int, a: int, m: int)\n ensures (k * a) * m == k * (a * m)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_3590","instance":3590,"id":173589,"goal":"lemma Distrib_3590(n: nat, i: nat, x: nat)\n ensures n * (i + x) == n * i + n * x\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_3591","instance":3591,"id":173590,"goal":"lemma AddZero_3591(m: real)\n ensures m + 0 == m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_3592","instance":3592,"id":173591,"goal":"lemma MulOne_3592(m: int)\n ensures m * 1 == m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_3593","instance":3593,"id":173592,"goal":"lemma MulZero_3593(z: nat)\n ensures z * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_3594","instance":3594,"id":173593,"goal":"lemma LeRefl_3594(x: real)\n ensures x <= x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_3595","instance":3595,"id":173594,"goal":"lemma LeTrans_3595(b: int, d: int, a: int)\n requires b <= d && d <= a\n ensures b <= a\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_3596","instance":3596,"id":173595,"goal":"lemma AddMono_3596(d: nat, m: nat, y: nat)\n requires d <= m\n ensures d + y <= m + y\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_3597","instance":3597,"id":173596,"goal":"lemma Abs_Nonneg_3597(d: real)\n ensures (if d >= 0 then d else -d) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_3598","instance":3598,"id":173597,"goal":"lemma DivMod_3598(d: int, m: int)\n requires m > 0\n ensures d == m * (d / m) + (d % m)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_3599","instance":3599,"id":173598,"goal":"lemma ModBounds_3599(d: nat, x: nat)\n requires x > 0\n ensures 0 <= d % x < x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_3600","instance":3600,"id":173599,"goal":"lemma Square_Nonneg_3600(i: real)\n ensures i * i >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_3601","instance":3601,"id":173600,"goal":"lemma AddComm_3601(k: int, i: int)\n ensures k + i == i + k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_3602","instance":3602,"id":173601,"goal":"lemma AddAssoc_3602(x: nat, i: nat, z: nat)\n ensures (x + i) + z == x + (i + z)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_3603","instance":3603,"id":173602,"goal":"lemma MulComm_3603(n: real, y: real)\n ensures n * y == y * n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_3604","instance":3604,"id":173603,"goal":"lemma MulAssoc_3604(d: int, k: int, a: int)\n ensures (d * k) * a == d * (k * a)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_3605","instance":3605,"id":173604,"goal":"lemma Distrib_3605(x: nat, m: nat, z: nat)\n ensures x * (m + z) == x * m + x * z\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_3606","instance":3606,"id":173605,"goal":"lemma AddZero_3606(z: real)\n ensures z + 0 == z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_3607","instance":3607,"id":173606,"goal":"lemma MulOne_3607(z: int)\n ensures z * 1 == z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_3608","instance":3608,"id":173607,"goal":"lemma MulZero_3608(y: nat)\n ensures y * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_3609","instance":3609,"id":173608,"goal":"lemma LeRefl_3609(y: real)\n ensures y <= y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_3610","instance":3610,"id":173609,"goal":"lemma LeTrans_3610(d: int, n: int, j: int)\n requires d <= n && n <= j\n ensures d <= j\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_3611","instance":3611,"id":173610,"goal":"lemma AddMono_3611(b: nat, k: nat, a: nat)\n requires b <= k\n ensures b + a <= k + a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_3612","instance":3612,"id":173611,"goal":"lemma Abs_Nonneg_3612(i: real)\n ensures (if i >= 0 then i else -i) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_3613","instance":3613,"id":173612,"goal":"lemma DivMod_3613(x: int, a: int)\n requires a > 0\n ensures x == a * (x / a) + (x % a)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_3614","instance":3614,"id":173613,"goal":"lemma ModBounds_3614(c: nat, k: nat)\n requires k > 0\n ensures 0 <= c % k < k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_3615","instance":3615,"id":173614,"goal":"lemma Square_Nonneg_3615(z: real)\n ensures z * z >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_3616","instance":3616,"id":173615,"goal":"lemma AddComm_3616(n: int, m: int)\n ensures n + m == m + n\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_3617","instance":3617,"id":173616,"goal":"lemma AddAssoc_3617(n: nat, i: nat, y: nat)\n ensures (n + i) + y == n + (i + y)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_3618","instance":3618,"id":173617,"goal":"lemma MulComm_3618(d: real, x: real)\n ensures d * x == x * d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_3619","instance":3619,"id":173618,"goal":"lemma MulAssoc_3619(z: int, c: int, m: int)\n ensures (z * c) * m == z * (c * m)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_3620","instance":3620,"id":173619,"goal":"lemma Distrib_3620(b: nat, k: nat, m: nat)\n ensures b * (k + m) == b * k + b * m\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_3621","instance":3621,"id":173620,"goal":"lemma AddZero_3621(d: real)\n ensures d + 0 == d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_3622","instance":3622,"id":173621,"goal":"lemma MulOne_3622(z: int)\n ensures z * 1 == z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_3623","instance":3623,"id":173622,"goal":"lemma MulZero_3623(d: nat)\n ensures d * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_3624","instance":3624,"id":173623,"goal":"lemma LeRefl_3624(b: real)\n ensures b <= b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_3625","instance":3625,"id":173624,"goal":"lemma LeTrans_3625(m: int, d: int, j: int)\n requires m <= d && d <= j\n ensures m <= j\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_3626","instance":3626,"id":173625,"goal":"lemma AddMono_3626(x: nat, a: nat, k: nat)\n requires x <= a\n ensures x + k <= a + k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_3627","instance":3627,"id":173626,"goal":"lemma Abs_Nonneg_3627(a: real)\n ensures (if a >= 0 then a else -a) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_3628","instance":3628,"id":173627,"goal":"lemma DivMod_3628(a: int, y: int)\n requires y > 0\n ensures a == y * (a / y) + (a % y)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_3629","instance":3629,"id":173628,"goal":"lemma ModBounds_3629(y: nat, i: nat)\n requires i > 0\n ensures 0 <= y % i < i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_3630","instance":3630,"id":173629,"goal":"lemma Square_Nonneg_3630(m: real)\n ensures m * m >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_3631","instance":3631,"id":173630,"goal":"lemma AddComm_3631(m: int, k: int)\n ensures m + k == k + m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_3632","instance":3632,"id":173631,"goal":"lemma AddAssoc_3632(m: nat, y: nat, n: nat)\n ensures (m + y) + n == m + (y + n)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_3633","instance":3633,"id":173632,"goal":"lemma MulComm_3633(a: real, x: real)\n ensures a * x == x * a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_3634","instance":3634,"id":173633,"goal":"lemma MulAssoc_3634(i: int, n: int, c: int)\n ensures (i * n) * c == i * (n * c)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_3635","instance":3635,"id":173634,"goal":"lemma Distrib_3635(x: nat, m: nat, d: nat)\n ensures x * (m + d) == x * m + x * d\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_3636","instance":3636,"id":173635,"goal":"lemma AddZero_3636(a: real)\n ensures a + 0 == a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_3637","instance":3637,"id":173636,"goal":"lemma MulOne_3637(j: int)\n ensures j * 1 == j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_3638","instance":3638,"id":173637,"goal":"lemma MulZero_3638(m: nat)\n ensures m * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_3639","instance":3639,"id":173638,"goal":"lemma LeRefl_3639(a: real)\n ensures a <= a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_3640","instance":3640,"id":173639,"goal":"lemma LeTrans_3640(d: int, i: int, n: int)\n requires d <= i && i <= n\n ensures d <= n\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_3641","instance":3641,"id":173640,"goal":"lemma AddMono_3641(y: nat, j: nat, i: nat)\n requires y <= j\n ensures y + i <= j + i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_3642","instance":3642,"id":173641,"goal":"lemma Abs_Nonneg_3642(b: real)\n ensures (if b >= 0 then b else -b) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_3643","instance":3643,"id":173642,"goal":"lemma DivMod_3643(j: int, z: int)\n requires z > 0\n ensures j == z * (j / z) + (j % z)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_3644","instance":3644,"id":173643,"goal":"lemma ModBounds_3644(i: nat, y: nat)\n requires y > 0\n ensures 0 <= i % y < y\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_3645","instance":3645,"id":173644,"goal":"lemma Square_Nonneg_3645(m: real)\n ensures m * m >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_3646","instance":3646,"id":173645,"goal":"lemma AddComm_3646(m: int, z: int)\n ensures m + z == z + m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_3647","instance":3647,"id":173646,"goal":"lemma AddAssoc_3647(z: nat, a: nat, y: nat)\n ensures (z + a) + y == z + (a + y)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_3648","instance":3648,"id":173647,"goal":"lemma MulComm_3648(y: real, m: real)\n ensures y * m == m * y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_3649","instance":3649,"id":173648,"goal":"lemma MulAssoc_3649(x: int, i: int, n: int)\n ensures (x * i) * n == x * (i * n)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_3650","instance":3650,"id":173649,"goal":"lemma Distrib_3650(y: nat, c: nat, x: nat)\n ensures y * (c + x) == y * c + y * x\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_3651","instance":3651,"id":173650,"goal":"lemma AddZero_3651(b: real)\n ensures b + 0 == b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_3652","instance":3652,"id":173651,"goal":"lemma MulOne_3652(x: int)\n ensures x * 1 == x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_3653","instance":3653,"id":173652,"goal":"lemma MulZero_3653(k: nat)\n ensures k * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_3654","instance":3654,"id":173653,"goal":"lemma LeRefl_3654(m: real)\n ensures m <= m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_3655","instance":3655,"id":173654,"goal":"lemma LeTrans_3655(m: int, c: int, z: int)\n requires m <= c && c <= z\n ensures m <= z\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_3656","instance":3656,"id":173655,"goal":"lemma AddMono_3656(d: nat, b: nat, z: nat)\n requires d <= b\n ensures d + z <= b + z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_3657","instance":3657,"id":173656,"goal":"lemma Abs_Nonneg_3657(b: real)\n ensures (if b >= 0 then b else -b) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_3658","instance":3658,"id":173657,"goal":"lemma DivMod_3658(c: int, x: int)\n requires x > 0\n ensures c == x * (c / x) + (c % x)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_3659","instance":3659,"id":173658,"goal":"lemma ModBounds_3659(z: nat, b: nat)\n requires b > 0\n ensures 0 <= z % b < b\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_3660","instance":3660,"id":173659,"goal":"lemma Square_Nonneg_3660(y: real)\n ensures y * y >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_3661","instance":3661,"id":173660,"goal":"lemma AddComm_3661(d: int, y: int)\n ensures d + y == y + d\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_3662","instance":3662,"id":173661,"goal":"lemma AddAssoc_3662(y: nat, m: nat, b: nat)\n ensures (y + m) + b == y + (m + b)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_3663","instance":3663,"id":173662,"goal":"lemma MulComm_3663(i: real, d: real)\n ensures i * d == d * i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_3664","instance":3664,"id":173663,"goal":"lemma MulAssoc_3664(k: int, m: int, i: int)\n ensures (k * m) * i == k * (m * i)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_3665","instance":3665,"id":173664,"goal":"lemma Distrib_3665(z: nat, k: nat, x: nat)\n ensures z * (k + x) == z * k + z * x\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_3666","instance":3666,"id":173665,"goal":"lemma AddZero_3666(d: real)\n ensures d + 0 == d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_3667","instance":3667,"id":173666,"goal":"lemma MulOne_3667(m: int)\n ensures m * 1 == m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_3668","instance":3668,"id":173667,"goal":"lemma MulZero_3668(d: nat)\n ensures d * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_3669","instance":3669,"id":173668,"goal":"lemma LeRefl_3669(m: real)\n ensures m <= m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_3670","instance":3670,"id":173669,"goal":"lemma LeTrans_3670(a: int, z: int, n: int)\n requires a <= z && z <= n\n ensures a <= n\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_3671","instance":3671,"id":173670,"goal":"lemma AddMono_3671(d: nat, m: nat, k: nat)\n requires d <= m\n ensures d + k <= m + k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_3672","instance":3672,"id":173671,"goal":"lemma Abs_Nonneg_3672(c: real)\n ensures (if c >= 0 then c else -c) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_3673","instance":3673,"id":173672,"goal":"lemma DivMod_3673(k: int, i: int)\n requires i > 0\n ensures k == i * (k / i) + (k % i)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_3674","instance":3674,"id":173673,"goal":"lemma ModBounds_3674(b: nat, z: nat)\n requires z > 0\n ensures 0 <= b % z < z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_3675","instance":3675,"id":173674,"goal":"lemma Square_Nonneg_3675(d: real)\n ensures d * d >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_3676","instance":3676,"id":173675,"goal":"lemma AddComm_3676(x: int, d: int)\n ensures x + d == d + x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_3677","instance":3677,"id":173676,"goal":"lemma AddAssoc_3677(y: nat, i: nat, b: nat)\n ensures (y + i) + b == y + (i + b)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_3678","instance":3678,"id":173677,"goal":"lemma MulComm_3678(z: real, a: real)\n ensures z * a == a * z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_3679","instance":3679,"id":173678,"goal":"lemma MulAssoc_3679(k: int, m: int, d: int)\n ensures (k * m) * d == k * (m * d)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_3680","instance":3680,"id":173679,"goal":"lemma Distrib_3680(x: nat, n: nat, k: nat)\n ensures x * (n + k) == x * n + x * k\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_3681","instance":3681,"id":173680,"goal":"lemma AddZero_3681(y: real)\n ensures y + 0 == y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_3682","instance":3682,"id":173681,"goal":"lemma MulOne_3682(j: int)\n ensures j * 1 == j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_3683","instance":3683,"id":173682,"goal":"lemma MulZero_3683(x: nat)\n ensures x * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_3684","instance":3684,"id":173683,"goal":"lemma LeRefl_3684(a: real)\n ensures a <= a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_3685","instance":3685,"id":173684,"goal":"lemma LeTrans_3685(d: int, k: int, m: int)\n requires d <= k && k <= m\n ensures d <= m\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_3686","instance":3686,"id":173685,"goal":"lemma AddMono_3686(k: nat, d: nat, x: nat)\n requires k <= d\n ensures k + x <= d + x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_3687","instance":3687,"id":173686,"goal":"lemma Abs_Nonneg_3687(a: real)\n ensures (if a >= 0 then a else -a) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_3688","instance":3688,"id":173687,"goal":"lemma DivMod_3688(b: int, y: int)\n requires y > 0\n ensures b == y * (b / y) + (b % y)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_3689","instance":3689,"id":173688,"goal":"lemma ModBounds_3689(k: nat, m: nat)\n requires m > 0\n ensures 0 <= k % m < m\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_3690","instance":3690,"id":173689,"goal":"lemma Square_Nonneg_3690(c: real)\n ensures c * c >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_3691","instance":3691,"id":173690,"goal":"lemma AddComm_3691(m: int, a: int)\n ensures m + a == a + m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_3692","instance":3692,"id":173691,"goal":"lemma AddAssoc_3692(a: nat, c: nat, i: nat)\n ensures (a + c) + i == a + (c + i)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_3693","instance":3693,"id":173692,"goal":"lemma MulComm_3693(d: real, a: real)\n ensures d * a == a * d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_3694","instance":3694,"id":173693,"goal":"lemma MulAssoc_3694(c: int, a: int, x: int)\n ensures (c * a) * x == c * (a * x)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_3695","instance":3695,"id":173694,"goal":"lemma Distrib_3695(m: nat, n: nat, y: nat)\n ensures m * (n + y) == m * n + m * y\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_3696","instance":3696,"id":173695,"goal":"lemma AddZero_3696(z: real)\n ensures z + 0 == z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_3697","instance":3697,"id":173696,"goal":"lemma MulOne_3697(i: int)\n ensures i * 1 == i\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_3698","instance":3698,"id":173697,"goal":"lemma MulZero_3698(m: nat)\n ensures m * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_3699","instance":3699,"id":173698,"goal":"lemma LeRefl_3699(x: real)\n ensures x <= x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_3700","instance":3700,"id":173699,"goal":"lemma LeTrans_3700(x: int, m: int, a: int)\n requires x <= m && m <= a\n ensures x <= a\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_3701","instance":3701,"id":173700,"goal":"lemma AddMono_3701(n: nat, z: nat, j: nat)\n requires n <= z\n ensures n + j <= z + j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_3702","instance":3702,"id":173701,"goal":"lemma Abs_Nonneg_3702(y: real)\n ensures (if y >= 0 then y else -y) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_3703","instance":3703,"id":173702,"goal":"lemma DivMod_3703(c: int, b: int)\n requires b > 0\n ensures c == b * (c / b) + (c % b)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_3704","instance":3704,"id":173703,"goal":"lemma ModBounds_3704(k: nat, z: nat)\n requires z > 0\n ensures 0 <= k % z < z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_3705","instance":3705,"id":173704,"goal":"lemma Square_Nonneg_3705(n: real)\n ensures n * n >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_3706","instance":3706,"id":173705,"goal":"lemma AddComm_3706(a: int, n: int)\n ensures a + n == n + a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_3707","instance":3707,"id":173706,"goal":"lemma AddAssoc_3707(d: nat, c: nat, a: nat)\n ensures (d + c) + a == d + (c + a)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_3708","instance":3708,"id":173707,"goal":"lemma MulComm_3708(k: real, n: real)\n ensures k * n == n * k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_3709","instance":3709,"id":173708,"goal":"lemma MulAssoc_3709(z: int, x: int, y: int)\n ensures (z * x) * y == z * (x * y)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_3710","instance":3710,"id":173709,"goal":"lemma Distrib_3710(n: nat, a: nat, z: nat)\n ensures n * (a + z) == n * a + n * z\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_3711","instance":3711,"id":173710,"goal":"lemma AddZero_3711(m: real)\n ensures m + 0 == m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_3712","instance":3712,"id":173711,"goal":"lemma MulOne_3712(b: int)\n ensures b * 1 == b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_3713","instance":3713,"id":173712,"goal":"lemma MulZero_3713(b: nat)\n ensures b * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_3714","instance":3714,"id":173713,"goal":"lemma LeRefl_3714(d: real)\n ensures d <= d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_3715","instance":3715,"id":173714,"goal":"lemma LeTrans_3715(m: int, b: int, i: int)\n requires m <= b && b <= i\n ensures m <= i\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_3716","instance":3716,"id":173715,"goal":"lemma AddMono_3716(i: nat, b: nat, n: nat)\n requires i <= b\n ensures i + n <= b + n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_3717","instance":3717,"id":173716,"goal":"lemma Abs_Nonneg_3717(d: real)\n ensures (if d >= 0 then d else -d) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_3718","instance":3718,"id":173717,"goal":"lemma DivMod_3718(z: int, n: int)\n requires n > 0\n ensures z == n * (z / n) + (z % n)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_3719","instance":3719,"id":173718,"goal":"lemma ModBounds_3719(m: nat, b: nat)\n requires b > 0\n ensures 0 <= m % b < b\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_3720","instance":3720,"id":173719,"goal":"lemma Square_Nonneg_3720(m: real)\n ensures m * m >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_3721","instance":3721,"id":173720,"goal":"lemma AddComm_3721(c: int, i: int)\n ensures c + i == i + c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_3722","instance":3722,"id":173721,"goal":"lemma AddAssoc_3722(c: nat, n: nat, a: nat)\n ensures (c + n) + a == c + (n + a)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_3723","instance":3723,"id":173722,"goal":"lemma MulComm_3723(i: real, d: real)\n ensures i * d == d * i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_3724","instance":3724,"id":173723,"goal":"lemma MulAssoc_3724(j: int, c: int, x: int)\n ensures (j * c) * x == j * (c * x)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_3725","instance":3725,"id":173724,"goal":"lemma Distrib_3725(c: nat, n: nat, z: nat)\n ensures c * (n + z) == c * n + c * z\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_3726","instance":3726,"id":173725,"goal":"lemma AddZero_3726(x: real)\n ensures x + 0 == x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_3727","instance":3727,"id":173726,"goal":"lemma MulOne_3727(i: int)\n ensures i * 1 == i\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_3728","instance":3728,"id":173727,"goal":"lemma MulZero_3728(c: nat)\n ensures c * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_3729","instance":3729,"id":173728,"goal":"lemma LeRefl_3729(z: real)\n ensures z <= z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_3730","instance":3730,"id":173729,"goal":"lemma LeTrans_3730(j: int, k: int, i: int)\n requires j <= k && k <= i\n ensures j <= i\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_3731","instance":3731,"id":173730,"goal":"lemma AddMono_3731(j: nat, i: nat, c: nat)\n requires j <= i\n ensures j + c <= i + c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_3732","instance":3732,"id":173731,"goal":"lemma Abs_Nonneg_3732(b: real)\n ensures (if b >= 0 then b else -b) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_3733","instance":3733,"id":173732,"goal":"lemma DivMod_3733(z: int, d: int)\n requires d > 0\n ensures z == d * (z / d) + (z % d)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_3734","instance":3734,"id":173733,"goal":"lemma ModBounds_3734(m: nat, y: nat)\n requires y > 0\n ensures 0 <= m % y < y\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_3735","instance":3735,"id":173734,"goal":"lemma Square_Nonneg_3735(x: real)\n ensures x * x >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_3736","instance":3736,"id":173735,"goal":"lemma AddComm_3736(i: int, b: int)\n ensures i + b == b + i\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_3737","instance":3737,"id":173736,"goal":"lemma AddAssoc_3737(c: nat, b: nat, i: nat)\n ensures (c + b) + i == c + (b + i)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_3738","instance":3738,"id":173737,"goal":"lemma MulComm_3738(b: real, a: real)\n ensures b * a == a * b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_3739","instance":3739,"id":173738,"goal":"lemma MulAssoc_3739(a: int, c: int, d: int)\n ensures (a * c) * d == a * (c * d)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_3740","instance":3740,"id":173739,"goal":"lemma Distrib_3740(a: nat, i: nat, n: nat)\n ensures a * (i + n) == a * i + a * n\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_3741","instance":3741,"id":173740,"goal":"lemma AddZero_3741(x: real)\n ensures x + 0 == x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_3742","instance":3742,"id":173741,"goal":"lemma MulOne_3742(i: int)\n ensures i * 1 == i\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_3743","instance":3743,"id":173742,"goal":"lemma MulZero_3743(b: nat)\n ensures b * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_3744","instance":3744,"id":173743,"goal":"lemma LeRefl_3744(x: real)\n ensures x <= x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_3745","instance":3745,"id":173744,"goal":"lemma LeTrans_3745(b: int, x: int, d: int)\n requires b <= x && x <= d\n ensures b <= d\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_3746","instance":3746,"id":173745,"goal":"lemma AddMono_3746(b: nat, n: nat, x: nat)\n requires b <= n\n ensures b + x <= n + x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_3747","instance":3747,"id":173746,"goal":"lemma Abs_Nonneg_3747(y: real)\n ensures (if y >= 0 then y else -y) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_3748","instance":3748,"id":173747,"goal":"lemma DivMod_3748(a: int, z: int)\n requires z > 0\n ensures a == z * (a / z) + (a % z)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_3749","instance":3749,"id":173748,"goal":"lemma ModBounds_3749(d: nat, c: nat)\n requires c > 0\n ensures 0 <= d % c < c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_3750","instance":3750,"id":173749,"goal":"lemma Square_Nonneg_3750(j: real)\n ensures j * j >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_3751","instance":3751,"id":173750,"goal":"lemma AddComm_3751(n: int, m: int)\n ensures n + m == m + n\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_3752","instance":3752,"id":173751,"goal":"lemma AddAssoc_3752(j: nat, a: nat, y: nat)\n ensures (j + a) + y == j + (a + y)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_3753","instance":3753,"id":173752,"goal":"lemma MulComm_3753(k: real, d: real)\n ensures k * d == d * k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_3754","instance":3754,"id":173753,"goal":"lemma MulAssoc_3754(j: int, d: int, y: int)\n ensures (j * d) * y == j * (d * y)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_3755","instance":3755,"id":173754,"goal":"lemma Distrib_3755(z: nat, b: nat, n: nat)\n ensures z * (b + n) == z * b + z * n\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_3756","instance":3756,"id":173755,"goal":"lemma AddZero_3756(i: real)\n ensures i + 0 == i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_3757","instance":3757,"id":173756,"goal":"lemma MulOne_3757(c: int)\n ensures c * 1 == c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_3758","instance":3758,"id":173757,"goal":"lemma MulZero_3758(x: nat)\n ensures x * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_3759","instance":3759,"id":173758,"goal":"lemma LeRefl_3759(x: real)\n ensures x <= x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_3760","instance":3760,"id":173759,"goal":"lemma LeTrans_3760(c: int, d: int, x: int)\n requires c <= d && d <= x\n ensures c <= x\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_3761","instance":3761,"id":173760,"goal":"lemma AddMono_3761(c: nat, x: nat, d: nat)\n requires c <= x\n ensures c + d <= x + d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_3762","instance":3762,"id":173761,"goal":"lemma Abs_Nonneg_3762(b: real)\n ensures (if b >= 0 then b else -b) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_3763","instance":3763,"id":173762,"goal":"lemma DivMod_3763(c: int, j: int)\n requires j > 0\n ensures c == j * (c / j) + (c % j)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_3764","instance":3764,"id":173763,"goal":"lemma ModBounds_3764(x: nat, a: nat)\n requires a > 0\n ensures 0 <= x % a < a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_3765","instance":3765,"id":173764,"goal":"lemma Square_Nonneg_3765(b: real)\n ensures b * b >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_3766","instance":3766,"id":173765,"goal":"lemma AddComm_3766(d: int, n: int)\n ensures d + n == n + d\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_3767","instance":3767,"id":173766,"goal":"lemma AddAssoc_3767(m: nat, n: nat, a: nat)\n ensures (m + n) + a == m + (n + a)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_3768","instance":3768,"id":173767,"goal":"lemma MulComm_3768(c: real, d: real)\n ensures c * d == d * c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_3769","instance":3769,"id":173768,"goal":"lemma MulAssoc_3769(c: int, m: int, k: int)\n ensures (c * m) * k == c * (m * k)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_3770","instance":3770,"id":173769,"goal":"lemma Distrib_3770(y: nat, d: nat, i: nat)\n ensures y * (d + i) == y * d + y * i\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_3771","instance":3771,"id":173770,"goal":"lemma AddZero_3771(j: real)\n ensures j + 0 == j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_3772","instance":3772,"id":173771,"goal":"lemma MulOne_3772(k: int)\n ensures k * 1 == k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_3773","instance":3773,"id":173772,"goal":"lemma MulZero_3773(n: nat)\n ensures n * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_3774","instance":3774,"id":173773,"goal":"lemma LeRefl_3774(n: real)\n ensures n <= n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_3775","instance":3775,"id":173774,"goal":"lemma LeTrans_3775(j: int, n: int, i: int)\n requires j <= n && n <= i\n ensures j <= i\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_3776","instance":3776,"id":173775,"goal":"lemma AddMono_3776(a: nat, z: nat, b: nat)\n requires a <= z\n ensures a + b <= z + b\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_3777","instance":3777,"id":173776,"goal":"lemma Abs_Nonneg_3777(k: real)\n ensures (if k >= 0 then k else -k) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_3778","instance":3778,"id":173777,"goal":"lemma DivMod_3778(n: int, b: int)\n requires b > 0\n ensures n == b * (n / b) + (n % b)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_3779","instance":3779,"id":173778,"goal":"lemma ModBounds_3779(a: nat, k: nat)\n requires k > 0\n ensures 0 <= a % k < k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_3780","instance":3780,"id":173779,"goal":"lemma Square_Nonneg_3780(j: real)\n ensures j * j >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_3781","instance":3781,"id":173780,"goal":"lemma AddComm_3781(z: int, k: int)\n ensures z + k == k + z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_3782","instance":3782,"id":173781,"goal":"lemma AddAssoc_3782(j: nat, x: nat, y: nat)\n ensures (j + x) + y == j + (x + y)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_3783","instance":3783,"id":173782,"goal":"lemma MulComm_3783(c: real, n: real)\n ensures c * n == n * c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_3784","instance":3784,"id":173783,"goal":"lemma MulAssoc_3784(d: int, n: int, z: int)\n ensures (d * n) * z == d * (n * z)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_3785","instance":3785,"id":173784,"goal":"lemma Distrib_3785(m: nat, a: nat, z: nat)\n ensures m * (a + z) == m * a + m * z\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_3786","instance":3786,"id":173785,"goal":"lemma AddZero_3786(a: real)\n ensures a + 0 == a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_3787","instance":3787,"id":173786,"goal":"lemma MulOne_3787(b: int)\n ensures b * 1 == b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_3788","instance":3788,"id":173787,"goal":"lemma MulZero_3788(a: nat)\n ensures a * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_3789","instance":3789,"id":173788,"goal":"lemma LeRefl_3789(j: real)\n ensures j <= j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_3790","instance":3790,"id":173789,"goal":"lemma LeTrans_3790(d: int, a: int, c: int)\n requires d <= a && a <= c\n ensures d <= c\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_3791","instance":3791,"id":173790,"goal":"lemma AddMono_3791(z: nat, i: nat, a: nat)\n requires z <= i\n ensures z + a <= i + a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_3792","instance":3792,"id":173791,"goal":"lemma Abs_Nonneg_3792(b: real)\n ensures (if b >= 0 then b else -b) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_3793","instance":3793,"id":173792,"goal":"lemma DivMod_3793(x: int, j: int)\n requires j > 0\n ensures x == j * (x / j) + (x % j)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_3794","instance":3794,"id":173793,"goal":"lemma ModBounds_3794(a: nat, j: nat)\n requires j > 0\n ensures 0 <= a % j < j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_3795","instance":3795,"id":173794,"goal":"lemma Square_Nonneg_3795(a: real)\n ensures a * a >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_3796","instance":3796,"id":173795,"goal":"lemma AddComm_3796(x: int, j: int)\n ensures x + j == j + x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_3797","instance":3797,"id":173796,"goal":"lemma AddAssoc_3797(n: nat, d: nat, k: nat)\n ensures (n + d) + k == n + (d + k)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_3798","instance":3798,"id":173797,"goal":"lemma MulComm_3798(c: real, y: real)\n ensures c * y == y * c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_3799","instance":3799,"id":173798,"goal":"lemma MulAssoc_3799(x: int, b: int, c: int)\n ensures (x * b) * c == x * (b * c)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_3800","instance":3800,"id":173799,"goal":"lemma Distrib_3800(m: nat, z: nat, k: nat)\n ensures m * (z + k) == m * z + m * k\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_3801","instance":3801,"id":173800,"goal":"lemma AddZero_3801(k: real)\n ensures k + 0 == k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_3802","instance":3802,"id":173801,"goal":"lemma MulOne_3802(b: int)\n ensures b * 1 == b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_3803","instance":3803,"id":173802,"goal":"lemma MulZero_3803(d: nat)\n ensures d * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_3804","instance":3804,"id":173803,"goal":"lemma LeRefl_3804(x: real)\n ensures x <= x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_3805","instance":3805,"id":173804,"goal":"lemma LeTrans_3805(n: int, y: int, i: int)\n requires n <= y && y <= i\n ensures n <= i\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_3806","instance":3806,"id":173805,"goal":"lemma AddMono_3806(k: nat, j: nat, c: nat)\n requires k <= j\n ensures k + c <= j + c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_3807","instance":3807,"id":173806,"goal":"lemma Abs_Nonneg_3807(z: real)\n ensures (if z >= 0 then z else -z) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_3808","instance":3808,"id":173807,"goal":"lemma DivMod_3808(c: int, y: int)\n requires y > 0\n ensures c == y * (c / y) + (c % y)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_3809","instance":3809,"id":173808,"goal":"lemma ModBounds_3809(d: nat, c: nat)\n requires c > 0\n ensures 0 <= d % c < c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_3810","instance":3810,"id":173809,"goal":"lemma Square_Nonneg_3810(b: real)\n ensures b * b >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_3811","instance":3811,"id":173810,"goal":"lemma AddComm_3811(i: int, n: int)\n ensures i + n == n + i\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_3812","instance":3812,"id":173811,"goal":"lemma AddAssoc_3812(y: nat, j: nat, d: nat)\n ensures (y + j) + d == y + (j + d)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_3813","instance":3813,"id":173812,"goal":"lemma MulComm_3813(k: real, c: real)\n ensures k * c == c * k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_3814","instance":3814,"id":173813,"goal":"lemma MulAssoc_3814(m: int, k: int, x: int)\n ensures (m * k) * x == m * (k * x)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_3815","instance":3815,"id":173814,"goal":"lemma Distrib_3815(a: nat, c: nat, y: nat)\n ensures a * (c + y) == a * c + a * y\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_3816","instance":3816,"id":173815,"goal":"lemma AddZero_3816(y: real)\n ensures y + 0 == y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_3817","instance":3817,"id":173816,"goal":"lemma MulOne_3817(b: int)\n ensures b * 1 == b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_3818","instance":3818,"id":173817,"goal":"lemma MulZero_3818(m: nat)\n ensures m * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_3819","instance":3819,"id":173818,"goal":"lemma LeRefl_3819(z: real)\n ensures z <= z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_3820","instance":3820,"id":173819,"goal":"lemma LeTrans_3820(x: int, z: int, y: int)\n requires x <= z && z <= y\n ensures x <= y\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_3821","instance":3821,"id":173820,"goal":"lemma AddMono_3821(a: nat, k: nat, b: nat)\n requires a <= k\n ensures a + b <= k + b\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_3822","instance":3822,"id":173821,"goal":"lemma Abs_Nonneg_3822(m: real)\n ensures (if m >= 0 then m else -m) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_3823","instance":3823,"id":173822,"goal":"lemma DivMod_3823(x: int, i: int)\n requires i > 0\n ensures x == i * (x / i) + (x % i)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_3824","instance":3824,"id":173823,"goal":"lemma ModBounds_3824(x: nat, j: nat)\n requires j > 0\n ensures 0 <= x % j < j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_3825","instance":3825,"id":173824,"goal":"lemma Square_Nonneg_3825(i: real)\n ensures i * i >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_3826","instance":3826,"id":173825,"goal":"lemma AddComm_3826(n: int, k: int)\n ensures n + k == k + n\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_3827","instance":3827,"id":173826,"goal":"lemma AddAssoc_3827(d: nat, c: nat, m: nat)\n ensures (d + c) + m == d + (c + m)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_3828","instance":3828,"id":173827,"goal":"lemma MulComm_3828(y: real, m: real)\n ensures y * m == m * y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_3829","instance":3829,"id":173828,"goal":"lemma MulAssoc_3829(k: int, x: int, c: int)\n ensures (k * x) * c == k * (x * c)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_3830","instance":3830,"id":173829,"goal":"lemma Distrib_3830(m: nat, k: nat, i: nat)\n ensures m * (k + i) == m * k + m * i\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_3831","instance":3831,"id":173830,"goal":"lemma AddZero_3831(d: real)\n ensures d + 0 == d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_3832","instance":3832,"id":173831,"goal":"lemma MulOne_3832(i: int)\n ensures i * 1 == i\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_3833","instance":3833,"id":173832,"goal":"lemma MulZero_3833(n: nat)\n ensures n * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_3834","instance":3834,"id":173833,"goal":"lemma LeRefl_3834(z: real)\n ensures z <= z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_3835","instance":3835,"id":173834,"goal":"lemma LeTrans_3835(y: int, c: int, j: int)\n requires y <= c && c <= j\n ensures y <= j\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_3836","instance":3836,"id":173835,"goal":"lemma AddMono_3836(a: nat, i: nat, z: nat)\n requires a <= i\n ensures a + z <= i + z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_3837","instance":3837,"id":173836,"goal":"lemma Abs_Nonneg_3837(k: real)\n ensures (if k >= 0 then k else -k) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_3838","instance":3838,"id":173837,"goal":"lemma DivMod_3838(x: int, z: int)\n requires z > 0\n ensures x == z * (x / z) + (x % z)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_3839","instance":3839,"id":173838,"goal":"lemma ModBounds_3839(n: nat, y: nat)\n requires y > 0\n ensures 0 <= n % y < y\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_3840","instance":3840,"id":173839,"goal":"lemma Square_Nonneg_3840(d: real)\n ensures d * d >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_3841","instance":3841,"id":173840,"goal":"lemma AddComm_3841(d: int, n: int)\n ensures d + n == n + d\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_3842","instance":3842,"id":173841,"goal":"lemma AddAssoc_3842(b: nat, k: nat, z: nat)\n ensures (b + k) + z == b + (k + z)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_3843","instance":3843,"id":173842,"goal":"lemma MulComm_3843(z: real, n: real)\n ensures z * n == n * z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_3844","instance":3844,"id":173843,"goal":"lemma MulAssoc_3844(m: int, b: int, c: int)\n ensures (m * b) * c == m * (b * c)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_3845","instance":3845,"id":173844,"goal":"lemma Distrib_3845(m: nat, j: nat, i: nat)\n ensures m * (j + i) == m * j + m * i\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_3846","instance":3846,"id":173845,"goal":"lemma AddZero_3846(n: real)\n ensures n + 0 == n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_3847","instance":3847,"id":173846,"goal":"lemma MulOne_3847(a: int)\n ensures a * 1 == a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_3848","instance":3848,"id":173847,"goal":"lemma MulZero_3848(x: nat)\n ensures x * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_3849","instance":3849,"id":173848,"goal":"lemma LeRefl_3849(j: real)\n ensures j <= j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_3850","instance":3850,"id":173849,"goal":"lemma LeTrans_3850(k: int, n: int, m: int)\n requires k <= n && n <= m\n ensures k <= m\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_3851","instance":3851,"id":173850,"goal":"lemma AddMono_3851(z: nat, m: nat, b: nat)\n requires z <= m\n ensures z + b <= m + b\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_3852","instance":3852,"id":173851,"goal":"lemma Abs_Nonneg_3852(x: real)\n ensures (if x >= 0 then x else -x) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_3853","instance":3853,"id":173852,"goal":"lemma DivMod_3853(y: int, j: int)\n requires j > 0\n ensures y == j * (y / j) + (y % j)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_3854","instance":3854,"id":173853,"goal":"lemma ModBounds_3854(n: nat, k: nat)\n requires k > 0\n ensures 0 <= n % k < k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_3855","instance":3855,"id":173854,"goal":"lemma Square_Nonneg_3855(c: real)\n ensures c * c >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_3856","instance":3856,"id":173855,"goal":"lemma AddComm_3856(b: int, j: int)\n ensures b + j == j + b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_3857","instance":3857,"id":173856,"goal":"lemma AddAssoc_3857(j: nat, a: nat, z: nat)\n ensures (j + a) + z == j + (a + z)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_3858","instance":3858,"id":173857,"goal":"lemma MulComm_3858(b: real, d: real)\n ensures b * d == d * b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_3859","instance":3859,"id":173858,"goal":"lemma MulAssoc_3859(c: int, z: int, b: int)\n ensures (c * z) * b == c * (z * b)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_3860","instance":3860,"id":173859,"goal":"lemma Distrib_3860(k: nat, n: nat, z: nat)\n ensures k * (n + z) == k * n + k * z\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_3861","instance":3861,"id":173860,"goal":"lemma AddZero_3861(b: real)\n ensures b + 0 == b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_3862","instance":3862,"id":173861,"goal":"lemma MulOne_3862(n: int)\n ensures n * 1 == n\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_3863","instance":3863,"id":173862,"goal":"lemma MulZero_3863(k: nat)\n ensures k * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_3864","instance":3864,"id":173863,"goal":"lemma LeRefl_3864(i: real)\n ensures i <= i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_3865","instance":3865,"id":173864,"goal":"lemma LeTrans_3865(n: int, i: int, d: int)\n requires n <= i && i <= d\n ensures n <= d\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_3866","instance":3866,"id":173865,"goal":"lemma AddMono_3866(c: nat, z: nat, k: nat)\n requires c <= z\n ensures c + k <= z + k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_3867","instance":3867,"id":173866,"goal":"lemma Abs_Nonneg_3867(n: real)\n ensures (if n >= 0 then n else -n) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_3868","instance":3868,"id":173867,"goal":"lemma DivMod_3868(a: int, n: int)\n requires n > 0\n ensures a == n * (a / n) + (a % n)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_3869","instance":3869,"id":173868,"goal":"lemma ModBounds_3869(a: nat, x: nat)\n requires x > 0\n ensures 0 <= a % x < x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_3870","instance":3870,"id":173869,"goal":"lemma Square_Nonneg_3870(x: real)\n ensures x * x >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_3871","instance":3871,"id":173870,"goal":"lemma AddComm_3871(y: int, m: int)\n ensures y + m == m + y\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_3872","instance":3872,"id":173871,"goal":"lemma AddAssoc_3872(k: nat, i: nat, c: nat)\n ensures (k + i) + c == k + (i + c)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_3873","instance":3873,"id":173872,"goal":"lemma MulComm_3873(b: real, i: real)\n ensures b * i == i * b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_3874","instance":3874,"id":173873,"goal":"lemma MulAssoc_3874(x: int, b: int, y: int)\n ensures (x * b) * y == x * (b * y)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_3875","instance":3875,"id":173874,"goal":"lemma Distrib_3875(d: nat, z: nat, y: nat)\n ensures d * (z + y) == d * z + d * y\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_3876","instance":3876,"id":173875,"goal":"lemma AddZero_3876(b: real)\n ensures b + 0 == b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_3877","instance":3877,"id":173876,"goal":"lemma MulOne_3877(n: int)\n ensures n * 1 == n\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_3878","instance":3878,"id":173877,"goal":"lemma MulZero_3878(k: nat)\n ensures k * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_3879","instance":3879,"id":173878,"goal":"lemma LeRefl_3879(z: real)\n ensures z <= z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_3880","instance":3880,"id":173879,"goal":"lemma LeTrans_3880(z: int, c: int, x: int)\n requires z <= c && c <= x\n ensures z <= x\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_3881","instance":3881,"id":173880,"goal":"lemma AddMono_3881(m: nat, n: nat, b: nat)\n requires m <= n\n ensures m + b <= n + b\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_3882","instance":3882,"id":173881,"goal":"lemma Abs_Nonneg_3882(c: real)\n ensures (if c >= 0 then c else -c) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_3883","instance":3883,"id":173882,"goal":"lemma DivMod_3883(k: int, c: int)\n requires c > 0\n ensures k == c * (k / c) + (k % c)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_3884","instance":3884,"id":173883,"goal":"lemma ModBounds_3884(d: nat, j: nat)\n requires j > 0\n ensures 0 <= d % j < j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_3885","instance":3885,"id":173884,"goal":"lemma Square_Nonneg_3885(y: real)\n ensures y * y >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_3886","instance":3886,"id":173885,"goal":"lemma AddComm_3886(z: int, n: int)\n ensures z + n == n + z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_3887","instance":3887,"id":173886,"goal":"lemma AddAssoc_3887(d: nat, c: nat, a: nat)\n ensures (d + c) + a == d + (c + a)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_3888","instance":3888,"id":173887,"goal":"lemma MulComm_3888(i: real, k: real)\n ensures i * k == k * i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_3889","instance":3889,"id":173888,"goal":"lemma MulAssoc_3889(i: int, d: int, c: int)\n ensures (i * d) * c == i * (d * c)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_3890","instance":3890,"id":173889,"goal":"lemma Distrib_3890(d: nat, k: nat, i: nat)\n ensures d * (k + i) == d * k + d * i\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_3891","instance":3891,"id":173890,"goal":"lemma AddZero_3891(a: real)\n ensures a + 0 == a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_3892","instance":3892,"id":173891,"goal":"lemma MulOne_3892(i: int)\n ensures i * 1 == i\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_3893","instance":3893,"id":173892,"goal":"lemma MulZero_3893(y: nat)\n ensures y * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_3894","instance":3894,"id":173893,"goal":"lemma LeRefl_3894(c: real)\n ensures c <= c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_3895","instance":3895,"id":173894,"goal":"lemma LeTrans_3895(d: int, a: int, x: int)\n requires d <= a && a <= x\n ensures d <= x\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_3896","instance":3896,"id":173895,"goal":"lemma AddMono_3896(x: nat, z: nat, m: nat)\n requires x <= z\n ensures x + m <= z + m\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_3897","instance":3897,"id":173896,"goal":"lemma Abs_Nonneg_3897(n: real)\n ensures (if n >= 0 then n else -n) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_3898","instance":3898,"id":173897,"goal":"lemma DivMod_3898(i: int, k: int)\n requires k > 0\n ensures i == k * (i / k) + (i % k)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_3899","instance":3899,"id":173898,"goal":"lemma ModBounds_3899(n: nat, i: nat)\n requires i > 0\n ensures 0 <= n % i < i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_3900","instance":3900,"id":173899,"goal":"lemma Square_Nonneg_3900(z: real)\n ensures z * z >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_3901","instance":3901,"id":173900,"goal":"lemma AddComm_3901(j: int, z: int)\n ensures j + z == z + j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_3902","instance":3902,"id":173901,"goal":"lemma AddAssoc_3902(b: nat, i: nat, j: nat)\n ensures (b + i) + j == b + (i + j)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_3903","instance":3903,"id":173902,"goal":"lemma MulComm_3903(a: real, j: real)\n ensures a * j == j * a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_3904","instance":3904,"id":173903,"goal":"lemma MulAssoc_3904(j: int, a: int, c: int)\n ensures (j * a) * c == j * (a * c)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_3905","instance":3905,"id":173904,"goal":"lemma Distrib_3905(x: nat, b: nat, j: nat)\n ensures x * (b + j) == x * b + x * j\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_3906","instance":3906,"id":173905,"goal":"lemma AddZero_3906(x: real)\n ensures x + 0 == x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_3907","instance":3907,"id":173906,"goal":"lemma MulOne_3907(n: int)\n ensures n * 1 == n\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_3908","instance":3908,"id":173907,"goal":"lemma MulZero_3908(k: nat)\n ensures k * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_3909","instance":3909,"id":173908,"goal":"lemma LeRefl_3909(c: real)\n ensures c <= c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_3910","instance":3910,"id":173909,"goal":"lemma LeTrans_3910(j: int, z: int, x: int)\n requires j <= z && z <= x\n ensures j <= x\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_3911","instance":3911,"id":173910,"goal":"lemma AddMono_3911(y: nat, m: nat, d: nat)\n requires y <= m\n ensures y + d <= m + d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_3912","instance":3912,"id":173911,"goal":"lemma Abs_Nonneg_3912(m: real)\n ensures (if m >= 0 then m else -m) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_3913","instance":3913,"id":173912,"goal":"lemma DivMod_3913(i: int, c: int)\n requires c > 0\n ensures i == c * (i / c) + (i % c)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_3914","instance":3914,"id":173913,"goal":"lemma ModBounds_3914(a: nat, b: nat)\n requires b > 0\n ensures 0 <= a % b < b\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_3915","instance":3915,"id":173914,"goal":"lemma Square_Nonneg_3915(k: real)\n ensures k * k >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_3916","instance":3916,"id":173915,"goal":"lemma AddComm_3916(z: int, m: int)\n ensures z + m == m + z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_3917","instance":3917,"id":173916,"goal":"lemma AddAssoc_3917(d: nat, y: nat, c: nat)\n ensures (d + y) + c == d + (y + c)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_3918","instance":3918,"id":173917,"goal":"lemma MulComm_3918(x: real, k: real)\n ensures x * k == k * x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_3919","instance":3919,"id":173918,"goal":"lemma MulAssoc_3919(n: int, a: int, i: int)\n ensures (n * a) * i == n * (a * i)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_3920","instance":3920,"id":173919,"goal":"lemma Distrib_3920(a: nat, x: nat, y: nat)\n ensures a * (x + y) == a * x + a * y\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_3921","instance":3921,"id":173920,"goal":"lemma AddZero_3921(y: real)\n ensures y + 0 == y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_3922","instance":3922,"id":173921,"goal":"lemma MulOne_3922(z: int)\n ensures z * 1 == z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_3923","instance":3923,"id":173922,"goal":"lemma MulZero_3923(k: nat)\n ensures k * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_3924","instance":3924,"id":173923,"goal":"lemma LeRefl_3924(y: real)\n ensures y <= y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_3925","instance":3925,"id":173924,"goal":"lemma LeTrans_3925(z: int, m: int, d: int)\n requires z <= m && m <= d\n ensures z <= d\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_3926","instance":3926,"id":173925,"goal":"lemma AddMono_3926(c: nat, i: nat, b: nat)\n requires c <= i\n ensures c + b <= i + b\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_3927","instance":3927,"id":173926,"goal":"lemma Abs_Nonneg_3927(m: real)\n ensures (if m >= 0 then m else -m) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_3928","instance":3928,"id":173927,"goal":"lemma DivMod_3928(k: int, x: int)\n requires x > 0\n ensures k == x * (k / x) + (k % x)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_3929","instance":3929,"id":173928,"goal":"lemma ModBounds_3929(i: nat, x: nat)\n requires x > 0\n ensures 0 <= i % x < x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_3930","instance":3930,"id":173929,"goal":"lemma Square_Nonneg_3930(m: real)\n ensures m * m >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_3931","instance":3931,"id":173930,"goal":"lemma AddComm_3931(b: int, j: int)\n ensures b + j == j + b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_3932","instance":3932,"id":173931,"goal":"lemma AddAssoc_3932(m: nat, d: nat, c: nat)\n ensures (m + d) + c == m + (d + c)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_3933","instance":3933,"id":173932,"goal":"lemma MulComm_3933(c: real, d: real)\n ensures c * d == d * c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_3934","instance":3934,"id":173933,"goal":"lemma MulAssoc_3934(b: int, a: int, i: int)\n ensures (b * a) * i == b * (a * i)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_3935","instance":3935,"id":173934,"goal":"lemma Distrib_3935(m: nat, x: nat, i: nat)\n ensures m * (x + i) == m * x + m * i\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_3936","instance":3936,"id":173935,"goal":"lemma AddZero_3936(m: real)\n ensures m + 0 == m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_3937","instance":3937,"id":173936,"goal":"lemma MulOne_3937(i: int)\n ensures i * 1 == i\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_3938","instance":3938,"id":173937,"goal":"lemma MulZero_3938(i: nat)\n ensures i * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_3939","instance":3939,"id":173938,"goal":"lemma LeRefl_3939(a: real)\n ensures a <= a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_3940","instance":3940,"id":173939,"goal":"lemma LeTrans_3940(j: int, k: int, d: int)\n requires j <= k && k <= d\n ensures j <= d\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_3941","instance":3941,"id":173940,"goal":"lemma AddMono_3941(j: nat, i: nat, n: nat)\n requires j <= i\n ensures j + n <= i + n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_3942","instance":3942,"id":173941,"goal":"lemma Abs_Nonneg_3942(n: real)\n ensures (if n >= 0 then n else -n) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_3943","instance":3943,"id":173942,"goal":"lemma DivMod_3943(c: int, m: int)\n requires m > 0\n ensures c == m * (c / m) + (c % m)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_3944","instance":3944,"id":173943,"goal":"lemma ModBounds_3944(n: nat, d: nat)\n requires d > 0\n ensures 0 <= n % d < d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_3945","instance":3945,"id":173944,"goal":"lemma Square_Nonneg_3945(b: real)\n ensures b * b >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_3946","instance":3946,"id":173945,"goal":"lemma AddComm_3946(x: int, m: int)\n ensures x + m == m + x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_3947","instance":3947,"id":173946,"goal":"lemma AddAssoc_3947(k: nat, c: nat, y: nat)\n ensures (k + c) + y == k + (c + y)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_3948","instance":3948,"id":173947,"goal":"lemma MulComm_3948(m: real, d: real)\n ensures m * d == d * m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_3949","instance":3949,"id":173948,"goal":"lemma MulAssoc_3949(m: int, k: int, z: int)\n ensures (m * k) * z == m * (k * z)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_3950","instance":3950,"id":173949,"goal":"lemma Distrib_3950(z: nat, x: nat, k: nat)\n ensures z * (x + k) == z * x + z * k\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_3951","instance":3951,"id":173950,"goal":"lemma AddZero_3951(x: real)\n ensures x + 0 == x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_3952","instance":3952,"id":173951,"goal":"lemma MulOne_3952(a: int)\n ensures a * 1 == a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_3953","instance":3953,"id":173952,"goal":"lemma MulZero_3953(y: nat)\n ensures y * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_3954","instance":3954,"id":173953,"goal":"lemma LeRefl_3954(d: real)\n ensures d <= d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_3955","instance":3955,"id":173954,"goal":"lemma LeTrans_3955(k: int, b: int, z: int)\n requires k <= b && b <= z\n ensures k <= z\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_3956","instance":3956,"id":173955,"goal":"lemma AddMono_3956(m: nat, c: nat, k: nat)\n requires m <= c\n ensures m + k <= c + k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_3957","instance":3957,"id":173956,"goal":"lemma Abs_Nonneg_3957(b: real)\n ensures (if b >= 0 then b else -b) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_3958","instance":3958,"id":173957,"goal":"lemma DivMod_3958(k: int, n: int)\n requires n > 0\n ensures k == n * (k / n) + (k % n)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_3959","instance":3959,"id":173958,"goal":"lemma ModBounds_3959(x: nat, a: nat)\n requires a > 0\n ensures 0 <= x % a < a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_3960","instance":3960,"id":173959,"goal":"lemma Square_Nonneg_3960(j: real)\n ensures j * j >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_3961","instance":3961,"id":173960,"goal":"lemma AddComm_3961(x: int, b: int)\n ensures x + b == b + x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_3962","instance":3962,"id":173961,"goal":"lemma AddAssoc_3962(d: nat, i: nat, c: nat)\n ensures (d + i) + c == d + (i + c)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_3963","instance":3963,"id":173962,"goal":"lemma MulComm_3963(m: real, z: real)\n ensures m * z == z * m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_3964","instance":3964,"id":173963,"goal":"lemma MulAssoc_3964(i: int, d: int, m: int)\n ensures (i * d) * m == i * (d * m)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_3965","instance":3965,"id":173964,"goal":"lemma Distrib_3965(n: nat, i: nat, b: nat)\n ensures n * (i + b) == n * i + n * b\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_3966","instance":3966,"id":173965,"goal":"lemma AddZero_3966(x: real)\n ensures x + 0 == x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_3967","instance":3967,"id":173966,"goal":"lemma MulOne_3967(i: int)\n ensures i * 1 == i\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_3968","instance":3968,"id":173967,"goal":"lemma MulZero_3968(b: nat)\n ensures b * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_3969","instance":3969,"id":173968,"goal":"lemma LeRefl_3969(z: real)\n ensures z <= z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_3970","instance":3970,"id":173969,"goal":"lemma LeTrans_3970(c: int, z: int, j: int)\n requires c <= z && z <= j\n ensures c <= j\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_3971","instance":3971,"id":173970,"goal":"lemma AddMono_3971(b: nat, k: nat, z: nat)\n requires b <= k\n ensures b + z <= k + z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_3972","instance":3972,"id":173971,"goal":"lemma Abs_Nonneg_3972(d: real)\n ensures (if d >= 0 then d else -d) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_3973","instance":3973,"id":173972,"goal":"lemma DivMod_3973(k: int, n: int)\n requires n > 0\n ensures k == n * (k / n) + (k % n)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_3974","instance":3974,"id":173973,"goal":"lemma ModBounds_3974(x: nat, a: nat)\n requires a > 0\n ensures 0 <= x % a < a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_3975","instance":3975,"id":173974,"goal":"lemma Square_Nonneg_3975(k: real)\n ensures k * k >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_3976","instance":3976,"id":173975,"goal":"lemma AddComm_3976(n: int, i: int)\n ensures n + i == i + n\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_3977","instance":3977,"id":173976,"goal":"lemma AddAssoc_3977(k: nat, c: nat, b: nat)\n ensures (k + c) + b == k + (c + b)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_3978","instance":3978,"id":173977,"goal":"lemma MulComm_3978(b: real, z: real)\n ensures b * z == z * b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_3979","instance":3979,"id":173978,"goal":"lemma MulAssoc_3979(a: int, c: int, j: int)\n ensures (a * c) * j == a * (c * j)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_3980","instance":3980,"id":173979,"goal":"lemma Distrib_3980(a: nat, c: nat, n: nat)\n ensures a * (c + n) == a * c + a * n\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_3981","instance":3981,"id":173980,"goal":"lemma AddZero_3981(i: real)\n ensures i + 0 == i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_3982","instance":3982,"id":173981,"goal":"lemma MulOne_3982(a: int)\n ensures a * 1 == a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_3983","instance":3983,"id":173982,"goal":"lemma MulZero_3983(z: nat)\n ensures z * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_3984","instance":3984,"id":173983,"goal":"lemma LeRefl_3984(d: real)\n ensures d <= d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_3985","instance":3985,"id":173984,"goal":"lemma LeTrans_3985(n: int, b: int, x: int)\n requires n <= b && b <= x\n ensures n <= x\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_3986","instance":3986,"id":173985,"goal":"lemma AddMono_3986(b: nat, i: nat, n: nat)\n requires b <= i\n ensures b + n <= i + n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_3987","instance":3987,"id":173986,"goal":"lemma Abs_Nonneg_3987(a: real)\n ensures (if a >= 0 then a else -a) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_3988","instance":3988,"id":173987,"goal":"lemma DivMod_3988(c: int, i: int)\n requires i > 0\n ensures c == i * (c / i) + (c % i)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_3989","instance":3989,"id":173988,"goal":"lemma ModBounds_3989(j: nat, i: nat)\n requires i > 0\n ensures 0 <= j % i < i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_3990","instance":3990,"id":173989,"goal":"lemma Square_Nonneg_3990(d: real)\n ensures d * d >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_3991","instance":3991,"id":173990,"goal":"lemma AddComm_3991(k: int, a: int)\n ensures k + a == a + k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_3992","instance":3992,"id":173991,"goal":"lemma AddAssoc_3992(i: nat, x: nat, n: nat)\n ensures (i + x) + n == i + (x + n)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_3993","instance":3993,"id":173992,"goal":"lemma MulComm_3993(x: real, b: real)\n ensures x * b == b * x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_3994","instance":3994,"id":173993,"goal":"lemma MulAssoc_3994(i: int, x: int, k: int)\n ensures (i * x) * k == i * (x * k)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_3995","instance":3995,"id":173994,"goal":"lemma Distrib_3995(a: nat, n: nat, x: nat)\n ensures a * (n + x) == a * n + a * x\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_3996","instance":3996,"id":173995,"goal":"lemma AddZero_3996(a: real)\n ensures a + 0 == a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_3997","instance":3997,"id":173996,"goal":"lemma MulOne_3997(j: int)\n ensures j * 1 == j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_3998","instance":3998,"id":173997,"goal":"lemma MulZero_3998(x: nat)\n ensures x * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_3999","instance":3999,"id":173998,"goal":"lemma LeRefl_3999(n: real)\n ensures n <= n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_4000","instance":4000,"id":173999,"goal":"lemma LeTrans_4000(z: int, d: int, x: int)\n requires z <= d && d <= x\n ensures z <= x\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_4001","instance":4001,"id":174000,"goal":"lemma AddMono_4001(n: nat, j: nat, y: nat)\n requires n <= j\n ensures n + y <= j + y\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_4002","instance":4002,"id":174001,"goal":"lemma Abs_Nonneg_4002(c: real)\n ensures (if c >= 0 then c else -c) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_4003","instance":4003,"id":174002,"goal":"lemma DivMod_4003(m: int, a: int)\n requires a > 0\n ensures m == a * (m / a) + (m % a)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_4004","instance":4004,"id":174003,"goal":"lemma ModBounds_4004(i: nat, z: nat)\n requires z > 0\n ensures 0 <= i % z < z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_4005","instance":4005,"id":174004,"goal":"lemma Square_Nonneg_4005(d: real)\n ensures d * d >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_4006","instance":4006,"id":174005,"goal":"lemma AddComm_4006(a: int, y: int)\n ensures a + y == y + a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_4007","instance":4007,"id":174006,"goal":"lemma AddAssoc_4007(i: nat, n: nat, a: nat)\n ensures (i + n) + a == i + (n + a)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_4008","instance":4008,"id":174007,"goal":"lemma MulComm_4008(i: real, c: real)\n ensures i * c == c * i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_4009","instance":4009,"id":174008,"goal":"lemma MulAssoc_4009(k: int, z: int, a: int)\n ensures (k * z) * a == k * (z * a)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_4010","instance":4010,"id":174009,"goal":"lemma Distrib_4010(k: nat, j: nat, n: nat)\n ensures k * (j + n) == k * j + k * n\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_4011","instance":4011,"id":174010,"goal":"lemma AddZero_4011(d: real)\n ensures d + 0 == d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_4012","instance":4012,"id":174011,"goal":"lemma MulOne_4012(n: int)\n ensures n * 1 == n\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_4013","instance":4013,"id":174012,"goal":"lemma MulZero_4013(d: nat)\n ensures d * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_4014","instance":4014,"id":174013,"goal":"lemma LeRefl_4014(k: real)\n ensures k <= k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_4015","instance":4015,"id":174014,"goal":"lemma LeTrans_4015(b: int, x: int, a: int)\n requires b <= x && x <= a\n ensures b <= a\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_4016","instance":4016,"id":174015,"goal":"lemma AddMono_4016(z: nat, a: nat, m: nat)\n requires z <= a\n ensures z + m <= a + m\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_4017","instance":4017,"id":174016,"goal":"lemma Abs_Nonneg_4017(b: real)\n ensures (if b >= 0 then b else -b) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_4018","instance":4018,"id":174017,"goal":"lemma DivMod_4018(a: int, k: int)\n requires k > 0\n ensures a == k * (a / k) + (a % k)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_4019","instance":4019,"id":174018,"goal":"lemma ModBounds_4019(c: nat, z: nat)\n requires z > 0\n ensures 0 <= c % z < z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_4020","instance":4020,"id":174019,"goal":"lemma Square_Nonneg_4020(j: real)\n ensures j * j >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_4021","instance":4021,"id":174020,"goal":"lemma AddComm_4021(x: int, k: int)\n ensures x + k == k + x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_4022","instance":4022,"id":174021,"goal":"lemma AddAssoc_4022(m: nat, i: nat, j: nat)\n ensures (m + i) + j == m + (i + j)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_4023","instance":4023,"id":174022,"goal":"lemma MulComm_4023(c: real, y: real)\n ensures c * y == y * c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_4024","instance":4024,"id":174023,"goal":"lemma MulAssoc_4024(a: int, c: int, d: int)\n ensures (a * c) * d == a * (c * d)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_4025","instance":4025,"id":174024,"goal":"lemma Distrib_4025(y: nat, j: nat, i: nat)\n ensures y * (j + i) == y * j + y * i\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_4026","instance":4026,"id":174025,"goal":"lemma AddZero_4026(x: real)\n ensures x + 0 == x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_4027","instance":4027,"id":174026,"goal":"lemma MulOne_4027(y: int)\n ensures y * 1 == y\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_4028","instance":4028,"id":174027,"goal":"lemma MulZero_4028(a: nat)\n ensures a * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_4029","instance":4029,"id":174028,"goal":"lemma LeRefl_4029(j: real)\n ensures j <= j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_4030","instance":4030,"id":174029,"goal":"lemma LeTrans_4030(x: int, k: int, b: int)\n requires x <= k && k <= b\n ensures x <= b\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_4031","instance":4031,"id":174030,"goal":"lemma AddMono_4031(n: nat, z: nat, a: nat)\n requires n <= z\n ensures n + a <= z + a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_4032","instance":4032,"id":174031,"goal":"lemma Abs_Nonneg_4032(m: real)\n ensures (if m >= 0 then m else -m) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_4033","instance":4033,"id":174032,"goal":"lemma DivMod_4033(y: int, x: int)\n requires x > 0\n ensures y == x * (y / x) + (y % x)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_4034","instance":4034,"id":174033,"goal":"lemma ModBounds_4034(d: nat, c: nat)\n requires c > 0\n ensures 0 <= d % c < c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_4035","instance":4035,"id":174034,"goal":"lemma Square_Nonneg_4035(a: real)\n ensures a * a >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_4036","instance":4036,"id":174035,"goal":"lemma AddComm_4036(n: int, k: int)\n ensures n + k == k + n\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_4037","instance":4037,"id":174036,"goal":"lemma AddAssoc_4037(a: nat, n: nat, d: nat)\n ensures (a + n) + d == a + (n + d)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_4038","instance":4038,"id":174037,"goal":"lemma MulComm_4038(a: real, c: real)\n ensures a * c == c * a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_4039","instance":4039,"id":174038,"goal":"lemma MulAssoc_4039(b: int, y: int, j: int)\n ensures (b * y) * j == b * (y * j)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_4040","instance":4040,"id":174039,"goal":"lemma Distrib_4040(k: nat, b: nat, c: nat)\n ensures k * (b + c) == k * b + k * c\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_4041","instance":4041,"id":174040,"goal":"lemma AddZero_4041(m: real)\n ensures m + 0 == m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_4042","instance":4042,"id":174041,"goal":"lemma MulOne_4042(b: int)\n ensures b * 1 == b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_4043","instance":4043,"id":174042,"goal":"lemma MulZero_4043(d: nat)\n ensures d * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_4044","instance":4044,"id":174043,"goal":"lemma LeRefl_4044(y: real)\n ensures y <= y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_4045","instance":4045,"id":174044,"goal":"lemma LeTrans_4045(i: int, j: int, m: int)\n requires i <= j && j <= m\n ensures i <= m\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_4046","instance":4046,"id":174045,"goal":"lemma AddMono_4046(m: nat, d: nat, j: nat)\n requires m <= d\n ensures m + j <= d + j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_4047","instance":4047,"id":174046,"goal":"lemma Abs_Nonneg_4047(y: real)\n ensures (if y >= 0 then y else -y) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_4048","instance":4048,"id":174047,"goal":"lemma DivMod_4048(a: int, m: int)\n requires m > 0\n ensures a == m * (a / m) + (a % m)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_4049","instance":4049,"id":174048,"goal":"lemma ModBounds_4049(x: nat, j: nat)\n requires j > 0\n ensures 0 <= x % j < j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_4050","instance":4050,"id":174049,"goal":"lemma Square_Nonneg_4050(z: real)\n ensures z * z >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_4051","instance":4051,"id":174050,"goal":"lemma AddComm_4051(a: int, m: int)\n ensures a + m == m + a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_4052","instance":4052,"id":174051,"goal":"lemma AddAssoc_4052(k: nat, y: nat, a: nat)\n ensures (k + y) + a == k + (y + a)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_4053","instance":4053,"id":174052,"goal":"lemma MulComm_4053(c: real, j: real)\n ensures c * j == j * c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_4054","instance":4054,"id":174053,"goal":"lemma MulAssoc_4054(a: int, y: int, b: int)\n ensures (a * y) * b == a * (y * b)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_4055","instance":4055,"id":174054,"goal":"lemma Distrib_4055(n: nat, j: nat, d: nat)\n ensures n * (j + d) == n * j + n * d\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_4056","instance":4056,"id":174055,"goal":"lemma AddZero_4056(i: real)\n ensures i + 0 == i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_4057","instance":4057,"id":174056,"goal":"lemma MulOne_4057(z: int)\n ensures z * 1 == z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_4058","instance":4058,"id":174057,"goal":"lemma MulZero_4058(n: nat)\n ensures n * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_4059","instance":4059,"id":174058,"goal":"lemma LeRefl_4059(j: real)\n ensures j <= j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_4060","instance":4060,"id":174059,"goal":"lemma LeTrans_4060(d: int, n: int, z: int)\n requires d <= n && n <= z\n ensures d <= z\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_4061","instance":4061,"id":174060,"goal":"lemma AddMono_4061(i: nat, n: nat, j: nat)\n requires i <= n\n ensures i + j <= n + j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_4062","instance":4062,"id":174061,"goal":"lemma Abs_Nonneg_4062(d: real)\n ensures (if d >= 0 then d else -d) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_4063","instance":4063,"id":174062,"goal":"lemma DivMod_4063(i: int, y: int)\n requires y > 0\n ensures i == y * (i / y) + (i % y)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_4064","instance":4064,"id":174063,"goal":"lemma ModBounds_4064(y: nat, m: nat)\n requires m > 0\n ensures 0 <= y % m < m\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_4065","instance":4065,"id":174064,"goal":"lemma Square_Nonneg_4065(a: real)\n ensures a * a >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_4066","instance":4066,"id":174065,"goal":"lemma AddComm_4066(c: int, m: int)\n ensures c + m == m + c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_4067","instance":4067,"id":174066,"goal":"lemma AddAssoc_4067(j: nat, d: nat, z: nat)\n ensures (j + d) + z == j + (d + z)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_4068","instance":4068,"id":174067,"goal":"lemma MulComm_4068(b: real, n: real)\n ensures b * n == n * b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_4069","instance":4069,"id":174068,"goal":"lemma MulAssoc_4069(d: int, x: int, z: int)\n ensures (d * x) * z == d * (x * z)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_4070","instance":4070,"id":174069,"goal":"lemma Distrib_4070(i: nat, k: nat, m: nat)\n ensures i * (k + m) == i * k + i * m\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_4071","instance":4071,"id":174070,"goal":"lemma AddZero_4071(b: real)\n ensures b + 0 == b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_4072","instance":4072,"id":174071,"goal":"lemma MulOne_4072(x: int)\n ensures x * 1 == x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_4073","instance":4073,"id":174072,"goal":"lemma MulZero_4073(n: nat)\n ensures n * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_4074","instance":4074,"id":174073,"goal":"lemma LeRefl_4074(i: real)\n ensures i <= i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_4075","instance":4075,"id":174074,"goal":"lemma LeTrans_4075(i: int, d: int, k: int)\n requires i <= d && d <= k\n ensures i <= k\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_4076","instance":4076,"id":174075,"goal":"lemma AddMono_4076(z: nat, m: nat, x: nat)\n requires z <= m\n ensures z + x <= m + x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_4077","instance":4077,"id":174076,"goal":"lemma Abs_Nonneg_4077(x: real)\n ensures (if x >= 0 then x else -x) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_4078","instance":4078,"id":174077,"goal":"lemma DivMod_4078(m: int, d: int)\n requires d > 0\n ensures m == d * (m / d) + (m % d)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_4079","instance":4079,"id":174078,"goal":"lemma ModBounds_4079(x: nat, d: nat)\n requires d > 0\n ensures 0 <= x % d < d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_4080","instance":4080,"id":174079,"goal":"lemma Square_Nonneg_4080(k: real)\n ensures k * k >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_4081","instance":4081,"id":174080,"goal":"lemma AddComm_4081(b: int, i: int)\n ensures b + i == i + b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_4082","instance":4082,"id":174081,"goal":"lemma AddAssoc_4082(z: nat, m: nat, i: nat)\n ensures (z + m) + i == z + (m + i)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_4083","instance":4083,"id":174082,"goal":"lemma MulComm_4083(x: real, a: real)\n ensures x * a == a * x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_4084","instance":4084,"id":174083,"goal":"lemma MulAssoc_4084(n: int, i: int, b: int)\n ensures (n * i) * b == n * (i * b)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_4085","instance":4085,"id":174084,"goal":"lemma Distrib_4085(i: nat, y: nat, k: nat)\n ensures i * (y + k) == i * y + i * k\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_4086","instance":4086,"id":174085,"goal":"lemma AddZero_4086(i: real)\n ensures i + 0 == i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_4087","instance":4087,"id":174086,"goal":"lemma MulOne_4087(c: int)\n ensures c * 1 == c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_4088","instance":4088,"id":174087,"goal":"lemma MulZero_4088(z: nat)\n ensures z * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_4089","instance":4089,"id":174088,"goal":"lemma LeRefl_4089(y: real)\n ensures y <= y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_4090","instance":4090,"id":174089,"goal":"lemma LeTrans_4090(x: int, m: int, a: int)\n requires x <= m && m <= a\n ensures x <= a\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_4091","instance":4091,"id":174090,"goal":"lemma AddMono_4091(a: nat, y: nat, i: nat)\n requires a <= y\n ensures a + i <= y + i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_4092","instance":4092,"id":174091,"goal":"lemma Abs_Nonneg_4092(i: real)\n ensures (if i >= 0 then i else -i) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_4093","instance":4093,"id":174092,"goal":"lemma DivMod_4093(m: int, z: int)\n requires z > 0\n ensures m == z * (m / z) + (m % z)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_4094","instance":4094,"id":174093,"goal":"lemma ModBounds_4094(c: nat, a: nat)\n requires a > 0\n ensures 0 <= c % a < a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_4095","instance":4095,"id":174094,"goal":"lemma Square_Nonneg_4095(y: real)\n ensures y * y >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_4096","instance":4096,"id":174095,"goal":"lemma AddComm_4096(c: int, z: int)\n ensures c + z == z + c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_4097","instance":4097,"id":174096,"goal":"lemma AddAssoc_4097(c: nat, z: nat, b: nat)\n ensures (c + z) + b == c + (z + b)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_4098","instance":4098,"id":174097,"goal":"lemma MulComm_4098(a: real, y: real)\n ensures a * y == y * a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_4099","instance":4099,"id":174098,"goal":"lemma MulAssoc_4099(c: int, j: int, d: int)\n ensures (c * j) * d == c * (j * d)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_4100","instance":4100,"id":174099,"goal":"lemma Distrib_4100(k: nat, d: nat, z: nat)\n ensures k * (d + z) == k * d + k * z\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_4101","instance":4101,"id":174100,"goal":"lemma AddZero_4101(d: real)\n ensures d + 0 == d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_4102","instance":4102,"id":174101,"goal":"lemma MulOne_4102(a: int)\n ensures a * 1 == a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_4103","instance":4103,"id":174102,"goal":"lemma MulZero_4103(b: nat)\n ensures b * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_4104","instance":4104,"id":174103,"goal":"lemma LeRefl_4104(d: real)\n ensures d <= d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_4105","instance":4105,"id":174104,"goal":"lemma LeTrans_4105(x: int, a: int, b: int)\n requires x <= a && a <= b\n ensures x <= b\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_4106","instance":4106,"id":174105,"goal":"lemma AddMono_4106(a: nat, b: nat, m: nat)\n requires a <= b\n ensures a + m <= b + m\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_4107","instance":4107,"id":174106,"goal":"lemma Abs_Nonneg_4107(j: real)\n ensures (if j >= 0 then j else -j) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_4108","instance":4108,"id":174107,"goal":"lemma DivMod_4108(d: int, z: int)\n requires z > 0\n ensures d == z * (d / z) + (d % z)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_4109","instance":4109,"id":174108,"goal":"lemma ModBounds_4109(n: nat, d: nat)\n requires d > 0\n ensures 0 <= n % d < d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_4110","instance":4110,"id":174109,"goal":"lemma Square_Nonneg_4110(z: real)\n ensures z * z >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_4111","instance":4111,"id":174110,"goal":"lemma AddComm_4111(z: int, a: int)\n ensures z + a == a + z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_4112","instance":4112,"id":174111,"goal":"lemma AddAssoc_4112(m: nat, c: nat, a: nat)\n ensures (m + c) + a == m + (c + a)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_4113","instance":4113,"id":174112,"goal":"lemma MulComm_4113(d: real, y: real)\n ensures d * y == y * d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_4114","instance":4114,"id":174113,"goal":"lemma MulAssoc_4114(i: int, z: int, j: int)\n ensures (i * z) * j == i * (z * j)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_4115","instance":4115,"id":174114,"goal":"lemma Distrib_4115(y: nat, i: nat, a: nat)\n ensures y * (i + a) == y * i + y * a\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_4116","instance":4116,"id":174115,"goal":"lemma AddZero_4116(i: real)\n ensures i + 0 == i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_4117","instance":4117,"id":174116,"goal":"lemma MulOne_4117(k: int)\n ensures k * 1 == k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_4118","instance":4118,"id":174117,"goal":"lemma MulZero_4118(y: nat)\n ensures y * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_4119","instance":4119,"id":174118,"goal":"lemma LeRefl_4119(x: real)\n ensures x <= x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_4120","instance":4120,"id":174119,"goal":"lemma LeTrans_4120(n: int, a: int, y: int)\n requires n <= a && a <= y\n ensures n <= y\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_4121","instance":4121,"id":174120,"goal":"lemma AddMono_4121(j: nat, y: nat, z: nat)\n requires j <= y\n ensures j + z <= y + z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_4122","instance":4122,"id":174121,"goal":"lemma Abs_Nonneg_4122(y: real)\n ensures (if y >= 0 then y else -y) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_4123","instance":4123,"id":174122,"goal":"lemma DivMod_4123(a: int, j: int)\n requires j > 0\n ensures a == j * (a / j) + (a % j)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_4124","instance":4124,"id":174123,"goal":"lemma ModBounds_4124(x: nat, b: nat)\n requires b > 0\n ensures 0 <= x % b < b\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_4125","instance":4125,"id":174124,"goal":"lemma Square_Nonneg_4125(a: real)\n ensures a * a >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_4126","instance":4126,"id":174125,"goal":"lemma AddComm_4126(j: int, n: int)\n ensures j + n == n + j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_4127","instance":4127,"id":174126,"goal":"lemma AddAssoc_4127(k: nat, d: nat, n: nat)\n ensures (k + d) + n == k + (d + n)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_4128","instance":4128,"id":174127,"goal":"lemma MulComm_4128(k: real, d: real)\n ensures k * d == d * k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_4129","instance":4129,"id":174128,"goal":"lemma MulAssoc_4129(n: int, y: int, z: int)\n ensures (n * y) * z == n * (y * z)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_4130","instance":4130,"id":174129,"goal":"lemma Distrib_4130(m: nat, k: nat, j: nat)\n ensures m * (k + j) == m * k + m * j\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_4131","instance":4131,"id":174130,"goal":"lemma AddZero_4131(b: real)\n ensures b + 0 == b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_4132","instance":4132,"id":174131,"goal":"lemma MulOne_4132(j: int)\n ensures j * 1 == j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_4133","instance":4133,"id":174132,"goal":"lemma MulZero_4133(c: nat)\n ensures c * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_4134","instance":4134,"id":174133,"goal":"lemma LeRefl_4134(m: real)\n ensures m <= m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_4135","instance":4135,"id":174134,"goal":"lemma LeTrans_4135(z: int, m: int, i: int)\n requires z <= m && m <= i\n ensures z <= i\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_4136","instance":4136,"id":174135,"goal":"lemma AddMono_4136(b: nat, k: nat, x: nat)\n requires b <= k\n ensures b + x <= k + x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_4137","instance":4137,"id":174136,"goal":"lemma Abs_Nonneg_4137(a: real)\n ensures (if a >= 0 then a else -a) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_4138","instance":4138,"id":174137,"goal":"lemma DivMod_4138(b: int, i: int)\n requires i > 0\n ensures b == i * (b / i) + (b % i)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_4139","instance":4139,"id":174138,"goal":"lemma ModBounds_4139(m: nat, k: nat)\n requires k > 0\n ensures 0 <= m % k < k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_4140","instance":4140,"id":174139,"goal":"lemma Square_Nonneg_4140(b: real)\n ensures b * b >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_4141","instance":4141,"id":174140,"goal":"lemma AddComm_4141(j: int, m: int)\n ensures j + m == m + j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_4142","instance":4142,"id":174141,"goal":"lemma AddAssoc_4142(m: nat, b: nat, j: nat)\n ensures (m + b) + j == m + (b + j)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_4143","instance":4143,"id":174142,"goal":"lemma MulComm_4143(a: real, z: real)\n ensures a * z == z * a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_4144","instance":4144,"id":174143,"goal":"lemma MulAssoc_4144(d: int, b: int, x: int)\n ensures (d * b) * x == d * (b * x)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_4145","instance":4145,"id":174144,"goal":"lemma Distrib_4145(y: nat, x: nat, c: nat)\n ensures y * (x + c) == y * x + y * c\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_4146","instance":4146,"id":174145,"goal":"lemma AddZero_4146(a: real)\n ensures a + 0 == a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_4147","instance":4147,"id":174146,"goal":"lemma MulOne_4147(y: int)\n ensures y * 1 == y\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_4148","instance":4148,"id":174147,"goal":"lemma MulZero_4148(c: nat)\n ensures c * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_4149","instance":4149,"id":174148,"goal":"lemma LeRefl_4149(k: real)\n ensures k <= k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_4150","instance":4150,"id":174149,"goal":"lemma LeTrans_4150(d: int, i: int, j: int)\n requires d <= i && i <= j\n ensures d <= j\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_4151","instance":4151,"id":174150,"goal":"lemma AddMono_4151(x: nat, c: nat, k: nat)\n requires x <= c\n ensures x + k <= c + k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_4152","instance":4152,"id":174151,"goal":"lemma Abs_Nonneg_4152(b: real)\n ensures (if b >= 0 then b else -b) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_4153","instance":4153,"id":174152,"goal":"lemma DivMod_4153(z: int, m: int)\n requires m > 0\n ensures z == m * (z / m) + (z % m)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_4154","instance":4154,"id":174153,"goal":"lemma ModBounds_4154(d: nat, k: nat)\n requires k > 0\n ensures 0 <= d % k < k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_4155","instance":4155,"id":174154,"goal":"lemma Square_Nonneg_4155(m: real)\n ensures m * m >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_4156","instance":4156,"id":174155,"goal":"lemma AddComm_4156(c: int, j: int)\n ensures c + j == j + c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_4157","instance":4157,"id":174156,"goal":"lemma AddAssoc_4157(d: nat, x: nat, m: nat)\n ensures (d + x) + m == d + (x + m)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_4158","instance":4158,"id":174157,"goal":"lemma MulComm_4158(y: real, d: real)\n ensures y * d == d * y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_4159","instance":4159,"id":174158,"goal":"lemma MulAssoc_4159(m: int, x: int, j: int)\n ensures (m * x) * j == m * (x * j)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_4160","instance":4160,"id":174159,"goal":"lemma Distrib_4160(m: nat, a: nat, d: nat)\n ensures m * (a + d) == m * a + m * d\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_4161","instance":4161,"id":174160,"goal":"lemma AddZero_4161(z: real)\n ensures z + 0 == z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_4162","instance":4162,"id":174161,"goal":"lemma MulOne_4162(b: int)\n ensures b * 1 == b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_4163","instance":4163,"id":174162,"goal":"lemma MulZero_4163(b: nat)\n ensures b * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_4164","instance":4164,"id":174163,"goal":"lemma LeRefl_4164(a: real)\n ensures a <= a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_4165","instance":4165,"id":174164,"goal":"lemma LeTrans_4165(b: int, n: int, m: int)\n requires b <= n && n <= m\n ensures b <= m\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_4166","instance":4166,"id":174165,"goal":"lemma AddMono_4166(y: nat, z: nat, x: nat)\n requires y <= z\n ensures y + x <= z + x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_4167","instance":4167,"id":174166,"goal":"lemma Abs_Nonneg_4167(a: real)\n ensures (if a >= 0 then a else -a) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_4168","instance":4168,"id":174167,"goal":"lemma DivMod_4168(b: int, a: int)\n requires a > 0\n ensures b == a * (b / a) + (b % a)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_4169","instance":4169,"id":174168,"goal":"lemma ModBounds_4169(d: nat, y: nat)\n requires y > 0\n ensures 0 <= d % y < y\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_4170","instance":4170,"id":174169,"goal":"lemma Square_Nonneg_4170(k: real)\n ensures k * k >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_4171","instance":4171,"id":174170,"goal":"lemma AddComm_4171(d: int, n: int)\n ensures d + n == n + d\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_4172","instance":4172,"id":174171,"goal":"lemma AddAssoc_4172(z: nat, y: nat, d: nat)\n ensures (z + y) + d == z + (y + d)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_4173","instance":4173,"id":174172,"goal":"lemma MulComm_4173(j: real, c: real)\n ensures j * c == c * j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_4174","instance":4174,"id":174173,"goal":"lemma MulAssoc_4174(j: int, m: int, x: int)\n ensures (j * m) * x == j * (m * x)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_4175","instance":4175,"id":174174,"goal":"lemma Distrib_4175(d: nat, x: nat, a: nat)\n ensures d * (x + a) == d * x + d * a\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_4176","instance":4176,"id":174175,"goal":"lemma AddZero_4176(d: real)\n ensures d + 0 == d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_4177","instance":4177,"id":174176,"goal":"lemma MulOne_4177(x: int)\n ensures x * 1 == x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_4178","instance":4178,"id":174177,"goal":"lemma MulZero_4178(m: nat)\n ensures m * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_4179","instance":4179,"id":174178,"goal":"lemma LeRefl_4179(b: real)\n ensures b <= b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_4180","instance":4180,"id":174179,"goal":"lemma LeTrans_4180(k: int, d: int, x: int)\n requires k <= d && d <= x\n ensures k <= x\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_4181","instance":4181,"id":174180,"goal":"lemma AddMono_4181(z: nat, a: nat, k: nat)\n requires z <= a\n ensures z + k <= a + k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_4182","instance":4182,"id":174181,"goal":"lemma Abs_Nonneg_4182(i: real)\n ensures (if i >= 0 then i else -i) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_4183","instance":4183,"id":174182,"goal":"lemma DivMod_4183(k: int, d: int)\n requires d > 0\n ensures k == d * (k / d) + (k % d)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_4184","instance":4184,"id":174183,"goal":"lemma ModBounds_4184(b: nat, d: nat)\n requires d > 0\n ensures 0 <= b % d < d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_4185","instance":4185,"id":174184,"goal":"lemma Square_Nonneg_4185(i: real)\n ensures i * i >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_4186","instance":4186,"id":174185,"goal":"lemma AddComm_4186(m: int, y: int)\n ensures m + y == y + m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_4187","instance":4187,"id":174186,"goal":"lemma AddAssoc_4187(y: nat, n: nat, z: nat)\n ensures (y + n) + z == y + (n + z)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_4188","instance":4188,"id":174187,"goal":"lemma MulComm_4188(k: real, n: real)\n ensures k * n == n * k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_4189","instance":4189,"id":174188,"goal":"lemma MulAssoc_4189(d: int, n: int, i: int)\n ensures (d * n) * i == d * (n * i)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_4190","instance":4190,"id":174189,"goal":"lemma Distrib_4190(y: nat, n: nat, z: nat)\n ensures y * (n + z) == y * n + y * z\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_4191","instance":4191,"id":174190,"goal":"lemma AddZero_4191(i: real)\n ensures i + 0 == i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_4192","instance":4192,"id":174191,"goal":"lemma MulOne_4192(x: int)\n ensures x * 1 == x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_4193","instance":4193,"id":174192,"goal":"lemma MulZero_4193(j: nat)\n ensures j * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_4194","instance":4194,"id":174193,"goal":"lemma LeRefl_4194(y: real)\n ensures y <= y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_4195","instance":4195,"id":174194,"goal":"lemma LeTrans_4195(b: int, i: int, n: int)\n requires b <= i && i <= n\n ensures b <= n\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_4196","instance":4196,"id":174195,"goal":"lemma AddMono_4196(z: nat, x: nat, b: nat)\n requires z <= x\n ensures z + b <= x + b\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_4197","instance":4197,"id":174196,"goal":"lemma Abs_Nonneg_4197(b: real)\n ensures (if b >= 0 then b else -b) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_4198","instance":4198,"id":174197,"goal":"lemma DivMod_4198(n: int, m: int)\n requires m > 0\n ensures n == m * (n / m) + (n % m)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_4199","instance":4199,"id":174198,"goal":"lemma ModBounds_4199(i: nat, z: nat)\n requires z > 0\n ensures 0 <= i % z < z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_4200","instance":4200,"id":174199,"goal":"lemma Square_Nonneg_4200(d: real)\n ensures d * d >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_4201","instance":4201,"id":174200,"goal":"lemma AddComm_4201(x: int, a: int)\n ensures x + a == a + x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_4202","instance":4202,"id":174201,"goal":"lemma AddAssoc_4202(b: nat, c: nat, z: nat)\n ensures (b + c) + z == b + (c + z)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_4203","instance":4203,"id":174202,"goal":"lemma MulComm_4203(k: real, x: real)\n ensures k * x == x * k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_4204","instance":4204,"id":174203,"goal":"lemma MulAssoc_4204(k: int, n: int, d: int)\n ensures (k * n) * d == k * (n * d)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_4205","instance":4205,"id":174204,"goal":"lemma Distrib_4205(a: nat, k: nat, j: nat)\n ensures a * (k + j) == a * k + a * j\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_4206","instance":4206,"id":174205,"goal":"lemma AddZero_4206(y: real)\n ensures y + 0 == y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_4207","instance":4207,"id":174206,"goal":"lemma MulOne_4207(c: int)\n ensures c * 1 == c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_4208","instance":4208,"id":174207,"goal":"lemma MulZero_4208(y: nat)\n ensures y * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_4209","instance":4209,"id":174208,"goal":"lemma LeRefl_4209(x: real)\n ensures x <= x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_4210","instance":4210,"id":174209,"goal":"lemma LeTrans_4210(x: int, k: int, z: int)\n requires x <= k && k <= z\n ensures x <= z\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_4211","instance":4211,"id":174210,"goal":"lemma AddMono_4211(k: nat, c: nat, a: nat)\n requires k <= c\n ensures k + a <= c + a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_4212","instance":4212,"id":174211,"goal":"lemma Abs_Nonneg_4212(z: real)\n ensures (if z >= 0 then z else -z) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_4213","instance":4213,"id":174212,"goal":"lemma DivMod_4213(a: int, m: int)\n requires m > 0\n ensures a == m * (a / m) + (a % m)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_4214","instance":4214,"id":174213,"goal":"lemma ModBounds_4214(c: nat, x: nat)\n requires x > 0\n ensures 0 <= c % x < x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_4215","instance":4215,"id":174214,"goal":"lemma Square_Nonneg_4215(i: real)\n ensures i * i >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_4216","instance":4216,"id":174215,"goal":"lemma AddComm_4216(z: int, j: int)\n ensures z + j == j + z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_4217","instance":4217,"id":174216,"goal":"lemma AddAssoc_4217(n: nat, z: nat, y: nat)\n ensures (n + z) + y == n + (z + y)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_4218","instance":4218,"id":174217,"goal":"lemma MulComm_4218(x: real, z: real)\n ensures x * z == z * x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_4219","instance":4219,"id":174218,"goal":"lemma MulAssoc_4219(n: int, y: int, d: int)\n ensures (n * y) * d == n * (y * d)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_4220","instance":4220,"id":174219,"goal":"lemma Distrib_4220(y: nat, x: nat, c: nat)\n ensures y * (x + c) == y * x + y * c\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_4221","instance":4221,"id":174220,"goal":"lemma AddZero_4221(m: real)\n ensures m + 0 == m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_4222","instance":4222,"id":174221,"goal":"lemma MulOne_4222(k: int)\n ensures k * 1 == k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_4223","instance":4223,"id":174222,"goal":"lemma MulZero_4223(m: nat)\n ensures m * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_4224","instance":4224,"id":174223,"goal":"lemma LeRefl_4224(k: real)\n ensures k <= k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_4225","instance":4225,"id":174224,"goal":"lemma LeTrans_4225(y: int, c: int, n: int)\n requires y <= c && c <= n\n ensures y <= n\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_4226","instance":4226,"id":174225,"goal":"lemma AddMono_4226(j: nat, a: nat, b: nat)\n requires j <= a\n ensures j + b <= a + b\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_4227","instance":4227,"id":174226,"goal":"lemma Abs_Nonneg_4227(b: real)\n ensures (if b >= 0 then b else -b) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_4228","instance":4228,"id":174227,"goal":"lemma DivMod_4228(b: int, k: int)\n requires k > 0\n ensures b == k * (b / k) + (b % k)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_4229","instance":4229,"id":174228,"goal":"lemma ModBounds_4229(a: nat, j: nat)\n requires j > 0\n ensures 0 <= a % j < j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_4230","instance":4230,"id":174229,"goal":"lemma Square_Nonneg_4230(y: real)\n ensures y * y >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_4231","instance":4231,"id":174230,"goal":"lemma AddComm_4231(a: int, j: int)\n ensures a + j == j + a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_4232","instance":4232,"id":174231,"goal":"lemma AddAssoc_4232(a: nat, k: nat, j: nat)\n ensures (a + k) + j == a + (k + j)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_4233","instance":4233,"id":174232,"goal":"lemma MulComm_4233(k: real, c: real)\n ensures k * c == c * k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_4234","instance":4234,"id":174233,"goal":"lemma MulAssoc_4234(z: int, j: int, y: int)\n ensures (z * j) * y == z * (j * y)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_4235","instance":4235,"id":174234,"goal":"lemma Distrib_4235(c: nat, z: nat, k: nat)\n ensures c * (z + k) == c * z + c * k\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_4236","instance":4236,"id":174235,"goal":"lemma AddZero_4236(m: real)\n ensures m + 0 == m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_4237","instance":4237,"id":174236,"goal":"lemma MulOne_4237(c: int)\n ensures c * 1 == c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_4238","instance":4238,"id":174237,"goal":"lemma MulZero_4238(d: nat)\n ensures d * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_4239","instance":4239,"id":174238,"goal":"lemma LeRefl_4239(x: real)\n ensures x <= x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_4240","instance":4240,"id":174239,"goal":"lemma LeTrans_4240(k: int, i: int, a: int)\n requires k <= i && i <= a\n ensures k <= a\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_4241","instance":4241,"id":174240,"goal":"lemma AddMono_4241(a: nat, y: nat, n: nat)\n requires a <= y\n ensures a + n <= y + n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_4242","instance":4242,"id":174241,"goal":"lemma Abs_Nonneg_4242(i: real)\n ensures (if i >= 0 then i else -i) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_4243","instance":4243,"id":174242,"goal":"lemma DivMod_4243(n: int, y: int)\n requires y > 0\n ensures n == y * (n / y) + (n % y)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_4244","instance":4244,"id":174243,"goal":"lemma ModBounds_4244(n: nat, k: nat)\n requires k > 0\n ensures 0 <= n % k < k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_4245","instance":4245,"id":174244,"goal":"lemma Square_Nonneg_4245(c: real)\n ensures c * c >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_4246","instance":4246,"id":174245,"goal":"lemma AddComm_4246(k: int, n: int)\n ensures k + n == n + k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_4247","instance":4247,"id":174246,"goal":"lemma AddAssoc_4247(i: nat, x: nat, b: nat)\n ensures (i + x) + b == i + (x + b)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_4248","instance":4248,"id":174247,"goal":"lemma MulComm_4248(y: real, b: real)\n ensures y * b == b * y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_4249","instance":4249,"id":174248,"goal":"lemma MulAssoc_4249(a: int, y: int, d: int)\n ensures (a * y) * d == a * (y * d)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_4250","instance":4250,"id":174249,"goal":"lemma Distrib_4250(k: nat, i: nat, z: nat)\n ensures k * (i + z) == k * i + k * z\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_4251","instance":4251,"id":174250,"goal":"lemma AddZero_4251(c: real)\n ensures c + 0 == c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_4252","instance":4252,"id":174251,"goal":"lemma MulOne_4252(y: int)\n ensures y * 1 == y\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_4253","instance":4253,"id":174252,"goal":"lemma MulZero_4253(k: nat)\n ensures k * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_4254","instance":4254,"id":174253,"goal":"lemma LeRefl_4254(n: real)\n ensures n <= n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_4255","instance":4255,"id":174254,"goal":"lemma LeTrans_4255(c: int, m: int, k: int)\n requires c <= m && m <= k\n ensures c <= k\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_4256","instance":4256,"id":174255,"goal":"lemma AddMono_4256(b: nat, m: nat, n: nat)\n requires b <= m\n ensures b + n <= m + n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_4257","instance":4257,"id":174256,"goal":"lemma Abs_Nonneg_4257(i: real)\n ensures (if i >= 0 then i else -i) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_4258","instance":4258,"id":174257,"goal":"lemma DivMod_4258(z: int, d: int)\n requires d > 0\n ensures z == d * (z / d) + (z % d)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_4259","instance":4259,"id":174258,"goal":"lemma ModBounds_4259(b: nat, c: nat)\n requires c > 0\n ensures 0 <= b % c < c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_4260","instance":4260,"id":174259,"goal":"lemma Square_Nonneg_4260(n: real)\n ensures n * n >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_4261","instance":4261,"id":174260,"goal":"lemma AddComm_4261(n: int, m: int)\n ensures n + m == m + n\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_4262","instance":4262,"id":174261,"goal":"lemma AddAssoc_4262(x: nat, m: nat, k: nat)\n ensures (x + m) + k == x + (m + k)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_4263","instance":4263,"id":174262,"goal":"lemma MulComm_4263(c: real, m: real)\n ensures c * m == m * c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_4264","instance":4264,"id":174263,"goal":"lemma MulAssoc_4264(d: int, k: int, b: int)\n ensures (d * k) * b == d * (k * b)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_4265","instance":4265,"id":174264,"goal":"lemma Distrib_4265(j: nat, i: nat, z: nat)\n ensures j * (i + z) == j * i + j * z\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_4266","instance":4266,"id":174265,"goal":"lemma AddZero_4266(d: real)\n ensures d + 0 == d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_4267","instance":4267,"id":174266,"goal":"lemma MulOne_4267(i: int)\n ensures i * 1 == i\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_4268","instance":4268,"id":174267,"goal":"lemma MulZero_4268(k: nat)\n ensures k * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_4269","instance":4269,"id":174268,"goal":"lemma LeRefl_4269(j: real)\n ensures j <= j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_4270","instance":4270,"id":174269,"goal":"lemma LeTrans_4270(k: int, d: int, z: int)\n requires k <= d && d <= z\n ensures k <= z\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_4271","instance":4271,"id":174270,"goal":"lemma AddMono_4271(k: nat, i: nat, n: nat)\n requires k <= i\n ensures k + n <= i + n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_4272","instance":4272,"id":174271,"goal":"lemma Abs_Nonneg_4272(k: real)\n ensures (if k >= 0 then k else -k) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_4273","instance":4273,"id":174272,"goal":"lemma DivMod_4273(i: int, j: int)\n requires j > 0\n ensures i == j * (i / j) + (i % j)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_4274","instance":4274,"id":174273,"goal":"lemma ModBounds_4274(n: nat, d: nat)\n requires d > 0\n ensures 0 <= n % d < d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_4275","instance":4275,"id":174274,"goal":"lemma Square_Nonneg_4275(n: real)\n ensures n * n >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_4276","instance":4276,"id":174275,"goal":"lemma AddComm_4276(x: int, c: int)\n ensures x + c == c + x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_4277","instance":4277,"id":174276,"goal":"lemma AddAssoc_4277(b: nat, m: nat, z: nat)\n ensures (b + m) + z == b + (m + z)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_4278","instance":4278,"id":174277,"goal":"lemma MulComm_4278(y: real, i: real)\n ensures y * i == i * y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_4279","instance":4279,"id":174278,"goal":"lemma MulAssoc_4279(n: int, i: int, d: int)\n ensures (n * i) * d == n * (i * d)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_4280","instance":4280,"id":174279,"goal":"lemma Distrib_4280(d: nat, j: nat, c: nat)\n ensures d * (j + c) == d * j + d * c\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_4281","instance":4281,"id":174280,"goal":"lemma AddZero_4281(k: real)\n ensures k + 0 == k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_4282","instance":4282,"id":174281,"goal":"lemma MulOne_4282(k: int)\n ensures k * 1 == k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_4283","instance":4283,"id":174282,"goal":"lemma MulZero_4283(m: nat)\n ensures m * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_4284","instance":4284,"id":174283,"goal":"lemma LeRefl_4284(i: real)\n ensures i <= i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_4285","instance":4285,"id":174284,"goal":"lemma LeTrans_4285(j: int, x: int, m: int)\n requires j <= x && x <= m\n ensures j <= m\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_4286","instance":4286,"id":174285,"goal":"lemma AddMono_4286(c: nat, i: nat, a: nat)\n requires c <= i\n ensures c + a <= i + a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_4287","instance":4287,"id":174286,"goal":"lemma Abs_Nonneg_4287(c: real)\n ensures (if c >= 0 then c else -c) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_4288","instance":4288,"id":174287,"goal":"lemma DivMod_4288(j: int, z: int)\n requires z > 0\n ensures j == z * (j / z) + (j % z)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_4289","instance":4289,"id":174288,"goal":"lemma ModBounds_4289(a: nat, i: nat)\n requires i > 0\n ensures 0 <= a % i < i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_4290","instance":4290,"id":174289,"goal":"lemma Square_Nonneg_4290(x: real)\n ensures x * x >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_4291","instance":4291,"id":174290,"goal":"lemma AddComm_4291(i: int, y: int)\n ensures i + y == y + i\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_4292","instance":4292,"id":174291,"goal":"lemma AddAssoc_4292(c: nat, k: nat, n: nat)\n ensures (c + k) + n == c + (k + n)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_4293","instance":4293,"id":174292,"goal":"lemma MulComm_4293(a: real, c: real)\n ensures a * c == c * a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_4294","instance":4294,"id":174293,"goal":"lemma MulAssoc_4294(i: int, c: int, x: int)\n ensures (i * c) * x == i * (c * x)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_4295","instance":4295,"id":174294,"goal":"lemma Distrib_4295(m: nat, z: nat, c: nat)\n ensures m * (z + c) == m * z + m * c\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_4296","instance":4296,"id":174295,"goal":"lemma AddZero_4296(j: real)\n ensures j + 0 == j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_4297","instance":4297,"id":174296,"goal":"lemma MulOne_4297(j: int)\n ensures j * 1 == j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_4298","instance":4298,"id":174297,"goal":"lemma MulZero_4298(n: nat)\n ensures n * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_4299","instance":4299,"id":174298,"goal":"lemma LeRefl_4299(n: real)\n ensures n <= n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_4300","instance":4300,"id":174299,"goal":"lemma LeTrans_4300(m: int, n: int, a: int)\n requires m <= n && n <= a\n ensures m <= a\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_4301","instance":4301,"id":174300,"goal":"lemma AddMono_4301(y: nat, n: nat, b: nat)\n requires y <= n\n ensures y + b <= n + b\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_4302","instance":4302,"id":174301,"goal":"lemma Abs_Nonneg_4302(b: real)\n ensures (if b >= 0 then b else -b) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_4303","instance":4303,"id":174302,"goal":"lemma DivMod_4303(m: int, b: int)\n requires b > 0\n ensures m == b * (m / b) + (m % b)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_4304","instance":4304,"id":174303,"goal":"lemma ModBounds_4304(a: nat, c: nat)\n requires c > 0\n ensures 0 <= a % c < c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_4305","instance":4305,"id":174304,"goal":"lemma Square_Nonneg_4305(c: real)\n ensures c * c >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_4306","instance":4306,"id":174305,"goal":"lemma AddComm_4306(y: int, m: int)\n ensures y + m == m + y\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_4307","instance":4307,"id":174306,"goal":"lemma AddAssoc_4307(y: nat, x: nat, c: nat)\n ensures (y + x) + c == y + (x + c)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_4308","instance":4308,"id":174307,"goal":"lemma MulComm_4308(c: real, k: real)\n ensures c * k == k * c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_4309","instance":4309,"id":174308,"goal":"lemma MulAssoc_4309(z: int, k: int, j: int)\n ensures (z * k) * j == z * (k * j)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_4310","instance":4310,"id":174309,"goal":"lemma Distrib_4310(k: nat, z: nat, b: nat)\n ensures k * (z + b) == k * z + k * b\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_4311","instance":4311,"id":174310,"goal":"lemma AddZero_4311(k: real)\n ensures k + 0 == k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_4312","instance":4312,"id":174311,"goal":"lemma MulOne_4312(d: int)\n ensures d * 1 == d\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_4313","instance":4313,"id":174312,"goal":"lemma MulZero_4313(a: nat)\n ensures a * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_4314","instance":4314,"id":174313,"goal":"lemma LeRefl_4314(n: real)\n ensures n <= n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_4315","instance":4315,"id":174314,"goal":"lemma LeTrans_4315(n: int, j: int, d: int)\n requires n <= j && j <= d\n ensures n <= d\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_4316","instance":4316,"id":174315,"goal":"lemma AddMono_4316(i: nat, z: nat, b: nat)\n requires i <= z\n ensures i + b <= z + b\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_4317","instance":4317,"id":174316,"goal":"lemma Abs_Nonneg_4317(z: real)\n ensures (if z >= 0 then z else -z) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_4318","instance":4318,"id":174317,"goal":"lemma DivMod_4318(d: int, a: int)\n requires a > 0\n ensures d == a * (d / a) + (d % a)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_4319","instance":4319,"id":174318,"goal":"lemma ModBounds_4319(n: nat, c: nat)\n requires c > 0\n ensures 0 <= n % c < c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_4320","instance":4320,"id":174319,"goal":"lemma Square_Nonneg_4320(b: real)\n ensures b * b >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_4321","instance":4321,"id":174320,"goal":"lemma AddComm_4321(j: int, d: int)\n ensures j + d == d + j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_4322","instance":4322,"id":174321,"goal":"lemma AddAssoc_4322(i: nat, a: nat, m: nat)\n ensures (i + a) + m == i + (a + m)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_4323","instance":4323,"id":174322,"goal":"lemma MulComm_4323(a: real, y: real)\n ensures a * y == y * a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_4324","instance":4324,"id":174323,"goal":"lemma MulAssoc_4324(a: int, c: int, n: int)\n ensures (a * c) * n == a * (c * n)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_4325","instance":4325,"id":174324,"goal":"lemma Distrib_4325(k: nat, m: nat, z: nat)\n ensures k * (m + z) == k * m + k * z\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_4326","instance":4326,"id":174325,"goal":"lemma AddZero_4326(y: real)\n ensures y + 0 == y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_4327","instance":4327,"id":174326,"goal":"lemma MulOne_4327(m: int)\n ensures m * 1 == m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_4328","instance":4328,"id":174327,"goal":"lemma MulZero_4328(j: nat)\n ensures j * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_4329","instance":4329,"id":174328,"goal":"lemma LeRefl_4329(n: real)\n ensures n <= n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_4330","instance":4330,"id":174329,"goal":"lemma LeTrans_4330(c: int, m: int, a: int)\n requires c <= m && m <= a\n ensures c <= a\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_4331","instance":4331,"id":174330,"goal":"lemma AddMono_4331(c: nat, i: nat, z: nat)\n requires c <= i\n ensures c + z <= i + z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_4332","instance":4332,"id":174331,"goal":"lemma Abs_Nonneg_4332(c: real)\n ensures (if c >= 0 then c else -c) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_4333","instance":4333,"id":174332,"goal":"lemma DivMod_4333(m: int, n: int)\n requires n > 0\n ensures m == n * (m / n) + (m % n)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_4334","instance":4334,"id":174333,"goal":"lemma ModBounds_4334(c: nat, n: nat)\n requires n > 0\n ensures 0 <= c % n < n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_4335","instance":4335,"id":174334,"goal":"lemma Square_Nonneg_4335(k: real)\n ensures k * k >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_4336","instance":4336,"id":174335,"goal":"lemma AddComm_4336(d: int, a: int)\n ensures d + a == a + d\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_4337","instance":4337,"id":174336,"goal":"lemma AddAssoc_4337(m: nat, k: nat, i: nat)\n ensures (m + k) + i == m + (k + i)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_4338","instance":4338,"id":174337,"goal":"lemma MulComm_4338(k: real, m: real)\n ensures k * m == m * k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_4339","instance":4339,"id":174338,"goal":"lemma MulAssoc_4339(c: int, m: int, n: int)\n ensures (c * m) * n == c * (m * n)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_4340","instance":4340,"id":174339,"goal":"lemma Distrib_4340(x: nat, y: nat, c: nat)\n ensures x * (y + c) == x * y + x * c\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_4341","instance":4341,"id":174340,"goal":"lemma AddZero_4341(i: real)\n ensures i + 0 == i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_4342","instance":4342,"id":174341,"goal":"lemma MulOne_4342(j: int)\n ensures j * 1 == j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_4343","instance":4343,"id":174342,"goal":"lemma MulZero_4343(z: nat)\n ensures z * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_4344","instance":4344,"id":174343,"goal":"lemma LeRefl_4344(z: real)\n ensures z <= z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_4345","instance":4345,"id":174344,"goal":"lemma LeTrans_4345(b: int, j: int, d: int)\n requires b <= j && j <= d\n ensures b <= d\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_4346","instance":4346,"id":174345,"goal":"lemma AddMono_4346(n: nat, x: nat, y: nat)\n requires n <= x\n ensures n + y <= x + y\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_4347","instance":4347,"id":174346,"goal":"lemma Abs_Nonneg_4347(y: real)\n ensures (if y >= 0 then y else -y) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_4348","instance":4348,"id":174347,"goal":"lemma DivMod_4348(m: int, d: int)\n requires d > 0\n ensures m == d * (m / d) + (m % d)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_4349","instance":4349,"id":174348,"goal":"lemma ModBounds_4349(n: nat, z: nat)\n requires z > 0\n ensures 0 <= n % z < z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_4350","instance":4350,"id":174349,"goal":"lemma Square_Nonneg_4350(m: real)\n ensures m * m >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_4351","instance":4351,"id":174350,"goal":"lemma AddComm_4351(y: int, b: int)\n ensures y + b == b + y\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_4352","instance":4352,"id":174351,"goal":"lemma AddAssoc_4352(a: nat, b: nat, x: nat)\n ensures (a + b) + x == a + (b + x)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_4353","instance":4353,"id":174352,"goal":"lemma MulComm_4353(k: real, j: real)\n ensures k * j == j * k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_4354","instance":4354,"id":174353,"goal":"lemma MulAssoc_4354(d: int, n: int, i: int)\n ensures (d * n) * i == d * (n * i)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_4355","instance":4355,"id":174354,"goal":"lemma Distrib_4355(j: nat, m: nat, a: nat)\n ensures j * (m + a) == j * m + j * a\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_4356","instance":4356,"id":174355,"goal":"lemma AddZero_4356(c: real)\n ensures c + 0 == c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_4357","instance":4357,"id":174356,"goal":"lemma MulOne_4357(c: int)\n ensures c * 1 == c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_4358","instance":4358,"id":174357,"goal":"lemma MulZero_4358(c: nat)\n ensures c * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_4359","instance":4359,"id":174358,"goal":"lemma LeRefl_4359(m: real)\n ensures m <= m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_4360","instance":4360,"id":174359,"goal":"lemma LeTrans_4360(n: int, b: int, m: int)\n requires n <= b && b <= m\n ensures n <= m\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_4361","instance":4361,"id":174360,"goal":"lemma AddMono_4361(x: nat, a: nat, z: nat)\n requires x <= a\n ensures x + z <= a + z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_4362","instance":4362,"id":174361,"goal":"lemma Abs_Nonneg_4362(i: real)\n ensures (if i >= 0 then i else -i) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_4363","instance":4363,"id":174362,"goal":"lemma DivMod_4363(b: int, j: int)\n requires j > 0\n ensures b == j * (b / j) + (b % j)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_4364","instance":4364,"id":174363,"goal":"lemma ModBounds_4364(d: nat, z: nat)\n requires z > 0\n ensures 0 <= d % z < z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_4365","instance":4365,"id":174364,"goal":"lemma Square_Nonneg_4365(x: real)\n ensures x * x >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_4366","instance":4366,"id":174365,"goal":"lemma AddComm_4366(z: int, i: int)\n ensures z + i == i + z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_4367","instance":4367,"id":174366,"goal":"lemma AddAssoc_4367(b: nat, d: nat, j: nat)\n ensures (b + d) + j == b + (d + j)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_4368","instance":4368,"id":174367,"goal":"lemma MulComm_4368(j: real, x: real)\n ensures j * x == x * j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_4369","instance":4369,"id":174368,"goal":"lemma MulAssoc_4369(j: int, n: int, z: int)\n ensures (j * n) * z == j * (n * z)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_4370","instance":4370,"id":174369,"goal":"lemma Distrib_4370(m: nat, n: nat, k: nat)\n ensures m * (n + k) == m * n + m * k\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_4371","instance":4371,"id":174370,"goal":"lemma AddZero_4371(a: real)\n ensures a + 0 == a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_4372","instance":4372,"id":174371,"goal":"lemma MulOne_4372(b: int)\n ensures b * 1 == b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_4373","instance":4373,"id":174372,"goal":"lemma MulZero_4373(d: nat)\n ensures d * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_4374","instance":4374,"id":174373,"goal":"lemma LeRefl_4374(z: real)\n ensures z <= z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_4375","instance":4375,"id":174374,"goal":"lemma LeTrans_4375(d: int, y: int, m: int)\n requires d <= y && y <= m\n ensures d <= m\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_4376","instance":4376,"id":174375,"goal":"lemma AddMono_4376(n: nat, b: nat, x: nat)\n requires n <= b\n ensures n + x <= b + x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_4377","instance":4377,"id":174376,"goal":"lemma Abs_Nonneg_4377(a: real)\n ensures (if a >= 0 then a else -a) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_4378","instance":4378,"id":174377,"goal":"lemma DivMod_4378(y: int, d: int)\n requires d > 0\n ensures y == d * (y / d) + (y % d)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_4379","instance":4379,"id":174378,"goal":"lemma ModBounds_4379(x: nat, a: nat)\n requires a > 0\n ensures 0 <= x % a < a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_4380","instance":4380,"id":174379,"goal":"lemma Square_Nonneg_4380(d: real)\n ensures d * d >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_4381","instance":4381,"id":174380,"goal":"lemma AddComm_4381(m: int, b: int)\n ensures m + b == b + m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_4382","instance":4382,"id":174381,"goal":"lemma AddAssoc_4382(k: nat, c: nat, y: nat)\n ensures (k + c) + y == k + (c + y)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_4383","instance":4383,"id":174382,"goal":"lemma MulComm_4383(n: real, b: real)\n ensures n * b == b * n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_4384","instance":4384,"id":174383,"goal":"lemma MulAssoc_4384(m: int, j: int, c: int)\n ensures (m * j) * c == m * (j * c)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_4385","instance":4385,"id":174384,"goal":"lemma Distrib_4385(m: nat, x: nat, j: nat)\n ensures m * (x + j) == m * x + m * j\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_4386","instance":4386,"id":174385,"goal":"lemma AddZero_4386(d: real)\n ensures d + 0 == d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_4387","instance":4387,"id":174386,"goal":"lemma MulOne_4387(x: int)\n ensures x * 1 == x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_4388","instance":4388,"id":174387,"goal":"lemma MulZero_4388(n: nat)\n ensures n * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_4389","instance":4389,"id":174388,"goal":"lemma LeRefl_4389(j: real)\n ensures j <= j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_4390","instance":4390,"id":174389,"goal":"lemma LeTrans_4390(i: int, d: int, y: int)\n requires i <= d && d <= y\n ensures i <= y\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_4391","instance":4391,"id":174390,"goal":"lemma AddMono_4391(y: nat, x: nat, z: nat)\n requires y <= x\n ensures y + z <= x + z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_4392","instance":4392,"id":174391,"goal":"lemma Abs_Nonneg_4392(b: real)\n ensures (if b >= 0 then b else -b) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_4393","instance":4393,"id":174392,"goal":"lemma DivMod_4393(z: int, n: int)\n requires n > 0\n ensures z == n * (z / n) + (z % n)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_4394","instance":4394,"id":174393,"goal":"lemma ModBounds_4394(b: nat, y: nat)\n requires y > 0\n ensures 0 <= b % y < y\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_4395","instance":4395,"id":174394,"goal":"lemma Square_Nonneg_4395(m: real)\n ensures m * m >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_4396","instance":4396,"id":174395,"goal":"lemma AddComm_4396(c: int, b: int)\n ensures c + b == b + c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_4397","instance":4397,"id":174396,"goal":"lemma AddAssoc_4397(j: nat, i: nat, m: nat)\n ensures (j + i) + m == j + (i + m)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_4398","instance":4398,"id":174397,"goal":"lemma MulComm_4398(z: real, d: real)\n ensures z * d == d * z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_4399","instance":4399,"id":174398,"goal":"lemma MulAssoc_4399(m: int, k: int, z: int)\n ensures (m * k) * z == m * (k * z)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_4400","instance":4400,"id":174399,"goal":"lemma Distrib_4400(z: nat, b: nat, j: nat)\n ensures z * (b + j) == z * b + z * j\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_4401","instance":4401,"id":174400,"goal":"lemma AddZero_4401(b: real)\n ensures b + 0 == b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_4402","instance":4402,"id":174401,"goal":"lemma MulOne_4402(i: int)\n ensures i * 1 == i\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_4403","instance":4403,"id":174402,"goal":"lemma MulZero_4403(x: nat)\n ensures x * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_4404","instance":4404,"id":174403,"goal":"lemma LeRefl_4404(n: real)\n ensures n <= n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_4405","instance":4405,"id":174404,"goal":"lemma LeTrans_4405(d: int, z: int, m: int)\n requires d <= z && z <= m\n ensures d <= m\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_4406","instance":4406,"id":174405,"goal":"lemma AddMono_4406(y: nat, x: nat, i: nat)\n requires y <= x\n ensures y + i <= x + i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_4407","instance":4407,"id":174406,"goal":"lemma Abs_Nonneg_4407(z: real)\n ensures (if z >= 0 then z else -z) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_4408","instance":4408,"id":174407,"goal":"lemma DivMod_4408(m: int, b: int)\n requires b > 0\n ensures m == b * (m / b) + (m % b)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_4409","instance":4409,"id":174408,"goal":"lemma ModBounds_4409(i: nat, k: nat)\n requires k > 0\n ensures 0 <= i % k < k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_4410","instance":4410,"id":174409,"goal":"lemma Square_Nonneg_4410(n: real)\n ensures n * n >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_4411","instance":4411,"id":174410,"goal":"lemma AddComm_4411(c: int, m: int)\n ensures c + m == m + c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_4412","instance":4412,"id":174411,"goal":"lemma AddAssoc_4412(m: nat, y: nat, k: nat)\n ensures (m + y) + k == m + (y + k)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_4413","instance":4413,"id":174412,"goal":"lemma MulComm_4413(b: real, i: real)\n ensures b * i == i * b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_4414","instance":4414,"id":174413,"goal":"lemma MulAssoc_4414(n: int, a: int, d: int)\n ensures (n * a) * d == n * (a * d)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_4415","instance":4415,"id":174414,"goal":"lemma Distrib_4415(j: nat, i: nat, y: nat)\n ensures j * (i + y) == j * i + j * y\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_4416","instance":4416,"id":174415,"goal":"lemma AddZero_4416(d: real)\n ensures d + 0 == d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_4417","instance":4417,"id":174416,"goal":"lemma MulOne_4417(d: int)\n ensures d * 1 == d\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_4418","instance":4418,"id":174417,"goal":"lemma MulZero_4418(n: nat)\n ensures n * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_4419","instance":4419,"id":174418,"goal":"lemma LeRefl_4419(j: real)\n ensures j <= j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_4420","instance":4420,"id":174419,"goal":"lemma LeTrans_4420(j: int, z: int, b: int)\n requires j <= z && z <= b\n ensures j <= b\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_4421","instance":4421,"id":174420,"goal":"lemma AddMono_4421(z: nat, j: nat, i: nat)\n requires z <= j\n ensures z + i <= j + i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_4422","instance":4422,"id":174421,"goal":"lemma Abs_Nonneg_4422(z: real)\n ensures (if z >= 0 then z else -z) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_4423","instance":4423,"id":174422,"goal":"lemma DivMod_4423(a: int, n: int)\n requires n > 0\n ensures a == n * (a / n) + (a % n)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_4424","instance":4424,"id":174423,"goal":"lemma ModBounds_4424(d: nat, i: nat)\n requires i > 0\n ensures 0 <= d % i < i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_4425","instance":4425,"id":174424,"goal":"lemma Square_Nonneg_4425(c: real)\n ensures c * c >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_4426","instance":4426,"id":174425,"goal":"lemma AddComm_4426(d: int, a: int)\n ensures d + a == a + d\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_4427","instance":4427,"id":174426,"goal":"lemma AddAssoc_4427(c: nat, a: nat, z: nat)\n ensures (c + a) + z == c + (a + z)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_4428","instance":4428,"id":174427,"goal":"lemma MulComm_4428(x: real, i: real)\n ensures x * i == i * x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_4429","instance":4429,"id":174428,"goal":"lemma MulAssoc_4429(x: int, z: int, c: int)\n ensures (x * z) * c == x * (z * c)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_4430","instance":4430,"id":174429,"goal":"lemma Distrib_4430(y: nat, z: nat, m: nat)\n ensures y * (z + m) == y * z + y * m\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_4431","instance":4431,"id":174430,"goal":"lemma AddZero_4431(a: real)\n ensures a + 0 == a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_4432","instance":4432,"id":174431,"goal":"lemma MulOne_4432(y: int)\n ensures y * 1 == y\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_4433","instance":4433,"id":174432,"goal":"lemma MulZero_4433(a: nat)\n ensures a * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_4434","instance":4434,"id":174433,"goal":"lemma LeRefl_4434(n: real)\n ensures n <= n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_4435","instance":4435,"id":174434,"goal":"lemma LeTrans_4435(c: int, d: int, a: int)\n requires c <= d && d <= a\n ensures c <= a\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_4436","instance":4436,"id":174435,"goal":"lemma AddMono_4436(a: nat, z: nat, y: nat)\n requires a <= z\n ensures a + y <= z + y\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_4437","instance":4437,"id":174436,"goal":"lemma Abs_Nonneg_4437(b: real)\n ensures (if b >= 0 then b else -b) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_4438","instance":4438,"id":174437,"goal":"lemma DivMod_4438(i: int, a: int)\n requires a > 0\n ensures i == a * (i / a) + (i % a)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_4439","instance":4439,"id":174438,"goal":"lemma ModBounds_4439(k: nat, c: nat)\n requires c > 0\n ensures 0 <= k % c < c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_4440","instance":4440,"id":174439,"goal":"lemma Square_Nonneg_4440(k: real)\n ensures k * k >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_4441","instance":4441,"id":174440,"goal":"lemma AddComm_4441(a: int, x: int)\n ensures a + x == x + a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_4442","instance":4442,"id":174441,"goal":"lemma AddAssoc_4442(j: nat, d: nat, m: nat)\n ensures (j + d) + m == j + (d + m)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_4443","instance":4443,"id":174442,"goal":"lemma MulComm_4443(x: real, b: real)\n ensures x * b == b * x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_4444","instance":4444,"id":174443,"goal":"lemma MulAssoc_4444(z: int, c: int, i: int)\n ensures (z * c) * i == z * (c * i)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_4445","instance":4445,"id":174444,"goal":"lemma Distrib_4445(j: nat, y: nat, c: nat)\n ensures j * (y + c) == j * y + j * c\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_4446","instance":4446,"id":174445,"goal":"lemma AddZero_4446(n: real)\n ensures n + 0 == n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_4447","instance":4447,"id":174446,"goal":"lemma MulOne_4447(c: int)\n ensures c * 1 == c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_4448","instance":4448,"id":174447,"goal":"lemma MulZero_4448(a: nat)\n ensures a * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_4449","instance":4449,"id":174448,"goal":"lemma LeRefl_4449(y: real)\n ensures y <= y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_4450","instance":4450,"id":174449,"goal":"lemma LeTrans_4450(n: int, i: int, m: int)\n requires n <= i && i <= m\n ensures n <= m\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_4451","instance":4451,"id":174450,"goal":"lemma AddMono_4451(n: nat, d: nat, y: nat)\n requires n <= d\n ensures n + y <= d + y\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_4452","instance":4452,"id":174451,"goal":"lemma Abs_Nonneg_4452(y: real)\n ensures (if y >= 0 then y else -y) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_4453","instance":4453,"id":174452,"goal":"lemma DivMod_4453(c: int, n: int)\n requires n > 0\n ensures c == n * (c / n) + (c % n)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_4454","instance":4454,"id":174453,"goal":"lemma ModBounds_4454(j: nat, k: nat)\n requires k > 0\n ensures 0 <= j % k < k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_4455","instance":4455,"id":174454,"goal":"lemma Square_Nonneg_4455(j: real)\n ensures j * j >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_4456","instance":4456,"id":174455,"goal":"lemma AddComm_4456(i: int, z: int)\n ensures i + z == z + i\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_4457","instance":4457,"id":174456,"goal":"lemma AddAssoc_4457(d: nat, c: nat, k: nat)\n ensures (d + c) + k == d + (c + k)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_4458","instance":4458,"id":174457,"goal":"lemma MulComm_4458(i: real, c: real)\n ensures i * c == c * i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_4459","instance":4459,"id":174458,"goal":"lemma MulAssoc_4459(c: int, i: int, a: int)\n ensures (c * i) * a == c * (i * a)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_4460","instance":4460,"id":174459,"goal":"lemma Distrib_4460(y: nat, m: nat, a: nat)\n ensures y * (m + a) == y * m + y * a\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_4461","instance":4461,"id":174460,"goal":"lemma AddZero_4461(k: real)\n ensures k + 0 == k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_4462","instance":4462,"id":174461,"goal":"lemma MulOne_4462(z: int)\n ensures z * 1 == z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_4463","instance":4463,"id":174462,"goal":"lemma MulZero_4463(m: nat)\n ensures m * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_4464","instance":4464,"id":174463,"goal":"lemma LeRefl_4464(c: real)\n ensures c <= c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_4465","instance":4465,"id":174464,"goal":"lemma LeTrans_4465(n: int, a: int, z: int)\n requires n <= a && a <= z\n ensures n <= z\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_4466","instance":4466,"id":174465,"goal":"lemma AddMono_4466(b: nat, z: nat, a: nat)\n requires b <= z\n ensures b + a <= z + a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_4467","instance":4467,"id":174466,"goal":"lemma Abs_Nonneg_4467(b: real)\n ensures (if b >= 0 then b else -b) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_4468","instance":4468,"id":174467,"goal":"lemma DivMod_4468(d: int, m: int)\n requires m > 0\n ensures d == m * (d / m) + (d % m)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_4469","instance":4469,"id":174468,"goal":"lemma ModBounds_4469(z: nat, a: nat)\n requires a > 0\n ensures 0 <= z % a < a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_4470","instance":4470,"id":174469,"goal":"lemma Square_Nonneg_4470(n: real)\n ensures n * n >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_4471","instance":4471,"id":174470,"goal":"lemma AddComm_4471(d: int, i: int)\n ensures d + i == i + d\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_4472","instance":4472,"id":174471,"goal":"lemma AddAssoc_4472(j: nat, i: nat, c: nat)\n ensures (j + i) + c == j + (i + c)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_4473","instance":4473,"id":174472,"goal":"lemma MulComm_4473(a: real, d: real)\n ensures a * d == d * a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_4474","instance":4474,"id":174473,"goal":"lemma MulAssoc_4474(n: int, b: int, i: int)\n ensures (n * b) * i == n * (b * i)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_4475","instance":4475,"id":174474,"goal":"lemma Distrib_4475(c: nat, i: nat, a: nat)\n ensures c * (i + a) == c * i + c * a\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_4476","instance":4476,"id":174475,"goal":"lemma AddZero_4476(b: real)\n ensures b + 0 == b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_4477","instance":4477,"id":174476,"goal":"lemma MulOne_4477(i: int)\n ensures i * 1 == i\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_4478","instance":4478,"id":174477,"goal":"lemma MulZero_4478(z: nat)\n ensures z * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_4479","instance":4479,"id":174478,"goal":"lemma LeRefl_4479(a: real)\n ensures a <= a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_4480","instance":4480,"id":174479,"goal":"lemma LeTrans_4480(j: int, b: int, z: int)\n requires j <= b && b <= z\n ensures j <= z\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_4481","instance":4481,"id":174480,"goal":"lemma AddMono_4481(d: nat, n: nat, b: nat)\n requires d <= n\n ensures d + b <= n + b\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_4482","instance":4482,"id":174481,"goal":"lemma Abs_Nonneg_4482(m: real)\n ensures (if m >= 0 then m else -m) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_4483","instance":4483,"id":174482,"goal":"lemma DivMod_4483(i: int, a: int)\n requires a > 0\n ensures i == a * (i / a) + (i % a)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_4484","instance":4484,"id":174483,"goal":"lemma ModBounds_4484(y: nat, b: nat)\n requires b > 0\n ensures 0 <= y % b < b\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_4485","instance":4485,"id":174484,"goal":"lemma Square_Nonneg_4485(c: real)\n ensures c * c >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_4486","instance":4486,"id":174485,"goal":"lemma AddComm_4486(b: int, x: int)\n ensures b + x == x + b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_4487","instance":4487,"id":174486,"goal":"lemma AddAssoc_4487(i: nat, c: nat, k: nat)\n ensures (i + c) + k == i + (c + k)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_4488","instance":4488,"id":174487,"goal":"lemma MulComm_4488(a: real, m: real)\n ensures a * m == m * a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_4489","instance":4489,"id":174488,"goal":"lemma MulAssoc_4489(n: int, k: int, j: int)\n ensures (n * k) * j == n * (k * j)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_4490","instance":4490,"id":174489,"goal":"lemma Distrib_4490(m: nat, i: nat, c: nat)\n ensures m * (i + c) == m * i + m * c\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_4491","instance":4491,"id":174490,"goal":"lemma AddZero_4491(b: real)\n ensures b + 0 == b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_4492","instance":4492,"id":174491,"goal":"lemma MulOne_4492(n: int)\n ensures n * 1 == n\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_4493","instance":4493,"id":174492,"goal":"lemma MulZero_4493(x: nat)\n ensures x * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_4494","instance":4494,"id":174493,"goal":"lemma LeRefl_4494(k: real)\n ensures k <= k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_4495","instance":4495,"id":174494,"goal":"lemma LeTrans_4495(k: int, z: int, i: int)\n requires k <= z && z <= i\n ensures k <= i\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_4496","instance":4496,"id":174495,"goal":"lemma AddMono_4496(n: nat, m: nat, y: nat)\n requires n <= m\n ensures n + y <= m + y\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_4497","instance":4497,"id":174496,"goal":"lemma Abs_Nonneg_4497(c: real)\n ensures (if c >= 0 then c else -c) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_4498","instance":4498,"id":174497,"goal":"lemma DivMod_4498(n: int, m: int)\n requires m > 0\n ensures n == m * (n / m) + (n % m)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_4499","instance":4499,"id":174498,"goal":"lemma ModBounds_4499(k: nat, n: nat)\n requires n > 0\n ensures 0 <= k % n < n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_4500","instance":4500,"id":174499,"goal":"lemma Square_Nonneg_4500(b: real)\n ensures b * b >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_4501","instance":4501,"id":174500,"goal":"lemma AddComm_4501(i: int, b: int)\n ensures i + b == b + i\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_4502","instance":4502,"id":174501,"goal":"lemma AddAssoc_4502(k: nat, c: nat, y: nat)\n ensures (k + c) + y == k + (c + y)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_4503","instance":4503,"id":174502,"goal":"lemma MulComm_4503(d: real, j: real)\n ensures d * j == j * d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_4504","instance":4504,"id":174503,"goal":"lemma MulAssoc_4504(b: int, d: int, c: int)\n ensures (b * d) * c == b * (d * c)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_4505","instance":4505,"id":174504,"goal":"lemma Distrib_4505(j: nat, d: nat, k: nat)\n ensures j * (d + k) == j * d + j * k\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_4506","instance":4506,"id":174505,"goal":"lemma AddZero_4506(d: real)\n ensures d + 0 == d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_4507","instance":4507,"id":174506,"goal":"lemma MulOne_4507(n: int)\n ensures n * 1 == n\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_4508","instance":4508,"id":174507,"goal":"lemma MulZero_4508(k: nat)\n ensures k * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_4509","instance":4509,"id":174508,"goal":"lemma LeRefl_4509(m: real)\n ensures m <= m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_4510","instance":4510,"id":174509,"goal":"lemma LeTrans_4510(y: int, i: int, k: int)\n requires y <= i && i <= k\n ensures y <= k\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_4511","instance":4511,"id":174510,"goal":"lemma AddMono_4511(k: nat, m: nat, i: nat)\n requires k <= m\n ensures k + i <= m + i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_4512","instance":4512,"id":174511,"goal":"lemma Abs_Nonneg_4512(x: real)\n ensures (if x >= 0 then x else -x) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_4513","instance":4513,"id":174512,"goal":"lemma DivMod_4513(d: int, y: int)\n requires y > 0\n ensures d == y * (d / y) + (d % y)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_4514","instance":4514,"id":174513,"goal":"lemma ModBounds_4514(n: nat, a: nat)\n requires a > 0\n ensures 0 <= n % a < a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_4515","instance":4515,"id":174514,"goal":"lemma Square_Nonneg_4515(b: real)\n ensures b * b >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_4516","instance":4516,"id":174515,"goal":"lemma AddComm_4516(y: int, i: int)\n ensures y + i == i + y\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_4517","instance":4517,"id":174516,"goal":"lemma AddAssoc_4517(m: nat, j: nat, y: nat)\n ensures (m + j) + y == m + (j + y)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_4518","instance":4518,"id":174517,"goal":"lemma MulComm_4518(x: real, j: real)\n ensures x * j == j * x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_4519","instance":4519,"id":174518,"goal":"lemma MulAssoc_4519(m: int, n: int, x: int)\n ensures (m * n) * x == m * (n * x)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_4520","instance":4520,"id":174519,"goal":"lemma Distrib_4520(d: nat, c: nat, n: nat)\n ensures d * (c + n) == d * c + d * n\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_4521","instance":4521,"id":174520,"goal":"lemma AddZero_4521(n: real)\n ensures n + 0 == n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_4522","instance":4522,"id":174521,"goal":"lemma MulOne_4522(n: int)\n ensures n * 1 == n\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_4523","instance":4523,"id":174522,"goal":"lemma MulZero_4523(b: nat)\n ensures b * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_4524","instance":4524,"id":174523,"goal":"lemma LeRefl_4524(y: real)\n ensures y <= y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_4525","instance":4525,"id":174524,"goal":"lemma LeTrans_4525(c: int, d: int, z: int)\n requires c <= d && d <= z\n ensures c <= z\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_4526","instance":4526,"id":174525,"goal":"lemma AddMono_4526(x: nat, j: nat, d: nat)\n requires x <= j\n ensures x + d <= j + d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_4527","instance":4527,"id":174526,"goal":"lemma Abs_Nonneg_4527(i: real)\n ensures (if i >= 0 then i else -i) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_4528","instance":4528,"id":174527,"goal":"lemma DivMod_4528(c: int, a: int)\n requires a > 0\n ensures c == a * (c / a) + (c % a)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_4529","instance":4529,"id":174528,"goal":"lemma ModBounds_4529(b: nat, a: nat)\n requires a > 0\n ensures 0 <= b % a < a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_4530","instance":4530,"id":174529,"goal":"lemma Square_Nonneg_4530(j: real)\n ensures j * j >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_4531","instance":4531,"id":174530,"goal":"lemma AddComm_4531(x: int, d: int)\n ensures x + d == d + x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_4532","instance":4532,"id":174531,"goal":"lemma AddAssoc_4532(i: nat, b: nat, k: nat)\n ensures (i + b) + k == i + (b + k)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_4533","instance":4533,"id":174532,"goal":"lemma MulComm_4533(b: real, c: real)\n ensures b * c == c * b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_4534","instance":4534,"id":174533,"goal":"lemma MulAssoc_4534(a: int, z: int, d: int)\n ensures (a * z) * d == a * (z * d)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_4535","instance":4535,"id":174534,"goal":"lemma Distrib_4535(i: nat, a: nat, k: nat)\n ensures i * (a + k) == i * a + i * k\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_4536","instance":4536,"id":174535,"goal":"lemma AddZero_4536(z: real)\n ensures z + 0 == z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_4537","instance":4537,"id":174536,"goal":"lemma MulOne_4537(y: int)\n ensures y * 1 == y\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_4538","instance":4538,"id":174537,"goal":"lemma MulZero_4538(k: nat)\n ensures k * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_4539","instance":4539,"id":174538,"goal":"lemma LeRefl_4539(d: real)\n ensures d <= d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_4540","instance":4540,"id":174539,"goal":"lemma LeTrans_4540(a: int, b: int, m: int)\n requires a <= b && b <= m\n ensures a <= m\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_4541","instance":4541,"id":174540,"goal":"lemma AddMono_4541(z: nat, m: nat, j: nat)\n requires z <= m\n ensures z + j <= m + j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_4542","instance":4542,"id":174541,"goal":"lemma Abs_Nonneg_4542(d: real)\n ensures (if d >= 0 then d else -d) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_4543","instance":4543,"id":174542,"goal":"lemma DivMod_4543(m: int, k: int)\n requires k > 0\n ensures m == k * (m / k) + (m % k)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_4544","instance":4544,"id":174543,"goal":"lemma ModBounds_4544(n: nat, k: nat)\n requires k > 0\n ensures 0 <= n % k < k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_4545","instance":4545,"id":174544,"goal":"lemma Square_Nonneg_4545(y: real)\n ensures y * y >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_4546","instance":4546,"id":174545,"goal":"lemma AddComm_4546(k: int, y: int)\n ensures k + y == y + k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_4547","instance":4547,"id":174546,"goal":"lemma AddAssoc_4547(x: nat, k: nat, y: nat)\n ensures (x + k) + y == x + (k + y)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_4548","instance":4548,"id":174547,"goal":"lemma MulComm_4548(d: real, n: real)\n ensures d * n == n * d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_4549","instance":4549,"id":174548,"goal":"lemma MulAssoc_4549(n: int, i: int, d: int)\n ensures (n * i) * d == n * (i * d)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_4550","instance":4550,"id":174549,"goal":"lemma Distrib_4550(z: nat, m: nat, c: nat)\n ensures z * (m + c) == z * m + z * c\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_4551","instance":4551,"id":174550,"goal":"lemma AddZero_4551(j: real)\n ensures j + 0 == j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_4552","instance":4552,"id":174551,"goal":"lemma MulOne_4552(d: int)\n ensures d * 1 == d\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_4553","instance":4553,"id":174552,"goal":"lemma MulZero_4553(j: nat)\n ensures j * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_4554","instance":4554,"id":174553,"goal":"lemma LeRefl_4554(j: real)\n ensures j <= j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_4555","instance":4555,"id":174554,"goal":"lemma LeTrans_4555(m: int, x: int, y: int)\n requires m <= x && x <= y\n ensures m <= y\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_4556","instance":4556,"id":174555,"goal":"lemma AddMono_4556(y: nat, a: nat, m: nat)\n requires y <= a\n ensures y + m <= a + m\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_4557","instance":4557,"id":174556,"goal":"lemma Abs_Nonneg_4557(a: real)\n ensures (if a >= 0 then a else -a) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_4558","instance":4558,"id":174557,"goal":"lemma DivMod_4558(k: int, y: int)\n requires y > 0\n ensures k == y * (k / y) + (k % y)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_4559","instance":4559,"id":174558,"goal":"lemma ModBounds_4559(b: nat, c: nat)\n requires c > 0\n ensures 0 <= b % c < c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_4560","instance":4560,"id":174559,"goal":"lemma Square_Nonneg_4560(a: real)\n ensures a * a >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_4561","instance":4561,"id":174560,"goal":"lemma AddComm_4561(b: int, i: int)\n ensures b + i == i + b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_4562","instance":4562,"id":174561,"goal":"lemma AddAssoc_4562(i: nat, j: nat, c: nat)\n ensures (i + j) + c == i + (j + c)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_4563","instance":4563,"id":174562,"goal":"lemma MulComm_4563(m: real, a: real)\n ensures m * a == a * m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_4564","instance":4564,"id":174563,"goal":"lemma MulAssoc_4564(i: int, a: int, x: int)\n ensures (i * a) * x == i * (a * x)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_4565","instance":4565,"id":174564,"goal":"lemma Distrib_4565(j: nat, x: nat, b: nat)\n ensures j * (x + b) == j * x + j * b\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_4566","instance":4566,"id":174565,"goal":"lemma AddZero_4566(d: real)\n ensures d + 0 == d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_4567","instance":4567,"id":174566,"goal":"lemma MulOne_4567(i: int)\n ensures i * 1 == i\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_4568","instance":4568,"id":174567,"goal":"lemma MulZero_4568(c: nat)\n ensures c * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_4569","instance":4569,"id":174568,"goal":"lemma LeRefl_4569(m: real)\n ensures m <= m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_4570","instance":4570,"id":174569,"goal":"lemma LeTrans_4570(z: int, y: int, x: int)\n requires z <= y && y <= x\n ensures z <= x\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_4571","instance":4571,"id":174570,"goal":"lemma AddMono_4571(k: nat, a: nat, y: nat)\n requires k <= a\n ensures k + y <= a + y\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_4572","instance":4572,"id":174571,"goal":"lemma Abs_Nonneg_4572(a: real)\n ensures (if a >= 0 then a else -a) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_4573","instance":4573,"id":174572,"goal":"lemma DivMod_4573(i: int, y: int)\n requires y > 0\n ensures i == y * (i / y) + (i % y)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_4574","instance":4574,"id":174573,"goal":"lemma ModBounds_4574(j: nat, a: nat)\n requires a > 0\n ensures 0 <= j % a < a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_4575","instance":4575,"id":174574,"goal":"lemma Square_Nonneg_4575(y: real)\n ensures y * y >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_4576","instance":4576,"id":174575,"goal":"lemma AddComm_4576(z: int, x: int)\n ensures z + x == x + z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_4577","instance":4577,"id":174576,"goal":"lemma AddAssoc_4577(d: nat, y: nat, b: nat)\n ensures (d + y) + b == d + (y + b)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_4578","instance":4578,"id":174577,"goal":"lemma MulComm_4578(n: real, m: real)\n ensures n * m == m * n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_4579","instance":4579,"id":174578,"goal":"lemma MulAssoc_4579(a: int, b: int, j: int)\n ensures (a * b) * j == a * (b * j)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_4580","instance":4580,"id":174579,"goal":"lemma Distrib_4580(a: nat, j: nat, m: nat)\n ensures a * (j + m) == a * j + a * m\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_4581","instance":4581,"id":174580,"goal":"lemma AddZero_4581(m: real)\n ensures m + 0 == m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_4582","instance":4582,"id":174581,"goal":"lemma MulOne_4582(m: int)\n ensures m * 1 == m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_4583","instance":4583,"id":174582,"goal":"lemma MulZero_4583(k: nat)\n ensures k * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_4584","instance":4584,"id":174583,"goal":"lemma LeRefl_4584(i: real)\n ensures i <= i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_4585","instance":4585,"id":174584,"goal":"lemma LeTrans_4585(b: int, i: int, c: int)\n requires b <= i && i <= c\n ensures b <= c\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_4586","instance":4586,"id":174585,"goal":"lemma AddMono_4586(m: nat, y: nat, i: nat)\n requires m <= y\n ensures m + i <= y + i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_4587","instance":4587,"id":174586,"goal":"lemma Abs_Nonneg_4587(n: real)\n ensures (if n >= 0 then n else -n) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_4588","instance":4588,"id":174587,"goal":"lemma DivMod_4588(j: int, c: int)\n requires c > 0\n ensures j == c * (j / c) + (j % c)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_4589","instance":4589,"id":174588,"goal":"lemma ModBounds_4589(i: nat, k: nat)\n requires k > 0\n ensures 0 <= i % k < k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_4590","instance":4590,"id":174589,"goal":"lemma Square_Nonneg_4590(d: real)\n ensures d * d >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_4591","instance":4591,"id":174590,"goal":"lemma AddComm_4591(c: int, b: int)\n ensures c + b == b + c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_4592","instance":4592,"id":174591,"goal":"lemma AddAssoc_4592(j: nat, k: nat, x: nat)\n ensures (j + k) + x == j + (k + x)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_4593","instance":4593,"id":174592,"goal":"lemma MulComm_4593(a: real, i: real)\n ensures a * i == i * a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_4594","instance":4594,"id":174593,"goal":"lemma MulAssoc_4594(m: int, c: int, a: int)\n ensures (m * c) * a == m * (c * a)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_4595","instance":4595,"id":174594,"goal":"lemma Distrib_4595(a: nat, i: nat, z: nat)\n ensures a * (i + z) == a * i + a * z\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_4596","instance":4596,"id":174595,"goal":"lemma AddZero_4596(m: real)\n ensures m + 0 == m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_4597","instance":4597,"id":174596,"goal":"lemma MulOne_4597(a: int)\n ensures a * 1 == a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_4598","instance":4598,"id":174597,"goal":"lemma MulZero_4598(n: nat)\n ensures n * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_4599","instance":4599,"id":174598,"goal":"lemma LeRefl_4599(j: real)\n ensures j <= j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_4600","instance":4600,"id":174599,"goal":"lemma LeTrans_4600(c: int, m: int, x: int)\n requires c <= m && m <= x\n ensures c <= x\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_4601","instance":4601,"id":174600,"goal":"lemma AddMono_4601(y: nat, b: nat, j: nat)\n requires y <= b\n ensures y + j <= b + j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_4602","instance":4602,"id":174601,"goal":"lemma Abs_Nonneg_4602(j: real)\n ensures (if j >= 0 then j else -j) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_4603","instance":4603,"id":174602,"goal":"lemma DivMod_4603(k: int, c: int)\n requires c > 0\n ensures k == c * (k / c) + (k % c)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_4604","instance":4604,"id":174603,"goal":"lemma ModBounds_4604(y: nat, x: nat)\n requires x > 0\n ensures 0 <= y % x < x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_4605","instance":4605,"id":174604,"goal":"lemma Square_Nonneg_4605(b: real)\n ensures b * b >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_4606","instance":4606,"id":174605,"goal":"lemma AddComm_4606(y: int, k: int)\n ensures y + k == k + y\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_4607","instance":4607,"id":174606,"goal":"lemma AddAssoc_4607(n: nat, y: nat, z: nat)\n ensures (n + y) + z == n + (y + z)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_4608","instance":4608,"id":174607,"goal":"lemma MulComm_4608(i: real, m: real)\n ensures i * m == m * i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_4609","instance":4609,"id":174608,"goal":"lemma MulAssoc_4609(a: int, d: int, i: int)\n ensures (a * d) * i == a * (d * i)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_4610","instance":4610,"id":174609,"goal":"lemma Distrib_4610(i: nat, y: nat, k: nat)\n ensures i * (y + k) == i * y + i * k\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_4611","instance":4611,"id":174610,"goal":"lemma AddZero_4611(y: real)\n ensures y + 0 == y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_4612","instance":4612,"id":174611,"goal":"lemma MulOne_4612(m: int)\n ensures m * 1 == m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_4613","instance":4613,"id":174612,"goal":"lemma MulZero_4613(d: nat)\n ensures d * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_4614","instance":4614,"id":174613,"goal":"lemma LeRefl_4614(a: real)\n ensures a <= a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_4615","instance":4615,"id":174614,"goal":"lemma LeTrans_4615(j: int, m: int, n: int)\n requires j <= m && m <= n\n ensures j <= n\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_4616","instance":4616,"id":174615,"goal":"lemma AddMono_4616(z: nat, j: nat, y: nat)\n requires z <= j\n ensures z + y <= j + y\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_4617","instance":4617,"id":174616,"goal":"lemma Abs_Nonneg_4617(d: real)\n ensures (if d >= 0 then d else -d) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_4618","instance":4618,"id":174617,"goal":"lemma DivMod_4618(i: int, d: int)\n requires d > 0\n ensures i == d * (i / d) + (i % d)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_4619","instance":4619,"id":174618,"goal":"lemma ModBounds_4619(y: nat, j: nat)\n requires j > 0\n ensures 0 <= y % j < j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_4620","instance":4620,"id":174619,"goal":"lemma Square_Nonneg_4620(n: real)\n ensures n * n >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_4621","instance":4621,"id":174620,"goal":"lemma AddComm_4621(c: int, b: int)\n ensures c + b == b + c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_4622","instance":4622,"id":174621,"goal":"lemma AddAssoc_4622(k: nat, n: nat, c: nat)\n ensures (k + n) + c == k + (n + c)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_4623","instance":4623,"id":174622,"goal":"lemma MulComm_4623(x: real, m: real)\n ensures x * m == m * x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_4624","instance":4624,"id":174623,"goal":"lemma MulAssoc_4624(m: int, n: int, z: int)\n ensures (m * n) * z == m * (n * z)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_4625","instance":4625,"id":174624,"goal":"lemma Distrib_4625(d: nat, z: nat, b: nat)\n ensures d * (z + b) == d * z + d * b\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_4626","instance":4626,"id":174625,"goal":"lemma AddZero_4626(c: real)\n ensures c + 0 == c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_4627","instance":4627,"id":174626,"goal":"lemma MulOne_4627(z: int)\n ensures z * 1 == z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_4628","instance":4628,"id":174627,"goal":"lemma MulZero_4628(i: nat)\n ensures i * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_4629","instance":4629,"id":174628,"goal":"lemma LeRefl_4629(j: real)\n ensures j <= j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_4630","instance":4630,"id":174629,"goal":"lemma LeTrans_4630(c: int, d: int, b: int)\n requires c <= d && d <= b\n ensures c <= b\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_4631","instance":4631,"id":174630,"goal":"lemma AddMono_4631(k: nat, n: nat, d: nat)\n requires k <= n\n ensures k + d <= n + d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_4632","instance":4632,"id":174631,"goal":"lemma Abs_Nonneg_4632(j: real)\n ensures (if j >= 0 then j else -j) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_4633","instance":4633,"id":174632,"goal":"lemma DivMod_4633(z: int, x: int)\n requires x > 0\n ensures z == x * (z / x) + (z % x)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_4634","instance":4634,"id":174633,"goal":"lemma ModBounds_4634(m: nat, j: nat)\n requires j > 0\n ensures 0 <= m % j < j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_4635","instance":4635,"id":174634,"goal":"lemma Square_Nonneg_4635(y: real)\n ensures y * y >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_4636","instance":4636,"id":174635,"goal":"lemma AddComm_4636(j: int, m: int)\n ensures j + m == m + j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_4637","instance":4637,"id":174636,"goal":"lemma AddAssoc_4637(i: nat, c: nat, k: nat)\n ensures (i + c) + k == i + (c + k)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_4638","instance":4638,"id":174637,"goal":"lemma MulComm_4638(b: real, z: real)\n ensures b * z == z * b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_4639","instance":4639,"id":174638,"goal":"lemma MulAssoc_4639(n: int, d: int, z: int)\n ensures (n * d) * z == n * (d * z)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_4640","instance":4640,"id":174639,"goal":"lemma Distrib_4640(d: nat, j: nat, b: nat)\n ensures d * (j + b) == d * j + d * b\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_4641","instance":4641,"id":174640,"goal":"lemma AddZero_4641(c: real)\n ensures c + 0 == c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_4642","instance":4642,"id":174641,"goal":"lemma MulOne_4642(n: int)\n ensures n * 1 == n\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_4643","instance":4643,"id":174642,"goal":"lemma MulZero_4643(y: nat)\n ensures y * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_4644","instance":4644,"id":174643,"goal":"lemma LeRefl_4644(m: real)\n ensures m <= m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_4645","instance":4645,"id":174644,"goal":"lemma LeTrans_4645(c: int, d: int, b: int)\n requires c <= d && d <= b\n ensures c <= b\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_4646","instance":4646,"id":174645,"goal":"lemma AddMono_4646(b: nat, y: nat, k: nat)\n requires b <= y\n ensures b + k <= y + k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_4647","instance":4647,"id":174646,"goal":"lemma Abs_Nonneg_4647(k: real)\n ensures (if k >= 0 then k else -k) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_4648","instance":4648,"id":174647,"goal":"lemma DivMod_4648(m: int, y: int)\n requires y > 0\n ensures m == y * (m / y) + (m % y)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_4649","instance":4649,"id":174648,"goal":"lemma ModBounds_4649(x: nat, n: nat)\n requires n > 0\n ensures 0 <= x % n < n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_4650","instance":4650,"id":174649,"goal":"lemma Square_Nonneg_4650(c: real)\n ensures c * c >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_4651","instance":4651,"id":174650,"goal":"lemma AddComm_4651(j: int, b: int)\n ensures j + b == b + j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_4652","instance":4652,"id":174651,"goal":"lemma AddAssoc_4652(i: nat, d: nat, x: nat)\n ensures (i + d) + x == i + (d + x)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_4653","instance":4653,"id":174652,"goal":"lemma MulComm_4653(a: real, y: real)\n ensures a * y == y * a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_4654","instance":4654,"id":174653,"goal":"lemma MulAssoc_4654(i: int, k: int, x: int)\n ensures (i * k) * x == i * (k * x)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_4655","instance":4655,"id":174654,"goal":"lemma Distrib_4655(d: nat, y: nat, n: nat)\n ensures d * (y + n) == d * y + d * n\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_4656","instance":4656,"id":174655,"goal":"lemma AddZero_4656(k: real)\n ensures k + 0 == k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_4657","instance":4657,"id":174656,"goal":"lemma MulOne_4657(b: int)\n ensures b * 1 == b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_4658","instance":4658,"id":174657,"goal":"lemma MulZero_4658(k: nat)\n ensures k * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_4659","instance":4659,"id":174658,"goal":"lemma LeRefl_4659(i: real)\n ensures i <= i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_4660","instance":4660,"id":174659,"goal":"lemma LeTrans_4660(c: int, z: int, b: int)\n requires c <= z && z <= b\n ensures c <= b\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_4661","instance":4661,"id":174660,"goal":"lemma AddMono_4661(m: nat, y: nat, a: nat)\n requires m <= y\n ensures m + a <= y + a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_4662","instance":4662,"id":174661,"goal":"lemma Abs_Nonneg_4662(j: real)\n ensures (if j >= 0 then j else -j) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_4663","instance":4663,"id":174662,"goal":"lemma DivMod_4663(i: int, x: int)\n requires x > 0\n ensures i == x * (i / x) + (i % x)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_4664","instance":4664,"id":174663,"goal":"lemma ModBounds_4664(b: nat, x: nat)\n requires x > 0\n ensures 0 <= b % x < x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_4665","instance":4665,"id":174664,"goal":"lemma Square_Nonneg_4665(k: real)\n ensures k * k >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_4666","instance":4666,"id":174665,"goal":"lemma AddComm_4666(z: int, c: int)\n ensures z + c == c + z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_4667","instance":4667,"id":174666,"goal":"lemma AddAssoc_4667(i: nat, z: nat, x: nat)\n ensures (i + z) + x == i + (z + x)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_4668","instance":4668,"id":174667,"goal":"lemma MulComm_4668(d: real, b: real)\n ensures d * b == b * d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_4669","instance":4669,"id":174668,"goal":"lemma MulAssoc_4669(x: int, n: int, d: int)\n ensures (x * n) * d == x * (n * d)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_4670","instance":4670,"id":174669,"goal":"lemma Distrib_4670(z: nat, m: nat, x: nat)\n ensures z * (m + x) == z * m + z * x\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_4671","instance":4671,"id":174670,"goal":"lemma AddZero_4671(z: real)\n ensures z + 0 == z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_4672","instance":4672,"id":174671,"goal":"lemma MulOne_4672(y: int)\n ensures y * 1 == y\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_4673","instance":4673,"id":174672,"goal":"lemma MulZero_4673(c: nat)\n ensures c * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_4674","instance":4674,"id":174673,"goal":"lemma LeRefl_4674(k: real)\n ensures k <= k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_4675","instance":4675,"id":174674,"goal":"lemma LeTrans_4675(d: int, c: int, i: int)\n requires d <= c && c <= i\n ensures d <= i\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_4676","instance":4676,"id":174675,"goal":"lemma AddMono_4676(z: nat, d: nat, k: nat)\n requires z <= d\n ensures z + k <= d + k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_4677","instance":4677,"id":174676,"goal":"lemma Abs_Nonneg_4677(i: real)\n ensures (if i >= 0 then i else -i) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_4678","instance":4678,"id":174677,"goal":"lemma DivMod_4678(j: int, y: int)\n requires y > 0\n ensures j == y * (j / y) + (j % y)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_4679","instance":4679,"id":174678,"goal":"lemma ModBounds_4679(a: nat, c: nat)\n requires c > 0\n ensures 0 <= a % c < c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_4680","instance":4680,"id":174679,"goal":"lemma Square_Nonneg_4680(x: real)\n ensures x * x >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_4681","instance":4681,"id":174680,"goal":"lemma AddComm_4681(x: int, j: int)\n ensures x + j == j + x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_4682","instance":4682,"id":174681,"goal":"lemma AddAssoc_4682(a: nat, m: nat, n: nat)\n ensures (a + m) + n == a + (m + n)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_4683","instance":4683,"id":174682,"goal":"lemma MulComm_4683(z: real, m: real)\n ensures z * m == m * z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_4684","instance":4684,"id":174683,"goal":"lemma MulAssoc_4684(z: int, y: int, a: int)\n ensures (z * y) * a == z * (y * a)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_4685","instance":4685,"id":174684,"goal":"lemma Distrib_4685(m: nat, z: nat, d: nat)\n ensures m * (z + d) == m * z + m * d\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_4686","instance":4686,"id":174685,"goal":"lemma AddZero_4686(c: real)\n ensures c + 0 == c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_4687","instance":4687,"id":174686,"goal":"lemma MulOne_4687(x: int)\n ensures x * 1 == x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_4688","instance":4688,"id":174687,"goal":"lemma MulZero_4688(m: nat)\n ensures m * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_4689","instance":4689,"id":174688,"goal":"lemma LeRefl_4689(z: real)\n ensures z <= z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_4690","instance":4690,"id":174689,"goal":"lemma LeTrans_4690(j: int, k: int, d: int)\n requires j <= k && k <= d\n ensures j <= d\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_4691","instance":4691,"id":174690,"goal":"lemma AddMono_4691(z: nat, d: nat, j: nat)\n requires z <= d\n ensures z + j <= d + j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_4692","instance":4692,"id":174691,"goal":"lemma Abs_Nonneg_4692(m: real)\n ensures (if m >= 0 then m else -m) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_4693","instance":4693,"id":174692,"goal":"lemma DivMod_4693(z: int, n: int)\n requires n > 0\n ensures z == n * (z / n) + (z % n)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_4694","instance":4694,"id":174693,"goal":"lemma ModBounds_4694(i: nat, y: nat)\n requires y > 0\n ensures 0 <= i % y < y\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_4695","instance":4695,"id":174694,"goal":"lemma Square_Nonneg_4695(y: real)\n ensures y * y >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_4696","instance":4696,"id":174695,"goal":"lemma AddComm_4696(x: int, c: int)\n ensures x + c == c + x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_4697","instance":4697,"id":174696,"goal":"lemma AddAssoc_4697(k: nat, j: nat, i: nat)\n ensures (k + j) + i == k + (j + i)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_4698","instance":4698,"id":174697,"goal":"lemma MulComm_4698(b: real, c: real)\n ensures b * c == c * b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_4699","instance":4699,"id":174698,"goal":"lemma MulAssoc_4699(j: int, d: int, a: int)\n ensures (j * d) * a == j * (d * a)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_4700","instance":4700,"id":174699,"goal":"lemma Distrib_4700(j: nat, c: nat, m: nat)\n ensures j * (c + m) == j * c + j * m\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_4701","instance":4701,"id":174700,"goal":"lemma AddZero_4701(b: real)\n ensures b + 0 == b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_4702","instance":4702,"id":174701,"goal":"lemma MulOne_4702(d: int)\n ensures d * 1 == d\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_4703","instance":4703,"id":174702,"goal":"lemma MulZero_4703(d: nat)\n ensures d * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_4704","instance":4704,"id":174703,"goal":"lemma LeRefl_4704(z: real)\n ensures z <= z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_4705","instance":4705,"id":174704,"goal":"lemma LeTrans_4705(j: int, n: int, k: int)\n requires j <= n && n <= k\n ensures j <= k\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_4706","instance":4706,"id":174705,"goal":"lemma AddMono_4706(a: nat, b: nat, n: nat)\n requires a <= b\n ensures a + n <= b + n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_4707","instance":4707,"id":174706,"goal":"lemma Abs_Nonneg_4707(d: real)\n ensures (if d >= 0 then d else -d) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_4708","instance":4708,"id":174707,"goal":"lemma DivMod_4708(a: int, x: int)\n requires x > 0\n ensures a == x * (a / x) + (a % x)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_4709","instance":4709,"id":174708,"goal":"lemma ModBounds_4709(y: nat, d: nat)\n requires d > 0\n ensures 0 <= y % d < d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_4710","instance":4710,"id":174709,"goal":"lemma Square_Nonneg_4710(a: real)\n ensures a * a >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_4711","instance":4711,"id":174710,"goal":"lemma AddComm_4711(c: int, k: int)\n ensures c + k == k + c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_4712","instance":4712,"id":174711,"goal":"lemma AddAssoc_4712(y: nat, c: nat, d: nat)\n ensures (y + c) + d == y + (c + d)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_4713","instance":4713,"id":174712,"goal":"lemma MulComm_4713(z: real, c: real)\n ensures z * c == c * z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_4714","instance":4714,"id":174713,"goal":"lemma MulAssoc_4714(k: int, m: int, j: int)\n ensures (k * m) * j == k * (m * j)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_4715","instance":4715,"id":174714,"goal":"lemma Distrib_4715(x: nat, z: nat, c: nat)\n ensures x * (z + c) == x * z + x * c\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_4716","instance":4716,"id":174715,"goal":"lemma AddZero_4716(x: real)\n ensures x + 0 == x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_4717","instance":4717,"id":174716,"goal":"lemma MulOne_4717(a: int)\n ensures a * 1 == a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_4718","instance":4718,"id":174717,"goal":"lemma MulZero_4718(d: nat)\n ensures d * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_4719","instance":4719,"id":174718,"goal":"lemma LeRefl_4719(z: real)\n ensures z <= z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_4720","instance":4720,"id":174719,"goal":"lemma LeTrans_4720(z: int, a: int, n: int)\n requires z <= a && a <= n\n ensures z <= n\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_4721","instance":4721,"id":174720,"goal":"lemma AddMono_4721(k: nat, a: nat, d: nat)\n requires k <= a\n ensures k + d <= a + d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_4722","instance":4722,"id":174721,"goal":"lemma Abs_Nonneg_4722(z: real)\n ensures (if z >= 0 then z else -z) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_4723","instance":4723,"id":174722,"goal":"lemma DivMod_4723(k: int, c: int)\n requires c > 0\n ensures k == c * (k / c) + (k % c)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_4724","instance":4724,"id":174723,"goal":"lemma ModBounds_4724(c: nat, x: nat)\n requires x > 0\n ensures 0 <= c % x < x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_4725","instance":4725,"id":174724,"goal":"lemma Square_Nonneg_4725(j: real)\n ensures j * j >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_4726","instance":4726,"id":174725,"goal":"lemma AddComm_4726(d: int, i: int)\n ensures d + i == i + d\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_4727","instance":4727,"id":174726,"goal":"lemma AddAssoc_4727(j: nat, z: nat, n: nat)\n ensures (j + z) + n == j + (z + n)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_4728","instance":4728,"id":174727,"goal":"lemma MulComm_4728(i: real, m: real)\n ensures i * m == m * i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_4729","instance":4729,"id":174728,"goal":"lemma MulAssoc_4729(k: int, a: int, x: int)\n ensures (k * a) * x == k * (a * x)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_4730","instance":4730,"id":174729,"goal":"lemma Distrib_4730(j: nat, c: nat, d: nat)\n ensures j * (c + d) == j * c + j * d\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_4731","instance":4731,"id":174730,"goal":"lemma AddZero_4731(z: real)\n ensures z + 0 == z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_4732","instance":4732,"id":174731,"goal":"lemma MulOne_4732(y: int)\n ensures y * 1 == y\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_4733","instance":4733,"id":174732,"goal":"lemma MulZero_4733(b: nat)\n ensures b * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_4734","instance":4734,"id":174733,"goal":"lemma LeRefl_4734(a: real)\n ensures a <= a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_4735","instance":4735,"id":174734,"goal":"lemma LeTrans_4735(b: int, d: int, x: int)\n requires b <= d && d <= x\n ensures b <= x\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_4736","instance":4736,"id":174735,"goal":"lemma AddMono_4736(z: nat, i: nat, d: nat)\n requires z <= i\n ensures z + d <= i + d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_4737","instance":4737,"id":174736,"goal":"lemma Abs_Nonneg_4737(i: real)\n ensures (if i >= 0 then i else -i) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_4738","instance":4738,"id":174737,"goal":"lemma DivMod_4738(n: int, i: int)\n requires i > 0\n ensures n == i * (n / i) + (n % i)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_4739","instance":4739,"id":174738,"goal":"lemma ModBounds_4739(m: nat, j: nat)\n requires j > 0\n ensures 0 <= m % j < j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_4740","instance":4740,"id":174739,"goal":"lemma Square_Nonneg_4740(m: real)\n ensures m * m >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_4741","instance":4741,"id":174740,"goal":"lemma AddComm_4741(d: int, y: int)\n ensures d + y == y + d\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_4742","instance":4742,"id":174741,"goal":"lemma AddAssoc_4742(m: nat, b: nat, a: nat)\n ensures (m + b) + a == m + (b + a)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_4743","instance":4743,"id":174742,"goal":"lemma MulComm_4743(m: real, c: real)\n ensures m * c == c * m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_4744","instance":4744,"id":174743,"goal":"lemma MulAssoc_4744(j: int, x: int, d: int)\n ensures (j * x) * d == j * (x * d)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_4745","instance":4745,"id":174744,"goal":"lemma Distrib_4745(a: nat, m: nat, z: nat)\n ensures a * (m + z) == a * m + a * z\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_4746","instance":4746,"id":174745,"goal":"lemma AddZero_4746(j: real)\n ensures j + 0 == j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_4747","instance":4747,"id":174746,"goal":"lemma MulOne_4747(n: int)\n ensures n * 1 == n\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_4748","instance":4748,"id":174747,"goal":"lemma MulZero_4748(i: nat)\n ensures i * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_4749","instance":4749,"id":174748,"goal":"lemma LeRefl_4749(n: real)\n ensures n <= n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_4750","instance":4750,"id":174749,"goal":"lemma LeTrans_4750(i: int, m: int, n: int)\n requires i <= m && m <= n\n ensures i <= n\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_4751","instance":4751,"id":174750,"goal":"lemma AddMono_4751(y: nat, m: nat, z: nat)\n requires y <= m\n ensures y + z <= m + z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_4752","instance":4752,"id":174751,"goal":"lemma Abs_Nonneg_4752(k: real)\n ensures (if k >= 0 then k else -k) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_4753","instance":4753,"id":174752,"goal":"lemma DivMod_4753(x: int, m: int)\n requires m > 0\n ensures x == m * (x / m) + (x % m)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_4754","instance":4754,"id":174753,"goal":"lemma ModBounds_4754(z: nat, c: nat)\n requires c > 0\n ensures 0 <= z % c < c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_4755","instance":4755,"id":174754,"goal":"lemma Square_Nonneg_4755(y: real)\n ensures y * y >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_4756","instance":4756,"id":174755,"goal":"lemma AddComm_4756(c: int, d: int)\n ensures c + d == d + c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_4757","instance":4757,"id":174756,"goal":"lemma AddAssoc_4757(x: nat, a: nat, k: nat)\n ensures (x + a) + k == x + (a + k)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_4758","instance":4758,"id":174757,"goal":"lemma MulComm_4758(z: real, a: real)\n ensures z * a == a * z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_4759","instance":4759,"id":174758,"goal":"lemma MulAssoc_4759(j: int, x: int, d: int)\n ensures (j * x) * d == j * (x * d)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_4760","instance":4760,"id":174759,"goal":"lemma Distrib_4760(i: nat, y: nat, j: nat)\n ensures i * (y + j) == i * y + i * j\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_4761","instance":4761,"id":174760,"goal":"lemma AddZero_4761(y: real)\n ensures y + 0 == y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_4762","instance":4762,"id":174761,"goal":"lemma MulOne_4762(c: int)\n ensures c * 1 == c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_4763","instance":4763,"id":174762,"goal":"lemma MulZero_4763(b: nat)\n ensures b * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_4764","instance":4764,"id":174763,"goal":"lemma LeRefl_4764(c: real)\n ensures c <= c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_4765","instance":4765,"id":174764,"goal":"lemma LeTrans_4765(x: int, d: int, m: int)\n requires x <= d && d <= m\n ensures x <= m\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_4766","instance":4766,"id":174765,"goal":"lemma AddMono_4766(x: nat, n: nat, z: nat)\n requires x <= n\n ensures x + z <= n + z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_4767","instance":4767,"id":174766,"goal":"lemma Abs_Nonneg_4767(x: real)\n ensures (if x >= 0 then x else -x) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_4768","instance":4768,"id":174767,"goal":"lemma DivMod_4768(m: int, b: int)\n requires b > 0\n ensures m == b * (m / b) + (m % b)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_4769","instance":4769,"id":174768,"goal":"lemma ModBounds_4769(m: nat, n: nat)\n requires n > 0\n ensures 0 <= m % n < n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_4770","instance":4770,"id":174769,"goal":"lemma Square_Nonneg_4770(a: real)\n ensures a * a >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_4771","instance":4771,"id":174770,"goal":"lemma AddComm_4771(x: int, c: int)\n ensures x + c == c + x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_4772","instance":4772,"id":174771,"goal":"lemma AddAssoc_4772(a: nat, x: nat, d: nat)\n ensures (a + x) + d == a + (x + d)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_4773","instance":4773,"id":174772,"goal":"lemma MulComm_4773(n: real, a: real)\n ensures n * a == a * n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_4774","instance":4774,"id":174773,"goal":"lemma MulAssoc_4774(b: int, c: int, y: int)\n ensures (b * c) * y == b * (c * y)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_4775","instance":4775,"id":174774,"goal":"lemma Distrib_4775(y: nat, b: nat, d: nat)\n ensures y * (b + d) == y * b + y * d\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_4776","instance":4776,"id":174775,"goal":"lemma AddZero_4776(b: real)\n ensures b + 0 == b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_4777","instance":4777,"id":174776,"goal":"lemma MulOne_4777(i: int)\n ensures i * 1 == i\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_4778","instance":4778,"id":174777,"goal":"lemma MulZero_4778(m: nat)\n ensures m * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_4779","instance":4779,"id":174778,"goal":"lemma LeRefl_4779(y: real)\n ensures y <= y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_4780","instance":4780,"id":174779,"goal":"lemma LeTrans_4780(c: int, j: int, b: int)\n requires c <= j && j <= b\n ensures c <= b\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_4781","instance":4781,"id":174780,"goal":"lemma AddMono_4781(b: nat, j: nat, y: nat)\n requires b <= j\n ensures b + y <= j + y\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_4782","instance":4782,"id":174781,"goal":"lemma Abs_Nonneg_4782(c: real)\n ensures (if c >= 0 then c else -c) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_4783","instance":4783,"id":174782,"goal":"lemma DivMod_4783(k: int, x: int)\n requires x > 0\n ensures k == x * (k / x) + (k % x)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_4784","instance":4784,"id":174783,"goal":"lemma ModBounds_4784(y: nat, x: nat)\n requires x > 0\n ensures 0 <= y % x < x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_4785","instance":4785,"id":174784,"goal":"lemma Square_Nonneg_4785(z: real)\n ensures z * z >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_4786","instance":4786,"id":174785,"goal":"lemma AddComm_4786(m: int, z: int)\n ensures m + z == z + m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_4787","instance":4787,"id":174786,"goal":"lemma AddAssoc_4787(d: nat, c: nat, i: nat)\n ensures (d + c) + i == d + (c + i)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_4788","instance":4788,"id":174787,"goal":"lemma MulComm_4788(i: real, y: real)\n ensures i * y == y * i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_4789","instance":4789,"id":174788,"goal":"lemma MulAssoc_4789(k: int, j: int, m: int)\n ensures (k * j) * m == k * (j * m)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_4790","instance":4790,"id":174789,"goal":"lemma Distrib_4790(c: nat, i: nat, x: nat)\n ensures c * (i + x) == c * i + c * x\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_4791","instance":4791,"id":174790,"goal":"lemma AddZero_4791(m: real)\n ensures m + 0 == m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_4792","instance":4792,"id":174791,"goal":"lemma MulOne_4792(y: int)\n ensures y * 1 == y\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_4793","instance":4793,"id":174792,"goal":"lemma MulZero_4793(i: nat)\n ensures i * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_4794","instance":4794,"id":174793,"goal":"lemma LeRefl_4794(d: real)\n ensures d <= d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_4795","instance":4795,"id":174794,"goal":"lemma LeTrans_4795(i: int, d: int, j: int)\n requires i <= d && d <= j\n ensures i <= j\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_4796","instance":4796,"id":174795,"goal":"lemma AddMono_4796(z: nat, m: nat, a: nat)\n requires z <= m\n ensures z + a <= m + a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_4797","instance":4797,"id":174796,"goal":"lemma Abs_Nonneg_4797(x: real)\n ensures (if x >= 0 then x else -x) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_4798","instance":4798,"id":174797,"goal":"lemma DivMod_4798(a: int, n: int)\n requires n > 0\n ensures a == n * (a / n) + (a % n)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_4799","instance":4799,"id":174798,"goal":"lemma ModBounds_4799(k: nat, a: nat)\n requires a > 0\n ensures 0 <= k % a < a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_4800","instance":4800,"id":174799,"goal":"lemma Square_Nonneg_4800(c: real)\n ensures c * c >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_4801","instance":4801,"id":174800,"goal":"lemma AddComm_4801(c: int, n: int)\n ensures c + n == n + c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_4802","instance":4802,"id":174801,"goal":"lemma AddAssoc_4802(y: nat, d: nat, z: nat)\n ensures (y + d) + z == y + (d + z)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_4803","instance":4803,"id":174802,"goal":"lemma MulComm_4803(a: real, x: real)\n ensures a * x == x * a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_4804","instance":4804,"id":174803,"goal":"lemma MulAssoc_4804(c: int, d: int, n: int)\n ensures (c * d) * n == c * (d * n)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_4805","instance":4805,"id":174804,"goal":"lemma Distrib_4805(j: nat, d: nat, m: nat)\n ensures j * (d + m) == j * d + j * m\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_4806","instance":4806,"id":174805,"goal":"lemma AddZero_4806(k: real)\n ensures k + 0 == k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_4807","instance":4807,"id":174806,"goal":"lemma MulOne_4807(y: int)\n ensures y * 1 == y\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_4808","instance":4808,"id":174807,"goal":"lemma MulZero_4808(c: nat)\n ensures c * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_4809","instance":4809,"id":174808,"goal":"lemma LeRefl_4809(k: real)\n ensures k <= k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_4810","instance":4810,"id":174809,"goal":"lemma LeTrans_4810(b: int, c: int, z: int)\n requires b <= c && c <= z\n ensures b <= z\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_4811","instance":4811,"id":174810,"goal":"lemma AddMono_4811(a: nat, i: nat, n: nat)\n requires a <= i\n ensures a + n <= i + n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_4812","instance":4812,"id":174811,"goal":"lemma Abs_Nonneg_4812(x: real)\n ensures (if x >= 0 then x else -x) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_4813","instance":4813,"id":174812,"goal":"lemma DivMod_4813(d: int, a: int)\n requires a > 0\n ensures d == a * (d / a) + (d % a)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_4814","instance":4814,"id":174813,"goal":"lemma ModBounds_4814(b: nat, c: nat)\n requires c > 0\n ensures 0 <= b % c < c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_4815","instance":4815,"id":174814,"goal":"lemma Square_Nonneg_4815(c: real)\n ensures c * c >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_4816","instance":4816,"id":174815,"goal":"lemma AddComm_4816(a: int, z: int)\n ensures a + z == z + a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_4817","instance":4817,"id":174816,"goal":"lemma AddAssoc_4817(j: nat, m: nat, y: nat)\n ensures (j + m) + y == j + (m + y)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_4818","instance":4818,"id":174817,"goal":"lemma MulComm_4818(b: real, i: real)\n ensures b * i == i * b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_4819","instance":4819,"id":174818,"goal":"lemma MulAssoc_4819(i: int, k: int, z: int)\n ensures (i * k) * z == i * (k * z)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_4820","instance":4820,"id":174819,"goal":"lemma Distrib_4820(j: nat, n: nat, b: nat)\n ensures j * (n + b) == j * n + j * b\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_4821","instance":4821,"id":174820,"goal":"lemma AddZero_4821(n: real)\n ensures n + 0 == n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_4822","instance":4822,"id":174821,"goal":"lemma MulOne_4822(n: int)\n ensures n * 1 == n\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_4823","instance":4823,"id":174822,"goal":"lemma MulZero_4823(y: nat)\n ensures y * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_4824","instance":4824,"id":174823,"goal":"lemma LeRefl_4824(y: real)\n ensures y <= y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_4825","instance":4825,"id":174824,"goal":"lemma LeTrans_4825(n: int, m: int, d: int)\n requires n <= m && m <= d\n ensures n <= d\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_4826","instance":4826,"id":174825,"goal":"lemma AddMono_4826(n: nat, d: nat, c: nat)\n requires n <= d\n ensures n + c <= d + c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_4827","instance":4827,"id":174826,"goal":"lemma Abs_Nonneg_4827(i: real)\n ensures (if i >= 0 then i else -i) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_4828","instance":4828,"id":174827,"goal":"lemma DivMod_4828(c: int, d: int)\n requires d > 0\n ensures c == d * (c / d) + (c % d)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_4829","instance":4829,"id":174828,"goal":"lemma ModBounds_4829(a: nat, x: nat)\n requires x > 0\n ensures 0 <= a % x < x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_4830","instance":4830,"id":174829,"goal":"lemma Square_Nonneg_4830(m: real)\n ensures m * m >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_4831","instance":4831,"id":174830,"goal":"lemma AddComm_4831(x: int, n: int)\n ensures x + n == n + x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_4832","instance":4832,"id":174831,"goal":"lemma AddAssoc_4832(d: nat, j: nat, k: nat)\n ensures (d + j) + k == d + (j + k)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_4833","instance":4833,"id":174832,"goal":"lemma MulComm_4833(j: real, n: real)\n ensures j * n == n * j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_4834","instance":4834,"id":174833,"goal":"lemma MulAssoc_4834(j: int, n: int, z: int)\n ensures (j * n) * z == j * (n * z)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_4835","instance":4835,"id":174834,"goal":"lemma Distrib_4835(j: nat, n: nat, k: nat)\n ensures j * (n + k) == j * n + j * k\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_4836","instance":4836,"id":174835,"goal":"lemma AddZero_4836(c: real)\n ensures c + 0 == c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_4837","instance":4837,"id":174836,"goal":"lemma MulOne_4837(z: int)\n ensures z * 1 == z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_4838","instance":4838,"id":174837,"goal":"lemma MulZero_4838(n: nat)\n ensures n * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_4839","instance":4839,"id":174838,"goal":"lemma LeRefl_4839(b: real)\n ensures b <= b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_4840","instance":4840,"id":174839,"goal":"lemma LeTrans_4840(x: int, c: int, b: int)\n requires x <= c && c <= b\n ensures x <= b\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_4841","instance":4841,"id":174840,"goal":"lemma AddMono_4841(c: nat, b: nat, j: nat)\n requires c <= b\n ensures c + j <= b + j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_4842","instance":4842,"id":174841,"goal":"lemma Abs_Nonneg_4842(m: real)\n ensures (if m >= 0 then m else -m) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_4843","instance":4843,"id":174842,"goal":"lemma DivMod_4843(m: int, b: int)\n requires b > 0\n ensures m == b * (m / b) + (m % b)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_4844","instance":4844,"id":174843,"goal":"lemma ModBounds_4844(x: nat, c: nat)\n requires c > 0\n ensures 0 <= x % c < c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_4845","instance":4845,"id":174844,"goal":"lemma Square_Nonneg_4845(k: real)\n ensures k * k >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_4846","instance":4846,"id":174845,"goal":"lemma AddComm_4846(k: int, y: int)\n ensures k + y == y + k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_4847","instance":4847,"id":174846,"goal":"lemma AddAssoc_4847(z: nat, a: nat, x: nat)\n ensures (z + a) + x == z + (a + x)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_4848","instance":4848,"id":174847,"goal":"lemma MulComm_4848(y: real, a: real)\n ensures y * a == a * y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_4849","instance":4849,"id":174848,"goal":"lemma MulAssoc_4849(i: int, y: int, b: int)\n ensures (i * y) * b == i * (y * b)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_4850","instance":4850,"id":174849,"goal":"lemma Distrib_4850(z: nat, c: nat, d: nat)\n ensures z * (c + d) == z * c + z * d\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_4851","instance":4851,"id":174850,"goal":"lemma AddZero_4851(a: real)\n ensures a + 0 == a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_4852","instance":4852,"id":174851,"goal":"lemma MulOne_4852(c: int)\n ensures c * 1 == c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_4853","instance":4853,"id":174852,"goal":"lemma MulZero_4853(m: nat)\n ensures m * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_4854","instance":4854,"id":174853,"goal":"lemma LeRefl_4854(j: real)\n ensures j <= j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_4855","instance":4855,"id":174854,"goal":"lemma LeTrans_4855(z: int, a: int, m: int)\n requires z <= a && a <= m\n ensures z <= m\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_4856","instance":4856,"id":174855,"goal":"lemma AddMono_4856(d: nat, x: nat, b: nat)\n requires d <= x\n ensures d + b <= x + b\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_4857","instance":4857,"id":174856,"goal":"lemma Abs_Nonneg_4857(m: real)\n ensures (if m >= 0 then m else -m) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_4858","instance":4858,"id":174857,"goal":"lemma DivMod_4858(d: int, j: int)\n requires j > 0\n ensures d == j * (d / j) + (d % j)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_4859","instance":4859,"id":174858,"goal":"lemma ModBounds_4859(a: nat, j: nat)\n requires j > 0\n ensures 0 <= a % j < j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_4860","instance":4860,"id":174859,"goal":"lemma Square_Nonneg_4860(y: real)\n ensures y * y >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_4861","instance":4861,"id":174860,"goal":"lemma AddComm_4861(m: int, y: int)\n ensures m + y == y + m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_4862","instance":4862,"id":174861,"goal":"lemma AddAssoc_4862(d: nat, x: nat, y: nat)\n ensures (d + x) + y == d + (x + y)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_4863","instance":4863,"id":174862,"goal":"lemma MulComm_4863(i: real, c: real)\n ensures i * c == c * i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_4864","instance":4864,"id":174863,"goal":"lemma MulAssoc_4864(d: int, m: int, c: int)\n ensures (d * m) * c == d * (m * c)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_4865","instance":4865,"id":174864,"goal":"lemma Distrib_4865(i: nat, k: nat, n: nat)\n ensures i * (k + n) == i * k + i * n\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_4866","instance":4866,"id":174865,"goal":"lemma AddZero_4866(d: real)\n ensures d + 0 == d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_4867","instance":4867,"id":174866,"goal":"lemma MulOne_4867(a: int)\n ensures a * 1 == a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_4868","instance":4868,"id":174867,"goal":"lemma MulZero_4868(n: nat)\n ensures n * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_4869","instance":4869,"id":174868,"goal":"lemma LeRefl_4869(k: real)\n ensures k <= k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_4870","instance":4870,"id":174869,"goal":"lemma LeTrans_4870(z: int, j: int, m: int)\n requires z <= j && j <= m\n ensures z <= m\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_4871","instance":4871,"id":174870,"goal":"lemma AddMono_4871(b: nat, m: nat, j: nat)\n requires b <= m\n ensures b + j <= m + j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_4872","instance":4872,"id":174871,"goal":"lemma Abs_Nonneg_4872(c: real)\n ensures (if c >= 0 then c else -c) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_4873","instance":4873,"id":174872,"goal":"lemma DivMod_4873(m: int, x: int)\n requires x > 0\n ensures m == x * (m / x) + (m % x)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_4874","instance":4874,"id":174873,"goal":"lemma ModBounds_4874(i: nat, c: nat)\n requires c > 0\n ensures 0 <= i % c < c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_4875","instance":4875,"id":174874,"goal":"lemma Square_Nonneg_4875(x: real)\n ensures x * x >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_4876","instance":4876,"id":174875,"goal":"lemma AddComm_4876(c: int, k: int)\n ensures c + k == k + c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_4877","instance":4877,"id":174876,"goal":"lemma AddAssoc_4877(y: nat, i: nat, a: nat)\n ensures (y + i) + a == y + (i + a)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_4878","instance":4878,"id":174877,"goal":"lemma MulComm_4878(k: real, d: real)\n ensures k * d == d * k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_4879","instance":4879,"id":174878,"goal":"lemma MulAssoc_4879(c: int, i: int, j: int)\n ensures (c * i) * j == c * (i * j)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_4880","instance":4880,"id":174879,"goal":"lemma Distrib_4880(x: nat, a: nat, d: nat)\n ensures x * (a + d) == x * a + x * d\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_4881","instance":4881,"id":174880,"goal":"lemma AddZero_4881(x: real)\n ensures x + 0 == x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_4882","instance":4882,"id":174881,"goal":"lemma MulOne_4882(c: int)\n ensures c * 1 == c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_4883","instance":4883,"id":174882,"goal":"lemma MulZero_4883(c: nat)\n ensures c * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_4884","instance":4884,"id":174883,"goal":"lemma LeRefl_4884(b: real)\n ensures b <= b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_4885","instance":4885,"id":174884,"goal":"lemma LeTrans_4885(b: int, y: int, x: int)\n requires b <= y && y <= x\n ensures b <= x\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_4886","instance":4886,"id":174885,"goal":"lemma AddMono_4886(m: nat, x: nat, b: nat)\n requires m <= x\n ensures m + b <= x + b\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_4887","instance":4887,"id":174886,"goal":"lemma Abs_Nonneg_4887(a: real)\n ensures (if a >= 0 then a else -a) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_4888","instance":4888,"id":174887,"goal":"lemma DivMod_4888(i: int, c: int)\n requires c > 0\n ensures i == c * (i / c) + (i % c)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_4889","instance":4889,"id":174888,"goal":"lemma ModBounds_4889(y: nat, b: nat)\n requires b > 0\n ensures 0 <= y % b < b\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_4890","instance":4890,"id":174889,"goal":"lemma Square_Nonneg_4890(m: real)\n ensures m * m >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_4891","instance":4891,"id":174890,"goal":"lemma AddComm_4891(c: int, y: int)\n ensures c + y == y + c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_4892","instance":4892,"id":174891,"goal":"lemma AddAssoc_4892(n: nat, m: nat, a: nat)\n ensures (n + m) + a == n + (m + a)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_4893","instance":4893,"id":174892,"goal":"lemma MulComm_4893(z: real, m: real)\n ensures z * m == m * z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_4894","instance":4894,"id":174893,"goal":"lemma MulAssoc_4894(d: int, n: int, a: int)\n ensures (d * n) * a == d * (n * a)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_4895","instance":4895,"id":174894,"goal":"lemma Distrib_4895(k: nat, i: nat, n: nat)\n ensures k * (i + n) == k * i + k * n\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_4896","instance":4896,"id":174895,"goal":"lemma AddZero_4896(k: real)\n ensures k + 0 == k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_4897","instance":4897,"id":174896,"goal":"lemma MulOne_4897(i: int)\n ensures i * 1 == i\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_4898","instance":4898,"id":174897,"goal":"lemma MulZero_4898(b: nat)\n ensures b * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_4899","instance":4899,"id":174898,"goal":"lemma LeRefl_4899(c: real)\n ensures c <= c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_4900","instance":4900,"id":174899,"goal":"lemma LeTrans_4900(n: int, y: int, m: int)\n requires n <= y && y <= m\n ensures n <= m\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_4901","instance":4901,"id":174900,"goal":"lemma AddMono_4901(n: nat, j: nat, k: nat)\n requires n <= j\n ensures n + k <= j + k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_4902","instance":4902,"id":174901,"goal":"lemma Abs_Nonneg_4902(x: real)\n ensures (if x >= 0 then x else -x) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_4903","instance":4903,"id":174902,"goal":"lemma DivMod_4903(y: int, a: int)\n requires a > 0\n ensures y == a * (y / a) + (y % a)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_4904","instance":4904,"id":174903,"goal":"lemma ModBounds_4904(k: nat, i: nat)\n requires i > 0\n ensures 0 <= k % i < i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_4905","instance":4905,"id":174904,"goal":"lemma Square_Nonneg_4905(z: real)\n ensures z * z >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_4906","instance":4906,"id":174905,"goal":"lemma AddComm_4906(b: int, c: int)\n ensures b + c == c + b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_4907","instance":4907,"id":174906,"goal":"lemma AddAssoc_4907(k: nat, i: nat, c: nat)\n ensures (k + i) + c == k + (i + c)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_4908","instance":4908,"id":174907,"goal":"lemma MulComm_4908(k: real, n: real)\n ensures k * n == n * k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_4909","instance":4909,"id":174908,"goal":"lemma MulAssoc_4909(j: int, y: int, k: int)\n ensures (j * y) * k == j * (y * k)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_4910","instance":4910,"id":174909,"goal":"lemma Distrib_4910(d: nat, b: nat, m: nat)\n ensures d * (b + m) == d * b + d * m\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_4911","instance":4911,"id":174910,"goal":"lemma AddZero_4911(k: real)\n ensures k + 0 == k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_4912","instance":4912,"id":174911,"goal":"lemma MulOne_4912(z: int)\n ensures z * 1 == z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_4913","instance":4913,"id":174912,"goal":"lemma MulZero_4913(b: nat)\n ensures b * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_4914","instance":4914,"id":174913,"goal":"lemma LeRefl_4914(b: real)\n ensures b <= b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_4915","instance":4915,"id":174914,"goal":"lemma LeTrans_4915(b: int, x: int, c: int)\n requires b <= x && x <= c\n ensures b <= c\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_4916","instance":4916,"id":174915,"goal":"lemma AddMono_4916(m: nat, b: nat, j: nat)\n requires m <= b\n ensures m + j <= b + j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_4917","instance":4917,"id":174916,"goal":"lemma Abs_Nonneg_4917(i: real)\n ensures (if i >= 0 then i else -i) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_4918","instance":4918,"id":174917,"goal":"lemma DivMod_4918(b: int, i: int)\n requires i > 0\n ensures b == i * (b / i) + (b % i)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_4919","instance":4919,"id":174918,"goal":"lemma ModBounds_4919(a: nat, b: nat)\n requires b > 0\n ensures 0 <= a % b < b\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_4920","instance":4920,"id":174919,"goal":"lemma Square_Nonneg_4920(z: real)\n ensures z * z >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_4921","instance":4921,"id":174920,"goal":"lemma AddComm_4921(b: int, j: int)\n ensures b + j == j + b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_4922","instance":4922,"id":174921,"goal":"lemma AddAssoc_4922(b: nat, m: nat, x: nat)\n ensures (b + m) + x == b + (m + x)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_4923","instance":4923,"id":174922,"goal":"lemma MulComm_4923(z: real, a: real)\n ensures z * a == a * z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_4924","instance":4924,"id":174923,"goal":"lemma MulAssoc_4924(z: int, y: int, d: int)\n ensures (z * y) * d == z * (y * d)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_4925","instance":4925,"id":174924,"goal":"lemma Distrib_4925(d: nat, k: nat, z: nat)\n ensures d * (k + z) == d * k + d * z\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_4926","instance":4926,"id":174925,"goal":"lemma AddZero_4926(m: real)\n ensures m + 0 == m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_4927","instance":4927,"id":174926,"goal":"lemma MulOne_4927(b: int)\n ensures b * 1 == b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_4928","instance":4928,"id":174927,"goal":"lemma MulZero_4928(c: nat)\n ensures c * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_4929","instance":4929,"id":174928,"goal":"lemma LeRefl_4929(c: real)\n ensures c <= c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_4930","instance":4930,"id":174929,"goal":"lemma LeTrans_4930(n: int, y: int, a: int)\n requires n <= y && y <= a\n ensures n <= a\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_4931","instance":4931,"id":174930,"goal":"lemma AddMono_4931(d: nat, z: nat, b: nat)\n requires d <= z\n ensures d + b <= z + b\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_4932","instance":4932,"id":174931,"goal":"lemma Abs_Nonneg_4932(b: real)\n ensures (if b >= 0 then b else -b) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_4933","instance":4933,"id":174932,"goal":"lemma DivMod_4933(i: int, n: int)\n requires n > 0\n ensures i == n * (i / n) + (i % n)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_4934","instance":4934,"id":174933,"goal":"lemma ModBounds_4934(m: nat, n: nat)\n requires n > 0\n ensures 0 <= m % n < n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_4935","instance":4935,"id":174934,"goal":"lemma Square_Nonneg_4935(x: real)\n ensures x * x >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_4936","instance":4936,"id":174935,"goal":"lemma AddComm_4936(y: int, a: int)\n ensures y + a == a + y\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_4937","instance":4937,"id":174936,"goal":"lemma AddAssoc_4937(y: nat, i: nat, z: nat)\n ensures (y + i) + z == y + (i + z)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_4938","instance":4938,"id":174937,"goal":"lemma MulComm_4938(a: real, k: real)\n ensures a * k == k * a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_4939","instance":4939,"id":174938,"goal":"lemma MulAssoc_4939(d: int, m: int, a: int)\n ensures (d * m) * a == d * (m * a)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_4940","instance":4940,"id":174939,"goal":"lemma Distrib_4940(i: nat, m: nat, y: nat)\n ensures i * (m + y) == i * m + i * y\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_4941","instance":4941,"id":174940,"goal":"lemma AddZero_4941(a: real)\n ensures a + 0 == a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_4942","instance":4942,"id":174941,"goal":"lemma MulOne_4942(x: int)\n ensures x * 1 == x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_4943","instance":4943,"id":174942,"goal":"lemma MulZero_4943(c: nat)\n ensures c * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_4944","instance":4944,"id":174943,"goal":"lemma LeRefl_4944(c: real)\n ensures c <= c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_4945","instance":4945,"id":174944,"goal":"lemma LeTrans_4945(c: int, k: int, j: int)\n requires c <= k && k <= j\n ensures c <= j\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_4946","instance":4946,"id":174945,"goal":"lemma AddMono_4946(d: nat, m: nat, j: nat)\n requires d <= m\n ensures d + j <= m + j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_4947","instance":4947,"id":174946,"goal":"lemma Abs_Nonneg_4947(n: real)\n ensures (if n >= 0 then n else -n) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_4948","instance":4948,"id":174947,"goal":"lemma DivMod_4948(z: int, a: int)\n requires a > 0\n ensures z == a * (z / a) + (z % a)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_4949","instance":4949,"id":174948,"goal":"lemma ModBounds_4949(b: nat, m: nat)\n requires m > 0\n ensures 0 <= b % m < m\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_4950","instance":4950,"id":174949,"goal":"lemma Square_Nonneg_4950(m: real)\n ensures m * m >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_4951","instance":4951,"id":174950,"goal":"lemma AddComm_4951(z: int, b: int)\n ensures z + b == b + z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_4952","instance":4952,"id":174951,"goal":"lemma AddAssoc_4952(n: nat, a: nat, z: nat)\n ensures (n + a) + z == n + (a + z)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_4953","instance":4953,"id":174952,"goal":"lemma MulComm_4953(d: real, x: real)\n ensures d * x == x * d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_4954","instance":4954,"id":174953,"goal":"lemma MulAssoc_4954(n: int, y: int, x: int)\n ensures (n * y) * x == n * (y * x)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_4955","instance":4955,"id":174954,"goal":"lemma Distrib_4955(b: nat, c: nat, j: nat)\n ensures b * (c + j) == b * c + b * j\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_4956","instance":4956,"id":174955,"goal":"lemma AddZero_4956(m: real)\n ensures m + 0 == m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_4957","instance":4957,"id":174956,"goal":"lemma MulOne_4957(c: int)\n ensures c * 1 == c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_4958","instance":4958,"id":174957,"goal":"lemma MulZero_4958(n: nat)\n ensures n * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_4959","instance":4959,"id":174958,"goal":"lemma LeRefl_4959(d: real)\n ensures d <= d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_4960","instance":4960,"id":174959,"goal":"lemma LeTrans_4960(n: int, j: int, k: int)\n requires n <= j && j <= k\n ensures n <= k\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_4961","instance":4961,"id":174960,"goal":"lemma AddMono_4961(z: nat, j: nat, c: nat)\n requires z <= j\n ensures z + c <= j + c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_4962","instance":4962,"id":174961,"goal":"lemma Abs_Nonneg_4962(i: real)\n ensures (if i >= 0 then i else -i) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_4963","instance":4963,"id":174962,"goal":"lemma DivMod_4963(n: int, y: int)\n requires y > 0\n ensures n == y * (n / y) + (n % y)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_4964","instance":4964,"id":174963,"goal":"lemma ModBounds_4964(x: nat, i: nat)\n requires i > 0\n ensures 0 <= x % i < i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_4965","instance":4965,"id":174964,"goal":"lemma Square_Nonneg_4965(c: real)\n ensures c * c >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_4966","instance":4966,"id":174965,"goal":"lemma AddComm_4966(m: int, j: int)\n ensures m + j == j + m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_4967","instance":4967,"id":174966,"goal":"lemma AddAssoc_4967(x: nat, y: nat, n: nat)\n ensures (x + y) + n == x + (y + n)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_4968","instance":4968,"id":174967,"goal":"lemma MulComm_4968(c: real, m: real)\n ensures c * m == m * c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_4969","instance":4969,"id":174968,"goal":"lemma MulAssoc_4969(y: int, c: int, z: int)\n ensures (y * c) * z == y * (c * z)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_4970","instance":4970,"id":174969,"goal":"lemma Distrib_4970(i: nat, j: nat, k: nat)\n ensures i * (j + k) == i * j + i * k\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_4971","instance":4971,"id":174970,"goal":"lemma AddZero_4971(x: real)\n ensures x + 0 == x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_4972","instance":4972,"id":174971,"goal":"lemma MulOne_4972(b: int)\n ensures b * 1 == b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_4973","instance":4973,"id":174972,"goal":"lemma MulZero_4973(j: nat)\n ensures j * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_4974","instance":4974,"id":174973,"goal":"lemma LeRefl_4974(d: real)\n ensures d <= d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_4975","instance":4975,"id":174974,"goal":"lemma LeTrans_4975(x: int, d: int, c: int)\n requires x <= d && d <= c\n ensures x <= c\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_4976","instance":4976,"id":174975,"goal":"lemma AddMono_4976(d: nat, b: nat, k: nat)\n requires d <= b\n ensures d + k <= b + k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_4977","instance":4977,"id":174976,"goal":"lemma Abs_Nonneg_4977(x: real)\n ensures (if x >= 0 then x else -x) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_4978","instance":4978,"id":174977,"goal":"lemma DivMod_4978(d: int, b: int)\n requires b > 0\n ensures d == b * (d / b) + (d % b)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_4979","instance":4979,"id":174978,"goal":"lemma ModBounds_4979(y: nat, d: nat)\n requires d > 0\n ensures 0 <= y % d < d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_4980","instance":4980,"id":174979,"goal":"lemma Square_Nonneg_4980(x: real)\n ensures x * x >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_4981","instance":4981,"id":174980,"goal":"lemma AddComm_4981(y: int, j: int)\n ensures y + j == j + y\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_4982","instance":4982,"id":174981,"goal":"lemma AddAssoc_4982(m: nat, b: nat, x: nat)\n ensures (m + b) + x == m + (b + x)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_4983","instance":4983,"id":174982,"goal":"lemma MulComm_4983(c: real, n: real)\n ensures c * n == n * c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_4984","instance":4984,"id":174983,"goal":"lemma MulAssoc_4984(y: int, z: int, k: int)\n ensures (y * z) * k == y * (z * k)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_4985","instance":4985,"id":174984,"goal":"lemma Distrib_4985(c: nat, y: nat, x: nat)\n ensures c * (y + x) == c * y + c * x\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_4986","instance":4986,"id":174985,"goal":"lemma AddZero_4986(i: real)\n ensures i + 0 == i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_4987","instance":4987,"id":174986,"goal":"lemma MulOne_4987(y: int)\n ensures y * 1 == y\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_4988","instance":4988,"id":174987,"goal":"lemma MulZero_4988(z: nat)\n ensures z * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_4989","instance":4989,"id":174988,"goal":"lemma LeRefl_4989(k: real)\n ensures k <= k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_4990","instance":4990,"id":174989,"goal":"lemma LeTrans_4990(a: int, c: int, z: int)\n requires a <= c && c <= z\n ensures a <= z\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_4991","instance":4991,"id":174990,"goal":"lemma AddMono_4991(b: nat, d: nat, x: nat)\n requires b <= d\n ensures b + x <= d + x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_4992","instance":4992,"id":174991,"goal":"lemma Abs_Nonneg_4992(n: real)\n ensures (if n >= 0 then n else -n) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_4993","instance":4993,"id":174992,"goal":"lemma DivMod_4993(n: int, i: int)\n requires i > 0\n ensures n == i * (n / i) + (n % i)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_4994","instance":4994,"id":174993,"goal":"lemma ModBounds_4994(z: nat, n: nat)\n requires n > 0\n ensures 0 <= z % n < n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_4995","instance":4995,"id":174994,"goal":"lemma Square_Nonneg_4995(y: real)\n ensures y * y >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_4996","instance":4996,"id":174995,"goal":"lemma AddComm_4996(z: int, a: int)\n ensures z + a == a + z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_4997","instance":4997,"id":174996,"goal":"lemma AddAssoc_4997(z: nat, k: nat, a: nat)\n ensures (z + k) + a == z + (k + a)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_4998","instance":4998,"id":174997,"goal":"lemma MulComm_4998(z: real, y: real)\n ensures z * y == y * z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_4999","instance":4999,"id":174998,"goal":"lemma MulAssoc_4999(m: int, z: int, d: int)\n ensures (m * z) * d == m * (z * d)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_5000","instance":5000,"id":174999,"goal":"lemma Distrib_5000(m: nat, x: nat, c: nat)\n ensures m * (x + c) == m * x + m * c\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_5001","instance":5001,"id":175000,"goal":"lemma AddZero_5001(a: real)\n ensures a + 0 == a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_5002","instance":5002,"id":175001,"goal":"lemma MulOne_5002(a: int)\n ensures a * 1 == a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_5003","instance":5003,"id":175002,"goal":"lemma MulZero_5003(i: nat)\n ensures i * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_5004","instance":5004,"id":175003,"goal":"lemma LeRefl_5004(j: real)\n ensures j <= j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_5005","instance":5005,"id":175004,"goal":"lemma LeTrans_5005(d: int, b: int, z: int)\n requires d <= b && b <= z\n ensures d <= z\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_5006","instance":5006,"id":175005,"goal":"lemma AddMono_5006(c: nat, x: nat, n: nat)\n requires c <= x\n ensures c + n <= x + n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_5007","instance":5007,"id":175006,"goal":"lemma Abs_Nonneg_5007(a: real)\n ensures (if a >= 0 then a else -a) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_5008","instance":5008,"id":175007,"goal":"lemma DivMod_5008(a: int, m: int)\n requires m > 0\n ensures a == m * (a / m) + (a % m)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_5009","instance":5009,"id":175008,"goal":"lemma ModBounds_5009(z: nat, c: nat)\n requires c > 0\n ensures 0 <= z % c < c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_5010","instance":5010,"id":175009,"goal":"lemma Square_Nonneg_5010(x: real)\n ensures x * x >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_5011","instance":5011,"id":175010,"goal":"lemma AddComm_5011(n: int, k: int)\n ensures n + k == k + n\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_5012","instance":5012,"id":175011,"goal":"lemma AddAssoc_5012(m: nat, k: nat, d: nat)\n ensures (m + k) + d == m + (k + d)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_5013","instance":5013,"id":175012,"goal":"lemma MulComm_5013(y: real, n: real)\n ensures y * n == n * y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_5014","instance":5014,"id":175013,"goal":"lemma MulAssoc_5014(a: int, b: int, m: int)\n ensures (a * b) * m == a * (b * m)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_5015","instance":5015,"id":175014,"goal":"lemma Distrib_5015(m: nat, k: nat, d: nat)\n ensures m * (k + d) == m * k + m * d\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_5016","instance":5016,"id":175015,"goal":"lemma AddZero_5016(j: real)\n ensures j + 0 == j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_5017","instance":5017,"id":175016,"goal":"lemma MulOne_5017(z: int)\n ensures z * 1 == z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_5018","instance":5018,"id":175017,"goal":"lemma MulZero_5018(c: nat)\n ensures c * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_5019","instance":5019,"id":175018,"goal":"lemma LeRefl_5019(x: real)\n ensures x <= x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_5020","instance":5020,"id":175019,"goal":"lemma LeTrans_5020(z: int, k: int, d: int)\n requires z <= k && k <= d\n ensures z <= d\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_5021","instance":5021,"id":175020,"goal":"lemma AddMono_5021(n: nat, i: nat, d: nat)\n requires n <= i\n ensures n + d <= i + d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_5022","instance":5022,"id":175021,"goal":"lemma Abs_Nonneg_5022(i: real)\n ensures (if i >= 0 then i else -i) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_5023","instance":5023,"id":175022,"goal":"lemma DivMod_5023(z: int, c: int)\n requires c > 0\n ensures z == c * (z / c) + (z % c)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_5024","instance":5024,"id":175023,"goal":"lemma ModBounds_5024(c: nat, n: nat)\n requires n > 0\n ensures 0 <= c % n < n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_5025","instance":5025,"id":175024,"goal":"lemma Square_Nonneg_5025(a: real)\n ensures a * a >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_5026","instance":5026,"id":175025,"goal":"lemma AddComm_5026(x: int, m: int)\n ensures x + m == m + x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_5027","instance":5027,"id":175026,"goal":"lemma AddAssoc_5027(z: nat, m: nat, d: nat)\n ensures (z + m) + d == z + (m + d)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_5028","instance":5028,"id":175027,"goal":"lemma MulComm_5028(b: real, c: real)\n ensures b * c == c * b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_5029","instance":5029,"id":175028,"goal":"lemma MulAssoc_5029(y: int, c: int, d: int)\n ensures (y * c) * d == y * (c * d)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_5030","instance":5030,"id":175029,"goal":"lemma Distrib_5030(i: nat, x: nat, d: nat)\n ensures i * (x + d) == i * x + i * d\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_5031","instance":5031,"id":175030,"goal":"lemma AddZero_5031(d: real)\n ensures d + 0 == d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_5032","instance":5032,"id":175031,"goal":"lemma MulOne_5032(k: int)\n ensures k * 1 == k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_5033","instance":5033,"id":175032,"goal":"lemma MulZero_5033(x: nat)\n ensures x * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_5034","instance":5034,"id":175033,"goal":"lemma LeRefl_5034(m: real)\n ensures m <= m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_5035","instance":5035,"id":175034,"goal":"lemma LeTrans_5035(x: int, m: int, y: int)\n requires x <= m && m <= y\n ensures x <= y\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_5036","instance":5036,"id":175035,"goal":"lemma AddMono_5036(k: nat, b: nat, c: nat)\n requires k <= b\n ensures k + c <= b + c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_5037","instance":5037,"id":175036,"goal":"lemma Abs_Nonneg_5037(m: real)\n ensures (if m >= 0 then m else -m) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_5038","instance":5038,"id":175037,"goal":"lemma DivMod_5038(a: int, j: int)\n requires j > 0\n ensures a == j * (a / j) + (a % j)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_5039","instance":5039,"id":175038,"goal":"lemma ModBounds_5039(m: nat, i: nat)\n requires i > 0\n ensures 0 <= m % i < i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_5040","instance":5040,"id":175039,"goal":"lemma Square_Nonneg_5040(z: real)\n ensures z * z >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_5041","instance":5041,"id":175040,"goal":"lemma AddComm_5041(b: int, y: int)\n ensures b + y == y + b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_5042","instance":5042,"id":175041,"goal":"lemma AddAssoc_5042(a: nat, k: nat, y: nat)\n ensures (a + k) + y == a + (k + y)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_5043","instance":5043,"id":175042,"goal":"lemma MulComm_5043(i: real, n: real)\n ensures i * n == n * i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_5044","instance":5044,"id":175043,"goal":"lemma MulAssoc_5044(z: int, n: int, c: int)\n ensures (z * n) * c == z * (n * c)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_5045","instance":5045,"id":175044,"goal":"lemma Distrib_5045(a: nat, c: nat, n: nat)\n ensures a * (c + n) == a * c + a * n\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_5046","instance":5046,"id":175045,"goal":"lemma AddZero_5046(a: real)\n ensures a + 0 == a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_5047","instance":5047,"id":175046,"goal":"lemma MulOne_5047(a: int)\n ensures a * 1 == a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_5048","instance":5048,"id":175047,"goal":"lemma MulZero_5048(m: nat)\n ensures m * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_5049","instance":5049,"id":175048,"goal":"lemma LeRefl_5049(b: real)\n ensures b <= b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_5050","instance":5050,"id":175049,"goal":"lemma LeTrans_5050(c: int, n: int, j: int)\n requires c <= n && n <= j\n ensures c <= j\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_5051","instance":5051,"id":175050,"goal":"lemma AddMono_5051(j: nat, z: nat, d: nat)\n requires j <= z\n ensures j + d <= z + d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_5052","instance":5052,"id":175051,"goal":"lemma Abs_Nonneg_5052(x: real)\n ensures (if x >= 0 then x else -x) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_5053","instance":5053,"id":175052,"goal":"lemma DivMod_5053(x: int, j: int)\n requires j > 0\n ensures x == j * (x / j) + (x % j)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_5054","instance":5054,"id":175053,"goal":"lemma ModBounds_5054(j: nat, c: nat)\n requires c > 0\n ensures 0 <= j % c < c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_5055","instance":5055,"id":175054,"goal":"lemma Square_Nonneg_5055(k: real)\n ensures k * k >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_5056","instance":5056,"id":175055,"goal":"lemma AddComm_5056(y: int, x: int)\n ensures y + x == x + y\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_5057","instance":5057,"id":175056,"goal":"lemma AddAssoc_5057(m: nat, n: nat, c: nat)\n ensures (m + n) + c == m + (n + c)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_5058","instance":5058,"id":175057,"goal":"lemma MulComm_5058(y: real, b: real)\n ensures y * b == b * y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_5059","instance":5059,"id":175058,"goal":"lemma MulAssoc_5059(d: int, n: int, j: int)\n ensures (d * n) * j == d * (n * j)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_5060","instance":5060,"id":175059,"goal":"lemma Distrib_5060(n: nat, c: nat, d: nat)\n ensures n * (c + d) == n * c + n * d\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_5061","instance":5061,"id":175060,"goal":"lemma AddZero_5061(j: real)\n ensures j + 0 == j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_5062","instance":5062,"id":175061,"goal":"lemma MulOne_5062(y: int)\n ensures y * 1 == y\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_5063","instance":5063,"id":175062,"goal":"lemma MulZero_5063(d: nat)\n ensures d * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_5064","instance":5064,"id":175063,"goal":"lemma LeRefl_5064(d: real)\n ensures d <= d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_5065","instance":5065,"id":175064,"goal":"lemma LeTrans_5065(m: int, b: int, k: int)\n requires m <= b && b <= k\n ensures m <= k\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_5066","instance":5066,"id":175065,"goal":"lemma AddMono_5066(j: nat, y: nat, k: nat)\n requires j <= y\n ensures j + k <= y + k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_5067","instance":5067,"id":175066,"goal":"lemma Abs_Nonneg_5067(n: real)\n ensures (if n >= 0 then n else -n) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_5068","instance":5068,"id":175067,"goal":"lemma DivMod_5068(y: int, m: int)\n requires m > 0\n ensures y == m * (y / m) + (y % m)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_5069","instance":5069,"id":175068,"goal":"lemma ModBounds_5069(a: nat, d: nat)\n requires d > 0\n ensures 0 <= a % d < d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_5070","instance":5070,"id":175069,"goal":"lemma Square_Nonneg_5070(k: real)\n ensures k * k >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_5071","instance":5071,"id":175070,"goal":"lemma AddComm_5071(a: int, c: int)\n ensures a + c == c + a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_5072","instance":5072,"id":175071,"goal":"lemma AddAssoc_5072(x: nat, z: nat, a: nat)\n ensures (x + z) + a == x + (z + a)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_5073","instance":5073,"id":175072,"goal":"lemma MulComm_5073(b: real, m: real)\n ensures b * m == m * b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_5074","instance":5074,"id":175073,"goal":"lemma MulAssoc_5074(b: int, k: int, x: int)\n ensures (b * k) * x == b * (k * x)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_5075","instance":5075,"id":175074,"goal":"lemma Distrib_5075(z: nat, y: nat, j: nat)\n ensures z * (y + j) == z * y + z * j\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_5076","instance":5076,"id":175075,"goal":"lemma AddZero_5076(x: real)\n ensures x + 0 == x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_5077","instance":5077,"id":175076,"goal":"lemma MulOne_5077(j: int)\n ensures j * 1 == j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_5078","instance":5078,"id":175077,"goal":"lemma MulZero_5078(x: nat)\n ensures x * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_5079","instance":5079,"id":175078,"goal":"lemma LeRefl_5079(d: real)\n ensures d <= d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_5080","instance":5080,"id":175079,"goal":"lemma LeTrans_5080(z: int, n: int, j: int)\n requires z <= n && n <= j\n ensures z <= j\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_5081","instance":5081,"id":175080,"goal":"lemma AddMono_5081(b: nat, y: nat, a: nat)\n requires b <= y\n ensures b + a <= y + a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_5082","instance":5082,"id":175081,"goal":"lemma Abs_Nonneg_5082(i: real)\n ensures (if i >= 0 then i else -i) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_5083","instance":5083,"id":175082,"goal":"lemma DivMod_5083(i: int, n: int)\n requires n > 0\n ensures i == n * (i / n) + (i % n)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_5084","instance":5084,"id":175083,"goal":"lemma ModBounds_5084(j: nat, z: nat)\n requires z > 0\n ensures 0 <= j % z < z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_5085","instance":5085,"id":175084,"goal":"lemma Square_Nonneg_5085(a: real)\n ensures a * a >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_5086","instance":5086,"id":175085,"goal":"lemma AddComm_5086(n: int, i: int)\n ensures n + i == i + n\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_5087","instance":5087,"id":175086,"goal":"lemma AddAssoc_5087(k: nat, n: nat, i: nat)\n ensures (k + n) + i == k + (n + i)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_5088","instance":5088,"id":175087,"goal":"lemma MulComm_5088(k: real, j: real)\n ensures k * j == j * k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_5089","instance":5089,"id":175088,"goal":"lemma MulAssoc_5089(d: int, a: int, m: int)\n ensures (d * a) * m == d * (a * m)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_5090","instance":5090,"id":175089,"goal":"lemma Distrib_5090(n: nat, y: nat, k: nat)\n ensures n * (y + k) == n * y + n * k\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_5091","instance":5091,"id":175090,"goal":"lemma AddZero_5091(m: real)\n ensures m + 0 == m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_5092","instance":5092,"id":175091,"goal":"lemma MulOne_5092(d: int)\n ensures d * 1 == d\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_5093","instance":5093,"id":175092,"goal":"lemma MulZero_5093(c: nat)\n ensures c * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_5094","instance":5094,"id":175093,"goal":"lemma LeRefl_5094(j: real)\n ensures j <= j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_5095","instance":5095,"id":175094,"goal":"lemma LeTrans_5095(c: int, z: int, a: int)\n requires c <= z && z <= a\n ensures c <= a\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_5096","instance":5096,"id":175095,"goal":"lemma AddMono_5096(m: nat, d: nat, x: nat)\n requires m <= d\n ensures m + x <= d + x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_5097","instance":5097,"id":175096,"goal":"lemma Abs_Nonneg_5097(i: real)\n ensures (if i >= 0 then i else -i) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_5098","instance":5098,"id":175097,"goal":"lemma DivMod_5098(i: int, c: int)\n requires c > 0\n ensures i == c * (i / c) + (i % c)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_5099","instance":5099,"id":175098,"goal":"lemma ModBounds_5099(i: nat, d: nat)\n requires d > 0\n ensures 0 <= i % d < d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_5100","instance":5100,"id":175099,"goal":"lemma Square_Nonneg_5100(a: real)\n ensures a * a >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_5101","instance":5101,"id":175100,"goal":"lemma AddComm_5101(b: int, a: int)\n ensures b + a == a + b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_5102","instance":5102,"id":175101,"goal":"lemma AddAssoc_5102(j: nat, a: nat, k: nat)\n ensures (j + a) + k == j + (a + k)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_5103","instance":5103,"id":175102,"goal":"lemma MulComm_5103(m: real, a: real)\n ensures m * a == a * m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_5104","instance":5104,"id":175103,"goal":"lemma MulAssoc_5104(k: int, m: int, a: int)\n ensures (k * m) * a == k * (m * a)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_5105","instance":5105,"id":175104,"goal":"lemma Distrib_5105(x: nat, m: nat, i: nat)\n ensures x * (m + i) == x * m + x * i\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_5106","instance":5106,"id":175105,"goal":"lemma AddZero_5106(i: real)\n ensures i + 0 == i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_5107","instance":5107,"id":175106,"goal":"lemma MulOne_5107(b: int)\n ensures b * 1 == b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_5108","instance":5108,"id":175107,"goal":"lemma MulZero_5108(n: nat)\n ensures n * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_5109","instance":5109,"id":175108,"goal":"lemma LeRefl_5109(j: real)\n ensures j <= j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_5110","instance":5110,"id":175109,"goal":"lemma LeTrans_5110(m: int, b: int, x: int)\n requires m <= b && b <= x\n ensures m <= x\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_5111","instance":5111,"id":175110,"goal":"lemma AddMono_5111(i: nat, j: nat, k: nat)\n requires i <= j\n ensures i + k <= j + k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_5112","instance":5112,"id":175111,"goal":"lemma Abs_Nonneg_5112(x: real)\n ensures (if x >= 0 then x else -x) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_5113","instance":5113,"id":175112,"goal":"lemma DivMod_5113(j: int, y: int)\n requires y > 0\n ensures j == y * (j / y) + (j % y)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_5114","instance":5114,"id":175113,"goal":"lemma ModBounds_5114(i: nat, a: nat)\n requires a > 0\n ensures 0 <= i % a < a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_5115","instance":5115,"id":175114,"goal":"lemma Square_Nonneg_5115(y: real)\n ensures y * y >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_5116","instance":5116,"id":175115,"goal":"lemma AddComm_5116(c: int, n: int)\n ensures c + n == n + c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_5117","instance":5117,"id":175116,"goal":"lemma AddAssoc_5117(j: nat, d: nat, x: nat)\n ensures (j + d) + x == j + (d + x)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_5118","instance":5118,"id":175117,"goal":"lemma MulComm_5118(i: real, x: real)\n ensures i * x == x * i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_5119","instance":5119,"id":175118,"goal":"lemma MulAssoc_5119(d: int, k: int, c: int)\n ensures (d * k) * c == d * (k * c)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_5120","instance":5120,"id":175119,"goal":"lemma Distrib_5120(y: nat, x: nat, n: nat)\n ensures y * (x + n) == y * x + y * n\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_5121","instance":5121,"id":175120,"goal":"lemma AddZero_5121(j: real)\n ensures j + 0 == j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_5122","instance":5122,"id":175121,"goal":"lemma MulOne_5122(k: int)\n ensures k * 1 == k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_5123","instance":5123,"id":175122,"goal":"lemma MulZero_5123(x: nat)\n ensures x * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_5124","instance":5124,"id":175123,"goal":"lemma LeRefl_5124(m: real)\n ensures m <= m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_5125","instance":5125,"id":175124,"goal":"lemma LeTrans_5125(z: int, x: int, n: int)\n requires z <= x && x <= n\n ensures z <= n\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_5126","instance":5126,"id":175125,"goal":"lemma AddMono_5126(x: nat, k: nat, b: nat)\n requires x <= k\n ensures x + b <= k + b\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_5127","instance":5127,"id":175126,"goal":"lemma Abs_Nonneg_5127(x: real)\n ensures (if x >= 0 then x else -x) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_5128","instance":5128,"id":175127,"goal":"lemma DivMod_5128(b: int, k: int)\n requires k > 0\n ensures b == k * (b / k) + (b % k)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_5129","instance":5129,"id":175128,"goal":"lemma ModBounds_5129(k: nat, i: nat)\n requires i > 0\n ensures 0 <= k % i < i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_5130","instance":5130,"id":175129,"goal":"lemma Square_Nonneg_5130(b: real)\n ensures b * b >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_5131","instance":5131,"id":175130,"goal":"lemma AddComm_5131(y: int, m: int)\n ensures y + m == m + y\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_5132","instance":5132,"id":175131,"goal":"lemma AddAssoc_5132(x: nat, z: nat, m: nat)\n ensures (x + z) + m == x + (z + m)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_5133","instance":5133,"id":175132,"goal":"lemma MulComm_5133(k: real, n: real)\n ensures k * n == n * k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_5134","instance":5134,"id":175133,"goal":"lemma MulAssoc_5134(b: int, d: int, c: int)\n ensures (b * d) * c == b * (d * c)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_5135","instance":5135,"id":175134,"goal":"lemma Distrib_5135(b: nat, i: nat, y: nat)\n ensures b * (i + y) == b * i + b * y\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_5136","instance":5136,"id":175135,"goal":"lemma AddZero_5136(i: real)\n ensures i + 0 == i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_5137","instance":5137,"id":175136,"goal":"lemma MulOne_5137(z: int)\n ensures z * 1 == z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_5138","instance":5138,"id":175137,"goal":"lemma MulZero_5138(c: nat)\n ensures c * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_5139","instance":5139,"id":175138,"goal":"lemma LeRefl_5139(j: real)\n ensures j <= j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_5140","instance":5140,"id":175139,"goal":"lemma LeTrans_5140(b: int, z: int, n: int)\n requires b <= z && z <= n\n ensures b <= n\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_5141","instance":5141,"id":175140,"goal":"lemma AddMono_5141(y: nat, c: nat, k: nat)\n requires y <= c\n ensures y + k <= c + k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_5142","instance":5142,"id":175141,"goal":"lemma Abs_Nonneg_5142(x: real)\n ensures (if x >= 0 then x else -x) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_5143","instance":5143,"id":175142,"goal":"lemma DivMod_5143(d: int, j: int)\n requires j > 0\n ensures d == j * (d / j) + (d % j)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_5144","instance":5144,"id":175143,"goal":"lemma ModBounds_5144(m: nat, j: nat)\n requires j > 0\n ensures 0 <= m % j < j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_5145","instance":5145,"id":175144,"goal":"lemma Square_Nonneg_5145(k: real)\n ensures k * k >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_5146","instance":5146,"id":175145,"goal":"lemma AddComm_5146(i: int, n: int)\n ensures i + n == n + i\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_5147","instance":5147,"id":175146,"goal":"lemma AddAssoc_5147(n: nat, c: nat, d: nat)\n ensures (n + c) + d == n + (c + d)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_5148","instance":5148,"id":175147,"goal":"lemma MulComm_5148(y: real, d: real)\n ensures y * d == d * y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_5149","instance":5149,"id":175148,"goal":"lemma MulAssoc_5149(k: int, b: int, y: int)\n ensures (k * b) * y == k * (b * y)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_5150","instance":5150,"id":175149,"goal":"lemma Distrib_5150(d: nat, k: nat, b: nat)\n ensures d * (k + b) == d * k + d * b\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_5151","instance":5151,"id":175150,"goal":"lemma AddZero_5151(j: real)\n ensures j + 0 == j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_5152","instance":5152,"id":175151,"goal":"lemma MulOne_5152(m: int)\n ensures m * 1 == m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_5153","instance":5153,"id":175152,"goal":"lemma MulZero_5153(c: nat)\n ensures c * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_5154","instance":5154,"id":175153,"goal":"lemma LeRefl_5154(i: real)\n ensures i <= i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_5155","instance":5155,"id":175154,"goal":"lemma LeTrans_5155(m: int, c: int, k: int)\n requires m <= c && c <= k\n ensures m <= k\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_5156","instance":5156,"id":175155,"goal":"lemma AddMono_5156(b: nat, d: nat, n: nat)\n requires b <= d\n ensures b + n <= d + n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_5157","instance":5157,"id":175156,"goal":"lemma Abs_Nonneg_5157(y: real)\n ensures (if y >= 0 then y else -y) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_5158","instance":5158,"id":175157,"goal":"lemma DivMod_5158(d: int, m: int)\n requires m > 0\n ensures d == m * (d / m) + (d % m)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_5159","instance":5159,"id":175158,"goal":"lemma ModBounds_5159(d: nat, m: nat)\n requires m > 0\n ensures 0 <= d % m < m\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_5160","instance":5160,"id":175159,"goal":"lemma Square_Nonneg_5160(c: real)\n ensures c * c >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_5161","instance":5161,"id":175160,"goal":"lemma AddComm_5161(x: int, a: int)\n ensures x + a == a + x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_5162","instance":5162,"id":175161,"goal":"lemma AddAssoc_5162(y: nat, x: nat, j: nat)\n ensures (y + x) + j == y + (x + j)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_5163","instance":5163,"id":175162,"goal":"lemma MulComm_5163(c: real, z: real)\n ensures c * z == z * c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_5164","instance":5164,"id":175163,"goal":"lemma MulAssoc_5164(x: int, a: int, y: int)\n ensures (x * a) * y == x * (a * y)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_5165","instance":5165,"id":175164,"goal":"lemma Distrib_5165(z: nat, c: nat, m: nat)\n ensures z * (c + m) == z * c + z * m\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_5166","instance":5166,"id":175165,"goal":"lemma AddZero_5166(j: real)\n ensures j + 0 == j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_5167","instance":5167,"id":175166,"goal":"lemma MulOne_5167(d: int)\n ensures d * 1 == d\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_5168","instance":5168,"id":175167,"goal":"lemma MulZero_5168(j: nat)\n ensures j * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_5169","instance":5169,"id":175168,"goal":"lemma LeRefl_5169(j: real)\n ensures j <= j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_5170","instance":5170,"id":175169,"goal":"lemma LeTrans_5170(k: int, z: int, i: int)\n requires k <= z && z <= i\n ensures k <= i\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_5171","instance":5171,"id":175170,"goal":"lemma AddMono_5171(z: nat, n: nat, b: nat)\n requires z <= n\n ensures z + b <= n + b\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_5172","instance":5172,"id":175171,"goal":"lemma Abs_Nonneg_5172(z: real)\n ensures (if z >= 0 then z else -z) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_5173","instance":5173,"id":175172,"goal":"lemma DivMod_5173(i: int, x: int)\n requires x > 0\n ensures i == x * (i / x) + (i % x)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_5174","instance":5174,"id":175173,"goal":"lemma ModBounds_5174(j: nat, m: nat)\n requires m > 0\n ensures 0 <= j % m < m\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_5175","instance":5175,"id":175174,"goal":"lemma Square_Nonneg_5175(y: real)\n ensures y * y >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_5176","instance":5176,"id":175175,"goal":"lemma AddComm_5176(m: int, a: int)\n ensures m + a == a + m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_5177","instance":5177,"id":175176,"goal":"lemma AddAssoc_5177(d: nat, i: nat, y: nat)\n ensures (d + i) + y == d + (i + y)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_5178","instance":5178,"id":175177,"goal":"lemma MulComm_5178(y: real, m: real)\n ensures y * m == m * y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_5179","instance":5179,"id":175178,"goal":"lemma MulAssoc_5179(b: int, a: int, z: int)\n ensures (b * a) * z == b * (a * z)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_5180","instance":5180,"id":175179,"goal":"lemma Distrib_5180(b: nat, j: nat, d: nat)\n ensures b * (j + d) == b * j + b * d\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_5181","instance":5181,"id":175180,"goal":"lemma AddZero_5181(k: real)\n ensures k + 0 == k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_5182","instance":5182,"id":175181,"goal":"lemma MulOne_5182(i: int)\n ensures i * 1 == i\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_5183","instance":5183,"id":175182,"goal":"lemma MulZero_5183(a: nat)\n ensures a * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_5184","instance":5184,"id":175183,"goal":"lemma LeRefl_5184(y: real)\n ensures y <= y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_5185","instance":5185,"id":175184,"goal":"lemma LeTrans_5185(z: int, x: int, m: int)\n requires z <= x && x <= m\n ensures z <= m\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_5186","instance":5186,"id":175185,"goal":"lemma AddMono_5186(m: nat, b: nat, a: nat)\n requires m <= b\n ensures m + a <= b + a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_5187","instance":5187,"id":175186,"goal":"lemma Abs_Nonneg_5187(a: real)\n ensures (if a >= 0 then a else -a) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_5188","instance":5188,"id":175187,"goal":"lemma DivMod_5188(k: int, m: int)\n requires m > 0\n ensures k == m * (k / m) + (k % m)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_5189","instance":5189,"id":175188,"goal":"lemma ModBounds_5189(k: nat, y: nat)\n requires y > 0\n ensures 0 <= k % y < y\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_5190","instance":5190,"id":175189,"goal":"lemma Square_Nonneg_5190(m: real)\n ensures m * m >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_5191","instance":5191,"id":175190,"goal":"lemma AddComm_5191(k: int, z: int)\n ensures k + z == z + k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_5192","instance":5192,"id":175191,"goal":"lemma AddAssoc_5192(z: nat, x: nat, j: nat)\n ensures (z + x) + j == z + (x + j)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_5193","instance":5193,"id":175192,"goal":"lemma MulComm_5193(k: real, c: real)\n ensures k * c == c * k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_5194","instance":5194,"id":175193,"goal":"lemma MulAssoc_5194(c: int, n: int, x: int)\n ensures (c * n) * x == c * (n * x)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_5195","instance":5195,"id":175194,"goal":"lemma Distrib_5195(a: nat, d: nat, x: nat)\n ensures a * (d + x) == a * d + a * x\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_5196","instance":5196,"id":175195,"goal":"lemma AddZero_5196(i: real)\n ensures i + 0 == i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_5197","instance":5197,"id":175196,"goal":"lemma MulOne_5197(y: int)\n ensures y * 1 == y\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_5198","instance":5198,"id":175197,"goal":"lemma MulZero_5198(y: nat)\n ensures y * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_5199","instance":5199,"id":175198,"goal":"lemma LeRefl_5199(m: real)\n ensures m <= m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_5200","instance":5200,"id":175199,"goal":"lemma LeTrans_5200(b: int, j: int, a: int)\n requires b <= j && j <= a\n ensures b <= a\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_5201","instance":5201,"id":175200,"goal":"lemma AddMono_5201(z: nat, d: nat, c: nat)\n requires z <= d\n ensures z + c <= d + c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_5202","instance":5202,"id":175201,"goal":"lemma Abs_Nonneg_5202(x: real)\n ensures (if x >= 0 then x else -x) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_5203","instance":5203,"id":175202,"goal":"lemma DivMod_5203(z: int, k: int)\n requires k > 0\n ensures z == k * (z / k) + (z % k)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_5204","instance":5204,"id":175203,"goal":"lemma ModBounds_5204(i: nat, a: nat)\n requires a > 0\n ensures 0 <= i % a < a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_5205","instance":5205,"id":175204,"goal":"lemma Square_Nonneg_5205(d: real)\n ensures d * d >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_5206","instance":5206,"id":175205,"goal":"lemma AddComm_5206(y: int, n: int)\n ensures y + n == n + y\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_5207","instance":5207,"id":175206,"goal":"lemma AddAssoc_5207(j: nat, a: nat, n: nat)\n ensures (j + a) + n == j + (a + n)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_5208","instance":5208,"id":175207,"goal":"lemma MulComm_5208(z: real, d: real)\n ensures z * d == d * z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_5209","instance":5209,"id":175208,"goal":"lemma MulAssoc_5209(a: int, j: int, n: int)\n ensures (a * j) * n == a * (j * n)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_5210","instance":5210,"id":175209,"goal":"lemma Distrib_5210(m: nat, y: nat, n: nat)\n ensures m * (y + n) == m * y + m * n\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_5211","instance":5211,"id":175210,"goal":"lemma AddZero_5211(x: real)\n ensures x + 0 == x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_5212","instance":5212,"id":175211,"goal":"lemma MulOne_5212(d: int)\n ensures d * 1 == d\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_5213","instance":5213,"id":175212,"goal":"lemma MulZero_5213(k: nat)\n ensures k * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_5214","instance":5214,"id":175213,"goal":"lemma LeRefl_5214(x: real)\n ensures x <= x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_5215","instance":5215,"id":175214,"goal":"lemma LeTrans_5215(d: int, b: int, z: int)\n requires d <= b && b <= z\n ensures d <= z\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_5216","instance":5216,"id":175215,"goal":"lemma AddMono_5216(m: nat, a: nat, c: nat)\n requires m <= a\n ensures m + c <= a + c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_5217","instance":5217,"id":175216,"goal":"lemma Abs_Nonneg_5217(d: real)\n ensures (if d >= 0 then d else -d) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_5218","instance":5218,"id":175217,"goal":"lemma DivMod_5218(x: int, i: int)\n requires i > 0\n ensures x == i * (x / i) + (x % i)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_5219","instance":5219,"id":175218,"goal":"lemma ModBounds_5219(z: nat, b: nat)\n requires b > 0\n ensures 0 <= z % b < b\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_5220","instance":5220,"id":175219,"goal":"lemma Square_Nonneg_5220(j: real)\n ensures j * j >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_5221","instance":5221,"id":175220,"goal":"lemma AddComm_5221(k: int, n: int)\n ensures k + n == n + k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_5222","instance":5222,"id":175221,"goal":"lemma AddAssoc_5222(k: nat, z: nat, i: nat)\n ensures (k + z) + i == k + (z + i)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_5223","instance":5223,"id":175222,"goal":"lemma MulComm_5223(z: real, y: real)\n ensures z * y == y * z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_5224","instance":5224,"id":175223,"goal":"lemma MulAssoc_5224(x: int, a: int, m: int)\n ensures (x * a) * m == x * (a * m)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_5225","instance":5225,"id":175224,"goal":"lemma Distrib_5225(x: nat, d: nat, n: nat)\n ensures x * (d + n) == x * d + x * n\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_5226","instance":5226,"id":175225,"goal":"lemma AddZero_5226(d: real)\n ensures d + 0 == d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_5227","instance":5227,"id":175226,"goal":"lemma MulOne_5227(x: int)\n ensures x * 1 == x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_5228","instance":5228,"id":175227,"goal":"lemma MulZero_5228(a: nat)\n ensures a * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_5229","instance":5229,"id":175228,"goal":"lemma LeRefl_5229(b: real)\n ensures b <= b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_5230","instance":5230,"id":175229,"goal":"lemma LeTrans_5230(n: int, c: int, d: int)\n requires n <= c && c <= d\n ensures n <= d\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_5231","instance":5231,"id":175230,"goal":"lemma AddMono_5231(k: nat, x: nat, i: nat)\n requires k <= x\n ensures k + i <= x + i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_5232","instance":5232,"id":175231,"goal":"lemma Abs_Nonneg_5232(c: real)\n ensures (if c >= 0 then c else -c) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_5233","instance":5233,"id":175232,"goal":"lemma DivMod_5233(z: int, m: int)\n requires m > 0\n ensures z == m * (z / m) + (z % m)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_5234","instance":5234,"id":175233,"goal":"lemma ModBounds_5234(x: nat, z: nat)\n requires z > 0\n ensures 0 <= x % z < z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_5235","instance":5235,"id":175234,"goal":"lemma Square_Nonneg_5235(x: real)\n ensures x * x >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_5236","instance":5236,"id":175235,"goal":"lemma AddComm_5236(c: int, a: int)\n ensures c + a == a + c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_5237","instance":5237,"id":175236,"goal":"lemma AddAssoc_5237(d: nat, z: nat, x: nat)\n ensures (d + z) + x == d + (z + x)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_5238","instance":5238,"id":175237,"goal":"lemma MulComm_5238(b: real, d: real)\n ensures b * d == d * b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_5239","instance":5239,"id":175238,"goal":"lemma MulAssoc_5239(n: int, b: int, k: int)\n ensures (n * b) * k == n * (b * k)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_5240","instance":5240,"id":175239,"goal":"lemma Distrib_5240(y: nat, a: nat, i: nat)\n ensures y * (a + i) == y * a + y * i\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_5241","instance":5241,"id":175240,"goal":"lemma AddZero_5241(a: real)\n ensures a + 0 == a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_5242","instance":5242,"id":175241,"goal":"lemma MulOne_5242(k: int)\n ensures k * 1 == k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_5243","instance":5243,"id":175242,"goal":"lemma MulZero_5243(d: nat)\n ensures d * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_5244","instance":5244,"id":175243,"goal":"lemma LeRefl_5244(d: real)\n ensures d <= d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_5245","instance":5245,"id":175244,"goal":"lemma LeTrans_5245(y: int, j: int, c: int)\n requires y <= j && j <= c\n ensures y <= c\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_5246","instance":5246,"id":175245,"goal":"lemma AddMono_5246(x: nat, m: nat, j: nat)\n requires x <= m\n ensures x + j <= m + j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_5247","instance":5247,"id":175246,"goal":"lemma Abs_Nonneg_5247(a: real)\n ensures (if a >= 0 then a else -a) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_5248","instance":5248,"id":175247,"goal":"lemma DivMod_5248(i: int, a: int)\n requires a > 0\n ensures i == a * (i / a) + (i % a)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_5249","instance":5249,"id":175248,"goal":"lemma ModBounds_5249(d: nat, n: nat)\n requires n > 0\n ensures 0 <= d % n < n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_5250","instance":5250,"id":175249,"goal":"lemma Square_Nonneg_5250(c: real)\n ensures c * c >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_5251","instance":5251,"id":175250,"goal":"lemma AddComm_5251(x: int, j: int)\n ensures x + j == j + x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_5252","instance":5252,"id":175251,"goal":"lemma AddAssoc_5252(b: nat, k: nat, i: nat)\n ensures (b + k) + i == b + (k + i)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_5253","instance":5253,"id":175252,"goal":"lemma MulComm_5253(z: real, m: real)\n ensures z * m == m * z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_5254","instance":5254,"id":175253,"goal":"lemma MulAssoc_5254(x: int, b: int, c: int)\n ensures (x * b) * c == x * (b * c)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_5255","instance":5255,"id":175254,"goal":"lemma Distrib_5255(n: nat, c: nat, d: nat)\n ensures n * (c + d) == n * c + n * d\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_5256","instance":5256,"id":175255,"goal":"lemma AddZero_5256(x: real)\n ensures x + 0 == x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_5257","instance":5257,"id":175256,"goal":"lemma MulOne_5257(j: int)\n ensures j * 1 == j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_5258","instance":5258,"id":175257,"goal":"lemma MulZero_5258(z: nat)\n ensures z * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_5259","instance":5259,"id":175258,"goal":"lemma LeRefl_5259(a: real)\n ensures a <= a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_5260","instance":5260,"id":175259,"goal":"lemma LeTrans_5260(k: int, b: int, a: int)\n requires k <= b && b <= a\n ensures k <= a\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_5261","instance":5261,"id":175260,"goal":"lemma AddMono_5261(c: nat, d: nat, a: nat)\n requires c <= d\n ensures c + a <= d + a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_5262","instance":5262,"id":175261,"goal":"lemma Abs_Nonneg_5262(y: real)\n ensures (if y >= 0 then y else -y) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_5263","instance":5263,"id":175262,"goal":"lemma DivMod_5263(n: int, d: int)\n requires d > 0\n ensures n == d * (n / d) + (n % d)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_5264","instance":5264,"id":175263,"goal":"lemma ModBounds_5264(m: nat, z: nat)\n requires z > 0\n ensures 0 <= m % z < z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_5265","instance":5265,"id":175264,"goal":"lemma Square_Nonneg_5265(b: real)\n ensures b * b >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_5266","instance":5266,"id":175265,"goal":"lemma AddComm_5266(n: int, b: int)\n ensures n + b == b + n\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_5267","instance":5267,"id":175266,"goal":"lemma AddAssoc_5267(z: nat, y: nat, x: nat)\n ensures (z + y) + x == z + (y + x)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_5268","instance":5268,"id":175267,"goal":"lemma MulComm_5268(k: real, z: real)\n ensures k * z == z * k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_5269","instance":5269,"id":175268,"goal":"lemma MulAssoc_5269(d: int, b: int, x: int)\n ensures (d * b) * x == d * (b * x)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_5270","instance":5270,"id":175269,"goal":"lemma Distrib_5270(d: nat, x: nat, j: nat)\n ensures d * (x + j) == d * x + d * j\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_5271","instance":5271,"id":175270,"goal":"lemma AddZero_5271(y: real)\n ensures y + 0 == y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_5272","instance":5272,"id":175271,"goal":"lemma MulOne_5272(j: int)\n ensures j * 1 == j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_5273","instance":5273,"id":175272,"goal":"lemma MulZero_5273(n: nat)\n ensures n * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_5274","instance":5274,"id":175273,"goal":"lemma LeRefl_5274(y: real)\n ensures y <= y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_5275","instance":5275,"id":175274,"goal":"lemma LeTrans_5275(a: int, c: int, j: int)\n requires a <= c && c <= j\n ensures a <= j\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_5276","instance":5276,"id":175275,"goal":"lemma AddMono_5276(b: nat, i: nat, d: nat)\n requires b <= i\n ensures b + d <= i + d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_5277","instance":5277,"id":175276,"goal":"lemma Abs_Nonneg_5277(d: real)\n ensures (if d >= 0 then d else -d) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_5278","instance":5278,"id":175277,"goal":"lemma DivMod_5278(n: int, d: int)\n requires d > 0\n ensures n == d * (n / d) + (n % d)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_5279","instance":5279,"id":175278,"goal":"lemma ModBounds_5279(k: nat, y: nat)\n requires y > 0\n ensures 0 <= k % y < y\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_5280","instance":5280,"id":175279,"goal":"lemma Square_Nonneg_5280(n: real)\n ensures n * n >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_5281","instance":5281,"id":175280,"goal":"lemma AddComm_5281(k: int, z: int)\n ensures k + z == z + k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_5282","instance":5282,"id":175281,"goal":"lemma AddAssoc_5282(i: nat, j: nat, x: nat)\n ensures (i + j) + x == i + (j + x)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_5283","instance":5283,"id":175282,"goal":"lemma MulComm_5283(y: real, m: real)\n ensures y * m == m * y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_5284","instance":5284,"id":175283,"goal":"lemma MulAssoc_5284(a: int, d: int, z: int)\n ensures (a * d) * z == a * (d * z)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_5285","instance":5285,"id":175284,"goal":"lemma Distrib_5285(y: nat, a: nat, j: nat)\n ensures y * (a + j) == y * a + y * j\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_5286","instance":5286,"id":175285,"goal":"lemma AddZero_5286(k: real)\n ensures k + 0 == k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_5287","instance":5287,"id":175286,"goal":"lemma MulOne_5287(y: int)\n ensures y * 1 == y\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_5288","instance":5288,"id":175287,"goal":"lemma MulZero_5288(d: nat)\n ensures d * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_5289","instance":5289,"id":175288,"goal":"lemma LeRefl_5289(x: real)\n ensures x <= x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_5290","instance":5290,"id":175289,"goal":"lemma LeTrans_5290(a: int, k: int, j: int)\n requires a <= k && k <= j\n ensures a <= j\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_5291","instance":5291,"id":175290,"goal":"lemma AddMono_5291(i: nat, z: nat, n: nat)\n requires i <= z\n ensures i + n <= z + n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_5292","instance":5292,"id":175291,"goal":"lemma Abs_Nonneg_5292(m: real)\n ensures (if m >= 0 then m else -m) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_5293","instance":5293,"id":175292,"goal":"lemma DivMod_5293(z: int, i: int)\n requires i > 0\n ensures z == i * (z / i) + (z % i)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_5294","instance":5294,"id":175293,"goal":"lemma ModBounds_5294(z: nat, x: nat)\n requires x > 0\n ensures 0 <= z % x < x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_5295","instance":5295,"id":175294,"goal":"lemma Square_Nonneg_5295(b: real)\n ensures b * b >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_5296","instance":5296,"id":175295,"goal":"lemma AddComm_5296(n: int, z: int)\n ensures n + z == z + n\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_5297","instance":5297,"id":175296,"goal":"lemma AddAssoc_5297(k: nat, a: nat, x: nat)\n ensures (k + a) + x == k + (a + x)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_5298","instance":5298,"id":175297,"goal":"lemma MulComm_5298(d: real, j: real)\n ensures d * j == j * d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_5299","instance":5299,"id":175298,"goal":"lemma MulAssoc_5299(b: int, i: int, c: int)\n ensures (b * i) * c == b * (i * c)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_5300","instance":5300,"id":175299,"goal":"lemma Distrib_5300(a: nat, d: nat, x: nat)\n ensures a * (d + x) == a * d + a * x\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_5301","instance":5301,"id":175300,"goal":"lemma AddZero_5301(c: real)\n ensures c + 0 == c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_5302","instance":5302,"id":175301,"goal":"lemma MulOne_5302(k: int)\n ensures k * 1 == k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_5303","instance":5303,"id":175302,"goal":"lemma MulZero_5303(i: nat)\n ensures i * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_5304","instance":5304,"id":175303,"goal":"lemma LeRefl_5304(z: real)\n ensures z <= z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_5305","instance":5305,"id":175304,"goal":"lemma LeTrans_5305(d: int, j: int, m: int)\n requires d <= j && j <= m\n ensures d <= m\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_5306","instance":5306,"id":175305,"goal":"lemma AddMono_5306(i: nat, x: nat, d: nat)\n requires i <= x\n ensures i + d <= x + d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_5307","instance":5307,"id":175306,"goal":"lemma Abs_Nonneg_5307(i: real)\n ensures (if i >= 0 then i else -i) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_5308","instance":5308,"id":175307,"goal":"lemma DivMod_5308(n: int, d: int)\n requires d > 0\n ensures n == d * (n / d) + (n % d)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_5309","instance":5309,"id":175308,"goal":"lemma ModBounds_5309(a: nat, n: nat)\n requires n > 0\n ensures 0 <= a % n < n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_5310","instance":5310,"id":175309,"goal":"lemma Square_Nonneg_5310(k: real)\n ensures k * k >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_5311","instance":5311,"id":175310,"goal":"lemma AddComm_5311(y: int, j: int)\n ensures y + j == j + y\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_5312","instance":5312,"id":175311,"goal":"lemma AddAssoc_5312(x: nat, c: nat, a: nat)\n ensures (x + c) + a == x + (c + a)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_5313","instance":5313,"id":175312,"goal":"lemma MulComm_5313(i: real, d: real)\n ensures i * d == d * i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_5314","instance":5314,"id":175313,"goal":"lemma MulAssoc_5314(j: int, y: int, b: int)\n ensures (j * y) * b == j * (y * b)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_5315","instance":5315,"id":175314,"goal":"lemma Distrib_5315(x: nat, y: nat, m: nat)\n ensures x * (y + m) == x * y + x * m\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_5316","instance":5316,"id":175315,"goal":"lemma AddZero_5316(a: real)\n ensures a + 0 == a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_5317","instance":5317,"id":175316,"goal":"lemma MulOne_5317(d: int)\n ensures d * 1 == d\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_5318","instance":5318,"id":175317,"goal":"lemma MulZero_5318(x: nat)\n ensures x * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_5319","instance":5319,"id":175318,"goal":"lemma LeRefl_5319(y: real)\n ensures y <= y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_5320","instance":5320,"id":175319,"goal":"lemma LeTrans_5320(j: int, y: int, k: int)\n requires j <= y && y <= k\n ensures j <= k\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_5321","instance":5321,"id":175320,"goal":"lemma AddMono_5321(k: nat, z: nat, c: nat)\n requires k <= z\n ensures k + c <= z + c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_5322","instance":5322,"id":175321,"goal":"lemma Abs_Nonneg_5322(k: real)\n ensures (if k >= 0 then k else -k) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_5323","instance":5323,"id":175322,"goal":"lemma DivMod_5323(i: int, x: int)\n requires x > 0\n ensures i == x * (i / x) + (i % x)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_5324","instance":5324,"id":175323,"goal":"lemma ModBounds_5324(z: nat, a: nat)\n requires a > 0\n ensures 0 <= z % a < a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_5325","instance":5325,"id":175324,"goal":"lemma Square_Nonneg_5325(a: real)\n ensures a * a >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_5326","instance":5326,"id":175325,"goal":"lemma AddComm_5326(a: int, m: int)\n ensures a + m == m + a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_5327","instance":5327,"id":175326,"goal":"lemma AddAssoc_5327(d: nat, j: nat, i: nat)\n ensures (d + j) + i == d + (j + i)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_5328","instance":5328,"id":175327,"goal":"lemma MulComm_5328(k: real, b: real)\n ensures k * b == b * k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_5329","instance":5329,"id":175328,"goal":"lemma MulAssoc_5329(y: int, b: int, k: int)\n ensures (y * b) * k == y * (b * k)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_5330","instance":5330,"id":175329,"goal":"lemma Distrib_5330(m: nat, k: nat, a: nat)\n ensures m * (k + a) == m * k + m * a\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_5331","instance":5331,"id":175330,"goal":"lemma AddZero_5331(n: real)\n ensures n + 0 == n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_5332","instance":5332,"id":175331,"goal":"lemma MulOne_5332(x: int)\n ensures x * 1 == x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_5333","instance":5333,"id":175332,"goal":"lemma MulZero_5333(i: nat)\n ensures i * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_5334","instance":5334,"id":175333,"goal":"lemma LeRefl_5334(b: real)\n ensures b <= b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_5335","instance":5335,"id":175334,"goal":"lemma LeTrans_5335(d: int, x: int, n: int)\n requires d <= x && x <= n\n ensures d <= n\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_5336","instance":5336,"id":175335,"goal":"lemma AddMono_5336(a: nat, m: nat, z: nat)\n requires a <= m\n ensures a + z <= m + z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_5337","instance":5337,"id":175336,"goal":"lemma Abs_Nonneg_5337(b: real)\n ensures (if b >= 0 then b else -b) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_5338","instance":5338,"id":175337,"goal":"lemma DivMod_5338(d: int, c: int)\n requires c > 0\n ensures d == c * (d / c) + (d % c)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_5339","instance":5339,"id":175338,"goal":"lemma ModBounds_5339(y: nat, x: nat)\n requires x > 0\n ensures 0 <= y % x < x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_5340","instance":5340,"id":175339,"goal":"lemma Square_Nonneg_5340(m: real)\n ensures m * m >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_5341","instance":5341,"id":175340,"goal":"lemma AddComm_5341(k: int, n: int)\n ensures k + n == n + k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_5342","instance":5342,"id":175341,"goal":"lemma AddAssoc_5342(a: nat, c: nat, k: nat)\n ensures (a + c) + k == a + (c + k)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_5343","instance":5343,"id":175342,"goal":"lemma MulComm_5343(i: real, a: real)\n ensures i * a == a * i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_5344","instance":5344,"id":175343,"goal":"lemma MulAssoc_5344(c: int, z: int, y: int)\n ensures (c * z) * y == c * (z * y)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_5345","instance":5345,"id":175344,"goal":"lemma Distrib_5345(d: nat, i: nat, c: nat)\n ensures d * (i + c) == d * i + d * c\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_5346","instance":5346,"id":175345,"goal":"lemma AddZero_5346(b: real)\n ensures b + 0 == b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_5347","instance":5347,"id":175346,"goal":"lemma MulOne_5347(y: int)\n ensures y * 1 == y\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_5348","instance":5348,"id":175347,"goal":"lemma MulZero_5348(y: nat)\n ensures y * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_5349","instance":5349,"id":175348,"goal":"lemma LeRefl_5349(a: real)\n ensures a <= a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_5350","instance":5350,"id":175349,"goal":"lemma LeTrans_5350(a: int, x: int, c: int)\n requires a <= x && x <= c\n ensures a <= c\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_5351","instance":5351,"id":175350,"goal":"lemma AddMono_5351(c: nat, y: nat, a: nat)\n requires c <= y\n ensures c + a <= y + a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_5352","instance":5352,"id":175351,"goal":"lemma Abs_Nonneg_5352(m: real)\n ensures (if m >= 0 then m else -m) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_5353","instance":5353,"id":175352,"goal":"lemma DivMod_5353(j: int, y: int)\n requires y > 0\n ensures j == y * (j / y) + (j % y)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_5354","instance":5354,"id":175353,"goal":"lemma ModBounds_5354(y: nat, c: nat)\n requires c > 0\n ensures 0 <= y % c < c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_5355","instance":5355,"id":175354,"goal":"lemma Square_Nonneg_5355(d: real)\n ensures d * d >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_5356","instance":5356,"id":175355,"goal":"lemma AddComm_5356(x: int, k: int)\n ensures x + k == k + x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_5357","instance":5357,"id":175356,"goal":"lemma AddAssoc_5357(c: nat, i: nat, z: nat)\n ensures (c + i) + z == c + (i + z)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_5358","instance":5358,"id":175357,"goal":"lemma MulComm_5358(d: real, a: real)\n ensures d * a == a * d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_5359","instance":5359,"id":175358,"goal":"lemma MulAssoc_5359(a: int, b: int, m: int)\n ensures (a * b) * m == a * (b * m)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_5360","instance":5360,"id":175359,"goal":"lemma Distrib_5360(i: nat, d: nat, x: nat)\n ensures i * (d + x) == i * d + i * x\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_5361","instance":5361,"id":175360,"goal":"lemma AddZero_5361(b: real)\n ensures b + 0 == b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_5362","instance":5362,"id":175361,"goal":"lemma MulOne_5362(y: int)\n ensures y * 1 == y\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_5363","instance":5363,"id":175362,"goal":"lemma MulZero_5363(k: nat)\n ensures k * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_5364","instance":5364,"id":175363,"goal":"lemma LeRefl_5364(x: real)\n ensures x <= x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_5365","instance":5365,"id":175364,"goal":"lemma LeTrans_5365(c: int, b: int, n: int)\n requires c <= b && b <= n\n ensures c <= n\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_5366","instance":5366,"id":175365,"goal":"lemma AddMono_5366(i: nat, d: nat, c: nat)\n requires i <= d\n ensures i + c <= d + c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_5367","instance":5367,"id":175366,"goal":"lemma Abs_Nonneg_5367(j: real)\n ensures (if j >= 0 then j else -j) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_5368","instance":5368,"id":175367,"goal":"lemma DivMod_5368(k: int, x: int)\n requires x > 0\n ensures k == x * (k / x) + (k % x)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_5369","instance":5369,"id":175368,"goal":"lemma ModBounds_5369(x: nat, i: nat)\n requires i > 0\n ensures 0 <= x % i < i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_5370","instance":5370,"id":175369,"goal":"lemma Square_Nonneg_5370(x: real)\n ensures x * x >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_5371","instance":5371,"id":175370,"goal":"lemma AddComm_5371(d: int, i: int)\n ensures d + i == i + d\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_5372","instance":5372,"id":175371,"goal":"lemma AddAssoc_5372(k: nat, c: nat, x: nat)\n ensures (k + c) + x == k + (c + x)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_5373","instance":5373,"id":175372,"goal":"lemma MulComm_5373(a: real, z: real)\n ensures a * z == z * a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_5374","instance":5374,"id":175373,"goal":"lemma MulAssoc_5374(z: int, j: int, b: int)\n ensures (z * j) * b == z * (j * b)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_5375","instance":5375,"id":175374,"goal":"lemma Distrib_5375(z: nat, a: nat, m: nat)\n ensures z * (a + m) == z * a + z * m\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_5376","instance":5376,"id":175375,"goal":"lemma AddZero_5376(j: real)\n ensures j + 0 == j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_5377","instance":5377,"id":175376,"goal":"lemma MulOne_5377(i: int)\n ensures i * 1 == i\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_5378","instance":5378,"id":175377,"goal":"lemma MulZero_5378(i: nat)\n ensures i * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_5379","instance":5379,"id":175378,"goal":"lemma LeRefl_5379(y: real)\n ensures y <= y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_5380","instance":5380,"id":175379,"goal":"lemma LeTrans_5380(c: int, a: int, z: int)\n requires c <= a && a <= z\n ensures c <= z\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_5381","instance":5381,"id":175380,"goal":"lemma AddMono_5381(i: nat, n: nat, b: nat)\n requires i <= n\n ensures i + b <= n + b\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_5382","instance":5382,"id":175381,"goal":"lemma Abs_Nonneg_5382(y: real)\n ensures (if y >= 0 then y else -y) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_5383","instance":5383,"id":175382,"goal":"lemma DivMod_5383(n: int, y: int)\n requires y > 0\n ensures n == y * (n / y) + (n % y)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_5384","instance":5384,"id":175383,"goal":"lemma ModBounds_5384(y: nat, b: nat)\n requires b > 0\n ensures 0 <= y % b < b\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_5385","instance":5385,"id":175384,"goal":"lemma Square_Nonneg_5385(y: real)\n ensures y * y >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_5386","instance":5386,"id":175385,"goal":"lemma AddComm_5386(m: int, d: int)\n ensures m + d == d + m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_5387","instance":5387,"id":175386,"goal":"lemma AddAssoc_5387(d: nat, b: nat, i: nat)\n ensures (d + b) + i == d + (b + i)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_5388","instance":5388,"id":175387,"goal":"lemma MulComm_5388(c: real, a: real)\n ensures c * a == a * c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_5389","instance":5389,"id":175388,"goal":"lemma MulAssoc_5389(c: int, n: int, y: int)\n ensures (c * n) * y == c * (n * y)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_5390","instance":5390,"id":175389,"goal":"lemma Distrib_5390(d: nat, c: nat, y: nat)\n ensures d * (c + y) == d * c + d * y\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_5391","instance":5391,"id":175390,"goal":"lemma AddZero_5391(c: real)\n ensures c + 0 == c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_5392","instance":5392,"id":175391,"goal":"lemma MulOne_5392(c: int)\n ensures c * 1 == c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_5393","instance":5393,"id":175392,"goal":"lemma MulZero_5393(y: nat)\n ensures y * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_5394","instance":5394,"id":175393,"goal":"lemma LeRefl_5394(c: real)\n ensures c <= c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_5395","instance":5395,"id":175394,"goal":"lemma LeTrans_5395(k: int, c: int, i: int)\n requires k <= c && c <= i\n ensures k <= i\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_5396","instance":5396,"id":175395,"goal":"lemma AddMono_5396(d: nat, m: nat, c: nat)\n requires d <= m\n ensures d + c <= m + c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_5397","instance":5397,"id":175396,"goal":"lemma Abs_Nonneg_5397(y: real)\n ensures (if y >= 0 then y else -y) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_5398","instance":5398,"id":175397,"goal":"lemma DivMod_5398(j: int, z: int)\n requires z > 0\n ensures j == z * (j / z) + (j % z)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_5399","instance":5399,"id":175398,"goal":"lemma ModBounds_5399(y: nat, c: nat)\n requires c > 0\n ensures 0 <= y % c < c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_5400","instance":5400,"id":175399,"goal":"lemma Square_Nonneg_5400(d: real)\n ensures d * d >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_5401","instance":5401,"id":175400,"goal":"lemma AddComm_5401(j: int, c: int)\n ensures j + c == c + j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_5402","instance":5402,"id":175401,"goal":"lemma AddAssoc_5402(n: nat, y: nat, j: nat)\n ensures (n + y) + j == n + (y + j)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_5403","instance":5403,"id":175402,"goal":"lemma MulComm_5403(b: real, j: real)\n ensures b * j == j * b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_5404","instance":5404,"id":175403,"goal":"lemma MulAssoc_5404(a: int, m: int, c: int)\n ensures (a * m) * c == a * (m * c)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_5405","instance":5405,"id":175404,"goal":"lemma Distrib_5405(z: nat, n: nat, d: nat)\n ensures z * (n + d) == z * n + z * d\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_5406","instance":5406,"id":175405,"goal":"lemma AddZero_5406(k: real)\n ensures k + 0 == k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_5407","instance":5407,"id":175406,"goal":"lemma MulOne_5407(m: int)\n ensures m * 1 == m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_5408","instance":5408,"id":175407,"goal":"lemma MulZero_5408(b: nat)\n ensures b * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_5409","instance":5409,"id":175408,"goal":"lemma LeRefl_5409(i: real)\n ensures i <= i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_5410","instance":5410,"id":175409,"goal":"lemma LeTrans_5410(k: int, d: int, j: int)\n requires k <= d && d <= j\n ensures k <= j\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_5411","instance":5411,"id":175410,"goal":"lemma AddMono_5411(b: nat, m: nat, n: nat)\n requires b <= m\n ensures b + n <= m + n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_5412","instance":5412,"id":175411,"goal":"lemma Abs_Nonneg_5412(n: real)\n ensures (if n >= 0 then n else -n) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_5413","instance":5413,"id":175412,"goal":"lemma DivMod_5413(y: int, i: int)\n requires i > 0\n ensures y == i * (y / i) + (y % i)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_5414","instance":5414,"id":175413,"goal":"lemma ModBounds_5414(m: nat, z: nat)\n requires z > 0\n ensures 0 <= m % z < z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_5415","instance":5415,"id":175414,"goal":"lemma Square_Nonneg_5415(b: real)\n ensures b * b >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_5416","instance":5416,"id":175415,"goal":"lemma AddComm_5416(c: int, x: int)\n ensures c + x == x + c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_5417","instance":5417,"id":175416,"goal":"lemma AddAssoc_5417(j: nat, b: nat, z: nat)\n ensures (j + b) + z == j + (b + z)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_5418","instance":5418,"id":175417,"goal":"lemma MulComm_5418(z: real, n: real)\n ensures z * n == n * z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_5419","instance":5419,"id":175418,"goal":"lemma MulAssoc_5419(m: int, y: int, i: int)\n ensures (m * y) * i == m * (y * i)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_5420","instance":5420,"id":175419,"goal":"lemma Distrib_5420(n: nat, j: nat, y: nat)\n ensures n * (j + y) == n * j + n * y\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_5421","instance":5421,"id":175420,"goal":"lemma AddZero_5421(m: real)\n ensures m + 0 == m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_5422","instance":5422,"id":175421,"goal":"lemma MulOne_5422(n: int)\n ensures n * 1 == n\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_5423","instance":5423,"id":175422,"goal":"lemma MulZero_5423(m: nat)\n ensures m * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_5424","instance":5424,"id":175423,"goal":"lemma LeRefl_5424(z: real)\n ensures z <= z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_5425","instance":5425,"id":175424,"goal":"lemma LeTrans_5425(x: int, a: int, z: int)\n requires x <= a && a <= z\n ensures x <= z\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_5426","instance":5426,"id":175425,"goal":"lemma AddMono_5426(i: nat, c: nat, z: nat)\n requires i <= c\n ensures i + z <= c + z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_5427","instance":5427,"id":175426,"goal":"lemma Abs_Nonneg_5427(c: real)\n ensures (if c >= 0 then c else -c) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_5428","instance":5428,"id":175427,"goal":"lemma DivMod_5428(x: int, m: int)\n requires m > 0\n ensures x == m * (x / m) + (x % m)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_5429","instance":5429,"id":175428,"goal":"lemma ModBounds_5429(d: nat, c: nat)\n requires c > 0\n ensures 0 <= d % c < c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_5430","instance":5430,"id":175429,"goal":"lemma Square_Nonneg_5430(b: real)\n ensures b * b >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_5431","instance":5431,"id":175430,"goal":"lemma AddComm_5431(x: int, i: int)\n ensures x + i == i + x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_5432","instance":5432,"id":175431,"goal":"lemma AddAssoc_5432(k: nat, i: nat, z: nat)\n ensures (k + i) + z == k + (i + z)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_5433","instance":5433,"id":175432,"goal":"lemma MulComm_5433(z: real, j: real)\n ensures z * j == j * z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_5434","instance":5434,"id":175433,"goal":"lemma MulAssoc_5434(k: int, c: int, m: int)\n ensures (k * c) * m == k * (c * m)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_5435","instance":5435,"id":175434,"goal":"lemma Distrib_5435(x: nat, a: nat, c: nat)\n ensures x * (a + c) == x * a + x * c\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_5436","instance":5436,"id":175435,"goal":"lemma AddZero_5436(i: real)\n ensures i + 0 == i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_5437","instance":5437,"id":175436,"goal":"lemma MulOne_5437(y: int)\n ensures y * 1 == y\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_5438","instance":5438,"id":175437,"goal":"lemma MulZero_5438(a: nat)\n ensures a * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_5439","instance":5439,"id":175438,"goal":"lemma LeRefl_5439(d: real)\n ensures d <= d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_5440","instance":5440,"id":175439,"goal":"lemma LeTrans_5440(m: int, i: int, k: int)\n requires m <= i && i <= k\n ensures m <= k\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_5441","instance":5441,"id":175440,"goal":"lemma AddMono_5441(m: nat, n: nat, x: nat)\n requires m <= n\n ensures m + x <= n + x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_5442","instance":5442,"id":175441,"goal":"lemma Abs_Nonneg_5442(y: real)\n ensures (if y >= 0 then y else -y) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_5443","instance":5443,"id":175442,"goal":"lemma DivMod_5443(b: int, i: int)\n requires i > 0\n ensures b == i * (b / i) + (b % i)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_5444","instance":5444,"id":175443,"goal":"lemma ModBounds_5444(j: nat, a: nat)\n requires a > 0\n ensures 0 <= j % a < a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_5445","instance":5445,"id":175444,"goal":"lemma Square_Nonneg_5445(k: real)\n ensures k * k >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_5446","instance":5446,"id":175445,"goal":"lemma AddComm_5446(k: int, y: int)\n ensures k + y == y + k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_5447","instance":5447,"id":175446,"goal":"lemma AddAssoc_5447(n: nat, m: nat, x: nat)\n ensures (n + m) + x == n + (m + x)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_5448","instance":5448,"id":175447,"goal":"lemma MulComm_5448(c: real, i: real)\n ensures c * i == i * c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_5449","instance":5449,"id":175448,"goal":"lemma MulAssoc_5449(j: int, i: int, m: int)\n ensures (j * i) * m == j * (i * m)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_5450","instance":5450,"id":175449,"goal":"lemma Distrib_5450(b: nat, n: nat, i: nat)\n ensures b * (n + i) == b * n + b * i\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_5451","instance":5451,"id":175450,"goal":"lemma AddZero_5451(d: real)\n ensures d + 0 == d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_5452","instance":5452,"id":175451,"goal":"lemma MulOne_5452(b: int)\n ensures b * 1 == b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_5453","instance":5453,"id":175452,"goal":"lemma MulZero_5453(d: nat)\n ensures d * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_5454","instance":5454,"id":175453,"goal":"lemma LeRefl_5454(b: real)\n ensures b <= b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_5455","instance":5455,"id":175454,"goal":"lemma LeTrans_5455(b: int, z: int, c: int)\n requires b <= z && z <= c\n ensures b <= c\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_5456","instance":5456,"id":175455,"goal":"lemma AddMono_5456(k: nat, b: nat, d: nat)\n requires k <= b\n ensures k + d <= b + d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_5457","instance":5457,"id":175456,"goal":"lemma Abs_Nonneg_5457(b: real)\n ensures (if b >= 0 then b else -b) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_5458","instance":5458,"id":175457,"goal":"lemma DivMod_5458(a: int, c: int)\n requires c > 0\n ensures a == c * (a / c) + (a % c)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_5459","instance":5459,"id":175458,"goal":"lemma ModBounds_5459(z: nat, i: nat)\n requires i > 0\n ensures 0 <= z % i < i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_5460","instance":5460,"id":175459,"goal":"lemma Square_Nonneg_5460(j: real)\n ensures j * j >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_5461","instance":5461,"id":175460,"goal":"lemma AddComm_5461(c: int, x: int)\n ensures c + x == x + c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_5462","instance":5462,"id":175461,"goal":"lemma AddAssoc_5462(y: nat, n: nat, a: nat)\n ensures (y + n) + a == y + (n + a)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_5463","instance":5463,"id":175462,"goal":"lemma MulComm_5463(m: real, b: real)\n ensures m * b == b * m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_5464","instance":5464,"id":175463,"goal":"lemma MulAssoc_5464(y: int, k: int, n: int)\n ensures (y * k) * n == y * (k * n)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_5465","instance":5465,"id":175464,"goal":"lemma Distrib_5465(x: nat, n: nat, c: nat)\n ensures x * (n + c) == x * n + x * c\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_5466","instance":5466,"id":175465,"goal":"lemma AddZero_5466(z: real)\n ensures z + 0 == z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_5467","instance":5467,"id":175466,"goal":"lemma MulOne_5467(k: int)\n ensures k * 1 == k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_5468","instance":5468,"id":175467,"goal":"lemma MulZero_5468(m: nat)\n ensures m * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_5469","instance":5469,"id":175468,"goal":"lemma LeRefl_5469(a: real)\n ensures a <= a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_5470","instance":5470,"id":175469,"goal":"lemma LeTrans_5470(d: int, z: int, i: int)\n requires d <= z && z <= i\n ensures d <= i\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_5471","instance":5471,"id":175470,"goal":"lemma AddMono_5471(n: nat, a: nat, z: nat)\n requires n <= a\n ensures n + z <= a + z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_5472","instance":5472,"id":175471,"goal":"lemma Abs_Nonneg_5472(n: real)\n ensures (if n >= 0 then n else -n) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_5473","instance":5473,"id":175472,"goal":"lemma DivMod_5473(b: int, j: int)\n requires j > 0\n ensures b == j * (b / j) + (b % j)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_5474","instance":5474,"id":175473,"goal":"lemma ModBounds_5474(z: nat, a: nat)\n requires a > 0\n ensures 0 <= z % a < a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_5475","instance":5475,"id":175474,"goal":"lemma Square_Nonneg_5475(m: real)\n ensures m * m >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_5476","instance":5476,"id":175475,"goal":"lemma AddComm_5476(a: int, n: int)\n ensures a + n == n + a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_5477","instance":5477,"id":175476,"goal":"lemma AddAssoc_5477(c: nat, j: nat, x: nat)\n ensures (c + j) + x == c + (j + x)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_5478","instance":5478,"id":175477,"goal":"lemma MulComm_5478(d: real, a: real)\n ensures d * a == a * d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_5479","instance":5479,"id":175478,"goal":"lemma MulAssoc_5479(m: int, k: int, i: int)\n ensures (m * k) * i == m * (k * i)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_5480","instance":5480,"id":175479,"goal":"lemma Distrib_5480(m: nat, z: nat, d: nat)\n ensures m * (z + d) == m * z + m * d\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_5481","instance":5481,"id":175480,"goal":"lemma AddZero_5481(a: real)\n ensures a + 0 == a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_5482","instance":5482,"id":175481,"goal":"lemma MulOne_5482(i: int)\n ensures i * 1 == i\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_5483","instance":5483,"id":175482,"goal":"lemma MulZero_5483(k: nat)\n ensures k * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_5484","instance":5484,"id":175483,"goal":"lemma LeRefl_5484(n: real)\n ensures n <= n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_5485","instance":5485,"id":175484,"goal":"lemma LeTrans_5485(i: int, z: int, c: int)\n requires i <= z && z <= c\n ensures i <= c\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_5486","instance":5486,"id":175485,"goal":"lemma AddMono_5486(y: nat, b: nat, a: nat)\n requires y <= b\n ensures y + a <= b + a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_5487","instance":5487,"id":175486,"goal":"lemma Abs_Nonneg_5487(i: real)\n ensures (if i >= 0 then i else -i) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_5488","instance":5488,"id":175487,"goal":"lemma DivMod_5488(c: int, d: int)\n requires d > 0\n ensures c == d * (c / d) + (c % d)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_5489","instance":5489,"id":175488,"goal":"lemma ModBounds_5489(c: nat, k: nat)\n requires k > 0\n ensures 0 <= c % k < k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_5490","instance":5490,"id":175489,"goal":"lemma Square_Nonneg_5490(c: real)\n ensures c * c >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_5491","instance":5491,"id":175490,"goal":"lemma AddComm_5491(i: int, k: int)\n ensures i + k == k + i\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_5492","instance":5492,"id":175491,"goal":"lemma AddAssoc_5492(d: nat, b: nat, a: nat)\n ensures (d + b) + a == d + (b + a)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_5493","instance":5493,"id":175492,"goal":"lemma MulComm_5493(k: real, j: real)\n ensures k * j == j * k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_5494","instance":5494,"id":175493,"goal":"lemma MulAssoc_5494(x: int, z: int, a: int)\n ensures (x * z) * a == x * (z * a)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_5495","instance":5495,"id":175494,"goal":"lemma Distrib_5495(y: nat, z: nat, c: nat)\n ensures y * (z + c) == y * z + y * c\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_5496","instance":5496,"id":175495,"goal":"lemma AddZero_5496(b: real)\n ensures b + 0 == b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_5497","instance":5497,"id":175496,"goal":"lemma MulOne_5497(d: int)\n ensures d * 1 == d\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_5498","instance":5498,"id":175497,"goal":"lemma MulZero_5498(y: nat)\n ensures y * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_5499","instance":5499,"id":175498,"goal":"lemma LeRefl_5499(b: real)\n ensures b <= b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_5500","instance":5500,"id":175499,"goal":"lemma LeTrans_5500(k: int, x: int, y: int)\n requires k <= x && x <= y\n ensures k <= y\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_5501","instance":5501,"id":175500,"goal":"lemma AddMono_5501(b: nat, x: nat, n: nat)\n requires b <= x\n ensures b + n <= x + n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_5502","instance":5502,"id":175501,"goal":"lemma Abs_Nonneg_5502(x: real)\n ensures (if x >= 0 then x else -x) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_5503","instance":5503,"id":175502,"goal":"lemma DivMod_5503(b: int, d: int)\n requires d > 0\n ensures b == d * (b / d) + (b % d)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_5504","instance":5504,"id":175503,"goal":"lemma ModBounds_5504(i: nat, m: nat)\n requires m > 0\n ensures 0 <= i % m < m\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_5505","instance":5505,"id":175504,"goal":"lemma Square_Nonneg_5505(i: real)\n ensures i * i >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_5506","instance":5506,"id":175505,"goal":"lemma AddComm_5506(z: int, n: int)\n ensures z + n == n + z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_5507","instance":5507,"id":175506,"goal":"lemma AddAssoc_5507(c: nat, m: nat, y: nat)\n ensures (c + m) + y == c + (m + y)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_5508","instance":5508,"id":175507,"goal":"lemma MulComm_5508(n: real, d: real)\n ensures n * d == d * n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_5509","instance":5509,"id":175508,"goal":"lemma MulAssoc_5509(n: int, m: int, a: int)\n ensures (n * m) * a == n * (m * a)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_5510","instance":5510,"id":175509,"goal":"lemma Distrib_5510(m: nat, y: nat, b: nat)\n ensures m * (y + b) == m * y + m * b\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_5511","instance":5511,"id":175510,"goal":"lemma AddZero_5511(b: real)\n ensures b + 0 == b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_5512","instance":5512,"id":175511,"goal":"lemma MulOne_5512(m: int)\n ensures m * 1 == m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_5513","instance":5513,"id":175512,"goal":"lemma MulZero_5513(i: nat)\n ensures i * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_5514","instance":5514,"id":175513,"goal":"lemma LeRefl_5514(a: real)\n ensures a <= a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_5515","instance":5515,"id":175514,"goal":"lemma LeTrans_5515(n: int, c: int, j: int)\n requires n <= c && c <= j\n ensures n <= j\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_5516","instance":5516,"id":175515,"goal":"lemma AddMono_5516(d: nat, k: nat, a: nat)\n requires d <= k\n ensures d + a <= k + a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_5517","instance":5517,"id":175516,"goal":"lemma Abs_Nonneg_5517(j: real)\n ensures (if j >= 0 then j else -j) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_5518","instance":5518,"id":175517,"goal":"lemma DivMod_5518(b: int, j: int)\n requires j > 0\n ensures b == j * (b / j) + (b % j)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_5519","instance":5519,"id":175518,"goal":"lemma ModBounds_5519(z: nat, i: nat)\n requires i > 0\n ensures 0 <= z % i < i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_5520","instance":5520,"id":175519,"goal":"lemma Square_Nonneg_5520(k: real)\n ensures k * k >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_5521","instance":5521,"id":175520,"goal":"lemma AddComm_5521(m: int, c: int)\n ensures m + c == c + m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_5522","instance":5522,"id":175521,"goal":"lemma AddAssoc_5522(j: nat, c: nat, k: nat)\n ensures (j + c) + k == j + (c + k)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_5523","instance":5523,"id":175522,"goal":"lemma MulComm_5523(m: real, b: real)\n ensures m * b == b * m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_5524","instance":5524,"id":175523,"goal":"lemma MulAssoc_5524(j: int, k: int, y: int)\n ensures (j * k) * y == j * (k * y)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_5525","instance":5525,"id":175524,"goal":"lemma Distrib_5525(y: nat, d: nat, m: nat)\n ensures y * (d + m) == y * d + y * m\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_5526","instance":5526,"id":175525,"goal":"lemma AddZero_5526(d: real)\n ensures d + 0 == d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_5527","instance":5527,"id":175526,"goal":"lemma MulOne_5527(c: int)\n ensures c * 1 == c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_5528","instance":5528,"id":175527,"goal":"lemma MulZero_5528(j: nat)\n ensures j * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_5529","instance":5529,"id":175528,"goal":"lemma LeRefl_5529(x: real)\n ensures x <= x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_5530","instance":5530,"id":175529,"goal":"lemma LeTrans_5530(k: int, m: int, n: int)\n requires k <= m && m <= n\n ensures k <= n\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_5531","instance":5531,"id":175530,"goal":"lemma AddMono_5531(b: nat, z: nat, j: nat)\n requires b <= z\n ensures b + j <= z + j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_5532","instance":5532,"id":175531,"goal":"lemma Abs_Nonneg_5532(y: real)\n ensures (if y >= 0 then y else -y) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_5533","instance":5533,"id":175532,"goal":"lemma DivMod_5533(b: int, i: int)\n requires i > 0\n ensures b == i * (b / i) + (b % i)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_5534","instance":5534,"id":175533,"goal":"lemma ModBounds_5534(x: nat, d: nat)\n requires d > 0\n ensures 0 <= x % d < d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_5535","instance":5535,"id":175534,"goal":"lemma Square_Nonneg_5535(x: real)\n ensures x * x >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_5536","instance":5536,"id":175535,"goal":"lemma AddComm_5536(i: int, z: int)\n ensures i + z == z + i\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_5537","instance":5537,"id":175536,"goal":"lemma AddAssoc_5537(z: nat, j: nat, d: nat)\n ensures (z + j) + d == z + (j + d)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_5538","instance":5538,"id":175537,"goal":"lemma MulComm_5538(d: real, a: real)\n ensures d * a == a * d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_5539","instance":5539,"id":175538,"goal":"lemma MulAssoc_5539(j: int, k: int, m: int)\n ensures (j * k) * m == j * (k * m)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_5540","instance":5540,"id":175539,"goal":"lemma Distrib_5540(n: nat, y: nat, z: nat)\n ensures n * (y + z) == n * y + n * z\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_5541","instance":5541,"id":175540,"goal":"lemma AddZero_5541(j: real)\n ensures j + 0 == j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_5542","instance":5542,"id":175541,"goal":"lemma MulOne_5542(z: int)\n ensures z * 1 == z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_5543","instance":5543,"id":175542,"goal":"lemma MulZero_5543(a: nat)\n ensures a * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_5544","instance":5544,"id":175543,"goal":"lemma LeRefl_5544(j: real)\n ensures j <= j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_5545","instance":5545,"id":175544,"goal":"lemma LeTrans_5545(c: int, x: int, m: int)\n requires c <= x && x <= m\n ensures c <= m\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_5546","instance":5546,"id":175545,"goal":"lemma AddMono_5546(y: nat, a: nat, i: nat)\n requires y <= a\n ensures y + i <= a + i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_5547","instance":5547,"id":175546,"goal":"lemma Abs_Nonneg_5547(j: real)\n ensures (if j >= 0 then j else -j) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_5548","instance":5548,"id":175547,"goal":"lemma DivMod_5548(i: int, k: int)\n requires k > 0\n ensures i == k * (i / k) + (i % k)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_5549","instance":5549,"id":175548,"goal":"lemma ModBounds_5549(n: nat, k: nat)\n requires k > 0\n ensures 0 <= n % k < k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_5550","instance":5550,"id":175549,"goal":"lemma Square_Nonneg_5550(d: real)\n ensures d * d >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_5551","instance":5551,"id":175550,"goal":"lemma AddComm_5551(d: int, n: int)\n ensures d + n == n + d\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_5552","instance":5552,"id":175551,"goal":"lemma AddAssoc_5552(a: nat, c: nat, b: nat)\n ensures (a + c) + b == a + (c + b)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_5553","instance":5553,"id":175552,"goal":"lemma MulComm_5553(m: real, x: real)\n ensures m * x == x * m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_5554","instance":5554,"id":175553,"goal":"lemma MulAssoc_5554(a: int, z: int, j: int)\n ensures (a * z) * j == a * (z * j)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_5555","instance":5555,"id":175554,"goal":"lemma Distrib_5555(m: nat, n: nat, k: nat)\n ensures m * (n + k) == m * n + m * k\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_5556","instance":5556,"id":175555,"goal":"lemma AddZero_5556(z: real)\n ensures z + 0 == z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_5557","instance":5557,"id":175556,"goal":"lemma MulOne_5557(i: int)\n ensures i * 1 == i\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_5558","instance":5558,"id":175557,"goal":"lemma MulZero_5558(d: nat)\n ensures d * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_5559","instance":5559,"id":175558,"goal":"lemma LeRefl_5559(y: real)\n ensures y <= y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_5560","instance":5560,"id":175559,"goal":"lemma LeTrans_5560(i: int, x: int, y: int)\n requires i <= x && x <= y\n ensures i <= y\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_5561","instance":5561,"id":175560,"goal":"lemma AddMono_5561(b: nat, j: nat, a: nat)\n requires b <= j\n ensures b + a <= j + a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_5562","instance":5562,"id":175561,"goal":"lemma Abs_Nonneg_5562(y: real)\n ensures (if y >= 0 then y else -y) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_5563","instance":5563,"id":175562,"goal":"lemma DivMod_5563(j: int, c: int)\n requires c > 0\n ensures j == c * (j / c) + (j % c)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_5564","instance":5564,"id":175563,"goal":"lemma ModBounds_5564(n: nat, x: nat)\n requires x > 0\n ensures 0 <= n % x < x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_5565","instance":5565,"id":175564,"goal":"lemma Square_Nonneg_5565(n: real)\n ensures n * n >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_5566","instance":5566,"id":175565,"goal":"lemma AddComm_5566(j: int, z: int)\n ensures j + z == z + j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_5567","instance":5567,"id":175566,"goal":"lemma AddAssoc_5567(i: nat, c: nat, d: nat)\n ensures (i + c) + d == i + (c + d)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_5568","instance":5568,"id":175567,"goal":"lemma MulComm_5568(b: real, k: real)\n ensures b * k == k * b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_5569","instance":5569,"id":175568,"goal":"lemma MulAssoc_5569(z: int, n: int, k: int)\n ensures (z * n) * k == z * (n * k)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_5570","instance":5570,"id":175569,"goal":"lemma Distrib_5570(m: nat, z: nat, c: nat)\n ensures m * (z + c) == m * z + m * c\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_5571","instance":5571,"id":175570,"goal":"lemma AddZero_5571(z: real)\n ensures z + 0 == z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_5572","instance":5572,"id":175571,"goal":"lemma MulOne_5572(a: int)\n ensures a * 1 == a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_5573","instance":5573,"id":175572,"goal":"lemma MulZero_5573(k: nat)\n ensures k * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_5574","instance":5574,"id":175573,"goal":"lemma LeRefl_5574(z: real)\n ensures z <= z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_5575","instance":5575,"id":175574,"goal":"lemma LeTrans_5575(i: int, z: int, b: int)\n requires i <= z && z <= b\n ensures i <= b\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_5576","instance":5576,"id":175575,"goal":"lemma AddMono_5576(j: nat, b: nat, x: nat)\n requires j <= b\n ensures j + x <= b + x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_5577","instance":5577,"id":175576,"goal":"lemma Abs_Nonneg_5577(k: real)\n ensures (if k >= 0 then k else -k) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_5578","instance":5578,"id":175577,"goal":"lemma DivMod_5578(c: int, a: int)\n requires a > 0\n ensures c == a * (c / a) + (c % a)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_5579","instance":5579,"id":175578,"goal":"lemma ModBounds_5579(k: nat, i: nat)\n requires i > 0\n ensures 0 <= k % i < i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_5580","instance":5580,"id":175579,"goal":"lemma Square_Nonneg_5580(a: real)\n ensures a * a >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_5581","instance":5581,"id":175580,"goal":"lemma AddComm_5581(c: int, n: int)\n ensures c + n == n + c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_5582","instance":5582,"id":175581,"goal":"lemma AddAssoc_5582(d: nat, z: nat, n: nat)\n ensures (d + z) + n == d + (z + n)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_5583","instance":5583,"id":175582,"goal":"lemma MulComm_5583(m: real, x: real)\n ensures m * x == x * m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_5584","instance":5584,"id":175583,"goal":"lemma MulAssoc_5584(a: int, k: int, j: int)\n ensures (a * k) * j == a * (k * j)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_5585","instance":5585,"id":175584,"goal":"lemma Distrib_5585(j: nat, k: nat, i: nat)\n ensures j * (k + i) == j * k + j * i\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_5586","instance":5586,"id":175585,"goal":"lemma AddZero_5586(d: real)\n ensures d + 0 == d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_5587","instance":5587,"id":175586,"goal":"lemma MulOne_5587(m: int)\n ensures m * 1 == m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_5588","instance":5588,"id":175587,"goal":"lemma MulZero_5588(n: nat)\n ensures n * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_5589","instance":5589,"id":175588,"goal":"lemma LeRefl_5589(j: real)\n ensures j <= j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_5590","instance":5590,"id":175589,"goal":"lemma LeTrans_5590(c: int, x: int, a: int)\n requires c <= x && x <= a\n ensures c <= a\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_5591","instance":5591,"id":175590,"goal":"lemma AddMono_5591(a: nat, i: nat, z: nat)\n requires a <= i\n ensures a + z <= i + z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_5592","instance":5592,"id":175591,"goal":"lemma Abs_Nonneg_5592(b: real)\n ensures (if b >= 0 then b else -b) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_5593","instance":5593,"id":175592,"goal":"lemma DivMod_5593(i: int, m: int)\n requires m > 0\n ensures i == m * (i / m) + (i % m)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_5594","instance":5594,"id":175593,"goal":"lemma ModBounds_5594(y: nat, x: nat)\n requires x > 0\n ensures 0 <= y % x < x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_5595","instance":5595,"id":175594,"goal":"lemma Square_Nonneg_5595(d: real)\n ensures d * d >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_5596","instance":5596,"id":175595,"goal":"lemma AddComm_5596(b: int, y: int)\n ensures b + y == y + b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_5597","instance":5597,"id":175596,"goal":"lemma AddAssoc_5597(d: nat, i: nat, n: nat)\n ensures (d + i) + n == d + (i + n)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_5598","instance":5598,"id":175597,"goal":"lemma MulComm_5598(i: real, d: real)\n ensures i * d == d * i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_5599","instance":5599,"id":175598,"goal":"lemma MulAssoc_5599(m: int, k: int, b: int)\n ensures (m * k) * b == m * (k * b)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_5600","instance":5600,"id":175599,"goal":"lemma Distrib_5600(n: nat, i: nat, x: nat)\n ensures n * (i + x) == n * i + n * x\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_5601","instance":5601,"id":175600,"goal":"lemma AddZero_5601(c: real)\n ensures c + 0 == c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_5602","instance":5602,"id":175601,"goal":"lemma MulOne_5602(j: int)\n ensures j * 1 == j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_5603","instance":5603,"id":175602,"goal":"lemma MulZero_5603(y: nat)\n ensures y * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_5604","instance":5604,"id":175603,"goal":"lemma LeRefl_5604(j: real)\n ensures j <= j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_5605","instance":5605,"id":175604,"goal":"lemma LeTrans_5605(b: int, y: int, x: int)\n requires b <= y && y <= x\n ensures b <= x\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_5606","instance":5606,"id":175605,"goal":"lemma AddMono_5606(d: nat, y: nat, j: nat)\n requires d <= y\n ensures d + j <= y + j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_5607","instance":5607,"id":175606,"goal":"lemma Abs_Nonneg_5607(z: real)\n ensures (if z >= 0 then z else -z) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_5608","instance":5608,"id":175607,"goal":"lemma DivMod_5608(k: int, x: int)\n requires x > 0\n ensures k == x * (k / x) + (k % x)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_5609","instance":5609,"id":175608,"goal":"lemma ModBounds_5609(b: nat, k: nat)\n requires k > 0\n ensures 0 <= b % k < k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_5610","instance":5610,"id":175609,"goal":"lemma Square_Nonneg_5610(c: real)\n ensures c * c >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_5611","instance":5611,"id":175610,"goal":"lemma AddComm_5611(x: int, k: int)\n ensures x + k == k + x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_5612","instance":5612,"id":175611,"goal":"lemma AddAssoc_5612(j: nat, x: nat, b: nat)\n ensures (j + x) + b == j + (x + b)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_5613","instance":5613,"id":175612,"goal":"lemma MulComm_5613(x: real, d: real)\n ensures x * d == d * x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_5614","instance":5614,"id":175613,"goal":"lemma MulAssoc_5614(b: int, y: int, n: int)\n ensures (b * y) * n == b * (y * n)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_5615","instance":5615,"id":175614,"goal":"lemma Distrib_5615(x: nat, a: nat, c: nat)\n ensures x * (a + c) == x * a + x * c\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_5616","instance":5616,"id":175615,"goal":"lemma AddZero_5616(n: real)\n ensures n + 0 == n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_5617","instance":5617,"id":175616,"goal":"lemma MulOne_5617(i: int)\n ensures i * 1 == i\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_5618","instance":5618,"id":175617,"goal":"lemma MulZero_5618(d: nat)\n ensures d * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_5619","instance":5619,"id":175618,"goal":"lemma LeRefl_5619(k: real)\n ensures k <= k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_5620","instance":5620,"id":175619,"goal":"lemma LeTrans_5620(k: int, j: int, d: int)\n requires k <= j && j <= d\n ensures k <= d\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_5621","instance":5621,"id":175620,"goal":"lemma AddMono_5621(k: nat, x: nat, c: nat)\n requires k <= x\n ensures k + c <= x + c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_5622","instance":5622,"id":175621,"goal":"lemma Abs_Nonneg_5622(j: real)\n ensures (if j >= 0 then j else -j) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_5623","instance":5623,"id":175622,"goal":"lemma DivMod_5623(a: int, i: int)\n requires i > 0\n ensures a == i * (a / i) + (a % i)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_5624","instance":5624,"id":175623,"goal":"lemma ModBounds_5624(x: nat, m: nat)\n requires m > 0\n ensures 0 <= x % m < m\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_5625","instance":5625,"id":175624,"goal":"lemma Square_Nonneg_5625(n: real)\n ensures n * n >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_5626","instance":5626,"id":175625,"goal":"lemma AddComm_5626(i: int, b: int)\n ensures i + b == b + i\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_5627","instance":5627,"id":175626,"goal":"lemma AddAssoc_5627(d: nat, x: nat, n: nat)\n ensures (d + x) + n == d + (x + n)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_5628","instance":5628,"id":175627,"goal":"lemma MulComm_5628(c: real, i: real)\n ensures c * i == i * c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_5629","instance":5629,"id":175628,"goal":"lemma MulAssoc_5629(y: int, k: int, m: int)\n ensures (y * k) * m == y * (k * m)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_5630","instance":5630,"id":175629,"goal":"lemma Distrib_5630(j: nat, k: nat, n: nat)\n ensures j * (k + n) == j * k + j * n\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_5631","instance":5631,"id":175630,"goal":"lemma AddZero_5631(z: real)\n ensures z + 0 == z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_5632","instance":5632,"id":175631,"goal":"lemma MulOne_5632(c: int)\n ensures c * 1 == c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_5633","instance":5633,"id":175632,"goal":"lemma MulZero_5633(n: nat)\n ensures n * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_5634","instance":5634,"id":175633,"goal":"lemma LeRefl_5634(y: real)\n ensures y <= y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_5635","instance":5635,"id":175634,"goal":"lemma LeTrans_5635(y: int, i: int, x: int)\n requires y <= i && i <= x\n ensures y <= x\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_5636","instance":5636,"id":175635,"goal":"lemma AddMono_5636(c: nat, z: nat, m: nat)\n requires c <= z\n ensures c + m <= z + m\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_5637","instance":5637,"id":175636,"goal":"lemma Abs_Nonneg_5637(j: real)\n ensures (if j >= 0 then j else -j) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_5638","instance":5638,"id":175637,"goal":"lemma DivMod_5638(i: int, a: int)\n requires a > 0\n ensures i == a * (i / a) + (i % a)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_5639","instance":5639,"id":175638,"goal":"lemma ModBounds_5639(m: nat, n: nat)\n requires n > 0\n ensures 0 <= m % n < n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_5640","instance":5640,"id":175639,"goal":"lemma Square_Nonneg_5640(n: real)\n ensures n * n >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_5641","instance":5641,"id":175640,"goal":"lemma AddComm_5641(j: int, k: int)\n ensures j + k == k + j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_5642","instance":5642,"id":175641,"goal":"lemma AddAssoc_5642(m: nat, z: nat, c: nat)\n ensures (m + z) + c == m + (z + c)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_5643","instance":5643,"id":175642,"goal":"lemma MulComm_5643(y: real, m: real)\n ensures y * m == m * y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_5644","instance":5644,"id":175643,"goal":"lemma MulAssoc_5644(a: int, n: int, c: int)\n ensures (a * n) * c == a * (n * c)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_5645","instance":5645,"id":175644,"goal":"lemma Distrib_5645(b: nat, x: nat, m: nat)\n ensures b * (x + m) == b * x + b * m\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_5646","instance":5646,"id":175645,"goal":"lemma AddZero_5646(z: real)\n ensures z + 0 == z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_5647","instance":5647,"id":175646,"goal":"lemma MulOne_5647(b: int)\n ensures b * 1 == b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_5648","instance":5648,"id":175647,"goal":"lemma MulZero_5648(a: nat)\n ensures a * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_5649","instance":5649,"id":175648,"goal":"lemma LeRefl_5649(j: real)\n ensures j <= j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_5650","instance":5650,"id":175649,"goal":"lemma LeTrans_5650(j: int, y: int, z: int)\n requires j <= y && y <= z\n ensures j <= z\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_5651","instance":5651,"id":175650,"goal":"lemma AddMono_5651(i: nat, a: nat, d: nat)\n requires i <= a\n ensures i + d <= a + d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_5652","instance":5652,"id":175651,"goal":"lemma Abs_Nonneg_5652(c: real)\n ensures (if c >= 0 then c else -c) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_5653","instance":5653,"id":175652,"goal":"lemma DivMod_5653(a: int, c: int)\n requires c > 0\n ensures a == c * (a / c) + (a % c)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_5654","instance":5654,"id":175653,"goal":"lemma ModBounds_5654(x: nat, i: nat)\n requires i > 0\n ensures 0 <= x % i < i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_5655","instance":5655,"id":175654,"goal":"lemma Square_Nonneg_5655(m: real)\n ensures m * m >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_5656","instance":5656,"id":175655,"goal":"lemma AddComm_5656(j: int, a: int)\n ensures j + a == a + j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_5657","instance":5657,"id":175656,"goal":"lemma AddAssoc_5657(n: nat, c: nat, j: nat)\n ensures (n + c) + j == n + (c + j)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_5658","instance":5658,"id":175657,"goal":"lemma MulComm_5658(m: real, y: real)\n ensures m * y == y * m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_5659","instance":5659,"id":175658,"goal":"lemma MulAssoc_5659(i: int, a: int, m: int)\n ensures (i * a) * m == i * (a * m)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_5660","instance":5660,"id":175659,"goal":"lemma Distrib_5660(n: nat, z: nat, m: nat)\n ensures n * (z + m) == n * z + n * m\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_5661","instance":5661,"id":175660,"goal":"lemma AddZero_5661(y: real)\n ensures y + 0 == y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_5662","instance":5662,"id":175661,"goal":"lemma MulOne_5662(x: int)\n ensures x * 1 == x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_5663","instance":5663,"id":175662,"goal":"lemma MulZero_5663(y: nat)\n ensures y * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_5664","instance":5664,"id":175663,"goal":"lemma LeRefl_5664(y: real)\n ensures y <= y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_5665","instance":5665,"id":175664,"goal":"lemma LeTrans_5665(k: int, b: int, a: int)\n requires k <= b && b <= a\n ensures k <= a\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_5666","instance":5666,"id":175665,"goal":"lemma AddMono_5666(z: nat, x: nat, y: nat)\n requires z <= x\n ensures z + y <= x + y\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_5667","instance":5667,"id":175666,"goal":"lemma Abs_Nonneg_5667(j: real)\n ensures (if j >= 0 then j else -j) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_5668","instance":5668,"id":175667,"goal":"lemma DivMod_5668(b: int, a: int)\n requires a > 0\n ensures b == a * (b / a) + (b % a)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_5669","instance":5669,"id":175668,"goal":"lemma ModBounds_5669(k: nat, j: nat)\n requires j > 0\n ensures 0 <= k % j < j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_5670","instance":5670,"id":175669,"goal":"lemma Square_Nonneg_5670(m: real)\n ensures m * m >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_5671","instance":5671,"id":175670,"goal":"lemma AddComm_5671(i: int, m: int)\n ensures i + m == m + i\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_5672","instance":5672,"id":175671,"goal":"lemma AddAssoc_5672(z: nat, b: nat, a: nat)\n ensures (z + b) + a == z + (b + a)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_5673","instance":5673,"id":175672,"goal":"lemma MulComm_5673(a: real, b: real)\n ensures a * b == b * a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_5674","instance":5674,"id":175673,"goal":"lemma MulAssoc_5674(j: int, b: int, m: int)\n ensures (j * b) * m == j * (b * m)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_5675","instance":5675,"id":175674,"goal":"lemma Distrib_5675(k: nat, y: nat, j: nat)\n ensures k * (y + j) == k * y + k * j\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_5676","instance":5676,"id":175675,"goal":"lemma AddZero_5676(x: real)\n ensures x + 0 == x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_5677","instance":5677,"id":175676,"goal":"lemma MulOne_5677(m: int)\n ensures m * 1 == m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_5678","instance":5678,"id":175677,"goal":"lemma MulZero_5678(c: nat)\n ensures c * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_5679","instance":5679,"id":175678,"goal":"lemma LeRefl_5679(k: real)\n ensures k <= k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_5680","instance":5680,"id":175679,"goal":"lemma LeTrans_5680(b: int, k: int, j: int)\n requires b <= k && k <= j\n ensures b <= j\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_5681","instance":5681,"id":175680,"goal":"lemma AddMono_5681(m: nat, i: nat, a: nat)\n requires m <= i\n ensures m + a <= i + a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_5682","instance":5682,"id":175681,"goal":"lemma Abs_Nonneg_5682(n: real)\n ensures (if n >= 0 then n else -n) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_5683","instance":5683,"id":175682,"goal":"lemma DivMod_5683(b: int, c: int)\n requires c > 0\n ensures b == c * (b / c) + (b % c)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_5684","instance":5684,"id":175683,"goal":"lemma ModBounds_5684(x: nat, z: nat)\n requires z > 0\n ensures 0 <= x % z < z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_5685","instance":5685,"id":175684,"goal":"lemma Square_Nonneg_5685(c: real)\n ensures c * c >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_5686","instance":5686,"id":175685,"goal":"lemma AddComm_5686(m: int, b: int)\n ensures m + b == b + m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_5687","instance":5687,"id":175686,"goal":"lemma AddAssoc_5687(x: nat, n: nat, d: nat)\n ensures (x + n) + d == x + (n + d)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_5688","instance":5688,"id":175687,"goal":"lemma MulComm_5688(d: real, k: real)\n ensures d * k == k * d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_5689","instance":5689,"id":175688,"goal":"lemma MulAssoc_5689(b: int, d: int, j: int)\n ensures (b * d) * j == b * (d * j)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_5690","instance":5690,"id":175689,"goal":"lemma Distrib_5690(j: nat, a: nat, n: nat)\n ensures j * (a + n) == j * a + j * n\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_5691","instance":5691,"id":175690,"goal":"lemma AddZero_5691(k: real)\n ensures k + 0 == k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_5692","instance":5692,"id":175691,"goal":"lemma MulOne_5692(i: int)\n ensures i * 1 == i\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_5693","instance":5693,"id":175692,"goal":"lemma MulZero_5693(d: nat)\n ensures d * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_5694","instance":5694,"id":175693,"goal":"lemma LeRefl_5694(b: real)\n ensures b <= b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_5695","instance":5695,"id":175694,"goal":"lemma LeTrans_5695(z: int, a: int, k: int)\n requires z <= a && a <= k\n ensures z <= k\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_5696","instance":5696,"id":175695,"goal":"lemma AddMono_5696(k: nat, i: nat, x: nat)\n requires k <= i\n ensures k + x <= i + x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_5697","instance":5697,"id":175696,"goal":"lemma Abs_Nonneg_5697(m: real)\n ensures (if m >= 0 then m else -m) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_5698","instance":5698,"id":175697,"goal":"lemma DivMod_5698(d: int, a: int)\n requires a > 0\n ensures d == a * (d / a) + (d % a)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_5699","instance":5699,"id":175698,"goal":"lemma ModBounds_5699(b: nat, d: nat)\n requires d > 0\n ensures 0 <= b % d < d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_5700","instance":5700,"id":175699,"goal":"lemma Square_Nonneg_5700(d: real)\n ensures d * d >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_5701","instance":5701,"id":175700,"goal":"lemma AddComm_5701(n: int, c: int)\n ensures n + c == c + n\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_5702","instance":5702,"id":175701,"goal":"lemma AddAssoc_5702(n: nat, a: nat, c: nat)\n ensures (n + a) + c == n + (a + c)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_5703","instance":5703,"id":175702,"goal":"lemma MulComm_5703(k: real, d: real)\n ensures k * d == d * k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_5704","instance":5704,"id":175703,"goal":"lemma MulAssoc_5704(a: int, k: int, d: int)\n ensures (a * k) * d == a * (k * d)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_5705","instance":5705,"id":175704,"goal":"lemma Distrib_5705(a: nat, n: nat, b: nat)\n ensures a * (n + b) == a * n + a * b\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_5706","instance":5706,"id":175705,"goal":"lemma AddZero_5706(d: real)\n ensures d + 0 == d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_5707","instance":5707,"id":175706,"goal":"lemma MulOne_5707(d: int)\n ensures d * 1 == d\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_5708","instance":5708,"id":175707,"goal":"lemma MulZero_5708(j: nat)\n ensures j * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_5709","instance":5709,"id":175708,"goal":"lemma LeRefl_5709(k: real)\n ensures k <= k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_5710","instance":5710,"id":175709,"goal":"lemma LeTrans_5710(z: int, b: int, x: int)\n requires z <= b && b <= x\n ensures z <= x\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_5711","instance":5711,"id":175710,"goal":"lemma AddMono_5711(i: nat, z: nat, d: nat)\n requires i <= z\n ensures i + d <= z + d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_5712","instance":5712,"id":175711,"goal":"lemma Abs_Nonneg_5712(k: real)\n ensures (if k >= 0 then k else -k) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_5713","instance":5713,"id":175712,"goal":"lemma DivMod_5713(c: int, m: int)\n requires m > 0\n ensures c == m * (c / m) + (c % m)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_5714","instance":5714,"id":175713,"goal":"lemma ModBounds_5714(b: nat, d: nat)\n requires d > 0\n ensures 0 <= b % d < d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_5715","instance":5715,"id":175714,"goal":"lemma Square_Nonneg_5715(x: real)\n ensures x * x >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_5716","instance":5716,"id":175715,"goal":"lemma AddComm_5716(c: int, j: int)\n ensures c + j == j + c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_5717","instance":5717,"id":175716,"goal":"lemma AddAssoc_5717(a: nat, m: nat, k: nat)\n ensures (a + m) + k == a + (m + k)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_5718","instance":5718,"id":175717,"goal":"lemma MulComm_5718(j: real, x: real)\n ensures j * x == x * j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_5719","instance":5719,"id":175718,"goal":"lemma MulAssoc_5719(d: int, i: int, y: int)\n ensures (d * i) * y == d * (i * y)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_5720","instance":5720,"id":175719,"goal":"lemma Distrib_5720(k: nat, d: nat, i: nat)\n ensures k * (d + i) == k * d + k * i\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_5721","instance":5721,"id":175720,"goal":"lemma AddZero_5721(b: real)\n ensures b + 0 == b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_5722","instance":5722,"id":175721,"goal":"lemma MulOne_5722(n: int)\n ensures n * 1 == n\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_5723","instance":5723,"id":175722,"goal":"lemma MulZero_5723(z: nat)\n ensures z * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_5724","instance":5724,"id":175723,"goal":"lemma LeRefl_5724(k: real)\n ensures k <= k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_5725","instance":5725,"id":175724,"goal":"lemma LeTrans_5725(y: int, d: int, a: int)\n requires y <= d && d <= a\n ensures y <= a\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_5726","instance":5726,"id":175725,"goal":"lemma AddMono_5726(n: nat, a: nat, i: nat)\n requires n <= a\n ensures n + i <= a + i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_5727","instance":5727,"id":175726,"goal":"lemma Abs_Nonneg_5727(c: real)\n ensures (if c >= 0 then c else -c) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_5728","instance":5728,"id":175727,"goal":"lemma DivMod_5728(a: int, m: int)\n requires m > 0\n ensures a == m * (a / m) + (a % m)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_5729","instance":5729,"id":175728,"goal":"lemma ModBounds_5729(z: nat, c: nat)\n requires c > 0\n ensures 0 <= z % c < c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_5730","instance":5730,"id":175729,"goal":"lemma Square_Nonneg_5730(x: real)\n ensures x * x >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_5731","instance":5731,"id":175730,"goal":"lemma AddComm_5731(c: int, z: int)\n ensures c + z == z + c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_5732","instance":5732,"id":175731,"goal":"lemma AddAssoc_5732(i: nat, c: nat, a: nat)\n ensures (i + c) + a == i + (c + a)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_5733","instance":5733,"id":175732,"goal":"lemma MulComm_5733(y: real, n: real)\n ensures y * n == n * y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_5734","instance":5734,"id":175733,"goal":"lemma MulAssoc_5734(a: int, i: int, d: int)\n ensures (a * i) * d == a * (i * d)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_5735","instance":5735,"id":175734,"goal":"lemma Distrib_5735(d: nat, i: nat, j: nat)\n ensures d * (i + j) == d * i + d * j\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_5736","instance":5736,"id":175735,"goal":"lemma AddZero_5736(k: real)\n ensures k + 0 == k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_5737","instance":5737,"id":175736,"goal":"lemma MulOne_5737(n: int)\n ensures n * 1 == n\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_5738","instance":5738,"id":175737,"goal":"lemma MulZero_5738(j: nat)\n ensures j * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_5739","instance":5739,"id":175738,"goal":"lemma LeRefl_5739(a: real)\n ensures a <= a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_5740","instance":5740,"id":175739,"goal":"lemma LeTrans_5740(c: int, j: int, n: int)\n requires c <= j && j <= n\n ensures c <= n\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_5741","instance":5741,"id":175740,"goal":"lemma AddMono_5741(z: nat, i: nat, c: nat)\n requires z <= i\n ensures z + c <= i + c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_5742","instance":5742,"id":175741,"goal":"lemma Abs_Nonneg_5742(j: real)\n ensures (if j >= 0 then j else -j) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_5743","instance":5743,"id":175742,"goal":"lemma DivMod_5743(a: int, y: int)\n requires y > 0\n ensures a == y * (a / y) + (a % y)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_5744","instance":5744,"id":175743,"goal":"lemma ModBounds_5744(x: nat, n: nat)\n requires n > 0\n ensures 0 <= x % n < n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_5745","instance":5745,"id":175744,"goal":"lemma Square_Nonneg_5745(z: real)\n ensures z * z >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_5746","instance":5746,"id":175745,"goal":"lemma AddComm_5746(k: int, c: int)\n ensures k + c == c + k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_5747","instance":5747,"id":175746,"goal":"lemma AddAssoc_5747(z: nat, n: nat, y: nat)\n ensures (z + n) + y == z + (n + y)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_5748","instance":5748,"id":175747,"goal":"lemma MulComm_5748(a: real, z: real)\n ensures a * z == z * a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_5749","instance":5749,"id":175748,"goal":"lemma MulAssoc_5749(b: int, c: int, z: int)\n ensures (b * c) * z == b * (c * z)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_5750","instance":5750,"id":175749,"goal":"lemma Distrib_5750(m: nat, b: nat, a: nat)\n ensures m * (b + a) == m * b + m * a\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_5751","instance":5751,"id":175750,"goal":"lemma AddZero_5751(b: real)\n ensures b + 0 == b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_5752","instance":5752,"id":175751,"goal":"lemma MulOne_5752(m: int)\n ensures m * 1 == m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_5753","instance":5753,"id":175752,"goal":"lemma MulZero_5753(a: nat)\n ensures a * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_5754","instance":5754,"id":175753,"goal":"lemma LeRefl_5754(j: real)\n ensures j <= j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_5755","instance":5755,"id":175754,"goal":"lemma LeTrans_5755(i: int, m: int, k: int)\n requires i <= m && m <= k\n ensures i <= k\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_5756","instance":5756,"id":175755,"goal":"lemma AddMono_5756(n: nat, c: nat, m: nat)\n requires n <= c\n ensures n + m <= c + m\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_5757","instance":5757,"id":175756,"goal":"lemma Abs_Nonneg_5757(j: real)\n ensures (if j >= 0 then j else -j) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_5758","instance":5758,"id":175757,"goal":"lemma DivMod_5758(n: int, j: int)\n requires j > 0\n ensures n == j * (n / j) + (n % j)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_5759","instance":5759,"id":175758,"goal":"lemma ModBounds_5759(z: nat, n: nat)\n requires n > 0\n ensures 0 <= z % n < n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_5760","instance":5760,"id":175759,"goal":"lemma Square_Nonneg_5760(n: real)\n ensures n * n >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_5761","instance":5761,"id":175760,"goal":"lemma AddComm_5761(c: int, y: int)\n ensures c + y == y + c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_5762","instance":5762,"id":175761,"goal":"lemma AddAssoc_5762(k: nat, j: nat, b: nat)\n ensures (k + j) + b == k + (j + b)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_5763","instance":5763,"id":175762,"goal":"lemma MulComm_5763(x: real, a: real)\n ensures x * a == a * x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_5764","instance":5764,"id":175763,"goal":"lemma MulAssoc_5764(m: int, y: int, x: int)\n ensures (m * y) * x == m * (y * x)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_5765","instance":5765,"id":175764,"goal":"lemma Distrib_5765(y: nat, m: nat, i: nat)\n ensures y * (m + i) == y * m + y * i\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_5766","instance":5766,"id":175765,"goal":"lemma AddZero_5766(i: real)\n ensures i + 0 == i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_5767","instance":5767,"id":175766,"goal":"lemma MulOne_5767(k: int)\n ensures k * 1 == k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_5768","instance":5768,"id":175767,"goal":"lemma MulZero_5768(z: nat)\n ensures z * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_5769","instance":5769,"id":175768,"goal":"lemma LeRefl_5769(n: real)\n ensures n <= n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_5770","instance":5770,"id":175769,"goal":"lemma LeTrans_5770(i: int, a: int, y: int)\n requires i <= a && a <= y\n ensures i <= y\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_5771","instance":5771,"id":175770,"goal":"lemma AddMono_5771(y: nat, b: nat, j: nat)\n requires y <= b\n ensures y + j <= b + j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_5772","instance":5772,"id":175771,"goal":"lemma Abs_Nonneg_5772(a: real)\n ensures (if a >= 0 then a else -a) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_5773","instance":5773,"id":175772,"goal":"lemma DivMod_5773(c: int, d: int)\n requires d > 0\n ensures c == d * (c / d) + (c % d)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_5774","instance":5774,"id":175773,"goal":"lemma ModBounds_5774(b: nat, y: nat)\n requires y > 0\n ensures 0 <= b % y < y\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_5775","instance":5775,"id":175774,"goal":"lemma Square_Nonneg_5775(i: real)\n ensures i * i >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_5776","instance":5776,"id":175775,"goal":"lemma AddComm_5776(j: int, y: int)\n ensures j + y == y + j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_5777","instance":5777,"id":175776,"goal":"lemma AddAssoc_5777(b: nat, x: nat, m: nat)\n ensures (b + x) + m == b + (x + m)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_5778","instance":5778,"id":175777,"goal":"lemma MulComm_5778(n: real, j: real)\n ensures n * j == j * n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_5779","instance":5779,"id":175778,"goal":"lemma MulAssoc_5779(k: int, x: int, i: int)\n ensures (k * x) * i == k * (x * i)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_5780","instance":5780,"id":175779,"goal":"lemma Distrib_5780(b: nat, d: nat, z: nat)\n ensures b * (d + z) == b * d + b * z\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_5781","instance":5781,"id":175780,"goal":"lemma AddZero_5781(n: real)\n ensures n + 0 == n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_5782","instance":5782,"id":175781,"goal":"lemma MulOne_5782(y: int)\n ensures y * 1 == y\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_5783","instance":5783,"id":175782,"goal":"lemma MulZero_5783(x: nat)\n ensures x * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_5784","instance":5784,"id":175783,"goal":"lemma LeRefl_5784(a: real)\n ensures a <= a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_5785","instance":5785,"id":175784,"goal":"lemma LeTrans_5785(c: int, d: int, n: int)\n requires c <= d && d <= n\n ensures c <= n\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_5786","instance":5786,"id":175785,"goal":"lemma AddMono_5786(a: nat, y: nat, j: nat)\n requires a <= y\n ensures a + j <= y + j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_5787","instance":5787,"id":175786,"goal":"lemma Abs_Nonneg_5787(m: real)\n ensures (if m >= 0 then m else -m) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_5788","instance":5788,"id":175787,"goal":"lemma DivMod_5788(x: int, a: int)\n requires a > 0\n ensures x == a * (x / a) + (x % a)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_5789","instance":5789,"id":175788,"goal":"lemma ModBounds_5789(c: nat, x: nat)\n requires x > 0\n ensures 0 <= c % x < x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_5790","instance":5790,"id":175789,"goal":"lemma Square_Nonneg_5790(c: real)\n ensures c * c >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_5791","instance":5791,"id":175790,"goal":"lemma AddComm_5791(a: int, d: int)\n ensures a + d == d + a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_5792","instance":5792,"id":175791,"goal":"lemma AddAssoc_5792(c: nat, y: nat, j: nat)\n ensures (c + y) + j == c + (y + j)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_5793","instance":5793,"id":175792,"goal":"lemma MulComm_5793(a: real, z: real)\n ensures a * z == z * a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_5794","instance":5794,"id":175793,"goal":"lemma MulAssoc_5794(d: int, n: int, x: int)\n ensures (d * n) * x == d * (n * x)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_5795","instance":5795,"id":175794,"goal":"lemma Distrib_5795(j: nat, i: nat, n: nat)\n ensures j * (i + n) == j * i + j * n\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_5796","instance":5796,"id":175795,"goal":"lemma AddZero_5796(b: real)\n ensures b + 0 == b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_5797","instance":5797,"id":175796,"goal":"lemma MulOne_5797(y: int)\n ensures y * 1 == y\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_5798","instance":5798,"id":175797,"goal":"lemma MulZero_5798(y: nat)\n ensures y * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_5799","instance":5799,"id":175798,"goal":"lemma LeRefl_5799(n: real)\n ensures n <= n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_5800","instance":5800,"id":175799,"goal":"lemma LeTrans_5800(y: int, k: int, m: int)\n requires y <= k && k <= m\n ensures y <= m\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_5801","instance":5801,"id":175800,"goal":"lemma AddMono_5801(x: nat, i: nat, j: nat)\n requires x <= i\n ensures x + j <= i + j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_5802","instance":5802,"id":175801,"goal":"lemma Abs_Nonneg_5802(k: real)\n ensures (if k >= 0 then k else -k) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_5803","instance":5803,"id":175802,"goal":"lemma DivMod_5803(x: int, m: int)\n requires m > 0\n ensures x == m * (x / m) + (x % m)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_5804","instance":5804,"id":175803,"goal":"lemma ModBounds_5804(j: nat, y: nat)\n requires y > 0\n ensures 0 <= j % y < y\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_5805","instance":5805,"id":175804,"goal":"lemma Square_Nonneg_5805(z: real)\n ensures z * z >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_5806","instance":5806,"id":175805,"goal":"lemma AddComm_5806(b: int, k: int)\n ensures b + k == k + b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_5807","instance":5807,"id":175806,"goal":"lemma AddAssoc_5807(y: nat, d: nat, a: nat)\n ensures (y + d) + a == y + (d + a)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_5808","instance":5808,"id":175807,"goal":"lemma MulComm_5808(a: real, i: real)\n ensures a * i == i * a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_5809","instance":5809,"id":175808,"goal":"lemma MulAssoc_5809(a: int, m: int, n: int)\n ensures (a * m) * n == a * (m * n)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_5810","instance":5810,"id":175809,"goal":"lemma Distrib_5810(d: nat, j: nat, c: nat)\n ensures d * (j + c) == d * j + d * c\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_5811","instance":5811,"id":175810,"goal":"lemma AddZero_5811(a: real)\n ensures a + 0 == a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_5812","instance":5812,"id":175811,"goal":"lemma MulOne_5812(c: int)\n ensures c * 1 == c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_5813","instance":5813,"id":175812,"goal":"lemma MulZero_5813(c: nat)\n ensures c * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_5814","instance":5814,"id":175813,"goal":"lemma LeRefl_5814(y: real)\n ensures y <= y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_5815","instance":5815,"id":175814,"goal":"lemma LeTrans_5815(c: int, x: int, n: int)\n requires c <= x && x <= n\n ensures c <= n\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_5816","instance":5816,"id":175815,"goal":"lemma AddMono_5816(d: nat, z: nat, n: nat)\n requires d <= z\n ensures d + n <= z + n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_5817","instance":5817,"id":175816,"goal":"lemma Abs_Nonneg_5817(y: real)\n ensures (if y >= 0 then y else -y) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_5818","instance":5818,"id":175817,"goal":"lemma DivMod_5818(m: int, z: int)\n requires z > 0\n ensures m == z * (m / z) + (m % z)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_5819","instance":5819,"id":175818,"goal":"lemma ModBounds_5819(m: nat, d: nat)\n requires d > 0\n ensures 0 <= m % d < d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_5820","instance":5820,"id":175819,"goal":"lemma Square_Nonneg_5820(z: real)\n ensures z * z >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_5821","instance":5821,"id":175820,"goal":"lemma AddComm_5821(c: int, b: int)\n ensures c + b == b + c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_5822","instance":5822,"id":175821,"goal":"lemma AddAssoc_5822(k: nat, x: nat, b: nat)\n ensures (k + x) + b == k + (x + b)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_5823","instance":5823,"id":175822,"goal":"lemma MulComm_5823(a: real, i: real)\n ensures a * i == i * a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_5824","instance":5824,"id":175823,"goal":"lemma MulAssoc_5824(z: int, c: int, k: int)\n ensures (z * c) * k == z * (c * k)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_5825","instance":5825,"id":175824,"goal":"lemma Distrib_5825(k: nat, i: nat, a: nat)\n ensures k * (i + a) == k * i + k * a\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_5826","instance":5826,"id":175825,"goal":"lemma AddZero_5826(j: real)\n ensures j + 0 == j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_5827","instance":5827,"id":175826,"goal":"lemma MulOne_5827(k: int)\n ensures k * 1 == k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_5828","instance":5828,"id":175827,"goal":"lemma MulZero_5828(i: nat)\n ensures i * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_5829","instance":5829,"id":175828,"goal":"lemma LeRefl_5829(j: real)\n ensures j <= j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_5830","instance":5830,"id":175829,"goal":"lemma LeTrans_5830(m: int, d: int, k: int)\n requires m <= d && d <= k\n ensures m <= k\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_5831","instance":5831,"id":175830,"goal":"lemma AddMono_5831(z: nat, y: nat, a: nat)\n requires z <= y\n ensures z + a <= y + a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_5832","instance":5832,"id":175831,"goal":"lemma Abs_Nonneg_5832(i: real)\n ensures (if i >= 0 then i else -i) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_5833","instance":5833,"id":175832,"goal":"lemma DivMod_5833(a: int, z: int)\n requires z > 0\n ensures a == z * (a / z) + (a % z)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_5834","instance":5834,"id":175833,"goal":"lemma ModBounds_5834(j: nat, x: nat)\n requires x > 0\n ensures 0 <= j % x < x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_5835","instance":5835,"id":175834,"goal":"lemma Square_Nonneg_5835(i: real)\n ensures i * i >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_5836","instance":5836,"id":175835,"goal":"lemma AddComm_5836(c: int, k: int)\n ensures c + k == k + c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_5837","instance":5837,"id":175836,"goal":"lemma AddAssoc_5837(c: nat, a: nat, n: nat)\n ensures (c + a) + n == c + (a + n)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_5838","instance":5838,"id":175837,"goal":"lemma MulComm_5838(i: real, k: real)\n ensures i * k == k * i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_5839","instance":5839,"id":175838,"goal":"lemma MulAssoc_5839(m: int, y: int, i: int)\n ensures (m * y) * i == m * (y * i)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_5840","instance":5840,"id":175839,"goal":"lemma Distrib_5840(y: nat, c: nat, i: nat)\n ensures y * (c + i) == y * c + y * i\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_5841","instance":5841,"id":175840,"goal":"lemma AddZero_5841(k: real)\n ensures k + 0 == k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_5842","instance":5842,"id":175841,"goal":"lemma MulOne_5842(z: int)\n ensures z * 1 == z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_5843","instance":5843,"id":175842,"goal":"lemma MulZero_5843(y: nat)\n ensures y * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_5844","instance":5844,"id":175843,"goal":"lemma LeRefl_5844(a: real)\n ensures a <= a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_5845","instance":5845,"id":175844,"goal":"lemma LeTrans_5845(a: int, i: int, y: int)\n requires a <= i && i <= y\n ensures a <= y\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_5846","instance":5846,"id":175845,"goal":"lemma AddMono_5846(z: nat, y: nat, n: nat)\n requires z <= y\n ensures z + n <= y + n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_5847","instance":5847,"id":175846,"goal":"lemma Abs_Nonneg_5847(n: real)\n ensures (if n >= 0 then n else -n) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_5848","instance":5848,"id":175847,"goal":"lemma DivMod_5848(j: int, a: int)\n requires a > 0\n ensures j == a * (j / a) + (j % a)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_5849","instance":5849,"id":175848,"goal":"lemma ModBounds_5849(y: nat, k: nat)\n requires k > 0\n ensures 0 <= y % k < k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_5850","instance":5850,"id":175849,"goal":"lemma Square_Nonneg_5850(c: real)\n ensures c * c >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_5851","instance":5851,"id":175850,"goal":"lemma AddComm_5851(a: int, n: int)\n ensures a + n == n + a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_5852","instance":5852,"id":175851,"goal":"lemma AddAssoc_5852(z: nat, y: nat, a: nat)\n ensures (z + y) + a == z + (y + a)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_5853","instance":5853,"id":175852,"goal":"lemma MulComm_5853(m: real, n: real)\n ensures m * n == n * m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_5854","instance":5854,"id":175853,"goal":"lemma MulAssoc_5854(k: int, b: int, y: int)\n ensures (k * b) * y == k * (b * y)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_5855","instance":5855,"id":175854,"goal":"lemma Distrib_5855(a: nat, y: nat, n: nat)\n ensures a * (y + n) == a * y + a * n\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_5856","instance":5856,"id":175855,"goal":"lemma AddZero_5856(c: real)\n ensures c + 0 == c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_5857","instance":5857,"id":175856,"goal":"lemma MulOne_5857(x: int)\n ensures x * 1 == x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_5858","instance":5858,"id":175857,"goal":"lemma MulZero_5858(b: nat)\n ensures b * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_5859","instance":5859,"id":175858,"goal":"lemma LeRefl_5859(a: real)\n ensures a <= a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_5860","instance":5860,"id":175859,"goal":"lemma LeTrans_5860(b: int, x: int, i: int)\n requires b <= x && x <= i\n ensures b <= i\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_5861","instance":5861,"id":175860,"goal":"lemma AddMono_5861(a: nat, c: nat, x: nat)\n requires a <= c\n ensures a + x <= c + x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_5862","instance":5862,"id":175861,"goal":"lemma Abs_Nonneg_5862(c: real)\n ensures (if c >= 0 then c else -c) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_5863","instance":5863,"id":175862,"goal":"lemma DivMod_5863(b: int, x: int)\n requires x > 0\n ensures b == x * (b / x) + (b % x)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_5864","instance":5864,"id":175863,"goal":"lemma ModBounds_5864(z: nat, x: nat)\n requires x > 0\n ensures 0 <= z % x < x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_5865","instance":5865,"id":175864,"goal":"lemma Square_Nonneg_5865(m: real)\n ensures m * m >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_5866","instance":5866,"id":175865,"goal":"lemma AddComm_5866(j: int, k: int)\n ensures j + k == k + j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_5867","instance":5867,"id":175866,"goal":"lemma AddAssoc_5867(n: nat, z: nat, a: nat)\n ensures (n + z) + a == n + (z + a)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_5868","instance":5868,"id":175867,"goal":"lemma MulComm_5868(b: real, m: real)\n ensures b * m == m * b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_5869","instance":5869,"id":175868,"goal":"lemma MulAssoc_5869(z: int, k: int, j: int)\n ensures (z * k) * j == z * (k * j)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_5870","instance":5870,"id":175869,"goal":"lemma Distrib_5870(b: nat, d: nat, c: nat)\n ensures b * (d + c) == b * d + b * c\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_5871","instance":5871,"id":175870,"goal":"lemma AddZero_5871(j: real)\n ensures j + 0 == j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_5872","instance":5872,"id":175871,"goal":"lemma MulOne_5872(n: int)\n ensures n * 1 == n\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_5873","instance":5873,"id":175872,"goal":"lemma MulZero_5873(n: nat)\n ensures n * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_5874","instance":5874,"id":175873,"goal":"lemma LeRefl_5874(y: real)\n ensures y <= y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_5875","instance":5875,"id":175874,"goal":"lemma LeTrans_5875(c: int, k: int, n: int)\n requires c <= k && k <= n\n ensures c <= n\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_5876","instance":5876,"id":175875,"goal":"lemma AddMono_5876(i: nat, j: nat, k: nat)\n requires i <= j\n ensures i + k <= j + k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_5877","instance":5877,"id":175876,"goal":"lemma Abs_Nonneg_5877(j: real)\n ensures (if j >= 0 then j else -j) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_5878","instance":5878,"id":175877,"goal":"lemma DivMod_5878(i: int, m: int)\n requires m > 0\n ensures i == m * (i / m) + (i % m)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_5879","instance":5879,"id":175878,"goal":"lemma ModBounds_5879(j: nat, n: nat)\n requires n > 0\n ensures 0 <= j % n < n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_5880","instance":5880,"id":175879,"goal":"lemma Square_Nonneg_5880(m: real)\n ensures m * m >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_5881","instance":5881,"id":175880,"goal":"lemma AddComm_5881(j: int, m: int)\n ensures j + m == m + j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_5882","instance":5882,"id":175881,"goal":"lemma AddAssoc_5882(z: nat, c: nat, x: nat)\n ensures (z + c) + x == z + (c + x)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_5883","instance":5883,"id":175882,"goal":"lemma MulComm_5883(x: real, b: real)\n ensures x * b == b * x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_5884","instance":5884,"id":175883,"goal":"lemma MulAssoc_5884(z: int, d: int, i: int)\n ensures (z * d) * i == z * (d * i)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_5885","instance":5885,"id":175884,"goal":"lemma Distrib_5885(d: nat, z: nat, c: nat)\n ensures d * (z + c) == d * z + d * c\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_5886","instance":5886,"id":175885,"goal":"lemma AddZero_5886(j: real)\n ensures j + 0 == j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_5887","instance":5887,"id":175886,"goal":"lemma MulOne_5887(c: int)\n ensures c * 1 == c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_5888","instance":5888,"id":175887,"goal":"lemma MulZero_5888(m: nat)\n ensures m * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_5889","instance":5889,"id":175888,"goal":"lemma LeRefl_5889(y: real)\n ensures y <= y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_5890","instance":5890,"id":175889,"goal":"lemma LeTrans_5890(k: int, c: int, b: int)\n requires k <= c && c <= b\n ensures k <= b\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_5891","instance":5891,"id":175890,"goal":"lemma AddMono_5891(z: nat, n: nat, m: nat)\n requires z <= n\n ensures z + m <= n + m\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_5892","instance":5892,"id":175891,"goal":"lemma Abs_Nonneg_5892(j: real)\n ensures (if j >= 0 then j else -j) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_5893","instance":5893,"id":175892,"goal":"lemma DivMod_5893(m: int, n: int)\n requires n > 0\n ensures m == n * (m / n) + (m % n)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_5894","instance":5894,"id":175893,"goal":"lemma ModBounds_5894(c: nat, a: nat)\n requires a > 0\n ensures 0 <= c % a < a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_5895","instance":5895,"id":175894,"goal":"lemma Square_Nonneg_5895(z: real)\n ensures z * z >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_5896","instance":5896,"id":175895,"goal":"lemma AddComm_5896(a: int, k: int)\n ensures a + k == k + a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_5897","instance":5897,"id":175896,"goal":"lemma AddAssoc_5897(y: nat, k: nat, c: nat)\n ensures (y + k) + c == y + (k + c)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_5898","instance":5898,"id":175897,"goal":"lemma MulComm_5898(m: real, a: real)\n ensures m * a == a * m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_5899","instance":5899,"id":175898,"goal":"lemma MulAssoc_5899(n: int, y: int, j: int)\n ensures (n * y) * j == n * (y * j)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_5900","instance":5900,"id":175899,"goal":"lemma Distrib_5900(a: nat, j: nat, d: nat)\n ensures a * (j + d) == a * j + a * d\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_5901","instance":5901,"id":175900,"goal":"lemma AddZero_5901(j: real)\n ensures j + 0 == j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_5902","instance":5902,"id":175901,"goal":"lemma MulOne_5902(m: int)\n ensures m * 1 == m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_5903","instance":5903,"id":175902,"goal":"lemma MulZero_5903(b: nat)\n ensures b * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_5904","instance":5904,"id":175903,"goal":"lemma LeRefl_5904(y: real)\n ensures y <= y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_5905","instance":5905,"id":175904,"goal":"lemma LeTrans_5905(c: int, a: int, i: int)\n requires c <= a && a <= i\n ensures c <= i\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_5906","instance":5906,"id":175905,"goal":"lemma AddMono_5906(i: nat, z: nat, m: nat)\n requires i <= z\n ensures i + m <= z + m\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_5907","instance":5907,"id":175906,"goal":"lemma Abs_Nonneg_5907(b: real)\n ensures (if b >= 0 then b else -b) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_5908","instance":5908,"id":175907,"goal":"lemma DivMod_5908(k: int, a: int)\n requires a > 0\n ensures k == a * (k / a) + (k % a)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_5909","instance":5909,"id":175908,"goal":"lemma ModBounds_5909(b: nat, k: nat)\n requires k > 0\n ensures 0 <= b % k < k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_5910","instance":5910,"id":175909,"goal":"lemma Square_Nonneg_5910(m: real)\n ensures m * m >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_5911","instance":5911,"id":175910,"goal":"lemma AddComm_5911(y: int, m: int)\n ensures y + m == m + y\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_5912","instance":5912,"id":175911,"goal":"lemma AddAssoc_5912(x: nat, m: nat, d: nat)\n ensures (x + m) + d == x + (m + d)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_5913","instance":5913,"id":175912,"goal":"lemma MulComm_5913(z: real, x: real)\n ensures z * x == x * z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_5914","instance":5914,"id":175913,"goal":"lemma MulAssoc_5914(y: int, c: int, a: int)\n ensures (y * c) * a == y * (c * a)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_5915","instance":5915,"id":175914,"goal":"lemma Distrib_5915(m: nat, k: nat, c: nat)\n ensures m * (k + c) == m * k + m * c\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_5916","instance":5916,"id":175915,"goal":"lemma AddZero_5916(m: real)\n ensures m + 0 == m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_5917","instance":5917,"id":175916,"goal":"lemma MulOne_5917(y: int)\n ensures y * 1 == y\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_5918","instance":5918,"id":175917,"goal":"lemma MulZero_5918(j: nat)\n ensures j * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_5919","instance":5919,"id":175918,"goal":"lemma LeRefl_5919(y: real)\n ensures y <= y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_5920","instance":5920,"id":175919,"goal":"lemma LeTrans_5920(j: int, i: int, k: int)\n requires j <= i && i <= k\n ensures j <= k\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_5921","instance":5921,"id":175920,"goal":"lemma AddMono_5921(x: nat, b: nat, k: nat)\n requires x <= b\n ensures x + k <= b + k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_5922","instance":5922,"id":175921,"goal":"lemma Abs_Nonneg_5922(m: real)\n ensures (if m >= 0 then m else -m) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_5923","instance":5923,"id":175922,"goal":"lemma DivMod_5923(m: int, n: int)\n requires n > 0\n ensures m == n * (m / n) + (m % n)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_5924","instance":5924,"id":175923,"goal":"lemma ModBounds_5924(c: nat, i: nat)\n requires i > 0\n ensures 0 <= c % i < i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_5925","instance":5925,"id":175924,"goal":"lemma Square_Nonneg_5925(n: real)\n ensures n * n >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_5926","instance":5926,"id":175925,"goal":"lemma AddComm_5926(b: int, z: int)\n ensures b + z == z + b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_5927","instance":5927,"id":175926,"goal":"lemma AddAssoc_5927(k: nat, c: nat, n: nat)\n ensures (k + c) + n == k + (c + n)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_5928","instance":5928,"id":175927,"goal":"lemma MulComm_5928(m: real, y: real)\n ensures m * y == y * m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_5929","instance":5929,"id":175928,"goal":"lemma MulAssoc_5929(a: int, c: int, y: int)\n ensures (a * c) * y == a * (c * y)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_5930","instance":5930,"id":175929,"goal":"lemma Distrib_5930(m: nat, n: nat, k: nat)\n ensures m * (n + k) == m * n + m * k\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_5931","instance":5931,"id":175930,"goal":"lemma AddZero_5931(b: real)\n ensures b + 0 == b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_5932","instance":5932,"id":175931,"goal":"lemma MulOne_5932(n: int)\n ensures n * 1 == n\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_5933","instance":5933,"id":175932,"goal":"lemma MulZero_5933(k: nat)\n ensures k * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_5934","instance":5934,"id":175933,"goal":"lemma LeRefl_5934(z: real)\n ensures z <= z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_5935","instance":5935,"id":175934,"goal":"lemma LeTrans_5935(c: int, a: int, k: int)\n requires c <= a && a <= k\n ensures c <= k\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_5936","instance":5936,"id":175935,"goal":"lemma AddMono_5936(j: nat, x: nat, n: nat)\n requires j <= x\n ensures j + n <= x + n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_5937","instance":5937,"id":175936,"goal":"lemma Abs_Nonneg_5937(d: real)\n ensures (if d >= 0 then d else -d) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_5938","instance":5938,"id":175937,"goal":"lemma DivMod_5938(a: int, m: int)\n requires m > 0\n ensures a == m * (a / m) + (a % m)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_5939","instance":5939,"id":175938,"goal":"lemma ModBounds_5939(j: nat, m: nat)\n requires m > 0\n ensures 0 <= j % m < m\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_5940","instance":5940,"id":175939,"goal":"lemma Square_Nonneg_5940(z: real)\n ensures z * z >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_5941","instance":5941,"id":175940,"goal":"lemma AddComm_5941(d: int, n: int)\n ensures d + n == n + d\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_5942","instance":5942,"id":175941,"goal":"lemma AddAssoc_5942(a: nat, c: nat, d: nat)\n ensures (a + c) + d == a + (c + d)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_5943","instance":5943,"id":175942,"goal":"lemma MulComm_5943(y: real, i: real)\n ensures y * i == i * y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_5944","instance":5944,"id":175943,"goal":"lemma MulAssoc_5944(a: int, m: int, y: int)\n ensures (a * m) * y == a * (m * y)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_5945","instance":5945,"id":175944,"goal":"lemma Distrib_5945(b: nat, i: nat, x: nat)\n ensures b * (i + x) == b * i + b * x\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_5946","instance":5946,"id":175945,"goal":"lemma AddZero_5946(m: real)\n ensures m + 0 == m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_5947","instance":5947,"id":175946,"goal":"lemma MulOne_5947(b: int)\n ensures b * 1 == b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_5948","instance":5948,"id":175947,"goal":"lemma MulZero_5948(i: nat)\n ensures i * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_5949","instance":5949,"id":175948,"goal":"lemma LeRefl_5949(a: real)\n ensures a <= a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_5950","instance":5950,"id":175949,"goal":"lemma LeTrans_5950(a: int, z: int, x: int)\n requires a <= z && z <= x\n ensures a <= x\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_5951","instance":5951,"id":175950,"goal":"lemma AddMono_5951(k: nat, z: nat, b: nat)\n requires k <= z\n ensures k + b <= z + b\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_5952","instance":5952,"id":175951,"goal":"lemma Abs_Nonneg_5952(y: real)\n ensures (if y >= 0 then y else -y) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_5953","instance":5953,"id":175952,"goal":"lemma DivMod_5953(k: int, y: int)\n requires y > 0\n ensures k == y * (k / y) + (k % y)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_5954","instance":5954,"id":175953,"goal":"lemma ModBounds_5954(i: nat, c: nat)\n requires c > 0\n ensures 0 <= i % c < c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_5955","instance":5955,"id":175954,"goal":"lemma Square_Nonneg_5955(b: real)\n ensures b * b >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_5956","instance":5956,"id":175955,"goal":"lemma AddComm_5956(c: int, k: int)\n ensures c + k == k + c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_5957","instance":5957,"id":175956,"goal":"lemma AddAssoc_5957(y: nat, n: nat, a: nat)\n ensures (y + n) + a == y + (n + a)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_5958","instance":5958,"id":175957,"goal":"lemma MulComm_5958(d: real, b: real)\n ensures d * b == b * d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_5959","instance":5959,"id":175958,"goal":"lemma MulAssoc_5959(j: int, k: int, b: int)\n ensures (j * k) * b == j * (k * b)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_5960","instance":5960,"id":175959,"goal":"lemma Distrib_5960(z: nat, j: nat, d: nat)\n ensures z * (j + d) == z * j + z * d\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_5961","instance":5961,"id":175960,"goal":"lemma AddZero_5961(j: real)\n ensures j + 0 == j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_5962","instance":5962,"id":175961,"goal":"lemma MulOne_5962(m: int)\n ensures m * 1 == m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_5963","instance":5963,"id":175962,"goal":"lemma MulZero_5963(i: nat)\n ensures i * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_5964","instance":5964,"id":175963,"goal":"lemma LeRefl_5964(n: real)\n ensures n <= n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_5965","instance":5965,"id":175964,"goal":"lemma LeTrans_5965(i: int, z: int, k: int)\n requires i <= z && z <= k\n ensures i <= k\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_5966","instance":5966,"id":175965,"goal":"lemma AddMono_5966(b: nat, x: nat, m: nat)\n requires b <= x\n ensures b + m <= x + m\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_5967","instance":5967,"id":175966,"goal":"lemma Abs_Nonneg_5967(n: real)\n ensures (if n >= 0 then n else -n) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_5968","instance":5968,"id":175967,"goal":"lemma DivMod_5968(n: int, z: int)\n requires z > 0\n ensures n == z * (n / z) + (n % z)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_5969","instance":5969,"id":175968,"goal":"lemma ModBounds_5969(d: nat, i: nat)\n requires i > 0\n ensures 0 <= d % i < i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_5970","instance":5970,"id":175969,"goal":"lemma Square_Nonneg_5970(j: real)\n ensures j * j >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_5971","instance":5971,"id":175970,"goal":"lemma AddComm_5971(y: int, i: int)\n ensures y + i == i + y\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_5972","instance":5972,"id":175971,"goal":"lemma AddAssoc_5972(c: nat, i: nat, k: nat)\n ensures (c + i) + k == c + (i + k)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_5973","instance":5973,"id":175972,"goal":"lemma MulComm_5973(d: real, x: real)\n ensures d * x == x * d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_5974","instance":5974,"id":175973,"goal":"lemma MulAssoc_5974(n: int, y: int, i: int)\n ensures (n * y) * i == n * (y * i)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_5975","instance":5975,"id":175974,"goal":"lemma Distrib_5975(z: nat, c: nat, b: nat)\n ensures z * (c + b) == z * c + z * b\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_5976","instance":5976,"id":175975,"goal":"lemma AddZero_5976(b: real)\n ensures b + 0 == b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_5977","instance":5977,"id":175976,"goal":"lemma MulOne_5977(k: int)\n ensures k * 1 == k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_5978","instance":5978,"id":175977,"goal":"lemma MulZero_5978(c: nat)\n ensures c * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_5979","instance":5979,"id":175978,"goal":"lemma LeRefl_5979(b: real)\n ensures b <= b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_5980","instance":5980,"id":175979,"goal":"lemma LeTrans_5980(k: int, a: int, i: int)\n requires k <= a && a <= i\n ensures k <= i\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_5981","instance":5981,"id":175980,"goal":"lemma AddMono_5981(n: nat, d: nat, k: nat)\n requires n <= d\n ensures n + k <= d + k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_5982","instance":5982,"id":175981,"goal":"lemma Abs_Nonneg_5982(k: real)\n ensures (if k >= 0 then k else -k) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_5983","instance":5983,"id":175982,"goal":"lemma DivMod_5983(c: int, n: int)\n requires n > 0\n ensures c == n * (c / n) + (c % n)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_5984","instance":5984,"id":175983,"goal":"lemma ModBounds_5984(z: nat, x: nat)\n requires x > 0\n ensures 0 <= z % x < x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_5985","instance":5985,"id":175984,"goal":"lemma Square_Nonneg_5985(b: real)\n ensures b * b >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_5986","instance":5986,"id":175985,"goal":"lemma AddComm_5986(y: int, z: int)\n ensures y + z == z + y\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_5987","instance":5987,"id":175986,"goal":"lemma AddAssoc_5987(c: nat, j: nat, a: nat)\n ensures (c + j) + a == c + (j + a)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_5988","instance":5988,"id":175987,"goal":"lemma MulComm_5988(c: real, b: real)\n ensures c * b == b * c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_5989","instance":5989,"id":175988,"goal":"lemma MulAssoc_5989(n: int, m: int, i: int)\n ensures (n * m) * i == n * (m * i)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_5990","instance":5990,"id":175989,"goal":"lemma Distrib_5990(a: nat, j: nat, i: nat)\n ensures a * (j + i) == a * j + a * i\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_5991","instance":5991,"id":175990,"goal":"lemma AddZero_5991(j: real)\n ensures j + 0 == j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_5992","instance":5992,"id":175991,"goal":"lemma MulOne_5992(b: int)\n ensures b * 1 == b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_5993","instance":5993,"id":175992,"goal":"lemma MulZero_5993(d: nat)\n ensures d * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_5994","instance":5994,"id":175993,"goal":"lemma LeRefl_5994(d: real)\n ensures d <= d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_5995","instance":5995,"id":175994,"goal":"lemma LeTrans_5995(z: int, c: int, x: int)\n requires z <= c && c <= x\n ensures z <= x\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_5996","instance":5996,"id":175995,"goal":"lemma AddMono_5996(b: nat, n: nat, a: nat)\n requires b <= n\n ensures b + a <= n + a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_5997","instance":5997,"id":175996,"goal":"lemma Abs_Nonneg_5997(i: real)\n ensures (if i >= 0 then i else -i) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_5998","instance":5998,"id":175997,"goal":"lemma DivMod_5998(b: int, i: int)\n requires i > 0\n ensures b == i * (b / i) + (b % i)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_5999","instance":5999,"id":175998,"goal":"lemma ModBounds_5999(j: nat, a: nat)\n requires a > 0\n ensures 0 <= j % a < a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_6000","instance":6000,"id":175999,"goal":"lemma Square_Nonneg_6000(y: real)\n ensures y * y >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_6001","instance":6001,"id":176000,"goal":"lemma AddComm_6001(i: int, c: int)\n ensures i + c == c + i\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_6002","instance":6002,"id":176001,"goal":"lemma AddAssoc_6002(j: nat, a: nat, c: nat)\n ensures (j + a) + c == j + (a + c)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_6003","instance":6003,"id":176002,"goal":"lemma MulComm_6003(x: real, i: real)\n ensures x * i == i * x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_6004","instance":6004,"id":176003,"goal":"lemma MulAssoc_6004(y: int, k: int, z: int)\n ensures (y * k) * z == y * (k * z)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_6005","instance":6005,"id":176004,"goal":"lemma Distrib_6005(i: nat, n: nat, a: nat)\n ensures i * (n + a) == i * n + i * a\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_6006","instance":6006,"id":176005,"goal":"lemma AddZero_6006(y: real)\n ensures y + 0 == y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_6007","instance":6007,"id":176006,"goal":"lemma MulOne_6007(d: int)\n ensures d * 1 == d\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_6008","instance":6008,"id":176007,"goal":"lemma MulZero_6008(z: nat)\n ensures z * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_6009","instance":6009,"id":176008,"goal":"lemma LeRefl_6009(i: real)\n ensures i <= i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_6010","instance":6010,"id":176009,"goal":"lemma LeTrans_6010(y: int, x: int, a: int)\n requires y <= x && x <= a\n ensures y <= a\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_6011","instance":6011,"id":176010,"goal":"lemma AddMono_6011(c: nat, b: nat, z: nat)\n requires c <= b\n ensures c + z <= b + z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_6012","instance":6012,"id":176011,"goal":"lemma Abs_Nonneg_6012(i: real)\n ensures (if i >= 0 then i else -i) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_6013","instance":6013,"id":176012,"goal":"lemma DivMod_6013(y: int, x: int)\n requires x > 0\n ensures y == x * (y / x) + (y % x)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_6014","instance":6014,"id":176013,"goal":"lemma ModBounds_6014(c: nat, z: nat)\n requires z > 0\n ensures 0 <= c % z < z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_6015","instance":6015,"id":176014,"goal":"lemma Square_Nonneg_6015(k: real)\n ensures k * k >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_6016","instance":6016,"id":176015,"goal":"lemma AddComm_6016(m: int, j: int)\n ensures m + j == j + m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_6017","instance":6017,"id":176016,"goal":"lemma AddAssoc_6017(c: nat, x: nat, m: nat)\n ensures (c + x) + m == c + (x + m)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_6018","instance":6018,"id":176017,"goal":"lemma MulComm_6018(x: real, b: real)\n ensures x * b == b * x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_6019","instance":6019,"id":176018,"goal":"lemma MulAssoc_6019(a: int, x: int, z: int)\n ensures (a * x) * z == a * (x * z)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_6020","instance":6020,"id":176019,"goal":"lemma Distrib_6020(x: nat, z: nat, y: nat)\n ensures x * (z + y) == x * z + x * y\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_6021","instance":6021,"id":176020,"goal":"lemma AddZero_6021(a: real)\n ensures a + 0 == a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_6022","instance":6022,"id":176021,"goal":"lemma MulOne_6022(a: int)\n ensures a * 1 == a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_6023","instance":6023,"id":176022,"goal":"lemma MulZero_6023(z: nat)\n ensures z * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_6024","instance":6024,"id":176023,"goal":"lemma LeRefl_6024(i: real)\n ensures i <= i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_6025","instance":6025,"id":176024,"goal":"lemma LeTrans_6025(j: int, a: int, c: int)\n requires j <= a && a <= c\n ensures j <= c\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_6026","instance":6026,"id":176025,"goal":"lemma AddMono_6026(j: nat, n: nat, a: nat)\n requires j <= n\n ensures j + a <= n + a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_6027","instance":6027,"id":176026,"goal":"lemma Abs_Nonneg_6027(j: real)\n ensures (if j >= 0 then j else -j) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_6028","instance":6028,"id":176027,"goal":"lemma DivMod_6028(y: int, k: int)\n requires k > 0\n ensures y == k * (y / k) + (y % k)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_6029","instance":6029,"id":176028,"goal":"lemma ModBounds_6029(j: nat, m: nat)\n requires m > 0\n ensures 0 <= j % m < m\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_6030","instance":6030,"id":176029,"goal":"lemma Square_Nonneg_6030(i: real)\n ensures i * i >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_6031","instance":6031,"id":176030,"goal":"lemma AddComm_6031(x: int, c: int)\n ensures x + c == c + x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_6032","instance":6032,"id":176031,"goal":"lemma AddAssoc_6032(m: nat, n: nat, b: nat)\n ensures (m + n) + b == m + (n + b)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_6033","instance":6033,"id":176032,"goal":"lemma MulComm_6033(i: real, d: real)\n ensures i * d == d * i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_6034","instance":6034,"id":176033,"goal":"lemma MulAssoc_6034(y: int, j: int, c: int)\n ensures (y * j) * c == y * (j * c)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_6035","instance":6035,"id":176034,"goal":"lemma Distrib_6035(d: nat, n: nat, x: nat)\n ensures d * (n + x) == d * n + d * x\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_6036","instance":6036,"id":176035,"goal":"lemma AddZero_6036(n: real)\n ensures n + 0 == n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_6037","instance":6037,"id":176036,"goal":"lemma MulOne_6037(n: int)\n ensures n * 1 == n\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_6038","instance":6038,"id":176037,"goal":"lemma MulZero_6038(y: nat)\n ensures y * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_6039","instance":6039,"id":176038,"goal":"lemma LeRefl_6039(y: real)\n ensures y <= y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_6040","instance":6040,"id":176039,"goal":"lemma LeTrans_6040(k: int, m: int, y: int)\n requires k <= m && m <= y\n ensures k <= y\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_6041","instance":6041,"id":176040,"goal":"lemma AddMono_6041(i: nat, n: nat, d: nat)\n requires i <= n\n ensures i + d <= n + d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_6042","instance":6042,"id":176041,"goal":"lemma Abs_Nonneg_6042(z: real)\n ensures (if z >= 0 then z else -z) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_6043","instance":6043,"id":176042,"goal":"lemma DivMod_6043(c: int, i: int)\n requires i > 0\n ensures c == i * (c / i) + (c % i)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_6044","instance":6044,"id":176043,"goal":"lemma ModBounds_6044(j: nat, z: nat)\n requires z > 0\n ensures 0 <= j % z < z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_6045","instance":6045,"id":176044,"goal":"lemma Square_Nonneg_6045(y: real)\n ensures y * y >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_6046","instance":6046,"id":176045,"goal":"lemma AddComm_6046(b: int, j: int)\n ensures b + j == j + b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_6047","instance":6047,"id":176046,"goal":"lemma AddAssoc_6047(a: nat, b: nat, d: nat)\n ensures (a + b) + d == a + (b + d)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_6048","instance":6048,"id":176047,"goal":"lemma MulComm_6048(j: real, a: real)\n ensures j * a == a * j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_6049","instance":6049,"id":176048,"goal":"lemma MulAssoc_6049(a: int, m: int, n: int)\n ensures (a * m) * n == a * (m * n)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_6050","instance":6050,"id":176049,"goal":"lemma Distrib_6050(m: nat, n: nat, d: nat)\n ensures m * (n + d) == m * n + m * d\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_6051","instance":6051,"id":176050,"goal":"lemma AddZero_6051(i: real)\n ensures i + 0 == i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_6052","instance":6052,"id":176051,"goal":"lemma MulOne_6052(b: int)\n ensures b * 1 == b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_6053","instance":6053,"id":176052,"goal":"lemma MulZero_6053(n: nat)\n ensures n * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_6054","instance":6054,"id":176053,"goal":"lemma LeRefl_6054(y: real)\n ensures y <= y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_6055","instance":6055,"id":176054,"goal":"lemma LeTrans_6055(k: int, m: int, c: int)\n requires k <= m && m <= c\n ensures k <= c\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_6056","instance":6056,"id":176055,"goal":"lemma AddMono_6056(n: nat, i: nat, c: nat)\n requires n <= i\n ensures n + c <= i + c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_6057","instance":6057,"id":176056,"goal":"lemma Abs_Nonneg_6057(c: real)\n ensures (if c >= 0 then c else -c) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_6058","instance":6058,"id":176057,"goal":"lemma DivMod_6058(y: int, x: int)\n requires x > 0\n ensures y == x * (y / x) + (y % x)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_6059","instance":6059,"id":176058,"goal":"lemma ModBounds_6059(b: nat, m: nat)\n requires m > 0\n ensures 0 <= b % m < m\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_6060","instance":6060,"id":176059,"goal":"lemma Square_Nonneg_6060(a: real)\n ensures a * a >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_6061","instance":6061,"id":176060,"goal":"lemma AddComm_6061(a: int, n: int)\n ensures a + n == n + a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_6062","instance":6062,"id":176061,"goal":"lemma AddAssoc_6062(c: nat, n: nat, d: nat)\n ensures (c + n) + d == c + (n + d)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_6063","instance":6063,"id":176062,"goal":"lemma MulComm_6063(m: real, j: real)\n ensures m * j == j * m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_6064","instance":6064,"id":176063,"goal":"lemma MulAssoc_6064(y: int, n: int, j: int)\n ensures (y * n) * j == y * (n * j)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_6065","instance":6065,"id":176064,"goal":"lemma Distrib_6065(x: nat, j: nat, i: nat)\n ensures x * (j + i) == x * j + x * i\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_6066","instance":6066,"id":176065,"goal":"lemma AddZero_6066(n: real)\n ensures n + 0 == n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_6067","instance":6067,"id":176066,"goal":"lemma MulOne_6067(j: int)\n ensures j * 1 == j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_6068","instance":6068,"id":176067,"goal":"lemma MulZero_6068(x: nat)\n ensures x * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_6069","instance":6069,"id":176068,"goal":"lemma LeRefl_6069(z: real)\n ensures z <= z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_6070","instance":6070,"id":176069,"goal":"lemma LeTrans_6070(z: int, c: int, j: int)\n requires z <= c && c <= j\n ensures z <= j\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_6071","instance":6071,"id":176070,"goal":"lemma AddMono_6071(m: nat, x: nat, c: nat)\n requires m <= x\n ensures m + c <= x + c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_6072","instance":6072,"id":176071,"goal":"lemma Abs_Nonneg_6072(y: real)\n ensures (if y >= 0 then y else -y) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_6073","instance":6073,"id":176072,"goal":"lemma DivMod_6073(k: int, j: int)\n requires j > 0\n ensures k == j * (k / j) + (k % j)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_6074","instance":6074,"id":176073,"goal":"lemma ModBounds_6074(x: nat, i: nat)\n requires i > 0\n ensures 0 <= x % i < i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_6075","instance":6075,"id":176074,"goal":"lemma Square_Nonneg_6075(m: real)\n ensures m * m >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_6076","instance":6076,"id":176075,"goal":"lemma AddComm_6076(z: int, j: int)\n ensures z + j == j + z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_6077","instance":6077,"id":176076,"goal":"lemma AddAssoc_6077(b: nat, i: nat, z: nat)\n ensures (b + i) + z == b + (i + z)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_6078","instance":6078,"id":176077,"goal":"lemma MulComm_6078(d: real, k: real)\n ensures d * k == k * d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_6079","instance":6079,"id":176078,"goal":"lemma MulAssoc_6079(x: int, z: int, m: int)\n ensures (x * z) * m == x * (z * m)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_6080","instance":6080,"id":176079,"goal":"lemma Distrib_6080(k: nat, n: nat, c: nat)\n ensures k * (n + c) == k * n + k * c\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_6081","instance":6081,"id":176080,"goal":"lemma AddZero_6081(i: real)\n ensures i + 0 == i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_6082","instance":6082,"id":176081,"goal":"lemma MulOne_6082(a: int)\n ensures a * 1 == a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_6083","instance":6083,"id":176082,"goal":"lemma MulZero_6083(j: nat)\n ensures j * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_6084","instance":6084,"id":176083,"goal":"lemma LeRefl_6084(x: real)\n ensures x <= x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_6085","instance":6085,"id":176084,"goal":"lemma LeTrans_6085(k: int, b: int, c: int)\n requires k <= b && b <= c\n ensures k <= c\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_6086","instance":6086,"id":176085,"goal":"lemma AddMono_6086(x: nat, j: nat, k: nat)\n requires x <= j\n ensures x + k <= j + k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_6087","instance":6087,"id":176086,"goal":"lemma Abs_Nonneg_6087(b: real)\n ensures (if b >= 0 then b else -b) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_6088","instance":6088,"id":176087,"goal":"lemma DivMod_6088(n: int, k: int)\n requires k > 0\n ensures n == k * (n / k) + (n % k)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_6089","instance":6089,"id":176088,"goal":"lemma ModBounds_6089(b: nat, x: nat)\n requires x > 0\n ensures 0 <= b % x < x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_6090","instance":6090,"id":176089,"goal":"lemma Square_Nonneg_6090(x: real)\n ensures x * x >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_6091","instance":6091,"id":176090,"goal":"lemma AddComm_6091(a: int, c: int)\n ensures a + c == c + a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_6092","instance":6092,"id":176091,"goal":"lemma AddAssoc_6092(y: nat, k: nat, m: nat)\n ensures (y + k) + m == y + (k + m)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_6093","instance":6093,"id":176092,"goal":"lemma MulComm_6093(i: real, a: real)\n ensures i * a == a * i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_6094","instance":6094,"id":176093,"goal":"lemma MulAssoc_6094(i: int, a: int, n: int)\n ensures (i * a) * n == i * (a * n)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_6095","instance":6095,"id":176094,"goal":"lemma Distrib_6095(d: nat, m: nat, z: nat)\n ensures d * (m + z) == d * m + d * z\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_6096","instance":6096,"id":176095,"goal":"lemma AddZero_6096(b: real)\n ensures b + 0 == b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_6097","instance":6097,"id":176096,"goal":"lemma MulOne_6097(x: int)\n ensures x * 1 == x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_6098","instance":6098,"id":176097,"goal":"lemma MulZero_6098(j: nat)\n ensures j * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_6099","instance":6099,"id":176098,"goal":"lemma LeRefl_6099(m: real)\n ensures m <= m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_6100","instance":6100,"id":176099,"goal":"lemma LeTrans_6100(k: int, n: int, a: int)\n requires k <= n && n <= a\n ensures k <= a\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_6101","instance":6101,"id":176100,"goal":"lemma AddMono_6101(b: nat, a: nat, n: nat)\n requires b <= a\n ensures b + n <= a + n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_6102","instance":6102,"id":176101,"goal":"lemma Abs_Nonneg_6102(j: real)\n ensures (if j >= 0 then j else -j) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_6103","instance":6103,"id":176102,"goal":"lemma DivMod_6103(d: int, k: int)\n requires k > 0\n ensures d == k * (d / k) + (d % k)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_6104","instance":6104,"id":176103,"goal":"lemma ModBounds_6104(z: nat, k: nat)\n requires k > 0\n ensures 0 <= z % k < k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_6105","instance":6105,"id":176104,"goal":"lemma Square_Nonneg_6105(m: real)\n ensures m * m >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_6106","instance":6106,"id":176105,"goal":"lemma AddComm_6106(n: int, b: int)\n ensures n + b == b + n\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_6107","instance":6107,"id":176106,"goal":"lemma AddAssoc_6107(a: nat, c: nat, x: nat)\n ensures (a + c) + x == a + (c + x)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_6108","instance":6108,"id":176107,"goal":"lemma MulComm_6108(j: real, i: real)\n ensures j * i == i * j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_6109","instance":6109,"id":176108,"goal":"lemma MulAssoc_6109(b: int, m: int, x: int)\n ensures (b * m) * x == b * (m * x)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_6110","instance":6110,"id":176109,"goal":"lemma Distrib_6110(x: nat, y: nat, d: nat)\n ensures x * (y + d) == x * y + x * d\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_6111","instance":6111,"id":176110,"goal":"lemma AddZero_6111(z: real)\n ensures z + 0 == z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_6112","instance":6112,"id":176111,"goal":"lemma MulOne_6112(n: int)\n ensures n * 1 == n\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_6113","instance":6113,"id":176112,"goal":"lemma MulZero_6113(i: nat)\n ensures i * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_6114","instance":6114,"id":176113,"goal":"lemma LeRefl_6114(i: real)\n ensures i <= i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_6115","instance":6115,"id":176114,"goal":"lemma LeTrans_6115(n: int, z: int, m: int)\n requires n <= z && z <= m\n ensures n <= m\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_6116","instance":6116,"id":176115,"goal":"lemma AddMono_6116(m: nat, c: nat, z: nat)\n requires m <= c\n ensures m + z <= c + z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_6117","instance":6117,"id":176116,"goal":"lemma Abs_Nonneg_6117(x: real)\n ensures (if x >= 0 then x else -x) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_6118","instance":6118,"id":176117,"goal":"lemma DivMod_6118(k: int, c: int)\n requires c > 0\n ensures k == c * (k / c) + (k % c)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_6119","instance":6119,"id":176118,"goal":"lemma ModBounds_6119(c: nat, m: nat)\n requires m > 0\n ensures 0 <= c % m < m\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_6120","instance":6120,"id":176119,"goal":"lemma Square_Nonneg_6120(m: real)\n ensures m * m >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_6121","instance":6121,"id":176120,"goal":"lemma AddComm_6121(d: int, n: int)\n ensures d + n == n + d\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_6122","instance":6122,"id":176121,"goal":"lemma AddAssoc_6122(a: nat, z: nat, j: nat)\n ensures (a + z) + j == a + (z + j)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_6123","instance":6123,"id":176122,"goal":"lemma MulComm_6123(x: real, m: real)\n ensures x * m == m * x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_6124","instance":6124,"id":176123,"goal":"lemma MulAssoc_6124(c: int, b: int, i: int)\n ensures (c * b) * i == c * (b * i)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_6125","instance":6125,"id":176124,"goal":"lemma Distrib_6125(x: nat, j: nat, d: nat)\n ensures x * (j + d) == x * j + x * d\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_6126","instance":6126,"id":176125,"goal":"lemma AddZero_6126(a: real)\n ensures a + 0 == a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_6127","instance":6127,"id":176126,"goal":"lemma MulOne_6127(j: int)\n ensures j * 1 == j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_6128","instance":6128,"id":176127,"goal":"lemma MulZero_6128(n: nat)\n ensures n * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_6129","instance":6129,"id":176128,"goal":"lemma LeRefl_6129(y: real)\n ensures y <= y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_6130","instance":6130,"id":176129,"goal":"lemma LeTrans_6130(d: int, y: int, c: int)\n requires d <= y && y <= c\n ensures d <= c\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_6131","instance":6131,"id":176130,"goal":"lemma AddMono_6131(i: nat, z: nat, j: nat)\n requires i <= z\n ensures i + j <= z + j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_6132","instance":6132,"id":176131,"goal":"lemma Abs_Nonneg_6132(b: real)\n ensures (if b >= 0 then b else -b) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_6133","instance":6133,"id":176132,"goal":"lemma DivMod_6133(b: int, n: int)\n requires n > 0\n ensures b == n * (b / n) + (b % n)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_6134","instance":6134,"id":176133,"goal":"lemma ModBounds_6134(y: nat, j: nat)\n requires j > 0\n ensures 0 <= y % j < j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_6135","instance":6135,"id":176134,"goal":"lemma Square_Nonneg_6135(c: real)\n ensures c * c >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_6136","instance":6136,"id":176135,"goal":"lemma AddComm_6136(y: int, b: int)\n ensures y + b == b + y\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_6137","instance":6137,"id":176136,"goal":"lemma AddAssoc_6137(m: nat, b: nat, n: nat)\n ensures (m + b) + n == m + (b + n)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_6138","instance":6138,"id":176137,"goal":"lemma MulComm_6138(b: real, y: real)\n ensures b * y == y * b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_6139","instance":6139,"id":176138,"goal":"lemma MulAssoc_6139(z: int, a: int, m: int)\n ensures (z * a) * m == z * (a * m)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_6140","instance":6140,"id":176139,"goal":"lemma Distrib_6140(k: nat, b: nat, a: nat)\n ensures k * (b + a) == k * b + k * a\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_6141","instance":6141,"id":176140,"goal":"lemma AddZero_6141(c: real)\n ensures c + 0 == c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_6142","instance":6142,"id":176141,"goal":"lemma MulOne_6142(z: int)\n ensures z * 1 == z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_6143","instance":6143,"id":176142,"goal":"lemma MulZero_6143(x: nat)\n ensures x * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_6144","instance":6144,"id":176143,"goal":"lemma LeRefl_6144(y: real)\n ensures y <= y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_6145","instance":6145,"id":176144,"goal":"lemma LeTrans_6145(m: int, b: int, c: int)\n requires m <= b && b <= c\n ensures m <= c\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_6146","instance":6146,"id":176145,"goal":"lemma AddMono_6146(k: nat, z: nat, x: nat)\n requires k <= z\n ensures k + x <= z + x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_6147","instance":6147,"id":176146,"goal":"lemma Abs_Nonneg_6147(c: real)\n ensures (if c >= 0 then c else -c) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_6148","instance":6148,"id":176147,"goal":"lemma DivMod_6148(j: int, x: int)\n requires x > 0\n ensures j == x * (j / x) + (j % x)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_6149","instance":6149,"id":176148,"goal":"lemma ModBounds_6149(a: nat, m: nat)\n requires m > 0\n ensures 0 <= a % m < m\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_6150","instance":6150,"id":176149,"goal":"lemma Square_Nonneg_6150(y: real)\n ensures y * y >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_6151","instance":6151,"id":176150,"goal":"lemma AddComm_6151(y: int, d: int)\n ensures y + d == d + y\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_6152","instance":6152,"id":176151,"goal":"lemma AddAssoc_6152(d: nat, y: nat, n: nat)\n ensures (d + y) + n == d + (y + n)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_6153","instance":6153,"id":176152,"goal":"lemma MulComm_6153(b: real, j: real)\n ensures b * j == j * b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_6154","instance":6154,"id":176153,"goal":"lemma MulAssoc_6154(n: int, c: int, a: int)\n ensures (n * c) * a == n * (c * a)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_6155","instance":6155,"id":176154,"goal":"lemma Distrib_6155(c: nat, d: nat, j: nat)\n ensures c * (d + j) == c * d + c * j\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_6156","instance":6156,"id":176155,"goal":"lemma AddZero_6156(d: real)\n ensures d + 0 == d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_6157","instance":6157,"id":176156,"goal":"lemma MulOne_6157(i: int)\n ensures i * 1 == i\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_6158","instance":6158,"id":176157,"goal":"lemma MulZero_6158(n: nat)\n ensures n * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_6159","instance":6159,"id":176158,"goal":"lemma LeRefl_6159(m: real)\n ensures m <= m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_6160","instance":6160,"id":176159,"goal":"lemma LeTrans_6160(d: int, j: int, a: int)\n requires d <= j && j <= a\n ensures d <= a\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_6161","instance":6161,"id":176160,"goal":"lemma AddMono_6161(y: nat, x: nat, c: nat)\n requires y <= x\n ensures y + c <= x + c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_6162","instance":6162,"id":176161,"goal":"lemma Abs_Nonneg_6162(y: real)\n ensures (if y >= 0 then y else -y) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_6163","instance":6163,"id":176162,"goal":"lemma DivMod_6163(a: int, b: int)\n requires b > 0\n ensures a == b * (a / b) + (a % b)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_6164","instance":6164,"id":176163,"goal":"lemma ModBounds_6164(b: nat, m: nat)\n requires m > 0\n ensures 0 <= b % m < m\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_6165","instance":6165,"id":176164,"goal":"lemma Square_Nonneg_6165(y: real)\n ensures y * y >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_6166","instance":6166,"id":176165,"goal":"lemma AddComm_6166(a: int, n: int)\n ensures a + n == n + a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_6167","instance":6167,"id":176166,"goal":"lemma AddAssoc_6167(z: nat, c: nat, j: nat)\n ensures (z + c) + j == z + (c + j)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_6168","instance":6168,"id":176167,"goal":"lemma MulComm_6168(b: real, z: real)\n ensures b * z == z * b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_6169","instance":6169,"id":176168,"goal":"lemma MulAssoc_6169(d: int, m: int, c: int)\n ensures (d * m) * c == d * (m * c)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_6170","instance":6170,"id":176169,"goal":"lemma Distrib_6170(m: nat, d: nat, a: nat)\n ensures m * (d + a) == m * d + m * a\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_6171","instance":6171,"id":176170,"goal":"lemma AddZero_6171(i: real)\n ensures i + 0 == i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_6172","instance":6172,"id":176171,"goal":"lemma MulOne_6172(a: int)\n ensures a * 1 == a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_6173","instance":6173,"id":176172,"goal":"lemma MulZero_6173(x: nat)\n ensures x * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_6174","instance":6174,"id":176173,"goal":"lemma LeRefl_6174(x: real)\n ensures x <= x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_6175","instance":6175,"id":176174,"goal":"lemma LeTrans_6175(n: int, c: int, m: int)\n requires n <= c && c <= m\n ensures n <= m\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_6176","instance":6176,"id":176175,"goal":"lemma AddMono_6176(j: nat, y: nat, a: nat)\n requires j <= y\n ensures j + a <= y + a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_6177","instance":6177,"id":176176,"goal":"lemma Abs_Nonneg_6177(i: real)\n ensures (if i >= 0 then i else -i) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_6178","instance":6178,"id":176177,"goal":"lemma DivMod_6178(j: int, x: int)\n requires x > 0\n ensures j == x * (j / x) + (j % x)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_6179","instance":6179,"id":176178,"goal":"lemma ModBounds_6179(z: nat, a: nat)\n requires a > 0\n ensures 0 <= z % a < a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_6180","instance":6180,"id":176179,"goal":"lemma Square_Nonneg_6180(d: real)\n ensures d * d >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_6181","instance":6181,"id":176180,"goal":"lemma AddComm_6181(k: int, d: int)\n ensures k + d == d + k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_6182","instance":6182,"id":176181,"goal":"lemma AddAssoc_6182(n: nat, k: nat, c: nat)\n ensures (n + k) + c == n + (k + c)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_6183","instance":6183,"id":176182,"goal":"lemma MulComm_6183(c: real, a: real)\n ensures c * a == a * c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_6184","instance":6184,"id":176183,"goal":"lemma MulAssoc_6184(z: int, y: int, k: int)\n ensures (z * y) * k == z * (y * k)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_6185","instance":6185,"id":176184,"goal":"lemma Distrib_6185(b: nat, m: nat, j: nat)\n ensures b * (m + j) == b * m + b * j\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_6186","instance":6186,"id":176185,"goal":"lemma AddZero_6186(y: real)\n ensures y + 0 == y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_6187","instance":6187,"id":176186,"goal":"lemma MulOne_6187(a: int)\n ensures a * 1 == a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_6188","instance":6188,"id":176187,"goal":"lemma MulZero_6188(b: nat)\n ensures b * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_6189","instance":6189,"id":176188,"goal":"lemma LeRefl_6189(z: real)\n ensures z <= z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_6190","instance":6190,"id":176189,"goal":"lemma LeTrans_6190(i: int, z: int, n: int)\n requires i <= z && z <= n\n ensures i <= n\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_6191","instance":6191,"id":176190,"goal":"lemma AddMono_6191(y: nat, d: nat, x: nat)\n requires y <= d\n ensures y + x <= d + x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_6192","instance":6192,"id":176191,"goal":"lemma Abs_Nonneg_6192(b: real)\n ensures (if b >= 0 then b else -b) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_6193","instance":6193,"id":176192,"goal":"lemma DivMod_6193(a: int, n: int)\n requires n > 0\n ensures a == n * (a / n) + (a % n)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_6194","instance":6194,"id":176193,"goal":"lemma ModBounds_6194(k: nat, m: nat)\n requires m > 0\n ensures 0 <= k % m < m\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_6195","instance":6195,"id":176194,"goal":"lemma Square_Nonneg_6195(z: real)\n ensures z * z >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_6196","instance":6196,"id":176195,"goal":"lemma AddComm_6196(m: int, y: int)\n ensures m + y == y + m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_6197","instance":6197,"id":176196,"goal":"lemma AddAssoc_6197(d: nat, n: nat, b: nat)\n ensures (d + n) + b == d + (n + b)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_6198","instance":6198,"id":176197,"goal":"lemma MulComm_6198(y: real, b: real)\n ensures y * b == b * y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_6199","instance":6199,"id":176198,"goal":"lemma MulAssoc_6199(k: int, d: int, m: int)\n ensures (k * d) * m == k * (d * m)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_6200","instance":6200,"id":176199,"goal":"lemma Distrib_6200(n: nat, b: nat, z: nat)\n ensures n * (b + z) == n * b + n * z\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_6201","instance":6201,"id":176200,"goal":"lemma AddZero_6201(m: real)\n ensures m + 0 == m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_6202","instance":6202,"id":176201,"goal":"lemma MulOne_6202(a: int)\n ensures a * 1 == a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_6203","instance":6203,"id":176202,"goal":"lemma MulZero_6203(c: nat)\n ensures c * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_6204","instance":6204,"id":176203,"goal":"lemma LeRefl_6204(x: real)\n ensures x <= x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_6205","instance":6205,"id":176204,"goal":"lemma LeTrans_6205(z: int, x: int, k: int)\n requires z <= x && x <= k\n ensures z <= k\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_6206","instance":6206,"id":176205,"goal":"lemma AddMono_6206(d: nat, n: nat, y: nat)\n requires d <= n\n ensures d + y <= n + y\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_6207","instance":6207,"id":176206,"goal":"lemma Abs_Nonneg_6207(c: real)\n ensures (if c >= 0 then c else -c) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_6208","instance":6208,"id":176207,"goal":"lemma DivMod_6208(m: int, k: int)\n requires k > 0\n ensures m == k * (m / k) + (m % k)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_6209","instance":6209,"id":176208,"goal":"lemma ModBounds_6209(z: nat, x: nat)\n requires x > 0\n ensures 0 <= z % x < x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_6210","instance":6210,"id":176209,"goal":"lemma Square_Nonneg_6210(z: real)\n ensures z * z >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_6211","instance":6211,"id":176210,"goal":"lemma AddComm_6211(z: int, x: int)\n ensures z + x == x + z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_6212","instance":6212,"id":176211,"goal":"lemma AddAssoc_6212(b: nat, j: nat, d: nat)\n ensures (b + j) + d == b + (j + d)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_6213","instance":6213,"id":176212,"goal":"lemma MulComm_6213(z: real, d: real)\n ensures z * d == d * z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_6214","instance":6214,"id":176213,"goal":"lemma MulAssoc_6214(z: int, m: int, x: int)\n ensures (z * m) * x == z * (m * x)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_6215","instance":6215,"id":176214,"goal":"lemma Distrib_6215(d: nat, b: nat, i: nat)\n ensures d * (b + i) == d * b + d * i\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_6216","instance":6216,"id":176215,"goal":"lemma AddZero_6216(j: real)\n ensures j + 0 == j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_6217","instance":6217,"id":176216,"goal":"lemma MulOne_6217(j: int)\n ensures j * 1 == j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_6218","instance":6218,"id":176217,"goal":"lemma MulZero_6218(x: nat)\n ensures x * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_6219","instance":6219,"id":176218,"goal":"lemma LeRefl_6219(i: real)\n ensures i <= i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_6220","instance":6220,"id":176219,"goal":"lemma LeTrans_6220(a: int, c: int, n: int)\n requires a <= c && c <= n\n ensures a <= n\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_6221","instance":6221,"id":176220,"goal":"lemma AddMono_6221(n: nat, i: nat, k: nat)\n requires n <= i\n ensures n + k <= i + k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_6222","instance":6222,"id":176221,"goal":"lemma Abs_Nonneg_6222(a: real)\n ensures (if a >= 0 then a else -a) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_6223","instance":6223,"id":176222,"goal":"lemma DivMod_6223(m: int, k: int)\n requires k > 0\n ensures m == k * (m / k) + (m % k)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_6224","instance":6224,"id":176223,"goal":"lemma ModBounds_6224(b: nat, c: nat)\n requires c > 0\n ensures 0 <= b % c < c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_6225","instance":6225,"id":176224,"goal":"lemma Square_Nonneg_6225(y: real)\n ensures y * y >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_6226","instance":6226,"id":176225,"goal":"lemma AddComm_6226(x: int, y: int)\n ensures x + y == y + x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_6227","instance":6227,"id":176226,"goal":"lemma AddAssoc_6227(a: nat, k: nat, m: nat)\n ensures (a + k) + m == a + (k + m)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_6228","instance":6228,"id":176227,"goal":"lemma MulComm_6228(j: real, x: real)\n ensures j * x == x * j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_6229","instance":6229,"id":176228,"goal":"lemma MulAssoc_6229(y: int, c: int, x: int)\n ensures (y * c) * x == y * (c * x)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_6230","instance":6230,"id":176229,"goal":"lemma Distrib_6230(b: nat, a: nat, d: nat)\n ensures b * (a + d) == b * a + b * d\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_6231","instance":6231,"id":176230,"goal":"lemma AddZero_6231(c: real)\n ensures c + 0 == c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_6232","instance":6232,"id":176231,"goal":"lemma MulOne_6232(m: int)\n ensures m * 1 == m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_6233","instance":6233,"id":176232,"goal":"lemma MulZero_6233(z: nat)\n ensures z * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_6234","instance":6234,"id":176233,"goal":"lemma LeRefl_6234(a: real)\n ensures a <= a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_6235","instance":6235,"id":176234,"goal":"lemma LeTrans_6235(a: int, i: int, m: int)\n requires a <= i && i <= m\n ensures a <= m\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_6236","instance":6236,"id":176235,"goal":"lemma AddMono_6236(d: nat, k: nat, z: nat)\n requires d <= k\n ensures d + z <= k + z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_6237","instance":6237,"id":176236,"goal":"lemma Abs_Nonneg_6237(y: real)\n ensures (if y >= 0 then y else -y) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_6238","instance":6238,"id":176237,"goal":"lemma DivMod_6238(i: int, z: int)\n requires z > 0\n ensures i == z * (i / z) + (i % z)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_6239","instance":6239,"id":176238,"goal":"lemma ModBounds_6239(a: nat, k: nat)\n requires k > 0\n ensures 0 <= a % k < k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_6240","instance":6240,"id":176239,"goal":"lemma Square_Nonneg_6240(m: real)\n ensures m * m >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_6241","instance":6241,"id":176240,"goal":"lemma AddComm_6241(j: int, y: int)\n ensures j + y == y + j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_6242","instance":6242,"id":176241,"goal":"lemma AddAssoc_6242(n: nat, a: nat, x: nat)\n ensures (n + a) + x == n + (a + x)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_6243","instance":6243,"id":176242,"goal":"lemma MulComm_6243(a: real, y: real)\n ensures a * y == y * a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_6244","instance":6244,"id":176243,"goal":"lemma MulAssoc_6244(k: int, z: int, x: int)\n ensures (k * z) * x == k * (z * x)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_6245","instance":6245,"id":176244,"goal":"lemma Distrib_6245(z: nat, i: nat, d: nat)\n ensures z * (i + d) == z * i + z * d\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_6246","instance":6246,"id":176245,"goal":"lemma AddZero_6246(a: real)\n ensures a + 0 == a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_6247","instance":6247,"id":176246,"goal":"lemma MulOne_6247(i: int)\n ensures i * 1 == i\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_6248","instance":6248,"id":176247,"goal":"lemma MulZero_6248(i: nat)\n ensures i * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_6249","instance":6249,"id":176248,"goal":"lemma LeRefl_6249(x: real)\n ensures x <= x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_6250","instance":6250,"id":176249,"goal":"lemma LeTrans_6250(m: int, d: int, a: int)\n requires m <= d && d <= a\n ensures m <= a\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_6251","instance":6251,"id":176250,"goal":"lemma AddMono_6251(d: nat, a: nat, x: nat)\n requires d <= a\n ensures d + x <= a + x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_6252","instance":6252,"id":176251,"goal":"lemma Abs_Nonneg_6252(m: real)\n ensures (if m >= 0 then m else -m) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_6253","instance":6253,"id":176252,"goal":"lemma DivMod_6253(n: int, c: int)\n requires c > 0\n ensures n == c * (n / c) + (n % c)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_6254","instance":6254,"id":176253,"goal":"lemma ModBounds_6254(i: nat, m: nat)\n requires m > 0\n ensures 0 <= i % m < m\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_6255","instance":6255,"id":176254,"goal":"lemma Square_Nonneg_6255(z: real)\n ensures z * z >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_6256","instance":6256,"id":176255,"goal":"lemma AddComm_6256(k: int, n: int)\n ensures k + n == n + k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_6257","instance":6257,"id":176256,"goal":"lemma AddAssoc_6257(n: nat, c: nat, x: nat)\n ensures (n + c) + x == n + (c + x)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_6258","instance":6258,"id":176257,"goal":"lemma MulComm_6258(x: real, j: real)\n ensures x * j == j * x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_6259","instance":6259,"id":176258,"goal":"lemma MulAssoc_6259(j: int, b: int, n: int)\n ensures (j * b) * n == j * (b * n)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_6260","instance":6260,"id":176259,"goal":"lemma Distrib_6260(m: nat, y: nat, z: nat)\n ensures m * (y + z) == m * y + m * z\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_6261","instance":6261,"id":176260,"goal":"lemma AddZero_6261(m: real)\n ensures m + 0 == m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_6262","instance":6262,"id":176261,"goal":"lemma MulOne_6262(y: int)\n ensures y * 1 == y\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_6263","instance":6263,"id":176262,"goal":"lemma MulZero_6263(k: nat)\n ensures k * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_6264","instance":6264,"id":176263,"goal":"lemma LeRefl_6264(b: real)\n ensures b <= b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_6265","instance":6265,"id":176264,"goal":"lemma LeTrans_6265(j: int, b: int, z: int)\n requires j <= b && b <= z\n ensures j <= z\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_6266","instance":6266,"id":176265,"goal":"lemma AddMono_6266(k: nat, i: nat, m: nat)\n requires k <= i\n ensures k + m <= i + m\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_6267","instance":6267,"id":176266,"goal":"lemma Abs_Nonneg_6267(c: real)\n ensures (if c >= 0 then c else -c) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_6268","instance":6268,"id":176267,"goal":"lemma DivMod_6268(z: int, c: int)\n requires c > 0\n ensures z == c * (z / c) + (z % c)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_6269","instance":6269,"id":176268,"goal":"lemma ModBounds_6269(k: nat, b: nat)\n requires b > 0\n ensures 0 <= k % b < b\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_6270","instance":6270,"id":176269,"goal":"lemma Square_Nonneg_6270(k: real)\n ensures k * k >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_6271","instance":6271,"id":176270,"goal":"lemma AddComm_6271(m: int, x: int)\n ensures m + x == x + m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_6272","instance":6272,"id":176271,"goal":"lemma AddAssoc_6272(b: nat, j: nat, n: nat)\n ensures (b + j) + n == b + (j + n)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_6273","instance":6273,"id":176272,"goal":"lemma MulComm_6273(z: real, b: real)\n ensures z * b == b * z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_6274","instance":6274,"id":176273,"goal":"lemma MulAssoc_6274(y: int, i: int, x: int)\n ensures (y * i) * x == y * (i * x)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_6275","instance":6275,"id":176274,"goal":"lemma Distrib_6275(m: nat, k: nat, a: nat)\n ensures m * (k + a) == m * k + m * a\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_6276","instance":6276,"id":176275,"goal":"lemma AddZero_6276(x: real)\n ensures x + 0 == x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_6277","instance":6277,"id":176276,"goal":"lemma MulOne_6277(x: int)\n ensures x * 1 == x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_6278","instance":6278,"id":176277,"goal":"lemma MulZero_6278(y: nat)\n ensures y * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_6279","instance":6279,"id":176278,"goal":"lemma LeRefl_6279(x: real)\n ensures x <= x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_6280","instance":6280,"id":176279,"goal":"lemma LeTrans_6280(k: int, i: int, m: int)\n requires k <= i && i <= m\n ensures k <= m\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_6281","instance":6281,"id":176280,"goal":"lemma AddMono_6281(y: nat, b: nat, j: nat)\n requires y <= b\n ensures y + j <= b + j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_6282","instance":6282,"id":176281,"goal":"lemma Abs_Nonneg_6282(a: real)\n ensures (if a >= 0 then a else -a) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_6283","instance":6283,"id":176282,"goal":"lemma DivMod_6283(b: int, y: int)\n requires y > 0\n ensures b == y * (b / y) + (b % y)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_6284","instance":6284,"id":176283,"goal":"lemma ModBounds_6284(n: nat, d: nat)\n requires d > 0\n ensures 0 <= n % d < d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_6285","instance":6285,"id":176284,"goal":"lemma Square_Nonneg_6285(z: real)\n ensures z * z >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_6286","instance":6286,"id":176285,"goal":"lemma AddComm_6286(b: int, j: int)\n ensures b + j == j + b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_6287","instance":6287,"id":176286,"goal":"lemma AddAssoc_6287(n: nat, x: nat, m: nat)\n ensures (n + x) + m == n + (x + m)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_6288","instance":6288,"id":176287,"goal":"lemma MulComm_6288(i: real, m: real)\n ensures i * m == m * i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_6289","instance":6289,"id":176288,"goal":"lemma MulAssoc_6289(y: int, z: int, k: int)\n ensures (y * z) * k == y * (z * k)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_6290","instance":6290,"id":176289,"goal":"lemma Distrib_6290(j: nat, y: nat, i: nat)\n ensures j * (y + i) == j * y + j * i\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_6291","instance":6291,"id":176290,"goal":"lemma AddZero_6291(j: real)\n ensures j + 0 == j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_6292","instance":6292,"id":176291,"goal":"lemma MulOne_6292(i: int)\n ensures i * 1 == i\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_6293","instance":6293,"id":176292,"goal":"lemma MulZero_6293(x: nat)\n ensures x * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_6294","instance":6294,"id":176293,"goal":"lemma LeRefl_6294(a: real)\n ensures a <= a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_6295","instance":6295,"id":176294,"goal":"lemma LeTrans_6295(k: int, d: int, x: int)\n requires k <= d && d <= x\n ensures k <= x\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_6296","instance":6296,"id":176295,"goal":"lemma AddMono_6296(c: nat, i: nat, j: nat)\n requires c <= i\n ensures c + j <= i + j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_6297","instance":6297,"id":176296,"goal":"lemma Abs_Nonneg_6297(b: real)\n ensures (if b >= 0 then b else -b) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_6298","instance":6298,"id":176297,"goal":"lemma DivMod_6298(d: int, k: int)\n requires k > 0\n ensures d == k * (d / k) + (d % k)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_6299","instance":6299,"id":176298,"goal":"lemma ModBounds_6299(a: nat, m: nat)\n requires m > 0\n ensures 0 <= a % m < m\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_6300","instance":6300,"id":176299,"goal":"lemma Square_Nonneg_6300(m: real)\n ensures m * m >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_6301","instance":6301,"id":176300,"goal":"lemma AddComm_6301(z: int, k: int)\n ensures z + k == k + z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_6302","instance":6302,"id":176301,"goal":"lemma AddAssoc_6302(b: nat, z: nat, c: nat)\n ensures (b + z) + c == b + (z + c)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_6303","instance":6303,"id":176302,"goal":"lemma MulComm_6303(i: real, c: real)\n ensures i * c == c * i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_6304","instance":6304,"id":176303,"goal":"lemma MulAssoc_6304(n: int, d: int, b: int)\n ensures (n * d) * b == n * (d * b)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_6305","instance":6305,"id":176304,"goal":"lemma Distrib_6305(y: nat, c: nat, n: nat)\n ensures y * (c + n) == y * c + y * n\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_6306","instance":6306,"id":176305,"goal":"lemma AddZero_6306(c: real)\n ensures c + 0 == c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_6307","instance":6307,"id":176306,"goal":"lemma MulOne_6307(x: int)\n ensures x * 1 == x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_6308","instance":6308,"id":176307,"goal":"lemma MulZero_6308(z: nat)\n ensures z * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_6309","instance":6309,"id":176308,"goal":"lemma LeRefl_6309(d: real)\n ensures d <= d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_6310","instance":6310,"id":176309,"goal":"lemma LeTrans_6310(b: int, m: int, z: int)\n requires b <= m && m <= z\n ensures b <= z\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_6311","instance":6311,"id":176310,"goal":"lemma AddMono_6311(i: nat, k: nat, c: nat)\n requires i <= k\n ensures i + c <= k + c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_6312","instance":6312,"id":176311,"goal":"lemma Abs_Nonneg_6312(y: real)\n ensures (if y >= 0 then y else -y) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_6313","instance":6313,"id":176312,"goal":"lemma DivMod_6313(m: int, z: int)\n requires z > 0\n ensures m == z * (m / z) + (m % z)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_6314","instance":6314,"id":176313,"goal":"lemma ModBounds_6314(i: nat, b: nat)\n requires b > 0\n ensures 0 <= i % b < b\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_6315","instance":6315,"id":176314,"goal":"lemma Square_Nonneg_6315(c: real)\n ensures c * c >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_6316","instance":6316,"id":176315,"goal":"lemma AddComm_6316(b: int, n: int)\n ensures b + n == n + b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_6317","instance":6317,"id":176316,"goal":"lemma AddAssoc_6317(k: nat, j: nat, b: nat)\n ensures (k + j) + b == k + (j + b)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_6318","instance":6318,"id":176317,"goal":"lemma MulComm_6318(j: real, c: real)\n ensures j * c == c * j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_6319","instance":6319,"id":176318,"goal":"lemma MulAssoc_6319(x: int, m: int, n: int)\n ensures (x * m) * n == x * (m * n)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_6320","instance":6320,"id":176319,"goal":"lemma Distrib_6320(x: nat, j: nat, c: nat)\n ensures x * (j + c) == x * j + x * c\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_6321","instance":6321,"id":176320,"goal":"lemma AddZero_6321(n: real)\n ensures n + 0 == n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_6322","instance":6322,"id":176321,"goal":"lemma MulOne_6322(a: int)\n ensures a * 1 == a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_6323","instance":6323,"id":176322,"goal":"lemma MulZero_6323(k: nat)\n ensures k * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_6324","instance":6324,"id":176323,"goal":"lemma LeRefl_6324(a: real)\n ensures a <= a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_6325","instance":6325,"id":176324,"goal":"lemma LeTrans_6325(d: int, c: int, k: int)\n requires d <= c && c <= k\n ensures d <= k\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_6326","instance":6326,"id":176325,"goal":"lemma AddMono_6326(x: nat, j: nat, d: nat)\n requires x <= j\n ensures x + d <= j + d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_6327","instance":6327,"id":176326,"goal":"lemma Abs_Nonneg_6327(n: real)\n ensures (if n >= 0 then n else -n) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_6328","instance":6328,"id":176327,"goal":"lemma DivMod_6328(a: int, k: int)\n requires k > 0\n ensures a == k * (a / k) + (a % k)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_6329","instance":6329,"id":176328,"goal":"lemma ModBounds_6329(x: nat, n: nat)\n requires n > 0\n ensures 0 <= x % n < n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_6330","instance":6330,"id":176329,"goal":"lemma Square_Nonneg_6330(y: real)\n ensures y * y >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_6331","instance":6331,"id":176330,"goal":"lemma AddComm_6331(m: int, b: int)\n ensures m + b == b + m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_6332","instance":6332,"id":176331,"goal":"lemma AddAssoc_6332(m: nat, d: nat, j: nat)\n ensures (m + d) + j == m + (d + j)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_6333","instance":6333,"id":176332,"goal":"lemma MulComm_6333(j: real, a: real)\n ensures j * a == a * j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_6334","instance":6334,"id":176333,"goal":"lemma MulAssoc_6334(a: int, x: int, j: int)\n ensures (a * x) * j == a * (x * j)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_6335","instance":6335,"id":176334,"goal":"lemma Distrib_6335(y: nat, z: nat, x: nat)\n ensures y * (z + x) == y * z + y * x\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_6336","instance":6336,"id":176335,"goal":"lemma AddZero_6336(j: real)\n ensures j + 0 == j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_6337","instance":6337,"id":176336,"goal":"lemma MulOne_6337(m: int)\n ensures m * 1 == m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_6338","instance":6338,"id":176337,"goal":"lemma MulZero_6338(n: nat)\n ensures n * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_6339","instance":6339,"id":176338,"goal":"lemma LeRefl_6339(x: real)\n ensures x <= x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_6340","instance":6340,"id":176339,"goal":"lemma LeTrans_6340(x: int, b: int, y: int)\n requires x <= b && b <= y\n ensures x <= y\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_6341","instance":6341,"id":176340,"goal":"lemma AddMono_6341(i: nat, y: nat, b: nat)\n requires i <= y\n ensures i + b <= y + b\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_6342","instance":6342,"id":176341,"goal":"lemma Abs_Nonneg_6342(c: real)\n ensures (if c >= 0 then c else -c) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_6343","instance":6343,"id":176342,"goal":"lemma DivMod_6343(b: int, n: int)\n requires n > 0\n ensures b == n * (b / n) + (b % n)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_6344","instance":6344,"id":176343,"goal":"lemma ModBounds_6344(a: nat, b: nat)\n requires b > 0\n ensures 0 <= a % b < b\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_6345","instance":6345,"id":176344,"goal":"lemma Square_Nonneg_6345(i: real)\n ensures i * i >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_6346","instance":6346,"id":176345,"goal":"lemma AddComm_6346(b: int, i: int)\n ensures b + i == i + b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_6347","instance":6347,"id":176346,"goal":"lemma AddAssoc_6347(j: nat, z: nat, k: nat)\n ensures (j + z) + k == j + (z + k)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_6348","instance":6348,"id":176347,"goal":"lemma MulComm_6348(x: real, d: real)\n ensures x * d == d * x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_6349","instance":6349,"id":176348,"goal":"lemma MulAssoc_6349(x: int, c: int, b: int)\n ensures (x * c) * b == x * (c * b)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_6350","instance":6350,"id":176349,"goal":"lemma Distrib_6350(b: nat, k: nat, y: nat)\n ensures b * (k + y) == b * k + b * y\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_6351","instance":6351,"id":176350,"goal":"lemma AddZero_6351(i: real)\n ensures i + 0 == i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_6352","instance":6352,"id":176351,"goal":"lemma MulOne_6352(k: int)\n ensures k * 1 == k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_6353","instance":6353,"id":176352,"goal":"lemma MulZero_6353(x: nat)\n ensures x * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_6354","instance":6354,"id":176353,"goal":"lemma LeRefl_6354(z: real)\n ensures z <= z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_6355","instance":6355,"id":176354,"goal":"lemma LeTrans_6355(a: int, y: int, i: int)\n requires a <= y && y <= i\n ensures a <= i\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_6356","instance":6356,"id":176355,"goal":"lemma AddMono_6356(n: nat, i: nat, m: nat)\n requires n <= i\n ensures n + m <= i + m\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_6357","instance":6357,"id":176356,"goal":"lemma Abs_Nonneg_6357(c: real)\n ensures (if c >= 0 then c else -c) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_6358","instance":6358,"id":176357,"goal":"lemma DivMod_6358(y: int, m: int)\n requires m > 0\n ensures y == m * (y / m) + (y % m)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_6359","instance":6359,"id":176358,"goal":"lemma ModBounds_6359(j: nat, n: nat)\n requires n > 0\n ensures 0 <= j % n < n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_6360","instance":6360,"id":176359,"goal":"lemma Square_Nonneg_6360(d: real)\n ensures d * d >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_6361","instance":6361,"id":176360,"goal":"lemma AddComm_6361(k: int, n: int)\n ensures k + n == n + k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_6362","instance":6362,"id":176361,"goal":"lemma AddAssoc_6362(n: nat, i: nat, k: nat)\n ensures (n + i) + k == n + (i + k)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_6363","instance":6363,"id":176362,"goal":"lemma MulComm_6363(z: real, d: real)\n ensures z * d == d * z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_6364","instance":6364,"id":176363,"goal":"lemma MulAssoc_6364(x: int, j: int, m: int)\n ensures (x * j) * m == x * (j * m)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_6365","instance":6365,"id":176364,"goal":"lemma Distrib_6365(a: nat, d: nat, b: nat)\n ensures a * (d + b) == a * d + a * b\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_6366","instance":6366,"id":176365,"goal":"lemma AddZero_6366(x: real)\n ensures x + 0 == x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_6367","instance":6367,"id":176366,"goal":"lemma MulOne_6367(y: int)\n ensures y * 1 == y\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_6368","instance":6368,"id":176367,"goal":"lemma MulZero_6368(y: nat)\n ensures y * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_6369","instance":6369,"id":176368,"goal":"lemma LeRefl_6369(a: real)\n ensures a <= a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_6370","instance":6370,"id":176369,"goal":"lemma LeTrans_6370(x: int, n: int, m: int)\n requires x <= n && n <= m\n ensures x <= m\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_6371","instance":6371,"id":176370,"goal":"lemma AddMono_6371(z: nat, k: nat, j: nat)\n requires z <= k\n ensures z + j <= k + j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_6372","instance":6372,"id":176371,"goal":"lemma Abs_Nonneg_6372(m: real)\n ensures (if m >= 0 then m else -m) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_6373","instance":6373,"id":176372,"goal":"lemma DivMod_6373(z: int, y: int)\n requires y > 0\n ensures z == y * (z / y) + (z % y)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_6374","instance":6374,"id":176373,"goal":"lemma ModBounds_6374(z: nat, x: nat)\n requires x > 0\n ensures 0 <= z % x < x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_6375","instance":6375,"id":176374,"goal":"lemma Square_Nonneg_6375(d: real)\n ensures d * d >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_6376","instance":6376,"id":176375,"goal":"lemma AddComm_6376(m: int, z: int)\n ensures m + z == z + m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_6377","instance":6377,"id":176376,"goal":"lemma AddAssoc_6377(b: nat, y: nat, d: nat)\n ensures (b + y) + d == b + (y + d)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_6378","instance":6378,"id":176377,"goal":"lemma MulComm_6378(i: real, c: real)\n ensures i * c == c * i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_6379","instance":6379,"id":176378,"goal":"lemma MulAssoc_6379(i: int, d: int, c: int)\n ensures (i * d) * c == i * (d * c)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_6380","instance":6380,"id":176379,"goal":"lemma Distrib_6380(j: nat, b: nat, a: nat)\n ensures j * (b + a) == j * b + j * a\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_6381","instance":6381,"id":176380,"goal":"lemma AddZero_6381(k: real)\n ensures k + 0 == k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_6382","instance":6382,"id":176381,"goal":"lemma MulOne_6382(a: int)\n ensures a * 1 == a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_6383","instance":6383,"id":176382,"goal":"lemma MulZero_6383(d: nat)\n ensures d * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_6384","instance":6384,"id":176383,"goal":"lemma LeRefl_6384(c: real)\n ensures c <= c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_6385","instance":6385,"id":176384,"goal":"lemma LeTrans_6385(n: int, z: int, a: int)\n requires n <= z && z <= a\n ensures n <= a\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_6386","instance":6386,"id":176385,"goal":"lemma AddMono_6386(y: nat, d: nat, m: nat)\n requires y <= d\n ensures y + m <= d + m\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_6387","instance":6387,"id":176386,"goal":"lemma Abs_Nonneg_6387(a: real)\n ensures (if a >= 0 then a else -a) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_6388","instance":6388,"id":176387,"goal":"lemma DivMod_6388(d: int, c: int)\n requires c > 0\n ensures d == c * (d / c) + (d % c)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_6389","instance":6389,"id":176388,"goal":"lemma ModBounds_6389(j: nat, i: nat)\n requires i > 0\n ensures 0 <= j % i < i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_6390","instance":6390,"id":176389,"goal":"lemma Square_Nonneg_6390(m: real)\n ensures m * m >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_6391","instance":6391,"id":176390,"goal":"lemma AddComm_6391(x: int, k: int)\n ensures x + k == k + x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_6392","instance":6392,"id":176391,"goal":"lemma AddAssoc_6392(k: nat, m: nat, c: nat)\n ensures (k + m) + c == k + (m + c)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_6393","instance":6393,"id":176392,"goal":"lemma MulComm_6393(n: real, j: real)\n ensures n * j == j * n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_6394","instance":6394,"id":176393,"goal":"lemma MulAssoc_6394(z: int, x: int, b: int)\n ensures (z * x) * b == z * (x * b)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_6395","instance":6395,"id":176394,"goal":"lemma Distrib_6395(i: nat, b: nat, n: nat)\n ensures i * (b + n) == i * b + i * n\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_6396","instance":6396,"id":176395,"goal":"lemma AddZero_6396(c: real)\n ensures c + 0 == c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_6397","instance":6397,"id":176396,"goal":"lemma MulOne_6397(c: int)\n ensures c * 1 == c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_6398","instance":6398,"id":176397,"goal":"lemma MulZero_6398(x: nat)\n ensures x * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_6399","instance":6399,"id":176398,"goal":"lemma LeRefl_6399(x: real)\n ensures x <= x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_6400","instance":6400,"id":176399,"goal":"lemma LeTrans_6400(y: int, c: int, j: int)\n requires y <= c && c <= j\n ensures y <= j\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_6401","instance":6401,"id":176400,"goal":"lemma AddMono_6401(a: nat, n: nat, d: nat)\n requires a <= n\n ensures a + d <= n + d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_6402","instance":6402,"id":176401,"goal":"lemma Abs_Nonneg_6402(i: real)\n ensures (if i >= 0 then i else -i) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_6403","instance":6403,"id":176402,"goal":"lemma DivMod_6403(i: int, d: int)\n requires d > 0\n ensures i == d * (i / d) + (i % d)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_6404","instance":6404,"id":176403,"goal":"lemma ModBounds_6404(i: nat, x: nat)\n requires x > 0\n ensures 0 <= i % x < x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_6405","instance":6405,"id":176404,"goal":"lemma Square_Nonneg_6405(i: real)\n ensures i * i >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_6406","instance":6406,"id":176405,"goal":"lemma AddComm_6406(d: int, j: int)\n ensures d + j == j + d\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_6407","instance":6407,"id":176406,"goal":"lemma AddAssoc_6407(c: nat, k: nat, b: nat)\n ensures (c + k) + b == c + (k + b)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_6408","instance":6408,"id":176407,"goal":"lemma MulComm_6408(a: real, y: real)\n ensures a * y == y * a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_6409","instance":6409,"id":176408,"goal":"lemma MulAssoc_6409(x: int, d: int, b: int)\n ensures (x * d) * b == x * (d * b)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_6410","instance":6410,"id":176409,"goal":"lemma Distrib_6410(c: nat, k: nat, a: nat)\n ensures c * (k + a) == c * k + c * a\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_6411","instance":6411,"id":176410,"goal":"lemma AddZero_6411(i: real)\n ensures i + 0 == i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_6412","instance":6412,"id":176411,"goal":"lemma MulOne_6412(d: int)\n ensures d * 1 == d\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_6413","instance":6413,"id":176412,"goal":"lemma MulZero_6413(a: nat)\n ensures a * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_6414","instance":6414,"id":176413,"goal":"lemma LeRefl_6414(b: real)\n ensures b <= b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_6415","instance":6415,"id":176414,"goal":"lemma LeTrans_6415(y: int, d: int, k: int)\n requires y <= d && d <= k\n ensures y <= k\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_6416","instance":6416,"id":176415,"goal":"lemma AddMono_6416(a: nat, b: nat, m: nat)\n requires a <= b\n ensures a + m <= b + m\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_6417","instance":6417,"id":176416,"goal":"lemma Abs_Nonneg_6417(k: real)\n ensures (if k >= 0 then k else -k) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_6418","instance":6418,"id":176417,"goal":"lemma DivMod_6418(z: int, m: int)\n requires m > 0\n ensures z == m * (z / m) + (z % m)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_6419","instance":6419,"id":176418,"goal":"lemma ModBounds_6419(c: nat, b: nat)\n requires b > 0\n ensures 0 <= c % b < b\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_6420","instance":6420,"id":176419,"goal":"lemma Square_Nonneg_6420(c: real)\n ensures c * c >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_6421","instance":6421,"id":176420,"goal":"lemma AddComm_6421(m: int, b: int)\n ensures m + b == b + m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_6422","instance":6422,"id":176421,"goal":"lemma AddAssoc_6422(j: nat, a: nat, n: nat)\n ensures (j + a) + n == j + (a + n)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_6423","instance":6423,"id":176422,"goal":"lemma MulComm_6423(b: real, x: real)\n ensures b * x == x * b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_6424","instance":6424,"id":176423,"goal":"lemma MulAssoc_6424(n: int, k: int, x: int)\n ensures (n * k) * x == n * (k * x)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_6425","instance":6425,"id":176424,"goal":"lemma Distrib_6425(i: nat, m: nat, a: nat)\n ensures i * (m + a) == i * m + i * a\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_6426","instance":6426,"id":176425,"goal":"lemma AddZero_6426(z: real)\n ensures z + 0 == z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_6427","instance":6427,"id":176426,"goal":"lemma MulOne_6427(y: int)\n ensures y * 1 == y\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_6428","instance":6428,"id":176427,"goal":"lemma MulZero_6428(m: nat)\n ensures m * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_6429","instance":6429,"id":176428,"goal":"lemma LeRefl_6429(x: real)\n ensures x <= x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_6430","instance":6430,"id":176429,"goal":"lemma LeTrans_6430(k: int, d: int, i: int)\n requires k <= d && d <= i\n ensures k <= i\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_6431","instance":6431,"id":176430,"goal":"lemma AddMono_6431(y: nat, d: nat, m: nat)\n requires y <= d\n ensures y + m <= d + m\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_6432","instance":6432,"id":176431,"goal":"lemma Abs_Nonneg_6432(j: real)\n ensures (if j >= 0 then j else -j) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_6433","instance":6433,"id":176432,"goal":"lemma DivMod_6433(a: int, b: int)\n requires b > 0\n ensures a == b * (a / b) + (a % b)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_6434","instance":6434,"id":176433,"goal":"lemma ModBounds_6434(k: nat, c: nat)\n requires c > 0\n ensures 0 <= k % c < c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_6435","instance":6435,"id":176434,"goal":"lemma Square_Nonneg_6435(a: real)\n ensures a * a >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_6436","instance":6436,"id":176435,"goal":"lemma AddComm_6436(n: int, j: int)\n ensures n + j == j + n\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_6437","instance":6437,"id":176436,"goal":"lemma AddAssoc_6437(d: nat, y: nat, n: nat)\n ensures (d + y) + n == d + (y + n)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_6438","instance":6438,"id":176437,"goal":"lemma MulComm_6438(n: real, z: real)\n ensures n * z == z * n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_6439","instance":6439,"id":176438,"goal":"lemma MulAssoc_6439(b: int, n: int, k: int)\n ensures (b * n) * k == b * (n * k)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_6440","instance":6440,"id":176439,"goal":"lemma Distrib_6440(a: nat, d: nat, j: nat)\n ensures a * (d + j) == a * d + a * j\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_6441","instance":6441,"id":176440,"goal":"lemma AddZero_6441(x: real)\n ensures x + 0 == x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_6442","instance":6442,"id":176441,"goal":"lemma MulOne_6442(c: int)\n ensures c * 1 == c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_6443","instance":6443,"id":176442,"goal":"lemma MulZero_6443(z: nat)\n ensures z * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_6444","instance":6444,"id":176443,"goal":"lemma LeRefl_6444(a: real)\n ensures a <= a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_6445","instance":6445,"id":176444,"goal":"lemma LeTrans_6445(i: int, j: int, m: int)\n requires i <= j && j <= m\n ensures i <= m\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_6446","instance":6446,"id":176445,"goal":"lemma AddMono_6446(i: nat, k: nat, a: nat)\n requires i <= k\n ensures i + a <= k + a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_6447","instance":6447,"id":176446,"goal":"lemma Abs_Nonneg_6447(k: real)\n ensures (if k >= 0 then k else -k) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_6448","instance":6448,"id":176447,"goal":"lemma DivMod_6448(n: int, a: int)\n requires a > 0\n ensures n == a * (n / a) + (n % a)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_6449","instance":6449,"id":176448,"goal":"lemma ModBounds_6449(i: nat, d: nat)\n requires d > 0\n ensures 0 <= i % d < d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_6450","instance":6450,"id":176449,"goal":"lemma Square_Nonneg_6450(z: real)\n ensures z * z >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_6451","instance":6451,"id":176450,"goal":"lemma AddComm_6451(j: int, a: int)\n ensures j + a == a + j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_6452","instance":6452,"id":176451,"goal":"lemma AddAssoc_6452(j: nat, a: nat, b: nat)\n ensures (j + a) + b == j + (a + b)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_6453","instance":6453,"id":176452,"goal":"lemma MulComm_6453(b: real, k: real)\n ensures b * k == k * b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_6454","instance":6454,"id":176453,"goal":"lemma MulAssoc_6454(y: int, d: int, j: int)\n ensures (y * d) * j == y * (d * j)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_6455","instance":6455,"id":176454,"goal":"lemma Distrib_6455(y: nat, c: nat, a: nat)\n ensures y * (c + a) == y * c + y * a\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_6456","instance":6456,"id":176455,"goal":"lemma AddZero_6456(y: real)\n ensures y + 0 == y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_6457","instance":6457,"id":176456,"goal":"lemma MulOne_6457(c: int)\n ensures c * 1 == c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_6458","instance":6458,"id":176457,"goal":"lemma MulZero_6458(a: nat)\n ensures a * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_6459","instance":6459,"id":176458,"goal":"lemma LeRefl_6459(i: real)\n ensures i <= i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_6460","instance":6460,"id":176459,"goal":"lemma LeTrans_6460(m: int, x: int, z: int)\n requires m <= x && x <= z\n ensures m <= z\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_6461","instance":6461,"id":176460,"goal":"lemma AddMono_6461(z: nat, m: nat, c: nat)\n requires z <= m\n ensures z + c <= m + c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_6462","instance":6462,"id":176461,"goal":"lemma Abs_Nonneg_6462(d: real)\n ensures (if d >= 0 then d else -d) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_6463","instance":6463,"id":176462,"goal":"lemma DivMod_6463(j: int, a: int)\n requires a > 0\n ensures j == a * (j / a) + (j % a)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_6464","instance":6464,"id":176463,"goal":"lemma ModBounds_6464(j: nat, n: nat)\n requires n > 0\n ensures 0 <= j % n < n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_6465","instance":6465,"id":176464,"goal":"lemma Square_Nonneg_6465(y: real)\n ensures y * y >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_6466","instance":6466,"id":176465,"goal":"lemma AddComm_6466(i: int, z: int)\n ensures i + z == z + i\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_6467","instance":6467,"id":176466,"goal":"lemma AddAssoc_6467(j: nat, b: nat, c: nat)\n ensures (j + b) + c == j + (b + c)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_6468","instance":6468,"id":176467,"goal":"lemma MulComm_6468(m: real, y: real)\n ensures m * y == y * m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_6469","instance":6469,"id":176468,"goal":"lemma MulAssoc_6469(c: int, n: int, k: int)\n ensures (c * n) * k == c * (n * k)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_6470","instance":6470,"id":176469,"goal":"lemma Distrib_6470(a: nat, m: nat, k: nat)\n ensures a * (m + k) == a * m + a * k\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_6471","instance":6471,"id":176470,"goal":"lemma AddZero_6471(x: real)\n ensures x + 0 == x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_6472","instance":6472,"id":176471,"goal":"lemma MulOne_6472(y: int)\n ensures y * 1 == y\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_6473","instance":6473,"id":176472,"goal":"lemma MulZero_6473(a: nat)\n ensures a * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_6474","instance":6474,"id":176473,"goal":"lemma LeRefl_6474(c: real)\n ensures c <= c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_6475","instance":6475,"id":176474,"goal":"lemma LeTrans_6475(c: int, a: int, z: int)\n requires c <= a && a <= z\n ensures c <= z\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_6476","instance":6476,"id":176475,"goal":"lemma AddMono_6476(j: nat, d: nat, c: nat)\n requires j <= d\n ensures j + c <= d + c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_6477","instance":6477,"id":176476,"goal":"lemma Abs_Nonneg_6477(j: real)\n ensures (if j >= 0 then j else -j) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_6478","instance":6478,"id":176477,"goal":"lemma DivMod_6478(m: int, d: int)\n requires d > 0\n ensures m == d * (m / d) + (m % d)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_6479","instance":6479,"id":176478,"goal":"lemma ModBounds_6479(b: nat, k: nat)\n requires k > 0\n ensures 0 <= b % k < k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_6480","instance":6480,"id":176479,"goal":"lemma Square_Nonneg_6480(y: real)\n ensures y * y >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_6481","instance":6481,"id":176480,"goal":"lemma AddComm_6481(x: int, n: int)\n ensures x + n == n + x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_6482","instance":6482,"id":176481,"goal":"lemma AddAssoc_6482(a: nat, z: nat, j: nat)\n ensures (a + z) + j == a + (z + j)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_6483","instance":6483,"id":176482,"goal":"lemma MulComm_6483(a: real, d: real)\n ensures a * d == d * a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_6484","instance":6484,"id":176483,"goal":"lemma MulAssoc_6484(i: int, j: int, b: int)\n ensures (i * j) * b == i * (j * b)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_6485","instance":6485,"id":176484,"goal":"lemma Distrib_6485(j: nat, c: nat, i: nat)\n ensures j * (c + i) == j * c + j * i\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_6486","instance":6486,"id":176485,"goal":"lemma AddZero_6486(c: real)\n ensures c + 0 == c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_6487","instance":6487,"id":176486,"goal":"lemma MulOne_6487(z: int)\n ensures z * 1 == z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_6488","instance":6488,"id":176487,"goal":"lemma MulZero_6488(y: nat)\n ensures y * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_6489","instance":6489,"id":176488,"goal":"lemma LeRefl_6489(x: real)\n ensures x <= x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_6490","instance":6490,"id":176489,"goal":"lemma LeTrans_6490(j: int, z: int, d: int)\n requires j <= z && z <= d\n ensures j <= d\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_6491","instance":6491,"id":176490,"goal":"lemma AddMono_6491(m: nat, i: nat, k: nat)\n requires m <= i\n ensures m + k <= i + k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_6492","instance":6492,"id":176491,"goal":"lemma Abs_Nonneg_6492(c: real)\n ensures (if c >= 0 then c else -c) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_6493","instance":6493,"id":176492,"goal":"lemma DivMod_6493(b: int, j: int)\n requires j > 0\n ensures b == j * (b / j) + (b % j)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_6494","instance":6494,"id":176493,"goal":"lemma ModBounds_6494(j: nat, k: nat)\n requires k > 0\n ensures 0 <= j % k < k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_6495","instance":6495,"id":176494,"goal":"lemma Square_Nonneg_6495(d: real)\n ensures d * d >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_6496","instance":6496,"id":176495,"goal":"lemma AddComm_6496(m: int, b: int)\n ensures m + b == b + m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_6497","instance":6497,"id":176496,"goal":"lemma AddAssoc_6497(z: nat, y: nat, a: nat)\n ensures (z + y) + a == z + (y + a)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_6498","instance":6498,"id":176497,"goal":"lemma MulComm_6498(j: real, d: real)\n ensures j * d == d * j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_6499","instance":6499,"id":176498,"goal":"lemma MulAssoc_6499(j: int, x: int, a: int)\n ensures (j * x) * a == j * (x * a)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_6500","instance":6500,"id":176499,"goal":"lemma Distrib_6500(z: nat, k: nat, x: nat)\n ensures z * (k + x) == z * k + z * x\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_6501","instance":6501,"id":176500,"goal":"lemma AddZero_6501(d: real)\n ensures d + 0 == d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_6502","instance":6502,"id":176501,"goal":"lemma MulOne_6502(y: int)\n ensures y * 1 == y\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_6503","instance":6503,"id":176502,"goal":"lemma MulZero_6503(k: nat)\n ensures k * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_6504","instance":6504,"id":176503,"goal":"lemma LeRefl_6504(m: real)\n ensures m <= m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_6505","instance":6505,"id":176504,"goal":"lemma LeTrans_6505(j: int, b: int, k: int)\n requires j <= b && b <= k\n ensures j <= k\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_6506","instance":6506,"id":176505,"goal":"lemma AddMono_6506(d: nat, c: nat, n: nat)\n requires d <= c\n ensures d + n <= c + n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_6507","instance":6507,"id":176506,"goal":"lemma Abs_Nonneg_6507(j: real)\n ensures (if j >= 0 then j else -j) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_6508","instance":6508,"id":176507,"goal":"lemma DivMod_6508(d: int, a: int)\n requires a > 0\n ensures d == a * (d / a) + (d % a)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_6509","instance":6509,"id":176508,"goal":"lemma ModBounds_6509(d: nat, x: nat)\n requires x > 0\n ensures 0 <= d % x < x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_6510","instance":6510,"id":176509,"goal":"lemma Square_Nonneg_6510(j: real)\n ensures j * j >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_6511","instance":6511,"id":176510,"goal":"lemma AddComm_6511(i: int, n: int)\n ensures i + n == n + i\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_6512","instance":6512,"id":176511,"goal":"lemma AddAssoc_6512(n: nat, i: nat, a: nat)\n ensures (n + i) + a == n + (i + a)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_6513","instance":6513,"id":176512,"goal":"lemma MulComm_6513(j: real, b: real)\n ensures j * b == b * j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_6514","instance":6514,"id":176513,"goal":"lemma MulAssoc_6514(a: int, b: int, k: int)\n ensures (a * b) * k == a * (b * k)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_6515","instance":6515,"id":176514,"goal":"lemma Distrib_6515(x: nat, z: nat, i: nat)\n ensures x * (z + i) == x * z + x * i\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_6516","instance":6516,"id":176515,"goal":"lemma AddZero_6516(j: real)\n ensures j + 0 == j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_6517","instance":6517,"id":176516,"goal":"lemma MulOne_6517(z: int)\n ensures z * 1 == z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_6518","instance":6518,"id":176517,"goal":"lemma MulZero_6518(m: nat)\n ensures m * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_6519","instance":6519,"id":176518,"goal":"lemma LeRefl_6519(m: real)\n ensures m <= m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_6520","instance":6520,"id":176519,"goal":"lemma LeTrans_6520(b: int, k: int, x: int)\n requires b <= k && k <= x\n ensures b <= x\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_6521","instance":6521,"id":176520,"goal":"lemma AddMono_6521(y: nat, b: nat, n: nat)\n requires y <= b\n ensures y + n <= b + n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_6522","instance":6522,"id":176521,"goal":"lemma Abs_Nonneg_6522(d: real)\n ensures (if d >= 0 then d else -d) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_6523","instance":6523,"id":176522,"goal":"lemma DivMod_6523(a: int, i: int)\n requires i > 0\n ensures a == i * (a / i) + (a % i)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_6524","instance":6524,"id":176523,"goal":"lemma ModBounds_6524(j: nat, c: nat)\n requires c > 0\n ensures 0 <= j % c < c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_6525","instance":6525,"id":176524,"goal":"lemma Square_Nonneg_6525(z: real)\n ensures z * z >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_6526","instance":6526,"id":176525,"goal":"lemma AddComm_6526(z: int, x: int)\n ensures z + x == x + z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_6527","instance":6527,"id":176526,"goal":"lemma AddAssoc_6527(j: nat, b: nat, y: nat)\n ensures (j + b) + y == j + (b + y)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_6528","instance":6528,"id":176527,"goal":"lemma MulComm_6528(d: real, c: real)\n ensures d * c == c * d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_6529","instance":6529,"id":176528,"goal":"lemma MulAssoc_6529(y: int, z: int, m: int)\n ensures (y * z) * m == y * (z * m)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_6530","instance":6530,"id":176529,"goal":"lemma Distrib_6530(m: nat, c: nat, n: nat)\n ensures m * (c + n) == m * c + m * n\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_6531","instance":6531,"id":176530,"goal":"lemma AddZero_6531(j: real)\n ensures j + 0 == j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_6532","instance":6532,"id":176531,"goal":"lemma MulOne_6532(i: int)\n ensures i * 1 == i\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_6533","instance":6533,"id":176532,"goal":"lemma MulZero_6533(m: nat)\n ensures m * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_6534","instance":6534,"id":176533,"goal":"lemma LeRefl_6534(z: real)\n ensures z <= z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_6535","instance":6535,"id":176534,"goal":"lemma LeTrans_6535(a: int, m: int, i: int)\n requires a <= m && m <= i\n ensures a <= i\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_6536","instance":6536,"id":176535,"goal":"lemma AddMono_6536(c: nat, m: nat, y: nat)\n requires c <= m\n ensures c + y <= m + y\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_6537","instance":6537,"id":176536,"goal":"lemma Abs_Nonneg_6537(c: real)\n ensures (if c >= 0 then c else -c) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_6538","instance":6538,"id":176537,"goal":"lemma DivMod_6538(j: int, b: int)\n requires b > 0\n ensures j == b * (j / b) + (j % b)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_6539","instance":6539,"id":176538,"goal":"lemma ModBounds_6539(j: nat, y: nat)\n requires y > 0\n ensures 0 <= j % y < y\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_6540","instance":6540,"id":176539,"goal":"lemma Square_Nonneg_6540(m: real)\n ensures m * m >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_6541","instance":6541,"id":176540,"goal":"lemma AddComm_6541(i: int, j: int)\n ensures i + j == j + i\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_6542","instance":6542,"id":176541,"goal":"lemma AddAssoc_6542(y: nat, x: nat, d: nat)\n ensures (y + x) + d == y + (x + d)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_6543","instance":6543,"id":176542,"goal":"lemma MulComm_6543(k: real, x: real)\n ensures k * x == x * k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_6544","instance":6544,"id":176543,"goal":"lemma MulAssoc_6544(m: int, j: int, a: int)\n ensures (m * j) * a == m * (j * a)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_6545","instance":6545,"id":176544,"goal":"lemma Distrib_6545(y: nat, n: nat, x: nat)\n ensures y * (n + x) == y * n + y * x\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_6546","instance":6546,"id":176545,"goal":"lemma AddZero_6546(b: real)\n ensures b + 0 == b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_6547","instance":6547,"id":176546,"goal":"lemma MulOne_6547(y: int)\n ensures y * 1 == y\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_6548","instance":6548,"id":176547,"goal":"lemma MulZero_6548(j: nat)\n ensures j * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_6549","instance":6549,"id":176548,"goal":"lemma LeRefl_6549(k: real)\n ensures k <= k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_6550","instance":6550,"id":176549,"goal":"lemma LeTrans_6550(b: int, j: int, z: int)\n requires b <= j && j <= z\n ensures b <= z\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_6551","instance":6551,"id":176550,"goal":"lemma AddMono_6551(m: nat, i: nat, b: nat)\n requires m <= i\n ensures m + b <= i + b\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_6552","instance":6552,"id":176551,"goal":"lemma Abs_Nonneg_6552(c: real)\n ensures (if c >= 0 then c else -c) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_6553","instance":6553,"id":176552,"goal":"lemma DivMod_6553(c: int, m: int)\n requires m > 0\n ensures c == m * (c / m) + (c % m)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_6554","instance":6554,"id":176553,"goal":"lemma ModBounds_6554(d: nat, b: nat)\n requires b > 0\n ensures 0 <= d % b < b\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_6555","instance":6555,"id":176554,"goal":"lemma Square_Nonneg_6555(n: real)\n ensures n * n >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_6556","instance":6556,"id":176555,"goal":"lemma AddComm_6556(k: int, a: int)\n ensures k + a == a + k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_6557","instance":6557,"id":176556,"goal":"lemma AddAssoc_6557(d: nat, b: nat, x: nat)\n ensures (d + b) + x == d + (b + x)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_6558","instance":6558,"id":176557,"goal":"lemma MulComm_6558(m: real, b: real)\n ensures m * b == b * m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_6559","instance":6559,"id":176558,"goal":"lemma MulAssoc_6559(z: int, j: int, n: int)\n ensures (z * j) * n == z * (j * n)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_6560","instance":6560,"id":176559,"goal":"lemma Distrib_6560(k: nat, d: nat, x: nat)\n ensures k * (d + x) == k * d + k * x\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_6561","instance":6561,"id":176560,"goal":"lemma AddZero_6561(n: real)\n ensures n + 0 == n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_6562","instance":6562,"id":176561,"goal":"lemma MulOne_6562(d: int)\n ensures d * 1 == d\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_6563","instance":6563,"id":176562,"goal":"lemma MulZero_6563(n: nat)\n ensures n * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_6564","instance":6564,"id":176563,"goal":"lemma LeRefl_6564(x: real)\n ensures x <= x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_6565","instance":6565,"id":176564,"goal":"lemma LeTrans_6565(z: int, i: int, b: int)\n requires z <= i && i <= b\n ensures z <= b\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_6566","instance":6566,"id":176565,"goal":"lemma AddMono_6566(y: nat, d: nat, j: nat)\n requires y <= d\n ensures y + j <= d + j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_6567","instance":6567,"id":176566,"goal":"lemma Abs_Nonneg_6567(d: real)\n ensures (if d >= 0 then d else -d) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_6568","instance":6568,"id":176567,"goal":"lemma DivMod_6568(a: int, b: int)\n requires b > 0\n ensures a == b * (a / b) + (a % b)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_6569","instance":6569,"id":176568,"goal":"lemma ModBounds_6569(a: nat, z: nat)\n requires z > 0\n ensures 0 <= a % z < z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_6570","instance":6570,"id":176569,"goal":"lemma Square_Nonneg_6570(d: real)\n ensures d * d >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_6571","instance":6571,"id":176570,"goal":"lemma AddComm_6571(y: int, x: int)\n ensures y + x == x + y\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_6572","instance":6572,"id":176571,"goal":"lemma AddAssoc_6572(k: nat, j: nat, b: nat)\n ensures (k + j) + b == k + (j + b)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_6573","instance":6573,"id":176572,"goal":"lemma MulComm_6573(z: real, a: real)\n ensures z * a == a * z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_6574","instance":6574,"id":176573,"goal":"lemma MulAssoc_6574(i: int, b: int, y: int)\n ensures (i * b) * y == i * (b * y)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_6575","instance":6575,"id":176574,"goal":"lemma Distrib_6575(n: nat, z: nat, j: nat)\n ensures n * (z + j) == n * z + n * j\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_6576","instance":6576,"id":176575,"goal":"lemma AddZero_6576(j: real)\n ensures j + 0 == j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_6577","instance":6577,"id":176576,"goal":"lemma MulOne_6577(d: int)\n ensures d * 1 == d\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_6578","instance":6578,"id":176577,"goal":"lemma MulZero_6578(y: nat)\n ensures y * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_6579","instance":6579,"id":176578,"goal":"lemma LeRefl_6579(i: real)\n ensures i <= i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_6580","instance":6580,"id":176579,"goal":"lemma LeTrans_6580(j: int, i: int, b: int)\n requires j <= i && i <= b\n ensures j <= b\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_6581","instance":6581,"id":176580,"goal":"lemma AddMono_6581(n: nat, a: nat, k: nat)\n requires n <= a\n ensures n + k <= a + k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_6582","instance":6582,"id":176581,"goal":"lemma Abs_Nonneg_6582(m: real)\n ensures (if m >= 0 then m else -m) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_6583","instance":6583,"id":176582,"goal":"lemma DivMod_6583(y: int, n: int)\n requires n > 0\n ensures y == n * (y / n) + (y % n)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_6584","instance":6584,"id":176583,"goal":"lemma ModBounds_6584(d: nat, k: nat)\n requires k > 0\n ensures 0 <= d % k < k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_6585","instance":6585,"id":176584,"goal":"lemma Square_Nonneg_6585(z: real)\n ensures z * z >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_6586","instance":6586,"id":176585,"goal":"lemma AddComm_6586(z: int, y: int)\n ensures z + y == y + z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_6587","instance":6587,"id":176586,"goal":"lemma AddAssoc_6587(y: nat, i: nat, j: nat)\n ensures (y + i) + j == y + (i + j)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_6588","instance":6588,"id":176587,"goal":"lemma MulComm_6588(a: real, z: real)\n ensures a * z == z * a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_6589","instance":6589,"id":176588,"goal":"lemma MulAssoc_6589(m: int, i: int, y: int)\n ensures (m * i) * y == m * (i * y)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_6590","instance":6590,"id":176589,"goal":"lemma Distrib_6590(j: nat, a: nat, y: nat)\n ensures j * (a + y) == j * a + j * y\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_6591","instance":6591,"id":176590,"goal":"lemma AddZero_6591(x: real)\n ensures x + 0 == x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_6592","instance":6592,"id":176591,"goal":"lemma MulOne_6592(k: int)\n ensures k * 1 == k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_6593","instance":6593,"id":176592,"goal":"lemma MulZero_6593(a: nat)\n ensures a * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_6594","instance":6594,"id":176593,"goal":"lemma LeRefl_6594(i: real)\n ensures i <= i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_6595","instance":6595,"id":176594,"goal":"lemma LeTrans_6595(c: int, y: int, z: int)\n requires c <= y && y <= z\n ensures c <= z\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_6596","instance":6596,"id":176595,"goal":"lemma AddMono_6596(j: nat, z: nat, a: nat)\n requires j <= z\n ensures j + a <= z + a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_6597","instance":6597,"id":176596,"goal":"lemma Abs_Nonneg_6597(y: real)\n ensures (if y >= 0 then y else -y) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_6598","instance":6598,"id":176597,"goal":"lemma DivMod_6598(i: int, j: int)\n requires j > 0\n ensures i == j * (i / j) + (i % j)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_6599","instance":6599,"id":176598,"goal":"lemma ModBounds_6599(d: nat, k: nat)\n requires k > 0\n ensures 0 <= d % k < k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_6600","instance":6600,"id":176599,"goal":"lemma Square_Nonneg_6600(k: real)\n ensures k * k >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_6601","instance":6601,"id":176600,"goal":"lemma AddComm_6601(y: int, j: int)\n ensures y + j == j + y\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_6602","instance":6602,"id":176601,"goal":"lemma AddAssoc_6602(m: nat, d: nat, c: nat)\n ensures (m + d) + c == m + (d + c)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_6603","instance":6603,"id":176602,"goal":"lemma MulComm_6603(m: real, c: real)\n ensures m * c == c * m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_6604","instance":6604,"id":176603,"goal":"lemma MulAssoc_6604(j: int, a: int, z: int)\n ensures (j * a) * z == j * (a * z)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_6605","instance":6605,"id":176604,"goal":"lemma Distrib_6605(c: nat, j: nat, a: nat)\n ensures c * (j + a) == c * j + c * a\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_6606","instance":6606,"id":176605,"goal":"lemma AddZero_6606(a: real)\n ensures a + 0 == a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_6607","instance":6607,"id":176606,"goal":"lemma MulOne_6607(j: int)\n ensures j * 1 == j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_6608","instance":6608,"id":176607,"goal":"lemma MulZero_6608(m: nat)\n ensures m * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_6609","instance":6609,"id":176608,"goal":"lemma LeRefl_6609(z: real)\n ensures z <= z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_6610","instance":6610,"id":176609,"goal":"lemma LeTrans_6610(m: int, c: int, z: int)\n requires m <= c && c <= z\n ensures m <= z\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_6611","instance":6611,"id":176610,"goal":"lemma AddMono_6611(j: nat, i: nat, y: nat)\n requires j <= i\n ensures j + y <= i + y\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_6612","instance":6612,"id":176611,"goal":"lemma Abs_Nonneg_6612(k: real)\n ensures (if k >= 0 then k else -k) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_6613","instance":6613,"id":176612,"goal":"lemma DivMod_6613(m: int, n: int)\n requires n > 0\n ensures m == n * (m / n) + (m % n)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_6614","instance":6614,"id":176613,"goal":"lemma ModBounds_6614(c: nat, y: nat)\n requires y > 0\n ensures 0 <= c % y < y\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_6615","instance":6615,"id":176614,"goal":"lemma Square_Nonneg_6615(k: real)\n ensures k * k >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_6616","instance":6616,"id":176615,"goal":"lemma AddComm_6616(d: int, y: int)\n ensures d + y == y + d\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_6617","instance":6617,"id":176616,"goal":"lemma AddAssoc_6617(y: nat, j: nat, x: nat)\n ensures (y + j) + x == y + (j + x)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_6618","instance":6618,"id":176617,"goal":"lemma MulComm_6618(z: real, a: real)\n ensures z * a == a * z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_6619","instance":6619,"id":176618,"goal":"lemma MulAssoc_6619(n: int, a: int, k: int)\n ensures (n * a) * k == n * (a * k)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_6620","instance":6620,"id":176619,"goal":"lemma Distrib_6620(d: nat, c: nat, y: nat)\n ensures d * (c + y) == d * c + d * y\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_6621","instance":6621,"id":176620,"goal":"lemma AddZero_6621(c: real)\n ensures c + 0 == c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_6622","instance":6622,"id":176621,"goal":"lemma MulOne_6622(a: int)\n ensures a * 1 == a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_6623","instance":6623,"id":176622,"goal":"lemma MulZero_6623(i: nat)\n ensures i * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_6624","instance":6624,"id":176623,"goal":"lemma LeRefl_6624(n: real)\n ensures n <= n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_6625","instance":6625,"id":176624,"goal":"lemma LeTrans_6625(d: int, m: int, x: int)\n requires d <= m && m <= x\n ensures d <= x\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_6626","instance":6626,"id":176625,"goal":"lemma AddMono_6626(y: nat, n: nat, k: nat)\n requires y <= n\n ensures y + k <= n + k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_6627","instance":6627,"id":176626,"goal":"lemma Abs_Nonneg_6627(z: real)\n ensures (if z >= 0 then z else -z) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_6628","instance":6628,"id":176627,"goal":"lemma DivMod_6628(m: int, c: int)\n requires c > 0\n ensures m == c * (m / c) + (m % c)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_6629","instance":6629,"id":176628,"goal":"lemma ModBounds_6629(b: nat, k: nat)\n requires k > 0\n ensures 0 <= b % k < k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_6630","instance":6630,"id":176629,"goal":"lemma Square_Nonneg_6630(z: real)\n ensures z * z >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_6631","instance":6631,"id":176630,"goal":"lemma AddComm_6631(n: int, c: int)\n ensures n + c == c + n\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_6632","instance":6632,"id":176631,"goal":"lemma AddAssoc_6632(k: nat, c: nat, n: nat)\n ensures (k + c) + n == k + (c + n)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_6633","instance":6633,"id":176632,"goal":"lemma MulComm_6633(j: real, z: real)\n ensures j * z == z * j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_6634","instance":6634,"id":176633,"goal":"lemma MulAssoc_6634(n: int, j: int, m: int)\n ensures (n * j) * m == n * (j * m)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_6635","instance":6635,"id":176634,"goal":"lemma Distrib_6635(k: nat, a: nat, b: nat)\n ensures k * (a + b) == k * a + k * b\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_6636","instance":6636,"id":176635,"goal":"lemma AddZero_6636(b: real)\n ensures b + 0 == b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_6637","instance":6637,"id":176636,"goal":"lemma MulOne_6637(k: int)\n ensures k * 1 == k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_6638","instance":6638,"id":176637,"goal":"lemma MulZero_6638(d: nat)\n ensures d * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_6639","instance":6639,"id":176638,"goal":"lemma LeRefl_6639(a: real)\n ensures a <= a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_6640","instance":6640,"id":176639,"goal":"lemma LeTrans_6640(c: int, y: int, n: int)\n requires c <= y && y <= n\n ensures c <= n\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_6641","instance":6641,"id":176640,"goal":"lemma AddMono_6641(x: nat, n: nat, d: nat)\n requires x <= n\n ensures x + d <= n + d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_6642","instance":6642,"id":176641,"goal":"lemma Abs_Nonneg_6642(x: real)\n ensures (if x >= 0 then x else -x) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_6643","instance":6643,"id":176642,"goal":"lemma DivMod_6643(j: int, i: int)\n requires i > 0\n ensures j == i * (j / i) + (j % i)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_6644","instance":6644,"id":176643,"goal":"lemma ModBounds_6644(c: nat, n: nat)\n requires n > 0\n ensures 0 <= c % n < n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_6645","instance":6645,"id":176644,"goal":"lemma Square_Nonneg_6645(z: real)\n ensures z * z >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_6646","instance":6646,"id":176645,"goal":"lemma AddComm_6646(d: int, y: int)\n ensures d + y == y + d\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_6647","instance":6647,"id":176646,"goal":"lemma AddAssoc_6647(m: nat, i: nat, k: nat)\n ensures (m + i) + k == m + (i + k)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_6648","instance":6648,"id":176647,"goal":"lemma MulComm_6648(y: real, a: real)\n ensures y * a == a * y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_6649","instance":6649,"id":176648,"goal":"lemma MulAssoc_6649(z: int, x: int, m: int)\n ensures (z * x) * m == z * (x * m)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_6650","instance":6650,"id":176649,"goal":"lemma Distrib_6650(i: nat, y: nat, a: nat)\n ensures i * (y + a) == i * y + i * a\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_6651","instance":6651,"id":176650,"goal":"lemma AddZero_6651(a: real)\n ensures a + 0 == a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_6652","instance":6652,"id":176651,"goal":"lemma MulOne_6652(a: int)\n ensures a * 1 == a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_6653","instance":6653,"id":176652,"goal":"lemma MulZero_6653(b: nat)\n ensures b * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_6654","instance":6654,"id":176653,"goal":"lemma LeRefl_6654(d: real)\n ensures d <= d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_6655","instance":6655,"id":176654,"goal":"lemma LeTrans_6655(c: int, d: int, a: int)\n requires c <= d && d <= a\n ensures c <= a\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_6656","instance":6656,"id":176655,"goal":"lemma AddMono_6656(a: nat, c: nat, k: nat)\n requires a <= c\n ensures a + k <= c + k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_6657","instance":6657,"id":176656,"goal":"lemma Abs_Nonneg_6657(d: real)\n ensures (if d >= 0 then d else -d) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_6658","instance":6658,"id":176657,"goal":"lemma DivMod_6658(i: int, a: int)\n requires a > 0\n ensures i == a * (i / a) + (i % a)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_6659","instance":6659,"id":176658,"goal":"lemma ModBounds_6659(a: nat, c: nat)\n requires c > 0\n ensures 0 <= a % c < c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_6660","instance":6660,"id":176659,"goal":"lemma Square_Nonneg_6660(k: real)\n ensures k * k >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_6661","instance":6661,"id":176660,"goal":"lemma AddComm_6661(z: int, b: int)\n ensures z + b == b + z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_6662","instance":6662,"id":176661,"goal":"lemma AddAssoc_6662(j: nat, c: nat, y: nat)\n ensures (j + c) + y == j + (c + y)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_6663","instance":6663,"id":176662,"goal":"lemma MulComm_6663(m: real, k: real)\n ensures m * k == k * m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_6664","instance":6664,"id":176663,"goal":"lemma MulAssoc_6664(i: int, x: int, z: int)\n ensures (i * x) * z == i * (x * z)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_6665","instance":6665,"id":176664,"goal":"lemma Distrib_6665(i: nat, y: nat, c: nat)\n ensures i * (y + c) == i * y + i * c\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_6666","instance":6666,"id":176665,"goal":"lemma AddZero_6666(b: real)\n ensures b + 0 == b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_6667","instance":6667,"id":176666,"goal":"lemma MulOne_6667(d: int)\n ensures d * 1 == d\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_6668","instance":6668,"id":176667,"goal":"lemma MulZero_6668(y: nat)\n ensures y * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_6669","instance":6669,"id":176668,"goal":"lemma LeRefl_6669(a: real)\n ensures a <= a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_6670","instance":6670,"id":176669,"goal":"lemma LeTrans_6670(y: int, m: int, x: int)\n requires y <= m && m <= x\n ensures y <= x\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_6671","instance":6671,"id":176670,"goal":"lemma AddMono_6671(z: nat, m: nat, b: nat)\n requires z <= m\n ensures z + b <= m + b\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_6672","instance":6672,"id":176671,"goal":"lemma Abs_Nonneg_6672(d: real)\n ensures (if d >= 0 then d else -d) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_6673","instance":6673,"id":176672,"goal":"lemma DivMod_6673(b: int, c: int)\n requires c > 0\n ensures b == c * (b / c) + (b % c)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_6674","instance":6674,"id":176673,"goal":"lemma ModBounds_6674(c: nat, k: nat)\n requires k > 0\n ensures 0 <= c % k < k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_6675","instance":6675,"id":176674,"goal":"lemma Square_Nonneg_6675(m: real)\n ensures m * m >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_6676","instance":6676,"id":176675,"goal":"lemma AddComm_6676(c: int, x: int)\n ensures c + x == x + c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_6677","instance":6677,"id":176676,"goal":"lemma AddAssoc_6677(j: nat, a: nat, m: nat)\n ensures (j + a) + m == j + (a + m)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_6678","instance":6678,"id":176677,"goal":"lemma MulComm_6678(i: real, x: real)\n ensures i * x == x * i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_6679","instance":6679,"id":176678,"goal":"lemma MulAssoc_6679(d: int, n: int, a: int)\n ensures (d * n) * a == d * (n * a)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_6680","instance":6680,"id":176679,"goal":"lemma Distrib_6680(k: nat, b: nat, m: nat)\n ensures k * (b + m) == k * b + k * m\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_6681","instance":6681,"id":176680,"goal":"lemma AddZero_6681(b: real)\n ensures b + 0 == b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_6682","instance":6682,"id":176681,"goal":"lemma MulOne_6682(c: int)\n ensures c * 1 == c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_6683","instance":6683,"id":176682,"goal":"lemma MulZero_6683(i: nat)\n ensures i * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_6684","instance":6684,"id":176683,"goal":"lemma LeRefl_6684(i: real)\n ensures i <= i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_6685","instance":6685,"id":176684,"goal":"lemma LeTrans_6685(y: int, j: int, n: int)\n requires y <= j && j <= n\n ensures y <= n\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_6686","instance":6686,"id":176685,"goal":"lemma AddMono_6686(n: nat, b: nat, j: nat)\n requires n <= b\n ensures n + j <= b + j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_6687","instance":6687,"id":176686,"goal":"lemma Abs_Nonneg_6687(d: real)\n ensures (if d >= 0 then d else -d) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_6688","instance":6688,"id":176687,"goal":"lemma DivMod_6688(c: int, z: int)\n requires z > 0\n ensures c == z * (c / z) + (c % z)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_6689","instance":6689,"id":176688,"goal":"lemma ModBounds_6689(b: nat, x: nat)\n requires x > 0\n ensures 0 <= b % x < x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_6690","instance":6690,"id":176689,"goal":"lemma Square_Nonneg_6690(k: real)\n ensures k * k >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_6691","instance":6691,"id":176690,"goal":"lemma AddComm_6691(b: int, y: int)\n ensures b + y == y + b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_6692","instance":6692,"id":176691,"goal":"lemma AddAssoc_6692(a: nat, y: nat, d: nat)\n ensures (a + y) + d == a + (y + d)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_6693","instance":6693,"id":176692,"goal":"lemma MulComm_6693(z: real, x: real)\n ensures z * x == x * z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_6694","instance":6694,"id":176693,"goal":"lemma MulAssoc_6694(i: int, j: int, c: int)\n ensures (i * j) * c == i * (j * c)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_6695","instance":6695,"id":176694,"goal":"lemma Distrib_6695(x: nat, y: nat, z: nat)\n ensures x * (y + z) == x * y + x * z\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_6696","instance":6696,"id":176695,"goal":"lemma AddZero_6696(k: real)\n ensures k + 0 == k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_6697","instance":6697,"id":176696,"goal":"lemma MulOne_6697(j: int)\n ensures j * 1 == j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_6698","instance":6698,"id":176697,"goal":"lemma MulZero_6698(i: nat)\n ensures i * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_6699","instance":6699,"id":176698,"goal":"lemma LeRefl_6699(a: real)\n ensures a <= a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_6700","instance":6700,"id":176699,"goal":"lemma LeTrans_6700(x: int, y: int, k: int)\n requires x <= y && y <= k\n ensures x <= k\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_6701","instance":6701,"id":176700,"goal":"lemma AddMono_6701(y: nat, z: nat, j: nat)\n requires y <= z\n ensures y + j <= z + j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_6702","instance":6702,"id":176701,"goal":"lemma Abs_Nonneg_6702(n: real)\n ensures (if n >= 0 then n else -n) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_6703","instance":6703,"id":176702,"goal":"lemma DivMod_6703(n: int, a: int)\n requires a > 0\n ensures n == a * (n / a) + (n % a)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_6704","instance":6704,"id":176703,"goal":"lemma ModBounds_6704(m: nat, j: nat)\n requires j > 0\n ensures 0 <= m % j < j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_6705","instance":6705,"id":176704,"goal":"lemma Square_Nonneg_6705(z: real)\n ensures z * z >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_6706","instance":6706,"id":176705,"goal":"lemma AddComm_6706(k: int, y: int)\n ensures k + y == y + k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_6707","instance":6707,"id":176706,"goal":"lemma AddAssoc_6707(n: nat, m: nat, k: nat)\n ensures (n + m) + k == n + (m + k)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_6708","instance":6708,"id":176707,"goal":"lemma MulComm_6708(a: real, b: real)\n ensures a * b == b * a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_6709","instance":6709,"id":176708,"goal":"lemma MulAssoc_6709(d: int, i: int, m: int)\n ensures (d * i) * m == d * (i * m)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_6710","instance":6710,"id":176709,"goal":"lemma Distrib_6710(b: nat, x: nat, m: nat)\n ensures b * (x + m) == b * x + b * m\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_6711","instance":6711,"id":176710,"goal":"lemma AddZero_6711(b: real)\n ensures b + 0 == b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_6712","instance":6712,"id":176711,"goal":"lemma MulOne_6712(y: int)\n ensures y * 1 == y\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_6713","instance":6713,"id":176712,"goal":"lemma MulZero_6713(x: nat)\n ensures x * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_6714","instance":6714,"id":176713,"goal":"lemma LeRefl_6714(x: real)\n ensures x <= x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_6715","instance":6715,"id":176714,"goal":"lemma LeTrans_6715(y: int, x: int, a: int)\n requires y <= x && x <= a\n ensures y <= a\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_6716","instance":6716,"id":176715,"goal":"lemma AddMono_6716(d: nat, b: nat, j: nat)\n requires d <= b\n ensures d + j <= b + j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_6717","instance":6717,"id":176716,"goal":"lemma Abs_Nonneg_6717(k: real)\n ensures (if k >= 0 then k else -k) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_6718","instance":6718,"id":176717,"goal":"lemma DivMod_6718(x: int, j: int)\n requires j > 0\n ensures x == j * (x / j) + (x % j)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_6719","instance":6719,"id":176718,"goal":"lemma ModBounds_6719(y: nat, i: nat)\n requires i > 0\n ensures 0 <= y % i < i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_6720","instance":6720,"id":176719,"goal":"lemma Square_Nonneg_6720(j: real)\n ensures j * j >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_6721","instance":6721,"id":176720,"goal":"lemma AddComm_6721(z: int, m: int)\n ensures z + m == m + z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_6722","instance":6722,"id":176721,"goal":"lemma AddAssoc_6722(y: nat, n: nat, d: nat)\n ensures (y + n) + d == y + (n + d)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_6723","instance":6723,"id":176722,"goal":"lemma MulComm_6723(b: real, z: real)\n ensures b * z == z * b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_6724","instance":6724,"id":176723,"goal":"lemma MulAssoc_6724(j: int, x: int, d: int)\n ensures (j * x) * d == j * (x * d)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_6725","instance":6725,"id":176724,"goal":"lemma Distrib_6725(y: nat, c: nat, z: nat)\n ensures y * (c + z) == y * c + y * z\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_6726","instance":6726,"id":176725,"goal":"lemma AddZero_6726(y: real)\n ensures y + 0 == y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_6727","instance":6727,"id":176726,"goal":"lemma MulOne_6727(x: int)\n ensures x * 1 == x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_6728","instance":6728,"id":176727,"goal":"lemma MulZero_6728(a: nat)\n ensures a * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_6729","instance":6729,"id":176728,"goal":"lemma LeRefl_6729(x: real)\n ensures x <= x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_6730","instance":6730,"id":176729,"goal":"lemma LeTrans_6730(i: int, d: int, b: int)\n requires i <= d && d <= b\n ensures i <= b\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_6731","instance":6731,"id":176730,"goal":"lemma AddMono_6731(c: nat, a: nat, x: nat)\n requires c <= a\n ensures c + x <= a + x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_6732","instance":6732,"id":176731,"goal":"lemma Abs_Nonneg_6732(j: real)\n ensures (if j >= 0 then j else -j) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_6733","instance":6733,"id":176732,"goal":"lemma DivMod_6733(k: int, y: int)\n requires y > 0\n ensures k == y * (k / y) + (k % y)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_6734","instance":6734,"id":176733,"goal":"lemma ModBounds_6734(c: nat, x: nat)\n requires x > 0\n ensures 0 <= c % x < x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_6735","instance":6735,"id":176734,"goal":"lemma Square_Nonneg_6735(x: real)\n ensures x * x >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_6736","instance":6736,"id":176735,"goal":"lemma AddComm_6736(k: int, b: int)\n ensures k + b == b + k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_6737","instance":6737,"id":176736,"goal":"lemma AddAssoc_6737(x: nat, k: nat, j: nat)\n ensures (x + k) + j == x + (k + j)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_6738","instance":6738,"id":176737,"goal":"lemma MulComm_6738(b: real, n: real)\n ensures b * n == n * b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_6739","instance":6739,"id":176738,"goal":"lemma MulAssoc_6739(m: int, b: int, c: int)\n ensures (m * b) * c == m * (b * c)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_6740","instance":6740,"id":176739,"goal":"lemma Distrib_6740(x: nat, a: nat, z: nat)\n ensures x * (a + z) == x * a + x * z\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_6741","instance":6741,"id":176740,"goal":"lemma AddZero_6741(d: real)\n ensures d + 0 == d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_6742","instance":6742,"id":176741,"goal":"lemma MulOne_6742(n: int)\n ensures n * 1 == n\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_6743","instance":6743,"id":176742,"goal":"lemma MulZero_6743(y: nat)\n ensures y * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_6744","instance":6744,"id":176743,"goal":"lemma LeRefl_6744(i: real)\n ensures i <= i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_6745","instance":6745,"id":176744,"goal":"lemma LeTrans_6745(d: int, j: int, c: int)\n requires d <= j && j <= c\n ensures d <= c\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_6746","instance":6746,"id":176745,"goal":"lemma AddMono_6746(n: nat, c: nat, m: nat)\n requires n <= c\n ensures n + m <= c + m\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_6747","instance":6747,"id":176746,"goal":"lemma Abs_Nonneg_6747(k: real)\n ensures (if k >= 0 then k else -k) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_6748","instance":6748,"id":176747,"goal":"lemma DivMod_6748(y: int, j: int)\n requires j > 0\n ensures y == j * (y / j) + (y % j)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_6749","instance":6749,"id":176748,"goal":"lemma ModBounds_6749(x: nat, c: nat)\n requires c > 0\n ensures 0 <= x % c < c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_6750","instance":6750,"id":176749,"goal":"lemma Square_Nonneg_6750(k: real)\n ensures k * k >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_6751","instance":6751,"id":176750,"goal":"lemma AddComm_6751(i: int, y: int)\n ensures i + y == y + i\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_6752","instance":6752,"id":176751,"goal":"lemma AddAssoc_6752(x: nat, c: nat, a: nat)\n ensures (x + c) + a == x + (c + a)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_6753","instance":6753,"id":176752,"goal":"lemma MulComm_6753(c: real, k: real)\n ensures c * k == k * c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_6754","instance":6754,"id":176753,"goal":"lemma MulAssoc_6754(x: int, j: int, i: int)\n ensures (x * j) * i == x * (j * i)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_6755","instance":6755,"id":176754,"goal":"lemma Distrib_6755(n: nat, x: nat, z: nat)\n ensures n * (x + z) == n * x + n * z\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_6756","instance":6756,"id":176755,"goal":"lemma AddZero_6756(b: real)\n ensures b + 0 == b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_6757","instance":6757,"id":176756,"goal":"lemma MulOne_6757(x: int)\n ensures x * 1 == x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_6758","instance":6758,"id":176757,"goal":"lemma MulZero_6758(n: nat)\n ensures n * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_6759","instance":6759,"id":176758,"goal":"lemma LeRefl_6759(j: real)\n ensures j <= j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_6760","instance":6760,"id":176759,"goal":"lemma LeTrans_6760(a: int, j: int, n: int)\n requires a <= j && j <= n\n ensures a <= n\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_6761","instance":6761,"id":176760,"goal":"lemma AddMono_6761(n: nat, i: nat, y: nat)\n requires n <= i\n ensures n + y <= i + y\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_6762","instance":6762,"id":176761,"goal":"lemma Abs_Nonneg_6762(a: real)\n ensures (if a >= 0 then a else -a) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_6763","instance":6763,"id":176762,"goal":"lemma DivMod_6763(a: int, m: int)\n requires m > 0\n ensures a == m * (a / m) + (a % m)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_6764","instance":6764,"id":176763,"goal":"lemma ModBounds_6764(z: nat, m: nat)\n requires m > 0\n ensures 0 <= z % m < m\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_6765","instance":6765,"id":176764,"goal":"lemma Square_Nonneg_6765(a: real)\n ensures a * a >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_6766","instance":6766,"id":176765,"goal":"lemma AddComm_6766(j: int, i: int)\n ensures j + i == i + j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_6767","instance":6767,"id":176766,"goal":"lemma AddAssoc_6767(a: nat, n: nat, i: nat)\n ensures (a + n) + i == a + (n + i)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_6768","instance":6768,"id":176767,"goal":"lemma MulComm_6768(a: real, y: real)\n ensures a * y == y * a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_6769","instance":6769,"id":176768,"goal":"lemma MulAssoc_6769(k: int, d: int, i: int)\n ensures (k * d) * i == k * (d * i)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_6770","instance":6770,"id":176769,"goal":"lemma Distrib_6770(i: nat, d: nat, m: nat)\n ensures i * (d + m) == i * d + i * m\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_6771","instance":6771,"id":176770,"goal":"lemma AddZero_6771(k: real)\n ensures k + 0 == k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_6772","instance":6772,"id":176771,"goal":"lemma MulOne_6772(m: int)\n ensures m * 1 == m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_6773","instance":6773,"id":176772,"goal":"lemma MulZero_6773(j: nat)\n ensures j * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_6774","instance":6774,"id":176773,"goal":"lemma LeRefl_6774(a: real)\n ensures a <= a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_6775","instance":6775,"id":176774,"goal":"lemma LeTrans_6775(d: int, c: int, z: int)\n requires d <= c && c <= z\n ensures d <= z\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_6776","instance":6776,"id":176775,"goal":"lemma AddMono_6776(z: nat, a: nat, k: nat)\n requires z <= a\n ensures z + k <= a + k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_6777","instance":6777,"id":176776,"goal":"lemma Abs_Nonneg_6777(n: real)\n ensures (if n >= 0 then n else -n) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_6778","instance":6778,"id":176777,"goal":"lemma DivMod_6778(m: int, a: int)\n requires a > 0\n ensures m == a * (m / a) + (m % a)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_6779","instance":6779,"id":176778,"goal":"lemma ModBounds_6779(y: nat, i: nat)\n requires i > 0\n ensures 0 <= y % i < i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_6780","instance":6780,"id":176779,"goal":"lemma Square_Nonneg_6780(x: real)\n ensures x * x >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_6781","instance":6781,"id":176780,"goal":"lemma AddComm_6781(y: int, a: int)\n ensures y + a == a + y\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_6782","instance":6782,"id":176781,"goal":"lemma AddAssoc_6782(i: nat, a: nat, c: nat)\n ensures (i + a) + c == i + (a + c)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_6783","instance":6783,"id":176782,"goal":"lemma MulComm_6783(x: real, c: real)\n ensures x * c == c * x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_6784","instance":6784,"id":176783,"goal":"lemma MulAssoc_6784(n: int, a: int, m: int)\n ensures (n * a) * m == n * (a * m)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_6785","instance":6785,"id":176784,"goal":"lemma Distrib_6785(m: nat, x: nat, k: nat)\n ensures m * (x + k) == m * x + m * k\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_6786","instance":6786,"id":176785,"goal":"lemma AddZero_6786(x: real)\n ensures x + 0 == x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_6787","instance":6787,"id":176786,"goal":"lemma MulOne_6787(b: int)\n ensures b * 1 == b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_6788","instance":6788,"id":176787,"goal":"lemma MulZero_6788(y: nat)\n ensures y * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_6789","instance":6789,"id":176788,"goal":"lemma LeRefl_6789(y: real)\n ensures y <= y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_6790","instance":6790,"id":176789,"goal":"lemma LeTrans_6790(k: int, a: int, j: int)\n requires k <= a && a <= j\n ensures k <= j\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_6791","instance":6791,"id":176790,"goal":"lemma AddMono_6791(z: nat, n: nat, k: nat)\n requires z <= n\n ensures z + k <= n + k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_6792","instance":6792,"id":176791,"goal":"lemma Abs_Nonneg_6792(n: real)\n ensures (if n >= 0 then n else -n) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_6793","instance":6793,"id":176792,"goal":"lemma DivMod_6793(n: int, b: int)\n requires b > 0\n ensures n == b * (n / b) + (n % b)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_6794","instance":6794,"id":176793,"goal":"lemma ModBounds_6794(k: nat, d: nat)\n requires d > 0\n ensures 0 <= k % d < d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_6795","instance":6795,"id":176794,"goal":"lemma Square_Nonneg_6795(j: real)\n ensures j * j >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_6796","instance":6796,"id":176795,"goal":"lemma AddComm_6796(y: int, x: int)\n ensures y + x == x + y\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_6797","instance":6797,"id":176796,"goal":"lemma AddAssoc_6797(i: nat, a: nat, y: nat)\n ensures (i + a) + y == i + (a + y)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_6798","instance":6798,"id":176797,"goal":"lemma MulComm_6798(i: real, j: real)\n ensures i * j == j * i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_6799","instance":6799,"id":176798,"goal":"lemma MulAssoc_6799(m: int, y: int, i: int)\n ensures (m * y) * i == m * (y * i)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_6800","instance":6800,"id":176799,"goal":"lemma Distrib_6800(j: nat, n: nat, d: nat)\n ensures j * (n + d) == j * n + j * d\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_6801","instance":6801,"id":176800,"goal":"lemma AddZero_6801(n: real)\n ensures n + 0 == n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_6802","instance":6802,"id":176801,"goal":"lemma MulOne_6802(b: int)\n ensures b * 1 == b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_6803","instance":6803,"id":176802,"goal":"lemma MulZero_6803(b: nat)\n ensures b * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_6804","instance":6804,"id":176803,"goal":"lemma LeRefl_6804(a: real)\n ensures a <= a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_6805","instance":6805,"id":176804,"goal":"lemma LeTrans_6805(n: int, d: int, k: int)\n requires n <= d && d <= k\n ensures n <= k\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_6806","instance":6806,"id":176805,"goal":"lemma AddMono_6806(k: nat, m: nat, y: nat)\n requires k <= m\n ensures k + y <= m + y\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_6807","instance":6807,"id":176806,"goal":"lemma Abs_Nonneg_6807(c: real)\n ensures (if c >= 0 then c else -c) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_6808","instance":6808,"id":176807,"goal":"lemma DivMod_6808(z: int, x: int)\n requires x > 0\n ensures z == x * (z / x) + (z % x)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_6809","instance":6809,"id":176808,"goal":"lemma ModBounds_6809(z: nat, n: nat)\n requires n > 0\n ensures 0 <= z % n < n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_6810","instance":6810,"id":176809,"goal":"lemma Square_Nonneg_6810(a: real)\n ensures a * a >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_6811","instance":6811,"id":176810,"goal":"lemma AddComm_6811(c: int, m: int)\n ensures c + m == m + c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_6812","instance":6812,"id":176811,"goal":"lemma AddAssoc_6812(j: nat, i: nat, z: nat)\n ensures (j + i) + z == j + (i + z)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_6813","instance":6813,"id":176812,"goal":"lemma MulComm_6813(i: real, y: real)\n ensures i * y == y * i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_6814","instance":6814,"id":176813,"goal":"lemma MulAssoc_6814(c: int, d: int, x: int)\n ensures (c * d) * x == c * (d * x)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_6815","instance":6815,"id":176814,"goal":"lemma Distrib_6815(n: nat, b: nat, z: nat)\n ensures n * (b + z) == n * b + n * z\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_6816","instance":6816,"id":176815,"goal":"lemma AddZero_6816(k: real)\n ensures k + 0 == k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_6817","instance":6817,"id":176816,"goal":"lemma MulOne_6817(d: int)\n ensures d * 1 == d\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_6818","instance":6818,"id":176817,"goal":"lemma MulZero_6818(y: nat)\n ensures y * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_6819","instance":6819,"id":176818,"goal":"lemma LeRefl_6819(a: real)\n ensures a <= a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_6820","instance":6820,"id":176819,"goal":"lemma LeTrans_6820(d: int, i: int, x: int)\n requires d <= i && i <= x\n ensures d <= x\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_6821","instance":6821,"id":176820,"goal":"lemma AddMono_6821(z: nat, x: nat, y: nat)\n requires z <= x\n ensures z + y <= x + y\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_6822","instance":6822,"id":176821,"goal":"lemma Abs_Nonneg_6822(j: real)\n ensures (if j >= 0 then j else -j) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_6823","instance":6823,"id":176822,"goal":"lemma DivMod_6823(m: int, j: int)\n requires j > 0\n ensures m == j * (m / j) + (m % j)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_6824","instance":6824,"id":176823,"goal":"lemma ModBounds_6824(d: nat, m: nat)\n requires m > 0\n ensures 0 <= d % m < m\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_6825","instance":6825,"id":176824,"goal":"lemma Square_Nonneg_6825(c: real)\n ensures c * c >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_6826","instance":6826,"id":176825,"goal":"lemma AddComm_6826(m: int, d: int)\n ensures m + d == d + m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_6827","instance":6827,"id":176826,"goal":"lemma AddAssoc_6827(b: nat, n: nat, i: nat)\n ensures (b + n) + i == b + (n + i)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_6828","instance":6828,"id":176827,"goal":"lemma MulComm_6828(j: real, z: real)\n ensures j * z == z * j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_6829","instance":6829,"id":176828,"goal":"lemma MulAssoc_6829(n: int, b: int, z: int)\n ensures (n * b) * z == n * (b * z)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_6830","instance":6830,"id":176829,"goal":"lemma Distrib_6830(j: nat, a: nat, n: nat)\n ensures j * (a + n) == j * a + j * n\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_6831","instance":6831,"id":176830,"goal":"lemma AddZero_6831(c: real)\n ensures c + 0 == c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_6832","instance":6832,"id":176831,"goal":"lemma MulOne_6832(c: int)\n ensures c * 1 == c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_6833","instance":6833,"id":176832,"goal":"lemma MulZero_6833(b: nat)\n ensures b * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_6834","instance":6834,"id":176833,"goal":"lemma LeRefl_6834(z: real)\n ensures z <= z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_6835","instance":6835,"id":176834,"goal":"lemma LeTrans_6835(a: int, x: int, m: int)\n requires a <= x && x <= m\n ensures a <= m\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_6836","instance":6836,"id":176835,"goal":"lemma AddMono_6836(m: nat, a: nat, y: nat)\n requires m <= a\n ensures m + y <= a + y\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_6837","instance":6837,"id":176836,"goal":"lemma Abs_Nonneg_6837(n: real)\n ensures (if n >= 0 then n else -n) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_6838","instance":6838,"id":176837,"goal":"lemma DivMod_6838(k: int, c: int)\n requires c > 0\n ensures k == c * (k / c) + (k % c)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_6839","instance":6839,"id":176838,"goal":"lemma ModBounds_6839(z: nat, i: nat)\n requires i > 0\n ensures 0 <= z % i < i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_6840","instance":6840,"id":176839,"goal":"lemma Square_Nonneg_6840(y: real)\n ensures y * y >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_6841","instance":6841,"id":176840,"goal":"lemma AddComm_6841(a: int, y: int)\n ensures a + y == y + a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_6842","instance":6842,"id":176841,"goal":"lemma AddAssoc_6842(j: nat, k: nat, x: nat)\n ensures (j + k) + x == j + (k + x)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_6843","instance":6843,"id":176842,"goal":"lemma MulComm_6843(n: real, k: real)\n ensures n * k == k * n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_6844","instance":6844,"id":176843,"goal":"lemma MulAssoc_6844(j: int, a: int, y: int)\n ensures (j * a) * y == j * (a * y)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_6845","instance":6845,"id":176844,"goal":"lemma Distrib_6845(k: nat, m: nat, b: nat)\n ensures k * (m + b) == k * m + k * b\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_6846","instance":6846,"id":176845,"goal":"lemma AddZero_6846(d: real)\n ensures d + 0 == d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_6847","instance":6847,"id":176846,"goal":"lemma MulOne_6847(j: int)\n ensures j * 1 == j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_6848","instance":6848,"id":176847,"goal":"lemma MulZero_6848(x: nat)\n ensures x * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_6849","instance":6849,"id":176848,"goal":"lemma LeRefl_6849(y: real)\n ensures y <= y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_6850","instance":6850,"id":176849,"goal":"lemma LeTrans_6850(k: int, c: int, x: int)\n requires k <= c && c <= x\n ensures k <= x\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_6851","instance":6851,"id":176850,"goal":"lemma AddMono_6851(n: nat, y: nat, b: nat)\n requires n <= y\n ensures n + b <= y + b\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_6852","instance":6852,"id":176851,"goal":"lemma Abs_Nonneg_6852(b: real)\n ensures (if b >= 0 then b else -b) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_6853","instance":6853,"id":176852,"goal":"lemma DivMod_6853(k: int, b: int)\n requires b > 0\n ensures k == b * (k / b) + (k % b)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_6854","instance":6854,"id":176853,"goal":"lemma ModBounds_6854(k: nat, j: nat)\n requires j > 0\n ensures 0 <= k % j < j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_6855","instance":6855,"id":176854,"goal":"lemma Square_Nonneg_6855(a: real)\n ensures a * a >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_6856","instance":6856,"id":176855,"goal":"lemma AddComm_6856(n: int, i: int)\n ensures n + i == i + n\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_6857","instance":6857,"id":176856,"goal":"lemma AddAssoc_6857(k: nat, b: nat, m: nat)\n ensures (k + b) + m == k + (b + m)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_6858","instance":6858,"id":176857,"goal":"lemma MulComm_6858(c: real, k: real)\n ensures c * k == k * c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_6859","instance":6859,"id":176858,"goal":"lemma MulAssoc_6859(k: int, n: int, a: int)\n ensures (k * n) * a == k * (n * a)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_6860","instance":6860,"id":176859,"goal":"lemma Distrib_6860(k: nat, z: nat, d: nat)\n ensures k * (z + d) == k * z + k * d\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_6861","instance":6861,"id":176860,"goal":"lemma AddZero_6861(c: real)\n ensures c + 0 == c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_6862","instance":6862,"id":176861,"goal":"lemma MulOne_6862(c: int)\n ensures c * 1 == c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_6863","instance":6863,"id":176862,"goal":"lemma MulZero_6863(m: nat)\n ensures m * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_6864","instance":6864,"id":176863,"goal":"lemma LeRefl_6864(y: real)\n ensures y <= y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_6865","instance":6865,"id":176864,"goal":"lemma LeTrans_6865(x: int, z: int, n: int)\n requires x <= z && z <= n\n ensures x <= n\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_6866","instance":6866,"id":176865,"goal":"lemma AddMono_6866(i: nat, m: nat, j: nat)\n requires i <= m\n ensures i + j <= m + j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_6867","instance":6867,"id":176866,"goal":"lemma Abs_Nonneg_6867(b: real)\n ensures (if b >= 0 then b else -b) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_6868","instance":6868,"id":176867,"goal":"lemma DivMod_6868(d: int, k: int)\n requires k > 0\n ensures d == k * (d / k) + (d % k)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_6869","instance":6869,"id":176868,"goal":"lemma ModBounds_6869(i: nat, c: nat)\n requires c > 0\n ensures 0 <= i % c < c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_6870","instance":6870,"id":176869,"goal":"lemma Square_Nonneg_6870(n: real)\n ensures n * n >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_6871","instance":6871,"id":176870,"goal":"lemma AddComm_6871(z: int, y: int)\n ensures z + y == y + z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_6872","instance":6872,"id":176871,"goal":"lemma AddAssoc_6872(z: nat, j: nat, n: nat)\n ensures (z + j) + n == z + (j + n)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_6873","instance":6873,"id":176872,"goal":"lemma MulComm_6873(i: real, j: real)\n ensures i * j == j * i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_6874","instance":6874,"id":176873,"goal":"lemma MulAssoc_6874(k: int, m: int, i: int)\n ensures (k * m) * i == k * (m * i)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_6875","instance":6875,"id":176874,"goal":"lemma Distrib_6875(c: nat, y: nat, b: nat)\n ensures c * (y + b) == c * y + c * b\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_6876","instance":6876,"id":176875,"goal":"lemma AddZero_6876(i: real)\n ensures i + 0 == i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_6877","instance":6877,"id":176876,"goal":"lemma MulOne_6877(j: int)\n ensures j * 1 == j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_6878","instance":6878,"id":176877,"goal":"lemma MulZero_6878(x: nat)\n ensures x * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_6879","instance":6879,"id":176878,"goal":"lemma LeRefl_6879(d: real)\n ensures d <= d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_6880","instance":6880,"id":176879,"goal":"lemma LeTrans_6880(n: int, b: int, i: int)\n requires n <= b && b <= i\n ensures n <= i\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_6881","instance":6881,"id":176880,"goal":"lemma AddMono_6881(b: nat, z: nat, i: nat)\n requires b <= z\n ensures b + i <= z + i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_6882","instance":6882,"id":176881,"goal":"lemma Abs_Nonneg_6882(x: real)\n ensures (if x >= 0 then x else -x) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_6883","instance":6883,"id":176882,"goal":"lemma DivMod_6883(x: int, d: int)\n requires d > 0\n ensures x == d * (x / d) + (x % d)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_6884","instance":6884,"id":176883,"goal":"lemma ModBounds_6884(x: nat, i: nat)\n requires i > 0\n ensures 0 <= x % i < i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_6885","instance":6885,"id":176884,"goal":"lemma Square_Nonneg_6885(n: real)\n ensures n * n >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_6886","instance":6886,"id":176885,"goal":"lemma AddComm_6886(x: int, j: int)\n ensures x + j == j + x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_6887","instance":6887,"id":176886,"goal":"lemma AddAssoc_6887(k: nat, c: nat, x: nat)\n ensures (k + c) + x == k + (c + x)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_6888","instance":6888,"id":176887,"goal":"lemma MulComm_6888(i: real, n: real)\n ensures i * n == n * i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_6889","instance":6889,"id":176888,"goal":"lemma MulAssoc_6889(n: int, i: int, b: int)\n ensures (n * i) * b == n * (i * b)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_6890","instance":6890,"id":176889,"goal":"lemma Distrib_6890(b: nat, i: nat, x: nat)\n ensures b * (i + x) == b * i + b * x\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_6891","instance":6891,"id":176890,"goal":"lemma AddZero_6891(y: real)\n ensures y + 0 == y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_6892","instance":6892,"id":176891,"goal":"lemma MulOne_6892(a: int)\n ensures a * 1 == a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_6893","instance":6893,"id":176892,"goal":"lemma MulZero_6893(d: nat)\n ensures d * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_6894","instance":6894,"id":176893,"goal":"lemma LeRefl_6894(x: real)\n ensures x <= x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_6895","instance":6895,"id":176894,"goal":"lemma LeTrans_6895(a: int, z: int, j: int)\n requires a <= z && z <= j\n ensures a <= j\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_6896","instance":6896,"id":176895,"goal":"lemma AddMono_6896(y: nat, b: nat, n: nat)\n requires y <= b\n ensures y + n <= b + n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_6897","instance":6897,"id":176896,"goal":"lemma Abs_Nonneg_6897(k: real)\n ensures (if k >= 0 then k else -k) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_6898","instance":6898,"id":176897,"goal":"lemma DivMod_6898(a: int, n: int)\n requires n > 0\n ensures a == n * (a / n) + (a % n)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_6899","instance":6899,"id":176898,"goal":"lemma ModBounds_6899(y: nat, n: nat)\n requires n > 0\n ensures 0 <= y % n < n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_6900","instance":6900,"id":176899,"goal":"lemma Square_Nonneg_6900(j: real)\n ensures j * j >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_6901","instance":6901,"id":176900,"goal":"lemma AddComm_6901(a: int, b: int)\n ensures a + b == b + a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_6902","instance":6902,"id":176901,"goal":"lemma AddAssoc_6902(z: nat, a: nat, b: nat)\n ensures (z + a) + b == z + (a + b)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_6903","instance":6903,"id":176902,"goal":"lemma MulComm_6903(y: real, j: real)\n ensures y * j == j * y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_6904","instance":6904,"id":176903,"goal":"lemma MulAssoc_6904(j: int, m: int, y: int)\n ensures (j * m) * y == j * (m * y)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_6905","instance":6905,"id":176904,"goal":"lemma Distrib_6905(k: nat, j: nat, d: nat)\n ensures k * (j + d) == k * j + k * d\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_6906","instance":6906,"id":176905,"goal":"lemma AddZero_6906(x: real)\n ensures x + 0 == x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_6907","instance":6907,"id":176906,"goal":"lemma MulOne_6907(y: int)\n ensures y * 1 == y\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_6908","instance":6908,"id":176907,"goal":"lemma MulZero_6908(y: nat)\n ensures y * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_6909","instance":6909,"id":176908,"goal":"lemma LeRefl_6909(c: real)\n ensures c <= c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_6910","instance":6910,"id":176909,"goal":"lemma LeTrans_6910(a: int, z: int, x: int)\n requires a <= z && z <= x\n ensures a <= x\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_6911","instance":6911,"id":176910,"goal":"lemma AddMono_6911(b: nat, a: nat, k: nat)\n requires b <= a\n ensures b + k <= a + k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_6912","instance":6912,"id":176911,"goal":"lemma Abs_Nonneg_6912(b: real)\n ensures (if b >= 0 then b else -b) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_6913","instance":6913,"id":176912,"goal":"lemma DivMod_6913(j: int, z: int)\n requires z > 0\n ensures j == z * (j / z) + (j % z)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_6914","instance":6914,"id":176913,"goal":"lemma ModBounds_6914(n: nat, d: nat)\n requires d > 0\n ensures 0 <= n % d < d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_6915","instance":6915,"id":176914,"goal":"lemma Square_Nonneg_6915(m: real)\n ensures m * m >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_6916","instance":6916,"id":176915,"goal":"lemma AddComm_6916(n: int, m: int)\n ensures n + m == m + n\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_6917","instance":6917,"id":176916,"goal":"lemma AddAssoc_6917(m: nat, n: nat, y: nat)\n ensures (m + n) + y == m + (n + y)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_6918","instance":6918,"id":176917,"goal":"lemma MulComm_6918(j: real, x: real)\n ensures j * x == x * j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_6919","instance":6919,"id":176918,"goal":"lemma MulAssoc_6919(n: int, k: int, d: int)\n ensures (n * k) * d == n * (k * d)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_6920","instance":6920,"id":176919,"goal":"lemma Distrib_6920(n: nat, z: nat, k: nat)\n ensures n * (z + k) == n * z + n * k\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_6921","instance":6921,"id":176920,"goal":"lemma AddZero_6921(j: real)\n ensures j + 0 == j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_6922","instance":6922,"id":176921,"goal":"lemma MulOne_6922(n: int)\n ensures n * 1 == n\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_6923","instance":6923,"id":176922,"goal":"lemma MulZero_6923(k: nat)\n ensures k * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_6924","instance":6924,"id":176923,"goal":"lemma LeRefl_6924(b: real)\n ensures b <= b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_6925","instance":6925,"id":176924,"goal":"lemma LeTrans_6925(i: int, c: int, b: int)\n requires i <= c && c <= b\n ensures i <= b\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_6926","instance":6926,"id":176925,"goal":"lemma AddMono_6926(y: nat, j: nat, z: nat)\n requires y <= j\n ensures y + z <= j + z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_6927","instance":6927,"id":176926,"goal":"lemma Abs_Nonneg_6927(i: real)\n ensures (if i >= 0 then i else -i) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_6928","instance":6928,"id":176927,"goal":"lemma DivMod_6928(k: int, i: int)\n requires i > 0\n ensures k == i * (k / i) + (k % i)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_6929","instance":6929,"id":176928,"goal":"lemma ModBounds_6929(i: nat, n: nat)\n requires n > 0\n ensures 0 <= i % n < n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_6930","instance":6930,"id":176929,"goal":"lemma Square_Nonneg_6930(y: real)\n ensures y * y >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_6931","instance":6931,"id":176930,"goal":"lemma AddComm_6931(n: int, y: int)\n ensures n + y == y + n\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_6932","instance":6932,"id":176931,"goal":"lemma AddAssoc_6932(m: nat, a: nat, y: nat)\n ensures (m + a) + y == m + (a + y)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_6933","instance":6933,"id":176932,"goal":"lemma MulComm_6933(x: real, j: real)\n ensures x * j == j * x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_6934","instance":6934,"id":176933,"goal":"lemma MulAssoc_6934(a: int, z: int, c: int)\n ensures (a * z) * c == a * (z * c)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_6935","instance":6935,"id":176934,"goal":"lemma Distrib_6935(n: nat, j: nat, c: nat)\n ensures n * (j + c) == n * j + n * c\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_6936","instance":6936,"id":176935,"goal":"lemma AddZero_6936(x: real)\n ensures x + 0 == x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_6937","instance":6937,"id":176936,"goal":"lemma MulOne_6937(d: int)\n ensures d * 1 == d\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_6938","instance":6938,"id":176937,"goal":"lemma MulZero_6938(n: nat)\n ensures n * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_6939","instance":6939,"id":176938,"goal":"lemma LeRefl_6939(j: real)\n ensures j <= j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_6940","instance":6940,"id":176939,"goal":"lemma LeTrans_6940(n: int, k: int, m: int)\n requires n <= k && k <= m\n ensures n <= m\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_6941","instance":6941,"id":176940,"goal":"lemma AddMono_6941(b: nat, y: nat, x: nat)\n requires b <= y\n ensures b + x <= y + x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_6942","instance":6942,"id":176941,"goal":"lemma Abs_Nonneg_6942(d: real)\n ensures (if d >= 0 then d else -d) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_6943","instance":6943,"id":176942,"goal":"lemma DivMod_6943(n: int, m: int)\n requires m > 0\n ensures n == m * (n / m) + (n % m)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_6944","instance":6944,"id":176943,"goal":"lemma ModBounds_6944(b: nat, d: nat)\n requires d > 0\n ensures 0 <= b % d < d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_6945","instance":6945,"id":176944,"goal":"lemma Square_Nonneg_6945(m: real)\n ensures m * m >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_6946","instance":6946,"id":176945,"goal":"lemma AddComm_6946(j: int, a: int)\n ensures j + a == a + j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_6947","instance":6947,"id":176946,"goal":"lemma AddAssoc_6947(n: nat, a: nat, j: nat)\n ensures (n + a) + j == n + (a + j)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_6948","instance":6948,"id":176947,"goal":"lemma MulComm_6948(i: real, n: real)\n ensures i * n == n * i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_6949","instance":6949,"id":176948,"goal":"lemma MulAssoc_6949(z: int, i: int, d: int)\n ensures (z * i) * d == z * (i * d)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_6950","instance":6950,"id":176949,"goal":"lemma Distrib_6950(a: nat, b: nat, j: nat)\n ensures a * (b + j) == a * b + a * j\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_6951","instance":6951,"id":176950,"goal":"lemma AddZero_6951(z: real)\n ensures z + 0 == z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_6952","instance":6952,"id":176951,"goal":"lemma MulOne_6952(a: int)\n ensures a * 1 == a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_6953","instance":6953,"id":176952,"goal":"lemma MulZero_6953(a: nat)\n ensures a * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_6954","instance":6954,"id":176953,"goal":"lemma LeRefl_6954(y: real)\n ensures y <= y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_6955","instance":6955,"id":176954,"goal":"lemma LeTrans_6955(m: int, z: int, y: int)\n requires m <= z && z <= y\n ensures m <= y\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_6956","instance":6956,"id":176955,"goal":"lemma AddMono_6956(i: nat, b: nat, x: nat)\n requires i <= b\n ensures i + x <= b + x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_6957","instance":6957,"id":176956,"goal":"lemma Abs_Nonneg_6957(m: real)\n ensures (if m >= 0 then m else -m) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_6958","instance":6958,"id":176957,"goal":"lemma DivMod_6958(i: int, x: int)\n requires x > 0\n ensures i == x * (i / x) + (i % x)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_6959","instance":6959,"id":176958,"goal":"lemma ModBounds_6959(a: nat, n: nat)\n requires n > 0\n ensures 0 <= a % n < n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_6960","instance":6960,"id":176959,"goal":"lemma Square_Nonneg_6960(b: real)\n ensures b * b >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_6961","instance":6961,"id":176960,"goal":"lemma AddComm_6961(z: int, m: int)\n ensures z + m == m + z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_6962","instance":6962,"id":176961,"goal":"lemma AddAssoc_6962(n: nat, x: nat, c: nat)\n ensures (n + x) + c == n + (x + c)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_6963","instance":6963,"id":176962,"goal":"lemma MulComm_6963(c: real, k: real)\n ensures c * k == k * c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_6964","instance":6964,"id":176963,"goal":"lemma MulAssoc_6964(z: int, m: int, y: int)\n ensures (z * m) * y == z * (m * y)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_6965","instance":6965,"id":176964,"goal":"lemma Distrib_6965(y: nat, k: nat, d: nat)\n ensures y * (k + d) == y * k + y * d\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_6966","instance":6966,"id":176965,"goal":"lemma AddZero_6966(n: real)\n ensures n + 0 == n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_6967","instance":6967,"id":176966,"goal":"lemma MulOne_6967(d: int)\n ensures d * 1 == d\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_6968","instance":6968,"id":176967,"goal":"lemma MulZero_6968(d: nat)\n ensures d * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_6969","instance":6969,"id":176968,"goal":"lemma LeRefl_6969(x: real)\n ensures x <= x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_6970","instance":6970,"id":176969,"goal":"lemma LeTrans_6970(a: int, i: int, y: int)\n requires a <= i && i <= y\n ensures a <= y\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_6971","instance":6971,"id":176970,"goal":"lemma AddMono_6971(y: nat, j: nat, d: nat)\n requires y <= j\n ensures y + d <= j + d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_6972","instance":6972,"id":176971,"goal":"lemma Abs_Nonneg_6972(a: real)\n ensures (if a >= 0 then a else -a) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_6973","instance":6973,"id":176972,"goal":"lemma DivMod_6973(m: int, i: int)\n requires i > 0\n ensures m == i * (m / i) + (m % i)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_6974","instance":6974,"id":176973,"goal":"lemma ModBounds_6974(y: nat, d: nat)\n requires d > 0\n ensures 0 <= y % d < d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_6975","instance":6975,"id":176974,"goal":"lemma Square_Nonneg_6975(b: real)\n ensures b * b >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_6976","instance":6976,"id":176975,"goal":"lemma AddComm_6976(z: int, m: int)\n ensures z + m == m + z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_6977","instance":6977,"id":176976,"goal":"lemma AddAssoc_6977(k: nat, x: nat, z: nat)\n ensures (k + x) + z == k + (x + z)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_6978","instance":6978,"id":176977,"goal":"lemma MulComm_6978(a: real, y: real)\n ensures a * y == y * a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_6979","instance":6979,"id":176978,"goal":"lemma MulAssoc_6979(j: int, x: int, c: int)\n ensures (j * x) * c == j * (x * c)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_6980","instance":6980,"id":176979,"goal":"lemma Distrib_6980(n: nat, j: nat, z: nat)\n ensures n * (j + z) == n * j + n * z\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_6981","instance":6981,"id":176980,"goal":"lemma AddZero_6981(a: real)\n ensures a + 0 == a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_6982","instance":6982,"id":176981,"goal":"lemma MulOne_6982(a: int)\n ensures a * 1 == a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_6983","instance":6983,"id":176982,"goal":"lemma MulZero_6983(c: nat)\n ensures c * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_6984","instance":6984,"id":176983,"goal":"lemma LeRefl_6984(y: real)\n ensures y <= y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_6985","instance":6985,"id":176984,"goal":"lemma LeTrans_6985(i: int, d: int, a: int)\n requires i <= d && d <= a\n ensures i <= a\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_6986","instance":6986,"id":176985,"goal":"lemma AddMono_6986(c: nat, k: nat, n: nat)\n requires c <= k\n ensures c + n <= k + n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_6987","instance":6987,"id":176986,"goal":"lemma Abs_Nonneg_6987(n: real)\n ensures (if n >= 0 then n else -n) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_6988","instance":6988,"id":176987,"goal":"lemma DivMod_6988(i: int, j: int)\n requires j > 0\n ensures i == j * (i / j) + (i % j)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_6989","instance":6989,"id":176988,"goal":"lemma ModBounds_6989(m: nat, n: nat)\n requires n > 0\n ensures 0 <= m % n < n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_6990","instance":6990,"id":176989,"goal":"lemma Square_Nonneg_6990(j: real)\n ensures j * j >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_6991","instance":6991,"id":176990,"goal":"lemma AddComm_6991(k: int, n: int)\n ensures k + n == n + k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_6992","instance":6992,"id":176991,"goal":"lemma AddAssoc_6992(b: nat, x: nat, a: nat)\n ensures (b + x) + a == b + (x + a)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_6993","instance":6993,"id":176992,"goal":"lemma MulComm_6993(m: real, a: real)\n ensures m * a == a * m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_6994","instance":6994,"id":176993,"goal":"lemma MulAssoc_6994(x: int, z: int, c: int)\n ensures (x * z) * c == x * (z * c)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_6995","instance":6995,"id":176994,"goal":"lemma Distrib_6995(k: nat, d: nat, b: nat)\n ensures k * (d + b) == k * d + k * b\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_6996","instance":6996,"id":176995,"goal":"lemma AddZero_6996(j: real)\n ensures j + 0 == j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_6997","instance":6997,"id":176996,"goal":"lemma MulOne_6997(m: int)\n ensures m * 1 == m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_6998","instance":6998,"id":176997,"goal":"lemma MulZero_6998(i: nat)\n ensures i * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_6999","instance":6999,"id":176998,"goal":"lemma LeRefl_6999(i: real)\n ensures i <= i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_7000","instance":7000,"id":176999,"goal":"lemma LeTrans_7000(i: int, y: int, x: int)\n requires i <= y && y <= x\n ensures i <= x\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_7001","instance":7001,"id":177000,"goal":"lemma AddMono_7001(i: nat, n: nat, y: nat)\n requires i <= n\n ensures i + y <= n + y\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_7002","instance":7002,"id":177001,"goal":"lemma Abs_Nonneg_7002(d: real)\n ensures (if d >= 0 then d else -d) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_7003","instance":7003,"id":177002,"goal":"lemma DivMod_7003(y: int, d: int)\n requires d > 0\n ensures y == d * (y / d) + (y % d)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_7004","instance":7004,"id":177003,"goal":"lemma ModBounds_7004(k: nat, a: nat)\n requires a > 0\n ensures 0 <= k % a < a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_7005","instance":7005,"id":177004,"goal":"lemma Square_Nonneg_7005(z: real)\n ensures z * z >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_7006","instance":7006,"id":177005,"goal":"lemma AddComm_7006(d: int, b: int)\n ensures d + b == b + d\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_7007","instance":7007,"id":177006,"goal":"lemma AddAssoc_7007(b: nat, y: nat, z: nat)\n ensures (b + y) + z == b + (y + z)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_7008","instance":7008,"id":177007,"goal":"lemma MulComm_7008(d: real, a: real)\n ensures d * a == a * d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_7009","instance":7009,"id":177008,"goal":"lemma MulAssoc_7009(b: int, j: int, z: int)\n ensures (b * j) * z == b * (j * z)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_7010","instance":7010,"id":177009,"goal":"lemma Distrib_7010(d: nat, x: nat, b: nat)\n ensures d * (x + b) == d * x + d * b\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_7011","instance":7011,"id":177010,"goal":"lemma AddZero_7011(y: real)\n ensures y + 0 == y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_7012","instance":7012,"id":177011,"goal":"lemma MulOne_7012(d: int)\n ensures d * 1 == d\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_7013","instance":7013,"id":177012,"goal":"lemma MulZero_7013(n: nat)\n ensures n * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_7014","instance":7014,"id":177013,"goal":"lemma LeRefl_7014(z: real)\n ensures z <= z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_7015","instance":7015,"id":177014,"goal":"lemma LeTrans_7015(k: int, b: int, x: int)\n requires k <= b && b <= x\n ensures k <= x\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_7016","instance":7016,"id":177015,"goal":"lemma AddMono_7016(k: nat, i: nat, x: nat)\n requires k <= i\n ensures k + x <= i + x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_7017","instance":7017,"id":177016,"goal":"lemma Abs_Nonneg_7017(k: real)\n ensures (if k >= 0 then k else -k) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_7018","instance":7018,"id":177017,"goal":"lemma DivMod_7018(b: int, j: int)\n requires j > 0\n ensures b == j * (b / j) + (b % j)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_7019","instance":7019,"id":177018,"goal":"lemma ModBounds_7019(c: nat, j: nat)\n requires j > 0\n ensures 0 <= c % j < j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_7020","instance":7020,"id":177019,"goal":"lemma Square_Nonneg_7020(i: real)\n ensures i * i >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_7021","instance":7021,"id":177020,"goal":"lemma AddComm_7021(j: int, a: int)\n ensures j + a == a + j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_7022","instance":7022,"id":177021,"goal":"lemma AddAssoc_7022(x: nat, c: nat, z: nat)\n ensures (x + c) + z == x + (c + z)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_7023","instance":7023,"id":177022,"goal":"lemma MulComm_7023(y: real, c: real)\n ensures y * c == c * y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_7024","instance":7024,"id":177023,"goal":"lemma MulAssoc_7024(x: int, b: int, m: int)\n ensures (x * b) * m == x * (b * m)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_7025","instance":7025,"id":177024,"goal":"lemma Distrib_7025(c: nat, j: nat, k: nat)\n ensures c * (j + k) == c * j + c * k\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_7026","instance":7026,"id":177025,"goal":"lemma AddZero_7026(a: real)\n ensures a + 0 == a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_7027","instance":7027,"id":177026,"goal":"lemma MulOne_7027(a: int)\n ensures a * 1 == a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_7028","instance":7028,"id":177027,"goal":"lemma MulZero_7028(j: nat)\n ensures j * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_7029","instance":7029,"id":177028,"goal":"lemma LeRefl_7029(j: real)\n ensures j <= j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_7030","instance":7030,"id":177029,"goal":"lemma LeTrans_7030(k: int, n: int, y: int)\n requires k <= n && n <= y\n ensures k <= y\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_7031","instance":7031,"id":177030,"goal":"lemma AddMono_7031(y: nat, x: nat, i: nat)\n requires y <= x\n ensures y + i <= x + i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_7032","instance":7032,"id":177031,"goal":"lemma Abs_Nonneg_7032(m: real)\n ensures (if m >= 0 then m else -m) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_7033","instance":7033,"id":177032,"goal":"lemma DivMod_7033(c: int, y: int)\n requires y > 0\n ensures c == y * (c / y) + (c % y)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_7034","instance":7034,"id":177033,"goal":"lemma ModBounds_7034(d: nat, b: nat)\n requires b > 0\n ensures 0 <= d % b < b\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_7035","instance":7035,"id":177034,"goal":"lemma Square_Nonneg_7035(n: real)\n ensures n * n >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_7036","instance":7036,"id":177035,"goal":"lemma AddComm_7036(n: int, b: int)\n ensures n + b == b + n\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_7037","instance":7037,"id":177036,"goal":"lemma AddAssoc_7037(m: nat, z: nat, i: nat)\n ensures (m + z) + i == m + (z + i)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_7038","instance":7038,"id":177037,"goal":"lemma MulComm_7038(m: real, c: real)\n ensures m * c == c * m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_7039","instance":7039,"id":177038,"goal":"lemma MulAssoc_7039(y: int, b: int, k: int)\n ensures (y * b) * k == y * (b * k)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_7040","instance":7040,"id":177039,"goal":"lemma Distrib_7040(m: nat, a: nat, k: nat)\n ensures m * (a + k) == m * a + m * k\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_7041","instance":7041,"id":177040,"goal":"lemma AddZero_7041(m: real)\n ensures m + 0 == m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_7042","instance":7042,"id":177041,"goal":"lemma MulOne_7042(c: int)\n ensures c * 1 == c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_7043","instance":7043,"id":177042,"goal":"lemma MulZero_7043(x: nat)\n ensures x * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_7044","instance":7044,"id":177043,"goal":"lemma LeRefl_7044(i: real)\n ensures i <= i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_7045","instance":7045,"id":177044,"goal":"lemma LeTrans_7045(i: int, j: int, d: int)\n requires i <= j && j <= d\n ensures i <= d\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_7046","instance":7046,"id":177045,"goal":"lemma AddMono_7046(a: nat, n: nat, j: nat)\n requires a <= n\n ensures a + j <= n + j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_7047","instance":7047,"id":177046,"goal":"lemma Abs_Nonneg_7047(c: real)\n ensures (if c >= 0 then c else -c) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_7048","instance":7048,"id":177047,"goal":"lemma DivMod_7048(k: int, x: int)\n requires x > 0\n ensures k == x * (k / x) + (k % x)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_7049","instance":7049,"id":177048,"goal":"lemma ModBounds_7049(z: nat, m: nat)\n requires m > 0\n ensures 0 <= z % m < m\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_7050","instance":7050,"id":177049,"goal":"lemma Square_Nonneg_7050(x: real)\n ensures x * x >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_7051","instance":7051,"id":177050,"goal":"lemma AddComm_7051(d: int, c: int)\n ensures d + c == c + d\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_7052","instance":7052,"id":177051,"goal":"lemma AddAssoc_7052(y: nat, k: nat, x: nat)\n ensures (y + k) + x == y + (k + x)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_7053","instance":7053,"id":177052,"goal":"lemma MulComm_7053(y: real, x: real)\n ensures y * x == x * y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_7054","instance":7054,"id":177053,"goal":"lemma MulAssoc_7054(n: int, x: int, y: int)\n ensures (n * x) * y == n * (x * y)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_7055","instance":7055,"id":177054,"goal":"lemma Distrib_7055(a: nat, y: nat, m: nat)\n ensures a * (y + m) == a * y + a * m\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_7056","instance":7056,"id":177055,"goal":"lemma AddZero_7056(a: real)\n ensures a + 0 == a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_7057","instance":7057,"id":177056,"goal":"lemma MulOne_7057(a: int)\n ensures a * 1 == a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_7058","instance":7058,"id":177057,"goal":"lemma MulZero_7058(d: nat)\n ensures d * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_7059","instance":7059,"id":177058,"goal":"lemma LeRefl_7059(x: real)\n ensures x <= x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_7060","instance":7060,"id":177059,"goal":"lemma LeTrans_7060(x: int, c: int, m: int)\n requires x <= c && c <= m\n ensures x <= m\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_7061","instance":7061,"id":177060,"goal":"lemma AddMono_7061(y: nat, d: nat, k: nat)\n requires y <= d\n ensures y + k <= d + k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_7062","instance":7062,"id":177061,"goal":"lemma Abs_Nonneg_7062(z: real)\n ensures (if z >= 0 then z else -z) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_7063","instance":7063,"id":177062,"goal":"lemma DivMod_7063(d: int, y: int)\n requires y > 0\n ensures d == y * (d / y) + (d % y)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_7064","instance":7064,"id":177063,"goal":"lemma ModBounds_7064(m: nat, d: nat)\n requires d > 0\n ensures 0 <= m % d < d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_7065","instance":7065,"id":177064,"goal":"lemma Square_Nonneg_7065(a: real)\n ensures a * a >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_7066","instance":7066,"id":177065,"goal":"lemma AddComm_7066(j: int, k: int)\n ensures j + k == k + j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_7067","instance":7067,"id":177066,"goal":"lemma AddAssoc_7067(k: nat, y: nat, m: nat)\n ensures (k + y) + m == k + (y + m)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_7068","instance":7068,"id":177067,"goal":"lemma MulComm_7068(m: real, b: real)\n ensures m * b == b * m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_7069","instance":7069,"id":177068,"goal":"lemma MulAssoc_7069(i: int, z: int, b: int)\n ensures (i * z) * b == i * (z * b)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_7070","instance":7070,"id":177069,"goal":"lemma Distrib_7070(k: nat, i: nat, y: nat)\n ensures k * (i + y) == k * i + k * y\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_7071","instance":7071,"id":177070,"goal":"lemma AddZero_7071(k: real)\n ensures k + 0 == k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_7072","instance":7072,"id":177071,"goal":"lemma MulOne_7072(x: int)\n ensures x * 1 == x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_7073","instance":7073,"id":177072,"goal":"lemma MulZero_7073(k: nat)\n ensures k * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_7074","instance":7074,"id":177073,"goal":"lemma LeRefl_7074(k: real)\n ensures k <= k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_7075","instance":7075,"id":177074,"goal":"lemma LeTrans_7075(k: int, z: int, n: int)\n requires k <= z && z <= n\n ensures k <= n\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_7076","instance":7076,"id":177075,"goal":"lemma AddMono_7076(n: nat, b: nat, y: nat)\n requires n <= b\n ensures n + y <= b + y\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_7077","instance":7077,"id":177076,"goal":"lemma Abs_Nonneg_7077(b: real)\n ensures (if b >= 0 then b else -b) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_7078","instance":7078,"id":177077,"goal":"lemma DivMod_7078(i: int, d: int)\n requires d > 0\n ensures i == d * (i / d) + (i % d)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_7079","instance":7079,"id":177078,"goal":"lemma ModBounds_7079(z: nat, n: nat)\n requires n > 0\n ensures 0 <= z % n < n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_7080","instance":7080,"id":177079,"goal":"lemma Square_Nonneg_7080(a: real)\n ensures a * a >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_7081","instance":7081,"id":177080,"goal":"lemma AddComm_7081(x: int, i: int)\n ensures x + i == i + x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_7082","instance":7082,"id":177081,"goal":"lemma AddAssoc_7082(i: nat, d: nat, a: nat)\n ensures (i + d) + a == i + (d + a)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_7083","instance":7083,"id":177082,"goal":"lemma MulComm_7083(d: real, m: real)\n ensures d * m == m * d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_7084","instance":7084,"id":177083,"goal":"lemma MulAssoc_7084(x: int, a: int, i: int)\n ensures (x * a) * i == x * (a * i)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_7085","instance":7085,"id":177084,"goal":"lemma Distrib_7085(k: nat, y: nat, d: nat)\n ensures k * (y + d) == k * y + k * d\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_7086","instance":7086,"id":177085,"goal":"lemma AddZero_7086(k: real)\n ensures k + 0 == k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_7087","instance":7087,"id":177086,"goal":"lemma MulOne_7087(a: int)\n ensures a * 1 == a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_7088","instance":7088,"id":177087,"goal":"lemma MulZero_7088(z: nat)\n ensures z * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_7089","instance":7089,"id":177088,"goal":"lemma LeRefl_7089(j: real)\n ensures j <= j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_7090","instance":7090,"id":177089,"goal":"lemma LeTrans_7090(j: int, k: int, c: int)\n requires j <= k && k <= c\n ensures j <= c\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_7091","instance":7091,"id":177090,"goal":"lemma AddMono_7091(n: nat, k: nat, m: nat)\n requires n <= k\n ensures n + m <= k + m\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_7092","instance":7092,"id":177091,"goal":"lemma Abs_Nonneg_7092(k: real)\n ensures (if k >= 0 then k else -k) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_7093","instance":7093,"id":177092,"goal":"lemma DivMod_7093(z: int, k: int)\n requires k > 0\n ensures z == k * (z / k) + (z % k)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_7094","instance":7094,"id":177093,"goal":"lemma ModBounds_7094(k: nat, m: nat)\n requires m > 0\n ensures 0 <= k % m < m\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_7095","instance":7095,"id":177094,"goal":"lemma Square_Nonneg_7095(k: real)\n ensures k * k >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_7096","instance":7096,"id":177095,"goal":"lemma AddComm_7096(j: int, d: int)\n ensures j + d == d + j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_7097","instance":7097,"id":177096,"goal":"lemma AddAssoc_7097(j: nat, b: nat, m: nat)\n ensures (j + b) + m == j + (b + m)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_7098","instance":7098,"id":177097,"goal":"lemma MulComm_7098(x: real, z: real)\n ensures x * z == z * x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_7099","instance":7099,"id":177098,"goal":"lemma MulAssoc_7099(i: int, c: int, x: int)\n ensures (i * c) * x == i * (c * x)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_7100","instance":7100,"id":177099,"goal":"lemma Distrib_7100(m: nat, k: nat, n: nat)\n ensures m * (k + n) == m * k + m * n\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_7101","instance":7101,"id":177100,"goal":"lemma AddZero_7101(y: real)\n ensures y + 0 == y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_7102","instance":7102,"id":177101,"goal":"lemma MulOne_7102(j: int)\n ensures j * 1 == j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_7103","instance":7103,"id":177102,"goal":"lemma MulZero_7103(m: nat)\n ensures m * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_7104","instance":7104,"id":177103,"goal":"lemma LeRefl_7104(c: real)\n ensures c <= c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_7105","instance":7105,"id":177104,"goal":"lemma LeTrans_7105(d: int, z: int, x: int)\n requires d <= z && z <= x\n ensures d <= x\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_7106","instance":7106,"id":177105,"goal":"lemma AddMono_7106(z: nat, k: nat, j: nat)\n requires z <= k\n ensures z + j <= k + j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_7107","instance":7107,"id":177106,"goal":"lemma Abs_Nonneg_7107(i: real)\n ensures (if i >= 0 then i else -i) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_7108","instance":7108,"id":177107,"goal":"lemma DivMod_7108(z: int, a: int)\n requires a > 0\n ensures z == a * (z / a) + (z % a)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_7109","instance":7109,"id":177108,"goal":"lemma ModBounds_7109(z: nat, c: nat)\n requires c > 0\n ensures 0 <= z % c < c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_7110","instance":7110,"id":177109,"goal":"lemma Square_Nonneg_7110(y: real)\n ensures y * y >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_7111","instance":7111,"id":177110,"goal":"lemma AddComm_7111(b: int, n: int)\n ensures b + n == n + b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_7112","instance":7112,"id":177111,"goal":"lemma AddAssoc_7112(d: nat, i: nat, j: nat)\n ensures (d + i) + j == d + (i + j)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_7113","instance":7113,"id":177112,"goal":"lemma MulComm_7113(d: real, y: real)\n ensures d * y == y * d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_7114","instance":7114,"id":177113,"goal":"lemma MulAssoc_7114(k: int, b: int, y: int)\n ensures (k * b) * y == k * (b * y)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_7115","instance":7115,"id":177114,"goal":"lemma Distrib_7115(j: nat, b: nat, y: nat)\n ensures j * (b + y) == j * b + j * y\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_7116","instance":7116,"id":177115,"goal":"lemma AddZero_7116(a: real)\n ensures a + 0 == a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_7117","instance":7117,"id":177116,"goal":"lemma MulOne_7117(x: int)\n ensures x * 1 == x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_7118","instance":7118,"id":177117,"goal":"lemma MulZero_7118(n: nat)\n ensures n * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_7119","instance":7119,"id":177118,"goal":"lemma LeRefl_7119(z: real)\n ensures z <= z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_7120","instance":7120,"id":177119,"goal":"lemma LeTrans_7120(y: int, z: int, c: int)\n requires y <= z && z <= c\n ensures y <= c\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_7121","instance":7121,"id":177120,"goal":"lemma AddMono_7121(n: nat, x: nat, i: nat)\n requires n <= x\n ensures n + i <= x + i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_7122","instance":7122,"id":177121,"goal":"lemma Abs_Nonneg_7122(d: real)\n ensures (if d >= 0 then d else -d) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_7123","instance":7123,"id":177122,"goal":"lemma DivMod_7123(m: int, j: int)\n requires j > 0\n ensures m == j * (m / j) + (m % j)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_7124","instance":7124,"id":177123,"goal":"lemma ModBounds_7124(k: nat, i: nat)\n requires i > 0\n ensures 0 <= k % i < i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_7125","instance":7125,"id":177124,"goal":"lemma Square_Nonneg_7125(d: real)\n ensures d * d >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_7126","instance":7126,"id":177125,"goal":"lemma AddComm_7126(n: int, x: int)\n ensures n + x == x + n\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_7127","instance":7127,"id":177126,"goal":"lemma AddAssoc_7127(c: nat, i: nat, d: nat)\n ensures (c + i) + d == c + (i + d)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_7128","instance":7128,"id":177127,"goal":"lemma MulComm_7128(y: real, m: real)\n ensures y * m == m * y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_7129","instance":7129,"id":177128,"goal":"lemma MulAssoc_7129(k: int, z: int, y: int)\n ensures (k * z) * y == k * (z * y)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_7130","instance":7130,"id":177129,"goal":"lemma Distrib_7130(a: nat, z: nat, x: nat)\n ensures a * (z + x) == a * z + a * x\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_7131","instance":7131,"id":177130,"goal":"lemma AddZero_7131(a: real)\n ensures a + 0 == a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_7132","instance":7132,"id":177131,"goal":"lemma MulOne_7132(m: int)\n ensures m * 1 == m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_7133","instance":7133,"id":177132,"goal":"lemma MulZero_7133(c: nat)\n ensures c * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_7134","instance":7134,"id":177133,"goal":"lemma LeRefl_7134(m: real)\n ensures m <= m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_7135","instance":7135,"id":177134,"goal":"lemma LeTrans_7135(z: int, i: int, y: int)\n requires z <= i && i <= y\n ensures z <= y\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_7136","instance":7136,"id":177135,"goal":"lemma AddMono_7136(n: nat, m: nat, x: nat)\n requires n <= m\n ensures n + x <= m + x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_7137","instance":7137,"id":177136,"goal":"lemma Abs_Nonneg_7137(d: real)\n ensures (if d >= 0 then d else -d) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_7138","instance":7138,"id":177137,"goal":"lemma DivMod_7138(b: int, z: int)\n requires z > 0\n ensures b == z * (b / z) + (b % z)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_7139","instance":7139,"id":177138,"goal":"lemma ModBounds_7139(d: nat, b: nat)\n requires b > 0\n ensures 0 <= d % b < b\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_7140","instance":7140,"id":177139,"goal":"lemma Square_Nonneg_7140(n: real)\n ensures n * n >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_7141","instance":7141,"id":177140,"goal":"lemma AddComm_7141(j: int, d: int)\n ensures j + d == d + j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_7142","instance":7142,"id":177141,"goal":"lemma AddAssoc_7142(k: nat, b: nat, m: nat)\n ensures (k + b) + m == k + (b + m)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_7143","instance":7143,"id":177142,"goal":"lemma MulComm_7143(m: real, z: real)\n ensures m * z == z * m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_7144","instance":7144,"id":177143,"goal":"lemma MulAssoc_7144(b: int, z: int, n: int)\n ensures (b * z) * n == b * (z * n)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_7145","instance":7145,"id":177144,"goal":"lemma Distrib_7145(a: nat, j: nat, b: nat)\n ensures a * (j + b) == a * j + a * b\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_7146","instance":7146,"id":177145,"goal":"lemma AddZero_7146(y: real)\n ensures y + 0 == y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_7147","instance":7147,"id":177146,"goal":"lemma MulOne_7147(x: int)\n ensures x * 1 == x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_7148","instance":7148,"id":177147,"goal":"lemma MulZero_7148(z: nat)\n ensures z * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_7149","instance":7149,"id":177148,"goal":"lemma LeRefl_7149(n: real)\n ensures n <= n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_7150","instance":7150,"id":177149,"goal":"lemma LeTrans_7150(j: int, i: int, k: int)\n requires j <= i && i <= k\n ensures j <= k\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_7151","instance":7151,"id":177150,"goal":"lemma AddMono_7151(b: nat, m: nat, a: nat)\n requires b <= m\n ensures b + a <= m + a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_7152","instance":7152,"id":177151,"goal":"lemma Abs_Nonneg_7152(i: real)\n ensures (if i >= 0 then i else -i) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_7153","instance":7153,"id":177152,"goal":"lemma DivMod_7153(d: int, j: int)\n requires j > 0\n ensures d == j * (d / j) + (d % j)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_7154","instance":7154,"id":177153,"goal":"lemma ModBounds_7154(b: nat, d: nat)\n requires d > 0\n ensures 0 <= b % d < d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_7155","instance":7155,"id":177154,"goal":"lemma Square_Nonneg_7155(b: real)\n ensures b * b >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_7156","instance":7156,"id":177155,"goal":"lemma AddComm_7156(i: int, a: int)\n ensures i + a == a + i\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_7157","instance":7157,"id":177156,"goal":"lemma AddAssoc_7157(d: nat, k: nat, y: nat)\n ensures (d + k) + y == d + (k + y)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_7158","instance":7158,"id":177157,"goal":"lemma MulComm_7158(k: real, x: real)\n ensures k * x == x * k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_7159","instance":7159,"id":177158,"goal":"lemma MulAssoc_7159(c: int, b: int, n: int)\n ensures (c * b) * n == c * (b * n)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_7160","instance":7160,"id":177159,"goal":"lemma Distrib_7160(d: nat, a: nat, m: nat)\n ensures d * (a + m) == d * a + d * m\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_7161","instance":7161,"id":177160,"goal":"lemma AddZero_7161(k: real)\n ensures k + 0 == k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_7162","instance":7162,"id":177161,"goal":"lemma MulOne_7162(d: int)\n ensures d * 1 == d\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_7163","instance":7163,"id":177162,"goal":"lemma MulZero_7163(i: nat)\n ensures i * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_7164","instance":7164,"id":177163,"goal":"lemma LeRefl_7164(m: real)\n ensures m <= m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_7165","instance":7165,"id":177164,"goal":"lemma LeTrans_7165(c: int, a: int, x: int)\n requires c <= a && a <= x\n ensures c <= x\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_7166","instance":7166,"id":177165,"goal":"lemma AddMono_7166(k: nat, n: nat, d: nat)\n requires k <= n\n ensures k + d <= n + d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_7167","instance":7167,"id":177166,"goal":"lemma Abs_Nonneg_7167(n: real)\n ensures (if n >= 0 then n else -n) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_7168","instance":7168,"id":177167,"goal":"lemma DivMod_7168(d: int, k: int)\n requires k > 0\n ensures d == k * (d / k) + (d % k)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_7169","instance":7169,"id":177168,"goal":"lemma ModBounds_7169(y: nat, c: nat)\n requires c > 0\n ensures 0 <= y % c < c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_7170","instance":7170,"id":177169,"goal":"lemma Square_Nonneg_7170(y: real)\n ensures y * y >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_7171","instance":7171,"id":177170,"goal":"lemma AddComm_7171(j: int, m: int)\n ensures j + m == m + j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_7172","instance":7172,"id":177171,"goal":"lemma AddAssoc_7172(a: nat, m: nat, c: nat)\n ensures (a + m) + c == a + (m + c)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_7173","instance":7173,"id":177172,"goal":"lemma MulComm_7173(c: real, n: real)\n ensures c * n == n * c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_7174","instance":7174,"id":177173,"goal":"lemma MulAssoc_7174(d: int, b: int, j: int)\n ensures (d * b) * j == d * (b * j)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_7175","instance":7175,"id":177174,"goal":"lemma Distrib_7175(k: nat, b: nat, y: nat)\n ensures k * (b + y) == k * b + k * y\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_7176","instance":7176,"id":177175,"goal":"lemma AddZero_7176(i: real)\n ensures i + 0 == i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_7177","instance":7177,"id":177176,"goal":"lemma MulOne_7177(m: int)\n ensures m * 1 == m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_7178","instance":7178,"id":177177,"goal":"lemma MulZero_7178(b: nat)\n ensures b * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_7179","instance":7179,"id":177178,"goal":"lemma LeRefl_7179(m: real)\n ensures m <= m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_7180","instance":7180,"id":177179,"goal":"lemma LeTrans_7180(m: int, a: int, b: int)\n requires m <= a && a <= b\n ensures m <= b\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_7181","instance":7181,"id":177180,"goal":"lemma AddMono_7181(m: nat, b: nat, d: nat)\n requires m <= b\n ensures m + d <= b + d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_7182","instance":7182,"id":177181,"goal":"lemma Abs_Nonneg_7182(n: real)\n ensures (if n >= 0 then n else -n) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_7183","instance":7183,"id":177182,"goal":"lemma DivMod_7183(a: int, y: int)\n requires y > 0\n ensures a == y * (a / y) + (a % y)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_7184","instance":7184,"id":177183,"goal":"lemma ModBounds_7184(b: nat, y: nat)\n requires y > 0\n ensures 0 <= b % y < y\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_7185","instance":7185,"id":177184,"goal":"lemma Square_Nonneg_7185(n: real)\n ensures n * n >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_7186","instance":7186,"id":177185,"goal":"lemma AddComm_7186(d: int, y: int)\n ensures d + y == y + d\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_7187","instance":7187,"id":177186,"goal":"lemma AddAssoc_7187(z: nat, j: nat, b: nat)\n ensures (z + j) + b == z + (j + b)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_7188","instance":7188,"id":177187,"goal":"lemma MulComm_7188(y: real, k: real)\n ensures y * k == k * y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_7189","instance":7189,"id":177188,"goal":"lemma MulAssoc_7189(m: int, a: int, x: int)\n ensures (m * a) * x == m * (a * x)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_7190","instance":7190,"id":177189,"goal":"lemma Distrib_7190(m: nat, z: nat, x: nat)\n ensures m * (z + x) == m * z + m * x\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_7191","instance":7191,"id":177190,"goal":"lemma AddZero_7191(c: real)\n ensures c + 0 == c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_7192","instance":7192,"id":177191,"goal":"lemma MulOne_7192(b: int)\n ensures b * 1 == b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_7193","instance":7193,"id":177192,"goal":"lemma MulZero_7193(z: nat)\n ensures z * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_7194","instance":7194,"id":177193,"goal":"lemma LeRefl_7194(x: real)\n ensures x <= x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_7195","instance":7195,"id":177194,"goal":"lemma LeTrans_7195(c: int, z: int, k: int)\n requires c <= z && z <= k\n ensures c <= k\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_7196","instance":7196,"id":177195,"goal":"lemma AddMono_7196(z: nat, x: nat, i: nat)\n requires z <= x\n ensures z + i <= x + i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_7197","instance":7197,"id":177196,"goal":"lemma Abs_Nonneg_7197(b: real)\n ensures (if b >= 0 then b else -b) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_7198","instance":7198,"id":177197,"goal":"lemma DivMod_7198(d: int, j: int)\n requires j > 0\n ensures d == j * (d / j) + (d % j)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_7199","instance":7199,"id":177198,"goal":"lemma ModBounds_7199(i: nat, d: nat)\n requires d > 0\n ensures 0 <= i % d < d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_7200","instance":7200,"id":177199,"goal":"lemma Square_Nonneg_7200(y: real)\n ensures y * y >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_7201","instance":7201,"id":177200,"goal":"lemma AddComm_7201(i: int, y: int)\n ensures i + y == y + i\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_7202","instance":7202,"id":177201,"goal":"lemma AddAssoc_7202(z: nat, d: nat, i: nat)\n ensures (z + d) + i == z + (d + i)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_7203","instance":7203,"id":177202,"goal":"lemma MulComm_7203(b: real, d: real)\n ensures b * d == d * b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_7204","instance":7204,"id":177203,"goal":"lemma MulAssoc_7204(b: int, a: int, d: int)\n ensures (b * a) * d == b * (a * d)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_7205","instance":7205,"id":177204,"goal":"lemma Distrib_7205(b: nat, d: nat, z: nat)\n ensures b * (d + z) == b * d + b * z\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_7206","instance":7206,"id":177205,"goal":"lemma AddZero_7206(n: real)\n ensures n + 0 == n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_7207","instance":7207,"id":177206,"goal":"lemma MulOne_7207(a: int)\n ensures a * 1 == a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_7208","instance":7208,"id":177207,"goal":"lemma MulZero_7208(m: nat)\n ensures m * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_7209","instance":7209,"id":177208,"goal":"lemma LeRefl_7209(k: real)\n ensures k <= k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_7210","instance":7210,"id":177209,"goal":"lemma LeTrans_7210(i: int, d: int, y: int)\n requires i <= d && d <= y\n ensures i <= y\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_7211","instance":7211,"id":177210,"goal":"lemma AddMono_7211(j: nat, a: nat, d: nat)\n requires j <= a\n ensures j + d <= a + d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_7212","instance":7212,"id":177211,"goal":"lemma Abs_Nonneg_7212(d: real)\n ensures (if d >= 0 then d else -d) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_7213","instance":7213,"id":177212,"goal":"lemma DivMod_7213(d: int, x: int)\n requires x > 0\n ensures d == x * (d / x) + (d % x)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_7214","instance":7214,"id":177213,"goal":"lemma ModBounds_7214(j: nat, d: nat)\n requires d > 0\n ensures 0 <= j % d < d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_7215","instance":7215,"id":177214,"goal":"lemma Square_Nonneg_7215(j: real)\n ensures j * j >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_7216","instance":7216,"id":177215,"goal":"lemma AddComm_7216(m: int, x: int)\n ensures m + x == x + m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_7217","instance":7217,"id":177216,"goal":"lemma AddAssoc_7217(z: nat, n: nat, b: nat)\n ensures (z + n) + b == z + (n + b)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_7218","instance":7218,"id":177217,"goal":"lemma MulComm_7218(y: real, i: real)\n ensures y * i == i * y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_7219","instance":7219,"id":177218,"goal":"lemma MulAssoc_7219(i: int, d: int, n: int)\n ensures (i * d) * n == i * (d * n)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_7220","instance":7220,"id":177219,"goal":"lemma Distrib_7220(d: nat, i: nat, n: nat)\n ensures d * (i + n) == d * i + d * n\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_7221","instance":7221,"id":177220,"goal":"lemma AddZero_7221(n: real)\n ensures n + 0 == n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_7222","instance":7222,"id":177221,"goal":"lemma MulOne_7222(m: int)\n ensures m * 1 == m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_7223","instance":7223,"id":177222,"goal":"lemma MulZero_7223(k: nat)\n ensures k * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_7224","instance":7224,"id":177223,"goal":"lemma LeRefl_7224(d: real)\n ensures d <= d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_7225","instance":7225,"id":177224,"goal":"lemma LeTrans_7225(b: int, m: int, i: int)\n requires b <= m && m <= i\n ensures b <= i\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_7226","instance":7226,"id":177225,"goal":"lemma AddMono_7226(x: nat, i: nat, y: nat)\n requires x <= i\n ensures x + y <= i + y\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_7227","instance":7227,"id":177226,"goal":"lemma Abs_Nonneg_7227(m: real)\n ensures (if m >= 0 then m else -m) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_7228","instance":7228,"id":177227,"goal":"lemma DivMod_7228(y: int, n: int)\n requires n > 0\n ensures y == n * (y / n) + (y % n)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_7229","instance":7229,"id":177228,"goal":"lemma ModBounds_7229(b: nat, z: nat)\n requires z > 0\n ensures 0 <= b % z < z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_7230","instance":7230,"id":177229,"goal":"lemma Square_Nonneg_7230(c: real)\n ensures c * c >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_7231","instance":7231,"id":177230,"goal":"lemma AddComm_7231(z: int, x: int)\n ensures z + x == x + z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_7232","instance":7232,"id":177231,"goal":"lemma AddAssoc_7232(k: nat, a: nat, z: nat)\n ensures (k + a) + z == k + (a + z)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_7233","instance":7233,"id":177232,"goal":"lemma MulComm_7233(i: real, d: real)\n ensures i * d == d * i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_7234","instance":7234,"id":177233,"goal":"lemma MulAssoc_7234(k: int, n: int, d: int)\n ensures (k * n) * d == k * (n * d)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_7235","instance":7235,"id":177234,"goal":"lemma Distrib_7235(y: nat, b: nat, a: nat)\n ensures y * (b + a) == y * b + y * a\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_7236","instance":7236,"id":177235,"goal":"lemma AddZero_7236(k: real)\n ensures k + 0 == k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_7237","instance":7237,"id":177236,"goal":"lemma MulOne_7237(z: int)\n ensures z * 1 == z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_7238","instance":7238,"id":177237,"goal":"lemma MulZero_7238(k: nat)\n ensures k * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_7239","instance":7239,"id":177238,"goal":"lemma LeRefl_7239(x: real)\n ensures x <= x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_7240","instance":7240,"id":177239,"goal":"lemma LeTrans_7240(c: int, m: int, k: int)\n requires c <= m && m <= k\n ensures c <= k\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_7241","instance":7241,"id":177240,"goal":"lemma AddMono_7241(n: nat, x: nat, k: nat)\n requires n <= x\n ensures n + k <= x + k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_7242","instance":7242,"id":177241,"goal":"lemma Abs_Nonneg_7242(x: real)\n ensures (if x >= 0 then x else -x) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_7243","instance":7243,"id":177242,"goal":"lemma DivMod_7243(c: int, x: int)\n requires x > 0\n ensures c == x * (c / x) + (c % x)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_7244","instance":7244,"id":177243,"goal":"lemma ModBounds_7244(c: nat, j: nat)\n requires j > 0\n ensures 0 <= c % j < j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_7245","instance":7245,"id":177244,"goal":"lemma Square_Nonneg_7245(i: real)\n ensures i * i >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_7246","instance":7246,"id":177245,"goal":"lemma AddComm_7246(n: int, b: int)\n ensures n + b == b + n\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_7247","instance":7247,"id":177246,"goal":"lemma AddAssoc_7247(b: nat, y: nat, d: nat)\n ensures (b + y) + d == b + (y + d)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_7248","instance":7248,"id":177247,"goal":"lemma MulComm_7248(b: real, n: real)\n ensures b * n == n * b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_7249","instance":7249,"id":177248,"goal":"lemma MulAssoc_7249(n: int, i: int, d: int)\n ensures (n * i) * d == n * (i * d)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_7250","instance":7250,"id":177249,"goal":"lemma Distrib_7250(b: nat, k: nat, c: nat)\n ensures b * (k + c) == b * k + b * c\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_7251","instance":7251,"id":177250,"goal":"lemma AddZero_7251(y: real)\n ensures y + 0 == y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_7252","instance":7252,"id":177251,"goal":"lemma MulOne_7252(n: int)\n ensures n * 1 == n\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_7253","instance":7253,"id":177252,"goal":"lemma MulZero_7253(i: nat)\n ensures i * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_7254","instance":7254,"id":177253,"goal":"lemma LeRefl_7254(k: real)\n ensures k <= k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_7255","instance":7255,"id":177254,"goal":"lemma LeTrans_7255(b: int, j: int, y: int)\n requires b <= j && j <= y\n ensures b <= y\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_7256","instance":7256,"id":177255,"goal":"lemma AddMono_7256(b: nat, d: nat, a: nat)\n requires b <= d\n ensures b + a <= d + a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_7257","instance":7257,"id":177256,"goal":"lemma Abs_Nonneg_7257(c: real)\n ensures (if c >= 0 then c else -c) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_7258","instance":7258,"id":177257,"goal":"lemma DivMod_7258(i: int, c: int)\n requires c > 0\n ensures i == c * (i / c) + (i % c)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_7259","instance":7259,"id":177258,"goal":"lemma ModBounds_7259(x: nat, z: nat)\n requires z > 0\n ensures 0 <= x % z < z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_7260","instance":7260,"id":177259,"goal":"lemma Square_Nonneg_7260(m: real)\n ensures m * m >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_7261","instance":7261,"id":177260,"goal":"lemma AddComm_7261(d: int, y: int)\n ensures d + y == y + d\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_7262","instance":7262,"id":177261,"goal":"lemma AddAssoc_7262(y: nat, k: nat, i: nat)\n ensures (y + k) + i == y + (k + i)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_7263","instance":7263,"id":177262,"goal":"lemma MulComm_7263(z: real, a: real)\n ensures z * a == a * z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_7264","instance":7264,"id":177263,"goal":"lemma MulAssoc_7264(n: int, a: int, j: int)\n ensures (n * a) * j == n * (a * j)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_7265","instance":7265,"id":177264,"goal":"lemma Distrib_7265(a: nat, x: nat, b: nat)\n ensures a * (x + b) == a * x + a * b\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_7266","instance":7266,"id":177265,"goal":"lemma AddZero_7266(y: real)\n ensures y + 0 == y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_7267","instance":7267,"id":177266,"goal":"lemma MulOne_7267(b: int)\n ensures b * 1 == b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_7268","instance":7268,"id":177267,"goal":"lemma MulZero_7268(x: nat)\n ensures x * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_7269","instance":7269,"id":177268,"goal":"lemma LeRefl_7269(b: real)\n ensures b <= b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_7270","instance":7270,"id":177269,"goal":"lemma LeTrans_7270(k: int, m: int, j: int)\n requires k <= m && m <= j\n ensures k <= j\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_7271","instance":7271,"id":177270,"goal":"lemma AddMono_7271(y: nat, z: nat, x: nat)\n requires y <= z\n ensures y + x <= z + x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_7272","instance":7272,"id":177271,"goal":"lemma Abs_Nonneg_7272(b: real)\n ensures (if b >= 0 then b else -b) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_7273","instance":7273,"id":177272,"goal":"lemma DivMod_7273(m: int, x: int)\n requires x > 0\n ensures m == x * (m / x) + (m % x)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_7274","instance":7274,"id":177273,"goal":"lemma ModBounds_7274(n: nat, c: nat)\n requires c > 0\n ensures 0 <= n % c < c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_7275","instance":7275,"id":177274,"goal":"lemma Square_Nonneg_7275(x: real)\n ensures x * x >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_7276","instance":7276,"id":177275,"goal":"lemma AddComm_7276(k: int, d: int)\n ensures k + d == d + k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_7277","instance":7277,"id":177276,"goal":"lemma AddAssoc_7277(k: nat, d: nat, i: nat)\n ensures (k + d) + i == k + (d + i)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_7278","instance":7278,"id":177277,"goal":"lemma MulComm_7278(a: real, c: real)\n ensures a * c == c * a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_7279","instance":7279,"id":177278,"goal":"lemma MulAssoc_7279(n: int, j: int, d: int)\n ensures (n * j) * d == n * (j * d)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_7280","instance":7280,"id":177279,"goal":"lemma Distrib_7280(x: nat, d: nat, a: nat)\n ensures x * (d + a) == x * d + x * a\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_7281","instance":7281,"id":177280,"goal":"lemma AddZero_7281(c: real)\n ensures c + 0 == c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_7282","instance":7282,"id":177281,"goal":"lemma MulOne_7282(c: int)\n ensures c * 1 == c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_7283","instance":7283,"id":177282,"goal":"lemma MulZero_7283(j: nat)\n ensures j * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_7284","instance":7284,"id":177283,"goal":"lemma LeRefl_7284(i: real)\n ensures i <= i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_7285","instance":7285,"id":177284,"goal":"lemma LeTrans_7285(y: int, c: int, m: int)\n requires y <= c && c <= m\n ensures y <= m\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_7286","instance":7286,"id":177285,"goal":"lemma AddMono_7286(y: nat, n: nat, k: nat)\n requires y <= n\n ensures y + k <= n + k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_7287","instance":7287,"id":177286,"goal":"lemma Abs_Nonneg_7287(y: real)\n ensures (if y >= 0 then y else -y) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_7288","instance":7288,"id":177287,"goal":"lemma DivMod_7288(a: int, n: int)\n requires n > 0\n ensures a == n * (a / n) + (a % n)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_7289","instance":7289,"id":177288,"goal":"lemma ModBounds_7289(x: nat, j: nat)\n requires j > 0\n ensures 0 <= x % j < j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_7290","instance":7290,"id":177289,"goal":"lemma Square_Nonneg_7290(c: real)\n ensures c * c >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_7291","instance":7291,"id":177290,"goal":"lemma AddComm_7291(x: int, m: int)\n ensures x + m == m + x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_7292","instance":7292,"id":177291,"goal":"lemma AddAssoc_7292(d: nat, y: nat, x: nat)\n ensures (d + y) + x == d + (y + x)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_7293","instance":7293,"id":177292,"goal":"lemma MulComm_7293(j: real, m: real)\n ensures j * m == m * j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_7294","instance":7294,"id":177293,"goal":"lemma MulAssoc_7294(z: int, b: int, y: int)\n ensures (z * b) * y == z * (b * y)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_7295","instance":7295,"id":177294,"goal":"lemma Distrib_7295(n: nat, j: nat, z: nat)\n ensures n * (j + z) == n * j + n * z\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_7296","instance":7296,"id":177295,"goal":"lemma AddZero_7296(k: real)\n ensures k + 0 == k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_7297","instance":7297,"id":177296,"goal":"lemma MulOne_7297(d: int)\n ensures d * 1 == d\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_7298","instance":7298,"id":177297,"goal":"lemma MulZero_7298(k: nat)\n ensures k * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_7299","instance":7299,"id":177298,"goal":"lemma LeRefl_7299(k: real)\n ensures k <= k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_7300","instance":7300,"id":177299,"goal":"lemma LeTrans_7300(c: int, a: int, b: int)\n requires c <= a && a <= b\n ensures c <= b\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_7301","instance":7301,"id":177300,"goal":"lemma AddMono_7301(z: nat, x: nat, j: nat)\n requires z <= x\n ensures z + j <= x + j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_7302","instance":7302,"id":177301,"goal":"lemma Abs_Nonneg_7302(b: real)\n ensures (if b >= 0 then b else -b) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_7303","instance":7303,"id":177302,"goal":"lemma DivMod_7303(m: int, x: int)\n requires x > 0\n ensures m == x * (m / x) + (m % x)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_7304","instance":7304,"id":177303,"goal":"lemma ModBounds_7304(x: nat, c: nat)\n requires c > 0\n ensures 0 <= x % c < c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_7305","instance":7305,"id":177304,"goal":"lemma Square_Nonneg_7305(x: real)\n ensures x * x >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_7306","instance":7306,"id":177305,"goal":"lemma AddComm_7306(i: int, k: int)\n ensures i + k == k + i\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_7307","instance":7307,"id":177306,"goal":"lemma AddAssoc_7307(d: nat, x: nat, b: nat)\n ensures (d + x) + b == d + (x + b)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_7308","instance":7308,"id":177307,"goal":"lemma MulComm_7308(z: real, c: real)\n ensures z * c == c * z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_7309","instance":7309,"id":177308,"goal":"lemma MulAssoc_7309(x: int, y: int, i: int)\n ensures (x * y) * i == x * (y * i)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_7310","instance":7310,"id":177309,"goal":"lemma Distrib_7310(b: nat, c: nat, x: nat)\n ensures b * (c + x) == b * c + b * x\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_7311","instance":7311,"id":177310,"goal":"lemma AddZero_7311(b: real)\n ensures b + 0 == b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_7312","instance":7312,"id":177311,"goal":"lemma MulOne_7312(x: int)\n ensures x * 1 == x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_7313","instance":7313,"id":177312,"goal":"lemma MulZero_7313(b: nat)\n ensures b * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_7314","instance":7314,"id":177313,"goal":"lemma LeRefl_7314(n: real)\n ensures n <= n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_7315","instance":7315,"id":177314,"goal":"lemma LeTrans_7315(d: int, n: int, c: int)\n requires d <= n && n <= c\n ensures d <= c\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_7316","instance":7316,"id":177315,"goal":"lemma AddMono_7316(x: nat, j: nat, d: nat)\n requires x <= j\n ensures x + d <= j + d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_7317","instance":7317,"id":177316,"goal":"lemma Abs_Nonneg_7317(y: real)\n ensures (if y >= 0 then y else -y) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_7318","instance":7318,"id":177317,"goal":"lemma DivMod_7318(d: int, b: int)\n requires b > 0\n ensures d == b * (d / b) + (d % b)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_7319","instance":7319,"id":177318,"goal":"lemma ModBounds_7319(n: nat, b: nat)\n requires b > 0\n ensures 0 <= n % b < b\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_7320","instance":7320,"id":177319,"goal":"lemma Square_Nonneg_7320(d: real)\n ensures d * d >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_7321","instance":7321,"id":177320,"goal":"lemma AddComm_7321(c: int, x: int)\n ensures c + x == x + c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_7322","instance":7322,"id":177321,"goal":"lemma AddAssoc_7322(j: nat, z: nat, m: nat)\n ensures (j + z) + m == j + (z + m)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_7323","instance":7323,"id":177322,"goal":"lemma MulComm_7323(n: real, x: real)\n ensures n * x == x * n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_7324","instance":7324,"id":177323,"goal":"lemma MulAssoc_7324(x: int, k: int, y: int)\n ensures (x * k) * y == x * (k * y)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_7325","instance":7325,"id":177324,"goal":"lemma Distrib_7325(m: nat, a: nat, c: nat)\n ensures m * (a + c) == m * a + m * c\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_7326","instance":7326,"id":177325,"goal":"lemma AddZero_7326(n: real)\n ensures n + 0 == n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_7327","instance":7327,"id":177326,"goal":"lemma MulOne_7327(j: int)\n ensures j * 1 == j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_7328","instance":7328,"id":177327,"goal":"lemma MulZero_7328(j: nat)\n ensures j * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_7329","instance":7329,"id":177328,"goal":"lemma LeRefl_7329(y: real)\n ensures y <= y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_7330","instance":7330,"id":177329,"goal":"lemma LeTrans_7330(j: int, k: int, c: int)\n requires j <= k && k <= c\n ensures j <= c\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_7331","instance":7331,"id":177330,"goal":"lemma AddMono_7331(k: nat, z: nat, a: nat)\n requires k <= z\n ensures k + a <= z + a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_7332","instance":7332,"id":177331,"goal":"lemma Abs_Nonneg_7332(x: real)\n ensures (if x >= 0 then x else -x) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_7333","instance":7333,"id":177332,"goal":"lemma DivMod_7333(a: int, m: int)\n requires m > 0\n ensures a == m * (a / m) + (a % m)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_7334","instance":7334,"id":177333,"goal":"lemma ModBounds_7334(b: nat, c: nat)\n requires c > 0\n ensures 0 <= b % c < c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_7335","instance":7335,"id":177334,"goal":"lemma Square_Nonneg_7335(y: real)\n ensures y * y >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_7336","instance":7336,"id":177335,"goal":"lemma AddComm_7336(z: int, c: int)\n ensures z + c == c + z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_7337","instance":7337,"id":177336,"goal":"lemma AddAssoc_7337(x: nat, d: nat, j: nat)\n ensures (x + d) + j == x + (d + j)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_7338","instance":7338,"id":177337,"goal":"lemma MulComm_7338(m: real, k: real)\n ensures m * k == k * m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_7339","instance":7339,"id":177338,"goal":"lemma MulAssoc_7339(c: int, j: int, x: int)\n ensures (c * j) * x == c * (j * x)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_7340","instance":7340,"id":177339,"goal":"lemma Distrib_7340(d: nat, m: nat, c: nat)\n ensures d * (m + c) == d * m + d * c\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_7341","instance":7341,"id":177340,"goal":"lemma AddZero_7341(y: real)\n ensures y + 0 == y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_7342","instance":7342,"id":177341,"goal":"lemma MulOne_7342(c: int)\n ensures c * 1 == c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_7343","instance":7343,"id":177342,"goal":"lemma MulZero_7343(z: nat)\n ensures z * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_7344","instance":7344,"id":177343,"goal":"lemma LeRefl_7344(j: real)\n ensures j <= j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_7345","instance":7345,"id":177344,"goal":"lemma LeTrans_7345(m: int, a: int, y: int)\n requires m <= a && a <= y\n ensures m <= y\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_7346","instance":7346,"id":177345,"goal":"lemma AddMono_7346(i: nat, j: nat, m: nat)\n requires i <= j\n ensures i + m <= j + m\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_7347","instance":7347,"id":177346,"goal":"lemma Abs_Nonneg_7347(n: real)\n ensures (if n >= 0 then n else -n) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_7348","instance":7348,"id":177347,"goal":"lemma DivMod_7348(n: int, b: int)\n requires b > 0\n ensures n == b * (n / b) + (n % b)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_7349","instance":7349,"id":177348,"goal":"lemma ModBounds_7349(n: nat, i: nat)\n requires i > 0\n ensures 0 <= n % i < i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_7350","instance":7350,"id":177349,"goal":"lemma Square_Nonneg_7350(y: real)\n ensures y * y >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_7351","instance":7351,"id":177350,"goal":"lemma AddComm_7351(a: int, m: int)\n ensures a + m == m + a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_7352","instance":7352,"id":177351,"goal":"lemma AddAssoc_7352(a: nat, x: nat, d: nat)\n ensures (a + x) + d == a + (x + d)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_7353","instance":7353,"id":177352,"goal":"lemma MulComm_7353(c: real, y: real)\n ensures c * y == y * c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_7354","instance":7354,"id":177353,"goal":"lemma MulAssoc_7354(i: int, y: int, a: int)\n ensures (i * y) * a == i * (y * a)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_7355","instance":7355,"id":177354,"goal":"lemma Distrib_7355(j: nat, k: nat, a: nat)\n ensures j * (k + a) == j * k + j * a\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_7356","instance":7356,"id":177355,"goal":"lemma AddZero_7356(a: real)\n ensures a + 0 == a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_7357","instance":7357,"id":177356,"goal":"lemma MulOne_7357(i: int)\n ensures i * 1 == i\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_7358","instance":7358,"id":177357,"goal":"lemma MulZero_7358(i: nat)\n ensures i * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_7359","instance":7359,"id":177358,"goal":"lemma LeRefl_7359(z: real)\n ensures z <= z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_7360","instance":7360,"id":177359,"goal":"lemma LeTrans_7360(x: int, d: int, k: int)\n requires x <= d && d <= k\n ensures x <= k\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_7361","instance":7361,"id":177360,"goal":"lemma AddMono_7361(i: nat, d: nat, z: nat)\n requires i <= d\n ensures i + z <= d + z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_7362","instance":7362,"id":177361,"goal":"lemma Abs_Nonneg_7362(d: real)\n ensures (if d >= 0 then d else -d) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_7363","instance":7363,"id":177362,"goal":"lemma DivMod_7363(a: int, c: int)\n requires c > 0\n ensures a == c * (a / c) + (a % c)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_7364","instance":7364,"id":177363,"goal":"lemma ModBounds_7364(k: nat, i: nat)\n requires i > 0\n ensures 0 <= k % i < i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_7365","instance":7365,"id":177364,"goal":"lemma Square_Nonneg_7365(i: real)\n ensures i * i >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_7366","instance":7366,"id":177365,"goal":"lemma AddComm_7366(d: int, x: int)\n ensures d + x == x + d\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_7367","instance":7367,"id":177366,"goal":"lemma AddAssoc_7367(d: nat, c: nat, a: nat)\n ensures (d + c) + a == d + (c + a)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_7368","instance":7368,"id":177367,"goal":"lemma MulComm_7368(j: real, z: real)\n ensures j * z == z * j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_7369","instance":7369,"id":177368,"goal":"lemma MulAssoc_7369(k: int, i: int, b: int)\n ensures (k * i) * b == k * (i * b)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_7370","instance":7370,"id":177369,"goal":"lemma Distrib_7370(a: nat, d: nat, k: nat)\n ensures a * (d + k) == a * d + a * k\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_7371","instance":7371,"id":177370,"goal":"lemma AddZero_7371(x: real)\n ensures x + 0 == x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_7372","instance":7372,"id":177371,"goal":"lemma MulOne_7372(n: int)\n ensures n * 1 == n\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_7373","instance":7373,"id":177372,"goal":"lemma MulZero_7373(j: nat)\n ensures j * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_7374","instance":7374,"id":177373,"goal":"lemma LeRefl_7374(x: real)\n ensures x <= x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_7375","instance":7375,"id":177374,"goal":"lemma LeTrans_7375(n: int, i: int, b: int)\n requires n <= i && i <= b\n ensures n <= b\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_7376","instance":7376,"id":177375,"goal":"lemma AddMono_7376(n: nat, m: nat, a: nat)\n requires n <= m\n ensures n + a <= m + a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_7377","instance":7377,"id":177376,"goal":"lemma Abs_Nonneg_7377(a: real)\n ensures (if a >= 0 then a else -a) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_7378","instance":7378,"id":177377,"goal":"lemma DivMod_7378(m: int, i: int)\n requires i > 0\n ensures m == i * (m / i) + (m % i)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_7379","instance":7379,"id":177378,"goal":"lemma ModBounds_7379(k: nat, m: nat)\n requires m > 0\n ensures 0 <= k % m < m\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_7380","instance":7380,"id":177379,"goal":"lemma Square_Nonneg_7380(k: real)\n ensures k * k >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_7381","instance":7381,"id":177380,"goal":"lemma AddComm_7381(j: int, c: int)\n ensures j + c == c + j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_7382","instance":7382,"id":177381,"goal":"lemma AddAssoc_7382(b: nat, c: nat, y: nat)\n ensures (b + c) + y == b + (c + y)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_7383","instance":7383,"id":177382,"goal":"lemma MulComm_7383(i: real, b: real)\n ensures i * b == b * i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_7384","instance":7384,"id":177383,"goal":"lemma MulAssoc_7384(m: int, j: int, k: int)\n ensures (m * j) * k == m * (j * k)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_7385","instance":7385,"id":177384,"goal":"lemma Distrib_7385(z: nat, n: nat, b: nat)\n ensures z * (n + b) == z * n + z * b\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_7386","instance":7386,"id":177385,"goal":"lemma AddZero_7386(x: real)\n ensures x + 0 == x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_7387","instance":7387,"id":177386,"goal":"lemma MulOne_7387(d: int)\n ensures d * 1 == d\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_7388","instance":7388,"id":177387,"goal":"lemma MulZero_7388(k: nat)\n ensures k * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_7389","instance":7389,"id":177388,"goal":"lemma LeRefl_7389(k: real)\n ensures k <= k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_7390","instance":7390,"id":177389,"goal":"lemma LeTrans_7390(i: int, x: int, a: int)\n requires i <= x && x <= a\n ensures i <= a\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_7391","instance":7391,"id":177390,"goal":"lemma AddMono_7391(a: nat, d: nat, c: nat)\n requires a <= d\n ensures a + c <= d + c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_7392","instance":7392,"id":177391,"goal":"lemma Abs_Nonneg_7392(a: real)\n ensures (if a >= 0 then a else -a) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_7393","instance":7393,"id":177392,"goal":"lemma DivMod_7393(d: int, c: int)\n requires c > 0\n ensures d == c * (d / c) + (d % c)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_7394","instance":7394,"id":177393,"goal":"lemma ModBounds_7394(d: nat, n: nat)\n requires n > 0\n ensures 0 <= d % n < n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_7395","instance":7395,"id":177394,"goal":"lemma Square_Nonneg_7395(m: real)\n ensures m * m >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_7396","instance":7396,"id":177395,"goal":"lemma AddComm_7396(y: int, z: int)\n ensures y + z == z + y\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_7397","instance":7397,"id":177396,"goal":"lemma AddAssoc_7397(a: nat, y: nat, i: nat)\n ensures (a + y) + i == a + (y + i)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_7398","instance":7398,"id":177397,"goal":"lemma MulComm_7398(k: real, c: real)\n ensures k * c == c * k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_7399","instance":7399,"id":177398,"goal":"lemma MulAssoc_7399(n: int, k: int, a: int)\n ensures (n * k) * a == n * (k * a)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_7400","instance":7400,"id":177399,"goal":"lemma Distrib_7400(n: nat, d: nat, i: nat)\n ensures n * (d + i) == n * d + n * i\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_7401","instance":7401,"id":177400,"goal":"lemma AddZero_7401(k: real)\n ensures k + 0 == k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_7402","instance":7402,"id":177401,"goal":"lemma MulOne_7402(j: int)\n ensures j * 1 == j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_7403","instance":7403,"id":177402,"goal":"lemma MulZero_7403(d: nat)\n ensures d * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_7404","instance":7404,"id":177403,"goal":"lemma LeRefl_7404(a: real)\n ensures a <= a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_7405","instance":7405,"id":177404,"goal":"lemma LeTrans_7405(d: int, c: int, z: int)\n requires d <= c && c <= z\n ensures d <= z\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_7406","instance":7406,"id":177405,"goal":"lemma AddMono_7406(m: nat, y: nat, b: nat)\n requires m <= y\n ensures m + b <= y + b\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_7407","instance":7407,"id":177406,"goal":"lemma Abs_Nonneg_7407(d: real)\n ensures (if d >= 0 then d else -d) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_7408","instance":7408,"id":177407,"goal":"lemma DivMod_7408(b: int, j: int)\n requires j > 0\n ensures b == j * (b / j) + (b % j)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_7409","instance":7409,"id":177408,"goal":"lemma ModBounds_7409(y: nat, m: nat)\n requires m > 0\n ensures 0 <= y % m < m\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_7410","instance":7410,"id":177409,"goal":"lemma Square_Nonneg_7410(d: real)\n ensures d * d >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_7411","instance":7411,"id":177410,"goal":"lemma AddComm_7411(x: int, j: int)\n ensures x + j == j + x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_7412","instance":7412,"id":177411,"goal":"lemma AddAssoc_7412(z: nat, j: nat, k: nat)\n ensures (z + j) + k == z + (j + k)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_7413","instance":7413,"id":177412,"goal":"lemma MulComm_7413(c: real, k: real)\n ensures c * k == k * c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_7414","instance":7414,"id":177413,"goal":"lemma MulAssoc_7414(x: int, i: int, b: int)\n ensures (x * i) * b == x * (i * b)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_7415","instance":7415,"id":177414,"goal":"lemma Distrib_7415(k: nat, y: nat, m: nat)\n ensures k * (y + m) == k * y + k * m\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_7416","instance":7416,"id":177415,"goal":"lemma AddZero_7416(b: real)\n ensures b + 0 == b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_7417","instance":7417,"id":177416,"goal":"lemma MulOne_7417(x: int)\n ensures x * 1 == x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_7418","instance":7418,"id":177417,"goal":"lemma MulZero_7418(n: nat)\n ensures n * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_7419","instance":7419,"id":177418,"goal":"lemma LeRefl_7419(a: real)\n ensures a <= a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_7420","instance":7420,"id":177419,"goal":"lemma LeTrans_7420(x: int, k: int, j: int)\n requires x <= k && k <= j\n ensures x <= j\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_7421","instance":7421,"id":177420,"goal":"lemma AddMono_7421(n: nat, k: nat, b: nat)\n requires n <= k\n ensures n + b <= k + b\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_7422","instance":7422,"id":177421,"goal":"lemma Abs_Nonneg_7422(k: real)\n ensures (if k >= 0 then k else -k) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_7423","instance":7423,"id":177422,"goal":"lemma DivMod_7423(y: int, j: int)\n requires j > 0\n ensures y == j * (y / j) + (y % j)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_7424","instance":7424,"id":177423,"goal":"lemma ModBounds_7424(z: nat, a: nat)\n requires a > 0\n ensures 0 <= z % a < a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_7425","instance":7425,"id":177424,"goal":"lemma Square_Nonneg_7425(x: real)\n ensures x * x >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_7426","instance":7426,"id":177425,"goal":"lemma AddComm_7426(d: int, n: int)\n ensures d + n == n + d\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_7427","instance":7427,"id":177426,"goal":"lemma AddAssoc_7427(i: nat, b: nat, x: nat)\n ensures (i + b) + x == i + (b + x)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_7428","instance":7428,"id":177427,"goal":"lemma MulComm_7428(m: real, z: real)\n ensures m * z == z * m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_7429","instance":7429,"id":177428,"goal":"lemma MulAssoc_7429(a: int, i: int, n: int)\n ensures (a * i) * n == a * (i * n)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_7430","instance":7430,"id":177429,"goal":"lemma Distrib_7430(y: nat, c: nat, m: nat)\n ensures y * (c + m) == y * c + y * m\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_7431","instance":7431,"id":177430,"goal":"lemma AddZero_7431(c: real)\n ensures c + 0 == c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_7432","instance":7432,"id":177431,"goal":"lemma MulOne_7432(i: int)\n ensures i * 1 == i\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_7433","instance":7433,"id":177432,"goal":"lemma MulZero_7433(n: nat)\n ensures n * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_7434","instance":7434,"id":177433,"goal":"lemma LeRefl_7434(z: real)\n ensures z <= z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_7435","instance":7435,"id":177434,"goal":"lemma LeTrans_7435(j: int, i: int, z: int)\n requires j <= i && i <= z\n ensures j <= z\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_7436","instance":7436,"id":177435,"goal":"lemma AddMono_7436(x: nat, a: nat, c: nat)\n requires x <= a\n ensures x + c <= a + c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_7437","instance":7437,"id":177436,"goal":"lemma Abs_Nonneg_7437(i: real)\n ensures (if i >= 0 then i else -i) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_7438","instance":7438,"id":177437,"goal":"lemma DivMod_7438(d: int, i: int)\n requires i > 0\n ensures d == i * (d / i) + (d % i)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_7439","instance":7439,"id":177438,"goal":"lemma ModBounds_7439(k: nat, n: nat)\n requires n > 0\n ensures 0 <= k % n < n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_7440","instance":7440,"id":177439,"goal":"lemma Square_Nonneg_7440(k: real)\n ensures k * k >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_7441","instance":7441,"id":177440,"goal":"lemma AddComm_7441(j: int, i: int)\n ensures j + i == i + j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_7442","instance":7442,"id":177441,"goal":"lemma AddAssoc_7442(a: nat, x: nat, c: nat)\n ensures (a + x) + c == a + (x + c)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_7443","instance":7443,"id":177442,"goal":"lemma MulComm_7443(b: real, a: real)\n ensures b * a == a * b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_7444","instance":7444,"id":177443,"goal":"lemma MulAssoc_7444(a: int, n: int, x: int)\n ensures (a * n) * x == a * (n * x)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_7445","instance":7445,"id":177444,"goal":"lemma Distrib_7445(c: nat, k: nat, y: nat)\n ensures c * (k + y) == c * k + c * y\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_7446","instance":7446,"id":177445,"goal":"lemma AddZero_7446(j: real)\n ensures j + 0 == j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_7447","instance":7447,"id":177446,"goal":"lemma MulOne_7447(j: int)\n ensures j * 1 == j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_7448","instance":7448,"id":177447,"goal":"lemma MulZero_7448(a: nat)\n ensures a * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_7449","instance":7449,"id":177448,"goal":"lemma LeRefl_7449(z: real)\n ensures z <= z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_7450","instance":7450,"id":177449,"goal":"lemma LeTrans_7450(y: int, j: int, z: int)\n requires y <= j && j <= z\n ensures y <= z\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_7451","instance":7451,"id":177450,"goal":"lemma AddMono_7451(i: nat, m: nat, b: nat)\n requires i <= m\n ensures i + b <= m + b\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_7452","instance":7452,"id":177451,"goal":"lemma Abs_Nonneg_7452(j: real)\n ensures (if j >= 0 then j else -j) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_7453","instance":7453,"id":177452,"goal":"lemma DivMod_7453(y: int, x: int)\n requires x > 0\n ensures y == x * (y / x) + (y % x)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_7454","instance":7454,"id":177453,"goal":"lemma ModBounds_7454(a: nat, y: nat)\n requires y > 0\n ensures 0 <= a % y < y\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_7455","instance":7455,"id":177454,"goal":"lemma Square_Nonneg_7455(j: real)\n ensures j * j >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_7456","instance":7456,"id":177455,"goal":"lemma AddComm_7456(z: int, d: int)\n ensures z + d == d + z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_7457","instance":7457,"id":177456,"goal":"lemma AddAssoc_7457(k: nat, x: nat, z: nat)\n ensures (k + x) + z == k + (x + z)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_7458","instance":7458,"id":177457,"goal":"lemma MulComm_7458(y: real, c: real)\n ensures y * c == c * y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_7459","instance":7459,"id":177458,"goal":"lemma MulAssoc_7459(b: int, y: int, n: int)\n ensures (b * y) * n == b * (y * n)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_7460","instance":7460,"id":177459,"goal":"lemma Distrib_7460(d: nat, i: nat, k: nat)\n ensures d * (i + k) == d * i + d * k\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_7461","instance":7461,"id":177460,"goal":"lemma AddZero_7461(y: real)\n ensures y + 0 == y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_7462","instance":7462,"id":177461,"goal":"lemma MulOne_7462(d: int)\n ensures d * 1 == d\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_7463","instance":7463,"id":177462,"goal":"lemma MulZero_7463(z: nat)\n ensures z * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_7464","instance":7464,"id":177463,"goal":"lemma LeRefl_7464(a: real)\n ensures a <= a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_7465","instance":7465,"id":177464,"goal":"lemma LeTrans_7465(i: int, a: int, n: int)\n requires i <= a && a <= n\n ensures i <= n\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_7466","instance":7466,"id":177465,"goal":"lemma AddMono_7466(i: nat, y: nat, c: nat)\n requires i <= y\n ensures i + c <= y + c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_7467","instance":7467,"id":177466,"goal":"lemma Abs_Nonneg_7467(c: real)\n ensures (if c >= 0 then c else -c) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_7468","instance":7468,"id":177467,"goal":"lemma DivMod_7468(i: int, a: int)\n requires a > 0\n ensures i == a * (i / a) + (i % a)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_7469","instance":7469,"id":177468,"goal":"lemma ModBounds_7469(c: nat, j: nat)\n requires j > 0\n ensures 0 <= c % j < j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_7470","instance":7470,"id":177469,"goal":"lemma Square_Nonneg_7470(y: real)\n ensures y * y >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_7471","instance":7471,"id":177470,"goal":"lemma AddComm_7471(j: int, m: int)\n ensures j + m == m + j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_7472","instance":7472,"id":177471,"goal":"lemma AddAssoc_7472(k: nat, i: nat, c: nat)\n ensures (k + i) + c == k + (i + c)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_7473","instance":7473,"id":177472,"goal":"lemma MulComm_7473(j: real, k: real)\n ensures j * k == k * j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_7474","instance":7474,"id":177473,"goal":"lemma MulAssoc_7474(j: int, k: int, y: int)\n ensures (j * k) * y == j * (k * y)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_7475","instance":7475,"id":177474,"goal":"lemma Distrib_7475(x: nat, i: nat, c: nat)\n ensures x * (i + c) == x * i + x * c\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_7476","instance":7476,"id":177475,"goal":"lemma AddZero_7476(y: real)\n ensures y + 0 == y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_7477","instance":7477,"id":177476,"goal":"lemma MulOne_7477(z: int)\n ensures z * 1 == z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_7478","instance":7478,"id":177477,"goal":"lemma MulZero_7478(k: nat)\n ensures k * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_7479","instance":7479,"id":177478,"goal":"lemma LeRefl_7479(b: real)\n ensures b <= b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_7480","instance":7480,"id":177479,"goal":"lemma LeTrans_7480(i: int, j: int, d: int)\n requires i <= j && j <= d\n ensures i <= d\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_7481","instance":7481,"id":177480,"goal":"lemma AddMono_7481(y: nat, n: nat, j: nat)\n requires y <= n\n ensures y + j <= n + j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_7482","instance":7482,"id":177481,"goal":"lemma Abs_Nonneg_7482(a: real)\n ensures (if a >= 0 then a else -a) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_7483","instance":7483,"id":177482,"goal":"lemma DivMod_7483(d: int, y: int)\n requires y > 0\n ensures d == y * (d / y) + (d % y)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_7484","instance":7484,"id":177483,"goal":"lemma ModBounds_7484(b: nat, j: nat)\n requires j > 0\n ensures 0 <= b % j < j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_7485","instance":7485,"id":177484,"goal":"lemma Square_Nonneg_7485(x: real)\n ensures x * x >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_7486","instance":7486,"id":177485,"goal":"lemma AddComm_7486(n: int, y: int)\n ensures n + y == y + n\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_7487","instance":7487,"id":177486,"goal":"lemma AddAssoc_7487(i: nat, m: nat, n: nat)\n ensures (i + m) + n == i + (m + n)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_7488","instance":7488,"id":177487,"goal":"lemma MulComm_7488(b: real, d: real)\n ensures b * d == d * b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_7489","instance":7489,"id":177488,"goal":"lemma MulAssoc_7489(z: int, n: int, k: int)\n ensures (z * n) * k == z * (n * k)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_7490","instance":7490,"id":177489,"goal":"lemma Distrib_7490(c: nat, z: nat, k: nat)\n ensures c * (z + k) == c * z + c * k\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_7491","instance":7491,"id":177490,"goal":"lemma AddZero_7491(b: real)\n ensures b + 0 == b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_7492","instance":7492,"id":177491,"goal":"lemma MulOne_7492(d: int)\n ensures d * 1 == d\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_7493","instance":7493,"id":177492,"goal":"lemma MulZero_7493(y: nat)\n ensures y * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_7494","instance":7494,"id":177493,"goal":"lemma LeRefl_7494(k: real)\n ensures k <= k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_7495","instance":7495,"id":177494,"goal":"lemma LeTrans_7495(n: int, z: int, c: int)\n requires n <= z && z <= c\n ensures n <= c\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_7496","instance":7496,"id":177495,"goal":"lemma AddMono_7496(m: nat, d: nat, k: nat)\n requires m <= d\n ensures m + k <= d + k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_7497","instance":7497,"id":177496,"goal":"lemma Abs_Nonneg_7497(b: real)\n ensures (if b >= 0 then b else -b) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_7498","instance":7498,"id":177497,"goal":"lemma DivMod_7498(z: int, a: int)\n requires a > 0\n ensures z == a * (z / a) + (z % a)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_7499","instance":7499,"id":177498,"goal":"lemma ModBounds_7499(x: nat, b: nat)\n requires b > 0\n ensures 0 <= x % b < b\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_7500","instance":7500,"id":177499,"goal":"lemma Square_Nonneg_7500(x: real)\n ensures x * x >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_7501","instance":7501,"id":177500,"goal":"lemma AddComm_7501(d: int, k: int)\n ensures d + k == k + d\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_7502","instance":7502,"id":177501,"goal":"lemma AddAssoc_7502(m: nat, j: nat, c: nat)\n ensures (m + j) + c == m + (j + c)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_7503","instance":7503,"id":177502,"goal":"lemma MulComm_7503(n: real, x: real)\n ensures n * x == x * n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_7504","instance":7504,"id":177503,"goal":"lemma MulAssoc_7504(m: int, z: int, n: int)\n ensures (m * z) * n == m * (z * n)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_7505","instance":7505,"id":177504,"goal":"lemma Distrib_7505(z: nat, y: nat, a: nat)\n ensures z * (y + a) == z * y + z * a\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_7506","instance":7506,"id":177505,"goal":"lemma AddZero_7506(c: real)\n ensures c + 0 == c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_7507","instance":7507,"id":177506,"goal":"lemma MulOne_7507(b: int)\n ensures b * 1 == b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_7508","instance":7508,"id":177507,"goal":"lemma MulZero_7508(a: nat)\n ensures a * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_7509","instance":7509,"id":177508,"goal":"lemma LeRefl_7509(k: real)\n ensures k <= k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_7510","instance":7510,"id":177509,"goal":"lemma LeTrans_7510(j: int, b: int, c: int)\n requires j <= b && b <= c\n ensures j <= c\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_7511","instance":7511,"id":177510,"goal":"lemma AddMono_7511(z: nat, b: nat, c: nat)\n requires z <= b\n ensures z + c <= b + c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_7512","instance":7512,"id":177511,"goal":"lemma Abs_Nonneg_7512(c: real)\n ensures (if c >= 0 then c else -c) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_7513","instance":7513,"id":177512,"goal":"lemma DivMod_7513(z: int, n: int)\n requires n > 0\n ensures z == n * (z / n) + (z % n)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_7514","instance":7514,"id":177513,"goal":"lemma ModBounds_7514(k: nat, d: nat)\n requires d > 0\n ensures 0 <= k % d < d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_7515","instance":7515,"id":177514,"goal":"lemma Square_Nonneg_7515(a: real)\n ensures a * a >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_7516","instance":7516,"id":177515,"goal":"lemma AddComm_7516(c: int, j: int)\n ensures c + j == j + c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_7517","instance":7517,"id":177516,"goal":"lemma AddAssoc_7517(d: nat, z: nat, x: nat)\n ensures (d + z) + x == d + (z + x)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_7518","instance":7518,"id":177517,"goal":"lemma MulComm_7518(d: real, b: real)\n ensures d * b == b * d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_7519","instance":7519,"id":177518,"goal":"lemma MulAssoc_7519(z: int, b: int, x: int)\n ensures (z * b) * x == z * (b * x)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_7520","instance":7520,"id":177519,"goal":"lemma Distrib_7520(y: nat, z: nat, x: nat)\n ensures y * (z + x) == y * z + y * x\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_7521","instance":7521,"id":177520,"goal":"lemma AddZero_7521(z: real)\n ensures z + 0 == z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_7522","instance":7522,"id":177521,"goal":"lemma MulOne_7522(n: int)\n ensures n * 1 == n\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_7523","instance":7523,"id":177522,"goal":"lemma MulZero_7523(c: nat)\n ensures c * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_7524","instance":7524,"id":177523,"goal":"lemma LeRefl_7524(i: real)\n ensures i <= i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_7525","instance":7525,"id":177524,"goal":"lemma LeTrans_7525(y: int, c: int, n: int)\n requires y <= c && c <= n\n ensures y <= n\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_7526","instance":7526,"id":177525,"goal":"lemma AddMono_7526(i: nat, j: nat, m: nat)\n requires i <= j\n ensures i + m <= j + m\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_7527","instance":7527,"id":177526,"goal":"lemma Abs_Nonneg_7527(b: real)\n ensures (if b >= 0 then b else -b) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_7528","instance":7528,"id":177527,"goal":"lemma DivMod_7528(d: int, a: int)\n requires a > 0\n ensures d == a * (d / a) + (d % a)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_7529","instance":7529,"id":177528,"goal":"lemma ModBounds_7529(b: nat, k: nat)\n requires k > 0\n ensures 0 <= b % k < k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_7530","instance":7530,"id":177529,"goal":"lemma Square_Nonneg_7530(c: real)\n ensures c * c >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_7531","instance":7531,"id":177530,"goal":"lemma AddComm_7531(d: int, x: int)\n ensures d + x == x + d\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_7532","instance":7532,"id":177531,"goal":"lemma AddAssoc_7532(z: nat, m: nat, y: nat)\n ensures (z + m) + y == z + (m + y)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_7533","instance":7533,"id":177532,"goal":"lemma MulComm_7533(k: real, z: real)\n ensures k * z == z * k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_7534","instance":7534,"id":177533,"goal":"lemma MulAssoc_7534(c: int, i: int, y: int)\n ensures (c * i) * y == c * (i * y)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_7535","instance":7535,"id":177534,"goal":"lemma Distrib_7535(a: nat, i: nat, c: nat)\n ensures a * (i + c) == a * i + a * c\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_7536","instance":7536,"id":177535,"goal":"lemma AddZero_7536(a: real)\n ensures a + 0 == a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_7537","instance":7537,"id":177536,"goal":"lemma MulOne_7537(k: int)\n ensures k * 1 == k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_7538","instance":7538,"id":177537,"goal":"lemma MulZero_7538(i: nat)\n ensures i * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_7539","instance":7539,"id":177538,"goal":"lemma LeRefl_7539(y: real)\n ensures y <= y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_7540","instance":7540,"id":177539,"goal":"lemma LeTrans_7540(a: int, y: int, i: int)\n requires a <= y && y <= i\n ensures a <= i\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_7541","instance":7541,"id":177540,"goal":"lemma AddMono_7541(m: nat, x: nat, a: nat)\n requires m <= x\n ensures m + a <= x + a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_7542","instance":7542,"id":177541,"goal":"lemma Abs_Nonneg_7542(z: real)\n ensures (if z >= 0 then z else -z) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_7543","instance":7543,"id":177542,"goal":"lemma DivMod_7543(d: int, b: int)\n requires b > 0\n ensures d == b * (d / b) + (d % b)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_7544","instance":7544,"id":177543,"goal":"lemma ModBounds_7544(m: nat, y: nat)\n requires y > 0\n ensures 0 <= m % y < y\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_7545","instance":7545,"id":177544,"goal":"lemma Square_Nonneg_7545(k: real)\n ensures k * k >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_7546","instance":7546,"id":177545,"goal":"lemma AddComm_7546(m: int, y: int)\n ensures m + y == y + m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_7547","instance":7547,"id":177546,"goal":"lemma AddAssoc_7547(j: nat, z: nat, a: nat)\n ensures (j + z) + a == j + (z + a)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_7548","instance":7548,"id":177547,"goal":"lemma MulComm_7548(n: real, k: real)\n ensures n * k == k * n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_7549","instance":7549,"id":177548,"goal":"lemma MulAssoc_7549(c: int, m: int, d: int)\n ensures (c * m) * d == c * (m * d)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_7550","instance":7550,"id":177549,"goal":"lemma Distrib_7550(x: nat, j: nat, n: nat)\n ensures x * (j + n) == x * j + x * n\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_7551","instance":7551,"id":177550,"goal":"lemma AddZero_7551(k: real)\n ensures k + 0 == k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_7552","instance":7552,"id":177551,"goal":"lemma MulOne_7552(b: int)\n ensures b * 1 == b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_7553","instance":7553,"id":177552,"goal":"lemma MulZero_7553(c: nat)\n ensures c * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_7554","instance":7554,"id":177553,"goal":"lemma LeRefl_7554(z: real)\n ensures z <= z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_7555","instance":7555,"id":177554,"goal":"lemma LeTrans_7555(c: int, k: int, i: int)\n requires c <= k && k <= i\n ensures c <= i\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_7556","instance":7556,"id":177555,"goal":"lemma AddMono_7556(z: nat, n: nat, k: nat)\n requires z <= n\n ensures z + k <= n + k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_7557","instance":7557,"id":177556,"goal":"lemma Abs_Nonneg_7557(c: real)\n ensures (if c >= 0 then c else -c) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_7558","instance":7558,"id":177557,"goal":"lemma DivMod_7558(d: int, a: int)\n requires a > 0\n ensures d == a * (d / a) + (d % a)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_7559","instance":7559,"id":177558,"goal":"lemma ModBounds_7559(n: nat, d: nat)\n requires d > 0\n ensures 0 <= n % d < d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_7560","instance":7560,"id":177559,"goal":"lemma Square_Nonneg_7560(m: real)\n ensures m * m >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_7561","instance":7561,"id":177560,"goal":"lemma AddComm_7561(z: int, n: int)\n ensures z + n == n + z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_7562","instance":7562,"id":177561,"goal":"lemma AddAssoc_7562(b: nat, c: nat, a: nat)\n ensures (b + c) + a == b + (c + a)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_7563","instance":7563,"id":177562,"goal":"lemma MulComm_7563(j: real, z: real)\n ensures j * z == z * j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_7564","instance":7564,"id":177563,"goal":"lemma MulAssoc_7564(n: int, y: int, m: int)\n ensures (n * y) * m == n * (y * m)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_7565","instance":7565,"id":177564,"goal":"lemma Distrib_7565(x: nat, d: nat, i: nat)\n ensures x * (d + i) == x * d + x * i\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_7566","instance":7566,"id":177565,"goal":"lemma AddZero_7566(d: real)\n ensures d + 0 == d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_7567","instance":7567,"id":177566,"goal":"lemma MulOne_7567(d: int)\n ensures d * 1 == d\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_7568","instance":7568,"id":177567,"goal":"lemma MulZero_7568(a: nat)\n ensures a * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_7569","instance":7569,"id":177568,"goal":"lemma LeRefl_7569(m: real)\n ensures m <= m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_7570","instance":7570,"id":177569,"goal":"lemma LeTrans_7570(b: int, k: int, y: int)\n requires b <= k && k <= y\n ensures b <= y\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_7571","instance":7571,"id":177570,"goal":"lemma AddMono_7571(y: nat, z: nat, x: nat)\n requires y <= z\n ensures y + x <= z + x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_7572","instance":7572,"id":177571,"goal":"lemma Abs_Nonneg_7572(x: real)\n ensures (if x >= 0 then x else -x) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_7573","instance":7573,"id":177572,"goal":"lemma DivMod_7573(y: int, b: int)\n requires b > 0\n ensures y == b * (y / b) + (y % b)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_7574","instance":7574,"id":177573,"goal":"lemma ModBounds_7574(c: nat, k: nat)\n requires k > 0\n ensures 0 <= c % k < k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_7575","instance":7575,"id":177574,"goal":"lemma Square_Nonneg_7575(a: real)\n ensures a * a >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_7576","instance":7576,"id":177575,"goal":"lemma AddComm_7576(b: int, z: int)\n ensures b + z == z + b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_7577","instance":7577,"id":177576,"goal":"lemma AddAssoc_7577(k: nat, n: nat, y: nat)\n ensures (k + n) + y == k + (n + y)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_7578","instance":7578,"id":177577,"goal":"lemma MulComm_7578(y: real, a: real)\n ensures y * a == a * y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_7579","instance":7579,"id":177578,"goal":"lemma MulAssoc_7579(c: int, z: int, i: int)\n ensures (c * z) * i == c * (z * i)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_7580","instance":7580,"id":177579,"goal":"lemma Distrib_7580(i: nat, x: nat, j: nat)\n ensures i * (x + j) == i * x + i * j\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_7581","instance":7581,"id":177580,"goal":"lemma AddZero_7581(i: real)\n ensures i + 0 == i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_7582","instance":7582,"id":177581,"goal":"lemma MulOne_7582(k: int)\n ensures k * 1 == k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_7583","instance":7583,"id":177582,"goal":"lemma MulZero_7583(a: nat)\n ensures a * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_7584","instance":7584,"id":177583,"goal":"lemma LeRefl_7584(z: real)\n ensures z <= z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_7585","instance":7585,"id":177584,"goal":"lemma LeTrans_7585(x: int, c: int, n: int)\n requires x <= c && c <= n\n ensures x <= n\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_7586","instance":7586,"id":177585,"goal":"lemma AddMono_7586(m: nat, b: nat, k: nat)\n requires m <= b\n ensures m + k <= b + k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_7587","instance":7587,"id":177586,"goal":"lemma Abs_Nonneg_7587(j: real)\n ensures (if j >= 0 then j else -j) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_7588","instance":7588,"id":177587,"goal":"lemma DivMod_7588(j: int, d: int)\n requires d > 0\n ensures j == d * (j / d) + (j % d)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_7589","instance":7589,"id":177588,"goal":"lemma ModBounds_7589(m: nat, a: nat)\n requires a > 0\n ensures 0 <= m % a < a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_7590","instance":7590,"id":177589,"goal":"lemma Square_Nonneg_7590(x: real)\n ensures x * x >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_7591","instance":7591,"id":177590,"goal":"lemma AddComm_7591(a: int, i: int)\n ensures a + i == i + a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_7592","instance":7592,"id":177591,"goal":"lemma AddAssoc_7592(c: nat, j: nat, x: nat)\n ensures (c + j) + x == c + (j + x)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_7593","instance":7593,"id":177592,"goal":"lemma MulComm_7593(i: real, j: real)\n ensures i * j == j * i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_7594","instance":7594,"id":177593,"goal":"lemma MulAssoc_7594(d: int, k: int, y: int)\n ensures (d * k) * y == d * (k * y)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_7595","instance":7595,"id":177594,"goal":"lemma Distrib_7595(y: nat, a: nat, b: nat)\n ensures y * (a + b) == y * a + y * b\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_7596","instance":7596,"id":177595,"goal":"lemma AddZero_7596(x: real)\n ensures x + 0 == x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_7597","instance":7597,"id":177596,"goal":"lemma MulOne_7597(y: int)\n ensures y * 1 == y\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_7598","instance":7598,"id":177597,"goal":"lemma MulZero_7598(b: nat)\n ensures b * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_7599","instance":7599,"id":177598,"goal":"lemma LeRefl_7599(y: real)\n ensures y <= y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_7600","instance":7600,"id":177599,"goal":"lemma LeTrans_7600(a: int, k: int, d: int)\n requires a <= k && k <= d\n ensures a <= d\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_7601","instance":7601,"id":177600,"goal":"lemma AddMono_7601(b: nat, k: nat, m: nat)\n requires b <= k\n ensures b + m <= k + m\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_7602","instance":7602,"id":177601,"goal":"lemma Abs_Nonneg_7602(a: real)\n ensures (if a >= 0 then a else -a) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_7603","instance":7603,"id":177602,"goal":"lemma DivMod_7603(m: int, d: int)\n requires d > 0\n ensures m == d * (m / d) + (m % d)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_7604","instance":7604,"id":177603,"goal":"lemma ModBounds_7604(n: nat, z: nat)\n requires z > 0\n ensures 0 <= n % z < z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_7605","instance":7605,"id":177604,"goal":"lemma Square_Nonneg_7605(z: real)\n ensures z * z >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_7606","instance":7606,"id":177605,"goal":"lemma AddComm_7606(n: int, c: int)\n ensures n + c == c + n\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_7607","instance":7607,"id":177606,"goal":"lemma AddAssoc_7607(b: nat, d: nat, n: nat)\n ensures (b + d) + n == b + (d + n)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_7608","instance":7608,"id":177607,"goal":"lemma MulComm_7608(z: real, c: real)\n ensures z * c == c * z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_7609","instance":7609,"id":177608,"goal":"lemma MulAssoc_7609(x: int, b: int, c: int)\n ensures (x * b) * c == x * (b * c)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_7610","instance":7610,"id":177609,"goal":"lemma Distrib_7610(i: nat, b: nat, m: nat)\n ensures i * (b + m) == i * b + i * m\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_7611","instance":7611,"id":177610,"goal":"lemma AddZero_7611(n: real)\n ensures n + 0 == n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_7612","instance":7612,"id":177611,"goal":"lemma MulOne_7612(b: int)\n ensures b * 1 == b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_7613","instance":7613,"id":177612,"goal":"lemma MulZero_7613(m: nat)\n ensures m * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_7614","instance":7614,"id":177613,"goal":"lemma LeRefl_7614(j: real)\n ensures j <= j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_7615","instance":7615,"id":177614,"goal":"lemma LeTrans_7615(c: int, m: int, d: int)\n requires c <= m && m <= d\n ensures c <= d\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_7616","instance":7616,"id":177615,"goal":"lemma AddMono_7616(m: nat, x: nat, b: nat)\n requires m <= x\n ensures m + b <= x + b\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_7617","instance":7617,"id":177616,"goal":"lemma Abs_Nonneg_7617(d: real)\n ensures (if d >= 0 then d else -d) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_7618","instance":7618,"id":177617,"goal":"lemma DivMod_7618(c: int, k: int)\n requires k > 0\n ensures c == k * (c / k) + (c % k)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_7619","instance":7619,"id":177618,"goal":"lemma ModBounds_7619(b: nat, n: nat)\n requires n > 0\n ensures 0 <= b % n < n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_7620","instance":7620,"id":177619,"goal":"lemma Square_Nonneg_7620(a: real)\n ensures a * a >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_7621","instance":7621,"id":177620,"goal":"lemma AddComm_7621(i: int, y: int)\n ensures i + y == y + i\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_7622","instance":7622,"id":177621,"goal":"lemma AddAssoc_7622(y: nat, b: nat, n: nat)\n ensures (y + b) + n == y + (b + n)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_7623","instance":7623,"id":177622,"goal":"lemma MulComm_7623(x: real, k: real)\n ensures x * k == k * x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_7624","instance":7624,"id":177623,"goal":"lemma MulAssoc_7624(x: int, m: int, z: int)\n ensures (x * m) * z == x * (m * z)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_7625","instance":7625,"id":177624,"goal":"lemma Distrib_7625(c: nat, k: nat, a: nat)\n ensures c * (k + a) == c * k + c * a\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_7626","instance":7626,"id":177625,"goal":"lemma AddZero_7626(c: real)\n ensures c + 0 == c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_7627","instance":7627,"id":177626,"goal":"lemma MulOne_7627(m: int)\n ensures m * 1 == m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_7628","instance":7628,"id":177627,"goal":"lemma MulZero_7628(i: nat)\n ensures i * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_7629","instance":7629,"id":177628,"goal":"lemma LeRefl_7629(y: real)\n ensures y <= y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_7630","instance":7630,"id":177629,"goal":"lemma LeTrans_7630(y: int, n: int, k: int)\n requires y <= n && n <= k\n ensures y <= k\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_7631","instance":7631,"id":177630,"goal":"lemma AddMono_7631(k: nat, j: nat, x: nat)\n requires k <= j\n ensures k + x <= j + x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_7632","instance":7632,"id":177631,"goal":"lemma Abs_Nonneg_7632(c: real)\n ensures (if c >= 0 then c else -c) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_7633","instance":7633,"id":177632,"goal":"lemma DivMod_7633(a: int, x: int)\n requires x > 0\n ensures a == x * (a / x) + (a % x)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_7634","instance":7634,"id":177633,"goal":"lemma ModBounds_7634(j: nat, i: nat)\n requires i > 0\n ensures 0 <= j % i < i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_7635","instance":7635,"id":177634,"goal":"lemma Square_Nonneg_7635(x: real)\n ensures x * x >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_7636","instance":7636,"id":177635,"goal":"lemma AddComm_7636(k: int, m: int)\n ensures k + m == m + k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_7637","instance":7637,"id":177636,"goal":"lemma AddAssoc_7637(x: nat, b: nat, y: nat)\n ensures (x + b) + y == x + (b + y)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_7638","instance":7638,"id":177637,"goal":"lemma MulComm_7638(b: real, z: real)\n ensures b * z == z * b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_7639","instance":7639,"id":177638,"goal":"lemma MulAssoc_7639(z: int, y: int, b: int)\n ensures (z * y) * b == z * (y * b)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_7640","instance":7640,"id":177639,"goal":"lemma Distrib_7640(n: nat, z: nat, x: nat)\n ensures n * (z + x) == n * z + n * x\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_7641","instance":7641,"id":177640,"goal":"lemma AddZero_7641(a: real)\n ensures a + 0 == a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_7642","instance":7642,"id":177641,"goal":"lemma MulOne_7642(m: int)\n ensures m * 1 == m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_7643","instance":7643,"id":177642,"goal":"lemma MulZero_7643(x: nat)\n ensures x * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_7644","instance":7644,"id":177643,"goal":"lemma LeRefl_7644(i: real)\n ensures i <= i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_7645","instance":7645,"id":177644,"goal":"lemma LeTrans_7645(d: int, n: int, c: int)\n requires d <= n && n <= c\n ensures d <= c\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_7646","instance":7646,"id":177645,"goal":"lemma AddMono_7646(b: nat, c: nat, i: nat)\n requires b <= c\n ensures b + i <= c + i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_7647","instance":7647,"id":177646,"goal":"lemma Abs_Nonneg_7647(k: real)\n ensures (if k >= 0 then k else -k) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_7648","instance":7648,"id":177647,"goal":"lemma DivMod_7648(n: int, k: int)\n requires k > 0\n ensures n == k * (n / k) + (n % k)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_7649","instance":7649,"id":177648,"goal":"lemma ModBounds_7649(n: nat, x: nat)\n requires x > 0\n ensures 0 <= n % x < x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_7650","instance":7650,"id":177649,"goal":"lemma Square_Nonneg_7650(c: real)\n ensures c * c >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_7651","instance":7651,"id":177650,"goal":"lemma AddComm_7651(i: int, j: int)\n ensures i + j == j + i\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_7652","instance":7652,"id":177651,"goal":"lemma AddAssoc_7652(y: nat, c: nat, j: nat)\n ensures (y + c) + j == y + (c + j)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_7653","instance":7653,"id":177652,"goal":"lemma MulComm_7653(b: real, k: real)\n ensures b * k == k * b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_7654","instance":7654,"id":177653,"goal":"lemma MulAssoc_7654(j: int, b: int, a: int)\n ensures (j * b) * a == j * (b * a)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_7655","instance":7655,"id":177654,"goal":"lemma Distrib_7655(b: nat, i: nat, x: nat)\n ensures b * (i + x) == b * i + b * x\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_7656","instance":7656,"id":177655,"goal":"lemma AddZero_7656(z: real)\n ensures z + 0 == z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_7657","instance":7657,"id":177656,"goal":"lemma MulOne_7657(x: int)\n ensures x * 1 == x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_7658","instance":7658,"id":177657,"goal":"lemma MulZero_7658(j: nat)\n ensures j * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_7659","instance":7659,"id":177658,"goal":"lemma LeRefl_7659(z: real)\n ensures z <= z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_7660","instance":7660,"id":177659,"goal":"lemma LeTrans_7660(n: int, y: int, k: int)\n requires n <= y && y <= k\n ensures n <= k\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_7661","instance":7661,"id":177660,"goal":"lemma AddMono_7661(z: nat, d: nat, x: nat)\n requires z <= d\n ensures z + x <= d + x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_7662","instance":7662,"id":177661,"goal":"lemma Abs_Nonneg_7662(y: real)\n ensures (if y >= 0 then y else -y) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_7663","instance":7663,"id":177662,"goal":"lemma DivMod_7663(k: int, j: int)\n requires j > 0\n ensures k == j * (k / j) + (k % j)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_7664","instance":7664,"id":177663,"goal":"lemma ModBounds_7664(j: nat, x: nat)\n requires x > 0\n ensures 0 <= j % x < x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_7665","instance":7665,"id":177664,"goal":"lemma Square_Nonneg_7665(z: real)\n ensures z * z >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_7666","instance":7666,"id":177665,"goal":"lemma AddComm_7666(b: int, c: int)\n ensures b + c == c + b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_7667","instance":7667,"id":177666,"goal":"lemma AddAssoc_7667(a: nat, i: nat, x: nat)\n ensures (a + i) + x == a + (i + x)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_7668","instance":7668,"id":177667,"goal":"lemma MulComm_7668(m: real, b: real)\n ensures m * b == b * m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_7669","instance":7669,"id":177668,"goal":"lemma MulAssoc_7669(b: int, d: int, m: int)\n ensures (b * d) * m == b * (d * m)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_7670","instance":7670,"id":177669,"goal":"lemma Distrib_7670(y: nat, k: nat, x: nat)\n ensures y * (k + x) == y * k + y * x\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_7671","instance":7671,"id":177670,"goal":"lemma AddZero_7671(d: real)\n ensures d + 0 == d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_7672","instance":7672,"id":177671,"goal":"lemma MulOne_7672(k: int)\n ensures k * 1 == k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_7673","instance":7673,"id":177672,"goal":"lemma MulZero_7673(k: nat)\n ensures k * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_7674","instance":7674,"id":177673,"goal":"lemma LeRefl_7674(i: real)\n ensures i <= i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_7675","instance":7675,"id":177674,"goal":"lemma LeTrans_7675(j: int, k: int, z: int)\n requires j <= k && k <= z\n ensures j <= z\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_7676","instance":7676,"id":177675,"goal":"lemma AddMono_7676(x: nat, a: nat, i: nat)\n requires x <= a\n ensures x + i <= a + i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_7677","instance":7677,"id":177676,"goal":"lemma Abs_Nonneg_7677(m: real)\n ensures (if m >= 0 then m else -m) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_7678","instance":7678,"id":177677,"goal":"lemma DivMod_7678(b: int, x: int)\n requires x > 0\n ensures b == x * (b / x) + (b % x)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_7679","instance":7679,"id":177678,"goal":"lemma ModBounds_7679(y: nat, a: nat)\n requires a > 0\n ensures 0 <= y % a < a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_7680","instance":7680,"id":177679,"goal":"lemma Square_Nonneg_7680(y: real)\n ensures y * y >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_7681","instance":7681,"id":177680,"goal":"lemma AddComm_7681(b: int, z: int)\n ensures b + z == z + b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_7682","instance":7682,"id":177681,"goal":"lemma AddAssoc_7682(b: nat, a: nat, m: nat)\n ensures (b + a) + m == b + (a + m)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_7683","instance":7683,"id":177682,"goal":"lemma MulComm_7683(b: real, k: real)\n ensures b * k == k * b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_7684","instance":7684,"id":177683,"goal":"lemma MulAssoc_7684(j: int, i: int, z: int)\n ensures (j * i) * z == j * (i * z)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_7685","instance":7685,"id":177684,"goal":"lemma Distrib_7685(z: nat, d: nat, c: nat)\n ensures z * (d + c) == z * d + z * c\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_7686","instance":7686,"id":177685,"goal":"lemma AddZero_7686(z: real)\n ensures z + 0 == z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_7687","instance":7687,"id":177686,"goal":"lemma MulOne_7687(a: int)\n ensures a * 1 == a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_7688","instance":7688,"id":177687,"goal":"lemma MulZero_7688(n: nat)\n ensures n * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_7689","instance":7689,"id":177688,"goal":"lemma LeRefl_7689(b: real)\n ensures b <= b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_7690","instance":7690,"id":177689,"goal":"lemma LeTrans_7690(n: int, x: int, m: int)\n requires n <= x && x <= m\n ensures n <= m\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_7691","instance":7691,"id":177690,"goal":"lemma AddMono_7691(m: nat, i: nat, n: nat)\n requires m <= i\n ensures m + n <= i + n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_7692","instance":7692,"id":177691,"goal":"lemma Abs_Nonneg_7692(a: real)\n ensures (if a >= 0 then a else -a) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_7693","instance":7693,"id":177692,"goal":"lemma DivMod_7693(b: int, j: int)\n requires j > 0\n ensures b == j * (b / j) + (b % j)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_7694","instance":7694,"id":177693,"goal":"lemma ModBounds_7694(x: nat, m: nat)\n requires m > 0\n ensures 0 <= x % m < m\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_7695","instance":7695,"id":177694,"goal":"lemma Square_Nonneg_7695(c: real)\n ensures c * c >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_7696","instance":7696,"id":177695,"goal":"lemma AddComm_7696(k: int, y: int)\n ensures k + y == y + k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_7697","instance":7697,"id":177696,"goal":"lemma AddAssoc_7697(y: nat, b: nat, n: nat)\n ensures (y + b) + n == y + (b + n)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_7698","instance":7698,"id":177697,"goal":"lemma MulComm_7698(k: real, b: real)\n ensures k * b == b * k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_7699","instance":7699,"id":177698,"goal":"lemma MulAssoc_7699(k: int, i: int, c: int)\n ensures (k * i) * c == k * (i * c)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_7700","instance":7700,"id":177699,"goal":"lemma Distrib_7700(m: nat, y: nat, j: nat)\n ensures m * (y + j) == m * y + m * j\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_7701","instance":7701,"id":177700,"goal":"lemma AddZero_7701(j: real)\n ensures j + 0 == j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_7702","instance":7702,"id":177701,"goal":"lemma MulOne_7702(k: int)\n ensures k * 1 == k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_7703","instance":7703,"id":177702,"goal":"lemma MulZero_7703(c: nat)\n ensures c * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_7704","instance":7704,"id":177703,"goal":"lemma LeRefl_7704(c: real)\n ensures c <= c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_7705","instance":7705,"id":177704,"goal":"lemma LeTrans_7705(y: int, z: int, b: int)\n requires y <= z && z <= b\n ensures y <= b\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_7706","instance":7706,"id":177705,"goal":"lemma AddMono_7706(b: nat, d: nat, a: nat)\n requires b <= d\n ensures b + a <= d + a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_7707","instance":7707,"id":177706,"goal":"lemma Abs_Nonneg_7707(x: real)\n ensures (if x >= 0 then x else -x) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_7708","instance":7708,"id":177707,"goal":"lemma DivMod_7708(a: int, x: int)\n requires x > 0\n ensures a == x * (a / x) + (a % x)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_7709","instance":7709,"id":177708,"goal":"lemma ModBounds_7709(c: nat, x: nat)\n requires x > 0\n ensures 0 <= c % x < x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_7710","instance":7710,"id":177709,"goal":"lemma Square_Nonneg_7710(k: real)\n ensures k * k >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_7711","instance":7711,"id":177710,"goal":"lemma AddComm_7711(d: int, x: int)\n ensures d + x == x + d\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_7712","instance":7712,"id":177711,"goal":"lemma AddAssoc_7712(i: nat, n: nat, c: nat)\n ensures (i + n) + c == i + (n + c)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_7713","instance":7713,"id":177712,"goal":"lemma MulComm_7713(c: real, a: real)\n ensures c * a == a * c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_7714","instance":7714,"id":177713,"goal":"lemma MulAssoc_7714(d: int, z: int, b: int)\n ensures (d * z) * b == d * (z * b)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_7715","instance":7715,"id":177714,"goal":"lemma Distrib_7715(c: nat, k: nat, a: nat)\n ensures c * (k + a) == c * k + c * a\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_7716","instance":7716,"id":177715,"goal":"lemma AddZero_7716(b: real)\n ensures b + 0 == b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_7717","instance":7717,"id":177716,"goal":"lemma MulOne_7717(c: int)\n ensures c * 1 == c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_7718","instance":7718,"id":177717,"goal":"lemma MulZero_7718(d: nat)\n ensures d * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_7719","instance":7719,"id":177718,"goal":"lemma LeRefl_7719(k: real)\n ensures k <= k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_7720","instance":7720,"id":177719,"goal":"lemma LeTrans_7720(n: int, x: int, i: int)\n requires n <= x && x <= i\n ensures n <= i\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_7721","instance":7721,"id":177720,"goal":"lemma AddMono_7721(k: nat, z: nat, i: nat)\n requires k <= z\n ensures k + i <= z + i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_7722","instance":7722,"id":177721,"goal":"lemma Abs_Nonneg_7722(a: real)\n ensures (if a >= 0 then a else -a) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_7723","instance":7723,"id":177722,"goal":"lemma DivMod_7723(k: int, j: int)\n requires j > 0\n ensures k == j * (k / j) + (k % j)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_7724","instance":7724,"id":177723,"goal":"lemma ModBounds_7724(a: nat, j: nat)\n requires j > 0\n ensures 0 <= a % j < j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_7725","instance":7725,"id":177724,"goal":"lemma Square_Nonneg_7725(z: real)\n ensures z * z >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_7726","instance":7726,"id":177725,"goal":"lemma AddComm_7726(m: int, j: int)\n ensures m + j == j + m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_7727","instance":7727,"id":177726,"goal":"lemma AddAssoc_7727(m: nat, y: nat, i: nat)\n ensures (m + y) + i == m + (y + i)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_7728","instance":7728,"id":177727,"goal":"lemma MulComm_7728(n: real, k: real)\n ensures n * k == k * n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_7729","instance":7729,"id":177728,"goal":"lemma MulAssoc_7729(c: int, m: int, b: int)\n ensures (c * m) * b == c * (m * b)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_7730","instance":7730,"id":177729,"goal":"lemma Distrib_7730(n: nat, k: nat, b: nat)\n ensures n * (k + b) == n * k + n * b\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_7731","instance":7731,"id":177730,"goal":"lemma AddZero_7731(i: real)\n ensures i + 0 == i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_7732","instance":7732,"id":177731,"goal":"lemma MulOne_7732(j: int)\n ensures j * 1 == j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_7733","instance":7733,"id":177732,"goal":"lemma MulZero_7733(b: nat)\n ensures b * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_7734","instance":7734,"id":177733,"goal":"lemma LeRefl_7734(b: real)\n ensures b <= b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_7735","instance":7735,"id":177734,"goal":"lemma LeTrans_7735(m: int, d: int, j: int)\n requires m <= d && d <= j\n ensures m <= j\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_7736","instance":7736,"id":177735,"goal":"lemma AddMono_7736(z: nat, j: nat, b: nat)\n requires z <= j\n ensures z + b <= j + b\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_7737","instance":7737,"id":177736,"goal":"lemma Abs_Nonneg_7737(i: real)\n ensures (if i >= 0 then i else -i) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_7738","instance":7738,"id":177737,"goal":"lemma DivMod_7738(j: int, n: int)\n requires n > 0\n ensures j == n * (j / n) + (j % n)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_7739","instance":7739,"id":177738,"goal":"lemma ModBounds_7739(m: nat, n: nat)\n requires n > 0\n ensures 0 <= m % n < n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_7740","instance":7740,"id":177739,"goal":"lemma Square_Nonneg_7740(c: real)\n ensures c * c >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_7741","instance":7741,"id":177740,"goal":"lemma AddComm_7741(i: int, j: int)\n ensures i + j == j + i\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_7742","instance":7742,"id":177741,"goal":"lemma AddAssoc_7742(i: nat, b: nat, c: nat)\n ensures (i + b) + c == i + (b + c)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_7743","instance":7743,"id":177742,"goal":"lemma MulComm_7743(z: real, i: real)\n ensures z * i == i * z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_7744","instance":7744,"id":177743,"goal":"lemma MulAssoc_7744(n: int, m: int, y: int)\n ensures (n * m) * y == n * (m * y)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_7745","instance":7745,"id":177744,"goal":"lemma Distrib_7745(i: nat, b: nat, k: nat)\n ensures i * (b + k) == i * b + i * k\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_7746","instance":7746,"id":177745,"goal":"lemma AddZero_7746(a: real)\n ensures a + 0 == a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_7747","instance":7747,"id":177746,"goal":"lemma MulOne_7747(j: int)\n ensures j * 1 == j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_7748","instance":7748,"id":177747,"goal":"lemma MulZero_7748(c: nat)\n ensures c * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_7749","instance":7749,"id":177748,"goal":"lemma LeRefl_7749(x: real)\n ensures x <= x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_7750","instance":7750,"id":177749,"goal":"lemma LeTrans_7750(a: int, j: int, x: int)\n requires a <= j && j <= x\n ensures a <= x\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_7751","instance":7751,"id":177750,"goal":"lemma AddMono_7751(d: nat, j: nat, b: nat)\n requires d <= j\n ensures d + b <= j + b\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_7752","instance":7752,"id":177751,"goal":"lemma Abs_Nonneg_7752(z: real)\n ensures (if z >= 0 then z else -z) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_7753","instance":7753,"id":177752,"goal":"lemma DivMod_7753(i: int, x: int)\n requires x > 0\n ensures i == x * (i / x) + (i % x)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_7754","instance":7754,"id":177753,"goal":"lemma ModBounds_7754(m: nat, i: nat)\n requires i > 0\n ensures 0 <= m % i < i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_7755","instance":7755,"id":177754,"goal":"lemma Square_Nonneg_7755(i: real)\n ensures i * i >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_7756","instance":7756,"id":177755,"goal":"lemma AddComm_7756(d: int, m: int)\n ensures d + m == m + d\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_7757","instance":7757,"id":177756,"goal":"lemma AddAssoc_7757(a: nat, y: nat, c: nat)\n ensures (a + y) + c == a + (y + c)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_7758","instance":7758,"id":177757,"goal":"lemma MulComm_7758(c: real, j: real)\n ensures c * j == j * c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_7759","instance":7759,"id":177758,"goal":"lemma MulAssoc_7759(j: int, a: int, c: int)\n ensures (j * a) * c == j * (a * c)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_7760","instance":7760,"id":177759,"goal":"lemma Distrib_7760(c: nat, d: nat, y: nat)\n ensures c * (d + y) == c * d + c * y\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_7761","instance":7761,"id":177760,"goal":"lemma AddZero_7761(k: real)\n ensures k + 0 == k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_7762","instance":7762,"id":177761,"goal":"lemma MulOne_7762(d: int)\n ensures d * 1 == d\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_7763","instance":7763,"id":177762,"goal":"lemma MulZero_7763(c: nat)\n ensures c * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_7764","instance":7764,"id":177763,"goal":"lemma LeRefl_7764(x: real)\n ensures x <= x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_7765","instance":7765,"id":177764,"goal":"lemma LeTrans_7765(y: int, z: int, k: int)\n requires y <= z && z <= k\n ensures y <= k\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_7766","instance":7766,"id":177765,"goal":"lemma AddMono_7766(c: nat, m: nat, y: nat)\n requires c <= m\n ensures c + y <= m + y\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_7767","instance":7767,"id":177766,"goal":"lemma Abs_Nonneg_7767(y: real)\n ensures (if y >= 0 then y else -y) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_7768","instance":7768,"id":177767,"goal":"lemma DivMod_7768(z: int, a: int)\n requires a > 0\n ensures z == a * (z / a) + (z % a)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_7769","instance":7769,"id":177768,"goal":"lemma ModBounds_7769(j: nat, a: nat)\n requires a > 0\n ensures 0 <= j % a < a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_7770","instance":7770,"id":177769,"goal":"lemma Square_Nonneg_7770(n: real)\n ensures n * n >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_7771","instance":7771,"id":177770,"goal":"lemma AddComm_7771(j: int, b: int)\n ensures j + b == b + j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_7772","instance":7772,"id":177771,"goal":"lemma AddAssoc_7772(k: nat, y: nat, j: nat)\n ensures (k + y) + j == k + (y + j)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_7773","instance":7773,"id":177772,"goal":"lemma MulComm_7773(k: real, n: real)\n ensures k * n == n * k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_7774","instance":7774,"id":177773,"goal":"lemma MulAssoc_7774(x: int, y: int, k: int)\n ensures (x * y) * k == x * (y * k)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_7775","instance":7775,"id":177774,"goal":"lemma Distrib_7775(j: nat, c: nat, d: nat)\n ensures j * (c + d) == j * c + j * d\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_7776","instance":7776,"id":177775,"goal":"lemma AddZero_7776(m: real)\n ensures m + 0 == m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_7777","instance":7777,"id":177776,"goal":"lemma MulOne_7777(m: int)\n ensures m * 1 == m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_7778","instance":7778,"id":177777,"goal":"lemma MulZero_7778(i: nat)\n ensures i * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_7779","instance":7779,"id":177778,"goal":"lemma LeRefl_7779(b: real)\n ensures b <= b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_7780","instance":7780,"id":177779,"goal":"lemma LeTrans_7780(d: int, a: int, z: int)\n requires d <= a && a <= z\n ensures d <= z\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_7781","instance":7781,"id":177780,"goal":"lemma AddMono_7781(y: nat, d: nat, j: nat)\n requires y <= d\n ensures y + j <= d + j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_7782","instance":7782,"id":177781,"goal":"lemma Abs_Nonneg_7782(m: real)\n ensures (if m >= 0 then m else -m) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_7783","instance":7783,"id":177782,"goal":"lemma DivMod_7783(j: int, z: int)\n requires z > 0\n ensures j == z * (j / z) + (j % z)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_7784","instance":7784,"id":177783,"goal":"lemma ModBounds_7784(b: nat, k: nat)\n requires k > 0\n ensures 0 <= b % k < k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_7785","instance":7785,"id":177784,"goal":"lemma Square_Nonneg_7785(m: real)\n ensures m * m >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_7786","instance":7786,"id":177785,"goal":"lemma AddComm_7786(i: int, m: int)\n ensures i + m == m + i\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_7787","instance":7787,"id":177786,"goal":"lemma AddAssoc_7787(n: nat, d: nat, m: nat)\n ensures (n + d) + m == n + (d + m)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_7788","instance":7788,"id":177787,"goal":"lemma MulComm_7788(j: real, z: real)\n ensures j * z == z * j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_7789","instance":7789,"id":177788,"goal":"lemma MulAssoc_7789(y: int, k: int, z: int)\n ensures (y * k) * z == y * (k * z)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_7790","instance":7790,"id":177789,"goal":"lemma Distrib_7790(y: nat, j: nat, z: nat)\n ensures y * (j + z) == y * j + y * z\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_7791","instance":7791,"id":177790,"goal":"lemma AddZero_7791(i: real)\n ensures i + 0 == i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_7792","instance":7792,"id":177791,"goal":"lemma MulOne_7792(a: int)\n ensures a * 1 == a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_7793","instance":7793,"id":177792,"goal":"lemma MulZero_7793(j: nat)\n ensures j * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_7794","instance":7794,"id":177793,"goal":"lemma LeRefl_7794(x: real)\n ensures x <= x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_7795","instance":7795,"id":177794,"goal":"lemma LeTrans_7795(x: int, j: int, b: int)\n requires x <= j && j <= b\n ensures x <= b\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_7796","instance":7796,"id":177795,"goal":"lemma AddMono_7796(b: nat, k: nat, n: nat)\n requires b <= k\n ensures b + n <= k + n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_7797","instance":7797,"id":177796,"goal":"lemma Abs_Nonneg_7797(z: real)\n ensures (if z >= 0 then z else -z) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_7798","instance":7798,"id":177797,"goal":"lemma DivMod_7798(a: int, z: int)\n requires z > 0\n ensures a == z * (a / z) + (a % z)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_7799","instance":7799,"id":177798,"goal":"lemma ModBounds_7799(z: nat, j: nat)\n requires j > 0\n ensures 0 <= z % j < j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_7800","instance":7800,"id":177799,"goal":"lemma Square_Nonneg_7800(x: real)\n ensures x * x >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_7801","instance":7801,"id":177800,"goal":"lemma AddComm_7801(d: int, z: int)\n ensures d + z == z + d\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_7802","instance":7802,"id":177801,"goal":"lemma AddAssoc_7802(m: nat, y: nat, x: nat)\n ensures (m + y) + x == m + (y + x)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_7803","instance":7803,"id":177802,"goal":"lemma MulComm_7803(j: real, a: real)\n ensures j * a == a * j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_7804","instance":7804,"id":177803,"goal":"lemma MulAssoc_7804(z: int, c: int, y: int)\n ensures (z * c) * y == z * (c * y)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_7805","instance":7805,"id":177804,"goal":"lemma Distrib_7805(c: nat, j: nat, d: nat)\n ensures c * (j + d) == c * j + c * d\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_7806","instance":7806,"id":177805,"goal":"lemma AddZero_7806(b: real)\n ensures b + 0 == b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_7807","instance":7807,"id":177806,"goal":"lemma MulOne_7807(i: int)\n ensures i * 1 == i\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_7808","instance":7808,"id":177807,"goal":"lemma MulZero_7808(y: nat)\n ensures y * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_7809","instance":7809,"id":177808,"goal":"lemma LeRefl_7809(n: real)\n ensures n <= n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_7810","instance":7810,"id":177809,"goal":"lemma LeTrans_7810(y: int, m: int, x: int)\n requires y <= m && m <= x\n ensures y <= x\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_7811","instance":7811,"id":177810,"goal":"lemma AddMono_7811(y: nat, i: nat, b: nat)\n requires y <= i\n ensures y + b <= i + b\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_7812","instance":7812,"id":177811,"goal":"lemma Abs_Nonneg_7812(i: real)\n ensures (if i >= 0 then i else -i) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_7813","instance":7813,"id":177812,"goal":"lemma DivMod_7813(z: int, y: int)\n requires y > 0\n ensures z == y * (z / y) + (z % y)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_7814","instance":7814,"id":177813,"goal":"lemma ModBounds_7814(j: nat, c: nat)\n requires c > 0\n ensures 0 <= j % c < c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_7815","instance":7815,"id":177814,"goal":"lemma Square_Nonneg_7815(n: real)\n ensures n * n >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_7816","instance":7816,"id":177815,"goal":"lemma AddComm_7816(a: int, x: int)\n ensures a + x == x + a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_7817","instance":7817,"id":177816,"goal":"lemma AddAssoc_7817(b: nat, y: nat, k: nat)\n ensures (b + y) + k == b + (y + k)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_7818","instance":7818,"id":177817,"goal":"lemma MulComm_7818(n: real, a: real)\n ensures n * a == a * n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_7819","instance":7819,"id":177818,"goal":"lemma MulAssoc_7819(b: int, n: int, i: int)\n ensures (b * n) * i == b * (n * i)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_7820","instance":7820,"id":177819,"goal":"lemma Distrib_7820(j: nat, z: nat, d: nat)\n ensures j * (z + d) == j * z + j * d\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_7821","instance":7821,"id":177820,"goal":"lemma AddZero_7821(x: real)\n ensures x + 0 == x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_7822","instance":7822,"id":177821,"goal":"lemma MulOne_7822(m: int)\n ensures m * 1 == m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_7823","instance":7823,"id":177822,"goal":"lemma MulZero_7823(z: nat)\n ensures z * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_7824","instance":7824,"id":177823,"goal":"lemma LeRefl_7824(j: real)\n ensures j <= j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_7825","instance":7825,"id":177824,"goal":"lemma LeTrans_7825(d: int, a: int, i: int)\n requires d <= a && a <= i\n ensures d <= i\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_7826","instance":7826,"id":177825,"goal":"lemma AddMono_7826(a: nat, j: nat, n: nat)\n requires a <= j\n ensures a + n <= j + n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_7827","instance":7827,"id":177826,"goal":"lemma Abs_Nonneg_7827(y: real)\n ensures (if y >= 0 then y else -y) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_7828","instance":7828,"id":177827,"goal":"lemma DivMod_7828(d: int, b: int)\n requires b > 0\n ensures d == b * (d / b) + (d % b)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_7829","instance":7829,"id":177828,"goal":"lemma ModBounds_7829(c: nat, i: nat)\n requires i > 0\n ensures 0 <= c % i < i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_7830","instance":7830,"id":177829,"goal":"lemma Square_Nonneg_7830(k: real)\n ensures k * k >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_7831","instance":7831,"id":177830,"goal":"lemma AddComm_7831(y: int, k: int)\n ensures y + k == k + y\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_7832","instance":7832,"id":177831,"goal":"lemma AddAssoc_7832(x: nat, y: nat, a: nat)\n ensures (x + y) + a == x + (y + a)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_7833","instance":7833,"id":177832,"goal":"lemma MulComm_7833(y: real, x: real)\n ensures y * x == x * y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_7834","instance":7834,"id":177833,"goal":"lemma MulAssoc_7834(m: int, x: int, y: int)\n ensures (m * x) * y == m * (x * y)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_7835","instance":7835,"id":177834,"goal":"lemma Distrib_7835(a: nat, j: nat, d: nat)\n ensures a * (j + d) == a * j + a * d\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_7836","instance":7836,"id":177835,"goal":"lemma AddZero_7836(z: real)\n ensures z + 0 == z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_7837","instance":7837,"id":177836,"goal":"lemma MulOne_7837(j: int)\n ensures j * 1 == j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_7838","instance":7838,"id":177837,"goal":"lemma MulZero_7838(b: nat)\n ensures b * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_7839","instance":7839,"id":177838,"goal":"lemma LeRefl_7839(z: real)\n ensures z <= z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_7840","instance":7840,"id":177839,"goal":"lemma LeTrans_7840(k: int, d: int, j: int)\n requires k <= d && d <= j\n ensures k <= j\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_7841","instance":7841,"id":177840,"goal":"lemma AddMono_7841(d: nat, a: nat, i: nat)\n requires d <= a\n ensures d + i <= a + i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_7842","instance":7842,"id":177841,"goal":"lemma Abs_Nonneg_7842(x: real)\n ensures (if x >= 0 then x else -x) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_7843","instance":7843,"id":177842,"goal":"lemma DivMod_7843(y: int, j: int)\n requires j > 0\n ensures y == j * (y / j) + (y % j)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_7844","instance":7844,"id":177843,"goal":"lemma ModBounds_7844(x: nat, j: nat)\n requires j > 0\n ensures 0 <= x % j < j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_7845","instance":7845,"id":177844,"goal":"lemma Square_Nonneg_7845(j: real)\n ensures j * j >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_7846","instance":7846,"id":177845,"goal":"lemma AddComm_7846(n: int, d: int)\n ensures n + d == d + n\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_7847","instance":7847,"id":177846,"goal":"lemma AddAssoc_7847(i: nat, k: nat, y: nat)\n ensures (i + k) + y == i + (k + y)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_7848","instance":7848,"id":177847,"goal":"lemma MulComm_7848(k: real, j: real)\n ensures k * j == j * k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_7849","instance":7849,"id":177848,"goal":"lemma MulAssoc_7849(i: int, a: int, x: int)\n ensures (i * a) * x == i * (a * x)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_7850","instance":7850,"id":177849,"goal":"lemma Distrib_7850(m: nat, c: nat, a: nat)\n ensures m * (c + a) == m * c + m * a\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_7851","instance":7851,"id":177850,"goal":"lemma AddZero_7851(d: real)\n ensures d + 0 == d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_7852","instance":7852,"id":177851,"goal":"lemma MulOne_7852(y: int)\n ensures y * 1 == y\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_7853","instance":7853,"id":177852,"goal":"lemma MulZero_7853(b: nat)\n ensures b * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_7854","instance":7854,"id":177853,"goal":"lemma LeRefl_7854(a: real)\n ensures a <= a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_7855","instance":7855,"id":177854,"goal":"lemma LeTrans_7855(d: int, y: int, z: int)\n requires d <= y && y <= z\n ensures d <= z\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_7856","instance":7856,"id":177855,"goal":"lemma AddMono_7856(i: nat, n: nat, m: nat)\n requires i <= n\n ensures i + m <= n + m\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_7857","instance":7857,"id":177856,"goal":"lemma Abs_Nonneg_7857(n: real)\n ensures (if n >= 0 then n else -n) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_7858","instance":7858,"id":177857,"goal":"lemma DivMod_7858(m: int, d: int)\n requires d > 0\n ensures m == d * (m / d) + (m % d)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_7859","instance":7859,"id":177858,"goal":"lemma ModBounds_7859(y: nat, m: nat)\n requires m > 0\n ensures 0 <= y % m < m\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_7860","instance":7860,"id":177859,"goal":"lemma Square_Nonneg_7860(x: real)\n ensures x * x >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_7861","instance":7861,"id":177860,"goal":"lemma AddComm_7861(c: int, i: int)\n ensures c + i == i + c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_7862","instance":7862,"id":177861,"goal":"lemma AddAssoc_7862(d: nat, i: nat, a: nat)\n ensures (d + i) + a == d + (i + a)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_7863","instance":7863,"id":177862,"goal":"lemma MulComm_7863(m: real, c: real)\n ensures m * c == c * m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_7864","instance":7864,"id":177863,"goal":"lemma MulAssoc_7864(j: int, c: int, i: int)\n ensures (j * c) * i == j * (c * i)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_7865","instance":7865,"id":177864,"goal":"lemma Distrib_7865(n: nat, a: nat, i: nat)\n ensures n * (a + i) == n * a + n * i\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_7866","instance":7866,"id":177865,"goal":"lemma AddZero_7866(j: real)\n ensures j + 0 == j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_7867","instance":7867,"id":177866,"goal":"lemma MulOne_7867(i: int)\n ensures i * 1 == i\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_7868","instance":7868,"id":177867,"goal":"lemma MulZero_7868(z: nat)\n ensures z * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_7869","instance":7869,"id":177868,"goal":"lemma LeRefl_7869(n: real)\n ensures n <= n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_7870","instance":7870,"id":177869,"goal":"lemma LeTrans_7870(z: int, c: int, b: int)\n requires z <= c && c <= b\n ensures z <= b\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_7871","instance":7871,"id":177870,"goal":"lemma AddMono_7871(j: nat, i: nat, d: nat)\n requires j <= i\n ensures j + d <= i + d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_7872","instance":7872,"id":177871,"goal":"lemma Abs_Nonneg_7872(d: real)\n ensures (if d >= 0 then d else -d) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_7873","instance":7873,"id":177872,"goal":"lemma DivMod_7873(y: int, b: int)\n requires b > 0\n ensures y == b * (y / b) + (y % b)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_7874","instance":7874,"id":177873,"goal":"lemma ModBounds_7874(k: nat, z: nat)\n requires z > 0\n ensures 0 <= k % z < z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_7875","instance":7875,"id":177874,"goal":"lemma Square_Nonneg_7875(i: real)\n ensures i * i >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_7876","instance":7876,"id":177875,"goal":"lemma AddComm_7876(a: int, m: int)\n ensures a + m == m + a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_7877","instance":7877,"id":177876,"goal":"lemma AddAssoc_7877(a: nat, y: nat, d: nat)\n ensures (a + y) + d == a + (y + d)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_7878","instance":7878,"id":177877,"goal":"lemma MulComm_7878(a: real, x: real)\n ensures a * x == x * a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_7879","instance":7879,"id":177878,"goal":"lemma MulAssoc_7879(n: int, d: int, z: int)\n ensures (n * d) * z == n * (d * z)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_7880","instance":7880,"id":177879,"goal":"lemma Distrib_7880(b: nat, d: nat, z: nat)\n ensures b * (d + z) == b * d + b * z\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_7881","instance":7881,"id":177880,"goal":"lemma AddZero_7881(m: real)\n ensures m + 0 == m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_7882","instance":7882,"id":177881,"goal":"lemma MulOne_7882(n: int)\n ensures n * 1 == n\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_7883","instance":7883,"id":177882,"goal":"lemma MulZero_7883(b: nat)\n ensures b * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_7884","instance":7884,"id":177883,"goal":"lemma LeRefl_7884(n: real)\n ensures n <= n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_7885","instance":7885,"id":177884,"goal":"lemma LeTrans_7885(c: int, m: int, i: int)\n requires c <= m && m <= i\n ensures c <= i\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_7886","instance":7886,"id":177885,"goal":"lemma AddMono_7886(i: nat, j: nat, y: nat)\n requires i <= j\n ensures i + y <= j + y\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_7887","instance":7887,"id":177886,"goal":"lemma Abs_Nonneg_7887(y: real)\n ensures (if y >= 0 then y else -y) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_7888","instance":7888,"id":177887,"goal":"lemma DivMod_7888(n: int, z: int)\n requires z > 0\n ensures n == z * (n / z) + (n % z)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_7889","instance":7889,"id":177888,"goal":"lemma ModBounds_7889(x: nat, b: nat)\n requires b > 0\n ensures 0 <= x % b < b\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_7890","instance":7890,"id":177889,"goal":"lemma Square_Nonneg_7890(d: real)\n ensures d * d >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_7891","instance":7891,"id":177890,"goal":"lemma AddComm_7891(z: int, m: int)\n ensures z + m == m + z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_7892","instance":7892,"id":177891,"goal":"lemma AddAssoc_7892(j: nat, x: nat, y: nat)\n ensures (j + x) + y == j + (x + y)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_7893","instance":7893,"id":177892,"goal":"lemma MulComm_7893(j: real, k: real)\n ensures j * k == k * j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_7894","instance":7894,"id":177893,"goal":"lemma MulAssoc_7894(b: int, a: int, n: int)\n ensures (b * a) * n == b * (a * n)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_7895","instance":7895,"id":177894,"goal":"lemma Distrib_7895(a: nat, n: nat, b: nat)\n ensures a * (n + b) == a * n + a * b\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_7896","instance":7896,"id":177895,"goal":"lemma AddZero_7896(c: real)\n ensures c + 0 == c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_7897","instance":7897,"id":177896,"goal":"lemma MulOne_7897(z: int)\n ensures z * 1 == z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_7898","instance":7898,"id":177897,"goal":"lemma MulZero_7898(x: nat)\n ensures x * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_7899","instance":7899,"id":177898,"goal":"lemma LeRefl_7899(d: real)\n ensures d <= d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_7900","instance":7900,"id":177899,"goal":"lemma LeTrans_7900(z: int, b: int, k: int)\n requires z <= b && b <= k\n ensures z <= k\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_7901","instance":7901,"id":177900,"goal":"lemma AddMono_7901(n: nat, z: nat, x: nat)\n requires n <= z\n ensures n + x <= z + x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_7902","instance":7902,"id":177901,"goal":"lemma Abs_Nonneg_7902(a: real)\n ensures (if a >= 0 then a else -a) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_7903","instance":7903,"id":177902,"goal":"lemma DivMod_7903(b: int, m: int)\n requires m > 0\n ensures b == m * (b / m) + (b % m)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_7904","instance":7904,"id":177903,"goal":"lemma ModBounds_7904(n: nat, k: nat)\n requires k > 0\n ensures 0 <= n % k < k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_7905","instance":7905,"id":177904,"goal":"lemma Square_Nonneg_7905(n: real)\n ensures n * n >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_7906","instance":7906,"id":177905,"goal":"lemma AddComm_7906(b: int, m: int)\n ensures b + m == m + b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_7907","instance":7907,"id":177906,"goal":"lemma AddAssoc_7907(j: nat, b: nat, z: nat)\n ensures (j + b) + z == j + (b + z)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_7908","instance":7908,"id":177907,"goal":"lemma MulComm_7908(b: real, c: real)\n ensures b * c == c * b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_7909","instance":7909,"id":177908,"goal":"lemma MulAssoc_7909(d: int, m: int, b: int)\n ensures (d * m) * b == d * (m * b)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_7910","instance":7910,"id":177909,"goal":"lemma Distrib_7910(d: nat, c: nat, n: nat)\n ensures d * (c + n) == d * c + d * n\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_7911","instance":7911,"id":177910,"goal":"lemma AddZero_7911(y: real)\n ensures y + 0 == y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_7912","instance":7912,"id":177911,"goal":"lemma MulOne_7912(j: int)\n ensures j * 1 == j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_7913","instance":7913,"id":177912,"goal":"lemma MulZero_7913(a: nat)\n ensures a * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_7914","instance":7914,"id":177913,"goal":"lemma LeRefl_7914(j: real)\n ensures j <= j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_7915","instance":7915,"id":177914,"goal":"lemma LeTrans_7915(a: int, c: int, z: int)\n requires a <= c && c <= z\n ensures a <= z\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_7916","instance":7916,"id":177915,"goal":"lemma AddMono_7916(n: nat, d: nat, k: nat)\n requires n <= d\n ensures n + k <= d + k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_7917","instance":7917,"id":177916,"goal":"lemma Abs_Nonneg_7917(k: real)\n ensures (if k >= 0 then k else -k) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_7918","instance":7918,"id":177917,"goal":"lemma DivMod_7918(i: int, k: int)\n requires k > 0\n ensures i == k * (i / k) + (i % k)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_7919","instance":7919,"id":177918,"goal":"lemma ModBounds_7919(m: nat, d: nat)\n requires d > 0\n ensures 0 <= m % d < d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_7920","instance":7920,"id":177919,"goal":"lemma Square_Nonneg_7920(c: real)\n ensures c * c >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_7921","instance":7921,"id":177920,"goal":"lemma AddComm_7921(k: int, a: int)\n ensures k + a == a + k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_7922","instance":7922,"id":177921,"goal":"lemma AddAssoc_7922(j: nat, k: nat, d: nat)\n ensures (j + k) + d == j + (k + d)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_7923","instance":7923,"id":177922,"goal":"lemma MulComm_7923(z: real, m: real)\n ensures z * m == m * z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_7924","instance":7924,"id":177923,"goal":"lemma MulAssoc_7924(c: int, m: int, j: int)\n ensures (c * m) * j == c * (m * j)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_7925","instance":7925,"id":177924,"goal":"lemma Distrib_7925(n: nat, x: nat, i: nat)\n ensures n * (x + i) == n * x + n * i\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_7926","instance":7926,"id":177925,"goal":"lemma AddZero_7926(k: real)\n ensures k + 0 == k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_7927","instance":7927,"id":177926,"goal":"lemma MulOne_7927(k: int)\n ensures k * 1 == k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_7928","instance":7928,"id":177927,"goal":"lemma MulZero_7928(b: nat)\n ensures b * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_7929","instance":7929,"id":177928,"goal":"lemma LeRefl_7929(m: real)\n ensures m <= m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_7930","instance":7930,"id":177929,"goal":"lemma LeTrans_7930(m: int, x: int, b: int)\n requires m <= x && x <= b\n ensures m <= b\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_7931","instance":7931,"id":177930,"goal":"lemma AddMono_7931(m: nat, y: nat, n: nat)\n requires m <= y\n ensures m + n <= y + n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_7932","instance":7932,"id":177931,"goal":"lemma Abs_Nonneg_7932(c: real)\n ensures (if c >= 0 then c else -c) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_7933","instance":7933,"id":177932,"goal":"lemma DivMod_7933(m: int, z: int)\n requires z > 0\n ensures m == z * (m / z) + (m % z)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_7934","instance":7934,"id":177933,"goal":"lemma ModBounds_7934(y: nat, k: nat)\n requires k > 0\n ensures 0 <= y % k < k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_7935","instance":7935,"id":177934,"goal":"lemma Square_Nonneg_7935(j: real)\n ensures j * j >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_7936","instance":7936,"id":177935,"goal":"lemma AddComm_7936(m: int, z: int)\n ensures m + z == z + m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_7937","instance":7937,"id":177936,"goal":"lemma AddAssoc_7937(y: nat, x: nat, k: nat)\n ensures (y + x) + k == y + (x + k)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_7938","instance":7938,"id":177937,"goal":"lemma MulComm_7938(b: real, n: real)\n ensures b * n == n * b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_7939","instance":7939,"id":177938,"goal":"lemma MulAssoc_7939(i: int, j: int, b: int)\n ensures (i * j) * b == i * (j * b)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_7940","instance":7940,"id":177939,"goal":"lemma Distrib_7940(n: nat, b: nat, m: nat)\n ensures n * (b + m) == n * b + n * m\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_7941","instance":7941,"id":177940,"goal":"lemma AddZero_7941(z: real)\n ensures z + 0 == z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_7942","instance":7942,"id":177941,"goal":"lemma MulOne_7942(k: int)\n ensures k * 1 == k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_7943","instance":7943,"id":177942,"goal":"lemma MulZero_7943(i: nat)\n ensures i * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_7944","instance":7944,"id":177943,"goal":"lemma LeRefl_7944(y: real)\n ensures y <= y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_7945","instance":7945,"id":177944,"goal":"lemma LeTrans_7945(j: int, x: int, m: int)\n requires j <= x && x <= m\n ensures j <= m\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_7946","instance":7946,"id":177945,"goal":"lemma AddMono_7946(j: nat, z: nat, a: nat)\n requires j <= z\n ensures j + a <= z + a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_7947","instance":7947,"id":177946,"goal":"lemma Abs_Nonneg_7947(k: real)\n ensures (if k >= 0 then k else -k) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_7948","instance":7948,"id":177947,"goal":"lemma DivMod_7948(k: int, d: int)\n requires d > 0\n ensures k == d * (k / d) + (k % d)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_7949","instance":7949,"id":177948,"goal":"lemma ModBounds_7949(d: nat, z: nat)\n requires z > 0\n ensures 0 <= d % z < z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_7950","instance":7950,"id":177949,"goal":"lemma Square_Nonneg_7950(n: real)\n ensures n * n >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_7951","instance":7951,"id":177950,"goal":"lemma AddComm_7951(i: int, z: int)\n ensures i + z == z + i\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_7952","instance":7952,"id":177951,"goal":"lemma AddAssoc_7952(n: nat, m: nat, i: nat)\n ensures (n + m) + i == n + (m + i)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_7953","instance":7953,"id":177952,"goal":"lemma MulComm_7953(z: real, k: real)\n ensures z * k == k * z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_7954","instance":7954,"id":177953,"goal":"lemma MulAssoc_7954(x: int, d: int, j: int)\n ensures (x * d) * j == x * (d * j)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_7955","instance":7955,"id":177954,"goal":"lemma Distrib_7955(c: nat, m: nat, b: nat)\n ensures c * (m + b) == c * m + c * b\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_7956","instance":7956,"id":177955,"goal":"lemma AddZero_7956(b: real)\n ensures b + 0 == b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_7957","instance":7957,"id":177956,"goal":"lemma MulOne_7957(c: int)\n ensures c * 1 == c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_7958","instance":7958,"id":177957,"goal":"lemma MulZero_7958(i: nat)\n ensures i * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_7959","instance":7959,"id":177958,"goal":"lemma LeRefl_7959(j: real)\n ensures j <= j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_7960","instance":7960,"id":177959,"goal":"lemma LeTrans_7960(a: int, d: int, i: int)\n requires a <= d && d <= i\n ensures a <= i\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_7961","instance":7961,"id":177960,"goal":"lemma AddMono_7961(x: nat, c: nat, a: nat)\n requires x <= c\n ensures x + a <= c + a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_7962","instance":7962,"id":177961,"goal":"lemma Abs_Nonneg_7962(a: real)\n ensures (if a >= 0 then a else -a) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_7963","instance":7963,"id":177962,"goal":"lemma DivMod_7963(m: int, d: int)\n requires d > 0\n ensures m == d * (m / d) + (m % d)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_7964","instance":7964,"id":177963,"goal":"lemma ModBounds_7964(j: nat, b: nat)\n requires b > 0\n ensures 0 <= j % b < b\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_7965","instance":7965,"id":177964,"goal":"lemma Square_Nonneg_7965(x: real)\n ensures x * x >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_7966","instance":7966,"id":177965,"goal":"lemma AddComm_7966(y: int, i: int)\n ensures y + i == i + y\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_7967","instance":7967,"id":177966,"goal":"lemma AddAssoc_7967(c: nat, b: nat, j: nat)\n ensures (c + b) + j == c + (b + j)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_7968","instance":7968,"id":177967,"goal":"lemma MulComm_7968(m: real, i: real)\n ensures m * i == i * m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_7969","instance":7969,"id":177968,"goal":"lemma MulAssoc_7969(c: int, x: int, i: int)\n ensures (c * x) * i == c * (x * i)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_7970","instance":7970,"id":177969,"goal":"lemma Distrib_7970(d: nat, i: nat, j: nat)\n ensures d * (i + j) == d * i + d * j\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_7971","instance":7971,"id":177970,"goal":"lemma AddZero_7971(y: real)\n ensures y + 0 == y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_7972","instance":7972,"id":177971,"goal":"lemma MulOne_7972(j: int)\n ensures j * 1 == j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_7973","instance":7973,"id":177972,"goal":"lemma MulZero_7973(i: nat)\n ensures i * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_7974","instance":7974,"id":177973,"goal":"lemma LeRefl_7974(j: real)\n ensures j <= j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_7975","instance":7975,"id":177974,"goal":"lemma LeTrans_7975(z: int, d: int, m: int)\n requires z <= d && d <= m\n ensures z <= m\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_7976","instance":7976,"id":177975,"goal":"lemma AddMono_7976(k: nat, y: nat, a: nat)\n requires k <= y\n ensures k + a <= y + a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_7977","instance":7977,"id":177976,"goal":"lemma Abs_Nonneg_7977(i: real)\n ensures (if i >= 0 then i else -i) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_7978","instance":7978,"id":177977,"goal":"lemma DivMod_7978(z: int, y: int)\n requires y > 0\n ensures z == y * (z / y) + (z % y)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_7979","instance":7979,"id":177978,"goal":"lemma ModBounds_7979(j: nat, z: nat)\n requires z > 0\n ensures 0 <= j % z < z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_7980","instance":7980,"id":177979,"goal":"lemma Square_Nonneg_7980(d: real)\n ensures d * d >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_7981","instance":7981,"id":177980,"goal":"lemma AddComm_7981(m: int, y: int)\n ensures m + y == y + m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_7982","instance":7982,"id":177981,"goal":"lemma AddAssoc_7982(d: nat, c: nat, z: nat)\n ensures (d + c) + z == d + (c + z)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_7983","instance":7983,"id":177982,"goal":"lemma MulComm_7983(b: real, n: real)\n ensures b * n == n * b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_7984","instance":7984,"id":177983,"goal":"lemma MulAssoc_7984(j: int, m: int, a: int)\n ensures (j * m) * a == j * (m * a)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_7985","instance":7985,"id":177984,"goal":"lemma Distrib_7985(a: nat, y: nat, x: nat)\n ensures a * (y + x) == a * y + a * x\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_7986","instance":7986,"id":177985,"goal":"lemma AddZero_7986(d: real)\n ensures d + 0 == d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_7987","instance":7987,"id":177986,"goal":"lemma MulOne_7987(j: int)\n ensures j * 1 == j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_7988","instance":7988,"id":177987,"goal":"lemma MulZero_7988(k: nat)\n ensures k * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_7989","instance":7989,"id":177988,"goal":"lemma LeRefl_7989(k: real)\n ensures k <= k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_7990","instance":7990,"id":177989,"goal":"lemma LeTrans_7990(y: int, m: int, b: int)\n requires y <= m && m <= b\n ensures y <= b\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_7991","instance":7991,"id":177990,"goal":"lemma AddMono_7991(z: nat, k: nat, x: nat)\n requires z <= k\n ensures z + x <= k + x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_7992","instance":7992,"id":177991,"goal":"lemma Abs_Nonneg_7992(j: real)\n ensures (if j >= 0 then j else -j) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_7993","instance":7993,"id":177992,"goal":"lemma DivMod_7993(j: int, d: int)\n requires d > 0\n ensures j == d * (j / d) + (j % d)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_7994","instance":7994,"id":177993,"goal":"lemma ModBounds_7994(k: nat, j: nat)\n requires j > 0\n ensures 0 <= k % j < j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_7995","instance":7995,"id":177994,"goal":"lemma Square_Nonneg_7995(k: real)\n ensures k * k >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_7996","instance":7996,"id":177995,"goal":"lemma AddComm_7996(a: int, z: int)\n ensures a + z == z + a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_7997","instance":7997,"id":177996,"goal":"lemma AddAssoc_7997(a: nat, y: nat, m: nat)\n ensures (a + y) + m == a + (y + m)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_7998","instance":7998,"id":177997,"goal":"lemma MulComm_7998(n: real, j: real)\n ensures n * j == j * n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_7999","instance":7999,"id":177998,"goal":"lemma MulAssoc_7999(d: int, a: int, i: int)\n ensures (d * a) * i == d * (a * i)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_8000","instance":8000,"id":177999,"goal":"lemma Distrib_8000(z: nat, d: nat, a: nat)\n ensures z * (d + a) == z * d + z * a\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_8001","instance":8001,"id":178000,"goal":"lemma AddZero_8001(a: real)\n ensures a + 0 == a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_8002","instance":8002,"id":178001,"goal":"lemma MulOne_8002(d: int)\n ensures d * 1 == d\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_8003","instance":8003,"id":178002,"goal":"lemma MulZero_8003(m: nat)\n ensures m * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_8004","instance":8004,"id":178003,"goal":"lemma LeRefl_8004(j: real)\n ensures j <= j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_8005","instance":8005,"id":178004,"goal":"lemma LeTrans_8005(m: int, c: int, z: int)\n requires m <= c && c <= z\n ensures m <= z\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_8006","instance":8006,"id":178005,"goal":"lemma AddMono_8006(x: nat, z: nat, a: nat)\n requires x <= z\n ensures x + a <= z + a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_8007","instance":8007,"id":178006,"goal":"lemma Abs_Nonneg_8007(d: real)\n ensures (if d >= 0 then d else -d) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_8008","instance":8008,"id":178007,"goal":"lemma DivMod_8008(b: int, i: int)\n requires i > 0\n ensures b == i * (b / i) + (b % i)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_8009","instance":8009,"id":178008,"goal":"lemma ModBounds_8009(b: nat, x: nat)\n requires x > 0\n ensures 0 <= b % x < x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_8010","instance":8010,"id":178009,"goal":"lemma Square_Nonneg_8010(c: real)\n ensures c * c >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_8011","instance":8011,"id":178010,"goal":"lemma AddComm_8011(i: int, m: int)\n ensures i + m == m + i\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_8012","instance":8012,"id":178011,"goal":"lemma AddAssoc_8012(y: nat, z: nat, k: nat)\n ensures (y + z) + k == y + (z + k)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_8013","instance":8013,"id":178012,"goal":"lemma MulComm_8013(m: real, y: real)\n ensures m * y == y * m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_8014","instance":8014,"id":178013,"goal":"lemma MulAssoc_8014(d: int, j: int, c: int)\n ensures (d * j) * c == d * (j * c)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_8015","instance":8015,"id":178014,"goal":"lemma Distrib_8015(i: nat, m: nat, x: nat)\n ensures i * (m + x) == i * m + i * x\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_8016","instance":8016,"id":178015,"goal":"lemma AddZero_8016(d: real)\n ensures d + 0 == d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_8017","instance":8017,"id":178016,"goal":"lemma MulOne_8017(n: int)\n ensures n * 1 == n\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_8018","instance":8018,"id":178017,"goal":"lemma MulZero_8018(i: nat)\n ensures i * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_8019","instance":8019,"id":178018,"goal":"lemma LeRefl_8019(x: real)\n ensures x <= x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_8020","instance":8020,"id":178019,"goal":"lemma LeTrans_8020(b: int, m: int, x: int)\n requires b <= m && m <= x\n ensures b <= x\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_8021","instance":8021,"id":178020,"goal":"lemma AddMono_8021(j: nat, i: nat, k: nat)\n requires j <= i\n ensures j + k <= i + k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_8022","instance":8022,"id":178021,"goal":"lemma Abs_Nonneg_8022(y: real)\n ensures (if y >= 0 then y else -y) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_8023","instance":8023,"id":178022,"goal":"lemma DivMod_8023(j: int, c: int)\n requires c > 0\n ensures j == c * (j / c) + (j % c)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_8024","instance":8024,"id":178023,"goal":"lemma ModBounds_8024(b: nat, c: nat)\n requires c > 0\n ensures 0 <= b % c < c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_8025","instance":8025,"id":178024,"goal":"lemma Square_Nonneg_8025(a: real)\n ensures a * a >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_8026","instance":8026,"id":178025,"goal":"lemma AddComm_8026(n: int, a: int)\n ensures n + a == a + n\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_8027","instance":8027,"id":178026,"goal":"lemma AddAssoc_8027(z: nat, j: nat, a: nat)\n ensures (z + j) + a == z + (j + a)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_8028","instance":8028,"id":178027,"goal":"lemma MulComm_8028(m: real, c: real)\n ensures m * c == c * m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_8029","instance":8029,"id":178028,"goal":"lemma MulAssoc_8029(n: int, a: int, b: int)\n ensures (n * a) * b == n * (a * b)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_8030","instance":8030,"id":178029,"goal":"lemma Distrib_8030(z: nat, y: nat, b: nat)\n ensures z * (y + b) == z * y + z * b\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_8031","instance":8031,"id":178030,"goal":"lemma AddZero_8031(y: real)\n ensures y + 0 == y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_8032","instance":8032,"id":178031,"goal":"lemma MulOne_8032(a: int)\n ensures a * 1 == a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_8033","instance":8033,"id":178032,"goal":"lemma MulZero_8033(n: nat)\n ensures n * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_8034","instance":8034,"id":178033,"goal":"lemma LeRefl_8034(z: real)\n ensures z <= z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_8035","instance":8035,"id":178034,"goal":"lemma LeTrans_8035(k: int, y: int, j: int)\n requires k <= y && y <= j\n ensures k <= j\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_8036","instance":8036,"id":178035,"goal":"lemma AddMono_8036(y: nat, c: nat, a: nat)\n requires y <= c\n ensures y + a <= c + a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_8037","instance":8037,"id":178036,"goal":"lemma Abs_Nonneg_8037(k: real)\n ensures (if k >= 0 then k else -k) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_8038","instance":8038,"id":178037,"goal":"lemma DivMod_8038(c: int, a: int)\n requires a > 0\n ensures c == a * (c / a) + (c % a)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_8039","instance":8039,"id":178038,"goal":"lemma ModBounds_8039(y: nat, c: nat)\n requires c > 0\n ensures 0 <= y % c < c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_8040","instance":8040,"id":178039,"goal":"lemma Square_Nonneg_8040(d: real)\n ensures d * d >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_8041","instance":8041,"id":178040,"goal":"lemma AddComm_8041(x: int, z: int)\n ensures x + z == z + x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_8042","instance":8042,"id":178041,"goal":"lemma AddAssoc_8042(z: nat, n: nat, i: nat)\n ensures (z + n) + i == z + (n + i)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_8043","instance":8043,"id":178042,"goal":"lemma MulComm_8043(x: real, j: real)\n ensures x * j == j * x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_8044","instance":8044,"id":178043,"goal":"lemma MulAssoc_8044(j: int, c: int, n: int)\n ensures (j * c) * n == j * (c * n)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_8045","instance":8045,"id":178044,"goal":"lemma Distrib_8045(x: nat, d: nat, b: nat)\n ensures x * (d + b) == x * d + x * b\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_8046","instance":8046,"id":178045,"goal":"lemma AddZero_8046(j: real)\n ensures j + 0 == j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_8047","instance":8047,"id":178046,"goal":"lemma MulOne_8047(z: int)\n ensures z * 1 == z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_8048","instance":8048,"id":178047,"goal":"lemma MulZero_8048(x: nat)\n ensures x * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_8049","instance":8049,"id":178048,"goal":"lemma LeRefl_8049(b: real)\n ensures b <= b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_8050","instance":8050,"id":178049,"goal":"lemma LeTrans_8050(x: int, n: int, i: int)\n requires x <= n && n <= i\n ensures x <= i\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_8051","instance":8051,"id":178050,"goal":"lemma AddMono_8051(d: nat, z: nat, m: nat)\n requires d <= z\n ensures d + m <= z + m\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_8052","instance":8052,"id":178051,"goal":"lemma Abs_Nonneg_8052(b: real)\n ensures (if b >= 0 then b else -b) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_8053","instance":8053,"id":178052,"goal":"lemma DivMod_8053(d: int, i: int)\n requires i > 0\n ensures d == i * (d / i) + (d % i)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_8054","instance":8054,"id":178053,"goal":"lemma ModBounds_8054(i: nat, n: nat)\n requires n > 0\n ensures 0 <= i % n < n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_8055","instance":8055,"id":178054,"goal":"lemma Square_Nonneg_8055(n: real)\n ensures n * n >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_8056","instance":8056,"id":178055,"goal":"lemma AddComm_8056(x: int, c: int)\n ensures x + c == c + x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_8057","instance":8057,"id":178056,"goal":"lemma AddAssoc_8057(x: nat, a: nat, d: nat)\n ensures (x + a) + d == x + (a + d)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_8058","instance":8058,"id":178057,"goal":"lemma MulComm_8058(j: real, b: real)\n ensures j * b == b * j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_8059","instance":8059,"id":178058,"goal":"lemma MulAssoc_8059(c: int, i: int, x: int)\n ensures (c * i) * x == c * (i * x)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_8060","instance":8060,"id":178059,"goal":"lemma Distrib_8060(m: nat, a: nat, d: nat)\n ensures m * (a + d) == m * a + m * d\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_8061","instance":8061,"id":178060,"goal":"lemma AddZero_8061(b: real)\n ensures b + 0 == b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_8062","instance":8062,"id":178061,"goal":"lemma MulOne_8062(m: int)\n ensures m * 1 == m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_8063","instance":8063,"id":178062,"goal":"lemma MulZero_8063(n: nat)\n ensures n * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_8064","instance":8064,"id":178063,"goal":"lemma LeRefl_8064(z: real)\n ensures z <= z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_8065","instance":8065,"id":178064,"goal":"lemma LeTrans_8065(n: int, x: int, d: int)\n requires n <= x && x <= d\n ensures n <= d\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_8066","instance":8066,"id":178065,"goal":"lemma AddMono_8066(j: nat, x: nat, b: nat)\n requires j <= x\n ensures j + b <= x + b\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_8067","instance":8067,"id":178066,"goal":"lemma Abs_Nonneg_8067(i: real)\n ensures (if i >= 0 then i else -i) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_8068","instance":8068,"id":178067,"goal":"lemma DivMod_8068(y: int, d: int)\n requires d > 0\n ensures y == d * (y / d) + (y % d)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_8069","instance":8069,"id":178068,"goal":"lemma ModBounds_8069(m: nat, k: nat)\n requires k > 0\n ensures 0 <= m % k < k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_8070","instance":8070,"id":178069,"goal":"lemma Square_Nonneg_8070(i: real)\n ensures i * i >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_8071","instance":8071,"id":178070,"goal":"lemma AddComm_8071(c: int, d: int)\n ensures c + d == d + c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_8072","instance":8072,"id":178071,"goal":"lemma AddAssoc_8072(z: nat, b: nat, y: nat)\n ensures (z + b) + y == z + (b + y)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_8073","instance":8073,"id":178072,"goal":"lemma MulComm_8073(c: real, z: real)\n ensures c * z == z * c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_8074","instance":8074,"id":178073,"goal":"lemma MulAssoc_8074(c: int, m: int, k: int)\n ensures (c * m) * k == c * (m * k)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_8075","instance":8075,"id":178074,"goal":"lemma Distrib_8075(j: nat, m: nat, d: nat)\n ensures j * (m + d) == j * m + j * d\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_8076","instance":8076,"id":178075,"goal":"lemma AddZero_8076(i: real)\n ensures i + 0 == i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_8077","instance":8077,"id":178076,"goal":"lemma MulOne_8077(a: int)\n ensures a * 1 == a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_8078","instance":8078,"id":178077,"goal":"lemma MulZero_8078(c: nat)\n ensures c * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_8079","instance":8079,"id":178078,"goal":"lemma LeRefl_8079(j: real)\n ensures j <= j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_8080","instance":8080,"id":178079,"goal":"lemma LeTrans_8080(n: int, z: int, b: int)\n requires n <= z && z <= b\n ensures n <= b\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_8081","instance":8081,"id":178080,"goal":"lemma AddMono_8081(b: nat, c: nat, j: nat)\n requires b <= c\n ensures b + j <= c + j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_8082","instance":8082,"id":178081,"goal":"lemma Abs_Nonneg_8082(a: real)\n ensures (if a >= 0 then a else -a) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_8083","instance":8083,"id":178082,"goal":"lemma DivMod_8083(a: int, y: int)\n requires y > 0\n ensures a == y * (a / y) + (a % y)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_8084","instance":8084,"id":178083,"goal":"lemma ModBounds_8084(z: nat, y: nat)\n requires y > 0\n ensures 0 <= z % y < y\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_8085","instance":8085,"id":178084,"goal":"lemma Square_Nonneg_8085(n: real)\n ensures n * n >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_8086","instance":8086,"id":178085,"goal":"lemma AddComm_8086(m: int, y: int)\n ensures m + y == y + m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_8087","instance":8087,"id":178086,"goal":"lemma AddAssoc_8087(y: nat, j: nat, x: nat)\n ensures (y + j) + x == y + (j + x)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_8088","instance":8088,"id":178087,"goal":"lemma MulComm_8088(m: real, j: real)\n ensures m * j == j * m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_8089","instance":8089,"id":178088,"goal":"lemma MulAssoc_8089(j: int, c: int, i: int)\n ensures (j * c) * i == j * (c * i)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_8090","instance":8090,"id":178089,"goal":"lemma Distrib_8090(z: nat, d: nat, a: nat)\n ensures z * (d + a) == z * d + z * a\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_8091","instance":8091,"id":178090,"goal":"lemma AddZero_8091(m: real)\n ensures m + 0 == m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_8092","instance":8092,"id":178091,"goal":"lemma MulOne_8092(a: int)\n ensures a * 1 == a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_8093","instance":8093,"id":178092,"goal":"lemma MulZero_8093(b: nat)\n ensures b * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_8094","instance":8094,"id":178093,"goal":"lemma LeRefl_8094(d: real)\n ensures d <= d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_8095","instance":8095,"id":178094,"goal":"lemma LeTrans_8095(y: int, a: int, i: int)\n requires y <= a && a <= i\n ensures y <= i\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_8096","instance":8096,"id":178095,"goal":"lemma AddMono_8096(y: nat, x: nat, b: nat)\n requires y <= x\n ensures y + b <= x + b\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_8097","instance":8097,"id":178096,"goal":"lemma Abs_Nonneg_8097(m: real)\n ensures (if m >= 0 then m else -m) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_8098","instance":8098,"id":178097,"goal":"lemma DivMod_8098(i: int, b: int)\n requires b > 0\n ensures i == b * (i / b) + (i % b)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_8099","instance":8099,"id":178098,"goal":"lemma ModBounds_8099(z: nat, x: nat)\n requires x > 0\n ensures 0 <= z % x < x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_8100","instance":8100,"id":178099,"goal":"lemma Square_Nonneg_8100(k: real)\n ensures k * k >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_8101","instance":8101,"id":178100,"goal":"lemma AddComm_8101(i: int, d: int)\n ensures i + d == d + i\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_8102","instance":8102,"id":178101,"goal":"lemma AddAssoc_8102(k: nat, j: nat, b: nat)\n ensures (k + j) + b == k + (j + b)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_8103","instance":8103,"id":178102,"goal":"lemma MulComm_8103(d: real, m: real)\n ensures d * m == m * d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_8104","instance":8104,"id":178103,"goal":"lemma MulAssoc_8104(a: int, x: int, i: int)\n ensures (a * x) * i == a * (x * i)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_8105","instance":8105,"id":178104,"goal":"lemma Distrib_8105(m: nat, z: nat, a: nat)\n ensures m * (z + a) == m * z + m * a\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_8106","instance":8106,"id":178105,"goal":"lemma AddZero_8106(z: real)\n ensures z + 0 == z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_8107","instance":8107,"id":178106,"goal":"lemma MulOne_8107(b: int)\n ensures b * 1 == b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_8108","instance":8108,"id":178107,"goal":"lemma MulZero_8108(m: nat)\n ensures m * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_8109","instance":8109,"id":178108,"goal":"lemma LeRefl_8109(k: real)\n ensures k <= k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_8110","instance":8110,"id":178109,"goal":"lemma LeTrans_8110(m: int, k: int, n: int)\n requires m <= k && k <= n\n ensures m <= n\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_8111","instance":8111,"id":178110,"goal":"lemma AddMono_8111(b: nat, m: nat, c: nat)\n requires b <= m\n ensures b + c <= m + c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_8112","instance":8112,"id":178111,"goal":"lemma Abs_Nonneg_8112(n: real)\n ensures (if n >= 0 then n else -n) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_8113","instance":8113,"id":178112,"goal":"lemma DivMod_8113(d: int, z: int)\n requires z > 0\n ensures d == z * (d / z) + (d % z)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_8114","instance":8114,"id":178113,"goal":"lemma ModBounds_8114(y: nat, d: nat)\n requires d > 0\n ensures 0 <= y % d < d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_8115","instance":8115,"id":178114,"goal":"lemma Square_Nonneg_8115(z: real)\n ensures z * z >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_8116","instance":8116,"id":178115,"goal":"lemma AddComm_8116(i: int, j: int)\n ensures i + j == j + i\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_8117","instance":8117,"id":178116,"goal":"lemma AddAssoc_8117(k: nat, m: nat, i: nat)\n ensures (k + m) + i == k + (m + i)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_8118","instance":8118,"id":178117,"goal":"lemma MulComm_8118(k: real, b: real)\n ensures k * b == b * k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_8119","instance":8119,"id":178118,"goal":"lemma MulAssoc_8119(b: int, c: int, d: int)\n ensures (b * c) * d == b * (c * d)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_8120","instance":8120,"id":178119,"goal":"lemma Distrib_8120(i: nat, j: nat, k: nat)\n ensures i * (j + k) == i * j + i * k\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_8121","instance":8121,"id":178120,"goal":"lemma AddZero_8121(b: real)\n ensures b + 0 == b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_8122","instance":8122,"id":178121,"goal":"lemma MulOne_8122(y: int)\n ensures y * 1 == y\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_8123","instance":8123,"id":178122,"goal":"lemma MulZero_8123(y: nat)\n ensures y * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_8124","instance":8124,"id":178123,"goal":"lemma LeRefl_8124(j: real)\n ensures j <= j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_8125","instance":8125,"id":178124,"goal":"lemma LeTrans_8125(z: int, y: int, a: int)\n requires z <= y && y <= a\n ensures z <= a\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_8126","instance":8126,"id":178125,"goal":"lemma AddMono_8126(n: nat, b: nat, z: nat)\n requires n <= b\n ensures n + z <= b + z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_8127","instance":8127,"id":178126,"goal":"lemma Abs_Nonneg_8127(x: real)\n ensures (if x >= 0 then x else -x) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_8128","instance":8128,"id":178127,"goal":"lemma DivMod_8128(n: int, b: int)\n requires b > 0\n ensures n == b * (n / b) + (n % b)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_8129","instance":8129,"id":178128,"goal":"lemma ModBounds_8129(n: nat, d: nat)\n requires d > 0\n ensures 0 <= n % d < d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_8130","instance":8130,"id":178129,"goal":"lemma Square_Nonneg_8130(y: real)\n ensures y * y >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_8131","instance":8131,"id":178130,"goal":"lemma AddComm_8131(d: int, z: int)\n ensures d + z == z + d\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_8132","instance":8132,"id":178131,"goal":"lemma AddAssoc_8132(j: nat, x: nat, b: nat)\n ensures (j + x) + b == j + (x + b)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_8133","instance":8133,"id":178132,"goal":"lemma MulComm_8133(c: real, b: real)\n ensures c * b == b * c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_8134","instance":8134,"id":178133,"goal":"lemma MulAssoc_8134(x: int, k: int, b: int)\n ensures (x * k) * b == x * (k * b)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_8135","instance":8135,"id":178134,"goal":"lemma Distrib_8135(b: nat, n: nat, j: nat)\n ensures b * (n + j) == b * n + b * j\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_8136","instance":8136,"id":178135,"goal":"lemma AddZero_8136(k: real)\n ensures k + 0 == k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_8137","instance":8137,"id":178136,"goal":"lemma MulOne_8137(d: int)\n ensures d * 1 == d\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_8138","instance":8138,"id":178137,"goal":"lemma MulZero_8138(i: nat)\n ensures i * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_8139","instance":8139,"id":178138,"goal":"lemma LeRefl_8139(k: real)\n ensures k <= k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_8140","instance":8140,"id":178139,"goal":"lemma LeTrans_8140(d: int, k: int, m: int)\n requires d <= k && k <= m\n ensures d <= m\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_8141","instance":8141,"id":178140,"goal":"lemma AddMono_8141(m: nat, k: nat, b: nat)\n requires m <= k\n ensures m + b <= k + b\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_8142","instance":8142,"id":178141,"goal":"lemma Abs_Nonneg_8142(m: real)\n ensures (if m >= 0 then m else -m) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_8143","instance":8143,"id":178142,"goal":"lemma DivMod_8143(j: int, y: int)\n requires y > 0\n ensures j == y * (j / y) + (j % y)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_8144","instance":8144,"id":178143,"goal":"lemma ModBounds_8144(i: nat, x: nat)\n requires x > 0\n ensures 0 <= i % x < x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_8145","instance":8145,"id":178144,"goal":"lemma Square_Nonneg_8145(j: real)\n ensures j * j >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_8146","instance":8146,"id":178145,"goal":"lemma AddComm_8146(c: int, a: int)\n ensures c + a == a + c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_8147","instance":8147,"id":178146,"goal":"lemma AddAssoc_8147(k: nat, j: nat, c: nat)\n ensures (k + j) + c == k + (j + c)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_8148","instance":8148,"id":178147,"goal":"lemma MulComm_8148(a: real, y: real)\n ensures a * y == y * a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_8149","instance":8149,"id":178148,"goal":"lemma MulAssoc_8149(j: int, x: int, n: int)\n ensures (j * x) * n == j * (x * n)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_8150","instance":8150,"id":178149,"goal":"lemma Distrib_8150(z: nat, m: nat, j: nat)\n ensures z * (m + j) == z * m + z * j\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_8151","instance":8151,"id":178150,"goal":"lemma AddZero_8151(x: real)\n ensures x + 0 == x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_8152","instance":8152,"id":178151,"goal":"lemma MulOne_8152(z: int)\n ensures z * 1 == z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_8153","instance":8153,"id":178152,"goal":"lemma MulZero_8153(n: nat)\n ensures n * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_8154","instance":8154,"id":178153,"goal":"lemma LeRefl_8154(c: real)\n ensures c <= c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_8155","instance":8155,"id":178154,"goal":"lemma LeTrans_8155(b: int, k: int, a: int)\n requires b <= k && k <= a\n ensures b <= a\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_8156","instance":8156,"id":178155,"goal":"lemma AddMono_8156(c: nat, i: nat, z: nat)\n requires c <= i\n ensures c + z <= i + z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_8157","instance":8157,"id":178156,"goal":"lemma Abs_Nonneg_8157(c: real)\n ensures (if c >= 0 then c else -c) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_8158","instance":8158,"id":178157,"goal":"lemma DivMod_8158(m: int, j: int)\n requires j > 0\n ensures m == j * (m / j) + (m % j)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_8159","instance":8159,"id":178158,"goal":"lemma ModBounds_8159(a: nat, z: nat)\n requires z > 0\n ensures 0 <= a % z < z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_8160","instance":8160,"id":178159,"goal":"lemma Square_Nonneg_8160(i: real)\n ensures i * i >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_8161","instance":8161,"id":178160,"goal":"lemma AddComm_8161(z: int, x: int)\n ensures z + x == x + z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_8162","instance":8162,"id":178161,"goal":"lemma AddAssoc_8162(a: nat, n: nat, x: nat)\n ensures (a + n) + x == a + (n + x)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_8163","instance":8163,"id":178162,"goal":"lemma MulComm_8163(k: real, a: real)\n ensures k * a == a * k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_8164","instance":8164,"id":178163,"goal":"lemma MulAssoc_8164(m: int, n: int, j: int)\n ensures (m * n) * j == m * (n * j)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_8165","instance":8165,"id":178164,"goal":"lemma Distrib_8165(z: nat, c: nat, i: nat)\n ensures z * (c + i) == z * c + z * i\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_8166","instance":8166,"id":178165,"goal":"lemma AddZero_8166(i: real)\n ensures i + 0 == i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_8167","instance":8167,"id":178166,"goal":"lemma MulOne_8167(z: int)\n ensures z * 1 == z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_8168","instance":8168,"id":178167,"goal":"lemma MulZero_8168(x: nat)\n ensures x * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_8169","instance":8169,"id":178168,"goal":"lemma LeRefl_8169(x: real)\n ensures x <= x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_8170","instance":8170,"id":178169,"goal":"lemma LeTrans_8170(a: int, z: int, n: int)\n requires a <= z && z <= n\n ensures a <= n\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_8171","instance":8171,"id":178170,"goal":"lemma AddMono_8171(a: nat, m: nat, n: nat)\n requires a <= m\n ensures a + n <= m + n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_8172","instance":8172,"id":178171,"goal":"lemma Abs_Nonneg_8172(b: real)\n ensures (if b >= 0 then b else -b) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_8173","instance":8173,"id":178172,"goal":"lemma DivMod_8173(k: int, n: int)\n requires n > 0\n ensures k == n * (k / n) + (k % n)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_8174","instance":8174,"id":178173,"goal":"lemma ModBounds_8174(b: nat, a: nat)\n requires a > 0\n ensures 0 <= b % a < a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_8175","instance":8175,"id":178174,"goal":"lemma Square_Nonneg_8175(c: real)\n ensures c * c >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_8176","instance":8176,"id":178175,"goal":"lemma AddComm_8176(m: int, j: int)\n ensures m + j == j + m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_8177","instance":8177,"id":178176,"goal":"lemma AddAssoc_8177(a: nat, y: nat, m: nat)\n ensures (a + y) + m == a + (y + m)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_8178","instance":8178,"id":178177,"goal":"lemma MulComm_8178(k: real, d: real)\n ensures k * d == d * k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_8179","instance":8179,"id":178178,"goal":"lemma MulAssoc_8179(c: int, d: int, m: int)\n ensures (c * d) * m == c * (d * m)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_8180","instance":8180,"id":178179,"goal":"lemma Distrib_8180(i: nat, k: nat, m: nat)\n ensures i * (k + m) == i * k + i * m\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_8181","instance":8181,"id":178180,"goal":"lemma AddZero_8181(x: real)\n ensures x + 0 == x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_8182","instance":8182,"id":178181,"goal":"lemma MulOne_8182(c: int)\n ensures c * 1 == c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_8183","instance":8183,"id":178182,"goal":"lemma MulZero_8183(x: nat)\n ensures x * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_8184","instance":8184,"id":178183,"goal":"lemma LeRefl_8184(i: real)\n ensures i <= i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_8185","instance":8185,"id":178184,"goal":"lemma LeTrans_8185(b: int, y: int, a: int)\n requires b <= y && y <= a\n ensures b <= a\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_8186","instance":8186,"id":178185,"goal":"lemma AddMono_8186(k: nat, z: nat, m: nat)\n requires k <= z\n ensures k + m <= z + m\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_8187","instance":8187,"id":178186,"goal":"lemma Abs_Nonneg_8187(i: real)\n ensures (if i >= 0 then i else -i) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_8188","instance":8188,"id":178187,"goal":"lemma DivMod_8188(b: int, z: int)\n requires z > 0\n ensures b == z * (b / z) + (b % z)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_8189","instance":8189,"id":178188,"goal":"lemma ModBounds_8189(i: nat, m: nat)\n requires m > 0\n ensures 0 <= i % m < m\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_8190","instance":8190,"id":178189,"goal":"lemma Square_Nonneg_8190(k: real)\n ensures k * k >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_8191","instance":8191,"id":178190,"goal":"lemma AddComm_8191(i: int, a: int)\n ensures i + a == a + i\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_8192","instance":8192,"id":178191,"goal":"lemma AddAssoc_8192(y: nat, z: nat, n: nat)\n ensures (y + z) + n == y + (z + n)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_8193","instance":8193,"id":178192,"goal":"lemma MulComm_8193(x: real, d: real)\n ensures x * d == d * x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_8194","instance":8194,"id":178193,"goal":"lemma MulAssoc_8194(i: int, c: int, x: int)\n ensures (i * c) * x == i * (c * x)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_8195","instance":8195,"id":178194,"goal":"lemma Distrib_8195(z: nat, n: nat, m: nat)\n ensures z * (n + m) == z * n + z * m\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_8196","instance":8196,"id":178195,"goal":"lemma AddZero_8196(d: real)\n ensures d + 0 == d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_8197","instance":8197,"id":178196,"goal":"lemma MulOne_8197(b: int)\n ensures b * 1 == b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_8198","instance":8198,"id":178197,"goal":"lemma MulZero_8198(j: nat)\n ensures j * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_8199","instance":8199,"id":178198,"goal":"lemma LeRefl_8199(d: real)\n ensures d <= d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_8200","instance":8200,"id":178199,"goal":"lemma LeTrans_8200(m: int, j: int, d: int)\n requires m <= j && j <= d\n ensures m <= d\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_8201","instance":8201,"id":178200,"goal":"lemma AddMono_8201(j: nat, a: nat, x: nat)\n requires j <= a\n ensures j + x <= a + x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_8202","instance":8202,"id":178201,"goal":"lemma Abs_Nonneg_8202(m: real)\n ensures (if m >= 0 then m else -m) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_8203","instance":8203,"id":178202,"goal":"lemma DivMod_8203(i: int, k: int)\n requires k > 0\n ensures i == k * (i / k) + (i % k)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_8204","instance":8204,"id":178203,"goal":"lemma ModBounds_8204(b: nat, c: nat)\n requires c > 0\n ensures 0 <= b % c < c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_8205","instance":8205,"id":178204,"goal":"lemma Square_Nonneg_8205(y: real)\n ensures y * y >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_8206","instance":8206,"id":178205,"goal":"lemma AddComm_8206(j: int, c: int)\n ensures j + c == c + j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_8207","instance":8207,"id":178206,"goal":"lemma AddAssoc_8207(i: nat, a: nat, b: nat)\n ensures (i + a) + b == i + (a + b)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_8208","instance":8208,"id":178207,"goal":"lemma MulComm_8208(d: real, c: real)\n ensures d * c == c * d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_8209","instance":8209,"id":178208,"goal":"lemma MulAssoc_8209(n: int, j: int, m: int)\n ensures (n * j) * m == n * (j * m)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_8210","instance":8210,"id":178209,"goal":"lemma Distrib_8210(j: nat, d: nat, y: nat)\n ensures j * (d + y) == j * d + j * y\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_8211","instance":8211,"id":178210,"goal":"lemma AddZero_8211(n: real)\n ensures n + 0 == n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_8212","instance":8212,"id":178211,"goal":"lemma MulOne_8212(n: int)\n ensures n * 1 == n\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_8213","instance":8213,"id":178212,"goal":"lemma MulZero_8213(a: nat)\n ensures a * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_8214","instance":8214,"id":178213,"goal":"lemma LeRefl_8214(j: real)\n ensures j <= j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_8215","instance":8215,"id":178214,"goal":"lemma LeTrans_8215(c: int, x: int, i: int)\n requires c <= x && x <= i\n ensures c <= i\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_8216","instance":8216,"id":178215,"goal":"lemma AddMono_8216(z: nat, m: nat, j: nat)\n requires z <= m\n ensures z + j <= m + j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_8217","instance":8217,"id":178216,"goal":"lemma Abs_Nonneg_8217(d: real)\n ensures (if d >= 0 then d else -d) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_8218","instance":8218,"id":178217,"goal":"lemma DivMod_8218(j: int, z: int)\n requires z > 0\n ensures j == z * (j / z) + (j % z)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_8219","instance":8219,"id":178218,"goal":"lemma ModBounds_8219(d: nat, n: nat)\n requires n > 0\n ensures 0 <= d % n < n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_8220","instance":8220,"id":178219,"goal":"lemma Square_Nonneg_8220(c: real)\n ensures c * c >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_8221","instance":8221,"id":178220,"goal":"lemma AddComm_8221(m: int, k: int)\n ensures m + k == k + m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_8222","instance":8222,"id":178221,"goal":"lemma AddAssoc_8222(a: nat, z: nat, j: nat)\n ensures (a + z) + j == a + (z + j)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_8223","instance":8223,"id":178222,"goal":"lemma MulComm_8223(z: real, m: real)\n ensures z * m == m * z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_8224","instance":8224,"id":178223,"goal":"lemma MulAssoc_8224(c: int, k: int, z: int)\n ensures (c * k) * z == c * (k * z)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_8225","instance":8225,"id":178224,"goal":"lemma Distrib_8225(k: nat, c: nat, a: nat)\n ensures k * (c + a) == k * c + k * a\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_8226","instance":8226,"id":178225,"goal":"lemma AddZero_8226(z: real)\n ensures z + 0 == z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_8227","instance":8227,"id":178226,"goal":"lemma MulOne_8227(d: int)\n ensures d * 1 == d\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_8228","instance":8228,"id":178227,"goal":"lemma MulZero_8228(i: nat)\n ensures i * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_8229","instance":8229,"id":178228,"goal":"lemma LeRefl_8229(a: real)\n ensures a <= a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_8230","instance":8230,"id":178229,"goal":"lemma LeTrans_8230(n: int, z: int, a: int)\n requires n <= z && z <= a\n ensures n <= a\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_8231","instance":8231,"id":178230,"goal":"lemma AddMono_8231(b: nat, n: nat, a: nat)\n requires b <= n\n ensures b + a <= n + a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_8232","instance":8232,"id":178231,"goal":"lemma Abs_Nonneg_8232(a: real)\n ensures (if a >= 0 then a else -a) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_8233","instance":8233,"id":178232,"goal":"lemma DivMod_8233(m: int, j: int)\n requires j > 0\n ensures m == j * (m / j) + (m % j)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_8234","instance":8234,"id":178233,"goal":"lemma ModBounds_8234(j: nat, m: nat)\n requires m > 0\n ensures 0 <= j % m < m\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_8235","instance":8235,"id":178234,"goal":"lemma Square_Nonneg_8235(a: real)\n ensures a * a >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_8236","instance":8236,"id":178235,"goal":"lemma AddComm_8236(c: int, i: int)\n ensures c + i == i + c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_8237","instance":8237,"id":178236,"goal":"lemma AddAssoc_8237(a: nat, y: nat, c: nat)\n ensures (a + y) + c == a + (y + c)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_8238","instance":8238,"id":178237,"goal":"lemma MulComm_8238(d: real, k: real)\n ensures d * k == k * d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_8239","instance":8239,"id":178238,"goal":"lemma MulAssoc_8239(i: int, y: int, b: int)\n ensures (i * y) * b == i * (y * b)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_8240","instance":8240,"id":178239,"goal":"lemma Distrib_8240(k: nat, x: nat, z: nat)\n ensures k * (x + z) == k * x + k * z\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_8241","instance":8241,"id":178240,"goal":"lemma AddZero_8241(j: real)\n ensures j + 0 == j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_8242","instance":8242,"id":178241,"goal":"lemma MulOne_8242(a: int)\n ensures a * 1 == a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_8243","instance":8243,"id":178242,"goal":"lemma MulZero_8243(n: nat)\n ensures n * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_8244","instance":8244,"id":178243,"goal":"lemma LeRefl_8244(d: real)\n ensures d <= d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_8245","instance":8245,"id":178244,"goal":"lemma LeTrans_8245(x: int, m: int, i: int)\n requires x <= m && m <= i\n ensures x <= i\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_8246","instance":8246,"id":178245,"goal":"lemma AddMono_8246(k: nat, n: nat, m: nat)\n requires k <= n\n ensures k + m <= n + m\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_8247","instance":8247,"id":178246,"goal":"lemma Abs_Nonneg_8247(a: real)\n ensures (if a >= 0 then a else -a) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_8248","instance":8248,"id":178247,"goal":"lemma DivMod_8248(y: int, b: int)\n requires b > 0\n ensures y == b * (y / b) + (y % b)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_8249","instance":8249,"id":178248,"goal":"lemma ModBounds_8249(b: nat, a: nat)\n requires a > 0\n ensures 0 <= b % a < a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_8250","instance":8250,"id":178249,"goal":"lemma Square_Nonneg_8250(x: real)\n ensures x * x >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_8251","instance":8251,"id":178250,"goal":"lemma AddComm_8251(i: int, a: int)\n ensures i + a == a + i\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_8252","instance":8252,"id":178251,"goal":"lemma AddAssoc_8252(y: nat, m: nat, k: nat)\n ensures (y + m) + k == y + (m + k)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_8253","instance":8253,"id":178252,"goal":"lemma MulComm_8253(a: real, k: real)\n ensures a * k == k * a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_8254","instance":8254,"id":178253,"goal":"lemma MulAssoc_8254(n: int, k: int, z: int)\n ensures (n * k) * z == n * (k * z)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_8255","instance":8255,"id":178254,"goal":"lemma Distrib_8255(x: nat, z: nat, d: nat)\n ensures x * (z + d) == x * z + x * d\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_8256","instance":8256,"id":178255,"goal":"lemma AddZero_8256(m: real)\n ensures m + 0 == m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_8257","instance":8257,"id":178256,"goal":"lemma MulOne_8257(c: int)\n ensures c * 1 == c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_8258","instance":8258,"id":178257,"goal":"lemma MulZero_8258(b: nat)\n ensures b * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_8259","instance":8259,"id":178258,"goal":"lemma LeRefl_8259(n: real)\n ensures n <= n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_8260","instance":8260,"id":178259,"goal":"lemma LeTrans_8260(b: int, z: int, x: int)\n requires b <= z && z <= x\n ensures b <= x\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_8261","instance":8261,"id":178260,"goal":"lemma AddMono_8261(b: nat, m: nat, c: nat)\n requires b <= m\n ensures b + c <= m + c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_8262","instance":8262,"id":178261,"goal":"lemma Abs_Nonneg_8262(k: real)\n ensures (if k >= 0 then k else -k) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_8263","instance":8263,"id":178262,"goal":"lemma DivMod_8263(x: int, b: int)\n requires b > 0\n ensures x == b * (x / b) + (x % b)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_8264","instance":8264,"id":178263,"goal":"lemma ModBounds_8264(x: nat, c: nat)\n requires c > 0\n ensures 0 <= x % c < c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_8265","instance":8265,"id":178264,"goal":"lemma Square_Nonneg_8265(j: real)\n ensures j * j >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_8266","instance":8266,"id":178265,"goal":"lemma AddComm_8266(j: int, a: int)\n ensures j + a == a + j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_8267","instance":8267,"id":178266,"goal":"lemma AddAssoc_8267(a: nat, d: nat, n: nat)\n ensures (a + d) + n == a + (d + n)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_8268","instance":8268,"id":178267,"goal":"lemma MulComm_8268(x: real, d: real)\n ensures x * d == d * x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_8269","instance":8269,"id":178268,"goal":"lemma MulAssoc_8269(i: int, d: int, c: int)\n ensures (i * d) * c == i * (d * c)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_8270","instance":8270,"id":178269,"goal":"lemma Distrib_8270(d: nat, b: nat, j: nat)\n ensures d * (b + j) == d * b + d * j\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_8271","instance":8271,"id":178270,"goal":"lemma AddZero_8271(z: real)\n ensures z + 0 == z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_8272","instance":8272,"id":178271,"goal":"lemma MulOne_8272(i: int)\n ensures i * 1 == i\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_8273","instance":8273,"id":178272,"goal":"lemma MulZero_8273(z: nat)\n ensures z * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_8274","instance":8274,"id":178273,"goal":"lemma LeRefl_8274(c: real)\n ensures c <= c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_8275","instance":8275,"id":178274,"goal":"lemma LeTrans_8275(m: int, n: int, z: int)\n requires m <= n && n <= z\n ensures m <= z\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_8276","instance":8276,"id":178275,"goal":"lemma AddMono_8276(b: nat, y: nat, z: nat)\n requires b <= y\n ensures b + z <= y + z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_8277","instance":8277,"id":178276,"goal":"lemma Abs_Nonneg_8277(d: real)\n ensures (if d >= 0 then d else -d) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_8278","instance":8278,"id":178277,"goal":"lemma DivMod_8278(i: int, j: int)\n requires j > 0\n ensures i == j * (i / j) + (i % j)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_8279","instance":8279,"id":178278,"goal":"lemma ModBounds_8279(d: nat, y: nat)\n requires y > 0\n ensures 0 <= d % y < y\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_8280","instance":8280,"id":178279,"goal":"lemma Square_Nonneg_8280(x: real)\n ensures x * x >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_8281","instance":8281,"id":178280,"goal":"lemma AddComm_8281(j: int, y: int)\n ensures j + y == y + j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_8282","instance":8282,"id":178281,"goal":"lemma AddAssoc_8282(d: nat, n: nat, z: nat)\n ensures (d + n) + z == d + (n + z)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_8283","instance":8283,"id":178282,"goal":"lemma MulComm_8283(i: real, d: real)\n ensures i * d == d * i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_8284","instance":8284,"id":178283,"goal":"lemma MulAssoc_8284(y: int, n: int, a: int)\n ensures (y * n) * a == y * (n * a)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_8285","instance":8285,"id":178284,"goal":"lemma Distrib_8285(m: nat, x: nat, a: nat)\n ensures m * (x + a) == m * x + m * a\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_8286","instance":8286,"id":178285,"goal":"lemma AddZero_8286(a: real)\n ensures a + 0 == a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_8287","instance":8287,"id":178286,"goal":"lemma MulOne_8287(c: int)\n ensures c * 1 == c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_8288","instance":8288,"id":178287,"goal":"lemma MulZero_8288(x: nat)\n ensures x * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_8289","instance":8289,"id":178288,"goal":"lemma LeRefl_8289(y: real)\n ensures y <= y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_8290","instance":8290,"id":178289,"goal":"lemma LeTrans_8290(m: int, y: int, k: int)\n requires m <= y && y <= k\n ensures m <= k\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_8291","instance":8291,"id":178290,"goal":"lemma AddMono_8291(j: nat, i: nat, y: nat)\n requires j <= i\n ensures j + y <= i + y\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_8292","instance":8292,"id":178291,"goal":"lemma Abs_Nonneg_8292(a: real)\n ensures (if a >= 0 then a else -a) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_8293","instance":8293,"id":178292,"goal":"lemma DivMod_8293(b: int, j: int)\n requires j > 0\n ensures b == j * (b / j) + (b % j)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_8294","instance":8294,"id":178293,"goal":"lemma ModBounds_8294(c: nat, k: nat)\n requires k > 0\n ensures 0 <= c % k < k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_8295","instance":8295,"id":178294,"goal":"lemma Square_Nonneg_8295(d: real)\n ensures d * d >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_8296","instance":8296,"id":178295,"goal":"lemma AddComm_8296(x: int, a: int)\n ensures x + a == a + x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_8297","instance":8297,"id":178296,"goal":"lemma AddAssoc_8297(c: nat, x: nat, i: nat)\n ensures (c + x) + i == c + (x + i)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_8298","instance":8298,"id":178297,"goal":"lemma MulComm_8298(b: real, y: real)\n ensures b * y == y * b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_8299","instance":8299,"id":178298,"goal":"lemma MulAssoc_8299(a: int, z: int, b: int)\n ensures (a * z) * b == a * (z * b)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_8300","instance":8300,"id":178299,"goal":"lemma Distrib_8300(b: nat, i: nat, n: nat)\n ensures b * (i + n) == b * i + b * n\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_8301","instance":8301,"id":178300,"goal":"lemma AddZero_8301(n: real)\n ensures n + 0 == n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_8302","instance":8302,"id":178301,"goal":"lemma MulOne_8302(n: int)\n ensures n * 1 == n\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_8303","instance":8303,"id":178302,"goal":"lemma MulZero_8303(d: nat)\n ensures d * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_8304","instance":8304,"id":178303,"goal":"lemma LeRefl_8304(y: real)\n ensures y <= y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_8305","instance":8305,"id":178304,"goal":"lemma LeTrans_8305(n: int, b: int, c: int)\n requires n <= b && b <= c\n ensures n <= c\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_8306","instance":8306,"id":178305,"goal":"lemma AddMono_8306(x: nat, m: nat, a: nat)\n requires x <= m\n ensures x + a <= m + a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_8307","instance":8307,"id":178306,"goal":"lemma Abs_Nonneg_8307(i: real)\n ensures (if i >= 0 then i else -i) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_8308","instance":8308,"id":178307,"goal":"lemma DivMod_8308(y: int, k: int)\n requires k > 0\n ensures y == k * (y / k) + (y % k)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_8309","instance":8309,"id":178308,"goal":"lemma ModBounds_8309(i: nat, z: nat)\n requires z > 0\n ensures 0 <= i % z < z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_8310","instance":8310,"id":178309,"goal":"lemma Square_Nonneg_8310(b: real)\n ensures b * b >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_8311","instance":8311,"id":178310,"goal":"lemma AddComm_8311(m: int, y: int)\n ensures m + y == y + m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_8312","instance":8312,"id":178311,"goal":"lemma AddAssoc_8312(y: nat, m: nat, n: nat)\n ensures (y + m) + n == y + (m + n)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_8313","instance":8313,"id":178312,"goal":"lemma MulComm_8313(n: real, d: real)\n ensures n * d == d * n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_8314","instance":8314,"id":178313,"goal":"lemma MulAssoc_8314(m: int, b: int, y: int)\n ensures (m * b) * y == m * (b * y)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_8315","instance":8315,"id":178314,"goal":"lemma Distrib_8315(c: nat, n: nat, k: nat)\n ensures c * (n + k) == c * n + c * k\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_8316","instance":8316,"id":178315,"goal":"lemma AddZero_8316(z: real)\n ensures z + 0 == z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_8317","instance":8317,"id":178316,"goal":"lemma MulOne_8317(a: int)\n ensures a * 1 == a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_8318","instance":8318,"id":178317,"goal":"lemma MulZero_8318(z: nat)\n ensures z * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_8319","instance":8319,"id":178318,"goal":"lemma LeRefl_8319(a: real)\n ensures a <= a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_8320","instance":8320,"id":178319,"goal":"lemma LeTrans_8320(x: int, d: int, m: int)\n requires x <= d && d <= m\n ensures x <= m\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_8321","instance":8321,"id":178320,"goal":"lemma AddMono_8321(j: nat, i: nat, a: nat)\n requires j <= i\n ensures j + a <= i + a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_8322","instance":8322,"id":178321,"goal":"lemma Abs_Nonneg_8322(d: real)\n ensures (if d >= 0 then d else -d) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_8323","instance":8323,"id":178322,"goal":"lemma DivMod_8323(c: int, z: int)\n requires z > 0\n ensures c == z * (c / z) + (c % z)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_8324","instance":8324,"id":178323,"goal":"lemma ModBounds_8324(n: nat, c: nat)\n requires c > 0\n ensures 0 <= n % c < c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_8325","instance":8325,"id":178324,"goal":"lemma Square_Nonneg_8325(x: real)\n ensures x * x >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_8326","instance":8326,"id":178325,"goal":"lemma AddComm_8326(y: int, m: int)\n ensures y + m == m + y\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_8327","instance":8327,"id":178326,"goal":"lemma AddAssoc_8327(y: nat, b: nat, k: nat)\n ensures (y + b) + k == y + (b + k)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_8328","instance":8328,"id":178327,"goal":"lemma MulComm_8328(n: real, b: real)\n ensures n * b == b * n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_8329","instance":8329,"id":178328,"goal":"lemma MulAssoc_8329(j: int, z: int, b: int)\n ensures (j * z) * b == j * (z * b)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_8330","instance":8330,"id":178329,"goal":"lemma Distrib_8330(d: nat, z: nat, x: nat)\n ensures d * (z + x) == d * z + d * x\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_8331","instance":8331,"id":178330,"goal":"lemma AddZero_8331(d: real)\n ensures d + 0 == d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_8332","instance":8332,"id":178331,"goal":"lemma MulOne_8332(i: int)\n ensures i * 1 == i\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_8333","instance":8333,"id":178332,"goal":"lemma MulZero_8333(d: nat)\n ensures d * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_8334","instance":8334,"id":178333,"goal":"lemma LeRefl_8334(b: real)\n ensures b <= b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_8335","instance":8335,"id":178334,"goal":"lemma LeTrans_8335(k: int, d: int, n: int)\n requires k <= d && d <= n\n ensures k <= n\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_8336","instance":8336,"id":178335,"goal":"lemma AddMono_8336(k: nat, m: nat, y: nat)\n requires k <= m\n ensures k + y <= m + y\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_8337","instance":8337,"id":178336,"goal":"lemma Abs_Nonneg_8337(j: real)\n ensures (if j >= 0 then j else -j) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_8338","instance":8338,"id":178337,"goal":"lemma DivMod_8338(z: int, a: int)\n requires a > 0\n ensures z == a * (z / a) + (z % a)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_8339","instance":8339,"id":178338,"goal":"lemma ModBounds_8339(a: nat, x: nat)\n requires x > 0\n ensures 0 <= a % x < x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_8340","instance":8340,"id":178339,"goal":"lemma Square_Nonneg_8340(k: real)\n ensures k * k >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_8341","instance":8341,"id":178340,"goal":"lemma AddComm_8341(j: int, c: int)\n ensures j + c == c + j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_8342","instance":8342,"id":178341,"goal":"lemma AddAssoc_8342(j: nat, d: nat, k: nat)\n ensures (j + d) + k == j + (d + k)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_8343","instance":8343,"id":178342,"goal":"lemma MulComm_8343(z: real, i: real)\n ensures z * i == i * z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_8344","instance":8344,"id":178343,"goal":"lemma MulAssoc_8344(m: int, k: int, x: int)\n ensures (m * k) * x == m * (k * x)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_8345","instance":8345,"id":178344,"goal":"lemma Distrib_8345(c: nat, i: nat, x: nat)\n ensures c * (i + x) == c * i + c * x\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_8346","instance":8346,"id":178345,"goal":"lemma AddZero_8346(a: real)\n ensures a + 0 == a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_8347","instance":8347,"id":178346,"goal":"lemma MulOne_8347(c: int)\n ensures c * 1 == c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_8348","instance":8348,"id":178347,"goal":"lemma MulZero_8348(c: nat)\n ensures c * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_8349","instance":8349,"id":178348,"goal":"lemma LeRefl_8349(a: real)\n ensures a <= a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_8350","instance":8350,"id":178349,"goal":"lemma LeTrans_8350(a: int, z: int, k: int)\n requires a <= z && z <= k\n ensures a <= k\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_8351","instance":8351,"id":178350,"goal":"lemma AddMono_8351(m: nat, i: nat, k: nat)\n requires m <= i\n ensures m + k <= i + k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_8352","instance":8352,"id":178351,"goal":"lemma Abs_Nonneg_8352(b: real)\n ensures (if b >= 0 then b else -b) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_8353","instance":8353,"id":178352,"goal":"lemma DivMod_8353(j: int, y: int)\n requires y > 0\n ensures j == y * (j / y) + (j % y)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_8354","instance":8354,"id":178353,"goal":"lemma ModBounds_8354(y: nat, a: nat)\n requires a > 0\n ensures 0 <= y % a < a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_8355","instance":8355,"id":178354,"goal":"lemma Square_Nonneg_8355(n: real)\n ensures n * n >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_8356","instance":8356,"id":178355,"goal":"lemma AddComm_8356(n: int, x: int)\n ensures n + x == x + n\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_8357","instance":8357,"id":178356,"goal":"lemma AddAssoc_8357(n: nat, x: nat, i: nat)\n ensures (n + x) + i == n + (x + i)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_8358","instance":8358,"id":178357,"goal":"lemma MulComm_8358(b: real, k: real)\n ensures b * k == k * b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_8359","instance":8359,"id":178358,"goal":"lemma MulAssoc_8359(n: int, a: int, y: int)\n ensures (n * a) * y == n * (a * y)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_8360","instance":8360,"id":178359,"goal":"lemma Distrib_8360(b: nat, d: nat, y: nat)\n ensures b * (d + y) == b * d + b * y\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_8361","instance":8361,"id":178360,"goal":"lemma AddZero_8361(j: real)\n ensures j + 0 == j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_8362","instance":8362,"id":178361,"goal":"lemma MulOne_8362(k: int)\n ensures k * 1 == k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_8363","instance":8363,"id":178362,"goal":"lemma MulZero_8363(m: nat)\n ensures m * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_8364","instance":8364,"id":178363,"goal":"lemma LeRefl_8364(n: real)\n ensures n <= n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_8365","instance":8365,"id":178364,"goal":"lemma LeTrans_8365(d: int, k: int, n: int)\n requires d <= k && k <= n\n ensures d <= n\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_8366","instance":8366,"id":178365,"goal":"lemma AddMono_8366(z: nat, k: nat, j: nat)\n requires z <= k\n ensures z + j <= k + j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_8367","instance":8367,"id":178366,"goal":"lemma Abs_Nonneg_8367(j: real)\n ensures (if j >= 0 then j else -j) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_8368","instance":8368,"id":178367,"goal":"lemma DivMod_8368(x: int, b: int)\n requires b > 0\n ensures x == b * (x / b) + (x % b)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_8369","instance":8369,"id":178368,"goal":"lemma ModBounds_8369(j: nat, d: nat)\n requires d > 0\n ensures 0 <= j % d < d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_8370","instance":8370,"id":178369,"goal":"lemma Square_Nonneg_8370(z: real)\n ensures z * z >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_8371","instance":8371,"id":178370,"goal":"lemma AddComm_8371(y: int, m: int)\n ensures y + m == m + y\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_8372","instance":8372,"id":178371,"goal":"lemma AddAssoc_8372(a: nat, y: nat, x: nat)\n ensures (a + y) + x == a + (y + x)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_8373","instance":8373,"id":178372,"goal":"lemma MulComm_8373(k: real, c: real)\n ensures k * c == c * k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_8374","instance":8374,"id":178373,"goal":"lemma MulAssoc_8374(y: int, c: int, b: int)\n ensures (y * c) * b == y * (c * b)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_8375","instance":8375,"id":178374,"goal":"lemma Distrib_8375(y: nat, n: nat, z: nat)\n ensures y * (n + z) == y * n + y * z\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_8376","instance":8376,"id":178375,"goal":"lemma AddZero_8376(y: real)\n ensures y + 0 == y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_8377","instance":8377,"id":178376,"goal":"lemma MulOne_8377(x: int)\n ensures x * 1 == x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_8378","instance":8378,"id":178377,"goal":"lemma MulZero_8378(m: nat)\n ensures m * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_8379","instance":8379,"id":178378,"goal":"lemma LeRefl_8379(c: real)\n ensures c <= c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_8380","instance":8380,"id":178379,"goal":"lemma LeTrans_8380(k: int, z: int, b: int)\n requires k <= z && z <= b\n ensures k <= b\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_8381","instance":8381,"id":178380,"goal":"lemma AddMono_8381(k: nat, n: nat, b: nat)\n requires k <= n\n ensures k + b <= n + b\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_8382","instance":8382,"id":178381,"goal":"lemma Abs_Nonneg_8382(i: real)\n ensures (if i >= 0 then i else -i) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_8383","instance":8383,"id":178382,"goal":"lemma DivMod_8383(m: int, a: int)\n requires a > 0\n ensures m == a * (m / a) + (m % a)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_8384","instance":8384,"id":178383,"goal":"lemma ModBounds_8384(n: nat, c: nat)\n requires c > 0\n ensures 0 <= n % c < c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_8385","instance":8385,"id":178384,"goal":"lemma Square_Nonneg_8385(k: real)\n ensures k * k >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_8386","instance":8386,"id":178385,"goal":"lemma AddComm_8386(y: int, x: int)\n ensures y + x == x + y\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_8387","instance":8387,"id":178386,"goal":"lemma AddAssoc_8387(x: nat, k: nat, m: nat)\n ensures (x + k) + m == x + (k + m)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_8388","instance":8388,"id":178387,"goal":"lemma MulComm_8388(x: real, j: real)\n ensures x * j == j * x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_8389","instance":8389,"id":178388,"goal":"lemma MulAssoc_8389(c: int, x: int, m: int)\n ensures (c * x) * m == c * (x * m)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_8390","instance":8390,"id":178389,"goal":"lemma Distrib_8390(n: nat, i: nat, z: nat)\n ensures n * (i + z) == n * i + n * z\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_8391","instance":8391,"id":178390,"goal":"lemma AddZero_8391(x: real)\n ensures x + 0 == x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_8392","instance":8392,"id":178391,"goal":"lemma MulOne_8392(j: int)\n ensures j * 1 == j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_8393","instance":8393,"id":178392,"goal":"lemma MulZero_8393(k: nat)\n ensures k * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_8394","instance":8394,"id":178393,"goal":"lemma LeRefl_8394(z: real)\n ensures z <= z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_8395","instance":8395,"id":178394,"goal":"lemma LeTrans_8395(n: int, d: int, a: int)\n requires n <= d && d <= a\n ensures n <= a\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_8396","instance":8396,"id":178395,"goal":"lemma AddMono_8396(j: nat, z: nat, m: nat)\n requires j <= z\n ensures j + m <= z + m\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_8397","instance":8397,"id":178396,"goal":"lemma Abs_Nonneg_8397(m: real)\n ensures (if m >= 0 then m else -m) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_8398","instance":8398,"id":178397,"goal":"lemma DivMod_8398(n: int, a: int)\n requires a > 0\n ensures n == a * (n / a) + (n % a)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_8399","instance":8399,"id":178398,"goal":"lemma ModBounds_8399(d: nat, k: nat)\n requires k > 0\n ensures 0 <= d % k < k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_8400","instance":8400,"id":178399,"goal":"lemma Square_Nonneg_8400(i: real)\n ensures i * i >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_8401","instance":8401,"id":178400,"goal":"lemma AddComm_8401(c: int, k: int)\n ensures c + k == k + c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_8402","instance":8402,"id":178401,"goal":"lemma AddAssoc_8402(j: nat, d: nat, c: nat)\n ensures (j + d) + c == j + (d + c)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_8403","instance":8403,"id":178402,"goal":"lemma MulComm_8403(c: real, i: real)\n ensures c * i == i * c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_8404","instance":8404,"id":178403,"goal":"lemma MulAssoc_8404(i: int, j: int, x: int)\n ensures (i * j) * x == i * (j * x)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_8405","instance":8405,"id":178404,"goal":"lemma Distrib_8405(d: nat, j: nat, y: nat)\n ensures d * (j + y) == d * j + d * y\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_8406","instance":8406,"id":178405,"goal":"lemma AddZero_8406(z: real)\n ensures z + 0 == z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_8407","instance":8407,"id":178406,"goal":"lemma MulOne_8407(c: int)\n ensures c * 1 == c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_8408","instance":8408,"id":178407,"goal":"lemma MulZero_8408(i: nat)\n ensures i * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_8409","instance":8409,"id":178408,"goal":"lemma LeRefl_8409(k: real)\n ensures k <= k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_8410","instance":8410,"id":178409,"goal":"lemma LeTrans_8410(b: int, x: int, z: int)\n requires b <= x && x <= z\n ensures b <= z\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_8411","instance":8411,"id":178410,"goal":"lemma AddMono_8411(z: nat, c: nat, x: nat)\n requires z <= c\n ensures z + x <= c + x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_8412","instance":8412,"id":178411,"goal":"lemma Abs_Nonneg_8412(n: real)\n ensures (if n >= 0 then n else -n) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_8413","instance":8413,"id":178412,"goal":"lemma DivMod_8413(j: int, x: int)\n requires x > 0\n ensures j == x * (j / x) + (j % x)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_8414","instance":8414,"id":178413,"goal":"lemma ModBounds_8414(c: nat, z: nat)\n requires z > 0\n ensures 0 <= c % z < z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_8415","instance":8415,"id":178414,"goal":"lemma Square_Nonneg_8415(d: real)\n ensures d * d >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_8416","instance":8416,"id":178415,"goal":"lemma AddComm_8416(c: int, k: int)\n ensures c + k == k + c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_8417","instance":8417,"id":178416,"goal":"lemma AddAssoc_8417(j: nat, c: nat, z: nat)\n ensures (j + c) + z == j + (c + z)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_8418","instance":8418,"id":178417,"goal":"lemma MulComm_8418(i: real, a: real)\n ensures i * a == a * i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_8419","instance":8419,"id":178418,"goal":"lemma MulAssoc_8419(d: int, y: int, n: int)\n ensures (d * y) * n == d * (y * n)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_8420","instance":8420,"id":178419,"goal":"lemma Distrib_8420(m: nat, b: nat, z: nat)\n ensures m * (b + z) == m * b + m * z\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_8421","instance":8421,"id":178420,"goal":"lemma AddZero_8421(a: real)\n ensures a + 0 == a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_8422","instance":8422,"id":178421,"goal":"lemma MulOne_8422(j: int)\n ensures j * 1 == j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_8423","instance":8423,"id":178422,"goal":"lemma MulZero_8423(b: nat)\n ensures b * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_8424","instance":8424,"id":178423,"goal":"lemma LeRefl_8424(d: real)\n ensures d <= d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_8425","instance":8425,"id":178424,"goal":"lemma LeTrans_8425(i: int, x: int, n: int)\n requires i <= x && x <= n\n ensures i <= n\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_8426","instance":8426,"id":178425,"goal":"lemma AddMono_8426(n: nat, a: nat, b: nat)\n requires n <= a\n ensures n + b <= a + b\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_8427","instance":8427,"id":178426,"goal":"lemma Abs_Nonneg_8427(y: real)\n ensures (if y >= 0 then y else -y) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_8428","instance":8428,"id":178427,"goal":"lemma DivMod_8428(k: int, a: int)\n requires a > 0\n ensures k == a * (k / a) + (k % a)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_8429","instance":8429,"id":178428,"goal":"lemma ModBounds_8429(b: nat, z: nat)\n requires z > 0\n ensures 0 <= b % z < z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_8430","instance":8430,"id":178429,"goal":"lemma Square_Nonneg_8430(m: real)\n ensures m * m >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_8431","instance":8431,"id":178430,"goal":"lemma AddComm_8431(i: int, z: int)\n ensures i + z == z + i\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_8432","instance":8432,"id":178431,"goal":"lemma AddAssoc_8432(k: nat, d: nat, n: nat)\n ensures (k + d) + n == k + (d + n)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_8433","instance":8433,"id":178432,"goal":"lemma MulComm_8433(n: real, j: real)\n ensures n * j == j * n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_8434","instance":8434,"id":178433,"goal":"lemma MulAssoc_8434(y: int, c: int, m: int)\n ensures (y * c) * m == y * (c * m)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_8435","instance":8435,"id":178434,"goal":"lemma Distrib_8435(i: nat, x: nat, n: nat)\n ensures i * (x + n) == i * x + i * n\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_8436","instance":8436,"id":178435,"goal":"lemma AddZero_8436(j: real)\n ensures j + 0 == j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_8437","instance":8437,"id":178436,"goal":"lemma MulOne_8437(i: int)\n ensures i * 1 == i\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_8438","instance":8438,"id":178437,"goal":"lemma MulZero_8438(z: nat)\n ensures z * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_8439","instance":8439,"id":178438,"goal":"lemma LeRefl_8439(d: real)\n ensures d <= d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_8440","instance":8440,"id":178439,"goal":"lemma LeTrans_8440(c: int, x: int, y: int)\n requires c <= x && x <= y\n ensures c <= y\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_8441","instance":8441,"id":178440,"goal":"lemma AddMono_8441(d: nat, c: nat, x: nat)\n requires d <= c\n ensures d + x <= c + x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_8442","instance":8442,"id":178441,"goal":"lemma Abs_Nonneg_8442(y: real)\n ensures (if y >= 0 then y else -y) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_8443","instance":8443,"id":178442,"goal":"lemma DivMod_8443(j: int, i: int)\n requires i > 0\n ensures j == i * (j / i) + (j % i)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_8444","instance":8444,"id":178443,"goal":"lemma ModBounds_8444(d: nat, m: nat)\n requires m > 0\n ensures 0 <= d % m < m\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_8445","instance":8445,"id":178444,"goal":"lemma Square_Nonneg_8445(z: real)\n ensures z * z >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_8446","instance":8446,"id":178445,"goal":"lemma AddComm_8446(z: int, j: int)\n ensures z + j == j + z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_8447","instance":8447,"id":178446,"goal":"lemma AddAssoc_8447(y: nat, c: nat, z: nat)\n ensures (y + c) + z == y + (c + z)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_8448","instance":8448,"id":178447,"goal":"lemma MulComm_8448(y: real, k: real)\n ensures y * k == k * y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_8449","instance":8449,"id":178448,"goal":"lemma MulAssoc_8449(m: int, x: int, j: int)\n ensures (m * x) * j == m * (x * j)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_8450","instance":8450,"id":178449,"goal":"lemma Distrib_8450(c: nat, a: nat, d: nat)\n ensures c * (a + d) == c * a + c * d\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_8451","instance":8451,"id":178450,"goal":"lemma AddZero_8451(y: real)\n ensures y + 0 == y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_8452","instance":8452,"id":178451,"goal":"lemma MulOne_8452(y: int)\n ensures y * 1 == y\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_8453","instance":8453,"id":178452,"goal":"lemma MulZero_8453(i: nat)\n ensures i * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_8454","instance":8454,"id":178453,"goal":"lemma LeRefl_8454(c: real)\n ensures c <= c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_8455","instance":8455,"id":178454,"goal":"lemma LeTrans_8455(b: int, z: int, i: int)\n requires b <= z && z <= i\n ensures b <= i\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_8456","instance":8456,"id":178455,"goal":"lemma AddMono_8456(c: nat, y: nat, k: nat)\n requires c <= y\n ensures c + k <= y + k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_8457","instance":8457,"id":178456,"goal":"lemma Abs_Nonneg_8457(x: real)\n ensures (if x >= 0 then x else -x) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_8458","instance":8458,"id":178457,"goal":"lemma DivMod_8458(z: int, y: int)\n requires y > 0\n ensures z == y * (z / y) + (z % y)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_8459","instance":8459,"id":178458,"goal":"lemma ModBounds_8459(z: nat, c: nat)\n requires c > 0\n ensures 0 <= z % c < c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_8460","instance":8460,"id":178459,"goal":"lemma Square_Nonneg_8460(j: real)\n ensures j * j >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_8461","instance":8461,"id":178460,"goal":"lemma AddComm_8461(a: int, n: int)\n ensures a + n == n + a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_8462","instance":8462,"id":178461,"goal":"lemma AddAssoc_8462(k: nat, z: nat, b: nat)\n ensures (k + z) + b == k + (z + b)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_8463","instance":8463,"id":178462,"goal":"lemma MulComm_8463(k: real, y: real)\n ensures k * y == y * k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_8464","instance":8464,"id":178463,"goal":"lemma MulAssoc_8464(m: int, c: int, i: int)\n ensures (m * c) * i == m * (c * i)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_8465","instance":8465,"id":178464,"goal":"lemma Distrib_8465(i: nat, z: nat, a: nat)\n ensures i * (z + a) == i * z + i * a\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_8466","instance":8466,"id":178465,"goal":"lemma AddZero_8466(m: real)\n ensures m + 0 == m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_8467","instance":8467,"id":178466,"goal":"lemma MulOne_8467(b: int)\n ensures b * 1 == b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_8468","instance":8468,"id":178467,"goal":"lemma MulZero_8468(m: nat)\n ensures m * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_8469","instance":8469,"id":178468,"goal":"lemma LeRefl_8469(z: real)\n ensures z <= z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_8470","instance":8470,"id":178469,"goal":"lemma LeTrans_8470(j: int, i: int, y: int)\n requires j <= i && i <= y\n ensures j <= y\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_8471","instance":8471,"id":178470,"goal":"lemma AddMono_8471(d: nat, j: nat, m: nat)\n requires d <= j\n ensures d + m <= j + m\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_8472","instance":8472,"id":178471,"goal":"lemma Abs_Nonneg_8472(d: real)\n ensures (if d >= 0 then d else -d) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_8473","instance":8473,"id":178472,"goal":"lemma DivMod_8473(d: int, k: int)\n requires k > 0\n ensures d == k * (d / k) + (d % k)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_8474","instance":8474,"id":178473,"goal":"lemma ModBounds_8474(n: nat, b: nat)\n requires b > 0\n ensures 0 <= n % b < b\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_8475","instance":8475,"id":178474,"goal":"lemma Square_Nonneg_8475(a: real)\n ensures a * a >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_8476","instance":8476,"id":178475,"goal":"lemma AddComm_8476(x: int, i: int)\n ensures x + i == i + x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_8477","instance":8477,"id":178476,"goal":"lemma AddAssoc_8477(d: nat, a: nat, z: nat)\n ensures (d + a) + z == d + (a + z)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_8478","instance":8478,"id":178477,"goal":"lemma MulComm_8478(c: real, a: real)\n ensures c * a == a * c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_8479","instance":8479,"id":178478,"goal":"lemma MulAssoc_8479(n: int, k: int, a: int)\n ensures (n * k) * a == n * (k * a)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_8480","instance":8480,"id":178479,"goal":"lemma Distrib_8480(j: nat, c: nat, z: nat)\n ensures j * (c + z) == j * c + j * z\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_8481","instance":8481,"id":178480,"goal":"lemma AddZero_8481(i: real)\n ensures i + 0 == i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_8482","instance":8482,"id":178481,"goal":"lemma MulOne_8482(j: int)\n ensures j * 1 == j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_8483","instance":8483,"id":178482,"goal":"lemma MulZero_8483(x: nat)\n ensures x * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_8484","instance":8484,"id":178483,"goal":"lemma LeRefl_8484(y: real)\n ensures y <= y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_8485","instance":8485,"id":178484,"goal":"lemma LeTrans_8485(b: int, k: int, n: int)\n requires b <= k && k <= n\n ensures b <= n\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_8486","instance":8486,"id":178485,"goal":"lemma AddMono_8486(k: nat, d: nat, j: nat)\n requires k <= d\n ensures k + j <= d + j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_8487","instance":8487,"id":178486,"goal":"lemma Abs_Nonneg_8487(b: real)\n ensures (if b >= 0 then b else -b) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_8488","instance":8488,"id":178487,"goal":"lemma DivMod_8488(j: int, z: int)\n requires z > 0\n ensures j == z * (j / z) + (j % z)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_8489","instance":8489,"id":178488,"goal":"lemma ModBounds_8489(b: nat, n: nat)\n requires n > 0\n ensures 0 <= b % n < n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_8490","instance":8490,"id":178489,"goal":"lemma Square_Nonneg_8490(k: real)\n ensures k * k >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_8491","instance":8491,"id":178490,"goal":"lemma AddComm_8491(z: int, x: int)\n ensures z + x == x + z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_8492","instance":8492,"id":178491,"goal":"lemma AddAssoc_8492(a: nat, x: nat, k: nat)\n ensures (a + x) + k == a + (x + k)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_8493","instance":8493,"id":178492,"goal":"lemma MulComm_8493(y: real, c: real)\n ensures y * c == c * y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_8494","instance":8494,"id":178493,"goal":"lemma MulAssoc_8494(m: int, n: int, a: int)\n ensures (m * n) * a == m * (n * a)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_8495","instance":8495,"id":178494,"goal":"lemma Distrib_8495(d: nat, c: nat, a: nat)\n ensures d * (c + a) == d * c + d * a\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_8496","instance":8496,"id":178495,"goal":"lemma AddZero_8496(m: real)\n ensures m + 0 == m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_8497","instance":8497,"id":178496,"goal":"lemma MulOne_8497(j: int)\n ensures j * 1 == j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_8498","instance":8498,"id":178497,"goal":"lemma MulZero_8498(d: nat)\n ensures d * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_8499","instance":8499,"id":178498,"goal":"lemma LeRefl_8499(k: real)\n ensures k <= k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_8500","instance":8500,"id":178499,"goal":"lemma LeTrans_8500(n: int, b: int, a: int)\n requires n <= b && b <= a\n ensures n <= a\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_8501","instance":8501,"id":178500,"goal":"lemma AddMono_8501(j: nat, k: nat, y: nat)\n requires j <= k\n ensures j + y <= k + y\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_8502","instance":8502,"id":178501,"goal":"lemma Abs_Nonneg_8502(b: real)\n ensures (if b >= 0 then b else -b) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_8503","instance":8503,"id":178502,"goal":"lemma DivMod_8503(a: int, i: int)\n requires i > 0\n ensures a == i * (a / i) + (a % i)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_8504","instance":8504,"id":178503,"goal":"lemma ModBounds_8504(a: nat, m: nat)\n requires m > 0\n ensures 0 <= a % m < m\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_8505","instance":8505,"id":178504,"goal":"lemma Square_Nonneg_8505(y: real)\n ensures y * y >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_8506","instance":8506,"id":178505,"goal":"lemma AddComm_8506(m: int, a: int)\n ensures m + a == a + m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_8507","instance":8507,"id":178506,"goal":"lemma AddAssoc_8507(z: nat, n: nat, k: nat)\n ensures (z + n) + k == z + (n + k)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_8508","instance":8508,"id":178507,"goal":"lemma MulComm_8508(d: real, k: real)\n ensures d * k == k * d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_8509","instance":8509,"id":178508,"goal":"lemma MulAssoc_8509(y: int, b: int, k: int)\n ensures (y * b) * k == y * (b * k)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_8510","instance":8510,"id":178509,"goal":"lemma Distrib_8510(d: nat, b: nat, i: nat)\n ensures d * (b + i) == d * b + d * i\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_8511","instance":8511,"id":178510,"goal":"lemma AddZero_8511(a: real)\n ensures a + 0 == a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_8512","instance":8512,"id":178511,"goal":"lemma MulOne_8512(c: int)\n ensures c * 1 == c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_8513","instance":8513,"id":178512,"goal":"lemma MulZero_8513(z: nat)\n ensures z * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_8514","instance":8514,"id":178513,"goal":"lemma LeRefl_8514(i: real)\n ensures i <= i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_8515","instance":8515,"id":178514,"goal":"lemma LeTrans_8515(j: int, b: int, d: int)\n requires j <= b && b <= d\n ensures j <= d\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_8516","instance":8516,"id":178515,"goal":"lemma AddMono_8516(c: nat, i: nat, j: nat)\n requires c <= i\n ensures c + j <= i + j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_8517","instance":8517,"id":178516,"goal":"lemma Abs_Nonneg_8517(c: real)\n ensures (if c >= 0 then c else -c) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_8518","instance":8518,"id":178517,"goal":"lemma DivMod_8518(m: int, a: int)\n requires a > 0\n ensures m == a * (m / a) + (m % a)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_8519","instance":8519,"id":178518,"goal":"lemma ModBounds_8519(d: nat, c: nat)\n requires c > 0\n ensures 0 <= d % c < c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_8520","instance":8520,"id":178519,"goal":"lemma Square_Nonneg_8520(z: real)\n ensures z * z >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_8521","instance":8521,"id":178520,"goal":"lemma AddComm_8521(z: int, d: int)\n ensures z + d == d + z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_8522","instance":8522,"id":178521,"goal":"lemma AddAssoc_8522(d: nat, b: nat, y: nat)\n ensures (d + b) + y == d + (b + y)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_8523","instance":8523,"id":178522,"goal":"lemma MulComm_8523(z: real, b: real)\n ensures z * b == b * z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_8524","instance":8524,"id":178523,"goal":"lemma MulAssoc_8524(n: int, x: int, j: int)\n ensures (n * x) * j == n * (x * j)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_8525","instance":8525,"id":178524,"goal":"lemma Distrib_8525(j: nat, i: nat, c: nat)\n ensures j * (i + c) == j * i + j * c\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_8526","instance":8526,"id":178525,"goal":"lemma AddZero_8526(x: real)\n ensures x + 0 == x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_8527","instance":8527,"id":178526,"goal":"lemma MulOne_8527(c: int)\n ensures c * 1 == c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_8528","instance":8528,"id":178527,"goal":"lemma MulZero_8528(a: nat)\n ensures a * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_8529","instance":8529,"id":178528,"goal":"lemma LeRefl_8529(b: real)\n ensures b <= b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_8530","instance":8530,"id":178529,"goal":"lemma LeTrans_8530(b: int, j: int, x: int)\n requires b <= j && j <= x\n ensures b <= x\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_8531","instance":8531,"id":178530,"goal":"lemma AddMono_8531(i: nat, k: nat, x: nat)\n requires i <= k\n ensures i + x <= k + x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_8532","instance":8532,"id":178531,"goal":"lemma Abs_Nonneg_8532(x: real)\n ensures (if x >= 0 then x else -x) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_8533","instance":8533,"id":178532,"goal":"lemma DivMod_8533(i: int, n: int)\n requires n > 0\n ensures i == n * (i / n) + (i % n)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_8534","instance":8534,"id":178533,"goal":"lemma ModBounds_8534(b: nat, y: nat)\n requires y > 0\n ensures 0 <= b % y < y\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_8535","instance":8535,"id":178534,"goal":"lemma Square_Nonneg_8535(m: real)\n ensures m * m >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_8536","instance":8536,"id":178535,"goal":"lemma AddComm_8536(n: int, j: int)\n ensures n + j == j + n\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_8537","instance":8537,"id":178536,"goal":"lemma AddAssoc_8537(z: nat, d: nat, n: nat)\n ensures (z + d) + n == z + (d + n)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_8538","instance":8538,"id":178537,"goal":"lemma MulComm_8538(z: real, x: real)\n ensures z * x == x * z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_8539","instance":8539,"id":178538,"goal":"lemma MulAssoc_8539(x: int, i: int, m: int)\n ensures (x * i) * m == x * (i * m)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_8540","instance":8540,"id":178539,"goal":"lemma Distrib_8540(i: nat, z: nat, x: nat)\n ensures i * (z + x) == i * z + i * x\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_8541","instance":8541,"id":178540,"goal":"lemma AddZero_8541(a: real)\n ensures a + 0 == a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_8542","instance":8542,"id":178541,"goal":"lemma MulOne_8542(i: int)\n ensures i * 1 == i\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_8543","instance":8543,"id":178542,"goal":"lemma MulZero_8543(y: nat)\n ensures y * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_8544","instance":8544,"id":178543,"goal":"lemma LeRefl_8544(b: real)\n ensures b <= b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_8545","instance":8545,"id":178544,"goal":"lemma LeTrans_8545(d: int, a: int, m: int)\n requires d <= a && a <= m\n ensures d <= m\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_8546","instance":8546,"id":178545,"goal":"lemma AddMono_8546(j: nat, y: nat, a: nat)\n requires j <= y\n ensures j + a <= y + a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_8547","instance":8547,"id":178546,"goal":"lemma Abs_Nonneg_8547(y: real)\n ensures (if y >= 0 then y else -y) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_8548","instance":8548,"id":178547,"goal":"lemma DivMod_8548(x: int, y: int)\n requires y > 0\n ensures x == y * (x / y) + (x % y)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_8549","instance":8549,"id":178548,"goal":"lemma ModBounds_8549(x: nat, d: nat)\n requires d > 0\n ensures 0 <= x % d < d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_8550","instance":8550,"id":178549,"goal":"lemma Square_Nonneg_8550(d: real)\n ensures d * d >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_8551","instance":8551,"id":178550,"goal":"lemma AddComm_8551(b: int, i: int)\n ensures b + i == i + b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_8552","instance":8552,"id":178551,"goal":"lemma AddAssoc_8552(y: nat, c: nat, d: nat)\n ensures (y + c) + d == y + (c + d)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_8553","instance":8553,"id":178552,"goal":"lemma MulComm_8553(b: real, k: real)\n ensures b * k == k * b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_8554","instance":8554,"id":178553,"goal":"lemma MulAssoc_8554(x: int, a: int, b: int)\n ensures (x * a) * b == x * (a * b)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_8555","instance":8555,"id":178554,"goal":"lemma Distrib_8555(k: nat, i: nat, x: nat)\n ensures k * (i + x) == k * i + k * x\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_8556","instance":8556,"id":178555,"goal":"lemma AddZero_8556(i: real)\n ensures i + 0 == i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_8557","instance":8557,"id":178556,"goal":"lemma MulOne_8557(x: int)\n ensures x * 1 == x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_8558","instance":8558,"id":178557,"goal":"lemma MulZero_8558(z: nat)\n ensures z * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_8559","instance":8559,"id":178558,"goal":"lemma LeRefl_8559(x: real)\n ensures x <= x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_8560","instance":8560,"id":178559,"goal":"lemma LeTrans_8560(c: int, z: int, d: int)\n requires c <= z && z <= d\n ensures c <= d\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_8561","instance":8561,"id":178560,"goal":"lemma AddMono_8561(d: nat, k: nat, a: nat)\n requires d <= k\n ensures d + a <= k + a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_8562","instance":8562,"id":178561,"goal":"lemma Abs_Nonneg_8562(n: real)\n ensures (if n >= 0 then n else -n) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_8563","instance":8563,"id":178562,"goal":"lemma DivMod_8563(m: int, d: int)\n requires d > 0\n ensures m == d * (m / d) + (m % d)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_8564","instance":8564,"id":178563,"goal":"lemma ModBounds_8564(b: nat, c: nat)\n requires c > 0\n ensures 0 <= b % c < c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_8565","instance":8565,"id":178564,"goal":"lemma Square_Nonneg_8565(j: real)\n ensures j * j >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_8566","instance":8566,"id":178565,"goal":"lemma AddComm_8566(x: int, k: int)\n ensures x + k == k + x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_8567","instance":8567,"id":178566,"goal":"lemma AddAssoc_8567(a: nat, j: nat, z: nat)\n ensures (a + j) + z == a + (j + z)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_8568","instance":8568,"id":178567,"goal":"lemma MulComm_8568(a: real, y: real)\n ensures a * y == y * a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_8569","instance":8569,"id":178568,"goal":"lemma MulAssoc_8569(b: int, j: int, y: int)\n ensures (b * j) * y == b * (j * y)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_8570","instance":8570,"id":178569,"goal":"lemma Distrib_8570(n: nat, d: nat, c: nat)\n ensures n * (d + c) == n * d + n * c\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_8571","instance":8571,"id":178570,"goal":"lemma AddZero_8571(a: real)\n ensures a + 0 == a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_8572","instance":8572,"id":178571,"goal":"lemma MulOne_8572(i: int)\n ensures i * 1 == i\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_8573","instance":8573,"id":178572,"goal":"lemma MulZero_8573(m: nat)\n ensures m * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_8574","instance":8574,"id":178573,"goal":"lemma LeRefl_8574(z: real)\n ensures z <= z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_8575","instance":8575,"id":178574,"goal":"lemma LeTrans_8575(a: int, i: int, y: int)\n requires a <= i && i <= y\n ensures a <= y\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_8576","instance":8576,"id":178575,"goal":"lemma AddMono_8576(i: nat, n: nat, a: nat)\n requires i <= n\n ensures i + a <= n + a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_8577","instance":8577,"id":178576,"goal":"lemma Abs_Nonneg_8577(y: real)\n ensures (if y >= 0 then y else -y) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_8578","instance":8578,"id":178577,"goal":"lemma DivMod_8578(b: int, i: int)\n requires i > 0\n ensures b == i * (b / i) + (b % i)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_8579","instance":8579,"id":178578,"goal":"lemma ModBounds_8579(c: nat, i: nat)\n requires i > 0\n ensures 0 <= c % i < i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_8580","instance":8580,"id":178579,"goal":"lemma Square_Nonneg_8580(d: real)\n ensures d * d >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_8581","instance":8581,"id":178580,"goal":"lemma AddComm_8581(i: int, k: int)\n ensures i + k == k + i\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_8582","instance":8582,"id":178581,"goal":"lemma AddAssoc_8582(b: nat, c: nat, x: nat)\n ensures (b + c) + x == b + (c + x)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_8583","instance":8583,"id":178582,"goal":"lemma MulComm_8583(x: real, n: real)\n ensures x * n == n * x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_8584","instance":8584,"id":178583,"goal":"lemma MulAssoc_8584(d: int, j: int, k: int)\n ensures (d * j) * k == d * (j * k)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_8585","instance":8585,"id":178584,"goal":"lemma Distrib_8585(y: nat, c: nat, n: nat)\n ensures y * (c + n) == y * c + y * n\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_8586","instance":8586,"id":178585,"goal":"lemma AddZero_8586(x: real)\n ensures x + 0 == x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_8587","instance":8587,"id":178586,"goal":"lemma MulOne_8587(x: int)\n ensures x * 1 == x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_8588","instance":8588,"id":178587,"goal":"lemma MulZero_8588(x: nat)\n ensures x * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_8589","instance":8589,"id":178588,"goal":"lemma LeRefl_8589(i: real)\n ensures i <= i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_8590","instance":8590,"id":178589,"goal":"lemma LeTrans_8590(m: int, a: int, d: int)\n requires m <= a && a <= d\n ensures m <= d\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_8591","instance":8591,"id":178590,"goal":"lemma AddMono_8591(j: nat, a: nat, x: nat)\n requires j <= a\n ensures j + x <= a + x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_8592","instance":8592,"id":178591,"goal":"lemma Abs_Nonneg_8592(b: real)\n ensures (if b >= 0 then b else -b) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_8593","instance":8593,"id":178592,"goal":"lemma DivMod_8593(y: int, x: int)\n requires x > 0\n ensures y == x * (y / x) + (y % x)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_8594","instance":8594,"id":178593,"goal":"lemma ModBounds_8594(z: nat, a: nat)\n requires a > 0\n ensures 0 <= z % a < a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_8595","instance":8595,"id":178594,"goal":"lemma Square_Nonneg_8595(j: real)\n ensures j * j >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_8596","instance":8596,"id":178595,"goal":"lemma AddComm_8596(z: int, m: int)\n ensures z + m == m + z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_8597","instance":8597,"id":178596,"goal":"lemma AddAssoc_8597(k: nat, c: nat, z: nat)\n ensures (k + c) + z == k + (c + z)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_8598","instance":8598,"id":178597,"goal":"lemma MulComm_8598(m: real, d: real)\n ensures m * d == d * m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_8599","instance":8599,"id":178598,"goal":"lemma MulAssoc_8599(z: int, n: int, y: int)\n ensures (z * n) * y == z * (n * y)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_8600","instance":8600,"id":178599,"goal":"lemma Distrib_8600(i: nat, j: nat, k: nat)\n ensures i * (j + k) == i * j + i * k\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_8601","instance":8601,"id":178600,"goal":"lemma AddZero_8601(a: real)\n ensures a + 0 == a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_8602","instance":8602,"id":178601,"goal":"lemma MulOne_8602(d: int)\n ensures d * 1 == d\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_8603","instance":8603,"id":178602,"goal":"lemma MulZero_8603(k: nat)\n ensures k * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_8604","instance":8604,"id":178603,"goal":"lemma LeRefl_8604(k: real)\n ensures k <= k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_8605","instance":8605,"id":178604,"goal":"lemma LeTrans_8605(j: int, a: int, x: int)\n requires j <= a && a <= x\n ensures j <= x\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_8606","instance":8606,"id":178605,"goal":"lemma AddMono_8606(j: nat, d: nat, y: nat)\n requires j <= d\n ensures j + y <= d + y\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_8607","instance":8607,"id":178606,"goal":"lemma Abs_Nonneg_8607(x: real)\n ensures (if x >= 0 then x else -x) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_8608","instance":8608,"id":178607,"goal":"lemma DivMod_8608(k: int, b: int)\n requires b > 0\n ensures k == b * (k / b) + (k % b)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_8609","instance":8609,"id":178608,"goal":"lemma ModBounds_8609(b: nat, z: nat)\n requires z > 0\n ensures 0 <= b % z < z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_8610","instance":8610,"id":178609,"goal":"lemma Square_Nonneg_8610(y: real)\n ensures y * y >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_8611","instance":8611,"id":178610,"goal":"lemma AddComm_8611(z: int, a: int)\n ensures z + a == a + z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_8612","instance":8612,"id":178611,"goal":"lemma AddAssoc_8612(i: nat, b: nat, d: nat)\n ensures (i + b) + d == i + (b + d)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_8613","instance":8613,"id":178612,"goal":"lemma MulComm_8613(j: real, d: real)\n ensures j * d == d * j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_8614","instance":8614,"id":178613,"goal":"lemma MulAssoc_8614(n: int, b: int, z: int)\n ensures (n * b) * z == n * (b * z)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_8615","instance":8615,"id":178614,"goal":"lemma Distrib_8615(n: nat, b: nat, i: nat)\n ensures n * (b + i) == n * b + n * i\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_8616","instance":8616,"id":178615,"goal":"lemma AddZero_8616(n: real)\n ensures n + 0 == n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_8617","instance":8617,"id":178616,"goal":"lemma MulOne_8617(b: int)\n ensures b * 1 == b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_8618","instance":8618,"id":178617,"goal":"lemma MulZero_8618(i: nat)\n ensures i * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_8619","instance":8619,"id":178618,"goal":"lemma LeRefl_8619(n: real)\n ensures n <= n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_8620","instance":8620,"id":178619,"goal":"lemma LeTrans_8620(c: int, j: int, d: int)\n requires c <= j && j <= d\n ensures c <= d\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_8621","instance":8621,"id":178620,"goal":"lemma AddMono_8621(x: nat, k: nat, a: nat)\n requires x <= k\n ensures x + a <= k + a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_8622","instance":8622,"id":178621,"goal":"lemma Abs_Nonneg_8622(x: real)\n ensures (if x >= 0 then x else -x) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_8623","instance":8623,"id":178622,"goal":"lemma DivMod_8623(b: int, k: int)\n requires k > 0\n ensures b == k * (b / k) + (b % k)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_8624","instance":8624,"id":178623,"goal":"lemma ModBounds_8624(b: nat, n: nat)\n requires n > 0\n ensures 0 <= b % n < n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_8625","instance":8625,"id":178624,"goal":"lemma Square_Nonneg_8625(j: real)\n ensures j * j >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_8626","instance":8626,"id":178625,"goal":"lemma AddComm_8626(z: int, m: int)\n ensures z + m == m + z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_8627","instance":8627,"id":178626,"goal":"lemma AddAssoc_8627(m: nat, x: nat, a: nat)\n ensures (m + x) + a == m + (x + a)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_8628","instance":8628,"id":178627,"goal":"lemma MulComm_8628(b: real, a: real)\n ensures b * a == a * b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_8629","instance":8629,"id":178628,"goal":"lemma MulAssoc_8629(c: int, a: int, i: int)\n ensures (c * a) * i == c * (a * i)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_8630","instance":8630,"id":178629,"goal":"lemma Distrib_8630(m: nat, i: nat, c: nat)\n ensures m * (i + c) == m * i + m * c\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_8631","instance":8631,"id":178630,"goal":"lemma AddZero_8631(m: real)\n ensures m + 0 == m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_8632","instance":8632,"id":178631,"goal":"lemma MulOne_8632(m: int)\n ensures m * 1 == m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_8633","instance":8633,"id":178632,"goal":"lemma MulZero_8633(i: nat)\n ensures i * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_8634","instance":8634,"id":178633,"goal":"lemma LeRefl_8634(m: real)\n ensures m <= m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_8635","instance":8635,"id":178634,"goal":"lemma LeTrans_8635(x: int, k: int, d: int)\n requires x <= k && k <= d\n ensures x <= d\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_8636","instance":8636,"id":178635,"goal":"lemma AddMono_8636(x: nat, j: nat, d: nat)\n requires x <= j\n ensures x + d <= j + d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_8637","instance":8637,"id":178636,"goal":"lemma Abs_Nonneg_8637(k: real)\n ensures (if k >= 0 then k else -k) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_8638","instance":8638,"id":178637,"goal":"lemma DivMod_8638(d: int, x: int)\n requires x > 0\n ensures d == x * (d / x) + (d % x)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_8639","instance":8639,"id":178638,"goal":"lemma ModBounds_8639(n: nat, a: nat)\n requires a > 0\n ensures 0 <= n % a < a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_8640","instance":8640,"id":178639,"goal":"lemma Square_Nonneg_8640(j: real)\n ensures j * j >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_8641","instance":8641,"id":178640,"goal":"lemma AddComm_8641(i: int, n: int)\n ensures i + n == n + i\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_8642","instance":8642,"id":178641,"goal":"lemma AddAssoc_8642(b: nat, n: nat, a: nat)\n ensures (b + n) + a == b + (n + a)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_8643","instance":8643,"id":178642,"goal":"lemma MulComm_8643(a: real, b: real)\n ensures a * b == b * a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_8644","instance":8644,"id":178643,"goal":"lemma MulAssoc_8644(d: int, m: int, c: int)\n ensures (d * m) * c == d * (m * c)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_8645","instance":8645,"id":178644,"goal":"lemma Distrib_8645(z: nat, m: nat, b: nat)\n ensures z * (m + b) == z * m + z * b\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_8646","instance":8646,"id":178645,"goal":"lemma AddZero_8646(n: real)\n ensures n + 0 == n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_8647","instance":8647,"id":178646,"goal":"lemma MulOne_8647(m: int)\n ensures m * 1 == m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_8648","instance":8648,"id":178647,"goal":"lemma MulZero_8648(i: nat)\n ensures i * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_8649","instance":8649,"id":178648,"goal":"lemma LeRefl_8649(x: real)\n ensures x <= x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_8650","instance":8650,"id":178649,"goal":"lemma LeTrans_8650(c: int, i: int, j: int)\n requires c <= i && i <= j\n ensures c <= j\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_8651","instance":8651,"id":178650,"goal":"lemma AddMono_8651(k: nat, a: nat, d: nat)\n requires k <= a\n ensures k + d <= a + d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_8652","instance":8652,"id":178651,"goal":"lemma Abs_Nonneg_8652(k: real)\n ensures (if k >= 0 then k else -k) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_8653","instance":8653,"id":178652,"goal":"lemma DivMod_8653(y: int, n: int)\n requires n > 0\n ensures y == n * (y / n) + (y % n)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_8654","instance":8654,"id":178653,"goal":"lemma ModBounds_8654(c: nat, y: nat)\n requires y > 0\n ensures 0 <= c % y < y\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_8655","instance":8655,"id":178654,"goal":"lemma Square_Nonneg_8655(a: real)\n ensures a * a >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_8656","instance":8656,"id":178655,"goal":"lemma AddComm_8656(c: int, z: int)\n ensures c + z == z + c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_8657","instance":8657,"id":178656,"goal":"lemma AddAssoc_8657(y: nat, z: nat, x: nat)\n ensures (y + z) + x == y + (z + x)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_8658","instance":8658,"id":178657,"goal":"lemma MulComm_8658(x: real, z: real)\n ensures x * z == z * x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_8659","instance":8659,"id":178658,"goal":"lemma MulAssoc_8659(d: int, y: int, x: int)\n ensures (d * y) * x == d * (y * x)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_8660","instance":8660,"id":178659,"goal":"lemma Distrib_8660(i: nat, j: nat, b: nat)\n ensures i * (j + b) == i * j + i * b\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_8661","instance":8661,"id":178660,"goal":"lemma AddZero_8661(a: real)\n ensures a + 0 == a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_8662","instance":8662,"id":178661,"goal":"lemma MulOne_8662(k: int)\n ensures k * 1 == k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_8663","instance":8663,"id":178662,"goal":"lemma MulZero_8663(d: nat)\n ensures d * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_8664","instance":8664,"id":178663,"goal":"lemma LeRefl_8664(a: real)\n ensures a <= a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_8665","instance":8665,"id":178664,"goal":"lemma LeTrans_8665(m: int, x: int, n: int)\n requires m <= x && x <= n\n ensures m <= n\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_8666","instance":8666,"id":178665,"goal":"lemma AddMono_8666(n: nat, b: nat, y: nat)\n requires n <= b\n ensures n + y <= b + y\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_8667","instance":8667,"id":178666,"goal":"lemma Abs_Nonneg_8667(c: real)\n ensures (if c >= 0 then c else -c) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_8668","instance":8668,"id":178667,"goal":"lemma DivMod_8668(k: int, j: int)\n requires j > 0\n ensures k == j * (k / j) + (k % j)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_8669","instance":8669,"id":178668,"goal":"lemma ModBounds_8669(d: nat, z: nat)\n requires z > 0\n ensures 0 <= d % z < z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_8670","instance":8670,"id":178669,"goal":"lemma Square_Nonneg_8670(a: real)\n ensures a * a >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_8671","instance":8671,"id":178670,"goal":"lemma AddComm_8671(n: int, i: int)\n ensures n + i == i + n\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_8672","instance":8672,"id":178671,"goal":"lemma AddAssoc_8672(i: nat, y: nat, a: nat)\n ensures (i + y) + a == i + (y + a)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_8673","instance":8673,"id":178672,"goal":"lemma MulComm_8673(y: real, b: real)\n ensures y * b == b * y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_8674","instance":8674,"id":178673,"goal":"lemma MulAssoc_8674(b: int, m: int, k: int)\n ensures (b * m) * k == b * (m * k)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_8675","instance":8675,"id":178674,"goal":"lemma Distrib_8675(z: nat, k: nat, j: nat)\n ensures z * (k + j) == z * k + z * j\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_8676","instance":8676,"id":178675,"goal":"lemma AddZero_8676(m: real)\n ensures m + 0 == m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_8677","instance":8677,"id":178676,"goal":"lemma MulOne_8677(d: int)\n ensures d * 1 == d\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_8678","instance":8678,"id":178677,"goal":"lemma MulZero_8678(x: nat)\n ensures x * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_8679","instance":8679,"id":178678,"goal":"lemma LeRefl_8679(d: real)\n ensures d <= d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_8680","instance":8680,"id":178679,"goal":"lemma LeTrans_8680(n: int, c: int, k: int)\n requires n <= c && c <= k\n ensures n <= k\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_8681","instance":8681,"id":178680,"goal":"lemma AddMono_8681(x: nat, b: nat, m: nat)\n requires x <= b\n ensures x + m <= b + m\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_8682","instance":8682,"id":178681,"goal":"lemma Abs_Nonneg_8682(i: real)\n ensures (if i >= 0 then i else -i) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_8683","instance":8683,"id":178682,"goal":"lemma DivMod_8683(x: int, k: int)\n requires k > 0\n ensures x == k * (x / k) + (x % k)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_8684","instance":8684,"id":178683,"goal":"lemma ModBounds_8684(b: nat, m: nat)\n requires m > 0\n ensures 0 <= b % m < m\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_8685","instance":8685,"id":178684,"goal":"lemma Square_Nonneg_8685(z: real)\n ensures z * z >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_8686","instance":8686,"id":178685,"goal":"lemma AddComm_8686(y: int, z: int)\n ensures y + z == z + y\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_8687","instance":8687,"id":178686,"goal":"lemma AddAssoc_8687(i: nat, x: nat, b: nat)\n ensures (i + x) + b == i + (x + b)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_8688","instance":8688,"id":178687,"goal":"lemma MulComm_8688(j: real, x: real)\n ensures j * x == x * j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_8689","instance":8689,"id":178688,"goal":"lemma MulAssoc_8689(n: int, j: int, a: int)\n ensures (n * j) * a == n * (j * a)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_8690","instance":8690,"id":178689,"goal":"lemma Distrib_8690(z: nat, k: nat, n: nat)\n ensures z * (k + n) == z * k + z * n\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_8691","instance":8691,"id":178690,"goal":"lemma AddZero_8691(y: real)\n ensures y + 0 == y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_8692","instance":8692,"id":178691,"goal":"lemma MulOne_8692(z: int)\n ensures z * 1 == z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_8693","instance":8693,"id":178692,"goal":"lemma MulZero_8693(i: nat)\n ensures i * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_8694","instance":8694,"id":178693,"goal":"lemma LeRefl_8694(n: real)\n ensures n <= n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_8695","instance":8695,"id":178694,"goal":"lemma LeTrans_8695(d: int, i: int, a: int)\n requires d <= i && i <= a\n ensures d <= a\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_8696","instance":8696,"id":178695,"goal":"lemma AddMono_8696(b: nat, x: nat, n: nat)\n requires b <= x\n ensures b + n <= x + n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_8697","instance":8697,"id":178696,"goal":"lemma Abs_Nonneg_8697(y: real)\n ensures (if y >= 0 then y else -y) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_8698","instance":8698,"id":178697,"goal":"lemma DivMod_8698(j: int, k: int)\n requires k > 0\n ensures j == k * (j / k) + (j % k)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_8699","instance":8699,"id":178698,"goal":"lemma ModBounds_8699(i: nat, m: nat)\n requires m > 0\n ensures 0 <= i % m < m\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_8700","instance":8700,"id":178699,"goal":"lemma Square_Nonneg_8700(x: real)\n ensures x * x >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_8701","instance":8701,"id":178700,"goal":"lemma AddComm_8701(a: int, n: int)\n ensures a + n == n + a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_8702","instance":8702,"id":178701,"goal":"lemma AddAssoc_8702(b: nat, z: nat, d: nat)\n ensures (b + z) + d == b + (z + d)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_8703","instance":8703,"id":178702,"goal":"lemma MulComm_8703(z: real, i: real)\n ensures z * i == i * z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_8704","instance":8704,"id":178703,"goal":"lemma MulAssoc_8704(y: int, z: int, i: int)\n ensures (y * z) * i == y * (z * i)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_8705","instance":8705,"id":178704,"goal":"lemma Distrib_8705(y: nat, i: nat, d: nat)\n ensures y * (i + d) == y * i + y * d\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_8706","instance":8706,"id":178705,"goal":"lemma AddZero_8706(k: real)\n ensures k + 0 == k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_8707","instance":8707,"id":178706,"goal":"lemma MulOne_8707(i: int)\n ensures i * 1 == i\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_8708","instance":8708,"id":178707,"goal":"lemma MulZero_8708(y: nat)\n ensures y * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_8709","instance":8709,"id":178708,"goal":"lemma LeRefl_8709(c: real)\n ensures c <= c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_8710","instance":8710,"id":178709,"goal":"lemma LeTrans_8710(x: int, m: int, b: int)\n requires x <= m && m <= b\n ensures x <= b\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_8711","instance":8711,"id":178710,"goal":"lemma AddMono_8711(b: nat, m: nat, j: nat)\n requires b <= m\n ensures b + j <= m + j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_8712","instance":8712,"id":178711,"goal":"lemma Abs_Nonneg_8712(b: real)\n ensures (if b >= 0 then b else -b) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_8713","instance":8713,"id":178712,"goal":"lemma DivMod_8713(z: int, i: int)\n requires i > 0\n ensures z == i * (z / i) + (z % i)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_8714","instance":8714,"id":178713,"goal":"lemma ModBounds_8714(m: nat, z: nat)\n requires z > 0\n ensures 0 <= m % z < z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_8715","instance":8715,"id":178714,"goal":"lemma Square_Nonneg_8715(x: real)\n ensures x * x >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_8716","instance":8716,"id":178715,"goal":"lemma AddComm_8716(x: int, z: int)\n ensures x + z == z + x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_8717","instance":8717,"id":178716,"goal":"lemma AddAssoc_8717(d: nat, k: nat, n: nat)\n ensures (d + k) + n == d + (k + n)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_8718","instance":8718,"id":178717,"goal":"lemma MulComm_8718(z: real, y: real)\n ensures z * y == y * z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_8719","instance":8719,"id":178718,"goal":"lemma MulAssoc_8719(b: int, j: int, i: int)\n ensures (b * j) * i == b * (j * i)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_8720","instance":8720,"id":178719,"goal":"lemma Distrib_8720(b: nat, k: nat, x: nat)\n ensures b * (k + x) == b * k + b * x\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_8721","instance":8721,"id":178720,"goal":"lemma AddZero_8721(y: real)\n ensures y + 0 == y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_8722","instance":8722,"id":178721,"goal":"lemma MulOne_8722(z: int)\n ensures z * 1 == z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_8723","instance":8723,"id":178722,"goal":"lemma MulZero_8723(c: nat)\n ensures c * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_8724","instance":8724,"id":178723,"goal":"lemma LeRefl_8724(i: real)\n ensures i <= i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_8725","instance":8725,"id":178724,"goal":"lemma LeTrans_8725(c: int, k: int, i: int)\n requires c <= k && k <= i\n ensures c <= i\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_8726","instance":8726,"id":178725,"goal":"lemma AddMono_8726(m: nat, y: nat, d: nat)\n requires m <= y\n ensures m + d <= y + d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_8727","instance":8727,"id":178726,"goal":"lemma Abs_Nonneg_8727(d: real)\n ensures (if d >= 0 then d else -d) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_8728","instance":8728,"id":178727,"goal":"lemma DivMod_8728(b: int, i: int)\n requires i > 0\n ensures b == i * (b / i) + (b % i)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_8729","instance":8729,"id":178728,"goal":"lemma ModBounds_8729(m: nat, x: nat)\n requires x > 0\n ensures 0 <= m % x < x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_8730","instance":8730,"id":178729,"goal":"lemma Square_Nonneg_8730(a: real)\n ensures a * a >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_8731","instance":8731,"id":178730,"goal":"lemma AddComm_8731(y: int, c: int)\n ensures y + c == c + y\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_8732","instance":8732,"id":178731,"goal":"lemma AddAssoc_8732(b: nat, c: nat, a: nat)\n ensures (b + c) + a == b + (c + a)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_8733","instance":8733,"id":178732,"goal":"lemma MulComm_8733(n: real, d: real)\n ensures n * d == d * n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_8734","instance":8734,"id":178733,"goal":"lemma MulAssoc_8734(z: int, a: int, i: int)\n ensures (z * a) * i == z * (a * i)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_8735","instance":8735,"id":178734,"goal":"lemma Distrib_8735(x: nat, a: nat, j: nat)\n ensures x * (a + j) == x * a + x * j\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_8736","instance":8736,"id":178735,"goal":"lemma AddZero_8736(n: real)\n ensures n + 0 == n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_8737","instance":8737,"id":178736,"goal":"lemma MulOne_8737(x: int)\n ensures x * 1 == x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_8738","instance":8738,"id":178737,"goal":"lemma MulZero_8738(y: nat)\n ensures y * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_8739","instance":8739,"id":178738,"goal":"lemma LeRefl_8739(k: real)\n ensures k <= k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_8740","instance":8740,"id":178739,"goal":"lemma LeTrans_8740(d: int, m: int, b: int)\n requires d <= m && m <= b\n ensures d <= b\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_8741","instance":8741,"id":178740,"goal":"lemma AddMono_8741(b: nat, a: nat, n: nat)\n requires b <= a\n ensures b + n <= a + n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_8742","instance":8742,"id":178741,"goal":"lemma Abs_Nonneg_8742(b: real)\n ensures (if b >= 0 then b else -b) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_8743","instance":8743,"id":178742,"goal":"lemma DivMod_8743(c: int, x: int)\n requires x > 0\n ensures c == x * (c / x) + (c % x)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_8744","instance":8744,"id":178743,"goal":"lemma ModBounds_8744(d: nat, y: nat)\n requires y > 0\n ensures 0 <= d % y < y\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_8745","instance":8745,"id":178744,"goal":"lemma Square_Nonneg_8745(k: real)\n ensures k * k >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_8746","instance":8746,"id":178745,"goal":"lemma AddComm_8746(i: int, m: int)\n ensures i + m == m + i\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_8747","instance":8747,"id":178746,"goal":"lemma AddAssoc_8747(x: nat, b: nat, n: nat)\n ensures (x + b) + n == x + (b + n)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_8748","instance":8748,"id":178747,"goal":"lemma MulComm_8748(y: real, x: real)\n ensures y * x == x * y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_8749","instance":8749,"id":178748,"goal":"lemma MulAssoc_8749(b: int, y: int, c: int)\n ensures (b * y) * c == b * (y * c)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_8750","instance":8750,"id":178749,"goal":"lemma Distrib_8750(a: nat, k: nat, m: nat)\n ensures a * (k + m) == a * k + a * m\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_8751","instance":8751,"id":178750,"goal":"lemma AddZero_8751(a: real)\n ensures a + 0 == a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_8752","instance":8752,"id":178751,"goal":"lemma MulOne_8752(c: int)\n ensures c * 1 == c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_8753","instance":8753,"id":178752,"goal":"lemma MulZero_8753(j: nat)\n ensures j * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_8754","instance":8754,"id":178753,"goal":"lemma LeRefl_8754(k: real)\n ensures k <= k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_8755","instance":8755,"id":178754,"goal":"lemma LeTrans_8755(j: int, n: int, a: int)\n requires j <= n && n <= a\n ensures j <= a\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_8756","instance":8756,"id":178755,"goal":"lemma AddMono_8756(i: nat, k: nat, b: nat)\n requires i <= k\n ensures i + b <= k + b\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_8757","instance":8757,"id":178756,"goal":"lemma Abs_Nonneg_8757(k: real)\n ensures (if k >= 0 then k else -k) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_8758","instance":8758,"id":178757,"goal":"lemma DivMod_8758(m: int, d: int)\n requires d > 0\n ensures m == d * (m / d) + (m % d)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_8759","instance":8759,"id":178758,"goal":"lemma ModBounds_8759(m: nat, z: nat)\n requires z > 0\n ensures 0 <= m % z < z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_8760","instance":8760,"id":178759,"goal":"lemma Square_Nonneg_8760(m: real)\n ensures m * m >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_8761","instance":8761,"id":178760,"goal":"lemma AddComm_8761(i: int, b: int)\n ensures i + b == b + i\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_8762","instance":8762,"id":178761,"goal":"lemma AddAssoc_8762(n: nat, x: nat, c: nat)\n ensures (n + x) + c == n + (x + c)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_8763","instance":8763,"id":178762,"goal":"lemma MulComm_8763(n: real, c: real)\n ensures n * c == c * n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_8764","instance":8764,"id":178763,"goal":"lemma MulAssoc_8764(c: int, k: int, m: int)\n ensures (c * k) * m == c * (k * m)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_8765","instance":8765,"id":178764,"goal":"lemma Distrib_8765(k: nat, j: nat, n: nat)\n ensures k * (j + n) == k * j + k * n\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_8766","instance":8766,"id":178765,"goal":"lemma AddZero_8766(d: real)\n ensures d + 0 == d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_8767","instance":8767,"id":178766,"goal":"lemma MulOne_8767(j: int)\n ensures j * 1 == j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_8768","instance":8768,"id":178767,"goal":"lemma MulZero_8768(y: nat)\n ensures y * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_8769","instance":8769,"id":178768,"goal":"lemma LeRefl_8769(z: real)\n ensures z <= z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_8770","instance":8770,"id":178769,"goal":"lemma LeTrans_8770(a: int, b: int, y: int)\n requires a <= b && b <= y\n ensures a <= y\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_8771","instance":8771,"id":178770,"goal":"lemma AddMono_8771(d: nat, a: nat, c: nat)\n requires d <= a\n ensures d + c <= a + c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_8772","instance":8772,"id":178771,"goal":"lemma Abs_Nonneg_8772(i: real)\n ensures (if i >= 0 then i else -i) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_8773","instance":8773,"id":178772,"goal":"lemma DivMod_8773(k: int, b: int)\n requires b > 0\n ensures k == b * (k / b) + (k % b)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_8774","instance":8774,"id":178773,"goal":"lemma ModBounds_8774(m: nat, c: nat)\n requires c > 0\n ensures 0 <= m % c < c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_8775","instance":8775,"id":178774,"goal":"lemma Square_Nonneg_8775(z: real)\n ensures z * z >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_8776","instance":8776,"id":178775,"goal":"lemma AddComm_8776(k: int, m: int)\n ensures k + m == m + k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_8777","instance":8777,"id":178776,"goal":"lemma AddAssoc_8777(x: nat, k: nat, j: nat)\n ensures (x + k) + j == x + (k + j)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_8778","instance":8778,"id":178777,"goal":"lemma MulComm_8778(j: real, y: real)\n ensures j * y == y * j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_8779","instance":8779,"id":178778,"goal":"lemma MulAssoc_8779(a: int, y: int, x: int)\n ensures (a * y) * x == a * (y * x)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_8780","instance":8780,"id":178779,"goal":"lemma Distrib_8780(j: nat, z: nat, d: nat)\n ensures j * (z + d) == j * z + j * d\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_8781","instance":8781,"id":178780,"goal":"lemma AddZero_8781(b: real)\n ensures b + 0 == b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_8782","instance":8782,"id":178781,"goal":"lemma MulOne_8782(z: int)\n ensures z * 1 == z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_8783","instance":8783,"id":178782,"goal":"lemma MulZero_8783(y: nat)\n ensures y * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_8784","instance":8784,"id":178783,"goal":"lemma LeRefl_8784(d: real)\n ensures d <= d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_8785","instance":8785,"id":178784,"goal":"lemma LeTrans_8785(a: int, x: int, b: int)\n requires a <= x && x <= b\n ensures a <= b\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_8786","instance":8786,"id":178785,"goal":"lemma AddMono_8786(x: nat, i: nat, m: nat)\n requires x <= i\n ensures x + m <= i + m\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_8787","instance":8787,"id":178786,"goal":"lemma Abs_Nonneg_8787(m: real)\n ensures (if m >= 0 then m else -m) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_8788","instance":8788,"id":178787,"goal":"lemma DivMod_8788(i: int, j: int)\n requires j > 0\n ensures i == j * (i / j) + (i % j)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_8789","instance":8789,"id":178788,"goal":"lemma ModBounds_8789(n: nat, z: nat)\n requires z > 0\n ensures 0 <= n % z < z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_8790","instance":8790,"id":178789,"goal":"lemma Square_Nonneg_8790(m: real)\n ensures m * m >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_8791","instance":8791,"id":178790,"goal":"lemma AddComm_8791(n: int, b: int)\n ensures n + b == b + n\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_8792","instance":8792,"id":178791,"goal":"lemma AddAssoc_8792(c: nat, d: nat, a: nat)\n ensures (c + d) + a == c + (d + a)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_8793","instance":8793,"id":178792,"goal":"lemma MulComm_8793(d: real, j: real)\n ensures d * j == j * d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_8794","instance":8794,"id":178793,"goal":"lemma MulAssoc_8794(m: int, y: int, d: int)\n ensures (m * y) * d == m * (y * d)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_8795","instance":8795,"id":178794,"goal":"lemma Distrib_8795(a: nat, c: nat, i: nat)\n ensures a * (c + i) == a * c + a * i\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_8796","instance":8796,"id":178795,"goal":"lemma AddZero_8796(m: real)\n ensures m + 0 == m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_8797","instance":8797,"id":178796,"goal":"lemma MulOne_8797(b: int)\n ensures b * 1 == b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_8798","instance":8798,"id":178797,"goal":"lemma MulZero_8798(a: nat)\n ensures a * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_8799","instance":8799,"id":178798,"goal":"lemma LeRefl_8799(x: real)\n ensures x <= x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_8800","instance":8800,"id":178799,"goal":"lemma LeTrans_8800(z: int, n: int, c: int)\n requires z <= n && n <= c\n ensures z <= c\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_8801","instance":8801,"id":178800,"goal":"lemma AddMono_8801(b: nat, k: nat, x: nat)\n requires b <= k\n ensures b + x <= k + x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_8802","instance":8802,"id":178801,"goal":"lemma Abs_Nonneg_8802(j: real)\n ensures (if j >= 0 then j else -j) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_8803","instance":8803,"id":178802,"goal":"lemma DivMod_8803(a: int, i: int)\n requires i > 0\n ensures a == i * (a / i) + (a % i)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_8804","instance":8804,"id":178803,"goal":"lemma ModBounds_8804(m: nat, i: nat)\n requires i > 0\n ensures 0 <= m % i < i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_8805","instance":8805,"id":178804,"goal":"lemma Square_Nonneg_8805(d: real)\n ensures d * d >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_8806","instance":8806,"id":178805,"goal":"lemma AddComm_8806(j: int, y: int)\n ensures j + y == y + j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_8807","instance":8807,"id":178806,"goal":"lemma AddAssoc_8807(n: nat, j: nat, a: nat)\n ensures (n + j) + a == n + (j + a)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_8808","instance":8808,"id":178807,"goal":"lemma MulComm_8808(y: real, d: real)\n ensures y * d == d * y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_8809","instance":8809,"id":178808,"goal":"lemma MulAssoc_8809(j: int, x: int, k: int)\n ensures (j * x) * k == j * (x * k)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_8810","instance":8810,"id":178809,"goal":"lemma Distrib_8810(j: nat, m: nat, d: nat)\n ensures j * (m + d) == j * m + j * d\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_8811","instance":8811,"id":178810,"goal":"lemma AddZero_8811(c: real)\n ensures c + 0 == c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_8812","instance":8812,"id":178811,"goal":"lemma MulOne_8812(m: int)\n ensures m * 1 == m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_8813","instance":8813,"id":178812,"goal":"lemma MulZero_8813(a: nat)\n ensures a * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_8814","instance":8814,"id":178813,"goal":"lemma LeRefl_8814(b: real)\n ensures b <= b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_8815","instance":8815,"id":178814,"goal":"lemma LeTrans_8815(k: int, m: int, a: int)\n requires k <= m && m <= a\n ensures k <= a\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_8816","instance":8816,"id":178815,"goal":"lemma AddMono_8816(y: nat, x: nat, k: nat)\n requires y <= x\n ensures y + k <= x + k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_8817","instance":8817,"id":178816,"goal":"lemma Abs_Nonneg_8817(k: real)\n ensures (if k >= 0 then k else -k) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_8818","instance":8818,"id":178817,"goal":"lemma DivMod_8818(y: int, a: int)\n requires a > 0\n ensures y == a * (y / a) + (y % a)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_8819","instance":8819,"id":178818,"goal":"lemma ModBounds_8819(a: nat, n: nat)\n requires n > 0\n ensures 0 <= a % n < n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_8820","instance":8820,"id":178819,"goal":"lemma Square_Nonneg_8820(y: real)\n ensures y * y >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_8821","instance":8821,"id":178820,"goal":"lemma AddComm_8821(k: int, d: int)\n ensures k + d == d + k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_8822","instance":8822,"id":178821,"goal":"lemma AddAssoc_8822(y: nat, i: nat, k: nat)\n ensures (y + i) + k == y + (i + k)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_8823","instance":8823,"id":178822,"goal":"lemma MulComm_8823(b: real, d: real)\n ensures b * d == d * b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_8824","instance":8824,"id":178823,"goal":"lemma MulAssoc_8824(y: int, a: int, j: int)\n ensures (y * a) * j == y * (a * j)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_8825","instance":8825,"id":178824,"goal":"lemma Distrib_8825(a: nat, i: nat, z: nat)\n ensures a * (i + z) == a * i + a * z\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_8826","instance":8826,"id":178825,"goal":"lemma AddZero_8826(m: real)\n ensures m + 0 == m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_8827","instance":8827,"id":178826,"goal":"lemma MulOne_8827(y: int)\n ensures y * 1 == y\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_8828","instance":8828,"id":178827,"goal":"lemma MulZero_8828(d: nat)\n ensures d * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_8829","instance":8829,"id":178828,"goal":"lemma LeRefl_8829(k: real)\n ensures k <= k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_8830","instance":8830,"id":178829,"goal":"lemma LeTrans_8830(b: int, z: int, d: int)\n requires b <= z && z <= d\n ensures b <= d\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_8831","instance":8831,"id":178830,"goal":"lemma AddMono_8831(a: nat, c: nat, b: nat)\n requires a <= c\n ensures a + b <= c + b\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_8832","instance":8832,"id":178831,"goal":"lemma Abs_Nonneg_8832(k: real)\n ensures (if k >= 0 then k else -k) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_8833","instance":8833,"id":178832,"goal":"lemma DivMod_8833(k: int, m: int)\n requires m > 0\n ensures k == m * (k / m) + (k % m)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_8834","instance":8834,"id":178833,"goal":"lemma ModBounds_8834(i: nat, d: nat)\n requires d > 0\n ensures 0 <= i % d < d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_8835","instance":8835,"id":178834,"goal":"lemma Square_Nonneg_8835(y: real)\n ensures y * y >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_8836","instance":8836,"id":178835,"goal":"lemma AddComm_8836(x: int, m: int)\n ensures x + m == m + x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_8837","instance":8837,"id":178836,"goal":"lemma AddAssoc_8837(x: nat, n: nat, y: nat)\n ensures (x + n) + y == x + (n + y)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_8838","instance":8838,"id":178837,"goal":"lemma MulComm_8838(y: real, x: real)\n ensures y * x == x * y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_8839","instance":8839,"id":178838,"goal":"lemma MulAssoc_8839(x: int, k: int, b: int)\n ensures (x * k) * b == x * (k * b)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_8840","instance":8840,"id":178839,"goal":"lemma Distrib_8840(i: nat, a: nat, d: nat)\n ensures i * (a + d) == i * a + i * d\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_8841","instance":8841,"id":178840,"goal":"lemma AddZero_8841(n: real)\n ensures n + 0 == n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_8842","instance":8842,"id":178841,"goal":"lemma MulOne_8842(c: int)\n ensures c * 1 == c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_8843","instance":8843,"id":178842,"goal":"lemma MulZero_8843(m: nat)\n ensures m * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_8844","instance":8844,"id":178843,"goal":"lemma LeRefl_8844(i: real)\n ensures i <= i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_8845","instance":8845,"id":178844,"goal":"lemma LeTrans_8845(z: int, x: int, k: int)\n requires z <= x && x <= k\n ensures z <= k\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_8846","instance":8846,"id":178845,"goal":"lemma AddMono_8846(x: nat, d: nat, n: nat)\n requires x <= d\n ensures x + n <= d + n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_8847","instance":8847,"id":178846,"goal":"lemma Abs_Nonneg_8847(i: real)\n ensures (if i >= 0 then i else -i) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_8848","instance":8848,"id":178847,"goal":"lemma DivMod_8848(i: int, m: int)\n requires m > 0\n ensures i == m * (i / m) + (i % m)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_8849","instance":8849,"id":178848,"goal":"lemma ModBounds_8849(k: nat, i: nat)\n requires i > 0\n ensures 0 <= k % i < i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_8850","instance":8850,"id":178849,"goal":"lemma Square_Nonneg_8850(x: real)\n ensures x * x >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_8851","instance":8851,"id":178850,"goal":"lemma AddComm_8851(i: int, y: int)\n ensures i + y == y + i\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_8852","instance":8852,"id":178851,"goal":"lemma AddAssoc_8852(y: nat, j: nat, z: nat)\n ensures (y + j) + z == y + (j + z)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_8853","instance":8853,"id":178852,"goal":"lemma MulComm_8853(n: real, a: real)\n ensures n * a == a * n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_8854","instance":8854,"id":178853,"goal":"lemma MulAssoc_8854(i: int, a: int, y: int)\n ensures (i * a) * y == i * (a * y)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_8855","instance":8855,"id":178854,"goal":"lemma Distrib_8855(a: nat, b: nat, i: nat)\n ensures a * (b + i) == a * b + a * i\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_8856","instance":8856,"id":178855,"goal":"lemma AddZero_8856(y: real)\n ensures y + 0 == y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_8857","instance":8857,"id":178856,"goal":"lemma MulOne_8857(k: int)\n ensures k * 1 == k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_8858","instance":8858,"id":178857,"goal":"lemma MulZero_8858(n: nat)\n ensures n * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_8859","instance":8859,"id":178858,"goal":"lemma LeRefl_8859(x: real)\n ensures x <= x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_8860","instance":8860,"id":178859,"goal":"lemma LeTrans_8860(i: int, a: int, b: int)\n requires i <= a && a <= b\n ensures i <= b\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_8861","instance":8861,"id":178860,"goal":"lemma AddMono_8861(n: nat, a: nat, c: nat)\n requires n <= a\n ensures n + c <= a + c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_8862","instance":8862,"id":178861,"goal":"lemma Abs_Nonneg_8862(y: real)\n ensures (if y >= 0 then y else -y) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_8863","instance":8863,"id":178862,"goal":"lemma DivMod_8863(n: int, b: int)\n requires b > 0\n ensures n == b * (n / b) + (n % b)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_8864","instance":8864,"id":178863,"goal":"lemma ModBounds_8864(y: nat, x: nat)\n requires x > 0\n ensures 0 <= y % x < x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_8865","instance":8865,"id":178864,"goal":"lemma Square_Nonneg_8865(n: real)\n ensures n * n >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_8866","instance":8866,"id":178865,"goal":"lemma AddComm_8866(y: int, c: int)\n ensures y + c == c + y\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_8867","instance":8867,"id":178866,"goal":"lemma AddAssoc_8867(b: nat, n: nat, j: nat)\n ensures (b + n) + j == b + (n + j)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_8868","instance":8868,"id":178867,"goal":"lemma MulComm_8868(k: real, z: real)\n ensures k * z == z * k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_8869","instance":8869,"id":178868,"goal":"lemma MulAssoc_8869(b: int, c: int, z: int)\n ensures (b * c) * z == b * (c * z)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_8870","instance":8870,"id":178869,"goal":"lemma Distrib_8870(m: nat, z: nat, a: nat)\n ensures m * (z + a) == m * z + m * a\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_8871","instance":8871,"id":178870,"goal":"lemma AddZero_8871(x: real)\n ensures x + 0 == x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_8872","instance":8872,"id":178871,"goal":"lemma MulOne_8872(b: int)\n ensures b * 1 == b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_8873","instance":8873,"id":178872,"goal":"lemma MulZero_8873(z: nat)\n ensures z * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_8874","instance":8874,"id":178873,"goal":"lemma LeRefl_8874(z: real)\n ensures z <= z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_8875","instance":8875,"id":178874,"goal":"lemma LeTrans_8875(x: int, n: int, a: int)\n requires x <= n && n <= a\n ensures x <= a\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_8876","instance":8876,"id":178875,"goal":"lemma AddMono_8876(z: nat, x: nat, k: nat)\n requires z <= x\n ensures z + k <= x + k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_8877","instance":8877,"id":178876,"goal":"lemma Abs_Nonneg_8877(z: real)\n ensures (if z >= 0 then z else -z) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_8878","instance":8878,"id":178877,"goal":"lemma DivMod_8878(x: int, k: int)\n requires k > 0\n ensures x == k * (x / k) + (x % k)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_8879","instance":8879,"id":178878,"goal":"lemma ModBounds_8879(y: nat, n: nat)\n requires n > 0\n ensures 0 <= y % n < n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_8880","instance":8880,"id":178879,"goal":"lemma Square_Nonneg_8880(a: real)\n ensures a * a >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_8881","instance":8881,"id":178880,"goal":"lemma AddComm_8881(i: int, z: int)\n ensures i + z == z + i\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_8882","instance":8882,"id":178881,"goal":"lemma AddAssoc_8882(n: nat, a: nat, k: nat)\n ensures (n + a) + k == n + (a + k)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_8883","instance":8883,"id":178882,"goal":"lemma MulComm_8883(b: real, n: real)\n ensures b * n == n * b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_8884","instance":8884,"id":178883,"goal":"lemma MulAssoc_8884(a: int, b: int, c: int)\n ensures (a * b) * c == a * (b * c)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_8885","instance":8885,"id":178884,"goal":"lemma Distrib_8885(m: nat, x: nat, y: nat)\n ensures m * (x + y) == m * x + m * y\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_8886","instance":8886,"id":178885,"goal":"lemma AddZero_8886(c: real)\n ensures c + 0 == c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_8887","instance":8887,"id":178886,"goal":"lemma MulOne_8887(y: int)\n ensures y * 1 == y\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_8888","instance":8888,"id":178887,"goal":"lemma MulZero_8888(n: nat)\n ensures n * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_8889","instance":8889,"id":178888,"goal":"lemma LeRefl_8889(c: real)\n ensures c <= c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_8890","instance":8890,"id":178889,"goal":"lemma LeTrans_8890(i: int, k: int, z: int)\n requires i <= k && k <= z\n ensures i <= z\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_8891","instance":8891,"id":178890,"goal":"lemma AddMono_8891(x: nat, j: nat, a: nat)\n requires x <= j\n ensures x + a <= j + a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_8892","instance":8892,"id":178891,"goal":"lemma Abs_Nonneg_8892(j: real)\n ensures (if j >= 0 then j else -j) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_8893","instance":8893,"id":178892,"goal":"lemma DivMod_8893(k: int, m: int)\n requires m > 0\n ensures k == m * (k / m) + (k % m)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_8894","instance":8894,"id":178893,"goal":"lemma ModBounds_8894(i: nat, m: nat)\n requires m > 0\n ensures 0 <= i % m < m\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_8895","instance":8895,"id":178894,"goal":"lemma Square_Nonneg_8895(z: real)\n ensures z * z >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_8896","instance":8896,"id":178895,"goal":"lemma AddComm_8896(k: int, a: int)\n ensures k + a == a + k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_8897","instance":8897,"id":178896,"goal":"lemma AddAssoc_8897(c: nat, a: nat, n: nat)\n ensures (c + a) + n == c + (a + n)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_8898","instance":8898,"id":178897,"goal":"lemma MulComm_8898(c: real, a: real)\n ensures c * a == a * c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_8899","instance":8899,"id":178898,"goal":"lemma MulAssoc_8899(b: int, k: int, c: int)\n ensures (b * k) * c == b * (k * c)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_8900","instance":8900,"id":178899,"goal":"lemma Distrib_8900(n: nat, z: nat, y: nat)\n ensures n * (z + y) == n * z + n * y\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_8901","instance":8901,"id":178900,"goal":"lemma AddZero_8901(a: real)\n ensures a + 0 == a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_8902","instance":8902,"id":178901,"goal":"lemma MulOne_8902(k: int)\n ensures k * 1 == k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_8903","instance":8903,"id":178902,"goal":"lemma MulZero_8903(z: nat)\n ensures z * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_8904","instance":8904,"id":178903,"goal":"lemma LeRefl_8904(n: real)\n ensures n <= n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_8905","instance":8905,"id":178904,"goal":"lemma LeTrans_8905(y: int, k: int, i: int)\n requires y <= k && k <= i\n ensures y <= i\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_8906","instance":8906,"id":178905,"goal":"lemma AddMono_8906(y: nat, m: nat, a: nat)\n requires y <= m\n ensures y + a <= m + a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_8907","instance":8907,"id":178906,"goal":"lemma Abs_Nonneg_8907(c: real)\n ensures (if c >= 0 then c else -c) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_8908","instance":8908,"id":178907,"goal":"lemma DivMod_8908(c: int, m: int)\n requires m > 0\n ensures c == m * (c / m) + (c % m)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_8909","instance":8909,"id":178908,"goal":"lemma ModBounds_8909(y: nat, a: nat)\n requires a > 0\n ensures 0 <= y % a < a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_8910","instance":8910,"id":178909,"goal":"lemma Square_Nonneg_8910(b: real)\n ensures b * b >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_8911","instance":8911,"id":178910,"goal":"lemma AddComm_8911(z: int, x: int)\n ensures z + x == x + z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_8912","instance":8912,"id":178911,"goal":"lemma AddAssoc_8912(y: nat, b: nat, j: nat)\n ensures (y + b) + j == y + (b + j)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_8913","instance":8913,"id":178912,"goal":"lemma MulComm_8913(z: real, y: real)\n ensures z * y == y * z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_8914","instance":8914,"id":178913,"goal":"lemma MulAssoc_8914(x: int, j: int, z: int)\n ensures (x * j) * z == x * (j * z)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_8915","instance":8915,"id":178914,"goal":"lemma Distrib_8915(z: nat, y: nat, i: nat)\n ensures z * (y + i) == z * y + z * i\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_8916","instance":8916,"id":178915,"goal":"lemma AddZero_8916(x: real)\n ensures x + 0 == x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_8917","instance":8917,"id":178916,"goal":"lemma MulOne_8917(m: int)\n ensures m * 1 == m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_8918","instance":8918,"id":178917,"goal":"lemma MulZero_8918(k: nat)\n ensures k * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_8919","instance":8919,"id":178918,"goal":"lemma LeRefl_8919(a: real)\n ensures a <= a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_8920","instance":8920,"id":178919,"goal":"lemma LeTrans_8920(m: int, a: int, d: int)\n requires m <= a && a <= d\n ensures m <= d\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_8921","instance":8921,"id":178920,"goal":"lemma AddMono_8921(m: nat, y: nat, a: nat)\n requires m <= y\n ensures m + a <= y + a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_8922","instance":8922,"id":178921,"goal":"lemma Abs_Nonneg_8922(c: real)\n ensures (if c >= 0 then c else -c) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_8923","instance":8923,"id":178922,"goal":"lemma DivMod_8923(k: int, b: int)\n requires b > 0\n ensures k == b * (k / b) + (k % b)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_8924","instance":8924,"id":178923,"goal":"lemma ModBounds_8924(j: nat, z: nat)\n requires z > 0\n ensures 0 <= j % z < z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_8925","instance":8925,"id":178924,"goal":"lemma Square_Nonneg_8925(m: real)\n ensures m * m >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_8926","instance":8926,"id":178925,"goal":"lemma AddComm_8926(j: int, n: int)\n ensures j + n == n + j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_8927","instance":8927,"id":178926,"goal":"lemma AddAssoc_8927(b: nat, z: nat, c: nat)\n ensures (b + z) + c == b + (z + c)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_8928","instance":8928,"id":178927,"goal":"lemma MulComm_8928(j: real, x: real)\n ensures j * x == x * j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_8929","instance":8929,"id":178928,"goal":"lemma MulAssoc_8929(k: int, z: int, x: int)\n ensures (k * z) * x == k * (z * x)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_8930","instance":8930,"id":178929,"goal":"lemma Distrib_8930(m: nat, i: nat, a: nat)\n ensures m * (i + a) == m * i + m * a\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_8931","instance":8931,"id":178930,"goal":"lemma AddZero_8931(d: real)\n ensures d + 0 == d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_8932","instance":8932,"id":178931,"goal":"lemma MulOne_8932(m: int)\n ensures m * 1 == m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_8933","instance":8933,"id":178932,"goal":"lemma MulZero_8933(z: nat)\n ensures z * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_8934","instance":8934,"id":178933,"goal":"lemma LeRefl_8934(i: real)\n ensures i <= i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_8935","instance":8935,"id":178934,"goal":"lemma LeTrans_8935(d: int, b: int, i: int)\n requires d <= b && b <= i\n ensures d <= i\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_8936","instance":8936,"id":178935,"goal":"lemma AddMono_8936(j: nat, m: nat, c: nat)\n requires j <= m\n ensures j + c <= m + c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_8937","instance":8937,"id":178936,"goal":"lemma Abs_Nonneg_8937(z: real)\n ensures (if z >= 0 then z else -z) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_8938","instance":8938,"id":178937,"goal":"lemma DivMod_8938(y: int, n: int)\n requires n > 0\n ensures y == n * (y / n) + (y % n)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_8939","instance":8939,"id":178938,"goal":"lemma ModBounds_8939(y: nat, j: nat)\n requires j > 0\n ensures 0 <= y % j < j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_8940","instance":8940,"id":178939,"goal":"lemma Square_Nonneg_8940(z: real)\n ensures z * z >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_8941","instance":8941,"id":178940,"goal":"lemma AddComm_8941(z: int, b: int)\n ensures z + b == b + z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_8942","instance":8942,"id":178941,"goal":"lemma AddAssoc_8942(z: nat, i: nat, x: nat)\n ensures (z + i) + x == z + (i + x)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_8943","instance":8943,"id":178942,"goal":"lemma MulComm_8943(a: real, b: real)\n ensures a * b == b * a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_8944","instance":8944,"id":178943,"goal":"lemma MulAssoc_8944(k: int, z: int, x: int)\n ensures (k * z) * x == k * (z * x)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_8945","instance":8945,"id":178944,"goal":"lemma Distrib_8945(c: nat, a: nat, m: nat)\n ensures c * (a + m) == c * a + c * m\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_8946","instance":8946,"id":178945,"goal":"lemma AddZero_8946(z: real)\n ensures z + 0 == z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_8947","instance":8947,"id":178946,"goal":"lemma MulOne_8947(a: int)\n ensures a * 1 == a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_8948","instance":8948,"id":178947,"goal":"lemma MulZero_8948(i: nat)\n ensures i * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_8949","instance":8949,"id":178948,"goal":"lemma LeRefl_8949(x: real)\n ensures x <= x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_8950","instance":8950,"id":178949,"goal":"lemma LeTrans_8950(y: int, m: int, k: int)\n requires y <= m && m <= k\n ensures y <= k\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_8951","instance":8951,"id":178950,"goal":"lemma AddMono_8951(z: nat, a: nat, b: nat)\n requires z <= a\n ensures z + b <= a + b\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_8952","instance":8952,"id":178951,"goal":"lemma Abs_Nonneg_8952(j: real)\n ensures (if j >= 0 then j else -j) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_8953","instance":8953,"id":178952,"goal":"lemma DivMod_8953(z: int, d: int)\n requires d > 0\n ensures z == d * (z / d) + (z % d)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_8954","instance":8954,"id":178953,"goal":"lemma ModBounds_8954(m: nat, n: nat)\n requires n > 0\n ensures 0 <= m % n < n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_8955","instance":8955,"id":178954,"goal":"lemma Square_Nonneg_8955(a: real)\n ensures a * a >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_8956","instance":8956,"id":178955,"goal":"lemma AddComm_8956(a: int, y: int)\n ensures a + y == y + a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_8957","instance":8957,"id":178956,"goal":"lemma AddAssoc_8957(a: nat, b: nat, n: nat)\n ensures (a + b) + n == a + (b + n)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_8958","instance":8958,"id":178957,"goal":"lemma MulComm_8958(i: real, x: real)\n ensures i * x == x * i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_8959","instance":8959,"id":178958,"goal":"lemma MulAssoc_8959(c: int, n: int, x: int)\n ensures (c * n) * x == c * (n * x)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_8960","instance":8960,"id":178959,"goal":"lemma Distrib_8960(b: nat, c: nat, z: nat)\n ensures b * (c + z) == b * c + b * z\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_8961","instance":8961,"id":178960,"goal":"lemma AddZero_8961(c: real)\n ensures c + 0 == c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_8962","instance":8962,"id":178961,"goal":"lemma MulOne_8962(y: int)\n ensures y * 1 == y\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_8963","instance":8963,"id":178962,"goal":"lemma MulZero_8963(x: nat)\n ensures x * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_8964","instance":8964,"id":178963,"goal":"lemma LeRefl_8964(z: real)\n ensures z <= z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_8965","instance":8965,"id":178964,"goal":"lemma LeTrans_8965(c: int, b: int, n: int)\n requires c <= b && b <= n\n ensures c <= n\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_8966","instance":8966,"id":178965,"goal":"lemma AddMono_8966(a: nat, n: nat, z: nat)\n requires a <= n\n ensures a + z <= n + z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_8967","instance":8967,"id":178966,"goal":"lemma Abs_Nonneg_8967(z: real)\n ensures (if z >= 0 then z else -z) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_8968","instance":8968,"id":178967,"goal":"lemma DivMod_8968(n: int, z: int)\n requires z > 0\n ensures n == z * (n / z) + (n % z)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_8969","instance":8969,"id":178968,"goal":"lemma ModBounds_8969(y: nat, z: nat)\n requires z > 0\n ensures 0 <= y % z < z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_8970","instance":8970,"id":178969,"goal":"lemma Square_Nonneg_8970(a: real)\n ensures a * a >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_8971","instance":8971,"id":178970,"goal":"lemma AddComm_8971(j: int, b: int)\n ensures j + b == b + j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_8972","instance":8972,"id":178971,"goal":"lemma AddAssoc_8972(a: nat, y: nat, m: nat)\n ensures (a + y) + m == a + (y + m)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_8973","instance":8973,"id":178972,"goal":"lemma MulComm_8973(n: real, y: real)\n ensures n * y == y * n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_8974","instance":8974,"id":178973,"goal":"lemma MulAssoc_8974(y: int, k: int, c: int)\n ensures (y * k) * c == y * (k * c)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_8975","instance":8975,"id":178974,"goal":"lemma Distrib_8975(c: nat, k: nat, m: nat)\n ensures c * (k + m) == c * k + c * m\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_8976","instance":8976,"id":178975,"goal":"lemma AddZero_8976(n: real)\n ensures n + 0 == n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_8977","instance":8977,"id":178976,"goal":"lemma MulOne_8977(k: int)\n ensures k * 1 == k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_8978","instance":8978,"id":178977,"goal":"lemma MulZero_8978(a: nat)\n ensures a * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_8979","instance":8979,"id":178978,"goal":"lemma LeRefl_8979(i: real)\n ensures i <= i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_8980","instance":8980,"id":178979,"goal":"lemma LeTrans_8980(y: int, j: int, a: int)\n requires y <= j && j <= a\n ensures y <= a\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_8981","instance":8981,"id":178980,"goal":"lemma AddMono_8981(d: nat, c: nat, x: nat)\n requires d <= c\n ensures d + x <= c + x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_8982","instance":8982,"id":178981,"goal":"lemma Abs_Nonneg_8982(d: real)\n ensures (if d >= 0 then d else -d) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_8983","instance":8983,"id":178982,"goal":"lemma DivMod_8983(c: int, z: int)\n requires z > 0\n ensures c == z * (c / z) + (c % z)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_8984","instance":8984,"id":178983,"goal":"lemma ModBounds_8984(b: nat, j: nat)\n requires j > 0\n ensures 0 <= b % j < j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_8985","instance":8985,"id":178984,"goal":"lemma Square_Nonneg_8985(k: real)\n ensures k * k >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_8986","instance":8986,"id":178985,"goal":"lemma AddComm_8986(j: int, y: int)\n ensures j + y == y + j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_8987","instance":8987,"id":178986,"goal":"lemma AddAssoc_8987(y: nat, d: nat, j: nat)\n ensures (y + d) + j == y + (d + j)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_8988","instance":8988,"id":178987,"goal":"lemma MulComm_8988(i: real, a: real)\n ensures i * a == a * i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_8989","instance":8989,"id":178988,"goal":"lemma MulAssoc_8989(z: int, k: int, b: int)\n ensures (z * k) * b == z * (k * b)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_8990","instance":8990,"id":178989,"goal":"lemma Distrib_8990(m: nat, i: nat, a: nat)\n ensures m * (i + a) == m * i + m * a\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_8991","instance":8991,"id":178990,"goal":"lemma AddZero_8991(m: real)\n ensures m + 0 == m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_8992","instance":8992,"id":178991,"goal":"lemma MulOne_8992(c: int)\n ensures c * 1 == c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_8993","instance":8993,"id":178992,"goal":"lemma MulZero_8993(y: nat)\n ensures y * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_8994","instance":8994,"id":178993,"goal":"lemma LeRefl_8994(a: real)\n ensures a <= a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_8995","instance":8995,"id":178994,"goal":"lemma LeTrans_8995(n: int, m: int, b: int)\n requires n <= m && m <= b\n ensures n <= b\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_8996","instance":8996,"id":178995,"goal":"lemma AddMono_8996(m: nat, j: nat, i: nat)\n requires m <= j\n ensures m + i <= j + i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_8997","instance":8997,"id":178996,"goal":"lemma Abs_Nonneg_8997(c: real)\n ensures (if c >= 0 then c else -c) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_8998","instance":8998,"id":178997,"goal":"lemma DivMod_8998(c: int, x: int)\n requires x > 0\n ensures c == x * (c / x) + (c % x)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_8999","instance":8999,"id":178998,"goal":"lemma ModBounds_8999(z: nat, m: nat)\n requires m > 0\n ensures 0 <= z % m < m\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_9000","instance":9000,"id":178999,"goal":"lemma Square_Nonneg_9000(c: real)\n ensures c * c >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_9001","instance":9001,"id":179000,"goal":"lemma AddComm_9001(k: int, d: int)\n ensures k + d == d + k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_9002","instance":9002,"id":179001,"goal":"lemma AddAssoc_9002(b: nat, y: nat, d: nat)\n ensures (b + y) + d == b + (y + d)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_9003","instance":9003,"id":179002,"goal":"lemma MulComm_9003(a: real, n: real)\n ensures a * n == n * a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_9004","instance":9004,"id":179003,"goal":"lemma MulAssoc_9004(c: int, k: int, y: int)\n ensures (c * k) * y == c * (k * y)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_9005","instance":9005,"id":179004,"goal":"lemma Distrib_9005(n: nat, c: nat, a: nat)\n ensures n * (c + a) == n * c + n * a\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_9006","instance":9006,"id":179005,"goal":"lemma AddZero_9006(b: real)\n ensures b + 0 == b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_9007","instance":9007,"id":179006,"goal":"lemma MulOne_9007(y: int)\n ensures y * 1 == y\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_9008","instance":9008,"id":179007,"goal":"lemma MulZero_9008(x: nat)\n ensures x * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_9009","instance":9009,"id":179008,"goal":"lemma LeRefl_9009(i: real)\n ensures i <= i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_9010","instance":9010,"id":179009,"goal":"lemma LeTrans_9010(x: int, a: int, i: int)\n requires x <= a && a <= i\n ensures x <= i\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_9011","instance":9011,"id":179010,"goal":"lemma AddMono_9011(n: nat, y: nat, c: nat)\n requires n <= y\n ensures n + c <= y + c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_9012","instance":9012,"id":179011,"goal":"lemma Abs_Nonneg_9012(i: real)\n ensures (if i >= 0 then i else -i) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_9013","instance":9013,"id":179012,"goal":"lemma DivMod_9013(j: int, m: int)\n requires m > 0\n ensures j == m * (j / m) + (j % m)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_9014","instance":9014,"id":179013,"goal":"lemma ModBounds_9014(b: nat, m: nat)\n requires m > 0\n ensures 0 <= b % m < m\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_9015","instance":9015,"id":179014,"goal":"lemma Square_Nonneg_9015(i: real)\n ensures i * i >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_9016","instance":9016,"id":179015,"goal":"lemma AddComm_9016(m: int, z: int)\n ensures m + z == z + m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_9017","instance":9017,"id":179016,"goal":"lemma AddAssoc_9017(x: nat, b: nat, a: nat)\n ensures (x + b) + a == x + (b + a)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_9018","instance":9018,"id":179017,"goal":"lemma MulComm_9018(m: real, a: real)\n ensures m * a == a * m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_9019","instance":9019,"id":179018,"goal":"lemma MulAssoc_9019(y: int, b: int, k: int)\n ensures (y * b) * k == y * (b * k)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_9020","instance":9020,"id":179019,"goal":"lemma Distrib_9020(n: nat, x: nat, k: nat)\n ensures n * (x + k) == n * x + n * k\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_9021","instance":9021,"id":179020,"goal":"lemma AddZero_9021(x: real)\n ensures x + 0 == x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_9022","instance":9022,"id":179021,"goal":"lemma MulOne_9022(b: int)\n ensures b * 1 == b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_9023","instance":9023,"id":179022,"goal":"lemma MulZero_9023(c: nat)\n ensures c * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_9024","instance":9024,"id":179023,"goal":"lemma LeRefl_9024(a: real)\n ensures a <= a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_9025","instance":9025,"id":179024,"goal":"lemma LeTrans_9025(m: int, j: int, a: int)\n requires m <= j && j <= a\n ensures m <= a\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_9026","instance":9026,"id":179025,"goal":"lemma AddMono_9026(k: nat, x: nat, y: nat)\n requires k <= x\n ensures k + y <= x + y\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_9027","instance":9027,"id":179026,"goal":"lemma Abs_Nonneg_9027(x: real)\n ensures (if x >= 0 then x else -x) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_9028","instance":9028,"id":179027,"goal":"lemma DivMod_9028(z: int, j: int)\n requires j > 0\n ensures z == j * (z / j) + (z % j)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_9029","instance":9029,"id":179028,"goal":"lemma ModBounds_9029(z: nat, a: nat)\n requires a > 0\n ensures 0 <= z % a < a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_9030","instance":9030,"id":179029,"goal":"lemma Square_Nonneg_9030(n: real)\n ensures n * n >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_9031","instance":9031,"id":179030,"goal":"lemma AddComm_9031(n: int, b: int)\n ensures n + b == b + n\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_9032","instance":9032,"id":179031,"goal":"lemma AddAssoc_9032(z: nat, y: nat, j: nat)\n ensures (z + y) + j == z + (y + j)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_9033","instance":9033,"id":179032,"goal":"lemma MulComm_9033(c: real, a: real)\n ensures c * a == a * c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_9034","instance":9034,"id":179033,"goal":"lemma MulAssoc_9034(k: int, n: int, b: int)\n ensures (k * n) * b == k * (n * b)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_9035","instance":9035,"id":179034,"goal":"lemma Distrib_9035(y: nat, z: nat, x: nat)\n ensures y * (z + x) == y * z + y * x\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_9036","instance":9036,"id":179035,"goal":"lemma AddZero_9036(c: real)\n ensures c + 0 == c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_9037","instance":9037,"id":179036,"goal":"lemma MulOne_9037(m: int)\n ensures m * 1 == m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_9038","instance":9038,"id":179037,"goal":"lemma MulZero_9038(c: nat)\n ensures c * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_9039","instance":9039,"id":179038,"goal":"lemma LeRefl_9039(c: real)\n ensures c <= c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_9040","instance":9040,"id":179039,"goal":"lemma LeTrans_9040(n: int, y: int, z: int)\n requires n <= y && y <= z\n ensures n <= z\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_9041","instance":9041,"id":179040,"goal":"lemma AddMono_9041(a: nat, m: nat, i: nat)\n requires a <= m\n ensures a + i <= m + i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_9042","instance":9042,"id":179041,"goal":"lemma Abs_Nonneg_9042(y: real)\n ensures (if y >= 0 then y else -y) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_9043","instance":9043,"id":179042,"goal":"lemma DivMod_9043(j: int, a: int)\n requires a > 0\n ensures j == a * (j / a) + (j % a)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_9044","instance":9044,"id":179043,"goal":"lemma ModBounds_9044(m: nat, z: nat)\n requires z > 0\n ensures 0 <= m % z < z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_9045","instance":9045,"id":179044,"goal":"lemma Square_Nonneg_9045(i: real)\n ensures i * i >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_9046","instance":9046,"id":179045,"goal":"lemma AddComm_9046(b: int, y: int)\n ensures b + y == y + b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_9047","instance":9047,"id":179046,"goal":"lemma AddAssoc_9047(i: nat, b: nat, z: nat)\n ensures (i + b) + z == i + (b + z)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_9048","instance":9048,"id":179047,"goal":"lemma MulComm_9048(n: real, a: real)\n ensures n * a == a * n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_9049","instance":9049,"id":179048,"goal":"lemma MulAssoc_9049(y: int, z: int, x: int)\n ensures (y * z) * x == y * (z * x)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_9050","instance":9050,"id":179049,"goal":"lemma Distrib_9050(j: nat, z: nat, y: nat)\n ensures j * (z + y) == j * z + j * y\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_9051","instance":9051,"id":179050,"goal":"lemma AddZero_9051(x: real)\n ensures x + 0 == x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_9052","instance":9052,"id":179051,"goal":"lemma MulOne_9052(z: int)\n ensures z * 1 == z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_9053","instance":9053,"id":179052,"goal":"lemma MulZero_9053(i: nat)\n ensures i * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_9054","instance":9054,"id":179053,"goal":"lemma LeRefl_9054(c: real)\n ensures c <= c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_9055","instance":9055,"id":179054,"goal":"lemma LeTrans_9055(k: int, m: int, y: int)\n requires k <= m && m <= y\n ensures k <= y\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_9056","instance":9056,"id":179055,"goal":"lemma AddMono_9056(n: nat, c: nat, j: nat)\n requires n <= c\n ensures n + j <= c + j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_9057","instance":9057,"id":179056,"goal":"lemma Abs_Nonneg_9057(x: real)\n ensures (if x >= 0 then x else -x) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_9058","instance":9058,"id":179057,"goal":"lemma DivMod_9058(k: int, a: int)\n requires a > 0\n ensures k == a * (k / a) + (k % a)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_9059","instance":9059,"id":179058,"goal":"lemma ModBounds_9059(j: nat, x: nat)\n requires x > 0\n ensures 0 <= j % x < x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_9060","instance":9060,"id":179059,"goal":"lemma Square_Nonneg_9060(j: real)\n ensures j * j >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_9061","instance":9061,"id":179060,"goal":"lemma AddComm_9061(j: int, y: int)\n ensures j + y == y + j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_9062","instance":9062,"id":179061,"goal":"lemma AddAssoc_9062(m: nat, z: nat, j: nat)\n ensures (m + z) + j == m + (z + j)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_9063","instance":9063,"id":179062,"goal":"lemma MulComm_9063(c: real, x: real)\n ensures c * x == x * c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_9064","instance":9064,"id":179063,"goal":"lemma MulAssoc_9064(c: int, k: int, y: int)\n ensures (c * k) * y == c * (k * y)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_9065","instance":9065,"id":179064,"goal":"lemma Distrib_9065(c: nat, n: nat, a: nat)\n ensures c * (n + a) == c * n + c * a\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_9066","instance":9066,"id":179065,"goal":"lemma AddZero_9066(m: real)\n ensures m + 0 == m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_9067","instance":9067,"id":179066,"goal":"lemma MulOne_9067(z: int)\n ensures z * 1 == z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_9068","instance":9068,"id":179067,"goal":"lemma MulZero_9068(d: nat)\n ensures d * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_9069","instance":9069,"id":179068,"goal":"lemma LeRefl_9069(x: real)\n ensures x <= x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_9070","instance":9070,"id":179069,"goal":"lemma LeTrans_9070(c: int, j: int, b: int)\n requires c <= j && j <= b\n ensures c <= b\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_9071","instance":9071,"id":179070,"goal":"lemma AddMono_9071(j: nat, a: nat, n: nat)\n requires j <= a\n ensures j + n <= a + n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_9072","instance":9072,"id":179071,"goal":"lemma Abs_Nonneg_9072(y: real)\n ensures (if y >= 0 then y else -y) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_9073","instance":9073,"id":179072,"goal":"lemma DivMod_9073(c: int, x: int)\n requires x > 0\n ensures c == x * (c / x) + (c % x)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_9074","instance":9074,"id":179073,"goal":"lemma ModBounds_9074(x: nat, y: nat)\n requires y > 0\n ensures 0 <= x % y < y\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_9075","instance":9075,"id":179074,"goal":"lemma Square_Nonneg_9075(m: real)\n ensures m * m >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_9076","instance":9076,"id":179075,"goal":"lemma AddComm_9076(y: int, k: int)\n ensures y + k == k + y\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_9077","instance":9077,"id":179076,"goal":"lemma AddAssoc_9077(j: nat, c: nat, z: nat)\n ensures (j + c) + z == j + (c + z)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_9078","instance":9078,"id":179077,"goal":"lemma MulComm_9078(k: real, i: real)\n ensures k * i == i * k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_9079","instance":9079,"id":179078,"goal":"lemma MulAssoc_9079(n: int, k: int, c: int)\n ensures (n * k) * c == n * (k * c)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_9080","instance":9080,"id":179079,"goal":"lemma Distrib_9080(x: nat, d: nat, j: nat)\n ensures x * (d + j) == x * d + x * j\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_9081","instance":9081,"id":179080,"goal":"lemma AddZero_9081(z: real)\n ensures z + 0 == z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_9082","instance":9082,"id":179081,"goal":"lemma MulOne_9082(y: int)\n ensures y * 1 == y\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_9083","instance":9083,"id":179082,"goal":"lemma MulZero_9083(k: nat)\n ensures k * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_9084","instance":9084,"id":179083,"goal":"lemma LeRefl_9084(d: real)\n ensures d <= d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_9085","instance":9085,"id":179084,"goal":"lemma LeTrans_9085(x: int, a: int, b: int)\n requires x <= a && a <= b\n ensures x <= b\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_9086","instance":9086,"id":179085,"goal":"lemma AddMono_9086(j: nat, c: nat, a: nat)\n requires j <= c\n ensures j + a <= c + a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_9087","instance":9087,"id":179086,"goal":"lemma Abs_Nonneg_9087(a: real)\n ensures (if a >= 0 then a else -a) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_9088","instance":9088,"id":179087,"goal":"lemma DivMod_9088(m: int, d: int)\n requires d > 0\n ensures m == d * (m / d) + (m % d)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_9089","instance":9089,"id":179088,"goal":"lemma ModBounds_9089(a: nat, m: nat)\n requires m > 0\n ensures 0 <= a % m < m\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_9090","instance":9090,"id":179089,"goal":"lemma Square_Nonneg_9090(c: real)\n ensures c * c >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_9091","instance":9091,"id":179090,"goal":"lemma AddComm_9091(x: int, a: int)\n ensures x + a == a + x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_9092","instance":9092,"id":179091,"goal":"lemma AddAssoc_9092(x: nat, a: nat, c: nat)\n ensures (x + a) + c == x + (a + c)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_9093","instance":9093,"id":179092,"goal":"lemma MulComm_9093(i: real, x: real)\n ensures i * x == x * i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_9094","instance":9094,"id":179093,"goal":"lemma MulAssoc_9094(z: int, i: int, b: int)\n ensures (z * i) * b == z * (i * b)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_9095","instance":9095,"id":179094,"goal":"lemma Distrib_9095(m: nat, z: nat, d: nat)\n ensures m * (z + d) == m * z + m * d\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_9096","instance":9096,"id":179095,"goal":"lemma AddZero_9096(c: real)\n ensures c + 0 == c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_9097","instance":9097,"id":179096,"goal":"lemma MulOne_9097(b: int)\n ensures b * 1 == b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_9098","instance":9098,"id":179097,"goal":"lemma MulZero_9098(y: nat)\n ensures y * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_9099","instance":9099,"id":179098,"goal":"lemma LeRefl_9099(d: real)\n ensures d <= d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_9100","instance":9100,"id":179099,"goal":"lemma LeTrans_9100(d: int, b: int, y: int)\n requires d <= b && b <= y\n ensures d <= y\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_9101","instance":9101,"id":179100,"goal":"lemma AddMono_9101(b: nat, i: nat, c: nat)\n requires b <= i\n ensures b + c <= i + c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_9102","instance":9102,"id":179101,"goal":"lemma Abs_Nonneg_9102(z: real)\n ensures (if z >= 0 then z else -z) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_9103","instance":9103,"id":179102,"goal":"lemma DivMod_9103(c: int, z: int)\n requires z > 0\n ensures c == z * (c / z) + (c % z)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_9104","instance":9104,"id":179103,"goal":"lemma ModBounds_9104(m: nat, d: nat)\n requires d > 0\n ensures 0 <= m % d < d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_9105","instance":9105,"id":179104,"goal":"lemma Square_Nonneg_9105(y: real)\n ensures y * y >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_9106","instance":9106,"id":179105,"goal":"lemma AddComm_9106(j: int, y: int)\n ensures j + y == y + j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_9107","instance":9107,"id":179106,"goal":"lemma AddAssoc_9107(k: nat, d: nat, n: nat)\n ensures (k + d) + n == k + (d + n)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_9108","instance":9108,"id":179107,"goal":"lemma MulComm_9108(j: real, b: real)\n ensures j * b == b * j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_9109","instance":9109,"id":179108,"goal":"lemma MulAssoc_9109(b: int, n: int, j: int)\n ensures (b * n) * j == b * (n * j)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_9110","instance":9110,"id":179109,"goal":"lemma Distrib_9110(z: nat, n: nat, c: nat)\n ensures z * (n + c) == z * n + z * c\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_9111","instance":9111,"id":179110,"goal":"lemma AddZero_9111(i: real)\n ensures i + 0 == i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_9112","instance":9112,"id":179111,"goal":"lemma MulOne_9112(i: int)\n ensures i * 1 == i\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_9113","instance":9113,"id":179112,"goal":"lemma MulZero_9113(k: nat)\n ensures k * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_9114","instance":9114,"id":179113,"goal":"lemma LeRefl_9114(i: real)\n ensures i <= i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_9115","instance":9115,"id":179114,"goal":"lemma LeTrans_9115(x: int, a: int, b: int)\n requires x <= a && a <= b\n ensures x <= b\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_9116","instance":9116,"id":179115,"goal":"lemma AddMono_9116(n: nat, x: nat, a: nat)\n requires n <= x\n ensures n + a <= x + a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_9117","instance":9117,"id":179116,"goal":"lemma Abs_Nonneg_9117(k: real)\n ensures (if k >= 0 then k else -k) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_9118","instance":9118,"id":179117,"goal":"lemma DivMod_9118(k: int, b: int)\n requires b > 0\n ensures k == b * (k / b) + (k % b)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_9119","instance":9119,"id":179118,"goal":"lemma ModBounds_9119(m: nat, b: nat)\n requires b > 0\n ensures 0 <= m % b < b\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_9120","instance":9120,"id":179119,"goal":"lemma Square_Nonneg_9120(k: real)\n ensures k * k >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_9121","instance":9121,"id":179120,"goal":"lemma AddComm_9121(j: int, x: int)\n ensures j + x == x + j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_9122","instance":9122,"id":179121,"goal":"lemma AddAssoc_9122(b: nat, x: nat, m: nat)\n ensures (b + x) + m == b + (x + m)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_9123","instance":9123,"id":179122,"goal":"lemma MulComm_9123(j: real, z: real)\n ensures j * z == z * j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_9124","instance":9124,"id":179123,"goal":"lemma MulAssoc_9124(d: int, c: int, j: int)\n ensures (d * c) * j == d * (c * j)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_9125","instance":9125,"id":179124,"goal":"lemma Distrib_9125(x: nat, z: nat, a: nat)\n ensures x * (z + a) == x * z + x * a\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_9126","instance":9126,"id":179125,"goal":"lemma AddZero_9126(y: real)\n ensures y + 0 == y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_9127","instance":9127,"id":179126,"goal":"lemma MulOne_9127(z: int)\n ensures z * 1 == z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_9128","instance":9128,"id":179127,"goal":"lemma MulZero_9128(m: nat)\n ensures m * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_9129","instance":9129,"id":179128,"goal":"lemma LeRefl_9129(a: real)\n ensures a <= a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_9130","instance":9130,"id":179129,"goal":"lemma LeTrans_9130(m: int, n: int, a: int)\n requires m <= n && n <= a\n ensures m <= a\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_9131","instance":9131,"id":179130,"goal":"lemma AddMono_9131(n: nat, z: nat, j: nat)\n requires n <= z\n ensures n + j <= z + j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_9132","instance":9132,"id":179131,"goal":"lemma Abs_Nonneg_9132(k: real)\n ensures (if k >= 0 then k else -k) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_9133","instance":9133,"id":179132,"goal":"lemma DivMod_9133(x: int, d: int)\n requires d > 0\n ensures x == d * (x / d) + (x % d)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_9134","instance":9134,"id":179133,"goal":"lemma ModBounds_9134(n: nat, j: nat)\n requires j > 0\n ensures 0 <= n % j < j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_9135","instance":9135,"id":179134,"goal":"lemma Square_Nonneg_9135(n: real)\n ensures n * n >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_9136","instance":9136,"id":179135,"goal":"lemma AddComm_9136(n: int, y: int)\n ensures n + y == y + n\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_9137","instance":9137,"id":179136,"goal":"lemma AddAssoc_9137(c: nat, y: nat, m: nat)\n ensures (c + y) + m == c + (y + m)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_9138","instance":9138,"id":179137,"goal":"lemma MulComm_9138(c: real, y: real)\n ensures c * y == y * c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_9139","instance":9139,"id":179138,"goal":"lemma MulAssoc_9139(m: int, c: int, x: int)\n ensures (m * c) * x == m * (c * x)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_9140","instance":9140,"id":179139,"goal":"lemma Distrib_9140(c: nat, a: nat, x: nat)\n ensures c * (a + x) == c * a + c * x\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_9141","instance":9141,"id":179140,"goal":"lemma AddZero_9141(x: real)\n ensures x + 0 == x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_9142","instance":9142,"id":179141,"goal":"lemma MulOne_9142(a: int)\n ensures a * 1 == a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_9143","instance":9143,"id":179142,"goal":"lemma MulZero_9143(a: nat)\n ensures a * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_9144","instance":9144,"id":179143,"goal":"lemma LeRefl_9144(z: real)\n ensures z <= z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_9145","instance":9145,"id":179144,"goal":"lemma LeTrans_9145(y: int, b: int, j: int)\n requires y <= b && b <= j\n ensures y <= j\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_9146","instance":9146,"id":179145,"goal":"lemma AddMono_9146(a: nat, k: nat, x: nat)\n requires a <= k\n ensures a + x <= k + x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_9147","instance":9147,"id":179146,"goal":"lemma Abs_Nonneg_9147(j: real)\n ensures (if j >= 0 then j else -j) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_9148","instance":9148,"id":179147,"goal":"lemma DivMod_9148(m: int, c: int)\n requires c > 0\n ensures m == c * (m / c) + (m % c)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_9149","instance":9149,"id":179148,"goal":"lemma ModBounds_9149(j: nat, b: nat)\n requires b > 0\n ensures 0 <= j % b < b\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_9150","instance":9150,"id":179149,"goal":"lemma Square_Nonneg_9150(y: real)\n ensures y * y >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_9151","instance":9151,"id":179150,"goal":"lemma AddComm_9151(z: int, d: int)\n ensures z + d == d + z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_9152","instance":9152,"id":179151,"goal":"lemma AddAssoc_9152(m: nat, a: nat, k: nat)\n ensures (m + a) + k == m + (a + k)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_9153","instance":9153,"id":179152,"goal":"lemma MulComm_9153(j: real, k: real)\n ensures j * k == k * j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_9154","instance":9154,"id":179153,"goal":"lemma MulAssoc_9154(j: int, c: int, a: int)\n ensures (j * c) * a == j * (c * a)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_9155","instance":9155,"id":179154,"goal":"lemma Distrib_9155(y: nat, x: nat, a: nat)\n ensures y * (x + a) == y * x + y * a\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_9156","instance":9156,"id":179155,"goal":"lemma AddZero_9156(a: real)\n ensures a + 0 == a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_9157","instance":9157,"id":179156,"goal":"lemma MulOne_9157(x: int)\n ensures x * 1 == x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_9158","instance":9158,"id":179157,"goal":"lemma MulZero_9158(x: nat)\n ensures x * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_9159","instance":9159,"id":179158,"goal":"lemma LeRefl_9159(d: real)\n ensures d <= d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_9160","instance":9160,"id":179159,"goal":"lemma LeTrans_9160(m: int, k: int, c: int)\n requires m <= k && k <= c\n ensures m <= c\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_9161","instance":9161,"id":179160,"goal":"lemma AddMono_9161(b: nat, m: nat, n: nat)\n requires b <= m\n ensures b + n <= m + n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_9162","instance":9162,"id":179161,"goal":"lemma Abs_Nonneg_9162(c: real)\n ensures (if c >= 0 then c else -c) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_9163","instance":9163,"id":179162,"goal":"lemma DivMod_9163(i: int, j: int)\n requires j > 0\n ensures i == j * (i / j) + (i % j)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_9164","instance":9164,"id":179163,"goal":"lemma ModBounds_9164(m: nat, z: nat)\n requires z > 0\n ensures 0 <= m % z < z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_9165","instance":9165,"id":179164,"goal":"lemma Square_Nonneg_9165(y: real)\n ensures y * y >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_9166","instance":9166,"id":179165,"goal":"lemma AddComm_9166(b: int, j: int)\n ensures b + j == j + b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_9167","instance":9167,"id":179166,"goal":"lemma AddAssoc_9167(b: nat, d: nat, k: nat)\n ensures (b + d) + k == b + (d + k)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_9168","instance":9168,"id":179167,"goal":"lemma MulComm_9168(x: real, b: real)\n ensures x * b == b * x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_9169","instance":9169,"id":179168,"goal":"lemma MulAssoc_9169(m: int, z: int, n: int)\n ensures (m * z) * n == m * (z * n)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_9170","instance":9170,"id":179169,"goal":"lemma Distrib_9170(n: nat, m: nat, a: nat)\n ensures n * (m + a) == n * m + n * a\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_9171","instance":9171,"id":179170,"goal":"lemma AddZero_9171(m: real)\n ensures m + 0 == m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_9172","instance":9172,"id":179171,"goal":"lemma MulOne_9172(d: int)\n ensures d * 1 == d\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_9173","instance":9173,"id":179172,"goal":"lemma MulZero_9173(i: nat)\n ensures i * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_9174","instance":9174,"id":179173,"goal":"lemma LeRefl_9174(d: real)\n ensures d <= d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_9175","instance":9175,"id":179174,"goal":"lemma LeTrans_9175(m: int, b: int, c: int)\n requires m <= b && b <= c\n ensures m <= c\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_9176","instance":9176,"id":179175,"goal":"lemma AddMono_9176(c: nat, y: nat, x: nat)\n requires c <= y\n ensures c + x <= y + x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_9177","instance":9177,"id":179176,"goal":"lemma Abs_Nonneg_9177(n: real)\n ensures (if n >= 0 then n else -n) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_9178","instance":9178,"id":179177,"goal":"lemma DivMod_9178(z: int, a: int)\n requires a > 0\n ensures z == a * (z / a) + (z % a)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_9179","instance":9179,"id":179178,"goal":"lemma ModBounds_9179(i: nat, m: nat)\n requires m > 0\n ensures 0 <= i % m < m\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_9180","instance":9180,"id":179179,"goal":"lemma Square_Nonneg_9180(z: real)\n ensures z * z >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_9181","instance":9181,"id":179180,"goal":"lemma AddComm_9181(d: int, k: int)\n ensures d + k == k + d\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_9182","instance":9182,"id":179181,"goal":"lemma AddAssoc_9182(i: nat, z: nat, x: nat)\n ensures (i + z) + x == i + (z + x)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_9183","instance":9183,"id":179182,"goal":"lemma MulComm_9183(m: real, a: real)\n ensures m * a == a * m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_9184","instance":9184,"id":179183,"goal":"lemma MulAssoc_9184(j: int, y: int, d: int)\n ensures (j * y) * d == j * (y * d)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_9185","instance":9185,"id":179184,"goal":"lemma Distrib_9185(j: nat, k: nat, d: nat)\n ensures j * (k + d) == j * k + j * d\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_9186","instance":9186,"id":179185,"goal":"lemma AddZero_9186(z: real)\n ensures z + 0 == z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_9187","instance":9187,"id":179186,"goal":"lemma MulOne_9187(a: int)\n ensures a * 1 == a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_9188","instance":9188,"id":179187,"goal":"lemma MulZero_9188(c: nat)\n ensures c * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_9189","instance":9189,"id":179188,"goal":"lemma LeRefl_9189(m: real)\n ensures m <= m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_9190","instance":9190,"id":179189,"goal":"lemma LeTrans_9190(i: int, c: int, b: int)\n requires i <= c && c <= b\n ensures i <= b\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_9191","instance":9191,"id":179190,"goal":"lemma AddMono_9191(b: nat, j: nat, n: nat)\n requires b <= j\n ensures b + n <= j + n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_9192","instance":9192,"id":179191,"goal":"lemma Abs_Nonneg_9192(x: real)\n ensures (if x >= 0 then x else -x) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_9193","instance":9193,"id":179192,"goal":"lemma DivMod_9193(a: int, b: int)\n requires b > 0\n ensures a == b * (a / b) + (a % b)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_9194","instance":9194,"id":179193,"goal":"lemma ModBounds_9194(i: nat, d: nat)\n requires d > 0\n ensures 0 <= i % d < d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_9195","instance":9195,"id":179194,"goal":"lemma Square_Nonneg_9195(y: real)\n ensures y * y >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_9196","instance":9196,"id":179195,"goal":"lemma AddComm_9196(n: int, x: int)\n ensures n + x == x + n\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_9197","instance":9197,"id":179196,"goal":"lemma AddAssoc_9197(n: nat, c: nat, k: nat)\n ensures (n + c) + k == n + (c + k)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_9198","instance":9198,"id":179197,"goal":"lemma MulComm_9198(z: real, c: real)\n ensures z * c == c * z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_9199","instance":9199,"id":179198,"goal":"lemma MulAssoc_9199(n: int, z: int, y: int)\n ensures (n * z) * y == n * (z * y)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_9200","instance":9200,"id":179199,"goal":"lemma Distrib_9200(b: nat, y: nat, n: nat)\n ensures b * (y + n) == b * y + b * n\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_9201","instance":9201,"id":179200,"goal":"lemma AddZero_9201(m: real)\n ensures m + 0 == m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_9202","instance":9202,"id":179201,"goal":"lemma MulOne_9202(k: int)\n ensures k * 1 == k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_9203","instance":9203,"id":179202,"goal":"lemma MulZero_9203(k: nat)\n ensures k * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_9204","instance":9204,"id":179203,"goal":"lemma LeRefl_9204(j: real)\n ensures j <= j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_9205","instance":9205,"id":179204,"goal":"lemma LeTrans_9205(y: int, a: int, n: int)\n requires y <= a && a <= n\n ensures y <= n\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_9206","instance":9206,"id":179205,"goal":"lemma AddMono_9206(x: nat, c: nat, d: nat)\n requires x <= c\n ensures x + d <= c + d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_9207","instance":9207,"id":179206,"goal":"lemma Abs_Nonneg_9207(y: real)\n ensures (if y >= 0 then y else -y) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_9208","instance":9208,"id":179207,"goal":"lemma DivMod_9208(k: int, y: int)\n requires y > 0\n ensures k == y * (k / y) + (k % y)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_9209","instance":9209,"id":179208,"goal":"lemma ModBounds_9209(j: nat, c: nat)\n requires c > 0\n ensures 0 <= j % c < c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_9210","instance":9210,"id":179209,"goal":"lemma Square_Nonneg_9210(z: real)\n ensures z * z >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_9211","instance":9211,"id":179210,"goal":"lemma AddComm_9211(k: int, x: int)\n ensures k + x == x + k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_9212","instance":9212,"id":179211,"goal":"lemma AddAssoc_9212(y: nat, n: nat, b: nat)\n ensures (y + n) + b == y + (n + b)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_9213","instance":9213,"id":179212,"goal":"lemma MulComm_9213(b: real, i: real)\n ensures b * i == i * b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_9214","instance":9214,"id":179213,"goal":"lemma MulAssoc_9214(d: int, i: int, c: int)\n ensures (d * i) * c == d * (i * c)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_9215","instance":9215,"id":179214,"goal":"lemma Distrib_9215(b: nat, n: nat, x: nat)\n ensures b * (n + x) == b * n + b * x\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_9216","instance":9216,"id":179215,"goal":"lemma AddZero_9216(b: real)\n ensures b + 0 == b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_9217","instance":9217,"id":179216,"goal":"lemma MulOne_9217(k: int)\n ensures k * 1 == k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_9218","instance":9218,"id":179217,"goal":"lemma MulZero_9218(d: nat)\n ensures d * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_9219","instance":9219,"id":179218,"goal":"lemma LeRefl_9219(k: real)\n ensures k <= k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_9220","instance":9220,"id":179219,"goal":"lemma LeTrans_9220(m: int, z: int, d: int)\n requires m <= z && z <= d\n ensures m <= d\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_9221","instance":9221,"id":179220,"goal":"lemma AddMono_9221(i: nat, m: nat, c: nat)\n requires i <= m\n ensures i + c <= m + c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_9222","instance":9222,"id":179221,"goal":"lemma Abs_Nonneg_9222(i: real)\n ensures (if i >= 0 then i else -i) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_9223","instance":9223,"id":179222,"goal":"lemma DivMod_9223(j: int, d: int)\n requires d > 0\n ensures j == d * (j / d) + (j % d)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_9224","instance":9224,"id":179223,"goal":"lemma ModBounds_9224(j: nat, a: nat)\n requires a > 0\n ensures 0 <= j % a < a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_9225","instance":9225,"id":179224,"goal":"lemma Square_Nonneg_9225(d: real)\n ensures d * d >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_9226","instance":9226,"id":179225,"goal":"lemma AddComm_9226(b: int, x: int)\n ensures b + x == x + b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_9227","instance":9227,"id":179226,"goal":"lemma AddAssoc_9227(i: nat, b: nat, c: nat)\n ensures (i + b) + c == i + (b + c)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_9228","instance":9228,"id":179227,"goal":"lemma MulComm_9228(y: real, d: real)\n ensures y * d == d * y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_9229","instance":9229,"id":179228,"goal":"lemma MulAssoc_9229(n: int, a: int, c: int)\n ensures (n * a) * c == n * (a * c)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_9230","instance":9230,"id":179229,"goal":"lemma Distrib_9230(c: nat, x: nat, z: nat)\n ensures c * (x + z) == c * x + c * z\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_9231","instance":9231,"id":179230,"goal":"lemma AddZero_9231(b: real)\n ensures b + 0 == b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_9232","instance":9232,"id":179231,"goal":"lemma MulOne_9232(y: int)\n ensures y * 1 == y\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_9233","instance":9233,"id":179232,"goal":"lemma MulZero_9233(z: nat)\n ensures z * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_9234","instance":9234,"id":179233,"goal":"lemma LeRefl_9234(y: real)\n ensures y <= y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_9235","instance":9235,"id":179234,"goal":"lemma LeTrans_9235(c: int, n: int, d: int)\n requires c <= n && n <= d\n ensures c <= d\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_9236","instance":9236,"id":179235,"goal":"lemma AddMono_9236(b: nat, a: nat, m: nat)\n requires b <= a\n ensures b + m <= a + m\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_9237","instance":9237,"id":179236,"goal":"lemma Abs_Nonneg_9237(x: real)\n ensures (if x >= 0 then x else -x) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_9238","instance":9238,"id":179237,"goal":"lemma DivMod_9238(a: int, x: int)\n requires x > 0\n ensures a == x * (a / x) + (a % x)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_9239","instance":9239,"id":179238,"goal":"lemma ModBounds_9239(x: nat, j: nat)\n requires j > 0\n ensures 0 <= x % j < j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_9240","instance":9240,"id":179239,"goal":"lemma Square_Nonneg_9240(y: real)\n ensures y * y >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_9241","instance":9241,"id":179240,"goal":"lemma AddComm_9241(k: int, j: int)\n ensures k + j == j + k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_9242","instance":9242,"id":179241,"goal":"lemma AddAssoc_9242(a: nat, c: nat, m: nat)\n ensures (a + c) + m == a + (c + m)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_9243","instance":9243,"id":179242,"goal":"lemma MulComm_9243(d: real, a: real)\n ensures d * a == a * d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_9244","instance":9244,"id":179243,"goal":"lemma MulAssoc_9244(m: int, n: int, j: int)\n ensures (m * n) * j == m * (n * j)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_9245","instance":9245,"id":179244,"goal":"lemma Distrib_9245(z: nat, n: nat, i: nat)\n ensures z * (n + i) == z * n + z * i\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_9246","instance":9246,"id":179245,"goal":"lemma AddZero_9246(n: real)\n ensures n + 0 == n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_9247","instance":9247,"id":179246,"goal":"lemma MulOne_9247(d: int)\n ensures d * 1 == d\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_9248","instance":9248,"id":179247,"goal":"lemma MulZero_9248(x: nat)\n ensures x * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_9249","instance":9249,"id":179248,"goal":"lemma LeRefl_9249(c: real)\n ensures c <= c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_9250","instance":9250,"id":179249,"goal":"lemma LeTrans_9250(k: int, j: int, z: int)\n requires k <= j && j <= z\n ensures k <= z\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_9251","instance":9251,"id":179250,"goal":"lemma AddMono_9251(a: nat, c: nat, j: nat)\n requires a <= c\n ensures a + j <= c + j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_9252","instance":9252,"id":179251,"goal":"lemma Abs_Nonneg_9252(k: real)\n ensures (if k >= 0 then k else -k) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_9253","instance":9253,"id":179252,"goal":"lemma DivMod_9253(x: int, a: int)\n requires a > 0\n ensures x == a * (x / a) + (x % a)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_9254","instance":9254,"id":179253,"goal":"lemma ModBounds_9254(n: nat, x: nat)\n requires x > 0\n ensures 0 <= n % x < x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_9255","instance":9255,"id":179254,"goal":"lemma Square_Nonneg_9255(k: real)\n ensures k * k >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_9256","instance":9256,"id":179255,"goal":"lemma AddComm_9256(d: int, m: int)\n ensures d + m == m + d\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_9257","instance":9257,"id":179256,"goal":"lemma AddAssoc_9257(z: nat, x: nat, c: nat)\n ensures (z + x) + c == z + (x + c)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_9258","instance":9258,"id":179257,"goal":"lemma MulComm_9258(b: real, d: real)\n ensures b * d == d * b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_9259","instance":9259,"id":179258,"goal":"lemma MulAssoc_9259(a: int, m: int, b: int)\n ensures (a * m) * b == a * (m * b)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_9260","instance":9260,"id":179259,"goal":"lemma Distrib_9260(c: nat, x: nat, y: nat)\n ensures c * (x + y) == c * x + c * y\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_9261","instance":9261,"id":179260,"goal":"lemma AddZero_9261(i: real)\n ensures i + 0 == i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_9262","instance":9262,"id":179261,"goal":"lemma MulOne_9262(j: int)\n ensures j * 1 == j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_9263","instance":9263,"id":179262,"goal":"lemma MulZero_9263(y: nat)\n ensures y * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_9264","instance":9264,"id":179263,"goal":"lemma LeRefl_9264(c: real)\n ensures c <= c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_9265","instance":9265,"id":179264,"goal":"lemma LeTrans_9265(z: int, m: int, y: int)\n requires z <= m && m <= y\n ensures z <= y\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_9266","instance":9266,"id":179265,"goal":"lemma AddMono_9266(a: nat, y: nat, j: nat)\n requires a <= y\n ensures a + j <= y + j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_9267","instance":9267,"id":179266,"goal":"lemma Abs_Nonneg_9267(z: real)\n ensures (if z >= 0 then z else -z) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_9268","instance":9268,"id":179267,"goal":"lemma DivMod_9268(d: int, j: int)\n requires j > 0\n ensures d == j * (d / j) + (d % j)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_9269","instance":9269,"id":179268,"goal":"lemma ModBounds_9269(y: nat, j: nat)\n requires j > 0\n ensures 0 <= y % j < j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_9270","instance":9270,"id":179269,"goal":"lemma Square_Nonneg_9270(k: real)\n ensures k * k >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_9271","instance":9271,"id":179270,"goal":"lemma AddComm_9271(n: int, d: int)\n ensures n + d == d + n\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_9272","instance":9272,"id":179271,"goal":"lemma AddAssoc_9272(z: nat, x: nat, i: nat)\n ensures (z + x) + i == z + (x + i)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_9273","instance":9273,"id":179272,"goal":"lemma MulComm_9273(c: real, i: real)\n ensures c * i == i * c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_9274","instance":9274,"id":179273,"goal":"lemma MulAssoc_9274(z: int, m: int, y: int)\n ensures (z * m) * y == z * (m * y)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_9275","instance":9275,"id":179274,"goal":"lemma Distrib_9275(i: nat, c: nat, j: nat)\n ensures i * (c + j) == i * c + i * j\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_9276","instance":9276,"id":179275,"goal":"lemma AddZero_9276(i: real)\n ensures i + 0 == i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_9277","instance":9277,"id":179276,"goal":"lemma MulOne_9277(y: int)\n ensures y * 1 == y\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_9278","instance":9278,"id":179277,"goal":"lemma MulZero_9278(a: nat)\n ensures a * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_9279","instance":9279,"id":179278,"goal":"lemma LeRefl_9279(y: real)\n ensures y <= y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_9280","instance":9280,"id":179279,"goal":"lemma LeTrans_9280(m: int, k: int, c: int)\n requires m <= k && k <= c\n ensures m <= c\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_9281","instance":9281,"id":179280,"goal":"lemma AddMono_9281(m: nat, z: nat, i: nat)\n requires m <= z\n ensures m + i <= z + i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_9282","instance":9282,"id":179281,"goal":"lemma Abs_Nonneg_9282(j: real)\n ensures (if j >= 0 then j else -j) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_9283","instance":9283,"id":179282,"goal":"lemma DivMod_9283(n: int, z: int)\n requires z > 0\n ensures n == z * (n / z) + (n % z)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_9284","instance":9284,"id":179283,"goal":"lemma ModBounds_9284(z: nat, m: nat)\n requires m > 0\n ensures 0 <= z % m < m\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_9285","instance":9285,"id":179284,"goal":"lemma Square_Nonneg_9285(b: real)\n ensures b * b >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_9286","instance":9286,"id":179285,"goal":"lemma AddComm_9286(b: int, n: int)\n ensures b + n == n + b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_9287","instance":9287,"id":179286,"goal":"lemma AddAssoc_9287(j: nat, x: nat, z: nat)\n ensures (j + x) + z == j + (x + z)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_9288","instance":9288,"id":179287,"goal":"lemma MulComm_9288(a: real, i: real)\n ensures a * i == i * a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_9289","instance":9289,"id":179288,"goal":"lemma MulAssoc_9289(z: int, b: int, m: int)\n ensures (z * b) * m == z * (b * m)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_9290","instance":9290,"id":179289,"goal":"lemma Distrib_9290(z: nat, y: nat, n: nat)\n ensures z * (y + n) == z * y + z * n\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_9291","instance":9291,"id":179290,"goal":"lemma AddZero_9291(z: real)\n ensures z + 0 == z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_9292","instance":9292,"id":179291,"goal":"lemma MulOne_9292(j: int)\n ensures j * 1 == j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_9293","instance":9293,"id":179292,"goal":"lemma MulZero_9293(m: nat)\n ensures m * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_9294","instance":9294,"id":179293,"goal":"lemma LeRefl_9294(d: real)\n ensures d <= d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_9295","instance":9295,"id":179294,"goal":"lemma LeTrans_9295(j: int, x: int, z: int)\n requires j <= x && x <= z\n ensures j <= z\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_9296","instance":9296,"id":179295,"goal":"lemma AddMono_9296(m: nat, c: nat, i: nat)\n requires m <= c\n ensures m + i <= c + i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_9297","instance":9297,"id":179296,"goal":"lemma Abs_Nonneg_9297(m: real)\n ensures (if m >= 0 then m else -m) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_9298","instance":9298,"id":179297,"goal":"lemma DivMod_9298(z: int, i: int)\n requires i > 0\n ensures z == i * (z / i) + (z % i)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_9299","instance":9299,"id":179298,"goal":"lemma ModBounds_9299(i: nat, k: nat)\n requires k > 0\n ensures 0 <= i % k < k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_9300","instance":9300,"id":179299,"goal":"lemma Square_Nonneg_9300(z: real)\n ensures z * z >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_9301","instance":9301,"id":179300,"goal":"lemma AddComm_9301(m: int, i: int)\n ensures m + i == i + m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_9302","instance":9302,"id":179301,"goal":"lemma AddAssoc_9302(d: nat, a: nat, n: nat)\n ensures (d + a) + n == d + (a + n)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_9303","instance":9303,"id":179302,"goal":"lemma MulComm_9303(d: real, x: real)\n ensures d * x == x * d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_9304","instance":9304,"id":179303,"goal":"lemma MulAssoc_9304(d: int, m: int, x: int)\n ensures (d * m) * x == d * (m * x)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_9305","instance":9305,"id":179304,"goal":"lemma Distrib_9305(j: nat, m: nat, c: nat)\n ensures j * (m + c) == j * m + j * c\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_9306","instance":9306,"id":179305,"goal":"lemma AddZero_9306(j: real)\n ensures j + 0 == j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_9307","instance":9307,"id":179306,"goal":"lemma MulOne_9307(y: int)\n ensures y * 1 == y\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_9308","instance":9308,"id":179307,"goal":"lemma MulZero_9308(x: nat)\n ensures x * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_9309","instance":9309,"id":179308,"goal":"lemma LeRefl_9309(j: real)\n ensures j <= j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_9310","instance":9310,"id":179309,"goal":"lemma LeTrans_9310(j: int, m: int, d: int)\n requires j <= m && m <= d\n ensures j <= d\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_9311","instance":9311,"id":179310,"goal":"lemma AddMono_9311(y: nat, a: nat, m: nat)\n requires y <= a\n ensures y + m <= a + m\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_9312","instance":9312,"id":179311,"goal":"lemma Abs_Nonneg_9312(d: real)\n ensures (if d >= 0 then d else -d) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_9313","instance":9313,"id":179312,"goal":"lemma DivMod_9313(i: int, c: int)\n requires c > 0\n ensures i == c * (i / c) + (i % c)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_9314","instance":9314,"id":179313,"goal":"lemma ModBounds_9314(b: nat, d: nat)\n requires d > 0\n ensures 0 <= b % d < d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_9315","instance":9315,"id":179314,"goal":"lemma Square_Nonneg_9315(z: real)\n ensures z * z >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_9316","instance":9316,"id":179315,"goal":"lemma AddComm_9316(c: int, m: int)\n ensures c + m == m + c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_9317","instance":9317,"id":179316,"goal":"lemma AddAssoc_9317(c: nat, x: nat, y: nat)\n ensures (c + x) + y == c + (x + y)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_9318","instance":9318,"id":179317,"goal":"lemma MulComm_9318(d: real, b: real)\n ensures d * b == b * d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_9319","instance":9319,"id":179318,"goal":"lemma MulAssoc_9319(c: int, y: int, a: int)\n ensures (c * y) * a == c * (y * a)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_9320","instance":9320,"id":179319,"goal":"lemma Distrib_9320(a: nat, z: nat, x: nat)\n ensures a * (z + x) == a * z + a * x\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_9321","instance":9321,"id":179320,"goal":"lemma AddZero_9321(j: real)\n ensures j + 0 == j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_9322","instance":9322,"id":179321,"goal":"lemma MulOne_9322(m: int)\n ensures m * 1 == m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_9323","instance":9323,"id":179322,"goal":"lemma MulZero_9323(k: nat)\n ensures k * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_9324","instance":9324,"id":179323,"goal":"lemma LeRefl_9324(z: real)\n ensures z <= z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_9325","instance":9325,"id":179324,"goal":"lemma LeTrans_9325(y: int, b: int, n: int)\n requires y <= b && b <= n\n ensures y <= n\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_9326","instance":9326,"id":179325,"goal":"lemma AddMono_9326(b: nat, z: nat, c: nat)\n requires b <= z\n ensures b + c <= z + c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_9327","instance":9327,"id":179326,"goal":"lemma Abs_Nonneg_9327(c: real)\n ensures (if c >= 0 then c else -c) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_9328","instance":9328,"id":179327,"goal":"lemma DivMod_9328(a: int, i: int)\n requires i > 0\n ensures a == i * (a / i) + (a % i)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_9329","instance":9329,"id":179328,"goal":"lemma ModBounds_9329(a: nat, x: nat)\n requires x > 0\n ensures 0 <= a % x < x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_9330","instance":9330,"id":179329,"goal":"lemma Square_Nonneg_9330(c: real)\n ensures c * c >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_9331","instance":9331,"id":179330,"goal":"lemma AddComm_9331(y: int, x: int)\n ensures y + x == x + y\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_9332","instance":9332,"id":179331,"goal":"lemma AddAssoc_9332(k: nat, j: nat, c: nat)\n ensures (k + j) + c == k + (j + c)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_9333","instance":9333,"id":179332,"goal":"lemma MulComm_9333(c: real, n: real)\n ensures c * n == n * c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_9334","instance":9334,"id":179333,"goal":"lemma MulAssoc_9334(y: int, b: int, d: int)\n ensures (y * b) * d == y * (b * d)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_9335","instance":9335,"id":179334,"goal":"lemma Distrib_9335(a: nat, i: nat, k: nat)\n ensures a * (i + k) == a * i + a * k\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_9336","instance":9336,"id":179335,"goal":"lemma AddZero_9336(m: real)\n ensures m + 0 == m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_9337","instance":9337,"id":179336,"goal":"lemma MulOne_9337(x: int)\n ensures x * 1 == x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_9338","instance":9338,"id":179337,"goal":"lemma MulZero_9338(n: nat)\n ensures n * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_9339","instance":9339,"id":179338,"goal":"lemma LeRefl_9339(a: real)\n ensures a <= a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_9340","instance":9340,"id":179339,"goal":"lemma LeTrans_9340(k: int, j: int, n: int)\n requires k <= j && j <= n\n ensures k <= n\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_9341","instance":9341,"id":179340,"goal":"lemma AddMono_9341(z: nat, k: nat, x: nat)\n requires z <= k\n ensures z + x <= k + x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_9342","instance":9342,"id":179341,"goal":"lemma Abs_Nonneg_9342(i: real)\n ensures (if i >= 0 then i else -i) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_9343","instance":9343,"id":179342,"goal":"lemma DivMod_9343(c: int, y: int)\n requires y > 0\n ensures c == y * (c / y) + (c % y)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_9344","instance":9344,"id":179343,"goal":"lemma ModBounds_9344(i: nat, j: nat)\n requires j > 0\n ensures 0 <= i % j < j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_9345","instance":9345,"id":179344,"goal":"lemma Square_Nonneg_9345(z: real)\n ensures z * z >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_9346","instance":9346,"id":179345,"goal":"lemma AddComm_9346(a: int, z: int)\n ensures a + z == z + a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_9347","instance":9347,"id":179346,"goal":"lemma AddAssoc_9347(b: nat, n: nat, d: nat)\n ensures (b + n) + d == b + (n + d)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_9348","instance":9348,"id":179347,"goal":"lemma MulComm_9348(x: real, d: real)\n ensures x * d == d * x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_9349","instance":9349,"id":179348,"goal":"lemma MulAssoc_9349(b: int, c: int, a: int)\n ensures (b * c) * a == b * (c * a)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_9350","instance":9350,"id":179349,"goal":"lemma Distrib_9350(a: nat, b: nat, y: nat)\n ensures a * (b + y) == a * b + a * y\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_9351","instance":9351,"id":179350,"goal":"lemma AddZero_9351(a: real)\n ensures a + 0 == a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_9352","instance":9352,"id":179351,"goal":"lemma MulOne_9352(z: int)\n ensures z * 1 == z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_9353","instance":9353,"id":179352,"goal":"lemma MulZero_9353(k: nat)\n ensures k * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_9354","instance":9354,"id":179353,"goal":"lemma LeRefl_9354(d: real)\n ensures d <= d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_9355","instance":9355,"id":179354,"goal":"lemma LeTrans_9355(y: int, j: int, b: int)\n requires y <= j && j <= b\n ensures y <= b\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_9356","instance":9356,"id":179355,"goal":"lemma AddMono_9356(b: nat, j: nat, a: nat)\n requires b <= j\n ensures b + a <= j + a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_9357","instance":9357,"id":179356,"goal":"lemma Abs_Nonneg_9357(b: real)\n ensures (if b >= 0 then b else -b) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_9358","instance":9358,"id":179357,"goal":"lemma DivMod_9358(c: int, i: int)\n requires i > 0\n ensures c == i * (c / i) + (c % i)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_9359","instance":9359,"id":179358,"goal":"lemma ModBounds_9359(j: nat, n: nat)\n requires n > 0\n ensures 0 <= j % n < n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_9360","instance":9360,"id":179359,"goal":"lemma Square_Nonneg_9360(n: real)\n ensures n * n >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_9361","instance":9361,"id":179360,"goal":"lemma AddComm_9361(n: int, j: int)\n ensures n + j == j + n\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_9362","instance":9362,"id":179361,"goal":"lemma AddAssoc_9362(d: nat, i: nat, m: nat)\n ensures (d + i) + m == d + (i + m)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_9363","instance":9363,"id":179362,"goal":"lemma MulComm_9363(y: real, c: real)\n ensures y * c == c * y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_9364","instance":9364,"id":179363,"goal":"lemma MulAssoc_9364(k: int, z: int, b: int)\n ensures (k * z) * b == k * (z * b)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_9365","instance":9365,"id":179364,"goal":"lemma Distrib_9365(c: nat, b: nat, y: nat)\n ensures c * (b + y) == c * b + c * y\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_9366","instance":9366,"id":179365,"goal":"lemma AddZero_9366(d: real)\n ensures d + 0 == d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_9367","instance":9367,"id":179366,"goal":"lemma MulOne_9367(c: int)\n ensures c * 1 == c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_9368","instance":9368,"id":179367,"goal":"lemma MulZero_9368(z: nat)\n ensures z * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_9369","instance":9369,"id":179368,"goal":"lemma LeRefl_9369(k: real)\n ensures k <= k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_9370","instance":9370,"id":179369,"goal":"lemma LeTrans_9370(n: int, j: int, k: int)\n requires n <= j && j <= k\n ensures n <= k\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_9371","instance":9371,"id":179370,"goal":"lemma AddMono_9371(y: nat, b: nat, m: nat)\n requires y <= b\n ensures y + m <= b + m\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_9372","instance":9372,"id":179371,"goal":"lemma Abs_Nonneg_9372(k: real)\n ensures (if k >= 0 then k else -k) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_9373","instance":9373,"id":179372,"goal":"lemma DivMod_9373(x: int, i: int)\n requires i > 0\n ensures x == i * (x / i) + (x % i)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_9374","instance":9374,"id":179373,"goal":"lemma ModBounds_9374(y: nat, a: nat)\n requires a > 0\n ensures 0 <= y % a < a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_9375","instance":9375,"id":179374,"goal":"lemma Square_Nonneg_9375(m: real)\n ensures m * m >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_9376","instance":9376,"id":179375,"goal":"lemma AddComm_9376(a: int, b: int)\n ensures a + b == b + a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_9377","instance":9377,"id":179376,"goal":"lemma AddAssoc_9377(z: nat, b: nat, m: nat)\n ensures (z + b) + m == z + (b + m)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_9378","instance":9378,"id":179377,"goal":"lemma MulComm_9378(y: real, x: real)\n ensures y * x == x * y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_9379","instance":9379,"id":179378,"goal":"lemma MulAssoc_9379(c: int, x: int, b: int)\n ensures (c * x) * b == c * (x * b)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_9380","instance":9380,"id":179379,"goal":"lemma Distrib_9380(x: nat, c: nat, n: nat)\n ensures x * (c + n) == x * c + x * n\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_9381","instance":9381,"id":179380,"goal":"lemma AddZero_9381(k: real)\n ensures k + 0 == k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_9382","instance":9382,"id":179381,"goal":"lemma MulOne_9382(b: int)\n ensures b * 1 == b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_9383","instance":9383,"id":179382,"goal":"lemma MulZero_9383(m: nat)\n ensures m * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_9384","instance":9384,"id":179383,"goal":"lemma LeRefl_9384(k: real)\n ensures k <= k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_9385","instance":9385,"id":179384,"goal":"lemma LeTrans_9385(m: int, x: int, b: int)\n requires m <= x && x <= b\n ensures m <= b\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_9386","instance":9386,"id":179385,"goal":"lemma AddMono_9386(b: nat, m: nat, i: nat)\n requires b <= m\n ensures b + i <= m + i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_9387","instance":9387,"id":179386,"goal":"lemma Abs_Nonneg_9387(i: real)\n ensures (if i >= 0 then i else -i) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_9388","instance":9388,"id":179387,"goal":"lemma DivMod_9388(y: int, m: int)\n requires m > 0\n ensures y == m * (y / m) + (y % m)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_9389","instance":9389,"id":179388,"goal":"lemma ModBounds_9389(m: nat, z: nat)\n requires z > 0\n ensures 0 <= m % z < z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_9390","instance":9390,"id":179389,"goal":"lemma Square_Nonneg_9390(i: real)\n ensures i * i >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_9391","instance":9391,"id":179390,"goal":"lemma AddComm_9391(b: int, a: int)\n ensures b + a == a + b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_9392","instance":9392,"id":179391,"goal":"lemma AddAssoc_9392(j: nat, x: nat, n: nat)\n ensures (j + x) + n == j + (x + n)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_9393","instance":9393,"id":179392,"goal":"lemma MulComm_9393(j: real, y: real)\n ensures j * y == y * j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_9394","instance":9394,"id":179393,"goal":"lemma MulAssoc_9394(c: int, m: int, y: int)\n ensures (c * m) * y == c * (m * y)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_9395","instance":9395,"id":179394,"goal":"lemma Distrib_9395(b: nat, k: nat, a: nat)\n ensures b * (k + a) == b * k + b * a\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_9396","instance":9396,"id":179395,"goal":"lemma AddZero_9396(z: real)\n ensures z + 0 == z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_9397","instance":9397,"id":179396,"goal":"lemma MulOne_9397(d: int)\n ensures d * 1 == d\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_9398","instance":9398,"id":179397,"goal":"lemma MulZero_9398(y: nat)\n ensures y * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_9399","instance":9399,"id":179398,"goal":"lemma LeRefl_9399(c: real)\n ensures c <= c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_9400","instance":9400,"id":179399,"goal":"lemma LeTrans_9400(c: int, y: int, d: int)\n requires c <= y && y <= d\n ensures c <= d\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_9401","instance":9401,"id":179400,"goal":"lemma AddMono_9401(i: nat, m: nat, z: nat)\n requires i <= m\n ensures i + z <= m + z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_9402","instance":9402,"id":179401,"goal":"lemma Abs_Nonneg_9402(c: real)\n ensures (if c >= 0 then c else -c) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_9403","instance":9403,"id":179402,"goal":"lemma DivMod_9403(j: int, d: int)\n requires d > 0\n ensures j == d * (j / d) + (j % d)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_9404","instance":9404,"id":179403,"goal":"lemma ModBounds_9404(m: nat, k: nat)\n requires k > 0\n ensures 0 <= m % k < k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_9405","instance":9405,"id":179404,"goal":"lemma Square_Nonneg_9405(z: real)\n ensures z * z >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_9406","instance":9406,"id":179405,"goal":"lemma AddComm_9406(x: int, a: int)\n ensures x + a == a + x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_9407","instance":9407,"id":179406,"goal":"lemma AddAssoc_9407(y: nat, j: nat, c: nat)\n ensures (y + j) + c == y + (j + c)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_9408","instance":9408,"id":179407,"goal":"lemma MulComm_9408(k: real, j: real)\n ensures k * j == j * k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_9409","instance":9409,"id":179408,"goal":"lemma MulAssoc_9409(c: int, j: int, n: int)\n ensures (c * j) * n == c * (j * n)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_9410","instance":9410,"id":179409,"goal":"lemma Distrib_9410(i: nat, n: nat, a: nat)\n ensures i * (n + a) == i * n + i * a\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_9411","instance":9411,"id":179410,"goal":"lemma AddZero_9411(d: real)\n ensures d + 0 == d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_9412","instance":9412,"id":179411,"goal":"lemma MulOne_9412(b: int)\n ensures b * 1 == b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_9413","instance":9413,"id":179412,"goal":"lemma MulZero_9413(c: nat)\n ensures c * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_9414","instance":9414,"id":179413,"goal":"lemma LeRefl_9414(k: real)\n ensures k <= k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_9415","instance":9415,"id":179414,"goal":"lemma LeTrans_9415(x: int, k: int, y: int)\n requires x <= k && k <= y\n ensures x <= y\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_9416","instance":9416,"id":179415,"goal":"lemma AddMono_9416(m: nat, i: nat, z: nat)\n requires m <= i\n ensures m + z <= i + z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_9417","instance":9417,"id":179416,"goal":"lemma Abs_Nonneg_9417(z: real)\n ensures (if z >= 0 then z else -z) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_9418","instance":9418,"id":179417,"goal":"lemma DivMod_9418(x: int, b: int)\n requires b > 0\n ensures x == b * (x / b) + (x % b)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_9419","instance":9419,"id":179418,"goal":"lemma ModBounds_9419(d: nat, j: nat)\n requires j > 0\n ensures 0 <= d % j < j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_9420","instance":9420,"id":179419,"goal":"lemma Square_Nonneg_9420(k: real)\n ensures k * k >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_9421","instance":9421,"id":179420,"goal":"lemma AddComm_9421(b: int, c: int)\n ensures b + c == c + b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_9422","instance":9422,"id":179421,"goal":"lemma AddAssoc_9422(c: nat, y: nat, n: nat)\n ensures (c + y) + n == c + (y + n)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_9423","instance":9423,"id":179422,"goal":"lemma MulComm_9423(i: real, a: real)\n ensures i * a == a * i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_9424","instance":9424,"id":179423,"goal":"lemma MulAssoc_9424(x: int, n: int, d: int)\n ensures (x * n) * d == x * (n * d)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_9425","instance":9425,"id":179424,"goal":"lemma Distrib_9425(b: nat, z: nat, n: nat)\n ensures b * (z + n) == b * z + b * n\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_9426","instance":9426,"id":179425,"goal":"lemma AddZero_9426(m: real)\n ensures m + 0 == m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_9427","instance":9427,"id":179426,"goal":"lemma MulOne_9427(j: int)\n ensures j * 1 == j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_9428","instance":9428,"id":179427,"goal":"lemma MulZero_9428(k: nat)\n ensures k * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_9429","instance":9429,"id":179428,"goal":"lemma LeRefl_9429(c: real)\n ensures c <= c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_9430","instance":9430,"id":179429,"goal":"lemma LeTrans_9430(m: int, i: int, k: int)\n requires m <= i && i <= k\n ensures m <= k\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_9431","instance":9431,"id":179430,"goal":"lemma AddMono_9431(j: nat, m: nat, n: nat)\n requires j <= m\n ensures j + n <= m + n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_9432","instance":9432,"id":179431,"goal":"lemma Abs_Nonneg_9432(m: real)\n ensures (if m >= 0 then m else -m) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_9433","instance":9433,"id":179432,"goal":"lemma DivMod_9433(m: int, k: int)\n requires k > 0\n ensures m == k * (m / k) + (m % k)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_9434","instance":9434,"id":179433,"goal":"lemma ModBounds_9434(d: nat, j: nat)\n requires j > 0\n ensures 0 <= d % j < j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_9435","instance":9435,"id":179434,"goal":"lemma Square_Nonneg_9435(d: real)\n ensures d * d >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_9436","instance":9436,"id":179435,"goal":"lemma AddComm_9436(j: int, c: int)\n ensures j + c == c + j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_9437","instance":9437,"id":179436,"goal":"lemma AddAssoc_9437(i: nat, m: nat, y: nat)\n ensures (i + m) + y == i + (m + y)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_9438","instance":9438,"id":179437,"goal":"lemma MulComm_9438(c: real, z: real)\n ensures c * z == z * c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_9439","instance":9439,"id":179438,"goal":"lemma MulAssoc_9439(i: int, m: int, b: int)\n ensures (i * m) * b == i * (m * b)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_9440","instance":9440,"id":179439,"goal":"lemma Distrib_9440(i: nat, n: nat, m: nat)\n ensures i * (n + m) == i * n + i * m\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_9441","instance":9441,"id":179440,"goal":"lemma AddZero_9441(k: real)\n ensures k + 0 == k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_9442","instance":9442,"id":179441,"goal":"lemma MulOne_9442(d: int)\n ensures d * 1 == d\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_9443","instance":9443,"id":179442,"goal":"lemma MulZero_9443(j: nat)\n ensures j * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_9444","instance":9444,"id":179443,"goal":"lemma LeRefl_9444(k: real)\n ensures k <= k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_9445","instance":9445,"id":179444,"goal":"lemma LeTrans_9445(x: int, a: int, c: int)\n requires x <= a && a <= c\n ensures x <= c\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_9446","instance":9446,"id":179445,"goal":"lemma AddMono_9446(x: nat, b: nat, j: nat)\n requires x <= b\n ensures x + j <= b + j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_9447","instance":9447,"id":179446,"goal":"lemma Abs_Nonneg_9447(y: real)\n ensures (if y >= 0 then y else -y) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_9448","instance":9448,"id":179447,"goal":"lemma DivMod_9448(c: int, j: int)\n requires j > 0\n ensures c == j * (c / j) + (c % j)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_9449","instance":9449,"id":179448,"goal":"lemma ModBounds_9449(x: nat, d: nat)\n requires d > 0\n ensures 0 <= x % d < d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_9450","instance":9450,"id":179449,"goal":"lemma Square_Nonneg_9450(k: real)\n ensures k * k >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_9451","instance":9451,"id":179450,"goal":"lemma AddComm_9451(z: int, b: int)\n ensures z + b == b + z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_9452","instance":9452,"id":179451,"goal":"lemma AddAssoc_9452(z: nat, j: nat, c: nat)\n ensures (z + j) + c == z + (j + c)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_9453","instance":9453,"id":179452,"goal":"lemma MulComm_9453(i: real, z: real)\n ensures i * z == z * i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_9454","instance":9454,"id":179453,"goal":"lemma MulAssoc_9454(k: int, a: int, b: int)\n ensures (k * a) * b == k * (a * b)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_9455","instance":9455,"id":179454,"goal":"lemma Distrib_9455(b: nat, k: nat, x: nat)\n ensures b * (k + x) == b * k + b * x\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_9456","instance":9456,"id":179455,"goal":"lemma AddZero_9456(n: real)\n ensures n + 0 == n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_9457","instance":9457,"id":179456,"goal":"lemma MulOne_9457(a: int)\n ensures a * 1 == a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_9458","instance":9458,"id":179457,"goal":"lemma MulZero_9458(c: nat)\n ensures c * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_9459","instance":9459,"id":179458,"goal":"lemma LeRefl_9459(d: real)\n ensures d <= d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_9460","instance":9460,"id":179459,"goal":"lemma LeTrans_9460(a: int, j: int, k: int)\n requires a <= j && j <= k\n ensures a <= k\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_9461","instance":9461,"id":179460,"goal":"lemma AddMono_9461(c: nat, i: nat, z: nat)\n requires c <= i\n ensures c + z <= i + z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_9462","instance":9462,"id":179461,"goal":"lemma Abs_Nonneg_9462(b: real)\n ensures (if b >= 0 then b else -b) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_9463","instance":9463,"id":179462,"goal":"lemma DivMod_9463(b: int, x: int)\n requires x > 0\n ensures b == x * (b / x) + (b % x)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_9464","instance":9464,"id":179463,"goal":"lemma ModBounds_9464(c: nat, i: nat)\n requires i > 0\n ensures 0 <= c % i < i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_9465","instance":9465,"id":179464,"goal":"lemma Square_Nonneg_9465(i: real)\n ensures i * i >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_9466","instance":9466,"id":179465,"goal":"lemma AddComm_9466(i: int, m: int)\n ensures i + m == m + i\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_9467","instance":9467,"id":179466,"goal":"lemma AddAssoc_9467(a: nat, m: nat, z: nat)\n ensures (a + m) + z == a + (m + z)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_9468","instance":9468,"id":179467,"goal":"lemma MulComm_9468(a: real, y: real)\n ensures a * y == y * a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_9469","instance":9469,"id":179468,"goal":"lemma MulAssoc_9469(j: int, y: int, b: int)\n ensures (j * y) * b == j * (y * b)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_9470","instance":9470,"id":179469,"goal":"lemma Distrib_9470(n: nat, m: nat, z: nat)\n ensures n * (m + z) == n * m + n * z\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_9471","instance":9471,"id":179470,"goal":"lemma AddZero_9471(y: real)\n ensures y + 0 == y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_9472","instance":9472,"id":179471,"goal":"lemma MulOne_9472(x: int)\n ensures x * 1 == x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_9473","instance":9473,"id":179472,"goal":"lemma MulZero_9473(y: nat)\n ensures y * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_9474","instance":9474,"id":179473,"goal":"lemma LeRefl_9474(n: real)\n ensures n <= n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_9475","instance":9475,"id":179474,"goal":"lemma LeTrans_9475(j: int, c: int, z: int)\n requires j <= c && c <= z\n ensures j <= z\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_9476","instance":9476,"id":179475,"goal":"lemma AddMono_9476(n: nat, z: nat, i: nat)\n requires n <= z\n ensures n + i <= z + i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_9477","instance":9477,"id":179476,"goal":"lemma Abs_Nonneg_9477(y: real)\n ensures (if y >= 0 then y else -y) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_9478","instance":9478,"id":179477,"goal":"lemma DivMod_9478(c: int, y: int)\n requires y > 0\n ensures c == y * (c / y) + (c % y)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_9479","instance":9479,"id":179478,"goal":"lemma ModBounds_9479(y: nat, i: nat)\n requires i > 0\n ensures 0 <= y % i < i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_9480","instance":9480,"id":179479,"goal":"lemma Square_Nonneg_9480(j: real)\n ensures j * j >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_9481","instance":9481,"id":179480,"goal":"lemma AddComm_9481(y: int, z: int)\n ensures y + z == z + y\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_9482","instance":9482,"id":179481,"goal":"lemma AddAssoc_9482(j: nat, m: nat, c: nat)\n ensures (j + m) + c == j + (m + c)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_9483","instance":9483,"id":179482,"goal":"lemma MulComm_9483(z: real, d: real)\n ensures z * d == d * z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_9484","instance":9484,"id":179483,"goal":"lemma MulAssoc_9484(j: int, y: int, x: int)\n ensures (j * y) * x == j * (y * x)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_9485","instance":9485,"id":179484,"goal":"lemma Distrib_9485(a: nat, k: nat, x: nat)\n ensures a * (k + x) == a * k + a * x\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_9486","instance":9486,"id":179485,"goal":"lemma AddZero_9486(x: real)\n ensures x + 0 == x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_9487","instance":9487,"id":179486,"goal":"lemma MulOne_9487(x: int)\n ensures x * 1 == x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_9488","instance":9488,"id":179487,"goal":"lemma MulZero_9488(k: nat)\n ensures k * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_9489","instance":9489,"id":179488,"goal":"lemma LeRefl_9489(x: real)\n ensures x <= x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_9490","instance":9490,"id":179489,"goal":"lemma LeTrans_9490(j: int, d: int, b: int)\n requires j <= d && d <= b\n ensures j <= b\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_9491","instance":9491,"id":179490,"goal":"lemma AddMono_9491(b: nat, m: nat, j: nat)\n requires b <= m\n ensures b + j <= m + j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_9492","instance":9492,"id":179491,"goal":"lemma Abs_Nonneg_9492(b: real)\n ensures (if b >= 0 then b else -b) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_9493","instance":9493,"id":179492,"goal":"lemma DivMod_9493(k: int, i: int)\n requires i > 0\n ensures k == i * (k / i) + (k % i)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_9494","instance":9494,"id":179493,"goal":"lemma ModBounds_9494(y: nat, z: nat)\n requires z > 0\n ensures 0 <= y % z < z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_9495","instance":9495,"id":179494,"goal":"lemma Square_Nonneg_9495(i: real)\n ensures i * i >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_9496","instance":9496,"id":179495,"goal":"lemma AddComm_9496(z: int, b: int)\n ensures z + b == b + z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_9497","instance":9497,"id":179496,"goal":"lemma AddAssoc_9497(m: nat, c: nat, i: nat)\n ensures (m + c) + i == m + (c + i)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_9498","instance":9498,"id":179497,"goal":"lemma MulComm_9498(c: real, a: real)\n ensures c * a == a * c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_9499","instance":9499,"id":179498,"goal":"lemma MulAssoc_9499(x: int, b: int, d: int)\n ensures (x * b) * d == x * (b * d)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_9500","instance":9500,"id":179499,"goal":"lemma Distrib_9500(y: nat, x: nat, b: nat)\n ensures y * (x + b) == y * x + y * b\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_9501","instance":9501,"id":179500,"goal":"lemma AddZero_9501(j: real)\n ensures j + 0 == j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_9502","instance":9502,"id":179501,"goal":"lemma MulOne_9502(c: int)\n ensures c * 1 == c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_9503","instance":9503,"id":179502,"goal":"lemma MulZero_9503(d: nat)\n ensures d * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_9504","instance":9504,"id":179503,"goal":"lemma LeRefl_9504(m: real)\n ensures m <= m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_9505","instance":9505,"id":179504,"goal":"lemma LeTrans_9505(n: int, a: int, c: int)\n requires n <= a && a <= c\n ensures n <= c\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_9506","instance":9506,"id":179505,"goal":"lemma AddMono_9506(z: nat, d: nat, n: nat)\n requires z <= d\n ensures z + n <= d + n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_9507","instance":9507,"id":179506,"goal":"lemma Abs_Nonneg_9507(x: real)\n ensures (if x >= 0 then x else -x) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_9508","instance":9508,"id":179507,"goal":"lemma DivMod_9508(x: int, a: int)\n requires a > 0\n ensures x == a * (x / a) + (x % a)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_9509","instance":9509,"id":179508,"goal":"lemma ModBounds_9509(d: nat, n: nat)\n requires n > 0\n ensures 0 <= d % n < n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_9510","instance":9510,"id":179509,"goal":"lemma Square_Nonneg_9510(m: real)\n ensures m * m >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_9511","instance":9511,"id":179510,"goal":"lemma AddComm_9511(n: int, x: int)\n ensures n + x == x + n\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_9512","instance":9512,"id":179511,"goal":"lemma AddAssoc_9512(c: nat, z: nat, n: nat)\n ensures (c + z) + n == c + (z + n)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_9513","instance":9513,"id":179512,"goal":"lemma MulComm_9513(i: real, z: real)\n ensures i * z == z * i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_9514","instance":9514,"id":179513,"goal":"lemma MulAssoc_9514(d: int, n: int, b: int)\n ensures (d * n) * b == d * (n * b)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_9515","instance":9515,"id":179514,"goal":"lemma Distrib_9515(k: nat, i: nat, a: nat)\n ensures k * (i + a) == k * i + k * a\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_9516","instance":9516,"id":179515,"goal":"lemma AddZero_9516(z: real)\n ensures z + 0 == z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_9517","instance":9517,"id":179516,"goal":"lemma MulOne_9517(j: int)\n ensures j * 1 == j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_9518","instance":9518,"id":179517,"goal":"lemma MulZero_9518(k: nat)\n ensures k * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_9519","instance":9519,"id":179518,"goal":"lemma LeRefl_9519(b: real)\n ensures b <= b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_9520","instance":9520,"id":179519,"goal":"lemma LeTrans_9520(j: int, c: int, x: int)\n requires j <= c && c <= x\n ensures j <= x\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_9521","instance":9521,"id":179520,"goal":"lemma AddMono_9521(a: nat, d: nat, k: nat)\n requires a <= d\n ensures a + k <= d + k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_9522","instance":9522,"id":179521,"goal":"lemma Abs_Nonneg_9522(y: real)\n ensures (if y >= 0 then y else -y) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_9523","instance":9523,"id":179522,"goal":"lemma DivMod_9523(j: int, x: int)\n requires x > 0\n ensures j == x * (j / x) + (j % x)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_9524","instance":9524,"id":179523,"goal":"lemma ModBounds_9524(k: nat, z: nat)\n requires z > 0\n ensures 0 <= k % z < z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_9525","instance":9525,"id":179524,"goal":"lemma Square_Nonneg_9525(k: real)\n ensures k * k >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_9526","instance":9526,"id":179525,"goal":"lemma AddComm_9526(j: int, y: int)\n ensures j + y == y + j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_9527","instance":9527,"id":179526,"goal":"lemma AddAssoc_9527(b: nat, x: nat, d: nat)\n ensures (b + x) + d == b + (x + d)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_9528","instance":9528,"id":179527,"goal":"lemma MulComm_9528(j: real, z: real)\n ensures j * z == z * j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_9529","instance":9529,"id":179528,"goal":"lemma MulAssoc_9529(c: int, i: int, b: int)\n ensures (c * i) * b == c * (i * b)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_9530","instance":9530,"id":179529,"goal":"lemma Distrib_9530(i: nat, d: nat, c: nat)\n ensures i * (d + c) == i * d + i * c\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_9531","instance":9531,"id":179530,"goal":"lemma AddZero_9531(m: real)\n ensures m + 0 == m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_9532","instance":9532,"id":179531,"goal":"lemma MulOne_9532(c: int)\n ensures c * 1 == c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_9533","instance":9533,"id":179532,"goal":"lemma MulZero_9533(z: nat)\n ensures z * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_9534","instance":9534,"id":179533,"goal":"lemma LeRefl_9534(x: real)\n ensures x <= x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_9535","instance":9535,"id":179534,"goal":"lemma LeTrans_9535(d: int, k: int, z: int)\n requires d <= k && k <= z\n ensures d <= z\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_9536","instance":9536,"id":179535,"goal":"lemma AddMono_9536(n: nat, c: nat, z: nat)\n requires n <= c\n ensures n + z <= c + z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_9537","instance":9537,"id":179536,"goal":"lemma Abs_Nonneg_9537(n: real)\n ensures (if n >= 0 then n else -n) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_9538","instance":9538,"id":179537,"goal":"lemma DivMod_9538(x: int, i: int)\n requires i > 0\n ensures x == i * (x / i) + (x % i)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_9539","instance":9539,"id":179538,"goal":"lemma ModBounds_9539(d: nat, z: nat)\n requires z > 0\n ensures 0 <= d % z < z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_9540","instance":9540,"id":179539,"goal":"lemma Square_Nonneg_9540(j: real)\n ensures j * j >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_9541","instance":9541,"id":179540,"goal":"lemma AddComm_9541(z: int, x: int)\n ensures z + x == x + z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_9542","instance":9542,"id":179541,"goal":"lemma AddAssoc_9542(x: nat, k: nat, n: nat)\n ensures (x + k) + n == x + (k + n)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_9543","instance":9543,"id":179542,"goal":"lemma MulComm_9543(y: real, n: real)\n ensures y * n == n * y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_9544","instance":9544,"id":179543,"goal":"lemma MulAssoc_9544(c: int, y: int, n: int)\n ensures (c * y) * n == c * (y * n)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_9545","instance":9545,"id":179544,"goal":"lemma Distrib_9545(y: nat, b: nat, m: nat)\n ensures y * (b + m) == y * b + y * m\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_9546","instance":9546,"id":179545,"goal":"lemma AddZero_9546(m: real)\n ensures m + 0 == m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_9547","instance":9547,"id":179546,"goal":"lemma MulOne_9547(k: int)\n ensures k * 1 == k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_9548","instance":9548,"id":179547,"goal":"lemma MulZero_9548(m: nat)\n ensures m * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_9549","instance":9549,"id":179548,"goal":"lemma LeRefl_9549(j: real)\n ensures j <= j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_9550","instance":9550,"id":179549,"goal":"lemma LeTrans_9550(i: int, c: int, b: int)\n requires i <= c && c <= b\n ensures i <= b\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_9551","instance":9551,"id":179550,"goal":"lemma AddMono_9551(d: nat, m: nat, y: nat)\n requires d <= m\n ensures d + y <= m + y\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_9552","instance":9552,"id":179551,"goal":"lemma Abs_Nonneg_9552(m: real)\n ensures (if m >= 0 then m else -m) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_9553","instance":9553,"id":179552,"goal":"lemma DivMod_9553(z: int, k: int)\n requires k > 0\n ensures z == k * (z / k) + (z % k)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_9554","instance":9554,"id":179553,"goal":"lemma ModBounds_9554(y: nat, b: nat)\n requires b > 0\n ensures 0 <= y % b < b\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_9555","instance":9555,"id":179554,"goal":"lemma Square_Nonneg_9555(a: real)\n ensures a * a >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_9556","instance":9556,"id":179555,"goal":"lemma AddComm_9556(i: int, m: int)\n ensures i + m == m + i\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_9557","instance":9557,"id":179556,"goal":"lemma AddAssoc_9557(b: nat, y: nat, x: nat)\n ensures (b + y) + x == b + (y + x)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_9558","instance":9558,"id":179557,"goal":"lemma MulComm_9558(i: real, x: real)\n ensures i * x == x * i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_9559","instance":9559,"id":179558,"goal":"lemma MulAssoc_9559(d: int, z: int, i: int)\n ensures (d * z) * i == d * (z * i)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_9560","instance":9560,"id":179559,"goal":"lemma Distrib_9560(b: nat, x: nat, m: nat)\n ensures b * (x + m) == b * x + b * m\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_9561","instance":9561,"id":179560,"goal":"lemma AddZero_9561(z: real)\n ensures z + 0 == z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_9562","instance":9562,"id":179561,"goal":"lemma MulOne_9562(k: int)\n ensures k * 1 == k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_9563","instance":9563,"id":179562,"goal":"lemma MulZero_9563(i: nat)\n ensures i * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_9564","instance":9564,"id":179563,"goal":"lemma LeRefl_9564(i: real)\n ensures i <= i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_9565","instance":9565,"id":179564,"goal":"lemma LeTrans_9565(k: int, b: int, c: int)\n requires k <= b && b <= c\n ensures k <= c\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_9566","instance":9566,"id":179565,"goal":"lemma AddMono_9566(b: nat, y: nat, m: nat)\n requires b <= y\n ensures b + m <= y + m\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_9567","instance":9567,"id":179566,"goal":"lemma Abs_Nonneg_9567(j: real)\n ensures (if j >= 0 then j else -j) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_9568","instance":9568,"id":179567,"goal":"lemma DivMod_9568(d: int, y: int)\n requires y > 0\n ensures d == y * (d / y) + (d % y)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_9569","instance":9569,"id":179568,"goal":"lemma ModBounds_9569(x: nat, b: nat)\n requires b > 0\n ensures 0 <= x % b < b\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_9570","instance":9570,"id":179569,"goal":"lemma Square_Nonneg_9570(b: real)\n ensures b * b >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_9571","instance":9571,"id":179570,"goal":"lemma AddComm_9571(z: int, a: int)\n ensures z + a == a + z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_9572","instance":9572,"id":179571,"goal":"lemma AddAssoc_9572(a: nat, k: nat, m: nat)\n ensures (a + k) + m == a + (k + m)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_9573","instance":9573,"id":179572,"goal":"lemma MulComm_9573(i: real, z: real)\n ensures i * z == z * i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_9574","instance":9574,"id":179573,"goal":"lemma MulAssoc_9574(i: int, j: int, z: int)\n ensures (i * j) * z == i * (j * z)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_9575","instance":9575,"id":179574,"goal":"lemma Distrib_9575(n: nat, z: nat, y: nat)\n ensures n * (z + y) == n * z + n * y\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_9576","instance":9576,"id":179575,"goal":"lemma AddZero_9576(x: real)\n ensures x + 0 == x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_9577","instance":9577,"id":179576,"goal":"lemma MulOne_9577(n: int)\n ensures n * 1 == n\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_9578","instance":9578,"id":179577,"goal":"lemma MulZero_9578(i: nat)\n ensures i * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_9579","instance":9579,"id":179578,"goal":"lemma LeRefl_9579(i: real)\n ensures i <= i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_9580","instance":9580,"id":179579,"goal":"lemma LeTrans_9580(c: int, k: int, b: int)\n requires c <= k && k <= b\n ensures c <= b\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_9581","instance":9581,"id":179580,"goal":"lemma AddMono_9581(j: nat, z: nat, x: nat)\n requires j <= z\n ensures j + x <= z + x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_9582","instance":9582,"id":179581,"goal":"lemma Abs_Nonneg_9582(b: real)\n ensures (if b >= 0 then b else -b) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_9583","instance":9583,"id":179582,"goal":"lemma DivMod_9583(b: int, j: int)\n requires j > 0\n ensures b == j * (b / j) + (b % j)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_9584","instance":9584,"id":179583,"goal":"lemma ModBounds_9584(y: nat, j: nat)\n requires j > 0\n ensures 0 <= y % j < j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_9585","instance":9585,"id":179584,"goal":"lemma Square_Nonneg_9585(y: real)\n ensures y * y >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_9586","instance":9586,"id":179585,"goal":"lemma AddComm_9586(j: int, x: int)\n ensures j + x == x + j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_9587","instance":9587,"id":179586,"goal":"lemma AddAssoc_9587(b: nat, j: nat, m: nat)\n ensures (b + j) + m == b + (j + m)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_9588","instance":9588,"id":179587,"goal":"lemma MulComm_9588(j: real, a: real)\n ensures j * a == a * j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_9589","instance":9589,"id":179588,"goal":"lemma MulAssoc_9589(m: int, d: int, x: int)\n ensures (m * d) * x == m * (d * x)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_9590","instance":9590,"id":179589,"goal":"lemma Distrib_9590(m: nat, d: nat, b: nat)\n ensures m * (d + b) == m * d + m * b\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_9591","instance":9591,"id":179590,"goal":"lemma AddZero_9591(j: real)\n ensures j + 0 == j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_9592","instance":9592,"id":179591,"goal":"lemma MulOne_9592(m: int)\n ensures m * 1 == m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_9593","instance":9593,"id":179592,"goal":"lemma MulZero_9593(d: nat)\n ensures d * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_9594","instance":9594,"id":179593,"goal":"lemma LeRefl_9594(x: real)\n ensures x <= x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_9595","instance":9595,"id":179594,"goal":"lemma LeTrans_9595(k: int, y: int, d: int)\n requires k <= y && y <= d\n ensures k <= d\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_9596","instance":9596,"id":179595,"goal":"lemma AddMono_9596(y: nat, n: nat, x: nat)\n requires y <= n\n ensures y + x <= n + x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_9597","instance":9597,"id":179596,"goal":"lemma Abs_Nonneg_9597(n: real)\n ensures (if n >= 0 then n else -n) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_9598","instance":9598,"id":179597,"goal":"lemma DivMod_9598(d: int, k: int)\n requires k > 0\n ensures d == k * (d / k) + (d % k)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_9599","instance":9599,"id":179598,"goal":"lemma ModBounds_9599(x: nat, b: nat)\n requires b > 0\n ensures 0 <= x % b < b\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_9600","instance":9600,"id":179599,"goal":"lemma Square_Nonneg_9600(c: real)\n ensures c * c >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_9601","instance":9601,"id":179600,"goal":"lemma AddComm_9601(i: int, n: int)\n ensures i + n == n + i\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_9602","instance":9602,"id":179601,"goal":"lemma AddAssoc_9602(z: nat, x: nat, b: nat)\n ensures (z + x) + b == z + (x + b)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_9603","instance":9603,"id":179602,"goal":"lemma MulComm_9603(b: real, y: real)\n ensures b * y == y * b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_9604","instance":9604,"id":179603,"goal":"lemma MulAssoc_9604(a: int, y: int, b: int)\n ensures (a * y) * b == a * (y * b)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_9605","instance":9605,"id":179604,"goal":"lemma Distrib_9605(z: nat, x: nat, n: nat)\n ensures z * (x + n) == z * x + z * n\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_9606","instance":9606,"id":179605,"goal":"lemma AddZero_9606(j: real)\n ensures j + 0 == j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_9607","instance":9607,"id":179606,"goal":"lemma MulOne_9607(n: int)\n ensures n * 1 == n\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_9608","instance":9608,"id":179607,"goal":"lemma MulZero_9608(j: nat)\n ensures j * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_9609","instance":9609,"id":179608,"goal":"lemma LeRefl_9609(z: real)\n ensures z <= z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_9610","instance":9610,"id":179609,"goal":"lemma LeTrans_9610(y: int, x: int, m: int)\n requires y <= x && x <= m\n ensures y <= m\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_9611","instance":9611,"id":179610,"goal":"lemma AddMono_9611(n: nat, i: nat, m: nat)\n requires n <= i\n ensures n + m <= i + m\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_9612","instance":9612,"id":179611,"goal":"lemma Abs_Nonneg_9612(j: real)\n ensures (if j >= 0 then j else -j) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_9613","instance":9613,"id":179612,"goal":"lemma DivMod_9613(x: int, k: int)\n requires k > 0\n ensures x == k * (x / k) + (x % k)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_9614","instance":9614,"id":179613,"goal":"lemma ModBounds_9614(x: nat, d: nat)\n requires d > 0\n ensures 0 <= x % d < d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_9615","instance":9615,"id":179614,"goal":"lemma Square_Nonneg_9615(d: real)\n ensures d * d >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_9616","instance":9616,"id":179615,"goal":"lemma AddComm_9616(z: int, m: int)\n ensures z + m == m + z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_9617","instance":9617,"id":179616,"goal":"lemma AddAssoc_9617(y: nat, c: nat, d: nat)\n ensures (y + c) + d == y + (c + d)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_9618","instance":9618,"id":179617,"goal":"lemma MulComm_9618(n: real, b: real)\n ensures n * b == b * n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_9619","instance":9619,"id":179618,"goal":"lemma MulAssoc_9619(b: int, m: int, k: int)\n ensures (b * m) * k == b * (m * k)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_9620","instance":9620,"id":179619,"goal":"lemma Distrib_9620(a: nat, m: nat, z: nat)\n ensures a * (m + z) == a * m + a * z\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_9621","instance":9621,"id":179620,"goal":"lemma AddZero_9621(x: real)\n ensures x + 0 == x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_9622","instance":9622,"id":179621,"goal":"lemma MulOne_9622(m: int)\n ensures m * 1 == m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_9623","instance":9623,"id":179622,"goal":"lemma MulZero_9623(y: nat)\n ensures y * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_9624","instance":9624,"id":179623,"goal":"lemma LeRefl_9624(j: real)\n ensures j <= j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_9625","instance":9625,"id":179624,"goal":"lemma LeTrans_9625(a: int, c: int, j: int)\n requires a <= c && c <= j\n ensures a <= j\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_9626","instance":9626,"id":179625,"goal":"lemma AddMono_9626(a: nat, y: nat, m: nat)\n requires a <= y\n ensures a + m <= y + m\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_9627","instance":9627,"id":179626,"goal":"lemma Abs_Nonneg_9627(c: real)\n ensures (if c >= 0 then c else -c) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_9628","instance":9628,"id":179627,"goal":"lemma DivMod_9628(c: int, n: int)\n requires n > 0\n ensures c == n * (c / n) + (c % n)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_9629","instance":9629,"id":179628,"goal":"lemma ModBounds_9629(d: nat, c: nat)\n requires c > 0\n ensures 0 <= d % c < c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_9630","instance":9630,"id":179629,"goal":"lemma Square_Nonneg_9630(c: real)\n ensures c * c >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_9631","instance":9631,"id":179630,"goal":"lemma AddComm_9631(d: int, m: int)\n ensures d + m == m + d\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_9632","instance":9632,"id":179631,"goal":"lemma AddAssoc_9632(c: nat, d: nat, y: nat)\n ensures (c + d) + y == c + (d + y)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_9633","instance":9633,"id":179632,"goal":"lemma MulComm_9633(x: real, a: real)\n ensures x * a == a * x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_9634","instance":9634,"id":179633,"goal":"lemma MulAssoc_9634(c: int, i: int, d: int)\n ensures (c * i) * d == c * (i * d)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_9635","instance":9635,"id":179634,"goal":"lemma Distrib_9635(c: nat, n: nat, i: nat)\n ensures c * (n + i) == c * n + c * i\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_9636","instance":9636,"id":179635,"goal":"lemma AddZero_9636(j: real)\n ensures j + 0 == j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_9637","instance":9637,"id":179636,"goal":"lemma MulOne_9637(d: int)\n ensures d * 1 == d\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_9638","instance":9638,"id":179637,"goal":"lemma MulZero_9638(n: nat)\n ensures n * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_9639","instance":9639,"id":179638,"goal":"lemma LeRefl_9639(j: real)\n ensures j <= j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_9640","instance":9640,"id":179639,"goal":"lemma LeTrans_9640(j: int, n: int, m: int)\n requires j <= n && n <= m\n ensures j <= m\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_9641","instance":9641,"id":179640,"goal":"lemma AddMono_9641(y: nat, z: nat, x: nat)\n requires y <= z\n ensures y + x <= z + x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_9642","instance":9642,"id":179641,"goal":"lemma Abs_Nonneg_9642(m: real)\n ensures (if m >= 0 then m else -m) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_9643","instance":9643,"id":179642,"goal":"lemma DivMod_9643(b: int, y: int)\n requires y > 0\n ensures b == y * (b / y) + (b % y)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_9644","instance":9644,"id":179643,"goal":"lemma ModBounds_9644(c: nat, j: nat)\n requires j > 0\n ensures 0 <= c % j < j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_9645","instance":9645,"id":179644,"goal":"lemma Square_Nonneg_9645(j: real)\n ensures j * j >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_9646","instance":9646,"id":179645,"goal":"lemma AddComm_9646(c: int, k: int)\n ensures c + k == k + c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_9647","instance":9647,"id":179646,"goal":"lemma AddAssoc_9647(i: nat, n: nat, j: nat)\n ensures (i + n) + j == i + (n + j)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_9648","instance":9648,"id":179647,"goal":"lemma MulComm_9648(b: real, n: real)\n ensures b * n == n * b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_9649","instance":9649,"id":179648,"goal":"lemma MulAssoc_9649(b: int, k: int, x: int)\n ensures (b * k) * x == b * (k * x)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_9650","instance":9650,"id":179649,"goal":"lemma Distrib_9650(c: nat, b: nat, d: nat)\n ensures c * (b + d) == c * b + c * d\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_9651","instance":9651,"id":179650,"goal":"lemma AddZero_9651(j: real)\n ensures j + 0 == j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_9652","instance":9652,"id":179651,"goal":"lemma MulOne_9652(b: int)\n ensures b * 1 == b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_9653","instance":9653,"id":179652,"goal":"lemma MulZero_9653(b: nat)\n ensures b * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_9654","instance":9654,"id":179653,"goal":"lemma LeRefl_9654(x: real)\n ensures x <= x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_9655","instance":9655,"id":179654,"goal":"lemma LeTrans_9655(j: int, m: int, b: int)\n requires j <= m && m <= b\n ensures j <= b\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_9656","instance":9656,"id":179655,"goal":"lemma AddMono_9656(j: nat, n: nat, a: nat)\n requires j <= n\n ensures j + a <= n + a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_9657","instance":9657,"id":179656,"goal":"lemma Abs_Nonneg_9657(z: real)\n ensures (if z >= 0 then z else -z) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_9658","instance":9658,"id":179657,"goal":"lemma DivMod_9658(a: int, m: int)\n requires m > 0\n ensures a == m * (a / m) + (a % m)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_9659","instance":9659,"id":179658,"goal":"lemma ModBounds_9659(z: nat, n: nat)\n requires n > 0\n ensures 0 <= z % n < n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_9660","instance":9660,"id":179659,"goal":"lemma Square_Nonneg_9660(b: real)\n ensures b * b >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_9661","instance":9661,"id":179660,"goal":"lemma AddComm_9661(j: int, c: int)\n ensures j + c == c + j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_9662","instance":9662,"id":179661,"goal":"lemma AddAssoc_9662(z: nat, m: nat, y: nat)\n ensures (z + m) + y == z + (m + y)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_9663","instance":9663,"id":179662,"goal":"lemma MulComm_9663(m: real, z: real)\n ensures m * z == z * m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_9664","instance":9664,"id":179663,"goal":"lemma MulAssoc_9664(m: int, y: int, j: int)\n ensures (m * y) * j == m * (y * j)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_9665","instance":9665,"id":179664,"goal":"lemma Distrib_9665(b: nat, n: nat, c: nat)\n ensures b * (n + c) == b * n + b * c\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_9666","instance":9666,"id":179665,"goal":"lemma AddZero_9666(x: real)\n ensures x + 0 == x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_9667","instance":9667,"id":179666,"goal":"lemma MulOne_9667(k: int)\n ensures k * 1 == k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_9668","instance":9668,"id":179667,"goal":"lemma MulZero_9668(j: nat)\n ensures j * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_9669","instance":9669,"id":179668,"goal":"lemma LeRefl_9669(z: real)\n ensures z <= z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_9670","instance":9670,"id":179669,"goal":"lemma LeTrans_9670(c: int, k: int, n: int)\n requires c <= k && k <= n\n ensures c <= n\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_9671","instance":9671,"id":179670,"goal":"lemma AddMono_9671(i: nat, a: nat, n: nat)\n requires i <= a\n ensures i + n <= a + n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_9672","instance":9672,"id":179671,"goal":"lemma Abs_Nonneg_9672(y: real)\n ensures (if y >= 0 then y else -y) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_9673","instance":9673,"id":179672,"goal":"lemma DivMod_9673(m: int, a: int)\n requires a > 0\n ensures m == a * (m / a) + (m % a)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_9674","instance":9674,"id":179673,"goal":"lemma ModBounds_9674(m: nat, z: nat)\n requires z > 0\n ensures 0 <= m % z < z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_9675","instance":9675,"id":179674,"goal":"lemma Square_Nonneg_9675(j: real)\n ensures j * j >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_9676","instance":9676,"id":179675,"goal":"lemma AddComm_9676(m: int, y: int)\n ensures m + y == y + m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_9677","instance":9677,"id":179676,"goal":"lemma AddAssoc_9677(x: nat, y: nat, k: nat)\n ensures (x + y) + k == x + (y + k)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_9678","instance":9678,"id":179677,"goal":"lemma MulComm_9678(d: real, z: real)\n ensures d * z == z * d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_9679","instance":9679,"id":179678,"goal":"lemma MulAssoc_9679(x: int, y: int, b: int)\n ensures (x * y) * b == x * (y * b)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_9680","instance":9680,"id":179679,"goal":"lemma Distrib_9680(k: nat, d: nat, x: nat)\n ensures k * (d + x) == k * d + k * x\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_9681","instance":9681,"id":179680,"goal":"lemma AddZero_9681(a: real)\n ensures a + 0 == a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_9682","instance":9682,"id":179681,"goal":"lemma MulOne_9682(d: int)\n ensures d * 1 == d\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_9683","instance":9683,"id":179682,"goal":"lemma MulZero_9683(a: nat)\n ensures a * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_9684","instance":9684,"id":179683,"goal":"lemma LeRefl_9684(n: real)\n ensures n <= n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_9685","instance":9685,"id":179684,"goal":"lemma LeTrans_9685(c: int, z: int, j: int)\n requires c <= z && z <= j\n ensures c <= j\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_9686","instance":9686,"id":179685,"goal":"lemma AddMono_9686(n: nat, z: nat, k: nat)\n requires n <= z\n ensures n + k <= z + k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_9687","instance":9687,"id":179686,"goal":"lemma Abs_Nonneg_9687(j: real)\n ensures (if j >= 0 then j else -j) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_9688","instance":9688,"id":179687,"goal":"lemma DivMod_9688(k: int, x: int)\n requires x > 0\n ensures k == x * (k / x) + (k % x)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_9689","instance":9689,"id":179688,"goal":"lemma ModBounds_9689(b: nat, y: nat)\n requires y > 0\n ensures 0 <= b % y < y\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_9690","instance":9690,"id":179689,"goal":"lemma Square_Nonneg_9690(k: real)\n ensures k * k >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_9691","instance":9691,"id":179690,"goal":"lemma AddComm_9691(c: int, y: int)\n ensures c + y == y + c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_9692","instance":9692,"id":179691,"goal":"lemma AddAssoc_9692(k: nat, b: nat, a: nat)\n ensures (k + b) + a == k + (b + a)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_9693","instance":9693,"id":179692,"goal":"lemma MulComm_9693(n: real, i: real)\n ensures n * i == i * n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_9694","instance":9694,"id":179693,"goal":"lemma MulAssoc_9694(m: int, y: int, z: int)\n ensures (m * y) * z == m * (y * z)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_9695","instance":9695,"id":179694,"goal":"lemma Distrib_9695(d: nat, z: nat, n: nat)\n ensures d * (z + n) == d * z + d * n\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_9696","instance":9696,"id":179695,"goal":"lemma AddZero_9696(k: real)\n ensures k + 0 == k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_9697","instance":9697,"id":179696,"goal":"lemma MulOne_9697(n: int)\n ensures n * 1 == n\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_9698","instance":9698,"id":179697,"goal":"lemma MulZero_9698(x: nat)\n ensures x * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_9699","instance":9699,"id":179698,"goal":"lemma LeRefl_9699(x: real)\n ensures x <= x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_9700","instance":9700,"id":179699,"goal":"lemma LeTrans_9700(a: int, n: int, i: int)\n requires a <= n && n <= i\n ensures a <= i\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_9701","instance":9701,"id":179700,"goal":"lemma AddMono_9701(m: nat, c: nat, j: nat)\n requires m <= c\n ensures m + j <= c + j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_9702","instance":9702,"id":179701,"goal":"lemma Abs_Nonneg_9702(d: real)\n ensures (if d >= 0 then d else -d) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_9703","instance":9703,"id":179702,"goal":"lemma DivMod_9703(i: int, z: int)\n requires z > 0\n ensures i == z * (i / z) + (i % z)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_9704","instance":9704,"id":179703,"goal":"lemma ModBounds_9704(k: nat, i: nat)\n requires i > 0\n ensures 0 <= k % i < i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_9705","instance":9705,"id":179704,"goal":"lemma Square_Nonneg_9705(x: real)\n ensures x * x >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_9706","instance":9706,"id":179705,"goal":"lemma AddComm_9706(x: int, n: int)\n ensures x + n == n + x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_9707","instance":9707,"id":179706,"goal":"lemma AddAssoc_9707(i: nat, m: nat, a: nat)\n ensures (i + m) + a == i + (m + a)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_9708","instance":9708,"id":179707,"goal":"lemma MulComm_9708(z: real, d: real)\n ensures z * d == d * z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_9709","instance":9709,"id":179708,"goal":"lemma MulAssoc_9709(x: int, m: int, d: int)\n ensures (x * m) * d == x * (m * d)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_9710","instance":9710,"id":179709,"goal":"lemma Distrib_9710(z: nat, m: nat, d: nat)\n ensures z * (m + d) == z * m + z * d\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_9711","instance":9711,"id":179710,"goal":"lemma AddZero_9711(y: real)\n ensures y + 0 == y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_9712","instance":9712,"id":179711,"goal":"lemma MulOne_9712(c: int)\n ensures c * 1 == c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_9713","instance":9713,"id":179712,"goal":"lemma MulZero_9713(y: nat)\n ensures y * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_9714","instance":9714,"id":179713,"goal":"lemma LeRefl_9714(i: real)\n ensures i <= i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_9715","instance":9715,"id":179714,"goal":"lemma LeTrans_9715(b: int, x: int, i: int)\n requires b <= x && x <= i\n ensures b <= i\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_9716","instance":9716,"id":179715,"goal":"lemma AddMono_9716(c: nat, m: nat, b: nat)\n requires c <= m\n ensures c + b <= m + b\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_9717","instance":9717,"id":179716,"goal":"lemma Abs_Nonneg_9717(y: real)\n ensures (if y >= 0 then y else -y) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_9718","instance":9718,"id":179717,"goal":"lemma DivMod_9718(k: int, i: int)\n requires i > 0\n ensures k == i * (k / i) + (k % i)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_9719","instance":9719,"id":179718,"goal":"lemma ModBounds_9719(y: nat, c: nat)\n requires c > 0\n ensures 0 <= y % c < c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_9720","instance":9720,"id":179719,"goal":"lemma Square_Nonneg_9720(j: real)\n ensures j * j >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_9721","instance":9721,"id":179720,"goal":"lemma AddComm_9721(x: int, d: int)\n ensures x + d == d + x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_9722","instance":9722,"id":179721,"goal":"lemma AddAssoc_9722(n: nat, b: nat, d: nat)\n ensures (n + b) + d == n + (b + d)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_9723","instance":9723,"id":179722,"goal":"lemma MulComm_9723(x: real, d: real)\n ensures x * d == d * x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_9724","instance":9724,"id":179723,"goal":"lemma MulAssoc_9724(k: int, x: int, j: int)\n ensures (k * x) * j == k * (x * j)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_9725","instance":9725,"id":179724,"goal":"lemma Distrib_9725(y: nat, i: nat, m: nat)\n ensures y * (i + m) == y * i + y * m\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_9726","instance":9726,"id":179725,"goal":"lemma AddZero_9726(y: real)\n ensures y + 0 == y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_9727","instance":9727,"id":179726,"goal":"lemma MulOne_9727(b: int)\n ensures b * 1 == b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_9728","instance":9728,"id":179727,"goal":"lemma MulZero_9728(c: nat)\n ensures c * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_9729","instance":9729,"id":179728,"goal":"lemma LeRefl_9729(a: real)\n ensures a <= a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_9730","instance":9730,"id":179729,"goal":"lemma LeTrans_9730(n: int, y: int, c: int)\n requires n <= y && y <= c\n ensures n <= c\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_9731","instance":9731,"id":179730,"goal":"lemma AddMono_9731(i: nat, d: nat, y: nat)\n requires i <= d\n ensures i + y <= d + y\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_9732","instance":9732,"id":179731,"goal":"lemma Abs_Nonneg_9732(m: real)\n ensures (if m >= 0 then m else -m) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_9733","instance":9733,"id":179732,"goal":"lemma DivMod_9733(i: int, z: int)\n requires z > 0\n ensures i == z * (i / z) + (i % z)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_9734","instance":9734,"id":179733,"goal":"lemma ModBounds_9734(y: nat, c: nat)\n requires c > 0\n ensures 0 <= y % c < c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_9735","instance":9735,"id":179734,"goal":"lemma Square_Nonneg_9735(b: real)\n ensures b * b >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_9736","instance":9736,"id":179735,"goal":"lemma AddComm_9736(b: int, c: int)\n ensures b + c == c + b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_9737","instance":9737,"id":179736,"goal":"lemma AddAssoc_9737(m: nat, c: nat, i: nat)\n ensures (m + c) + i == m + (c + i)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_9738","instance":9738,"id":179737,"goal":"lemma MulComm_9738(c: real, b: real)\n ensures c * b == b * c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_9739","instance":9739,"id":179738,"goal":"lemma MulAssoc_9739(z: int, a: int, n: int)\n ensures (z * a) * n == z * (a * n)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_9740","instance":9740,"id":179739,"goal":"lemma Distrib_9740(n: nat, d: nat, z: nat)\n ensures n * (d + z) == n * d + n * z\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_9741","instance":9741,"id":179740,"goal":"lemma AddZero_9741(x: real)\n ensures x + 0 == x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_9742","instance":9742,"id":179741,"goal":"lemma MulOne_9742(i: int)\n ensures i * 1 == i\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_9743","instance":9743,"id":179742,"goal":"lemma MulZero_9743(k: nat)\n ensures k * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_9744","instance":9744,"id":179743,"goal":"lemma LeRefl_9744(c: real)\n ensures c <= c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_9745","instance":9745,"id":179744,"goal":"lemma LeTrans_9745(k: int, i: int, z: int)\n requires k <= i && i <= z\n ensures k <= z\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_9746","instance":9746,"id":179745,"goal":"lemma AddMono_9746(d: nat, k: nat, b: nat)\n requires d <= k\n ensures d + b <= k + b\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_9747","instance":9747,"id":179746,"goal":"lemma Abs_Nonneg_9747(c: real)\n ensures (if c >= 0 then c else -c) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_9748","instance":9748,"id":179747,"goal":"lemma DivMod_9748(n: int, z: int)\n requires z > 0\n ensures n == z * (n / z) + (n % z)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_9749","instance":9749,"id":179748,"goal":"lemma ModBounds_9749(d: nat, z: nat)\n requires z > 0\n ensures 0 <= d % z < z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_9750","instance":9750,"id":179749,"goal":"lemma Square_Nonneg_9750(x: real)\n ensures x * x >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_9751","instance":9751,"id":179750,"goal":"lemma AddComm_9751(z: int, x: int)\n ensures z + x == x + z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_9752","instance":9752,"id":179751,"goal":"lemma AddAssoc_9752(x: nat, j: nat, c: nat)\n ensures (x + j) + c == x + (j + c)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_9753","instance":9753,"id":179752,"goal":"lemma MulComm_9753(n: real, x: real)\n ensures n * x == x * n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_9754","instance":9754,"id":179753,"goal":"lemma MulAssoc_9754(n: int, k: int, x: int)\n ensures (n * k) * x == n * (k * x)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_9755","instance":9755,"id":179754,"goal":"lemma Distrib_9755(i: nat, m: nat, k: nat)\n ensures i * (m + k) == i * m + i * k\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_9756","instance":9756,"id":179755,"goal":"lemma AddZero_9756(b: real)\n ensures b + 0 == b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_9757","instance":9757,"id":179756,"goal":"lemma MulOne_9757(x: int)\n ensures x * 1 == x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_9758","instance":9758,"id":179757,"goal":"lemma MulZero_9758(z: nat)\n ensures z * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_9759","instance":9759,"id":179758,"goal":"lemma LeRefl_9759(b: real)\n ensures b <= b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_9760","instance":9760,"id":179759,"goal":"lemma LeTrans_9760(n: int, y: int, d: int)\n requires n <= y && y <= d\n ensures n <= d\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_9761","instance":9761,"id":179760,"goal":"lemma AddMono_9761(x: nat, b: nat, a: nat)\n requires x <= b\n ensures x + a <= b + a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_9762","instance":9762,"id":179761,"goal":"lemma Abs_Nonneg_9762(i: real)\n ensures (if i >= 0 then i else -i) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_9763","instance":9763,"id":179762,"goal":"lemma DivMod_9763(x: int, a: int)\n requires a > 0\n ensures x == a * (x / a) + (x % a)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_9764","instance":9764,"id":179763,"goal":"lemma ModBounds_9764(j: nat, m: nat)\n requires m > 0\n ensures 0 <= j % m < m\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_9765","instance":9765,"id":179764,"goal":"lemma Square_Nonneg_9765(b: real)\n ensures b * b >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_9766","instance":9766,"id":179765,"goal":"lemma AddComm_9766(j: int, m: int)\n ensures j + m == m + j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_9767","instance":9767,"id":179766,"goal":"lemma AddAssoc_9767(d: nat, j: nat, z: nat)\n ensures (d + j) + z == d + (j + z)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_9768","instance":9768,"id":179767,"goal":"lemma MulComm_9768(a: real, d: real)\n ensures a * d == d * a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_9769","instance":9769,"id":179768,"goal":"lemma MulAssoc_9769(j: int, b: int, x: int)\n ensures (j * b) * x == j * (b * x)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_9770","instance":9770,"id":179769,"goal":"lemma Distrib_9770(d: nat, x: nat, k: nat)\n ensures d * (x + k) == d * x + d * k\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_9771","instance":9771,"id":179770,"goal":"lemma AddZero_9771(n: real)\n ensures n + 0 == n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_9772","instance":9772,"id":179771,"goal":"lemma MulOne_9772(n: int)\n ensures n * 1 == n\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_9773","instance":9773,"id":179772,"goal":"lemma MulZero_9773(b: nat)\n ensures b * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_9774","instance":9774,"id":179773,"goal":"lemma LeRefl_9774(b: real)\n ensures b <= b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_9775","instance":9775,"id":179774,"goal":"lemma LeTrans_9775(b: int, c: int, k: int)\n requires b <= c && c <= k\n ensures b <= k\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_9776","instance":9776,"id":179775,"goal":"lemma AddMono_9776(n: nat, c: nat, k: nat)\n requires n <= c\n ensures n + k <= c + k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_9777","instance":9777,"id":179776,"goal":"lemma Abs_Nonneg_9777(n: real)\n ensures (if n >= 0 then n else -n) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_9778","instance":9778,"id":179777,"goal":"lemma DivMod_9778(c: int, k: int)\n requires k > 0\n ensures c == k * (c / k) + (c % k)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_9779","instance":9779,"id":179778,"goal":"lemma ModBounds_9779(m: nat, c: nat)\n requires c > 0\n ensures 0 <= m % c < c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_9780","instance":9780,"id":179779,"goal":"lemma Square_Nonneg_9780(a: real)\n ensures a * a >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_9781","instance":9781,"id":179780,"goal":"lemma AddComm_9781(n: int, a: int)\n ensures n + a == a + n\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_9782","instance":9782,"id":179781,"goal":"lemma AddAssoc_9782(c: nat, d: nat, x: nat)\n ensures (c + d) + x == c + (d + x)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_9783","instance":9783,"id":179782,"goal":"lemma MulComm_9783(c: real, n: real)\n ensures c * n == n * c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_9784","instance":9784,"id":179783,"goal":"lemma MulAssoc_9784(b: int, k: int, y: int)\n ensures (b * k) * y == b * (k * y)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_9785","instance":9785,"id":179784,"goal":"lemma Distrib_9785(y: nat, m: nat, b: nat)\n ensures y * (m + b) == y * m + y * b\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_9786","instance":9786,"id":179785,"goal":"lemma AddZero_9786(m: real)\n ensures m + 0 == m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_9787","instance":9787,"id":179786,"goal":"lemma MulOne_9787(a: int)\n ensures a * 1 == a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_9788","instance":9788,"id":179787,"goal":"lemma MulZero_9788(m: nat)\n ensures m * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_9789","instance":9789,"id":179788,"goal":"lemma LeRefl_9789(i: real)\n ensures i <= i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_9790","instance":9790,"id":179789,"goal":"lemma LeTrans_9790(j: int, a: int, b: int)\n requires j <= a && a <= b\n ensures j <= b\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_9791","instance":9791,"id":179790,"goal":"lemma AddMono_9791(j: nat, b: nat, y: nat)\n requires j <= b\n ensures j + y <= b + y\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_9792","instance":9792,"id":179791,"goal":"lemma Abs_Nonneg_9792(n: real)\n ensures (if n >= 0 then n else -n) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_9793","instance":9793,"id":179792,"goal":"lemma DivMod_9793(d: int, j: int)\n requires j > 0\n ensures d == j * (d / j) + (d % j)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_9794","instance":9794,"id":179793,"goal":"lemma ModBounds_9794(a: nat, z: nat)\n requires z > 0\n ensures 0 <= a % z < z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_9795","instance":9795,"id":179794,"goal":"lemma Square_Nonneg_9795(b: real)\n ensures b * b >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_9796","instance":9796,"id":179795,"goal":"lemma AddComm_9796(d: int, a: int)\n ensures d + a == a + d\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_9797","instance":9797,"id":179796,"goal":"lemma AddAssoc_9797(m: nat, z: nat, d: nat)\n ensures (m + z) + d == m + (z + d)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_9798","instance":9798,"id":179797,"goal":"lemma MulComm_9798(k: real, a: real)\n ensures k * a == a * k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_9799","instance":9799,"id":179798,"goal":"lemma MulAssoc_9799(i: int, a: int, d: int)\n ensures (i * a) * d == i * (a * d)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_9800","instance":9800,"id":179799,"goal":"lemma Distrib_9800(x: nat, i: nat, m: nat)\n ensures x * (i + m) == x * i + x * m\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_9801","instance":9801,"id":179800,"goal":"lemma AddZero_9801(y: real)\n ensures y + 0 == y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_9802","instance":9802,"id":179801,"goal":"lemma MulOne_9802(c: int)\n ensures c * 1 == c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_9803","instance":9803,"id":179802,"goal":"lemma MulZero_9803(m: nat)\n ensures m * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_9804","instance":9804,"id":179803,"goal":"lemma LeRefl_9804(m: real)\n ensures m <= m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_9805","instance":9805,"id":179804,"goal":"lemma LeTrans_9805(y: int, d: int, a: int)\n requires y <= d && d <= a\n ensures y <= a\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_9806","instance":9806,"id":179805,"goal":"lemma AddMono_9806(j: nat, k: nat, i: nat)\n requires j <= k\n ensures j + i <= k + i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_9807","instance":9807,"id":179806,"goal":"lemma Abs_Nonneg_9807(k: real)\n ensures (if k >= 0 then k else -k) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_9808","instance":9808,"id":179807,"goal":"lemma DivMod_9808(a: int, x: int)\n requires x > 0\n ensures a == x * (a / x) + (a % x)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_9809","instance":9809,"id":179808,"goal":"lemma ModBounds_9809(y: nat, i: nat)\n requires i > 0\n ensures 0 <= y % i < i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_9810","instance":9810,"id":179809,"goal":"lemma Square_Nonneg_9810(x: real)\n ensures x * x >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_9811","instance":9811,"id":179810,"goal":"lemma AddComm_9811(m: int, y: int)\n ensures m + y == y + m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_9812","instance":9812,"id":179811,"goal":"lemma AddAssoc_9812(k: nat, y: nat, z: nat)\n ensures (k + y) + z == k + (y + z)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_9813","instance":9813,"id":179812,"goal":"lemma MulComm_9813(n: real, z: real)\n ensures n * z == z * n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_9814","instance":9814,"id":179813,"goal":"lemma MulAssoc_9814(x: int, b: int, n: int)\n ensures (x * b) * n == x * (b * n)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_9815","instance":9815,"id":179814,"goal":"lemma Distrib_9815(c: nat, i: nat, j: nat)\n ensures c * (i + j) == c * i + c * j\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_9816","instance":9816,"id":179815,"goal":"lemma AddZero_9816(y: real)\n ensures y + 0 == y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_9817","instance":9817,"id":179816,"goal":"lemma MulOne_9817(z: int)\n ensures z * 1 == z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_9818","instance":9818,"id":179817,"goal":"lemma MulZero_9818(y: nat)\n ensures y * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_9819","instance":9819,"id":179818,"goal":"lemma LeRefl_9819(z: real)\n ensures z <= z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_9820","instance":9820,"id":179819,"goal":"lemma LeTrans_9820(y: int, d: int, c: int)\n requires y <= d && d <= c\n ensures y <= c\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_9821","instance":9821,"id":179820,"goal":"lemma AddMono_9821(c: nat, x: nat, z: nat)\n requires c <= x\n ensures c + z <= x + z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_9822","instance":9822,"id":179821,"goal":"lemma Abs_Nonneg_9822(z: real)\n ensures (if z >= 0 then z else -z) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_9823","instance":9823,"id":179822,"goal":"lemma DivMod_9823(n: int, b: int)\n requires b > 0\n ensures n == b * (n / b) + (n % b)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_9824","instance":9824,"id":179823,"goal":"lemma ModBounds_9824(a: nat, d: nat)\n requires d > 0\n ensures 0 <= a % d < d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_9825","instance":9825,"id":179824,"goal":"lemma Square_Nonneg_9825(m: real)\n ensures m * m >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_9826","instance":9826,"id":179825,"goal":"lemma AddComm_9826(z: int, y: int)\n ensures z + y == y + z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_9827","instance":9827,"id":179826,"goal":"lemma AddAssoc_9827(b: nat, k: nat, x: nat)\n ensures (b + k) + x == b + (k + x)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_9828","instance":9828,"id":179827,"goal":"lemma MulComm_9828(i: real, n: real)\n ensures i * n == n * i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_9829","instance":9829,"id":179828,"goal":"lemma MulAssoc_9829(a: int, m: int, k: int)\n ensures (a * m) * k == a * (m * k)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_9830","instance":9830,"id":179829,"goal":"lemma Distrib_9830(z: nat, x: nat, m: nat)\n ensures z * (x + m) == z * x + z * m\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_9831","instance":9831,"id":179830,"goal":"lemma AddZero_9831(c: real)\n ensures c + 0 == c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_9832","instance":9832,"id":179831,"goal":"lemma MulOne_9832(n: int)\n ensures n * 1 == n\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_9833","instance":9833,"id":179832,"goal":"lemma MulZero_9833(x: nat)\n ensures x * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_9834","instance":9834,"id":179833,"goal":"lemma LeRefl_9834(m: real)\n ensures m <= m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_9835","instance":9835,"id":179834,"goal":"lemma LeTrans_9835(c: int, i: int, y: int)\n requires c <= i && i <= y\n ensures c <= y\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_9836","instance":9836,"id":179835,"goal":"lemma AddMono_9836(z: nat, i: nat, n: nat)\n requires z <= i\n ensures z + n <= i + n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_9837","instance":9837,"id":179836,"goal":"lemma Abs_Nonneg_9837(a: real)\n ensures (if a >= 0 then a else -a) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_9838","instance":9838,"id":179837,"goal":"lemma DivMod_9838(i: int, k: int)\n requires k > 0\n ensures i == k * (i / k) + (i % k)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_9839","instance":9839,"id":179838,"goal":"lemma ModBounds_9839(j: nat, x: nat)\n requires x > 0\n ensures 0 <= j % x < x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_9840","instance":9840,"id":179839,"goal":"lemma Square_Nonneg_9840(n: real)\n ensures n * n >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_9841","instance":9841,"id":179840,"goal":"lemma AddComm_9841(j: int, i: int)\n ensures j + i == i + j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_9842","instance":9842,"id":179841,"goal":"lemma AddAssoc_9842(i: nat, z: nat, x: nat)\n ensures (i + z) + x == i + (z + x)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_9843","instance":9843,"id":179842,"goal":"lemma MulComm_9843(m: real, d: real)\n ensures m * d == d * m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_9844","instance":9844,"id":179843,"goal":"lemma MulAssoc_9844(d: int, x: int, k: int)\n ensures (d * x) * k == d * (x * k)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_9845","instance":9845,"id":179844,"goal":"lemma Distrib_9845(n: nat, c: nat, d: nat)\n ensures n * (c + d) == n * c + n * d\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_9846","instance":9846,"id":179845,"goal":"lemma AddZero_9846(z: real)\n ensures z + 0 == z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_9847","instance":9847,"id":179846,"goal":"lemma MulOne_9847(x: int)\n ensures x * 1 == x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_9848","instance":9848,"id":179847,"goal":"lemma MulZero_9848(m: nat)\n ensures m * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_9849","instance":9849,"id":179848,"goal":"lemma LeRefl_9849(d: real)\n ensures d <= d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_9850","instance":9850,"id":179849,"goal":"lemma LeTrans_9850(j: int, a: int, k: int)\n requires j <= a && a <= k\n ensures j <= k\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_9851","instance":9851,"id":179850,"goal":"lemma AddMono_9851(d: nat, n: nat, x: nat)\n requires d <= n\n ensures d + x <= n + x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_9852","instance":9852,"id":179851,"goal":"lemma Abs_Nonneg_9852(j: real)\n ensures (if j >= 0 then j else -j) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_9853","instance":9853,"id":179852,"goal":"lemma DivMod_9853(a: int, j: int)\n requires j > 0\n ensures a == j * (a / j) + (a % j)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_9854","instance":9854,"id":179853,"goal":"lemma ModBounds_9854(n: nat, z: nat)\n requires z > 0\n ensures 0 <= n % z < z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_9855","instance":9855,"id":179854,"goal":"lemma Square_Nonneg_9855(y: real)\n ensures y * y >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_9856","instance":9856,"id":179855,"goal":"lemma AddComm_9856(i: int, x: int)\n ensures i + x == x + i\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_9857","instance":9857,"id":179856,"goal":"lemma AddAssoc_9857(n: nat, a: nat, b: nat)\n ensures (n + a) + b == n + (a + b)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_9858","instance":9858,"id":179857,"goal":"lemma MulComm_9858(y: real, i: real)\n ensures y * i == i * y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_9859","instance":9859,"id":179858,"goal":"lemma MulAssoc_9859(b: int, m: int, n: int)\n ensures (b * m) * n == b * (m * n)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_9860","instance":9860,"id":179859,"goal":"lemma Distrib_9860(n: nat, i: nat, a: nat)\n ensures n * (i + a) == n * i + n * a\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_9861","instance":9861,"id":179860,"goal":"lemma AddZero_9861(x: real)\n ensures x + 0 == x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_9862","instance":9862,"id":179861,"goal":"lemma MulOne_9862(x: int)\n ensures x * 1 == x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_9863","instance":9863,"id":179862,"goal":"lemma MulZero_9863(n: nat)\n ensures n * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_9864","instance":9864,"id":179863,"goal":"lemma LeRefl_9864(z: real)\n ensures z <= z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_9865","instance":9865,"id":179864,"goal":"lemma LeTrans_9865(i: int, z: int, b: int)\n requires i <= z && z <= b\n ensures i <= b\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_9866","instance":9866,"id":179865,"goal":"lemma AddMono_9866(n: nat, m: nat, z: nat)\n requires n <= m\n ensures n + z <= m + z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_9867","instance":9867,"id":179866,"goal":"lemma Abs_Nonneg_9867(k: real)\n ensures (if k >= 0 then k else -k) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_9868","instance":9868,"id":179867,"goal":"lemma DivMod_9868(n: int, k: int)\n requires k > 0\n ensures n == k * (n / k) + (n % k)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_9869","instance":9869,"id":179868,"goal":"lemma ModBounds_9869(b: nat, x: nat)\n requires x > 0\n ensures 0 <= b % x < x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_9870","instance":9870,"id":179869,"goal":"lemma Square_Nonneg_9870(x: real)\n ensures x * x >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_9871","instance":9871,"id":179870,"goal":"lemma AddComm_9871(x: int, n: int)\n ensures x + n == n + x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_9872","instance":9872,"id":179871,"goal":"lemma AddAssoc_9872(z: nat, c: nat, k: nat)\n ensures (z + c) + k == z + (c + k)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_9873","instance":9873,"id":179872,"goal":"lemma MulComm_9873(c: real, j: real)\n ensures c * j == j * c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_9874","instance":9874,"id":179873,"goal":"lemma MulAssoc_9874(b: int, y: int, n: int)\n ensures (b * y) * n == b * (y * n)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_9875","instance":9875,"id":179874,"goal":"lemma Distrib_9875(n: nat, y: nat, x: nat)\n ensures n * (y + x) == n * y + n * x\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_9876","instance":9876,"id":179875,"goal":"lemma AddZero_9876(k: real)\n ensures k + 0 == k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_9877","instance":9877,"id":179876,"goal":"lemma MulOne_9877(k: int)\n ensures k * 1 == k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_9878","instance":9878,"id":179877,"goal":"lemma MulZero_9878(d: nat)\n ensures d * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_9879","instance":9879,"id":179878,"goal":"lemma LeRefl_9879(m: real)\n ensures m <= m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_9880","instance":9880,"id":179879,"goal":"lemma LeTrans_9880(z: int, j: int, n: int)\n requires z <= j && j <= n\n ensures z <= n\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_9881","instance":9881,"id":179880,"goal":"lemma AddMono_9881(b: nat, n: nat, k: nat)\n requires b <= n\n ensures b + k <= n + k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_9882","instance":9882,"id":179881,"goal":"lemma Abs_Nonneg_9882(c: real)\n ensures (if c >= 0 then c else -c) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_9883","instance":9883,"id":179882,"goal":"lemma DivMod_9883(y: int, k: int)\n requires k > 0\n ensures y == k * (y / k) + (y % k)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_9884","instance":9884,"id":179883,"goal":"lemma ModBounds_9884(j: nat, m: nat)\n requires m > 0\n ensures 0 <= j % m < m\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_9885","instance":9885,"id":179884,"goal":"lemma Square_Nonneg_9885(i: real)\n ensures i * i >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_9886","instance":9886,"id":179885,"goal":"lemma AddComm_9886(m: int, c: int)\n ensures m + c == c + m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_9887","instance":9887,"id":179886,"goal":"lemma AddAssoc_9887(y: nat, c: nat, i: nat)\n ensures (y + c) + i == y + (c + i)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_9888","instance":9888,"id":179887,"goal":"lemma MulComm_9888(c: real, x: real)\n ensures c * x == x * c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_9889","instance":9889,"id":179888,"goal":"lemma MulAssoc_9889(j: int, b: int, x: int)\n ensures (j * b) * x == j * (b * x)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_9890","instance":9890,"id":179889,"goal":"lemma Distrib_9890(y: nat, k: nat, b: nat)\n ensures y * (k + b) == y * k + y * b\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_9891","instance":9891,"id":179890,"goal":"lemma AddZero_9891(b: real)\n ensures b + 0 == b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_9892","instance":9892,"id":179891,"goal":"lemma MulOne_9892(k: int)\n ensures k * 1 == k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_9893","instance":9893,"id":179892,"goal":"lemma MulZero_9893(b: nat)\n ensures b * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_9894","instance":9894,"id":179893,"goal":"lemma LeRefl_9894(j: real)\n ensures j <= j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_9895","instance":9895,"id":179894,"goal":"lemma LeTrans_9895(d: int, z: int, a: int)\n requires d <= z && z <= a\n ensures d <= a\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_9896","instance":9896,"id":179895,"goal":"lemma AddMono_9896(m: nat, a: nat, b: nat)\n requires m <= a\n ensures m + b <= a + b\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_9897","instance":9897,"id":179896,"goal":"lemma Abs_Nonneg_9897(i: real)\n ensures (if i >= 0 then i else -i) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_9898","instance":9898,"id":179897,"goal":"lemma DivMod_9898(x: int, c: int)\n requires c > 0\n ensures x == c * (x / c) + (x % c)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_9899","instance":9899,"id":179898,"goal":"lemma ModBounds_9899(b: nat, i: nat)\n requires i > 0\n ensures 0 <= b % i < i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_9900","instance":9900,"id":179899,"goal":"lemma Square_Nonneg_9900(j: real)\n ensures j * j >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_9901","instance":9901,"id":179900,"goal":"lemma AddComm_9901(i: int, a: int)\n ensures i + a == a + i\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_9902","instance":9902,"id":179901,"goal":"lemma AddAssoc_9902(j: nat, n: nat, k: nat)\n ensures (j + n) + k == j + (n + k)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_9903","instance":9903,"id":179902,"goal":"lemma MulComm_9903(j: real, d: real)\n ensures j * d == d * j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_9904","instance":9904,"id":179903,"goal":"lemma MulAssoc_9904(c: int, b: int, n: int)\n ensures (c * b) * n == c * (b * n)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_9905","instance":9905,"id":179904,"goal":"lemma Distrib_9905(a: nat, m: nat, b: nat)\n ensures a * (m + b) == a * m + a * b\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_9906","instance":9906,"id":179905,"goal":"lemma AddZero_9906(c: real)\n ensures c + 0 == c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_9907","instance":9907,"id":179906,"goal":"lemma MulOne_9907(z: int)\n ensures z * 1 == z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_9908","instance":9908,"id":179907,"goal":"lemma MulZero_9908(x: nat)\n ensures x * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_9909","instance":9909,"id":179908,"goal":"lemma LeRefl_9909(k: real)\n ensures k <= k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_9910","instance":9910,"id":179909,"goal":"lemma LeTrans_9910(n: int, b: int, c: int)\n requires n <= b && b <= c\n ensures n <= c\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_9911","instance":9911,"id":179910,"goal":"lemma AddMono_9911(y: nat, a: nat, i: nat)\n requires y <= a\n ensures y + i <= a + i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_9912","instance":9912,"id":179911,"goal":"lemma Abs_Nonneg_9912(z: real)\n ensures (if z >= 0 then z else -z) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_9913","instance":9913,"id":179912,"goal":"lemma DivMod_9913(x: int, z: int)\n requires z > 0\n ensures x == z * (x / z) + (x % z)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_9914","instance":9914,"id":179913,"goal":"lemma ModBounds_9914(m: nat, b: nat)\n requires b > 0\n ensures 0 <= m % b < b\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_9915","instance":9915,"id":179914,"goal":"lemma Square_Nonneg_9915(y: real)\n ensures y * y >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_9916","instance":9916,"id":179915,"goal":"lemma AddComm_9916(y: int, a: int)\n ensures y + a == a + y\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_9917","instance":9917,"id":179916,"goal":"lemma AddAssoc_9917(i: nat, n: nat, y: nat)\n ensures (i + n) + y == i + (n + y)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_9918","instance":9918,"id":179917,"goal":"lemma MulComm_9918(j: real, i: real)\n ensures j * i == i * j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_9919","instance":9919,"id":179918,"goal":"lemma MulAssoc_9919(j: int, m: int, x: int)\n ensures (j * m) * x == j * (m * x)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_9920","instance":9920,"id":179919,"goal":"lemma Distrib_9920(y: nat, k: nat, i: nat)\n ensures y * (k + i) == y * k + y * i\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_9921","instance":9921,"id":179920,"goal":"lemma AddZero_9921(k: real)\n ensures k + 0 == k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_9922","instance":9922,"id":179921,"goal":"lemma MulOne_9922(b: int)\n ensures b * 1 == b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_9923","instance":9923,"id":179922,"goal":"lemma MulZero_9923(a: nat)\n ensures a * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_9924","instance":9924,"id":179923,"goal":"lemma LeRefl_9924(i: real)\n ensures i <= i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_9925","instance":9925,"id":179924,"goal":"lemma LeTrans_9925(i: int, c: int, m: int)\n requires i <= c && c <= m\n ensures i <= m\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_9926","instance":9926,"id":179925,"goal":"lemma AddMono_9926(d: nat, x: nat, i: nat)\n requires d <= x\n ensures d + i <= x + i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_9927","instance":9927,"id":179926,"goal":"lemma Abs_Nonneg_9927(i: real)\n ensures (if i >= 0 then i else -i) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_9928","instance":9928,"id":179927,"goal":"lemma DivMod_9928(b: int, j: int)\n requires j > 0\n ensures b == j * (b / j) + (b % j)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_9929","instance":9929,"id":179928,"goal":"lemma ModBounds_9929(d: nat, j: nat)\n requires j > 0\n ensures 0 <= d % j < j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_9930","instance":9930,"id":179929,"goal":"lemma Square_Nonneg_9930(n: real)\n ensures n * n >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_9931","instance":9931,"id":179930,"goal":"lemma AddComm_9931(n: int, i: int)\n ensures n + i == i + n\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_9932","instance":9932,"id":179931,"goal":"lemma AddAssoc_9932(i: nat, k: nat, n: nat)\n ensures (i + k) + n == i + (k + n)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_9933","instance":9933,"id":179932,"goal":"lemma MulComm_9933(x: real, k: real)\n ensures x * k == k * x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_9934","instance":9934,"id":179933,"goal":"lemma MulAssoc_9934(n: int, d: int, m: int)\n ensures (n * d) * m == n * (d * m)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_9935","instance":9935,"id":179934,"goal":"lemma Distrib_9935(c: nat, k: nat, z: nat)\n ensures c * (k + z) == c * k + c * z\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_9936","instance":9936,"id":179935,"goal":"lemma AddZero_9936(i: real)\n ensures i + 0 == i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_9937","instance":9937,"id":179936,"goal":"lemma MulOne_9937(i: int)\n ensures i * 1 == i\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_9938","instance":9938,"id":179937,"goal":"lemma MulZero_9938(z: nat)\n ensures z * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_9939","instance":9939,"id":179938,"goal":"lemma LeRefl_9939(c: real)\n ensures c <= c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_9940","instance":9940,"id":179939,"goal":"lemma LeTrans_9940(k: int, d: int, i: int)\n requires k <= d && d <= i\n ensures k <= i\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_9941","instance":9941,"id":179940,"goal":"lemma AddMono_9941(y: nat, b: nat, x: nat)\n requires y <= b\n ensures y + x <= b + x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_9942","instance":9942,"id":179941,"goal":"lemma Abs_Nonneg_9942(i: real)\n ensures (if i >= 0 then i else -i) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_9943","instance":9943,"id":179942,"goal":"lemma DivMod_9943(d: int, c: int)\n requires c > 0\n ensures d == c * (d / c) + (d % c)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_9944","instance":9944,"id":179943,"goal":"lemma ModBounds_9944(y: nat, c: nat)\n requires c > 0\n ensures 0 <= y % c < c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_9945","instance":9945,"id":179944,"goal":"lemma Square_Nonneg_9945(i: real)\n ensures i * i >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_9946","instance":9946,"id":179945,"goal":"lemma AddComm_9946(a: int, c: int)\n ensures a + c == c + a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_9947","instance":9947,"id":179946,"goal":"lemma AddAssoc_9947(k: nat, n: nat, i: nat)\n ensures (k + n) + i == k + (n + i)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_9948","instance":9948,"id":179947,"goal":"lemma MulComm_9948(m: real, b: real)\n ensures m * b == b * m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_9949","instance":9949,"id":179948,"goal":"lemma MulAssoc_9949(i: int, b: int, d: int)\n ensures (i * b) * d == i * (b * d)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_9950","instance":9950,"id":179949,"goal":"lemma Distrib_9950(n: nat, z: nat, m: nat)\n ensures n * (z + m) == n * z + n * m\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_9951","instance":9951,"id":179950,"goal":"lemma AddZero_9951(m: real)\n ensures m + 0 == m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_9952","instance":9952,"id":179951,"goal":"lemma MulOne_9952(m: int)\n ensures m * 1 == m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_9953","instance":9953,"id":179952,"goal":"lemma MulZero_9953(i: nat)\n ensures i * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_9954","instance":9954,"id":179953,"goal":"lemma LeRefl_9954(k: real)\n ensures k <= k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_9955","instance":9955,"id":179954,"goal":"lemma LeTrans_9955(j: int, d: int, z: int)\n requires j <= d && d <= z\n ensures j <= z\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_9956","instance":9956,"id":179955,"goal":"lemma AddMono_9956(n: nat, k: nat, y: nat)\n requires n <= k\n ensures n + y <= k + y\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_9957","instance":9957,"id":179956,"goal":"lemma Abs_Nonneg_9957(x: real)\n ensures (if x >= 0 then x else -x) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_9958","instance":9958,"id":179957,"goal":"lemma DivMod_9958(c: int, b: int)\n requires b > 0\n ensures c == b * (c / b) + (c % b)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_9959","instance":9959,"id":179958,"goal":"lemma ModBounds_9959(i: nat, k: nat)\n requires k > 0\n ensures 0 <= i % k < k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_9960","instance":9960,"id":179959,"goal":"lemma Square_Nonneg_9960(z: real)\n ensures z * z >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_9961","instance":9961,"id":179960,"goal":"lemma AddComm_9961(i: int, c: int)\n ensures i + c == c + i\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_9962","instance":9962,"id":179961,"goal":"lemma AddAssoc_9962(c: nat, j: nat, m: nat)\n ensures (c + j) + m == c + (j + m)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_9963","instance":9963,"id":179962,"goal":"lemma MulComm_9963(x: real, d: real)\n ensures x * d == d * x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_9964","instance":9964,"id":179963,"goal":"lemma MulAssoc_9964(a: int, m: int, j: int)\n ensures (a * m) * j == a * (m * j)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_9965","instance":9965,"id":179964,"goal":"lemma Distrib_9965(y: nat, b: nat, k: nat)\n ensures y * (b + k) == y * b + y * k\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_9966","instance":9966,"id":179965,"goal":"lemma AddZero_9966(n: real)\n ensures n + 0 == n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_9967","instance":9967,"id":179966,"goal":"lemma MulOne_9967(k: int)\n ensures k * 1 == k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_9968","instance":9968,"id":179967,"goal":"lemma MulZero_9968(a: nat)\n ensures a * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_9969","instance":9969,"id":179968,"goal":"lemma LeRefl_9969(i: real)\n ensures i <= i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_9970","instance":9970,"id":179969,"goal":"lemma LeTrans_9970(z: int, y: int, d: int)\n requires z <= y && y <= d\n ensures z <= d\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_9971","instance":9971,"id":179970,"goal":"lemma AddMono_9971(j: nat, c: nat, a: nat)\n requires j <= c\n ensures j + a <= c + a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_9972","instance":9972,"id":179971,"goal":"lemma Abs_Nonneg_9972(j: real)\n ensures (if j >= 0 then j else -j) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_9973","instance":9973,"id":179972,"goal":"lemma DivMod_9973(b: int, c: int)\n requires c > 0\n ensures b == c * (b / c) + (b % c)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_9974","instance":9974,"id":179973,"goal":"lemma ModBounds_9974(z: nat, k: nat)\n requires k > 0\n ensures 0 <= z % k < k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_9975","instance":9975,"id":179974,"goal":"lemma Square_Nonneg_9975(i: real)\n ensures i * i >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_9976","instance":9976,"id":179975,"goal":"lemma AddComm_9976(d: int, x: int)\n ensures d + x == x + d\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_9977","instance":9977,"id":179976,"goal":"lemma AddAssoc_9977(d: nat, c: nat, y: nat)\n ensures (d + c) + y == d + (c + y)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_9978","instance":9978,"id":179977,"goal":"lemma MulComm_9978(z: real, i: real)\n ensures z * i == i * z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_9979","instance":9979,"id":179978,"goal":"lemma MulAssoc_9979(y: int, z: int, a: int)\n ensures (y * z) * a == y * (z * a)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_9980","instance":9980,"id":179979,"goal":"lemma Distrib_9980(j: nat, k: nat, m: nat)\n ensures j * (k + m) == j * k + j * m\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_9981","instance":9981,"id":179980,"goal":"lemma AddZero_9981(y: real)\n ensures y + 0 == y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_9982","instance":9982,"id":179981,"goal":"lemma MulOne_9982(a: int)\n ensures a * 1 == a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_9983","instance":9983,"id":179982,"goal":"lemma MulZero_9983(d: nat)\n ensures d * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_9984","instance":9984,"id":179983,"goal":"lemma LeRefl_9984(i: real)\n ensures i <= i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_9985","instance":9985,"id":179984,"goal":"lemma LeTrans_9985(m: int, b: int, a: int)\n requires m <= b && b <= a\n ensures m <= a\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_9986","instance":9986,"id":179985,"goal":"lemma AddMono_9986(b: nat, z: nat, a: nat)\n requires b <= z\n ensures b + a <= z + a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_9987","instance":9987,"id":179986,"goal":"lemma Abs_Nonneg_9987(a: real)\n ensures (if a >= 0 then a else -a) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_9988","instance":9988,"id":179987,"goal":"lemma DivMod_9988(x: int, n: int)\n requires n > 0\n ensures x == n * (x / n) + (x % n)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_9989","instance":9989,"id":179988,"goal":"lemma ModBounds_9989(k: nat, c: nat)\n requires c > 0\n ensures 0 <= k % c < c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_9990","instance":9990,"id":179989,"goal":"lemma Square_Nonneg_9990(a: real)\n ensures a * a >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_9991","instance":9991,"id":179990,"goal":"lemma AddComm_9991(n: int, x: int)\n ensures n + x == x + n\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_9992","instance":9992,"id":179991,"goal":"lemma AddAssoc_9992(z: nat, n: nat, c: nat)\n ensures (z + n) + c == z + (n + c)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_9993","instance":9993,"id":179992,"goal":"lemma MulComm_9993(b: real, i: real)\n ensures b * i == i * b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_9994","instance":9994,"id":179993,"goal":"lemma MulAssoc_9994(i: int, d: int, a: int)\n ensures (i * d) * a == i * (d * a)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_9995","instance":9995,"id":179994,"goal":"lemma Distrib_9995(m: nat, c: nat, j: nat)\n ensures m * (c + j) == m * c + m * j\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_9996","instance":9996,"id":179995,"goal":"lemma AddZero_9996(b: real)\n ensures b + 0 == b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_9997","instance":9997,"id":179996,"goal":"lemma MulOne_9997(a: int)\n ensures a * 1 == a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_9998","instance":9998,"id":179997,"goal":"lemma MulZero_9998(y: nat)\n ensures y * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_9999","instance":9999,"id":179998,"goal":"lemma LeRefl_9999(c: real)\n ensures c <= c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_10000","instance":10000,"id":179999,"goal":"lemma LeTrans_10000(z: int, i: int, b: int)\n requires z <= i && i <= b\n ensures z <= b\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_10001","instance":10001,"id":180000,"goal":"lemma AddMono_10001(k: nat, a: nat, i: nat)\n requires k <= a\n ensures k + i <= a + i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_10002","instance":10002,"id":180001,"goal":"lemma Abs_Nonneg_10002(d: real)\n ensures (if d >= 0 then d else -d) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_10003","instance":10003,"id":180002,"goal":"lemma DivMod_10003(x: int, d: int)\n requires d > 0\n ensures x == d * (x / d) + (x % d)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_10004","instance":10004,"id":180003,"goal":"lemma ModBounds_10004(n: nat, z: nat)\n requires z > 0\n ensures 0 <= n % z < z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_10005","instance":10005,"id":180004,"goal":"lemma Square_Nonneg_10005(c: real)\n ensures c * c >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_10006","instance":10006,"id":180005,"goal":"lemma AddComm_10006(c: int, x: int)\n ensures c + x == x + c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_10007","instance":10007,"id":180006,"goal":"lemma AddAssoc_10007(z: nat, b: nat, j: nat)\n ensures (z + b) + j == z + (b + j)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_10008","instance":10008,"id":180007,"goal":"lemma MulComm_10008(n: real, b: real)\n ensures n * b == b * n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_10009","instance":10009,"id":180008,"goal":"lemma MulAssoc_10009(n: int, d: int, x: int)\n ensures (n * d) * x == n * (d * x)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_10010","instance":10010,"id":180009,"goal":"lemma Distrib_10010(n: nat, j: nat, x: nat)\n ensures n * (j + x) == n * j + n * x\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_10011","instance":10011,"id":180010,"goal":"lemma AddZero_10011(b: real)\n ensures b + 0 == b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_10012","instance":10012,"id":180011,"goal":"lemma MulOne_10012(b: int)\n ensures b * 1 == b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_10013","instance":10013,"id":180012,"goal":"lemma MulZero_10013(n: nat)\n ensures n * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_10014","instance":10014,"id":180013,"goal":"lemma LeRefl_10014(z: real)\n ensures z <= z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_10015","instance":10015,"id":180014,"goal":"lemma LeTrans_10015(j: int, b: int, c: int)\n requires j <= b && b <= c\n ensures j <= c\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_10016","instance":10016,"id":180015,"goal":"lemma AddMono_10016(y: nat, b: nat, n: nat)\n requires y <= b\n ensures y + n <= b + n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_10017","instance":10017,"id":180016,"goal":"lemma Abs_Nonneg_10017(i: real)\n ensures (if i >= 0 then i else -i) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_10018","instance":10018,"id":180017,"goal":"lemma DivMod_10018(a: int, c: int)\n requires c > 0\n ensures a == c * (a / c) + (a % c)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_10019","instance":10019,"id":180018,"goal":"lemma ModBounds_10019(m: nat, z: nat)\n requires z > 0\n ensures 0 <= m % z < z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_10020","instance":10020,"id":180019,"goal":"lemma Square_Nonneg_10020(i: real)\n ensures i * i >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_10021","instance":10021,"id":180020,"goal":"lemma AddComm_10021(z: int, k: int)\n ensures z + k == k + z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_10022","instance":10022,"id":180021,"goal":"lemma AddAssoc_10022(j: nat, x: nat, n: nat)\n ensures (j + x) + n == j + (x + n)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_10023","instance":10023,"id":180022,"goal":"lemma MulComm_10023(a: real, d: real)\n ensures a * d == d * a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_10024","instance":10024,"id":180023,"goal":"lemma MulAssoc_10024(n: int, a: int, i: int)\n ensures (n * a) * i == n * (a * i)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_10025","instance":10025,"id":180024,"goal":"lemma Distrib_10025(i: nat, z: nat, c: nat)\n ensures i * (z + c) == i * z + i * c\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_10026","instance":10026,"id":180025,"goal":"lemma AddZero_10026(i: real)\n ensures i + 0 == i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_10027","instance":10027,"id":180026,"goal":"lemma MulOne_10027(a: int)\n ensures a * 1 == a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_10028","instance":10028,"id":180027,"goal":"lemma MulZero_10028(j: nat)\n ensures j * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_10029","instance":10029,"id":180028,"goal":"lemma LeRefl_10029(x: real)\n ensures x <= x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_10030","instance":10030,"id":180029,"goal":"lemma LeTrans_10030(c: int, j: int, n: int)\n requires c <= j && j <= n\n ensures c <= n\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_10031","instance":10031,"id":180030,"goal":"lemma AddMono_10031(b: nat, n: nat, i: nat)\n requires b <= n\n ensures b + i <= n + i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_10032","instance":10032,"id":180031,"goal":"lemma Abs_Nonneg_10032(n: real)\n ensures (if n >= 0 then n else -n) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_10033","instance":10033,"id":180032,"goal":"lemma DivMod_10033(d: int, x: int)\n requires x > 0\n ensures d == x * (d / x) + (d % x)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_10034","instance":10034,"id":180033,"goal":"lemma ModBounds_10034(k: nat, m: nat)\n requires m > 0\n ensures 0 <= k % m < m\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_10035","instance":10035,"id":180034,"goal":"lemma Square_Nonneg_10035(i: real)\n ensures i * i >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_10036","instance":10036,"id":180035,"goal":"lemma AddComm_10036(d: int, b: int)\n ensures d + b == b + d\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_10037","instance":10037,"id":180036,"goal":"lemma AddAssoc_10037(a: nat, j: nat, b: nat)\n ensures (a + j) + b == a + (j + b)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_10038","instance":10038,"id":180037,"goal":"lemma MulComm_10038(m: real, y: real)\n ensures m * y == y * m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_10039","instance":10039,"id":180038,"goal":"lemma MulAssoc_10039(d: int, z: int, a: int)\n ensures (d * z) * a == d * (z * a)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_10040","instance":10040,"id":180039,"goal":"lemma Distrib_10040(x: nat, z: nat, j: nat)\n ensures x * (z + j) == x * z + x * j\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_10041","instance":10041,"id":180040,"goal":"lemma AddZero_10041(j: real)\n ensures j + 0 == j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_10042","instance":10042,"id":180041,"goal":"lemma MulOne_10042(a: int)\n ensures a * 1 == a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_10043","instance":10043,"id":180042,"goal":"lemma MulZero_10043(i: nat)\n ensures i * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_10044","instance":10044,"id":180043,"goal":"lemma LeRefl_10044(c: real)\n ensures c <= c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_10045","instance":10045,"id":180044,"goal":"lemma LeTrans_10045(n: int, d: int, a: int)\n requires n <= d && d <= a\n ensures n <= a\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_10046","instance":10046,"id":180045,"goal":"lemma AddMono_10046(c: nat, z: nat, a: nat)\n requires c <= z\n ensures c + a <= z + a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_10047","instance":10047,"id":180046,"goal":"lemma Abs_Nonneg_10047(m: real)\n ensures (if m >= 0 then m else -m) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_10048","instance":10048,"id":180047,"goal":"lemma DivMod_10048(k: int, c: int)\n requires c > 0\n ensures k == c * (k / c) + (k % c)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_10049","instance":10049,"id":180048,"goal":"lemma ModBounds_10049(z: nat, y: nat)\n requires y > 0\n ensures 0 <= z % y < y\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_10050","instance":10050,"id":180049,"goal":"lemma Square_Nonneg_10050(k: real)\n ensures k * k >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_10051","instance":10051,"id":180050,"goal":"lemma AddComm_10051(k: int, c: int)\n ensures k + c == c + k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_10052","instance":10052,"id":180051,"goal":"lemma AddAssoc_10052(y: nat, a: nat, j: nat)\n ensures (y + a) + j == y + (a + j)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_10053","instance":10053,"id":180052,"goal":"lemma MulComm_10053(i: real, d: real)\n ensures i * d == d * i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_10054","instance":10054,"id":180053,"goal":"lemma MulAssoc_10054(d: int, n: int, k: int)\n ensures (d * n) * k == d * (n * k)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_10055","instance":10055,"id":180054,"goal":"lemma Distrib_10055(a: nat, m: nat, c: nat)\n ensures a * (m + c) == a * m + a * c\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_10056","instance":10056,"id":180055,"goal":"lemma AddZero_10056(b: real)\n ensures b + 0 == b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_10057","instance":10057,"id":180056,"goal":"lemma MulOne_10057(b: int)\n ensures b * 1 == b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_10058","instance":10058,"id":180057,"goal":"lemma MulZero_10058(y: nat)\n ensures y * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_10059","instance":10059,"id":180058,"goal":"lemma LeRefl_10059(m: real)\n ensures m <= m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_10060","instance":10060,"id":180059,"goal":"lemma LeTrans_10060(i: int, y: int, k: int)\n requires i <= y && y <= k\n ensures i <= k\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_10061","instance":10061,"id":180060,"goal":"lemma AddMono_10061(d: nat, y: nat, n: nat)\n requires d <= y\n ensures d + n <= y + n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_10062","instance":10062,"id":180061,"goal":"lemma Abs_Nonneg_10062(z: real)\n ensures (if z >= 0 then z else -z) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_10063","instance":10063,"id":180062,"goal":"lemma DivMod_10063(z: int, j: int)\n requires j > 0\n ensures z == j * (z / j) + (z % j)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_10064","instance":10064,"id":180063,"goal":"lemma ModBounds_10064(c: nat, d: nat)\n requires d > 0\n ensures 0 <= c % d < d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_10065","instance":10065,"id":180064,"goal":"lemma Square_Nonneg_10065(b: real)\n ensures b * b >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_10066","instance":10066,"id":180065,"goal":"lemma AddComm_10066(x: int, j: int)\n ensures x + j == j + x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_10067","instance":10067,"id":180066,"goal":"lemma AddAssoc_10067(x: nat, k: nat, a: nat)\n ensures (x + k) + a == x + (k + a)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_10068","instance":10068,"id":180067,"goal":"lemma MulComm_10068(i: real, a: real)\n ensures i * a == a * i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_10069","instance":10069,"id":180068,"goal":"lemma MulAssoc_10069(c: int, a: int, j: int)\n ensures (c * a) * j == c * (a * j)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_10070","instance":10070,"id":180069,"goal":"lemma Distrib_10070(x: nat, y: nat, z: nat)\n ensures x * (y + z) == x * y + x * z\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_10071","instance":10071,"id":180070,"goal":"lemma AddZero_10071(j: real)\n ensures j + 0 == j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_10072","instance":10072,"id":180071,"goal":"lemma MulOne_10072(j: int)\n ensures j * 1 == j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_10073","instance":10073,"id":180072,"goal":"lemma MulZero_10073(m: nat)\n ensures m * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_10074","instance":10074,"id":180073,"goal":"lemma LeRefl_10074(x: real)\n ensures x <= x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_10075","instance":10075,"id":180074,"goal":"lemma LeTrans_10075(k: int, d: int, c: int)\n requires k <= d && d <= c\n ensures k <= c\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_10076","instance":10076,"id":180075,"goal":"lemma AddMono_10076(y: nat, i: nat, a: nat)\n requires y <= i\n ensures y + a <= i + a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_10077","instance":10077,"id":180076,"goal":"lemma Abs_Nonneg_10077(d: real)\n ensures (if d >= 0 then d else -d) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_10078","instance":10078,"id":180077,"goal":"lemma DivMod_10078(n: int, i: int)\n requires i > 0\n ensures n == i * (n / i) + (n % i)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_10079","instance":10079,"id":180078,"goal":"lemma ModBounds_10079(j: nat, m: nat)\n requires m > 0\n ensures 0 <= j % m < m\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_10080","instance":10080,"id":180079,"goal":"lemma Square_Nonneg_10080(n: real)\n ensures n * n >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_10081","instance":10081,"id":180080,"goal":"lemma AddComm_10081(n: int, b: int)\n ensures n + b == b + n\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_10082","instance":10082,"id":180081,"goal":"lemma AddAssoc_10082(n: nat, x: nat, y: nat)\n ensures (n + x) + y == n + (x + y)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_10083","instance":10083,"id":180082,"goal":"lemma MulComm_10083(m: real, z: real)\n ensures m * z == z * m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_10084","instance":10084,"id":180083,"goal":"lemma MulAssoc_10084(b: int, c: int, j: int)\n ensures (b * c) * j == b * (c * j)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_10085","instance":10085,"id":180084,"goal":"lemma Distrib_10085(y: nat, k: nat, b: nat)\n ensures y * (k + b) == y * k + y * b\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_10086","instance":10086,"id":180085,"goal":"lemma AddZero_10086(x: real)\n ensures x + 0 == x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_10087","instance":10087,"id":180086,"goal":"lemma MulOne_10087(x: int)\n ensures x * 1 == x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_10088","instance":10088,"id":180087,"goal":"lemma MulZero_10088(y: nat)\n ensures y * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_10089","instance":10089,"id":180088,"goal":"lemma LeRefl_10089(d: real)\n ensures d <= d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_10090","instance":10090,"id":180089,"goal":"lemma LeTrans_10090(j: int, n: int, i: int)\n requires j <= n && n <= i\n ensures j <= i\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_10091","instance":10091,"id":180090,"goal":"lemma AddMono_10091(j: nat, d: nat, y: nat)\n requires j <= d\n ensures j + y <= d + y\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_10092","instance":10092,"id":180091,"goal":"lemma Abs_Nonneg_10092(a: real)\n ensures (if a >= 0 then a else -a) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_10093","instance":10093,"id":180092,"goal":"lemma DivMod_10093(n: int, j: int)\n requires j > 0\n ensures n == j * (n / j) + (n % j)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_10094","instance":10094,"id":180093,"goal":"lemma ModBounds_10094(i: nat, z: nat)\n requires z > 0\n ensures 0 <= i % z < z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_10095","instance":10095,"id":180094,"goal":"lemma Square_Nonneg_10095(x: real)\n ensures x * x >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_10096","instance":10096,"id":180095,"goal":"lemma AddComm_10096(d: int, i: int)\n ensures d + i == i + d\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_10097","instance":10097,"id":180096,"goal":"lemma AddAssoc_10097(i: nat, b: nat, z: nat)\n ensures (i + b) + z == i + (b + z)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_10098","instance":10098,"id":180097,"goal":"lemma MulComm_10098(m: real, x: real)\n ensures m * x == x * m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_10099","instance":10099,"id":180098,"goal":"lemma MulAssoc_10099(x: int, b: int, j: int)\n ensures (x * b) * j == x * (b * j)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_10100","instance":10100,"id":180099,"goal":"lemma Distrib_10100(y: nat, b: nat, z: nat)\n ensures y * (b + z) == y * b + y * z\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_10101","instance":10101,"id":180100,"goal":"lemma AddZero_10101(m: real)\n ensures m + 0 == m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_10102","instance":10102,"id":180101,"goal":"lemma MulOne_10102(c: int)\n ensures c * 1 == c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_10103","instance":10103,"id":180102,"goal":"lemma MulZero_10103(j: nat)\n ensures j * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_10104","instance":10104,"id":180103,"goal":"lemma LeRefl_10104(n: real)\n ensures n <= n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_10105","instance":10105,"id":180104,"goal":"lemma LeTrans_10105(k: int, y: int, z: int)\n requires k <= y && y <= z\n ensures k <= z\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_10106","instance":10106,"id":180105,"goal":"lemma AddMono_10106(b: nat, m: nat, n: nat)\n requires b <= m\n ensures b + n <= m + n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_10107","instance":10107,"id":180106,"goal":"lemma Abs_Nonneg_10107(n: real)\n ensures (if n >= 0 then n else -n) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_10108","instance":10108,"id":180107,"goal":"lemma DivMod_10108(m: int, a: int)\n requires a > 0\n ensures m == a * (m / a) + (m % a)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_10109","instance":10109,"id":180108,"goal":"lemma ModBounds_10109(m: nat, k: nat)\n requires k > 0\n ensures 0 <= m % k < k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_10110","instance":10110,"id":180109,"goal":"lemma Square_Nonneg_10110(c: real)\n ensures c * c >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_10111","instance":10111,"id":180110,"goal":"lemma AddComm_10111(n: int, b: int)\n ensures n + b == b + n\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_10112","instance":10112,"id":180111,"goal":"lemma AddAssoc_10112(m: nat, c: nat, z: nat)\n ensures (m + c) + z == m + (c + z)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_10113","instance":10113,"id":180112,"goal":"lemma MulComm_10113(z: real, c: real)\n ensures z * c == c * z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_10114","instance":10114,"id":180113,"goal":"lemma MulAssoc_10114(n: int, c: int, k: int)\n ensures (n * c) * k == n * (c * k)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_10115","instance":10115,"id":180114,"goal":"lemma Distrib_10115(d: nat, i: nat, k: nat)\n ensures d * (i + k) == d * i + d * k\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_10116","instance":10116,"id":180115,"goal":"lemma AddZero_10116(a: real)\n ensures a + 0 == a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_10117","instance":10117,"id":180116,"goal":"lemma MulOne_10117(k: int)\n ensures k * 1 == k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_10118","instance":10118,"id":180117,"goal":"lemma MulZero_10118(j: nat)\n ensures j * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_10119","instance":10119,"id":180118,"goal":"lemma LeRefl_10119(b: real)\n ensures b <= b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_10120","instance":10120,"id":180119,"goal":"lemma LeTrans_10120(i: int, z: int, x: int)\n requires i <= z && z <= x\n ensures i <= x\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_10121","instance":10121,"id":180120,"goal":"lemma AddMono_10121(y: nat, d: nat, j: nat)\n requires y <= d\n ensures y + j <= d + j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_10122","instance":10122,"id":180121,"goal":"lemma Abs_Nonneg_10122(a: real)\n ensures (if a >= 0 then a else -a) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_10123","instance":10123,"id":180122,"goal":"lemma DivMod_10123(m: int, i: int)\n requires i > 0\n ensures m == i * (m / i) + (m % i)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_10124","instance":10124,"id":180123,"goal":"lemma ModBounds_10124(x: nat, m: nat)\n requires m > 0\n ensures 0 <= x % m < m\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_10125","instance":10125,"id":180124,"goal":"lemma Square_Nonneg_10125(i: real)\n ensures i * i >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_10126","instance":10126,"id":180125,"goal":"lemma AddComm_10126(b: int, m: int)\n ensures b + m == m + b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_10127","instance":10127,"id":180126,"goal":"lemma AddAssoc_10127(b: nat, x: nat, m: nat)\n ensures (b + x) + m == b + (x + m)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_10128","instance":10128,"id":180127,"goal":"lemma MulComm_10128(d: real, k: real)\n ensures d * k == k * d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_10129","instance":10129,"id":180128,"goal":"lemma MulAssoc_10129(i: int, z: int, a: int)\n ensures (i * z) * a == i * (z * a)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_10130","instance":10130,"id":180129,"goal":"lemma Distrib_10130(d: nat, i: nat, n: nat)\n ensures d * (i + n) == d * i + d * n\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_10131","instance":10131,"id":180130,"goal":"lemma AddZero_10131(y: real)\n ensures y + 0 == y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_10132","instance":10132,"id":180131,"goal":"lemma MulOne_10132(n: int)\n ensures n * 1 == n\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_10133","instance":10133,"id":180132,"goal":"lemma MulZero_10133(k: nat)\n ensures k * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_10134","instance":10134,"id":180133,"goal":"lemma LeRefl_10134(x: real)\n ensures x <= x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_10135","instance":10135,"id":180134,"goal":"lemma LeTrans_10135(d: int, i: int, n: int)\n requires d <= i && i <= n\n ensures d <= n\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_10136","instance":10136,"id":180135,"goal":"lemma AddMono_10136(c: nat, k: nat, m: nat)\n requires c <= k\n ensures c + m <= k + m\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_10137","instance":10137,"id":180136,"goal":"lemma Abs_Nonneg_10137(x: real)\n ensures (if x >= 0 then x else -x) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_10138","instance":10138,"id":180137,"goal":"lemma DivMod_10138(c: int, x: int)\n requires x > 0\n ensures c == x * (c / x) + (c % x)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_10139","instance":10139,"id":180138,"goal":"lemma ModBounds_10139(k: nat, x: nat)\n requires x > 0\n ensures 0 <= k % x < x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_10140","instance":10140,"id":180139,"goal":"lemma Square_Nonneg_10140(z: real)\n ensures z * z >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_10141","instance":10141,"id":180140,"goal":"lemma AddComm_10141(z: int, j: int)\n ensures z + j == j + z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_10142","instance":10142,"id":180141,"goal":"lemma AddAssoc_10142(x: nat, m: nat, i: nat)\n ensures (x + m) + i == x + (m + i)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_10143","instance":10143,"id":180142,"goal":"lemma MulComm_10143(c: real, y: real)\n ensures c * y == y * c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_10144","instance":10144,"id":180143,"goal":"lemma MulAssoc_10144(n: int, m: int, c: int)\n ensures (n * m) * c == n * (m * c)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_10145","instance":10145,"id":180144,"goal":"lemma Distrib_10145(k: nat, c: nat, m: nat)\n ensures k * (c + m) == k * c + k * m\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_10146","instance":10146,"id":180145,"goal":"lemma AddZero_10146(y: real)\n ensures y + 0 == y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_10147","instance":10147,"id":180146,"goal":"lemma MulOne_10147(d: int)\n ensures d * 1 == d\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_10148","instance":10148,"id":180147,"goal":"lemma MulZero_10148(c: nat)\n ensures c * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_10149","instance":10149,"id":180148,"goal":"lemma LeRefl_10149(k: real)\n ensures k <= k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_10150","instance":10150,"id":180149,"goal":"lemma LeTrans_10150(j: int, y: int, a: int)\n requires j <= y && y <= a\n ensures j <= a\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_10151","instance":10151,"id":180150,"goal":"lemma AddMono_10151(x: nat, a: nat, d: nat)\n requires x <= a\n ensures x + d <= a + d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_10152","instance":10152,"id":180151,"goal":"lemma Abs_Nonneg_10152(x: real)\n ensures (if x >= 0 then x else -x) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_10153","instance":10153,"id":180152,"goal":"lemma DivMod_10153(d: int, m: int)\n requires m > 0\n ensures d == m * (d / m) + (d % m)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_10154","instance":10154,"id":180153,"goal":"lemma ModBounds_10154(a: nat, k: nat)\n requires k > 0\n ensures 0 <= a % k < k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_10155","instance":10155,"id":180154,"goal":"lemma Square_Nonneg_10155(y: real)\n ensures y * y >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_10156","instance":10156,"id":180155,"goal":"lemma AddComm_10156(a: int, k: int)\n ensures a + k == k + a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_10157","instance":10157,"id":180156,"goal":"lemma AddAssoc_10157(b: nat, z: nat, n: nat)\n ensures (b + z) + n == b + (z + n)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_10158","instance":10158,"id":180157,"goal":"lemma MulComm_10158(n: real, x: real)\n ensures n * x == x * n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_10159","instance":10159,"id":180158,"goal":"lemma MulAssoc_10159(z: int, i: int, c: int)\n ensures (z * i) * c == z * (i * c)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_10160","instance":10160,"id":180159,"goal":"lemma Distrib_10160(a: nat, m: nat, j: nat)\n ensures a * (m + j) == a * m + a * j\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_10161","instance":10161,"id":180160,"goal":"lemma AddZero_10161(a: real)\n ensures a + 0 == a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_10162","instance":10162,"id":180161,"goal":"lemma MulOne_10162(x: int)\n ensures x * 1 == x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_10163","instance":10163,"id":180162,"goal":"lemma MulZero_10163(c: nat)\n ensures c * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_10164","instance":10164,"id":180163,"goal":"lemma LeRefl_10164(y: real)\n ensures y <= y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_10165","instance":10165,"id":180164,"goal":"lemma LeTrans_10165(d: int, j: int, m: int)\n requires d <= j && j <= m\n ensures d <= m\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_10166","instance":10166,"id":180165,"goal":"lemma AddMono_10166(b: nat, c: nat, x: nat)\n requires b <= c\n ensures b + x <= c + x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_10167","instance":10167,"id":180166,"goal":"lemma Abs_Nonneg_10167(b: real)\n ensures (if b >= 0 then b else -b) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_10168","instance":10168,"id":180167,"goal":"lemma DivMod_10168(k: int, x: int)\n requires x > 0\n ensures k == x * (k / x) + (k % x)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_10169","instance":10169,"id":180168,"goal":"lemma ModBounds_10169(i: nat, n: nat)\n requires n > 0\n ensures 0 <= i % n < n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_10170","instance":10170,"id":180169,"goal":"lemma Square_Nonneg_10170(y: real)\n ensures y * y >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_10171","instance":10171,"id":180170,"goal":"lemma AddComm_10171(c: int, y: int)\n ensures c + y == y + c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_10172","instance":10172,"id":180171,"goal":"lemma AddAssoc_10172(m: nat, b: nat, i: nat)\n ensures (m + b) + i == m + (b + i)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_10173","instance":10173,"id":180172,"goal":"lemma MulComm_10173(d: real, n: real)\n ensures d * n == n * d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_10174","instance":10174,"id":180173,"goal":"lemma MulAssoc_10174(z: int, b: int, a: int)\n ensures (z * b) * a == z * (b * a)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_10175","instance":10175,"id":180174,"goal":"lemma Distrib_10175(c: nat, z: nat, x: nat)\n ensures c * (z + x) == c * z + c * x\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_10176","instance":10176,"id":180175,"goal":"lemma AddZero_10176(d: real)\n ensures d + 0 == d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_10177","instance":10177,"id":180176,"goal":"lemma MulOne_10177(j: int)\n ensures j * 1 == j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_10178","instance":10178,"id":180177,"goal":"lemma MulZero_10178(j: nat)\n ensures j * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_10179","instance":10179,"id":180178,"goal":"lemma LeRefl_10179(k: real)\n ensures k <= k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_10180","instance":10180,"id":180179,"goal":"lemma LeTrans_10180(d: int, j: int, y: int)\n requires d <= j && j <= y\n ensures d <= y\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_10181","instance":10181,"id":180180,"goal":"lemma AddMono_10181(k: nat, i: nat, j: nat)\n requires k <= i\n ensures k + j <= i + j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_10182","instance":10182,"id":180181,"goal":"lemma Abs_Nonneg_10182(d: real)\n ensures (if d >= 0 then d else -d) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_10183","instance":10183,"id":180182,"goal":"lemma DivMod_10183(d: int, x: int)\n requires x > 0\n ensures d == x * (d / x) + (d % x)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_10184","instance":10184,"id":180183,"goal":"lemma ModBounds_10184(n: nat, d: nat)\n requires d > 0\n ensures 0 <= n % d < d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_10185","instance":10185,"id":180184,"goal":"lemma Square_Nonneg_10185(x: real)\n ensures x * x >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_10186","instance":10186,"id":180185,"goal":"lemma AddComm_10186(m: int, x: int)\n ensures m + x == x + m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_10187","instance":10187,"id":180186,"goal":"lemma AddAssoc_10187(y: nat, a: nat, b: nat)\n ensures (y + a) + b == y + (a + b)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_10188","instance":10188,"id":180187,"goal":"lemma MulComm_10188(a: real, x: real)\n ensures a * x == x * a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_10189","instance":10189,"id":180188,"goal":"lemma MulAssoc_10189(b: int, k: int, z: int)\n ensures (b * k) * z == b * (k * z)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_10190","instance":10190,"id":180189,"goal":"lemma Distrib_10190(b: nat, k: nat, a: nat)\n ensures b * (k + a) == b * k + b * a\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_10191","instance":10191,"id":180190,"goal":"lemma AddZero_10191(b: real)\n ensures b + 0 == b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_10192","instance":10192,"id":180191,"goal":"lemma MulOne_10192(i: int)\n ensures i * 1 == i\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_10193","instance":10193,"id":180192,"goal":"lemma MulZero_10193(k: nat)\n ensures k * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_10194","instance":10194,"id":180193,"goal":"lemma LeRefl_10194(i: real)\n ensures i <= i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_10195","instance":10195,"id":180194,"goal":"lemma LeTrans_10195(k: int, j: int, m: int)\n requires k <= j && j <= m\n ensures k <= m\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_10196","instance":10196,"id":180195,"goal":"lemma AddMono_10196(b: nat, j: nat, y: nat)\n requires b <= j\n ensures b + y <= j + y\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_10197","instance":10197,"id":180196,"goal":"lemma Abs_Nonneg_10197(y: real)\n ensures (if y >= 0 then y else -y) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_10198","instance":10198,"id":180197,"goal":"lemma DivMod_10198(a: int, z: int)\n requires z > 0\n ensures a == z * (a / z) + (a % z)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_10199","instance":10199,"id":180198,"goal":"lemma ModBounds_10199(a: nat, m: nat)\n requires m > 0\n ensures 0 <= a % m < m\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_10200","instance":10200,"id":180199,"goal":"lemma Square_Nonneg_10200(b: real)\n ensures b * b >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_10201","instance":10201,"id":180200,"goal":"lemma AddComm_10201(a: int, k: int)\n ensures a + k == k + a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_10202","instance":10202,"id":180201,"goal":"lemma AddAssoc_10202(a: nat, b: nat, j: nat)\n ensures (a + b) + j == a + (b + j)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_10203","instance":10203,"id":180202,"goal":"lemma MulComm_10203(k: real, d: real)\n ensures k * d == d * k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_10204","instance":10204,"id":180203,"goal":"lemma MulAssoc_10204(a: int, n: int, j: int)\n ensures (a * n) * j == a * (n * j)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_10205","instance":10205,"id":180204,"goal":"lemma Distrib_10205(y: nat, m: nat, z: nat)\n ensures y * (m + z) == y * m + y * z\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_10206","instance":10206,"id":180205,"goal":"lemma AddZero_10206(j: real)\n ensures j + 0 == j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_10207","instance":10207,"id":180206,"goal":"lemma MulOne_10207(j: int)\n ensures j * 1 == j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_10208","instance":10208,"id":180207,"goal":"lemma MulZero_10208(a: nat)\n ensures a * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_10209","instance":10209,"id":180208,"goal":"lemma LeRefl_10209(d: real)\n ensures d <= d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_10210","instance":10210,"id":180209,"goal":"lemma LeTrans_10210(k: int, d: int, b: int)\n requires k <= d && d <= b\n ensures k <= b\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_10211","instance":10211,"id":180210,"goal":"lemma AddMono_10211(j: nat, x: nat, z: nat)\n requires j <= x\n ensures j + z <= x + z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_10212","instance":10212,"id":180211,"goal":"lemma Abs_Nonneg_10212(b: real)\n ensures (if b >= 0 then b else -b) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_10213","instance":10213,"id":180212,"goal":"lemma DivMod_10213(b: int, n: int)\n requires n > 0\n ensures b == n * (b / n) + (b % n)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_10214","instance":10214,"id":180213,"goal":"lemma ModBounds_10214(x: nat, y: nat)\n requires y > 0\n ensures 0 <= x % y < y\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_10215","instance":10215,"id":180214,"goal":"lemma Square_Nonneg_10215(j: real)\n ensures j * j >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_10216","instance":10216,"id":180215,"goal":"lemma AddComm_10216(b: int, d: int)\n ensures b + d == d + b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_10217","instance":10217,"id":180216,"goal":"lemma AddAssoc_10217(n: nat, d: nat, a: nat)\n ensures (n + d) + a == n + (d + a)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_10218","instance":10218,"id":180217,"goal":"lemma MulComm_10218(b: real, m: real)\n ensures b * m == m * b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_10219","instance":10219,"id":180218,"goal":"lemma MulAssoc_10219(k: int, d: int, y: int)\n ensures (k * d) * y == k * (d * y)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_10220","instance":10220,"id":180219,"goal":"lemma Distrib_10220(y: nat, z: nat, c: nat)\n ensures y * (z + c) == y * z + y * c\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_10221","instance":10221,"id":180220,"goal":"lemma AddZero_10221(x: real)\n ensures x + 0 == x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_10222","instance":10222,"id":180221,"goal":"lemma MulOne_10222(d: int)\n ensures d * 1 == d\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_10223","instance":10223,"id":180222,"goal":"lemma MulZero_10223(c: nat)\n ensures c * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_10224","instance":10224,"id":180223,"goal":"lemma LeRefl_10224(z: real)\n ensures z <= z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_10225","instance":10225,"id":180224,"goal":"lemma LeTrans_10225(z: int, k: int, m: int)\n requires z <= k && k <= m\n ensures z <= m\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_10226","instance":10226,"id":180225,"goal":"lemma AddMono_10226(n: nat, a: nat, b: nat)\n requires n <= a\n ensures n + b <= a + b\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_10227","instance":10227,"id":180226,"goal":"lemma Abs_Nonneg_10227(c: real)\n ensures (if c >= 0 then c else -c) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_10228","instance":10228,"id":180227,"goal":"lemma DivMod_10228(j: int, y: int)\n requires y > 0\n ensures j == y * (j / y) + (j % y)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_10229","instance":10229,"id":180228,"goal":"lemma ModBounds_10229(y: nat, k: nat)\n requires k > 0\n ensures 0 <= y % k < k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_10230","instance":10230,"id":180229,"goal":"lemma Square_Nonneg_10230(b: real)\n ensures b * b >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_10231","instance":10231,"id":180230,"goal":"lemma AddComm_10231(z: int, m: int)\n ensures z + m == m + z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_10232","instance":10232,"id":180231,"goal":"lemma AddAssoc_10232(z: nat, j: nat, d: nat)\n ensures (z + j) + d == z + (j + d)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_10233","instance":10233,"id":180232,"goal":"lemma MulComm_10233(y: real, b: real)\n ensures y * b == b * y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_10234","instance":10234,"id":180233,"goal":"lemma MulAssoc_10234(j: int, a: int, m: int)\n ensures (j * a) * m == j * (a * m)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_10235","instance":10235,"id":180234,"goal":"lemma Distrib_10235(j: nat, i: nat, z: nat)\n ensures j * (i + z) == j * i + j * z\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_10236","instance":10236,"id":180235,"goal":"lemma AddZero_10236(n: real)\n ensures n + 0 == n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_10237","instance":10237,"id":180236,"goal":"lemma MulOne_10237(k: int)\n ensures k * 1 == k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_10238","instance":10238,"id":180237,"goal":"lemma MulZero_10238(b: nat)\n ensures b * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_10239","instance":10239,"id":180238,"goal":"lemma LeRefl_10239(x: real)\n ensures x <= x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_10240","instance":10240,"id":180239,"goal":"lemma LeTrans_10240(a: int, y: int, d: int)\n requires a <= y && y <= d\n ensures a <= d\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_10241","instance":10241,"id":180240,"goal":"lemma AddMono_10241(j: nat, c: nat, a: nat)\n requires j <= c\n ensures j + a <= c + a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_10242","instance":10242,"id":180241,"goal":"lemma Abs_Nonneg_10242(i: real)\n ensures (if i >= 0 then i else -i) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_10243","instance":10243,"id":180242,"goal":"lemma DivMod_10243(a: int, d: int)\n requires d > 0\n ensures a == d * (a / d) + (a % d)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_10244","instance":10244,"id":180243,"goal":"lemma ModBounds_10244(y: nat, i: nat)\n requires i > 0\n ensures 0 <= y % i < i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_10245","instance":10245,"id":180244,"goal":"lemma Square_Nonneg_10245(b: real)\n ensures b * b >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_10246","instance":10246,"id":180245,"goal":"lemma AddComm_10246(c: int, j: int)\n ensures c + j == j + c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_10247","instance":10247,"id":180246,"goal":"lemma AddAssoc_10247(y: nat, z: nat, j: nat)\n ensures (y + z) + j == y + (z + j)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_10248","instance":10248,"id":180247,"goal":"lemma MulComm_10248(x: real, j: real)\n ensures x * j == j * x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_10249","instance":10249,"id":180248,"goal":"lemma MulAssoc_10249(k: int, m: int, i: int)\n ensures (k * m) * i == k * (m * i)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_10250","instance":10250,"id":180249,"goal":"lemma Distrib_10250(d: nat, x: nat, i: nat)\n ensures d * (x + i) == d * x + d * i\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_10251","instance":10251,"id":180250,"goal":"lemma AddZero_10251(m: real)\n ensures m + 0 == m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_10252","instance":10252,"id":180251,"goal":"lemma MulOne_10252(d: int)\n ensures d * 1 == d\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_10253","instance":10253,"id":180252,"goal":"lemma MulZero_10253(i: nat)\n ensures i * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_10254","instance":10254,"id":180253,"goal":"lemma LeRefl_10254(k: real)\n ensures k <= k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_10255","instance":10255,"id":180254,"goal":"lemma LeTrans_10255(z: int, j: int, i: int)\n requires z <= j && j <= i\n ensures z <= i\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_10256","instance":10256,"id":180255,"goal":"lemma AddMono_10256(n: nat, y: nat, k: nat)\n requires n <= y\n ensures n + k <= y + k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_10257","instance":10257,"id":180256,"goal":"lemma Abs_Nonneg_10257(x: real)\n ensures (if x >= 0 then x else -x) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_10258","instance":10258,"id":180257,"goal":"lemma DivMod_10258(z: int, j: int)\n requires j > 0\n ensures z == j * (z / j) + (z % j)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_10259","instance":10259,"id":180258,"goal":"lemma ModBounds_10259(j: nat, k: nat)\n requires k > 0\n ensures 0 <= j % k < k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_10260","instance":10260,"id":180259,"goal":"lemma Square_Nonneg_10260(i: real)\n ensures i * i >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_10261","instance":10261,"id":180260,"goal":"lemma AddComm_10261(i: int, y: int)\n ensures i + y == y + i\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_10262","instance":10262,"id":180261,"goal":"lemma AddAssoc_10262(i: nat, j: nat, z: nat)\n ensures (i + j) + z == i + (j + z)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_10263","instance":10263,"id":180262,"goal":"lemma MulComm_10263(a: real, c: real)\n ensures a * c == c * a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_10264","instance":10264,"id":180263,"goal":"lemma MulAssoc_10264(x: int, d: int, b: int)\n ensures (x * d) * b == x * (d * b)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_10265","instance":10265,"id":180264,"goal":"lemma Distrib_10265(z: nat, b: nat, y: nat)\n ensures z * (b + y) == z * b + z * y\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_10266","instance":10266,"id":180265,"goal":"lemma AddZero_10266(z: real)\n ensures z + 0 == z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_10267","instance":10267,"id":180266,"goal":"lemma MulOne_10267(k: int)\n ensures k * 1 == k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_10268","instance":10268,"id":180267,"goal":"lemma MulZero_10268(j: nat)\n ensures j * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_10269","instance":10269,"id":180268,"goal":"lemma LeRefl_10269(b: real)\n ensures b <= b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_10270","instance":10270,"id":180269,"goal":"lemma LeTrans_10270(m: int, a: int, k: int)\n requires m <= a && a <= k\n ensures m <= k\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_10271","instance":10271,"id":180270,"goal":"lemma AddMono_10271(z: nat, b: nat, k: nat)\n requires z <= b\n ensures z + k <= b + k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_10272","instance":10272,"id":180271,"goal":"lemma Abs_Nonneg_10272(b: real)\n ensures (if b >= 0 then b else -b) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_10273","instance":10273,"id":180272,"goal":"lemma DivMod_10273(a: int, j: int)\n requires j > 0\n ensures a == j * (a / j) + (a % j)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_10274","instance":10274,"id":180273,"goal":"lemma ModBounds_10274(m: nat, y: nat)\n requires y > 0\n ensures 0 <= m % y < y\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_10275","instance":10275,"id":180274,"goal":"lemma Square_Nonneg_10275(m: real)\n ensures m * m >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_10276","instance":10276,"id":180275,"goal":"lemma AddComm_10276(n: int, z: int)\n ensures n + z == z + n\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_10277","instance":10277,"id":180276,"goal":"lemma AddAssoc_10277(b: nat, d: nat, i: nat)\n ensures (b + d) + i == b + (d + i)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_10278","instance":10278,"id":180277,"goal":"lemma MulComm_10278(d: real, j: real)\n ensures d * j == j * d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_10279","instance":10279,"id":180278,"goal":"lemma MulAssoc_10279(j: int, d: int, z: int)\n ensures (j * d) * z == j * (d * z)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_10280","instance":10280,"id":180279,"goal":"lemma Distrib_10280(c: nat, j: nat, y: nat)\n ensures c * (j + y) == c * j + c * y\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_10281","instance":10281,"id":180280,"goal":"lemma AddZero_10281(y: real)\n ensures y + 0 == y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_10282","instance":10282,"id":180281,"goal":"lemma MulOne_10282(x: int)\n ensures x * 1 == x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_10283","instance":10283,"id":180282,"goal":"lemma MulZero_10283(x: nat)\n ensures x * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_10284","instance":10284,"id":180283,"goal":"lemma LeRefl_10284(d: real)\n ensures d <= d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_10285","instance":10285,"id":180284,"goal":"lemma LeTrans_10285(z: int, a: int, c: int)\n requires z <= a && a <= c\n ensures z <= c\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_10286","instance":10286,"id":180285,"goal":"lemma AddMono_10286(j: nat, x: nat, z: nat)\n requires j <= x\n ensures j + z <= x + z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_10287","instance":10287,"id":180286,"goal":"lemma Abs_Nonneg_10287(y: real)\n ensures (if y >= 0 then y else -y) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_10288","instance":10288,"id":180287,"goal":"lemma DivMod_10288(x: int, n: int)\n requires n > 0\n ensures x == n * (x / n) + (x % n)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_10289","instance":10289,"id":180288,"goal":"lemma ModBounds_10289(b: nat, a: nat)\n requires a > 0\n ensures 0 <= b % a < a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_10290","instance":10290,"id":180289,"goal":"lemma Square_Nonneg_10290(x: real)\n ensures x * x >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_10291","instance":10291,"id":180290,"goal":"lemma AddComm_10291(b: int, z: int)\n ensures b + z == z + b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_10292","instance":10292,"id":180291,"goal":"lemma AddAssoc_10292(i: nat, a: nat, x: nat)\n ensures (i + a) + x == i + (a + x)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_10293","instance":10293,"id":180292,"goal":"lemma MulComm_10293(a: real, n: real)\n ensures a * n == n * a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_10294","instance":10294,"id":180293,"goal":"lemma MulAssoc_10294(i: int, z: int, y: int)\n ensures (i * z) * y == i * (z * y)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_10295","instance":10295,"id":180294,"goal":"lemma Distrib_10295(n: nat, b: nat, j: nat)\n ensures n * (b + j) == n * b + n * j\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_10296","instance":10296,"id":180295,"goal":"lemma AddZero_10296(m: real)\n ensures m + 0 == m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_10297","instance":10297,"id":180296,"goal":"lemma MulOne_10297(k: int)\n ensures k * 1 == k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_10298","instance":10298,"id":180297,"goal":"lemma MulZero_10298(y: nat)\n ensures y * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_10299","instance":10299,"id":180298,"goal":"lemma LeRefl_10299(y: real)\n ensures y <= y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_10300","instance":10300,"id":180299,"goal":"lemma LeTrans_10300(k: int, c: int, m: int)\n requires k <= c && c <= m\n ensures k <= m\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_10301","instance":10301,"id":180300,"goal":"lemma AddMono_10301(a: nat, x: nat, c: nat)\n requires a <= x\n ensures a + c <= x + c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_10302","instance":10302,"id":180301,"goal":"lemma Abs_Nonneg_10302(i: real)\n ensures (if i >= 0 then i else -i) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_10303","instance":10303,"id":180302,"goal":"lemma DivMod_10303(j: int, n: int)\n requires n > 0\n ensures j == n * (j / n) + (j % n)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_10304","instance":10304,"id":180303,"goal":"lemma ModBounds_10304(y: nat, z: nat)\n requires z > 0\n ensures 0 <= y % z < z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_10305","instance":10305,"id":180304,"goal":"lemma Square_Nonneg_10305(b: real)\n ensures b * b >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_10306","instance":10306,"id":180305,"goal":"lemma AddComm_10306(k: int, x: int)\n ensures k + x == x + k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_10307","instance":10307,"id":180306,"goal":"lemma AddAssoc_10307(i: nat, b: nat, j: nat)\n ensures (i + b) + j == i + (b + j)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_10308","instance":10308,"id":180307,"goal":"lemma MulComm_10308(c: real, a: real)\n ensures c * a == a * c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_10309","instance":10309,"id":180308,"goal":"lemma MulAssoc_10309(y: int, x: int, j: int)\n ensures (y * x) * j == y * (x * j)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_10310","instance":10310,"id":180309,"goal":"lemma Distrib_10310(y: nat, n: nat, j: nat)\n ensures y * (n + j) == y * n + y * j\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_10311","instance":10311,"id":180310,"goal":"lemma AddZero_10311(c: real)\n ensures c + 0 == c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_10312","instance":10312,"id":180311,"goal":"lemma MulOne_10312(c: int)\n ensures c * 1 == c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_10313","instance":10313,"id":180312,"goal":"lemma MulZero_10313(y: nat)\n ensures y * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_10314","instance":10314,"id":180313,"goal":"lemma LeRefl_10314(c: real)\n ensures c <= c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_10315","instance":10315,"id":180314,"goal":"lemma LeTrans_10315(c: int, k: int, j: int)\n requires c <= k && k <= j\n ensures c <= j\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_10316","instance":10316,"id":180315,"goal":"lemma AddMono_10316(i: nat, y: nat, x: nat)\n requires i <= y\n ensures i + x <= y + x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_10317","instance":10317,"id":180316,"goal":"lemma Abs_Nonneg_10317(y: real)\n ensures (if y >= 0 then y else -y) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_10318","instance":10318,"id":180317,"goal":"lemma DivMod_10318(m: int, z: int)\n requires z > 0\n ensures m == z * (m / z) + (m % z)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_10319","instance":10319,"id":180318,"goal":"lemma ModBounds_10319(x: nat, i: nat)\n requires i > 0\n ensures 0 <= x % i < i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_10320","instance":10320,"id":180319,"goal":"lemma Square_Nonneg_10320(x: real)\n ensures x * x >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_10321","instance":10321,"id":180320,"goal":"lemma AddComm_10321(d: int, j: int)\n ensures d + j == j + d\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_10322","instance":10322,"id":180321,"goal":"lemma AddAssoc_10322(d: nat, b: nat, z: nat)\n ensures (d + b) + z == d + (b + z)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_10323","instance":10323,"id":180322,"goal":"lemma MulComm_10323(c: real, x: real)\n ensures c * x == x * c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_10324","instance":10324,"id":180323,"goal":"lemma MulAssoc_10324(z: int, m: int, d: int)\n ensures (z * m) * d == z * (m * d)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_10325","instance":10325,"id":180324,"goal":"lemma Distrib_10325(d: nat, a: nat, z: nat)\n ensures d * (a + z) == d * a + d * z\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_10326","instance":10326,"id":180325,"goal":"lemma AddZero_10326(i: real)\n ensures i + 0 == i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_10327","instance":10327,"id":180326,"goal":"lemma MulOne_10327(n: int)\n ensures n * 1 == n\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_10328","instance":10328,"id":180327,"goal":"lemma MulZero_10328(y: nat)\n ensures y * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_10329","instance":10329,"id":180328,"goal":"lemma LeRefl_10329(k: real)\n ensures k <= k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_10330","instance":10330,"id":180329,"goal":"lemma LeTrans_10330(d: int, n: int, m: int)\n requires d <= n && n <= m\n ensures d <= m\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_10331","instance":10331,"id":180330,"goal":"lemma AddMono_10331(j: nat, a: nat, m: nat)\n requires j <= a\n ensures j + m <= a + m\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_10332","instance":10332,"id":180331,"goal":"lemma Abs_Nonneg_10332(i: real)\n ensures (if i >= 0 then i else -i) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_10333","instance":10333,"id":180332,"goal":"lemma DivMod_10333(k: int, j: int)\n requires j > 0\n ensures k == j * (k / j) + (k % j)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_10334","instance":10334,"id":180333,"goal":"lemma ModBounds_10334(a: nat, d: nat)\n requires d > 0\n ensures 0 <= a % d < d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_10335","instance":10335,"id":180334,"goal":"lemma Square_Nonneg_10335(x: real)\n ensures x * x >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_10336","instance":10336,"id":180335,"goal":"lemma AddComm_10336(y: int, z: int)\n ensures y + z == z + y\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_10337","instance":10337,"id":180336,"goal":"lemma AddAssoc_10337(c: nat, m: nat, i: nat)\n ensures (c + m) + i == c + (m + i)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_10338","instance":10338,"id":180337,"goal":"lemma MulComm_10338(b: real, a: real)\n ensures b * a == a * b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_10339","instance":10339,"id":180338,"goal":"lemma MulAssoc_10339(k: int, n: int, c: int)\n ensures (k * n) * c == k * (n * c)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_10340","instance":10340,"id":180339,"goal":"lemma Distrib_10340(k: nat, a: nat, y: nat)\n ensures k * (a + y) == k * a + k * y\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_10341","instance":10341,"id":180340,"goal":"lemma AddZero_10341(x: real)\n ensures x + 0 == x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_10342","instance":10342,"id":180341,"goal":"lemma MulOne_10342(k: int)\n ensures k * 1 == k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_10343","instance":10343,"id":180342,"goal":"lemma MulZero_10343(n: nat)\n ensures n * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_10344","instance":10344,"id":180343,"goal":"lemma LeRefl_10344(k: real)\n ensures k <= k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_10345","instance":10345,"id":180344,"goal":"lemma LeTrans_10345(y: int, j: int, d: int)\n requires y <= j && j <= d\n ensures y <= d\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_10346","instance":10346,"id":180345,"goal":"lemma AddMono_10346(n: nat, d: nat, y: nat)\n requires n <= d\n ensures n + y <= d + y\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_10347","instance":10347,"id":180346,"goal":"lemma Abs_Nonneg_10347(c: real)\n ensures (if c >= 0 then c else -c) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_10348","instance":10348,"id":180347,"goal":"lemma DivMod_10348(k: int, y: int)\n requires y > 0\n ensures k == y * (k / y) + (k % y)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_10349","instance":10349,"id":180348,"goal":"lemma ModBounds_10349(n: nat, d: nat)\n requires d > 0\n ensures 0 <= n % d < d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_10350","instance":10350,"id":180349,"goal":"lemma Square_Nonneg_10350(b: real)\n ensures b * b >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_10351","instance":10351,"id":180350,"goal":"lemma AddComm_10351(m: int, x: int)\n ensures m + x == x + m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_10352","instance":10352,"id":180351,"goal":"lemma AddAssoc_10352(d: nat, z: nat, i: nat)\n ensures (d + z) + i == d + (z + i)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_10353","instance":10353,"id":180352,"goal":"lemma MulComm_10353(i: real, x: real)\n ensures i * x == x * i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_10354","instance":10354,"id":180353,"goal":"lemma MulAssoc_10354(i: int, x: int, c: int)\n ensures (i * x) * c == i * (x * c)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_10355","instance":10355,"id":180354,"goal":"lemma Distrib_10355(a: nat, x: nat, b: nat)\n ensures a * (x + b) == a * x + a * b\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_10356","instance":10356,"id":180355,"goal":"lemma AddZero_10356(d: real)\n ensures d + 0 == d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_10357","instance":10357,"id":180356,"goal":"lemma MulOne_10357(m: int)\n ensures m * 1 == m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_10358","instance":10358,"id":180357,"goal":"lemma MulZero_10358(d: nat)\n ensures d * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_10359","instance":10359,"id":180358,"goal":"lemma LeRefl_10359(d: real)\n ensures d <= d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_10360","instance":10360,"id":180359,"goal":"lemma LeTrans_10360(y: int, z: int, i: int)\n requires y <= z && z <= i\n ensures y <= i\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_10361","instance":10361,"id":180360,"goal":"lemma AddMono_10361(k: nat, m: nat, z: nat)\n requires k <= m\n ensures k + z <= m + z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_10362","instance":10362,"id":180361,"goal":"lemma Abs_Nonneg_10362(n: real)\n ensures (if n >= 0 then n else -n) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_10363","instance":10363,"id":180362,"goal":"lemma DivMod_10363(z: int, a: int)\n requires a > 0\n ensures z == a * (z / a) + (z % a)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_10364","instance":10364,"id":180363,"goal":"lemma ModBounds_10364(c: nat, j: nat)\n requires j > 0\n ensures 0 <= c % j < j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_10365","instance":10365,"id":180364,"goal":"lemma Square_Nonneg_10365(n: real)\n ensures n * n >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_10366","instance":10366,"id":180365,"goal":"lemma AddComm_10366(d: int, m: int)\n ensures d + m == m + d\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_10367","instance":10367,"id":180366,"goal":"lemma AddAssoc_10367(i: nat, k: nat, y: nat)\n ensures (i + k) + y == i + (k + y)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_10368","instance":10368,"id":180367,"goal":"lemma MulComm_10368(z: real, a: real)\n ensures z * a == a * z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_10369","instance":10369,"id":180368,"goal":"lemma MulAssoc_10369(x: int, n: int, a: int)\n ensures (x * n) * a == x * (n * a)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_10370","instance":10370,"id":180369,"goal":"lemma Distrib_10370(k: nat, x: nat, d: nat)\n ensures k * (x + d) == k * x + k * d\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_10371","instance":10371,"id":180370,"goal":"lemma AddZero_10371(c: real)\n ensures c + 0 == c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_10372","instance":10372,"id":180371,"goal":"lemma MulOne_10372(c: int)\n ensures c * 1 == c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_10373","instance":10373,"id":180372,"goal":"lemma MulZero_10373(b: nat)\n ensures b * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_10374","instance":10374,"id":180373,"goal":"lemma LeRefl_10374(a: real)\n ensures a <= a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_10375","instance":10375,"id":180374,"goal":"lemma LeTrans_10375(a: int, m: int, b: int)\n requires a <= m && m <= b\n ensures a <= b\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_10376","instance":10376,"id":180375,"goal":"lemma AddMono_10376(k: nat, x: nat, d: nat)\n requires k <= x\n ensures k + d <= x + d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_10377","instance":10377,"id":180376,"goal":"lemma Abs_Nonneg_10377(k: real)\n ensures (if k >= 0 then k else -k) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_10378","instance":10378,"id":180377,"goal":"lemma DivMod_10378(j: int, c: int)\n requires c > 0\n ensures j == c * (j / c) + (j % c)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_10379","instance":10379,"id":180378,"goal":"lemma ModBounds_10379(m: nat, k: nat)\n requires k > 0\n ensures 0 <= m % k < k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_10380","instance":10380,"id":180379,"goal":"lemma Square_Nonneg_10380(x: real)\n ensures x * x >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_10381","instance":10381,"id":180380,"goal":"lemma AddComm_10381(z: int, x: int)\n ensures z + x == x + z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_10382","instance":10382,"id":180381,"goal":"lemma AddAssoc_10382(c: nat, k: nat, m: nat)\n ensures (c + k) + m == c + (k + m)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_10383","instance":10383,"id":180382,"goal":"lemma MulComm_10383(x: real, y: real)\n ensures x * y == y * x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_10384","instance":10384,"id":180383,"goal":"lemma MulAssoc_10384(a: int, k: int, c: int)\n ensures (a * k) * c == a * (k * c)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_10385","instance":10385,"id":180384,"goal":"lemma Distrib_10385(z: nat, a: nat, c: nat)\n ensures z * (a + c) == z * a + z * c\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_10386","instance":10386,"id":180385,"goal":"lemma AddZero_10386(j: real)\n ensures j + 0 == j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_10387","instance":10387,"id":180386,"goal":"lemma MulOne_10387(x: int)\n ensures x * 1 == x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_10388","instance":10388,"id":180387,"goal":"lemma MulZero_10388(i: nat)\n ensures i * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_10389","instance":10389,"id":180388,"goal":"lemma LeRefl_10389(k: real)\n ensures k <= k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_10390","instance":10390,"id":180389,"goal":"lemma LeTrans_10390(z: int, c: int, d: int)\n requires z <= c && c <= d\n ensures z <= d\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_10391","instance":10391,"id":180390,"goal":"lemma AddMono_10391(j: nat, y: nat, x: nat)\n requires j <= y\n ensures j + x <= y + x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_10392","instance":10392,"id":180391,"goal":"lemma Abs_Nonneg_10392(k: real)\n ensures (if k >= 0 then k else -k) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_10393","instance":10393,"id":180392,"goal":"lemma DivMod_10393(m: int, j: int)\n requires j > 0\n ensures m == j * (m / j) + (m % j)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_10394","instance":10394,"id":180393,"goal":"lemma ModBounds_10394(z: nat, b: nat)\n requires b > 0\n ensures 0 <= z % b < b\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_10395","instance":10395,"id":180394,"goal":"lemma Square_Nonneg_10395(a: real)\n ensures a * a >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_10396","instance":10396,"id":180395,"goal":"lemma AddComm_10396(z: int, i: int)\n ensures z + i == i + z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_10397","instance":10397,"id":180396,"goal":"lemma AddAssoc_10397(m: nat, a: nat, b: nat)\n ensures (m + a) + b == m + (a + b)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_10398","instance":10398,"id":180397,"goal":"lemma MulComm_10398(n: real, k: real)\n ensures n * k == k * n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_10399","instance":10399,"id":180398,"goal":"lemma MulAssoc_10399(b: int, x: int, a: int)\n ensures (b * x) * a == b * (x * a)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_10400","instance":10400,"id":180399,"goal":"lemma Distrib_10400(j: nat, m: nat, k: nat)\n ensures j * (m + k) == j * m + j * k\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_10401","instance":10401,"id":180400,"goal":"lemma AddZero_10401(y: real)\n ensures y + 0 == y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_10402","instance":10402,"id":180401,"goal":"lemma MulOne_10402(n: int)\n ensures n * 1 == n\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_10403","instance":10403,"id":180402,"goal":"lemma MulZero_10403(j: nat)\n ensures j * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_10404","instance":10404,"id":180403,"goal":"lemma LeRefl_10404(c: real)\n ensures c <= c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_10405","instance":10405,"id":180404,"goal":"lemma LeTrans_10405(a: int, m: int, x: int)\n requires a <= m && m <= x\n ensures a <= x\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_10406","instance":10406,"id":180405,"goal":"lemma AddMono_10406(i: nat, b: nat, n: nat)\n requires i <= b\n ensures i + n <= b + n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_10407","instance":10407,"id":180406,"goal":"lemma Abs_Nonneg_10407(n: real)\n ensures (if n >= 0 then n else -n) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_10408","instance":10408,"id":180407,"goal":"lemma DivMod_10408(k: int, n: int)\n requires n > 0\n ensures k == n * (k / n) + (k % n)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_10409","instance":10409,"id":180408,"goal":"lemma ModBounds_10409(i: nat, x: nat)\n requires x > 0\n ensures 0 <= i % x < x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_10410","instance":10410,"id":180409,"goal":"lemma Square_Nonneg_10410(y: real)\n ensures y * y >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_10411","instance":10411,"id":180410,"goal":"lemma AddComm_10411(a: int, x: int)\n ensures a + x == x + a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_10412","instance":10412,"id":180411,"goal":"lemma AddAssoc_10412(c: nat, x: nat, b: nat)\n ensures (c + x) + b == c + (x + b)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_10413","instance":10413,"id":180412,"goal":"lemma MulComm_10413(m: real, x: real)\n ensures m * x == x * m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_10414","instance":10414,"id":180413,"goal":"lemma MulAssoc_10414(a: int, y: int, c: int)\n ensures (a * y) * c == a * (y * c)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_10415","instance":10415,"id":180414,"goal":"lemma Distrib_10415(c: nat, a: nat, y: nat)\n ensures c * (a + y) == c * a + c * y\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_10416","instance":10416,"id":180415,"goal":"lemma AddZero_10416(k: real)\n ensures k + 0 == k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_10417","instance":10417,"id":180416,"goal":"lemma MulOne_10417(b: int)\n ensures b * 1 == b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_10418","instance":10418,"id":180417,"goal":"lemma MulZero_10418(b: nat)\n ensures b * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_10419","instance":10419,"id":180418,"goal":"lemma LeRefl_10419(x: real)\n ensures x <= x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_10420","instance":10420,"id":180419,"goal":"lemma LeTrans_10420(m: int, z: int, x: int)\n requires m <= z && z <= x\n ensures m <= x\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_10421","instance":10421,"id":180420,"goal":"lemma AddMono_10421(y: nat, n: nat, z: nat)\n requires y <= n\n ensures y + z <= n + z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_10422","instance":10422,"id":180421,"goal":"lemma Abs_Nonneg_10422(z: real)\n ensures (if z >= 0 then z else -z) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_10423","instance":10423,"id":180422,"goal":"lemma DivMod_10423(c: int, y: int)\n requires y > 0\n ensures c == y * (c / y) + (c % y)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_10424","instance":10424,"id":180423,"goal":"lemma ModBounds_10424(y: nat, a: nat)\n requires a > 0\n ensures 0 <= y % a < a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_10425","instance":10425,"id":180424,"goal":"lemma Square_Nonneg_10425(d: real)\n ensures d * d >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_10426","instance":10426,"id":180425,"goal":"lemma AddComm_10426(d: int, i: int)\n ensures d + i == i + d\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_10427","instance":10427,"id":180426,"goal":"lemma AddAssoc_10427(d: nat, a: nat, k: nat)\n ensures (d + a) + k == d + (a + k)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_10428","instance":10428,"id":180427,"goal":"lemma MulComm_10428(c: real, d: real)\n ensures c * d == d * c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_10429","instance":10429,"id":180428,"goal":"lemma MulAssoc_10429(c: int, m: int, a: int)\n ensures (c * m) * a == c * (m * a)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_10430","instance":10430,"id":180429,"goal":"lemma Distrib_10430(d: nat, k: nat, i: nat)\n ensures d * (k + i) == d * k + d * i\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_10431","instance":10431,"id":180430,"goal":"lemma AddZero_10431(x: real)\n ensures x + 0 == x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_10432","instance":10432,"id":180431,"goal":"lemma MulOne_10432(n: int)\n ensures n * 1 == n\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_10433","instance":10433,"id":180432,"goal":"lemma MulZero_10433(z: nat)\n ensures z * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_10434","instance":10434,"id":180433,"goal":"lemma LeRefl_10434(k: real)\n ensures k <= k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_10435","instance":10435,"id":180434,"goal":"lemma LeTrans_10435(d: int, j: int, m: int)\n requires d <= j && j <= m\n ensures d <= m\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_10436","instance":10436,"id":180435,"goal":"lemma AddMono_10436(i: nat, n: nat, c: nat)\n requires i <= n\n ensures i + c <= n + c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_10437","instance":10437,"id":180436,"goal":"lemma Abs_Nonneg_10437(i: real)\n ensures (if i >= 0 then i else -i) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_10438","instance":10438,"id":180437,"goal":"lemma DivMod_10438(c: int, x: int)\n requires x > 0\n ensures c == x * (c / x) + (c % x)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_10439","instance":10439,"id":180438,"goal":"lemma ModBounds_10439(n: nat, k: nat)\n requires k > 0\n ensures 0 <= n % k < k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_10440","instance":10440,"id":180439,"goal":"lemma Square_Nonneg_10440(d: real)\n ensures d * d >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_10441","instance":10441,"id":180440,"goal":"lemma AddComm_10441(j: int, y: int)\n ensures j + y == y + j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_10442","instance":10442,"id":180441,"goal":"lemma AddAssoc_10442(z: nat, b: nat, y: nat)\n ensures (z + b) + y == z + (b + y)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_10443","instance":10443,"id":180442,"goal":"lemma MulComm_10443(c: real, a: real)\n ensures c * a == a * c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_10444","instance":10444,"id":180443,"goal":"lemma MulAssoc_10444(i: int, j: int, z: int)\n ensures (i * j) * z == i * (j * z)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_10445","instance":10445,"id":180444,"goal":"lemma Distrib_10445(z: nat, i: nat, j: nat)\n ensures z * (i + j) == z * i + z * j\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_10446","instance":10446,"id":180445,"goal":"lemma AddZero_10446(m: real)\n ensures m + 0 == m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_10447","instance":10447,"id":180446,"goal":"lemma MulOne_10447(b: int)\n ensures b * 1 == b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_10448","instance":10448,"id":180447,"goal":"lemma MulZero_10448(m: nat)\n ensures m * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_10449","instance":10449,"id":180448,"goal":"lemma LeRefl_10449(d: real)\n ensures d <= d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_10450","instance":10450,"id":180449,"goal":"lemma LeTrans_10450(k: int, c: int, d: int)\n requires k <= c && c <= d\n ensures k <= d\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_10451","instance":10451,"id":180450,"goal":"lemma AddMono_10451(d: nat, n: nat, b: nat)\n requires d <= n\n ensures d + b <= n + b\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_10452","instance":10452,"id":180451,"goal":"lemma Abs_Nonneg_10452(j: real)\n ensures (if j >= 0 then j else -j) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_10453","instance":10453,"id":180452,"goal":"lemma DivMod_10453(a: int, c: int)\n requires c > 0\n ensures a == c * (a / c) + (a % c)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_10454","instance":10454,"id":180453,"goal":"lemma ModBounds_10454(n: nat, z: nat)\n requires z > 0\n ensures 0 <= n % z < z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_10455","instance":10455,"id":180454,"goal":"lemma Square_Nonneg_10455(x: real)\n ensures x * x >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_10456","instance":10456,"id":180455,"goal":"lemma AddComm_10456(d: int, x: int)\n ensures d + x == x + d\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_10457","instance":10457,"id":180456,"goal":"lemma AddAssoc_10457(a: nat, b: nat, i: nat)\n ensures (a + b) + i == a + (b + i)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_10458","instance":10458,"id":180457,"goal":"lemma MulComm_10458(d: real, y: real)\n ensures d * y == y * d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_10459","instance":10459,"id":180458,"goal":"lemma MulAssoc_10459(n: int, c: int, x: int)\n ensures (n * c) * x == n * (c * x)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_10460","instance":10460,"id":180459,"goal":"lemma Distrib_10460(a: nat, d: nat, i: nat)\n ensures a * (d + i) == a * d + a * i\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_10461","instance":10461,"id":180460,"goal":"lemma AddZero_10461(y: real)\n ensures y + 0 == y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_10462","instance":10462,"id":180461,"goal":"lemma MulOne_10462(n: int)\n ensures n * 1 == n\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_10463","instance":10463,"id":180462,"goal":"lemma MulZero_10463(n: nat)\n ensures n * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_10464","instance":10464,"id":180463,"goal":"lemma LeRefl_10464(z: real)\n ensures z <= z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_10465","instance":10465,"id":180464,"goal":"lemma LeTrans_10465(b: int, m: int, y: int)\n requires b <= m && m <= y\n ensures b <= y\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_10466","instance":10466,"id":180465,"goal":"lemma AddMono_10466(k: nat, b: nat, m: nat)\n requires k <= b\n ensures k + m <= b + m\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_10467","instance":10467,"id":180466,"goal":"lemma Abs_Nonneg_10467(j: real)\n ensures (if j >= 0 then j else -j) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_10468","instance":10468,"id":180467,"goal":"lemma DivMod_10468(m: int, c: int)\n requires c > 0\n ensures m == c * (m / c) + (m % c)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_10469","instance":10469,"id":180468,"goal":"lemma ModBounds_10469(j: nat, i: nat)\n requires i > 0\n ensures 0 <= j % i < i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_10470","instance":10470,"id":180469,"goal":"lemma Square_Nonneg_10470(b: real)\n ensures b * b >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_10471","instance":10471,"id":180470,"goal":"lemma AddComm_10471(b: int, n: int)\n ensures b + n == n + b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_10472","instance":10472,"id":180471,"goal":"lemma AddAssoc_10472(x: nat, n: nat, d: nat)\n ensures (x + n) + d == x + (n + d)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_10473","instance":10473,"id":180472,"goal":"lemma MulComm_10473(c: real, j: real)\n ensures c * j == j * c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_10474","instance":10474,"id":180473,"goal":"lemma MulAssoc_10474(c: int, d: int, k: int)\n ensures (c * d) * k == c * (d * k)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_10475","instance":10475,"id":180474,"goal":"lemma Distrib_10475(i: nat, d: nat, k: nat)\n ensures i * (d + k) == i * d + i * k\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_10476","instance":10476,"id":180475,"goal":"lemma AddZero_10476(k: real)\n ensures k + 0 == k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_10477","instance":10477,"id":180476,"goal":"lemma MulOne_10477(a: int)\n ensures a * 1 == a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_10478","instance":10478,"id":180477,"goal":"lemma MulZero_10478(y: nat)\n ensures y * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_10479","instance":10479,"id":180478,"goal":"lemma LeRefl_10479(k: real)\n ensures k <= k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_10480","instance":10480,"id":180479,"goal":"lemma LeTrans_10480(c: int, y: int, j: int)\n requires c <= y && y <= j\n ensures c <= j\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_10481","instance":10481,"id":180480,"goal":"lemma AddMono_10481(b: nat, c: nat, y: nat)\n requires b <= c\n ensures b + y <= c + y\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_10482","instance":10482,"id":180481,"goal":"lemma Abs_Nonneg_10482(c: real)\n ensures (if c >= 0 then c else -c) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_10483","instance":10483,"id":180482,"goal":"lemma DivMod_10483(m: int, z: int)\n requires z > 0\n ensures m == z * (m / z) + (m % z)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_10484","instance":10484,"id":180483,"goal":"lemma ModBounds_10484(y: nat, c: nat)\n requires c > 0\n ensures 0 <= y % c < c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_10485","instance":10485,"id":180484,"goal":"lemma Square_Nonneg_10485(b: real)\n ensures b * b >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_10486","instance":10486,"id":180485,"goal":"lemma AddComm_10486(b: int, n: int)\n ensures b + n == n + b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_10487","instance":10487,"id":180486,"goal":"lemma AddAssoc_10487(i: nat, x: nat, z: nat)\n ensures (i + x) + z == i + (x + z)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_10488","instance":10488,"id":180487,"goal":"lemma MulComm_10488(b: real, i: real)\n ensures b * i == i * b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_10489","instance":10489,"id":180488,"goal":"lemma MulAssoc_10489(m: int, y: int, i: int)\n ensures (m * y) * i == m * (y * i)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_10490","instance":10490,"id":180489,"goal":"lemma Distrib_10490(d: nat, a: nat, x: nat)\n ensures d * (a + x) == d * a + d * x\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_10491","instance":10491,"id":180490,"goal":"lemma AddZero_10491(d: real)\n ensures d + 0 == d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_10492","instance":10492,"id":180491,"goal":"lemma MulOne_10492(c: int)\n ensures c * 1 == c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_10493","instance":10493,"id":180492,"goal":"lemma MulZero_10493(m: nat)\n ensures m * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_10494","instance":10494,"id":180493,"goal":"lemma LeRefl_10494(j: real)\n ensures j <= j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_10495","instance":10495,"id":180494,"goal":"lemma LeTrans_10495(c: int, n: int, i: int)\n requires c <= n && n <= i\n ensures c <= i\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_10496","instance":10496,"id":180495,"goal":"lemma AddMono_10496(a: nat, c: nat, d: nat)\n requires a <= c\n ensures a + d <= c + d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_10497","instance":10497,"id":180496,"goal":"lemma Abs_Nonneg_10497(j: real)\n ensures (if j >= 0 then j else -j) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_10498","instance":10498,"id":180497,"goal":"lemma DivMod_10498(b: int, n: int)\n requires n > 0\n ensures b == n * (b / n) + (b % n)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_10499","instance":10499,"id":180498,"goal":"lemma ModBounds_10499(b: nat, j: nat)\n requires j > 0\n ensures 0 <= b % j < j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_10500","instance":10500,"id":180499,"goal":"lemma Square_Nonneg_10500(k: real)\n ensures k * k >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_10501","instance":10501,"id":180500,"goal":"lemma AddComm_10501(b: int, d: int)\n ensures b + d == d + b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_10502","instance":10502,"id":180501,"goal":"lemma AddAssoc_10502(j: nat, x: nat, a: nat)\n ensures (j + x) + a == j + (x + a)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_10503","instance":10503,"id":180502,"goal":"lemma MulComm_10503(c: real, n: real)\n ensures c * n == n * c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_10504","instance":10504,"id":180503,"goal":"lemma MulAssoc_10504(z: int, c: int, j: int)\n ensures (z * c) * j == z * (c * j)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_10505","instance":10505,"id":180504,"goal":"lemma Distrib_10505(n: nat, d: nat, b: nat)\n ensures n * (d + b) == n * d + n * b\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_10506","instance":10506,"id":180505,"goal":"lemma AddZero_10506(z: real)\n ensures z + 0 == z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_10507","instance":10507,"id":180506,"goal":"lemma MulOne_10507(i: int)\n ensures i * 1 == i\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_10508","instance":10508,"id":180507,"goal":"lemma MulZero_10508(y: nat)\n ensures y * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_10509","instance":10509,"id":180508,"goal":"lemma LeRefl_10509(c: real)\n ensures c <= c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_10510","instance":10510,"id":180509,"goal":"lemma LeTrans_10510(k: int, j: int, y: int)\n requires k <= j && j <= y\n ensures k <= y\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_10511","instance":10511,"id":180510,"goal":"lemma AddMono_10511(b: nat, i: nat, a: nat)\n requires b <= i\n ensures b + a <= i + a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_10512","instance":10512,"id":180511,"goal":"lemma Abs_Nonneg_10512(m: real)\n ensures (if m >= 0 then m else -m) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_10513","instance":10513,"id":180512,"goal":"lemma DivMod_10513(k: int, y: int)\n requires y > 0\n ensures k == y * (k / y) + (k % y)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_10514","instance":10514,"id":180513,"goal":"lemma ModBounds_10514(z: nat, y: nat)\n requires y > 0\n ensures 0 <= z % y < y\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_10515","instance":10515,"id":180514,"goal":"lemma Square_Nonneg_10515(m: real)\n ensures m * m >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_10516","instance":10516,"id":180515,"goal":"lemma AddComm_10516(k: int, c: int)\n ensures k + c == c + k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_10517","instance":10517,"id":180516,"goal":"lemma AddAssoc_10517(z: nat, k: nat, m: nat)\n ensures (z + k) + m == z + (k + m)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_10518","instance":10518,"id":180517,"goal":"lemma MulComm_10518(a: real, y: real)\n ensures a * y == y * a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_10519","instance":10519,"id":180518,"goal":"lemma MulAssoc_10519(b: int, z: int, y: int)\n ensures (b * z) * y == b * (z * y)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_10520","instance":10520,"id":180519,"goal":"lemma Distrib_10520(m: nat, a: nat, c: nat)\n ensures m * (a + c) == m * a + m * c\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_10521","instance":10521,"id":180520,"goal":"lemma AddZero_10521(a: real)\n ensures a + 0 == a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_10522","instance":10522,"id":180521,"goal":"lemma MulOne_10522(x: int)\n ensures x * 1 == x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_10523","instance":10523,"id":180522,"goal":"lemma MulZero_10523(x: nat)\n ensures x * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_10524","instance":10524,"id":180523,"goal":"lemma LeRefl_10524(x: real)\n ensures x <= x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_10525","instance":10525,"id":180524,"goal":"lemma LeTrans_10525(d: int, a: int, b: int)\n requires d <= a && a <= b\n ensures d <= b\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_10526","instance":10526,"id":180525,"goal":"lemma AddMono_10526(d: nat, j: nat, k: nat)\n requires d <= j\n ensures d + k <= j + k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_10527","instance":10527,"id":180526,"goal":"lemma Abs_Nonneg_10527(y: real)\n ensures (if y >= 0 then y else -y) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_10528","instance":10528,"id":180527,"goal":"lemma DivMod_10528(y: int, d: int)\n requires d > 0\n ensures y == d * (y / d) + (y % d)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_10529","instance":10529,"id":180528,"goal":"lemma ModBounds_10529(b: nat, n: nat)\n requires n > 0\n ensures 0 <= b % n < n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_10530","instance":10530,"id":180529,"goal":"lemma Square_Nonneg_10530(n: real)\n ensures n * n >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_10531","instance":10531,"id":180530,"goal":"lemma AddComm_10531(k: int, j: int)\n ensures k + j == j + k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_10532","instance":10532,"id":180531,"goal":"lemma AddAssoc_10532(n: nat, y: nat, a: nat)\n ensures (n + y) + a == n + (y + a)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_10533","instance":10533,"id":180532,"goal":"lemma MulComm_10533(k: real, i: real)\n ensures k * i == i * k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_10534","instance":10534,"id":180533,"goal":"lemma MulAssoc_10534(x: int, j: int, b: int)\n ensures (x * j) * b == x * (j * b)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_10535","instance":10535,"id":180534,"goal":"lemma Distrib_10535(y: nat, j: nat, c: nat)\n ensures y * (j + c) == y * j + y * c\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_10536","instance":10536,"id":180535,"goal":"lemma AddZero_10536(k: real)\n ensures k + 0 == k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_10537","instance":10537,"id":180536,"goal":"lemma MulOne_10537(x: int)\n ensures x * 1 == x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_10538","instance":10538,"id":180537,"goal":"lemma MulZero_10538(z: nat)\n ensures z * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_10539","instance":10539,"id":180538,"goal":"lemma LeRefl_10539(c: real)\n ensures c <= c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_10540","instance":10540,"id":180539,"goal":"lemma LeTrans_10540(b: int, d: int, j: int)\n requires b <= d && d <= j\n ensures b <= j\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_10541","instance":10541,"id":180540,"goal":"lemma AddMono_10541(k: nat, j: nat, m: nat)\n requires k <= j\n ensures k + m <= j + m\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_10542","instance":10542,"id":180541,"goal":"lemma Abs_Nonneg_10542(i: real)\n ensures (if i >= 0 then i else -i) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_10543","instance":10543,"id":180542,"goal":"lemma DivMod_10543(d: int, x: int)\n requires x > 0\n ensures d == x * (d / x) + (d % x)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_10544","instance":10544,"id":180543,"goal":"lemma ModBounds_10544(c: nat, a: nat)\n requires a > 0\n ensures 0 <= c % a < a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_10545","instance":10545,"id":180544,"goal":"lemma Square_Nonneg_10545(i: real)\n ensures i * i >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_10546","instance":10546,"id":180545,"goal":"lemma AddComm_10546(x: int, m: int)\n ensures x + m == m + x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_10547","instance":10547,"id":180546,"goal":"lemma AddAssoc_10547(c: nat, z: nat, i: nat)\n ensures (c + z) + i == c + (z + i)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_10548","instance":10548,"id":180547,"goal":"lemma MulComm_10548(x: real, c: real)\n ensures x * c == c * x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_10549","instance":10549,"id":180548,"goal":"lemma MulAssoc_10549(x: int, d: int, z: int)\n ensures (x * d) * z == x * (d * z)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_10550","instance":10550,"id":180549,"goal":"lemma Distrib_10550(j: nat, k: nat, d: nat)\n ensures j * (k + d) == j * k + j * d\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_10551","instance":10551,"id":180550,"goal":"lemma AddZero_10551(a: real)\n ensures a + 0 == a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_10552","instance":10552,"id":180551,"goal":"lemma MulOne_10552(z: int)\n ensures z * 1 == z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_10553","instance":10553,"id":180552,"goal":"lemma MulZero_10553(m: nat)\n ensures m * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_10554","instance":10554,"id":180553,"goal":"lemma LeRefl_10554(z: real)\n ensures z <= z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_10555","instance":10555,"id":180554,"goal":"lemma LeTrans_10555(n: int, i: int, k: int)\n requires n <= i && i <= k\n ensures n <= k\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_10556","instance":10556,"id":180555,"goal":"lemma AddMono_10556(a: nat, m: nat, y: nat)\n requires a <= m\n ensures a + y <= m + y\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_10557","instance":10557,"id":180556,"goal":"lemma Abs_Nonneg_10557(x: real)\n ensures (if x >= 0 then x else -x) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_10558","instance":10558,"id":180557,"goal":"lemma DivMod_10558(c: int, d: int)\n requires d > 0\n ensures c == d * (c / d) + (c % d)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_10559","instance":10559,"id":180558,"goal":"lemma ModBounds_10559(i: nat, c: nat)\n requires c > 0\n ensures 0 <= i % c < c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_10560","instance":10560,"id":180559,"goal":"lemma Square_Nonneg_10560(b: real)\n ensures b * b >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_10561","instance":10561,"id":180560,"goal":"lemma AddComm_10561(d: int, k: int)\n ensures d + k == k + d\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_10562","instance":10562,"id":180561,"goal":"lemma AddAssoc_10562(d: nat, m: nat, i: nat)\n ensures (d + m) + i == d + (m + i)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_10563","instance":10563,"id":180562,"goal":"lemma MulComm_10563(x: real, b: real)\n ensures x * b == b * x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_10564","instance":10564,"id":180563,"goal":"lemma MulAssoc_10564(a: int, x: int, y: int)\n ensures (a * x) * y == a * (x * y)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_10565","instance":10565,"id":180564,"goal":"lemma Distrib_10565(y: nat, x: nat, m: nat)\n ensures y * (x + m) == y * x + y * m\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_10566","instance":10566,"id":180565,"goal":"lemma AddZero_10566(i: real)\n ensures i + 0 == i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_10567","instance":10567,"id":180566,"goal":"lemma MulOne_10567(y: int)\n ensures y * 1 == y\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_10568","instance":10568,"id":180567,"goal":"lemma MulZero_10568(z: nat)\n ensures z * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_10569","instance":10569,"id":180568,"goal":"lemma LeRefl_10569(m: real)\n ensures m <= m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_10570","instance":10570,"id":180569,"goal":"lemma LeTrans_10570(j: int, z: int, m: int)\n requires j <= z && z <= m\n ensures j <= m\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_10571","instance":10571,"id":180570,"goal":"lemma AddMono_10571(n: nat, k: nat, j: nat)\n requires n <= k\n ensures n + j <= k + j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_10572","instance":10572,"id":180571,"goal":"lemma Abs_Nonneg_10572(d: real)\n ensures (if d >= 0 then d else -d) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_10573","instance":10573,"id":180572,"goal":"lemma DivMod_10573(n: int, j: int)\n requires j > 0\n ensures n == j * (n / j) + (n % j)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_10574","instance":10574,"id":180573,"goal":"lemma ModBounds_10574(k: nat, x: nat)\n requires x > 0\n ensures 0 <= k % x < x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_10575","instance":10575,"id":180574,"goal":"lemma Square_Nonneg_10575(k: real)\n ensures k * k >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_10576","instance":10576,"id":180575,"goal":"lemma AddComm_10576(n: int, x: int)\n ensures n + x == x + n\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_10577","instance":10577,"id":180576,"goal":"lemma AddAssoc_10577(a: nat, x: nat, c: nat)\n ensures (a + x) + c == a + (x + c)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_10578","instance":10578,"id":180577,"goal":"lemma MulComm_10578(y: real, a: real)\n ensures y * a == a * y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_10579","instance":10579,"id":180578,"goal":"lemma MulAssoc_10579(j: int, k: int, y: int)\n ensures (j * k) * y == j * (k * y)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_10580","instance":10580,"id":180579,"goal":"lemma Distrib_10580(i: nat, y: nat, c: nat)\n ensures i * (y + c) == i * y + i * c\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_10581","instance":10581,"id":180580,"goal":"lemma AddZero_10581(z: real)\n ensures z + 0 == z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_10582","instance":10582,"id":180581,"goal":"lemma MulOne_10582(i: int)\n ensures i * 1 == i\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_10583","instance":10583,"id":180582,"goal":"lemma MulZero_10583(j: nat)\n ensures j * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_10584","instance":10584,"id":180583,"goal":"lemma LeRefl_10584(m: real)\n ensures m <= m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_10585","instance":10585,"id":180584,"goal":"lemma LeTrans_10585(c: int, j: int, n: int)\n requires c <= j && j <= n\n ensures c <= n\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_10586","instance":10586,"id":180585,"goal":"lemma AddMono_10586(a: nat, z: nat, x: nat)\n requires a <= z\n ensures a + x <= z + x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_10587","instance":10587,"id":180586,"goal":"lemma Abs_Nonneg_10587(n: real)\n ensures (if n >= 0 then n else -n) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_10588","instance":10588,"id":180587,"goal":"lemma DivMod_10588(b: int, k: int)\n requires k > 0\n ensures b == k * (b / k) + (b % k)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_10589","instance":10589,"id":180588,"goal":"lemma ModBounds_10589(n: nat, k: nat)\n requires k > 0\n ensures 0 <= n % k < k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_10590","instance":10590,"id":180589,"goal":"lemma Square_Nonneg_10590(y: real)\n ensures y * y >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_10591","instance":10591,"id":180590,"goal":"lemma AddComm_10591(a: int, b: int)\n ensures a + b == b + a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_10592","instance":10592,"id":180591,"goal":"lemma AddAssoc_10592(d: nat, m: nat, x: nat)\n ensures (d + m) + x == d + (m + x)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_10593","instance":10593,"id":180592,"goal":"lemma MulComm_10593(j: real, c: real)\n ensures j * c == c * j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_10594","instance":10594,"id":180593,"goal":"lemma MulAssoc_10594(c: int, m: int, i: int)\n ensures (c * m) * i == c * (m * i)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_10595","instance":10595,"id":180594,"goal":"lemma Distrib_10595(b: nat, x: nat, y: nat)\n ensures b * (x + y) == b * x + b * y\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_10596","instance":10596,"id":180595,"goal":"lemma AddZero_10596(m: real)\n ensures m + 0 == m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_10597","instance":10597,"id":180596,"goal":"lemma MulOne_10597(c: int)\n ensures c * 1 == c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_10598","instance":10598,"id":180597,"goal":"lemma MulZero_10598(x: nat)\n ensures x * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_10599","instance":10599,"id":180598,"goal":"lemma LeRefl_10599(z: real)\n ensures z <= z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_10600","instance":10600,"id":180599,"goal":"lemma LeTrans_10600(y: int, i: int, m: int)\n requires y <= i && i <= m\n ensures y <= m\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_10601","instance":10601,"id":180600,"goal":"lemma AddMono_10601(d: nat, j: nat, i: nat)\n requires d <= j\n ensures d + i <= j + i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_10602","instance":10602,"id":180601,"goal":"lemma Abs_Nonneg_10602(c: real)\n ensures (if c >= 0 then c else -c) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_10603","instance":10603,"id":180602,"goal":"lemma DivMod_10603(b: int, c: int)\n requires c > 0\n ensures b == c * (b / c) + (b % c)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_10604","instance":10604,"id":180603,"goal":"lemma ModBounds_10604(j: nat, i: nat)\n requires i > 0\n ensures 0 <= j % i < i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_10605","instance":10605,"id":180604,"goal":"lemma Square_Nonneg_10605(m: real)\n ensures m * m >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_10606","instance":10606,"id":180605,"goal":"lemma AddComm_10606(x: int, m: int)\n ensures x + m == m + x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_10607","instance":10607,"id":180606,"goal":"lemma AddAssoc_10607(m: nat, x: nat, c: nat)\n ensures (m + x) + c == m + (x + c)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_10608","instance":10608,"id":180607,"goal":"lemma MulComm_10608(a: real, x: real)\n ensures a * x == x * a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_10609","instance":10609,"id":180608,"goal":"lemma MulAssoc_10609(i: int, n: int, m: int)\n ensures (i * n) * m == i * (n * m)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_10610","instance":10610,"id":180609,"goal":"lemma Distrib_10610(a: nat, z: nat, x: nat)\n ensures a * (z + x) == a * z + a * x\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_10611","instance":10611,"id":180610,"goal":"lemma AddZero_10611(i: real)\n ensures i + 0 == i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_10612","instance":10612,"id":180611,"goal":"lemma MulOne_10612(c: int)\n ensures c * 1 == c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_10613","instance":10613,"id":180612,"goal":"lemma MulZero_10613(b: nat)\n ensures b * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_10614","instance":10614,"id":180613,"goal":"lemma LeRefl_10614(c: real)\n ensures c <= c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_10615","instance":10615,"id":180614,"goal":"lemma LeTrans_10615(d: int, m: int, n: int)\n requires d <= m && m <= n\n ensures d <= n\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_10616","instance":10616,"id":180615,"goal":"lemma AddMono_10616(n: nat, a: nat, d: nat)\n requires n <= a\n ensures n + d <= a + d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_10617","instance":10617,"id":180616,"goal":"lemma Abs_Nonneg_10617(a: real)\n ensures (if a >= 0 then a else -a) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_10618","instance":10618,"id":180617,"goal":"lemma DivMod_10618(k: int, y: int)\n requires y > 0\n ensures k == y * (k / y) + (k % y)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_10619","instance":10619,"id":180618,"goal":"lemma ModBounds_10619(n: nat, a: nat)\n requires a > 0\n ensures 0 <= n % a < a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_10620","instance":10620,"id":180619,"goal":"lemma Square_Nonneg_10620(x: real)\n ensures x * x >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_10621","instance":10621,"id":180620,"goal":"lemma AddComm_10621(d: int, x: int)\n ensures d + x == x + d\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_10622","instance":10622,"id":180621,"goal":"lemma AddAssoc_10622(a: nat, b: nat, y: nat)\n ensures (a + b) + y == a + (b + y)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_10623","instance":10623,"id":180622,"goal":"lemma MulComm_10623(d: real, x: real)\n ensures d * x == x * d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_10624","instance":10624,"id":180623,"goal":"lemma MulAssoc_10624(b: int, j: int, z: int)\n ensures (b * j) * z == b * (j * z)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_10625","instance":10625,"id":180624,"goal":"lemma Distrib_10625(i: nat, d: nat, m: nat)\n ensures i * (d + m) == i * d + i * m\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_10626","instance":10626,"id":180625,"goal":"lemma AddZero_10626(n: real)\n ensures n + 0 == n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_10627","instance":10627,"id":180626,"goal":"lemma MulOne_10627(z: int)\n ensures z * 1 == z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_10628","instance":10628,"id":180627,"goal":"lemma MulZero_10628(z: nat)\n ensures z * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_10629","instance":10629,"id":180628,"goal":"lemma LeRefl_10629(j: real)\n ensures j <= j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_10630","instance":10630,"id":180629,"goal":"lemma LeTrans_10630(y: int, m: int, x: int)\n requires y <= m && m <= x\n ensures y <= x\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_10631","instance":10631,"id":180630,"goal":"lemma AddMono_10631(n: nat, i: nat, d: nat)\n requires n <= i\n ensures n + d <= i + d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_10632","instance":10632,"id":180631,"goal":"lemma Abs_Nonneg_10632(d: real)\n ensures (if d >= 0 then d else -d) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_10633","instance":10633,"id":180632,"goal":"lemma DivMod_10633(j: int, a: int)\n requires a > 0\n ensures j == a * (j / a) + (j % a)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_10634","instance":10634,"id":180633,"goal":"lemma ModBounds_10634(j: nat, b: nat)\n requires b > 0\n ensures 0 <= j % b < b\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_10635","instance":10635,"id":180634,"goal":"lemma Square_Nonneg_10635(d: real)\n ensures d * d >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_10636","instance":10636,"id":180635,"goal":"lemma AddComm_10636(d: int, k: int)\n ensures d + k == k + d\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_10637","instance":10637,"id":180636,"goal":"lemma AddAssoc_10637(m: nat, d: nat, c: nat)\n ensures (m + d) + c == m + (d + c)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_10638","instance":10638,"id":180637,"goal":"lemma MulComm_10638(m: real, i: real)\n ensures m * i == i * m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_10639","instance":10639,"id":180638,"goal":"lemma MulAssoc_10639(m: int, x: int, j: int)\n ensures (m * x) * j == m * (x * j)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_10640","instance":10640,"id":180639,"goal":"lemma Distrib_10640(j: nat, b: nat, i: nat)\n ensures j * (b + i) == j * b + j * i\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_10641","instance":10641,"id":180640,"goal":"lemma AddZero_10641(i: real)\n ensures i + 0 == i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_10642","instance":10642,"id":180641,"goal":"lemma MulOne_10642(x: int)\n ensures x * 1 == x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_10643","instance":10643,"id":180642,"goal":"lemma MulZero_10643(d: nat)\n ensures d * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_10644","instance":10644,"id":180643,"goal":"lemma LeRefl_10644(j: real)\n ensures j <= j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_10645","instance":10645,"id":180644,"goal":"lemma LeTrans_10645(k: int, j: int, y: int)\n requires k <= j && j <= y\n ensures k <= y\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_10646","instance":10646,"id":180645,"goal":"lemma AddMono_10646(m: nat, a: nat, c: nat)\n requires m <= a\n ensures m + c <= a + c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_10647","instance":10647,"id":180646,"goal":"lemma Abs_Nonneg_10647(k: real)\n ensures (if k >= 0 then k else -k) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_10648","instance":10648,"id":180647,"goal":"lemma DivMod_10648(c: int, m: int)\n requires m > 0\n ensures c == m * (c / m) + (c % m)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_10649","instance":10649,"id":180648,"goal":"lemma ModBounds_10649(m: nat, n: nat)\n requires n > 0\n ensures 0 <= m % n < n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_10650","instance":10650,"id":180649,"goal":"lemma Square_Nonneg_10650(b: real)\n ensures b * b >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_10651","instance":10651,"id":180650,"goal":"lemma AddComm_10651(i: int, d: int)\n ensures i + d == d + i\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_10652","instance":10652,"id":180651,"goal":"lemma AddAssoc_10652(z: nat, x: nat, n: nat)\n ensures (z + x) + n == z + (x + n)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_10653","instance":10653,"id":180652,"goal":"lemma MulComm_10653(i: real, a: real)\n ensures i * a == a * i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_10654","instance":10654,"id":180653,"goal":"lemma MulAssoc_10654(z: int, j: int, x: int)\n ensures (z * j) * x == z * (j * x)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_10655","instance":10655,"id":180654,"goal":"lemma Distrib_10655(n: nat, d: nat, x: nat)\n ensures n * (d + x) == n * d + n * x\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_10656","instance":10656,"id":180655,"goal":"lemma AddZero_10656(c: real)\n ensures c + 0 == c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_10657","instance":10657,"id":180656,"goal":"lemma MulOne_10657(n: int)\n ensures n * 1 == n\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_10658","instance":10658,"id":180657,"goal":"lemma MulZero_10658(m: nat)\n ensures m * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_10659","instance":10659,"id":180658,"goal":"lemma LeRefl_10659(m: real)\n ensures m <= m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_10660","instance":10660,"id":180659,"goal":"lemma LeTrans_10660(j: int, b: int, d: int)\n requires j <= b && b <= d\n ensures j <= d\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_10661","instance":10661,"id":180660,"goal":"lemma AddMono_10661(m: nat, k: nat, y: nat)\n requires m <= k\n ensures m + y <= k + y\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_10662","instance":10662,"id":180661,"goal":"lemma Abs_Nonneg_10662(k: real)\n ensures (if k >= 0 then k else -k) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_10663","instance":10663,"id":180662,"goal":"lemma DivMod_10663(d: int, x: int)\n requires x > 0\n ensures d == x * (d / x) + (d % x)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_10664","instance":10664,"id":180663,"goal":"lemma ModBounds_10664(b: nat, k: nat)\n requires k > 0\n ensures 0 <= b % k < k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_10665","instance":10665,"id":180664,"goal":"lemma Square_Nonneg_10665(i: real)\n ensures i * i >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_10666","instance":10666,"id":180665,"goal":"lemma AddComm_10666(d: int, c: int)\n ensures d + c == c + d\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_10667","instance":10667,"id":180666,"goal":"lemma AddAssoc_10667(y: nat, k: nat, c: nat)\n ensures (y + k) + c == y + (k + c)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_10668","instance":10668,"id":180667,"goal":"lemma MulComm_10668(z: real, i: real)\n ensures z * i == i * z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_10669","instance":10669,"id":180668,"goal":"lemma MulAssoc_10669(m: int, d: int, z: int)\n ensures (m * d) * z == m * (d * z)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_10670","instance":10670,"id":180669,"goal":"lemma Distrib_10670(b: nat, i: nat, m: nat)\n ensures b * (i + m) == b * i + b * m\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_10671","instance":10671,"id":180670,"goal":"lemma AddZero_10671(y: real)\n ensures y + 0 == y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_10672","instance":10672,"id":180671,"goal":"lemma MulOne_10672(m: int)\n ensures m * 1 == m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_10673","instance":10673,"id":180672,"goal":"lemma MulZero_10673(b: nat)\n ensures b * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_10674","instance":10674,"id":180673,"goal":"lemma LeRefl_10674(i: real)\n ensures i <= i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_10675","instance":10675,"id":180674,"goal":"lemma LeTrans_10675(k: int, j: int, m: int)\n requires k <= j && j <= m\n ensures k <= m\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_10676","instance":10676,"id":180675,"goal":"lemma AddMono_10676(n: nat, a: nat, x: nat)\n requires n <= a\n ensures n + x <= a + x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_10677","instance":10677,"id":180676,"goal":"lemma Abs_Nonneg_10677(m: real)\n ensures (if m >= 0 then m else -m) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_10678","instance":10678,"id":180677,"goal":"lemma DivMod_10678(y: int, j: int)\n requires j > 0\n ensures y == j * (y / j) + (y % j)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_10679","instance":10679,"id":180678,"goal":"lemma ModBounds_10679(b: nat, c: nat)\n requires c > 0\n ensures 0 <= b % c < c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_10680","instance":10680,"id":180679,"goal":"lemma Square_Nonneg_10680(i: real)\n ensures i * i >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_10681","instance":10681,"id":180680,"goal":"lemma AddComm_10681(i: int, c: int)\n ensures i + c == c + i\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_10682","instance":10682,"id":180681,"goal":"lemma AddAssoc_10682(m: nat, x: nat, c: nat)\n ensures (m + x) + c == m + (x + c)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_10683","instance":10683,"id":180682,"goal":"lemma MulComm_10683(b: real, z: real)\n ensures b * z == z * b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_10684","instance":10684,"id":180683,"goal":"lemma MulAssoc_10684(m: int, j: int, n: int)\n ensures (m * j) * n == m * (j * n)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_10685","instance":10685,"id":180684,"goal":"lemma Distrib_10685(x: nat, j: nat, z: nat)\n ensures x * (j + z) == x * j + x * z\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_10686","instance":10686,"id":180685,"goal":"lemma AddZero_10686(b: real)\n ensures b + 0 == b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_10687","instance":10687,"id":180686,"goal":"lemma MulOne_10687(x: int)\n ensures x * 1 == x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_10688","instance":10688,"id":180687,"goal":"lemma MulZero_10688(y: nat)\n ensures y * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_10689","instance":10689,"id":180688,"goal":"lemma LeRefl_10689(c: real)\n ensures c <= c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_10690","instance":10690,"id":180689,"goal":"lemma LeTrans_10690(m: int, j: int, b: int)\n requires m <= j && j <= b\n ensures m <= b\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_10691","instance":10691,"id":180690,"goal":"lemma AddMono_10691(j: nat, n: nat, c: nat)\n requires j <= n\n ensures j + c <= n + c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_10692","instance":10692,"id":180691,"goal":"lemma Abs_Nonneg_10692(c: real)\n ensures (if c >= 0 then c else -c) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_10693","instance":10693,"id":180692,"goal":"lemma DivMod_10693(m: int, b: int)\n requires b > 0\n ensures m == b * (m / b) + (m % b)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_10694","instance":10694,"id":180693,"goal":"lemma ModBounds_10694(k: nat, d: nat)\n requires d > 0\n ensures 0 <= k % d < d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_10695","instance":10695,"id":180694,"goal":"lemma Square_Nonneg_10695(m: real)\n ensures m * m >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_10696","instance":10696,"id":180695,"goal":"lemma AddComm_10696(c: int, n: int)\n ensures c + n == n + c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_10697","instance":10697,"id":180696,"goal":"lemma AddAssoc_10697(z: nat, y: nat, a: nat)\n ensures (z + y) + a == z + (y + a)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_10698","instance":10698,"id":180697,"goal":"lemma MulComm_10698(k: real, j: real)\n ensures k * j == j * k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_10699","instance":10699,"id":180698,"goal":"lemma MulAssoc_10699(n: int, d: int, i: int)\n ensures (n * d) * i == n * (d * i)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_10700","instance":10700,"id":180699,"goal":"lemma Distrib_10700(c: nat, k: nat, n: nat)\n ensures c * (k + n) == c * k + c * n\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_10701","instance":10701,"id":180700,"goal":"lemma AddZero_10701(i: real)\n ensures i + 0 == i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_10702","instance":10702,"id":180701,"goal":"lemma MulOne_10702(j: int)\n ensures j * 1 == j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_10703","instance":10703,"id":180702,"goal":"lemma MulZero_10703(c: nat)\n ensures c * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_10704","instance":10704,"id":180703,"goal":"lemma LeRefl_10704(d: real)\n ensures d <= d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_10705","instance":10705,"id":180704,"goal":"lemma LeTrans_10705(i: int, c: int, k: int)\n requires i <= c && c <= k\n ensures i <= k\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_10706","instance":10706,"id":180705,"goal":"lemma AddMono_10706(n: nat, k: nat, x: nat)\n requires n <= k\n ensures n + x <= k + x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_10707","instance":10707,"id":180706,"goal":"lemma Abs_Nonneg_10707(a: real)\n ensures (if a >= 0 then a else -a) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_10708","instance":10708,"id":180707,"goal":"lemma DivMod_10708(x: int, m: int)\n requires m > 0\n ensures x == m * (x / m) + (x % m)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_10709","instance":10709,"id":180708,"goal":"lemma ModBounds_10709(n: nat, a: nat)\n requires a > 0\n ensures 0 <= n % a < a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_10710","instance":10710,"id":180709,"goal":"lemma Square_Nonneg_10710(b: real)\n ensures b * b >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_10711","instance":10711,"id":180710,"goal":"lemma AddComm_10711(x: int, a: int)\n ensures x + a == a + x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_10712","instance":10712,"id":180711,"goal":"lemma AddAssoc_10712(z: nat, x: nat, d: nat)\n ensures (z + x) + d == z + (x + d)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_10713","instance":10713,"id":180712,"goal":"lemma MulComm_10713(d: real, j: real)\n ensures d * j == j * d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_10714","instance":10714,"id":180713,"goal":"lemma MulAssoc_10714(c: int, d: int, n: int)\n ensures (c * d) * n == c * (d * n)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_10715","instance":10715,"id":180714,"goal":"lemma Distrib_10715(c: nat, k: nat, x: nat)\n ensures c * (k + x) == c * k + c * x\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_10716","instance":10716,"id":180715,"goal":"lemma AddZero_10716(m: real)\n ensures m + 0 == m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_10717","instance":10717,"id":180716,"goal":"lemma MulOne_10717(d: int)\n ensures d * 1 == d\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_10718","instance":10718,"id":180717,"goal":"lemma MulZero_10718(i: nat)\n ensures i * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_10719","instance":10719,"id":180718,"goal":"lemma LeRefl_10719(c: real)\n ensures c <= c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_10720","instance":10720,"id":180719,"goal":"lemma LeTrans_10720(k: int, d: int, y: int)\n requires k <= d && d <= y\n ensures k <= y\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_10721","instance":10721,"id":180720,"goal":"lemma AddMono_10721(i: nat, b: nat, z: nat)\n requires i <= b\n ensures i + z <= b + z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_10722","instance":10722,"id":180721,"goal":"lemma Abs_Nonneg_10722(k: real)\n ensures (if k >= 0 then k else -k) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_10723","instance":10723,"id":180722,"goal":"lemma DivMod_10723(a: int, z: int)\n requires z > 0\n ensures a == z * (a / z) + (a % z)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_10724","instance":10724,"id":180723,"goal":"lemma ModBounds_10724(m: nat, d: nat)\n requires d > 0\n ensures 0 <= m % d < d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_10725","instance":10725,"id":180724,"goal":"lemma Square_Nonneg_10725(m: real)\n ensures m * m >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_10726","instance":10726,"id":180725,"goal":"lemma AddComm_10726(d: int, m: int)\n ensures d + m == m + d\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_10727","instance":10727,"id":180726,"goal":"lemma AddAssoc_10727(z: nat, d: nat, x: nat)\n ensures (z + d) + x == z + (d + x)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_10728","instance":10728,"id":180727,"goal":"lemma MulComm_10728(j: real, n: real)\n ensures j * n == n * j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_10729","instance":10729,"id":180728,"goal":"lemma MulAssoc_10729(z: int, i: int, k: int)\n ensures (z * i) * k == z * (i * k)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_10730","instance":10730,"id":180729,"goal":"lemma Distrib_10730(j: nat, x: nat, k: nat)\n ensures j * (x + k) == j * x + j * k\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_10731","instance":10731,"id":180730,"goal":"lemma AddZero_10731(y: real)\n ensures y + 0 == y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_10732","instance":10732,"id":180731,"goal":"lemma MulOne_10732(x: int)\n ensures x * 1 == x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_10733","instance":10733,"id":180732,"goal":"lemma MulZero_10733(n: nat)\n ensures n * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_10734","instance":10734,"id":180733,"goal":"lemma LeRefl_10734(z: real)\n ensures z <= z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_10735","instance":10735,"id":180734,"goal":"lemma LeTrans_10735(x: int, k: int, z: int)\n requires x <= k && k <= z\n ensures x <= z\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_10736","instance":10736,"id":180735,"goal":"lemma AddMono_10736(y: nat, a: nat, d: nat)\n requires y <= a\n ensures y + d <= a + d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_10737","instance":10737,"id":180736,"goal":"lemma Abs_Nonneg_10737(a: real)\n ensures (if a >= 0 then a else -a) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_10738","instance":10738,"id":180737,"goal":"lemma DivMod_10738(n: int, d: int)\n requires d > 0\n ensures n == d * (n / d) + (n % d)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_10739","instance":10739,"id":180738,"goal":"lemma ModBounds_10739(z: nat, k: nat)\n requires k > 0\n ensures 0 <= z % k < k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_10740","instance":10740,"id":180739,"goal":"lemma Square_Nonneg_10740(d: real)\n ensures d * d >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_10741","instance":10741,"id":180740,"goal":"lemma AddComm_10741(j: int, b: int)\n ensures j + b == b + j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_10742","instance":10742,"id":180741,"goal":"lemma AddAssoc_10742(j: nat, a: nat, y: nat)\n ensures (j + a) + y == j + (a + y)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_10743","instance":10743,"id":180742,"goal":"lemma MulComm_10743(m: real, x: real)\n ensures m * x == x * m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_10744","instance":10744,"id":180743,"goal":"lemma MulAssoc_10744(z: int, x: int, i: int)\n ensures (z * x) * i == z * (x * i)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_10745","instance":10745,"id":180744,"goal":"lemma Distrib_10745(y: nat, n: nat, b: nat)\n ensures y * (n + b) == y * n + y * b\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_10746","instance":10746,"id":180745,"goal":"lemma AddZero_10746(i: real)\n ensures i + 0 == i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_10747","instance":10747,"id":180746,"goal":"lemma MulOne_10747(k: int)\n ensures k * 1 == k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_10748","instance":10748,"id":180747,"goal":"lemma MulZero_10748(x: nat)\n ensures x * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_10749","instance":10749,"id":180748,"goal":"lemma LeRefl_10749(x: real)\n ensures x <= x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_10750","instance":10750,"id":180749,"goal":"lemma LeTrans_10750(k: int, c: int, d: int)\n requires k <= c && c <= d\n ensures k <= d\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_10751","instance":10751,"id":180750,"goal":"lemma AddMono_10751(m: nat, z: nat, i: nat)\n requires m <= z\n ensures m + i <= z + i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_10752","instance":10752,"id":180751,"goal":"lemma Abs_Nonneg_10752(j: real)\n ensures (if j >= 0 then j else -j) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_10753","instance":10753,"id":180752,"goal":"lemma DivMod_10753(a: int, d: int)\n requires d > 0\n ensures a == d * (a / d) + (a % d)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_10754","instance":10754,"id":180753,"goal":"lemma ModBounds_10754(b: nat, k: nat)\n requires k > 0\n ensures 0 <= b % k < k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_10755","instance":10755,"id":180754,"goal":"lemma Square_Nonneg_10755(m: real)\n ensures m * m >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_10756","instance":10756,"id":180755,"goal":"lemma AddComm_10756(n: int, j: int)\n ensures n + j == j + n\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_10757","instance":10757,"id":180756,"goal":"lemma AddAssoc_10757(n: nat, j: nat, x: nat)\n ensures (n + j) + x == n + (j + x)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_10758","instance":10758,"id":180757,"goal":"lemma MulComm_10758(k: real, j: real)\n ensures k * j == j * k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_10759","instance":10759,"id":180758,"goal":"lemma MulAssoc_10759(x: int, c: int, m: int)\n ensures (x * c) * m == x * (c * m)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_10760","instance":10760,"id":180759,"goal":"lemma Distrib_10760(z: nat, k: nat, x: nat)\n ensures z * (k + x) == z * k + z * x\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_10761","instance":10761,"id":180760,"goal":"lemma AddZero_10761(d: real)\n ensures d + 0 == d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_10762","instance":10762,"id":180761,"goal":"lemma MulOne_10762(j: int)\n ensures j * 1 == j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_10763","instance":10763,"id":180762,"goal":"lemma MulZero_10763(c: nat)\n ensures c * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_10764","instance":10764,"id":180763,"goal":"lemma LeRefl_10764(y: real)\n ensures y <= y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_10765","instance":10765,"id":180764,"goal":"lemma LeTrans_10765(j: int, a: int, y: int)\n requires j <= a && a <= y\n ensures j <= y\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_10766","instance":10766,"id":180765,"goal":"lemma AddMono_10766(y: nat, n: nat, a: nat)\n requires y <= n\n ensures y + a <= n + a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_10767","instance":10767,"id":180766,"goal":"lemma Abs_Nonneg_10767(k: real)\n ensures (if k >= 0 then k else -k) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_10768","instance":10768,"id":180767,"goal":"lemma DivMod_10768(z: int, d: int)\n requires d > 0\n ensures z == d * (z / d) + (z % d)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_10769","instance":10769,"id":180768,"goal":"lemma ModBounds_10769(m: nat, z: nat)\n requires z > 0\n ensures 0 <= m % z < z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_10770","instance":10770,"id":180769,"goal":"lemma Square_Nonneg_10770(c: real)\n ensures c * c >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_10771","instance":10771,"id":180770,"goal":"lemma AddComm_10771(b: int, d: int)\n ensures b + d == d + b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_10772","instance":10772,"id":180771,"goal":"lemma AddAssoc_10772(i: nat, a: nat, b: nat)\n ensures (i + a) + b == i + (a + b)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_10773","instance":10773,"id":180772,"goal":"lemma MulComm_10773(k: real, y: real)\n ensures k * y == y * k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_10774","instance":10774,"id":180773,"goal":"lemma MulAssoc_10774(k: int, j: int, z: int)\n ensures (k * j) * z == k * (j * z)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_10775","instance":10775,"id":180774,"goal":"lemma Distrib_10775(x: nat, a: nat, i: nat)\n ensures x * (a + i) == x * a + x * i\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_10776","instance":10776,"id":180775,"goal":"lemma AddZero_10776(a: real)\n ensures a + 0 == a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_10777","instance":10777,"id":180776,"goal":"lemma MulOne_10777(i: int)\n ensures i * 1 == i\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_10778","instance":10778,"id":180777,"goal":"lemma MulZero_10778(m: nat)\n ensures m * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_10779","instance":10779,"id":180778,"goal":"lemma LeRefl_10779(z: real)\n ensures z <= z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_10780","instance":10780,"id":180779,"goal":"lemma LeTrans_10780(y: int, n: int, x: int)\n requires y <= n && n <= x\n ensures y <= x\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_10781","instance":10781,"id":180780,"goal":"lemma AddMono_10781(n: nat, c: nat, y: nat)\n requires n <= c\n ensures n + y <= c + y\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_10782","instance":10782,"id":180781,"goal":"lemma Abs_Nonneg_10782(b: real)\n ensures (if b >= 0 then b else -b) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_10783","instance":10783,"id":180782,"goal":"lemma DivMod_10783(y: int, b: int)\n requires b > 0\n ensures y == b * (y / b) + (y % b)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_10784","instance":10784,"id":180783,"goal":"lemma ModBounds_10784(x: nat, d: nat)\n requires d > 0\n ensures 0 <= x % d < d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_10785","instance":10785,"id":180784,"goal":"lemma Square_Nonneg_10785(n: real)\n ensures n * n >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_10786","instance":10786,"id":180785,"goal":"lemma AddComm_10786(m: int, c: int)\n ensures m + c == c + m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_10787","instance":10787,"id":180786,"goal":"lemma AddAssoc_10787(d: nat, j: nat, y: nat)\n ensures (d + j) + y == d + (j + y)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_10788","instance":10788,"id":180787,"goal":"lemma MulComm_10788(c: real, y: real)\n ensures c * y == y * c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_10789","instance":10789,"id":180788,"goal":"lemma MulAssoc_10789(y: int, b: int, x: int)\n ensures (y * b) * x == y * (b * x)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_10790","instance":10790,"id":180789,"goal":"lemma Distrib_10790(y: nat, z: nat, j: nat)\n ensures y * (z + j) == y * z + y * j\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_10791","instance":10791,"id":180790,"goal":"lemma AddZero_10791(b: real)\n ensures b + 0 == b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_10792","instance":10792,"id":180791,"goal":"lemma MulOne_10792(a: int)\n ensures a * 1 == a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_10793","instance":10793,"id":180792,"goal":"lemma MulZero_10793(b: nat)\n ensures b * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_10794","instance":10794,"id":180793,"goal":"lemma LeRefl_10794(y: real)\n ensures y <= y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_10795","instance":10795,"id":180794,"goal":"lemma LeTrans_10795(k: int, j: int, c: int)\n requires k <= j && j <= c\n ensures k <= c\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_10796","instance":10796,"id":180795,"goal":"lemma AddMono_10796(j: nat, m: nat, c: nat)\n requires j <= m\n ensures j + c <= m + c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_10797","instance":10797,"id":180796,"goal":"lemma Abs_Nonneg_10797(a: real)\n ensures (if a >= 0 then a else -a) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_10798","instance":10798,"id":180797,"goal":"lemma DivMod_10798(b: int, z: int)\n requires z > 0\n ensures b == z * (b / z) + (b % z)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_10799","instance":10799,"id":180798,"goal":"lemma ModBounds_10799(k: nat, y: nat)\n requires y > 0\n ensures 0 <= k % y < y\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_10800","instance":10800,"id":180799,"goal":"lemma Square_Nonneg_10800(j: real)\n ensures j * j >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_10801","instance":10801,"id":180800,"goal":"lemma AddComm_10801(m: int, d: int)\n ensures m + d == d + m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_10802","instance":10802,"id":180801,"goal":"lemma AddAssoc_10802(b: nat, k: nat, a: nat)\n ensures (b + k) + a == b + (k + a)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_10803","instance":10803,"id":180802,"goal":"lemma MulComm_10803(j: real, d: real)\n ensures j * d == d * j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_10804","instance":10804,"id":180803,"goal":"lemma MulAssoc_10804(k: int, y: int, z: int)\n ensures (k * y) * z == k * (y * z)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_10805","instance":10805,"id":180804,"goal":"lemma Distrib_10805(c: nat, x: nat, a: nat)\n ensures c * (x + a) == c * x + c * a\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_10806","instance":10806,"id":180805,"goal":"lemma AddZero_10806(b: real)\n ensures b + 0 == b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_10807","instance":10807,"id":180806,"goal":"lemma MulOne_10807(c: int)\n ensures c * 1 == c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_10808","instance":10808,"id":180807,"goal":"lemma MulZero_10808(c: nat)\n ensures c * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_10809","instance":10809,"id":180808,"goal":"lemma LeRefl_10809(z: real)\n ensures z <= z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_10810","instance":10810,"id":180809,"goal":"lemma LeTrans_10810(j: int, n: int, k: int)\n requires j <= n && n <= k\n ensures j <= k\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_10811","instance":10811,"id":180810,"goal":"lemma AddMono_10811(x: nat, c: nat, b: nat)\n requires x <= c\n ensures x + b <= c + b\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_10812","instance":10812,"id":180811,"goal":"lemma Abs_Nonneg_10812(c: real)\n ensures (if c >= 0 then c else -c) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_10813","instance":10813,"id":180812,"goal":"lemma DivMod_10813(n: int, x: int)\n requires x > 0\n ensures n == x * (n / x) + (n % x)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_10814","instance":10814,"id":180813,"goal":"lemma ModBounds_10814(k: nat, i: nat)\n requires i > 0\n ensures 0 <= k % i < i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_10815","instance":10815,"id":180814,"goal":"lemma Square_Nonneg_10815(b: real)\n ensures b * b >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_10816","instance":10816,"id":180815,"goal":"lemma AddComm_10816(i: int, n: int)\n ensures i + n == n + i\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_10817","instance":10817,"id":180816,"goal":"lemma AddAssoc_10817(z: nat, i: nat, k: nat)\n ensures (z + i) + k == z + (i + k)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_10818","instance":10818,"id":180817,"goal":"lemma MulComm_10818(c: real, m: real)\n ensures c * m == m * c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_10819","instance":10819,"id":180818,"goal":"lemma MulAssoc_10819(j: int, c: int, y: int)\n ensures (j * c) * y == j * (c * y)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_10820","instance":10820,"id":180819,"goal":"lemma Distrib_10820(b: nat, d: nat, z: nat)\n ensures b * (d + z) == b * d + b * z\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_10821","instance":10821,"id":180820,"goal":"lemma AddZero_10821(j: real)\n ensures j + 0 == j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_10822","instance":10822,"id":180821,"goal":"lemma MulOne_10822(i: int)\n ensures i * 1 == i\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_10823","instance":10823,"id":180822,"goal":"lemma MulZero_10823(d: nat)\n ensures d * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_10824","instance":10824,"id":180823,"goal":"lemma LeRefl_10824(x: real)\n ensures x <= x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_10825","instance":10825,"id":180824,"goal":"lemma LeTrans_10825(y: int, m: int, n: int)\n requires y <= m && m <= n\n ensures y <= n\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_10826","instance":10826,"id":180825,"goal":"lemma AddMono_10826(k: nat, x: nat, z: nat)\n requires k <= x\n ensures k + z <= x + z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_10827","instance":10827,"id":180826,"goal":"lemma Abs_Nonneg_10827(m: real)\n ensures (if m >= 0 then m else -m) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_10828","instance":10828,"id":180827,"goal":"lemma DivMod_10828(i: int, m: int)\n requires m > 0\n ensures i == m * (i / m) + (i % m)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_10829","instance":10829,"id":180828,"goal":"lemma ModBounds_10829(i: nat, j: nat)\n requires j > 0\n ensures 0 <= i % j < j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_10830","instance":10830,"id":180829,"goal":"lemma Square_Nonneg_10830(j: real)\n ensures j * j >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_10831","instance":10831,"id":180830,"goal":"lemma AddComm_10831(z: int, c: int)\n ensures z + c == c + z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_10832","instance":10832,"id":180831,"goal":"lemma AddAssoc_10832(c: nat, n: nat, i: nat)\n ensures (c + n) + i == c + (n + i)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_10833","instance":10833,"id":180832,"goal":"lemma MulComm_10833(c: real, i: real)\n ensures c * i == i * c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_10834","instance":10834,"id":180833,"goal":"lemma MulAssoc_10834(k: int, d: int, b: int)\n ensures (k * d) * b == k * (d * b)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_10835","instance":10835,"id":180834,"goal":"lemma Distrib_10835(b: nat, k: nat, m: nat)\n ensures b * (k + m) == b * k + b * m\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_10836","instance":10836,"id":180835,"goal":"lemma AddZero_10836(j: real)\n ensures j + 0 == j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_10837","instance":10837,"id":180836,"goal":"lemma MulOne_10837(k: int)\n ensures k * 1 == k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_10838","instance":10838,"id":180837,"goal":"lemma MulZero_10838(z: nat)\n ensures z * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_10839","instance":10839,"id":180838,"goal":"lemma LeRefl_10839(c: real)\n ensures c <= c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_10840","instance":10840,"id":180839,"goal":"lemma LeTrans_10840(j: int, i: int, x: int)\n requires j <= i && i <= x\n ensures j <= x\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_10841","instance":10841,"id":180840,"goal":"lemma AddMono_10841(n: nat, i: nat, z: nat)\n requires n <= i\n ensures n + z <= i + z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_10842","instance":10842,"id":180841,"goal":"lemma Abs_Nonneg_10842(c: real)\n ensures (if c >= 0 then c else -c) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_10843","instance":10843,"id":180842,"goal":"lemma DivMod_10843(d: int, a: int)\n requires a > 0\n ensures d == a * (d / a) + (d % a)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_10844","instance":10844,"id":180843,"goal":"lemma ModBounds_10844(c: nat, z: nat)\n requires z > 0\n ensures 0 <= c % z < z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_10845","instance":10845,"id":180844,"goal":"lemma Square_Nonneg_10845(c: real)\n ensures c * c >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_10846","instance":10846,"id":180845,"goal":"lemma AddComm_10846(m: int, z: int)\n ensures m + z == z + m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_10847","instance":10847,"id":180846,"goal":"lemma AddAssoc_10847(m: nat, n: nat, i: nat)\n ensures (m + n) + i == m + (n + i)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_10848","instance":10848,"id":180847,"goal":"lemma MulComm_10848(z: real, b: real)\n ensures z * b == b * z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_10849","instance":10849,"id":180848,"goal":"lemma MulAssoc_10849(x: int, n: int, a: int)\n ensures (x * n) * a == x * (n * a)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_10850","instance":10850,"id":180849,"goal":"lemma Distrib_10850(a: nat, b: nat, x: nat)\n ensures a * (b + x) == a * b + a * x\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_10851","instance":10851,"id":180850,"goal":"lemma AddZero_10851(k: real)\n ensures k + 0 == k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_10852","instance":10852,"id":180851,"goal":"lemma MulOne_10852(c: int)\n ensures c * 1 == c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_10853","instance":10853,"id":180852,"goal":"lemma MulZero_10853(x: nat)\n ensures x * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_10854","instance":10854,"id":180853,"goal":"lemma LeRefl_10854(k: real)\n ensures k <= k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_10855","instance":10855,"id":180854,"goal":"lemma LeTrans_10855(a: int, i: int, j: int)\n requires a <= i && i <= j\n ensures a <= j\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_10856","instance":10856,"id":180855,"goal":"lemma AddMono_10856(z: nat, d: nat, x: nat)\n requires z <= d\n ensures z + x <= d + x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_10857","instance":10857,"id":180856,"goal":"lemma Abs_Nonneg_10857(k: real)\n ensures (if k >= 0 then k else -k) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_10858","instance":10858,"id":180857,"goal":"lemma DivMod_10858(k: int, a: int)\n requires a > 0\n ensures k == a * (k / a) + (k % a)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_10859","instance":10859,"id":180858,"goal":"lemma ModBounds_10859(y: nat, a: nat)\n requires a > 0\n ensures 0 <= y % a < a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_10860","instance":10860,"id":180859,"goal":"lemma Square_Nonneg_10860(z: real)\n ensures z * z >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_10861","instance":10861,"id":180860,"goal":"lemma AddComm_10861(n: int, x: int)\n ensures n + x == x + n\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_10862","instance":10862,"id":180861,"goal":"lemma AddAssoc_10862(c: nat, a: nat, b: nat)\n ensures (c + a) + b == c + (a + b)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_10863","instance":10863,"id":180862,"goal":"lemma MulComm_10863(k: real, n: real)\n ensures k * n == n * k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_10864","instance":10864,"id":180863,"goal":"lemma MulAssoc_10864(d: int, b: int, y: int)\n ensures (d * b) * y == d * (b * y)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_10865","instance":10865,"id":180864,"goal":"lemma Distrib_10865(a: nat, n: nat, i: nat)\n ensures a * (n + i) == a * n + a * i\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_10866","instance":10866,"id":180865,"goal":"lemma AddZero_10866(b: real)\n ensures b + 0 == b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_10867","instance":10867,"id":180866,"goal":"lemma MulOne_10867(b: int)\n ensures b * 1 == b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_10868","instance":10868,"id":180867,"goal":"lemma MulZero_10868(m: nat)\n ensures m * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_10869","instance":10869,"id":180868,"goal":"lemma LeRefl_10869(n: real)\n ensures n <= n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_10870","instance":10870,"id":180869,"goal":"lemma LeTrans_10870(d: int, j: int, n: int)\n requires d <= j && j <= n\n ensures d <= n\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_10871","instance":10871,"id":180870,"goal":"lemma AddMono_10871(a: nat, y: nat, x: nat)\n requires a <= y\n ensures a + x <= y + x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_10872","instance":10872,"id":180871,"goal":"lemma Abs_Nonneg_10872(j: real)\n ensures (if j >= 0 then j else -j) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_10873","instance":10873,"id":180872,"goal":"lemma DivMod_10873(b: int, z: int)\n requires z > 0\n ensures b == z * (b / z) + (b % z)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_10874","instance":10874,"id":180873,"goal":"lemma ModBounds_10874(y: nat, x: nat)\n requires x > 0\n ensures 0 <= y % x < x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_10875","instance":10875,"id":180874,"goal":"lemma Square_Nonneg_10875(k: real)\n ensures k * k >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_10876","instance":10876,"id":180875,"goal":"lemma AddComm_10876(x: int, z: int)\n ensures x + z == z + x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_10877","instance":10877,"id":180876,"goal":"lemma AddAssoc_10877(z: nat, j: nat, c: nat)\n ensures (z + j) + c == z + (j + c)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_10878","instance":10878,"id":180877,"goal":"lemma MulComm_10878(b: real, d: real)\n ensures b * d == d * b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_10879","instance":10879,"id":180878,"goal":"lemma MulAssoc_10879(z: int, d: int, m: int)\n ensures (z * d) * m == z * (d * m)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_10880","instance":10880,"id":180879,"goal":"lemma Distrib_10880(k: nat, x: nat, a: nat)\n ensures k * (x + a) == k * x + k * a\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_10881","instance":10881,"id":180880,"goal":"lemma AddZero_10881(d: real)\n ensures d + 0 == d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_10882","instance":10882,"id":180881,"goal":"lemma MulOne_10882(c: int)\n ensures c * 1 == c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_10883","instance":10883,"id":180882,"goal":"lemma MulZero_10883(y: nat)\n ensures y * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_10884","instance":10884,"id":180883,"goal":"lemma LeRefl_10884(a: real)\n ensures a <= a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_10885","instance":10885,"id":180884,"goal":"lemma LeTrans_10885(x: int, j: int, k: int)\n requires x <= j && j <= k\n ensures x <= k\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_10886","instance":10886,"id":180885,"goal":"lemma AddMono_10886(d: nat, a: nat, m: nat)\n requires d <= a\n ensures d + m <= a + m\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_10887","instance":10887,"id":180886,"goal":"lemma Abs_Nonneg_10887(d: real)\n ensures (if d >= 0 then d else -d) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_10888","instance":10888,"id":180887,"goal":"lemma DivMod_10888(c: int, b: int)\n requires b > 0\n ensures c == b * (c / b) + (c % b)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_10889","instance":10889,"id":180888,"goal":"lemma ModBounds_10889(x: nat, b: nat)\n requires b > 0\n ensures 0 <= x % b < b\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_10890","instance":10890,"id":180889,"goal":"lemma Square_Nonneg_10890(c: real)\n ensures c * c >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_10891","instance":10891,"id":180890,"goal":"lemma AddComm_10891(z: int, k: int)\n ensures z + k == k + z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_10892","instance":10892,"id":180891,"goal":"lemma AddAssoc_10892(z: nat, c: nat, x: nat)\n ensures (z + c) + x == z + (c + x)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_10893","instance":10893,"id":180892,"goal":"lemma MulComm_10893(a: real, x: real)\n ensures a * x == x * a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_10894","instance":10894,"id":180893,"goal":"lemma MulAssoc_10894(x: int, k: int, d: int)\n ensures (x * k) * d == x * (k * d)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_10895","instance":10895,"id":180894,"goal":"lemma Distrib_10895(j: nat, i: nat, y: nat)\n ensures j * (i + y) == j * i + j * y\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_10896","instance":10896,"id":180895,"goal":"lemma AddZero_10896(z: real)\n ensures z + 0 == z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_10897","instance":10897,"id":180896,"goal":"lemma MulOne_10897(y: int)\n ensures y * 1 == y\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_10898","instance":10898,"id":180897,"goal":"lemma MulZero_10898(i: nat)\n ensures i * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_10899","instance":10899,"id":180898,"goal":"lemma LeRefl_10899(k: real)\n ensures k <= k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_10900","instance":10900,"id":180899,"goal":"lemma LeTrans_10900(i: int, z: int, j: int)\n requires i <= z && z <= j\n ensures i <= j\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_10901","instance":10901,"id":180900,"goal":"lemma AddMono_10901(y: nat, i: nat, j: nat)\n requires y <= i\n ensures y + j <= i + j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_10902","instance":10902,"id":180901,"goal":"lemma Abs_Nonneg_10902(j: real)\n ensures (if j >= 0 then j else -j) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_10903","instance":10903,"id":180902,"goal":"lemma DivMod_10903(k: int, x: int)\n requires x > 0\n ensures k == x * (k / x) + (k % x)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_10904","instance":10904,"id":180903,"goal":"lemma ModBounds_10904(a: nat, z: nat)\n requires z > 0\n ensures 0 <= a % z < z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_10905","instance":10905,"id":180904,"goal":"lemma Square_Nonneg_10905(z: real)\n ensures z * z >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_10906","instance":10906,"id":180905,"goal":"lemma AddComm_10906(b: int, m: int)\n ensures b + m == m + b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_10907","instance":10907,"id":180906,"goal":"lemma AddAssoc_10907(y: nat, k: nat, c: nat)\n ensures (y + k) + c == y + (k + c)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_10908","instance":10908,"id":180907,"goal":"lemma MulComm_10908(b: real, d: real)\n ensures b * d == d * b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_10909","instance":10909,"id":180908,"goal":"lemma MulAssoc_10909(y: int, n: int, k: int)\n ensures (y * n) * k == y * (n * k)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_10910","instance":10910,"id":180909,"goal":"lemma Distrib_10910(a: nat, y: nat, b: nat)\n ensures a * (y + b) == a * y + a * b\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_10911","instance":10911,"id":180910,"goal":"lemma AddZero_10911(m: real)\n ensures m + 0 == m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_10912","instance":10912,"id":180911,"goal":"lemma MulOne_10912(m: int)\n ensures m * 1 == m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_10913","instance":10913,"id":180912,"goal":"lemma MulZero_10913(b: nat)\n ensures b * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_10914","instance":10914,"id":180913,"goal":"lemma LeRefl_10914(n: real)\n ensures n <= n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_10915","instance":10915,"id":180914,"goal":"lemma LeTrans_10915(j: int, z: int, a: int)\n requires j <= z && z <= a\n ensures j <= a\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_10916","instance":10916,"id":180915,"goal":"lemma AddMono_10916(i: nat, j: nat, y: nat)\n requires i <= j\n ensures i + y <= j + y\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_10917","instance":10917,"id":180916,"goal":"lemma Abs_Nonneg_10917(m: real)\n ensures (if m >= 0 then m else -m) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_10918","instance":10918,"id":180917,"goal":"lemma DivMod_10918(k: int, m: int)\n requires m > 0\n ensures k == m * (k / m) + (k % m)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_10919","instance":10919,"id":180918,"goal":"lemma ModBounds_10919(n: nat, z: nat)\n requires z > 0\n ensures 0 <= n % z < z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_10920","instance":10920,"id":180919,"goal":"lemma Square_Nonneg_10920(z: real)\n ensures z * z >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_10921","instance":10921,"id":180920,"goal":"lemma AddComm_10921(n: int, j: int)\n ensures n + j == j + n\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_10922","instance":10922,"id":180921,"goal":"lemma AddAssoc_10922(z: nat, d: nat, n: nat)\n ensures (z + d) + n == z + (d + n)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_10923","instance":10923,"id":180922,"goal":"lemma MulComm_10923(m: real, z: real)\n ensures m * z == z * m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_10924","instance":10924,"id":180923,"goal":"lemma MulAssoc_10924(m: int, a: int, b: int)\n ensures (m * a) * b == m * (a * b)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_10925","instance":10925,"id":180924,"goal":"lemma Distrib_10925(i: nat, n: nat, c: nat)\n ensures i * (n + c) == i * n + i * c\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_10926","instance":10926,"id":180925,"goal":"lemma AddZero_10926(n: real)\n ensures n + 0 == n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_10927","instance":10927,"id":180926,"goal":"lemma MulOne_10927(n: int)\n ensures n * 1 == n\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_10928","instance":10928,"id":180927,"goal":"lemma MulZero_10928(b: nat)\n ensures b * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_10929","instance":10929,"id":180928,"goal":"lemma LeRefl_10929(b: real)\n ensures b <= b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_10930","instance":10930,"id":180929,"goal":"lemma LeTrans_10930(b: int, y: int, a: int)\n requires b <= y && y <= a\n ensures b <= a\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_10931","instance":10931,"id":180930,"goal":"lemma AddMono_10931(x: nat, j: nat, n: nat)\n requires x <= j\n ensures x + n <= j + n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_10932","instance":10932,"id":180931,"goal":"lemma Abs_Nonneg_10932(d: real)\n ensures (if d >= 0 then d else -d) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_10933","instance":10933,"id":180932,"goal":"lemma DivMod_10933(m: int, c: int)\n requires c > 0\n ensures m == c * (m / c) + (m % c)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_10934","instance":10934,"id":180933,"goal":"lemma ModBounds_10934(b: nat, m: nat)\n requires m > 0\n ensures 0 <= b % m < m\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_10935","instance":10935,"id":180934,"goal":"lemma Square_Nonneg_10935(n: real)\n ensures n * n >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_10936","instance":10936,"id":180935,"goal":"lemma AddComm_10936(y: int, m: int)\n ensures y + m == m + y\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_10937","instance":10937,"id":180936,"goal":"lemma AddAssoc_10937(b: nat, z: nat, k: nat)\n ensures (b + z) + k == b + (z + k)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_10938","instance":10938,"id":180937,"goal":"lemma MulComm_10938(d: real, z: real)\n ensures d * z == z * d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_10939","instance":10939,"id":180938,"goal":"lemma MulAssoc_10939(y: int, m: int, x: int)\n ensures (y * m) * x == y * (m * x)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_10940","instance":10940,"id":180939,"goal":"lemma Distrib_10940(x: nat, i: nat, a: nat)\n ensures x * (i + a) == x * i + x * a\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_10941","instance":10941,"id":180940,"goal":"lemma AddZero_10941(d: real)\n ensures d + 0 == d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_10942","instance":10942,"id":180941,"goal":"lemma MulOne_10942(a: int)\n ensures a * 1 == a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_10943","instance":10943,"id":180942,"goal":"lemma MulZero_10943(i: nat)\n ensures i * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_10944","instance":10944,"id":180943,"goal":"lemma LeRefl_10944(y: real)\n ensures y <= y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_10945","instance":10945,"id":180944,"goal":"lemma LeTrans_10945(z: int, a: int, b: int)\n requires z <= a && a <= b\n ensures z <= b\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_10946","instance":10946,"id":180945,"goal":"lemma AddMono_10946(y: nat, z: nat, i: nat)\n requires y <= z\n ensures y + i <= z + i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_10947","instance":10947,"id":180946,"goal":"lemma Abs_Nonneg_10947(y: real)\n ensures (if y >= 0 then y else -y) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_10948","instance":10948,"id":180947,"goal":"lemma DivMod_10948(i: int, z: int)\n requires z > 0\n ensures i == z * (i / z) + (i % z)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_10949","instance":10949,"id":180948,"goal":"lemma ModBounds_10949(i: nat, a: nat)\n requires a > 0\n ensures 0 <= i % a < a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_10950","instance":10950,"id":180949,"goal":"lemma Square_Nonneg_10950(x: real)\n ensures x * x >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_10951","instance":10951,"id":180950,"goal":"lemma AddComm_10951(k: int, c: int)\n ensures k + c == c + k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_10952","instance":10952,"id":180951,"goal":"lemma AddAssoc_10952(k: nat, y: nat, i: nat)\n ensures (k + y) + i == k + (y + i)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_10953","instance":10953,"id":180952,"goal":"lemma MulComm_10953(j: real, b: real)\n ensures j * b == b * j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_10954","instance":10954,"id":180953,"goal":"lemma MulAssoc_10954(b: int, x: int, i: int)\n ensures (b * x) * i == b * (x * i)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_10955","instance":10955,"id":180954,"goal":"lemma Distrib_10955(j: nat, k: nat, i: nat)\n ensures j * (k + i) == j * k + j * i\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_10956","instance":10956,"id":180955,"goal":"lemma AddZero_10956(x: real)\n ensures x + 0 == x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_10957","instance":10957,"id":180956,"goal":"lemma MulOne_10957(k: int)\n ensures k * 1 == k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_10958","instance":10958,"id":180957,"goal":"lemma MulZero_10958(m: nat)\n ensures m * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_10959","instance":10959,"id":180958,"goal":"lemma LeRefl_10959(m: real)\n ensures m <= m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_10960","instance":10960,"id":180959,"goal":"lemma LeTrans_10960(a: int, d: int, k: int)\n requires a <= d && d <= k\n ensures a <= k\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_10961","instance":10961,"id":180960,"goal":"lemma AddMono_10961(d: nat, i: nat, x: nat)\n requires d <= i\n ensures d + x <= i + x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_10962","instance":10962,"id":180961,"goal":"lemma Abs_Nonneg_10962(j: real)\n ensures (if j >= 0 then j else -j) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_10963","instance":10963,"id":180962,"goal":"lemma DivMod_10963(b: int, z: int)\n requires z > 0\n ensures b == z * (b / z) + (b % z)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_10964","instance":10964,"id":180963,"goal":"lemma ModBounds_10964(b: nat, z: nat)\n requires z > 0\n ensures 0 <= b % z < z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_10965","instance":10965,"id":180964,"goal":"lemma Square_Nonneg_10965(j: real)\n ensures j * j >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_10966","instance":10966,"id":180965,"goal":"lemma AddComm_10966(n: int, b: int)\n ensures n + b == b + n\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_10967","instance":10967,"id":180966,"goal":"lemma AddAssoc_10967(i: nat, k: nat, a: nat)\n ensures (i + k) + a == i + (k + a)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_10968","instance":10968,"id":180967,"goal":"lemma MulComm_10968(j: real, y: real)\n ensures j * y == y * j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_10969","instance":10969,"id":180968,"goal":"lemma MulAssoc_10969(x: int, a: int, c: int)\n ensures (x * a) * c == x * (a * c)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_10970","instance":10970,"id":180969,"goal":"lemma Distrib_10970(n: nat, c: nat, j: nat)\n ensures n * (c + j) == n * c + n * j\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_10971","instance":10971,"id":180970,"goal":"lemma AddZero_10971(i: real)\n ensures i + 0 == i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_10972","instance":10972,"id":180971,"goal":"lemma MulOne_10972(x: int)\n ensures x * 1 == x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_10973","instance":10973,"id":180972,"goal":"lemma MulZero_10973(k: nat)\n ensures k * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_10974","instance":10974,"id":180973,"goal":"lemma LeRefl_10974(b: real)\n ensures b <= b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_10975","instance":10975,"id":180974,"goal":"lemma LeTrans_10975(y: int, m: int, i: int)\n requires y <= m && m <= i\n ensures y <= i\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_10976","instance":10976,"id":180975,"goal":"lemma AddMono_10976(n: nat, j: nat, b: nat)\n requires n <= j\n ensures n + b <= j + b\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_10977","instance":10977,"id":180976,"goal":"lemma Abs_Nonneg_10977(k: real)\n ensures (if k >= 0 then k else -k) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_10978","instance":10978,"id":180977,"goal":"lemma DivMod_10978(b: int, y: int)\n requires y > 0\n ensures b == y * (b / y) + (b % y)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_10979","instance":10979,"id":180978,"goal":"lemma ModBounds_10979(n: nat, c: nat)\n requires c > 0\n ensures 0 <= n % c < c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_10980","instance":10980,"id":180979,"goal":"lemma Square_Nonneg_10980(d: real)\n ensures d * d >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_10981","instance":10981,"id":180980,"goal":"lemma AddComm_10981(d: int, n: int)\n ensures d + n == n + d\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_10982","instance":10982,"id":180981,"goal":"lemma AddAssoc_10982(d: nat, n: nat, c: nat)\n ensures (d + n) + c == d + (n + c)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_10983","instance":10983,"id":180982,"goal":"lemma MulComm_10983(z: real, n: real)\n ensures z * n == n * z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_10984","instance":10984,"id":180983,"goal":"lemma MulAssoc_10984(a: int, k: int, j: int)\n ensures (a * k) * j == a * (k * j)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_10985","instance":10985,"id":180984,"goal":"lemma Distrib_10985(i: nat, b: nat, n: nat)\n ensures i * (b + n) == i * b + i * n\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_10986","instance":10986,"id":180985,"goal":"lemma AddZero_10986(x: real)\n ensures x + 0 == x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_10987","instance":10987,"id":180986,"goal":"lemma MulOne_10987(z: int)\n ensures z * 1 == z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_10988","instance":10988,"id":180987,"goal":"lemma MulZero_10988(i: nat)\n ensures i * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_10989","instance":10989,"id":180988,"goal":"lemma LeRefl_10989(i: real)\n ensures i <= i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_10990","instance":10990,"id":180989,"goal":"lemma LeTrans_10990(d: int, a: int, y: int)\n requires d <= a && a <= y\n ensures d <= y\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_10991","instance":10991,"id":180990,"goal":"lemma AddMono_10991(n: nat, a: nat, i: nat)\n requires n <= a\n ensures n + i <= a + i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_10992","instance":10992,"id":180991,"goal":"lemma Abs_Nonneg_10992(d: real)\n ensures (if d >= 0 then d else -d) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_10993","instance":10993,"id":180992,"goal":"lemma DivMod_10993(i: int, a: int)\n requires a > 0\n ensures i == a * (i / a) + (i % a)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_10994","instance":10994,"id":180993,"goal":"lemma ModBounds_10994(j: nat, m: nat)\n requires m > 0\n ensures 0 <= j % m < m\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_10995","instance":10995,"id":180994,"goal":"lemma Square_Nonneg_10995(m: real)\n ensures m * m >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_10996","instance":10996,"id":180995,"goal":"lemma AddComm_10996(x: int, a: int)\n ensures x + a == a + x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_10997","instance":10997,"id":180996,"goal":"lemma AddAssoc_10997(x: nat, m: nat, a: nat)\n ensures (x + m) + a == x + (m + a)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_10998","instance":10998,"id":180997,"goal":"lemma MulComm_10998(b: real, m: real)\n ensures b * m == m * b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_10999","instance":10999,"id":180998,"goal":"lemma MulAssoc_10999(j: int, d: int, b: int)\n ensures (j * d) * b == j * (d * b)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_11000","instance":11000,"id":180999,"goal":"lemma Distrib_11000(n: nat, j: nat, y: nat)\n ensures n * (j + y) == n * j + n * y\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_11001","instance":11001,"id":181000,"goal":"lemma AddZero_11001(x: real)\n ensures x + 0 == x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_11002","instance":11002,"id":181001,"goal":"lemma MulOne_11002(c: int)\n ensures c * 1 == c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_11003","instance":11003,"id":181002,"goal":"lemma MulZero_11003(z: nat)\n ensures z * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_11004","instance":11004,"id":181003,"goal":"lemma LeRefl_11004(d: real)\n ensures d <= d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_11005","instance":11005,"id":181004,"goal":"lemma LeTrans_11005(z: int, j: int, c: int)\n requires z <= j && j <= c\n ensures z <= c\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_11006","instance":11006,"id":181005,"goal":"lemma AddMono_11006(c: nat, j: nat, y: nat)\n requires c <= j\n ensures c + y <= j + y\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_11007","instance":11007,"id":181006,"goal":"lemma Abs_Nonneg_11007(b: real)\n ensures (if b >= 0 then b else -b) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_11008","instance":11008,"id":181007,"goal":"lemma DivMod_11008(b: int, c: int)\n requires c > 0\n ensures b == c * (b / c) + (b % c)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_11009","instance":11009,"id":181008,"goal":"lemma ModBounds_11009(c: nat, n: nat)\n requires n > 0\n ensures 0 <= c % n < n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_11010","instance":11010,"id":181009,"goal":"lemma Square_Nonneg_11010(m: real)\n ensures m * m >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_11011","instance":11011,"id":181010,"goal":"lemma AddComm_11011(b: int, x: int)\n ensures b + x == x + b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_11012","instance":11012,"id":181011,"goal":"lemma AddAssoc_11012(z: nat, c: nat, y: nat)\n ensures (z + c) + y == z + (c + y)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_11013","instance":11013,"id":181012,"goal":"lemma MulComm_11013(z: real, y: real)\n ensures z * y == y * z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_11014","instance":11014,"id":181013,"goal":"lemma MulAssoc_11014(i: int, m: int, d: int)\n ensures (i * m) * d == i * (m * d)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_11015","instance":11015,"id":181014,"goal":"lemma Distrib_11015(i: nat, k: nat, y: nat)\n ensures i * (k + y) == i * k + i * y\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_11016","instance":11016,"id":181015,"goal":"lemma AddZero_11016(b: real)\n ensures b + 0 == b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_11017","instance":11017,"id":181016,"goal":"lemma MulOne_11017(x: int)\n ensures x * 1 == x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_11018","instance":11018,"id":181017,"goal":"lemma MulZero_11018(b: nat)\n ensures b * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_11019","instance":11019,"id":181018,"goal":"lemma LeRefl_11019(m: real)\n ensures m <= m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_11020","instance":11020,"id":181019,"goal":"lemma LeTrans_11020(a: int, i: int, c: int)\n requires a <= i && i <= c\n ensures a <= c\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_11021","instance":11021,"id":181020,"goal":"lemma AddMono_11021(b: nat, i: nat, n: nat)\n requires b <= i\n ensures b + n <= i + n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_11022","instance":11022,"id":181021,"goal":"lemma Abs_Nonneg_11022(d: real)\n ensures (if d >= 0 then d else -d) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_11023","instance":11023,"id":181022,"goal":"lemma DivMod_11023(n: int, a: int)\n requires a > 0\n ensures n == a * (n / a) + (n % a)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_11024","instance":11024,"id":181023,"goal":"lemma ModBounds_11024(n: nat, i: nat)\n requires i > 0\n ensures 0 <= n % i < i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_11025","instance":11025,"id":181024,"goal":"lemma Square_Nonneg_11025(n: real)\n ensures n * n >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_11026","instance":11026,"id":181025,"goal":"lemma AddComm_11026(a: int, b: int)\n ensures a + b == b + a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_11027","instance":11027,"id":181026,"goal":"lemma AddAssoc_11027(z: nat, b: nat, c: nat)\n ensures (z + b) + c == z + (b + c)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_11028","instance":11028,"id":181027,"goal":"lemma MulComm_11028(n: real, b: real)\n ensures n * b == b * n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_11029","instance":11029,"id":181028,"goal":"lemma MulAssoc_11029(a: int, k: int, y: int)\n ensures (a * k) * y == a * (k * y)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_11030","instance":11030,"id":181029,"goal":"lemma Distrib_11030(a: nat, i: nat, n: nat)\n ensures a * (i + n) == a * i + a * n\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_11031","instance":11031,"id":181030,"goal":"lemma AddZero_11031(z: real)\n ensures z + 0 == z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_11032","instance":11032,"id":181031,"goal":"lemma MulOne_11032(c: int)\n ensures c * 1 == c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_11033","instance":11033,"id":181032,"goal":"lemma MulZero_11033(z: nat)\n ensures z * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_11034","instance":11034,"id":181033,"goal":"lemma LeRefl_11034(x: real)\n ensures x <= x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_11035","instance":11035,"id":181034,"goal":"lemma LeTrans_11035(z: int, x: int, m: int)\n requires z <= x && x <= m\n ensures z <= m\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_11036","instance":11036,"id":181035,"goal":"lemma AddMono_11036(d: nat, y: nat, n: nat)\n requires d <= y\n ensures d + n <= y + n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_11037","instance":11037,"id":181036,"goal":"lemma Abs_Nonneg_11037(z: real)\n ensures (if z >= 0 then z else -z) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_11038","instance":11038,"id":181037,"goal":"lemma DivMod_11038(y: int, n: int)\n requires n > 0\n ensures y == n * (y / n) + (y % n)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_11039","instance":11039,"id":181038,"goal":"lemma ModBounds_11039(x: nat, m: nat)\n requires m > 0\n ensures 0 <= x % m < m\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_11040","instance":11040,"id":181039,"goal":"lemma Square_Nonneg_11040(j: real)\n ensures j * j >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_11041","instance":11041,"id":181040,"goal":"lemma AddComm_11041(c: int, a: int)\n ensures c + a == a + c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_11042","instance":11042,"id":181041,"goal":"lemma AddAssoc_11042(b: nat, j: nat, c: nat)\n ensures (b + j) + c == b + (j + c)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_11043","instance":11043,"id":181042,"goal":"lemma MulComm_11043(x: real, d: real)\n ensures x * d == d * x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_11044","instance":11044,"id":181043,"goal":"lemma MulAssoc_11044(i: int, z: int, y: int)\n ensures (i * z) * y == i * (z * y)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_11045","instance":11045,"id":181044,"goal":"lemma Distrib_11045(d: nat, y: nat, n: nat)\n ensures d * (y + n) == d * y + d * n\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_11046","instance":11046,"id":181045,"goal":"lemma AddZero_11046(z: real)\n ensures z + 0 == z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_11047","instance":11047,"id":181046,"goal":"lemma MulOne_11047(x: int)\n ensures x * 1 == x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_11048","instance":11048,"id":181047,"goal":"lemma MulZero_11048(y: nat)\n ensures y * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_11049","instance":11049,"id":181048,"goal":"lemma LeRefl_11049(x: real)\n ensures x <= x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_11050","instance":11050,"id":181049,"goal":"lemma LeTrans_11050(c: int, z: int, i: int)\n requires c <= z && z <= i\n ensures c <= i\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_11051","instance":11051,"id":181050,"goal":"lemma AddMono_11051(y: nat, m: nat, d: nat)\n requires y <= m\n ensures y + d <= m + d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_11052","instance":11052,"id":181051,"goal":"lemma Abs_Nonneg_11052(b: real)\n ensures (if b >= 0 then b else -b) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_11053","instance":11053,"id":181052,"goal":"lemma DivMod_11053(c: int, y: int)\n requires y > 0\n ensures c == y * (c / y) + (c % y)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_11054","instance":11054,"id":181053,"goal":"lemma ModBounds_11054(d: nat, a: nat)\n requires a > 0\n ensures 0 <= d % a < a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_11055","instance":11055,"id":181054,"goal":"lemma Square_Nonneg_11055(j: real)\n ensures j * j >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_11056","instance":11056,"id":181055,"goal":"lemma AddComm_11056(y: int, j: int)\n ensures y + j == j + y\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_11057","instance":11057,"id":181056,"goal":"lemma AddAssoc_11057(j: nat, n: nat, c: nat)\n ensures (j + n) + c == j + (n + c)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_11058","instance":11058,"id":181057,"goal":"lemma MulComm_11058(a: real, n: real)\n ensures a * n == n * a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_11059","instance":11059,"id":181058,"goal":"lemma MulAssoc_11059(c: int, m: int, n: int)\n ensures (c * m) * n == c * (m * n)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_11060","instance":11060,"id":181059,"goal":"lemma Distrib_11060(i: nat, c: nat, j: nat)\n ensures i * (c + j) == i * c + i * j\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_11061","instance":11061,"id":181060,"goal":"lemma AddZero_11061(a: real)\n ensures a + 0 == a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_11062","instance":11062,"id":181061,"goal":"lemma MulOne_11062(i: int)\n ensures i * 1 == i\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_11063","instance":11063,"id":181062,"goal":"lemma MulZero_11063(c: nat)\n ensures c * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_11064","instance":11064,"id":181063,"goal":"lemma LeRefl_11064(c: real)\n ensures c <= c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_11065","instance":11065,"id":181064,"goal":"lemma LeTrans_11065(a: int, k: int, n: int)\n requires a <= k && k <= n\n ensures a <= n\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_11066","instance":11066,"id":181065,"goal":"lemma AddMono_11066(x: nat, m: nat, y: nat)\n requires x <= m\n ensures x + y <= m + y\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_11067","instance":11067,"id":181066,"goal":"lemma Abs_Nonneg_11067(z: real)\n ensures (if z >= 0 then z else -z) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_11068","instance":11068,"id":181067,"goal":"lemma DivMod_11068(x: int, y: int)\n requires y > 0\n ensures x == y * (x / y) + (x % y)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_11069","instance":11069,"id":181068,"goal":"lemma ModBounds_11069(c: nat, j: nat)\n requires j > 0\n ensures 0 <= c % j < j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_11070","instance":11070,"id":181069,"goal":"lemma Square_Nonneg_11070(j: real)\n ensures j * j >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_11071","instance":11071,"id":181070,"goal":"lemma AddComm_11071(i: int, b: int)\n ensures i + b == b + i\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_11072","instance":11072,"id":181071,"goal":"lemma AddAssoc_11072(x: nat, d: nat, j: nat)\n ensures (x + d) + j == x + (d + j)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_11073","instance":11073,"id":181072,"goal":"lemma MulComm_11073(i: real, d: real)\n ensures i * d == d * i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_11074","instance":11074,"id":181073,"goal":"lemma MulAssoc_11074(a: int, z: int, c: int)\n ensures (a * z) * c == a * (z * c)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_11075","instance":11075,"id":181074,"goal":"lemma Distrib_11075(n: nat, i: nat, y: nat)\n ensures n * (i + y) == n * i + n * y\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_11076","instance":11076,"id":181075,"goal":"lemma AddZero_11076(z: real)\n ensures z + 0 == z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_11077","instance":11077,"id":181076,"goal":"lemma MulOne_11077(d: int)\n ensures d * 1 == d\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_11078","instance":11078,"id":181077,"goal":"lemma MulZero_11078(c: nat)\n ensures c * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_11079","instance":11079,"id":181078,"goal":"lemma LeRefl_11079(b: real)\n ensures b <= b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_11080","instance":11080,"id":181079,"goal":"lemma LeTrans_11080(m: int, n: int, i: int)\n requires m <= n && n <= i\n ensures m <= i\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_11081","instance":11081,"id":181080,"goal":"lemma AddMono_11081(j: nat, k: nat, i: nat)\n requires j <= k\n ensures j + i <= k + i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_11082","instance":11082,"id":181081,"goal":"lemma Abs_Nonneg_11082(z: real)\n ensures (if z >= 0 then z else -z) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_11083","instance":11083,"id":181082,"goal":"lemma DivMod_11083(k: int, n: int)\n requires n > 0\n ensures k == n * (k / n) + (k % n)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_11084","instance":11084,"id":181083,"goal":"lemma ModBounds_11084(i: nat, a: nat)\n requires a > 0\n ensures 0 <= i % a < a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_11085","instance":11085,"id":181084,"goal":"lemma Square_Nonneg_11085(n: real)\n ensures n * n >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_11086","instance":11086,"id":181085,"goal":"lemma AddComm_11086(c: int, k: int)\n ensures c + k == k + c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_11087","instance":11087,"id":181086,"goal":"lemma AddAssoc_11087(i: nat, k: nat, d: nat)\n ensures (i + k) + d == i + (k + d)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_11088","instance":11088,"id":181087,"goal":"lemma MulComm_11088(c: real, y: real)\n ensures c * y == y * c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_11089","instance":11089,"id":181088,"goal":"lemma MulAssoc_11089(z: int, x: int, k: int)\n ensures (z * x) * k == z * (x * k)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_11090","instance":11090,"id":181089,"goal":"lemma Distrib_11090(k: nat, i: nat, m: nat)\n ensures k * (i + m) == k * i + k * m\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_11091","instance":11091,"id":181090,"goal":"lemma AddZero_11091(z: real)\n ensures z + 0 == z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_11092","instance":11092,"id":181091,"goal":"lemma MulOne_11092(x: int)\n ensures x * 1 == x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_11093","instance":11093,"id":181092,"goal":"lemma MulZero_11093(j: nat)\n ensures j * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_11094","instance":11094,"id":181093,"goal":"lemma LeRefl_11094(x: real)\n ensures x <= x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_11095","instance":11095,"id":181094,"goal":"lemma LeTrans_11095(j: int, b: int, k: int)\n requires j <= b && b <= k\n ensures j <= k\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_11096","instance":11096,"id":181095,"goal":"lemma AddMono_11096(c: nat, b: nat, k: nat)\n requires c <= b\n ensures c + k <= b + k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_11097","instance":11097,"id":181096,"goal":"lemma Abs_Nonneg_11097(j: real)\n ensures (if j >= 0 then j else -j) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_11098","instance":11098,"id":181097,"goal":"lemma DivMod_11098(i: int, z: int)\n requires z > 0\n ensures i == z * (i / z) + (i % z)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_11099","instance":11099,"id":181098,"goal":"lemma ModBounds_11099(x: nat, j: nat)\n requires j > 0\n ensures 0 <= x % j < j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_11100","instance":11100,"id":181099,"goal":"lemma Square_Nonneg_11100(d: real)\n ensures d * d >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_11101","instance":11101,"id":181100,"goal":"lemma AddComm_11101(y: int, c: int)\n ensures y + c == c + y\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_11102","instance":11102,"id":181101,"goal":"lemma AddAssoc_11102(i: nat, n: nat, k: nat)\n ensures (i + n) + k == i + (n + k)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_11103","instance":11103,"id":181102,"goal":"lemma MulComm_11103(y: real, i: real)\n ensures y * i == i * y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_11104","instance":11104,"id":181103,"goal":"lemma MulAssoc_11104(b: int, z: int, n: int)\n ensures (b * z) * n == b * (z * n)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_11105","instance":11105,"id":181104,"goal":"lemma Distrib_11105(a: nat, c: nat, b: nat)\n ensures a * (c + b) == a * c + a * b\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_11106","instance":11106,"id":181105,"goal":"lemma AddZero_11106(x: real)\n ensures x + 0 == x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_11107","instance":11107,"id":181106,"goal":"lemma MulOne_11107(m: int)\n ensures m * 1 == m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_11108","instance":11108,"id":181107,"goal":"lemma MulZero_11108(k: nat)\n ensures k * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_11109","instance":11109,"id":181108,"goal":"lemma LeRefl_11109(x: real)\n ensures x <= x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_11110","instance":11110,"id":181109,"goal":"lemma LeTrans_11110(n: int, c: int, y: int)\n requires n <= c && c <= y\n ensures n <= y\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_11111","instance":11111,"id":181110,"goal":"lemma AddMono_11111(i: nat, z: nat, a: nat)\n requires i <= z\n ensures i + a <= z + a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_11112","instance":11112,"id":181111,"goal":"lemma Abs_Nonneg_11112(y: real)\n ensures (if y >= 0 then y else -y) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_11113","instance":11113,"id":181112,"goal":"lemma DivMod_11113(d: int, j: int)\n requires j > 0\n ensures d == j * (d / j) + (d % j)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_11114","instance":11114,"id":181113,"goal":"lemma ModBounds_11114(d: nat, z: nat)\n requires z > 0\n ensures 0 <= d % z < z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_11115","instance":11115,"id":181114,"goal":"lemma Square_Nonneg_11115(d: real)\n ensures d * d >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_11116","instance":11116,"id":181115,"goal":"lemma AddComm_11116(c: int, z: int)\n ensures c + z == z + c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_11117","instance":11117,"id":181116,"goal":"lemma AddAssoc_11117(b: nat, m: nat, d: nat)\n ensures (b + m) + d == b + (m + d)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_11118","instance":11118,"id":181117,"goal":"lemma MulComm_11118(y: real, k: real)\n ensures y * k == k * y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_11119","instance":11119,"id":181118,"goal":"lemma MulAssoc_11119(y: int, k: int, i: int)\n ensures (y * k) * i == y * (k * i)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_11120","instance":11120,"id":181119,"goal":"lemma Distrib_11120(k: nat, j: nat, m: nat)\n ensures k * (j + m) == k * j + k * m\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_11121","instance":11121,"id":181120,"goal":"lemma AddZero_11121(n: real)\n ensures n + 0 == n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_11122","instance":11122,"id":181121,"goal":"lemma MulOne_11122(k: int)\n ensures k * 1 == k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_11123","instance":11123,"id":181122,"goal":"lemma MulZero_11123(b: nat)\n ensures b * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_11124","instance":11124,"id":181123,"goal":"lemma LeRefl_11124(y: real)\n ensures y <= y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_11125","instance":11125,"id":181124,"goal":"lemma LeTrans_11125(j: int, a: int, n: int)\n requires j <= a && a <= n\n ensures j <= n\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_11126","instance":11126,"id":181125,"goal":"lemma AddMono_11126(z: nat, c: nat, a: nat)\n requires z <= c\n ensures z + a <= c + a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_11127","instance":11127,"id":181126,"goal":"lemma Abs_Nonneg_11127(a: real)\n ensures (if a >= 0 then a else -a) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_11128","instance":11128,"id":181127,"goal":"lemma DivMod_11128(n: int, z: int)\n requires z > 0\n ensures n == z * (n / z) + (n % z)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_11129","instance":11129,"id":181128,"goal":"lemma ModBounds_11129(b: nat, y: nat)\n requires y > 0\n ensures 0 <= b % y < y\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_11130","instance":11130,"id":181129,"goal":"lemma Square_Nonneg_11130(c: real)\n ensures c * c >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_11131","instance":11131,"id":181130,"goal":"lemma AddComm_11131(y: int, b: int)\n ensures y + b == b + y\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_11132","instance":11132,"id":181131,"goal":"lemma AddAssoc_11132(i: nat, z: nat, c: nat)\n ensures (i + z) + c == i + (z + c)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_11133","instance":11133,"id":181132,"goal":"lemma MulComm_11133(a: real, c: real)\n ensures a * c == c * a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_11134","instance":11134,"id":181133,"goal":"lemma MulAssoc_11134(j: int, k: int, m: int)\n ensures (j * k) * m == j * (k * m)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_11135","instance":11135,"id":181134,"goal":"lemma Distrib_11135(k: nat, d: nat, z: nat)\n ensures k * (d + z) == k * d + k * z\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_11136","instance":11136,"id":181135,"goal":"lemma AddZero_11136(n: real)\n ensures n + 0 == n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_11137","instance":11137,"id":181136,"goal":"lemma MulOne_11137(m: int)\n ensures m * 1 == m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_11138","instance":11138,"id":181137,"goal":"lemma MulZero_11138(j: nat)\n ensures j * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_11139","instance":11139,"id":181138,"goal":"lemma LeRefl_11139(z: real)\n ensures z <= z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_11140","instance":11140,"id":181139,"goal":"lemma LeTrans_11140(c: int, d: int, y: int)\n requires c <= d && d <= y\n ensures c <= y\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_11141","instance":11141,"id":181140,"goal":"lemma AddMono_11141(z: nat, k: nat, i: nat)\n requires z <= k\n ensures z + i <= k + i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_11142","instance":11142,"id":181141,"goal":"lemma Abs_Nonneg_11142(z: real)\n ensures (if z >= 0 then z else -z) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_11143","instance":11143,"id":181142,"goal":"lemma DivMod_11143(b: int, x: int)\n requires x > 0\n ensures b == x * (b / x) + (b % x)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_11144","instance":11144,"id":181143,"goal":"lemma ModBounds_11144(n: nat, a: nat)\n requires a > 0\n ensures 0 <= n % a < a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_11145","instance":11145,"id":181144,"goal":"lemma Square_Nonneg_11145(c: real)\n ensures c * c >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_11146","instance":11146,"id":181145,"goal":"lemma AddComm_11146(d: int, j: int)\n ensures d + j == j + d\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_11147","instance":11147,"id":181146,"goal":"lemma AddAssoc_11147(y: nat, j: nat, a: nat)\n ensures (y + j) + a == y + (j + a)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_11148","instance":11148,"id":181147,"goal":"lemma MulComm_11148(a: real, c: real)\n ensures a * c == c * a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_11149","instance":11149,"id":181148,"goal":"lemma MulAssoc_11149(d: int, y: int, a: int)\n ensures (d * y) * a == d * (y * a)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_11150","instance":11150,"id":181149,"goal":"lemma Distrib_11150(a: nat, n: nat, c: nat)\n ensures a * (n + c) == a * n + a * c\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_11151","instance":11151,"id":181150,"goal":"lemma AddZero_11151(c: real)\n ensures c + 0 == c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_11152","instance":11152,"id":181151,"goal":"lemma MulOne_11152(y: int)\n ensures y * 1 == y\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_11153","instance":11153,"id":181152,"goal":"lemma MulZero_11153(m: nat)\n ensures m * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_11154","instance":11154,"id":181153,"goal":"lemma LeRefl_11154(n: real)\n ensures n <= n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_11155","instance":11155,"id":181154,"goal":"lemma LeTrans_11155(x: int, d: int, i: int)\n requires x <= d && d <= i\n ensures x <= i\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_11156","instance":11156,"id":181155,"goal":"lemma AddMono_11156(a: nat, d: nat, n: nat)\n requires a <= d\n ensures a + n <= d + n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_11157","instance":11157,"id":181156,"goal":"lemma Abs_Nonneg_11157(k: real)\n ensures (if k >= 0 then k else -k) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_11158","instance":11158,"id":181157,"goal":"lemma DivMod_11158(d: int, k: int)\n requires k > 0\n ensures d == k * (d / k) + (d % k)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_11159","instance":11159,"id":181158,"goal":"lemma ModBounds_11159(y: nat, k: nat)\n requires k > 0\n ensures 0 <= y % k < k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_11160","instance":11160,"id":181159,"goal":"lemma Square_Nonneg_11160(n: real)\n ensures n * n >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_11161","instance":11161,"id":181160,"goal":"lemma AddComm_11161(j: int, y: int)\n ensures j + y == y + j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_11162","instance":11162,"id":181161,"goal":"lemma AddAssoc_11162(d: nat, j: nat, k: nat)\n ensures (d + j) + k == d + (j + k)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_11163","instance":11163,"id":181162,"goal":"lemma MulComm_11163(c: real, d: real)\n ensures c * d == d * c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_11164","instance":11164,"id":181163,"goal":"lemma MulAssoc_11164(y: int, i: int, c: int)\n ensures (y * i) * c == y * (i * c)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_11165","instance":11165,"id":181164,"goal":"lemma Distrib_11165(d: nat, m: nat, x: nat)\n ensures d * (m + x) == d * m + d * x\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_11166","instance":11166,"id":181165,"goal":"lemma AddZero_11166(d: real)\n ensures d + 0 == d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_11167","instance":11167,"id":181166,"goal":"lemma MulOne_11167(j: int)\n ensures j * 1 == j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_11168","instance":11168,"id":181167,"goal":"lemma MulZero_11168(z: nat)\n ensures z * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_11169","instance":11169,"id":181168,"goal":"lemma LeRefl_11169(i: real)\n ensures i <= i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_11170","instance":11170,"id":181169,"goal":"lemma LeTrans_11170(a: int, i: int, d: int)\n requires a <= i && i <= d\n ensures a <= d\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_11171","instance":11171,"id":181170,"goal":"lemma AddMono_11171(a: nat, i: nat, y: nat)\n requires a <= i\n ensures a + y <= i + y\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_11172","instance":11172,"id":181171,"goal":"lemma Abs_Nonneg_11172(j: real)\n ensures (if j >= 0 then j else -j) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_11173","instance":11173,"id":181172,"goal":"lemma DivMod_11173(d: int, n: int)\n requires n > 0\n ensures d == n * (d / n) + (d % n)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_11174","instance":11174,"id":181173,"goal":"lemma ModBounds_11174(c: nat, x: nat)\n requires x > 0\n ensures 0 <= c % x < x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_11175","instance":11175,"id":181174,"goal":"lemma Square_Nonneg_11175(n: real)\n ensures n * n >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_11176","instance":11176,"id":181175,"goal":"lemma AddComm_11176(m: int, d: int)\n ensures m + d == d + m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_11177","instance":11177,"id":181176,"goal":"lemma AddAssoc_11177(j: nat, n: nat, a: nat)\n ensures (j + n) + a == j + (n + a)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_11178","instance":11178,"id":181177,"goal":"lemma MulComm_11178(d: real, j: real)\n ensures d * j == j * d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_11179","instance":11179,"id":181178,"goal":"lemma MulAssoc_11179(j: int, c: int, a: int)\n ensures (j * c) * a == j * (c * a)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_11180","instance":11180,"id":181179,"goal":"lemma Distrib_11180(c: nat, d: nat, z: nat)\n ensures c * (d + z) == c * d + c * z\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_11181","instance":11181,"id":181180,"goal":"lemma AddZero_11181(i: real)\n ensures i + 0 == i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_11182","instance":11182,"id":181181,"goal":"lemma MulOne_11182(n: int)\n ensures n * 1 == n\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_11183","instance":11183,"id":181182,"goal":"lemma MulZero_11183(z: nat)\n ensures z * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_11184","instance":11184,"id":181183,"goal":"lemma LeRefl_11184(k: real)\n ensures k <= k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_11185","instance":11185,"id":181184,"goal":"lemma LeTrans_11185(b: int, z: int, m: int)\n requires b <= z && z <= m\n ensures b <= m\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_11186","instance":11186,"id":181185,"goal":"lemma AddMono_11186(d: nat, j: nat, b: nat)\n requires d <= j\n ensures d + b <= j + b\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_11187","instance":11187,"id":181186,"goal":"lemma Abs_Nonneg_11187(d: real)\n ensures (if d >= 0 then d else -d) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_11188","instance":11188,"id":181187,"goal":"lemma DivMod_11188(b: int, i: int)\n requires i > 0\n ensures b == i * (b / i) + (b % i)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_11189","instance":11189,"id":181188,"goal":"lemma ModBounds_11189(z: nat, y: nat)\n requires y > 0\n ensures 0 <= z % y < y\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_11190","instance":11190,"id":181189,"goal":"lemma Square_Nonneg_11190(j: real)\n ensures j * j >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_11191","instance":11191,"id":181190,"goal":"lemma AddComm_11191(c: int, d: int)\n ensures c + d == d + c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_11192","instance":11192,"id":181191,"goal":"lemma AddAssoc_11192(b: nat, c: nat, j: nat)\n ensures (b + c) + j == b + (c + j)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_11193","instance":11193,"id":181192,"goal":"lemma MulComm_11193(c: real, z: real)\n ensures c * z == z * c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_11194","instance":11194,"id":181193,"goal":"lemma MulAssoc_11194(k: int, i: int, n: int)\n ensures (k * i) * n == k * (i * n)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_11195","instance":11195,"id":181194,"goal":"lemma Distrib_11195(z: nat, x: nat, a: nat)\n ensures z * (x + a) == z * x + z * a\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_11196","instance":11196,"id":181195,"goal":"lemma AddZero_11196(j: real)\n ensures j + 0 == j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_11197","instance":11197,"id":181196,"goal":"lemma MulOne_11197(b: int)\n ensures b * 1 == b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_11198","instance":11198,"id":181197,"goal":"lemma MulZero_11198(x: nat)\n ensures x * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_11199","instance":11199,"id":181198,"goal":"lemma LeRefl_11199(b: real)\n ensures b <= b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_11200","instance":11200,"id":181199,"goal":"lemma LeTrans_11200(n: int, a: int, i: int)\n requires n <= a && a <= i\n ensures n <= i\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_11201","instance":11201,"id":181200,"goal":"lemma AddMono_11201(c: nat, n: nat, d: nat)\n requires c <= n\n ensures c + d <= n + d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_11202","instance":11202,"id":181201,"goal":"lemma Abs_Nonneg_11202(z: real)\n ensures (if z >= 0 then z else -z) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_11203","instance":11203,"id":181202,"goal":"lemma DivMod_11203(j: int, i: int)\n requires i > 0\n ensures j == i * (j / i) + (j % i)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_11204","instance":11204,"id":181203,"goal":"lemma ModBounds_11204(x: nat, c: nat)\n requires c > 0\n ensures 0 <= x % c < c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_11205","instance":11205,"id":181204,"goal":"lemma Square_Nonneg_11205(k: real)\n ensures k * k >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_11206","instance":11206,"id":181205,"goal":"lemma AddComm_11206(x: int, j: int)\n ensures x + j == j + x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_11207","instance":11207,"id":181206,"goal":"lemma AddAssoc_11207(d: nat, x: nat, j: nat)\n ensures (d + x) + j == d + (x + j)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_11208","instance":11208,"id":181207,"goal":"lemma MulComm_11208(d: real, y: real)\n ensures d * y == y * d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_11209","instance":11209,"id":181208,"goal":"lemma MulAssoc_11209(n: int, a: int, c: int)\n ensures (n * a) * c == n * (a * c)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_11210","instance":11210,"id":181209,"goal":"lemma Distrib_11210(b: nat, x: nat, m: nat)\n ensures b * (x + m) == b * x + b * m\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_11211","instance":11211,"id":181210,"goal":"lemma AddZero_11211(c: real)\n ensures c + 0 == c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_11212","instance":11212,"id":181211,"goal":"lemma MulOne_11212(j: int)\n ensures j * 1 == j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_11213","instance":11213,"id":181212,"goal":"lemma MulZero_11213(c: nat)\n ensures c * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_11214","instance":11214,"id":181213,"goal":"lemma LeRefl_11214(y: real)\n ensures y <= y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_11215","instance":11215,"id":181214,"goal":"lemma LeTrans_11215(y: int, d: int, j: int)\n requires y <= d && d <= j\n ensures y <= j\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_11216","instance":11216,"id":181215,"goal":"lemma AddMono_11216(n: nat, j: nat, x: nat)\n requires n <= j\n ensures n + x <= j + x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_11217","instance":11217,"id":181216,"goal":"lemma Abs_Nonneg_11217(x: real)\n ensures (if x >= 0 then x else -x) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_11218","instance":11218,"id":181217,"goal":"lemma DivMod_11218(a: int, d: int)\n requires d > 0\n ensures a == d * (a / d) + (a % d)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_11219","instance":11219,"id":181218,"goal":"lemma ModBounds_11219(z: nat, y: nat)\n requires y > 0\n ensures 0 <= z % y < y\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_11220","instance":11220,"id":181219,"goal":"lemma Square_Nonneg_11220(d: real)\n ensures d * d >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_11221","instance":11221,"id":181220,"goal":"lemma AddComm_11221(m: int, b: int)\n ensures m + b == b + m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_11222","instance":11222,"id":181221,"goal":"lemma AddAssoc_11222(b: nat, k: nat, n: nat)\n ensures (b + k) + n == b + (k + n)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_11223","instance":11223,"id":181222,"goal":"lemma MulComm_11223(c: real, j: real)\n ensures c * j == j * c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_11224","instance":11224,"id":181223,"goal":"lemma MulAssoc_11224(k: int, b: int, z: int)\n ensures (k * b) * z == k * (b * z)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_11225","instance":11225,"id":181224,"goal":"lemma Distrib_11225(z: nat, m: nat, n: nat)\n ensures z * (m + n) == z * m + z * n\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_11226","instance":11226,"id":181225,"goal":"lemma AddZero_11226(a: real)\n ensures a + 0 == a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_11227","instance":11227,"id":181226,"goal":"lemma MulOne_11227(d: int)\n ensures d * 1 == d\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_11228","instance":11228,"id":181227,"goal":"lemma MulZero_11228(c: nat)\n ensures c * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_11229","instance":11229,"id":181228,"goal":"lemma LeRefl_11229(d: real)\n ensures d <= d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_11230","instance":11230,"id":181229,"goal":"lemma LeTrans_11230(x: int, a: int, m: int)\n requires x <= a && a <= m\n ensures x <= m\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_11231","instance":11231,"id":181230,"goal":"lemma AddMono_11231(m: nat, y: nat, c: nat)\n requires m <= y\n ensures m + c <= y + c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_11232","instance":11232,"id":181231,"goal":"lemma Abs_Nonneg_11232(i: real)\n ensures (if i >= 0 then i else -i) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_11233","instance":11233,"id":181232,"goal":"lemma DivMod_11233(j: int, n: int)\n requires n > 0\n ensures j == n * (j / n) + (j % n)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_11234","instance":11234,"id":181233,"goal":"lemma ModBounds_11234(i: nat, c: nat)\n requires c > 0\n ensures 0 <= i % c < c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_11235","instance":11235,"id":181234,"goal":"lemma Square_Nonneg_11235(a: real)\n ensures a * a >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_11236","instance":11236,"id":181235,"goal":"lemma AddComm_11236(a: int, d: int)\n ensures a + d == d + a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_11237","instance":11237,"id":181236,"goal":"lemma AddAssoc_11237(a: nat, j: nat, m: nat)\n ensures (a + j) + m == a + (j + m)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_11238","instance":11238,"id":181237,"goal":"lemma MulComm_11238(m: real, b: real)\n ensures m * b == b * m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_11239","instance":11239,"id":181238,"goal":"lemma MulAssoc_11239(c: int, d: int, j: int)\n ensures (c * d) * j == c * (d * j)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_11240","instance":11240,"id":181239,"goal":"lemma Distrib_11240(z: nat, j: nat, k: nat)\n ensures z * (j + k) == z * j + z * k\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_11241","instance":11241,"id":181240,"goal":"lemma AddZero_11241(n: real)\n ensures n + 0 == n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_11242","instance":11242,"id":181241,"goal":"lemma MulOne_11242(m: int)\n ensures m * 1 == m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_11243","instance":11243,"id":181242,"goal":"lemma MulZero_11243(z: nat)\n ensures z * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_11244","instance":11244,"id":181243,"goal":"lemma LeRefl_11244(y: real)\n ensures y <= y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_11245","instance":11245,"id":181244,"goal":"lemma LeTrans_11245(j: int, a: int, n: int)\n requires j <= a && a <= n\n ensures j <= n\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_11246","instance":11246,"id":181245,"goal":"lemma AddMono_11246(k: nat, n: nat, z: nat)\n requires k <= n\n ensures k + z <= n + z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_11247","instance":11247,"id":181246,"goal":"lemma Abs_Nonneg_11247(n: real)\n ensures (if n >= 0 then n else -n) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_11248","instance":11248,"id":181247,"goal":"lemma DivMod_11248(c: int, m: int)\n requires m > 0\n ensures c == m * (c / m) + (c % m)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_11249","instance":11249,"id":181248,"goal":"lemma ModBounds_11249(c: nat, j: nat)\n requires j > 0\n ensures 0 <= c % j < j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_11250","instance":11250,"id":181249,"goal":"lemma Square_Nonneg_11250(a: real)\n ensures a * a >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_11251","instance":11251,"id":181250,"goal":"lemma AddComm_11251(c: int, m: int)\n ensures c + m == m + c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_11252","instance":11252,"id":181251,"goal":"lemma AddAssoc_11252(j: nat, i: nat, a: nat)\n ensures (j + i) + a == j + (i + a)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_11253","instance":11253,"id":181252,"goal":"lemma MulComm_11253(k: real, b: real)\n ensures k * b == b * k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_11254","instance":11254,"id":181253,"goal":"lemma MulAssoc_11254(b: int, y: int, a: int)\n ensures (b * y) * a == b * (y * a)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_11255","instance":11255,"id":181254,"goal":"lemma Distrib_11255(n: nat, y: nat, z: nat)\n ensures n * (y + z) == n * y + n * z\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_11256","instance":11256,"id":181255,"goal":"lemma AddZero_11256(j: real)\n ensures j + 0 == j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_11257","instance":11257,"id":181256,"goal":"lemma MulOne_11257(m: int)\n ensures m * 1 == m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_11258","instance":11258,"id":181257,"goal":"lemma MulZero_11258(y: nat)\n ensures y * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_11259","instance":11259,"id":181258,"goal":"lemma LeRefl_11259(n: real)\n ensures n <= n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_11260","instance":11260,"id":181259,"goal":"lemma LeTrans_11260(i: int, j: int, b: int)\n requires i <= j && j <= b\n ensures i <= b\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_11261","instance":11261,"id":181260,"goal":"lemma AddMono_11261(i: nat, x: nat, b: nat)\n requires i <= x\n ensures i + b <= x + b\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_11262","instance":11262,"id":181261,"goal":"lemma Abs_Nonneg_11262(b: real)\n ensures (if b >= 0 then b else -b) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_11263","instance":11263,"id":181262,"goal":"lemma DivMod_11263(i: int, a: int)\n requires a > 0\n ensures i == a * (i / a) + (i % a)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_11264","instance":11264,"id":181263,"goal":"lemma ModBounds_11264(a: nat, i: nat)\n requires i > 0\n ensures 0 <= a % i < i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_11265","instance":11265,"id":181264,"goal":"lemma Square_Nonneg_11265(j: real)\n ensures j * j >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_11266","instance":11266,"id":181265,"goal":"lemma AddComm_11266(i: int, a: int)\n ensures i + a == a + i\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_11267","instance":11267,"id":181266,"goal":"lemma AddAssoc_11267(y: nat, c: nat, d: nat)\n ensures (y + c) + d == y + (c + d)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_11268","instance":11268,"id":181267,"goal":"lemma MulComm_11268(i: real, j: real)\n ensures i * j == j * i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_11269","instance":11269,"id":181268,"goal":"lemma MulAssoc_11269(n: int, i: int, y: int)\n ensures (n * i) * y == n * (i * y)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_11270","instance":11270,"id":181269,"goal":"lemma Distrib_11270(b: nat, x: nat, y: nat)\n ensures b * (x + y) == b * x + b * y\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_11271","instance":11271,"id":181270,"goal":"lemma AddZero_11271(m: real)\n ensures m + 0 == m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_11272","instance":11272,"id":181271,"goal":"lemma MulOne_11272(i: int)\n ensures i * 1 == i\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_11273","instance":11273,"id":181272,"goal":"lemma MulZero_11273(z: nat)\n ensures z * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_11274","instance":11274,"id":181273,"goal":"lemma LeRefl_11274(k: real)\n ensures k <= k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_11275","instance":11275,"id":181274,"goal":"lemma LeTrans_11275(c: int, i: int, b: int)\n requires c <= i && i <= b\n ensures c <= b\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_11276","instance":11276,"id":181275,"goal":"lemma AddMono_11276(b: nat, c: nat, j: nat)\n requires b <= c\n ensures b + j <= c + j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_11277","instance":11277,"id":181276,"goal":"lemma Abs_Nonneg_11277(c: real)\n ensures (if c >= 0 then c else -c) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_11278","instance":11278,"id":181277,"goal":"lemma DivMod_11278(i: int, z: int)\n requires z > 0\n ensures i == z * (i / z) + (i % z)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_11279","instance":11279,"id":181278,"goal":"lemma ModBounds_11279(z: nat, m: nat)\n requires m > 0\n ensures 0 <= z % m < m\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_11280","instance":11280,"id":181279,"goal":"lemma Square_Nonneg_11280(k: real)\n ensures k * k >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_11281","instance":11281,"id":181280,"goal":"lemma AddComm_11281(i: int, y: int)\n ensures i + y == y + i\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_11282","instance":11282,"id":181281,"goal":"lemma AddAssoc_11282(i: nat, x: nat, a: nat)\n ensures (i + x) + a == i + (x + a)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_11283","instance":11283,"id":181282,"goal":"lemma MulComm_11283(a: real, b: real)\n ensures a * b == b * a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_11284","instance":11284,"id":181283,"goal":"lemma MulAssoc_11284(c: int, k: int, j: int)\n ensures (c * k) * j == c * (k * j)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_11285","instance":11285,"id":181284,"goal":"lemma Distrib_11285(x: nat, d: nat, n: nat)\n ensures x * (d + n) == x * d + x * n\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_11286","instance":11286,"id":181285,"goal":"lemma AddZero_11286(c: real)\n ensures c + 0 == c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_11287","instance":11287,"id":181286,"goal":"lemma MulOne_11287(y: int)\n ensures y * 1 == y\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_11288","instance":11288,"id":181287,"goal":"lemma MulZero_11288(c: nat)\n ensures c * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_11289","instance":11289,"id":181288,"goal":"lemma LeRefl_11289(i: real)\n ensures i <= i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_11290","instance":11290,"id":181289,"goal":"lemma LeTrans_11290(k: int, b: int, y: int)\n requires k <= b && b <= y\n ensures k <= y\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_11291","instance":11291,"id":181290,"goal":"lemma AddMono_11291(z: nat, k: nat, x: nat)\n requires z <= k\n ensures z + x <= k + x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_11292","instance":11292,"id":181291,"goal":"lemma Abs_Nonneg_11292(d: real)\n ensures (if d >= 0 then d else -d) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_11293","instance":11293,"id":181292,"goal":"lemma DivMod_11293(z: int, d: int)\n requires d > 0\n ensures z == d * (z / d) + (z % d)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_11294","instance":11294,"id":181293,"goal":"lemma ModBounds_11294(j: nat, d: nat)\n requires d > 0\n ensures 0 <= j % d < d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_11295","instance":11295,"id":181294,"goal":"lemma Square_Nonneg_11295(b: real)\n ensures b * b >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_11296","instance":11296,"id":181295,"goal":"lemma AddComm_11296(m: int, b: int)\n ensures m + b == b + m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_11297","instance":11297,"id":181296,"goal":"lemma AddAssoc_11297(x: nat, j: nat, y: nat)\n ensures (x + j) + y == x + (j + y)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_11298","instance":11298,"id":181297,"goal":"lemma MulComm_11298(b: real, j: real)\n ensures b * j == j * b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_11299","instance":11299,"id":181298,"goal":"lemma MulAssoc_11299(z: int, d: int, x: int)\n ensures (z * d) * x == z * (d * x)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_11300","instance":11300,"id":181299,"goal":"lemma Distrib_11300(y: nat, d: nat, m: nat)\n ensures y * (d + m) == y * d + y * m\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_11301","instance":11301,"id":181300,"goal":"lemma AddZero_11301(d: real)\n ensures d + 0 == d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_11302","instance":11302,"id":181301,"goal":"lemma MulOne_11302(b: int)\n ensures b * 1 == b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_11303","instance":11303,"id":181302,"goal":"lemma MulZero_11303(j: nat)\n ensures j * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_11304","instance":11304,"id":181303,"goal":"lemma LeRefl_11304(m: real)\n ensures m <= m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_11305","instance":11305,"id":181304,"goal":"lemma LeTrans_11305(y: int, c: int, b: int)\n requires y <= c && c <= b\n ensures y <= b\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_11306","instance":11306,"id":181305,"goal":"lemma AddMono_11306(m: nat, a: nat, i: nat)\n requires m <= a\n ensures m + i <= a + i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_11307","instance":11307,"id":181306,"goal":"lemma Abs_Nonneg_11307(c: real)\n ensures (if c >= 0 then c else -c) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_11308","instance":11308,"id":181307,"goal":"lemma DivMod_11308(b: int, i: int)\n requires i > 0\n ensures b == i * (b / i) + (b % i)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_11309","instance":11309,"id":181308,"goal":"lemma ModBounds_11309(n: nat, b: nat)\n requires b > 0\n ensures 0 <= n % b < b\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_11310","instance":11310,"id":181309,"goal":"lemma Square_Nonneg_11310(a: real)\n ensures a * a >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_11311","instance":11311,"id":181310,"goal":"lemma AddComm_11311(m: int, a: int)\n ensures m + a == a + m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_11312","instance":11312,"id":181311,"goal":"lemma AddAssoc_11312(y: nat, j: nat, m: nat)\n ensures (y + j) + m == y + (j + m)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_11313","instance":11313,"id":181312,"goal":"lemma MulComm_11313(b: real, i: real)\n ensures b * i == i * b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_11314","instance":11314,"id":181313,"goal":"lemma MulAssoc_11314(n: int, z: int, d: int)\n ensures (n * z) * d == n * (z * d)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_11315","instance":11315,"id":181314,"goal":"lemma Distrib_11315(c: nat, a: nat, j: nat)\n ensures c * (a + j) == c * a + c * j\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_11316","instance":11316,"id":181315,"goal":"lemma AddZero_11316(d: real)\n ensures d + 0 == d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_11317","instance":11317,"id":181316,"goal":"lemma MulOne_11317(m: int)\n ensures m * 1 == m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_11318","instance":11318,"id":181317,"goal":"lemma MulZero_11318(k: nat)\n ensures k * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_11319","instance":11319,"id":181318,"goal":"lemma LeRefl_11319(a: real)\n ensures a <= a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_11320","instance":11320,"id":181319,"goal":"lemma LeTrans_11320(c: int, b: int, n: int)\n requires c <= b && b <= n\n ensures c <= n\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_11321","instance":11321,"id":181320,"goal":"lemma AddMono_11321(x: nat, a: nat, n: nat)\n requires x <= a\n ensures x + n <= a + n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_11322","instance":11322,"id":181321,"goal":"lemma Abs_Nonneg_11322(i: real)\n ensures (if i >= 0 then i else -i) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_11323","instance":11323,"id":181322,"goal":"lemma DivMod_11323(z: int, j: int)\n requires j > 0\n ensures z == j * (z / j) + (z % j)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_11324","instance":11324,"id":181323,"goal":"lemma ModBounds_11324(d: nat, n: nat)\n requires n > 0\n ensures 0 <= d % n < n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_11325","instance":11325,"id":181324,"goal":"lemma Square_Nonneg_11325(z: real)\n ensures z * z >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_11326","instance":11326,"id":181325,"goal":"lemma AddComm_11326(y: int, c: int)\n ensures y + c == c + y\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_11327","instance":11327,"id":181326,"goal":"lemma AddAssoc_11327(x: nat, b: nat, a: nat)\n ensures (x + b) + a == x + (b + a)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_11328","instance":11328,"id":181327,"goal":"lemma MulComm_11328(c: real, y: real)\n ensures c * y == y * c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_11329","instance":11329,"id":181328,"goal":"lemma MulAssoc_11329(k: int, a: int, z: int)\n ensures (k * a) * z == k * (a * z)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_11330","instance":11330,"id":181329,"goal":"lemma Distrib_11330(c: nat, b: nat, d: nat)\n ensures c * (b + d) == c * b + c * d\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_11331","instance":11331,"id":181330,"goal":"lemma AddZero_11331(x: real)\n ensures x + 0 == x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_11332","instance":11332,"id":181331,"goal":"lemma MulOne_11332(a: int)\n ensures a * 1 == a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_11333","instance":11333,"id":181332,"goal":"lemma MulZero_11333(x: nat)\n ensures x * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_11334","instance":11334,"id":181333,"goal":"lemma LeRefl_11334(x: real)\n ensures x <= x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_11335","instance":11335,"id":181334,"goal":"lemma LeTrans_11335(i: int, d: int, a: int)\n requires i <= d && d <= a\n ensures i <= a\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_11336","instance":11336,"id":181335,"goal":"lemma AddMono_11336(c: nat, a: nat, n: nat)\n requires c <= a\n ensures c + n <= a + n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_11337","instance":11337,"id":181336,"goal":"lemma Abs_Nonneg_11337(j: real)\n ensures (if j >= 0 then j else -j) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_11338","instance":11338,"id":181337,"goal":"lemma DivMod_11338(m: int, i: int)\n requires i > 0\n ensures m == i * (m / i) + (m % i)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_11339","instance":11339,"id":181338,"goal":"lemma ModBounds_11339(x: nat, n: nat)\n requires n > 0\n ensures 0 <= x % n < n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_11340","instance":11340,"id":181339,"goal":"lemma Square_Nonneg_11340(z: real)\n ensures z * z >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_11341","instance":11341,"id":181340,"goal":"lemma AddComm_11341(y: int, n: int)\n ensures y + n == n + y\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_11342","instance":11342,"id":181341,"goal":"lemma AddAssoc_11342(n: nat, j: nat, k: nat)\n ensures (n + j) + k == n + (j + k)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_11343","instance":11343,"id":181342,"goal":"lemma MulComm_11343(k: real, j: real)\n ensures k * j == j * k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_11344","instance":11344,"id":181343,"goal":"lemma MulAssoc_11344(x: int, d: int, m: int)\n ensures (x * d) * m == x * (d * m)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_11345","instance":11345,"id":181344,"goal":"lemma Distrib_11345(z: nat, k: nat, a: nat)\n ensures z * (k + a) == z * k + z * a\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_11346","instance":11346,"id":181345,"goal":"lemma AddZero_11346(k: real)\n ensures k + 0 == k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_11347","instance":11347,"id":181346,"goal":"lemma MulOne_11347(y: int)\n ensures y * 1 == y\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_11348","instance":11348,"id":181347,"goal":"lemma MulZero_11348(a: nat)\n ensures a * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_11349","instance":11349,"id":181348,"goal":"lemma LeRefl_11349(j: real)\n ensures j <= j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_11350","instance":11350,"id":181349,"goal":"lemma LeTrans_11350(j: int, c: int, d: int)\n requires j <= c && c <= d\n ensures j <= d\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_11351","instance":11351,"id":181350,"goal":"lemma AddMono_11351(d: nat, j: nat, i: nat)\n requires d <= j\n ensures d + i <= j + i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_11352","instance":11352,"id":181351,"goal":"lemma Abs_Nonneg_11352(c: real)\n ensures (if c >= 0 then c else -c) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_11353","instance":11353,"id":181352,"goal":"lemma DivMod_11353(m: int, j: int)\n requires j > 0\n ensures m == j * (m / j) + (m % j)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_11354","instance":11354,"id":181353,"goal":"lemma ModBounds_11354(j: nat, m: nat)\n requires m > 0\n ensures 0 <= j % m < m\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_11355","instance":11355,"id":181354,"goal":"lemma Square_Nonneg_11355(k: real)\n ensures k * k >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_11356","instance":11356,"id":181355,"goal":"lemma AddComm_11356(b: int, n: int)\n ensures b + n == n + b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_11357","instance":11357,"id":181356,"goal":"lemma AddAssoc_11357(y: nat, x: nat, d: nat)\n ensures (y + x) + d == y + (x + d)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_11358","instance":11358,"id":181357,"goal":"lemma MulComm_11358(m: real, x: real)\n ensures m * x == x * m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_11359","instance":11359,"id":181358,"goal":"lemma MulAssoc_11359(b: int, x: int, i: int)\n ensures (b * x) * i == b * (x * i)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_11360","instance":11360,"id":181359,"goal":"lemma Distrib_11360(k: nat, j: nat, n: nat)\n ensures k * (j + n) == k * j + k * n\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_11361","instance":11361,"id":181360,"goal":"lemma AddZero_11361(n: real)\n ensures n + 0 == n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_11362","instance":11362,"id":181361,"goal":"lemma MulOne_11362(i: int)\n ensures i * 1 == i\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_11363","instance":11363,"id":181362,"goal":"lemma MulZero_11363(a: nat)\n ensures a * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_11364","instance":11364,"id":181363,"goal":"lemma LeRefl_11364(i: real)\n ensures i <= i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_11365","instance":11365,"id":181364,"goal":"lemma LeTrans_11365(d: int, k: int, i: int)\n requires d <= k && k <= i\n ensures d <= i\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_11366","instance":11366,"id":181365,"goal":"lemma AddMono_11366(d: nat, x: nat, z: nat)\n requires d <= x\n ensures d + z <= x + z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_11367","instance":11367,"id":181366,"goal":"lemma Abs_Nonneg_11367(n: real)\n ensures (if n >= 0 then n else -n) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_11368","instance":11368,"id":181367,"goal":"lemma DivMod_11368(m: int, k: int)\n requires k > 0\n ensures m == k * (m / k) + (m % k)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_11369","instance":11369,"id":181368,"goal":"lemma ModBounds_11369(i: nat, j: nat)\n requires j > 0\n ensures 0 <= i % j < j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_11370","instance":11370,"id":181369,"goal":"lemma Square_Nonneg_11370(x: real)\n ensures x * x >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_11371","instance":11371,"id":181370,"goal":"lemma AddComm_11371(b: int, n: int)\n ensures b + n == n + b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_11372","instance":11372,"id":181371,"goal":"lemma AddAssoc_11372(c: nat, k: nat, a: nat)\n ensures (c + k) + a == c + (k + a)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_11373","instance":11373,"id":181372,"goal":"lemma MulComm_11373(m: real, j: real)\n ensures m * j == j * m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_11374","instance":11374,"id":181373,"goal":"lemma MulAssoc_11374(d: int, y: int, i: int)\n ensures (d * y) * i == d * (y * i)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_11375","instance":11375,"id":181374,"goal":"lemma Distrib_11375(x: nat, j: nat, y: nat)\n ensures x * (j + y) == x * j + x * y\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_11376","instance":11376,"id":181375,"goal":"lemma AddZero_11376(d: real)\n ensures d + 0 == d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_11377","instance":11377,"id":181376,"goal":"lemma MulOne_11377(c: int)\n ensures c * 1 == c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_11378","instance":11378,"id":181377,"goal":"lemma MulZero_11378(b: nat)\n ensures b * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_11379","instance":11379,"id":181378,"goal":"lemma LeRefl_11379(a: real)\n ensures a <= a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_11380","instance":11380,"id":181379,"goal":"lemma LeTrans_11380(z: int, x: int, n: int)\n requires z <= x && x <= n\n ensures z <= n\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_11381","instance":11381,"id":181380,"goal":"lemma AddMono_11381(y: nat, z: nat, j: nat)\n requires y <= z\n ensures y + j <= z + j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_11382","instance":11382,"id":181381,"goal":"lemma Abs_Nonneg_11382(d: real)\n ensures (if d >= 0 then d else -d) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_11383","instance":11383,"id":181382,"goal":"lemma DivMod_11383(m: int, y: int)\n requires y > 0\n ensures m == y * (m / y) + (m % y)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_11384","instance":11384,"id":181383,"goal":"lemma ModBounds_11384(m: nat, d: nat)\n requires d > 0\n ensures 0 <= m % d < d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_11385","instance":11385,"id":181384,"goal":"lemma Square_Nonneg_11385(x: real)\n ensures x * x >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_11386","instance":11386,"id":181385,"goal":"lemma AddComm_11386(j: int, c: int)\n ensures j + c == c + j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_11387","instance":11387,"id":181386,"goal":"lemma AddAssoc_11387(n: nat, i: nat, z: nat)\n ensures (n + i) + z == n + (i + z)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_11388","instance":11388,"id":181387,"goal":"lemma MulComm_11388(a: real, j: real)\n ensures a * j == j * a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_11389","instance":11389,"id":181388,"goal":"lemma MulAssoc_11389(c: int, z: int, m: int)\n ensures (c * z) * m == c * (z * m)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_11390","instance":11390,"id":181389,"goal":"lemma Distrib_11390(b: nat, k: nat, n: nat)\n ensures b * (k + n) == b * k + b * n\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_11391","instance":11391,"id":181390,"goal":"lemma AddZero_11391(d: real)\n ensures d + 0 == d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_11392","instance":11392,"id":181391,"goal":"lemma MulOne_11392(m: int)\n ensures m * 1 == m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_11393","instance":11393,"id":181392,"goal":"lemma MulZero_11393(y: nat)\n ensures y * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_11394","instance":11394,"id":181393,"goal":"lemma LeRefl_11394(z: real)\n ensures z <= z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_11395","instance":11395,"id":181394,"goal":"lemma LeTrans_11395(d: int, a: int, z: int)\n requires d <= a && a <= z\n ensures d <= z\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_11396","instance":11396,"id":181395,"goal":"lemma AddMono_11396(y: nat, m: nat, a: nat)\n requires y <= m\n ensures y + a <= m + a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_11397","instance":11397,"id":181396,"goal":"lemma Abs_Nonneg_11397(b: real)\n ensures (if b >= 0 then b else -b) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_11398","instance":11398,"id":181397,"goal":"lemma DivMod_11398(y: int, j: int)\n requires j > 0\n ensures y == j * (y / j) + (y % j)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_11399","instance":11399,"id":181398,"goal":"lemma ModBounds_11399(y: nat, x: nat)\n requires x > 0\n ensures 0 <= y % x < x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_11400","instance":11400,"id":181399,"goal":"lemma Square_Nonneg_11400(x: real)\n ensures x * x >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_11401","instance":11401,"id":181400,"goal":"lemma AddComm_11401(c: int, n: int)\n ensures c + n == n + c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_11402","instance":11402,"id":181401,"goal":"lemma AddAssoc_11402(j: nat, n: nat, y: nat)\n ensures (j + n) + y == j + (n + y)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_11403","instance":11403,"id":181402,"goal":"lemma MulComm_11403(j: real, k: real)\n ensures j * k == k * j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_11404","instance":11404,"id":181403,"goal":"lemma MulAssoc_11404(k: int, j: int, x: int)\n ensures (k * j) * x == k * (j * x)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_11405","instance":11405,"id":181404,"goal":"lemma Distrib_11405(y: nat, z: nat, i: nat)\n ensures y * (z + i) == y * z + y * i\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_11406","instance":11406,"id":181405,"goal":"lemma AddZero_11406(y: real)\n ensures y + 0 == y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_11407","instance":11407,"id":181406,"goal":"lemma MulOne_11407(m: int)\n ensures m * 1 == m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_11408","instance":11408,"id":181407,"goal":"lemma MulZero_11408(c: nat)\n ensures c * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_11409","instance":11409,"id":181408,"goal":"lemma LeRefl_11409(j: real)\n ensures j <= j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_11410","instance":11410,"id":181409,"goal":"lemma LeTrans_11410(i: int, y: int, m: int)\n requires i <= y && y <= m\n ensures i <= m\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_11411","instance":11411,"id":181410,"goal":"lemma AddMono_11411(a: nat, c: nat, d: nat)\n requires a <= c\n ensures a + d <= c + d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_11412","instance":11412,"id":181411,"goal":"lemma Abs_Nonneg_11412(z: real)\n ensures (if z >= 0 then z else -z) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_11413","instance":11413,"id":181412,"goal":"lemma DivMod_11413(n: int, d: int)\n requires d > 0\n ensures n == d * (n / d) + (n % d)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_11414","instance":11414,"id":181413,"goal":"lemma ModBounds_11414(n: nat, x: nat)\n requires x > 0\n ensures 0 <= n % x < x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_11415","instance":11415,"id":181414,"goal":"lemma Square_Nonneg_11415(a: real)\n ensures a * a >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_11416","instance":11416,"id":181415,"goal":"lemma AddComm_11416(m: int, d: int)\n ensures m + d == d + m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_11417","instance":11417,"id":181416,"goal":"lemma AddAssoc_11417(n: nat, i: nat, c: nat)\n ensures (n + i) + c == n + (i + c)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_11418","instance":11418,"id":181417,"goal":"lemma MulComm_11418(d: real, m: real)\n ensures d * m == m * d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_11419","instance":11419,"id":181418,"goal":"lemma MulAssoc_11419(b: int, c: int, k: int)\n ensures (b * c) * k == b * (c * k)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_11420","instance":11420,"id":181419,"goal":"lemma Distrib_11420(a: nat, j: nat, c: nat)\n ensures a * (j + c) == a * j + a * c\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_11421","instance":11421,"id":181420,"goal":"lemma AddZero_11421(a: real)\n ensures a + 0 == a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_11422","instance":11422,"id":181421,"goal":"lemma MulOne_11422(b: int)\n ensures b * 1 == b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_11423","instance":11423,"id":181422,"goal":"lemma MulZero_11423(j: nat)\n ensures j * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_11424","instance":11424,"id":181423,"goal":"lemma LeRefl_11424(d: real)\n ensures d <= d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_11425","instance":11425,"id":181424,"goal":"lemma LeTrans_11425(z: int, y: int, m: int)\n requires z <= y && y <= m\n ensures z <= m\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_11426","instance":11426,"id":181425,"goal":"lemma AddMono_11426(n: nat, x: nat, z: nat)\n requires n <= x\n ensures n + z <= x + z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_11427","instance":11427,"id":181426,"goal":"lemma Abs_Nonneg_11427(i: real)\n ensures (if i >= 0 then i else -i) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_11428","instance":11428,"id":181427,"goal":"lemma DivMod_11428(y: int, m: int)\n requires m > 0\n ensures y == m * (y / m) + (y % m)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_11429","instance":11429,"id":181428,"goal":"lemma ModBounds_11429(y: nat, k: nat)\n requires k > 0\n ensures 0 <= y % k < k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_11430","instance":11430,"id":181429,"goal":"lemma Square_Nonneg_11430(a: real)\n ensures a * a >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_11431","instance":11431,"id":181430,"goal":"lemma AddComm_11431(a: int, k: int)\n ensures a + k == k + a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_11432","instance":11432,"id":181431,"goal":"lemma AddAssoc_11432(b: nat, z: nat, j: nat)\n ensures (b + z) + j == b + (z + j)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_11433","instance":11433,"id":181432,"goal":"lemma MulComm_11433(a: real, x: real)\n ensures a * x == x * a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_11434","instance":11434,"id":181433,"goal":"lemma MulAssoc_11434(d: int, j: int, b: int)\n ensures (d * j) * b == d * (j * b)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_11435","instance":11435,"id":181434,"goal":"lemma Distrib_11435(b: nat, d: nat, n: nat)\n ensures b * (d + n) == b * d + b * n\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_11436","instance":11436,"id":181435,"goal":"lemma AddZero_11436(x: real)\n ensures x + 0 == x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_11437","instance":11437,"id":181436,"goal":"lemma MulOne_11437(d: int)\n ensures d * 1 == d\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_11438","instance":11438,"id":181437,"goal":"lemma MulZero_11438(a: nat)\n ensures a * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_11439","instance":11439,"id":181438,"goal":"lemma LeRefl_11439(d: real)\n ensures d <= d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_11440","instance":11440,"id":181439,"goal":"lemma LeTrans_11440(d: int, a: int, i: int)\n requires d <= a && a <= i\n ensures d <= i\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_11441","instance":11441,"id":181440,"goal":"lemma AddMono_11441(k: nat, y: nat, n: nat)\n requires k <= y\n ensures k + n <= y + n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_11442","instance":11442,"id":181441,"goal":"lemma Abs_Nonneg_11442(i: real)\n ensures (if i >= 0 then i else -i) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_11443","instance":11443,"id":181442,"goal":"lemma DivMod_11443(k: int, y: int)\n requires y > 0\n ensures k == y * (k / y) + (k % y)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_11444","instance":11444,"id":181443,"goal":"lemma ModBounds_11444(i: nat, c: nat)\n requires c > 0\n ensures 0 <= i % c < c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_11445","instance":11445,"id":181444,"goal":"lemma Square_Nonneg_11445(d: real)\n ensures d * d >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_11446","instance":11446,"id":181445,"goal":"lemma AddComm_11446(d: int, c: int)\n ensures d + c == c + d\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_11447","instance":11447,"id":181446,"goal":"lemma AddAssoc_11447(d: nat, z: nat, x: nat)\n ensures (d + z) + x == d + (z + x)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_11448","instance":11448,"id":181447,"goal":"lemma MulComm_11448(k: real, b: real)\n ensures k * b == b * k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_11449","instance":11449,"id":181448,"goal":"lemma MulAssoc_11449(b: int, a: int, x: int)\n ensures (b * a) * x == b * (a * x)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_11450","instance":11450,"id":181449,"goal":"lemma Distrib_11450(c: nat, m: nat, x: nat)\n ensures c * (m + x) == c * m + c * x\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_11451","instance":11451,"id":181450,"goal":"lemma AddZero_11451(n: real)\n ensures n + 0 == n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_11452","instance":11452,"id":181451,"goal":"lemma MulOne_11452(j: int)\n ensures j * 1 == j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_11453","instance":11453,"id":181452,"goal":"lemma MulZero_11453(b: nat)\n ensures b * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_11454","instance":11454,"id":181453,"goal":"lemma LeRefl_11454(m: real)\n ensures m <= m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_11455","instance":11455,"id":181454,"goal":"lemma LeTrans_11455(d: int, k: int, m: int)\n requires d <= k && k <= m\n ensures d <= m\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_11456","instance":11456,"id":181455,"goal":"lemma AddMono_11456(a: nat, m: nat, k: nat)\n requires a <= m\n ensures a + k <= m + k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_11457","instance":11457,"id":181456,"goal":"lemma Abs_Nonneg_11457(m: real)\n ensures (if m >= 0 then m else -m) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_11458","instance":11458,"id":181457,"goal":"lemma DivMod_11458(m: int, n: int)\n requires n > 0\n ensures m == n * (m / n) + (m % n)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_11459","instance":11459,"id":181458,"goal":"lemma ModBounds_11459(y: nat, j: nat)\n requires j > 0\n ensures 0 <= y % j < j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_11460","instance":11460,"id":181459,"goal":"lemma Square_Nonneg_11460(m: real)\n ensures m * m >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_11461","instance":11461,"id":181460,"goal":"lemma AddComm_11461(m: int, c: int)\n ensures m + c == c + m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_11462","instance":11462,"id":181461,"goal":"lemma AddAssoc_11462(x: nat, m: nat, n: nat)\n ensures (x + m) + n == x + (m + n)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_11463","instance":11463,"id":181462,"goal":"lemma MulComm_11463(a: real, y: real)\n ensures a * y == y * a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_11464","instance":11464,"id":181463,"goal":"lemma MulAssoc_11464(a: int, z: int, m: int)\n ensures (a * z) * m == a * (z * m)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_11465","instance":11465,"id":181464,"goal":"lemma Distrib_11465(z: nat, d: nat, a: nat)\n ensures z * (d + a) == z * d + z * a\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_11466","instance":11466,"id":181465,"goal":"lemma AddZero_11466(z: real)\n ensures z + 0 == z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_11467","instance":11467,"id":181466,"goal":"lemma MulOne_11467(m: int)\n ensures m * 1 == m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_11468","instance":11468,"id":181467,"goal":"lemma MulZero_11468(a: nat)\n ensures a * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_11469","instance":11469,"id":181468,"goal":"lemma LeRefl_11469(c: real)\n ensures c <= c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_11470","instance":11470,"id":181469,"goal":"lemma LeTrans_11470(z: int, a: int, x: int)\n requires z <= a && a <= x\n ensures z <= x\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_11471","instance":11471,"id":181470,"goal":"lemma AddMono_11471(n: nat, b: nat, j: nat)\n requires n <= b\n ensures n + j <= b + j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_11472","instance":11472,"id":181471,"goal":"lemma Abs_Nonneg_11472(x: real)\n ensures (if x >= 0 then x else -x) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_11473","instance":11473,"id":181472,"goal":"lemma DivMod_11473(z: int, n: int)\n requires n > 0\n ensures z == n * (z / n) + (z % n)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_11474","instance":11474,"id":181473,"goal":"lemma ModBounds_11474(c: nat, k: nat)\n requires k > 0\n ensures 0 <= c % k < k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_11475","instance":11475,"id":181474,"goal":"lemma Square_Nonneg_11475(n: real)\n ensures n * n >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_11476","instance":11476,"id":181475,"goal":"lemma AddComm_11476(b: int, c: int)\n ensures b + c == c + b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_11477","instance":11477,"id":181476,"goal":"lemma AddAssoc_11477(b: nat, n: nat, i: nat)\n ensures (b + n) + i == b + (n + i)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_11478","instance":11478,"id":181477,"goal":"lemma MulComm_11478(z: real, n: real)\n ensures z * n == n * z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_11479","instance":11479,"id":181478,"goal":"lemma MulAssoc_11479(c: int, m: int, z: int)\n ensures (c * m) * z == c * (m * z)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_11480","instance":11480,"id":181479,"goal":"lemma Distrib_11480(d: nat, k: nat, a: nat)\n ensures d * (k + a) == d * k + d * a\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_11481","instance":11481,"id":181480,"goal":"lemma AddZero_11481(i: real)\n ensures i + 0 == i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_11482","instance":11482,"id":181481,"goal":"lemma MulOne_11482(y: int)\n ensures y * 1 == y\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_11483","instance":11483,"id":181482,"goal":"lemma MulZero_11483(m: nat)\n ensures m * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_11484","instance":11484,"id":181483,"goal":"lemma LeRefl_11484(a: real)\n ensures a <= a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_11485","instance":11485,"id":181484,"goal":"lemma LeTrans_11485(k: int, j: int, m: int)\n requires k <= j && j <= m\n ensures k <= m\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_11486","instance":11486,"id":181485,"goal":"lemma AddMono_11486(x: nat, m: nat, b: nat)\n requires x <= m\n ensures x + b <= m + b\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_11487","instance":11487,"id":181486,"goal":"lemma Abs_Nonneg_11487(a: real)\n ensures (if a >= 0 then a else -a) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_11488","instance":11488,"id":181487,"goal":"lemma DivMod_11488(k: int, a: int)\n requires a > 0\n ensures k == a * (k / a) + (k % a)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_11489","instance":11489,"id":181488,"goal":"lemma ModBounds_11489(i: nat, z: nat)\n requires z > 0\n ensures 0 <= i % z < z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_11490","instance":11490,"id":181489,"goal":"lemma Square_Nonneg_11490(z: real)\n ensures z * z >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_11491","instance":11491,"id":181490,"goal":"lemma AddComm_11491(b: int, i: int)\n ensures b + i == i + b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_11492","instance":11492,"id":181491,"goal":"lemma AddAssoc_11492(d: nat, x: nat, i: nat)\n ensures (d + x) + i == d + (x + i)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_11493","instance":11493,"id":181492,"goal":"lemma MulComm_11493(c: real, k: real)\n ensures c * k == k * c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_11494","instance":11494,"id":181493,"goal":"lemma MulAssoc_11494(d: int, y: int, x: int)\n ensures (d * y) * x == d * (y * x)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_11495","instance":11495,"id":181494,"goal":"lemma Distrib_11495(y: nat, x: nat, j: nat)\n ensures y * (x + j) == y * x + y * j\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_11496","instance":11496,"id":181495,"goal":"lemma AddZero_11496(z: real)\n ensures z + 0 == z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_11497","instance":11497,"id":181496,"goal":"lemma MulOne_11497(k: int)\n ensures k * 1 == k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_11498","instance":11498,"id":181497,"goal":"lemma MulZero_11498(n: nat)\n ensures n * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_11499","instance":11499,"id":181498,"goal":"lemma LeRefl_11499(k: real)\n ensures k <= k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_11500","instance":11500,"id":181499,"goal":"lemma LeTrans_11500(b: int, j: int, a: int)\n requires b <= j && j <= a\n ensures b <= a\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_11501","instance":11501,"id":181500,"goal":"lemma AddMono_11501(a: nat, x: nat, d: nat)\n requires a <= x\n ensures a + d <= x + d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_11502","instance":11502,"id":181501,"goal":"lemma Abs_Nonneg_11502(x: real)\n ensures (if x >= 0 then x else -x) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_11503","instance":11503,"id":181502,"goal":"lemma DivMod_11503(k: int, j: int)\n requires j > 0\n ensures k == j * (k / j) + (k % j)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_11504","instance":11504,"id":181503,"goal":"lemma ModBounds_11504(a: nat, i: nat)\n requires i > 0\n ensures 0 <= a % i < i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_11505","instance":11505,"id":181504,"goal":"lemma Square_Nonneg_11505(b: real)\n ensures b * b >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_11506","instance":11506,"id":181505,"goal":"lemma AddComm_11506(d: int, z: int)\n ensures d + z == z + d\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_11507","instance":11507,"id":181506,"goal":"lemma AddAssoc_11507(m: nat, i: nat, k: nat)\n ensures (m + i) + k == m + (i + k)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_11508","instance":11508,"id":181507,"goal":"lemma MulComm_11508(x: real, a: real)\n ensures x * a == a * x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_11509","instance":11509,"id":181508,"goal":"lemma MulAssoc_11509(c: int, m: int, d: int)\n ensures (c * m) * d == c * (m * d)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_11510","instance":11510,"id":181509,"goal":"lemma Distrib_11510(j: nat, y: nat, b: nat)\n ensures j * (y + b) == j * y + j * b\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_11511","instance":11511,"id":181510,"goal":"lemma AddZero_11511(z: real)\n ensures z + 0 == z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_11512","instance":11512,"id":181511,"goal":"lemma MulOne_11512(n: int)\n ensures n * 1 == n\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_11513","instance":11513,"id":181512,"goal":"lemma MulZero_11513(m: nat)\n ensures m * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_11514","instance":11514,"id":181513,"goal":"lemma LeRefl_11514(i: real)\n ensures i <= i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_11515","instance":11515,"id":181514,"goal":"lemma LeTrans_11515(j: int, a: int, x: int)\n requires j <= a && a <= x\n ensures j <= x\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_11516","instance":11516,"id":181515,"goal":"lemma AddMono_11516(b: nat, j: nat, k: nat)\n requires b <= j\n ensures b + k <= j + k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_11517","instance":11517,"id":181516,"goal":"lemma Abs_Nonneg_11517(k: real)\n ensures (if k >= 0 then k else -k) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_11518","instance":11518,"id":181517,"goal":"lemma DivMod_11518(j: int, i: int)\n requires i > 0\n ensures j == i * (j / i) + (j % i)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_11519","instance":11519,"id":181518,"goal":"lemma ModBounds_11519(a: nat, i: nat)\n requires i > 0\n ensures 0 <= a % i < i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_11520","instance":11520,"id":181519,"goal":"lemma Square_Nonneg_11520(z: real)\n ensures z * z >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_11521","instance":11521,"id":181520,"goal":"lemma AddComm_11521(i: int, m: int)\n ensures i + m == m + i\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_11522","instance":11522,"id":181521,"goal":"lemma AddAssoc_11522(i: nat, d: nat, n: nat)\n ensures (i + d) + n == i + (d + n)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_11523","instance":11523,"id":181522,"goal":"lemma MulComm_11523(j: real, y: real)\n ensures j * y == y * j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_11524","instance":11524,"id":181523,"goal":"lemma MulAssoc_11524(y: int, c: int, d: int)\n ensures (y * c) * d == y * (c * d)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_11525","instance":11525,"id":181524,"goal":"lemma Distrib_11525(m: nat, z: nat, n: nat)\n ensures m * (z + n) == m * z + m * n\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_11526","instance":11526,"id":181525,"goal":"lemma AddZero_11526(i: real)\n ensures i + 0 == i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_11527","instance":11527,"id":181526,"goal":"lemma MulOne_11527(a: int)\n ensures a * 1 == a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_11528","instance":11528,"id":181527,"goal":"lemma MulZero_11528(a: nat)\n ensures a * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_11529","instance":11529,"id":181528,"goal":"lemma LeRefl_11529(i: real)\n ensures i <= i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_11530","instance":11530,"id":181529,"goal":"lemma LeTrans_11530(j: int, k: int, x: int)\n requires j <= k && k <= x\n ensures j <= x\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_11531","instance":11531,"id":181530,"goal":"lemma AddMono_11531(d: nat, b: nat, n: nat)\n requires d <= b\n ensures d + n <= b + n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_11532","instance":11532,"id":181531,"goal":"lemma Abs_Nonneg_11532(d: real)\n ensures (if d >= 0 then d else -d) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_11533","instance":11533,"id":181532,"goal":"lemma DivMod_11533(a: int, m: int)\n requires m > 0\n ensures a == m * (a / m) + (a % m)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_11534","instance":11534,"id":181533,"goal":"lemma ModBounds_11534(d: nat, k: nat)\n requires k > 0\n ensures 0 <= d % k < k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_11535","instance":11535,"id":181534,"goal":"lemma Square_Nonneg_11535(a: real)\n ensures a * a >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_11536","instance":11536,"id":181535,"goal":"lemma AddComm_11536(b: int, m: int)\n ensures b + m == m + b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_11537","instance":11537,"id":181536,"goal":"lemma AddAssoc_11537(j: nat, n: nat, d: nat)\n ensures (j + n) + d == j + (n + d)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_11538","instance":11538,"id":181537,"goal":"lemma MulComm_11538(c: real, i: real)\n ensures c * i == i * c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_11539","instance":11539,"id":181538,"goal":"lemma MulAssoc_11539(m: int, y: int, b: int)\n ensures (m * y) * b == m * (y * b)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_11540","instance":11540,"id":181539,"goal":"lemma Distrib_11540(b: nat, j: nat, k: nat)\n ensures b * (j + k) == b * j + b * k\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_11541","instance":11541,"id":181540,"goal":"lemma AddZero_11541(i: real)\n ensures i + 0 == i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_11542","instance":11542,"id":181541,"goal":"lemma MulOne_11542(x: int)\n ensures x * 1 == x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_11543","instance":11543,"id":181542,"goal":"lemma MulZero_11543(n: nat)\n ensures n * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_11544","instance":11544,"id":181543,"goal":"lemma LeRefl_11544(d: real)\n ensures d <= d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_11545","instance":11545,"id":181544,"goal":"lemma LeTrans_11545(b: int, a: int, x: int)\n requires b <= a && a <= x\n ensures b <= x\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_11546","instance":11546,"id":181545,"goal":"lemma AddMono_11546(n: nat, a: nat, z: nat)\n requires n <= a\n ensures n + z <= a + z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_11547","instance":11547,"id":181546,"goal":"lemma Abs_Nonneg_11547(k: real)\n ensures (if k >= 0 then k else -k) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_11548","instance":11548,"id":181547,"goal":"lemma DivMod_11548(x: int, d: int)\n requires d > 0\n ensures x == d * (x / d) + (x % d)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_11549","instance":11549,"id":181548,"goal":"lemma ModBounds_11549(k: nat, b: nat)\n requires b > 0\n ensures 0 <= k % b < b\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_11550","instance":11550,"id":181549,"goal":"lemma Square_Nonneg_11550(i: real)\n ensures i * i >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_11551","instance":11551,"id":181550,"goal":"lemma AddComm_11551(z: int, m: int)\n ensures z + m == m + z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_11552","instance":11552,"id":181551,"goal":"lemma AddAssoc_11552(z: nat, b: nat, a: nat)\n ensures (z + b) + a == z + (b + a)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_11553","instance":11553,"id":181552,"goal":"lemma MulComm_11553(m: real, k: real)\n ensures m * k == k * m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_11554","instance":11554,"id":181553,"goal":"lemma MulAssoc_11554(d: int, n: int, c: int)\n ensures (d * n) * c == d * (n * c)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_11555","instance":11555,"id":181554,"goal":"lemma Distrib_11555(i: nat, m: nat, d: nat)\n ensures i * (m + d) == i * m + i * d\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_11556","instance":11556,"id":181555,"goal":"lemma AddZero_11556(i: real)\n ensures i + 0 == i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_11557","instance":11557,"id":181556,"goal":"lemma MulOne_11557(i: int)\n ensures i * 1 == i\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_11558","instance":11558,"id":181557,"goal":"lemma MulZero_11558(d: nat)\n ensures d * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_11559","instance":11559,"id":181558,"goal":"lemma LeRefl_11559(y: real)\n ensures y <= y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_11560","instance":11560,"id":181559,"goal":"lemma LeTrans_11560(x: int, i: int, k: int)\n requires x <= i && i <= k\n ensures x <= k\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_11561","instance":11561,"id":181560,"goal":"lemma AddMono_11561(z: nat, b: nat, d: nat)\n requires z <= b\n ensures z + d <= b + d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_11562","instance":11562,"id":181561,"goal":"lemma Abs_Nonneg_11562(n: real)\n ensures (if n >= 0 then n else -n) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_11563","instance":11563,"id":181562,"goal":"lemma DivMod_11563(k: int, y: int)\n requires y > 0\n ensures k == y * (k / y) + (k % y)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_11564","instance":11564,"id":181563,"goal":"lemma ModBounds_11564(n: nat, i: nat)\n requires i > 0\n ensures 0 <= n % i < i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_11565","instance":11565,"id":181564,"goal":"lemma Square_Nonneg_11565(m: real)\n ensures m * m >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_11566","instance":11566,"id":181565,"goal":"lemma AddComm_11566(i: int, k: int)\n ensures i + k == k + i\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_11567","instance":11567,"id":181566,"goal":"lemma AddAssoc_11567(x: nat, k: nat, d: nat)\n ensures (x + k) + d == x + (k + d)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_11568","instance":11568,"id":181567,"goal":"lemma MulComm_11568(z: real, m: real)\n ensures z * m == m * z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_11569","instance":11569,"id":181568,"goal":"lemma MulAssoc_11569(d: int, i: int, y: int)\n ensures (d * i) * y == d * (i * y)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_11570","instance":11570,"id":181569,"goal":"lemma Distrib_11570(c: nat, d: nat, k: nat)\n ensures c * (d + k) == c * d + c * k\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_11571","instance":11571,"id":181570,"goal":"lemma AddZero_11571(j: real)\n ensures j + 0 == j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_11572","instance":11572,"id":181571,"goal":"lemma MulOne_11572(k: int)\n ensures k * 1 == k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_11573","instance":11573,"id":181572,"goal":"lemma MulZero_11573(k: nat)\n ensures k * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_11574","instance":11574,"id":181573,"goal":"lemma LeRefl_11574(c: real)\n ensures c <= c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_11575","instance":11575,"id":181574,"goal":"lemma LeTrans_11575(m: int, n: int, y: int)\n requires m <= n && n <= y\n ensures m <= y\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_11576","instance":11576,"id":181575,"goal":"lemma AddMono_11576(z: nat, x: nat, d: nat)\n requires z <= x\n ensures z + d <= x + d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_11577","instance":11577,"id":181576,"goal":"lemma Abs_Nonneg_11577(j: real)\n ensures (if j >= 0 then j else -j) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_11578","instance":11578,"id":181577,"goal":"lemma DivMod_11578(d: int, z: int)\n requires z > 0\n ensures d == z * (d / z) + (d % z)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_11579","instance":11579,"id":181578,"goal":"lemma ModBounds_11579(m: nat, n: nat)\n requires n > 0\n ensures 0 <= m % n < n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_11580","instance":11580,"id":181579,"goal":"lemma Square_Nonneg_11580(k: real)\n ensures k * k >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_11581","instance":11581,"id":181580,"goal":"lemma AddComm_11581(d: int, j: int)\n ensures d + j == j + d\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_11582","instance":11582,"id":181581,"goal":"lemma AddAssoc_11582(b: nat, a: nat, d: nat)\n ensures (b + a) + d == b + (a + d)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_11583","instance":11583,"id":181582,"goal":"lemma MulComm_11583(n: real, j: real)\n ensures n * j == j * n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_11584","instance":11584,"id":181583,"goal":"lemma MulAssoc_11584(n: int, m: int, z: int)\n ensures (n * m) * z == n * (m * z)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_11585","instance":11585,"id":181584,"goal":"lemma Distrib_11585(m: nat, k: nat, b: nat)\n ensures m * (k + b) == m * k + m * b\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_11586","instance":11586,"id":181585,"goal":"lemma AddZero_11586(d: real)\n ensures d + 0 == d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_11587","instance":11587,"id":181586,"goal":"lemma MulOne_11587(k: int)\n ensures k * 1 == k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_11588","instance":11588,"id":181587,"goal":"lemma MulZero_11588(j: nat)\n ensures j * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_11589","instance":11589,"id":181588,"goal":"lemma LeRefl_11589(j: real)\n ensures j <= j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_11590","instance":11590,"id":181589,"goal":"lemma LeTrans_11590(k: int, i: int, a: int)\n requires k <= i && i <= a\n ensures k <= a\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_11591","instance":11591,"id":181590,"goal":"lemma AddMono_11591(n: nat, m: nat, c: nat)\n requires n <= m\n ensures n + c <= m + c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_11592","instance":11592,"id":181591,"goal":"lemma Abs_Nonneg_11592(n: real)\n ensures (if n >= 0 then n else -n) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_11593","instance":11593,"id":181592,"goal":"lemma DivMod_11593(y: int, d: int)\n requires d > 0\n ensures y == d * (y / d) + (y % d)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_11594","instance":11594,"id":181593,"goal":"lemma ModBounds_11594(c: nat, b: nat)\n requires b > 0\n ensures 0 <= c % b < b\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_11595","instance":11595,"id":181594,"goal":"lemma Square_Nonneg_11595(n: real)\n ensures n * n >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_11596","instance":11596,"id":181595,"goal":"lemma AddComm_11596(m: int, b: int)\n ensures m + b == b + m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_11597","instance":11597,"id":181596,"goal":"lemma AddAssoc_11597(k: nat, a: nat, m: nat)\n ensures (k + a) + m == k + (a + m)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_11598","instance":11598,"id":181597,"goal":"lemma MulComm_11598(i: real, b: real)\n ensures i * b == b * i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_11599","instance":11599,"id":181598,"goal":"lemma MulAssoc_11599(k: int, n: int, y: int)\n ensures (k * n) * y == k * (n * y)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_11600","instance":11600,"id":181599,"goal":"lemma Distrib_11600(b: nat, a: nat, y: nat)\n ensures b * (a + y) == b * a + b * y\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_11601","instance":11601,"id":181600,"goal":"lemma AddZero_11601(c: real)\n ensures c + 0 == c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_11602","instance":11602,"id":181601,"goal":"lemma MulOne_11602(a: int)\n ensures a * 1 == a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_11603","instance":11603,"id":181602,"goal":"lemma MulZero_11603(j: nat)\n ensures j * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_11604","instance":11604,"id":181603,"goal":"lemma LeRefl_11604(n: real)\n ensures n <= n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_11605","instance":11605,"id":181604,"goal":"lemma LeTrans_11605(d: int, m: int, c: int)\n requires d <= m && m <= c\n ensures d <= c\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_11606","instance":11606,"id":181605,"goal":"lemma AddMono_11606(c: nat, b: nat, x: nat)\n requires c <= b\n ensures c + x <= b + x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_11607","instance":11607,"id":181606,"goal":"lemma Abs_Nonneg_11607(z: real)\n ensures (if z >= 0 then z else -z) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_11608","instance":11608,"id":181607,"goal":"lemma DivMod_11608(z: int, a: int)\n requires a > 0\n ensures z == a * (z / a) + (z % a)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_11609","instance":11609,"id":181608,"goal":"lemma ModBounds_11609(y: nat, z: nat)\n requires z > 0\n ensures 0 <= y % z < z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_11610","instance":11610,"id":181609,"goal":"lemma Square_Nonneg_11610(i: real)\n ensures i * i >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_11611","instance":11611,"id":181610,"goal":"lemma AddComm_11611(x: int, i: int)\n ensures x + i == i + x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_11612","instance":11612,"id":181611,"goal":"lemma AddAssoc_11612(d: nat, c: nat, y: nat)\n ensures (d + c) + y == d + (c + y)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_11613","instance":11613,"id":181612,"goal":"lemma MulComm_11613(j: real, i: real)\n ensures j * i == i * j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_11614","instance":11614,"id":181613,"goal":"lemma MulAssoc_11614(n: int, i: int, m: int)\n ensures (n * i) * m == n * (i * m)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_11615","instance":11615,"id":181614,"goal":"lemma Distrib_11615(d: nat, j: nat, x: nat)\n ensures d * (j + x) == d * j + d * x\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_11616","instance":11616,"id":181615,"goal":"lemma AddZero_11616(k: real)\n ensures k + 0 == k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_11617","instance":11617,"id":181616,"goal":"lemma MulOne_11617(x: int)\n ensures x * 1 == x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_11618","instance":11618,"id":181617,"goal":"lemma MulZero_11618(z: nat)\n ensures z * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_11619","instance":11619,"id":181618,"goal":"lemma LeRefl_11619(b: real)\n ensures b <= b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_11620","instance":11620,"id":181619,"goal":"lemma LeTrans_11620(c: int, b: int, m: int)\n requires c <= b && b <= m\n ensures c <= m\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_11621","instance":11621,"id":181620,"goal":"lemma AddMono_11621(y: nat, d: nat, j: nat)\n requires y <= d\n ensures y + j <= d + j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_11622","instance":11622,"id":181621,"goal":"lemma Abs_Nonneg_11622(d: real)\n ensures (if d >= 0 then d else -d) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_11623","instance":11623,"id":181622,"goal":"lemma DivMod_11623(j: int, n: int)\n requires n > 0\n ensures j == n * (j / n) + (j % n)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_11624","instance":11624,"id":181623,"goal":"lemma ModBounds_11624(n: nat, z: nat)\n requires z > 0\n ensures 0 <= n % z < z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_11625","instance":11625,"id":181624,"goal":"lemma Square_Nonneg_11625(k: real)\n ensures k * k >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_11626","instance":11626,"id":181625,"goal":"lemma AddComm_11626(n: int, a: int)\n ensures n + a == a + n\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_11627","instance":11627,"id":181626,"goal":"lemma AddAssoc_11627(x: nat, a: nat, i: nat)\n ensures (x + a) + i == x + (a + i)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_11628","instance":11628,"id":181627,"goal":"lemma MulComm_11628(d: real, z: real)\n ensures d * z == z * d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_11629","instance":11629,"id":181628,"goal":"lemma MulAssoc_11629(m: int, k: int, x: int)\n ensures (m * k) * x == m * (k * x)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_11630","instance":11630,"id":181629,"goal":"lemma Distrib_11630(d: nat, x: nat, b: nat)\n ensures d * (x + b) == d * x + d * b\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_11631","instance":11631,"id":181630,"goal":"lemma AddZero_11631(z: real)\n ensures z + 0 == z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_11632","instance":11632,"id":181631,"goal":"lemma MulOne_11632(y: int)\n ensures y * 1 == y\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_11633","instance":11633,"id":181632,"goal":"lemma MulZero_11633(b: nat)\n ensures b * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_11634","instance":11634,"id":181633,"goal":"lemma LeRefl_11634(z: real)\n ensures z <= z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_11635","instance":11635,"id":181634,"goal":"lemma LeTrans_11635(i: int, n: int, c: int)\n requires i <= n && n <= c\n ensures i <= c\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_11636","instance":11636,"id":181635,"goal":"lemma AddMono_11636(y: nat, b: nat, k: nat)\n requires y <= b\n ensures y + k <= b + k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_11637","instance":11637,"id":181636,"goal":"lemma Abs_Nonneg_11637(m: real)\n ensures (if m >= 0 then m else -m) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_11638","instance":11638,"id":181637,"goal":"lemma DivMod_11638(k: int, b: int)\n requires b > 0\n ensures k == b * (k / b) + (k % b)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_11639","instance":11639,"id":181638,"goal":"lemma ModBounds_11639(y: nat, j: nat)\n requires j > 0\n ensures 0 <= y % j < j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_11640","instance":11640,"id":181639,"goal":"lemma Square_Nonneg_11640(j: real)\n ensures j * j >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_11641","instance":11641,"id":181640,"goal":"lemma AddComm_11641(c: int, n: int)\n ensures c + n == n + c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_11642","instance":11642,"id":181641,"goal":"lemma AddAssoc_11642(i: nat, x: nat, z: nat)\n ensures (i + x) + z == i + (x + z)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_11643","instance":11643,"id":181642,"goal":"lemma MulComm_11643(y: real, x: real)\n ensures y * x == x * y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_11644","instance":11644,"id":181643,"goal":"lemma MulAssoc_11644(m: int, y: int, i: int)\n ensures (m * y) * i == m * (y * i)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_11645","instance":11645,"id":181644,"goal":"lemma Distrib_11645(y: nat, d: nat, a: nat)\n ensures y * (d + a) == y * d + y * a\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_11646","instance":11646,"id":181645,"goal":"lemma AddZero_11646(d: real)\n ensures d + 0 == d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_11647","instance":11647,"id":181646,"goal":"lemma MulOne_11647(a: int)\n ensures a * 1 == a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_11648","instance":11648,"id":181647,"goal":"lemma MulZero_11648(z: nat)\n ensures z * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_11649","instance":11649,"id":181648,"goal":"lemma LeRefl_11649(k: real)\n ensures k <= k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_11650","instance":11650,"id":181649,"goal":"lemma LeTrans_11650(j: int, n: int, c: int)\n requires j <= n && n <= c\n ensures j <= c\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_11651","instance":11651,"id":181650,"goal":"lemma AddMono_11651(j: nat, d: nat, m: nat)\n requires j <= d\n ensures j + m <= d + m\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_11652","instance":11652,"id":181651,"goal":"lemma Abs_Nonneg_11652(x: real)\n ensures (if x >= 0 then x else -x) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_11653","instance":11653,"id":181652,"goal":"lemma DivMod_11653(a: int, m: int)\n requires m > 0\n ensures a == m * (a / m) + (a % m)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_11654","instance":11654,"id":181653,"goal":"lemma ModBounds_11654(b: nat, d: nat)\n requires d > 0\n ensures 0 <= b % d < d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_11655","instance":11655,"id":181654,"goal":"lemma Square_Nonneg_11655(a: real)\n ensures a * a >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_11656","instance":11656,"id":181655,"goal":"lemma AddComm_11656(b: int, z: int)\n ensures b + z == z + b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_11657","instance":11657,"id":181656,"goal":"lemma AddAssoc_11657(d: nat, j: nat, n: nat)\n ensures (d + j) + n == d + (j + n)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_11658","instance":11658,"id":181657,"goal":"lemma MulComm_11658(d: real, k: real)\n ensures d * k == k * d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_11659","instance":11659,"id":181658,"goal":"lemma MulAssoc_11659(n: int, k: int, y: int)\n ensures (n * k) * y == n * (k * y)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_11660","instance":11660,"id":181659,"goal":"lemma Distrib_11660(a: nat, m: nat, c: nat)\n ensures a * (m + c) == a * m + a * c\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_11661","instance":11661,"id":181660,"goal":"lemma AddZero_11661(y: real)\n ensures y + 0 == y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_11662","instance":11662,"id":181661,"goal":"lemma MulOne_11662(m: int)\n ensures m * 1 == m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_11663","instance":11663,"id":181662,"goal":"lemma MulZero_11663(a: nat)\n ensures a * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_11664","instance":11664,"id":181663,"goal":"lemma LeRefl_11664(i: real)\n ensures i <= i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_11665","instance":11665,"id":181664,"goal":"lemma LeTrans_11665(y: int, m: int, i: int)\n requires y <= m && m <= i\n ensures y <= i\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_11666","instance":11666,"id":181665,"goal":"lemma AddMono_11666(a: nat, j: nat, y: nat)\n requires a <= j\n ensures a + y <= j + y\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_11667","instance":11667,"id":181666,"goal":"lemma Abs_Nonneg_11667(j: real)\n ensures (if j >= 0 then j else -j) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_11668","instance":11668,"id":181667,"goal":"lemma DivMod_11668(a: int, y: int)\n requires y > 0\n ensures a == y * (a / y) + (a % y)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_11669","instance":11669,"id":181668,"goal":"lemma ModBounds_11669(d: nat, z: nat)\n requires z > 0\n ensures 0 <= d % z < z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_11670","instance":11670,"id":181669,"goal":"lemma Square_Nonneg_11670(d: real)\n ensures d * d >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_11671","instance":11671,"id":181670,"goal":"lemma AddComm_11671(c: int, x: int)\n ensures c + x == x + c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_11672","instance":11672,"id":181671,"goal":"lemma AddAssoc_11672(a: nat, z: nat, x: nat)\n ensures (a + z) + x == a + (z + x)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_11673","instance":11673,"id":181672,"goal":"lemma MulComm_11673(b: real, x: real)\n ensures b * x == x * b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_11674","instance":11674,"id":181673,"goal":"lemma MulAssoc_11674(z: int, x: int, i: int)\n ensures (z * x) * i == z * (x * i)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_11675","instance":11675,"id":181674,"goal":"lemma Distrib_11675(y: nat, j: nat, c: nat)\n ensures y * (j + c) == y * j + y * c\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_11676","instance":11676,"id":181675,"goal":"lemma AddZero_11676(b: real)\n ensures b + 0 == b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_11677","instance":11677,"id":181676,"goal":"lemma MulOne_11677(z: int)\n ensures z * 1 == z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_11678","instance":11678,"id":181677,"goal":"lemma MulZero_11678(z: nat)\n ensures z * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_11679","instance":11679,"id":181678,"goal":"lemma LeRefl_11679(j: real)\n ensures j <= j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_11680","instance":11680,"id":181679,"goal":"lemma LeTrans_11680(k: int, c: int, y: int)\n requires k <= c && c <= y\n ensures k <= y\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_11681","instance":11681,"id":181680,"goal":"lemma AddMono_11681(b: nat, y: nat, z: nat)\n requires b <= y\n ensures b + z <= y + z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_11682","instance":11682,"id":181681,"goal":"lemma Abs_Nonneg_11682(c: real)\n ensures (if c >= 0 then c else -c) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_11683","instance":11683,"id":181682,"goal":"lemma DivMod_11683(d: int, y: int)\n requires y > 0\n ensures d == y * (d / y) + (d % y)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_11684","instance":11684,"id":181683,"goal":"lemma ModBounds_11684(x: nat, c: nat)\n requires c > 0\n ensures 0 <= x % c < c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_11685","instance":11685,"id":181684,"goal":"lemma Square_Nonneg_11685(x: real)\n ensures x * x >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_11686","instance":11686,"id":181685,"goal":"lemma AddComm_11686(z: int, n: int)\n ensures z + n == n + z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_11687","instance":11687,"id":181686,"goal":"lemma AddAssoc_11687(z: nat, i: nat, d: nat)\n ensures (z + i) + d == z + (i + d)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_11688","instance":11688,"id":181687,"goal":"lemma MulComm_11688(b: real, a: real)\n ensures b * a == a * b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_11689","instance":11689,"id":181688,"goal":"lemma MulAssoc_11689(b: int, m: int, j: int)\n ensures (b * m) * j == b * (m * j)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_11690","instance":11690,"id":181689,"goal":"lemma Distrib_11690(d: nat, y: nat, a: nat)\n ensures d * (y + a) == d * y + d * a\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_11691","instance":11691,"id":181690,"goal":"lemma AddZero_11691(d: real)\n ensures d + 0 == d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_11692","instance":11692,"id":181691,"goal":"lemma MulOne_11692(n: int)\n ensures n * 1 == n\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_11693","instance":11693,"id":181692,"goal":"lemma MulZero_11693(a: nat)\n ensures a * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_11694","instance":11694,"id":181693,"goal":"lemma LeRefl_11694(n: real)\n ensures n <= n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_11695","instance":11695,"id":181694,"goal":"lemma LeTrans_11695(j: int, z: int, m: int)\n requires j <= z && z <= m\n ensures j <= m\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_11696","instance":11696,"id":181695,"goal":"lemma AddMono_11696(n: nat, x: nat, j: nat)\n requires n <= x\n ensures n + j <= x + j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_11697","instance":11697,"id":181696,"goal":"lemma Abs_Nonneg_11697(j: real)\n ensures (if j >= 0 then j else -j) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_11698","instance":11698,"id":181697,"goal":"lemma DivMod_11698(j: int, a: int)\n requires a > 0\n ensures j == a * (j / a) + (j % a)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_11699","instance":11699,"id":181698,"goal":"lemma ModBounds_11699(x: nat, z: nat)\n requires z > 0\n ensures 0 <= x % z < z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_11700","instance":11700,"id":181699,"goal":"lemma Square_Nonneg_11700(k: real)\n ensures k * k >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_11701","instance":11701,"id":181700,"goal":"lemma AddComm_11701(z: int, c: int)\n ensures z + c == c + z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_11702","instance":11702,"id":181701,"goal":"lemma AddAssoc_11702(b: nat, k: nat, c: nat)\n ensures (b + k) + c == b + (k + c)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_11703","instance":11703,"id":181702,"goal":"lemma MulComm_11703(i: real, m: real)\n ensures i * m == m * i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_11704","instance":11704,"id":181703,"goal":"lemma MulAssoc_11704(n: int, i: int, x: int)\n ensures (n * i) * x == n * (i * x)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_11705","instance":11705,"id":181704,"goal":"lemma Distrib_11705(k: nat, x: nat, c: nat)\n ensures k * (x + c) == k * x + k * c\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_11706","instance":11706,"id":181705,"goal":"lemma AddZero_11706(b: real)\n ensures b + 0 == b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_11707","instance":11707,"id":181706,"goal":"lemma MulOne_11707(x: int)\n ensures x * 1 == x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_11708","instance":11708,"id":181707,"goal":"lemma MulZero_11708(k: nat)\n ensures k * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_11709","instance":11709,"id":181708,"goal":"lemma LeRefl_11709(a: real)\n ensures a <= a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_11710","instance":11710,"id":181709,"goal":"lemma LeTrans_11710(x: int, m: int, k: int)\n requires x <= m && m <= k\n ensures x <= k\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_11711","instance":11711,"id":181710,"goal":"lemma AddMono_11711(c: nat, m: nat, i: nat)\n requires c <= m\n ensures c + i <= m + i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_11712","instance":11712,"id":181711,"goal":"lemma Abs_Nonneg_11712(x: real)\n ensures (if x >= 0 then x else -x) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_11713","instance":11713,"id":181712,"goal":"lemma DivMod_11713(x: int, i: int)\n requires i > 0\n ensures x == i * (x / i) + (x % i)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_11714","instance":11714,"id":181713,"goal":"lemma ModBounds_11714(j: nat, c: nat)\n requires c > 0\n ensures 0 <= j % c < c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_11715","instance":11715,"id":181714,"goal":"lemma Square_Nonneg_11715(m: real)\n ensures m * m >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_11716","instance":11716,"id":181715,"goal":"lemma AddComm_11716(i: int, b: int)\n ensures i + b == b + i\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_11717","instance":11717,"id":181716,"goal":"lemma AddAssoc_11717(x: nat, c: nat, a: nat)\n ensures (x + c) + a == x + (c + a)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_11718","instance":11718,"id":181717,"goal":"lemma MulComm_11718(c: real, y: real)\n ensures c * y == y * c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_11719","instance":11719,"id":181718,"goal":"lemma MulAssoc_11719(a: int, z: int, d: int)\n ensures (a * z) * d == a * (z * d)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_11720","instance":11720,"id":181719,"goal":"lemma Distrib_11720(b: nat, x: nat, a: nat)\n ensures b * (x + a) == b * x + b * a\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_11721","instance":11721,"id":181720,"goal":"lemma AddZero_11721(c: real)\n ensures c + 0 == c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_11722","instance":11722,"id":181721,"goal":"lemma MulOne_11722(z: int)\n ensures z * 1 == z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_11723","instance":11723,"id":181722,"goal":"lemma MulZero_11723(j: nat)\n ensures j * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_11724","instance":11724,"id":181723,"goal":"lemma LeRefl_11724(d: real)\n ensures d <= d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_11725","instance":11725,"id":181724,"goal":"lemma LeTrans_11725(a: int, y: int, i: int)\n requires a <= y && y <= i\n ensures a <= i\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_11726","instance":11726,"id":181725,"goal":"lemma AddMono_11726(k: nat, c: nat, d: nat)\n requires k <= c\n ensures k + d <= c + d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_11727","instance":11727,"id":181726,"goal":"lemma Abs_Nonneg_11727(c: real)\n ensures (if c >= 0 then c else -c) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_11728","instance":11728,"id":181727,"goal":"lemma DivMod_11728(j: int, y: int)\n requires y > 0\n ensures j == y * (j / y) + (j % y)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_11729","instance":11729,"id":181728,"goal":"lemma ModBounds_11729(b: nat, j: nat)\n requires j > 0\n ensures 0 <= b % j < j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_11730","instance":11730,"id":181729,"goal":"lemma Square_Nonneg_11730(m: real)\n ensures m * m >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_11731","instance":11731,"id":181730,"goal":"lemma AddComm_11731(m: int, n: int)\n ensures m + n == n + m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_11732","instance":11732,"id":181731,"goal":"lemma AddAssoc_11732(j: nat, a: nat, y: nat)\n ensures (j + a) + y == j + (a + y)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_11733","instance":11733,"id":181732,"goal":"lemma MulComm_11733(j: real, c: real)\n ensures j * c == c * j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_11734","instance":11734,"id":181733,"goal":"lemma MulAssoc_11734(b: int, a: int, x: int)\n ensures (b * a) * x == b * (a * x)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_11735","instance":11735,"id":181734,"goal":"lemma Distrib_11735(d: nat, a: nat, i: nat)\n ensures d * (a + i) == d * a + d * i\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_11736","instance":11736,"id":181735,"goal":"lemma AddZero_11736(c: real)\n ensures c + 0 == c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_11737","instance":11737,"id":181736,"goal":"lemma MulOne_11737(m: int)\n ensures m * 1 == m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_11738","instance":11738,"id":181737,"goal":"lemma MulZero_11738(z: nat)\n ensures z * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_11739","instance":11739,"id":181738,"goal":"lemma LeRefl_11739(a: real)\n ensures a <= a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_11740","instance":11740,"id":181739,"goal":"lemma LeTrans_11740(a: int, m: int, d: int)\n requires a <= m && m <= d\n ensures a <= d\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_11741","instance":11741,"id":181740,"goal":"lemma AddMono_11741(n: nat, i: nat, x: nat)\n requires n <= i\n ensures n + x <= i + x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_11742","instance":11742,"id":181741,"goal":"lemma Abs_Nonneg_11742(y: real)\n ensures (if y >= 0 then y else -y) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_11743","instance":11743,"id":181742,"goal":"lemma DivMod_11743(z: int, m: int)\n requires m > 0\n ensures z == m * (z / m) + (z % m)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_11744","instance":11744,"id":181743,"goal":"lemma ModBounds_11744(i: nat, d: nat)\n requires d > 0\n ensures 0 <= i % d < d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_11745","instance":11745,"id":181744,"goal":"lemma Square_Nonneg_11745(a: real)\n ensures a * a >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_11746","instance":11746,"id":181745,"goal":"lemma AddComm_11746(j: int, d: int)\n ensures j + d == d + j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_11747","instance":11747,"id":181746,"goal":"lemma AddAssoc_11747(d: nat, j: nat, b: nat)\n ensures (d + j) + b == d + (j + b)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_11748","instance":11748,"id":181747,"goal":"lemma MulComm_11748(x: real, d: real)\n ensures x * d == d * x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_11749","instance":11749,"id":181748,"goal":"lemma MulAssoc_11749(c: int, d: int, m: int)\n ensures (c * d) * m == c * (d * m)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_11750","instance":11750,"id":181749,"goal":"lemma Distrib_11750(b: nat, c: nat, j: nat)\n ensures b * (c + j) == b * c + b * j\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_11751","instance":11751,"id":181750,"goal":"lemma AddZero_11751(b: real)\n ensures b + 0 == b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_11752","instance":11752,"id":181751,"goal":"lemma MulOne_11752(z: int)\n ensures z * 1 == z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_11753","instance":11753,"id":181752,"goal":"lemma MulZero_11753(x: nat)\n ensures x * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_11754","instance":11754,"id":181753,"goal":"lemma LeRefl_11754(k: real)\n ensures k <= k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_11755","instance":11755,"id":181754,"goal":"lemma LeTrans_11755(d: int, c: int, i: int)\n requires d <= c && c <= i\n ensures d <= i\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_11756","instance":11756,"id":181755,"goal":"lemma AddMono_11756(c: nat, z: nat, d: nat)\n requires c <= z\n ensures c + d <= z + d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_11757","instance":11757,"id":181756,"goal":"lemma Abs_Nonneg_11757(k: real)\n ensures (if k >= 0 then k else -k) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_11758","instance":11758,"id":181757,"goal":"lemma DivMod_11758(n: int, m: int)\n requires m > 0\n ensures n == m * (n / m) + (n % m)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_11759","instance":11759,"id":181758,"goal":"lemma ModBounds_11759(m: nat, k: nat)\n requires k > 0\n ensures 0 <= m % k < k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_11760","instance":11760,"id":181759,"goal":"lemma Square_Nonneg_11760(c: real)\n ensures c * c >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_11761","instance":11761,"id":181760,"goal":"lemma AddComm_11761(m: int, i: int)\n ensures m + i == i + m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_11762","instance":11762,"id":181761,"goal":"lemma AddAssoc_11762(y: nat, a: nat, b: nat)\n ensures (y + a) + b == y + (a + b)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_11763","instance":11763,"id":181762,"goal":"lemma MulComm_11763(k: real, x: real)\n ensures k * x == x * k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_11764","instance":11764,"id":181763,"goal":"lemma MulAssoc_11764(c: int, i: int, d: int)\n ensures (c * i) * d == c * (i * d)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_11765","instance":11765,"id":181764,"goal":"lemma Distrib_11765(i: nat, n: nat, k: nat)\n ensures i * (n + k) == i * n + i * k\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_11766","instance":11766,"id":181765,"goal":"lemma AddZero_11766(i: real)\n ensures i + 0 == i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_11767","instance":11767,"id":181766,"goal":"lemma MulOne_11767(z: int)\n ensures z * 1 == z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_11768","instance":11768,"id":181767,"goal":"lemma MulZero_11768(d: nat)\n ensures d * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_11769","instance":11769,"id":181768,"goal":"lemma LeRefl_11769(m: real)\n ensures m <= m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_11770","instance":11770,"id":181769,"goal":"lemma LeTrans_11770(z: int, i: int, j: int)\n requires z <= i && i <= j\n ensures z <= j\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_11771","instance":11771,"id":181770,"goal":"lemma AddMono_11771(x: nat, z: nat, c: nat)\n requires x <= z\n ensures x + c <= z + c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_11772","instance":11772,"id":181771,"goal":"lemma Abs_Nonneg_11772(i: real)\n ensures (if i >= 0 then i else -i) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_11773","instance":11773,"id":181772,"goal":"lemma DivMod_11773(a: int, d: int)\n requires d > 0\n ensures a == d * (a / d) + (a % d)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_11774","instance":11774,"id":181773,"goal":"lemma ModBounds_11774(c: nat, j: nat)\n requires j > 0\n ensures 0 <= c % j < j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_11775","instance":11775,"id":181774,"goal":"lemma Square_Nonneg_11775(x: real)\n ensures x * x >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_11776","instance":11776,"id":181775,"goal":"lemma AddComm_11776(k: int, d: int)\n ensures k + d == d + k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_11777","instance":11777,"id":181776,"goal":"lemma AddAssoc_11777(m: nat, n: nat, x: nat)\n ensures (m + n) + x == m + (n + x)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_11778","instance":11778,"id":181777,"goal":"lemma MulComm_11778(k: real, c: real)\n ensures k * c == c * k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_11779","instance":11779,"id":181778,"goal":"lemma MulAssoc_11779(m: int, z: int, x: int)\n ensures (m * z) * x == m * (z * x)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_11780","instance":11780,"id":181779,"goal":"lemma Distrib_11780(x: nat, m: nat, a: nat)\n ensures x * (m + a) == x * m + x * a\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_11781","instance":11781,"id":181780,"goal":"lemma AddZero_11781(n: real)\n ensures n + 0 == n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_11782","instance":11782,"id":181781,"goal":"lemma MulOne_11782(m: int)\n ensures m * 1 == m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_11783","instance":11783,"id":181782,"goal":"lemma MulZero_11783(k: nat)\n ensures k * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_11784","instance":11784,"id":181783,"goal":"lemma LeRefl_11784(n: real)\n ensures n <= n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_11785","instance":11785,"id":181784,"goal":"lemma LeTrans_11785(c: int, a: int, b: int)\n requires c <= a && a <= b\n ensures c <= b\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_11786","instance":11786,"id":181785,"goal":"lemma AddMono_11786(d: nat, i: nat, k: nat)\n requires d <= i\n ensures d + k <= i + k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_11787","instance":11787,"id":181786,"goal":"lemma Abs_Nonneg_11787(m: real)\n ensures (if m >= 0 then m else -m) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_11788","instance":11788,"id":181787,"goal":"lemma DivMod_11788(d: int, j: int)\n requires j > 0\n ensures d == j * (d / j) + (d % j)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_11789","instance":11789,"id":181788,"goal":"lemma ModBounds_11789(n: nat, j: nat)\n requires j > 0\n ensures 0 <= n % j < j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_11790","instance":11790,"id":181789,"goal":"lemma Square_Nonneg_11790(a: real)\n ensures a * a >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_11791","instance":11791,"id":181790,"goal":"lemma AddComm_11791(n: int, x: int)\n ensures n + x == x + n\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_11792","instance":11792,"id":181791,"goal":"lemma AddAssoc_11792(x: nat, a: nat, c: nat)\n ensures (x + a) + c == x + (a + c)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_11793","instance":11793,"id":181792,"goal":"lemma MulComm_11793(z: real, y: real)\n ensures z * y == y * z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_11794","instance":11794,"id":181793,"goal":"lemma MulAssoc_11794(j: int, i: int, n: int)\n ensures (j * i) * n == j * (i * n)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_11795","instance":11795,"id":181794,"goal":"lemma Distrib_11795(z: nat, j: nat, y: nat)\n ensures z * (j + y) == z * j + z * y\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_11796","instance":11796,"id":181795,"goal":"lemma AddZero_11796(k: real)\n ensures k + 0 == k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_11797","instance":11797,"id":181796,"goal":"lemma MulOne_11797(k: int)\n ensures k * 1 == k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_11798","instance":11798,"id":181797,"goal":"lemma MulZero_11798(m: nat)\n ensures m * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_11799","instance":11799,"id":181798,"goal":"lemma LeRefl_11799(a: real)\n ensures a <= a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_11800","instance":11800,"id":181799,"goal":"lemma LeTrans_11800(n: int, c: int, i: int)\n requires n <= c && c <= i\n ensures n <= i\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_11801","instance":11801,"id":181800,"goal":"lemma AddMono_11801(n: nat, k: nat, m: nat)\n requires n <= k\n ensures n + m <= k + m\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_11802","instance":11802,"id":181801,"goal":"lemma Abs_Nonneg_11802(k: real)\n ensures (if k >= 0 then k else -k) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_11803","instance":11803,"id":181802,"goal":"lemma DivMod_11803(k: int, n: int)\n requires n > 0\n ensures k == n * (k / n) + (k % n)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_11804","instance":11804,"id":181803,"goal":"lemma ModBounds_11804(n: nat, a: nat)\n requires a > 0\n ensures 0 <= n % a < a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_11805","instance":11805,"id":181804,"goal":"lemma Square_Nonneg_11805(y: real)\n ensures y * y >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_11806","instance":11806,"id":181805,"goal":"lemma AddComm_11806(x: int, d: int)\n ensures x + d == d + x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_11807","instance":11807,"id":181806,"goal":"lemma AddAssoc_11807(y: nat, b: nat, j: nat)\n ensures (y + b) + j == y + (b + j)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_11808","instance":11808,"id":181807,"goal":"lemma MulComm_11808(c: real, n: real)\n ensures c * n == n * c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_11809","instance":11809,"id":181808,"goal":"lemma MulAssoc_11809(x: int, d: int, k: int)\n ensures (x * d) * k == x * (d * k)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_11810","instance":11810,"id":181809,"goal":"lemma Distrib_11810(j: nat, n: nat, k: nat)\n ensures j * (n + k) == j * n + j * k\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_11811","instance":11811,"id":181810,"goal":"lemma AddZero_11811(y: real)\n ensures y + 0 == y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_11812","instance":11812,"id":181811,"goal":"lemma MulOne_11812(x: int)\n ensures x * 1 == x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_11813","instance":11813,"id":181812,"goal":"lemma MulZero_11813(k: nat)\n ensures k * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_11814","instance":11814,"id":181813,"goal":"lemma LeRefl_11814(d: real)\n ensures d <= d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_11815","instance":11815,"id":181814,"goal":"lemma LeTrans_11815(a: int, y: int, x: int)\n requires a <= y && y <= x\n ensures a <= x\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_11816","instance":11816,"id":181815,"goal":"lemma AddMono_11816(k: nat, c: nat, x: nat)\n requires k <= c\n ensures k + x <= c + x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_11817","instance":11817,"id":181816,"goal":"lemma Abs_Nonneg_11817(k: real)\n ensures (if k >= 0 then k else -k) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_11818","instance":11818,"id":181817,"goal":"lemma DivMod_11818(n: int, m: int)\n requires m > 0\n ensures n == m * (n / m) + (n % m)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_11819","instance":11819,"id":181818,"goal":"lemma ModBounds_11819(a: nat, c: nat)\n requires c > 0\n ensures 0 <= a % c < c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_11820","instance":11820,"id":181819,"goal":"lemma Square_Nonneg_11820(d: real)\n ensures d * d >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_11821","instance":11821,"id":181820,"goal":"lemma AddComm_11821(y: int, d: int)\n ensures y + d == d + y\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_11822","instance":11822,"id":181821,"goal":"lemma AddAssoc_11822(y: nat, d: nat, k: nat)\n ensures (y + d) + k == y + (d + k)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_11823","instance":11823,"id":181822,"goal":"lemma MulComm_11823(x: real, z: real)\n ensures x * z == z * x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_11824","instance":11824,"id":181823,"goal":"lemma MulAssoc_11824(x: int, d: int, z: int)\n ensures (x * d) * z == x * (d * z)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_11825","instance":11825,"id":181824,"goal":"lemma Distrib_11825(y: nat, k: nat, a: nat)\n ensures y * (k + a) == y * k + y * a\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_11826","instance":11826,"id":181825,"goal":"lemma AddZero_11826(d: real)\n ensures d + 0 == d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_11827","instance":11827,"id":181826,"goal":"lemma MulOne_11827(d: int)\n ensures d * 1 == d\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_11828","instance":11828,"id":181827,"goal":"lemma MulZero_11828(a: nat)\n ensures a * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_11829","instance":11829,"id":181828,"goal":"lemma LeRefl_11829(m: real)\n ensures m <= m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_11830","instance":11830,"id":181829,"goal":"lemma LeTrans_11830(y: int, n: int, m: int)\n requires y <= n && n <= m\n ensures y <= m\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_11831","instance":11831,"id":181830,"goal":"lemma AddMono_11831(a: nat, k: nat, b: nat)\n requires a <= k\n ensures a + b <= k + b\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_11832","instance":11832,"id":181831,"goal":"lemma Abs_Nonneg_11832(k: real)\n ensures (if k >= 0 then k else -k) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_11833","instance":11833,"id":181832,"goal":"lemma DivMod_11833(a: int, c: int)\n requires c > 0\n ensures a == c * (a / c) + (a % c)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_11834","instance":11834,"id":181833,"goal":"lemma ModBounds_11834(y: nat, a: nat)\n requires a > 0\n ensures 0 <= y % a < a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_11835","instance":11835,"id":181834,"goal":"lemma Square_Nonneg_11835(c: real)\n ensures c * c >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_11836","instance":11836,"id":181835,"goal":"lemma AddComm_11836(x: int, b: int)\n ensures x + b == b + x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_11837","instance":11837,"id":181836,"goal":"lemma AddAssoc_11837(z: nat, a: nat, d: nat)\n ensures (z + a) + d == z + (a + d)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_11838","instance":11838,"id":181837,"goal":"lemma MulComm_11838(i: real, j: real)\n ensures i * j == j * i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_11839","instance":11839,"id":181838,"goal":"lemma MulAssoc_11839(z: int, m: int, c: int)\n ensures (z * m) * c == z * (m * c)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_11840","instance":11840,"id":181839,"goal":"lemma Distrib_11840(i: nat, k: nat, m: nat)\n ensures i * (k + m) == i * k + i * m\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_11841","instance":11841,"id":181840,"goal":"lemma AddZero_11841(b: real)\n ensures b + 0 == b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_11842","instance":11842,"id":181841,"goal":"lemma MulOne_11842(c: int)\n ensures c * 1 == c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_11843","instance":11843,"id":181842,"goal":"lemma MulZero_11843(x: nat)\n ensures x * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_11844","instance":11844,"id":181843,"goal":"lemma LeRefl_11844(j: real)\n ensures j <= j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_11845","instance":11845,"id":181844,"goal":"lemma LeTrans_11845(y: int, i: int, m: int)\n requires y <= i && i <= m\n ensures y <= m\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_11846","instance":11846,"id":181845,"goal":"lemma AddMono_11846(x: nat, k: nat, y: nat)\n requires x <= k\n ensures x + y <= k + y\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_11847","instance":11847,"id":181846,"goal":"lemma Abs_Nonneg_11847(k: real)\n ensures (if k >= 0 then k else -k) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_11848","instance":11848,"id":181847,"goal":"lemma DivMod_11848(i: int, c: int)\n requires c > 0\n ensures i == c * (i / c) + (i % c)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_11849","instance":11849,"id":181848,"goal":"lemma ModBounds_11849(k: nat, m: nat)\n requires m > 0\n ensures 0 <= k % m < m\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_11850","instance":11850,"id":181849,"goal":"lemma Square_Nonneg_11850(x: real)\n ensures x * x >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_11851","instance":11851,"id":181850,"goal":"lemma AddComm_11851(c: int, a: int)\n ensures c + a == a + c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_11852","instance":11852,"id":181851,"goal":"lemma AddAssoc_11852(d: nat, z: nat, i: nat)\n ensures (d + z) + i == d + (z + i)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_11853","instance":11853,"id":181852,"goal":"lemma MulComm_11853(n: real, x: real)\n ensures n * x == x * n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_11854","instance":11854,"id":181853,"goal":"lemma MulAssoc_11854(b: int, z: int, d: int)\n ensures (b * z) * d == b * (z * d)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_11855","instance":11855,"id":181854,"goal":"lemma Distrib_11855(a: nat, b: nat, z: nat)\n ensures a * (b + z) == a * b + a * z\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_11856","instance":11856,"id":181855,"goal":"lemma AddZero_11856(b: real)\n ensures b + 0 == b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_11857","instance":11857,"id":181856,"goal":"lemma MulOne_11857(z: int)\n ensures z * 1 == z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_11858","instance":11858,"id":181857,"goal":"lemma MulZero_11858(b: nat)\n ensures b * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_11859","instance":11859,"id":181858,"goal":"lemma LeRefl_11859(c: real)\n ensures c <= c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_11860","instance":11860,"id":181859,"goal":"lemma LeTrans_11860(j: int, d: int, a: int)\n requires j <= d && d <= a\n ensures j <= a\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_11861","instance":11861,"id":181860,"goal":"lemma AddMono_11861(b: nat, n: nat, y: nat)\n requires b <= n\n ensures b + y <= n + y\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_11862","instance":11862,"id":181861,"goal":"lemma Abs_Nonneg_11862(m: real)\n ensures (if m >= 0 then m else -m) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_11863","instance":11863,"id":181862,"goal":"lemma DivMod_11863(z: int, d: int)\n requires d > 0\n ensures z == d * (z / d) + (z % d)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_11864","instance":11864,"id":181863,"goal":"lemma ModBounds_11864(d: nat, y: nat)\n requires y > 0\n ensures 0 <= d % y < y\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_11865","instance":11865,"id":181864,"goal":"lemma Square_Nonneg_11865(n: real)\n ensures n * n >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_11866","instance":11866,"id":181865,"goal":"lemma AddComm_11866(x: int, y: int)\n ensures x + y == y + x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_11867","instance":11867,"id":181866,"goal":"lemma AddAssoc_11867(j: nat, c: nat, z: nat)\n ensures (j + c) + z == j + (c + z)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_11868","instance":11868,"id":181867,"goal":"lemma MulComm_11868(b: real, i: real)\n ensures b * i == i * b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_11869","instance":11869,"id":181868,"goal":"lemma MulAssoc_11869(i: int, k: int, n: int)\n ensures (i * k) * n == i * (k * n)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_11870","instance":11870,"id":181869,"goal":"lemma Distrib_11870(k: nat, b: nat, x: nat)\n ensures k * (b + x) == k * b + k * x\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_11871","instance":11871,"id":181870,"goal":"lemma AddZero_11871(i: real)\n ensures i + 0 == i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_11872","instance":11872,"id":181871,"goal":"lemma MulOne_11872(k: int)\n ensures k * 1 == k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_11873","instance":11873,"id":181872,"goal":"lemma MulZero_11873(d: nat)\n ensures d * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_11874","instance":11874,"id":181873,"goal":"lemma LeRefl_11874(j: real)\n ensures j <= j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_11875","instance":11875,"id":181874,"goal":"lemma LeTrans_11875(b: int, z: int, y: int)\n requires b <= z && z <= y\n ensures b <= y\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_11876","instance":11876,"id":181875,"goal":"lemma AddMono_11876(c: nat, d: nat, m: nat)\n requires c <= d\n ensures c + m <= d + m\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_11877","instance":11877,"id":181876,"goal":"lemma Abs_Nonneg_11877(x: real)\n ensures (if x >= 0 then x else -x) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_11878","instance":11878,"id":181877,"goal":"lemma DivMod_11878(k: int, j: int)\n requires j > 0\n ensures k == j * (k / j) + (k % j)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_11879","instance":11879,"id":181878,"goal":"lemma ModBounds_11879(i: nat, z: nat)\n requires z > 0\n ensures 0 <= i % z < z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_11880","instance":11880,"id":181879,"goal":"lemma Square_Nonneg_11880(i: real)\n ensures i * i >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_11881","instance":11881,"id":181880,"goal":"lemma AddComm_11881(i: int, y: int)\n ensures i + y == y + i\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_11882","instance":11882,"id":181881,"goal":"lemma AddAssoc_11882(j: nat, i: nat, a: nat)\n ensures (j + i) + a == j + (i + a)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_11883","instance":11883,"id":181882,"goal":"lemma MulComm_11883(b: real, x: real)\n ensures b * x == x * b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_11884","instance":11884,"id":181883,"goal":"lemma MulAssoc_11884(j: int, k: int, a: int)\n ensures (j * k) * a == j * (k * a)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_11885","instance":11885,"id":181884,"goal":"lemma Distrib_11885(a: nat, m: nat, b: nat)\n ensures a * (m + b) == a * m + a * b\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_11886","instance":11886,"id":181885,"goal":"lemma AddZero_11886(c: real)\n ensures c + 0 == c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_11887","instance":11887,"id":181886,"goal":"lemma MulOne_11887(x: int)\n ensures x * 1 == x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_11888","instance":11888,"id":181887,"goal":"lemma MulZero_11888(b: nat)\n ensures b * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_11889","instance":11889,"id":181888,"goal":"lemma LeRefl_11889(i: real)\n ensures i <= i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_11890","instance":11890,"id":181889,"goal":"lemma LeTrans_11890(a: int, m: int, k: int)\n requires a <= m && m <= k\n ensures a <= k\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_11891","instance":11891,"id":181890,"goal":"lemma AddMono_11891(z: nat, j: nat, m: nat)\n requires z <= j\n ensures z + m <= j + m\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_11892","instance":11892,"id":181891,"goal":"lemma Abs_Nonneg_11892(k: real)\n ensures (if k >= 0 then k else -k) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_11893","instance":11893,"id":181892,"goal":"lemma DivMod_11893(b: int, k: int)\n requires k > 0\n ensures b == k * (b / k) + (b % k)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_11894","instance":11894,"id":181893,"goal":"lemma ModBounds_11894(n: nat, j: nat)\n requires j > 0\n ensures 0 <= n % j < j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_11895","instance":11895,"id":181894,"goal":"lemma Square_Nonneg_11895(n: real)\n ensures n * n >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_11896","instance":11896,"id":181895,"goal":"lemma AddComm_11896(j: int, i: int)\n ensures j + i == i + j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_11897","instance":11897,"id":181896,"goal":"lemma AddAssoc_11897(x: nat, i: nat, d: nat)\n ensures (x + i) + d == x + (i + d)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_11898","instance":11898,"id":181897,"goal":"lemma MulComm_11898(b: real, a: real)\n ensures b * a == a * b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_11899","instance":11899,"id":181898,"goal":"lemma MulAssoc_11899(x: int, d: int, a: int)\n ensures (x * d) * a == x * (d * a)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_11900","instance":11900,"id":181899,"goal":"lemma Distrib_11900(y: nat, n: nat, m: nat)\n ensures y * (n + m) == y * n + y * m\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_11901","instance":11901,"id":181900,"goal":"lemma AddZero_11901(a: real)\n ensures a + 0 == a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_11902","instance":11902,"id":181901,"goal":"lemma MulOne_11902(m: int)\n ensures m * 1 == m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_11903","instance":11903,"id":181902,"goal":"lemma MulZero_11903(n: nat)\n ensures n * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_11904","instance":11904,"id":181903,"goal":"lemma LeRefl_11904(n: real)\n ensures n <= n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_11905","instance":11905,"id":181904,"goal":"lemma LeTrans_11905(i: int, c: int, x: int)\n requires i <= c && c <= x\n ensures i <= x\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_11906","instance":11906,"id":181905,"goal":"lemma AddMono_11906(j: nat, m: nat, d: nat)\n requires j <= m\n ensures j + d <= m + d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_11907","instance":11907,"id":181906,"goal":"lemma Abs_Nonneg_11907(b: real)\n ensures (if b >= 0 then b else -b) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_11908","instance":11908,"id":181907,"goal":"lemma DivMod_11908(n: int, a: int)\n requires a > 0\n ensures n == a * (n / a) + (n % a)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_11909","instance":11909,"id":181908,"goal":"lemma ModBounds_11909(m: nat, d: nat)\n requires d > 0\n ensures 0 <= m % d < d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_11910","instance":11910,"id":181909,"goal":"lemma Square_Nonneg_11910(x: real)\n ensures x * x >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_11911","instance":11911,"id":181910,"goal":"lemma AddComm_11911(y: int, k: int)\n ensures y + k == k + y\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_11912","instance":11912,"id":181911,"goal":"lemma AddAssoc_11912(k: nat, z: nat, n: nat)\n ensures (k + z) + n == k + (z + n)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_11913","instance":11913,"id":181912,"goal":"lemma MulComm_11913(x: real, d: real)\n ensures x * d == d * x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_11914","instance":11914,"id":181913,"goal":"lemma MulAssoc_11914(k: int, c: int, y: int)\n ensures (k * c) * y == k * (c * y)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_11915","instance":11915,"id":181914,"goal":"lemma Distrib_11915(a: nat, n: nat, j: nat)\n ensures a * (n + j) == a * n + a * j\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_11916","instance":11916,"id":181915,"goal":"lemma AddZero_11916(a: real)\n ensures a + 0 == a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_11917","instance":11917,"id":181916,"goal":"lemma MulOne_11917(n: int)\n ensures n * 1 == n\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_11918","instance":11918,"id":181917,"goal":"lemma MulZero_11918(z: nat)\n ensures z * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_11919","instance":11919,"id":181918,"goal":"lemma LeRefl_11919(a: real)\n ensures a <= a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_11920","instance":11920,"id":181919,"goal":"lemma LeTrans_11920(a: int, x: int, j: int)\n requires a <= x && x <= j\n ensures a <= j\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_11921","instance":11921,"id":181920,"goal":"lemma AddMono_11921(n: nat, j: nat, m: nat)\n requires n <= j\n ensures n + m <= j + m\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_11922","instance":11922,"id":181921,"goal":"lemma Abs_Nonneg_11922(c: real)\n ensures (if c >= 0 then c else -c) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_11923","instance":11923,"id":181922,"goal":"lemma DivMod_11923(d: int, n: int)\n requires n > 0\n ensures d == n * (d / n) + (d % n)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_11924","instance":11924,"id":181923,"goal":"lemma ModBounds_11924(k: nat, m: nat)\n requires m > 0\n ensures 0 <= k % m < m\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_11925","instance":11925,"id":181924,"goal":"lemma Square_Nonneg_11925(n: real)\n ensures n * n >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_11926","instance":11926,"id":181925,"goal":"lemma AddComm_11926(j: int, k: int)\n ensures j + k == k + j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_11927","instance":11927,"id":181926,"goal":"lemma AddAssoc_11927(m: nat, x: nat, n: nat)\n ensures (m + x) + n == m + (x + n)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_11928","instance":11928,"id":181927,"goal":"lemma MulComm_11928(n: real, z: real)\n ensures n * z == z * n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_11929","instance":11929,"id":181928,"goal":"lemma MulAssoc_11929(c: int, a: int, i: int)\n ensures (c * a) * i == c * (a * i)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_11930","instance":11930,"id":181929,"goal":"lemma Distrib_11930(m: nat, z: nat, i: nat)\n ensures m * (z + i) == m * z + m * i\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_11931","instance":11931,"id":181930,"goal":"lemma AddZero_11931(y: real)\n ensures y + 0 == y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_11932","instance":11932,"id":181931,"goal":"lemma MulOne_11932(z: int)\n ensures z * 1 == z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_11933","instance":11933,"id":181932,"goal":"lemma MulZero_11933(y: nat)\n ensures y * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_11934","instance":11934,"id":181933,"goal":"lemma LeRefl_11934(m: real)\n ensures m <= m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_11935","instance":11935,"id":181934,"goal":"lemma LeTrans_11935(i: int, b: int, j: int)\n requires i <= b && b <= j\n ensures i <= j\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_11936","instance":11936,"id":181935,"goal":"lemma AddMono_11936(a: nat, n: nat, d: nat)\n requires a <= n\n ensures a + d <= n + d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_11937","instance":11937,"id":181936,"goal":"lemma Abs_Nonneg_11937(d: real)\n ensures (if d >= 0 then d else -d) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_11938","instance":11938,"id":181937,"goal":"lemma DivMod_11938(z: int, d: int)\n requires d > 0\n ensures z == d * (z / d) + (z % d)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_11939","instance":11939,"id":181938,"goal":"lemma ModBounds_11939(j: nat, k: nat)\n requires k > 0\n ensures 0 <= j % k < k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_11940","instance":11940,"id":181939,"goal":"lemma Square_Nonneg_11940(i: real)\n ensures i * i >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_11941","instance":11941,"id":181940,"goal":"lemma AddComm_11941(m: int, b: int)\n ensures m + b == b + m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_11942","instance":11942,"id":181941,"goal":"lemma AddAssoc_11942(n: nat, y: nat, x: nat)\n ensures (n + y) + x == n + (y + x)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_11943","instance":11943,"id":181942,"goal":"lemma MulComm_11943(z: real, i: real)\n ensures z * i == i * z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_11944","instance":11944,"id":181943,"goal":"lemma MulAssoc_11944(j: int, k: int, n: int)\n ensures (j * k) * n == j * (k * n)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_11945","instance":11945,"id":181944,"goal":"lemma Distrib_11945(x: nat, n: nat, y: nat)\n ensures x * (n + y) == x * n + x * y\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_11946","instance":11946,"id":181945,"goal":"lemma AddZero_11946(d: real)\n ensures d + 0 == d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_11947","instance":11947,"id":181946,"goal":"lemma MulOne_11947(a: int)\n ensures a * 1 == a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_11948","instance":11948,"id":181947,"goal":"lemma MulZero_11948(j: nat)\n ensures j * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_11949","instance":11949,"id":181948,"goal":"lemma LeRefl_11949(i: real)\n ensures i <= i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_11950","instance":11950,"id":181949,"goal":"lemma LeTrans_11950(a: int, b: int, n: int)\n requires a <= b && b <= n\n ensures a <= n\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_11951","instance":11951,"id":181950,"goal":"lemma AddMono_11951(a: nat, n: nat, k: nat)\n requires a <= n\n ensures a + k <= n + k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_11952","instance":11952,"id":181951,"goal":"lemma Abs_Nonneg_11952(a: real)\n ensures (if a >= 0 then a else -a) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_11953","instance":11953,"id":181952,"goal":"lemma DivMod_11953(m: int, z: int)\n requires z > 0\n ensures m == z * (m / z) + (m % z)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_11954","instance":11954,"id":181953,"goal":"lemma ModBounds_11954(b: nat, k: nat)\n requires k > 0\n ensures 0 <= b % k < k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_11955","instance":11955,"id":181954,"goal":"lemma Square_Nonneg_11955(a: real)\n ensures a * a >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_11956","instance":11956,"id":181955,"goal":"lemma AddComm_11956(k: int, n: int)\n ensures k + n == n + k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_11957","instance":11957,"id":181956,"goal":"lemma AddAssoc_11957(k: nat, b: nat, d: nat)\n ensures (k + b) + d == k + (b + d)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_11958","instance":11958,"id":181957,"goal":"lemma MulComm_11958(z: real, i: real)\n ensures z * i == i * z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_11959","instance":11959,"id":181958,"goal":"lemma MulAssoc_11959(n: int, k: int, a: int)\n ensures (n * k) * a == n * (k * a)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_11960","instance":11960,"id":181959,"goal":"lemma Distrib_11960(j: nat, k: nat, x: nat)\n ensures j * (k + x) == j * k + j * x\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_11961","instance":11961,"id":181960,"goal":"lemma AddZero_11961(b: real)\n ensures b + 0 == b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_11962","instance":11962,"id":181961,"goal":"lemma MulOne_11962(i: int)\n ensures i * 1 == i\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_11963","instance":11963,"id":181962,"goal":"lemma MulZero_11963(z: nat)\n ensures z * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_11964","instance":11964,"id":181963,"goal":"lemma LeRefl_11964(x: real)\n ensures x <= x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_11965","instance":11965,"id":181964,"goal":"lemma LeTrans_11965(j: int, i: int, a: int)\n requires j <= i && i <= a\n ensures j <= a\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_11966","instance":11966,"id":181965,"goal":"lemma AddMono_11966(z: nat, k: nat, j: nat)\n requires z <= k\n ensures z + j <= k + j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_11967","instance":11967,"id":181966,"goal":"lemma Abs_Nonneg_11967(j: real)\n ensures (if j >= 0 then j else -j) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_11968","instance":11968,"id":181967,"goal":"lemma DivMod_11968(j: int, n: int)\n requires n > 0\n ensures j == n * (j / n) + (j % n)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_11969","instance":11969,"id":181968,"goal":"lemma ModBounds_11969(k: nat, b: nat)\n requires b > 0\n ensures 0 <= k % b < b\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_11970","instance":11970,"id":181969,"goal":"lemma Square_Nonneg_11970(m: real)\n ensures m * m >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_11971","instance":11971,"id":181970,"goal":"lemma AddComm_11971(n: int, z: int)\n ensures n + z == z + n\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_11972","instance":11972,"id":181971,"goal":"lemma AddAssoc_11972(z: nat, y: nat, d: nat)\n ensures (z + y) + d == z + (y + d)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_11973","instance":11973,"id":181972,"goal":"lemma MulComm_11973(x: real, d: real)\n ensures x * d == d * x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_11974","instance":11974,"id":181973,"goal":"lemma MulAssoc_11974(n: int, d: int, z: int)\n ensures (n * d) * z == n * (d * z)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_11975","instance":11975,"id":181974,"goal":"lemma Distrib_11975(b: nat, d: nat, i: nat)\n ensures b * (d + i) == b * d + b * i\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_11976","instance":11976,"id":181975,"goal":"lemma AddZero_11976(z: real)\n ensures z + 0 == z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_11977","instance":11977,"id":181976,"goal":"lemma MulOne_11977(k: int)\n ensures k * 1 == k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_11978","instance":11978,"id":181977,"goal":"lemma MulZero_11978(c: nat)\n ensures c * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_11979","instance":11979,"id":181978,"goal":"lemma LeRefl_11979(a: real)\n ensures a <= a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_11980","instance":11980,"id":181979,"goal":"lemma LeTrans_11980(x: int, c: int, i: int)\n requires x <= c && c <= i\n ensures x <= i\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_11981","instance":11981,"id":181980,"goal":"lemma AddMono_11981(z: nat, j: nat, y: nat)\n requires z <= j\n ensures z + y <= j + y\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_11982","instance":11982,"id":181981,"goal":"lemma Abs_Nonneg_11982(n: real)\n ensures (if n >= 0 then n else -n) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_11983","instance":11983,"id":181982,"goal":"lemma DivMod_11983(c: int, k: int)\n requires k > 0\n ensures c == k * (c / k) + (c % k)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_11984","instance":11984,"id":181983,"goal":"lemma ModBounds_11984(a: nat, x: nat)\n requires x > 0\n ensures 0 <= a % x < x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_11985","instance":11985,"id":181984,"goal":"lemma Square_Nonneg_11985(i: real)\n ensures i * i >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_11986","instance":11986,"id":181985,"goal":"lemma AddComm_11986(n: int, m: int)\n ensures n + m == m + n\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_11987","instance":11987,"id":181986,"goal":"lemma AddAssoc_11987(i: nat, c: nat, k: nat)\n ensures (i + c) + k == i + (c + k)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_11988","instance":11988,"id":181987,"goal":"lemma MulComm_11988(c: real, a: real)\n ensures c * a == a * c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_11989","instance":11989,"id":181988,"goal":"lemma MulAssoc_11989(a: int, b: int, c: int)\n ensures (a * b) * c == a * (b * c)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_11990","instance":11990,"id":181989,"goal":"lemma Distrib_11990(j: nat, z: nat, y: nat)\n ensures j * (z + y) == j * z + j * y\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_11991","instance":11991,"id":181990,"goal":"lemma AddZero_11991(j: real)\n ensures j + 0 == j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_11992","instance":11992,"id":181991,"goal":"lemma MulOne_11992(n: int)\n ensures n * 1 == n\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_11993","instance":11993,"id":181992,"goal":"lemma MulZero_11993(c: nat)\n ensures c * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_11994","instance":11994,"id":181993,"goal":"lemma LeRefl_11994(k: real)\n ensures k <= k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_11995","instance":11995,"id":181994,"goal":"lemma LeTrans_11995(c: int, x: int, j: int)\n requires c <= x && x <= j\n ensures c <= j\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_11996","instance":11996,"id":181995,"goal":"lemma AddMono_11996(j: nat, z: nat, c: nat)\n requires j <= z\n ensures j + c <= z + c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_11997","instance":11997,"id":181996,"goal":"lemma Abs_Nonneg_11997(k: real)\n ensures (if k >= 0 then k else -k) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_11998","instance":11998,"id":181997,"goal":"lemma DivMod_11998(j: int, n: int)\n requires n > 0\n ensures j == n * (j / n) + (j % n)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_11999","instance":11999,"id":181998,"goal":"lemma ModBounds_11999(n: nat, x: nat)\n requires x > 0\n ensures 0 <= n % x < x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_12000","instance":12000,"id":181999,"goal":"lemma Square_Nonneg_12000(n: real)\n ensures n * n >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_12001","instance":12001,"id":182000,"goal":"lemma AddComm_12001(x: int, b: int)\n ensures x + b == b + x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_12002","instance":12002,"id":182001,"goal":"lemma AddAssoc_12002(i: nat, x: nat, m: nat)\n ensures (i + x) + m == i + (x + m)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_12003","instance":12003,"id":182002,"goal":"lemma MulComm_12003(z: real, b: real)\n ensures z * b == b * z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_12004","instance":12004,"id":182003,"goal":"lemma MulAssoc_12004(n: int, b: int, d: int)\n ensures (n * b) * d == n * (b * d)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_12005","instance":12005,"id":182004,"goal":"lemma Distrib_12005(i: nat, d: nat, a: nat)\n ensures i * (d + a) == i * d + i * a\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_12006","instance":12006,"id":182005,"goal":"lemma AddZero_12006(d: real)\n ensures d + 0 == d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_12007","instance":12007,"id":182006,"goal":"lemma MulOne_12007(m: int)\n ensures m * 1 == m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_12008","instance":12008,"id":182007,"goal":"lemma MulZero_12008(i: nat)\n ensures i * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_12009","instance":12009,"id":182008,"goal":"lemma LeRefl_12009(y: real)\n ensures y <= y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_12010","instance":12010,"id":182009,"goal":"lemma LeTrans_12010(i: int, k: int, d: int)\n requires i <= k && k <= d\n ensures i <= d\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_12011","instance":12011,"id":182010,"goal":"lemma AddMono_12011(y: nat, x: nat, j: nat)\n requires y <= x\n ensures y + j <= x + j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_12012","instance":12012,"id":182011,"goal":"lemma Abs_Nonneg_12012(i: real)\n ensures (if i >= 0 then i else -i) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_12013","instance":12013,"id":182012,"goal":"lemma DivMod_12013(m: int, y: int)\n requires y > 0\n ensures m == y * (m / y) + (m % y)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_12014","instance":12014,"id":182013,"goal":"lemma ModBounds_12014(j: nat, c: nat)\n requires c > 0\n ensures 0 <= j % c < c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_12015","instance":12015,"id":182014,"goal":"lemma Square_Nonneg_12015(z: real)\n ensures z * z >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_12016","instance":12016,"id":182015,"goal":"lemma AddComm_12016(z: int, i: int)\n ensures z + i == i + z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_12017","instance":12017,"id":182016,"goal":"lemma AddAssoc_12017(x: nat, a: nat, m: nat)\n ensures (x + a) + m == x + (a + m)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_12018","instance":12018,"id":182017,"goal":"lemma MulComm_12018(z: real, x: real)\n ensures z * x == x * z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_12019","instance":12019,"id":182018,"goal":"lemma MulAssoc_12019(a: int, c: int, j: int)\n ensures (a * c) * j == a * (c * j)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_12020","instance":12020,"id":182019,"goal":"lemma Distrib_12020(k: nat, a: nat, m: nat)\n ensures k * (a + m) == k * a + k * m\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_12021","instance":12021,"id":182020,"goal":"lemma AddZero_12021(d: real)\n ensures d + 0 == d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_12022","instance":12022,"id":182021,"goal":"lemma MulOne_12022(x: int)\n ensures x * 1 == x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_12023","instance":12023,"id":182022,"goal":"lemma MulZero_12023(x: nat)\n ensures x * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_12024","instance":12024,"id":182023,"goal":"lemma LeRefl_12024(b: real)\n ensures b <= b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_12025","instance":12025,"id":182024,"goal":"lemma LeTrans_12025(y: int, n: int, j: int)\n requires y <= n && n <= j\n ensures y <= j\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_12026","instance":12026,"id":182025,"goal":"lemma AddMono_12026(k: nat, i: nat, n: nat)\n requires k <= i\n ensures k + n <= i + n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_12027","instance":12027,"id":182026,"goal":"lemma Abs_Nonneg_12027(d: real)\n ensures (if d >= 0 then d else -d) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_12028","instance":12028,"id":182027,"goal":"lemma DivMod_12028(n: int, x: int)\n requires x > 0\n ensures n == x * (n / x) + (n % x)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_12029","instance":12029,"id":182028,"goal":"lemma ModBounds_12029(z: nat, a: nat)\n requires a > 0\n ensures 0 <= z % a < a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_12030","instance":12030,"id":182029,"goal":"lemma Square_Nonneg_12030(i: real)\n ensures i * i >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_12031","instance":12031,"id":182030,"goal":"lemma AddComm_12031(a: int, c: int)\n ensures a + c == c + a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_12032","instance":12032,"id":182031,"goal":"lemma AddAssoc_12032(i: nat, c: nat, j: nat)\n ensures (i + c) + j == i + (c + j)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_12033","instance":12033,"id":182032,"goal":"lemma MulComm_12033(k: real, a: real)\n ensures k * a == a * k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_12034","instance":12034,"id":182033,"goal":"lemma MulAssoc_12034(y: int, x: int, d: int)\n ensures (y * x) * d == y * (x * d)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_12035","instance":12035,"id":182034,"goal":"lemma Distrib_12035(a: nat, d: nat, i: nat)\n ensures a * (d + i) == a * d + a * i\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_12036","instance":12036,"id":182035,"goal":"lemma AddZero_12036(y: real)\n ensures y + 0 == y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_12037","instance":12037,"id":182036,"goal":"lemma MulOne_12037(x: int)\n ensures x * 1 == x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_12038","instance":12038,"id":182037,"goal":"lemma MulZero_12038(d: nat)\n ensures d * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_12039","instance":12039,"id":182038,"goal":"lemma LeRefl_12039(b: real)\n ensures b <= b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_12040","instance":12040,"id":182039,"goal":"lemma LeTrans_12040(m: int, a: int, x: int)\n requires m <= a && a <= x\n ensures m <= x\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_12041","instance":12041,"id":182040,"goal":"lemma AddMono_12041(a: nat, k: nat, y: nat)\n requires a <= k\n ensures a + y <= k + y\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_12042","instance":12042,"id":182041,"goal":"lemma Abs_Nonneg_12042(j: real)\n ensures (if j >= 0 then j else -j) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_12043","instance":12043,"id":182042,"goal":"lemma DivMod_12043(z: int, k: int)\n requires k > 0\n ensures z == k * (z / k) + (z % k)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_12044","instance":12044,"id":182043,"goal":"lemma ModBounds_12044(z: nat, y: nat)\n requires y > 0\n ensures 0 <= z % y < y\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_12045","instance":12045,"id":182044,"goal":"lemma Square_Nonneg_12045(a: real)\n ensures a * a >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_12046","instance":12046,"id":182045,"goal":"lemma AddComm_12046(a: int, y: int)\n ensures a + y == y + a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_12047","instance":12047,"id":182046,"goal":"lemma AddAssoc_12047(b: nat, z: nat, a: nat)\n ensures (b + z) + a == b + (z + a)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_12048","instance":12048,"id":182047,"goal":"lemma MulComm_12048(k: real, d: real)\n ensures k * d == d * k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_12049","instance":12049,"id":182048,"goal":"lemma MulAssoc_12049(j: int, b: int, a: int)\n ensures (j * b) * a == j * (b * a)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_12050","instance":12050,"id":182049,"goal":"lemma Distrib_12050(b: nat, c: nat, x: nat)\n ensures b * (c + x) == b * c + b * x\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_12051","instance":12051,"id":182050,"goal":"lemma AddZero_12051(k: real)\n ensures k + 0 == k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_12052","instance":12052,"id":182051,"goal":"lemma MulOne_12052(d: int)\n ensures d * 1 == d\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_12053","instance":12053,"id":182052,"goal":"lemma MulZero_12053(x: nat)\n ensures x * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_12054","instance":12054,"id":182053,"goal":"lemma LeRefl_12054(n: real)\n ensures n <= n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_12055","instance":12055,"id":182054,"goal":"lemma LeTrans_12055(i: int, x: int, c: int)\n requires i <= x && x <= c\n ensures i <= c\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_12056","instance":12056,"id":182055,"goal":"lemma AddMono_12056(y: nat, d: nat, i: nat)\n requires y <= d\n ensures y + i <= d + i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_12057","instance":12057,"id":182056,"goal":"lemma Abs_Nonneg_12057(d: real)\n ensures (if d >= 0 then d else -d) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_12058","instance":12058,"id":182057,"goal":"lemma DivMod_12058(a: int, b: int)\n requires b > 0\n ensures a == b * (a / b) + (a % b)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_12059","instance":12059,"id":182058,"goal":"lemma ModBounds_12059(x: nat, k: nat)\n requires k > 0\n ensures 0 <= x % k < k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_12060","instance":12060,"id":182059,"goal":"lemma Square_Nonneg_12060(x: real)\n ensures x * x >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_12061","instance":12061,"id":182060,"goal":"lemma AddComm_12061(c: int, y: int)\n ensures c + y == y + c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_12062","instance":12062,"id":182061,"goal":"lemma AddAssoc_12062(j: nat, b: nat, a: nat)\n ensures (j + b) + a == j + (b + a)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_12063","instance":12063,"id":182062,"goal":"lemma MulComm_12063(x: real, b: real)\n ensures x * b == b * x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_12064","instance":12064,"id":182063,"goal":"lemma MulAssoc_12064(m: int, b: int, y: int)\n ensures (m * b) * y == m * (b * y)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_12065","instance":12065,"id":182064,"goal":"lemma Distrib_12065(x: nat, b: nat, m: nat)\n ensures x * (b + m) == x * b + x * m\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_12066","instance":12066,"id":182065,"goal":"lemma AddZero_12066(b: real)\n ensures b + 0 == b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_12067","instance":12067,"id":182066,"goal":"lemma MulOne_12067(j: int)\n ensures j * 1 == j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_12068","instance":12068,"id":182067,"goal":"lemma MulZero_12068(a: nat)\n ensures a * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_12069","instance":12069,"id":182068,"goal":"lemma LeRefl_12069(m: real)\n ensures m <= m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_12070","instance":12070,"id":182069,"goal":"lemma LeTrans_12070(z: int, k: int, x: int)\n requires z <= k && k <= x\n ensures z <= x\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_12071","instance":12071,"id":182070,"goal":"lemma AddMono_12071(m: nat, i: nat, k: nat)\n requires m <= i\n ensures m + k <= i + k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_12072","instance":12072,"id":182071,"goal":"lemma Abs_Nonneg_12072(m: real)\n ensures (if m >= 0 then m else -m) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_12073","instance":12073,"id":182072,"goal":"lemma DivMod_12073(k: int, i: int)\n requires i > 0\n ensures k == i * (k / i) + (k % i)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_12074","instance":12074,"id":182073,"goal":"lemma ModBounds_12074(a: nat, m: nat)\n requires m > 0\n ensures 0 <= a % m < m\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_12075","instance":12075,"id":182074,"goal":"lemma Square_Nonneg_12075(d: real)\n ensures d * d >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_12076","instance":12076,"id":182075,"goal":"lemma AddComm_12076(z: int, c: int)\n ensures z + c == c + z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_12077","instance":12077,"id":182076,"goal":"lemma AddAssoc_12077(x: nat, n: nat, z: nat)\n ensures (x + n) + z == x + (n + z)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_12078","instance":12078,"id":182077,"goal":"lemma MulComm_12078(x: real, i: real)\n ensures x * i == i * x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_12079","instance":12079,"id":182078,"goal":"lemma MulAssoc_12079(x: int, n: int, k: int)\n ensures (x * n) * k == x * (n * k)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_12080","instance":12080,"id":182079,"goal":"lemma Distrib_12080(z: nat, m: nat, x: nat)\n ensures z * (m + x) == z * m + z * x\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_12081","instance":12081,"id":182080,"goal":"lemma AddZero_12081(b: real)\n ensures b + 0 == b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_12082","instance":12082,"id":182081,"goal":"lemma MulOne_12082(z: int)\n ensures z * 1 == z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_12083","instance":12083,"id":182082,"goal":"lemma MulZero_12083(n: nat)\n ensures n * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_12084","instance":12084,"id":182083,"goal":"lemma LeRefl_12084(b: real)\n ensures b <= b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_12085","instance":12085,"id":182084,"goal":"lemma LeTrans_12085(b: int, a: int, z: int)\n requires b <= a && a <= z\n ensures b <= z\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_12086","instance":12086,"id":182085,"goal":"lemma AddMono_12086(d: nat, k: nat, y: nat)\n requires d <= k\n ensures d + y <= k + y\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_12087","instance":12087,"id":182086,"goal":"lemma Abs_Nonneg_12087(b: real)\n ensures (if b >= 0 then b else -b) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_12088","instance":12088,"id":182087,"goal":"lemma DivMod_12088(n: int, m: int)\n requires m > 0\n ensures n == m * (n / m) + (n % m)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_12089","instance":12089,"id":182088,"goal":"lemma ModBounds_12089(x: nat, i: nat)\n requires i > 0\n ensures 0 <= x % i < i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_12090","instance":12090,"id":182089,"goal":"lemma Square_Nonneg_12090(i: real)\n ensures i * i >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_12091","instance":12091,"id":182090,"goal":"lemma AddComm_12091(j: int, m: int)\n ensures j + m == m + j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_12092","instance":12092,"id":182091,"goal":"lemma AddAssoc_12092(i: nat, x: nat, c: nat)\n ensures (i + x) + c == i + (x + c)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_12093","instance":12093,"id":182092,"goal":"lemma MulComm_12093(c: real, b: real)\n ensures c * b == b * c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_12094","instance":12094,"id":182093,"goal":"lemma MulAssoc_12094(y: int, b: int, a: int)\n ensures (y * b) * a == y * (b * a)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_12095","instance":12095,"id":182094,"goal":"lemma Distrib_12095(d: nat, a: nat, x: nat)\n ensures d * (a + x) == d * a + d * x\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_12096","instance":12096,"id":182095,"goal":"lemma AddZero_12096(m: real)\n ensures m + 0 == m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_12097","instance":12097,"id":182096,"goal":"lemma MulOne_12097(z: int)\n ensures z * 1 == z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_12098","instance":12098,"id":182097,"goal":"lemma MulZero_12098(m: nat)\n ensures m * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_12099","instance":12099,"id":182098,"goal":"lemma LeRefl_12099(y: real)\n ensures y <= y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_12100","instance":12100,"id":182099,"goal":"lemma LeTrans_12100(a: int, d: int, k: int)\n requires a <= d && d <= k\n ensures a <= k\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_12101","instance":12101,"id":182100,"goal":"lemma AddMono_12101(i: nat, m: nat, d: nat)\n requires i <= m\n ensures i + d <= m + d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_12102","instance":12102,"id":182101,"goal":"lemma Abs_Nonneg_12102(d: real)\n ensures (if d >= 0 then d else -d) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_12103","instance":12103,"id":182102,"goal":"lemma DivMod_12103(j: int, a: int)\n requires a > 0\n ensures j == a * (j / a) + (j % a)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_12104","instance":12104,"id":182103,"goal":"lemma ModBounds_12104(j: nat, y: nat)\n requires y > 0\n ensures 0 <= j % y < y\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_12105","instance":12105,"id":182104,"goal":"lemma Square_Nonneg_12105(x: real)\n ensures x * x >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_12106","instance":12106,"id":182105,"goal":"lemma AddComm_12106(c: int, k: int)\n ensures c + k == k + c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_12107","instance":12107,"id":182106,"goal":"lemma AddAssoc_12107(y: nat, b: nat, i: nat)\n ensures (y + b) + i == y + (b + i)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_12108","instance":12108,"id":182107,"goal":"lemma MulComm_12108(c: real, k: real)\n ensures c * k == k * c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_12109","instance":12109,"id":182108,"goal":"lemma MulAssoc_12109(a: int, m: int, n: int)\n ensures (a * m) * n == a * (m * n)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_12110","instance":12110,"id":182109,"goal":"lemma Distrib_12110(b: nat, n: nat, i: nat)\n ensures b * (n + i) == b * n + b * i\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_12111","instance":12111,"id":182110,"goal":"lemma AddZero_12111(j: real)\n ensures j + 0 == j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_12112","instance":12112,"id":182111,"goal":"lemma MulOne_12112(x: int)\n ensures x * 1 == x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_12113","instance":12113,"id":182112,"goal":"lemma MulZero_12113(j: nat)\n ensures j * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_12114","instance":12114,"id":182113,"goal":"lemma LeRefl_12114(k: real)\n ensures k <= k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_12115","instance":12115,"id":182114,"goal":"lemma LeTrans_12115(b: int, a: int, y: int)\n requires b <= a && a <= y\n ensures b <= y\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_12116","instance":12116,"id":182115,"goal":"lemma AddMono_12116(d: nat, i: nat, b: nat)\n requires d <= i\n ensures d + b <= i + b\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_12117","instance":12117,"id":182116,"goal":"lemma Abs_Nonneg_12117(y: real)\n ensures (if y >= 0 then y else -y) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_12118","instance":12118,"id":182117,"goal":"lemma DivMod_12118(a: int, z: int)\n requires z > 0\n ensures a == z * (a / z) + (a % z)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_12119","instance":12119,"id":182118,"goal":"lemma ModBounds_12119(x: nat, j: nat)\n requires j > 0\n ensures 0 <= x % j < j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_12120","instance":12120,"id":182119,"goal":"lemma Square_Nonneg_12120(m: real)\n ensures m * m >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_12121","instance":12121,"id":182120,"goal":"lemma AddComm_12121(c: int, j: int)\n ensures c + j == j + c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_12122","instance":12122,"id":182121,"goal":"lemma AddAssoc_12122(c: nat, k: nat, j: nat)\n ensures (c + k) + j == c + (k + j)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_12123","instance":12123,"id":182122,"goal":"lemma MulComm_12123(i: real, y: real)\n ensures i * y == y * i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_12124","instance":12124,"id":182123,"goal":"lemma MulAssoc_12124(y: int, c: int, n: int)\n ensures (y * c) * n == y * (c * n)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_12125","instance":12125,"id":182124,"goal":"lemma Distrib_12125(b: nat, i: nat, c: nat)\n ensures b * (i + c) == b * i + b * c\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_12126","instance":12126,"id":182125,"goal":"lemma AddZero_12126(m: real)\n ensures m + 0 == m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_12127","instance":12127,"id":182126,"goal":"lemma MulOne_12127(n: int)\n ensures n * 1 == n\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_12128","instance":12128,"id":182127,"goal":"lemma MulZero_12128(a: nat)\n ensures a * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_12129","instance":12129,"id":182128,"goal":"lemma LeRefl_12129(b: real)\n ensures b <= b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_12130","instance":12130,"id":182129,"goal":"lemma LeTrans_12130(y: int, c: int, z: int)\n requires y <= c && c <= z\n ensures y <= z\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_12131","instance":12131,"id":182130,"goal":"lemma AddMono_12131(z: nat, a: nat, d: nat)\n requires z <= a\n ensures z + d <= a + d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_12132","instance":12132,"id":182131,"goal":"lemma Abs_Nonneg_12132(z: real)\n ensures (if z >= 0 then z else -z) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_12133","instance":12133,"id":182132,"goal":"lemma DivMod_12133(k: int, x: int)\n requires x > 0\n ensures k == x * (k / x) + (k % x)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_12134","instance":12134,"id":182133,"goal":"lemma ModBounds_12134(a: nat, c: nat)\n requires c > 0\n ensures 0 <= a % c < c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_12135","instance":12135,"id":182134,"goal":"lemma Square_Nonneg_12135(k: real)\n ensures k * k >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_12136","instance":12136,"id":182135,"goal":"lemma AddComm_12136(a: int, x: int)\n ensures a + x == x + a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_12137","instance":12137,"id":182136,"goal":"lemma AddAssoc_12137(x: nat, c: nat, n: nat)\n ensures (x + c) + n == x + (c + n)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_12138","instance":12138,"id":182137,"goal":"lemma MulComm_12138(b: real, c: real)\n ensures b * c == c * b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_12139","instance":12139,"id":182138,"goal":"lemma MulAssoc_12139(d: int, m: int, j: int)\n ensures (d * m) * j == d * (m * j)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_12140","instance":12140,"id":182139,"goal":"lemma Distrib_12140(k: nat, b: nat, c: nat)\n ensures k * (b + c) == k * b + k * c\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_12141","instance":12141,"id":182140,"goal":"lemma AddZero_12141(i: real)\n ensures i + 0 == i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_12142","instance":12142,"id":182141,"goal":"lemma MulOne_12142(i: int)\n ensures i * 1 == i\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_12143","instance":12143,"id":182142,"goal":"lemma MulZero_12143(c: nat)\n ensures c * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_12144","instance":12144,"id":182143,"goal":"lemma LeRefl_12144(k: real)\n ensures k <= k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_12145","instance":12145,"id":182144,"goal":"lemma LeTrans_12145(j: int, c: int, x: int)\n requires j <= c && c <= x\n ensures j <= x\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_12146","instance":12146,"id":182145,"goal":"lemma AddMono_12146(y: nat, c: nat, d: nat)\n requires y <= c\n ensures y + d <= c + d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_12147","instance":12147,"id":182146,"goal":"lemma Abs_Nonneg_12147(b: real)\n ensures (if b >= 0 then b else -b) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_12148","instance":12148,"id":182147,"goal":"lemma DivMod_12148(n: int, m: int)\n requires m > 0\n ensures n == m * (n / m) + (n % m)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_12149","instance":12149,"id":182148,"goal":"lemma ModBounds_12149(d: nat, x: nat)\n requires x > 0\n ensures 0 <= d % x < x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_12150","instance":12150,"id":182149,"goal":"lemma Square_Nonneg_12150(d: real)\n ensures d * d >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_12151","instance":12151,"id":182150,"goal":"lemma AddComm_12151(c: int, b: int)\n ensures c + b == b + c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_12152","instance":12152,"id":182151,"goal":"lemma AddAssoc_12152(m: nat, z: nat, i: nat)\n ensures (m + z) + i == m + (z + i)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_12153","instance":12153,"id":182152,"goal":"lemma MulComm_12153(n: real, i: real)\n ensures n * i == i * n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_12154","instance":12154,"id":182153,"goal":"lemma MulAssoc_12154(i: int, a: int, k: int)\n ensures (i * a) * k == i * (a * k)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_12155","instance":12155,"id":182154,"goal":"lemma Distrib_12155(x: nat, y: nat, b: nat)\n ensures x * (y + b) == x * y + x * b\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_12156","instance":12156,"id":182155,"goal":"lemma AddZero_12156(d: real)\n ensures d + 0 == d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_12157","instance":12157,"id":182156,"goal":"lemma MulOne_12157(j: int)\n ensures j * 1 == j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_12158","instance":12158,"id":182157,"goal":"lemma MulZero_12158(k: nat)\n ensures k * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_12159","instance":12159,"id":182158,"goal":"lemma LeRefl_12159(d: real)\n ensures d <= d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_12160","instance":12160,"id":182159,"goal":"lemma LeTrans_12160(b: int, k: int, z: int)\n requires b <= k && k <= z\n ensures b <= z\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_12161","instance":12161,"id":182160,"goal":"lemma AddMono_12161(m: nat, b: nat, k: nat)\n requires m <= b\n ensures m + k <= b + k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_12162","instance":12162,"id":182161,"goal":"lemma Abs_Nonneg_12162(j: real)\n ensures (if j >= 0 then j else -j) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_12163","instance":12163,"id":182162,"goal":"lemma DivMod_12163(z: int, y: int)\n requires y > 0\n ensures z == y * (z / y) + (z % y)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_12164","instance":12164,"id":182163,"goal":"lemma ModBounds_12164(c: nat, j: nat)\n requires j > 0\n ensures 0 <= c % j < j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_12165","instance":12165,"id":182164,"goal":"lemma Square_Nonneg_12165(z: real)\n ensures z * z >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_12166","instance":12166,"id":182165,"goal":"lemma AddComm_12166(j: int, m: int)\n ensures j + m == m + j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_12167","instance":12167,"id":182166,"goal":"lemma AddAssoc_12167(m: nat, a: nat, c: nat)\n ensures (m + a) + c == m + (a + c)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_12168","instance":12168,"id":182167,"goal":"lemma MulComm_12168(c: real, b: real)\n ensures c * b == b * c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_12169","instance":12169,"id":182168,"goal":"lemma MulAssoc_12169(x: int, n: int, i: int)\n ensures (x * n) * i == x * (n * i)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_12170","instance":12170,"id":182169,"goal":"lemma Distrib_12170(z: nat, y: nat, i: nat)\n ensures z * (y + i) == z * y + z * i\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_12171","instance":12171,"id":182170,"goal":"lemma AddZero_12171(n: real)\n ensures n + 0 == n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_12172","instance":12172,"id":182171,"goal":"lemma MulOne_12172(d: int)\n ensures d * 1 == d\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_12173","instance":12173,"id":182172,"goal":"lemma MulZero_12173(x: nat)\n ensures x * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_12174","instance":12174,"id":182173,"goal":"lemma LeRefl_12174(a: real)\n ensures a <= a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_12175","instance":12175,"id":182174,"goal":"lemma LeTrans_12175(z: int, c: int, i: int)\n requires z <= c && c <= i\n ensures z <= i\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_12176","instance":12176,"id":182175,"goal":"lemma AddMono_12176(n: nat, j: nat, y: nat)\n requires n <= j\n ensures n + y <= j + y\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_12177","instance":12177,"id":182176,"goal":"lemma Abs_Nonneg_12177(m: real)\n ensures (if m >= 0 then m else -m) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_12178","instance":12178,"id":182177,"goal":"lemma DivMod_12178(j: int, k: int)\n requires k > 0\n ensures j == k * (j / k) + (j % k)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_12179","instance":12179,"id":182178,"goal":"lemma ModBounds_12179(d: nat, i: nat)\n requires i > 0\n ensures 0 <= d % i < i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_12180","instance":12180,"id":182179,"goal":"lemma Square_Nonneg_12180(m: real)\n ensures m * m >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_12181","instance":12181,"id":182180,"goal":"lemma AddComm_12181(a: int, d: int)\n ensures a + d == d + a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_12182","instance":12182,"id":182181,"goal":"lemma AddAssoc_12182(i: nat, m: nat, d: nat)\n ensures (i + m) + d == i + (m + d)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_12183","instance":12183,"id":182182,"goal":"lemma MulComm_12183(n: real, k: real)\n ensures n * k == k * n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_12184","instance":12184,"id":182183,"goal":"lemma MulAssoc_12184(n: int, y: int, d: int)\n ensures (n * y) * d == n * (y * d)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_12185","instance":12185,"id":182184,"goal":"lemma Distrib_12185(a: nat, n: nat, j: nat)\n ensures a * (n + j) == a * n + a * j\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_12186","instance":12186,"id":182185,"goal":"lemma AddZero_12186(y: real)\n ensures y + 0 == y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_12187","instance":12187,"id":182186,"goal":"lemma MulOne_12187(z: int)\n ensures z * 1 == z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_12188","instance":12188,"id":182187,"goal":"lemma MulZero_12188(a: nat)\n ensures a * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_12189","instance":12189,"id":182188,"goal":"lemma LeRefl_12189(z: real)\n ensures z <= z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_12190","instance":12190,"id":182189,"goal":"lemma LeTrans_12190(b: int, i: int, d: int)\n requires b <= i && i <= d\n ensures b <= d\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_12191","instance":12191,"id":182190,"goal":"lemma AddMono_12191(z: nat, b: nat, i: nat)\n requires z <= b\n ensures z + i <= b + i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_12192","instance":12192,"id":182191,"goal":"lemma Abs_Nonneg_12192(y: real)\n ensures (if y >= 0 then y else -y) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_12193","instance":12193,"id":182192,"goal":"lemma DivMod_12193(c: int, x: int)\n requires x > 0\n ensures c == x * (c / x) + (c % x)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_12194","instance":12194,"id":182193,"goal":"lemma ModBounds_12194(c: nat, x: nat)\n requires x > 0\n ensures 0 <= c % x < x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_12195","instance":12195,"id":182194,"goal":"lemma Square_Nonneg_12195(b: real)\n ensures b * b >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_12196","instance":12196,"id":182195,"goal":"lemma AddComm_12196(i: int, m: int)\n ensures i + m == m + i\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_12197","instance":12197,"id":182196,"goal":"lemma AddAssoc_12197(k: nat, b: nat, x: nat)\n ensures (k + b) + x == k + (b + x)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_12198","instance":12198,"id":182197,"goal":"lemma MulComm_12198(b: real, i: real)\n ensures b * i == i * b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_12199","instance":12199,"id":182198,"goal":"lemma MulAssoc_12199(d: int, k: int, c: int)\n ensures (d * k) * c == d * (k * c)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_12200","instance":12200,"id":182199,"goal":"lemma Distrib_12200(c: nat, k: nat, x: nat)\n ensures c * (k + x) == c * k + c * x\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_12201","instance":12201,"id":182200,"goal":"lemma AddZero_12201(k: real)\n ensures k + 0 == k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_12202","instance":12202,"id":182201,"goal":"lemma MulOne_12202(c: int)\n ensures c * 1 == c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_12203","instance":12203,"id":182202,"goal":"lemma MulZero_12203(a: nat)\n ensures a * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_12204","instance":12204,"id":182203,"goal":"lemma LeRefl_12204(j: real)\n ensures j <= j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_12205","instance":12205,"id":182204,"goal":"lemma LeTrans_12205(c: int, d: int, k: int)\n requires c <= d && d <= k\n ensures c <= k\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_12206","instance":12206,"id":182205,"goal":"lemma AddMono_12206(c: nat, d: nat, z: nat)\n requires c <= d\n ensures c + z <= d + z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_12207","instance":12207,"id":182206,"goal":"lemma Abs_Nonneg_12207(n: real)\n ensures (if n >= 0 then n else -n) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_12208","instance":12208,"id":182207,"goal":"lemma DivMod_12208(k: int, b: int)\n requires b > 0\n ensures k == b * (k / b) + (k % b)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_12209","instance":12209,"id":182208,"goal":"lemma ModBounds_12209(k: nat, b: nat)\n requires b > 0\n ensures 0 <= k % b < b\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_12210","instance":12210,"id":182209,"goal":"lemma Square_Nonneg_12210(c: real)\n ensures c * c >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_12211","instance":12211,"id":182210,"goal":"lemma AddComm_12211(y: int, x: int)\n ensures y + x == x + y\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_12212","instance":12212,"id":182211,"goal":"lemma AddAssoc_12212(x: nat, c: nat, n: nat)\n ensures (x + c) + n == x + (c + n)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_12213","instance":12213,"id":182212,"goal":"lemma MulComm_12213(m: real, b: real)\n ensures m * b == b * m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_12214","instance":12214,"id":182213,"goal":"lemma MulAssoc_12214(x: int, y: int, n: int)\n ensures (x * y) * n == x * (y * n)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_12215","instance":12215,"id":182214,"goal":"lemma Distrib_12215(i: nat, j: nat, a: nat)\n ensures i * (j + a) == i * j + i * a\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_12216","instance":12216,"id":182215,"goal":"lemma AddZero_12216(m: real)\n ensures m + 0 == m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_12217","instance":12217,"id":182216,"goal":"lemma MulOne_12217(k: int)\n ensures k * 1 == k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_12218","instance":12218,"id":182217,"goal":"lemma MulZero_12218(y: nat)\n ensures y * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_12219","instance":12219,"id":182218,"goal":"lemma LeRefl_12219(j: real)\n ensures j <= j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_12220","instance":12220,"id":182219,"goal":"lemma LeTrans_12220(z: int, b: int, a: int)\n requires z <= b && b <= a\n ensures z <= a\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_12221","instance":12221,"id":182220,"goal":"lemma AddMono_12221(y: nat, k: nat, j: nat)\n requires y <= k\n ensures y + j <= k + j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_12222","instance":12222,"id":182221,"goal":"lemma Abs_Nonneg_12222(b: real)\n ensures (if b >= 0 then b else -b) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_12223","instance":12223,"id":182222,"goal":"lemma DivMod_12223(i: int, z: int)\n requires z > 0\n ensures i == z * (i / z) + (i % z)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_12224","instance":12224,"id":182223,"goal":"lemma ModBounds_12224(m: nat, c: nat)\n requires c > 0\n ensures 0 <= m % c < c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_12225","instance":12225,"id":182224,"goal":"lemma Square_Nonneg_12225(z: real)\n ensures z * z >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_12226","instance":12226,"id":182225,"goal":"lemma AddComm_12226(m: int, a: int)\n ensures m + a == a + m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_12227","instance":12227,"id":182226,"goal":"lemma AddAssoc_12227(j: nat, d: nat, m: nat)\n ensures (j + d) + m == j + (d + m)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_12228","instance":12228,"id":182227,"goal":"lemma MulComm_12228(k: real, c: real)\n ensures k * c == c * k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_12229","instance":12229,"id":182228,"goal":"lemma MulAssoc_12229(b: int, n: int, d: int)\n ensures (b * n) * d == b * (n * d)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_12230","instance":12230,"id":182229,"goal":"lemma Distrib_12230(c: nat, i: nat, k: nat)\n ensures c * (i + k) == c * i + c * k\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_12231","instance":12231,"id":182230,"goal":"lemma AddZero_12231(k: real)\n ensures k + 0 == k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_12232","instance":12232,"id":182231,"goal":"lemma MulOne_12232(j: int)\n ensures j * 1 == j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_12233","instance":12233,"id":182232,"goal":"lemma MulZero_12233(n: nat)\n ensures n * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_12234","instance":12234,"id":182233,"goal":"lemma LeRefl_12234(z: real)\n ensures z <= z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_12235","instance":12235,"id":182234,"goal":"lemma LeTrans_12235(j: int, d: int, x: int)\n requires j <= d && d <= x\n ensures j <= x\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_12236","instance":12236,"id":182235,"goal":"lemma AddMono_12236(j: nat, a: nat, n: nat)\n requires j <= a\n ensures j + n <= a + n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_12237","instance":12237,"id":182236,"goal":"lemma Abs_Nonneg_12237(n: real)\n ensures (if n >= 0 then n else -n) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_12238","instance":12238,"id":182237,"goal":"lemma DivMod_12238(i: int, d: int)\n requires d > 0\n ensures i == d * (i / d) + (i % d)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_12239","instance":12239,"id":182238,"goal":"lemma ModBounds_12239(z: nat, b: nat)\n requires b > 0\n ensures 0 <= z % b < b\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_12240","instance":12240,"id":182239,"goal":"lemma Square_Nonneg_12240(j: real)\n ensures j * j >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_12241","instance":12241,"id":182240,"goal":"lemma AddComm_12241(y: int, c: int)\n ensures y + c == c + y\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_12242","instance":12242,"id":182241,"goal":"lemma AddAssoc_12242(n: nat, d: nat, z: nat)\n ensures (n + d) + z == n + (d + z)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_12243","instance":12243,"id":182242,"goal":"lemma MulComm_12243(d: real, n: real)\n ensures d * n == n * d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_12244","instance":12244,"id":182243,"goal":"lemma MulAssoc_12244(n: int, b: int, x: int)\n ensures (n * b) * x == n * (b * x)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_12245","instance":12245,"id":182244,"goal":"lemma Distrib_12245(k: nat, d: nat, z: nat)\n ensures k * (d + z) == k * d + k * z\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_12246","instance":12246,"id":182245,"goal":"lemma AddZero_12246(i: real)\n ensures i + 0 == i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_12247","instance":12247,"id":182246,"goal":"lemma MulOne_12247(i: int)\n ensures i * 1 == i\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_12248","instance":12248,"id":182247,"goal":"lemma MulZero_12248(m: nat)\n ensures m * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_12249","instance":12249,"id":182248,"goal":"lemma LeRefl_12249(a: real)\n ensures a <= a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_12250","instance":12250,"id":182249,"goal":"lemma LeTrans_12250(j: int, a: int, x: int)\n requires j <= a && a <= x\n ensures j <= x\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_12251","instance":12251,"id":182250,"goal":"lemma AddMono_12251(b: nat, z: nat, y: nat)\n requires b <= z\n ensures b + y <= z + y\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_12252","instance":12252,"id":182251,"goal":"lemma Abs_Nonneg_12252(d: real)\n ensures (if d >= 0 then d else -d) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_12253","instance":12253,"id":182252,"goal":"lemma DivMod_12253(c: int, b: int)\n requires b > 0\n ensures c == b * (c / b) + (c % b)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_12254","instance":12254,"id":182253,"goal":"lemma ModBounds_12254(j: nat, c: nat)\n requires c > 0\n ensures 0 <= j % c < c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_12255","instance":12255,"id":182254,"goal":"lemma Square_Nonneg_12255(n: real)\n ensures n * n >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_12256","instance":12256,"id":182255,"goal":"lemma AddComm_12256(a: int, z: int)\n ensures a + z == z + a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_12257","instance":12257,"id":182256,"goal":"lemma AddAssoc_12257(y: nat, m: nat, x: nat)\n ensures (y + m) + x == y + (m + x)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_12258","instance":12258,"id":182257,"goal":"lemma MulComm_12258(i: real, a: real)\n ensures i * a == a * i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_12259","instance":12259,"id":182258,"goal":"lemma MulAssoc_12259(y: int, x: int, k: int)\n ensures (y * x) * k == y * (x * k)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_12260","instance":12260,"id":182259,"goal":"lemma Distrib_12260(m: nat, z: nat, y: nat)\n ensures m * (z + y) == m * z + m * y\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_12261","instance":12261,"id":182260,"goal":"lemma AddZero_12261(y: real)\n ensures y + 0 == y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_12262","instance":12262,"id":182261,"goal":"lemma MulOne_12262(a: int)\n ensures a * 1 == a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_12263","instance":12263,"id":182262,"goal":"lemma MulZero_12263(y: nat)\n ensures y * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_12264","instance":12264,"id":182263,"goal":"lemma LeRefl_12264(k: real)\n ensures k <= k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_12265","instance":12265,"id":182264,"goal":"lemma LeTrans_12265(d: int, z: int, b: int)\n requires d <= z && z <= b\n ensures d <= b\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_12266","instance":12266,"id":182265,"goal":"lemma AddMono_12266(k: nat, d: nat, c: nat)\n requires k <= d\n ensures k + c <= d + c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_12267","instance":12267,"id":182266,"goal":"lemma Abs_Nonneg_12267(a: real)\n ensures (if a >= 0 then a else -a) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_12268","instance":12268,"id":182267,"goal":"lemma DivMod_12268(n: int, m: int)\n requires m > 0\n ensures n == m * (n / m) + (n % m)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_12269","instance":12269,"id":182268,"goal":"lemma ModBounds_12269(z: nat, d: nat)\n requires d > 0\n ensures 0 <= z % d < d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_12270","instance":12270,"id":182269,"goal":"lemma Square_Nonneg_12270(c: real)\n ensures c * c >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_12271","instance":12271,"id":182270,"goal":"lemma AddComm_12271(x: int, n: int)\n ensures x + n == n + x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_12272","instance":12272,"id":182271,"goal":"lemma AddAssoc_12272(a: nat, n: nat, d: nat)\n ensures (a + n) + d == a + (n + d)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_12273","instance":12273,"id":182272,"goal":"lemma MulComm_12273(j: real, x: real)\n ensures j * x == x * j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_12274","instance":12274,"id":182273,"goal":"lemma MulAssoc_12274(z: int, x: int, j: int)\n ensures (z * x) * j == z * (x * j)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_12275","instance":12275,"id":182274,"goal":"lemma Distrib_12275(j: nat, a: nat, d: nat)\n ensures j * (a + d) == j * a + j * d\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_12276","instance":12276,"id":182275,"goal":"lemma AddZero_12276(x: real)\n ensures x + 0 == x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_12277","instance":12277,"id":182276,"goal":"lemma MulOne_12277(j: int)\n ensures j * 1 == j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_12278","instance":12278,"id":182277,"goal":"lemma MulZero_12278(n: nat)\n ensures n * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_12279","instance":12279,"id":182278,"goal":"lemma LeRefl_12279(b: real)\n ensures b <= b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_12280","instance":12280,"id":182279,"goal":"lemma LeTrans_12280(b: int, k: int, m: int)\n requires b <= k && k <= m\n ensures b <= m\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_12281","instance":12281,"id":182280,"goal":"lemma AddMono_12281(c: nat, i: nat, m: nat)\n requires c <= i\n ensures c + m <= i + m\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_12282","instance":12282,"id":182281,"goal":"lemma Abs_Nonneg_12282(k: real)\n ensures (if k >= 0 then k else -k) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_12283","instance":12283,"id":182282,"goal":"lemma DivMod_12283(x: int, y: int)\n requires y > 0\n ensures x == y * (x / y) + (x % y)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_12284","instance":12284,"id":182283,"goal":"lemma ModBounds_12284(d: nat, a: nat)\n requires a > 0\n ensures 0 <= d % a < a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_12285","instance":12285,"id":182284,"goal":"lemma Square_Nonneg_12285(c: real)\n ensures c * c >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_12286","instance":12286,"id":182285,"goal":"lemma AddComm_12286(c: int, a: int)\n ensures c + a == a + c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_12287","instance":12287,"id":182286,"goal":"lemma AddAssoc_12287(k: nat, d: nat, m: nat)\n ensures (k + d) + m == k + (d + m)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_12288","instance":12288,"id":182287,"goal":"lemma MulComm_12288(z: real, c: real)\n ensures z * c == c * z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_12289","instance":12289,"id":182288,"goal":"lemma MulAssoc_12289(c: int, m: int, z: int)\n ensures (c * m) * z == c * (m * z)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_12290","instance":12290,"id":182289,"goal":"lemma Distrib_12290(z: nat, a: nat, m: nat)\n ensures z * (a + m) == z * a + z * m\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_12291","instance":12291,"id":182290,"goal":"lemma AddZero_12291(y: real)\n ensures y + 0 == y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_12292","instance":12292,"id":182291,"goal":"lemma MulOne_12292(j: int)\n ensures j * 1 == j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_12293","instance":12293,"id":182292,"goal":"lemma MulZero_12293(a: nat)\n ensures a * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_12294","instance":12294,"id":182293,"goal":"lemma LeRefl_12294(a: real)\n ensures a <= a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_12295","instance":12295,"id":182294,"goal":"lemma LeTrans_12295(n: int, j: int, i: int)\n requires n <= j && j <= i\n ensures n <= i\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_12296","instance":12296,"id":182295,"goal":"lemma AddMono_12296(b: nat, k: nat, m: nat)\n requires b <= k\n ensures b + m <= k + m\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_12297","instance":12297,"id":182296,"goal":"lemma Abs_Nonneg_12297(y: real)\n ensures (if y >= 0 then y else -y) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_12298","instance":12298,"id":182297,"goal":"lemma DivMod_12298(k: int, i: int)\n requires i > 0\n ensures k == i * (k / i) + (k % i)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_12299","instance":12299,"id":182298,"goal":"lemma ModBounds_12299(z: nat, x: nat)\n requires x > 0\n ensures 0 <= z % x < x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_12300","instance":12300,"id":182299,"goal":"lemma Square_Nonneg_12300(y: real)\n ensures y * y >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_12301","instance":12301,"id":182300,"goal":"lemma AddComm_12301(y: int, d: int)\n ensures y + d == d + y\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_12302","instance":12302,"id":182301,"goal":"lemma AddAssoc_12302(i: nat, z: nat, d: nat)\n ensures (i + z) + d == i + (z + d)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_12303","instance":12303,"id":182302,"goal":"lemma MulComm_12303(k: real, z: real)\n ensures k * z == z * k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_12304","instance":12304,"id":182303,"goal":"lemma MulAssoc_12304(b: int, x: int, y: int)\n ensures (b * x) * y == b * (x * y)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_12305","instance":12305,"id":182304,"goal":"lemma Distrib_12305(m: nat, j: nat, z: nat)\n ensures m * (j + z) == m * j + m * z\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_12306","instance":12306,"id":182305,"goal":"lemma AddZero_12306(i: real)\n ensures i + 0 == i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_12307","instance":12307,"id":182306,"goal":"lemma MulOne_12307(z: int)\n ensures z * 1 == z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_12308","instance":12308,"id":182307,"goal":"lemma MulZero_12308(c: nat)\n ensures c * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_12309","instance":12309,"id":182308,"goal":"lemma LeRefl_12309(x: real)\n ensures x <= x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_12310","instance":12310,"id":182309,"goal":"lemma LeTrans_12310(c: int, z: int, k: int)\n requires c <= z && z <= k\n ensures c <= k\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_12311","instance":12311,"id":182310,"goal":"lemma AddMono_12311(c: nat, d: nat, k: nat)\n requires c <= d\n ensures c + k <= d + k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_12312","instance":12312,"id":182311,"goal":"lemma Abs_Nonneg_12312(i: real)\n ensures (if i >= 0 then i else -i) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_12313","instance":12313,"id":182312,"goal":"lemma DivMod_12313(n: int, c: int)\n requires c > 0\n ensures n == c * (n / c) + (n % c)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_12314","instance":12314,"id":182313,"goal":"lemma ModBounds_12314(a: nat, n: nat)\n requires n > 0\n ensures 0 <= a % n < n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_12315","instance":12315,"id":182314,"goal":"lemma Square_Nonneg_12315(x: real)\n ensures x * x >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_12316","instance":12316,"id":182315,"goal":"lemma AddComm_12316(z: int, x: int)\n ensures z + x == x + z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_12317","instance":12317,"id":182316,"goal":"lemma AddAssoc_12317(n: nat, i: nat, z: nat)\n ensures (n + i) + z == n + (i + z)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_12318","instance":12318,"id":182317,"goal":"lemma MulComm_12318(k: real, a: real)\n ensures k * a == a * k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_12319","instance":12319,"id":182318,"goal":"lemma MulAssoc_12319(a: int, x: int, m: int)\n ensures (a * x) * m == a * (x * m)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_12320","instance":12320,"id":182319,"goal":"lemma Distrib_12320(b: nat, k: nat, n: nat)\n ensures b * (k + n) == b * k + b * n\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_12321","instance":12321,"id":182320,"goal":"lemma AddZero_12321(c: real)\n ensures c + 0 == c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_12322","instance":12322,"id":182321,"goal":"lemma MulOne_12322(z: int)\n ensures z * 1 == z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_12323","instance":12323,"id":182322,"goal":"lemma MulZero_12323(d: nat)\n ensures d * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_12324","instance":12324,"id":182323,"goal":"lemma LeRefl_12324(n: real)\n ensures n <= n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_12325","instance":12325,"id":182324,"goal":"lemma LeTrans_12325(z: int, b: int, a: int)\n requires z <= b && b <= a\n ensures z <= a\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_12326","instance":12326,"id":182325,"goal":"lemma AddMono_12326(b: nat, c: nat, x: nat)\n requires b <= c\n ensures b + x <= c + x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_12327","instance":12327,"id":182326,"goal":"lemma Abs_Nonneg_12327(m: real)\n ensures (if m >= 0 then m else -m) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_12328","instance":12328,"id":182327,"goal":"lemma DivMod_12328(x: int, z: int)\n requires z > 0\n ensures x == z * (x / z) + (x % z)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_12329","instance":12329,"id":182328,"goal":"lemma ModBounds_12329(d: nat, c: nat)\n requires c > 0\n ensures 0 <= d % c < c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_12330","instance":12330,"id":182329,"goal":"lemma Square_Nonneg_12330(a: real)\n ensures a * a >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_12331","instance":12331,"id":182330,"goal":"lemma AddComm_12331(n: int, i: int)\n ensures n + i == i + n\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_12332","instance":12332,"id":182331,"goal":"lemma AddAssoc_12332(c: nat, m: nat, j: nat)\n ensures (c + m) + j == c + (m + j)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_12333","instance":12333,"id":182332,"goal":"lemma MulComm_12333(y: real, x: real)\n ensures y * x == x * y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_12334","instance":12334,"id":182333,"goal":"lemma MulAssoc_12334(k: int, d: int, i: int)\n ensures (k * d) * i == k * (d * i)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_12335","instance":12335,"id":182334,"goal":"lemma Distrib_12335(d: nat, k: nat, y: nat)\n ensures d * (k + y) == d * k + d * y\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_12336","instance":12336,"id":182335,"goal":"lemma AddZero_12336(k: real)\n ensures k + 0 == k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_12337","instance":12337,"id":182336,"goal":"lemma MulOne_12337(x: int)\n ensures x * 1 == x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_12338","instance":12338,"id":182337,"goal":"lemma MulZero_12338(j: nat)\n ensures j * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_12339","instance":12339,"id":182338,"goal":"lemma LeRefl_12339(y: real)\n ensures y <= y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_12340","instance":12340,"id":182339,"goal":"lemma LeTrans_12340(y: int, b: int, c: int)\n requires y <= b && b <= c\n ensures y <= c\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_12341","instance":12341,"id":182340,"goal":"lemma AddMono_12341(y: nat, z: nat, i: nat)\n requires y <= z\n ensures y + i <= z + i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_12342","instance":12342,"id":182341,"goal":"lemma Abs_Nonneg_12342(c: real)\n ensures (if c >= 0 then c else -c) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_12343","instance":12343,"id":182342,"goal":"lemma DivMod_12343(m: int, y: int)\n requires y > 0\n ensures m == y * (m / y) + (m % y)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_12344","instance":12344,"id":182343,"goal":"lemma ModBounds_12344(y: nat, k: nat)\n requires k > 0\n ensures 0 <= y % k < k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_12345","instance":12345,"id":182344,"goal":"lemma Square_Nonneg_12345(a: real)\n ensures a * a >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_12346","instance":12346,"id":182345,"goal":"lemma AddComm_12346(d: int, k: int)\n ensures d + k == k + d\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_12347","instance":12347,"id":182346,"goal":"lemma AddAssoc_12347(b: nat, c: nat, y: nat)\n ensures (b + c) + y == b + (c + y)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_12348","instance":12348,"id":182347,"goal":"lemma MulComm_12348(j: real, c: real)\n ensures j * c == c * j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_12349","instance":12349,"id":182348,"goal":"lemma MulAssoc_12349(n: int, d: int, c: int)\n ensures (n * d) * c == n * (d * c)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_12350","instance":12350,"id":182349,"goal":"lemma Distrib_12350(n: nat, y: nat, i: nat)\n ensures n * (y + i) == n * y + n * i\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_12351","instance":12351,"id":182350,"goal":"lemma AddZero_12351(c: real)\n ensures c + 0 == c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_12352","instance":12352,"id":182351,"goal":"lemma MulOne_12352(n: int)\n ensures n * 1 == n\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_12353","instance":12353,"id":182352,"goal":"lemma MulZero_12353(c: nat)\n ensures c * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_12354","instance":12354,"id":182353,"goal":"lemma LeRefl_12354(z: real)\n ensures z <= z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_12355","instance":12355,"id":182354,"goal":"lemma LeTrans_12355(y: int, i: int, k: int)\n requires y <= i && i <= k\n ensures y <= k\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_12356","instance":12356,"id":182355,"goal":"lemma AddMono_12356(k: nat, j: nat, n: nat)\n requires k <= j\n ensures k + n <= j + n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_12357","instance":12357,"id":182356,"goal":"lemma Abs_Nonneg_12357(d: real)\n ensures (if d >= 0 then d else -d) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_12358","instance":12358,"id":182357,"goal":"lemma DivMod_12358(d: int, k: int)\n requires k > 0\n ensures d == k * (d / k) + (d % k)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_12359","instance":12359,"id":182358,"goal":"lemma ModBounds_12359(y: nat, i: nat)\n requires i > 0\n ensures 0 <= y % i < i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_12360","instance":12360,"id":182359,"goal":"lemma Square_Nonneg_12360(m: real)\n ensures m * m >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_12361","instance":12361,"id":182360,"goal":"lemma AddComm_12361(c: int, a: int)\n ensures c + a == a + c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_12362","instance":12362,"id":182361,"goal":"lemma AddAssoc_12362(b: nat, j: nat, z: nat)\n ensures (b + j) + z == b + (j + z)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_12363","instance":12363,"id":182362,"goal":"lemma MulComm_12363(k: real, c: real)\n ensures k * c == c * k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_12364","instance":12364,"id":182363,"goal":"lemma MulAssoc_12364(a: int, c: int, j: int)\n ensures (a * c) * j == a * (c * j)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_12365","instance":12365,"id":182364,"goal":"lemma Distrib_12365(j: nat, i: nat, m: nat)\n ensures j * (i + m) == j * i + j * m\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_12366","instance":12366,"id":182365,"goal":"lemma AddZero_12366(j: real)\n ensures j + 0 == j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_12367","instance":12367,"id":182366,"goal":"lemma MulOne_12367(y: int)\n ensures y * 1 == y\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_12368","instance":12368,"id":182367,"goal":"lemma MulZero_12368(y: nat)\n ensures y * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_12369","instance":12369,"id":182368,"goal":"lemma LeRefl_12369(d: real)\n ensures d <= d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_12370","instance":12370,"id":182369,"goal":"lemma LeTrans_12370(x: int, m: int, k: int)\n requires x <= m && m <= k\n ensures x <= k\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_12371","instance":12371,"id":182370,"goal":"lemma AddMono_12371(d: nat, b: nat, j: nat)\n requires d <= b\n ensures d + j <= b + j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_12372","instance":12372,"id":182371,"goal":"lemma Abs_Nonneg_12372(j: real)\n ensures (if j >= 0 then j else -j) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_12373","instance":12373,"id":182372,"goal":"lemma DivMod_12373(x: int, a: int)\n requires a > 0\n ensures x == a * (x / a) + (x % a)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_12374","instance":12374,"id":182373,"goal":"lemma ModBounds_12374(c: nat, x: nat)\n requires x > 0\n ensures 0 <= c % x < x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_12375","instance":12375,"id":182374,"goal":"lemma Square_Nonneg_12375(y: real)\n ensures y * y >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_12376","instance":12376,"id":182375,"goal":"lemma AddComm_12376(k: int, j: int)\n ensures k + j == j + k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_12377","instance":12377,"id":182376,"goal":"lemma AddAssoc_12377(c: nat, k: nat, x: nat)\n ensures (c + k) + x == c + (k + x)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_12378","instance":12378,"id":182377,"goal":"lemma MulComm_12378(k: real, x: real)\n ensures k * x == x * k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_12379","instance":12379,"id":182378,"goal":"lemma MulAssoc_12379(n: int, x: int, c: int)\n ensures (n * x) * c == n * (x * c)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_12380","instance":12380,"id":182379,"goal":"lemma Distrib_12380(a: nat, i: nat, b: nat)\n ensures a * (i + b) == a * i + a * b\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_12381","instance":12381,"id":182380,"goal":"lemma AddZero_12381(d: real)\n ensures d + 0 == d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_12382","instance":12382,"id":182381,"goal":"lemma MulOne_12382(n: int)\n ensures n * 1 == n\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_12383","instance":12383,"id":182382,"goal":"lemma MulZero_12383(j: nat)\n ensures j * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_12384","instance":12384,"id":182383,"goal":"lemma LeRefl_12384(i: real)\n ensures i <= i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_12385","instance":12385,"id":182384,"goal":"lemma LeTrans_12385(b: int, m: int, d: int)\n requires b <= m && m <= d\n ensures b <= d\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_12386","instance":12386,"id":182385,"goal":"lemma AddMono_12386(y: nat, d: nat, c: nat)\n requires y <= d\n ensures y + c <= d + c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_12387","instance":12387,"id":182386,"goal":"lemma Abs_Nonneg_12387(i: real)\n ensures (if i >= 0 then i else -i) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_12388","instance":12388,"id":182387,"goal":"lemma DivMod_12388(m: int, j: int)\n requires j > 0\n ensures m == j * (m / j) + (m % j)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_12389","instance":12389,"id":182388,"goal":"lemma ModBounds_12389(i: nat, m: nat)\n requires m > 0\n ensures 0 <= i % m < m\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_12390","instance":12390,"id":182389,"goal":"lemma Square_Nonneg_12390(c: real)\n ensures c * c >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_12391","instance":12391,"id":182390,"goal":"lemma AddComm_12391(k: int, c: int)\n ensures k + c == c + k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_12392","instance":12392,"id":182391,"goal":"lemma AddAssoc_12392(m: nat, b: nat, k: nat)\n ensures (m + b) + k == m + (b + k)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_12393","instance":12393,"id":182392,"goal":"lemma MulComm_12393(c: real, b: real)\n ensures c * b == b * c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_12394","instance":12394,"id":182393,"goal":"lemma MulAssoc_12394(n: int, i: int, m: int)\n ensures (n * i) * m == n * (i * m)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_12395","instance":12395,"id":182394,"goal":"lemma Distrib_12395(x: nat, k: nat, a: nat)\n ensures x * (k + a) == x * k + x * a\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_12396","instance":12396,"id":182395,"goal":"lemma AddZero_12396(z: real)\n ensures z + 0 == z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_12397","instance":12397,"id":182396,"goal":"lemma MulOne_12397(i: int)\n ensures i * 1 == i\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_12398","instance":12398,"id":182397,"goal":"lemma MulZero_12398(c: nat)\n ensures c * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_12399","instance":12399,"id":182398,"goal":"lemma LeRefl_12399(y: real)\n ensures y <= y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_12400","instance":12400,"id":182399,"goal":"lemma LeTrans_12400(n: int, x: int, c: int)\n requires n <= x && x <= c\n ensures n <= c\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_12401","instance":12401,"id":182400,"goal":"lemma AddMono_12401(n: nat, x: nat, c: nat)\n requires n <= x\n ensures n + c <= x + c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_12402","instance":12402,"id":182401,"goal":"lemma Abs_Nonneg_12402(c: real)\n ensures (if c >= 0 then c else -c) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_12403","instance":12403,"id":182402,"goal":"lemma DivMod_12403(c: int, m: int)\n requires m > 0\n ensures c == m * (c / m) + (c % m)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_12404","instance":12404,"id":182403,"goal":"lemma ModBounds_12404(x: nat, d: nat)\n requires d > 0\n ensures 0 <= x % d < d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_12405","instance":12405,"id":182404,"goal":"lemma Square_Nonneg_12405(b: real)\n ensures b * b >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_12406","instance":12406,"id":182405,"goal":"lemma AddComm_12406(m: int, a: int)\n ensures m + a == a + m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_12407","instance":12407,"id":182406,"goal":"lemma AddAssoc_12407(m: nat, j: nat, a: nat)\n ensures (m + j) + a == m + (j + a)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_12408","instance":12408,"id":182407,"goal":"lemma MulComm_12408(d: real, m: real)\n ensures d * m == m * d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_12409","instance":12409,"id":182408,"goal":"lemma MulAssoc_12409(a: int, d: int, k: int)\n ensures (a * d) * k == a * (d * k)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_12410","instance":12410,"id":182409,"goal":"lemma Distrib_12410(z: nat, a: nat, b: nat)\n ensures z * (a + b) == z * a + z * b\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_12411","instance":12411,"id":182410,"goal":"lemma AddZero_12411(b: real)\n ensures b + 0 == b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_12412","instance":12412,"id":182411,"goal":"lemma MulOne_12412(i: int)\n ensures i * 1 == i\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_12413","instance":12413,"id":182412,"goal":"lemma MulZero_12413(n: nat)\n ensures n * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_12414","instance":12414,"id":182413,"goal":"lemma LeRefl_12414(x: real)\n ensures x <= x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_12415","instance":12415,"id":182414,"goal":"lemma LeTrans_12415(z: int, a: int, k: int)\n requires z <= a && a <= k\n ensures z <= k\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_12416","instance":12416,"id":182415,"goal":"lemma AddMono_12416(z: nat, j: nat, y: nat)\n requires z <= j\n ensures z + y <= j + y\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_12417","instance":12417,"id":182416,"goal":"lemma Abs_Nonneg_12417(c: real)\n ensures (if c >= 0 then c else -c) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_12418","instance":12418,"id":182417,"goal":"lemma DivMod_12418(m: int, d: int)\n requires d > 0\n ensures m == d * (m / d) + (m % d)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_12419","instance":12419,"id":182418,"goal":"lemma ModBounds_12419(b: nat, z: nat)\n requires z > 0\n ensures 0 <= b % z < z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_12420","instance":12420,"id":182419,"goal":"lemma Square_Nonneg_12420(d: real)\n ensures d * d >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_12421","instance":12421,"id":182420,"goal":"lemma AddComm_12421(i: int, m: int)\n ensures i + m == m + i\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_12422","instance":12422,"id":182421,"goal":"lemma AddAssoc_12422(y: nat, d: nat, x: nat)\n ensures (y + d) + x == y + (d + x)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_12423","instance":12423,"id":182422,"goal":"lemma MulComm_12423(k: real, z: real)\n ensures k * z == z * k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_12424","instance":12424,"id":182423,"goal":"lemma MulAssoc_12424(x: int, i: int, k: int)\n ensures (x * i) * k == x * (i * k)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_12425","instance":12425,"id":182424,"goal":"lemma Distrib_12425(i: nat, d: nat, a: nat)\n ensures i * (d + a) == i * d + i * a\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_12426","instance":12426,"id":182425,"goal":"lemma AddZero_12426(k: real)\n ensures k + 0 == k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_12427","instance":12427,"id":182426,"goal":"lemma MulOne_12427(d: int)\n ensures d * 1 == d\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_12428","instance":12428,"id":182427,"goal":"lemma MulZero_12428(y: nat)\n ensures y * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_12429","instance":12429,"id":182428,"goal":"lemma LeRefl_12429(d: real)\n ensures d <= d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_12430","instance":12430,"id":182429,"goal":"lemma LeTrans_12430(b: int, k: int, y: int)\n requires b <= k && k <= y\n ensures b <= y\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_12431","instance":12431,"id":182430,"goal":"lemma AddMono_12431(m: nat, x: nat, c: nat)\n requires m <= x\n ensures m + c <= x + c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_12432","instance":12432,"id":182431,"goal":"lemma Abs_Nonneg_12432(m: real)\n ensures (if m >= 0 then m else -m) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_12433","instance":12433,"id":182432,"goal":"lemma DivMod_12433(c: int, a: int)\n requires a > 0\n ensures c == a * (c / a) + (c % a)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_12434","instance":12434,"id":182433,"goal":"lemma ModBounds_12434(k: nat, b: nat)\n requires b > 0\n ensures 0 <= k % b < b\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_12435","instance":12435,"id":182434,"goal":"lemma Square_Nonneg_12435(c: real)\n ensures c * c >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_12436","instance":12436,"id":182435,"goal":"lemma AddComm_12436(b: int, c: int)\n ensures b + c == c + b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_12437","instance":12437,"id":182436,"goal":"lemma AddAssoc_12437(c: nat, z: nat, m: nat)\n ensures (c + z) + m == c + (z + m)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_12438","instance":12438,"id":182437,"goal":"lemma MulComm_12438(y: real, n: real)\n ensures y * n == n * y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_12439","instance":12439,"id":182438,"goal":"lemma MulAssoc_12439(n: int, m: int, x: int)\n ensures (n * m) * x == n * (m * x)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_12440","instance":12440,"id":182439,"goal":"lemma Distrib_12440(m: nat, x: nat, d: nat)\n ensures m * (x + d) == m * x + m * d\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_12441","instance":12441,"id":182440,"goal":"lemma AddZero_12441(k: real)\n ensures k + 0 == k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_12442","instance":12442,"id":182441,"goal":"lemma MulOne_12442(i: int)\n ensures i * 1 == i\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_12443","instance":12443,"id":182442,"goal":"lemma MulZero_12443(n: nat)\n ensures n * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_12444","instance":12444,"id":182443,"goal":"lemma LeRefl_12444(m: real)\n ensures m <= m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_12445","instance":12445,"id":182444,"goal":"lemma LeTrans_12445(z: int, n: int, i: int)\n requires z <= n && n <= i\n ensures z <= i\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_12446","instance":12446,"id":182445,"goal":"lemma AddMono_12446(z: nat, y: nat, n: nat)\n requires z <= y\n ensures z + n <= y + n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_12447","instance":12447,"id":182446,"goal":"lemma Abs_Nonneg_12447(c: real)\n ensures (if c >= 0 then c else -c) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_12448","instance":12448,"id":182447,"goal":"lemma DivMod_12448(n: int, a: int)\n requires a > 0\n ensures n == a * (n / a) + (n % a)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_12449","instance":12449,"id":182448,"goal":"lemma ModBounds_12449(m: nat, z: nat)\n requires z > 0\n ensures 0 <= m % z < z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_12450","instance":12450,"id":182449,"goal":"lemma Square_Nonneg_12450(j: real)\n ensures j * j >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_12451","instance":12451,"id":182450,"goal":"lemma AddComm_12451(m: int, a: int)\n ensures m + a == a + m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_12452","instance":12452,"id":182451,"goal":"lemma AddAssoc_12452(y: nat, d: nat, n: nat)\n ensures (y + d) + n == y + (d + n)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_12453","instance":12453,"id":182452,"goal":"lemma MulComm_12453(a: real, n: real)\n ensures a * n == n * a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_12454","instance":12454,"id":182453,"goal":"lemma MulAssoc_12454(k: int, j: int, x: int)\n ensures (k * j) * x == k * (j * x)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_12455","instance":12455,"id":182454,"goal":"lemma Distrib_12455(z: nat, d: nat, b: nat)\n ensures z * (d + b) == z * d + z * b\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_12456","instance":12456,"id":182455,"goal":"lemma AddZero_12456(n: real)\n ensures n + 0 == n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_12457","instance":12457,"id":182456,"goal":"lemma MulOne_12457(y: int)\n ensures y * 1 == y\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_12458","instance":12458,"id":182457,"goal":"lemma MulZero_12458(j: nat)\n ensures j * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_12459","instance":12459,"id":182458,"goal":"lemma LeRefl_12459(c: real)\n ensures c <= c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_12460","instance":12460,"id":182459,"goal":"lemma LeTrans_12460(k: int, m: int, i: int)\n requires k <= m && m <= i\n ensures k <= i\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_12461","instance":12461,"id":182460,"goal":"lemma AddMono_12461(x: nat, i: nat, k: nat)\n requires x <= i\n ensures x + k <= i + k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_12462","instance":12462,"id":182461,"goal":"lemma Abs_Nonneg_12462(n: real)\n ensures (if n >= 0 then n else -n) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_12463","instance":12463,"id":182462,"goal":"lemma DivMod_12463(j: int, a: int)\n requires a > 0\n ensures j == a * (j / a) + (j % a)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_12464","instance":12464,"id":182463,"goal":"lemma ModBounds_12464(m: nat, c: nat)\n requires c > 0\n ensures 0 <= m % c < c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_12465","instance":12465,"id":182464,"goal":"lemma Square_Nonneg_12465(m: real)\n ensures m * m >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_12466","instance":12466,"id":182465,"goal":"lemma AddComm_12466(m: int, k: int)\n ensures m + k == k + m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_12467","instance":12467,"id":182466,"goal":"lemma AddAssoc_12467(m: nat, i: nat, a: nat)\n ensures (m + i) + a == m + (i + a)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_12468","instance":12468,"id":182467,"goal":"lemma MulComm_12468(c: real, b: real)\n ensures c * b == b * c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_12469","instance":12469,"id":182468,"goal":"lemma MulAssoc_12469(y: int, a: int, k: int)\n ensures (y * a) * k == y * (a * k)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_12470","instance":12470,"id":182469,"goal":"lemma Distrib_12470(x: nat, b: nat, k: nat)\n ensures x * (b + k) == x * b + x * k\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_12471","instance":12471,"id":182470,"goal":"lemma AddZero_12471(n: real)\n ensures n + 0 == n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_12472","instance":12472,"id":182471,"goal":"lemma MulOne_12472(z: int)\n ensures z * 1 == z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_12473","instance":12473,"id":182472,"goal":"lemma MulZero_12473(m: nat)\n ensures m * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_12474","instance":12474,"id":182473,"goal":"lemma LeRefl_12474(i: real)\n ensures i <= i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_12475","instance":12475,"id":182474,"goal":"lemma LeTrans_12475(k: int, n: int, a: int)\n requires k <= n && n <= a\n ensures k <= a\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_12476","instance":12476,"id":182475,"goal":"lemma AddMono_12476(i: nat, b: nat, a: nat)\n requires i <= b\n ensures i + a <= b + a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_12477","instance":12477,"id":182476,"goal":"lemma Abs_Nonneg_12477(j: real)\n ensures (if j >= 0 then j else -j) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_12478","instance":12478,"id":182477,"goal":"lemma DivMod_12478(x: int, b: int)\n requires b > 0\n ensures x == b * (x / b) + (x % b)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_12479","instance":12479,"id":182478,"goal":"lemma ModBounds_12479(k: nat, m: nat)\n requires m > 0\n ensures 0 <= k % m < m\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_12480","instance":12480,"id":182479,"goal":"lemma Square_Nonneg_12480(z: real)\n ensures z * z >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_12481","instance":12481,"id":182480,"goal":"lemma AddComm_12481(b: int, n: int)\n ensures b + n == n + b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_12482","instance":12482,"id":182481,"goal":"lemma AddAssoc_12482(j: nat, d: nat, y: nat)\n ensures (j + d) + y == j + (d + y)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_12483","instance":12483,"id":182482,"goal":"lemma MulComm_12483(x: real, a: real)\n ensures x * a == a * x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_12484","instance":12484,"id":182483,"goal":"lemma MulAssoc_12484(a: int, z: int, j: int)\n ensures (a * z) * j == a * (z * j)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_12485","instance":12485,"id":182484,"goal":"lemma Distrib_12485(c: nat, a: nat, x: nat)\n ensures c * (a + x) == c * a + c * x\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_12486","instance":12486,"id":182485,"goal":"lemma AddZero_12486(x: real)\n ensures x + 0 == x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_12487","instance":12487,"id":182486,"goal":"lemma MulOne_12487(y: int)\n ensures y * 1 == y\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_12488","instance":12488,"id":182487,"goal":"lemma MulZero_12488(k: nat)\n ensures k * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_12489","instance":12489,"id":182488,"goal":"lemma LeRefl_12489(b: real)\n ensures b <= b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_12490","instance":12490,"id":182489,"goal":"lemma LeTrans_12490(d: int, y: int, c: int)\n requires d <= y && y <= c\n ensures d <= c\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_12491","instance":12491,"id":182490,"goal":"lemma AddMono_12491(x: nat, y: nat, b: nat)\n requires x <= y\n ensures x + b <= y + b\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_12492","instance":12492,"id":182491,"goal":"lemma Abs_Nonneg_12492(x: real)\n ensures (if x >= 0 then x else -x) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_12493","instance":12493,"id":182492,"goal":"lemma DivMod_12493(z: int, i: int)\n requires i > 0\n ensures z == i * (z / i) + (z % i)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_12494","instance":12494,"id":182493,"goal":"lemma ModBounds_12494(m: nat, z: nat)\n requires z > 0\n ensures 0 <= m % z < z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_12495","instance":12495,"id":182494,"goal":"lemma Square_Nonneg_12495(m: real)\n ensures m * m >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_12496","instance":12496,"id":182495,"goal":"lemma AddComm_12496(i: int, y: int)\n ensures i + y == y + i\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_12497","instance":12497,"id":182496,"goal":"lemma AddAssoc_12497(y: nat, m: nat, b: nat)\n ensures (y + m) + b == y + (m + b)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_12498","instance":12498,"id":182497,"goal":"lemma MulComm_12498(i: real, d: real)\n ensures i * d == d * i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_12499","instance":12499,"id":182498,"goal":"lemma MulAssoc_12499(b: int, z: int, i: int)\n ensures (b * z) * i == b * (z * i)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_12500","instance":12500,"id":182499,"goal":"lemma Distrib_12500(z: nat, a: nat, x: nat)\n ensures z * (a + x) == z * a + z * x\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_12501","instance":12501,"id":182500,"goal":"lemma AddZero_12501(y: real)\n ensures y + 0 == y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_12502","instance":12502,"id":182501,"goal":"lemma MulOne_12502(b: int)\n ensures b * 1 == b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_12503","instance":12503,"id":182502,"goal":"lemma MulZero_12503(j: nat)\n ensures j * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_12504","instance":12504,"id":182503,"goal":"lemma LeRefl_12504(n: real)\n ensures n <= n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_12505","instance":12505,"id":182504,"goal":"lemma LeTrans_12505(d: int, k: int, a: int)\n requires d <= k && k <= a\n ensures d <= a\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_12506","instance":12506,"id":182505,"goal":"lemma AddMono_12506(j: nat, d: nat, z: nat)\n requires j <= d\n ensures j + z <= d + z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_12507","instance":12507,"id":182506,"goal":"lemma Abs_Nonneg_12507(b: real)\n ensures (if b >= 0 then b else -b) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_12508","instance":12508,"id":182507,"goal":"lemma DivMod_12508(j: int, n: int)\n requires n > 0\n ensures j == n * (j / n) + (j % n)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_12509","instance":12509,"id":182508,"goal":"lemma ModBounds_12509(d: nat, j: nat)\n requires j > 0\n ensures 0 <= d % j < j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_12510","instance":12510,"id":182509,"goal":"lemma Square_Nonneg_12510(m: real)\n ensures m * m >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_12511","instance":12511,"id":182510,"goal":"lemma AddComm_12511(j: int, a: int)\n ensures j + a == a + j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_12512","instance":12512,"id":182511,"goal":"lemma AddAssoc_12512(i: nat, d: nat, a: nat)\n ensures (i + d) + a == i + (d + a)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_12513","instance":12513,"id":182512,"goal":"lemma MulComm_12513(j: real, d: real)\n ensures j * d == d * j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_12514","instance":12514,"id":182513,"goal":"lemma MulAssoc_12514(b: int, j: int, m: int)\n ensures (b * j) * m == b * (j * m)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_12515","instance":12515,"id":182514,"goal":"lemma Distrib_12515(b: nat, x: nat, y: nat)\n ensures b * (x + y) == b * x + b * y\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_12516","instance":12516,"id":182515,"goal":"lemma AddZero_12516(c: real)\n ensures c + 0 == c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_12517","instance":12517,"id":182516,"goal":"lemma MulOne_12517(i: int)\n ensures i * 1 == i\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_12518","instance":12518,"id":182517,"goal":"lemma MulZero_12518(c: nat)\n ensures c * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_12519","instance":12519,"id":182518,"goal":"lemma LeRefl_12519(k: real)\n ensures k <= k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_12520","instance":12520,"id":182519,"goal":"lemma LeTrans_12520(k: int, n: int, z: int)\n requires k <= n && n <= z\n ensures k <= z\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_12521","instance":12521,"id":182520,"goal":"lemma AddMono_12521(b: nat, x: nat, z: nat)\n requires b <= x\n ensures b + z <= x + z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_12522","instance":12522,"id":182521,"goal":"lemma Abs_Nonneg_12522(c: real)\n ensures (if c >= 0 then c else -c) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_12523","instance":12523,"id":182522,"goal":"lemma DivMod_12523(c: int, y: int)\n requires y > 0\n ensures c == y * (c / y) + (c % y)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_12524","instance":12524,"id":182523,"goal":"lemma ModBounds_12524(x: nat, a: nat)\n requires a > 0\n ensures 0 <= x % a < a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_12525","instance":12525,"id":182524,"goal":"lemma Square_Nonneg_12525(i: real)\n ensures i * i >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_12526","instance":12526,"id":182525,"goal":"lemma AddComm_12526(b: int, z: int)\n ensures b + z == z + b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_12527","instance":12527,"id":182526,"goal":"lemma AddAssoc_12527(y: nat, a: nat, z: nat)\n ensures (y + a) + z == y + (a + z)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_12528","instance":12528,"id":182527,"goal":"lemma MulComm_12528(m: real, j: real)\n ensures m * j == j * m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_12529","instance":12529,"id":182528,"goal":"lemma MulAssoc_12529(j: int, m: int, b: int)\n ensures (j * m) * b == j * (m * b)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_12530","instance":12530,"id":182529,"goal":"lemma Distrib_12530(c: nat, d: nat, j: nat)\n ensures c * (d + j) == c * d + c * j\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_12531","instance":12531,"id":182530,"goal":"lemma AddZero_12531(n: real)\n ensures n + 0 == n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_12532","instance":12532,"id":182531,"goal":"lemma MulOne_12532(n: int)\n ensures n * 1 == n\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_12533","instance":12533,"id":182532,"goal":"lemma MulZero_12533(n: nat)\n ensures n * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_12534","instance":12534,"id":182533,"goal":"lemma LeRefl_12534(d: real)\n ensures d <= d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_12535","instance":12535,"id":182534,"goal":"lemma LeTrans_12535(z: int, x: int, b: int)\n requires z <= x && x <= b\n ensures z <= b\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_12536","instance":12536,"id":182535,"goal":"lemma AddMono_12536(m: nat, n: nat, j: nat)\n requires m <= n\n ensures m + j <= n + j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_12537","instance":12537,"id":182536,"goal":"lemma Abs_Nonneg_12537(n: real)\n ensures (if n >= 0 then n else -n) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_12538","instance":12538,"id":182537,"goal":"lemma DivMod_12538(c: int, n: int)\n requires n > 0\n ensures c == n * (c / n) + (c % n)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_12539","instance":12539,"id":182538,"goal":"lemma ModBounds_12539(z: nat, k: nat)\n requires k > 0\n ensures 0 <= z % k < k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_12540","instance":12540,"id":182539,"goal":"lemma Square_Nonneg_12540(m: real)\n ensures m * m >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_12541","instance":12541,"id":182540,"goal":"lemma AddComm_12541(j: int, b: int)\n ensures j + b == b + j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_12542","instance":12542,"id":182541,"goal":"lemma AddAssoc_12542(n: nat, c: nat, a: nat)\n ensures (n + c) + a == n + (c + a)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_12543","instance":12543,"id":182542,"goal":"lemma MulComm_12543(z: real, a: real)\n ensures z * a == a * z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_12544","instance":12544,"id":182543,"goal":"lemma MulAssoc_12544(k: int, j: int, y: int)\n ensures (k * j) * y == k * (j * y)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_12545","instance":12545,"id":182544,"goal":"lemma Distrib_12545(c: nat, y: nat, b: nat)\n ensures c * (y + b) == c * y + c * b\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_12546","instance":12546,"id":182545,"goal":"lemma AddZero_12546(i: real)\n ensures i + 0 == i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_12547","instance":12547,"id":182546,"goal":"lemma MulOne_12547(j: int)\n ensures j * 1 == j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_12548","instance":12548,"id":182547,"goal":"lemma MulZero_12548(y: nat)\n ensures y * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_12549","instance":12549,"id":182548,"goal":"lemma LeRefl_12549(c: real)\n ensures c <= c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_12550","instance":12550,"id":182549,"goal":"lemma LeTrans_12550(d: int, m: int, k: int)\n requires d <= m && m <= k\n ensures d <= k\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_12551","instance":12551,"id":182550,"goal":"lemma AddMono_12551(a: nat, x: nat, z: nat)\n requires a <= x\n ensures a + z <= x + z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_12552","instance":12552,"id":182551,"goal":"lemma Abs_Nonneg_12552(a: real)\n ensures (if a >= 0 then a else -a) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_12553","instance":12553,"id":182552,"goal":"lemma DivMod_12553(k: int, i: int)\n requires i > 0\n ensures k == i * (k / i) + (k % i)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_12554","instance":12554,"id":182553,"goal":"lemma ModBounds_12554(m: nat, d: nat)\n requires d > 0\n ensures 0 <= m % d < d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_12555","instance":12555,"id":182554,"goal":"lemma Square_Nonneg_12555(c: real)\n ensures c * c >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_12556","instance":12556,"id":182555,"goal":"lemma AddComm_12556(d: int, k: int)\n ensures d + k == k + d\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_12557","instance":12557,"id":182556,"goal":"lemma AddAssoc_12557(a: nat, m: nat, c: nat)\n ensures (a + m) + c == a + (m + c)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_12558","instance":12558,"id":182557,"goal":"lemma MulComm_12558(i: real, y: real)\n ensures i * y == y * i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_12559","instance":12559,"id":182558,"goal":"lemma MulAssoc_12559(i: int, b: int, k: int)\n ensures (i * b) * k == i * (b * k)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_12560","instance":12560,"id":182559,"goal":"lemma Distrib_12560(n: nat, a: nat, m: nat)\n ensures n * (a + m) == n * a + n * m\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_12561","instance":12561,"id":182560,"goal":"lemma AddZero_12561(m: real)\n ensures m + 0 == m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_12562","instance":12562,"id":182561,"goal":"lemma MulOne_12562(x: int)\n ensures x * 1 == x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_12563","instance":12563,"id":182562,"goal":"lemma MulZero_12563(j: nat)\n ensures j * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_12564","instance":12564,"id":182563,"goal":"lemma LeRefl_12564(c: real)\n ensures c <= c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_12565","instance":12565,"id":182564,"goal":"lemma LeTrans_12565(m: int, z: int, x: int)\n requires m <= z && z <= x\n ensures m <= x\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_12566","instance":12566,"id":182565,"goal":"lemma AddMono_12566(c: nat, d: nat, n: nat)\n requires c <= d\n ensures c + n <= d + n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_12567","instance":12567,"id":182566,"goal":"lemma Abs_Nonneg_12567(b: real)\n ensures (if b >= 0 then b else -b) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_12568","instance":12568,"id":182567,"goal":"lemma DivMod_12568(k: int, d: int)\n requires d > 0\n ensures k == d * (k / d) + (k % d)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_12569","instance":12569,"id":182568,"goal":"lemma ModBounds_12569(b: nat, k: nat)\n requires k > 0\n ensures 0 <= b % k < k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_12570","instance":12570,"id":182569,"goal":"lemma Square_Nonneg_12570(k: real)\n ensures k * k >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_12571","instance":12571,"id":182570,"goal":"lemma AddComm_12571(c: int, z: int)\n ensures c + z == z + c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_12572","instance":12572,"id":182571,"goal":"lemma AddAssoc_12572(m: nat, b: nat, i: nat)\n ensures (m + b) + i == m + (b + i)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_12573","instance":12573,"id":182572,"goal":"lemma MulComm_12573(c: real, m: real)\n ensures c * m == m * c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_12574","instance":12574,"id":182573,"goal":"lemma MulAssoc_12574(j: int, n: int, i: int)\n ensures (j * n) * i == j * (n * i)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_12575","instance":12575,"id":182574,"goal":"lemma Distrib_12575(d: nat, i: nat, n: nat)\n ensures d * (i + n) == d * i + d * n\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_12576","instance":12576,"id":182575,"goal":"lemma AddZero_12576(d: real)\n ensures d + 0 == d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_12577","instance":12577,"id":182576,"goal":"lemma MulOne_12577(n: int)\n ensures n * 1 == n\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_12578","instance":12578,"id":182577,"goal":"lemma MulZero_12578(x: nat)\n ensures x * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_12579","instance":12579,"id":182578,"goal":"lemma LeRefl_12579(z: real)\n ensures z <= z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_12580","instance":12580,"id":182579,"goal":"lemma LeTrans_12580(a: int, z: int, c: int)\n requires a <= z && z <= c\n ensures a <= c\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_12581","instance":12581,"id":182580,"goal":"lemma AddMono_12581(x: nat, z: nat, n: nat)\n requires x <= z\n ensures x + n <= z + n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_12582","instance":12582,"id":182581,"goal":"lemma Abs_Nonneg_12582(d: real)\n ensures (if d >= 0 then d else -d) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_12583","instance":12583,"id":182582,"goal":"lemma DivMod_12583(a: int, m: int)\n requires m > 0\n ensures a == m * (a / m) + (a % m)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_12584","instance":12584,"id":182583,"goal":"lemma ModBounds_12584(m: nat, a: nat)\n requires a > 0\n ensures 0 <= m % a < a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_12585","instance":12585,"id":182584,"goal":"lemma Square_Nonneg_12585(m: real)\n ensures m * m >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_12586","instance":12586,"id":182585,"goal":"lemma AddComm_12586(k: int, y: int)\n ensures k + y == y + k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_12587","instance":12587,"id":182586,"goal":"lemma AddAssoc_12587(n: nat, y: nat, b: nat)\n ensures (n + y) + b == n + (y + b)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_12588","instance":12588,"id":182587,"goal":"lemma MulComm_12588(b: real, i: real)\n ensures b * i == i * b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_12589","instance":12589,"id":182588,"goal":"lemma MulAssoc_12589(y: int, d: int, b: int)\n ensures (y * d) * b == y * (d * b)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_12590","instance":12590,"id":182589,"goal":"lemma Distrib_12590(a: nat, j: nat, n: nat)\n ensures a * (j + n) == a * j + a * n\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_12591","instance":12591,"id":182590,"goal":"lemma AddZero_12591(n: real)\n ensures n + 0 == n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_12592","instance":12592,"id":182591,"goal":"lemma MulOne_12592(k: int)\n ensures k * 1 == k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_12593","instance":12593,"id":182592,"goal":"lemma MulZero_12593(b: nat)\n ensures b * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_12594","instance":12594,"id":182593,"goal":"lemma LeRefl_12594(c: real)\n ensures c <= c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_12595","instance":12595,"id":182594,"goal":"lemma LeTrans_12595(n: int, d: int, y: int)\n requires n <= d && d <= y\n ensures n <= y\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_12596","instance":12596,"id":182595,"goal":"lemma AddMono_12596(x: nat, i: nat, d: nat)\n requires x <= i\n ensures x + d <= i + d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_12597","instance":12597,"id":182596,"goal":"lemma Abs_Nonneg_12597(b: real)\n ensures (if b >= 0 then b else -b) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_12598","instance":12598,"id":182597,"goal":"lemma DivMod_12598(b: int, z: int)\n requires z > 0\n ensures b == z * (b / z) + (b % z)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_12599","instance":12599,"id":182598,"goal":"lemma ModBounds_12599(d: nat, x: nat)\n requires x > 0\n ensures 0 <= d % x < x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_12600","instance":12600,"id":182599,"goal":"lemma Square_Nonneg_12600(a: real)\n ensures a * a >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_12601","instance":12601,"id":182600,"goal":"lemma AddComm_12601(y: int, n: int)\n ensures y + n == n + y\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_12602","instance":12602,"id":182601,"goal":"lemma AddAssoc_12602(m: nat, y: nat, x: nat)\n ensures (m + y) + x == m + (y + x)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_12603","instance":12603,"id":182602,"goal":"lemma MulComm_12603(d: real, a: real)\n ensures d * a == a * d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_12604","instance":12604,"id":182603,"goal":"lemma MulAssoc_12604(x: int, d: int, b: int)\n ensures (x * d) * b == x * (d * b)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_12605","instance":12605,"id":182604,"goal":"lemma Distrib_12605(z: nat, x: nat, y: nat)\n ensures z * (x + y) == z * x + z * y\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_12606","instance":12606,"id":182605,"goal":"lemma AddZero_12606(c: real)\n ensures c + 0 == c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_12607","instance":12607,"id":182606,"goal":"lemma MulOne_12607(c: int)\n ensures c * 1 == c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_12608","instance":12608,"id":182607,"goal":"lemma MulZero_12608(x: nat)\n ensures x * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_12609","instance":12609,"id":182608,"goal":"lemma LeRefl_12609(a: real)\n ensures a <= a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_12610","instance":12610,"id":182609,"goal":"lemma LeTrans_12610(c: int, i: int, x: int)\n requires c <= i && i <= x\n ensures c <= x\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_12611","instance":12611,"id":182610,"goal":"lemma AddMono_12611(k: nat, n: nat, b: nat)\n requires k <= n\n ensures k + b <= n + b\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_12612","instance":12612,"id":182611,"goal":"lemma Abs_Nonneg_12612(b: real)\n ensures (if b >= 0 then b else -b) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_12613","instance":12613,"id":182612,"goal":"lemma DivMod_12613(d: int, a: int)\n requires a > 0\n ensures d == a * (d / a) + (d % a)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_12614","instance":12614,"id":182613,"goal":"lemma ModBounds_12614(j: nat, d: nat)\n requires d > 0\n ensures 0 <= j % d < d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_12615","instance":12615,"id":182614,"goal":"lemma Square_Nonneg_12615(b: real)\n ensures b * b >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_12616","instance":12616,"id":182615,"goal":"lemma AddComm_12616(j: int, b: int)\n ensures j + b == b + j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_12617","instance":12617,"id":182616,"goal":"lemma AddAssoc_12617(c: nat, y: nat, i: nat)\n ensures (c + y) + i == c + (y + i)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_12618","instance":12618,"id":182617,"goal":"lemma MulComm_12618(i: real, a: real)\n ensures i * a == a * i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_12619","instance":12619,"id":182618,"goal":"lemma MulAssoc_12619(n: int, i: int, k: int)\n ensures (n * i) * k == n * (i * k)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_12620","instance":12620,"id":182619,"goal":"lemma Distrib_12620(d: nat, i: nat, n: nat)\n ensures d * (i + n) == d * i + d * n\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_12621","instance":12621,"id":182620,"goal":"lemma AddZero_12621(c: real)\n ensures c + 0 == c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_12622","instance":12622,"id":182621,"goal":"lemma MulOne_12622(c: int)\n ensures c * 1 == c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_12623","instance":12623,"id":182622,"goal":"lemma MulZero_12623(x: nat)\n ensures x * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_12624","instance":12624,"id":182623,"goal":"lemma LeRefl_12624(x: real)\n ensures x <= x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_12625","instance":12625,"id":182624,"goal":"lemma LeTrans_12625(c: int, y: int, a: int)\n requires c <= y && y <= a\n ensures c <= a\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_12626","instance":12626,"id":182625,"goal":"lemma AddMono_12626(m: nat, x: nat, a: nat)\n requires m <= x\n ensures m + a <= x + a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_12627","instance":12627,"id":182626,"goal":"lemma Abs_Nonneg_12627(b: real)\n ensures (if b >= 0 then b else -b) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_12628","instance":12628,"id":182627,"goal":"lemma DivMod_12628(x: int, c: int)\n requires c > 0\n ensures x == c * (x / c) + (x % c)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_12629","instance":12629,"id":182628,"goal":"lemma ModBounds_12629(k: nat, n: nat)\n requires n > 0\n ensures 0 <= k % n < n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_12630","instance":12630,"id":182629,"goal":"lemma Square_Nonneg_12630(k: real)\n ensures k * k >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_12631","instance":12631,"id":182630,"goal":"lemma AddComm_12631(i: int, y: int)\n ensures i + y == y + i\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_12632","instance":12632,"id":182631,"goal":"lemma AddAssoc_12632(i: nat, c: nat, d: nat)\n ensures (i + c) + d == i + (c + d)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_12633","instance":12633,"id":182632,"goal":"lemma MulComm_12633(c: real, y: real)\n ensures c * y == y * c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_12634","instance":12634,"id":182633,"goal":"lemma MulAssoc_12634(x: int, n: int, k: int)\n ensures (x * n) * k == x * (n * k)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_12635","instance":12635,"id":182634,"goal":"lemma Distrib_12635(n: nat, m: nat, c: nat)\n ensures n * (m + c) == n * m + n * c\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_12636","instance":12636,"id":182635,"goal":"lemma AddZero_12636(z: real)\n ensures z + 0 == z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_12637","instance":12637,"id":182636,"goal":"lemma MulOne_12637(x: int)\n ensures x * 1 == x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_12638","instance":12638,"id":182637,"goal":"lemma MulZero_12638(b: nat)\n ensures b * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_12639","instance":12639,"id":182638,"goal":"lemma LeRefl_12639(a: real)\n ensures a <= a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_12640","instance":12640,"id":182639,"goal":"lemma LeTrans_12640(b: int, i: int, m: int)\n requires b <= i && i <= m\n ensures b <= m\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_12641","instance":12641,"id":182640,"goal":"lemma AddMono_12641(d: nat, b: nat, i: nat)\n requires d <= b\n ensures d + i <= b + i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_12642","instance":12642,"id":182641,"goal":"lemma Abs_Nonneg_12642(m: real)\n ensures (if m >= 0 then m else -m) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_12643","instance":12643,"id":182642,"goal":"lemma DivMod_12643(z: int, b: int)\n requires b > 0\n ensures z == b * (z / b) + (z % b)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_12644","instance":12644,"id":182643,"goal":"lemma ModBounds_12644(a: nat, n: nat)\n requires n > 0\n ensures 0 <= a % n < n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_12645","instance":12645,"id":182644,"goal":"lemma Square_Nonneg_12645(m: real)\n ensures m * m >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_12646","instance":12646,"id":182645,"goal":"lemma AddComm_12646(c: int, i: int)\n ensures c + i == i + c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_12647","instance":12647,"id":182646,"goal":"lemma AddAssoc_12647(i: nat, b: nat, d: nat)\n ensures (i + b) + d == i + (b + d)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_12648","instance":12648,"id":182647,"goal":"lemma MulComm_12648(d: real, a: real)\n ensures d * a == a * d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_12649","instance":12649,"id":182648,"goal":"lemma MulAssoc_12649(j: int, m: int, c: int)\n ensures (j * m) * c == j * (m * c)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_12650","instance":12650,"id":182649,"goal":"lemma Distrib_12650(b: nat, y: nat, j: nat)\n ensures b * (y + j) == b * y + b * j\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_12651","instance":12651,"id":182650,"goal":"lemma AddZero_12651(c: real)\n ensures c + 0 == c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_12652","instance":12652,"id":182651,"goal":"lemma MulOne_12652(a: int)\n ensures a * 1 == a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_12653","instance":12653,"id":182652,"goal":"lemma MulZero_12653(j: nat)\n ensures j * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_12654","instance":12654,"id":182653,"goal":"lemma LeRefl_12654(x: real)\n ensures x <= x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_12655","instance":12655,"id":182654,"goal":"lemma LeTrans_12655(d: int, n: int, z: int)\n requires d <= n && n <= z\n ensures d <= z\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_12656","instance":12656,"id":182655,"goal":"lemma AddMono_12656(d: nat, x: nat, a: nat)\n requires d <= x\n ensures d + a <= x + a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_12657","instance":12657,"id":182656,"goal":"lemma Abs_Nonneg_12657(c: real)\n ensures (if c >= 0 then c else -c) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_12658","instance":12658,"id":182657,"goal":"lemma DivMod_12658(n: int, x: int)\n requires x > 0\n ensures n == x * (n / x) + (n % x)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_12659","instance":12659,"id":182658,"goal":"lemma ModBounds_12659(b: nat, x: nat)\n requires x > 0\n ensures 0 <= b % x < x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_12660","instance":12660,"id":182659,"goal":"lemma Square_Nonneg_12660(i: real)\n ensures i * i >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_12661","instance":12661,"id":182660,"goal":"lemma AddComm_12661(a: int, c: int)\n ensures a + c == c + a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_12662","instance":12662,"id":182661,"goal":"lemma AddAssoc_12662(x: nat, n: nat, y: nat)\n ensures (x + n) + y == x + (n + y)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_12663","instance":12663,"id":182662,"goal":"lemma MulComm_12663(n: real, c: real)\n ensures n * c == c * n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_12664","instance":12664,"id":182663,"goal":"lemma MulAssoc_12664(y: int, c: int, j: int)\n ensures (y * c) * j == y * (c * j)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_12665","instance":12665,"id":182664,"goal":"lemma Distrib_12665(i: nat, d: nat, a: nat)\n ensures i * (d + a) == i * d + i * a\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_12666","instance":12666,"id":182665,"goal":"lemma AddZero_12666(j: real)\n ensures j + 0 == j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_12667","instance":12667,"id":182666,"goal":"lemma MulOne_12667(z: int)\n ensures z * 1 == z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_12668","instance":12668,"id":182667,"goal":"lemma MulZero_12668(x: nat)\n ensures x * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_12669","instance":12669,"id":182668,"goal":"lemma LeRefl_12669(y: real)\n ensures y <= y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_12670","instance":12670,"id":182669,"goal":"lemma LeTrans_12670(j: int, c: int, x: int)\n requires j <= c && c <= x\n ensures j <= x\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_12671","instance":12671,"id":182670,"goal":"lemma AddMono_12671(i: nat, m: nat, y: nat)\n requires i <= m\n ensures i + y <= m + y\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_12672","instance":12672,"id":182671,"goal":"lemma Abs_Nonneg_12672(k: real)\n ensures (if k >= 0 then k else -k) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_12673","instance":12673,"id":182672,"goal":"lemma DivMod_12673(i: int, d: int)\n requires d > 0\n ensures i == d * (i / d) + (i % d)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_12674","instance":12674,"id":182673,"goal":"lemma ModBounds_12674(b: nat, m: nat)\n requires m > 0\n ensures 0 <= b % m < m\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_12675","instance":12675,"id":182674,"goal":"lemma Square_Nonneg_12675(j: real)\n ensures j * j >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_12676","instance":12676,"id":182675,"goal":"lemma AddComm_12676(x: int, a: int)\n ensures x + a == a + x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_12677","instance":12677,"id":182676,"goal":"lemma AddAssoc_12677(b: nat, x: nat, k: nat)\n ensures (b + x) + k == b + (x + k)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_12678","instance":12678,"id":182677,"goal":"lemma MulComm_12678(i: real, x: real)\n ensures i * x == x * i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_12679","instance":12679,"id":182678,"goal":"lemma MulAssoc_12679(j: int, y: int, b: int)\n ensures (j * y) * b == j * (y * b)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_12680","instance":12680,"id":182679,"goal":"lemma Distrib_12680(m: nat, y: nat, b: nat)\n ensures m * (y + b) == m * y + m * b\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_12681","instance":12681,"id":182680,"goal":"lemma AddZero_12681(n: real)\n ensures n + 0 == n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_12682","instance":12682,"id":182681,"goal":"lemma MulOne_12682(i: int)\n ensures i * 1 == i\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_12683","instance":12683,"id":182682,"goal":"lemma MulZero_12683(j: nat)\n ensures j * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_12684","instance":12684,"id":182683,"goal":"lemma LeRefl_12684(i: real)\n ensures i <= i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_12685","instance":12685,"id":182684,"goal":"lemma LeTrans_12685(m: int, k: int, x: int)\n requires m <= k && k <= x\n ensures m <= x\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_12686","instance":12686,"id":182685,"goal":"lemma AddMono_12686(y: nat, x: nat, z: nat)\n requires y <= x\n ensures y + z <= x + z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_12687","instance":12687,"id":182686,"goal":"lemma Abs_Nonneg_12687(k: real)\n ensures (if k >= 0 then k else -k) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_12688","instance":12688,"id":182687,"goal":"lemma DivMod_12688(c: int, x: int)\n requires x > 0\n ensures c == x * (c / x) + (c % x)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_12689","instance":12689,"id":182688,"goal":"lemma ModBounds_12689(i: nat, j: nat)\n requires j > 0\n ensures 0 <= i % j < j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_12690","instance":12690,"id":182689,"goal":"lemma Square_Nonneg_12690(b: real)\n ensures b * b >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_12691","instance":12691,"id":182690,"goal":"lemma AddComm_12691(z: int, y: int)\n ensures z + y == y + z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_12692","instance":12692,"id":182691,"goal":"lemma AddAssoc_12692(d: nat, x: nat, y: nat)\n ensures (d + x) + y == d + (x + y)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_12693","instance":12693,"id":182692,"goal":"lemma MulComm_12693(i: real, n: real)\n ensures i * n == n * i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_12694","instance":12694,"id":182693,"goal":"lemma MulAssoc_12694(x: int, b: int, d: int)\n ensures (x * b) * d == x * (b * d)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_12695","instance":12695,"id":182694,"goal":"lemma Distrib_12695(b: nat, j: nat, z: nat)\n ensures b * (j + z) == b * j + b * z\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_12696","instance":12696,"id":182695,"goal":"lemma AddZero_12696(m: real)\n ensures m + 0 == m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_12697","instance":12697,"id":182696,"goal":"lemma MulOne_12697(i: int)\n ensures i * 1 == i\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_12698","instance":12698,"id":182697,"goal":"lemma MulZero_12698(z: nat)\n ensures z * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_12699","instance":12699,"id":182698,"goal":"lemma LeRefl_12699(n: real)\n ensures n <= n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_12700","instance":12700,"id":182699,"goal":"lemma LeTrans_12700(m: int, d: int, b: int)\n requires m <= d && d <= b\n ensures m <= b\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_12701","instance":12701,"id":182700,"goal":"lemma AddMono_12701(m: nat, i: nat, y: nat)\n requires m <= i\n ensures m + y <= i + y\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_12702","instance":12702,"id":182701,"goal":"lemma Abs_Nonneg_12702(x: real)\n ensures (if x >= 0 then x else -x) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_12703","instance":12703,"id":182702,"goal":"lemma DivMod_12703(n: int, a: int)\n requires a > 0\n ensures n == a * (n / a) + (n % a)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_12704","instance":12704,"id":182703,"goal":"lemma ModBounds_12704(d: nat, a: nat)\n requires a > 0\n ensures 0 <= d % a < a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_12705","instance":12705,"id":182704,"goal":"lemma Square_Nonneg_12705(b: real)\n ensures b * b >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_12706","instance":12706,"id":182705,"goal":"lemma AddComm_12706(n: int, i: int)\n ensures n + i == i + n\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_12707","instance":12707,"id":182706,"goal":"lemma AddAssoc_12707(i: nat, b: nat, c: nat)\n ensures (i + b) + c == i + (b + c)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_12708","instance":12708,"id":182707,"goal":"lemma MulComm_12708(m: real, y: real)\n ensures m * y == y * m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_12709","instance":12709,"id":182708,"goal":"lemma MulAssoc_12709(a: int, m: int, y: int)\n ensures (a * m) * y == a * (m * y)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_12710","instance":12710,"id":182709,"goal":"lemma Distrib_12710(j: nat, c: nat, i: nat)\n ensures j * (c + i) == j * c + j * i\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_12711","instance":12711,"id":182710,"goal":"lemma AddZero_12711(j: real)\n ensures j + 0 == j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_12712","instance":12712,"id":182711,"goal":"lemma MulOne_12712(c: int)\n ensures c * 1 == c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_12713","instance":12713,"id":182712,"goal":"lemma MulZero_12713(b: nat)\n ensures b * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_12714","instance":12714,"id":182713,"goal":"lemma LeRefl_12714(y: real)\n ensures y <= y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_12715","instance":12715,"id":182714,"goal":"lemma LeTrans_12715(a: int, i: int, m: int)\n requires a <= i && i <= m\n ensures a <= m\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_12716","instance":12716,"id":182715,"goal":"lemma AddMono_12716(k: nat, b: nat, i: nat)\n requires k <= b\n ensures k + i <= b + i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_12717","instance":12717,"id":182716,"goal":"lemma Abs_Nonneg_12717(b: real)\n ensures (if b >= 0 then b else -b) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_12718","instance":12718,"id":182717,"goal":"lemma DivMod_12718(x: int, m: int)\n requires m > 0\n ensures x == m * (x / m) + (x % m)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_12719","instance":12719,"id":182718,"goal":"lemma ModBounds_12719(y: nat, x: nat)\n requires x > 0\n ensures 0 <= y % x < x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_12720","instance":12720,"id":182719,"goal":"lemma Square_Nonneg_12720(m: real)\n ensures m * m >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_12721","instance":12721,"id":182720,"goal":"lemma AddComm_12721(i: int, y: int)\n ensures i + y == y + i\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_12722","instance":12722,"id":182721,"goal":"lemma AddAssoc_12722(b: nat, y: nat, j: nat)\n ensures (b + y) + j == b + (y + j)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_12723","instance":12723,"id":182722,"goal":"lemma MulComm_12723(i: real, n: real)\n ensures i * n == n * i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_12724","instance":12724,"id":182723,"goal":"lemma MulAssoc_12724(x: int, b: int, y: int)\n ensures (x * b) * y == x * (b * y)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_12725","instance":12725,"id":182724,"goal":"lemma Distrib_12725(d: nat, a: nat, z: nat)\n ensures d * (a + z) == d * a + d * z\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_12726","instance":12726,"id":182725,"goal":"lemma AddZero_12726(j: real)\n ensures j + 0 == j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_12727","instance":12727,"id":182726,"goal":"lemma MulOne_12727(m: int)\n ensures m * 1 == m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_12728","instance":12728,"id":182727,"goal":"lemma MulZero_12728(m: nat)\n ensures m * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_12729","instance":12729,"id":182728,"goal":"lemma LeRefl_12729(b: real)\n ensures b <= b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_12730","instance":12730,"id":182729,"goal":"lemma LeTrans_12730(c: int, y: int, j: int)\n requires c <= y && y <= j\n ensures c <= j\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_12731","instance":12731,"id":182730,"goal":"lemma AddMono_12731(d: nat, b: nat, x: nat)\n requires d <= b\n ensures d + x <= b + x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_12732","instance":12732,"id":182731,"goal":"lemma Abs_Nonneg_12732(y: real)\n ensures (if y >= 0 then y else -y) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_12733","instance":12733,"id":182732,"goal":"lemma DivMod_12733(k: int, j: int)\n requires j > 0\n ensures k == j * (k / j) + (k % j)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_12734","instance":12734,"id":182733,"goal":"lemma ModBounds_12734(x: nat, m: nat)\n requires m > 0\n ensures 0 <= x % m < m\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_12735","instance":12735,"id":182734,"goal":"lemma Square_Nonneg_12735(x: real)\n ensures x * x >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_12736","instance":12736,"id":182735,"goal":"lemma AddComm_12736(z: int, n: int)\n ensures z + n == n + z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_12737","instance":12737,"id":182736,"goal":"lemma AddAssoc_12737(x: nat, z: nat, m: nat)\n ensures (x + z) + m == x + (z + m)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_12738","instance":12738,"id":182737,"goal":"lemma MulComm_12738(k: real, z: real)\n ensures k * z == z * k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_12739","instance":12739,"id":182738,"goal":"lemma MulAssoc_12739(m: int, b: int, a: int)\n ensures (m * b) * a == m * (b * a)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_12740","instance":12740,"id":182739,"goal":"lemma Distrib_12740(x: nat, c: nat, a: nat)\n ensures x * (c + a) == x * c + x * a\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_12741","instance":12741,"id":182740,"goal":"lemma AddZero_12741(y: real)\n ensures y + 0 == y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_12742","instance":12742,"id":182741,"goal":"lemma MulOne_12742(m: int)\n ensures m * 1 == m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_12743","instance":12743,"id":182742,"goal":"lemma MulZero_12743(d: nat)\n ensures d * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_12744","instance":12744,"id":182743,"goal":"lemma LeRefl_12744(c: real)\n ensures c <= c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_12745","instance":12745,"id":182744,"goal":"lemma LeTrans_12745(c: int, b: int, j: int)\n requires c <= b && b <= j\n ensures c <= j\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_12746","instance":12746,"id":182745,"goal":"lemma AddMono_12746(j: nat, i: nat, c: nat)\n requires j <= i\n ensures j + c <= i + c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_12747","instance":12747,"id":182746,"goal":"lemma Abs_Nonneg_12747(d: real)\n ensures (if d >= 0 then d else -d) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_12748","instance":12748,"id":182747,"goal":"lemma DivMod_12748(n: int, y: int)\n requires y > 0\n ensures n == y * (n / y) + (n % y)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_12749","instance":12749,"id":182748,"goal":"lemma ModBounds_12749(n: nat, i: nat)\n requires i > 0\n ensures 0 <= n % i < i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_12750","instance":12750,"id":182749,"goal":"lemma Square_Nonneg_12750(b: real)\n ensures b * b >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_12751","instance":12751,"id":182750,"goal":"lemma AddComm_12751(m: int, y: int)\n ensures m + y == y + m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_12752","instance":12752,"id":182751,"goal":"lemma AddAssoc_12752(i: nat, c: nat, d: nat)\n ensures (i + c) + d == i + (c + d)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_12753","instance":12753,"id":182752,"goal":"lemma MulComm_12753(k: real, n: real)\n ensures k * n == n * k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_12754","instance":12754,"id":182753,"goal":"lemma MulAssoc_12754(a: int, d: int, i: int)\n ensures (a * d) * i == a * (d * i)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_12755","instance":12755,"id":182754,"goal":"lemma Distrib_12755(b: nat, m: nat, y: nat)\n ensures b * (m + y) == b * m + b * y\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_12756","instance":12756,"id":182755,"goal":"lemma AddZero_12756(d: real)\n ensures d + 0 == d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_12757","instance":12757,"id":182756,"goal":"lemma MulOne_12757(n: int)\n ensures n * 1 == n\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_12758","instance":12758,"id":182757,"goal":"lemma MulZero_12758(z: nat)\n ensures z * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_12759","instance":12759,"id":182758,"goal":"lemma LeRefl_12759(j: real)\n ensures j <= j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_12760","instance":12760,"id":182759,"goal":"lemma LeTrans_12760(j: int, i: int, m: int)\n requires j <= i && i <= m\n ensures j <= m\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_12761","instance":12761,"id":182760,"goal":"lemma AddMono_12761(c: nat, y: nat, x: nat)\n requires c <= y\n ensures c + x <= y + x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_12762","instance":12762,"id":182761,"goal":"lemma Abs_Nonneg_12762(m: real)\n ensures (if m >= 0 then m else -m) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_12763","instance":12763,"id":182762,"goal":"lemma DivMod_12763(d: int, m: int)\n requires m > 0\n ensures d == m * (d / m) + (d % m)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_12764","instance":12764,"id":182763,"goal":"lemma ModBounds_12764(i: nat, n: nat)\n requires n > 0\n ensures 0 <= i % n < n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_12765","instance":12765,"id":182764,"goal":"lemma Square_Nonneg_12765(m: real)\n ensures m * m >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_12766","instance":12766,"id":182765,"goal":"lemma AddComm_12766(z: int, b: int)\n ensures z + b == b + z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_12767","instance":12767,"id":182766,"goal":"lemma AddAssoc_12767(d: nat, z: nat, m: nat)\n ensures (d + z) + m == d + (z + m)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_12768","instance":12768,"id":182767,"goal":"lemma MulComm_12768(b: real, a: real)\n ensures b * a == a * b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_12769","instance":12769,"id":182768,"goal":"lemma MulAssoc_12769(x: int, a: int, n: int)\n ensures (x * a) * n == x * (a * n)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_12770","instance":12770,"id":182769,"goal":"lemma Distrib_12770(j: nat, k: nat, a: nat)\n ensures j * (k + a) == j * k + j * a\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_12771","instance":12771,"id":182770,"goal":"lemma AddZero_12771(m: real)\n ensures m + 0 == m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_12772","instance":12772,"id":182771,"goal":"lemma MulOne_12772(x: int)\n ensures x * 1 == x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_12773","instance":12773,"id":182772,"goal":"lemma MulZero_12773(d: nat)\n ensures d * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_12774","instance":12774,"id":182773,"goal":"lemma LeRefl_12774(x: real)\n ensures x <= x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_12775","instance":12775,"id":182774,"goal":"lemma LeTrans_12775(b: int, i: int, m: int)\n requires b <= i && i <= m\n ensures b <= m\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_12776","instance":12776,"id":182775,"goal":"lemma AddMono_12776(a: nat, n: nat, m: nat)\n requires a <= n\n ensures a + m <= n + m\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_12777","instance":12777,"id":182776,"goal":"lemma Abs_Nonneg_12777(i: real)\n ensures (if i >= 0 then i else -i) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_12778","instance":12778,"id":182777,"goal":"lemma DivMod_12778(n: int, a: int)\n requires a > 0\n ensures n == a * (n / a) + (n % a)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_12779","instance":12779,"id":182778,"goal":"lemma ModBounds_12779(x: nat, z: nat)\n requires z > 0\n ensures 0 <= x % z < z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_12780","instance":12780,"id":182779,"goal":"lemma Square_Nonneg_12780(k: real)\n ensures k * k >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_12781","instance":12781,"id":182780,"goal":"lemma AddComm_12781(z: int, y: int)\n ensures z + y == y + z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_12782","instance":12782,"id":182781,"goal":"lemma AddAssoc_12782(y: nat, k: nat, b: nat)\n ensures (y + k) + b == y + (k + b)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_12783","instance":12783,"id":182782,"goal":"lemma MulComm_12783(n: real, d: real)\n ensures n * d == d * n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_12784","instance":12784,"id":182783,"goal":"lemma MulAssoc_12784(k: int, z: int, b: int)\n ensures (k * z) * b == k * (z * b)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_12785","instance":12785,"id":182784,"goal":"lemma Distrib_12785(c: nat, j: nat, i: nat)\n ensures c * (j + i) == c * j + c * i\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_12786","instance":12786,"id":182785,"goal":"lemma AddZero_12786(x: real)\n ensures x + 0 == x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_12787","instance":12787,"id":182786,"goal":"lemma MulOne_12787(b: int)\n ensures b * 1 == b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_12788","instance":12788,"id":182787,"goal":"lemma MulZero_12788(d: nat)\n ensures d * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_12789","instance":12789,"id":182788,"goal":"lemma LeRefl_12789(x: real)\n ensures x <= x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_12790","instance":12790,"id":182789,"goal":"lemma LeTrans_12790(i: int, a: int, n: int)\n requires i <= a && a <= n\n ensures i <= n\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_12791","instance":12791,"id":182790,"goal":"lemma AddMono_12791(a: nat, d: nat, k: nat)\n requires a <= d\n ensures a + k <= d + k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_12792","instance":12792,"id":182791,"goal":"lemma Abs_Nonneg_12792(n: real)\n ensures (if n >= 0 then n else -n) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_12793","instance":12793,"id":182792,"goal":"lemma DivMod_12793(j: int, i: int)\n requires i > 0\n ensures j == i * (j / i) + (j % i)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_12794","instance":12794,"id":182793,"goal":"lemma ModBounds_12794(k: nat, x: nat)\n requires x > 0\n ensures 0 <= k % x < x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_12795","instance":12795,"id":182794,"goal":"lemma Square_Nonneg_12795(a: real)\n ensures a * a >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_12796","instance":12796,"id":182795,"goal":"lemma AddComm_12796(z: int, b: int)\n ensures z + b == b + z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_12797","instance":12797,"id":182796,"goal":"lemma AddAssoc_12797(i: nat, d: nat, a: nat)\n ensures (i + d) + a == i + (d + a)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_12798","instance":12798,"id":182797,"goal":"lemma MulComm_12798(b: real, a: real)\n ensures b * a == a * b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_12799","instance":12799,"id":182798,"goal":"lemma MulAssoc_12799(y: int, x: int, d: int)\n ensures (y * x) * d == y * (x * d)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_12800","instance":12800,"id":182799,"goal":"lemma Distrib_12800(k: nat, j: nat, i: nat)\n ensures k * (j + i) == k * j + k * i\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_12801","instance":12801,"id":182800,"goal":"lemma AddZero_12801(i: real)\n ensures i + 0 == i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_12802","instance":12802,"id":182801,"goal":"lemma MulOne_12802(x: int)\n ensures x * 1 == x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_12803","instance":12803,"id":182802,"goal":"lemma MulZero_12803(a: nat)\n ensures a * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_12804","instance":12804,"id":182803,"goal":"lemma LeRefl_12804(i: real)\n ensures i <= i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_12805","instance":12805,"id":182804,"goal":"lemma LeTrans_12805(j: int, z: int, d: int)\n requires j <= z && z <= d\n ensures j <= d\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_12806","instance":12806,"id":182805,"goal":"lemma AddMono_12806(a: nat, c: nat, m: nat)\n requires a <= c\n ensures a + m <= c + m\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_12807","instance":12807,"id":182806,"goal":"lemma Abs_Nonneg_12807(n: real)\n ensures (if n >= 0 then n else -n) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_12808","instance":12808,"id":182807,"goal":"lemma DivMod_12808(x: int, k: int)\n requires k > 0\n ensures x == k * (x / k) + (x % k)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_12809","instance":12809,"id":182808,"goal":"lemma ModBounds_12809(i: nat, c: nat)\n requires c > 0\n ensures 0 <= i % c < c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_12810","instance":12810,"id":182809,"goal":"lemma Square_Nonneg_12810(a: real)\n ensures a * a >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_12811","instance":12811,"id":182810,"goal":"lemma AddComm_12811(c: int, z: int)\n ensures c + z == z + c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_12812","instance":12812,"id":182811,"goal":"lemma AddAssoc_12812(z: nat, i: nat, c: nat)\n ensures (z + i) + c == z + (i + c)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_12813","instance":12813,"id":182812,"goal":"lemma MulComm_12813(y: real, x: real)\n ensures y * x == x * y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_12814","instance":12814,"id":182813,"goal":"lemma MulAssoc_12814(z: int, c: int, m: int)\n ensures (z * c) * m == z * (c * m)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_12815","instance":12815,"id":182814,"goal":"lemma Distrib_12815(a: nat, k: nat, d: nat)\n ensures a * (k + d) == a * k + a * d\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_12816","instance":12816,"id":182815,"goal":"lemma AddZero_12816(y: real)\n ensures y + 0 == y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_12817","instance":12817,"id":182816,"goal":"lemma MulOne_12817(a: int)\n ensures a * 1 == a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_12818","instance":12818,"id":182817,"goal":"lemma MulZero_12818(d: nat)\n ensures d * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_12819","instance":12819,"id":182818,"goal":"lemma LeRefl_12819(c: real)\n ensures c <= c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_12820","instance":12820,"id":182819,"goal":"lemma LeTrans_12820(n: int, a: int, c: int)\n requires n <= a && a <= c\n ensures n <= c\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_12821","instance":12821,"id":182820,"goal":"lemma AddMono_12821(i: nat, m: nat, j: nat)\n requires i <= m\n ensures i + j <= m + j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_12822","instance":12822,"id":182821,"goal":"lemma Abs_Nonneg_12822(b: real)\n ensures (if b >= 0 then b else -b) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_12823","instance":12823,"id":182822,"goal":"lemma DivMod_12823(y: int, m: int)\n requires m > 0\n ensures y == m * (y / m) + (y % m)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_12824","instance":12824,"id":182823,"goal":"lemma ModBounds_12824(n: nat, j: nat)\n requires j > 0\n ensures 0 <= n % j < j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_12825","instance":12825,"id":182824,"goal":"lemma Square_Nonneg_12825(k: real)\n ensures k * k >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_12826","instance":12826,"id":182825,"goal":"lemma AddComm_12826(b: int, i: int)\n ensures b + i == i + b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_12827","instance":12827,"id":182826,"goal":"lemma AddAssoc_12827(b: nat, d: nat, y: nat)\n ensures (b + d) + y == b + (d + y)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_12828","instance":12828,"id":182827,"goal":"lemma MulComm_12828(d: real, m: real)\n ensures d * m == m * d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_12829","instance":12829,"id":182828,"goal":"lemma MulAssoc_12829(k: int, a: int, b: int)\n ensures (k * a) * b == k * (a * b)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_12830","instance":12830,"id":182829,"goal":"lemma Distrib_12830(a: nat, n: nat, m: nat)\n ensures a * (n + m) == a * n + a * m\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_12831","instance":12831,"id":182830,"goal":"lemma AddZero_12831(m: real)\n ensures m + 0 == m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_12832","instance":12832,"id":182831,"goal":"lemma MulOne_12832(a: int)\n ensures a * 1 == a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_12833","instance":12833,"id":182832,"goal":"lemma MulZero_12833(i: nat)\n ensures i * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_12834","instance":12834,"id":182833,"goal":"lemma LeRefl_12834(d: real)\n ensures d <= d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_12835","instance":12835,"id":182834,"goal":"lemma LeTrans_12835(a: int, b: int, j: int)\n requires a <= b && b <= j\n ensures a <= j\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_12836","instance":12836,"id":182835,"goal":"lemma AddMono_12836(m: nat, n: nat, x: nat)\n requires m <= n\n ensures m + x <= n + x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_12837","instance":12837,"id":182836,"goal":"lemma Abs_Nonneg_12837(m: real)\n ensures (if m >= 0 then m else -m) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_12838","instance":12838,"id":182837,"goal":"lemma DivMod_12838(a: int, j: int)\n requires j > 0\n ensures a == j * (a / j) + (a % j)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_12839","instance":12839,"id":182838,"goal":"lemma ModBounds_12839(a: nat, i: nat)\n requires i > 0\n ensures 0 <= a % i < i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_12840","instance":12840,"id":182839,"goal":"lemma Square_Nonneg_12840(c: real)\n ensures c * c >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_12841","instance":12841,"id":182840,"goal":"lemma AddComm_12841(x: int, b: int)\n ensures x + b == b + x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_12842","instance":12842,"id":182841,"goal":"lemma AddAssoc_12842(d: nat, z: nat, y: nat)\n ensures (d + z) + y == d + (z + y)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_12843","instance":12843,"id":182842,"goal":"lemma MulComm_12843(z: real, j: real)\n ensures z * j == j * z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_12844","instance":12844,"id":182843,"goal":"lemma MulAssoc_12844(y: int, n: int, z: int)\n ensures (y * n) * z == y * (n * z)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_12845","instance":12845,"id":182844,"goal":"lemma Distrib_12845(j: nat, m: nat, b: nat)\n ensures j * (m + b) == j * m + j * b\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_12846","instance":12846,"id":182845,"goal":"lemma AddZero_12846(c: real)\n ensures c + 0 == c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_12847","instance":12847,"id":182846,"goal":"lemma MulOne_12847(y: int)\n ensures y * 1 == y\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_12848","instance":12848,"id":182847,"goal":"lemma MulZero_12848(i: nat)\n ensures i * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_12849","instance":12849,"id":182848,"goal":"lemma LeRefl_12849(d: real)\n ensures d <= d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_12850","instance":12850,"id":182849,"goal":"lemma LeTrans_12850(b: int, d: int, c: int)\n requires b <= d && d <= c\n ensures b <= c\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_12851","instance":12851,"id":182850,"goal":"lemma AddMono_12851(y: nat, n: nat, i: nat)\n requires y <= n\n ensures y + i <= n + i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_12852","instance":12852,"id":182851,"goal":"lemma Abs_Nonneg_12852(d: real)\n ensures (if d >= 0 then d else -d) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_12853","instance":12853,"id":182852,"goal":"lemma DivMod_12853(n: int, k: int)\n requires k > 0\n ensures n == k * (n / k) + (n % k)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_12854","instance":12854,"id":182853,"goal":"lemma ModBounds_12854(a: nat, k: nat)\n requires k > 0\n ensures 0 <= a % k < k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_12855","instance":12855,"id":182854,"goal":"lemma Square_Nonneg_12855(c: real)\n ensures c * c >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_12856","instance":12856,"id":182855,"goal":"lemma AddComm_12856(y: int, m: int)\n ensures y + m == m + y\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_12857","instance":12857,"id":182856,"goal":"lemma AddAssoc_12857(m: nat, y: nat, j: nat)\n ensures (m + y) + j == m + (y + j)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_12858","instance":12858,"id":182857,"goal":"lemma MulComm_12858(k: real, d: real)\n ensures k * d == d * k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_12859","instance":12859,"id":182858,"goal":"lemma MulAssoc_12859(a: int, c: int, k: int)\n ensures (a * c) * k == a * (c * k)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_12860","instance":12860,"id":182859,"goal":"lemma Distrib_12860(y: nat, d: nat, i: nat)\n ensures y * (d + i) == y * d + y * i\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_12861","instance":12861,"id":182860,"goal":"lemma AddZero_12861(y: real)\n ensures y + 0 == y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_12862","instance":12862,"id":182861,"goal":"lemma MulOne_12862(j: int)\n ensures j * 1 == j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_12863","instance":12863,"id":182862,"goal":"lemma MulZero_12863(c: nat)\n ensures c * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_12864","instance":12864,"id":182863,"goal":"lemma LeRefl_12864(c: real)\n ensures c <= c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_12865","instance":12865,"id":182864,"goal":"lemma LeTrans_12865(i: int, b: int, c: int)\n requires i <= b && b <= c\n ensures i <= c\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_12866","instance":12866,"id":182865,"goal":"lemma AddMono_12866(k: nat, a: nat, y: nat)\n requires k <= a\n ensures k + y <= a + y\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_12867","instance":12867,"id":182866,"goal":"lemma Abs_Nonneg_12867(k: real)\n ensures (if k >= 0 then k else -k) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_12868","instance":12868,"id":182867,"goal":"lemma DivMod_12868(z: int, y: int)\n requires y > 0\n ensures z == y * (z / y) + (z % y)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_12869","instance":12869,"id":182868,"goal":"lemma ModBounds_12869(i: nat, x: nat)\n requires x > 0\n ensures 0 <= i % x < x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_12870","instance":12870,"id":182869,"goal":"lemma Square_Nonneg_12870(d: real)\n ensures d * d >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_12871","instance":12871,"id":182870,"goal":"lemma AddComm_12871(a: int, z: int)\n ensures a + z == z + a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_12872","instance":12872,"id":182871,"goal":"lemma AddAssoc_12872(z: nat, n: nat, k: nat)\n ensures (z + n) + k == z + (n + k)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_12873","instance":12873,"id":182872,"goal":"lemma MulComm_12873(x: real, i: real)\n ensures x * i == i * x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_12874","instance":12874,"id":182873,"goal":"lemma MulAssoc_12874(x: int, k: int, a: int)\n ensures (x * k) * a == x * (k * a)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_12875","instance":12875,"id":182874,"goal":"lemma Distrib_12875(d: nat, c: nat, y: nat)\n ensures d * (c + y) == d * c + d * y\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_12876","instance":12876,"id":182875,"goal":"lemma AddZero_12876(x: real)\n ensures x + 0 == x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_12877","instance":12877,"id":182876,"goal":"lemma MulOne_12877(c: int)\n ensures c * 1 == c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_12878","instance":12878,"id":182877,"goal":"lemma MulZero_12878(y: nat)\n ensures y * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_12879","instance":12879,"id":182878,"goal":"lemma LeRefl_12879(b: real)\n ensures b <= b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_12880","instance":12880,"id":182879,"goal":"lemma LeTrans_12880(m: int, d: int, j: int)\n requires m <= d && d <= j\n ensures m <= j\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_12881","instance":12881,"id":182880,"goal":"lemma AddMono_12881(z: nat, j: nat, c: nat)\n requires z <= j\n ensures z + c <= j + c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_12882","instance":12882,"id":182881,"goal":"lemma Abs_Nonneg_12882(j: real)\n ensures (if j >= 0 then j else -j) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_12883","instance":12883,"id":182882,"goal":"lemma DivMod_12883(z: int, a: int)\n requires a > 0\n ensures z == a * (z / a) + (z % a)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_12884","instance":12884,"id":182883,"goal":"lemma ModBounds_12884(i: nat, c: nat)\n requires c > 0\n ensures 0 <= i % c < c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_12885","instance":12885,"id":182884,"goal":"lemma Square_Nonneg_12885(c: real)\n ensures c * c >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_12886","instance":12886,"id":182885,"goal":"lemma AddComm_12886(c: int, d: int)\n ensures c + d == d + c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_12887","instance":12887,"id":182886,"goal":"lemma AddAssoc_12887(m: nat, j: nat, n: nat)\n ensures (m + j) + n == m + (j + n)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_12888","instance":12888,"id":182887,"goal":"lemma MulComm_12888(b: real, x: real)\n ensures b * x == x * b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_12889","instance":12889,"id":182888,"goal":"lemma MulAssoc_12889(n: int, i: int, d: int)\n ensures (n * i) * d == n * (i * d)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_12890","instance":12890,"id":182889,"goal":"lemma Distrib_12890(b: nat, z: nat, d: nat)\n ensures b * (z + d) == b * z + b * d\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_12891","instance":12891,"id":182890,"goal":"lemma AddZero_12891(y: real)\n ensures y + 0 == y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_12892","instance":12892,"id":182891,"goal":"lemma MulOne_12892(c: int)\n ensures c * 1 == c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_12893","instance":12893,"id":182892,"goal":"lemma MulZero_12893(d: nat)\n ensures d * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_12894","instance":12894,"id":182893,"goal":"lemma LeRefl_12894(c: real)\n ensures c <= c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_12895","instance":12895,"id":182894,"goal":"lemma LeTrans_12895(j: int, d: int, a: int)\n requires j <= d && d <= a\n ensures j <= a\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_12896","instance":12896,"id":182895,"goal":"lemma AddMono_12896(i: nat, z: nat, k: nat)\n requires i <= z\n ensures i + k <= z + k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_12897","instance":12897,"id":182896,"goal":"lemma Abs_Nonneg_12897(x: real)\n ensures (if x >= 0 then x else -x) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_12898","instance":12898,"id":182897,"goal":"lemma DivMod_12898(n: int, c: int)\n requires c > 0\n ensures n == c * (n / c) + (n % c)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_12899","instance":12899,"id":182898,"goal":"lemma ModBounds_12899(z: nat, j: nat)\n requires j > 0\n ensures 0 <= z % j < j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_12900","instance":12900,"id":182899,"goal":"lemma Square_Nonneg_12900(i: real)\n ensures i * i >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_12901","instance":12901,"id":182900,"goal":"lemma AddComm_12901(x: int, k: int)\n ensures x + k == k + x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_12902","instance":12902,"id":182901,"goal":"lemma AddAssoc_12902(c: nat, n: nat, b: nat)\n ensures (c + n) + b == c + (n + b)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_12903","instance":12903,"id":182902,"goal":"lemma MulComm_12903(d: real, n: real)\n ensures d * n == n * d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_12904","instance":12904,"id":182903,"goal":"lemma MulAssoc_12904(d: int, y: int, x: int)\n ensures (d * y) * x == d * (y * x)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_12905","instance":12905,"id":182904,"goal":"lemma Distrib_12905(n: nat, k: nat, m: nat)\n ensures n * (k + m) == n * k + n * m\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_12906","instance":12906,"id":182905,"goal":"lemma AddZero_12906(x: real)\n ensures x + 0 == x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_12907","instance":12907,"id":182906,"goal":"lemma MulOne_12907(i: int)\n ensures i * 1 == i\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_12908","instance":12908,"id":182907,"goal":"lemma MulZero_12908(z: nat)\n ensures z * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_12909","instance":12909,"id":182908,"goal":"lemma LeRefl_12909(x: real)\n ensures x <= x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_12910","instance":12910,"id":182909,"goal":"lemma LeTrans_12910(x: int, c: int, n: int)\n requires x <= c && c <= n\n ensures x <= n\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_12911","instance":12911,"id":182910,"goal":"lemma AddMono_12911(z: nat, x: nat, y: nat)\n requires z <= x\n ensures z + y <= x + y\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_12912","instance":12912,"id":182911,"goal":"lemma Abs_Nonneg_12912(c: real)\n ensures (if c >= 0 then c else -c) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_12913","instance":12913,"id":182912,"goal":"lemma DivMod_12913(n: int, b: int)\n requires b > 0\n ensures n == b * (n / b) + (n % b)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_12914","instance":12914,"id":182913,"goal":"lemma ModBounds_12914(j: nat, d: nat)\n requires d > 0\n ensures 0 <= j % d < d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_12915","instance":12915,"id":182914,"goal":"lemma Square_Nonneg_12915(i: real)\n ensures i * i >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_12916","instance":12916,"id":182915,"goal":"lemma AddComm_12916(y: int, j: int)\n ensures y + j == j + y\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_12917","instance":12917,"id":182916,"goal":"lemma AddAssoc_12917(j: nat, i: nat, a: nat)\n ensures (j + i) + a == j + (i + a)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_12918","instance":12918,"id":182917,"goal":"lemma MulComm_12918(m: real, y: real)\n ensures m * y == y * m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_12919","instance":12919,"id":182918,"goal":"lemma MulAssoc_12919(m: int, d: int, b: int)\n ensures (m * d) * b == m * (d * b)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_12920","instance":12920,"id":182919,"goal":"lemma Distrib_12920(y: nat, x: nat, j: nat)\n ensures y * (x + j) == y * x + y * j\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_12921","instance":12921,"id":182920,"goal":"lemma AddZero_12921(z: real)\n ensures z + 0 == z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_12922","instance":12922,"id":182921,"goal":"lemma MulOne_12922(c: int)\n ensures c * 1 == c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_12923","instance":12923,"id":182922,"goal":"lemma MulZero_12923(b: nat)\n ensures b * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_12924","instance":12924,"id":182923,"goal":"lemma LeRefl_12924(k: real)\n ensures k <= k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_12925","instance":12925,"id":182924,"goal":"lemma LeTrans_12925(j: int, i: int, a: int)\n requires j <= i && i <= a\n ensures j <= a\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_12926","instance":12926,"id":182925,"goal":"lemma AddMono_12926(y: nat, c: nat, x: nat)\n requires y <= c\n ensures y + x <= c + x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_12927","instance":12927,"id":182926,"goal":"lemma Abs_Nonneg_12927(m: real)\n ensures (if m >= 0 then m else -m) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_12928","instance":12928,"id":182927,"goal":"lemma DivMod_12928(i: int, j: int)\n requires j > 0\n ensures i == j * (i / j) + (i % j)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_12929","instance":12929,"id":182928,"goal":"lemma ModBounds_12929(i: nat, y: nat)\n requires y > 0\n ensures 0 <= i % y < y\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_12930","instance":12930,"id":182929,"goal":"lemma Square_Nonneg_12930(n: real)\n ensures n * n >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_12931","instance":12931,"id":182930,"goal":"lemma AddComm_12931(y: int, i: int)\n ensures y + i == i + y\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_12932","instance":12932,"id":182931,"goal":"lemma AddAssoc_12932(y: nat, k: nat, b: nat)\n ensures (y + k) + b == y + (k + b)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_12933","instance":12933,"id":182932,"goal":"lemma MulComm_12933(m: real, n: real)\n ensures m * n == n * m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_12934","instance":12934,"id":182933,"goal":"lemma MulAssoc_12934(k: int, x: int, m: int)\n ensures (k * x) * m == k * (x * m)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_12935","instance":12935,"id":182934,"goal":"lemma Distrib_12935(x: nat, b: nat, n: nat)\n ensures x * (b + n) == x * b + x * n\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_12936","instance":12936,"id":182935,"goal":"lemma AddZero_12936(b: real)\n ensures b + 0 == b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_12937","instance":12937,"id":182936,"goal":"lemma MulOne_12937(y: int)\n ensures y * 1 == y\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_12938","instance":12938,"id":182937,"goal":"lemma MulZero_12938(i: nat)\n ensures i * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_12939","instance":12939,"id":182938,"goal":"lemma LeRefl_12939(y: real)\n ensures y <= y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_12940","instance":12940,"id":182939,"goal":"lemma LeTrans_12940(m: int, b: int, a: int)\n requires m <= b && b <= a\n ensures m <= a\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_12941","instance":12941,"id":182940,"goal":"lemma AddMono_12941(d: nat, i: nat, m: nat)\n requires d <= i\n ensures d + m <= i + m\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_12942","instance":12942,"id":182941,"goal":"lemma Abs_Nonneg_12942(d: real)\n ensures (if d >= 0 then d else -d) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_12943","instance":12943,"id":182942,"goal":"lemma DivMod_12943(n: int, x: int)\n requires x > 0\n ensures n == x * (n / x) + (n % x)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_12944","instance":12944,"id":182943,"goal":"lemma ModBounds_12944(k: nat, i: nat)\n requires i > 0\n ensures 0 <= k % i < i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_12945","instance":12945,"id":182944,"goal":"lemma Square_Nonneg_12945(k: real)\n ensures k * k >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_12946","instance":12946,"id":182945,"goal":"lemma AddComm_12946(a: int, y: int)\n ensures a + y == y + a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_12947","instance":12947,"id":182946,"goal":"lemma AddAssoc_12947(i: nat, j: nat, x: nat)\n ensures (i + j) + x == i + (j + x)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_12948","instance":12948,"id":182947,"goal":"lemma MulComm_12948(j: real, x: real)\n ensures j * x == x * j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_12949","instance":12949,"id":182948,"goal":"lemma MulAssoc_12949(j: int, c: int, y: int)\n ensures (j * c) * y == j * (c * y)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_12950","instance":12950,"id":182949,"goal":"lemma Distrib_12950(z: nat, b: nat, m: nat)\n ensures z * (b + m) == z * b + z * m\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_12951","instance":12951,"id":182950,"goal":"lemma AddZero_12951(x: real)\n ensures x + 0 == x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_12952","instance":12952,"id":182951,"goal":"lemma MulOne_12952(b: int)\n ensures b * 1 == b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_12953","instance":12953,"id":182952,"goal":"lemma MulZero_12953(y: nat)\n ensures y * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_12954","instance":12954,"id":182953,"goal":"lemma LeRefl_12954(a: real)\n ensures a <= a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_12955","instance":12955,"id":182954,"goal":"lemma LeTrans_12955(b: int, i: int, z: int)\n requires b <= i && i <= z\n ensures b <= z\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_12956","instance":12956,"id":182955,"goal":"lemma AddMono_12956(n: nat, x: nat, j: nat)\n requires n <= x\n ensures n + j <= x + j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_12957","instance":12957,"id":182956,"goal":"lemma Abs_Nonneg_12957(j: real)\n ensures (if j >= 0 then j else -j) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_12958","instance":12958,"id":182957,"goal":"lemma DivMod_12958(m: int, a: int)\n requires a > 0\n ensures m == a * (m / a) + (m % a)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_12959","instance":12959,"id":182958,"goal":"lemma ModBounds_12959(n: nat, y: nat)\n requires y > 0\n ensures 0 <= n % y < y\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_12960","instance":12960,"id":182959,"goal":"lemma Square_Nonneg_12960(y: real)\n ensures y * y >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_12961","instance":12961,"id":182960,"goal":"lemma AddComm_12961(y: int, x: int)\n ensures y + x == x + y\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_12962","instance":12962,"id":182961,"goal":"lemma AddAssoc_12962(c: nat, i: nat, m: nat)\n ensures (c + i) + m == c + (i + m)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_12963","instance":12963,"id":182962,"goal":"lemma MulComm_12963(b: real, d: real)\n ensures b * d == d * b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_12964","instance":12964,"id":182963,"goal":"lemma MulAssoc_12964(k: int, y: int, n: int)\n ensures (k * y) * n == k * (y * n)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_12965","instance":12965,"id":182964,"goal":"lemma Distrib_12965(k: nat, m: nat, i: nat)\n ensures k * (m + i) == k * m + k * i\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_12966","instance":12966,"id":182965,"goal":"lemma AddZero_12966(k: real)\n ensures k + 0 == k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_12967","instance":12967,"id":182966,"goal":"lemma MulOne_12967(a: int)\n ensures a * 1 == a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_12968","instance":12968,"id":182967,"goal":"lemma MulZero_12968(k: nat)\n ensures k * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_12969","instance":12969,"id":182968,"goal":"lemma LeRefl_12969(m: real)\n ensures m <= m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_12970","instance":12970,"id":182969,"goal":"lemma LeTrans_12970(x: int, b: int, m: int)\n requires x <= b && b <= m\n ensures x <= m\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_12971","instance":12971,"id":182970,"goal":"lemma AddMono_12971(y: nat, a: nat, n: nat)\n requires y <= a\n ensures y + n <= a + n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_12972","instance":12972,"id":182971,"goal":"lemma Abs_Nonneg_12972(m: real)\n ensures (if m >= 0 then m else -m) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_12973","instance":12973,"id":182972,"goal":"lemma DivMod_12973(k: int, b: int)\n requires b > 0\n ensures k == b * (k / b) + (k % b)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_12974","instance":12974,"id":182973,"goal":"lemma ModBounds_12974(k: nat, y: nat)\n requires y > 0\n ensures 0 <= k % y < y\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_12975","instance":12975,"id":182974,"goal":"lemma Square_Nonneg_12975(x: real)\n ensures x * x >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_12976","instance":12976,"id":182975,"goal":"lemma AddComm_12976(i: int, k: int)\n ensures i + k == k + i\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_12977","instance":12977,"id":182976,"goal":"lemma AddAssoc_12977(i: nat, n: nat, z: nat)\n ensures (i + n) + z == i + (n + z)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_12978","instance":12978,"id":182977,"goal":"lemma MulComm_12978(y: real, i: real)\n ensures y * i == i * y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_12979","instance":12979,"id":182978,"goal":"lemma MulAssoc_12979(y: int, c: int, b: int)\n ensures (y * c) * b == y * (c * b)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_12980","instance":12980,"id":182979,"goal":"lemma Distrib_12980(a: nat, b: nat, k: nat)\n ensures a * (b + k) == a * b + a * k\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_12981","instance":12981,"id":182980,"goal":"lemma AddZero_12981(n: real)\n ensures n + 0 == n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_12982","instance":12982,"id":182981,"goal":"lemma MulOne_12982(m: int)\n ensures m * 1 == m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_12983","instance":12983,"id":182982,"goal":"lemma MulZero_12983(c: nat)\n ensures c * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_12984","instance":12984,"id":182983,"goal":"lemma LeRefl_12984(d: real)\n ensures d <= d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_12985","instance":12985,"id":182984,"goal":"lemma LeTrans_12985(a: int, n: int, b: int)\n requires a <= n && n <= b\n ensures a <= b\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_12986","instance":12986,"id":182985,"goal":"lemma AddMono_12986(k: nat, m: nat, a: nat)\n requires k <= m\n ensures k + a <= m + a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_12987","instance":12987,"id":182986,"goal":"lemma Abs_Nonneg_12987(y: real)\n ensures (if y >= 0 then y else -y) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_12988","instance":12988,"id":182987,"goal":"lemma DivMod_12988(a: int, m: int)\n requires m > 0\n ensures a == m * (a / m) + (a % m)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_12989","instance":12989,"id":182988,"goal":"lemma ModBounds_12989(a: nat, y: nat)\n requires y > 0\n ensures 0 <= a % y < y\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_12990","instance":12990,"id":182989,"goal":"lemma Square_Nonneg_12990(x: real)\n ensures x * x >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_12991","instance":12991,"id":182990,"goal":"lemma AddComm_12991(d: int, a: int)\n ensures d + a == a + d\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_12992","instance":12992,"id":182991,"goal":"lemma AddAssoc_12992(y: nat, d: nat, k: nat)\n ensures (y + d) + k == y + (d + k)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_12993","instance":12993,"id":182992,"goal":"lemma MulComm_12993(d: real, m: real)\n ensures d * m == m * d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_12994","instance":12994,"id":182993,"goal":"lemma MulAssoc_12994(k: int, d: int, i: int)\n ensures (k * d) * i == k * (d * i)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_12995","instance":12995,"id":182994,"goal":"lemma Distrib_12995(m: nat, b: nat, i: nat)\n ensures m * (b + i) == m * b + m * i\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_12996","instance":12996,"id":182995,"goal":"lemma AddZero_12996(j: real)\n ensures j + 0 == j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_12997","instance":12997,"id":182996,"goal":"lemma MulOne_12997(m: int)\n ensures m * 1 == m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_12998","instance":12998,"id":182997,"goal":"lemma MulZero_12998(i: nat)\n ensures i * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_12999","instance":12999,"id":182998,"goal":"lemma LeRefl_12999(c: real)\n ensures c <= c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_13000","instance":13000,"id":182999,"goal":"lemma LeTrans_13000(n: int, a: int, z: int)\n requires n <= a && a <= z\n ensures n <= z\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_13001","instance":13001,"id":183000,"goal":"lemma AddMono_13001(b: nat, c: nat, z: nat)\n requires b <= c\n ensures b + z <= c + z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_13002","instance":13002,"id":183001,"goal":"lemma Abs_Nonneg_13002(y: real)\n ensures (if y >= 0 then y else -y) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_13003","instance":13003,"id":183002,"goal":"lemma DivMod_13003(n: int, a: int)\n requires a > 0\n ensures n == a * (n / a) + (n % a)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_13004","instance":13004,"id":183003,"goal":"lemma ModBounds_13004(i: nat, b: nat)\n requires b > 0\n ensures 0 <= i % b < b\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_13005","instance":13005,"id":183004,"goal":"lemma Square_Nonneg_13005(m: real)\n ensures m * m >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_13006","instance":13006,"id":183005,"goal":"lemma AddComm_13006(x: int, d: int)\n ensures x + d == d + x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_13007","instance":13007,"id":183006,"goal":"lemma AddAssoc_13007(a: nat, d: nat, c: nat)\n ensures (a + d) + c == a + (d + c)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_13008","instance":13008,"id":183007,"goal":"lemma MulComm_13008(c: real, a: real)\n ensures c * a == a * c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_13009","instance":13009,"id":183008,"goal":"lemma MulAssoc_13009(j: int, x: int, c: int)\n ensures (j * x) * c == j * (x * c)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_13010","instance":13010,"id":183009,"goal":"lemma Distrib_13010(d: nat, z: nat, b: nat)\n ensures d * (z + b) == d * z + d * b\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_13011","instance":13011,"id":183010,"goal":"lemma AddZero_13011(a: real)\n ensures a + 0 == a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_13012","instance":13012,"id":183011,"goal":"lemma MulOne_13012(d: int)\n ensures d * 1 == d\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_13013","instance":13013,"id":183012,"goal":"lemma MulZero_13013(c: nat)\n ensures c * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_13014","instance":13014,"id":183013,"goal":"lemma LeRefl_13014(x: real)\n ensures x <= x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_13015","instance":13015,"id":183014,"goal":"lemma LeTrans_13015(y: int, j: int, n: int)\n requires y <= j && j <= n\n ensures y <= n\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_13016","instance":13016,"id":183015,"goal":"lemma AddMono_13016(j: nat, m: nat, k: nat)\n requires j <= m\n ensures j + k <= m + k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_13017","instance":13017,"id":183016,"goal":"lemma Abs_Nonneg_13017(c: real)\n ensures (if c >= 0 then c else -c) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_13018","instance":13018,"id":183017,"goal":"lemma DivMod_13018(i: int, k: int)\n requires k > 0\n ensures i == k * (i / k) + (i % k)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_13019","instance":13019,"id":183018,"goal":"lemma ModBounds_13019(k: nat, x: nat)\n requires x > 0\n ensures 0 <= k % x < x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_13020","instance":13020,"id":183019,"goal":"lemma Square_Nonneg_13020(c: real)\n ensures c * c >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_13021","instance":13021,"id":183020,"goal":"lemma AddComm_13021(k: int, d: int)\n ensures k + d == d + k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_13022","instance":13022,"id":183021,"goal":"lemma AddAssoc_13022(b: nat, i: nat, z: nat)\n ensures (b + i) + z == b + (i + z)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_13023","instance":13023,"id":183022,"goal":"lemma MulComm_13023(m: real, d: real)\n ensures m * d == d * m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_13024","instance":13024,"id":183023,"goal":"lemma MulAssoc_13024(b: int, z: int, c: int)\n ensures (b * z) * c == b * (z * c)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_13025","instance":13025,"id":183024,"goal":"lemma Distrib_13025(c: nat, m: nat, y: nat)\n ensures c * (m + y) == c * m + c * y\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_13026","instance":13026,"id":183025,"goal":"lemma AddZero_13026(b: real)\n ensures b + 0 == b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_13027","instance":13027,"id":183026,"goal":"lemma MulOne_13027(m: int)\n ensures m * 1 == m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_13028","instance":13028,"id":183027,"goal":"lemma MulZero_13028(a: nat)\n ensures a * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_13029","instance":13029,"id":183028,"goal":"lemma LeRefl_13029(j: real)\n ensures j <= j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_13030","instance":13030,"id":183029,"goal":"lemma LeTrans_13030(j: int, x: int, y: int)\n requires j <= x && x <= y\n ensures j <= y\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_13031","instance":13031,"id":183030,"goal":"lemma AddMono_13031(d: nat, b: nat, k: nat)\n requires d <= b\n ensures d + k <= b + k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_13032","instance":13032,"id":183031,"goal":"lemma Abs_Nonneg_13032(k: real)\n ensures (if k >= 0 then k else -k) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_13033","instance":13033,"id":183032,"goal":"lemma DivMod_13033(m: int, i: int)\n requires i > 0\n ensures m == i * (m / i) + (m % i)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_13034","instance":13034,"id":183033,"goal":"lemma ModBounds_13034(x: nat, k: nat)\n requires k > 0\n ensures 0 <= x % k < k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_13035","instance":13035,"id":183034,"goal":"lemma Square_Nonneg_13035(j: real)\n ensures j * j >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_13036","instance":13036,"id":183035,"goal":"lemma AddComm_13036(x: int, k: int)\n ensures x + k == k + x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_13037","instance":13037,"id":183036,"goal":"lemma AddAssoc_13037(b: nat, n: nat, j: nat)\n ensures (b + n) + j == b + (n + j)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_13038","instance":13038,"id":183037,"goal":"lemma MulComm_13038(j: real, d: real)\n ensures j * d == d * j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_13039","instance":13039,"id":183038,"goal":"lemma MulAssoc_13039(a: int, d: int, c: int)\n ensures (a * d) * c == a * (d * c)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_13040","instance":13040,"id":183039,"goal":"lemma Distrib_13040(b: nat, y: nat, d: nat)\n ensures b * (y + d) == b * y + b * d\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_13041","instance":13041,"id":183040,"goal":"lemma AddZero_13041(b: real)\n ensures b + 0 == b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_13042","instance":13042,"id":183041,"goal":"lemma MulOne_13042(j: int)\n ensures j * 1 == j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_13043","instance":13043,"id":183042,"goal":"lemma MulZero_13043(b: nat)\n ensures b * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_13044","instance":13044,"id":183043,"goal":"lemma LeRefl_13044(b: real)\n ensures b <= b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_13045","instance":13045,"id":183044,"goal":"lemma LeTrans_13045(z: int, x: int, b: int)\n requires z <= x && x <= b\n ensures z <= b\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_13046","instance":13046,"id":183045,"goal":"lemma AddMono_13046(n: nat, k: nat, z: nat)\n requires n <= k\n ensures n + z <= k + z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_13047","instance":13047,"id":183046,"goal":"lemma Abs_Nonneg_13047(n: real)\n ensures (if n >= 0 then n else -n) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_13048","instance":13048,"id":183047,"goal":"lemma DivMod_13048(j: int, a: int)\n requires a > 0\n ensures j == a * (j / a) + (j % a)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_13049","instance":13049,"id":183048,"goal":"lemma ModBounds_13049(z: nat, j: nat)\n requires j > 0\n ensures 0 <= z % j < j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_13050","instance":13050,"id":183049,"goal":"lemma Square_Nonneg_13050(y: real)\n ensures y * y >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_13051","instance":13051,"id":183050,"goal":"lemma AddComm_13051(z: int, m: int)\n ensures z + m == m + z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_13052","instance":13052,"id":183051,"goal":"lemma AddAssoc_13052(a: nat, y: nat, x: nat)\n ensures (a + y) + x == a + (y + x)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_13053","instance":13053,"id":183052,"goal":"lemma MulComm_13053(m: real, j: real)\n ensures m * j == j * m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_13054","instance":13054,"id":183053,"goal":"lemma MulAssoc_13054(x: int, b: int, d: int)\n ensures (x * b) * d == x * (b * d)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_13055","instance":13055,"id":183054,"goal":"lemma Distrib_13055(k: nat, j: nat, a: nat)\n ensures k * (j + a) == k * j + k * a\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_13056","instance":13056,"id":183055,"goal":"lemma AddZero_13056(d: real)\n ensures d + 0 == d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_13057","instance":13057,"id":183056,"goal":"lemma MulOne_13057(m: int)\n ensures m * 1 == m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_13058","instance":13058,"id":183057,"goal":"lemma MulZero_13058(m: nat)\n ensures m * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_13059","instance":13059,"id":183058,"goal":"lemma LeRefl_13059(c: real)\n ensures c <= c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_13060","instance":13060,"id":183059,"goal":"lemma LeTrans_13060(b: int, c: int, x: int)\n requires b <= c && c <= x\n ensures b <= x\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_13061","instance":13061,"id":183060,"goal":"lemma AddMono_13061(j: nat, c: nat, z: nat)\n requires j <= c\n ensures j + z <= c + z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_13062","instance":13062,"id":183061,"goal":"lemma Abs_Nonneg_13062(z: real)\n ensures (if z >= 0 then z else -z) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_13063","instance":13063,"id":183062,"goal":"lemma DivMod_13063(c: int, d: int)\n requires d > 0\n ensures c == d * (c / d) + (c % d)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_13064","instance":13064,"id":183063,"goal":"lemma ModBounds_13064(y: nat, d: nat)\n requires d > 0\n ensures 0 <= y % d < d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_13065","instance":13065,"id":183064,"goal":"lemma Square_Nonneg_13065(n: real)\n ensures n * n >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_13066","instance":13066,"id":183065,"goal":"lemma AddComm_13066(z: int, c: int)\n ensures z + c == c + z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_13067","instance":13067,"id":183066,"goal":"lemma AddAssoc_13067(k: nat, n: nat, z: nat)\n ensures (k + n) + z == k + (n + z)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_13068","instance":13068,"id":183067,"goal":"lemma MulComm_13068(n: real, a: real)\n ensures n * a == a * n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_13069","instance":13069,"id":183068,"goal":"lemma MulAssoc_13069(c: int, z: int, i: int)\n ensures (c * z) * i == c * (z * i)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_13070","instance":13070,"id":183069,"goal":"lemma Distrib_13070(a: nat, i: nat, j: nat)\n ensures a * (i + j) == a * i + a * j\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_13071","instance":13071,"id":183070,"goal":"lemma AddZero_13071(y: real)\n ensures y + 0 == y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_13072","instance":13072,"id":183071,"goal":"lemma MulOne_13072(z: int)\n ensures z * 1 == z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_13073","instance":13073,"id":183072,"goal":"lemma MulZero_13073(y: nat)\n ensures y * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_13074","instance":13074,"id":183073,"goal":"lemma LeRefl_13074(z: real)\n ensures z <= z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_13075","instance":13075,"id":183074,"goal":"lemma LeTrans_13075(b: int, k: int, x: int)\n requires b <= k && k <= x\n ensures b <= x\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_13076","instance":13076,"id":183075,"goal":"lemma AddMono_13076(d: nat, z: nat, b: nat)\n requires d <= z\n ensures d + b <= z + b\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_13077","instance":13077,"id":183076,"goal":"lemma Abs_Nonneg_13077(c: real)\n ensures (if c >= 0 then c else -c) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_13078","instance":13078,"id":183077,"goal":"lemma DivMod_13078(x: int, i: int)\n requires i > 0\n ensures x == i * (x / i) + (x % i)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_13079","instance":13079,"id":183078,"goal":"lemma ModBounds_13079(a: nat, d: nat)\n requires d > 0\n ensures 0 <= a % d < d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_13080","instance":13080,"id":183079,"goal":"lemma Square_Nonneg_13080(c: real)\n ensures c * c >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_13081","instance":13081,"id":183080,"goal":"lemma AddComm_13081(a: int, m: int)\n ensures a + m == m + a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_13082","instance":13082,"id":183081,"goal":"lemma AddAssoc_13082(k: nat, j: nat, b: nat)\n ensures (k + j) + b == k + (j + b)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_13083","instance":13083,"id":183082,"goal":"lemma MulComm_13083(x: real, b: real)\n ensures x * b == b * x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_13084","instance":13084,"id":183083,"goal":"lemma MulAssoc_13084(n: int, z: int, y: int)\n ensures (n * z) * y == n * (z * y)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_13085","instance":13085,"id":183084,"goal":"lemma Distrib_13085(n: nat, b: nat, z: nat)\n ensures n * (b + z) == n * b + n * z\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_13086","instance":13086,"id":183085,"goal":"lemma AddZero_13086(c: real)\n ensures c + 0 == c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_13087","instance":13087,"id":183086,"goal":"lemma MulOne_13087(d: int)\n ensures d * 1 == d\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_13088","instance":13088,"id":183087,"goal":"lemma MulZero_13088(x: nat)\n ensures x * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_13089","instance":13089,"id":183088,"goal":"lemma LeRefl_13089(z: real)\n ensures z <= z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_13090","instance":13090,"id":183089,"goal":"lemma LeTrans_13090(b: int, d: int, j: int)\n requires b <= d && d <= j\n ensures b <= j\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_13091","instance":13091,"id":183090,"goal":"lemma AddMono_13091(c: nat, k: nat, i: nat)\n requires c <= k\n ensures c + i <= k + i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_13092","instance":13092,"id":183091,"goal":"lemma Abs_Nonneg_13092(k: real)\n ensures (if k >= 0 then k else -k) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_13093","instance":13093,"id":183092,"goal":"lemma DivMod_13093(i: int, m: int)\n requires m > 0\n ensures i == m * (i / m) + (i % m)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_13094","instance":13094,"id":183093,"goal":"lemma ModBounds_13094(k: nat, d: nat)\n requires d > 0\n ensures 0 <= k % d < d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_13095","instance":13095,"id":183094,"goal":"lemma Square_Nonneg_13095(x: real)\n ensures x * x >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_13096","instance":13096,"id":183095,"goal":"lemma AddComm_13096(c: int, n: int)\n ensures c + n == n + c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_13097","instance":13097,"id":183096,"goal":"lemma AddAssoc_13097(m: nat, y: nat, z: nat)\n ensures (m + y) + z == m + (y + z)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_13098","instance":13098,"id":183097,"goal":"lemma MulComm_13098(y: real, z: real)\n ensures y * z == z * y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_13099","instance":13099,"id":183098,"goal":"lemma MulAssoc_13099(x: int, b: int, y: int)\n ensures (x * b) * y == x * (b * y)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_13100","instance":13100,"id":183099,"goal":"lemma Distrib_13100(j: nat, c: nat, y: nat)\n ensures j * (c + y) == j * c + j * y\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_13101","instance":13101,"id":183100,"goal":"lemma AddZero_13101(z: real)\n ensures z + 0 == z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_13102","instance":13102,"id":183101,"goal":"lemma MulOne_13102(d: int)\n ensures d * 1 == d\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_13103","instance":13103,"id":183102,"goal":"lemma MulZero_13103(b: nat)\n ensures b * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_13104","instance":13104,"id":183103,"goal":"lemma LeRefl_13104(c: real)\n ensures c <= c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_13105","instance":13105,"id":183104,"goal":"lemma LeTrans_13105(y: int, c: int, a: int)\n requires y <= c && c <= a\n ensures y <= a\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_13106","instance":13106,"id":183105,"goal":"lemma AddMono_13106(z: nat, b: nat, d: nat)\n requires z <= b\n ensures z + d <= b + d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_13107","instance":13107,"id":183106,"goal":"lemma Abs_Nonneg_13107(c: real)\n ensures (if c >= 0 then c else -c) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_13108","instance":13108,"id":183107,"goal":"lemma DivMod_13108(x: int, i: int)\n requires i > 0\n ensures x == i * (x / i) + (x % i)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_13109","instance":13109,"id":183108,"goal":"lemma ModBounds_13109(d: nat, x: nat)\n requires x > 0\n ensures 0 <= d % x < x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_13110","instance":13110,"id":183109,"goal":"lemma Square_Nonneg_13110(a: real)\n ensures a * a >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_13111","instance":13111,"id":183110,"goal":"lemma AddComm_13111(j: int, n: int)\n ensures j + n == n + j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_13112","instance":13112,"id":183111,"goal":"lemma AddAssoc_13112(x: nat, c: nat, y: nat)\n ensures (x + c) + y == x + (c + y)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_13113","instance":13113,"id":183112,"goal":"lemma MulComm_13113(y: real, k: real)\n ensures y * k == k * y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_13114","instance":13114,"id":183113,"goal":"lemma MulAssoc_13114(b: int, m: int, c: int)\n ensures (b * m) * c == b * (m * c)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_13115","instance":13115,"id":183114,"goal":"lemma Distrib_13115(k: nat, j: nat, c: nat)\n ensures k * (j + c) == k * j + k * c\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_13116","instance":13116,"id":183115,"goal":"lemma AddZero_13116(m: real)\n ensures m + 0 == m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_13117","instance":13117,"id":183116,"goal":"lemma MulOne_13117(y: int)\n ensures y * 1 == y\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_13118","instance":13118,"id":183117,"goal":"lemma MulZero_13118(d: nat)\n ensures d * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_13119","instance":13119,"id":183118,"goal":"lemma LeRefl_13119(j: real)\n ensures j <= j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_13120","instance":13120,"id":183119,"goal":"lemma LeTrans_13120(d: int, n: int, i: int)\n requires d <= n && n <= i\n ensures d <= i\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_13121","instance":13121,"id":183120,"goal":"lemma AddMono_13121(z: nat, n: nat, y: nat)\n requires z <= n\n ensures z + y <= n + y\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_13122","instance":13122,"id":183121,"goal":"lemma Abs_Nonneg_13122(n: real)\n ensures (if n >= 0 then n else -n) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_13123","instance":13123,"id":183122,"goal":"lemma DivMod_13123(i: int, n: int)\n requires n > 0\n ensures i == n * (i / n) + (i % n)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_13124","instance":13124,"id":183123,"goal":"lemma ModBounds_13124(n: nat, x: nat)\n requires x > 0\n ensures 0 <= n % x < x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_13125","instance":13125,"id":183124,"goal":"lemma Square_Nonneg_13125(c: real)\n ensures c * c >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_13126","instance":13126,"id":183125,"goal":"lemma AddComm_13126(m: int, x: int)\n ensures m + x == x + m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_13127","instance":13127,"id":183126,"goal":"lemma AddAssoc_13127(i: nat, m: nat, k: nat)\n ensures (i + m) + k == i + (m + k)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_13128","instance":13128,"id":183127,"goal":"lemma MulComm_13128(d: real, i: real)\n ensures d * i == i * d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_13129","instance":13129,"id":183128,"goal":"lemma MulAssoc_13129(a: int, m: int, n: int)\n ensures (a * m) * n == a * (m * n)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_13130","instance":13130,"id":183129,"goal":"lemma Distrib_13130(k: nat, i: nat, x: nat)\n ensures k * (i + x) == k * i + k * x\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_13131","instance":13131,"id":183130,"goal":"lemma AddZero_13131(b: real)\n ensures b + 0 == b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_13132","instance":13132,"id":183131,"goal":"lemma MulOne_13132(i: int)\n ensures i * 1 == i\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_13133","instance":13133,"id":183132,"goal":"lemma MulZero_13133(z: nat)\n ensures z * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_13134","instance":13134,"id":183133,"goal":"lemma LeRefl_13134(z: real)\n ensures z <= z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_13135","instance":13135,"id":183134,"goal":"lemma LeTrans_13135(d: int, z: int, b: int)\n requires d <= z && z <= b\n ensures d <= b\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_13136","instance":13136,"id":183135,"goal":"lemma AddMono_13136(b: nat, j: nat, d: nat)\n requires b <= j\n ensures b + d <= j + d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_13137","instance":13137,"id":183136,"goal":"lemma Abs_Nonneg_13137(n: real)\n ensures (if n >= 0 then n else -n) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_13138","instance":13138,"id":183137,"goal":"lemma DivMod_13138(k: int, m: int)\n requires m > 0\n ensures k == m * (k / m) + (k % m)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_13139","instance":13139,"id":183138,"goal":"lemma ModBounds_13139(n: nat, a: nat)\n requires a > 0\n ensures 0 <= n % a < a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_13140","instance":13140,"id":183139,"goal":"lemma Square_Nonneg_13140(c: real)\n ensures c * c >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_13141","instance":13141,"id":183140,"goal":"lemma AddComm_13141(a: int, d: int)\n ensures a + d == d + a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_13142","instance":13142,"id":183141,"goal":"lemma AddAssoc_13142(x: nat, k: nat, d: nat)\n ensures (x + k) + d == x + (k + d)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_13143","instance":13143,"id":183142,"goal":"lemma MulComm_13143(c: real, i: real)\n ensures c * i == i * c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_13144","instance":13144,"id":183143,"goal":"lemma MulAssoc_13144(a: int, d: int, b: int)\n ensures (a * d) * b == a * (d * b)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_13145","instance":13145,"id":183144,"goal":"lemma Distrib_13145(n: nat, a: nat, m: nat)\n ensures n * (a + m) == n * a + n * m\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_13146","instance":13146,"id":183145,"goal":"lemma AddZero_13146(x: real)\n ensures x + 0 == x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_13147","instance":13147,"id":183146,"goal":"lemma MulOne_13147(n: int)\n ensures n * 1 == n\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_13148","instance":13148,"id":183147,"goal":"lemma MulZero_13148(i: nat)\n ensures i * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_13149","instance":13149,"id":183148,"goal":"lemma LeRefl_13149(n: real)\n ensures n <= n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_13150","instance":13150,"id":183149,"goal":"lemma LeTrans_13150(x: int, z: int, b: int)\n requires x <= z && z <= b\n ensures x <= b\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_13151","instance":13151,"id":183150,"goal":"lemma AddMono_13151(z: nat, b: nat, c: nat)\n requires z <= b\n ensures z + c <= b + c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_13152","instance":13152,"id":183151,"goal":"lemma Abs_Nonneg_13152(z: real)\n ensures (if z >= 0 then z else -z) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_13153","instance":13153,"id":183152,"goal":"lemma DivMod_13153(i: int, y: int)\n requires y > 0\n ensures i == y * (i / y) + (i % y)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_13154","instance":13154,"id":183153,"goal":"lemma ModBounds_13154(j: nat, n: nat)\n requires n > 0\n ensures 0 <= j % n < n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_13155","instance":13155,"id":183154,"goal":"lemma Square_Nonneg_13155(x: real)\n ensures x * x >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_13156","instance":13156,"id":183155,"goal":"lemma AddComm_13156(n: int, i: int)\n ensures n + i == i + n\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_13157","instance":13157,"id":183156,"goal":"lemma AddAssoc_13157(y: nat, d: nat, x: nat)\n ensures (y + d) + x == y + (d + x)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_13158","instance":13158,"id":183157,"goal":"lemma MulComm_13158(x: real, y: real)\n ensures x * y == y * x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_13159","instance":13159,"id":183158,"goal":"lemma MulAssoc_13159(a: int, j: int, i: int)\n ensures (a * j) * i == a * (j * i)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_13160","instance":13160,"id":183159,"goal":"lemma Distrib_13160(y: nat, z: nat, k: nat)\n ensures y * (z + k) == y * z + y * k\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_13161","instance":13161,"id":183160,"goal":"lemma AddZero_13161(z: real)\n ensures z + 0 == z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_13162","instance":13162,"id":183161,"goal":"lemma MulOne_13162(j: int)\n ensures j * 1 == j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_13163","instance":13163,"id":183162,"goal":"lemma MulZero_13163(n: nat)\n ensures n * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_13164","instance":13164,"id":183163,"goal":"lemma LeRefl_13164(a: real)\n ensures a <= a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_13165","instance":13165,"id":183164,"goal":"lemma LeTrans_13165(b: int, n: int, x: int)\n requires b <= n && n <= x\n ensures b <= x\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_13166","instance":13166,"id":183165,"goal":"lemma AddMono_13166(y: nat, j: nat, d: nat)\n requires y <= j\n ensures y + d <= j + d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_13167","instance":13167,"id":183166,"goal":"lemma Abs_Nonneg_13167(c: real)\n ensures (if c >= 0 then c else -c) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_13168","instance":13168,"id":183167,"goal":"lemma DivMod_13168(b: int, d: int)\n requires d > 0\n ensures b == d * (b / d) + (b % d)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_13169","instance":13169,"id":183168,"goal":"lemma ModBounds_13169(c: nat, z: nat)\n requires z > 0\n ensures 0 <= c % z < z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_13170","instance":13170,"id":183169,"goal":"lemma Square_Nonneg_13170(d: real)\n ensures d * d >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_13171","instance":13171,"id":183170,"goal":"lemma AddComm_13171(k: int, c: int)\n ensures k + c == c + k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_13172","instance":13172,"id":183171,"goal":"lemma AddAssoc_13172(a: nat, i: nat, k: nat)\n ensures (a + i) + k == a + (i + k)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_13173","instance":13173,"id":183172,"goal":"lemma MulComm_13173(k: real, n: real)\n ensures k * n == n * k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_13174","instance":13174,"id":183173,"goal":"lemma MulAssoc_13174(z: int, m: int, i: int)\n ensures (z * m) * i == z * (m * i)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_13175","instance":13175,"id":183174,"goal":"lemma Distrib_13175(d: nat, n: nat, y: nat)\n ensures d * (n + y) == d * n + d * y\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_13176","instance":13176,"id":183175,"goal":"lemma AddZero_13176(y: real)\n ensures y + 0 == y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_13177","instance":13177,"id":183176,"goal":"lemma MulOne_13177(m: int)\n ensures m * 1 == m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_13178","instance":13178,"id":183177,"goal":"lemma MulZero_13178(b: nat)\n ensures b * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_13179","instance":13179,"id":183178,"goal":"lemma LeRefl_13179(z: real)\n ensures z <= z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_13180","instance":13180,"id":183179,"goal":"lemma LeTrans_13180(b: int, m: int, c: int)\n requires b <= m && m <= c\n ensures b <= c\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_13181","instance":13181,"id":183180,"goal":"lemma AddMono_13181(k: nat, j: nat, z: nat)\n requires k <= j\n ensures k + z <= j + z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_13182","instance":13182,"id":183181,"goal":"lemma Abs_Nonneg_13182(d: real)\n ensures (if d >= 0 then d else -d) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_13183","instance":13183,"id":183182,"goal":"lemma DivMod_13183(n: int, i: int)\n requires i > 0\n ensures n == i * (n / i) + (n % i)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_13184","instance":13184,"id":183183,"goal":"lemma ModBounds_13184(z: nat, k: nat)\n requires k > 0\n ensures 0 <= z % k < k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_13185","instance":13185,"id":183184,"goal":"lemma Square_Nonneg_13185(m: real)\n ensures m * m >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_13186","instance":13186,"id":183185,"goal":"lemma AddComm_13186(b: int, z: int)\n ensures b + z == z + b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_13187","instance":13187,"id":183186,"goal":"lemma AddAssoc_13187(c: nat, n: nat, y: nat)\n ensures (c + n) + y == c + (n + y)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_13188","instance":13188,"id":183187,"goal":"lemma MulComm_13188(k: real, j: real)\n ensures k * j == j * k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_13189","instance":13189,"id":183188,"goal":"lemma MulAssoc_13189(n: int, a: int, c: int)\n ensures (n * a) * c == n * (a * c)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_13190","instance":13190,"id":183189,"goal":"lemma Distrib_13190(b: nat, x: nat, c: nat)\n ensures b * (x + c) == b * x + b * c\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_13191","instance":13191,"id":183190,"goal":"lemma AddZero_13191(c: real)\n ensures c + 0 == c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_13192","instance":13192,"id":183191,"goal":"lemma MulOne_13192(a: int)\n ensures a * 1 == a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_13193","instance":13193,"id":183192,"goal":"lemma MulZero_13193(a: nat)\n ensures a * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_13194","instance":13194,"id":183193,"goal":"lemma LeRefl_13194(k: real)\n ensures k <= k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_13195","instance":13195,"id":183194,"goal":"lemma LeTrans_13195(y: int, n: int, x: int)\n requires y <= n && n <= x\n ensures y <= x\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_13196","instance":13196,"id":183195,"goal":"lemma AddMono_13196(j: nat, a: nat, k: nat)\n requires j <= a\n ensures j + k <= a + k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_13197","instance":13197,"id":183196,"goal":"lemma Abs_Nonneg_13197(k: real)\n ensures (if k >= 0 then k else -k) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_13198","instance":13198,"id":183197,"goal":"lemma DivMod_13198(k: int, n: int)\n requires n > 0\n ensures k == n * (k / n) + (k % n)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_13199","instance":13199,"id":183198,"goal":"lemma ModBounds_13199(x: nat, j: nat)\n requires j > 0\n ensures 0 <= x % j < j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_13200","instance":13200,"id":183199,"goal":"lemma Square_Nonneg_13200(i: real)\n ensures i * i >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_13201","instance":13201,"id":183200,"goal":"lemma AddComm_13201(z: int, a: int)\n ensures z + a == a + z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_13202","instance":13202,"id":183201,"goal":"lemma AddAssoc_13202(z: nat, x: nat, m: nat)\n ensures (z + x) + m == z + (x + m)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_13203","instance":13203,"id":183202,"goal":"lemma MulComm_13203(y: real, m: real)\n ensures y * m == m * y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_13204","instance":13204,"id":183203,"goal":"lemma MulAssoc_13204(m: int, a: int, d: int)\n ensures (m * a) * d == m * (a * d)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_13205","instance":13205,"id":183204,"goal":"lemma Distrib_13205(y: nat, x: nat, k: nat)\n ensures y * (x + k) == y * x + y * k\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_13206","instance":13206,"id":183205,"goal":"lemma AddZero_13206(x: real)\n ensures x + 0 == x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_13207","instance":13207,"id":183206,"goal":"lemma MulOne_13207(z: int)\n ensures z * 1 == z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_13208","instance":13208,"id":183207,"goal":"lemma MulZero_13208(j: nat)\n ensures j * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_13209","instance":13209,"id":183208,"goal":"lemma LeRefl_13209(z: real)\n ensures z <= z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_13210","instance":13210,"id":183209,"goal":"lemma LeTrans_13210(d: int, y: int, j: int)\n requires d <= y && y <= j\n ensures d <= j\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_13211","instance":13211,"id":183210,"goal":"lemma AddMono_13211(a: nat, j: nat, n: nat)\n requires a <= j\n ensures a + n <= j + n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_13212","instance":13212,"id":183211,"goal":"lemma Abs_Nonneg_13212(z: real)\n ensures (if z >= 0 then z else -z) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_13213","instance":13213,"id":183212,"goal":"lemma DivMod_13213(k: int, y: int)\n requires y > 0\n ensures k == y * (k / y) + (k % y)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_13214","instance":13214,"id":183213,"goal":"lemma ModBounds_13214(j: nat, c: nat)\n requires c > 0\n ensures 0 <= j % c < c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_13215","instance":13215,"id":183214,"goal":"lemma Square_Nonneg_13215(j: real)\n ensures j * j >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_13216","instance":13216,"id":183215,"goal":"lemma AddComm_13216(k: int, d: int)\n ensures k + d == d + k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_13217","instance":13217,"id":183216,"goal":"lemma AddAssoc_13217(b: nat, j: nat, n: nat)\n ensures (b + j) + n == b + (j + n)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_13218","instance":13218,"id":183217,"goal":"lemma MulComm_13218(d: real, n: real)\n ensures d * n == n * d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_13219","instance":13219,"id":183218,"goal":"lemma MulAssoc_13219(z: int, m: int, a: int)\n ensures (z * m) * a == z * (m * a)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_13220","instance":13220,"id":183219,"goal":"lemma Distrib_13220(n: nat, k: nat, i: nat)\n ensures n * (k + i) == n * k + n * i\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_13221","instance":13221,"id":183220,"goal":"lemma AddZero_13221(j: real)\n ensures j + 0 == j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_13222","instance":13222,"id":183221,"goal":"lemma MulOne_13222(n: int)\n ensures n * 1 == n\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_13223","instance":13223,"id":183222,"goal":"lemma MulZero_13223(y: nat)\n ensures y * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_13224","instance":13224,"id":183223,"goal":"lemma LeRefl_13224(z: real)\n ensures z <= z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_13225","instance":13225,"id":183224,"goal":"lemma LeTrans_13225(a: int, c: int, z: int)\n requires a <= c && c <= z\n ensures a <= z\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_13226","instance":13226,"id":183225,"goal":"lemma AddMono_13226(k: nat, y: nat, c: nat)\n requires k <= y\n ensures k + c <= y + c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_13227","instance":13227,"id":183226,"goal":"lemma Abs_Nonneg_13227(z: real)\n ensures (if z >= 0 then z else -z) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_13228","instance":13228,"id":183227,"goal":"lemma DivMod_13228(m: int, z: int)\n requires z > 0\n ensures m == z * (m / z) + (m % z)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_13229","instance":13229,"id":183228,"goal":"lemma ModBounds_13229(d: nat, i: nat)\n requires i > 0\n ensures 0 <= d % i < i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_13230","instance":13230,"id":183229,"goal":"lemma Square_Nonneg_13230(b: real)\n ensures b * b >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_13231","instance":13231,"id":183230,"goal":"lemma AddComm_13231(c: int, k: int)\n ensures c + k == k + c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_13232","instance":13232,"id":183231,"goal":"lemma AddAssoc_13232(j: nat, d: nat, i: nat)\n ensures (j + d) + i == j + (d + i)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_13233","instance":13233,"id":183232,"goal":"lemma MulComm_13233(c: real, n: real)\n ensures c * n == n * c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_13234","instance":13234,"id":183233,"goal":"lemma MulAssoc_13234(c: int, b: int, x: int)\n ensures (c * b) * x == c * (b * x)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_13235","instance":13235,"id":183234,"goal":"lemma Distrib_13235(z: nat, m: nat, c: nat)\n ensures z * (m + c) == z * m + z * c\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_13236","instance":13236,"id":183235,"goal":"lemma AddZero_13236(z: real)\n ensures z + 0 == z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_13237","instance":13237,"id":183236,"goal":"lemma MulOne_13237(i: int)\n ensures i * 1 == i\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_13238","instance":13238,"id":183237,"goal":"lemma MulZero_13238(d: nat)\n ensures d * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_13239","instance":13239,"id":183238,"goal":"lemma LeRefl_13239(x: real)\n ensures x <= x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_13240","instance":13240,"id":183239,"goal":"lemma LeTrans_13240(a: int, d: int, m: int)\n requires a <= d && d <= m\n ensures a <= m\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_13241","instance":13241,"id":183240,"goal":"lemma AddMono_13241(j: nat, a: nat, c: nat)\n requires j <= a\n ensures j + c <= a + c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_13242","instance":13242,"id":183241,"goal":"lemma Abs_Nonneg_13242(n: real)\n ensures (if n >= 0 then n else -n) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_13243","instance":13243,"id":183242,"goal":"lemma DivMod_13243(b: int, x: int)\n requires x > 0\n ensures b == x * (b / x) + (b % x)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_13244","instance":13244,"id":183243,"goal":"lemma ModBounds_13244(c: nat, b: nat)\n requires b > 0\n ensures 0 <= c % b < b\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_13245","instance":13245,"id":183244,"goal":"lemma Square_Nonneg_13245(j: real)\n ensures j * j >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_13246","instance":13246,"id":183245,"goal":"lemma AddComm_13246(z: int, b: int)\n ensures z + b == b + z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_13247","instance":13247,"id":183246,"goal":"lemma AddAssoc_13247(k: nat, m: nat, d: nat)\n ensures (k + m) + d == k + (m + d)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_13248","instance":13248,"id":183247,"goal":"lemma MulComm_13248(j: real, i: real)\n ensures j * i == i * j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_13249","instance":13249,"id":183248,"goal":"lemma MulAssoc_13249(z: int, b: int, c: int)\n ensures (z * b) * c == z * (b * c)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_13250","instance":13250,"id":183249,"goal":"lemma Distrib_13250(c: nat, z: nat, j: nat)\n ensures c * (z + j) == c * z + c * j\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_13251","instance":13251,"id":183250,"goal":"lemma AddZero_13251(z: real)\n ensures z + 0 == z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_13252","instance":13252,"id":183251,"goal":"lemma MulOne_13252(y: int)\n ensures y * 1 == y\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_13253","instance":13253,"id":183252,"goal":"lemma MulZero_13253(a: nat)\n ensures a * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_13254","instance":13254,"id":183253,"goal":"lemma LeRefl_13254(m: real)\n ensures m <= m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_13255","instance":13255,"id":183254,"goal":"lemma LeTrans_13255(i: int, j: int, c: int)\n requires i <= j && j <= c\n ensures i <= c\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_13256","instance":13256,"id":183255,"goal":"lemma AddMono_13256(b: nat, x: nat, k: nat)\n requires b <= x\n ensures b + k <= x + k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_13257","instance":13257,"id":183256,"goal":"lemma Abs_Nonneg_13257(y: real)\n ensures (if y >= 0 then y else -y) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_13258","instance":13258,"id":183257,"goal":"lemma DivMod_13258(c: int, y: int)\n requires y > 0\n ensures c == y * (c / y) + (c % y)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_13259","instance":13259,"id":183258,"goal":"lemma ModBounds_13259(i: nat, y: nat)\n requires y > 0\n ensures 0 <= i % y < y\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_13260","instance":13260,"id":183259,"goal":"lemma Square_Nonneg_13260(m: real)\n ensures m * m >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_13261","instance":13261,"id":183260,"goal":"lemma AddComm_13261(m: int, x: int)\n ensures m + x == x + m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_13262","instance":13262,"id":183261,"goal":"lemma AddAssoc_13262(a: nat, d: nat, y: nat)\n ensures (a + d) + y == a + (d + y)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_13263","instance":13263,"id":183262,"goal":"lemma MulComm_13263(z: real, i: real)\n ensures z * i == i * z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_13264","instance":13264,"id":183263,"goal":"lemma MulAssoc_13264(x: int, k: int, j: int)\n ensures (x * k) * j == x * (k * j)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_13265","instance":13265,"id":183264,"goal":"lemma Distrib_13265(n: nat, a: nat, k: nat)\n ensures n * (a + k) == n * a + n * k\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_13266","instance":13266,"id":183265,"goal":"lemma AddZero_13266(b: real)\n ensures b + 0 == b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_13267","instance":13267,"id":183266,"goal":"lemma MulOne_13267(b: int)\n ensures b * 1 == b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_13268","instance":13268,"id":183267,"goal":"lemma MulZero_13268(m: nat)\n ensures m * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_13269","instance":13269,"id":183268,"goal":"lemma LeRefl_13269(a: real)\n ensures a <= a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_13270","instance":13270,"id":183269,"goal":"lemma LeTrans_13270(d: int, k: int, c: int)\n requires d <= k && k <= c\n ensures d <= c\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_13271","instance":13271,"id":183270,"goal":"lemma AddMono_13271(j: nat, i: nat, a: nat)\n requires j <= i\n ensures j + a <= i + a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_13272","instance":13272,"id":183271,"goal":"lemma Abs_Nonneg_13272(y: real)\n ensures (if y >= 0 then y else -y) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_13273","instance":13273,"id":183272,"goal":"lemma DivMod_13273(d: int, k: int)\n requires k > 0\n ensures d == k * (d / k) + (d % k)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_13274","instance":13274,"id":183273,"goal":"lemma ModBounds_13274(y: nat, m: nat)\n requires m > 0\n ensures 0 <= y % m < m\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_13275","instance":13275,"id":183274,"goal":"lemma Square_Nonneg_13275(k: real)\n ensures k * k >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_13276","instance":13276,"id":183275,"goal":"lemma AddComm_13276(k: int, j: int)\n ensures k + j == j + k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_13277","instance":13277,"id":183276,"goal":"lemma AddAssoc_13277(x: nat, i: nat, a: nat)\n ensures (x + i) + a == x + (i + a)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_13278","instance":13278,"id":183277,"goal":"lemma MulComm_13278(z: real, c: real)\n ensures z * c == c * z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_13279","instance":13279,"id":183278,"goal":"lemma MulAssoc_13279(b: int, n: int, a: int)\n ensures (b * n) * a == b * (n * a)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_13280","instance":13280,"id":183279,"goal":"lemma Distrib_13280(c: nat, j: nat, y: nat)\n ensures c * (j + y) == c * j + c * y\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_13281","instance":13281,"id":183280,"goal":"lemma AddZero_13281(b: real)\n ensures b + 0 == b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_13282","instance":13282,"id":183281,"goal":"lemma MulOne_13282(c: int)\n ensures c * 1 == c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_13283","instance":13283,"id":183282,"goal":"lemma MulZero_13283(m: nat)\n ensures m * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_13284","instance":13284,"id":183283,"goal":"lemma LeRefl_13284(m: real)\n ensures m <= m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_13285","instance":13285,"id":183284,"goal":"lemma LeTrans_13285(j: int, n: int, c: int)\n requires j <= n && n <= c\n ensures j <= c\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_13286","instance":13286,"id":183285,"goal":"lemma AddMono_13286(z: nat, k: nat, y: nat)\n requires z <= k\n ensures z + y <= k + y\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_13287","instance":13287,"id":183286,"goal":"lemma Abs_Nonneg_13287(k: real)\n ensures (if k >= 0 then k else -k) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_13288","instance":13288,"id":183287,"goal":"lemma DivMod_13288(j: int, a: int)\n requires a > 0\n ensures j == a * (j / a) + (j % a)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_13289","instance":13289,"id":183288,"goal":"lemma ModBounds_13289(n: nat, c: nat)\n requires c > 0\n ensures 0 <= n % c < c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_13290","instance":13290,"id":183289,"goal":"lemma Square_Nonneg_13290(y: real)\n ensures y * y >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_13291","instance":13291,"id":183290,"goal":"lemma AddComm_13291(a: int, i: int)\n ensures a + i == i + a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_13292","instance":13292,"id":183291,"goal":"lemma AddAssoc_13292(z: nat, d: nat, x: nat)\n ensures (z + d) + x == z + (d + x)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_13293","instance":13293,"id":183292,"goal":"lemma MulComm_13293(j: real, x: real)\n ensures j * x == x * j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_13294","instance":13294,"id":183293,"goal":"lemma MulAssoc_13294(j: int, m: int, k: int)\n ensures (j * m) * k == j * (m * k)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_13295","instance":13295,"id":183294,"goal":"lemma Distrib_13295(n: nat, k: nat, z: nat)\n ensures n * (k + z) == n * k + n * z\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_13296","instance":13296,"id":183295,"goal":"lemma AddZero_13296(c: real)\n ensures c + 0 == c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_13297","instance":13297,"id":183296,"goal":"lemma MulOne_13297(z: int)\n ensures z * 1 == z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_13298","instance":13298,"id":183297,"goal":"lemma MulZero_13298(i: nat)\n ensures i * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_13299","instance":13299,"id":183298,"goal":"lemma LeRefl_13299(y: real)\n ensures y <= y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_13300","instance":13300,"id":183299,"goal":"lemma LeTrans_13300(z: int, j: int, d: int)\n requires z <= j && j <= d\n ensures z <= d\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_13301","instance":13301,"id":183300,"goal":"lemma AddMono_13301(n: nat, k: nat, a: nat)\n requires n <= k\n ensures n + a <= k + a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_13302","instance":13302,"id":183301,"goal":"lemma Abs_Nonneg_13302(a: real)\n ensures (if a >= 0 then a else -a) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_13303","instance":13303,"id":183302,"goal":"lemma DivMod_13303(n: int, x: int)\n requires x > 0\n ensures n == x * (n / x) + (n % x)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_13304","instance":13304,"id":183303,"goal":"lemma ModBounds_13304(n: nat, z: nat)\n requires z > 0\n ensures 0 <= n % z < z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_13305","instance":13305,"id":183304,"goal":"lemma Square_Nonneg_13305(n: real)\n ensures n * n >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_13306","instance":13306,"id":183305,"goal":"lemma AddComm_13306(z: int, j: int)\n ensures z + j == j + z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_13307","instance":13307,"id":183306,"goal":"lemma AddAssoc_13307(d: nat, i: nat, c: nat)\n ensures (d + i) + c == d + (i + c)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_13308","instance":13308,"id":183307,"goal":"lemma MulComm_13308(z: real, k: real)\n ensures z * k == k * z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_13309","instance":13309,"id":183308,"goal":"lemma MulAssoc_13309(i: int, n: int, a: int)\n ensures (i * n) * a == i * (n * a)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_13310","instance":13310,"id":183309,"goal":"lemma Distrib_13310(b: nat, y: nat, j: nat)\n ensures b * (y + j) == b * y + b * j\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_13311","instance":13311,"id":183310,"goal":"lemma AddZero_13311(i: real)\n ensures i + 0 == i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_13312","instance":13312,"id":183311,"goal":"lemma MulOne_13312(b: int)\n ensures b * 1 == b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_13313","instance":13313,"id":183312,"goal":"lemma MulZero_13313(m: nat)\n ensures m * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_13314","instance":13314,"id":183313,"goal":"lemma LeRefl_13314(y: real)\n ensures y <= y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_13315","instance":13315,"id":183314,"goal":"lemma LeTrans_13315(a: int, m: int, b: int)\n requires a <= m && m <= b\n ensures a <= b\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_13316","instance":13316,"id":183315,"goal":"lemma AddMono_13316(j: nat, x: nat, d: nat)\n requires j <= x\n ensures j + d <= x + d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_13317","instance":13317,"id":183316,"goal":"lemma Abs_Nonneg_13317(a: real)\n ensures (if a >= 0 then a else -a) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_13318","instance":13318,"id":183317,"goal":"lemma DivMod_13318(n: int, j: int)\n requires j > 0\n ensures n == j * (n / j) + (n % j)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_13319","instance":13319,"id":183318,"goal":"lemma ModBounds_13319(a: nat, i: nat)\n requires i > 0\n ensures 0 <= a % i < i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_13320","instance":13320,"id":183319,"goal":"lemma Square_Nonneg_13320(y: real)\n ensures y * y >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_13321","instance":13321,"id":183320,"goal":"lemma AddComm_13321(z: int, n: int)\n ensures z + n == n + z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_13322","instance":13322,"id":183321,"goal":"lemma AddAssoc_13322(x: nat, k: nat, j: nat)\n ensures (x + k) + j == x + (k + j)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_13323","instance":13323,"id":183322,"goal":"lemma MulComm_13323(x: real, k: real)\n ensures x * k == k * x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_13324","instance":13324,"id":183323,"goal":"lemma MulAssoc_13324(b: int, m: int, y: int)\n ensures (b * m) * y == b * (m * y)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_13325","instance":13325,"id":183324,"goal":"lemma Distrib_13325(n: nat, b: nat, z: nat)\n ensures n * (b + z) == n * b + n * z\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_13326","instance":13326,"id":183325,"goal":"lemma AddZero_13326(c: real)\n ensures c + 0 == c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_13327","instance":13327,"id":183326,"goal":"lemma MulOne_13327(d: int)\n ensures d * 1 == d\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_13328","instance":13328,"id":183327,"goal":"lemma MulZero_13328(i: nat)\n ensures i * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_13329","instance":13329,"id":183328,"goal":"lemma LeRefl_13329(b: real)\n ensures b <= b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_13330","instance":13330,"id":183329,"goal":"lemma LeTrans_13330(j: int, c: int, x: int)\n requires j <= c && c <= x\n ensures j <= x\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_13331","instance":13331,"id":183330,"goal":"lemma AddMono_13331(k: nat, n: nat, i: nat)\n requires k <= n\n ensures k + i <= n + i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_13332","instance":13332,"id":183331,"goal":"lemma Abs_Nonneg_13332(a: real)\n ensures (if a >= 0 then a else -a) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_13333","instance":13333,"id":183332,"goal":"lemma DivMod_13333(n: int, y: int)\n requires y > 0\n ensures n == y * (n / y) + (n % y)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_13334","instance":13334,"id":183333,"goal":"lemma ModBounds_13334(i: nat, y: nat)\n requires y > 0\n ensures 0 <= i % y < y\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_13335","instance":13335,"id":183334,"goal":"lemma Square_Nonneg_13335(y: real)\n ensures y * y >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_13336","instance":13336,"id":183335,"goal":"lemma AddComm_13336(z: int, c: int)\n ensures z + c == c + z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_13337","instance":13337,"id":183336,"goal":"lemma AddAssoc_13337(y: nat, m: nat, i: nat)\n ensures (y + m) + i == y + (m + i)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_13338","instance":13338,"id":183337,"goal":"lemma MulComm_13338(d: real, j: real)\n ensures d * j == j * d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_13339","instance":13339,"id":183338,"goal":"lemma MulAssoc_13339(i: int, z: int, x: int)\n ensures (i * z) * x == i * (z * x)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_13340","instance":13340,"id":183339,"goal":"lemma Distrib_13340(d: nat, i: nat, z: nat)\n ensures d * (i + z) == d * i + d * z\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_13341","instance":13341,"id":183340,"goal":"lemma AddZero_13341(a: real)\n ensures a + 0 == a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_13342","instance":13342,"id":183341,"goal":"lemma MulOne_13342(a: int)\n ensures a * 1 == a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_13343","instance":13343,"id":183342,"goal":"lemma MulZero_13343(j: nat)\n ensures j * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_13344","instance":13344,"id":183343,"goal":"lemma LeRefl_13344(n: real)\n ensures n <= n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_13345","instance":13345,"id":183344,"goal":"lemma LeTrans_13345(x: int, i: int, a: int)\n requires x <= i && i <= a\n ensures x <= a\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_13346","instance":13346,"id":183345,"goal":"lemma AddMono_13346(y: nat, i: nat, a: nat)\n requires y <= i\n ensures y + a <= i + a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_13347","instance":13347,"id":183346,"goal":"lemma Abs_Nonneg_13347(c: real)\n ensures (if c >= 0 then c else -c) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_13348","instance":13348,"id":183347,"goal":"lemma DivMod_13348(j: int, m: int)\n requires m > 0\n ensures j == m * (j / m) + (j % m)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_13349","instance":13349,"id":183348,"goal":"lemma ModBounds_13349(a: nat, y: nat)\n requires y > 0\n ensures 0 <= a % y < y\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_13350","instance":13350,"id":183349,"goal":"lemma Square_Nonneg_13350(c: real)\n ensures c * c >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_13351","instance":13351,"id":183350,"goal":"lemma AddComm_13351(y: int, x: int)\n ensures y + x == x + y\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_13352","instance":13352,"id":183351,"goal":"lemma AddAssoc_13352(d: nat, b: nat, c: nat)\n ensures (d + b) + c == d + (b + c)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_13353","instance":13353,"id":183352,"goal":"lemma MulComm_13353(m: real, a: real)\n ensures m * a == a * m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_13354","instance":13354,"id":183353,"goal":"lemma MulAssoc_13354(m: int, z: int, i: int)\n ensures (m * z) * i == m * (z * i)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_13355","instance":13355,"id":183354,"goal":"lemma Distrib_13355(a: nat, y: nat, k: nat)\n ensures a * (y + k) == a * y + a * k\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_13356","instance":13356,"id":183355,"goal":"lemma AddZero_13356(z: real)\n ensures z + 0 == z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_13357","instance":13357,"id":183356,"goal":"lemma MulOne_13357(k: int)\n ensures k * 1 == k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_13358","instance":13358,"id":183357,"goal":"lemma MulZero_13358(d: nat)\n ensures d * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_13359","instance":13359,"id":183358,"goal":"lemma LeRefl_13359(d: real)\n ensures d <= d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_13360","instance":13360,"id":183359,"goal":"lemma LeTrans_13360(n: int, i: int, k: int)\n requires n <= i && i <= k\n ensures n <= k\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_13361","instance":13361,"id":183360,"goal":"lemma AddMono_13361(y: nat, b: nat, n: nat)\n requires y <= b\n ensures y + n <= b + n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_13362","instance":13362,"id":183361,"goal":"lemma Abs_Nonneg_13362(d: real)\n ensures (if d >= 0 then d else -d) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_13363","instance":13363,"id":183362,"goal":"lemma DivMod_13363(n: int, i: int)\n requires i > 0\n ensures n == i * (n / i) + (n % i)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_13364","instance":13364,"id":183363,"goal":"lemma ModBounds_13364(x: nat, k: nat)\n requires k > 0\n ensures 0 <= x % k < k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_13365","instance":13365,"id":183364,"goal":"lemma Square_Nonneg_13365(b: real)\n ensures b * b >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_13366","instance":13366,"id":183365,"goal":"lemma AddComm_13366(y: int, d: int)\n ensures y + d == d + y\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_13367","instance":13367,"id":183366,"goal":"lemma AddAssoc_13367(k: nat, x: nat, n: nat)\n ensures (k + x) + n == k + (x + n)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_13368","instance":13368,"id":183367,"goal":"lemma MulComm_13368(y: real, d: real)\n ensures y * d == d * y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_13369","instance":13369,"id":183368,"goal":"lemma MulAssoc_13369(j: int, i: int, a: int)\n ensures (j * i) * a == j * (i * a)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_13370","instance":13370,"id":183369,"goal":"lemma Distrib_13370(z: nat, n: nat, c: nat)\n ensures z * (n + c) == z * n + z * c\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_13371","instance":13371,"id":183370,"goal":"lemma AddZero_13371(z: real)\n ensures z + 0 == z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_13372","instance":13372,"id":183371,"goal":"lemma MulOne_13372(k: int)\n ensures k * 1 == k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_13373","instance":13373,"id":183372,"goal":"lemma MulZero_13373(n: nat)\n ensures n * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_13374","instance":13374,"id":183373,"goal":"lemma LeRefl_13374(c: real)\n ensures c <= c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_13375","instance":13375,"id":183374,"goal":"lemma LeTrans_13375(d: int, x: int, a: int)\n requires d <= x && x <= a\n ensures d <= a\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_13376","instance":13376,"id":183375,"goal":"lemma AddMono_13376(x: nat, m: nat, a: nat)\n requires x <= m\n ensures x + a <= m + a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_13377","instance":13377,"id":183376,"goal":"lemma Abs_Nonneg_13377(c: real)\n ensures (if c >= 0 then c else -c) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_13378","instance":13378,"id":183377,"goal":"lemma DivMod_13378(j: int, y: int)\n requires y > 0\n ensures j == y * (j / y) + (j % y)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_13379","instance":13379,"id":183378,"goal":"lemma ModBounds_13379(n: nat, m: nat)\n requires m > 0\n ensures 0 <= n % m < m\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_13380","instance":13380,"id":183379,"goal":"lemma Square_Nonneg_13380(n: real)\n ensures n * n >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_13381","instance":13381,"id":183380,"goal":"lemma AddComm_13381(y: int, d: int)\n ensures y + d == d + y\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_13382","instance":13382,"id":183381,"goal":"lemma AddAssoc_13382(b: nat, c: nat, k: nat)\n ensures (b + c) + k == b + (c + k)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_13383","instance":13383,"id":183382,"goal":"lemma MulComm_13383(n: real, m: real)\n ensures n * m == m * n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_13384","instance":13384,"id":183383,"goal":"lemma MulAssoc_13384(z: int, i: int, k: int)\n ensures (z * i) * k == z * (i * k)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_13385","instance":13385,"id":183384,"goal":"lemma Distrib_13385(k: nat, x: nat, z: nat)\n ensures k * (x + z) == k * x + k * z\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_13386","instance":13386,"id":183385,"goal":"lemma AddZero_13386(x: real)\n ensures x + 0 == x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_13387","instance":13387,"id":183386,"goal":"lemma MulOne_13387(a: int)\n ensures a * 1 == a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_13388","instance":13388,"id":183387,"goal":"lemma MulZero_13388(n: nat)\n ensures n * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_13389","instance":13389,"id":183388,"goal":"lemma LeRefl_13389(i: real)\n ensures i <= i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_13390","instance":13390,"id":183389,"goal":"lemma LeTrans_13390(j: int, m: int, n: int)\n requires j <= m && m <= n\n ensures j <= n\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_13391","instance":13391,"id":183390,"goal":"lemma AddMono_13391(c: nat, i: nat, z: nat)\n requires c <= i\n ensures c + z <= i + z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_13392","instance":13392,"id":183391,"goal":"lemma Abs_Nonneg_13392(x: real)\n ensures (if x >= 0 then x else -x) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_13393","instance":13393,"id":183392,"goal":"lemma DivMod_13393(d: int, n: int)\n requires n > 0\n ensures d == n * (d / n) + (d % n)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_13394","instance":13394,"id":183393,"goal":"lemma ModBounds_13394(x: nat, b: nat)\n requires b > 0\n ensures 0 <= x % b < b\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_13395","instance":13395,"id":183394,"goal":"lemma Square_Nonneg_13395(k: real)\n ensures k * k >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_13396","instance":13396,"id":183395,"goal":"lemma AddComm_13396(y: int, m: int)\n ensures y + m == m + y\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_13397","instance":13397,"id":183396,"goal":"lemma AddAssoc_13397(y: nat, k: nat, c: nat)\n ensures (y + k) + c == y + (k + c)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_13398","instance":13398,"id":183397,"goal":"lemma MulComm_13398(y: real, m: real)\n ensures y * m == m * y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_13399","instance":13399,"id":183398,"goal":"lemma MulAssoc_13399(n: int, i: int, y: int)\n ensures (n * i) * y == n * (i * y)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_13400","instance":13400,"id":183399,"goal":"lemma Distrib_13400(j: nat, x: nat, c: nat)\n ensures j * (x + c) == j * x + j * c\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_13401","instance":13401,"id":183400,"goal":"lemma AddZero_13401(y: real)\n ensures y + 0 == y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_13402","instance":13402,"id":183401,"goal":"lemma MulOne_13402(y: int)\n ensures y * 1 == y\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_13403","instance":13403,"id":183402,"goal":"lemma MulZero_13403(z: nat)\n ensures z * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_13404","instance":13404,"id":183403,"goal":"lemma LeRefl_13404(a: real)\n ensures a <= a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_13405","instance":13405,"id":183404,"goal":"lemma LeTrans_13405(y: int, k: int, n: int)\n requires y <= k && k <= n\n ensures y <= n\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_13406","instance":13406,"id":183405,"goal":"lemma AddMono_13406(d: nat, a: nat, b: nat)\n requires d <= a\n ensures d + b <= a + b\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_13407","instance":13407,"id":183406,"goal":"lemma Abs_Nonneg_13407(k: real)\n ensures (if k >= 0 then k else -k) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_13408","instance":13408,"id":183407,"goal":"lemma DivMod_13408(m: int, j: int)\n requires j > 0\n ensures m == j * (m / j) + (m % j)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_13409","instance":13409,"id":183408,"goal":"lemma ModBounds_13409(a: nat, n: nat)\n requires n > 0\n ensures 0 <= a % n < n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_13410","instance":13410,"id":183409,"goal":"lemma Square_Nonneg_13410(d: real)\n ensures d * d >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_13411","instance":13411,"id":183410,"goal":"lemma AddComm_13411(a: int, c: int)\n ensures a + c == c + a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_13412","instance":13412,"id":183411,"goal":"lemma AddAssoc_13412(b: nat, y: nat, z: nat)\n ensures (b + y) + z == b + (y + z)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_13413","instance":13413,"id":183412,"goal":"lemma MulComm_13413(y: real, z: real)\n ensures y * z == z * y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_13414","instance":13414,"id":183413,"goal":"lemma MulAssoc_13414(k: int, a: int, d: int)\n ensures (k * a) * d == k * (a * d)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_13415","instance":13415,"id":183414,"goal":"lemma Distrib_13415(i: nat, c: nat, z: nat)\n ensures i * (c + z) == i * c + i * z\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_13416","instance":13416,"id":183415,"goal":"lemma AddZero_13416(i: real)\n ensures i + 0 == i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_13417","instance":13417,"id":183416,"goal":"lemma MulOne_13417(m: int)\n ensures m * 1 == m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_13418","instance":13418,"id":183417,"goal":"lemma MulZero_13418(i: nat)\n ensures i * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_13419","instance":13419,"id":183418,"goal":"lemma LeRefl_13419(j: real)\n ensures j <= j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_13420","instance":13420,"id":183419,"goal":"lemma LeTrans_13420(b: int, d: int, n: int)\n requires b <= d && d <= n\n ensures b <= n\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_13421","instance":13421,"id":183420,"goal":"lemma AddMono_13421(k: nat, z: nat, j: nat)\n requires k <= z\n ensures k + j <= z + j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_13422","instance":13422,"id":183421,"goal":"lemma Abs_Nonneg_13422(b: real)\n ensures (if b >= 0 then b else -b) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_13423","instance":13423,"id":183422,"goal":"lemma DivMod_13423(j: int, d: int)\n requires d > 0\n ensures j == d * (j / d) + (j % d)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_13424","instance":13424,"id":183423,"goal":"lemma ModBounds_13424(m: nat, z: nat)\n requires z > 0\n ensures 0 <= m % z < z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_13425","instance":13425,"id":183424,"goal":"lemma Square_Nonneg_13425(y: real)\n ensures y * y >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_13426","instance":13426,"id":183425,"goal":"lemma AddComm_13426(b: int, x: int)\n ensures b + x == x + b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_13427","instance":13427,"id":183426,"goal":"lemma AddAssoc_13427(k: nat, m: nat, d: nat)\n ensures (k + m) + d == k + (m + d)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_13428","instance":13428,"id":183427,"goal":"lemma MulComm_13428(d: real, k: real)\n ensures d * k == k * d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_13429","instance":13429,"id":183428,"goal":"lemma MulAssoc_13429(y: int, n: int, a: int)\n ensures (y * n) * a == y * (n * a)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_13430","instance":13430,"id":183429,"goal":"lemma Distrib_13430(n: nat, x: nat, j: nat)\n ensures n * (x + j) == n * x + n * j\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_13431","instance":13431,"id":183430,"goal":"lemma AddZero_13431(m: real)\n ensures m + 0 == m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_13432","instance":13432,"id":183431,"goal":"lemma MulOne_13432(d: int)\n ensures d * 1 == d\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_13433","instance":13433,"id":183432,"goal":"lemma MulZero_13433(n: nat)\n ensures n * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_13434","instance":13434,"id":183433,"goal":"lemma LeRefl_13434(m: real)\n ensures m <= m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_13435","instance":13435,"id":183434,"goal":"lemma LeTrans_13435(n: int, y: int, x: int)\n requires n <= y && y <= x\n ensures n <= x\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_13436","instance":13436,"id":183435,"goal":"lemma AddMono_13436(z: nat, k: nat, m: nat)\n requires z <= k\n ensures z + m <= k + m\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_13437","instance":13437,"id":183436,"goal":"lemma Abs_Nonneg_13437(c: real)\n ensures (if c >= 0 then c else -c) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_13438","instance":13438,"id":183437,"goal":"lemma DivMod_13438(c: int, y: int)\n requires y > 0\n ensures c == y * (c / y) + (c % y)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_13439","instance":13439,"id":183438,"goal":"lemma ModBounds_13439(a: nat, z: nat)\n requires z > 0\n ensures 0 <= a % z < z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_13440","instance":13440,"id":183439,"goal":"lemma Square_Nonneg_13440(y: real)\n ensures y * y >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_13441","instance":13441,"id":183440,"goal":"lemma AddComm_13441(b: int, y: int)\n ensures b + y == y + b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_13442","instance":13442,"id":183441,"goal":"lemma AddAssoc_13442(m: nat, a: nat, x: nat)\n ensures (m + a) + x == m + (a + x)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_13443","instance":13443,"id":183442,"goal":"lemma MulComm_13443(z: real, x: real)\n ensures z * x == x * z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_13444","instance":13444,"id":183443,"goal":"lemma MulAssoc_13444(z: int, j: int, i: int)\n ensures (z * j) * i == z * (j * i)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_13445","instance":13445,"id":183444,"goal":"lemma Distrib_13445(k: nat, a: nat, b: nat)\n ensures k * (a + b) == k * a + k * b\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_13446","instance":13446,"id":183445,"goal":"lemma AddZero_13446(c: real)\n ensures c + 0 == c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_13447","instance":13447,"id":183446,"goal":"lemma MulOne_13447(m: int)\n ensures m * 1 == m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_13448","instance":13448,"id":183447,"goal":"lemma MulZero_13448(c: nat)\n ensures c * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_13449","instance":13449,"id":183448,"goal":"lemma LeRefl_13449(z: real)\n ensures z <= z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_13450","instance":13450,"id":183449,"goal":"lemma LeTrans_13450(m: int, d: int, a: int)\n requires m <= d && d <= a\n ensures m <= a\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_13451","instance":13451,"id":183450,"goal":"lemma AddMono_13451(i: nat, b: nat, a: nat)\n requires i <= b\n ensures i + a <= b + a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_13452","instance":13452,"id":183451,"goal":"lemma Abs_Nonneg_13452(k: real)\n ensures (if k >= 0 then k else -k) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_13453","instance":13453,"id":183452,"goal":"lemma DivMod_13453(n: int, y: int)\n requires y > 0\n ensures n == y * (n / y) + (n % y)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_13454","instance":13454,"id":183453,"goal":"lemma ModBounds_13454(m: nat, i: nat)\n requires i > 0\n ensures 0 <= m % i < i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_13455","instance":13455,"id":183454,"goal":"lemma Square_Nonneg_13455(d: real)\n ensures d * d >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_13456","instance":13456,"id":183455,"goal":"lemma AddComm_13456(z: int, n: int)\n ensures z + n == n + z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_13457","instance":13457,"id":183456,"goal":"lemma AddAssoc_13457(j: nat, i: nat, m: nat)\n ensures (j + i) + m == j + (i + m)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_13458","instance":13458,"id":183457,"goal":"lemma MulComm_13458(k: real, a: real)\n ensures k * a == a * k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_13459","instance":13459,"id":183458,"goal":"lemma MulAssoc_13459(a: int, c: int, z: int)\n ensures (a * c) * z == a * (c * z)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_13460","instance":13460,"id":183459,"goal":"lemma Distrib_13460(c: nat, x: nat, y: nat)\n ensures c * (x + y) == c * x + c * y\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_13461","instance":13461,"id":183460,"goal":"lemma AddZero_13461(z: real)\n ensures z + 0 == z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_13462","instance":13462,"id":183461,"goal":"lemma MulOne_13462(y: int)\n ensures y * 1 == y\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_13463","instance":13463,"id":183462,"goal":"lemma MulZero_13463(m: nat)\n ensures m * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_13464","instance":13464,"id":183463,"goal":"lemma LeRefl_13464(b: real)\n ensures b <= b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_13465","instance":13465,"id":183464,"goal":"lemma LeTrans_13465(n: int, m: int, d: int)\n requires n <= m && m <= d\n ensures n <= d\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_13466","instance":13466,"id":183465,"goal":"lemma AddMono_13466(z: nat, k: nat, j: nat)\n requires z <= k\n ensures z + j <= k + j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_13467","instance":13467,"id":183466,"goal":"lemma Abs_Nonneg_13467(y: real)\n ensures (if y >= 0 then y else -y) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_13468","instance":13468,"id":183467,"goal":"lemma DivMod_13468(c: int, x: int)\n requires x > 0\n ensures c == x * (c / x) + (c % x)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_13469","instance":13469,"id":183468,"goal":"lemma ModBounds_13469(b: nat, k: nat)\n requires k > 0\n ensures 0 <= b % k < k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_13470","instance":13470,"id":183469,"goal":"lemma Square_Nonneg_13470(m: real)\n ensures m * m >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_13471","instance":13471,"id":183470,"goal":"lemma AddComm_13471(c: int, j: int)\n ensures c + j == j + c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_13472","instance":13472,"id":183471,"goal":"lemma AddAssoc_13472(n: nat, i: nat, j: nat)\n ensures (n + i) + j == n + (i + j)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_13473","instance":13473,"id":183472,"goal":"lemma MulComm_13473(z: real, x: real)\n ensures z * x == x * z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_13474","instance":13474,"id":183473,"goal":"lemma MulAssoc_13474(i: int, k: int, j: int)\n ensures (i * k) * j == i * (k * j)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_13475","instance":13475,"id":183474,"goal":"lemma Distrib_13475(i: nat, b: nat, y: nat)\n ensures i * (b + y) == i * b + i * y\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_13476","instance":13476,"id":183475,"goal":"lemma AddZero_13476(i: real)\n ensures i + 0 == i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_13477","instance":13477,"id":183476,"goal":"lemma MulOne_13477(n: int)\n ensures n * 1 == n\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_13478","instance":13478,"id":183477,"goal":"lemma MulZero_13478(i: nat)\n ensures i * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_13479","instance":13479,"id":183478,"goal":"lemma LeRefl_13479(d: real)\n ensures d <= d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_13480","instance":13480,"id":183479,"goal":"lemma LeTrans_13480(j: int, d: int, a: int)\n requires j <= d && d <= a\n ensures j <= a\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_13481","instance":13481,"id":183480,"goal":"lemma AddMono_13481(c: nat, z: nat, i: nat)\n requires c <= z\n ensures c + i <= z + i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_13482","instance":13482,"id":183481,"goal":"lemma Abs_Nonneg_13482(z: real)\n ensures (if z >= 0 then z else -z) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_13483","instance":13483,"id":183482,"goal":"lemma DivMod_13483(z: int, n: int)\n requires n > 0\n ensures z == n * (z / n) + (z % n)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_13484","instance":13484,"id":183483,"goal":"lemma ModBounds_13484(d: nat, j: nat)\n requires j > 0\n ensures 0 <= d % j < j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_13485","instance":13485,"id":183484,"goal":"lemma Square_Nonneg_13485(m: real)\n ensures m * m >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_13486","instance":13486,"id":183485,"goal":"lemma AddComm_13486(z: int, x: int)\n ensures z + x == x + z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_13487","instance":13487,"id":183486,"goal":"lemma AddAssoc_13487(d: nat, a: nat, j: nat)\n ensures (d + a) + j == d + (a + j)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_13488","instance":13488,"id":183487,"goal":"lemma MulComm_13488(z: real, b: real)\n ensures z * b == b * z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_13489","instance":13489,"id":183488,"goal":"lemma MulAssoc_13489(d: int, b: int, n: int)\n ensures (d * b) * n == d * (b * n)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_13490","instance":13490,"id":183489,"goal":"lemma Distrib_13490(k: nat, x: nat, a: nat)\n ensures k * (x + a) == k * x + k * a\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_13491","instance":13491,"id":183490,"goal":"lemma AddZero_13491(d: real)\n ensures d + 0 == d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_13492","instance":13492,"id":183491,"goal":"lemma MulOne_13492(m: int)\n ensures m * 1 == m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_13493","instance":13493,"id":183492,"goal":"lemma MulZero_13493(n: nat)\n ensures n * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_13494","instance":13494,"id":183493,"goal":"lemma LeRefl_13494(m: real)\n ensures m <= m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_13495","instance":13495,"id":183494,"goal":"lemma LeTrans_13495(c: int, j: int, x: int)\n requires c <= j && j <= x\n ensures c <= x\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_13496","instance":13496,"id":183495,"goal":"lemma AddMono_13496(z: nat, b: nat, c: nat)\n requires z <= b\n ensures z + c <= b + c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_13497","instance":13497,"id":183496,"goal":"lemma Abs_Nonneg_13497(z: real)\n ensures (if z >= 0 then z else -z) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_13498","instance":13498,"id":183497,"goal":"lemma DivMod_13498(c: int, n: int)\n requires n > 0\n ensures c == n * (c / n) + (c % n)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_13499","instance":13499,"id":183498,"goal":"lemma ModBounds_13499(k: nat, j: nat)\n requires j > 0\n ensures 0 <= k % j < j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_13500","instance":13500,"id":183499,"goal":"lemma Square_Nonneg_13500(k: real)\n ensures k * k >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_13501","instance":13501,"id":183500,"goal":"lemma AddComm_13501(k: int, a: int)\n ensures k + a == a + k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_13502","instance":13502,"id":183501,"goal":"lemma AddAssoc_13502(k: nat, z: nat, a: nat)\n ensures (k + z) + a == k + (z + a)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_13503","instance":13503,"id":183502,"goal":"lemma MulComm_13503(d: real, n: real)\n ensures d * n == n * d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_13504","instance":13504,"id":183503,"goal":"lemma MulAssoc_13504(j: int, n: int, z: int)\n ensures (j * n) * z == j * (n * z)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_13505","instance":13505,"id":183504,"goal":"lemma Distrib_13505(a: nat, y: nat, z: nat)\n ensures a * (y + z) == a * y + a * z\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_13506","instance":13506,"id":183505,"goal":"lemma AddZero_13506(n: real)\n ensures n + 0 == n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_13507","instance":13507,"id":183506,"goal":"lemma MulOne_13507(j: int)\n ensures j * 1 == j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_13508","instance":13508,"id":183507,"goal":"lemma MulZero_13508(k: nat)\n ensures k * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_13509","instance":13509,"id":183508,"goal":"lemma LeRefl_13509(n: real)\n ensures n <= n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_13510","instance":13510,"id":183509,"goal":"lemma LeTrans_13510(x: int, d: int, k: int)\n requires x <= d && d <= k\n ensures x <= k\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_13511","instance":13511,"id":183510,"goal":"lemma AddMono_13511(n: nat, j: nat, k: nat)\n requires n <= j\n ensures n + k <= j + k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_13512","instance":13512,"id":183511,"goal":"lemma Abs_Nonneg_13512(n: real)\n ensures (if n >= 0 then n else -n) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_13513","instance":13513,"id":183512,"goal":"lemma DivMod_13513(i: int, c: int)\n requires c > 0\n ensures i == c * (i / c) + (i % c)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_13514","instance":13514,"id":183513,"goal":"lemma ModBounds_13514(i: nat, n: nat)\n requires n > 0\n ensures 0 <= i % n < n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_13515","instance":13515,"id":183514,"goal":"lemma Square_Nonneg_13515(z: real)\n ensures z * z >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_13516","instance":13516,"id":183515,"goal":"lemma AddComm_13516(b: int, j: int)\n ensures b + j == j + b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_13517","instance":13517,"id":183516,"goal":"lemma AddAssoc_13517(y: nat, z: nat, c: nat)\n ensures (y + z) + c == y + (z + c)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_13518","instance":13518,"id":183517,"goal":"lemma MulComm_13518(j: real, x: real)\n ensures j * x == x * j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_13519","instance":13519,"id":183518,"goal":"lemma MulAssoc_13519(d: int, z: int, k: int)\n ensures (d * z) * k == d * (z * k)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_13520","instance":13520,"id":183519,"goal":"lemma Distrib_13520(b: nat, x: nat, i: nat)\n ensures b * (x + i) == b * x + b * i\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_13521","instance":13521,"id":183520,"goal":"lemma AddZero_13521(a: real)\n ensures a + 0 == a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_13522","instance":13522,"id":183521,"goal":"lemma MulOne_13522(x: int)\n ensures x * 1 == x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_13523","instance":13523,"id":183522,"goal":"lemma MulZero_13523(x: nat)\n ensures x * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_13524","instance":13524,"id":183523,"goal":"lemma LeRefl_13524(i: real)\n ensures i <= i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_13525","instance":13525,"id":183524,"goal":"lemma LeTrans_13525(c: int, i: int, x: int)\n requires c <= i && i <= x\n ensures c <= x\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_13526","instance":13526,"id":183525,"goal":"lemma AddMono_13526(b: nat, d: nat, i: nat)\n requires b <= d\n ensures b + i <= d + i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_13527","instance":13527,"id":183526,"goal":"lemma Abs_Nonneg_13527(a: real)\n ensures (if a >= 0 then a else -a) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_13528","instance":13528,"id":183527,"goal":"lemma DivMod_13528(a: int, m: int)\n requires m > 0\n ensures a == m * (a / m) + (a % m)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_13529","instance":13529,"id":183528,"goal":"lemma ModBounds_13529(b: nat, z: nat)\n requires z > 0\n ensures 0 <= b % z < z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_13530","instance":13530,"id":183529,"goal":"lemma Square_Nonneg_13530(j: real)\n ensures j * j >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_13531","instance":13531,"id":183530,"goal":"lemma AddComm_13531(z: int, y: int)\n ensures z + y == y + z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_13532","instance":13532,"id":183531,"goal":"lemma AddAssoc_13532(d: nat, b: nat, k: nat)\n ensures (d + b) + k == d + (b + k)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_13533","instance":13533,"id":183532,"goal":"lemma MulComm_13533(y: real, x: real)\n ensures y * x == x * y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_13534","instance":13534,"id":183533,"goal":"lemma MulAssoc_13534(y: int, c: int, n: int)\n ensures (y * c) * n == y * (c * n)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_13535","instance":13535,"id":183534,"goal":"lemma Distrib_13535(x: nat, b: nat, i: nat)\n ensures x * (b + i) == x * b + x * i\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_13536","instance":13536,"id":183535,"goal":"lemma AddZero_13536(m: real)\n ensures m + 0 == m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_13537","instance":13537,"id":183536,"goal":"lemma MulOne_13537(m: int)\n ensures m * 1 == m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_13538","instance":13538,"id":183537,"goal":"lemma MulZero_13538(d: nat)\n ensures d * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_13539","instance":13539,"id":183538,"goal":"lemma LeRefl_13539(b: real)\n ensures b <= b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_13540","instance":13540,"id":183539,"goal":"lemma LeTrans_13540(y: int, n: int, k: int)\n requires y <= n && n <= k\n ensures y <= k\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_13541","instance":13541,"id":183540,"goal":"lemma AddMono_13541(k: nat, x: nat, n: nat)\n requires k <= x\n ensures k + n <= x + n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_13542","instance":13542,"id":183541,"goal":"lemma Abs_Nonneg_13542(x: real)\n ensures (if x >= 0 then x else -x) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_13543","instance":13543,"id":183542,"goal":"lemma DivMod_13543(y: int, n: int)\n requires n > 0\n ensures y == n * (y / n) + (y % n)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_13544","instance":13544,"id":183543,"goal":"lemma ModBounds_13544(i: nat, y: nat)\n requires y > 0\n ensures 0 <= i % y < y\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_13545","instance":13545,"id":183544,"goal":"lemma Square_Nonneg_13545(n: real)\n ensures n * n >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_13546","instance":13546,"id":183545,"goal":"lemma AddComm_13546(z: int, d: int)\n ensures z + d == d + z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_13547","instance":13547,"id":183546,"goal":"lemma AddAssoc_13547(i: nat, n: nat, k: nat)\n ensures (i + n) + k == i + (n + k)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_13548","instance":13548,"id":183547,"goal":"lemma MulComm_13548(i: real, d: real)\n ensures i * d == d * i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_13549","instance":13549,"id":183548,"goal":"lemma MulAssoc_13549(x: int, i: int, c: int)\n ensures (x * i) * c == x * (i * c)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_13550","instance":13550,"id":183549,"goal":"lemma Distrib_13550(z: nat, n: nat, m: nat)\n ensures z * (n + m) == z * n + z * m\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_13551","instance":13551,"id":183550,"goal":"lemma AddZero_13551(i: real)\n ensures i + 0 == i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_13552","instance":13552,"id":183551,"goal":"lemma MulOne_13552(n: int)\n ensures n * 1 == n\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_13553","instance":13553,"id":183552,"goal":"lemma MulZero_13553(k: nat)\n ensures k * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_13554","instance":13554,"id":183553,"goal":"lemma LeRefl_13554(d: real)\n ensures d <= d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_13555","instance":13555,"id":183554,"goal":"lemma LeTrans_13555(z: int, x: int, c: int)\n requires z <= x && x <= c\n ensures z <= c\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_13556","instance":13556,"id":183555,"goal":"lemma AddMono_13556(d: nat, m: nat, y: nat)\n requires d <= m\n ensures d + y <= m + y\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_13557","instance":13557,"id":183556,"goal":"lemma Abs_Nonneg_13557(j: real)\n ensures (if j >= 0 then j else -j) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_13558","instance":13558,"id":183557,"goal":"lemma DivMod_13558(c: int, x: int)\n requires x > 0\n ensures c == x * (c / x) + (c % x)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_13559","instance":13559,"id":183558,"goal":"lemma ModBounds_13559(k: nat, m: nat)\n requires m > 0\n ensures 0 <= k % m < m\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_13560","instance":13560,"id":183559,"goal":"lemma Square_Nonneg_13560(y: real)\n ensures y * y >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_13561","instance":13561,"id":183560,"goal":"lemma AddComm_13561(c: int, n: int)\n ensures c + n == n + c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_13562","instance":13562,"id":183561,"goal":"lemma AddAssoc_13562(k: nat, a: nat, m: nat)\n ensures (k + a) + m == k + (a + m)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_13563","instance":13563,"id":183562,"goal":"lemma MulComm_13563(m: real, n: real)\n ensures m * n == n * m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_13564","instance":13564,"id":183563,"goal":"lemma MulAssoc_13564(k: int, d: int, i: int)\n ensures (k * d) * i == k * (d * i)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_13565","instance":13565,"id":183564,"goal":"lemma Distrib_13565(d: nat, j: nat, m: nat)\n ensures d * (j + m) == d * j + d * m\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_13566","instance":13566,"id":183565,"goal":"lemma AddZero_13566(k: real)\n ensures k + 0 == k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_13567","instance":13567,"id":183566,"goal":"lemma MulOne_13567(i: int)\n ensures i * 1 == i\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_13568","instance":13568,"id":183567,"goal":"lemma MulZero_13568(y: nat)\n ensures y * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_13569","instance":13569,"id":183568,"goal":"lemma LeRefl_13569(x: real)\n ensures x <= x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_13570","instance":13570,"id":183569,"goal":"lemma LeTrans_13570(n: int, y: int, x: int)\n requires n <= y && y <= x\n ensures n <= x\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_13571","instance":13571,"id":183570,"goal":"lemma AddMono_13571(z: nat, k: nat, j: nat)\n requires z <= k\n ensures z + j <= k + j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_13572","instance":13572,"id":183571,"goal":"lemma Abs_Nonneg_13572(i: real)\n ensures (if i >= 0 then i else -i) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_13573","instance":13573,"id":183572,"goal":"lemma DivMod_13573(b: int, x: int)\n requires x > 0\n ensures b == x * (b / x) + (b % x)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_13574","instance":13574,"id":183573,"goal":"lemma ModBounds_13574(c: nat, i: nat)\n requires i > 0\n ensures 0 <= c % i < i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_13575","instance":13575,"id":183574,"goal":"lemma Square_Nonneg_13575(z: real)\n ensures z * z >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_13576","instance":13576,"id":183575,"goal":"lemma AddComm_13576(m: int, n: int)\n ensures m + n == n + m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_13577","instance":13577,"id":183576,"goal":"lemma AddAssoc_13577(m: nat, b: nat, n: nat)\n ensures (m + b) + n == m + (b + n)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_13578","instance":13578,"id":183577,"goal":"lemma MulComm_13578(n: real, d: real)\n ensures n * d == d * n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_13579","instance":13579,"id":183578,"goal":"lemma MulAssoc_13579(m: int, a: int, d: int)\n ensures (m * a) * d == m * (a * d)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_13580","instance":13580,"id":183579,"goal":"lemma Distrib_13580(z: nat, c: nat, m: nat)\n ensures z * (c + m) == z * c + z * m\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_13581","instance":13581,"id":183580,"goal":"lemma AddZero_13581(c: real)\n ensures c + 0 == c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_13582","instance":13582,"id":183581,"goal":"lemma MulOne_13582(a: int)\n ensures a * 1 == a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_13583","instance":13583,"id":183582,"goal":"lemma MulZero_13583(i: nat)\n ensures i * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_13584","instance":13584,"id":183583,"goal":"lemma LeRefl_13584(k: real)\n ensures k <= k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_13585","instance":13585,"id":183584,"goal":"lemma LeTrans_13585(c: int, d: int, n: int)\n requires c <= d && d <= n\n ensures c <= n\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_13586","instance":13586,"id":183585,"goal":"lemma AddMono_13586(y: nat, z: nat, n: nat)\n requires y <= z\n ensures y + n <= z + n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_13587","instance":13587,"id":183586,"goal":"lemma Abs_Nonneg_13587(x: real)\n ensures (if x >= 0 then x else -x) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_13588","instance":13588,"id":183587,"goal":"lemma DivMod_13588(y: int, a: int)\n requires a > 0\n ensures y == a * (y / a) + (y % a)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_13589","instance":13589,"id":183588,"goal":"lemma ModBounds_13589(a: nat, m: nat)\n requires m > 0\n ensures 0 <= a % m < m\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_13590","instance":13590,"id":183589,"goal":"lemma Square_Nonneg_13590(d: real)\n ensures d * d >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_13591","instance":13591,"id":183590,"goal":"lemma AddComm_13591(d: int, y: int)\n ensures d + y == y + d\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_13592","instance":13592,"id":183591,"goal":"lemma AddAssoc_13592(j: nat, k: nat, x: nat)\n ensures (j + k) + x == j + (k + x)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_13593","instance":13593,"id":183592,"goal":"lemma MulComm_13593(i: real, j: real)\n ensures i * j == j * i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_13594","instance":13594,"id":183593,"goal":"lemma MulAssoc_13594(j: int, d: int, a: int)\n ensures (j * d) * a == j * (d * a)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_13595","instance":13595,"id":183594,"goal":"lemma Distrib_13595(y: nat, b: nat, n: nat)\n ensures y * (b + n) == y * b + y * n\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_13596","instance":13596,"id":183595,"goal":"lemma AddZero_13596(y: real)\n ensures y + 0 == y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_13597","instance":13597,"id":183596,"goal":"lemma MulOne_13597(a: int)\n ensures a * 1 == a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_13598","instance":13598,"id":183597,"goal":"lemma MulZero_13598(d: nat)\n ensures d * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_13599","instance":13599,"id":183598,"goal":"lemma LeRefl_13599(a: real)\n ensures a <= a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_13600","instance":13600,"id":183599,"goal":"lemma LeTrans_13600(c: int, m: int, n: int)\n requires c <= m && m <= n\n ensures c <= n\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_13601","instance":13601,"id":183600,"goal":"lemma AddMono_13601(k: nat, z: nat, c: nat)\n requires k <= z\n ensures k + c <= z + c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_13602","instance":13602,"id":183601,"goal":"lemma Abs_Nonneg_13602(m: real)\n ensures (if m >= 0 then m else -m) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_13603","instance":13603,"id":183602,"goal":"lemma DivMod_13603(x: int, c: int)\n requires c > 0\n ensures x == c * (x / c) + (x % c)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_13604","instance":13604,"id":183603,"goal":"lemma ModBounds_13604(d: nat, i: nat)\n requires i > 0\n ensures 0 <= d % i < i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_13605","instance":13605,"id":183604,"goal":"lemma Square_Nonneg_13605(n: real)\n ensures n * n >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_13606","instance":13606,"id":183605,"goal":"lemma AddComm_13606(i: int, k: int)\n ensures i + k == k + i\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_13607","instance":13607,"id":183606,"goal":"lemma AddAssoc_13607(n: nat, d: nat, j: nat)\n ensures (n + d) + j == n + (d + j)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_13608","instance":13608,"id":183607,"goal":"lemma MulComm_13608(b: real, j: real)\n ensures b * j == j * b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_13609","instance":13609,"id":183608,"goal":"lemma MulAssoc_13609(y: int, c: int, m: int)\n ensures (y * c) * m == y * (c * m)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_13610","instance":13610,"id":183609,"goal":"lemma Distrib_13610(n: nat, j: nat, z: nat)\n ensures n * (j + z) == n * j + n * z\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_13611","instance":13611,"id":183610,"goal":"lemma AddZero_13611(x: real)\n ensures x + 0 == x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_13612","instance":13612,"id":183611,"goal":"lemma MulOne_13612(z: int)\n ensures z * 1 == z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_13613","instance":13613,"id":183612,"goal":"lemma MulZero_13613(c: nat)\n ensures c * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_13614","instance":13614,"id":183613,"goal":"lemma LeRefl_13614(y: real)\n ensures y <= y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_13615","instance":13615,"id":183614,"goal":"lemma LeTrans_13615(m: int, z: int, y: int)\n requires m <= z && z <= y\n ensures m <= y\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_13616","instance":13616,"id":183615,"goal":"lemma AddMono_13616(k: nat, c: nat, b: nat)\n requires k <= c\n ensures k + b <= c + b\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_13617","instance":13617,"id":183616,"goal":"lemma Abs_Nonneg_13617(y: real)\n ensures (if y >= 0 then y else -y) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_13618","instance":13618,"id":183617,"goal":"lemma DivMod_13618(n: int, z: int)\n requires z > 0\n ensures n == z * (n / z) + (n % z)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_13619","instance":13619,"id":183618,"goal":"lemma ModBounds_13619(z: nat, y: nat)\n requires y > 0\n ensures 0 <= z % y < y\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_13620","instance":13620,"id":183619,"goal":"lemma Square_Nonneg_13620(a: real)\n ensures a * a >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_13621","instance":13621,"id":183620,"goal":"lemma AddComm_13621(i: int, z: int)\n ensures i + z == z + i\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_13622","instance":13622,"id":183621,"goal":"lemma AddAssoc_13622(i: nat, d: nat, a: nat)\n ensures (i + d) + a == i + (d + a)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_13623","instance":13623,"id":183622,"goal":"lemma MulComm_13623(n: real, c: real)\n ensures n * c == c * n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_13624","instance":13624,"id":183623,"goal":"lemma MulAssoc_13624(k: int, x: int, y: int)\n ensures (k * x) * y == k * (x * y)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_13625","instance":13625,"id":183624,"goal":"lemma Distrib_13625(x: nat, c: nat, b: nat)\n ensures x * (c + b) == x * c + x * b\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_13626","instance":13626,"id":183625,"goal":"lemma AddZero_13626(a: real)\n ensures a + 0 == a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_13627","instance":13627,"id":183626,"goal":"lemma MulOne_13627(z: int)\n ensures z * 1 == z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_13628","instance":13628,"id":183627,"goal":"lemma MulZero_13628(i: nat)\n ensures i * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_13629","instance":13629,"id":183628,"goal":"lemma LeRefl_13629(k: real)\n ensures k <= k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_13630","instance":13630,"id":183629,"goal":"lemma LeTrans_13630(b: int, z: int, a: int)\n requires b <= z && z <= a\n ensures b <= a\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_13631","instance":13631,"id":183630,"goal":"lemma AddMono_13631(m: nat, n: nat, y: nat)\n requires m <= n\n ensures m + y <= n + y\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_13632","instance":13632,"id":183631,"goal":"lemma Abs_Nonneg_13632(m: real)\n ensures (if m >= 0 then m else -m) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_13633","instance":13633,"id":183632,"goal":"lemma DivMod_13633(n: int, j: int)\n requires j > 0\n ensures n == j * (n / j) + (n % j)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_13634","instance":13634,"id":183633,"goal":"lemma ModBounds_13634(j: nat, d: nat)\n requires d > 0\n ensures 0 <= j % d < d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_13635","instance":13635,"id":183634,"goal":"lemma Square_Nonneg_13635(j: real)\n ensures j * j >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_13636","instance":13636,"id":183635,"goal":"lemma AddComm_13636(z: int, a: int)\n ensures z + a == a + z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_13637","instance":13637,"id":183636,"goal":"lemma AddAssoc_13637(a: nat, j: nat, y: nat)\n ensures (a + j) + y == a + (j + y)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_13638","instance":13638,"id":183637,"goal":"lemma MulComm_13638(k: real, n: real)\n ensures k * n == n * k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_13639","instance":13639,"id":183638,"goal":"lemma MulAssoc_13639(d: int, k: int, a: int)\n ensures (d * k) * a == d * (k * a)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_13640","instance":13640,"id":183639,"goal":"lemma Distrib_13640(d: nat, k: nat, i: nat)\n ensures d * (k + i) == d * k + d * i\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_13641","instance":13641,"id":183640,"goal":"lemma AddZero_13641(z: real)\n ensures z + 0 == z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_13642","instance":13642,"id":183641,"goal":"lemma MulOne_13642(k: int)\n ensures k * 1 == k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_13643","instance":13643,"id":183642,"goal":"lemma MulZero_13643(j: nat)\n ensures j * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_13644","instance":13644,"id":183643,"goal":"lemma LeRefl_13644(m: real)\n ensures m <= m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_13645","instance":13645,"id":183644,"goal":"lemma LeTrans_13645(i: int, k: int, y: int)\n requires i <= k && k <= y\n ensures i <= y\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_13646","instance":13646,"id":183645,"goal":"lemma AddMono_13646(j: nat, b: nat, c: nat)\n requires j <= b\n ensures j + c <= b + c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_13647","instance":13647,"id":183646,"goal":"lemma Abs_Nonneg_13647(x: real)\n ensures (if x >= 0 then x else -x) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_13648","instance":13648,"id":183647,"goal":"lemma DivMod_13648(m: int, b: int)\n requires b > 0\n ensures m == b * (m / b) + (m % b)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_13649","instance":13649,"id":183648,"goal":"lemma ModBounds_13649(a: nat, c: nat)\n requires c > 0\n ensures 0 <= a % c < c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_13650","instance":13650,"id":183649,"goal":"lemma Square_Nonneg_13650(d: real)\n ensures d * d >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_13651","instance":13651,"id":183650,"goal":"lemma AddComm_13651(b: int, i: int)\n ensures b + i == i + b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_13652","instance":13652,"id":183651,"goal":"lemma AddAssoc_13652(m: nat, d: nat, j: nat)\n ensures (m + d) + j == m + (d + j)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_13653","instance":13653,"id":183652,"goal":"lemma MulComm_13653(n: real, b: real)\n ensures n * b == b * n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_13654","instance":13654,"id":183653,"goal":"lemma MulAssoc_13654(y: int, z: int, m: int)\n ensures (y * z) * m == y * (z * m)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_13655","instance":13655,"id":183654,"goal":"lemma Distrib_13655(x: nat, y: nat, k: nat)\n ensures x * (y + k) == x * y + x * k\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_13656","instance":13656,"id":183655,"goal":"lemma AddZero_13656(m: real)\n ensures m + 0 == m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_13657","instance":13657,"id":183656,"goal":"lemma MulOne_13657(c: int)\n ensures c * 1 == c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_13658","instance":13658,"id":183657,"goal":"lemma MulZero_13658(y: nat)\n ensures y * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_13659","instance":13659,"id":183658,"goal":"lemma LeRefl_13659(m: real)\n ensures m <= m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_13660","instance":13660,"id":183659,"goal":"lemma LeTrans_13660(y: int, b: int, n: int)\n requires y <= b && b <= n\n ensures y <= n\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_13661","instance":13661,"id":183660,"goal":"lemma AddMono_13661(b: nat, m: nat, k: nat)\n requires b <= m\n ensures b + k <= m + k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_13662","instance":13662,"id":183661,"goal":"lemma Abs_Nonneg_13662(d: real)\n ensures (if d >= 0 then d else -d) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_13663","instance":13663,"id":183662,"goal":"lemma DivMod_13663(i: int, m: int)\n requires m > 0\n ensures i == m * (i / m) + (i % m)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_13664","instance":13664,"id":183663,"goal":"lemma ModBounds_13664(m: nat, b: nat)\n requires b > 0\n ensures 0 <= m % b < b\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_13665","instance":13665,"id":183664,"goal":"lemma Square_Nonneg_13665(i: real)\n ensures i * i >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_13666","instance":13666,"id":183665,"goal":"lemma AddComm_13666(n: int, c: int)\n ensures n + c == c + n\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_13667","instance":13667,"id":183666,"goal":"lemma AddAssoc_13667(m: nat, n: nat, a: nat)\n ensures (m + n) + a == m + (n + a)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_13668","instance":13668,"id":183667,"goal":"lemma MulComm_13668(b: real, j: real)\n ensures b * j == j * b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_13669","instance":13669,"id":183668,"goal":"lemma MulAssoc_13669(c: int, d: int, k: int)\n ensures (c * d) * k == c * (d * k)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_13670","instance":13670,"id":183669,"goal":"lemma Distrib_13670(d: nat, j: nat, c: nat)\n ensures d * (j + c) == d * j + d * c\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_13671","instance":13671,"id":183670,"goal":"lemma AddZero_13671(j: real)\n ensures j + 0 == j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_13672","instance":13672,"id":183671,"goal":"lemma MulOne_13672(m: int)\n ensures m * 1 == m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_13673","instance":13673,"id":183672,"goal":"lemma MulZero_13673(d: nat)\n ensures d * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_13674","instance":13674,"id":183673,"goal":"lemma LeRefl_13674(k: real)\n ensures k <= k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_13675","instance":13675,"id":183674,"goal":"lemma LeTrans_13675(k: int, m: int, i: int)\n requires k <= m && m <= i\n ensures k <= i\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_13676","instance":13676,"id":183675,"goal":"lemma AddMono_13676(a: nat, n: nat, m: nat)\n requires a <= n\n ensures a + m <= n + m\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_13677","instance":13677,"id":183676,"goal":"lemma Abs_Nonneg_13677(c: real)\n ensures (if c >= 0 then c else -c) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_13678","instance":13678,"id":183677,"goal":"lemma DivMod_13678(b: int, d: int)\n requires d > 0\n ensures b == d * (b / d) + (b % d)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_13679","instance":13679,"id":183678,"goal":"lemma ModBounds_13679(z: nat, a: nat)\n requires a > 0\n ensures 0 <= z % a < a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_13680","instance":13680,"id":183679,"goal":"lemma Square_Nonneg_13680(x: real)\n ensures x * x >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_13681","instance":13681,"id":183680,"goal":"lemma AddComm_13681(b: int, i: int)\n ensures b + i == i + b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_13682","instance":13682,"id":183681,"goal":"lemma AddAssoc_13682(i: nat, j: nat, z: nat)\n ensures (i + j) + z == i + (j + z)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_13683","instance":13683,"id":183682,"goal":"lemma MulComm_13683(c: real, n: real)\n ensures c * n == n * c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_13684","instance":13684,"id":183683,"goal":"lemma MulAssoc_13684(k: int, x: int, d: int)\n ensures (k * x) * d == k * (x * d)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_13685","instance":13685,"id":183684,"goal":"lemma Distrib_13685(c: nat, k: nat, z: nat)\n ensures c * (k + z) == c * k + c * z\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_13686","instance":13686,"id":183685,"goal":"lemma AddZero_13686(c: real)\n ensures c + 0 == c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_13687","instance":13687,"id":183686,"goal":"lemma MulOne_13687(k: int)\n ensures k * 1 == k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_13688","instance":13688,"id":183687,"goal":"lemma MulZero_13688(z: nat)\n ensures z * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_13689","instance":13689,"id":183688,"goal":"lemma LeRefl_13689(d: real)\n ensures d <= d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_13690","instance":13690,"id":183689,"goal":"lemma LeTrans_13690(a: int, c: int, j: int)\n requires a <= c && c <= j\n ensures a <= j\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_13691","instance":13691,"id":183690,"goal":"lemma AddMono_13691(b: nat, y: nat, c: nat)\n requires b <= y\n ensures b + c <= y + c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_13692","instance":13692,"id":183691,"goal":"lemma Abs_Nonneg_13692(y: real)\n ensures (if y >= 0 then y else -y) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_13693","instance":13693,"id":183692,"goal":"lemma DivMod_13693(m: int, a: int)\n requires a > 0\n ensures m == a * (m / a) + (m % a)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_13694","instance":13694,"id":183693,"goal":"lemma ModBounds_13694(a: nat, n: nat)\n requires n > 0\n ensures 0 <= a % n < n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_13695","instance":13695,"id":183694,"goal":"lemma Square_Nonneg_13695(k: real)\n ensures k * k >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_13696","instance":13696,"id":183695,"goal":"lemma AddComm_13696(c: int, y: int)\n ensures c + y == y + c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_13697","instance":13697,"id":183696,"goal":"lemma AddAssoc_13697(b: nat, k: nat, z: nat)\n ensures (b + k) + z == b + (k + z)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_13698","instance":13698,"id":183697,"goal":"lemma MulComm_13698(m: real, z: real)\n ensures m * z == z * m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_13699","instance":13699,"id":183698,"goal":"lemma MulAssoc_13699(j: int, c: int, y: int)\n ensures (j * c) * y == j * (c * y)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_13700","instance":13700,"id":183699,"goal":"lemma Distrib_13700(b: nat, c: nat, i: nat)\n ensures b * (c + i) == b * c + b * i\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_13701","instance":13701,"id":183700,"goal":"lemma AddZero_13701(m: real)\n ensures m + 0 == m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_13702","instance":13702,"id":183701,"goal":"lemma MulOne_13702(d: int)\n ensures d * 1 == d\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_13703","instance":13703,"id":183702,"goal":"lemma MulZero_13703(c: nat)\n ensures c * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_13704","instance":13704,"id":183703,"goal":"lemma LeRefl_13704(a: real)\n ensures a <= a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_13705","instance":13705,"id":183704,"goal":"lemma LeTrans_13705(k: int, j: int, y: int)\n requires k <= j && j <= y\n ensures k <= y\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_13706","instance":13706,"id":183705,"goal":"lemma AddMono_13706(z: nat, k: nat, y: nat)\n requires z <= k\n ensures z + y <= k + y\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_13707","instance":13707,"id":183706,"goal":"lemma Abs_Nonneg_13707(y: real)\n ensures (if y >= 0 then y else -y) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_13708","instance":13708,"id":183707,"goal":"lemma DivMod_13708(m: int, d: int)\n requires d > 0\n ensures m == d * (m / d) + (m % d)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_13709","instance":13709,"id":183708,"goal":"lemma ModBounds_13709(j: nat, y: nat)\n requires y > 0\n ensures 0 <= j % y < y\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_13710","instance":13710,"id":183709,"goal":"lemma Square_Nonneg_13710(y: real)\n ensures y * y >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_13711","instance":13711,"id":183710,"goal":"lemma AddComm_13711(a: int, b: int)\n ensures a + b == b + a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_13712","instance":13712,"id":183711,"goal":"lemma AddAssoc_13712(k: nat, y: nat, d: nat)\n ensures (k + y) + d == k + (y + d)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_13713","instance":13713,"id":183712,"goal":"lemma MulComm_13713(c: real, m: real)\n ensures c * m == m * c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_13714","instance":13714,"id":183713,"goal":"lemma MulAssoc_13714(j: int, y: int, i: int)\n ensures (j * y) * i == j * (y * i)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_13715","instance":13715,"id":183714,"goal":"lemma Distrib_13715(j: nat, y: nat, i: nat)\n ensures j * (y + i) == j * y + j * i\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_13716","instance":13716,"id":183715,"goal":"lemma AddZero_13716(n: real)\n ensures n + 0 == n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_13717","instance":13717,"id":183716,"goal":"lemma MulOne_13717(i: int)\n ensures i * 1 == i\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_13718","instance":13718,"id":183717,"goal":"lemma MulZero_13718(z: nat)\n ensures z * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_13719","instance":13719,"id":183718,"goal":"lemma LeRefl_13719(a: real)\n ensures a <= a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_13720","instance":13720,"id":183719,"goal":"lemma LeTrans_13720(z: int, k: int, a: int)\n requires z <= k && k <= a\n ensures z <= a\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_13721","instance":13721,"id":183720,"goal":"lemma AddMono_13721(d: nat, m: nat, y: nat)\n requires d <= m\n ensures d + y <= m + y\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_13722","instance":13722,"id":183721,"goal":"lemma Abs_Nonneg_13722(x: real)\n ensures (if x >= 0 then x else -x) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_13723","instance":13723,"id":183722,"goal":"lemma DivMod_13723(b: int, m: int)\n requires m > 0\n ensures b == m * (b / m) + (b % m)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_13724","instance":13724,"id":183723,"goal":"lemma ModBounds_13724(k: nat, a: nat)\n requires a > 0\n ensures 0 <= k % a < a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_13725","instance":13725,"id":183724,"goal":"lemma Square_Nonneg_13725(d: real)\n ensures d * d >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_13726","instance":13726,"id":183725,"goal":"lemma AddComm_13726(j: int, m: int)\n ensures j + m == m + j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_13727","instance":13727,"id":183726,"goal":"lemma AddAssoc_13727(c: nat, n: nat, x: nat)\n ensures (c + n) + x == c + (n + x)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_13728","instance":13728,"id":183727,"goal":"lemma MulComm_13728(c: real, x: real)\n ensures c * x == x * c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_13729","instance":13729,"id":183728,"goal":"lemma MulAssoc_13729(c: int, a: int, d: int)\n ensures (c * a) * d == c * (a * d)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_13730","instance":13730,"id":183729,"goal":"lemma Distrib_13730(i: nat, y: nat, m: nat)\n ensures i * (y + m) == i * y + i * m\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_13731","instance":13731,"id":183730,"goal":"lemma AddZero_13731(z: real)\n ensures z + 0 == z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_13732","instance":13732,"id":183731,"goal":"lemma MulOne_13732(y: int)\n ensures y * 1 == y\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_13733","instance":13733,"id":183732,"goal":"lemma MulZero_13733(c: nat)\n ensures c * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_13734","instance":13734,"id":183733,"goal":"lemma LeRefl_13734(b: real)\n ensures b <= b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_13735","instance":13735,"id":183734,"goal":"lemma LeTrans_13735(a: int, j: int, i: int)\n requires a <= j && j <= i\n ensures a <= i\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_13736","instance":13736,"id":183735,"goal":"lemma AddMono_13736(b: nat, c: nat, d: nat)\n requires b <= c\n ensures b + d <= c + d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_13737","instance":13737,"id":183736,"goal":"lemma Abs_Nonneg_13737(x: real)\n ensures (if x >= 0 then x else -x) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_13738","instance":13738,"id":183737,"goal":"lemma DivMod_13738(b: int, z: int)\n requires z > 0\n ensures b == z * (b / z) + (b % z)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_13739","instance":13739,"id":183738,"goal":"lemma ModBounds_13739(b: nat, x: nat)\n requires x > 0\n ensures 0 <= b % x < x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_13740","instance":13740,"id":183739,"goal":"lemma Square_Nonneg_13740(i: real)\n ensures i * i >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_13741","instance":13741,"id":183740,"goal":"lemma AddComm_13741(b: int, a: int)\n ensures b + a == a + b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_13742","instance":13742,"id":183741,"goal":"lemma AddAssoc_13742(z: nat, i: nat, j: nat)\n ensures (z + i) + j == z + (i + j)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_13743","instance":13743,"id":183742,"goal":"lemma MulComm_13743(n: real, a: real)\n ensures n * a == a * n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_13744","instance":13744,"id":183743,"goal":"lemma MulAssoc_13744(z: int, x: int, d: int)\n ensures (z * x) * d == z * (x * d)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_13745","instance":13745,"id":183744,"goal":"lemma Distrib_13745(y: nat, n: nat, x: nat)\n ensures y * (n + x) == y * n + y * x\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_13746","instance":13746,"id":183745,"goal":"lemma AddZero_13746(k: real)\n ensures k + 0 == k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_13747","instance":13747,"id":183746,"goal":"lemma MulOne_13747(b: int)\n ensures b * 1 == b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_13748","instance":13748,"id":183747,"goal":"lemma MulZero_13748(d: nat)\n ensures d * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_13749","instance":13749,"id":183748,"goal":"lemma LeRefl_13749(i: real)\n ensures i <= i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_13750","instance":13750,"id":183749,"goal":"lemma LeTrans_13750(y: int, i: int, x: int)\n requires y <= i && i <= x\n ensures y <= x\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_13751","instance":13751,"id":183750,"goal":"lemma AddMono_13751(b: nat, c: nat, y: nat)\n requires b <= c\n ensures b + y <= c + y\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_13752","instance":13752,"id":183751,"goal":"lemma Abs_Nonneg_13752(j: real)\n ensures (if j >= 0 then j else -j) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_13753","instance":13753,"id":183752,"goal":"lemma DivMod_13753(d: int, a: int)\n requires a > 0\n ensures d == a * (d / a) + (d % a)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_13754","instance":13754,"id":183753,"goal":"lemma ModBounds_13754(j: nat, x: nat)\n requires x > 0\n ensures 0 <= j % x < x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_13755","instance":13755,"id":183754,"goal":"lemma Square_Nonneg_13755(j: real)\n ensures j * j >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_13756","instance":13756,"id":183755,"goal":"lemma AddComm_13756(n: int, y: int)\n ensures n + y == y + n\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_13757","instance":13757,"id":183756,"goal":"lemma AddAssoc_13757(b: nat, i: nat, c: nat)\n ensures (b + i) + c == b + (i + c)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_13758","instance":13758,"id":183757,"goal":"lemma MulComm_13758(z: real, c: real)\n ensures z * c == c * z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_13759","instance":13759,"id":183758,"goal":"lemma MulAssoc_13759(d: int, a: int, i: int)\n ensures (d * a) * i == d * (a * i)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_13760","instance":13760,"id":183759,"goal":"lemma Distrib_13760(d: nat, k: nat, i: nat)\n ensures d * (k + i) == d * k + d * i\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_13761","instance":13761,"id":183760,"goal":"lemma AddZero_13761(k: real)\n ensures k + 0 == k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_13762","instance":13762,"id":183761,"goal":"lemma MulOne_13762(k: int)\n ensures k * 1 == k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_13763","instance":13763,"id":183762,"goal":"lemma MulZero_13763(x: nat)\n ensures x * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_13764","instance":13764,"id":183763,"goal":"lemma LeRefl_13764(y: real)\n ensures y <= y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_13765","instance":13765,"id":183764,"goal":"lemma LeTrans_13765(b: int, m: int, y: int)\n requires b <= m && m <= y\n ensures b <= y\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_13766","instance":13766,"id":183765,"goal":"lemma AddMono_13766(x: nat, d: nat, m: nat)\n requires x <= d\n ensures x + m <= d + m\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_13767","instance":13767,"id":183766,"goal":"lemma Abs_Nonneg_13767(n: real)\n ensures (if n >= 0 then n else -n) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_13768","instance":13768,"id":183767,"goal":"lemma DivMod_13768(y: int, x: int)\n requires x > 0\n ensures y == x * (y / x) + (y % x)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_13769","instance":13769,"id":183768,"goal":"lemma ModBounds_13769(j: nat, y: nat)\n requires y > 0\n ensures 0 <= j % y < y\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_13770","instance":13770,"id":183769,"goal":"lemma Square_Nonneg_13770(i: real)\n ensures i * i >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_13771","instance":13771,"id":183770,"goal":"lemma AddComm_13771(m: int, j: int)\n ensures m + j == j + m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_13772","instance":13772,"id":183771,"goal":"lemma AddAssoc_13772(k: nat, y: nat, a: nat)\n ensures (k + y) + a == k + (y + a)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_13773","instance":13773,"id":183772,"goal":"lemma MulComm_13773(b: real, x: real)\n ensures b * x == x * b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_13774","instance":13774,"id":183773,"goal":"lemma MulAssoc_13774(m: int, x: int, z: int)\n ensures (m * x) * z == m * (x * z)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_13775","instance":13775,"id":183774,"goal":"lemma Distrib_13775(k: nat, b: nat, m: nat)\n ensures k * (b + m) == k * b + k * m\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_13776","instance":13776,"id":183775,"goal":"lemma AddZero_13776(c: real)\n ensures c + 0 == c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_13777","instance":13777,"id":183776,"goal":"lemma MulOne_13777(b: int)\n ensures b * 1 == b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_13778","instance":13778,"id":183777,"goal":"lemma MulZero_13778(d: nat)\n ensures d * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_13779","instance":13779,"id":183778,"goal":"lemma LeRefl_13779(z: real)\n ensures z <= z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_13780","instance":13780,"id":183779,"goal":"lemma LeTrans_13780(k: int, b: int, d: int)\n requires k <= b && b <= d\n ensures k <= d\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_13781","instance":13781,"id":183780,"goal":"lemma AddMono_13781(z: nat, n: nat, x: nat)\n requires z <= n\n ensures z + x <= n + x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_13782","instance":13782,"id":183781,"goal":"lemma Abs_Nonneg_13782(a: real)\n ensures (if a >= 0 then a else -a) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_13783","instance":13783,"id":183782,"goal":"lemma DivMod_13783(z: int, d: int)\n requires d > 0\n ensures z == d * (z / d) + (z % d)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_13784","instance":13784,"id":183783,"goal":"lemma ModBounds_13784(a: nat, j: nat)\n requires j > 0\n ensures 0 <= a % j < j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_13785","instance":13785,"id":183784,"goal":"lemma Square_Nonneg_13785(i: real)\n ensures i * i >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_13786","instance":13786,"id":183785,"goal":"lemma AddComm_13786(c: int, y: int)\n ensures c + y == y + c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_13787","instance":13787,"id":183786,"goal":"lemma AddAssoc_13787(i: nat, y: nat, k: nat)\n ensures (i + y) + k == i + (y + k)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_13788","instance":13788,"id":183787,"goal":"lemma MulComm_13788(i: real, a: real)\n ensures i * a == a * i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_13789","instance":13789,"id":183788,"goal":"lemma MulAssoc_13789(k: int, x: int, c: int)\n ensures (k * x) * c == k * (x * c)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_13790","instance":13790,"id":183789,"goal":"lemma Distrib_13790(a: nat, i: nat, x: nat)\n ensures a * (i + x) == a * i + a * x\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_13791","instance":13791,"id":183790,"goal":"lemma AddZero_13791(z: real)\n ensures z + 0 == z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_13792","instance":13792,"id":183791,"goal":"lemma MulOne_13792(m: int)\n ensures m * 1 == m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_13793","instance":13793,"id":183792,"goal":"lemma MulZero_13793(b: nat)\n ensures b * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_13794","instance":13794,"id":183793,"goal":"lemma LeRefl_13794(m: real)\n ensures m <= m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_13795","instance":13795,"id":183794,"goal":"lemma LeTrans_13795(z: int, m: int, n: int)\n requires z <= m && m <= n\n ensures z <= n\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_13796","instance":13796,"id":183795,"goal":"lemma AddMono_13796(j: nat, c: nat, x: nat)\n requires j <= c\n ensures j + x <= c + x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_13797","instance":13797,"id":183796,"goal":"lemma Abs_Nonneg_13797(z: real)\n ensures (if z >= 0 then z else -z) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_13798","instance":13798,"id":183797,"goal":"lemma DivMod_13798(a: int, i: int)\n requires i > 0\n ensures a == i * (a / i) + (a % i)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_13799","instance":13799,"id":183798,"goal":"lemma ModBounds_13799(c: nat, i: nat)\n requires i > 0\n ensures 0 <= c % i < i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_13800","instance":13800,"id":183799,"goal":"lemma Square_Nonneg_13800(m: real)\n ensures m * m >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_13801","instance":13801,"id":183800,"goal":"lemma AddComm_13801(n: int, k: int)\n ensures n + k == k + n\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_13802","instance":13802,"id":183801,"goal":"lemma AddAssoc_13802(m: nat, z: nat, n: nat)\n ensures (m + z) + n == m + (z + n)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_13803","instance":13803,"id":183802,"goal":"lemma MulComm_13803(n: real, d: real)\n ensures n * d == d * n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_13804","instance":13804,"id":183803,"goal":"lemma MulAssoc_13804(z: int, m: int, y: int)\n ensures (z * m) * y == z * (m * y)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_13805","instance":13805,"id":183804,"goal":"lemma Distrib_13805(y: nat, z: nat, d: nat)\n ensures y * (z + d) == y * z + y * d\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_13806","instance":13806,"id":183805,"goal":"lemma AddZero_13806(k: real)\n ensures k + 0 == k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_13807","instance":13807,"id":183806,"goal":"lemma MulOne_13807(i: int)\n ensures i * 1 == i\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_13808","instance":13808,"id":183807,"goal":"lemma MulZero_13808(j: nat)\n ensures j * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_13809","instance":13809,"id":183808,"goal":"lemma LeRefl_13809(m: real)\n ensures m <= m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_13810","instance":13810,"id":183809,"goal":"lemma LeTrans_13810(a: int, x: int, c: int)\n requires a <= x && x <= c\n ensures a <= c\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_13811","instance":13811,"id":183810,"goal":"lemma AddMono_13811(d: nat, i: nat, a: nat)\n requires d <= i\n ensures d + a <= i + a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_13812","instance":13812,"id":183811,"goal":"lemma Abs_Nonneg_13812(m: real)\n ensures (if m >= 0 then m else -m) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_13813","instance":13813,"id":183812,"goal":"lemma DivMod_13813(a: int, x: int)\n requires x > 0\n ensures a == x * (a / x) + (a % x)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_13814","instance":13814,"id":183813,"goal":"lemma ModBounds_13814(a: nat, m: nat)\n requires m > 0\n ensures 0 <= a % m < m\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_13815","instance":13815,"id":183814,"goal":"lemma Square_Nonneg_13815(a: real)\n ensures a * a >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_13816","instance":13816,"id":183815,"goal":"lemma AddComm_13816(z: int, k: int)\n ensures z + k == k + z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_13817","instance":13817,"id":183816,"goal":"lemma AddAssoc_13817(z: nat, k: nat, b: nat)\n ensures (z + k) + b == z + (k + b)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_13818","instance":13818,"id":183817,"goal":"lemma MulComm_13818(j: real, x: real)\n ensures j * x == x * j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_13819","instance":13819,"id":183818,"goal":"lemma MulAssoc_13819(m: int, k: int, i: int)\n ensures (m * k) * i == m * (k * i)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_13820","instance":13820,"id":183819,"goal":"lemma Distrib_13820(b: nat, x: nat, i: nat)\n ensures b * (x + i) == b * x + b * i\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_13821","instance":13821,"id":183820,"goal":"lemma AddZero_13821(n: real)\n ensures n + 0 == n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_13822","instance":13822,"id":183821,"goal":"lemma MulOne_13822(j: int)\n ensures j * 1 == j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_13823","instance":13823,"id":183822,"goal":"lemma MulZero_13823(y: nat)\n ensures y * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_13824","instance":13824,"id":183823,"goal":"lemma LeRefl_13824(a: real)\n ensures a <= a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_13825","instance":13825,"id":183824,"goal":"lemma LeTrans_13825(n: int, d: int, z: int)\n requires n <= d && d <= z\n ensures n <= z\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_13826","instance":13826,"id":183825,"goal":"lemma AddMono_13826(k: nat, d: nat, y: nat)\n requires k <= d\n ensures k + y <= d + y\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_13827","instance":13827,"id":183826,"goal":"lemma Abs_Nonneg_13827(x: real)\n ensures (if x >= 0 then x else -x) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_13828","instance":13828,"id":183827,"goal":"lemma DivMod_13828(m: int, j: int)\n requires j > 0\n ensures m == j * (m / j) + (m % j)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_13829","instance":13829,"id":183828,"goal":"lemma ModBounds_13829(n: nat, c: nat)\n requires c > 0\n ensures 0 <= n % c < c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_13830","instance":13830,"id":183829,"goal":"lemma Square_Nonneg_13830(a: real)\n ensures a * a >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_13831","instance":13831,"id":183830,"goal":"lemma AddComm_13831(a: int, c: int)\n ensures a + c == c + a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_13832","instance":13832,"id":183831,"goal":"lemma AddAssoc_13832(m: nat, z: nat, n: nat)\n ensures (m + z) + n == m + (z + n)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_13833","instance":13833,"id":183832,"goal":"lemma MulComm_13833(a: real, j: real)\n ensures a * j == j * a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_13834","instance":13834,"id":183833,"goal":"lemma MulAssoc_13834(k: int, n: int, b: int)\n ensures (k * n) * b == k * (n * b)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_13835","instance":13835,"id":183834,"goal":"lemma Distrib_13835(y: nat, x: nat, n: nat)\n ensures y * (x + n) == y * x + y * n\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_13836","instance":13836,"id":183835,"goal":"lemma AddZero_13836(d: real)\n ensures d + 0 == d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_13837","instance":13837,"id":183836,"goal":"lemma MulOne_13837(z: int)\n ensures z * 1 == z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_13838","instance":13838,"id":183837,"goal":"lemma MulZero_13838(y: nat)\n ensures y * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_13839","instance":13839,"id":183838,"goal":"lemma LeRefl_13839(x: real)\n ensures x <= x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_13840","instance":13840,"id":183839,"goal":"lemma LeTrans_13840(y: int, a: int, j: int)\n requires y <= a && a <= j\n ensures y <= j\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_13841","instance":13841,"id":183840,"goal":"lemma AddMono_13841(a: nat, k: nat, x: nat)\n requires a <= k\n ensures a + x <= k + x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_13842","instance":13842,"id":183841,"goal":"lemma Abs_Nonneg_13842(b: real)\n ensures (if b >= 0 then b else -b) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_13843","instance":13843,"id":183842,"goal":"lemma DivMod_13843(x: int, c: int)\n requires c > 0\n ensures x == c * (x / c) + (x % c)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_13844","instance":13844,"id":183843,"goal":"lemma ModBounds_13844(d: nat, j: nat)\n requires j > 0\n ensures 0 <= d % j < j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_13845","instance":13845,"id":183844,"goal":"lemma Square_Nonneg_13845(y: real)\n ensures y * y >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_13846","instance":13846,"id":183845,"goal":"lemma AddComm_13846(i: int, m: int)\n ensures i + m == m + i\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_13847","instance":13847,"id":183846,"goal":"lemma AddAssoc_13847(z: nat, i: nat, a: nat)\n ensures (z + i) + a == z + (i + a)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_13848","instance":13848,"id":183847,"goal":"lemma MulComm_13848(n: real, j: real)\n ensures n * j == j * n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_13849","instance":13849,"id":183848,"goal":"lemma MulAssoc_13849(x: int, i: int, j: int)\n ensures (x * i) * j == x * (i * j)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_13850","instance":13850,"id":183849,"goal":"lemma Distrib_13850(c: nat, i: nat, n: nat)\n ensures c * (i + n) == c * i + c * n\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_13851","instance":13851,"id":183850,"goal":"lemma AddZero_13851(k: real)\n ensures k + 0 == k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_13852","instance":13852,"id":183851,"goal":"lemma MulOne_13852(y: int)\n ensures y * 1 == y\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_13853","instance":13853,"id":183852,"goal":"lemma MulZero_13853(m: nat)\n ensures m * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_13854","instance":13854,"id":183853,"goal":"lemma LeRefl_13854(a: real)\n ensures a <= a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_13855","instance":13855,"id":183854,"goal":"lemma LeTrans_13855(z: int, i: int, j: int)\n requires z <= i && i <= j\n ensures z <= j\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_13856","instance":13856,"id":183855,"goal":"lemma AddMono_13856(m: nat, d: nat, y: nat)\n requires m <= d\n ensures m + y <= d + y\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_13857","instance":13857,"id":183856,"goal":"lemma Abs_Nonneg_13857(d: real)\n ensures (if d >= 0 then d else -d) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_13858","instance":13858,"id":183857,"goal":"lemma DivMod_13858(z: int, x: int)\n requires x > 0\n ensures z == x * (z / x) + (z % x)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_13859","instance":13859,"id":183858,"goal":"lemma ModBounds_13859(b: nat, n: nat)\n requires n > 0\n ensures 0 <= b % n < n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_13860","instance":13860,"id":183859,"goal":"lemma Square_Nonneg_13860(k: real)\n ensures k * k >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_13861","instance":13861,"id":183860,"goal":"lemma AddComm_13861(i: int, c: int)\n ensures i + c == c + i\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_13862","instance":13862,"id":183861,"goal":"lemma AddAssoc_13862(c: nat, n: nat, k: nat)\n ensures (c + n) + k == c + (n + k)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_13863","instance":13863,"id":183862,"goal":"lemma MulComm_13863(a: real, x: real)\n ensures a * x == x * a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_13864","instance":13864,"id":183863,"goal":"lemma MulAssoc_13864(i: int, k: int, j: int)\n ensures (i * k) * j == i * (k * j)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_13865","instance":13865,"id":183864,"goal":"lemma Distrib_13865(x: nat, i: nat, z: nat)\n ensures x * (i + z) == x * i + x * z\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_13866","instance":13866,"id":183865,"goal":"lemma AddZero_13866(x: real)\n ensures x + 0 == x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_13867","instance":13867,"id":183866,"goal":"lemma MulOne_13867(j: int)\n ensures j * 1 == j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_13868","instance":13868,"id":183867,"goal":"lemma MulZero_13868(y: nat)\n ensures y * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_13869","instance":13869,"id":183868,"goal":"lemma LeRefl_13869(m: real)\n ensures m <= m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_13870","instance":13870,"id":183869,"goal":"lemma LeTrans_13870(z: int, b: int, n: int)\n requires z <= b && b <= n\n ensures z <= n\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_13871","instance":13871,"id":183870,"goal":"lemma AddMono_13871(m: nat, y: nat, d: nat)\n requires m <= y\n ensures m + d <= y + d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_13872","instance":13872,"id":183871,"goal":"lemma Abs_Nonneg_13872(y: real)\n ensures (if y >= 0 then y else -y) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_13873","instance":13873,"id":183872,"goal":"lemma DivMod_13873(y: int, k: int)\n requires k > 0\n ensures y == k * (y / k) + (y % k)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_13874","instance":13874,"id":183873,"goal":"lemma ModBounds_13874(j: nat, a: nat)\n requires a > 0\n ensures 0 <= j % a < a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_13875","instance":13875,"id":183874,"goal":"lemma Square_Nonneg_13875(x: real)\n ensures x * x >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_13876","instance":13876,"id":183875,"goal":"lemma AddComm_13876(d: int, c: int)\n ensures d + c == c + d\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_13877","instance":13877,"id":183876,"goal":"lemma AddAssoc_13877(m: nat, b: nat, k: nat)\n ensures (m + b) + k == m + (b + k)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_13878","instance":13878,"id":183877,"goal":"lemma MulComm_13878(n: real, y: real)\n ensures n * y == y * n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_13879","instance":13879,"id":183878,"goal":"lemma MulAssoc_13879(n: int, x: int, b: int)\n ensures (n * x) * b == n * (x * b)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_13880","instance":13880,"id":183879,"goal":"lemma Distrib_13880(y: nat, x: nat, z: nat)\n ensures y * (x + z) == y * x + y * z\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_13881","instance":13881,"id":183880,"goal":"lemma AddZero_13881(x: real)\n ensures x + 0 == x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_13882","instance":13882,"id":183881,"goal":"lemma MulOne_13882(z: int)\n ensures z * 1 == z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_13883","instance":13883,"id":183882,"goal":"lemma MulZero_13883(m: nat)\n ensures m * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_13884","instance":13884,"id":183883,"goal":"lemma LeRefl_13884(z: real)\n ensures z <= z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_13885","instance":13885,"id":183884,"goal":"lemma LeTrans_13885(z: int, m: int, a: int)\n requires z <= m && m <= a\n ensures z <= a\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_13886","instance":13886,"id":183885,"goal":"lemma AddMono_13886(c: nat, b: nat, k: nat)\n requires c <= b\n ensures c + k <= b + k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_13887","instance":13887,"id":183886,"goal":"lemma Abs_Nonneg_13887(a: real)\n ensures (if a >= 0 then a else -a) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_13888","instance":13888,"id":183887,"goal":"lemma DivMod_13888(c: int, k: int)\n requires k > 0\n ensures c == k * (c / k) + (c % k)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_13889","instance":13889,"id":183888,"goal":"lemma ModBounds_13889(n: nat, k: nat)\n requires k > 0\n ensures 0 <= n % k < k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_13890","instance":13890,"id":183889,"goal":"lemma Square_Nonneg_13890(i: real)\n ensures i * i >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_13891","instance":13891,"id":183890,"goal":"lemma AddComm_13891(a: int, x: int)\n ensures a + x == x + a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_13892","instance":13892,"id":183891,"goal":"lemma AddAssoc_13892(d: nat, c: nat, y: nat)\n ensures (d + c) + y == d + (c + y)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_13893","instance":13893,"id":183892,"goal":"lemma MulComm_13893(y: real, d: real)\n ensures y * d == d * y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_13894","instance":13894,"id":183893,"goal":"lemma MulAssoc_13894(d: int, y: int, c: int)\n ensures (d * y) * c == d * (y * c)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_13895","instance":13895,"id":183894,"goal":"lemma Distrib_13895(i: nat, k: nat, m: nat)\n ensures i * (k + m) == i * k + i * m\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_13896","instance":13896,"id":183895,"goal":"lemma AddZero_13896(n: real)\n ensures n + 0 == n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_13897","instance":13897,"id":183896,"goal":"lemma MulOne_13897(d: int)\n ensures d * 1 == d\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_13898","instance":13898,"id":183897,"goal":"lemma MulZero_13898(b: nat)\n ensures b * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_13899","instance":13899,"id":183898,"goal":"lemma LeRefl_13899(a: real)\n ensures a <= a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_13900","instance":13900,"id":183899,"goal":"lemma LeTrans_13900(n: int, z: int, i: int)\n requires n <= z && z <= i\n ensures n <= i\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_13901","instance":13901,"id":183900,"goal":"lemma AddMono_13901(b: nat, c: nat, j: nat)\n requires b <= c\n ensures b + j <= c + j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_13902","instance":13902,"id":183901,"goal":"lemma Abs_Nonneg_13902(k: real)\n ensures (if k >= 0 then k else -k) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_13903","instance":13903,"id":183902,"goal":"lemma DivMod_13903(c: int, j: int)\n requires j > 0\n ensures c == j * (c / j) + (c % j)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_13904","instance":13904,"id":183903,"goal":"lemma ModBounds_13904(y: nat, n: nat)\n requires n > 0\n ensures 0 <= y % n < n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_13905","instance":13905,"id":183904,"goal":"lemma Square_Nonneg_13905(z: real)\n ensures z * z >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_13906","instance":13906,"id":183905,"goal":"lemma AddComm_13906(y: int, c: int)\n ensures y + c == c + y\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_13907","instance":13907,"id":183906,"goal":"lemma AddAssoc_13907(y: nat, n: nat, b: nat)\n ensures (y + n) + b == y + (n + b)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_13908","instance":13908,"id":183907,"goal":"lemma MulComm_13908(m: real, n: real)\n ensures m * n == n * m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_13909","instance":13909,"id":183908,"goal":"lemma MulAssoc_13909(k: int, z: int, x: int)\n ensures (k * z) * x == k * (z * x)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_13910","instance":13910,"id":183909,"goal":"lemma Distrib_13910(n: nat, m: nat, x: nat)\n ensures n * (m + x) == n * m + n * x\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_13911","instance":13911,"id":183910,"goal":"lemma AddZero_13911(y: real)\n ensures y + 0 == y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_13912","instance":13912,"id":183911,"goal":"lemma MulOne_13912(k: int)\n ensures k * 1 == k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_13913","instance":13913,"id":183912,"goal":"lemma MulZero_13913(b: nat)\n ensures b * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_13914","instance":13914,"id":183913,"goal":"lemma LeRefl_13914(m: real)\n ensures m <= m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_13915","instance":13915,"id":183914,"goal":"lemma LeTrans_13915(y: int, d: int, c: int)\n requires y <= d && d <= c\n ensures y <= c\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_13916","instance":13916,"id":183915,"goal":"lemma AddMono_13916(i: nat, d: nat, y: nat)\n requires i <= d\n ensures i + y <= d + y\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_13917","instance":13917,"id":183916,"goal":"lemma Abs_Nonneg_13917(x: real)\n ensures (if x >= 0 then x else -x) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_13918","instance":13918,"id":183917,"goal":"lemma DivMod_13918(b: int, k: int)\n requires k > 0\n ensures b == k * (b / k) + (b % k)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_13919","instance":13919,"id":183918,"goal":"lemma ModBounds_13919(b: nat, m: nat)\n requires m > 0\n ensures 0 <= b % m < m\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_13920","instance":13920,"id":183919,"goal":"lemma Square_Nonneg_13920(c: real)\n ensures c * c >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_13921","instance":13921,"id":183920,"goal":"lemma AddComm_13921(k: int, x: int)\n ensures k + x == x + k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_13922","instance":13922,"id":183921,"goal":"lemma AddAssoc_13922(b: nat, z: nat, k: nat)\n ensures (b + z) + k == b + (z + k)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_13923","instance":13923,"id":183922,"goal":"lemma MulComm_13923(a: real, j: real)\n ensures a * j == j * a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_13924","instance":13924,"id":183923,"goal":"lemma MulAssoc_13924(m: int, x: int, c: int)\n ensures (m * x) * c == m * (x * c)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_13925","instance":13925,"id":183924,"goal":"lemma Distrib_13925(z: nat, x: nat, n: nat)\n ensures z * (x + n) == z * x + z * n\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_13926","instance":13926,"id":183925,"goal":"lemma AddZero_13926(c: real)\n ensures c + 0 == c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_13927","instance":13927,"id":183926,"goal":"lemma MulOne_13927(m: int)\n ensures m * 1 == m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_13928","instance":13928,"id":183927,"goal":"lemma MulZero_13928(b: nat)\n ensures b * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_13929","instance":13929,"id":183928,"goal":"lemma LeRefl_13929(b: real)\n ensures b <= b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_13930","instance":13930,"id":183929,"goal":"lemma LeTrans_13930(c: int, b: int, n: int)\n requires c <= b && b <= n\n ensures c <= n\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_13931","instance":13931,"id":183930,"goal":"lemma AddMono_13931(y: nat, z: nat, i: nat)\n requires y <= z\n ensures y + i <= z + i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_13932","instance":13932,"id":183931,"goal":"lemma Abs_Nonneg_13932(j: real)\n ensures (if j >= 0 then j else -j) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_13933","instance":13933,"id":183932,"goal":"lemma DivMod_13933(k: int, z: int)\n requires z > 0\n ensures k == z * (k / z) + (k % z)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_13934","instance":13934,"id":183933,"goal":"lemma ModBounds_13934(m: nat, k: nat)\n requires k > 0\n ensures 0 <= m % k < k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_13935","instance":13935,"id":183934,"goal":"lemma Square_Nonneg_13935(x: real)\n ensures x * x >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_13936","instance":13936,"id":183935,"goal":"lemma AddComm_13936(i: int, x: int)\n ensures i + x == x + i\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_13937","instance":13937,"id":183936,"goal":"lemma AddAssoc_13937(x: nat, m: nat, z: nat)\n ensures (x + m) + z == x + (m + z)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_13938","instance":13938,"id":183937,"goal":"lemma MulComm_13938(j: real, m: real)\n ensures j * m == m * j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_13939","instance":13939,"id":183938,"goal":"lemma MulAssoc_13939(m: int, k: int, j: int)\n ensures (m * k) * j == m * (k * j)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_13940","instance":13940,"id":183939,"goal":"lemma Distrib_13940(k: nat, x: nat, n: nat)\n ensures k * (x + n) == k * x + k * n\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_13941","instance":13941,"id":183940,"goal":"lemma AddZero_13941(d: real)\n ensures d + 0 == d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_13942","instance":13942,"id":183941,"goal":"lemma MulOne_13942(c: int)\n ensures c * 1 == c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_13943","instance":13943,"id":183942,"goal":"lemma MulZero_13943(m: nat)\n ensures m * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_13944","instance":13944,"id":183943,"goal":"lemma LeRefl_13944(c: real)\n ensures c <= c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_13945","instance":13945,"id":183944,"goal":"lemma LeTrans_13945(c: int, i: int, m: int)\n requires c <= i && i <= m\n ensures c <= m\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_13946","instance":13946,"id":183945,"goal":"lemma AddMono_13946(a: nat, y: nat, b: nat)\n requires a <= y\n ensures a + b <= y + b\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_13947","instance":13947,"id":183946,"goal":"lemma Abs_Nonneg_13947(j: real)\n ensures (if j >= 0 then j else -j) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_13948","instance":13948,"id":183947,"goal":"lemma DivMod_13948(k: int, m: int)\n requires m > 0\n ensures k == m * (k / m) + (k % m)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_13949","instance":13949,"id":183948,"goal":"lemma ModBounds_13949(z: nat, b: nat)\n requires b > 0\n ensures 0 <= z % b < b\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_13950","instance":13950,"id":183949,"goal":"lemma Square_Nonneg_13950(d: real)\n ensures d * d >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_13951","instance":13951,"id":183950,"goal":"lemma AddComm_13951(x: int, i: int)\n ensures x + i == i + x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_13952","instance":13952,"id":183951,"goal":"lemma AddAssoc_13952(j: nat, i: nat, x: nat)\n ensures (j + i) + x == j + (i + x)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_13953","instance":13953,"id":183952,"goal":"lemma MulComm_13953(d: real, x: real)\n ensures d * x == x * d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_13954","instance":13954,"id":183953,"goal":"lemma MulAssoc_13954(a: int, z: int, b: int)\n ensures (a * z) * b == a * (z * b)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_13955","instance":13955,"id":183954,"goal":"lemma Distrib_13955(k: nat, j: nat, i: nat)\n ensures k * (j + i) == k * j + k * i\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_13956","instance":13956,"id":183955,"goal":"lemma AddZero_13956(m: real)\n ensures m + 0 == m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_13957","instance":13957,"id":183956,"goal":"lemma MulOne_13957(m: int)\n ensures m * 1 == m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_13958","instance":13958,"id":183957,"goal":"lemma MulZero_13958(i: nat)\n ensures i * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_13959","instance":13959,"id":183958,"goal":"lemma LeRefl_13959(d: real)\n ensures d <= d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_13960","instance":13960,"id":183959,"goal":"lemma LeTrans_13960(i: int, n: int, a: int)\n requires i <= n && n <= a\n ensures i <= a\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_13961","instance":13961,"id":183960,"goal":"lemma AddMono_13961(j: nat, m: nat, x: nat)\n requires j <= m\n ensures j + x <= m + x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_13962","instance":13962,"id":183961,"goal":"lemma Abs_Nonneg_13962(j: real)\n ensures (if j >= 0 then j else -j) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_13963","instance":13963,"id":183962,"goal":"lemma DivMod_13963(z: int, y: int)\n requires y > 0\n ensures z == y * (z / y) + (z % y)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_13964","instance":13964,"id":183963,"goal":"lemma ModBounds_13964(x: nat, d: nat)\n requires d > 0\n ensures 0 <= x % d < d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_13965","instance":13965,"id":183964,"goal":"lemma Square_Nonneg_13965(k: real)\n ensures k * k >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_13966","instance":13966,"id":183965,"goal":"lemma AddComm_13966(m: int, z: int)\n ensures m + z == z + m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_13967","instance":13967,"id":183966,"goal":"lemma AddAssoc_13967(a: nat, k: nat, x: nat)\n ensures (a + k) + x == a + (k + x)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_13968","instance":13968,"id":183967,"goal":"lemma MulComm_13968(k: real, m: real)\n ensures k * m == m * k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_13969","instance":13969,"id":183968,"goal":"lemma MulAssoc_13969(m: int, a: int, i: int)\n ensures (m * a) * i == m * (a * i)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_13970","instance":13970,"id":183969,"goal":"lemma Distrib_13970(d: nat, b: nat, y: nat)\n ensures d * (b + y) == d * b + d * y\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_13971","instance":13971,"id":183970,"goal":"lemma AddZero_13971(c: real)\n ensures c + 0 == c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_13972","instance":13972,"id":183971,"goal":"lemma MulOne_13972(a: int)\n ensures a * 1 == a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_13973","instance":13973,"id":183972,"goal":"lemma MulZero_13973(m: nat)\n ensures m * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_13974","instance":13974,"id":183973,"goal":"lemma LeRefl_13974(x: real)\n ensures x <= x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_13975","instance":13975,"id":183974,"goal":"lemma LeTrans_13975(j: int, z: int, a: int)\n requires j <= z && z <= a\n ensures j <= a\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_13976","instance":13976,"id":183975,"goal":"lemma AddMono_13976(k: nat, z: nat, n: nat)\n requires k <= z\n ensures k + n <= z + n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_13977","instance":13977,"id":183976,"goal":"lemma Abs_Nonneg_13977(m: real)\n ensures (if m >= 0 then m else -m) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_13978","instance":13978,"id":183977,"goal":"lemma DivMod_13978(m: int, x: int)\n requires x > 0\n ensures m == x * (m / x) + (m % x)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_13979","instance":13979,"id":183978,"goal":"lemma ModBounds_13979(d: nat, x: nat)\n requires x > 0\n ensures 0 <= d % x < x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_13980","instance":13980,"id":183979,"goal":"lemma Square_Nonneg_13980(a: real)\n ensures a * a >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_13981","instance":13981,"id":183980,"goal":"lemma AddComm_13981(k: int, i: int)\n ensures k + i == i + k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_13982","instance":13982,"id":183981,"goal":"lemma AddAssoc_13982(d: nat, b: nat, m: nat)\n ensures (d + b) + m == d + (b + m)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_13983","instance":13983,"id":183982,"goal":"lemma MulComm_13983(n: real, a: real)\n ensures n * a == a * n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_13984","instance":13984,"id":183983,"goal":"lemma MulAssoc_13984(y: int, x: int, m: int)\n ensures (y * x) * m == y * (x * m)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_13985","instance":13985,"id":183984,"goal":"lemma Distrib_13985(n: nat, i: nat, k: nat)\n ensures n * (i + k) == n * i + n * k\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_13986","instance":13986,"id":183985,"goal":"lemma AddZero_13986(n: real)\n ensures n + 0 == n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_13987","instance":13987,"id":183986,"goal":"lemma MulOne_13987(m: int)\n ensures m * 1 == m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_13988","instance":13988,"id":183987,"goal":"lemma MulZero_13988(k: nat)\n ensures k * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_13989","instance":13989,"id":183988,"goal":"lemma LeRefl_13989(d: real)\n ensures d <= d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_13990","instance":13990,"id":183989,"goal":"lemma LeTrans_13990(n: int, b: int, m: int)\n requires n <= b && b <= m\n ensures n <= m\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_13991","instance":13991,"id":183990,"goal":"lemma AddMono_13991(y: nat, i: nat, m: nat)\n requires y <= i\n ensures y + m <= i + m\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_13992","instance":13992,"id":183991,"goal":"lemma Abs_Nonneg_13992(b: real)\n ensures (if b >= 0 then b else -b) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_13993","instance":13993,"id":183992,"goal":"lemma DivMod_13993(a: int, x: int)\n requires x > 0\n ensures a == x * (a / x) + (a % x)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_13994","instance":13994,"id":183993,"goal":"lemma ModBounds_13994(m: nat, x: nat)\n requires x > 0\n ensures 0 <= m % x < x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_13995","instance":13995,"id":183994,"goal":"lemma Square_Nonneg_13995(n: real)\n ensures n * n >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_13996","instance":13996,"id":183995,"goal":"lemma AddComm_13996(k: int, x: int)\n ensures k + x == x + k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_13997","instance":13997,"id":183996,"goal":"lemma AddAssoc_13997(x: nat, y: nat, a: nat)\n ensures (x + y) + a == x + (y + a)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_13998","instance":13998,"id":183997,"goal":"lemma MulComm_13998(m: real, z: real)\n ensures m * z == z * m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_13999","instance":13999,"id":183998,"goal":"lemma MulAssoc_13999(z: int, j: int, c: int)\n ensures (z * j) * c == z * (j * c)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_14000","instance":14000,"id":183999,"goal":"lemma Distrib_14000(m: nat, y: nat, x: nat)\n ensures m * (y + x) == m * y + m * x\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_14001","instance":14001,"id":184000,"goal":"lemma AddZero_14001(c: real)\n ensures c + 0 == c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_14002","instance":14002,"id":184001,"goal":"lemma MulOne_14002(b: int)\n ensures b * 1 == b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_14003","instance":14003,"id":184002,"goal":"lemma MulZero_14003(k: nat)\n ensures k * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_14004","instance":14004,"id":184003,"goal":"lemma LeRefl_14004(n: real)\n ensures n <= n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_14005","instance":14005,"id":184004,"goal":"lemma LeTrans_14005(a: int, i: int, y: int)\n requires a <= i && i <= y\n ensures a <= y\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_14006","instance":14006,"id":184005,"goal":"lemma AddMono_14006(c: nat, i: nat, d: nat)\n requires c <= i\n ensures c + d <= i + d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_14007","instance":14007,"id":184006,"goal":"lemma Abs_Nonneg_14007(z: real)\n ensures (if z >= 0 then z else -z) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_14008","instance":14008,"id":184007,"goal":"lemma DivMod_14008(c: int, j: int)\n requires j > 0\n ensures c == j * (c / j) + (c % j)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_14009","instance":14009,"id":184008,"goal":"lemma ModBounds_14009(k: nat, j: nat)\n requires j > 0\n ensures 0 <= k % j < j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_14010","instance":14010,"id":184009,"goal":"lemma Square_Nonneg_14010(i: real)\n ensures i * i >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_14011","instance":14011,"id":184010,"goal":"lemma AddComm_14011(j: int, k: int)\n ensures j + k == k + j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_14012","instance":14012,"id":184011,"goal":"lemma AddAssoc_14012(a: nat, d: nat, c: nat)\n ensures (a + d) + c == a + (d + c)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_14013","instance":14013,"id":184012,"goal":"lemma MulComm_14013(b: real, z: real)\n ensures b * z == z * b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_14014","instance":14014,"id":184013,"goal":"lemma MulAssoc_14014(m: int, z: int, k: int)\n ensures (m * z) * k == m * (z * k)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_14015","instance":14015,"id":184014,"goal":"lemma Distrib_14015(y: nat, n: nat, k: nat)\n ensures y * (n + k) == y * n + y * k\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_14016","instance":14016,"id":184015,"goal":"lemma AddZero_14016(n: real)\n ensures n + 0 == n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_14017","instance":14017,"id":184016,"goal":"lemma MulOne_14017(j: int)\n ensures j * 1 == j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_14018","instance":14018,"id":184017,"goal":"lemma MulZero_14018(k: nat)\n ensures k * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_14019","instance":14019,"id":184018,"goal":"lemma LeRefl_14019(m: real)\n ensures m <= m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_14020","instance":14020,"id":184019,"goal":"lemma LeTrans_14020(i: int, k: int, a: int)\n requires i <= k && k <= a\n ensures i <= a\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_14021","instance":14021,"id":184020,"goal":"lemma AddMono_14021(n: nat, x: nat, d: nat)\n requires n <= x\n ensures n + d <= x + d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_14022","instance":14022,"id":184021,"goal":"lemma Abs_Nonneg_14022(c: real)\n ensures (if c >= 0 then c else -c) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_14023","instance":14023,"id":184022,"goal":"lemma DivMod_14023(n: int, j: int)\n requires j > 0\n ensures n == j * (n / j) + (n % j)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_14024","instance":14024,"id":184023,"goal":"lemma ModBounds_14024(z: nat, n: nat)\n requires n > 0\n ensures 0 <= z % n < n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_14025","instance":14025,"id":184024,"goal":"lemma Square_Nonneg_14025(z: real)\n ensures z * z >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_14026","instance":14026,"id":184025,"goal":"lemma AddComm_14026(z: int, j: int)\n ensures z + j == j + z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_14027","instance":14027,"id":184026,"goal":"lemma AddAssoc_14027(m: nat, d: nat, i: nat)\n ensures (m + d) + i == m + (d + i)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_14028","instance":14028,"id":184027,"goal":"lemma MulComm_14028(y: real, b: real)\n ensures y * b == b * y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_14029","instance":14029,"id":184028,"goal":"lemma MulAssoc_14029(j: int, n: int, m: int)\n ensures (j * n) * m == j * (n * m)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_14030","instance":14030,"id":184029,"goal":"lemma Distrib_14030(i: nat, d: nat, n: nat)\n ensures i * (d + n) == i * d + i * n\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_14031","instance":14031,"id":184030,"goal":"lemma AddZero_14031(x: real)\n ensures x + 0 == x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_14032","instance":14032,"id":184031,"goal":"lemma MulOne_14032(b: int)\n ensures b * 1 == b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_14033","instance":14033,"id":184032,"goal":"lemma MulZero_14033(z: nat)\n ensures z * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_14034","instance":14034,"id":184033,"goal":"lemma LeRefl_14034(y: real)\n ensures y <= y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_14035","instance":14035,"id":184034,"goal":"lemma LeTrans_14035(b: int, m: int, x: int)\n requires b <= m && m <= x\n ensures b <= x\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_14036","instance":14036,"id":184035,"goal":"lemma AddMono_14036(a: nat, z: nat, k: nat)\n requires a <= z\n ensures a + k <= z + k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_14037","instance":14037,"id":184036,"goal":"lemma Abs_Nonneg_14037(b: real)\n ensures (if b >= 0 then b else -b) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_14038","instance":14038,"id":184037,"goal":"lemma DivMod_14038(j: int, c: int)\n requires c > 0\n ensures j == c * (j / c) + (j % c)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_14039","instance":14039,"id":184038,"goal":"lemma ModBounds_14039(i: nat, c: nat)\n requires c > 0\n ensures 0 <= i % c < c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_14040","instance":14040,"id":184039,"goal":"lemma Square_Nonneg_14040(z: real)\n ensures z * z >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_14041","instance":14041,"id":184040,"goal":"lemma AddComm_14041(z: int, d: int)\n ensures z + d == d + z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_14042","instance":14042,"id":184041,"goal":"lemma AddAssoc_14042(x: nat, c: nat, i: nat)\n ensures (x + c) + i == x + (c + i)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_14043","instance":14043,"id":184042,"goal":"lemma MulComm_14043(n: real, c: real)\n ensures n * c == c * n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_14044","instance":14044,"id":184043,"goal":"lemma MulAssoc_14044(i: int, m: int, x: int)\n ensures (i * m) * x == i * (m * x)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_14045","instance":14045,"id":184044,"goal":"lemma Distrib_14045(c: nat, y: nat, k: nat)\n ensures c * (y + k) == c * y + c * k\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_14046","instance":14046,"id":184045,"goal":"lemma AddZero_14046(j: real)\n ensures j + 0 == j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_14047","instance":14047,"id":184046,"goal":"lemma MulOne_14047(j: int)\n ensures j * 1 == j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_14048","instance":14048,"id":184047,"goal":"lemma MulZero_14048(z: nat)\n ensures z * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_14049","instance":14049,"id":184048,"goal":"lemma LeRefl_14049(d: real)\n ensures d <= d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_14050","instance":14050,"id":184049,"goal":"lemma LeTrans_14050(m: int, j: int, b: int)\n requires m <= j && j <= b\n ensures m <= b\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_14051","instance":14051,"id":184050,"goal":"lemma AddMono_14051(a: nat, y: nat, k: nat)\n requires a <= y\n ensures a + k <= y + k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_14052","instance":14052,"id":184051,"goal":"lemma Abs_Nonneg_14052(i: real)\n ensures (if i >= 0 then i else -i) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_14053","instance":14053,"id":184052,"goal":"lemma DivMod_14053(x: int, c: int)\n requires c > 0\n ensures x == c * (x / c) + (x % c)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_14054","instance":14054,"id":184053,"goal":"lemma ModBounds_14054(i: nat, a: nat)\n requires a > 0\n ensures 0 <= i % a < a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_14055","instance":14055,"id":184054,"goal":"lemma Square_Nonneg_14055(x: real)\n ensures x * x >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_14056","instance":14056,"id":184055,"goal":"lemma AddComm_14056(y: int, n: int)\n ensures y + n == n + y\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_14057","instance":14057,"id":184056,"goal":"lemma AddAssoc_14057(j: nat, a: nat, k: nat)\n ensures (j + a) + k == j + (a + k)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_14058","instance":14058,"id":184057,"goal":"lemma MulComm_14058(i: real, a: real)\n ensures i * a == a * i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_14059","instance":14059,"id":184058,"goal":"lemma MulAssoc_14059(k: int, c: int, a: int)\n ensures (k * c) * a == k * (c * a)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_14060","instance":14060,"id":184059,"goal":"lemma Distrib_14060(b: nat, a: nat, c: nat)\n ensures b * (a + c) == b * a + b * c\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_14061","instance":14061,"id":184060,"goal":"lemma AddZero_14061(d: real)\n ensures d + 0 == d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_14062","instance":14062,"id":184061,"goal":"lemma MulOne_14062(c: int)\n ensures c * 1 == c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_14063","instance":14063,"id":184062,"goal":"lemma MulZero_14063(n: nat)\n ensures n * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_14064","instance":14064,"id":184063,"goal":"lemma LeRefl_14064(b: real)\n ensures b <= b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_14065","instance":14065,"id":184064,"goal":"lemma LeTrans_14065(i: int, k: int, b: int)\n requires i <= k && k <= b\n ensures i <= b\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_14066","instance":14066,"id":184065,"goal":"lemma AddMono_14066(c: nat, i: nat, m: nat)\n requires c <= i\n ensures c + m <= i + m\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_14067","instance":14067,"id":184066,"goal":"lemma Abs_Nonneg_14067(y: real)\n ensures (if y >= 0 then y else -y) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_14068","instance":14068,"id":184067,"goal":"lemma DivMod_14068(b: int, j: int)\n requires j > 0\n ensures b == j * (b / j) + (b % j)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_14069","instance":14069,"id":184068,"goal":"lemma ModBounds_14069(k: nat, j: nat)\n requires j > 0\n ensures 0 <= k % j < j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_14070","instance":14070,"id":184069,"goal":"lemma Square_Nonneg_14070(y: real)\n ensures y * y >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_14071","instance":14071,"id":184070,"goal":"lemma AddComm_14071(k: int, y: int)\n ensures k + y == y + k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_14072","instance":14072,"id":184071,"goal":"lemma AddAssoc_14072(k: nat, a: nat, d: nat)\n ensures (k + a) + d == k + (a + d)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_14073","instance":14073,"id":184072,"goal":"lemma MulComm_14073(d: real, y: real)\n ensures d * y == y * d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_14074","instance":14074,"id":184073,"goal":"lemma MulAssoc_14074(b: int, j: int, n: int)\n ensures (b * j) * n == b * (j * n)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_14075","instance":14075,"id":184074,"goal":"lemma Distrib_14075(j: nat, a: nat, m: nat)\n ensures j * (a + m) == j * a + j * m\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_14076","instance":14076,"id":184075,"goal":"lemma AddZero_14076(d: real)\n ensures d + 0 == d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_14077","instance":14077,"id":184076,"goal":"lemma MulOne_14077(m: int)\n ensures m * 1 == m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_14078","instance":14078,"id":184077,"goal":"lemma MulZero_14078(k: nat)\n ensures k * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_14079","instance":14079,"id":184078,"goal":"lemma LeRefl_14079(c: real)\n ensures c <= c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_14080","instance":14080,"id":184079,"goal":"lemma LeTrans_14080(x: int, m: int, d: int)\n requires x <= m && m <= d\n ensures x <= d\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_14081","instance":14081,"id":184080,"goal":"lemma AddMono_14081(c: nat, x: nat, m: nat)\n requires c <= x\n ensures c + m <= x + m\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_14082","instance":14082,"id":184081,"goal":"lemma Abs_Nonneg_14082(c: real)\n ensures (if c >= 0 then c else -c) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_14083","instance":14083,"id":184082,"goal":"lemma DivMod_14083(z: int, i: int)\n requires i > 0\n ensures z == i * (z / i) + (z % i)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_14084","instance":14084,"id":184083,"goal":"lemma ModBounds_14084(y: nat, j: nat)\n requires j > 0\n ensures 0 <= y % j < j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_14085","instance":14085,"id":184084,"goal":"lemma Square_Nonneg_14085(j: real)\n ensures j * j >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_14086","instance":14086,"id":184085,"goal":"lemma AddComm_14086(d: int, k: int)\n ensures d + k == k + d\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_14087","instance":14087,"id":184086,"goal":"lemma AddAssoc_14087(z: nat, i: nat, x: nat)\n ensures (z + i) + x == z + (i + x)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_14088","instance":14088,"id":184087,"goal":"lemma MulComm_14088(j: real, i: real)\n ensures j * i == i * j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_14089","instance":14089,"id":184088,"goal":"lemma MulAssoc_14089(x: int, d: int, n: int)\n ensures (x * d) * n == x * (d * n)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_14090","instance":14090,"id":184089,"goal":"lemma Distrib_14090(x: nat, c: nat, m: nat)\n ensures x * (c + m) == x * c + x * m\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_14091","instance":14091,"id":184090,"goal":"lemma AddZero_14091(m: real)\n ensures m + 0 == m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_14092","instance":14092,"id":184091,"goal":"lemma MulOne_14092(z: int)\n ensures z * 1 == z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_14093","instance":14093,"id":184092,"goal":"lemma MulZero_14093(b: nat)\n ensures b * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_14094","instance":14094,"id":184093,"goal":"lemma LeRefl_14094(a: real)\n ensures a <= a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_14095","instance":14095,"id":184094,"goal":"lemma LeTrans_14095(a: int, x: int, d: int)\n requires a <= x && x <= d\n ensures a <= d\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_14096","instance":14096,"id":184095,"goal":"lemma AddMono_14096(m: nat, n: nat, c: nat)\n requires m <= n\n ensures m + c <= n + c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_14097","instance":14097,"id":184096,"goal":"lemma Abs_Nonneg_14097(y: real)\n ensures (if y >= 0 then y else -y) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_14098","instance":14098,"id":184097,"goal":"lemma DivMod_14098(n: int, k: int)\n requires k > 0\n ensures n == k * (n / k) + (n % k)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_14099","instance":14099,"id":184098,"goal":"lemma ModBounds_14099(a: nat, m: nat)\n requires m > 0\n ensures 0 <= a % m < m\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_14100","instance":14100,"id":184099,"goal":"lemma Square_Nonneg_14100(c: real)\n ensures c * c >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_14101","instance":14101,"id":184100,"goal":"lemma AddComm_14101(b: int, j: int)\n ensures b + j == j + b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_14102","instance":14102,"id":184101,"goal":"lemma AddAssoc_14102(z: nat, d: nat, i: nat)\n ensures (z + d) + i == z + (d + i)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_14103","instance":14103,"id":184102,"goal":"lemma MulComm_14103(j: real, c: real)\n ensures j * c == c * j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_14104","instance":14104,"id":184103,"goal":"lemma MulAssoc_14104(k: int, m: int, i: int)\n ensures (k * m) * i == k * (m * i)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_14105","instance":14105,"id":184104,"goal":"lemma Distrib_14105(y: nat, i: nat, j: nat)\n ensures y * (i + j) == y * i + y * j\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_14106","instance":14106,"id":184105,"goal":"lemma AddZero_14106(k: real)\n ensures k + 0 == k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_14107","instance":14107,"id":184106,"goal":"lemma MulOne_14107(m: int)\n ensures m * 1 == m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_14108","instance":14108,"id":184107,"goal":"lemma MulZero_14108(m: nat)\n ensures m * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_14109","instance":14109,"id":184108,"goal":"lemma LeRefl_14109(j: real)\n ensures j <= j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_14110","instance":14110,"id":184109,"goal":"lemma LeTrans_14110(c: int, y: int, z: int)\n requires c <= y && y <= z\n ensures c <= z\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_14111","instance":14111,"id":184110,"goal":"lemma AddMono_14111(b: nat, x: nat, n: nat)\n requires b <= x\n ensures b + n <= x + n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_14112","instance":14112,"id":184111,"goal":"lemma Abs_Nonneg_14112(x: real)\n ensures (if x >= 0 then x else -x) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_14113","instance":14113,"id":184112,"goal":"lemma DivMod_14113(b: int, x: int)\n requires x > 0\n ensures b == x * (b / x) + (b % x)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_14114","instance":14114,"id":184113,"goal":"lemma ModBounds_14114(c: nat, j: nat)\n requires j > 0\n ensures 0 <= c % j < j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_14115","instance":14115,"id":184114,"goal":"lemma Square_Nonneg_14115(d: real)\n ensures d * d >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_14116","instance":14116,"id":184115,"goal":"lemma AddComm_14116(c: int, x: int)\n ensures c + x == x + c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_14117","instance":14117,"id":184116,"goal":"lemma AddAssoc_14117(n: nat, d: nat, c: nat)\n ensures (n + d) + c == n + (d + c)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_14118","instance":14118,"id":184117,"goal":"lemma MulComm_14118(k: real, i: real)\n ensures k * i == i * k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_14119","instance":14119,"id":184118,"goal":"lemma MulAssoc_14119(d: int, x: int, c: int)\n ensures (d * x) * c == d * (x * c)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_14120","instance":14120,"id":184119,"goal":"lemma Distrib_14120(z: nat, a: nat, k: nat)\n ensures z * (a + k) == z * a + z * k\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_14121","instance":14121,"id":184120,"goal":"lemma AddZero_14121(k: real)\n ensures k + 0 == k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_14122","instance":14122,"id":184121,"goal":"lemma MulOne_14122(x: int)\n ensures x * 1 == x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_14123","instance":14123,"id":184122,"goal":"lemma MulZero_14123(d: nat)\n ensures d * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_14124","instance":14124,"id":184123,"goal":"lemma LeRefl_14124(b: real)\n ensures b <= b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_14125","instance":14125,"id":184124,"goal":"lemma LeTrans_14125(k: int, z: int, b: int)\n requires k <= z && z <= b\n ensures k <= b\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_14126","instance":14126,"id":184125,"goal":"lemma AddMono_14126(z: nat, k: nat, i: nat)\n requires z <= k\n ensures z + i <= k + i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_14127","instance":14127,"id":184126,"goal":"lemma Abs_Nonneg_14127(k: real)\n ensures (if k >= 0 then k else -k) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_14128","instance":14128,"id":184127,"goal":"lemma DivMod_14128(z: int, b: int)\n requires b > 0\n ensures z == b * (z / b) + (z % b)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_14129","instance":14129,"id":184128,"goal":"lemma ModBounds_14129(n: nat, z: nat)\n requires z > 0\n ensures 0 <= n % z < z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_14130","instance":14130,"id":184129,"goal":"lemma Square_Nonneg_14130(j: real)\n ensures j * j >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_14131","instance":14131,"id":184130,"goal":"lemma AddComm_14131(m: int, b: int)\n ensures m + b == b + m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_14132","instance":14132,"id":184131,"goal":"lemma AddAssoc_14132(x: nat, b: nat, z: nat)\n ensures (x + b) + z == x + (b + z)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_14133","instance":14133,"id":184132,"goal":"lemma MulComm_14133(j: real, i: real)\n ensures j * i == i * j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_14134","instance":14134,"id":184133,"goal":"lemma MulAssoc_14134(j: int, n: int, m: int)\n ensures (j * n) * m == j * (n * m)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_14135","instance":14135,"id":184134,"goal":"lemma Distrib_14135(j: nat, x: nat, z: nat)\n ensures j * (x + z) == j * x + j * z\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_14136","instance":14136,"id":184135,"goal":"lemma AddZero_14136(i: real)\n ensures i + 0 == i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_14137","instance":14137,"id":184136,"goal":"lemma MulOne_14137(j: int)\n ensures j * 1 == j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_14138","instance":14138,"id":184137,"goal":"lemma MulZero_14138(i: nat)\n ensures i * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_14139","instance":14139,"id":184138,"goal":"lemma LeRefl_14139(k: real)\n ensures k <= k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_14140","instance":14140,"id":184139,"goal":"lemma LeTrans_14140(b: int, c: int, d: int)\n requires b <= c && c <= d\n ensures b <= d\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_14141","instance":14141,"id":184140,"goal":"lemma AddMono_14141(i: nat, d: nat, n: nat)\n requires i <= d\n ensures i + n <= d + n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_14142","instance":14142,"id":184141,"goal":"lemma Abs_Nonneg_14142(i: real)\n ensures (if i >= 0 then i else -i) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_14143","instance":14143,"id":184142,"goal":"lemma DivMod_14143(m: int, i: int)\n requires i > 0\n ensures m == i * (m / i) + (m % i)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_14144","instance":14144,"id":184143,"goal":"lemma ModBounds_14144(m: nat, n: nat)\n requires n > 0\n ensures 0 <= m % n < n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_14145","instance":14145,"id":184144,"goal":"lemma Square_Nonneg_14145(n: real)\n ensures n * n >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_14146","instance":14146,"id":184145,"goal":"lemma AddComm_14146(n: int, j: int)\n ensures n + j == j + n\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_14147","instance":14147,"id":184146,"goal":"lemma AddAssoc_14147(x: nat, c: nat, y: nat)\n ensures (x + c) + y == x + (c + y)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_14148","instance":14148,"id":184147,"goal":"lemma MulComm_14148(y: real, a: real)\n ensures y * a == a * y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_14149","instance":14149,"id":184148,"goal":"lemma MulAssoc_14149(a: int, c: int, y: int)\n ensures (a * c) * y == a * (c * y)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_14150","instance":14150,"id":184149,"goal":"lemma Distrib_14150(a: nat, x: nat, n: nat)\n ensures a * (x + n) == a * x + a * n\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_14151","instance":14151,"id":184150,"goal":"lemma AddZero_14151(b: real)\n ensures b + 0 == b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_14152","instance":14152,"id":184151,"goal":"lemma MulOne_14152(m: int)\n ensures m * 1 == m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_14153","instance":14153,"id":184152,"goal":"lemma MulZero_14153(b: nat)\n ensures b * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_14154","instance":14154,"id":184153,"goal":"lemma LeRefl_14154(i: real)\n ensures i <= i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_14155","instance":14155,"id":184154,"goal":"lemma LeTrans_14155(c: int, b: int, x: int)\n requires c <= b && b <= x\n ensures c <= x\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_14156","instance":14156,"id":184155,"goal":"lemma AddMono_14156(d: nat, j: nat, c: nat)\n requires d <= j\n ensures d + c <= j + c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_14157","instance":14157,"id":184156,"goal":"lemma Abs_Nonneg_14157(i: real)\n ensures (if i >= 0 then i else -i) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_14158","instance":14158,"id":184157,"goal":"lemma DivMod_14158(m: int, j: int)\n requires j > 0\n ensures m == j * (m / j) + (m % j)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_14159","instance":14159,"id":184158,"goal":"lemma ModBounds_14159(z: nat, n: nat)\n requires n > 0\n ensures 0 <= z % n < n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_14160","instance":14160,"id":184159,"goal":"lemma Square_Nonneg_14160(i: real)\n ensures i * i >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_14161","instance":14161,"id":184160,"goal":"lemma AddComm_14161(y: int, c: int)\n ensures y + c == c + y\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_14162","instance":14162,"id":184161,"goal":"lemma AddAssoc_14162(k: nat, n: nat, b: nat)\n ensures (k + n) + b == k + (n + b)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_14163","instance":14163,"id":184162,"goal":"lemma MulComm_14163(i: real, k: real)\n ensures i * k == k * i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_14164","instance":14164,"id":184163,"goal":"lemma MulAssoc_14164(j: int, m: int, x: int)\n ensures (j * m) * x == j * (m * x)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_14165","instance":14165,"id":184164,"goal":"lemma Distrib_14165(j: nat, m: nat, k: nat)\n ensures j * (m + k) == j * m + j * k\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_14166","instance":14166,"id":184165,"goal":"lemma AddZero_14166(k: real)\n ensures k + 0 == k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_14167","instance":14167,"id":184166,"goal":"lemma MulOne_14167(z: int)\n ensures z * 1 == z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_14168","instance":14168,"id":184167,"goal":"lemma MulZero_14168(b: nat)\n ensures b * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_14169","instance":14169,"id":184168,"goal":"lemma LeRefl_14169(i: real)\n ensures i <= i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_14170","instance":14170,"id":184169,"goal":"lemma LeTrans_14170(y: int, c: int, d: int)\n requires y <= c && c <= d\n ensures y <= d\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_14171","instance":14171,"id":184170,"goal":"lemma AddMono_14171(j: nat, c: nat, z: nat)\n requires j <= c\n ensures j + z <= c + z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_14172","instance":14172,"id":184171,"goal":"lemma Abs_Nonneg_14172(d: real)\n ensures (if d >= 0 then d else -d) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_14173","instance":14173,"id":184172,"goal":"lemma DivMod_14173(k: int, d: int)\n requires d > 0\n ensures k == d * (k / d) + (k % d)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_14174","instance":14174,"id":184173,"goal":"lemma ModBounds_14174(z: nat, k: nat)\n requires k > 0\n ensures 0 <= z % k < k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_14175","instance":14175,"id":184174,"goal":"lemma Square_Nonneg_14175(d: real)\n ensures d * d >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_14176","instance":14176,"id":184175,"goal":"lemma AddComm_14176(x: int, b: int)\n ensures x + b == b + x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_14177","instance":14177,"id":184176,"goal":"lemma AddAssoc_14177(i: nat, k: nat, j: nat)\n ensures (i + k) + j == i + (k + j)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_14178","instance":14178,"id":184177,"goal":"lemma MulComm_14178(m: real, d: real)\n ensures m * d == d * m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_14179","instance":14179,"id":184178,"goal":"lemma MulAssoc_14179(c: int, n: int, a: int)\n ensures (c * n) * a == c * (n * a)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_14180","instance":14180,"id":184179,"goal":"lemma Distrib_14180(m: nat, d: nat, k: nat)\n ensures m * (d + k) == m * d + m * k\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_14181","instance":14181,"id":184180,"goal":"lemma AddZero_14181(b: real)\n ensures b + 0 == b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_14182","instance":14182,"id":184181,"goal":"lemma MulOne_14182(m: int)\n ensures m * 1 == m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_14183","instance":14183,"id":184182,"goal":"lemma MulZero_14183(d: nat)\n ensures d * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_14184","instance":14184,"id":184183,"goal":"lemma LeRefl_14184(m: real)\n ensures m <= m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_14185","instance":14185,"id":184184,"goal":"lemma LeTrans_14185(b: int, a: int, j: int)\n requires b <= a && a <= j\n ensures b <= j\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_14186","instance":14186,"id":184185,"goal":"lemma AddMono_14186(x: nat, k: nat, b: nat)\n requires x <= k\n ensures x + b <= k + b\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_14187","instance":14187,"id":184186,"goal":"lemma Abs_Nonneg_14187(j: real)\n ensures (if j >= 0 then j else -j) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_14188","instance":14188,"id":184187,"goal":"lemma DivMod_14188(z: int, i: int)\n requires i > 0\n ensures z == i * (z / i) + (z % i)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_14189","instance":14189,"id":184188,"goal":"lemma ModBounds_14189(c: nat, m: nat)\n requires m > 0\n ensures 0 <= c % m < m\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_14190","instance":14190,"id":184189,"goal":"lemma Square_Nonneg_14190(y: real)\n ensures y * y >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_14191","instance":14191,"id":184190,"goal":"lemma AddComm_14191(c: int, z: int)\n ensures c + z == z + c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_14192","instance":14192,"id":184191,"goal":"lemma AddAssoc_14192(b: nat, j: nat, z: nat)\n ensures (b + j) + z == b + (j + z)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_14193","instance":14193,"id":184192,"goal":"lemma MulComm_14193(d: real, i: real)\n ensures d * i == i * d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_14194","instance":14194,"id":184193,"goal":"lemma MulAssoc_14194(z: int, d: int, y: int)\n ensures (z * d) * y == z * (d * y)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_14195","instance":14195,"id":184194,"goal":"lemma Distrib_14195(z: nat, j: nat, m: nat)\n ensures z * (j + m) == z * j + z * m\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_14196","instance":14196,"id":184195,"goal":"lemma AddZero_14196(z: real)\n ensures z + 0 == z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_14197","instance":14197,"id":184196,"goal":"lemma MulOne_14197(c: int)\n ensures c * 1 == c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_14198","instance":14198,"id":184197,"goal":"lemma MulZero_14198(m: nat)\n ensures m * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_14199","instance":14199,"id":184198,"goal":"lemma LeRefl_14199(j: real)\n ensures j <= j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_14200","instance":14200,"id":184199,"goal":"lemma LeTrans_14200(d: int, z: int, j: int)\n requires d <= z && z <= j\n ensures d <= j\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_14201","instance":14201,"id":184200,"goal":"lemma AddMono_14201(x: nat, m: nat, z: nat)\n requires x <= m\n ensures x + z <= m + z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_14202","instance":14202,"id":184201,"goal":"lemma Abs_Nonneg_14202(b: real)\n ensures (if b >= 0 then b else -b) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_14203","instance":14203,"id":184202,"goal":"lemma DivMod_14203(n: int, c: int)\n requires c > 0\n ensures n == c * (n / c) + (n % c)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_14204","instance":14204,"id":184203,"goal":"lemma ModBounds_14204(n: nat, y: nat)\n requires y > 0\n ensures 0 <= n % y < y\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_14205","instance":14205,"id":184204,"goal":"lemma Square_Nonneg_14205(b: real)\n ensures b * b >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_14206","instance":14206,"id":184205,"goal":"lemma AddComm_14206(k: int, d: int)\n ensures k + d == d + k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_14207","instance":14207,"id":184206,"goal":"lemma AddAssoc_14207(d: nat, i: nat, j: nat)\n ensures (d + i) + j == d + (i + j)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_14208","instance":14208,"id":184207,"goal":"lemma MulComm_14208(n: real, y: real)\n ensures n * y == y * n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_14209","instance":14209,"id":184208,"goal":"lemma MulAssoc_14209(m: int, y: int, k: int)\n ensures (m * y) * k == m * (y * k)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_14210","instance":14210,"id":184209,"goal":"lemma Distrib_14210(j: nat, x: nat, z: nat)\n ensures j * (x + z) == j * x + j * z\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_14211","instance":14211,"id":184210,"goal":"lemma AddZero_14211(y: real)\n ensures y + 0 == y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_14212","instance":14212,"id":184211,"goal":"lemma MulOne_14212(i: int)\n ensures i * 1 == i\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_14213","instance":14213,"id":184212,"goal":"lemma MulZero_14213(i: nat)\n ensures i * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_14214","instance":14214,"id":184213,"goal":"lemma LeRefl_14214(y: real)\n ensures y <= y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_14215","instance":14215,"id":184214,"goal":"lemma LeTrans_14215(j: int, y: int, m: int)\n requires j <= y && y <= m\n ensures j <= m\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_14216","instance":14216,"id":184215,"goal":"lemma AddMono_14216(z: nat, d: nat, y: nat)\n requires z <= d\n ensures z + y <= d + y\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_14217","instance":14217,"id":184216,"goal":"lemma Abs_Nonneg_14217(y: real)\n ensures (if y >= 0 then y else -y) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_14218","instance":14218,"id":184217,"goal":"lemma DivMod_14218(c: int, b: int)\n requires b > 0\n ensures c == b * (c / b) + (c % b)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_14219","instance":14219,"id":184218,"goal":"lemma ModBounds_14219(x: nat, j: nat)\n requires j > 0\n ensures 0 <= x % j < j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_14220","instance":14220,"id":184219,"goal":"lemma Square_Nonneg_14220(m: real)\n ensures m * m >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_14221","instance":14221,"id":184220,"goal":"lemma AddComm_14221(k: int, z: int)\n ensures k + z == z + k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_14222","instance":14222,"id":184221,"goal":"lemma AddAssoc_14222(a: nat, k: nat, d: nat)\n ensures (a + k) + d == a + (k + d)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_14223","instance":14223,"id":184222,"goal":"lemma MulComm_14223(i: real, y: real)\n ensures i * y == y * i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_14224","instance":14224,"id":184223,"goal":"lemma MulAssoc_14224(i: int, j: int, a: int)\n ensures (i * j) * a == i * (j * a)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_14225","instance":14225,"id":184224,"goal":"lemma Distrib_14225(a: nat, b: nat, m: nat)\n ensures a * (b + m) == a * b + a * m\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_14226","instance":14226,"id":184225,"goal":"lemma AddZero_14226(n: real)\n ensures n + 0 == n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_14227","instance":14227,"id":184226,"goal":"lemma MulOne_14227(z: int)\n ensures z * 1 == z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_14228","instance":14228,"id":184227,"goal":"lemma MulZero_14228(y: nat)\n ensures y * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_14229","instance":14229,"id":184228,"goal":"lemma LeRefl_14229(i: real)\n ensures i <= i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_14230","instance":14230,"id":184229,"goal":"lemma LeTrans_14230(d: int, a: int, x: int)\n requires d <= a && a <= x\n ensures d <= x\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_14231","instance":14231,"id":184230,"goal":"lemma AddMono_14231(i: nat, n: nat, c: nat)\n requires i <= n\n ensures i + c <= n + c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_14232","instance":14232,"id":184231,"goal":"lemma Abs_Nonneg_14232(m: real)\n ensures (if m >= 0 then m else -m) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_14233","instance":14233,"id":184232,"goal":"lemma DivMod_14233(d: int, i: int)\n requires i > 0\n ensures d == i * (d / i) + (d % i)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_14234","instance":14234,"id":184233,"goal":"lemma ModBounds_14234(k: nat, j: nat)\n requires j > 0\n ensures 0 <= k % j < j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_14235","instance":14235,"id":184234,"goal":"lemma Square_Nonneg_14235(j: real)\n ensures j * j >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_14236","instance":14236,"id":184235,"goal":"lemma AddComm_14236(k: int, c: int)\n ensures k + c == c + k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_14237","instance":14237,"id":184236,"goal":"lemma AddAssoc_14237(m: nat, x: nat, y: nat)\n ensures (m + x) + y == m + (x + y)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_14238","instance":14238,"id":184237,"goal":"lemma MulComm_14238(m: real, y: real)\n ensures m * y == y * m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_14239","instance":14239,"id":184238,"goal":"lemma MulAssoc_14239(m: int, b: int, j: int)\n ensures (m * b) * j == m * (b * j)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_14240","instance":14240,"id":184239,"goal":"lemma Distrib_14240(b: nat, d: nat, a: nat)\n ensures b * (d + a) == b * d + b * a\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_14241","instance":14241,"id":184240,"goal":"lemma AddZero_14241(x: real)\n ensures x + 0 == x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_14242","instance":14242,"id":184241,"goal":"lemma MulOne_14242(z: int)\n ensures z * 1 == z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_14243","instance":14243,"id":184242,"goal":"lemma MulZero_14243(x: nat)\n ensures x * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_14244","instance":14244,"id":184243,"goal":"lemma LeRefl_14244(x: real)\n ensures x <= x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_14245","instance":14245,"id":184244,"goal":"lemma LeTrans_14245(z: int, d: int, k: int)\n requires z <= d && d <= k\n ensures z <= k\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_14246","instance":14246,"id":184245,"goal":"lemma AddMono_14246(j: nat, y: nat, m: nat)\n requires j <= y\n ensures j + m <= y + m\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_14247","instance":14247,"id":184246,"goal":"lemma Abs_Nonneg_14247(y: real)\n ensures (if y >= 0 then y else -y) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_14248","instance":14248,"id":184247,"goal":"lemma DivMod_14248(n: int, k: int)\n requires k > 0\n ensures n == k * (n / k) + (n % k)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_14249","instance":14249,"id":184248,"goal":"lemma ModBounds_14249(y: nat, a: nat)\n requires a > 0\n ensures 0 <= y % a < a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_14250","instance":14250,"id":184249,"goal":"lemma Square_Nonneg_14250(x: real)\n ensures x * x >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_14251","instance":14251,"id":184250,"goal":"lemma AddComm_14251(j: int, c: int)\n ensures j + c == c + j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_14252","instance":14252,"id":184251,"goal":"lemma AddAssoc_14252(b: nat, m: nat, i: nat)\n ensures (b + m) + i == b + (m + i)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_14253","instance":14253,"id":184252,"goal":"lemma MulComm_14253(m: real, k: real)\n ensures m * k == k * m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_14254","instance":14254,"id":184253,"goal":"lemma MulAssoc_14254(d: int, i: int, z: int)\n ensures (d * i) * z == d * (i * z)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_14255","instance":14255,"id":184254,"goal":"lemma Distrib_14255(n: nat, j: nat, d: nat)\n ensures n * (j + d) == n * j + n * d\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_14256","instance":14256,"id":184255,"goal":"lemma AddZero_14256(i: real)\n ensures i + 0 == i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_14257","instance":14257,"id":184256,"goal":"lemma MulOne_14257(d: int)\n ensures d * 1 == d\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_14258","instance":14258,"id":184257,"goal":"lemma MulZero_14258(m: nat)\n ensures m * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_14259","instance":14259,"id":184258,"goal":"lemma LeRefl_14259(k: real)\n ensures k <= k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_14260","instance":14260,"id":184259,"goal":"lemma LeTrans_14260(z: int, d: int, j: int)\n requires z <= d && d <= j\n ensures z <= j\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_14261","instance":14261,"id":184260,"goal":"lemma AddMono_14261(a: nat, m: nat, x: nat)\n requires a <= m\n ensures a + x <= m + x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_14262","instance":14262,"id":184261,"goal":"lemma Abs_Nonneg_14262(j: real)\n ensures (if j >= 0 then j else -j) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_14263","instance":14263,"id":184262,"goal":"lemma DivMod_14263(y: int, k: int)\n requires k > 0\n ensures y == k * (y / k) + (y % k)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_14264","instance":14264,"id":184263,"goal":"lemma ModBounds_14264(d: nat, z: nat)\n requires z > 0\n ensures 0 <= d % z < z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_14265","instance":14265,"id":184264,"goal":"lemma Square_Nonneg_14265(b: real)\n ensures b * b >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_14266","instance":14266,"id":184265,"goal":"lemma AddComm_14266(k: int, n: int)\n ensures k + n == n + k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_14267","instance":14267,"id":184266,"goal":"lemma AddAssoc_14267(j: nat, c: nat, b: nat)\n ensures (j + c) + b == j + (c + b)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_14268","instance":14268,"id":184267,"goal":"lemma MulComm_14268(k: real, x: real)\n ensures k * x == x * k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_14269","instance":14269,"id":184268,"goal":"lemma MulAssoc_14269(i: int, j: int, y: int)\n ensures (i * j) * y == i * (j * y)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_14270","instance":14270,"id":184269,"goal":"lemma Distrib_14270(b: nat, a: nat, i: nat)\n ensures b * (a + i) == b * a + b * i\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_14271","instance":14271,"id":184270,"goal":"lemma AddZero_14271(y: real)\n ensures y + 0 == y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_14272","instance":14272,"id":184271,"goal":"lemma MulOne_14272(z: int)\n ensures z * 1 == z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_14273","instance":14273,"id":184272,"goal":"lemma MulZero_14273(d: nat)\n ensures d * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_14274","instance":14274,"id":184273,"goal":"lemma LeRefl_14274(n: real)\n ensures n <= n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_14275","instance":14275,"id":184274,"goal":"lemma LeTrans_14275(k: int, b: int, c: int)\n requires k <= b && b <= c\n ensures k <= c\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_14276","instance":14276,"id":184275,"goal":"lemma AddMono_14276(n: nat, m: nat, z: nat)\n requires n <= m\n ensures n + z <= m + z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_14277","instance":14277,"id":184276,"goal":"lemma Abs_Nonneg_14277(k: real)\n ensures (if k >= 0 then k else -k) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_14278","instance":14278,"id":184277,"goal":"lemma DivMod_14278(d: int, j: int)\n requires j > 0\n ensures d == j * (d / j) + (d % j)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_14279","instance":14279,"id":184278,"goal":"lemma ModBounds_14279(i: nat, b: nat)\n requires b > 0\n ensures 0 <= i % b < b\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_14280","instance":14280,"id":184279,"goal":"lemma Square_Nonneg_14280(n: real)\n ensures n * n >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_14281","instance":14281,"id":184280,"goal":"lemma AddComm_14281(m: int, a: int)\n ensures m + a == a + m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_14282","instance":14282,"id":184281,"goal":"lemma AddAssoc_14282(a: nat, m: nat, x: nat)\n ensures (a + m) + x == a + (m + x)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_14283","instance":14283,"id":184282,"goal":"lemma MulComm_14283(c: real, n: real)\n ensures c * n == n * c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_14284","instance":14284,"id":184283,"goal":"lemma MulAssoc_14284(y: int, j: int, d: int)\n ensures (y * j) * d == y * (j * d)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_14285","instance":14285,"id":184284,"goal":"lemma Distrib_14285(c: nat, k: nat, y: nat)\n ensures c * (k + y) == c * k + c * y\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_14286","instance":14286,"id":184285,"goal":"lemma AddZero_14286(x: real)\n ensures x + 0 == x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_14287","instance":14287,"id":184286,"goal":"lemma MulOne_14287(j: int)\n ensures j * 1 == j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_14288","instance":14288,"id":184287,"goal":"lemma MulZero_14288(b: nat)\n ensures b * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_14289","instance":14289,"id":184288,"goal":"lemma LeRefl_14289(c: real)\n ensures c <= c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_14290","instance":14290,"id":184289,"goal":"lemma LeTrans_14290(n: int, y: int, b: int)\n requires n <= y && y <= b\n ensures n <= b\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_14291","instance":14291,"id":184290,"goal":"lemma AddMono_14291(m: nat, k: nat, i: nat)\n requires m <= k\n ensures m + i <= k + i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_14292","instance":14292,"id":184291,"goal":"lemma Abs_Nonneg_14292(d: real)\n ensures (if d >= 0 then d else -d) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_14293","instance":14293,"id":184292,"goal":"lemma DivMod_14293(c: int, n: int)\n requires n > 0\n ensures c == n * (c / n) + (c % n)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_14294","instance":14294,"id":184293,"goal":"lemma ModBounds_14294(k: nat, m: nat)\n requires m > 0\n ensures 0 <= k % m < m\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_14295","instance":14295,"id":184294,"goal":"lemma Square_Nonneg_14295(k: real)\n ensures k * k >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_14296","instance":14296,"id":184295,"goal":"lemma AddComm_14296(m: int, n: int)\n ensures m + n == n + m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_14297","instance":14297,"id":184296,"goal":"lemma AddAssoc_14297(z: nat, b: nat, j: nat)\n ensures (z + b) + j == z + (b + j)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_14298","instance":14298,"id":184297,"goal":"lemma MulComm_14298(z: real, x: real)\n ensures z * x == x * z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_14299","instance":14299,"id":184298,"goal":"lemma MulAssoc_14299(y: int, z: int, i: int)\n ensures (y * z) * i == y * (z * i)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_14300","instance":14300,"id":184299,"goal":"lemma Distrib_14300(y: nat, z: nat, j: nat)\n ensures y * (z + j) == y * z + y * j\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_14301","instance":14301,"id":184300,"goal":"lemma AddZero_14301(k: real)\n ensures k + 0 == k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_14302","instance":14302,"id":184301,"goal":"lemma MulOne_14302(m: int)\n ensures m * 1 == m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_14303","instance":14303,"id":184302,"goal":"lemma MulZero_14303(z: nat)\n ensures z * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_14304","instance":14304,"id":184303,"goal":"lemma LeRefl_14304(d: real)\n ensures d <= d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_14305","instance":14305,"id":184304,"goal":"lemma LeTrans_14305(a: int, x: int, i: int)\n requires a <= x && x <= i\n ensures a <= i\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_14306","instance":14306,"id":184305,"goal":"lemma AddMono_14306(y: nat, d: nat, n: nat)\n requires y <= d\n ensures y + n <= d + n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_14307","instance":14307,"id":184306,"goal":"lemma Abs_Nonneg_14307(k: real)\n ensures (if k >= 0 then k else -k) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_14308","instance":14308,"id":184307,"goal":"lemma DivMod_14308(b: int, n: int)\n requires n > 0\n ensures b == n * (b / n) + (b % n)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_14309","instance":14309,"id":184308,"goal":"lemma ModBounds_14309(k: nat, m: nat)\n requires m > 0\n ensures 0 <= k % m < m\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_14310","instance":14310,"id":184309,"goal":"lemma Square_Nonneg_14310(n: real)\n ensures n * n >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_14311","instance":14311,"id":184310,"goal":"lemma AddComm_14311(n: int, m: int)\n ensures n + m == m + n\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_14312","instance":14312,"id":184311,"goal":"lemma AddAssoc_14312(x: nat, a: nat, z: nat)\n ensures (x + a) + z == x + (a + z)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_14313","instance":14313,"id":184312,"goal":"lemma MulComm_14313(b: real, z: real)\n ensures b * z == z * b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_14314","instance":14314,"id":184313,"goal":"lemma MulAssoc_14314(z: int, n: int, k: int)\n ensures (z * n) * k == z * (n * k)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_14315","instance":14315,"id":184314,"goal":"lemma Distrib_14315(j: nat, z: nat, x: nat)\n ensures j * (z + x) == j * z + j * x\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_14316","instance":14316,"id":184315,"goal":"lemma AddZero_14316(k: real)\n ensures k + 0 == k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_14317","instance":14317,"id":184316,"goal":"lemma MulOne_14317(j: int)\n ensures j * 1 == j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_14318","instance":14318,"id":184317,"goal":"lemma MulZero_14318(b: nat)\n ensures b * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_14319","instance":14319,"id":184318,"goal":"lemma LeRefl_14319(d: real)\n ensures d <= d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_14320","instance":14320,"id":184319,"goal":"lemma LeTrans_14320(m: int, c: int, k: int)\n requires m <= c && c <= k\n ensures m <= k\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_14321","instance":14321,"id":184320,"goal":"lemma AddMono_14321(d: nat, b: nat, c: nat)\n requires d <= b\n ensures d + c <= b + c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_14322","instance":14322,"id":184321,"goal":"lemma Abs_Nonneg_14322(m: real)\n ensures (if m >= 0 then m else -m) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_14323","instance":14323,"id":184322,"goal":"lemma DivMod_14323(d: int, k: int)\n requires k > 0\n ensures d == k * (d / k) + (d % k)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_14324","instance":14324,"id":184323,"goal":"lemma ModBounds_14324(d: nat, k: nat)\n requires k > 0\n ensures 0 <= d % k < k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_14325","instance":14325,"id":184324,"goal":"lemma Square_Nonneg_14325(k: real)\n ensures k * k >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_14326","instance":14326,"id":184325,"goal":"lemma AddComm_14326(z: int, b: int)\n ensures z + b == b + z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_14327","instance":14327,"id":184326,"goal":"lemma AddAssoc_14327(i: nat, z: nat, y: nat)\n ensures (i + z) + y == i + (z + y)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_14328","instance":14328,"id":184327,"goal":"lemma MulComm_14328(d: real, n: real)\n ensures d * n == n * d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_14329","instance":14329,"id":184328,"goal":"lemma MulAssoc_14329(b: int, x: int, d: int)\n ensures (b * x) * d == b * (x * d)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_14330","instance":14330,"id":184329,"goal":"lemma Distrib_14330(m: nat, n: nat, a: nat)\n ensures m * (n + a) == m * n + m * a\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_14331","instance":14331,"id":184330,"goal":"lemma AddZero_14331(y: real)\n ensures y + 0 == y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_14332","instance":14332,"id":184331,"goal":"lemma MulOne_14332(i: int)\n ensures i * 1 == i\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_14333","instance":14333,"id":184332,"goal":"lemma MulZero_14333(c: nat)\n ensures c * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_14334","instance":14334,"id":184333,"goal":"lemma LeRefl_14334(a: real)\n ensures a <= a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_14335","instance":14335,"id":184334,"goal":"lemma LeTrans_14335(m: int, k: int, y: int)\n requires m <= k && k <= y\n ensures m <= y\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_14336","instance":14336,"id":184335,"goal":"lemma AddMono_14336(y: nat, z: nat, d: nat)\n requires y <= z\n ensures y + d <= z + d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_14337","instance":14337,"id":184336,"goal":"lemma Abs_Nonneg_14337(n: real)\n ensures (if n >= 0 then n else -n) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_14338","instance":14338,"id":184337,"goal":"lemma DivMod_14338(z: int, y: int)\n requires y > 0\n ensures z == y * (z / y) + (z % y)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_14339","instance":14339,"id":184338,"goal":"lemma ModBounds_14339(n: nat, z: nat)\n requires z > 0\n ensures 0 <= n % z < z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_14340","instance":14340,"id":184339,"goal":"lemma Square_Nonneg_14340(y: real)\n ensures y * y >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_14341","instance":14341,"id":184340,"goal":"lemma AddComm_14341(m: int, i: int)\n ensures m + i == i + m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_14342","instance":14342,"id":184341,"goal":"lemma AddAssoc_14342(x: nat, j: nat, y: nat)\n ensures (x + j) + y == x + (j + y)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_14343","instance":14343,"id":184342,"goal":"lemma MulComm_14343(a: real, b: real)\n ensures a * b == b * a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_14344","instance":14344,"id":184343,"goal":"lemma MulAssoc_14344(y: int, a: int, m: int)\n ensures (y * a) * m == y * (a * m)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_14345","instance":14345,"id":184344,"goal":"lemma Distrib_14345(n: nat, x: nat, c: nat)\n ensures n * (x + c) == n * x + n * c\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_14346","instance":14346,"id":184345,"goal":"lemma AddZero_14346(i: real)\n ensures i + 0 == i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_14347","instance":14347,"id":184346,"goal":"lemma MulOne_14347(j: int)\n ensures j * 1 == j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_14348","instance":14348,"id":184347,"goal":"lemma MulZero_14348(c: nat)\n ensures c * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_14349","instance":14349,"id":184348,"goal":"lemma LeRefl_14349(a: real)\n ensures a <= a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_14350","instance":14350,"id":184349,"goal":"lemma LeTrans_14350(d: int, z: int, i: int)\n requires d <= z && z <= i\n ensures d <= i\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_14351","instance":14351,"id":184350,"goal":"lemma AddMono_14351(c: nat, d: nat, k: nat)\n requires c <= d\n ensures c + k <= d + k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_14352","instance":14352,"id":184351,"goal":"lemma Abs_Nonneg_14352(n: real)\n ensures (if n >= 0 then n else -n) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_14353","instance":14353,"id":184352,"goal":"lemma DivMod_14353(n: int, i: int)\n requires i > 0\n ensures n == i * (n / i) + (n % i)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_14354","instance":14354,"id":184353,"goal":"lemma ModBounds_14354(j: nat, d: nat)\n requires d > 0\n ensures 0 <= j % d < d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_14355","instance":14355,"id":184354,"goal":"lemma Square_Nonneg_14355(m: real)\n ensures m * m >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_14356","instance":14356,"id":184355,"goal":"lemma AddComm_14356(n: int, c: int)\n ensures n + c == c + n\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_14357","instance":14357,"id":184356,"goal":"lemma AddAssoc_14357(y: nat, i: nat, j: nat)\n ensures (y + i) + j == y + (i + j)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_14358","instance":14358,"id":184357,"goal":"lemma MulComm_14358(c: real, m: real)\n ensures c * m == m * c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_14359","instance":14359,"id":184358,"goal":"lemma MulAssoc_14359(z: int, b: int, x: int)\n ensures (z * b) * x == z * (b * x)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_14360","instance":14360,"id":184359,"goal":"lemma Distrib_14360(m: nat, d: nat, k: nat)\n ensures m * (d + k) == m * d + m * k\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_14361","instance":14361,"id":184360,"goal":"lemma AddZero_14361(x: real)\n ensures x + 0 == x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_14362","instance":14362,"id":184361,"goal":"lemma MulOne_14362(a: int)\n ensures a * 1 == a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_14363","instance":14363,"id":184362,"goal":"lemma MulZero_14363(m: nat)\n ensures m * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_14364","instance":14364,"id":184363,"goal":"lemma LeRefl_14364(y: real)\n ensures y <= y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_14365","instance":14365,"id":184364,"goal":"lemma LeTrans_14365(x: int, n: int, m: int)\n requires x <= n && n <= m\n ensures x <= m\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_14366","instance":14366,"id":184365,"goal":"lemma AddMono_14366(i: nat, j: nat, y: nat)\n requires i <= j\n ensures i + y <= j + y\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_14367","instance":14367,"id":184366,"goal":"lemma Abs_Nonneg_14367(n: real)\n ensures (if n >= 0 then n else -n) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_14368","instance":14368,"id":184367,"goal":"lemma DivMod_14368(c: int, m: int)\n requires m > 0\n ensures c == m * (c / m) + (c % m)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_14369","instance":14369,"id":184368,"goal":"lemma ModBounds_14369(k: nat, d: nat)\n requires d > 0\n ensures 0 <= k % d < d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_14370","instance":14370,"id":184369,"goal":"lemma Square_Nonneg_14370(y: real)\n ensures y * y >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_14371","instance":14371,"id":184370,"goal":"lemma AddComm_14371(b: int, a: int)\n ensures b + a == a + b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_14372","instance":14372,"id":184371,"goal":"lemma AddAssoc_14372(b: nat, x: nat, a: nat)\n ensures (b + x) + a == b + (x + a)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_14373","instance":14373,"id":184372,"goal":"lemma MulComm_14373(b: real, j: real)\n ensures b * j == j * b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_14374","instance":14374,"id":184373,"goal":"lemma MulAssoc_14374(m: int, k: int, y: int)\n ensures (m * k) * y == m * (k * y)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_14375","instance":14375,"id":184374,"goal":"lemma Distrib_14375(d: nat, y: nat, m: nat)\n ensures d * (y + m) == d * y + d * m\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_14376","instance":14376,"id":184375,"goal":"lemma AddZero_14376(c: real)\n ensures c + 0 == c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_14377","instance":14377,"id":184376,"goal":"lemma MulOne_14377(m: int)\n ensures m * 1 == m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_14378","instance":14378,"id":184377,"goal":"lemma MulZero_14378(z: nat)\n ensures z * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_14379","instance":14379,"id":184378,"goal":"lemma LeRefl_14379(i: real)\n ensures i <= i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_14380","instance":14380,"id":184379,"goal":"lemma LeTrans_14380(z: int, b: int, n: int)\n requires z <= b && b <= n\n ensures z <= n\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_14381","instance":14381,"id":184380,"goal":"lemma AddMono_14381(j: nat, b: nat, a: nat)\n requires j <= b\n ensures j + a <= b + a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_14382","instance":14382,"id":184381,"goal":"lemma Abs_Nonneg_14382(k: real)\n ensures (if k >= 0 then k else -k) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_14383","instance":14383,"id":184382,"goal":"lemma DivMod_14383(c: int, m: int)\n requires m > 0\n ensures c == m * (c / m) + (c % m)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_14384","instance":14384,"id":184383,"goal":"lemma ModBounds_14384(x: nat, n: nat)\n requires n > 0\n ensures 0 <= x % n < n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_14385","instance":14385,"id":184384,"goal":"lemma Square_Nonneg_14385(n: real)\n ensures n * n >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_14386","instance":14386,"id":184385,"goal":"lemma AddComm_14386(a: int, z: int)\n ensures a + z == z + a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_14387","instance":14387,"id":184386,"goal":"lemma AddAssoc_14387(c: nat, i: nat, z: nat)\n ensures (c + i) + z == c + (i + z)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_14388","instance":14388,"id":184387,"goal":"lemma MulComm_14388(b: real, y: real)\n ensures b * y == y * b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_14389","instance":14389,"id":184388,"goal":"lemma MulAssoc_14389(i: int, c: int, y: int)\n ensures (i * c) * y == i * (c * y)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_14390","instance":14390,"id":184389,"goal":"lemma Distrib_14390(i: nat, a: nat, k: nat)\n ensures i * (a + k) == i * a + i * k\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_14391","instance":14391,"id":184390,"goal":"lemma AddZero_14391(m: real)\n ensures m + 0 == m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_14392","instance":14392,"id":184391,"goal":"lemma MulOne_14392(z: int)\n ensures z * 1 == z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_14393","instance":14393,"id":184392,"goal":"lemma MulZero_14393(x: nat)\n ensures x * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_14394","instance":14394,"id":184393,"goal":"lemma LeRefl_14394(x: real)\n ensures x <= x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_14395","instance":14395,"id":184394,"goal":"lemma LeTrans_14395(y: int, a: int, x: int)\n requires y <= a && a <= x\n ensures y <= x\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_14396","instance":14396,"id":184395,"goal":"lemma AddMono_14396(n: nat, b: nat, m: nat)\n requires n <= b\n ensures n + m <= b + m\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_14397","instance":14397,"id":184396,"goal":"lemma Abs_Nonneg_14397(x: real)\n ensures (if x >= 0 then x else -x) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_14398","instance":14398,"id":184397,"goal":"lemma DivMod_14398(y: int, j: int)\n requires j > 0\n ensures y == j * (y / j) + (y % j)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_14399","instance":14399,"id":184398,"goal":"lemma ModBounds_14399(y: nat, x: nat)\n requires x > 0\n ensures 0 <= y % x < x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_14400","instance":14400,"id":184399,"goal":"lemma Square_Nonneg_14400(i: real)\n ensures i * i >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_14401","instance":14401,"id":184400,"goal":"lemma AddComm_14401(k: int, z: int)\n ensures k + z == z + k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_14402","instance":14402,"id":184401,"goal":"lemma AddAssoc_14402(z: nat, c: nat, k: nat)\n ensures (z + c) + k == z + (c + k)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_14403","instance":14403,"id":184402,"goal":"lemma MulComm_14403(k: real, n: real)\n ensures k * n == n * k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_14404","instance":14404,"id":184403,"goal":"lemma MulAssoc_14404(d: int, i: int, a: int)\n ensures (d * i) * a == d * (i * a)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_14405","instance":14405,"id":184404,"goal":"lemma Distrib_14405(k: nat, y: nat, n: nat)\n ensures k * (y + n) == k * y + k * n\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_14406","instance":14406,"id":184405,"goal":"lemma AddZero_14406(n: real)\n ensures n + 0 == n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_14407","instance":14407,"id":184406,"goal":"lemma MulOne_14407(c: int)\n ensures c * 1 == c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_14408","instance":14408,"id":184407,"goal":"lemma MulZero_14408(a: nat)\n ensures a * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_14409","instance":14409,"id":184408,"goal":"lemma LeRefl_14409(c: real)\n ensures c <= c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_14410","instance":14410,"id":184409,"goal":"lemma LeTrans_14410(j: int, b: int, z: int)\n requires j <= b && b <= z\n ensures j <= z\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_14411","instance":14411,"id":184410,"goal":"lemma AddMono_14411(n: nat, x: nat, b: nat)\n requires n <= x\n ensures n + b <= x + b\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_14412","instance":14412,"id":184411,"goal":"lemma Abs_Nonneg_14412(c: real)\n ensures (if c >= 0 then c else -c) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_14413","instance":14413,"id":184412,"goal":"lemma DivMod_14413(x: int, i: int)\n requires i > 0\n ensures x == i * (x / i) + (x % i)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_14414","instance":14414,"id":184413,"goal":"lemma ModBounds_14414(m: nat, k: nat)\n requires k > 0\n ensures 0 <= m % k < k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_14415","instance":14415,"id":184414,"goal":"lemma Square_Nonneg_14415(b: real)\n ensures b * b >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_14416","instance":14416,"id":184415,"goal":"lemma AddComm_14416(n: int, k: int)\n ensures n + k == k + n\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_14417","instance":14417,"id":184416,"goal":"lemma AddAssoc_14417(a: nat, x: nat, j: nat)\n ensures (a + x) + j == a + (x + j)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_14418","instance":14418,"id":184417,"goal":"lemma MulComm_14418(c: real, k: real)\n ensures c * k == k * c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_14419","instance":14419,"id":184418,"goal":"lemma MulAssoc_14419(n: int, m: int, i: int)\n ensures (n * m) * i == n * (m * i)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_14420","instance":14420,"id":184419,"goal":"lemma Distrib_14420(b: nat, i: nat, j: nat)\n ensures b * (i + j) == b * i + b * j\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_14421","instance":14421,"id":184420,"goal":"lemma AddZero_14421(y: real)\n ensures y + 0 == y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_14422","instance":14422,"id":184421,"goal":"lemma MulOne_14422(m: int)\n ensures m * 1 == m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_14423","instance":14423,"id":184422,"goal":"lemma MulZero_14423(z: nat)\n ensures z * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_14424","instance":14424,"id":184423,"goal":"lemma LeRefl_14424(d: real)\n ensures d <= d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_14425","instance":14425,"id":184424,"goal":"lemma LeTrans_14425(k: int, a: int, m: int)\n requires k <= a && a <= m\n ensures k <= m\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_14426","instance":14426,"id":184425,"goal":"lemma AddMono_14426(x: nat, y: nat, m: nat)\n requires x <= y\n ensures x + m <= y + m\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_14427","instance":14427,"id":184426,"goal":"lemma Abs_Nonneg_14427(z: real)\n ensures (if z >= 0 then z else -z) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_14428","instance":14428,"id":184427,"goal":"lemma DivMod_14428(n: int, k: int)\n requires k > 0\n ensures n == k * (n / k) + (n % k)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_14429","instance":14429,"id":184428,"goal":"lemma ModBounds_14429(b: nat, y: nat)\n requires y > 0\n ensures 0 <= b % y < y\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_14430","instance":14430,"id":184429,"goal":"lemma Square_Nonneg_14430(k: real)\n ensures k * k >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_14431","instance":14431,"id":184430,"goal":"lemma AddComm_14431(a: int, z: int)\n ensures a + z == z + a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_14432","instance":14432,"id":184431,"goal":"lemma AddAssoc_14432(x: nat, m: nat, j: nat)\n ensures (x + m) + j == x + (m + j)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_14433","instance":14433,"id":184432,"goal":"lemma MulComm_14433(i: real, c: real)\n ensures i * c == c * i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_14434","instance":14434,"id":184433,"goal":"lemma MulAssoc_14434(c: int, z: int, i: int)\n ensures (c * z) * i == c * (z * i)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_14435","instance":14435,"id":184434,"goal":"lemma Distrib_14435(c: nat, a: nat, y: nat)\n ensures c * (a + y) == c * a + c * y\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_14436","instance":14436,"id":184435,"goal":"lemma AddZero_14436(b: real)\n ensures b + 0 == b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_14437","instance":14437,"id":184436,"goal":"lemma MulOne_14437(n: int)\n ensures n * 1 == n\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_14438","instance":14438,"id":184437,"goal":"lemma MulZero_14438(y: nat)\n ensures y * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_14439","instance":14439,"id":184438,"goal":"lemma LeRefl_14439(y: real)\n ensures y <= y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_14440","instance":14440,"id":184439,"goal":"lemma LeTrans_14440(d: int, n: int, c: int)\n requires d <= n && n <= c\n ensures d <= c\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_14441","instance":14441,"id":184440,"goal":"lemma AddMono_14441(z: nat, k: nat, i: nat)\n requires z <= k\n ensures z + i <= k + i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_14442","instance":14442,"id":184441,"goal":"lemma Abs_Nonneg_14442(d: real)\n ensures (if d >= 0 then d else -d) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_14443","instance":14443,"id":184442,"goal":"lemma DivMod_14443(z: int, k: int)\n requires k > 0\n ensures z == k * (z / k) + (z % k)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_14444","instance":14444,"id":184443,"goal":"lemma ModBounds_14444(b: nat, n: nat)\n requires n > 0\n ensures 0 <= b % n < n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_14445","instance":14445,"id":184444,"goal":"lemma Square_Nonneg_14445(k: real)\n ensures k * k >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_14446","instance":14446,"id":184445,"goal":"lemma AddComm_14446(c: int, b: int)\n ensures c + b == b + c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_14447","instance":14447,"id":184446,"goal":"lemma AddAssoc_14447(b: nat, j: nat, i: nat)\n ensures (b + j) + i == b + (j + i)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_14448","instance":14448,"id":184447,"goal":"lemma MulComm_14448(i: real, b: real)\n ensures i * b == b * i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_14449","instance":14449,"id":184448,"goal":"lemma MulAssoc_14449(m: int, c: int, k: int)\n ensures (m * c) * k == m * (c * k)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_14450","instance":14450,"id":184449,"goal":"lemma Distrib_14450(m: nat, y: nat, n: nat)\n ensures m * (y + n) == m * y + m * n\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_14451","instance":14451,"id":184450,"goal":"lemma AddZero_14451(m: real)\n ensures m + 0 == m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_14452","instance":14452,"id":184451,"goal":"lemma MulOne_14452(k: int)\n ensures k * 1 == k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_14453","instance":14453,"id":184452,"goal":"lemma MulZero_14453(c: nat)\n ensures c * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_14454","instance":14454,"id":184453,"goal":"lemma LeRefl_14454(x: real)\n ensures x <= x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_14455","instance":14455,"id":184454,"goal":"lemma LeTrans_14455(n: int, j: int, i: int)\n requires n <= j && j <= i\n ensures n <= i\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_14456","instance":14456,"id":184455,"goal":"lemma AddMono_14456(d: nat, z: nat, x: nat)\n requires d <= z\n ensures d + x <= z + x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_14457","instance":14457,"id":184456,"goal":"lemma Abs_Nonneg_14457(x: real)\n ensures (if x >= 0 then x else -x) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_14458","instance":14458,"id":184457,"goal":"lemma DivMod_14458(d: int, y: int)\n requires y > 0\n ensures d == y * (d / y) + (d % y)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_14459","instance":14459,"id":184458,"goal":"lemma ModBounds_14459(z: nat, b: nat)\n requires b > 0\n ensures 0 <= z % b < b\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_14460","instance":14460,"id":184459,"goal":"lemma Square_Nonneg_14460(x: real)\n ensures x * x >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_14461","instance":14461,"id":184460,"goal":"lemma AddComm_14461(k: int, j: int)\n ensures k + j == j + k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_14462","instance":14462,"id":184461,"goal":"lemma AddAssoc_14462(y: nat, i: nat, k: nat)\n ensures (y + i) + k == y + (i + k)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_14463","instance":14463,"id":184462,"goal":"lemma MulComm_14463(m: real, b: real)\n ensures m * b == b * m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_14464","instance":14464,"id":184463,"goal":"lemma MulAssoc_14464(m: int, y: int, d: int)\n ensures (m * y) * d == m * (y * d)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_14465","instance":14465,"id":184464,"goal":"lemma Distrib_14465(z: nat, c: nat, n: nat)\n ensures z * (c + n) == z * c + z * n\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_14466","instance":14466,"id":184465,"goal":"lemma AddZero_14466(c: real)\n ensures c + 0 == c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_14467","instance":14467,"id":184466,"goal":"lemma MulOne_14467(c: int)\n ensures c * 1 == c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_14468","instance":14468,"id":184467,"goal":"lemma MulZero_14468(j: nat)\n ensures j * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_14469","instance":14469,"id":184468,"goal":"lemma LeRefl_14469(a: real)\n ensures a <= a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_14470","instance":14470,"id":184469,"goal":"lemma LeTrans_14470(k: int, j: int, x: int)\n requires k <= j && j <= x\n ensures k <= x\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_14471","instance":14471,"id":184470,"goal":"lemma AddMono_14471(j: nat, a: nat, d: nat)\n requires j <= a\n ensures j + d <= a + d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_14472","instance":14472,"id":184471,"goal":"lemma Abs_Nonneg_14472(c: real)\n ensures (if c >= 0 then c else -c) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_14473","instance":14473,"id":184472,"goal":"lemma DivMod_14473(n: int, m: int)\n requires m > 0\n ensures n == m * (n / m) + (n % m)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_14474","instance":14474,"id":184473,"goal":"lemma ModBounds_14474(m: nat, z: nat)\n requires z > 0\n ensures 0 <= m % z < z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_14475","instance":14475,"id":184474,"goal":"lemma Square_Nonneg_14475(n: real)\n ensures n * n >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_14476","instance":14476,"id":184475,"goal":"lemma AddComm_14476(n: int, d: int)\n ensures n + d == d + n\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_14477","instance":14477,"id":184476,"goal":"lemma AddAssoc_14477(i: nat, y: nat, n: nat)\n ensures (i + y) + n == i + (y + n)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_14478","instance":14478,"id":184477,"goal":"lemma MulComm_14478(j: real, x: real)\n ensures j * x == x * j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_14479","instance":14479,"id":184478,"goal":"lemma MulAssoc_14479(a: int, j: int, b: int)\n ensures (a * j) * b == a * (j * b)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_14480","instance":14480,"id":184479,"goal":"lemma Distrib_14480(c: nat, d: nat, y: nat)\n ensures c * (d + y) == c * d + c * y\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_14481","instance":14481,"id":184480,"goal":"lemma AddZero_14481(b: real)\n ensures b + 0 == b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_14482","instance":14482,"id":184481,"goal":"lemma MulOne_14482(c: int)\n ensures c * 1 == c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_14483","instance":14483,"id":184482,"goal":"lemma MulZero_14483(j: nat)\n ensures j * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_14484","instance":14484,"id":184483,"goal":"lemma LeRefl_14484(j: real)\n ensures j <= j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_14485","instance":14485,"id":184484,"goal":"lemma LeTrans_14485(n: int, k: int, m: int)\n requires n <= k && k <= m\n ensures n <= m\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_14486","instance":14486,"id":184485,"goal":"lemma AddMono_14486(m: nat, x: nat, a: nat)\n requires m <= x\n ensures m + a <= x + a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_14487","instance":14487,"id":184486,"goal":"lemma Abs_Nonneg_14487(a: real)\n ensures (if a >= 0 then a else -a) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_14488","instance":14488,"id":184487,"goal":"lemma DivMod_14488(j: int, a: int)\n requires a > 0\n ensures j == a * (j / a) + (j % a)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_14489","instance":14489,"id":184488,"goal":"lemma ModBounds_14489(k: nat, j: nat)\n requires j > 0\n ensures 0 <= k % j < j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_14490","instance":14490,"id":184489,"goal":"lemma Square_Nonneg_14490(m: real)\n ensures m * m >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_14491","instance":14491,"id":184490,"goal":"lemma AddComm_14491(b: int, k: int)\n ensures b + k == k + b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_14492","instance":14492,"id":184491,"goal":"lemma AddAssoc_14492(z: nat, a: nat, c: nat)\n ensures (z + a) + c == z + (a + c)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_14493","instance":14493,"id":184492,"goal":"lemma MulComm_14493(k: real, x: real)\n ensures k * x == x * k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_14494","instance":14494,"id":184493,"goal":"lemma MulAssoc_14494(d: int, k: int, j: int)\n ensures (d * k) * j == d * (k * j)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_14495","instance":14495,"id":184494,"goal":"lemma Distrib_14495(x: nat, d: nat, b: nat)\n ensures x * (d + b) == x * d + x * b\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_14496","instance":14496,"id":184495,"goal":"lemma AddZero_14496(i: real)\n ensures i + 0 == i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_14497","instance":14497,"id":184496,"goal":"lemma MulOne_14497(z: int)\n ensures z * 1 == z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_14498","instance":14498,"id":184497,"goal":"lemma MulZero_14498(z: nat)\n ensures z * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_14499","instance":14499,"id":184498,"goal":"lemma LeRefl_14499(b: real)\n ensures b <= b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_14500","instance":14500,"id":184499,"goal":"lemma LeTrans_14500(z: int, y: int, m: int)\n requires z <= y && y <= m\n ensures z <= m\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_14501","instance":14501,"id":184500,"goal":"lemma AddMono_14501(d: nat, j: nat, m: nat)\n requires d <= j\n ensures d + m <= j + m\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_14502","instance":14502,"id":184501,"goal":"lemma Abs_Nonneg_14502(m: real)\n ensures (if m >= 0 then m else -m) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_14503","instance":14503,"id":184502,"goal":"lemma DivMod_14503(x: int, c: int)\n requires c > 0\n ensures x == c * (x / c) + (x % c)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_14504","instance":14504,"id":184503,"goal":"lemma ModBounds_14504(y: nat, j: nat)\n requires j > 0\n ensures 0 <= y % j < j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_14505","instance":14505,"id":184504,"goal":"lemma Square_Nonneg_14505(i: real)\n ensures i * i >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_14506","instance":14506,"id":184505,"goal":"lemma AddComm_14506(k: int, y: int)\n ensures k + y == y + k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_14507","instance":14507,"id":184506,"goal":"lemma AddAssoc_14507(k: nat, n: nat, i: nat)\n ensures (k + n) + i == k + (n + i)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_14508","instance":14508,"id":184507,"goal":"lemma MulComm_14508(d: real, y: real)\n ensures d * y == y * d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_14509","instance":14509,"id":184508,"goal":"lemma MulAssoc_14509(j: int, n: int, i: int)\n ensures (j * n) * i == j * (n * i)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_14510","instance":14510,"id":184509,"goal":"lemma Distrib_14510(d: nat, c: nat, b: nat)\n ensures d * (c + b) == d * c + d * b\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_14511","instance":14511,"id":184510,"goal":"lemma AddZero_14511(y: real)\n ensures y + 0 == y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_14512","instance":14512,"id":184511,"goal":"lemma MulOne_14512(y: int)\n ensures y * 1 == y\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_14513","instance":14513,"id":184512,"goal":"lemma MulZero_14513(j: nat)\n ensures j * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_14514","instance":14514,"id":184513,"goal":"lemma LeRefl_14514(z: real)\n ensures z <= z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_14515","instance":14515,"id":184514,"goal":"lemma LeTrans_14515(a: int, x: int, b: int)\n requires a <= x && x <= b\n ensures a <= b\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_14516","instance":14516,"id":184515,"goal":"lemma AddMono_14516(x: nat, i: nat, d: nat)\n requires x <= i\n ensures x + d <= i + d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_14517","instance":14517,"id":184516,"goal":"lemma Abs_Nonneg_14517(x: real)\n ensures (if x >= 0 then x else -x) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_14518","instance":14518,"id":184517,"goal":"lemma DivMod_14518(c: int, d: int)\n requires d > 0\n ensures c == d * (c / d) + (c % d)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_14519","instance":14519,"id":184518,"goal":"lemma ModBounds_14519(a: nat, b: nat)\n requires b > 0\n ensures 0 <= a % b < b\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_14520","instance":14520,"id":184519,"goal":"lemma Square_Nonneg_14520(a: real)\n ensures a * a >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_14521","instance":14521,"id":184520,"goal":"lemma AddComm_14521(y: int, x: int)\n ensures y + x == x + y\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_14522","instance":14522,"id":184521,"goal":"lemma AddAssoc_14522(z: nat, i: nat, j: nat)\n ensures (z + i) + j == z + (i + j)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_14523","instance":14523,"id":184522,"goal":"lemma MulComm_14523(d: real, c: real)\n ensures d * c == c * d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_14524","instance":14524,"id":184523,"goal":"lemma MulAssoc_14524(i: int, z: int, n: int)\n ensures (i * z) * n == i * (z * n)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_14525","instance":14525,"id":184524,"goal":"lemma Distrib_14525(m: nat, a: nat, c: nat)\n ensures m * (a + c) == m * a + m * c\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_14526","instance":14526,"id":184525,"goal":"lemma AddZero_14526(z: real)\n ensures z + 0 == z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_14527","instance":14527,"id":184526,"goal":"lemma MulOne_14527(b: int)\n ensures b * 1 == b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_14528","instance":14528,"id":184527,"goal":"lemma MulZero_14528(m: nat)\n ensures m * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_14529","instance":14529,"id":184528,"goal":"lemma LeRefl_14529(a: real)\n ensures a <= a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_14530","instance":14530,"id":184529,"goal":"lemma LeTrans_14530(k: int, n: int, y: int)\n requires k <= n && n <= y\n ensures k <= y\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_14531","instance":14531,"id":184530,"goal":"lemma AddMono_14531(i: nat, x: nat, z: nat)\n requires i <= x\n ensures i + z <= x + z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_14532","instance":14532,"id":184531,"goal":"lemma Abs_Nonneg_14532(m: real)\n ensures (if m >= 0 then m else -m) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_14533","instance":14533,"id":184532,"goal":"lemma DivMod_14533(y: int, b: int)\n requires b > 0\n ensures y == b * (y / b) + (y % b)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_14534","instance":14534,"id":184533,"goal":"lemma ModBounds_14534(b: nat, x: nat)\n requires x > 0\n ensures 0 <= b % x < x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_14535","instance":14535,"id":184534,"goal":"lemma Square_Nonneg_14535(y: real)\n ensures y * y >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_14536","instance":14536,"id":184535,"goal":"lemma AddComm_14536(j: int, z: int)\n ensures j + z == z + j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_14537","instance":14537,"id":184536,"goal":"lemma AddAssoc_14537(i: nat, n: nat, m: nat)\n ensures (i + n) + m == i + (n + m)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_14538","instance":14538,"id":184537,"goal":"lemma MulComm_14538(x: real, m: real)\n ensures x * m == m * x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_14539","instance":14539,"id":184538,"goal":"lemma MulAssoc_14539(m: int, x: int, y: int)\n ensures (m * x) * y == m * (x * y)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_14540","instance":14540,"id":184539,"goal":"lemma Distrib_14540(x: nat, b: nat, m: nat)\n ensures x * (b + m) == x * b + x * m\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_14541","instance":14541,"id":184540,"goal":"lemma AddZero_14541(i: real)\n ensures i + 0 == i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_14542","instance":14542,"id":184541,"goal":"lemma MulOne_14542(i: int)\n ensures i * 1 == i\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_14543","instance":14543,"id":184542,"goal":"lemma MulZero_14543(c: nat)\n ensures c * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_14544","instance":14544,"id":184543,"goal":"lemma LeRefl_14544(a: real)\n ensures a <= a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_14545","instance":14545,"id":184544,"goal":"lemma LeTrans_14545(x: int, i: int, n: int)\n requires x <= i && i <= n\n ensures x <= n\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_14546","instance":14546,"id":184545,"goal":"lemma AddMono_14546(y: nat, x: nat, b: nat)\n requires y <= x\n ensures y + b <= x + b\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_14547","instance":14547,"id":184546,"goal":"lemma Abs_Nonneg_14547(j: real)\n ensures (if j >= 0 then j else -j) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_14548","instance":14548,"id":184547,"goal":"lemma DivMod_14548(i: int, b: int)\n requires b > 0\n ensures i == b * (i / b) + (i % b)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_14549","instance":14549,"id":184548,"goal":"lemma ModBounds_14549(m: nat, b: nat)\n requires b > 0\n ensures 0 <= m % b < b\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_14550","instance":14550,"id":184549,"goal":"lemma Square_Nonneg_14550(k: real)\n ensures k * k >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_14551","instance":14551,"id":184550,"goal":"lemma AddComm_14551(b: int, y: int)\n ensures b + y == y + b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_14552","instance":14552,"id":184551,"goal":"lemma AddAssoc_14552(j: nat, i: nat, d: nat)\n ensures (j + i) + d == j + (i + d)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_14553","instance":14553,"id":184552,"goal":"lemma MulComm_14553(c: real, b: real)\n ensures c * b == b * c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_14554","instance":14554,"id":184553,"goal":"lemma MulAssoc_14554(n: int, a: int, b: int)\n ensures (n * a) * b == n * (a * b)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_14555","instance":14555,"id":184554,"goal":"lemma Distrib_14555(z: nat, c: nat, y: nat)\n ensures z * (c + y) == z * c + z * y\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_14556","instance":14556,"id":184555,"goal":"lemma AddZero_14556(m: real)\n ensures m + 0 == m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_14557","instance":14557,"id":184556,"goal":"lemma MulOne_14557(x: int)\n ensures x * 1 == x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_14558","instance":14558,"id":184557,"goal":"lemma MulZero_14558(k: nat)\n ensures k * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_14559","instance":14559,"id":184558,"goal":"lemma LeRefl_14559(c: real)\n ensures c <= c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_14560","instance":14560,"id":184559,"goal":"lemma LeTrans_14560(k: int, c: int, x: int)\n requires k <= c && c <= x\n ensures k <= x\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_14561","instance":14561,"id":184560,"goal":"lemma AddMono_14561(x: nat, m: nat, b: nat)\n requires x <= m\n ensures x + b <= m + b\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_14562","instance":14562,"id":184561,"goal":"lemma Abs_Nonneg_14562(n: real)\n ensures (if n >= 0 then n else -n) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_14563","instance":14563,"id":184562,"goal":"lemma DivMod_14563(x: int, n: int)\n requires n > 0\n ensures x == n * (x / n) + (x % n)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_14564","instance":14564,"id":184563,"goal":"lemma ModBounds_14564(k: nat, j: nat)\n requires j > 0\n ensures 0 <= k % j < j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_14565","instance":14565,"id":184564,"goal":"lemma Square_Nonneg_14565(a: real)\n ensures a * a >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_14566","instance":14566,"id":184565,"goal":"lemma AddComm_14566(i: int, z: int)\n ensures i + z == z + i\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_14567","instance":14567,"id":184566,"goal":"lemma AddAssoc_14567(z: nat, a: nat, y: nat)\n ensures (z + a) + y == z + (a + y)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_14568","instance":14568,"id":184567,"goal":"lemma MulComm_14568(z: real, b: real)\n ensures z * b == b * z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_14569","instance":14569,"id":184568,"goal":"lemma MulAssoc_14569(d: int, y: int, k: int)\n ensures (d * y) * k == d * (y * k)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_14570","instance":14570,"id":184569,"goal":"lemma Distrib_14570(x: nat, y: nat, c: nat)\n ensures x * (y + c) == x * y + x * c\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_14571","instance":14571,"id":184570,"goal":"lemma AddZero_14571(d: real)\n ensures d + 0 == d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_14572","instance":14572,"id":184571,"goal":"lemma MulOne_14572(y: int)\n ensures y * 1 == y\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_14573","instance":14573,"id":184572,"goal":"lemma MulZero_14573(k: nat)\n ensures k * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_14574","instance":14574,"id":184573,"goal":"lemma LeRefl_14574(m: real)\n ensures m <= m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_14575","instance":14575,"id":184574,"goal":"lemma LeTrans_14575(a: int, k: int, i: int)\n requires a <= k && k <= i\n ensures a <= i\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_14576","instance":14576,"id":184575,"goal":"lemma AddMono_14576(d: nat, a: nat, y: nat)\n requires d <= a\n ensures d + y <= a + y\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_14577","instance":14577,"id":184576,"goal":"lemma Abs_Nonneg_14577(i: real)\n ensures (if i >= 0 then i else -i) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_14578","instance":14578,"id":184577,"goal":"lemma DivMod_14578(b: int, i: int)\n requires i > 0\n ensures b == i * (b / i) + (b % i)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_14579","instance":14579,"id":184578,"goal":"lemma ModBounds_14579(k: nat, b: nat)\n requires b > 0\n ensures 0 <= k % b < b\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_14580","instance":14580,"id":184579,"goal":"lemma Square_Nonneg_14580(y: real)\n ensures y * y >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_14581","instance":14581,"id":184580,"goal":"lemma AddComm_14581(i: int, n: int)\n ensures i + n == n + i\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_14582","instance":14582,"id":184581,"goal":"lemma AddAssoc_14582(x: nat, a: nat, z: nat)\n ensures (x + a) + z == x + (a + z)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_14583","instance":14583,"id":184582,"goal":"lemma MulComm_14583(z: real, j: real)\n ensures z * j == j * z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_14584","instance":14584,"id":184583,"goal":"lemma MulAssoc_14584(i: int, z: int, x: int)\n ensures (i * z) * x == i * (z * x)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_14585","instance":14585,"id":184584,"goal":"lemma Distrib_14585(i: nat, b: nat, y: nat)\n ensures i * (b + y) == i * b + i * y\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_14586","instance":14586,"id":184585,"goal":"lemma AddZero_14586(d: real)\n ensures d + 0 == d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_14587","instance":14587,"id":184586,"goal":"lemma MulOne_14587(d: int)\n ensures d * 1 == d\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_14588","instance":14588,"id":184587,"goal":"lemma MulZero_14588(x: nat)\n ensures x * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_14589","instance":14589,"id":184588,"goal":"lemma LeRefl_14589(i: real)\n ensures i <= i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_14590","instance":14590,"id":184589,"goal":"lemma LeTrans_14590(y: int, x: int, k: int)\n requires y <= x && x <= k\n ensures y <= k\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_14591","instance":14591,"id":184590,"goal":"lemma AddMono_14591(b: nat, d: nat, y: nat)\n requires b <= d\n ensures b + y <= d + y\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_14592","instance":14592,"id":184591,"goal":"lemma Abs_Nonneg_14592(k: real)\n ensures (if k >= 0 then k else -k) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_14593","instance":14593,"id":184592,"goal":"lemma DivMod_14593(c: int, z: int)\n requires z > 0\n ensures c == z * (c / z) + (c % z)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_14594","instance":14594,"id":184593,"goal":"lemma ModBounds_14594(d: nat, x: nat)\n requires x > 0\n ensures 0 <= d % x < x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_14595","instance":14595,"id":184594,"goal":"lemma Square_Nonneg_14595(z: real)\n ensures z * z >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_14596","instance":14596,"id":184595,"goal":"lemma AddComm_14596(d: int, n: int)\n ensures d + n == n + d\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_14597","instance":14597,"id":184596,"goal":"lemma AddAssoc_14597(d: nat, j: nat, z: nat)\n ensures (d + j) + z == d + (j + z)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_14598","instance":14598,"id":184597,"goal":"lemma MulComm_14598(z: real, j: real)\n ensures z * j == j * z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_14599","instance":14599,"id":184598,"goal":"lemma MulAssoc_14599(k: int, m: int, b: int)\n ensures (k * m) * b == k * (m * b)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_14600","instance":14600,"id":184599,"goal":"lemma Distrib_14600(k: nat, d: nat, x: nat)\n ensures k * (d + x) == k * d + k * x\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_14601","instance":14601,"id":184600,"goal":"lemma AddZero_14601(i: real)\n ensures i + 0 == i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_14602","instance":14602,"id":184601,"goal":"lemma MulOne_14602(a: int)\n ensures a * 1 == a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_14603","instance":14603,"id":184602,"goal":"lemma MulZero_14603(a: nat)\n ensures a * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_14604","instance":14604,"id":184603,"goal":"lemma LeRefl_14604(m: real)\n ensures m <= m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_14605","instance":14605,"id":184604,"goal":"lemma LeTrans_14605(x: int, j: int, i: int)\n requires x <= j && j <= i\n ensures x <= i\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_14606","instance":14606,"id":184605,"goal":"lemma AddMono_14606(b: nat, x: nat, a: nat)\n requires b <= x\n ensures b + a <= x + a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_14607","instance":14607,"id":184606,"goal":"lemma Abs_Nonneg_14607(a: real)\n ensures (if a >= 0 then a else -a) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_14608","instance":14608,"id":184607,"goal":"lemma DivMod_14608(x: int, k: int)\n requires k > 0\n ensures x == k * (x / k) + (x % k)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_14609","instance":14609,"id":184608,"goal":"lemma ModBounds_14609(a: nat, b: nat)\n requires b > 0\n ensures 0 <= a % b < b\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_14610","instance":14610,"id":184609,"goal":"lemma Square_Nonneg_14610(i: real)\n ensures i * i >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_14611","instance":14611,"id":184610,"goal":"lemma AddComm_14611(k: int, a: int)\n ensures k + a == a + k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_14612","instance":14612,"id":184611,"goal":"lemma AddAssoc_14612(c: nat, j: nat, m: nat)\n ensures (c + j) + m == c + (j + m)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_14613","instance":14613,"id":184612,"goal":"lemma MulComm_14613(d: real, z: real)\n ensures d * z == z * d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_14614","instance":14614,"id":184613,"goal":"lemma MulAssoc_14614(n: int, m: int, k: int)\n ensures (n * m) * k == n * (m * k)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_14615","instance":14615,"id":184614,"goal":"lemma Distrib_14615(i: nat, d: nat, x: nat)\n ensures i * (d + x) == i * d + i * x\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_14616","instance":14616,"id":184615,"goal":"lemma AddZero_14616(x: real)\n ensures x + 0 == x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_14617","instance":14617,"id":184616,"goal":"lemma MulOne_14617(m: int)\n ensures m * 1 == m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_14618","instance":14618,"id":184617,"goal":"lemma MulZero_14618(d: nat)\n ensures d * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_14619","instance":14619,"id":184618,"goal":"lemma LeRefl_14619(b: real)\n ensures b <= b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_14620","instance":14620,"id":184619,"goal":"lemma LeTrans_14620(m: int, y: int, c: int)\n requires m <= y && y <= c\n ensures m <= c\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_14621","instance":14621,"id":184620,"goal":"lemma AddMono_14621(m: nat, x: nat, d: nat)\n requires m <= x\n ensures m + d <= x + d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_14622","instance":14622,"id":184621,"goal":"lemma Abs_Nonneg_14622(m: real)\n ensures (if m >= 0 then m else -m) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_14623","instance":14623,"id":184622,"goal":"lemma DivMod_14623(b: int, m: int)\n requires m > 0\n ensures b == m * (b / m) + (b % m)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_14624","instance":14624,"id":184623,"goal":"lemma ModBounds_14624(a: nat, j: nat)\n requires j > 0\n ensures 0 <= a % j < j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_14625","instance":14625,"id":184624,"goal":"lemma Square_Nonneg_14625(d: real)\n ensures d * d >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_14626","instance":14626,"id":184625,"goal":"lemma AddComm_14626(y: int, k: int)\n ensures y + k == k + y\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_14627","instance":14627,"id":184626,"goal":"lemma AddAssoc_14627(m: nat, k: nat, i: nat)\n ensures (m + k) + i == m + (k + i)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_14628","instance":14628,"id":184627,"goal":"lemma MulComm_14628(y: real, j: real)\n ensures y * j == j * y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_14629","instance":14629,"id":184628,"goal":"lemma MulAssoc_14629(c: int, j: int, m: int)\n ensures (c * j) * m == c * (j * m)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_14630","instance":14630,"id":184629,"goal":"lemma Distrib_14630(k: nat, c: nat, y: nat)\n ensures k * (c + y) == k * c + k * y\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_14631","instance":14631,"id":184630,"goal":"lemma AddZero_14631(c: real)\n ensures c + 0 == c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_14632","instance":14632,"id":184631,"goal":"lemma MulOne_14632(a: int)\n ensures a * 1 == a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_14633","instance":14633,"id":184632,"goal":"lemma MulZero_14633(b: nat)\n ensures b * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_14634","instance":14634,"id":184633,"goal":"lemma LeRefl_14634(m: real)\n ensures m <= m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_14635","instance":14635,"id":184634,"goal":"lemma LeTrans_14635(b: int, j: int, z: int)\n requires b <= j && j <= z\n ensures b <= z\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_14636","instance":14636,"id":184635,"goal":"lemma AddMono_14636(n: nat, i: nat, y: nat)\n requires n <= i\n ensures n + y <= i + y\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_14637","instance":14637,"id":184636,"goal":"lemma Abs_Nonneg_14637(c: real)\n ensures (if c >= 0 then c else -c) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_14638","instance":14638,"id":184637,"goal":"lemma DivMod_14638(i: int, j: int)\n requires j > 0\n ensures i == j * (i / j) + (i % j)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_14639","instance":14639,"id":184638,"goal":"lemma ModBounds_14639(x: nat, a: nat)\n requires a > 0\n ensures 0 <= x % a < a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_14640","instance":14640,"id":184639,"goal":"lemma Square_Nonneg_14640(x: real)\n ensures x * x >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_14641","instance":14641,"id":184640,"goal":"lemma AddComm_14641(j: int, x: int)\n ensures j + x == x + j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_14642","instance":14642,"id":184641,"goal":"lemma AddAssoc_14642(z: nat, y: nat, j: nat)\n ensures (z + y) + j == z + (y + j)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_14643","instance":14643,"id":184642,"goal":"lemma MulComm_14643(x: real, d: real)\n ensures x * d == d * x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_14644","instance":14644,"id":184643,"goal":"lemma MulAssoc_14644(i: int, y: int, b: int)\n ensures (i * y) * b == i * (y * b)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_14645","instance":14645,"id":184644,"goal":"lemma Distrib_14645(a: nat, k: nat, b: nat)\n ensures a * (k + b) == a * k + a * b\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_14646","instance":14646,"id":184645,"goal":"lemma AddZero_14646(z: real)\n ensures z + 0 == z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_14647","instance":14647,"id":184646,"goal":"lemma MulOne_14647(b: int)\n ensures b * 1 == b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_14648","instance":14648,"id":184647,"goal":"lemma MulZero_14648(k: nat)\n ensures k * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_14649","instance":14649,"id":184648,"goal":"lemma LeRefl_14649(z: real)\n ensures z <= z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_14650","instance":14650,"id":184649,"goal":"lemma LeTrans_14650(m: int, d: int, z: int)\n requires m <= d && d <= z\n ensures m <= z\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_14651","instance":14651,"id":184650,"goal":"lemma AddMono_14651(i: nat, m: nat, n: nat)\n requires i <= m\n ensures i + n <= m + n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_14652","instance":14652,"id":184651,"goal":"lemma Abs_Nonneg_14652(n: real)\n ensures (if n >= 0 then n else -n) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_14653","instance":14653,"id":184652,"goal":"lemma DivMod_14653(j: int, i: int)\n requires i > 0\n ensures j == i * (j / i) + (j % i)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_14654","instance":14654,"id":184653,"goal":"lemma ModBounds_14654(c: nat, d: nat)\n requires d > 0\n ensures 0 <= c % d < d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_14655","instance":14655,"id":184654,"goal":"lemma Square_Nonneg_14655(a: real)\n ensures a * a >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_14656","instance":14656,"id":184655,"goal":"lemma AddComm_14656(k: int, i: int)\n ensures k + i == i + k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_14657","instance":14657,"id":184656,"goal":"lemma AddAssoc_14657(a: nat, z: nat, c: nat)\n ensures (a + z) + c == a + (z + c)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_14658","instance":14658,"id":184657,"goal":"lemma MulComm_14658(c: real, k: real)\n ensures c * k == k * c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_14659","instance":14659,"id":184658,"goal":"lemma MulAssoc_14659(y: int, i: int, n: int)\n ensures (y * i) * n == y * (i * n)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_14660","instance":14660,"id":184659,"goal":"lemma Distrib_14660(a: nat, k: nat, c: nat)\n ensures a * (k + c) == a * k + a * c\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_14661","instance":14661,"id":184660,"goal":"lemma AddZero_14661(a: real)\n ensures a + 0 == a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_14662","instance":14662,"id":184661,"goal":"lemma MulOne_14662(k: int)\n ensures k * 1 == k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_14663","instance":14663,"id":184662,"goal":"lemma MulZero_14663(c: nat)\n ensures c * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_14664","instance":14664,"id":184663,"goal":"lemma LeRefl_14664(z: real)\n ensures z <= z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_14665","instance":14665,"id":184664,"goal":"lemma LeTrans_14665(k: int, a: int, j: int)\n requires k <= a && a <= j\n ensures k <= j\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_14666","instance":14666,"id":184665,"goal":"lemma AddMono_14666(m: nat, a: nat, k: nat)\n requires m <= a\n ensures m + k <= a + k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_14667","instance":14667,"id":184666,"goal":"lemma Abs_Nonneg_14667(k: real)\n ensures (if k >= 0 then k else -k) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_14668","instance":14668,"id":184667,"goal":"lemma DivMod_14668(a: int, y: int)\n requires y > 0\n ensures a == y * (a / y) + (a % y)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_14669","instance":14669,"id":184668,"goal":"lemma ModBounds_14669(x: nat, n: nat)\n requires n > 0\n ensures 0 <= x % n < n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_14670","instance":14670,"id":184669,"goal":"lemma Square_Nonneg_14670(d: real)\n ensures d * d >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_14671","instance":14671,"id":184670,"goal":"lemma AddComm_14671(y: int, a: int)\n ensures y + a == a + y\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_14672","instance":14672,"id":184671,"goal":"lemma AddAssoc_14672(m: nat, z: nat, d: nat)\n ensures (m + z) + d == m + (z + d)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_14673","instance":14673,"id":184672,"goal":"lemma MulComm_14673(a: real, c: real)\n ensures a * c == c * a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_14674","instance":14674,"id":184673,"goal":"lemma MulAssoc_14674(c: int, i: int, z: int)\n ensures (c * i) * z == c * (i * z)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_14675","instance":14675,"id":184674,"goal":"lemma Distrib_14675(c: nat, z: nat, k: nat)\n ensures c * (z + k) == c * z + c * k\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_14676","instance":14676,"id":184675,"goal":"lemma AddZero_14676(y: real)\n ensures y + 0 == y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_14677","instance":14677,"id":184676,"goal":"lemma MulOne_14677(i: int)\n ensures i * 1 == i\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_14678","instance":14678,"id":184677,"goal":"lemma MulZero_14678(y: nat)\n ensures y * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_14679","instance":14679,"id":184678,"goal":"lemma LeRefl_14679(a: real)\n ensures a <= a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_14680","instance":14680,"id":184679,"goal":"lemma LeTrans_14680(y: int, k: int, a: int)\n requires y <= k && k <= a\n ensures y <= a\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_14681","instance":14681,"id":184680,"goal":"lemma AddMono_14681(c: nat, y: nat, j: nat)\n requires c <= y\n ensures c + j <= y + j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_14682","instance":14682,"id":184681,"goal":"lemma Abs_Nonneg_14682(k: real)\n ensures (if k >= 0 then k else -k) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_14683","instance":14683,"id":184682,"goal":"lemma DivMod_14683(m: int, k: int)\n requires k > 0\n ensures m == k * (m / k) + (m % k)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_14684","instance":14684,"id":184683,"goal":"lemma ModBounds_14684(m: nat, b: nat)\n requires b > 0\n ensures 0 <= m % b < b\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_14685","instance":14685,"id":184684,"goal":"lemma Square_Nonneg_14685(d: real)\n ensures d * d >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_14686","instance":14686,"id":184685,"goal":"lemma AddComm_14686(m: int, a: int)\n ensures m + a == a + m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_14687","instance":14687,"id":184686,"goal":"lemma AddAssoc_14687(n: nat, z: nat, k: nat)\n ensures (n + z) + k == n + (z + k)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_14688","instance":14688,"id":184687,"goal":"lemma MulComm_14688(n: real, z: real)\n ensures n * z == z * n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_14689","instance":14689,"id":184688,"goal":"lemma MulAssoc_14689(z: int, n: int, d: int)\n ensures (z * n) * d == z * (n * d)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_14690","instance":14690,"id":184689,"goal":"lemma Distrib_14690(i: nat, b: nat, m: nat)\n ensures i * (b + m) == i * b + i * m\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_14691","instance":14691,"id":184690,"goal":"lemma AddZero_14691(x: real)\n ensures x + 0 == x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_14692","instance":14692,"id":184691,"goal":"lemma MulOne_14692(j: int)\n ensures j * 1 == j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_14693","instance":14693,"id":184692,"goal":"lemma MulZero_14693(d: nat)\n ensures d * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_14694","instance":14694,"id":184693,"goal":"lemma LeRefl_14694(a: real)\n ensures a <= a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_14695","instance":14695,"id":184694,"goal":"lemma LeTrans_14695(j: int, x: int, z: int)\n requires j <= x && x <= z\n ensures j <= z\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_14696","instance":14696,"id":184695,"goal":"lemma AddMono_14696(n: nat, i: nat, z: nat)\n requires n <= i\n ensures n + z <= i + z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_14697","instance":14697,"id":184696,"goal":"lemma Abs_Nonneg_14697(n: real)\n ensures (if n >= 0 then n else -n) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_14698","instance":14698,"id":184697,"goal":"lemma DivMod_14698(m: int, b: int)\n requires b > 0\n ensures m == b * (m / b) + (m % b)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_14699","instance":14699,"id":184698,"goal":"lemma ModBounds_14699(c: nat, z: nat)\n requires z > 0\n ensures 0 <= c % z < z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_14700","instance":14700,"id":184699,"goal":"lemma Square_Nonneg_14700(a: real)\n ensures a * a >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_14701","instance":14701,"id":184700,"goal":"lemma AddComm_14701(b: int, i: int)\n ensures b + i == i + b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_14702","instance":14702,"id":184701,"goal":"lemma AddAssoc_14702(i: nat, z: nat, c: nat)\n ensures (i + z) + c == i + (z + c)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_14703","instance":14703,"id":184702,"goal":"lemma MulComm_14703(c: real, m: real)\n ensures c * m == m * c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_14704","instance":14704,"id":184703,"goal":"lemma MulAssoc_14704(b: int, m: int, n: int)\n ensures (b * m) * n == b * (m * n)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_14705","instance":14705,"id":184704,"goal":"lemma Distrib_14705(n: nat, x: nat, i: nat)\n ensures n * (x + i) == n * x + n * i\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_14706","instance":14706,"id":184705,"goal":"lemma AddZero_14706(n: real)\n ensures n + 0 == n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_14707","instance":14707,"id":184706,"goal":"lemma MulOne_14707(m: int)\n ensures m * 1 == m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_14708","instance":14708,"id":184707,"goal":"lemma MulZero_14708(y: nat)\n ensures y * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_14709","instance":14709,"id":184708,"goal":"lemma LeRefl_14709(a: real)\n ensures a <= a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_14710","instance":14710,"id":184709,"goal":"lemma LeTrans_14710(k: int, z: int, y: int)\n requires k <= z && z <= y\n ensures k <= y\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_14711","instance":14711,"id":184710,"goal":"lemma AddMono_14711(n: nat, i: nat, k: nat)\n requires n <= i\n ensures n + k <= i + k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_14712","instance":14712,"id":184711,"goal":"lemma Abs_Nonneg_14712(k: real)\n ensures (if k >= 0 then k else -k) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_14713","instance":14713,"id":184712,"goal":"lemma DivMod_14713(k: int, a: int)\n requires a > 0\n ensures k == a * (k / a) + (k % a)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_14714","instance":14714,"id":184713,"goal":"lemma ModBounds_14714(x: nat, c: nat)\n requires c > 0\n ensures 0 <= x % c < c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_14715","instance":14715,"id":184714,"goal":"lemma Square_Nonneg_14715(n: real)\n ensures n * n >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_14716","instance":14716,"id":184715,"goal":"lemma AddComm_14716(b: int, i: int)\n ensures b + i == i + b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_14717","instance":14717,"id":184716,"goal":"lemma AddAssoc_14717(x: nat, b: nat, y: nat)\n ensures (x + b) + y == x + (b + y)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_14718","instance":14718,"id":184717,"goal":"lemma MulComm_14718(c: real, y: real)\n ensures c * y == y * c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_14719","instance":14719,"id":184718,"goal":"lemma MulAssoc_14719(z: int, a: int, c: int)\n ensures (z * a) * c == z * (a * c)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_14720","instance":14720,"id":184719,"goal":"lemma Distrib_14720(d: nat, m: nat, y: nat)\n ensures d * (m + y) == d * m + d * y\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_14721","instance":14721,"id":184720,"goal":"lemma AddZero_14721(b: real)\n ensures b + 0 == b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_14722","instance":14722,"id":184721,"goal":"lemma MulOne_14722(a: int)\n ensures a * 1 == a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_14723","instance":14723,"id":184722,"goal":"lemma MulZero_14723(a: nat)\n ensures a * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_14724","instance":14724,"id":184723,"goal":"lemma LeRefl_14724(m: real)\n ensures m <= m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_14725","instance":14725,"id":184724,"goal":"lemma LeTrans_14725(y: int, a: int, c: int)\n requires y <= a && a <= c\n ensures y <= c\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_14726","instance":14726,"id":184725,"goal":"lemma AddMono_14726(b: nat, x: nat, j: nat)\n requires b <= x\n ensures b + j <= x + j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_14727","instance":14727,"id":184726,"goal":"lemma Abs_Nonneg_14727(d: real)\n ensures (if d >= 0 then d else -d) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_14728","instance":14728,"id":184727,"goal":"lemma DivMod_14728(x: int, b: int)\n requires b > 0\n ensures x == b * (x / b) + (x % b)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_14729","instance":14729,"id":184728,"goal":"lemma ModBounds_14729(d: nat, z: nat)\n requires z > 0\n ensures 0 <= d % z < z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_14730","instance":14730,"id":184729,"goal":"lemma Square_Nonneg_14730(z: real)\n ensures z * z >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_14731","instance":14731,"id":184730,"goal":"lemma AddComm_14731(y: int, d: int)\n ensures y + d == d + y\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_14732","instance":14732,"id":184731,"goal":"lemma AddAssoc_14732(z: nat, c: nat, d: nat)\n ensures (z + c) + d == z + (c + d)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_14733","instance":14733,"id":184732,"goal":"lemma MulComm_14733(m: real, k: real)\n ensures m * k == k * m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_14734","instance":14734,"id":184733,"goal":"lemma MulAssoc_14734(j: int, a: int, m: int)\n ensures (j * a) * m == j * (a * m)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_14735","instance":14735,"id":184734,"goal":"lemma Distrib_14735(z: nat, x: nat, i: nat)\n ensures z * (x + i) == z * x + z * i\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_14736","instance":14736,"id":184735,"goal":"lemma AddZero_14736(y: real)\n ensures y + 0 == y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_14737","instance":14737,"id":184736,"goal":"lemma MulOne_14737(n: int)\n ensures n * 1 == n\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_14738","instance":14738,"id":184737,"goal":"lemma MulZero_14738(k: nat)\n ensures k * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_14739","instance":14739,"id":184738,"goal":"lemma LeRefl_14739(i: real)\n ensures i <= i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_14740","instance":14740,"id":184739,"goal":"lemma LeTrans_14740(b: int, c: int, k: int)\n requires b <= c && c <= k\n ensures b <= k\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_14741","instance":14741,"id":184740,"goal":"lemma AddMono_14741(i: nat, c: nat, m: nat)\n requires i <= c\n ensures i + m <= c + m\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_14742","instance":14742,"id":184741,"goal":"lemma Abs_Nonneg_14742(m: real)\n ensures (if m >= 0 then m else -m) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_14743","instance":14743,"id":184742,"goal":"lemma DivMod_14743(d: int, i: int)\n requires i > 0\n ensures d == i * (d / i) + (d % i)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_14744","instance":14744,"id":184743,"goal":"lemma ModBounds_14744(z: nat, j: nat)\n requires j > 0\n ensures 0 <= z % j < j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_14745","instance":14745,"id":184744,"goal":"lemma Square_Nonneg_14745(b: real)\n ensures b * b >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_14746","instance":14746,"id":184745,"goal":"lemma AddComm_14746(c: int, b: int)\n ensures c + b == b + c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_14747","instance":14747,"id":184746,"goal":"lemma AddAssoc_14747(d: nat, x: nat, c: nat)\n ensures (d + x) + c == d + (x + c)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_14748","instance":14748,"id":184747,"goal":"lemma MulComm_14748(b: real, m: real)\n ensures b * m == m * b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_14749","instance":14749,"id":184748,"goal":"lemma MulAssoc_14749(m: int, b: int, x: int)\n ensures (m * b) * x == m * (b * x)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_14750","instance":14750,"id":184749,"goal":"lemma Distrib_14750(c: nat, k: nat, d: nat)\n ensures c * (k + d) == c * k + c * d\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_14751","instance":14751,"id":184750,"goal":"lemma AddZero_14751(x: real)\n ensures x + 0 == x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_14752","instance":14752,"id":184751,"goal":"lemma MulOne_14752(y: int)\n ensures y * 1 == y\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_14753","instance":14753,"id":184752,"goal":"lemma MulZero_14753(a: nat)\n ensures a * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_14754","instance":14754,"id":184753,"goal":"lemma LeRefl_14754(d: real)\n ensures d <= d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_14755","instance":14755,"id":184754,"goal":"lemma LeTrans_14755(j: int, a: int, b: int)\n requires j <= a && a <= b\n ensures j <= b\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_14756","instance":14756,"id":184755,"goal":"lemma AddMono_14756(k: nat, n: nat, z: nat)\n requires k <= n\n ensures k + z <= n + z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_14757","instance":14757,"id":184756,"goal":"lemma Abs_Nonneg_14757(j: real)\n ensures (if j >= 0 then j else -j) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_14758","instance":14758,"id":184757,"goal":"lemma DivMod_14758(k: int, i: int)\n requires i > 0\n ensures k == i * (k / i) + (k % i)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_14759","instance":14759,"id":184758,"goal":"lemma ModBounds_14759(m: nat, x: nat)\n requires x > 0\n ensures 0 <= m % x < x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_14760","instance":14760,"id":184759,"goal":"lemma Square_Nonneg_14760(n: real)\n ensures n * n >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_14761","instance":14761,"id":184760,"goal":"lemma AddComm_14761(j: int, z: int)\n ensures j + z == z + j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_14762","instance":14762,"id":184761,"goal":"lemma AddAssoc_14762(d: nat, a: nat, n: nat)\n ensures (d + a) + n == d + (a + n)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_14763","instance":14763,"id":184762,"goal":"lemma MulComm_14763(a: real, m: real)\n ensures a * m == m * a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_14764","instance":14764,"id":184763,"goal":"lemma MulAssoc_14764(m: int, a: int, x: int)\n ensures (m * a) * x == m * (a * x)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_14765","instance":14765,"id":184764,"goal":"lemma Distrib_14765(a: nat, d: nat, y: nat)\n ensures a * (d + y) == a * d + a * y\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_14766","instance":14766,"id":184765,"goal":"lemma AddZero_14766(n: real)\n ensures n + 0 == n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_14767","instance":14767,"id":184766,"goal":"lemma MulOne_14767(k: int)\n ensures k * 1 == k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_14768","instance":14768,"id":184767,"goal":"lemma MulZero_14768(b: nat)\n ensures b * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_14769","instance":14769,"id":184768,"goal":"lemma LeRefl_14769(a: real)\n ensures a <= a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_14770","instance":14770,"id":184769,"goal":"lemma LeTrans_14770(d: int, n: int, x: int)\n requires d <= n && n <= x\n ensures d <= x\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_14771","instance":14771,"id":184770,"goal":"lemma AddMono_14771(j: nat, k: nat, d: nat)\n requires j <= k\n ensures j + d <= k + d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_14772","instance":14772,"id":184771,"goal":"lemma Abs_Nonneg_14772(n: real)\n ensures (if n >= 0 then n else -n) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_14773","instance":14773,"id":184772,"goal":"lemma DivMod_14773(d: int, x: int)\n requires x > 0\n ensures d == x * (d / x) + (d % x)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_14774","instance":14774,"id":184773,"goal":"lemma ModBounds_14774(k: nat, d: nat)\n requires d > 0\n ensures 0 <= k % d < d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_14775","instance":14775,"id":184774,"goal":"lemma Square_Nonneg_14775(n: real)\n ensures n * n >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_14776","instance":14776,"id":184775,"goal":"lemma AddComm_14776(d: int, c: int)\n ensures d + c == c + d\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_14777","instance":14777,"id":184776,"goal":"lemma AddAssoc_14777(b: nat, i: nat, y: nat)\n ensures (b + i) + y == b + (i + y)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_14778","instance":14778,"id":184777,"goal":"lemma MulComm_14778(d: real, b: real)\n ensures d * b == b * d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_14779","instance":14779,"id":184778,"goal":"lemma MulAssoc_14779(k: int, d: int, n: int)\n ensures (k * d) * n == k * (d * n)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_14780","instance":14780,"id":184779,"goal":"lemma Distrib_14780(z: nat, j: nat, y: nat)\n ensures z * (j + y) == z * j + z * y\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_14781","instance":14781,"id":184780,"goal":"lemma AddZero_14781(b: real)\n ensures b + 0 == b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_14782","instance":14782,"id":184781,"goal":"lemma MulOne_14782(m: int)\n ensures m * 1 == m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_14783","instance":14783,"id":184782,"goal":"lemma MulZero_14783(c: nat)\n ensures c * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_14784","instance":14784,"id":184783,"goal":"lemma LeRefl_14784(c: real)\n ensures c <= c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_14785","instance":14785,"id":184784,"goal":"lemma LeTrans_14785(c: int, j: int, m: int)\n requires c <= j && j <= m\n ensures c <= m\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_14786","instance":14786,"id":184785,"goal":"lemma AddMono_14786(d: nat, y: nat, i: nat)\n requires d <= y\n ensures d + i <= y + i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_14787","instance":14787,"id":184786,"goal":"lemma Abs_Nonneg_14787(y: real)\n ensures (if y >= 0 then y else -y) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_14788","instance":14788,"id":184787,"goal":"lemma DivMod_14788(b: int, d: int)\n requires d > 0\n ensures b == d * (b / d) + (b % d)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_14789","instance":14789,"id":184788,"goal":"lemma ModBounds_14789(y: nat, z: nat)\n requires z > 0\n ensures 0 <= y % z < z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_14790","instance":14790,"id":184789,"goal":"lemma Square_Nonneg_14790(d: real)\n ensures d * d >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_14791","instance":14791,"id":184790,"goal":"lemma AddComm_14791(d: int, i: int)\n ensures d + i == i + d\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_14792","instance":14792,"id":184791,"goal":"lemma AddAssoc_14792(n: nat, b: nat, d: nat)\n ensures (n + b) + d == n + (b + d)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_14793","instance":14793,"id":184792,"goal":"lemma MulComm_14793(i: real, y: real)\n ensures i * y == y * i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_14794","instance":14794,"id":184793,"goal":"lemma MulAssoc_14794(x: int, b: int, a: int)\n ensures (x * b) * a == x * (b * a)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_14795","instance":14795,"id":184794,"goal":"lemma Distrib_14795(k: nat, i: nat, y: nat)\n ensures k * (i + y) == k * i + k * y\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_14796","instance":14796,"id":184795,"goal":"lemma AddZero_14796(a: real)\n ensures a + 0 == a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_14797","instance":14797,"id":184796,"goal":"lemma MulOne_14797(d: int)\n ensures d * 1 == d\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_14798","instance":14798,"id":184797,"goal":"lemma MulZero_14798(c: nat)\n ensures c * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_14799","instance":14799,"id":184798,"goal":"lemma LeRefl_14799(z: real)\n ensures z <= z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_14800","instance":14800,"id":184799,"goal":"lemma LeTrans_14800(x: int, b: int, k: int)\n requires x <= b && b <= k\n ensures x <= k\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_14801","instance":14801,"id":184800,"goal":"lemma AddMono_14801(m: nat, c: nat, b: nat)\n requires m <= c\n ensures m + b <= c + b\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_14802","instance":14802,"id":184801,"goal":"lemma Abs_Nonneg_14802(m: real)\n ensures (if m >= 0 then m else -m) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_14803","instance":14803,"id":184802,"goal":"lemma DivMod_14803(m: int, n: int)\n requires n > 0\n ensures m == n * (m / n) + (m % n)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_14804","instance":14804,"id":184803,"goal":"lemma ModBounds_14804(y: nat, j: nat)\n requires j > 0\n ensures 0 <= y % j < j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_14805","instance":14805,"id":184804,"goal":"lemma Square_Nonneg_14805(d: real)\n ensures d * d >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_14806","instance":14806,"id":184805,"goal":"lemma AddComm_14806(a: int, n: int)\n ensures a + n == n + a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_14807","instance":14807,"id":184806,"goal":"lemma AddAssoc_14807(i: nat, d: nat, j: nat)\n ensures (i + d) + j == i + (d + j)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_14808","instance":14808,"id":184807,"goal":"lemma MulComm_14808(j: real, z: real)\n ensures j * z == z * j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_14809","instance":14809,"id":184808,"goal":"lemma MulAssoc_14809(d: int, c: int, z: int)\n ensures (d * c) * z == d * (c * z)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_14810","instance":14810,"id":184809,"goal":"lemma Distrib_14810(b: nat, c: nat, d: nat)\n ensures b * (c + d) == b * c + b * d\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_14811","instance":14811,"id":184810,"goal":"lemma AddZero_14811(k: real)\n ensures k + 0 == k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_14812","instance":14812,"id":184811,"goal":"lemma MulOne_14812(c: int)\n ensures c * 1 == c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_14813","instance":14813,"id":184812,"goal":"lemma MulZero_14813(m: nat)\n ensures m * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_14814","instance":14814,"id":184813,"goal":"lemma LeRefl_14814(m: real)\n ensures m <= m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_14815","instance":14815,"id":184814,"goal":"lemma LeTrans_14815(a: int, z: int, i: int)\n requires a <= z && z <= i\n ensures a <= i\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_14816","instance":14816,"id":184815,"goal":"lemma AddMono_14816(c: nat, a: nat, z: nat)\n requires c <= a\n ensures c + z <= a + z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_14817","instance":14817,"id":184816,"goal":"lemma Abs_Nonneg_14817(d: real)\n ensures (if d >= 0 then d else -d) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_14818","instance":14818,"id":184817,"goal":"lemma DivMod_14818(k: int, i: int)\n requires i > 0\n ensures k == i * (k / i) + (k % i)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_14819","instance":14819,"id":184818,"goal":"lemma ModBounds_14819(k: nat, m: nat)\n requires m > 0\n ensures 0 <= k % m < m\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_14820","instance":14820,"id":184819,"goal":"lemma Square_Nonneg_14820(j: real)\n ensures j * j >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_14821","instance":14821,"id":184820,"goal":"lemma AddComm_14821(b: int, k: int)\n ensures b + k == k + b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_14822","instance":14822,"id":184821,"goal":"lemma AddAssoc_14822(j: nat, b: nat, i: nat)\n ensures (j + b) + i == j + (b + i)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_14823","instance":14823,"id":184822,"goal":"lemma MulComm_14823(b: real, c: real)\n ensures b * c == c * b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_14824","instance":14824,"id":184823,"goal":"lemma MulAssoc_14824(n: int, a: int, c: int)\n ensures (n * a) * c == n * (a * c)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_14825","instance":14825,"id":184824,"goal":"lemma Distrib_14825(d: nat, a: nat, i: nat)\n ensures d * (a + i) == d * a + d * i\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_14826","instance":14826,"id":184825,"goal":"lemma AddZero_14826(k: real)\n ensures k + 0 == k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_14827","instance":14827,"id":184826,"goal":"lemma MulOne_14827(d: int)\n ensures d * 1 == d\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_14828","instance":14828,"id":184827,"goal":"lemma MulZero_14828(x: nat)\n ensures x * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_14829","instance":14829,"id":184828,"goal":"lemma LeRefl_14829(a: real)\n ensures a <= a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_14830","instance":14830,"id":184829,"goal":"lemma LeTrans_14830(b: int, i: int, y: int)\n requires b <= i && i <= y\n ensures b <= y\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_14831","instance":14831,"id":184830,"goal":"lemma AddMono_14831(n: nat, b: nat, c: nat)\n requires n <= b\n ensures n + c <= b + c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_14832","instance":14832,"id":184831,"goal":"lemma Abs_Nonneg_14832(c: real)\n ensures (if c >= 0 then c else -c) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_14833","instance":14833,"id":184832,"goal":"lemma DivMod_14833(k: int, z: int)\n requires z > 0\n ensures k == z * (k / z) + (k % z)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_14834","instance":14834,"id":184833,"goal":"lemma ModBounds_14834(j: nat, m: nat)\n requires m > 0\n ensures 0 <= j % m < m\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_14835","instance":14835,"id":184834,"goal":"lemma Square_Nonneg_14835(z: real)\n ensures z * z >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_14836","instance":14836,"id":184835,"goal":"lemma AddComm_14836(z: int, x: int)\n ensures z + x == x + z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_14837","instance":14837,"id":184836,"goal":"lemma AddAssoc_14837(a: nat, c: nat, m: nat)\n ensures (a + c) + m == a + (c + m)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_14838","instance":14838,"id":184837,"goal":"lemma MulComm_14838(c: real, a: real)\n ensures c * a == a * c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_14839","instance":14839,"id":184838,"goal":"lemma MulAssoc_14839(c: int, m: int, j: int)\n ensures (c * m) * j == c * (m * j)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_14840","instance":14840,"id":184839,"goal":"lemma Distrib_14840(k: nat, a: nat, i: nat)\n ensures k * (a + i) == k * a + k * i\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_14841","instance":14841,"id":184840,"goal":"lemma AddZero_14841(j: real)\n ensures j + 0 == j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_14842","instance":14842,"id":184841,"goal":"lemma MulOne_14842(z: int)\n ensures z * 1 == z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_14843","instance":14843,"id":184842,"goal":"lemma MulZero_14843(a: nat)\n ensures a * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_14844","instance":14844,"id":184843,"goal":"lemma LeRefl_14844(j: real)\n ensures j <= j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_14845","instance":14845,"id":184844,"goal":"lemma LeTrans_14845(a: int, j: int, z: int)\n requires a <= j && j <= z\n ensures a <= z\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_14846","instance":14846,"id":184845,"goal":"lemma AddMono_14846(x: nat, m: nat, d: nat)\n requires x <= m\n ensures x + d <= m + d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_14847","instance":14847,"id":184846,"goal":"lemma Abs_Nonneg_14847(x: real)\n ensures (if x >= 0 then x else -x) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_14848","instance":14848,"id":184847,"goal":"lemma DivMod_14848(c: int, z: int)\n requires z > 0\n ensures c == z * (c / z) + (c % z)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_14849","instance":14849,"id":184848,"goal":"lemma ModBounds_14849(a: nat, y: nat)\n requires y > 0\n ensures 0 <= a % y < y\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_14850","instance":14850,"id":184849,"goal":"lemma Square_Nonneg_14850(m: real)\n ensures m * m >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_14851","instance":14851,"id":184850,"goal":"lemma AddComm_14851(x: int, i: int)\n ensures x + i == i + x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_14852","instance":14852,"id":184851,"goal":"lemma AddAssoc_14852(n: nat, z: nat, b: nat)\n ensures (n + z) + b == n + (z + b)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_14853","instance":14853,"id":184852,"goal":"lemma MulComm_14853(c: real, i: real)\n ensures c * i == i * c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_14854","instance":14854,"id":184853,"goal":"lemma MulAssoc_14854(z: int, a: int, x: int)\n ensures (z * a) * x == z * (a * x)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_14855","instance":14855,"id":184854,"goal":"lemma Distrib_14855(n: nat, d: nat, c: nat)\n ensures n * (d + c) == n * d + n * c\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_14856","instance":14856,"id":184855,"goal":"lemma AddZero_14856(k: real)\n ensures k + 0 == k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_14857","instance":14857,"id":184856,"goal":"lemma MulOne_14857(z: int)\n ensures z * 1 == z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_14858","instance":14858,"id":184857,"goal":"lemma MulZero_14858(k: nat)\n ensures k * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_14859","instance":14859,"id":184858,"goal":"lemma LeRefl_14859(b: real)\n ensures b <= b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_14860","instance":14860,"id":184859,"goal":"lemma LeTrans_14860(k: int, b: int, i: int)\n requires k <= b && b <= i\n ensures k <= i\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_14861","instance":14861,"id":184860,"goal":"lemma AddMono_14861(m: nat, c: nat, a: nat)\n requires m <= c\n ensures m + a <= c + a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_14862","instance":14862,"id":184861,"goal":"lemma Abs_Nonneg_14862(m: real)\n ensures (if m >= 0 then m else -m) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_14863","instance":14863,"id":184862,"goal":"lemma DivMod_14863(d: int, c: int)\n requires c > 0\n ensures d == c * (d / c) + (d % c)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_14864","instance":14864,"id":184863,"goal":"lemma ModBounds_14864(y: nat, d: nat)\n requires d > 0\n ensures 0 <= y % d < d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_14865","instance":14865,"id":184864,"goal":"lemma Square_Nonneg_14865(a: real)\n ensures a * a >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_14866","instance":14866,"id":184865,"goal":"lemma AddComm_14866(d: int, y: int)\n ensures d + y == y + d\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_14867","instance":14867,"id":184866,"goal":"lemma AddAssoc_14867(a: nat, j: nat, d: nat)\n ensures (a + j) + d == a + (j + d)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_14868","instance":14868,"id":184867,"goal":"lemma MulComm_14868(k: real, c: real)\n ensures k * c == c * k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_14869","instance":14869,"id":184868,"goal":"lemma MulAssoc_14869(x: int, m: int, b: int)\n ensures (x * m) * b == x * (m * b)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_14870","instance":14870,"id":184869,"goal":"lemma Distrib_14870(d: nat, a: nat, n: nat)\n ensures d * (a + n) == d * a + d * n\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_14871","instance":14871,"id":184870,"goal":"lemma AddZero_14871(n: real)\n ensures n + 0 == n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_14872","instance":14872,"id":184871,"goal":"lemma MulOne_14872(n: int)\n ensures n * 1 == n\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_14873","instance":14873,"id":184872,"goal":"lemma MulZero_14873(k: nat)\n ensures k * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_14874","instance":14874,"id":184873,"goal":"lemma LeRefl_14874(m: real)\n ensures m <= m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_14875","instance":14875,"id":184874,"goal":"lemma LeTrans_14875(c: int, b: int, x: int)\n requires c <= b && b <= x\n ensures c <= x\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_14876","instance":14876,"id":184875,"goal":"lemma AddMono_14876(i: nat, n: nat, x: nat)\n requires i <= n\n ensures i + x <= n + x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_14877","instance":14877,"id":184876,"goal":"lemma Abs_Nonneg_14877(m: real)\n ensures (if m >= 0 then m else -m) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_14878","instance":14878,"id":184877,"goal":"lemma DivMod_14878(x: int, y: int)\n requires y > 0\n ensures x == y * (x / y) + (x % y)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_14879","instance":14879,"id":184878,"goal":"lemma ModBounds_14879(x: nat, j: nat)\n requires j > 0\n ensures 0 <= x % j < j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_14880","instance":14880,"id":184879,"goal":"lemma Square_Nonneg_14880(z: real)\n ensures z * z >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_14881","instance":14881,"id":184880,"goal":"lemma AddComm_14881(j: int, i: int)\n ensures j + i == i + j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_14882","instance":14882,"id":184881,"goal":"lemma AddAssoc_14882(m: nat, c: nat, a: nat)\n ensures (m + c) + a == m + (c + a)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_14883","instance":14883,"id":184882,"goal":"lemma MulComm_14883(n: real, m: real)\n ensures n * m == m * n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_14884","instance":14884,"id":184883,"goal":"lemma MulAssoc_14884(m: int, a: int, y: int)\n ensures (m * a) * y == m * (a * y)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_14885","instance":14885,"id":184884,"goal":"lemma Distrib_14885(a: nat, n: nat, j: nat)\n ensures a * (n + j) == a * n + a * j\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_14886","instance":14886,"id":184885,"goal":"lemma AddZero_14886(m: real)\n ensures m + 0 == m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_14887","instance":14887,"id":184886,"goal":"lemma MulOne_14887(y: int)\n ensures y * 1 == y\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_14888","instance":14888,"id":184887,"goal":"lemma MulZero_14888(c: nat)\n ensures c * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_14889","instance":14889,"id":184888,"goal":"lemma LeRefl_14889(k: real)\n ensures k <= k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_14890","instance":14890,"id":184889,"goal":"lemma LeTrans_14890(x: int, a: int, j: int)\n requires x <= a && a <= j\n ensures x <= j\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_14891","instance":14891,"id":184890,"goal":"lemma AddMono_14891(z: nat, x: nat, j: nat)\n requires z <= x\n ensures z + j <= x + j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_14892","instance":14892,"id":184891,"goal":"lemma Abs_Nonneg_14892(c: real)\n ensures (if c >= 0 then c else -c) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_14893","instance":14893,"id":184892,"goal":"lemma DivMod_14893(a: int, i: int)\n requires i > 0\n ensures a == i * (a / i) + (a % i)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_14894","instance":14894,"id":184893,"goal":"lemma ModBounds_14894(c: nat, j: nat)\n requires j > 0\n ensures 0 <= c % j < j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_14895","instance":14895,"id":184894,"goal":"lemma Square_Nonneg_14895(m: real)\n ensures m * m >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_14896","instance":14896,"id":184895,"goal":"lemma AddComm_14896(k: int, c: int)\n ensures k + c == c + k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_14897","instance":14897,"id":184896,"goal":"lemma AddAssoc_14897(y: nat, i: nat, c: nat)\n ensures (y + i) + c == y + (i + c)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_14898","instance":14898,"id":184897,"goal":"lemma MulComm_14898(z: real, d: real)\n ensures z * d == d * z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_14899","instance":14899,"id":184898,"goal":"lemma MulAssoc_14899(j: int, d: int, n: int)\n ensures (j * d) * n == j * (d * n)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_14900","instance":14900,"id":184899,"goal":"lemma Distrib_14900(x: nat, n: nat, m: nat)\n ensures x * (n + m) == x * n + x * m\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_14901","instance":14901,"id":184900,"goal":"lemma AddZero_14901(a: real)\n ensures a + 0 == a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_14902","instance":14902,"id":184901,"goal":"lemma MulOne_14902(x: int)\n ensures x * 1 == x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_14903","instance":14903,"id":184902,"goal":"lemma MulZero_14903(m: nat)\n ensures m * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_14904","instance":14904,"id":184903,"goal":"lemma LeRefl_14904(i: real)\n ensures i <= i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_14905","instance":14905,"id":184904,"goal":"lemma LeTrans_14905(j: int, z: int, x: int)\n requires j <= z && z <= x\n ensures j <= x\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_14906","instance":14906,"id":184905,"goal":"lemma AddMono_14906(a: nat, d: nat, j: nat)\n requires a <= d\n ensures a + j <= d + j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_14907","instance":14907,"id":184906,"goal":"lemma Abs_Nonneg_14907(x: real)\n ensures (if x >= 0 then x else -x) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_14908","instance":14908,"id":184907,"goal":"lemma DivMod_14908(d: int, a: int)\n requires a > 0\n ensures d == a * (d / a) + (d % a)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_14909","instance":14909,"id":184908,"goal":"lemma ModBounds_14909(x: nat, b: nat)\n requires b > 0\n ensures 0 <= x % b < b\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_14910","instance":14910,"id":184909,"goal":"lemma Square_Nonneg_14910(n: real)\n ensures n * n >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_14911","instance":14911,"id":184910,"goal":"lemma AddComm_14911(x: int, b: int)\n ensures x + b == b + x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_14912","instance":14912,"id":184911,"goal":"lemma AddAssoc_14912(b: nat, d: nat, i: nat)\n ensures (b + d) + i == b + (d + i)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_14913","instance":14913,"id":184912,"goal":"lemma MulComm_14913(z: real, n: real)\n ensures z * n == n * z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_14914","instance":14914,"id":184913,"goal":"lemma MulAssoc_14914(m: int, y: int, b: int)\n ensures (m * y) * b == m * (y * b)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_14915","instance":14915,"id":184914,"goal":"lemma Distrib_14915(m: nat, x: nat, n: nat)\n ensures m * (x + n) == m * x + m * n\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_14916","instance":14916,"id":184915,"goal":"lemma AddZero_14916(b: real)\n ensures b + 0 == b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_14917","instance":14917,"id":184916,"goal":"lemma MulOne_14917(k: int)\n ensures k * 1 == k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_14918","instance":14918,"id":184917,"goal":"lemma MulZero_14918(i: nat)\n ensures i * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_14919","instance":14919,"id":184918,"goal":"lemma LeRefl_14919(j: real)\n ensures j <= j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_14920","instance":14920,"id":184919,"goal":"lemma LeTrans_14920(a: int, b: int, k: int)\n requires a <= b && b <= k\n ensures a <= k\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_14921","instance":14921,"id":184920,"goal":"lemma AddMono_14921(x: nat, n: nat, c: nat)\n requires x <= n\n ensures x + c <= n + c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_14922","instance":14922,"id":184921,"goal":"lemma Abs_Nonneg_14922(b: real)\n ensures (if b >= 0 then b else -b) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_14923","instance":14923,"id":184922,"goal":"lemma DivMod_14923(x: int, k: int)\n requires k > 0\n ensures x == k * (x / k) + (x % k)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_14924","instance":14924,"id":184923,"goal":"lemma ModBounds_14924(y: nat, c: nat)\n requires c > 0\n ensures 0 <= y % c < c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_14925","instance":14925,"id":184924,"goal":"lemma Square_Nonneg_14925(z: real)\n ensures z * z >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_14926","instance":14926,"id":184925,"goal":"lemma AddComm_14926(z: int, b: int)\n ensures z + b == b + z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_14927","instance":14927,"id":184926,"goal":"lemma AddAssoc_14927(i: nat, n: nat, x: nat)\n ensures (i + n) + x == i + (n + x)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_14928","instance":14928,"id":184927,"goal":"lemma MulComm_14928(i: real, n: real)\n ensures i * n == n * i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_14929","instance":14929,"id":184928,"goal":"lemma MulAssoc_14929(k: int, x: int, y: int)\n ensures (k * x) * y == k * (x * y)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_14930","instance":14930,"id":184929,"goal":"lemma Distrib_14930(n: nat, m: nat, x: nat)\n ensures n * (m + x) == n * m + n * x\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_14931","instance":14931,"id":184930,"goal":"lemma AddZero_14931(z: real)\n ensures z + 0 == z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_14932","instance":14932,"id":184931,"goal":"lemma MulOne_14932(m: int)\n ensures m * 1 == m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_14933","instance":14933,"id":184932,"goal":"lemma MulZero_14933(d: nat)\n ensures d * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_14934","instance":14934,"id":184933,"goal":"lemma LeRefl_14934(j: real)\n ensures j <= j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_14935","instance":14935,"id":184934,"goal":"lemma LeTrans_14935(y: int, x: int, c: int)\n requires y <= x && x <= c\n ensures y <= c\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_14936","instance":14936,"id":184935,"goal":"lemma AddMono_14936(z: nat, i: nat, n: nat)\n requires z <= i\n ensures z + n <= i + n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_14937","instance":14937,"id":184936,"goal":"lemma Abs_Nonneg_14937(z: real)\n ensures (if z >= 0 then z else -z) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_14938","instance":14938,"id":184937,"goal":"lemma DivMod_14938(j: int, n: int)\n requires n > 0\n ensures j == n * (j / n) + (j % n)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_14939","instance":14939,"id":184938,"goal":"lemma ModBounds_14939(m: nat, x: nat)\n requires x > 0\n ensures 0 <= m % x < x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_14940","instance":14940,"id":184939,"goal":"lemma Square_Nonneg_14940(m: real)\n ensures m * m >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_14941","instance":14941,"id":184940,"goal":"lemma AddComm_14941(a: int, j: int)\n ensures a + j == j + a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_14942","instance":14942,"id":184941,"goal":"lemma AddAssoc_14942(m: nat, y: nat, z: nat)\n ensures (m + y) + z == m + (y + z)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_14943","instance":14943,"id":184942,"goal":"lemma MulComm_14943(m: real, a: real)\n ensures m * a == a * m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_14944","instance":14944,"id":184943,"goal":"lemma MulAssoc_14944(c: int, z: int, m: int)\n ensures (c * z) * m == c * (z * m)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_14945","instance":14945,"id":184944,"goal":"lemma Distrib_14945(a: nat, y: nat, b: nat)\n ensures a * (y + b) == a * y + a * b\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_14946","instance":14946,"id":184945,"goal":"lemma AddZero_14946(j: real)\n ensures j + 0 == j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_14947","instance":14947,"id":184946,"goal":"lemma MulOne_14947(a: int)\n ensures a * 1 == a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_14948","instance":14948,"id":184947,"goal":"lemma MulZero_14948(d: nat)\n ensures d * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_14949","instance":14949,"id":184948,"goal":"lemma LeRefl_14949(j: real)\n ensures j <= j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_14950","instance":14950,"id":184949,"goal":"lemma LeTrans_14950(k: int, y: int, d: int)\n requires k <= y && y <= d\n ensures k <= d\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_14951","instance":14951,"id":184950,"goal":"lemma AddMono_14951(i: nat, n: nat, m: nat)\n requires i <= n\n ensures i + m <= n + m\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_14952","instance":14952,"id":184951,"goal":"lemma Abs_Nonneg_14952(d: real)\n ensures (if d >= 0 then d else -d) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_14953","instance":14953,"id":184952,"goal":"lemma DivMod_14953(c: int, a: int)\n requires a > 0\n ensures c == a * (c / a) + (c % a)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_14954","instance":14954,"id":184953,"goal":"lemma ModBounds_14954(k: nat, x: nat)\n requires x > 0\n ensures 0 <= k % x < x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_14955","instance":14955,"id":184954,"goal":"lemma Square_Nonneg_14955(k: real)\n ensures k * k >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_14956","instance":14956,"id":184955,"goal":"lemma AddComm_14956(i: int, k: int)\n ensures i + k == k + i\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_14957","instance":14957,"id":184956,"goal":"lemma AddAssoc_14957(y: nat, b: nat, j: nat)\n ensures (y + b) + j == y + (b + j)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_14958","instance":14958,"id":184957,"goal":"lemma MulComm_14958(z: real, b: real)\n ensures z * b == b * z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_14959","instance":14959,"id":184958,"goal":"lemma MulAssoc_14959(m: int, j: int, c: int)\n ensures (m * j) * c == m * (j * c)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_14960","instance":14960,"id":184959,"goal":"lemma Distrib_14960(k: nat, y: nat, z: nat)\n ensures k * (y + z) == k * y + k * z\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_14961","instance":14961,"id":184960,"goal":"lemma AddZero_14961(m: real)\n ensures m + 0 == m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_14962","instance":14962,"id":184961,"goal":"lemma MulOne_14962(z: int)\n ensures z * 1 == z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_14963","instance":14963,"id":184962,"goal":"lemma MulZero_14963(m: nat)\n ensures m * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_14964","instance":14964,"id":184963,"goal":"lemma LeRefl_14964(k: real)\n ensures k <= k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_14965","instance":14965,"id":184964,"goal":"lemma LeTrans_14965(b: int, y: int, m: int)\n requires b <= y && y <= m\n ensures b <= m\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_14966","instance":14966,"id":184965,"goal":"lemma AddMono_14966(k: nat, a: nat, z: nat)\n requires k <= a\n ensures k + z <= a + z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_14967","instance":14967,"id":184966,"goal":"lemma Abs_Nonneg_14967(c: real)\n ensures (if c >= 0 then c else -c) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_14968","instance":14968,"id":184967,"goal":"lemma DivMod_14968(j: int, n: int)\n requires n > 0\n ensures j == n * (j / n) + (j % n)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_14969","instance":14969,"id":184968,"goal":"lemma ModBounds_14969(a: nat, j: nat)\n requires j > 0\n ensures 0 <= a % j < j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_14970","instance":14970,"id":184969,"goal":"lemma Square_Nonneg_14970(a: real)\n ensures a * a >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_14971","instance":14971,"id":184970,"goal":"lemma AddComm_14971(k: int, a: int)\n ensures k + a == a + k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_14972","instance":14972,"id":184971,"goal":"lemma AddAssoc_14972(b: nat, a: nat, m: nat)\n ensures (b + a) + m == b + (a + m)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_14973","instance":14973,"id":184972,"goal":"lemma MulComm_14973(n: real, b: real)\n ensures n * b == b * n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_14974","instance":14974,"id":184973,"goal":"lemma MulAssoc_14974(i: int, n: int, d: int)\n ensures (i * n) * d == i * (n * d)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_14975","instance":14975,"id":184974,"goal":"lemma Distrib_14975(a: nat, i: nat, m: nat)\n ensures a * (i + m) == a * i + a * m\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_14976","instance":14976,"id":184975,"goal":"lemma AddZero_14976(b: real)\n ensures b + 0 == b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_14977","instance":14977,"id":184976,"goal":"lemma MulOne_14977(i: int)\n ensures i * 1 == i\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_14978","instance":14978,"id":184977,"goal":"lemma MulZero_14978(i: nat)\n ensures i * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_14979","instance":14979,"id":184978,"goal":"lemma LeRefl_14979(x: real)\n ensures x <= x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_14980","instance":14980,"id":184979,"goal":"lemma LeTrans_14980(m: int, b: int, c: int)\n requires m <= b && b <= c\n ensures m <= c\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_14981","instance":14981,"id":184980,"goal":"lemma AddMono_14981(b: nat, d: nat, z: nat)\n requires b <= d\n ensures b + z <= d + z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_14982","instance":14982,"id":184981,"goal":"lemma Abs_Nonneg_14982(b: real)\n ensures (if b >= 0 then b else -b) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_14983","instance":14983,"id":184982,"goal":"lemma DivMod_14983(a: int, m: int)\n requires m > 0\n ensures a == m * (a / m) + (a % m)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_14984","instance":14984,"id":184983,"goal":"lemma ModBounds_14984(k: nat, j: nat)\n requires j > 0\n ensures 0 <= k % j < j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_14985","instance":14985,"id":184984,"goal":"lemma Square_Nonneg_14985(z: real)\n ensures z * z >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_14986","instance":14986,"id":184985,"goal":"lemma AddComm_14986(b: int, n: int)\n ensures b + n == n + b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_14987","instance":14987,"id":184986,"goal":"lemma AddAssoc_14987(m: nat, x: nat, y: nat)\n ensures (m + x) + y == m + (x + y)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_14988","instance":14988,"id":184987,"goal":"lemma MulComm_14988(j: real, a: real)\n ensures j * a == a * j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_14989","instance":14989,"id":184988,"goal":"lemma MulAssoc_14989(n: int, k: int, i: int)\n ensures (n * k) * i == n * (k * i)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_14990","instance":14990,"id":184989,"goal":"lemma Distrib_14990(b: nat, c: nat, k: nat)\n ensures b * (c + k) == b * c + b * k\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_14991","instance":14991,"id":184990,"goal":"lemma AddZero_14991(m: real)\n ensures m + 0 == m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_14992","instance":14992,"id":184991,"goal":"lemma MulOne_14992(i: int)\n ensures i * 1 == i\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_14993","instance":14993,"id":184992,"goal":"lemma MulZero_14993(k: nat)\n ensures k * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_14994","instance":14994,"id":184993,"goal":"lemma LeRefl_14994(m: real)\n ensures m <= m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_14995","instance":14995,"id":184994,"goal":"lemma LeTrans_14995(c: int, m: int, z: int)\n requires c <= m && m <= z\n ensures c <= z\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_14996","instance":14996,"id":184995,"goal":"lemma AddMono_14996(d: nat, n: nat, j: nat)\n requires d <= n\n ensures d + j <= n + j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_14997","instance":14997,"id":184996,"goal":"lemma Abs_Nonneg_14997(b: real)\n ensures (if b >= 0 then b else -b) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_14998","instance":14998,"id":184997,"goal":"lemma DivMod_14998(k: int, c: int)\n requires c > 0\n ensures k == c * (k / c) + (k % c)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_14999","instance":14999,"id":184998,"goal":"lemma ModBounds_14999(n: nat, d: nat)\n requires d > 0\n ensures 0 <= n % d < d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_15000","instance":15000,"id":184999,"goal":"lemma Square_Nonneg_15000(b: real)\n ensures b * b >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_15001","instance":15001,"id":185000,"goal":"lemma AddComm_15001(b: int, a: int)\n ensures b + a == a + b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_15002","instance":15002,"id":185001,"goal":"lemma AddAssoc_15002(m: nat, x: nat, y: nat)\n ensures (m + x) + y == m + (x + y)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_15003","instance":15003,"id":185002,"goal":"lemma MulComm_15003(i: real, c: real)\n ensures i * c == c * i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_15004","instance":15004,"id":185003,"goal":"lemma MulAssoc_15004(z: int, d: int, k: int)\n ensures (z * d) * k == z * (d * k)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_15005","instance":15005,"id":185004,"goal":"lemma Distrib_15005(k: nat, m: nat, c: nat)\n ensures k * (m + c) == k * m + k * c\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_15006","instance":15006,"id":185005,"goal":"lemma AddZero_15006(z: real)\n ensures z + 0 == z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_15007","instance":15007,"id":185006,"goal":"lemma MulOne_15007(b: int)\n ensures b * 1 == b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_15008","instance":15008,"id":185007,"goal":"lemma MulZero_15008(k: nat)\n ensures k * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_15009","instance":15009,"id":185008,"goal":"lemma LeRefl_15009(x: real)\n ensures x <= x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_15010","instance":15010,"id":185009,"goal":"lemma LeTrans_15010(i: int, m: int, j: int)\n requires i <= m && m <= j\n ensures i <= j\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_15011","instance":15011,"id":185010,"goal":"lemma AddMono_15011(b: nat, n: nat, y: nat)\n requires b <= n\n ensures b + y <= n + y\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_15012","instance":15012,"id":185011,"goal":"lemma Abs_Nonneg_15012(k: real)\n ensures (if k >= 0 then k else -k) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_15013","instance":15013,"id":185012,"goal":"lemma DivMod_15013(y: int, c: int)\n requires c > 0\n ensures y == c * (y / c) + (y % c)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_15014","instance":15014,"id":185013,"goal":"lemma ModBounds_15014(a: nat, c: nat)\n requires c > 0\n ensures 0 <= a % c < c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_15015","instance":15015,"id":185014,"goal":"lemma Square_Nonneg_15015(b: real)\n ensures b * b >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_15016","instance":15016,"id":185015,"goal":"lemma AddComm_15016(y: int, b: int)\n ensures y + b == b + y\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_15017","instance":15017,"id":185016,"goal":"lemma AddAssoc_15017(j: nat, n: nat, i: nat)\n ensures (j + n) + i == j + (n + i)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_15018","instance":15018,"id":185017,"goal":"lemma MulComm_15018(a: real, d: real)\n ensures a * d == d * a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_15019","instance":15019,"id":185018,"goal":"lemma MulAssoc_15019(c: int, k: int, x: int)\n ensures (c * k) * x == c * (k * x)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_15020","instance":15020,"id":185019,"goal":"lemma Distrib_15020(j: nat, n: nat, c: nat)\n ensures j * (n + c) == j * n + j * c\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_15021","instance":15021,"id":185020,"goal":"lemma AddZero_15021(k: real)\n ensures k + 0 == k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_15022","instance":15022,"id":185021,"goal":"lemma MulOne_15022(k: int)\n ensures k * 1 == k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_15023","instance":15023,"id":185022,"goal":"lemma MulZero_15023(b: nat)\n ensures b * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_15024","instance":15024,"id":185023,"goal":"lemma LeRefl_15024(m: real)\n ensures m <= m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_15025","instance":15025,"id":185024,"goal":"lemma LeTrans_15025(n: int, z: int, k: int)\n requires n <= z && z <= k\n ensures n <= k\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_15026","instance":15026,"id":185025,"goal":"lemma AddMono_15026(x: nat, m: nat, z: nat)\n requires x <= m\n ensures x + z <= m + z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_15027","instance":15027,"id":185026,"goal":"lemma Abs_Nonneg_15027(c: real)\n ensures (if c >= 0 then c else -c) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_15028","instance":15028,"id":185027,"goal":"lemma DivMod_15028(j: int, n: int)\n requires n > 0\n ensures j == n * (j / n) + (j % n)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_15029","instance":15029,"id":185028,"goal":"lemma ModBounds_15029(c: nat, k: nat)\n requires k > 0\n ensures 0 <= c % k < k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_15030","instance":15030,"id":185029,"goal":"lemma Square_Nonneg_15030(c: real)\n ensures c * c >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_15031","instance":15031,"id":185030,"goal":"lemma AddComm_15031(i: int, d: int)\n ensures i + d == d + i\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_15032","instance":15032,"id":185031,"goal":"lemma AddAssoc_15032(m: nat, y: nat, b: nat)\n ensures (m + y) + b == m + (y + b)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_15033","instance":15033,"id":185032,"goal":"lemma MulComm_15033(z: real, x: real)\n ensures z * x == x * z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_15034","instance":15034,"id":185033,"goal":"lemma MulAssoc_15034(z: int, n: int, c: int)\n ensures (z * n) * c == z * (n * c)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_15035","instance":15035,"id":185034,"goal":"lemma Distrib_15035(a: nat, b: nat, n: nat)\n ensures a * (b + n) == a * b + a * n\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_15036","instance":15036,"id":185035,"goal":"lemma AddZero_15036(j: real)\n ensures j + 0 == j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_15037","instance":15037,"id":185036,"goal":"lemma MulOne_15037(a: int)\n ensures a * 1 == a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_15038","instance":15038,"id":185037,"goal":"lemma MulZero_15038(d: nat)\n ensures d * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_15039","instance":15039,"id":185038,"goal":"lemma LeRefl_15039(m: real)\n ensures m <= m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_15040","instance":15040,"id":185039,"goal":"lemma LeTrans_15040(z: int, y: int, b: int)\n requires z <= y && y <= b\n ensures z <= b\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_15041","instance":15041,"id":185040,"goal":"lemma AddMono_15041(b: nat, c: nat, z: nat)\n requires b <= c\n ensures b + z <= c + z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_15042","instance":15042,"id":185041,"goal":"lemma Abs_Nonneg_15042(n: real)\n ensures (if n >= 0 then n else -n) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_15043","instance":15043,"id":185042,"goal":"lemma DivMod_15043(z: int, b: int)\n requires b > 0\n ensures z == b * (z / b) + (z % b)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_15044","instance":15044,"id":185043,"goal":"lemma ModBounds_15044(x: nat, j: nat)\n requires j > 0\n ensures 0 <= x % j < j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_15045","instance":15045,"id":185044,"goal":"lemma Square_Nonneg_15045(n: real)\n ensures n * n >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_15046","instance":15046,"id":185045,"goal":"lemma AddComm_15046(j: int, k: int)\n ensures j + k == k + j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_15047","instance":15047,"id":185046,"goal":"lemma AddAssoc_15047(z: nat, k: nat, c: nat)\n ensures (z + k) + c == z + (k + c)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_15048","instance":15048,"id":185047,"goal":"lemma MulComm_15048(n: real, c: real)\n ensures n * c == c * n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_15049","instance":15049,"id":185048,"goal":"lemma MulAssoc_15049(n: int, i: int, b: int)\n ensures (n * i) * b == n * (i * b)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_15050","instance":15050,"id":185049,"goal":"lemma Distrib_15050(b: nat, a: nat, i: nat)\n ensures b * (a + i) == b * a + b * i\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_15051","instance":15051,"id":185050,"goal":"lemma AddZero_15051(k: real)\n ensures k + 0 == k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_15052","instance":15052,"id":185051,"goal":"lemma MulOne_15052(i: int)\n ensures i * 1 == i\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_15053","instance":15053,"id":185052,"goal":"lemma MulZero_15053(n: nat)\n ensures n * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_15054","instance":15054,"id":185053,"goal":"lemma LeRefl_15054(i: real)\n ensures i <= i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_15055","instance":15055,"id":185054,"goal":"lemma LeTrans_15055(c: int, x: int, a: int)\n requires c <= x && x <= a\n ensures c <= a\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_15056","instance":15056,"id":185055,"goal":"lemma AddMono_15056(c: nat, k: nat, z: nat)\n requires c <= k\n ensures c + z <= k + z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_15057","instance":15057,"id":185056,"goal":"lemma Abs_Nonneg_15057(x: real)\n ensures (if x >= 0 then x else -x) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_15058","instance":15058,"id":185057,"goal":"lemma DivMod_15058(d: int, j: int)\n requires j > 0\n ensures d == j * (d / j) + (d % j)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_15059","instance":15059,"id":185058,"goal":"lemma ModBounds_15059(i: nat, j: nat)\n requires j > 0\n ensures 0 <= i % j < j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_15060","instance":15060,"id":185059,"goal":"lemma Square_Nonneg_15060(j: real)\n ensures j * j >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_15061","instance":15061,"id":185060,"goal":"lemma AddComm_15061(b: int, c: int)\n ensures b + c == c + b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_15062","instance":15062,"id":185061,"goal":"lemma AddAssoc_15062(i: nat, c: nat, n: nat)\n ensures (i + c) + n == i + (c + n)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_15063","instance":15063,"id":185062,"goal":"lemma MulComm_15063(j: real, a: real)\n ensures j * a == a * j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_15064","instance":15064,"id":185063,"goal":"lemma MulAssoc_15064(k: int, d: int, b: int)\n ensures (k * d) * b == k * (d * b)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_15065","instance":15065,"id":185064,"goal":"lemma Distrib_15065(i: nat, c: nat, d: nat)\n ensures i * (c + d) == i * c + i * d\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_15066","instance":15066,"id":185065,"goal":"lemma AddZero_15066(y: real)\n ensures y + 0 == y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_15067","instance":15067,"id":185066,"goal":"lemma MulOne_15067(m: int)\n ensures m * 1 == m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_15068","instance":15068,"id":185067,"goal":"lemma MulZero_15068(n: nat)\n ensures n * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_15069","instance":15069,"id":185068,"goal":"lemma LeRefl_15069(c: real)\n ensures c <= c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_15070","instance":15070,"id":185069,"goal":"lemma LeTrans_15070(c: int, k: int, i: int)\n requires c <= k && k <= i\n ensures c <= i\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_15071","instance":15071,"id":185070,"goal":"lemma AddMono_15071(b: nat, k: nat, d: nat)\n requires b <= k\n ensures b + d <= k + d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_15072","instance":15072,"id":185071,"goal":"lemma Abs_Nonneg_15072(j: real)\n ensures (if j >= 0 then j else -j) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_15073","instance":15073,"id":185072,"goal":"lemma DivMod_15073(x: int, m: int)\n requires m > 0\n ensures x == m * (x / m) + (x % m)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_15074","instance":15074,"id":185073,"goal":"lemma ModBounds_15074(j: nat, a: nat)\n requires a > 0\n ensures 0 <= j % a < a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_15075","instance":15075,"id":185074,"goal":"lemma Square_Nonneg_15075(b: real)\n ensures b * b >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_15076","instance":15076,"id":185075,"goal":"lemma AddComm_15076(n: int, y: int)\n ensures n + y == y + n\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_15077","instance":15077,"id":185076,"goal":"lemma AddAssoc_15077(m: nat, c: nat, z: nat)\n ensures (m + c) + z == m + (c + z)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_15078","instance":15078,"id":185077,"goal":"lemma MulComm_15078(a: real, m: real)\n ensures a * m == m * a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_15079","instance":15079,"id":185078,"goal":"lemma MulAssoc_15079(n: int, j: int, d: int)\n ensures (n * j) * d == n * (j * d)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_15080","instance":15080,"id":185079,"goal":"lemma Distrib_15080(x: nat, k: nat, y: nat)\n ensures x * (k + y) == x * k + x * y\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_15081","instance":15081,"id":185080,"goal":"lemma AddZero_15081(n: real)\n ensures n + 0 == n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_15082","instance":15082,"id":185081,"goal":"lemma MulOne_15082(m: int)\n ensures m * 1 == m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_15083","instance":15083,"id":185082,"goal":"lemma MulZero_15083(n: nat)\n ensures n * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_15084","instance":15084,"id":185083,"goal":"lemma LeRefl_15084(k: real)\n ensures k <= k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_15085","instance":15085,"id":185084,"goal":"lemma LeTrans_15085(i: int, k: int, b: int)\n requires i <= k && k <= b\n ensures i <= b\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_15086","instance":15086,"id":185085,"goal":"lemma AddMono_15086(n: nat, k: nat, x: nat)\n requires n <= k\n ensures n + x <= k + x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_15087","instance":15087,"id":185086,"goal":"lemma Abs_Nonneg_15087(a: real)\n ensures (if a >= 0 then a else -a) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_15088","instance":15088,"id":185087,"goal":"lemma DivMod_15088(y: int, z: int)\n requires z > 0\n ensures y == z * (y / z) + (y % z)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_15089","instance":15089,"id":185088,"goal":"lemma ModBounds_15089(i: nat, y: nat)\n requires y > 0\n ensures 0 <= i % y < y\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_15090","instance":15090,"id":185089,"goal":"lemma Square_Nonneg_15090(i: real)\n ensures i * i >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_15091","instance":15091,"id":185090,"goal":"lemma AddComm_15091(d: int, k: int)\n ensures d + k == k + d\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_15092","instance":15092,"id":185091,"goal":"lemma AddAssoc_15092(b: nat, z: nat, j: nat)\n ensures (b + z) + j == b + (z + j)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_15093","instance":15093,"id":185092,"goal":"lemma MulComm_15093(z: real, m: real)\n ensures z * m == m * z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_15094","instance":15094,"id":185093,"goal":"lemma MulAssoc_15094(y: int, n: int, c: int)\n ensures (y * n) * c == y * (n * c)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_15095","instance":15095,"id":185094,"goal":"lemma Distrib_15095(y: nat, i: nat, n: nat)\n ensures y * (i + n) == y * i + y * n\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_15096","instance":15096,"id":185095,"goal":"lemma AddZero_15096(j: real)\n ensures j + 0 == j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_15097","instance":15097,"id":185096,"goal":"lemma MulOne_15097(n: int)\n ensures n * 1 == n\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_15098","instance":15098,"id":185097,"goal":"lemma MulZero_15098(y: nat)\n ensures y * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_15099","instance":15099,"id":185098,"goal":"lemma LeRefl_15099(y: real)\n ensures y <= y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_15100","instance":15100,"id":185099,"goal":"lemma LeTrans_15100(y: int, k: int, b: int)\n requires y <= k && k <= b\n ensures y <= b\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_15101","instance":15101,"id":185100,"goal":"lemma AddMono_15101(d: nat, b: nat, n: nat)\n requires d <= b\n ensures d + n <= b + n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_15102","instance":15102,"id":185101,"goal":"lemma Abs_Nonneg_15102(x: real)\n ensures (if x >= 0 then x else -x) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_15103","instance":15103,"id":185102,"goal":"lemma DivMod_15103(n: int, m: int)\n requires m > 0\n ensures n == m * (n / m) + (n % m)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_15104","instance":15104,"id":185103,"goal":"lemma ModBounds_15104(n: nat, z: nat)\n requires z > 0\n ensures 0 <= n % z < z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_15105","instance":15105,"id":185104,"goal":"lemma Square_Nonneg_15105(i: real)\n ensures i * i >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_15106","instance":15106,"id":185105,"goal":"lemma AddComm_15106(m: int, i: int)\n ensures m + i == i + m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_15107","instance":15107,"id":185106,"goal":"lemma AddAssoc_15107(j: nat, i: nat, c: nat)\n ensures (j + i) + c == j + (i + c)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_15108","instance":15108,"id":185107,"goal":"lemma MulComm_15108(c: real, n: real)\n ensures c * n == n * c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_15109","instance":15109,"id":185108,"goal":"lemma MulAssoc_15109(k: int, m: int, j: int)\n ensures (k * m) * j == k * (m * j)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_15110","instance":15110,"id":185109,"goal":"lemma Distrib_15110(i: nat, c: nat, n: nat)\n ensures i * (c + n) == i * c + i * n\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_15111","instance":15111,"id":185110,"goal":"lemma AddZero_15111(k: real)\n ensures k + 0 == k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_15112","instance":15112,"id":185111,"goal":"lemma MulOne_15112(y: int)\n ensures y * 1 == y\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_15113","instance":15113,"id":185112,"goal":"lemma MulZero_15113(a: nat)\n ensures a * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_15114","instance":15114,"id":185113,"goal":"lemma LeRefl_15114(n: real)\n ensures n <= n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_15115","instance":15115,"id":185114,"goal":"lemma LeTrans_15115(c: int, m: int, k: int)\n requires c <= m && m <= k\n ensures c <= k\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_15116","instance":15116,"id":185115,"goal":"lemma AddMono_15116(x: nat, c: nat, n: nat)\n requires x <= c\n ensures x + n <= c + n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_15117","instance":15117,"id":185116,"goal":"lemma Abs_Nonneg_15117(c: real)\n ensures (if c >= 0 then c else -c) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_15118","instance":15118,"id":185117,"goal":"lemma DivMod_15118(i: int, y: int)\n requires y > 0\n ensures i == y * (i / y) + (i % y)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_15119","instance":15119,"id":185118,"goal":"lemma ModBounds_15119(z: nat, n: nat)\n requires n > 0\n ensures 0 <= z % n < n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_15120","instance":15120,"id":185119,"goal":"lemma Square_Nonneg_15120(b: real)\n ensures b * b >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_15121","instance":15121,"id":185120,"goal":"lemma AddComm_15121(j: int, i: int)\n ensures j + i == i + j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_15122","instance":15122,"id":185121,"goal":"lemma AddAssoc_15122(m: nat, j: nat, b: nat)\n ensures (m + j) + b == m + (j + b)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_15123","instance":15123,"id":185122,"goal":"lemma MulComm_15123(d: real, b: real)\n ensures d * b == b * d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_15124","instance":15124,"id":185123,"goal":"lemma MulAssoc_15124(z: int, y: int, d: int)\n ensures (z * y) * d == z * (y * d)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_15125","instance":15125,"id":185124,"goal":"lemma Distrib_15125(j: nat, z: nat, a: nat)\n ensures j * (z + a) == j * z + j * a\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_15126","instance":15126,"id":185125,"goal":"lemma AddZero_15126(c: real)\n ensures c + 0 == c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_15127","instance":15127,"id":185126,"goal":"lemma MulOne_15127(z: int)\n ensures z * 1 == z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_15128","instance":15128,"id":185127,"goal":"lemma MulZero_15128(z: nat)\n ensures z * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_15129","instance":15129,"id":185128,"goal":"lemma LeRefl_15129(k: real)\n ensures k <= k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_15130","instance":15130,"id":185129,"goal":"lemma LeTrans_15130(m: int, a: int, k: int)\n requires m <= a && a <= k\n ensures m <= k\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_15131","instance":15131,"id":185130,"goal":"lemma AddMono_15131(d: nat, b: nat, x: nat)\n requires d <= b\n ensures d + x <= b + x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_15132","instance":15132,"id":185131,"goal":"lemma Abs_Nonneg_15132(a: real)\n ensures (if a >= 0 then a else -a) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_15133","instance":15133,"id":185132,"goal":"lemma DivMod_15133(n: int, b: int)\n requires b > 0\n ensures n == b * (n / b) + (n % b)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_15134","instance":15134,"id":185133,"goal":"lemma ModBounds_15134(c: nat, k: nat)\n requires k > 0\n ensures 0 <= c % k < k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_15135","instance":15135,"id":185134,"goal":"lemma Square_Nonneg_15135(m: real)\n ensures m * m >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_15136","instance":15136,"id":185135,"goal":"lemma AddComm_15136(n: int, a: int)\n ensures n + a == a + n\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_15137","instance":15137,"id":185136,"goal":"lemma AddAssoc_15137(z: nat, b: nat, i: nat)\n ensures (z + b) + i == z + (b + i)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_15138","instance":15138,"id":185137,"goal":"lemma MulComm_15138(i: real, x: real)\n ensures i * x == x * i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_15139","instance":15139,"id":185138,"goal":"lemma MulAssoc_15139(z: int, i: int, x: int)\n ensures (z * i) * x == z * (i * x)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_15140","instance":15140,"id":185139,"goal":"lemma Distrib_15140(x: nat, d: nat, m: nat)\n ensures x * (d + m) == x * d + x * m\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_15141","instance":15141,"id":185140,"goal":"lemma AddZero_15141(c: real)\n ensures c + 0 == c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_15142","instance":15142,"id":185141,"goal":"lemma MulOne_15142(z: int)\n ensures z * 1 == z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_15143","instance":15143,"id":185142,"goal":"lemma MulZero_15143(i: nat)\n ensures i * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_15144","instance":15144,"id":185143,"goal":"lemma LeRefl_15144(m: real)\n ensures m <= m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_15145","instance":15145,"id":185144,"goal":"lemma LeTrans_15145(n: int, j: int, i: int)\n requires n <= j && j <= i\n ensures n <= i\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_15146","instance":15146,"id":185145,"goal":"lemma AddMono_15146(z: nat, m: nat, c: nat)\n requires z <= m\n ensures z + c <= m + c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_15147","instance":15147,"id":185146,"goal":"lemma Abs_Nonneg_15147(b: real)\n ensures (if b >= 0 then b else -b) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_15148","instance":15148,"id":185147,"goal":"lemma DivMod_15148(y: int, x: int)\n requires x > 0\n ensures y == x * (y / x) + (y % x)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_15149","instance":15149,"id":185148,"goal":"lemma ModBounds_15149(d: nat, i: nat)\n requires i > 0\n ensures 0 <= d % i < i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_15150","instance":15150,"id":185149,"goal":"lemma Square_Nonneg_15150(y: real)\n ensures y * y >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_15151","instance":15151,"id":185150,"goal":"lemma AddComm_15151(j: int, a: int)\n ensures j + a == a + j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_15152","instance":15152,"id":185151,"goal":"lemma AddAssoc_15152(m: nat, j: nat, y: nat)\n ensures (m + j) + y == m + (j + y)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_15153","instance":15153,"id":185152,"goal":"lemma MulComm_15153(c: real, k: real)\n ensures c * k == k * c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_15154","instance":15154,"id":185153,"goal":"lemma MulAssoc_15154(y: int, n: int, b: int)\n ensures (y * n) * b == y * (n * b)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_15155","instance":15155,"id":185154,"goal":"lemma Distrib_15155(a: nat, n: nat, j: nat)\n ensures a * (n + j) == a * n + a * j\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_15156","instance":15156,"id":185155,"goal":"lemma AddZero_15156(d: real)\n ensures d + 0 == d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_15157","instance":15157,"id":185156,"goal":"lemma MulOne_15157(i: int)\n ensures i * 1 == i\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_15158","instance":15158,"id":185157,"goal":"lemma MulZero_15158(a: nat)\n ensures a * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_15159","instance":15159,"id":185158,"goal":"lemma LeRefl_15159(a: real)\n ensures a <= a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_15160","instance":15160,"id":185159,"goal":"lemma LeTrans_15160(k: int, c: int, j: int)\n requires k <= c && c <= j\n ensures k <= j\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_15161","instance":15161,"id":185160,"goal":"lemma AddMono_15161(n: nat, i: nat, y: nat)\n requires n <= i\n ensures n + y <= i + y\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_15162","instance":15162,"id":185161,"goal":"lemma Abs_Nonneg_15162(b: real)\n ensures (if b >= 0 then b else -b) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_15163","instance":15163,"id":185162,"goal":"lemma DivMod_15163(k: int, y: int)\n requires y > 0\n ensures k == y * (k / y) + (k % y)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_15164","instance":15164,"id":185163,"goal":"lemma ModBounds_15164(d: nat, y: nat)\n requires y > 0\n ensures 0 <= d % y < y\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_15165","instance":15165,"id":185164,"goal":"lemma Square_Nonneg_15165(a: real)\n ensures a * a >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_15166","instance":15166,"id":185165,"goal":"lemma AddComm_15166(c: int, i: int)\n ensures c + i == i + c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_15167","instance":15167,"id":185166,"goal":"lemma AddAssoc_15167(c: nat, y: nat, j: nat)\n ensures (c + y) + j == c + (y + j)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_15168","instance":15168,"id":185167,"goal":"lemma MulComm_15168(d: real, i: real)\n ensures d * i == i * d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_15169","instance":15169,"id":185168,"goal":"lemma MulAssoc_15169(m: int, x: int, y: int)\n ensures (m * x) * y == m * (x * y)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_15170","instance":15170,"id":185169,"goal":"lemma Distrib_15170(n: nat, i: nat, a: nat)\n ensures n * (i + a) == n * i + n * a\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_15171","instance":15171,"id":185170,"goal":"lemma AddZero_15171(b: real)\n ensures b + 0 == b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_15172","instance":15172,"id":185171,"goal":"lemma MulOne_15172(j: int)\n ensures j * 1 == j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_15173","instance":15173,"id":185172,"goal":"lemma MulZero_15173(j: nat)\n ensures j * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_15174","instance":15174,"id":185173,"goal":"lemma LeRefl_15174(a: real)\n ensures a <= a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_15175","instance":15175,"id":185174,"goal":"lemma LeTrans_15175(d: int, j: int, m: int)\n requires d <= j && j <= m\n ensures d <= m\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_15176","instance":15176,"id":185175,"goal":"lemma AddMono_15176(d: nat, i: nat, y: nat)\n requires d <= i\n ensures d + y <= i + y\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_15177","instance":15177,"id":185176,"goal":"lemma Abs_Nonneg_15177(a: real)\n ensures (if a >= 0 then a else -a) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_15178","instance":15178,"id":185177,"goal":"lemma DivMod_15178(d: int, x: int)\n requires x > 0\n ensures d == x * (d / x) + (d % x)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_15179","instance":15179,"id":185178,"goal":"lemma ModBounds_15179(a: nat, b: nat)\n requires b > 0\n ensures 0 <= a % b < b\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_15180","instance":15180,"id":185179,"goal":"lemma Square_Nonneg_15180(i: real)\n ensures i * i >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_15181","instance":15181,"id":185180,"goal":"lemma AddComm_15181(d: int, j: int)\n ensures d + j == j + d\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_15182","instance":15182,"id":185181,"goal":"lemma AddAssoc_15182(b: nat, d: nat, z: nat)\n ensures (b + d) + z == b + (d + z)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_15183","instance":15183,"id":185182,"goal":"lemma MulComm_15183(z: real, j: real)\n ensures z * j == j * z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_15184","instance":15184,"id":185183,"goal":"lemma MulAssoc_15184(b: int, m: int, j: int)\n ensures (b * m) * j == b * (m * j)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_15185","instance":15185,"id":185184,"goal":"lemma Distrib_15185(j: nat, m: nat, c: nat)\n ensures j * (m + c) == j * m + j * c\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_15186","instance":15186,"id":185185,"goal":"lemma AddZero_15186(n: real)\n ensures n + 0 == n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_15187","instance":15187,"id":185186,"goal":"lemma MulOne_15187(n: int)\n ensures n * 1 == n\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_15188","instance":15188,"id":185187,"goal":"lemma MulZero_15188(c: nat)\n ensures c * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_15189","instance":15189,"id":185188,"goal":"lemma LeRefl_15189(d: real)\n ensures d <= d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_15190","instance":15190,"id":185189,"goal":"lemma LeTrans_15190(j: int, b: int, k: int)\n requires j <= b && b <= k\n ensures j <= k\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_15191","instance":15191,"id":185190,"goal":"lemma AddMono_15191(m: nat, j: nat, x: nat)\n requires m <= j\n ensures m + x <= j + x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_15192","instance":15192,"id":185191,"goal":"lemma Abs_Nonneg_15192(m: real)\n ensures (if m >= 0 then m else -m) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_15193","instance":15193,"id":185192,"goal":"lemma DivMod_15193(y: int, n: int)\n requires n > 0\n ensures y == n * (y / n) + (y % n)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_15194","instance":15194,"id":185193,"goal":"lemma ModBounds_15194(n: nat, m: nat)\n requires m > 0\n ensures 0 <= n % m < m\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_15195","instance":15195,"id":185194,"goal":"lemma Square_Nonneg_15195(k: real)\n ensures k * k >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_15196","instance":15196,"id":185195,"goal":"lemma AddComm_15196(a: int, d: int)\n ensures a + d == d + a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_15197","instance":15197,"id":185196,"goal":"lemma AddAssoc_15197(d: nat, z: nat, x: nat)\n ensures (d + z) + x == d + (z + x)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_15198","instance":15198,"id":185197,"goal":"lemma MulComm_15198(d: real, z: real)\n ensures d * z == z * d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_15199","instance":15199,"id":185198,"goal":"lemma MulAssoc_15199(b: int, i: int, z: int)\n ensures (b * i) * z == b * (i * z)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_15200","instance":15200,"id":185199,"goal":"lemma Distrib_15200(j: nat, i: nat, y: nat)\n ensures j * (i + y) == j * i + j * y\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_15201","instance":15201,"id":185200,"goal":"lemma AddZero_15201(j: real)\n ensures j + 0 == j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_15202","instance":15202,"id":185201,"goal":"lemma MulOne_15202(y: int)\n ensures y * 1 == y\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_15203","instance":15203,"id":185202,"goal":"lemma MulZero_15203(x: nat)\n ensures x * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_15204","instance":15204,"id":185203,"goal":"lemma LeRefl_15204(c: real)\n ensures c <= c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_15205","instance":15205,"id":185204,"goal":"lemma LeTrans_15205(c: int, b: int, i: int)\n requires c <= b && b <= i\n ensures c <= i\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_15206","instance":15206,"id":185205,"goal":"lemma AddMono_15206(k: nat, m: nat, d: nat)\n requires k <= m\n ensures k + d <= m + d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_15207","instance":15207,"id":185206,"goal":"lemma Abs_Nonneg_15207(z: real)\n ensures (if z >= 0 then z else -z) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_15208","instance":15208,"id":185207,"goal":"lemma DivMod_15208(j: int, z: int)\n requires z > 0\n ensures j == z * (j / z) + (j % z)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_15209","instance":15209,"id":185208,"goal":"lemma ModBounds_15209(k: nat, a: nat)\n requires a > 0\n ensures 0 <= k % a < a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_15210","instance":15210,"id":185209,"goal":"lemma Square_Nonneg_15210(j: real)\n ensures j * j >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_15211","instance":15211,"id":185210,"goal":"lemma AddComm_15211(j: int, k: int)\n ensures j + k == k + j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_15212","instance":15212,"id":185211,"goal":"lemma AddAssoc_15212(x: nat, c: nat, z: nat)\n ensures (x + c) + z == x + (c + z)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_15213","instance":15213,"id":185212,"goal":"lemma MulComm_15213(m: real, a: real)\n ensures m * a == a * m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_15214","instance":15214,"id":185213,"goal":"lemma MulAssoc_15214(i: int, n: int, k: int)\n ensures (i * n) * k == i * (n * k)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_15215","instance":15215,"id":185214,"goal":"lemma Distrib_15215(k: nat, b: nat, j: nat)\n ensures k * (b + j) == k * b + k * j\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_15216","instance":15216,"id":185215,"goal":"lemma AddZero_15216(b: real)\n ensures b + 0 == b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_15217","instance":15217,"id":185216,"goal":"lemma MulOne_15217(b: int)\n ensures b * 1 == b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_15218","instance":15218,"id":185217,"goal":"lemma MulZero_15218(a: nat)\n ensures a * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_15219","instance":15219,"id":185218,"goal":"lemma LeRefl_15219(y: real)\n ensures y <= y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_15220","instance":15220,"id":185219,"goal":"lemma LeTrans_15220(d: int, b: int, i: int)\n requires d <= b && b <= i\n ensures d <= i\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_15221","instance":15221,"id":185220,"goal":"lemma AddMono_15221(y: nat, c: nat, a: nat)\n requires y <= c\n ensures y + a <= c + a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_15222","instance":15222,"id":185221,"goal":"lemma Abs_Nonneg_15222(m: real)\n ensures (if m >= 0 then m else -m) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_15223","instance":15223,"id":185222,"goal":"lemma DivMod_15223(x: int, m: int)\n requires m > 0\n ensures x == m * (x / m) + (x % m)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_15224","instance":15224,"id":185223,"goal":"lemma ModBounds_15224(a: nat, m: nat)\n requires m > 0\n ensures 0 <= a % m < m\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_15225","instance":15225,"id":185224,"goal":"lemma Square_Nonneg_15225(b: real)\n ensures b * b >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_15226","instance":15226,"id":185225,"goal":"lemma AddComm_15226(k: int, b: int)\n ensures k + b == b + k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_15227","instance":15227,"id":185226,"goal":"lemma AddAssoc_15227(b: nat, i: nat, a: nat)\n ensures (b + i) + a == b + (i + a)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_15228","instance":15228,"id":185227,"goal":"lemma MulComm_15228(b: real, i: real)\n ensures b * i == i * b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_15229","instance":15229,"id":185228,"goal":"lemma MulAssoc_15229(z: int, y: int, c: int)\n ensures (z * y) * c == z * (y * c)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_15230","instance":15230,"id":185229,"goal":"lemma Distrib_15230(b: nat, a: nat, z: nat)\n ensures b * (a + z) == b * a + b * z\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_15231","instance":15231,"id":185230,"goal":"lemma AddZero_15231(b: real)\n ensures b + 0 == b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_15232","instance":15232,"id":185231,"goal":"lemma MulOne_15232(d: int)\n ensures d * 1 == d\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_15233","instance":15233,"id":185232,"goal":"lemma MulZero_15233(j: nat)\n ensures j * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_15234","instance":15234,"id":185233,"goal":"lemma LeRefl_15234(b: real)\n ensures b <= b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_15235","instance":15235,"id":185234,"goal":"lemma LeTrans_15235(c: int, d: int, a: int)\n requires c <= d && d <= a\n ensures c <= a\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_15236","instance":15236,"id":185235,"goal":"lemma AddMono_15236(y: nat, i: nat, z: nat)\n requires y <= i\n ensures y + z <= i + z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_15237","instance":15237,"id":185236,"goal":"lemma Abs_Nonneg_15237(i: real)\n ensures (if i >= 0 then i else -i) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_15238","instance":15238,"id":185237,"goal":"lemma DivMod_15238(b: int, c: int)\n requires c > 0\n ensures b == c * (b / c) + (b % c)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_15239","instance":15239,"id":185238,"goal":"lemma ModBounds_15239(z: nat, y: nat)\n requires y > 0\n ensures 0 <= z % y < y\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_15240","instance":15240,"id":185239,"goal":"lemma Square_Nonneg_15240(n: real)\n ensures n * n >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_15241","instance":15241,"id":185240,"goal":"lemma AddComm_15241(j: int, a: int)\n ensures j + a == a + j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_15242","instance":15242,"id":185241,"goal":"lemma AddAssoc_15242(j: nat, z: nat, x: nat)\n ensures (j + z) + x == j + (z + x)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_15243","instance":15243,"id":185242,"goal":"lemma MulComm_15243(k: real, c: real)\n ensures k * c == c * k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_15244","instance":15244,"id":185243,"goal":"lemma MulAssoc_15244(d: int, z: int, m: int)\n ensures (d * z) * m == d * (z * m)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_15245","instance":15245,"id":185244,"goal":"lemma Distrib_15245(k: nat, a: nat, x: nat)\n ensures k * (a + x) == k * a + k * x\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_15246","instance":15246,"id":185245,"goal":"lemma AddZero_15246(j: real)\n ensures j + 0 == j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_15247","instance":15247,"id":185246,"goal":"lemma MulOne_15247(z: int)\n ensures z * 1 == z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_15248","instance":15248,"id":185247,"goal":"lemma MulZero_15248(m: nat)\n ensures m * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_15249","instance":15249,"id":185248,"goal":"lemma LeRefl_15249(j: real)\n ensures j <= j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_15250","instance":15250,"id":185249,"goal":"lemma LeTrans_15250(x: int, k: int, c: int)\n requires x <= k && k <= c\n ensures x <= c\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_15251","instance":15251,"id":185250,"goal":"lemma AddMono_15251(b: nat, a: nat, z: nat)\n requires b <= a\n ensures b + z <= a + z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_15252","instance":15252,"id":185251,"goal":"lemma Abs_Nonneg_15252(a: real)\n ensures (if a >= 0 then a else -a) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_15253","instance":15253,"id":185252,"goal":"lemma DivMod_15253(k: int, z: int)\n requires z > 0\n ensures k == z * (k / z) + (k % z)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_15254","instance":15254,"id":185253,"goal":"lemma ModBounds_15254(i: nat, d: nat)\n requires d > 0\n ensures 0 <= i % d < d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_15255","instance":15255,"id":185254,"goal":"lemma Square_Nonneg_15255(a: real)\n ensures a * a >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_15256","instance":15256,"id":185255,"goal":"lemma AddComm_15256(n: int, i: int)\n ensures n + i == i + n\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_15257","instance":15257,"id":185256,"goal":"lemma AddAssoc_15257(n: nat, c: nat, d: nat)\n ensures (n + c) + d == n + (c + d)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_15258","instance":15258,"id":185257,"goal":"lemma MulComm_15258(c: real, n: real)\n ensures c * n == n * c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_15259","instance":15259,"id":185258,"goal":"lemma MulAssoc_15259(a: int, m: int, z: int)\n ensures (a * m) * z == a * (m * z)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_15260","instance":15260,"id":185259,"goal":"lemma Distrib_15260(j: nat, c: nat, z: nat)\n ensures j * (c + z) == j * c + j * z\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_15261","instance":15261,"id":185260,"goal":"lemma AddZero_15261(a: real)\n ensures a + 0 == a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_15262","instance":15262,"id":185261,"goal":"lemma MulOne_15262(m: int)\n ensures m * 1 == m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_15263","instance":15263,"id":185262,"goal":"lemma MulZero_15263(m: nat)\n ensures m * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_15264","instance":15264,"id":185263,"goal":"lemma LeRefl_15264(m: real)\n ensures m <= m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_15265","instance":15265,"id":185264,"goal":"lemma LeTrans_15265(i: int, a: int, d: int)\n requires i <= a && a <= d\n ensures i <= d\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_15266","instance":15266,"id":185265,"goal":"lemma AddMono_15266(x: nat, a: nat, c: nat)\n requires x <= a\n ensures x + c <= a + c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_15267","instance":15267,"id":185266,"goal":"lemma Abs_Nonneg_15267(z: real)\n ensures (if z >= 0 then z else -z) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_15268","instance":15268,"id":185267,"goal":"lemma DivMod_15268(m: int, y: int)\n requires y > 0\n ensures m == y * (m / y) + (m % y)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_15269","instance":15269,"id":185268,"goal":"lemma ModBounds_15269(j: nat, i: nat)\n requires i > 0\n ensures 0 <= j % i < i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_15270","instance":15270,"id":185269,"goal":"lemma Square_Nonneg_15270(a: real)\n ensures a * a >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_15271","instance":15271,"id":185270,"goal":"lemma AddComm_15271(d: int, x: int)\n ensures d + x == x + d\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_15272","instance":15272,"id":185271,"goal":"lemma AddAssoc_15272(n: nat, i: nat, a: nat)\n ensures (n + i) + a == n + (i + a)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_15273","instance":15273,"id":185272,"goal":"lemma MulComm_15273(y: real, b: real)\n ensures y * b == b * y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_15274","instance":15274,"id":185273,"goal":"lemma MulAssoc_15274(k: int, i: int, m: int)\n ensures (k * i) * m == k * (i * m)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_15275","instance":15275,"id":185274,"goal":"lemma Distrib_15275(z: nat, k: nat, d: nat)\n ensures z * (k + d) == z * k + z * d\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_15276","instance":15276,"id":185275,"goal":"lemma AddZero_15276(i: real)\n ensures i + 0 == i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_15277","instance":15277,"id":185276,"goal":"lemma MulOne_15277(b: int)\n ensures b * 1 == b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_15278","instance":15278,"id":185277,"goal":"lemma MulZero_15278(d: nat)\n ensures d * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_15279","instance":15279,"id":185278,"goal":"lemma LeRefl_15279(z: real)\n ensures z <= z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_15280","instance":15280,"id":185279,"goal":"lemma LeTrans_15280(x: int, j: int, d: int)\n requires x <= j && j <= d\n ensures x <= d\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_15281","instance":15281,"id":185280,"goal":"lemma AddMono_15281(x: nat, i: nat, j: nat)\n requires x <= i\n ensures x + j <= i + j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_15282","instance":15282,"id":185281,"goal":"lemma Abs_Nonneg_15282(a: real)\n ensures (if a >= 0 then a else -a) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_15283","instance":15283,"id":185282,"goal":"lemma DivMod_15283(b: int, n: int)\n requires n > 0\n ensures b == n * (b / n) + (b % n)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_15284","instance":15284,"id":185283,"goal":"lemma ModBounds_15284(m: nat, n: nat)\n requires n > 0\n ensures 0 <= m % n < n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_15285","instance":15285,"id":185284,"goal":"lemma Square_Nonneg_15285(z: real)\n ensures z * z >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_15286","instance":15286,"id":185285,"goal":"lemma AddComm_15286(n: int, i: int)\n ensures n + i == i + n\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_15287","instance":15287,"id":185286,"goal":"lemma AddAssoc_15287(d: nat, m: nat, c: nat)\n ensures (d + m) + c == d + (m + c)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_15288","instance":15288,"id":185287,"goal":"lemma MulComm_15288(c: real, j: real)\n ensures c * j == j * c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_15289","instance":15289,"id":185288,"goal":"lemma MulAssoc_15289(a: int, k: int, b: int)\n ensures (a * k) * b == a * (k * b)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_15290","instance":15290,"id":185289,"goal":"lemma Distrib_15290(k: nat, x: nat, a: nat)\n ensures k * (x + a) == k * x + k * a\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_15291","instance":15291,"id":185290,"goal":"lemma AddZero_15291(c: real)\n ensures c + 0 == c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_15292","instance":15292,"id":185291,"goal":"lemma MulOne_15292(x: int)\n ensures x * 1 == x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_15293","instance":15293,"id":185292,"goal":"lemma MulZero_15293(y: nat)\n ensures y * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_15294","instance":15294,"id":185293,"goal":"lemma LeRefl_15294(b: real)\n ensures b <= b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_15295","instance":15295,"id":185294,"goal":"lemma LeTrans_15295(a: int, i: int, k: int)\n requires a <= i && i <= k\n ensures a <= k\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_15296","instance":15296,"id":185295,"goal":"lemma AddMono_15296(x: nat, n: nat, c: nat)\n requires x <= n\n ensures x + c <= n + c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_15297","instance":15297,"id":185296,"goal":"lemma Abs_Nonneg_15297(a: real)\n ensures (if a >= 0 then a else -a) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_15298","instance":15298,"id":185297,"goal":"lemma DivMod_15298(x: int, b: int)\n requires b > 0\n ensures x == b * (x / b) + (x % b)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_15299","instance":15299,"id":185298,"goal":"lemma ModBounds_15299(c: nat, a: nat)\n requires a > 0\n ensures 0 <= c % a < a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_15300","instance":15300,"id":185299,"goal":"lemma Square_Nonneg_15300(z: real)\n ensures z * z >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_15301","instance":15301,"id":185300,"goal":"lemma AddComm_15301(n: int, x: int)\n ensures n + x == x + n\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_15302","instance":15302,"id":185301,"goal":"lemma AddAssoc_15302(b: nat, a: nat, c: nat)\n ensures (b + a) + c == b + (a + c)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_15303","instance":15303,"id":185302,"goal":"lemma MulComm_15303(y: real, a: real)\n ensures y * a == a * y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_15304","instance":15304,"id":185303,"goal":"lemma MulAssoc_15304(c: int, k: int, n: int)\n ensures (c * k) * n == c * (k * n)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_15305","instance":15305,"id":185304,"goal":"lemma Distrib_15305(d: nat, a: nat, c: nat)\n ensures d * (a + c) == d * a + d * c\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_15306","instance":15306,"id":185305,"goal":"lemma AddZero_15306(z: real)\n ensures z + 0 == z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_15307","instance":15307,"id":185306,"goal":"lemma MulOne_15307(x: int)\n ensures x * 1 == x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_15308","instance":15308,"id":185307,"goal":"lemma MulZero_15308(b: nat)\n ensures b * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_15309","instance":15309,"id":185308,"goal":"lemma LeRefl_15309(m: real)\n ensures m <= m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_15310","instance":15310,"id":185309,"goal":"lemma LeTrans_15310(x: int, a: int, j: int)\n requires x <= a && a <= j\n ensures x <= j\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_15311","instance":15311,"id":185310,"goal":"lemma AddMono_15311(a: nat, z: nat, j: nat)\n requires a <= z\n ensures a + j <= z + j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_15312","instance":15312,"id":185311,"goal":"lemma Abs_Nonneg_15312(k: real)\n ensures (if k >= 0 then k else -k) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_15313","instance":15313,"id":185312,"goal":"lemma DivMod_15313(c: int, i: int)\n requires i > 0\n ensures c == i * (c / i) + (c % i)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_15314","instance":15314,"id":185313,"goal":"lemma ModBounds_15314(b: nat, k: nat)\n requires k > 0\n ensures 0 <= b % k < k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_15315","instance":15315,"id":185314,"goal":"lemma Square_Nonneg_15315(b: real)\n ensures b * b >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_15316","instance":15316,"id":185315,"goal":"lemma AddComm_15316(a: int, m: int)\n ensures a + m == m + a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_15317","instance":15317,"id":185316,"goal":"lemma AddAssoc_15317(z: nat, d: nat, c: nat)\n ensures (z + d) + c == z + (d + c)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_15318","instance":15318,"id":185317,"goal":"lemma MulComm_15318(y: real, m: real)\n ensures y * m == m * y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_15319","instance":15319,"id":185318,"goal":"lemma MulAssoc_15319(j: int, x: int, y: int)\n ensures (j * x) * y == j * (x * y)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_15320","instance":15320,"id":185319,"goal":"lemma Distrib_15320(m: nat, j: nat, i: nat)\n ensures m * (j + i) == m * j + m * i\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_15321","instance":15321,"id":185320,"goal":"lemma AddZero_15321(x: real)\n ensures x + 0 == x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_15322","instance":15322,"id":185321,"goal":"lemma MulOne_15322(b: int)\n ensures b * 1 == b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_15323","instance":15323,"id":185322,"goal":"lemma MulZero_15323(a: nat)\n ensures a * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_15324","instance":15324,"id":185323,"goal":"lemma LeRefl_15324(n: real)\n ensures n <= n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_15325","instance":15325,"id":185324,"goal":"lemma LeTrans_15325(b: int, y: int, i: int)\n requires b <= y && y <= i\n ensures b <= i\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_15326","instance":15326,"id":185325,"goal":"lemma AddMono_15326(a: nat, b: nat, z: nat)\n requires a <= b\n ensures a + z <= b + z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_15327","instance":15327,"id":185326,"goal":"lemma Abs_Nonneg_15327(c: real)\n ensures (if c >= 0 then c else -c) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_15328","instance":15328,"id":185327,"goal":"lemma DivMod_15328(n: int, a: int)\n requires a > 0\n ensures n == a * (n / a) + (n % a)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_15329","instance":15329,"id":185328,"goal":"lemma ModBounds_15329(i: nat, n: nat)\n requires n > 0\n ensures 0 <= i % n < n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_15330","instance":15330,"id":185329,"goal":"lemma Square_Nonneg_15330(x: real)\n ensures x * x >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_15331","instance":15331,"id":185330,"goal":"lemma AddComm_15331(b: int, c: int)\n ensures b + c == c + b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_15332","instance":15332,"id":185331,"goal":"lemma AddAssoc_15332(y: nat, m: nat, b: nat)\n ensures (y + m) + b == y + (m + b)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_15333","instance":15333,"id":185332,"goal":"lemma MulComm_15333(y: real, n: real)\n ensures y * n == n * y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_15334","instance":15334,"id":185333,"goal":"lemma MulAssoc_15334(i: int, k: int, y: int)\n ensures (i * k) * y == i * (k * y)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_15335","instance":15335,"id":185334,"goal":"lemma Distrib_15335(b: nat, z: nat, i: nat)\n ensures b * (z + i) == b * z + b * i\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_15336","instance":15336,"id":185335,"goal":"lemma AddZero_15336(y: real)\n ensures y + 0 == y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_15337","instance":15337,"id":185336,"goal":"lemma MulOne_15337(i: int)\n ensures i * 1 == i\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_15338","instance":15338,"id":185337,"goal":"lemma MulZero_15338(b: nat)\n ensures b * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_15339","instance":15339,"id":185338,"goal":"lemma LeRefl_15339(x: real)\n ensures x <= x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_15340","instance":15340,"id":185339,"goal":"lemma LeTrans_15340(n: int, y: int, c: int)\n requires n <= y && y <= c\n ensures n <= c\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_15341","instance":15341,"id":185340,"goal":"lemma AddMono_15341(m: nat, c: nat, x: nat)\n requires m <= c\n ensures m + x <= c + x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_15342","instance":15342,"id":185341,"goal":"lemma Abs_Nonneg_15342(x: real)\n ensures (if x >= 0 then x else -x) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_15343","instance":15343,"id":185342,"goal":"lemma DivMod_15343(a: int, z: int)\n requires z > 0\n ensures a == z * (a / z) + (a % z)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_15344","instance":15344,"id":185343,"goal":"lemma ModBounds_15344(c: nat, y: nat)\n requires y > 0\n ensures 0 <= c % y < y\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_15345","instance":15345,"id":185344,"goal":"lemma Square_Nonneg_15345(d: real)\n ensures d * d >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_15346","instance":15346,"id":185345,"goal":"lemma AddComm_15346(z: int, n: int)\n ensures z + n == n + z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_15347","instance":15347,"id":185346,"goal":"lemma AddAssoc_15347(n: nat, a: nat, y: nat)\n ensures (n + a) + y == n + (a + y)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_15348","instance":15348,"id":185347,"goal":"lemma MulComm_15348(m: real, k: real)\n ensures m * k == k * m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_15349","instance":15349,"id":185348,"goal":"lemma MulAssoc_15349(a: int, c: int, b: int)\n ensures (a * c) * b == a * (c * b)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_15350","instance":15350,"id":185349,"goal":"lemma Distrib_15350(d: nat, z: nat, c: nat)\n ensures d * (z + c) == d * z + d * c\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_15351","instance":15351,"id":185350,"goal":"lemma AddZero_15351(y: real)\n ensures y + 0 == y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_15352","instance":15352,"id":185351,"goal":"lemma MulOne_15352(m: int)\n ensures m * 1 == m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_15353","instance":15353,"id":185352,"goal":"lemma MulZero_15353(m: nat)\n ensures m * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_15354","instance":15354,"id":185353,"goal":"lemma LeRefl_15354(a: real)\n ensures a <= a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_15355","instance":15355,"id":185354,"goal":"lemma LeTrans_15355(i: int, a: int, x: int)\n requires i <= a && a <= x\n ensures i <= x\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_15356","instance":15356,"id":185355,"goal":"lemma AddMono_15356(a: nat, b: nat, m: nat)\n requires a <= b\n ensures a + m <= b + m\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_15357","instance":15357,"id":185356,"goal":"lemma Abs_Nonneg_15357(c: real)\n ensures (if c >= 0 then c else -c) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_15358","instance":15358,"id":185357,"goal":"lemma DivMod_15358(j: int, b: int)\n requires b > 0\n ensures j == b * (j / b) + (j % b)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_15359","instance":15359,"id":185358,"goal":"lemma ModBounds_15359(b: nat, m: nat)\n requires m > 0\n ensures 0 <= b % m < m\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_15360","instance":15360,"id":185359,"goal":"lemma Square_Nonneg_15360(y: real)\n ensures y * y >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_15361","instance":15361,"id":185360,"goal":"lemma AddComm_15361(d: int, a: int)\n ensures d + a == a + d\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_15362","instance":15362,"id":185361,"goal":"lemma AddAssoc_15362(c: nat, x: nat, b: nat)\n ensures (c + x) + b == c + (x + b)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_15363","instance":15363,"id":185362,"goal":"lemma MulComm_15363(k: real, a: real)\n ensures k * a == a * k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_15364","instance":15364,"id":185363,"goal":"lemma MulAssoc_15364(x: int, j: int, a: int)\n ensures (x * j) * a == x * (j * a)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_15365","instance":15365,"id":185364,"goal":"lemma Distrib_15365(b: nat, k: nat, d: nat)\n ensures b * (k + d) == b * k + b * d\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_15366","instance":15366,"id":185365,"goal":"lemma AddZero_15366(c: real)\n ensures c + 0 == c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_15367","instance":15367,"id":185366,"goal":"lemma MulOne_15367(a: int)\n ensures a * 1 == a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_15368","instance":15368,"id":185367,"goal":"lemma MulZero_15368(k: nat)\n ensures k * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_15369","instance":15369,"id":185368,"goal":"lemma LeRefl_15369(b: real)\n ensures b <= b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_15370","instance":15370,"id":185369,"goal":"lemma LeTrans_15370(i: int, y: int, k: int)\n requires i <= y && y <= k\n ensures i <= k\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_15371","instance":15371,"id":185370,"goal":"lemma AddMono_15371(n: nat, m: nat, x: nat)\n requires n <= m\n ensures n + x <= m + x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_15372","instance":15372,"id":185371,"goal":"lemma Abs_Nonneg_15372(z: real)\n ensures (if z >= 0 then z else -z) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_15373","instance":15373,"id":185372,"goal":"lemma DivMod_15373(j: int, x: int)\n requires x > 0\n ensures j == x * (j / x) + (j % x)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_15374","instance":15374,"id":185373,"goal":"lemma ModBounds_15374(z: nat, n: nat)\n requires n > 0\n ensures 0 <= z % n < n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_15375","instance":15375,"id":185374,"goal":"lemma Square_Nonneg_15375(y: real)\n ensures y * y >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_15376","instance":15376,"id":185375,"goal":"lemma AddComm_15376(d: int, a: int)\n ensures d + a == a + d\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_15377","instance":15377,"id":185376,"goal":"lemma AddAssoc_15377(n: nat, i: nat, j: nat)\n ensures (n + i) + j == n + (i + j)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_15378","instance":15378,"id":185377,"goal":"lemma MulComm_15378(x: real, m: real)\n ensures x * m == m * x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_15379","instance":15379,"id":185378,"goal":"lemma MulAssoc_15379(b: int, x: int, n: int)\n ensures (b * x) * n == b * (x * n)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_15380","instance":15380,"id":185379,"goal":"lemma Distrib_15380(m: nat, z: nat, d: nat)\n ensures m * (z + d) == m * z + m * d\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_15381","instance":15381,"id":185380,"goal":"lemma AddZero_15381(x: real)\n ensures x + 0 == x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_15382","instance":15382,"id":185381,"goal":"lemma MulOne_15382(i: int)\n ensures i * 1 == i\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_15383","instance":15383,"id":185382,"goal":"lemma MulZero_15383(k: nat)\n ensures k * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_15384","instance":15384,"id":185383,"goal":"lemma LeRefl_15384(d: real)\n ensures d <= d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_15385","instance":15385,"id":185384,"goal":"lemma LeTrans_15385(m: int, j: int, y: int)\n requires m <= j && j <= y\n ensures m <= y\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_15386","instance":15386,"id":185385,"goal":"lemma AddMono_15386(k: nat, i: nat, y: nat)\n requires k <= i\n ensures k + y <= i + y\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_15387","instance":15387,"id":185386,"goal":"lemma Abs_Nonneg_15387(c: real)\n ensures (if c >= 0 then c else -c) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_15388","instance":15388,"id":185387,"goal":"lemma DivMod_15388(d: int, z: int)\n requires z > 0\n ensures d == z * (d / z) + (d % z)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_15389","instance":15389,"id":185388,"goal":"lemma ModBounds_15389(m: nat, i: nat)\n requires i > 0\n ensures 0 <= m % i < i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_15390","instance":15390,"id":185389,"goal":"lemma Square_Nonneg_15390(m: real)\n ensures m * m >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_15391","instance":15391,"id":185390,"goal":"lemma AddComm_15391(z: int, x: int)\n ensures z + x == x + z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_15392","instance":15392,"id":185391,"goal":"lemma AddAssoc_15392(j: nat, x: nat, a: nat)\n ensures (j + x) + a == j + (x + a)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_15393","instance":15393,"id":185392,"goal":"lemma MulComm_15393(n: real, i: real)\n ensures n * i == i * n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_15394","instance":15394,"id":185393,"goal":"lemma MulAssoc_15394(b: int, a: int, m: int)\n ensures (b * a) * m == b * (a * m)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_15395","instance":15395,"id":185394,"goal":"lemma Distrib_15395(a: nat, i: nat, n: nat)\n ensures a * (i + n) == a * i + a * n\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_15396","instance":15396,"id":185395,"goal":"lemma AddZero_15396(j: real)\n ensures j + 0 == j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_15397","instance":15397,"id":185396,"goal":"lemma MulOne_15397(a: int)\n ensures a * 1 == a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_15398","instance":15398,"id":185397,"goal":"lemma MulZero_15398(k: nat)\n ensures k * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_15399","instance":15399,"id":185398,"goal":"lemma LeRefl_15399(a: real)\n ensures a <= a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_15400","instance":15400,"id":185399,"goal":"lemma LeTrans_15400(d: int, a: int, x: int)\n requires d <= a && a <= x\n ensures d <= x\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_15401","instance":15401,"id":185400,"goal":"lemma AddMono_15401(k: nat, x: nat, i: nat)\n requires k <= x\n ensures k + i <= x + i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_15402","instance":15402,"id":185401,"goal":"lemma Abs_Nonneg_15402(a: real)\n ensures (if a >= 0 then a else -a) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_15403","instance":15403,"id":185402,"goal":"lemma DivMod_15403(d: int, n: int)\n requires n > 0\n ensures d == n * (d / n) + (d % n)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_15404","instance":15404,"id":185403,"goal":"lemma ModBounds_15404(a: nat, m: nat)\n requires m > 0\n ensures 0 <= a % m < m\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_15405","instance":15405,"id":185404,"goal":"lemma Square_Nonneg_15405(a: real)\n ensures a * a >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_15406","instance":15406,"id":185405,"goal":"lemma AddComm_15406(m: int, y: int)\n ensures m + y == y + m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_15407","instance":15407,"id":185406,"goal":"lemma AddAssoc_15407(y: nat, n: nat, k: nat)\n ensures (y + n) + k == y + (n + k)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_15408","instance":15408,"id":185407,"goal":"lemma MulComm_15408(y: real, n: real)\n ensures y * n == n * y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_15409","instance":15409,"id":185408,"goal":"lemma MulAssoc_15409(z: int, j: int, b: int)\n ensures (z * j) * b == z * (j * b)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_15410","instance":15410,"id":185409,"goal":"lemma Distrib_15410(z: nat, k: nat, m: nat)\n ensures z * (k + m) == z * k + z * m\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_15411","instance":15411,"id":185410,"goal":"lemma AddZero_15411(z: real)\n ensures z + 0 == z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_15412","instance":15412,"id":185411,"goal":"lemma MulOne_15412(j: int)\n ensures j * 1 == j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_15413","instance":15413,"id":185412,"goal":"lemma MulZero_15413(m: nat)\n ensures m * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_15414","instance":15414,"id":185413,"goal":"lemma LeRefl_15414(c: real)\n ensures c <= c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_15415","instance":15415,"id":185414,"goal":"lemma LeTrans_15415(a: int, z: int, d: int)\n requires a <= z && z <= d\n ensures a <= d\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_15416","instance":15416,"id":185415,"goal":"lemma AddMono_15416(z: nat, a: nat, d: nat)\n requires z <= a\n ensures z + d <= a + d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_15417","instance":15417,"id":185416,"goal":"lemma Abs_Nonneg_15417(k: real)\n ensures (if k >= 0 then k else -k) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_15418","instance":15418,"id":185417,"goal":"lemma DivMod_15418(x: int, k: int)\n requires k > 0\n ensures x == k * (x / k) + (x % k)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_15419","instance":15419,"id":185418,"goal":"lemma ModBounds_15419(m: nat, i: nat)\n requires i > 0\n ensures 0 <= m % i < i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_15420","instance":15420,"id":185419,"goal":"lemma Square_Nonneg_15420(b: real)\n ensures b * b >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_15421","instance":15421,"id":185420,"goal":"lemma AddComm_15421(d: int, c: int)\n ensures d + c == c + d\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_15422","instance":15422,"id":185421,"goal":"lemma AddAssoc_15422(z: nat, m: nat, j: nat)\n ensures (z + m) + j == z + (m + j)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_15423","instance":15423,"id":185422,"goal":"lemma MulComm_15423(k: real, x: real)\n ensures k * x == x * k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_15424","instance":15424,"id":185423,"goal":"lemma MulAssoc_15424(n: int, m: int, i: int)\n ensures (n * m) * i == n * (m * i)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_15425","instance":15425,"id":185424,"goal":"lemma Distrib_15425(k: nat, c: nat, a: nat)\n ensures k * (c + a) == k * c + k * a\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_15426","instance":15426,"id":185425,"goal":"lemma AddZero_15426(m: real)\n ensures m + 0 == m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_15427","instance":15427,"id":185426,"goal":"lemma MulOne_15427(k: int)\n ensures k * 1 == k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_15428","instance":15428,"id":185427,"goal":"lemma MulZero_15428(y: nat)\n ensures y * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_15429","instance":15429,"id":185428,"goal":"lemma LeRefl_15429(y: real)\n ensures y <= y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_15430","instance":15430,"id":185429,"goal":"lemma LeTrans_15430(z: int, c: int, x: int)\n requires z <= c && c <= x\n ensures z <= x\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_15431","instance":15431,"id":185430,"goal":"lemma AddMono_15431(a: nat, m: nat, z: nat)\n requires a <= m\n ensures a + z <= m + z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_15432","instance":15432,"id":185431,"goal":"lemma Abs_Nonneg_15432(k: real)\n ensures (if k >= 0 then k else -k) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_15433","instance":15433,"id":185432,"goal":"lemma DivMod_15433(y: int, k: int)\n requires k > 0\n ensures y == k * (y / k) + (y % k)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_15434","instance":15434,"id":185433,"goal":"lemma ModBounds_15434(n: nat, y: nat)\n requires y > 0\n ensures 0 <= n % y < y\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_15435","instance":15435,"id":185434,"goal":"lemma Square_Nonneg_15435(b: real)\n ensures b * b >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_15436","instance":15436,"id":185435,"goal":"lemma AddComm_15436(b: int, i: int)\n ensures b + i == i + b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_15437","instance":15437,"id":185436,"goal":"lemma AddAssoc_15437(k: nat, z: nat, c: nat)\n ensures (k + z) + c == k + (z + c)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_15438","instance":15438,"id":185437,"goal":"lemma MulComm_15438(m: real, k: real)\n ensures m * k == k * m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_15439","instance":15439,"id":185438,"goal":"lemma MulAssoc_15439(n: int, z: int, c: int)\n ensures (n * z) * c == n * (z * c)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_15440","instance":15440,"id":185439,"goal":"lemma Distrib_15440(i: nat, d: nat, k: nat)\n ensures i * (d + k) == i * d + i * k\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_15441","instance":15441,"id":185440,"goal":"lemma AddZero_15441(b: real)\n ensures b + 0 == b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_15442","instance":15442,"id":185441,"goal":"lemma MulOne_15442(x: int)\n ensures x * 1 == x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_15443","instance":15443,"id":185442,"goal":"lemma MulZero_15443(j: nat)\n ensures j * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_15444","instance":15444,"id":185443,"goal":"lemma LeRefl_15444(z: real)\n ensures z <= z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_15445","instance":15445,"id":185444,"goal":"lemma LeTrans_15445(c: int, y: int, d: int)\n requires c <= y && y <= d\n ensures c <= d\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_15446","instance":15446,"id":185445,"goal":"lemma AddMono_15446(x: nat, z: nat, m: nat)\n requires x <= z\n ensures x + m <= z + m\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_15447","instance":15447,"id":185446,"goal":"lemma Abs_Nonneg_15447(c: real)\n ensures (if c >= 0 then c else -c) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_15448","instance":15448,"id":185447,"goal":"lemma DivMod_15448(m: int, a: int)\n requires a > 0\n ensures m == a * (m / a) + (m % a)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_15449","instance":15449,"id":185448,"goal":"lemma ModBounds_15449(m: nat, i: nat)\n requires i > 0\n ensures 0 <= m % i < i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_15450","instance":15450,"id":185449,"goal":"lemma Square_Nonneg_15450(j: real)\n ensures j * j >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_15451","instance":15451,"id":185450,"goal":"lemma AddComm_15451(x: int, c: int)\n ensures x + c == c + x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_15452","instance":15452,"id":185451,"goal":"lemma AddAssoc_15452(k: nat, n: nat, b: nat)\n ensures (k + n) + b == k + (n + b)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_15453","instance":15453,"id":185452,"goal":"lemma MulComm_15453(x: real, d: real)\n ensures x * d == d * x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_15454","instance":15454,"id":185453,"goal":"lemma MulAssoc_15454(m: int, j: int, y: int)\n ensures (m * j) * y == m * (j * y)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_15455","instance":15455,"id":185454,"goal":"lemma Distrib_15455(b: nat, d: nat, x: nat)\n ensures b * (d + x) == b * d + b * x\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_15456","instance":15456,"id":185455,"goal":"lemma AddZero_15456(j: real)\n ensures j + 0 == j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_15457","instance":15457,"id":185456,"goal":"lemma MulOne_15457(i: int)\n ensures i * 1 == i\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_15458","instance":15458,"id":185457,"goal":"lemma MulZero_15458(d: nat)\n ensures d * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_15459","instance":15459,"id":185458,"goal":"lemma LeRefl_15459(n: real)\n ensures n <= n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_15460","instance":15460,"id":185459,"goal":"lemma LeTrans_15460(d: int, z: int, a: int)\n requires d <= z && z <= a\n ensures d <= a\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_15461","instance":15461,"id":185460,"goal":"lemma AddMono_15461(a: nat, b: nat, d: nat)\n requires a <= b\n ensures a + d <= b + d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_15462","instance":15462,"id":185461,"goal":"lemma Abs_Nonneg_15462(x: real)\n ensures (if x >= 0 then x else -x) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_15463","instance":15463,"id":185462,"goal":"lemma DivMod_15463(m: int, i: int)\n requires i > 0\n ensures m == i * (m / i) + (m % i)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_15464","instance":15464,"id":185463,"goal":"lemma ModBounds_15464(z: nat, m: nat)\n requires m > 0\n ensures 0 <= z % m < m\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_15465","instance":15465,"id":185464,"goal":"lemma Square_Nonneg_15465(y: real)\n ensures y * y >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_15466","instance":15466,"id":185465,"goal":"lemma AddComm_15466(b: int, d: int)\n ensures b + d == d + b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_15467","instance":15467,"id":185466,"goal":"lemma AddAssoc_15467(x: nat, k: nat, i: nat)\n ensures (x + k) + i == x + (k + i)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_15468","instance":15468,"id":185467,"goal":"lemma MulComm_15468(d: real, c: real)\n ensures d * c == c * d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_15469","instance":15469,"id":185468,"goal":"lemma MulAssoc_15469(z: int, b: int, d: int)\n ensures (z * b) * d == z * (b * d)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_15470","instance":15470,"id":185469,"goal":"lemma Distrib_15470(j: nat, x: nat, y: nat)\n ensures j * (x + y) == j * x + j * y\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_15471","instance":15471,"id":185470,"goal":"lemma AddZero_15471(d: real)\n ensures d + 0 == d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_15472","instance":15472,"id":185471,"goal":"lemma MulOne_15472(x: int)\n ensures x * 1 == x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_15473","instance":15473,"id":185472,"goal":"lemma MulZero_15473(d: nat)\n ensures d * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_15474","instance":15474,"id":185473,"goal":"lemma LeRefl_15474(k: real)\n ensures k <= k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_15475","instance":15475,"id":185474,"goal":"lemma LeTrans_15475(m: int, y: int, z: int)\n requires m <= y && y <= z\n ensures m <= z\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_15476","instance":15476,"id":185475,"goal":"lemma AddMono_15476(y: nat, c: nat, z: nat)\n requires y <= c\n ensures y + z <= c + z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_15477","instance":15477,"id":185476,"goal":"lemma Abs_Nonneg_15477(a: real)\n ensures (if a >= 0 then a else -a) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_15478","instance":15478,"id":185477,"goal":"lemma DivMod_15478(i: int, m: int)\n requires m > 0\n ensures i == m * (i / m) + (i % m)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_15479","instance":15479,"id":185478,"goal":"lemma ModBounds_15479(x: nat, a: nat)\n requires a > 0\n ensures 0 <= x % a < a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_15480","instance":15480,"id":185479,"goal":"lemma Square_Nonneg_15480(m: real)\n ensures m * m >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_15481","instance":15481,"id":185480,"goal":"lemma AddComm_15481(y: int, a: int)\n ensures y + a == a + y\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_15482","instance":15482,"id":185481,"goal":"lemma AddAssoc_15482(z: nat, a: nat, x: nat)\n ensures (z + a) + x == z + (a + x)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_15483","instance":15483,"id":185482,"goal":"lemma MulComm_15483(z: real, y: real)\n ensures z * y == y * z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_15484","instance":15484,"id":185483,"goal":"lemma MulAssoc_15484(i: int, b: int, k: int)\n ensures (i * b) * k == i * (b * k)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_15485","instance":15485,"id":185484,"goal":"lemma Distrib_15485(c: nat, y: nat, n: nat)\n ensures c * (y + n) == c * y + c * n\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_15486","instance":15486,"id":185485,"goal":"lemma AddZero_15486(i: real)\n ensures i + 0 == i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_15487","instance":15487,"id":185486,"goal":"lemma MulOne_15487(j: int)\n ensures j * 1 == j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_15488","instance":15488,"id":185487,"goal":"lemma MulZero_15488(n: nat)\n ensures n * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_15489","instance":15489,"id":185488,"goal":"lemma LeRefl_15489(x: real)\n ensures x <= x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_15490","instance":15490,"id":185489,"goal":"lemma LeTrans_15490(x: int, d: int, j: int)\n requires x <= d && d <= j\n ensures x <= j\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_15491","instance":15491,"id":185490,"goal":"lemma AddMono_15491(b: nat, x: nat, j: nat)\n requires b <= x\n ensures b + j <= x + j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_15492","instance":15492,"id":185491,"goal":"lemma Abs_Nonneg_15492(y: real)\n ensures (if y >= 0 then y else -y) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_15493","instance":15493,"id":185492,"goal":"lemma DivMod_15493(y: int, b: int)\n requires b > 0\n ensures y == b * (y / b) + (y % b)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_15494","instance":15494,"id":185493,"goal":"lemma ModBounds_15494(d: nat, y: nat)\n requires y > 0\n ensures 0 <= d % y < y\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_15495","instance":15495,"id":185494,"goal":"lemma Square_Nonneg_15495(m: real)\n ensures m * m >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_15496","instance":15496,"id":185495,"goal":"lemma AddComm_15496(k: int, b: int)\n ensures k + b == b + k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_15497","instance":15497,"id":185496,"goal":"lemma AddAssoc_15497(d: nat, c: nat, i: nat)\n ensures (d + c) + i == d + (c + i)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_15498","instance":15498,"id":185497,"goal":"lemma MulComm_15498(x: real, d: real)\n ensures x * d == d * x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_15499","instance":15499,"id":185498,"goal":"lemma MulAssoc_15499(i: int, z: int, m: int)\n ensures (i * z) * m == i * (z * m)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_15500","instance":15500,"id":185499,"goal":"lemma Distrib_15500(i: nat, y: nat, k: nat)\n ensures i * (y + k) == i * y + i * k\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_15501","instance":15501,"id":185500,"goal":"lemma AddZero_15501(d: real)\n ensures d + 0 == d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_15502","instance":15502,"id":185501,"goal":"lemma MulOne_15502(c: int)\n ensures c * 1 == c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_15503","instance":15503,"id":185502,"goal":"lemma MulZero_15503(n: nat)\n ensures n * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_15504","instance":15504,"id":185503,"goal":"lemma LeRefl_15504(k: real)\n ensures k <= k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_15505","instance":15505,"id":185504,"goal":"lemma LeTrans_15505(c: int, x: int, d: int)\n requires c <= x && x <= d\n ensures c <= d\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_15506","instance":15506,"id":185505,"goal":"lemma AddMono_15506(y: nat, b: nat, n: nat)\n requires y <= b\n ensures y + n <= b + n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_15507","instance":15507,"id":185506,"goal":"lemma Abs_Nonneg_15507(k: real)\n ensures (if k >= 0 then k else -k) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_15508","instance":15508,"id":185507,"goal":"lemma DivMod_15508(c: int, k: int)\n requires k > 0\n ensures c == k * (c / k) + (c % k)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_15509","instance":15509,"id":185508,"goal":"lemma ModBounds_15509(k: nat, c: nat)\n requires c > 0\n ensures 0 <= k % c < c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_15510","instance":15510,"id":185509,"goal":"lemma Square_Nonneg_15510(y: real)\n ensures y * y >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_15511","instance":15511,"id":185510,"goal":"lemma AddComm_15511(n: int, d: int)\n ensures n + d == d + n\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_15512","instance":15512,"id":185511,"goal":"lemma AddAssoc_15512(d: nat, i: nat, y: nat)\n ensures (d + i) + y == d + (i + y)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_15513","instance":15513,"id":185512,"goal":"lemma MulComm_15513(x: real, y: real)\n ensures x * y == y * x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_15514","instance":15514,"id":185513,"goal":"lemma MulAssoc_15514(b: int, m: int, j: int)\n ensures (b * m) * j == b * (m * j)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_15515","instance":15515,"id":185514,"goal":"lemma Distrib_15515(n: nat, k: nat, z: nat)\n ensures n * (k + z) == n * k + n * z\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_15516","instance":15516,"id":185515,"goal":"lemma AddZero_15516(z: real)\n ensures z + 0 == z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_15517","instance":15517,"id":185516,"goal":"lemma MulOne_15517(x: int)\n ensures x * 1 == x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_15518","instance":15518,"id":185517,"goal":"lemma MulZero_15518(i: nat)\n ensures i * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_15519","instance":15519,"id":185518,"goal":"lemma LeRefl_15519(x: real)\n ensures x <= x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_15520","instance":15520,"id":185519,"goal":"lemma LeTrans_15520(x: int, a: int, i: int)\n requires x <= a && a <= i\n ensures x <= i\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_15521","instance":15521,"id":185520,"goal":"lemma AddMono_15521(x: nat, i: nat, b: nat)\n requires x <= i\n ensures x + b <= i + b\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_15522","instance":15522,"id":185521,"goal":"lemma Abs_Nonneg_15522(x: real)\n ensures (if x >= 0 then x else -x) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_15523","instance":15523,"id":185522,"goal":"lemma DivMod_15523(c: int, y: int)\n requires y > 0\n ensures c == y * (c / y) + (c % y)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_15524","instance":15524,"id":185523,"goal":"lemma ModBounds_15524(y: nat, i: nat)\n requires i > 0\n ensures 0 <= y % i < i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_15525","instance":15525,"id":185524,"goal":"lemma Square_Nonneg_15525(d: real)\n ensures d * d >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_15526","instance":15526,"id":185525,"goal":"lemma AddComm_15526(m: int, i: int)\n ensures m + i == i + m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_15527","instance":15527,"id":185526,"goal":"lemma AddAssoc_15527(i: nat, b: nat, x: nat)\n ensures (i + b) + x == i + (b + x)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_15528","instance":15528,"id":185527,"goal":"lemma MulComm_15528(y: real, i: real)\n ensures y * i == i * y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_15529","instance":15529,"id":185528,"goal":"lemma MulAssoc_15529(z: int, i: int, m: int)\n ensures (z * i) * m == z * (i * m)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_15530","instance":15530,"id":185529,"goal":"lemma Distrib_15530(c: nat, a: nat, m: nat)\n ensures c * (a + m) == c * a + c * m\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_15531","instance":15531,"id":185530,"goal":"lemma AddZero_15531(c: real)\n ensures c + 0 == c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_15532","instance":15532,"id":185531,"goal":"lemma MulOne_15532(c: int)\n ensures c * 1 == c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_15533","instance":15533,"id":185532,"goal":"lemma MulZero_15533(d: nat)\n ensures d * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_15534","instance":15534,"id":185533,"goal":"lemma LeRefl_15534(y: real)\n ensures y <= y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_15535","instance":15535,"id":185534,"goal":"lemma LeTrans_15535(k: int, z: int, n: int)\n requires k <= z && z <= n\n ensures k <= n\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_15536","instance":15536,"id":185535,"goal":"lemma AddMono_15536(n: nat, j: nat, b: nat)\n requires n <= j\n ensures n + b <= j + b\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_15537","instance":15537,"id":185536,"goal":"lemma Abs_Nonneg_15537(z: real)\n ensures (if z >= 0 then z else -z) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_15538","instance":15538,"id":185537,"goal":"lemma DivMod_15538(n: int, m: int)\n requires m > 0\n ensures n == m * (n / m) + (n % m)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_15539","instance":15539,"id":185538,"goal":"lemma ModBounds_15539(b: nat, a: nat)\n requires a > 0\n ensures 0 <= b % a < a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_15540","instance":15540,"id":185539,"goal":"lemma Square_Nonneg_15540(n: real)\n ensures n * n >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_15541","instance":15541,"id":185540,"goal":"lemma AddComm_15541(i: int, b: int)\n ensures i + b == b + i\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_15542","instance":15542,"id":185541,"goal":"lemma AddAssoc_15542(b: nat, j: nat, z: nat)\n ensures (b + j) + z == b + (j + z)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_15543","instance":15543,"id":185542,"goal":"lemma MulComm_15543(b: real, y: real)\n ensures b * y == y * b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_15544","instance":15544,"id":185543,"goal":"lemma MulAssoc_15544(a: int, y: int, k: int)\n ensures (a * y) * k == a * (y * k)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_15545","instance":15545,"id":185544,"goal":"lemma Distrib_15545(i: nat, z: nat, k: nat)\n ensures i * (z + k) == i * z + i * k\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_15546","instance":15546,"id":185545,"goal":"lemma AddZero_15546(j: real)\n ensures j + 0 == j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_15547","instance":15547,"id":185546,"goal":"lemma MulOne_15547(k: int)\n ensures k * 1 == k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_15548","instance":15548,"id":185547,"goal":"lemma MulZero_15548(c: nat)\n ensures c * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_15549","instance":15549,"id":185548,"goal":"lemma LeRefl_15549(k: real)\n ensures k <= k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_15550","instance":15550,"id":185549,"goal":"lemma LeTrans_15550(n: int, x: int, a: int)\n requires n <= x && x <= a\n ensures n <= a\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_15551","instance":15551,"id":185550,"goal":"lemma AddMono_15551(a: nat, m: nat, j: nat)\n requires a <= m\n ensures a + j <= m + j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_15552","instance":15552,"id":185551,"goal":"lemma Abs_Nonneg_15552(n: real)\n ensures (if n >= 0 then n else -n) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_15553","instance":15553,"id":185552,"goal":"lemma DivMod_15553(j: int, c: int)\n requires c > 0\n ensures j == c * (j / c) + (j % c)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_15554","instance":15554,"id":185553,"goal":"lemma ModBounds_15554(b: nat, i: nat)\n requires i > 0\n ensures 0 <= b % i < i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_15555","instance":15555,"id":185554,"goal":"lemma Square_Nonneg_15555(a: real)\n ensures a * a >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_15556","instance":15556,"id":185555,"goal":"lemma AddComm_15556(c: int, k: int)\n ensures c + k == k + c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_15557","instance":15557,"id":185556,"goal":"lemma AddAssoc_15557(j: nat, z: nat, d: nat)\n ensures (j + z) + d == j + (z + d)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_15558","instance":15558,"id":185557,"goal":"lemma MulComm_15558(y: real, d: real)\n ensures y * d == d * y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_15559","instance":15559,"id":185558,"goal":"lemma MulAssoc_15559(j: int, z: int, x: int)\n ensures (j * z) * x == j * (z * x)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_15560","instance":15560,"id":185559,"goal":"lemma Distrib_15560(n: nat, c: nat, m: nat)\n ensures n * (c + m) == n * c + n * m\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_15561","instance":15561,"id":185560,"goal":"lemma AddZero_15561(i: real)\n ensures i + 0 == i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_15562","instance":15562,"id":185561,"goal":"lemma MulOne_15562(n: int)\n ensures n * 1 == n\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_15563","instance":15563,"id":185562,"goal":"lemma MulZero_15563(a: nat)\n ensures a * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_15564","instance":15564,"id":185563,"goal":"lemma LeRefl_15564(a: real)\n ensures a <= a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_15565","instance":15565,"id":185564,"goal":"lemma LeTrans_15565(y: int, m: int, k: int)\n requires y <= m && m <= k\n ensures y <= k\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_15566","instance":15566,"id":185565,"goal":"lemma AddMono_15566(m: nat, k: nat, n: nat)\n requires m <= k\n ensures m + n <= k + n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_15567","instance":15567,"id":185566,"goal":"lemma Abs_Nonneg_15567(z: real)\n ensures (if z >= 0 then z else -z) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_15568","instance":15568,"id":185567,"goal":"lemma DivMod_15568(a: int, y: int)\n requires y > 0\n ensures a == y * (a / y) + (a % y)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_15569","instance":15569,"id":185568,"goal":"lemma ModBounds_15569(b: nat, x: nat)\n requires x > 0\n ensures 0 <= b % x < x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_15570","instance":15570,"id":185569,"goal":"lemma Square_Nonneg_15570(m: real)\n ensures m * m >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_15571","instance":15571,"id":185570,"goal":"lemma AddComm_15571(c: int, k: int)\n ensures c + k == k + c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_15572","instance":15572,"id":185571,"goal":"lemma AddAssoc_15572(b: nat, i: nat, z: nat)\n ensures (b + i) + z == b + (i + z)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_15573","instance":15573,"id":185572,"goal":"lemma MulComm_15573(x: real, b: real)\n ensures x * b == b * x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_15574","instance":15574,"id":185573,"goal":"lemma MulAssoc_15574(x: int, b: int, a: int)\n ensures (x * b) * a == x * (b * a)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_15575","instance":15575,"id":185574,"goal":"lemma Distrib_15575(i: nat, d: nat, c: nat)\n ensures i * (d + c) == i * d + i * c\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_15576","instance":15576,"id":185575,"goal":"lemma AddZero_15576(i: real)\n ensures i + 0 == i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_15577","instance":15577,"id":185576,"goal":"lemma MulOne_15577(c: int)\n ensures c * 1 == c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_15578","instance":15578,"id":185577,"goal":"lemma MulZero_15578(y: nat)\n ensures y * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_15579","instance":15579,"id":185578,"goal":"lemma LeRefl_15579(j: real)\n ensures j <= j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_15580","instance":15580,"id":185579,"goal":"lemma LeTrans_15580(x: int, c: int, m: int)\n requires x <= c && c <= m\n ensures x <= m\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_15581","instance":15581,"id":185580,"goal":"lemma AddMono_15581(m: nat, b: nat, x: nat)\n requires m <= b\n ensures m + x <= b + x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_15582","instance":15582,"id":185581,"goal":"lemma Abs_Nonneg_15582(x: real)\n ensures (if x >= 0 then x else -x) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_15583","instance":15583,"id":185582,"goal":"lemma DivMod_15583(i: int, c: int)\n requires c > 0\n ensures i == c * (i / c) + (i % c)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_15584","instance":15584,"id":185583,"goal":"lemma ModBounds_15584(k: nat, z: nat)\n requires z > 0\n ensures 0 <= k % z < z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_15585","instance":15585,"id":185584,"goal":"lemma Square_Nonneg_15585(j: real)\n ensures j * j >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_15586","instance":15586,"id":185585,"goal":"lemma AddComm_15586(k: int, b: int)\n ensures k + b == b + k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_15587","instance":15587,"id":185586,"goal":"lemma AddAssoc_15587(m: nat, i: nat, z: nat)\n ensures (m + i) + z == m + (i + z)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_15588","instance":15588,"id":185587,"goal":"lemma MulComm_15588(n: real, i: real)\n ensures n * i == i * n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_15589","instance":15589,"id":185588,"goal":"lemma MulAssoc_15589(i: int, y: int, z: int)\n ensures (i * y) * z == i * (y * z)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_15590","instance":15590,"id":185589,"goal":"lemma Distrib_15590(n: nat, y: nat, z: nat)\n ensures n * (y + z) == n * y + n * z\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_15591","instance":15591,"id":185590,"goal":"lemma AddZero_15591(b: real)\n ensures b + 0 == b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_15592","instance":15592,"id":185591,"goal":"lemma MulOne_15592(a: int)\n ensures a * 1 == a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_15593","instance":15593,"id":185592,"goal":"lemma MulZero_15593(c: nat)\n ensures c * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_15594","instance":15594,"id":185593,"goal":"lemma LeRefl_15594(i: real)\n ensures i <= i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_15595","instance":15595,"id":185594,"goal":"lemma LeTrans_15595(a: int, b: int, k: int)\n requires a <= b && b <= k\n ensures a <= k\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_15596","instance":15596,"id":185595,"goal":"lemma AddMono_15596(n: nat, i: nat, y: nat)\n requires n <= i\n ensures n + y <= i + y\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_15597","instance":15597,"id":185596,"goal":"lemma Abs_Nonneg_15597(y: real)\n ensures (if y >= 0 then y else -y) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_15598","instance":15598,"id":185597,"goal":"lemma DivMod_15598(k: int, c: int)\n requires c > 0\n ensures k == c * (k / c) + (k % c)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_15599","instance":15599,"id":185598,"goal":"lemma ModBounds_15599(i: nat, z: nat)\n requires z > 0\n ensures 0 <= i % z < z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_15600","instance":15600,"id":185599,"goal":"lemma Square_Nonneg_15600(i: real)\n ensures i * i >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_15601","instance":15601,"id":185600,"goal":"lemma AddComm_15601(n: int, b: int)\n ensures n + b == b + n\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_15602","instance":15602,"id":185601,"goal":"lemma AddAssoc_15602(n: nat, k: nat, a: nat)\n ensures (n + k) + a == n + (k + a)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_15603","instance":15603,"id":185602,"goal":"lemma MulComm_15603(c: real, x: real)\n ensures c * x == x * c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_15604","instance":15604,"id":185603,"goal":"lemma MulAssoc_15604(d: int, y: int, i: int)\n ensures (d * y) * i == d * (y * i)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_15605","instance":15605,"id":185604,"goal":"lemma Distrib_15605(a: nat, x: nat, j: nat)\n ensures a * (x + j) == a * x + a * j\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_15606","instance":15606,"id":185605,"goal":"lemma AddZero_15606(k: real)\n ensures k + 0 == k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_15607","instance":15607,"id":185606,"goal":"lemma MulOne_15607(b: int)\n ensures b * 1 == b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_15608","instance":15608,"id":185607,"goal":"lemma MulZero_15608(y: nat)\n ensures y * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_15609","instance":15609,"id":185608,"goal":"lemma LeRefl_15609(d: real)\n ensures d <= d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_15610","instance":15610,"id":185609,"goal":"lemma LeTrans_15610(b: int, d: int, j: int)\n requires b <= d && d <= j\n ensures b <= j\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_15611","instance":15611,"id":185610,"goal":"lemma AddMono_15611(x: nat, n: nat, z: nat)\n requires x <= n\n ensures x + z <= n + z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_15612","instance":15612,"id":185611,"goal":"lemma Abs_Nonneg_15612(b: real)\n ensures (if b >= 0 then b else -b) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_15613","instance":15613,"id":185612,"goal":"lemma DivMod_15613(n: int, c: int)\n requires c > 0\n ensures n == c * (n / c) + (n % c)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_15614","instance":15614,"id":185613,"goal":"lemma ModBounds_15614(y: nat, a: nat)\n requires a > 0\n ensures 0 <= y % a < a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_15615","instance":15615,"id":185614,"goal":"lemma Square_Nonneg_15615(z: real)\n ensures z * z >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_15616","instance":15616,"id":185615,"goal":"lemma AddComm_15616(j: int, i: int)\n ensures j + i == i + j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_15617","instance":15617,"id":185616,"goal":"lemma AddAssoc_15617(c: nat, y: nat, b: nat)\n ensures (c + y) + b == c + (y + b)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_15618","instance":15618,"id":185617,"goal":"lemma MulComm_15618(i: real, n: real)\n ensures i * n == n * i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_15619","instance":15619,"id":185618,"goal":"lemma MulAssoc_15619(c: int, i: int, x: int)\n ensures (c * i) * x == c * (i * x)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_15620","instance":15620,"id":185619,"goal":"lemma Distrib_15620(a: nat, i: nat, n: nat)\n ensures a * (i + n) == a * i + a * n\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_15621","instance":15621,"id":185620,"goal":"lemma AddZero_15621(b: real)\n ensures b + 0 == b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_15622","instance":15622,"id":185621,"goal":"lemma MulOne_15622(j: int)\n ensures j * 1 == j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_15623","instance":15623,"id":185622,"goal":"lemma MulZero_15623(x: nat)\n ensures x * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_15624","instance":15624,"id":185623,"goal":"lemma LeRefl_15624(n: real)\n ensures n <= n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_15625","instance":15625,"id":185624,"goal":"lemma LeTrans_15625(x: int, a: int, n: int)\n requires x <= a && a <= n\n ensures x <= n\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_15626","instance":15626,"id":185625,"goal":"lemma AddMono_15626(i: nat, a: nat, n: nat)\n requires i <= a\n ensures i + n <= a + n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_15627","instance":15627,"id":185626,"goal":"lemma Abs_Nonneg_15627(y: real)\n ensures (if y >= 0 then y else -y) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_15628","instance":15628,"id":185627,"goal":"lemma DivMod_15628(b: int, z: int)\n requires z > 0\n ensures b == z * (b / z) + (b % z)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_15629","instance":15629,"id":185628,"goal":"lemma ModBounds_15629(n: nat, i: nat)\n requires i > 0\n ensures 0 <= n % i < i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_15630","instance":15630,"id":185629,"goal":"lemma Square_Nonneg_15630(n: real)\n ensures n * n >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_15631","instance":15631,"id":185630,"goal":"lemma AddComm_15631(j: int, k: int)\n ensures j + k == k + j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_15632","instance":15632,"id":185631,"goal":"lemma AddAssoc_15632(y: nat, a: nat, c: nat)\n ensures (y + a) + c == y + (a + c)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_15633","instance":15633,"id":185632,"goal":"lemma MulComm_15633(k: real, x: real)\n ensures k * x == x * k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_15634","instance":15634,"id":185633,"goal":"lemma MulAssoc_15634(x: int, j: int, a: int)\n ensures (x * j) * a == x * (j * a)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_15635","instance":15635,"id":185634,"goal":"lemma Distrib_15635(k: nat, d: nat, n: nat)\n ensures k * (d + n) == k * d + k * n\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_15636","instance":15636,"id":185635,"goal":"lemma AddZero_15636(j: real)\n ensures j + 0 == j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_15637","instance":15637,"id":185636,"goal":"lemma MulOne_15637(a: int)\n ensures a * 1 == a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_15638","instance":15638,"id":185637,"goal":"lemma MulZero_15638(n: nat)\n ensures n * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_15639","instance":15639,"id":185638,"goal":"lemma LeRefl_15639(y: real)\n ensures y <= y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_15640","instance":15640,"id":185639,"goal":"lemma LeTrans_15640(k: int, c: int, n: int)\n requires k <= c && c <= n\n ensures k <= n\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_15641","instance":15641,"id":185640,"goal":"lemma AddMono_15641(k: nat, i: nat, c: nat)\n requires k <= i\n ensures k + c <= i + c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_15642","instance":15642,"id":185641,"goal":"lemma Abs_Nonneg_15642(d: real)\n ensures (if d >= 0 then d else -d) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_15643","instance":15643,"id":185642,"goal":"lemma DivMod_15643(m: int, d: int)\n requires d > 0\n ensures m == d * (m / d) + (m % d)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_15644","instance":15644,"id":185643,"goal":"lemma ModBounds_15644(b: nat, m: nat)\n requires m > 0\n ensures 0 <= b % m < m\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_15645","instance":15645,"id":185644,"goal":"lemma Square_Nonneg_15645(x: real)\n ensures x * x >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_15646","instance":15646,"id":185645,"goal":"lemma AddComm_15646(n: int, d: int)\n ensures n + d == d + n\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_15647","instance":15647,"id":185646,"goal":"lemma AddAssoc_15647(c: nat, y: nat, m: nat)\n ensures (c + y) + m == c + (y + m)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_15648","instance":15648,"id":185647,"goal":"lemma MulComm_15648(k: real, y: real)\n ensures k * y == y * k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_15649","instance":15649,"id":185648,"goal":"lemma MulAssoc_15649(i: int, z: int, y: int)\n ensures (i * z) * y == i * (z * y)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_15650","instance":15650,"id":185649,"goal":"lemma Distrib_15650(d: nat, b: nat, c: nat)\n ensures d * (b + c) == d * b + d * c\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_15651","instance":15651,"id":185650,"goal":"lemma AddZero_15651(n: real)\n ensures n + 0 == n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_15652","instance":15652,"id":185651,"goal":"lemma MulOne_15652(b: int)\n ensures b * 1 == b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_15653","instance":15653,"id":185652,"goal":"lemma MulZero_15653(c: nat)\n ensures c * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_15654","instance":15654,"id":185653,"goal":"lemma LeRefl_15654(y: real)\n ensures y <= y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_15655","instance":15655,"id":185654,"goal":"lemma LeTrans_15655(b: int, c: int, y: int)\n requires b <= c && c <= y\n ensures b <= y\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_15656","instance":15656,"id":185655,"goal":"lemma AddMono_15656(c: nat, m: nat, k: nat)\n requires c <= m\n ensures c + k <= m + k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_15657","instance":15657,"id":185656,"goal":"lemma Abs_Nonneg_15657(x: real)\n ensures (if x >= 0 then x else -x) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_15658","instance":15658,"id":185657,"goal":"lemma DivMod_15658(c: int, i: int)\n requires i > 0\n ensures c == i * (c / i) + (c % i)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_15659","instance":15659,"id":185658,"goal":"lemma ModBounds_15659(b: nat, m: nat)\n requires m > 0\n ensures 0 <= b % m < m\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_15660","instance":15660,"id":185659,"goal":"lemma Square_Nonneg_15660(m: real)\n ensures m * m >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_15661","instance":15661,"id":185660,"goal":"lemma AddComm_15661(a: int, j: int)\n ensures a + j == j + a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_15662","instance":15662,"id":185661,"goal":"lemma AddAssoc_15662(n: nat, x: nat, i: nat)\n ensures (n + x) + i == n + (x + i)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_15663","instance":15663,"id":185662,"goal":"lemma MulComm_15663(m: real, n: real)\n ensures m * n == n * m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_15664","instance":15664,"id":185663,"goal":"lemma MulAssoc_15664(x: int, i: int, y: int)\n ensures (x * i) * y == x * (i * y)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_15665","instance":15665,"id":185664,"goal":"lemma Distrib_15665(i: nat, d: nat, n: nat)\n ensures i * (d + n) == i * d + i * n\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_15666","instance":15666,"id":185665,"goal":"lemma AddZero_15666(a: real)\n ensures a + 0 == a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_15667","instance":15667,"id":185666,"goal":"lemma MulOne_15667(a: int)\n ensures a * 1 == a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_15668","instance":15668,"id":185667,"goal":"lemma MulZero_15668(i: nat)\n ensures i * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_15669","instance":15669,"id":185668,"goal":"lemma LeRefl_15669(k: real)\n ensures k <= k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_15670","instance":15670,"id":185669,"goal":"lemma LeTrans_15670(c: int, n: int, d: int)\n requires c <= n && n <= d\n ensures c <= d\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_15671","instance":15671,"id":185670,"goal":"lemma AddMono_15671(i: nat, b: nat, y: nat)\n requires i <= b\n ensures i + y <= b + y\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_15672","instance":15672,"id":185671,"goal":"lemma Abs_Nonneg_15672(d: real)\n ensures (if d >= 0 then d else -d) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_15673","instance":15673,"id":185672,"goal":"lemma DivMod_15673(y: int, b: int)\n requires b > 0\n ensures y == b * (y / b) + (y % b)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_15674","instance":15674,"id":185673,"goal":"lemma ModBounds_15674(i: nat, a: nat)\n requires a > 0\n ensures 0 <= i % a < a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_15675","instance":15675,"id":185674,"goal":"lemma Square_Nonneg_15675(j: real)\n ensures j * j >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_15676","instance":15676,"id":185675,"goal":"lemma AddComm_15676(d: int, c: int)\n ensures d + c == c + d\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_15677","instance":15677,"id":185676,"goal":"lemma AddAssoc_15677(y: nat, x: nat, d: nat)\n ensures (y + x) + d == y + (x + d)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_15678","instance":15678,"id":185677,"goal":"lemma MulComm_15678(b: real, y: real)\n ensures b * y == y * b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_15679","instance":15679,"id":185678,"goal":"lemma MulAssoc_15679(b: int, k: int, z: int)\n ensures (b * k) * z == b * (k * z)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_15680","instance":15680,"id":185679,"goal":"lemma Distrib_15680(n: nat, j: nat, a: nat)\n ensures n * (j + a) == n * j + n * a\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_15681","instance":15681,"id":185680,"goal":"lemma AddZero_15681(z: real)\n ensures z + 0 == z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_15682","instance":15682,"id":185681,"goal":"lemma MulOne_15682(x: int)\n ensures x * 1 == x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_15683","instance":15683,"id":185682,"goal":"lemma MulZero_15683(n: nat)\n ensures n * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_15684","instance":15684,"id":185683,"goal":"lemma LeRefl_15684(d: real)\n ensures d <= d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_15685","instance":15685,"id":185684,"goal":"lemma LeTrans_15685(j: int, n: int, z: int)\n requires j <= n && n <= z\n ensures j <= z\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_15686","instance":15686,"id":185685,"goal":"lemma AddMono_15686(i: nat, k: nat, c: nat)\n requires i <= k\n ensures i + c <= k + c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_15687","instance":15687,"id":185686,"goal":"lemma Abs_Nonneg_15687(z: real)\n ensures (if z >= 0 then z else -z) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_15688","instance":15688,"id":185687,"goal":"lemma DivMod_15688(i: int, c: int)\n requires c > 0\n ensures i == c * (i / c) + (i % c)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_15689","instance":15689,"id":185688,"goal":"lemma ModBounds_15689(c: nat, b: nat)\n requires b > 0\n ensures 0 <= c % b < b\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_15690","instance":15690,"id":185689,"goal":"lemma Square_Nonneg_15690(z: real)\n ensures z * z >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_15691","instance":15691,"id":185690,"goal":"lemma AddComm_15691(z: int, d: int)\n ensures z + d == d + z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_15692","instance":15692,"id":185691,"goal":"lemma AddAssoc_15692(j: nat, m: nat, z: nat)\n ensures (j + m) + z == j + (m + z)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_15693","instance":15693,"id":185692,"goal":"lemma MulComm_15693(k: real, c: real)\n ensures k * c == c * k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_15694","instance":15694,"id":185693,"goal":"lemma MulAssoc_15694(i: int, y: int, x: int)\n ensures (i * y) * x == i * (y * x)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_15695","instance":15695,"id":185694,"goal":"lemma Distrib_15695(i: nat, z: nat, k: nat)\n ensures i * (z + k) == i * z + i * k\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_15696","instance":15696,"id":185695,"goal":"lemma AddZero_15696(i: real)\n ensures i + 0 == i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_15697","instance":15697,"id":185696,"goal":"lemma MulOne_15697(j: int)\n ensures j * 1 == j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_15698","instance":15698,"id":185697,"goal":"lemma MulZero_15698(i: nat)\n ensures i * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_15699","instance":15699,"id":185698,"goal":"lemma LeRefl_15699(x: real)\n ensures x <= x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_15700","instance":15700,"id":185699,"goal":"lemma LeTrans_15700(i: int, j: int, b: int)\n requires i <= j && j <= b\n ensures i <= b\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_15701","instance":15701,"id":185700,"goal":"lemma AddMono_15701(x: nat, n: nat, k: nat)\n requires x <= n\n ensures x + k <= n + k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_15702","instance":15702,"id":185701,"goal":"lemma Abs_Nonneg_15702(i: real)\n ensures (if i >= 0 then i else -i) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_15703","instance":15703,"id":185702,"goal":"lemma DivMod_15703(n: int, z: int)\n requires z > 0\n ensures n == z * (n / z) + (n % z)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_15704","instance":15704,"id":185703,"goal":"lemma ModBounds_15704(y: nat, k: nat)\n requires k > 0\n ensures 0 <= y % k < k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_15705","instance":15705,"id":185704,"goal":"lemma Square_Nonneg_15705(m: real)\n ensures m * m >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_15706","instance":15706,"id":185705,"goal":"lemma AddComm_15706(m: int, b: int)\n ensures m + b == b + m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_15707","instance":15707,"id":185706,"goal":"lemma AddAssoc_15707(i: nat, k: nat, a: nat)\n ensures (i + k) + a == i + (k + a)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_15708","instance":15708,"id":185707,"goal":"lemma MulComm_15708(b: real, x: real)\n ensures b * x == x * b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_15709","instance":15709,"id":185708,"goal":"lemma MulAssoc_15709(n: int, d: int, m: int)\n ensures (n * d) * m == n * (d * m)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_15710","instance":15710,"id":185709,"goal":"lemma Distrib_15710(i: nat, z: nat, m: nat)\n ensures i * (z + m) == i * z + i * m\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_15711","instance":15711,"id":185710,"goal":"lemma AddZero_15711(i: real)\n ensures i + 0 == i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_15712","instance":15712,"id":185711,"goal":"lemma MulOne_15712(k: int)\n ensures k * 1 == k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_15713","instance":15713,"id":185712,"goal":"lemma MulZero_15713(y: nat)\n ensures y * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_15714","instance":15714,"id":185713,"goal":"lemma LeRefl_15714(a: real)\n ensures a <= a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_15715","instance":15715,"id":185714,"goal":"lemma LeTrans_15715(c: int, m: int, k: int)\n requires c <= m && m <= k\n ensures c <= k\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_15716","instance":15716,"id":185715,"goal":"lemma AddMono_15716(j: nat, n: nat, i: nat)\n requires j <= n\n ensures j + i <= n + i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_15717","instance":15717,"id":185716,"goal":"lemma Abs_Nonneg_15717(c: real)\n ensures (if c >= 0 then c else -c) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_15718","instance":15718,"id":185717,"goal":"lemma DivMod_15718(d: int, y: int)\n requires y > 0\n ensures d == y * (d / y) + (d % y)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_15719","instance":15719,"id":185718,"goal":"lemma ModBounds_15719(k: nat, i: nat)\n requires i > 0\n ensures 0 <= k % i < i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_15720","instance":15720,"id":185719,"goal":"lemma Square_Nonneg_15720(n: real)\n ensures n * n >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_15721","instance":15721,"id":185720,"goal":"lemma AddComm_15721(b: int, d: int)\n ensures b + d == d + b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_15722","instance":15722,"id":185721,"goal":"lemma AddAssoc_15722(y: nat, z: nat, x: nat)\n ensures (y + z) + x == y + (z + x)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_15723","instance":15723,"id":185722,"goal":"lemma MulComm_15723(b: real, n: real)\n ensures b * n == n * b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_15724","instance":15724,"id":185723,"goal":"lemma MulAssoc_15724(b: int, m: int, j: int)\n ensures (b * m) * j == b * (m * j)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_15725","instance":15725,"id":185724,"goal":"lemma Distrib_15725(b: nat, a: nat, i: nat)\n ensures b * (a + i) == b * a + b * i\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_15726","instance":15726,"id":185725,"goal":"lemma AddZero_15726(k: real)\n ensures k + 0 == k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_15727","instance":15727,"id":185726,"goal":"lemma MulOne_15727(d: int)\n ensures d * 1 == d\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_15728","instance":15728,"id":185727,"goal":"lemma MulZero_15728(j: nat)\n ensures j * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_15729","instance":15729,"id":185728,"goal":"lemma LeRefl_15729(d: real)\n ensures d <= d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_15730","instance":15730,"id":185729,"goal":"lemma LeTrans_15730(x: int, d: int, c: int)\n requires x <= d && d <= c\n ensures x <= c\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_15731","instance":15731,"id":185730,"goal":"lemma AddMono_15731(n: nat, j: nat, c: nat)\n requires n <= j\n ensures n + c <= j + c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_15732","instance":15732,"id":185731,"goal":"lemma Abs_Nonneg_15732(i: real)\n ensures (if i >= 0 then i else -i) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_15733","instance":15733,"id":185732,"goal":"lemma DivMod_15733(j: int, c: int)\n requires c > 0\n ensures j == c * (j / c) + (j % c)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_15734","instance":15734,"id":185733,"goal":"lemma ModBounds_15734(j: nat, n: nat)\n requires n > 0\n ensures 0 <= j % n < n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_15735","instance":15735,"id":185734,"goal":"lemma Square_Nonneg_15735(i: real)\n ensures i * i >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_15736","instance":15736,"id":185735,"goal":"lemma AddComm_15736(m: int, x: int)\n ensures m + x == x + m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_15737","instance":15737,"id":185736,"goal":"lemma AddAssoc_15737(j: nat, k: nat, n: nat)\n ensures (j + k) + n == j + (k + n)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_15738","instance":15738,"id":185737,"goal":"lemma MulComm_15738(d: real, x: real)\n ensures d * x == x * d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_15739","instance":15739,"id":185738,"goal":"lemma MulAssoc_15739(x: int, n: int, m: int)\n ensures (x * n) * m == x * (n * m)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_15740","instance":15740,"id":185739,"goal":"lemma Distrib_15740(k: nat, c: nat, a: nat)\n ensures k * (c + a) == k * c + k * a\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_15741","instance":15741,"id":185740,"goal":"lemma AddZero_15741(k: real)\n ensures k + 0 == k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_15742","instance":15742,"id":185741,"goal":"lemma MulOne_15742(b: int)\n ensures b * 1 == b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_15743","instance":15743,"id":185742,"goal":"lemma MulZero_15743(i: nat)\n ensures i * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_15744","instance":15744,"id":185743,"goal":"lemma LeRefl_15744(y: real)\n ensures y <= y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_15745","instance":15745,"id":185744,"goal":"lemma LeTrans_15745(m: int, k: int, z: int)\n requires m <= k && k <= z\n ensures m <= z\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_15746","instance":15746,"id":185745,"goal":"lemma AddMono_15746(y: nat, b: nat, a: nat)\n requires y <= b\n ensures y + a <= b + a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_15747","instance":15747,"id":185746,"goal":"lemma Abs_Nonneg_15747(z: real)\n ensures (if z >= 0 then z else -z) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_15748","instance":15748,"id":185747,"goal":"lemma DivMod_15748(c: int, x: int)\n requires x > 0\n ensures c == x * (c / x) + (c % x)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_15749","instance":15749,"id":185748,"goal":"lemma ModBounds_15749(x: nat, i: nat)\n requires i > 0\n ensures 0 <= x % i < i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_15750","instance":15750,"id":185749,"goal":"lemma Square_Nonneg_15750(m: real)\n ensures m * m >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_15751","instance":15751,"id":185750,"goal":"lemma AddComm_15751(c: int, m: int)\n ensures c + m == m + c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_15752","instance":15752,"id":185751,"goal":"lemma AddAssoc_15752(x: nat, a: nat, i: nat)\n ensures (x + a) + i == x + (a + i)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_15753","instance":15753,"id":185752,"goal":"lemma MulComm_15753(y: real, c: real)\n ensures y * c == c * y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_15754","instance":15754,"id":185753,"goal":"lemma MulAssoc_15754(m: int, d: int, y: int)\n ensures (m * d) * y == m * (d * y)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_15755","instance":15755,"id":185754,"goal":"lemma Distrib_15755(i: nat, b: nat, c: nat)\n ensures i * (b + c) == i * b + i * c\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_15756","instance":15756,"id":185755,"goal":"lemma AddZero_15756(i: real)\n ensures i + 0 == i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_15757","instance":15757,"id":185756,"goal":"lemma MulOne_15757(a: int)\n ensures a * 1 == a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_15758","instance":15758,"id":185757,"goal":"lemma MulZero_15758(d: nat)\n ensures d * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_15759","instance":15759,"id":185758,"goal":"lemma LeRefl_15759(n: real)\n ensures n <= n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_15760","instance":15760,"id":185759,"goal":"lemma LeTrans_15760(x: int, d: int, a: int)\n requires x <= d && d <= a\n ensures x <= a\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_15761","instance":15761,"id":185760,"goal":"lemma AddMono_15761(m: nat, y: nat, b: nat)\n requires m <= y\n ensures m + b <= y + b\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_15762","instance":15762,"id":185761,"goal":"lemma Abs_Nonneg_15762(d: real)\n ensures (if d >= 0 then d else -d) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_15763","instance":15763,"id":185762,"goal":"lemma DivMod_15763(d: int, x: int)\n requires x > 0\n ensures d == x * (d / x) + (d % x)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_15764","instance":15764,"id":185763,"goal":"lemma ModBounds_15764(m: nat, a: nat)\n requires a > 0\n ensures 0 <= m % a < a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_15765","instance":15765,"id":185764,"goal":"lemma Square_Nonneg_15765(y: real)\n ensures y * y >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_15766","instance":15766,"id":185765,"goal":"lemma AddComm_15766(c: int, j: int)\n ensures c + j == j + c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_15767","instance":15767,"id":185766,"goal":"lemma AddAssoc_15767(b: nat, y: nat, a: nat)\n ensures (b + y) + a == b + (y + a)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_15768","instance":15768,"id":185767,"goal":"lemma MulComm_15768(z: real, i: real)\n ensures z * i == i * z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_15769","instance":15769,"id":185768,"goal":"lemma MulAssoc_15769(z: int, j: int, c: int)\n ensures (z * j) * c == z * (j * c)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_15770","instance":15770,"id":185769,"goal":"lemma Distrib_15770(b: nat, k: nat, x: nat)\n ensures b * (k + x) == b * k + b * x\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_15771","instance":15771,"id":185770,"goal":"lemma AddZero_15771(m: real)\n ensures m + 0 == m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_15772","instance":15772,"id":185771,"goal":"lemma MulOne_15772(z: int)\n ensures z * 1 == z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_15773","instance":15773,"id":185772,"goal":"lemma MulZero_15773(i: nat)\n ensures i * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_15774","instance":15774,"id":185773,"goal":"lemma LeRefl_15774(i: real)\n ensures i <= i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_15775","instance":15775,"id":185774,"goal":"lemma LeTrans_15775(c: int, i: int, z: int)\n requires c <= i && i <= z\n ensures c <= z\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_15776","instance":15776,"id":185775,"goal":"lemma AddMono_15776(z: nat, n: nat, a: nat)\n requires z <= n\n ensures z + a <= n + a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_15777","instance":15777,"id":185776,"goal":"lemma Abs_Nonneg_15777(a: real)\n ensures (if a >= 0 then a else -a) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_15778","instance":15778,"id":185777,"goal":"lemma DivMod_15778(b: int, x: int)\n requires x > 0\n ensures b == x * (b / x) + (b % x)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_15779","instance":15779,"id":185778,"goal":"lemma ModBounds_15779(y: nat, k: nat)\n requires k > 0\n ensures 0 <= y % k < k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_15780","instance":15780,"id":185779,"goal":"lemma Square_Nonneg_15780(k: real)\n ensures k * k >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_15781","instance":15781,"id":185780,"goal":"lemma AddComm_15781(n: int, y: int)\n ensures n + y == y + n\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_15782","instance":15782,"id":185781,"goal":"lemma AddAssoc_15782(i: nat, a: nat, j: nat)\n ensures (i + a) + j == i + (a + j)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_15783","instance":15783,"id":185782,"goal":"lemma MulComm_15783(n: real, a: real)\n ensures n * a == a * n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_15784","instance":15784,"id":185783,"goal":"lemma MulAssoc_15784(i: int, y: int, x: int)\n ensures (i * y) * x == i * (y * x)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_15785","instance":15785,"id":185784,"goal":"lemma Distrib_15785(x: nat, j: nat, c: nat)\n ensures x * (j + c) == x * j + x * c\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_15786","instance":15786,"id":185785,"goal":"lemma AddZero_15786(d: real)\n ensures d + 0 == d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_15787","instance":15787,"id":185786,"goal":"lemma MulOne_15787(d: int)\n ensures d * 1 == d\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_15788","instance":15788,"id":185787,"goal":"lemma MulZero_15788(y: nat)\n ensures y * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_15789","instance":15789,"id":185788,"goal":"lemma LeRefl_15789(d: real)\n ensures d <= d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_15790","instance":15790,"id":185789,"goal":"lemma LeTrans_15790(c: int, d: int, a: int)\n requires c <= d && d <= a\n ensures c <= a\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_15791","instance":15791,"id":185790,"goal":"lemma AddMono_15791(z: nat, d: nat, y: nat)\n requires z <= d\n ensures z + y <= d + y\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_15792","instance":15792,"id":185791,"goal":"lemma Abs_Nonneg_15792(x: real)\n ensures (if x >= 0 then x else -x) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_15793","instance":15793,"id":185792,"goal":"lemma DivMod_15793(d: int, c: int)\n requires c > 0\n ensures d == c * (d / c) + (d % c)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_15794","instance":15794,"id":185793,"goal":"lemma ModBounds_15794(m: nat, j: nat)\n requires j > 0\n ensures 0 <= m % j < j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_15795","instance":15795,"id":185794,"goal":"lemma Square_Nonneg_15795(i: real)\n ensures i * i >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_15796","instance":15796,"id":185795,"goal":"lemma AddComm_15796(b: int, y: int)\n ensures b + y == y + b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_15797","instance":15797,"id":185796,"goal":"lemma AddAssoc_15797(k: nat, x: nat, d: nat)\n ensures (k + x) + d == k + (x + d)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_15798","instance":15798,"id":185797,"goal":"lemma MulComm_15798(i: real, a: real)\n ensures i * a == a * i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_15799","instance":15799,"id":185798,"goal":"lemma MulAssoc_15799(c: int, k: int, d: int)\n ensures (c * k) * d == c * (k * d)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_15800","instance":15800,"id":185799,"goal":"lemma Distrib_15800(a: nat, z: nat, m: nat)\n ensures a * (z + m) == a * z + a * m\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_15801","instance":15801,"id":185800,"goal":"lemma AddZero_15801(x: real)\n ensures x + 0 == x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_15802","instance":15802,"id":185801,"goal":"lemma MulOne_15802(a: int)\n ensures a * 1 == a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_15803","instance":15803,"id":185802,"goal":"lemma MulZero_15803(c: nat)\n ensures c * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_15804","instance":15804,"id":185803,"goal":"lemma LeRefl_15804(c: real)\n ensures c <= c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_15805","instance":15805,"id":185804,"goal":"lemma LeTrans_15805(x: int, j: int, b: int)\n requires x <= j && j <= b\n ensures x <= b\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_15806","instance":15806,"id":185805,"goal":"lemma AddMono_15806(d: nat, k: nat, z: nat)\n requires d <= k\n ensures d + z <= k + z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_15807","instance":15807,"id":185806,"goal":"lemma Abs_Nonneg_15807(c: real)\n ensures (if c >= 0 then c else -c) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_15808","instance":15808,"id":185807,"goal":"lemma DivMod_15808(y: int, i: int)\n requires i > 0\n ensures y == i * (y / i) + (y % i)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_15809","instance":15809,"id":185808,"goal":"lemma ModBounds_15809(j: nat, a: nat)\n requires a > 0\n ensures 0 <= j % a < a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_15810","instance":15810,"id":185809,"goal":"lemma Square_Nonneg_15810(z: real)\n ensures z * z >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_15811","instance":15811,"id":185810,"goal":"lemma AddComm_15811(c: int, d: int)\n ensures c + d == d + c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_15812","instance":15812,"id":185811,"goal":"lemma AddAssoc_15812(k: nat, b: nat, n: nat)\n ensures (k + b) + n == k + (b + n)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_15813","instance":15813,"id":185812,"goal":"lemma MulComm_15813(j: real, n: real)\n ensures j * n == n * j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_15814","instance":15814,"id":185813,"goal":"lemma MulAssoc_15814(k: int, d: int, x: int)\n ensures (k * d) * x == k * (d * x)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_15815","instance":15815,"id":185814,"goal":"lemma Distrib_15815(i: nat, x: nat, c: nat)\n ensures i * (x + c) == i * x + i * c\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_15816","instance":15816,"id":185815,"goal":"lemma AddZero_15816(k: real)\n ensures k + 0 == k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_15817","instance":15817,"id":185816,"goal":"lemma MulOne_15817(k: int)\n ensures k * 1 == k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_15818","instance":15818,"id":185817,"goal":"lemma MulZero_15818(m: nat)\n ensures m * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_15819","instance":15819,"id":185818,"goal":"lemma LeRefl_15819(m: real)\n ensures m <= m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_15820","instance":15820,"id":185819,"goal":"lemma LeTrans_15820(c: int, z: int, i: int)\n requires c <= z && z <= i\n ensures c <= i\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_15821","instance":15821,"id":185820,"goal":"lemma AddMono_15821(x: nat, y: nat, d: nat)\n requires x <= y\n ensures x + d <= y + d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_15822","instance":15822,"id":185821,"goal":"lemma Abs_Nonneg_15822(x: real)\n ensures (if x >= 0 then x else -x) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_15823","instance":15823,"id":185822,"goal":"lemma DivMod_15823(n: int, j: int)\n requires j > 0\n ensures n == j * (n / j) + (n % j)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_15824","instance":15824,"id":185823,"goal":"lemma ModBounds_15824(k: nat, x: nat)\n requires x > 0\n ensures 0 <= k % x < x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_15825","instance":15825,"id":185824,"goal":"lemma Square_Nonneg_15825(y: real)\n ensures y * y >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_15826","instance":15826,"id":185825,"goal":"lemma AddComm_15826(z: int, b: int)\n ensures z + b == b + z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_15827","instance":15827,"id":185826,"goal":"lemma AddAssoc_15827(i: nat, y: nat, a: nat)\n ensures (i + y) + a == i + (y + a)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_15828","instance":15828,"id":185827,"goal":"lemma MulComm_15828(j: real, m: real)\n ensures j * m == m * j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_15829","instance":15829,"id":185828,"goal":"lemma MulAssoc_15829(a: int, n: int, i: int)\n ensures (a * n) * i == a * (n * i)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_15830","instance":15830,"id":185829,"goal":"lemma Distrib_15830(a: nat, k: nat, b: nat)\n ensures a * (k + b) == a * k + a * b\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_15831","instance":15831,"id":185830,"goal":"lemma AddZero_15831(a: real)\n ensures a + 0 == a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_15832","instance":15832,"id":185831,"goal":"lemma MulOne_15832(b: int)\n ensures b * 1 == b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_15833","instance":15833,"id":185832,"goal":"lemma MulZero_15833(x: nat)\n ensures x * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_15834","instance":15834,"id":185833,"goal":"lemma LeRefl_15834(j: real)\n ensures j <= j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_15835","instance":15835,"id":185834,"goal":"lemma LeTrans_15835(j: int, i: int, z: int)\n requires j <= i && i <= z\n ensures j <= z\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_15836","instance":15836,"id":185835,"goal":"lemma AddMono_15836(d: nat, x: nat, a: nat)\n requires d <= x\n ensures d + a <= x + a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_15837","instance":15837,"id":185836,"goal":"lemma Abs_Nonneg_15837(k: real)\n ensures (if k >= 0 then k else -k) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_15838","instance":15838,"id":185837,"goal":"lemma DivMod_15838(i: int, z: int)\n requires z > 0\n ensures i == z * (i / z) + (i % z)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_15839","instance":15839,"id":185838,"goal":"lemma ModBounds_15839(k: nat, c: nat)\n requires c > 0\n ensures 0 <= k % c < c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_15840","instance":15840,"id":185839,"goal":"lemma Square_Nonneg_15840(m: real)\n ensures m * m >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_15841","instance":15841,"id":185840,"goal":"lemma AddComm_15841(z: int, d: int)\n ensures z + d == d + z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_15842","instance":15842,"id":185841,"goal":"lemma AddAssoc_15842(y: nat, d: nat, b: nat)\n ensures (y + d) + b == y + (d + b)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_15843","instance":15843,"id":185842,"goal":"lemma MulComm_15843(c: real, z: real)\n ensures c * z == z * c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_15844","instance":15844,"id":185843,"goal":"lemma MulAssoc_15844(m: int, j: int, c: int)\n ensures (m * j) * c == m * (j * c)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_15845","instance":15845,"id":185844,"goal":"lemma Distrib_15845(d: nat, a: nat, y: nat)\n ensures d * (a + y) == d * a + d * y\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_15846","instance":15846,"id":185845,"goal":"lemma AddZero_15846(x: real)\n ensures x + 0 == x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_15847","instance":15847,"id":185846,"goal":"lemma MulOne_15847(b: int)\n ensures b * 1 == b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_15848","instance":15848,"id":185847,"goal":"lemma MulZero_15848(j: nat)\n ensures j * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_15849","instance":15849,"id":185848,"goal":"lemma LeRefl_15849(y: real)\n ensures y <= y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_15850","instance":15850,"id":185849,"goal":"lemma LeTrans_15850(d: int, m: int, c: int)\n requires d <= m && m <= c\n ensures d <= c\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_15851","instance":15851,"id":185850,"goal":"lemma AddMono_15851(b: nat, j: nat, i: nat)\n requires b <= j\n ensures b + i <= j + i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_15852","instance":15852,"id":185851,"goal":"lemma Abs_Nonneg_15852(d: real)\n ensures (if d >= 0 then d else -d) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_15853","instance":15853,"id":185852,"goal":"lemma DivMod_15853(j: int, k: int)\n requires k > 0\n ensures j == k * (j / k) + (j % k)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_15854","instance":15854,"id":185853,"goal":"lemma ModBounds_15854(k: nat, j: nat)\n requires j > 0\n ensures 0 <= k % j < j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_15855","instance":15855,"id":185854,"goal":"lemma Square_Nonneg_15855(a: real)\n ensures a * a >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_15856","instance":15856,"id":185855,"goal":"lemma AddComm_15856(j: int, k: int)\n ensures j + k == k + j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_15857","instance":15857,"id":185856,"goal":"lemma AddAssoc_15857(m: nat, b: nat, y: nat)\n ensures (m + b) + y == m + (b + y)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_15858","instance":15858,"id":185857,"goal":"lemma MulComm_15858(y: real, j: real)\n ensures y * j == j * y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_15859","instance":15859,"id":185858,"goal":"lemma MulAssoc_15859(y: int, j: int, i: int)\n ensures (y * j) * i == y * (j * i)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_15860","instance":15860,"id":185859,"goal":"lemma Distrib_15860(c: nat, m: nat, i: nat)\n ensures c * (m + i) == c * m + c * i\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_15861","instance":15861,"id":185860,"goal":"lemma AddZero_15861(b: real)\n ensures b + 0 == b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_15862","instance":15862,"id":185861,"goal":"lemma MulOne_15862(z: int)\n ensures z * 1 == z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_15863","instance":15863,"id":185862,"goal":"lemma MulZero_15863(j: nat)\n ensures j * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_15864","instance":15864,"id":185863,"goal":"lemma LeRefl_15864(j: real)\n ensures j <= j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_15865","instance":15865,"id":185864,"goal":"lemma LeTrans_15865(x: int, i: int, n: int)\n requires x <= i && i <= n\n ensures x <= n\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_15866","instance":15866,"id":185865,"goal":"lemma AddMono_15866(k: nat, n: nat, c: nat)\n requires k <= n\n ensures k + c <= n + c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_15867","instance":15867,"id":185866,"goal":"lemma Abs_Nonneg_15867(k: real)\n ensures (if k >= 0 then k else -k) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_15868","instance":15868,"id":185867,"goal":"lemma DivMod_15868(x: int, m: int)\n requires m > 0\n ensures x == m * (x / m) + (x % m)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_15869","instance":15869,"id":185868,"goal":"lemma ModBounds_15869(z: nat, y: nat)\n requires y > 0\n ensures 0 <= z % y < y\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_15870","instance":15870,"id":185869,"goal":"lemma Square_Nonneg_15870(z: real)\n ensures z * z >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_15871","instance":15871,"id":185870,"goal":"lemma AddComm_15871(z: int, m: int)\n ensures z + m == m + z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_15872","instance":15872,"id":185871,"goal":"lemma AddAssoc_15872(a: nat, j: nat, n: nat)\n ensures (a + j) + n == a + (j + n)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_15873","instance":15873,"id":185872,"goal":"lemma MulComm_15873(b: real, a: real)\n ensures b * a == a * b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_15874","instance":15874,"id":185873,"goal":"lemma MulAssoc_15874(d: int, n: int, y: int)\n ensures (d * n) * y == d * (n * y)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_15875","instance":15875,"id":185874,"goal":"lemma Distrib_15875(m: nat, i: nat, j: nat)\n ensures m * (i + j) == m * i + m * j\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_15876","instance":15876,"id":185875,"goal":"lemma AddZero_15876(n: real)\n ensures n + 0 == n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_15877","instance":15877,"id":185876,"goal":"lemma MulOne_15877(j: int)\n ensures j * 1 == j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_15878","instance":15878,"id":185877,"goal":"lemma MulZero_15878(b: nat)\n ensures b * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_15879","instance":15879,"id":185878,"goal":"lemma LeRefl_15879(d: real)\n ensures d <= d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_15880","instance":15880,"id":185879,"goal":"lemma LeTrans_15880(m: int, d: int, b: int)\n requires m <= d && d <= b\n ensures m <= b\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_15881","instance":15881,"id":185880,"goal":"lemma AddMono_15881(c: nat, z: nat, b: nat)\n requires c <= z\n ensures c + b <= z + b\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_15882","instance":15882,"id":185881,"goal":"lemma Abs_Nonneg_15882(x: real)\n ensures (if x >= 0 then x else -x) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_15883","instance":15883,"id":185882,"goal":"lemma DivMod_15883(k: int, i: int)\n requires i > 0\n ensures k == i * (k / i) + (k % i)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_15884","instance":15884,"id":185883,"goal":"lemma ModBounds_15884(z: nat, y: nat)\n requires y > 0\n ensures 0 <= z % y < y\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_15885","instance":15885,"id":185884,"goal":"lemma Square_Nonneg_15885(c: real)\n ensures c * c >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_15886","instance":15886,"id":185885,"goal":"lemma AddComm_15886(b: int, a: int)\n ensures b + a == a + b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_15887","instance":15887,"id":185886,"goal":"lemma AddAssoc_15887(b: nat, x: nat, n: nat)\n ensures (b + x) + n == b + (x + n)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_15888","instance":15888,"id":185887,"goal":"lemma MulComm_15888(j: real, i: real)\n ensures j * i == i * j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_15889","instance":15889,"id":185888,"goal":"lemma MulAssoc_15889(m: int, b: int, y: int)\n ensures (m * b) * y == m * (b * y)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_15890","instance":15890,"id":185889,"goal":"lemma Distrib_15890(b: nat, c: nat, i: nat)\n ensures b * (c + i) == b * c + b * i\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_15891","instance":15891,"id":185890,"goal":"lemma AddZero_15891(z: real)\n ensures z + 0 == z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_15892","instance":15892,"id":185891,"goal":"lemma MulOne_15892(i: int)\n ensures i * 1 == i\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_15893","instance":15893,"id":185892,"goal":"lemma MulZero_15893(k: nat)\n ensures k * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_15894","instance":15894,"id":185893,"goal":"lemma LeRefl_15894(z: real)\n ensures z <= z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_15895","instance":15895,"id":185894,"goal":"lemma LeTrans_15895(j: int, a: int, m: int)\n requires j <= a && a <= m\n ensures j <= m\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_15896","instance":15896,"id":185895,"goal":"lemma AddMono_15896(c: nat, b: nat, n: nat)\n requires c <= b\n ensures c + n <= b + n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_15897","instance":15897,"id":185896,"goal":"lemma Abs_Nonneg_15897(n: real)\n ensures (if n >= 0 then n else -n) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_15898","instance":15898,"id":185897,"goal":"lemma DivMod_15898(c: int, b: int)\n requires b > 0\n ensures c == b * (c / b) + (c % b)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_15899","instance":15899,"id":185898,"goal":"lemma ModBounds_15899(i: nat, b: nat)\n requires b > 0\n ensures 0 <= i % b < b\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_15900","instance":15900,"id":185899,"goal":"lemma Square_Nonneg_15900(n: real)\n ensures n * n >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_15901","instance":15901,"id":185900,"goal":"lemma AddComm_15901(a: int, y: int)\n ensures a + y == y + a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_15902","instance":15902,"id":185901,"goal":"lemma AddAssoc_15902(z: nat, c: nat, x: nat)\n ensures (z + c) + x == z + (c + x)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_15903","instance":15903,"id":185902,"goal":"lemma MulComm_15903(x: real, k: real)\n ensures x * k == k * x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_15904","instance":15904,"id":185903,"goal":"lemma MulAssoc_15904(i: int, z: int, y: int)\n ensures (i * z) * y == i * (z * y)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_15905","instance":15905,"id":185904,"goal":"lemma Distrib_15905(x: nat, d: nat, k: nat)\n ensures x * (d + k) == x * d + x * k\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_15906","instance":15906,"id":185905,"goal":"lemma AddZero_15906(k: real)\n ensures k + 0 == k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_15907","instance":15907,"id":185906,"goal":"lemma MulOne_15907(y: int)\n ensures y * 1 == y\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_15908","instance":15908,"id":185907,"goal":"lemma MulZero_15908(z: nat)\n ensures z * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_15909","instance":15909,"id":185908,"goal":"lemma LeRefl_15909(x: real)\n ensures x <= x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_15910","instance":15910,"id":185909,"goal":"lemma LeTrans_15910(d: int, b: int, m: int)\n requires d <= b && b <= m\n ensures d <= m\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_15911","instance":15911,"id":185910,"goal":"lemma AddMono_15911(z: nat, y: nat, k: nat)\n requires z <= y\n ensures z + k <= y + k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_15912","instance":15912,"id":185911,"goal":"lemma Abs_Nonneg_15912(z: real)\n ensures (if z >= 0 then z else -z) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_15913","instance":15913,"id":185912,"goal":"lemma DivMod_15913(c: int, n: int)\n requires n > 0\n ensures c == n * (c / n) + (c % n)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_15914","instance":15914,"id":185913,"goal":"lemma ModBounds_15914(j: nat, k: nat)\n requires k > 0\n ensures 0 <= j % k < k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_15915","instance":15915,"id":185914,"goal":"lemma Square_Nonneg_15915(i: real)\n ensures i * i >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_15916","instance":15916,"id":185915,"goal":"lemma AddComm_15916(a: int, z: int)\n ensures a + z == z + a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_15917","instance":15917,"id":185916,"goal":"lemma AddAssoc_15917(d: nat, b: nat, k: nat)\n ensures (d + b) + k == d + (b + k)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_15918","instance":15918,"id":185917,"goal":"lemma MulComm_15918(k: real, x: real)\n ensures k * x == x * k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_15919","instance":15919,"id":185918,"goal":"lemma MulAssoc_15919(b: int, a: int, y: int)\n ensures (b * a) * y == b * (a * y)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_15920","instance":15920,"id":185919,"goal":"lemma Distrib_15920(x: nat, d: nat, y: nat)\n ensures x * (d + y) == x * d + x * y\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_15921","instance":15921,"id":185920,"goal":"lemma AddZero_15921(i: real)\n ensures i + 0 == i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_15922","instance":15922,"id":185921,"goal":"lemma MulOne_15922(i: int)\n ensures i * 1 == i\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_15923","instance":15923,"id":185922,"goal":"lemma MulZero_15923(d: nat)\n ensures d * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_15924","instance":15924,"id":185923,"goal":"lemma LeRefl_15924(z: real)\n ensures z <= z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_15925","instance":15925,"id":185924,"goal":"lemma LeTrans_15925(x: int, d: int, c: int)\n requires x <= d && d <= c\n ensures x <= c\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_15926","instance":15926,"id":185925,"goal":"lemma AddMono_15926(y: nat, d: nat, a: nat)\n requires y <= d\n ensures y + a <= d + a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_15927","instance":15927,"id":185926,"goal":"lemma Abs_Nonneg_15927(k: real)\n ensures (if k >= 0 then k else -k) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_15928","instance":15928,"id":185927,"goal":"lemma DivMod_15928(j: int, d: int)\n requires d > 0\n ensures j == d * (j / d) + (j % d)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_15929","instance":15929,"id":185928,"goal":"lemma ModBounds_15929(z: nat, i: nat)\n requires i > 0\n ensures 0 <= z % i < i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_15930","instance":15930,"id":185929,"goal":"lemma Square_Nonneg_15930(y: real)\n ensures y * y >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_15931","instance":15931,"id":185930,"goal":"lemma AddComm_15931(y: int, k: int)\n ensures y + k == k + y\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_15932","instance":15932,"id":185931,"goal":"lemma AddAssoc_15932(j: nat, z: nat, d: nat)\n ensures (j + z) + d == j + (z + d)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_15933","instance":15933,"id":185932,"goal":"lemma MulComm_15933(n: real, c: real)\n ensures n * c == c * n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_15934","instance":15934,"id":185933,"goal":"lemma MulAssoc_15934(d: int, k: int, z: int)\n ensures (d * k) * z == d * (k * z)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_15935","instance":15935,"id":185934,"goal":"lemma Distrib_15935(m: nat, x: nat, n: nat)\n ensures m * (x + n) == m * x + m * n\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_15936","instance":15936,"id":185935,"goal":"lemma AddZero_15936(c: real)\n ensures c + 0 == c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_15937","instance":15937,"id":185936,"goal":"lemma MulOne_15937(a: int)\n ensures a * 1 == a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_15938","instance":15938,"id":185937,"goal":"lemma MulZero_15938(m: nat)\n ensures m * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_15939","instance":15939,"id":185938,"goal":"lemma LeRefl_15939(k: real)\n ensures k <= k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_15940","instance":15940,"id":185939,"goal":"lemma LeTrans_15940(j: int, c: int, i: int)\n requires j <= c && c <= i\n ensures j <= i\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_15941","instance":15941,"id":185940,"goal":"lemma AddMono_15941(z: nat, x: nat, i: nat)\n requires z <= x\n ensures z + i <= x + i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_15942","instance":15942,"id":185941,"goal":"lemma Abs_Nonneg_15942(z: real)\n ensures (if z >= 0 then z else -z) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_15943","instance":15943,"id":185942,"goal":"lemma DivMod_15943(n: int, i: int)\n requires i > 0\n ensures n == i * (n / i) + (n % i)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_15944","instance":15944,"id":185943,"goal":"lemma ModBounds_15944(k: nat, d: nat)\n requires d > 0\n ensures 0 <= k % d < d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_15945","instance":15945,"id":185944,"goal":"lemma Square_Nonneg_15945(z: real)\n ensures z * z >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_15946","instance":15946,"id":185945,"goal":"lemma AddComm_15946(k: int, n: int)\n ensures k + n == n + k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_15947","instance":15947,"id":185946,"goal":"lemma AddAssoc_15947(z: nat, d: nat, b: nat)\n ensures (z + d) + b == z + (d + b)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_15948","instance":15948,"id":185947,"goal":"lemma MulComm_15948(c: real, i: real)\n ensures c * i == i * c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_15949","instance":15949,"id":185948,"goal":"lemma MulAssoc_15949(n: int, d: int, k: int)\n ensures (n * d) * k == n * (d * k)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_15950","instance":15950,"id":185949,"goal":"lemma Distrib_15950(n: nat, k: nat, y: nat)\n ensures n * (k + y) == n * k + n * y\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_15951","instance":15951,"id":185950,"goal":"lemma AddZero_15951(k: real)\n ensures k + 0 == k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_15952","instance":15952,"id":185951,"goal":"lemma MulOne_15952(n: int)\n ensures n * 1 == n\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_15953","instance":15953,"id":185952,"goal":"lemma MulZero_15953(d: nat)\n ensures d * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_15954","instance":15954,"id":185953,"goal":"lemma LeRefl_15954(m: real)\n ensures m <= m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_15955","instance":15955,"id":185954,"goal":"lemma LeTrans_15955(m: int, d: int, x: int)\n requires m <= d && d <= x\n ensures m <= x\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_15956","instance":15956,"id":185955,"goal":"lemma AddMono_15956(j: nat, y: nat, b: nat)\n requires j <= y\n ensures j + b <= y + b\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_15957","instance":15957,"id":185956,"goal":"lemma Abs_Nonneg_15957(j: real)\n ensures (if j >= 0 then j else -j) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_15958","instance":15958,"id":185957,"goal":"lemma DivMod_15958(k: int, z: int)\n requires z > 0\n ensures k == z * (k / z) + (k % z)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_15959","instance":15959,"id":185958,"goal":"lemma ModBounds_15959(k: nat, z: nat)\n requires z > 0\n ensures 0 <= k % z < z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_15960","instance":15960,"id":185959,"goal":"lemma Square_Nonneg_15960(k: real)\n ensures k * k >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_15961","instance":15961,"id":185960,"goal":"lemma AddComm_15961(m: int, z: int)\n ensures m + z == z + m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_15962","instance":15962,"id":185961,"goal":"lemma AddAssoc_15962(j: nat, x: nat, y: nat)\n ensures (j + x) + y == j + (x + y)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_15963","instance":15963,"id":185962,"goal":"lemma MulComm_15963(c: real, i: real)\n ensures c * i == i * c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_15964","instance":15964,"id":185963,"goal":"lemma MulAssoc_15964(i: int, k: int, d: int)\n ensures (i * k) * d == i * (k * d)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_15965","instance":15965,"id":185964,"goal":"lemma Distrib_15965(a: nat, j: nat, m: nat)\n ensures a * (j + m) == a * j + a * m\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_15966","instance":15966,"id":185965,"goal":"lemma AddZero_15966(y: real)\n ensures y + 0 == y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_15967","instance":15967,"id":185966,"goal":"lemma MulOne_15967(z: int)\n ensures z * 1 == z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_15968","instance":15968,"id":185967,"goal":"lemma MulZero_15968(n: nat)\n ensures n * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_15969","instance":15969,"id":185968,"goal":"lemma LeRefl_15969(d: real)\n ensures d <= d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_15970","instance":15970,"id":185969,"goal":"lemma LeTrans_15970(k: int, m: int, z: int)\n requires k <= m && m <= z\n ensures k <= z\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_15971","instance":15971,"id":185970,"goal":"lemma AddMono_15971(i: nat, m: nat, k: nat)\n requires i <= m\n ensures i + k <= m + k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_15972","instance":15972,"id":185971,"goal":"lemma Abs_Nonneg_15972(j: real)\n ensures (if j >= 0 then j else -j) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_15973","instance":15973,"id":185972,"goal":"lemma DivMod_15973(y: int, d: int)\n requires d > 0\n ensures y == d * (y / d) + (y % d)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_15974","instance":15974,"id":185973,"goal":"lemma ModBounds_15974(z: nat, a: nat)\n requires a > 0\n ensures 0 <= z % a < a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_15975","instance":15975,"id":185974,"goal":"lemma Square_Nonneg_15975(j: real)\n ensures j * j >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_15976","instance":15976,"id":185975,"goal":"lemma AddComm_15976(d: int, k: int)\n ensures d + k == k + d\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_15977","instance":15977,"id":185976,"goal":"lemma AddAssoc_15977(n: nat, k: nat, j: nat)\n ensures (n + k) + j == n + (k + j)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_15978","instance":15978,"id":185977,"goal":"lemma MulComm_15978(j: real, y: real)\n ensures j * y == y * j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_15979","instance":15979,"id":185978,"goal":"lemma MulAssoc_15979(i: int, n: int, d: int)\n ensures (i * n) * d == i * (n * d)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_15980","instance":15980,"id":185979,"goal":"lemma Distrib_15980(z: nat, i: nat, c: nat)\n ensures z * (i + c) == z * i + z * c\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_15981","instance":15981,"id":185980,"goal":"lemma AddZero_15981(a: real)\n ensures a + 0 == a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_15982","instance":15982,"id":185981,"goal":"lemma MulOne_15982(m: int)\n ensures m * 1 == m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_15983","instance":15983,"id":185982,"goal":"lemma MulZero_15983(m: nat)\n ensures m * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_15984","instance":15984,"id":185983,"goal":"lemma LeRefl_15984(d: real)\n ensures d <= d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_15985","instance":15985,"id":185984,"goal":"lemma LeTrans_15985(d: int, i: int, n: int)\n requires d <= i && i <= n\n ensures d <= n\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_15986","instance":15986,"id":185985,"goal":"lemma AddMono_15986(k: nat, c: nat, b: nat)\n requires k <= c\n ensures k + b <= c + b\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_15987","instance":15987,"id":185986,"goal":"lemma Abs_Nonneg_15987(i: real)\n ensures (if i >= 0 then i else -i) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_15988","instance":15988,"id":185987,"goal":"lemma DivMod_15988(z: int, k: int)\n requires k > 0\n ensures z == k * (z / k) + (z % k)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_15989","instance":15989,"id":185988,"goal":"lemma ModBounds_15989(d: nat, j: nat)\n requires j > 0\n ensures 0 <= d % j < j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_15990","instance":15990,"id":185989,"goal":"lemma Square_Nonneg_15990(j: real)\n ensures j * j >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_15991","instance":15991,"id":185990,"goal":"lemma AddComm_15991(x: int, c: int)\n ensures x + c == c + x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_15992","instance":15992,"id":185991,"goal":"lemma AddAssoc_15992(m: nat, k: nat, n: nat)\n ensures (m + k) + n == m + (k + n)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_15993","instance":15993,"id":185992,"goal":"lemma MulComm_15993(m: real, k: real)\n ensures m * k == k * m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_15994","instance":15994,"id":185993,"goal":"lemma MulAssoc_15994(n: int, b: int, z: int)\n ensures (n * b) * z == n * (b * z)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_15995","instance":15995,"id":185994,"goal":"lemma Distrib_15995(b: nat, x: nat, a: nat)\n ensures b * (x + a) == b * x + b * a\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_15996","instance":15996,"id":185995,"goal":"lemma AddZero_15996(d: real)\n ensures d + 0 == d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_15997","instance":15997,"id":185996,"goal":"lemma MulOne_15997(x: int)\n ensures x * 1 == x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_15998","instance":15998,"id":185997,"goal":"lemma MulZero_15998(j: nat)\n ensures j * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_15999","instance":15999,"id":185998,"goal":"lemma LeRefl_15999(k: real)\n ensures k <= k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_16000","instance":16000,"id":185999,"goal":"lemma LeTrans_16000(j: int, y: int, c: int)\n requires j <= y && y <= c\n ensures j <= c\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_16001","instance":16001,"id":186000,"goal":"lemma AddMono_16001(i: nat, x: nat, y: nat)\n requires i <= x\n ensures i + y <= x + y\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_16002","instance":16002,"id":186001,"goal":"lemma Abs_Nonneg_16002(a: real)\n ensures (if a >= 0 then a else -a) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_16003","instance":16003,"id":186002,"goal":"lemma DivMod_16003(a: int, n: int)\n requires n > 0\n ensures a == n * (a / n) + (a % n)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_16004","instance":16004,"id":186003,"goal":"lemma ModBounds_16004(b: nat, d: nat)\n requires d > 0\n ensures 0 <= b % d < d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_16005","instance":16005,"id":186004,"goal":"lemma Square_Nonneg_16005(a: real)\n ensures a * a >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_16006","instance":16006,"id":186005,"goal":"lemma AddComm_16006(k: int, y: int)\n ensures k + y == y + k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_16007","instance":16007,"id":186006,"goal":"lemma AddAssoc_16007(y: nat, c: nat, n: nat)\n ensures (y + c) + n == y + (c + n)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_16008","instance":16008,"id":186007,"goal":"lemma MulComm_16008(n: real, i: real)\n ensures n * i == i * n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_16009","instance":16009,"id":186008,"goal":"lemma MulAssoc_16009(k: int, d: int, i: int)\n ensures (k * d) * i == k * (d * i)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_16010","instance":16010,"id":186009,"goal":"lemma Distrib_16010(c: nat, m: nat, d: nat)\n ensures c * (m + d) == c * m + c * d\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_16011","instance":16011,"id":186010,"goal":"lemma AddZero_16011(y: real)\n ensures y + 0 == y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_16012","instance":16012,"id":186011,"goal":"lemma MulOne_16012(k: int)\n ensures k * 1 == k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_16013","instance":16013,"id":186012,"goal":"lemma MulZero_16013(j: nat)\n ensures j * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_16014","instance":16014,"id":186013,"goal":"lemma LeRefl_16014(y: real)\n ensures y <= y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_16015","instance":16015,"id":186014,"goal":"lemma LeTrans_16015(b: int, d: int, z: int)\n requires b <= d && d <= z\n ensures b <= z\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_16016","instance":16016,"id":186015,"goal":"lemma AddMono_16016(x: nat, y: nat, c: nat)\n requires x <= y\n ensures x + c <= y + c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_16017","instance":16017,"id":186016,"goal":"lemma Abs_Nonneg_16017(i: real)\n ensures (if i >= 0 then i else -i) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_16018","instance":16018,"id":186017,"goal":"lemma DivMod_16018(d: int, z: int)\n requires z > 0\n ensures d == z * (d / z) + (d % z)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_16019","instance":16019,"id":186018,"goal":"lemma ModBounds_16019(a: nat, m: nat)\n requires m > 0\n ensures 0 <= a % m < m\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_16020","instance":16020,"id":186019,"goal":"lemma Square_Nonneg_16020(y: real)\n ensures y * y >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_16021","instance":16021,"id":186020,"goal":"lemma AddComm_16021(k: int, a: int)\n ensures k + a == a + k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_16022","instance":16022,"id":186021,"goal":"lemma AddAssoc_16022(k: nat, d: nat, j: nat)\n ensures (k + d) + j == k + (d + j)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_16023","instance":16023,"id":186022,"goal":"lemma MulComm_16023(n: real, d: real)\n ensures n * d == d * n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_16024","instance":16024,"id":186023,"goal":"lemma MulAssoc_16024(y: int, i: int, d: int)\n ensures (y * i) * d == y * (i * d)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_16025","instance":16025,"id":186024,"goal":"lemma Distrib_16025(y: nat, n: nat, i: nat)\n ensures y * (n + i) == y * n + y * i\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_16026","instance":16026,"id":186025,"goal":"lemma AddZero_16026(m: real)\n ensures m + 0 == m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_16027","instance":16027,"id":186026,"goal":"lemma MulOne_16027(y: int)\n ensures y * 1 == y\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_16028","instance":16028,"id":186027,"goal":"lemma MulZero_16028(y: nat)\n ensures y * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_16029","instance":16029,"id":186028,"goal":"lemma LeRefl_16029(y: real)\n ensures y <= y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_16030","instance":16030,"id":186029,"goal":"lemma LeTrans_16030(x: int, c: int, y: int)\n requires x <= c && c <= y\n ensures x <= y\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_16031","instance":16031,"id":186030,"goal":"lemma AddMono_16031(i: nat, x: nat, n: nat)\n requires i <= x\n ensures i + n <= x + n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_16032","instance":16032,"id":186031,"goal":"lemma Abs_Nonneg_16032(x: real)\n ensures (if x >= 0 then x else -x) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_16033","instance":16033,"id":186032,"goal":"lemma DivMod_16033(z: int, n: int)\n requires n > 0\n ensures z == n * (z / n) + (z % n)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_16034","instance":16034,"id":186033,"goal":"lemma ModBounds_16034(n: nat, i: nat)\n requires i > 0\n ensures 0 <= n % i < i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_16035","instance":16035,"id":186034,"goal":"lemma Square_Nonneg_16035(j: real)\n ensures j * j >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_16036","instance":16036,"id":186035,"goal":"lemma AddComm_16036(x: int, c: int)\n ensures x + c == c + x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_16037","instance":16037,"id":186036,"goal":"lemma AddAssoc_16037(b: nat, x: nat, i: nat)\n ensures (b + x) + i == b + (x + i)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_16038","instance":16038,"id":186037,"goal":"lemma MulComm_16038(k: real, j: real)\n ensures k * j == j * k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_16039","instance":16039,"id":186038,"goal":"lemma MulAssoc_16039(n: int, j: int, y: int)\n ensures (n * j) * y == n * (j * y)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_16040","instance":16040,"id":186039,"goal":"lemma Distrib_16040(j: nat, c: nat, b: nat)\n ensures j * (c + b) == j * c + j * b\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_16041","instance":16041,"id":186040,"goal":"lemma AddZero_16041(x: real)\n ensures x + 0 == x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_16042","instance":16042,"id":186041,"goal":"lemma MulOne_16042(j: int)\n ensures j * 1 == j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_16043","instance":16043,"id":186042,"goal":"lemma MulZero_16043(a: nat)\n ensures a * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_16044","instance":16044,"id":186043,"goal":"lemma LeRefl_16044(y: real)\n ensures y <= y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_16045","instance":16045,"id":186044,"goal":"lemma LeTrans_16045(i: int, j: int, d: int)\n requires i <= j && j <= d\n ensures i <= d\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_16046","instance":16046,"id":186045,"goal":"lemma AddMono_16046(d: nat, k: nat, n: nat)\n requires d <= k\n ensures d + n <= k + n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_16047","instance":16047,"id":186046,"goal":"lemma Abs_Nonneg_16047(y: real)\n ensures (if y >= 0 then y else -y) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_16048","instance":16048,"id":186047,"goal":"lemma DivMod_16048(b: int, d: int)\n requires d > 0\n ensures b == d * (b / d) + (b % d)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_16049","instance":16049,"id":186048,"goal":"lemma ModBounds_16049(y: nat, z: nat)\n requires z > 0\n ensures 0 <= y % z < z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_16050","instance":16050,"id":186049,"goal":"lemma Square_Nonneg_16050(y: real)\n ensures y * y >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_16051","instance":16051,"id":186050,"goal":"lemma AddComm_16051(m: int, b: int)\n ensures m + b == b + m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_16052","instance":16052,"id":186051,"goal":"lemma AddAssoc_16052(k: nat, n: nat, m: nat)\n ensures (k + n) + m == k + (n + m)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_16053","instance":16053,"id":186052,"goal":"lemma MulComm_16053(z: real, d: real)\n ensures z * d == d * z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_16054","instance":16054,"id":186053,"goal":"lemma MulAssoc_16054(n: int, a: int, z: int)\n ensures (n * a) * z == n * (a * z)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_16055","instance":16055,"id":186054,"goal":"lemma Distrib_16055(a: nat, i: nat, z: nat)\n ensures a * (i + z) == a * i + a * z\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_16056","instance":16056,"id":186055,"goal":"lemma AddZero_16056(n: real)\n ensures n + 0 == n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_16057","instance":16057,"id":186056,"goal":"lemma MulOne_16057(m: int)\n ensures m * 1 == m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_16058","instance":16058,"id":186057,"goal":"lemma MulZero_16058(m: nat)\n ensures m * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_16059","instance":16059,"id":186058,"goal":"lemma LeRefl_16059(a: real)\n ensures a <= a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_16060","instance":16060,"id":186059,"goal":"lemma LeTrans_16060(b: int, x: int, i: int)\n requires b <= x && x <= i\n ensures b <= i\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_16061","instance":16061,"id":186060,"goal":"lemma AddMono_16061(j: nat, d: nat, b: nat)\n requires j <= d\n ensures j + b <= d + b\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_16062","instance":16062,"id":186061,"goal":"lemma Abs_Nonneg_16062(z: real)\n ensures (if z >= 0 then z else -z) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_16063","instance":16063,"id":186062,"goal":"lemma DivMod_16063(y: int, n: int)\n requires n > 0\n ensures y == n * (y / n) + (y % n)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_16064","instance":16064,"id":186063,"goal":"lemma ModBounds_16064(k: nat, m: nat)\n requires m > 0\n ensures 0 <= k % m < m\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_16065","instance":16065,"id":186064,"goal":"lemma Square_Nonneg_16065(a: real)\n ensures a * a >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_16066","instance":16066,"id":186065,"goal":"lemma AddComm_16066(i: int, m: int)\n ensures i + m == m + i\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_16067","instance":16067,"id":186066,"goal":"lemma AddAssoc_16067(d: nat, b: nat, i: nat)\n ensures (d + b) + i == d + (b + i)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_16068","instance":16068,"id":186067,"goal":"lemma MulComm_16068(x: real, a: real)\n ensures x * a == a * x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_16069","instance":16069,"id":186068,"goal":"lemma MulAssoc_16069(a: int, i: int, k: int)\n ensures (a * i) * k == a * (i * k)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_16070","instance":16070,"id":186069,"goal":"lemma Distrib_16070(b: nat, d: nat, j: nat)\n ensures b * (d + j) == b * d + b * j\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_16071","instance":16071,"id":186070,"goal":"lemma AddZero_16071(z: real)\n ensures z + 0 == z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_16072","instance":16072,"id":186071,"goal":"lemma MulOne_16072(d: int)\n ensures d * 1 == d\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_16073","instance":16073,"id":186072,"goal":"lemma MulZero_16073(c: nat)\n ensures c * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_16074","instance":16074,"id":186073,"goal":"lemma LeRefl_16074(d: real)\n ensures d <= d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_16075","instance":16075,"id":186074,"goal":"lemma LeTrans_16075(m: int, k: int, n: int)\n requires m <= k && k <= n\n ensures m <= n\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_16076","instance":16076,"id":186075,"goal":"lemma AddMono_16076(z: nat, x: nat, n: nat)\n requires z <= x\n ensures z + n <= x + n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_16077","instance":16077,"id":186076,"goal":"lemma Abs_Nonneg_16077(x: real)\n ensures (if x >= 0 then x else -x) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_16078","instance":16078,"id":186077,"goal":"lemma DivMod_16078(z: int, d: int)\n requires d > 0\n ensures z == d * (z / d) + (z % d)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_16079","instance":16079,"id":186078,"goal":"lemma ModBounds_16079(d: nat, n: nat)\n requires n > 0\n ensures 0 <= d % n < n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_16080","instance":16080,"id":186079,"goal":"lemma Square_Nonneg_16080(c: real)\n ensures c * c >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_16081","instance":16081,"id":186080,"goal":"lemma AddComm_16081(k: int, y: int)\n ensures k + y == y + k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_16082","instance":16082,"id":186081,"goal":"lemma AddAssoc_16082(b: nat, n: nat, c: nat)\n ensures (b + n) + c == b + (n + c)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_16083","instance":16083,"id":186082,"goal":"lemma MulComm_16083(k: real, x: real)\n ensures k * x == x * k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_16084","instance":16084,"id":186083,"goal":"lemma MulAssoc_16084(d: int, n: int, x: int)\n ensures (d * n) * x == d * (n * x)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_16085","instance":16085,"id":186084,"goal":"lemma Distrib_16085(c: nat, i: nat, j: nat)\n ensures c * (i + j) == c * i + c * j\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_16086","instance":16086,"id":186085,"goal":"lemma AddZero_16086(y: real)\n ensures y + 0 == y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_16087","instance":16087,"id":186086,"goal":"lemma MulOne_16087(b: int)\n ensures b * 1 == b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_16088","instance":16088,"id":186087,"goal":"lemma MulZero_16088(b: nat)\n ensures b * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_16089","instance":16089,"id":186088,"goal":"lemma LeRefl_16089(y: real)\n ensures y <= y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_16090","instance":16090,"id":186089,"goal":"lemma LeTrans_16090(z: int, y: int, n: int)\n requires z <= y && y <= n\n ensures z <= n\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_16091","instance":16091,"id":186090,"goal":"lemma AddMono_16091(i: nat, z: nat, c: nat)\n requires i <= z\n ensures i + c <= z + c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_16092","instance":16092,"id":186091,"goal":"lemma Abs_Nonneg_16092(d: real)\n ensures (if d >= 0 then d else -d) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_16093","instance":16093,"id":186092,"goal":"lemma DivMod_16093(b: int, c: int)\n requires c > 0\n ensures b == c * (b / c) + (b % c)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_16094","instance":16094,"id":186093,"goal":"lemma ModBounds_16094(m: nat, i: nat)\n requires i > 0\n ensures 0 <= m % i < i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_16095","instance":16095,"id":186094,"goal":"lemma Square_Nonneg_16095(n: real)\n ensures n * n >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_16096","instance":16096,"id":186095,"goal":"lemma AddComm_16096(d: int, n: int)\n ensures d + n == n + d\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_16097","instance":16097,"id":186096,"goal":"lemma AddAssoc_16097(c: nat, j: nat, d: nat)\n ensures (c + j) + d == c + (j + d)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_16098","instance":16098,"id":186097,"goal":"lemma MulComm_16098(m: real, j: real)\n ensures m * j == j * m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_16099","instance":16099,"id":186098,"goal":"lemma MulAssoc_16099(z: int, d: int, m: int)\n ensures (z * d) * m == z * (d * m)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_16100","instance":16100,"id":186099,"goal":"lemma Distrib_16100(x: nat, k: nat, n: nat)\n ensures x * (k + n) == x * k + x * n\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_16101","instance":16101,"id":186100,"goal":"lemma AddZero_16101(a: real)\n ensures a + 0 == a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_16102","instance":16102,"id":186101,"goal":"lemma MulOne_16102(k: int)\n ensures k * 1 == k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_16103","instance":16103,"id":186102,"goal":"lemma MulZero_16103(x: nat)\n ensures x * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_16104","instance":16104,"id":186103,"goal":"lemma LeRefl_16104(k: real)\n ensures k <= k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_16105","instance":16105,"id":186104,"goal":"lemma LeTrans_16105(a: int, m: int, j: int)\n requires a <= m && m <= j\n ensures a <= j\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_16106","instance":16106,"id":186105,"goal":"lemma AddMono_16106(y: nat, i: nat, c: nat)\n requires y <= i\n ensures y + c <= i + c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_16107","instance":16107,"id":186106,"goal":"lemma Abs_Nonneg_16107(k: real)\n ensures (if k >= 0 then k else -k) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_16108","instance":16108,"id":186107,"goal":"lemma DivMod_16108(b: int, a: int)\n requires a > 0\n ensures b == a * (b / a) + (b % a)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_16109","instance":16109,"id":186108,"goal":"lemma ModBounds_16109(d: nat, i: nat)\n requires i > 0\n ensures 0 <= d % i < i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_16110","instance":16110,"id":186109,"goal":"lemma Square_Nonneg_16110(k: real)\n ensures k * k >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_16111","instance":16111,"id":186110,"goal":"lemma AddComm_16111(z: int, x: int)\n ensures z + x == x + z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_16112","instance":16112,"id":186111,"goal":"lemma AddAssoc_16112(i: nat, d: nat, k: nat)\n ensures (i + d) + k == i + (d + k)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_16113","instance":16113,"id":186112,"goal":"lemma MulComm_16113(z: real, i: real)\n ensures z * i == i * z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_16114","instance":16114,"id":186113,"goal":"lemma MulAssoc_16114(c: int, n: int, m: int)\n ensures (c * n) * m == c * (n * m)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_16115","instance":16115,"id":186114,"goal":"lemma Distrib_16115(i: nat, d: nat, j: nat)\n ensures i * (d + j) == i * d + i * j\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_16116","instance":16116,"id":186115,"goal":"lemma AddZero_16116(y: real)\n ensures y + 0 == y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_16117","instance":16117,"id":186116,"goal":"lemma MulOne_16117(z: int)\n ensures z * 1 == z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_16118","instance":16118,"id":186117,"goal":"lemma MulZero_16118(x: nat)\n ensures x * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_16119","instance":16119,"id":186118,"goal":"lemma LeRefl_16119(z: real)\n ensures z <= z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_16120","instance":16120,"id":186119,"goal":"lemma LeTrans_16120(c: int, z: int, d: int)\n requires c <= z && z <= d\n ensures c <= d\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_16121","instance":16121,"id":186120,"goal":"lemma AddMono_16121(y: nat, c: nat, i: nat)\n requires y <= c\n ensures y + i <= c + i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_16122","instance":16122,"id":186121,"goal":"lemma Abs_Nonneg_16122(i: real)\n ensures (if i >= 0 then i else -i) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_16123","instance":16123,"id":186122,"goal":"lemma DivMod_16123(b: int, d: int)\n requires d > 0\n ensures b == d * (b / d) + (b % d)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_16124","instance":16124,"id":186123,"goal":"lemma ModBounds_16124(n: nat, x: nat)\n requires x > 0\n ensures 0 <= n % x < x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_16125","instance":16125,"id":186124,"goal":"lemma Square_Nonneg_16125(d: real)\n ensures d * d >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_16126","instance":16126,"id":186125,"goal":"lemma AddComm_16126(n: int, z: int)\n ensures n + z == z + n\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_16127","instance":16127,"id":186126,"goal":"lemma AddAssoc_16127(z: nat, b: nat, k: nat)\n ensures (z + b) + k == z + (b + k)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_16128","instance":16128,"id":186127,"goal":"lemma MulComm_16128(y: real, i: real)\n ensures y * i == i * y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_16129","instance":16129,"id":186128,"goal":"lemma MulAssoc_16129(c: int, m: int, n: int)\n ensures (c * m) * n == c * (m * n)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_16130","instance":16130,"id":186129,"goal":"lemma Distrib_16130(n: nat, d: nat, x: nat)\n ensures n * (d + x) == n * d + n * x\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_16131","instance":16131,"id":186130,"goal":"lemma AddZero_16131(k: real)\n ensures k + 0 == k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_16132","instance":16132,"id":186131,"goal":"lemma MulOne_16132(n: int)\n ensures n * 1 == n\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_16133","instance":16133,"id":186132,"goal":"lemma MulZero_16133(x: nat)\n ensures x * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_16134","instance":16134,"id":186133,"goal":"lemma LeRefl_16134(j: real)\n ensures j <= j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_16135","instance":16135,"id":186134,"goal":"lemma LeTrans_16135(d: int, x: int, k: int)\n requires d <= x && x <= k\n ensures d <= k\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_16136","instance":16136,"id":186135,"goal":"lemma AddMono_16136(a: nat, m: nat, z: nat)\n requires a <= m\n ensures a + z <= m + z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_16137","instance":16137,"id":186136,"goal":"lemma Abs_Nonneg_16137(d: real)\n ensures (if d >= 0 then d else -d) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_16138","instance":16138,"id":186137,"goal":"lemma DivMod_16138(k: int, z: int)\n requires z > 0\n ensures k == z * (k / z) + (k % z)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_16139","instance":16139,"id":186138,"goal":"lemma ModBounds_16139(b: nat, c: nat)\n requires c > 0\n ensures 0 <= b % c < c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_16140","instance":16140,"id":186139,"goal":"lemma Square_Nonneg_16140(m: real)\n ensures m * m >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_16141","instance":16141,"id":186140,"goal":"lemma AddComm_16141(d: int, x: int)\n ensures d + x == x + d\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_16142","instance":16142,"id":186141,"goal":"lemma AddAssoc_16142(d: nat, j: nat, x: nat)\n ensures (d + j) + x == d + (j + x)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_16143","instance":16143,"id":186142,"goal":"lemma MulComm_16143(z: real, c: real)\n ensures z * c == c * z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_16144","instance":16144,"id":186143,"goal":"lemma MulAssoc_16144(n: int, m: int, d: int)\n ensures (n * m) * d == n * (m * d)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_16145","instance":16145,"id":186144,"goal":"lemma Distrib_16145(k: nat, n: nat, i: nat)\n ensures k * (n + i) == k * n + k * i\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_16146","instance":16146,"id":186145,"goal":"lemma AddZero_16146(x: real)\n ensures x + 0 == x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_16147","instance":16147,"id":186146,"goal":"lemma MulOne_16147(y: int)\n ensures y * 1 == y\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_16148","instance":16148,"id":186147,"goal":"lemma MulZero_16148(z: nat)\n ensures z * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_16149","instance":16149,"id":186148,"goal":"lemma LeRefl_16149(x: real)\n ensures x <= x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_16150","instance":16150,"id":186149,"goal":"lemma LeTrans_16150(m: int, d: int, y: int)\n requires m <= d && d <= y\n ensures m <= y\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_16151","instance":16151,"id":186150,"goal":"lemma AddMono_16151(z: nat, k: nat, c: nat)\n requires z <= k\n ensures z + c <= k + c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_16152","instance":16152,"id":186151,"goal":"lemma Abs_Nonneg_16152(k: real)\n ensures (if k >= 0 then k else -k) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_16153","instance":16153,"id":186152,"goal":"lemma DivMod_16153(b: int, m: int)\n requires m > 0\n ensures b == m * (b / m) + (b % m)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_16154","instance":16154,"id":186153,"goal":"lemma ModBounds_16154(n: nat, z: nat)\n requires z > 0\n ensures 0 <= n % z < z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_16155","instance":16155,"id":186154,"goal":"lemma Square_Nonneg_16155(y: real)\n ensures y * y >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_16156","instance":16156,"id":186155,"goal":"lemma AddComm_16156(i: int, n: int)\n ensures i + n == n + i\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_16157","instance":16157,"id":186156,"goal":"lemma AddAssoc_16157(y: nat, b: nat, n: nat)\n ensures (y + b) + n == y + (b + n)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_16158","instance":16158,"id":186157,"goal":"lemma MulComm_16158(d: real, j: real)\n ensures d * j == j * d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_16159","instance":16159,"id":186158,"goal":"lemma MulAssoc_16159(k: int, a: int, x: int)\n ensures (k * a) * x == k * (a * x)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_16160","instance":16160,"id":186159,"goal":"lemma Distrib_16160(a: nat, k: nat, n: nat)\n ensures a * (k + n) == a * k + a * n\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_16161","instance":16161,"id":186160,"goal":"lemma AddZero_16161(b: real)\n ensures b + 0 == b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_16162","instance":16162,"id":186161,"goal":"lemma MulOne_16162(a: int)\n ensures a * 1 == a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_16163","instance":16163,"id":186162,"goal":"lemma MulZero_16163(x: nat)\n ensures x * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_16164","instance":16164,"id":186163,"goal":"lemma LeRefl_16164(a: real)\n ensures a <= a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_16165","instance":16165,"id":186164,"goal":"lemma LeTrans_16165(z: int, b: int, a: int)\n requires z <= b && b <= a\n ensures z <= a\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_16166","instance":16166,"id":186165,"goal":"lemma AddMono_16166(z: nat, a: nat, i: nat)\n requires z <= a\n ensures z + i <= a + i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_16167","instance":16167,"id":186166,"goal":"lemma Abs_Nonneg_16167(c: real)\n ensures (if c >= 0 then c else -c) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_16168","instance":16168,"id":186167,"goal":"lemma DivMod_16168(c: int, b: int)\n requires b > 0\n ensures c == b * (c / b) + (c % b)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_16169","instance":16169,"id":186168,"goal":"lemma ModBounds_16169(y: nat, k: nat)\n requires k > 0\n ensures 0 <= y % k < k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_16170","instance":16170,"id":186169,"goal":"lemma Square_Nonneg_16170(m: real)\n ensures m * m >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_16171","instance":16171,"id":186170,"goal":"lemma AddComm_16171(y: int, k: int)\n ensures y + k == k + y\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_16172","instance":16172,"id":186171,"goal":"lemma AddAssoc_16172(n: nat, m: nat, d: nat)\n ensures (n + m) + d == n + (m + d)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_16173","instance":16173,"id":186172,"goal":"lemma MulComm_16173(x: real, c: real)\n ensures x * c == c * x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_16174","instance":16174,"id":186173,"goal":"lemma MulAssoc_16174(n: int, x: int, y: int)\n ensures (n * x) * y == n * (x * y)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_16175","instance":16175,"id":186174,"goal":"lemma Distrib_16175(x: nat, k: nat, n: nat)\n ensures x * (k + n) == x * k + x * n\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_16176","instance":16176,"id":186175,"goal":"lemma AddZero_16176(j: real)\n ensures j + 0 == j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_16177","instance":16177,"id":186176,"goal":"lemma MulOne_16177(k: int)\n ensures k * 1 == k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_16178","instance":16178,"id":186177,"goal":"lemma MulZero_16178(i: nat)\n ensures i * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_16179","instance":16179,"id":186178,"goal":"lemma LeRefl_16179(d: real)\n ensures d <= d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_16180","instance":16180,"id":186179,"goal":"lemma LeTrans_16180(z: int, x: int, i: int)\n requires z <= x && x <= i\n ensures z <= i\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_16181","instance":16181,"id":186180,"goal":"lemma AddMono_16181(z: nat, d: nat, j: nat)\n requires z <= d\n ensures z + j <= d + j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_16182","instance":16182,"id":186181,"goal":"lemma Abs_Nonneg_16182(x: real)\n ensures (if x >= 0 then x else -x) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_16183","instance":16183,"id":186182,"goal":"lemma DivMod_16183(k: int, z: int)\n requires z > 0\n ensures k == z * (k / z) + (k % z)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_16184","instance":16184,"id":186183,"goal":"lemma ModBounds_16184(n: nat, m: nat)\n requires m > 0\n ensures 0 <= n % m < m\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_16185","instance":16185,"id":186184,"goal":"lemma Square_Nonneg_16185(y: real)\n ensures y * y >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_16186","instance":16186,"id":186185,"goal":"lemma AddComm_16186(y: int, d: int)\n ensures y + d == d + y\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_16187","instance":16187,"id":186186,"goal":"lemma AddAssoc_16187(j: nat, a: nat, i: nat)\n ensures (j + a) + i == j + (a + i)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_16188","instance":16188,"id":186187,"goal":"lemma MulComm_16188(z: real, x: real)\n ensures z * x == x * z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_16189","instance":16189,"id":186188,"goal":"lemma MulAssoc_16189(i: int, j: int, x: int)\n ensures (i * j) * x == i * (j * x)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_16190","instance":16190,"id":186189,"goal":"lemma Distrib_16190(y: nat, n: nat, d: nat)\n ensures y * (n + d) == y * n + y * d\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_16191","instance":16191,"id":186190,"goal":"lemma AddZero_16191(x: real)\n ensures x + 0 == x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_16192","instance":16192,"id":186191,"goal":"lemma MulOne_16192(k: int)\n ensures k * 1 == k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_16193","instance":16193,"id":186192,"goal":"lemma MulZero_16193(n: nat)\n ensures n * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_16194","instance":16194,"id":186193,"goal":"lemma LeRefl_16194(j: real)\n ensures j <= j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_16195","instance":16195,"id":186194,"goal":"lemma LeTrans_16195(x: int, b: int, n: int)\n requires x <= b && b <= n\n ensures x <= n\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_16196","instance":16196,"id":186195,"goal":"lemma AddMono_16196(d: nat, b: nat, i: nat)\n requires d <= b\n ensures d + i <= b + i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_16197","instance":16197,"id":186196,"goal":"lemma Abs_Nonneg_16197(m: real)\n ensures (if m >= 0 then m else -m) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_16198","instance":16198,"id":186197,"goal":"lemma DivMod_16198(i: int, b: int)\n requires b > 0\n ensures i == b * (i / b) + (i % b)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_16199","instance":16199,"id":186198,"goal":"lemma ModBounds_16199(b: nat, m: nat)\n requires m > 0\n ensures 0 <= b % m < m\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_16200","instance":16200,"id":186199,"goal":"lemma Square_Nonneg_16200(a: real)\n ensures a * a >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_16201","instance":16201,"id":186200,"goal":"lemma AddComm_16201(y: int, a: int)\n ensures y + a == a + y\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_16202","instance":16202,"id":186201,"goal":"lemma AddAssoc_16202(k: nat, i: nat, y: nat)\n ensures (k + i) + y == k + (i + y)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_16203","instance":16203,"id":186202,"goal":"lemma MulComm_16203(a: real, j: real)\n ensures a * j == j * a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_16204","instance":16204,"id":186203,"goal":"lemma MulAssoc_16204(i: int, d: int, j: int)\n ensures (i * d) * j == i * (d * j)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_16205","instance":16205,"id":186204,"goal":"lemma Distrib_16205(n: nat, b: nat, y: nat)\n ensures n * (b + y) == n * b + n * y\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_16206","instance":16206,"id":186205,"goal":"lemma AddZero_16206(z: real)\n ensures z + 0 == z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_16207","instance":16207,"id":186206,"goal":"lemma MulOne_16207(y: int)\n ensures y * 1 == y\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_16208","instance":16208,"id":186207,"goal":"lemma MulZero_16208(a: nat)\n ensures a * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_16209","instance":16209,"id":186208,"goal":"lemma LeRefl_16209(j: real)\n ensures j <= j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_16210","instance":16210,"id":186209,"goal":"lemma LeTrans_16210(b: int, k: int, y: int)\n requires b <= k && k <= y\n ensures b <= y\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_16211","instance":16211,"id":186210,"goal":"lemma AddMono_16211(n: nat, c: nat, m: nat)\n requires n <= c\n ensures n + m <= c + m\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_16212","instance":16212,"id":186211,"goal":"lemma Abs_Nonneg_16212(a: real)\n ensures (if a >= 0 then a else -a) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_16213","instance":16213,"id":186212,"goal":"lemma DivMod_16213(a: int, c: int)\n requires c > 0\n ensures a == c * (a / c) + (a % c)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_16214","instance":16214,"id":186213,"goal":"lemma ModBounds_16214(m: nat, c: nat)\n requires c > 0\n ensures 0 <= m % c < c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_16215","instance":16215,"id":186214,"goal":"lemma Square_Nonneg_16215(d: real)\n ensures d * d >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_16216","instance":16216,"id":186215,"goal":"lemma AddComm_16216(b: int, d: int)\n ensures b + d == d + b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_16217","instance":16217,"id":186216,"goal":"lemma AddAssoc_16217(b: nat, m: nat, i: nat)\n ensures (b + m) + i == b + (m + i)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_16218","instance":16218,"id":186217,"goal":"lemma MulComm_16218(z: real, d: real)\n ensures z * d == d * z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_16219","instance":16219,"id":186218,"goal":"lemma MulAssoc_16219(a: int, c: int, j: int)\n ensures (a * c) * j == a * (c * j)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_16220","instance":16220,"id":186219,"goal":"lemma Distrib_16220(y: nat, z: nat, b: nat)\n ensures y * (z + b) == y * z + y * b\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_16221","instance":16221,"id":186220,"goal":"lemma AddZero_16221(n: real)\n ensures n + 0 == n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_16222","instance":16222,"id":186221,"goal":"lemma MulOne_16222(i: int)\n ensures i * 1 == i\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_16223","instance":16223,"id":186222,"goal":"lemma MulZero_16223(n: nat)\n ensures n * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_16224","instance":16224,"id":186223,"goal":"lemma LeRefl_16224(x: real)\n ensures x <= x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_16225","instance":16225,"id":186224,"goal":"lemma LeTrans_16225(j: int, b: int, d: int)\n requires j <= b && b <= d\n ensures j <= d\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_16226","instance":16226,"id":186225,"goal":"lemma AddMono_16226(j: nat, c: nat, k: nat)\n requires j <= c\n ensures j + k <= c + k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_16227","instance":16227,"id":186226,"goal":"lemma Abs_Nonneg_16227(b: real)\n ensures (if b >= 0 then b else -b) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_16228","instance":16228,"id":186227,"goal":"lemma DivMod_16228(m: int, n: int)\n requires n > 0\n ensures m == n * (m / n) + (m % n)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_16229","instance":16229,"id":186228,"goal":"lemma ModBounds_16229(a: nat, i: nat)\n requires i > 0\n ensures 0 <= a % i < i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_16230","instance":16230,"id":186229,"goal":"lemma Square_Nonneg_16230(n: real)\n ensures n * n >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_16231","instance":16231,"id":186230,"goal":"lemma AddComm_16231(k: int, b: int)\n ensures k + b == b + k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_16232","instance":16232,"id":186231,"goal":"lemma AddAssoc_16232(x: nat, b: nat, j: nat)\n ensures (x + b) + j == x + (b + j)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_16233","instance":16233,"id":186232,"goal":"lemma MulComm_16233(x: real, z: real)\n ensures x * z == z * x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_16234","instance":16234,"id":186233,"goal":"lemma MulAssoc_16234(k: int, m: int, a: int)\n ensures (k * m) * a == k * (m * a)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_16235","instance":16235,"id":186234,"goal":"lemma Distrib_16235(c: nat, j: nat, z: nat)\n ensures c * (j + z) == c * j + c * z\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_16236","instance":16236,"id":186235,"goal":"lemma AddZero_16236(d: real)\n ensures d + 0 == d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_16237","instance":16237,"id":186236,"goal":"lemma MulOne_16237(d: int)\n ensures d * 1 == d\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_16238","instance":16238,"id":186237,"goal":"lemma MulZero_16238(z: nat)\n ensures z * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_16239","instance":16239,"id":186238,"goal":"lemma LeRefl_16239(b: real)\n ensures b <= b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_16240","instance":16240,"id":186239,"goal":"lemma LeTrans_16240(i: int, j: int, k: int)\n requires i <= j && j <= k\n ensures i <= k\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_16241","instance":16241,"id":186240,"goal":"lemma AddMono_16241(a: nat, d: nat, m: nat)\n requires a <= d\n ensures a + m <= d + m\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_16242","instance":16242,"id":186241,"goal":"lemma Abs_Nonneg_16242(x: real)\n ensures (if x >= 0 then x else -x) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_16243","instance":16243,"id":186242,"goal":"lemma DivMod_16243(d: int, y: int)\n requires y > 0\n ensures d == y * (d / y) + (d % y)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_16244","instance":16244,"id":186243,"goal":"lemma ModBounds_16244(d: nat, z: nat)\n requires z > 0\n ensures 0 <= d % z < z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_16245","instance":16245,"id":186244,"goal":"lemma Square_Nonneg_16245(b: real)\n ensures b * b >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_16246","instance":16246,"id":186245,"goal":"lemma AddComm_16246(j: int, a: int)\n ensures j + a == a + j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_16247","instance":16247,"id":186246,"goal":"lemma AddAssoc_16247(x: nat, j: nat, n: nat)\n ensures (x + j) + n == x + (j + n)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_16248","instance":16248,"id":186247,"goal":"lemma MulComm_16248(z: real, b: real)\n ensures z * b == b * z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_16249","instance":16249,"id":186248,"goal":"lemma MulAssoc_16249(z: int, d: int, j: int)\n ensures (z * d) * j == z * (d * j)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_16250","instance":16250,"id":186249,"goal":"lemma Distrib_16250(n: nat, z: nat, x: nat)\n ensures n * (z + x) == n * z + n * x\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_16251","instance":16251,"id":186250,"goal":"lemma AddZero_16251(d: real)\n ensures d + 0 == d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_16252","instance":16252,"id":186251,"goal":"lemma MulOne_16252(z: int)\n ensures z * 1 == z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_16253","instance":16253,"id":186252,"goal":"lemma MulZero_16253(z: nat)\n ensures z * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_16254","instance":16254,"id":186253,"goal":"lemma LeRefl_16254(i: real)\n ensures i <= i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_16255","instance":16255,"id":186254,"goal":"lemma LeTrans_16255(y: int, a: int, k: int)\n requires y <= a && a <= k\n ensures y <= k\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_16256","instance":16256,"id":186255,"goal":"lemma AddMono_16256(i: nat, k: nat, x: nat)\n requires i <= k\n ensures i + x <= k + x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_16257","instance":16257,"id":186256,"goal":"lemma Abs_Nonneg_16257(i: real)\n ensures (if i >= 0 then i else -i) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_16258","instance":16258,"id":186257,"goal":"lemma DivMod_16258(n: int, x: int)\n requires x > 0\n ensures n == x * (n / x) + (n % x)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_16259","instance":16259,"id":186258,"goal":"lemma ModBounds_16259(c: nat, d: nat)\n requires d > 0\n ensures 0 <= c % d < d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_16260","instance":16260,"id":186259,"goal":"lemma Square_Nonneg_16260(x: real)\n ensures x * x >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_16261","instance":16261,"id":186260,"goal":"lemma AddComm_16261(d: int, y: int)\n ensures d + y == y + d\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_16262","instance":16262,"id":186261,"goal":"lemma AddAssoc_16262(k: nat, b: nat, m: nat)\n ensures (k + b) + m == k + (b + m)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_16263","instance":16263,"id":186262,"goal":"lemma MulComm_16263(y: real, b: real)\n ensures y * b == b * y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_16264","instance":16264,"id":186263,"goal":"lemma MulAssoc_16264(b: int, y: int, j: int)\n ensures (b * y) * j == b * (y * j)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_16265","instance":16265,"id":186264,"goal":"lemma Distrib_16265(d: nat, k: nat, a: nat)\n ensures d * (k + a) == d * k + d * a\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_16266","instance":16266,"id":186265,"goal":"lemma AddZero_16266(y: real)\n ensures y + 0 == y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_16267","instance":16267,"id":186266,"goal":"lemma MulOne_16267(j: int)\n ensures j * 1 == j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_16268","instance":16268,"id":186267,"goal":"lemma MulZero_16268(a: nat)\n ensures a * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_16269","instance":16269,"id":186268,"goal":"lemma LeRefl_16269(x: real)\n ensures x <= x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_16270","instance":16270,"id":186269,"goal":"lemma LeTrans_16270(c: int, k: int, a: int)\n requires c <= k && k <= a\n ensures c <= a\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_16271","instance":16271,"id":186270,"goal":"lemma AddMono_16271(x: nat, y: nat, z: nat)\n requires x <= y\n ensures x + z <= y + z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_16272","instance":16272,"id":186271,"goal":"lemma Abs_Nonneg_16272(k: real)\n ensures (if k >= 0 then k else -k) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_16273","instance":16273,"id":186272,"goal":"lemma DivMod_16273(y: int, c: int)\n requires c > 0\n ensures y == c * (y / c) + (y % c)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_16274","instance":16274,"id":186273,"goal":"lemma ModBounds_16274(b: nat, d: nat)\n requires d > 0\n ensures 0 <= b % d < d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_16275","instance":16275,"id":186274,"goal":"lemma Square_Nonneg_16275(c: real)\n ensures c * c >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_16276","instance":16276,"id":186275,"goal":"lemma AddComm_16276(k: int, j: int)\n ensures k + j == j + k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_16277","instance":16277,"id":186276,"goal":"lemma AddAssoc_16277(i: nat, m: nat, n: nat)\n ensures (i + m) + n == i + (m + n)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_16278","instance":16278,"id":186277,"goal":"lemma MulComm_16278(x: real, i: real)\n ensures x * i == i * x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_16279","instance":16279,"id":186278,"goal":"lemma MulAssoc_16279(b: int, y: int, m: int)\n ensures (b * y) * m == b * (y * m)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_16280","instance":16280,"id":186279,"goal":"lemma Distrib_16280(n: nat, x: nat, i: nat)\n ensures n * (x + i) == n * x + n * i\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_16281","instance":16281,"id":186280,"goal":"lemma AddZero_16281(m: real)\n ensures m + 0 == m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_16282","instance":16282,"id":186281,"goal":"lemma MulOne_16282(i: int)\n ensures i * 1 == i\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_16283","instance":16283,"id":186282,"goal":"lemma MulZero_16283(j: nat)\n ensures j * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_16284","instance":16284,"id":186283,"goal":"lemma LeRefl_16284(a: real)\n ensures a <= a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_16285","instance":16285,"id":186284,"goal":"lemma LeTrans_16285(a: int, i: int, k: int)\n requires a <= i && i <= k\n ensures a <= k\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_16286","instance":16286,"id":186285,"goal":"lemma AddMono_16286(d: nat, y: nat, j: nat)\n requires d <= y\n ensures d + j <= y + j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_16287","instance":16287,"id":186286,"goal":"lemma Abs_Nonneg_16287(x: real)\n ensures (if x >= 0 then x else -x) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_16288","instance":16288,"id":186287,"goal":"lemma DivMod_16288(i: int, c: int)\n requires c > 0\n ensures i == c * (i / c) + (i % c)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_16289","instance":16289,"id":186288,"goal":"lemma ModBounds_16289(z: nat, c: nat)\n requires c > 0\n ensures 0 <= z % c < c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_16290","instance":16290,"id":186289,"goal":"lemma Square_Nonneg_16290(m: real)\n ensures m * m >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_16291","instance":16291,"id":186290,"goal":"lemma AddComm_16291(k: int, z: int)\n ensures k + z == z + k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_16292","instance":16292,"id":186291,"goal":"lemma AddAssoc_16292(m: nat, b: nat, k: nat)\n ensures (m + b) + k == m + (b + k)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_16293","instance":16293,"id":186292,"goal":"lemma MulComm_16293(z: real, c: real)\n ensures z * c == c * z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_16294","instance":16294,"id":186293,"goal":"lemma MulAssoc_16294(b: int, m: int, i: int)\n ensures (b * m) * i == b * (m * i)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_16295","instance":16295,"id":186294,"goal":"lemma Distrib_16295(m: nat, z: nat, n: nat)\n ensures m * (z + n) == m * z + m * n\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_16296","instance":16296,"id":186295,"goal":"lemma AddZero_16296(j: real)\n ensures j + 0 == j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_16297","instance":16297,"id":186296,"goal":"lemma MulOne_16297(n: int)\n ensures n * 1 == n\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_16298","instance":16298,"id":186297,"goal":"lemma MulZero_16298(x: nat)\n ensures x * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_16299","instance":16299,"id":186298,"goal":"lemma LeRefl_16299(a: real)\n ensures a <= a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_16300","instance":16300,"id":186299,"goal":"lemma LeTrans_16300(n: int, y: int, m: int)\n requires n <= y && y <= m\n ensures n <= m\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_16301","instance":16301,"id":186300,"goal":"lemma AddMono_16301(z: nat, i: nat, x: nat)\n requires z <= i\n ensures z + x <= i + x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_16302","instance":16302,"id":186301,"goal":"lemma Abs_Nonneg_16302(c: real)\n ensures (if c >= 0 then c else -c) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_16303","instance":16303,"id":186302,"goal":"lemma DivMod_16303(b: int, c: int)\n requires c > 0\n ensures b == c * (b / c) + (b % c)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_16304","instance":16304,"id":186303,"goal":"lemma ModBounds_16304(b: nat, z: nat)\n requires z > 0\n ensures 0 <= b % z < z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_16305","instance":16305,"id":186304,"goal":"lemma Square_Nonneg_16305(b: real)\n ensures b * b >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_16306","instance":16306,"id":186305,"goal":"lemma AddComm_16306(n: int, i: int)\n ensures n + i == i + n\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_16307","instance":16307,"id":186306,"goal":"lemma AddAssoc_16307(b: nat, m: nat, n: nat)\n ensures (b + m) + n == b + (m + n)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_16308","instance":16308,"id":186307,"goal":"lemma MulComm_16308(j: real, c: real)\n ensures j * c == c * j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_16309","instance":16309,"id":186308,"goal":"lemma MulAssoc_16309(d: int, a: int, y: int)\n ensures (d * a) * y == d * (a * y)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_16310","instance":16310,"id":186309,"goal":"lemma Distrib_16310(x: nat, n: nat, a: nat)\n ensures x * (n + a) == x * n + x * a\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_16311","instance":16311,"id":186310,"goal":"lemma AddZero_16311(j: real)\n ensures j + 0 == j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_16312","instance":16312,"id":186311,"goal":"lemma MulOne_16312(a: int)\n ensures a * 1 == a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_16313","instance":16313,"id":186312,"goal":"lemma MulZero_16313(a: nat)\n ensures a * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_16314","instance":16314,"id":186313,"goal":"lemma LeRefl_16314(m: real)\n ensures m <= m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_16315","instance":16315,"id":186314,"goal":"lemma LeTrans_16315(k: int, j: int, x: int)\n requires k <= j && j <= x\n ensures k <= x\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_16316","instance":16316,"id":186315,"goal":"lemma AddMono_16316(z: nat, k: nat, j: nat)\n requires z <= k\n ensures z + j <= k + j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_16317","instance":16317,"id":186316,"goal":"lemma Abs_Nonneg_16317(x: real)\n ensures (if x >= 0 then x else -x) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_16318","instance":16318,"id":186317,"goal":"lemma DivMod_16318(j: int, k: int)\n requires k > 0\n ensures j == k * (j / k) + (j % k)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_16319","instance":16319,"id":186318,"goal":"lemma ModBounds_16319(x: nat, c: nat)\n requires c > 0\n ensures 0 <= x % c < c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_16320","instance":16320,"id":186319,"goal":"lemma Square_Nonneg_16320(x: real)\n ensures x * x >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_16321","instance":16321,"id":186320,"goal":"lemma AddComm_16321(z: int, y: int)\n ensures z + y == y + z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_16322","instance":16322,"id":186321,"goal":"lemma AddAssoc_16322(x: nat, z: nat, d: nat)\n ensures (x + z) + d == x + (z + d)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_16323","instance":16323,"id":186322,"goal":"lemma MulComm_16323(z: real, n: real)\n ensures z * n == n * z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_16324","instance":16324,"id":186323,"goal":"lemma MulAssoc_16324(n: int, z: int, b: int)\n ensures (n * z) * b == n * (z * b)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_16325","instance":16325,"id":186324,"goal":"lemma Distrib_16325(b: nat, i: nat, x: nat)\n ensures b * (i + x) == b * i + b * x\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_16326","instance":16326,"id":186325,"goal":"lemma AddZero_16326(k: real)\n ensures k + 0 == k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_16327","instance":16327,"id":186326,"goal":"lemma MulOne_16327(j: int)\n ensures j * 1 == j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_16328","instance":16328,"id":186327,"goal":"lemma MulZero_16328(i: nat)\n ensures i * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_16329","instance":16329,"id":186328,"goal":"lemma LeRefl_16329(c: real)\n ensures c <= c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_16330","instance":16330,"id":186329,"goal":"lemma LeTrans_16330(z: int, b: int, k: int)\n requires z <= b && b <= k\n ensures z <= k\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_16331","instance":16331,"id":186330,"goal":"lemma AddMono_16331(z: nat, m: nat, x: nat)\n requires z <= m\n ensures z + x <= m + x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_16332","instance":16332,"id":186331,"goal":"lemma Abs_Nonneg_16332(a: real)\n ensures (if a >= 0 then a else -a) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_16333","instance":16333,"id":186332,"goal":"lemma DivMod_16333(a: int, x: int)\n requires x > 0\n ensures a == x * (a / x) + (a % x)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_16334","instance":16334,"id":186333,"goal":"lemma ModBounds_16334(j: nat, d: nat)\n requires d > 0\n ensures 0 <= j % d < d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_16335","instance":16335,"id":186334,"goal":"lemma Square_Nonneg_16335(z: real)\n ensures z * z >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_16336","instance":16336,"id":186335,"goal":"lemma AddComm_16336(j: int, k: int)\n ensures j + k == k + j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_16337","instance":16337,"id":186336,"goal":"lemma AddAssoc_16337(b: nat, n: nat, d: nat)\n ensures (b + n) + d == b + (n + d)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_16338","instance":16338,"id":186337,"goal":"lemma MulComm_16338(j: real, d: real)\n ensures j * d == d * j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_16339","instance":16339,"id":186338,"goal":"lemma MulAssoc_16339(y: int, j: int, a: int)\n ensures (y * j) * a == y * (j * a)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_16340","instance":16340,"id":186339,"goal":"lemma Distrib_16340(y: nat, z: nat, i: nat)\n ensures y * (z + i) == y * z + y * i\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_16341","instance":16341,"id":186340,"goal":"lemma AddZero_16341(y: real)\n ensures y + 0 == y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_16342","instance":16342,"id":186341,"goal":"lemma MulOne_16342(z: int)\n ensures z * 1 == z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_16343","instance":16343,"id":186342,"goal":"lemma MulZero_16343(y: nat)\n ensures y * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_16344","instance":16344,"id":186343,"goal":"lemma LeRefl_16344(k: real)\n ensures k <= k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_16345","instance":16345,"id":186344,"goal":"lemma LeTrans_16345(x: int, a: int, d: int)\n requires x <= a && a <= d\n ensures x <= d\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_16346","instance":16346,"id":186345,"goal":"lemma AddMono_16346(z: nat, d: nat, b: nat)\n requires z <= d\n ensures z + b <= d + b\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_16347","instance":16347,"id":186346,"goal":"lemma Abs_Nonneg_16347(m: real)\n ensures (if m >= 0 then m else -m) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_16348","instance":16348,"id":186347,"goal":"lemma DivMod_16348(a: int, d: int)\n requires d > 0\n ensures a == d * (a / d) + (a % d)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_16349","instance":16349,"id":186348,"goal":"lemma ModBounds_16349(c: nat, a: nat)\n requires a > 0\n ensures 0 <= c % a < a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_16350","instance":16350,"id":186349,"goal":"lemma Square_Nonneg_16350(a: real)\n ensures a * a >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_16351","instance":16351,"id":186350,"goal":"lemma AddComm_16351(x: int, c: int)\n ensures x + c == c + x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_16352","instance":16352,"id":186351,"goal":"lemma AddAssoc_16352(a: nat, c: nat, y: nat)\n ensures (a + c) + y == a + (c + y)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_16353","instance":16353,"id":186352,"goal":"lemma MulComm_16353(x: real, z: real)\n ensures x * z == z * x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_16354","instance":16354,"id":186353,"goal":"lemma MulAssoc_16354(a: int, y: int, x: int)\n ensures (a * y) * x == a * (y * x)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_16355","instance":16355,"id":186354,"goal":"lemma Distrib_16355(x: nat, k: nat, c: nat)\n ensures x * (k + c) == x * k + x * c\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_16356","instance":16356,"id":186355,"goal":"lemma AddZero_16356(y: real)\n ensures y + 0 == y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_16357","instance":16357,"id":186356,"goal":"lemma MulOne_16357(k: int)\n ensures k * 1 == k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_16358","instance":16358,"id":186357,"goal":"lemma MulZero_16358(a: nat)\n ensures a * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_16359","instance":16359,"id":186358,"goal":"lemma LeRefl_16359(j: real)\n ensures j <= j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_16360","instance":16360,"id":186359,"goal":"lemma LeTrans_16360(z: int, n: int, x: int)\n requires z <= n && n <= x\n ensures z <= x\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_16361","instance":16361,"id":186360,"goal":"lemma AddMono_16361(b: nat, k: nat, z: nat)\n requires b <= k\n ensures b + z <= k + z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_16362","instance":16362,"id":186361,"goal":"lemma Abs_Nonneg_16362(n: real)\n ensures (if n >= 0 then n else -n) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_16363","instance":16363,"id":186362,"goal":"lemma DivMod_16363(x: int, d: int)\n requires d > 0\n ensures x == d * (x / d) + (x % d)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_16364","instance":16364,"id":186363,"goal":"lemma ModBounds_16364(c: nat, n: nat)\n requires n > 0\n ensures 0 <= c % n < n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_16365","instance":16365,"id":186364,"goal":"lemma Square_Nonneg_16365(x: real)\n ensures x * x >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_16366","instance":16366,"id":186365,"goal":"lemma AddComm_16366(m: int, k: int)\n ensures m + k == k + m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_16367","instance":16367,"id":186366,"goal":"lemma AddAssoc_16367(m: nat, y: nat, j: nat)\n ensures (m + y) + j == m + (y + j)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_16368","instance":16368,"id":186367,"goal":"lemma MulComm_16368(x: real, a: real)\n ensures x * a == a * x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_16369","instance":16369,"id":186368,"goal":"lemma MulAssoc_16369(m: int, z: int, c: int)\n ensures (m * z) * c == m * (z * c)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_16370","instance":16370,"id":186369,"goal":"lemma Distrib_16370(x: nat, k: nat, z: nat)\n ensures x * (k + z) == x * k + x * z\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_16371","instance":16371,"id":186370,"goal":"lemma AddZero_16371(b: real)\n ensures b + 0 == b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_16372","instance":16372,"id":186371,"goal":"lemma MulOne_16372(a: int)\n ensures a * 1 == a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_16373","instance":16373,"id":186372,"goal":"lemma MulZero_16373(x: nat)\n ensures x * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_16374","instance":16374,"id":186373,"goal":"lemma LeRefl_16374(a: real)\n ensures a <= a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_16375","instance":16375,"id":186374,"goal":"lemma LeTrans_16375(j: int, m: int, y: int)\n requires j <= m && m <= y\n ensures j <= y\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_16376","instance":16376,"id":186375,"goal":"lemma AddMono_16376(n: nat, y: nat, j: nat)\n requires n <= y\n ensures n + j <= y + j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_16377","instance":16377,"id":186376,"goal":"lemma Abs_Nonneg_16377(d: real)\n ensures (if d >= 0 then d else -d) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_16378","instance":16378,"id":186377,"goal":"lemma DivMod_16378(m: int, i: int)\n requires i > 0\n ensures m == i * (m / i) + (m % i)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_16379","instance":16379,"id":186378,"goal":"lemma ModBounds_16379(j: nat, x: nat)\n requires x > 0\n ensures 0 <= j % x < x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_16380","instance":16380,"id":186379,"goal":"lemma Square_Nonneg_16380(c: real)\n ensures c * c >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_16381","instance":16381,"id":186380,"goal":"lemma AddComm_16381(b: int, c: int)\n ensures b + c == c + b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_16382","instance":16382,"id":186381,"goal":"lemma AddAssoc_16382(d: nat, j: nat, z: nat)\n ensures (d + j) + z == d + (j + z)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_16383","instance":16383,"id":186382,"goal":"lemma MulComm_16383(b: real, y: real)\n ensures b * y == y * b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_16384","instance":16384,"id":186383,"goal":"lemma MulAssoc_16384(n: int, d: int, z: int)\n ensures (n * d) * z == n * (d * z)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_16385","instance":16385,"id":186384,"goal":"lemma Distrib_16385(j: nat, n: nat, y: nat)\n ensures j * (n + y) == j * n + j * y\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_16386","instance":16386,"id":186385,"goal":"lemma AddZero_16386(b: real)\n ensures b + 0 == b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_16387","instance":16387,"id":186386,"goal":"lemma MulOne_16387(m: int)\n ensures m * 1 == m\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_16388","instance":16388,"id":186387,"goal":"lemma MulZero_16388(k: nat)\n ensures k * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_16389","instance":16389,"id":186388,"goal":"lemma LeRefl_16389(n: real)\n ensures n <= n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_16390","instance":16390,"id":186389,"goal":"lemma LeTrans_16390(y: int, k: int, c: int)\n requires y <= k && k <= c\n ensures y <= c\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_16391","instance":16391,"id":186390,"goal":"lemma AddMono_16391(x: nat, d: nat, a: nat)\n requires x <= d\n ensures x + a <= d + a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_16392","instance":16392,"id":186391,"goal":"lemma Abs_Nonneg_16392(j: real)\n ensures (if j >= 0 then j else -j) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_16393","instance":16393,"id":186392,"goal":"lemma DivMod_16393(c: int, a: int)\n requires a > 0\n ensures c == a * (c / a) + (c % a)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_16394","instance":16394,"id":186393,"goal":"lemma ModBounds_16394(i: nat, y: nat)\n requires y > 0\n ensures 0 <= i % y < y\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_16395","instance":16395,"id":186394,"goal":"lemma Square_Nonneg_16395(b: real)\n ensures b * b >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_16396","instance":16396,"id":186395,"goal":"lemma AddComm_16396(y: int, z: int)\n ensures y + z == z + y\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_16397","instance":16397,"id":186396,"goal":"lemma AddAssoc_16397(d: nat, y: nat, a: nat)\n ensures (d + y) + a == d + (y + a)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_16398","instance":16398,"id":186397,"goal":"lemma MulComm_16398(k: real, z: real)\n ensures k * z == z * k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_16399","instance":16399,"id":186398,"goal":"lemma MulAssoc_16399(a: int, y: int, k: int)\n ensures (a * y) * k == a * (y * k)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_16400","instance":16400,"id":186399,"goal":"lemma Distrib_16400(c: nat, n: nat, j: nat)\n ensures c * (n + j) == c * n + c * j\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_16401","instance":16401,"id":186400,"goal":"lemma AddZero_16401(z: real)\n ensures z + 0 == z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_16402","instance":16402,"id":186401,"goal":"lemma MulOne_16402(j: int)\n ensures j * 1 == j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_16403","instance":16403,"id":186402,"goal":"lemma MulZero_16403(x: nat)\n ensures x * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_16404","instance":16404,"id":186403,"goal":"lemma LeRefl_16404(z: real)\n ensures z <= z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_16405","instance":16405,"id":186404,"goal":"lemma LeTrans_16405(n: int, j: int, x: int)\n requires n <= j && j <= x\n ensures n <= x\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_16406","instance":16406,"id":186405,"goal":"lemma AddMono_16406(y: nat, m: nat, b: nat)\n requires y <= m\n ensures y + b <= m + b\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_16407","instance":16407,"id":186406,"goal":"lemma Abs_Nonneg_16407(j: real)\n ensures (if j >= 0 then j else -j) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_16408","instance":16408,"id":186407,"goal":"lemma DivMod_16408(y: int, d: int)\n requires d > 0\n ensures y == d * (y / d) + (y % d)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_16409","instance":16409,"id":186408,"goal":"lemma ModBounds_16409(c: nat, b: nat)\n requires b > 0\n ensures 0 <= c % b < b\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_16410","instance":16410,"id":186409,"goal":"lemma Square_Nonneg_16410(b: real)\n ensures b * b >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_16411","instance":16411,"id":186410,"goal":"lemma AddComm_16411(x: int, i: int)\n ensures x + i == i + x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_16412","instance":16412,"id":186411,"goal":"lemma AddAssoc_16412(b: nat, d: nat, j: nat)\n ensures (b + d) + j == b + (d + j)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_16413","instance":16413,"id":186412,"goal":"lemma MulComm_16413(y: real, a: real)\n ensures y * a == a * y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_16414","instance":16414,"id":186413,"goal":"lemma MulAssoc_16414(k: int, i: int, a: int)\n ensures (k * i) * a == k * (i * a)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_16415","instance":16415,"id":186414,"goal":"lemma Distrib_16415(b: nat, k: nat, x: nat)\n ensures b * (k + x) == b * k + b * x\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_16416","instance":16416,"id":186415,"goal":"lemma AddZero_16416(c: real)\n ensures c + 0 == c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_16417","instance":16417,"id":186416,"goal":"lemma MulOne_16417(n: int)\n ensures n * 1 == n\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_16418","instance":16418,"id":186417,"goal":"lemma MulZero_16418(j: nat)\n ensures j * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_16419","instance":16419,"id":186418,"goal":"lemma LeRefl_16419(j: real)\n ensures j <= j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_16420","instance":16420,"id":186419,"goal":"lemma LeTrans_16420(k: int, a: int, i: int)\n requires k <= a && a <= i\n ensures k <= i\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_16421","instance":16421,"id":186420,"goal":"lemma AddMono_16421(k: nat, x: nat, m: nat)\n requires k <= x\n ensures k + m <= x + m\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_16422","instance":16422,"id":186421,"goal":"lemma Abs_Nonneg_16422(d: real)\n ensures (if d >= 0 then d else -d) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_16423","instance":16423,"id":186422,"goal":"lemma DivMod_16423(i: int, j: int)\n requires j > 0\n ensures i == j * (i / j) + (i % j)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_16424","instance":16424,"id":186423,"goal":"lemma ModBounds_16424(n: nat, m: nat)\n requires m > 0\n ensures 0 <= n % m < m\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_16425","instance":16425,"id":186424,"goal":"lemma Square_Nonneg_16425(c: real)\n ensures c * c >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_16426","instance":16426,"id":186425,"goal":"lemma AddComm_16426(a: int, z: int)\n ensures a + z == z + a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_16427","instance":16427,"id":186426,"goal":"lemma AddAssoc_16427(n: nat, b: nat, y: nat)\n ensures (n + b) + y == n + (b + y)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_16428","instance":16428,"id":186427,"goal":"lemma MulComm_16428(d: real, m: real)\n ensures d * m == m * d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_16429","instance":16429,"id":186428,"goal":"lemma MulAssoc_16429(a: int, m: int, j: int)\n ensures (a * m) * j == a * (m * j)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_16430","instance":16430,"id":186429,"goal":"lemma Distrib_16430(i: nat, d: nat, m: nat)\n ensures i * (d + m) == i * d + i * m\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_16431","instance":16431,"id":186430,"goal":"lemma AddZero_16431(y: real)\n ensures y + 0 == y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_16432","instance":16432,"id":186431,"goal":"lemma MulOne_16432(c: int)\n ensures c * 1 == c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_16433","instance":16433,"id":186432,"goal":"lemma MulZero_16433(c: nat)\n ensures c * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_16434","instance":16434,"id":186433,"goal":"lemma LeRefl_16434(k: real)\n ensures k <= k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_16435","instance":16435,"id":186434,"goal":"lemma LeTrans_16435(c: int, y: int, n: int)\n requires c <= y && y <= n\n ensures c <= n\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_16436","instance":16436,"id":186435,"goal":"lemma AddMono_16436(a: nat, z: nat, n: nat)\n requires a <= z\n ensures a + n <= z + n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_16437","instance":16437,"id":186436,"goal":"lemma Abs_Nonneg_16437(n: real)\n ensures (if n >= 0 then n else -n) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_16438","instance":16438,"id":186437,"goal":"lemma DivMod_16438(d: int, c: int)\n requires c > 0\n ensures d == c * (d / c) + (d % c)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_16439","instance":16439,"id":186438,"goal":"lemma ModBounds_16439(n: nat, k: nat)\n requires k > 0\n ensures 0 <= n % k < k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_16440","instance":16440,"id":186439,"goal":"lemma Square_Nonneg_16440(x: real)\n ensures x * x >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_16441","instance":16441,"id":186440,"goal":"lemma AddComm_16441(z: int, j: int)\n ensures z + j == j + z\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_16442","instance":16442,"id":186441,"goal":"lemma AddAssoc_16442(n: nat, z: nat, c: nat)\n ensures (n + z) + c == n + (z + c)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_16443","instance":16443,"id":186442,"goal":"lemma MulComm_16443(k: real, d: real)\n ensures k * d == d * k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_16444","instance":16444,"id":186443,"goal":"lemma MulAssoc_16444(d: int, y: int, m: int)\n ensures (d * y) * m == d * (y * m)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_16445","instance":16445,"id":186444,"goal":"lemma Distrib_16445(d: nat, x: nat, n: nat)\n ensures d * (x + n) == d * x + d * n\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_16446","instance":16446,"id":186445,"goal":"lemma AddZero_16446(z: real)\n ensures z + 0 == z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_16447","instance":16447,"id":186446,"goal":"lemma MulOne_16447(a: int)\n ensures a * 1 == a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_16448","instance":16448,"id":186447,"goal":"lemma MulZero_16448(m: nat)\n ensures m * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_16449","instance":16449,"id":186448,"goal":"lemma LeRefl_16449(a: real)\n ensures a <= a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_16450","instance":16450,"id":186449,"goal":"lemma LeTrans_16450(i: int, x: int, d: int)\n requires i <= x && x <= d\n ensures i <= d\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_16451","instance":16451,"id":186450,"goal":"lemma AddMono_16451(m: nat, z: nat, b: nat)\n requires m <= z\n ensures m + b <= z + b\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_16452","instance":16452,"id":186451,"goal":"lemma Abs_Nonneg_16452(c: real)\n ensures (if c >= 0 then c else -c) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_16453","instance":16453,"id":186452,"goal":"lemma DivMod_16453(k: int, y: int)\n requires y > 0\n ensures k == y * (k / y) + (k % y)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_16454","instance":16454,"id":186453,"goal":"lemma ModBounds_16454(d: nat, c: nat)\n requires c > 0\n ensures 0 <= d % c < c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_16455","instance":16455,"id":186454,"goal":"lemma Square_Nonneg_16455(i: real)\n ensures i * i >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_16456","instance":16456,"id":186455,"goal":"lemma AddComm_16456(i: int, y: int)\n ensures i + y == y + i\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_16457","instance":16457,"id":186456,"goal":"lemma AddAssoc_16457(b: nat, d: nat, n: nat)\n ensures (b + d) + n == b + (d + n)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_16458","instance":16458,"id":186457,"goal":"lemma MulComm_16458(a: real, j: real)\n ensures a * j == j * a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_16459","instance":16459,"id":186458,"goal":"lemma MulAssoc_16459(x: int, m: int, b: int)\n ensures (x * m) * b == x * (m * b)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_16460","instance":16460,"id":186459,"goal":"lemma Distrib_16460(m: nat, a: nat, j: nat)\n ensures m * (a + j) == m * a + m * j\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_16461","instance":16461,"id":186460,"goal":"lemma AddZero_16461(x: real)\n ensures x + 0 == x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_16462","instance":16462,"id":186461,"goal":"lemma MulOne_16462(j: int)\n ensures j * 1 == j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_16463","instance":16463,"id":186462,"goal":"lemma MulZero_16463(y: nat)\n ensures y * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_16464","instance":16464,"id":186463,"goal":"lemma LeRefl_16464(a: real)\n ensures a <= a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_16465","instance":16465,"id":186464,"goal":"lemma LeTrans_16465(z: int, d: int, k: int)\n requires z <= d && d <= k\n ensures z <= k\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_16466","instance":16466,"id":186465,"goal":"lemma AddMono_16466(i: nat, d: nat, k: nat)\n requires i <= d\n ensures i + k <= d + k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_16467","instance":16467,"id":186466,"goal":"lemma Abs_Nonneg_16467(k: real)\n ensures (if k >= 0 then k else -k) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_16468","instance":16468,"id":186467,"goal":"lemma DivMod_16468(i: int, k: int)\n requires k > 0\n ensures i == k * (i / k) + (i % k)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_16469","instance":16469,"id":186468,"goal":"lemma ModBounds_16469(y: nat, b: nat)\n requires b > 0\n ensures 0 <= y % b < b\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_16470","instance":16470,"id":186469,"goal":"lemma Square_Nonneg_16470(a: real)\n ensures a * a >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_16471","instance":16471,"id":186470,"goal":"lemma AddComm_16471(x: int, a: int)\n ensures x + a == a + x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_16472","instance":16472,"id":186471,"goal":"lemma AddAssoc_16472(m: nat, x: nat, b: nat)\n ensures (m + x) + b == m + (x + b)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_16473","instance":16473,"id":186472,"goal":"lemma MulComm_16473(x: real, a: real)\n ensures x * a == a * x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_16474","instance":16474,"id":186473,"goal":"lemma MulAssoc_16474(i: int, a: int, k: int)\n ensures (i * a) * k == i * (a * k)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_16475","instance":16475,"id":186474,"goal":"lemma Distrib_16475(z: nat, a: nat, m: nat)\n ensures z * (a + m) == z * a + z * m\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_16476","instance":16476,"id":186475,"goal":"lemma AddZero_16476(x: real)\n ensures x + 0 == x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_16477","instance":16477,"id":186476,"goal":"lemma MulOne_16477(a: int)\n ensures a * 1 == a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_16478","instance":16478,"id":186477,"goal":"lemma MulZero_16478(m: nat)\n ensures m * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_16479","instance":16479,"id":186478,"goal":"lemma LeRefl_16479(n: real)\n ensures n <= n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_16480","instance":16480,"id":186479,"goal":"lemma LeTrans_16480(k: int, n: int, a: int)\n requires k <= n && n <= a\n ensures k <= a\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_16481","instance":16481,"id":186480,"goal":"lemma AddMono_16481(c: nat, n: nat, z: nat)\n requires c <= n\n ensures c + z <= n + z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_16482","instance":16482,"id":186481,"goal":"lemma Abs_Nonneg_16482(y: real)\n ensures (if y >= 0 then y else -y) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_16483","instance":16483,"id":186482,"goal":"lemma DivMod_16483(m: int, a: int)\n requires a > 0\n ensures m == a * (m / a) + (m % a)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_16484","instance":16484,"id":186483,"goal":"lemma ModBounds_16484(a: nat, x: nat)\n requires x > 0\n ensures 0 <= a % x < x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_16485","instance":16485,"id":186484,"goal":"lemma Square_Nonneg_16485(z: real)\n ensures z * z >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_16486","instance":16486,"id":186485,"goal":"lemma AddComm_16486(n: int, z: int)\n ensures n + z == z + n\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_16487","instance":16487,"id":186486,"goal":"lemma AddAssoc_16487(y: nat, k: nat, i: nat)\n ensures (y + k) + i == y + (k + i)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_16488","instance":16488,"id":186487,"goal":"lemma MulComm_16488(z: real, x: real)\n ensures z * x == x * z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_16489","instance":16489,"id":186488,"goal":"lemma MulAssoc_16489(m: int, x: int, b: int)\n ensures (m * x) * b == m * (x * b)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_16490","instance":16490,"id":186489,"goal":"lemma Distrib_16490(m: nat, d: nat, b: nat)\n ensures m * (d + b) == m * d + m * b\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_16491","instance":16491,"id":186490,"goal":"lemma AddZero_16491(y: real)\n ensures y + 0 == y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_16492","instance":16492,"id":186491,"goal":"lemma MulOne_16492(k: int)\n ensures k * 1 == k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_16493","instance":16493,"id":186492,"goal":"lemma MulZero_16493(a: nat)\n ensures a * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_16494","instance":16494,"id":186493,"goal":"lemma LeRefl_16494(k: real)\n ensures k <= k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_16495","instance":16495,"id":186494,"goal":"lemma LeTrans_16495(a: int, n: int, c: int)\n requires a <= n && n <= c\n ensures a <= c\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_16496","instance":16496,"id":186495,"goal":"lemma AddMono_16496(c: nat, d: nat, a: nat)\n requires c <= d\n ensures c + a <= d + a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_16497","instance":16497,"id":186496,"goal":"lemma Abs_Nonneg_16497(b: real)\n ensures (if b >= 0 then b else -b) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_16498","instance":16498,"id":186497,"goal":"lemma DivMod_16498(c: int, y: int)\n requires y > 0\n ensures c == y * (c / y) + (c % y)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_16499","instance":16499,"id":186498,"goal":"lemma ModBounds_16499(b: nat, j: nat)\n requires j > 0\n ensures 0 <= b % j < j\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_16500","instance":16500,"id":186499,"goal":"lemma Square_Nonneg_16500(i: real)\n ensures i * i >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_16501","instance":16501,"id":186500,"goal":"lemma AddComm_16501(n: int, m: int)\n ensures n + m == m + n\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_16502","instance":16502,"id":186501,"goal":"lemma AddAssoc_16502(a: nat, i: nat, m: nat)\n ensures (a + i) + m == a + (i + m)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_16503","instance":16503,"id":186502,"goal":"lemma MulComm_16503(y: real, d: real)\n ensures y * d == d * y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_16504","instance":16504,"id":186503,"goal":"lemma MulAssoc_16504(j: int, b: int, x: int)\n ensures (j * b) * x == j * (b * x)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_16505","instance":16505,"id":186504,"goal":"lemma Distrib_16505(i: nat, k: nat, c: nat)\n ensures i * (k + c) == i * k + i * c\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_16506","instance":16506,"id":186505,"goal":"lemma AddZero_16506(c: real)\n ensures c + 0 == c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_16507","instance":16507,"id":186506,"goal":"lemma MulOne_16507(n: int)\n ensures n * 1 == n\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_16508","instance":16508,"id":186507,"goal":"lemma MulZero_16508(i: nat)\n ensures i * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_16509","instance":16509,"id":186508,"goal":"lemma LeRefl_16509(a: real)\n ensures a <= a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_16510","instance":16510,"id":186509,"goal":"lemma LeTrans_16510(b: int, d: int, x: int)\n requires b <= d && d <= x\n ensures b <= x\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_16511","instance":16511,"id":186510,"goal":"lemma AddMono_16511(n: nat, j: nat, k: nat)\n requires n <= j\n ensures n + k <= j + k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_16512","instance":16512,"id":186511,"goal":"lemma Abs_Nonneg_16512(n: real)\n ensures (if n >= 0 then n else -n) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_16513","instance":16513,"id":186512,"goal":"lemma DivMod_16513(n: int, b: int)\n requires b > 0\n ensures n == b * (n / b) + (n % b)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_16514","instance":16514,"id":186513,"goal":"lemma ModBounds_16514(d: nat, y: nat)\n requires y > 0\n ensures 0 <= d % y < y\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_16515","instance":16515,"id":186514,"goal":"lemma Square_Nonneg_16515(j: real)\n ensures j * j >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_16516","instance":16516,"id":186515,"goal":"lemma AddComm_16516(j: int, a: int)\n ensures j + a == a + j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_16517","instance":16517,"id":186516,"goal":"lemma AddAssoc_16517(a: nat, b: nat, m: nat)\n ensures (a + b) + m == a + (b + m)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_16518","instance":16518,"id":186517,"goal":"lemma MulComm_16518(b: real, i: real)\n ensures b * i == i * b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_16519","instance":16519,"id":186518,"goal":"lemma MulAssoc_16519(n: int, a: int, x: int)\n ensures (n * a) * x == n * (a * x)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_16520","instance":16520,"id":186519,"goal":"lemma Distrib_16520(k: nat, i: nat, c: nat)\n ensures k * (i + c) == k * i + k * c\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_16521","instance":16521,"id":186520,"goal":"lemma AddZero_16521(d: real)\n ensures d + 0 == d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_16522","instance":16522,"id":186521,"goal":"lemma MulOne_16522(c: int)\n ensures c * 1 == c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_16523","instance":16523,"id":186522,"goal":"lemma MulZero_16523(d: nat)\n ensures d * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_16524","instance":16524,"id":186523,"goal":"lemma LeRefl_16524(b: real)\n ensures b <= b\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_16525","instance":16525,"id":186524,"goal":"lemma LeTrans_16525(d: int, a: int, b: int)\n requires d <= a && a <= b\n ensures d <= b\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_16526","instance":16526,"id":186525,"goal":"lemma AddMono_16526(b: nat, k: nat, c: nat)\n requires b <= k\n ensures b + c <= k + c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_16527","instance":16527,"id":186526,"goal":"lemma Abs_Nonneg_16527(a: real)\n ensures (if a >= 0 then a else -a) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_16528","instance":16528,"id":186527,"goal":"lemma DivMod_16528(z: int, j: int)\n requires j > 0\n ensures z == j * (z / j) + (z % j)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_16529","instance":16529,"id":186528,"goal":"lemma ModBounds_16529(y: nat, d: nat)\n requires d > 0\n ensures 0 <= y % d < d\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_16530","instance":16530,"id":186529,"goal":"lemma Square_Nonneg_16530(z: real)\n ensures z * z >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_16531","instance":16531,"id":186530,"goal":"lemma AddComm_16531(j: int, c: int)\n ensures j + c == c + j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_16532","instance":16532,"id":186531,"goal":"lemma AddAssoc_16532(d: nat, y: nat, a: nat)\n ensures (d + y) + a == d + (y + a)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_16533","instance":16533,"id":186532,"goal":"lemma MulComm_16533(j: real, x: real)\n ensures j * x == x * j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_16534","instance":16534,"id":186533,"goal":"lemma MulAssoc_16534(m: int, y: int, k: int)\n ensures (m * y) * k == m * (y * k)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_16535","instance":16535,"id":186534,"goal":"lemma Distrib_16535(k: nat, x: nat, m: nat)\n ensures k * (x + m) == k * x + k * m\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_16536","instance":16536,"id":186535,"goal":"lemma AddZero_16536(a: real)\n ensures a + 0 == a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_16537","instance":16537,"id":186536,"goal":"lemma MulOne_16537(x: int)\n ensures x * 1 == x\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_16538","instance":16538,"id":186537,"goal":"lemma MulZero_16538(a: nat)\n ensures a * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_16539","instance":16539,"id":186538,"goal":"lemma LeRefl_16539(i: real)\n ensures i <= i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_16540","instance":16540,"id":186539,"goal":"lemma LeTrans_16540(c: int, i: int, x: int)\n requires c <= i && i <= x\n ensures c <= x\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_16541","instance":16541,"id":186540,"goal":"lemma AddMono_16541(m: nat, d: nat, x: nat)\n requires m <= d\n ensures m + x <= d + x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_16542","instance":16542,"id":186541,"goal":"lemma Abs_Nonneg_16542(a: real)\n ensures (if a >= 0 then a else -a) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_16543","instance":16543,"id":186542,"goal":"lemma DivMod_16543(z: int, b: int)\n requires b > 0\n ensures z == b * (z / b) + (z % b)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_16544","instance":16544,"id":186543,"goal":"lemma ModBounds_16544(k: nat, z: nat)\n requires z > 0\n ensures 0 <= k % z < z\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_16545","instance":16545,"id":186544,"goal":"lemma Square_Nonneg_16545(k: real)\n ensures k * k >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_16546","instance":16546,"id":186545,"goal":"lemma AddComm_16546(k: int, a: int)\n ensures k + a == a + k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_16547","instance":16547,"id":186546,"goal":"lemma AddAssoc_16547(k: nat, i: nat, d: nat)\n ensures (k + i) + d == k + (i + d)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_16548","instance":16548,"id":186547,"goal":"lemma MulComm_16548(c: real, b: real)\n ensures c * b == b * c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_16549","instance":16549,"id":186548,"goal":"lemma MulAssoc_16549(b: int, x: int, z: int)\n ensures (b * x) * z == b * (x * z)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_16550","instance":16550,"id":186549,"goal":"lemma Distrib_16550(y: nat, x: nat, c: nat)\n ensures y * (x + c) == y * x + y * c\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_16551","instance":16551,"id":186550,"goal":"lemma AddZero_16551(i: real)\n ensures i + 0 == i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_16552","instance":16552,"id":186551,"goal":"lemma MulOne_16552(c: int)\n ensures c * 1 == c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_16553","instance":16553,"id":186552,"goal":"lemma MulZero_16553(y: nat)\n ensures y * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_16554","instance":16554,"id":186553,"goal":"lemma LeRefl_16554(x: real)\n ensures x <= x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_16555","instance":16555,"id":186554,"goal":"lemma LeTrans_16555(d: int, b: int, a: int)\n requires d <= b && b <= a\n ensures d <= a\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_16556","instance":16556,"id":186555,"goal":"lemma AddMono_16556(n: nat, a: nat, x: nat)\n requires n <= a\n ensures n + x <= a + x\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_16557","instance":16557,"id":186556,"goal":"lemma Abs_Nonneg_16557(a: real)\n ensures (if a >= 0 then a else -a) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_16558","instance":16558,"id":186557,"goal":"lemma DivMod_16558(d: int, m: int)\n requires m > 0\n ensures d == m * (d / m) + (d % m)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_16559","instance":16559,"id":186558,"goal":"lemma ModBounds_16559(x: nat, y: nat)\n requires y > 0\n ensures 0 <= x % y < y\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_16560","instance":16560,"id":186559,"goal":"lemma Square_Nonneg_16560(x: real)\n ensures x * x >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_16561","instance":16561,"id":186560,"goal":"lemma AddComm_16561(j: int, k: int)\n ensures j + k == k + j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_16562","instance":16562,"id":186561,"goal":"lemma AddAssoc_16562(d: nat, a: nat, z: nat)\n ensures (d + a) + z == d + (a + z)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_16563","instance":16563,"id":186562,"goal":"lemma MulComm_16563(j: real, n: real)\n ensures j * n == n * j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_16564","instance":16564,"id":186563,"goal":"lemma MulAssoc_16564(i: int, a: int, d: int)\n ensures (i * a) * d == i * (a * d)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_16565","instance":16565,"id":186564,"goal":"lemma Distrib_16565(y: nat, k: nat, a: nat)\n ensures y * (k + a) == y * k + y * a\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_16566","instance":16566,"id":186565,"goal":"lemma AddZero_16566(z: real)\n ensures z + 0 == z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_16567","instance":16567,"id":186566,"goal":"lemma MulOne_16567(n: int)\n ensures n * 1 == n\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_16568","instance":16568,"id":186567,"goal":"lemma MulZero_16568(c: nat)\n ensures c * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_16569","instance":16569,"id":186568,"goal":"lemma LeRefl_16569(a: real)\n ensures a <= a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_16570","instance":16570,"id":186569,"goal":"lemma LeTrans_16570(i: int, m: int, c: int)\n requires i <= m && m <= c\n ensures i <= c\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_16571","instance":16571,"id":186570,"goal":"lemma AddMono_16571(j: nat, b: nat, m: nat)\n requires j <= b\n ensures j + m <= b + m\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_16572","instance":16572,"id":186571,"goal":"lemma Abs_Nonneg_16572(b: real)\n ensures (if b >= 0 then b else -b) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_16573","instance":16573,"id":186572,"goal":"lemma DivMod_16573(n: int, m: int)\n requires m > 0\n ensures n == m * (n / m) + (n % m)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_16574","instance":16574,"id":186573,"goal":"lemma ModBounds_16574(c: nat, i: nat)\n requires i > 0\n ensures 0 <= c % i < i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_16575","instance":16575,"id":186574,"goal":"lemma Square_Nonneg_16575(i: real)\n ensures i * i >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_16576","instance":16576,"id":186575,"goal":"lemma AddComm_16576(n: int, j: int)\n ensures n + j == j + n\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_16577","instance":16577,"id":186576,"goal":"lemma AddAssoc_16577(c: nat, x: nat, n: nat)\n ensures (c + x) + n == c + (x + n)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_16578","instance":16578,"id":186577,"goal":"lemma MulComm_16578(n: real, x: real)\n ensures n * x == x * n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_16579","instance":16579,"id":186578,"goal":"lemma MulAssoc_16579(c: int, z: int, y: int)\n ensures (c * z) * y == c * (z * y)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_16580","instance":16580,"id":186579,"goal":"lemma Distrib_16580(m: nat, a: nat, d: nat)\n ensures m * (a + d) == m * a + m * d\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_16581","instance":16581,"id":186580,"goal":"lemma AddZero_16581(n: real)\n ensures n + 0 == n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_16582","instance":16582,"id":186581,"goal":"lemma MulOne_16582(i: int)\n ensures i * 1 == i\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_16583","instance":16583,"id":186582,"goal":"lemma MulZero_16583(b: nat)\n ensures b * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_16584","instance":16584,"id":186583,"goal":"lemma LeRefl_16584(j: real)\n ensures j <= j\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_16585","instance":16585,"id":186584,"goal":"lemma LeTrans_16585(d: int, j: int, y: int)\n requires d <= j && j <= y\n ensures d <= y\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_16586","instance":16586,"id":186585,"goal":"lemma AddMono_16586(y: nat, k: nat, n: nat)\n requires y <= k\n ensures y + n <= k + n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_16587","instance":16587,"id":186586,"goal":"lemma Abs_Nonneg_16587(x: real)\n ensures (if x >= 0 then x else -x) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_16588","instance":16588,"id":186587,"goal":"lemma DivMod_16588(x: int, k: int)\n requires k > 0\n ensures x == k * (x / k) + (x % k)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_16589","instance":16589,"id":186588,"goal":"lemma ModBounds_16589(d: nat, n: nat)\n requires n > 0\n ensures 0 <= d % n < n\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_16590","instance":16590,"id":186589,"goal":"lemma Square_Nonneg_16590(n: real)\n ensures n * n >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_16591","instance":16591,"id":186590,"goal":"lemma AddComm_16591(k: int, d: int)\n ensures k + d == d + k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_16592","instance":16592,"id":186591,"goal":"lemma AddAssoc_16592(c: nat, i: nat, x: nat)\n ensures (c + i) + x == c + (i + x)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_16593","instance":16593,"id":186592,"goal":"lemma MulComm_16593(n: real, k: real)\n ensures n * k == k * n\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_16594","instance":16594,"id":186593,"goal":"lemma MulAssoc_16594(m: int, d: int, a: int)\n ensures (m * d) * a == m * (d * a)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_16595","instance":16595,"id":186594,"goal":"lemma Distrib_16595(x: nat, c: nat, n: nat)\n ensures x * (c + n) == x * c + x * n\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_16596","instance":16596,"id":186595,"goal":"lemma AddZero_16596(c: real)\n ensures c + 0 == c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_16597","instance":16597,"id":186596,"goal":"lemma MulOne_16597(c: int)\n ensures c * 1 == c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_16598","instance":16598,"id":186597,"goal":"lemma MulZero_16598(y: nat)\n ensures y * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_16599","instance":16599,"id":186598,"goal":"lemma LeRefl_16599(c: real)\n ensures c <= c\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_16600","instance":16600,"id":186599,"goal":"lemma LeTrans_16600(i: int, z: int, b: int)\n requires i <= z && z <= b\n ensures i <= b\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_16601","instance":16601,"id":186600,"goal":"lemma AddMono_16601(d: nat, a: nat, c: nat)\n requires d <= a\n ensures d + c <= a + c\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_16602","instance":16602,"id":186601,"goal":"lemma Abs_Nonneg_16602(k: real)\n ensures (if k >= 0 then k else -k) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_16603","instance":16603,"id":186602,"goal":"lemma DivMod_16603(x: int, c: int)\n requires c > 0\n ensures x == c * (x / c) + (x % c)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_16604","instance":16604,"id":186603,"goal":"lemma ModBounds_16604(b: nat, k: nat)\n requires k > 0\n ensures 0 <= b % k < k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_16605","instance":16605,"id":186604,"goal":"lemma Square_Nonneg_16605(d: real)\n ensures d * d >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_16606","instance":16606,"id":186605,"goal":"lemma AddComm_16606(i: int, z: int)\n ensures i + z == z + i\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_16607","instance":16607,"id":186606,"goal":"lemma AddAssoc_16607(i: nat, y: nat, b: nat)\n ensures (i + y) + b == i + (y + b)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_16608","instance":16608,"id":186607,"goal":"lemma MulComm_16608(i: real, j: real)\n ensures i * j == j * i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_16609","instance":16609,"id":186608,"goal":"lemma MulAssoc_16609(c: int, z: int, a: int)\n ensures (c * z) * a == c * (z * a)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_16610","instance":16610,"id":186609,"goal":"lemma Distrib_16610(k: nat, n: nat, a: nat)\n ensures k * (n + a) == k * n + k * a\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_16611","instance":16611,"id":186610,"goal":"lemma AddZero_16611(d: real)\n ensures d + 0 == d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_16612","instance":16612,"id":186611,"goal":"lemma MulOne_16612(b: int)\n ensures b * 1 == b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_16613","instance":16613,"id":186612,"goal":"lemma MulZero_16613(n: nat)\n ensures n * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_16614","instance":16614,"id":186613,"goal":"lemma LeRefl_16614(y: real)\n ensures y <= y\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_16615","instance":16615,"id":186614,"goal":"lemma LeTrans_16615(m: int, b: int, j: int)\n requires m <= b && b <= j\n ensures m <= j\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_16616","instance":16616,"id":186615,"goal":"lemma AddMono_16616(m: nat, j: nat, a: nat)\n requires m <= j\n ensures m + a <= j + a\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_16617","instance":16617,"id":186616,"goal":"lemma Abs_Nonneg_16617(x: real)\n ensures (if x >= 0 then x else -x) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_16618","instance":16618,"id":186617,"goal":"lemma DivMod_16618(y: int, j: int)\n requires j > 0\n ensures y == j * (y / j) + (y % j)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_16619","instance":16619,"id":186618,"goal":"lemma ModBounds_16619(b: nat, i: nat)\n requires i > 0\n ensures 0 <= b % i < i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_16620","instance":16620,"id":186619,"goal":"lemma Square_Nonneg_16620(i: real)\n ensures i * i >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_16621","instance":16621,"id":186620,"goal":"lemma AddComm_16621(b: int, x: int)\n ensures b + x == x + b\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_16622","instance":16622,"id":186621,"goal":"lemma AddAssoc_16622(a: nat, i: nat, m: nat)\n ensures (a + i) + m == a + (i + m)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_16623","instance":16623,"id":186622,"goal":"lemma MulComm_16623(i: real, a: real)\n ensures i * a == a * i\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_16624","instance":16624,"id":186623,"goal":"lemma MulAssoc_16624(a: int, b: int, j: int)\n ensures (a * b) * j == a * (b * j)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_16625","instance":16625,"id":186624,"goal":"lemma Distrib_16625(i: nat, k: nat, z: nat)\n ensures i * (k + z) == i * k + i * z\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_16626","instance":16626,"id":186625,"goal":"lemma AddZero_16626(x: real)\n ensures x + 0 == x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_16627","instance":16627,"id":186626,"goal":"lemma MulOne_16627(a: int)\n ensures a * 1 == a\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_16628","instance":16628,"id":186627,"goal":"lemma MulZero_16628(a: nat)\n ensures a * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_16629","instance":16629,"id":186628,"goal":"lemma LeRefl_16629(d: real)\n ensures d <= d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_16630","instance":16630,"id":186629,"goal":"lemma LeTrans_16630(i: int, m: int, d: int)\n requires i <= m && m <= d\n ensures i <= d\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_16631","instance":16631,"id":186630,"goal":"lemma AddMono_16631(m: nat, c: nat, i: nat)\n requires m <= c\n ensures m + i <= c + i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_16632","instance":16632,"id":186631,"goal":"lemma Abs_Nonneg_16632(k: real)\n ensures (if k >= 0 then k else -k) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_16633","instance":16633,"id":186632,"goal":"lemma DivMod_16633(j: int, a: int)\n requires a > 0\n ensures j == a * (j / a) + (j % a)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_16634","instance":16634,"id":186633,"goal":"lemma ModBounds_16634(d: nat, k: nat)\n requires k > 0\n ensures 0 <= d % k < k\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_16635","instance":16635,"id":186634,"goal":"lemma Square_Nonneg_16635(a: real)\n ensures a * a >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_16636","instance":16636,"id":186635,"goal":"lemma AddComm_16636(i: int, z: int)\n ensures i + z == z + i\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_16637","instance":16637,"id":186636,"goal":"lemma AddAssoc_16637(a: nat, b: nat, m: nat)\n ensures (a + b) + m == a + (b + m)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_16638","instance":16638,"id":186637,"goal":"lemma MulComm_16638(m: real, y: real)\n ensures m * y == y * m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_16639","instance":16639,"id":186638,"goal":"lemma MulAssoc_16639(k: int, j: int, z: int)\n ensures (k * j) * z == k * (j * z)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_16640","instance":16640,"id":186639,"goal":"lemma Distrib_16640(i: nat, j: nat, b: nat)\n ensures i * (j + b) == i * j + i * b\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_16641","instance":16641,"id":186640,"goal":"lemma AddZero_16641(d: real)\n ensures d + 0 == d\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_16642","instance":16642,"id":186641,"goal":"lemma MulOne_16642(k: int)\n ensures k * 1 == k\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_16643","instance":16643,"id":186642,"goal":"lemma MulZero_16643(m: nat)\n ensures m * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_16644","instance":16644,"id":186643,"goal":"lemma LeRefl_16644(a: real)\n ensures a <= a\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_16645","instance":16645,"id":186644,"goal":"lemma LeTrans_16645(b: int, j: int, c: int)\n requires b <= j && j <= c\n ensures b <= c\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_16646","instance":16646,"id":186645,"goal":"lemma AddMono_16646(n: nat, a: nat, y: nat)\n requires n <= a\n ensures n + y <= a + y\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_16647","instance":16647,"id":186646,"goal":"lemma Abs_Nonneg_16647(b: real)\n ensures (if b >= 0 then b else -b) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_16648","instance":16648,"id":186647,"goal":"lemma DivMod_16648(d: int, n: int)\n requires n > 0\n ensures d == n * (d / n) + (d % n)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_16649","instance":16649,"id":186648,"goal":"lemma ModBounds_16649(x: nat, i: nat)\n requires i > 0\n ensures 0 <= x % i < i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_16650","instance":16650,"id":186649,"goal":"lemma Square_Nonneg_16650(a: real)\n ensures a * a >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_16651","instance":16651,"id":186650,"goal":"lemma AddComm_16651(c: int, i: int)\n ensures c + i == i + c\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_16652","instance":16652,"id":186651,"goal":"lemma AddAssoc_16652(a: nat, m: nat, c: nat)\n ensures (a + m) + c == a + (m + c)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_16653","instance":16653,"id":186652,"goal":"lemma MulComm_16653(m: real, d: real)\n ensures m * d == d * m\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_16654","instance":16654,"id":186653,"goal":"lemma MulAssoc_16654(a: int, c: int, n: int)\n ensures (a * c) * n == a * (c * n)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_16655","instance":16655,"id":186654,"goal":"lemma Distrib_16655(a: nat, d: nat, m: nat)\n ensures a * (d + m) == a * d + a * m\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_16656","instance":16656,"id":186655,"goal":"lemma AddZero_16656(z: real)\n ensures z + 0 == z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_16657","instance":16657,"id":186656,"goal":"lemma MulOne_16657(i: int)\n ensures i * 1 == i\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulZero","theorem":"MulZero_16658","instance":16658,"id":186657,"goal":"lemma MulZero_16658(z: nat)\n ensures z * 0 == 0\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeRefl","theorem":"LeRefl_16659","instance":16659,"id":186658,"goal":"lemma LeRefl_16659(k: real)\n ensures k <= k\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"LeTrans","theorem":"LeTrans_16660","instance":16660,"id":186659,"goal":"lemma LeTrans_16660(b: int, d: int, j: int)\n requires b <= d && d <= j\n ensures b <= j\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddMono","theorem":"AddMono_16661","instance":16661,"id":186660,"goal":"lemma AddMono_16661(z: nat, x: nat, i: nat)\n requires z <= x\n ensures z + i <= x + i\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Abs_Nonneg","theorem":"Abs_Nonneg_16662","instance":16662,"id":186661,"goal":"lemma Abs_Nonneg_16662(c: real)\n ensures (if c >= 0 then c else -c) >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"DivMod","theorem":"DivMod_16663","instance":16663,"id":186662,"goal":"lemma DivMod_16663(z: int, d: int)\n requires d > 0\n ensures z == d * (z / d) + (z % d)\n{}","type_family":"int","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"ModBounds","theorem":"ModBounds_16664","instance":16664,"id":186663,"goal":"lemma ModBounds_16664(j: nat, b: nat)\n requires b > 0\n ensures 0 <= j % b < b\n{}","type_family":"nat","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Square_Nonneg","theorem":"Square_Nonneg_16665","instance":16665,"id":186664,"goal":"lemma Square_Nonneg_16665(z: real)\n ensures z * z >= 0\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddComm","theorem":"AddComm_16666","instance":16666,"id":186665,"goal":"lemma AddComm_16666(n: int, c: int)\n ensures n + c == c + n\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddAssoc","theorem":"AddAssoc_16667","instance":16667,"id":186666,"goal":"lemma AddAssoc_16667(n: nat, a: nat, z: nat)\n ensures (n + a) + z == n + (a + z)\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulComm","theorem":"MulComm_16668","instance":16668,"id":186667,"goal":"lemma MulComm_16668(z: real, k: real)\n ensures z * k == k * z\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulAssoc","theorem":"MulAssoc_16669","instance":16669,"id":186668,"goal":"lemma MulAssoc_16669(b: int, c: int, x: int)\n ensures (b * c) * x == b * (c * x)\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"Distrib","theorem":"Distrib_16670","instance":16670,"id":186669,"goal":"lemma Distrib_16670(b: nat, k: nat, d: nat)\n ensures b * (k + d) == b * k + b * d\n{}","type_family":"nat","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"AddZero","theorem":"AddZero_16671","instance":16671,"id":186670,"goal":"lemma AddZero_16671(x: real)\n ensures x + 0 == x\n{}","type_family":"real","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/arith","variant":"MulOne","theorem":"MulOne_16672","instance":16672,"id":186671,"goal":"lemma MulOne_16672(j: int)\n ensures j * 1 == j\n{}","type_family":"int","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_1","instance":1,"id":186672,"goal":"lemma SeqAppendLen_1(zs: seq, t: seq)\n ensures |zs + t| == |zs| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_2","instance":2,"id":186673,"goal":"lemma SeqAppendNil_2(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_3","instance":3,"id":186674,"goal":"lemma SeqNilAppend_3(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_4","instance":4,"id":186675,"goal":"lemma SeqAppendAssoc_4(ys: seq, t: seq, xs: seq)\n ensures (ys + t) + xs == ys + (t + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_5","instance":5,"id":186676,"goal":"lemma SeqTakeDrop_5(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_6","instance":6,"id":186677,"goal":"lemma SeqReverseLen_6(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_7","instance":7,"id":186678,"goal":"lemma SeqReverseIdem_7(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_8","instance":8,"id":186679,"goal":"lemma SeqMapLen_8(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_9","instance":9,"id":186680,"goal":"lemma SeqFilterLe_9(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_10","instance":10,"id":186681,"goal":"lemma SeqMemberAppend_10(t: seq, s: seq)\n ensures x in t + s <==> x in t || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_11","instance":11,"id":186682,"goal":"lemma SeqAppendLen_11(t: seq, s: seq)\n ensures |t + s| == |t| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_12","instance":12,"id":186683,"goal":"lemma SeqAppendNil_12(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_13","instance":13,"id":186684,"goal":"lemma SeqNilAppend_13(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_14","instance":14,"id":186685,"goal":"lemma SeqAppendAssoc_14(t: seq, zs: seq, xs: seq)\n ensures (t + zs) + xs == t + (zs + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_15","instance":15,"id":186686,"goal":"lemma SeqTakeDrop_15(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_16","instance":16,"id":186687,"goal":"lemma SeqReverseLen_16(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_17","instance":17,"id":186688,"goal":"lemma SeqReverseIdem_17(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_18","instance":18,"id":186689,"goal":"lemma SeqMapLen_18(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_19","instance":19,"id":186690,"goal":"lemma SeqFilterLe_19(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_20","instance":20,"id":186691,"goal":"lemma SeqMemberAppend_20(ys: seq, xs: seq)\n ensures x in ys + xs <==> x in ys || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_21","instance":21,"id":186692,"goal":"lemma SeqAppendLen_21(u: seq, t: seq)\n ensures |u + t| == |u| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_22","instance":22,"id":186693,"goal":"lemma SeqAppendNil_22(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_23","instance":23,"id":186694,"goal":"lemma SeqNilAppend_23(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_24","instance":24,"id":186695,"goal":"lemma SeqAppendAssoc_24(t: seq, xs: seq, u: seq)\n ensures (t + xs) + u == t + (xs + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_25","instance":25,"id":186696,"goal":"lemma SeqTakeDrop_25(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_26","instance":26,"id":186697,"goal":"lemma SeqReverseLen_26(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_27","instance":27,"id":186698,"goal":"lemma SeqReverseIdem_27(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_28","instance":28,"id":186699,"goal":"lemma SeqMapLen_28(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_29","instance":29,"id":186700,"goal":"lemma SeqFilterLe_29(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_30","instance":30,"id":186701,"goal":"lemma SeqMemberAppend_30(s: seq, u: seq)\n ensures x in s + u <==> x in s || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_31","instance":31,"id":186702,"goal":"lemma SeqAppendLen_31(xs: seq, ys: seq)\n ensures |xs + ys| == |xs| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_32","instance":32,"id":186703,"goal":"lemma SeqAppendNil_32(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_33","instance":33,"id":186704,"goal":"lemma SeqNilAppend_33(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_34","instance":34,"id":186705,"goal":"lemma SeqAppendAssoc_34(u: seq, zs: seq, xs: seq)\n ensures (u + zs) + xs == u + (zs + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_35","instance":35,"id":186706,"goal":"lemma SeqTakeDrop_35(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_36","instance":36,"id":186707,"goal":"lemma SeqReverseLen_36(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_37","instance":37,"id":186708,"goal":"lemma SeqReverseIdem_37(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_38","instance":38,"id":186709,"goal":"lemma SeqMapLen_38(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_39","instance":39,"id":186710,"goal":"lemma SeqFilterLe_39(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_40","instance":40,"id":186711,"goal":"lemma SeqMemberAppend_40(s: seq, t: seq)\n ensures x in s + t <==> x in s || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_41","instance":41,"id":186712,"goal":"lemma SeqAppendLen_41(zs: seq, ys: seq)\n ensures |zs + ys| == |zs| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_42","instance":42,"id":186713,"goal":"lemma SeqAppendNil_42(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_43","instance":43,"id":186714,"goal":"lemma SeqNilAppend_43(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_44","instance":44,"id":186715,"goal":"lemma SeqAppendAssoc_44(s: seq, ys: seq, t: seq)\n ensures (s + ys) + t == s + (ys + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_45","instance":45,"id":186716,"goal":"lemma SeqTakeDrop_45(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_46","instance":46,"id":186717,"goal":"lemma SeqReverseLen_46(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_47","instance":47,"id":186718,"goal":"lemma SeqReverseIdem_47(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_48","instance":48,"id":186719,"goal":"lemma SeqMapLen_48(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_49","instance":49,"id":186720,"goal":"lemma SeqFilterLe_49(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_50","instance":50,"id":186721,"goal":"lemma SeqMemberAppend_50(u: seq, xs: seq)\n ensures x in u + xs <==> x in u || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_51","instance":51,"id":186722,"goal":"lemma SeqAppendLen_51(ys: seq, zs: seq)\n ensures |ys + zs| == |ys| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_52","instance":52,"id":186723,"goal":"lemma SeqAppendNil_52(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_53","instance":53,"id":186724,"goal":"lemma SeqNilAppend_53(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_54","instance":54,"id":186725,"goal":"lemma SeqAppendAssoc_54(t: seq, zs: seq, s: seq)\n ensures (t + zs) + s == t + (zs + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_55","instance":55,"id":186726,"goal":"lemma SeqTakeDrop_55(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_56","instance":56,"id":186727,"goal":"lemma SeqReverseLen_56(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_57","instance":57,"id":186728,"goal":"lemma SeqReverseIdem_57(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_58","instance":58,"id":186729,"goal":"lemma SeqMapLen_58(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_59","instance":59,"id":186730,"goal":"lemma SeqFilterLe_59(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_60","instance":60,"id":186731,"goal":"lemma SeqMemberAppend_60(u: seq, zs: seq)\n ensures x in u + zs <==> x in u || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_61","instance":61,"id":186732,"goal":"lemma SeqAppendLen_61(t: seq, ys: seq)\n ensures |t + ys| == |t| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_62","instance":62,"id":186733,"goal":"lemma SeqAppendNil_62(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_63","instance":63,"id":186734,"goal":"lemma SeqNilAppend_63(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_64","instance":64,"id":186735,"goal":"lemma SeqAppendAssoc_64(u: seq, s: seq, xs: seq)\n ensures (u + s) + xs == u + (s + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_65","instance":65,"id":186736,"goal":"lemma SeqTakeDrop_65(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_66","instance":66,"id":186737,"goal":"lemma SeqReverseLen_66(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_67","instance":67,"id":186738,"goal":"lemma SeqReverseIdem_67(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_68","instance":68,"id":186739,"goal":"lemma SeqMapLen_68(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_69","instance":69,"id":186740,"goal":"lemma SeqFilterLe_69(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_70","instance":70,"id":186741,"goal":"lemma SeqMemberAppend_70(zs: seq, xs: seq)\n ensures x in zs + xs <==> x in zs || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_71","instance":71,"id":186742,"goal":"lemma SeqAppendLen_71(t: seq, u: seq)\n ensures |t + u| == |t| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_72","instance":72,"id":186743,"goal":"lemma SeqAppendNil_72(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_73","instance":73,"id":186744,"goal":"lemma SeqNilAppend_73(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_74","instance":74,"id":186745,"goal":"lemma SeqAppendAssoc_74(xs: seq, ys: seq, zs: seq)\n ensures (xs + ys) + zs == xs + (ys + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_75","instance":75,"id":186746,"goal":"lemma SeqTakeDrop_75(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_76","instance":76,"id":186747,"goal":"lemma SeqReverseLen_76(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_77","instance":77,"id":186748,"goal":"lemma SeqReverseIdem_77(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_78","instance":78,"id":186749,"goal":"lemma SeqMapLen_78(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_79","instance":79,"id":186750,"goal":"lemma SeqFilterLe_79(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_80","instance":80,"id":186751,"goal":"lemma SeqMemberAppend_80(s: seq, t: seq)\n ensures x in s + t <==> x in s || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_81","instance":81,"id":186752,"goal":"lemma SeqAppendLen_81(t: seq, xs: seq)\n ensures |t + xs| == |t| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_82","instance":82,"id":186753,"goal":"lemma SeqAppendNil_82(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_83","instance":83,"id":186754,"goal":"lemma SeqNilAppend_83(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_84","instance":84,"id":186755,"goal":"lemma SeqAppendAssoc_84(u: seq, ys: seq, t: seq)\n ensures (u + ys) + t == u + (ys + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_85","instance":85,"id":186756,"goal":"lemma SeqTakeDrop_85(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_86","instance":86,"id":186757,"goal":"lemma SeqReverseLen_86(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_87","instance":87,"id":186758,"goal":"lemma SeqReverseIdem_87(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_88","instance":88,"id":186759,"goal":"lemma SeqMapLen_88(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_89","instance":89,"id":186760,"goal":"lemma SeqFilterLe_89(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_90","instance":90,"id":186761,"goal":"lemma SeqMemberAppend_90(u: seq, zs: seq)\n ensures x in u + zs <==> x in u || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_91","instance":91,"id":186762,"goal":"lemma SeqAppendLen_91(u: seq, xs: seq)\n ensures |u + xs| == |u| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_92","instance":92,"id":186763,"goal":"lemma SeqAppendNil_92(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_93","instance":93,"id":186764,"goal":"lemma SeqNilAppend_93(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_94","instance":94,"id":186765,"goal":"lemma SeqAppendAssoc_94(xs: seq, u: seq, t: seq)\n ensures (xs + u) + t == xs + (u + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_95","instance":95,"id":186766,"goal":"lemma SeqTakeDrop_95(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_96","instance":96,"id":186767,"goal":"lemma SeqReverseLen_96(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_97","instance":97,"id":186768,"goal":"lemma SeqReverseIdem_97(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_98","instance":98,"id":186769,"goal":"lemma SeqMapLen_98(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_99","instance":99,"id":186770,"goal":"lemma SeqFilterLe_99(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_100","instance":100,"id":186771,"goal":"lemma SeqMemberAppend_100(ys: seq, zs: seq)\n ensures x in ys + zs <==> x in ys || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_101","instance":101,"id":186772,"goal":"lemma SeqAppendLen_101(ys: seq, t: seq)\n ensures |ys + t| == |ys| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_102","instance":102,"id":186773,"goal":"lemma SeqAppendNil_102(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_103","instance":103,"id":186774,"goal":"lemma SeqNilAppend_103(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_104","instance":104,"id":186775,"goal":"lemma SeqAppendAssoc_104(xs: seq, u: seq, s: seq)\n ensures (xs + u) + s == xs + (u + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_105","instance":105,"id":186776,"goal":"lemma SeqTakeDrop_105(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_106","instance":106,"id":186777,"goal":"lemma SeqReverseLen_106(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_107","instance":107,"id":186778,"goal":"lemma SeqReverseIdem_107(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_108","instance":108,"id":186779,"goal":"lemma SeqMapLen_108(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_109","instance":109,"id":186780,"goal":"lemma SeqFilterLe_109(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_110","instance":110,"id":186781,"goal":"lemma SeqMemberAppend_110(s: seq, t: seq)\n ensures x in s + t <==> x in s || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_111","instance":111,"id":186782,"goal":"lemma SeqAppendLen_111(xs: seq, ys: seq)\n ensures |xs + ys| == |xs| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_112","instance":112,"id":186783,"goal":"lemma SeqAppendNil_112(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_113","instance":113,"id":186784,"goal":"lemma SeqNilAppend_113(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_114","instance":114,"id":186785,"goal":"lemma SeqAppendAssoc_114(xs: seq, zs: seq, t: seq)\n ensures (xs + zs) + t == xs + (zs + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_115","instance":115,"id":186786,"goal":"lemma SeqTakeDrop_115(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_116","instance":116,"id":186787,"goal":"lemma SeqReverseLen_116(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_117","instance":117,"id":186788,"goal":"lemma SeqReverseIdem_117(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_118","instance":118,"id":186789,"goal":"lemma SeqMapLen_118(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_119","instance":119,"id":186790,"goal":"lemma SeqFilterLe_119(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_120","instance":120,"id":186791,"goal":"lemma SeqMemberAppend_120(xs: seq, s: seq)\n ensures x in xs + s <==> x in xs || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_121","instance":121,"id":186792,"goal":"lemma SeqAppendLen_121(t: seq, zs: seq)\n ensures |t + zs| == |t| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_122","instance":122,"id":186793,"goal":"lemma SeqAppendNil_122(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_123","instance":123,"id":186794,"goal":"lemma SeqNilAppend_123(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_124","instance":124,"id":186795,"goal":"lemma SeqAppendAssoc_124(u: seq, t: seq, zs: seq)\n ensures (u + t) + zs == u + (t + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_125","instance":125,"id":186796,"goal":"lemma SeqTakeDrop_125(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_126","instance":126,"id":186797,"goal":"lemma SeqReverseLen_126(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_127","instance":127,"id":186798,"goal":"lemma SeqReverseIdem_127(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_128","instance":128,"id":186799,"goal":"lemma SeqMapLen_128(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_129","instance":129,"id":186800,"goal":"lemma SeqFilterLe_129(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_130","instance":130,"id":186801,"goal":"lemma SeqMemberAppend_130(ys: seq, s: seq)\n ensures x in ys + s <==> x in ys || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_131","instance":131,"id":186802,"goal":"lemma SeqAppendLen_131(s: seq, t: seq)\n ensures |s + t| == |s| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_132","instance":132,"id":186803,"goal":"lemma SeqAppendNil_132(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_133","instance":133,"id":186804,"goal":"lemma SeqNilAppend_133(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_134","instance":134,"id":186805,"goal":"lemma SeqAppendAssoc_134(zs: seq, t: seq, s: seq)\n ensures (zs + t) + s == zs + (t + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_135","instance":135,"id":186806,"goal":"lemma SeqTakeDrop_135(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_136","instance":136,"id":186807,"goal":"lemma SeqReverseLen_136(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_137","instance":137,"id":186808,"goal":"lemma SeqReverseIdem_137(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_138","instance":138,"id":186809,"goal":"lemma SeqMapLen_138(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_139","instance":139,"id":186810,"goal":"lemma SeqFilterLe_139(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_140","instance":140,"id":186811,"goal":"lemma SeqMemberAppend_140(zs: seq, s: seq)\n ensures x in zs + s <==> x in zs || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_141","instance":141,"id":186812,"goal":"lemma SeqAppendLen_141(ys: seq, s: seq)\n ensures |ys + s| == |ys| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_142","instance":142,"id":186813,"goal":"lemma SeqAppendNil_142(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_143","instance":143,"id":186814,"goal":"lemma SeqNilAppend_143(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_144","instance":144,"id":186815,"goal":"lemma SeqAppendAssoc_144(ys: seq, u: seq, xs: seq)\n ensures (ys + u) + xs == ys + (u + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_145","instance":145,"id":186816,"goal":"lemma SeqTakeDrop_145(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_146","instance":146,"id":186817,"goal":"lemma SeqReverseLen_146(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_147","instance":147,"id":186818,"goal":"lemma SeqReverseIdem_147(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_148","instance":148,"id":186819,"goal":"lemma SeqMapLen_148(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_149","instance":149,"id":186820,"goal":"lemma SeqFilterLe_149(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_150","instance":150,"id":186821,"goal":"lemma SeqMemberAppend_150(ys: seq, zs: seq)\n ensures x in ys + zs <==> x in ys || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_151","instance":151,"id":186822,"goal":"lemma SeqAppendLen_151(zs: seq, u: seq)\n ensures |zs + u| == |zs| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_152","instance":152,"id":186823,"goal":"lemma SeqAppendNil_152(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_153","instance":153,"id":186824,"goal":"lemma SeqNilAppend_153(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_154","instance":154,"id":186825,"goal":"lemma SeqAppendAssoc_154(xs: seq, u: seq, t: seq)\n ensures (xs + u) + t == xs + (u + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_155","instance":155,"id":186826,"goal":"lemma SeqTakeDrop_155(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_156","instance":156,"id":186827,"goal":"lemma SeqReverseLen_156(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_157","instance":157,"id":186828,"goal":"lemma SeqReverseIdem_157(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_158","instance":158,"id":186829,"goal":"lemma SeqMapLen_158(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_159","instance":159,"id":186830,"goal":"lemma SeqFilterLe_159(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_160","instance":160,"id":186831,"goal":"lemma SeqMemberAppend_160(t: seq, u: seq)\n ensures x in t + u <==> x in t || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_161","instance":161,"id":186832,"goal":"lemma SeqAppendLen_161(u: seq, xs: seq)\n ensures |u + xs| == |u| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_162","instance":162,"id":186833,"goal":"lemma SeqAppendNil_162(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_163","instance":163,"id":186834,"goal":"lemma SeqNilAppend_163(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_164","instance":164,"id":186835,"goal":"lemma SeqAppendAssoc_164(ys: seq, xs: seq, zs: seq)\n ensures (ys + xs) + zs == ys + (xs + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_165","instance":165,"id":186836,"goal":"lemma SeqTakeDrop_165(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_166","instance":166,"id":186837,"goal":"lemma SeqReverseLen_166(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_167","instance":167,"id":186838,"goal":"lemma SeqReverseIdem_167(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_168","instance":168,"id":186839,"goal":"lemma SeqMapLen_168(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_169","instance":169,"id":186840,"goal":"lemma SeqFilterLe_169(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_170","instance":170,"id":186841,"goal":"lemma SeqMemberAppend_170(s: seq, ys: seq)\n ensures x in s + ys <==> x in s || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_171","instance":171,"id":186842,"goal":"lemma SeqAppendLen_171(s: seq, u: seq)\n ensures |s + u| == |s| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_172","instance":172,"id":186843,"goal":"lemma SeqAppendNil_172(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_173","instance":173,"id":186844,"goal":"lemma SeqNilAppend_173(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_174","instance":174,"id":186845,"goal":"lemma SeqAppendAssoc_174(xs: seq, t: seq, s: seq)\n ensures (xs + t) + s == xs + (t + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_175","instance":175,"id":186846,"goal":"lemma SeqTakeDrop_175(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_176","instance":176,"id":186847,"goal":"lemma SeqReverseLen_176(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_177","instance":177,"id":186848,"goal":"lemma SeqReverseIdem_177(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_178","instance":178,"id":186849,"goal":"lemma SeqMapLen_178(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_179","instance":179,"id":186850,"goal":"lemma SeqFilterLe_179(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_180","instance":180,"id":186851,"goal":"lemma SeqMemberAppend_180(zs: seq, u: seq)\n ensures x in zs + u <==> x in zs || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_181","instance":181,"id":186852,"goal":"lemma SeqAppendLen_181(zs: seq, t: seq)\n ensures |zs + t| == |zs| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_182","instance":182,"id":186853,"goal":"lemma SeqAppendNil_182(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_183","instance":183,"id":186854,"goal":"lemma SeqNilAppend_183(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_184","instance":184,"id":186855,"goal":"lemma SeqAppendAssoc_184(ys: seq, t: seq, u: seq)\n ensures (ys + t) + u == ys + (t + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_185","instance":185,"id":186856,"goal":"lemma SeqTakeDrop_185(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_186","instance":186,"id":186857,"goal":"lemma SeqReverseLen_186(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_187","instance":187,"id":186858,"goal":"lemma SeqReverseIdem_187(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_188","instance":188,"id":186859,"goal":"lemma SeqMapLen_188(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_189","instance":189,"id":186860,"goal":"lemma SeqFilterLe_189(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_190","instance":190,"id":186861,"goal":"lemma SeqMemberAppend_190(zs: seq, t: seq)\n ensures x in zs + t <==> x in zs || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_191","instance":191,"id":186862,"goal":"lemma SeqAppendLen_191(xs: seq, zs: seq)\n ensures |xs + zs| == |xs| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_192","instance":192,"id":186863,"goal":"lemma SeqAppendNil_192(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_193","instance":193,"id":186864,"goal":"lemma SeqNilAppend_193(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_194","instance":194,"id":186865,"goal":"lemma SeqAppendAssoc_194(xs: seq, s: seq, zs: seq)\n ensures (xs + s) + zs == xs + (s + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_195","instance":195,"id":186866,"goal":"lemma SeqTakeDrop_195(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_196","instance":196,"id":186867,"goal":"lemma SeqReverseLen_196(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_197","instance":197,"id":186868,"goal":"lemma SeqReverseIdem_197(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_198","instance":198,"id":186869,"goal":"lemma SeqMapLen_198(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_199","instance":199,"id":186870,"goal":"lemma SeqFilterLe_199(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_200","instance":200,"id":186871,"goal":"lemma SeqMemberAppend_200(zs: seq, t: seq)\n ensures x in zs + t <==> x in zs || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_201","instance":201,"id":186872,"goal":"lemma SeqAppendLen_201(s: seq, ys: seq)\n ensures |s + ys| == |s| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_202","instance":202,"id":186873,"goal":"lemma SeqAppendNil_202(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_203","instance":203,"id":186874,"goal":"lemma SeqNilAppend_203(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_204","instance":204,"id":186875,"goal":"lemma SeqAppendAssoc_204(xs: seq, ys: seq, u: seq)\n ensures (xs + ys) + u == xs + (ys + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_205","instance":205,"id":186876,"goal":"lemma SeqTakeDrop_205(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_206","instance":206,"id":186877,"goal":"lemma SeqReverseLen_206(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_207","instance":207,"id":186878,"goal":"lemma SeqReverseIdem_207(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_208","instance":208,"id":186879,"goal":"lemma SeqMapLen_208(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_209","instance":209,"id":186880,"goal":"lemma SeqFilterLe_209(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_210","instance":210,"id":186881,"goal":"lemma SeqMemberAppend_210(ys: seq, xs: seq)\n ensures x in ys + xs <==> x in ys || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_211","instance":211,"id":186882,"goal":"lemma SeqAppendLen_211(u: seq, ys: seq)\n ensures |u + ys| == |u| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_212","instance":212,"id":186883,"goal":"lemma SeqAppendNil_212(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_213","instance":213,"id":186884,"goal":"lemma SeqNilAppend_213(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_214","instance":214,"id":186885,"goal":"lemma SeqAppendAssoc_214(t: seq, zs: seq, u: seq)\n ensures (t + zs) + u == t + (zs + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_215","instance":215,"id":186886,"goal":"lemma SeqTakeDrop_215(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_216","instance":216,"id":186887,"goal":"lemma SeqReverseLen_216(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_217","instance":217,"id":186888,"goal":"lemma SeqReverseIdem_217(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_218","instance":218,"id":186889,"goal":"lemma SeqMapLen_218(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_219","instance":219,"id":186890,"goal":"lemma SeqFilterLe_219(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_220","instance":220,"id":186891,"goal":"lemma SeqMemberAppend_220(t: seq, u: seq)\n ensures x in t + u <==> x in t || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_221","instance":221,"id":186892,"goal":"lemma SeqAppendLen_221(zs: seq, xs: seq)\n ensures |zs + xs| == |zs| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_222","instance":222,"id":186893,"goal":"lemma SeqAppendNil_222(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_223","instance":223,"id":186894,"goal":"lemma SeqNilAppend_223(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_224","instance":224,"id":186895,"goal":"lemma SeqAppendAssoc_224(xs: seq, ys: seq, t: seq)\n ensures (xs + ys) + t == xs + (ys + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_225","instance":225,"id":186896,"goal":"lemma SeqTakeDrop_225(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_226","instance":226,"id":186897,"goal":"lemma SeqReverseLen_226(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_227","instance":227,"id":186898,"goal":"lemma SeqReverseIdem_227(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_228","instance":228,"id":186899,"goal":"lemma SeqMapLen_228(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_229","instance":229,"id":186900,"goal":"lemma SeqFilterLe_229(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_230","instance":230,"id":186901,"goal":"lemma SeqMemberAppend_230(t: seq, u: seq)\n ensures x in t + u <==> x in t || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_231","instance":231,"id":186902,"goal":"lemma SeqAppendLen_231(s: seq, u: seq)\n ensures |s + u| == |s| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_232","instance":232,"id":186903,"goal":"lemma SeqAppendNil_232(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_233","instance":233,"id":186904,"goal":"lemma SeqNilAppend_233(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_234","instance":234,"id":186905,"goal":"lemma SeqAppendAssoc_234(ys: seq, s: seq, xs: seq)\n ensures (ys + s) + xs == ys + (s + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_235","instance":235,"id":186906,"goal":"lemma SeqTakeDrop_235(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_236","instance":236,"id":186907,"goal":"lemma SeqReverseLen_236(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_237","instance":237,"id":186908,"goal":"lemma SeqReverseIdem_237(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_238","instance":238,"id":186909,"goal":"lemma SeqMapLen_238(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_239","instance":239,"id":186910,"goal":"lemma SeqFilterLe_239(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_240","instance":240,"id":186911,"goal":"lemma SeqMemberAppend_240(zs: seq, xs: seq)\n ensures x in zs + xs <==> x in zs || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_241","instance":241,"id":186912,"goal":"lemma SeqAppendLen_241(ys: seq, s: seq)\n ensures |ys + s| == |ys| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_242","instance":242,"id":186913,"goal":"lemma SeqAppendNil_242(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_243","instance":243,"id":186914,"goal":"lemma SeqNilAppend_243(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_244","instance":244,"id":186915,"goal":"lemma SeqAppendAssoc_244(t: seq, u: seq, ys: seq)\n ensures (t + u) + ys == t + (u + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_245","instance":245,"id":186916,"goal":"lemma SeqTakeDrop_245(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_246","instance":246,"id":186917,"goal":"lemma SeqReverseLen_246(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_247","instance":247,"id":186918,"goal":"lemma SeqReverseIdem_247(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_248","instance":248,"id":186919,"goal":"lemma SeqMapLen_248(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_249","instance":249,"id":186920,"goal":"lemma SeqFilterLe_249(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_250","instance":250,"id":186921,"goal":"lemma SeqMemberAppend_250(t: seq, s: seq)\n ensures x in t + s <==> x in t || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_251","instance":251,"id":186922,"goal":"lemma SeqAppendLen_251(t: seq, ys: seq)\n ensures |t + ys| == |t| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_252","instance":252,"id":186923,"goal":"lemma SeqAppendNil_252(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_253","instance":253,"id":186924,"goal":"lemma SeqNilAppend_253(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_254","instance":254,"id":186925,"goal":"lemma SeqAppendAssoc_254(u: seq, zs: seq, t: seq)\n ensures (u + zs) + t == u + (zs + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_255","instance":255,"id":186926,"goal":"lemma SeqTakeDrop_255(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_256","instance":256,"id":186927,"goal":"lemma SeqReverseLen_256(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_257","instance":257,"id":186928,"goal":"lemma SeqReverseIdem_257(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_258","instance":258,"id":186929,"goal":"lemma SeqMapLen_258(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_259","instance":259,"id":186930,"goal":"lemma SeqFilterLe_259(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_260","instance":260,"id":186931,"goal":"lemma SeqMemberAppend_260(xs: seq, u: seq)\n ensures x in xs + u <==> x in xs || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_261","instance":261,"id":186932,"goal":"lemma SeqAppendLen_261(u: seq, s: seq)\n ensures |u + s| == |u| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_262","instance":262,"id":186933,"goal":"lemma SeqAppendNil_262(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_263","instance":263,"id":186934,"goal":"lemma SeqNilAppend_263(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_264","instance":264,"id":186935,"goal":"lemma SeqAppendAssoc_264(t: seq, zs: seq, s: seq)\n ensures (t + zs) + s == t + (zs + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_265","instance":265,"id":186936,"goal":"lemma SeqTakeDrop_265(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_266","instance":266,"id":186937,"goal":"lemma SeqReverseLen_266(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_267","instance":267,"id":186938,"goal":"lemma SeqReverseIdem_267(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_268","instance":268,"id":186939,"goal":"lemma SeqMapLen_268(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_269","instance":269,"id":186940,"goal":"lemma SeqFilterLe_269(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_270","instance":270,"id":186941,"goal":"lemma SeqMemberAppend_270(t: seq, s: seq)\n ensures x in t + s <==> x in t || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_271","instance":271,"id":186942,"goal":"lemma SeqAppendLen_271(t: seq, xs: seq)\n ensures |t + xs| == |t| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_272","instance":272,"id":186943,"goal":"lemma SeqAppendNil_272(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_273","instance":273,"id":186944,"goal":"lemma SeqNilAppend_273(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_274","instance":274,"id":186945,"goal":"lemma SeqAppendAssoc_274(u: seq, s: seq, zs: seq)\n ensures (u + s) + zs == u + (s + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_275","instance":275,"id":186946,"goal":"lemma SeqTakeDrop_275(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_276","instance":276,"id":186947,"goal":"lemma SeqReverseLen_276(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_277","instance":277,"id":186948,"goal":"lemma SeqReverseIdem_277(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_278","instance":278,"id":186949,"goal":"lemma SeqMapLen_278(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_279","instance":279,"id":186950,"goal":"lemma SeqFilterLe_279(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_280","instance":280,"id":186951,"goal":"lemma SeqMemberAppend_280(s: seq, zs: seq)\n ensures x in s + zs <==> x in s || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_281","instance":281,"id":186952,"goal":"lemma SeqAppendLen_281(zs: seq, xs: seq)\n ensures |zs + xs| == |zs| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_282","instance":282,"id":186953,"goal":"lemma SeqAppendNil_282(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_283","instance":283,"id":186954,"goal":"lemma SeqNilAppend_283(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_284","instance":284,"id":186955,"goal":"lemma SeqAppendAssoc_284(t: seq, xs: seq, s: seq)\n ensures (t + xs) + s == t + (xs + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_285","instance":285,"id":186956,"goal":"lemma SeqTakeDrop_285(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_286","instance":286,"id":186957,"goal":"lemma SeqReverseLen_286(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_287","instance":287,"id":186958,"goal":"lemma SeqReverseIdem_287(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_288","instance":288,"id":186959,"goal":"lemma SeqMapLen_288(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_289","instance":289,"id":186960,"goal":"lemma SeqFilterLe_289(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_290","instance":290,"id":186961,"goal":"lemma SeqMemberAppend_290(xs: seq, s: seq)\n ensures x in xs + s <==> x in xs || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_291","instance":291,"id":186962,"goal":"lemma SeqAppendLen_291(zs: seq, s: seq)\n ensures |zs + s| == |zs| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_292","instance":292,"id":186963,"goal":"lemma SeqAppendNil_292(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_293","instance":293,"id":186964,"goal":"lemma SeqNilAppend_293(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_294","instance":294,"id":186965,"goal":"lemma SeqAppendAssoc_294(s: seq, t: seq, u: seq)\n ensures (s + t) + u == s + (t + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_295","instance":295,"id":186966,"goal":"lemma SeqTakeDrop_295(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_296","instance":296,"id":186967,"goal":"lemma SeqReverseLen_296(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_297","instance":297,"id":186968,"goal":"lemma SeqReverseIdem_297(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_298","instance":298,"id":186969,"goal":"lemma SeqMapLen_298(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_299","instance":299,"id":186970,"goal":"lemma SeqFilterLe_299(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_300","instance":300,"id":186971,"goal":"lemma SeqMemberAppend_300(u: seq, zs: seq)\n ensures x in u + zs <==> x in u || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_301","instance":301,"id":186972,"goal":"lemma SeqAppendLen_301(t: seq, s: seq)\n ensures |t + s| == |t| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_302","instance":302,"id":186973,"goal":"lemma SeqAppendNil_302(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_303","instance":303,"id":186974,"goal":"lemma SeqNilAppend_303(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_304","instance":304,"id":186975,"goal":"lemma SeqAppendAssoc_304(ys: seq, s: seq, zs: seq)\n ensures (ys + s) + zs == ys + (s + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_305","instance":305,"id":186976,"goal":"lemma SeqTakeDrop_305(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_306","instance":306,"id":186977,"goal":"lemma SeqReverseLen_306(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_307","instance":307,"id":186978,"goal":"lemma SeqReverseIdem_307(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_308","instance":308,"id":186979,"goal":"lemma SeqMapLen_308(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_309","instance":309,"id":186980,"goal":"lemma SeqFilterLe_309(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_310","instance":310,"id":186981,"goal":"lemma SeqMemberAppend_310(xs: seq, u: seq)\n ensures x in xs + u <==> x in xs || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_311","instance":311,"id":186982,"goal":"lemma SeqAppendLen_311(xs: seq, zs: seq)\n ensures |xs + zs| == |xs| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_312","instance":312,"id":186983,"goal":"lemma SeqAppendNil_312(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_313","instance":313,"id":186984,"goal":"lemma SeqNilAppend_313(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_314","instance":314,"id":186985,"goal":"lemma SeqAppendAssoc_314(u: seq, zs: seq, xs: seq)\n ensures (u + zs) + xs == u + (zs + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_315","instance":315,"id":186986,"goal":"lemma SeqTakeDrop_315(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_316","instance":316,"id":186987,"goal":"lemma SeqReverseLen_316(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_317","instance":317,"id":186988,"goal":"lemma SeqReverseIdem_317(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_318","instance":318,"id":186989,"goal":"lemma SeqMapLen_318(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_319","instance":319,"id":186990,"goal":"lemma SeqFilterLe_319(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_320","instance":320,"id":186991,"goal":"lemma SeqMemberAppend_320(xs: seq, ys: seq)\n ensures x in xs + ys <==> x in xs || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_321","instance":321,"id":186992,"goal":"lemma SeqAppendLen_321(u: seq, zs: seq)\n ensures |u + zs| == |u| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_322","instance":322,"id":186993,"goal":"lemma SeqAppendNil_322(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_323","instance":323,"id":186994,"goal":"lemma SeqNilAppend_323(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_324","instance":324,"id":186995,"goal":"lemma SeqAppendAssoc_324(zs: seq, t: seq, ys: seq)\n ensures (zs + t) + ys == zs + (t + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_325","instance":325,"id":186996,"goal":"lemma SeqTakeDrop_325(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_326","instance":326,"id":186997,"goal":"lemma SeqReverseLen_326(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_327","instance":327,"id":186998,"goal":"lemma SeqReverseIdem_327(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_328","instance":328,"id":186999,"goal":"lemma SeqMapLen_328(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_329","instance":329,"id":187000,"goal":"lemma SeqFilterLe_329(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_330","instance":330,"id":187001,"goal":"lemma SeqMemberAppend_330(s: seq, u: seq)\n ensures x in s + u <==> x in s || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_331","instance":331,"id":187002,"goal":"lemma SeqAppendLen_331(xs: seq, ys: seq)\n ensures |xs + ys| == |xs| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_332","instance":332,"id":187003,"goal":"lemma SeqAppendNil_332(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_333","instance":333,"id":187004,"goal":"lemma SeqNilAppend_333(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_334","instance":334,"id":187005,"goal":"lemma SeqAppendAssoc_334(t: seq, ys: seq, zs: seq)\n ensures (t + ys) + zs == t + (ys + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_335","instance":335,"id":187006,"goal":"lemma SeqTakeDrop_335(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_336","instance":336,"id":187007,"goal":"lemma SeqReverseLen_336(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_337","instance":337,"id":187008,"goal":"lemma SeqReverseIdem_337(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_338","instance":338,"id":187009,"goal":"lemma SeqMapLen_338(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_339","instance":339,"id":187010,"goal":"lemma SeqFilterLe_339(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_340","instance":340,"id":187011,"goal":"lemma SeqMemberAppend_340(t: seq, s: seq)\n ensures x in t + s <==> x in t || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_341","instance":341,"id":187012,"goal":"lemma SeqAppendLen_341(zs: seq, xs: seq)\n ensures |zs + xs| == |zs| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_342","instance":342,"id":187013,"goal":"lemma SeqAppendNil_342(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_343","instance":343,"id":187014,"goal":"lemma SeqNilAppend_343(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_344","instance":344,"id":187015,"goal":"lemma SeqAppendAssoc_344(u: seq, t: seq, s: seq)\n ensures (u + t) + s == u + (t + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_345","instance":345,"id":187016,"goal":"lemma SeqTakeDrop_345(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_346","instance":346,"id":187017,"goal":"lemma SeqReverseLen_346(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_347","instance":347,"id":187018,"goal":"lemma SeqReverseIdem_347(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_348","instance":348,"id":187019,"goal":"lemma SeqMapLen_348(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_349","instance":349,"id":187020,"goal":"lemma SeqFilterLe_349(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_350","instance":350,"id":187021,"goal":"lemma SeqMemberAppend_350(s: seq, t: seq)\n ensures x in s + t <==> x in s || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_351","instance":351,"id":187022,"goal":"lemma SeqAppendLen_351(t: seq, ys: seq)\n ensures |t + ys| == |t| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_352","instance":352,"id":187023,"goal":"lemma SeqAppendNil_352(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_353","instance":353,"id":187024,"goal":"lemma SeqNilAppend_353(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_354","instance":354,"id":187025,"goal":"lemma SeqAppendAssoc_354(ys: seq, u: seq, xs: seq)\n ensures (ys + u) + xs == ys + (u + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_355","instance":355,"id":187026,"goal":"lemma SeqTakeDrop_355(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_356","instance":356,"id":187027,"goal":"lemma SeqReverseLen_356(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_357","instance":357,"id":187028,"goal":"lemma SeqReverseIdem_357(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_358","instance":358,"id":187029,"goal":"lemma SeqMapLen_358(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_359","instance":359,"id":187030,"goal":"lemma SeqFilterLe_359(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_360","instance":360,"id":187031,"goal":"lemma SeqMemberAppend_360(t: seq, u: seq)\n ensures x in t + u <==> x in t || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_361","instance":361,"id":187032,"goal":"lemma SeqAppendLen_361(t: seq, xs: seq)\n ensures |t + xs| == |t| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_362","instance":362,"id":187033,"goal":"lemma SeqAppendNil_362(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_363","instance":363,"id":187034,"goal":"lemma SeqNilAppend_363(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_364","instance":364,"id":187035,"goal":"lemma SeqAppendAssoc_364(xs: seq, zs: seq, u: seq)\n ensures (xs + zs) + u == xs + (zs + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_365","instance":365,"id":187036,"goal":"lemma SeqTakeDrop_365(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_366","instance":366,"id":187037,"goal":"lemma SeqReverseLen_366(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_367","instance":367,"id":187038,"goal":"lemma SeqReverseIdem_367(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_368","instance":368,"id":187039,"goal":"lemma SeqMapLen_368(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_369","instance":369,"id":187040,"goal":"lemma SeqFilterLe_369(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_370","instance":370,"id":187041,"goal":"lemma SeqMemberAppend_370(xs: seq, s: seq)\n ensures x in xs + s <==> x in xs || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_371","instance":371,"id":187042,"goal":"lemma SeqAppendLen_371(xs: seq, u: seq)\n ensures |xs + u| == |xs| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_372","instance":372,"id":187043,"goal":"lemma SeqAppendNil_372(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_373","instance":373,"id":187044,"goal":"lemma SeqNilAppend_373(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_374","instance":374,"id":187045,"goal":"lemma SeqAppendAssoc_374(xs: seq, zs: seq, u: seq)\n ensures (xs + zs) + u == xs + (zs + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_375","instance":375,"id":187046,"goal":"lemma SeqTakeDrop_375(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_376","instance":376,"id":187047,"goal":"lemma SeqReverseLen_376(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_377","instance":377,"id":187048,"goal":"lemma SeqReverseIdem_377(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_378","instance":378,"id":187049,"goal":"lemma SeqMapLen_378(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_379","instance":379,"id":187050,"goal":"lemma SeqFilterLe_379(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_380","instance":380,"id":187051,"goal":"lemma SeqMemberAppend_380(xs: seq, zs: seq)\n ensures x in xs + zs <==> x in xs || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_381","instance":381,"id":187052,"goal":"lemma SeqAppendLen_381(s: seq, ys: seq)\n ensures |s + ys| == |s| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_382","instance":382,"id":187053,"goal":"lemma SeqAppendNil_382(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_383","instance":383,"id":187054,"goal":"lemma SeqNilAppend_383(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_384","instance":384,"id":187055,"goal":"lemma SeqAppendAssoc_384(ys: seq, xs: seq, s: seq)\n ensures (ys + xs) + s == ys + (xs + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_385","instance":385,"id":187056,"goal":"lemma SeqTakeDrop_385(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_386","instance":386,"id":187057,"goal":"lemma SeqReverseLen_386(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_387","instance":387,"id":187058,"goal":"lemma SeqReverseIdem_387(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_388","instance":388,"id":187059,"goal":"lemma SeqMapLen_388(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_389","instance":389,"id":187060,"goal":"lemma SeqFilterLe_389(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_390","instance":390,"id":187061,"goal":"lemma SeqMemberAppend_390(s: seq, t: seq)\n ensures x in s + t <==> x in s || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_391","instance":391,"id":187062,"goal":"lemma SeqAppendLen_391(u: seq, zs: seq)\n ensures |u + zs| == |u| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_392","instance":392,"id":187063,"goal":"lemma SeqAppendNil_392(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_393","instance":393,"id":187064,"goal":"lemma SeqNilAppend_393(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_394","instance":394,"id":187065,"goal":"lemma SeqAppendAssoc_394(xs: seq, ys: seq, zs: seq)\n ensures (xs + ys) + zs == xs + (ys + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_395","instance":395,"id":187066,"goal":"lemma SeqTakeDrop_395(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_396","instance":396,"id":187067,"goal":"lemma SeqReverseLen_396(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_397","instance":397,"id":187068,"goal":"lemma SeqReverseIdem_397(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_398","instance":398,"id":187069,"goal":"lemma SeqMapLen_398(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_399","instance":399,"id":187070,"goal":"lemma SeqFilterLe_399(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_400","instance":400,"id":187071,"goal":"lemma SeqMemberAppend_400(zs: seq, s: seq)\n ensures x in zs + s <==> x in zs || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_401","instance":401,"id":187072,"goal":"lemma SeqAppendLen_401(u: seq, zs: seq)\n ensures |u + zs| == |u| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_402","instance":402,"id":187073,"goal":"lemma SeqAppendNil_402(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_403","instance":403,"id":187074,"goal":"lemma SeqNilAppend_403(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_404","instance":404,"id":187075,"goal":"lemma SeqAppendAssoc_404(xs: seq, u: seq, zs: seq)\n ensures (xs + u) + zs == xs + (u + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_405","instance":405,"id":187076,"goal":"lemma SeqTakeDrop_405(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_406","instance":406,"id":187077,"goal":"lemma SeqReverseLen_406(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_407","instance":407,"id":187078,"goal":"lemma SeqReverseIdem_407(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_408","instance":408,"id":187079,"goal":"lemma SeqMapLen_408(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_409","instance":409,"id":187080,"goal":"lemma SeqFilterLe_409(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_410","instance":410,"id":187081,"goal":"lemma SeqMemberAppend_410(t: seq, u: seq)\n ensures x in t + u <==> x in t || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_411","instance":411,"id":187082,"goal":"lemma SeqAppendLen_411(u: seq, s: seq)\n ensures |u + s| == |u| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_412","instance":412,"id":187083,"goal":"lemma SeqAppendNil_412(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_413","instance":413,"id":187084,"goal":"lemma SeqNilAppend_413(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_414","instance":414,"id":187085,"goal":"lemma SeqAppendAssoc_414(xs: seq, t: seq, zs: seq)\n ensures (xs + t) + zs == xs + (t + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_415","instance":415,"id":187086,"goal":"lemma SeqTakeDrop_415(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_416","instance":416,"id":187087,"goal":"lemma SeqReverseLen_416(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_417","instance":417,"id":187088,"goal":"lemma SeqReverseIdem_417(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_418","instance":418,"id":187089,"goal":"lemma SeqMapLen_418(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_419","instance":419,"id":187090,"goal":"lemma SeqFilterLe_419(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_420","instance":420,"id":187091,"goal":"lemma SeqMemberAppend_420(s: seq, ys: seq)\n ensures x in s + ys <==> x in s || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_421","instance":421,"id":187092,"goal":"lemma SeqAppendLen_421(s: seq, t: seq)\n ensures |s + t| == |s| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_422","instance":422,"id":187093,"goal":"lemma SeqAppendNil_422(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_423","instance":423,"id":187094,"goal":"lemma SeqNilAppend_423(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_424","instance":424,"id":187095,"goal":"lemma SeqAppendAssoc_424(s: seq, u: seq, t: seq)\n ensures (s + u) + t == s + (u + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_425","instance":425,"id":187096,"goal":"lemma SeqTakeDrop_425(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_426","instance":426,"id":187097,"goal":"lemma SeqReverseLen_426(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_427","instance":427,"id":187098,"goal":"lemma SeqReverseIdem_427(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_428","instance":428,"id":187099,"goal":"lemma SeqMapLen_428(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_429","instance":429,"id":187100,"goal":"lemma SeqFilterLe_429(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_430","instance":430,"id":187101,"goal":"lemma SeqMemberAppend_430(s: seq, xs: seq)\n ensures x in s + xs <==> x in s || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_431","instance":431,"id":187102,"goal":"lemma SeqAppendLen_431(zs: seq, s: seq)\n ensures |zs + s| == |zs| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_432","instance":432,"id":187103,"goal":"lemma SeqAppendNil_432(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_433","instance":433,"id":187104,"goal":"lemma SeqNilAppend_433(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_434","instance":434,"id":187105,"goal":"lemma SeqAppendAssoc_434(ys: seq, xs: seq, t: seq)\n ensures (ys + xs) + t == ys + (xs + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_435","instance":435,"id":187106,"goal":"lemma SeqTakeDrop_435(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_436","instance":436,"id":187107,"goal":"lemma SeqReverseLen_436(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_437","instance":437,"id":187108,"goal":"lemma SeqReverseIdem_437(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_438","instance":438,"id":187109,"goal":"lemma SeqMapLen_438(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_439","instance":439,"id":187110,"goal":"lemma SeqFilterLe_439(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_440","instance":440,"id":187111,"goal":"lemma SeqMemberAppend_440(s: seq, zs: seq)\n ensures x in s + zs <==> x in s || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_441","instance":441,"id":187112,"goal":"lemma SeqAppendLen_441(zs: seq, xs: seq)\n ensures |zs + xs| == |zs| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_442","instance":442,"id":187113,"goal":"lemma SeqAppendNil_442(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_443","instance":443,"id":187114,"goal":"lemma SeqNilAppend_443(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_444","instance":444,"id":187115,"goal":"lemma SeqAppendAssoc_444(zs: seq, s: seq, t: seq)\n ensures (zs + s) + t == zs + (s + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_445","instance":445,"id":187116,"goal":"lemma SeqTakeDrop_445(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_446","instance":446,"id":187117,"goal":"lemma SeqReverseLen_446(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_447","instance":447,"id":187118,"goal":"lemma SeqReverseIdem_447(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_448","instance":448,"id":187119,"goal":"lemma SeqMapLen_448(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_449","instance":449,"id":187120,"goal":"lemma SeqFilterLe_449(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_450","instance":450,"id":187121,"goal":"lemma SeqMemberAppend_450(xs: seq, t: seq)\n ensures x in xs + t <==> x in xs || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_451","instance":451,"id":187122,"goal":"lemma SeqAppendLen_451(u: seq, zs: seq)\n ensures |u + zs| == |u| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_452","instance":452,"id":187123,"goal":"lemma SeqAppendNil_452(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_453","instance":453,"id":187124,"goal":"lemma SeqNilAppend_453(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_454","instance":454,"id":187125,"goal":"lemma SeqAppendAssoc_454(t: seq, zs: seq, ys: seq)\n ensures (t + zs) + ys == t + (zs + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_455","instance":455,"id":187126,"goal":"lemma SeqTakeDrop_455(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_456","instance":456,"id":187127,"goal":"lemma SeqReverseLen_456(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_457","instance":457,"id":187128,"goal":"lemma SeqReverseIdem_457(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_458","instance":458,"id":187129,"goal":"lemma SeqMapLen_458(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_459","instance":459,"id":187130,"goal":"lemma SeqFilterLe_459(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_460","instance":460,"id":187131,"goal":"lemma SeqMemberAppend_460(u: seq, s: seq)\n ensures x in u + s <==> x in u || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_461","instance":461,"id":187132,"goal":"lemma SeqAppendLen_461(t: seq, xs: seq)\n ensures |t + xs| == |t| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_462","instance":462,"id":187133,"goal":"lemma SeqAppendNil_462(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_463","instance":463,"id":187134,"goal":"lemma SeqNilAppend_463(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_464","instance":464,"id":187135,"goal":"lemma SeqAppendAssoc_464(t: seq, u: seq, ys: seq)\n ensures (t + u) + ys == t + (u + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_465","instance":465,"id":187136,"goal":"lemma SeqTakeDrop_465(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_466","instance":466,"id":187137,"goal":"lemma SeqReverseLen_466(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_467","instance":467,"id":187138,"goal":"lemma SeqReverseIdem_467(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_468","instance":468,"id":187139,"goal":"lemma SeqMapLen_468(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_469","instance":469,"id":187140,"goal":"lemma SeqFilterLe_469(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_470","instance":470,"id":187141,"goal":"lemma SeqMemberAppend_470(s: seq, u: seq)\n ensures x in s + u <==> x in s || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_471","instance":471,"id":187142,"goal":"lemma SeqAppendLen_471(zs: seq, xs: seq)\n ensures |zs + xs| == |zs| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_472","instance":472,"id":187143,"goal":"lemma SeqAppendNil_472(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_473","instance":473,"id":187144,"goal":"lemma SeqNilAppend_473(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_474","instance":474,"id":187145,"goal":"lemma SeqAppendAssoc_474(zs: seq, ys: seq, u: seq)\n ensures (zs + ys) + u == zs + (ys + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_475","instance":475,"id":187146,"goal":"lemma SeqTakeDrop_475(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_476","instance":476,"id":187147,"goal":"lemma SeqReverseLen_476(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_477","instance":477,"id":187148,"goal":"lemma SeqReverseIdem_477(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_478","instance":478,"id":187149,"goal":"lemma SeqMapLen_478(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_479","instance":479,"id":187150,"goal":"lemma SeqFilterLe_479(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_480","instance":480,"id":187151,"goal":"lemma SeqMemberAppend_480(s: seq, ys: seq)\n ensures x in s + ys <==> x in s || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_481","instance":481,"id":187152,"goal":"lemma SeqAppendLen_481(xs: seq, s: seq)\n ensures |xs + s| == |xs| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_482","instance":482,"id":187153,"goal":"lemma SeqAppendNil_482(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_483","instance":483,"id":187154,"goal":"lemma SeqNilAppend_483(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_484","instance":484,"id":187155,"goal":"lemma SeqAppendAssoc_484(ys: seq, xs: seq, t: seq)\n ensures (ys + xs) + t == ys + (xs + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_485","instance":485,"id":187156,"goal":"lemma SeqTakeDrop_485(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_486","instance":486,"id":187157,"goal":"lemma SeqReverseLen_486(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_487","instance":487,"id":187158,"goal":"lemma SeqReverseIdem_487(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_488","instance":488,"id":187159,"goal":"lemma SeqMapLen_488(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_489","instance":489,"id":187160,"goal":"lemma SeqFilterLe_489(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_490","instance":490,"id":187161,"goal":"lemma SeqMemberAppend_490(zs: seq, ys: seq)\n ensures x in zs + ys <==> x in zs || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_491","instance":491,"id":187162,"goal":"lemma SeqAppendLen_491(u: seq, s: seq)\n ensures |u + s| == |u| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_492","instance":492,"id":187163,"goal":"lemma SeqAppendNil_492(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_493","instance":493,"id":187164,"goal":"lemma SeqNilAppend_493(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_494","instance":494,"id":187165,"goal":"lemma SeqAppendAssoc_494(zs: seq, s: seq, t: seq)\n ensures (zs + s) + t == zs + (s + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_495","instance":495,"id":187166,"goal":"lemma SeqTakeDrop_495(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_496","instance":496,"id":187167,"goal":"lemma SeqReverseLen_496(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_497","instance":497,"id":187168,"goal":"lemma SeqReverseIdem_497(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_498","instance":498,"id":187169,"goal":"lemma SeqMapLen_498(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_499","instance":499,"id":187170,"goal":"lemma SeqFilterLe_499(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_500","instance":500,"id":187171,"goal":"lemma SeqMemberAppend_500(ys: seq, t: seq)\n ensures x in ys + t <==> x in ys || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_501","instance":501,"id":187172,"goal":"lemma SeqAppendLen_501(ys: seq, xs: seq)\n ensures |ys + xs| == |ys| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_502","instance":502,"id":187173,"goal":"lemma SeqAppendNil_502(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_503","instance":503,"id":187174,"goal":"lemma SeqNilAppend_503(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_504","instance":504,"id":187175,"goal":"lemma SeqAppendAssoc_504(zs: seq, u: seq, ys: seq)\n ensures (zs + u) + ys == zs + (u + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_505","instance":505,"id":187176,"goal":"lemma SeqTakeDrop_505(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_506","instance":506,"id":187177,"goal":"lemma SeqReverseLen_506(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_507","instance":507,"id":187178,"goal":"lemma SeqReverseIdem_507(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_508","instance":508,"id":187179,"goal":"lemma SeqMapLen_508(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_509","instance":509,"id":187180,"goal":"lemma SeqFilterLe_509(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_510","instance":510,"id":187181,"goal":"lemma SeqMemberAppend_510(zs: seq, t: seq)\n ensures x in zs + t <==> x in zs || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_511","instance":511,"id":187182,"goal":"lemma SeqAppendLen_511(t: seq, ys: seq)\n ensures |t + ys| == |t| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_512","instance":512,"id":187183,"goal":"lemma SeqAppendNil_512(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_513","instance":513,"id":187184,"goal":"lemma SeqNilAppend_513(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_514","instance":514,"id":187185,"goal":"lemma SeqAppendAssoc_514(t: seq, u: seq, xs: seq)\n ensures (t + u) + xs == t + (u + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_515","instance":515,"id":187186,"goal":"lemma SeqTakeDrop_515(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_516","instance":516,"id":187187,"goal":"lemma SeqReverseLen_516(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_517","instance":517,"id":187188,"goal":"lemma SeqReverseIdem_517(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_518","instance":518,"id":187189,"goal":"lemma SeqMapLen_518(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_519","instance":519,"id":187190,"goal":"lemma SeqFilterLe_519(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_520","instance":520,"id":187191,"goal":"lemma SeqMemberAppend_520(xs: seq, s: seq)\n ensures x in xs + s <==> x in xs || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_521","instance":521,"id":187192,"goal":"lemma SeqAppendLen_521(zs: seq, u: seq)\n ensures |zs + u| == |zs| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_522","instance":522,"id":187193,"goal":"lemma SeqAppendNil_522(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_523","instance":523,"id":187194,"goal":"lemma SeqNilAppend_523(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_524","instance":524,"id":187195,"goal":"lemma SeqAppendAssoc_524(ys: seq, t: seq, s: seq)\n ensures (ys + t) + s == ys + (t + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_525","instance":525,"id":187196,"goal":"lemma SeqTakeDrop_525(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_526","instance":526,"id":187197,"goal":"lemma SeqReverseLen_526(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_527","instance":527,"id":187198,"goal":"lemma SeqReverseIdem_527(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_528","instance":528,"id":187199,"goal":"lemma SeqMapLen_528(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_529","instance":529,"id":187200,"goal":"lemma SeqFilterLe_529(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_530","instance":530,"id":187201,"goal":"lemma SeqMemberAppend_530(t: seq, u: seq)\n ensures x in t + u <==> x in t || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_531","instance":531,"id":187202,"goal":"lemma SeqAppendLen_531(ys: seq, zs: seq)\n ensures |ys + zs| == |ys| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_532","instance":532,"id":187203,"goal":"lemma SeqAppendNil_532(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_533","instance":533,"id":187204,"goal":"lemma SeqNilAppend_533(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_534","instance":534,"id":187205,"goal":"lemma SeqAppendAssoc_534(xs: seq, u: seq, ys: seq)\n ensures (xs + u) + ys == xs + (u + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_535","instance":535,"id":187206,"goal":"lemma SeqTakeDrop_535(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_536","instance":536,"id":187207,"goal":"lemma SeqReverseLen_536(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_537","instance":537,"id":187208,"goal":"lemma SeqReverseIdem_537(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_538","instance":538,"id":187209,"goal":"lemma SeqMapLen_538(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_539","instance":539,"id":187210,"goal":"lemma SeqFilterLe_539(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_540","instance":540,"id":187211,"goal":"lemma SeqMemberAppend_540(u: seq, zs: seq)\n ensures x in u + zs <==> x in u || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_541","instance":541,"id":187212,"goal":"lemma SeqAppendLen_541(zs: seq, ys: seq)\n ensures |zs + ys| == |zs| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_542","instance":542,"id":187213,"goal":"lemma SeqAppendNil_542(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_543","instance":543,"id":187214,"goal":"lemma SeqNilAppend_543(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_544","instance":544,"id":187215,"goal":"lemma SeqAppendAssoc_544(zs: seq, xs: seq, t: seq)\n ensures (zs + xs) + t == zs + (xs + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_545","instance":545,"id":187216,"goal":"lemma SeqTakeDrop_545(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_546","instance":546,"id":187217,"goal":"lemma SeqReverseLen_546(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_547","instance":547,"id":187218,"goal":"lemma SeqReverseIdem_547(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_548","instance":548,"id":187219,"goal":"lemma SeqMapLen_548(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_549","instance":549,"id":187220,"goal":"lemma SeqFilterLe_549(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_550","instance":550,"id":187221,"goal":"lemma SeqMemberAppend_550(xs: seq, t: seq)\n ensures x in xs + t <==> x in xs || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_551","instance":551,"id":187222,"goal":"lemma SeqAppendLen_551(u: seq, t: seq)\n ensures |u + t| == |u| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_552","instance":552,"id":187223,"goal":"lemma SeqAppendNil_552(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_553","instance":553,"id":187224,"goal":"lemma SeqNilAppend_553(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_554","instance":554,"id":187225,"goal":"lemma SeqAppendAssoc_554(ys: seq, xs: seq, s: seq)\n ensures (ys + xs) + s == ys + (xs + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_555","instance":555,"id":187226,"goal":"lemma SeqTakeDrop_555(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_556","instance":556,"id":187227,"goal":"lemma SeqReverseLen_556(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_557","instance":557,"id":187228,"goal":"lemma SeqReverseIdem_557(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_558","instance":558,"id":187229,"goal":"lemma SeqMapLen_558(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_559","instance":559,"id":187230,"goal":"lemma SeqFilterLe_559(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_560","instance":560,"id":187231,"goal":"lemma SeqMemberAppend_560(zs: seq, t: seq)\n ensures x in zs + t <==> x in zs || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_561","instance":561,"id":187232,"goal":"lemma SeqAppendLen_561(zs: seq, u: seq)\n ensures |zs + u| == |zs| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_562","instance":562,"id":187233,"goal":"lemma SeqAppendNil_562(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_563","instance":563,"id":187234,"goal":"lemma SeqNilAppend_563(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_564","instance":564,"id":187235,"goal":"lemma SeqAppendAssoc_564(ys: seq, u: seq, zs: seq)\n ensures (ys + u) + zs == ys + (u + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_565","instance":565,"id":187236,"goal":"lemma SeqTakeDrop_565(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_566","instance":566,"id":187237,"goal":"lemma SeqReverseLen_566(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_567","instance":567,"id":187238,"goal":"lemma SeqReverseIdem_567(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_568","instance":568,"id":187239,"goal":"lemma SeqMapLen_568(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_569","instance":569,"id":187240,"goal":"lemma SeqFilterLe_569(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_570","instance":570,"id":187241,"goal":"lemma SeqMemberAppend_570(u: seq, t: seq)\n ensures x in u + t <==> x in u || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_571","instance":571,"id":187242,"goal":"lemma SeqAppendLen_571(ys: seq, zs: seq)\n ensures |ys + zs| == |ys| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_572","instance":572,"id":187243,"goal":"lemma SeqAppendNil_572(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_573","instance":573,"id":187244,"goal":"lemma SeqNilAppend_573(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_574","instance":574,"id":187245,"goal":"lemma SeqAppendAssoc_574(ys: seq, s: seq, xs: seq)\n ensures (ys + s) + xs == ys + (s + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_575","instance":575,"id":187246,"goal":"lemma SeqTakeDrop_575(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_576","instance":576,"id":187247,"goal":"lemma SeqReverseLen_576(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_577","instance":577,"id":187248,"goal":"lemma SeqReverseIdem_577(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_578","instance":578,"id":187249,"goal":"lemma SeqMapLen_578(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_579","instance":579,"id":187250,"goal":"lemma SeqFilterLe_579(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_580","instance":580,"id":187251,"goal":"lemma SeqMemberAppend_580(xs: seq, t: seq)\n ensures x in xs + t <==> x in xs || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_581","instance":581,"id":187252,"goal":"lemma SeqAppendLen_581(t: seq, xs: seq)\n ensures |t + xs| == |t| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_582","instance":582,"id":187253,"goal":"lemma SeqAppendNil_582(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_583","instance":583,"id":187254,"goal":"lemma SeqNilAppend_583(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_584","instance":584,"id":187255,"goal":"lemma SeqAppendAssoc_584(u: seq, t: seq, ys: seq)\n ensures (u + t) + ys == u + (t + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_585","instance":585,"id":187256,"goal":"lemma SeqTakeDrop_585(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_586","instance":586,"id":187257,"goal":"lemma SeqReverseLen_586(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_587","instance":587,"id":187258,"goal":"lemma SeqReverseIdem_587(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_588","instance":588,"id":187259,"goal":"lemma SeqMapLen_588(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_589","instance":589,"id":187260,"goal":"lemma SeqFilterLe_589(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_590","instance":590,"id":187261,"goal":"lemma SeqMemberAppend_590(zs: seq, s: seq)\n ensures x in zs + s <==> x in zs || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_591","instance":591,"id":187262,"goal":"lemma SeqAppendLen_591(t: seq, s: seq)\n ensures |t + s| == |t| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_592","instance":592,"id":187263,"goal":"lemma SeqAppendNil_592(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_593","instance":593,"id":187264,"goal":"lemma SeqNilAppend_593(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_594","instance":594,"id":187265,"goal":"lemma SeqAppendAssoc_594(t: seq, u: seq, ys: seq)\n ensures (t + u) + ys == t + (u + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_595","instance":595,"id":187266,"goal":"lemma SeqTakeDrop_595(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_596","instance":596,"id":187267,"goal":"lemma SeqReverseLen_596(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_597","instance":597,"id":187268,"goal":"lemma SeqReverseIdem_597(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_598","instance":598,"id":187269,"goal":"lemma SeqMapLen_598(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_599","instance":599,"id":187270,"goal":"lemma SeqFilterLe_599(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_600","instance":600,"id":187271,"goal":"lemma SeqMemberAppend_600(t: seq, u: seq)\n ensures x in t + u <==> x in t || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_601","instance":601,"id":187272,"goal":"lemma SeqAppendLen_601(s: seq, ys: seq)\n ensures |s + ys| == |s| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_602","instance":602,"id":187273,"goal":"lemma SeqAppendNil_602(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_603","instance":603,"id":187274,"goal":"lemma SeqNilAppend_603(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_604","instance":604,"id":187275,"goal":"lemma SeqAppendAssoc_604(zs: seq, ys: seq, s: seq)\n ensures (zs + ys) + s == zs + (ys + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_605","instance":605,"id":187276,"goal":"lemma SeqTakeDrop_605(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_606","instance":606,"id":187277,"goal":"lemma SeqReverseLen_606(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_607","instance":607,"id":187278,"goal":"lemma SeqReverseIdem_607(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_608","instance":608,"id":187279,"goal":"lemma SeqMapLen_608(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_609","instance":609,"id":187280,"goal":"lemma SeqFilterLe_609(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_610","instance":610,"id":187281,"goal":"lemma SeqMemberAppend_610(u: seq, zs: seq)\n ensures x in u + zs <==> x in u || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_611","instance":611,"id":187282,"goal":"lemma SeqAppendLen_611(u: seq, xs: seq)\n ensures |u + xs| == |u| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_612","instance":612,"id":187283,"goal":"lemma SeqAppendNil_612(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_613","instance":613,"id":187284,"goal":"lemma SeqNilAppend_613(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_614","instance":614,"id":187285,"goal":"lemma SeqAppendAssoc_614(xs: seq, ys: seq, u: seq)\n ensures (xs + ys) + u == xs + (ys + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_615","instance":615,"id":187286,"goal":"lemma SeqTakeDrop_615(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_616","instance":616,"id":187287,"goal":"lemma SeqReverseLen_616(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_617","instance":617,"id":187288,"goal":"lemma SeqReverseIdem_617(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_618","instance":618,"id":187289,"goal":"lemma SeqMapLen_618(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_619","instance":619,"id":187290,"goal":"lemma SeqFilterLe_619(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_620","instance":620,"id":187291,"goal":"lemma SeqMemberAppend_620(t: seq, u: seq)\n ensures x in t + u <==> x in t || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_621","instance":621,"id":187292,"goal":"lemma SeqAppendLen_621(u: seq, xs: seq)\n ensures |u + xs| == |u| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_622","instance":622,"id":187293,"goal":"lemma SeqAppendNil_622(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_623","instance":623,"id":187294,"goal":"lemma SeqNilAppend_623(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_624","instance":624,"id":187295,"goal":"lemma SeqAppendAssoc_624(s: seq, u: seq, t: seq)\n ensures (s + u) + t == s + (u + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_625","instance":625,"id":187296,"goal":"lemma SeqTakeDrop_625(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_626","instance":626,"id":187297,"goal":"lemma SeqReverseLen_626(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_627","instance":627,"id":187298,"goal":"lemma SeqReverseIdem_627(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_628","instance":628,"id":187299,"goal":"lemma SeqMapLen_628(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_629","instance":629,"id":187300,"goal":"lemma SeqFilterLe_629(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_630","instance":630,"id":187301,"goal":"lemma SeqMemberAppend_630(zs: seq, u: seq)\n ensures x in zs + u <==> x in zs || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_631","instance":631,"id":187302,"goal":"lemma SeqAppendLen_631(ys: seq, s: seq)\n ensures |ys + s| == |ys| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_632","instance":632,"id":187303,"goal":"lemma SeqAppendNil_632(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_633","instance":633,"id":187304,"goal":"lemma SeqNilAppend_633(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_634","instance":634,"id":187305,"goal":"lemma SeqAppendAssoc_634(s: seq, xs: seq, t: seq)\n ensures (s + xs) + t == s + (xs + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_635","instance":635,"id":187306,"goal":"lemma SeqTakeDrop_635(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_636","instance":636,"id":187307,"goal":"lemma SeqReverseLen_636(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_637","instance":637,"id":187308,"goal":"lemma SeqReverseIdem_637(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_638","instance":638,"id":187309,"goal":"lemma SeqMapLen_638(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_639","instance":639,"id":187310,"goal":"lemma SeqFilterLe_639(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_640","instance":640,"id":187311,"goal":"lemma SeqMemberAppend_640(xs: seq, u: seq)\n ensures x in xs + u <==> x in xs || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_641","instance":641,"id":187312,"goal":"lemma SeqAppendLen_641(zs: seq, u: seq)\n ensures |zs + u| == |zs| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_642","instance":642,"id":187313,"goal":"lemma SeqAppendNil_642(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_643","instance":643,"id":187314,"goal":"lemma SeqNilAppend_643(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_644","instance":644,"id":187315,"goal":"lemma SeqAppendAssoc_644(t: seq, s: seq, xs: seq)\n ensures (t + s) + xs == t + (s + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_645","instance":645,"id":187316,"goal":"lemma SeqTakeDrop_645(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_646","instance":646,"id":187317,"goal":"lemma SeqReverseLen_646(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_647","instance":647,"id":187318,"goal":"lemma SeqReverseIdem_647(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_648","instance":648,"id":187319,"goal":"lemma SeqMapLen_648(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_649","instance":649,"id":187320,"goal":"lemma SeqFilterLe_649(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_650","instance":650,"id":187321,"goal":"lemma SeqMemberAppend_650(s: seq, zs: seq)\n ensures x in s + zs <==> x in s || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_651","instance":651,"id":187322,"goal":"lemma SeqAppendLen_651(s: seq, ys: seq)\n ensures |s + ys| == |s| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_652","instance":652,"id":187323,"goal":"lemma SeqAppendNil_652(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_653","instance":653,"id":187324,"goal":"lemma SeqNilAppend_653(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_654","instance":654,"id":187325,"goal":"lemma SeqAppendAssoc_654(t: seq, ys: seq, xs: seq)\n ensures (t + ys) + xs == t + (ys + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_655","instance":655,"id":187326,"goal":"lemma SeqTakeDrop_655(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_656","instance":656,"id":187327,"goal":"lemma SeqReverseLen_656(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_657","instance":657,"id":187328,"goal":"lemma SeqReverseIdem_657(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_658","instance":658,"id":187329,"goal":"lemma SeqMapLen_658(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_659","instance":659,"id":187330,"goal":"lemma SeqFilterLe_659(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_660","instance":660,"id":187331,"goal":"lemma SeqMemberAppend_660(t: seq, u: seq)\n ensures x in t + u <==> x in t || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_661","instance":661,"id":187332,"goal":"lemma SeqAppendLen_661(u: seq, s: seq)\n ensures |u + s| == |u| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_662","instance":662,"id":187333,"goal":"lemma SeqAppendNil_662(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_663","instance":663,"id":187334,"goal":"lemma SeqNilAppend_663(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_664","instance":664,"id":187335,"goal":"lemma SeqAppendAssoc_664(zs: seq, s: seq, u: seq)\n ensures (zs + s) + u == zs + (s + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_665","instance":665,"id":187336,"goal":"lemma SeqTakeDrop_665(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_666","instance":666,"id":187337,"goal":"lemma SeqReverseLen_666(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_667","instance":667,"id":187338,"goal":"lemma SeqReverseIdem_667(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_668","instance":668,"id":187339,"goal":"lemma SeqMapLen_668(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_669","instance":669,"id":187340,"goal":"lemma SeqFilterLe_669(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_670","instance":670,"id":187341,"goal":"lemma SeqMemberAppend_670(u: seq, s: seq)\n ensures x in u + s <==> x in u || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_671","instance":671,"id":187342,"goal":"lemma SeqAppendLen_671(u: seq, zs: seq)\n ensures |u + zs| == |u| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_672","instance":672,"id":187343,"goal":"lemma SeqAppendNil_672(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_673","instance":673,"id":187344,"goal":"lemma SeqNilAppend_673(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_674","instance":674,"id":187345,"goal":"lemma SeqAppendAssoc_674(ys: seq, t: seq, zs: seq)\n ensures (ys + t) + zs == ys + (t + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_675","instance":675,"id":187346,"goal":"lemma SeqTakeDrop_675(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_676","instance":676,"id":187347,"goal":"lemma SeqReverseLen_676(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_677","instance":677,"id":187348,"goal":"lemma SeqReverseIdem_677(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_678","instance":678,"id":187349,"goal":"lemma SeqMapLen_678(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_679","instance":679,"id":187350,"goal":"lemma SeqFilterLe_679(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_680","instance":680,"id":187351,"goal":"lemma SeqMemberAppend_680(u: seq, s: seq)\n ensures x in u + s <==> x in u || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_681","instance":681,"id":187352,"goal":"lemma SeqAppendLen_681(xs: seq, ys: seq)\n ensures |xs + ys| == |xs| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_682","instance":682,"id":187353,"goal":"lemma SeqAppendNil_682(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_683","instance":683,"id":187354,"goal":"lemma SeqNilAppend_683(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_684","instance":684,"id":187355,"goal":"lemma SeqAppendAssoc_684(s: seq, xs: seq, t: seq)\n ensures (s + xs) + t == s + (xs + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_685","instance":685,"id":187356,"goal":"lemma SeqTakeDrop_685(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_686","instance":686,"id":187357,"goal":"lemma SeqReverseLen_686(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_687","instance":687,"id":187358,"goal":"lemma SeqReverseIdem_687(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_688","instance":688,"id":187359,"goal":"lemma SeqMapLen_688(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_689","instance":689,"id":187360,"goal":"lemma SeqFilterLe_689(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_690","instance":690,"id":187361,"goal":"lemma SeqMemberAppend_690(u: seq, zs: seq)\n ensures x in u + zs <==> x in u || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_691","instance":691,"id":187362,"goal":"lemma SeqAppendLen_691(xs: seq, u: seq)\n ensures |xs + u| == |xs| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_692","instance":692,"id":187363,"goal":"lemma SeqAppendNil_692(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_693","instance":693,"id":187364,"goal":"lemma SeqNilAppend_693(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_694","instance":694,"id":187365,"goal":"lemma SeqAppendAssoc_694(s: seq, t: seq, u: seq)\n ensures (s + t) + u == s + (t + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_695","instance":695,"id":187366,"goal":"lemma SeqTakeDrop_695(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_696","instance":696,"id":187367,"goal":"lemma SeqReverseLen_696(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_697","instance":697,"id":187368,"goal":"lemma SeqReverseIdem_697(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_698","instance":698,"id":187369,"goal":"lemma SeqMapLen_698(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_699","instance":699,"id":187370,"goal":"lemma SeqFilterLe_699(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_700","instance":700,"id":187371,"goal":"lemma SeqMemberAppend_700(xs: seq, s: seq)\n ensures x in xs + s <==> x in xs || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_701","instance":701,"id":187372,"goal":"lemma SeqAppendLen_701(t: seq, s: seq)\n ensures |t + s| == |t| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_702","instance":702,"id":187373,"goal":"lemma SeqAppendNil_702(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_703","instance":703,"id":187374,"goal":"lemma SeqNilAppend_703(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_704","instance":704,"id":187375,"goal":"lemma SeqAppendAssoc_704(s: seq, t: seq, ys: seq)\n ensures (s + t) + ys == s + (t + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_705","instance":705,"id":187376,"goal":"lemma SeqTakeDrop_705(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_706","instance":706,"id":187377,"goal":"lemma SeqReverseLen_706(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_707","instance":707,"id":187378,"goal":"lemma SeqReverseIdem_707(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_708","instance":708,"id":187379,"goal":"lemma SeqMapLen_708(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_709","instance":709,"id":187380,"goal":"lemma SeqFilterLe_709(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_710","instance":710,"id":187381,"goal":"lemma SeqMemberAppend_710(t: seq, u: seq)\n ensures x in t + u <==> x in t || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_711","instance":711,"id":187382,"goal":"lemma SeqAppendLen_711(t: seq, ys: seq)\n ensures |t + ys| == |t| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_712","instance":712,"id":187383,"goal":"lemma SeqAppendNil_712(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_713","instance":713,"id":187384,"goal":"lemma SeqNilAppend_713(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_714","instance":714,"id":187385,"goal":"lemma SeqAppendAssoc_714(s: seq, xs: seq, ys: seq)\n ensures (s + xs) + ys == s + (xs + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_715","instance":715,"id":187386,"goal":"lemma SeqTakeDrop_715(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_716","instance":716,"id":187387,"goal":"lemma SeqReverseLen_716(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_717","instance":717,"id":187388,"goal":"lemma SeqReverseIdem_717(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_718","instance":718,"id":187389,"goal":"lemma SeqMapLen_718(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_719","instance":719,"id":187390,"goal":"lemma SeqFilterLe_719(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_720","instance":720,"id":187391,"goal":"lemma SeqMemberAppend_720(u: seq, t: seq)\n ensures x in u + t <==> x in u || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_721","instance":721,"id":187392,"goal":"lemma SeqAppendLen_721(xs: seq, u: seq)\n ensures |xs + u| == |xs| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_722","instance":722,"id":187393,"goal":"lemma SeqAppendNil_722(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_723","instance":723,"id":187394,"goal":"lemma SeqNilAppend_723(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_724","instance":724,"id":187395,"goal":"lemma SeqAppendAssoc_724(s: seq, u: seq, xs: seq)\n ensures (s + u) + xs == s + (u + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_725","instance":725,"id":187396,"goal":"lemma SeqTakeDrop_725(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_726","instance":726,"id":187397,"goal":"lemma SeqReverseLen_726(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_727","instance":727,"id":187398,"goal":"lemma SeqReverseIdem_727(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_728","instance":728,"id":187399,"goal":"lemma SeqMapLen_728(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_729","instance":729,"id":187400,"goal":"lemma SeqFilterLe_729(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_730","instance":730,"id":187401,"goal":"lemma SeqMemberAppend_730(s: seq, xs: seq)\n ensures x in s + xs <==> x in s || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_731","instance":731,"id":187402,"goal":"lemma SeqAppendLen_731(s: seq, t: seq)\n ensures |s + t| == |s| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_732","instance":732,"id":187403,"goal":"lemma SeqAppendNil_732(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_733","instance":733,"id":187404,"goal":"lemma SeqNilAppend_733(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_734","instance":734,"id":187405,"goal":"lemma SeqAppendAssoc_734(ys: seq, s: seq, t: seq)\n ensures (ys + s) + t == ys + (s + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_735","instance":735,"id":187406,"goal":"lemma SeqTakeDrop_735(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_736","instance":736,"id":187407,"goal":"lemma SeqReverseLen_736(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_737","instance":737,"id":187408,"goal":"lemma SeqReverseIdem_737(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_738","instance":738,"id":187409,"goal":"lemma SeqMapLen_738(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_739","instance":739,"id":187410,"goal":"lemma SeqFilterLe_739(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_740","instance":740,"id":187411,"goal":"lemma SeqMemberAppend_740(ys: seq, u: seq)\n ensures x in ys + u <==> x in ys || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_741","instance":741,"id":187412,"goal":"lemma SeqAppendLen_741(s: seq, t: seq)\n ensures |s + t| == |s| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_742","instance":742,"id":187413,"goal":"lemma SeqAppendNil_742(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_743","instance":743,"id":187414,"goal":"lemma SeqNilAppend_743(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_744","instance":744,"id":187415,"goal":"lemma SeqAppendAssoc_744(s: seq, u: seq, zs: seq)\n ensures (s + u) + zs == s + (u + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_745","instance":745,"id":187416,"goal":"lemma SeqTakeDrop_745(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_746","instance":746,"id":187417,"goal":"lemma SeqReverseLen_746(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_747","instance":747,"id":187418,"goal":"lemma SeqReverseIdem_747(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_748","instance":748,"id":187419,"goal":"lemma SeqMapLen_748(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_749","instance":749,"id":187420,"goal":"lemma SeqFilterLe_749(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_750","instance":750,"id":187421,"goal":"lemma SeqMemberAppend_750(t: seq, zs: seq)\n ensures x in t + zs <==> x in t || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_751","instance":751,"id":187422,"goal":"lemma SeqAppendLen_751(u: seq, s: seq)\n ensures |u + s| == |u| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_752","instance":752,"id":187423,"goal":"lemma SeqAppendNil_752(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_753","instance":753,"id":187424,"goal":"lemma SeqNilAppend_753(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_754","instance":754,"id":187425,"goal":"lemma SeqAppendAssoc_754(u: seq, s: seq, ys: seq)\n ensures (u + s) + ys == u + (s + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_755","instance":755,"id":187426,"goal":"lemma SeqTakeDrop_755(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_756","instance":756,"id":187427,"goal":"lemma SeqReverseLen_756(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_757","instance":757,"id":187428,"goal":"lemma SeqReverseIdem_757(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_758","instance":758,"id":187429,"goal":"lemma SeqMapLen_758(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_759","instance":759,"id":187430,"goal":"lemma SeqFilterLe_759(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_760","instance":760,"id":187431,"goal":"lemma SeqMemberAppend_760(ys: seq, zs: seq)\n ensures x in ys + zs <==> x in ys || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_761","instance":761,"id":187432,"goal":"lemma SeqAppendLen_761(ys: seq, u: seq)\n ensures |ys + u| == |ys| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_762","instance":762,"id":187433,"goal":"lemma SeqAppendNil_762(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_763","instance":763,"id":187434,"goal":"lemma SeqNilAppend_763(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_764","instance":764,"id":187435,"goal":"lemma SeqAppendAssoc_764(xs: seq, zs: seq, t: seq)\n ensures (xs + zs) + t == xs + (zs + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_765","instance":765,"id":187436,"goal":"lemma SeqTakeDrop_765(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_766","instance":766,"id":187437,"goal":"lemma SeqReverseLen_766(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_767","instance":767,"id":187438,"goal":"lemma SeqReverseIdem_767(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_768","instance":768,"id":187439,"goal":"lemma SeqMapLen_768(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_769","instance":769,"id":187440,"goal":"lemma SeqFilterLe_769(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_770","instance":770,"id":187441,"goal":"lemma SeqMemberAppend_770(u: seq, zs: seq)\n ensures x in u + zs <==> x in u || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_771","instance":771,"id":187442,"goal":"lemma SeqAppendLen_771(t: seq, u: seq)\n ensures |t + u| == |t| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_772","instance":772,"id":187443,"goal":"lemma SeqAppendNil_772(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_773","instance":773,"id":187444,"goal":"lemma SeqNilAppend_773(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_774","instance":774,"id":187445,"goal":"lemma SeqAppendAssoc_774(ys: seq, zs: seq, xs: seq)\n ensures (ys + zs) + xs == ys + (zs + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_775","instance":775,"id":187446,"goal":"lemma SeqTakeDrop_775(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_776","instance":776,"id":187447,"goal":"lemma SeqReverseLen_776(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_777","instance":777,"id":187448,"goal":"lemma SeqReverseIdem_777(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_778","instance":778,"id":187449,"goal":"lemma SeqMapLen_778(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_779","instance":779,"id":187450,"goal":"lemma SeqFilterLe_779(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_780","instance":780,"id":187451,"goal":"lemma SeqMemberAppend_780(ys: seq, s: seq)\n ensures x in ys + s <==> x in ys || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_781","instance":781,"id":187452,"goal":"lemma SeqAppendLen_781(u: seq, s: seq)\n ensures |u + s| == |u| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_782","instance":782,"id":187453,"goal":"lemma SeqAppendNil_782(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_783","instance":783,"id":187454,"goal":"lemma SeqNilAppend_783(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_784","instance":784,"id":187455,"goal":"lemma SeqAppendAssoc_784(s: seq, ys: seq, t: seq)\n ensures (s + ys) + t == s + (ys + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_785","instance":785,"id":187456,"goal":"lemma SeqTakeDrop_785(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_786","instance":786,"id":187457,"goal":"lemma SeqReverseLen_786(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_787","instance":787,"id":187458,"goal":"lemma SeqReverseIdem_787(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_788","instance":788,"id":187459,"goal":"lemma SeqMapLen_788(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_789","instance":789,"id":187460,"goal":"lemma SeqFilterLe_789(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_790","instance":790,"id":187461,"goal":"lemma SeqMemberAppend_790(ys: seq, xs: seq)\n ensures x in ys + xs <==> x in ys || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_791","instance":791,"id":187462,"goal":"lemma SeqAppendLen_791(s: seq, t: seq)\n ensures |s + t| == |s| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_792","instance":792,"id":187463,"goal":"lemma SeqAppendNil_792(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_793","instance":793,"id":187464,"goal":"lemma SeqNilAppend_793(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_794","instance":794,"id":187465,"goal":"lemma SeqAppendAssoc_794(zs: seq, ys: seq, xs: seq)\n ensures (zs + ys) + xs == zs + (ys + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_795","instance":795,"id":187466,"goal":"lemma SeqTakeDrop_795(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_796","instance":796,"id":187467,"goal":"lemma SeqReverseLen_796(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_797","instance":797,"id":187468,"goal":"lemma SeqReverseIdem_797(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_798","instance":798,"id":187469,"goal":"lemma SeqMapLen_798(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_799","instance":799,"id":187470,"goal":"lemma SeqFilterLe_799(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_800","instance":800,"id":187471,"goal":"lemma SeqMemberAppend_800(t: seq, zs: seq)\n ensures x in t + zs <==> x in t || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_801","instance":801,"id":187472,"goal":"lemma SeqAppendLen_801(ys: seq, xs: seq)\n ensures |ys + xs| == |ys| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_802","instance":802,"id":187473,"goal":"lemma SeqAppendNil_802(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_803","instance":803,"id":187474,"goal":"lemma SeqNilAppend_803(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_804","instance":804,"id":187475,"goal":"lemma SeqAppendAssoc_804(u: seq, ys: seq, s: seq)\n ensures (u + ys) + s == u + (ys + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_805","instance":805,"id":187476,"goal":"lemma SeqTakeDrop_805(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_806","instance":806,"id":187477,"goal":"lemma SeqReverseLen_806(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_807","instance":807,"id":187478,"goal":"lemma SeqReverseIdem_807(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_808","instance":808,"id":187479,"goal":"lemma SeqMapLen_808(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_809","instance":809,"id":187480,"goal":"lemma SeqFilterLe_809(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_810","instance":810,"id":187481,"goal":"lemma SeqMemberAppend_810(s: seq, zs: seq)\n ensures x in s + zs <==> x in s || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_811","instance":811,"id":187482,"goal":"lemma SeqAppendLen_811(u: seq, t: seq)\n ensures |u + t| == |u| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_812","instance":812,"id":187483,"goal":"lemma SeqAppendNil_812(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_813","instance":813,"id":187484,"goal":"lemma SeqNilAppend_813(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_814","instance":814,"id":187485,"goal":"lemma SeqAppendAssoc_814(s: seq, t: seq, xs: seq)\n ensures (s + t) + xs == s + (t + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_815","instance":815,"id":187486,"goal":"lemma SeqTakeDrop_815(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_816","instance":816,"id":187487,"goal":"lemma SeqReverseLen_816(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_817","instance":817,"id":187488,"goal":"lemma SeqReverseIdem_817(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_818","instance":818,"id":187489,"goal":"lemma SeqMapLen_818(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_819","instance":819,"id":187490,"goal":"lemma SeqFilterLe_819(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_820","instance":820,"id":187491,"goal":"lemma SeqMemberAppend_820(ys: seq, s: seq)\n ensures x in ys + s <==> x in ys || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_821","instance":821,"id":187492,"goal":"lemma SeqAppendLen_821(zs: seq, xs: seq)\n ensures |zs + xs| == |zs| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_822","instance":822,"id":187493,"goal":"lemma SeqAppendNil_822(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_823","instance":823,"id":187494,"goal":"lemma SeqNilAppend_823(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_824","instance":824,"id":187495,"goal":"lemma SeqAppendAssoc_824(u: seq, s: seq, t: seq)\n ensures (u + s) + t == u + (s + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_825","instance":825,"id":187496,"goal":"lemma SeqTakeDrop_825(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_826","instance":826,"id":187497,"goal":"lemma SeqReverseLen_826(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_827","instance":827,"id":187498,"goal":"lemma SeqReverseIdem_827(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_828","instance":828,"id":187499,"goal":"lemma SeqMapLen_828(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_829","instance":829,"id":187500,"goal":"lemma SeqFilterLe_829(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_830","instance":830,"id":187501,"goal":"lemma SeqMemberAppend_830(u: seq, s: seq)\n ensures x in u + s <==> x in u || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_831","instance":831,"id":187502,"goal":"lemma SeqAppendLen_831(ys: seq, t: seq)\n ensures |ys + t| == |ys| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_832","instance":832,"id":187503,"goal":"lemma SeqAppendNil_832(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_833","instance":833,"id":187504,"goal":"lemma SeqNilAppend_833(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_834","instance":834,"id":187505,"goal":"lemma SeqAppendAssoc_834(xs: seq, ys: seq, zs: seq)\n ensures (xs + ys) + zs == xs + (ys + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_835","instance":835,"id":187506,"goal":"lemma SeqTakeDrop_835(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_836","instance":836,"id":187507,"goal":"lemma SeqReverseLen_836(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_837","instance":837,"id":187508,"goal":"lemma SeqReverseIdem_837(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_838","instance":838,"id":187509,"goal":"lemma SeqMapLen_838(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_839","instance":839,"id":187510,"goal":"lemma SeqFilterLe_839(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_840","instance":840,"id":187511,"goal":"lemma SeqMemberAppend_840(ys: seq, t: seq)\n ensures x in ys + t <==> x in ys || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_841","instance":841,"id":187512,"goal":"lemma SeqAppendLen_841(u: seq, t: seq)\n ensures |u + t| == |u| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_842","instance":842,"id":187513,"goal":"lemma SeqAppendNil_842(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_843","instance":843,"id":187514,"goal":"lemma SeqNilAppend_843(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_844","instance":844,"id":187515,"goal":"lemma SeqAppendAssoc_844(ys: seq, s: seq, xs: seq)\n ensures (ys + s) + xs == ys + (s + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_845","instance":845,"id":187516,"goal":"lemma SeqTakeDrop_845(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_846","instance":846,"id":187517,"goal":"lemma SeqReverseLen_846(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_847","instance":847,"id":187518,"goal":"lemma SeqReverseIdem_847(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_848","instance":848,"id":187519,"goal":"lemma SeqMapLen_848(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_849","instance":849,"id":187520,"goal":"lemma SeqFilterLe_849(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_850","instance":850,"id":187521,"goal":"lemma SeqMemberAppend_850(ys: seq, zs: seq)\n ensures x in ys + zs <==> x in ys || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_851","instance":851,"id":187522,"goal":"lemma SeqAppendLen_851(xs: seq, t: seq)\n ensures |xs + t| == |xs| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_852","instance":852,"id":187523,"goal":"lemma SeqAppendNil_852(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_853","instance":853,"id":187524,"goal":"lemma SeqNilAppend_853(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_854","instance":854,"id":187525,"goal":"lemma SeqAppendAssoc_854(u: seq, ys: seq, s: seq)\n ensures (u + ys) + s == u + (ys + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_855","instance":855,"id":187526,"goal":"lemma SeqTakeDrop_855(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_856","instance":856,"id":187527,"goal":"lemma SeqReverseLen_856(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_857","instance":857,"id":187528,"goal":"lemma SeqReverseIdem_857(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_858","instance":858,"id":187529,"goal":"lemma SeqMapLen_858(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_859","instance":859,"id":187530,"goal":"lemma SeqFilterLe_859(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_860","instance":860,"id":187531,"goal":"lemma SeqMemberAppend_860(zs: seq, s: seq)\n ensures x in zs + s <==> x in zs || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_861","instance":861,"id":187532,"goal":"lemma SeqAppendLen_861(u: seq, xs: seq)\n ensures |u + xs| == |u| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_862","instance":862,"id":187533,"goal":"lemma SeqAppendNil_862(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_863","instance":863,"id":187534,"goal":"lemma SeqNilAppend_863(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_864","instance":864,"id":187535,"goal":"lemma SeqAppendAssoc_864(s: seq, u: seq, xs: seq)\n ensures (s + u) + xs == s + (u + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_865","instance":865,"id":187536,"goal":"lemma SeqTakeDrop_865(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_866","instance":866,"id":187537,"goal":"lemma SeqReverseLen_866(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_867","instance":867,"id":187538,"goal":"lemma SeqReverseIdem_867(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_868","instance":868,"id":187539,"goal":"lemma SeqMapLen_868(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_869","instance":869,"id":187540,"goal":"lemma SeqFilterLe_869(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_870","instance":870,"id":187541,"goal":"lemma SeqMemberAppend_870(xs: seq, s: seq)\n ensures x in xs + s <==> x in xs || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_871","instance":871,"id":187542,"goal":"lemma SeqAppendLen_871(u: seq, s: seq)\n ensures |u + s| == |u| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_872","instance":872,"id":187543,"goal":"lemma SeqAppendNil_872(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_873","instance":873,"id":187544,"goal":"lemma SeqNilAppend_873(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_874","instance":874,"id":187545,"goal":"lemma SeqAppendAssoc_874(zs: seq, xs: seq, u: seq)\n ensures (zs + xs) + u == zs + (xs + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_875","instance":875,"id":187546,"goal":"lemma SeqTakeDrop_875(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_876","instance":876,"id":187547,"goal":"lemma SeqReverseLen_876(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_877","instance":877,"id":187548,"goal":"lemma SeqReverseIdem_877(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_878","instance":878,"id":187549,"goal":"lemma SeqMapLen_878(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_879","instance":879,"id":187550,"goal":"lemma SeqFilterLe_879(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_880","instance":880,"id":187551,"goal":"lemma SeqMemberAppend_880(ys: seq, u: seq)\n ensures x in ys + u <==> x in ys || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_881","instance":881,"id":187552,"goal":"lemma SeqAppendLen_881(zs: seq, xs: seq)\n ensures |zs + xs| == |zs| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_882","instance":882,"id":187553,"goal":"lemma SeqAppendNil_882(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_883","instance":883,"id":187554,"goal":"lemma SeqNilAppend_883(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_884","instance":884,"id":187555,"goal":"lemma SeqAppendAssoc_884(t: seq, zs: seq, ys: seq)\n ensures (t + zs) + ys == t + (zs + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_885","instance":885,"id":187556,"goal":"lemma SeqTakeDrop_885(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_886","instance":886,"id":187557,"goal":"lemma SeqReverseLen_886(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_887","instance":887,"id":187558,"goal":"lemma SeqReverseIdem_887(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_888","instance":888,"id":187559,"goal":"lemma SeqMapLen_888(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_889","instance":889,"id":187560,"goal":"lemma SeqFilterLe_889(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_890","instance":890,"id":187561,"goal":"lemma SeqMemberAppend_890(t: seq, s: seq)\n ensures x in t + s <==> x in t || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_891","instance":891,"id":187562,"goal":"lemma SeqAppendLen_891(s: seq, xs: seq)\n ensures |s + xs| == |s| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_892","instance":892,"id":187563,"goal":"lemma SeqAppendNil_892(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_893","instance":893,"id":187564,"goal":"lemma SeqNilAppend_893(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_894","instance":894,"id":187565,"goal":"lemma SeqAppendAssoc_894(xs: seq, t: seq, ys: seq)\n ensures (xs + t) + ys == xs + (t + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_895","instance":895,"id":187566,"goal":"lemma SeqTakeDrop_895(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_896","instance":896,"id":187567,"goal":"lemma SeqReverseLen_896(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_897","instance":897,"id":187568,"goal":"lemma SeqReverseIdem_897(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_898","instance":898,"id":187569,"goal":"lemma SeqMapLen_898(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_899","instance":899,"id":187570,"goal":"lemma SeqFilterLe_899(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_900","instance":900,"id":187571,"goal":"lemma SeqMemberAppend_900(ys: seq, t: seq)\n ensures x in ys + t <==> x in ys || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_901","instance":901,"id":187572,"goal":"lemma SeqAppendLen_901(ys: seq, u: seq)\n ensures |ys + u| == |ys| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_902","instance":902,"id":187573,"goal":"lemma SeqAppendNil_902(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_903","instance":903,"id":187574,"goal":"lemma SeqNilAppend_903(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_904","instance":904,"id":187575,"goal":"lemma SeqAppendAssoc_904(t: seq, ys: seq, u: seq)\n ensures (t + ys) + u == t + (ys + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_905","instance":905,"id":187576,"goal":"lemma SeqTakeDrop_905(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_906","instance":906,"id":187577,"goal":"lemma SeqReverseLen_906(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_907","instance":907,"id":187578,"goal":"lemma SeqReverseIdem_907(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_908","instance":908,"id":187579,"goal":"lemma SeqMapLen_908(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_909","instance":909,"id":187580,"goal":"lemma SeqFilterLe_909(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_910","instance":910,"id":187581,"goal":"lemma SeqMemberAppend_910(xs: seq, ys: seq)\n ensures x in xs + ys <==> x in xs || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_911","instance":911,"id":187582,"goal":"lemma SeqAppendLen_911(xs: seq, ys: seq)\n ensures |xs + ys| == |xs| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_912","instance":912,"id":187583,"goal":"lemma SeqAppendNil_912(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_913","instance":913,"id":187584,"goal":"lemma SeqNilAppend_913(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_914","instance":914,"id":187585,"goal":"lemma SeqAppendAssoc_914(xs: seq, zs: seq, t: seq)\n ensures (xs + zs) + t == xs + (zs + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_915","instance":915,"id":187586,"goal":"lemma SeqTakeDrop_915(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_916","instance":916,"id":187587,"goal":"lemma SeqReverseLen_916(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_917","instance":917,"id":187588,"goal":"lemma SeqReverseIdem_917(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_918","instance":918,"id":187589,"goal":"lemma SeqMapLen_918(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_919","instance":919,"id":187590,"goal":"lemma SeqFilterLe_919(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_920","instance":920,"id":187591,"goal":"lemma SeqMemberAppend_920(u: seq, ys: seq)\n ensures x in u + ys <==> x in u || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_921","instance":921,"id":187592,"goal":"lemma SeqAppendLen_921(zs: seq, s: seq)\n ensures |zs + s| == |zs| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_922","instance":922,"id":187593,"goal":"lemma SeqAppendNil_922(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_923","instance":923,"id":187594,"goal":"lemma SeqNilAppend_923(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_924","instance":924,"id":187595,"goal":"lemma SeqAppendAssoc_924(zs: seq, ys: seq, s: seq)\n ensures (zs + ys) + s == zs + (ys + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_925","instance":925,"id":187596,"goal":"lemma SeqTakeDrop_925(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_926","instance":926,"id":187597,"goal":"lemma SeqReverseLen_926(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_927","instance":927,"id":187598,"goal":"lemma SeqReverseIdem_927(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_928","instance":928,"id":187599,"goal":"lemma SeqMapLen_928(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_929","instance":929,"id":187600,"goal":"lemma SeqFilterLe_929(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_930","instance":930,"id":187601,"goal":"lemma SeqMemberAppend_930(s: seq, zs: seq)\n ensures x in s + zs <==> x in s || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_931","instance":931,"id":187602,"goal":"lemma SeqAppendLen_931(zs: seq, u: seq)\n ensures |zs + u| == |zs| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_932","instance":932,"id":187603,"goal":"lemma SeqAppendNil_932(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_933","instance":933,"id":187604,"goal":"lemma SeqNilAppend_933(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_934","instance":934,"id":187605,"goal":"lemma SeqAppendAssoc_934(zs: seq, u: seq, ys: seq)\n ensures (zs + u) + ys == zs + (u + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_935","instance":935,"id":187606,"goal":"lemma SeqTakeDrop_935(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_936","instance":936,"id":187607,"goal":"lemma SeqReverseLen_936(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_937","instance":937,"id":187608,"goal":"lemma SeqReverseIdem_937(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_938","instance":938,"id":187609,"goal":"lemma SeqMapLen_938(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_939","instance":939,"id":187610,"goal":"lemma SeqFilterLe_939(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_940","instance":940,"id":187611,"goal":"lemma SeqMemberAppend_940(xs: seq, ys: seq)\n ensures x in xs + ys <==> x in xs || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_941","instance":941,"id":187612,"goal":"lemma SeqAppendLen_941(t: seq, ys: seq)\n ensures |t + ys| == |t| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_942","instance":942,"id":187613,"goal":"lemma SeqAppendNil_942(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_943","instance":943,"id":187614,"goal":"lemma SeqNilAppend_943(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_944","instance":944,"id":187615,"goal":"lemma SeqAppendAssoc_944(t: seq, zs: seq, u: seq)\n ensures (t + zs) + u == t + (zs + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_945","instance":945,"id":187616,"goal":"lemma SeqTakeDrop_945(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_946","instance":946,"id":187617,"goal":"lemma SeqReverseLen_946(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_947","instance":947,"id":187618,"goal":"lemma SeqReverseIdem_947(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_948","instance":948,"id":187619,"goal":"lemma SeqMapLen_948(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_949","instance":949,"id":187620,"goal":"lemma SeqFilterLe_949(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_950","instance":950,"id":187621,"goal":"lemma SeqMemberAppend_950(t: seq, ys: seq)\n ensures x in t + ys <==> x in t || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_951","instance":951,"id":187622,"goal":"lemma SeqAppendLen_951(u: seq, ys: seq)\n ensures |u + ys| == |u| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_952","instance":952,"id":187623,"goal":"lemma SeqAppendNil_952(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_953","instance":953,"id":187624,"goal":"lemma SeqNilAppend_953(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_954","instance":954,"id":187625,"goal":"lemma SeqAppendAssoc_954(zs: seq, t: seq, ys: seq)\n ensures (zs + t) + ys == zs + (t + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_955","instance":955,"id":187626,"goal":"lemma SeqTakeDrop_955(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_956","instance":956,"id":187627,"goal":"lemma SeqReverseLen_956(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_957","instance":957,"id":187628,"goal":"lemma SeqReverseIdem_957(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_958","instance":958,"id":187629,"goal":"lemma SeqMapLen_958(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_959","instance":959,"id":187630,"goal":"lemma SeqFilterLe_959(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_960","instance":960,"id":187631,"goal":"lemma SeqMemberAppend_960(s: seq, t: seq)\n ensures x in s + t <==> x in s || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_961","instance":961,"id":187632,"goal":"lemma SeqAppendLen_961(t: seq, xs: seq)\n ensures |t + xs| == |t| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_962","instance":962,"id":187633,"goal":"lemma SeqAppendNil_962(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_963","instance":963,"id":187634,"goal":"lemma SeqNilAppend_963(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_964","instance":964,"id":187635,"goal":"lemma SeqAppendAssoc_964(xs: seq, u: seq, zs: seq)\n ensures (xs + u) + zs == xs + (u + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_965","instance":965,"id":187636,"goal":"lemma SeqTakeDrop_965(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_966","instance":966,"id":187637,"goal":"lemma SeqReverseLen_966(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_967","instance":967,"id":187638,"goal":"lemma SeqReverseIdem_967(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_968","instance":968,"id":187639,"goal":"lemma SeqMapLen_968(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_969","instance":969,"id":187640,"goal":"lemma SeqFilterLe_969(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_970","instance":970,"id":187641,"goal":"lemma SeqMemberAppend_970(t: seq, xs: seq)\n ensures x in t + xs <==> x in t || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_971","instance":971,"id":187642,"goal":"lemma SeqAppendLen_971(xs: seq, t: seq)\n ensures |xs + t| == |xs| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_972","instance":972,"id":187643,"goal":"lemma SeqAppendNil_972(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_973","instance":973,"id":187644,"goal":"lemma SeqNilAppend_973(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_974","instance":974,"id":187645,"goal":"lemma SeqAppendAssoc_974(u: seq, s: seq, zs: seq)\n ensures (u + s) + zs == u + (s + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_975","instance":975,"id":187646,"goal":"lemma SeqTakeDrop_975(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_976","instance":976,"id":187647,"goal":"lemma SeqReverseLen_976(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_977","instance":977,"id":187648,"goal":"lemma SeqReverseIdem_977(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_978","instance":978,"id":187649,"goal":"lemma SeqMapLen_978(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_979","instance":979,"id":187650,"goal":"lemma SeqFilterLe_979(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_980","instance":980,"id":187651,"goal":"lemma SeqMemberAppend_980(t: seq, xs: seq)\n ensures x in t + xs <==> x in t || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_981","instance":981,"id":187652,"goal":"lemma SeqAppendLen_981(s: seq, xs: seq)\n ensures |s + xs| == |s| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_982","instance":982,"id":187653,"goal":"lemma SeqAppendNil_982(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_983","instance":983,"id":187654,"goal":"lemma SeqNilAppend_983(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_984","instance":984,"id":187655,"goal":"lemma SeqAppendAssoc_984(xs: seq, ys: seq, t: seq)\n ensures (xs + ys) + t == xs + (ys + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_985","instance":985,"id":187656,"goal":"lemma SeqTakeDrop_985(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_986","instance":986,"id":187657,"goal":"lemma SeqReverseLen_986(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_987","instance":987,"id":187658,"goal":"lemma SeqReverseIdem_987(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_988","instance":988,"id":187659,"goal":"lemma SeqMapLen_988(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_989","instance":989,"id":187660,"goal":"lemma SeqFilterLe_989(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_990","instance":990,"id":187661,"goal":"lemma SeqMemberAppend_990(zs: seq, t: seq)\n ensures x in zs + t <==> x in zs || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_991","instance":991,"id":187662,"goal":"lemma SeqAppendLen_991(zs: seq, ys: seq)\n ensures |zs + ys| == |zs| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_992","instance":992,"id":187663,"goal":"lemma SeqAppendNil_992(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_993","instance":993,"id":187664,"goal":"lemma SeqNilAppend_993(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_994","instance":994,"id":187665,"goal":"lemma SeqAppendAssoc_994(xs: seq, t: seq, s: seq)\n ensures (xs + t) + s == xs + (t + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_995","instance":995,"id":187666,"goal":"lemma SeqTakeDrop_995(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_996","instance":996,"id":187667,"goal":"lemma SeqReverseLen_996(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_997","instance":997,"id":187668,"goal":"lemma SeqReverseIdem_997(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_998","instance":998,"id":187669,"goal":"lemma SeqMapLen_998(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_999","instance":999,"id":187670,"goal":"lemma SeqFilterLe_999(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_1000","instance":1000,"id":187671,"goal":"lemma SeqMemberAppend_1000(ys: seq, u: seq)\n ensures x in ys + u <==> x in ys || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_1001","instance":1001,"id":187672,"goal":"lemma SeqAppendLen_1001(zs: seq, s: seq)\n ensures |zs + s| == |zs| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_1002","instance":1002,"id":187673,"goal":"lemma SeqAppendNil_1002(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_1003","instance":1003,"id":187674,"goal":"lemma SeqNilAppend_1003(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_1004","instance":1004,"id":187675,"goal":"lemma SeqAppendAssoc_1004(u: seq, t: seq, zs: seq)\n ensures (u + t) + zs == u + (t + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_1005","instance":1005,"id":187676,"goal":"lemma SeqTakeDrop_1005(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_1006","instance":1006,"id":187677,"goal":"lemma SeqReverseLen_1006(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_1007","instance":1007,"id":187678,"goal":"lemma SeqReverseIdem_1007(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_1008","instance":1008,"id":187679,"goal":"lemma SeqMapLen_1008(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_1009","instance":1009,"id":187680,"goal":"lemma SeqFilterLe_1009(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_1010","instance":1010,"id":187681,"goal":"lemma SeqMemberAppend_1010(zs: seq, u: seq)\n ensures x in zs + u <==> x in zs || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_1011","instance":1011,"id":187682,"goal":"lemma SeqAppendLen_1011(xs: seq, zs: seq)\n ensures |xs + zs| == |xs| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_1012","instance":1012,"id":187683,"goal":"lemma SeqAppendNil_1012(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_1013","instance":1013,"id":187684,"goal":"lemma SeqNilAppend_1013(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_1014","instance":1014,"id":187685,"goal":"lemma SeqAppendAssoc_1014(zs: seq, t: seq, u: seq)\n ensures (zs + t) + u == zs + (t + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_1015","instance":1015,"id":187686,"goal":"lemma SeqTakeDrop_1015(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_1016","instance":1016,"id":187687,"goal":"lemma SeqReverseLen_1016(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_1017","instance":1017,"id":187688,"goal":"lemma SeqReverseIdem_1017(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_1018","instance":1018,"id":187689,"goal":"lemma SeqMapLen_1018(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_1019","instance":1019,"id":187690,"goal":"lemma SeqFilterLe_1019(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_1020","instance":1020,"id":187691,"goal":"lemma SeqMemberAppend_1020(s: seq, u: seq)\n ensures x in s + u <==> x in s || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_1021","instance":1021,"id":187692,"goal":"lemma SeqAppendLen_1021(xs: seq, t: seq)\n ensures |xs + t| == |xs| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_1022","instance":1022,"id":187693,"goal":"lemma SeqAppendNil_1022(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_1023","instance":1023,"id":187694,"goal":"lemma SeqNilAppend_1023(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_1024","instance":1024,"id":187695,"goal":"lemma SeqAppendAssoc_1024(u: seq, s: seq, ys: seq)\n ensures (u + s) + ys == u + (s + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_1025","instance":1025,"id":187696,"goal":"lemma SeqTakeDrop_1025(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_1026","instance":1026,"id":187697,"goal":"lemma SeqReverseLen_1026(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_1027","instance":1027,"id":187698,"goal":"lemma SeqReverseIdem_1027(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_1028","instance":1028,"id":187699,"goal":"lemma SeqMapLen_1028(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_1029","instance":1029,"id":187700,"goal":"lemma SeqFilterLe_1029(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_1030","instance":1030,"id":187701,"goal":"lemma SeqMemberAppend_1030(u: seq, xs: seq)\n ensures x in u + xs <==> x in u || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_1031","instance":1031,"id":187702,"goal":"lemma SeqAppendLen_1031(s: seq, u: seq)\n ensures |s + u| == |s| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_1032","instance":1032,"id":187703,"goal":"lemma SeqAppendNil_1032(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_1033","instance":1033,"id":187704,"goal":"lemma SeqNilAppend_1033(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_1034","instance":1034,"id":187705,"goal":"lemma SeqAppendAssoc_1034(t: seq, s: seq, xs: seq)\n ensures (t + s) + xs == t + (s + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_1035","instance":1035,"id":187706,"goal":"lemma SeqTakeDrop_1035(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_1036","instance":1036,"id":187707,"goal":"lemma SeqReverseLen_1036(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_1037","instance":1037,"id":187708,"goal":"lemma SeqReverseIdem_1037(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_1038","instance":1038,"id":187709,"goal":"lemma SeqMapLen_1038(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_1039","instance":1039,"id":187710,"goal":"lemma SeqFilterLe_1039(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_1040","instance":1040,"id":187711,"goal":"lemma SeqMemberAppend_1040(xs: seq, zs: seq)\n ensures x in xs + zs <==> x in xs || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_1041","instance":1041,"id":187712,"goal":"lemma SeqAppendLen_1041(ys: seq, xs: seq)\n ensures |ys + xs| == |ys| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_1042","instance":1042,"id":187713,"goal":"lemma SeqAppendNil_1042(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_1043","instance":1043,"id":187714,"goal":"lemma SeqNilAppend_1043(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_1044","instance":1044,"id":187715,"goal":"lemma SeqAppendAssoc_1044(xs: seq, ys: seq, s: seq)\n ensures (xs + ys) + s == xs + (ys + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_1045","instance":1045,"id":187716,"goal":"lemma SeqTakeDrop_1045(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_1046","instance":1046,"id":187717,"goal":"lemma SeqReverseLen_1046(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_1047","instance":1047,"id":187718,"goal":"lemma SeqReverseIdem_1047(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_1048","instance":1048,"id":187719,"goal":"lemma SeqMapLen_1048(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_1049","instance":1049,"id":187720,"goal":"lemma SeqFilterLe_1049(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_1050","instance":1050,"id":187721,"goal":"lemma SeqMemberAppend_1050(u: seq, xs: seq)\n ensures x in u + xs <==> x in u || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_1051","instance":1051,"id":187722,"goal":"lemma SeqAppendLen_1051(s: seq, t: seq)\n ensures |s + t| == |s| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_1052","instance":1052,"id":187723,"goal":"lemma SeqAppendNil_1052(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_1053","instance":1053,"id":187724,"goal":"lemma SeqNilAppend_1053(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_1054","instance":1054,"id":187725,"goal":"lemma SeqAppendAssoc_1054(xs: seq, ys: seq, t: seq)\n ensures (xs + ys) + t == xs + (ys + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_1055","instance":1055,"id":187726,"goal":"lemma SeqTakeDrop_1055(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_1056","instance":1056,"id":187727,"goal":"lemma SeqReverseLen_1056(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_1057","instance":1057,"id":187728,"goal":"lemma SeqReverseIdem_1057(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_1058","instance":1058,"id":187729,"goal":"lemma SeqMapLen_1058(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_1059","instance":1059,"id":187730,"goal":"lemma SeqFilterLe_1059(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_1060","instance":1060,"id":187731,"goal":"lemma SeqMemberAppend_1060(zs: seq, t: seq)\n ensures x in zs + t <==> x in zs || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_1061","instance":1061,"id":187732,"goal":"lemma SeqAppendLen_1061(zs: seq, s: seq)\n ensures |zs + s| == |zs| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_1062","instance":1062,"id":187733,"goal":"lemma SeqAppendNil_1062(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_1063","instance":1063,"id":187734,"goal":"lemma SeqNilAppend_1063(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_1064","instance":1064,"id":187735,"goal":"lemma SeqAppendAssoc_1064(t: seq, s: seq, ys: seq)\n ensures (t + s) + ys == t + (s + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_1065","instance":1065,"id":187736,"goal":"lemma SeqTakeDrop_1065(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_1066","instance":1066,"id":187737,"goal":"lemma SeqReverseLen_1066(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_1067","instance":1067,"id":187738,"goal":"lemma SeqReverseIdem_1067(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_1068","instance":1068,"id":187739,"goal":"lemma SeqMapLen_1068(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_1069","instance":1069,"id":187740,"goal":"lemma SeqFilterLe_1069(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_1070","instance":1070,"id":187741,"goal":"lemma SeqMemberAppend_1070(s: seq, zs: seq)\n ensures x in s + zs <==> x in s || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_1071","instance":1071,"id":187742,"goal":"lemma SeqAppendLen_1071(t: seq, xs: seq)\n ensures |t + xs| == |t| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_1072","instance":1072,"id":187743,"goal":"lemma SeqAppendNil_1072(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_1073","instance":1073,"id":187744,"goal":"lemma SeqNilAppend_1073(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_1074","instance":1074,"id":187745,"goal":"lemma SeqAppendAssoc_1074(xs: seq, ys: seq, zs: seq)\n ensures (xs + ys) + zs == xs + (ys + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_1075","instance":1075,"id":187746,"goal":"lemma SeqTakeDrop_1075(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_1076","instance":1076,"id":187747,"goal":"lemma SeqReverseLen_1076(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_1077","instance":1077,"id":187748,"goal":"lemma SeqReverseIdem_1077(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_1078","instance":1078,"id":187749,"goal":"lemma SeqMapLen_1078(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_1079","instance":1079,"id":187750,"goal":"lemma SeqFilterLe_1079(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_1080","instance":1080,"id":187751,"goal":"lemma SeqMemberAppend_1080(ys: seq, u: seq)\n ensures x in ys + u <==> x in ys || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_1081","instance":1081,"id":187752,"goal":"lemma SeqAppendLen_1081(xs: seq, zs: seq)\n ensures |xs + zs| == |xs| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_1082","instance":1082,"id":187753,"goal":"lemma SeqAppendNil_1082(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_1083","instance":1083,"id":187754,"goal":"lemma SeqNilAppend_1083(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_1084","instance":1084,"id":187755,"goal":"lemma SeqAppendAssoc_1084(zs: seq, t: seq, xs: seq)\n ensures (zs + t) + xs == zs + (t + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_1085","instance":1085,"id":187756,"goal":"lemma SeqTakeDrop_1085(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_1086","instance":1086,"id":187757,"goal":"lemma SeqReverseLen_1086(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_1087","instance":1087,"id":187758,"goal":"lemma SeqReverseIdem_1087(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_1088","instance":1088,"id":187759,"goal":"lemma SeqMapLen_1088(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_1089","instance":1089,"id":187760,"goal":"lemma SeqFilterLe_1089(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_1090","instance":1090,"id":187761,"goal":"lemma SeqMemberAppend_1090(u: seq, ys: seq)\n ensures x in u + ys <==> x in u || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_1091","instance":1091,"id":187762,"goal":"lemma SeqAppendLen_1091(s: seq, t: seq)\n ensures |s + t| == |s| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_1092","instance":1092,"id":187763,"goal":"lemma SeqAppendNil_1092(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_1093","instance":1093,"id":187764,"goal":"lemma SeqNilAppend_1093(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_1094","instance":1094,"id":187765,"goal":"lemma SeqAppendAssoc_1094(xs: seq, t: seq, ys: seq)\n ensures (xs + t) + ys == xs + (t + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_1095","instance":1095,"id":187766,"goal":"lemma SeqTakeDrop_1095(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_1096","instance":1096,"id":187767,"goal":"lemma SeqReverseLen_1096(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_1097","instance":1097,"id":187768,"goal":"lemma SeqReverseIdem_1097(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_1098","instance":1098,"id":187769,"goal":"lemma SeqMapLen_1098(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_1099","instance":1099,"id":187770,"goal":"lemma SeqFilterLe_1099(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_1100","instance":1100,"id":187771,"goal":"lemma SeqMemberAppend_1100(s: seq, u: seq)\n ensures x in s + u <==> x in s || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_1101","instance":1101,"id":187772,"goal":"lemma SeqAppendLen_1101(xs: seq, s: seq)\n ensures |xs + s| == |xs| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_1102","instance":1102,"id":187773,"goal":"lemma SeqAppendNil_1102(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_1103","instance":1103,"id":187774,"goal":"lemma SeqNilAppend_1103(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_1104","instance":1104,"id":187775,"goal":"lemma SeqAppendAssoc_1104(xs: seq, u: seq, zs: seq)\n ensures (xs + u) + zs == xs + (u + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_1105","instance":1105,"id":187776,"goal":"lemma SeqTakeDrop_1105(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_1106","instance":1106,"id":187777,"goal":"lemma SeqReverseLen_1106(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_1107","instance":1107,"id":187778,"goal":"lemma SeqReverseIdem_1107(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_1108","instance":1108,"id":187779,"goal":"lemma SeqMapLen_1108(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_1109","instance":1109,"id":187780,"goal":"lemma SeqFilterLe_1109(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_1110","instance":1110,"id":187781,"goal":"lemma SeqMemberAppend_1110(u: seq, s: seq)\n ensures x in u + s <==> x in u || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_1111","instance":1111,"id":187782,"goal":"lemma SeqAppendLen_1111(t: seq, zs: seq)\n ensures |t + zs| == |t| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_1112","instance":1112,"id":187783,"goal":"lemma SeqAppendNil_1112(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_1113","instance":1113,"id":187784,"goal":"lemma SeqNilAppend_1113(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_1114","instance":1114,"id":187785,"goal":"lemma SeqAppendAssoc_1114(t: seq, u: seq, ys: seq)\n ensures (t + u) + ys == t + (u + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_1115","instance":1115,"id":187786,"goal":"lemma SeqTakeDrop_1115(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_1116","instance":1116,"id":187787,"goal":"lemma SeqReverseLen_1116(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_1117","instance":1117,"id":187788,"goal":"lemma SeqReverseIdem_1117(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_1118","instance":1118,"id":187789,"goal":"lemma SeqMapLen_1118(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_1119","instance":1119,"id":187790,"goal":"lemma SeqFilterLe_1119(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_1120","instance":1120,"id":187791,"goal":"lemma SeqMemberAppend_1120(s: seq, u: seq)\n ensures x in s + u <==> x in s || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_1121","instance":1121,"id":187792,"goal":"lemma SeqAppendLen_1121(s: seq, xs: seq)\n ensures |s + xs| == |s| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_1122","instance":1122,"id":187793,"goal":"lemma SeqAppendNil_1122(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_1123","instance":1123,"id":187794,"goal":"lemma SeqNilAppend_1123(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_1124","instance":1124,"id":187795,"goal":"lemma SeqAppendAssoc_1124(u: seq, t: seq, xs: seq)\n ensures (u + t) + xs == u + (t + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_1125","instance":1125,"id":187796,"goal":"lemma SeqTakeDrop_1125(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_1126","instance":1126,"id":187797,"goal":"lemma SeqReverseLen_1126(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_1127","instance":1127,"id":187798,"goal":"lemma SeqReverseIdem_1127(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_1128","instance":1128,"id":187799,"goal":"lemma SeqMapLen_1128(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_1129","instance":1129,"id":187800,"goal":"lemma SeqFilterLe_1129(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_1130","instance":1130,"id":187801,"goal":"lemma SeqMemberAppend_1130(u: seq, t: seq)\n ensures x in u + t <==> x in u || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_1131","instance":1131,"id":187802,"goal":"lemma SeqAppendLen_1131(s: seq, t: seq)\n ensures |s + t| == |s| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_1132","instance":1132,"id":187803,"goal":"lemma SeqAppendNil_1132(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_1133","instance":1133,"id":187804,"goal":"lemma SeqNilAppend_1133(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_1134","instance":1134,"id":187805,"goal":"lemma SeqAppendAssoc_1134(ys: seq, zs: seq, xs: seq)\n ensures (ys + zs) + xs == ys + (zs + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_1135","instance":1135,"id":187806,"goal":"lemma SeqTakeDrop_1135(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_1136","instance":1136,"id":187807,"goal":"lemma SeqReverseLen_1136(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_1137","instance":1137,"id":187808,"goal":"lemma SeqReverseIdem_1137(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_1138","instance":1138,"id":187809,"goal":"lemma SeqMapLen_1138(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_1139","instance":1139,"id":187810,"goal":"lemma SeqFilterLe_1139(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_1140","instance":1140,"id":187811,"goal":"lemma SeqMemberAppend_1140(ys: seq, t: seq)\n ensures x in ys + t <==> x in ys || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_1141","instance":1141,"id":187812,"goal":"lemma SeqAppendLen_1141(ys: seq, t: seq)\n ensures |ys + t| == |ys| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_1142","instance":1142,"id":187813,"goal":"lemma SeqAppendNil_1142(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_1143","instance":1143,"id":187814,"goal":"lemma SeqNilAppend_1143(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_1144","instance":1144,"id":187815,"goal":"lemma SeqAppendAssoc_1144(zs: seq, u: seq, xs: seq)\n ensures (zs + u) + xs == zs + (u + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_1145","instance":1145,"id":187816,"goal":"lemma SeqTakeDrop_1145(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_1146","instance":1146,"id":187817,"goal":"lemma SeqReverseLen_1146(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_1147","instance":1147,"id":187818,"goal":"lemma SeqReverseIdem_1147(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_1148","instance":1148,"id":187819,"goal":"lemma SeqMapLen_1148(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_1149","instance":1149,"id":187820,"goal":"lemma SeqFilterLe_1149(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_1150","instance":1150,"id":187821,"goal":"lemma SeqMemberAppend_1150(zs: seq, t: seq)\n ensures x in zs + t <==> x in zs || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_1151","instance":1151,"id":187822,"goal":"lemma SeqAppendLen_1151(u: seq, zs: seq)\n ensures |u + zs| == |u| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_1152","instance":1152,"id":187823,"goal":"lemma SeqAppendNil_1152(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_1153","instance":1153,"id":187824,"goal":"lemma SeqNilAppend_1153(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_1154","instance":1154,"id":187825,"goal":"lemma SeqAppendAssoc_1154(xs: seq, ys: seq, s: seq)\n ensures (xs + ys) + s == xs + (ys + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_1155","instance":1155,"id":187826,"goal":"lemma SeqTakeDrop_1155(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_1156","instance":1156,"id":187827,"goal":"lemma SeqReverseLen_1156(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_1157","instance":1157,"id":187828,"goal":"lemma SeqReverseIdem_1157(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_1158","instance":1158,"id":187829,"goal":"lemma SeqMapLen_1158(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_1159","instance":1159,"id":187830,"goal":"lemma SeqFilterLe_1159(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_1160","instance":1160,"id":187831,"goal":"lemma SeqMemberAppend_1160(xs: seq, t: seq)\n ensures x in xs + t <==> x in xs || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_1161","instance":1161,"id":187832,"goal":"lemma SeqAppendLen_1161(zs: seq, xs: seq)\n ensures |zs + xs| == |zs| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_1162","instance":1162,"id":187833,"goal":"lemma SeqAppendNil_1162(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_1163","instance":1163,"id":187834,"goal":"lemma SeqNilAppend_1163(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_1164","instance":1164,"id":187835,"goal":"lemma SeqAppendAssoc_1164(ys: seq, s: seq, xs: seq)\n ensures (ys + s) + xs == ys + (s + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_1165","instance":1165,"id":187836,"goal":"lemma SeqTakeDrop_1165(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_1166","instance":1166,"id":187837,"goal":"lemma SeqReverseLen_1166(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_1167","instance":1167,"id":187838,"goal":"lemma SeqReverseIdem_1167(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_1168","instance":1168,"id":187839,"goal":"lemma SeqMapLen_1168(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_1169","instance":1169,"id":187840,"goal":"lemma SeqFilterLe_1169(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_1170","instance":1170,"id":187841,"goal":"lemma SeqMemberAppend_1170(xs: seq, t: seq)\n ensures x in xs + t <==> x in xs || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_1171","instance":1171,"id":187842,"goal":"lemma SeqAppendLen_1171(s: seq, ys: seq)\n ensures |s + ys| == |s| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_1172","instance":1172,"id":187843,"goal":"lemma SeqAppendNil_1172(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_1173","instance":1173,"id":187844,"goal":"lemma SeqNilAppend_1173(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_1174","instance":1174,"id":187845,"goal":"lemma SeqAppendAssoc_1174(u: seq, xs: seq, s: seq)\n ensures (u + xs) + s == u + (xs + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_1175","instance":1175,"id":187846,"goal":"lemma SeqTakeDrop_1175(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_1176","instance":1176,"id":187847,"goal":"lemma SeqReverseLen_1176(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_1177","instance":1177,"id":187848,"goal":"lemma SeqReverseIdem_1177(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_1178","instance":1178,"id":187849,"goal":"lemma SeqMapLen_1178(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_1179","instance":1179,"id":187850,"goal":"lemma SeqFilterLe_1179(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_1180","instance":1180,"id":187851,"goal":"lemma SeqMemberAppend_1180(xs: seq, t: seq)\n ensures x in xs + t <==> x in xs || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_1181","instance":1181,"id":187852,"goal":"lemma SeqAppendLen_1181(xs: seq, s: seq)\n ensures |xs + s| == |xs| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_1182","instance":1182,"id":187853,"goal":"lemma SeqAppendNil_1182(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_1183","instance":1183,"id":187854,"goal":"lemma SeqNilAppend_1183(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_1184","instance":1184,"id":187855,"goal":"lemma SeqAppendAssoc_1184(u: seq, zs: seq, s: seq)\n ensures (u + zs) + s == u + (zs + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_1185","instance":1185,"id":187856,"goal":"lemma SeqTakeDrop_1185(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_1186","instance":1186,"id":187857,"goal":"lemma SeqReverseLen_1186(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_1187","instance":1187,"id":187858,"goal":"lemma SeqReverseIdem_1187(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_1188","instance":1188,"id":187859,"goal":"lemma SeqMapLen_1188(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_1189","instance":1189,"id":187860,"goal":"lemma SeqFilterLe_1189(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_1190","instance":1190,"id":187861,"goal":"lemma SeqMemberAppend_1190(xs: seq, zs: seq)\n ensures x in xs + zs <==> x in xs || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_1191","instance":1191,"id":187862,"goal":"lemma SeqAppendLen_1191(xs: seq, s: seq)\n ensures |xs + s| == |xs| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_1192","instance":1192,"id":187863,"goal":"lemma SeqAppendNil_1192(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_1193","instance":1193,"id":187864,"goal":"lemma SeqNilAppend_1193(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_1194","instance":1194,"id":187865,"goal":"lemma SeqAppendAssoc_1194(xs: seq, ys: seq, zs: seq)\n ensures (xs + ys) + zs == xs + (ys + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_1195","instance":1195,"id":187866,"goal":"lemma SeqTakeDrop_1195(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_1196","instance":1196,"id":187867,"goal":"lemma SeqReverseLen_1196(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_1197","instance":1197,"id":187868,"goal":"lemma SeqReverseIdem_1197(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_1198","instance":1198,"id":187869,"goal":"lemma SeqMapLen_1198(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_1199","instance":1199,"id":187870,"goal":"lemma SeqFilterLe_1199(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_1200","instance":1200,"id":187871,"goal":"lemma SeqMemberAppend_1200(ys: seq, zs: seq)\n ensures x in ys + zs <==> x in ys || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_1201","instance":1201,"id":187872,"goal":"lemma SeqAppendLen_1201(t: seq, u: seq)\n ensures |t + u| == |t| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_1202","instance":1202,"id":187873,"goal":"lemma SeqAppendNil_1202(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_1203","instance":1203,"id":187874,"goal":"lemma SeqNilAppend_1203(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_1204","instance":1204,"id":187875,"goal":"lemma SeqAppendAssoc_1204(zs: seq, t: seq, u: seq)\n ensures (zs + t) + u == zs + (t + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_1205","instance":1205,"id":187876,"goal":"lemma SeqTakeDrop_1205(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_1206","instance":1206,"id":187877,"goal":"lemma SeqReverseLen_1206(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_1207","instance":1207,"id":187878,"goal":"lemma SeqReverseIdem_1207(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_1208","instance":1208,"id":187879,"goal":"lemma SeqMapLen_1208(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_1209","instance":1209,"id":187880,"goal":"lemma SeqFilterLe_1209(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_1210","instance":1210,"id":187881,"goal":"lemma SeqMemberAppend_1210(u: seq, s: seq)\n ensures x in u + s <==> x in u || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_1211","instance":1211,"id":187882,"goal":"lemma SeqAppendLen_1211(u: seq, zs: seq)\n ensures |u + zs| == |u| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_1212","instance":1212,"id":187883,"goal":"lemma SeqAppendNil_1212(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_1213","instance":1213,"id":187884,"goal":"lemma SeqNilAppend_1213(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_1214","instance":1214,"id":187885,"goal":"lemma SeqAppendAssoc_1214(xs: seq, ys: seq, t: seq)\n ensures (xs + ys) + t == xs + (ys + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_1215","instance":1215,"id":187886,"goal":"lemma SeqTakeDrop_1215(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_1216","instance":1216,"id":187887,"goal":"lemma SeqReverseLen_1216(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_1217","instance":1217,"id":187888,"goal":"lemma SeqReverseIdem_1217(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_1218","instance":1218,"id":187889,"goal":"lemma SeqMapLen_1218(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_1219","instance":1219,"id":187890,"goal":"lemma SeqFilterLe_1219(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_1220","instance":1220,"id":187891,"goal":"lemma SeqMemberAppend_1220(zs: seq, s: seq)\n ensures x in zs + s <==> x in zs || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_1221","instance":1221,"id":187892,"goal":"lemma SeqAppendLen_1221(s: seq, xs: seq)\n ensures |s + xs| == |s| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_1222","instance":1222,"id":187893,"goal":"lemma SeqAppendNil_1222(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_1223","instance":1223,"id":187894,"goal":"lemma SeqNilAppend_1223(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_1224","instance":1224,"id":187895,"goal":"lemma SeqAppendAssoc_1224(xs: seq, zs: seq, ys: seq)\n ensures (xs + zs) + ys == xs + (zs + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_1225","instance":1225,"id":187896,"goal":"lemma SeqTakeDrop_1225(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_1226","instance":1226,"id":187897,"goal":"lemma SeqReverseLen_1226(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_1227","instance":1227,"id":187898,"goal":"lemma SeqReverseIdem_1227(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_1228","instance":1228,"id":187899,"goal":"lemma SeqMapLen_1228(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_1229","instance":1229,"id":187900,"goal":"lemma SeqFilterLe_1229(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_1230","instance":1230,"id":187901,"goal":"lemma SeqMemberAppend_1230(t: seq, s: seq)\n ensures x in t + s <==> x in t || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_1231","instance":1231,"id":187902,"goal":"lemma SeqAppendLen_1231(s: seq, u: seq)\n ensures |s + u| == |s| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_1232","instance":1232,"id":187903,"goal":"lemma SeqAppendNil_1232(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_1233","instance":1233,"id":187904,"goal":"lemma SeqNilAppend_1233(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_1234","instance":1234,"id":187905,"goal":"lemma SeqAppendAssoc_1234(zs: seq, ys: seq, u: seq)\n ensures (zs + ys) + u == zs + (ys + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_1235","instance":1235,"id":187906,"goal":"lemma SeqTakeDrop_1235(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_1236","instance":1236,"id":187907,"goal":"lemma SeqReverseLen_1236(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_1237","instance":1237,"id":187908,"goal":"lemma SeqReverseIdem_1237(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_1238","instance":1238,"id":187909,"goal":"lemma SeqMapLen_1238(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_1239","instance":1239,"id":187910,"goal":"lemma SeqFilterLe_1239(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_1240","instance":1240,"id":187911,"goal":"lemma SeqMemberAppend_1240(t: seq, zs: seq)\n ensures x in t + zs <==> x in t || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_1241","instance":1241,"id":187912,"goal":"lemma SeqAppendLen_1241(zs: seq, t: seq)\n ensures |zs + t| == |zs| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_1242","instance":1242,"id":187913,"goal":"lemma SeqAppendNil_1242(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_1243","instance":1243,"id":187914,"goal":"lemma SeqNilAppend_1243(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_1244","instance":1244,"id":187915,"goal":"lemma SeqAppendAssoc_1244(zs: seq, t: seq, s: seq)\n ensures (zs + t) + s == zs + (t + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_1245","instance":1245,"id":187916,"goal":"lemma SeqTakeDrop_1245(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_1246","instance":1246,"id":187917,"goal":"lemma SeqReverseLen_1246(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_1247","instance":1247,"id":187918,"goal":"lemma SeqReverseIdem_1247(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_1248","instance":1248,"id":187919,"goal":"lemma SeqMapLen_1248(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_1249","instance":1249,"id":187920,"goal":"lemma SeqFilterLe_1249(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_1250","instance":1250,"id":187921,"goal":"lemma SeqMemberAppend_1250(t: seq, ys: seq)\n ensures x in t + ys <==> x in t || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_1251","instance":1251,"id":187922,"goal":"lemma SeqAppendLen_1251(zs: seq, u: seq)\n ensures |zs + u| == |zs| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_1252","instance":1252,"id":187923,"goal":"lemma SeqAppendNil_1252(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_1253","instance":1253,"id":187924,"goal":"lemma SeqNilAppend_1253(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_1254","instance":1254,"id":187925,"goal":"lemma SeqAppendAssoc_1254(xs: seq, ys: seq, u: seq)\n ensures (xs + ys) + u == xs + (ys + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_1255","instance":1255,"id":187926,"goal":"lemma SeqTakeDrop_1255(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_1256","instance":1256,"id":187927,"goal":"lemma SeqReverseLen_1256(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_1257","instance":1257,"id":187928,"goal":"lemma SeqReverseIdem_1257(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_1258","instance":1258,"id":187929,"goal":"lemma SeqMapLen_1258(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_1259","instance":1259,"id":187930,"goal":"lemma SeqFilterLe_1259(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_1260","instance":1260,"id":187931,"goal":"lemma SeqMemberAppend_1260(ys: seq, t: seq)\n ensures x in ys + t <==> x in ys || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_1261","instance":1261,"id":187932,"goal":"lemma SeqAppendLen_1261(u: seq, ys: seq)\n ensures |u + ys| == |u| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_1262","instance":1262,"id":187933,"goal":"lemma SeqAppendNil_1262(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_1263","instance":1263,"id":187934,"goal":"lemma SeqNilAppend_1263(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_1264","instance":1264,"id":187935,"goal":"lemma SeqAppendAssoc_1264(zs: seq, t: seq, s: seq)\n ensures (zs + t) + s == zs + (t + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_1265","instance":1265,"id":187936,"goal":"lemma SeqTakeDrop_1265(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_1266","instance":1266,"id":187937,"goal":"lemma SeqReverseLen_1266(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_1267","instance":1267,"id":187938,"goal":"lemma SeqReverseIdem_1267(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_1268","instance":1268,"id":187939,"goal":"lemma SeqMapLen_1268(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_1269","instance":1269,"id":187940,"goal":"lemma SeqFilterLe_1269(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_1270","instance":1270,"id":187941,"goal":"lemma SeqMemberAppend_1270(t: seq, xs: seq)\n ensures x in t + xs <==> x in t || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_1271","instance":1271,"id":187942,"goal":"lemma SeqAppendLen_1271(ys: seq, zs: seq)\n ensures |ys + zs| == |ys| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_1272","instance":1272,"id":187943,"goal":"lemma SeqAppendNil_1272(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_1273","instance":1273,"id":187944,"goal":"lemma SeqNilAppend_1273(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_1274","instance":1274,"id":187945,"goal":"lemma SeqAppendAssoc_1274(zs: seq, s: seq, t: seq)\n ensures (zs + s) + t == zs + (s + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_1275","instance":1275,"id":187946,"goal":"lemma SeqTakeDrop_1275(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_1276","instance":1276,"id":187947,"goal":"lemma SeqReverseLen_1276(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_1277","instance":1277,"id":187948,"goal":"lemma SeqReverseIdem_1277(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_1278","instance":1278,"id":187949,"goal":"lemma SeqMapLen_1278(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_1279","instance":1279,"id":187950,"goal":"lemma SeqFilterLe_1279(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_1280","instance":1280,"id":187951,"goal":"lemma SeqMemberAppend_1280(ys: seq, t: seq)\n ensures x in ys + t <==> x in ys || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_1281","instance":1281,"id":187952,"goal":"lemma SeqAppendLen_1281(xs: seq, s: seq)\n ensures |xs + s| == |xs| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_1282","instance":1282,"id":187953,"goal":"lemma SeqAppendNil_1282(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_1283","instance":1283,"id":187954,"goal":"lemma SeqNilAppend_1283(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_1284","instance":1284,"id":187955,"goal":"lemma SeqAppendAssoc_1284(zs: seq, u: seq, s: seq)\n ensures (zs + u) + s == zs + (u + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_1285","instance":1285,"id":187956,"goal":"lemma SeqTakeDrop_1285(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_1286","instance":1286,"id":187957,"goal":"lemma SeqReverseLen_1286(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_1287","instance":1287,"id":187958,"goal":"lemma SeqReverseIdem_1287(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_1288","instance":1288,"id":187959,"goal":"lemma SeqMapLen_1288(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_1289","instance":1289,"id":187960,"goal":"lemma SeqFilterLe_1289(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_1290","instance":1290,"id":187961,"goal":"lemma SeqMemberAppend_1290(xs: seq, s: seq)\n ensures x in xs + s <==> x in xs || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_1291","instance":1291,"id":187962,"goal":"lemma SeqAppendLen_1291(s: seq, ys: seq)\n ensures |s + ys| == |s| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_1292","instance":1292,"id":187963,"goal":"lemma SeqAppendNil_1292(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_1293","instance":1293,"id":187964,"goal":"lemma SeqNilAppend_1293(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_1294","instance":1294,"id":187965,"goal":"lemma SeqAppendAssoc_1294(zs: seq, ys: seq, t: seq)\n ensures (zs + ys) + t == zs + (ys + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_1295","instance":1295,"id":187966,"goal":"lemma SeqTakeDrop_1295(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_1296","instance":1296,"id":187967,"goal":"lemma SeqReverseLen_1296(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_1297","instance":1297,"id":187968,"goal":"lemma SeqReverseIdem_1297(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_1298","instance":1298,"id":187969,"goal":"lemma SeqMapLen_1298(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_1299","instance":1299,"id":187970,"goal":"lemma SeqFilterLe_1299(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_1300","instance":1300,"id":187971,"goal":"lemma SeqMemberAppend_1300(zs: seq, t: seq)\n ensures x in zs + t <==> x in zs || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_1301","instance":1301,"id":187972,"goal":"lemma SeqAppendLen_1301(s: seq, xs: seq)\n ensures |s + xs| == |s| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_1302","instance":1302,"id":187973,"goal":"lemma SeqAppendNil_1302(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_1303","instance":1303,"id":187974,"goal":"lemma SeqNilAppend_1303(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_1304","instance":1304,"id":187975,"goal":"lemma SeqAppendAssoc_1304(t: seq, ys: seq, s: seq)\n ensures (t + ys) + s == t + (ys + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_1305","instance":1305,"id":187976,"goal":"lemma SeqTakeDrop_1305(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_1306","instance":1306,"id":187977,"goal":"lemma SeqReverseLen_1306(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_1307","instance":1307,"id":187978,"goal":"lemma SeqReverseIdem_1307(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_1308","instance":1308,"id":187979,"goal":"lemma SeqMapLen_1308(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_1309","instance":1309,"id":187980,"goal":"lemma SeqFilterLe_1309(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_1310","instance":1310,"id":187981,"goal":"lemma SeqMemberAppend_1310(xs: seq, zs: seq)\n ensures x in xs + zs <==> x in xs || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_1311","instance":1311,"id":187982,"goal":"lemma SeqAppendLen_1311(zs: seq, ys: seq)\n ensures |zs + ys| == |zs| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_1312","instance":1312,"id":187983,"goal":"lemma SeqAppendNil_1312(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_1313","instance":1313,"id":187984,"goal":"lemma SeqNilAppend_1313(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_1314","instance":1314,"id":187985,"goal":"lemma SeqAppendAssoc_1314(zs: seq, s: seq, xs: seq)\n ensures (zs + s) + xs == zs + (s + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_1315","instance":1315,"id":187986,"goal":"lemma SeqTakeDrop_1315(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_1316","instance":1316,"id":187987,"goal":"lemma SeqReverseLen_1316(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_1317","instance":1317,"id":187988,"goal":"lemma SeqReverseIdem_1317(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_1318","instance":1318,"id":187989,"goal":"lemma SeqMapLen_1318(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_1319","instance":1319,"id":187990,"goal":"lemma SeqFilterLe_1319(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_1320","instance":1320,"id":187991,"goal":"lemma SeqMemberAppend_1320(xs: seq, zs: seq)\n ensures x in xs + zs <==> x in xs || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_1321","instance":1321,"id":187992,"goal":"lemma SeqAppendLen_1321(s: seq, ys: seq)\n ensures |s + ys| == |s| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_1322","instance":1322,"id":187993,"goal":"lemma SeqAppendNil_1322(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_1323","instance":1323,"id":187994,"goal":"lemma SeqNilAppend_1323(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_1324","instance":1324,"id":187995,"goal":"lemma SeqAppendAssoc_1324(zs: seq, u: seq, xs: seq)\n ensures (zs + u) + xs == zs + (u + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_1325","instance":1325,"id":187996,"goal":"lemma SeqTakeDrop_1325(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_1326","instance":1326,"id":187997,"goal":"lemma SeqReverseLen_1326(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_1327","instance":1327,"id":187998,"goal":"lemma SeqReverseIdem_1327(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_1328","instance":1328,"id":187999,"goal":"lemma SeqMapLen_1328(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_1329","instance":1329,"id":188000,"goal":"lemma SeqFilterLe_1329(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_1330","instance":1330,"id":188001,"goal":"lemma SeqMemberAppend_1330(t: seq, zs: seq)\n ensures x in t + zs <==> x in t || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_1331","instance":1331,"id":188002,"goal":"lemma SeqAppendLen_1331(ys: seq, s: seq)\n ensures |ys + s| == |ys| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_1332","instance":1332,"id":188003,"goal":"lemma SeqAppendNil_1332(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_1333","instance":1333,"id":188004,"goal":"lemma SeqNilAppend_1333(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_1334","instance":1334,"id":188005,"goal":"lemma SeqAppendAssoc_1334(zs: seq, xs: seq, ys: seq)\n ensures (zs + xs) + ys == zs + (xs + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_1335","instance":1335,"id":188006,"goal":"lemma SeqTakeDrop_1335(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_1336","instance":1336,"id":188007,"goal":"lemma SeqReverseLen_1336(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_1337","instance":1337,"id":188008,"goal":"lemma SeqReverseIdem_1337(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_1338","instance":1338,"id":188009,"goal":"lemma SeqMapLen_1338(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_1339","instance":1339,"id":188010,"goal":"lemma SeqFilterLe_1339(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_1340","instance":1340,"id":188011,"goal":"lemma SeqMemberAppend_1340(zs: seq, u: seq)\n ensures x in zs + u <==> x in zs || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_1341","instance":1341,"id":188012,"goal":"lemma SeqAppendLen_1341(zs: seq, u: seq)\n ensures |zs + u| == |zs| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_1342","instance":1342,"id":188013,"goal":"lemma SeqAppendNil_1342(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_1343","instance":1343,"id":188014,"goal":"lemma SeqNilAppend_1343(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_1344","instance":1344,"id":188015,"goal":"lemma SeqAppendAssoc_1344(u: seq, ys: seq, zs: seq)\n ensures (u + ys) + zs == u + (ys + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_1345","instance":1345,"id":188016,"goal":"lemma SeqTakeDrop_1345(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_1346","instance":1346,"id":188017,"goal":"lemma SeqReverseLen_1346(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_1347","instance":1347,"id":188018,"goal":"lemma SeqReverseIdem_1347(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_1348","instance":1348,"id":188019,"goal":"lemma SeqMapLen_1348(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_1349","instance":1349,"id":188020,"goal":"lemma SeqFilterLe_1349(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_1350","instance":1350,"id":188021,"goal":"lemma SeqMemberAppend_1350(ys: seq, u: seq)\n ensures x in ys + u <==> x in ys || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_1351","instance":1351,"id":188022,"goal":"lemma SeqAppendLen_1351(s: seq, ys: seq)\n ensures |s + ys| == |s| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_1352","instance":1352,"id":188023,"goal":"lemma SeqAppendNil_1352(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_1353","instance":1353,"id":188024,"goal":"lemma SeqNilAppend_1353(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_1354","instance":1354,"id":188025,"goal":"lemma SeqAppendAssoc_1354(t: seq, zs: seq, s: seq)\n ensures (t + zs) + s == t + (zs + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_1355","instance":1355,"id":188026,"goal":"lemma SeqTakeDrop_1355(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_1356","instance":1356,"id":188027,"goal":"lemma SeqReverseLen_1356(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_1357","instance":1357,"id":188028,"goal":"lemma SeqReverseIdem_1357(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_1358","instance":1358,"id":188029,"goal":"lemma SeqMapLen_1358(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_1359","instance":1359,"id":188030,"goal":"lemma SeqFilterLe_1359(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_1360","instance":1360,"id":188031,"goal":"lemma SeqMemberAppend_1360(xs: seq, zs: seq)\n ensures x in xs + zs <==> x in xs || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_1361","instance":1361,"id":188032,"goal":"lemma SeqAppendLen_1361(zs: seq, xs: seq)\n ensures |zs + xs| == |zs| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_1362","instance":1362,"id":188033,"goal":"lemma SeqAppendNil_1362(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_1363","instance":1363,"id":188034,"goal":"lemma SeqNilAppend_1363(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_1364","instance":1364,"id":188035,"goal":"lemma SeqAppendAssoc_1364(zs: seq, u: seq, t: seq)\n ensures (zs + u) + t == zs + (u + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_1365","instance":1365,"id":188036,"goal":"lemma SeqTakeDrop_1365(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_1366","instance":1366,"id":188037,"goal":"lemma SeqReverseLen_1366(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_1367","instance":1367,"id":188038,"goal":"lemma SeqReverseIdem_1367(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_1368","instance":1368,"id":188039,"goal":"lemma SeqMapLen_1368(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_1369","instance":1369,"id":188040,"goal":"lemma SeqFilterLe_1369(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_1370","instance":1370,"id":188041,"goal":"lemma SeqMemberAppend_1370(xs: seq, u: seq)\n ensures x in xs + u <==> x in xs || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_1371","instance":1371,"id":188042,"goal":"lemma SeqAppendLen_1371(u: seq, t: seq)\n ensures |u + t| == |u| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_1372","instance":1372,"id":188043,"goal":"lemma SeqAppendNil_1372(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_1373","instance":1373,"id":188044,"goal":"lemma SeqNilAppend_1373(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_1374","instance":1374,"id":188045,"goal":"lemma SeqAppendAssoc_1374(s: seq, xs: seq, ys: seq)\n ensures (s + xs) + ys == s + (xs + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_1375","instance":1375,"id":188046,"goal":"lemma SeqTakeDrop_1375(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_1376","instance":1376,"id":188047,"goal":"lemma SeqReverseLen_1376(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_1377","instance":1377,"id":188048,"goal":"lemma SeqReverseIdem_1377(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_1378","instance":1378,"id":188049,"goal":"lemma SeqMapLen_1378(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_1379","instance":1379,"id":188050,"goal":"lemma SeqFilterLe_1379(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_1380","instance":1380,"id":188051,"goal":"lemma SeqMemberAppend_1380(s: seq, u: seq)\n ensures x in s + u <==> x in s || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_1381","instance":1381,"id":188052,"goal":"lemma SeqAppendLen_1381(xs: seq, s: seq)\n ensures |xs + s| == |xs| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_1382","instance":1382,"id":188053,"goal":"lemma SeqAppendNil_1382(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_1383","instance":1383,"id":188054,"goal":"lemma SeqNilAppend_1383(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_1384","instance":1384,"id":188055,"goal":"lemma SeqAppendAssoc_1384(xs: seq, zs: seq, u: seq)\n ensures (xs + zs) + u == xs + (zs + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_1385","instance":1385,"id":188056,"goal":"lemma SeqTakeDrop_1385(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_1386","instance":1386,"id":188057,"goal":"lemma SeqReverseLen_1386(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_1387","instance":1387,"id":188058,"goal":"lemma SeqReverseIdem_1387(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_1388","instance":1388,"id":188059,"goal":"lemma SeqMapLen_1388(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_1389","instance":1389,"id":188060,"goal":"lemma SeqFilterLe_1389(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_1390","instance":1390,"id":188061,"goal":"lemma SeqMemberAppend_1390(xs: seq, ys: seq)\n ensures x in xs + ys <==> x in xs || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_1391","instance":1391,"id":188062,"goal":"lemma SeqAppendLen_1391(zs: seq, ys: seq)\n ensures |zs + ys| == |zs| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_1392","instance":1392,"id":188063,"goal":"lemma SeqAppendNil_1392(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_1393","instance":1393,"id":188064,"goal":"lemma SeqNilAppend_1393(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_1394","instance":1394,"id":188065,"goal":"lemma SeqAppendAssoc_1394(xs: seq, zs: seq, ys: seq)\n ensures (xs + zs) + ys == xs + (zs + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_1395","instance":1395,"id":188066,"goal":"lemma SeqTakeDrop_1395(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_1396","instance":1396,"id":188067,"goal":"lemma SeqReverseLen_1396(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_1397","instance":1397,"id":188068,"goal":"lemma SeqReverseIdem_1397(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_1398","instance":1398,"id":188069,"goal":"lemma SeqMapLen_1398(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_1399","instance":1399,"id":188070,"goal":"lemma SeqFilterLe_1399(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_1400","instance":1400,"id":188071,"goal":"lemma SeqMemberAppend_1400(ys: seq, u: seq)\n ensures x in ys + u <==> x in ys || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_1401","instance":1401,"id":188072,"goal":"lemma SeqAppendLen_1401(ys: seq, zs: seq)\n ensures |ys + zs| == |ys| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_1402","instance":1402,"id":188073,"goal":"lemma SeqAppendNil_1402(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_1403","instance":1403,"id":188074,"goal":"lemma SeqNilAppend_1403(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_1404","instance":1404,"id":188075,"goal":"lemma SeqAppendAssoc_1404(t: seq, zs: seq, ys: seq)\n ensures (t + zs) + ys == t + (zs + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_1405","instance":1405,"id":188076,"goal":"lemma SeqTakeDrop_1405(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_1406","instance":1406,"id":188077,"goal":"lemma SeqReverseLen_1406(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_1407","instance":1407,"id":188078,"goal":"lemma SeqReverseIdem_1407(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_1408","instance":1408,"id":188079,"goal":"lemma SeqMapLen_1408(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_1409","instance":1409,"id":188080,"goal":"lemma SeqFilterLe_1409(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_1410","instance":1410,"id":188081,"goal":"lemma SeqMemberAppend_1410(s: seq, ys: seq)\n ensures x in s + ys <==> x in s || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_1411","instance":1411,"id":188082,"goal":"lemma SeqAppendLen_1411(xs: seq, u: seq)\n ensures |xs + u| == |xs| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_1412","instance":1412,"id":188083,"goal":"lemma SeqAppendNil_1412(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_1413","instance":1413,"id":188084,"goal":"lemma SeqNilAppend_1413(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_1414","instance":1414,"id":188085,"goal":"lemma SeqAppendAssoc_1414(ys: seq, t: seq, s: seq)\n ensures (ys + t) + s == ys + (t + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_1415","instance":1415,"id":188086,"goal":"lemma SeqTakeDrop_1415(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_1416","instance":1416,"id":188087,"goal":"lemma SeqReverseLen_1416(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_1417","instance":1417,"id":188088,"goal":"lemma SeqReverseIdem_1417(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_1418","instance":1418,"id":188089,"goal":"lemma SeqMapLen_1418(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_1419","instance":1419,"id":188090,"goal":"lemma SeqFilterLe_1419(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_1420","instance":1420,"id":188091,"goal":"lemma SeqMemberAppend_1420(u: seq, ys: seq)\n ensures x in u + ys <==> x in u || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_1421","instance":1421,"id":188092,"goal":"lemma SeqAppendLen_1421(t: seq, u: seq)\n ensures |t + u| == |t| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_1422","instance":1422,"id":188093,"goal":"lemma SeqAppendNil_1422(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_1423","instance":1423,"id":188094,"goal":"lemma SeqNilAppend_1423(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_1424","instance":1424,"id":188095,"goal":"lemma SeqAppendAssoc_1424(u: seq, t: seq, zs: seq)\n ensures (u + t) + zs == u + (t + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_1425","instance":1425,"id":188096,"goal":"lemma SeqTakeDrop_1425(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_1426","instance":1426,"id":188097,"goal":"lemma SeqReverseLen_1426(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_1427","instance":1427,"id":188098,"goal":"lemma SeqReverseIdem_1427(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_1428","instance":1428,"id":188099,"goal":"lemma SeqMapLen_1428(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_1429","instance":1429,"id":188100,"goal":"lemma SeqFilterLe_1429(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_1430","instance":1430,"id":188101,"goal":"lemma SeqMemberAppend_1430(xs: seq, s: seq)\n ensures x in xs + s <==> x in xs || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_1431","instance":1431,"id":188102,"goal":"lemma SeqAppendLen_1431(xs: seq, u: seq)\n ensures |xs + u| == |xs| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_1432","instance":1432,"id":188103,"goal":"lemma SeqAppendNil_1432(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_1433","instance":1433,"id":188104,"goal":"lemma SeqNilAppend_1433(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_1434","instance":1434,"id":188105,"goal":"lemma SeqAppendAssoc_1434(s: seq, ys: seq, zs: seq)\n ensures (s + ys) + zs == s + (ys + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_1435","instance":1435,"id":188106,"goal":"lemma SeqTakeDrop_1435(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_1436","instance":1436,"id":188107,"goal":"lemma SeqReverseLen_1436(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_1437","instance":1437,"id":188108,"goal":"lemma SeqReverseIdem_1437(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_1438","instance":1438,"id":188109,"goal":"lemma SeqMapLen_1438(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_1439","instance":1439,"id":188110,"goal":"lemma SeqFilterLe_1439(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_1440","instance":1440,"id":188111,"goal":"lemma SeqMemberAppend_1440(xs: seq, s: seq)\n ensures x in xs + s <==> x in xs || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_1441","instance":1441,"id":188112,"goal":"lemma SeqAppendLen_1441(t: seq, zs: seq)\n ensures |t + zs| == |t| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_1442","instance":1442,"id":188113,"goal":"lemma SeqAppendNil_1442(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_1443","instance":1443,"id":188114,"goal":"lemma SeqNilAppend_1443(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_1444","instance":1444,"id":188115,"goal":"lemma SeqAppendAssoc_1444(u: seq, xs: seq, ys: seq)\n ensures (u + xs) + ys == u + (xs + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_1445","instance":1445,"id":188116,"goal":"lemma SeqTakeDrop_1445(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_1446","instance":1446,"id":188117,"goal":"lemma SeqReverseLen_1446(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_1447","instance":1447,"id":188118,"goal":"lemma SeqReverseIdem_1447(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_1448","instance":1448,"id":188119,"goal":"lemma SeqMapLen_1448(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_1449","instance":1449,"id":188120,"goal":"lemma SeqFilterLe_1449(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_1450","instance":1450,"id":188121,"goal":"lemma SeqMemberAppend_1450(ys: seq, s: seq)\n ensures x in ys + s <==> x in ys || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_1451","instance":1451,"id":188122,"goal":"lemma SeqAppendLen_1451(ys: seq, t: seq)\n ensures |ys + t| == |ys| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_1452","instance":1452,"id":188123,"goal":"lemma SeqAppendNil_1452(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_1453","instance":1453,"id":188124,"goal":"lemma SeqNilAppend_1453(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_1454","instance":1454,"id":188125,"goal":"lemma SeqAppendAssoc_1454(xs: seq, ys: seq, u: seq)\n ensures (xs + ys) + u == xs + (ys + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_1455","instance":1455,"id":188126,"goal":"lemma SeqTakeDrop_1455(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_1456","instance":1456,"id":188127,"goal":"lemma SeqReverseLen_1456(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_1457","instance":1457,"id":188128,"goal":"lemma SeqReverseIdem_1457(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_1458","instance":1458,"id":188129,"goal":"lemma SeqMapLen_1458(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_1459","instance":1459,"id":188130,"goal":"lemma SeqFilterLe_1459(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_1460","instance":1460,"id":188131,"goal":"lemma SeqMemberAppend_1460(u: seq, ys: seq)\n ensures x in u + ys <==> x in u || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_1461","instance":1461,"id":188132,"goal":"lemma SeqAppendLen_1461(u: seq, ys: seq)\n ensures |u + ys| == |u| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_1462","instance":1462,"id":188133,"goal":"lemma SeqAppendNil_1462(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_1463","instance":1463,"id":188134,"goal":"lemma SeqNilAppend_1463(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_1464","instance":1464,"id":188135,"goal":"lemma SeqAppendAssoc_1464(ys: seq, s: seq, xs: seq)\n ensures (ys + s) + xs == ys + (s + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_1465","instance":1465,"id":188136,"goal":"lemma SeqTakeDrop_1465(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_1466","instance":1466,"id":188137,"goal":"lemma SeqReverseLen_1466(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_1467","instance":1467,"id":188138,"goal":"lemma SeqReverseIdem_1467(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_1468","instance":1468,"id":188139,"goal":"lemma SeqMapLen_1468(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_1469","instance":1469,"id":188140,"goal":"lemma SeqFilterLe_1469(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_1470","instance":1470,"id":188141,"goal":"lemma SeqMemberAppend_1470(ys: seq, u: seq)\n ensures x in ys + u <==> x in ys || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_1471","instance":1471,"id":188142,"goal":"lemma SeqAppendLen_1471(xs: seq, s: seq)\n ensures |xs + s| == |xs| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_1472","instance":1472,"id":188143,"goal":"lemma SeqAppendNil_1472(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_1473","instance":1473,"id":188144,"goal":"lemma SeqNilAppend_1473(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_1474","instance":1474,"id":188145,"goal":"lemma SeqAppendAssoc_1474(xs: seq, u: seq, ys: seq)\n ensures (xs + u) + ys == xs + (u + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_1475","instance":1475,"id":188146,"goal":"lemma SeqTakeDrop_1475(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_1476","instance":1476,"id":188147,"goal":"lemma SeqReverseLen_1476(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_1477","instance":1477,"id":188148,"goal":"lemma SeqReverseIdem_1477(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_1478","instance":1478,"id":188149,"goal":"lemma SeqMapLen_1478(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_1479","instance":1479,"id":188150,"goal":"lemma SeqFilterLe_1479(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_1480","instance":1480,"id":188151,"goal":"lemma SeqMemberAppend_1480(s: seq, zs: seq)\n ensures x in s + zs <==> x in s || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_1481","instance":1481,"id":188152,"goal":"lemma SeqAppendLen_1481(u: seq, xs: seq)\n ensures |u + xs| == |u| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_1482","instance":1482,"id":188153,"goal":"lemma SeqAppendNil_1482(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_1483","instance":1483,"id":188154,"goal":"lemma SeqNilAppend_1483(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_1484","instance":1484,"id":188155,"goal":"lemma SeqAppendAssoc_1484(s: seq, zs: seq, xs: seq)\n ensures (s + zs) + xs == s + (zs + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_1485","instance":1485,"id":188156,"goal":"lemma SeqTakeDrop_1485(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_1486","instance":1486,"id":188157,"goal":"lemma SeqReverseLen_1486(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_1487","instance":1487,"id":188158,"goal":"lemma SeqReverseIdem_1487(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_1488","instance":1488,"id":188159,"goal":"lemma SeqMapLen_1488(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_1489","instance":1489,"id":188160,"goal":"lemma SeqFilterLe_1489(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_1490","instance":1490,"id":188161,"goal":"lemma SeqMemberAppend_1490(ys: seq, s: seq)\n ensures x in ys + s <==> x in ys || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_1491","instance":1491,"id":188162,"goal":"lemma SeqAppendLen_1491(ys: seq, s: seq)\n ensures |ys + s| == |ys| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_1492","instance":1492,"id":188163,"goal":"lemma SeqAppendNil_1492(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_1493","instance":1493,"id":188164,"goal":"lemma SeqNilAppend_1493(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_1494","instance":1494,"id":188165,"goal":"lemma SeqAppendAssoc_1494(t: seq, s: seq, zs: seq)\n ensures (t + s) + zs == t + (s + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_1495","instance":1495,"id":188166,"goal":"lemma SeqTakeDrop_1495(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_1496","instance":1496,"id":188167,"goal":"lemma SeqReverseLen_1496(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_1497","instance":1497,"id":188168,"goal":"lemma SeqReverseIdem_1497(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_1498","instance":1498,"id":188169,"goal":"lemma SeqMapLen_1498(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_1499","instance":1499,"id":188170,"goal":"lemma SeqFilterLe_1499(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_1500","instance":1500,"id":188171,"goal":"lemma SeqMemberAppend_1500(t: seq, zs: seq)\n ensures x in t + zs <==> x in t || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_1501","instance":1501,"id":188172,"goal":"lemma SeqAppendLen_1501(s: seq, xs: seq)\n ensures |s + xs| == |s| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_1502","instance":1502,"id":188173,"goal":"lemma SeqAppendNil_1502(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_1503","instance":1503,"id":188174,"goal":"lemma SeqNilAppend_1503(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_1504","instance":1504,"id":188175,"goal":"lemma SeqAppendAssoc_1504(s: seq, ys: seq, t: seq)\n ensures (s + ys) + t == s + (ys + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_1505","instance":1505,"id":188176,"goal":"lemma SeqTakeDrop_1505(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_1506","instance":1506,"id":188177,"goal":"lemma SeqReverseLen_1506(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_1507","instance":1507,"id":188178,"goal":"lemma SeqReverseIdem_1507(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_1508","instance":1508,"id":188179,"goal":"lemma SeqMapLen_1508(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_1509","instance":1509,"id":188180,"goal":"lemma SeqFilterLe_1509(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_1510","instance":1510,"id":188181,"goal":"lemma SeqMemberAppend_1510(t: seq, ys: seq)\n ensures x in t + ys <==> x in t || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_1511","instance":1511,"id":188182,"goal":"lemma SeqAppendLen_1511(ys: seq, s: seq)\n ensures |ys + s| == |ys| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_1512","instance":1512,"id":188183,"goal":"lemma SeqAppendNil_1512(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_1513","instance":1513,"id":188184,"goal":"lemma SeqNilAppend_1513(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_1514","instance":1514,"id":188185,"goal":"lemma SeqAppendAssoc_1514(zs: seq, s: seq, u: seq)\n ensures (zs + s) + u == zs + (s + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_1515","instance":1515,"id":188186,"goal":"lemma SeqTakeDrop_1515(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_1516","instance":1516,"id":188187,"goal":"lemma SeqReverseLen_1516(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_1517","instance":1517,"id":188188,"goal":"lemma SeqReverseIdem_1517(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_1518","instance":1518,"id":188189,"goal":"lemma SeqMapLen_1518(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_1519","instance":1519,"id":188190,"goal":"lemma SeqFilterLe_1519(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_1520","instance":1520,"id":188191,"goal":"lemma SeqMemberAppend_1520(t: seq, ys: seq)\n ensures x in t + ys <==> x in t || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_1521","instance":1521,"id":188192,"goal":"lemma SeqAppendLen_1521(zs: seq, u: seq)\n ensures |zs + u| == |zs| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_1522","instance":1522,"id":188193,"goal":"lemma SeqAppendNil_1522(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_1523","instance":1523,"id":188194,"goal":"lemma SeqNilAppend_1523(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_1524","instance":1524,"id":188195,"goal":"lemma SeqAppendAssoc_1524(s: seq, t: seq, u: seq)\n ensures (s + t) + u == s + (t + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_1525","instance":1525,"id":188196,"goal":"lemma SeqTakeDrop_1525(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_1526","instance":1526,"id":188197,"goal":"lemma SeqReverseLen_1526(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_1527","instance":1527,"id":188198,"goal":"lemma SeqReverseIdem_1527(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_1528","instance":1528,"id":188199,"goal":"lemma SeqMapLen_1528(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_1529","instance":1529,"id":188200,"goal":"lemma SeqFilterLe_1529(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_1530","instance":1530,"id":188201,"goal":"lemma SeqMemberAppend_1530(t: seq, xs: seq)\n ensures x in t + xs <==> x in t || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_1531","instance":1531,"id":188202,"goal":"lemma SeqAppendLen_1531(ys: seq, zs: seq)\n ensures |ys + zs| == |ys| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_1532","instance":1532,"id":188203,"goal":"lemma SeqAppendNil_1532(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_1533","instance":1533,"id":188204,"goal":"lemma SeqNilAppend_1533(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_1534","instance":1534,"id":188205,"goal":"lemma SeqAppendAssoc_1534(u: seq, zs: seq, xs: seq)\n ensures (u + zs) + xs == u + (zs + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_1535","instance":1535,"id":188206,"goal":"lemma SeqTakeDrop_1535(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_1536","instance":1536,"id":188207,"goal":"lemma SeqReverseLen_1536(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_1537","instance":1537,"id":188208,"goal":"lemma SeqReverseIdem_1537(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_1538","instance":1538,"id":188209,"goal":"lemma SeqMapLen_1538(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_1539","instance":1539,"id":188210,"goal":"lemma SeqFilterLe_1539(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_1540","instance":1540,"id":188211,"goal":"lemma SeqMemberAppend_1540(xs: seq, u: seq)\n ensures x in xs + u <==> x in xs || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_1541","instance":1541,"id":188212,"goal":"lemma SeqAppendLen_1541(t: seq, u: seq)\n ensures |t + u| == |t| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_1542","instance":1542,"id":188213,"goal":"lemma SeqAppendNil_1542(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_1543","instance":1543,"id":188214,"goal":"lemma SeqNilAppend_1543(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_1544","instance":1544,"id":188215,"goal":"lemma SeqAppendAssoc_1544(u: seq, xs: seq, ys: seq)\n ensures (u + xs) + ys == u + (xs + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_1545","instance":1545,"id":188216,"goal":"lemma SeqTakeDrop_1545(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_1546","instance":1546,"id":188217,"goal":"lemma SeqReverseLen_1546(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_1547","instance":1547,"id":188218,"goal":"lemma SeqReverseIdem_1547(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_1548","instance":1548,"id":188219,"goal":"lemma SeqMapLen_1548(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_1549","instance":1549,"id":188220,"goal":"lemma SeqFilterLe_1549(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_1550","instance":1550,"id":188221,"goal":"lemma SeqMemberAppend_1550(s: seq, u: seq)\n ensures x in s + u <==> x in s || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_1551","instance":1551,"id":188222,"goal":"lemma SeqAppendLen_1551(zs: seq, xs: seq)\n ensures |zs + xs| == |zs| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_1552","instance":1552,"id":188223,"goal":"lemma SeqAppendNil_1552(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_1553","instance":1553,"id":188224,"goal":"lemma SeqNilAppend_1553(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_1554","instance":1554,"id":188225,"goal":"lemma SeqAppendAssoc_1554(ys: seq, t: seq, zs: seq)\n ensures (ys + t) + zs == ys + (t + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_1555","instance":1555,"id":188226,"goal":"lemma SeqTakeDrop_1555(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_1556","instance":1556,"id":188227,"goal":"lemma SeqReverseLen_1556(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_1557","instance":1557,"id":188228,"goal":"lemma SeqReverseIdem_1557(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_1558","instance":1558,"id":188229,"goal":"lemma SeqMapLen_1558(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_1559","instance":1559,"id":188230,"goal":"lemma SeqFilterLe_1559(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_1560","instance":1560,"id":188231,"goal":"lemma SeqMemberAppend_1560(xs: seq, s: seq)\n ensures x in xs + s <==> x in xs || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_1561","instance":1561,"id":188232,"goal":"lemma SeqAppendLen_1561(u: seq, t: seq)\n ensures |u + t| == |u| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_1562","instance":1562,"id":188233,"goal":"lemma SeqAppendNil_1562(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_1563","instance":1563,"id":188234,"goal":"lemma SeqNilAppend_1563(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_1564","instance":1564,"id":188235,"goal":"lemma SeqAppendAssoc_1564(ys: seq, s: seq, t: seq)\n ensures (ys + s) + t == ys + (s + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_1565","instance":1565,"id":188236,"goal":"lemma SeqTakeDrop_1565(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_1566","instance":1566,"id":188237,"goal":"lemma SeqReverseLen_1566(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_1567","instance":1567,"id":188238,"goal":"lemma SeqReverseIdem_1567(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_1568","instance":1568,"id":188239,"goal":"lemma SeqMapLen_1568(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_1569","instance":1569,"id":188240,"goal":"lemma SeqFilterLe_1569(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_1570","instance":1570,"id":188241,"goal":"lemma SeqMemberAppend_1570(ys: seq, xs: seq)\n ensures x in ys + xs <==> x in ys || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_1571","instance":1571,"id":188242,"goal":"lemma SeqAppendLen_1571(t: seq, u: seq)\n ensures |t + u| == |t| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_1572","instance":1572,"id":188243,"goal":"lemma SeqAppendNil_1572(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_1573","instance":1573,"id":188244,"goal":"lemma SeqNilAppend_1573(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_1574","instance":1574,"id":188245,"goal":"lemma SeqAppendAssoc_1574(ys: seq, xs: seq, s: seq)\n ensures (ys + xs) + s == ys + (xs + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_1575","instance":1575,"id":188246,"goal":"lemma SeqTakeDrop_1575(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_1576","instance":1576,"id":188247,"goal":"lemma SeqReverseLen_1576(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_1577","instance":1577,"id":188248,"goal":"lemma SeqReverseIdem_1577(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_1578","instance":1578,"id":188249,"goal":"lemma SeqMapLen_1578(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_1579","instance":1579,"id":188250,"goal":"lemma SeqFilterLe_1579(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_1580","instance":1580,"id":188251,"goal":"lemma SeqMemberAppend_1580(zs: seq, s: seq)\n ensures x in zs + s <==> x in zs || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_1581","instance":1581,"id":188252,"goal":"lemma SeqAppendLen_1581(zs: seq, t: seq)\n ensures |zs + t| == |zs| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_1582","instance":1582,"id":188253,"goal":"lemma SeqAppendNil_1582(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_1583","instance":1583,"id":188254,"goal":"lemma SeqNilAppend_1583(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_1584","instance":1584,"id":188255,"goal":"lemma SeqAppendAssoc_1584(t: seq, u: seq, xs: seq)\n ensures (t + u) + xs == t + (u + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_1585","instance":1585,"id":188256,"goal":"lemma SeqTakeDrop_1585(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_1586","instance":1586,"id":188257,"goal":"lemma SeqReverseLen_1586(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_1587","instance":1587,"id":188258,"goal":"lemma SeqReverseIdem_1587(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_1588","instance":1588,"id":188259,"goal":"lemma SeqMapLen_1588(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_1589","instance":1589,"id":188260,"goal":"lemma SeqFilterLe_1589(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_1590","instance":1590,"id":188261,"goal":"lemma SeqMemberAppend_1590(t: seq, ys: seq)\n ensures x in t + ys <==> x in t || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_1591","instance":1591,"id":188262,"goal":"lemma SeqAppendLen_1591(xs: seq, ys: seq)\n ensures |xs + ys| == |xs| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_1592","instance":1592,"id":188263,"goal":"lemma SeqAppendNil_1592(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_1593","instance":1593,"id":188264,"goal":"lemma SeqNilAppend_1593(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_1594","instance":1594,"id":188265,"goal":"lemma SeqAppendAssoc_1594(t: seq, xs: seq, s: seq)\n ensures (t + xs) + s == t + (xs + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_1595","instance":1595,"id":188266,"goal":"lemma SeqTakeDrop_1595(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_1596","instance":1596,"id":188267,"goal":"lemma SeqReverseLen_1596(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_1597","instance":1597,"id":188268,"goal":"lemma SeqReverseIdem_1597(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_1598","instance":1598,"id":188269,"goal":"lemma SeqMapLen_1598(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_1599","instance":1599,"id":188270,"goal":"lemma SeqFilterLe_1599(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_1600","instance":1600,"id":188271,"goal":"lemma SeqMemberAppend_1600(xs: seq, zs: seq)\n ensures x in xs + zs <==> x in xs || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_1601","instance":1601,"id":188272,"goal":"lemma SeqAppendLen_1601(ys: seq, zs: seq)\n ensures |ys + zs| == |ys| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_1602","instance":1602,"id":188273,"goal":"lemma SeqAppendNil_1602(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_1603","instance":1603,"id":188274,"goal":"lemma SeqNilAppend_1603(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_1604","instance":1604,"id":188275,"goal":"lemma SeqAppendAssoc_1604(t: seq, zs: seq, ys: seq)\n ensures (t + zs) + ys == t + (zs + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_1605","instance":1605,"id":188276,"goal":"lemma SeqTakeDrop_1605(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_1606","instance":1606,"id":188277,"goal":"lemma SeqReverseLen_1606(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_1607","instance":1607,"id":188278,"goal":"lemma SeqReverseIdem_1607(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_1608","instance":1608,"id":188279,"goal":"lemma SeqMapLen_1608(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_1609","instance":1609,"id":188280,"goal":"lemma SeqFilterLe_1609(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_1610","instance":1610,"id":188281,"goal":"lemma SeqMemberAppend_1610(zs: seq, t: seq)\n ensures x in zs + t <==> x in zs || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_1611","instance":1611,"id":188282,"goal":"lemma SeqAppendLen_1611(zs: seq, s: seq)\n ensures |zs + s| == |zs| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_1612","instance":1612,"id":188283,"goal":"lemma SeqAppendNil_1612(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_1613","instance":1613,"id":188284,"goal":"lemma SeqNilAppend_1613(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_1614","instance":1614,"id":188285,"goal":"lemma SeqAppendAssoc_1614(xs: seq, zs: seq, s: seq)\n ensures (xs + zs) + s == xs + (zs + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_1615","instance":1615,"id":188286,"goal":"lemma SeqTakeDrop_1615(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_1616","instance":1616,"id":188287,"goal":"lemma SeqReverseLen_1616(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_1617","instance":1617,"id":188288,"goal":"lemma SeqReverseIdem_1617(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_1618","instance":1618,"id":188289,"goal":"lemma SeqMapLen_1618(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_1619","instance":1619,"id":188290,"goal":"lemma SeqFilterLe_1619(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_1620","instance":1620,"id":188291,"goal":"lemma SeqMemberAppend_1620(zs: seq, t: seq)\n ensures x in zs + t <==> x in zs || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_1621","instance":1621,"id":188292,"goal":"lemma SeqAppendLen_1621(s: seq, xs: seq)\n ensures |s + xs| == |s| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_1622","instance":1622,"id":188293,"goal":"lemma SeqAppendNil_1622(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_1623","instance":1623,"id":188294,"goal":"lemma SeqNilAppend_1623(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_1624","instance":1624,"id":188295,"goal":"lemma SeqAppendAssoc_1624(xs: seq, u: seq, t: seq)\n ensures (xs + u) + t == xs + (u + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_1625","instance":1625,"id":188296,"goal":"lemma SeqTakeDrop_1625(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_1626","instance":1626,"id":188297,"goal":"lemma SeqReverseLen_1626(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_1627","instance":1627,"id":188298,"goal":"lemma SeqReverseIdem_1627(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_1628","instance":1628,"id":188299,"goal":"lemma SeqMapLen_1628(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_1629","instance":1629,"id":188300,"goal":"lemma SeqFilterLe_1629(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_1630","instance":1630,"id":188301,"goal":"lemma SeqMemberAppend_1630(u: seq, xs: seq)\n ensures x in u + xs <==> x in u || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_1631","instance":1631,"id":188302,"goal":"lemma SeqAppendLen_1631(u: seq, xs: seq)\n ensures |u + xs| == |u| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_1632","instance":1632,"id":188303,"goal":"lemma SeqAppendNil_1632(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_1633","instance":1633,"id":188304,"goal":"lemma SeqNilAppend_1633(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_1634","instance":1634,"id":188305,"goal":"lemma SeqAppendAssoc_1634(ys: seq, u: seq, t: seq)\n ensures (ys + u) + t == ys + (u + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_1635","instance":1635,"id":188306,"goal":"lemma SeqTakeDrop_1635(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_1636","instance":1636,"id":188307,"goal":"lemma SeqReverseLen_1636(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_1637","instance":1637,"id":188308,"goal":"lemma SeqReverseIdem_1637(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_1638","instance":1638,"id":188309,"goal":"lemma SeqMapLen_1638(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_1639","instance":1639,"id":188310,"goal":"lemma SeqFilterLe_1639(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_1640","instance":1640,"id":188311,"goal":"lemma SeqMemberAppend_1640(zs: seq, u: seq)\n ensures x in zs + u <==> x in zs || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_1641","instance":1641,"id":188312,"goal":"lemma SeqAppendLen_1641(zs: seq, t: seq)\n ensures |zs + t| == |zs| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_1642","instance":1642,"id":188313,"goal":"lemma SeqAppendNil_1642(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_1643","instance":1643,"id":188314,"goal":"lemma SeqNilAppend_1643(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_1644","instance":1644,"id":188315,"goal":"lemma SeqAppendAssoc_1644(t: seq, ys: seq, zs: seq)\n ensures (t + ys) + zs == t + (ys + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_1645","instance":1645,"id":188316,"goal":"lemma SeqTakeDrop_1645(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_1646","instance":1646,"id":188317,"goal":"lemma SeqReverseLen_1646(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_1647","instance":1647,"id":188318,"goal":"lemma SeqReverseIdem_1647(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_1648","instance":1648,"id":188319,"goal":"lemma SeqMapLen_1648(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_1649","instance":1649,"id":188320,"goal":"lemma SeqFilterLe_1649(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_1650","instance":1650,"id":188321,"goal":"lemma SeqMemberAppend_1650(s: seq, t: seq)\n ensures x in s + t <==> x in s || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_1651","instance":1651,"id":188322,"goal":"lemma SeqAppendLen_1651(t: seq, ys: seq)\n ensures |t + ys| == |t| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_1652","instance":1652,"id":188323,"goal":"lemma SeqAppendNil_1652(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_1653","instance":1653,"id":188324,"goal":"lemma SeqNilAppend_1653(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_1654","instance":1654,"id":188325,"goal":"lemma SeqAppendAssoc_1654(t: seq, zs: seq, s: seq)\n ensures (t + zs) + s == t + (zs + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_1655","instance":1655,"id":188326,"goal":"lemma SeqTakeDrop_1655(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_1656","instance":1656,"id":188327,"goal":"lemma SeqReverseLen_1656(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_1657","instance":1657,"id":188328,"goal":"lemma SeqReverseIdem_1657(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_1658","instance":1658,"id":188329,"goal":"lemma SeqMapLen_1658(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_1659","instance":1659,"id":188330,"goal":"lemma SeqFilterLe_1659(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_1660","instance":1660,"id":188331,"goal":"lemma SeqMemberAppend_1660(t: seq, u: seq)\n ensures x in t + u <==> x in t || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_1661","instance":1661,"id":188332,"goal":"lemma SeqAppendLen_1661(t: seq, ys: seq)\n ensures |t + ys| == |t| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_1662","instance":1662,"id":188333,"goal":"lemma SeqAppendNil_1662(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_1663","instance":1663,"id":188334,"goal":"lemma SeqNilAppend_1663(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_1664","instance":1664,"id":188335,"goal":"lemma SeqAppendAssoc_1664(s: seq, xs: seq, ys: seq)\n ensures (s + xs) + ys == s + (xs + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_1665","instance":1665,"id":188336,"goal":"lemma SeqTakeDrop_1665(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_1666","instance":1666,"id":188337,"goal":"lemma SeqReverseLen_1666(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_1667","instance":1667,"id":188338,"goal":"lemma SeqReverseIdem_1667(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_1668","instance":1668,"id":188339,"goal":"lemma SeqMapLen_1668(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_1669","instance":1669,"id":188340,"goal":"lemma SeqFilterLe_1669(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_1670","instance":1670,"id":188341,"goal":"lemma SeqMemberAppend_1670(ys: seq, xs: seq)\n ensures x in ys + xs <==> x in ys || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_1671","instance":1671,"id":188342,"goal":"lemma SeqAppendLen_1671(s: seq, zs: seq)\n ensures |s + zs| == |s| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_1672","instance":1672,"id":188343,"goal":"lemma SeqAppendNil_1672(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_1673","instance":1673,"id":188344,"goal":"lemma SeqNilAppend_1673(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_1674","instance":1674,"id":188345,"goal":"lemma SeqAppendAssoc_1674(ys: seq, s: seq, xs: seq)\n ensures (ys + s) + xs == ys + (s + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_1675","instance":1675,"id":188346,"goal":"lemma SeqTakeDrop_1675(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_1676","instance":1676,"id":188347,"goal":"lemma SeqReverseLen_1676(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_1677","instance":1677,"id":188348,"goal":"lemma SeqReverseIdem_1677(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_1678","instance":1678,"id":188349,"goal":"lemma SeqMapLen_1678(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_1679","instance":1679,"id":188350,"goal":"lemma SeqFilterLe_1679(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_1680","instance":1680,"id":188351,"goal":"lemma SeqMemberAppend_1680(zs: seq, u: seq)\n ensures x in zs + u <==> x in zs || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_1681","instance":1681,"id":188352,"goal":"lemma SeqAppendLen_1681(ys: seq, zs: seq)\n ensures |ys + zs| == |ys| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_1682","instance":1682,"id":188353,"goal":"lemma SeqAppendNil_1682(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_1683","instance":1683,"id":188354,"goal":"lemma SeqNilAppend_1683(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_1684","instance":1684,"id":188355,"goal":"lemma SeqAppendAssoc_1684(xs: seq, s: seq, u: seq)\n ensures (xs + s) + u == xs + (s + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_1685","instance":1685,"id":188356,"goal":"lemma SeqTakeDrop_1685(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_1686","instance":1686,"id":188357,"goal":"lemma SeqReverseLen_1686(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_1687","instance":1687,"id":188358,"goal":"lemma SeqReverseIdem_1687(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_1688","instance":1688,"id":188359,"goal":"lemma SeqMapLen_1688(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_1689","instance":1689,"id":188360,"goal":"lemma SeqFilterLe_1689(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_1690","instance":1690,"id":188361,"goal":"lemma SeqMemberAppend_1690(xs: seq, zs: seq)\n ensures x in xs + zs <==> x in xs || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_1691","instance":1691,"id":188362,"goal":"lemma SeqAppendLen_1691(ys: seq, zs: seq)\n ensures |ys + zs| == |ys| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_1692","instance":1692,"id":188363,"goal":"lemma SeqAppendNil_1692(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_1693","instance":1693,"id":188364,"goal":"lemma SeqNilAppend_1693(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_1694","instance":1694,"id":188365,"goal":"lemma SeqAppendAssoc_1694(u: seq, t: seq, s: seq)\n ensures (u + t) + s == u + (t + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_1695","instance":1695,"id":188366,"goal":"lemma SeqTakeDrop_1695(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_1696","instance":1696,"id":188367,"goal":"lemma SeqReverseLen_1696(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_1697","instance":1697,"id":188368,"goal":"lemma SeqReverseIdem_1697(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_1698","instance":1698,"id":188369,"goal":"lemma SeqMapLen_1698(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_1699","instance":1699,"id":188370,"goal":"lemma SeqFilterLe_1699(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_1700","instance":1700,"id":188371,"goal":"lemma SeqMemberAppend_1700(xs: seq, s: seq)\n ensures x in xs + s <==> x in xs || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_1701","instance":1701,"id":188372,"goal":"lemma SeqAppendLen_1701(xs: seq, u: seq)\n ensures |xs + u| == |xs| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_1702","instance":1702,"id":188373,"goal":"lemma SeqAppendNil_1702(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_1703","instance":1703,"id":188374,"goal":"lemma SeqNilAppend_1703(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_1704","instance":1704,"id":188375,"goal":"lemma SeqAppendAssoc_1704(t: seq, ys: seq, u: seq)\n ensures (t + ys) + u == t + (ys + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_1705","instance":1705,"id":188376,"goal":"lemma SeqTakeDrop_1705(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_1706","instance":1706,"id":188377,"goal":"lemma SeqReverseLen_1706(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_1707","instance":1707,"id":188378,"goal":"lemma SeqReverseIdem_1707(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_1708","instance":1708,"id":188379,"goal":"lemma SeqMapLen_1708(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_1709","instance":1709,"id":188380,"goal":"lemma SeqFilterLe_1709(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_1710","instance":1710,"id":188381,"goal":"lemma SeqMemberAppend_1710(ys: seq, s: seq)\n ensures x in ys + s <==> x in ys || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_1711","instance":1711,"id":188382,"goal":"lemma SeqAppendLen_1711(ys: seq, zs: seq)\n ensures |ys + zs| == |ys| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_1712","instance":1712,"id":188383,"goal":"lemma SeqAppendNil_1712(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_1713","instance":1713,"id":188384,"goal":"lemma SeqNilAppend_1713(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_1714","instance":1714,"id":188385,"goal":"lemma SeqAppendAssoc_1714(zs: seq, u: seq, ys: seq)\n ensures (zs + u) + ys == zs + (u + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_1715","instance":1715,"id":188386,"goal":"lemma SeqTakeDrop_1715(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_1716","instance":1716,"id":188387,"goal":"lemma SeqReverseLen_1716(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_1717","instance":1717,"id":188388,"goal":"lemma SeqReverseIdem_1717(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_1718","instance":1718,"id":188389,"goal":"lemma SeqMapLen_1718(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_1719","instance":1719,"id":188390,"goal":"lemma SeqFilterLe_1719(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_1720","instance":1720,"id":188391,"goal":"lemma SeqMemberAppend_1720(s: seq, zs: seq)\n ensures x in s + zs <==> x in s || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_1721","instance":1721,"id":188392,"goal":"lemma SeqAppendLen_1721(ys: seq, u: seq)\n ensures |ys + u| == |ys| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_1722","instance":1722,"id":188393,"goal":"lemma SeqAppendNil_1722(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_1723","instance":1723,"id":188394,"goal":"lemma SeqNilAppend_1723(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_1724","instance":1724,"id":188395,"goal":"lemma SeqAppendAssoc_1724(s: seq, u: seq, ys: seq)\n ensures (s + u) + ys == s + (u + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_1725","instance":1725,"id":188396,"goal":"lemma SeqTakeDrop_1725(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_1726","instance":1726,"id":188397,"goal":"lemma SeqReverseLen_1726(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_1727","instance":1727,"id":188398,"goal":"lemma SeqReverseIdem_1727(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_1728","instance":1728,"id":188399,"goal":"lemma SeqMapLen_1728(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_1729","instance":1729,"id":188400,"goal":"lemma SeqFilterLe_1729(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_1730","instance":1730,"id":188401,"goal":"lemma SeqMemberAppend_1730(zs: seq, u: seq)\n ensures x in zs + u <==> x in zs || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_1731","instance":1731,"id":188402,"goal":"lemma SeqAppendLen_1731(xs: seq, s: seq)\n ensures |xs + s| == |xs| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_1732","instance":1732,"id":188403,"goal":"lemma SeqAppendNil_1732(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_1733","instance":1733,"id":188404,"goal":"lemma SeqNilAppend_1733(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_1734","instance":1734,"id":188405,"goal":"lemma SeqAppendAssoc_1734(s: seq, xs: seq, t: seq)\n ensures (s + xs) + t == s + (xs + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_1735","instance":1735,"id":188406,"goal":"lemma SeqTakeDrop_1735(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_1736","instance":1736,"id":188407,"goal":"lemma SeqReverseLen_1736(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_1737","instance":1737,"id":188408,"goal":"lemma SeqReverseIdem_1737(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_1738","instance":1738,"id":188409,"goal":"lemma SeqMapLen_1738(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_1739","instance":1739,"id":188410,"goal":"lemma SeqFilterLe_1739(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_1740","instance":1740,"id":188411,"goal":"lemma SeqMemberAppend_1740(zs: seq, ys: seq)\n ensures x in zs + ys <==> x in zs || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_1741","instance":1741,"id":188412,"goal":"lemma SeqAppendLen_1741(u: seq, zs: seq)\n ensures |u + zs| == |u| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_1742","instance":1742,"id":188413,"goal":"lemma SeqAppendNil_1742(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_1743","instance":1743,"id":188414,"goal":"lemma SeqNilAppend_1743(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_1744","instance":1744,"id":188415,"goal":"lemma SeqAppendAssoc_1744(u: seq, zs: seq, s: seq)\n ensures (u + zs) + s == u + (zs + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_1745","instance":1745,"id":188416,"goal":"lemma SeqTakeDrop_1745(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_1746","instance":1746,"id":188417,"goal":"lemma SeqReverseLen_1746(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_1747","instance":1747,"id":188418,"goal":"lemma SeqReverseIdem_1747(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_1748","instance":1748,"id":188419,"goal":"lemma SeqMapLen_1748(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_1749","instance":1749,"id":188420,"goal":"lemma SeqFilterLe_1749(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_1750","instance":1750,"id":188421,"goal":"lemma SeqMemberAppend_1750(ys: seq, t: seq)\n ensures x in ys + t <==> x in ys || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_1751","instance":1751,"id":188422,"goal":"lemma SeqAppendLen_1751(t: seq, ys: seq)\n ensures |t + ys| == |t| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_1752","instance":1752,"id":188423,"goal":"lemma SeqAppendNil_1752(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_1753","instance":1753,"id":188424,"goal":"lemma SeqNilAppend_1753(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_1754","instance":1754,"id":188425,"goal":"lemma SeqAppendAssoc_1754(xs: seq, zs: seq, ys: seq)\n ensures (xs + zs) + ys == xs + (zs + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_1755","instance":1755,"id":188426,"goal":"lemma SeqTakeDrop_1755(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_1756","instance":1756,"id":188427,"goal":"lemma SeqReverseLen_1756(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_1757","instance":1757,"id":188428,"goal":"lemma SeqReverseIdem_1757(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_1758","instance":1758,"id":188429,"goal":"lemma SeqMapLen_1758(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_1759","instance":1759,"id":188430,"goal":"lemma SeqFilterLe_1759(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_1760","instance":1760,"id":188431,"goal":"lemma SeqMemberAppend_1760(u: seq, xs: seq)\n ensures x in u + xs <==> x in u || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_1761","instance":1761,"id":188432,"goal":"lemma SeqAppendLen_1761(s: seq, xs: seq)\n ensures |s + xs| == |s| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_1762","instance":1762,"id":188433,"goal":"lemma SeqAppendNil_1762(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_1763","instance":1763,"id":188434,"goal":"lemma SeqNilAppend_1763(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_1764","instance":1764,"id":188435,"goal":"lemma SeqAppendAssoc_1764(ys: seq, xs: seq, s: seq)\n ensures (ys + xs) + s == ys + (xs + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_1765","instance":1765,"id":188436,"goal":"lemma SeqTakeDrop_1765(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_1766","instance":1766,"id":188437,"goal":"lemma SeqReverseLen_1766(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_1767","instance":1767,"id":188438,"goal":"lemma SeqReverseIdem_1767(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_1768","instance":1768,"id":188439,"goal":"lemma SeqMapLen_1768(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_1769","instance":1769,"id":188440,"goal":"lemma SeqFilterLe_1769(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_1770","instance":1770,"id":188441,"goal":"lemma SeqMemberAppend_1770(u: seq, s: seq)\n ensures x in u + s <==> x in u || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_1771","instance":1771,"id":188442,"goal":"lemma SeqAppendLen_1771(ys: seq, zs: seq)\n ensures |ys + zs| == |ys| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_1772","instance":1772,"id":188443,"goal":"lemma SeqAppendNil_1772(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_1773","instance":1773,"id":188444,"goal":"lemma SeqNilAppend_1773(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_1774","instance":1774,"id":188445,"goal":"lemma SeqAppendAssoc_1774(u: seq, s: seq, xs: seq)\n ensures (u + s) + xs == u + (s + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_1775","instance":1775,"id":188446,"goal":"lemma SeqTakeDrop_1775(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_1776","instance":1776,"id":188447,"goal":"lemma SeqReverseLen_1776(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_1777","instance":1777,"id":188448,"goal":"lemma SeqReverseIdem_1777(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_1778","instance":1778,"id":188449,"goal":"lemma SeqMapLen_1778(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_1779","instance":1779,"id":188450,"goal":"lemma SeqFilterLe_1779(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_1780","instance":1780,"id":188451,"goal":"lemma SeqMemberAppend_1780(xs: seq, s: seq)\n ensures x in xs + s <==> x in xs || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_1781","instance":1781,"id":188452,"goal":"lemma SeqAppendLen_1781(xs: seq, zs: seq)\n ensures |xs + zs| == |xs| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_1782","instance":1782,"id":188453,"goal":"lemma SeqAppendNil_1782(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_1783","instance":1783,"id":188454,"goal":"lemma SeqNilAppend_1783(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_1784","instance":1784,"id":188455,"goal":"lemma SeqAppendAssoc_1784(zs: seq, s: seq, xs: seq)\n ensures (zs + s) + xs == zs + (s + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_1785","instance":1785,"id":188456,"goal":"lemma SeqTakeDrop_1785(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_1786","instance":1786,"id":188457,"goal":"lemma SeqReverseLen_1786(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_1787","instance":1787,"id":188458,"goal":"lemma SeqReverseIdem_1787(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_1788","instance":1788,"id":188459,"goal":"lemma SeqMapLen_1788(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_1789","instance":1789,"id":188460,"goal":"lemma SeqFilterLe_1789(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_1790","instance":1790,"id":188461,"goal":"lemma SeqMemberAppend_1790(ys: seq, t: seq)\n ensures x in ys + t <==> x in ys || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_1791","instance":1791,"id":188462,"goal":"lemma SeqAppendLen_1791(s: seq, xs: seq)\n ensures |s + xs| == |s| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_1792","instance":1792,"id":188463,"goal":"lemma SeqAppendNil_1792(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_1793","instance":1793,"id":188464,"goal":"lemma SeqNilAppend_1793(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_1794","instance":1794,"id":188465,"goal":"lemma SeqAppendAssoc_1794(xs: seq, s: seq, zs: seq)\n ensures (xs + s) + zs == xs + (s + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_1795","instance":1795,"id":188466,"goal":"lemma SeqTakeDrop_1795(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_1796","instance":1796,"id":188467,"goal":"lemma SeqReverseLen_1796(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_1797","instance":1797,"id":188468,"goal":"lemma SeqReverseIdem_1797(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_1798","instance":1798,"id":188469,"goal":"lemma SeqMapLen_1798(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_1799","instance":1799,"id":188470,"goal":"lemma SeqFilterLe_1799(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_1800","instance":1800,"id":188471,"goal":"lemma SeqMemberAppend_1800(ys: seq, u: seq)\n ensures x in ys + u <==> x in ys || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_1801","instance":1801,"id":188472,"goal":"lemma SeqAppendLen_1801(u: seq, ys: seq)\n ensures |u + ys| == |u| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_1802","instance":1802,"id":188473,"goal":"lemma SeqAppendNil_1802(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_1803","instance":1803,"id":188474,"goal":"lemma SeqNilAppend_1803(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_1804","instance":1804,"id":188475,"goal":"lemma SeqAppendAssoc_1804(u: seq, xs: seq, ys: seq)\n ensures (u + xs) + ys == u + (xs + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_1805","instance":1805,"id":188476,"goal":"lemma SeqTakeDrop_1805(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_1806","instance":1806,"id":188477,"goal":"lemma SeqReverseLen_1806(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_1807","instance":1807,"id":188478,"goal":"lemma SeqReverseIdem_1807(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_1808","instance":1808,"id":188479,"goal":"lemma SeqMapLen_1808(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_1809","instance":1809,"id":188480,"goal":"lemma SeqFilterLe_1809(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_1810","instance":1810,"id":188481,"goal":"lemma SeqMemberAppend_1810(zs: seq, s: seq)\n ensures x in zs + s <==> x in zs || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_1811","instance":1811,"id":188482,"goal":"lemma SeqAppendLen_1811(s: seq, t: seq)\n ensures |s + t| == |s| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_1812","instance":1812,"id":188483,"goal":"lemma SeqAppendNil_1812(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_1813","instance":1813,"id":188484,"goal":"lemma SeqNilAppend_1813(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_1814","instance":1814,"id":188485,"goal":"lemma SeqAppendAssoc_1814(zs: seq, ys: seq, u: seq)\n ensures (zs + ys) + u == zs + (ys + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_1815","instance":1815,"id":188486,"goal":"lemma SeqTakeDrop_1815(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_1816","instance":1816,"id":188487,"goal":"lemma SeqReverseLen_1816(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_1817","instance":1817,"id":188488,"goal":"lemma SeqReverseIdem_1817(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_1818","instance":1818,"id":188489,"goal":"lemma SeqMapLen_1818(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_1819","instance":1819,"id":188490,"goal":"lemma SeqFilterLe_1819(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_1820","instance":1820,"id":188491,"goal":"lemma SeqMemberAppend_1820(xs: seq, ys: seq)\n ensures x in xs + ys <==> x in xs || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_1821","instance":1821,"id":188492,"goal":"lemma SeqAppendLen_1821(xs: seq, t: seq)\n ensures |xs + t| == |xs| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_1822","instance":1822,"id":188493,"goal":"lemma SeqAppendNil_1822(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_1823","instance":1823,"id":188494,"goal":"lemma SeqNilAppend_1823(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_1824","instance":1824,"id":188495,"goal":"lemma SeqAppendAssoc_1824(t: seq, u: seq, xs: seq)\n ensures (t + u) + xs == t + (u + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_1825","instance":1825,"id":188496,"goal":"lemma SeqTakeDrop_1825(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_1826","instance":1826,"id":188497,"goal":"lemma SeqReverseLen_1826(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_1827","instance":1827,"id":188498,"goal":"lemma SeqReverseIdem_1827(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_1828","instance":1828,"id":188499,"goal":"lemma SeqMapLen_1828(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_1829","instance":1829,"id":188500,"goal":"lemma SeqFilterLe_1829(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_1830","instance":1830,"id":188501,"goal":"lemma SeqMemberAppend_1830(ys: seq, u: seq)\n ensures x in ys + u <==> x in ys || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_1831","instance":1831,"id":188502,"goal":"lemma SeqAppendLen_1831(t: seq, s: seq)\n ensures |t + s| == |t| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_1832","instance":1832,"id":188503,"goal":"lemma SeqAppendNil_1832(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_1833","instance":1833,"id":188504,"goal":"lemma SeqNilAppend_1833(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_1834","instance":1834,"id":188505,"goal":"lemma SeqAppendAssoc_1834(ys: seq, s: seq, zs: seq)\n ensures (ys + s) + zs == ys + (s + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_1835","instance":1835,"id":188506,"goal":"lemma SeqTakeDrop_1835(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_1836","instance":1836,"id":188507,"goal":"lemma SeqReverseLen_1836(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_1837","instance":1837,"id":188508,"goal":"lemma SeqReverseIdem_1837(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_1838","instance":1838,"id":188509,"goal":"lemma SeqMapLen_1838(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_1839","instance":1839,"id":188510,"goal":"lemma SeqFilterLe_1839(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_1840","instance":1840,"id":188511,"goal":"lemma SeqMemberAppend_1840(zs: seq, s: seq)\n ensures x in zs + s <==> x in zs || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_1841","instance":1841,"id":188512,"goal":"lemma SeqAppendLen_1841(u: seq, s: seq)\n ensures |u + s| == |u| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_1842","instance":1842,"id":188513,"goal":"lemma SeqAppendNil_1842(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_1843","instance":1843,"id":188514,"goal":"lemma SeqNilAppend_1843(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_1844","instance":1844,"id":188515,"goal":"lemma SeqAppendAssoc_1844(ys: seq, t: seq, u: seq)\n ensures (ys + t) + u == ys + (t + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_1845","instance":1845,"id":188516,"goal":"lemma SeqTakeDrop_1845(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_1846","instance":1846,"id":188517,"goal":"lemma SeqReverseLen_1846(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_1847","instance":1847,"id":188518,"goal":"lemma SeqReverseIdem_1847(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_1848","instance":1848,"id":188519,"goal":"lemma SeqMapLen_1848(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_1849","instance":1849,"id":188520,"goal":"lemma SeqFilterLe_1849(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_1850","instance":1850,"id":188521,"goal":"lemma SeqMemberAppend_1850(ys: seq, s: seq)\n ensures x in ys + s <==> x in ys || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_1851","instance":1851,"id":188522,"goal":"lemma SeqAppendLen_1851(s: seq, t: seq)\n ensures |s + t| == |s| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_1852","instance":1852,"id":188523,"goal":"lemma SeqAppendNil_1852(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_1853","instance":1853,"id":188524,"goal":"lemma SeqNilAppend_1853(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_1854","instance":1854,"id":188525,"goal":"lemma SeqAppendAssoc_1854(ys: seq, u: seq, zs: seq)\n ensures (ys + u) + zs == ys + (u + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_1855","instance":1855,"id":188526,"goal":"lemma SeqTakeDrop_1855(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_1856","instance":1856,"id":188527,"goal":"lemma SeqReverseLen_1856(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_1857","instance":1857,"id":188528,"goal":"lemma SeqReverseIdem_1857(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_1858","instance":1858,"id":188529,"goal":"lemma SeqMapLen_1858(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_1859","instance":1859,"id":188530,"goal":"lemma SeqFilterLe_1859(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_1860","instance":1860,"id":188531,"goal":"lemma SeqMemberAppend_1860(xs: seq, s: seq)\n ensures x in xs + s <==> x in xs || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_1861","instance":1861,"id":188532,"goal":"lemma SeqAppendLen_1861(zs: seq, u: seq)\n ensures |zs + u| == |zs| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_1862","instance":1862,"id":188533,"goal":"lemma SeqAppendNil_1862(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_1863","instance":1863,"id":188534,"goal":"lemma SeqNilAppend_1863(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_1864","instance":1864,"id":188535,"goal":"lemma SeqAppendAssoc_1864(s: seq, ys: seq, u: seq)\n ensures (s + ys) + u == s + (ys + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_1865","instance":1865,"id":188536,"goal":"lemma SeqTakeDrop_1865(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_1866","instance":1866,"id":188537,"goal":"lemma SeqReverseLen_1866(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_1867","instance":1867,"id":188538,"goal":"lemma SeqReverseIdem_1867(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_1868","instance":1868,"id":188539,"goal":"lemma SeqMapLen_1868(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_1869","instance":1869,"id":188540,"goal":"lemma SeqFilterLe_1869(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_1870","instance":1870,"id":188541,"goal":"lemma SeqMemberAppend_1870(xs: seq, s: seq)\n ensures x in xs + s <==> x in xs || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_1871","instance":1871,"id":188542,"goal":"lemma SeqAppendLen_1871(xs: seq, t: seq)\n ensures |xs + t| == |xs| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_1872","instance":1872,"id":188543,"goal":"lemma SeqAppendNil_1872(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_1873","instance":1873,"id":188544,"goal":"lemma SeqNilAppend_1873(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_1874","instance":1874,"id":188545,"goal":"lemma SeqAppendAssoc_1874(xs: seq, s: seq, u: seq)\n ensures (xs + s) + u == xs + (s + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_1875","instance":1875,"id":188546,"goal":"lemma SeqTakeDrop_1875(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_1876","instance":1876,"id":188547,"goal":"lemma SeqReverseLen_1876(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_1877","instance":1877,"id":188548,"goal":"lemma SeqReverseIdem_1877(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_1878","instance":1878,"id":188549,"goal":"lemma SeqMapLen_1878(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_1879","instance":1879,"id":188550,"goal":"lemma SeqFilterLe_1879(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_1880","instance":1880,"id":188551,"goal":"lemma SeqMemberAppend_1880(xs: seq, zs: seq)\n ensures x in xs + zs <==> x in xs || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_1881","instance":1881,"id":188552,"goal":"lemma SeqAppendLen_1881(zs: seq, xs: seq)\n ensures |zs + xs| == |zs| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_1882","instance":1882,"id":188553,"goal":"lemma SeqAppendNil_1882(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_1883","instance":1883,"id":188554,"goal":"lemma SeqNilAppend_1883(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_1884","instance":1884,"id":188555,"goal":"lemma SeqAppendAssoc_1884(t: seq, s: seq, zs: seq)\n ensures (t + s) + zs == t + (s + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_1885","instance":1885,"id":188556,"goal":"lemma SeqTakeDrop_1885(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_1886","instance":1886,"id":188557,"goal":"lemma SeqReverseLen_1886(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_1887","instance":1887,"id":188558,"goal":"lemma SeqReverseIdem_1887(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_1888","instance":1888,"id":188559,"goal":"lemma SeqMapLen_1888(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_1889","instance":1889,"id":188560,"goal":"lemma SeqFilterLe_1889(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_1890","instance":1890,"id":188561,"goal":"lemma SeqMemberAppend_1890(xs: seq, zs: seq)\n ensures x in xs + zs <==> x in xs || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_1891","instance":1891,"id":188562,"goal":"lemma SeqAppendLen_1891(zs: seq, xs: seq)\n ensures |zs + xs| == |zs| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_1892","instance":1892,"id":188563,"goal":"lemma SeqAppendNil_1892(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_1893","instance":1893,"id":188564,"goal":"lemma SeqNilAppend_1893(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_1894","instance":1894,"id":188565,"goal":"lemma SeqAppendAssoc_1894(t: seq, s: seq, u: seq)\n ensures (t + s) + u == t + (s + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_1895","instance":1895,"id":188566,"goal":"lemma SeqTakeDrop_1895(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_1896","instance":1896,"id":188567,"goal":"lemma SeqReverseLen_1896(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_1897","instance":1897,"id":188568,"goal":"lemma SeqReverseIdem_1897(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_1898","instance":1898,"id":188569,"goal":"lemma SeqMapLen_1898(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_1899","instance":1899,"id":188570,"goal":"lemma SeqFilterLe_1899(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_1900","instance":1900,"id":188571,"goal":"lemma SeqMemberAppend_1900(s: seq, ys: seq)\n ensures x in s + ys <==> x in s || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_1901","instance":1901,"id":188572,"goal":"lemma SeqAppendLen_1901(t: seq, ys: seq)\n ensures |t + ys| == |t| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_1902","instance":1902,"id":188573,"goal":"lemma SeqAppendNil_1902(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_1903","instance":1903,"id":188574,"goal":"lemma SeqNilAppend_1903(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_1904","instance":1904,"id":188575,"goal":"lemma SeqAppendAssoc_1904(zs: seq, xs: seq, t: seq)\n ensures (zs + xs) + t == zs + (xs + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_1905","instance":1905,"id":188576,"goal":"lemma SeqTakeDrop_1905(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_1906","instance":1906,"id":188577,"goal":"lemma SeqReverseLen_1906(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_1907","instance":1907,"id":188578,"goal":"lemma SeqReverseIdem_1907(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_1908","instance":1908,"id":188579,"goal":"lemma SeqMapLen_1908(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_1909","instance":1909,"id":188580,"goal":"lemma SeqFilterLe_1909(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_1910","instance":1910,"id":188581,"goal":"lemma SeqMemberAppend_1910(u: seq, zs: seq)\n ensures x in u + zs <==> x in u || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_1911","instance":1911,"id":188582,"goal":"lemma SeqAppendLen_1911(t: seq, s: seq)\n ensures |t + s| == |t| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_1912","instance":1912,"id":188583,"goal":"lemma SeqAppendNil_1912(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_1913","instance":1913,"id":188584,"goal":"lemma SeqNilAppend_1913(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_1914","instance":1914,"id":188585,"goal":"lemma SeqAppendAssoc_1914(zs: seq, s: seq, u: seq)\n ensures (zs + s) + u == zs + (s + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_1915","instance":1915,"id":188586,"goal":"lemma SeqTakeDrop_1915(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_1916","instance":1916,"id":188587,"goal":"lemma SeqReverseLen_1916(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_1917","instance":1917,"id":188588,"goal":"lemma SeqReverseIdem_1917(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_1918","instance":1918,"id":188589,"goal":"lemma SeqMapLen_1918(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_1919","instance":1919,"id":188590,"goal":"lemma SeqFilterLe_1919(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_1920","instance":1920,"id":188591,"goal":"lemma SeqMemberAppend_1920(xs: seq, ys: seq)\n ensures x in xs + ys <==> x in xs || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_1921","instance":1921,"id":188592,"goal":"lemma SeqAppendLen_1921(zs: seq, t: seq)\n ensures |zs + t| == |zs| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_1922","instance":1922,"id":188593,"goal":"lemma SeqAppendNil_1922(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_1923","instance":1923,"id":188594,"goal":"lemma SeqNilAppend_1923(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_1924","instance":1924,"id":188595,"goal":"lemma SeqAppendAssoc_1924(u: seq, xs: seq, ys: seq)\n ensures (u + xs) + ys == u + (xs + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_1925","instance":1925,"id":188596,"goal":"lemma SeqTakeDrop_1925(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_1926","instance":1926,"id":188597,"goal":"lemma SeqReverseLen_1926(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_1927","instance":1927,"id":188598,"goal":"lemma SeqReverseIdem_1927(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_1928","instance":1928,"id":188599,"goal":"lemma SeqMapLen_1928(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_1929","instance":1929,"id":188600,"goal":"lemma SeqFilterLe_1929(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_1930","instance":1930,"id":188601,"goal":"lemma SeqMemberAppend_1930(ys: seq, xs: seq)\n ensures x in ys + xs <==> x in ys || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_1931","instance":1931,"id":188602,"goal":"lemma SeqAppendLen_1931(s: seq, ys: seq)\n ensures |s + ys| == |s| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_1932","instance":1932,"id":188603,"goal":"lemma SeqAppendNil_1932(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_1933","instance":1933,"id":188604,"goal":"lemma SeqNilAppend_1933(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_1934","instance":1934,"id":188605,"goal":"lemma SeqAppendAssoc_1934(xs: seq, u: seq, ys: seq)\n ensures (xs + u) + ys == xs + (u + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_1935","instance":1935,"id":188606,"goal":"lemma SeqTakeDrop_1935(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_1936","instance":1936,"id":188607,"goal":"lemma SeqReverseLen_1936(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_1937","instance":1937,"id":188608,"goal":"lemma SeqReverseIdem_1937(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_1938","instance":1938,"id":188609,"goal":"lemma SeqMapLen_1938(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_1939","instance":1939,"id":188610,"goal":"lemma SeqFilterLe_1939(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_1940","instance":1940,"id":188611,"goal":"lemma SeqMemberAppend_1940(ys: seq, t: seq)\n ensures x in ys + t <==> x in ys || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_1941","instance":1941,"id":188612,"goal":"lemma SeqAppendLen_1941(zs: seq, u: seq)\n ensures |zs + u| == |zs| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_1942","instance":1942,"id":188613,"goal":"lemma SeqAppendNil_1942(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_1943","instance":1943,"id":188614,"goal":"lemma SeqNilAppend_1943(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_1944","instance":1944,"id":188615,"goal":"lemma SeqAppendAssoc_1944(zs: seq, s: seq, u: seq)\n ensures (zs + s) + u == zs + (s + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_1945","instance":1945,"id":188616,"goal":"lemma SeqTakeDrop_1945(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_1946","instance":1946,"id":188617,"goal":"lemma SeqReverseLen_1946(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_1947","instance":1947,"id":188618,"goal":"lemma SeqReverseIdem_1947(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_1948","instance":1948,"id":188619,"goal":"lemma SeqMapLen_1948(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_1949","instance":1949,"id":188620,"goal":"lemma SeqFilterLe_1949(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_1950","instance":1950,"id":188621,"goal":"lemma SeqMemberAppend_1950(xs: seq, t: seq)\n ensures x in xs + t <==> x in xs || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_1951","instance":1951,"id":188622,"goal":"lemma SeqAppendLen_1951(xs: seq, s: seq)\n ensures |xs + s| == |xs| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_1952","instance":1952,"id":188623,"goal":"lemma SeqAppendNil_1952(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_1953","instance":1953,"id":188624,"goal":"lemma SeqNilAppend_1953(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_1954","instance":1954,"id":188625,"goal":"lemma SeqAppendAssoc_1954(ys: seq, xs: seq, u: seq)\n ensures (ys + xs) + u == ys + (xs + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_1955","instance":1955,"id":188626,"goal":"lemma SeqTakeDrop_1955(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_1956","instance":1956,"id":188627,"goal":"lemma SeqReverseLen_1956(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_1957","instance":1957,"id":188628,"goal":"lemma SeqReverseIdem_1957(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_1958","instance":1958,"id":188629,"goal":"lemma SeqMapLen_1958(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_1959","instance":1959,"id":188630,"goal":"lemma SeqFilterLe_1959(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_1960","instance":1960,"id":188631,"goal":"lemma SeqMemberAppend_1960(u: seq, ys: seq)\n ensures x in u + ys <==> x in u || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_1961","instance":1961,"id":188632,"goal":"lemma SeqAppendLen_1961(ys: seq, xs: seq)\n ensures |ys + xs| == |ys| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_1962","instance":1962,"id":188633,"goal":"lemma SeqAppendNil_1962(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_1963","instance":1963,"id":188634,"goal":"lemma SeqNilAppend_1963(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_1964","instance":1964,"id":188635,"goal":"lemma SeqAppendAssoc_1964(s: seq, zs: seq, xs: seq)\n ensures (s + zs) + xs == s + (zs + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_1965","instance":1965,"id":188636,"goal":"lemma SeqTakeDrop_1965(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_1966","instance":1966,"id":188637,"goal":"lemma SeqReverseLen_1966(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_1967","instance":1967,"id":188638,"goal":"lemma SeqReverseIdem_1967(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_1968","instance":1968,"id":188639,"goal":"lemma SeqMapLen_1968(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_1969","instance":1969,"id":188640,"goal":"lemma SeqFilterLe_1969(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_1970","instance":1970,"id":188641,"goal":"lemma SeqMemberAppend_1970(t: seq, zs: seq)\n ensures x in t + zs <==> x in t || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_1971","instance":1971,"id":188642,"goal":"lemma SeqAppendLen_1971(u: seq, ys: seq)\n ensures |u + ys| == |u| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_1972","instance":1972,"id":188643,"goal":"lemma SeqAppendNil_1972(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_1973","instance":1973,"id":188644,"goal":"lemma SeqNilAppend_1973(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_1974","instance":1974,"id":188645,"goal":"lemma SeqAppendAssoc_1974(xs: seq, s: seq, zs: seq)\n ensures (xs + s) + zs == xs + (s + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_1975","instance":1975,"id":188646,"goal":"lemma SeqTakeDrop_1975(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_1976","instance":1976,"id":188647,"goal":"lemma SeqReverseLen_1976(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_1977","instance":1977,"id":188648,"goal":"lemma SeqReverseIdem_1977(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_1978","instance":1978,"id":188649,"goal":"lemma SeqMapLen_1978(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_1979","instance":1979,"id":188650,"goal":"lemma SeqFilterLe_1979(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_1980","instance":1980,"id":188651,"goal":"lemma SeqMemberAppend_1980(xs: seq, u: seq)\n ensures x in xs + u <==> x in xs || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_1981","instance":1981,"id":188652,"goal":"lemma SeqAppendLen_1981(t: seq, xs: seq)\n ensures |t + xs| == |t| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_1982","instance":1982,"id":188653,"goal":"lemma SeqAppendNil_1982(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_1983","instance":1983,"id":188654,"goal":"lemma SeqNilAppend_1983(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_1984","instance":1984,"id":188655,"goal":"lemma SeqAppendAssoc_1984(s: seq, t: seq, zs: seq)\n ensures (s + t) + zs == s + (t + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_1985","instance":1985,"id":188656,"goal":"lemma SeqTakeDrop_1985(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_1986","instance":1986,"id":188657,"goal":"lemma SeqReverseLen_1986(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_1987","instance":1987,"id":188658,"goal":"lemma SeqReverseIdem_1987(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_1988","instance":1988,"id":188659,"goal":"lemma SeqMapLen_1988(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_1989","instance":1989,"id":188660,"goal":"lemma SeqFilterLe_1989(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_1990","instance":1990,"id":188661,"goal":"lemma SeqMemberAppend_1990(s: seq, ys: seq)\n ensures x in s + ys <==> x in s || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_1991","instance":1991,"id":188662,"goal":"lemma SeqAppendLen_1991(t: seq, u: seq)\n ensures |t + u| == |t| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_1992","instance":1992,"id":188663,"goal":"lemma SeqAppendNil_1992(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_1993","instance":1993,"id":188664,"goal":"lemma SeqNilAppend_1993(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_1994","instance":1994,"id":188665,"goal":"lemma SeqAppendAssoc_1994(ys: seq, s: seq, xs: seq)\n ensures (ys + s) + xs == ys + (s + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_1995","instance":1995,"id":188666,"goal":"lemma SeqTakeDrop_1995(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_1996","instance":1996,"id":188667,"goal":"lemma SeqReverseLen_1996(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_1997","instance":1997,"id":188668,"goal":"lemma SeqReverseIdem_1997(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_1998","instance":1998,"id":188669,"goal":"lemma SeqMapLen_1998(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_1999","instance":1999,"id":188670,"goal":"lemma SeqFilterLe_1999(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_2000","instance":2000,"id":188671,"goal":"lemma SeqMemberAppend_2000(t: seq, xs: seq)\n ensures x in t + xs <==> x in t || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_2001","instance":2001,"id":188672,"goal":"lemma SeqAppendLen_2001(ys: seq, xs: seq)\n ensures |ys + xs| == |ys| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_2002","instance":2002,"id":188673,"goal":"lemma SeqAppendNil_2002(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_2003","instance":2003,"id":188674,"goal":"lemma SeqNilAppend_2003(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_2004","instance":2004,"id":188675,"goal":"lemma SeqAppendAssoc_2004(t: seq, xs: seq, ys: seq)\n ensures (t + xs) + ys == t + (xs + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_2005","instance":2005,"id":188676,"goal":"lemma SeqTakeDrop_2005(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_2006","instance":2006,"id":188677,"goal":"lemma SeqReverseLen_2006(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_2007","instance":2007,"id":188678,"goal":"lemma SeqReverseIdem_2007(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_2008","instance":2008,"id":188679,"goal":"lemma SeqMapLen_2008(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_2009","instance":2009,"id":188680,"goal":"lemma SeqFilterLe_2009(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_2010","instance":2010,"id":188681,"goal":"lemma SeqMemberAppend_2010(xs: seq, s: seq)\n ensures x in xs + s <==> x in xs || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_2011","instance":2011,"id":188682,"goal":"lemma SeqAppendLen_2011(xs: seq, ys: seq)\n ensures |xs + ys| == |xs| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_2012","instance":2012,"id":188683,"goal":"lemma SeqAppendNil_2012(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_2013","instance":2013,"id":188684,"goal":"lemma SeqNilAppend_2013(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_2014","instance":2014,"id":188685,"goal":"lemma SeqAppendAssoc_2014(t: seq, ys: seq, s: seq)\n ensures (t + ys) + s == t + (ys + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_2015","instance":2015,"id":188686,"goal":"lemma SeqTakeDrop_2015(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_2016","instance":2016,"id":188687,"goal":"lemma SeqReverseLen_2016(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_2017","instance":2017,"id":188688,"goal":"lemma SeqReverseIdem_2017(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_2018","instance":2018,"id":188689,"goal":"lemma SeqMapLen_2018(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_2019","instance":2019,"id":188690,"goal":"lemma SeqFilterLe_2019(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_2020","instance":2020,"id":188691,"goal":"lemma SeqMemberAppend_2020(xs: seq, ys: seq)\n ensures x in xs + ys <==> x in xs || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_2021","instance":2021,"id":188692,"goal":"lemma SeqAppendLen_2021(ys: seq, t: seq)\n ensures |ys + t| == |ys| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_2022","instance":2022,"id":188693,"goal":"lemma SeqAppendNil_2022(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_2023","instance":2023,"id":188694,"goal":"lemma SeqNilAppend_2023(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_2024","instance":2024,"id":188695,"goal":"lemma SeqAppendAssoc_2024(xs: seq, s: seq, zs: seq)\n ensures (xs + s) + zs == xs + (s + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_2025","instance":2025,"id":188696,"goal":"lemma SeqTakeDrop_2025(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_2026","instance":2026,"id":188697,"goal":"lemma SeqReverseLen_2026(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_2027","instance":2027,"id":188698,"goal":"lemma SeqReverseIdem_2027(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_2028","instance":2028,"id":188699,"goal":"lemma SeqMapLen_2028(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_2029","instance":2029,"id":188700,"goal":"lemma SeqFilterLe_2029(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_2030","instance":2030,"id":188701,"goal":"lemma SeqMemberAppend_2030(ys: seq, xs: seq)\n ensures x in ys + xs <==> x in ys || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_2031","instance":2031,"id":188702,"goal":"lemma SeqAppendLen_2031(s: seq, ys: seq)\n ensures |s + ys| == |s| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_2032","instance":2032,"id":188703,"goal":"lemma SeqAppendNil_2032(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_2033","instance":2033,"id":188704,"goal":"lemma SeqNilAppend_2033(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_2034","instance":2034,"id":188705,"goal":"lemma SeqAppendAssoc_2034(t: seq, u: seq, ys: seq)\n ensures (t + u) + ys == t + (u + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_2035","instance":2035,"id":188706,"goal":"lemma SeqTakeDrop_2035(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_2036","instance":2036,"id":188707,"goal":"lemma SeqReverseLen_2036(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_2037","instance":2037,"id":188708,"goal":"lemma SeqReverseIdem_2037(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_2038","instance":2038,"id":188709,"goal":"lemma SeqMapLen_2038(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_2039","instance":2039,"id":188710,"goal":"lemma SeqFilterLe_2039(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_2040","instance":2040,"id":188711,"goal":"lemma SeqMemberAppend_2040(xs: seq, zs: seq)\n ensures x in xs + zs <==> x in xs || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_2041","instance":2041,"id":188712,"goal":"lemma SeqAppendLen_2041(s: seq, zs: seq)\n ensures |s + zs| == |s| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_2042","instance":2042,"id":188713,"goal":"lemma SeqAppendNil_2042(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_2043","instance":2043,"id":188714,"goal":"lemma SeqNilAppend_2043(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_2044","instance":2044,"id":188715,"goal":"lemma SeqAppendAssoc_2044(s: seq, xs: seq, u: seq)\n ensures (s + xs) + u == s + (xs + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_2045","instance":2045,"id":188716,"goal":"lemma SeqTakeDrop_2045(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_2046","instance":2046,"id":188717,"goal":"lemma SeqReverseLen_2046(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_2047","instance":2047,"id":188718,"goal":"lemma SeqReverseIdem_2047(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_2048","instance":2048,"id":188719,"goal":"lemma SeqMapLen_2048(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_2049","instance":2049,"id":188720,"goal":"lemma SeqFilterLe_2049(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_2050","instance":2050,"id":188721,"goal":"lemma SeqMemberAppend_2050(t: seq, xs: seq)\n ensures x in t + xs <==> x in t || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_2051","instance":2051,"id":188722,"goal":"lemma SeqAppendLen_2051(u: seq, ys: seq)\n ensures |u + ys| == |u| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_2052","instance":2052,"id":188723,"goal":"lemma SeqAppendNil_2052(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_2053","instance":2053,"id":188724,"goal":"lemma SeqNilAppend_2053(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_2054","instance":2054,"id":188725,"goal":"lemma SeqAppendAssoc_2054(t: seq, zs: seq, xs: seq)\n ensures (t + zs) + xs == t + (zs + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_2055","instance":2055,"id":188726,"goal":"lemma SeqTakeDrop_2055(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_2056","instance":2056,"id":188727,"goal":"lemma SeqReverseLen_2056(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_2057","instance":2057,"id":188728,"goal":"lemma SeqReverseIdem_2057(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_2058","instance":2058,"id":188729,"goal":"lemma SeqMapLen_2058(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_2059","instance":2059,"id":188730,"goal":"lemma SeqFilterLe_2059(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_2060","instance":2060,"id":188731,"goal":"lemma SeqMemberAppend_2060(t: seq, zs: seq)\n ensures x in t + zs <==> x in t || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_2061","instance":2061,"id":188732,"goal":"lemma SeqAppendLen_2061(zs: seq, ys: seq)\n ensures |zs + ys| == |zs| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_2062","instance":2062,"id":188733,"goal":"lemma SeqAppendNil_2062(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_2063","instance":2063,"id":188734,"goal":"lemma SeqNilAppend_2063(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_2064","instance":2064,"id":188735,"goal":"lemma SeqAppendAssoc_2064(s: seq, t: seq, zs: seq)\n ensures (s + t) + zs == s + (t + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_2065","instance":2065,"id":188736,"goal":"lemma SeqTakeDrop_2065(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_2066","instance":2066,"id":188737,"goal":"lemma SeqReverseLen_2066(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_2067","instance":2067,"id":188738,"goal":"lemma SeqReverseIdem_2067(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_2068","instance":2068,"id":188739,"goal":"lemma SeqMapLen_2068(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_2069","instance":2069,"id":188740,"goal":"lemma SeqFilterLe_2069(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_2070","instance":2070,"id":188741,"goal":"lemma SeqMemberAppend_2070(u: seq, xs: seq)\n ensures x in u + xs <==> x in u || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_2071","instance":2071,"id":188742,"goal":"lemma SeqAppendLen_2071(u: seq, t: seq)\n ensures |u + t| == |u| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_2072","instance":2072,"id":188743,"goal":"lemma SeqAppendNil_2072(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_2073","instance":2073,"id":188744,"goal":"lemma SeqNilAppend_2073(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_2074","instance":2074,"id":188745,"goal":"lemma SeqAppendAssoc_2074(u: seq, s: seq, xs: seq)\n ensures (u + s) + xs == u + (s + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_2075","instance":2075,"id":188746,"goal":"lemma SeqTakeDrop_2075(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_2076","instance":2076,"id":188747,"goal":"lemma SeqReverseLen_2076(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_2077","instance":2077,"id":188748,"goal":"lemma SeqReverseIdem_2077(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_2078","instance":2078,"id":188749,"goal":"lemma SeqMapLen_2078(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_2079","instance":2079,"id":188750,"goal":"lemma SeqFilterLe_2079(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_2080","instance":2080,"id":188751,"goal":"lemma SeqMemberAppend_2080(u: seq, t: seq)\n ensures x in u + t <==> x in u || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_2081","instance":2081,"id":188752,"goal":"lemma SeqAppendLen_2081(u: seq, s: seq)\n ensures |u + s| == |u| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_2082","instance":2082,"id":188753,"goal":"lemma SeqAppendNil_2082(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_2083","instance":2083,"id":188754,"goal":"lemma SeqNilAppend_2083(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_2084","instance":2084,"id":188755,"goal":"lemma SeqAppendAssoc_2084(t: seq, ys: seq, xs: seq)\n ensures (t + ys) + xs == t + (ys + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_2085","instance":2085,"id":188756,"goal":"lemma SeqTakeDrop_2085(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_2086","instance":2086,"id":188757,"goal":"lemma SeqReverseLen_2086(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_2087","instance":2087,"id":188758,"goal":"lemma SeqReverseIdem_2087(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_2088","instance":2088,"id":188759,"goal":"lemma SeqMapLen_2088(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_2089","instance":2089,"id":188760,"goal":"lemma SeqFilterLe_2089(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_2090","instance":2090,"id":188761,"goal":"lemma SeqMemberAppend_2090(s: seq, u: seq)\n ensures x in s + u <==> x in s || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_2091","instance":2091,"id":188762,"goal":"lemma SeqAppendLen_2091(u: seq, xs: seq)\n ensures |u + xs| == |u| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_2092","instance":2092,"id":188763,"goal":"lemma SeqAppendNil_2092(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_2093","instance":2093,"id":188764,"goal":"lemma SeqNilAppend_2093(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_2094","instance":2094,"id":188765,"goal":"lemma SeqAppendAssoc_2094(zs: seq, ys: seq, xs: seq)\n ensures (zs + ys) + xs == zs + (ys + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_2095","instance":2095,"id":188766,"goal":"lemma SeqTakeDrop_2095(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_2096","instance":2096,"id":188767,"goal":"lemma SeqReverseLen_2096(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_2097","instance":2097,"id":188768,"goal":"lemma SeqReverseIdem_2097(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_2098","instance":2098,"id":188769,"goal":"lemma SeqMapLen_2098(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_2099","instance":2099,"id":188770,"goal":"lemma SeqFilterLe_2099(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_2100","instance":2100,"id":188771,"goal":"lemma SeqMemberAppend_2100(t: seq, ys: seq)\n ensures x in t + ys <==> x in t || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_2101","instance":2101,"id":188772,"goal":"lemma SeqAppendLen_2101(zs: seq, u: seq)\n ensures |zs + u| == |zs| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_2102","instance":2102,"id":188773,"goal":"lemma SeqAppendNil_2102(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_2103","instance":2103,"id":188774,"goal":"lemma SeqNilAppend_2103(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_2104","instance":2104,"id":188775,"goal":"lemma SeqAppendAssoc_2104(u: seq, ys: seq, zs: seq)\n ensures (u + ys) + zs == u + (ys + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_2105","instance":2105,"id":188776,"goal":"lemma SeqTakeDrop_2105(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_2106","instance":2106,"id":188777,"goal":"lemma SeqReverseLen_2106(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_2107","instance":2107,"id":188778,"goal":"lemma SeqReverseIdem_2107(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_2108","instance":2108,"id":188779,"goal":"lemma SeqMapLen_2108(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_2109","instance":2109,"id":188780,"goal":"lemma SeqFilterLe_2109(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_2110","instance":2110,"id":188781,"goal":"lemma SeqMemberAppend_2110(s: seq, ys: seq)\n ensures x in s + ys <==> x in s || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_2111","instance":2111,"id":188782,"goal":"lemma SeqAppendLen_2111(u: seq, t: seq)\n ensures |u + t| == |u| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_2112","instance":2112,"id":188783,"goal":"lemma SeqAppendNil_2112(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_2113","instance":2113,"id":188784,"goal":"lemma SeqNilAppend_2113(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_2114","instance":2114,"id":188785,"goal":"lemma SeqAppendAssoc_2114(t: seq, ys: seq, u: seq)\n ensures (t + ys) + u == t + (ys + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_2115","instance":2115,"id":188786,"goal":"lemma SeqTakeDrop_2115(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_2116","instance":2116,"id":188787,"goal":"lemma SeqReverseLen_2116(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_2117","instance":2117,"id":188788,"goal":"lemma SeqReverseIdem_2117(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_2118","instance":2118,"id":188789,"goal":"lemma SeqMapLen_2118(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_2119","instance":2119,"id":188790,"goal":"lemma SeqFilterLe_2119(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_2120","instance":2120,"id":188791,"goal":"lemma SeqMemberAppend_2120(t: seq, u: seq)\n ensures x in t + u <==> x in t || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_2121","instance":2121,"id":188792,"goal":"lemma SeqAppendLen_2121(u: seq, zs: seq)\n ensures |u + zs| == |u| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_2122","instance":2122,"id":188793,"goal":"lemma SeqAppendNil_2122(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_2123","instance":2123,"id":188794,"goal":"lemma SeqNilAppend_2123(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_2124","instance":2124,"id":188795,"goal":"lemma SeqAppendAssoc_2124(xs: seq, ys: seq, zs: seq)\n ensures (xs + ys) + zs == xs + (ys + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_2125","instance":2125,"id":188796,"goal":"lemma SeqTakeDrop_2125(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_2126","instance":2126,"id":188797,"goal":"lemma SeqReverseLen_2126(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_2127","instance":2127,"id":188798,"goal":"lemma SeqReverseIdem_2127(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_2128","instance":2128,"id":188799,"goal":"lemma SeqMapLen_2128(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_2129","instance":2129,"id":188800,"goal":"lemma SeqFilterLe_2129(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_2130","instance":2130,"id":188801,"goal":"lemma SeqMemberAppend_2130(u: seq, ys: seq)\n ensures x in u + ys <==> x in u || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_2131","instance":2131,"id":188802,"goal":"lemma SeqAppendLen_2131(u: seq, t: seq)\n ensures |u + t| == |u| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_2132","instance":2132,"id":188803,"goal":"lemma SeqAppendNil_2132(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_2133","instance":2133,"id":188804,"goal":"lemma SeqNilAppend_2133(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_2134","instance":2134,"id":188805,"goal":"lemma SeqAppendAssoc_2134(xs: seq, ys: seq, u: seq)\n ensures (xs + ys) + u == xs + (ys + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_2135","instance":2135,"id":188806,"goal":"lemma SeqTakeDrop_2135(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_2136","instance":2136,"id":188807,"goal":"lemma SeqReverseLen_2136(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_2137","instance":2137,"id":188808,"goal":"lemma SeqReverseIdem_2137(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_2138","instance":2138,"id":188809,"goal":"lemma SeqMapLen_2138(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_2139","instance":2139,"id":188810,"goal":"lemma SeqFilterLe_2139(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_2140","instance":2140,"id":188811,"goal":"lemma SeqMemberAppend_2140(u: seq, xs: seq)\n ensures x in u + xs <==> x in u || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_2141","instance":2141,"id":188812,"goal":"lemma SeqAppendLen_2141(t: seq, u: seq)\n ensures |t + u| == |t| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_2142","instance":2142,"id":188813,"goal":"lemma SeqAppendNil_2142(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_2143","instance":2143,"id":188814,"goal":"lemma SeqNilAppend_2143(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_2144","instance":2144,"id":188815,"goal":"lemma SeqAppendAssoc_2144(t: seq, zs: seq, xs: seq)\n ensures (t + zs) + xs == t + (zs + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_2145","instance":2145,"id":188816,"goal":"lemma SeqTakeDrop_2145(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_2146","instance":2146,"id":188817,"goal":"lemma SeqReverseLen_2146(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_2147","instance":2147,"id":188818,"goal":"lemma SeqReverseIdem_2147(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_2148","instance":2148,"id":188819,"goal":"lemma SeqMapLen_2148(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_2149","instance":2149,"id":188820,"goal":"lemma SeqFilterLe_2149(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_2150","instance":2150,"id":188821,"goal":"lemma SeqMemberAppend_2150(t: seq, u: seq)\n ensures x in t + u <==> x in t || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_2151","instance":2151,"id":188822,"goal":"lemma SeqAppendLen_2151(u: seq, s: seq)\n ensures |u + s| == |u| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_2152","instance":2152,"id":188823,"goal":"lemma SeqAppendNil_2152(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_2153","instance":2153,"id":188824,"goal":"lemma SeqNilAppend_2153(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_2154","instance":2154,"id":188825,"goal":"lemma SeqAppendAssoc_2154(u: seq, t: seq, ys: seq)\n ensures (u + t) + ys == u + (t + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_2155","instance":2155,"id":188826,"goal":"lemma SeqTakeDrop_2155(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_2156","instance":2156,"id":188827,"goal":"lemma SeqReverseLen_2156(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_2157","instance":2157,"id":188828,"goal":"lemma SeqReverseIdem_2157(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_2158","instance":2158,"id":188829,"goal":"lemma SeqMapLen_2158(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_2159","instance":2159,"id":188830,"goal":"lemma SeqFilterLe_2159(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_2160","instance":2160,"id":188831,"goal":"lemma SeqMemberAppend_2160(ys: seq, zs: seq)\n ensures x in ys + zs <==> x in ys || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_2161","instance":2161,"id":188832,"goal":"lemma SeqAppendLen_2161(s: seq, t: seq)\n ensures |s + t| == |s| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_2162","instance":2162,"id":188833,"goal":"lemma SeqAppendNil_2162(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_2163","instance":2163,"id":188834,"goal":"lemma SeqNilAppend_2163(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_2164","instance":2164,"id":188835,"goal":"lemma SeqAppendAssoc_2164(xs: seq, s: seq, u: seq)\n ensures (xs + s) + u == xs + (s + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_2165","instance":2165,"id":188836,"goal":"lemma SeqTakeDrop_2165(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_2166","instance":2166,"id":188837,"goal":"lemma SeqReverseLen_2166(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_2167","instance":2167,"id":188838,"goal":"lemma SeqReverseIdem_2167(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_2168","instance":2168,"id":188839,"goal":"lemma SeqMapLen_2168(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_2169","instance":2169,"id":188840,"goal":"lemma SeqFilterLe_2169(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_2170","instance":2170,"id":188841,"goal":"lemma SeqMemberAppend_2170(zs: seq, u: seq)\n ensures x in zs + u <==> x in zs || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_2171","instance":2171,"id":188842,"goal":"lemma SeqAppendLen_2171(zs: seq, xs: seq)\n ensures |zs + xs| == |zs| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_2172","instance":2172,"id":188843,"goal":"lemma SeqAppendNil_2172(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_2173","instance":2173,"id":188844,"goal":"lemma SeqNilAppend_2173(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_2174","instance":2174,"id":188845,"goal":"lemma SeqAppendAssoc_2174(s: seq, t: seq, xs: seq)\n ensures (s + t) + xs == s + (t + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_2175","instance":2175,"id":188846,"goal":"lemma SeqTakeDrop_2175(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_2176","instance":2176,"id":188847,"goal":"lemma SeqReverseLen_2176(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_2177","instance":2177,"id":188848,"goal":"lemma SeqReverseIdem_2177(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_2178","instance":2178,"id":188849,"goal":"lemma SeqMapLen_2178(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_2179","instance":2179,"id":188850,"goal":"lemma SeqFilterLe_2179(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_2180","instance":2180,"id":188851,"goal":"lemma SeqMemberAppend_2180(xs: seq, t: seq)\n ensures x in xs + t <==> x in xs || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_2181","instance":2181,"id":188852,"goal":"lemma SeqAppendLen_2181(s: seq, xs: seq)\n ensures |s + xs| == |s| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_2182","instance":2182,"id":188853,"goal":"lemma SeqAppendNil_2182(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_2183","instance":2183,"id":188854,"goal":"lemma SeqNilAppend_2183(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_2184","instance":2184,"id":188855,"goal":"lemma SeqAppendAssoc_2184(u: seq, zs: seq, ys: seq)\n ensures (u + zs) + ys == u + (zs + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_2185","instance":2185,"id":188856,"goal":"lemma SeqTakeDrop_2185(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_2186","instance":2186,"id":188857,"goal":"lemma SeqReverseLen_2186(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_2187","instance":2187,"id":188858,"goal":"lemma SeqReverseIdem_2187(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_2188","instance":2188,"id":188859,"goal":"lemma SeqMapLen_2188(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_2189","instance":2189,"id":188860,"goal":"lemma SeqFilterLe_2189(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_2190","instance":2190,"id":188861,"goal":"lemma SeqMemberAppend_2190(u: seq, t: seq)\n ensures x in u + t <==> x in u || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_2191","instance":2191,"id":188862,"goal":"lemma SeqAppendLen_2191(t: seq, zs: seq)\n ensures |t + zs| == |t| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_2192","instance":2192,"id":188863,"goal":"lemma SeqAppendNil_2192(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_2193","instance":2193,"id":188864,"goal":"lemma SeqNilAppend_2193(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_2194","instance":2194,"id":188865,"goal":"lemma SeqAppendAssoc_2194(ys: seq, s: seq, xs: seq)\n ensures (ys + s) + xs == ys + (s + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_2195","instance":2195,"id":188866,"goal":"lemma SeqTakeDrop_2195(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_2196","instance":2196,"id":188867,"goal":"lemma SeqReverseLen_2196(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_2197","instance":2197,"id":188868,"goal":"lemma SeqReverseIdem_2197(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_2198","instance":2198,"id":188869,"goal":"lemma SeqMapLen_2198(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_2199","instance":2199,"id":188870,"goal":"lemma SeqFilterLe_2199(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_2200","instance":2200,"id":188871,"goal":"lemma SeqMemberAppend_2200(zs: seq, s: seq)\n ensures x in zs + s <==> x in zs || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_2201","instance":2201,"id":188872,"goal":"lemma SeqAppendLen_2201(ys: seq, s: seq)\n ensures |ys + s| == |ys| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_2202","instance":2202,"id":188873,"goal":"lemma SeqAppendNil_2202(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_2203","instance":2203,"id":188874,"goal":"lemma SeqNilAppend_2203(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_2204","instance":2204,"id":188875,"goal":"lemma SeqAppendAssoc_2204(ys: seq, t: seq, zs: seq)\n ensures (ys + t) + zs == ys + (t + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_2205","instance":2205,"id":188876,"goal":"lemma SeqTakeDrop_2205(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_2206","instance":2206,"id":188877,"goal":"lemma SeqReverseLen_2206(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_2207","instance":2207,"id":188878,"goal":"lemma SeqReverseIdem_2207(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_2208","instance":2208,"id":188879,"goal":"lemma SeqMapLen_2208(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_2209","instance":2209,"id":188880,"goal":"lemma SeqFilterLe_2209(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_2210","instance":2210,"id":188881,"goal":"lemma SeqMemberAppend_2210(zs: seq, xs: seq)\n ensures x in zs + xs <==> x in zs || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_2211","instance":2211,"id":188882,"goal":"lemma SeqAppendLen_2211(u: seq, xs: seq)\n ensures |u + xs| == |u| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_2212","instance":2212,"id":188883,"goal":"lemma SeqAppendNil_2212(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_2213","instance":2213,"id":188884,"goal":"lemma SeqNilAppend_2213(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_2214","instance":2214,"id":188885,"goal":"lemma SeqAppendAssoc_2214(zs: seq, xs: seq, ys: seq)\n ensures (zs + xs) + ys == zs + (xs + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_2215","instance":2215,"id":188886,"goal":"lemma SeqTakeDrop_2215(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_2216","instance":2216,"id":188887,"goal":"lemma SeqReverseLen_2216(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_2217","instance":2217,"id":188888,"goal":"lemma SeqReverseIdem_2217(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_2218","instance":2218,"id":188889,"goal":"lemma SeqMapLen_2218(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_2219","instance":2219,"id":188890,"goal":"lemma SeqFilterLe_2219(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_2220","instance":2220,"id":188891,"goal":"lemma SeqMemberAppend_2220(u: seq, zs: seq)\n ensures x in u + zs <==> x in u || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_2221","instance":2221,"id":188892,"goal":"lemma SeqAppendLen_2221(t: seq, ys: seq)\n ensures |t + ys| == |t| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_2222","instance":2222,"id":188893,"goal":"lemma SeqAppendNil_2222(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_2223","instance":2223,"id":188894,"goal":"lemma SeqNilAppend_2223(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_2224","instance":2224,"id":188895,"goal":"lemma SeqAppendAssoc_2224(xs: seq, t: seq, zs: seq)\n ensures (xs + t) + zs == xs + (t + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_2225","instance":2225,"id":188896,"goal":"lemma SeqTakeDrop_2225(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_2226","instance":2226,"id":188897,"goal":"lemma SeqReverseLen_2226(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_2227","instance":2227,"id":188898,"goal":"lemma SeqReverseIdem_2227(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_2228","instance":2228,"id":188899,"goal":"lemma SeqMapLen_2228(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_2229","instance":2229,"id":188900,"goal":"lemma SeqFilterLe_2229(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_2230","instance":2230,"id":188901,"goal":"lemma SeqMemberAppend_2230(s: seq, t: seq)\n ensures x in s + t <==> x in s || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_2231","instance":2231,"id":188902,"goal":"lemma SeqAppendLen_2231(u: seq, ys: seq)\n ensures |u + ys| == |u| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_2232","instance":2232,"id":188903,"goal":"lemma SeqAppendNil_2232(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_2233","instance":2233,"id":188904,"goal":"lemma SeqNilAppend_2233(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_2234","instance":2234,"id":188905,"goal":"lemma SeqAppendAssoc_2234(zs: seq, u: seq, t: seq)\n ensures (zs + u) + t == zs + (u + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_2235","instance":2235,"id":188906,"goal":"lemma SeqTakeDrop_2235(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_2236","instance":2236,"id":188907,"goal":"lemma SeqReverseLen_2236(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_2237","instance":2237,"id":188908,"goal":"lemma SeqReverseIdem_2237(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_2238","instance":2238,"id":188909,"goal":"lemma SeqMapLen_2238(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_2239","instance":2239,"id":188910,"goal":"lemma SeqFilterLe_2239(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_2240","instance":2240,"id":188911,"goal":"lemma SeqMemberAppend_2240(u: seq, ys: seq)\n ensures x in u + ys <==> x in u || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_2241","instance":2241,"id":188912,"goal":"lemma SeqAppendLen_2241(xs: seq, ys: seq)\n ensures |xs + ys| == |xs| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_2242","instance":2242,"id":188913,"goal":"lemma SeqAppendNil_2242(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_2243","instance":2243,"id":188914,"goal":"lemma SeqNilAppend_2243(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_2244","instance":2244,"id":188915,"goal":"lemma SeqAppendAssoc_2244(ys: seq, zs: seq, u: seq)\n ensures (ys + zs) + u == ys + (zs + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_2245","instance":2245,"id":188916,"goal":"lemma SeqTakeDrop_2245(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_2246","instance":2246,"id":188917,"goal":"lemma SeqReverseLen_2246(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_2247","instance":2247,"id":188918,"goal":"lemma SeqReverseIdem_2247(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_2248","instance":2248,"id":188919,"goal":"lemma SeqMapLen_2248(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_2249","instance":2249,"id":188920,"goal":"lemma SeqFilterLe_2249(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_2250","instance":2250,"id":188921,"goal":"lemma SeqMemberAppend_2250(s: seq, t: seq)\n ensures x in s + t <==> x in s || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_2251","instance":2251,"id":188922,"goal":"lemma SeqAppendLen_2251(t: seq, s: seq)\n ensures |t + s| == |t| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_2252","instance":2252,"id":188923,"goal":"lemma SeqAppendNil_2252(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_2253","instance":2253,"id":188924,"goal":"lemma SeqNilAppend_2253(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_2254","instance":2254,"id":188925,"goal":"lemma SeqAppendAssoc_2254(s: seq, ys: seq, zs: seq)\n ensures (s + ys) + zs == s + (ys + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_2255","instance":2255,"id":188926,"goal":"lemma SeqTakeDrop_2255(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_2256","instance":2256,"id":188927,"goal":"lemma SeqReverseLen_2256(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_2257","instance":2257,"id":188928,"goal":"lemma SeqReverseIdem_2257(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_2258","instance":2258,"id":188929,"goal":"lemma SeqMapLen_2258(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_2259","instance":2259,"id":188930,"goal":"lemma SeqFilterLe_2259(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_2260","instance":2260,"id":188931,"goal":"lemma SeqMemberAppend_2260(t: seq, xs: seq)\n ensures x in t + xs <==> x in t || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_2261","instance":2261,"id":188932,"goal":"lemma SeqAppendLen_2261(u: seq, t: seq)\n ensures |u + t| == |u| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_2262","instance":2262,"id":188933,"goal":"lemma SeqAppendNil_2262(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_2263","instance":2263,"id":188934,"goal":"lemma SeqNilAppend_2263(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_2264","instance":2264,"id":188935,"goal":"lemma SeqAppendAssoc_2264(t: seq, u: seq, ys: seq)\n ensures (t + u) + ys == t + (u + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_2265","instance":2265,"id":188936,"goal":"lemma SeqTakeDrop_2265(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_2266","instance":2266,"id":188937,"goal":"lemma SeqReverseLen_2266(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_2267","instance":2267,"id":188938,"goal":"lemma SeqReverseIdem_2267(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_2268","instance":2268,"id":188939,"goal":"lemma SeqMapLen_2268(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_2269","instance":2269,"id":188940,"goal":"lemma SeqFilterLe_2269(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_2270","instance":2270,"id":188941,"goal":"lemma SeqMemberAppend_2270(xs: seq, t: seq)\n ensures x in xs + t <==> x in xs || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_2271","instance":2271,"id":188942,"goal":"lemma SeqAppendLen_2271(u: seq, s: seq)\n ensures |u + s| == |u| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_2272","instance":2272,"id":188943,"goal":"lemma SeqAppendNil_2272(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_2273","instance":2273,"id":188944,"goal":"lemma SeqNilAppend_2273(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_2274","instance":2274,"id":188945,"goal":"lemma SeqAppendAssoc_2274(ys: seq, zs: seq, xs: seq)\n ensures (ys + zs) + xs == ys + (zs + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_2275","instance":2275,"id":188946,"goal":"lemma SeqTakeDrop_2275(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_2276","instance":2276,"id":188947,"goal":"lemma SeqReverseLen_2276(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_2277","instance":2277,"id":188948,"goal":"lemma SeqReverseIdem_2277(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_2278","instance":2278,"id":188949,"goal":"lemma SeqMapLen_2278(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_2279","instance":2279,"id":188950,"goal":"lemma SeqFilterLe_2279(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_2280","instance":2280,"id":188951,"goal":"lemma SeqMemberAppend_2280(xs: seq, ys: seq)\n ensures x in xs + ys <==> x in xs || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_2281","instance":2281,"id":188952,"goal":"lemma SeqAppendLen_2281(t: seq, xs: seq)\n ensures |t + xs| == |t| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_2282","instance":2282,"id":188953,"goal":"lemma SeqAppendNil_2282(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_2283","instance":2283,"id":188954,"goal":"lemma SeqNilAppend_2283(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_2284","instance":2284,"id":188955,"goal":"lemma SeqAppendAssoc_2284(ys: seq, u: seq, zs: seq)\n ensures (ys + u) + zs == ys + (u + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_2285","instance":2285,"id":188956,"goal":"lemma SeqTakeDrop_2285(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_2286","instance":2286,"id":188957,"goal":"lemma SeqReverseLen_2286(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_2287","instance":2287,"id":188958,"goal":"lemma SeqReverseIdem_2287(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_2288","instance":2288,"id":188959,"goal":"lemma SeqMapLen_2288(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_2289","instance":2289,"id":188960,"goal":"lemma SeqFilterLe_2289(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_2290","instance":2290,"id":188961,"goal":"lemma SeqMemberAppend_2290(s: seq, ys: seq)\n ensures x in s + ys <==> x in s || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_2291","instance":2291,"id":188962,"goal":"lemma SeqAppendLen_2291(xs: seq, ys: seq)\n ensures |xs + ys| == |xs| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_2292","instance":2292,"id":188963,"goal":"lemma SeqAppendNil_2292(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_2293","instance":2293,"id":188964,"goal":"lemma SeqNilAppend_2293(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_2294","instance":2294,"id":188965,"goal":"lemma SeqAppendAssoc_2294(u: seq, ys: seq, s: seq)\n ensures (u + ys) + s == u + (ys + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_2295","instance":2295,"id":188966,"goal":"lemma SeqTakeDrop_2295(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_2296","instance":2296,"id":188967,"goal":"lemma SeqReverseLen_2296(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_2297","instance":2297,"id":188968,"goal":"lemma SeqReverseIdem_2297(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_2298","instance":2298,"id":188969,"goal":"lemma SeqMapLen_2298(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_2299","instance":2299,"id":188970,"goal":"lemma SeqFilterLe_2299(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_2300","instance":2300,"id":188971,"goal":"lemma SeqMemberAppend_2300(zs: seq, xs: seq)\n ensures x in zs + xs <==> x in zs || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_2301","instance":2301,"id":188972,"goal":"lemma SeqAppendLen_2301(t: seq, u: seq)\n ensures |t + u| == |t| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_2302","instance":2302,"id":188973,"goal":"lemma SeqAppendNil_2302(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_2303","instance":2303,"id":188974,"goal":"lemma SeqNilAppend_2303(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_2304","instance":2304,"id":188975,"goal":"lemma SeqAppendAssoc_2304(s: seq, u: seq, ys: seq)\n ensures (s + u) + ys == s + (u + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_2305","instance":2305,"id":188976,"goal":"lemma SeqTakeDrop_2305(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_2306","instance":2306,"id":188977,"goal":"lemma SeqReverseLen_2306(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_2307","instance":2307,"id":188978,"goal":"lemma SeqReverseIdem_2307(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_2308","instance":2308,"id":188979,"goal":"lemma SeqMapLen_2308(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_2309","instance":2309,"id":188980,"goal":"lemma SeqFilterLe_2309(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_2310","instance":2310,"id":188981,"goal":"lemma SeqMemberAppend_2310(ys: seq, t: seq)\n ensures x in ys + t <==> x in ys || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_2311","instance":2311,"id":188982,"goal":"lemma SeqAppendLen_2311(ys: seq, zs: seq)\n ensures |ys + zs| == |ys| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_2312","instance":2312,"id":188983,"goal":"lemma SeqAppendNil_2312(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_2313","instance":2313,"id":188984,"goal":"lemma SeqNilAppend_2313(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_2314","instance":2314,"id":188985,"goal":"lemma SeqAppendAssoc_2314(s: seq, u: seq, ys: seq)\n ensures (s + u) + ys == s + (u + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_2315","instance":2315,"id":188986,"goal":"lemma SeqTakeDrop_2315(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_2316","instance":2316,"id":188987,"goal":"lemma SeqReverseLen_2316(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_2317","instance":2317,"id":188988,"goal":"lemma SeqReverseIdem_2317(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_2318","instance":2318,"id":188989,"goal":"lemma SeqMapLen_2318(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_2319","instance":2319,"id":188990,"goal":"lemma SeqFilterLe_2319(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_2320","instance":2320,"id":188991,"goal":"lemma SeqMemberAppend_2320(s: seq, ys: seq)\n ensures x in s + ys <==> x in s || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_2321","instance":2321,"id":188992,"goal":"lemma SeqAppendLen_2321(t: seq, xs: seq)\n ensures |t + xs| == |t| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_2322","instance":2322,"id":188993,"goal":"lemma SeqAppendNil_2322(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_2323","instance":2323,"id":188994,"goal":"lemma SeqNilAppend_2323(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_2324","instance":2324,"id":188995,"goal":"lemma SeqAppendAssoc_2324(t: seq, xs: seq, s: seq)\n ensures (t + xs) + s == t + (xs + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_2325","instance":2325,"id":188996,"goal":"lemma SeqTakeDrop_2325(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_2326","instance":2326,"id":188997,"goal":"lemma SeqReverseLen_2326(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_2327","instance":2327,"id":188998,"goal":"lemma SeqReverseIdem_2327(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_2328","instance":2328,"id":188999,"goal":"lemma SeqMapLen_2328(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_2329","instance":2329,"id":189000,"goal":"lemma SeqFilterLe_2329(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_2330","instance":2330,"id":189001,"goal":"lemma SeqMemberAppend_2330(u: seq, ys: seq)\n ensures x in u + ys <==> x in u || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_2331","instance":2331,"id":189002,"goal":"lemma SeqAppendLen_2331(t: seq, ys: seq)\n ensures |t + ys| == |t| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_2332","instance":2332,"id":189003,"goal":"lemma SeqAppendNil_2332(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_2333","instance":2333,"id":189004,"goal":"lemma SeqNilAppend_2333(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_2334","instance":2334,"id":189005,"goal":"lemma SeqAppendAssoc_2334(t: seq, s: seq, u: seq)\n ensures (t + s) + u == t + (s + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_2335","instance":2335,"id":189006,"goal":"lemma SeqTakeDrop_2335(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_2336","instance":2336,"id":189007,"goal":"lemma SeqReverseLen_2336(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_2337","instance":2337,"id":189008,"goal":"lemma SeqReverseIdem_2337(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_2338","instance":2338,"id":189009,"goal":"lemma SeqMapLen_2338(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_2339","instance":2339,"id":189010,"goal":"lemma SeqFilterLe_2339(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_2340","instance":2340,"id":189011,"goal":"lemma SeqMemberAppend_2340(s: seq, zs: seq)\n ensures x in s + zs <==> x in s || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_2341","instance":2341,"id":189012,"goal":"lemma SeqAppendLen_2341(ys: seq, s: seq)\n ensures |ys + s| == |ys| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_2342","instance":2342,"id":189013,"goal":"lemma SeqAppendNil_2342(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_2343","instance":2343,"id":189014,"goal":"lemma SeqNilAppend_2343(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_2344","instance":2344,"id":189015,"goal":"lemma SeqAppendAssoc_2344(ys: seq, zs: seq, xs: seq)\n ensures (ys + zs) + xs == ys + (zs + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_2345","instance":2345,"id":189016,"goal":"lemma SeqTakeDrop_2345(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_2346","instance":2346,"id":189017,"goal":"lemma SeqReverseLen_2346(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_2347","instance":2347,"id":189018,"goal":"lemma SeqReverseIdem_2347(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_2348","instance":2348,"id":189019,"goal":"lemma SeqMapLen_2348(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_2349","instance":2349,"id":189020,"goal":"lemma SeqFilterLe_2349(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_2350","instance":2350,"id":189021,"goal":"lemma SeqMemberAppend_2350(ys: seq, s: seq)\n ensures x in ys + s <==> x in ys || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_2351","instance":2351,"id":189022,"goal":"lemma SeqAppendLen_2351(t: seq, u: seq)\n ensures |t + u| == |t| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_2352","instance":2352,"id":189023,"goal":"lemma SeqAppendNil_2352(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_2353","instance":2353,"id":189024,"goal":"lemma SeqNilAppend_2353(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_2354","instance":2354,"id":189025,"goal":"lemma SeqAppendAssoc_2354(u: seq, xs: seq, s: seq)\n ensures (u + xs) + s == u + (xs + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_2355","instance":2355,"id":189026,"goal":"lemma SeqTakeDrop_2355(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_2356","instance":2356,"id":189027,"goal":"lemma SeqReverseLen_2356(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_2357","instance":2357,"id":189028,"goal":"lemma SeqReverseIdem_2357(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_2358","instance":2358,"id":189029,"goal":"lemma SeqMapLen_2358(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_2359","instance":2359,"id":189030,"goal":"lemma SeqFilterLe_2359(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_2360","instance":2360,"id":189031,"goal":"lemma SeqMemberAppend_2360(xs: seq, u: seq)\n ensures x in xs + u <==> x in xs || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_2361","instance":2361,"id":189032,"goal":"lemma SeqAppendLen_2361(u: seq, zs: seq)\n ensures |u + zs| == |u| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_2362","instance":2362,"id":189033,"goal":"lemma SeqAppendNil_2362(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_2363","instance":2363,"id":189034,"goal":"lemma SeqNilAppend_2363(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_2364","instance":2364,"id":189035,"goal":"lemma SeqAppendAssoc_2364(zs: seq, s: seq, xs: seq)\n ensures (zs + s) + xs == zs + (s + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_2365","instance":2365,"id":189036,"goal":"lemma SeqTakeDrop_2365(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_2366","instance":2366,"id":189037,"goal":"lemma SeqReverseLen_2366(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_2367","instance":2367,"id":189038,"goal":"lemma SeqReverseIdem_2367(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_2368","instance":2368,"id":189039,"goal":"lemma SeqMapLen_2368(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_2369","instance":2369,"id":189040,"goal":"lemma SeqFilterLe_2369(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_2370","instance":2370,"id":189041,"goal":"lemma SeqMemberAppend_2370(s: seq, xs: seq)\n ensures x in s + xs <==> x in s || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_2371","instance":2371,"id":189042,"goal":"lemma SeqAppendLen_2371(u: seq, t: seq)\n ensures |u + t| == |u| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_2372","instance":2372,"id":189043,"goal":"lemma SeqAppendNil_2372(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_2373","instance":2373,"id":189044,"goal":"lemma SeqNilAppend_2373(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_2374","instance":2374,"id":189045,"goal":"lemma SeqAppendAssoc_2374(u: seq, s: seq, t: seq)\n ensures (u + s) + t == u + (s + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_2375","instance":2375,"id":189046,"goal":"lemma SeqTakeDrop_2375(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_2376","instance":2376,"id":189047,"goal":"lemma SeqReverseLen_2376(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_2377","instance":2377,"id":189048,"goal":"lemma SeqReverseIdem_2377(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_2378","instance":2378,"id":189049,"goal":"lemma SeqMapLen_2378(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_2379","instance":2379,"id":189050,"goal":"lemma SeqFilterLe_2379(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_2380","instance":2380,"id":189051,"goal":"lemma SeqMemberAppend_2380(zs: seq, ys: seq)\n ensures x in zs + ys <==> x in zs || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_2381","instance":2381,"id":189052,"goal":"lemma SeqAppendLen_2381(ys: seq, zs: seq)\n ensures |ys + zs| == |ys| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_2382","instance":2382,"id":189053,"goal":"lemma SeqAppendNil_2382(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_2383","instance":2383,"id":189054,"goal":"lemma SeqNilAppend_2383(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_2384","instance":2384,"id":189055,"goal":"lemma SeqAppendAssoc_2384(s: seq, zs: seq, t: seq)\n ensures (s + zs) + t == s + (zs + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_2385","instance":2385,"id":189056,"goal":"lemma SeqTakeDrop_2385(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_2386","instance":2386,"id":189057,"goal":"lemma SeqReverseLen_2386(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_2387","instance":2387,"id":189058,"goal":"lemma SeqReverseIdem_2387(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_2388","instance":2388,"id":189059,"goal":"lemma SeqMapLen_2388(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_2389","instance":2389,"id":189060,"goal":"lemma SeqFilterLe_2389(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_2390","instance":2390,"id":189061,"goal":"lemma SeqMemberAppend_2390(zs: seq, xs: seq)\n ensures x in zs + xs <==> x in zs || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_2391","instance":2391,"id":189062,"goal":"lemma SeqAppendLen_2391(t: seq, s: seq)\n ensures |t + s| == |t| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_2392","instance":2392,"id":189063,"goal":"lemma SeqAppendNil_2392(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_2393","instance":2393,"id":189064,"goal":"lemma SeqNilAppend_2393(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_2394","instance":2394,"id":189065,"goal":"lemma SeqAppendAssoc_2394(xs: seq, zs: seq, u: seq)\n ensures (xs + zs) + u == xs + (zs + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_2395","instance":2395,"id":189066,"goal":"lemma SeqTakeDrop_2395(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_2396","instance":2396,"id":189067,"goal":"lemma SeqReverseLen_2396(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_2397","instance":2397,"id":189068,"goal":"lemma SeqReverseIdem_2397(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_2398","instance":2398,"id":189069,"goal":"lemma SeqMapLen_2398(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_2399","instance":2399,"id":189070,"goal":"lemma SeqFilterLe_2399(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_2400","instance":2400,"id":189071,"goal":"lemma SeqMemberAppend_2400(t: seq, s: seq)\n ensures x in t + s <==> x in t || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_2401","instance":2401,"id":189072,"goal":"lemma SeqAppendLen_2401(s: seq, ys: seq)\n ensures |s + ys| == |s| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_2402","instance":2402,"id":189073,"goal":"lemma SeqAppendNil_2402(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_2403","instance":2403,"id":189074,"goal":"lemma SeqNilAppend_2403(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_2404","instance":2404,"id":189075,"goal":"lemma SeqAppendAssoc_2404(ys: seq, zs: seq, t: seq)\n ensures (ys + zs) + t == ys + (zs + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_2405","instance":2405,"id":189076,"goal":"lemma SeqTakeDrop_2405(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_2406","instance":2406,"id":189077,"goal":"lemma SeqReverseLen_2406(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_2407","instance":2407,"id":189078,"goal":"lemma SeqReverseIdem_2407(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_2408","instance":2408,"id":189079,"goal":"lemma SeqMapLen_2408(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_2409","instance":2409,"id":189080,"goal":"lemma SeqFilterLe_2409(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_2410","instance":2410,"id":189081,"goal":"lemma SeqMemberAppend_2410(u: seq, xs: seq)\n ensures x in u + xs <==> x in u || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_2411","instance":2411,"id":189082,"goal":"lemma SeqAppendLen_2411(t: seq, zs: seq)\n ensures |t + zs| == |t| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_2412","instance":2412,"id":189083,"goal":"lemma SeqAppendNil_2412(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_2413","instance":2413,"id":189084,"goal":"lemma SeqNilAppend_2413(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_2414","instance":2414,"id":189085,"goal":"lemma SeqAppendAssoc_2414(xs: seq, t: seq, zs: seq)\n ensures (xs + t) + zs == xs + (t + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_2415","instance":2415,"id":189086,"goal":"lemma SeqTakeDrop_2415(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_2416","instance":2416,"id":189087,"goal":"lemma SeqReverseLen_2416(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_2417","instance":2417,"id":189088,"goal":"lemma SeqReverseIdem_2417(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_2418","instance":2418,"id":189089,"goal":"lemma SeqMapLen_2418(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_2419","instance":2419,"id":189090,"goal":"lemma SeqFilterLe_2419(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_2420","instance":2420,"id":189091,"goal":"lemma SeqMemberAppend_2420(t: seq, u: seq)\n ensures x in t + u <==> x in t || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_2421","instance":2421,"id":189092,"goal":"lemma SeqAppendLen_2421(ys: seq, t: seq)\n ensures |ys + t| == |ys| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_2422","instance":2422,"id":189093,"goal":"lemma SeqAppendNil_2422(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_2423","instance":2423,"id":189094,"goal":"lemma SeqNilAppend_2423(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_2424","instance":2424,"id":189095,"goal":"lemma SeqAppendAssoc_2424(ys: seq, xs: seq, s: seq)\n ensures (ys + xs) + s == ys + (xs + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_2425","instance":2425,"id":189096,"goal":"lemma SeqTakeDrop_2425(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_2426","instance":2426,"id":189097,"goal":"lemma SeqReverseLen_2426(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_2427","instance":2427,"id":189098,"goal":"lemma SeqReverseIdem_2427(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_2428","instance":2428,"id":189099,"goal":"lemma SeqMapLen_2428(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_2429","instance":2429,"id":189100,"goal":"lemma SeqFilterLe_2429(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_2430","instance":2430,"id":189101,"goal":"lemma SeqMemberAppend_2430(u: seq, t: seq)\n ensures x in u + t <==> x in u || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_2431","instance":2431,"id":189102,"goal":"lemma SeqAppendLen_2431(ys: seq, t: seq)\n ensures |ys + t| == |ys| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_2432","instance":2432,"id":189103,"goal":"lemma SeqAppendNil_2432(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_2433","instance":2433,"id":189104,"goal":"lemma SeqNilAppend_2433(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_2434","instance":2434,"id":189105,"goal":"lemma SeqAppendAssoc_2434(zs: seq, ys: seq, u: seq)\n ensures (zs + ys) + u == zs + (ys + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_2435","instance":2435,"id":189106,"goal":"lemma SeqTakeDrop_2435(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_2436","instance":2436,"id":189107,"goal":"lemma SeqReverseLen_2436(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_2437","instance":2437,"id":189108,"goal":"lemma SeqReverseIdem_2437(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_2438","instance":2438,"id":189109,"goal":"lemma SeqMapLen_2438(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_2439","instance":2439,"id":189110,"goal":"lemma SeqFilterLe_2439(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_2440","instance":2440,"id":189111,"goal":"lemma SeqMemberAppend_2440(u: seq, ys: seq)\n ensures x in u + ys <==> x in u || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_2441","instance":2441,"id":189112,"goal":"lemma SeqAppendLen_2441(zs: seq, ys: seq)\n ensures |zs + ys| == |zs| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_2442","instance":2442,"id":189113,"goal":"lemma SeqAppendNil_2442(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_2443","instance":2443,"id":189114,"goal":"lemma SeqNilAppend_2443(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_2444","instance":2444,"id":189115,"goal":"lemma SeqAppendAssoc_2444(u: seq, t: seq, ys: seq)\n ensures (u + t) + ys == u + (t + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_2445","instance":2445,"id":189116,"goal":"lemma SeqTakeDrop_2445(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_2446","instance":2446,"id":189117,"goal":"lemma SeqReverseLen_2446(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_2447","instance":2447,"id":189118,"goal":"lemma SeqReverseIdem_2447(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_2448","instance":2448,"id":189119,"goal":"lemma SeqMapLen_2448(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_2449","instance":2449,"id":189120,"goal":"lemma SeqFilterLe_2449(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_2450","instance":2450,"id":189121,"goal":"lemma SeqMemberAppend_2450(zs: seq, s: seq)\n ensures x in zs + s <==> x in zs || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_2451","instance":2451,"id":189122,"goal":"lemma SeqAppendLen_2451(s: seq, t: seq)\n ensures |s + t| == |s| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_2452","instance":2452,"id":189123,"goal":"lemma SeqAppendNil_2452(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_2453","instance":2453,"id":189124,"goal":"lemma SeqNilAppend_2453(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_2454","instance":2454,"id":189125,"goal":"lemma SeqAppendAssoc_2454(ys: seq, zs: seq, u: seq)\n ensures (ys + zs) + u == ys + (zs + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_2455","instance":2455,"id":189126,"goal":"lemma SeqTakeDrop_2455(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_2456","instance":2456,"id":189127,"goal":"lemma SeqReverseLen_2456(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_2457","instance":2457,"id":189128,"goal":"lemma SeqReverseIdem_2457(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_2458","instance":2458,"id":189129,"goal":"lemma SeqMapLen_2458(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_2459","instance":2459,"id":189130,"goal":"lemma SeqFilterLe_2459(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_2460","instance":2460,"id":189131,"goal":"lemma SeqMemberAppend_2460(xs: seq, s: seq)\n ensures x in xs + s <==> x in xs || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_2461","instance":2461,"id":189132,"goal":"lemma SeqAppendLen_2461(s: seq, zs: seq)\n ensures |s + zs| == |s| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_2462","instance":2462,"id":189133,"goal":"lemma SeqAppendNil_2462(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_2463","instance":2463,"id":189134,"goal":"lemma SeqNilAppend_2463(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_2464","instance":2464,"id":189135,"goal":"lemma SeqAppendAssoc_2464(t: seq, u: seq, ys: seq)\n ensures (t + u) + ys == t + (u + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_2465","instance":2465,"id":189136,"goal":"lemma SeqTakeDrop_2465(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_2466","instance":2466,"id":189137,"goal":"lemma SeqReverseLen_2466(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_2467","instance":2467,"id":189138,"goal":"lemma SeqReverseIdem_2467(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_2468","instance":2468,"id":189139,"goal":"lemma SeqMapLen_2468(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_2469","instance":2469,"id":189140,"goal":"lemma SeqFilterLe_2469(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_2470","instance":2470,"id":189141,"goal":"lemma SeqMemberAppend_2470(u: seq, t: seq)\n ensures x in u + t <==> x in u || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_2471","instance":2471,"id":189142,"goal":"lemma SeqAppendLen_2471(u: seq, t: seq)\n ensures |u + t| == |u| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_2472","instance":2472,"id":189143,"goal":"lemma SeqAppendNil_2472(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_2473","instance":2473,"id":189144,"goal":"lemma SeqNilAppend_2473(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_2474","instance":2474,"id":189145,"goal":"lemma SeqAppendAssoc_2474(xs: seq, t: seq, u: seq)\n ensures (xs + t) + u == xs + (t + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_2475","instance":2475,"id":189146,"goal":"lemma SeqTakeDrop_2475(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_2476","instance":2476,"id":189147,"goal":"lemma SeqReverseLen_2476(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_2477","instance":2477,"id":189148,"goal":"lemma SeqReverseIdem_2477(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_2478","instance":2478,"id":189149,"goal":"lemma SeqMapLen_2478(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_2479","instance":2479,"id":189150,"goal":"lemma SeqFilterLe_2479(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_2480","instance":2480,"id":189151,"goal":"lemma SeqMemberAppend_2480(xs: seq, zs: seq)\n ensures x in xs + zs <==> x in xs || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_2481","instance":2481,"id":189152,"goal":"lemma SeqAppendLen_2481(s: seq, ys: seq)\n ensures |s + ys| == |s| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_2482","instance":2482,"id":189153,"goal":"lemma SeqAppendNil_2482(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_2483","instance":2483,"id":189154,"goal":"lemma SeqNilAppend_2483(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_2484","instance":2484,"id":189155,"goal":"lemma SeqAppendAssoc_2484(ys: seq, xs: seq, s: seq)\n ensures (ys + xs) + s == ys + (xs + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_2485","instance":2485,"id":189156,"goal":"lemma SeqTakeDrop_2485(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_2486","instance":2486,"id":189157,"goal":"lemma SeqReverseLen_2486(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_2487","instance":2487,"id":189158,"goal":"lemma SeqReverseIdem_2487(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_2488","instance":2488,"id":189159,"goal":"lemma SeqMapLen_2488(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_2489","instance":2489,"id":189160,"goal":"lemma SeqFilterLe_2489(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_2490","instance":2490,"id":189161,"goal":"lemma SeqMemberAppend_2490(xs: seq, u: seq)\n ensures x in xs + u <==> x in xs || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_2491","instance":2491,"id":189162,"goal":"lemma SeqAppendLen_2491(u: seq, xs: seq)\n ensures |u + xs| == |u| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_2492","instance":2492,"id":189163,"goal":"lemma SeqAppendNil_2492(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_2493","instance":2493,"id":189164,"goal":"lemma SeqNilAppend_2493(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_2494","instance":2494,"id":189165,"goal":"lemma SeqAppendAssoc_2494(t: seq, xs: seq, ys: seq)\n ensures (t + xs) + ys == t + (xs + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_2495","instance":2495,"id":189166,"goal":"lemma SeqTakeDrop_2495(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_2496","instance":2496,"id":189167,"goal":"lemma SeqReverseLen_2496(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_2497","instance":2497,"id":189168,"goal":"lemma SeqReverseIdem_2497(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_2498","instance":2498,"id":189169,"goal":"lemma SeqMapLen_2498(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_2499","instance":2499,"id":189170,"goal":"lemma SeqFilterLe_2499(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_2500","instance":2500,"id":189171,"goal":"lemma SeqMemberAppend_2500(xs: seq, zs: seq)\n ensures x in xs + zs <==> x in xs || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_2501","instance":2501,"id":189172,"goal":"lemma SeqAppendLen_2501(xs: seq, ys: seq)\n ensures |xs + ys| == |xs| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_2502","instance":2502,"id":189173,"goal":"lemma SeqAppendNil_2502(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_2503","instance":2503,"id":189174,"goal":"lemma SeqNilAppend_2503(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_2504","instance":2504,"id":189175,"goal":"lemma SeqAppendAssoc_2504(s: seq, zs: seq, xs: seq)\n ensures (s + zs) + xs == s + (zs + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_2505","instance":2505,"id":189176,"goal":"lemma SeqTakeDrop_2505(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_2506","instance":2506,"id":189177,"goal":"lemma SeqReverseLen_2506(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_2507","instance":2507,"id":189178,"goal":"lemma SeqReverseIdem_2507(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_2508","instance":2508,"id":189179,"goal":"lemma SeqMapLen_2508(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_2509","instance":2509,"id":189180,"goal":"lemma SeqFilterLe_2509(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_2510","instance":2510,"id":189181,"goal":"lemma SeqMemberAppend_2510(zs: seq, xs: seq)\n ensures x in zs + xs <==> x in zs || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_2511","instance":2511,"id":189182,"goal":"lemma SeqAppendLen_2511(s: seq, ys: seq)\n ensures |s + ys| == |s| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_2512","instance":2512,"id":189183,"goal":"lemma SeqAppendNil_2512(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_2513","instance":2513,"id":189184,"goal":"lemma SeqNilAppend_2513(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_2514","instance":2514,"id":189185,"goal":"lemma SeqAppendAssoc_2514(zs: seq, ys: seq, s: seq)\n ensures (zs + ys) + s == zs + (ys + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_2515","instance":2515,"id":189186,"goal":"lemma SeqTakeDrop_2515(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_2516","instance":2516,"id":189187,"goal":"lemma SeqReverseLen_2516(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_2517","instance":2517,"id":189188,"goal":"lemma SeqReverseIdem_2517(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_2518","instance":2518,"id":189189,"goal":"lemma SeqMapLen_2518(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_2519","instance":2519,"id":189190,"goal":"lemma SeqFilterLe_2519(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_2520","instance":2520,"id":189191,"goal":"lemma SeqMemberAppend_2520(zs: seq, t: seq)\n ensures x in zs + t <==> x in zs || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_2521","instance":2521,"id":189192,"goal":"lemma SeqAppendLen_2521(s: seq, xs: seq)\n ensures |s + xs| == |s| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_2522","instance":2522,"id":189193,"goal":"lemma SeqAppendNil_2522(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_2523","instance":2523,"id":189194,"goal":"lemma SeqNilAppend_2523(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_2524","instance":2524,"id":189195,"goal":"lemma SeqAppendAssoc_2524(u: seq, ys: seq, t: seq)\n ensures (u + ys) + t == u + (ys + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_2525","instance":2525,"id":189196,"goal":"lemma SeqTakeDrop_2525(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_2526","instance":2526,"id":189197,"goal":"lemma SeqReverseLen_2526(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_2527","instance":2527,"id":189198,"goal":"lemma SeqReverseIdem_2527(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_2528","instance":2528,"id":189199,"goal":"lemma SeqMapLen_2528(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_2529","instance":2529,"id":189200,"goal":"lemma SeqFilterLe_2529(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_2530","instance":2530,"id":189201,"goal":"lemma SeqMemberAppend_2530(s: seq, u: seq)\n ensures x in s + u <==> x in s || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_2531","instance":2531,"id":189202,"goal":"lemma SeqAppendLen_2531(s: seq, u: seq)\n ensures |s + u| == |s| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_2532","instance":2532,"id":189203,"goal":"lemma SeqAppendNil_2532(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_2533","instance":2533,"id":189204,"goal":"lemma SeqNilAppend_2533(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_2534","instance":2534,"id":189205,"goal":"lemma SeqAppendAssoc_2534(zs: seq, ys: seq, t: seq)\n ensures (zs + ys) + t == zs + (ys + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_2535","instance":2535,"id":189206,"goal":"lemma SeqTakeDrop_2535(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_2536","instance":2536,"id":189207,"goal":"lemma SeqReverseLen_2536(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_2537","instance":2537,"id":189208,"goal":"lemma SeqReverseIdem_2537(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_2538","instance":2538,"id":189209,"goal":"lemma SeqMapLen_2538(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_2539","instance":2539,"id":189210,"goal":"lemma SeqFilterLe_2539(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_2540","instance":2540,"id":189211,"goal":"lemma SeqMemberAppend_2540(u: seq, s: seq)\n ensures x in u + s <==> x in u || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_2541","instance":2541,"id":189212,"goal":"lemma SeqAppendLen_2541(u: seq, xs: seq)\n ensures |u + xs| == |u| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_2542","instance":2542,"id":189213,"goal":"lemma SeqAppendNil_2542(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_2543","instance":2543,"id":189214,"goal":"lemma SeqNilAppend_2543(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_2544","instance":2544,"id":189215,"goal":"lemma SeqAppendAssoc_2544(zs: seq, xs: seq, u: seq)\n ensures (zs + xs) + u == zs + (xs + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_2545","instance":2545,"id":189216,"goal":"lemma SeqTakeDrop_2545(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_2546","instance":2546,"id":189217,"goal":"lemma SeqReverseLen_2546(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_2547","instance":2547,"id":189218,"goal":"lemma SeqReverseIdem_2547(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_2548","instance":2548,"id":189219,"goal":"lemma SeqMapLen_2548(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_2549","instance":2549,"id":189220,"goal":"lemma SeqFilterLe_2549(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_2550","instance":2550,"id":189221,"goal":"lemma SeqMemberAppend_2550(xs: seq, s: seq)\n ensures x in xs + s <==> x in xs || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_2551","instance":2551,"id":189222,"goal":"lemma SeqAppendLen_2551(s: seq, xs: seq)\n ensures |s + xs| == |s| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_2552","instance":2552,"id":189223,"goal":"lemma SeqAppendNil_2552(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_2553","instance":2553,"id":189224,"goal":"lemma SeqNilAppend_2553(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_2554","instance":2554,"id":189225,"goal":"lemma SeqAppendAssoc_2554(s: seq, xs: seq, u: seq)\n ensures (s + xs) + u == s + (xs + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_2555","instance":2555,"id":189226,"goal":"lemma SeqTakeDrop_2555(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_2556","instance":2556,"id":189227,"goal":"lemma SeqReverseLen_2556(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_2557","instance":2557,"id":189228,"goal":"lemma SeqReverseIdem_2557(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_2558","instance":2558,"id":189229,"goal":"lemma SeqMapLen_2558(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_2559","instance":2559,"id":189230,"goal":"lemma SeqFilterLe_2559(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_2560","instance":2560,"id":189231,"goal":"lemma SeqMemberAppend_2560(t: seq, s: seq)\n ensures x in t + s <==> x in t || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_2561","instance":2561,"id":189232,"goal":"lemma SeqAppendLen_2561(ys: seq, s: seq)\n ensures |ys + s| == |ys| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_2562","instance":2562,"id":189233,"goal":"lemma SeqAppendNil_2562(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_2563","instance":2563,"id":189234,"goal":"lemma SeqNilAppend_2563(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_2564","instance":2564,"id":189235,"goal":"lemma SeqAppendAssoc_2564(u: seq, t: seq, xs: seq)\n ensures (u + t) + xs == u + (t + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_2565","instance":2565,"id":189236,"goal":"lemma SeqTakeDrop_2565(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_2566","instance":2566,"id":189237,"goal":"lemma SeqReverseLen_2566(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_2567","instance":2567,"id":189238,"goal":"lemma SeqReverseIdem_2567(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_2568","instance":2568,"id":189239,"goal":"lemma SeqMapLen_2568(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_2569","instance":2569,"id":189240,"goal":"lemma SeqFilterLe_2569(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_2570","instance":2570,"id":189241,"goal":"lemma SeqMemberAppend_2570(zs: seq, u: seq)\n ensures x in zs + u <==> x in zs || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_2571","instance":2571,"id":189242,"goal":"lemma SeqAppendLen_2571(ys: seq, t: seq)\n ensures |ys + t| == |ys| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_2572","instance":2572,"id":189243,"goal":"lemma SeqAppendNil_2572(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_2573","instance":2573,"id":189244,"goal":"lemma SeqNilAppend_2573(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_2574","instance":2574,"id":189245,"goal":"lemma SeqAppendAssoc_2574(s: seq, t: seq, zs: seq)\n ensures (s + t) + zs == s + (t + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_2575","instance":2575,"id":189246,"goal":"lemma SeqTakeDrop_2575(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_2576","instance":2576,"id":189247,"goal":"lemma SeqReverseLen_2576(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_2577","instance":2577,"id":189248,"goal":"lemma SeqReverseIdem_2577(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_2578","instance":2578,"id":189249,"goal":"lemma SeqMapLen_2578(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_2579","instance":2579,"id":189250,"goal":"lemma SeqFilterLe_2579(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_2580","instance":2580,"id":189251,"goal":"lemma SeqMemberAppend_2580(t: seq, xs: seq)\n ensures x in t + xs <==> x in t || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_2581","instance":2581,"id":189252,"goal":"lemma SeqAppendLen_2581(zs: seq, s: seq)\n ensures |zs + s| == |zs| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_2582","instance":2582,"id":189253,"goal":"lemma SeqAppendNil_2582(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_2583","instance":2583,"id":189254,"goal":"lemma SeqNilAppend_2583(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_2584","instance":2584,"id":189255,"goal":"lemma SeqAppendAssoc_2584(xs: seq, u: seq, zs: seq)\n ensures (xs + u) + zs == xs + (u + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_2585","instance":2585,"id":189256,"goal":"lemma SeqTakeDrop_2585(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_2586","instance":2586,"id":189257,"goal":"lemma SeqReverseLen_2586(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_2587","instance":2587,"id":189258,"goal":"lemma SeqReverseIdem_2587(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_2588","instance":2588,"id":189259,"goal":"lemma SeqMapLen_2588(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_2589","instance":2589,"id":189260,"goal":"lemma SeqFilterLe_2589(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_2590","instance":2590,"id":189261,"goal":"lemma SeqMemberAppend_2590(s: seq, xs: seq)\n ensures x in s + xs <==> x in s || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_2591","instance":2591,"id":189262,"goal":"lemma SeqAppendLen_2591(t: seq, xs: seq)\n ensures |t + xs| == |t| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_2592","instance":2592,"id":189263,"goal":"lemma SeqAppendNil_2592(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_2593","instance":2593,"id":189264,"goal":"lemma SeqNilAppend_2593(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_2594","instance":2594,"id":189265,"goal":"lemma SeqAppendAssoc_2594(s: seq, zs: seq, u: seq)\n ensures (s + zs) + u == s + (zs + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_2595","instance":2595,"id":189266,"goal":"lemma SeqTakeDrop_2595(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_2596","instance":2596,"id":189267,"goal":"lemma SeqReverseLen_2596(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_2597","instance":2597,"id":189268,"goal":"lemma SeqReverseIdem_2597(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_2598","instance":2598,"id":189269,"goal":"lemma SeqMapLen_2598(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_2599","instance":2599,"id":189270,"goal":"lemma SeqFilterLe_2599(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_2600","instance":2600,"id":189271,"goal":"lemma SeqMemberAppend_2600(t: seq, u: seq)\n ensures x in t + u <==> x in t || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_2601","instance":2601,"id":189272,"goal":"lemma SeqAppendLen_2601(ys: seq, s: seq)\n ensures |ys + s| == |ys| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_2602","instance":2602,"id":189273,"goal":"lemma SeqAppendNil_2602(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_2603","instance":2603,"id":189274,"goal":"lemma SeqNilAppend_2603(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_2604","instance":2604,"id":189275,"goal":"lemma SeqAppendAssoc_2604(ys: seq, zs: seq, u: seq)\n ensures (ys + zs) + u == ys + (zs + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_2605","instance":2605,"id":189276,"goal":"lemma SeqTakeDrop_2605(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_2606","instance":2606,"id":189277,"goal":"lemma SeqReverseLen_2606(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_2607","instance":2607,"id":189278,"goal":"lemma SeqReverseIdem_2607(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_2608","instance":2608,"id":189279,"goal":"lemma SeqMapLen_2608(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_2609","instance":2609,"id":189280,"goal":"lemma SeqFilterLe_2609(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_2610","instance":2610,"id":189281,"goal":"lemma SeqMemberAppend_2610(zs: seq, s: seq)\n ensures x in zs + s <==> x in zs || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_2611","instance":2611,"id":189282,"goal":"lemma SeqAppendLen_2611(u: seq, zs: seq)\n ensures |u + zs| == |u| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_2612","instance":2612,"id":189283,"goal":"lemma SeqAppendNil_2612(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_2613","instance":2613,"id":189284,"goal":"lemma SeqNilAppend_2613(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_2614","instance":2614,"id":189285,"goal":"lemma SeqAppendAssoc_2614(ys: seq, t: seq, zs: seq)\n ensures (ys + t) + zs == ys + (t + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_2615","instance":2615,"id":189286,"goal":"lemma SeqTakeDrop_2615(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_2616","instance":2616,"id":189287,"goal":"lemma SeqReverseLen_2616(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_2617","instance":2617,"id":189288,"goal":"lemma SeqReverseIdem_2617(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_2618","instance":2618,"id":189289,"goal":"lemma SeqMapLen_2618(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_2619","instance":2619,"id":189290,"goal":"lemma SeqFilterLe_2619(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_2620","instance":2620,"id":189291,"goal":"lemma SeqMemberAppend_2620(ys: seq, u: seq)\n ensures x in ys + u <==> x in ys || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_2621","instance":2621,"id":189292,"goal":"lemma SeqAppendLen_2621(s: seq, xs: seq)\n ensures |s + xs| == |s| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_2622","instance":2622,"id":189293,"goal":"lemma SeqAppendNil_2622(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_2623","instance":2623,"id":189294,"goal":"lemma SeqNilAppend_2623(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_2624","instance":2624,"id":189295,"goal":"lemma SeqAppendAssoc_2624(xs: seq, u: seq, t: seq)\n ensures (xs + u) + t == xs + (u + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_2625","instance":2625,"id":189296,"goal":"lemma SeqTakeDrop_2625(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_2626","instance":2626,"id":189297,"goal":"lemma SeqReverseLen_2626(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_2627","instance":2627,"id":189298,"goal":"lemma SeqReverseIdem_2627(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_2628","instance":2628,"id":189299,"goal":"lemma SeqMapLen_2628(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_2629","instance":2629,"id":189300,"goal":"lemma SeqFilterLe_2629(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_2630","instance":2630,"id":189301,"goal":"lemma SeqMemberAppend_2630(ys: seq, u: seq)\n ensures x in ys + u <==> x in ys || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_2631","instance":2631,"id":189302,"goal":"lemma SeqAppendLen_2631(s: seq, zs: seq)\n ensures |s + zs| == |s| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_2632","instance":2632,"id":189303,"goal":"lemma SeqAppendNil_2632(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_2633","instance":2633,"id":189304,"goal":"lemma SeqNilAppend_2633(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_2634","instance":2634,"id":189305,"goal":"lemma SeqAppendAssoc_2634(xs: seq, ys: seq, t: seq)\n ensures (xs + ys) + t == xs + (ys + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_2635","instance":2635,"id":189306,"goal":"lemma SeqTakeDrop_2635(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_2636","instance":2636,"id":189307,"goal":"lemma SeqReverseLen_2636(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_2637","instance":2637,"id":189308,"goal":"lemma SeqReverseIdem_2637(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_2638","instance":2638,"id":189309,"goal":"lemma SeqMapLen_2638(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_2639","instance":2639,"id":189310,"goal":"lemma SeqFilterLe_2639(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_2640","instance":2640,"id":189311,"goal":"lemma SeqMemberAppend_2640(ys: seq, zs: seq)\n ensures x in ys + zs <==> x in ys || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_2641","instance":2641,"id":189312,"goal":"lemma SeqAppendLen_2641(ys: seq, s: seq)\n ensures |ys + s| == |ys| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_2642","instance":2642,"id":189313,"goal":"lemma SeqAppendNil_2642(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_2643","instance":2643,"id":189314,"goal":"lemma SeqNilAppend_2643(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_2644","instance":2644,"id":189315,"goal":"lemma SeqAppendAssoc_2644(s: seq, zs: seq, u: seq)\n ensures (s + zs) + u == s + (zs + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_2645","instance":2645,"id":189316,"goal":"lemma SeqTakeDrop_2645(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_2646","instance":2646,"id":189317,"goal":"lemma SeqReverseLen_2646(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_2647","instance":2647,"id":189318,"goal":"lemma SeqReverseIdem_2647(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_2648","instance":2648,"id":189319,"goal":"lemma SeqMapLen_2648(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_2649","instance":2649,"id":189320,"goal":"lemma SeqFilterLe_2649(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_2650","instance":2650,"id":189321,"goal":"lemma SeqMemberAppend_2650(ys: seq, zs: seq)\n ensures x in ys + zs <==> x in ys || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_2651","instance":2651,"id":189322,"goal":"lemma SeqAppendLen_2651(ys: seq, xs: seq)\n ensures |ys + xs| == |ys| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_2652","instance":2652,"id":189323,"goal":"lemma SeqAppendNil_2652(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_2653","instance":2653,"id":189324,"goal":"lemma SeqNilAppend_2653(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_2654","instance":2654,"id":189325,"goal":"lemma SeqAppendAssoc_2654(t: seq, s: seq, ys: seq)\n ensures (t + s) + ys == t + (s + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_2655","instance":2655,"id":189326,"goal":"lemma SeqTakeDrop_2655(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_2656","instance":2656,"id":189327,"goal":"lemma SeqReverseLen_2656(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_2657","instance":2657,"id":189328,"goal":"lemma SeqReverseIdem_2657(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_2658","instance":2658,"id":189329,"goal":"lemma SeqMapLen_2658(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_2659","instance":2659,"id":189330,"goal":"lemma SeqFilterLe_2659(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_2660","instance":2660,"id":189331,"goal":"lemma SeqMemberAppend_2660(ys: seq, s: seq)\n ensures x in ys + s <==> x in ys || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_2661","instance":2661,"id":189332,"goal":"lemma SeqAppendLen_2661(s: seq, xs: seq)\n ensures |s + xs| == |s| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_2662","instance":2662,"id":189333,"goal":"lemma SeqAppendNil_2662(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_2663","instance":2663,"id":189334,"goal":"lemma SeqNilAppend_2663(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_2664","instance":2664,"id":189335,"goal":"lemma SeqAppendAssoc_2664(s: seq, xs: seq, u: seq)\n ensures (s + xs) + u == s + (xs + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_2665","instance":2665,"id":189336,"goal":"lemma SeqTakeDrop_2665(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_2666","instance":2666,"id":189337,"goal":"lemma SeqReverseLen_2666(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_2667","instance":2667,"id":189338,"goal":"lemma SeqReverseIdem_2667(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_2668","instance":2668,"id":189339,"goal":"lemma SeqMapLen_2668(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_2669","instance":2669,"id":189340,"goal":"lemma SeqFilterLe_2669(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_2670","instance":2670,"id":189341,"goal":"lemma SeqMemberAppend_2670(t: seq, xs: seq)\n ensures x in t + xs <==> x in t || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_2671","instance":2671,"id":189342,"goal":"lemma SeqAppendLen_2671(ys: seq, zs: seq)\n ensures |ys + zs| == |ys| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_2672","instance":2672,"id":189343,"goal":"lemma SeqAppendNil_2672(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_2673","instance":2673,"id":189344,"goal":"lemma SeqNilAppend_2673(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_2674","instance":2674,"id":189345,"goal":"lemma SeqAppendAssoc_2674(u: seq, s: seq, zs: seq)\n ensures (u + s) + zs == u + (s + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_2675","instance":2675,"id":189346,"goal":"lemma SeqTakeDrop_2675(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_2676","instance":2676,"id":189347,"goal":"lemma SeqReverseLen_2676(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_2677","instance":2677,"id":189348,"goal":"lemma SeqReverseIdem_2677(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_2678","instance":2678,"id":189349,"goal":"lemma SeqMapLen_2678(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_2679","instance":2679,"id":189350,"goal":"lemma SeqFilterLe_2679(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_2680","instance":2680,"id":189351,"goal":"lemma SeqMemberAppend_2680(s: seq, u: seq)\n ensures x in s + u <==> x in s || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_2681","instance":2681,"id":189352,"goal":"lemma SeqAppendLen_2681(s: seq, ys: seq)\n ensures |s + ys| == |s| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_2682","instance":2682,"id":189353,"goal":"lemma SeqAppendNil_2682(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_2683","instance":2683,"id":189354,"goal":"lemma SeqNilAppend_2683(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_2684","instance":2684,"id":189355,"goal":"lemma SeqAppendAssoc_2684(t: seq, xs: seq, s: seq)\n ensures (t + xs) + s == t + (xs + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_2685","instance":2685,"id":189356,"goal":"lemma SeqTakeDrop_2685(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_2686","instance":2686,"id":189357,"goal":"lemma SeqReverseLen_2686(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_2687","instance":2687,"id":189358,"goal":"lemma SeqReverseIdem_2687(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_2688","instance":2688,"id":189359,"goal":"lemma SeqMapLen_2688(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_2689","instance":2689,"id":189360,"goal":"lemma SeqFilterLe_2689(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_2690","instance":2690,"id":189361,"goal":"lemma SeqMemberAppend_2690(xs: seq, s: seq)\n ensures x in xs + s <==> x in xs || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_2691","instance":2691,"id":189362,"goal":"lemma SeqAppendLen_2691(s: seq, u: seq)\n ensures |s + u| == |s| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_2692","instance":2692,"id":189363,"goal":"lemma SeqAppendNil_2692(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_2693","instance":2693,"id":189364,"goal":"lemma SeqNilAppend_2693(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_2694","instance":2694,"id":189365,"goal":"lemma SeqAppendAssoc_2694(t: seq, s: seq, u: seq)\n ensures (t + s) + u == t + (s + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_2695","instance":2695,"id":189366,"goal":"lemma SeqTakeDrop_2695(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_2696","instance":2696,"id":189367,"goal":"lemma SeqReverseLen_2696(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_2697","instance":2697,"id":189368,"goal":"lemma SeqReverseIdem_2697(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_2698","instance":2698,"id":189369,"goal":"lemma SeqMapLen_2698(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_2699","instance":2699,"id":189370,"goal":"lemma SeqFilterLe_2699(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_2700","instance":2700,"id":189371,"goal":"lemma SeqMemberAppend_2700(zs: seq, xs: seq)\n ensures x in zs + xs <==> x in zs || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_2701","instance":2701,"id":189372,"goal":"lemma SeqAppendLen_2701(t: seq, s: seq)\n ensures |t + s| == |t| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_2702","instance":2702,"id":189373,"goal":"lemma SeqAppendNil_2702(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_2703","instance":2703,"id":189374,"goal":"lemma SeqNilAppend_2703(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_2704","instance":2704,"id":189375,"goal":"lemma SeqAppendAssoc_2704(zs: seq, u: seq, s: seq)\n ensures (zs + u) + s == zs + (u + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_2705","instance":2705,"id":189376,"goal":"lemma SeqTakeDrop_2705(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_2706","instance":2706,"id":189377,"goal":"lemma SeqReverseLen_2706(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_2707","instance":2707,"id":189378,"goal":"lemma SeqReverseIdem_2707(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_2708","instance":2708,"id":189379,"goal":"lemma SeqMapLen_2708(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_2709","instance":2709,"id":189380,"goal":"lemma SeqFilterLe_2709(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_2710","instance":2710,"id":189381,"goal":"lemma SeqMemberAppend_2710(s: seq, ys: seq)\n ensures x in s + ys <==> x in s || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_2711","instance":2711,"id":189382,"goal":"lemma SeqAppendLen_2711(t: seq, u: seq)\n ensures |t + u| == |t| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_2712","instance":2712,"id":189383,"goal":"lemma SeqAppendNil_2712(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_2713","instance":2713,"id":189384,"goal":"lemma SeqNilAppend_2713(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_2714","instance":2714,"id":189385,"goal":"lemma SeqAppendAssoc_2714(zs: seq, u: seq, ys: seq)\n ensures (zs + u) + ys == zs + (u + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_2715","instance":2715,"id":189386,"goal":"lemma SeqTakeDrop_2715(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_2716","instance":2716,"id":189387,"goal":"lemma SeqReverseLen_2716(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_2717","instance":2717,"id":189388,"goal":"lemma SeqReverseIdem_2717(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_2718","instance":2718,"id":189389,"goal":"lemma SeqMapLen_2718(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_2719","instance":2719,"id":189390,"goal":"lemma SeqFilterLe_2719(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_2720","instance":2720,"id":189391,"goal":"lemma SeqMemberAppend_2720(u: seq, ys: seq)\n ensures x in u + ys <==> x in u || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_2721","instance":2721,"id":189392,"goal":"lemma SeqAppendLen_2721(u: seq, xs: seq)\n ensures |u + xs| == |u| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_2722","instance":2722,"id":189393,"goal":"lemma SeqAppendNil_2722(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_2723","instance":2723,"id":189394,"goal":"lemma SeqNilAppend_2723(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_2724","instance":2724,"id":189395,"goal":"lemma SeqAppendAssoc_2724(t: seq, u: seq, ys: seq)\n ensures (t + u) + ys == t + (u + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_2725","instance":2725,"id":189396,"goal":"lemma SeqTakeDrop_2725(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_2726","instance":2726,"id":189397,"goal":"lemma SeqReverseLen_2726(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_2727","instance":2727,"id":189398,"goal":"lemma SeqReverseIdem_2727(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_2728","instance":2728,"id":189399,"goal":"lemma SeqMapLen_2728(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_2729","instance":2729,"id":189400,"goal":"lemma SeqFilterLe_2729(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_2730","instance":2730,"id":189401,"goal":"lemma SeqMemberAppend_2730(ys: seq, xs: seq)\n ensures x in ys + xs <==> x in ys || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_2731","instance":2731,"id":189402,"goal":"lemma SeqAppendLen_2731(s: seq, zs: seq)\n ensures |s + zs| == |s| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_2732","instance":2732,"id":189403,"goal":"lemma SeqAppendNil_2732(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_2733","instance":2733,"id":189404,"goal":"lemma SeqNilAppend_2733(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_2734","instance":2734,"id":189405,"goal":"lemma SeqAppendAssoc_2734(xs: seq, u: seq, s: seq)\n ensures (xs + u) + s == xs + (u + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_2735","instance":2735,"id":189406,"goal":"lemma SeqTakeDrop_2735(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_2736","instance":2736,"id":189407,"goal":"lemma SeqReverseLen_2736(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_2737","instance":2737,"id":189408,"goal":"lemma SeqReverseIdem_2737(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_2738","instance":2738,"id":189409,"goal":"lemma SeqMapLen_2738(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_2739","instance":2739,"id":189410,"goal":"lemma SeqFilterLe_2739(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_2740","instance":2740,"id":189411,"goal":"lemma SeqMemberAppend_2740(zs: seq, s: seq)\n ensures x in zs + s <==> x in zs || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_2741","instance":2741,"id":189412,"goal":"lemma SeqAppendLen_2741(u: seq, zs: seq)\n ensures |u + zs| == |u| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_2742","instance":2742,"id":189413,"goal":"lemma SeqAppendNil_2742(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_2743","instance":2743,"id":189414,"goal":"lemma SeqNilAppend_2743(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_2744","instance":2744,"id":189415,"goal":"lemma SeqAppendAssoc_2744(zs: seq, s: seq, ys: seq)\n ensures (zs + s) + ys == zs + (s + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_2745","instance":2745,"id":189416,"goal":"lemma SeqTakeDrop_2745(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_2746","instance":2746,"id":189417,"goal":"lemma SeqReverseLen_2746(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_2747","instance":2747,"id":189418,"goal":"lemma SeqReverseIdem_2747(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_2748","instance":2748,"id":189419,"goal":"lemma SeqMapLen_2748(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_2749","instance":2749,"id":189420,"goal":"lemma SeqFilterLe_2749(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_2750","instance":2750,"id":189421,"goal":"lemma SeqMemberAppend_2750(xs: seq, zs: seq)\n ensures x in xs + zs <==> x in xs || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_2751","instance":2751,"id":189422,"goal":"lemma SeqAppendLen_2751(ys: seq, t: seq)\n ensures |ys + t| == |ys| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_2752","instance":2752,"id":189423,"goal":"lemma SeqAppendNil_2752(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_2753","instance":2753,"id":189424,"goal":"lemma SeqNilAppend_2753(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_2754","instance":2754,"id":189425,"goal":"lemma SeqAppendAssoc_2754(u: seq, xs: seq, s: seq)\n ensures (u + xs) + s == u + (xs + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_2755","instance":2755,"id":189426,"goal":"lemma SeqTakeDrop_2755(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_2756","instance":2756,"id":189427,"goal":"lemma SeqReverseLen_2756(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_2757","instance":2757,"id":189428,"goal":"lemma SeqReverseIdem_2757(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_2758","instance":2758,"id":189429,"goal":"lemma SeqMapLen_2758(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_2759","instance":2759,"id":189430,"goal":"lemma SeqFilterLe_2759(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_2760","instance":2760,"id":189431,"goal":"lemma SeqMemberAppend_2760(u: seq, ys: seq)\n ensures x in u + ys <==> x in u || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_2761","instance":2761,"id":189432,"goal":"lemma SeqAppendLen_2761(s: seq, xs: seq)\n ensures |s + xs| == |s| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_2762","instance":2762,"id":189433,"goal":"lemma SeqAppendNil_2762(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_2763","instance":2763,"id":189434,"goal":"lemma SeqNilAppend_2763(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_2764","instance":2764,"id":189435,"goal":"lemma SeqAppendAssoc_2764(zs: seq, t: seq, xs: seq)\n ensures (zs + t) + xs == zs + (t + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_2765","instance":2765,"id":189436,"goal":"lemma SeqTakeDrop_2765(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_2766","instance":2766,"id":189437,"goal":"lemma SeqReverseLen_2766(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_2767","instance":2767,"id":189438,"goal":"lemma SeqReverseIdem_2767(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_2768","instance":2768,"id":189439,"goal":"lemma SeqMapLen_2768(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_2769","instance":2769,"id":189440,"goal":"lemma SeqFilterLe_2769(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_2770","instance":2770,"id":189441,"goal":"lemma SeqMemberAppend_2770(xs: seq, t: seq)\n ensures x in xs + t <==> x in xs || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_2771","instance":2771,"id":189442,"goal":"lemma SeqAppendLen_2771(zs: seq, t: seq)\n ensures |zs + t| == |zs| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_2772","instance":2772,"id":189443,"goal":"lemma SeqAppendNil_2772(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_2773","instance":2773,"id":189444,"goal":"lemma SeqNilAppend_2773(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_2774","instance":2774,"id":189445,"goal":"lemma SeqAppendAssoc_2774(zs: seq, u: seq, t: seq)\n ensures (zs + u) + t == zs + (u + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_2775","instance":2775,"id":189446,"goal":"lemma SeqTakeDrop_2775(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_2776","instance":2776,"id":189447,"goal":"lemma SeqReverseLen_2776(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_2777","instance":2777,"id":189448,"goal":"lemma SeqReverseIdem_2777(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_2778","instance":2778,"id":189449,"goal":"lemma SeqMapLen_2778(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_2779","instance":2779,"id":189450,"goal":"lemma SeqFilterLe_2779(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_2780","instance":2780,"id":189451,"goal":"lemma SeqMemberAppend_2780(t: seq, s: seq)\n ensures x in t + s <==> x in t || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_2781","instance":2781,"id":189452,"goal":"lemma SeqAppendLen_2781(xs: seq, ys: seq)\n ensures |xs + ys| == |xs| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_2782","instance":2782,"id":189453,"goal":"lemma SeqAppendNil_2782(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_2783","instance":2783,"id":189454,"goal":"lemma SeqNilAppend_2783(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_2784","instance":2784,"id":189455,"goal":"lemma SeqAppendAssoc_2784(u: seq, xs: seq, zs: seq)\n ensures (u + xs) + zs == u + (xs + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_2785","instance":2785,"id":189456,"goal":"lemma SeqTakeDrop_2785(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_2786","instance":2786,"id":189457,"goal":"lemma SeqReverseLen_2786(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_2787","instance":2787,"id":189458,"goal":"lemma SeqReverseIdem_2787(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_2788","instance":2788,"id":189459,"goal":"lemma SeqMapLen_2788(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_2789","instance":2789,"id":189460,"goal":"lemma SeqFilterLe_2789(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_2790","instance":2790,"id":189461,"goal":"lemma SeqMemberAppend_2790(u: seq, zs: seq)\n ensures x in u + zs <==> x in u || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_2791","instance":2791,"id":189462,"goal":"lemma SeqAppendLen_2791(u: seq, s: seq)\n ensures |u + s| == |u| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_2792","instance":2792,"id":189463,"goal":"lemma SeqAppendNil_2792(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_2793","instance":2793,"id":189464,"goal":"lemma SeqNilAppend_2793(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_2794","instance":2794,"id":189465,"goal":"lemma SeqAppendAssoc_2794(ys: seq, u: seq, xs: seq)\n ensures (ys + u) + xs == ys + (u + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_2795","instance":2795,"id":189466,"goal":"lemma SeqTakeDrop_2795(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_2796","instance":2796,"id":189467,"goal":"lemma SeqReverseLen_2796(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_2797","instance":2797,"id":189468,"goal":"lemma SeqReverseIdem_2797(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_2798","instance":2798,"id":189469,"goal":"lemma SeqMapLen_2798(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_2799","instance":2799,"id":189470,"goal":"lemma SeqFilterLe_2799(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_2800","instance":2800,"id":189471,"goal":"lemma SeqMemberAppend_2800(zs: seq, xs: seq)\n ensures x in zs + xs <==> x in zs || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_2801","instance":2801,"id":189472,"goal":"lemma SeqAppendLen_2801(t: seq, s: seq)\n ensures |t + s| == |t| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_2802","instance":2802,"id":189473,"goal":"lemma SeqAppendNil_2802(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_2803","instance":2803,"id":189474,"goal":"lemma SeqNilAppend_2803(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_2804","instance":2804,"id":189475,"goal":"lemma SeqAppendAssoc_2804(ys: seq, u: seq, t: seq)\n ensures (ys + u) + t == ys + (u + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_2805","instance":2805,"id":189476,"goal":"lemma SeqTakeDrop_2805(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_2806","instance":2806,"id":189477,"goal":"lemma SeqReverseLen_2806(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_2807","instance":2807,"id":189478,"goal":"lemma SeqReverseIdem_2807(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_2808","instance":2808,"id":189479,"goal":"lemma SeqMapLen_2808(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_2809","instance":2809,"id":189480,"goal":"lemma SeqFilterLe_2809(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_2810","instance":2810,"id":189481,"goal":"lemma SeqMemberAppend_2810(zs: seq, u: seq)\n ensures x in zs + u <==> x in zs || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_2811","instance":2811,"id":189482,"goal":"lemma SeqAppendLen_2811(ys: seq, zs: seq)\n ensures |ys + zs| == |ys| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_2812","instance":2812,"id":189483,"goal":"lemma SeqAppendNil_2812(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_2813","instance":2813,"id":189484,"goal":"lemma SeqNilAppend_2813(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_2814","instance":2814,"id":189485,"goal":"lemma SeqAppendAssoc_2814(t: seq, xs: seq, zs: seq)\n ensures (t + xs) + zs == t + (xs + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_2815","instance":2815,"id":189486,"goal":"lemma SeqTakeDrop_2815(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_2816","instance":2816,"id":189487,"goal":"lemma SeqReverseLen_2816(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_2817","instance":2817,"id":189488,"goal":"lemma SeqReverseIdem_2817(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_2818","instance":2818,"id":189489,"goal":"lemma SeqMapLen_2818(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_2819","instance":2819,"id":189490,"goal":"lemma SeqFilterLe_2819(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_2820","instance":2820,"id":189491,"goal":"lemma SeqMemberAppend_2820(ys: seq, xs: seq)\n ensures x in ys + xs <==> x in ys || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_2821","instance":2821,"id":189492,"goal":"lemma SeqAppendLen_2821(t: seq, s: seq)\n ensures |t + s| == |t| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_2822","instance":2822,"id":189493,"goal":"lemma SeqAppendNil_2822(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_2823","instance":2823,"id":189494,"goal":"lemma SeqNilAppend_2823(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_2824","instance":2824,"id":189495,"goal":"lemma SeqAppendAssoc_2824(u: seq, zs: seq, xs: seq)\n ensures (u + zs) + xs == u + (zs + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_2825","instance":2825,"id":189496,"goal":"lemma SeqTakeDrop_2825(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_2826","instance":2826,"id":189497,"goal":"lemma SeqReverseLen_2826(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_2827","instance":2827,"id":189498,"goal":"lemma SeqReverseIdem_2827(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_2828","instance":2828,"id":189499,"goal":"lemma SeqMapLen_2828(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_2829","instance":2829,"id":189500,"goal":"lemma SeqFilterLe_2829(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_2830","instance":2830,"id":189501,"goal":"lemma SeqMemberAppend_2830(t: seq, zs: seq)\n ensures x in t + zs <==> x in t || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_2831","instance":2831,"id":189502,"goal":"lemma SeqAppendLen_2831(u: seq, xs: seq)\n ensures |u + xs| == |u| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_2832","instance":2832,"id":189503,"goal":"lemma SeqAppendNil_2832(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_2833","instance":2833,"id":189504,"goal":"lemma SeqNilAppend_2833(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_2834","instance":2834,"id":189505,"goal":"lemma SeqAppendAssoc_2834(xs: seq, zs: seq, ys: seq)\n ensures (xs + zs) + ys == xs + (zs + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_2835","instance":2835,"id":189506,"goal":"lemma SeqTakeDrop_2835(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_2836","instance":2836,"id":189507,"goal":"lemma SeqReverseLen_2836(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_2837","instance":2837,"id":189508,"goal":"lemma SeqReverseIdem_2837(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_2838","instance":2838,"id":189509,"goal":"lemma SeqMapLen_2838(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_2839","instance":2839,"id":189510,"goal":"lemma SeqFilterLe_2839(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_2840","instance":2840,"id":189511,"goal":"lemma SeqMemberAppend_2840(zs: seq, u: seq)\n ensures x in zs + u <==> x in zs || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_2841","instance":2841,"id":189512,"goal":"lemma SeqAppendLen_2841(ys: seq, u: seq)\n ensures |ys + u| == |ys| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_2842","instance":2842,"id":189513,"goal":"lemma SeqAppendNil_2842(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_2843","instance":2843,"id":189514,"goal":"lemma SeqNilAppend_2843(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_2844","instance":2844,"id":189515,"goal":"lemma SeqAppendAssoc_2844(ys: seq, zs: seq, u: seq)\n ensures (ys + zs) + u == ys + (zs + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_2845","instance":2845,"id":189516,"goal":"lemma SeqTakeDrop_2845(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_2846","instance":2846,"id":189517,"goal":"lemma SeqReverseLen_2846(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_2847","instance":2847,"id":189518,"goal":"lemma SeqReverseIdem_2847(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_2848","instance":2848,"id":189519,"goal":"lemma SeqMapLen_2848(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_2849","instance":2849,"id":189520,"goal":"lemma SeqFilterLe_2849(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_2850","instance":2850,"id":189521,"goal":"lemma SeqMemberAppend_2850(t: seq, u: seq)\n ensures x in t + u <==> x in t || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_2851","instance":2851,"id":189522,"goal":"lemma SeqAppendLen_2851(t: seq, ys: seq)\n ensures |t + ys| == |t| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_2852","instance":2852,"id":189523,"goal":"lemma SeqAppendNil_2852(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_2853","instance":2853,"id":189524,"goal":"lemma SeqNilAppend_2853(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_2854","instance":2854,"id":189525,"goal":"lemma SeqAppendAssoc_2854(xs: seq, s: seq, zs: seq)\n ensures (xs + s) + zs == xs + (s + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_2855","instance":2855,"id":189526,"goal":"lemma SeqTakeDrop_2855(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_2856","instance":2856,"id":189527,"goal":"lemma SeqReverseLen_2856(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_2857","instance":2857,"id":189528,"goal":"lemma SeqReverseIdem_2857(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_2858","instance":2858,"id":189529,"goal":"lemma SeqMapLen_2858(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_2859","instance":2859,"id":189530,"goal":"lemma SeqFilterLe_2859(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_2860","instance":2860,"id":189531,"goal":"lemma SeqMemberAppend_2860(zs: seq, u: seq)\n ensures x in zs + u <==> x in zs || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_2861","instance":2861,"id":189532,"goal":"lemma SeqAppendLen_2861(ys: seq, s: seq)\n ensures |ys + s| == |ys| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_2862","instance":2862,"id":189533,"goal":"lemma SeqAppendNil_2862(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_2863","instance":2863,"id":189534,"goal":"lemma SeqNilAppend_2863(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_2864","instance":2864,"id":189535,"goal":"lemma SeqAppendAssoc_2864(zs: seq, ys: seq, u: seq)\n ensures (zs + ys) + u == zs + (ys + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_2865","instance":2865,"id":189536,"goal":"lemma SeqTakeDrop_2865(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_2866","instance":2866,"id":189537,"goal":"lemma SeqReverseLen_2866(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_2867","instance":2867,"id":189538,"goal":"lemma SeqReverseIdem_2867(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_2868","instance":2868,"id":189539,"goal":"lemma SeqMapLen_2868(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_2869","instance":2869,"id":189540,"goal":"lemma SeqFilterLe_2869(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_2870","instance":2870,"id":189541,"goal":"lemma SeqMemberAppend_2870(zs: seq, ys: seq)\n ensures x in zs + ys <==> x in zs || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_2871","instance":2871,"id":189542,"goal":"lemma SeqAppendLen_2871(zs: seq, xs: seq)\n ensures |zs + xs| == |zs| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_2872","instance":2872,"id":189543,"goal":"lemma SeqAppendNil_2872(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_2873","instance":2873,"id":189544,"goal":"lemma SeqNilAppend_2873(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_2874","instance":2874,"id":189545,"goal":"lemma SeqAppendAssoc_2874(ys: seq, u: seq, xs: seq)\n ensures (ys + u) + xs == ys + (u + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_2875","instance":2875,"id":189546,"goal":"lemma SeqTakeDrop_2875(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_2876","instance":2876,"id":189547,"goal":"lemma SeqReverseLen_2876(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_2877","instance":2877,"id":189548,"goal":"lemma SeqReverseIdem_2877(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_2878","instance":2878,"id":189549,"goal":"lemma SeqMapLen_2878(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_2879","instance":2879,"id":189550,"goal":"lemma SeqFilterLe_2879(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_2880","instance":2880,"id":189551,"goal":"lemma SeqMemberAppend_2880(t: seq, ys: seq)\n ensures x in t + ys <==> x in t || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_2881","instance":2881,"id":189552,"goal":"lemma SeqAppendLen_2881(u: seq, s: seq)\n ensures |u + s| == |u| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_2882","instance":2882,"id":189553,"goal":"lemma SeqAppendNil_2882(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_2883","instance":2883,"id":189554,"goal":"lemma SeqNilAppend_2883(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_2884","instance":2884,"id":189555,"goal":"lemma SeqAppendAssoc_2884(ys: seq, xs: seq, zs: seq)\n ensures (ys + xs) + zs == ys + (xs + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_2885","instance":2885,"id":189556,"goal":"lemma SeqTakeDrop_2885(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_2886","instance":2886,"id":189557,"goal":"lemma SeqReverseLen_2886(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_2887","instance":2887,"id":189558,"goal":"lemma SeqReverseIdem_2887(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_2888","instance":2888,"id":189559,"goal":"lemma SeqMapLen_2888(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_2889","instance":2889,"id":189560,"goal":"lemma SeqFilterLe_2889(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_2890","instance":2890,"id":189561,"goal":"lemma SeqMemberAppend_2890(ys: seq, s: seq)\n ensures x in ys + s <==> x in ys || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_2891","instance":2891,"id":189562,"goal":"lemma SeqAppendLen_2891(xs: seq, t: seq)\n ensures |xs + t| == |xs| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_2892","instance":2892,"id":189563,"goal":"lemma SeqAppendNil_2892(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_2893","instance":2893,"id":189564,"goal":"lemma SeqNilAppend_2893(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_2894","instance":2894,"id":189565,"goal":"lemma SeqAppendAssoc_2894(zs: seq, xs: seq, t: seq)\n ensures (zs + xs) + t == zs + (xs + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_2895","instance":2895,"id":189566,"goal":"lemma SeqTakeDrop_2895(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_2896","instance":2896,"id":189567,"goal":"lemma SeqReverseLen_2896(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_2897","instance":2897,"id":189568,"goal":"lemma SeqReverseIdem_2897(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_2898","instance":2898,"id":189569,"goal":"lemma SeqMapLen_2898(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_2899","instance":2899,"id":189570,"goal":"lemma SeqFilterLe_2899(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_2900","instance":2900,"id":189571,"goal":"lemma SeqMemberAppend_2900(s: seq, ys: seq)\n ensures x in s + ys <==> x in s || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_2901","instance":2901,"id":189572,"goal":"lemma SeqAppendLen_2901(u: seq, xs: seq)\n ensures |u + xs| == |u| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_2902","instance":2902,"id":189573,"goal":"lemma SeqAppendNil_2902(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_2903","instance":2903,"id":189574,"goal":"lemma SeqNilAppend_2903(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_2904","instance":2904,"id":189575,"goal":"lemma SeqAppendAssoc_2904(ys: seq, t: seq, zs: seq)\n ensures (ys + t) + zs == ys + (t + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_2905","instance":2905,"id":189576,"goal":"lemma SeqTakeDrop_2905(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_2906","instance":2906,"id":189577,"goal":"lemma SeqReverseLen_2906(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_2907","instance":2907,"id":189578,"goal":"lemma SeqReverseIdem_2907(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_2908","instance":2908,"id":189579,"goal":"lemma SeqMapLen_2908(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_2909","instance":2909,"id":189580,"goal":"lemma SeqFilterLe_2909(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_2910","instance":2910,"id":189581,"goal":"lemma SeqMemberAppend_2910(u: seq, xs: seq)\n ensures x in u + xs <==> x in u || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_2911","instance":2911,"id":189582,"goal":"lemma SeqAppendLen_2911(zs: seq, t: seq)\n ensures |zs + t| == |zs| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_2912","instance":2912,"id":189583,"goal":"lemma SeqAppendNil_2912(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_2913","instance":2913,"id":189584,"goal":"lemma SeqNilAppend_2913(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_2914","instance":2914,"id":189585,"goal":"lemma SeqAppendAssoc_2914(xs: seq, u: seq, zs: seq)\n ensures (xs + u) + zs == xs + (u + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_2915","instance":2915,"id":189586,"goal":"lemma SeqTakeDrop_2915(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_2916","instance":2916,"id":189587,"goal":"lemma SeqReverseLen_2916(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_2917","instance":2917,"id":189588,"goal":"lemma SeqReverseIdem_2917(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_2918","instance":2918,"id":189589,"goal":"lemma SeqMapLen_2918(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_2919","instance":2919,"id":189590,"goal":"lemma SeqFilterLe_2919(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_2920","instance":2920,"id":189591,"goal":"lemma SeqMemberAppend_2920(t: seq, u: seq)\n ensures x in t + u <==> x in t || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_2921","instance":2921,"id":189592,"goal":"lemma SeqAppendLen_2921(t: seq, zs: seq)\n ensures |t + zs| == |t| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_2922","instance":2922,"id":189593,"goal":"lemma SeqAppendNil_2922(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_2923","instance":2923,"id":189594,"goal":"lemma SeqNilAppend_2923(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_2924","instance":2924,"id":189595,"goal":"lemma SeqAppendAssoc_2924(t: seq, u: seq, s: seq)\n ensures (t + u) + s == t + (u + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_2925","instance":2925,"id":189596,"goal":"lemma SeqTakeDrop_2925(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_2926","instance":2926,"id":189597,"goal":"lemma SeqReverseLen_2926(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_2927","instance":2927,"id":189598,"goal":"lemma SeqReverseIdem_2927(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_2928","instance":2928,"id":189599,"goal":"lemma SeqMapLen_2928(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_2929","instance":2929,"id":189600,"goal":"lemma SeqFilterLe_2929(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_2930","instance":2930,"id":189601,"goal":"lemma SeqMemberAppend_2930(xs: seq, zs: seq)\n ensures x in xs + zs <==> x in xs || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_2931","instance":2931,"id":189602,"goal":"lemma SeqAppendLen_2931(u: seq, zs: seq)\n ensures |u + zs| == |u| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_2932","instance":2932,"id":189603,"goal":"lemma SeqAppendNil_2932(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_2933","instance":2933,"id":189604,"goal":"lemma SeqNilAppend_2933(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_2934","instance":2934,"id":189605,"goal":"lemma SeqAppendAssoc_2934(ys: seq, s: seq, t: seq)\n ensures (ys + s) + t == ys + (s + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_2935","instance":2935,"id":189606,"goal":"lemma SeqTakeDrop_2935(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_2936","instance":2936,"id":189607,"goal":"lemma SeqReverseLen_2936(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_2937","instance":2937,"id":189608,"goal":"lemma SeqReverseIdem_2937(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_2938","instance":2938,"id":189609,"goal":"lemma SeqMapLen_2938(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_2939","instance":2939,"id":189610,"goal":"lemma SeqFilterLe_2939(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_2940","instance":2940,"id":189611,"goal":"lemma SeqMemberAppend_2940(zs: seq, ys: seq)\n ensures x in zs + ys <==> x in zs || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_2941","instance":2941,"id":189612,"goal":"lemma SeqAppendLen_2941(s: seq, ys: seq)\n ensures |s + ys| == |s| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_2942","instance":2942,"id":189613,"goal":"lemma SeqAppendNil_2942(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_2943","instance":2943,"id":189614,"goal":"lemma SeqNilAppend_2943(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_2944","instance":2944,"id":189615,"goal":"lemma SeqAppendAssoc_2944(zs: seq, t: seq, s: seq)\n ensures (zs + t) + s == zs + (t + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_2945","instance":2945,"id":189616,"goal":"lemma SeqTakeDrop_2945(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_2946","instance":2946,"id":189617,"goal":"lemma SeqReverseLen_2946(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_2947","instance":2947,"id":189618,"goal":"lemma SeqReverseIdem_2947(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_2948","instance":2948,"id":189619,"goal":"lemma SeqMapLen_2948(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_2949","instance":2949,"id":189620,"goal":"lemma SeqFilterLe_2949(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_2950","instance":2950,"id":189621,"goal":"lemma SeqMemberAppend_2950(s: seq, t: seq)\n ensures x in s + t <==> x in s || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_2951","instance":2951,"id":189622,"goal":"lemma SeqAppendLen_2951(t: seq, s: seq)\n ensures |t + s| == |t| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_2952","instance":2952,"id":189623,"goal":"lemma SeqAppendNil_2952(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_2953","instance":2953,"id":189624,"goal":"lemma SeqNilAppend_2953(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_2954","instance":2954,"id":189625,"goal":"lemma SeqAppendAssoc_2954(s: seq, ys: seq, zs: seq)\n ensures (s + ys) + zs == s + (ys + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_2955","instance":2955,"id":189626,"goal":"lemma SeqTakeDrop_2955(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_2956","instance":2956,"id":189627,"goal":"lemma SeqReverseLen_2956(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_2957","instance":2957,"id":189628,"goal":"lemma SeqReverseIdem_2957(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_2958","instance":2958,"id":189629,"goal":"lemma SeqMapLen_2958(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_2959","instance":2959,"id":189630,"goal":"lemma SeqFilterLe_2959(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_2960","instance":2960,"id":189631,"goal":"lemma SeqMemberAppend_2960(u: seq, ys: seq)\n ensures x in u + ys <==> x in u || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_2961","instance":2961,"id":189632,"goal":"lemma SeqAppendLen_2961(s: seq, u: seq)\n ensures |s + u| == |s| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_2962","instance":2962,"id":189633,"goal":"lemma SeqAppendNil_2962(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_2963","instance":2963,"id":189634,"goal":"lemma SeqNilAppend_2963(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_2964","instance":2964,"id":189635,"goal":"lemma SeqAppendAssoc_2964(zs: seq, t: seq, ys: seq)\n ensures (zs + t) + ys == zs + (t + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_2965","instance":2965,"id":189636,"goal":"lemma SeqTakeDrop_2965(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_2966","instance":2966,"id":189637,"goal":"lemma SeqReverseLen_2966(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_2967","instance":2967,"id":189638,"goal":"lemma SeqReverseIdem_2967(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_2968","instance":2968,"id":189639,"goal":"lemma SeqMapLen_2968(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_2969","instance":2969,"id":189640,"goal":"lemma SeqFilterLe_2969(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_2970","instance":2970,"id":189641,"goal":"lemma SeqMemberAppend_2970(s: seq, xs: seq)\n ensures x in s + xs <==> x in s || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_2971","instance":2971,"id":189642,"goal":"lemma SeqAppendLen_2971(ys: seq, zs: seq)\n ensures |ys + zs| == |ys| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_2972","instance":2972,"id":189643,"goal":"lemma SeqAppendNil_2972(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_2973","instance":2973,"id":189644,"goal":"lemma SeqNilAppend_2973(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_2974","instance":2974,"id":189645,"goal":"lemma SeqAppendAssoc_2974(ys: seq, t: seq, xs: seq)\n ensures (ys + t) + xs == ys + (t + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_2975","instance":2975,"id":189646,"goal":"lemma SeqTakeDrop_2975(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_2976","instance":2976,"id":189647,"goal":"lemma SeqReverseLen_2976(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_2977","instance":2977,"id":189648,"goal":"lemma SeqReverseIdem_2977(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_2978","instance":2978,"id":189649,"goal":"lemma SeqMapLen_2978(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_2979","instance":2979,"id":189650,"goal":"lemma SeqFilterLe_2979(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_2980","instance":2980,"id":189651,"goal":"lemma SeqMemberAppend_2980(t: seq, ys: seq)\n ensures x in t + ys <==> x in t || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_2981","instance":2981,"id":189652,"goal":"lemma SeqAppendLen_2981(t: seq, zs: seq)\n ensures |t + zs| == |t| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_2982","instance":2982,"id":189653,"goal":"lemma SeqAppendNil_2982(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_2983","instance":2983,"id":189654,"goal":"lemma SeqNilAppend_2983(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_2984","instance":2984,"id":189655,"goal":"lemma SeqAppendAssoc_2984(xs: seq, t: seq, ys: seq)\n ensures (xs + t) + ys == xs + (t + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_2985","instance":2985,"id":189656,"goal":"lemma SeqTakeDrop_2985(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_2986","instance":2986,"id":189657,"goal":"lemma SeqReverseLen_2986(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_2987","instance":2987,"id":189658,"goal":"lemma SeqReverseIdem_2987(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_2988","instance":2988,"id":189659,"goal":"lemma SeqMapLen_2988(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_2989","instance":2989,"id":189660,"goal":"lemma SeqFilterLe_2989(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_2990","instance":2990,"id":189661,"goal":"lemma SeqMemberAppend_2990(zs: seq, t: seq)\n ensures x in zs + t <==> x in zs || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_2991","instance":2991,"id":189662,"goal":"lemma SeqAppendLen_2991(t: seq, xs: seq)\n ensures |t + xs| == |t| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_2992","instance":2992,"id":189663,"goal":"lemma SeqAppendNil_2992(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_2993","instance":2993,"id":189664,"goal":"lemma SeqNilAppend_2993(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_2994","instance":2994,"id":189665,"goal":"lemma SeqAppendAssoc_2994(s: seq, zs: seq, ys: seq)\n ensures (s + zs) + ys == s + (zs + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_2995","instance":2995,"id":189666,"goal":"lemma SeqTakeDrop_2995(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_2996","instance":2996,"id":189667,"goal":"lemma SeqReverseLen_2996(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_2997","instance":2997,"id":189668,"goal":"lemma SeqReverseIdem_2997(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_2998","instance":2998,"id":189669,"goal":"lemma SeqMapLen_2998(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_2999","instance":2999,"id":189670,"goal":"lemma SeqFilterLe_2999(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_3000","instance":3000,"id":189671,"goal":"lemma SeqMemberAppend_3000(xs: seq, t: seq)\n ensures x in xs + t <==> x in xs || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_3001","instance":3001,"id":189672,"goal":"lemma SeqAppendLen_3001(xs: seq, u: seq)\n ensures |xs + u| == |xs| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_3002","instance":3002,"id":189673,"goal":"lemma SeqAppendNil_3002(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_3003","instance":3003,"id":189674,"goal":"lemma SeqNilAppend_3003(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_3004","instance":3004,"id":189675,"goal":"lemma SeqAppendAssoc_3004(xs: seq, zs: seq, u: seq)\n ensures (xs + zs) + u == xs + (zs + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_3005","instance":3005,"id":189676,"goal":"lemma SeqTakeDrop_3005(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_3006","instance":3006,"id":189677,"goal":"lemma SeqReverseLen_3006(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_3007","instance":3007,"id":189678,"goal":"lemma SeqReverseIdem_3007(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_3008","instance":3008,"id":189679,"goal":"lemma SeqMapLen_3008(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_3009","instance":3009,"id":189680,"goal":"lemma SeqFilterLe_3009(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_3010","instance":3010,"id":189681,"goal":"lemma SeqMemberAppend_3010(u: seq, zs: seq)\n ensures x in u + zs <==> x in u || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_3011","instance":3011,"id":189682,"goal":"lemma SeqAppendLen_3011(s: seq, xs: seq)\n ensures |s + xs| == |s| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_3012","instance":3012,"id":189683,"goal":"lemma SeqAppendNil_3012(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_3013","instance":3013,"id":189684,"goal":"lemma SeqNilAppend_3013(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_3014","instance":3014,"id":189685,"goal":"lemma SeqAppendAssoc_3014(xs: seq, s: seq, u: seq)\n ensures (xs + s) + u == xs + (s + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_3015","instance":3015,"id":189686,"goal":"lemma SeqTakeDrop_3015(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_3016","instance":3016,"id":189687,"goal":"lemma SeqReverseLen_3016(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_3017","instance":3017,"id":189688,"goal":"lemma SeqReverseIdem_3017(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_3018","instance":3018,"id":189689,"goal":"lemma SeqMapLen_3018(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_3019","instance":3019,"id":189690,"goal":"lemma SeqFilterLe_3019(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_3020","instance":3020,"id":189691,"goal":"lemma SeqMemberAppend_3020(xs: seq, s: seq)\n ensures x in xs + s <==> x in xs || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_3021","instance":3021,"id":189692,"goal":"lemma SeqAppendLen_3021(xs: seq, zs: seq)\n ensures |xs + zs| == |xs| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_3022","instance":3022,"id":189693,"goal":"lemma SeqAppendNil_3022(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_3023","instance":3023,"id":189694,"goal":"lemma SeqNilAppend_3023(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_3024","instance":3024,"id":189695,"goal":"lemma SeqAppendAssoc_3024(ys: seq, u: seq, t: seq)\n ensures (ys + u) + t == ys + (u + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_3025","instance":3025,"id":189696,"goal":"lemma SeqTakeDrop_3025(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_3026","instance":3026,"id":189697,"goal":"lemma SeqReverseLen_3026(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_3027","instance":3027,"id":189698,"goal":"lemma SeqReverseIdem_3027(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_3028","instance":3028,"id":189699,"goal":"lemma SeqMapLen_3028(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_3029","instance":3029,"id":189700,"goal":"lemma SeqFilterLe_3029(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_3030","instance":3030,"id":189701,"goal":"lemma SeqMemberAppend_3030(s: seq, t: seq)\n ensures x in s + t <==> x in s || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_3031","instance":3031,"id":189702,"goal":"lemma SeqAppendLen_3031(ys: seq, t: seq)\n ensures |ys + t| == |ys| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_3032","instance":3032,"id":189703,"goal":"lemma SeqAppendNil_3032(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_3033","instance":3033,"id":189704,"goal":"lemma SeqNilAppend_3033(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_3034","instance":3034,"id":189705,"goal":"lemma SeqAppendAssoc_3034(u: seq, t: seq, xs: seq)\n ensures (u + t) + xs == u + (t + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_3035","instance":3035,"id":189706,"goal":"lemma SeqTakeDrop_3035(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_3036","instance":3036,"id":189707,"goal":"lemma SeqReverseLen_3036(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_3037","instance":3037,"id":189708,"goal":"lemma SeqReverseIdem_3037(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_3038","instance":3038,"id":189709,"goal":"lemma SeqMapLen_3038(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_3039","instance":3039,"id":189710,"goal":"lemma SeqFilterLe_3039(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_3040","instance":3040,"id":189711,"goal":"lemma SeqMemberAppend_3040(s: seq, t: seq)\n ensures x in s + t <==> x in s || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_3041","instance":3041,"id":189712,"goal":"lemma SeqAppendLen_3041(zs: seq, xs: seq)\n ensures |zs + xs| == |zs| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_3042","instance":3042,"id":189713,"goal":"lemma SeqAppendNil_3042(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_3043","instance":3043,"id":189714,"goal":"lemma SeqNilAppend_3043(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_3044","instance":3044,"id":189715,"goal":"lemma SeqAppendAssoc_3044(u: seq, zs: seq, s: seq)\n ensures (u + zs) + s == u + (zs + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_3045","instance":3045,"id":189716,"goal":"lemma SeqTakeDrop_3045(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_3046","instance":3046,"id":189717,"goal":"lemma SeqReverseLen_3046(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_3047","instance":3047,"id":189718,"goal":"lemma SeqReverseIdem_3047(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_3048","instance":3048,"id":189719,"goal":"lemma SeqMapLen_3048(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_3049","instance":3049,"id":189720,"goal":"lemma SeqFilterLe_3049(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_3050","instance":3050,"id":189721,"goal":"lemma SeqMemberAppend_3050(t: seq, xs: seq)\n ensures x in t + xs <==> x in t || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_3051","instance":3051,"id":189722,"goal":"lemma SeqAppendLen_3051(u: seq, t: seq)\n ensures |u + t| == |u| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_3052","instance":3052,"id":189723,"goal":"lemma SeqAppendNil_3052(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_3053","instance":3053,"id":189724,"goal":"lemma SeqNilAppend_3053(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_3054","instance":3054,"id":189725,"goal":"lemma SeqAppendAssoc_3054(xs: seq, s: seq, zs: seq)\n ensures (xs + s) + zs == xs + (s + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_3055","instance":3055,"id":189726,"goal":"lemma SeqTakeDrop_3055(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_3056","instance":3056,"id":189727,"goal":"lemma SeqReverseLen_3056(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_3057","instance":3057,"id":189728,"goal":"lemma SeqReverseIdem_3057(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_3058","instance":3058,"id":189729,"goal":"lemma SeqMapLen_3058(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_3059","instance":3059,"id":189730,"goal":"lemma SeqFilterLe_3059(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_3060","instance":3060,"id":189731,"goal":"lemma SeqMemberAppend_3060(zs: seq, t: seq)\n ensures x in zs + t <==> x in zs || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_3061","instance":3061,"id":189732,"goal":"lemma SeqAppendLen_3061(t: seq, s: seq)\n ensures |t + s| == |t| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_3062","instance":3062,"id":189733,"goal":"lemma SeqAppendNil_3062(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_3063","instance":3063,"id":189734,"goal":"lemma SeqNilAppend_3063(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_3064","instance":3064,"id":189735,"goal":"lemma SeqAppendAssoc_3064(xs: seq, zs: seq, t: seq)\n ensures (xs + zs) + t == xs + (zs + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_3065","instance":3065,"id":189736,"goal":"lemma SeqTakeDrop_3065(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_3066","instance":3066,"id":189737,"goal":"lemma SeqReverseLen_3066(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_3067","instance":3067,"id":189738,"goal":"lemma SeqReverseIdem_3067(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_3068","instance":3068,"id":189739,"goal":"lemma SeqMapLen_3068(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_3069","instance":3069,"id":189740,"goal":"lemma SeqFilterLe_3069(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_3070","instance":3070,"id":189741,"goal":"lemma SeqMemberAppend_3070(xs: seq, s: seq)\n ensures x in xs + s <==> x in xs || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_3071","instance":3071,"id":189742,"goal":"lemma SeqAppendLen_3071(u: seq, s: seq)\n ensures |u + s| == |u| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_3072","instance":3072,"id":189743,"goal":"lemma SeqAppendNil_3072(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_3073","instance":3073,"id":189744,"goal":"lemma SeqNilAppend_3073(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_3074","instance":3074,"id":189745,"goal":"lemma SeqAppendAssoc_3074(zs: seq, s: seq, t: seq)\n ensures (zs + s) + t == zs + (s + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_3075","instance":3075,"id":189746,"goal":"lemma SeqTakeDrop_3075(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_3076","instance":3076,"id":189747,"goal":"lemma SeqReverseLen_3076(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_3077","instance":3077,"id":189748,"goal":"lemma SeqReverseIdem_3077(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_3078","instance":3078,"id":189749,"goal":"lemma SeqMapLen_3078(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_3079","instance":3079,"id":189750,"goal":"lemma SeqFilterLe_3079(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_3080","instance":3080,"id":189751,"goal":"lemma SeqMemberAppend_3080(t: seq, ys: seq)\n ensures x in t + ys <==> x in t || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_3081","instance":3081,"id":189752,"goal":"lemma SeqAppendLen_3081(zs: seq, t: seq)\n ensures |zs + t| == |zs| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_3082","instance":3082,"id":189753,"goal":"lemma SeqAppendNil_3082(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_3083","instance":3083,"id":189754,"goal":"lemma SeqNilAppend_3083(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_3084","instance":3084,"id":189755,"goal":"lemma SeqAppendAssoc_3084(s: seq, xs: seq, ys: seq)\n ensures (s + xs) + ys == s + (xs + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_3085","instance":3085,"id":189756,"goal":"lemma SeqTakeDrop_3085(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_3086","instance":3086,"id":189757,"goal":"lemma SeqReverseLen_3086(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_3087","instance":3087,"id":189758,"goal":"lemma SeqReverseIdem_3087(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_3088","instance":3088,"id":189759,"goal":"lemma SeqMapLen_3088(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_3089","instance":3089,"id":189760,"goal":"lemma SeqFilterLe_3089(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_3090","instance":3090,"id":189761,"goal":"lemma SeqMemberAppend_3090(s: seq, u: seq)\n ensures x in s + u <==> x in s || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_3091","instance":3091,"id":189762,"goal":"lemma SeqAppendLen_3091(s: seq, ys: seq)\n ensures |s + ys| == |s| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_3092","instance":3092,"id":189763,"goal":"lemma SeqAppendNil_3092(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_3093","instance":3093,"id":189764,"goal":"lemma SeqNilAppend_3093(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_3094","instance":3094,"id":189765,"goal":"lemma SeqAppendAssoc_3094(u: seq, ys: seq, s: seq)\n ensures (u + ys) + s == u + (ys + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_3095","instance":3095,"id":189766,"goal":"lemma SeqTakeDrop_3095(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_3096","instance":3096,"id":189767,"goal":"lemma SeqReverseLen_3096(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_3097","instance":3097,"id":189768,"goal":"lemma SeqReverseIdem_3097(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_3098","instance":3098,"id":189769,"goal":"lemma SeqMapLen_3098(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_3099","instance":3099,"id":189770,"goal":"lemma SeqFilterLe_3099(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_3100","instance":3100,"id":189771,"goal":"lemma SeqMemberAppend_3100(u: seq, t: seq)\n ensures x in u + t <==> x in u || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_3101","instance":3101,"id":189772,"goal":"lemma SeqAppendLen_3101(ys: seq, xs: seq)\n ensures |ys + xs| == |ys| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_3102","instance":3102,"id":189773,"goal":"lemma SeqAppendNil_3102(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_3103","instance":3103,"id":189774,"goal":"lemma SeqNilAppend_3103(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_3104","instance":3104,"id":189775,"goal":"lemma SeqAppendAssoc_3104(zs: seq, t: seq, ys: seq)\n ensures (zs + t) + ys == zs + (t + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_3105","instance":3105,"id":189776,"goal":"lemma SeqTakeDrop_3105(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_3106","instance":3106,"id":189777,"goal":"lemma SeqReverseLen_3106(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_3107","instance":3107,"id":189778,"goal":"lemma SeqReverseIdem_3107(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_3108","instance":3108,"id":189779,"goal":"lemma SeqMapLen_3108(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_3109","instance":3109,"id":189780,"goal":"lemma SeqFilterLe_3109(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_3110","instance":3110,"id":189781,"goal":"lemma SeqMemberAppend_3110(xs: seq, u: seq)\n ensures x in xs + u <==> x in xs || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_3111","instance":3111,"id":189782,"goal":"lemma SeqAppendLen_3111(zs: seq, ys: seq)\n ensures |zs + ys| == |zs| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_3112","instance":3112,"id":189783,"goal":"lemma SeqAppendNil_3112(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_3113","instance":3113,"id":189784,"goal":"lemma SeqNilAppend_3113(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_3114","instance":3114,"id":189785,"goal":"lemma SeqAppendAssoc_3114(ys: seq, xs: seq, u: seq)\n ensures (ys + xs) + u == ys + (xs + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_3115","instance":3115,"id":189786,"goal":"lemma SeqTakeDrop_3115(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_3116","instance":3116,"id":189787,"goal":"lemma SeqReverseLen_3116(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_3117","instance":3117,"id":189788,"goal":"lemma SeqReverseIdem_3117(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_3118","instance":3118,"id":189789,"goal":"lemma SeqMapLen_3118(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_3119","instance":3119,"id":189790,"goal":"lemma SeqFilterLe_3119(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_3120","instance":3120,"id":189791,"goal":"lemma SeqMemberAppend_3120(s: seq, xs: seq)\n ensures x in s + xs <==> x in s || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_3121","instance":3121,"id":189792,"goal":"lemma SeqAppendLen_3121(xs: seq, u: seq)\n ensures |xs + u| == |xs| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_3122","instance":3122,"id":189793,"goal":"lemma SeqAppendNil_3122(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_3123","instance":3123,"id":189794,"goal":"lemma SeqNilAppend_3123(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_3124","instance":3124,"id":189795,"goal":"lemma SeqAppendAssoc_3124(ys: seq, zs: seq, t: seq)\n ensures (ys + zs) + t == ys + (zs + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_3125","instance":3125,"id":189796,"goal":"lemma SeqTakeDrop_3125(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_3126","instance":3126,"id":189797,"goal":"lemma SeqReverseLen_3126(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_3127","instance":3127,"id":189798,"goal":"lemma SeqReverseIdem_3127(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_3128","instance":3128,"id":189799,"goal":"lemma SeqMapLen_3128(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_3129","instance":3129,"id":189800,"goal":"lemma SeqFilterLe_3129(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_3130","instance":3130,"id":189801,"goal":"lemma SeqMemberAppend_3130(s: seq, ys: seq)\n ensures x in s + ys <==> x in s || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_3131","instance":3131,"id":189802,"goal":"lemma SeqAppendLen_3131(u: seq, t: seq)\n ensures |u + t| == |u| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_3132","instance":3132,"id":189803,"goal":"lemma SeqAppendNil_3132(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_3133","instance":3133,"id":189804,"goal":"lemma SeqNilAppend_3133(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_3134","instance":3134,"id":189805,"goal":"lemma SeqAppendAssoc_3134(ys: seq, t: seq, s: seq)\n ensures (ys + t) + s == ys + (t + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_3135","instance":3135,"id":189806,"goal":"lemma SeqTakeDrop_3135(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_3136","instance":3136,"id":189807,"goal":"lemma SeqReverseLen_3136(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_3137","instance":3137,"id":189808,"goal":"lemma SeqReverseIdem_3137(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_3138","instance":3138,"id":189809,"goal":"lemma SeqMapLen_3138(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_3139","instance":3139,"id":189810,"goal":"lemma SeqFilterLe_3139(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_3140","instance":3140,"id":189811,"goal":"lemma SeqMemberAppend_3140(ys: seq, s: seq)\n ensures x in ys + s <==> x in ys || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_3141","instance":3141,"id":189812,"goal":"lemma SeqAppendLen_3141(ys: seq, zs: seq)\n ensures |ys + zs| == |ys| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_3142","instance":3142,"id":189813,"goal":"lemma SeqAppendNil_3142(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_3143","instance":3143,"id":189814,"goal":"lemma SeqNilAppend_3143(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_3144","instance":3144,"id":189815,"goal":"lemma SeqAppendAssoc_3144(xs: seq, t: seq, ys: seq)\n ensures (xs + t) + ys == xs + (t + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_3145","instance":3145,"id":189816,"goal":"lemma SeqTakeDrop_3145(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_3146","instance":3146,"id":189817,"goal":"lemma SeqReverseLen_3146(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_3147","instance":3147,"id":189818,"goal":"lemma SeqReverseIdem_3147(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_3148","instance":3148,"id":189819,"goal":"lemma SeqMapLen_3148(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_3149","instance":3149,"id":189820,"goal":"lemma SeqFilterLe_3149(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_3150","instance":3150,"id":189821,"goal":"lemma SeqMemberAppend_3150(zs: seq, ys: seq)\n ensures x in zs + ys <==> x in zs || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_3151","instance":3151,"id":189822,"goal":"lemma SeqAppendLen_3151(xs: seq, s: seq)\n ensures |xs + s| == |xs| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_3152","instance":3152,"id":189823,"goal":"lemma SeqAppendNil_3152(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_3153","instance":3153,"id":189824,"goal":"lemma SeqNilAppend_3153(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_3154","instance":3154,"id":189825,"goal":"lemma SeqAppendAssoc_3154(ys: seq, s: seq, zs: seq)\n ensures (ys + s) + zs == ys + (s + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_3155","instance":3155,"id":189826,"goal":"lemma SeqTakeDrop_3155(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_3156","instance":3156,"id":189827,"goal":"lemma SeqReverseLen_3156(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_3157","instance":3157,"id":189828,"goal":"lemma SeqReverseIdem_3157(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_3158","instance":3158,"id":189829,"goal":"lemma SeqMapLen_3158(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_3159","instance":3159,"id":189830,"goal":"lemma SeqFilterLe_3159(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_3160","instance":3160,"id":189831,"goal":"lemma SeqMemberAppend_3160(ys: seq, zs: seq)\n ensures x in ys + zs <==> x in ys || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_3161","instance":3161,"id":189832,"goal":"lemma SeqAppendLen_3161(xs: seq, u: seq)\n ensures |xs + u| == |xs| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_3162","instance":3162,"id":189833,"goal":"lemma SeqAppendNil_3162(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_3163","instance":3163,"id":189834,"goal":"lemma SeqNilAppend_3163(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_3164","instance":3164,"id":189835,"goal":"lemma SeqAppendAssoc_3164(ys: seq, s: seq, xs: seq)\n ensures (ys + s) + xs == ys + (s + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_3165","instance":3165,"id":189836,"goal":"lemma SeqTakeDrop_3165(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_3166","instance":3166,"id":189837,"goal":"lemma SeqReverseLen_3166(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_3167","instance":3167,"id":189838,"goal":"lemma SeqReverseIdem_3167(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_3168","instance":3168,"id":189839,"goal":"lemma SeqMapLen_3168(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_3169","instance":3169,"id":189840,"goal":"lemma SeqFilterLe_3169(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_3170","instance":3170,"id":189841,"goal":"lemma SeqMemberAppend_3170(ys: seq, t: seq)\n ensures x in ys + t <==> x in ys || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_3171","instance":3171,"id":189842,"goal":"lemma SeqAppendLen_3171(xs: seq, zs: seq)\n ensures |xs + zs| == |xs| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_3172","instance":3172,"id":189843,"goal":"lemma SeqAppendNil_3172(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_3173","instance":3173,"id":189844,"goal":"lemma SeqNilAppend_3173(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_3174","instance":3174,"id":189845,"goal":"lemma SeqAppendAssoc_3174(zs: seq, ys: seq, xs: seq)\n ensures (zs + ys) + xs == zs + (ys + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_3175","instance":3175,"id":189846,"goal":"lemma SeqTakeDrop_3175(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_3176","instance":3176,"id":189847,"goal":"lemma SeqReverseLen_3176(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_3177","instance":3177,"id":189848,"goal":"lemma SeqReverseIdem_3177(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_3178","instance":3178,"id":189849,"goal":"lemma SeqMapLen_3178(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_3179","instance":3179,"id":189850,"goal":"lemma SeqFilterLe_3179(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_3180","instance":3180,"id":189851,"goal":"lemma SeqMemberAppend_3180(s: seq, zs: seq)\n ensures x in s + zs <==> x in s || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_3181","instance":3181,"id":189852,"goal":"lemma SeqAppendLen_3181(zs: seq, xs: seq)\n ensures |zs + xs| == |zs| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_3182","instance":3182,"id":189853,"goal":"lemma SeqAppendNil_3182(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_3183","instance":3183,"id":189854,"goal":"lemma SeqNilAppend_3183(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_3184","instance":3184,"id":189855,"goal":"lemma SeqAppendAssoc_3184(u: seq, s: seq, xs: seq)\n ensures (u + s) + xs == u + (s + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_3185","instance":3185,"id":189856,"goal":"lemma SeqTakeDrop_3185(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_3186","instance":3186,"id":189857,"goal":"lemma SeqReverseLen_3186(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_3187","instance":3187,"id":189858,"goal":"lemma SeqReverseIdem_3187(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_3188","instance":3188,"id":189859,"goal":"lemma SeqMapLen_3188(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_3189","instance":3189,"id":189860,"goal":"lemma SeqFilterLe_3189(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_3190","instance":3190,"id":189861,"goal":"lemma SeqMemberAppend_3190(zs: seq, ys: seq)\n ensures x in zs + ys <==> x in zs || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_3191","instance":3191,"id":189862,"goal":"lemma SeqAppendLen_3191(t: seq, s: seq)\n ensures |t + s| == |t| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_3192","instance":3192,"id":189863,"goal":"lemma SeqAppendNil_3192(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_3193","instance":3193,"id":189864,"goal":"lemma SeqNilAppend_3193(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_3194","instance":3194,"id":189865,"goal":"lemma SeqAppendAssoc_3194(xs: seq, u: seq, t: seq)\n ensures (xs + u) + t == xs + (u + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_3195","instance":3195,"id":189866,"goal":"lemma SeqTakeDrop_3195(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_3196","instance":3196,"id":189867,"goal":"lemma SeqReverseLen_3196(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_3197","instance":3197,"id":189868,"goal":"lemma SeqReverseIdem_3197(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_3198","instance":3198,"id":189869,"goal":"lemma SeqMapLen_3198(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_3199","instance":3199,"id":189870,"goal":"lemma SeqFilterLe_3199(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_3200","instance":3200,"id":189871,"goal":"lemma SeqMemberAppend_3200(ys: seq, s: seq)\n ensures x in ys + s <==> x in ys || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_3201","instance":3201,"id":189872,"goal":"lemma SeqAppendLen_3201(xs: seq, t: seq)\n ensures |xs + t| == |xs| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_3202","instance":3202,"id":189873,"goal":"lemma SeqAppendNil_3202(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_3203","instance":3203,"id":189874,"goal":"lemma SeqNilAppend_3203(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_3204","instance":3204,"id":189875,"goal":"lemma SeqAppendAssoc_3204(u: seq, s: seq, t: seq)\n ensures (u + s) + t == u + (s + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_3205","instance":3205,"id":189876,"goal":"lemma SeqTakeDrop_3205(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_3206","instance":3206,"id":189877,"goal":"lemma SeqReverseLen_3206(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_3207","instance":3207,"id":189878,"goal":"lemma SeqReverseIdem_3207(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_3208","instance":3208,"id":189879,"goal":"lemma SeqMapLen_3208(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_3209","instance":3209,"id":189880,"goal":"lemma SeqFilterLe_3209(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_3210","instance":3210,"id":189881,"goal":"lemma SeqMemberAppend_3210(zs: seq, xs: seq)\n ensures x in zs + xs <==> x in zs || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_3211","instance":3211,"id":189882,"goal":"lemma SeqAppendLen_3211(zs: seq, t: seq)\n ensures |zs + t| == |zs| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_3212","instance":3212,"id":189883,"goal":"lemma SeqAppendNil_3212(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_3213","instance":3213,"id":189884,"goal":"lemma SeqNilAppend_3213(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_3214","instance":3214,"id":189885,"goal":"lemma SeqAppendAssoc_3214(t: seq, s: seq, zs: seq)\n ensures (t + s) + zs == t + (s + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_3215","instance":3215,"id":189886,"goal":"lemma SeqTakeDrop_3215(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_3216","instance":3216,"id":189887,"goal":"lemma SeqReverseLen_3216(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_3217","instance":3217,"id":189888,"goal":"lemma SeqReverseIdem_3217(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_3218","instance":3218,"id":189889,"goal":"lemma SeqMapLen_3218(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_3219","instance":3219,"id":189890,"goal":"lemma SeqFilterLe_3219(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_3220","instance":3220,"id":189891,"goal":"lemma SeqMemberAppend_3220(xs: seq, ys: seq)\n ensures x in xs + ys <==> x in xs || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_3221","instance":3221,"id":189892,"goal":"lemma SeqAppendLen_3221(xs: seq, s: seq)\n ensures |xs + s| == |xs| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_3222","instance":3222,"id":189893,"goal":"lemma SeqAppendNil_3222(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_3223","instance":3223,"id":189894,"goal":"lemma SeqNilAppend_3223(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_3224","instance":3224,"id":189895,"goal":"lemma SeqAppendAssoc_3224(t: seq, zs: seq, ys: seq)\n ensures (t + zs) + ys == t + (zs + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_3225","instance":3225,"id":189896,"goal":"lemma SeqTakeDrop_3225(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_3226","instance":3226,"id":189897,"goal":"lemma SeqReverseLen_3226(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_3227","instance":3227,"id":189898,"goal":"lemma SeqReverseIdem_3227(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_3228","instance":3228,"id":189899,"goal":"lemma SeqMapLen_3228(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_3229","instance":3229,"id":189900,"goal":"lemma SeqFilterLe_3229(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_3230","instance":3230,"id":189901,"goal":"lemma SeqMemberAppend_3230(ys: seq, zs: seq)\n ensures x in ys + zs <==> x in ys || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_3231","instance":3231,"id":189902,"goal":"lemma SeqAppendLen_3231(ys: seq, s: seq)\n ensures |ys + s| == |ys| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_3232","instance":3232,"id":189903,"goal":"lemma SeqAppendNil_3232(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_3233","instance":3233,"id":189904,"goal":"lemma SeqNilAppend_3233(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_3234","instance":3234,"id":189905,"goal":"lemma SeqAppendAssoc_3234(xs: seq, u: seq, s: seq)\n ensures (xs + u) + s == xs + (u + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_3235","instance":3235,"id":189906,"goal":"lemma SeqTakeDrop_3235(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_3236","instance":3236,"id":189907,"goal":"lemma SeqReverseLen_3236(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_3237","instance":3237,"id":189908,"goal":"lemma SeqReverseIdem_3237(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_3238","instance":3238,"id":189909,"goal":"lemma SeqMapLen_3238(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_3239","instance":3239,"id":189910,"goal":"lemma SeqFilterLe_3239(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_3240","instance":3240,"id":189911,"goal":"lemma SeqMemberAppend_3240(t: seq, u: seq)\n ensures x in t + u <==> x in t || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_3241","instance":3241,"id":189912,"goal":"lemma SeqAppendLen_3241(ys: seq, u: seq)\n ensures |ys + u| == |ys| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_3242","instance":3242,"id":189913,"goal":"lemma SeqAppendNil_3242(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_3243","instance":3243,"id":189914,"goal":"lemma SeqNilAppend_3243(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_3244","instance":3244,"id":189915,"goal":"lemma SeqAppendAssoc_3244(xs: seq, t: seq, zs: seq)\n ensures (xs + t) + zs == xs + (t + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_3245","instance":3245,"id":189916,"goal":"lemma SeqTakeDrop_3245(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_3246","instance":3246,"id":189917,"goal":"lemma SeqReverseLen_3246(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_3247","instance":3247,"id":189918,"goal":"lemma SeqReverseIdem_3247(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_3248","instance":3248,"id":189919,"goal":"lemma SeqMapLen_3248(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_3249","instance":3249,"id":189920,"goal":"lemma SeqFilterLe_3249(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_3250","instance":3250,"id":189921,"goal":"lemma SeqMemberAppend_3250(zs: seq, u: seq)\n ensures x in zs + u <==> x in zs || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_3251","instance":3251,"id":189922,"goal":"lemma SeqAppendLen_3251(t: seq, zs: seq)\n ensures |t + zs| == |t| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_3252","instance":3252,"id":189923,"goal":"lemma SeqAppendNil_3252(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_3253","instance":3253,"id":189924,"goal":"lemma SeqNilAppend_3253(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_3254","instance":3254,"id":189925,"goal":"lemma SeqAppendAssoc_3254(s: seq, ys: seq, t: seq)\n ensures (s + ys) + t == s + (ys + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_3255","instance":3255,"id":189926,"goal":"lemma SeqTakeDrop_3255(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_3256","instance":3256,"id":189927,"goal":"lemma SeqReverseLen_3256(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_3257","instance":3257,"id":189928,"goal":"lemma SeqReverseIdem_3257(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_3258","instance":3258,"id":189929,"goal":"lemma SeqMapLen_3258(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_3259","instance":3259,"id":189930,"goal":"lemma SeqFilterLe_3259(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_3260","instance":3260,"id":189931,"goal":"lemma SeqMemberAppend_3260(s: seq, ys: seq)\n ensures x in s + ys <==> x in s || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_3261","instance":3261,"id":189932,"goal":"lemma SeqAppendLen_3261(t: seq, xs: seq)\n ensures |t + xs| == |t| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_3262","instance":3262,"id":189933,"goal":"lemma SeqAppendNil_3262(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_3263","instance":3263,"id":189934,"goal":"lemma SeqNilAppend_3263(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_3264","instance":3264,"id":189935,"goal":"lemma SeqAppendAssoc_3264(s: seq, zs: seq, u: seq)\n ensures (s + zs) + u == s + (zs + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_3265","instance":3265,"id":189936,"goal":"lemma SeqTakeDrop_3265(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_3266","instance":3266,"id":189937,"goal":"lemma SeqReverseLen_3266(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_3267","instance":3267,"id":189938,"goal":"lemma SeqReverseIdem_3267(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_3268","instance":3268,"id":189939,"goal":"lemma SeqMapLen_3268(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_3269","instance":3269,"id":189940,"goal":"lemma SeqFilterLe_3269(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_3270","instance":3270,"id":189941,"goal":"lemma SeqMemberAppend_3270(t: seq, s: seq)\n ensures x in t + s <==> x in t || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_3271","instance":3271,"id":189942,"goal":"lemma SeqAppendLen_3271(s: seq, ys: seq)\n ensures |s + ys| == |s| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_3272","instance":3272,"id":189943,"goal":"lemma SeqAppendNil_3272(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_3273","instance":3273,"id":189944,"goal":"lemma SeqNilAppend_3273(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_3274","instance":3274,"id":189945,"goal":"lemma SeqAppendAssoc_3274(xs: seq, u: seq, s: seq)\n ensures (xs + u) + s == xs + (u + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_3275","instance":3275,"id":189946,"goal":"lemma SeqTakeDrop_3275(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_3276","instance":3276,"id":189947,"goal":"lemma SeqReverseLen_3276(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_3277","instance":3277,"id":189948,"goal":"lemma SeqReverseIdem_3277(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_3278","instance":3278,"id":189949,"goal":"lemma SeqMapLen_3278(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_3279","instance":3279,"id":189950,"goal":"lemma SeqFilterLe_3279(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_3280","instance":3280,"id":189951,"goal":"lemma SeqMemberAppend_3280(t: seq, xs: seq)\n ensures x in t + xs <==> x in t || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_3281","instance":3281,"id":189952,"goal":"lemma SeqAppendLen_3281(xs: seq, zs: seq)\n ensures |xs + zs| == |xs| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_3282","instance":3282,"id":189953,"goal":"lemma SeqAppendNil_3282(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_3283","instance":3283,"id":189954,"goal":"lemma SeqNilAppend_3283(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_3284","instance":3284,"id":189955,"goal":"lemma SeqAppendAssoc_3284(u: seq, zs: seq, ys: seq)\n ensures (u + zs) + ys == u + (zs + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_3285","instance":3285,"id":189956,"goal":"lemma SeqTakeDrop_3285(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_3286","instance":3286,"id":189957,"goal":"lemma SeqReverseLen_3286(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_3287","instance":3287,"id":189958,"goal":"lemma SeqReverseIdem_3287(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_3288","instance":3288,"id":189959,"goal":"lemma SeqMapLen_3288(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_3289","instance":3289,"id":189960,"goal":"lemma SeqFilterLe_3289(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_3290","instance":3290,"id":189961,"goal":"lemma SeqMemberAppend_3290(u: seq, s: seq)\n ensures x in u + s <==> x in u || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_3291","instance":3291,"id":189962,"goal":"lemma SeqAppendLen_3291(u: seq, xs: seq)\n ensures |u + xs| == |u| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_3292","instance":3292,"id":189963,"goal":"lemma SeqAppendNil_3292(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_3293","instance":3293,"id":189964,"goal":"lemma SeqNilAppend_3293(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_3294","instance":3294,"id":189965,"goal":"lemma SeqAppendAssoc_3294(xs: seq, zs: seq, u: seq)\n ensures (xs + zs) + u == xs + (zs + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_3295","instance":3295,"id":189966,"goal":"lemma SeqTakeDrop_3295(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_3296","instance":3296,"id":189967,"goal":"lemma SeqReverseLen_3296(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_3297","instance":3297,"id":189968,"goal":"lemma SeqReverseIdem_3297(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_3298","instance":3298,"id":189969,"goal":"lemma SeqMapLen_3298(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_3299","instance":3299,"id":189970,"goal":"lemma SeqFilterLe_3299(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_3300","instance":3300,"id":189971,"goal":"lemma SeqMemberAppend_3300(u: seq, zs: seq)\n ensures x in u + zs <==> x in u || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_3301","instance":3301,"id":189972,"goal":"lemma SeqAppendLen_3301(xs: seq, s: seq)\n ensures |xs + s| == |xs| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_3302","instance":3302,"id":189973,"goal":"lemma SeqAppendNil_3302(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_3303","instance":3303,"id":189974,"goal":"lemma SeqNilAppend_3303(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_3304","instance":3304,"id":189975,"goal":"lemma SeqAppendAssoc_3304(s: seq, u: seq, t: seq)\n ensures (s + u) + t == s + (u + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_3305","instance":3305,"id":189976,"goal":"lemma SeqTakeDrop_3305(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_3306","instance":3306,"id":189977,"goal":"lemma SeqReverseLen_3306(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_3307","instance":3307,"id":189978,"goal":"lemma SeqReverseIdem_3307(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_3308","instance":3308,"id":189979,"goal":"lemma SeqMapLen_3308(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_3309","instance":3309,"id":189980,"goal":"lemma SeqFilterLe_3309(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_3310","instance":3310,"id":189981,"goal":"lemma SeqMemberAppend_3310(xs: seq, t: seq)\n ensures x in xs + t <==> x in xs || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_3311","instance":3311,"id":189982,"goal":"lemma SeqAppendLen_3311(zs: seq, t: seq)\n ensures |zs + t| == |zs| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_3312","instance":3312,"id":189983,"goal":"lemma SeqAppendNil_3312(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_3313","instance":3313,"id":189984,"goal":"lemma SeqNilAppend_3313(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_3314","instance":3314,"id":189985,"goal":"lemma SeqAppendAssoc_3314(ys: seq, u: seq, xs: seq)\n ensures (ys + u) + xs == ys + (u + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_3315","instance":3315,"id":189986,"goal":"lemma SeqTakeDrop_3315(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_3316","instance":3316,"id":189987,"goal":"lemma SeqReverseLen_3316(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_3317","instance":3317,"id":189988,"goal":"lemma SeqReverseIdem_3317(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_3318","instance":3318,"id":189989,"goal":"lemma SeqMapLen_3318(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_3319","instance":3319,"id":189990,"goal":"lemma SeqFilterLe_3319(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_3320","instance":3320,"id":189991,"goal":"lemma SeqMemberAppend_3320(u: seq, ys: seq)\n ensures x in u + ys <==> x in u || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_3321","instance":3321,"id":189992,"goal":"lemma SeqAppendLen_3321(u: seq, t: seq)\n ensures |u + t| == |u| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_3322","instance":3322,"id":189993,"goal":"lemma SeqAppendNil_3322(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_3323","instance":3323,"id":189994,"goal":"lemma SeqNilAppend_3323(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_3324","instance":3324,"id":189995,"goal":"lemma SeqAppendAssoc_3324(ys: seq, zs: seq, s: seq)\n ensures (ys + zs) + s == ys + (zs + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_3325","instance":3325,"id":189996,"goal":"lemma SeqTakeDrop_3325(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_3326","instance":3326,"id":189997,"goal":"lemma SeqReverseLen_3326(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_3327","instance":3327,"id":189998,"goal":"lemma SeqReverseIdem_3327(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_3328","instance":3328,"id":189999,"goal":"lemma SeqMapLen_3328(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_3329","instance":3329,"id":190000,"goal":"lemma SeqFilterLe_3329(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_3330","instance":3330,"id":190001,"goal":"lemma SeqMemberAppend_3330(xs: seq, s: seq)\n ensures x in xs + s <==> x in xs || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_3331","instance":3331,"id":190002,"goal":"lemma SeqAppendLen_3331(ys: seq, s: seq)\n ensures |ys + s| == |ys| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_3332","instance":3332,"id":190003,"goal":"lemma SeqAppendNil_3332(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_3333","instance":3333,"id":190004,"goal":"lemma SeqNilAppend_3333(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_3334","instance":3334,"id":190005,"goal":"lemma SeqAppendAssoc_3334(t: seq, ys: seq, u: seq)\n ensures (t + ys) + u == t + (ys + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_3335","instance":3335,"id":190006,"goal":"lemma SeqTakeDrop_3335(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_3336","instance":3336,"id":190007,"goal":"lemma SeqReverseLen_3336(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_3337","instance":3337,"id":190008,"goal":"lemma SeqReverseIdem_3337(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_3338","instance":3338,"id":190009,"goal":"lemma SeqMapLen_3338(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_3339","instance":3339,"id":190010,"goal":"lemma SeqFilterLe_3339(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_3340","instance":3340,"id":190011,"goal":"lemma SeqMemberAppend_3340(zs: seq, xs: seq)\n ensures x in zs + xs <==> x in zs || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_3341","instance":3341,"id":190012,"goal":"lemma SeqAppendLen_3341(s: seq, ys: seq)\n ensures |s + ys| == |s| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_3342","instance":3342,"id":190013,"goal":"lemma SeqAppendNil_3342(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_3343","instance":3343,"id":190014,"goal":"lemma SeqNilAppend_3343(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_3344","instance":3344,"id":190015,"goal":"lemma SeqAppendAssoc_3344(s: seq, zs: seq, xs: seq)\n ensures (s + zs) + xs == s + (zs + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_3345","instance":3345,"id":190016,"goal":"lemma SeqTakeDrop_3345(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_3346","instance":3346,"id":190017,"goal":"lemma SeqReverseLen_3346(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_3347","instance":3347,"id":190018,"goal":"lemma SeqReverseIdem_3347(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_3348","instance":3348,"id":190019,"goal":"lemma SeqMapLen_3348(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_3349","instance":3349,"id":190020,"goal":"lemma SeqFilterLe_3349(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_3350","instance":3350,"id":190021,"goal":"lemma SeqMemberAppend_3350(s: seq, zs: seq)\n ensures x in s + zs <==> x in s || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_3351","instance":3351,"id":190022,"goal":"lemma SeqAppendLen_3351(u: seq, s: seq)\n ensures |u + s| == |u| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_3352","instance":3352,"id":190023,"goal":"lemma SeqAppendNil_3352(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_3353","instance":3353,"id":190024,"goal":"lemma SeqNilAppend_3353(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_3354","instance":3354,"id":190025,"goal":"lemma SeqAppendAssoc_3354(t: seq, s: seq, ys: seq)\n ensures (t + s) + ys == t + (s + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_3355","instance":3355,"id":190026,"goal":"lemma SeqTakeDrop_3355(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_3356","instance":3356,"id":190027,"goal":"lemma SeqReverseLen_3356(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_3357","instance":3357,"id":190028,"goal":"lemma SeqReverseIdem_3357(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_3358","instance":3358,"id":190029,"goal":"lemma SeqMapLen_3358(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_3359","instance":3359,"id":190030,"goal":"lemma SeqFilterLe_3359(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_3360","instance":3360,"id":190031,"goal":"lemma SeqMemberAppend_3360(s: seq, zs: seq)\n ensures x in s + zs <==> x in s || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_3361","instance":3361,"id":190032,"goal":"lemma SeqAppendLen_3361(ys: seq, u: seq)\n ensures |ys + u| == |ys| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_3362","instance":3362,"id":190033,"goal":"lemma SeqAppendNil_3362(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_3363","instance":3363,"id":190034,"goal":"lemma SeqNilAppend_3363(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_3364","instance":3364,"id":190035,"goal":"lemma SeqAppendAssoc_3364(t: seq, ys: seq, zs: seq)\n ensures (t + ys) + zs == t + (ys + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_3365","instance":3365,"id":190036,"goal":"lemma SeqTakeDrop_3365(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_3366","instance":3366,"id":190037,"goal":"lemma SeqReverseLen_3366(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_3367","instance":3367,"id":190038,"goal":"lemma SeqReverseIdem_3367(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_3368","instance":3368,"id":190039,"goal":"lemma SeqMapLen_3368(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_3369","instance":3369,"id":190040,"goal":"lemma SeqFilterLe_3369(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_3370","instance":3370,"id":190041,"goal":"lemma SeqMemberAppend_3370(xs: seq, ys: seq)\n ensures x in xs + ys <==> x in xs || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_3371","instance":3371,"id":190042,"goal":"lemma SeqAppendLen_3371(t: seq, s: seq)\n ensures |t + s| == |t| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_3372","instance":3372,"id":190043,"goal":"lemma SeqAppendNil_3372(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_3373","instance":3373,"id":190044,"goal":"lemma SeqNilAppend_3373(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_3374","instance":3374,"id":190045,"goal":"lemma SeqAppendAssoc_3374(xs: seq, s: seq, u: seq)\n ensures (xs + s) + u == xs + (s + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_3375","instance":3375,"id":190046,"goal":"lemma SeqTakeDrop_3375(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_3376","instance":3376,"id":190047,"goal":"lemma SeqReverseLen_3376(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_3377","instance":3377,"id":190048,"goal":"lemma SeqReverseIdem_3377(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_3378","instance":3378,"id":190049,"goal":"lemma SeqMapLen_3378(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_3379","instance":3379,"id":190050,"goal":"lemma SeqFilterLe_3379(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_3380","instance":3380,"id":190051,"goal":"lemma SeqMemberAppend_3380(s: seq, ys: seq)\n ensures x in s + ys <==> x in s || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_3381","instance":3381,"id":190052,"goal":"lemma SeqAppendLen_3381(ys: seq, t: seq)\n ensures |ys + t| == |ys| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_3382","instance":3382,"id":190053,"goal":"lemma SeqAppendNil_3382(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_3383","instance":3383,"id":190054,"goal":"lemma SeqNilAppend_3383(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_3384","instance":3384,"id":190055,"goal":"lemma SeqAppendAssoc_3384(ys: seq, s: seq, t: seq)\n ensures (ys + s) + t == ys + (s + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_3385","instance":3385,"id":190056,"goal":"lemma SeqTakeDrop_3385(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_3386","instance":3386,"id":190057,"goal":"lemma SeqReverseLen_3386(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_3387","instance":3387,"id":190058,"goal":"lemma SeqReverseIdem_3387(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_3388","instance":3388,"id":190059,"goal":"lemma SeqMapLen_3388(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_3389","instance":3389,"id":190060,"goal":"lemma SeqFilterLe_3389(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_3390","instance":3390,"id":190061,"goal":"lemma SeqMemberAppend_3390(u: seq, ys: seq)\n ensures x in u + ys <==> x in u || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_3391","instance":3391,"id":190062,"goal":"lemma SeqAppendLen_3391(s: seq, zs: seq)\n ensures |s + zs| == |s| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_3392","instance":3392,"id":190063,"goal":"lemma SeqAppendNil_3392(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_3393","instance":3393,"id":190064,"goal":"lemma SeqNilAppend_3393(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_3394","instance":3394,"id":190065,"goal":"lemma SeqAppendAssoc_3394(s: seq, u: seq, ys: seq)\n ensures (s + u) + ys == s + (u + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_3395","instance":3395,"id":190066,"goal":"lemma SeqTakeDrop_3395(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_3396","instance":3396,"id":190067,"goal":"lemma SeqReverseLen_3396(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_3397","instance":3397,"id":190068,"goal":"lemma SeqReverseIdem_3397(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_3398","instance":3398,"id":190069,"goal":"lemma SeqMapLen_3398(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_3399","instance":3399,"id":190070,"goal":"lemma SeqFilterLe_3399(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_3400","instance":3400,"id":190071,"goal":"lemma SeqMemberAppend_3400(u: seq, zs: seq)\n ensures x in u + zs <==> x in u || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_3401","instance":3401,"id":190072,"goal":"lemma SeqAppendLen_3401(ys: seq, s: seq)\n ensures |ys + s| == |ys| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_3402","instance":3402,"id":190073,"goal":"lemma SeqAppendNil_3402(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_3403","instance":3403,"id":190074,"goal":"lemma SeqNilAppend_3403(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_3404","instance":3404,"id":190075,"goal":"lemma SeqAppendAssoc_3404(ys: seq, zs: seq, s: seq)\n ensures (ys + zs) + s == ys + (zs + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_3405","instance":3405,"id":190076,"goal":"lemma SeqTakeDrop_3405(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_3406","instance":3406,"id":190077,"goal":"lemma SeqReverseLen_3406(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_3407","instance":3407,"id":190078,"goal":"lemma SeqReverseIdem_3407(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_3408","instance":3408,"id":190079,"goal":"lemma SeqMapLen_3408(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_3409","instance":3409,"id":190080,"goal":"lemma SeqFilterLe_3409(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_3410","instance":3410,"id":190081,"goal":"lemma SeqMemberAppend_3410(u: seq, ys: seq)\n ensures x in u + ys <==> x in u || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_3411","instance":3411,"id":190082,"goal":"lemma SeqAppendLen_3411(t: seq, zs: seq)\n ensures |t + zs| == |t| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_3412","instance":3412,"id":190083,"goal":"lemma SeqAppendNil_3412(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_3413","instance":3413,"id":190084,"goal":"lemma SeqNilAppend_3413(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_3414","instance":3414,"id":190085,"goal":"lemma SeqAppendAssoc_3414(s: seq, u: seq, xs: seq)\n ensures (s + u) + xs == s + (u + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_3415","instance":3415,"id":190086,"goal":"lemma SeqTakeDrop_3415(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_3416","instance":3416,"id":190087,"goal":"lemma SeqReverseLen_3416(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_3417","instance":3417,"id":190088,"goal":"lemma SeqReverseIdem_3417(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_3418","instance":3418,"id":190089,"goal":"lemma SeqMapLen_3418(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_3419","instance":3419,"id":190090,"goal":"lemma SeqFilterLe_3419(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_3420","instance":3420,"id":190091,"goal":"lemma SeqMemberAppend_3420(xs: seq, ys: seq)\n ensures x in xs + ys <==> x in xs || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_3421","instance":3421,"id":190092,"goal":"lemma SeqAppendLen_3421(t: seq, xs: seq)\n ensures |t + xs| == |t| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_3422","instance":3422,"id":190093,"goal":"lemma SeqAppendNil_3422(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_3423","instance":3423,"id":190094,"goal":"lemma SeqNilAppend_3423(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_3424","instance":3424,"id":190095,"goal":"lemma SeqAppendAssoc_3424(t: seq, s: seq, xs: seq)\n ensures (t + s) + xs == t + (s + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_3425","instance":3425,"id":190096,"goal":"lemma SeqTakeDrop_3425(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_3426","instance":3426,"id":190097,"goal":"lemma SeqReverseLen_3426(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_3427","instance":3427,"id":190098,"goal":"lemma SeqReverseIdem_3427(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_3428","instance":3428,"id":190099,"goal":"lemma SeqMapLen_3428(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_3429","instance":3429,"id":190100,"goal":"lemma SeqFilterLe_3429(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_3430","instance":3430,"id":190101,"goal":"lemma SeqMemberAppend_3430(t: seq, zs: seq)\n ensures x in t + zs <==> x in t || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_3431","instance":3431,"id":190102,"goal":"lemma SeqAppendLen_3431(t: seq, u: seq)\n ensures |t + u| == |t| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_3432","instance":3432,"id":190103,"goal":"lemma SeqAppendNil_3432(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_3433","instance":3433,"id":190104,"goal":"lemma SeqNilAppend_3433(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_3434","instance":3434,"id":190105,"goal":"lemma SeqAppendAssoc_3434(ys: seq, s: seq, t: seq)\n ensures (ys + s) + t == ys + (s + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_3435","instance":3435,"id":190106,"goal":"lemma SeqTakeDrop_3435(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_3436","instance":3436,"id":190107,"goal":"lemma SeqReverseLen_3436(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_3437","instance":3437,"id":190108,"goal":"lemma SeqReverseIdem_3437(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_3438","instance":3438,"id":190109,"goal":"lemma SeqMapLen_3438(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_3439","instance":3439,"id":190110,"goal":"lemma SeqFilterLe_3439(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_3440","instance":3440,"id":190111,"goal":"lemma SeqMemberAppend_3440(u: seq, zs: seq)\n ensures x in u + zs <==> x in u || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_3441","instance":3441,"id":190112,"goal":"lemma SeqAppendLen_3441(s: seq, ys: seq)\n ensures |s + ys| == |s| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_3442","instance":3442,"id":190113,"goal":"lemma SeqAppendNil_3442(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_3443","instance":3443,"id":190114,"goal":"lemma SeqNilAppend_3443(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_3444","instance":3444,"id":190115,"goal":"lemma SeqAppendAssoc_3444(ys: seq, u: seq, s: seq)\n ensures (ys + u) + s == ys + (u + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_3445","instance":3445,"id":190116,"goal":"lemma SeqTakeDrop_3445(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_3446","instance":3446,"id":190117,"goal":"lemma SeqReverseLen_3446(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_3447","instance":3447,"id":190118,"goal":"lemma SeqReverseIdem_3447(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_3448","instance":3448,"id":190119,"goal":"lemma SeqMapLen_3448(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_3449","instance":3449,"id":190120,"goal":"lemma SeqFilterLe_3449(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_3450","instance":3450,"id":190121,"goal":"lemma SeqMemberAppend_3450(ys: seq, u: seq)\n ensures x in ys + u <==> x in ys || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_3451","instance":3451,"id":190122,"goal":"lemma SeqAppendLen_3451(s: seq, u: seq)\n ensures |s + u| == |s| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_3452","instance":3452,"id":190123,"goal":"lemma SeqAppendNil_3452(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_3453","instance":3453,"id":190124,"goal":"lemma SeqNilAppend_3453(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_3454","instance":3454,"id":190125,"goal":"lemma SeqAppendAssoc_3454(ys: seq, xs: seq, u: seq)\n ensures (ys + xs) + u == ys + (xs + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_3455","instance":3455,"id":190126,"goal":"lemma SeqTakeDrop_3455(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_3456","instance":3456,"id":190127,"goal":"lemma SeqReverseLen_3456(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_3457","instance":3457,"id":190128,"goal":"lemma SeqReverseIdem_3457(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_3458","instance":3458,"id":190129,"goal":"lemma SeqMapLen_3458(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_3459","instance":3459,"id":190130,"goal":"lemma SeqFilterLe_3459(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_3460","instance":3460,"id":190131,"goal":"lemma SeqMemberAppend_3460(zs: seq, t: seq)\n ensures x in zs + t <==> x in zs || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_3461","instance":3461,"id":190132,"goal":"lemma SeqAppendLen_3461(xs: seq, ys: seq)\n ensures |xs + ys| == |xs| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_3462","instance":3462,"id":190133,"goal":"lemma SeqAppendNil_3462(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_3463","instance":3463,"id":190134,"goal":"lemma SeqNilAppend_3463(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_3464","instance":3464,"id":190135,"goal":"lemma SeqAppendAssoc_3464(s: seq, ys: seq, zs: seq)\n ensures (s + ys) + zs == s + (ys + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_3465","instance":3465,"id":190136,"goal":"lemma SeqTakeDrop_3465(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_3466","instance":3466,"id":190137,"goal":"lemma SeqReverseLen_3466(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_3467","instance":3467,"id":190138,"goal":"lemma SeqReverseIdem_3467(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_3468","instance":3468,"id":190139,"goal":"lemma SeqMapLen_3468(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_3469","instance":3469,"id":190140,"goal":"lemma SeqFilterLe_3469(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_3470","instance":3470,"id":190141,"goal":"lemma SeqMemberAppend_3470(u: seq, t: seq)\n ensures x in u + t <==> x in u || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_3471","instance":3471,"id":190142,"goal":"lemma SeqAppendLen_3471(ys: seq, xs: seq)\n ensures |ys + xs| == |ys| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_3472","instance":3472,"id":190143,"goal":"lemma SeqAppendNil_3472(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_3473","instance":3473,"id":190144,"goal":"lemma SeqNilAppend_3473(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_3474","instance":3474,"id":190145,"goal":"lemma SeqAppendAssoc_3474(u: seq, xs: seq, zs: seq)\n ensures (u + xs) + zs == u + (xs + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_3475","instance":3475,"id":190146,"goal":"lemma SeqTakeDrop_3475(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_3476","instance":3476,"id":190147,"goal":"lemma SeqReverseLen_3476(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_3477","instance":3477,"id":190148,"goal":"lemma SeqReverseIdem_3477(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_3478","instance":3478,"id":190149,"goal":"lemma SeqMapLen_3478(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_3479","instance":3479,"id":190150,"goal":"lemma SeqFilterLe_3479(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_3480","instance":3480,"id":190151,"goal":"lemma SeqMemberAppend_3480(u: seq, zs: seq)\n ensures x in u + zs <==> x in u || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_3481","instance":3481,"id":190152,"goal":"lemma SeqAppendLen_3481(u: seq, zs: seq)\n ensures |u + zs| == |u| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_3482","instance":3482,"id":190153,"goal":"lemma SeqAppendNil_3482(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_3483","instance":3483,"id":190154,"goal":"lemma SeqNilAppend_3483(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_3484","instance":3484,"id":190155,"goal":"lemma SeqAppendAssoc_3484(u: seq, zs: seq, xs: seq)\n ensures (u + zs) + xs == u + (zs + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_3485","instance":3485,"id":190156,"goal":"lemma SeqTakeDrop_3485(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_3486","instance":3486,"id":190157,"goal":"lemma SeqReverseLen_3486(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_3487","instance":3487,"id":190158,"goal":"lemma SeqReverseIdem_3487(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_3488","instance":3488,"id":190159,"goal":"lemma SeqMapLen_3488(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_3489","instance":3489,"id":190160,"goal":"lemma SeqFilterLe_3489(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_3490","instance":3490,"id":190161,"goal":"lemma SeqMemberAppend_3490(ys: seq, t: seq)\n ensures x in ys + t <==> x in ys || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_3491","instance":3491,"id":190162,"goal":"lemma SeqAppendLen_3491(ys: seq, u: seq)\n ensures |ys + u| == |ys| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_3492","instance":3492,"id":190163,"goal":"lemma SeqAppendNil_3492(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_3493","instance":3493,"id":190164,"goal":"lemma SeqNilAppend_3493(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_3494","instance":3494,"id":190165,"goal":"lemma SeqAppendAssoc_3494(zs: seq, t: seq, u: seq)\n ensures (zs + t) + u == zs + (t + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_3495","instance":3495,"id":190166,"goal":"lemma SeqTakeDrop_3495(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_3496","instance":3496,"id":190167,"goal":"lemma SeqReverseLen_3496(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_3497","instance":3497,"id":190168,"goal":"lemma SeqReverseIdem_3497(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_3498","instance":3498,"id":190169,"goal":"lemma SeqMapLen_3498(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_3499","instance":3499,"id":190170,"goal":"lemma SeqFilterLe_3499(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_3500","instance":3500,"id":190171,"goal":"lemma SeqMemberAppend_3500(t: seq, xs: seq)\n ensures x in t + xs <==> x in t || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_3501","instance":3501,"id":190172,"goal":"lemma SeqAppendLen_3501(ys: seq, zs: seq)\n ensures |ys + zs| == |ys| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_3502","instance":3502,"id":190173,"goal":"lemma SeqAppendNil_3502(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_3503","instance":3503,"id":190174,"goal":"lemma SeqNilAppend_3503(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_3504","instance":3504,"id":190175,"goal":"lemma SeqAppendAssoc_3504(t: seq, u: seq, zs: seq)\n ensures (t + u) + zs == t + (u + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_3505","instance":3505,"id":190176,"goal":"lemma SeqTakeDrop_3505(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_3506","instance":3506,"id":190177,"goal":"lemma SeqReverseLen_3506(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_3507","instance":3507,"id":190178,"goal":"lemma SeqReverseIdem_3507(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_3508","instance":3508,"id":190179,"goal":"lemma SeqMapLen_3508(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_3509","instance":3509,"id":190180,"goal":"lemma SeqFilterLe_3509(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_3510","instance":3510,"id":190181,"goal":"lemma SeqMemberAppend_3510(xs: seq, t: seq)\n ensures x in xs + t <==> x in xs || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_3511","instance":3511,"id":190182,"goal":"lemma SeqAppendLen_3511(ys: seq, u: seq)\n ensures |ys + u| == |ys| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_3512","instance":3512,"id":190183,"goal":"lemma SeqAppendNil_3512(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_3513","instance":3513,"id":190184,"goal":"lemma SeqNilAppend_3513(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_3514","instance":3514,"id":190185,"goal":"lemma SeqAppendAssoc_3514(u: seq, zs: seq, t: seq)\n ensures (u + zs) + t == u + (zs + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_3515","instance":3515,"id":190186,"goal":"lemma SeqTakeDrop_3515(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_3516","instance":3516,"id":190187,"goal":"lemma SeqReverseLen_3516(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_3517","instance":3517,"id":190188,"goal":"lemma SeqReverseIdem_3517(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_3518","instance":3518,"id":190189,"goal":"lemma SeqMapLen_3518(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_3519","instance":3519,"id":190190,"goal":"lemma SeqFilterLe_3519(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_3520","instance":3520,"id":190191,"goal":"lemma SeqMemberAppend_3520(t: seq, ys: seq)\n ensures x in t + ys <==> x in t || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_3521","instance":3521,"id":190192,"goal":"lemma SeqAppendLen_3521(t: seq, u: seq)\n ensures |t + u| == |t| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_3522","instance":3522,"id":190193,"goal":"lemma SeqAppendNil_3522(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_3523","instance":3523,"id":190194,"goal":"lemma SeqNilAppend_3523(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_3524","instance":3524,"id":190195,"goal":"lemma SeqAppendAssoc_3524(u: seq, ys: seq, zs: seq)\n ensures (u + ys) + zs == u + (ys + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_3525","instance":3525,"id":190196,"goal":"lemma SeqTakeDrop_3525(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_3526","instance":3526,"id":190197,"goal":"lemma SeqReverseLen_3526(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_3527","instance":3527,"id":190198,"goal":"lemma SeqReverseIdem_3527(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_3528","instance":3528,"id":190199,"goal":"lemma SeqMapLen_3528(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_3529","instance":3529,"id":190200,"goal":"lemma SeqFilterLe_3529(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_3530","instance":3530,"id":190201,"goal":"lemma SeqMemberAppend_3530(t: seq, ys: seq)\n ensures x in t + ys <==> x in t || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_3531","instance":3531,"id":190202,"goal":"lemma SeqAppendLen_3531(s: seq, t: seq)\n ensures |s + t| == |s| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_3532","instance":3532,"id":190203,"goal":"lemma SeqAppendNil_3532(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_3533","instance":3533,"id":190204,"goal":"lemma SeqNilAppend_3533(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_3534","instance":3534,"id":190205,"goal":"lemma SeqAppendAssoc_3534(t: seq, ys: seq, xs: seq)\n ensures (t + ys) + xs == t + (ys + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_3535","instance":3535,"id":190206,"goal":"lemma SeqTakeDrop_3535(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_3536","instance":3536,"id":190207,"goal":"lemma SeqReverseLen_3536(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_3537","instance":3537,"id":190208,"goal":"lemma SeqReverseIdem_3537(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_3538","instance":3538,"id":190209,"goal":"lemma SeqMapLen_3538(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_3539","instance":3539,"id":190210,"goal":"lemma SeqFilterLe_3539(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_3540","instance":3540,"id":190211,"goal":"lemma SeqMemberAppend_3540(zs: seq, xs: seq)\n ensures x in zs + xs <==> x in zs || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_3541","instance":3541,"id":190212,"goal":"lemma SeqAppendLen_3541(u: seq, zs: seq)\n ensures |u + zs| == |u| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_3542","instance":3542,"id":190213,"goal":"lemma SeqAppendNil_3542(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_3543","instance":3543,"id":190214,"goal":"lemma SeqNilAppend_3543(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_3544","instance":3544,"id":190215,"goal":"lemma SeqAppendAssoc_3544(s: seq, xs: seq, ys: seq)\n ensures (s + xs) + ys == s + (xs + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_3545","instance":3545,"id":190216,"goal":"lemma SeqTakeDrop_3545(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_3546","instance":3546,"id":190217,"goal":"lemma SeqReverseLen_3546(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_3547","instance":3547,"id":190218,"goal":"lemma SeqReverseIdem_3547(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_3548","instance":3548,"id":190219,"goal":"lemma SeqMapLen_3548(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_3549","instance":3549,"id":190220,"goal":"lemma SeqFilterLe_3549(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_3550","instance":3550,"id":190221,"goal":"lemma SeqMemberAppend_3550(xs: seq, s: seq)\n ensures x in xs + s <==> x in xs || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_3551","instance":3551,"id":190222,"goal":"lemma SeqAppendLen_3551(xs: seq, u: seq)\n ensures |xs + u| == |xs| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_3552","instance":3552,"id":190223,"goal":"lemma SeqAppendNil_3552(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_3553","instance":3553,"id":190224,"goal":"lemma SeqNilAppend_3553(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_3554","instance":3554,"id":190225,"goal":"lemma SeqAppendAssoc_3554(t: seq, u: seq, s: seq)\n ensures (t + u) + s == t + (u + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_3555","instance":3555,"id":190226,"goal":"lemma SeqTakeDrop_3555(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_3556","instance":3556,"id":190227,"goal":"lemma SeqReverseLen_3556(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_3557","instance":3557,"id":190228,"goal":"lemma SeqReverseIdem_3557(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_3558","instance":3558,"id":190229,"goal":"lemma SeqMapLen_3558(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_3559","instance":3559,"id":190230,"goal":"lemma SeqFilterLe_3559(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_3560","instance":3560,"id":190231,"goal":"lemma SeqMemberAppend_3560(xs: seq, u: seq)\n ensures x in xs + u <==> x in xs || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_3561","instance":3561,"id":190232,"goal":"lemma SeqAppendLen_3561(ys: seq, s: seq)\n ensures |ys + s| == |ys| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_3562","instance":3562,"id":190233,"goal":"lemma SeqAppendNil_3562(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_3563","instance":3563,"id":190234,"goal":"lemma SeqNilAppend_3563(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_3564","instance":3564,"id":190235,"goal":"lemma SeqAppendAssoc_3564(ys: seq, zs: seq, t: seq)\n ensures (ys + zs) + t == ys + (zs + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_3565","instance":3565,"id":190236,"goal":"lemma SeqTakeDrop_3565(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_3566","instance":3566,"id":190237,"goal":"lemma SeqReverseLen_3566(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_3567","instance":3567,"id":190238,"goal":"lemma SeqReverseIdem_3567(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_3568","instance":3568,"id":190239,"goal":"lemma SeqMapLen_3568(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_3569","instance":3569,"id":190240,"goal":"lemma SeqFilterLe_3569(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_3570","instance":3570,"id":190241,"goal":"lemma SeqMemberAppend_3570(xs: seq, ys: seq)\n ensures x in xs + ys <==> x in xs || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_3571","instance":3571,"id":190242,"goal":"lemma SeqAppendLen_3571(ys: seq, u: seq)\n ensures |ys + u| == |ys| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_3572","instance":3572,"id":190243,"goal":"lemma SeqAppendNil_3572(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_3573","instance":3573,"id":190244,"goal":"lemma SeqNilAppend_3573(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_3574","instance":3574,"id":190245,"goal":"lemma SeqAppendAssoc_3574(u: seq, zs: seq, s: seq)\n ensures (u + zs) + s == u + (zs + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_3575","instance":3575,"id":190246,"goal":"lemma SeqTakeDrop_3575(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_3576","instance":3576,"id":190247,"goal":"lemma SeqReverseLen_3576(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_3577","instance":3577,"id":190248,"goal":"lemma SeqReverseIdem_3577(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_3578","instance":3578,"id":190249,"goal":"lemma SeqMapLen_3578(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_3579","instance":3579,"id":190250,"goal":"lemma SeqFilterLe_3579(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_3580","instance":3580,"id":190251,"goal":"lemma SeqMemberAppend_3580(t: seq, ys: seq)\n ensures x in t + ys <==> x in t || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_3581","instance":3581,"id":190252,"goal":"lemma SeqAppendLen_3581(u: seq, s: seq)\n ensures |u + s| == |u| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_3582","instance":3582,"id":190253,"goal":"lemma SeqAppendNil_3582(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_3583","instance":3583,"id":190254,"goal":"lemma SeqNilAppend_3583(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_3584","instance":3584,"id":190255,"goal":"lemma SeqAppendAssoc_3584(t: seq, xs: seq, u: seq)\n ensures (t + xs) + u == t + (xs + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_3585","instance":3585,"id":190256,"goal":"lemma SeqTakeDrop_3585(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_3586","instance":3586,"id":190257,"goal":"lemma SeqReverseLen_3586(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_3587","instance":3587,"id":190258,"goal":"lemma SeqReverseIdem_3587(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_3588","instance":3588,"id":190259,"goal":"lemma SeqMapLen_3588(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_3589","instance":3589,"id":190260,"goal":"lemma SeqFilterLe_3589(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_3590","instance":3590,"id":190261,"goal":"lemma SeqMemberAppend_3590(u: seq, xs: seq)\n ensures x in u + xs <==> x in u || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_3591","instance":3591,"id":190262,"goal":"lemma SeqAppendLen_3591(ys: seq, t: seq)\n ensures |ys + t| == |ys| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_3592","instance":3592,"id":190263,"goal":"lemma SeqAppendNil_3592(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_3593","instance":3593,"id":190264,"goal":"lemma SeqNilAppend_3593(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_3594","instance":3594,"id":190265,"goal":"lemma SeqAppendAssoc_3594(s: seq, t: seq, ys: seq)\n ensures (s + t) + ys == s + (t + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_3595","instance":3595,"id":190266,"goal":"lemma SeqTakeDrop_3595(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_3596","instance":3596,"id":190267,"goal":"lemma SeqReverseLen_3596(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_3597","instance":3597,"id":190268,"goal":"lemma SeqReverseIdem_3597(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_3598","instance":3598,"id":190269,"goal":"lemma SeqMapLen_3598(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_3599","instance":3599,"id":190270,"goal":"lemma SeqFilterLe_3599(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_3600","instance":3600,"id":190271,"goal":"lemma SeqMemberAppend_3600(t: seq, zs: seq)\n ensures x in t + zs <==> x in t || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_3601","instance":3601,"id":190272,"goal":"lemma SeqAppendLen_3601(xs: seq, zs: seq)\n ensures |xs + zs| == |xs| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_3602","instance":3602,"id":190273,"goal":"lemma SeqAppendNil_3602(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_3603","instance":3603,"id":190274,"goal":"lemma SeqNilAppend_3603(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_3604","instance":3604,"id":190275,"goal":"lemma SeqAppendAssoc_3604(t: seq, zs: seq, u: seq)\n ensures (t + zs) + u == t + (zs + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_3605","instance":3605,"id":190276,"goal":"lemma SeqTakeDrop_3605(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_3606","instance":3606,"id":190277,"goal":"lemma SeqReverseLen_3606(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_3607","instance":3607,"id":190278,"goal":"lemma SeqReverseIdem_3607(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_3608","instance":3608,"id":190279,"goal":"lemma SeqMapLen_3608(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_3609","instance":3609,"id":190280,"goal":"lemma SeqFilterLe_3609(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_3610","instance":3610,"id":190281,"goal":"lemma SeqMemberAppend_3610(ys: seq, s: seq)\n ensures x in ys + s <==> x in ys || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_3611","instance":3611,"id":190282,"goal":"lemma SeqAppendLen_3611(s: seq, u: seq)\n ensures |s + u| == |s| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_3612","instance":3612,"id":190283,"goal":"lemma SeqAppendNil_3612(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_3613","instance":3613,"id":190284,"goal":"lemma SeqNilAppend_3613(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_3614","instance":3614,"id":190285,"goal":"lemma SeqAppendAssoc_3614(s: seq, xs: seq, u: seq)\n ensures (s + xs) + u == s + (xs + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_3615","instance":3615,"id":190286,"goal":"lemma SeqTakeDrop_3615(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_3616","instance":3616,"id":190287,"goal":"lemma SeqReverseLen_3616(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_3617","instance":3617,"id":190288,"goal":"lemma SeqReverseIdem_3617(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_3618","instance":3618,"id":190289,"goal":"lemma SeqMapLen_3618(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_3619","instance":3619,"id":190290,"goal":"lemma SeqFilterLe_3619(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_3620","instance":3620,"id":190291,"goal":"lemma SeqMemberAppend_3620(xs: seq, t: seq)\n ensures x in xs + t <==> x in xs || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_3621","instance":3621,"id":190292,"goal":"lemma SeqAppendLen_3621(ys: seq, u: seq)\n ensures |ys + u| == |ys| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_3622","instance":3622,"id":190293,"goal":"lemma SeqAppendNil_3622(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_3623","instance":3623,"id":190294,"goal":"lemma SeqNilAppend_3623(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_3624","instance":3624,"id":190295,"goal":"lemma SeqAppendAssoc_3624(zs: seq, s: seq, u: seq)\n ensures (zs + s) + u == zs + (s + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_3625","instance":3625,"id":190296,"goal":"lemma SeqTakeDrop_3625(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_3626","instance":3626,"id":190297,"goal":"lemma SeqReverseLen_3626(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_3627","instance":3627,"id":190298,"goal":"lemma SeqReverseIdem_3627(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_3628","instance":3628,"id":190299,"goal":"lemma SeqMapLen_3628(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_3629","instance":3629,"id":190300,"goal":"lemma SeqFilterLe_3629(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_3630","instance":3630,"id":190301,"goal":"lemma SeqMemberAppend_3630(t: seq, u: seq)\n ensures x in t + u <==> x in t || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_3631","instance":3631,"id":190302,"goal":"lemma SeqAppendLen_3631(t: seq, zs: seq)\n ensures |t + zs| == |t| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_3632","instance":3632,"id":190303,"goal":"lemma SeqAppendNil_3632(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_3633","instance":3633,"id":190304,"goal":"lemma SeqNilAppend_3633(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_3634","instance":3634,"id":190305,"goal":"lemma SeqAppendAssoc_3634(zs: seq, ys: seq, s: seq)\n ensures (zs + ys) + s == zs + (ys + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_3635","instance":3635,"id":190306,"goal":"lemma SeqTakeDrop_3635(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_3636","instance":3636,"id":190307,"goal":"lemma SeqReverseLen_3636(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_3637","instance":3637,"id":190308,"goal":"lemma SeqReverseIdem_3637(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_3638","instance":3638,"id":190309,"goal":"lemma SeqMapLen_3638(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_3639","instance":3639,"id":190310,"goal":"lemma SeqFilterLe_3639(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_3640","instance":3640,"id":190311,"goal":"lemma SeqMemberAppend_3640(u: seq, zs: seq)\n ensures x in u + zs <==> x in u || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_3641","instance":3641,"id":190312,"goal":"lemma SeqAppendLen_3641(s: seq, zs: seq)\n ensures |s + zs| == |s| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_3642","instance":3642,"id":190313,"goal":"lemma SeqAppendNil_3642(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_3643","instance":3643,"id":190314,"goal":"lemma SeqNilAppend_3643(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_3644","instance":3644,"id":190315,"goal":"lemma SeqAppendAssoc_3644(s: seq, u: seq, xs: seq)\n ensures (s + u) + xs == s + (u + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_3645","instance":3645,"id":190316,"goal":"lemma SeqTakeDrop_3645(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_3646","instance":3646,"id":190317,"goal":"lemma SeqReverseLen_3646(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_3647","instance":3647,"id":190318,"goal":"lemma SeqReverseIdem_3647(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_3648","instance":3648,"id":190319,"goal":"lemma SeqMapLen_3648(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_3649","instance":3649,"id":190320,"goal":"lemma SeqFilterLe_3649(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_3650","instance":3650,"id":190321,"goal":"lemma SeqMemberAppend_3650(t: seq, u: seq)\n ensures x in t + u <==> x in t || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_3651","instance":3651,"id":190322,"goal":"lemma SeqAppendLen_3651(s: seq, u: seq)\n ensures |s + u| == |s| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_3652","instance":3652,"id":190323,"goal":"lemma SeqAppendNil_3652(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_3653","instance":3653,"id":190324,"goal":"lemma SeqNilAppend_3653(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_3654","instance":3654,"id":190325,"goal":"lemma SeqAppendAssoc_3654(t: seq, u: seq, xs: seq)\n ensures (t + u) + xs == t + (u + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_3655","instance":3655,"id":190326,"goal":"lemma SeqTakeDrop_3655(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_3656","instance":3656,"id":190327,"goal":"lemma SeqReverseLen_3656(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_3657","instance":3657,"id":190328,"goal":"lemma SeqReverseIdem_3657(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_3658","instance":3658,"id":190329,"goal":"lemma SeqMapLen_3658(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_3659","instance":3659,"id":190330,"goal":"lemma SeqFilterLe_3659(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_3660","instance":3660,"id":190331,"goal":"lemma SeqMemberAppend_3660(xs: seq, t: seq)\n ensures x in xs + t <==> x in xs || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_3661","instance":3661,"id":190332,"goal":"lemma SeqAppendLen_3661(t: seq, ys: seq)\n ensures |t + ys| == |t| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_3662","instance":3662,"id":190333,"goal":"lemma SeqAppendNil_3662(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_3663","instance":3663,"id":190334,"goal":"lemma SeqNilAppend_3663(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_3664","instance":3664,"id":190335,"goal":"lemma SeqAppendAssoc_3664(ys: seq, xs: seq, zs: seq)\n ensures (ys + xs) + zs == ys + (xs + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_3665","instance":3665,"id":190336,"goal":"lemma SeqTakeDrop_3665(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_3666","instance":3666,"id":190337,"goal":"lemma SeqReverseLen_3666(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_3667","instance":3667,"id":190338,"goal":"lemma SeqReverseIdem_3667(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_3668","instance":3668,"id":190339,"goal":"lemma SeqMapLen_3668(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_3669","instance":3669,"id":190340,"goal":"lemma SeqFilterLe_3669(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_3670","instance":3670,"id":190341,"goal":"lemma SeqMemberAppend_3670(zs: seq, u: seq)\n ensures x in zs + u <==> x in zs || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_3671","instance":3671,"id":190342,"goal":"lemma SeqAppendLen_3671(ys: seq, s: seq)\n ensures |ys + s| == |ys| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_3672","instance":3672,"id":190343,"goal":"lemma SeqAppendNil_3672(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_3673","instance":3673,"id":190344,"goal":"lemma SeqNilAppend_3673(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_3674","instance":3674,"id":190345,"goal":"lemma SeqAppendAssoc_3674(xs: seq, ys: seq, zs: seq)\n ensures (xs + ys) + zs == xs + (ys + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_3675","instance":3675,"id":190346,"goal":"lemma SeqTakeDrop_3675(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_3676","instance":3676,"id":190347,"goal":"lemma SeqReverseLen_3676(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_3677","instance":3677,"id":190348,"goal":"lemma SeqReverseIdem_3677(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_3678","instance":3678,"id":190349,"goal":"lemma SeqMapLen_3678(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_3679","instance":3679,"id":190350,"goal":"lemma SeqFilterLe_3679(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_3680","instance":3680,"id":190351,"goal":"lemma SeqMemberAppend_3680(ys: seq, t: seq)\n ensures x in ys + t <==> x in ys || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_3681","instance":3681,"id":190352,"goal":"lemma SeqAppendLen_3681(xs: seq, s: seq)\n ensures |xs + s| == |xs| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_3682","instance":3682,"id":190353,"goal":"lemma SeqAppendNil_3682(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_3683","instance":3683,"id":190354,"goal":"lemma SeqNilAppend_3683(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_3684","instance":3684,"id":190355,"goal":"lemma SeqAppendAssoc_3684(s: seq, xs: seq, t: seq)\n ensures (s + xs) + t == s + (xs + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_3685","instance":3685,"id":190356,"goal":"lemma SeqTakeDrop_3685(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_3686","instance":3686,"id":190357,"goal":"lemma SeqReverseLen_3686(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_3687","instance":3687,"id":190358,"goal":"lemma SeqReverseIdem_3687(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_3688","instance":3688,"id":190359,"goal":"lemma SeqMapLen_3688(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_3689","instance":3689,"id":190360,"goal":"lemma SeqFilterLe_3689(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_3690","instance":3690,"id":190361,"goal":"lemma SeqMemberAppend_3690(s: seq, xs: seq)\n ensures x in s + xs <==> x in s || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_3691","instance":3691,"id":190362,"goal":"lemma SeqAppendLen_3691(zs: seq, ys: seq)\n ensures |zs + ys| == |zs| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_3692","instance":3692,"id":190363,"goal":"lemma SeqAppendNil_3692(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_3693","instance":3693,"id":190364,"goal":"lemma SeqNilAppend_3693(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_3694","instance":3694,"id":190365,"goal":"lemma SeqAppendAssoc_3694(zs: seq, ys: seq, s: seq)\n ensures (zs + ys) + s == zs + (ys + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_3695","instance":3695,"id":190366,"goal":"lemma SeqTakeDrop_3695(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_3696","instance":3696,"id":190367,"goal":"lemma SeqReverseLen_3696(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_3697","instance":3697,"id":190368,"goal":"lemma SeqReverseIdem_3697(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_3698","instance":3698,"id":190369,"goal":"lemma SeqMapLen_3698(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_3699","instance":3699,"id":190370,"goal":"lemma SeqFilterLe_3699(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_3700","instance":3700,"id":190371,"goal":"lemma SeqMemberAppend_3700(u: seq, s: seq)\n ensures x in u + s <==> x in u || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_3701","instance":3701,"id":190372,"goal":"lemma SeqAppendLen_3701(u: seq, ys: seq)\n ensures |u + ys| == |u| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_3702","instance":3702,"id":190373,"goal":"lemma SeqAppendNil_3702(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_3703","instance":3703,"id":190374,"goal":"lemma SeqNilAppend_3703(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_3704","instance":3704,"id":190375,"goal":"lemma SeqAppendAssoc_3704(u: seq, xs: seq, s: seq)\n ensures (u + xs) + s == u + (xs + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_3705","instance":3705,"id":190376,"goal":"lemma SeqTakeDrop_3705(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_3706","instance":3706,"id":190377,"goal":"lemma SeqReverseLen_3706(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_3707","instance":3707,"id":190378,"goal":"lemma SeqReverseIdem_3707(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_3708","instance":3708,"id":190379,"goal":"lemma SeqMapLen_3708(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_3709","instance":3709,"id":190380,"goal":"lemma SeqFilterLe_3709(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_3710","instance":3710,"id":190381,"goal":"lemma SeqMemberAppend_3710(ys: seq, t: seq)\n ensures x in ys + t <==> x in ys || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_3711","instance":3711,"id":190382,"goal":"lemma SeqAppendLen_3711(t: seq, xs: seq)\n ensures |t + xs| == |t| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_3712","instance":3712,"id":190383,"goal":"lemma SeqAppendNil_3712(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_3713","instance":3713,"id":190384,"goal":"lemma SeqNilAppend_3713(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_3714","instance":3714,"id":190385,"goal":"lemma SeqAppendAssoc_3714(ys: seq, xs: seq, zs: seq)\n ensures (ys + xs) + zs == ys + (xs + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_3715","instance":3715,"id":190386,"goal":"lemma SeqTakeDrop_3715(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_3716","instance":3716,"id":190387,"goal":"lemma SeqReverseLen_3716(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_3717","instance":3717,"id":190388,"goal":"lemma SeqReverseIdem_3717(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_3718","instance":3718,"id":190389,"goal":"lemma SeqMapLen_3718(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_3719","instance":3719,"id":190390,"goal":"lemma SeqFilterLe_3719(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_3720","instance":3720,"id":190391,"goal":"lemma SeqMemberAppend_3720(xs: seq, u: seq)\n ensures x in xs + u <==> x in xs || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_3721","instance":3721,"id":190392,"goal":"lemma SeqAppendLen_3721(s: seq, xs: seq)\n ensures |s + xs| == |s| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_3722","instance":3722,"id":190393,"goal":"lemma SeqAppendNil_3722(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_3723","instance":3723,"id":190394,"goal":"lemma SeqNilAppend_3723(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_3724","instance":3724,"id":190395,"goal":"lemma SeqAppendAssoc_3724(zs: seq, ys: seq, t: seq)\n ensures (zs + ys) + t == zs + (ys + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_3725","instance":3725,"id":190396,"goal":"lemma SeqTakeDrop_3725(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_3726","instance":3726,"id":190397,"goal":"lemma SeqReverseLen_3726(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_3727","instance":3727,"id":190398,"goal":"lemma SeqReverseIdem_3727(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_3728","instance":3728,"id":190399,"goal":"lemma SeqMapLen_3728(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_3729","instance":3729,"id":190400,"goal":"lemma SeqFilterLe_3729(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_3730","instance":3730,"id":190401,"goal":"lemma SeqMemberAppend_3730(ys: seq, xs: seq)\n ensures x in ys + xs <==> x in ys || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_3731","instance":3731,"id":190402,"goal":"lemma SeqAppendLen_3731(t: seq, xs: seq)\n ensures |t + xs| == |t| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_3732","instance":3732,"id":190403,"goal":"lemma SeqAppendNil_3732(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_3733","instance":3733,"id":190404,"goal":"lemma SeqNilAppend_3733(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_3734","instance":3734,"id":190405,"goal":"lemma SeqAppendAssoc_3734(zs: seq, xs: seq, t: seq)\n ensures (zs + xs) + t == zs + (xs + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_3735","instance":3735,"id":190406,"goal":"lemma SeqTakeDrop_3735(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_3736","instance":3736,"id":190407,"goal":"lemma SeqReverseLen_3736(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_3737","instance":3737,"id":190408,"goal":"lemma SeqReverseIdem_3737(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_3738","instance":3738,"id":190409,"goal":"lemma SeqMapLen_3738(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_3739","instance":3739,"id":190410,"goal":"lemma SeqFilterLe_3739(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_3740","instance":3740,"id":190411,"goal":"lemma SeqMemberAppend_3740(ys: seq, s: seq)\n ensures x in ys + s <==> x in ys || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_3741","instance":3741,"id":190412,"goal":"lemma SeqAppendLen_3741(zs: seq, xs: seq)\n ensures |zs + xs| == |zs| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_3742","instance":3742,"id":190413,"goal":"lemma SeqAppendNil_3742(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_3743","instance":3743,"id":190414,"goal":"lemma SeqNilAppend_3743(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_3744","instance":3744,"id":190415,"goal":"lemma SeqAppendAssoc_3744(ys: seq, u: seq, s: seq)\n ensures (ys + u) + s == ys + (u + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_3745","instance":3745,"id":190416,"goal":"lemma SeqTakeDrop_3745(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_3746","instance":3746,"id":190417,"goal":"lemma SeqReverseLen_3746(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_3747","instance":3747,"id":190418,"goal":"lemma SeqReverseIdem_3747(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_3748","instance":3748,"id":190419,"goal":"lemma SeqMapLen_3748(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_3749","instance":3749,"id":190420,"goal":"lemma SeqFilterLe_3749(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_3750","instance":3750,"id":190421,"goal":"lemma SeqMemberAppend_3750(s: seq, ys: seq)\n ensures x in s + ys <==> x in s || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_3751","instance":3751,"id":190422,"goal":"lemma SeqAppendLen_3751(zs: seq, s: seq)\n ensures |zs + s| == |zs| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_3752","instance":3752,"id":190423,"goal":"lemma SeqAppendNil_3752(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_3753","instance":3753,"id":190424,"goal":"lemma SeqNilAppend_3753(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_3754","instance":3754,"id":190425,"goal":"lemma SeqAppendAssoc_3754(s: seq, zs: seq, u: seq)\n ensures (s + zs) + u == s + (zs + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_3755","instance":3755,"id":190426,"goal":"lemma SeqTakeDrop_3755(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_3756","instance":3756,"id":190427,"goal":"lemma SeqReverseLen_3756(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_3757","instance":3757,"id":190428,"goal":"lemma SeqReverseIdem_3757(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_3758","instance":3758,"id":190429,"goal":"lemma SeqMapLen_3758(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_3759","instance":3759,"id":190430,"goal":"lemma SeqFilterLe_3759(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_3760","instance":3760,"id":190431,"goal":"lemma SeqMemberAppend_3760(s: seq, ys: seq)\n ensures x in s + ys <==> x in s || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_3761","instance":3761,"id":190432,"goal":"lemma SeqAppendLen_3761(zs: seq, u: seq)\n ensures |zs + u| == |zs| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_3762","instance":3762,"id":190433,"goal":"lemma SeqAppendNil_3762(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_3763","instance":3763,"id":190434,"goal":"lemma SeqNilAppend_3763(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_3764","instance":3764,"id":190435,"goal":"lemma SeqAppendAssoc_3764(ys: seq, s: seq, zs: seq)\n ensures (ys + s) + zs == ys + (s + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_3765","instance":3765,"id":190436,"goal":"lemma SeqTakeDrop_3765(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_3766","instance":3766,"id":190437,"goal":"lemma SeqReverseLen_3766(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_3767","instance":3767,"id":190438,"goal":"lemma SeqReverseIdem_3767(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_3768","instance":3768,"id":190439,"goal":"lemma SeqMapLen_3768(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_3769","instance":3769,"id":190440,"goal":"lemma SeqFilterLe_3769(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_3770","instance":3770,"id":190441,"goal":"lemma SeqMemberAppend_3770(u: seq, zs: seq)\n ensures x in u + zs <==> x in u || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_3771","instance":3771,"id":190442,"goal":"lemma SeqAppendLen_3771(xs: seq, s: seq)\n ensures |xs + s| == |xs| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_3772","instance":3772,"id":190443,"goal":"lemma SeqAppendNil_3772(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_3773","instance":3773,"id":190444,"goal":"lemma SeqNilAppend_3773(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_3774","instance":3774,"id":190445,"goal":"lemma SeqAppendAssoc_3774(zs: seq, ys: seq, s: seq)\n ensures (zs + ys) + s == zs + (ys + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_3775","instance":3775,"id":190446,"goal":"lemma SeqTakeDrop_3775(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_3776","instance":3776,"id":190447,"goal":"lemma SeqReverseLen_3776(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_3777","instance":3777,"id":190448,"goal":"lemma SeqReverseIdem_3777(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_3778","instance":3778,"id":190449,"goal":"lemma SeqMapLen_3778(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_3779","instance":3779,"id":190450,"goal":"lemma SeqFilterLe_3779(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_3780","instance":3780,"id":190451,"goal":"lemma SeqMemberAppend_3780(zs: seq, s: seq)\n ensures x in zs + s <==> x in zs || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_3781","instance":3781,"id":190452,"goal":"lemma SeqAppendLen_3781(ys: seq, zs: seq)\n ensures |ys + zs| == |ys| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_3782","instance":3782,"id":190453,"goal":"lemma SeqAppendNil_3782(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_3783","instance":3783,"id":190454,"goal":"lemma SeqNilAppend_3783(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_3784","instance":3784,"id":190455,"goal":"lemma SeqAppendAssoc_3784(u: seq, xs: seq, zs: seq)\n ensures (u + xs) + zs == u + (xs + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_3785","instance":3785,"id":190456,"goal":"lemma SeqTakeDrop_3785(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_3786","instance":3786,"id":190457,"goal":"lemma SeqReverseLen_3786(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_3787","instance":3787,"id":190458,"goal":"lemma SeqReverseIdem_3787(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_3788","instance":3788,"id":190459,"goal":"lemma SeqMapLen_3788(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_3789","instance":3789,"id":190460,"goal":"lemma SeqFilterLe_3789(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_3790","instance":3790,"id":190461,"goal":"lemma SeqMemberAppend_3790(zs: seq, ys: seq)\n ensures x in zs + ys <==> x in zs || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_3791","instance":3791,"id":190462,"goal":"lemma SeqAppendLen_3791(s: seq, ys: seq)\n ensures |s + ys| == |s| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_3792","instance":3792,"id":190463,"goal":"lemma SeqAppendNil_3792(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_3793","instance":3793,"id":190464,"goal":"lemma SeqNilAppend_3793(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_3794","instance":3794,"id":190465,"goal":"lemma SeqAppendAssoc_3794(zs: seq, s: seq, t: seq)\n ensures (zs + s) + t == zs + (s + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_3795","instance":3795,"id":190466,"goal":"lemma SeqTakeDrop_3795(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_3796","instance":3796,"id":190467,"goal":"lemma SeqReverseLen_3796(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_3797","instance":3797,"id":190468,"goal":"lemma SeqReverseIdem_3797(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_3798","instance":3798,"id":190469,"goal":"lemma SeqMapLen_3798(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_3799","instance":3799,"id":190470,"goal":"lemma SeqFilterLe_3799(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_3800","instance":3800,"id":190471,"goal":"lemma SeqMemberAppend_3800(s: seq, t: seq)\n ensures x in s + t <==> x in s || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_3801","instance":3801,"id":190472,"goal":"lemma SeqAppendLen_3801(t: seq, zs: seq)\n ensures |t + zs| == |t| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_3802","instance":3802,"id":190473,"goal":"lemma SeqAppendNil_3802(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_3803","instance":3803,"id":190474,"goal":"lemma SeqNilAppend_3803(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_3804","instance":3804,"id":190475,"goal":"lemma SeqAppendAssoc_3804(ys: seq, xs: seq, s: seq)\n ensures (ys + xs) + s == ys + (xs + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_3805","instance":3805,"id":190476,"goal":"lemma SeqTakeDrop_3805(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_3806","instance":3806,"id":190477,"goal":"lemma SeqReverseLen_3806(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_3807","instance":3807,"id":190478,"goal":"lemma SeqReverseIdem_3807(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_3808","instance":3808,"id":190479,"goal":"lemma SeqMapLen_3808(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_3809","instance":3809,"id":190480,"goal":"lemma SeqFilterLe_3809(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_3810","instance":3810,"id":190481,"goal":"lemma SeqMemberAppend_3810(xs: seq, u: seq)\n ensures x in xs + u <==> x in xs || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_3811","instance":3811,"id":190482,"goal":"lemma SeqAppendLen_3811(ys: seq, t: seq)\n ensures |ys + t| == |ys| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_3812","instance":3812,"id":190483,"goal":"lemma SeqAppendNil_3812(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_3813","instance":3813,"id":190484,"goal":"lemma SeqNilAppend_3813(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_3814","instance":3814,"id":190485,"goal":"lemma SeqAppendAssoc_3814(zs: seq, xs: seq, ys: seq)\n ensures (zs + xs) + ys == zs + (xs + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_3815","instance":3815,"id":190486,"goal":"lemma SeqTakeDrop_3815(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_3816","instance":3816,"id":190487,"goal":"lemma SeqReverseLen_3816(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_3817","instance":3817,"id":190488,"goal":"lemma SeqReverseIdem_3817(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_3818","instance":3818,"id":190489,"goal":"lemma SeqMapLen_3818(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_3819","instance":3819,"id":190490,"goal":"lemma SeqFilterLe_3819(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_3820","instance":3820,"id":190491,"goal":"lemma SeqMemberAppend_3820(u: seq, t: seq)\n ensures x in u + t <==> x in u || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_3821","instance":3821,"id":190492,"goal":"lemma SeqAppendLen_3821(t: seq, s: seq)\n ensures |t + s| == |t| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_3822","instance":3822,"id":190493,"goal":"lemma SeqAppendNil_3822(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_3823","instance":3823,"id":190494,"goal":"lemma SeqNilAppend_3823(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_3824","instance":3824,"id":190495,"goal":"lemma SeqAppendAssoc_3824(u: seq, s: seq, t: seq)\n ensures (u + s) + t == u + (s + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_3825","instance":3825,"id":190496,"goal":"lemma SeqTakeDrop_3825(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_3826","instance":3826,"id":190497,"goal":"lemma SeqReverseLen_3826(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_3827","instance":3827,"id":190498,"goal":"lemma SeqReverseIdem_3827(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_3828","instance":3828,"id":190499,"goal":"lemma SeqMapLen_3828(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_3829","instance":3829,"id":190500,"goal":"lemma SeqFilterLe_3829(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_3830","instance":3830,"id":190501,"goal":"lemma SeqMemberAppend_3830(s: seq, ys: seq)\n ensures x in s + ys <==> x in s || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_3831","instance":3831,"id":190502,"goal":"lemma SeqAppendLen_3831(s: seq, t: seq)\n ensures |s + t| == |s| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_3832","instance":3832,"id":190503,"goal":"lemma SeqAppendNil_3832(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_3833","instance":3833,"id":190504,"goal":"lemma SeqNilAppend_3833(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_3834","instance":3834,"id":190505,"goal":"lemma SeqAppendAssoc_3834(zs: seq, s: seq, t: seq)\n ensures (zs + s) + t == zs + (s + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_3835","instance":3835,"id":190506,"goal":"lemma SeqTakeDrop_3835(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_3836","instance":3836,"id":190507,"goal":"lemma SeqReverseLen_3836(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_3837","instance":3837,"id":190508,"goal":"lemma SeqReverseIdem_3837(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_3838","instance":3838,"id":190509,"goal":"lemma SeqMapLen_3838(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_3839","instance":3839,"id":190510,"goal":"lemma SeqFilterLe_3839(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_3840","instance":3840,"id":190511,"goal":"lemma SeqMemberAppend_3840(zs: seq, t: seq)\n ensures x in zs + t <==> x in zs || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_3841","instance":3841,"id":190512,"goal":"lemma SeqAppendLen_3841(ys: seq, zs: seq)\n ensures |ys + zs| == |ys| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_3842","instance":3842,"id":190513,"goal":"lemma SeqAppendNil_3842(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_3843","instance":3843,"id":190514,"goal":"lemma SeqNilAppend_3843(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_3844","instance":3844,"id":190515,"goal":"lemma SeqAppendAssoc_3844(s: seq, ys: seq, t: seq)\n ensures (s + ys) + t == s + (ys + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_3845","instance":3845,"id":190516,"goal":"lemma SeqTakeDrop_3845(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_3846","instance":3846,"id":190517,"goal":"lemma SeqReverseLen_3846(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_3847","instance":3847,"id":190518,"goal":"lemma SeqReverseIdem_3847(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_3848","instance":3848,"id":190519,"goal":"lemma SeqMapLen_3848(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_3849","instance":3849,"id":190520,"goal":"lemma SeqFilterLe_3849(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_3850","instance":3850,"id":190521,"goal":"lemma SeqMemberAppend_3850(u: seq, xs: seq)\n ensures x in u + xs <==> x in u || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_3851","instance":3851,"id":190522,"goal":"lemma SeqAppendLen_3851(u: seq, t: seq)\n ensures |u + t| == |u| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_3852","instance":3852,"id":190523,"goal":"lemma SeqAppendNil_3852(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_3853","instance":3853,"id":190524,"goal":"lemma SeqNilAppend_3853(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_3854","instance":3854,"id":190525,"goal":"lemma SeqAppendAssoc_3854(ys: seq, t: seq, xs: seq)\n ensures (ys + t) + xs == ys + (t + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_3855","instance":3855,"id":190526,"goal":"lemma SeqTakeDrop_3855(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_3856","instance":3856,"id":190527,"goal":"lemma SeqReverseLen_3856(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_3857","instance":3857,"id":190528,"goal":"lemma SeqReverseIdem_3857(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_3858","instance":3858,"id":190529,"goal":"lemma SeqMapLen_3858(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_3859","instance":3859,"id":190530,"goal":"lemma SeqFilterLe_3859(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_3860","instance":3860,"id":190531,"goal":"lemma SeqMemberAppend_3860(ys: seq, u: seq)\n ensures x in ys + u <==> x in ys || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_3861","instance":3861,"id":190532,"goal":"lemma SeqAppendLen_3861(ys: seq, xs: seq)\n ensures |ys + xs| == |ys| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_3862","instance":3862,"id":190533,"goal":"lemma SeqAppendNil_3862(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_3863","instance":3863,"id":190534,"goal":"lemma SeqNilAppend_3863(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_3864","instance":3864,"id":190535,"goal":"lemma SeqAppendAssoc_3864(xs: seq, t: seq, s: seq)\n ensures (xs + t) + s == xs + (t + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_3865","instance":3865,"id":190536,"goal":"lemma SeqTakeDrop_3865(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_3866","instance":3866,"id":190537,"goal":"lemma SeqReverseLen_3866(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_3867","instance":3867,"id":190538,"goal":"lemma SeqReverseIdem_3867(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_3868","instance":3868,"id":190539,"goal":"lemma SeqMapLen_3868(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_3869","instance":3869,"id":190540,"goal":"lemma SeqFilterLe_3869(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_3870","instance":3870,"id":190541,"goal":"lemma SeqMemberAppend_3870(ys: seq, s: seq)\n ensures x in ys + s <==> x in ys || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_3871","instance":3871,"id":190542,"goal":"lemma SeqAppendLen_3871(xs: seq, s: seq)\n ensures |xs + s| == |xs| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_3872","instance":3872,"id":190543,"goal":"lemma SeqAppendNil_3872(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_3873","instance":3873,"id":190544,"goal":"lemma SeqNilAppend_3873(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_3874","instance":3874,"id":190545,"goal":"lemma SeqAppendAssoc_3874(u: seq, xs: seq, s: seq)\n ensures (u + xs) + s == u + (xs + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_3875","instance":3875,"id":190546,"goal":"lemma SeqTakeDrop_3875(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_3876","instance":3876,"id":190547,"goal":"lemma SeqReverseLen_3876(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_3877","instance":3877,"id":190548,"goal":"lemma SeqReverseIdem_3877(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_3878","instance":3878,"id":190549,"goal":"lemma SeqMapLen_3878(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_3879","instance":3879,"id":190550,"goal":"lemma SeqFilterLe_3879(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_3880","instance":3880,"id":190551,"goal":"lemma SeqMemberAppend_3880(u: seq, xs: seq)\n ensures x in u + xs <==> x in u || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_3881","instance":3881,"id":190552,"goal":"lemma SeqAppendLen_3881(s: seq, t: seq)\n ensures |s + t| == |s| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_3882","instance":3882,"id":190553,"goal":"lemma SeqAppendNil_3882(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_3883","instance":3883,"id":190554,"goal":"lemma SeqNilAppend_3883(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_3884","instance":3884,"id":190555,"goal":"lemma SeqAppendAssoc_3884(zs: seq, xs: seq, s: seq)\n ensures (zs + xs) + s == zs + (xs + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_3885","instance":3885,"id":190556,"goal":"lemma SeqTakeDrop_3885(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_3886","instance":3886,"id":190557,"goal":"lemma SeqReverseLen_3886(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_3887","instance":3887,"id":190558,"goal":"lemma SeqReverseIdem_3887(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_3888","instance":3888,"id":190559,"goal":"lemma SeqMapLen_3888(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_3889","instance":3889,"id":190560,"goal":"lemma SeqFilterLe_3889(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_3890","instance":3890,"id":190561,"goal":"lemma SeqMemberAppend_3890(zs: seq, u: seq)\n ensures x in zs + u <==> x in zs || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_3891","instance":3891,"id":190562,"goal":"lemma SeqAppendLen_3891(zs: seq, s: seq)\n ensures |zs + s| == |zs| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_3892","instance":3892,"id":190563,"goal":"lemma SeqAppendNil_3892(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_3893","instance":3893,"id":190564,"goal":"lemma SeqNilAppend_3893(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_3894","instance":3894,"id":190565,"goal":"lemma SeqAppendAssoc_3894(ys: seq, xs: seq, s: seq)\n ensures (ys + xs) + s == ys + (xs + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_3895","instance":3895,"id":190566,"goal":"lemma SeqTakeDrop_3895(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_3896","instance":3896,"id":190567,"goal":"lemma SeqReverseLen_3896(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_3897","instance":3897,"id":190568,"goal":"lemma SeqReverseIdem_3897(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_3898","instance":3898,"id":190569,"goal":"lemma SeqMapLen_3898(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_3899","instance":3899,"id":190570,"goal":"lemma SeqFilterLe_3899(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_3900","instance":3900,"id":190571,"goal":"lemma SeqMemberAppend_3900(t: seq, ys: seq)\n ensures x in t + ys <==> x in t || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_3901","instance":3901,"id":190572,"goal":"lemma SeqAppendLen_3901(t: seq, xs: seq)\n ensures |t + xs| == |t| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_3902","instance":3902,"id":190573,"goal":"lemma SeqAppendNil_3902(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_3903","instance":3903,"id":190574,"goal":"lemma SeqNilAppend_3903(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_3904","instance":3904,"id":190575,"goal":"lemma SeqAppendAssoc_3904(xs: seq, t: seq, s: seq)\n ensures (xs + t) + s == xs + (t + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_3905","instance":3905,"id":190576,"goal":"lemma SeqTakeDrop_3905(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_3906","instance":3906,"id":190577,"goal":"lemma SeqReverseLen_3906(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_3907","instance":3907,"id":190578,"goal":"lemma SeqReverseIdem_3907(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_3908","instance":3908,"id":190579,"goal":"lemma SeqMapLen_3908(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_3909","instance":3909,"id":190580,"goal":"lemma SeqFilterLe_3909(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_3910","instance":3910,"id":190581,"goal":"lemma SeqMemberAppend_3910(t: seq, xs: seq)\n ensures x in t + xs <==> x in t || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_3911","instance":3911,"id":190582,"goal":"lemma SeqAppendLen_3911(s: seq, zs: seq)\n ensures |s + zs| == |s| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_3912","instance":3912,"id":190583,"goal":"lemma SeqAppendNil_3912(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_3913","instance":3913,"id":190584,"goal":"lemma SeqNilAppend_3913(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_3914","instance":3914,"id":190585,"goal":"lemma SeqAppendAssoc_3914(u: seq, s: seq, ys: seq)\n ensures (u + s) + ys == u + (s + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_3915","instance":3915,"id":190586,"goal":"lemma SeqTakeDrop_3915(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_3916","instance":3916,"id":190587,"goal":"lemma SeqReverseLen_3916(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_3917","instance":3917,"id":190588,"goal":"lemma SeqReverseIdem_3917(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_3918","instance":3918,"id":190589,"goal":"lemma SeqMapLen_3918(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_3919","instance":3919,"id":190590,"goal":"lemma SeqFilterLe_3919(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_3920","instance":3920,"id":190591,"goal":"lemma SeqMemberAppend_3920(xs: seq, s: seq)\n ensures x in xs + s <==> x in xs || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_3921","instance":3921,"id":190592,"goal":"lemma SeqAppendLen_3921(xs: seq, u: seq)\n ensures |xs + u| == |xs| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_3922","instance":3922,"id":190593,"goal":"lemma SeqAppendNil_3922(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_3923","instance":3923,"id":190594,"goal":"lemma SeqNilAppend_3923(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_3924","instance":3924,"id":190595,"goal":"lemma SeqAppendAssoc_3924(s: seq, u: seq, xs: seq)\n ensures (s + u) + xs == s + (u + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_3925","instance":3925,"id":190596,"goal":"lemma SeqTakeDrop_3925(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_3926","instance":3926,"id":190597,"goal":"lemma SeqReverseLen_3926(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_3927","instance":3927,"id":190598,"goal":"lemma SeqReverseIdem_3927(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_3928","instance":3928,"id":190599,"goal":"lemma SeqMapLen_3928(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_3929","instance":3929,"id":190600,"goal":"lemma SeqFilterLe_3929(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_3930","instance":3930,"id":190601,"goal":"lemma SeqMemberAppend_3930(t: seq, ys: seq)\n ensures x in t + ys <==> x in t || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_3931","instance":3931,"id":190602,"goal":"lemma SeqAppendLen_3931(zs: seq, u: seq)\n ensures |zs + u| == |zs| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_3932","instance":3932,"id":190603,"goal":"lemma SeqAppendNil_3932(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_3933","instance":3933,"id":190604,"goal":"lemma SeqNilAppend_3933(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_3934","instance":3934,"id":190605,"goal":"lemma SeqAppendAssoc_3934(t: seq, xs: seq, u: seq)\n ensures (t + xs) + u == t + (xs + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_3935","instance":3935,"id":190606,"goal":"lemma SeqTakeDrop_3935(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_3936","instance":3936,"id":190607,"goal":"lemma SeqReverseLen_3936(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_3937","instance":3937,"id":190608,"goal":"lemma SeqReverseIdem_3937(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_3938","instance":3938,"id":190609,"goal":"lemma SeqMapLen_3938(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_3939","instance":3939,"id":190610,"goal":"lemma SeqFilterLe_3939(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_3940","instance":3940,"id":190611,"goal":"lemma SeqMemberAppend_3940(t: seq, zs: seq)\n ensures x in t + zs <==> x in t || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_3941","instance":3941,"id":190612,"goal":"lemma SeqAppendLen_3941(u: seq, s: seq)\n ensures |u + s| == |u| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_3942","instance":3942,"id":190613,"goal":"lemma SeqAppendNil_3942(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_3943","instance":3943,"id":190614,"goal":"lemma SeqNilAppend_3943(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_3944","instance":3944,"id":190615,"goal":"lemma SeqAppendAssoc_3944(s: seq, t: seq, u: seq)\n ensures (s + t) + u == s + (t + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_3945","instance":3945,"id":190616,"goal":"lemma SeqTakeDrop_3945(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_3946","instance":3946,"id":190617,"goal":"lemma SeqReverseLen_3946(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_3947","instance":3947,"id":190618,"goal":"lemma SeqReverseIdem_3947(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_3948","instance":3948,"id":190619,"goal":"lemma SeqMapLen_3948(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_3949","instance":3949,"id":190620,"goal":"lemma SeqFilterLe_3949(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_3950","instance":3950,"id":190621,"goal":"lemma SeqMemberAppend_3950(u: seq, ys: seq)\n ensures x in u + ys <==> x in u || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_3951","instance":3951,"id":190622,"goal":"lemma SeqAppendLen_3951(u: seq, zs: seq)\n ensures |u + zs| == |u| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_3952","instance":3952,"id":190623,"goal":"lemma SeqAppendNil_3952(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_3953","instance":3953,"id":190624,"goal":"lemma SeqNilAppend_3953(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_3954","instance":3954,"id":190625,"goal":"lemma SeqAppendAssoc_3954(s: seq, xs: seq, u: seq)\n ensures (s + xs) + u == s + (xs + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_3955","instance":3955,"id":190626,"goal":"lemma SeqTakeDrop_3955(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_3956","instance":3956,"id":190627,"goal":"lemma SeqReverseLen_3956(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_3957","instance":3957,"id":190628,"goal":"lemma SeqReverseIdem_3957(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_3958","instance":3958,"id":190629,"goal":"lemma SeqMapLen_3958(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_3959","instance":3959,"id":190630,"goal":"lemma SeqFilterLe_3959(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_3960","instance":3960,"id":190631,"goal":"lemma SeqMemberAppend_3960(t: seq, s: seq)\n ensures x in t + s <==> x in t || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_3961","instance":3961,"id":190632,"goal":"lemma SeqAppendLen_3961(ys: seq, s: seq)\n ensures |ys + s| == |ys| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_3962","instance":3962,"id":190633,"goal":"lemma SeqAppendNil_3962(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_3963","instance":3963,"id":190634,"goal":"lemma SeqNilAppend_3963(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_3964","instance":3964,"id":190635,"goal":"lemma SeqAppendAssoc_3964(s: seq, xs: seq, zs: seq)\n ensures (s + xs) + zs == s + (xs + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_3965","instance":3965,"id":190636,"goal":"lemma SeqTakeDrop_3965(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_3966","instance":3966,"id":190637,"goal":"lemma SeqReverseLen_3966(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_3967","instance":3967,"id":190638,"goal":"lemma SeqReverseIdem_3967(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_3968","instance":3968,"id":190639,"goal":"lemma SeqMapLen_3968(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_3969","instance":3969,"id":190640,"goal":"lemma SeqFilterLe_3969(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_3970","instance":3970,"id":190641,"goal":"lemma SeqMemberAppend_3970(zs: seq, t: seq)\n ensures x in zs + t <==> x in zs || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_3971","instance":3971,"id":190642,"goal":"lemma SeqAppendLen_3971(zs: seq, xs: seq)\n ensures |zs + xs| == |zs| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_3972","instance":3972,"id":190643,"goal":"lemma SeqAppendNil_3972(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_3973","instance":3973,"id":190644,"goal":"lemma SeqNilAppend_3973(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_3974","instance":3974,"id":190645,"goal":"lemma SeqAppendAssoc_3974(t: seq, zs: seq, u: seq)\n ensures (t + zs) + u == t + (zs + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_3975","instance":3975,"id":190646,"goal":"lemma SeqTakeDrop_3975(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_3976","instance":3976,"id":190647,"goal":"lemma SeqReverseLen_3976(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_3977","instance":3977,"id":190648,"goal":"lemma SeqReverseIdem_3977(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_3978","instance":3978,"id":190649,"goal":"lemma SeqMapLen_3978(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_3979","instance":3979,"id":190650,"goal":"lemma SeqFilterLe_3979(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_3980","instance":3980,"id":190651,"goal":"lemma SeqMemberAppend_3980(s: seq, zs: seq)\n ensures x in s + zs <==> x in s || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_3981","instance":3981,"id":190652,"goal":"lemma SeqAppendLen_3981(zs: seq, ys: seq)\n ensures |zs + ys| == |zs| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_3982","instance":3982,"id":190653,"goal":"lemma SeqAppendNil_3982(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_3983","instance":3983,"id":190654,"goal":"lemma SeqNilAppend_3983(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_3984","instance":3984,"id":190655,"goal":"lemma SeqAppendAssoc_3984(t: seq, u: seq, xs: seq)\n ensures (t + u) + xs == t + (u + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_3985","instance":3985,"id":190656,"goal":"lemma SeqTakeDrop_3985(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_3986","instance":3986,"id":190657,"goal":"lemma SeqReverseLen_3986(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_3987","instance":3987,"id":190658,"goal":"lemma SeqReverseIdem_3987(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_3988","instance":3988,"id":190659,"goal":"lemma SeqMapLen_3988(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_3989","instance":3989,"id":190660,"goal":"lemma SeqFilterLe_3989(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_3990","instance":3990,"id":190661,"goal":"lemma SeqMemberAppend_3990(u: seq, xs: seq)\n ensures x in u + xs <==> x in u || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_3991","instance":3991,"id":190662,"goal":"lemma SeqAppendLen_3991(t: seq, xs: seq)\n ensures |t + xs| == |t| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_3992","instance":3992,"id":190663,"goal":"lemma SeqAppendNil_3992(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_3993","instance":3993,"id":190664,"goal":"lemma SeqNilAppend_3993(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_3994","instance":3994,"id":190665,"goal":"lemma SeqAppendAssoc_3994(ys: seq, t: seq, u: seq)\n ensures (ys + t) + u == ys + (t + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_3995","instance":3995,"id":190666,"goal":"lemma SeqTakeDrop_3995(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_3996","instance":3996,"id":190667,"goal":"lemma SeqReverseLen_3996(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_3997","instance":3997,"id":190668,"goal":"lemma SeqReverseIdem_3997(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_3998","instance":3998,"id":190669,"goal":"lemma SeqMapLen_3998(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_3999","instance":3999,"id":190670,"goal":"lemma SeqFilterLe_3999(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_4000","instance":4000,"id":190671,"goal":"lemma SeqMemberAppend_4000(xs: seq, t: seq)\n ensures x in xs + t <==> x in xs || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_4001","instance":4001,"id":190672,"goal":"lemma SeqAppendLen_4001(t: seq, s: seq)\n ensures |t + s| == |t| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_4002","instance":4002,"id":190673,"goal":"lemma SeqAppendNil_4002(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_4003","instance":4003,"id":190674,"goal":"lemma SeqNilAppend_4003(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_4004","instance":4004,"id":190675,"goal":"lemma SeqAppendAssoc_4004(u: seq, zs: seq, t: seq)\n ensures (u + zs) + t == u + (zs + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_4005","instance":4005,"id":190676,"goal":"lemma SeqTakeDrop_4005(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_4006","instance":4006,"id":190677,"goal":"lemma SeqReverseLen_4006(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_4007","instance":4007,"id":190678,"goal":"lemma SeqReverseIdem_4007(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_4008","instance":4008,"id":190679,"goal":"lemma SeqMapLen_4008(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_4009","instance":4009,"id":190680,"goal":"lemma SeqFilterLe_4009(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_4010","instance":4010,"id":190681,"goal":"lemma SeqMemberAppend_4010(xs: seq, ys: seq)\n ensures x in xs + ys <==> x in xs || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_4011","instance":4011,"id":190682,"goal":"lemma SeqAppendLen_4011(zs: seq, xs: seq)\n ensures |zs + xs| == |zs| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_4012","instance":4012,"id":190683,"goal":"lemma SeqAppendNil_4012(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_4013","instance":4013,"id":190684,"goal":"lemma SeqNilAppend_4013(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_4014","instance":4014,"id":190685,"goal":"lemma SeqAppendAssoc_4014(t: seq, zs: seq, s: seq)\n ensures (t + zs) + s == t + (zs + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_4015","instance":4015,"id":190686,"goal":"lemma SeqTakeDrop_4015(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_4016","instance":4016,"id":190687,"goal":"lemma SeqReverseLen_4016(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_4017","instance":4017,"id":190688,"goal":"lemma SeqReverseIdem_4017(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_4018","instance":4018,"id":190689,"goal":"lemma SeqMapLen_4018(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_4019","instance":4019,"id":190690,"goal":"lemma SeqFilterLe_4019(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_4020","instance":4020,"id":190691,"goal":"lemma SeqMemberAppend_4020(t: seq, u: seq)\n ensures x in t + u <==> x in t || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_4021","instance":4021,"id":190692,"goal":"lemma SeqAppendLen_4021(u: seq, ys: seq)\n ensures |u + ys| == |u| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_4022","instance":4022,"id":190693,"goal":"lemma SeqAppendNil_4022(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_4023","instance":4023,"id":190694,"goal":"lemma SeqNilAppend_4023(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_4024","instance":4024,"id":190695,"goal":"lemma SeqAppendAssoc_4024(zs: seq, xs: seq, ys: seq)\n ensures (zs + xs) + ys == zs + (xs + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_4025","instance":4025,"id":190696,"goal":"lemma SeqTakeDrop_4025(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_4026","instance":4026,"id":190697,"goal":"lemma SeqReverseLen_4026(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_4027","instance":4027,"id":190698,"goal":"lemma SeqReverseIdem_4027(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_4028","instance":4028,"id":190699,"goal":"lemma SeqMapLen_4028(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_4029","instance":4029,"id":190700,"goal":"lemma SeqFilterLe_4029(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_4030","instance":4030,"id":190701,"goal":"lemma SeqMemberAppend_4030(ys: seq, t: seq)\n ensures x in ys + t <==> x in ys || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_4031","instance":4031,"id":190702,"goal":"lemma SeqAppendLen_4031(u: seq, ys: seq)\n ensures |u + ys| == |u| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_4032","instance":4032,"id":190703,"goal":"lemma SeqAppendNil_4032(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_4033","instance":4033,"id":190704,"goal":"lemma SeqNilAppend_4033(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_4034","instance":4034,"id":190705,"goal":"lemma SeqAppendAssoc_4034(xs: seq, t: seq, ys: seq)\n ensures (xs + t) + ys == xs + (t + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_4035","instance":4035,"id":190706,"goal":"lemma SeqTakeDrop_4035(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_4036","instance":4036,"id":190707,"goal":"lemma SeqReverseLen_4036(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_4037","instance":4037,"id":190708,"goal":"lemma SeqReverseIdem_4037(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_4038","instance":4038,"id":190709,"goal":"lemma SeqMapLen_4038(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_4039","instance":4039,"id":190710,"goal":"lemma SeqFilterLe_4039(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_4040","instance":4040,"id":190711,"goal":"lemma SeqMemberAppend_4040(zs: seq, ys: seq)\n ensures x in zs + ys <==> x in zs || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_4041","instance":4041,"id":190712,"goal":"lemma SeqAppendLen_4041(t: seq, u: seq)\n ensures |t + u| == |t| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_4042","instance":4042,"id":190713,"goal":"lemma SeqAppendNil_4042(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_4043","instance":4043,"id":190714,"goal":"lemma SeqNilAppend_4043(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_4044","instance":4044,"id":190715,"goal":"lemma SeqAppendAssoc_4044(ys: seq, u: seq, zs: seq)\n ensures (ys + u) + zs == ys + (u + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_4045","instance":4045,"id":190716,"goal":"lemma SeqTakeDrop_4045(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_4046","instance":4046,"id":190717,"goal":"lemma SeqReverseLen_4046(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_4047","instance":4047,"id":190718,"goal":"lemma SeqReverseIdem_4047(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_4048","instance":4048,"id":190719,"goal":"lemma SeqMapLen_4048(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_4049","instance":4049,"id":190720,"goal":"lemma SeqFilterLe_4049(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_4050","instance":4050,"id":190721,"goal":"lemma SeqMemberAppend_4050(xs: seq, ys: seq)\n ensures x in xs + ys <==> x in xs || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_4051","instance":4051,"id":190722,"goal":"lemma SeqAppendLen_4051(s: seq, u: seq)\n ensures |s + u| == |s| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_4052","instance":4052,"id":190723,"goal":"lemma SeqAppendNil_4052(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_4053","instance":4053,"id":190724,"goal":"lemma SeqNilAppend_4053(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_4054","instance":4054,"id":190725,"goal":"lemma SeqAppendAssoc_4054(xs: seq, s: seq, zs: seq)\n ensures (xs + s) + zs == xs + (s + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_4055","instance":4055,"id":190726,"goal":"lemma SeqTakeDrop_4055(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_4056","instance":4056,"id":190727,"goal":"lemma SeqReverseLen_4056(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_4057","instance":4057,"id":190728,"goal":"lemma SeqReverseIdem_4057(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_4058","instance":4058,"id":190729,"goal":"lemma SeqMapLen_4058(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_4059","instance":4059,"id":190730,"goal":"lemma SeqFilterLe_4059(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_4060","instance":4060,"id":190731,"goal":"lemma SeqMemberAppend_4060(ys: seq, u: seq)\n ensures x in ys + u <==> x in ys || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_4061","instance":4061,"id":190732,"goal":"lemma SeqAppendLen_4061(t: seq, xs: seq)\n ensures |t + xs| == |t| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_4062","instance":4062,"id":190733,"goal":"lemma SeqAppendNil_4062(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_4063","instance":4063,"id":190734,"goal":"lemma SeqNilAppend_4063(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_4064","instance":4064,"id":190735,"goal":"lemma SeqAppendAssoc_4064(zs: seq, s: seq, ys: seq)\n ensures (zs + s) + ys == zs + (s + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_4065","instance":4065,"id":190736,"goal":"lemma SeqTakeDrop_4065(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_4066","instance":4066,"id":190737,"goal":"lemma SeqReverseLen_4066(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_4067","instance":4067,"id":190738,"goal":"lemma SeqReverseIdem_4067(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_4068","instance":4068,"id":190739,"goal":"lemma SeqMapLen_4068(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_4069","instance":4069,"id":190740,"goal":"lemma SeqFilterLe_4069(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_4070","instance":4070,"id":190741,"goal":"lemma SeqMemberAppend_4070(s: seq, zs: seq)\n ensures x in s + zs <==> x in s || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_4071","instance":4071,"id":190742,"goal":"lemma SeqAppendLen_4071(xs: seq, zs: seq)\n ensures |xs + zs| == |xs| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_4072","instance":4072,"id":190743,"goal":"lemma SeqAppendNil_4072(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_4073","instance":4073,"id":190744,"goal":"lemma SeqNilAppend_4073(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_4074","instance":4074,"id":190745,"goal":"lemma SeqAppendAssoc_4074(ys: seq, t: seq, xs: seq)\n ensures (ys + t) + xs == ys + (t + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_4075","instance":4075,"id":190746,"goal":"lemma SeqTakeDrop_4075(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_4076","instance":4076,"id":190747,"goal":"lemma SeqReverseLen_4076(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_4077","instance":4077,"id":190748,"goal":"lemma SeqReverseIdem_4077(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_4078","instance":4078,"id":190749,"goal":"lemma SeqMapLen_4078(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_4079","instance":4079,"id":190750,"goal":"lemma SeqFilterLe_4079(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_4080","instance":4080,"id":190751,"goal":"lemma SeqMemberAppend_4080(t: seq, u: seq)\n ensures x in t + u <==> x in t || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_4081","instance":4081,"id":190752,"goal":"lemma SeqAppendLen_4081(t: seq, ys: seq)\n ensures |t + ys| == |t| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_4082","instance":4082,"id":190753,"goal":"lemma SeqAppendNil_4082(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_4083","instance":4083,"id":190754,"goal":"lemma SeqNilAppend_4083(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_4084","instance":4084,"id":190755,"goal":"lemma SeqAppendAssoc_4084(s: seq, u: seq, xs: seq)\n ensures (s + u) + xs == s + (u + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_4085","instance":4085,"id":190756,"goal":"lemma SeqTakeDrop_4085(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_4086","instance":4086,"id":190757,"goal":"lemma SeqReverseLen_4086(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_4087","instance":4087,"id":190758,"goal":"lemma SeqReverseIdem_4087(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_4088","instance":4088,"id":190759,"goal":"lemma SeqMapLen_4088(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_4089","instance":4089,"id":190760,"goal":"lemma SeqFilterLe_4089(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_4090","instance":4090,"id":190761,"goal":"lemma SeqMemberAppend_4090(ys: seq, u: seq)\n ensures x in ys + u <==> x in ys || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_4091","instance":4091,"id":190762,"goal":"lemma SeqAppendLen_4091(s: seq, zs: seq)\n ensures |s + zs| == |s| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_4092","instance":4092,"id":190763,"goal":"lemma SeqAppendNil_4092(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_4093","instance":4093,"id":190764,"goal":"lemma SeqNilAppend_4093(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_4094","instance":4094,"id":190765,"goal":"lemma SeqAppendAssoc_4094(zs: seq, ys: seq, s: seq)\n ensures (zs + ys) + s == zs + (ys + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_4095","instance":4095,"id":190766,"goal":"lemma SeqTakeDrop_4095(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_4096","instance":4096,"id":190767,"goal":"lemma SeqReverseLen_4096(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_4097","instance":4097,"id":190768,"goal":"lemma SeqReverseIdem_4097(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_4098","instance":4098,"id":190769,"goal":"lemma SeqMapLen_4098(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_4099","instance":4099,"id":190770,"goal":"lemma SeqFilterLe_4099(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_4100","instance":4100,"id":190771,"goal":"lemma SeqMemberAppend_4100(s: seq, xs: seq)\n ensures x in s + xs <==> x in s || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_4101","instance":4101,"id":190772,"goal":"lemma SeqAppendLen_4101(t: seq, ys: seq)\n ensures |t + ys| == |t| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_4102","instance":4102,"id":190773,"goal":"lemma SeqAppendNil_4102(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_4103","instance":4103,"id":190774,"goal":"lemma SeqNilAppend_4103(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_4104","instance":4104,"id":190775,"goal":"lemma SeqAppendAssoc_4104(zs: seq, u: seq, t: seq)\n ensures (zs + u) + t == zs + (u + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_4105","instance":4105,"id":190776,"goal":"lemma SeqTakeDrop_4105(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_4106","instance":4106,"id":190777,"goal":"lemma SeqReverseLen_4106(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_4107","instance":4107,"id":190778,"goal":"lemma SeqReverseIdem_4107(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_4108","instance":4108,"id":190779,"goal":"lemma SeqMapLen_4108(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_4109","instance":4109,"id":190780,"goal":"lemma SeqFilterLe_4109(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_4110","instance":4110,"id":190781,"goal":"lemma SeqMemberAppend_4110(xs: seq, t: seq)\n ensures x in xs + t <==> x in xs || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_4111","instance":4111,"id":190782,"goal":"lemma SeqAppendLen_4111(s: seq, t: seq)\n ensures |s + t| == |s| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_4112","instance":4112,"id":190783,"goal":"lemma SeqAppendNil_4112(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_4113","instance":4113,"id":190784,"goal":"lemma SeqNilAppend_4113(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_4114","instance":4114,"id":190785,"goal":"lemma SeqAppendAssoc_4114(ys: seq, u: seq, s: seq)\n ensures (ys + u) + s == ys + (u + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_4115","instance":4115,"id":190786,"goal":"lemma SeqTakeDrop_4115(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_4116","instance":4116,"id":190787,"goal":"lemma SeqReverseLen_4116(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_4117","instance":4117,"id":190788,"goal":"lemma SeqReverseIdem_4117(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_4118","instance":4118,"id":190789,"goal":"lemma SeqMapLen_4118(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_4119","instance":4119,"id":190790,"goal":"lemma SeqFilterLe_4119(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_4120","instance":4120,"id":190791,"goal":"lemma SeqMemberAppend_4120(s: seq, t: seq)\n ensures x in s + t <==> x in s || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_4121","instance":4121,"id":190792,"goal":"lemma SeqAppendLen_4121(t: seq, ys: seq)\n ensures |t + ys| == |t| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_4122","instance":4122,"id":190793,"goal":"lemma SeqAppendNil_4122(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_4123","instance":4123,"id":190794,"goal":"lemma SeqNilAppend_4123(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_4124","instance":4124,"id":190795,"goal":"lemma SeqAppendAssoc_4124(s: seq, ys: seq, t: seq)\n ensures (s + ys) + t == s + (ys + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_4125","instance":4125,"id":190796,"goal":"lemma SeqTakeDrop_4125(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_4126","instance":4126,"id":190797,"goal":"lemma SeqReverseLen_4126(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_4127","instance":4127,"id":190798,"goal":"lemma SeqReverseIdem_4127(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_4128","instance":4128,"id":190799,"goal":"lemma SeqMapLen_4128(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_4129","instance":4129,"id":190800,"goal":"lemma SeqFilterLe_4129(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_4130","instance":4130,"id":190801,"goal":"lemma SeqMemberAppend_4130(u: seq, s: seq)\n ensures x in u + s <==> x in u || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_4131","instance":4131,"id":190802,"goal":"lemma SeqAppendLen_4131(s: seq, ys: seq)\n ensures |s + ys| == |s| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_4132","instance":4132,"id":190803,"goal":"lemma SeqAppendNil_4132(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_4133","instance":4133,"id":190804,"goal":"lemma SeqNilAppend_4133(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_4134","instance":4134,"id":190805,"goal":"lemma SeqAppendAssoc_4134(ys: seq, t: seq, xs: seq)\n ensures (ys + t) + xs == ys + (t + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_4135","instance":4135,"id":190806,"goal":"lemma SeqTakeDrop_4135(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_4136","instance":4136,"id":190807,"goal":"lemma SeqReverseLen_4136(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_4137","instance":4137,"id":190808,"goal":"lemma SeqReverseIdem_4137(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_4138","instance":4138,"id":190809,"goal":"lemma SeqMapLen_4138(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_4139","instance":4139,"id":190810,"goal":"lemma SeqFilterLe_4139(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_4140","instance":4140,"id":190811,"goal":"lemma SeqMemberAppend_4140(u: seq, zs: seq)\n ensures x in u + zs <==> x in u || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_4141","instance":4141,"id":190812,"goal":"lemma SeqAppendLen_4141(s: seq, t: seq)\n ensures |s + t| == |s| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_4142","instance":4142,"id":190813,"goal":"lemma SeqAppendNil_4142(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_4143","instance":4143,"id":190814,"goal":"lemma SeqNilAppend_4143(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_4144","instance":4144,"id":190815,"goal":"lemma SeqAppendAssoc_4144(t: seq, ys: seq, xs: seq)\n ensures (t + ys) + xs == t + (ys + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_4145","instance":4145,"id":190816,"goal":"lemma SeqTakeDrop_4145(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_4146","instance":4146,"id":190817,"goal":"lemma SeqReverseLen_4146(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_4147","instance":4147,"id":190818,"goal":"lemma SeqReverseIdem_4147(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_4148","instance":4148,"id":190819,"goal":"lemma SeqMapLen_4148(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_4149","instance":4149,"id":190820,"goal":"lemma SeqFilterLe_4149(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_4150","instance":4150,"id":190821,"goal":"lemma SeqMemberAppend_4150(t: seq, zs: seq)\n ensures x in t + zs <==> x in t || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_4151","instance":4151,"id":190822,"goal":"lemma SeqAppendLen_4151(ys: seq, u: seq)\n ensures |ys + u| == |ys| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_4152","instance":4152,"id":190823,"goal":"lemma SeqAppendNil_4152(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_4153","instance":4153,"id":190824,"goal":"lemma SeqNilAppend_4153(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_4154","instance":4154,"id":190825,"goal":"lemma SeqAppendAssoc_4154(u: seq, zs: seq, xs: seq)\n ensures (u + zs) + xs == u + (zs + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_4155","instance":4155,"id":190826,"goal":"lemma SeqTakeDrop_4155(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_4156","instance":4156,"id":190827,"goal":"lemma SeqReverseLen_4156(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_4157","instance":4157,"id":190828,"goal":"lemma SeqReverseIdem_4157(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_4158","instance":4158,"id":190829,"goal":"lemma SeqMapLen_4158(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_4159","instance":4159,"id":190830,"goal":"lemma SeqFilterLe_4159(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_4160","instance":4160,"id":190831,"goal":"lemma SeqMemberAppend_4160(u: seq, t: seq)\n ensures x in u + t <==> x in u || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_4161","instance":4161,"id":190832,"goal":"lemma SeqAppendLen_4161(ys: seq, u: seq)\n ensures |ys + u| == |ys| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_4162","instance":4162,"id":190833,"goal":"lemma SeqAppendNil_4162(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_4163","instance":4163,"id":190834,"goal":"lemma SeqNilAppend_4163(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_4164","instance":4164,"id":190835,"goal":"lemma SeqAppendAssoc_4164(ys: seq, xs: seq, s: seq)\n ensures (ys + xs) + s == ys + (xs + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_4165","instance":4165,"id":190836,"goal":"lemma SeqTakeDrop_4165(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_4166","instance":4166,"id":190837,"goal":"lemma SeqReverseLen_4166(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_4167","instance":4167,"id":190838,"goal":"lemma SeqReverseIdem_4167(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_4168","instance":4168,"id":190839,"goal":"lemma SeqMapLen_4168(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_4169","instance":4169,"id":190840,"goal":"lemma SeqFilterLe_4169(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_4170","instance":4170,"id":190841,"goal":"lemma SeqMemberAppend_4170(xs: seq, zs: seq)\n ensures x in xs + zs <==> x in xs || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_4171","instance":4171,"id":190842,"goal":"lemma SeqAppendLen_4171(xs: seq, t: seq)\n ensures |xs + t| == |xs| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_4172","instance":4172,"id":190843,"goal":"lemma SeqAppendNil_4172(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_4173","instance":4173,"id":190844,"goal":"lemma SeqNilAppend_4173(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_4174","instance":4174,"id":190845,"goal":"lemma SeqAppendAssoc_4174(xs: seq, ys: seq, u: seq)\n ensures (xs + ys) + u == xs + (ys + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_4175","instance":4175,"id":190846,"goal":"lemma SeqTakeDrop_4175(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_4176","instance":4176,"id":190847,"goal":"lemma SeqReverseLen_4176(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_4177","instance":4177,"id":190848,"goal":"lemma SeqReverseIdem_4177(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_4178","instance":4178,"id":190849,"goal":"lemma SeqMapLen_4178(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_4179","instance":4179,"id":190850,"goal":"lemma SeqFilterLe_4179(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_4180","instance":4180,"id":190851,"goal":"lemma SeqMemberAppend_4180(zs: seq, s: seq)\n ensures x in zs + s <==> x in zs || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_4181","instance":4181,"id":190852,"goal":"lemma SeqAppendLen_4181(t: seq, u: seq)\n ensures |t + u| == |t| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_4182","instance":4182,"id":190853,"goal":"lemma SeqAppendNil_4182(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_4183","instance":4183,"id":190854,"goal":"lemma SeqNilAppend_4183(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_4184","instance":4184,"id":190855,"goal":"lemma SeqAppendAssoc_4184(zs: seq, s: seq, u: seq)\n ensures (zs + s) + u == zs + (s + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_4185","instance":4185,"id":190856,"goal":"lemma SeqTakeDrop_4185(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_4186","instance":4186,"id":190857,"goal":"lemma SeqReverseLen_4186(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_4187","instance":4187,"id":190858,"goal":"lemma SeqReverseIdem_4187(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_4188","instance":4188,"id":190859,"goal":"lemma SeqMapLen_4188(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_4189","instance":4189,"id":190860,"goal":"lemma SeqFilterLe_4189(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_4190","instance":4190,"id":190861,"goal":"lemma SeqMemberAppend_4190(u: seq, t: seq)\n ensures x in u + t <==> x in u || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_4191","instance":4191,"id":190862,"goal":"lemma SeqAppendLen_4191(t: seq, xs: seq)\n ensures |t + xs| == |t| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_4192","instance":4192,"id":190863,"goal":"lemma SeqAppendNil_4192(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_4193","instance":4193,"id":190864,"goal":"lemma SeqNilAppend_4193(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_4194","instance":4194,"id":190865,"goal":"lemma SeqAppendAssoc_4194(zs: seq, u: seq, s: seq)\n ensures (zs + u) + s == zs + (u + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_4195","instance":4195,"id":190866,"goal":"lemma SeqTakeDrop_4195(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_4196","instance":4196,"id":190867,"goal":"lemma SeqReverseLen_4196(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_4197","instance":4197,"id":190868,"goal":"lemma SeqReverseIdem_4197(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_4198","instance":4198,"id":190869,"goal":"lemma SeqMapLen_4198(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_4199","instance":4199,"id":190870,"goal":"lemma SeqFilterLe_4199(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_4200","instance":4200,"id":190871,"goal":"lemma SeqMemberAppend_4200(u: seq, xs: seq)\n ensures x in u + xs <==> x in u || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_4201","instance":4201,"id":190872,"goal":"lemma SeqAppendLen_4201(xs: seq, u: seq)\n ensures |xs + u| == |xs| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_4202","instance":4202,"id":190873,"goal":"lemma SeqAppendNil_4202(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_4203","instance":4203,"id":190874,"goal":"lemma SeqNilAppend_4203(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_4204","instance":4204,"id":190875,"goal":"lemma SeqAppendAssoc_4204(u: seq, zs: seq, s: seq)\n ensures (u + zs) + s == u + (zs + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_4205","instance":4205,"id":190876,"goal":"lemma SeqTakeDrop_4205(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_4206","instance":4206,"id":190877,"goal":"lemma SeqReverseLen_4206(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_4207","instance":4207,"id":190878,"goal":"lemma SeqReverseIdem_4207(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_4208","instance":4208,"id":190879,"goal":"lemma SeqMapLen_4208(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_4209","instance":4209,"id":190880,"goal":"lemma SeqFilterLe_4209(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_4210","instance":4210,"id":190881,"goal":"lemma SeqMemberAppend_4210(zs: seq, xs: seq)\n ensures x in zs + xs <==> x in zs || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_4211","instance":4211,"id":190882,"goal":"lemma SeqAppendLen_4211(s: seq, t: seq)\n ensures |s + t| == |s| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_4212","instance":4212,"id":190883,"goal":"lemma SeqAppendNil_4212(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_4213","instance":4213,"id":190884,"goal":"lemma SeqNilAppend_4213(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_4214","instance":4214,"id":190885,"goal":"lemma SeqAppendAssoc_4214(ys: seq, xs: seq, zs: seq)\n ensures (ys + xs) + zs == ys + (xs + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_4215","instance":4215,"id":190886,"goal":"lemma SeqTakeDrop_4215(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_4216","instance":4216,"id":190887,"goal":"lemma SeqReverseLen_4216(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_4217","instance":4217,"id":190888,"goal":"lemma SeqReverseIdem_4217(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_4218","instance":4218,"id":190889,"goal":"lemma SeqMapLen_4218(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_4219","instance":4219,"id":190890,"goal":"lemma SeqFilterLe_4219(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_4220","instance":4220,"id":190891,"goal":"lemma SeqMemberAppend_4220(s: seq, t: seq)\n ensures x in s + t <==> x in s || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_4221","instance":4221,"id":190892,"goal":"lemma SeqAppendLen_4221(ys: seq, zs: seq)\n ensures |ys + zs| == |ys| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_4222","instance":4222,"id":190893,"goal":"lemma SeqAppendNil_4222(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_4223","instance":4223,"id":190894,"goal":"lemma SeqNilAppend_4223(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_4224","instance":4224,"id":190895,"goal":"lemma SeqAppendAssoc_4224(xs: seq, zs: seq, s: seq)\n ensures (xs + zs) + s == xs + (zs + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_4225","instance":4225,"id":190896,"goal":"lemma SeqTakeDrop_4225(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_4226","instance":4226,"id":190897,"goal":"lemma SeqReverseLen_4226(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_4227","instance":4227,"id":190898,"goal":"lemma SeqReverseIdem_4227(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_4228","instance":4228,"id":190899,"goal":"lemma SeqMapLen_4228(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_4229","instance":4229,"id":190900,"goal":"lemma SeqFilterLe_4229(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_4230","instance":4230,"id":190901,"goal":"lemma SeqMemberAppend_4230(u: seq, t: seq)\n ensures x in u + t <==> x in u || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_4231","instance":4231,"id":190902,"goal":"lemma SeqAppendLen_4231(xs: seq, t: seq)\n ensures |xs + t| == |xs| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_4232","instance":4232,"id":190903,"goal":"lemma SeqAppendNil_4232(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_4233","instance":4233,"id":190904,"goal":"lemma SeqNilAppend_4233(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_4234","instance":4234,"id":190905,"goal":"lemma SeqAppendAssoc_4234(zs: seq, u: seq, ys: seq)\n ensures (zs + u) + ys == zs + (u + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_4235","instance":4235,"id":190906,"goal":"lemma SeqTakeDrop_4235(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_4236","instance":4236,"id":190907,"goal":"lemma SeqReverseLen_4236(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_4237","instance":4237,"id":190908,"goal":"lemma SeqReverseIdem_4237(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_4238","instance":4238,"id":190909,"goal":"lemma SeqMapLen_4238(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_4239","instance":4239,"id":190910,"goal":"lemma SeqFilterLe_4239(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_4240","instance":4240,"id":190911,"goal":"lemma SeqMemberAppend_4240(s: seq, t: seq)\n ensures x in s + t <==> x in s || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_4241","instance":4241,"id":190912,"goal":"lemma SeqAppendLen_4241(zs: seq, u: seq)\n ensures |zs + u| == |zs| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_4242","instance":4242,"id":190913,"goal":"lemma SeqAppendNil_4242(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_4243","instance":4243,"id":190914,"goal":"lemma SeqNilAppend_4243(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_4244","instance":4244,"id":190915,"goal":"lemma SeqAppendAssoc_4244(s: seq, u: seq, xs: seq)\n ensures (s + u) + xs == s + (u + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_4245","instance":4245,"id":190916,"goal":"lemma SeqTakeDrop_4245(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_4246","instance":4246,"id":190917,"goal":"lemma SeqReverseLen_4246(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_4247","instance":4247,"id":190918,"goal":"lemma SeqReverseIdem_4247(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_4248","instance":4248,"id":190919,"goal":"lemma SeqMapLen_4248(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_4249","instance":4249,"id":190920,"goal":"lemma SeqFilterLe_4249(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_4250","instance":4250,"id":190921,"goal":"lemma SeqMemberAppend_4250(s: seq, zs: seq)\n ensures x in s + zs <==> x in s || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_4251","instance":4251,"id":190922,"goal":"lemma SeqAppendLen_4251(zs: seq, u: seq)\n ensures |zs + u| == |zs| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_4252","instance":4252,"id":190923,"goal":"lemma SeqAppendNil_4252(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_4253","instance":4253,"id":190924,"goal":"lemma SeqNilAppend_4253(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_4254","instance":4254,"id":190925,"goal":"lemma SeqAppendAssoc_4254(zs: seq, xs: seq, t: seq)\n ensures (zs + xs) + t == zs + (xs + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_4255","instance":4255,"id":190926,"goal":"lemma SeqTakeDrop_4255(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_4256","instance":4256,"id":190927,"goal":"lemma SeqReverseLen_4256(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_4257","instance":4257,"id":190928,"goal":"lemma SeqReverseIdem_4257(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_4258","instance":4258,"id":190929,"goal":"lemma SeqMapLen_4258(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_4259","instance":4259,"id":190930,"goal":"lemma SeqFilterLe_4259(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_4260","instance":4260,"id":190931,"goal":"lemma SeqMemberAppend_4260(xs: seq, ys: seq)\n ensures x in xs + ys <==> x in xs || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_4261","instance":4261,"id":190932,"goal":"lemma SeqAppendLen_4261(xs: seq, t: seq)\n ensures |xs + t| == |xs| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_4262","instance":4262,"id":190933,"goal":"lemma SeqAppendNil_4262(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_4263","instance":4263,"id":190934,"goal":"lemma SeqNilAppend_4263(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_4264","instance":4264,"id":190935,"goal":"lemma SeqAppendAssoc_4264(s: seq, zs: seq, u: seq)\n ensures (s + zs) + u == s + (zs + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_4265","instance":4265,"id":190936,"goal":"lemma SeqTakeDrop_4265(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_4266","instance":4266,"id":190937,"goal":"lemma SeqReverseLen_4266(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_4267","instance":4267,"id":190938,"goal":"lemma SeqReverseIdem_4267(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_4268","instance":4268,"id":190939,"goal":"lemma SeqMapLen_4268(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_4269","instance":4269,"id":190940,"goal":"lemma SeqFilterLe_4269(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_4270","instance":4270,"id":190941,"goal":"lemma SeqMemberAppend_4270(zs: seq, t: seq)\n ensures x in zs + t <==> x in zs || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_4271","instance":4271,"id":190942,"goal":"lemma SeqAppendLen_4271(t: seq, u: seq)\n ensures |t + u| == |t| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_4272","instance":4272,"id":190943,"goal":"lemma SeqAppendNil_4272(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_4273","instance":4273,"id":190944,"goal":"lemma SeqNilAppend_4273(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_4274","instance":4274,"id":190945,"goal":"lemma SeqAppendAssoc_4274(s: seq, t: seq, ys: seq)\n ensures (s + t) + ys == s + (t + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_4275","instance":4275,"id":190946,"goal":"lemma SeqTakeDrop_4275(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_4276","instance":4276,"id":190947,"goal":"lemma SeqReverseLen_4276(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_4277","instance":4277,"id":190948,"goal":"lemma SeqReverseIdem_4277(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_4278","instance":4278,"id":190949,"goal":"lemma SeqMapLen_4278(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_4279","instance":4279,"id":190950,"goal":"lemma SeqFilterLe_4279(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_4280","instance":4280,"id":190951,"goal":"lemma SeqMemberAppend_4280(u: seq, zs: seq)\n ensures x in u + zs <==> x in u || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_4281","instance":4281,"id":190952,"goal":"lemma SeqAppendLen_4281(xs: seq, zs: seq)\n ensures |xs + zs| == |xs| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_4282","instance":4282,"id":190953,"goal":"lemma SeqAppendNil_4282(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_4283","instance":4283,"id":190954,"goal":"lemma SeqNilAppend_4283(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_4284","instance":4284,"id":190955,"goal":"lemma SeqAppendAssoc_4284(u: seq, t: seq, zs: seq)\n ensures (u + t) + zs == u + (t + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_4285","instance":4285,"id":190956,"goal":"lemma SeqTakeDrop_4285(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_4286","instance":4286,"id":190957,"goal":"lemma SeqReverseLen_4286(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_4287","instance":4287,"id":190958,"goal":"lemma SeqReverseIdem_4287(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_4288","instance":4288,"id":190959,"goal":"lemma SeqMapLen_4288(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_4289","instance":4289,"id":190960,"goal":"lemma SeqFilterLe_4289(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_4290","instance":4290,"id":190961,"goal":"lemma SeqMemberAppend_4290(s: seq, zs: seq)\n ensures x in s + zs <==> x in s || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_4291","instance":4291,"id":190962,"goal":"lemma SeqAppendLen_4291(xs: seq, s: seq)\n ensures |xs + s| == |xs| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_4292","instance":4292,"id":190963,"goal":"lemma SeqAppendNil_4292(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_4293","instance":4293,"id":190964,"goal":"lemma SeqNilAppend_4293(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_4294","instance":4294,"id":190965,"goal":"lemma SeqAppendAssoc_4294(ys: seq, u: seq, t: seq)\n ensures (ys + u) + t == ys + (u + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_4295","instance":4295,"id":190966,"goal":"lemma SeqTakeDrop_4295(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_4296","instance":4296,"id":190967,"goal":"lemma SeqReverseLen_4296(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_4297","instance":4297,"id":190968,"goal":"lemma SeqReverseIdem_4297(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_4298","instance":4298,"id":190969,"goal":"lemma SeqMapLen_4298(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_4299","instance":4299,"id":190970,"goal":"lemma SeqFilterLe_4299(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_4300","instance":4300,"id":190971,"goal":"lemma SeqMemberAppend_4300(zs: seq, ys: seq)\n ensures x in zs + ys <==> x in zs || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_4301","instance":4301,"id":190972,"goal":"lemma SeqAppendLen_4301(u: seq, t: seq)\n ensures |u + t| == |u| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_4302","instance":4302,"id":190973,"goal":"lemma SeqAppendNil_4302(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_4303","instance":4303,"id":190974,"goal":"lemma SeqNilAppend_4303(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_4304","instance":4304,"id":190975,"goal":"lemma SeqAppendAssoc_4304(s: seq, u: seq, ys: seq)\n ensures (s + u) + ys == s + (u + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_4305","instance":4305,"id":190976,"goal":"lemma SeqTakeDrop_4305(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_4306","instance":4306,"id":190977,"goal":"lemma SeqReverseLen_4306(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_4307","instance":4307,"id":190978,"goal":"lemma SeqReverseIdem_4307(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_4308","instance":4308,"id":190979,"goal":"lemma SeqMapLen_4308(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_4309","instance":4309,"id":190980,"goal":"lemma SeqFilterLe_4309(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_4310","instance":4310,"id":190981,"goal":"lemma SeqMemberAppend_4310(u: seq, s: seq)\n ensures x in u + s <==> x in u || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_4311","instance":4311,"id":190982,"goal":"lemma SeqAppendLen_4311(xs: seq, t: seq)\n ensures |xs + t| == |xs| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_4312","instance":4312,"id":190983,"goal":"lemma SeqAppendNil_4312(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_4313","instance":4313,"id":190984,"goal":"lemma SeqNilAppend_4313(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_4314","instance":4314,"id":190985,"goal":"lemma SeqAppendAssoc_4314(s: seq, zs: seq, xs: seq)\n ensures (s + zs) + xs == s + (zs + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_4315","instance":4315,"id":190986,"goal":"lemma SeqTakeDrop_4315(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_4316","instance":4316,"id":190987,"goal":"lemma SeqReverseLen_4316(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_4317","instance":4317,"id":190988,"goal":"lemma SeqReverseIdem_4317(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_4318","instance":4318,"id":190989,"goal":"lemma SeqMapLen_4318(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_4319","instance":4319,"id":190990,"goal":"lemma SeqFilterLe_4319(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_4320","instance":4320,"id":190991,"goal":"lemma SeqMemberAppend_4320(s: seq, zs: seq)\n ensures x in s + zs <==> x in s || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_4321","instance":4321,"id":190992,"goal":"lemma SeqAppendLen_4321(t: seq, u: seq)\n ensures |t + u| == |t| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_4322","instance":4322,"id":190993,"goal":"lemma SeqAppendNil_4322(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_4323","instance":4323,"id":190994,"goal":"lemma SeqNilAppend_4323(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_4324","instance":4324,"id":190995,"goal":"lemma SeqAppendAssoc_4324(ys: seq, u: seq, zs: seq)\n ensures (ys + u) + zs == ys + (u + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_4325","instance":4325,"id":190996,"goal":"lemma SeqTakeDrop_4325(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_4326","instance":4326,"id":190997,"goal":"lemma SeqReverseLen_4326(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_4327","instance":4327,"id":190998,"goal":"lemma SeqReverseIdem_4327(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_4328","instance":4328,"id":190999,"goal":"lemma SeqMapLen_4328(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_4329","instance":4329,"id":191000,"goal":"lemma SeqFilterLe_4329(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_4330","instance":4330,"id":191001,"goal":"lemma SeqMemberAppend_4330(ys: seq, s: seq)\n ensures x in ys + s <==> x in ys || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_4331","instance":4331,"id":191002,"goal":"lemma SeqAppendLen_4331(zs: seq, ys: seq)\n ensures |zs + ys| == |zs| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_4332","instance":4332,"id":191003,"goal":"lemma SeqAppendNil_4332(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_4333","instance":4333,"id":191004,"goal":"lemma SeqNilAppend_4333(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_4334","instance":4334,"id":191005,"goal":"lemma SeqAppendAssoc_4334(zs: seq, xs: seq, ys: seq)\n ensures (zs + xs) + ys == zs + (xs + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_4335","instance":4335,"id":191006,"goal":"lemma SeqTakeDrop_4335(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_4336","instance":4336,"id":191007,"goal":"lemma SeqReverseLen_4336(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_4337","instance":4337,"id":191008,"goal":"lemma SeqReverseIdem_4337(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_4338","instance":4338,"id":191009,"goal":"lemma SeqMapLen_4338(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_4339","instance":4339,"id":191010,"goal":"lemma SeqFilterLe_4339(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_4340","instance":4340,"id":191011,"goal":"lemma SeqMemberAppend_4340(xs: seq, u: seq)\n ensures x in xs + u <==> x in xs || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_4341","instance":4341,"id":191012,"goal":"lemma SeqAppendLen_4341(u: seq, xs: seq)\n ensures |u + xs| == |u| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_4342","instance":4342,"id":191013,"goal":"lemma SeqAppendNil_4342(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_4343","instance":4343,"id":191014,"goal":"lemma SeqNilAppend_4343(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_4344","instance":4344,"id":191015,"goal":"lemma SeqAppendAssoc_4344(t: seq, ys: seq, s: seq)\n ensures (t + ys) + s == t + (ys + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_4345","instance":4345,"id":191016,"goal":"lemma SeqTakeDrop_4345(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_4346","instance":4346,"id":191017,"goal":"lemma SeqReverseLen_4346(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_4347","instance":4347,"id":191018,"goal":"lemma SeqReverseIdem_4347(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_4348","instance":4348,"id":191019,"goal":"lemma SeqMapLen_4348(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_4349","instance":4349,"id":191020,"goal":"lemma SeqFilterLe_4349(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_4350","instance":4350,"id":191021,"goal":"lemma SeqMemberAppend_4350(u: seq, xs: seq)\n ensures x in u + xs <==> x in u || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_4351","instance":4351,"id":191022,"goal":"lemma SeqAppendLen_4351(xs: seq, ys: seq)\n ensures |xs + ys| == |xs| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_4352","instance":4352,"id":191023,"goal":"lemma SeqAppendNil_4352(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_4353","instance":4353,"id":191024,"goal":"lemma SeqNilAppend_4353(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_4354","instance":4354,"id":191025,"goal":"lemma SeqAppendAssoc_4354(t: seq, ys: seq, u: seq)\n ensures (t + ys) + u == t + (ys + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_4355","instance":4355,"id":191026,"goal":"lemma SeqTakeDrop_4355(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_4356","instance":4356,"id":191027,"goal":"lemma SeqReverseLen_4356(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_4357","instance":4357,"id":191028,"goal":"lemma SeqReverseIdem_4357(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_4358","instance":4358,"id":191029,"goal":"lemma SeqMapLen_4358(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_4359","instance":4359,"id":191030,"goal":"lemma SeqFilterLe_4359(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_4360","instance":4360,"id":191031,"goal":"lemma SeqMemberAppend_4360(xs: seq, ys: seq)\n ensures x in xs + ys <==> x in xs || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_4361","instance":4361,"id":191032,"goal":"lemma SeqAppendLen_4361(ys: seq, t: seq)\n ensures |ys + t| == |ys| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_4362","instance":4362,"id":191033,"goal":"lemma SeqAppendNil_4362(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_4363","instance":4363,"id":191034,"goal":"lemma SeqNilAppend_4363(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_4364","instance":4364,"id":191035,"goal":"lemma SeqAppendAssoc_4364(zs: seq, t: seq, xs: seq)\n ensures (zs + t) + xs == zs + (t + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_4365","instance":4365,"id":191036,"goal":"lemma SeqTakeDrop_4365(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_4366","instance":4366,"id":191037,"goal":"lemma SeqReverseLen_4366(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_4367","instance":4367,"id":191038,"goal":"lemma SeqReverseIdem_4367(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_4368","instance":4368,"id":191039,"goal":"lemma SeqMapLen_4368(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_4369","instance":4369,"id":191040,"goal":"lemma SeqFilterLe_4369(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_4370","instance":4370,"id":191041,"goal":"lemma SeqMemberAppend_4370(u: seq, s: seq)\n ensures x in u + s <==> x in u || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_4371","instance":4371,"id":191042,"goal":"lemma SeqAppendLen_4371(xs: seq, zs: seq)\n ensures |xs + zs| == |xs| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_4372","instance":4372,"id":191043,"goal":"lemma SeqAppendNil_4372(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_4373","instance":4373,"id":191044,"goal":"lemma SeqNilAppend_4373(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_4374","instance":4374,"id":191045,"goal":"lemma SeqAppendAssoc_4374(t: seq, zs: seq, ys: seq)\n ensures (t + zs) + ys == t + (zs + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_4375","instance":4375,"id":191046,"goal":"lemma SeqTakeDrop_4375(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_4376","instance":4376,"id":191047,"goal":"lemma SeqReverseLen_4376(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_4377","instance":4377,"id":191048,"goal":"lemma SeqReverseIdem_4377(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_4378","instance":4378,"id":191049,"goal":"lemma SeqMapLen_4378(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_4379","instance":4379,"id":191050,"goal":"lemma SeqFilterLe_4379(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_4380","instance":4380,"id":191051,"goal":"lemma SeqMemberAppend_4380(u: seq, zs: seq)\n ensures x in u + zs <==> x in u || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_4381","instance":4381,"id":191052,"goal":"lemma SeqAppendLen_4381(t: seq, u: seq)\n ensures |t + u| == |t| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_4382","instance":4382,"id":191053,"goal":"lemma SeqAppendNil_4382(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_4383","instance":4383,"id":191054,"goal":"lemma SeqNilAppend_4383(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_4384","instance":4384,"id":191055,"goal":"lemma SeqAppendAssoc_4384(s: seq, t: seq, ys: seq)\n ensures (s + t) + ys == s + (t + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_4385","instance":4385,"id":191056,"goal":"lemma SeqTakeDrop_4385(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_4386","instance":4386,"id":191057,"goal":"lemma SeqReverseLen_4386(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_4387","instance":4387,"id":191058,"goal":"lemma SeqReverseIdem_4387(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_4388","instance":4388,"id":191059,"goal":"lemma SeqMapLen_4388(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_4389","instance":4389,"id":191060,"goal":"lemma SeqFilterLe_4389(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_4390","instance":4390,"id":191061,"goal":"lemma SeqMemberAppend_4390(zs: seq, s: seq)\n ensures x in zs + s <==> x in zs || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_4391","instance":4391,"id":191062,"goal":"lemma SeqAppendLen_4391(ys: seq, zs: seq)\n ensures |ys + zs| == |ys| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_4392","instance":4392,"id":191063,"goal":"lemma SeqAppendNil_4392(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_4393","instance":4393,"id":191064,"goal":"lemma SeqNilAppend_4393(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_4394","instance":4394,"id":191065,"goal":"lemma SeqAppendAssoc_4394(ys: seq, t: seq, xs: seq)\n ensures (ys + t) + xs == ys + (t + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_4395","instance":4395,"id":191066,"goal":"lemma SeqTakeDrop_4395(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_4396","instance":4396,"id":191067,"goal":"lemma SeqReverseLen_4396(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_4397","instance":4397,"id":191068,"goal":"lemma SeqReverseIdem_4397(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_4398","instance":4398,"id":191069,"goal":"lemma SeqMapLen_4398(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_4399","instance":4399,"id":191070,"goal":"lemma SeqFilterLe_4399(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_4400","instance":4400,"id":191071,"goal":"lemma SeqMemberAppend_4400(zs: seq, xs: seq)\n ensures x in zs + xs <==> x in zs || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_4401","instance":4401,"id":191072,"goal":"lemma SeqAppendLen_4401(xs: seq, t: seq)\n ensures |xs + t| == |xs| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_4402","instance":4402,"id":191073,"goal":"lemma SeqAppendNil_4402(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_4403","instance":4403,"id":191074,"goal":"lemma SeqNilAppend_4403(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_4404","instance":4404,"id":191075,"goal":"lemma SeqAppendAssoc_4404(xs: seq, u: seq, ys: seq)\n ensures (xs + u) + ys == xs + (u + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_4405","instance":4405,"id":191076,"goal":"lemma SeqTakeDrop_4405(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_4406","instance":4406,"id":191077,"goal":"lemma SeqReverseLen_4406(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_4407","instance":4407,"id":191078,"goal":"lemma SeqReverseIdem_4407(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_4408","instance":4408,"id":191079,"goal":"lemma SeqMapLen_4408(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_4409","instance":4409,"id":191080,"goal":"lemma SeqFilterLe_4409(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_4410","instance":4410,"id":191081,"goal":"lemma SeqMemberAppend_4410(ys: seq, u: seq)\n ensures x in ys + u <==> x in ys || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_4411","instance":4411,"id":191082,"goal":"lemma SeqAppendLen_4411(xs: seq, t: seq)\n ensures |xs + t| == |xs| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_4412","instance":4412,"id":191083,"goal":"lemma SeqAppendNil_4412(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_4413","instance":4413,"id":191084,"goal":"lemma SeqNilAppend_4413(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_4414","instance":4414,"id":191085,"goal":"lemma SeqAppendAssoc_4414(ys: seq, zs: seq, u: seq)\n ensures (ys + zs) + u == ys + (zs + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_4415","instance":4415,"id":191086,"goal":"lemma SeqTakeDrop_4415(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_4416","instance":4416,"id":191087,"goal":"lemma SeqReverseLen_4416(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_4417","instance":4417,"id":191088,"goal":"lemma SeqReverseIdem_4417(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_4418","instance":4418,"id":191089,"goal":"lemma SeqMapLen_4418(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_4419","instance":4419,"id":191090,"goal":"lemma SeqFilterLe_4419(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_4420","instance":4420,"id":191091,"goal":"lemma SeqMemberAppend_4420(u: seq, t: seq)\n ensures x in u + t <==> x in u || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_4421","instance":4421,"id":191092,"goal":"lemma SeqAppendLen_4421(t: seq, zs: seq)\n ensures |t + zs| == |t| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_4422","instance":4422,"id":191093,"goal":"lemma SeqAppendNil_4422(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_4423","instance":4423,"id":191094,"goal":"lemma SeqNilAppend_4423(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_4424","instance":4424,"id":191095,"goal":"lemma SeqAppendAssoc_4424(zs: seq, xs: seq, t: seq)\n ensures (zs + xs) + t == zs + (xs + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_4425","instance":4425,"id":191096,"goal":"lemma SeqTakeDrop_4425(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_4426","instance":4426,"id":191097,"goal":"lemma SeqReverseLen_4426(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_4427","instance":4427,"id":191098,"goal":"lemma SeqReverseIdem_4427(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_4428","instance":4428,"id":191099,"goal":"lemma SeqMapLen_4428(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_4429","instance":4429,"id":191100,"goal":"lemma SeqFilterLe_4429(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_4430","instance":4430,"id":191101,"goal":"lemma SeqMemberAppend_4430(zs: seq, t: seq)\n ensures x in zs + t <==> x in zs || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_4431","instance":4431,"id":191102,"goal":"lemma SeqAppendLen_4431(ys: seq, u: seq)\n ensures |ys + u| == |ys| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_4432","instance":4432,"id":191103,"goal":"lemma SeqAppendNil_4432(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_4433","instance":4433,"id":191104,"goal":"lemma SeqNilAppend_4433(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_4434","instance":4434,"id":191105,"goal":"lemma SeqAppendAssoc_4434(zs: seq, u: seq, xs: seq)\n ensures (zs + u) + xs == zs + (u + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_4435","instance":4435,"id":191106,"goal":"lemma SeqTakeDrop_4435(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_4436","instance":4436,"id":191107,"goal":"lemma SeqReverseLen_4436(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_4437","instance":4437,"id":191108,"goal":"lemma SeqReverseIdem_4437(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_4438","instance":4438,"id":191109,"goal":"lemma SeqMapLen_4438(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_4439","instance":4439,"id":191110,"goal":"lemma SeqFilterLe_4439(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_4440","instance":4440,"id":191111,"goal":"lemma SeqMemberAppend_4440(s: seq, t: seq)\n ensures x in s + t <==> x in s || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_4441","instance":4441,"id":191112,"goal":"lemma SeqAppendLen_4441(ys: seq, u: seq)\n ensures |ys + u| == |ys| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_4442","instance":4442,"id":191113,"goal":"lemma SeqAppendNil_4442(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_4443","instance":4443,"id":191114,"goal":"lemma SeqNilAppend_4443(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_4444","instance":4444,"id":191115,"goal":"lemma SeqAppendAssoc_4444(zs: seq, u: seq, ys: seq)\n ensures (zs + u) + ys == zs + (u + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_4445","instance":4445,"id":191116,"goal":"lemma SeqTakeDrop_4445(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_4446","instance":4446,"id":191117,"goal":"lemma SeqReverseLen_4446(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_4447","instance":4447,"id":191118,"goal":"lemma SeqReverseIdem_4447(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_4448","instance":4448,"id":191119,"goal":"lemma SeqMapLen_4448(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_4449","instance":4449,"id":191120,"goal":"lemma SeqFilterLe_4449(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_4450","instance":4450,"id":191121,"goal":"lemma SeqMemberAppend_4450(xs: seq, t: seq)\n ensures x in xs + t <==> x in xs || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_4451","instance":4451,"id":191122,"goal":"lemma SeqAppendLen_4451(t: seq, ys: seq)\n ensures |t + ys| == |t| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_4452","instance":4452,"id":191123,"goal":"lemma SeqAppendNil_4452(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_4453","instance":4453,"id":191124,"goal":"lemma SeqNilAppend_4453(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_4454","instance":4454,"id":191125,"goal":"lemma SeqAppendAssoc_4454(u: seq, zs: seq, s: seq)\n ensures (u + zs) + s == u + (zs + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_4455","instance":4455,"id":191126,"goal":"lemma SeqTakeDrop_4455(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_4456","instance":4456,"id":191127,"goal":"lemma SeqReverseLen_4456(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_4457","instance":4457,"id":191128,"goal":"lemma SeqReverseIdem_4457(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_4458","instance":4458,"id":191129,"goal":"lemma SeqMapLen_4458(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_4459","instance":4459,"id":191130,"goal":"lemma SeqFilterLe_4459(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_4460","instance":4460,"id":191131,"goal":"lemma SeqMemberAppend_4460(xs: seq, ys: seq)\n ensures x in xs + ys <==> x in xs || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_4461","instance":4461,"id":191132,"goal":"lemma SeqAppendLen_4461(t: seq, s: seq)\n ensures |t + s| == |t| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_4462","instance":4462,"id":191133,"goal":"lemma SeqAppendNil_4462(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_4463","instance":4463,"id":191134,"goal":"lemma SeqNilAppend_4463(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_4464","instance":4464,"id":191135,"goal":"lemma SeqAppendAssoc_4464(u: seq, zs: seq, ys: seq)\n ensures (u + zs) + ys == u + (zs + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_4465","instance":4465,"id":191136,"goal":"lemma SeqTakeDrop_4465(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_4466","instance":4466,"id":191137,"goal":"lemma SeqReverseLen_4466(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_4467","instance":4467,"id":191138,"goal":"lemma SeqReverseIdem_4467(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_4468","instance":4468,"id":191139,"goal":"lemma SeqMapLen_4468(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_4469","instance":4469,"id":191140,"goal":"lemma SeqFilterLe_4469(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_4470","instance":4470,"id":191141,"goal":"lemma SeqMemberAppend_4470(xs: seq, u: seq)\n ensures x in xs + u <==> x in xs || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_4471","instance":4471,"id":191142,"goal":"lemma SeqAppendLen_4471(xs: seq, u: seq)\n ensures |xs + u| == |xs| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_4472","instance":4472,"id":191143,"goal":"lemma SeqAppendNil_4472(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_4473","instance":4473,"id":191144,"goal":"lemma SeqNilAppend_4473(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_4474","instance":4474,"id":191145,"goal":"lemma SeqAppendAssoc_4474(s: seq, zs: seq, u: seq)\n ensures (s + zs) + u == s + (zs + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_4475","instance":4475,"id":191146,"goal":"lemma SeqTakeDrop_4475(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_4476","instance":4476,"id":191147,"goal":"lemma SeqReverseLen_4476(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_4477","instance":4477,"id":191148,"goal":"lemma SeqReverseIdem_4477(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_4478","instance":4478,"id":191149,"goal":"lemma SeqMapLen_4478(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_4479","instance":4479,"id":191150,"goal":"lemma SeqFilterLe_4479(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_4480","instance":4480,"id":191151,"goal":"lemma SeqMemberAppend_4480(s: seq, u: seq)\n ensures x in s + u <==> x in s || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_4481","instance":4481,"id":191152,"goal":"lemma SeqAppendLen_4481(ys: seq, t: seq)\n ensures |ys + t| == |ys| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_4482","instance":4482,"id":191153,"goal":"lemma SeqAppendNil_4482(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_4483","instance":4483,"id":191154,"goal":"lemma SeqNilAppend_4483(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_4484","instance":4484,"id":191155,"goal":"lemma SeqAppendAssoc_4484(t: seq, xs: seq, s: seq)\n ensures (t + xs) + s == t + (xs + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_4485","instance":4485,"id":191156,"goal":"lemma SeqTakeDrop_4485(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_4486","instance":4486,"id":191157,"goal":"lemma SeqReverseLen_4486(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_4487","instance":4487,"id":191158,"goal":"lemma SeqReverseIdem_4487(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_4488","instance":4488,"id":191159,"goal":"lemma SeqMapLen_4488(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_4489","instance":4489,"id":191160,"goal":"lemma SeqFilterLe_4489(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_4490","instance":4490,"id":191161,"goal":"lemma SeqMemberAppend_4490(zs: seq, u: seq)\n ensures x in zs + u <==> x in zs || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_4491","instance":4491,"id":191162,"goal":"lemma SeqAppendLen_4491(ys: seq, zs: seq)\n ensures |ys + zs| == |ys| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_4492","instance":4492,"id":191163,"goal":"lemma SeqAppendNil_4492(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_4493","instance":4493,"id":191164,"goal":"lemma SeqNilAppend_4493(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_4494","instance":4494,"id":191165,"goal":"lemma SeqAppendAssoc_4494(u: seq, t: seq, zs: seq)\n ensures (u + t) + zs == u + (t + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_4495","instance":4495,"id":191166,"goal":"lemma SeqTakeDrop_4495(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_4496","instance":4496,"id":191167,"goal":"lemma SeqReverseLen_4496(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_4497","instance":4497,"id":191168,"goal":"lemma SeqReverseIdem_4497(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_4498","instance":4498,"id":191169,"goal":"lemma SeqMapLen_4498(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_4499","instance":4499,"id":191170,"goal":"lemma SeqFilterLe_4499(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_4500","instance":4500,"id":191171,"goal":"lemma SeqMemberAppend_4500(xs: seq, u: seq)\n ensures x in xs + u <==> x in xs || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_4501","instance":4501,"id":191172,"goal":"lemma SeqAppendLen_4501(t: seq, ys: seq)\n ensures |t + ys| == |t| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_4502","instance":4502,"id":191173,"goal":"lemma SeqAppendNil_4502(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_4503","instance":4503,"id":191174,"goal":"lemma SeqNilAppend_4503(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_4504","instance":4504,"id":191175,"goal":"lemma SeqAppendAssoc_4504(ys: seq, zs: seq, t: seq)\n ensures (ys + zs) + t == ys + (zs + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_4505","instance":4505,"id":191176,"goal":"lemma SeqTakeDrop_4505(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_4506","instance":4506,"id":191177,"goal":"lemma SeqReverseLen_4506(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_4507","instance":4507,"id":191178,"goal":"lemma SeqReverseIdem_4507(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_4508","instance":4508,"id":191179,"goal":"lemma SeqMapLen_4508(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_4509","instance":4509,"id":191180,"goal":"lemma SeqFilterLe_4509(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_4510","instance":4510,"id":191181,"goal":"lemma SeqMemberAppend_4510(s: seq, zs: seq)\n ensures x in s + zs <==> x in s || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_4511","instance":4511,"id":191182,"goal":"lemma SeqAppendLen_4511(s: seq, u: seq)\n ensures |s + u| == |s| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_4512","instance":4512,"id":191183,"goal":"lemma SeqAppendNil_4512(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_4513","instance":4513,"id":191184,"goal":"lemma SeqNilAppend_4513(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_4514","instance":4514,"id":191185,"goal":"lemma SeqAppendAssoc_4514(xs: seq, zs: seq, t: seq)\n ensures (xs + zs) + t == xs + (zs + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_4515","instance":4515,"id":191186,"goal":"lemma SeqTakeDrop_4515(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_4516","instance":4516,"id":191187,"goal":"lemma SeqReverseLen_4516(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_4517","instance":4517,"id":191188,"goal":"lemma SeqReverseIdem_4517(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_4518","instance":4518,"id":191189,"goal":"lemma SeqMapLen_4518(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_4519","instance":4519,"id":191190,"goal":"lemma SeqFilterLe_4519(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_4520","instance":4520,"id":191191,"goal":"lemma SeqMemberAppend_4520(ys: seq, xs: seq)\n ensures x in ys + xs <==> x in ys || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_4521","instance":4521,"id":191192,"goal":"lemma SeqAppendLen_4521(ys: seq, zs: seq)\n ensures |ys + zs| == |ys| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_4522","instance":4522,"id":191193,"goal":"lemma SeqAppendNil_4522(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_4523","instance":4523,"id":191194,"goal":"lemma SeqNilAppend_4523(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_4524","instance":4524,"id":191195,"goal":"lemma SeqAppendAssoc_4524(ys: seq, u: seq, t: seq)\n ensures (ys + u) + t == ys + (u + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_4525","instance":4525,"id":191196,"goal":"lemma SeqTakeDrop_4525(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_4526","instance":4526,"id":191197,"goal":"lemma SeqReverseLen_4526(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_4527","instance":4527,"id":191198,"goal":"lemma SeqReverseIdem_4527(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_4528","instance":4528,"id":191199,"goal":"lemma SeqMapLen_4528(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_4529","instance":4529,"id":191200,"goal":"lemma SeqFilterLe_4529(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_4530","instance":4530,"id":191201,"goal":"lemma SeqMemberAppend_4530(zs: seq, t: seq)\n ensures x in zs + t <==> x in zs || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_4531","instance":4531,"id":191202,"goal":"lemma SeqAppendLen_4531(u: seq, t: seq)\n ensures |u + t| == |u| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_4532","instance":4532,"id":191203,"goal":"lemma SeqAppendNil_4532(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_4533","instance":4533,"id":191204,"goal":"lemma SeqNilAppend_4533(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_4534","instance":4534,"id":191205,"goal":"lemma SeqAppendAssoc_4534(xs: seq, t: seq, u: seq)\n ensures (xs + t) + u == xs + (t + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_4535","instance":4535,"id":191206,"goal":"lemma SeqTakeDrop_4535(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_4536","instance":4536,"id":191207,"goal":"lemma SeqReverseLen_4536(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_4537","instance":4537,"id":191208,"goal":"lemma SeqReverseIdem_4537(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_4538","instance":4538,"id":191209,"goal":"lemma SeqMapLen_4538(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_4539","instance":4539,"id":191210,"goal":"lemma SeqFilterLe_4539(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_4540","instance":4540,"id":191211,"goal":"lemma SeqMemberAppend_4540(ys: seq, t: seq)\n ensures x in ys + t <==> x in ys || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_4541","instance":4541,"id":191212,"goal":"lemma SeqAppendLen_4541(u: seq, ys: seq)\n ensures |u + ys| == |u| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_4542","instance":4542,"id":191213,"goal":"lemma SeqAppendNil_4542(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_4543","instance":4543,"id":191214,"goal":"lemma SeqNilAppend_4543(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_4544","instance":4544,"id":191215,"goal":"lemma SeqAppendAssoc_4544(s: seq, t: seq, u: seq)\n ensures (s + t) + u == s + (t + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_4545","instance":4545,"id":191216,"goal":"lemma SeqTakeDrop_4545(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_4546","instance":4546,"id":191217,"goal":"lemma SeqReverseLen_4546(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_4547","instance":4547,"id":191218,"goal":"lemma SeqReverseIdem_4547(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_4548","instance":4548,"id":191219,"goal":"lemma SeqMapLen_4548(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_4549","instance":4549,"id":191220,"goal":"lemma SeqFilterLe_4549(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_4550","instance":4550,"id":191221,"goal":"lemma SeqMemberAppend_4550(xs: seq, zs: seq)\n ensures x in xs + zs <==> x in xs || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_4551","instance":4551,"id":191222,"goal":"lemma SeqAppendLen_4551(u: seq, s: seq)\n ensures |u + s| == |u| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_4552","instance":4552,"id":191223,"goal":"lemma SeqAppendNil_4552(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_4553","instance":4553,"id":191224,"goal":"lemma SeqNilAppend_4553(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_4554","instance":4554,"id":191225,"goal":"lemma SeqAppendAssoc_4554(s: seq, ys: seq, u: seq)\n ensures (s + ys) + u == s + (ys + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_4555","instance":4555,"id":191226,"goal":"lemma SeqTakeDrop_4555(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_4556","instance":4556,"id":191227,"goal":"lemma SeqReverseLen_4556(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_4557","instance":4557,"id":191228,"goal":"lemma SeqReverseIdem_4557(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_4558","instance":4558,"id":191229,"goal":"lemma SeqMapLen_4558(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_4559","instance":4559,"id":191230,"goal":"lemma SeqFilterLe_4559(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_4560","instance":4560,"id":191231,"goal":"lemma SeqMemberAppend_4560(t: seq, ys: seq)\n ensures x in t + ys <==> x in t || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_4561","instance":4561,"id":191232,"goal":"lemma SeqAppendLen_4561(u: seq, t: seq)\n ensures |u + t| == |u| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_4562","instance":4562,"id":191233,"goal":"lemma SeqAppendNil_4562(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_4563","instance":4563,"id":191234,"goal":"lemma SeqNilAppend_4563(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_4564","instance":4564,"id":191235,"goal":"lemma SeqAppendAssoc_4564(t: seq, ys: seq, u: seq)\n ensures (t + ys) + u == t + (ys + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_4565","instance":4565,"id":191236,"goal":"lemma SeqTakeDrop_4565(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_4566","instance":4566,"id":191237,"goal":"lemma SeqReverseLen_4566(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_4567","instance":4567,"id":191238,"goal":"lemma SeqReverseIdem_4567(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_4568","instance":4568,"id":191239,"goal":"lemma SeqMapLen_4568(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_4569","instance":4569,"id":191240,"goal":"lemma SeqFilterLe_4569(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_4570","instance":4570,"id":191241,"goal":"lemma SeqMemberAppend_4570(ys: seq, zs: seq)\n ensures x in ys + zs <==> x in ys || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_4571","instance":4571,"id":191242,"goal":"lemma SeqAppendLen_4571(t: seq, u: seq)\n ensures |t + u| == |t| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_4572","instance":4572,"id":191243,"goal":"lemma SeqAppendNil_4572(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_4573","instance":4573,"id":191244,"goal":"lemma SeqNilAppend_4573(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_4574","instance":4574,"id":191245,"goal":"lemma SeqAppendAssoc_4574(ys: seq, t: seq, xs: seq)\n ensures (ys + t) + xs == ys + (t + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_4575","instance":4575,"id":191246,"goal":"lemma SeqTakeDrop_4575(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_4576","instance":4576,"id":191247,"goal":"lemma SeqReverseLen_4576(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_4577","instance":4577,"id":191248,"goal":"lemma SeqReverseIdem_4577(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_4578","instance":4578,"id":191249,"goal":"lemma SeqMapLen_4578(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_4579","instance":4579,"id":191250,"goal":"lemma SeqFilterLe_4579(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_4580","instance":4580,"id":191251,"goal":"lemma SeqMemberAppend_4580(s: seq, xs: seq)\n ensures x in s + xs <==> x in s || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_4581","instance":4581,"id":191252,"goal":"lemma SeqAppendLen_4581(xs: seq, s: seq)\n ensures |xs + s| == |xs| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_4582","instance":4582,"id":191253,"goal":"lemma SeqAppendNil_4582(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_4583","instance":4583,"id":191254,"goal":"lemma SeqNilAppend_4583(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_4584","instance":4584,"id":191255,"goal":"lemma SeqAppendAssoc_4584(xs: seq, zs: seq, s: seq)\n ensures (xs + zs) + s == xs + (zs + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_4585","instance":4585,"id":191256,"goal":"lemma SeqTakeDrop_4585(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_4586","instance":4586,"id":191257,"goal":"lemma SeqReverseLen_4586(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_4587","instance":4587,"id":191258,"goal":"lemma SeqReverseIdem_4587(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_4588","instance":4588,"id":191259,"goal":"lemma SeqMapLen_4588(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_4589","instance":4589,"id":191260,"goal":"lemma SeqFilterLe_4589(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_4590","instance":4590,"id":191261,"goal":"lemma SeqMemberAppend_4590(zs: seq, s: seq)\n ensures x in zs + s <==> x in zs || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_4591","instance":4591,"id":191262,"goal":"lemma SeqAppendLen_4591(xs: seq, s: seq)\n ensures |xs + s| == |xs| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_4592","instance":4592,"id":191263,"goal":"lemma SeqAppendNil_4592(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_4593","instance":4593,"id":191264,"goal":"lemma SeqNilAppend_4593(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_4594","instance":4594,"id":191265,"goal":"lemma SeqAppendAssoc_4594(t: seq, ys: seq, u: seq)\n ensures (t + ys) + u == t + (ys + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_4595","instance":4595,"id":191266,"goal":"lemma SeqTakeDrop_4595(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_4596","instance":4596,"id":191267,"goal":"lemma SeqReverseLen_4596(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_4597","instance":4597,"id":191268,"goal":"lemma SeqReverseIdem_4597(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_4598","instance":4598,"id":191269,"goal":"lemma SeqMapLen_4598(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_4599","instance":4599,"id":191270,"goal":"lemma SeqFilterLe_4599(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_4600","instance":4600,"id":191271,"goal":"lemma SeqMemberAppend_4600(s: seq, u: seq)\n ensures x in s + u <==> x in s || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_4601","instance":4601,"id":191272,"goal":"lemma SeqAppendLen_4601(u: seq, xs: seq)\n ensures |u + xs| == |u| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_4602","instance":4602,"id":191273,"goal":"lemma SeqAppendNil_4602(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_4603","instance":4603,"id":191274,"goal":"lemma SeqNilAppend_4603(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_4604","instance":4604,"id":191275,"goal":"lemma SeqAppendAssoc_4604(xs: seq, u: seq, s: seq)\n ensures (xs + u) + s == xs + (u + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_4605","instance":4605,"id":191276,"goal":"lemma SeqTakeDrop_4605(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_4606","instance":4606,"id":191277,"goal":"lemma SeqReverseLen_4606(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_4607","instance":4607,"id":191278,"goal":"lemma SeqReverseIdem_4607(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_4608","instance":4608,"id":191279,"goal":"lemma SeqMapLen_4608(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_4609","instance":4609,"id":191280,"goal":"lemma SeqFilterLe_4609(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_4610","instance":4610,"id":191281,"goal":"lemma SeqMemberAppend_4610(zs: seq, t: seq)\n ensures x in zs + t <==> x in zs || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_4611","instance":4611,"id":191282,"goal":"lemma SeqAppendLen_4611(zs: seq, xs: seq)\n ensures |zs + xs| == |zs| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_4612","instance":4612,"id":191283,"goal":"lemma SeqAppendNil_4612(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_4613","instance":4613,"id":191284,"goal":"lemma SeqNilAppend_4613(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_4614","instance":4614,"id":191285,"goal":"lemma SeqAppendAssoc_4614(zs: seq, u: seq, xs: seq)\n ensures (zs + u) + xs == zs + (u + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_4615","instance":4615,"id":191286,"goal":"lemma SeqTakeDrop_4615(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_4616","instance":4616,"id":191287,"goal":"lemma SeqReverseLen_4616(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_4617","instance":4617,"id":191288,"goal":"lemma SeqReverseIdem_4617(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_4618","instance":4618,"id":191289,"goal":"lemma SeqMapLen_4618(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_4619","instance":4619,"id":191290,"goal":"lemma SeqFilterLe_4619(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_4620","instance":4620,"id":191291,"goal":"lemma SeqMemberAppend_4620(s: seq, xs: seq)\n ensures x in s + xs <==> x in s || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_4621","instance":4621,"id":191292,"goal":"lemma SeqAppendLen_4621(s: seq, u: seq)\n ensures |s + u| == |s| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_4622","instance":4622,"id":191293,"goal":"lemma SeqAppendNil_4622(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_4623","instance":4623,"id":191294,"goal":"lemma SeqNilAppend_4623(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_4624","instance":4624,"id":191295,"goal":"lemma SeqAppendAssoc_4624(u: seq, t: seq, xs: seq)\n ensures (u + t) + xs == u + (t + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_4625","instance":4625,"id":191296,"goal":"lemma SeqTakeDrop_4625(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_4626","instance":4626,"id":191297,"goal":"lemma SeqReverseLen_4626(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_4627","instance":4627,"id":191298,"goal":"lemma SeqReverseIdem_4627(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_4628","instance":4628,"id":191299,"goal":"lemma SeqMapLen_4628(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_4629","instance":4629,"id":191300,"goal":"lemma SeqFilterLe_4629(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_4630","instance":4630,"id":191301,"goal":"lemma SeqMemberAppend_4630(t: seq, u: seq)\n ensures x in t + u <==> x in t || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_4631","instance":4631,"id":191302,"goal":"lemma SeqAppendLen_4631(u: seq, ys: seq)\n ensures |u + ys| == |u| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_4632","instance":4632,"id":191303,"goal":"lemma SeqAppendNil_4632(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_4633","instance":4633,"id":191304,"goal":"lemma SeqNilAppend_4633(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_4634","instance":4634,"id":191305,"goal":"lemma SeqAppendAssoc_4634(s: seq, u: seq, zs: seq)\n ensures (s + u) + zs == s + (u + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_4635","instance":4635,"id":191306,"goal":"lemma SeqTakeDrop_4635(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_4636","instance":4636,"id":191307,"goal":"lemma SeqReverseLen_4636(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_4637","instance":4637,"id":191308,"goal":"lemma SeqReverseIdem_4637(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_4638","instance":4638,"id":191309,"goal":"lemma SeqMapLen_4638(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_4639","instance":4639,"id":191310,"goal":"lemma SeqFilterLe_4639(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_4640","instance":4640,"id":191311,"goal":"lemma SeqMemberAppend_4640(xs: seq, ys: seq)\n ensures x in xs + ys <==> x in xs || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_4641","instance":4641,"id":191312,"goal":"lemma SeqAppendLen_4641(xs: seq, ys: seq)\n ensures |xs + ys| == |xs| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_4642","instance":4642,"id":191313,"goal":"lemma SeqAppendNil_4642(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_4643","instance":4643,"id":191314,"goal":"lemma SeqNilAppend_4643(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_4644","instance":4644,"id":191315,"goal":"lemma SeqAppendAssoc_4644(ys: seq, u: seq, t: seq)\n ensures (ys + u) + t == ys + (u + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_4645","instance":4645,"id":191316,"goal":"lemma SeqTakeDrop_4645(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_4646","instance":4646,"id":191317,"goal":"lemma SeqReverseLen_4646(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_4647","instance":4647,"id":191318,"goal":"lemma SeqReverseIdem_4647(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_4648","instance":4648,"id":191319,"goal":"lemma SeqMapLen_4648(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_4649","instance":4649,"id":191320,"goal":"lemma SeqFilterLe_4649(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_4650","instance":4650,"id":191321,"goal":"lemma SeqMemberAppend_4650(zs: seq, u: seq)\n ensures x in zs + u <==> x in zs || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_4651","instance":4651,"id":191322,"goal":"lemma SeqAppendLen_4651(xs: seq, t: seq)\n ensures |xs + t| == |xs| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_4652","instance":4652,"id":191323,"goal":"lemma SeqAppendNil_4652(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_4653","instance":4653,"id":191324,"goal":"lemma SeqNilAppend_4653(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_4654","instance":4654,"id":191325,"goal":"lemma SeqAppendAssoc_4654(ys: seq, t: seq, u: seq)\n ensures (ys + t) + u == ys + (t + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_4655","instance":4655,"id":191326,"goal":"lemma SeqTakeDrop_4655(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_4656","instance":4656,"id":191327,"goal":"lemma SeqReverseLen_4656(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_4657","instance":4657,"id":191328,"goal":"lemma SeqReverseIdem_4657(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_4658","instance":4658,"id":191329,"goal":"lemma SeqMapLen_4658(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_4659","instance":4659,"id":191330,"goal":"lemma SeqFilterLe_4659(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_4660","instance":4660,"id":191331,"goal":"lemma SeqMemberAppend_4660(t: seq, s: seq)\n ensures x in t + s <==> x in t || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_4661","instance":4661,"id":191332,"goal":"lemma SeqAppendLen_4661(t: seq, zs: seq)\n ensures |t + zs| == |t| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_4662","instance":4662,"id":191333,"goal":"lemma SeqAppendNil_4662(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_4663","instance":4663,"id":191334,"goal":"lemma SeqNilAppend_4663(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_4664","instance":4664,"id":191335,"goal":"lemma SeqAppendAssoc_4664(ys: seq, u: seq, s: seq)\n ensures (ys + u) + s == ys + (u + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_4665","instance":4665,"id":191336,"goal":"lemma SeqTakeDrop_4665(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_4666","instance":4666,"id":191337,"goal":"lemma SeqReverseLen_4666(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_4667","instance":4667,"id":191338,"goal":"lemma SeqReverseIdem_4667(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_4668","instance":4668,"id":191339,"goal":"lemma SeqMapLen_4668(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_4669","instance":4669,"id":191340,"goal":"lemma SeqFilterLe_4669(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_4670","instance":4670,"id":191341,"goal":"lemma SeqMemberAppend_4670(u: seq, zs: seq)\n ensures x in u + zs <==> x in u || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_4671","instance":4671,"id":191342,"goal":"lemma SeqAppendLen_4671(xs: seq, ys: seq)\n ensures |xs + ys| == |xs| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_4672","instance":4672,"id":191343,"goal":"lemma SeqAppendNil_4672(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_4673","instance":4673,"id":191344,"goal":"lemma SeqNilAppend_4673(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_4674","instance":4674,"id":191345,"goal":"lemma SeqAppendAssoc_4674(u: seq, t: seq, ys: seq)\n ensures (u + t) + ys == u + (t + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_4675","instance":4675,"id":191346,"goal":"lemma SeqTakeDrop_4675(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_4676","instance":4676,"id":191347,"goal":"lemma SeqReverseLen_4676(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_4677","instance":4677,"id":191348,"goal":"lemma SeqReverseIdem_4677(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_4678","instance":4678,"id":191349,"goal":"lemma SeqMapLen_4678(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_4679","instance":4679,"id":191350,"goal":"lemma SeqFilterLe_4679(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_4680","instance":4680,"id":191351,"goal":"lemma SeqMemberAppend_4680(xs: seq, s: seq)\n ensures x in xs + s <==> x in xs || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_4681","instance":4681,"id":191352,"goal":"lemma SeqAppendLen_4681(xs: seq, zs: seq)\n ensures |xs + zs| == |xs| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_4682","instance":4682,"id":191353,"goal":"lemma SeqAppendNil_4682(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_4683","instance":4683,"id":191354,"goal":"lemma SeqNilAppend_4683(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_4684","instance":4684,"id":191355,"goal":"lemma SeqAppendAssoc_4684(s: seq, u: seq, t: seq)\n ensures (s + u) + t == s + (u + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_4685","instance":4685,"id":191356,"goal":"lemma SeqTakeDrop_4685(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_4686","instance":4686,"id":191357,"goal":"lemma SeqReverseLen_4686(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_4687","instance":4687,"id":191358,"goal":"lemma SeqReverseIdem_4687(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_4688","instance":4688,"id":191359,"goal":"lemma SeqMapLen_4688(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_4689","instance":4689,"id":191360,"goal":"lemma SeqFilterLe_4689(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_4690","instance":4690,"id":191361,"goal":"lemma SeqMemberAppend_4690(s: seq, zs: seq)\n ensures x in s + zs <==> x in s || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_4691","instance":4691,"id":191362,"goal":"lemma SeqAppendLen_4691(xs: seq, zs: seq)\n ensures |xs + zs| == |xs| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_4692","instance":4692,"id":191363,"goal":"lemma SeqAppendNil_4692(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_4693","instance":4693,"id":191364,"goal":"lemma SeqNilAppend_4693(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_4694","instance":4694,"id":191365,"goal":"lemma SeqAppendAssoc_4694(s: seq, u: seq, zs: seq)\n ensures (s + u) + zs == s + (u + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_4695","instance":4695,"id":191366,"goal":"lemma SeqTakeDrop_4695(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_4696","instance":4696,"id":191367,"goal":"lemma SeqReverseLen_4696(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_4697","instance":4697,"id":191368,"goal":"lemma SeqReverseIdem_4697(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_4698","instance":4698,"id":191369,"goal":"lemma SeqMapLen_4698(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_4699","instance":4699,"id":191370,"goal":"lemma SeqFilterLe_4699(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_4700","instance":4700,"id":191371,"goal":"lemma SeqMemberAppend_4700(u: seq, zs: seq)\n ensures x in u + zs <==> x in u || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_4701","instance":4701,"id":191372,"goal":"lemma SeqAppendLen_4701(zs: seq, ys: seq)\n ensures |zs + ys| == |zs| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_4702","instance":4702,"id":191373,"goal":"lemma SeqAppendNil_4702(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_4703","instance":4703,"id":191374,"goal":"lemma SeqNilAppend_4703(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_4704","instance":4704,"id":191375,"goal":"lemma SeqAppendAssoc_4704(ys: seq, xs: seq, t: seq)\n ensures (ys + xs) + t == ys + (xs + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_4705","instance":4705,"id":191376,"goal":"lemma SeqTakeDrop_4705(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_4706","instance":4706,"id":191377,"goal":"lemma SeqReverseLen_4706(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_4707","instance":4707,"id":191378,"goal":"lemma SeqReverseIdem_4707(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_4708","instance":4708,"id":191379,"goal":"lemma SeqMapLen_4708(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_4709","instance":4709,"id":191380,"goal":"lemma SeqFilterLe_4709(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_4710","instance":4710,"id":191381,"goal":"lemma SeqMemberAppend_4710(u: seq, zs: seq)\n ensures x in u + zs <==> x in u || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_4711","instance":4711,"id":191382,"goal":"lemma SeqAppendLen_4711(zs: seq, s: seq)\n ensures |zs + s| == |zs| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_4712","instance":4712,"id":191383,"goal":"lemma SeqAppendNil_4712(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_4713","instance":4713,"id":191384,"goal":"lemma SeqNilAppend_4713(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_4714","instance":4714,"id":191385,"goal":"lemma SeqAppendAssoc_4714(zs: seq, ys: seq, xs: seq)\n ensures (zs + ys) + xs == zs + (ys + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_4715","instance":4715,"id":191386,"goal":"lemma SeqTakeDrop_4715(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_4716","instance":4716,"id":191387,"goal":"lemma SeqReverseLen_4716(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_4717","instance":4717,"id":191388,"goal":"lemma SeqReverseIdem_4717(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_4718","instance":4718,"id":191389,"goal":"lemma SeqMapLen_4718(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_4719","instance":4719,"id":191390,"goal":"lemma SeqFilterLe_4719(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_4720","instance":4720,"id":191391,"goal":"lemma SeqMemberAppend_4720(zs: seq, t: seq)\n ensures x in zs + t <==> x in zs || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_4721","instance":4721,"id":191392,"goal":"lemma SeqAppendLen_4721(xs: seq, t: seq)\n ensures |xs + t| == |xs| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_4722","instance":4722,"id":191393,"goal":"lemma SeqAppendNil_4722(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_4723","instance":4723,"id":191394,"goal":"lemma SeqNilAppend_4723(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_4724","instance":4724,"id":191395,"goal":"lemma SeqAppendAssoc_4724(xs: seq, t: seq, ys: seq)\n ensures (xs + t) + ys == xs + (t + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_4725","instance":4725,"id":191396,"goal":"lemma SeqTakeDrop_4725(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_4726","instance":4726,"id":191397,"goal":"lemma SeqReverseLen_4726(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_4727","instance":4727,"id":191398,"goal":"lemma SeqReverseIdem_4727(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_4728","instance":4728,"id":191399,"goal":"lemma SeqMapLen_4728(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_4729","instance":4729,"id":191400,"goal":"lemma SeqFilterLe_4729(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_4730","instance":4730,"id":191401,"goal":"lemma SeqMemberAppend_4730(u: seq, t: seq)\n ensures x in u + t <==> x in u || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_4731","instance":4731,"id":191402,"goal":"lemma SeqAppendLen_4731(ys: seq, t: seq)\n ensures |ys + t| == |ys| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_4732","instance":4732,"id":191403,"goal":"lemma SeqAppendNil_4732(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_4733","instance":4733,"id":191404,"goal":"lemma SeqNilAppend_4733(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_4734","instance":4734,"id":191405,"goal":"lemma SeqAppendAssoc_4734(xs: seq, u: seq, s: seq)\n ensures (xs + u) + s == xs + (u + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_4735","instance":4735,"id":191406,"goal":"lemma SeqTakeDrop_4735(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_4736","instance":4736,"id":191407,"goal":"lemma SeqReverseLen_4736(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_4737","instance":4737,"id":191408,"goal":"lemma SeqReverseIdem_4737(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_4738","instance":4738,"id":191409,"goal":"lemma SeqMapLen_4738(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_4739","instance":4739,"id":191410,"goal":"lemma SeqFilterLe_4739(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_4740","instance":4740,"id":191411,"goal":"lemma SeqMemberAppend_4740(u: seq, ys: seq)\n ensures x in u + ys <==> x in u || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_4741","instance":4741,"id":191412,"goal":"lemma SeqAppendLen_4741(xs: seq, zs: seq)\n ensures |xs + zs| == |xs| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_4742","instance":4742,"id":191413,"goal":"lemma SeqAppendNil_4742(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_4743","instance":4743,"id":191414,"goal":"lemma SeqNilAppend_4743(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_4744","instance":4744,"id":191415,"goal":"lemma SeqAppendAssoc_4744(t: seq, xs: seq, ys: seq)\n ensures (t + xs) + ys == t + (xs + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_4745","instance":4745,"id":191416,"goal":"lemma SeqTakeDrop_4745(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_4746","instance":4746,"id":191417,"goal":"lemma SeqReverseLen_4746(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_4747","instance":4747,"id":191418,"goal":"lemma SeqReverseIdem_4747(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_4748","instance":4748,"id":191419,"goal":"lemma SeqMapLen_4748(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_4749","instance":4749,"id":191420,"goal":"lemma SeqFilterLe_4749(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_4750","instance":4750,"id":191421,"goal":"lemma SeqMemberAppend_4750(zs: seq, u: seq)\n ensures x in zs + u <==> x in zs || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_4751","instance":4751,"id":191422,"goal":"lemma SeqAppendLen_4751(t: seq, u: seq)\n ensures |t + u| == |t| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_4752","instance":4752,"id":191423,"goal":"lemma SeqAppendNil_4752(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_4753","instance":4753,"id":191424,"goal":"lemma SeqNilAppend_4753(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_4754","instance":4754,"id":191425,"goal":"lemma SeqAppendAssoc_4754(u: seq, ys: seq, xs: seq)\n ensures (u + ys) + xs == u + (ys + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_4755","instance":4755,"id":191426,"goal":"lemma SeqTakeDrop_4755(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_4756","instance":4756,"id":191427,"goal":"lemma SeqReverseLen_4756(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_4757","instance":4757,"id":191428,"goal":"lemma SeqReverseIdem_4757(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_4758","instance":4758,"id":191429,"goal":"lemma SeqMapLen_4758(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_4759","instance":4759,"id":191430,"goal":"lemma SeqFilterLe_4759(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_4760","instance":4760,"id":191431,"goal":"lemma SeqMemberAppend_4760(u: seq, xs: seq)\n ensures x in u + xs <==> x in u || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_4761","instance":4761,"id":191432,"goal":"lemma SeqAppendLen_4761(u: seq, ys: seq)\n ensures |u + ys| == |u| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_4762","instance":4762,"id":191433,"goal":"lemma SeqAppendNil_4762(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_4763","instance":4763,"id":191434,"goal":"lemma SeqNilAppend_4763(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_4764","instance":4764,"id":191435,"goal":"lemma SeqAppendAssoc_4764(s: seq, zs: seq, u: seq)\n ensures (s + zs) + u == s + (zs + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_4765","instance":4765,"id":191436,"goal":"lemma SeqTakeDrop_4765(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_4766","instance":4766,"id":191437,"goal":"lemma SeqReverseLen_4766(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_4767","instance":4767,"id":191438,"goal":"lemma SeqReverseIdem_4767(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_4768","instance":4768,"id":191439,"goal":"lemma SeqMapLen_4768(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_4769","instance":4769,"id":191440,"goal":"lemma SeqFilterLe_4769(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_4770","instance":4770,"id":191441,"goal":"lemma SeqMemberAppend_4770(s: seq, u: seq)\n ensures x in s + u <==> x in s || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_4771","instance":4771,"id":191442,"goal":"lemma SeqAppendLen_4771(u: seq, xs: seq)\n ensures |u + xs| == |u| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_4772","instance":4772,"id":191443,"goal":"lemma SeqAppendNil_4772(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_4773","instance":4773,"id":191444,"goal":"lemma SeqNilAppend_4773(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_4774","instance":4774,"id":191445,"goal":"lemma SeqAppendAssoc_4774(zs: seq, ys: seq, s: seq)\n ensures (zs + ys) + s == zs + (ys + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_4775","instance":4775,"id":191446,"goal":"lemma SeqTakeDrop_4775(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_4776","instance":4776,"id":191447,"goal":"lemma SeqReverseLen_4776(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_4777","instance":4777,"id":191448,"goal":"lemma SeqReverseIdem_4777(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_4778","instance":4778,"id":191449,"goal":"lemma SeqMapLen_4778(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_4779","instance":4779,"id":191450,"goal":"lemma SeqFilterLe_4779(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_4780","instance":4780,"id":191451,"goal":"lemma SeqMemberAppend_4780(s: seq, t: seq)\n ensures x in s + t <==> x in s || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_4781","instance":4781,"id":191452,"goal":"lemma SeqAppendLen_4781(xs: seq, s: seq)\n ensures |xs + s| == |xs| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_4782","instance":4782,"id":191453,"goal":"lemma SeqAppendNil_4782(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_4783","instance":4783,"id":191454,"goal":"lemma SeqNilAppend_4783(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_4784","instance":4784,"id":191455,"goal":"lemma SeqAppendAssoc_4784(xs: seq, t: seq, s: seq)\n ensures (xs + t) + s == xs + (t + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_4785","instance":4785,"id":191456,"goal":"lemma SeqTakeDrop_4785(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_4786","instance":4786,"id":191457,"goal":"lemma SeqReverseLen_4786(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_4787","instance":4787,"id":191458,"goal":"lemma SeqReverseIdem_4787(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_4788","instance":4788,"id":191459,"goal":"lemma SeqMapLen_4788(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_4789","instance":4789,"id":191460,"goal":"lemma SeqFilterLe_4789(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_4790","instance":4790,"id":191461,"goal":"lemma SeqMemberAppend_4790(zs: seq, xs: seq)\n ensures x in zs + xs <==> x in zs || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_4791","instance":4791,"id":191462,"goal":"lemma SeqAppendLen_4791(t: seq, u: seq)\n ensures |t + u| == |t| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_4792","instance":4792,"id":191463,"goal":"lemma SeqAppendNil_4792(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_4793","instance":4793,"id":191464,"goal":"lemma SeqNilAppend_4793(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_4794","instance":4794,"id":191465,"goal":"lemma SeqAppendAssoc_4794(s: seq, zs: seq, t: seq)\n ensures (s + zs) + t == s + (zs + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_4795","instance":4795,"id":191466,"goal":"lemma SeqTakeDrop_4795(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_4796","instance":4796,"id":191467,"goal":"lemma SeqReverseLen_4796(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_4797","instance":4797,"id":191468,"goal":"lemma SeqReverseIdem_4797(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_4798","instance":4798,"id":191469,"goal":"lemma SeqMapLen_4798(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_4799","instance":4799,"id":191470,"goal":"lemma SeqFilterLe_4799(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_4800","instance":4800,"id":191471,"goal":"lemma SeqMemberAppend_4800(s: seq, ys: seq)\n ensures x in s + ys <==> x in s || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_4801","instance":4801,"id":191472,"goal":"lemma SeqAppendLen_4801(s: seq, zs: seq)\n ensures |s + zs| == |s| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_4802","instance":4802,"id":191473,"goal":"lemma SeqAppendNil_4802(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_4803","instance":4803,"id":191474,"goal":"lemma SeqNilAppend_4803(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_4804","instance":4804,"id":191475,"goal":"lemma SeqAppendAssoc_4804(t: seq, xs: seq, zs: seq)\n ensures (t + xs) + zs == t + (xs + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_4805","instance":4805,"id":191476,"goal":"lemma SeqTakeDrop_4805(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_4806","instance":4806,"id":191477,"goal":"lemma SeqReverseLen_4806(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_4807","instance":4807,"id":191478,"goal":"lemma SeqReverseIdem_4807(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_4808","instance":4808,"id":191479,"goal":"lemma SeqMapLen_4808(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_4809","instance":4809,"id":191480,"goal":"lemma SeqFilterLe_4809(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_4810","instance":4810,"id":191481,"goal":"lemma SeqMemberAppend_4810(xs: seq, ys: seq)\n ensures x in xs + ys <==> x in xs || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_4811","instance":4811,"id":191482,"goal":"lemma SeqAppendLen_4811(zs: seq, t: seq)\n ensures |zs + t| == |zs| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_4812","instance":4812,"id":191483,"goal":"lemma SeqAppendNil_4812(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_4813","instance":4813,"id":191484,"goal":"lemma SeqNilAppend_4813(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_4814","instance":4814,"id":191485,"goal":"lemma SeqAppendAssoc_4814(t: seq, zs: seq, xs: seq)\n ensures (t + zs) + xs == t + (zs + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_4815","instance":4815,"id":191486,"goal":"lemma SeqTakeDrop_4815(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_4816","instance":4816,"id":191487,"goal":"lemma SeqReverseLen_4816(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_4817","instance":4817,"id":191488,"goal":"lemma SeqReverseIdem_4817(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_4818","instance":4818,"id":191489,"goal":"lemma SeqMapLen_4818(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_4819","instance":4819,"id":191490,"goal":"lemma SeqFilterLe_4819(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_4820","instance":4820,"id":191491,"goal":"lemma SeqMemberAppend_4820(xs: seq, zs: seq)\n ensures x in xs + zs <==> x in xs || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_4821","instance":4821,"id":191492,"goal":"lemma SeqAppendLen_4821(s: seq, xs: seq)\n ensures |s + xs| == |s| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_4822","instance":4822,"id":191493,"goal":"lemma SeqAppendNil_4822(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_4823","instance":4823,"id":191494,"goal":"lemma SeqNilAppend_4823(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_4824","instance":4824,"id":191495,"goal":"lemma SeqAppendAssoc_4824(xs: seq, s: seq, zs: seq)\n ensures (xs + s) + zs == xs + (s + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_4825","instance":4825,"id":191496,"goal":"lemma SeqTakeDrop_4825(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_4826","instance":4826,"id":191497,"goal":"lemma SeqReverseLen_4826(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_4827","instance":4827,"id":191498,"goal":"lemma SeqReverseIdem_4827(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_4828","instance":4828,"id":191499,"goal":"lemma SeqMapLen_4828(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_4829","instance":4829,"id":191500,"goal":"lemma SeqFilterLe_4829(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_4830","instance":4830,"id":191501,"goal":"lemma SeqMemberAppend_4830(ys: seq, zs: seq)\n ensures x in ys + zs <==> x in ys || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_4831","instance":4831,"id":191502,"goal":"lemma SeqAppendLen_4831(xs: seq, s: seq)\n ensures |xs + s| == |xs| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_4832","instance":4832,"id":191503,"goal":"lemma SeqAppendNil_4832(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_4833","instance":4833,"id":191504,"goal":"lemma SeqNilAppend_4833(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_4834","instance":4834,"id":191505,"goal":"lemma SeqAppendAssoc_4834(u: seq, ys: seq, xs: seq)\n ensures (u + ys) + xs == u + (ys + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_4835","instance":4835,"id":191506,"goal":"lemma SeqTakeDrop_4835(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_4836","instance":4836,"id":191507,"goal":"lemma SeqReverseLen_4836(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_4837","instance":4837,"id":191508,"goal":"lemma SeqReverseIdem_4837(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_4838","instance":4838,"id":191509,"goal":"lemma SeqMapLen_4838(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_4839","instance":4839,"id":191510,"goal":"lemma SeqFilterLe_4839(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_4840","instance":4840,"id":191511,"goal":"lemma SeqMemberAppend_4840(u: seq, t: seq)\n ensures x in u + t <==> x in u || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_4841","instance":4841,"id":191512,"goal":"lemma SeqAppendLen_4841(t: seq, ys: seq)\n ensures |t + ys| == |t| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_4842","instance":4842,"id":191513,"goal":"lemma SeqAppendNil_4842(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_4843","instance":4843,"id":191514,"goal":"lemma SeqNilAppend_4843(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_4844","instance":4844,"id":191515,"goal":"lemma SeqAppendAssoc_4844(zs: seq, s: seq, t: seq)\n ensures (zs + s) + t == zs + (s + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_4845","instance":4845,"id":191516,"goal":"lemma SeqTakeDrop_4845(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_4846","instance":4846,"id":191517,"goal":"lemma SeqReverseLen_4846(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_4847","instance":4847,"id":191518,"goal":"lemma SeqReverseIdem_4847(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_4848","instance":4848,"id":191519,"goal":"lemma SeqMapLen_4848(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_4849","instance":4849,"id":191520,"goal":"lemma SeqFilterLe_4849(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_4850","instance":4850,"id":191521,"goal":"lemma SeqMemberAppend_4850(u: seq, ys: seq)\n ensures x in u + ys <==> x in u || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_4851","instance":4851,"id":191522,"goal":"lemma SeqAppendLen_4851(s: seq, ys: seq)\n ensures |s + ys| == |s| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_4852","instance":4852,"id":191523,"goal":"lemma SeqAppendNil_4852(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_4853","instance":4853,"id":191524,"goal":"lemma SeqNilAppend_4853(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_4854","instance":4854,"id":191525,"goal":"lemma SeqAppendAssoc_4854(zs: seq, t: seq, xs: seq)\n ensures (zs + t) + xs == zs + (t + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_4855","instance":4855,"id":191526,"goal":"lemma SeqTakeDrop_4855(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_4856","instance":4856,"id":191527,"goal":"lemma SeqReverseLen_4856(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_4857","instance":4857,"id":191528,"goal":"lemma SeqReverseIdem_4857(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_4858","instance":4858,"id":191529,"goal":"lemma SeqMapLen_4858(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_4859","instance":4859,"id":191530,"goal":"lemma SeqFilterLe_4859(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_4860","instance":4860,"id":191531,"goal":"lemma SeqMemberAppend_4860(zs: seq, t: seq)\n ensures x in zs + t <==> x in zs || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_4861","instance":4861,"id":191532,"goal":"lemma SeqAppendLen_4861(zs: seq, u: seq)\n ensures |zs + u| == |zs| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_4862","instance":4862,"id":191533,"goal":"lemma SeqAppendNil_4862(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_4863","instance":4863,"id":191534,"goal":"lemma SeqNilAppend_4863(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_4864","instance":4864,"id":191535,"goal":"lemma SeqAppendAssoc_4864(t: seq, ys: seq, s: seq)\n ensures (t + ys) + s == t + (ys + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_4865","instance":4865,"id":191536,"goal":"lemma SeqTakeDrop_4865(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_4866","instance":4866,"id":191537,"goal":"lemma SeqReverseLen_4866(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_4867","instance":4867,"id":191538,"goal":"lemma SeqReverseIdem_4867(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_4868","instance":4868,"id":191539,"goal":"lemma SeqMapLen_4868(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_4869","instance":4869,"id":191540,"goal":"lemma SeqFilterLe_4869(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_4870","instance":4870,"id":191541,"goal":"lemma SeqMemberAppend_4870(s: seq, xs: seq)\n ensures x in s + xs <==> x in s || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_4871","instance":4871,"id":191542,"goal":"lemma SeqAppendLen_4871(s: seq, xs: seq)\n ensures |s + xs| == |s| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_4872","instance":4872,"id":191543,"goal":"lemma SeqAppendNil_4872(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_4873","instance":4873,"id":191544,"goal":"lemma SeqNilAppend_4873(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_4874","instance":4874,"id":191545,"goal":"lemma SeqAppendAssoc_4874(t: seq, zs: seq, u: seq)\n ensures (t + zs) + u == t + (zs + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_4875","instance":4875,"id":191546,"goal":"lemma SeqTakeDrop_4875(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_4876","instance":4876,"id":191547,"goal":"lemma SeqReverseLen_4876(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_4877","instance":4877,"id":191548,"goal":"lemma SeqReverseIdem_4877(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_4878","instance":4878,"id":191549,"goal":"lemma SeqMapLen_4878(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_4879","instance":4879,"id":191550,"goal":"lemma SeqFilterLe_4879(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_4880","instance":4880,"id":191551,"goal":"lemma SeqMemberAppend_4880(u: seq, s: seq)\n ensures x in u + s <==> x in u || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_4881","instance":4881,"id":191552,"goal":"lemma SeqAppendLen_4881(u: seq, xs: seq)\n ensures |u + xs| == |u| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_4882","instance":4882,"id":191553,"goal":"lemma SeqAppendNil_4882(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_4883","instance":4883,"id":191554,"goal":"lemma SeqNilAppend_4883(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_4884","instance":4884,"id":191555,"goal":"lemma SeqAppendAssoc_4884(u: seq, xs: seq, zs: seq)\n ensures (u + xs) + zs == u + (xs + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_4885","instance":4885,"id":191556,"goal":"lemma SeqTakeDrop_4885(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_4886","instance":4886,"id":191557,"goal":"lemma SeqReverseLen_4886(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_4887","instance":4887,"id":191558,"goal":"lemma SeqReverseIdem_4887(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_4888","instance":4888,"id":191559,"goal":"lemma SeqMapLen_4888(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_4889","instance":4889,"id":191560,"goal":"lemma SeqFilterLe_4889(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_4890","instance":4890,"id":191561,"goal":"lemma SeqMemberAppend_4890(ys: seq, u: seq)\n ensures x in ys + u <==> x in ys || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_4891","instance":4891,"id":191562,"goal":"lemma SeqAppendLen_4891(ys: seq, zs: seq)\n ensures |ys + zs| == |ys| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_4892","instance":4892,"id":191563,"goal":"lemma SeqAppendNil_4892(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_4893","instance":4893,"id":191564,"goal":"lemma SeqNilAppend_4893(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_4894","instance":4894,"id":191565,"goal":"lemma SeqAppendAssoc_4894(t: seq, u: seq, zs: seq)\n ensures (t + u) + zs == t + (u + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_4895","instance":4895,"id":191566,"goal":"lemma SeqTakeDrop_4895(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_4896","instance":4896,"id":191567,"goal":"lemma SeqReverseLen_4896(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_4897","instance":4897,"id":191568,"goal":"lemma SeqReverseIdem_4897(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_4898","instance":4898,"id":191569,"goal":"lemma SeqMapLen_4898(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_4899","instance":4899,"id":191570,"goal":"lemma SeqFilterLe_4899(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_4900","instance":4900,"id":191571,"goal":"lemma SeqMemberAppend_4900(t: seq, s: seq)\n ensures x in t + s <==> x in t || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_4901","instance":4901,"id":191572,"goal":"lemma SeqAppendLen_4901(s: seq, ys: seq)\n ensures |s + ys| == |s| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_4902","instance":4902,"id":191573,"goal":"lemma SeqAppendNil_4902(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_4903","instance":4903,"id":191574,"goal":"lemma SeqNilAppend_4903(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_4904","instance":4904,"id":191575,"goal":"lemma SeqAppendAssoc_4904(t: seq, ys: seq, xs: seq)\n ensures (t + ys) + xs == t + (ys + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_4905","instance":4905,"id":191576,"goal":"lemma SeqTakeDrop_4905(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_4906","instance":4906,"id":191577,"goal":"lemma SeqReverseLen_4906(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_4907","instance":4907,"id":191578,"goal":"lemma SeqReverseIdem_4907(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_4908","instance":4908,"id":191579,"goal":"lemma SeqMapLen_4908(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_4909","instance":4909,"id":191580,"goal":"lemma SeqFilterLe_4909(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_4910","instance":4910,"id":191581,"goal":"lemma SeqMemberAppend_4910(ys: seq, xs: seq)\n ensures x in ys + xs <==> x in ys || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_4911","instance":4911,"id":191582,"goal":"lemma SeqAppendLen_4911(u: seq, ys: seq)\n ensures |u + ys| == |u| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_4912","instance":4912,"id":191583,"goal":"lemma SeqAppendNil_4912(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_4913","instance":4913,"id":191584,"goal":"lemma SeqNilAppend_4913(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_4914","instance":4914,"id":191585,"goal":"lemma SeqAppendAssoc_4914(u: seq, ys: seq, xs: seq)\n ensures (u + ys) + xs == u + (ys + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_4915","instance":4915,"id":191586,"goal":"lemma SeqTakeDrop_4915(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_4916","instance":4916,"id":191587,"goal":"lemma SeqReverseLen_4916(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_4917","instance":4917,"id":191588,"goal":"lemma SeqReverseIdem_4917(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_4918","instance":4918,"id":191589,"goal":"lemma SeqMapLen_4918(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_4919","instance":4919,"id":191590,"goal":"lemma SeqFilterLe_4919(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_4920","instance":4920,"id":191591,"goal":"lemma SeqMemberAppend_4920(s: seq, t: seq)\n ensures x in s + t <==> x in s || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_4921","instance":4921,"id":191592,"goal":"lemma SeqAppendLen_4921(zs: seq, ys: seq)\n ensures |zs + ys| == |zs| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_4922","instance":4922,"id":191593,"goal":"lemma SeqAppendNil_4922(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_4923","instance":4923,"id":191594,"goal":"lemma SeqNilAppend_4923(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_4924","instance":4924,"id":191595,"goal":"lemma SeqAppendAssoc_4924(xs: seq, zs: seq, ys: seq)\n ensures (xs + zs) + ys == xs + (zs + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_4925","instance":4925,"id":191596,"goal":"lemma SeqTakeDrop_4925(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_4926","instance":4926,"id":191597,"goal":"lemma SeqReverseLen_4926(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_4927","instance":4927,"id":191598,"goal":"lemma SeqReverseIdem_4927(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_4928","instance":4928,"id":191599,"goal":"lemma SeqMapLen_4928(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_4929","instance":4929,"id":191600,"goal":"lemma SeqFilterLe_4929(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_4930","instance":4930,"id":191601,"goal":"lemma SeqMemberAppend_4930(u: seq, zs: seq)\n ensures x in u + zs <==> x in u || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_4931","instance":4931,"id":191602,"goal":"lemma SeqAppendLen_4931(t: seq, s: seq)\n ensures |t + s| == |t| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_4932","instance":4932,"id":191603,"goal":"lemma SeqAppendNil_4932(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_4933","instance":4933,"id":191604,"goal":"lemma SeqNilAppend_4933(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_4934","instance":4934,"id":191605,"goal":"lemma SeqAppendAssoc_4934(xs: seq, s: seq, u: seq)\n ensures (xs + s) + u == xs + (s + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_4935","instance":4935,"id":191606,"goal":"lemma SeqTakeDrop_4935(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_4936","instance":4936,"id":191607,"goal":"lemma SeqReverseLen_4936(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_4937","instance":4937,"id":191608,"goal":"lemma SeqReverseIdem_4937(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_4938","instance":4938,"id":191609,"goal":"lemma SeqMapLen_4938(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_4939","instance":4939,"id":191610,"goal":"lemma SeqFilterLe_4939(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_4940","instance":4940,"id":191611,"goal":"lemma SeqMemberAppend_4940(xs: seq, ys: seq)\n ensures x in xs + ys <==> x in xs || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_4941","instance":4941,"id":191612,"goal":"lemma SeqAppendLen_4941(t: seq, ys: seq)\n ensures |t + ys| == |t| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_4942","instance":4942,"id":191613,"goal":"lemma SeqAppendNil_4942(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_4943","instance":4943,"id":191614,"goal":"lemma SeqNilAppend_4943(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_4944","instance":4944,"id":191615,"goal":"lemma SeqAppendAssoc_4944(xs: seq, u: seq, t: seq)\n ensures (xs + u) + t == xs + (u + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_4945","instance":4945,"id":191616,"goal":"lemma SeqTakeDrop_4945(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_4946","instance":4946,"id":191617,"goal":"lemma SeqReverseLen_4946(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_4947","instance":4947,"id":191618,"goal":"lemma SeqReverseIdem_4947(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_4948","instance":4948,"id":191619,"goal":"lemma SeqMapLen_4948(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_4949","instance":4949,"id":191620,"goal":"lemma SeqFilterLe_4949(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_4950","instance":4950,"id":191621,"goal":"lemma SeqMemberAppend_4950(u: seq, zs: seq)\n ensures x in u + zs <==> x in u || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_4951","instance":4951,"id":191622,"goal":"lemma SeqAppendLen_4951(s: seq, xs: seq)\n ensures |s + xs| == |s| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_4952","instance":4952,"id":191623,"goal":"lemma SeqAppendNil_4952(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_4953","instance":4953,"id":191624,"goal":"lemma SeqNilAppend_4953(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_4954","instance":4954,"id":191625,"goal":"lemma SeqAppendAssoc_4954(u: seq, xs: seq, s: seq)\n ensures (u + xs) + s == u + (xs + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_4955","instance":4955,"id":191626,"goal":"lemma SeqTakeDrop_4955(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_4956","instance":4956,"id":191627,"goal":"lemma SeqReverseLen_4956(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_4957","instance":4957,"id":191628,"goal":"lemma SeqReverseIdem_4957(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_4958","instance":4958,"id":191629,"goal":"lemma SeqMapLen_4958(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_4959","instance":4959,"id":191630,"goal":"lemma SeqFilterLe_4959(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_4960","instance":4960,"id":191631,"goal":"lemma SeqMemberAppend_4960(zs: seq, ys: seq)\n ensures x in zs + ys <==> x in zs || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_4961","instance":4961,"id":191632,"goal":"lemma SeqAppendLen_4961(u: seq, zs: seq)\n ensures |u + zs| == |u| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_4962","instance":4962,"id":191633,"goal":"lemma SeqAppendNil_4962(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_4963","instance":4963,"id":191634,"goal":"lemma SeqNilAppend_4963(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_4964","instance":4964,"id":191635,"goal":"lemma SeqAppendAssoc_4964(t: seq, s: seq, zs: seq)\n ensures (t + s) + zs == t + (s + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_4965","instance":4965,"id":191636,"goal":"lemma SeqTakeDrop_4965(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_4966","instance":4966,"id":191637,"goal":"lemma SeqReverseLen_4966(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_4967","instance":4967,"id":191638,"goal":"lemma SeqReverseIdem_4967(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_4968","instance":4968,"id":191639,"goal":"lemma SeqMapLen_4968(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_4969","instance":4969,"id":191640,"goal":"lemma SeqFilterLe_4969(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_4970","instance":4970,"id":191641,"goal":"lemma SeqMemberAppend_4970(u: seq, s: seq)\n ensures x in u + s <==> x in u || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_4971","instance":4971,"id":191642,"goal":"lemma SeqAppendLen_4971(ys: seq, xs: seq)\n ensures |ys + xs| == |ys| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_4972","instance":4972,"id":191643,"goal":"lemma SeqAppendNil_4972(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_4973","instance":4973,"id":191644,"goal":"lemma SeqNilAppend_4973(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_4974","instance":4974,"id":191645,"goal":"lemma SeqAppendAssoc_4974(t: seq, s: seq, ys: seq)\n ensures (t + s) + ys == t + (s + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_4975","instance":4975,"id":191646,"goal":"lemma SeqTakeDrop_4975(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_4976","instance":4976,"id":191647,"goal":"lemma SeqReverseLen_4976(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_4977","instance":4977,"id":191648,"goal":"lemma SeqReverseIdem_4977(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_4978","instance":4978,"id":191649,"goal":"lemma SeqMapLen_4978(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_4979","instance":4979,"id":191650,"goal":"lemma SeqFilterLe_4979(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_4980","instance":4980,"id":191651,"goal":"lemma SeqMemberAppend_4980(t: seq, zs: seq)\n ensures x in t + zs <==> x in t || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_4981","instance":4981,"id":191652,"goal":"lemma SeqAppendLen_4981(t: seq, ys: seq)\n ensures |t + ys| == |t| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_4982","instance":4982,"id":191653,"goal":"lemma SeqAppendNil_4982(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_4983","instance":4983,"id":191654,"goal":"lemma SeqNilAppend_4983(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_4984","instance":4984,"id":191655,"goal":"lemma SeqAppendAssoc_4984(t: seq, u: seq, s: seq)\n ensures (t + u) + s == t + (u + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_4985","instance":4985,"id":191656,"goal":"lemma SeqTakeDrop_4985(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_4986","instance":4986,"id":191657,"goal":"lemma SeqReverseLen_4986(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_4987","instance":4987,"id":191658,"goal":"lemma SeqReverseIdem_4987(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_4988","instance":4988,"id":191659,"goal":"lemma SeqMapLen_4988(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_4989","instance":4989,"id":191660,"goal":"lemma SeqFilterLe_4989(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_4990","instance":4990,"id":191661,"goal":"lemma SeqMemberAppend_4990(s: seq, t: seq)\n ensures x in s + t <==> x in s || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_4991","instance":4991,"id":191662,"goal":"lemma SeqAppendLen_4991(zs: seq, u: seq)\n ensures |zs + u| == |zs| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_4992","instance":4992,"id":191663,"goal":"lemma SeqAppendNil_4992(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_4993","instance":4993,"id":191664,"goal":"lemma SeqNilAppend_4993(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_4994","instance":4994,"id":191665,"goal":"lemma SeqAppendAssoc_4994(zs: seq, ys: seq, xs: seq)\n ensures (zs + ys) + xs == zs + (ys + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_4995","instance":4995,"id":191666,"goal":"lemma SeqTakeDrop_4995(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_4996","instance":4996,"id":191667,"goal":"lemma SeqReverseLen_4996(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_4997","instance":4997,"id":191668,"goal":"lemma SeqReverseIdem_4997(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_4998","instance":4998,"id":191669,"goal":"lemma SeqMapLen_4998(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_4999","instance":4999,"id":191670,"goal":"lemma SeqFilterLe_4999(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_5000","instance":5000,"id":191671,"goal":"lemma SeqMemberAppend_5000(zs: seq, xs: seq)\n ensures x in zs + xs <==> x in zs || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_5001","instance":5001,"id":191672,"goal":"lemma SeqAppendLen_5001(u: seq, xs: seq)\n ensures |u + xs| == |u| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_5002","instance":5002,"id":191673,"goal":"lemma SeqAppendNil_5002(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_5003","instance":5003,"id":191674,"goal":"lemma SeqNilAppend_5003(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_5004","instance":5004,"id":191675,"goal":"lemma SeqAppendAssoc_5004(xs: seq, zs: seq, s: seq)\n ensures (xs + zs) + s == xs + (zs + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_5005","instance":5005,"id":191676,"goal":"lemma SeqTakeDrop_5005(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_5006","instance":5006,"id":191677,"goal":"lemma SeqReverseLen_5006(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_5007","instance":5007,"id":191678,"goal":"lemma SeqReverseIdem_5007(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_5008","instance":5008,"id":191679,"goal":"lemma SeqMapLen_5008(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_5009","instance":5009,"id":191680,"goal":"lemma SeqFilterLe_5009(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_5010","instance":5010,"id":191681,"goal":"lemma SeqMemberAppend_5010(ys: seq, t: seq)\n ensures x in ys + t <==> x in ys || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_5011","instance":5011,"id":191682,"goal":"lemma SeqAppendLen_5011(t: seq, u: seq)\n ensures |t + u| == |t| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_5012","instance":5012,"id":191683,"goal":"lemma SeqAppendNil_5012(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_5013","instance":5013,"id":191684,"goal":"lemma SeqNilAppend_5013(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_5014","instance":5014,"id":191685,"goal":"lemma SeqAppendAssoc_5014(u: seq, xs: seq, ys: seq)\n ensures (u + xs) + ys == u + (xs + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_5015","instance":5015,"id":191686,"goal":"lemma SeqTakeDrop_5015(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_5016","instance":5016,"id":191687,"goal":"lemma SeqReverseLen_5016(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_5017","instance":5017,"id":191688,"goal":"lemma SeqReverseIdem_5017(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_5018","instance":5018,"id":191689,"goal":"lemma SeqMapLen_5018(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_5019","instance":5019,"id":191690,"goal":"lemma SeqFilterLe_5019(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_5020","instance":5020,"id":191691,"goal":"lemma SeqMemberAppend_5020(ys: seq, s: seq)\n ensures x in ys + s <==> x in ys || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_5021","instance":5021,"id":191692,"goal":"lemma SeqAppendLen_5021(s: seq, ys: seq)\n ensures |s + ys| == |s| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_5022","instance":5022,"id":191693,"goal":"lemma SeqAppendNil_5022(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_5023","instance":5023,"id":191694,"goal":"lemma SeqNilAppend_5023(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_5024","instance":5024,"id":191695,"goal":"lemma SeqAppendAssoc_5024(xs: seq, u: seq, ys: seq)\n ensures (xs + u) + ys == xs + (u + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_5025","instance":5025,"id":191696,"goal":"lemma SeqTakeDrop_5025(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_5026","instance":5026,"id":191697,"goal":"lemma SeqReverseLen_5026(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_5027","instance":5027,"id":191698,"goal":"lemma SeqReverseIdem_5027(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_5028","instance":5028,"id":191699,"goal":"lemma SeqMapLen_5028(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_5029","instance":5029,"id":191700,"goal":"lemma SeqFilterLe_5029(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_5030","instance":5030,"id":191701,"goal":"lemma SeqMemberAppend_5030(ys: seq, t: seq)\n ensures x in ys + t <==> x in ys || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_5031","instance":5031,"id":191702,"goal":"lemma SeqAppendLen_5031(s: seq, u: seq)\n ensures |s + u| == |s| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_5032","instance":5032,"id":191703,"goal":"lemma SeqAppendNil_5032(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_5033","instance":5033,"id":191704,"goal":"lemma SeqNilAppend_5033(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_5034","instance":5034,"id":191705,"goal":"lemma SeqAppendAssoc_5034(zs: seq, ys: seq, xs: seq)\n ensures (zs + ys) + xs == zs + (ys + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_5035","instance":5035,"id":191706,"goal":"lemma SeqTakeDrop_5035(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_5036","instance":5036,"id":191707,"goal":"lemma SeqReverseLen_5036(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_5037","instance":5037,"id":191708,"goal":"lemma SeqReverseIdem_5037(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_5038","instance":5038,"id":191709,"goal":"lemma SeqMapLen_5038(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_5039","instance":5039,"id":191710,"goal":"lemma SeqFilterLe_5039(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_5040","instance":5040,"id":191711,"goal":"lemma SeqMemberAppend_5040(t: seq, u: seq)\n ensures x in t + u <==> x in t || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_5041","instance":5041,"id":191712,"goal":"lemma SeqAppendLen_5041(s: seq, ys: seq)\n ensures |s + ys| == |s| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_5042","instance":5042,"id":191713,"goal":"lemma SeqAppendNil_5042(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_5043","instance":5043,"id":191714,"goal":"lemma SeqNilAppend_5043(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_5044","instance":5044,"id":191715,"goal":"lemma SeqAppendAssoc_5044(u: seq, t: seq, ys: seq)\n ensures (u + t) + ys == u + (t + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_5045","instance":5045,"id":191716,"goal":"lemma SeqTakeDrop_5045(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_5046","instance":5046,"id":191717,"goal":"lemma SeqReverseLen_5046(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_5047","instance":5047,"id":191718,"goal":"lemma SeqReverseIdem_5047(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_5048","instance":5048,"id":191719,"goal":"lemma SeqMapLen_5048(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_5049","instance":5049,"id":191720,"goal":"lemma SeqFilterLe_5049(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_5050","instance":5050,"id":191721,"goal":"lemma SeqMemberAppend_5050(u: seq, s: seq)\n ensures x in u + s <==> x in u || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_5051","instance":5051,"id":191722,"goal":"lemma SeqAppendLen_5051(zs: seq, t: seq)\n ensures |zs + t| == |zs| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_5052","instance":5052,"id":191723,"goal":"lemma SeqAppendNil_5052(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_5053","instance":5053,"id":191724,"goal":"lemma SeqNilAppend_5053(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_5054","instance":5054,"id":191725,"goal":"lemma SeqAppendAssoc_5054(u: seq, xs: seq, s: seq)\n ensures (u + xs) + s == u + (xs + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_5055","instance":5055,"id":191726,"goal":"lemma SeqTakeDrop_5055(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_5056","instance":5056,"id":191727,"goal":"lemma SeqReverseLen_5056(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_5057","instance":5057,"id":191728,"goal":"lemma SeqReverseIdem_5057(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_5058","instance":5058,"id":191729,"goal":"lemma SeqMapLen_5058(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_5059","instance":5059,"id":191730,"goal":"lemma SeqFilterLe_5059(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_5060","instance":5060,"id":191731,"goal":"lemma SeqMemberAppend_5060(u: seq, xs: seq)\n ensures x in u + xs <==> x in u || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_5061","instance":5061,"id":191732,"goal":"lemma SeqAppendLen_5061(xs: seq, t: seq)\n ensures |xs + t| == |xs| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_5062","instance":5062,"id":191733,"goal":"lemma SeqAppendNil_5062(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_5063","instance":5063,"id":191734,"goal":"lemma SeqNilAppend_5063(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_5064","instance":5064,"id":191735,"goal":"lemma SeqAppendAssoc_5064(ys: seq, u: seq, xs: seq)\n ensures (ys + u) + xs == ys + (u + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_5065","instance":5065,"id":191736,"goal":"lemma SeqTakeDrop_5065(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_5066","instance":5066,"id":191737,"goal":"lemma SeqReverseLen_5066(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_5067","instance":5067,"id":191738,"goal":"lemma SeqReverseIdem_5067(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_5068","instance":5068,"id":191739,"goal":"lemma SeqMapLen_5068(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_5069","instance":5069,"id":191740,"goal":"lemma SeqFilterLe_5069(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_5070","instance":5070,"id":191741,"goal":"lemma SeqMemberAppend_5070(xs: seq, ys: seq)\n ensures x in xs + ys <==> x in xs || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_5071","instance":5071,"id":191742,"goal":"lemma SeqAppendLen_5071(u: seq, t: seq)\n ensures |u + t| == |u| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_5072","instance":5072,"id":191743,"goal":"lemma SeqAppendNil_5072(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_5073","instance":5073,"id":191744,"goal":"lemma SeqNilAppend_5073(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_5074","instance":5074,"id":191745,"goal":"lemma SeqAppendAssoc_5074(ys: seq, t: seq, s: seq)\n ensures (ys + t) + s == ys + (t + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_5075","instance":5075,"id":191746,"goal":"lemma SeqTakeDrop_5075(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_5076","instance":5076,"id":191747,"goal":"lemma SeqReverseLen_5076(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_5077","instance":5077,"id":191748,"goal":"lemma SeqReverseIdem_5077(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_5078","instance":5078,"id":191749,"goal":"lemma SeqMapLen_5078(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_5079","instance":5079,"id":191750,"goal":"lemma SeqFilterLe_5079(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_5080","instance":5080,"id":191751,"goal":"lemma SeqMemberAppend_5080(s: seq, u: seq)\n ensures x in s + u <==> x in s || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_5081","instance":5081,"id":191752,"goal":"lemma SeqAppendLen_5081(t: seq, s: seq)\n ensures |t + s| == |t| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_5082","instance":5082,"id":191753,"goal":"lemma SeqAppendNil_5082(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_5083","instance":5083,"id":191754,"goal":"lemma SeqNilAppend_5083(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_5084","instance":5084,"id":191755,"goal":"lemma SeqAppendAssoc_5084(xs: seq, zs: seq, t: seq)\n ensures (xs + zs) + t == xs + (zs + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_5085","instance":5085,"id":191756,"goal":"lemma SeqTakeDrop_5085(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_5086","instance":5086,"id":191757,"goal":"lemma SeqReverseLen_5086(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_5087","instance":5087,"id":191758,"goal":"lemma SeqReverseIdem_5087(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_5088","instance":5088,"id":191759,"goal":"lemma SeqMapLen_5088(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_5089","instance":5089,"id":191760,"goal":"lemma SeqFilterLe_5089(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_5090","instance":5090,"id":191761,"goal":"lemma SeqMemberAppend_5090(xs: seq, ys: seq)\n ensures x in xs + ys <==> x in xs || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_5091","instance":5091,"id":191762,"goal":"lemma SeqAppendLen_5091(xs: seq, ys: seq)\n ensures |xs + ys| == |xs| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_5092","instance":5092,"id":191763,"goal":"lemma SeqAppendNil_5092(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_5093","instance":5093,"id":191764,"goal":"lemma SeqNilAppend_5093(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_5094","instance":5094,"id":191765,"goal":"lemma SeqAppendAssoc_5094(ys: seq, t: seq, s: seq)\n ensures (ys + t) + s == ys + (t + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_5095","instance":5095,"id":191766,"goal":"lemma SeqTakeDrop_5095(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_5096","instance":5096,"id":191767,"goal":"lemma SeqReverseLen_5096(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_5097","instance":5097,"id":191768,"goal":"lemma SeqReverseIdem_5097(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_5098","instance":5098,"id":191769,"goal":"lemma SeqMapLen_5098(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_5099","instance":5099,"id":191770,"goal":"lemma SeqFilterLe_5099(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_5100","instance":5100,"id":191771,"goal":"lemma SeqMemberAppend_5100(u: seq, ys: seq)\n ensures x in u + ys <==> x in u || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_5101","instance":5101,"id":191772,"goal":"lemma SeqAppendLen_5101(u: seq, zs: seq)\n ensures |u + zs| == |u| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_5102","instance":5102,"id":191773,"goal":"lemma SeqAppendNil_5102(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_5103","instance":5103,"id":191774,"goal":"lemma SeqNilAppend_5103(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_5104","instance":5104,"id":191775,"goal":"lemma SeqAppendAssoc_5104(u: seq, ys: seq, xs: seq)\n ensures (u + ys) + xs == u + (ys + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_5105","instance":5105,"id":191776,"goal":"lemma SeqTakeDrop_5105(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_5106","instance":5106,"id":191777,"goal":"lemma SeqReverseLen_5106(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_5107","instance":5107,"id":191778,"goal":"lemma SeqReverseIdem_5107(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_5108","instance":5108,"id":191779,"goal":"lemma SeqMapLen_5108(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_5109","instance":5109,"id":191780,"goal":"lemma SeqFilterLe_5109(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_5110","instance":5110,"id":191781,"goal":"lemma SeqMemberAppend_5110(t: seq, xs: seq)\n ensures x in t + xs <==> x in t || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_5111","instance":5111,"id":191782,"goal":"lemma SeqAppendLen_5111(zs: seq, s: seq)\n ensures |zs + s| == |zs| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_5112","instance":5112,"id":191783,"goal":"lemma SeqAppendNil_5112(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_5113","instance":5113,"id":191784,"goal":"lemma SeqNilAppend_5113(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_5114","instance":5114,"id":191785,"goal":"lemma SeqAppendAssoc_5114(ys: seq, zs: seq, u: seq)\n ensures (ys + zs) + u == ys + (zs + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_5115","instance":5115,"id":191786,"goal":"lemma SeqTakeDrop_5115(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_5116","instance":5116,"id":191787,"goal":"lemma SeqReverseLen_5116(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_5117","instance":5117,"id":191788,"goal":"lemma SeqReverseIdem_5117(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_5118","instance":5118,"id":191789,"goal":"lemma SeqMapLen_5118(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_5119","instance":5119,"id":191790,"goal":"lemma SeqFilterLe_5119(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_5120","instance":5120,"id":191791,"goal":"lemma SeqMemberAppend_5120(t: seq, u: seq)\n ensures x in t + u <==> x in t || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_5121","instance":5121,"id":191792,"goal":"lemma SeqAppendLen_5121(xs: seq, t: seq)\n ensures |xs + t| == |xs| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_5122","instance":5122,"id":191793,"goal":"lemma SeqAppendNil_5122(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_5123","instance":5123,"id":191794,"goal":"lemma SeqNilAppend_5123(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_5124","instance":5124,"id":191795,"goal":"lemma SeqAppendAssoc_5124(t: seq, s: seq, u: seq)\n ensures (t + s) + u == t + (s + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_5125","instance":5125,"id":191796,"goal":"lemma SeqTakeDrop_5125(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_5126","instance":5126,"id":191797,"goal":"lemma SeqReverseLen_5126(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_5127","instance":5127,"id":191798,"goal":"lemma SeqReverseIdem_5127(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_5128","instance":5128,"id":191799,"goal":"lemma SeqMapLen_5128(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_5129","instance":5129,"id":191800,"goal":"lemma SeqFilterLe_5129(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_5130","instance":5130,"id":191801,"goal":"lemma SeqMemberAppend_5130(t: seq, u: seq)\n ensures x in t + u <==> x in t || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_5131","instance":5131,"id":191802,"goal":"lemma SeqAppendLen_5131(ys: seq, t: seq)\n ensures |ys + t| == |ys| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_5132","instance":5132,"id":191803,"goal":"lemma SeqAppendNil_5132(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_5133","instance":5133,"id":191804,"goal":"lemma SeqNilAppend_5133(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_5134","instance":5134,"id":191805,"goal":"lemma SeqAppendAssoc_5134(s: seq, u: seq, t: seq)\n ensures (s + u) + t == s + (u + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_5135","instance":5135,"id":191806,"goal":"lemma SeqTakeDrop_5135(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_5136","instance":5136,"id":191807,"goal":"lemma SeqReverseLen_5136(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_5137","instance":5137,"id":191808,"goal":"lemma SeqReverseIdem_5137(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_5138","instance":5138,"id":191809,"goal":"lemma SeqMapLen_5138(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_5139","instance":5139,"id":191810,"goal":"lemma SeqFilterLe_5139(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_5140","instance":5140,"id":191811,"goal":"lemma SeqMemberAppend_5140(ys: seq, xs: seq)\n ensures x in ys + xs <==> x in ys || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_5141","instance":5141,"id":191812,"goal":"lemma SeqAppendLen_5141(xs: seq, zs: seq)\n ensures |xs + zs| == |xs| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_5142","instance":5142,"id":191813,"goal":"lemma SeqAppendNil_5142(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_5143","instance":5143,"id":191814,"goal":"lemma SeqNilAppend_5143(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_5144","instance":5144,"id":191815,"goal":"lemma SeqAppendAssoc_5144(s: seq, ys: seq, t: seq)\n ensures (s + ys) + t == s + (ys + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_5145","instance":5145,"id":191816,"goal":"lemma SeqTakeDrop_5145(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_5146","instance":5146,"id":191817,"goal":"lemma SeqReverseLen_5146(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_5147","instance":5147,"id":191818,"goal":"lemma SeqReverseIdem_5147(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_5148","instance":5148,"id":191819,"goal":"lemma SeqMapLen_5148(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_5149","instance":5149,"id":191820,"goal":"lemma SeqFilterLe_5149(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_5150","instance":5150,"id":191821,"goal":"lemma SeqMemberAppend_5150(zs: seq, xs: seq)\n ensures x in zs + xs <==> x in zs || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_5151","instance":5151,"id":191822,"goal":"lemma SeqAppendLen_5151(t: seq, s: seq)\n ensures |t + s| == |t| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_5152","instance":5152,"id":191823,"goal":"lemma SeqAppendNil_5152(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_5153","instance":5153,"id":191824,"goal":"lemma SeqNilAppend_5153(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_5154","instance":5154,"id":191825,"goal":"lemma SeqAppendAssoc_5154(zs: seq, xs: seq, ys: seq)\n ensures (zs + xs) + ys == zs + (xs + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_5155","instance":5155,"id":191826,"goal":"lemma SeqTakeDrop_5155(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_5156","instance":5156,"id":191827,"goal":"lemma SeqReverseLen_5156(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_5157","instance":5157,"id":191828,"goal":"lemma SeqReverseIdem_5157(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_5158","instance":5158,"id":191829,"goal":"lemma SeqMapLen_5158(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_5159","instance":5159,"id":191830,"goal":"lemma SeqFilterLe_5159(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_5160","instance":5160,"id":191831,"goal":"lemma SeqMemberAppend_5160(zs: seq, s: seq)\n ensures x in zs + s <==> x in zs || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_5161","instance":5161,"id":191832,"goal":"lemma SeqAppendLen_5161(zs: seq, xs: seq)\n ensures |zs + xs| == |zs| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_5162","instance":5162,"id":191833,"goal":"lemma SeqAppendNil_5162(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_5163","instance":5163,"id":191834,"goal":"lemma SeqNilAppend_5163(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_5164","instance":5164,"id":191835,"goal":"lemma SeqAppendAssoc_5164(u: seq, zs: seq, s: seq)\n ensures (u + zs) + s == u + (zs + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_5165","instance":5165,"id":191836,"goal":"lemma SeqTakeDrop_5165(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_5166","instance":5166,"id":191837,"goal":"lemma SeqReverseLen_5166(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_5167","instance":5167,"id":191838,"goal":"lemma SeqReverseIdem_5167(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_5168","instance":5168,"id":191839,"goal":"lemma SeqMapLen_5168(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_5169","instance":5169,"id":191840,"goal":"lemma SeqFilterLe_5169(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_5170","instance":5170,"id":191841,"goal":"lemma SeqMemberAppend_5170(zs: seq, ys: seq)\n ensures x in zs + ys <==> x in zs || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_5171","instance":5171,"id":191842,"goal":"lemma SeqAppendLen_5171(s: seq, xs: seq)\n ensures |s + xs| == |s| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_5172","instance":5172,"id":191843,"goal":"lemma SeqAppendNil_5172(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_5173","instance":5173,"id":191844,"goal":"lemma SeqNilAppend_5173(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_5174","instance":5174,"id":191845,"goal":"lemma SeqAppendAssoc_5174(ys: seq, s: seq, zs: seq)\n ensures (ys + s) + zs == ys + (s + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_5175","instance":5175,"id":191846,"goal":"lemma SeqTakeDrop_5175(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_5176","instance":5176,"id":191847,"goal":"lemma SeqReverseLen_5176(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_5177","instance":5177,"id":191848,"goal":"lemma SeqReverseIdem_5177(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_5178","instance":5178,"id":191849,"goal":"lemma SeqMapLen_5178(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_5179","instance":5179,"id":191850,"goal":"lemma SeqFilterLe_5179(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_5180","instance":5180,"id":191851,"goal":"lemma SeqMemberAppend_5180(ys: seq, t: seq)\n ensures x in ys + t <==> x in ys || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_5181","instance":5181,"id":191852,"goal":"lemma SeqAppendLen_5181(xs: seq, t: seq)\n ensures |xs + t| == |xs| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_5182","instance":5182,"id":191853,"goal":"lemma SeqAppendNil_5182(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_5183","instance":5183,"id":191854,"goal":"lemma SeqNilAppend_5183(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_5184","instance":5184,"id":191855,"goal":"lemma SeqAppendAssoc_5184(u: seq, s: seq, zs: seq)\n ensures (u + s) + zs == u + (s + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_5185","instance":5185,"id":191856,"goal":"lemma SeqTakeDrop_5185(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_5186","instance":5186,"id":191857,"goal":"lemma SeqReverseLen_5186(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_5187","instance":5187,"id":191858,"goal":"lemma SeqReverseIdem_5187(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_5188","instance":5188,"id":191859,"goal":"lemma SeqMapLen_5188(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_5189","instance":5189,"id":191860,"goal":"lemma SeqFilterLe_5189(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_5190","instance":5190,"id":191861,"goal":"lemma SeqMemberAppend_5190(xs: seq, s: seq)\n ensures x in xs + s <==> x in xs || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_5191","instance":5191,"id":191862,"goal":"lemma SeqAppendLen_5191(t: seq, ys: seq)\n ensures |t + ys| == |t| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_5192","instance":5192,"id":191863,"goal":"lemma SeqAppendNil_5192(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_5193","instance":5193,"id":191864,"goal":"lemma SeqNilAppend_5193(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_5194","instance":5194,"id":191865,"goal":"lemma SeqAppendAssoc_5194(s: seq, xs: seq, zs: seq)\n ensures (s + xs) + zs == s + (xs + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_5195","instance":5195,"id":191866,"goal":"lemma SeqTakeDrop_5195(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_5196","instance":5196,"id":191867,"goal":"lemma SeqReverseLen_5196(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_5197","instance":5197,"id":191868,"goal":"lemma SeqReverseIdem_5197(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_5198","instance":5198,"id":191869,"goal":"lemma SeqMapLen_5198(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_5199","instance":5199,"id":191870,"goal":"lemma SeqFilterLe_5199(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_5200","instance":5200,"id":191871,"goal":"lemma SeqMemberAppend_5200(ys: seq, u: seq)\n ensures x in ys + u <==> x in ys || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_5201","instance":5201,"id":191872,"goal":"lemma SeqAppendLen_5201(u: seq, zs: seq)\n ensures |u + zs| == |u| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_5202","instance":5202,"id":191873,"goal":"lemma SeqAppendNil_5202(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_5203","instance":5203,"id":191874,"goal":"lemma SeqNilAppend_5203(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_5204","instance":5204,"id":191875,"goal":"lemma SeqAppendAssoc_5204(xs: seq, zs: seq, ys: seq)\n ensures (xs + zs) + ys == xs + (zs + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_5205","instance":5205,"id":191876,"goal":"lemma SeqTakeDrop_5205(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_5206","instance":5206,"id":191877,"goal":"lemma SeqReverseLen_5206(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_5207","instance":5207,"id":191878,"goal":"lemma SeqReverseIdem_5207(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_5208","instance":5208,"id":191879,"goal":"lemma SeqMapLen_5208(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_5209","instance":5209,"id":191880,"goal":"lemma SeqFilterLe_5209(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_5210","instance":5210,"id":191881,"goal":"lemma SeqMemberAppend_5210(ys: seq, xs: seq)\n ensures x in ys + xs <==> x in ys || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_5211","instance":5211,"id":191882,"goal":"lemma SeqAppendLen_5211(xs: seq, ys: seq)\n ensures |xs + ys| == |xs| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_5212","instance":5212,"id":191883,"goal":"lemma SeqAppendNil_5212(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_5213","instance":5213,"id":191884,"goal":"lemma SeqNilAppend_5213(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_5214","instance":5214,"id":191885,"goal":"lemma SeqAppendAssoc_5214(u: seq, t: seq, xs: seq)\n ensures (u + t) + xs == u + (t + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_5215","instance":5215,"id":191886,"goal":"lemma SeqTakeDrop_5215(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_5216","instance":5216,"id":191887,"goal":"lemma SeqReverseLen_5216(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_5217","instance":5217,"id":191888,"goal":"lemma SeqReverseIdem_5217(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_5218","instance":5218,"id":191889,"goal":"lemma SeqMapLen_5218(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_5219","instance":5219,"id":191890,"goal":"lemma SeqFilterLe_5219(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_5220","instance":5220,"id":191891,"goal":"lemma SeqMemberAppend_5220(s: seq, ys: seq)\n ensures x in s + ys <==> x in s || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_5221","instance":5221,"id":191892,"goal":"lemma SeqAppendLen_5221(u: seq, xs: seq)\n ensures |u + xs| == |u| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_5222","instance":5222,"id":191893,"goal":"lemma SeqAppendNil_5222(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_5223","instance":5223,"id":191894,"goal":"lemma SeqNilAppend_5223(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_5224","instance":5224,"id":191895,"goal":"lemma SeqAppendAssoc_5224(zs: seq, u: seq, s: seq)\n ensures (zs + u) + s == zs + (u + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_5225","instance":5225,"id":191896,"goal":"lemma SeqTakeDrop_5225(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_5226","instance":5226,"id":191897,"goal":"lemma SeqReverseLen_5226(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_5227","instance":5227,"id":191898,"goal":"lemma SeqReverseIdem_5227(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_5228","instance":5228,"id":191899,"goal":"lemma SeqMapLen_5228(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_5229","instance":5229,"id":191900,"goal":"lemma SeqFilterLe_5229(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_5230","instance":5230,"id":191901,"goal":"lemma SeqMemberAppend_5230(xs: seq, t: seq)\n ensures x in xs + t <==> x in xs || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_5231","instance":5231,"id":191902,"goal":"lemma SeqAppendLen_5231(t: seq, xs: seq)\n ensures |t + xs| == |t| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_5232","instance":5232,"id":191903,"goal":"lemma SeqAppendNil_5232(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_5233","instance":5233,"id":191904,"goal":"lemma SeqNilAppend_5233(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_5234","instance":5234,"id":191905,"goal":"lemma SeqAppendAssoc_5234(xs: seq, u: seq, ys: seq)\n ensures (xs + u) + ys == xs + (u + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_5235","instance":5235,"id":191906,"goal":"lemma SeqTakeDrop_5235(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_5236","instance":5236,"id":191907,"goal":"lemma SeqReverseLen_5236(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_5237","instance":5237,"id":191908,"goal":"lemma SeqReverseIdem_5237(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_5238","instance":5238,"id":191909,"goal":"lemma SeqMapLen_5238(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_5239","instance":5239,"id":191910,"goal":"lemma SeqFilterLe_5239(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_5240","instance":5240,"id":191911,"goal":"lemma SeqMemberAppend_5240(ys: seq, s: seq)\n ensures x in ys + s <==> x in ys || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_5241","instance":5241,"id":191912,"goal":"lemma SeqAppendLen_5241(u: seq, t: seq)\n ensures |u + t| == |u| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_5242","instance":5242,"id":191913,"goal":"lemma SeqAppendNil_5242(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_5243","instance":5243,"id":191914,"goal":"lemma SeqNilAppend_5243(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_5244","instance":5244,"id":191915,"goal":"lemma SeqAppendAssoc_5244(xs: seq, zs: seq, ys: seq)\n ensures (xs + zs) + ys == xs + (zs + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_5245","instance":5245,"id":191916,"goal":"lemma SeqTakeDrop_5245(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_5246","instance":5246,"id":191917,"goal":"lemma SeqReverseLen_5246(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_5247","instance":5247,"id":191918,"goal":"lemma SeqReverseIdem_5247(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_5248","instance":5248,"id":191919,"goal":"lemma SeqMapLen_5248(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_5249","instance":5249,"id":191920,"goal":"lemma SeqFilterLe_5249(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_5250","instance":5250,"id":191921,"goal":"lemma SeqMemberAppend_5250(zs: seq, s: seq)\n ensures x in zs + s <==> x in zs || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_5251","instance":5251,"id":191922,"goal":"lemma SeqAppendLen_5251(u: seq, xs: seq)\n ensures |u + xs| == |u| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_5252","instance":5252,"id":191923,"goal":"lemma SeqAppendNil_5252(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_5253","instance":5253,"id":191924,"goal":"lemma SeqNilAppend_5253(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_5254","instance":5254,"id":191925,"goal":"lemma SeqAppendAssoc_5254(zs: seq, s: seq, xs: seq)\n ensures (zs + s) + xs == zs + (s + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_5255","instance":5255,"id":191926,"goal":"lemma SeqTakeDrop_5255(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_5256","instance":5256,"id":191927,"goal":"lemma SeqReverseLen_5256(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_5257","instance":5257,"id":191928,"goal":"lemma SeqReverseIdem_5257(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_5258","instance":5258,"id":191929,"goal":"lemma SeqMapLen_5258(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_5259","instance":5259,"id":191930,"goal":"lemma SeqFilterLe_5259(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_5260","instance":5260,"id":191931,"goal":"lemma SeqMemberAppend_5260(s: seq, zs: seq)\n ensures x in s + zs <==> x in s || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_5261","instance":5261,"id":191932,"goal":"lemma SeqAppendLen_5261(zs: seq, s: seq)\n ensures |zs + s| == |zs| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_5262","instance":5262,"id":191933,"goal":"lemma SeqAppendNil_5262(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_5263","instance":5263,"id":191934,"goal":"lemma SeqNilAppend_5263(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_5264","instance":5264,"id":191935,"goal":"lemma SeqAppendAssoc_5264(ys: seq, t: seq, s: seq)\n ensures (ys + t) + s == ys + (t + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_5265","instance":5265,"id":191936,"goal":"lemma SeqTakeDrop_5265(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_5266","instance":5266,"id":191937,"goal":"lemma SeqReverseLen_5266(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_5267","instance":5267,"id":191938,"goal":"lemma SeqReverseIdem_5267(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_5268","instance":5268,"id":191939,"goal":"lemma SeqMapLen_5268(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_5269","instance":5269,"id":191940,"goal":"lemma SeqFilterLe_5269(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_5270","instance":5270,"id":191941,"goal":"lemma SeqMemberAppend_5270(u: seq, t: seq)\n ensures x in u + t <==> x in u || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_5271","instance":5271,"id":191942,"goal":"lemma SeqAppendLen_5271(s: seq, xs: seq)\n ensures |s + xs| == |s| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_5272","instance":5272,"id":191943,"goal":"lemma SeqAppendNil_5272(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_5273","instance":5273,"id":191944,"goal":"lemma SeqNilAppend_5273(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_5274","instance":5274,"id":191945,"goal":"lemma SeqAppendAssoc_5274(t: seq, u: seq, zs: seq)\n ensures (t + u) + zs == t + (u + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_5275","instance":5275,"id":191946,"goal":"lemma SeqTakeDrop_5275(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_5276","instance":5276,"id":191947,"goal":"lemma SeqReverseLen_5276(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_5277","instance":5277,"id":191948,"goal":"lemma SeqReverseIdem_5277(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_5278","instance":5278,"id":191949,"goal":"lemma SeqMapLen_5278(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_5279","instance":5279,"id":191950,"goal":"lemma SeqFilterLe_5279(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_5280","instance":5280,"id":191951,"goal":"lemma SeqMemberAppend_5280(u: seq, ys: seq)\n ensures x in u + ys <==> x in u || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_5281","instance":5281,"id":191952,"goal":"lemma SeqAppendLen_5281(u: seq, ys: seq)\n ensures |u + ys| == |u| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_5282","instance":5282,"id":191953,"goal":"lemma SeqAppendNil_5282(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_5283","instance":5283,"id":191954,"goal":"lemma SeqNilAppend_5283(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_5284","instance":5284,"id":191955,"goal":"lemma SeqAppendAssoc_5284(s: seq, ys: seq, zs: seq)\n ensures (s + ys) + zs == s + (ys + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_5285","instance":5285,"id":191956,"goal":"lemma SeqTakeDrop_5285(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_5286","instance":5286,"id":191957,"goal":"lemma SeqReverseLen_5286(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_5287","instance":5287,"id":191958,"goal":"lemma SeqReverseIdem_5287(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_5288","instance":5288,"id":191959,"goal":"lemma SeqMapLen_5288(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_5289","instance":5289,"id":191960,"goal":"lemma SeqFilterLe_5289(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_5290","instance":5290,"id":191961,"goal":"lemma SeqMemberAppend_5290(ys: seq, s: seq)\n ensures x in ys + s <==> x in ys || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_5291","instance":5291,"id":191962,"goal":"lemma SeqAppendLen_5291(zs: seq, t: seq)\n ensures |zs + t| == |zs| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_5292","instance":5292,"id":191963,"goal":"lemma SeqAppendNil_5292(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_5293","instance":5293,"id":191964,"goal":"lemma SeqNilAppend_5293(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_5294","instance":5294,"id":191965,"goal":"lemma SeqAppendAssoc_5294(t: seq, zs: seq, s: seq)\n ensures (t + zs) + s == t + (zs + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_5295","instance":5295,"id":191966,"goal":"lemma SeqTakeDrop_5295(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_5296","instance":5296,"id":191967,"goal":"lemma SeqReverseLen_5296(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_5297","instance":5297,"id":191968,"goal":"lemma SeqReverseIdem_5297(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_5298","instance":5298,"id":191969,"goal":"lemma SeqMapLen_5298(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_5299","instance":5299,"id":191970,"goal":"lemma SeqFilterLe_5299(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_5300","instance":5300,"id":191971,"goal":"lemma SeqMemberAppend_5300(ys: seq, zs: seq)\n ensures x in ys + zs <==> x in ys || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_5301","instance":5301,"id":191972,"goal":"lemma SeqAppendLen_5301(xs: seq, u: seq)\n ensures |xs + u| == |xs| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_5302","instance":5302,"id":191973,"goal":"lemma SeqAppendNil_5302(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_5303","instance":5303,"id":191974,"goal":"lemma SeqNilAppend_5303(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_5304","instance":5304,"id":191975,"goal":"lemma SeqAppendAssoc_5304(ys: seq, xs: seq, zs: seq)\n ensures (ys + xs) + zs == ys + (xs + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_5305","instance":5305,"id":191976,"goal":"lemma SeqTakeDrop_5305(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_5306","instance":5306,"id":191977,"goal":"lemma SeqReverseLen_5306(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_5307","instance":5307,"id":191978,"goal":"lemma SeqReverseIdem_5307(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_5308","instance":5308,"id":191979,"goal":"lemma SeqMapLen_5308(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_5309","instance":5309,"id":191980,"goal":"lemma SeqFilterLe_5309(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_5310","instance":5310,"id":191981,"goal":"lemma SeqMemberAppend_5310(xs: seq, s: seq)\n ensures x in xs + s <==> x in xs || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_5311","instance":5311,"id":191982,"goal":"lemma SeqAppendLen_5311(s: seq, u: seq)\n ensures |s + u| == |s| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_5312","instance":5312,"id":191983,"goal":"lemma SeqAppendNil_5312(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_5313","instance":5313,"id":191984,"goal":"lemma SeqNilAppend_5313(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_5314","instance":5314,"id":191985,"goal":"lemma SeqAppendAssoc_5314(zs: seq, t: seq, xs: seq)\n ensures (zs + t) + xs == zs + (t + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_5315","instance":5315,"id":191986,"goal":"lemma SeqTakeDrop_5315(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_5316","instance":5316,"id":191987,"goal":"lemma SeqReverseLen_5316(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_5317","instance":5317,"id":191988,"goal":"lemma SeqReverseIdem_5317(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_5318","instance":5318,"id":191989,"goal":"lemma SeqMapLen_5318(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_5319","instance":5319,"id":191990,"goal":"lemma SeqFilterLe_5319(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_5320","instance":5320,"id":191991,"goal":"lemma SeqMemberAppend_5320(ys: seq, zs: seq)\n ensures x in ys + zs <==> x in ys || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_5321","instance":5321,"id":191992,"goal":"lemma SeqAppendLen_5321(u: seq, ys: seq)\n ensures |u + ys| == |u| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_5322","instance":5322,"id":191993,"goal":"lemma SeqAppendNil_5322(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_5323","instance":5323,"id":191994,"goal":"lemma SeqNilAppend_5323(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_5324","instance":5324,"id":191995,"goal":"lemma SeqAppendAssoc_5324(t: seq, s: seq, u: seq)\n ensures (t + s) + u == t + (s + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_5325","instance":5325,"id":191996,"goal":"lemma SeqTakeDrop_5325(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_5326","instance":5326,"id":191997,"goal":"lemma SeqReverseLen_5326(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_5327","instance":5327,"id":191998,"goal":"lemma SeqReverseIdem_5327(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_5328","instance":5328,"id":191999,"goal":"lemma SeqMapLen_5328(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_5329","instance":5329,"id":192000,"goal":"lemma SeqFilterLe_5329(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_5330","instance":5330,"id":192001,"goal":"lemma SeqMemberAppend_5330(zs: seq, u: seq)\n ensures x in zs + u <==> x in zs || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_5331","instance":5331,"id":192002,"goal":"lemma SeqAppendLen_5331(xs: seq, s: seq)\n ensures |xs + s| == |xs| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_5332","instance":5332,"id":192003,"goal":"lemma SeqAppendNil_5332(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_5333","instance":5333,"id":192004,"goal":"lemma SeqNilAppend_5333(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_5334","instance":5334,"id":192005,"goal":"lemma SeqAppendAssoc_5334(xs: seq, zs: seq, u: seq)\n ensures (xs + zs) + u == xs + (zs + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_5335","instance":5335,"id":192006,"goal":"lemma SeqTakeDrop_5335(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_5336","instance":5336,"id":192007,"goal":"lemma SeqReverseLen_5336(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_5337","instance":5337,"id":192008,"goal":"lemma SeqReverseIdem_5337(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_5338","instance":5338,"id":192009,"goal":"lemma SeqMapLen_5338(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_5339","instance":5339,"id":192010,"goal":"lemma SeqFilterLe_5339(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_5340","instance":5340,"id":192011,"goal":"lemma SeqMemberAppend_5340(ys: seq, s: seq)\n ensures x in ys + s <==> x in ys || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_5341","instance":5341,"id":192012,"goal":"lemma SeqAppendLen_5341(xs: seq, u: seq)\n ensures |xs + u| == |xs| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_5342","instance":5342,"id":192013,"goal":"lemma SeqAppendNil_5342(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_5343","instance":5343,"id":192014,"goal":"lemma SeqNilAppend_5343(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_5344","instance":5344,"id":192015,"goal":"lemma SeqAppendAssoc_5344(ys: seq, xs: seq, t: seq)\n ensures (ys + xs) + t == ys + (xs + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_5345","instance":5345,"id":192016,"goal":"lemma SeqTakeDrop_5345(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_5346","instance":5346,"id":192017,"goal":"lemma SeqReverseLen_5346(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_5347","instance":5347,"id":192018,"goal":"lemma SeqReverseIdem_5347(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_5348","instance":5348,"id":192019,"goal":"lemma SeqMapLen_5348(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_5349","instance":5349,"id":192020,"goal":"lemma SeqFilterLe_5349(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_5350","instance":5350,"id":192021,"goal":"lemma SeqMemberAppend_5350(t: seq, u: seq)\n ensures x in t + u <==> x in t || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_5351","instance":5351,"id":192022,"goal":"lemma SeqAppendLen_5351(t: seq, ys: seq)\n ensures |t + ys| == |t| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_5352","instance":5352,"id":192023,"goal":"lemma SeqAppendNil_5352(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_5353","instance":5353,"id":192024,"goal":"lemma SeqNilAppend_5353(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_5354","instance":5354,"id":192025,"goal":"lemma SeqAppendAssoc_5354(u: seq, ys: seq, zs: seq)\n ensures (u + ys) + zs == u + (ys + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_5355","instance":5355,"id":192026,"goal":"lemma SeqTakeDrop_5355(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_5356","instance":5356,"id":192027,"goal":"lemma SeqReverseLen_5356(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_5357","instance":5357,"id":192028,"goal":"lemma SeqReverseIdem_5357(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_5358","instance":5358,"id":192029,"goal":"lemma SeqMapLen_5358(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_5359","instance":5359,"id":192030,"goal":"lemma SeqFilterLe_5359(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_5360","instance":5360,"id":192031,"goal":"lemma SeqMemberAppend_5360(ys: seq, xs: seq)\n ensures x in ys + xs <==> x in ys || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_5361","instance":5361,"id":192032,"goal":"lemma SeqAppendLen_5361(t: seq, xs: seq)\n ensures |t + xs| == |t| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_5362","instance":5362,"id":192033,"goal":"lemma SeqAppendNil_5362(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_5363","instance":5363,"id":192034,"goal":"lemma SeqNilAppend_5363(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_5364","instance":5364,"id":192035,"goal":"lemma SeqAppendAssoc_5364(t: seq, s: seq, zs: seq)\n ensures (t + s) + zs == t + (s + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_5365","instance":5365,"id":192036,"goal":"lemma SeqTakeDrop_5365(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_5366","instance":5366,"id":192037,"goal":"lemma SeqReverseLen_5366(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_5367","instance":5367,"id":192038,"goal":"lemma SeqReverseIdem_5367(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_5368","instance":5368,"id":192039,"goal":"lemma SeqMapLen_5368(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_5369","instance":5369,"id":192040,"goal":"lemma SeqFilterLe_5369(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_5370","instance":5370,"id":192041,"goal":"lemma SeqMemberAppend_5370(u: seq, zs: seq)\n ensures x in u + zs <==> x in u || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_5371","instance":5371,"id":192042,"goal":"lemma SeqAppendLen_5371(xs: seq, u: seq)\n ensures |xs + u| == |xs| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_5372","instance":5372,"id":192043,"goal":"lemma SeqAppendNil_5372(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_5373","instance":5373,"id":192044,"goal":"lemma SeqNilAppend_5373(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_5374","instance":5374,"id":192045,"goal":"lemma SeqAppendAssoc_5374(zs: seq, ys: seq, u: seq)\n ensures (zs + ys) + u == zs + (ys + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_5375","instance":5375,"id":192046,"goal":"lemma SeqTakeDrop_5375(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_5376","instance":5376,"id":192047,"goal":"lemma SeqReverseLen_5376(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_5377","instance":5377,"id":192048,"goal":"lemma SeqReverseIdem_5377(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_5378","instance":5378,"id":192049,"goal":"lemma SeqMapLen_5378(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_5379","instance":5379,"id":192050,"goal":"lemma SeqFilterLe_5379(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_5380","instance":5380,"id":192051,"goal":"lemma SeqMemberAppend_5380(t: seq, zs: seq)\n ensures x in t + zs <==> x in t || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_5381","instance":5381,"id":192052,"goal":"lemma SeqAppendLen_5381(t: seq, u: seq)\n ensures |t + u| == |t| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_5382","instance":5382,"id":192053,"goal":"lemma SeqAppendNil_5382(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_5383","instance":5383,"id":192054,"goal":"lemma SeqNilAppend_5383(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_5384","instance":5384,"id":192055,"goal":"lemma SeqAppendAssoc_5384(zs: seq, xs: seq, u: seq)\n ensures (zs + xs) + u == zs + (xs + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_5385","instance":5385,"id":192056,"goal":"lemma SeqTakeDrop_5385(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_5386","instance":5386,"id":192057,"goal":"lemma SeqReverseLen_5386(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_5387","instance":5387,"id":192058,"goal":"lemma SeqReverseIdem_5387(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_5388","instance":5388,"id":192059,"goal":"lemma SeqMapLen_5388(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_5389","instance":5389,"id":192060,"goal":"lemma SeqFilterLe_5389(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_5390","instance":5390,"id":192061,"goal":"lemma SeqMemberAppend_5390(u: seq, ys: seq)\n ensures x in u + ys <==> x in u || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_5391","instance":5391,"id":192062,"goal":"lemma SeqAppendLen_5391(ys: seq, xs: seq)\n ensures |ys + xs| == |ys| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_5392","instance":5392,"id":192063,"goal":"lemma SeqAppendNil_5392(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_5393","instance":5393,"id":192064,"goal":"lemma SeqNilAppend_5393(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_5394","instance":5394,"id":192065,"goal":"lemma SeqAppendAssoc_5394(t: seq, u: seq, xs: seq)\n ensures (t + u) + xs == t + (u + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_5395","instance":5395,"id":192066,"goal":"lemma SeqTakeDrop_5395(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_5396","instance":5396,"id":192067,"goal":"lemma SeqReverseLen_5396(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_5397","instance":5397,"id":192068,"goal":"lemma SeqReverseIdem_5397(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_5398","instance":5398,"id":192069,"goal":"lemma SeqMapLen_5398(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_5399","instance":5399,"id":192070,"goal":"lemma SeqFilterLe_5399(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_5400","instance":5400,"id":192071,"goal":"lemma SeqMemberAppend_5400(ys: seq, s: seq)\n ensures x in ys + s <==> x in ys || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_5401","instance":5401,"id":192072,"goal":"lemma SeqAppendLen_5401(t: seq, s: seq)\n ensures |t + s| == |t| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_5402","instance":5402,"id":192073,"goal":"lemma SeqAppendNil_5402(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_5403","instance":5403,"id":192074,"goal":"lemma SeqNilAppend_5403(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_5404","instance":5404,"id":192075,"goal":"lemma SeqAppendAssoc_5404(zs: seq, ys: seq, t: seq)\n ensures (zs + ys) + t == zs + (ys + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_5405","instance":5405,"id":192076,"goal":"lemma SeqTakeDrop_5405(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_5406","instance":5406,"id":192077,"goal":"lemma SeqReverseLen_5406(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_5407","instance":5407,"id":192078,"goal":"lemma SeqReverseIdem_5407(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_5408","instance":5408,"id":192079,"goal":"lemma SeqMapLen_5408(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_5409","instance":5409,"id":192080,"goal":"lemma SeqFilterLe_5409(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_5410","instance":5410,"id":192081,"goal":"lemma SeqMemberAppend_5410(t: seq, ys: seq)\n ensures x in t + ys <==> x in t || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_5411","instance":5411,"id":192082,"goal":"lemma SeqAppendLen_5411(ys: seq, zs: seq)\n ensures |ys + zs| == |ys| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_5412","instance":5412,"id":192083,"goal":"lemma SeqAppendNil_5412(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_5413","instance":5413,"id":192084,"goal":"lemma SeqNilAppend_5413(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_5414","instance":5414,"id":192085,"goal":"lemma SeqAppendAssoc_5414(ys: seq, s: seq, xs: seq)\n ensures (ys + s) + xs == ys + (s + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_5415","instance":5415,"id":192086,"goal":"lemma SeqTakeDrop_5415(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_5416","instance":5416,"id":192087,"goal":"lemma SeqReverseLen_5416(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_5417","instance":5417,"id":192088,"goal":"lemma SeqReverseIdem_5417(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_5418","instance":5418,"id":192089,"goal":"lemma SeqMapLen_5418(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_5419","instance":5419,"id":192090,"goal":"lemma SeqFilterLe_5419(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_5420","instance":5420,"id":192091,"goal":"lemma SeqMemberAppend_5420(s: seq, u: seq)\n ensures x in s + u <==> x in s || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_5421","instance":5421,"id":192092,"goal":"lemma SeqAppendLen_5421(t: seq, zs: seq)\n ensures |t + zs| == |t| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_5422","instance":5422,"id":192093,"goal":"lemma SeqAppendNil_5422(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_5423","instance":5423,"id":192094,"goal":"lemma SeqNilAppend_5423(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_5424","instance":5424,"id":192095,"goal":"lemma SeqAppendAssoc_5424(u: seq, xs: seq, t: seq)\n ensures (u + xs) + t == u + (xs + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_5425","instance":5425,"id":192096,"goal":"lemma SeqTakeDrop_5425(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_5426","instance":5426,"id":192097,"goal":"lemma SeqReverseLen_5426(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_5427","instance":5427,"id":192098,"goal":"lemma SeqReverseIdem_5427(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_5428","instance":5428,"id":192099,"goal":"lemma SeqMapLen_5428(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_5429","instance":5429,"id":192100,"goal":"lemma SeqFilterLe_5429(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_5430","instance":5430,"id":192101,"goal":"lemma SeqMemberAppend_5430(u: seq, t: seq)\n ensures x in u + t <==> x in u || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_5431","instance":5431,"id":192102,"goal":"lemma SeqAppendLen_5431(t: seq, s: seq)\n ensures |t + s| == |t| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_5432","instance":5432,"id":192103,"goal":"lemma SeqAppendNil_5432(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_5433","instance":5433,"id":192104,"goal":"lemma SeqNilAppend_5433(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_5434","instance":5434,"id":192105,"goal":"lemma SeqAppendAssoc_5434(ys: seq, t: seq, xs: seq)\n ensures (ys + t) + xs == ys + (t + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_5435","instance":5435,"id":192106,"goal":"lemma SeqTakeDrop_5435(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_5436","instance":5436,"id":192107,"goal":"lemma SeqReverseLen_5436(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_5437","instance":5437,"id":192108,"goal":"lemma SeqReverseIdem_5437(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_5438","instance":5438,"id":192109,"goal":"lemma SeqMapLen_5438(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_5439","instance":5439,"id":192110,"goal":"lemma SeqFilterLe_5439(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_5440","instance":5440,"id":192111,"goal":"lemma SeqMemberAppend_5440(zs: seq, t: seq)\n ensures x in zs + t <==> x in zs || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_5441","instance":5441,"id":192112,"goal":"lemma SeqAppendLen_5441(xs: seq, u: seq)\n ensures |xs + u| == |xs| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_5442","instance":5442,"id":192113,"goal":"lemma SeqAppendNil_5442(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_5443","instance":5443,"id":192114,"goal":"lemma SeqNilAppend_5443(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_5444","instance":5444,"id":192115,"goal":"lemma SeqAppendAssoc_5444(u: seq, s: seq, t: seq)\n ensures (u + s) + t == u + (s + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_5445","instance":5445,"id":192116,"goal":"lemma SeqTakeDrop_5445(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_5446","instance":5446,"id":192117,"goal":"lemma SeqReverseLen_5446(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_5447","instance":5447,"id":192118,"goal":"lemma SeqReverseIdem_5447(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_5448","instance":5448,"id":192119,"goal":"lemma SeqMapLen_5448(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_5449","instance":5449,"id":192120,"goal":"lemma SeqFilterLe_5449(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_5450","instance":5450,"id":192121,"goal":"lemma SeqMemberAppend_5450(s: seq, zs: seq)\n ensures x in s + zs <==> x in s || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_5451","instance":5451,"id":192122,"goal":"lemma SeqAppendLen_5451(ys: seq, xs: seq)\n ensures |ys + xs| == |ys| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_5452","instance":5452,"id":192123,"goal":"lemma SeqAppendNil_5452(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_5453","instance":5453,"id":192124,"goal":"lemma SeqNilAppend_5453(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_5454","instance":5454,"id":192125,"goal":"lemma SeqAppendAssoc_5454(zs: seq, u: seq, ys: seq)\n ensures (zs + u) + ys == zs + (u + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_5455","instance":5455,"id":192126,"goal":"lemma SeqTakeDrop_5455(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_5456","instance":5456,"id":192127,"goal":"lemma SeqReverseLen_5456(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_5457","instance":5457,"id":192128,"goal":"lemma SeqReverseIdem_5457(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_5458","instance":5458,"id":192129,"goal":"lemma SeqMapLen_5458(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_5459","instance":5459,"id":192130,"goal":"lemma SeqFilterLe_5459(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_5460","instance":5460,"id":192131,"goal":"lemma SeqMemberAppend_5460(ys: seq, u: seq)\n ensures x in ys + u <==> x in ys || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_5461","instance":5461,"id":192132,"goal":"lemma SeqAppendLen_5461(s: seq, xs: seq)\n ensures |s + xs| == |s| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_5462","instance":5462,"id":192133,"goal":"lemma SeqAppendNil_5462(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_5463","instance":5463,"id":192134,"goal":"lemma SeqNilAppend_5463(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_5464","instance":5464,"id":192135,"goal":"lemma SeqAppendAssoc_5464(xs: seq, zs: seq, s: seq)\n ensures (xs + zs) + s == xs + (zs + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_5465","instance":5465,"id":192136,"goal":"lemma SeqTakeDrop_5465(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_5466","instance":5466,"id":192137,"goal":"lemma SeqReverseLen_5466(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_5467","instance":5467,"id":192138,"goal":"lemma SeqReverseIdem_5467(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_5468","instance":5468,"id":192139,"goal":"lemma SeqMapLen_5468(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_5469","instance":5469,"id":192140,"goal":"lemma SeqFilterLe_5469(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_5470","instance":5470,"id":192141,"goal":"lemma SeqMemberAppend_5470(s: seq, zs: seq)\n ensures x in s + zs <==> x in s || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_5471","instance":5471,"id":192142,"goal":"lemma SeqAppendLen_5471(ys: seq, xs: seq)\n ensures |ys + xs| == |ys| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_5472","instance":5472,"id":192143,"goal":"lemma SeqAppendNil_5472(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_5473","instance":5473,"id":192144,"goal":"lemma SeqNilAppend_5473(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_5474","instance":5474,"id":192145,"goal":"lemma SeqAppendAssoc_5474(u: seq, xs: seq, s: seq)\n ensures (u + xs) + s == u + (xs + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_5475","instance":5475,"id":192146,"goal":"lemma SeqTakeDrop_5475(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_5476","instance":5476,"id":192147,"goal":"lemma SeqReverseLen_5476(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_5477","instance":5477,"id":192148,"goal":"lemma SeqReverseIdem_5477(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_5478","instance":5478,"id":192149,"goal":"lemma SeqMapLen_5478(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_5479","instance":5479,"id":192150,"goal":"lemma SeqFilterLe_5479(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_5480","instance":5480,"id":192151,"goal":"lemma SeqMemberAppend_5480(zs: seq, s: seq)\n ensures x in zs + s <==> x in zs || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_5481","instance":5481,"id":192152,"goal":"lemma SeqAppendLen_5481(ys: seq, u: seq)\n ensures |ys + u| == |ys| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_5482","instance":5482,"id":192153,"goal":"lemma SeqAppendNil_5482(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_5483","instance":5483,"id":192154,"goal":"lemma SeqNilAppend_5483(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_5484","instance":5484,"id":192155,"goal":"lemma SeqAppendAssoc_5484(u: seq, t: seq, zs: seq)\n ensures (u + t) + zs == u + (t + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_5485","instance":5485,"id":192156,"goal":"lemma SeqTakeDrop_5485(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_5486","instance":5486,"id":192157,"goal":"lemma SeqReverseLen_5486(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_5487","instance":5487,"id":192158,"goal":"lemma SeqReverseIdem_5487(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_5488","instance":5488,"id":192159,"goal":"lemma SeqMapLen_5488(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_5489","instance":5489,"id":192160,"goal":"lemma SeqFilterLe_5489(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_5490","instance":5490,"id":192161,"goal":"lemma SeqMemberAppend_5490(zs: seq, u: seq)\n ensures x in zs + u <==> x in zs || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_5491","instance":5491,"id":192162,"goal":"lemma SeqAppendLen_5491(t: seq, xs: seq)\n ensures |t + xs| == |t| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_5492","instance":5492,"id":192163,"goal":"lemma SeqAppendNil_5492(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_5493","instance":5493,"id":192164,"goal":"lemma SeqNilAppend_5493(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_5494","instance":5494,"id":192165,"goal":"lemma SeqAppendAssoc_5494(t: seq, ys: seq, zs: seq)\n ensures (t + ys) + zs == t + (ys + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_5495","instance":5495,"id":192166,"goal":"lemma SeqTakeDrop_5495(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_5496","instance":5496,"id":192167,"goal":"lemma SeqReverseLen_5496(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_5497","instance":5497,"id":192168,"goal":"lemma SeqReverseIdem_5497(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_5498","instance":5498,"id":192169,"goal":"lemma SeqMapLen_5498(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_5499","instance":5499,"id":192170,"goal":"lemma SeqFilterLe_5499(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_5500","instance":5500,"id":192171,"goal":"lemma SeqMemberAppend_5500(zs: seq, xs: seq)\n ensures x in zs + xs <==> x in zs || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_5501","instance":5501,"id":192172,"goal":"lemma SeqAppendLen_5501(t: seq, xs: seq)\n ensures |t + xs| == |t| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_5502","instance":5502,"id":192173,"goal":"lemma SeqAppendNil_5502(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_5503","instance":5503,"id":192174,"goal":"lemma SeqNilAppend_5503(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_5504","instance":5504,"id":192175,"goal":"lemma SeqAppendAssoc_5504(u: seq, ys: seq, s: seq)\n ensures (u + ys) + s == u + (ys + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_5505","instance":5505,"id":192176,"goal":"lemma SeqTakeDrop_5505(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_5506","instance":5506,"id":192177,"goal":"lemma SeqReverseLen_5506(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_5507","instance":5507,"id":192178,"goal":"lemma SeqReverseIdem_5507(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_5508","instance":5508,"id":192179,"goal":"lemma SeqMapLen_5508(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_5509","instance":5509,"id":192180,"goal":"lemma SeqFilterLe_5509(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_5510","instance":5510,"id":192181,"goal":"lemma SeqMemberAppend_5510(ys: seq, s: seq)\n ensures x in ys + s <==> x in ys || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_5511","instance":5511,"id":192182,"goal":"lemma SeqAppendLen_5511(u: seq, ys: seq)\n ensures |u + ys| == |u| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_5512","instance":5512,"id":192183,"goal":"lemma SeqAppendNil_5512(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_5513","instance":5513,"id":192184,"goal":"lemma SeqNilAppend_5513(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_5514","instance":5514,"id":192185,"goal":"lemma SeqAppendAssoc_5514(zs: seq, t: seq, xs: seq)\n ensures (zs + t) + xs == zs + (t + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_5515","instance":5515,"id":192186,"goal":"lemma SeqTakeDrop_5515(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_5516","instance":5516,"id":192187,"goal":"lemma SeqReverseLen_5516(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_5517","instance":5517,"id":192188,"goal":"lemma SeqReverseIdem_5517(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_5518","instance":5518,"id":192189,"goal":"lemma SeqMapLen_5518(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_5519","instance":5519,"id":192190,"goal":"lemma SeqFilterLe_5519(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_5520","instance":5520,"id":192191,"goal":"lemma SeqMemberAppend_5520(s: seq, zs: seq)\n ensures x in s + zs <==> x in s || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_5521","instance":5521,"id":192192,"goal":"lemma SeqAppendLen_5521(u: seq, zs: seq)\n ensures |u + zs| == |u| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_5522","instance":5522,"id":192193,"goal":"lemma SeqAppendNil_5522(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_5523","instance":5523,"id":192194,"goal":"lemma SeqNilAppend_5523(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_5524","instance":5524,"id":192195,"goal":"lemma SeqAppendAssoc_5524(t: seq, xs: seq, s: seq)\n ensures (t + xs) + s == t + (xs + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_5525","instance":5525,"id":192196,"goal":"lemma SeqTakeDrop_5525(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_5526","instance":5526,"id":192197,"goal":"lemma SeqReverseLen_5526(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_5527","instance":5527,"id":192198,"goal":"lemma SeqReverseIdem_5527(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_5528","instance":5528,"id":192199,"goal":"lemma SeqMapLen_5528(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_5529","instance":5529,"id":192200,"goal":"lemma SeqFilterLe_5529(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_5530","instance":5530,"id":192201,"goal":"lemma SeqMemberAppend_5530(u: seq, s: seq)\n ensures x in u + s <==> x in u || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_5531","instance":5531,"id":192202,"goal":"lemma SeqAppendLen_5531(ys: seq, t: seq)\n ensures |ys + t| == |ys| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_5532","instance":5532,"id":192203,"goal":"lemma SeqAppendNil_5532(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_5533","instance":5533,"id":192204,"goal":"lemma SeqNilAppend_5533(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_5534","instance":5534,"id":192205,"goal":"lemma SeqAppendAssoc_5534(s: seq, xs: seq, zs: seq)\n ensures (s + xs) + zs == s + (xs + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_5535","instance":5535,"id":192206,"goal":"lemma SeqTakeDrop_5535(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_5536","instance":5536,"id":192207,"goal":"lemma SeqReverseLen_5536(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_5537","instance":5537,"id":192208,"goal":"lemma SeqReverseIdem_5537(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_5538","instance":5538,"id":192209,"goal":"lemma SeqMapLen_5538(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_5539","instance":5539,"id":192210,"goal":"lemma SeqFilterLe_5539(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_5540","instance":5540,"id":192211,"goal":"lemma SeqMemberAppend_5540(zs: seq, xs: seq)\n ensures x in zs + xs <==> x in zs || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_5541","instance":5541,"id":192212,"goal":"lemma SeqAppendLen_5541(s: seq, ys: seq)\n ensures |s + ys| == |s| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_5542","instance":5542,"id":192213,"goal":"lemma SeqAppendNil_5542(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_5543","instance":5543,"id":192214,"goal":"lemma SeqNilAppend_5543(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_5544","instance":5544,"id":192215,"goal":"lemma SeqAppendAssoc_5544(ys: seq, u: seq, t: seq)\n ensures (ys + u) + t == ys + (u + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_5545","instance":5545,"id":192216,"goal":"lemma SeqTakeDrop_5545(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_5546","instance":5546,"id":192217,"goal":"lemma SeqReverseLen_5546(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_5547","instance":5547,"id":192218,"goal":"lemma SeqReverseIdem_5547(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_5548","instance":5548,"id":192219,"goal":"lemma SeqMapLen_5548(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_5549","instance":5549,"id":192220,"goal":"lemma SeqFilterLe_5549(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_5550","instance":5550,"id":192221,"goal":"lemma SeqMemberAppend_5550(u: seq, t: seq)\n ensures x in u + t <==> x in u || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_5551","instance":5551,"id":192222,"goal":"lemma SeqAppendLen_5551(zs: seq, u: seq)\n ensures |zs + u| == |zs| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_5552","instance":5552,"id":192223,"goal":"lemma SeqAppendNil_5552(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_5553","instance":5553,"id":192224,"goal":"lemma SeqNilAppend_5553(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_5554","instance":5554,"id":192225,"goal":"lemma SeqAppendAssoc_5554(s: seq, t: seq, ys: seq)\n ensures (s + t) + ys == s + (t + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_5555","instance":5555,"id":192226,"goal":"lemma SeqTakeDrop_5555(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_5556","instance":5556,"id":192227,"goal":"lemma SeqReverseLen_5556(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_5557","instance":5557,"id":192228,"goal":"lemma SeqReverseIdem_5557(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_5558","instance":5558,"id":192229,"goal":"lemma SeqMapLen_5558(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_5559","instance":5559,"id":192230,"goal":"lemma SeqFilterLe_5559(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_5560","instance":5560,"id":192231,"goal":"lemma SeqMemberAppend_5560(s: seq, ys: seq)\n ensures x in s + ys <==> x in s || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_5561","instance":5561,"id":192232,"goal":"lemma SeqAppendLen_5561(t: seq, u: seq)\n ensures |t + u| == |t| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_5562","instance":5562,"id":192233,"goal":"lemma SeqAppendNil_5562(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_5563","instance":5563,"id":192234,"goal":"lemma SeqNilAppend_5563(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_5564","instance":5564,"id":192235,"goal":"lemma SeqAppendAssoc_5564(xs: seq, ys: seq, zs: seq)\n ensures (xs + ys) + zs == xs + (ys + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_5565","instance":5565,"id":192236,"goal":"lemma SeqTakeDrop_5565(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_5566","instance":5566,"id":192237,"goal":"lemma SeqReverseLen_5566(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_5567","instance":5567,"id":192238,"goal":"lemma SeqReverseIdem_5567(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_5568","instance":5568,"id":192239,"goal":"lemma SeqMapLen_5568(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_5569","instance":5569,"id":192240,"goal":"lemma SeqFilterLe_5569(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_5570","instance":5570,"id":192241,"goal":"lemma SeqMemberAppend_5570(xs: seq, zs: seq)\n ensures x in xs + zs <==> x in xs || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_5571","instance":5571,"id":192242,"goal":"lemma SeqAppendLen_5571(u: seq, t: seq)\n ensures |u + t| == |u| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_5572","instance":5572,"id":192243,"goal":"lemma SeqAppendNil_5572(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_5573","instance":5573,"id":192244,"goal":"lemma SeqNilAppend_5573(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_5574","instance":5574,"id":192245,"goal":"lemma SeqAppendAssoc_5574(t: seq, u: seq, zs: seq)\n ensures (t + u) + zs == t + (u + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_5575","instance":5575,"id":192246,"goal":"lemma SeqTakeDrop_5575(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_5576","instance":5576,"id":192247,"goal":"lemma SeqReverseLen_5576(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_5577","instance":5577,"id":192248,"goal":"lemma SeqReverseIdem_5577(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_5578","instance":5578,"id":192249,"goal":"lemma SeqMapLen_5578(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_5579","instance":5579,"id":192250,"goal":"lemma SeqFilterLe_5579(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_5580","instance":5580,"id":192251,"goal":"lemma SeqMemberAppend_5580(zs: seq, t: seq)\n ensures x in zs + t <==> x in zs || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_5581","instance":5581,"id":192252,"goal":"lemma SeqAppendLen_5581(zs: seq, s: seq)\n ensures |zs + s| == |zs| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_5582","instance":5582,"id":192253,"goal":"lemma SeqAppendNil_5582(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_5583","instance":5583,"id":192254,"goal":"lemma SeqNilAppend_5583(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_5584","instance":5584,"id":192255,"goal":"lemma SeqAppendAssoc_5584(s: seq, zs: seq, t: seq)\n ensures (s + zs) + t == s + (zs + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_5585","instance":5585,"id":192256,"goal":"lemma SeqTakeDrop_5585(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_5586","instance":5586,"id":192257,"goal":"lemma SeqReverseLen_5586(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_5587","instance":5587,"id":192258,"goal":"lemma SeqReverseIdem_5587(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_5588","instance":5588,"id":192259,"goal":"lemma SeqMapLen_5588(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_5589","instance":5589,"id":192260,"goal":"lemma SeqFilterLe_5589(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_5590","instance":5590,"id":192261,"goal":"lemma SeqMemberAppend_5590(u: seq, ys: seq)\n ensures x in u + ys <==> x in u || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_5591","instance":5591,"id":192262,"goal":"lemma SeqAppendLen_5591(ys: seq, t: seq)\n ensures |ys + t| == |ys| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_5592","instance":5592,"id":192263,"goal":"lemma SeqAppendNil_5592(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_5593","instance":5593,"id":192264,"goal":"lemma SeqNilAppend_5593(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_5594","instance":5594,"id":192265,"goal":"lemma SeqAppendAssoc_5594(xs: seq, s: seq, t: seq)\n ensures (xs + s) + t == xs + (s + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_5595","instance":5595,"id":192266,"goal":"lemma SeqTakeDrop_5595(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_5596","instance":5596,"id":192267,"goal":"lemma SeqReverseLen_5596(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_5597","instance":5597,"id":192268,"goal":"lemma SeqReverseIdem_5597(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_5598","instance":5598,"id":192269,"goal":"lemma SeqMapLen_5598(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_5599","instance":5599,"id":192270,"goal":"lemma SeqFilterLe_5599(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_5600","instance":5600,"id":192271,"goal":"lemma SeqMemberAppend_5600(xs: seq, ys: seq)\n ensures x in xs + ys <==> x in xs || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_5601","instance":5601,"id":192272,"goal":"lemma SeqAppendLen_5601(xs: seq, s: seq)\n ensures |xs + s| == |xs| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_5602","instance":5602,"id":192273,"goal":"lemma SeqAppendNil_5602(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_5603","instance":5603,"id":192274,"goal":"lemma SeqNilAppend_5603(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_5604","instance":5604,"id":192275,"goal":"lemma SeqAppendAssoc_5604(zs: seq, s: seq, u: seq)\n ensures (zs + s) + u == zs + (s + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_5605","instance":5605,"id":192276,"goal":"lemma SeqTakeDrop_5605(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_5606","instance":5606,"id":192277,"goal":"lemma SeqReverseLen_5606(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_5607","instance":5607,"id":192278,"goal":"lemma SeqReverseIdem_5607(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_5608","instance":5608,"id":192279,"goal":"lemma SeqMapLen_5608(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_5609","instance":5609,"id":192280,"goal":"lemma SeqFilterLe_5609(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_5610","instance":5610,"id":192281,"goal":"lemma SeqMemberAppend_5610(zs: seq, s: seq)\n ensures x in zs + s <==> x in zs || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_5611","instance":5611,"id":192282,"goal":"lemma SeqAppendLen_5611(ys: seq, t: seq)\n ensures |ys + t| == |ys| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_5612","instance":5612,"id":192283,"goal":"lemma SeqAppendNil_5612(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_5613","instance":5613,"id":192284,"goal":"lemma SeqNilAppend_5613(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_5614","instance":5614,"id":192285,"goal":"lemma SeqAppendAssoc_5614(t: seq, ys: seq, s: seq)\n ensures (t + ys) + s == t + (ys + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_5615","instance":5615,"id":192286,"goal":"lemma SeqTakeDrop_5615(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_5616","instance":5616,"id":192287,"goal":"lemma SeqReverseLen_5616(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_5617","instance":5617,"id":192288,"goal":"lemma SeqReverseIdem_5617(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_5618","instance":5618,"id":192289,"goal":"lemma SeqMapLen_5618(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_5619","instance":5619,"id":192290,"goal":"lemma SeqFilterLe_5619(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_5620","instance":5620,"id":192291,"goal":"lemma SeqMemberAppend_5620(u: seq, s: seq)\n ensures x in u + s <==> x in u || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_5621","instance":5621,"id":192292,"goal":"lemma SeqAppendLen_5621(u: seq, s: seq)\n ensures |u + s| == |u| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_5622","instance":5622,"id":192293,"goal":"lemma SeqAppendNil_5622(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_5623","instance":5623,"id":192294,"goal":"lemma SeqNilAppend_5623(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_5624","instance":5624,"id":192295,"goal":"lemma SeqAppendAssoc_5624(ys: seq, xs: seq, t: seq)\n ensures (ys + xs) + t == ys + (xs + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_5625","instance":5625,"id":192296,"goal":"lemma SeqTakeDrop_5625(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_5626","instance":5626,"id":192297,"goal":"lemma SeqReverseLen_5626(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_5627","instance":5627,"id":192298,"goal":"lemma SeqReverseIdem_5627(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_5628","instance":5628,"id":192299,"goal":"lemma SeqMapLen_5628(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_5629","instance":5629,"id":192300,"goal":"lemma SeqFilterLe_5629(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_5630","instance":5630,"id":192301,"goal":"lemma SeqMemberAppend_5630(s: seq, t: seq)\n ensures x in s + t <==> x in s || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_5631","instance":5631,"id":192302,"goal":"lemma SeqAppendLen_5631(ys: seq, s: seq)\n ensures |ys + s| == |ys| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_5632","instance":5632,"id":192303,"goal":"lemma SeqAppendNil_5632(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_5633","instance":5633,"id":192304,"goal":"lemma SeqNilAppend_5633(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_5634","instance":5634,"id":192305,"goal":"lemma SeqAppendAssoc_5634(zs: seq, u: seq, ys: seq)\n ensures (zs + u) + ys == zs + (u + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_5635","instance":5635,"id":192306,"goal":"lemma SeqTakeDrop_5635(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_5636","instance":5636,"id":192307,"goal":"lemma SeqReverseLen_5636(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_5637","instance":5637,"id":192308,"goal":"lemma SeqReverseIdem_5637(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_5638","instance":5638,"id":192309,"goal":"lemma SeqMapLen_5638(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_5639","instance":5639,"id":192310,"goal":"lemma SeqFilterLe_5639(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_5640","instance":5640,"id":192311,"goal":"lemma SeqMemberAppend_5640(s: seq, ys: seq)\n ensures x in s + ys <==> x in s || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_5641","instance":5641,"id":192312,"goal":"lemma SeqAppendLen_5641(t: seq, u: seq)\n ensures |t + u| == |t| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_5642","instance":5642,"id":192313,"goal":"lemma SeqAppendNil_5642(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_5643","instance":5643,"id":192314,"goal":"lemma SeqNilAppend_5643(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_5644","instance":5644,"id":192315,"goal":"lemma SeqAppendAssoc_5644(ys: seq, s: seq, xs: seq)\n ensures (ys + s) + xs == ys + (s + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_5645","instance":5645,"id":192316,"goal":"lemma SeqTakeDrop_5645(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_5646","instance":5646,"id":192317,"goal":"lemma SeqReverseLen_5646(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_5647","instance":5647,"id":192318,"goal":"lemma SeqReverseIdem_5647(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_5648","instance":5648,"id":192319,"goal":"lemma SeqMapLen_5648(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_5649","instance":5649,"id":192320,"goal":"lemma SeqFilterLe_5649(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_5650","instance":5650,"id":192321,"goal":"lemma SeqMemberAppend_5650(t: seq, s: seq)\n ensures x in t + s <==> x in t || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_5651","instance":5651,"id":192322,"goal":"lemma SeqAppendLen_5651(t: seq, zs: seq)\n ensures |t + zs| == |t| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_5652","instance":5652,"id":192323,"goal":"lemma SeqAppendNil_5652(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_5653","instance":5653,"id":192324,"goal":"lemma SeqNilAppend_5653(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_5654","instance":5654,"id":192325,"goal":"lemma SeqAppendAssoc_5654(zs: seq, ys: seq, t: seq)\n ensures (zs + ys) + t == zs + (ys + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_5655","instance":5655,"id":192326,"goal":"lemma SeqTakeDrop_5655(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_5656","instance":5656,"id":192327,"goal":"lemma SeqReverseLen_5656(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_5657","instance":5657,"id":192328,"goal":"lemma SeqReverseIdem_5657(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_5658","instance":5658,"id":192329,"goal":"lemma SeqMapLen_5658(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_5659","instance":5659,"id":192330,"goal":"lemma SeqFilterLe_5659(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_5660","instance":5660,"id":192331,"goal":"lemma SeqMemberAppend_5660(s: seq, u: seq)\n ensures x in s + u <==> x in s || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_5661","instance":5661,"id":192332,"goal":"lemma SeqAppendLen_5661(s: seq, zs: seq)\n ensures |s + zs| == |s| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_5662","instance":5662,"id":192333,"goal":"lemma SeqAppendNil_5662(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_5663","instance":5663,"id":192334,"goal":"lemma SeqNilAppend_5663(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_5664","instance":5664,"id":192335,"goal":"lemma SeqAppendAssoc_5664(u: seq, t: seq, xs: seq)\n ensures (u + t) + xs == u + (t + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_5665","instance":5665,"id":192336,"goal":"lemma SeqTakeDrop_5665(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_5666","instance":5666,"id":192337,"goal":"lemma SeqReverseLen_5666(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_5667","instance":5667,"id":192338,"goal":"lemma SeqReverseIdem_5667(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_5668","instance":5668,"id":192339,"goal":"lemma SeqMapLen_5668(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_5669","instance":5669,"id":192340,"goal":"lemma SeqFilterLe_5669(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_5670","instance":5670,"id":192341,"goal":"lemma SeqMemberAppend_5670(u: seq, xs: seq)\n ensures x in u + xs <==> x in u || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_5671","instance":5671,"id":192342,"goal":"lemma SeqAppendLen_5671(ys: seq, t: seq)\n ensures |ys + t| == |ys| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_5672","instance":5672,"id":192343,"goal":"lemma SeqAppendNil_5672(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_5673","instance":5673,"id":192344,"goal":"lemma SeqNilAppend_5673(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_5674","instance":5674,"id":192345,"goal":"lemma SeqAppendAssoc_5674(t: seq, u: seq, xs: seq)\n ensures (t + u) + xs == t + (u + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_5675","instance":5675,"id":192346,"goal":"lemma SeqTakeDrop_5675(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_5676","instance":5676,"id":192347,"goal":"lemma SeqReverseLen_5676(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_5677","instance":5677,"id":192348,"goal":"lemma SeqReverseIdem_5677(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_5678","instance":5678,"id":192349,"goal":"lemma SeqMapLen_5678(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_5679","instance":5679,"id":192350,"goal":"lemma SeqFilterLe_5679(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_5680","instance":5680,"id":192351,"goal":"lemma SeqMemberAppend_5680(xs: seq, t: seq)\n ensures x in xs + t <==> x in xs || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_5681","instance":5681,"id":192352,"goal":"lemma SeqAppendLen_5681(xs: seq, t: seq)\n ensures |xs + t| == |xs| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_5682","instance":5682,"id":192353,"goal":"lemma SeqAppendNil_5682(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_5683","instance":5683,"id":192354,"goal":"lemma SeqNilAppend_5683(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_5684","instance":5684,"id":192355,"goal":"lemma SeqAppendAssoc_5684(u: seq, ys: seq, xs: seq)\n ensures (u + ys) + xs == u + (ys + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_5685","instance":5685,"id":192356,"goal":"lemma SeqTakeDrop_5685(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_5686","instance":5686,"id":192357,"goal":"lemma SeqReverseLen_5686(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_5687","instance":5687,"id":192358,"goal":"lemma SeqReverseIdem_5687(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_5688","instance":5688,"id":192359,"goal":"lemma SeqMapLen_5688(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_5689","instance":5689,"id":192360,"goal":"lemma SeqFilterLe_5689(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_5690","instance":5690,"id":192361,"goal":"lemma SeqMemberAppend_5690(xs: seq, t: seq)\n ensures x in xs + t <==> x in xs || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_5691","instance":5691,"id":192362,"goal":"lemma SeqAppendLen_5691(ys: seq, u: seq)\n ensures |ys + u| == |ys| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_5692","instance":5692,"id":192363,"goal":"lemma SeqAppendNil_5692(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_5693","instance":5693,"id":192364,"goal":"lemma SeqNilAppend_5693(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_5694","instance":5694,"id":192365,"goal":"lemma SeqAppendAssoc_5694(t: seq, u: seq, zs: seq)\n ensures (t + u) + zs == t + (u + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_5695","instance":5695,"id":192366,"goal":"lemma SeqTakeDrop_5695(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_5696","instance":5696,"id":192367,"goal":"lemma SeqReverseLen_5696(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_5697","instance":5697,"id":192368,"goal":"lemma SeqReverseIdem_5697(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_5698","instance":5698,"id":192369,"goal":"lemma SeqMapLen_5698(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_5699","instance":5699,"id":192370,"goal":"lemma SeqFilterLe_5699(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_5700","instance":5700,"id":192371,"goal":"lemma SeqMemberAppend_5700(zs: seq, s: seq)\n ensures x in zs + s <==> x in zs || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_5701","instance":5701,"id":192372,"goal":"lemma SeqAppendLen_5701(xs: seq, zs: seq)\n ensures |xs + zs| == |xs| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_5702","instance":5702,"id":192373,"goal":"lemma SeqAppendNil_5702(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_5703","instance":5703,"id":192374,"goal":"lemma SeqNilAppend_5703(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_5704","instance":5704,"id":192375,"goal":"lemma SeqAppendAssoc_5704(xs: seq, zs: seq, t: seq)\n ensures (xs + zs) + t == xs + (zs + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_5705","instance":5705,"id":192376,"goal":"lemma SeqTakeDrop_5705(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_5706","instance":5706,"id":192377,"goal":"lemma SeqReverseLen_5706(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_5707","instance":5707,"id":192378,"goal":"lemma SeqReverseIdem_5707(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_5708","instance":5708,"id":192379,"goal":"lemma SeqMapLen_5708(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_5709","instance":5709,"id":192380,"goal":"lemma SeqFilterLe_5709(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_5710","instance":5710,"id":192381,"goal":"lemma SeqMemberAppend_5710(u: seq, xs: seq)\n ensures x in u + xs <==> x in u || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_5711","instance":5711,"id":192382,"goal":"lemma SeqAppendLen_5711(s: seq, u: seq)\n ensures |s + u| == |s| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_5712","instance":5712,"id":192383,"goal":"lemma SeqAppendNil_5712(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_5713","instance":5713,"id":192384,"goal":"lemma SeqNilAppend_5713(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_5714","instance":5714,"id":192385,"goal":"lemma SeqAppendAssoc_5714(ys: seq, s: seq, xs: seq)\n ensures (ys + s) + xs == ys + (s + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_5715","instance":5715,"id":192386,"goal":"lemma SeqTakeDrop_5715(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_5716","instance":5716,"id":192387,"goal":"lemma SeqReverseLen_5716(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_5717","instance":5717,"id":192388,"goal":"lemma SeqReverseIdem_5717(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_5718","instance":5718,"id":192389,"goal":"lemma SeqMapLen_5718(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_5719","instance":5719,"id":192390,"goal":"lemma SeqFilterLe_5719(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_5720","instance":5720,"id":192391,"goal":"lemma SeqMemberAppend_5720(zs: seq, xs: seq)\n ensures x in zs + xs <==> x in zs || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_5721","instance":5721,"id":192392,"goal":"lemma SeqAppendLen_5721(s: seq, xs: seq)\n ensures |s + xs| == |s| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_5722","instance":5722,"id":192393,"goal":"lemma SeqAppendNil_5722(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_5723","instance":5723,"id":192394,"goal":"lemma SeqNilAppend_5723(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_5724","instance":5724,"id":192395,"goal":"lemma SeqAppendAssoc_5724(ys: seq, xs: seq, zs: seq)\n ensures (ys + xs) + zs == ys + (xs + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_5725","instance":5725,"id":192396,"goal":"lemma SeqTakeDrop_5725(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_5726","instance":5726,"id":192397,"goal":"lemma SeqReverseLen_5726(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_5727","instance":5727,"id":192398,"goal":"lemma SeqReverseIdem_5727(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_5728","instance":5728,"id":192399,"goal":"lemma SeqMapLen_5728(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_5729","instance":5729,"id":192400,"goal":"lemma SeqFilterLe_5729(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_5730","instance":5730,"id":192401,"goal":"lemma SeqMemberAppend_5730(u: seq, t: seq)\n ensures x in u + t <==> x in u || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_5731","instance":5731,"id":192402,"goal":"lemma SeqAppendLen_5731(xs: seq, ys: seq)\n ensures |xs + ys| == |xs| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_5732","instance":5732,"id":192403,"goal":"lemma SeqAppendNil_5732(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_5733","instance":5733,"id":192404,"goal":"lemma SeqNilAppend_5733(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_5734","instance":5734,"id":192405,"goal":"lemma SeqAppendAssoc_5734(u: seq, ys: seq, zs: seq)\n ensures (u + ys) + zs == u + (ys + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_5735","instance":5735,"id":192406,"goal":"lemma SeqTakeDrop_5735(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_5736","instance":5736,"id":192407,"goal":"lemma SeqReverseLen_5736(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_5737","instance":5737,"id":192408,"goal":"lemma SeqReverseIdem_5737(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_5738","instance":5738,"id":192409,"goal":"lemma SeqMapLen_5738(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_5739","instance":5739,"id":192410,"goal":"lemma SeqFilterLe_5739(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_5740","instance":5740,"id":192411,"goal":"lemma SeqMemberAppend_5740(u: seq, zs: seq)\n ensures x in u + zs <==> x in u || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_5741","instance":5741,"id":192412,"goal":"lemma SeqAppendLen_5741(ys: seq, xs: seq)\n ensures |ys + xs| == |ys| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_5742","instance":5742,"id":192413,"goal":"lemma SeqAppendNil_5742(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_5743","instance":5743,"id":192414,"goal":"lemma SeqNilAppend_5743(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_5744","instance":5744,"id":192415,"goal":"lemma SeqAppendAssoc_5744(zs: seq, t: seq, s: seq)\n ensures (zs + t) + s == zs + (t + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_5745","instance":5745,"id":192416,"goal":"lemma SeqTakeDrop_5745(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_5746","instance":5746,"id":192417,"goal":"lemma SeqReverseLen_5746(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_5747","instance":5747,"id":192418,"goal":"lemma SeqReverseIdem_5747(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_5748","instance":5748,"id":192419,"goal":"lemma SeqMapLen_5748(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_5749","instance":5749,"id":192420,"goal":"lemma SeqFilterLe_5749(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_5750","instance":5750,"id":192421,"goal":"lemma SeqMemberAppend_5750(t: seq, s: seq)\n ensures x in t + s <==> x in t || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_5751","instance":5751,"id":192422,"goal":"lemma SeqAppendLen_5751(xs: seq, u: seq)\n ensures |xs + u| == |xs| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_5752","instance":5752,"id":192423,"goal":"lemma SeqAppendNil_5752(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_5753","instance":5753,"id":192424,"goal":"lemma SeqNilAppend_5753(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_5754","instance":5754,"id":192425,"goal":"lemma SeqAppendAssoc_5754(t: seq, xs: seq, ys: seq)\n ensures (t + xs) + ys == t + (xs + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_5755","instance":5755,"id":192426,"goal":"lemma SeqTakeDrop_5755(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_5756","instance":5756,"id":192427,"goal":"lemma SeqReverseLen_5756(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_5757","instance":5757,"id":192428,"goal":"lemma SeqReverseIdem_5757(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_5758","instance":5758,"id":192429,"goal":"lemma SeqMapLen_5758(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_5759","instance":5759,"id":192430,"goal":"lemma SeqFilterLe_5759(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_5760","instance":5760,"id":192431,"goal":"lemma SeqMemberAppend_5760(t: seq, xs: seq)\n ensures x in t + xs <==> x in t || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_5761","instance":5761,"id":192432,"goal":"lemma SeqAppendLen_5761(zs: seq, xs: seq)\n ensures |zs + xs| == |zs| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_5762","instance":5762,"id":192433,"goal":"lemma SeqAppendNil_5762(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_5763","instance":5763,"id":192434,"goal":"lemma SeqNilAppend_5763(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_5764","instance":5764,"id":192435,"goal":"lemma SeqAppendAssoc_5764(t: seq, xs: seq, zs: seq)\n ensures (t + xs) + zs == t + (xs + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_5765","instance":5765,"id":192436,"goal":"lemma SeqTakeDrop_5765(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_5766","instance":5766,"id":192437,"goal":"lemma SeqReverseLen_5766(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_5767","instance":5767,"id":192438,"goal":"lemma SeqReverseIdem_5767(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_5768","instance":5768,"id":192439,"goal":"lemma SeqMapLen_5768(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_5769","instance":5769,"id":192440,"goal":"lemma SeqFilterLe_5769(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_5770","instance":5770,"id":192441,"goal":"lemma SeqMemberAppend_5770(t: seq, s: seq)\n ensures x in t + s <==> x in t || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_5771","instance":5771,"id":192442,"goal":"lemma SeqAppendLen_5771(xs: seq, u: seq)\n ensures |xs + u| == |xs| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_5772","instance":5772,"id":192443,"goal":"lemma SeqAppendNil_5772(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_5773","instance":5773,"id":192444,"goal":"lemma SeqNilAppend_5773(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_5774","instance":5774,"id":192445,"goal":"lemma SeqAppendAssoc_5774(ys: seq, u: seq, s: seq)\n ensures (ys + u) + s == ys + (u + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_5775","instance":5775,"id":192446,"goal":"lemma SeqTakeDrop_5775(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_5776","instance":5776,"id":192447,"goal":"lemma SeqReverseLen_5776(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_5777","instance":5777,"id":192448,"goal":"lemma SeqReverseIdem_5777(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_5778","instance":5778,"id":192449,"goal":"lemma SeqMapLen_5778(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_5779","instance":5779,"id":192450,"goal":"lemma SeqFilterLe_5779(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_5780","instance":5780,"id":192451,"goal":"lemma SeqMemberAppend_5780(t: seq, zs: seq)\n ensures x in t + zs <==> x in t || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_5781","instance":5781,"id":192452,"goal":"lemma SeqAppendLen_5781(s: seq, zs: seq)\n ensures |s + zs| == |s| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_5782","instance":5782,"id":192453,"goal":"lemma SeqAppendNil_5782(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_5783","instance":5783,"id":192454,"goal":"lemma SeqNilAppend_5783(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_5784","instance":5784,"id":192455,"goal":"lemma SeqAppendAssoc_5784(ys: seq, s: seq, zs: seq)\n ensures (ys + s) + zs == ys + (s + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_5785","instance":5785,"id":192456,"goal":"lemma SeqTakeDrop_5785(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_5786","instance":5786,"id":192457,"goal":"lemma SeqReverseLen_5786(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_5787","instance":5787,"id":192458,"goal":"lemma SeqReverseIdem_5787(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_5788","instance":5788,"id":192459,"goal":"lemma SeqMapLen_5788(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_5789","instance":5789,"id":192460,"goal":"lemma SeqFilterLe_5789(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_5790","instance":5790,"id":192461,"goal":"lemma SeqMemberAppend_5790(zs: seq, xs: seq)\n ensures x in zs + xs <==> x in zs || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_5791","instance":5791,"id":192462,"goal":"lemma SeqAppendLen_5791(ys: seq, u: seq)\n ensures |ys + u| == |ys| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_5792","instance":5792,"id":192463,"goal":"lemma SeqAppendNil_5792(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_5793","instance":5793,"id":192464,"goal":"lemma SeqNilAppend_5793(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_5794","instance":5794,"id":192465,"goal":"lemma SeqAppendAssoc_5794(xs: seq, ys: seq, s: seq)\n ensures (xs + ys) + s == xs + (ys + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_5795","instance":5795,"id":192466,"goal":"lemma SeqTakeDrop_5795(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_5796","instance":5796,"id":192467,"goal":"lemma SeqReverseLen_5796(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_5797","instance":5797,"id":192468,"goal":"lemma SeqReverseIdem_5797(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_5798","instance":5798,"id":192469,"goal":"lemma SeqMapLen_5798(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_5799","instance":5799,"id":192470,"goal":"lemma SeqFilterLe_5799(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_5800","instance":5800,"id":192471,"goal":"lemma SeqMemberAppend_5800(u: seq, zs: seq)\n ensures x in u + zs <==> x in u || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_5801","instance":5801,"id":192472,"goal":"lemma SeqAppendLen_5801(ys: seq, xs: seq)\n ensures |ys + xs| == |ys| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_5802","instance":5802,"id":192473,"goal":"lemma SeqAppendNil_5802(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_5803","instance":5803,"id":192474,"goal":"lemma SeqNilAppend_5803(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_5804","instance":5804,"id":192475,"goal":"lemma SeqAppendAssoc_5804(xs: seq, t: seq, s: seq)\n ensures (xs + t) + s == xs + (t + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_5805","instance":5805,"id":192476,"goal":"lemma SeqTakeDrop_5805(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_5806","instance":5806,"id":192477,"goal":"lemma SeqReverseLen_5806(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_5807","instance":5807,"id":192478,"goal":"lemma SeqReverseIdem_5807(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_5808","instance":5808,"id":192479,"goal":"lemma SeqMapLen_5808(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_5809","instance":5809,"id":192480,"goal":"lemma SeqFilterLe_5809(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_5810","instance":5810,"id":192481,"goal":"lemma SeqMemberAppend_5810(u: seq, xs: seq)\n ensures x in u + xs <==> x in u || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_5811","instance":5811,"id":192482,"goal":"lemma SeqAppendLen_5811(u: seq, xs: seq)\n ensures |u + xs| == |u| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_5812","instance":5812,"id":192483,"goal":"lemma SeqAppendNil_5812(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_5813","instance":5813,"id":192484,"goal":"lemma SeqNilAppend_5813(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_5814","instance":5814,"id":192485,"goal":"lemma SeqAppendAssoc_5814(u: seq, ys: seq, t: seq)\n ensures (u + ys) + t == u + (ys + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_5815","instance":5815,"id":192486,"goal":"lemma SeqTakeDrop_5815(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_5816","instance":5816,"id":192487,"goal":"lemma SeqReverseLen_5816(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_5817","instance":5817,"id":192488,"goal":"lemma SeqReverseIdem_5817(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_5818","instance":5818,"id":192489,"goal":"lemma SeqMapLen_5818(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_5819","instance":5819,"id":192490,"goal":"lemma SeqFilterLe_5819(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_5820","instance":5820,"id":192491,"goal":"lemma SeqMemberAppend_5820(s: seq, zs: seq)\n ensures x in s + zs <==> x in s || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_5821","instance":5821,"id":192492,"goal":"lemma SeqAppendLen_5821(ys: seq, u: seq)\n ensures |ys + u| == |ys| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_5822","instance":5822,"id":192493,"goal":"lemma SeqAppendNil_5822(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_5823","instance":5823,"id":192494,"goal":"lemma SeqNilAppend_5823(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_5824","instance":5824,"id":192495,"goal":"lemma SeqAppendAssoc_5824(ys: seq, xs: seq, u: seq)\n ensures (ys + xs) + u == ys + (xs + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_5825","instance":5825,"id":192496,"goal":"lemma SeqTakeDrop_5825(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_5826","instance":5826,"id":192497,"goal":"lemma SeqReverseLen_5826(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_5827","instance":5827,"id":192498,"goal":"lemma SeqReverseIdem_5827(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_5828","instance":5828,"id":192499,"goal":"lemma SeqMapLen_5828(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_5829","instance":5829,"id":192500,"goal":"lemma SeqFilterLe_5829(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_5830","instance":5830,"id":192501,"goal":"lemma SeqMemberAppend_5830(s: seq, u: seq)\n ensures x in s + u <==> x in s || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_5831","instance":5831,"id":192502,"goal":"lemma SeqAppendLen_5831(ys: seq, zs: seq)\n ensures |ys + zs| == |ys| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_5832","instance":5832,"id":192503,"goal":"lemma SeqAppendNil_5832(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_5833","instance":5833,"id":192504,"goal":"lemma SeqNilAppend_5833(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_5834","instance":5834,"id":192505,"goal":"lemma SeqAppendAssoc_5834(s: seq, zs: seq, xs: seq)\n ensures (s + zs) + xs == s + (zs + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_5835","instance":5835,"id":192506,"goal":"lemma SeqTakeDrop_5835(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_5836","instance":5836,"id":192507,"goal":"lemma SeqReverseLen_5836(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_5837","instance":5837,"id":192508,"goal":"lemma SeqReverseIdem_5837(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_5838","instance":5838,"id":192509,"goal":"lemma SeqMapLen_5838(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_5839","instance":5839,"id":192510,"goal":"lemma SeqFilterLe_5839(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_5840","instance":5840,"id":192511,"goal":"lemma SeqMemberAppend_5840(zs: seq, u: seq)\n ensures x in zs + u <==> x in zs || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_5841","instance":5841,"id":192512,"goal":"lemma SeqAppendLen_5841(t: seq, ys: seq)\n ensures |t + ys| == |t| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_5842","instance":5842,"id":192513,"goal":"lemma SeqAppendNil_5842(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_5843","instance":5843,"id":192514,"goal":"lemma SeqNilAppend_5843(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_5844","instance":5844,"id":192515,"goal":"lemma SeqAppendAssoc_5844(s: seq, xs: seq, ys: seq)\n ensures (s + xs) + ys == s + (xs + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_5845","instance":5845,"id":192516,"goal":"lemma SeqTakeDrop_5845(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_5846","instance":5846,"id":192517,"goal":"lemma SeqReverseLen_5846(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_5847","instance":5847,"id":192518,"goal":"lemma SeqReverseIdem_5847(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_5848","instance":5848,"id":192519,"goal":"lemma SeqMapLen_5848(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_5849","instance":5849,"id":192520,"goal":"lemma SeqFilterLe_5849(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_5850","instance":5850,"id":192521,"goal":"lemma SeqMemberAppend_5850(s: seq, ys: seq)\n ensures x in s + ys <==> x in s || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_5851","instance":5851,"id":192522,"goal":"lemma SeqAppendLen_5851(s: seq, zs: seq)\n ensures |s + zs| == |s| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_5852","instance":5852,"id":192523,"goal":"lemma SeqAppendNil_5852(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_5853","instance":5853,"id":192524,"goal":"lemma SeqNilAppend_5853(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_5854","instance":5854,"id":192525,"goal":"lemma SeqAppendAssoc_5854(t: seq, zs: seq, xs: seq)\n ensures (t + zs) + xs == t + (zs + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_5855","instance":5855,"id":192526,"goal":"lemma SeqTakeDrop_5855(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_5856","instance":5856,"id":192527,"goal":"lemma SeqReverseLen_5856(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_5857","instance":5857,"id":192528,"goal":"lemma SeqReverseIdem_5857(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_5858","instance":5858,"id":192529,"goal":"lemma SeqMapLen_5858(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_5859","instance":5859,"id":192530,"goal":"lemma SeqFilterLe_5859(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_5860","instance":5860,"id":192531,"goal":"lemma SeqMemberAppend_5860(xs: seq, s: seq)\n ensures x in xs + s <==> x in xs || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_5861","instance":5861,"id":192532,"goal":"lemma SeqAppendLen_5861(xs: seq, zs: seq)\n ensures |xs + zs| == |xs| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_5862","instance":5862,"id":192533,"goal":"lemma SeqAppendNil_5862(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_5863","instance":5863,"id":192534,"goal":"lemma SeqNilAppend_5863(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_5864","instance":5864,"id":192535,"goal":"lemma SeqAppendAssoc_5864(s: seq, u: seq, t: seq)\n ensures (s + u) + t == s + (u + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_5865","instance":5865,"id":192536,"goal":"lemma SeqTakeDrop_5865(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_5866","instance":5866,"id":192537,"goal":"lemma SeqReverseLen_5866(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_5867","instance":5867,"id":192538,"goal":"lemma SeqReverseIdem_5867(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_5868","instance":5868,"id":192539,"goal":"lemma SeqMapLen_5868(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_5869","instance":5869,"id":192540,"goal":"lemma SeqFilterLe_5869(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_5870","instance":5870,"id":192541,"goal":"lemma SeqMemberAppend_5870(ys: seq, t: seq)\n ensures x in ys + t <==> x in ys || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_5871","instance":5871,"id":192542,"goal":"lemma SeqAppendLen_5871(ys: seq, zs: seq)\n ensures |ys + zs| == |ys| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_5872","instance":5872,"id":192543,"goal":"lemma SeqAppendNil_5872(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_5873","instance":5873,"id":192544,"goal":"lemma SeqNilAppend_5873(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_5874","instance":5874,"id":192545,"goal":"lemma SeqAppendAssoc_5874(t: seq, xs: seq, zs: seq)\n ensures (t + xs) + zs == t + (xs + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_5875","instance":5875,"id":192546,"goal":"lemma SeqTakeDrop_5875(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_5876","instance":5876,"id":192547,"goal":"lemma SeqReverseLen_5876(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_5877","instance":5877,"id":192548,"goal":"lemma SeqReverseIdem_5877(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_5878","instance":5878,"id":192549,"goal":"lemma SeqMapLen_5878(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_5879","instance":5879,"id":192550,"goal":"lemma SeqFilterLe_5879(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_5880","instance":5880,"id":192551,"goal":"lemma SeqMemberAppend_5880(s: seq, u: seq)\n ensures x in s + u <==> x in s || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_5881","instance":5881,"id":192552,"goal":"lemma SeqAppendLen_5881(ys: seq, u: seq)\n ensures |ys + u| == |ys| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_5882","instance":5882,"id":192553,"goal":"lemma SeqAppendNil_5882(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_5883","instance":5883,"id":192554,"goal":"lemma SeqNilAppend_5883(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_5884","instance":5884,"id":192555,"goal":"lemma SeqAppendAssoc_5884(ys: seq, t: seq, s: seq)\n ensures (ys + t) + s == ys + (t + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_5885","instance":5885,"id":192556,"goal":"lemma SeqTakeDrop_5885(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_5886","instance":5886,"id":192557,"goal":"lemma SeqReverseLen_5886(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_5887","instance":5887,"id":192558,"goal":"lemma SeqReverseIdem_5887(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_5888","instance":5888,"id":192559,"goal":"lemma SeqMapLen_5888(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_5889","instance":5889,"id":192560,"goal":"lemma SeqFilterLe_5889(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_5890","instance":5890,"id":192561,"goal":"lemma SeqMemberAppend_5890(ys: seq, zs: seq)\n ensures x in ys + zs <==> x in ys || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_5891","instance":5891,"id":192562,"goal":"lemma SeqAppendLen_5891(xs: seq, t: seq)\n ensures |xs + t| == |xs| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_5892","instance":5892,"id":192563,"goal":"lemma SeqAppendNil_5892(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_5893","instance":5893,"id":192564,"goal":"lemma SeqNilAppend_5893(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_5894","instance":5894,"id":192565,"goal":"lemma SeqAppendAssoc_5894(s: seq, zs: seq, xs: seq)\n ensures (s + zs) + xs == s + (zs + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_5895","instance":5895,"id":192566,"goal":"lemma SeqTakeDrop_5895(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_5896","instance":5896,"id":192567,"goal":"lemma SeqReverseLen_5896(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_5897","instance":5897,"id":192568,"goal":"lemma SeqReverseIdem_5897(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_5898","instance":5898,"id":192569,"goal":"lemma SeqMapLen_5898(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_5899","instance":5899,"id":192570,"goal":"lemma SeqFilterLe_5899(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_5900","instance":5900,"id":192571,"goal":"lemma SeqMemberAppend_5900(xs: seq, u: seq)\n ensures x in xs + u <==> x in xs || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_5901","instance":5901,"id":192572,"goal":"lemma SeqAppendLen_5901(ys: seq, t: seq)\n ensures |ys + t| == |ys| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_5902","instance":5902,"id":192573,"goal":"lemma SeqAppendNil_5902(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_5903","instance":5903,"id":192574,"goal":"lemma SeqNilAppend_5903(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_5904","instance":5904,"id":192575,"goal":"lemma SeqAppendAssoc_5904(xs: seq, t: seq, ys: seq)\n ensures (xs + t) + ys == xs + (t + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_5905","instance":5905,"id":192576,"goal":"lemma SeqTakeDrop_5905(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_5906","instance":5906,"id":192577,"goal":"lemma SeqReverseLen_5906(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_5907","instance":5907,"id":192578,"goal":"lemma SeqReverseIdem_5907(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_5908","instance":5908,"id":192579,"goal":"lemma SeqMapLen_5908(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_5909","instance":5909,"id":192580,"goal":"lemma SeqFilterLe_5909(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_5910","instance":5910,"id":192581,"goal":"lemma SeqMemberAppend_5910(ys: seq, t: seq)\n ensures x in ys + t <==> x in ys || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_5911","instance":5911,"id":192582,"goal":"lemma SeqAppendLen_5911(t: seq, ys: seq)\n ensures |t + ys| == |t| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_5912","instance":5912,"id":192583,"goal":"lemma SeqAppendNil_5912(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_5913","instance":5913,"id":192584,"goal":"lemma SeqNilAppend_5913(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_5914","instance":5914,"id":192585,"goal":"lemma SeqAppendAssoc_5914(u: seq, ys: seq, zs: seq)\n ensures (u + ys) + zs == u + (ys + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_5915","instance":5915,"id":192586,"goal":"lemma SeqTakeDrop_5915(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_5916","instance":5916,"id":192587,"goal":"lemma SeqReverseLen_5916(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_5917","instance":5917,"id":192588,"goal":"lemma SeqReverseIdem_5917(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_5918","instance":5918,"id":192589,"goal":"lemma SeqMapLen_5918(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_5919","instance":5919,"id":192590,"goal":"lemma SeqFilterLe_5919(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_5920","instance":5920,"id":192591,"goal":"lemma SeqMemberAppend_5920(s: seq, u: seq)\n ensures x in s + u <==> x in s || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_5921","instance":5921,"id":192592,"goal":"lemma SeqAppendLen_5921(u: seq, xs: seq)\n ensures |u + xs| == |u| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_5922","instance":5922,"id":192593,"goal":"lemma SeqAppendNil_5922(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_5923","instance":5923,"id":192594,"goal":"lemma SeqNilAppend_5923(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_5924","instance":5924,"id":192595,"goal":"lemma SeqAppendAssoc_5924(t: seq, zs: seq, u: seq)\n ensures (t + zs) + u == t + (zs + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_5925","instance":5925,"id":192596,"goal":"lemma SeqTakeDrop_5925(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_5926","instance":5926,"id":192597,"goal":"lemma SeqReverseLen_5926(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_5927","instance":5927,"id":192598,"goal":"lemma SeqReverseIdem_5927(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_5928","instance":5928,"id":192599,"goal":"lemma SeqMapLen_5928(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_5929","instance":5929,"id":192600,"goal":"lemma SeqFilterLe_5929(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_5930","instance":5930,"id":192601,"goal":"lemma SeqMemberAppend_5930(xs: seq, t: seq)\n ensures x in xs + t <==> x in xs || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_5931","instance":5931,"id":192602,"goal":"lemma SeqAppendLen_5931(t: seq, xs: seq)\n ensures |t + xs| == |t| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_5932","instance":5932,"id":192603,"goal":"lemma SeqAppendNil_5932(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_5933","instance":5933,"id":192604,"goal":"lemma SeqNilAppend_5933(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_5934","instance":5934,"id":192605,"goal":"lemma SeqAppendAssoc_5934(s: seq, u: seq, ys: seq)\n ensures (s + u) + ys == s + (u + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_5935","instance":5935,"id":192606,"goal":"lemma SeqTakeDrop_5935(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_5936","instance":5936,"id":192607,"goal":"lemma SeqReverseLen_5936(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_5937","instance":5937,"id":192608,"goal":"lemma SeqReverseIdem_5937(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_5938","instance":5938,"id":192609,"goal":"lemma SeqMapLen_5938(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_5939","instance":5939,"id":192610,"goal":"lemma SeqFilterLe_5939(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_5940","instance":5940,"id":192611,"goal":"lemma SeqMemberAppend_5940(xs: seq, t: seq)\n ensures x in xs + t <==> x in xs || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_5941","instance":5941,"id":192612,"goal":"lemma SeqAppendLen_5941(s: seq, t: seq)\n ensures |s + t| == |s| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_5942","instance":5942,"id":192613,"goal":"lemma SeqAppendNil_5942(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_5943","instance":5943,"id":192614,"goal":"lemma SeqNilAppend_5943(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_5944","instance":5944,"id":192615,"goal":"lemma SeqAppendAssoc_5944(s: seq, ys: seq, u: seq)\n ensures (s + ys) + u == s + (ys + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_5945","instance":5945,"id":192616,"goal":"lemma SeqTakeDrop_5945(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_5946","instance":5946,"id":192617,"goal":"lemma SeqReverseLen_5946(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_5947","instance":5947,"id":192618,"goal":"lemma SeqReverseIdem_5947(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_5948","instance":5948,"id":192619,"goal":"lemma SeqMapLen_5948(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_5949","instance":5949,"id":192620,"goal":"lemma SeqFilterLe_5949(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_5950","instance":5950,"id":192621,"goal":"lemma SeqMemberAppend_5950(s: seq, t: seq)\n ensures x in s + t <==> x in s || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_5951","instance":5951,"id":192622,"goal":"lemma SeqAppendLen_5951(u: seq, s: seq)\n ensures |u + s| == |u| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_5952","instance":5952,"id":192623,"goal":"lemma SeqAppendNil_5952(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_5953","instance":5953,"id":192624,"goal":"lemma SeqNilAppend_5953(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_5954","instance":5954,"id":192625,"goal":"lemma SeqAppendAssoc_5954(xs: seq, u: seq, zs: seq)\n ensures (xs + u) + zs == xs + (u + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_5955","instance":5955,"id":192626,"goal":"lemma SeqTakeDrop_5955(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_5956","instance":5956,"id":192627,"goal":"lemma SeqReverseLen_5956(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_5957","instance":5957,"id":192628,"goal":"lemma SeqReverseIdem_5957(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_5958","instance":5958,"id":192629,"goal":"lemma SeqMapLen_5958(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_5959","instance":5959,"id":192630,"goal":"lemma SeqFilterLe_5959(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_5960","instance":5960,"id":192631,"goal":"lemma SeqMemberAppend_5960(t: seq, xs: seq)\n ensures x in t + xs <==> x in t || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_5961","instance":5961,"id":192632,"goal":"lemma SeqAppendLen_5961(zs: seq, ys: seq)\n ensures |zs + ys| == |zs| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_5962","instance":5962,"id":192633,"goal":"lemma SeqAppendNil_5962(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_5963","instance":5963,"id":192634,"goal":"lemma SeqNilAppend_5963(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_5964","instance":5964,"id":192635,"goal":"lemma SeqAppendAssoc_5964(xs: seq, s: seq, u: seq)\n ensures (xs + s) + u == xs + (s + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_5965","instance":5965,"id":192636,"goal":"lemma SeqTakeDrop_5965(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_5966","instance":5966,"id":192637,"goal":"lemma SeqReverseLen_5966(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_5967","instance":5967,"id":192638,"goal":"lemma SeqReverseIdem_5967(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_5968","instance":5968,"id":192639,"goal":"lemma SeqMapLen_5968(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_5969","instance":5969,"id":192640,"goal":"lemma SeqFilterLe_5969(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_5970","instance":5970,"id":192641,"goal":"lemma SeqMemberAppend_5970(zs: seq, u: seq)\n ensures x in zs + u <==> x in zs || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_5971","instance":5971,"id":192642,"goal":"lemma SeqAppendLen_5971(xs: seq, u: seq)\n ensures |xs + u| == |xs| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_5972","instance":5972,"id":192643,"goal":"lemma SeqAppendNil_5972(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_5973","instance":5973,"id":192644,"goal":"lemma SeqNilAppend_5973(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_5974","instance":5974,"id":192645,"goal":"lemma SeqAppendAssoc_5974(s: seq, xs: seq, ys: seq)\n ensures (s + xs) + ys == s + (xs + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_5975","instance":5975,"id":192646,"goal":"lemma SeqTakeDrop_5975(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_5976","instance":5976,"id":192647,"goal":"lemma SeqReverseLen_5976(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_5977","instance":5977,"id":192648,"goal":"lemma SeqReverseIdem_5977(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_5978","instance":5978,"id":192649,"goal":"lemma SeqMapLen_5978(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_5979","instance":5979,"id":192650,"goal":"lemma SeqFilterLe_5979(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_5980","instance":5980,"id":192651,"goal":"lemma SeqMemberAppend_5980(xs: seq, zs: seq)\n ensures x in xs + zs <==> x in xs || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_5981","instance":5981,"id":192652,"goal":"lemma SeqAppendLen_5981(t: seq, zs: seq)\n ensures |t + zs| == |t| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_5982","instance":5982,"id":192653,"goal":"lemma SeqAppendNil_5982(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_5983","instance":5983,"id":192654,"goal":"lemma SeqNilAppend_5983(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_5984","instance":5984,"id":192655,"goal":"lemma SeqAppendAssoc_5984(t: seq, xs: seq, ys: seq)\n ensures (t + xs) + ys == t + (xs + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_5985","instance":5985,"id":192656,"goal":"lemma SeqTakeDrop_5985(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_5986","instance":5986,"id":192657,"goal":"lemma SeqReverseLen_5986(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_5987","instance":5987,"id":192658,"goal":"lemma SeqReverseIdem_5987(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_5988","instance":5988,"id":192659,"goal":"lemma SeqMapLen_5988(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_5989","instance":5989,"id":192660,"goal":"lemma SeqFilterLe_5989(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_5990","instance":5990,"id":192661,"goal":"lemma SeqMemberAppend_5990(u: seq, ys: seq)\n ensures x in u + ys <==> x in u || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_5991","instance":5991,"id":192662,"goal":"lemma SeqAppendLen_5991(xs: seq, s: seq)\n ensures |xs + s| == |xs| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_5992","instance":5992,"id":192663,"goal":"lemma SeqAppendNil_5992(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_5993","instance":5993,"id":192664,"goal":"lemma SeqNilAppend_5993(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_5994","instance":5994,"id":192665,"goal":"lemma SeqAppendAssoc_5994(u: seq, ys: seq, t: seq)\n ensures (u + ys) + t == u + (ys + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_5995","instance":5995,"id":192666,"goal":"lemma SeqTakeDrop_5995(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_5996","instance":5996,"id":192667,"goal":"lemma SeqReverseLen_5996(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_5997","instance":5997,"id":192668,"goal":"lemma SeqReverseIdem_5997(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_5998","instance":5998,"id":192669,"goal":"lemma SeqMapLen_5998(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_5999","instance":5999,"id":192670,"goal":"lemma SeqFilterLe_5999(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_6000","instance":6000,"id":192671,"goal":"lemma SeqMemberAppend_6000(ys: seq, t: seq)\n ensures x in ys + t <==> x in ys || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_6001","instance":6001,"id":192672,"goal":"lemma SeqAppendLen_6001(t: seq, zs: seq)\n ensures |t + zs| == |t| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_6002","instance":6002,"id":192673,"goal":"lemma SeqAppendNil_6002(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_6003","instance":6003,"id":192674,"goal":"lemma SeqNilAppend_6003(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_6004","instance":6004,"id":192675,"goal":"lemma SeqAppendAssoc_6004(t: seq, s: seq, ys: seq)\n ensures (t + s) + ys == t + (s + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_6005","instance":6005,"id":192676,"goal":"lemma SeqTakeDrop_6005(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_6006","instance":6006,"id":192677,"goal":"lemma SeqReverseLen_6006(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_6007","instance":6007,"id":192678,"goal":"lemma SeqReverseIdem_6007(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_6008","instance":6008,"id":192679,"goal":"lemma SeqMapLen_6008(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_6009","instance":6009,"id":192680,"goal":"lemma SeqFilterLe_6009(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_6010","instance":6010,"id":192681,"goal":"lemma SeqMemberAppend_6010(s: seq, t: seq)\n ensures x in s + t <==> x in s || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_6011","instance":6011,"id":192682,"goal":"lemma SeqAppendLen_6011(s: seq, t: seq)\n ensures |s + t| == |s| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_6012","instance":6012,"id":192683,"goal":"lemma SeqAppendNil_6012(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_6013","instance":6013,"id":192684,"goal":"lemma SeqNilAppend_6013(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_6014","instance":6014,"id":192685,"goal":"lemma SeqAppendAssoc_6014(u: seq, xs: seq, t: seq)\n ensures (u + xs) + t == u + (xs + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_6015","instance":6015,"id":192686,"goal":"lemma SeqTakeDrop_6015(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_6016","instance":6016,"id":192687,"goal":"lemma SeqReverseLen_6016(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_6017","instance":6017,"id":192688,"goal":"lemma SeqReverseIdem_6017(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_6018","instance":6018,"id":192689,"goal":"lemma SeqMapLen_6018(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_6019","instance":6019,"id":192690,"goal":"lemma SeqFilterLe_6019(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_6020","instance":6020,"id":192691,"goal":"lemma SeqMemberAppend_6020(t: seq, s: seq)\n ensures x in t + s <==> x in t || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_6021","instance":6021,"id":192692,"goal":"lemma SeqAppendLen_6021(xs: seq, s: seq)\n ensures |xs + s| == |xs| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_6022","instance":6022,"id":192693,"goal":"lemma SeqAppendNil_6022(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_6023","instance":6023,"id":192694,"goal":"lemma SeqNilAppend_6023(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_6024","instance":6024,"id":192695,"goal":"lemma SeqAppendAssoc_6024(ys: seq, t: seq, s: seq)\n ensures (ys + t) + s == ys + (t + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_6025","instance":6025,"id":192696,"goal":"lemma SeqTakeDrop_6025(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_6026","instance":6026,"id":192697,"goal":"lemma SeqReverseLen_6026(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_6027","instance":6027,"id":192698,"goal":"lemma SeqReverseIdem_6027(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_6028","instance":6028,"id":192699,"goal":"lemma SeqMapLen_6028(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_6029","instance":6029,"id":192700,"goal":"lemma SeqFilterLe_6029(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_6030","instance":6030,"id":192701,"goal":"lemma SeqMemberAppend_6030(zs: seq, ys: seq)\n ensures x in zs + ys <==> x in zs || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_6031","instance":6031,"id":192702,"goal":"lemma SeqAppendLen_6031(zs: seq, s: seq)\n ensures |zs + s| == |zs| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_6032","instance":6032,"id":192703,"goal":"lemma SeqAppendNil_6032(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_6033","instance":6033,"id":192704,"goal":"lemma SeqNilAppend_6033(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_6034","instance":6034,"id":192705,"goal":"lemma SeqAppendAssoc_6034(s: seq, u: seq, zs: seq)\n ensures (s + u) + zs == s + (u + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_6035","instance":6035,"id":192706,"goal":"lemma SeqTakeDrop_6035(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_6036","instance":6036,"id":192707,"goal":"lemma SeqReverseLen_6036(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_6037","instance":6037,"id":192708,"goal":"lemma SeqReverseIdem_6037(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_6038","instance":6038,"id":192709,"goal":"lemma SeqMapLen_6038(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_6039","instance":6039,"id":192710,"goal":"lemma SeqFilterLe_6039(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_6040","instance":6040,"id":192711,"goal":"lemma SeqMemberAppend_6040(s: seq, u: seq)\n ensures x in s + u <==> x in s || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_6041","instance":6041,"id":192712,"goal":"lemma SeqAppendLen_6041(t: seq, zs: seq)\n ensures |t + zs| == |t| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_6042","instance":6042,"id":192713,"goal":"lemma SeqAppendNil_6042(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_6043","instance":6043,"id":192714,"goal":"lemma SeqNilAppend_6043(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_6044","instance":6044,"id":192715,"goal":"lemma SeqAppendAssoc_6044(ys: seq, t: seq, u: seq)\n ensures (ys + t) + u == ys + (t + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_6045","instance":6045,"id":192716,"goal":"lemma SeqTakeDrop_6045(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_6046","instance":6046,"id":192717,"goal":"lemma SeqReverseLen_6046(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_6047","instance":6047,"id":192718,"goal":"lemma SeqReverseIdem_6047(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_6048","instance":6048,"id":192719,"goal":"lemma SeqMapLen_6048(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_6049","instance":6049,"id":192720,"goal":"lemma SeqFilterLe_6049(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_6050","instance":6050,"id":192721,"goal":"lemma SeqMemberAppend_6050(s: seq, t: seq)\n ensures x in s + t <==> x in s || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_6051","instance":6051,"id":192722,"goal":"lemma SeqAppendLen_6051(u: seq, zs: seq)\n ensures |u + zs| == |u| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_6052","instance":6052,"id":192723,"goal":"lemma SeqAppendNil_6052(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_6053","instance":6053,"id":192724,"goal":"lemma SeqNilAppend_6053(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_6054","instance":6054,"id":192725,"goal":"lemma SeqAppendAssoc_6054(s: seq, t: seq, ys: seq)\n ensures (s + t) + ys == s + (t + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_6055","instance":6055,"id":192726,"goal":"lemma SeqTakeDrop_6055(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_6056","instance":6056,"id":192727,"goal":"lemma SeqReverseLen_6056(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_6057","instance":6057,"id":192728,"goal":"lemma SeqReverseIdem_6057(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_6058","instance":6058,"id":192729,"goal":"lemma SeqMapLen_6058(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_6059","instance":6059,"id":192730,"goal":"lemma SeqFilterLe_6059(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_6060","instance":6060,"id":192731,"goal":"lemma SeqMemberAppend_6060(s: seq, zs: seq)\n ensures x in s + zs <==> x in s || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_6061","instance":6061,"id":192732,"goal":"lemma SeqAppendLen_6061(ys: seq, u: seq)\n ensures |ys + u| == |ys| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_6062","instance":6062,"id":192733,"goal":"lemma SeqAppendNil_6062(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_6063","instance":6063,"id":192734,"goal":"lemma SeqNilAppend_6063(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_6064","instance":6064,"id":192735,"goal":"lemma SeqAppendAssoc_6064(u: seq, xs: seq, t: seq)\n ensures (u + xs) + t == u + (xs + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_6065","instance":6065,"id":192736,"goal":"lemma SeqTakeDrop_6065(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_6066","instance":6066,"id":192737,"goal":"lemma SeqReverseLen_6066(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_6067","instance":6067,"id":192738,"goal":"lemma SeqReverseIdem_6067(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_6068","instance":6068,"id":192739,"goal":"lemma SeqMapLen_6068(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_6069","instance":6069,"id":192740,"goal":"lemma SeqFilterLe_6069(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_6070","instance":6070,"id":192741,"goal":"lemma SeqMemberAppend_6070(s: seq, t: seq)\n ensures x in s + t <==> x in s || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_6071","instance":6071,"id":192742,"goal":"lemma SeqAppendLen_6071(t: seq, s: seq)\n ensures |t + s| == |t| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_6072","instance":6072,"id":192743,"goal":"lemma SeqAppendNil_6072(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_6073","instance":6073,"id":192744,"goal":"lemma SeqNilAppend_6073(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_6074","instance":6074,"id":192745,"goal":"lemma SeqAppendAssoc_6074(t: seq, s: seq, u: seq)\n ensures (t + s) + u == t + (s + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_6075","instance":6075,"id":192746,"goal":"lemma SeqTakeDrop_6075(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_6076","instance":6076,"id":192747,"goal":"lemma SeqReverseLen_6076(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_6077","instance":6077,"id":192748,"goal":"lemma SeqReverseIdem_6077(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_6078","instance":6078,"id":192749,"goal":"lemma SeqMapLen_6078(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_6079","instance":6079,"id":192750,"goal":"lemma SeqFilterLe_6079(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_6080","instance":6080,"id":192751,"goal":"lemma SeqMemberAppend_6080(xs: seq, t: seq)\n ensures x in xs + t <==> x in xs || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_6081","instance":6081,"id":192752,"goal":"lemma SeqAppendLen_6081(ys: seq, zs: seq)\n ensures |ys + zs| == |ys| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_6082","instance":6082,"id":192753,"goal":"lemma SeqAppendNil_6082(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_6083","instance":6083,"id":192754,"goal":"lemma SeqNilAppend_6083(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_6084","instance":6084,"id":192755,"goal":"lemma SeqAppendAssoc_6084(t: seq, u: seq, s: seq)\n ensures (t + u) + s == t + (u + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_6085","instance":6085,"id":192756,"goal":"lemma SeqTakeDrop_6085(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_6086","instance":6086,"id":192757,"goal":"lemma SeqReverseLen_6086(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_6087","instance":6087,"id":192758,"goal":"lemma SeqReverseIdem_6087(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_6088","instance":6088,"id":192759,"goal":"lemma SeqMapLen_6088(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_6089","instance":6089,"id":192760,"goal":"lemma SeqFilterLe_6089(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_6090","instance":6090,"id":192761,"goal":"lemma SeqMemberAppend_6090(zs: seq, xs: seq)\n ensures x in zs + xs <==> x in zs || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_6091","instance":6091,"id":192762,"goal":"lemma SeqAppendLen_6091(xs: seq, s: seq)\n ensures |xs + s| == |xs| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_6092","instance":6092,"id":192763,"goal":"lemma SeqAppendNil_6092(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_6093","instance":6093,"id":192764,"goal":"lemma SeqNilAppend_6093(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_6094","instance":6094,"id":192765,"goal":"lemma SeqAppendAssoc_6094(s: seq, t: seq, ys: seq)\n ensures (s + t) + ys == s + (t + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_6095","instance":6095,"id":192766,"goal":"lemma SeqTakeDrop_6095(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_6096","instance":6096,"id":192767,"goal":"lemma SeqReverseLen_6096(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_6097","instance":6097,"id":192768,"goal":"lemma SeqReverseIdem_6097(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_6098","instance":6098,"id":192769,"goal":"lemma SeqMapLen_6098(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_6099","instance":6099,"id":192770,"goal":"lemma SeqFilterLe_6099(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_6100","instance":6100,"id":192771,"goal":"lemma SeqMemberAppend_6100(zs: seq, t: seq)\n ensures x in zs + t <==> x in zs || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_6101","instance":6101,"id":192772,"goal":"lemma SeqAppendLen_6101(t: seq, s: seq)\n ensures |t + s| == |t| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_6102","instance":6102,"id":192773,"goal":"lemma SeqAppendNil_6102(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_6103","instance":6103,"id":192774,"goal":"lemma SeqNilAppend_6103(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_6104","instance":6104,"id":192775,"goal":"lemma SeqAppendAssoc_6104(u: seq, xs: seq, ys: seq)\n ensures (u + xs) + ys == u + (xs + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_6105","instance":6105,"id":192776,"goal":"lemma SeqTakeDrop_6105(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_6106","instance":6106,"id":192777,"goal":"lemma SeqReverseLen_6106(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_6107","instance":6107,"id":192778,"goal":"lemma SeqReverseIdem_6107(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_6108","instance":6108,"id":192779,"goal":"lemma SeqMapLen_6108(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_6109","instance":6109,"id":192780,"goal":"lemma SeqFilterLe_6109(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_6110","instance":6110,"id":192781,"goal":"lemma SeqMemberAppend_6110(xs: seq, zs: seq)\n ensures x in xs + zs <==> x in xs || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_6111","instance":6111,"id":192782,"goal":"lemma SeqAppendLen_6111(u: seq, s: seq)\n ensures |u + s| == |u| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_6112","instance":6112,"id":192783,"goal":"lemma SeqAppendNil_6112(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_6113","instance":6113,"id":192784,"goal":"lemma SeqNilAppend_6113(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_6114","instance":6114,"id":192785,"goal":"lemma SeqAppendAssoc_6114(u: seq, zs: seq, ys: seq)\n ensures (u + zs) + ys == u + (zs + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_6115","instance":6115,"id":192786,"goal":"lemma SeqTakeDrop_6115(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_6116","instance":6116,"id":192787,"goal":"lemma SeqReverseLen_6116(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_6117","instance":6117,"id":192788,"goal":"lemma SeqReverseIdem_6117(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_6118","instance":6118,"id":192789,"goal":"lemma SeqMapLen_6118(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_6119","instance":6119,"id":192790,"goal":"lemma SeqFilterLe_6119(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_6120","instance":6120,"id":192791,"goal":"lemma SeqMemberAppend_6120(u: seq, xs: seq)\n ensures x in u + xs <==> x in u || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_6121","instance":6121,"id":192792,"goal":"lemma SeqAppendLen_6121(t: seq, ys: seq)\n ensures |t + ys| == |t| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_6122","instance":6122,"id":192793,"goal":"lemma SeqAppendNil_6122(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_6123","instance":6123,"id":192794,"goal":"lemma SeqNilAppend_6123(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_6124","instance":6124,"id":192795,"goal":"lemma SeqAppendAssoc_6124(u: seq, zs: seq, t: seq)\n ensures (u + zs) + t == u + (zs + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_6125","instance":6125,"id":192796,"goal":"lemma SeqTakeDrop_6125(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_6126","instance":6126,"id":192797,"goal":"lemma SeqReverseLen_6126(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_6127","instance":6127,"id":192798,"goal":"lemma SeqReverseIdem_6127(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_6128","instance":6128,"id":192799,"goal":"lemma SeqMapLen_6128(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_6129","instance":6129,"id":192800,"goal":"lemma SeqFilterLe_6129(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_6130","instance":6130,"id":192801,"goal":"lemma SeqMemberAppend_6130(zs: seq, xs: seq)\n ensures x in zs + xs <==> x in zs || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_6131","instance":6131,"id":192802,"goal":"lemma SeqAppendLen_6131(u: seq, xs: seq)\n ensures |u + xs| == |u| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_6132","instance":6132,"id":192803,"goal":"lemma SeqAppendNil_6132(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_6133","instance":6133,"id":192804,"goal":"lemma SeqNilAppend_6133(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_6134","instance":6134,"id":192805,"goal":"lemma SeqAppendAssoc_6134(s: seq, ys: seq, t: seq)\n ensures (s + ys) + t == s + (ys + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_6135","instance":6135,"id":192806,"goal":"lemma SeqTakeDrop_6135(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_6136","instance":6136,"id":192807,"goal":"lemma SeqReverseLen_6136(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_6137","instance":6137,"id":192808,"goal":"lemma SeqReverseIdem_6137(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_6138","instance":6138,"id":192809,"goal":"lemma SeqMapLen_6138(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_6139","instance":6139,"id":192810,"goal":"lemma SeqFilterLe_6139(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_6140","instance":6140,"id":192811,"goal":"lemma SeqMemberAppend_6140(zs: seq, ys: seq)\n ensures x in zs + ys <==> x in zs || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_6141","instance":6141,"id":192812,"goal":"lemma SeqAppendLen_6141(zs: seq, xs: seq)\n ensures |zs + xs| == |zs| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_6142","instance":6142,"id":192813,"goal":"lemma SeqAppendNil_6142(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_6143","instance":6143,"id":192814,"goal":"lemma SeqNilAppend_6143(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_6144","instance":6144,"id":192815,"goal":"lemma SeqAppendAssoc_6144(zs: seq, t: seq, xs: seq)\n ensures (zs + t) + xs == zs + (t + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_6145","instance":6145,"id":192816,"goal":"lemma SeqTakeDrop_6145(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_6146","instance":6146,"id":192817,"goal":"lemma SeqReverseLen_6146(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_6147","instance":6147,"id":192818,"goal":"lemma SeqReverseIdem_6147(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_6148","instance":6148,"id":192819,"goal":"lemma SeqMapLen_6148(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_6149","instance":6149,"id":192820,"goal":"lemma SeqFilterLe_6149(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_6150","instance":6150,"id":192821,"goal":"lemma SeqMemberAppend_6150(u: seq, xs: seq)\n ensures x in u + xs <==> x in u || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_6151","instance":6151,"id":192822,"goal":"lemma SeqAppendLen_6151(xs: seq, t: seq)\n ensures |xs + t| == |xs| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_6152","instance":6152,"id":192823,"goal":"lemma SeqAppendNil_6152(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_6153","instance":6153,"id":192824,"goal":"lemma SeqNilAppend_6153(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_6154","instance":6154,"id":192825,"goal":"lemma SeqAppendAssoc_6154(u: seq, ys: seq, zs: seq)\n ensures (u + ys) + zs == u + (ys + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_6155","instance":6155,"id":192826,"goal":"lemma SeqTakeDrop_6155(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_6156","instance":6156,"id":192827,"goal":"lemma SeqReverseLen_6156(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_6157","instance":6157,"id":192828,"goal":"lemma SeqReverseIdem_6157(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_6158","instance":6158,"id":192829,"goal":"lemma SeqMapLen_6158(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_6159","instance":6159,"id":192830,"goal":"lemma SeqFilterLe_6159(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_6160","instance":6160,"id":192831,"goal":"lemma SeqMemberAppend_6160(t: seq, zs: seq)\n ensures x in t + zs <==> x in t || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_6161","instance":6161,"id":192832,"goal":"lemma SeqAppendLen_6161(zs: seq, u: seq)\n ensures |zs + u| == |zs| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_6162","instance":6162,"id":192833,"goal":"lemma SeqAppendNil_6162(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_6163","instance":6163,"id":192834,"goal":"lemma SeqNilAppend_6163(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_6164","instance":6164,"id":192835,"goal":"lemma SeqAppendAssoc_6164(s: seq, ys: seq, zs: seq)\n ensures (s + ys) + zs == s + (ys + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_6165","instance":6165,"id":192836,"goal":"lemma SeqTakeDrop_6165(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_6166","instance":6166,"id":192837,"goal":"lemma SeqReverseLen_6166(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_6167","instance":6167,"id":192838,"goal":"lemma SeqReverseIdem_6167(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_6168","instance":6168,"id":192839,"goal":"lemma SeqMapLen_6168(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_6169","instance":6169,"id":192840,"goal":"lemma SeqFilterLe_6169(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_6170","instance":6170,"id":192841,"goal":"lemma SeqMemberAppend_6170(ys: seq, u: seq)\n ensures x in ys + u <==> x in ys || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_6171","instance":6171,"id":192842,"goal":"lemma SeqAppendLen_6171(zs: seq, ys: seq)\n ensures |zs + ys| == |zs| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_6172","instance":6172,"id":192843,"goal":"lemma SeqAppendNil_6172(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_6173","instance":6173,"id":192844,"goal":"lemma SeqNilAppend_6173(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_6174","instance":6174,"id":192845,"goal":"lemma SeqAppendAssoc_6174(u: seq, t: seq, s: seq)\n ensures (u + t) + s == u + (t + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_6175","instance":6175,"id":192846,"goal":"lemma SeqTakeDrop_6175(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_6176","instance":6176,"id":192847,"goal":"lemma SeqReverseLen_6176(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_6177","instance":6177,"id":192848,"goal":"lemma SeqReverseIdem_6177(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_6178","instance":6178,"id":192849,"goal":"lemma SeqMapLen_6178(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_6179","instance":6179,"id":192850,"goal":"lemma SeqFilterLe_6179(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_6180","instance":6180,"id":192851,"goal":"lemma SeqMemberAppend_6180(t: seq, u: seq)\n ensures x in t + u <==> x in t || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_6181","instance":6181,"id":192852,"goal":"lemma SeqAppendLen_6181(ys: seq, s: seq)\n ensures |ys + s| == |ys| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_6182","instance":6182,"id":192853,"goal":"lemma SeqAppendNil_6182(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_6183","instance":6183,"id":192854,"goal":"lemma SeqNilAppend_6183(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_6184","instance":6184,"id":192855,"goal":"lemma SeqAppendAssoc_6184(ys: seq, zs: seq, s: seq)\n ensures (ys + zs) + s == ys + (zs + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_6185","instance":6185,"id":192856,"goal":"lemma SeqTakeDrop_6185(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_6186","instance":6186,"id":192857,"goal":"lemma SeqReverseLen_6186(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_6187","instance":6187,"id":192858,"goal":"lemma SeqReverseIdem_6187(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_6188","instance":6188,"id":192859,"goal":"lemma SeqMapLen_6188(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_6189","instance":6189,"id":192860,"goal":"lemma SeqFilterLe_6189(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_6190","instance":6190,"id":192861,"goal":"lemma SeqMemberAppend_6190(u: seq, xs: seq)\n ensures x in u + xs <==> x in u || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_6191","instance":6191,"id":192862,"goal":"lemma SeqAppendLen_6191(u: seq, t: seq)\n ensures |u + t| == |u| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_6192","instance":6192,"id":192863,"goal":"lemma SeqAppendNil_6192(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_6193","instance":6193,"id":192864,"goal":"lemma SeqNilAppend_6193(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_6194","instance":6194,"id":192865,"goal":"lemma SeqAppendAssoc_6194(u: seq, s: seq, ys: seq)\n ensures (u + s) + ys == u + (s + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_6195","instance":6195,"id":192866,"goal":"lemma SeqTakeDrop_6195(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_6196","instance":6196,"id":192867,"goal":"lemma SeqReverseLen_6196(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_6197","instance":6197,"id":192868,"goal":"lemma SeqReverseIdem_6197(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_6198","instance":6198,"id":192869,"goal":"lemma SeqMapLen_6198(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_6199","instance":6199,"id":192870,"goal":"lemma SeqFilterLe_6199(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_6200","instance":6200,"id":192871,"goal":"lemma SeqMemberAppend_6200(ys: seq, t: seq)\n ensures x in ys + t <==> x in ys || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_6201","instance":6201,"id":192872,"goal":"lemma SeqAppendLen_6201(xs: seq, zs: seq)\n ensures |xs + zs| == |xs| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_6202","instance":6202,"id":192873,"goal":"lemma SeqAppendNil_6202(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_6203","instance":6203,"id":192874,"goal":"lemma SeqNilAppend_6203(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_6204","instance":6204,"id":192875,"goal":"lemma SeqAppendAssoc_6204(xs: seq, u: seq, zs: seq)\n ensures (xs + u) + zs == xs + (u + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_6205","instance":6205,"id":192876,"goal":"lemma SeqTakeDrop_6205(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_6206","instance":6206,"id":192877,"goal":"lemma SeqReverseLen_6206(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_6207","instance":6207,"id":192878,"goal":"lemma SeqReverseIdem_6207(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_6208","instance":6208,"id":192879,"goal":"lemma SeqMapLen_6208(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_6209","instance":6209,"id":192880,"goal":"lemma SeqFilterLe_6209(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_6210","instance":6210,"id":192881,"goal":"lemma SeqMemberAppend_6210(zs: seq, s: seq)\n ensures x in zs + s <==> x in zs || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_6211","instance":6211,"id":192882,"goal":"lemma SeqAppendLen_6211(u: seq, ys: seq)\n ensures |u + ys| == |u| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_6212","instance":6212,"id":192883,"goal":"lemma SeqAppendNil_6212(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_6213","instance":6213,"id":192884,"goal":"lemma SeqNilAppend_6213(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_6214","instance":6214,"id":192885,"goal":"lemma SeqAppendAssoc_6214(zs: seq, u: seq, t: seq)\n ensures (zs + u) + t == zs + (u + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_6215","instance":6215,"id":192886,"goal":"lemma SeqTakeDrop_6215(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_6216","instance":6216,"id":192887,"goal":"lemma SeqReverseLen_6216(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_6217","instance":6217,"id":192888,"goal":"lemma SeqReverseIdem_6217(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_6218","instance":6218,"id":192889,"goal":"lemma SeqMapLen_6218(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_6219","instance":6219,"id":192890,"goal":"lemma SeqFilterLe_6219(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_6220","instance":6220,"id":192891,"goal":"lemma SeqMemberAppend_6220(ys: seq, t: seq)\n ensures x in ys + t <==> x in ys || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_6221","instance":6221,"id":192892,"goal":"lemma SeqAppendLen_6221(t: seq, xs: seq)\n ensures |t + xs| == |t| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_6222","instance":6222,"id":192893,"goal":"lemma SeqAppendNil_6222(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_6223","instance":6223,"id":192894,"goal":"lemma SeqNilAppend_6223(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_6224","instance":6224,"id":192895,"goal":"lemma SeqAppendAssoc_6224(s: seq, xs: seq, u: seq)\n ensures (s + xs) + u == s + (xs + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_6225","instance":6225,"id":192896,"goal":"lemma SeqTakeDrop_6225(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_6226","instance":6226,"id":192897,"goal":"lemma SeqReverseLen_6226(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_6227","instance":6227,"id":192898,"goal":"lemma SeqReverseIdem_6227(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_6228","instance":6228,"id":192899,"goal":"lemma SeqMapLen_6228(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_6229","instance":6229,"id":192900,"goal":"lemma SeqFilterLe_6229(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_6230","instance":6230,"id":192901,"goal":"lemma SeqMemberAppend_6230(t: seq, ys: seq)\n ensures x in t + ys <==> x in t || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_6231","instance":6231,"id":192902,"goal":"lemma SeqAppendLen_6231(zs: seq, t: seq)\n ensures |zs + t| == |zs| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_6232","instance":6232,"id":192903,"goal":"lemma SeqAppendNil_6232(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_6233","instance":6233,"id":192904,"goal":"lemma SeqNilAppend_6233(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_6234","instance":6234,"id":192905,"goal":"lemma SeqAppendAssoc_6234(s: seq, zs: seq, ys: seq)\n ensures (s + zs) + ys == s + (zs + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_6235","instance":6235,"id":192906,"goal":"lemma SeqTakeDrop_6235(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_6236","instance":6236,"id":192907,"goal":"lemma SeqReverseLen_6236(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_6237","instance":6237,"id":192908,"goal":"lemma SeqReverseIdem_6237(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_6238","instance":6238,"id":192909,"goal":"lemma SeqMapLen_6238(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_6239","instance":6239,"id":192910,"goal":"lemma SeqFilterLe_6239(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_6240","instance":6240,"id":192911,"goal":"lemma SeqMemberAppend_6240(ys: seq, xs: seq)\n ensures x in ys + xs <==> x in ys || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_6241","instance":6241,"id":192912,"goal":"lemma SeqAppendLen_6241(xs: seq, s: seq)\n ensures |xs + s| == |xs| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_6242","instance":6242,"id":192913,"goal":"lemma SeqAppendNil_6242(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_6243","instance":6243,"id":192914,"goal":"lemma SeqNilAppend_6243(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_6244","instance":6244,"id":192915,"goal":"lemma SeqAppendAssoc_6244(t: seq, xs: seq, u: seq)\n ensures (t + xs) + u == t + (xs + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_6245","instance":6245,"id":192916,"goal":"lemma SeqTakeDrop_6245(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_6246","instance":6246,"id":192917,"goal":"lemma SeqReverseLen_6246(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_6247","instance":6247,"id":192918,"goal":"lemma SeqReverseIdem_6247(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_6248","instance":6248,"id":192919,"goal":"lemma SeqMapLen_6248(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_6249","instance":6249,"id":192920,"goal":"lemma SeqFilterLe_6249(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_6250","instance":6250,"id":192921,"goal":"lemma SeqMemberAppend_6250(u: seq, zs: seq)\n ensures x in u + zs <==> x in u || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_6251","instance":6251,"id":192922,"goal":"lemma SeqAppendLen_6251(xs: seq, u: seq)\n ensures |xs + u| == |xs| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_6252","instance":6252,"id":192923,"goal":"lemma SeqAppendNil_6252(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_6253","instance":6253,"id":192924,"goal":"lemma SeqNilAppend_6253(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_6254","instance":6254,"id":192925,"goal":"lemma SeqAppendAssoc_6254(ys: seq, t: seq, s: seq)\n ensures (ys + t) + s == ys + (t + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_6255","instance":6255,"id":192926,"goal":"lemma SeqTakeDrop_6255(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_6256","instance":6256,"id":192927,"goal":"lemma SeqReverseLen_6256(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_6257","instance":6257,"id":192928,"goal":"lemma SeqReverseIdem_6257(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_6258","instance":6258,"id":192929,"goal":"lemma SeqMapLen_6258(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_6259","instance":6259,"id":192930,"goal":"lemma SeqFilterLe_6259(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_6260","instance":6260,"id":192931,"goal":"lemma SeqMemberAppend_6260(ys: seq, u: seq)\n ensures x in ys + u <==> x in ys || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_6261","instance":6261,"id":192932,"goal":"lemma SeqAppendLen_6261(ys: seq, xs: seq)\n ensures |ys + xs| == |ys| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_6262","instance":6262,"id":192933,"goal":"lemma SeqAppendNil_6262(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_6263","instance":6263,"id":192934,"goal":"lemma SeqNilAppend_6263(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_6264","instance":6264,"id":192935,"goal":"lemma SeqAppendAssoc_6264(zs: seq, xs: seq, s: seq)\n ensures (zs + xs) + s == zs + (xs + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_6265","instance":6265,"id":192936,"goal":"lemma SeqTakeDrop_6265(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_6266","instance":6266,"id":192937,"goal":"lemma SeqReverseLen_6266(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_6267","instance":6267,"id":192938,"goal":"lemma SeqReverseIdem_6267(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_6268","instance":6268,"id":192939,"goal":"lemma SeqMapLen_6268(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_6269","instance":6269,"id":192940,"goal":"lemma SeqFilterLe_6269(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_6270","instance":6270,"id":192941,"goal":"lemma SeqMemberAppend_6270(ys: seq, xs: seq)\n ensures x in ys + xs <==> x in ys || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_6271","instance":6271,"id":192942,"goal":"lemma SeqAppendLen_6271(ys: seq, t: seq)\n ensures |ys + t| == |ys| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_6272","instance":6272,"id":192943,"goal":"lemma SeqAppendNil_6272(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_6273","instance":6273,"id":192944,"goal":"lemma SeqNilAppend_6273(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_6274","instance":6274,"id":192945,"goal":"lemma SeqAppendAssoc_6274(t: seq, u: seq, ys: seq)\n ensures (t + u) + ys == t + (u + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_6275","instance":6275,"id":192946,"goal":"lemma SeqTakeDrop_6275(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_6276","instance":6276,"id":192947,"goal":"lemma SeqReverseLen_6276(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_6277","instance":6277,"id":192948,"goal":"lemma SeqReverseIdem_6277(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_6278","instance":6278,"id":192949,"goal":"lemma SeqMapLen_6278(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_6279","instance":6279,"id":192950,"goal":"lemma SeqFilterLe_6279(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_6280","instance":6280,"id":192951,"goal":"lemma SeqMemberAppend_6280(t: seq, u: seq)\n ensures x in t + u <==> x in t || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_6281","instance":6281,"id":192952,"goal":"lemma SeqAppendLen_6281(xs: seq, s: seq)\n ensures |xs + s| == |xs| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_6282","instance":6282,"id":192953,"goal":"lemma SeqAppendNil_6282(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_6283","instance":6283,"id":192954,"goal":"lemma SeqNilAppend_6283(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_6284","instance":6284,"id":192955,"goal":"lemma SeqAppendAssoc_6284(xs: seq, t: seq, ys: seq)\n ensures (xs + t) + ys == xs + (t + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_6285","instance":6285,"id":192956,"goal":"lemma SeqTakeDrop_6285(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_6286","instance":6286,"id":192957,"goal":"lemma SeqReverseLen_6286(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_6287","instance":6287,"id":192958,"goal":"lemma SeqReverseIdem_6287(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_6288","instance":6288,"id":192959,"goal":"lemma SeqMapLen_6288(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_6289","instance":6289,"id":192960,"goal":"lemma SeqFilterLe_6289(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_6290","instance":6290,"id":192961,"goal":"lemma SeqMemberAppend_6290(ys: seq, t: seq)\n ensures x in ys + t <==> x in ys || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_6291","instance":6291,"id":192962,"goal":"lemma SeqAppendLen_6291(t: seq, xs: seq)\n ensures |t + xs| == |t| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_6292","instance":6292,"id":192963,"goal":"lemma SeqAppendNil_6292(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_6293","instance":6293,"id":192964,"goal":"lemma SeqNilAppend_6293(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_6294","instance":6294,"id":192965,"goal":"lemma SeqAppendAssoc_6294(ys: seq, zs: seq, xs: seq)\n ensures (ys + zs) + xs == ys + (zs + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_6295","instance":6295,"id":192966,"goal":"lemma SeqTakeDrop_6295(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_6296","instance":6296,"id":192967,"goal":"lemma SeqReverseLen_6296(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_6297","instance":6297,"id":192968,"goal":"lemma SeqReverseIdem_6297(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_6298","instance":6298,"id":192969,"goal":"lemma SeqMapLen_6298(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_6299","instance":6299,"id":192970,"goal":"lemma SeqFilterLe_6299(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_6300","instance":6300,"id":192971,"goal":"lemma SeqMemberAppend_6300(zs: seq, ys: seq)\n ensures x in zs + ys <==> x in zs || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_6301","instance":6301,"id":192972,"goal":"lemma SeqAppendLen_6301(ys: seq, zs: seq)\n ensures |ys + zs| == |ys| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_6302","instance":6302,"id":192973,"goal":"lemma SeqAppendNil_6302(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_6303","instance":6303,"id":192974,"goal":"lemma SeqNilAppend_6303(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_6304","instance":6304,"id":192975,"goal":"lemma SeqAppendAssoc_6304(t: seq, ys: seq, xs: seq)\n ensures (t + ys) + xs == t + (ys + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_6305","instance":6305,"id":192976,"goal":"lemma SeqTakeDrop_6305(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_6306","instance":6306,"id":192977,"goal":"lemma SeqReverseLen_6306(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_6307","instance":6307,"id":192978,"goal":"lemma SeqReverseIdem_6307(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_6308","instance":6308,"id":192979,"goal":"lemma SeqMapLen_6308(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_6309","instance":6309,"id":192980,"goal":"lemma SeqFilterLe_6309(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_6310","instance":6310,"id":192981,"goal":"lemma SeqMemberAppend_6310(xs: seq, t: seq)\n ensures x in xs + t <==> x in xs || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_6311","instance":6311,"id":192982,"goal":"lemma SeqAppendLen_6311(ys: seq, s: seq)\n ensures |ys + s| == |ys| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_6312","instance":6312,"id":192983,"goal":"lemma SeqAppendNil_6312(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_6313","instance":6313,"id":192984,"goal":"lemma SeqNilAppend_6313(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_6314","instance":6314,"id":192985,"goal":"lemma SeqAppendAssoc_6314(u: seq, xs: seq, zs: seq)\n ensures (u + xs) + zs == u + (xs + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_6315","instance":6315,"id":192986,"goal":"lemma SeqTakeDrop_6315(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_6316","instance":6316,"id":192987,"goal":"lemma SeqReverseLen_6316(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_6317","instance":6317,"id":192988,"goal":"lemma SeqReverseIdem_6317(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_6318","instance":6318,"id":192989,"goal":"lemma SeqMapLen_6318(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_6319","instance":6319,"id":192990,"goal":"lemma SeqFilterLe_6319(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_6320","instance":6320,"id":192991,"goal":"lemma SeqMemberAppend_6320(s: seq, u: seq)\n ensures x in s + u <==> x in s || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_6321","instance":6321,"id":192992,"goal":"lemma SeqAppendLen_6321(t: seq, ys: seq)\n ensures |t + ys| == |t| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_6322","instance":6322,"id":192993,"goal":"lemma SeqAppendNil_6322(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_6323","instance":6323,"id":192994,"goal":"lemma SeqNilAppend_6323(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_6324","instance":6324,"id":192995,"goal":"lemma SeqAppendAssoc_6324(xs: seq, u: seq, s: seq)\n ensures (xs + u) + s == xs + (u + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_6325","instance":6325,"id":192996,"goal":"lemma SeqTakeDrop_6325(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_6326","instance":6326,"id":192997,"goal":"lemma SeqReverseLen_6326(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_6327","instance":6327,"id":192998,"goal":"lemma SeqReverseIdem_6327(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_6328","instance":6328,"id":192999,"goal":"lemma SeqMapLen_6328(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_6329","instance":6329,"id":193000,"goal":"lemma SeqFilterLe_6329(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_6330","instance":6330,"id":193001,"goal":"lemma SeqMemberAppend_6330(xs: seq, u: seq)\n ensures x in xs + u <==> x in xs || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_6331","instance":6331,"id":193002,"goal":"lemma SeqAppendLen_6331(s: seq, xs: seq)\n ensures |s + xs| == |s| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_6332","instance":6332,"id":193003,"goal":"lemma SeqAppendNil_6332(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_6333","instance":6333,"id":193004,"goal":"lemma SeqNilAppend_6333(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_6334","instance":6334,"id":193005,"goal":"lemma SeqAppendAssoc_6334(t: seq, ys: seq, s: seq)\n ensures (t + ys) + s == t + (ys + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_6335","instance":6335,"id":193006,"goal":"lemma SeqTakeDrop_6335(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_6336","instance":6336,"id":193007,"goal":"lemma SeqReverseLen_6336(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_6337","instance":6337,"id":193008,"goal":"lemma SeqReverseIdem_6337(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_6338","instance":6338,"id":193009,"goal":"lemma SeqMapLen_6338(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_6339","instance":6339,"id":193010,"goal":"lemma SeqFilterLe_6339(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_6340","instance":6340,"id":193011,"goal":"lemma SeqMemberAppend_6340(ys: seq, s: seq)\n ensures x in ys + s <==> x in ys || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_6341","instance":6341,"id":193012,"goal":"lemma SeqAppendLen_6341(s: seq, xs: seq)\n ensures |s + xs| == |s| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_6342","instance":6342,"id":193013,"goal":"lemma SeqAppendNil_6342(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_6343","instance":6343,"id":193014,"goal":"lemma SeqNilAppend_6343(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_6344","instance":6344,"id":193015,"goal":"lemma SeqAppendAssoc_6344(xs: seq, zs: seq, s: seq)\n ensures (xs + zs) + s == xs + (zs + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_6345","instance":6345,"id":193016,"goal":"lemma SeqTakeDrop_6345(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_6346","instance":6346,"id":193017,"goal":"lemma SeqReverseLen_6346(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_6347","instance":6347,"id":193018,"goal":"lemma SeqReverseIdem_6347(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_6348","instance":6348,"id":193019,"goal":"lemma SeqMapLen_6348(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_6349","instance":6349,"id":193020,"goal":"lemma SeqFilterLe_6349(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_6350","instance":6350,"id":193021,"goal":"lemma SeqMemberAppend_6350(s: seq, t: seq)\n ensures x in s + t <==> x in s || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_6351","instance":6351,"id":193022,"goal":"lemma SeqAppendLen_6351(u: seq, ys: seq)\n ensures |u + ys| == |u| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_6352","instance":6352,"id":193023,"goal":"lemma SeqAppendNil_6352(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_6353","instance":6353,"id":193024,"goal":"lemma SeqNilAppend_6353(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_6354","instance":6354,"id":193025,"goal":"lemma SeqAppendAssoc_6354(zs: seq, s: seq, t: seq)\n ensures (zs + s) + t == zs + (s + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_6355","instance":6355,"id":193026,"goal":"lemma SeqTakeDrop_6355(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_6356","instance":6356,"id":193027,"goal":"lemma SeqReverseLen_6356(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_6357","instance":6357,"id":193028,"goal":"lemma SeqReverseIdem_6357(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_6358","instance":6358,"id":193029,"goal":"lemma SeqMapLen_6358(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_6359","instance":6359,"id":193030,"goal":"lemma SeqFilterLe_6359(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_6360","instance":6360,"id":193031,"goal":"lemma SeqMemberAppend_6360(xs: seq, s: seq)\n ensures x in xs + s <==> x in xs || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_6361","instance":6361,"id":193032,"goal":"lemma SeqAppendLen_6361(ys: seq, t: seq)\n ensures |ys + t| == |ys| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_6362","instance":6362,"id":193033,"goal":"lemma SeqAppendNil_6362(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_6363","instance":6363,"id":193034,"goal":"lemma SeqNilAppend_6363(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_6364","instance":6364,"id":193035,"goal":"lemma SeqAppendAssoc_6364(t: seq, zs: seq, u: seq)\n ensures (t + zs) + u == t + (zs + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_6365","instance":6365,"id":193036,"goal":"lemma SeqTakeDrop_6365(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_6366","instance":6366,"id":193037,"goal":"lemma SeqReverseLen_6366(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_6367","instance":6367,"id":193038,"goal":"lemma SeqReverseIdem_6367(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_6368","instance":6368,"id":193039,"goal":"lemma SeqMapLen_6368(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_6369","instance":6369,"id":193040,"goal":"lemma SeqFilterLe_6369(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_6370","instance":6370,"id":193041,"goal":"lemma SeqMemberAppend_6370(t: seq, zs: seq)\n ensures x in t + zs <==> x in t || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_6371","instance":6371,"id":193042,"goal":"lemma SeqAppendLen_6371(ys: seq, zs: seq)\n ensures |ys + zs| == |ys| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_6372","instance":6372,"id":193043,"goal":"lemma SeqAppendNil_6372(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_6373","instance":6373,"id":193044,"goal":"lemma SeqNilAppend_6373(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_6374","instance":6374,"id":193045,"goal":"lemma SeqAppendAssoc_6374(u: seq, zs: seq, xs: seq)\n ensures (u + zs) + xs == u + (zs + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_6375","instance":6375,"id":193046,"goal":"lemma SeqTakeDrop_6375(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_6376","instance":6376,"id":193047,"goal":"lemma SeqReverseLen_6376(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_6377","instance":6377,"id":193048,"goal":"lemma SeqReverseIdem_6377(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_6378","instance":6378,"id":193049,"goal":"lemma SeqMapLen_6378(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_6379","instance":6379,"id":193050,"goal":"lemma SeqFilterLe_6379(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_6380","instance":6380,"id":193051,"goal":"lemma SeqMemberAppend_6380(xs: seq, t: seq)\n ensures x in xs + t <==> x in xs || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_6381","instance":6381,"id":193052,"goal":"lemma SeqAppendLen_6381(s: seq, xs: seq)\n ensures |s + xs| == |s| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_6382","instance":6382,"id":193053,"goal":"lemma SeqAppendNil_6382(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_6383","instance":6383,"id":193054,"goal":"lemma SeqNilAppend_6383(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_6384","instance":6384,"id":193055,"goal":"lemma SeqAppendAssoc_6384(u: seq, t: seq, xs: seq)\n ensures (u + t) + xs == u + (t + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_6385","instance":6385,"id":193056,"goal":"lemma SeqTakeDrop_6385(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_6386","instance":6386,"id":193057,"goal":"lemma SeqReverseLen_6386(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_6387","instance":6387,"id":193058,"goal":"lemma SeqReverseIdem_6387(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_6388","instance":6388,"id":193059,"goal":"lemma SeqMapLen_6388(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_6389","instance":6389,"id":193060,"goal":"lemma SeqFilterLe_6389(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_6390","instance":6390,"id":193061,"goal":"lemma SeqMemberAppend_6390(zs: seq, s: seq)\n ensures x in zs + s <==> x in zs || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_6391","instance":6391,"id":193062,"goal":"lemma SeqAppendLen_6391(u: seq, ys: seq)\n ensures |u + ys| == |u| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_6392","instance":6392,"id":193063,"goal":"lemma SeqAppendNil_6392(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_6393","instance":6393,"id":193064,"goal":"lemma SeqNilAppend_6393(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_6394","instance":6394,"id":193065,"goal":"lemma SeqAppendAssoc_6394(u: seq, zs: seq, ys: seq)\n ensures (u + zs) + ys == u + (zs + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_6395","instance":6395,"id":193066,"goal":"lemma SeqTakeDrop_6395(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_6396","instance":6396,"id":193067,"goal":"lemma SeqReverseLen_6396(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_6397","instance":6397,"id":193068,"goal":"lemma SeqReverseIdem_6397(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_6398","instance":6398,"id":193069,"goal":"lemma SeqMapLen_6398(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_6399","instance":6399,"id":193070,"goal":"lemma SeqFilterLe_6399(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_6400","instance":6400,"id":193071,"goal":"lemma SeqMemberAppend_6400(s: seq, zs: seq)\n ensures x in s + zs <==> x in s || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_6401","instance":6401,"id":193072,"goal":"lemma SeqAppendLen_6401(xs: seq, u: seq)\n ensures |xs + u| == |xs| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_6402","instance":6402,"id":193073,"goal":"lemma SeqAppendNil_6402(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_6403","instance":6403,"id":193074,"goal":"lemma SeqNilAppend_6403(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_6404","instance":6404,"id":193075,"goal":"lemma SeqAppendAssoc_6404(xs: seq, u: seq, ys: seq)\n ensures (xs + u) + ys == xs + (u + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_6405","instance":6405,"id":193076,"goal":"lemma SeqTakeDrop_6405(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_6406","instance":6406,"id":193077,"goal":"lemma SeqReverseLen_6406(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_6407","instance":6407,"id":193078,"goal":"lemma SeqReverseIdem_6407(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_6408","instance":6408,"id":193079,"goal":"lemma SeqMapLen_6408(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_6409","instance":6409,"id":193080,"goal":"lemma SeqFilterLe_6409(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_6410","instance":6410,"id":193081,"goal":"lemma SeqMemberAppend_6410(s: seq, t: seq)\n ensures x in s + t <==> x in s || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_6411","instance":6411,"id":193082,"goal":"lemma SeqAppendLen_6411(ys: seq, t: seq)\n ensures |ys + t| == |ys| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_6412","instance":6412,"id":193083,"goal":"lemma SeqAppendNil_6412(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_6413","instance":6413,"id":193084,"goal":"lemma SeqNilAppend_6413(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_6414","instance":6414,"id":193085,"goal":"lemma SeqAppendAssoc_6414(xs: seq, u: seq, ys: seq)\n ensures (xs + u) + ys == xs + (u + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_6415","instance":6415,"id":193086,"goal":"lemma SeqTakeDrop_6415(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_6416","instance":6416,"id":193087,"goal":"lemma SeqReverseLen_6416(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_6417","instance":6417,"id":193088,"goal":"lemma SeqReverseIdem_6417(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_6418","instance":6418,"id":193089,"goal":"lemma SeqMapLen_6418(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_6419","instance":6419,"id":193090,"goal":"lemma SeqFilterLe_6419(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_6420","instance":6420,"id":193091,"goal":"lemma SeqMemberAppend_6420(t: seq, ys: seq)\n ensures x in t + ys <==> x in t || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_6421","instance":6421,"id":193092,"goal":"lemma SeqAppendLen_6421(t: seq, zs: seq)\n ensures |t + zs| == |t| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_6422","instance":6422,"id":193093,"goal":"lemma SeqAppendNil_6422(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_6423","instance":6423,"id":193094,"goal":"lemma SeqNilAppend_6423(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_6424","instance":6424,"id":193095,"goal":"lemma SeqAppendAssoc_6424(s: seq, u: seq, zs: seq)\n ensures (s + u) + zs == s + (u + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_6425","instance":6425,"id":193096,"goal":"lemma SeqTakeDrop_6425(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_6426","instance":6426,"id":193097,"goal":"lemma SeqReverseLen_6426(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_6427","instance":6427,"id":193098,"goal":"lemma SeqReverseIdem_6427(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_6428","instance":6428,"id":193099,"goal":"lemma SeqMapLen_6428(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_6429","instance":6429,"id":193100,"goal":"lemma SeqFilterLe_6429(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_6430","instance":6430,"id":193101,"goal":"lemma SeqMemberAppend_6430(zs: seq, t: seq)\n ensures x in zs + t <==> x in zs || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_6431","instance":6431,"id":193102,"goal":"lemma SeqAppendLen_6431(t: seq, xs: seq)\n ensures |t + xs| == |t| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_6432","instance":6432,"id":193103,"goal":"lemma SeqAppendNil_6432(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_6433","instance":6433,"id":193104,"goal":"lemma SeqNilAppend_6433(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_6434","instance":6434,"id":193105,"goal":"lemma SeqAppendAssoc_6434(ys: seq, t: seq, s: seq)\n ensures (ys + t) + s == ys + (t + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_6435","instance":6435,"id":193106,"goal":"lemma SeqTakeDrop_6435(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_6436","instance":6436,"id":193107,"goal":"lemma SeqReverseLen_6436(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_6437","instance":6437,"id":193108,"goal":"lemma SeqReverseIdem_6437(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_6438","instance":6438,"id":193109,"goal":"lemma SeqMapLen_6438(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_6439","instance":6439,"id":193110,"goal":"lemma SeqFilterLe_6439(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_6440","instance":6440,"id":193111,"goal":"lemma SeqMemberAppend_6440(t: seq, s: seq)\n ensures x in t + s <==> x in t || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_6441","instance":6441,"id":193112,"goal":"lemma SeqAppendLen_6441(zs: seq, t: seq)\n ensures |zs + t| == |zs| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_6442","instance":6442,"id":193113,"goal":"lemma SeqAppendNil_6442(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_6443","instance":6443,"id":193114,"goal":"lemma SeqNilAppend_6443(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_6444","instance":6444,"id":193115,"goal":"lemma SeqAppendAssoc_6444(ys: seq, zs: seq, s: seq)\n ensures (ys + zs) + s == ys + (zs + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_6445","instance":6445,"id":193116,"goal":"lemma SeqTakeDrop_6445(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_6446","instance":6446,"id":193117,"goal":"lemma SeqReverseLen_6446(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_6447","instance":6447,"id":193118,"goal":"lemma SeqReverseIdem_6447(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_6448","instance":6448,"id":193119,"goal":"lemma SeqMapLen_6448(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_6449","instance":6449,"id":193120,"goal":"lemma SeqFilterLe_6449(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_6450","instance":6450,"id":193121,"goal":"lemma SeqMemberAppend_6450(t: seq, s: seq)\n ensures x in t + s <==> x in t || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_6451","instance":6451,"id":193122,"goal":"lemma SeqAppendLen_6451(u: seq, s: seq)\n ensures |u + s| == |u| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_6452","instance":6452,"id":193123,"goal":"lemma SeqAppendNil_6452(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_6453","instance":6453,"id":193124,"goal":"lemma SeqNilAppend_6453(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_6454","instance":6454,"id":193125,"goal":"lemma SeqAppendAssoc_6454(t: seq, xs: seq, zs: seq)\n ensures (t + xs) + zs == t + (xs + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_6455","instance":6455,"id":193126,"goal":"lemma SeqTakeDrop_6455(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_6456","instance":6456,"id":193127,"goal":"lemma SeqReverseLen_6456(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_6457","instance":6457,"id":193128,"goal":"lemma SeqReverseIdem_6457(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_6458","instance":6458,"id":193129,"goal":"lemma SeqMapLen_6458(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_6459","instance":6459,"id":193130,"goal":"lemma SeqFilterLe_6459(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_6460","instance":6460,"id":193131,"goal":"lemma SeqMemberAppend_6460(ys: seq, xs: seq)\n ensures x in ys + xs <==> x in ys || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_6461","instance":6461,"id":193132,"goal":"lemma SeqAppendLen_6461(xs: seq, ys: seq)\n ensures |xs + ys| == |xs| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_6462","instance":6462,"id":193133,"goal":"lemma SeqAppendNil_6462(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_6463","instance":6463,"id":193134,"goal":"lemma SeqNilAppend_6463(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_6464","instance":6464,"id":193135,"goal":"lemma SeqAppendAssoc_6464(zs: seq, ys: seq, s: seq)\n ensures (zs + ys) + s == zs + (ys + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_6465","instance":6465,"id":193136,"goal":"lemma SeqTakeDrop_6465(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_6466","instance":6466,"id":193137,"goal":"lemma SeqReverseLen_6466(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_6467","instance":6467,"id":193138,"goal":"lemma SeqReverseIdem_6467(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_6468","instance":6468,"id":193139,"goal":"lemma SeqMapLen_6468(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_6469","instance":6469,"id":193140,"goal":"lemma SeqFilterLe_6469(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_6470","instance":6470,"id":193141,"goal":"lemma SeqMemberAppend_6470(s: seq, t: seq)\n ensures x in s + t <==> x in s || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_6471","instance":6471,"id":193142,"goal":"lemma SeqAppendLen_6471(xs: seq, ys: seq)\n ensures |xs + ys| == |xs| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_6472","instance":6472,"id":193143,"goal":"lemma SeqAppendNil_6472(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_6473","instance":6473,"id":193144,"goal":"lemma SeqNilAppend_6473(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_6474","instance":6474,"id":193145,"goal":"lemma SeqAppendAssoc_6474(t: seq, u: seq, zs: seq)\n ensures (t + u) + zs == t + (u + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_6475","instance":6475,"id":193146,"goal":"lemma SeqTakeDrop_6475(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_6476","instance":6476,"id":193147,"goal":"lemma SeqReverseLen_6476(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_6477","instance":6477,"id":193148,"goal":"lemma SeqReverseIdem_6477(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_6478","instance":6478,"id":193149,"goal":"lemma SeqMapLen_6478(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_6479","instance":6479,"id":193150,"goal":"lemma SeqFilterLe_6479(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_6480","instance":6480,"id":193151,"goal":"lemma SeqMemberAppend_6480(s: seq, zs: seq)\n ensures x in s + zs <==> x in s || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_6481","instance":6481,"id":193152,"goal":"lemma SeqAppendLen_6481(s: seq, xs: seq)\n ensures |s + xs| == |s| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_6482","instance":6482,"id":193153,"goal":"lemma SeqAppendNil_6482(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_6483","instance":6483,"id":193154,"goal":"lemma SeqNilAppend_6483(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_6484","instance":6484,"id":193155,"goal":"lemma SeqAppendAssoc_6484(ys: seq, s: seq, u: seq)\n ensures (ys + s) + u == ys + (s + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_6485","instance":6485,"id":193156,"goal":"lemma SeqTakeDrop_6485(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_6486","instance":6486,"id":193157,"goal":"lemma SeqReverseLen_6486(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_6487","instance":6487,"id":193158,"goal":"lemma SeqReverseIdem_6487(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_6488","instance":6488,"id":193159,"goal":"lemma SeqMapLen_6488(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_6489","instance":6489,"id":193160,"goal":"lemma SeqFilterLe_6489(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_6490","instance":6490,"id":193161,"goal":"lemma SeqMemberAppend_6490(xs: seq, zs: seq)\n ensures x in xs + zs <==> x in xs || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_6491","instance":6491,"id":193162,"goal":"lemma SeqAppendLen_6491(ys: seq, s: seq)\n ensures |ys + s| == |ys| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_6492","instance":6492,"id":193163,"goal":"lemma SeqAppendNil_6492(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_6493","instance":6493,"id":193164,"goal":"lemma SeqNilAppend_6493(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_6494","instance":6494,"id":193165,"goal":"lemma SeqAppendAssoc_6494(ys: seq, u: seq, xs: seq)\n ensures (ys + u) + xs == ys + (u + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_6495","instance":6495,"id":193166,"goal":"lemma SeqTakeDrop_6495(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_6496","instance":6496,"id":193167,"goal":"lemma SeqReverseLen_6496(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_6497","instance":6497,"id":193168,"goal":"lemma SeqReverseIdem_6497(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_6498","instance":6498,"id":193169,"goal":"lemma SeqMapLen_6498(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_6499","instance":6499,"id":193170,"goal":"lemma SeqFilterLe_6499(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_6500","instance":6500,"id":193171,"goal":"lemma SeqMemberAppend_6500(xs: seq, ys: seq)\n ensures x in xs + ys <==> x in xs || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_6501","instance":6501,"id":193172,"goal":"lemma SeqAppendLen_6501(xs: seq, s: seq)\n ensures |xs + s| == |xs| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_6502","instance":6502,"id":193173,"goal":"lemma SeqAppendNil_6502(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_6503","instance":6503,"id":193174,"goal":"lemma SeqNilAppend_6503(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_6504","instance":6504,"id":193175,"goal":"lemma SeqAppendAssoc_6504(u: seq, t: seq, ys: seq)\n ensures (u + t) + ys == u + (t + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_6505","instance":6505,"id":193176,"goal":"lemma SeqTakeDrop_6505(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_6506","instance":6506,"id":193177,"goal":"lemma SeqReverseLen_6506(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_6507","instance":6507,"id":193178,"goal":"lemma SeqReverseIdem_6507(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_6508","instance":6508,"id":193179,"goal":"lemma SeqMapLen_6508(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_6509","instance":6509,"id":193180,"goal":"lemma SeqFilterLe_6509(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_6510","instance":6510,"id":193181,"goal":"lemma SeqMemberAppend_6510(ys: seq, t: seq)\n ensures x in ys + t <==> x in ys || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_6511","instance":6511,"id":193182,"goal":"lemma SeqAppendLen_6511(zs: seq, u: seq)\n ensures |zs + u| == |zs| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_6512","instance":6512,"id":193183,"goal":"lemma SeqAppendNil_6512(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_6513","instance":6513,"id":193184,"goal":"lemma SeqNilAppend_6513(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_6514","instance":6514,"id":193185,"goal":"lemma SeqAppendAssoc_6514(s: seq, xs: seq, zs: seq)\n ensures (s + xs) + zs == s + (xs + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_6515","instance":6515,"id":193186,"goal":"lemma SeqTakeDrop_6515(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_6516","instance":6516,"id":193187,"goal":"lemma SeqReverseLen_6516(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_6517","instance":6517,"id":193188,"goal":"lemma SeqReverseIdem_6517(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_6518","instance":6518,"id":193189,"goal":"lemma SeqMapLen_6518(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_6519","instance":6519,"id":193190,"goal":"lemma SeqFilterLe_6519(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_6520","instance":6520,"id":193191,"goal":"lemma SeqMemberAppend_6520(t: seq, ys: seq)\n ensures x in t + ys <==> x in t || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_6521","instance":6521,"id":193192,"goal":"lemma SeqAppendLen_6521(ys: seq, xs: seq)\n ensures |ys + xs| == |ys| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_6522","instance":6522,"id":193193,"goal":"lemma SeqAppendNil_6522(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_6523","instance":6523,"id":193194,"goal":"lemma SeqNilAppend_6523(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_6524","instance":6524,"id":193195,"goal":"lemma SeqAppendAssoc_6524(t: seq, ys: seq, s: seq)\n ensures (t + ys) + s == t + (ys + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_6525","instance":6525,"id":193196,"goal":"lemma SeqTakeDrop_6525(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_6526","instance":6526,"id":193197,"goal":"lemma SeqReverseLen_6526(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_6527","instance":6527,"id":193198,"goal":"lemma SeqReverseIdem_6527(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_6528","instance":6528,"id":193199,"goal":"lemma SeqMapLen_6528(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_6529","instance":6529,"id":193200,"goal":"lemma SeqFilterLe_6529(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_6530","instance":6530,"id":193201,"goal":"lemma SeqMemberAppend_6530(s: seq, ys: seq)\n ensures x in s + ys <==> x in s || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_6531","instance":6531,"id":193202,"goal":"lemma SeqAppendLen_6531(zs: seq, s: seq)\n ensures |zs + s| == |zs| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_6532","instance":6532,"id":193203,"goal":"lemma SeqAppendNil_6532(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_6533","instance":6533,"id":193204,"goal":"lemma SeqNilAppend_6533(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_6534","instance":6534,"id":193205,"goal":"lemma SeqAppendAssoc_6534(zs: seq, ys: seq, u: seq)\n ensures (zs + ys) + u == zs + (ys + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_6535","instance":6535,"id":193206,"goal":"lemma SeqTakeDrop_6535(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_6536","instance":6536,"id":193207,"goal":"lemma SeqReverseLen_6536(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_6537","instance":6537,"id":193208,"goal":"lemma SeqReverseIdem_6537(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_6538","instance":6538,"id":193209,"goal":"lemma SeqMapLen_6538(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_6539","instance":6539,"id":193210,"goal":"lemma SeqFilterLe_6539(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_6540","instance":6540,"id":193211,"goal":"lemma SeqMemberAppend_6540(zs: seq, ys: seq)\n ensures x in zs + ys <==> x in zs || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_6541","instance":6541,"id":193212,"goal":"lemma SeqAppendLen_6541(u: seq, ys: seq)\n ensures |u + ys| == |u| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_6542","instance":6542,"id":193213,"goal":"lemma SeqAppendNil_6542(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_6543","instance":6543,"id":193214,"goal":"lemma SeqNilAppend_6543(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_6544","instance":6544,"id":193215,"goal":"lemma SeqAppendAssoc_6544(xs: seq, s: seq, t: seq)\n ensures (xs + s) + t == xs + (s + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_6545","instance":6545,"id":193216,"goal":"lemma SeqTakeDrop_6545(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_6546","instance":6546,"id":193217,"goal":"lemma SeqReverseLen_6546(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_6547","instance":6547,"id":193218,"goal":"lemma SeqReverseIdem_6547(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_6548","instance":6548,"id":193219,"goal":"lemma SeqMapLen_6548(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_6549","instance":6549,"id":193220,"goal":"lemma SeqFilterLe_6549(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_6550","instance":6550,"id":193221,"goal":"lemma SeqMemberAppend_6550(u: seq, ys: seq)\n ensures x in u + ys <==> x in u || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_6551","instance":6551,"id":193222,"goal":"lemma SeqAppendLen_6551(u: seq, xs: seq)\n ensures |u + xs| == |u| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_6552","instance":6552,"id":193223,"goal":"lemma SeqAppendNil_6552(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_6553","instance":6553,"id":193224,"goal":"lemma SeqNilAppend_6553(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_6554","instance":6554,"id":193225,"goal":"lemma SeqAppendAssoc_6554(zs: seq, s: seq, u: seq)\n ensures (zs + s) + u == zs + (s + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_6555","instance":6555,"id":193226,"goal":"lemma SeqTakeDrop_6555(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_6556","instance":6556,"id":193227,"goal":"lemma SeqReverseLen_6556(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_6557","instance":6557,"id":193228,"goal":"lemma SeqReverseIdem_6557(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_6558","instance":6558,"id":193229,"goal":"lemma SeqMapLen_6558(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_6559","instance":6559,"id":193230,"goal":"lemma SeqFilterLe_6559(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_6560","instance":6560,"id":193231,"goal":"lemma SeqMemberAppend_6560(xs: seq, u: seq)\n ensures x in xs + u <==> x in xs || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_6561","instance":6561,"id":193232,"goal":"lemma SeqAppendLen_6561(u: seq, xs: seq)\n ensures |u + xs| == |u| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_6562","instance":6562,"id":193233,"goal":"lemma SeqAppendNil_6562(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_6563","instance":6563,"id":193234,"goal":"lemma SeqNilAppend_6563(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_6564","instance":6564,"id":193235,"goal":"lemma SeqAppendAssoc_6564(s: seq, xs: seq, ys: seq)\n ensures (s + xs) + ys == s + (xs + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_6565","instance":6565,"id":193236,"goal":"lemma SeqTakeDrop_6565(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_6566","instance":6566,"id":193237,"goal":"lemma SeqReverseLen_6566(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_6567","instance":6567,"id":193238,"goal":"lemma SeqReverseIdem_6567(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_6568","instance":6568,"id":193239,"goal":"lemma SeqMapLen_6568(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_6569","instance":6569,"id":193240,"goal":"lemma SeqFilterLe_6569(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_6570","instance":6570,"id":193241,"goal":"lemma SeqMemberAppend_6570(s: seq, ys: seq)\n ensures x in s + ys <==> x in s || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_6571","instance":6571,"id":193242,"goal":"lemma SeqAppendLen_6571(ys: seq, u: seq)\n ensures |ys + u| == |ys| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_6572","instance":6572,"id":193243,"goal":"lemma SeqAppendNil_6572(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_6573","instance":6573,"id":193244,"goal":"lemma SeqNilAppend_6573(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_6574","instance":6574,"id":193245,"goal":"lemma SeqAppendAssoc_6574(t: seq, u: seq, ys: seq)\n ensures (t + u) + ys == t + (u + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_6575","instance":6575,"id":193246,"goal":"lemma SeqTakeDrop_6575(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_6576","instance":6576,"id":193247,"goal":"lemma SeqReverseLen_6576(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_6577","instance":6577,"id":193248,"goal":"lemma SeqReverseIdem_6577(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_6578","instance":6578,"id":193249,"goal":"lemma SeqMapLen_6578(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_6579","instance":6579,"id":193250,"goal":"lemma SeqFilterLe_6579(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_6580","instance":6580,"id":193251,"goal":"lemma SeqMemberAppend_6580(s: seq, zs: seq)\n ensures x in s + zs <==> x in s || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_6581","instance":6581,"id":193252,"goal":"lemma SeqAppendLen_6581(t: seq, s: seq)\n ensures |t + s| == |t| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_6582","instance":6582,"id":193253,"goal":"lemma SeqAppendNil_6582(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_6583","instance":6583,"id":193254,"goal":"lemma SeqNilAppend_6583(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_6584","instance":6584,"id":193255,"goal":"lemma SeqAppendAssoc_6584(t: seq, xs: seq, s: seq)\n ensures (t + xs) + s == t + (xs + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_6585","instance":6585,"id":193256,"goal":"lemma SeqTakeDrop_6585(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_6586","instance":6586,"id":193257,"goal":"lemma SeqReverseLen_6586(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_6587","instance":6587,"id":193258,"goal":"lemma SeqReverseIdem_6587(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_6588","instance":6588,"id":193259,"goal":"lemma SeqMapLen_6588(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_6589","instance":6589,"id":193260,"goal":"lemma SeqFilterLe_6589(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_6590","instance":6590,"id":193261,"goal":"lemma SeqMemberAppend_6590(u: seq, s: seq)\n ensures x in u + s <==> x in u || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_6591","instance":6591,"id":193262,"goal":"lemma SeqAppendLen_6591(ys: seq, xs: seq)\n ensures |ys + xs| == |ys| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_6592","instance":6592,"id":193263,"goal":"lemma SeqAppendNil_6592(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_6593","instance":6593,"id":193264,"goal":"lemma SeqNilAppend_6593(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_6594","instance":6594,"id":193265,"goal":"lemma SeqAppendAssoc_6594(xs: seq, s: seq, t: seq)\n ensures (xs + s) + t == xs + (s + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_6595","instance":6595,"id":193266,"goal":"lemma SeqTakeDrop_6595(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_6596","instance":6596,"id":193267,"goal":"lemma SeqReverseLen_6596(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_6597","instance":6597,"id":193268,"goal":"lemma SeqReverseIdem_6597(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_6598","instance":6598,"id":193269,"goal":"lemma SeqMapLen_6598(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_6599","instance":6599,"id":193270,"goal":"lemma SeqFilterLe_6599(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_6600","instance":6600,"id":193271,"goal":"lemma SeqMemberAppend_6600(t: seq, zs: seq)\n ensures x in t + zs <==> x in t || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_6601","instance":6601,"id":193272,"goal":"lemma SeqAppendLen_6601(ys: seq, t: seq)\n ensures |ys + t| == |ys| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_6602","instance":6602,"id":193273,"goal":"lemma SeqAppendNil_6602(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_6603","instance":6603,"id":193274,"goal":"lemma SeqNilAppend_6603(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_6604","instance":6604,"id":193275,"goal":"lemma SeqAppendAssoc_6604(ys: seq, xs: seq, u: seq)\n ensures (ys + xs) + u == ys + (xs + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_6605","instance":6605,"id":193276,"goal":"lemma SeqTakeDrop_6605(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_6606","instance":6606,"id":193277,"goal":"lemma SeqReverseLen_6606(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_6607","instance":6607,"id":193278,"goal":"lemma SeqReverseIdem_6607(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_6608","instance":6608,"id":193279,"goal":"lemma SeqMapLen_6608(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_6609","instance":6609,"id":193280,"goal":"lemma SeqFilterLe_6609(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_6610","instance":6610,"id":193281,"goal":"lemma SeqMemberAppend_6610(zs: seq, t: seq)\n ensures x in zs + t <==> x in zs || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_6611","instance":6611,"id":193282,"goal":"lemma SeqAppendLen_6611(xs: seq, ys: seq)\n ensures |xs + ys| == |xs| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_6612","instance":6612,"id":193283,"goal":"lemma SeqAppendNil_6612(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_6613","instance":6613,"id":193284,"goal":"lemma SeqNilAppend_6613(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_6614","instance":6614,"id":193285,"goal":"lemma SeqAppendAssoc_6614(ys: seq, xs: seq, u: seq)\n ensures (ys + xs) + u == ys + (xs + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_6615","instance":6615,"id":193286,"goal":"lemma SeqTakeDrop_6615(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_6616","instance":6616,"id":193287,"goal":"lemma SeqReverseLen_6616(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_6617","instance":6617,"id":193288,"goal":"lemma SeqReverseIdem_6617(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_6618","instance":6618,"id":193289,"goal":"lemma SeqMapLen_6618(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_6619","instance":6619,"id":193290,"goal":"lemma SeqFilterLe_6619(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_6620","instance":6620,"id":193291,"goal":"lemma SeqMemberAppend_6620(u: seq, t: seq)\n ensures x in u + t <==> x in u || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_6621","instance":6621,"id":193292,"goal":"lemma SeqAppendLen_6621(t: seq, s: seq)\n ensures |t + s| == |t| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_6622","instance":6622,"id":193293,"goal":"lemma SeqAppendNil_6622(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_6623","instance":6623,"id":193294,"goal":"lemma SeqNilAppend_6623(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_6624","instance":6624,"id":193295,"goal":"lemma SeqAppendAssoc_6624(t: seq, xs: seq, s: seq)\n ensures (t + xs) + s == t + (xs + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_6625","instance":6625,"id":193296,"goal":"lemma SeqTakeDrop_6625(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_6626","instance":6626,"id":193297,"goal":"lemma SeqReverseLen_6626(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_6627","instance":6627,"id":193298,"goal":"lemma SeqReverseIdem_6627(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_6628","instance":6628,"id":193299,"goal":"lemma SeqMapLen_6628(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_6629","instance":6629,"id":193300,"goal":"lemma SeqFilterLe_6629(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_6630","instance":6630,"id":193301,"goal":"lemma SeqMemberAppend_6630(ys: seq, u: seq)\n ensures x in ys + u <==> x in ys || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_6631","instance":6631,"id":193302,"goal":"lemma SeqAppendLen_6631(u: seq, t: seq)\n ensures |u + t| == |u| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_6632","instance":6632,"id":193303,"goal":"lemma SeqAppendNil_6632(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_6633","instance":6633,"id":193304,"goal":"lemma SeqNilAppend_6633(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_6634","instance":6634,"id":193305,"goal":"lemma SeqAppendAssoc_6634(xs: seq, t: seq, u: seq)\n ensures (xs + t) + u == xs + (t + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_6635","instance":6635,"id":193306,"goal":"lemma SeqTakeDrop_6635(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_6636","instance":6636,"id":193307,"goal":"lemma SeqReverseLen_6636(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_6637","instance":6637,"id":193308,"goal":"lemma SeqReverseIdem_6637(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_6638","instance":6638,"id":193309,"goal":"lemma SeqMapLen_6638(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_6639","instance":6639,"id":193310,"goal":"lemma SeqFilterLe_6639(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_6640","instance":6640,"id":193311,"goal":"lemma SeqMemberAppend_6640(zs: seq, t: seq)\n ensures x in zs + t <==> x in zs || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_6641","instance":6641,"id":193312,"goal":"lemma SeqAppendLen_6641(s: seq, u: seq)\n ensures |s + u| == |s| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_6642","instance":6642,"id":193313,"goal":"lemma SeqAppendNil_6642(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_6643","instance":6643,"id":193314,"goal":"lemma SeqNilAppend_6643(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_6644","instance":6644,"id":193315,"goal":"lemma SeqAppendAssoc_6644(xs: seq, u: seq, zs: seq)\n ensures (xs + u) + zs == xs + (u + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_6645","instance":6645,"id":193316,"goal":"lemma SeqTakeDrop_6645(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_6646","instance":6646,"id":193317,"goal":"lemma SeqReverseLen_6646(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_6647","instance":6647,"id":193318,"goal":"lemma SeqReverseIdem_6647(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_6648","instance":6648,"id":193319,"goal":"lemma SeqMapLen_6648(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_6649","instance":6649,"id":193320,"goal":"lemma SeqFilterLe_6649(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_6650","instance":6650,"id":193321,"goal":"lemma SeqMemberAppend_6650(u: seq, s: seq)\n ensures x in u + s <==> x in u || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_6651","instance":6651,"id":193322,"goal":"lemma SeqAppendLen_6651(t: seq, ys: seq)\n ensures |t + ys| == |t| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_6652","instance":6652,"id":193323,"goal":"lemma SeqAppendNil_6652(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_6653","instance":6653,"id":193324,"goal":"lemma SeqNilAppend_6653(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_6654","instance":6654,"id":193325,"goal":"lemma SeqAppendAssoc_6654(xs: seq, t: seq, zs: seq)\n ensures (xs + t) + zs == xs + (t + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_6655","instance":6655,"id":193326,"goal":"lemma SeqTakeDrop_6655(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_6656","instance":6656,"id":193327,"goal":"lemma SeqReverseLen_6656(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_6657","instance":6657,"id":193328,"goal":"lemma SeqReverseIdem_6657(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_6658","instance":6658,"id":193329,"goal":"lemma SeqMapLen_6658(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_6659","instance":6659,"id":193330,"goal":"lemma SeqFilterLe_6659(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_6660","instance":6660,"id":193331,"goal":"lemma SeqMemberAppend_6660(ys: seq, s: seq)\n ensures x in ys + s <==> x in ys || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_6661","instance":6661,"id":193332,"goal":"lemma SeqAppendLen_6661(s: seq, ys: seq)\n ensures |s + ys| == |s| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_6662","instance":6662,"id":193333,"goal":"lemma SeqAppendNil_6662(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_6663","instance":6663,"id":193334,"goal":"lemma SeqNilAppend_6663(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_6664","instance":6664,"id":193335,"goal":"lemma SeqAppendAssoc_6664(zs: seq, ys: seq, xs: seq)\n ensures (zs + ys) + xs == zs + (ys + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_6665","instance":6665,"id":193336,"goal":"lemma SeqTakeDrop_6665(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_6666","instance":6666,"id":193337,"goal":"lemma SeqReverseLen_6666(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_6667","instance":6667,"id":193338,"goal":"lemma SeqReverseIdem_6667(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_6668","instance":6668,"id":193339,"goal":"lemma SeqMapLen_6668(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_6669","instance":6669,"id":193340,"goal":"lemma SeqFilterLe_6669(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_6670","instance":6670,"id":193341,"goal":"lemma SeqMemberAppend_6670(ys: seq, u: seq)\n ensures x in ys + u <==> x in ys || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_6671","instance":6671,"id":193342,"goal":"lemma SeqAppendLen_6671(ys: seq, s: seq)\n ensures |ys + s| == |ys| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_6672","instance":6672,"id":193343,"goal":"lemma SeqAppendNil_6672(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_6673","instance":6673,"id":193344,"goal":"lemma SeqNilAppend_6673(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_6674","instance":6674,"id":193345,"goal":"lemma SeqAppendAssoc_6674(zs: seq, s: seq, u: seq)\n ensures (zs + s) + u == zs + (s + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_6675","instance":6675,"id":193346,"goal":"lemma SeqTakeDrop_6675(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_6676","instance":6676,"id":193347,"goal":"lemma SeqReverseLen_6676(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_6677","instance":6677,"id":193348,"goal":"lemma SeqReverseIdem_6677(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_6678","instance":6678,"id":193349,"goal":"lemma SeqMapLen_6678(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_6679","instance":6679,"id":193350,"goal":"lemma SeqFilterLe_6679(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_6680","instance":6680,"id":193351,"goal":"lemma SeqMemberAppend_6680(ys: seq, xs: seq)\n ensures x in ys + xs <==> x in ys || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_6681","instance":6681,"id":193352,"goal":"lemma SeqAppendLen_6681(t: seq, zs: seq)\n ensures |t + zs| == |t| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_6682","instance":6682,"id":193353,"goal":"lemma SeqAppendNil_6682(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_6683","instance":6683,"id":193354,"goal":"lemma SeqNilAppend_6683(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_6684","instance":6684,"id":193355,"goal":"lemma SeqAppendAssoc_6684(u: seq, s: seq, zs: seq)\n ensures (u + s) + zs == u + (s + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_6685","instance":6685,"id":193356,"goal":"lemma SeqTakeDrop_6685(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_6686","instance":6686,"id":193357,"goal":"lemma SeqReverseLen_6686(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_6687","instance":6687,"id":193358,"goal":"lemma SeqReverseIdem_6687(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_6688","instance":6688,"id":193359,"goal":"lemma SeqMapLen_6688(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_6689","instance":6689,"id":193360,"goal":"lemma SeqFilterLe_6689(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_6690","instance":6690,"id":193361,"goal":"lemma SeqMemberAppend_6690(xs: seq, u: seq)\n ensures x in xs + u <==> x in xs || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_6691","instance":6691,"id":193362,"goal":"lemma SeqAppendLen_6691(u: seq, xs: seq)\n ensures |u + xs| == |u| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_6692","instance":6692,"id":193363,"goal":"lemma SeqAppendNil_6692(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_6693","instance":6693,"id":193364,"goal":"lemma SeqNilAppend_6693(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_6694","instance":6694,"id":193365,"goal":"lemma SeqAppendAssoc_6694(zs: seq, s: seq, ys: seq)\n ensures (zs + s) + ys == zs + (s + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_6695","instance":6695,"id":193366,"goal":"lemma SeqTakeDrop_6695(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_6696","instance":6696,"id":193367,"goal":"lemma SeqReverseLen_6696(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_6697","instance":6697,"id":193368,"goal":"lemma SeqReverseIdem_6697(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_6698","instance":6698,"id":193369,"goal":"lemma SeqMapLen_6698(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_6699","instance":6699,"id":193370,"goal":"lemma SeqFilterLe_6699(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_6700","instance":6700,"id":193371,"goal":"lemma SeqMemberAppend_6700(xs: seq, s: seq)\n ensures x in xs + s <==> x in xs || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_6701","instance":6701,"id":193372,"goal":"lemma SeqAppendLen_6701(xs: seq, t: seq)\n ensures |xs + t| == |xs| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_6702","instance":6702,"id":193373,"goal":"lemma SeqAppendNil_6702(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_6703","instance":6703,"id":193374,"goal":"lemma SeqNilAppend_6703(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_6704","instance":6704,"id":193375,"goal":"lemma SeqAppendAssoc_6704(ys: seq, u: seq, xs: seq)\n ensures (ys + u) + xs == ys + (u + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_6705","instance":6705,"id":193376,"goal":"lemma SeqTakeDrop_6705(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_6706","instance":6706,"id":193377,"goal":"lemma SeqReverseLen_6706(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_6707","instance":6707,"id":193378,"goal":"lemma SeqReverseIdem_6707(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_6708","instance":6708,"id":193379,"goal":"lemma SeqMapLen_6708(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_6709","instance":6709,"id":193380,"goal":"lemma SeqFilterLe_6709(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_6710","instance":6710,"id":193381,"goal":"lemma SeqMemberAppend_6710(xs: seq, ys: seq)\n ensures x in xs + ys <==> x in xs || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_6711","instance":6711,"id":193382,"goal":"lemma SeqAppendLen_6711(s: seq, t: seq)\n ensures |s + t| == |s| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_6712","instance":6712,"id":193383,"goal":"lemma SeqAppendNil_6712(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_6713","instance":6713,"id":193384,"goal":"lemma SeqNilAppend_6713(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_6714","instance":6714,"id":193385,"goal":"lemma SeqAppendAssoc_6714(t: seq, u: seq, ys: seq)\n ensures (t + u) + ys == t + (u + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_6715","instance":6715,"id":193386,"goal":"lemma SeqTakeDrop_6715(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_6716","instance":6716,"id":193387,"goal":"lemma SeqReverseLen_6716(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_6717","instance":6717,"id":193388,"goal":"lemma SeqReverseIdem_6717(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_6718","instance":6718,"id":193389,"goal":"lemma SeqMapLen_6718(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_6719","instance":6719,"id":193390,"goal":"lemma SeqFilterLe_6719(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_6720","instance":6720,"id":193391,"goal":"lemma SeqMemberAppend_6720(zs: seq, s: seq)\n ensures x in zs + s <==> x in zs || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_6721","instance":6721,"id":193392,"goal":"lemma SeqAppendLen_6721(xs: seq, s: seq)\n ensures |xs + s| == |xs| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_6722","instance":6722,"id":193393,"goal":"lemma SeqAppendNil_6722(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_6723","instance":6723,"id":193394,"goal":"lemma SeqNilAppend_6723(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_6724","instance":6724,"id":193395,"goal":"lemma SeqAppendAssoc_6724(zs: seq, ys: seq, s: seq)\n ensures (zs + ys) + s == zs + (ys + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_6725","instance":6725,"id":193396,"goal":"lemma SeqTakeDrop_6725(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_6726","instance":6726,"id":193397,"goal":"lemma SeqReverseLen_6726(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_6727","instance":6727,"id":193398,"goal":"lemma SeqReverseIdem_6727(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_6728","instance":6728,"id":193399,"goal":"lemma SeqMapLen_6728(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_6729","instance":6729,"id":193400,"goal":"lemma SeqFilterLe_6729(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_6730","instance":6730,"id":193401,"goal":"lemma SeqMemberAppend_6730(xs: seq, t: seq)\n ensures x in xs + t <==> x in xs || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_6731","instance":6731,"id":193402,"goal":"lemma SeqAppendLen_6731(zs: seq, xs: seq)\n ensures |zs + xs| == |zs| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_6732","instance":6732,"id":193403,"goal":"lemma SeqAppendNil_6732(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_6733","instance":6733,"id":193404,"goal":"lemma SeqNilAppend_6733(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_6734","instance":6734,"id":193405,"goal":"lemma SeqAppendAssoc_6734(xs: seq, ys: seq, t: seq)\n ensures (xs + ys) + t == xs + (ys + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_6735","instance":6735,"id":193406,"goal":"lemma SeqTakeDrop_6735(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_6736","instance":6736,"id":193407,"goal":"lemma SeqReverseLen_6736(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_6737","instance":6737,"id":193408,"goal":"lemma SeqReverseIdem_6737(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_6738","instance":6738,"id":193409,"goal":"lemma SeqMapLen_6738(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_6739","instance":6739,"id":193410,"goal":"lemma SeqFilterLe_6739(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_6740","instance":6740,"id":193411,"goal":"lemma SeqMemberAppend_6740(t: seq, ys: seq)\n ensures x in t + ys <==> x in t || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_6741","instance":6741,"id":193412,"goal":"lemma SeqAppendLen_6741(zs: seq, xs: seq)\n ensures |zs + xs| == |zs| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_6742","instance":6742,"id":193413,"goal":"lemma SeqAppendNil_6742(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_6743","instance":6743,"id":193414,"goal":"lemma SeqNilAppend_6743(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_6744","instance":6744,"id":193415,"goal":"lemma SeqAppendAssoc_6744(ys: seq, s: seq, t: seq)\n ensures (ys + s) + t == ys + (s + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_6745","instance":6745,"id":193416,"goal":"lemma SeqTakeDrop_6745(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_6746","instance":6746,"id":193417,"goal":"lemma SeqReverseLen_6746(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_6747","instance":6747,"id":193418,"goal":"lemma SeqReverseIdem_6747(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_6748","instance":6748,"id":193419,"goal":"lemma SeqMapLen_6748(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_6749","instance":6749,"id":193420,"goal":"lemma SeqFilterLe_6749(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_6750","instance":6750,"id":193421,"goal":"lemma SeqMemberAppend_6750(ys: seq, zs: seq)\n ensures x in ys + zs <==> x in ys || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_6751","instance":6751,"id":193422,"goal":"lemma SeqAppendLen_6751(t: seq, zs: seq)\n ensures |t + zs| == |t| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_6752","instance":6752,"id":193423,"goal":"lemma SeqAppendNil_6752(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_6753","instance":6753,"id":193424,"goal":"lemma SeqNilAppend_6753(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_6754","instance":6754,"id":193425,"goal":"lemma SeqAppendAssoc_6754(xs: seq, ys: seq, t: seq)\n ensures (xs + ys) + t == xs + (ys + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_6755","instance":6755,"id":193426,"goal":"lemma SeqTakeDrop_6755(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_6756","instance":6756,"id":193427,"goal":"lemma SeqReverseLen_6756(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_6757","instance":6757,"id":193428,"goal":"lemma SeqReverseIdem_6757(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_6758","instance":6758,"id":193429,"goal":"lemma SeqMapLen_6758(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_6759","instance":6759,"id":193430,"goal":"lemma SeqFilterLe_6759(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_6760","instance":6760,"id":193431,"goal":"lemma SeqMemberAppend_6760(ys: seq, xs: seq)\n ensures x in ys + xs <==> x in ys || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_6761","instance":6761,"id":193432,"goal":"lemma SeqAppendLen_6761(xs: seq, t: seq)\n ensures |xs + t| == |xs| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_6762","instance":6762,"id":193433,"goal":"lemma SeqAppendNil_6762(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_6763","instance":6763,"id":193434,"goal":"lemma SeqNilAppend_6763(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_6764","instance":6764,"id":193435,"goal":"lemma SeqAppendAssoc_6764(zs: seq, xs: seq, t: seq)\n ensures (zs + xs) + t == zs + (xs + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_6765","instance":6765,"id":193436,"goal":"lemma SeqTakeDrop_6765(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_6766","instance":6766,"id":193437,"goal":"lemma SeqReverseLen_6766(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_6767","instance":6767,"id":193438,"goal":"lemma SeqReverseIdem_6767(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_6768","instance":6768,"id":193439,"goal":"lemma SeqMapLen_6768(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_6769","instance":6769,"id":193440,"goal":"lemma SeqFilterLe_6769(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_6770","instance":6770,"id":193441,"goal":"lemma SeqMemberAppend_6770(u: seq, t: seq)\n ensures x in u + t <==> x in u || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_6771","instance":6771,"id":193442,"goal":"lemma SeqAppendLen_6771(t: seq, zs: seq)\n ensures |t + zs| == |t| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_6772","instance":6772,"id":193443,"goal":"lemma SeqAppendNil_6772(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_6773","instance":6773,"id":193444,"goal":"lemma SeqNilAppend_6773(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_6774","instance":6774,"id":193445,"goal":"lemma SeqAppendAssoc_6774(s: seq, ys: seq, t: seq)\n ensures (s + ys) + t == s + (ys + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_6775","instance":6775,"id":193446,"goal":"lemma SeqTakeDrop_6775(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_6776","instance":6776,"id":193447,"goal":"lemma SeqReverseLen_6776(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_6777","instance":6777,"id":193448,"goal":"lemma SeqReverseIdem_6777(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_6778","instance":6778,"id":193449,"goal":"lemma SeqMapLen_6778(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_6779","instance":6779,"id":193450,"goal":"lemma SeqFilterLe_6779(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_6780","instance":6780,"id":193451,"goal":"lemma SeqMemberAppend_6780(ys: seq, t: seq)\n ensures x in ys + t <==> x in ys || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_6781","instance":6781,"id":193452,"goal":"lemma SeqAppendLen_6781(s: seq, zs: seq)\n ensures |s + zs| == |s| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_6782","instance":6782,"id":193453,"goal":"lemma SeqAppendNil_6782(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_6783","instance":6783,"id":193454,"goal":"lemma SeqNilAppend_6783(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_6784","instance":6784,"id":193455,"goal":"lemma SeqAppendAssoc_6784(zs: seq, ys: seq, s: seq)\n ensures (zs + ys) + s == zs + (ys + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_6785","instance":6785,"id":193456,"goal":"lemma SeqTakeDrop_6785(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_6786","instance":6786,"id":193457,"goal":"lemma SeqReverseLen_6786(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_6787","instance":6787,"id":193458,"goal":"lemma SeqReverseIdem_6787(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_6788","instance":6788,"id":193459,"goal":"lemma SeqMapLen_6788(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_6789","instance":6789,"id":193460,"goal":"lemma SeqFilterLe_6789(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_6790","instance":6790,"id":193461,"goal":"lemma SeqMemberAppend_6790(t: seq, xs: seq)\n ensures x in t + xs <==> x in t || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_6791","instance":6791,"id":193462,"goal":"lemma SeqAppendLen_6791(xs: seq, zs: seq)\n ensures |xs + zs| == |xs| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_6792","instance":6792,"id":193463,"goal":"lemma SeqAppendNil_6792(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_6793","instance":6793,"id":193464,"goal":"lemma SeqNilAppend_6793(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_6794","instance":6794,"id":193465,"goal":"lemma SeqAppendAssoc_6794(s: seq, u: seq, t: seq)\n ensures (s + u) + t == s + (u + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_6795","instance":6795,"id":193466,"goal":"lemma SeqTakeDrop_6795(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_6796","instance":6796,"id":193467,"goal":"lemma SeqReverseLen_6796(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_6797","instance":6797,"id":193468,"goal":"lemma SeqReverseIdem_6797(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_6798","instance":6798,"id":193469,"goal":"lemma SeqMapLen_6798(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_6799","instance":6799,"id":193470,"goal":"lemma SeqFilterLe_6799(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_6800","instance":6800,"id":193471,"goal":"lemma SeqMemberAppend_6800(t: seq, s: seq)\n ensures x in t + s <==> x in t || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_6801","instance":6801,"id":193472,"goal":"lemma SeqAppendLen_6801(u: seq, t: seq)\n ensures |u + t| == |u| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_6802","instance":6802,"id":193473,"goal":"lemma SeqAppendNil_6802(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_6803","instance":6803,"id":193474,"goal":"lemma SeqNilAppend_6803(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_6804","instance":6804,"id":193475,"goal":"lemma SeqAppendAssoc_6804(s: seq, xs: seq, u: seq)\n ensures (s + xs) + u == s + (xs + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_6805","instance":6805,"id":193476,"goal":"lemma SeqTakeDrop_6805(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_6806","instance":6806,"id":193477,"goal":"lemma SeqReverseLen_6806(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_6807","instance":6807,"id":193478,"goal":"lemma SeqReverseIdem_6807(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_6808","instance":6808,"id":193479,"goal":"lemma SeqMapLen_6808(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_6809","instance":6809,"id":193480,"goal":"lemma SeqFilterLe_6809(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_6810","instance":6810,"id":193481,"goal":"lemma SeqMemberAppend_6810(ys: seq, u: seq)\n ensures x in ys + u <==> x in ys || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_6811","instance":6811,"id":193482,"goal":"lemma SeqAppendLen_6811(u: seq, t: seq)\n ensures |u + t| == |u| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_6812","instance":6812,"id":193483,"goal":"lemma SeqAppendNil_6812(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_6813","instance":6813,"id":193484,"goal":"lemma SeqNilAppend_6813(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_6814","instance":6814,"id":193485,"goal":"lemma SeqAppendAssoc_6814(xs: seq, s: seq, u: seq)\n ensures (xs + s) + u == xs + (s + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_6815","instance":6815,"id":193486,"goal":"lemma SeqTakeDrop_6815(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_6816","instance":6816,"id":193487,"goal":"lemma SeqReverseLen_6816(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_6817","instance":6817,"id":193488,"goal":"lemma SeqReverseIdem_6817(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_6818","instance":6818,"id":193489,"goal":"lemma SeqMapLen_6818(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_6819","instance":6819,"id":193490,"goal":"lemma SeqFilterLe_6819(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_6820","instance":6820,"id":193491,"goal":"lemma SeqMemberAppend_6820(xs: seq, s: seq)\n ensures x in xs + s <==> x in xs || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_6821","instance":6821,"id":193492,"goal":"lemma SeqAppendLen_6821(t: seq, u: seq)\n ensures |t + u| == |t| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_6822","instance":6822,"id":193493,"goal":"lemma SeqAppendNil_6822(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_6823","instance":6823,"id":193494,"goal":"lemma SeqNilAppend_6823(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_6824","instance":6824,"id":193495,"goal":"lemma SeqAppendAssoc_6824(zs: seq, u: seq, xs: seq)\n ensures (zs + u) + xs == zs + (u + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_6825","instance":6825,"id":193496,"goal":"lemma SeqTakeDrop_6825(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_6826","instance":6826,"id":193497,"goal":"lemma SeqReverseLen_6826(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_6827","instance":6827,"id":193498,"goal":"lemma SeqReverseIdem_6827(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_6828","instance":6828,"id":193499,"goal":"lemma SeqMapLen_6828(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_6829","instance":6829,"id":193500,"goal":"lemma SeqFilterLe_6829(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_6830","instance":6830,"id":193501,"goal":"lemma SeqMemberAppend_6830(u: seq, zs: seq)\n ensures x in u + zs <==> x in u || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_6831","instance":6831,"id":193502,"goal":"lemma SeqAppendLen_6831(u: seq, xs: seq)\n ensures |u + xs| == |u| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_6832","instance":6832,"id":193503,"goal":"lemma SeqAppendNil_6832(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_6833","instance":6833,"id":193504,"goal":"lemma SeqNilAppend_6833(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_6834","instance":6834,"id":193505,"goal":"lemma SeqAppendAssoc_6834(zs: seq, u: seq, t: seq)\n ensures (zs + u) + t == zs + (u + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_6835","instance":6835,"id":193506,"goal":"lemma SeqTakeDrop_6835(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_6836","instance":6836,"id":193507,"goal":"lemma SeqReverseLen_6836(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_6837","instance":6837,"id":193508,"goal":"lemma SeqReverseIdem_6837(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_6838","instance":6838,"id":193509,"goal":"lemma SeqMapLen_6838(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_6839","instance":6839,"id":193510,"goal":"lemma SeqFilterLe_6839(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_6840","instance":6840,"id":193511,"goal":"lemma SeqMemberAppend_6840(s: seq, ys: seq)\n ensures x in s + ys <==> x in s || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_6841","instance":6841,"id":193512,"goal":"lemma SeqAppendLen_6841(s: seq, xs: seq)\n ensures |s + xs| == |s| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_6842","instance":6842,"id":193513,"goal":"lemma SeqAppendNil_6842(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_6843","instance":6843,"id":193514,"goal":"lemma SeqNilAppend_6843(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_6844","instance":6844,"id":193515,"goal":"lemma SeqAppendAssoc_6844(ys: seq, s: seq, t: seq)\n ensures (ys + s) + t == ys + (s + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_6845","instance":6845,"id":193516,"goal":"lemma SeqTakeDrop_6845(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_6846","instance":6846,"id":193517,"goal":"lemma SeqReverseLen_6846(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_6847","instance":6847,"id":193518,"goal":"lemma SeqReverseIdem_6847(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_6848","instance":6848,"id":193519,"goal":"lemma SeqMapLen_6848(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_6849","instance":6849,"id":193520,"goal":"lemma SeqFilterLe_6849(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_6850","instance":6850,"id":193521,"goal":"lemma SeqMemberAppend_6850(zs: seq, xs: seq)\n ensures x in zs + xs <==> x in zs || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_6851","instance":6851,"id":193522,"goal":"lemma SeqAppendLen_6851(xs: seq, ys: seq)\n ensures |xs + ys| == |xs| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_6852","instance":6852,"id":193523,"goal":"lemma SeqAppendNil_6852(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_6853","instance":6853,"id":193524,"goal":"lemma SeqNilAppend_6853(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_6854","instance":6854,"id":193525,"goal":"lemma SeqAppendAssoc_6854(t: seq, zs: seq, u: seq)\n ensures (t + zs) + u == t + (zs + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_6855","instance":6855,"id":193526,"goal":"lemma SeqTakeDrop_6855(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_6856","instance":6856,"id":193527,"goal":"lemma SeqReverseLen_6856(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_6857","instance":6857,"id":193528,"goal":"lemma SeqReverseIdem_6857(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_6858","instance":6858,"id":193529,"goal":"lemma SeqMapLen_6858(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_6859","instance":6859,"id":193530,"goal":"lemma SeqFilterLe_6859(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_6860","instance":6860,"id":193531,"goal":"lemma SeqMemberAppend_6860(t: seq, zs: seq)\n ensures x in t + zs <==> x in t || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_6861","instance":6861,"id":193532,"goal":"lemma SeqAppendLen_6861(xs: seq, t: seq)\n ensures |xs + t| == |xs| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_6862","instance":6862,"id":193533,"goal":"lemma SeqAppendNil_6862(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_6863","instance":6863,"id":193534,"goal":"lemma SeqNilAppend_6863(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_6864","instance":6864,"id":193535,"goal":"lemma SeqAppendAssoc_6864(u: seq, ys: seq, xs: seq)\n ensures (u + ys) + xs == u + (ys + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_6865","instance":6865,"id":193536,"goal":"lemma SeqTakeDrop_6865(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_6866","instance":6866,"id":193537,"goal":"lemma SeqReverseLen_6866(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_6867","instance":6867,"id":193538,"goal":"lemma SeqReverseIdem_6867(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_6868","instance":6868,"id":193539,"goal":"lemma SeqMapLen_6868(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_6869","instance":6869,"id":193540,"goal":"lemma SeqFilterLe_6869(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_6870","instance":6870,"id":193541,"goal":"lemma SeqMemberAppend_6870(t: seq, s: seq)\n ensures x in t + s <==> x in t || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_6871","instance":6871,"id":193542,"goal":"lemma SeqAppendLen_6871(ys: seq, u: seq)\n ensures |ys + u| == |ys| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_6872","instance":6872,"id":193543,"goal":"lemma SeqAppendNil_6872(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_6873","instance":6873,"id":193544,"goal":"lemma SeqNilAppend_6873(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_6874","instance":6874,"id":193545,"goal":"lemma SeqAppendAssoc_6874(zs: seq, ys: seq, t: seq)\n ensures (zs + ys) + t == zs + (ys + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_6875","instance":6875,"id":193546,"goal":"lemma SeqTakeDrop_6875(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_6876","instance":6876,"id":193547,"goal":"lemma SeqReverseLen_6876(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_6877","instance":6877,"id":193548,"goal":"lemma SeqReverseIdem_6877(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_6878","instance":6878,"id":193549,"goal":"lemma SeqMapLen_6878(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_6879","instance":6879,"id":193550,"goal":"lemma SeqFilterLe_6879(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_6880","instance":6880,"id":193551,"goal":"lemma SeqMemberAppend_6880(ys: seq, t: seq)\n ensures x in ys + t <==> x in ys || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_6881","instance":6881,"id":193552,"goal":"lemma SeqAppendLen_6881(u: seq, xs: seq)\n ensures |u + xs| == |u| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_6882","instance":6882,"id":193553,"goal":"lemma SeqAppendNil_6882(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_6883","instance":6883,"id":193554,"goal":"lemma SeqNilAppend_6883(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_6884","instance":6884,"id":193555,"goal":"lemma SeqAppendAssoc_6884(u: seq, s: seq, zs: seq)\n ensures (u + s) + zs == u + (s + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_6885","instance":6885,"id":193556,"goal":"lemma SeqTakeDrop_6885(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_6886","instance":6886,"id":193557,"goal":"lemma SeqReverseLen_6886(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_6887","instance":6887,"id":193558,"goal":"lemma SeqReverseIdem_6887(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_6888","instance":6888,"id":193559,"goal":"lemma SeqMapLen_6888(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_6889","instance":6889,"id":193560,"goal":"lemma SeqFilterLe_6889(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_6890","instance":6890,"id":193561,"goal":"lemma SeqMemberAppend_6890(ys: seq, t: seq)\n ensures x in ys + t <==> x in ys || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_6891","instance":6891,"id":193562,"goal":"lemma SeqAppendLen_6891(u: seq, t: seq)\n ensures |u + t| == |u| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_6892","instance":6892,"id":193563,"goal":"lemma SeqAppendNil_6892(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_6893","instance":6893,"id":193564,"goal":"lemma SeqNilAppend_6893(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_6894","instance":6894,"id":193565,"goal":"lemma SeqAppendAssoc_6894(ys: seq, t: seq, u: seq)\n ensures (ys + t) + u == ys + (t + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_6895","instance":6895,"id":193566,"goal":"lemma SeqTakeDrop_6895(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_6896","instance":6896,"id":193567,"goal":"lemma SeqReverseLen_6896(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_6897","instance":6897,"id":193568,"goal":"lemma SeqReverseIdem_6897(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_6898","instance":6898,"id":193569,"goal":"lemma SeqMapLen_6898(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_6899","instance":6899,"id":193570,"goal":"lemma SeqFilterLe_6899(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_6900","instance":6900,"id":193571,"goal":"lemma SeqMemberAppend_6900(s: seq, xs: seq)\n ensures x in s + xs <==> x in s || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_6901","instance":6901,"id":193572,"goal":"lemma SeqAppendLen_6901(ys: seq, u: seq)\n ensures |ys + u| == |ys| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_6902","instance":6902,"id":193573,"goal":"lemma SeqAppendNil_6902(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_6903","instance":6903,"id":193574,"goal":"lemma SeqNilAppend_6903(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_6904","instance":6904,"id":193575,"goal":"lemma SeqAppendAssoc_6904(ys: seq, zs: seq, t: seq)\n ensures (ys + zs) + t == ys + (zs + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_6905","instance":6905,"id":193576,"goal":"lemma SeqTakeDrop_6905(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_6906","instance":6906,"id":193577,"goal":"lemma SeqReverseLen_6906(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_6907","instance":6907,"id":193578,"goal":"lemma SeqReverseIdem_6907(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_6908","instance":6908,"id":193579,"goal":"lemma SeqMapLen_6908(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_6909","instance":6909,"id":193580,"goal":"lemma SeqFilterLe_6909(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_6910","instance":6910,"id":193581,"goal":"lemma SeqMemberAppend_6910(u: seq, s: seq)\n ensures x in u + s <==> x in u || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_6911","instance":6911,"id":193582,"goal":"lemma SeqAppendLen_6911(s: seq, u: seq)\n ensures |s + u| == |s| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_6912","instance":6912,"id":193583,"goal":"lemma SeqAppendNil_6912(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_6913","instance":6913,"id":193584,"goal":"lemma SeqNilAppend_6913(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_6914","instance":6914,"id":193585,"goal":"lemma SeqAppendAssoc_6914(ys: seq, zs: seq, xs: seq)\n ensures (ys + zs) + xs == ys + (zs + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_6915","instance":6915,"id":193586,"goal":"lemma SeqTakeDrop_6915(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_6916","instance":6916,"id":193587,"goal":"lemma SeqReverseLen_6916(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_6917","instance":6917,"id":193588,"goal":"lemma SeqReverseIdem_6917(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_6918","instance":6918,"id":193589,"goal":"lemma SeqMapLen_6918(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_6919","instance":6919,"id":193590,"goal":"lemma SeqFilterLe_6919(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_6920","instance":6920,"id":193591,"goal":"lemma SeqMemberAppend_6920(xs: seq, ys: seq)\n ensures x in xs + ys <==> x in xs || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_6921","instance":6921,"id":193592,"goal":"lemma SeqAppendLen_6921(ys: seq, u: seq)\n ensures |ys + u| == |ys| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_6922","instance":6922,"id":193593,"goal":"lemma SeqAppendNil_6922(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_6923","instance":6923,"id":193594,"goal":"lemma SeqNilAppend_6923(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_6924","instance":6924,"id":193595,"goal":"lemma SeqAppendAssoc_6924(zs: seq, u: seq, t: seq)\n ensures (zs + u) + t == zs + (u + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_6925","instance":6925,"id":193596,"goal":"lemma SeqTakeDrop_6925(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_6926","instance":6926,"id":193597,"goal":"lemma SeqReverseLen_6926(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_6927","instance":6927,"id":193598,"goal":"lemma SeqReverseIdem_6927(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_6928","instance":6928,"id":193599,"goal":"lemma SeqMapLen_6928(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_6929","instance":6929,"id":193600,"goal":"lemma SeqFilterLe_6929(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_6930","instance":6930,"id":193601,"goal":"lemma SeqMemberAppend_6930(t: seq, xs: seq)\n ensures x in t + xs <==> x in t || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_6931","instance":6931,"id":193602,"goal":"lemma SeqAppendLen_6931(xs: seq, t: seq)\n ensures |xs + t| == |xs| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_6932","instance":6932,"id":193603,"goal":"lemma SeqAppendNil_6932(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_6933","instance":6933,"id":193604,"goal":"lemma SeqNilAppend_6933(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_6934","instance":6934,"id":193605,"goal":"lemma SeqAppendAssoc_6934(s: seq, u: seq, t: seq)\n ensures (s + u) + t == s + (u + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_6935","instance":6935,"id":193606,"goal":"lemma SeqTakeDrop_6935(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_6936","instance":6936,"id":193607,"goal":"lemma SeqReverseLen_6936(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_6937","instance":6937,"id":193608,"goal":"lemma SeqReverseIdem_6937(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_6938","instance":6938,"id":193609,"goal":"lemma SeqMapLen_6938(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_6939","instance":6939,"id":193610,"goal":"lemma SeqFilterLe_6939(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_6940","instance":6940,"id":193611,"goal":"lemma SeqMemberAppend_6940(xs: seq, ys: seq)\n ensures x in xs + ys <==> x in xs || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_6941","instance":6941,"id":193612,"goal":"lemma SeqAppendLen_6941(zs: seq, s: seq)\n ensures |zs + s| == |zs| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_6942","instance":6942,"id":193613,"goal":"lemma SeqAppendNil_6942(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_6943","instance":6943,"id":193614,"goal":"lemma SeqNilAppend_6943(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_6944","instance":6944,"id":193615,"goal":"lemma SeqAppendAssoc_6944(s: seq, zs: seq, ys: seq)\n ensures (s + zs) + ys == s + (zs + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_6945","instance":6945,"id":193616,"goal":"lemma SeqTakeDrop_6945(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_6946","instance":6946,"id":193617,"goal":"lemma SeqReverseLen_6946(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_6947","instance":6947,"id":193618,"goal":"lemma SeqReverseIdem_6947(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_6948","instance":6948,"id":193619,"goal":"lemma SeqMapLen_6948(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_6949","instance":6949,"id":193620,"goal":"lemma SeqFilterLe_6949(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_6950","instance":6950,"id":193621,"goal":"lemma SeqMemberAppend_6950(zs: seq, u: seq)\n ensures x in zs + u <==> x in zs || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_6951","instance":6951,"id":193622,"goal":"lemma SeqAppendLen_6951(t: seq, s: seq)\n ensures |t + s| == |t| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_6952","instance":6952,"id":193623,"goal":"lemma SeqAppendNil_6952(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_6953","instance":6953,"id":193624,"goal":"lemma SeqNilAppend_6953(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_6954","instance":6954,"id":193625,"goal":"lemma SeqAppendAssoc_6954(u: seq, t: seq, ys: seq)\n ensures (u + t) + ys == u + (t + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_6955","instance":6955,"id":193626,"goal":"lemma SeqTakeDrop_6955(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_6956","instance":6956,"id":193627,"goal":"lemma SeqReverseLen_6956(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_6957","instance":6957,"id":193628,"goal":"lemma SeqReverseIdem_6957(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_6958","instance":6958,"id":193629,"goal":"lemma SeqMapLen_6958(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_6959","instance":6959,"id":193630,"goal":"lemma SeqFilterLe_6959(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_6960","instance":6960,"id":193631,"goal":"lemma SeqMemberAppend_6960(t: seq, ys: seq)\n ensures x in t + ys <==> x in t || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_6961","instance":6961,"id":193632,"goal":"lemma SeqAppendLen_6961(zs: seq, u: seq)\n ensures |zs + u| == |zs| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_6962","instance":6962,"id":193633,"goal":"lemma SeqAppendNil_6962(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_6963","instance":6963,"id":193634,"goal":"lemma SeqNilAppend_6963(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_6964","instance":6964,"id":193635,"goal":"lemma SeqAppendAssoc_6964(xs: seq, t: seq, u: seq)\n ensures (xs + t) + u == xs + (t + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_6965","instance":6965,"id":193636,"goal":"lemma SeqTakeDrop_6965(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_6966","instance":6966,"id":193637,"goal":"lemma SeqReverseLen_6966(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_6967","instance":6967,"id":193638,"goal":"lemma SeqReverseIdem_6967(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_6968","instance":6968,"id":193639,"goal":"lemma SeqMapLen_6968(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_6969","instance":6969,"id":193640,"goal":"lemma SeqFilterLe_6969(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_6970","instance":6970,"id":193641,"goal":"lemma SeqMemberAppend_6970(zs: seq, xs: seq)\n ensures x in zs + xs <==> x in zs || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_6971","instance":6971,"id":193642,"goal":"lemma SeqAppendLen_6971(xs: seq, u: seq)\n ensures |xs + u| == |xs| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_6972","instance":6972,"id":193643,"goal":"lemma SeqAppendNil_6972(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_6973","instance":6973,"id":193644,"goal":"lemma SeqNilAppend_6973(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_6974","instance":6974,"id":193645,"goal":"lemma SeqAppendAssoc_6974(ys: seq, s: seq, t: seq)\n ensures (ys + s) + t == ys + (s + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_6975","instance":6975,"id":193646,"goal":"lemma SeqTakeDrop_6975(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_6976","instance":6976,"id":193647,"goal":"lemma SeqReverseLen_6976(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_6977","instance":6977,"id":193648,"goal":"lemma SeqReverseIdem_6977(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_6978","instance":6978,"id":193649,"goal":"lemma SeqMapLen_6978(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_6979","instance":6979,"id":193650,"goal":"lemma SeqFilterLe_6979(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_6980","instance":6980,"id":193651,"goal":"lemma SeqMemberAppend_6980(s: seq, t: seq)\n ensures x in s + t <==> x in s || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_6981","instance":6981,"id":193652,"goal":"lemma SeqAppendLen_6981(zs: seq, u: seq)\n ensures |zs + u| == |zs| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_6982","instance":6982,"id":193653,"goal":"lemma SeqAppendNil_6982(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_6983","instance":6983,"id":193654,"goal":"lemma SeqNilAppend_6983(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_6984","instance":6984,"id":193655,"goal":"lemma SeqAppendAssoc_6984(u: seq, zs: seq, s: seq)\n ensures (u + zs) + s == u + (zs + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_6985","instance":6985,"id":193656,"goal":"lemma SeqTakeDrop_6985(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_6986","instance":6986,"id":193657,"goal":"lemma SeqReverseLen_6986(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_6987","instance":6987,"id":193658,"goal":"lemma SeqReverseIdem_6987(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_6988","instance":6988,"id":193659,"goal":"lemma SeqMapLen_6988(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_6989","instance":6989,"id":193660,"goal":"lemma SeqFilterLe_6989(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_6990","instance":6990,"id":193661,"goal":"lemma SeqMemberAppend_6990(s: seq, u: seq)\n ensures x in s + u <==> x in s || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_6991","instance":6991,"id":193662,"goal":"lemma SeqAppendLen_6991(ys: seq, t: seq)\n ensures |ys + t| == |ys| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_6992","instance":6992,"id":193663,"goal":"lemma SeqAppendNil_6992(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_6993","instance":6993,"id":193664,"goal":"lemma SeqNilAppend_6993(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_6994","instance":6994,"id":193665,"goal":"lemma SeqAppendAssoc_6994(u: seq, s: seq, t: seq)\n ensures (u + s) + t == u + (s + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_6995","instance":6995,"id":193666,"goal":"lemma SeqTakeDrop_6995(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_6996","instance":6996,"id":193667,"goal":"lemma SeqReverseLen_6996(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_6997","instance":6997,"id":193668,"goal":"lemma SeqReverseIdem_6997(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_6998","instance":6998,"id":193669,"goal":"lemma SeqMapLen_6998(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_6999","instance":6999,"id":193670,"goal":"lemma SeqFilterLe_6999(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_7000","instance":7000,"id":193671,"goal":"lemma SeqMemberAppend_7000(t: seq, u: seq)\n ensures x in t + u <==> x in t || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_7001","instance":7001,"id":193672,"goal":"lemma SeqAppendLen_7001(s: seq, u: seq)\n ensures |s + u| == |s| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_7002","instance":7002,"id":193673,"goal":"lemma SeqAppendNil_7002(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_7003","instance":7003,"id":193674,"goal":"lemma SeqNilAppend_7003(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_7004","instance":7004,"id":193675,"goal":"lemma SeqAppendAssoc_7004(ys: seq, s: seq, xs: seq)\n ensures (ys + s) + xs == ys + (s + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_7005","instance":7005,"id":193676,"goal":"lemma SeqTakeDrop_7005(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_7006","instance":7006,"id":193677,"goal":"lemma SeqReverseLen_7006(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_7007","instance":7007,"id":193678,"goal":"lemma SeqReverseIdem_7007(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_7008","instance":7008,"id":193679,"goal":"lemma SeqMapLen_7008(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_7009","instance":7009,"id":193680,"goal":"lemma SeqFilterLe_7009(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_7010","instance":7010,"id":193681,"goal":"lemma SeqMemberAppend_7010(u: seq, zs: seq)\n ensures x in u + zs <==> x in u || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_7011","instance":7011,"id":193682,"goal":"lemma SeqAppendLen_7011(xs: seq, u: seq)\n ensures |xs + u| == |xs| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_7012","instance":7012,"id":193683,"goal":"lemma SeqAppendNil_7012(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_7013","instance":7013,"id":193684,"goal":"lemma SeqNilAppend_7013(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_7014","instance":7014,"id":193685,"goal":"lemma SeqAppendAssoc_7014(u: seq, s: seq, xs: seq)\n ensures (u + s) + xs == u + (s + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_7015","instance":7015,"id":193686,"goal":"lemma SeqTakeDrop_7015(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_7016","instance":7016,"id":193687,"goal":"lemma SeqReverseLen_7016(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_7017","instance":7017,"id":193688,"goal":"lemma SeqReverseIdem_7017(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_7018","instance":7018,"id":193689,"goal":"lemma SeqMapLen_7018(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_7019","instance":7019,"id":193690,"goal":"lemma SeqFilterLe_7019(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_7020","instance":7020,"id":193691,"goal":"lemma SeqMemberAppend_7020(xs: seq, t: seq)\n ensures x in xs + t <==> x in xs || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_7021","instance":7021,"id":193692,"goal":"lemma SeqAppendLen_7021(u: seq, xs: seq)\n ensures |u + xs| == |u| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_7022","instance":7022,"id":193693,"goal":"lemma SeqAppendNil_7022(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_7023","instance":7023,"id":193694,"goal":"lemma SeqNilAppend_7023(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_7024","instance":7024,"id":193695,"goal":"lemma SeqAppendAssoc_7024(ys: seq, xs: seq, zs: seq)\n ensures (ys + xs) + zs == ys + (xs + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_7025","instance":7025,"id":193696,"goal":"lemma SeqTakeDrop_7025(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_7026","instance":7026,"id":193697,"goal":"lemma SeqReverseLen_7026(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_7027","instance":7027,"id":193698,"goal":"lemma SeqReverseIdem_7027(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_7028","instance":7028,"id":193699,"goal":"lemma SeqMapLen_7028(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_7029","instance":7029,"id":193700,"goal":"lemma SeqFilterLe_7029(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_7030","instance":7030,"id":193701,"goal":"lemma SeqMemberAppend_7030(ys: seq, s: seq)\n ensures x in ys + s <==> x in ys || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_7031","instance":7031,"id":193702,"goal":"lemma SeqAppendLen_7031(ys: seq, u: seq)\n ensures |ys + u| == |ys| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_7032","instance":7032,"id":193703,"goal":"lemma SeqAppendNil_7032(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_7033","instance":7033,"id":193704,"goal":"lemma SeqNilAppend_7033(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_7034","instance":7034,"id":193705,"goal":"lemma SeqAppendAssoc_7034(t: seq, ys: seq, zs: seq)\n ensures (t + ys) + zs == t + (ys + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_7035","instance":7035,"id":193706,"goal":"lemma SeqTakeDrop_7035(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_7036","instance":7036,"id":193707,"goal":"lemma SeqReverseLen_7036(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_7037","instance":7037,"id":193708,"goal":"lemma SeqReverseIdem_7037(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_7038","instance":7038,"id":193709,"goal":"lemma SeqMapLen_7038(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_7039","instance":7039,"id":193710,"goal":"lemma SeqFilterLe_7039(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_7040","instance":7040,"id":193711,"goal":"lemma SeqMemberAppend_7040(xs: seq, zs: seq)\n ensures x in xs + zs <==> x in xs || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_7041","instance":7041,"id":193712,"goal":"lemma SeqAppendLen_7041(u: seq, xs: seq)\n ensures |u + xs| == |u| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_7042","instance":7042,"id":193713,"goal":"lemma SeqAppendNil_7042(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_7043","instance":7043,"id":193714,"goal":"lemma SeqNilAppend_7043(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_7044","instance":7044,"id":193715,"goal":"lemma SeqAppendAssoc_7044(s: seq, xs: seq, ys: seq)\n ensures (s + xs) + ys == s + (xs + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_7045","instance":7045,"id":193716,"goal":"lemma SeqTakeDrop_7045(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_7046","instance":7046,"id":193717,"goal":"lemma SeqReverseLen_7046(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_7047","instance":7047,"id":193718,"goal":"lemma SeqReverseIdem_7047(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_7048","instance":7048,"id":193719,"goal":"lemma SeqMapLen_7048(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_7049","instance":7049,"id":193720,"goal":"lemma SeqFilterLe_7049(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_7050","instance":7050,"id":193721,"goal":"lemma SeqMemberAppend_7050(s: seq, zs: seq)\n ensures x in s + zs <==> x in s || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_7051","instance":7051,"id":193722,"goal":"lemma SeqAppendLen_7051(zs: seq, t: seq)\n ensures |zs + t| == |zs| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_7052","instance":7052,"id":193723,"goal":"lemma SeqAppendNil_7052(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_7053","instance":7053,"id":193724,"goal":"lemma SeqNilAppend_7053(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_7054","instance":7054,"id":193725,"goal":"lemma SeqAppendAssoc_7054(ys: seq, zs: seq, s: seq)\n ensures (ys + zs) + s == ys + (zs + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_7055","instance":7055,"id":193726,"goal":"lemma SeqTakeDrop_7055(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_7056","instance":7056,"id":193727,"goal":"lemma SeqReverseLen_7056(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_7057","instance":7057,"id":193728,"goal":"lemma SeqReverseIdem_7057(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_7058","instance":7058,"id":193729,"goal":"lemma SeqMapLen_7058(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_7059","instance":7059,"id":193730,"goal":"lemma SeqFilterLe_7059(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_7060","instance":7060,"id":193731,"goal":"lemma SeqMemberAppend_7060(s: seq, t: seq)\n ensures x in s + t <==> x in s || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_7061","instance":7061,"id":193732,"goal":"lemma SeqAppendLen_7061(t: seq, zs: seq)\n ensures |t + zs| == |t| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_7062","instance":7062,"id":193733,"goal":"lemma SeqAppendNil_7062(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_7063","instance":7063,"id":193734,"goal":"lemma SeqNilAppend_7063(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_7064","instance":7064,"id":193735,"goal":"lemma SeqAppendAssoc_7064(ys: seq, t: seq, s: seq)\n ensures (ys + t) + s == ys + (t + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_7065","instance":7065,"id":193736,"goal":"lemma SeqTakeDrop_7065(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_7066","instance":7066,"id":193737,"goal":"lemma SeqReverseLen_7066(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_7067","instance":7067,"id":193738,"goal":"lemma SeqReverseIdem_7067(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_7068","instance":7068,"id":193739,"goal":"lemma SeqMapLen_7068(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_7069","instance":7069,"id":193740,"goal":"lemma SeqFilterLe_7069(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_7070","instance":7070,"id":193741,"goal":"lemma SeqMemberAppend_7070(u: seq, zs: seq)\n ensures x in u + zs <==> x in u || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_7071","instance":7071,"id":193742,"goal":"lemma SeqAppendLen_7071(t: seq, s: seq)\n ensures |t + s| == |t| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_7072","instance":7072,"id":193743,"goal":"lemma SeqAppendNil_7072(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_7073","instance":7073,"id":193744,"goal":"lemma SeqNilAppend_7073(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_7074","instance":7074,"id":193745,"goal":"lemma SeqAppendAssoc_7074(u: seq, s: seq, t: seq)\n ensures (u + s) + t == u + (s + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_7075","instance":7075,"id":193746,"goal":"lemma SeqTakeDrop_7075(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_7076","instance":7076,"id":193747,"goal":"lemma SeqReverseLen_7076(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_7077","instance":7077,"id":193748,"goal":"lemma SeqReverseIdem_7077(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_7078","instance":7078,"id":193749,"goal":"lemma SeqMapLen_7078(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_7079","instance":7079,"id":193750,"goal":"lemma SeqFilterLe_7079(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_7080","instance":7080,"id":193751,"goal":"lemma SeqMemberAppend_7080(xs: seq, s: seq)\n ensures x in xs + s <==> x in xs || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_7081","instance":7081,"id":193752,"goal":"lemma SeqAppendLen_7081(ys: seq, t: seq)\n ensures |ys + t| == |ys| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_7082","instance":7082,"id":193753,"goal":"lemma SeqAppendNil_7082(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_7083","instance":7083,"id":193754,"goal":"lemma SeqNilAppend_7083(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_7084","instance":7084,"id":193755,"goal":"lemma SeqAppendAssoc_7084(t: seq, s: seq, ys: seq)\n ensures (t + s) + ys == t + (s + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_7085","instance":7085,"id":193756,"goal":"lemma SeqTakeDrop_7085(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_7086","instance":7086,"id":193757,"goal":"lemma SeqReverseLen_7086(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_7087","instance":7087,"id":193758,"goal":"lemma SeqReverseIdem_7087(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_7088","instance":7088,"id":193759,"goal":"lemma SeqMapLen_7088(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_7089","instance":7089,"id":193760,"goal":"lemma SeqFilterLe_7089(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_7090","instance":7090,"id":193761,"goal":"lemma SeqMemberAppend_7090(t: seq, s: seq)\n ensures x in t + s <==> x in t || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_7091","instance":7091,"id":193762,"goal":"lemma SeqAppendLen_7091(zs: seq, u: seq)\n ensures |zs + u| == |zs| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_7092","instance":7092,"id":193763,"goal":"lemma SeqAppendNil_7092(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_7093","instance":7093,"id":193764,"goal":"lemma SeqNilAppend_7093(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_7094","instance":7094,"id":193765,"goal":"lemma SeqAppendAssoc_7094(u: seq, s: seq, zs: seq)\n ensures (u + s) + zs == u + (s + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_7095","instance":7095,"id":193766,"goal":"lemma SeqTakeDrop_7095(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_7096","instance":7096,"id":193767,"goal":"lemma SeqReverseLen_7096(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_7097","instance":7097,"id":193768,"goal":"lemma SeqReverseIdem_7097(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_7098","instance":7098,"id":193769,"goal":"lemma SeqMapLen_7098(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_7099","instance":7099,"id":193770,"goal":"lemma SeqFilterLe_7099(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_7100","instance":7100,"id":193771,"goal":"lemma SeqMemberAppend_7100(s: seq, xs: seq)\n ensures x in s + xs <==> x in s || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_7101","instance":7101,"id":193772,"goal":"lemma SeqAppendLen_7101(t: seq, zs: seq)\n ensures |t + zs| == |t| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_7102","instance":7102,"id":193773,"goal":"lemma SeqAppendNil_7102(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_7103","instance":7103,"id":193774,"goal":"lemma SeqNilAppend_7103(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_7104","instance":7104,"id":193775,"goal":"lemma SeqAppendAssoc_7104(u: seq, xs: seq, s: seq)\n ensures (u + xs) + s == u + (xs + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_7105","instance":7105,"id":193776,"goal":"lemma SeqTakeDrop_7105(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_7106","instance":7106,"id":193777,"goal":"lemma SeqReverseLen_7106(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_7107","instance":7107,"id":193778,"goal":"lemma SeqReverseIdem_7107(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_7108","instance":7108,"id":193779,"goal":"lemma SeqMapLen_7108(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_7109","instance":7109,"id":193780,"goal":"lemma SeqFilterLe_7109(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_7110","instance":7110,"id":193781,"goal":"lemma SeqMemberAppend_7110(s: seq, ys: seq)\n ensures x in s + ys <==> x in s || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_7111","instance":7111,"id":193782,"goal":"lemma SeqAppendLen_7111(zs: seq, u: seq)\n ensures |zs + u| == |zs| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_7112","instance":7112,"id":193783,"goal":"lemma SeqAppendNil_7112(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_7113","instance":7113,"id":193784,"goal":"lemma SeqNilAppend_7113(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_7114","instance":7114,"id":193785,"goal":"lemma SeqAppendAssoc_7114(xs: seq, zs: seq, ys: seq)\n ensures (xs + zs) + ys == xs + (zs + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_7115","instance":7115,"id":193786,"goal":"lemma SeqTakeDrop_7115(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_7116","instance":7116,"id":193787,"goal":"lemma SeqReverseLen_7116(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_7117","instance":7117,"id":193788,"goal":"lemma SeqReverseIdem_7117(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_7118","instance":7118,"id":193789,"goal":"lemma SeqMapLen_7118(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_7119","instance":7119,"id":193790,"goal":"lemma SeqFilterLe_7119(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_7120","instance":7120,"id":193791,"goal":"lemma SeqMemberAppend_7120(ys: seq, xs: seq)\n ensures x in ys + xs <==> x in ys || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_7121","instance":7121,"id":193792,"goal":"lemma SeqAppendLen_7121(zs: seq, u: seq)\n ensures |zs + u| == |zs| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_7122","instance":7122,"id":193793,"goal":"lemma SeqAppendNil_7122(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_7123","instance":7123,"id":193794,"goal":"lemma SeqNilAppend_7123(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_7124","instance":7124,"id":193795,"goal":"lemma SeqAppendAssoc_7124(ys: seq, xs: seq, zs: seq)\n ensures (ys + xs) + zs == ys + (xs + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_7125","instance":7125,"id":193796,"goal":"lemma SeqTakeDrop_7125(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_7126","instance":7126,"id":193797,"goal":"lemma SeqReverseLen_7126(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_7127","instance":7127,"id":193798,"goal":"lemma SeqReverseIdem_7127(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_7128","instance":7128,"id":193799,"goal":"lemma SeqMapLen_7128(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_7129","instance":7129,"id":193800,"goal":"lemma SeqFilterLe_7129(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_7130","instance":7130,"id":193801,"goal":"lemma SeqMemberAppend_7130(s: seq, ys: seq)\n ensures x in s + ys <==> x in s || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_7131","instance":7131,"id":193802,"goal":"lemma SeqAppendLen_7131(t: seq, zs: seq)\n ensures |t + zs| == |t| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_7132","instance":7132,"id":193803,"goal":"lemma SeqAppendNil_7132(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_7133","instance":7133,"id":193804,"goal":"lemma SeqNilAppend_7133(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_7134","instance":7134,"id":193805,"goal":"lemma SeqAppendAssoc_7134(zs: seq, ys: seq, t: seq)\n ensures (zs + ys) + t == zs + (ys + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_7135","instance":7135,"id":193806,"goal":"lemma SeqTakeDrop_7135(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_7136","instance":7136,"id":193807,"goal":"lemma SeqReverseLen_7136(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_7137","instance":7137,"id":193808,"goal":"lemma SeqReverseIdem_7137(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_7138","instance":7138,"id":193809,"goal":"lemma SeqMapLen_7138(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_7139","instance":7139,"id":193810,"goal":"lemma SeqFilterLe_7139(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_7140","instance":7140,"id":193811,"goal":"lemma SeqMemberAppend_7140(ys: seq, t: seq)\n ensures x in ys + t <==> x in ys || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_7141","instance":7141,"id":193812,"goal":"lemma SeqAppendLen_7141(zs: seq, t: seq)\n ensures |zs + t| == |zs| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_7142","instance":7142,"id":193813,"goal":"lemma SeqAppendNil_7142(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_7143","instance":7143,"id":193814,"goal":"lemma SeqNilAppend_7143(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_7144","instance":7144,"id":193815,"goal":"lemma SeqAppendAssoc_7144(ys: seq, u: seq, xs: seq)\n ensures (ys + u) + xs == ys + (u + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_7145","instance":7145,"id":193816,"goal":"lemma SeqTakeDrop_7145(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_7146","instance":7146,"id":193817,"goal":"lemma SeqReverseLen_7146(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_7147","instance":7147,"id":193818,"goal":"lemma SeqReverseIdem_7147(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_7148","instance":7148,"id":193819,"goal":"lemma SeqMapLen_7148(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_7149","instance":7149,"id":193820,"goal":"lemma SeqFilterLe_7149(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_7150","instance":7150,"id":193821,"goal":"lemma SeqMemberAppend_7150(zs: seq, xs: seq)\n ensures x in zs + xs <==> x in zs || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_7151","instance":7151,"id":193822,"goal":"lemma SeqAppendLen_7151(t: seq, xs: seq)\n ensures |t + xs| == |t| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_7152","instance":7152,"id":193823,"goal":"lemma SeqAppendNil_7152(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_7153","instance":7153,"id":193824,"goal":"lemma SeqNilAppend_7153(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_7154","instance":7154,"id":193825,"goal":"lemma SeqAppendAssoc_7154(u: seq, s: seq, ys: seq)\n ensures (u + s) + ys == u + (s + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_7155","instance":7155,"id":193826,"goal":"lemma SeqTakeDrop_7155(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_7156","instance":7156,"id":193827,"goal":"lemma SeqReverseLen_7156(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_7157","instance":7157,"id":193828,"goal":"lemma SeqReverseIdem_7157(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_7158","instance":7158,"id":193829,"goal":"lemma SeqMapLen_7158(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_7159","instance":7159,"id":193830,"goal":"lemma SeqFilterLe_7159(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_7160","instance":7160,"id":193831,"goal":"lemma SeqMemberAppend_7160(zs: seq, s: seq)\n ensures x in zs + s <==> x in zs || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_7161","instance":7161,"id":193832,"goal":"lemma SeqAppendLen_7161(xs: seq, s: seq)\n ensures |xs + s| == |xs| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_7162","instance":7162,"id":193833,"goal":"lemma SeqAppendNil_7162(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_7163","instance":7163,"id":193834,"goal":"lemma SeqNilAppend_7163(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_7164","instance":7164,"id":193835,"goal":"lemma SeqAppendAssoc_7164(s: seq, zs: seq, xs: seq)\n ensures (s + zs) + xs == s + (zs + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_7165","instance":7165,"id":193836,"goal":"lemma SeqTakeDrop_7165(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_7166","instance":7166,"id":193837,"goal":"lemma SeqReverseLen_7166(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_7167","instance":7167,"id":193838,"goal":"lemma SeqReverseIdem_7167(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_7168","instance":7168,"id":193839,"goal":"lemma SeqMapLen_7168(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_7169","instance":7169,"id":193840,"goal":"lemma SeqFilterLe_7169(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_7170","instance":7170,"id":193841,"goal":"lemma SeqMemberAppend_7170(t: seq, u: seq)\n ensures x in t + u <==> x in t || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_7171","instance":7171,"id":193842,"goal":"lemma SeqAppendLen_7171(zs: seq, xs: seq)\n ensures |zs + xs| == |zs| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_7172","instance":7172,"id":193843,"goal":"lemma SeqAppendNil_7172(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_7173","instance":7173,"id":193844,"goal":"lemma SeqNilAppend_7173(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_7174","instance":7174,"id":193845,"goal":"lemma SeqAppendAssoc_7174(ys: seq, u: seq, t: seq)\n ensures (ys + u) + t == ys + (u + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_7175","instance":7175,"id":193846,"goal":"lemma SeqTakeDrop_7175(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_7176","instance":7176,"id":193847,"goal":"lemma SeqReverseLen_7176(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_7177","instance":7177,"id":193848,"goal":"lemma SeqReverseIdem_7177(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_7178","instance":7178,"id":193849,"goal":"lemma SeqMapLen_7178(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_7179","instance":7179,"id":193850,"goal":"lemma SeqFilterLe_7179(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_7180","instance":7180,"id":193851,"goal":"lemma SeqMemberAppend_7180(t: seq, u: seq)\n ensures x in t + u <==> x in t || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_7181","instance":7181,"id":193852,"goal":"lemma SeqAppendLen_7181(zs: seq, s: seq)\n ensures |zs + s| == |zs| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_7182","instance":7182,"id":193853,"goal":"lemma SeqAppendNil_7182(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_7183","instance":7183,"id":193854,"goal":"lemma SeqNilAppend_7183(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_7184","instance":7184,"id":193855,"goal":"lemma SeqAppendAssoc_7184(u: seq, s: seq, zs: seq)\n ensures (u + s) + zs == u + (s + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_7185","instance":7185,"id":193856,"goal":"lemma SeqTakeDrop_7185(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_7186","instance":7186,"id":193857,"goal":"lemma SeqReverseLen_7186(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_7187","instance":7187,"id":193858,"goal":"lemma SeqReverseIdem_7187(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_7188","instance":7188,"id":193859,"goal":"lemma SeqMapLen_7188(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_7189","instance":7189,"id":193860,"goal":"lemma SeqFilterLe_7189(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_7190","instance":7190,"id":193861,"goal":"lemma SeqMemberAppend_7190(u: seq, xs: seq)\n ensures x in u + xs <==> x in u || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_7191","instance":7191,"id":193862,"goal":"lemma SeqAppendLen_7191(u: seq, xs: seq)\n ensures |u + xs| == |u| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_7192","instance":7192,"id":193863,"goal":"lemma SeqAppendNil_7192(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_7193","instance":7193,"id":193864,"goal":"lemma SeqNilAppend_7193(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_7194","instance":7194,"id":193865,"goal":"lemma SeqAppendAssoc_7194(u: seq, xs: seq, t: seq)\n ensures (u + xs) + t == u + (xs + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_7195","instance":7195,"id":193866,"goal":"lemma SeqTakeDrop_7195(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_7196","instance":7196,"id":193867,"goal":"lemma SeqReverseLen_7196(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_7197","instance":7197,"id":193868,"goal":"lemma SeqReverseIdem_7197(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_7198","instance":7198,"id":193869,"goal":"lemma SeqMapLen_7198(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_7199","instance":7199,"id":193870,"goal":"lemma SeqFilterLe_7199(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_7200","instance":7200,"id":193871,"goal":"lemma SeqMemberAppend_7200(t: seq, xs: seq)\n ensures x in t + xs <==> x in t || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_7201","instance":7201,"id":193872,"goal":"lemma SeqAppendLen_7201(zs: seq, ys: seq)\n ensures |zs + ys| == |zs| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_7202","instance":7202,"id":193873,"goal":"lemma SeqAppendNil_7202(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_7203","instance":7203,"id":193874,"goal":"lemma SeqNilAppend_7203(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_7204","instance":7204,"id":193875,"goal":"lemma SeqAppendAssoc_7204(u: seq, s: seq, xs: seq)\n ensures (u + s) + xs == u + (s + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_7205","instance":7205,"id":193876,"goal":"lemma SeqTakeDrop_7205(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_7206","instance":7206,"id":193877,"goal":"lemma SeqReverseLen_7206(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_7207","instance":7207,"id":193878,"goal":"lemma SeqReverseIdem_7207(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_7208","instance":7208,"id":193879,"goal":"lemma SeqMapLen_7208(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_7209","instance":7209,"id":193880,"goal":"lemma SeqFilterLe_7209(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_7210","instance":7210,"id":193881,"goal":"lemma SeqMemberAppend_7210(zs: seq, ys: seq)\n ensures x in zs + ys <==> x in zs || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_7211","instance":7211,"id":193882,"goal":"lemma SeqAppendLen_7211(zs: seq, s: seq)\n ensures |zs + s| == |zs| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_7212","instance":7212,"id":193883,"goal":"lemma SeqAppendNil_7212(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_7213","instance":7213,"id":193884,"goal":"lemma SeqNilAppend_7213(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_7214","instance":7214,"id":193885,"goal":"lemma SeqAppendAssoc_7214(t: seq, xs: seq, u: seq)\n ensures (t + xs) + u == t + (xs + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_7215","instance":7215,"id":193886,"goal":"lemma SeqTakeDrop_7215(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_7216","instance":7216,"id":193887,"goal":"lemma SeqReverseLen_7216(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_7217","instance":7217,"id":193888,"goal":"lemma SeqReverseIdem_7217(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_7218","instance":7218,"id":193889,"goal":"lemma SeqMapLen_7218(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_7219","instance":7219,"id":193890,"goal":"lemma SeqFilterLe_7219(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_7220","instance":7220,"id":193891,"goal":"lemma SeqMemberAppend_7220(zs: seq, u: seq)\n ensures x in zs + u <==> x in zs || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_7221","instance":7221,"id":193892,"goal":"lemma SeqAppendLen_7221(ys: seq, t: seq)\n ensures |ys + t| == |ys| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_7222","instance":7222,"id":193893,"goal":"lemma SeqAppendNil_7222(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_7223","instance":7223,"id":193894,"goal":"lemma SeqNilAppend_7223(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_7224","instance":7224,"id":193895,"goal":"lemma SeqAppendAssoc_7224(t: seq, s: seq, xs: seq)\n ensures (t + s) + xs == t + (s + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_7225","instance":7225,"id":193896,"goal":"lemma SeqTakeDrop_7225(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_7226","instance":7226,"id":193897,"goal":"lemma SeqReverseLen_7226(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_7227","instance":7227,"id":193898,"goal":"lemma SeqReverseIdem_7227(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_7228","instance":7228,"id":193899,"goal":"lemma SeqMapLen_7228(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_7229","instance":7229,"id":193900,"goal":"lemma SeqFilterLe_7229(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_7230","instance":7230,"id":193901,"goal":"lemma SeqMemberAppend_7230(ys: seq, s: seq)\n ensures x in ys + s <==> x in ys || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_7231","instance":7231,"id":193902,"goal":"lemma SeqAppendLen_7231(xs: seq, t: seq)\n ensures |xs + t| == |xs| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_7232","instance":7232,"id":193903,"goal":"lemma SeqAppendNil_7232(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_7233","instance":7233,"id":193904,"goal":"lemma SeqNilAppend_7233(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_7234","instance":7234,"id":193905,"goal":"lemma SeqAppendAssoc_7234(xs: seq, zs: seq, ys: seq)\n ensures (xs + zs) + ys == xs + (zs + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_7235","instance":7235,"id":193906,"goal":"lemma SeqTakeDrop_7235(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_7236","instance":7236,"id":193907,"goal":"lemma SeqReverseLen_7236(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_7237","instance":7237,"id":193908,"goal":"lemma SeqReverseIdem_7237(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_7238","instance":7238,"id":193909,"goal":"lemma SeqMapLen_7238(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_7239","instance":7239,"id":193910,"goal":"lemma SeqFilterLe_7239(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_7240","instance":7240,"id":193911,"goal":"lemma SeqMemberAppend_7240(t: seq, ys: seq)\n ensures x in t + ys <==> x in t || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_7241","instance":7241,"id":193912,"goal":"lemma SeqAppendLen_7241(xs: seq, zs: seq)\n ensures |xs + zs| == |xs| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_7242","instance":7242,"id":193913,"goal":"lemma SeqAppendNil_7242(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_7243","instance":7243,"id":193914,"goal":"lemma SeqNilAppend_7243(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_7244","instance":7244,"id":193915,"goal":"lemma SeqAppendAssoc_7244(ys: seq, t: seq, s: seq)\n ensures (ys + t) + s == ys + (t + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_7245","instance":7245,"id":193916,"goal":"lemma SeqTakeDrop_7245(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_7246","instance":7246,"id":193917,"goal":"lemma SeqReverseLen_7246(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_7247","instance":7247,"id":193918,"goal":"lemma SeqReverseIdem_7247(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_7248","instance":7248,"id":193919,"goal":"lemma SeqMapLen_7248(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_7249","instance":7249,"id":193920,"goal":"lemma SeqFilterLe_7249(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_7250","instance":7250,"id":193921,"goal":"lemma SeqMemberAppend_7250(zs: seq, ys: seq)\n ensures x in zs + ys <==> x in zs || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_7251","instance":7251,"id":193922,"goal":"lemma SeqAppendLen_7251(zs: seq, xs: seq)\n ensures |zs + xs| == |zs| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_7252","instance":7252,"id":193923,"goal":"lemma SeqAppendNil_7252(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_7253","instance":7253,"id":193924,"goal":"lemma SeqNilAppend_7253(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_7254","instance":7254,"id":193925,"goal":"lemma SeqAppendAssoc_7254(zs: seq, t: seq, xs: seq)\n ensures (zs + t) + xs == zs + (t + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_7255","instance":7255,"id":193926,"goal":"lemma SeqTakeDrop_7255(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_7256","instance":7256,"id":193927,"goal":"lemma SeqReverseLen_7256(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_7257","instance":7257,"id":193928,"goal":"lemma SeqReverseIdem_7257(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_7258","instance":7258,"id":193929,"goal":"lemma SeqMapLen_7258(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_7259","instance":7259,"id":193930,"goal":"lemma SeqFilterLe_7259(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_7260","instance":7260,"id":193931,"goal":"lemma SeqMemberAppend_7260(ys: seq, t: seq)\n ensures x in ys + t <==> x in ys || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_7261","instance":7261,"id":193932,"goal":"lemma SeqAppendLen_7261(s: seq, t: seq)\n ensures |s + t| == |s| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_7262","instance":7262,"id":193933,"goal":"lemma SeqAppendNil_7262(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_7263","instance":7263,"id":193934,"goal":"lemma SeqNilAppend_7263(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_7264","instance":7264,"id":193935,"goal":"lemma SeqAppendAssoc_7264(s: seq, zs: seq, ys: seq)\n ensures (s + zs) + ys == s + (zs + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_7265","instance":7265,"id":193936,"goal":"lemma SeqTakeDrop_7265(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_7266","instance":7266,"id":193937,"goal":"lemma SeqReverseLen_7266(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_7267","instance":7267,"id":193938,"goal":"lemma SeqReverseIdem_7267(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_7268","instance":7268,"id":193939,"goal":"lemma SeqMapLen_7268(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_7269","instance":7269,"id":193940,"goal":"lemma SeqFilterLe_7269(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_7270","instance":7270,"id":193941,"goal":"lemma SeqMemberAppend_7270(s: seq, t: seq)\n ensures x in s + t <==> x in s || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_7271","instance":7271,"id":193942,"goal":"lemma SeqAppendLen_7271(xs: seq, t: seq)\n ensures |xs + t| == |xs| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_7272","instance":7272,"id":193943,"goal":"lemma SeqAppendNil_7272(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_7273","instance":7273,"id":193944,"goal":"lemma SeqNilAppend_7273(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_7274","instance":7274,"id":193945,"goal":"lemma SeqAppendAssoc_7274(xs: seq, s: seq, ys: seq)\n ensures (xs + s) + ys == xs + (s + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_7275","instance":7275,"id":193946,"goal":"lemma SeqTakeDrop_7275(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_7276","instance":7276,"id":193947,"goal":"lemma SeqReverseLen_7276(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_7277","instance":7277,"id":193948,"goal":"lemma SeqReverseIdem_7277(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_7278","instance":7278,"id":193949,"goal":"lemma SeqMapLen_7278(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_7279","instance":7279,"id":193950,"goal":"lemma SeqFilterLe_7279(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_7280","instance":7280,"id":193951,"goal":"lemma SeqMemberAppend_7280(ys: seq, s: seq)\n ensures x in ys + s <==> x in ys || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_7281","instance":7281,"id":193952,"goal":"lemma SeqAppendLen_7281(ys: seq, xs: seq)\n ensures |ys + xs| == |ys| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_7282","instance":7282,"id":193953,"goal":"lemma SeqAppendNil_7282(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_7283","instance":7283,"id":193954,"goal":"lemma SeqNilAppend_7283(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_7284","instance":7284,"id":193955,"goal":"lemma SeqAppendAssoc_7284(t: seq, ys: seq, xs: seq)\n ensures (t + ys) + xs == t + (ys + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_7285","instance":7285,"id":193956,"goal":"lemma SeqTakeDrop_7285(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_7286","instance":7286,"id":193957,"goal":"lemma SeqReverseLen_7286(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_7287","instance":7287,"id":193958,"goal":"lemma SeqReverseIdem_7287(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_7288","instance":7288,"id":193959,"goal":"lemma SeqMapLen_7288(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_7289","instance":7289,"id":193960,"goal":"lemma SeqFilterLe_7289(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_7290","instance":7290,"id":193961,"goal":"lemma SeqMemberAppend_7290(ys: seq, u: seq)\n ensures x in ys + u <==> x in ys || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_7291","instance":7291,"id":193962,"goal":"lemma SeqAppendLen_7291(s: seq, xs: seq)\n ensures |s + xs| == |s| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_7292","instance":7292,"id":193963,"goal":"lemma SeqAppendNil_7292(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_7293","instance":7293,"id":193964,"goal":"lemma SeqNilAppend_7293(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_7294","instance":7294,"id":193965,"goal":"lemma SeqAppendAssoc_7294(s: seq, xs: seq, ys: seq)\n ensures (s + xs) + ys == s + (xs + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_7295","instance":7295,"id":193966,"goal":"lemma SeqTakeDrop_7295(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_7296","instance":7296,"id":193967,"goal":"lemma SeqReverseLen_7296(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_7297","instance":7297,"id":193968,"goal":"lemma SeqReverseIdem_7297(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_7298","instance":7298,"id":193969,"goal":"lemma SeqMapLen_7298(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_7299","instance":7299,"id":193970,"goal":"lemma SeqFilterLe_7299(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_7300","instance":7300,"id":193971,"goal":"lemma SeqMemberAppend_7300(s: seq, zs: seq)\n ensures x in s + zs <==> x in s || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_7301","instance":7301,"id":193972,"goal":"lemma SeqAppendLen_7301(u: seq, zs: seq)\n ensures |u + zs| == |u| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_7302","instance":7302,"id":193973,"goal":"lemma SeqAppendNil_7302(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_7303","instance":7303,"id":193974,"goal":"lemma SeqNilAppend_7303(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_7304","instance":7304,"id":193975,"goal":"lemma SeqAppendAssoc_7304(ys: seq, s: seq, u: seq)\n ensures (ys + s) + u == ys + (s + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_7305","instance":7305,"id":193976,"goal":"lemma SeqTakeDrop_7305(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_7306","instance":7306,"id":193977,"goal":"lemma SeqReverseLen_7306(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_7307","instance":7307,"id":193978,"goal":"lemma SeqReverseIdem_7307(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_7308","instance":7308,"id":193979,"goal":"lemma SeqMapLen_7308(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_7309","instance":7309,"id":193980,"goal":"lemma SeqFilterLe_7309(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_7310","instance":7310,"id":193981,"goal":"lemma SeqMemberAppend_7310(zs: seq, s: seq)\n ensures x in zs + s <==> x in zs || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_7311","instance":7311,"id":193982,"goal":"lemma SeqAppendLen_7311(zs: seq, ys: seq)\n ensures |zs + ys| == |zs| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_7312","instance":7312,"id":193983,"goal":"lemma SeqAppendNil_7312(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_7313","instance":7313,"id":193984,"goal":"lemma SeqNilAppend_7313(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_7314","instance":7314,"id":193985,"goal":"lemma SeqAppendAssoc_7314(s: seq, xs: seq, zs: seq)\n ensures (s + xs) + zs == s + (xs + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_7315","instance":7315,"id":193986,"goal":"lemma SeqTakeDrop_7315(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_7316","instance":7316,"id":193987,"goal":"lemma SeqReverseLen_7316(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_7317","instance":7317,"id":193988,"goal":"lemma SeqReverseIdem_7317(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_7318","instance":7318,"id":193989,"goal":"lemma SeqMapLen_7318(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_7319","instance":7319,"id":193990,"goal":"lemma SeqFilterLe_7319(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_7320","instance":7320,"id":193991,"goal":"lemma SeqMemberAppend_7320(zs: seq, t: seq)\n ensures x in zs + t <==> x in zs || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_7321","instance":7321,"id":193992,"goal":"lemma SeqAppendLen_7321(xs: seq, t: seq)\n ensures |xs + t| == |xs| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_7322","instance":7322,"id":193993,"goal":"lemma SeqAppendNil_7322(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_7323","instance":7323,"id":193994,"goal":"lemma SeqNilAppend_7323(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_7324","instance":7324,"id":193995,"goal":"lemma SeqAppendAssoc_7324(ys: seq, zs: seq, u: seq)\n ensures (ys + zs) + u == ys + (zs + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_7325","instance":7325,"id":193996,"goal":"lemma SeqTakeDrop_7325(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_7326","instance":7326,"id":193997,"goal":"lemma SeqReverseLen_7326(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_7327","instance":7327,"id":193998,"goal":"lemma SeqReverseIdem_7327(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_7328","instance":7328,"id":193999,"goal":"lemma SeqMapLen_7328(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_7329","instance":7329,"id":194000,"goal":"lemma SeqFilterLe_7329(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_7330","instance":7330,"id":194001,"goal":"lemma SeqMemberAppend_7330(u: seq, t: seq)\n ensures x in u + t <==> x in u || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_7331","instance":7331,"id":194002,"goal":"lemma SeqAppendLen_7331(ys: seq, zs: seq)\n ensures |ys + zs| == |ys| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_7332","instance":7332,"id":194003,"goal":"lemma SeqAppendNil_7332(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_7333","instance":7333,"id":194004,"goal":"lemma SeqNilAppend_7333(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_7334","instance":7334,"id":194005,"goal":"lemma SeqAppendAssoc_7334(ys: seq, zs: seq, xs: seq)\n ensures (ys + zs) + xs == ys + (zs + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_7335","instance":7335,"id":194006,"goal":"lemma SeqTakeDrop_7335(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_7336","instance":7336,"id":194007,"goal":"lemma SeqReverseLen_7336(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_7337","instance":7337,"id":194008,"goal":"lemma SeqReverseIdem_7337(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_7338","instance":7338,"id":194009,"goal":"lemma SeqMapLen_7338(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_7339","instance":7339,"id":194010,"goal":"lemma SeqFilterLe_7339(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_7340","instance":7340,"id":194011,"goal":"lemma SeqMemberAppend_7340(zs: seq, s: seq)\n ensures x in zs + s <==> x in zs || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_7341","instance":7341,"id":194012,"goal":"lemma SeqAppendLen_7341(t: seq, u: seq)\n ensures |t + u| == |t| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_7342","instance":7342,"id":194013,"goal":"lemma SeqAppendNil_7342(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_7343","instance":7343,"id":194014,"goal":"lemma SeqNilAppend_7343(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_7344","instance":7344,"id":194015,"goal":"lemma SeqAppendAssoc_7344(ys: seq, zs: seq, u: seq)\n ensures (ys + zs) + u == ys + (zs + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_7345","instance":7345,"id":194016,"goal":"lemma SeqTakeDrop_7345(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_7346","instance":7346,"id":194017,"goal":"lemma SeqReverseLen_7346(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_7347","instance":7347,"id":194018,"goal":"lemma SeqReverseIdem_7347(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_7348","instance":7348,"id":194019,"goal":"lemma SeqMapLen_7348(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_7349","instance":7349,"id":194020,"goal":"lemma SeqFilterLe_7349(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_7350","instance":7350,"id":194021,"goal":"lemma SeqMemberAppend_7350(s: seq, zs: seq)\n ensures x in s + zs <==> x in s || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_7351","instance":7351,"id":194022,"goal":"lemma SeqAppendLen_7351(zs: seq, xs: seq)\n ensures |zs + xs| == |zs| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_7352","instance":7352,"id":194023,"goal":"lemma SeqAppendNil_7352(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_7353","instance":7353,"id":194024,"goal":"lemma SeqNilAppend_7353(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_7354","instance":7354,"id":194025,"goal":"lemma SeqAppendAssoc_7354(ys: seq, s: seq, u: seq)\n ensures (ys + s) + u == ys + (s + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_7355","instance":7355,"id":194026,"goal":"lemma SeqTakeDrop_7355(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_7356","instance":7356,"id":194027,"goal":"lemma SeqReverseLen_7356(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_7357","instance":7357,"id":194028,"goal":"lemma SeqReverseIdem_7357(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_7358","instance":7358,"id":194029,"goal":"lemma SeqMapLen_7358(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_7359","instance":7359,"id":194030,"goal":"lemma SeqFilterLe_7359(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_7360","instance":7360,"id":194031,"goal":"lemma SeqMemberAppend_7360(t: seq, ys: seq)\n ensures x in t + ys <==> x in t || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_7361","instance":7361,"id":194032,"goal":"lemma SeqAppendLen_7361(t: seq, ys: seq)\n ensures |t + ys| == |t| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_7362","instance":7362,"id":194033,"goal":"lemma SeqAppendNil_7362(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_7363","instance":7363,"id":194034,"goal":"lemma SeqNilAppend_7363(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_7364","instance":7364,"id":194035,"goal":"lemma SeqAppendAssoc_7364(s: seq, xs: seq, u: seq)\n ensures (s + xs) + u == s + (xs + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_7365","instance":7365,"id":194036,"goal":"lemma SeqTakeDrop_7365(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_7366","instance":7366,"id":194037,"goal":"lemma SeqReverseLen_7366(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_7367","instance":7367,"id":194038,"goal":"lemma SeqReverseIdem_7367(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_7368","instance":7368,"id":194039,"goal":"lemma SeqMapLen_7368(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_7369","instance":7369,"id":194040,"goal":"lemma SeqFilterLe_7369(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_7370","instance":7370,"id":194041,"goal":"lemma SeqMemberAppend_7370(s: seq, u: seq)\n ensures x in s + u <==> x in s || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_7371","instance":7371,"id":194042,"goal":"lemma SeqAppendLen_7371(t: seq, zs: seq)\n ensures |t + zs| == |t| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_7372","instance":7372,"id":194043,"goal":"lemma SeqAppendNil_7372(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_7373","instance":7373,"id":194044,"goal":"lemma SeqNilAppend_7373(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_7374","instance":7374,"id":194045,"goal":"lemma SeqAppendAssoc_7374(u: seq, ys: seq, t: seq)\n ensures (u + ys) + t == u + (ys + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_7375","instance":7375,"id":194046,"goal":"lemma SeqTakeDrop_7375(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_7376","instance":7376,"id":194047,"goal":"lemma SeqReverseLen_7376(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_7377","instance":7377,"id":194048,"goal":"lemma SeqReverseIdem_7377(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_7378","instance":7378,"id":194049,"goal":"lemma SeqMapLen_7378(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_7379","instance":7379,"id":194050,"goal":"lemma SeqFilterLe_7379(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_7380","instance":7380,"id":194051,"goal":"lemma SeqMemberAppend_7380(zs: seq, xs: seq)\n ensures x in zs + xs <==> x in zs || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_7381","instance":7381,"id":194052,"goal":"lemma SeqAppendLen_7381(u: seq, t: seq)\n ensures |u + t| == |u| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_7382","instance":7382,"id":194053,"goal":"lemma SeqAppendNil_7382(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_7383","instance":7383,"id":194054,"goal":"lemma SeqNilAppend_7383(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_7384","instance":7384,"id":194055,"goal":"lemma SeqAppendAssoc_7384(s: seq, xs: seq, t: seq)\n ensures (s + xs) + t == s + (xs + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_7385","instance":7385,"id":194056,"goal":"lemma SeqTakeDrop_7385(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_7386","instance":7386,"id":194057,"goal":"lemma SeqReverseLen_7386(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_7387","instance":7387,"id":194058,"goal":"lemma SeqReverseIdem_7387(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_7388","instance":7388,"id":194059,"goal":"lemma SeqMapLen_7388(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_7389","instance":7389,"id":194060,"goal":"lemma SeqFilterLe_7389(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_7390","instance":7390,"id":194061,"goal":"lemma SeqMemberAppend_7390(u: seq, ys: seq)\n ensures x in u + ys <==> x in u || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_7391","instance":7391,"id":194062,"goal":"lemma SeqAppendLen_7391(xs: seq, s: seq)\n ensures |xs + s| == |xs| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_7392","instance":7392,"id":194063,"goal":"lemma SeqAppendNil_7392(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_7393","instance":7393,"id":194064,"goal":"lemma SeqNilAppend_7393(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_7394","instance":7394,"id":194065,"goal":"lemma SeqAppendAssoc_7394(u: seq, s: seq, xs: seq)\n ensures (u + s) + xs == u + (s + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_7395","instance":7395,"id":194066,"goal":"lemma SeqTakeDrop_7395(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_7396","instance":7396,"id":194067,"goal":"lemma SeqReverseLen_7396(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_7397","instance":7397,"id":194068,"goal":"lemma SeqReverseIdem_7397(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_7398","instance":7398,"id":194069,"goal":"lemma SeqMapLen_7398(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_7399","instance":7399,"id":194070,"goal":"lemma SeqFilterLe_7399(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_7400","instance":7400,"id":194071,"goal":"lemma SeqMemberAppend_7400(u: seq, zs: seq)\n ensures x in u + zs <==> x in u || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_7401","instance":7401,"id":194072,"goal":"lemma SeqAppendLen_7401(ys: seq, t: seq)\n ensures |ys + t| == |ys| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_7402","instance":7402,"id":194073,"goal":"lemma SeqAppendNil_7402(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_7403","instance":7403,"id":194074,"goal":"lemma SeqNilAppend_7403(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_7404","instance":7404,"id":194075,"goal":"lemma SeqAppendAssoc_7404(zs: seq, ys: seq, xs: seq)\n ensures (zs + ys) + xs == zs + (ys + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_7405","instance":7405,"id":194076,"goal":"lemma SeqTakeDrop_7405(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_7406","instance":7406,"id":194077,"goal":"lemma SeqReverseLen_7406(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_7407","instance":7407,"id":194078,"goal":"lemma SeqReverseIdem_7407(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_7408","instance":7408,"id":194079,"goal":"lemma SeqMapLen_7408(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_7409","instance":7409,"id":194080,"goal":"lemma SeqFilterLe_7409(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_7410","instance":7410,"id":194081,"goal":"lemma SeqMemberAppend_7410(zs: seq, u: seq)\n ensures x in zs + u <==> x in zs || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_7411","instance":7411,"id":194082,"goal":"lemma SeqAppendLen_7411(t: seq, u: seq)\n ensures |t + u| == |t| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_7412","instance":7412,"id":194083,"goal":"lemma SeqAppendNil_7412(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_7413","instance":7413,"id":194084,"goal":"lemma SeqNilAppend_7413(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_7414","instance":7414,"id":194085,"goal":"lemma SeqAppendAssoc_7414(t: seq, zs: seq, xs: seq)\n ensures (t + zs) + xs == t + (zs + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_7415","instance":7415,"id":194086,"goal":"lemma SeqTakeDrop_7415(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_7416","instance":7416,"id":194087,"goal":"lemma SeqReverseLen_7416(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_7417","instance":7417,"id":194088,"goal":"lemma SeqReverseIdem_7417(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_7418","instance":7418,"id":194089,"goal":"lemma SeqMapLen_7418(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_7419","instance":7419,"id":194090,"goal":"lemma SeqFilterLe_7419(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_7420","instance":7420,"id":194091,"goal":"lemma SeqMemberAppend_7420(u: seq, s: seq)\n ensures x in u + s <==> x in u || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_7421","instance":7421,"id":194092,"goal":"lemma SeqAppendLen_7421(s: seq, zs: seq)\n ensures |s + zs| == |s| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_7422","instance":7422,"id":194093,"goal":"lemma SeqAppendNil_7422(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_7423","instance":7423,"id":194094,"goal":"lemma SeqNilAppend_7423(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_7424","instance":7424,"id":194095,"goal":"lemma SeqAppendAssoc_7424(u: seq, xs: seq, ys: seq)\n ensures (u + xs) + ys == u + (xs + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_7425","instance":7425,"id":194096,"goal":"lemma SeqTakeDrop_7425(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_7426","instance":7426,"id":194097,"goal":"lemma SeqReverseLen_7426(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_7427","instance":7427,"id":194098,"goal":"lemma SeqReverseIdem_7427(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_7428","instance":7428,"id":194099,"goal":"lemma SeqMapLen_7428(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_7429","instance":7429,"id":194100,"goal":"lemma SeqFilterLe_7429(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_7430","instance":7430,"id":194101,"goal":"lemma SeqMemberAppend_7430(xs: seq, t: seq)\n ensures x in xs + t <==> x in xs || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_7431","instance":7431,"id":194102,"goal":"lemma SeqAppendLen_7431(ys: seq, zs: seq)\n ensures |ys + zs| == |ys| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_7432","instance":7432,"id":194103,"goal":"lemma SeqAppendNil_7432(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_7433","instance":7433,"id":194104,"goal":"lemma SeqNilAppend_7433(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_7434","instance":7434,"id":194105,"goal":"lemma SeqAppendAssoc_7434(u: seq, s: seq, t: seq)\n ensures (u + s) + t == u + (s + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_7435","instance":7435,"id":194106,"goal":"lemma SeqTakeDrop_7435(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_7436","instance":7436,"id":194107,"goal":"lemma SeqReverseLen_7436(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_7437","instance":7437,"id":194108,"goal":"lemma SeqReverseIdem_7437(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_7438","instance":7438,"id":194109,"goal":"lemma SeqMapLen_7438(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_7439","instance":7439,"id":194110,"goal":"lemma SeqFilterLe_7439(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_7440","instance":7440,"id":194111,"goal":"lemma SeqMemberAppend_7440(zs: seq, s: seq)\n ensures x in zs + s <==> x in zs || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_7441","instance":7441,"id":194112,"goal":"lemma SeqAppendLen_7441(xs: seq, s: seq)\n ensures |xs + s| == |xs| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_7442","instance":7442,"id":194113,"goal":"lemma SeqAppendNil_7442(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_7443","instance":7443,"id":194114,"goal":"lemma SeqNilAppend_7443(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_7444","instance":7444,"id":194115,"goal":"lemma SeqAppendAssoc_7444(u: seq, s: seq, zs: seq)\n ensures (u + s) + zs == u + (s + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_7445","instance":7445,"id":194116,"goal":"lemma SeqTakeDrop_7445(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_7446","instance":7446,"id":194117,"goal":"lemma SeqReverseLen_7446(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_7447","instance":7447,"id":194118,"goal":"lemma SeqReverseIdem_7447(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_7448","instance":7448,"id":194119,"goal":"lemma SeqMapLen_7448(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_7449","instance":7449,"id":194120,"goal":"lemma SeqFilterLe_7449(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_7450","instance":7450,"id":194121,"goal":"lemma SeqMemberAppend_7450(t: seq, s: seq)\n ensures x in t + s <==> x in t || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_7451","instance":7451,"id":194122,"goal":"lemma SeqAppendLen_7451(ys: seq, t: seq)\n ensures |ys + t| == |ys| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_7452","instance":7452,"id":194123,"goal":"lemma SeqAppendNil_7452(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_7453","instance":7453,"id":194124,"goal":"lemma SeqNilAppend_7453(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_7454","instance":7454,"id":194125,"goal":"lemma SeqAppendAssoc_7454(t: seq, u: seq, ys: seq)\n ensures (t + u) + ys == t + (u + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_7455","instance":7455,"id":194126,"goal":"lemma SeqTakeDrop_7455(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_7456","instance":7456,"id":194127,"goal":"lemma SeqReverseLen_7456(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_7457","instance":7457,"id":194128,"goal":"lemma SeqReverseIdem_7457(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_7458","instance":7458,"id":194129,"goal":"lemma SeqMapLen_7458(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_7459","instance":7459,"id":194130,"goal":"lemma SeqFilterLe_7459(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_7460","instance":7460,"id":194131,"goal":"lemma SeqMemberAppend_7460(zs: seq, t: seq)\n ensures x in zs + t <==> x in zs || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_7461","instance":7461,"id":194132,"goal":"lemma SeqAppendLen_7461(t: seq, s: seq)\n ensures |t + s| == |t| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_7462","instance":7462,"id":194133,"goal":"lemma SeqAppendNil_7462(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_7463","instance":7463,"id":194134,"goal":"lemma SeqNilAppend_7463(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_7464","instance":7464,"id":194135,"goal":"lemma SeqAppendAssoc_7464(zs: seq, t: seq, xs: seq)\n ensures (zs + t) + xs == zs + (t + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_7465","instance":7465,"id":194136,"goal":"lemma SeqTakeDrop_7465(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_7466","instance":7466,"id":194137,"goal":"lemma SeqReverseLen_7466(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_7467","instance":7467,"id":194138,"goal":"lemma SeqReverseIdem_7467(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_7468","instance":7468,"id":194139,"goal":"lemma SeqMapLen_7468(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_7469","instance":7469,"id":194140,"goal":"lemma SeqFilterLe_7469(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_7470","instance":7470,"id":194141,"goal":"lemma SeqMemberAppend_7470(ys: seq, xs: seq)\n ensures x in ys + xs <==> x in ys || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_7471","instance":7471,"id":194142,"goal":"lemma SeqAppendLen_7471(s: seq, xs: seq)\n ensures |s + xs| == |s| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_7472","instance":7472,"id":194143,"goal":"lemma SeqAppendNil_7472(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_7473","instance":7473,"id":194144,"goal":"lemma SeqNilAppend_7473(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_7474","instance":7474,"id":194145,"goal":"lemma SeqAppendAssoc_7474(ys: seq, s: seq, t: seq)\n ensures (ys + s) + t == ys + (s + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_7475","instance":7475,"id":194146,"goal":"lemma SeqTakeDrop_7475(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_7476","instance":7476,"id":194147,"goal":"lemma SeqReverseLen_7476(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_7477","instance":7477,"id":194148,"goal":"lemma SeqReverseIdem_7477(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_7478","instance":7478,"id":194149,"goal":"lemma SeqMapLen_7478(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_7479","instance":7479,"id":194150,"goal":"lemma SeqFilterLe_7479(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_7480","instance":7480,"id":194151,"goal":"lemma SeqMemberAppend_7480(u: seq, ys: seq)\n ensures x in u + ys <==> x in u || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_7481","instance":7481,"id":194152,"goal":"lemma SeqAppendLen_7481(s: seq, t: seq)\n ensures |s + t| == |s| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_7482","instance":7482,"id":194153,"goal":"lemma SeqAppendNil_7482(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_7483","instance":7483,"id":194154,"goal":"lemma SeqNilAppend_7483(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_7484","instance":7484,"id":194155,"goal":"lemma SeqAppendAssoc_7484(u: seq, zs: seq, s: seq)\n ensures (u + zs) + s == u + (zs + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_7485","instance":7485,"id":194156,"goal":"lemma SeqTakeDrop_7485(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_7486","instance":7486,"id":194157,"goal":"lemma SeqReverseLen_7486(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_7487","instance":7487,"id":194158,"goal":"lemma SeqReverseIdem_7487(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_7488","instance":7488,"id":194159,"goal":"lemma SeqMapLen_7488(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_7489","instance":7489,"id":194160,"goal":"lemma SeqFilterLe_7489(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_7490","instance":7490,"id":194161,"goal":"lemma SeqMemberAppend_7490(u: seq, ys: seq)\n ensures x in u + ys <==> x in u || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_7491","instance":7491,"id":194162,"goal":"lemma SeqAppendLen_7491(xs: seq, u: seq)\n ensures |xs + u| == |xs| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_7492","instance":7492,"id":194163,"goal":"lemma SeqAppendNil_7492(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_7493","instance":7493,"id":194164,"goal":"lemma SeqNilAppend_7493(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_7494","instance":7494,"id":194165,"goal":"lemma SeqAppendAssoc_7494(xs: seq, zs: seq, t: seq)\n ensures (xs + zs) + t == xs + (zs + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_7495","instance":7495,"id":194166,"goal":"lemma SeqTakeDrop_7495(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_7496","instance":7496,"id":194167,"goal":"lemma SeqReverseLen_7496(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_7497","instance":7497,"id":194168,"goal":"lemma SeqReverseIdem_7497(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_7498","instance":7498,"id":194169,"goal":"lemma SeqMapLen_7498(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_7499","instance":7499,"id":194170,"goal":"lemma SeqFilterLe_7499(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_7500","instance":7500,"id":194171,"goal":"lemma SeqMemberAppend_7500(xs: seq, u: seq)\n ensures x in xs + u <==> x in xs || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_7501","instance":7501,"id":194172,"goal":"lemma SeqAppendLen_7501(zs: seq, ys: seq)\n ensures |zs + ys| == |zs| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_7502","instance":7502,"id":194173,"goal":"lemma SeqAppendNil_7502(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_7503","instance":7503,"id":194174,"goal":"lemma SeqNilAppend_7503(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_7504","instance":7504,"id":194175,"goal":"lemma SeqAppendAssoc_7504(t: seq, s: seq, xs: seq)\n ensures (t + s) + xs == t + (s + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_7505","instance":7505,"id":194176,"goal":"lemma SeqTakeDrop_7505(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_7506","instance":7506,"id":194177,"goal":"lemma SeqReverseLen_7506(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_7507","instance":7507,"id":194178,"goal":"lemma SeqReverseIdem_7507(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_7508","instance":7508,"id":194179,"goal":"lemma SeqMapLen_7508(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_7509","instance":7509,"id":194180,"goal":"lemma SeqFilterLe_7509(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_7510","instance":7510,"id":194181,"goal":"lemma SeqMemberAppend_7510(s: seq, u: seq)\n ensures x in s + u <==> x in s || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_7511","instance":7511,"id":194182,"goal":"lemma SeqAppendLen_7511(ys: seq, xs: seq)\n ensures |ys + xs| == |ys| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_7512","instance":7512,"id":194183,"goal":"lemma SeqAppendNil_7512(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_7513","instance":7513,"id":194184,"goal":"lemma SeqNilAppend_7513(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_7514","instance":7514,"id":194185,"goal":"lemma SeqAppendAssoc_7514(s: seq, u: seq, t: seq)\n ensures (s + u) + t == s + (u + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_7515","instance":7515,"id":194186,"goal":"lemma SeqTakeDrop_7515(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_7516","instance":7516,"id":194187,"goal":"lemma SeqReverseLen_7516(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_7517","instance":7517,"id":194188,"goal":"lemma SeqReverseIdem_7517(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_7518","instance":7518,"id":194189,"goal":"lemma SeqMapLen_7518(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_7519","instance":7519,"id":194190,"goal":"lemma SeqFilterLe_7519(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_7520","instance":7520,"id":194191,"goal":"lemma SeqMemberAppend_7520(xs: seq, t: seq)\n ensures x in xs + t <==> x in xs || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_7521","instance":7521,"id":194192,"goal":"lemma SeqAppendLen_7521(u: seq, t: seq)\n ensures |u + t| == |u| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_7522","instance":7522,"id":194193,"goal":"lemma SeqAppendNil_7522(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_7523","instance":7523,"id":194194,"goal":"lemma SeqNilAppend_7523(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_7524","instance":7524,"id":194195,"goal":"lemma SeqAppendAssoc_7524(xs: seq, u: seq, t: seq)\n ensures (xs + u) + t == xs + (u + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_7525","instance":7525,"id":194196,"goal":"lemma SeqTakeDrop_7525(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_7526","instance":7526,"id":194197,"goal":"lemma SeqReverseLen_7526(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_7527","instance":7527,"id":194198,"goal":"lemma SeqReverseIdem_7527(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_7528","instance":7528,"id":194199,"goal":"lemma SeqMapLen_7528(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_7529","instance":7529,"id":194200,"goal":"lemma SeqFilterLe_7529(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_7530","instance":7530,"id":194201,"goal":"lemma SeqMemberAppend_7530(ys: seq, zs: seq)\n ensures x in ys + zs <==> x in ys || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_7531","instance":7531,"id":194202,"goal":"lemma SeqAppendLen_7531(ys: seq, t: seq)\n ensures |ys + t| == |ys| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_7532","instance":7532,"id":194203,"goal":"lemma SeqAppendNil_7532(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_7533","instance":7533,"id":194204,"goal":"lemma SeqNilAppend_7533(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_7534","instance":7534,"id":194205,"goal":"lemma SeqAppendAssoc_7534(t: seq, zs: seq, u: seq)\n ensures (t + zs) + u == t + (zs + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_7535","instance":7535,"id":194206,"goal":"lemma SeqTakeDrop_7535(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_7536","instance":7536,"id":194207,"goal":"lemma SeqReverseLen_7536(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_7537","instance":7537,"id":194208,"goal":"lemma SeqReverseIdem_7537(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_7538","instance":7538,"id":194209,"goal":"lemma SeqMapLen_7538(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_7539","instance":7539,"id":194210,"goal":"lemma SeqFilterLe_7539(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_7540","instance":7540,"id":194211,"goal":"lemma SeqMemberAppend_7540(ys: seq, u: seq)\n ensures x in ys + u <==> x in ys || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_7541","instance":7541,"id":194212,"goal":"lemma SeqAppendLen_7541(s: seq, zs: seq)\n ensures |s + zs| == |s| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_7542","instance":7542,"id":194213,"goal":"lemma SeqAppendNil_7542(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_7543","instance":7543,"id":194214,"goal":"lemma SeqNilAppend_7543(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_7544","instance":7544,"id":194215,"goal":"lemma SeqAppendAssoc_7544(u: seq, t: seq, xs: seq)\n ensures (u + t) + xs == u + (t + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_7545","instance":7545,"id":194216,"goal":"lemma SeqTakeDrop_7545(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_7546","instance":7546,"id":194217,"goal":"lemma SeqReverseLen_7546(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_7547","instance":7547,"id":194218,"goal":"lemma SeqReverseIdem_7547(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_7548","instance":7548,"id":194219,"goal":"lemma SeqMapLen_7548(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_7549","instance":7549,"id":194220,"goal":"lemma SeqFilterLe_7549(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_7550","instance":7550,"id":194221,"goal":"lemma SeqMemberAppend_7550(t: seq, xs: seq)\n ensures x in t + xs <==> x in t || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_7551","instance":7551,"id":194222,"goal":"lemma SeqAppendLen_7551(xs: seq, u: seq)\n ensures |xs + u| == |xs| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_7552","instance":7552,"id":194223,"goal":"lemma SeqAppendNil_7552(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_7553","instance":7553,"id":194224,"goal":"lemma SeqNilAppend_7553(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_7554","instance":7554,"id":194225,"goal":"lemma SeqAppendAssoc_7554(t: seq, zs: seq, xs: seq)\n ensures (t + zs) + xs == t + (zs + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_7555","instance":7555,"id":194226,"goal":"lemma SeqTakeDrop_7555(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_7556","instance":7556,"id":194227,"goal":"lemma SeqReverseLen_7556(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_7557","instance":7557,"id":194228,"goal":"lemma SeqReverseIdem_7557(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_7558","instance":7558,"id":194229,"goal":"lemma SeqMapLen_7558(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_7559","instance":7559,"id":194230,"goal":"lemma SeqFilterLe_7559(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_7560","instance":7560,"id":194231,"goal":"lemma SeqMemberAppend_7560(ys: seq, u: seq)\n ensures x in ys + u <==> x in ys || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_7561","instance":7561,"id":194232,"goal":"lemma SeqAppendLen_7561(zs: seq, xs: seq)\n ensures |zs + xs| == |zs| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_7562","instance":7562,"id":194233,"goal":"lemma SeqAppendNil_7562(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_7563","instance":7563,"id":194234,"goal":"lemma SeqNilAppend_7563(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_7564","instance":7564,"id":194235,"goal":"lemma SeqAppendAssoc_7564(t: seq, zs: seq, ys: seq)\n ensures (t + zs) + ys == t + (zs + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_7565","instance":7565,"id":194236,"goal":"lemma SeqTakeDrop_7565(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_7566","instance":7566,"id":194237,"goal":"lemma SeqReverseLen_7566(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_7567","instance":7567,"id":194238,"goal":"lemma SeqReverseIdem_7567(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_7568","instance":7568,"id":194239,"goal":"lemma SeqMapLen_7568(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_7569","instance":7569,"id":194240,"goal":"lemma SeqFilterLe_7569(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_7570","instance":7570,"id":194241,"goal":"lemma SeqMemberAppend_7570(zs: seq, s: seq)\n ensures x in zs + s <==> x in zs || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_7571","instance":7571,"id":194242,"goal":"lemma SeqAppendLen_7571(t: seq, xs: seq)\n ensures |t + xs| == |t| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_7572","instance":7572,"id":194243,"goal":"lemma SeqAppendNil_7572(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_7573","instance":7573,"id":194244,"goal":"lemma SeqNilAppend_7573(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_7574","instance":7574,"id":194245,"goal":"lemma SeqAppendAssoc_7574(t: seq, s: seq, ys: seq)\n ensures (t + s) + ys == t + (s + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_7575","instance":7575,"id":194246,"goal":"lemma SeqTakeDrop_7575(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_7576","instance":7576,"id":194247,"goal":"lemma SeqReverseLen_7576(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_7577","instance":7577,"id":194248,"goal":"lemma SeqReverseIdem_7577(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_7578","instance":7578,"id":194249,"goal":"lemma SeqMapLen_7578(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_7579","instance":7579,"id":194250,"goal":"lemma SeqFilterLe_7579(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_7580","instance":7580,"id":194251,"goal":"lemma SeqMemberAppend_7580(s: seq, u: seq)\n ensures x in s + u <==> x in s || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_7581","instance":7581,"id":194252,"goal":"lemma SeqAppendLen_7581(xs: seq, u: seq)\n ensures |xs + u| == |xs| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_7582","instance":7582,"id":194253,"goal":"lemma SeqAppendNil_7582(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_7583","instance":7583,"id":194254,"goal":"lemma SeqNilAppend_7583(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_7584","instance":7584,"id":194255,"goal":"lemma SeqAppendAssoc_7584(xs: seq, t: seq, s: seq)\n ensures (xs + t) + s == xs + (t + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_7585","instance":7585,"id":194256,"goal":"lemma SeqTakeDrop_7585(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_7586","instance":7586,"id":194257,"goal":"lemma SeqReverseLen_7586(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_7587","instance":7587,"id":194258,"goal":"lemma SeqReverseIdem_7587(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_7588","instance":7588,"id":194259,"goal":"lemma SeqMapLen_7588(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_7589","instance":7589,"id":194260,"goal":"lemma SeqFilterLe_7589(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_7590","instance":7590,"id":194261,"goal":"lemma SeqMemberAppend_7590(s: seq, t: seq)\n ensures x in s + t <==> x in s || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_7591","instance":7591,"id":194262,"goal":"lemma SeqAppendLen_7591(ys: seq, u: seq)\n ensures |ys + u| == |ys| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_7592","instance":7592,"id":194263,"goal":"lemma SeqAppendNil_7592(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_7593","instance":7593,"id":194264,"goal":"lemma SeqNilAppend_7593(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_7594","instance":7594,"id":194265,"goal":"lemma SeqAppendAssoc_7594(ys: seq, zs: seq, s: seq)\n ensures (ys + zs) + s == ys + (zs + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_7595","instance":7595,"id":194266,"goal":"lemma SeqTakeDrop_7595(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_7596","instance":7596,"id":194267,"goal":"lemma SeqReverseLen_7596(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_7597","instance":7597,"id":194268,"goal":"lemma SeqReverseIdem_7597(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_7598","instance":7598,"id":194269,"goal":"lemma SeqMapLen_7598(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_7599","instance":7599,"id":194270,"goal":"lemma SeqFilterLe_7599(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_7600","instance":7600,"id":194271,"goal":"lemma SeqMemberAppend_7600(zs: seq, xs: seq)\n ensures x in zs + xs <==> x in zs || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_7601","instance":7601,"id":194272,"goal":"lemma SeqAppendLen_7601(zs: seq, t: seq)\n ensures |zs + t| == |zs| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_7602","instance":7602,"id":194273,"goal":"lemma SeqAppendNil_7602(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_7603","instance":7603,"id":194274,"goal":"lemma SeqNilAppend_7603(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_7604","instance":7604,"id":194275,"goal":"lemma SeqAppendAssoc_7604(u: seq, t: seq, zs: seq)\n ensures (u + t) + zs == u + (t + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_7605","instance":7605,"id":194276,"goal":"lemma SeqTakeDrop_7605(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_7606","instance":7606,"id":194277,"goal":"lemma SeqReverseLen_7606(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_7607","instance":7607,"id":194278,"goal":"lemma SeqReverseIdem_7607(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_7608","instance":7608,"id":194279,"goal":"lemma SeqMapLen_7608(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_7609","instance":7609,"id":194280,"goal":"lemma SeqFilterLe_7609(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_7610","instance":7610,"id":194281,"goal":"lemma SeqMemberAppend_7610(u: seq, zs: seq)\n ensures x in u + zs <==> x in u || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_7611","instance":7611,"id":194282,"goal":"lemma SeqAppendLen_7611(zs: seq, t: seq)\n ensures |zs + t| == |zs| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_7612","instance":7612,"id":194283,"goal":"lemma SeqAppendNil_7612(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_7613","instance":7613,"id":194284,"goal":"lemma SeqNilAppend_7613(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_7614","instance":7614,"id":194285,"goal":"lemma SeqAppendAssoc_7614(ys: seq, s: seq, t: seq)\n ensures (ys + s) + t == ys + (s + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_7615","instance":7615,"id":194286,"goal":"lemma SeqTakeDrop_7615(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_7616","instance":7616,"id":194287,"goal":"lemma SeqReverseLen_7616(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_7617","instance":7617,"id":194288,"goal":"lemma SeqReverseIdem_7617(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_7618","instance":7618,"id":194289,"goal":"lemma SeqMapLen_7618(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_7619","instance":7619,"id":194290,"goal":"lemma SeqFilterLe_7619(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_7620","instance":7620,"id":194291,"goal":"lemma SeqMemberAppend_7620(s: seq, xs: seq)\n ensures x in s + xs <==> x in s || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_7621","instance":7621,"id":194292,"goal":"lemma SeqAppendLen_7621(zs: seq, xs: seq)\n ensures |zs + xs| == |zs| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_7622","instance":7622,"id":194293,"goal":"lemma SeqAppendNil_7622(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_7623","instance":7623,"id":194294,"goal":"lemma SeqNilAppend_7623(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_7624","instance":7624,"id":194295,"goal":"lemma SeqAppendAssoc_7624(zs: seq, u: seq, s: seq)\n ensures (zs + u) + s == zs + (u + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_7625","instance":7625,"id":194296,"goal":"lemma SeqTakeDrop_7625(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_7626","instance":7626,"id":194297,"goal":"lemma SeqReverseLen_7626(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_7627","instance":7627,"id":194298,"goal":"lemma SeqReverseIdem_7627(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_7628","instance":7628,"id":194299,"goal":"lemma SeqMapLen_7628(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_7629","instance":7629,"id":194300,"goal":"lemma SeqFilterLe_7629(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_7630","instance":7630,"id":194301,"goal":"lemma SeqMemberAppend_7630(t: seq, u: seq)\n ensures x in t + u <==> x in t || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_7631","instance":7631,"id":194302,"goal":"lemma SeqAppendLen_7631(ys: seq, s: seq)\n ensures |ys + s| == |ys| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_7632","instance":7632,"id":194303,"goal":"lemma SeqAppendNil_7632(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_7633","instance":7633,"id":194304,"goal":"lemma SeqNilAppend_7633(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_7634","instance":7634,"id":194305,"goal":"lemma SeqAppendAssoc_7634(ys: seq, t: seq, xs: seq)\n ensures (ys + t) + xs == ys + (t + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_7635","instance":7635,"id":194306,"goal":"lemma SeqTakeDrop_7635(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_7636","instance":7636,"id":194307,"goal":"lemma SeqReverseLen_7636(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_7637","instance":7637,"id":194308,"goal":"lemma SeqReverseIdem_7637(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_7638","instance":7638,"id":194309,"goal":"lemma SeqMapLen_7638(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_7639","instance":7639,"id":194310,"goal":"lemma SeqFilterLe_7639(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_7640","instance":7640,"id":194311,"goal":"lemma SeqMemberAppend_7640(t: seq, s: seq)\n ensures x in t + s <==> x in t || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_7641","instance":7641,"id":194312,"goal":"lemma SeqAppendLen_7641(xs: seq, u: seq)\n ensures |xs + u| == |xs| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_7642","instance":7642,"id":194313,"goal":"lemma SeqAppendNil_7642(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_7643","instance":7643,"id":194314,"goal":"lemma SeqNilAppend_7643(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_7644","instance":7644,"id":194315,"goal":"lemma SeqAppendAssoc_7644(zs: seq, ys: seq, s: seq)\n ensures (zs + ys) + s == zs + (ys + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_7645","instance":7645,"id":194316,"goal":"lemma SeqTakeDrop_7645(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_7646","instance":7646,"id":194317,"goal":"lemma SeqReverseLen_7646(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_7647","instance":7647,"id":194318,"goal":"lemma SeqReverseIdem_7647(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_7648","instance":7648,"id":194319,"goal":"lemma SeqMapLen_7648(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_7649","instance":7649,"id":194320,"goal":"lemma SeqFilterLe_7649(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_7650","instance":7650,"id":194321,"goal":"lemma SeqMemberAppend_7650(ys: seq, zs: seq)\n ensures x in ys + zs <==> x in ys || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_7651","instance":7651,"id":194322,"goal":"lemma SeqAppendLen_7651(t: seq, s: seq)\n ensures |t + s| == |t| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_7652","instance":7652,"id":194323,"goal":"lemma SeqAppendNil_7652(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_7653","instance":7653,"id":194324,"goal":"lemma SeqNilAppend_7653(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_7654","instance":7654,"id":194325,"goal":"lemma SeqAppendAssoc_7654(ys: seq, u: seq, xs: seq)\n ensures (ys + u) + xs == ys + (u + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_7655","instance":7655,"id":194326,"goal":"lemma SeqTakeDrop_7655(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_7656","instance":7656,"id":194327,"goal":"lemma SeqReverseLen_7656(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_7657","instance":7657,"id":194328,"goal":"lemma SeqReverseIdem_7657(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_7658","instance":7658,"id":194329,"goal":"lemma SeqMapLen_7658(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_7659","instance":7659,"id":194330,"goal":"lemma SeqFilterLe_7659(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_7660","instance":7660,"id":194331,"goal":"lemma SeqMemberAppend_7660(xs: seq, ys: seq)\n ensures x in xs + ys <==> x in xs || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_7661","instance":7661,"id":194332,"goal":"lemma SeqAppendLen_7661(xs: seq, s: seq)\n ensures |xs + s| == |xs| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_7662","instance":7662,"id":194333,"goal":"lemma SeqAppendNil_7662(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_7663","instance":7663,"id":194334,"goal":"lemma SeqNilAppend_7663(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_7664","instance":7664,"id":194335,"goal":"lemma SeqAppendAssoc_7664(s: seq, ys: seq, u: seq)\n ensures (s + ys) + u == s + (ys + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_7665","instance":7665,"id":194336,"goal":"lemma SeqTakeDrop_7665(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_7666","instance":7666,"id":194337,"goal":"lemma SeqReverseLen_7666(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_7667","instance":7667,"id":194338,"goal":"lemma SeqReverseIdem_7667(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_7668","instance":7668,"id":194339,"goal":"lemma SeqMapLen_7668(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_7669","instance":7669,"id":194340,"goal":"lemma SeqFilterLe_7669(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_7670","instance":7670,"id":194341,"goal":"lemma SeqMemberAppend_7670(ys: seq, t: seq)\n ensures x in ys + t <==> x in ys || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_7671","instance":7671,"id":194342,"goal":"lemma SeqAppendLen_7671(t: seq, zs: seq)\n ensures |t + zs| == |t| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_7672","instance":7672,"id":194343,"goal":"lemma SeqAppendNil_7672(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_7673","instance":7673,"id":194344,"goal":"lemma SeqNilAppend_7673(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_7674","instance":7674,"id":194345,"goal":"lemma SeqAppendAssoc_7674(ys: seq, zs: seq, t: seq)\n ensures (ys + zs) + t == ys + (zs + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_7675","instance":7675,"id":194346,"goal":"lemma SeqTakeDrop_7675(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_7676","instance":7676,"id":194347,"goal":"lemma SeqReverseLen_7676(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_7677","instance":7677,"id":194348,"goal":"lemma SeqReverseIdem_7677(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_7678","instance":7678,"id":194349,"goal":"lemma SeqMapLen_7678(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_7679","instance":7679,"id":194350,"goal":"lemma SeqFilterLe_7679(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_7680","instance":7680,"id":194351,"goal":"lemma SeqMemberAppend_7680(u: seq, ys: seq)\n ensures x in u + ys <==> x in u || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_7681","instance":7681,"id":194352,"goal":"lemma SeqAppendLen_7681(s: seq, ys: seq)\n ensures |s + ys| == |s| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_7682","instance":7682,"id":194353,"goal":"lemma SeqAppendNil_7682(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_7683","instance":7683,"id":194354,"goal":"lemma SeqNilAppend_7683(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_7684","instance":7684,"id":194355,"goal":"lemma SeqAppendAssoc_7684(zs: seq, u: seq, xs: seq)\n ensures (zs + u) + xs == zs + (u + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_7685","instance":7685,"id":194356,"goal":"lemma SeqTakeDrop_7685(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_7686","instance":7686,"id":194357,"goal":"lemma SeqReverseLen_7686(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_7687","instance":7687,"id":194358,"goal":"lemma SeqReverseIdem_7687(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_7688","instance":7688,"id":194359,"goal":"lemma SeqMapLen_7688(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_7689","instance":7689,"id":194360,"goal":"lemma SeqFilterLe_7689(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_7690","instance":7690,"id":194361,"goal":"lemma SeqMemberAppend_7690(t: seq, u: seq)\n ensures x in t + u <==> x in t || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_7691","instance":7691,"id":194362,"goal":"lemma SeqAppendLen_7691(xs: seq, ys: seq)\n ensures |xs + ys| == |xs| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_7692","instance":7692,"id":194363,"goal":"lemma SeqAppendNil_7692(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_7693","instance":7693,"id":194364,"goal":"lemma SeqNilAppend_7693(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_7694","instance":7694,"id":194365,"goal":"lemma SeqAppendAssoc_7694(s: seq, xs: seq, ys: seq)\n ensures (s + xs) + ys == s + (xs + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_7695","instance":7695,"id":194366,"goal":"lemma SeqTakeDrop_7695(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_7696","instance":7696,"id":194367,"goal":"lemma SeqReverseLen_7696(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_7697","instance":7697,"id":194368,"goal":"lemma SeqReverseIdem_7697(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_7698","instance":7698,"id":194369,"goal":"lemma SeqMapLen_7698(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_7699","instance":7699,"id":194370,"goal":"lemma SeqFilterLe_7699(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_7700","instance":7700,"id":194371,"goal":"lemma SeqMemberAppend_7700(t: seq, ys: seq)\n ensures x in t + ys <==> x in t || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_7701","instance":7701,"id":194372,"goal":"lemma SeqAppendLen_7701(u: seq, s: seq)\n ensures |u + s| == |u| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_7702","instance":7702,"id":194373,"goal":"lemma SeqAppendNil_7702(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_7703","instance":7703,"id":194374,"goal":"lemma SeqNilAppend_7703(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_7704","instance":7704,"id":194375,"goal":"lemma SeqAppendAssoc_7704(xs: seq, s: seq, t: seq)\n ensures (xs + s) + t == xs + (s + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_7705","instance":7705,"id":194376,"goal":"lemma SeqTakeDrop_7705(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_7706","instance":7706,"id":194377,"goal":"lemma SeqReverseLen_7706(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_7707","instance":7707,"id":194378,"goal":"lemma SeqReverseIdem_7707(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_7708","instance":7708,"id":194379,"goal":"lemma SeqMapLen_7708(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_7709","instance":7709,"id":194380,"goal":"lemma SeqFilterLe_7709(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_7710","instance":7710,"id":194381,"goal":"lemma SeqMemberAppend_7710(zs: seq, xs: seq)\n ensures x in zs + xs <==> x in zs || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_7711","instance":7711,"id":194382,"goal":"lemma SeqAppendLen_7711(zs: seq, u: seq)\n ensures |zs + u| == |zs| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_7712","instance":7712,"id":194383,"goal":"lemma SeqAppendNil_7712(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_7713","instance":7713,"id":194384,"goal":"lemma SeqNilAppend_7713(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_7714","instance":7714,"id":194385,"goal":"lemma SeqAppendAssoc_7714(t: seq, zs: seq, u: seq)\n ensures (t + zs) + u == t + (zs + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_7715","instance":7715,"id":194386,"goal":"lemma SeqTakeDrop_7715(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_7716","instance":7716,"id":194387,"goal":"lemma SeqReverseLen_7716(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_7717","instance":7717,"id":194388,"goal":"lemma SeqReverseIdem_7717(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_7718","instance":7718,"id":194389,"goal":"lemma SeqMapLen_7718(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_7719","instance":7719,"id":194390,"goal":"lemma SeqFilterLe_7719(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_7720","instance":7720,"id":194391,"goal":"lemma SeqMemberAppend_7720(t: seq, zs: seq)\n ensures x in t + zs <==> x in t || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_7721","instance":7721,"id":194392,"goal":"lemma SeqAppendLen_7721(s: seq, xs: seq)\n ensures |s + xs| == |s| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_7722","instance":7722,"id":194393,"goal":"lemma SeqAppendNil_7722(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_7723","instance":7723,"id":194394,"goal":"lemma SeqNilAppend_7723(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_7724","instance":7724,"id":194395,"goal":"lemma SeqAppendAssoc_7724(u: seq, zs: seq, xs: seq)\n ensures (u + zs) + xs == u + (zs + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_7725","instance":7725,"id":194396,"goal":"lemma SeqTakeDrop_7725(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_7726","instance":7726,"id":194397,"goal":"lemma SeqReverseLen_7726(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_7727","instance":7727,"id":194398,"goal":"lemma SeqReverseIdem_7727(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_7728","instance":7728,"id":194399,"goal":"lemma SeqMapLen_7728(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_7729","instance":7729,"id":194400,"goal":"lemma SeqFilterLe_7729(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_7730","instance":7730,"id":194401,"goal":"lemma SeqMemberAppend_7730(zs: seq, t: seq)\n ensures x in zs + t <==> x in zs || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_7731","instance":7731,"id":194402,"goal":"lemma SeqAppendLen_7731(ys: seq, t: seq)\n ensures |ys + t| == |ys| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_7732","instance":7732,"id":194403,"goal":"lemma SeqAppendNil_7732(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_7733","instance":7733,"id":194404,"goal":"lemma SeqNilAppend_7733(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_7734","instance":7734,"id":194405,"goal":"lemma SeqAppendAssoc_7734(ys: seq, s: seq, zs: seq)\n ensures (ys + s) + zs == ys + (s + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_7735","instance":7735,"id":194406,"goal":"lemma SeqTakeDrop_7735(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_7736","instance":7736,"id":194407,"goal":"lemma SeqReverseLen_7736(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_7737","instance":7737,"id":194408,"goal":"lemma SeqReverseIdem_7737(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_7738","instance":7738,"id":194409,"goal":"lemma SeqMapLen_7738(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_7739","instance":7739,"id":194410,"goal":"lemma SeqFilterLe_7739(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_7740","instance":7740,"id":194411,"goal":"lemma SeqMemberAppend_7740(s: seq, ys: seq)\n ensures x in s + ys <==> x in s || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_7741","instance":7741,"id":194412,"goal":"lemma SeqAppendLen_7741(xs: seq, ys: seq)\n ensures |xs + ys| == |xs| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_7742","instance":7742,"id":194413,"goal":"lemma SeqAppendNil_7742(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_7743","instance":7743,"id":194414,"goal":"lemma SeqNilAppend_7743(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_7744","instance":7744,"id":194415,"goal":"lemma SeqAppendAssoc_7744(xs: seq, zs: seq, s: seq)\n ensures (xs + zs) + s == xs + (zs + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_7745","instance":7745,"id":194416,"goal":"lemma SeqTakeDrop_7745(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_7746","instance":7746,"id":194417,"goal":"lemma SeqReverseLen_7746(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_7747","instance":7747,"id":194418,"goal":"lemma SeqReverseIdem_7747(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_7748","instance":7748,"id":194419,"goal":"lemma SeqMapLen_7748(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_7749","instance":7749,"id":194420,"goal":"lemma SeqFilterLe_7749(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_7750","instance":7750,"id":194421,"goal":"lemma SeqMemberAppend_7750(u: seq, s: seq)\n ensures x in u + s <==> x in u || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_7751","instance":7751,"id":194422,"goal":"lemma SeqAppendLen_7751(ys: seq, u: seq)\n ensures |ys + u| == |ys| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_7752","instance":7752,"id":194423,"goal":"lemma SeqAppendNil_7752(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_7753","instance":7753,"id":194424,"goal":"lemma SeqNilAppend_7753(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_7754","instance":7754,"id":194425,"goal":"lemma SeqAppendAssoc_7754(ys: seq, u: seq, zs: seq)\n ensures (ys + u) + zs == ys + (u + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_7755","instance":7755,"id":194426,"goal":"lemma SeqTakeDrop_7755(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_7756","instance":7756,"id":194427,"goal":"lemma SeqReverseLen_7756(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_7757","instance":7757,"id":194428,"goal":"lemma SeqReverseIdem_7757(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_7758","instance":7758,"id":194429,"goal":"lemma SeqMapLen_7758(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_7759","instance":7759,"id":194430,"goal":"lemma SeqFilterLe_7759(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_7760","instance":7760,"id":194431,"goal":"lemma SeqMemberAppend_7760(xs: seq, zs: seq)\n ensures x in xs + zs <==> x in xs || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_7761","instance":7761,"id":194432,"goal":"lemma SeqAppendLen_7761(u: seq, s: seq)\n ensures |u + s| == |u| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_7762","instance":7762,"id":194433,"goal":"lemma SeqAppendNil_7762(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_7763","instance":7763,"id":194434,"goal":"lemma SeqNilAppend_7763(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_7764","instance":7764,"id":194435,"goal":"lemma SeqAppendAssoc_7764(s: seq, xs: seq, ys: seq)\n ensures (s + xs) + ys == s + (xs + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_7765","instance":7765,"id":194436,"goal":"lemma SeqTakeDrop_7765(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_7766","instance":7766,"id":194437,"goal":"lemma SeqReverseLen_7766(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_7767","instance":7767,"id":194438,"goal":"lemma SeqReverseIdem_7767(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_7768","instance":7768,"id":194439,"goal":"lemma SeqMapLen_7768(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_7769","instance":7769,"id":194440,"goal":"lemma SeqFilterLe_7769(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_7770","instance":7770,"id":194441,"goal":"lemma SeqMemberAppend_7770(u: seq, s: seq)\n ensures x in u + s <==> x in u || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_7771","instance":7771,"id":194442,"goal":"lemma SeqAppendLen_7771(ys: seq, u: seq)\n ensures |ys + u| == |ys| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_7772","instance":7772,"id":194443,"goal":"lemma SeqAppendNil_7772(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_7773","instance":7773,"id":194444,"goal":"lemma SeqNilAppend_7773(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_7774","instance":7774,"id":194445,"goal":"lemma SeqAppendAssoc_7774(t: seq, s: seq, zs: seq)\n ensures (t + s) + zs == t + (s + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_7775","instance":7775,"id":194446,"goal":"lemma SeqTakeDrop_7775(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_7776","instance":7776,"id":194447,"goal":"lemma SeqReverseLen_7776(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_7777","instance":7777,"id":194448,"goal":"lemma SeqReverseIdem_7777(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_7778","instance":7778,"id":194449,"goal":"lemma SeqMapLen_7778(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_7779","instance":7779,"id":194450,"goal":"lemma SeqFilterLe_7779(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_7780","instance":7780,"id":194451,"goal":"lemma SeqMemberAppend_7780(s: seq, ys: seq)\n ensures x in s + ys <==> x in s || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_7781","instance":7781,"id":194452,"goal":"lemma SeqAppendLen_7781(ys: seq, zs: seq)\n ensures |ys + zs| == |ys| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_7782","instance":7782,"id":194453,"goal":"lemma SeqAppendNil_7782(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_7783","instance":7783,"id":194454,"goal":"lemma SeqNilAppend_7783(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_7784","instance":7784,"id":194455,"goal":"lemma SeqAppendAssoc_7784(u: seq, xs: seq, zs: seq)\n ensures (u + xs) + zs == u + (xs + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_7785","instance":7785,"id":194456,"goal":"lemma SeqTakeDrop_7785(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_7786","instance":7786,"id":194457,"goal":"lemma SeqReverseLen_7786(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_7787","instance":7787,"id":194458,"goal":"lemma SeqReverseIdem_7787(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_7788","instance":7788,"id":194459,"goal":"lemma SeqMapLen_7788(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_7789","instance":7789,"id":194460,"goal":"lemma SeqFilterLe_7789(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_7790","instance":7790,"id":194461,"goal":"lemma SeqMemberAppend_7790(u: seq, xs: seq)\n ensures x in u + xs <==> x in u || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_7791","instance":7791,"id":194462,"goal":"lemma SeqAppendLen_7791(t: seq, zs: seq)\n ensures |t + zs| == |t| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_7792","instance":7792,"id":194463,"goal":"lemma SeqAppendNil_7792(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_7793","instance":7793,"id":194464,"goal":"lemma SeqNilAppend_7793(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_7794","instance":7794,"id":194465,"goal":"lemma SeqAppendAssoc_7794(zs: seq, t: seq, u: seq)\n ensures (zs + t) + u == zs + (t + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_7795","instance":7795,"id":194466,"goal":"lemma SeqTakeDrop_7795(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_7796","instance":7796,"id":194467,"goal":"lemma SeqReverseLen_7796(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_7797","instance":7797,"id":194468,"goal":"lemma SeqReverseIdem_7797(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_7798","instance":7798,"id":194469,"goal":"lemma SeqMapLen_7798(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_7799","instance":7799,"id":194470,"goal":"lemma SeqFilterLe_7799(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_7800","instance":7800,"id":194471,"goal":"lemma SeqMemberAppend_7800(zs: seq, ys: seq)\n ensures x in zs + ys <==> x in zs || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_7801","instance":7801,"id":194472,"goal":"lemma SeqAppendLen_7801(xs: seq, t: seq)\n ensures |xs + t| == |xs| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_7802","instance":7802,"id":194473,"goal":"lemma SeqAppendNil_7802(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_7803","instance":7803,"id":194474,"goal":"lemma SeqNilAppend_7803(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_7804","instance":7804,"id":194475,"goal":"lemma SeqAppendAssoc_7804(zs: seq, s: seq, u: seq)\n ensures (zs + s) + u == zs + (s + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_7805","instance":7805,"id":194476,"goal":"lemma SeqTakeDrop_7805(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_7806","instance":7806,"id":194477,"goal":"lemma SeqReverseLen_7806(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_7807","instance":7807,"id":194478,"goal":"lemma SeqReverseIdem_7807(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_7808","instance":7808,"id":194479,"goal":"lemma SeqMapLen_7808(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_7809","instance":7809,"id":194480,"goal":"lemma SeqFilterLe_7809(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_7810","instance":7810,"id":194481,"goal":"lemma SeqMemberAppend_7810(xs: seq, t: seq)\n ensures x in xs + t <==> x in xs || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_7811","instance":7811,"id":194482,"goal":"lemma SeqAppendLen_7811(t: seq, u: seq)\n ensures |t + u| == |t| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_7812","instance":7812,"id":194483,"goal":"lemma SeqAppendNil_7812(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_7813","instance":7813,"id":194484,"goal":"lemma SeqNilAppend_7813(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_7814","instance":7814,"id":194485,"goal":"lemma SeqAppendAssoc_7814(u: seq, zs: seq, s: seq)\n ensures (u + zs) + s == u + (zs + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_7815","instance":7815,"id":194486,"goal":"lemma SeqTakeDrop_7815(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_7816","instance":7816,"id":194487,"goal":"lemma SeqReverseLen_7816(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_7817","instance":7817,"id":194488,"goal":"lemma SeqReverseIdem_7817(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_7818","instance":7818,"id":194489,"goal":"lemma SeqMapLen_7818(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_7819","instance":7819,"id":194490,"goal":"lemma SeqFilterLe_7819(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_7820","instance":7820,"id":194491,"goal":"lemma SeqMemberAppend_7820(ys: seq, t: seq)\n ensures x in ys + t <==> x in ys || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_7821","instance":7821,"id":194492,"goal":"lemma SeqAppendLen_7821(t: seq, ys: seq)\n ensures |t + ys| == |t| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_7822","instance":7822,"id":194493,"goal":"lemma SeqAppendNil_7822(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_7823","instance":7823,"id":194494,"goal":"lemma SeqNilAppend_7823(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_7824","instance":7824,"id":194495,"goal":"lemma SeqAppendAssoc_7824(xs: seq, u: seq, s: seq)\n ensures (xs + u) + s == xs + (u + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_7825","instance":7825,"id":194496,"goal":"lemma SeqTakeDrop_7825(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_7826","instance":7826,"id":194497,"goal":"lemma SeqReverseLen_7826(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_7827","instance":7827,"id":194498,"goal":"lemma SeqReverseIdem_7827(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_7828","instance":7828,"id":194499,"goal":"lemma SeqMapLen_7828(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_7829","instance":7829,"id":194500,"goal":"lemma SeqFilterLe_7829(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_7830","instance":7830,"id":194501,"goal":"lemma SeqMemberAppend_7830(ys: seq, zs: seq)\n ensures x in ys + zs <==> x in ys || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_7831","instance":7831,"id":194502,"goal":"lemma SeqAppendLen_7831(u: seq, s: seq)\n ensures |u + s| == |u| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_7832","instance":7832,"id":194503,"goal":"lemma SeqAppendNil_7832(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_7833","instance":7833,"id":194504,"goal":"lemma SeqNilAppend_7833(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_7834","instance":7834,"id":194505,"goal":"lemma SeqAppendAssoc_7834(s: seq, ys: seq, xs: seq)\n ensures (s + ys) + xs == s + (ys + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_7835","instance":7835,"id":194506,"goal":"lemma SeqTakeDrop_7835(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_7836","instance":7836,"id":194507,"goal":"lemma SeqReverseLen_7836(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_7837","instance":7837,"id":194508,"goal":"lemma SeqReverseIdem_7837(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_7838","instance":7838,"id":194509,"goal":"lemma SeqMapLen_7838(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_7839","instance":7839,"id":194510,"goal":"lemma SeqFilterLe_7839(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_7840","instance":7840,"id":194511,"goal":"lemma SeqMemberAppend_7840(zs: seq, s: seq)\n ensures x in zs + s <==> x in zs || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_7841","instance":7841,"id":194512,"goal":"lemma SeqAppendLen_7841(zs: seq, ys: seq)\n ensures |zs + ys| == |zs| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_7842","instance":7842,"id":194513,"goal":"lemma SeqAppendNil_7842(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_7843","instance":7843,"id":194514,"goal":"lemma SeqNilAppend_7843(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_7844","instance":7844,"id":194515,"goal":"lemma SeqAppendAssoc_7844(xs: seq, ys: seq, t: seq)\n ensures (xs + ys) + t == xs + (ys + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_7845","instance":7845,"id":194516,"goal":"lemma SeqTakeDrop_7845(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_7846","instance":7846,"id":194517,"goal":"lemma SeqReverseLen_7846(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_7847","instance":7847,"id":194518,"goal":"lemma SeqReverseIdem_7847(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_7848","instance":7848,"id":194519,"goal":"lemma SeqMapLen_7848(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_7849","instance":7849,"id":194520,"goal":"lemma SeqFilterLe_7849(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_7850","instance":7850,"id":194521,"goal":"lemma SeqMemberAppend_7850(t: seq, zs: seq)\n ensures x in t + zs <==> x in t || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_7851","instance":7851,"id":194522,"goal":"lemma SeqAppendLen_7851(u: seq, zs: seq)\n ensures |u + zs| == |u| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_7852","instance":7852,"id":194523,"goal":"lemma SeqAppendNil_7852(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_7853","instance":7853,"id":194524,"goal":"lemma SeqNilAppend_7853(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_7854","instance":7854,"id":194525,"goal":"lemma SeqAppendAssoc_7854(xs: seq, ys: seq, s: seq)\n ensures (xs + ys) + s == xs + (ys + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_7855","instance":7855,"id":194526,"goal":"lemma SeqTakeDrop_7855(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_7856","instance":7856,"id":194527,"goal":"lemma SeqReverseLen_7856(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_7857","instance":7857,"id":194528,"goal":"lemma SeqReverseIdem_7857(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_7858","instance":7858,"id":194529,"goal":"lemma SeqMapLen_7858(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_7859","instance":7859,"id":194530,"goal":"lemma SeqFilterLe_7859(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_7860","instance":7860,"id":194531,"goal":"lemma SeqMemberAppend_7860(ys: seq, zs: seq)\n ensures x in ys + zs <==> x in ys || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_7861","instance":7861,"id":194532,"goal":"lemma SeqAppendLen_7861(xs: seq, zs: seq)\n ensures |xs + zs| == |xs| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_7862","instance":7862,"id":194533,"goal":"lemma SeqAppendNil_7862(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_7863","instance":7863,"id":194534,"goal":"lemma SeqNilAppend_7863(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_7864","instance":7864,"id":194535,"goal":"lemma SeqAppendAssoc_7864(zs: seq, xs: seq, s: seq)\n ensures (zs + xs) + s == zs + (xs + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_7865","instance":7865,"id":194536,"goal":"lemma SeqTakeDrop_7865(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_7866","instance":7866,"id":194537,"goal":"lemma SeqReverseLen_7866(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_7867","instance":7867,"id":194538,"goal":"lemma SeqReverseIdem_7867(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_7868","instance":7868,"id":194539,"goal":"lemma SeqMapLen_7868(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_7869","instance":7869,"id":194540,"goal":"lemma SeqFilterLe_7869(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_7870","instance":7870,"id":194541,"goal":"lemma SeqMemberAppend_7870(s: seq, u: seq)\n ensures x in s + u <==> x in s || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_7871","instance":7871,"id":194542,"goal":"lemma SeqAppendLen_7871(xs: seq, ys: seq)\n ensures |xs + ys| == |xs| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_7872","instance":7872,"id":194543,"goal":"lemma SeqAppendNil_7872(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_7873","instance":7873,"id":194544,"goal":"lemma SeqNilAppend_7873(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_7874","instance":7874,"id":194545,"goal":"lemma SeqAppendAssoc_7874(u: seq, xs: seq, t: seq)\n ensures (u + xs) + t == u + (xs + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_7875","instance":7875,"id":194546,"goal":"lemma SeqTakeDrop_7875(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_7876","instance":7876,"id":194547,"goal":"lemma SeqReverseLen_7876(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_7877","instance":7877,"id":194548,"goal":"lemma SeqReverseIdem_7877(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_7878","instance":7878,"id":194549,"goal":"lemma SeqMapLen_7878(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_7879","instance":7879,"id":194550,"goal":"lemma SeqFilterLe_7879(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_7880","instance":7880,"id":194551,"goal":"lemma SeqMemberAppend_7880(u: seq, t: seq)\n ensures x in u + t <==> x in u || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_7881","instance":7881,"id":194552,"goal":"lemma SeqAppendLen_7881(zs: seq, xs: seq)\n ensures |zs + xs| == |zs| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_7882","instance":7882,"id":194553,"goal":"lemma SeqAppendNil_7882(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_7883","instance":7883,"id":194554,"goal":"lemma SeqNilAppend_7883(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_7884","instance":7884,"id":194555,"goal":"lemma SeqAppendAssoc_7884(t: seq, s: seq, xs: seq)\n ensures (t + s) + xs == t + (s + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_7885","instance":7885,"id":194556,"goal":"lemma SeqTakeDrop_7885(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_7886","instance":7886,"id":194557,"goal":"lemma SeqReverseLen_7886(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_7887","instance":7887,"id":194558,"goal":"lemma SeqReverseIdem_7887(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_7888","instance":7888,"id":194559,"goal":"lemma SeqMapLen_7888(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_7889","instance":7889,"id":194560,"goal":"lemma SeqFilterLe_7889(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_7890","instance":7890,"id":194561,"goal":"lemma SeqMemberAppend_7890(zs: seq, t: seq)\n ensures x in zs + t <==> x in zs || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_7891","instance":7891,"id":194562,"goal":"lemma SeqAppendLen_7891(s: seq, ys: seq)\n ensures |s + ys| == |s| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_7892","instance":7892,"id":194563,"goal":"lemma SeqAppendNil_7892(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_7893","instance":7893,"id":194564,"goal":"lemma SeqNilAppend_7893(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_7894","instance":7894,"id":194565,"goal":"lemma SeqAppendAssoc_7894(ys: seq, u: seq, zs: seq)\n ensures (ys + u) + zs == ys + (u + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_7895","instance":7895,"id":194566,"goal":"lemma SeqTakeDrop_7895(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_7896","instance":7896,"id":194567,"goal":"lemma SeqReverseLen_7896(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_7897","instance":7897,"id":194568,"goal":"lemma SeqReverseIdem_7897(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_7898","instance":7898,"id":194569,"goal":"lemma SeqMapLen_7898(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_7899","instance":7899,"id":194570,"goal":"lemma SeqFilterLe_7899(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_7900","instance":7900,"id":194571,"goal":"lemma SeqMemberAppend_7900(ys: seq, zs: seq)\n ensures x in ys + zs <==> x in ys || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_7901","instance":7901,"id":194572,"goal":"lemma SeqAppendLen_7901(s: seq, t: seq)\n ensures |s + t| == |s| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_7902","instance":7902,"id":194573,"goal":"lemma SeqAppendNil_7902(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_7903","instance":7903,"id":194574,"goal":"lemma SeqNilAppend_7903(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_7904","instance":7904,"id":194575,"goal":"lemma SeqAppendAssoc_7904(s: seq, ys: seq, zs: seq)\n ensures (s + ys) + zs == s + (ys + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_7905","instance":7905,"id":194576,"goal":"lemma SeqTakeDrop_7905(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_7906","instance":7906,"id":194577,"goal":"lemma SeqReverseLen_7906(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_7907","instance":7907,"id":194578,"goal":"lemma SeqReverseIdem_7907(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_7908","instance":7908,"id":194579,"goal":"lemma SeqMapLen_7908(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_7909","instance":7909,"id":194580,"goal":"lemma SeqFilterLe_7909(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_7910","instance":7910,"id":194581,"goal":"lemma SeqMemberAppend_7910(s: seq, t: seq)\n ensures x in s + t <==> x in s || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_7911","instance":7911,"id":194582,"goal":"lemma SeqAppendLen_7911(xs: seq, s: seq)\n ensures |xs + s| == |xs| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_7912","instance":7912,"id":194583,"goal":"lemma SeqAppendNil_7912(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_7913","instance":7913,"id":194584,"goal":"lemma SeqNilAppend_7913(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_7914","instance":7914,"id":194585,"goal":"lemma SeqAppendAssoc_7914(t: seq, ys: seq, s: seq)\n ensures (t + ys) + s == t + (ys + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_7915","instance":7915,"id":194586,"goal":"lemma SeqTakeDrop_7915(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_7916","instance":7916,"id":194587,"goal":"lemma SeqReverseLen_7916(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_7917","instance":7917,"id":194588,"goal":"lemma SeqReverseIdem_7917(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_7918","instance":7918,"id":194589,"goal":"lemma SeqMapLen_7918(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_7919","instance":7919,"id":194590,"goal":"lemma SeqFilterLe_7919(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_7920","instance":7920,"id":194591,"goal":"lemma SeqMemberAppend_7920(s: seq, u: seq)\n ensures x in s + u <==> x in s || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_7921","instance":7921,"id":194592,"goal":"lemma SeqAppendLen_7921(u: seq, xs: seq)\n ensures |u + xs| == |u| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_7922","instance":7922,"id":194593,"goal":"lemma SeqAppendNil_7922(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_7923","instance":7923,"id":194594,"goal":"lemma SeqNilAppend_7923(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_7924","instance":7924,"id":194595,"goal":"lemma SeqAppendAssoc_7924(t: seq, s: seq, xs: seq)\n ensures (t + s) + xs == t + (s + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_7925","instance":7925,"id":194596,"goal":"lemma SeqTakeDrop_7925(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_7926","instance":7926,"id":194597,"goal":"lemma SeqReverseLen_7926(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_7927","instance":7927,"id":194598,"goal":"lemma SeqReverseIdem_7927(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_7928","instance":7928,"id":194599,"goal":"lemma SeqMapLen_7928(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_7929","instance":7929,"id":194600,"goal":"lemma SeqFilterLe_7929(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_7930","instance":7930,"id":194601,"goal":"lemma SeqMemberAppend_7930(zs: seq, ys: seq)\n ensures x in zs + ys <==> x in zs || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_7931","instance":7931,"id":194602,"goal":"lemma SeqAppendLen_7931(s: seq, xs: seq)\n ensures |s + xs| == |s| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_7932","instance":7932,"id":194603,"goal":"lemma SeqAppendNil_7932(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_7933","instance":7933,"id":194604,"goal":"lemma SeqNilAppend_7933(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_7934","instance":7934,"id":194605,"goal":"lemma SeqAppendAssoc_7934(u: seq, zs: seq, ys: seq)\n ensures (u + zs) + ys == u + (zs + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_7935","instance":7935,"id":194606,"goal":"lemma SeqTakeDrop_7935(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_7936","instance":7936,"id":194607,"goal":"lemma SeqReverseLen_7936(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_7937","instance":7937,"id":194608,"goal":"lemma SeqReverseIdem_7937(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_7938","instance":7938,"id":194609,"goal":"lemma SeqMapLen_7938(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_7939","instance":7939,"id":194610,"goal":"lemma SeqFilterLe_7939(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_7940","instance":7940,"id":194611,"goal":"lemma SeqMemberAppend_7940(u: seq, t: seq)\n ensures x in u + t <==> x in u || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_7941","instance":7941,"id":194612,"goal":"lemma SeqAppendLen_7941(t: seq, xs: seq)\n ensures |t + xs| == |t| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_7942","instance":7942,"id":194613,"goal":"lemma SeqAppendNil_7942(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_7943","instance":7943,"id":194614,"goal":"lemma SeqNilAppend_7943(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_7944","instance":7944,"id":194615,"goal":"lemma SeqAppendAssoc_7944(zs: seq, ys: seq, xs: seq)\n ensures (zs + ys) + xs == zs + (ys + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_7945","instance":7945,"id":194616,"goal":"lemma SeqTakeDrop_7945(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_7946","instance":7946,"id":194617,"goal":"lemma SeqReverseLen_7946(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_7947","instance":7947,"id":194618,"goal":"lemma SeqReverseIdem_7947(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_7948","instance":7948,"id":194619,"goal":"lemma SeqMapLen_7948(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_7949","instance":7949,"id":194620,"goal":"lemma SeqFilterLe_7949(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_7950","instance":7950,"id":194621,"goal":"lemma SeqMemberAppend_7950(ys: seq, xs: seq)\n ensures x in ys + xs <==> x in ys || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_7951","instance":7951,"id":194622,"goal":"lemma SeqAppendLen_7951(t: seq, u: seq)\n ensures |t + u| == |t| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_7952","instance":7952,"id":194623,"goal":"lemma SeqAppendNil_7952(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_7953","instance":7953,"id":194624,"goal":"lemma SeqNilAppend_7953(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_7954","instance":7954,"id":194625,"goal":"lemma SeqAppendAssoc_7954(ys: seq, s: seq, u: seq)\n ensures (ys + s) + u == ys + (s + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_7955","instance":7955,"id":194626,"goal":"lemma SeqTakeDrop_7955(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_7956","instance":7956,"id":194627,"goal":"lemma SeqReverseLen_7956(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_7957","instance":7957,"id":194628,"goal":"lemma SeqReverseIdem_7957(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_7958","instance":7958,"id":194629,"goal":"lemma SeqMapLen_7958(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_7959","instance":7959,"id":194630,"goal":"lemma SeqFilterLe_7959(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_7960","instance":7960,"id":194631,"goal":"lemma SeqMemberAppend_7960(xs: seq, zs: seq)\n ensures x in xs + zs <==> x in xs || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_7961","instance":7961,"id":194632,"goal":"lemma SeqAppendLen_7961(zs: seq, xs: seq)\n ensures |zs + xs| == |zs| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_7962","instance":7962,"id":194633,"goal":"lemma SeqAppendNil_7962(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_7963","instance":7963,"id":194634,"goal":"lemma SeqNilAppend_7963(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_7964","instance":7964,"id":194635,"goal":"lemma SeqAppendAssoc_7964(t: seq, xs: seq, ys: seq)\n ensures (t + xs) + ys == t + (xs + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_7965","instance":7965,"id":194636,"goal":"lemma SeqTakeDrop_7965(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_7966","instance":7966,"id":194637,"goal":"lemma SeqReverseLen_7966(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_7967","instance":7967,"id":194638,"goal":"lemma SeqReverseIdem_7967(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_7968","instance":7968,"id":194639,"goal":"lemma SeqMapLen_7968(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_7969","instance":7969,"id":194640,"goal":"lemma SeqFilterLe_7969(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_7970","instance":7970,"id":194641,"goal":"lemma SeqMemberAppend_7970(xs: seq, ys: seq)\n ensures x in xs + ys <==> x in xs || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_7971","instance":7971,"id":194642,"goal":"lemma SeqAppendLen_7971(u: seq, zs: seq)\n ensures |u + zs| == |u| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_7972","instance":7972,"id":194643,"goal":"lemma SeqAppendNil_7972(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_7973","instance":7973,"id":194644,"goal":"lemma SeqNilAppend_7973(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_7974","instance":7974,"id":194645,"goal":"lemma SeqAppendAssoc_7974(ys: seq, s: seq, zs: seq)\n ensures (ys + s) + zs == ys + (s + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_7975","instance":7975,"id":194646,"goal":"lemma SeqTakeDrop_7975(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_7976","instance":7976,"id":194647,"goal":"lemma SeqReverseLen_7976(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_7977","instance":7977,"id":194648,"goal":"lemma SeqReverseIdem_7977(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_7978","instance":7978,"id":194649,"goal":"lemma SeqMapLen_7978(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_7979","instance":7979,"id":194650,"goal":"lemma SeqFilterLe_7979(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_7980","instance":7980,"id":194651,"goal":"lemma SeqMemberAppend_7980(zs: seq, t: seq)\n ensures x in zs + t <==> x in zs || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_7981","instance":7981,"id":194652,"goal":"lemma SeqAppendLen_7981(ys: seq, xs: seq)\n ensures |ys + xs| == |ys| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_7982","instance":7982,"id":194653,"goal":"lemma SeqAppendNil_7982(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_7983","instance":7983,"id":194654,"goal":"lemma SeqNilAppend_7983(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_7984","instance":7984,"id":194655,"goal":"lemma SeqAppendAssoc_7984(ys: seq, s: seq, u: seq)\n ensures (ys + s) + u == ys + (s + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_7985","instance":7985,"id":194656,"goal":"lemma SeqTakeDrop_7985(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_7986","instance":7986,"id":194657,"goal":"lemma SeqReverseLen_7986(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_7987","instance":7987,"id":194658,"goal":"lemma SeqReverseIdem_7987(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_7988","instance":7988,"id":194659,"goal":"lemma SeqMapLen_7988(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_7989","instance":7989,"id":194660,"goal":"lemma SeqFilterLe_7989(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_7990","instance":7990,"id":194661,"goal":"lemma SeqMemberAppend_7990(ys: seq, s: seq)\n ensures x in ys + s <==> x in ys || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_7991","instance":7991,"id":194662,"goal":"lemma SeqAppendLen_7991(ys: seq, zs: seq)\n ensures |ys + zs| == |ys| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_7992","instance":7992,"id":194663,"goal":"lemma SeqAppendNil_7992(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_7993","instance":7993,"id":194664,"goal":"lemma SeqNilAppend_7993(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_7994","instance":7994,"id":194665,"goal":"lemma SeqAppendAssoc_7994(s: seq, t: seq, zs: seq)\n ensures (s + t) + zs == s + (t + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_7995","instance":7995,"id":194666,"goal":"lemma SeqTakeDrop_7995(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_7996","instance":7996,"id":194667,"goal":"lemma SeqReverseLen_7996(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_7997","instance":7997,"id":194668,"goal":"lemma SeqReverseIdem_7997(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_7998","instance":7998,"id":194669,"goal":"lemma SeqMapLen_7998(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_7999","instance":7999,"id":194670,"goal":"lemma SeqFilterLe_7999(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_8000","instance":8000,"id":194671,"goal":"lemma SeqMemberAppend_8000(t: seq, s: seq)\n ensures x in t + s <==> x in t || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_8001","instance":8001,"id":194672,"goal":"lemma SeqAppendLen_8001(xs: seq, ys: seq)\n ensures |xs + ys| == |xs| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_8002","instance":8002,"id":194673,"goal":"lemma SeqAppendNil_8002(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_8003","instance":8003,"id":194674,"goal":"lemma SeqNilAppend_8003(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_8004","instance":8004,"id":194675,"goal":"lemma SeqAppendAssoc_8004(zs: seq, s: seq, xs: seq)\n ensures (zs + s) + xs == zs + (s + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_8005","instance":8005,"id":194676,"goal":"lemma SeqTakeDrop_8005(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_8006","instance":8006,"id":194677,"goal":"lemma SeqReverseLen_8006(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_8007","instance":8007,"id":194678,"goal":"lemma SeqReverseIdem_8007(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_8008","instance":8008,"id":194679,"goal":"lemma SeqMapLen_8008(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_8009","instance":8009,"id":194680,"goal":"lemma SeqFilterLe_8009(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_8010","instance":8010,"id":194681,"goal":"lemma SeqMemberAppend_8010(t: seq, s: seq)\n ensures x in t + s <==> x in t || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_8011","instance":8011,"id":194682,"goal":"lemma SeqAppendLen_8011(ys: seq, u: seq)\n ensures |ys + u| == |ys| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_8012","instance":8012,"id":194683,"goal":"lemma SeqAppendNil_8012(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_8013","instance":8013,"id":194684,"goal":"lemma SeqNilAppend_8013(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_8014","instance":8014,"id":194685,"goal":"lemma SeqAppendAssoc_8014(xs: seq, u: seq, zs: seq)\n ensures (xs + u) + zs == xs + (u + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_8015","instance":8015,"id":194686,"goal":"lemma SeqTakeDrop_8015(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_8016","instance":8016,"id":194687,"goal":"lemma SeqReverseLen_8016(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_8017","instance":8017,"id":194688,"goal":"lemma SeqReverseIdem_8017(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_8018","instance":8018,"id":194689,"goal":"lemma SeqMapLen_8018(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_8019","instance":8019,"id":194690,"goal":"lemma SeqFilterLe_8019(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_8020","instance":8020,"id":194691,"goal":"lemma SeqMemberAppend_8020(u: seq, ys: seq)\n ensures x in u + ys <==> x in u || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_8021","instance":8021,"id":194692,"goal":"lemma SeqAppendLen_8021(ys: seq, s: seq)\n ensures |ys + s| == |ys| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_8022","instance":8022,"id":194693,"goal":"lemma SeqAppendNil_8022(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_8023","instance":8023,"id":194694,"goal":"lemma SeqNilAppend_8023(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_8024","instance":8024,"id":194695,"goal":"lemma SeqAppendAssoc_8024(s: seq, u: seq, t: seq)\n ensures (s + u) + t == s + (u + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_8025","instance":8025,"id":194696,"goal":"lemma SeqTakeDrop_8025(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_8026","instance":8026,"id":194697,"goal":"lemma SeqReverseLen_8026(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_8027","instance":8027,"id":194698,"goal":"lemma SeqReverseIdem_8027(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_8028","instance":8028,"id":194699,"goal":"lemma SeqMapLen_8028(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_8029","instance":8029,"id":194700,"goal":"lemma SeqFilterLe_8029(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_8030","instance":8030,"id":194701,"goal":"lemma SeqMemberAppend_8030(ys: seq, u: seq)\n ensures x in ys + u <==> x in ys || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_8031","instance":8031,"id":194702,"goal":"lemma SeqAppendLen_8031(s: seq, ys: seq)\n ensures |s + ys| == |s| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_8032","instance":8032,"id":194703,"goal":"lemma SeqAppendNil_8032(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_8033","instance":8033,"id":194704,"goal":"lemma SeqNilAppend_8033(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_8034","instance":8034,"id":194705,"goal":"lemma SeqAppendAssoc_8034(zs: seq, t: seq, ys: seq)\n ensures (zs + t) + ys == zs + (t + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_8035","instance":8035,"id":194706,"goal":"lemma SeqTakeDrop_8035(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_8036","instance":8036,"id":194707,"goal":"lemma SeqReverseLen_8036(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_8037","instance":8037,"id":194708,"goal":"lemma SeqReverseIdem_8037(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_8038","instance":8038,"id":194709,"goal":"lemma SeqMapLen_8038(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_8039","instance":8039,"id":194710,"goal":"lemma SeqFilterLe_8039(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_8040","instance":8040,"id":194711,"goal":"lemma SeqMemberAppend_8040(t: seq, s: seq)\n ensures x in t + s <==> x in t || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_8041","instance":8041,"id":194712,"goal":"lemma SeqAppendLen_8041(ys: seq, s: seq)\n ensures |ys + s| == |ys| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_8042","instance":8042,"id":194713,"goal":"lemma SeqAppendNil_8042(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_8043","instance":8043,"id":194714,"goal":"lemma SeqNilAppend_8043(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_8044","instance":8044,"id":194715,"goal":"lemma SeqAppendAssoc_8044(ys: seq, t: seq, xs: seq)\n ensures (ys + t) + xs == ys + (t + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_8045","instance":8045,"id":194716,"goal":"lemma SeqTakeDrop_8045(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_8046","instance":8046,"id":194717,"goal":"lemma SeqReverseLen_8046(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_8047","instance":8047,"id":194718,"goal":"lemma SeqReverseIdem_8047(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_8048","instance":8048,"id":194719,"goal":"lemma SeqMapLen_8048(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_8049","instance":8049,"id":194720,"goal":"lemma SeqFilterLe_8049(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_8050","instance":8050,"id":194721,"goal":"lemma SeqMemberAppend_8050(u: seq, t: seq)\n ensures x in u + t <==> x in u || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_8051","instance":8051,"id":194722,"goal":"lemma SeqAppendLen_8051(u: seq, t: seq)\n ensures |u + t| == |u| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_8052","instance":8052,"id":194723,"goal":"lemma SeqAppendNil_8052(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_8053","instance":8053,"id":194724,"goal":"lemma SeqNilAppend_8053(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_8054","instance":8054,"id":194725,"goal":"lemma SeqAppendAssoc_8054(zs: seq, s: seq, t: seq)\n ensures (zs + s) + t == zs + (s + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_8055","instance":8055,"id":194726,"goal":"lemma SeqTakeDrop_8055(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_8056","instance":8056,"id":194727,"goal":"lemma SeqReverseLen_8056(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_8057","instance":8057,"id":194728,"goal":"lemma SeqReverseIdem_8057(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_8058","instance":8058,"id":194729,"goal":"lemma SeqMapLen_8058(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_8059","instance":8059,"id":194730,"goal":"lemma SeqFilterLe_8059(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_8060","instance":8060,"id":194731,"goal":"lemma SeqMemberAppend_8060(xs: seq, u: seq)\n ensures x in xs + u <==> x in xs || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_8061","instance":8061,"id":194732,"goal":"lemma SeqAppendLen_8061(s: seq, xs: seq)\n ensures |s + xs| == |s| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_8062","instance":8062,"id":194733,"goal":"lemma SeqAppendNil_8062(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_8063","instance":8063,"id":194734,"goal":"lemma SeqNilAppend_8063(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_8064","instance":8064,"id":194735,"goal":"lemma SeqAppendAssoc_8064(xs: seq, t: seq, zs: seq)\n ensures (xs + t) + zs == xs + (t + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_8065","instance":8065,"id":194736,"goal":"lemma SeqTakeDrop_8065(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_8066","instance":8066,"id":194737,"goal":"lemma SeqReverseLen_8066(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_8067","instance":8067,"id":194738,"goal":"lemma SeqReverseIdem_8067(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_8068","instance":8068,"id":194739,"goal":"lemma SeqMapLen_8068(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_8069","instance":8069,"id":194740,"goal":"lemma SeqFilterLe_8069(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_8070","instance":8070,"id":194741,"goal":"lemma SeqMemberAppend_8070(zs: seq, s: seq)\n ensures x in zs + s <==> x in zs || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_8071","instance":8071,"id":194742,"goal":"lemma SeqAppendLen_8071(ys: seq, zs: seq)\n ensures |ys + zs| == |ys| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_8072","instance":8072,"id":194743,"goal":"lemma SeqAppendNil_8072(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_8073","instance":8073,"id":194744,"goal":"lemma SeqNilAppend_8073(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_8074","instance":8074,"id":194745,"goal":"lemma SeqAppendAssoc_8074(zs: seq, s: seq, ys: seq)\n ensures (zs + s) + ys == zs + (s + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_8075","instance":8075,"id":194746,"goal":"lemma SeqTakeDrop_8075(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_8076","instance":8076,"id":194747,"goal":"lemma SeqReverseLen_8076(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_8077","instance":8077,"id":194748,"goal":"lemma SeqReverseIdem_8077(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_8078","instance":8078,"id":194749,"goal":"lemma SeqMapLen_8078(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_8079","instance":8079,"id":194750,"goal":"lemma SeqFilterLe_8079(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_8080","instance":8080,"id":194751,"goal":"lemma SeqMemberAppend_8080(s: seq, ys: seq)\n ensures x in s + ys <==> x in s || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_8081","instance":8081,"id":194752,"goal":"lemma SeqAppendLen_8081(zs: seq, ys: seq)\n ensures |zs + ys| == |zs| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_8082","instance":8082,"id":194753,"goal":"lemma SeqAppendNil_8082(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_8083","instance":8083,"id":194754,"goal":"lemma SeqNilAppend_8083(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_8084","instance":8084,"id":194755,"goal":"lemma SeqAppendAssoc_8084(ys: seq, s: seq, xs: seq)\n ensures (ys + s) + xs == ys + (s + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_8085","instance":8085,"id":194756,"goal":"lemma SeqTakeDrop_8085(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_8086","instance":8086,"id":194757,"goal":"lemma SeqReverseLen_8086(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_8087","instance":8087,"id":194758,"goal":"lemma SeqReverseIdem_8087(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_8088","instance":8088,"id":194759,"goal":"lemma SeqMapLen_8088(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_8089","instance":8089,"id":194760,"goal":"lemma SeqFilterLe_8089(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_8090","instance":8090,"id":194761,"goal":"lemma SeqMemberAppend_8090(t: seq, zs: seq)\n ensures x in t + zs <==> x in t || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_8091","instance":8091,"id":194762,"goal":"lemma SeqAppendLen_8091(u: seq, ys: seq)\n ensures |u + ys| == |u| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_8092","instance":8092,"id":194763,"goal":"lemma SeqAppendNil_8092(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_8093","instance":8093,"id":194764,"goal":"lemma SeqNilAppend_8093(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_8094","instance":8094,"id":194765,"goal":"lemma SeqAppendAssoc_8094(ys: seq, u: seq, s: seq)\n ensures (ys + u) + s == ys + (u + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_8095","instance":8095,"id":194766,"goal":"lemma SeqTakeDrop_8095(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_8096","instance":8096,"id":194767,"goal":"lemma SeqReverseLen_8096(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_8097","instance":8097,"id":194768,"goal":"lemma SeqReverseIdem_8097(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_8098","instance":8098,"id":194769,"goal":"lemma SeqMapLen_8098(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_8099","instance":8099,"id":194770,"goal":"lemma SeqFilterLe_8099(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_8100","instance":8100,"id":194771,"goal":"lemma SeqMemberAppend_8100(u: seq, ys: seq)\n ensures x in u + ys <==> x in u || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_8101","instance":8101,"id":194772,"goal":"lemma SeqAppendLen_8101(zs: seq, t: seq)\n ensures |zs + t| == |zs| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_8102","instance":8102,"id":194773,"goal":"lemma SeqAppendNil_8102(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_8103","instance":8103,"id":194774,"goal":"lemma SeqNilAppend_8103(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_8104","instance":8104,"id":194775,"goal":"lemma SeqAppendAssoc_8104(xs: seq, t: seq, ys: seq)\n ensures (xs + t) + ys == xs + (t + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_8105","instance":8105,"id":194776,"goal":"lemma SeqTakeDrop_8105(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_8106","instance":8106,"id":194777,"goal":"lemma SeqReverseLen_8106(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_8107","instance":8107,"id":194778,"goal":"lemma SeqReverseIdem_8107(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_8108","instance":8108,"id":194779,"goal":"lemma SeqMapLen_8108(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_8109","instance":8109,"id":194780,"goal":"lemma SeqFilterLe_8109(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_8110","instance":8110,"id":194781,"goal":"lemma SeqMemberAppend_8110(ys: seq, xs: seq)\n ensures x in ys + xs <==> x in ys || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_8111","instance":8111,"id":194782,"goal":"lemma SeqAppendLen_8111(ys: seq, t: seq)\n ensures |ys + t| == |ys| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_8112","instance":8112,"id":194783,"goal":"lemma SeqAppendNil_8112(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_8113","instance":8113,"id":194784,"goal":"lemma SeqNilAppend_8113(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_8114","instance":8114,"id":194785,"goal":"lemma SeqAppendAssoc_8114(ys: seq, xs: seq, zs: seq)\n ensures (ys + xs) + zs == ys + (xs + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_8115","instance":8115,"id":194786,"goal":"lemma SeqTakeDrop_8115(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_8116","instance":8116,"id":194787,"goal":"lemma SeqReverseLen_8116(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_8117","instance":8117,"id":194788,"goal":"lemma SeqReverseIdem_8117(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_8118","instance":8118,"id":194789,"goal":"lemma SeqMapLen_8118(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_8119","instance":8119,"id":194790,"goal":"lemma SeqFilterLe_8119(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_8120","instance":8120,"id":194791,"goal":"lemma SeqMemberAppend_8120(ys: seq, s: seq)\n ensures x in ys + s <==> x in ys || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_8121","instance":8121,"id":194792,"goal":"lemma SeqAppendLen_8121(t: seq, zs: seq)\n ensures |t + zs| == |t| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_8122","instance":8122,"id":194793,"goal":"lemma SeqAppendNil_8122(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_8123","instance":8123,"id":194794,"goal":"lemma SeqNilAppend_8123(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_8124","instance":8124,"id":194795,"goal":"lemma SeqAppendAssoc_8124(zs: seq, u: seq, t: seq)\n ensures (zs + u) + t == zs + (u + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_8125","instance":8125,"id":194796,"goal":"lemma SeqTakeDrop_8125(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_8126","instance":8126,"id":194797,"goal":"lemma SeqReverseLen_8126(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_8127","instance":8127,"id":194798,"goal":"lemma SeqReverseIdem_8127(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_8128","instance":8128,"id":194799,"goal":"lemma SeqMapLen_8128(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_8129","instance":8129,"id":194800,"goal":"lemma SeqFilterLe_8129(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_8130","instance":8130,"id":194801,"goal":"lemma SeqMemberAppend_8130(u: seq, s: seq)\n ensures x in u + s <==> x in u || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_8131","instance":8131,"id":194802,"goal":"lemma SeqAppendLen_8131(u: seq, t: seq)\n ensures |u + t| == |u| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_8132","instance":8132,"id":194803,"goal":"lemma SeqAppendNil_8132(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_8133","instance":8133,"id":194804,"goal":"lemma SeqNilAppend_8133(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_8134","instance":8134,"id":194805,"goal":"lemma SeqAppendAssoc_8134(u: seq, ys: seq, t: seq)\n ensures (u + ys) + t == u + (ys + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_8135","instance":8135,"id":194806,"goal":"lemma SeqTakeDrop_8135(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_8136","instance":8136,"id":194807,"goal":"lemma SeqReverseLen_8136(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_8137","instance":8137,"id":194808,"goal":"lemma SeqReverseIdem_8137(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_8138","instance":8138,"id":194809,"goal":"lemma SeqMapLen_8138(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_8139","instance":8139,"id":194810,"goal":"lemma SeqFilterLe_8139(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_8140","instance":8140,"id":194811,"goal":"lemma SeqMemberAppend_8140(s: seq, ys: seq)\n ensures x in s + ys <==> x in s || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_8141","instance":8141,"id":194812,"goal":"lemma SeqAppendLen_8141(ys: seq, s: seq)\n ensures |ys + s| == |ys| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_8142","instance":8142,"id":194813,"goal":"lemma SeqAppendNil_8142(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_8143","instance":8143,"id":194814,"goal":"lemma SeqNilAppend_8143(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_8144","instance":8144,"id":194815,"goal":"lemma SeqAppendAssoc_8144(zs: seq, s: seq, ys: seq)\n ensures (zs + s) + ys == zs + (s + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_8145","instance":8145,"id":194816,"goal":"lemma SeqTakeDrop_8145(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_8146","instance":8146,"id":194817,"goal":"lemma SeqReverseLen_8146(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_8147","instance":8147,"id":194818,"goal":"lemma SeqReverseIdem_8147(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_8148","instance":8148,"id":194819,"goal":"lemma SeqMapLen_8148(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_8149","instance":8149,"id":194820,"goal":"lemma SeqFilterLe_8149(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_8150","instance":8150,"id":194821,"goal":"lemma SeqMemberAppend_8150(zs: seq, xs: seq)\n ensures x in zs + xs <==> x in zs || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_8151","instance":8151,"id":194822,"goal":"lemma SeqAppendLen_8151(s: seq, ys: seq)\n ensures |s + ys| == |s| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_8152","instance":8152,"id":194823,"goal":"lemma SeqAppendNil_8152(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_8153","instance":8153,"id":194824,"goal":"lemma SeqNilAppend_8153(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_8154","instance":8154,"id":194825,"goal":"lemma SeqAppendAssoc_8154(ys: seq, u: seq, s: seq)\n ensures (ys + u) + s == ys + (u + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_8155","instance":8155,"id":194826,"goal":"lemma SeqTakeDrop_8155(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_8156","instance":8156,"id":194827,"goal":"lemma SeqReverseLen_8156(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_8157","instance":8157,"id":194828,"goal":"lemma SeqReverseIdem_8157(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_8158","instance":8158,"id":194829,"goal":"lemma SeqMapLen_8158(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_8159","instance":8159,"id":194830,"goal":"lemma SeqFilterLe_8159(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_8160","instance":8160,"id":194831,"goal":"lemma SeqMemberAppend_8160(xs: seq, u: seq)\n ensures x in xs + u <==> x in xs || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_8161","instance":8161,"id":194832,"goal":"lemma SeqAppendLen_8161(zs: seq, xs: seq)\n ensures |zs + xs| == |zs| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_8162","instance":8162,"id":194833,"goal":"lemma SeqAppendNil_8162(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_8163","instance":8163,"id":194834,"goal":"lemma SeqNilAppend_8163(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_8164","instance":8164,"id":194835,"goal":"lemma SeqAppendAssoc_8164(zs: seq, xs: seq, ys: seq)\n ensures (zs + xs) + ys == zs + (xs + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_8165","instance":8165,"id":194836,"goal":"lemma SeqTakeDrop_8165(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_8166","instance":8166,"id":194837,"goal":"lemma SeqReverseLen_8166(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_8167","instance":8167,"id":194838,"goal":"lemma SeqReverseIdem_8167(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_8168","instance":8168,"id":194839,"goal":"lemma SeqMapLen_8168(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_8169","instance":8169,"id":194840,"goal":"lemma SeqFilterLe_8169(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_8170","instance":8170,"id":194841,"goal":"lemma SeqMemberAppend_8170(zs: seq, ys: seq)\n ensures x in zs + ys <==> x in zs || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_8171","instance":8171,"id":194842,"goal":"lemma SeqAppendLen_8171(zs: seq, s: seq)\n ensures |zs + s| == |zs| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_8172","instance":8172,"id":194843,"goal":"lemma SeqAppendNil_8172(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_8173","instance":8173,"id":194844,"goal":"lemma SeqNilAppend_8173(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_8174","instance":8174,"id":194845,"goal":"lemma SeqAppendAssoc_8174(xs: seq, s: seq, u: seq)\n ensures (xs + s) + u == xs + (s + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_8175","instance":8175,"id":194846,"goal":"lemma SeqTakeDrop_8175(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_8176","instance":8176,"id":194847,"goal":"lemma SeqReverseLen_8176(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_8177","instance":8177,"id":194848,"goal":"lemma SeqReverseIdem_8177(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_8178","instance":8178,"id":194849,"goal":"lemma SeqMapLen_8178(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_8179","instance":8179,"id":194850,"goal":"lemma SeqFilterLe_8179(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_8180","instance":8180,"id":194851,"goal":"lemma SeqMemberAppend_8180(xs: seq, s: seq)\n ensures x in xs + s <==> x in xs || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_8181","instance":8181,"id":194852,"goal":"lemma SeqAppendLen_8181(xs: seq, t: seq)\n ensures |xs + t| == |xs| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_8182","instance":8182,"id":194853,"goal":"lemma SeqAppendNil_8182(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_8183","instance":8183,"id":194854,"goal":"lemma SeqNilAppend_8183(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_8184","instance":8184,"id":194855,"goal":"lemma SeqAppendAssoc_8184(t: seq, u: seq, xs: seq)\n ensures (t + u) + xs == t + (u + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_8185","instance":8185,"id":194856,"goal":"lemma SeqTakeDrop_8185(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_8186","instance":8186,"id":194857,"goal":"lemma SeqReverseLen_8186(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_8187","instance":8187,"id":194858,"goal":"lemma SeqReverseIdem_8187(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_8188","instance":8188,"id":194859,"goal":"lemma SeqMapLen_8188(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_8189","instance":8189,"id":194860,"goal":"lemma SeqFilterLe_8189(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_8190","instance":8190,"id":194861,"goal":"lemma SeqMemberAppend_8190(s: seq, zs: seq)\n ensures x in s + zs <==> x in s || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_8191","instance":8191,"id":194862,"goal":"lemma SeqAppendLen_8191(u: seq, zs: seq)\n ensures |u + zs| == |u| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_8192","instance":8192,"id":194863,"goal":"lemma SeqAppendNil_8192(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_8193","instance":8193,"id":194864,"goal":"lemma SeqNilAppend_8193(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_8194","instance":8194,"id":194865,"goal":"lemma SeqAppendAssoc_8194(t: seq, u: seq, ys: seq)\n ensures (t + u) + ys == t + (u + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_8195","instance":8195,"id":194866,"goal":"lemma SeqTakeDrop_8195(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_8196","instance":8196,"id":194867,"goal":"lemma SeqReverseLen_8196(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_8197","instance":8197,"id":194868,"goal":"lemma SeqReverseIdem_8197(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_8198","instance":8198,"id":194869,"goal":"lemma SeqMapLen_8198(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_8199","instance":8199,"id":194870,"goal":"lemma SeqFilterLe_8199(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_8200","instance":8200,"id":194871,"goal":"lemma SeqMemberAppend_8200(u: seq, xs: seq)\n ensures x in u + xs <==> x in u || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_8201","instance":8201,"id":194872,"goal":"lemma SeqAppendLen_8201(ys: seq, u: seq)\n ensures |ys + u| == |ys| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_8202","instance":8202,"id":194873,"goal":"lemma SeqAppendNil_8202(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_8203","instance":8203,"id":194874,"goal":"lemma SeqNilAppend_8203(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_8204","instance":8204,"id":194875,"goal":"lemma SeqAppendAssoc_8204(t: seq, s: seq, ys: seq)\n ensures (t + s) + ys == t + (s + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_8205","instance":8205,"id":194876,"goal":"lemma SeqTakeDrop_8205(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_8206","instance":8206,"id":194877,"goal":"lemma SeqReverseLen_8206(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_8207","instance":8207,"id":194878,"goal":"lemma SeqReverseIdem_8207(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_8208","instance":8208,"id":194879,"goal":"lemma SeqMapLen_8208(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_8209","instance":8209,"id":194880,"goal":"lemma SeqFilterLe_8209(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_8210","instance":8210,"id":194881,"goal":"lemma SeqMemberAppend_8210(zs: seq, xs: seq)\n ensures x in zs + xs <==> x in zs || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_8211","instance":8211,"id":194882,"goal":"lemma SeqAppendLen_8211(zs: seq, xs: seq)\n ensures |zs + xs| == |zs| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_8212","instance":8212,"id":194883,"goal":"lemma SeqAppendNil_8212(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_8213","instance":8213,"id":194884,"goal":"lemma SeqNilAppend_8213(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_8214","instance":8214,"id":194885,"goal":"lemma SeqAppendAssoc_8214(zs: seq, s: seq, t: seq)\n ensures (zs + s) + t == zs + (s + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_8215","instance":8215,"id":194886,"goal":"lemma SeqTakeDrop_8215(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_8216","instance":8216,"id":194887,"goal":"lemma SeqReverseLen_8216(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_8217","instance":8217,"id":194888,"goal":"lemma SeqReverseIdem_8217(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_8218","instance":8218,"id":194889,"goal":"lemma SeqMapLen_8218(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_8219","instance":8219,"id":194890,"goal":"lemma SeqFilterLe_8219(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_8220","instance":8220,"id":194891,"goal":"lemma SeqMemberAppend_8220(t: seq, s: seq)\n ensures x in t + s <==> x in t || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_8221","instance":8221,"id":194892,"goal":"lemma SeqAppendLen_8221(zs: seq, u: seq)\n ensures |zs + u| == |zs| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_8222","instance":8222,"id":194893,"goal":"lemma SeqAppendNil_8222(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_8223","instance":8223,"id":194894,"goal":"lemma SeqNilAppend_8223(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_8224","instance":8224,"id":194895,"goal":"lemma SeqAppendAssoc_8224(u: seq, t: seq, zs: seq)\n ensures (u + t) + zs == u + (t + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_8225","instance":8225,"id":194896,"goal":"lemma SeqTakeDrop_8225(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_8226","instance":8226,"id":194897,"goal":"lemma SeqReverseLen_8226(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_8227","instance":8227,"id":194898,"goal":"lemma SeqReverseIdem_8227(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_8228","instance":8228,"id":194899,"goal":"lemma SeqMapLen_8228(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_8229","instance":8229,"id":194900,"goal":"lemma SeqFilterLe_8229(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_8230","instance":8230,"id":194901,"goal":"lemma SeqMemberAppend_8230(xs: seq, ys: seq)\n ensures x in xs + ys <==> x in xs || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_8231","instance":8231,"id":194902,"goal":"lemma SeqAppendLen_8231(u: seq, t: seq)\n ensures |u + t| == |u| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_8232","instance":8232,"id":194903,"goal":"lemma SeqAppendNil_8232(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_8233","instance":8233,"id":194904,"goal":"lemma SeqNilAppend_8233(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_8234","instance":8234,"id":194905,"goal":"lemma SeqAppendAssoc_8234(s: seq, t: seq, xs: seq)\n ensures (s + t) + xs == s + (t + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_8235","instance":8235,"id":194906,"goal":"lemma SeqTakeDrop_8235(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_8236","instance":8236,"id":194907,"goal":"lemma SeqReverseLen_8236(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_8237","instance":8237,"id":194908,"goal":"lemma SeqReverseIdem_8237(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_8238","instance":8238,"id":194909,"goal":"lemma SeqMapLen_8238(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_8239","instance":8239,"id":194910,"goal":"lemma SeqFilterLe_8239(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_8240","instance":8240,"id":194911,"goal":"lemma SeqMemberAppend_8240(xs: seq, t: seq)\n ensures x in xs + t <==> x in xs || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_8241","instance":8241,"id":194912,"goal":"lemma SeqAppendLen_8241(s: seq, zs: seq)\n ensures |s + zs| == |s| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_8242","instance":8242,"id":194913,"goal":"lemma SeqAppendNil_8242(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_8243","instance":8243,"id":194914,"goal":"lemma SeqNilAppend_8243(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_8244","instance":8244,"id":194915,"goal":"lemma SeqAppendAssoc_8244(ys: seq, zs: seq, s: seq)\n ensures (ys + zs) + s == ys + (zs + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_8245","instance":8245,"id":194916,"goal":"lemma SeqTakeDrop_8245(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_8246","instance":8246,"id":194917,"goal":"lemma SeqReverseLen_8246(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_8247","instance":8247,"id":194918,"goal":"lemma SeqReverseIdem_8247(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_8248","instance":8248,"id":194919,"goal":"lemma SeqMapLen_8248(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_8249","instance":8249,"id":194920,"goal":"lemma SeqFilterLe_8249(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_8250","instance":8250,"id":194921,"goal":"lemma SeqMemberAppend_8250(s: seq, xs: seq)\n ensures x in s + xs <==> x in s || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_8251","instance":8251,"id":194922,"goal":"lemma SeqAppendLen_8251(s: seq, t: seq)\n ensures |s + t| == |s| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_8252","instance":8252,"id":194923,"goal":"lemma SeqAppendNil_8252(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_8253","instance":8253,"id":194924,"goal":"lemma SeqNilAppend_8253(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_8254","instance":8254,"id":194925,"goal":"lemma SeqAppendAssoc_8254(s: seq, zs: seq, t: seq)\n ensures (s + zs) + t == s + (zs + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_8255","instance":8255,"id":194926,"goal":"lemma SeqTakeDrop_8255(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_8256","instance":8256,"id":194927,"goal":"lemma SeqReverseLen_8256(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_8257","instance":8257,"id":194928,"goal":"lemma SeqReverseIdem_8257(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_8258","instance":8258,"id":194929,"goal":"lemma SeqMapLen_8258(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_8259","instance":8259,"id":194930,"goal":"lemma SeqFilterLe_8259(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_8260","instance":8260,"id":194931,"goal":"lemma SeqMemberAppend_8260(u: seq, ys: seq)\n ensures x in u + ys <==> x in u || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_8261","instance":8261,"id":194932,"goal":"lemma SeqAppendLen_8261(t: seq, s: seq)\n ensures |t + s| == |t| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_8262","instance":8262,"id":194933,"goal":"lemma SeqAppendNil_8262(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_8263","instance":8263,"id":194934,"goal":"lemma SeqNilAppend_8263(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_8264","instance":8264,"id":194935,"goal":"lemma SeqAppendAssoc_8264(s: seq, ys: seq, xs: seq)\n ensures (s + ys) + xs == s + (ys + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_8265","instance":8265,"id":194936,"goal":"lemma SeqTakeDrop_8265(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_8266","instance":8266,"id":194937,"goal":"lemma SeqReverseLen_8266(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_8267","instance":8267,"id":194938,"goal":"lemma SeqReverseIdem_8267(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_8268","instance":8268,"id":194939,"goal":"lemma SeqMapLen_8268(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_8269","instance":8269,"id":194940,"goal":"lemma SeqFilterLe_8269(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_8270","instance":8270,"id":194941,"goal":"lemma SeqMemberAppend_8270(xs: seq, ys: seq)\n ensures x in xs + ys <==> x in xs || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_8271","instance":8271,"id":194942,"goal":"lemma SeqAppendLen_8271(xs: seq, zs: seq)\n ensures |xs + zs| == |xs| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_8272","instance":8272,"id":194943,"goal":"lemma SeqAppendNil_8272(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_8273","instance":8273,"id":194944,"goal":"lemma SeqNilAppend_8273(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_8274","instance":8274,"id":194945,"goal":"lemma SeqAppendAssoc_8274(ys: seq, zs: seq, s: seq)\n ensures (ys + zs) + s == ys + (zs + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_8275","instance":8275,"id":194946,"goal":"lemma SeqTakeDrop_8275(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_8276","instance":8276,"id":194947,"goal":"lemma SeqReverseLen_8276(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_8277","instance":8277,"id":194948,"goal":"lemma SeqReverseIdem_8277(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_8278","instance":8278,"id":194949,"goal":"lemma SeqMapLen_8278(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_8279","instance":8279,"id":194950,"goal":"lemma SeqFilterLe_8279(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_8280","instance":8280,"id":194951,"goal":"lemma SeqMemberAppend_8280(t: seq, u: seq)\n ensures x in t + u <==> x in t || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_8281","instance":8281,"id":194952,"goal":"lemma SeqAppendLen_8281(ys: seq, zs: seq)\n ensures |ys + zs| == |ys| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_8282","instance":8282,"id":194953,"goal":"lemma SeqAppendNil_8282(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_8283","instance":8283,"id":194954,"goal":"lemma SeqNilAppend_8283(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_8284","instance":8284,"id":194955,"goal":"lemma SeqAppendAssoc_8284(ys: seq, u: seq, t: seq)\n ensures (ys + u) + t == ys + (u + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_8285","instance":8285,"id":194956,"goal":"lemma SeqTakeDrop_8285(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_8286","instance":8286,"id":194957,"goal":"lemma SeqReverseLen_8286(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_8287","instance":8287,"id":194958,"goal":"lemma SeqReverseIdem_8287(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_8288","instance":8288,"id":194959,"goal":"lemma SeqMapLen_8288(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_8289","instance":8289,"id":194960,"goal":"lemma SeqFilterLe_8289(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_8290","instance":8290,"id":194961,"goal":"lemma SeqMemberAppend_8290(xs: seq, ys: seq)\n ensures x in xs + ys <==> x in xs || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_8291","instance":8291,"id":194962,"goal":"lemma SeqAppendLen_8291(u: seq, zs: seq)\n ensures |u + zs| == |u| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_8292","instance":8292,"id":194963,"goal":"lemma SeqAppendNil_8292(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_8293","instance":8293,"id":194964,"goal":"lemma SeqNilAppend_8293(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_8294","instance":8294,"id":194965,"goal":"lemma SeqAppendAssoc_8294(t: seq, s: seq, zs: seq)\n ensures (t + s) + zs == t + (s + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_8295","instance":8295,"id":194966,"goal":"lemma SeqTakeDrop_8295(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_8296","instance":8296,"id":194967,"goal":"lemma SeqReverseLen_8296(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_8297","instance":8297,"id":194968,"goal":"lemma SeqReverseIdem_8297(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_8298","instance":8298,"id":194969,"goal":"lemma SeqMapLen_8298(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_8299","instance":8299,"id":194970,"goal":"lemma SeqFilterLe_8299(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_8300","instance":8300,"id":194971,"goal":"lemma SeqMemberAppend_8300(u: seq, zs: seq)\n ensures x in u + zs <==> x in u || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_8301","instance":8301,"id":194972,"goal":"lemma SeqAppendLen_8301(xs: seq, t: seq)\n ensures |xs + t| == |xs| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_8302","instance":8302,"id":194973,"goal":"lemma SeqAppendNil_8302(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_8303","instance":8303,"id":194974,"goal":"lemma SeqNilAppend_8303(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_8304","instance":8304,"id":194975,"goal":"lemma SeqAppendAssoc_8304(u: seq, ys: seq, t: seq)\n ensures (u + ys) + t == u + (ys + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_8305","instance":8305,"id":194976,"goal":"lemma SeqTakeDrop_8305(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_8306","instance":8306,"id":194977,"goal":"lemma SeqReverseLen_8306(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_8307","instance":8307,"id":194978,"goal":"lemma SeqReverseIdem_8307(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_8308","instance":8308,"id":194979,"goal":"lemma SeqMapLen_8308(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_8309","instance":8309,"id":194980,"goal":"lemma SeqFilterLe_8309(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_8310","instance":8310,"id":194981,"goal":"lemma SeqMemberAppend_8310(u: seq, ys: seq)\n ensures x in u + ys <==> x in u || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_8311","instance":8311,"id":194982,"goal":"lemma SeqAppendLen_8311(t: seq, xs: seq)\n ensures |t + xs| == |t| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_8312","instance":8312,"id":194983,"goal":"lemma SeqAppendNil_8312(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_8313","instance":8313,"id":194984,"goal":"lemma SeqNilAppend_8313(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_8314","instance":8314,"id":194985,"goal":"lemma SeqAppendAssoc_8314(ys: seq, u: seq, t: seq)\n ensures (ys + u) + t == ys + (u + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_8315","instance":8315,"id":194986,"goal":"lemma SeqTakeDrop_8315(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_8316","instance":8316,"id":194987,"goal":"lemma SeqReverseLen_8316(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_8317","instance":8317,"id":194988,"goal":"lemma SeqReverseIdem_8317(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_8318","instance":8318,"id":194989,"goal":"lemma SeqMapLen_8318(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_8319","instance":8319,"id":194990,"goal":"lemma SeqFilterLe_8319(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_8320","instance":8320,"id":194991,"goal":"lemma SeqMemberAppend_8320(xs: seq, t: seq)\n ensures x in xs + t <==> x in xs || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_8321","instance":8321,"id":194992,"goal":"lemma SeqAppendLen_8321(ys: seq, t: seq)\n ensures |ys + t| == |ys| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_8322","instance":8322,"id":194993,"goal":"lemma SeqAppendNil_8322(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_8323","instance":8323,"id":194994,"goal":"lemma SeqNilAppend_8323(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_8324","instance":8324,"id":194995,"goal":"lemma SeqAppendAssoc_8324(xs: seq, u: seq, s: seq)\n ensures (xs + u) + s == xs + (u + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_8325","instance":8325,"id":194996,"goal":"lemma SeqTakeDrop_8325(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_8326","instance":8326,"id":194997,"goal":"lemma SeqReverseLen_8326(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_8327","instance":8327,"id":194998,"goal":"lemma SeqReverseIdem_8327(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_8328","instance":8328,"id":194999,"goal":"lemma SeqMapLen_8328(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_8329","instance":8329,"id":195000,"goal":"lemma SeqFilterLe_8329(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_8330","instance":8330,"id":195001,"goal":"lemma SeqMemberAppend_8330(ys: seq, zs: seq)\n ensures x in ys + zs <==> x in ys || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_8331","instance":8331,"id":195002,"goal":"lemma SeqAppendLen_8331(u: seq, ys: seq)\n ensures |u + ys| == |u| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_8332","instance":8332,"id":195003,"goal":"lemma SeqAppendNil_8332(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_8333","instance":8333,"id":195004,"goal":"lemma SeqNilAppend_8333(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_8334","instance":8334,"id":195005,"goal":"lemma SeqAppendAssoc_8334(t: seq, xs: seq, u: seq)\n ensures (t + xs) + u == t + (xs + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_8335","instance":8335,"id":195006,"goal":"lemma SeqTakeDrop_8335(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_8336","instance":8336,"id":195007,"goal":"lemma SeqReverseLen_8336(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_8337","instance":8337,"id":195008,"goal":"lemma SeqReverseIdem_8337(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_8338","instance":8338,"id":195009,"goal":"lemma SeqMapLen_8338(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_8339","instance":8339,"id":195010,"goal":"lemma SeqFilterLe_8339(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_8340","instance":8340,"id":195011,"goal":"lemma SeqMemberAppend_8340(xs: seq, ys: seq)\n ensures x in xs + ys <==> x in xs || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_8341","instance":8341,"id":195012,"goal":"lemma SeqAppendLen_8341(s: seq, t: seq)\n ensures |s + t| == |s| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_8342","instance":8342,"id":195013,"goal":"lemma SeqAppendNil_8342(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_8343","instance":8343,"id":195014,"goal":"lemma SeqNilAppend_8343(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_8344","instance":8344,"id":195015,"goal":"lemma SeqAppendAssoc_8344(ys: seq, u: seq, zs: seq)\n ensures (ys + u) + zs == ys + (u + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_8345","instance":8345,"id":195016,"goal":"lemma SeqTakeDrop_8345(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_8346","instance":8346,"id":195017,"goal":"lemma SeqReverseLen_8346(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_8347","instance":8347,"id":195018,"goal":"lemma SeqReverseIdem_8347(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_8348","instance":8348,"id":195019,"goal":"lemma SeqMapLen_8348(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_8349","instance":8349,"id":195020,"goal":"lemma SeqFilterLe_8349(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_8350","instance":8350,"id":195021,"goal":"lemma SeqMemberAppend_8350(s: seq, t: seq)\n ensures x in s + t <==> x in s || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_8351","instance":8351,"id":195022,"goal":"lemma SeqAppendLen_8351(u: seq, s: seq)\n ensures |u + s| == |u| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_8352","instance":8352,"id":195023,"goal":"lemma SeqAppendNil_8352(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_8353","instance":8353,"id":195024,"goal":"lemma SeqNilAppend_8353(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_8354","instance":8354,"id":195025,"goal":"lemma SeqAppendAssoc_8354(t: seq, xs: seq, ys: seq)\n ensures (t + xs) + ys == t + (xs + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_8355","instance":8355,"id":195026,"goal":"lemma SeqTakeDrop_8355(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_8356","instance":8356,"id":195027,"goal":"lemma SeqReverseLen_8356(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_8357","instance":8357,"id":195028,"goal":"lemma SeqReverseIdem_8357(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_8358","instance":8358,"id":195029,"goal":"lemma SeqMapLen_8358(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_8359","instance":8359,"id":195030,"goal":"lemma SeqFilterLe_8359(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_8360","instance":8360,"id":195031,"goal":"lemma SeqMemberAppend_8360(zs: seq, xs: seq)\n ensures x in zs + xs <==> x in zs || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_8361","instance":8361,"id":195032,"goal":"lemma SeqAppendLen_8361(u: seq, s: seq)\n ensures |u + s| == |u| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_8362","instance":8362,"id":195033,"goal":"lemma SeqAppendNil_8362(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_8363","instance":8363,"id":195034,"goal":"lemma SeqNilAppend_8363(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_8364","instance":8364,"id":195035,"goal":"lemma SeqAppendAssoc_8364(s: seq, ys: seq, xs: seq)\n ensures (s + ys) + xs == s + (ys + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_8365","instance":8365,"id":195036,"goal":"lemma SeqTakeDrop_8365(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_8366","instance":8366,"id":195037,"goal":"lemma SeqReverseLen_8366(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_8367","instance":8367,"id":195038,"goal":"lemma SeqReverseIdem_8367(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_8368","instance":8368,"id":195039,"goal":"lemma SeqMapLen_8368(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_8369","instance":8369,"id":195040,"goal":"lemma SeqFilterLe_8369(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_8370","instance":8370,"id":195041,"goal":"lemma SeqMemberAppend_8370(ys: seq, s: seq)\n ensures x in ys + s <==> x in ys || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_8371","instance":8371,"id":195042,"goal":"lemma SeqAppendLen_8371(t: seq, ys: seq)\n ensures |t + ys| == |t| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_8372","instance":8372,"id":195043,"goal":"lemma SeqAppendNil_8372(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_8373","instance":8373,"id":195044,"goal":"lemma SeqNilAppend_8373(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_8374","instance":8374,"id":195045,"goal":"lemma SeqAppendAssoc_8374(ys: seq, t: seq, s: seq)\n ensures (ys + t) + s == ys + (t + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_8375","instance":8375,"id":195046,"goal":"lemma SeqTakeDrop_8375(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_8376","instance":8376,"id":195047,"goal":"lemma SeqReverseLen_8376(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_8377","instance":8377,"id":195048,"goal":"lemma SeqReverseIdem_8377(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_8378","instance":8378,"id":195049,"goal":"lemma SeqMapLen_8378(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_8379","instance":8379,"id":195050,"goal":"lemma SeqFilterLe_8379(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_8380","instance":8380,"id":195051,"goal":"lemma SeqMemberAppend_8380(ys: seq, s: seq)\n ensures x in ys + s <==> x in ys || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_8381","instance":8381,"id":195052,"goal":"lemma SeqAppendLen_8381(xs: seq, t: seq)\n ensures |xs + t| == |xs| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_8382","instance":8382,"id":195053,"goal":"lemma SeqAppendNil_8382(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_8383","instance":8383,"id":195054,"goal":"lemma SeqNilAppend_8383(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_8384","instance":8384,"id":195055,"goal":"lemma SeqAppendAssoc_8384(u: seq, ys: seq, xs: seq)\n ensures (u + ys) + xs == u + (ys + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_8385","instance":8385,"id":195056,"goal":"lemma SeqTakeDrop_8385(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_8386","instance":8386,"id":195057,"goal":"lemma SeqReverseLen_8386(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_8387","instance":8387,"id":195058,"goal":"lemma SeqReverseIdem_8387(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_8388","instance":8388,"id":195059,"goal":"lemma SeqMapLen_8388(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_8389","instance":8389,"id":195060,"goal":"lemma SeqFilterLe_8389(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_8390","instance":8390,"id":195061,"goal":"lemma SeqMemberAppend_8390(t: seq, xs: seq)\n ensures x in t + xs <==> x in t || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_8391","instance":8391,"id":195062,"goal":"lemma SeqAppendLen_8391(t: seq, zs: seq)\n ensures |t + zs| == |t| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_8392","instance":8392,"id":195063,"goal":"lemma SeqAppendNil_8392(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_8393","instance":8393,"id":195064,"goal":"lemma SeqNilAppend_8393(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_8394","instance":8394,"id":195065,"goal":"lemma SeqAppendAssoc_8394(t: seq, ys: seq, s: seq)\n ensures (t + ys) + s == t + (ys + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_8395","instance":8395,"id":195066,"goal":"lemma SeqTakeDrop_8395(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_8396","instance":8396,"id":195067,"goal":"lemma SeqReverseLen_8396(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_8397","instance":8397,"id":195068,"goal":"lemma SeqReverseIdem_8397(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_8398","instance":8398,"id":195069,"goal":"lemma SeqMapLen_8398(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_8399","instance":8399,"id":195070,"goal":"lemma SeqFilterLe_8399(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_8400","instance":8400,"id":195071,"goal":"lemma SeqMemberAppend_8400(zs: seq, u: seq)\n ensures x in zs + u <==> x in zs || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_8401","instance":8401,"id":195072,"goal":"lemma SeqAppendLen_8401(xs: seq, s: seq)\n ensures |xs + s| == |xs| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_8402","instance":8402,"id":195073,"goal":"lemma SeqAppendNil_8402(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_8403","instance":8403,"id":195074,"goal":"lemma SeqNilAppend_8403(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_8404","instance":8404,"id":195075,"goal":"lemma SeqAppendAssoc_8404(xs: seq, u: seq, t: seq)\n ensures (xs + u) + t == xs + (u + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_8405","instance":8405,"id":195076,"goal":"lemma SeqTakeDrop_8405(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_8406","instance":8406,"id":195077,"goal":"lemma SeqReverseLen_8406(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_8407","instance":8407,"id":195078,"goal":"lemma SeqReverseIdem_8407(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_8408","instance":8408,"id":195079,"goal":"lemma SeqMapLen_8408(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_8409","instance":8409,"id":195080,"goal":"lemma SeqFilterLe_8409(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_8410","instance":8410,"id":195081,"goal":"lemma SeqMemberAppend_8410(ys: seq, s: seq)\n ensures x in ys + s <==> x in ys || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_8411","instance":8411,"id":195082,"goal":"lemma SeqAppendLen_8411(u: seq, ys: seq)\n ensures |u + ys| == |u| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_8412","instance":8412,"id":195083,"goal":"lemma SeqAppendNil_8412(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_8413","instance":8413,"id":195084,"goal":"lemma SeqNilAppend_8413(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_8414","instance":8414,"id":195085,"goal":"lemma SeqAppendAssoc_8414(t: seq, s: seq, zs: seq)\n ensures (t + s) + zs == t + (s + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_8415","instance":8415,"id":195086,"goal":"lemma SeqTakeDrop_8415(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_8416","instance":8416,"id":195087,"goal":"lemma SeqReverseLen_8416(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_8417","instance":8417,"id":195088,"goal":"lemma SeqReverseIdem_8417(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_8418","instance":8418,"id":195089,"goal":"lemma SeqMapLen_8418(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_8419","instance":8419,"id":195090,"goal":"lemma SeqFilterLe_8419(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_8420","instance":8420,"id":195091,"goal":"lemma SeqMemberAppend_8420(t: seq, ys: seq)\n ensures x in t + ys <==> x in t || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_8421","instance":8421,"id":195092,"goal":"lemma SeqAppendLen_8421(u: seq, t: seq)\n ensures |u + t| == |u| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_8422","instance":8422,"id":195093,"goal":"lemma SeqAppendNil_8422(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_8423","instance":8423,"id":195094,"goal":"lemma SeqNilAppend_8423(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_8424","instance":8424,"id":195095,"goal":"lemma SeqAppendAssoc_8424(t: seq, xs: seq, zs: seq)\n ensures (t + xs) + zs == t + (xs + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_8425","instance":8425,"id":195096,"goal":"lemma SeqTakeDrop_8425(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_8426","instance":8426,"id":195097,"goal":"lemma SeqReverseLen_8426(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_8427","instance":8427,"id":195098,"goal":"lemma SeqReverseIdem_8427(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_8428","instance":8428,"id":195099,"goal":"lemma SeqMapLen_8428(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_8429","instance":8429,"id":195100,"goal":"lemma SeqFilterLe_8429(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_8430","instance":8430,"id":195101,"goal":"lemma SeqMemberAppend_8430(zs: seq, u: seq)\n ensures x in zs + u <==> x in zs || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_8431","instance":8431,"id":195102,"goal":"lemma SeqAppendLen_8431(u: seq, ys: seq)\n ensures |u + ys| == |u| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_8432","instance":8432,"id":195103,"goal":"lemma SeqAppendNil_8432(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_8433","instance":8433,"id":195104,"goal":"lemma SeqNilAppend_8433(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_8434","instance":8434,"id":195105,"goal":"lemma SeqAppendAssoc_8434(xs: seq, ys: seq, zs: seq)\n ensures (xs + ys) + zs == xs + (ys + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_8435","instance":8435,"id":195106,"goal":"lemma SeqTakeDrop_8435(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_8436","instance":8436,"id":195107,"goal":"lemma SeqReverseLen_8436(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_8437","instance":8437,"id":195108,"goal":"lemma SeqReverseIdem_8437(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_8438","instance":8438,"id":195109,"goal":"lemma SeqMapLen_8438(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_8439","instance":8439,"id":195110,"goal":"lemma SeqFilterLe_8439(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_8440","instance":8440,"id":195111,"goal":"lemma SeqMemberAppend_8440(s: seq, u: seq)\n ensures x in s + u <==> x in s || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_8441","instance":8441,"id":195112,"goal":"lemma SeqAppendLen_8441(ys: seq, xs: seq)\n ensures |ys + xs| == |ys| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_8442","instance":8442,"id":195113,"goal":"lemma SeqAppendNil_8442(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_8443","instance":8443,"id":195114,"goal":"lemma SeqNilAppend_8443(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_8444","instance":8444,"id":195115,"goal":"lemma SeqAppendAssoc_8444(s: seq, t: seq, zs: seq)\n ensures (s + t) + zs == s + (t + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_8445","instance":8445,"id":195116,"goal":"lemma SeqTakeDrop_8445(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_8446","instance":8446,"id":195117,"goal":"lemma SeqReverseLen_8446(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_8447","instance":8447,"id":195118,"goal":"lemma SeqReverseIdem_8447(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_8448","instance":8448,"id":195119,"goal":"lemma SeqMapLen_8448(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_8449","instance":8449,"id":195120,"goal":"lemma SeqFilterLe_8449(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_8450","instance":8450,"id":195121,"goal":"lemma SeqMemberAppend_8450(xs: seq, s: seq)\n ensures x in xs + s <==> x in xs || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_8451","instance":8451,"id":195122,"goal":"lemma SeqAppendLen_8451(s: seq, zs: seq)\n ensures |s + zs| == |s| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_8452","instance":8452,"id":195123,"goal":"lemma SeqAppendNil_8452(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_8453","instance":8453,"id":195124,"goal":"lemma SeqNilAppend_8453(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_8454","instance":8454,"id":195125,"goal":"lemma SeqAppendAssoc_8454(zs: seq, u: seq, xs: seq)\n ensures (zs + u) + xs == zs + (u + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_8455","instance":8455,"id":195126,"goal":"lemma SeqTakeDrop_8455(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_8456","instance":8456,"id":195127,"goal":"lemma SeqReverseLen_8456(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_8457","instance":8457,"id":195128,"goal":"lemma SeqReverseIdem_8457(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_8458","instance":8458,"id":195129,"goal":"lemma SeqMapLen_8458(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_8459","instance":8459,"id":195130,"goal":"lemma SeqFilterLe_8459(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_8460","instance":8460,"id":195131,"goal":"lemma SeqMemberAppend_8460(t: seq, u: seq)\n ensures x in t + u <==> x in t || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_8461","instance":8461,"id":195132,"goal":"lemma SeqAppendLen_8461(u: seq, t: seq)\n ensures |u + t| == |u| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_8462","instance":8462,"id":195133,"goal":"lemma SeqAppendNil_8462(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_8463","instance":8463,"id":195134,"goal":"lemma SeqNilAppend_8463(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_8464","instance":8464,"id":195135,"goal":"lemma SeqAppendAssoc_8464(u: seq, s: seq, zs: seq)\n ensures (u + s) + zs == u + (s + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_8465","instance":8465,"id":195136,"goal":"lemma SeqTakeDrop_8465(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_8466","instance":8466,"id":195137,"goal":"lemma SeqReverseLen_8466(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_8467","instance":8467,"id":195138,"goal":"lemma SeqReverseIdem_8467(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_8468","instance":8468,"id":195139,"goal":"lemma SeqMapLen_8468(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_8469","instance":8469,"id":195140,"goal":"lemma SeqFilterLe_8469(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_8470","instance":8470,"id":195141,"goal":"lemma SeqMemberAppend_8470(ys: seq, xs: seq)\n ensures x in ys + xs <==> x in ys || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_8471","instance":8471,"id":195142,"goal":"lemma SeqAppendLen_8471(zs: seq, ys: seq)\n ensures |zs + ys| == |zs| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_8472","instance":8472,"id":195143,"goal":"lemma SeqAppendNil_8472(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_8473","instance":8473,"id":195144,"goal":"lemma SeqNilAppend_8473(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_8474","instance":8474,"id":195145,"goal":"lemma SeqAppendAssoc_8474(t: seq, xs: seq, zs: seq)\n ensures (t + xs) + zs == t + (xs + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_8475","instance":8475,"id":195146,"goal":"lemma SeqTakeDrop_8475(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_8476","instance":8476,"id":195147,"goal":"lemma SeqReverseLen_8476(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_8477","instance":8477,"id":195148,"goal":"lemma SeqReverseIdem_8477(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_8478","instance":8478,"id":195149,"goal":"lemma SeqMapLen_8478(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_8479","instance":8479,"id":195150,"goal":"lemma SeqFilterLe_8479(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_8480","instance":8480,"id":195151,"goal":"lemma SeqMemberAppend_8480(s: seq, zs: seq)\n ensures x in s + zs <==> x in s || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_8481","instance":8481,"id":195152,"goal":"lemma SeqAppendLen_8481(xs: seq, t: seq)\n ensures |xs + t| == |xs| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_8482","instance":8482,"id":195153,"goal":"lemma SeqAppendNil_8482(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_8483","instance":8483,"id":195154,"goal":"lemma SeqNilAppend_8483(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_8484","instance":8484,"id":195155,"goal":"lemma SeqAppendAssoc_8484(ys: seq, s: seq, xs: seq)\n ensures (ys + s) + xs == ys + (s + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_8485","instance":8485,"id":195156,"goal":"lemma SeqTakeDrop_8485(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_8486","instance":8486,"id":195157,"goal":"lemma SeqReverseLen_8486(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_8487","instance":8487,"id":195158,"goal":"lemma SeqReverseIdem_8487(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_8488","instance":8488,"id":195159,"goal":"lemma SeqMapLen_8488(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_8489","instance":8489,"id":195160,"goal":"lemma SeqFilterLe_8489(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_8490","instance":8490,"id":195161,"goal":"lemma SeqMemberAppend_8490(u: seq, xs: seq)\n ensures x in u + xs <==> x in u || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_8491","instance":8491,"id":195162,"goal":"lemma SeqAppendLen_8491(zs: seq, xs: seq)\n ensures |zs + xs| == |zs| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_8492","instance":8492,"id":195163,"goal":"lemma SeqAppendNil_8492(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_8493","instance":8493,"id":195164,"goal":"lemma SeqNilAppend_8493(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_8494","instance":8494,"id":195165,"goal":"lemma SeqAppendAssoc_8494(ys: seq, t: seq, zs: seq)\n ensures (ys + t) + zs == ys + (t + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_8495","instance":8495,"id":195166,"goal":"lemma SeqTakeDrop_8495(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_8496","instance":8496,"id":195167,"goal":"lemma SeqReverseLen_8496(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_8497","instance":8497,"id":195168,"goal":"lemma SeqReverseIdem_8497(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_8498","instance":8498,"id":195169,"goal":"lemma SeqMapLen_8498(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_8499","instance":8499,"id":195170,"goal":"lemma SeqFilterLe_8499(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_8500","instance":8500,"id":195171,"goal":"lemma SeqMemberAppend_8500(t: seq, ys: seq)\n ensures x in t + ys <==> x in t || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_8501","instance":8501,"id":195172,"goal":"lemma SeqAppendLen_8501(u: seq, s: seq)\n ensures |u + s| == |u| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_8502","instance":8502,"id":195173,"goal":"lemma SeqAppendNil_8502(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_8503","instance":8503,"id":195174,"goal":"lemma SeqNilAppend_8503(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_8504","instance":8504,"id":195175,"goal":"lemma SeqAppendAssoc_8504(xs: seq, zs: seq, ys: seq)\n ensures (xs + zs) + ys == xs + (zs + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_8505","instance":8505,"id":195176,"goal":"lemma SeqTakeDrop_8505(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_8506","instance":8506,"id":195177,"goal":"lemma SeqReverseLen_8506(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_8507","instance":8507,"id":195178,"goal":"lemma SeqReverseIdem_8507(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_8508","instance":8508,"id":195179,"goal":"lemma SeqMapLen_8508(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_8509","instance":8509,"id":195180,"goal":"lemma SeqFilterLe_8509(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_8510","instance":8510,"id":195181,"goal":"lemma SeqMemberAppend_8510(t: seq, ys: seq)\n ensures x in t + ys <==> x in t || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_8511","instance":8511,"id":195182,"goal":"lemma SeqAppendLen_8511(u: seq, t: seq)\n ensures |u + t| == |u| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_8512","instance":8512,"id":195183,"goal":"lemma SeqAppendNil_8512(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_8513","instance":8513,"id":195184,"goal":"lemma SeqNilAppend_8513(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_8514","instance":8514,"id":195185,"goal":"lemma SeqAppendAssoc_8514(ys: seq, s: seq, zs: seq)\n ensures (ys + s) + zs == ys + (s + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_8515","instance":8515,"id":195186,"goal":"lemma SeqTakeDrop_8515(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_8516","instance":8516,"id":195187,"goal":"lemma SeqReverseLen_8516(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_8517","instance":8517,"id":195188,"goal":"lemma SeqReverseIdem_8517(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_8518","instance":8518,"id":195189,"goal":"lemma SeqMapLen_8518(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_8519","instance":8519,"id":195190,"goal":"lemma SeqFilterLe_8519(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_8520","instance":8520,"id":195191,"goal":"lemma SeqMemberAppend_8520(ys: seq, s: seq)\n ensures x in ys + s <==> x in ys || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_8521","instance":8521,"id":195192,"goal":"lemma SeqAppendLen_8521(u: seq, xs: seq)\n ensures |u + xs| == |u| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_8522","instance":8522,"id":195193,"goal":"lemma SeqAppendNil_8522(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_8523","instance":8523,"id":195194,"goal":"lemma SeqNilAppend_8523(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_8524","instance":8524,"id":195195,"goal":"lemma SeqAppendAssoc_8524(u: seq, ys: seq, t: seq)\n ensures (u + ys) + t == u + (ys + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_8525","instance":8525,"id":195196,"goal":"lemma SeqTakeDrop_8525(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_8526","instance":8526,"id":195197,"goal":"lemma SeqReverseLen_8526(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_8527","instance":8527,"id":195198,"goal":"lemma SeqReverseIdem_8527(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_8528","instance":8528,"id":195199,"goal":"lemma SeqMapLen_8528(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_8529","instance":8529,"id":195200,"goal":"lemma SeqFilterLe_8529(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_8530","instance":8530,"id":195201,"goal":"lemma SeqMemberAppend_8530(t: seq, ys: seq)\n ensures x in t + ys <==> x in t || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_8531","instance":8531,"id":195202,"goal":"lemma SeqAppendLen_8531(zs: seq, xs: seq)\n ensures |zs + xs| == |zs| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_8532","instance":8532,"id":195203,"goal":"lemma SeqAppendNil_8532(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_8533","instance":8533,"id":195204,"goal":"lemma SeqNilAppend_8533(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_8534","instance":8534,"id":195205,"goal":"lemma SeqAppendAssoc_8534(xs: seq, zs: seq, u: seq)\n ensures (xs + zs) + u == xs + (zs + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_8535","instance":8535,"id":195206,"goal":"lemma SeqTakeDrop_8535(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_8536","instance":8536,"id":195207,"goal":"lemma SeqReverseLen_8536(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_8537","instance":8537,"id":195208,"goal":"lemma SeqReverseIdem_8537(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_8538","instance":8538,"id":195209,"goal":"lemma SeqMapLen_8538(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_8539","instance":8539,"id":195210,"goal":"lemma SeqFilterLe_8539(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_8540","instance":8540,"id":195211,"goal":"lemma SeqMemberAppend_8540(s: seq, t: seq)\n ensures x in s + t <==> x in s || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_8541","instance":8541,"id":195212,"goal":"lemma SeqAppendLen_8541(zs: seq, ys: seq)\n ensures |zs + ys| == |zs| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_8542","instance":8542,"id":195213,"goal":"lemma SeqAppendNil_8542(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_8543","instance":8543,"id":195214,"goal":"lemma SeqNilAppend_8543(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_8544","instance":8544,"id":195215,"goal":"lemma SeqAppendAssoc_8544(s: seq, ys: seq, zs: seq)\n ensures (s + ys) + zs == s + (ys + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_8545","instance":8545,"id":195216,"goal":"lemma SeqTakeDrop_8545(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_8546","instance":8546,"id":195217,"goal":"lemma SeqReverseLen_8546(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_8547","instance":8547,"id":195218,"goal":"lemma SeqReverseIdem_8547(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_8548","instance":8548,"id":195219,"goal":"lemma SeqMapLen_8548(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_8549","instance":8549,"id":195220,"goal":"lemma SeqFilterLe_8549(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_8550","instance":8550,"id":195221,"goal":"lemma SeqMemberAppend_8550(ys: seq, t: seq)\n ensures x in ys + t <==> x in ys || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_8551","instance":8551,"id":195222,"goal":"lemma SeqAppendLen_8551(u: seq, ys: seq)\n ensures |u + ys| == |u| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_8552","instance":8552,"id":195223,"goal":"lemma SeqAppendNil_8552(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_8553","instance":8553,"id":195224,"goal":"lemma SeqNilAppend_8553(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_8554","instance":8554,"id":195225,"goal":"lemma SeqAppendAssoc_8554(u: seq, xs: seq, t: seq)\n ensures (u + xs) + t == u + (xs + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_8555","instance":8555,"id":195226,"goal":"lemma SeqTakeDrop_8555(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_8556","instance":8556,"id":195227,"goal":"lemma SeqReverseLen_8556(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_8557","instance":8557,"id":195228,"goal":"lemma SeqReverseIdem_8557(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_8558","instance":8558,"id":195229,"goal":"lemma SeqMapLen_8558(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_8559","instance":8559,"id":195230,"goal":"lemma SeqFilterLe_8559(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_8560","instance":8560,"id":195231,"goal":"lemma SeqMemberAppend_8560(u: seq, zs: seq)\n ensures x in u + zs <==> x in u || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_8561","instance":8561,"id":195232,"goal":"lemma SeqAppendLen_8561(u: seq, ys: seq)\n ensures |u + ys| == |u| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_8562","instance":8562,"id":195233,"goal":"lemma SeqAppendNil_8562(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_8563","instance":8563,"id":195234,"goal":"lemma SeqNilAppend_8563(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_8564","instance":8564,"id":195235,"goal":"lemma SeqAppendAssoc_8564(zs: seq, u: seq, s: seq)\n ensures (zs + u) + s == zs + (u + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_8565","instance":8565,"id":195236,"goal":"lemma SeqTakeDrop_8565(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_8566","instance":8566,"id":195237,"goal":"lemma SeqReverseLen_8566(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_8567","instance":8567,"id":195238,"goal":"lemma SeqReverseIdem_8567(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_8568","instance":8568,"id":195239,"goal":"lemma SeqMapLen_8568(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_8569","instance":8569,"id":195240,"goal":"lemma SeqFilterLe_8569(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_8570","instance":8570,"id":195241,"goal":"lemma SeqMemberAppend_8570(xs: seq, u: seq)\n ensures x in xs + u <==> x in xs || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_8571","instance":8571,"id":195242,"goal":"lemma SeqAppendLen_8571(xs: seq, u: seq)\n ensures |xs + u| == |xs| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_8572","instance":8572,"id":195243,"goal":"lemma SeqAppendNil_8572(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_8573","instance":8573,"id":195244,"goal":"lemma SeqNilAppend_8573(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_8574","instance":8574,"id":195245,"goal":"lemma SeqAppendAssoc_8574(zs: seq, u: seq, xs: seq)\n ensures (zs + u) + xs == zs + (u + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_8575","instance":8575,"id":195246,"goal":"lemma SeqTakeDrop_8575(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_8576","instance":8576,"id":195247,"goal":"lemma SeqReverseLen_8576(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_8577","instance":8577,"id":195248,"goal":"lemma SeqReverseIdem_8577(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_8578","instance":8578,"id":195249,"goal":"lemma SeqMapLen_8578(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_8579","instance":8579,"id":195250,"goal":"lemma SeqFilterLe_8579(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_8580","instance":8580,"id":195251,"goal":"lemma SeqMemberAppend_8580(t: seq, s: seq)\n ensures x in t + s <==> x in t || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_8581","instance":8581,"id":195252,"goal":"lemma SeqAppendLen_8581(ys: seq, u: seq)\n ensures |ys + u| == |ys| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_8582","instance":8582,"id":195253,"goal":"lemma SeqAppendNil_8582(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_8583","instance":8583,"id":195254,"goal":"lemma SeqNilAppend_8583(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_8584","instance":8584,"id":195255,"goal":"lemma SeqAppendAssoc_8584(t: seq, s: seq, u: seq)\n ensures (t + s) + u == t + (s + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_8585","instance":8585,"id":195256,"goal":"lemma SeqTakeDrop_8585(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_8586","instance":8586,"id":195257,"goal":"lemma SeqReverseLen_8586(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_8587","instance":8587,"id":195258,"goal":"lemma SeqReverseIdem_8587(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_8588","instance":8588,"id":195259,"goal":"lemma SeqMapLen_8588(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_8589","instance":8589,"id":195260,"goal":"lemma SeqFilterLe_8589(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_8590","instance":8590,"id":195261,"goal":"lemma SeqMemberAppend_8590(zs: seq, t: seq)\n ensures x in zs + t <==> x in zs || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_8591","instance":8591,"id":195262,"goal":"lemma SeqAppendLen_8591(xs: seq, u: seq)\n ensures |xs + u| == |xs| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_8592","instance":8592,"id":195263,"goal":"lemma SeqAppendNil_8592(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_8593","instance":8593,"id":195264,"goal":"lemma SeqNilAppend_8593(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_8594","instance":8594,"id":195265,"goal":"lemma SeqAppendAssoc_8594(t: seq, zs: seq, ys: seq)\n ensures (t + zs) + ys == t + (zs + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_8595","instance":8595,"id":195266,"goal":"lemma SeqTakeDrop_8595(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_8596","instance":8596,"id":195267,"goal":"lemma SeqReverseLen_8596(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_8597","instance":8597,"id":195268,"goal":"lemma SeqReverseIdem_8597(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_8598","instance":8598,"id":195269,"goal":"lemma SeqMapLen_8598(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_8599","instance":8599,"id":195270,"goal":"lemma SeqFilterLe_8599(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_8600","instance":8600,"id":195271,"goal":"lemma SeqMemberAppend_8600(xs: seq, t: seq)\n ensures x in xs + t <==> x in xs || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_8601","instance":8601,"id":195272,"goal":"lemma SeqAppendLen_8601(xs: seq, ys: seq)\n ensures |xs + ys| == |xs| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_8602","instance":8602,"id":195273,"goal":"lemma SeqAppendNil_8602(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_8603","instance":8603,"id":195274,"goal":"lemma SeqNilAppend_8603(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_8604","instance":8604,"id":195275,"goal":"lemma SeqAppendAssoc_8604(s: seq, t: seq, xs: seq)\n ensures (s + t) + xs == s + (t + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_8605","instance":8605,"id":195276,"goal":"lemma SeqTakeDrop_8605(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_8606","instance":8606,"id":195277,"goal":"lemma SeqReverseLen_8606(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_8607","instance":8607,"id":195278,"goal":"lemma SeqReverseIdem_8607(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_8608","instance":8608,"id":195279,"goal":"lemma SeqMapLen_8608(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_8609","instance":8609,"id":195280,"goal":"lemma SeqFilterLe_8609(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_8610","instance":8610,"id":195281,"goal":"lemma SeqMemberAppend_8610(u: seq, t: seq)\n ensures x in u + t <==> x in u || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_8611","instance":8611,"id":195282,"goal":"lemma SeqAppendLen_8611(xs: seq, ys: seq)\n ensures |xs + ys| == |xs| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_8612","instance":8612,"id":195283,"goal":"lemma SeqAppendNil_8612(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_8613","instance":8613,"id":195284,"goal":"lemma SeqNilAppend_8613(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_8614","instance":8614,"id":195285,"goal":"lemma SeqAppendAssoc_8614(xs: seq, zs: seq, ys: seq)\n ensures (xs + zs) + ys == xs + (zs + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_8615","instance":8615,"id":195286,"goal":"lemma SeqTakeDrop_8615(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_8616","instance":8616,"id":195287,"goal":"lemma SeqReverseLen_8616(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_8617","instance":8617,"id":195288,"goal":"lemma SeqReverseIdem_8617(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_8618","instance":8618,"id":195289,"goal":"lemma SeqMapLen_8618(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_8619","instance":8619,"id":195290,"goal":"lemma SeqFilterLe_8619(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_8620","instance":8620,"id":195291,"goal":"lemma SeqMemberAppend_8620(t: seq, ys: seq)\n ensures x in t + ys <==> x in t || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_8621","instance":8621,"id":195292,"goal":"lemma SeqAppendLen_8621(t: seq, zs: seq)\n ensures |t + zs| == |t| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_8622","instance":8622,"id":195293,"goal":"lemma SeqAppendNil_8622(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_8623","instance":8623,"id":195294,"goal":"lemma SeqNilAppend_8623(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_8624","instance":8624,"id":195295,"goal":"lemma SeqAppendAssoc_8624(zs: seq, u: seq, ys: seq)\n ensures (zs + u) + ys == zs + (u + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_8625","instance":8625,"id":195296,"goal":"lemma SeqTakeDrop_8625(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_8626","instance":8626,"id":195297,"goal":"lemma SeqReverseLen_8626(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_8627","instance":8627,"id":195298,"goal":"lemma SeqReverseIdem_8627(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_8628","instance":8628,"id":195299,"goal":"lemma SeqMapLen_8628(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_8629","instance":8629,"id":195300,"goal":"lemma SeqFilterLe_8629(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_8630","instance":8630,"id":195301,"goal":"lemma SeqMemberAppend_8630(xs: seq, t: seq)\n ensures x in xs + t <==> x in xs || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_8631","instance":8631,"id":195302,"goal":"lemma SeqAppendLen_8631(ys: seq, t: seq)\n ensures |ys + t| == |ys| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_8632","instance":8632,"id":195303,"goal":"lemma SeqAppendNil_8632(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_8633","instance":8633,"id":195304,"goal":"lemma SeqNilAppend_8633(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_8634","instance":8634,"id":195305,"goal":"lemma SeqAppendAssoc_8634(xs: seq, u: seq, t: seq)\n ensures (xs + u) + t == xs + (u + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_8635","instance":8635,"id":195306,"goal":"lemma SeqTakeDrop_8635(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_8636","instance":8636,"id":195307,"goal":"lemma SeqReverseLen_8636(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_8637","instance":8637,"id":195308,"goal":"lemma SeqReverseIdem_8637(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_8638","instance":8638,"id":195309,"goal":"lemma SeqMapLen_8638(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_8639","instance":8639,"id":195310,"goal":"lemma SeqFilterLe_8639(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_8640","instance":8640,"id":195311,"goal":"lemma SeqMemberAppend_8640(zs: seq, u: seq)\n ensures x in zs + u <==> x in zs || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_8641","instance":8641,"id":195312,"goal":"lemma SeqAppendLen_8641(xs: seq, ys: seq)\n ensures |xs + ys| == |xs| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_8642","instance":8642,"id":195313,"goal":"lemma SeqAppendNil_8642(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_8643","instance":8643,"id":195314,"goal":"lemma SeqNilAppend_8643(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_8644","instance":8644,"id":195315,"goal":"lemma SeqAppendAssoc_8644(zs: seq, u: seq, xs: seq)\n ensures (zs + u) + xs == zs + (u + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_8645","instance":8645,"id":195316,"goal":"lemma SeqTakeDrop_8645(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_8646","instance":8646,"id":195317,"goal":"lemma SeqReverseLen_8646(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_8647","instance":8647,"id":195318,"goal":"lemma SeqReverseIdem_8647(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_8648","instance":8648,"id":195319,"goal":"lemma SeqMapLen_8648(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_8649","instance":8649,"id":195320,"goal":"lemma SeqFilterLe_8649(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_8650","instance":8650,"id":195321,"goal":"lemma SeqMemberAppend_8650(zs: seq, u: seq)\n ensures x in zs + u <==> x in zs || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_8651","instance":8651,"id":195322,"goal":"lemma SeqAppendLen_8651(u: seq, xs: seq)\n ensures |u + xs| == |u| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_8652","instance":8652,"id":195323,"goal":"lemma SeqAppendNil_8652(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_8653","instance":8653,"id":195324,"goal":"lemma SeqNilAppend_8653(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_8654","instance":8654,"id":195325,"goal":"lemma SeqAppendAssoc_8654(u: seq, xs: seq, s: seq)\n ensures (u + xs) + s == u + (xs + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_8655","instance":8655,"id":195326,"goal":"lemma SeqTakeDrop_8655(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_8656","instance":8656,"id":195327,"goal":"lemma SeqReverseLen_8656(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_8657","instance":8657,"id":195328,"goal":"lemma SeqReverseIdem_8657(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_8658","instance":8658,"id":195329,"goal":"lemma SeqMapLen_8658(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_8659","instance":8659,"id":195330,"goal":"lemma SeqFilterLe_8659(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_8660","instance":8660,"id":195331,"goal":"lemma SeqMemberAppend_8660(u: seq, ys: seq)\n ensures x in u + ys <==> x in u || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_8661","instance":8661,"id":195332,"goal":"lemma SeqAppendLen_8661(zs: seq, u: seq)\n ensures |zs + u| == |zs| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_8662","instance":8662,"id":195333,"goal":"lemma SeqAppendNil_8662(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_8663","instance":8663,"id":195334,"goal":"lemma SeqNilAppend_8663(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_8664","instance":8664,"id":195335,"goal":"lemma SeqAppendAssoc_8664(s: seq, t: seq, zs: seq)\n ensures (s + t) + zs == s + (t + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_8665","instance":8665,"id":195336,"goal":"lemma SeqTakeDrop_8665(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_8666","instance":8666,"id":195337,"goal":"lemma SeqReverseLen_8666(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_8667","instance":8667,"id":195338,"goal":"lemma SeqReverseIdem_8667(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_8668","instance":8668,"id":195339,"goal":"lemma SeqMapLen_8668(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_8669","instance":8669,"id":195340,"goal":"lemma SeqFilterLe_8669(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_8670","instance":8670,"id":195341,"goal":"lemma SeqMemberAppend_8670(zs: seq, u: seq)\n ensures x in zs + u <==> x in zs || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_8671","instance":8671,"id":195342,"goal":"lemma SeqAppendLen_8671(xs: seq, u: seq)\n ensures |xs + u| == |xs| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_8672","instance":8672,"id":195343,"goal":"lemma SeqAppendNil_8672(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_8673","instance":8673,"id":195344,"goal":"lemma SeqNilAppend_8673(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_8674","instance":8674,"id":195345,"goal":"lemma SeqAppendAssoc_8674(xs: seq, ys: seq, t: seq)\n ensures (xs + ys) + t == xs + (ys + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_8675","instance":8675,"id":195346,"goal":"lemma SeqTakeDrop_8675(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_8676","instance":8676,"id":195347,"goal":"lemma SeqReverseLen_8676(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_8677","instance":8677,"id":195348,"goal":"lemma SeqReverseIdem_8677(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_8678","instance":8678,"id":195349,"goal":"lemma SeqMapLen_8678(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_8679","instance":8679,"id":195350,"goal":"lemma SeqFilterLe_8679(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_8680","instance":8680,"id":195351,"goal":"lemma SeqMemberAppend_8680(xs: seq, ys: seq)\n ensures x in xs + ys <==> x in xs || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_8681","instance":8681,"id":195352,"goal":"lemma SeqAppendLen_8681(zs: seq, ys: seq)\n ensures |zs + ys| == |zs| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_8682","instance":8682,"id":195353,"goal":"lemma SeqAppendNil_8682(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_8683","instance":8683,"id":195354,"goal":"lemma SeqNilAppend_8683(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_8684","instance":8684,"id":195355,"goal":"lemma SeqAppendAssoc_8684(xs: seq, u: seq, s: seq)\n ensures (xs + u) + s == xs + (u + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_8685","instance":8685,"id":195356,"goal":"lemma SeqTakeDrop_8685(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_8686","instance":8686,"id":195357,"goal":"lemma SeqReverseLen_8686(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_8687","instance":8687,"id":195358,"goal":"lemma SeqReverseIdem_8687(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_8688","instance":8688,"id":195359,"goal":"lemma SeqMapLen_8688(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_8689","instance":8689,"id":195360,"goal":"lemma SeqFilterLe_8689(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_8690","instance":8690,"id":195361,"goal":"lemma SeqMemberAppend_8690(xs: seq, ys: seq)\n ensures x in xs + ys <==> x in xs || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_8691","instance":8691,"id":195362,"goal":"lemma SeqAppendLen_8691(t: seq, xs: seq)\n ensures |t + xs| == |t| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_8692","instance":8692,"id":195363,"goal":"lemma SeqAppendNil_8692(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_8693","instance":8693,"id":195364,"goal":"lemma SeqNilAppend_8693(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_8694","instance":8694,"id":195365,"goal":"lemma SeqAppendAssoc_8694(xs: seq, zs: seq, t: seq)\n ensures (xs + zs) + t == xs + (zs + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_8695","instance":8695,"id":195366,"goal":"lemma SeqTakeDrop_8695(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_8696","instance":8696,"id":195367,"goal":"lemma SeqReverseLen_8696(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_8697","instance":8697,"id":195368,"goal":"lemma SeqReverseIdem_8697(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_8698","instance":8698,"id":195369,"goal":"lemma SeqMapLen_8698(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_8699","instance":8699,"id":195370,"goal":"lemma SeqFilterLe_8699(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_8700","instance":8700,"id":195371,"goal":"lemma SeqMemberAppend_8700(t: seq, u: seq)\n ensures x in t + u <==> x in t || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_8701","instance":8701,"id":195372,"goal":"lemma SeqAppendLen_8701(xs: seq, u: seq)\n ensures |xs + u| == |xs| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_8702","instance":8702,"id":195373,"goal":"lemma SeqAppendNil_8702(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_8703","instance":8703,"id":195374,"goal":"lemma SeqNilAppend_8703(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_8704","instance":8704,"id":195375,"goal":"lemma SeqAppendAssoc_8704(zs: seq, ys: seq, u: seq)\n ensures (zs + ys) + u == zs + (ys + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_8705","instance":8705,"id":195376,"goal":"lemma SeqTakeDrop_8705(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_8706","instance":8706,"id":195377,"goal":"lemma SeqReverseLen_8706(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_8707","instance":8707,"id":195378,"goal":"lemma SeqReverseIdem_8707(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_8708","instance":8708,"id":195379,"goal":"lemma SeqMapLen_8708(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_8709","instance":8709,"id":195380,"goal":"lemma SeqFilterLe_8709(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_8710","instance":8710,"id":195381,"goal":"lemma SeqMemberAppend_8710(t: seq, u: seq)\n ensures x in t + u <==> x in t || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_8711","instance":8711,"id":195382,"goal":"lemma SeqAppendLen_8711(u: seq, s: seq)\n ensures |u + s| == |u| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_8712","instance":8712,"id":195383,"goal":"lemma SeqAppendNil_8712(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_8713","instance":8713,"id":195384,"goal":"lemma SeqNilAppend_8713(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_8714","instance":8714,"id":195385,"goal":"lemma SeqAppendAssoc_8714(xs: seq, zs: seq, s: seq)\n ensures (xs + zs) + s == xs + (zs + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_8715","instance":8715,"id":195386,"goal":"lemma SeqTakeDrop_8715(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_8716","instance":8716,"id":195387,"goal":"lemma SeqReverseLen_8716(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_8717","instance":8717,"id":195388,"goal":"lemma SeqReverseIdem_8717(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_8718","instance":8718,"id":195389,"goal":"lemma SeqMapLen_8718(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_8719","instance":8719,"id":195390,"goal":"lemma SeqFilterLe_8719(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_8720","instance":8720,"id":195391,"goal":"lemma SeqMemberAppend_8720(s: seq, t: seq)\n ensures x in s + t <==> x in s || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_8721","instance":8721,"id":195392,"goal":"lemma SeqAppendLen_8721(t: seq, ys: seq)\n ensures |t + ys| == |t| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_8722","instance":8722,"id":195393,"goal":"lemma SeqAppendNil_8722(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_8723","instance":8723,"id":195394,"goal":"lemma SeqNilAppend_8723(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_8724","instance":8724,"id":195395,"goal":"lemma SeqAppendAssoc_8724(t: seq, zs: seq, ys: seq)\n ensures (t + zs) + ys == t + (zs + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_8725","instance":8725,"id":195396,"goal":"lemma SeqTakeDrop_8725(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_8726","instance":8726,"id":195397,"goal":"lemma SeqReverseLen_8726(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_8727","instance":8727,"id":195398,"goal":"lemma SeqReverseIdem_8727(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_8728","instance":8728,"id":195399,"goal":"lemma SeqMapLen_8728(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_8729","instance":8729,"id":195400,"goal":"lemma SeqFilterLe_8729(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_8730","instance":8730,"id":195401,"goal":"lemma SeqMemberAppend_8730(t: seq, zs: seq)\n ensures x in t + zs <==> x in t || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_8731","instance":8731,"id":195402,"goal":"lemma SeqAppendLen_8731(zs: seq, t: seq)\n ensures |zs + t| == |zs| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_8732","instance":8732,"id":195403,"goal":"lemma SeqAppendNil_8732(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_8733","instance":8733,"id":195404,"goal":"lemma SeqNilAppend_8733(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_8734","instance":8734,"id":195405,"goal":"lemma SeqAppendAssoc_8734(ys: seq, s: seq, u: seq)\n ensures (ys + s) + u == ys + (s + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_8735","instance":8735,"id":195406,"goal":"lemma SeqTakeDrop_8735(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_8736","instance":8736,"id":195407,"goal":"lemma SeqReverseLen_8736(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_8737","instance":8737,"id":195408,"goal":"lemma SeqReverseIdem_8737(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_8738","instance":8738,"id":195409,"goal":"lemma SeqMapLen_8738(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_8739","instance":8739,"id":195410,"goal":"lemma SeqFilterLe_8739(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_8740","instance":8740,"id":195411,"goal":"lemma SeqMemberAppend_8740(ys: seq, s: seq)\n ensures x in ys + s <==> x in ys || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_8741","instance":8741,"id":195412,"goal":"lemma SeqAppendLen_8741(u: seq, zs: seq)\n ensures |u + zs| == |u| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_8742","instance":8742,"id":195413,"goal":"lemma SeqAppendNil_8742(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_8743","instance":8743,"id":195414,"goal":"lemma SeqNilAppend_8743(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_8744","instance":8744,"id":195415,"goal":"lemma SeqAppendAssoc_8744(s: seq, xs: seq, t: seq)\n ensures (s + xs) + t == s + (xs + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_8745","instance":8745,"id":195416,"goal":"lemma SeqTakeDrop_8745(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_8746","instance":8746,"id":195417,"goal":"lemma SeqReverseLen_8746(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_8747","instance":8747,"id":195418,"goal":"lemma SeqReverseIdem_8747(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_8748","instance":8748,"id":195419,"goal":"lemma SeqMapLen_8748(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_8749","instance":8749,"id":195420,"goal":"lemma SeqFilterLe_8749(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_8750","instance":8750,"id":195421,"goal":"lemma SeqMemberAppend_8750(ys: seq, zs: seq)\n ensures x in ys + zs <==> x in ys || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_8751","instance":8751,"id":195422,"goal":"lemma SeqAppendLen_8751(xs: seq, t: seq)\n ensures |xs + t| == |xs| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_8752","instance":8752,"id":195423,"goal":"lemma SeqAppendNil_8752(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_8753","instance":8753,"id":195424,"goal":"lemma SeqNilAppend_8753(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_8754","instance":8754,"id":195425,"goal":"lemma SeqAppendAssoc_8754(zs: seq, s: seq, xs: seq)\n ensures (zs + s) + xs == zs + (s + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_8755","instance":8755,"id":195426,"goal":"lemma SeqTakeDrop_8755(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_8756","instance":8756,"id":195427,"goal":"lemma SeqReverseLen_8756(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_8757","instance":8757,"id":195428,"goal":"lemma SeqReverseIdem_8757(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_8758","instance":8758,"id":195429,"goal":"lemma SeqMapLen_8758(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_8759","instance":8759,"id":195430,"goal":"lemma SeqFilterLe_8759(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_8760","instance":8760,"id":195431,"goal":"lemma SeqMemberAppend_8760(s: seq, xs: seq)\n ensures x in s + xs <==> x in s || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_8761","instance":8761,"id":195432,"goal":"lemma SeqAppendLen_8761(s: seq, ys: seq)\n ensures |s + ys| == |s| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_8762","instance":8762,"id":195433,"goal":"lemma SeqAppendNil_8762(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_8763","instance":8763,"id":195434,"goal":"lemma SeqNilAppend_8763(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_8764","instance":8764,"id":195435,"goal":"lemma SeqAppendAssoc_8764(u: seq, zs: seq, ys: seq)\n ensures (u + zs) + ys == u + (zs + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_8765","instance":8765,"id":195436,"goal":"lemma SeqTakeDrop_8765(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_8766","instance":8766,"id":195437,"goal":"lemma SeqReverseLen_8766(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_8767","instance":8767,"id":195438,"goal":"lemma SeqReverseIdem_8767(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_8768","instance":8768,"id":195439,"goal":"lemma SeqMapLen_8768(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_8769","instance":8769,"id":195440,"goal":"lemma SeqFilterLe_8769(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_8770","instance":8770,"id":195441,"goal":"lemma SeqMemberAppend_8770(s: seq, u: seq)\n ensures x in s + u <==> x in s || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_8771","instance":8771,"id":195442,"goal":"lemma SeqAppendLen_8771(s: seq, xs: seq)\n ensures |s + xs| == |s| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_8772","instance":8772,"id":195443,"goal":"lemma SeqAppendNil_8772(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_8773","instance":8773,"id":195444,"goal":"lemma SeqNilAppend_8773(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_8774","instance":8774,"id":195445,"goal":"lemma SeqAppendAssoc_8774(xs: seq, ys: seq, t: seq)\n ensures (xs + ys) + t == xs + (ys + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_8775","instance":8775,"id":195446,"goal":"lemma SeqTakeDrop_8775(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_8776","instance":8776,"id":195447,"goal":"lemma SeqReverseLen_8776(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_8777","instance":8777,"id":195448,"goal":"lemma SeqReverseIdem_8777(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_8778","instance":8778,"id":195449,"goal":"lemma SeqMapLen_8778(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_8779","instance":8779,"id":195450,"goal":"lemma SeqFilterLe_8779(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_8780","instance":8780,"id":195451,"goal":"lemma SeqMemberAppend_8780(t: seq, xs: seq)\n ensures x in t + xs <==> x in t || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_8781","instance":8781,"id":195452,"goal":"lemma SeqAppendLen_8781(zs: seq, ys: seq)\n ensures |zs + ys| == |zs| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_8782","instance":8782,"id":195453,"goal":"lemma SeqAppendNil_8782(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_8783","instance":8783,"id":195454,"goal":"lemma SeqNilAppend_8783(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_8784","instance":8784,"id":195455,"goal":"lemma SeqAppendAssoc_8784(u: seq, xs: seq, ys: seq)\n ensures (u + xs) + ys == u + (xs + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_8785","instance":8785,"id":195456,"goal":"lemma SeqTakeDrop_8785(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_8786","instance":8786,"id":195457,"goal":"lemma SeqReverseLen_8786(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_8787","instance":8787,"id":195458,"goal":"lemma SeqReverseIdem_8787(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_8788","instance":8788,"id":195459,"goal":"lemma SeqMapLen_8788(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_8789","instance":8789,"id":195460,"goal":"lemma SeqFilterLe_8789(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_8790","instance":8790,"id":195461,"goal":"lemma SeqMemberAppend_8790(t: seq, s: seq)\n ensures x in t + s <==> x in t || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_8791","instance":8791,"id":195462,"goal":"lemma SeqAppendLen_8791(zs: seq, s: seq)\n ensures |zs + s| == |zs| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_8792","instance":8792,"id":195463,"goal":"lemma SeqAppendNil_8792(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_8793","instance":8793,"id":195464,"goal":"lemma SeqNilAppend_8793(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_8794","instance":8794,"id":195465,"goal":"lemma SeqAppendAssoc_8794(xs: seq, u: seq, s: seq)\n ensures (xs + u) + s == xs + (u + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_8795","instance":8795,"id":195466,"goal":"lemma SeqTakeDrop_8795(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_8796","instance":8796,"id":195467,"goal":"lemma SeqReverseLen_8796(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_8797","instance":8797,"id":195468,"goal":"lemma SeqReverseIdem_8797(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_8798","instance":8798,"id":195469,"goal":"lemma SeqMapLen_8798(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_8799","instance":8799,"id":195470,"goal":"lemma SeqFilterLe_8799(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_8800","instance":8800,"id":195471,"goal":"lemma SeqMemberAppend_8800(zs: seq, s: seq)\n ensures x in zs + s <==> x in zs || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_8801","instance":8801,"id":195472,"goal":"lemma SeqAppendLen_8801(s: seq, u: seq)\n ensures |s + u| == |s| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_8802","instance":8802,"id":195473,"goal":"lemma SeqAppendNil_8802(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_8803","instance":8803,"id":195474,"goal":"lemma SeqNilAppend_8803(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_8804","instance":8804,"id":195475,"goal":"lemma SeqAppendAssoc_8804(ys: seq, t: seq, u: seq)\n ensures (ys + t) + u == ys + (t + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_8805","instance":8805,"id":195476,"goal":"lemma SeqTakeDrop_8805(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_8806","instance":8806,"id":195477,"goal":"lemma SeqReverseLen_8806(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_8807","instance":8807,"id":195478,"goal":"lemma SeqReverseIdem_8807(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_8808","instance":8808,"id":195479,"goal":"lemma SeqMapLen_8808(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_8809","instance":8809,"id":195480,"goal":"lemma SeqFilterLe_8809(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_8810","instance":8810,"id":195481,"goal":"lemma SeqMemberAppend_8810(u: seq, zs: seq)\n ensures x in u + zs <==> x in u || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_8811","instance":8811,"id":195482,"goal":"lemma SeqAppendLen_8811(xs: seq, s: seq)\n ensures |xs + s| == |xs| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_8812","instance":8812,"id":195483,"goal":"lemma SeqAppendNil_8812(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_8813","instance":8813,"id":195484,"goal":"lemma SeqNilAppend_8813(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_8814","instance":8814,"id":195485,"goal":"lemma SeqAppendAssoc_8814(ys: seq, t: seq, s: seq)\n ensures (ys + t) + s == ys + (t + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_8815","instance":8815,"id":195486,"goal":"lemma SeqTakeDrop_8815(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_8816","instance":8816,"id":195487,"goal":"lemma SeqReverseLen_8816(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_8817","instance":8817,"id":195488,"goal":"lemma SeqReverseIdem_8817(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_8818","instance":8818,"id":195489,"goal":"lemma SeqMapLen_8818(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_8819","instance":8819,"id":195490,"goal":"lemma SeqFilterLe_8819(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_8820","instance":8820,"id":195491,"goal":"lemma SeqMemberAppend_8820(t: seq, u: seq)\n ensures x in t + u <==> x in t || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_8821","instance":8821,"id":195492,"goal":"lemma SeqAppendLen_8821(ys: seq, s: seq)\n ensures |ys + s| == |ys| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_8822","instance":8822,"id":195493,"goal":"lemma SeqAppendNil_8822(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_8823","instance":8823,"id":195494,"goal":"lemma SeqNilAppend_8823(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_8824","instance":8824,"id":195495,"goal":"lemma SeqAppendAssoc_8824(u: seq, ys: seq, zs: seq)\n ensures (u + ys) + zs == u + (ys + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_8825","instance":8825,"id":195496,"goal":"lemma SeqTakeDrop_8825(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_8826","instance":8826,"id":195497,"goal":"lemma SeqReverseLen_8826(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_8827","instance":8827,"id":195498,"goal":"lemma SeqReverseIdem_8827(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_8828","instance":8828,"id":195499,"goal":"lemma SeqMapLen_8828(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_8829","instance":8829,"id":195500,"goal":"lemma SeqFilterLe_8829(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_8830","instance":8830,"id":195501,"goal":"lemma SeqMemberAppend_8830(xs: seq, ys: seq)\n ensures x in xs + ys <==> x in xs || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_8831","instance":8831,"id":195502,"goal":"lemma SeqAppendLen_8831(ys: seq, xs: seq)\n ensures |ys + xs| == |ys| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_8832","instance":8832,"id":195503,"goal":"lemma SeqAppendNil_8832(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_8833","instance":8833,"id":195504,"goal":"lemma SeqNilAppend_8833(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_8834","instance":8834,"id":195505,"goal":"lemma SeqAppendAssoc_8834(xs: seq, ys: seq, s: seq)\n ensures (xs + ys) + s == xs + (ys + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_8835","instance":8835,"id":195506,"goal":"lemma SeqTakeDrop_8835(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_8836","instance":8836,"id":195507,"goal":"lemma SeqReverseLen_8836(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_8837","instance":8837,"id":195508,"goal":"lemma SeqReverseIdem_8837(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_8838","instance":8838,"id":195509,"goal":"lemma SeqMapLen_8838(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_8839","instance":8839,"id":195510,"goal":"lemma SeqFilterLe_8839(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_8840","instance":8840,"id":195511,"goal":"lemma SeqMemberAppend_8840(ys: seq, s: seq)\n ensures x in ys + s <==> x in ys || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_8841","instance":8841,"id":195512,"goal":"lemma SeqAppendLen_8841(xs: seq, ys: seq)\n ensures |xs + ys| == |xs| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_8842","instance":8842,"id":195513,"goal":"lemma SeqAppendNil_8842(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_8843","instance":8843,"id":195514,"goal":"lemma SeqNilAppend_8843(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_8844","instance":8844,"id":195515,"goal":"lemma SeqAppendAssoc_8844(t: seq, xs: seq, s: seq)\n ensures (t + xs) + s == t + (xs + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_8845","instance":8845,"id":195516,"goal":"lemma SeqTakeDrop_8845(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_8846","instance":8846,"id":195517,"goal":"lemma SeqReverseLen_8846(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_8847","instance":8847,"id":195518,"goal":"lemma SeqReverseIdem_8847(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_8848","instance":8848,"id":195519,"goal":"lemma SeqMapLen_8848(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_8849","instance":8849,"id":195520,"goal":"lemma SeqFilterLe_8849(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_8850","instance":8850,"id":195521,"goal":"lemma SeqMemberAppend_8850(zs: seq, ys: seq)\n ensures x in zs + ys <==> x in zs || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_8851","instance":8851,"id":195522,"goal":"lemma SeqAppendLen_8851(s: seq, t: seq)\n ensures |s + t| == |s| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_8852","instance":8852,"id":195523,"goal":"lemma SeqAppendNil_8852(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_8853","instance":8853,"id":195524,"goal":"lemma SeqNilAppend_8853(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_8854","instance":8854,"id":195525,"goal":"lemma SeqAppendAssoc_8854(t: seq, zs: seq, u: seq)\n ensures (t + zs) + u == t + (zs + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_8855","instance":8855,"id":195526,"goal":"lemma SeqTakeDrop_8855(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_8856","instance":8856,"id":195527,"goal":"lemma SeqReverseLen_8856(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_8857","instance":8857,"id":195528,"goal":"lemma SeqReverseIdem_8857(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_8858","instance":8858,"id":195529,"goal":"lemma SeqMapLen_8858(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_8859","instance":8859,"id":195530,"goal":"lemma SeqFilterLe_8859(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_8860","instance":8860,"id":195531,"goal":"lemma SeqMemberAppend_8860(u: seq, ys: seq)\n ensures x in u + ys <==> x in u || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_8861","instance":8861,"id":195532,"goal":"lemma SeqAppendLen_8861(ys: seq, xs: seq)\n ensures |ys + xs| == |ys| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_8862","instance":8862,"id":195533,"goal":"lemma SeqAppendNil_8862(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_8863","instance":8863,"id":195534,"goal":"lemma SeqNilAppend_8863(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_8864","instance":8864,"id":195535,"goal":"lemma SeqAppendAssoc_8864(zs: seq, s: seq, t: seq)\n ensures (zs + s) + t == zs + (s + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_8865","instance":8865,"id":195536,"goal":"lemma SeqTakeDrop_8865(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_8866","instance":8866,"id":195537,"goal":"lemma SeqReverseLen_8866(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_8867","instance":8867,"id":195538,"goal":"lemma SeqReverseIdem_8867(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_8868","instance":8868,"id":195539,"goal":"lemma SeqMapLen_8868(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_8869","instance":8869,"id":195540,"goal":"lemma SeqFilterLe_8869(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_8870","instance":8870,"id":195541,"goal":"lemma SeqMemberAppend_8870(u: seq, s: seq)\n ensures x in u + s <==> x in u || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_8871","instance":8871,"id":195542,"goal":"lemma SeqAppendLen_8871(xs: seq, t: seq)\n ensures |xs + t| == |xs| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_8872","instance":8872,"id":195543,"goal":"lemma SeqAppendNil_8872(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_8873","instance":8873,"id":195544,"goal":"lemma SeqNilAppend_8873(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_8874","instance":8874,"id":195545,"goal":"lemma SeqAppendAssoc_8874(s: seq, xs: seq, zs: seq)\n ensures (s + xs) + zs == s + (xs + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_8875","instance":8875,"id":195546,"goal":"lemma SeqTakeDrop_8875(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_8876","instance":8876,"id":195547,"goal":"lemma SeqReverseLen_8876(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_8877","instance":8877,"id":195548,"goal":"lemma SeqReverseIdem_8877(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_8878","instance":8878,"id":195549,"goal":"lemma SeqMapLen_8878(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_8879","instance":8879,"id":195550,"goal":"lemma SeqFilterLe_8879(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_8880","instance":8880,"id":195551,"goal":"lemma SeqMemberAppend_8880(ys: seq, xs: seq)\n ensures x in ys + xs <==> x in ys || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_8881","instance":8881,"id":195552,"goal":"lemma SeqAppendLen_8881(xs: seq, t: seq)\n ensures |xs + t| == |xs| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_8882","instance":8882,"id":195553,"goal":"lemma SeqAppendNil_8882(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_8883","instance":8883,"id":195554,"goal":"lemma SeqNilAppend_8883(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_8884","instance":8884,"id":195555,"goal":"lemma SeqAppendAssoc_8884(u: seq, ys: seq, t: seq)\n ensures (u + ys) + t == u + (ys + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_8885","instance":8885,"id":195556,"goal":"lemma SeqTakeDrop_8885(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_8886","instance":8886,"id":195557,"goal":"lemma SeqReverseLen_8886(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_8887","instance":8887,"id":195558,"goal":"lemma SeqReverseIdem_8887(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_8888","instance":8888,"id":195559,"goal":"lemma SeqMapLen_8888(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_8889","instance":8889,"id":195560,"goal":"lemma SeqFilterLe_8889(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_8890","instance":8890,"id":195561,"goal":"lemma SeqMemberAppend_8890(u: seq, ys: seq)\n ensures x in u + ys <==> x in u || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_8891","instance":8891,"id":195562,"goal":"lemma SeqAppendLen_8891(zs: seq, s: seq)\n ensures |zs + s| == |zs| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_8892","instance":8892,"id":195563,"goal":"lemma SeqAppendNil_8892(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_8893","instance":8893,"id":195564,"goal":"lemma SeqNilAppend_8893(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_8894","instance":8894,"id":195565,"goal":"lemma SeqAppendAssoc_8894(s: seq, u: seq, t: seq)\n ensures (s + u) + t == s + (u + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_8895","instance":8895,"id":195566,"goal":"lemma SeqTakeDrop_8895(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_8896","instance":8896,"id":195567,"goal":"lemma SeqReverseLen_8896(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_8897","instance":8897,"id":195568,"goal":"lemma SeqReverseIdem_8897(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_8898","instance":8898,"id":195569,"goal":"lemma SeqMapLen_8898(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_8899","instance":8899,"id":195570,"goal":"lemma SeqFilterLe_8899(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_8900","instance":8900,"id":195571,"goal":"lemma SeqMemberAppend_8900(u: seq, t: seq)\n ensures x in u + t <==> x in u || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_8901","instance":8901,"id":195572,"goal":"lemma SeqAppendLen_8901(u: seq, t: seq)\n ensures |u + t| == |u| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_8902","instance":8902,"id":195573,"goal":"lemma SeqAppendNil_8902(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_8903","instance":8903,"id":195574,"goal":"lemma SeqNilAppend_8903(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_8904","instance":8904,"id":195575,"goal":"lemma SeqAppendAssoc_8904(u: seq, xs: seq, ys: seq)\n ensures (u + xs) + ys == u + (xs + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_8905","instance":8905,"id":195576,"goal":"lemma SeqTakeDrop_8905(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_8906","instance":8906,"id":195577,"goal":"lemma SeqReverseLen_8906(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_8907","instance":8907,"id":195578,"goal":"lemma SeqReverseIdem_8907(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_8908","instance":8908,"id":195579,"goal":"lemma SeqMapLen_8908(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_8909","instance":8909,"id":195580,"goal":"lemma SeqFilterLe_8909(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_8910","instance":8910,"id":195581,"goal":"lemma SeqMemberAppend_8910(ys: seq, xs: seq)\n ensures x in ys + xs <==> x in ys || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_8911","instance":8911,"id":195582,"goal":"lemma SeqAppendLen_8911(xs: seq, zs: seq)\n ensures |xs + zs| == |xs| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_8912","instance":8912,"id":195583,"goal":"lemma SeqAppendNil_8912(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_8913","instance":8913,"id":195584,"goal":"lemma SeqNilAppend_8913(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_8914","instance":8914,"id":195585,"goal":"lemma SeqAppendAssoc_8914(zs: seq, u: seq, ys: seq)\n ensures (zs + u) + ys == zs + (u + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_8915","instance":8915,"id":195586,"goal":"lemma SeqTakeDrop_8915(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_8916","instance":8916,"id":195587,"goal":"lemma SeqReverseLen_8916(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_8917","instance":8917,"id":195588,"goal":"lemma SeqReverseIdem_8917(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_8918","instance":8918,"id":195589,"goal":"lemma SeqMapLen_8918(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_8919","instance":8919,"id":195590,"goal":"lemma SeqFilterLe_8919(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_8920","instance":8920,"id":195591,"goal":"lemma SeqMemberAppend_8920(s: seq, ys: seq)\n ensures x in s + ys <==> x in s || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_8921","instance":8921,"id":195592,"goal":"lemma SeqAppendLen_8921(zs: seq, u: seq)\n ensures |zs + u| == |zs| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_8922","instance":8922,"id":195593,"goal":"lemma SeqAppendNil_8922(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_8923","instance":8923,"id":195594,"goal":"lemma SeqNilAppend_8923(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_8924","instance":8924,"id":195595,"goal":"lemma SeqAppendAssoc_8924(xs: seq, s: seq, zs: seq)\n ensures (xs + s) + zs == xs + (s + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_8925","instance":8925,"id":195596,"goal":"lemma SeqTakeDrop_8925(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_8926","instance":8926,"id":195597,"goal":"lemma SeqReverseLen_8926(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_8927","instance":8927,"id":195598,"goal":"lemma SeqReverseIdem_8927(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_8928","instance":8928,"id":195599,"goal":"lemma SeqMapLen_8928(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_8929","instance":8929,"id":195600,"goal":"lemma SeqFilterLe_8929(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_8930","instance":8930,"id":195601,"goal":"lemma SeqMemberAppend_8930(zs: seq, xs: seq)\n ensures x in zs + xs <==> x in zs || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_8931","instance":8931,"id":195602,"goal":"lemma SeqAppendLen_8931(xs: seq, zs: seq)\n ensures |xs + zs| == |xs| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_8932","instance":8932,"id":195603,"goal":"lemma SeqAppendNil_8932(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_8933","instance":8933,"id":195604,"goal":"lemma SeqNilAppend_8933(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_8934","instance":8934,"id":195605,"goal":"lemma SeqAppendAssoc_8934(ys: seq, u: seq, s: seq)\n ensures (ys + u) + s == ys + (u + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_8935","instance":8935,"id":195606,"goal":"lemma SeqTakeDrop_8935(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_8936","instance":8936,"id":195607,"goal":"lemma SeqReverseLen_8936(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_8937","instance":8937,"id":195608,"goal":"lemma SeqReverseIdem_8937(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_8938","instance":8938,"id":195609,"goal":"lemma SeqMapLen_8938(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_8939","instance":8939,"id":195610,"goal":"lemma SeqFilterLe_8939(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_8940","instance":8940,"id":195611,"goal":"lemma SeqMemberAppend_8940(t: seq, zs: seq)\n ensures x in t + zs <==> x in t || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_8941","instance":8941,"id":195612,"goal":"lemma SeqAppendLen_8941(ys: seq, zs: seq)\n ensures |ys + zs| == |ys| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_8942","instance":8942,"id":195613,"goal":"lemma SeqAppendNil_8942(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_8943","instance":8943,"id":195614,"goal":"lemma SeqNilAppend_8943(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_8944","instance":8944,"id":195615,"goal":"lemma SeqAppendAssoc_8944(xs: seq, t: seq, s: seq)\n ensures (xs + t) + s == xs + (t + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_8945","instance":8945,"id":195616,"goal":"lemma SeqTakeDrop_8945(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_8946","instance":8946,"id":195617,"goal":"lemma SeqReverseLen_8946(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_8947","instance":8947,"id":195618,"goal":"lemma SeqReverseIdem_8947(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_8948","instance":8948,"id":195619,"goal":"lemma SeqMapLen_8948(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_8949","instance":8949,"id":195620,"goal":"lemma SeqFilterLe_8949(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_8950","instance":8950,"id":195621,"goal":"lemma SeqMemberAppend_8950(ys: seq, t: seq)\n ensures x in ys + t <==> x in ys || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_8951","instance":8951,"id":195622,"goal":"lemma SeqAppendLen_8951(xs: seq, ys: seq)\n ensures |xs + ys| == |xs| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_8952","instance":8952,"id":195623,"goal":"lemma SeqAppendNil_8952(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_8953","instance":8953,"id":195624,"goal":"lemma SeqNilAppend_8953(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_8954","instance":8954,"id":195625,"goal":"lemma SeqAppendAssoc_8954(t: seq, zs: seq, ys: seq)\n ensures (t + zs) + ys == t + (zs + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_8955","instance":8955,"id":195626,"goal":"lemma SeqTakeDrop_8955(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_8956","instance":8956,"id":195627,"goal":"lemma SeqReverseLen_8956(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_8957","instance":8957,"id":195628,"goal":"lemma SeqReverseIdem_8957(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_8958","instance":8958,"id":195629,"goal":"lemma SeqMapLen_8958(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_8959","instance":8959,"id":195630,"goal":"lemma SeqFilterLe_8959(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_8960","instance":8960,"id":195631,"goal":"lemma SeqMemberAppend_8960(zs: seq, t: seq)\n ensures x in zs + t <==> x in zs || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_8961","instance":8961,"id":195632,"goal":"lemma SeqAppendLen_8961(u: seq, ys: seq)\n ensures |u + ys| == |u| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_8962","instance":8962,"id":195633,"goal":"lemma SeqAppendNil_8962(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_8963","instance":8963,"id":195634,"goal":"lemma SeqNilAppend_8963(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_8964","instance":8964,"id":195635,"goal":"lemma SeqAppendAssoc_8964(zs: seq, s: seq, xs: seq)\n ensures (zs + s) + xs == zs + (s + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_8965","instance":8965,"id":195636,"goal":"lemma SeqTakeDrop_8965(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_8966","instance":8966,"id":195637,"goal":"lemma SeqReverseLen_8966(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_8967","instance":8967,"id":195638,"goal":"lemma SeqReverseIdem_8967(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_8968","instance":8968,"id":195639,"goal":"lemma SeqMapLen_8968(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_8969","instance":8969,"id":195640,"goal":"lemma SeqFilterLe_8969(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_8970","instance":8970,"id":195641,"goal":"lemma SeqMemberAppend_8970(t: seq, zs: seq)\n ensures x in t + zs <==> x in t || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_8971","instance":8971,"id":195642,"goal":"lemma SeqAppendLen_8971(xs: seq, s: seq)\n ensures |xs + s| == |xs| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_8972","instance":8972,"id":195643,"goal":"lemma SeqAppendNil_8972(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_8973","instance":8973,"id":195644,"goal":"lemma SeqNilAppend_8973(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_8974","instance":8974,"id":195645,"goal":"lemma SeqAppendAssoc_8974(s: seq, t: seq, ys: seq)\n ensures (s + t) + ys == s + (t + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_8975","instance":8975,"id":195646,"goal":"lemma SeqTakeDrop_8975(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_8976","instance":8976,"id":195647,"goal":"lemma SeqReverseLen_8976(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_8977","instance":8977,"id":195648,"goal":"lemma SeqReverseIdem_8977(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_8978","instance":8978,"id":195649,"goal":"lemma SeqMapLen_8978(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_8979","instance":8979,"id":195650,"goal":"lemma SeqFilterLe_8979(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_8980","instance":8980,"id":195651,"goal":"lemma SeqMemberAppend_8980(s: seq, zs: seq)\n ensures x in s + zs <==> x in s || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_8981","instance":8981,"id":195652,"goal":"lemma SeqAppendLen_8981(s: seq, u: seq)\n ensures |s + u| == |s| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_8982","instance":8982,"id":195653,"goal":"lemma SeqAppendNil_8982(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_8983","instance":8983,"id":195654,"goal":"lemma SeqNilAppend_8983(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_8984","instance":8984,"id":195655,"goal":"lemma SeqAppendAssoc_8984(ys: seq, zs: seq, t: seq)\n ensures (ys + zs) + t == ys + (zs + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_8985","instance":8985,"id":195656,"goal":"lemma SeqTakeDrop_8985(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_8986","instance":8986,"id":195657,"goal":"lemma SeqReverseLen_8986(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_8987","instance":8987,"id":195658,"goal":"lemma SeqReverseIdem_8987(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_8988","instance":8988,"id":195659,"goal":"lemma SeqMapLen_8988(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_8989","instance":8989,"id":195660,"goal":"lemma SeqFilterLe_8989(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_8990","instance":8990,"id":195661,"goal":"lemma SeqMemberAppend_8990(zs: seq, t: seq)\n ensures x in zs + t <==> x in zs || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_8991","instance":8991,"id":195662,"goal":"lemma SeqAppendLen_8991(u: seq, ys: seq)\n ensures |u + ys| == |u| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_8992","instance":8992,"id":195663,"goal":"lemma SeqAppendNil_8992(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_8993","instance":8993,"id":195664,"goal":"lemma SeqNilAppend_8993(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_8994","instance":8994,"id":195665,"goal":"lemma SeqAppendAssoc_8994(t: seq, zs: seq, ys: seq)\n ensures (t + zs) + ys == t + (zs + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_8995","instance":8995,"id":195666,"goal":"lemma SeqTakeDrop_8995(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_8996","instance":8996,"id":195667,"goal":"lemma SeqReverseLen_8996(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_8997","instance":8997,"id":195668,"goal":"lemma SeqReverseIdem_8997(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_8998","instance":8998,"id":195669,"goal":"lemma SeqMapLen_8998(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_8999","instance":8999,"id":195670,"goal":"lemma SeqFilterLe_8999(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_9000","instance":9000,"id":195671,"goal":"lemma SeqMemberAppend_9000(xs: seq, t: seq)\n ensures x in xs + t <==> x in xs || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_9001","instance":9001,"id":195672,"goal":"lemma SeqAppendLen_9001(s: seq, ys: seq)\n ensures |s + ys| == |s| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_9002","instance":9002,"id":195673,"goal":"lemma SeqAppendNil_9002(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_9003","instance":9003,"id":195674,"goal":"lemma SeqNilAppend_9003(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_9004","instance":9004,"id":195675,"goal":"lemma SeqAppendAssoc_9004(xs: seq, s: seq, ys: seq)\n ensures (xs + s) + ys == xs + (s + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_9005","instance":9005,"id":195676,"goal":"lemma SeqTakeDrop_9005(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_9006","instance":9006,"id":195677,"goal":"lemma SeqReverseLen_9006(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_9007","instance":9007,"id":195678,"goal":"lemma SeqReverseIdem_9007(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_9008","instance":9008,"id":195679,"goal":"lemma SeqMapLen_9008(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_9009","instance":9009,"id":195680,"goal":"lemma SeqFilterLe_9009(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_9010","instance":9010,"id":195681,"goal":"lemma SeqMemberAppend_9010(zs: seq, s: seq)\n ensures x in zs + s <==> x in zs || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_9011","instance":9011,"id":195682,"goal":"lemma SeqAppendLen_9011(zs: seq, ys: seq)\n ensures |zs + ys| == |zs| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_9012","instance":9012,"id":195683,"goal":"lemma SeqAppendNil_9012(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_9013","instance":9013,"id":195684,"goal":"lemma SeqNilAppend_9013(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_9014","instance":9014,"id":195685,"goal":"lemma SeqAppendAssoc_9014(s: seq, u: seq, zs: seq)\n ensures (s + u) + zs == s + (u + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_9015","instance":9015,"id":195686,"goal":"lemma SeqTakeDrop_9015(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_9016","instance":9016,"id":195687,"goal":"lemma SeqReverseLen_9016(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_9017","instance":9017,"id":195688,"goal":"lemma SeqReverseIdem_9017(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_9018","instance":9018,"id":195689,"goal":"lemma SeqMapLen_9018(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_9019","instance":9019,"id":195690,"goal":"lemma SeqFilterLe_9019(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_9020","instance":9020,"id":195691,"goal":"lemma SeqMemberAppend_9020(zs: seq, ys: seq)\n ensures x in zs + ys <==> x in zs || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_9021","instance":9021,"id":195692,"goal":"lemma SeqAppendLen_9021(zs: seq, ys: seq)\n ensures |zs + ys| == |zs| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_9022","instance":9022,"id":195693,"goal":"lemma SeqAppendNil_9022(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_9023","instance":9023,"id":195694,"goal":"lemma SeqNilAppend_9023(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_9024","instance":9024,"id":195695,"goal":"lemma SeqAppendAssoc_9024(t: seq, ys: seq, zs: seq)\n ensures (t + ys) + zs == t + (ys + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_9025","instance":9025,"id":195696,"goal":"lemma SeqTakeDrop_9025(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_9026","instance":9026,"id":195697,"goal":"lemma SeqReverseLen_9026(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_9027","instance":9027,"id":195698,"goal":"lemma SeqReverseIdem_9027(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_9028","instance":9028,"id":195699,"goal":"lemma SeqMapLen_9028(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_9029","instance":9029,"id":195700,"goal":"lemma SeqFilterLe_9029(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_9030","instance":9030,"id":195701,"goal":"lemma SeqMemberAppend_9030(t: seq, u: seq)\n ensures x in t + u <==> x in t || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_9031","instance":9031,"id":195702,"goal":"lemma SeqAppendLen_9031(xs: seq, t: seq)\n ensures |xs + t| == |xs| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_9032","instance":9032,"id":195703,"goal":"lemma SeqAppendNil_9032(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_9033","instance":9033,"id":195704,"goal":"lemma SeqNilAppend_9033(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_9034","instance":9034,"id":195705,"goal":"lemma SeqAppendAssoc_9034(ys: seq, xs: seq, t: seq)\n ensures (ys + xs) + t == ys + (xs + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_9035","instance":9035,"id":195706,"goal":"lemma SeqTakeDrop_9035(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_9036","instance":9036,"id":195707,"goal":"lemma SeqReverseLen_9036(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_9037","instance":9037,"id":195708,"goal":"lemma SeqReverseIdem_9037(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_9038","instance":9038,"id":195709,"goal":"lemma SeqMapLen_9038(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_9039","instance":9039,"id":195710,"goal":"lemma SeqFilterLe_9039(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_9040","instance":9040,"id":195711,"goal":"lemma SeqMemberAppend_9040(s: seq, t: seq)\n ensures x in s + t <==> x in s || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_9041","instance":9041,"id":195712,"goal":"lemma SeqAppendLen_9041(s: seq, zs: seq)\n ensures |s + zs| == |s| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_9042","instance":9042,"id":195713,"goal":"lemma SeqAppendNil_9042(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_9043","instance":9043,"id":195714,"goal":"lemma SeqNilAppend_9043(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_9044","instance":9044,"id":195715,"goal":"lemma SeqAppendAssoc_9044(xs: seq, u: seq, t: seq)\n ensures (xs + u) + t == xs + (u + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_9045","instance":9045,"id":195716,"goal":"lemma SeqTakeDrop_9045(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_9046","instance":9046,"id":195717,"goal":"lemma SeqReverseLen_9046(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_9047","instance":9047,"id":195718,"goal":"lemma SeqReverseIdem_9047(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_9048","instance":9048,"id":195719,"goal":"lemma SeqMapLen_9048(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_9049","instance":9049,"id":195720,"goal":"lemma SeqFilterLe_9049(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_9050","instance":9050,"id":195721,"goal":"lemma SeqMemberAppend_9050(s: seq, xs: seq)\n ensures x in s + xs <==> x in s || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_9051","instance":9051,"id":195722,"goal":"lemma SeqAppendLen_9051(xs: seq, zs: seq)\n ensures |xs + zs| == |xs| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_9052","instance":9052,"id":195723,"goal":"lemma SeqAppendNil_9052(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_9053","instance":9053,"id":195724,"goal":"lemma SeqNilAppend_9053(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_9054","instance":9054,"id":195725,"goal":"lemma SeqAppendAssoc_9054(zs: seq, u: seq, xs: seq)\n ensures (zs + u) + xs == zs + (u + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_9055","instance":9055,"id":195726,"goal":"lemma SeqTakeDrop_9055(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_9056","instance":9056,"id":195727,"goal":"lemma SeqReverseLen_9056(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_9057","instance":9057,"id":195728,"goal":"lemma SeqReverseIdem_9057(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_9058","instance":9058,"id":195729,"goal":"lemma SeqMapLen_9058(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_9059","instance":9059,"id":195730,"goal":"lemma SeqFilterLe_9059(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_9060","instance":9060,"id":195731,"goal":"lemma SeqMemberAppend_9060(s: seq, u: seq)\n ensures x in s + u <==> x in s || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_9061","instance":9061,"id":195732,"goal":"lemma SeqAppendLen_9061(s: seq, xs: seq)\n ensures |s + xs| == |s| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_9062","instance":9062,"id":195733,"goal":"lemma SeqAppendNil_9062(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_9063","instance":9063,"id":195734,"goal":"lemma SeqNilAppend_9063(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_9064","instance":9064,"id":195735,"goal":"lemma SeqAppendAssoc_9064(zs: seq, t: seq, u: seq)\n ensures (zs + t) + u == zs + (t + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_9065","instance":9065,"id":195736,"goal":"lemma SeqTakeDrop_9065(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_9066","instance":9066,"id":195737,"goal":"lemma SeqReverseLen_9066(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_9067","instance":9067,"id":195738,"goal":"lemma SeqReverseIdem_9067(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_9068","instance":9068,"id":195739,"goal":"lemma SeqMapLen_9068(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_9069","instance":9069,"id":195740,"goal":"lemma SeqFilterLe_9069(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_9070","instance":9070,"id":195741,"goal":"lemma SeqMemberAppend_9070(s: seq, zs: seq)\n ensures x in s + zs <==> x in s || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_9071","instance":9071,"id":195742,"goal":"lemma SeqAppendLen_9071(ys: seq, zs: seq)\n ensures |ys + zs| == |ys| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_9072","instance":9072,"id":195743,"goal":"lemma SeqAppendNil_9072(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_9073","instance":9073,"id":195744,"goal":"lemma SeqNilAppend_9073(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_9074","instance":9074,"id":195745,"goal":"lemma SeqAppendAssoc_9074(xs: seq, u: seq, s: seq)\n ensures (xs + u) + s == xs + (u + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_9075","instance":9075,"id":195746,"goal":"lemma SeqTakeDrop_9075(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_9076","instance":9076,"id":195747,"goal":"lemma SeqReverseLen_9076(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_9077","instance":9077,"id":195748,"goal":"lemma SeqReverseIdem_9077(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_9078","instance":9078,"id":195749,"goal":"lemma SeqMapLen_9078(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_9079","instance":9079,"id":195750,"goal":"lemma SeqFilterLe_9079(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_9080","instance":9080,"id":195751,"goal":"lemma SeqMemberAppend_9080(ys: seq, t: seq)\n ensures x in ys + t <==> x in ys || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_9081","instance":9081,"id":195752,"goal":"lemma SeqAppendLen_9081(xs: seq, ys: seq)\n ensures |xs + ys| == |xs| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_9082","instance":9082,"id":195753,"goal":"lemma SeqAppendNil_9082(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_9083","instance":9083,"id":195754,"goal":"lemma SeqNilAppend_9083(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_9084","instance":9084,"id":195755,"goal":"lemma SeqAppendAssoc_9084(xs: seq, ys: seq, s: seq)\n ensures (xs + ys) + s == xs + (ys + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_9085","instance":9085,"id":195756,"goal":"lemma SeqTakeDrop_9085(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_9086","instance":9086,"id":195757,"goal":"lemma SeqReverseLen_9086(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_9087","instance":9087,"id":195758,"goal":"lemma SeqReverseIdem_9087(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_9088","instance":9088,"id":195759,"goal":"lemma SeqMapLen_9088(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_9089","instance":9089,"id":195760,"goal":"lemma SeqFilterLe_9089(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_9090","instance":9090,"id":195761,"goal":"lemma SeqMemberAppend_9090(t: seq, zs: seq)\n ensures x in t + zs <==> x in t || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_9091","instance":9091,"id":195762,"goal":"lemma SeqAppendLen_9091(u: seq, ys: seq)\n ensures |u + ys| == |u| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_9092","instance":9092,"id":195763,"goal":"lemma SeqAppendNil_9092(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_9093","instance":9093,"id":195764,"goal":"lemma SeqNilAppend_9093(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_9094","instance":9094,"id":195765,"goal":"lemma SeqAppendAssoc_9094(zs: seq, xs: seq, t: seq)\n ensures (zs + xs) + t == zs + (xs + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_9095","instance":9095,"id":195766,"goal":"lemma SeqTakeDrop_9095(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_9096","instance":9096,"id":195767,"goal":"lemma SeqReverseLen_9096(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_9097","instance":9097,"id":195768,"goal":"lemma SeqReverseIdem_9097(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_9098","instance":9098,"id":195769,"goal":"lemma SeqMapLen_9098(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_9099","instance":9099,"id":195770,"goal":"lemma SeqFilterLe_9099(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_9100","instance":9100,"id":195771,"goal":"lemma SeqMemberAppend_9100(s: seq, u: seq)\n ensures x in s + u <==> x in s || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_9101","instance":9101,"id":195772,"goal":"lemma SeqAppendLen_9101(zs: seq, u: seq)\n ensures |zs + u| == |zs| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_9102","instance":9102,"id":195773,"goal":"lemma SeqAppendNil_9102(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_9103","instance":9103,"id":195774,"goal":"lemma SeqNilAppend_9103(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_9104","instance":9104,"id":195775,"goal":"lemma SeqAppendAssoc_9104(u: seq, zs: seq, t: seq)\n ensures (u + zs) + t == u + (zs + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_9105","instance":9105,"id":195776,"goal":"lemma SeqTakeDrop_9105(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_9106","instance":9106,"id":195777,"goal":"lemma SeqReverseLen_9106(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_9107","instance":9107,"id":195778,"goal":"lemma SeqReverseIdem_9107(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_9108","instance":9108,"id":195779,"goal":"lemma SeqMapLen_9108(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_9109","instance":9109,"id":195780,"goal":"lemma SeqFilterLe_9109(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_9110","instance":9110,"id":195781,"goal":"lemma SeqMemberAppend_9110(s: seq, u: seq)\n ensures x in s + u <==> x in s || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_9111","instance":9111,"id":195782,"goal":"lemma SeqAppendLen_9111(s: seq, xs: seq)\n ensures |s + xs| == |s| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_9112","instance":9112,"id":195783,"goal":"lemma SeqAppendNil_9112(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_9113","instance":9113,"id":195784,"goal":"lemma SeqNilAppend_9113(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_9114","instance":9114,"id":195785,"goal":"lemma SeqAppendAssoc_9114(t: seq, xs: seq, zs: seq)\n ensures (t + xs) + zs == t + (xs + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_9115","instance":9115,"id":195786,"goal":"lemma SeqTakeDrop_9115(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_9116","instance":9116,"id":195787,"goal":"lemma SeqReverseLen_9116(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_9117","instance":9117,"id":195788,"goal":"lemma SeqReverseIdem_9117(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_9118","instance":9118,"id":195789,"goal":"lemma SeqMapLen_9118(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_9119","instance":9119,"id":195790,"goal":"lemma SeqFilterLe_9119(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_9120","instance":9120,"id":195791,"goal":"lemma SeqMemberAppend_9120(xs: seq, ys: seq)\n ensures x in xs + ys <==> x in xs || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_9121","instance":9121,"id":195792,"goal":"lemma SeqAppendLen_9121(zs: seq, xs: seq)\n ensures |zs + xs| == |zs| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_9122","instance":9122,"id":195793,"goal":"lemma SeqAppendNil_9122(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_9123","instance":9123,"id":195794,"goal":"lemma SeqNilAppend_9123(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_9124","instance":9124,"id":195795,"goal":"lemma SeqAppendAssoc_9124(ys: seq, t: seq, zs: seq)\n ensures (ys + t) + zs == ys + (t + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_9125","instance":9125,"id":195796,"goal":"lemma SeqTakeDrop_9125(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_9126","instance":9126,"id":195797,"goal":"lemma SeqReverseLen_9126(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_9127","instance":9127,"id":195798,"goal":"lemma SeqReverseIdem_9127(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_9128","instance":9128,"id":195799,"goal":"lemma SeqMapLen_9128(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_9129","instance":9129,"id":195800,"goal":"lemma SeqFilterLe_9129(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_9130","instance":9130,"id":195801,"goal":"lemma SeqMemberAppend_9130(s: seq, ys: seq)\n ensures x in s + ys <==> x in s || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_9131","instance":9131,"id":195802,"goal":"lemma SeqAppendLen_9131(ys: seq, u: seq)\n ensures |ys + u| == |ys| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_9132","instance":9132,"id":195803,"goal":"lemma SeqAppendNil_9132(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_9133","instance":9133,"id":195804,"goal":"lemma SeqNilAppend_9133(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_9134","instance":9134,"id":195805,"goal":"lemma SeqAppendAssoc_9134(xs: seq, ys: seq, s: seq)\n ensures (xs + ys) + s == xs + (ys + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_9135","instance":9135,"id":195806,"goal":"lemma SeqTakeDrop_9135(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_9136","instance":9136,"id":195807,"goal":"lemma SeqReverseLen_9136(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_9137","instance":9137,"id":195808,"goal":"lemma SeqReverseIdem_9137(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_9138","instance":9138,"id":195809,"goal":"lemma SeqMapLen_9138(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_9139","instance":9139,"id":195810,"goal":"lemma SeqFilterLe_9139(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_9140","instance":9140,"id":195811,"goal":"lemma SeqMemberAppend_9140(t: seq, zs: seq)\n ensures x in t + zs <==> x in t || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_9141","instance":9141,"id":195812,"goal":"lemma SeqAppendLen_9141(t: seq, ys: seq)\n ensures |t + ys| == |t| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_9142","instance":9142,"id":195813,"goal":"lemma SeqAppendNil_9142(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_9143","instance":9143,"id":195814,"goal":"lemma SeqNilAppend_9143(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_9144","instance":9144,"id":195815,"goal":"lemma SeqAppendAssoc_9144(zs: seq, u: seq, xs: seq)\n ensures (zs + u) + xs == zs + (u + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_9145","instance":9145,"id":195816,"goal":"lemma SeqTakeDrop_9145(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_9146","instance":9146,"id":195817,"goal":"lemma SeqReverseLen_9146(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_9147","instance":9147,"id":195818,"goal":"lemma SeqReverseIdem_9147(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_9148","instance":9148,"id":195819,"goal":"lemma SeqMapLen_9148(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_9149","instance":9149,"id":195820,"goal":"lemma SeqFilterLe_9149(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_9150","instance":9150,"id":195821,"goal":"lemma SeqMemberAppend_9150(xs: seq, t: seq)\n ensures x in xs + t <==> x in xs || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_9151","instance":9151,"id":195822,"goal":"lemma SeqAppendLen_9151(ys: seq, u: seq)\n ensures |ys + u| == |ys| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_9152","instance":9152,"id":195823,"goal":"lemma SeqAppendNil_9152(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_9153","instance":9153,"id":195824,"goal":"lemma SeqNilAppend_9153(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_9154","instance":9154,"id":195825,"goal":"lemma SeqAppendAssoc_9154(ys: seq, s: seq, t: seq)\n ensures (ys + s) + t == ys + (s + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_9155","instance":9155,"id":195826,"goal":"lemma SeqTakeDrop_9155(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_9156","instance":9156,"id":195827,"goal":"lemma SeqReverseLen_9156(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_9157","instance":9157,"id":195828,"goal":"lemma SeqReverseIdem_9157(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_9158","instance":9158,"id":195829,"goal":"lemma SeqMapLen_9158(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_9159","instance":9159,"id":195830,"goal":"lemma SeqFilterLe_9159(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_9160","instance":9160,"id":195831,"goal":"lemma SeqMemberAppend_9160(t: seq, u: seq)\n ensures x in t + u <==> x in t || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_9161","instance":9161,"id":195832,"goal":"lemma SeqAppendLen_9161(ys: seq, t: seq)\n ensures |ys + t| == |ys| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_9162","instance":9162,"id":195833,"goal":"lemma SeqAppendNil_9162(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_9163","instance":9163,"id":195834,"goal":"lemma SeqNilAppend_9163(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_9164","instance":9164,"id":195835,"goal":"lemma SeqAppendAssoc_9164(ys: seq, t: seq, zs: seq)\n ensures (ys + t) + zs == ys + (t + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_9165","instance":9165,"id":195836,"goal":"lemma SeqTakeDrop_9165(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_9166","instance":9166,"id":195837,"goal":"lemma SeqReverseLen_9166(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_9167","instance":9167,"id":195838,"goal":"lemma SeqReverseIdem_9167(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_9168","instance":9168,"id":195839,"goal":"lemma SeqMapLen_9168(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_9169","instance":9169,"id":195840,"goal":"lemma SeqFilterLe_9169(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_9170","instance":9170,"id":195841,"goal":"lemma SeqMemberAppend_9170(zs: seq, u: seq)\n ensures x in zs + u <==> x in zs || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_9171","instance":9171,"id":195842,"goal":"lemma SeqAppendLen_9171(ys: seq, u: seq)\n ensures |ys + u| == |ys| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_9172","instance":9172,"id":195843,"goal":"lemma SeqAppendNil_9172(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_9173","instance":9173,"id":195844,"goal":"lemma SeqNilAppend_9173(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_9174","instance":9174,"id":195845,"goal":"lemma SeqAppendAssoc_9174(t: seq, xs: seq, u: seq)\n ensures (t + xs) + u == t + (xs + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_9175","instance":9175,"id":195846,"goal":"lemma SeqTakeDrop_9175(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_9176","instance":9176,"id":195847,"goal":"lemma SeqReverseLen_9176(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_9177","instance":9177,"id":195848,"goal":"lemma SeqReverseIdem_9177(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_9178","instance":9178,"id":195849,"goal":"lemma SeqMapLen_9178(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_9179","instance":9179,"id":195850,"goal":"lemma SeqFilterLe_9179(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_9180","instance":9180,"id":195851,"goal":"lemma SeqMemberAppend_9180(s: seq, xs: seq)\n ensures x in s + xs <==> x in s || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_9181","instance":9181,"id":195852,"goal":"lemma SeqAppendLen_9181(zs: seq, xs: seq)\n ensures |zs + xs| == |zs| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_9182","instance":9182,"id":195853,"goal":"lemma SeqAppendNil_9182(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_9183","instance":9183,"id":195854,"goal":"lemma SeqNilAppend_9183(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_9184","instance":9184,"id":195855,"goal":"lemma SeqAppendAssoc_9184(t: seq, zs: seq, ys: seq)\n ensures (t + zs) + ys == t + (zs + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_9185","instance":9185,"id":195856,"goal":"lemma SeqTakeDrop_9185(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_9186","instance":9186,"id":195857,"goal":"lemma SeqReverseLen_9186(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_9187","instance":9187,"id":195858,"goal":"lemma SeqReverseIdem_9187(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_9188","instance":9188,"id":195859,"goal":"lemma SeqMapLen_9188(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_9189","instance":9189,"id":195860,"goal":"lemma SeqFilterLe_9189(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_9190","instance":9190,"id":195861,"goal":"lemma SeqMemberAppend_9190(u: seq, t: seq)\n ensures x in u + t <==> x in u || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_9191","instance":9191,"id":195862,"goal":"lemma SeqAppendLen_9191(ys: seq, t: seq)\n ensures |ys + t| == |ys| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_9192","instance":9192,"id":195863,"goal":"lemma SeqAppendNil_9192(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_9193","instance":9193,"id":195864,"goal":"lemma SeqNilAppend_9193(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_9194","instance":9194,"id":195865,"goal":"lemma SeqAppendAssoc_9194(ys: seq, s: seq, xs: seq)\n ensures (ys + s) + xs == ys + (s + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_9195","instance":9195,"id":195866,"goal":"lemma SeqTakeDrop_9195(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_9196","instance":9196,"id":195867,"goal":"lemma SeqReverseLen_9196(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_9197","instance":9197,"id":195868,"goal":"lemma SeqReverseIdem_9197(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_9198","instance":9198,"id":195869,"goal":"lemma SeqMapLen_9198(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_9199","instance":9199,"id":195870,"goal":"lemma SeqFilterLe_9199(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_9200","instance":9200,"id":195871,"goal":"lemma SeqMemberAppend_9200(t: seq, zs: seq)\n ensures x in t + zs <==> x in t || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_9201","instance":9201,"id":195872,"goal":"lemma SeqAppendLen_9201(s: seq, ys: seq)\n ensures |s + ys| == |s| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_9202","instance":9202,"id":195873,"goal":"lemma SeqAppendNil_9202(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_9203","instance":9203,"id":195874,"goal":"lemma SeqNilAppend_9203(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_9204","instance":9204,"id":195875,"goal":"lemma SeqAppendAssoc_9204(t: seq, s: seq, ys: seq)\n ensures (t + s) + ys == t + (s + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_9205","instance":9205,"id":195876,"goal":"lemma SeqTakeDrop_9205(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_9206","instance":9206,"id":195877,"goal":"lemma SeqReverseLen_9206(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_9207","instance":9207,"id":195878,"goal":"lemma SeqReverseIdem_9207(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_9208","instance":9208,"id":195879,"goal":"lemma SeqMapLen_9208(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_9209","instance":9209,"id":195880,"goal":"lemma SeqFilterLe_9209(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_9210","instance":9210,"id":195881,"goal":"lemma SeqMemberAppend_9210(xs: seq, ys: seq)\n ensures x in xs + ys <==> x in xs || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_9211","instance":9211,"id":195882,"goal":"lemma SeqAppendLen_9211(zs: seq, ys: seq)\n ensures |zs + ys| == |zs| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_9212","instance":9212,"id":195883,"goal":"lemma SeqAppendNil_9212(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_9213","instance":9213,"id":195884,"goal":"lemma SeqNilAppend_9213(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_9214","instance":9214,"id":195885,"goal":"lemma SeqAppendAssoc_9214(zs: seq, s: seq, t: seq)\n ensures (zs + s) + t == zs + (s + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_9215","instance":9215,"id":195886,"goal":"lemma SeqTakeDrop_9215(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_9216","instance":9216,"id":195887,"goal":"lemma SeqReverseLen_9216(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_9217","instance":9217,"id":195888,"goal":"lemma SeqReverseIdem_9217(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_9218","instance":9218,"id":195889,"goal":"lemma SeqMapLen_9218(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_9219","instance":9219,"id":195890,"goal":"lemma SeqFilterLe_9219(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_9220","instance":9220,"id":195891,"goal":"lemma SeqMemberAppend_9220(t: seq, u: seq)\n ensures x in t + u <==> x in t || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_9221","instance":9221,"id":195892,"goal":"lemma SeqAppendLen_9221(xs: seq, ys: seq)\n ensures |xs + ys| == |xs| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_9222","instance":9222,"id":195893,"goal":"lemma SeqAppendNil_9222(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_9223","instance":9223,"id":195894,"goal":"lemma SeqNilAppend_9223(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_9224","instance":9224,"id":195895,"goal":"lemma SeqAppendAssoc_9224(s: seq, zs: seq, ys: seq)\n ensures (s + zs) + ys == s + (zs + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_9225","instance":9225,"id":195896,"goal":"lemma SeqTakeDrop_9225(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_9226","instance":9226,"id":195897,"goal":"lemma SeqReverseLen_9226(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_9227","instance":9227,"id":195898,"goal":"lemma SeqReverseIdem_9227(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_9228","instance":9228,"id":195899,"goal":"lemma SeqMapLen_9228(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_9229","instance":9229,"id":195900,"goal":"lemma SeqFilterLe_9229(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_9230","instance":9230,"id":195901,"goal":"lemma SeqMemberAppend_9230(zs: seq, u: seq)\n ensures x in zs + u <==> x in zs || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_9231","instance":9231,"id":195902,"goal":"lemma SeqAppendLen_9231(s: seq, t: seq)\n ensures |s + t| == |s| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_9232","instance":9232,"id":195903,"goal":"lemma SeqAppendNil_9232(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_9233","instance":9233,"id":195904,"goal":"lemma SeqNilAppend_9233(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_9234","instance":9234,"id":195905,"goal":"lemma SeqAppendAssoc_9234(xs: seq, t: seq, zs: seq)\n ensures (xs + t) + zs == xs + (t + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_9235","instance":9235,"id":195906,"goal":"lemma SeqTakeDrop_9235(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_9236","instance":9236,"id":195907,"goal":"lemma SeqReverseLen_9236(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_9237","instance":9237,"id":195908,"goal":"lemma SeqReverseIdem_9237(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_9238","instance":9238,"id":195909,"goal":"lemma SeqMapLen_9238(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_9239","instance":9239,"id":195910,"goal":"lemma SeqFilterLe_9239(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_9240","instance":9240,"id":195911,"goal":"lemma SeqMemberAppend_9240(u: seq, zs: seq)\n ensures x in u + zs <==> x in u || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_9241","instance":9241,"id":195912,"goal":"lemma SeqAppendLen_9241(zs: seq, u: seq)\n ensures |zs + u| == |zs| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_9242","instance":9242,"id":195913,"goal":"lemma SeqAppendNil_9242(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_9243","instance":9243,"id":195914,"goal":"lemma SeqNilAppend_9243(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_9244","instance":9244,"id":195915,"goal":"lemma SeqAppendAssoc_9244(t: seq, zs: seq, ys: seq)\n ensures (t + zs) + ys == t + (zs + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_9245","instance":9245,"id":195916,"goal":"lemma SeqTakeDrop_9245(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_9246","instance":9246,"id":195917,"goal":"lemma SeqReverseLen_9246(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_9247","instance":9247,"id":195918,"goal":"lemma SeqReverseIdem_9247(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_9248","instance":9248,"id":195919,"goal":"lemma SeqMapLen_9248(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_9249","instance":9249,"id":195920,"goal":"lemma SeqFilterLe_9249(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_9250","instance":9250,"id":195921,"goal":"lemma SeqMemberAppend_9250(xs: seq, zs: seq)\n ensures x in xs + zs <==> x in xs || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_9251","instance":9251,"id":195922,"goal":"lemma SeqAppendLen_9251(xs: seq, t: seq)\n ensures |xs + t| == |xs| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_9252","instance":9252,"id":195923,"goal":"lemma SeqAppendNil_9252(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_9253","instance":9253,"id":195924,"goal":"lemma SeqNilAppend_9253(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_9254","instance":9254,"id":195925,"goal":"lemma SeqAppendAssoc_9254(ys: seq, xs: seq, t: seq)\n ensures (ys + xs) + t == ys + (xs + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_9255","instance":9255,"id":195926,"goal":"lemma SeqTakeDrop_9255(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_9256","instance":9256,"id":195927,"goal":"lemma SeqReverseLen_9256(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_9257","instance":9257,"id":195928,"goal":"lemma SeqReverseIdem_9257(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_9258","instance":9258,"id":195929,"goal":"lemma SeqMapLen_9258(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_9259","instance":9259,"id":195930,"goal":"lemma SeqFilterLe_9259(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_9260","instance":9260,"id":195931,"goal":"lemma SeqMemberAppend_9260(u: seq, zs: seq)\n ensures x in u + zs <==> x in u || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_9261","instance":9261,"id":195932,"goal":"lemma SeqAppendLen_9261(zs: seq, u: seq)\n ensures |zs + u| == |zs| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_9262","instance":9262,"id":195933,"goal":"lemma SeqAppendNil_9262(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_9263","instance":9263,"id":195934,"goal":"lemma SeqNilAppend_9263(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_9264","instance":9264,"id":195935,"goal":"lemma SeqAppendAssoc_9264(zs: seq, s: seq, ys: seq)\n ensures (zs + s) + ys == zs + (s + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_9265","instance":9265,"id":195936,"goal":"lemma SeqTakeDrop_9265(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_9266","instance":9266,"id":195937,"goal":"lemma SeqReverseLen_9266(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_9267","instance":9267,"id":195938,"goal":"lemma SeqReverseIdem_9267(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_9268","instance":9268,"id":195939,"goal":"lemma SeqMapLen_9268(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_9269","instance":9269,"id":195940,"goal":"lemma SeqFilterLe_9269(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_9270","instance":9270,"id":195941,"goal":"lemma SeqMemberAppend_9270(xs: seq, s: seq)\n ensures x in xs + s <==> x in xs || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_9271","instance":9271,"id":195942,"goal":"lemma SeqAppendLen_9271(u: seq, t: seq)\n ensures |u + t| == |u| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_9272","instance":9272,"id":195943,"goal":"lemma SeqAppendNil_9272(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_9273","instance":9273,"id":195944,"goal":"lemma SeqNilAppend_9273(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_9274","instance":9274,"id":195945,"goal":"lemma SeqAppendAssoc_9274(ys: seq, xs: seq, t: seq)\n ensures (ys + xs) + t == ys + (xs + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_9275","instance":9275,"id":195946,"goal":"lemma SeqTakeDrop_9275(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_9276","instance":9276,"id":195947,"goal":"lemma SeqReverseLen_9276(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_9277","instance":9277,"id":195948,"goal":"lemma SeqReverseIdem_9277(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_9278","instance":9278,"id":195949,"goal":"lemma SeqMapLen_9278(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_9279","instance":9279,"id":195950,"goal":"lemma SeqFilterLe_9279(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_9280","instance":9280,"id":195951,"goal":"lemma SeqMemberAppend_9280(t: seq, s: seq)\n ensures x in t + s <==> x in t || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_9281","instance":9281,"id":195952,"goal":"lemma SeqAppendLen_9281(ys: seq, s: seq)\n ensures |ys + s| == |ys| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_9282","instance":9282,"id":195953,"goal":"lemma SeqAppendNil_9282(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_9283","instance":9283,"id":195954,"goal":"lemma SeqNilAppend_9283(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_9284","instance":9284,"id":195955,"goal":"lemma SeqAppendAssoc_9284(xs: seq, s: seq, u: seq)\n ensures (xs + s) + u == xs + (s + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_9285","instance":9285,"id":195956,"goal":"lemma SeqTakeDrop_9285(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_9286","instance":9286,"id":195957,"goal":"lemma SeqReverseLen_9286(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_9287","instance":9287,"id":195958,"goal":"lemma SeqReverseIdem_9287(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_9288","instance":9288,"id":195959,"goal":"lemma SeqMapLen_9288(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_9289","instance":9289,"id":195960,"goal":"lemma SeqFilterLe_9289(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_9290","instance":9290,"id":195961,"goal":"lemma SeqMemberAppend_9290(zs: seq, ys: seq)\n ensures x in zs + ys <==> x in zs || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_9291","instance":9291,"id":195962,"goal":"lemma SeqAppendLen_9291(ys: seq, u: seq)\n ensures |ys + u| == |ys| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_9292","instance":9292,"id":195963,"goal":"lemma SeqAppendNil_9292(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_9293","instance":9293,"id":195964,"goal":"lemma SeqNilAppend_9293(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_9294","instance":9294,"id":195965,"goal":"lemma SeqAppendAssoc_9294(t: seq, ys: seq, u: seq)\n ensures (t + ys) + u == t + (ys + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_9295","instance":9295,"id":195966,"goal":"lemma SeqTakeDrop_9295(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_9296","instance":9296,"id":195967,"goal":"lemma SeqReverseLen_9296(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_9297","instance":9297,"id":195968,"goal":"lemma SeqReverseIdem_9297(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_9298","instance":9298,"id":195969,"goal":"lemma SeqMapLen_9298(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_9299","instance":9299,"id":195970,"goal":"lemma SeqFilterLe_9299(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_9300","instance":9300,"id":195971,"goal":"lemma SeqMemberAppend_9300(ys: seq, xs: seq)\n ensures x in ys + xs <==> x in ys || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_9301","instance":9301,"id":195972,"goal":"lemma SeqAppendLen_9301(t: seq, zs: seq)\n ensures |t + zs| == |t| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_9302","instance":9302,"id":195973,"goal":"lemma SeqAppendNil_9302(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_9303","instance":9303,"id":195974,"goal":"lemma SeqNilAppend_9303(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_9304","instance":9304,"id":195975,"goal":"lemma SeqAppendAssoc_9304(s: seq, xs: seq, zs: seq)\n ensures (s + xs) + zs == s + (xs + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_9305","instance":9305,"id":195976,"goal":"lemma SeqTakeDrop_9305(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_9306","instance":9306,"id":195977,"goal":"lemma SeqReverseLen_9306(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_9307","instance":9307,"id":195978,"goal":"lemma SeqReverseIdem_9307(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_9308","instance":9308,"id":195979,"goal":"lemma SeqMapLen_9308(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_9309","instance":9309,"id":195980,"goal":"lemma SeqFilterLe_9309(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_9310","instance":9310,"id":195981,"goal":"lemma SeqMemberAppend_9310(ys: seq, s: seq)\n ensures x in ys + s <==> x in ys || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_9311","instance":9311,"id":195982,"goal":"lemma SeqAppendLen_9311(xs: seq, zs: seq)\n ensures |xs + zs| == |xs| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_9312","instance":9312,"id":195983,"goal":"lemma SeqAppendNil_9312(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_9313","instance":9313,"id":195984,"goal":"lemma SeqNilAppend_9313(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_9314","instance":9314,"id":195985,"goal":"lemma SeqAppendAssoc_9314(xs: seq, u: seq, ys: seq)\n ensures (xs + u) + ys == xs + (u + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_9315","instance":9315,"id":195986,"goal":"lemma SeqTakeDrop_9315(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_9316","instance":9316,"id":195987,"goal":"lemma SeqReverseLen_9316(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_9317","instance":9317,"id":195988,"goal":"lemma SeqReverseIdem_9317(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_9318","instance":9318,"id":195989,"goal":"lemma SeqMapLen_9318(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_9319","instance":9319,"id":195990,"goal":"lemma SeqFilterLe_9319(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_9320","instance":9320,"id":195991,"goal":"lemma SeqMemberAppend_9320(t: seq, xs: seq)\n ensures x in t + xs <==> x in t || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_9321","instance":9321,"id":195992,"goal":"lemma SeqAppendLen_9321(u: seq, t: seq)\n ensures |u + t| == |u| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_9322","instance":9322,"id":195993,"goal":"lemma SeqAppendNil_9322(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_9323","instance":9323,"id":195994,"goal":"lemma SeqNilAppend_9323(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_9324","instance":9324,"id":195995,"goal":"lemma SeqAppendAssoc_9324(t: seq, s: seq, ys: seq)\n ensures (t + s) + ys == t + (s + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_9325","instance":9325,"id":195996,"goal":"lemma SeqTakeDrop_9325(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_9326","instance":9326,"id":195997,"goal":"lemma SeqReverseLen_9326(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_9327","instance":9327,"id":195998,"goal":"lemma SeqReverseIdem_9327(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_9328","instance":9328,"id":195999,"goal":"lemma SeqMapLen_9328(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_9329","instance":9329,"id":196000,"goal":"lemma SeqFilterLe_9329(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_9330","instance":9330,"id":196001,"goal":"lemma SeqMemberAppend_9330(xs: seq, zs: seq)\n ensures x in xs + zs <==> x in xs || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_9331","instance":9331,"id":196002,"goal":"lemma SeqAppendLen_9331(s: seq, ys: seq)\n ensures |s + ys| == |s| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_9332","instance":9332,"id":196003,"goal":"lemma SeqAppendNil_9332(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_9333","instance":9333,"id":196004,"goal":"lemma SeqNilAppend_9333(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_9334","instance":9334,"id":196005,"goal":"lemma SeqAppendAssoc_9334(t: seq, ys: seq, xs: seq)\n ensures (t + ys) + xs == t + (ys + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_9335","instance":9335,"id":196006,"goal":"lemma SeqTakeDrop_9335(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_9336","instance":9336,"id":196007,"goal":"lemma SeqReverseLen_9336(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_9337","instance":9337,"id":196008,"goal":"lemma SeqReverseIdem_9337(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_9338","instance":9338,"id":196009,"goal":"lemma SeqMapLen_9338(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_9339","instance":9339,"id":196010,"goal":"lemma SeqFilterLe_9339(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_9340","instance":9340,"id":196011,"goal":"lemma SeqMemberAppend_9340(t: seq, u: seq)\n ensures x in t + u <==> x in t || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_9341","instance":9341,"id":196012,"goal":"lemma SeqAppendLen_9341(zs: seq, u: seq)\n ensures |zs + u| == |zs| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_9342","instance":9342,"id":196013,"goal":"lemma SeqAppendNil_9342(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_9343","instance":9343,"id":196014,"goal":"lemma SeqNilAppend_9343(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_9344","instance":9344,"id":196015,"goal":"lemma SeqAppendAssoc_9344(u: seq, xs: seq, zs: seq)\n ensures (u + xs) + zs == u + (xs + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_9345","instance":9345,"id":196016,"goal":"lemma SeqTakeDrop_9345(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_9346","instance":9346,"id":196017,"goal":"lemma SeqReverseLen_9346(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_9347","instance":9347,"id":196018,"goal":"lemma SeqReverseIdem_9347(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_9348","instance":9348,"id":196019,"goal":"lemma SeqMapLen_9348(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_9349","instance":9349,"id":196020,"goal":"lemma SeqFilterLe_9349(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_9350","instance":9350,"id":196021,"goal":"lemma SeqMemberAppend_9350(u: seq, s: seq)\n ensures x in u + s <==> x in u || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_9351","instance":9351,"id":196022,"goal":"lemma SeqAppendLen_9351(u: seq, ys: seq)\n ensures |u + ys| == |u| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_9352","instance":9352,"id":196023,"goal":"lemma SeqAppendNil_9352(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_9353","instance":9353,"id":196024,"goal":"lemma SeqNilAppend_9353(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_9354","instance":9354,"id":196025,"goal":"lemma SeqAppendAssoc_9354(xs: seq, u: seq, s: seq)\n ensures (xs + u) + s == xs + (u + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_9355","instance":9355,"id":196026,"goal":"lemma SeqTakeDrop_9355(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_9356","instance":9356,"id":196027,"goal":"lemma SeqReverseLen_9356(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_9357","instance":9357,"id":196028,"goal":"lemma SeqReverseIdem_9357(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_9358","instance":9358,"id":196029,"goal":"lemma SeqMapLen_9358(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_9359","instance":9359,"id":196030,"goal":"lemma SeqFilterLe_9359(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_9360","instance":9360,"id":196031,"goal":"lemma SeqMemberAppend_9360(xs: seq, t: seq)\n ensures x in xs + t <==> x in xs || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_9361","instance":9361,"id":196032,"goal":"lemma SeqAppendLen_9361(ys: seq, t: seq)\n ensures |ys + t| == |ys| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_9362","instance":9362,"id":196033,"goal":"lemma SeqAppendNil_9362(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_9363","instance":9363,"id":196034,"goal":"lemma SeqNilAppend_9363(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_9364","instance":9364,"id":196035,"goal":"lemma SeqAppendAssoc_9364(xs: seq, zs: seq, ys: seq)\n ensures (xs + zs) + ys == xs + (zs + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_9365","instance":9365,"id":196036,"goal":"lemma SeqTakeDrop_9365(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_9366","instance":9366,"id":196037,"goal":"lemma SeqReverseLen_9366(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_9367","instance":9367,"id":196038,"goal":"lemma SeqReverseIdem_9367(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_9368","instance":9368,"id":196039,"goal":"lemma SeqMapLen_9368(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_9369","instance":9369,"id":196040,"goal":"lemma SeqFilterLe_9369(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_9370","instance":9370,"id":196041,"goal":"lemma SeqMemberAppend_9370(s: seq, ys: seq)\n ensures x in s + ys <==> x in s || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_9371","instance":9371,"id":196042,"goal":"lemma SeqAppendLen_9371(t: seq, xs: seq)\n ensures |t + xs| == |t| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_9372","instance":9372,"id":196043,"goal":"lemma SeqAppendNil_9372(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_9373","instance":9373,"id":196044,"goal":"lemma SeqNilAppend_9373(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_9374","instance":9374,"id":196045,"goal":"lemma SeqAppendAssoc_9374(s: seq, u: seq, xs: seq)\n ensures (s + u) + xs == s + (u + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_9375","instance":9375,"id":196046,"goal":"lemma SeqTakeDrop_9375(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_9376","instance":9376,"id":196047,"goal":"lemma SeqReverseLen_9376(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_9377","instance":9377,"id":196048,"goal":"lemma SeqReverseIdem_9377(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_9378","instance":9378,"id":196049,"goal":"lemma SeqMapLen_9378(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_9379","instance":9379,"id":196050,"goal":"lemma SeqFilterLe_9379(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_9380","instance":9380,"id":196051,"goal":"lemma SeqMemberAppend_9380(xs: seq, zs: seq)\n ensures x in xs + zs <==> x in xs || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_9381","instance":9381,"id":196052,"goal":"lemma SeqAppendLen_9381(xs: seq, t: seq)\n ensures |xs + t| == |xs| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_9382","instance":9382,"id":196053,"goal":"lemma SeqAppendNil_9382(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_9383","instance":9383,"id":196054,"goal":"lemma SeqNilAppend_9383(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_9384","instance":9384,"id":196055,"goal":"lemma SeqAppendAssoc_9384(u: seq, ys: seq, zs: seq)\n ensures (u + ys) + zs == u + (ys + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_9385","instance":9385,"id":196056,"goal":"lemma SeqTakeDrop_9385(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_9386","instance":9386,"id":196057,"goal":"lemma SeqReverseLen_9386(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_9387","instance":9387,"id":196058,"goal":"lemma SeqReverseIdem_9387(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_9388","instance":9388,"id":196059,"goal":"lemma SeqMapLen_9388(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_9389","instance":9389,"id":196060,"goal":"lemma SeqFilterLe_9389(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_9390","instance":9390,"id":196061,"goal":"lemma SeqMemberAppend_9390(xs: seq, u: seq)\n ensures x in xs + u <==> x in xs || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_9391","instance":9391,"id":196062,"goal":"lemma SeqAppendLen_9391(zs: seq, ys: seq)\n ensures |zs + ys| == |zs| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_9392","instance":9392,"id":196063,"goal":"lemma SeqAppendNil_9392(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_9393","instance":9393,"id":196064,"goal":"lemma SeqNilAppend_9393(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_9394","instance":9394,"id":196065,"goal":"lemma SeqAppendAssoc_9394(ys: seq, u: seq, t: seq)\n ensures (ys + u) + t == ys + (u + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_9395","instance":9395,"id":196066,"goal":"lemma SeqTakeDrop_9395(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_9396","instance":9396,"id":196067,"goal":"lemma SeqReverseLen_9396(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_9397","instance":9397,"id":196068,"goal":"lemma SeqReverseIdem_9397(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_9398","instance":9398,"id":196069,"goal":"lemma SeqMapLen_9398(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_9399","instance":9399,"id":196070,"goal":"lemma SeqFilterLe_9399(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_9400","instance":9400,"id":196071,"goal":"lemma SeqMemberAppend_9400(t: seq, u: seq)\n ensures x in t + u <==> x in t || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_9401","instance":9401,"id":196072,"goal":"lemma SeqAppendLen_9401(s: seq, ys: seq)\n ensures |s + ys| == |s| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_9402","instance":9402,"id":196073,"goal":"lemma SeqAppendNil_9402(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_9403","instance":9403,"id":196074,"goal":"lemma SeqNilAppend_9403(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_9404","instance":9404,"id":196075,"goal":"lemma SeqAppendAssoc_9404(xs: seq, u: seq, ys: seq)\n ensures (xs + u) + ys == xs + (u + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_9405","instance":9405,"id":196076,"goal":"lemma SeqTakeDrop_9405(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_9406","instance":9406,"id":196077,"goal":"lemma SeqReverseLen_9406(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_9407","instance":9407,"id":196078,"goal":"lemma SeqReverseIdem_9407(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_9408","instance":9408,"id":196079,"goal":"lemma SeqMapLen_9408(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_9409","instance":9409,"id":196080,"goal":"lemma SeqFilterLe_9409(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_9410","instance":9410,"id":196081,"goal":"lemma SeqMemberAppend_9410(zs: seq, xs: seq)\n ensures x in zs + xs <==> x in zs || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_9411","instance":9411,"id":196082,"goal":"lemma SeqAppendLen_9411(t: seq, s: seq)\n ensures |t + s| == |t| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_9412","instance":9412,"id":196083,"goal":"lemma SeqAppendNil_9412(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_9413","instance":9413,"id":196084,"goal":"lemma SeqNilAppend_9413(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_9414","instance":9414,"id":196085,"goal":"lemma SeqAppendAssoc_9414(u: seq, t: seq, xs: seq)\n ensures (u + t) + xs == u + (t + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_9415","instance":9415,"id":196086,"goal":"lemma SeqTakeDrop_9415(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_9416","instance":9416,"id":196087,"goal":"lemma SeqReverseLen_9416(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_9417","instance":9417,"id":196088,"goal":"lemma SeqReverseIdem_9417(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_9418","instance":9418,"id":196089,"goal":"lemma SeqMapLen_9418(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_9419","instance":9419,"id":196090,"goal":"lemma SeqFilterLe_9419(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_9420","instance":9420,"id":196091,"goal":"lemma SeqMemberAppend_9420(ys: seq, t: seq)\n ensures x in ys + t <==> x in ys || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_9421","instance":9421,"id":196092,"goal":"lemma SeqAppendLen_9421(zs: seq, t: seq)\n ensures |zs + t| == |zs| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_9422","instance":9422,"id":196093,"goal":"lemma SeqAppendNil_9422(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_9423","instance":9423,"id":196094,"goal":"lemma SeqNilAppend_9423(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_9424","instance":9424,"id":196095,"goal":"lemma SeqAppendAssoc_9424(zs: seq, ys: seq, u: seq)\n ensures (zs + ys) + u == zs + (ys + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_9425","instance":9425,"id":196096,"goal":"lemma SeqTakeDrop_9425(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_9426","instance":9426,"id":196097,"goal":"lemma SeqReverseLen_9426(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_9427","instance":9427,"id":196098,"goal":"lemma SeqReverseIdem_9427(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_9428","instance":9428,"id":196099,"goal":"lemma SeqMapLen_9428(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_9429","instance":9429,"id":196100,"goal":"lemma SeqFilterLe_9429(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_9430","instance":9430,"id":196101,"goal":"lemma SeqMemberAppend_9430(s: seq, u: seq)\n ensures x in s + u <==> x in s || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_9431","instance":9431,"id":196102,"goal":"lemma SeqAppendLen_9431(s: seq, t: seq)\n ensures |s + t| == |s| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_9432","instance":9432,"id":196103,"goal":"lemma SeqAppendNil_9432(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_9433","instance":9433,"id":196104,"goal":"lemma SeqNilAppend_9433(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_9434","instance":9434,"id":196105,"goal":"lemma SeqAppendAssoc_9434(ys: seq, u: seq, zs: seq)\n ensures (ys + u) + zs == ys + (u + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_9435","instance":9435,"id":196106,"goal":"lemma SeqTakeDrop_9435(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_9436","instance":9436,"id":196107,"goal":"lemma SeqReverseLen_9436(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_9437","instance":9437,"id":196108,"goal":"lemma SeqReverseIdem_9437(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_9438","instance":9438,"id":196109,"goal":"lemma SeqMapLen_9438(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_9439","instance":9439,"id":196110,"goal":"lemma SeqFilterLe_9439(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_9440","instance":9440,"id":196111,"goal":"lemma SeqMemberAppend_9440(t: seq, xs: seq)\n ensures x in t + xs <==> x in t || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_9441","instance":9441,"id":196112,"goal":"lemma SeqAppendLen_9441(u: seq, s: seq)\n ensures |u + s| == |u| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_9442","instance":9442,"id":196113,"goal":"lemma SeqAppendNil_9442(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_9443","instance":9443,"id":196114,"goal":"lemma SeqNilAppend_9443(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_9444","instance":9444,"id":196115,"goal":"lemma SeqAppendAssoc_9444(u: seq, s: seq, t: seq)\n ensures (u + s) + t == u + (s + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_9445","instance":9445,"id":196116,"goal":"lemma SeqTakeDrop_9445(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_9446","instance":9446,"id":196117,"goal":"lemma SeqReverseLen_9446(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_9447","instance":9447,"id":196118,"goal":"lemma SeqReverseIdem_9447(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_9448","instance":9448,"id":196119,"goal":"lemma SeqMapLen_9448(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_9449","instance":9449,"id":196120,"goal":"lemma SeqFilterLe_9449(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_9450","instance":9450,"id":196121,"goal":"lemma SeqMemberAppend_9450(ys: seq, zs: seq)\n ensures x in ys + zs <==> x in ys || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_9451","instance":9451,"id":196122,"goal":"lemma SeqAppendLen_9451(xs: seq, s: seq)\n ensures |xs + s| == |xs| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_9452","instance":9452,"id":196123,"goal":"lemma SeqAppendNil_9452(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_9453","instance":9453,"id":196124,"goal":"lemma SeqNilAppend_9453(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_9454","instance":9454,"id":196125,"goal":"lemma SeqAppendAssoc_9454(t: seq, ys: seq, u: seq)\n ensures (t + ys) + u == t + (ys + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_9455","instance":9455,"id":196126,"goal":"lemma SeqTakeDrop_9455(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_9456","instance":9456,"id":196127,"goal":"lemma SeqReverseLen_9456(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_9457","instance":9457,"id":196128,"goal":"lemma SeqReverseIdem_9457(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_9458","instance":9458,"id":196129,"goal":"lemma SeqMapLen_9458(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_9459","instance":9459,"id":196130,"goal":"lemma SeqFilterLe_9459(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_9460","instance":9460,"id":196131,"goal":"lemma SeqMemberAppend_9460(s: seq, u: seq)\n ensures x in s + u <==> x in s || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_9461","instance":9461,"id":196132,"goal":"lemma SeqAppendLen_9461(t: seq, zs: seq)\n ensures |t + zs| == |t| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_9462","instance":9462,"id":196133,"goal":"lemma SeqAppendNil_9462(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_9463","instance":9463,"id":196134,"goal":"lemma SeqNilAppend_9463(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_9464","instance":9464,"id":196135,"goal":"lemma SeqAppendAssoc_9464(t: seq, xs: seq, ys: seq)\n ensures (t + xs) + ys == t + (xs + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_9465","instance":9465,"id":196136,"goal":"lemma SeqTakeDrop_9465(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_9466","instance":9466,"id":196137,"goal":"lemma SeqReverseLen_9466(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_9467","instance":9467,"id":196138,"goal":"lemma SeqReverseIdem_9467(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_9468","instance":9468,"id":196139,"goal":"lemma SeqMapLen_9468(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_9469","instance":9469,"id":196140,"goal":"lemma SeqFilterLe_9469(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_9470","instance":9470,"id":196141,"goal":"lemma SeqMemberAppend_9470(s: seq, ys: seq)\n ensures x in s + ys <==> x in s || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_9471","instance":9471,"id":196142,"goal":"lemma SeqAppendLen_9471(t: seq, s: seq)\n ensures |t + s| == |t| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_9472","instance":9472,"id":196143,"goal":"lemma SeqAppendNil_9472(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_9473","instance":9473,"id":196144,"goal":"lemma SeqNilAppend_9473(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_9474","instance":9474,"id":196145,"goal":"lemma SeqAppendAssoc_9474(u: seq, s: seq, t: seq)\n ensures (u + s) + t == u + (s + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_9475","instance":9475,"id":196146,"goal":"lemma SeqTakeDrop_9475(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_9476","instance":9476,"id":196147,"goal":"lemma SeqReverseLen_9476(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_9477","instance":9477,"id":196148,"goal":"lemma SeqReverseIdem_9477(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_9478","instance":9478,"id":196149,"goal":"lemma SeqMapLen_9478(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_9479","instance":9479,"id":196150,"goal":"lemma SeqFilterLe_9479(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_9480","instance":9480,"id":196151,"goal":"lemma SeqMemberAppend_9480(u: seq, s: seq)\n ensures x in u + s <==> x in u || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_9481","instance":9481,"id":196152,"goal":"lemma SeqAppendLen_9481(zs: seq, t: seq)\n ensures |zs + t| == |zs| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_9482","instance":9482,"id":196153,"goal":"lemma SeqAppendNil_9482(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_9483","instance":9483,"id":196154,"goal":"lemma SeqNilAppend_9483(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_9484","instance":9484,"id":196155,"goal":"lemma SeqAppendAssoc_9484(ys: seq, s: seq, u: seq)\n ensures (ys + s) + u == ys + (s + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_9485","instance":9485,"id":196156,"goal":"lemma SeqTakeDrop_9485(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_9486","instance":9486,"id":196157,"goal":"lemma SeqReverseLen_9486(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_9487","instance":9487,"id":196158,"goal":"lemma SeqReverseIdem_9487(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_9488","instance":9488,"id":196159,"goal":"lemma SeqMapLen_9488(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_9489","instance":9489,"id":196160,"goal":"lemma SeqFilterLe_9489(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_9490","instance":9490,"id":196161,"goal":"lemma SeqMemberAppend_9490(u: seq, s: seq)\n ensures x in u + s <==> x in u || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_9491","instance":9491,"id":196162,"goal":"lemma SeqAppendLen_9491(t: seq, s: seq)\n ensures |t + s| == |t| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_9492","instance":9492,"id":196163,"goal":"lemma SeqAppendNil_9492(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_9493","instance":9493,"id":196164,"goal":"lemma SeqNilAppend_9493(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_9494","instance":9494,"id":196165,"goal":"lemma SeqAppendAssoc_9494(s: seq, ys: seq, u: seq)\n ensures (s + ys) + u == s + (ys + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_9495","instance":9495,"id":196166,"goal":"lemma SeqTakeDrop_9495(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_9496","instance":9496,"id":196167,"goal":"lemma SeqReverseLen_9496(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_9497","instance":9497,"id":196168,"goal":"lemma SeqReverseIdem_9497(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_9498","instance":9498,"id":196169,"goal":"lemma SeqMapLen_9498(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_9499","instance":9499,"id":196170,"goal":"lemma SeqFilterLe_9499(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_9500","instance":9500,"id":196171,"goal":"lemma SeqMemberAppend_9500(ys: seq, t: seq)\n ensures x in ys + t <==> x in ys || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_9501","instance":9501,"id":196172,"goal":"lemma SeqAppendLen_9501(xs: seq, zs: seq)\n ensures |xs + zs| == |xs| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_9502","instance":9502,"id":196173,"goal":"lemma SeqAppendNil_9502(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_9503","instance":9503,"id":196174,"goal":"lemma SeqNilAppend_9503(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_9504","instance":9504,"id":196175,"goal":"lemma SeqAppendAssoc_9504(s: seq, xs: seq, ys: seq)\n ensures (s + xs) + ys == s + (xs + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_9505","instance":9505,"id":196176,"goal":"lemma SeqTakeDrop_9505(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_9506","instance":9506,"id":196177,"goal":"lemma SeqReverseLen_9506(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_9507","instance":9507,"id":196178,"goal":"lemma SeqReverseIdem_9507(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_9508","instance":9508,"id":196179,"goal":"lemma SeqMapLen_9508(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_9509","instance":9509,"id":196180,"goal":"lemma SeqFilterLe_9509(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_9510","instance":9510,"id":196181,"goal":"lemma SeqMemberAppend_9510(zs: seq, s: seq)\n ensures x in zs + s <==> x in zs || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_9511","instance":9511,"id":196182,"goal":"lemma SeqAppendLen_9511(ys: seq, zs: seq)\n ensures |ys + zs| == |ys| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_9512","instance":9512,"id":196183,"goal":"lemma SeqAppendNil_9512(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_9513","instance":9513,"id":196184,"goal":"lemma SeqNilAppend_9513(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_9514","instance":9514,"id":196185,"goal":"lemma SeqAppendAssoc_9514(ys: seq, zs: seq, t: seq)\n ensures (ys + zs) + t == ys + (zs + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_9515","instance":9515,"id":196186,"goal":"lemma SeqTakeDrop_9515(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_9516","instance":9516,"id":196187,"goal":"lemma SeqReverseLen_9516(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_9517","instance":9517,"id":196188,"goal":"lemma SeqReverseIdem_9517(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_9518","instance":9518,"id":196189,"goal":"lemma SeqMapLen_9518(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_9519","instance":9519,"id":196190,"goal":"lemma SeqFilterLe_9519(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_9520","instance":9520,"id":196191,"goal":"lemma SeqMemberAppend_9520(s: seq, u: seq)\n ensures x in s + u <==> x in s || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_9521","instance":9521,"id":196192,"goal":"lemma SeqAppendLen_9521(s: seq, ys: seq)\n ensures |s + ys| == |s| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_9522","instance":9522,"id":196193,"goal":"lemma SeqAppendNil_9522(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_9523","instance":9523,"id":196194,"goal":"lemma SeqNilAppend_9523(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_9524","instance":9524,"id":196195,"goal":"lemma SeqAppendAssoc_9524(zs: seq, t: seq, s: seq)\n ensures (zs + t) + s == zs + (t + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_9525","instance":9525,"id":196196,"goal":"lemma SeqTakeDrop_9525(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_9526","instance":9526,"id":196197,"goal":"lemma SeqReverseLen_9526(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_9527","instance":9527,"id":196198,"goal":"lemma SeqReverseIdem_9527(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_9528","instance":9528,"id":196199,"goal":"lemma SeqMapLen_9528(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_9529","instance":9529,"id":196200,"goal":"lemma SeqFilterLe_9529(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_9530","instance":9530,"id":196201,"goal":"lemma SeqMemberAppend_9530(u: seq, xs: seq)\n ensures x in u + xs <==> x in u || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_9531","instance":9531,"id":196202,"goal":"lemma SeqAppendLen_9531(zs: seq, ys: seq)\n ensures |zs + ys| == |zs| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_9532","instance":9532,"id":196203,"goal":"lemma SeqAppendNil_9532(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_9533","instance":9533,"id":196204,"goal":"lemma SeqNilAppend_9533(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_9534","instance":9534,"id":196205,"goal":"lemma SeqAppendAssoc_9534(t: seq, s: seq, u: seq)\n ensures (t + s) + u == t + (s + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_9535","instance":9535,"id":196206,"goal":"lemma SeqTakeDrop_9535(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_9536","instance":9536,"id":196207,"goal":"lemma SeqReverseLen_9536(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_9537","instance":9537,"id":196208,"goal":"lemma SeqReverseIdem_9537(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_9538","instance":9538,"id":196209,"goal":"lemma SeqMapLen_9538(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_9539","instance":9539,"id":196210,"goal":"lemma SeqFilterLe_9539(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_9540","instance":9540,"id":196211,"goal":"lemma SeqMemberAppend_9540(zs: seq, t: seq)\n ensures x in zs + t <==> x in zs || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_9541","instance":9541,"id":196212,"goal":"lemma SeqAppendLen_9541(xs: seq, t: seq)\n ensures |xs + t| == |xs| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_9542","instance":9542,"id":196213,"goal":"lemma SeqAppendNil_9542(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_9543","instance":9543,"id":196214,"goal":"lemma SeqNilAppend_9543(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_9544","instance":9544,"id":196215,"goal":"lemma SeqAppendAssoc_9544(ys: seq, t: seq, u: seq)\n ensures (ys + t) + u == ys + (t + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_9545","instance":9545,"id":196216,"goal":"lemma SeqTakeDrop_9545(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_9546","instance":9546,"id":196217,"goal":"lemma SeqReverseLen_9546(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_9547","instance":9547,"id":196218,"goal":"lemma SeqReverseIdem_9547(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_9548","instance":9548,"id":196219,"goal":"lemma SeqMapLen_9548(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_9549","instance":9549,"id":196220,"goal":"lemma SeqFilterLe_9549(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_9550","instance":9550,"id":196221,"goal":"lemma SeqMemberAppend_9550(s: seq, xs: seq)\n ensures x in s + xs <==> x in s || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_9551","instance":9551,"id":196222,"goal":"lemma SeqAppendLen_9551(s: seq, ys: seq)\n ensures |s + ys| == |s| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_9552","instance":9552,"id":196223,"goal":"lemma SeqAppendNil_9552(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_9553","instance":9553,"id":196224,"goal":"lemma SeqNilAppend_9553(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_9554","instance":9554,"id":196225,"goal":"lemma SeqAppendAssoc_9554(s: seq, u: seq, ys: seq)\n ensures (s + u) + ys == s + (u + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_9555","instance":9555,"id":196226,"goal":"lemma SeqTakeDrop_9555(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_9556","instance":9556,"id":196227,"goal":"lemma SeqReverseLen_9556(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_9557","instance":9557,"id":196228,"goal":"lemma SeqReverseIdem_9557(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_9558","instance":9558,"id":196229,"goal":"lemma SeqMapLen_9558(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_9559","instance":9559,"id":196230,"goal":"lemma SeqFilterLe_9559(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_9560","instance":9560,"id":196231,"goal":"lemma SeqMemberAppend_9560(zs: seq, xs: seq)\n ensures x in zs + xs <==> x in zs || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_9561","instance":9561,"id":196232,"goal":"lemma SeqAppendLen_9561(t: seq, zs: seq)\n ensures |t + zs| == |t| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_9562","instance":9562,"id":196233,"goal":"lemma SeqAppendNil_9562(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_9563","instance":9563,"id":196234,"goal":"lemma SeqNilAppend_9563(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_9564","instance":9564,"id":196235,"goal":"lemma SeqAppendAssoc_9564(zs: seq, u: seq, xs: seq)\n ensures (zs + u) + xs == zs + (u + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_9565","instance":9565,"id":196236,"goal":"lemma SeqTakeDrop_9565(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_9566","instance":9566,"id":196237,"goal":"lemma SeqReverseLen_9566(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_9567","instance":9567,"id":196238,"goal":"lemma SeqReverseIdem_9567(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_9568","instance":9568,"id":196239,"goal":"lemma SeqMapLen_9568(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_9569","instance":9569,"id":196240,"goal":"lemma SeqFilterLe_9569(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_9570","instance":9570,"id":196241,"goal":"lemma SeqMemberAppend_9570(ys: seq, s: seq)\n ensures x in ys + s <==> x in ys || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_9571","instance":9571,"id":196242,"goal":"lemma SeqAppendLen_9571(xs: seq, u: seq)\n ensures |xs + u| == |xs| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_9572","instance":9572,"id":196243,"goal":"lemma SeqAppendNil_9572(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_9573","instance":9573,"id":196244,"goal":"lemma SeqNilAppend_9573(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_9574","instance":9574,"id":196245,"goal":"lemma SeqAppendAssoc_9574(ys: seq, xs: seq, t: seq)\n ensures (ys + xs) + t == ys + (xs + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_9575","instance":9575,"id":196246,"goal":"lemma SeqTakeDrop_9575(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_9576","instance":9576,"id":196247,"goal":"lemma SeqReverseLen_9576(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_9577","instance":9577,"id":196248,"goal":"lemma SeqReverseIdem_9577(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_9578","instance":9578,"id":196249,"goal":"lemma SeqMapLen_9578(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_9579","instance":9579,"id":196250,"goal":"lemma SeqFilterLe_9579(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_9580","instance":9580,"id":196251,"goal":"lemma SeqMemberAppend_9580(xs: seq, ys: seq)\n ensures x in xs + ys <==> x in xs || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_9581","instance":9581,"id":196252,"goal":"lemma SeqAppendLen_9581(xs: seq, u: seq)\n ensures |xs + u| == |xs| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_9582","instance":9582,"id":196253,"goal":"lemma SeqAppendNil_9582(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_9583","instance":9583,"id":196254,"goal":"lemma SeqNilAppend_9583(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_9584","instance":9584,"id":196255,"goal":"lemma SeqAppendAssoc_9584(xs: seq, ys: seq, zs: seq)\n ensures (xs + ys) + zs == xs + (ys + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_9585","instance":9585,"id":196256,"goal":"lemma SeqTakeDrop_9585(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_9586","instance":9586,"id":196257,"goal":"lemma SeqReverseLen_9586(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_9587","instance":9587,"id":196258,"goal":"lemma SeqReverseIdem_9587(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_9588","instance":9588,"id":196259,"goal":"lemma SeqMapLen_9588(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_9589","instance":9589,"id":196260,"goal":"lemma SeqFilterLe_9589(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_9590","instance":9590,"id":196261,"goal":"lemma SeqMemberAppend_9590(u: seq, ys: seq)\n ensures x in u + ys <==> x in u || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_9591","instance":9591,"id":196262,"goal":"lemma SeqAppendLen_9591(t: seq, xs: seq)\n ensures |t + xs| == |t| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_9592","instance":9592,"id":196263,"goal":"lemma SeqAppendNil_9592(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_9593","instance":9593,"id":196264,"goal":"lemma SeqNilAppend_9593(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_9594","instance":9594,"id":196265,"goal":"lemma SeqAppendAssoc_9594(t: seq, s: seq, zs: seq)\n ensures (t + s) + zs == t + (s + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_9595","instance":9595,"id":196266,"goal":"lemma SeqTakeDrop_9595(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_9596","instance":9596,"id":196267,"goal":"lemma SeqReverseLen_9596(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_9597","instance":9597,"id":196268,"goal":"lemma SeqReverseIdem_9597(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_9598","instance":9598,"id":196269,"goal":"lemma SeqMapLen_9598(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_9599","instance":9599,"id":196270,"goal":"lemma SeqFilterLe_9599(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_9600","instance":9600,"id":196271,"goal":"lemma SeqMemberAppend_9600(xs: seq, s: seq)\n ensures x in xs + s <==> x in xs || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_9601","instance":9601,"id":196272,"goal":"lemma SeqAppendLen_9601(t: seq, xs: seq)\n ensures |t + xs| == |t| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_9602","instance":9602,"id":196273,"goal":"lemma SeqAppendNil_9602(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_9603","instance":9603,"id":196274,"goal":"lemma SeqNilAppend_9603(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_9604","instance":9604,"id":196275,"goal":"lemma SeqAppendAssoc_9604(u: seq, xs: seq, t: seq)\n ensures (u + xs) + t == u + (xs + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_9605","instance":9605,"id":196276,"goal":"lemma SeqTakeDrop_9605(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_9606","instance":9606,"id":196277,"goal":"lemma SeqReverseLen_9606(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_9607","instance":9607,"id":196278,"goal":"lemma SeqReverseIdem_9607(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_9608","instance":9608,"id":196279,"goal":"lemma SeqMapLen_9608(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_9609","instance":9609,"id":196280,"goal":"lemma SeqFilterLe_9609(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_9610","instance":9610,"id":196281,"goal":"lemma SeqMemberAppend_9610(s: seq, t: seq)\n ensures x in s + t <==> x in s || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_9611","instance":9611,"id":196282,"goal":"lemma SeqAppendLen_9611(u: seq, s: seq)\n ensures |u + s| == |u| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_9612","instance":9612,"id":196283,"goal":"lemma SeqAppendNil_9612(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_9613","instance":9613,"id":196284,"goal":"lemma SeqNilAppend_9613(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_9614","instance":9614,"id":196285,"goal":"lemma SeqAppendAssoc_9614(xs: seq, ys: seq, zs: seq)\n ensures (xs + ys) + zs == xs + (ys + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_9615","instance":9615,"id":196286,"goal":"lemma SeqTakeDrop_9615(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_9616","instance":9616,"id":196287,"goal":"lemma SeqReverseLen_9616(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_9617","instance":9617,"id":196288,"goal":"lemma SeqReverseIdem_9617(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_9618","instance":9618,"id":196289,"goal":"lemma SeqMapLen_9618(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_9619","instance":9619,"id":196290,"goal":"lemma SeqFilterLe_9619(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_9620","instance":9620,"id":196291,"goal":"lemma SeqMemberAppend_9620(t: seq, xs: seq)\n ensures x in t + xs <==> x in t || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_9621","instance":9621,"id":196292,"goal":"lemma SeqAppendLen_9621(ys: seq, xs: seq)\n ensures |ys + xs| == |ys| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_9622","instance":9622,"id":196293,"goal":"lemma SeqAppendNil_9622(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_9623","instance":9623,"id":196294,"goal":"lemma SeqNilAppend_9623(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_9624","instance":9624,"id":196295,"goal":"lemma SeqAppendAssoc_9624(zs: seq, s: seq, ys: seq)\n ensures (zs + s) + ys == zs + (s + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_9625","instance":9625,"id":196296,"goal":"lemma SeqTakeDrop_9625(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_9626","instance":9626,"id":196297,"goal":"lemma SeqReverseLen_9626(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_9627","instance":9627,"id":196298,"goal":"lemma SeqReverseIdem_9627(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_9628","instance":9628,"id":196299,"goal":"lemma SeqMapLen_9628(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_9629","instance":9629,"id":196300,"goal":"lemma SeqFilterLe_9629(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_9630","instance":9630,"id":196301,"goal":"lemma SeqMemberAppend_9630(t: seq, s: seq)\n ensures x in t + s <==> x in t || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_9631","instance":9631,"id":196302,"goal":"lemma SeqAppendLen_9631(xs: seq, s: seq)\n ensures |xs + s| == |xs| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_9632","instance":9632,"id":196303,"goal":"lemma SeqAppendNil_9632(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_9633","instance":9633,"id":196304,"goal":"lemma SeqNilAppend_9633(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_9634","instance":9634,"id":196305,"goal":"lemma SeqAppendAssoc_9634(ys: seq, t: seq, u: seq)\n ensures (ys + t) + u == ys + (t + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_9635","instance":9635,"id":196306,"goal":"lemma SeqTakeDrop_9635(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_9636","instance":9636,"id":196307,"goal":"lemma SeqReverseLen_9636(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_9637","instance":9637,"id":196308,"goal":"lemma SeqReverseIdem_9637(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_9638","instance":9638,"id":196309,"goal":"lemma SeqMapLen_9638(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_9639","instance":9639,"id":196310,"goal":"lemma SeqFilterLe_9639(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_9640","instance":9640,"id":196311,"goal":"lemma SeqMemberAppend_9640(u: seq, ys: seq)\n ensures x in u + ys <==> x in u || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_9641","instance":9641,"id":196312,"goal":"lemma SeqAppendLen_9641(zs: seq, s: seq)\n ensures |zs + s| == |zs| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_9642","instance":9642,"id":196313,"goal":"lemma SeqAppendNil_9642(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_9643","instance":9643,"id":196314,"goal":"lemma SeqNilAppend_9643(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_9644","instance":9644,"id":196315,"goal":"lemma SeqAppendAssoc_9644(xs: seq, u: seq, ys: seq)\n ensures (xs + u) + ys == xs + (u + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_9645","instance":9645,"id":196316,"goal":"lemma SeqTakeDrop_9645(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_9646","instance":9646,"id":196317,"goal":"lemma SeqReverseLen_9646(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_9647","instance":9647,"id":196318,"goal":"lemma SeqReverseIdem_9647(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_9648","instance":9648,"id":196319,"goal":"lemma SeqMapLen_9648(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_9649","instance":9649,"id":196320,"goal":"lemma SeqFilterLe_9649(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_9650","instance":9650,"id":196321,"goal":"lemma SeqMemberAppend_9650(ys: seq, u: seq)\n ensures x in ys + u <==> x in ys || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_9651","instance":9651,"id":196322,"goal":"lemma SeqAppendLen_9651(ys: seq, t: seq)\n ensures |ys + t| == |ys| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_9652","instance":9652,"id":196323,"goal":"lemma SeqAppendNil_9652(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_9653","instance":9653,"id":196324,"goal":"lemma SeqNilAppend_9653(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_9654","instance":9654,"id":196325,"goal":"lemma SeqAppendAssoc_9654(zs: seq, xs: seq, s: seq)\n ensures (zs + xs) + s == zs + (xs + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_9655","instance":9655,"id":196326,"goal":"lemma SeqTakeDrop_9655(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_9656","instance":9656,"id":196327,"goal":"lemma SeqReverseLen_9656(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_9657","instance":9657,"id":196328,"goal":"lemma SeqReverseIdem_9657(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_9658","instance":9658,"id":196329,"goal":"lemma SeqMapLen_9658(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_9659","instance":9659,"id":196330,"goal":"lemma SeqFilterLe_9659(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_9660","instance":9660,"id":196331,"goal":"lemma SeqMemberAppend_9660(u: seq, zs: seq)\n ensures x in u + zs <==> x in u || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_9661","instance":9661,"id":196332,"goal":"lemma SeqAppendLen_9661(xs: seq, zs: seq)\n ensures |xs + zs| == |xs| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_9662","instance":9662,"id":196333,"goal":"lemma SeqAppendNil_9662(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_9663","instance":9663,"id":196334,"goal":"lemma SeqNilAppend_9663(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_9664","instance":9664,"id":196335,"goal":"lemma SeqAppendAssoc_9664(xs: seq, s: seq, u: seq)\n ensures (xs + s) + u == xs + (s + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_9665","instance":9665,"id":196336,"goal":"lemma SeqTakeDrop_9665(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_9666","instance":9666,"id":196337,"goal":"lemma SeqReverseLen_9666(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_9667","instance":9667,"id":196338,"goal":"lemma SeqReverseIdem_9667(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_9668","instance":9668,"id":196339,"goal":"lemma SeqMapLen_9668(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_9669","instance":9669,"id":196340,"goal":"lemma SeqFilterLe_9669(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_9670","instance":9670,"id":196341,"goal":"lemma SeqMemberAppend_9670(t: seq, zs: seq)\n ensures x in t + zs <==> x in t || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_9671","instance":9671,"id":196342,"goal":"lemma SeqAppendLen_9671(t: seq, zs: seq)\n ensures |t + zs| == |t| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_9672","instance":9672,"id":196343,"goal":"lemma SeqAppendNil_9672(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_9673","instance":9673,"id":196344,"goal":"lemma SeqNilAppend_9673(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_9674","instance":9674,"id":196345,"goal":"lemma SeqAppendAssoc_9674(u: seq, zs: seq, ys: seq)\n ensures (u + zs) + ys == u + (zs + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_9675","instance":9675,"id":196346,"goal":"lemma SeqTakeDrop_9675(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_9676","instance":9676,"id":196347,"goal":"lemma SeqReverseLen_9676(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_9677","instance":9677,"id":196348,"goal":"lemma SeqReverseIdem_9677(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_9678","instance":9678,"id":196349,"goal":"lemma SeqMapLen_9678(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_9679","instance":9679,"id":196350,"goal":"lemma SeqFilterLe_9679(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_9680","instance":9680,"id":196351,"goal":"lemma SeqMemberAppend_9680(zs: seq, xs: seq)\n ensures x in zs + xs <==> x in zs || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_9681","instance":9681,"id":196352,"goal":"lemma SeqAppendLen_9681(s: seq, xs: seq)\n ensures |s + xs| == |s| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_9682","instance":9682,"id":196353,"goal":"lemma SeqAppendNil_9682(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_9683","instance":9683,"id":196354,"goal":"lemma SeqNilAppend_9683(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_9684","instance":9684,"id":196355,"goal":"lemma SeqAppendAssoc_9684(t: seq, s: seq, u: seq)\n ensures (t + s) + u == t + (s + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_9685","instance":9685,"id":196356,"goal":"lemma SeqTakeDrop_9685(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_9686","instance":9686,"id":196357,"goal":"lemma SeqReverseLen_9686(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_9687","instance":9687,"id":196358,"goal":"lemma SeqReverseIdem_9687(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_9688","instance":9688,"id":196359,"goal":"lemma SeqMapLen_9688(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_9689","instance":9689,"id":196360,"goal":"lemma SeqFilterLe_9689(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_9690","instance":9690,"id":196361,"goal":"lemma SeqMemberAppend_9690(t: seq, s: seq)\n ensures x in t + s <==> x in t || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_9691","instance":9691,"id":196362,"goal":"lemma SeqAppendLen_9691(ys: seq, xs: seq)\n ensures |ys + xs| == |ys| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_9692","instance":9692,"id":196363,"goal":"lemma SeqAppendNil_9692(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_9693","instance":9693,"id":196364,"goal":"lemma SeqNilAppend_9693(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_9694","instance":9694,"id":196365,"goal":"lemma SeqAppendAssoc_9694(zs: seq, ys: seq, xs: seq)\n ensures (zs + ys) + xs == zs + (ys + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_9695","instance":9695,"id":196366,"goal":"lemma SeqTakeDrop_9695(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_9696","instance":9696,"id":196367,"goal":"lemma SeqReverseLen_9696(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_9697","instance":9697,"id":196368,"goal":"lemma SeqReverseIdem_9697(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_9698","instance":9698,"id":196369,"goal":"lemma SeqMapLen_9698(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_9699","instance":9699,"id":196370,"goal":"lemma SeqFilterLe_9699(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_9700","instance":9700,"id":196371,"goal":"lemma SeqMemberAppend_9700(u: seq, s: seq)\n ensures x in u + s <==> x in u || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_9701","instance":9701,"id":196372,"goal":"lemma SeqAppendLen_9701(zs: seq, ys: seq)\n ensures |zs + ys| == |zs| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_9702","instance":9702,"id":196373,"goal":"lemma SeqAppendNil_9702(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_9703","instance":9703,"id":196374,"goal":"lemma SeqNilAppend_9703(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_9704","instance":9704,"id":196375,"goal":"lemma SeqAppendAssoc_9704(s: seq, t: seq, xs: seq)\n ensures (s + t) + xs == s + (t + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_9705","instance":9705,"id":196376,"goal":"lemma SeqTakeDrop_9705(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_9706","instance":9706,"id":196377,"goal":"lemma SeqReverseLen_9706(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_9707","instance":9707,"id":196378,"goal":"lemma SeqReverseIdem_9707(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_9708","instance":9708,"id":196379,"goal":"lemma SeqMapLen_9708(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_9709","instance":9709,"id":196380,"goal":"lemma SeqFilterLe_9709(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_9710","instance":9710,"id":196381,"goal":"lemma SeqMemberAppend_9710(xs: seq, u: seq)\n ensures x in xs + u <==> x in xs || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_9711","instance":9711,"id":196382,"goal":"lemma SeqAppendLen_9711(t: seq, u: seq)\n ensures |t + u| == |t| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_9712","instance":9712,"id":196383,"goal":"lemma SeqAppendNil_9712(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_9713","instance":9713,"id":196384,"goal":"lemma SeqNilAppend_9713(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_9714","instance":9714,"id":196385,"goal":"lemma SeqAppendAssoc_9714(s: seq, t: seq, zs: seq)\n ensures (s + t) + zs == s + (t + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_9715","instance":9715,"id":196386,"goal":"lemma SeqTakeDrop_9715(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_9716","instance":9716,"id":196387,"goal":"lemma SeqReverseLen_9716(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_9717","instance":9717,"id":196388,"goal":"lemma SeqReverseIdem_9717(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_9718","instance":9718,"id":196389,"goal":"lemma SeqMapLen_9718(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_9719","instance":9719,"id":196390,"goal":"lemma SeqFilterLe_9719(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_9720","instance":9720,"id":196391,"goal":"lemma SeqMemberAppend_9720(zs: seq, s: seq)\n ensures x in zs + s <==> x in zs || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_9721","instance":9721,"id":196392,"goal":"lemma SeqAppendLen_9721(ys: seq, t: seq)\n ensures |ys + t| == |ys| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_9722","instance":9722,"id":196393,"goal":"lemma SeqAppendNil_9722(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_9723","instance":9723,"id":196394,"goal":"lemma SeqNilAppend_9723(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_9724","instance":9724,"id":196395,"goal":"lemma SeqAppendAssoc_9724(zs: seq, ys: seq, xs: seq)\n ensures (zs + ys) + xs == zs + (ys + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_9725","instance":9725,"id":196396,"goal":"lemma SeqTakeDrop_9725(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_9726","instance":9726,"id":196397,"goal":"lemma SeqReverseLen_9726(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_9727","instance":9727,"id":196398,"goal":"lemma SeqReverseIdem_9727(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_9728","instance":9728,"id":196399,"goal":"lemma SeqMapLen_9728(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_9729","instance":9729,"id":196400,"goal":"lemma SeqFilterLe_9729(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_9730","instance":9730,"id":196401,"goal":"lemma SeqMemberAppend_9730(s: seq, zs: seq)\n ensures x in s + zs <==> x in s || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_9731","instance":9731,"id":196402,"goal":"lemma SeqAppendLen_9731(xs: seq, ys: seq)\n ensures |xs + ys| == |xs| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_9732","instance":9732,"id":196403,"goal":"lemma SeqAppendNil_9732(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_9733","instance":9733,"id":196404,"goal":"lemma SeqNilAppend_9733(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_9734","instance":9734,"id":196405,"goal":"lemma SeqAppendAssoc_9734(xs: seq, zs: seq, u: seq)\n ensures (xs + zs) + u == xs + (zs + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_9735","instance":9735,"id":196406,"goal":"lemma SeqTakeDrop_9735(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_9736","instance":9736,"id":196407,"goal":"lemma SeqReverseLen_9736(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_9737","instance":9737,"id":196408,"goal":"lemma SeqReverseIdem_9737(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_9738","instance":9738,"id":196409,"goal":"lemma SeqMapLen_9738(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_9739","instance":9739,"id":196410,"goal":"lemma SeqFilterLe_9739(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_9740","instance":9740,"id":196411,"goal":"lemma SeqMemberAppend_9740(t: seq, xs: seq)\n ensures x in t + xs <==> x in t || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_9741","instance":9741,"id":196412,"goal":"lemma SeqAppendLen_9741(s: seq, xs: seq)\n ensures |s + xs| == |s| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_9742","instance":9742,"id":196413,"goal":"lemma SeqAppendNil_9742(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_9743","instance":9743,"id":196414,"goal":"lemma SeqNilAppend_9743(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_9744","instance":9744,"id":196415,"goal":"lemma SeqAppendAssoc_9744(xs: seq, zs: seq, s: seq)\n ensures (xs + zs) + s == xs + (zs + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_9745","instance":9745,"id":196416,"goal":"lemma SeqTakeDrop_9745(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_9746","instance":9746,"id":196417,"goal":"lemma SeqReverseLen_9746(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_9747","instance":9747,"id":196418,"goal":"lemma SeqReverseIdem_9747(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_9748","instance":9748,"id":196419,"goal":"lemma SeqMapLen_9748(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_9749","instance":9749,"id":196420,"goal":"lemma SeqFilterLe_9749(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_9750","instance":9750,"id":196421,"goal":"lemma SeqMemberAppend_9750(t: seq, zs: seq)\n ensures x in t + zs <==> x in t || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_9751","instance":9751,"id":196422,"goal":"lemma SeqAppendLen_9751(xs: seq, s: seq)\n ensures |xs + s| == |xs| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_9752","instance":9752,"id":196423,"goal":"lemma SeqAppendNil_9752(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_9753","instance":9753,"id":196424,"goal":"lemma SeqNilAppend_9753(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_9754","instance":9754,"id":196425,"goal":"lemma SeqAppendAssoc_9754(u: seq, s: seq, xs: seq)\n ensures (u + s) + xs == u + (s + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_9755","instance":9755,"id":196426,"goal":"lemma SeqTakeDrop_9755(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_9756","instance":9756,"id":196427,"goal":"lemma SeqReverseLen_9756(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_9757","instance":9757,"id":196428,"goal":"lemma SeqReverseIdem_9757(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_9758","instance":9758,"id":196429,"goal":"lemma SeqMapLen_9758(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_9759","instance":9759,"id":196430,"goal":"lemma SeqFilterLe_9759(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_9760","instance":9760,"id":196431,"goal":"lemma SeqMemberAppend_9760(xs: seq, u: seq)\n ensures x in xs + u <==> x in xs || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_9761","instance":9761,"id":196432,"goal":"lemma SeqAppendLen_9761(s: seq, t: seq)\n ensures |s + t| == |s| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_9762","instance":9762,"id":196433,"goal":"lemma SeqAppendNil_9762(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_9763","instance":9763,"id":196434,"goal":"lemma SeqNilAppend_9763(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_9764","instance":9764,"id":196435,"goal":"lemma SeqAppendAssoc_9764(s: seq, t: seq, zs: seq)\n ensures (s + t) + zs == s + (t + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_9765","instance":9765,"id":196436,"goal":"lemma SeqTakeDrop_9765(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_9766","instance":9766,"id":196437,"goal":"lemma SeqReverseLen_9766(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_9767","instance":9767,"id":196438,"goal":"lemma SeqReverseIdem_9767(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_9768","instance":9768,"id":196439,"goal":"lemma SeqMapLen_9768(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_9769","instance":9769,"id":196440,"goal":"lemma SeqFilterLe_9769(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_9770","instance":9770,"id":196441,"goal":"lemma SeqMemberAppend_9770(xs: seq, t: seq)\n ensures x in xs + t <==> x in xs || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_9771","instance":9771,"id":196442,"goal":"lemma SeqAppendLen_9771(xs: seq, ys: seq)\n ensures |xs + ys| == |xs| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_9772","instance":9772,"id":196443,"goal":"lemma SeqAppendNil_9772(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_9773","instance":9773,"id":196444,"goal":"lemma SeqNilAppend_9773(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_9774","instance":9774,"id":196445,"goal":"lemma SeqAppendAssoc_9774(s: seq, xs: seq, zs: seq)\n ensures (s + xs) + zs == s + (xs + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_9775","instance":9775,"id":196446,"goal":"lemma SeqTakeDrop_9775(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_9776","instance":9776,"id":196447,"goal":"lemma SeqReverseLen_9776(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_9777","instance":9777,"id":196448,"goal":"lemma SeqReverseIdem_9777(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_9778","instance":9778,"id":196449,"goal":"lemma SeqMapLen_9778(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_9779","instance":9779,"id":196450,"goal":"lemma SeqFilterLe_9779(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_9780","instance":9780,"id":196451,"goal":"lemma SeqMemberAppend_9780(ys: seq, xs: seq)\n ensures x in ys + xs <==> x in ys || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_9781","instance":9781,"id":196452,"goal":"lemma SeqAppendLen_9781(u: seq, s: seq)\n ensures |u + s| == |u| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_9782","instance":9782,"id":196453,"goal":"lemma SeqAppendNil_9782(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_9783","instance":9783,"id":196454,"goal":"lemma SeqNilAppend_9783(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_9784","instance":9784,"id":196455,"goal":"lemma SeqAppendAssoc_9784(s: seq, zs: seq, xs: seq)\n ensures (s + zs) + xs == s + (zs + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_9785","instance":9785,"id":196456,"goal":"lemma SeqTakeDrop_9785(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_9786","instance":9786,"id":196457,"goal":"lemma SeqReverseLen_9786(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_9787","instance":9787,"id":196458,"goal":"lemma SeqReverseIdem_9787(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_9788","instance":9788,"id":196459,"goal":"lemma SeqMapLen_9788(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_9789","instance":9789,"id":196460,"goal":"lemma SeqFilterLe_9789(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_9790","instance":9790,"id":196461,"goal":"lemma SeqMemberAppend_9790(u: seq, ys: seq)\n ensures x in u + ys <==> x in u || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_9791","instance":9791,"id":196462,"goal":"lemma SeqAppendLen_9791(s: seq, ys: seq)\n ensures |s + ys| == |s| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_9792","instance":9792,"id":196463,"goal":"lemma SeqAppendNil_9792(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_9793","instance":9793,"id":196464,"goal":"lemma SeqNilAppend_9793(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_9794","instance":9794,"id":196465,"goal":"lemma SeqAppendAssoc_9794(t: seq, ys: seq, zs: seq)\n ensures (t + ys) + zs == t + (ys + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_9795","instance":9795,"id":196466,"goal":"lemma SeqTakeDrop_9795(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_9796","instance":9796,"id":196467,"goal":"lemma SeqReverseLen_9796(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_9797","instance":9797,"id":196468,"goal":"lemma SeqReverseIdem_9797(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_9798","instance":9798,"id":196469,"goal":"lemma SeqMapLen_9798(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_9799","instance":9799,"id":196470,"goal":"lemma SeqFilterLe_9799(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_9800","instance":9800,"id":196471,"goal":"lemma SeqMemberAppend_9800(ys: seq, u: seq)\n ensures x in ys + u <==> x in ys || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_9801","instance":9801,"id":196472,"goal":"lemma SeqAppendLen_9801(u: seq, zs: seq)\n ensures |u + zs| == |u| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_9802","instance":9802,"id":196473,"goal":"lemma SeqAppendNil_9802(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_9803","instance":9803,"id":196474,"goal":"lemma SeqNilAppend_9803(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_9804","instance":9804,"id":196475,"goal":"lemma SeqAppendAssoc_9804(ys: seq, xs: seq, u: seq)\n ensures (ys + xs) + u == ys + (xs + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_9805","instance":9805,"id":196476,"goal":"lemma SeqTakeDrop_9805(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_9806","instance":9806,"id":196477,"goal":"lemma SeqReverseLen_9806(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_9807","instance":9807,"id":196478,"goal":"lemma SeqReverseIdem_9807(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_9808","instance":9808,"id":196479,"goal":"lemma SeqMapLen_9808(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_9809","instance":9809,"id":196480,"goal":"lemma SeqFilterLe_9809(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_9810","instance":9810,"id":196481,"goal":"lemma SeqMemberAppend_9810(t: seq, s: seq)\n ensures x in t + s <==> x in t || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_9811","instance":9811,"id":196482,"goal":"lemma SeqAppendLen_9811(u: seq, t: seq)\n ensures |u + t| == |u| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_9812","instance":9812,"id":196483,"goal":"lemma SeqAppendNil_9812(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_9813","instance":9813,"id":196484,"goal":"lemma SeqNilAppend_9813(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_9814","instance":9814,"id":196485,"goal":"lemma SeqAppendAssoc_9814(u: seq, ys: seq, t: seq)\n ensures (u + ys) + t == u + (ys + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_9815","instance":9815,"id":196486,"goal":"lemma SeqTakeDrop_9815(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_9816","instance":9816,"id":196487,"goal":"lemma SeqReverseLen_9816(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_9817","instance":9817,"id":196488,"goal":"lemma SeqReverseIdem_9817(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_9818","instance":9818,"id":196489,"goal":"lemma SeqMapLen_9818(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_9819","instance":9819,"id":196490,"goal":"lemma SeqFilterLe_9819(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_9820","instance":9820,"id":196491,"goal":"lemma SeqMemberAppend_9820(s: seq, ys: seq)\n ensures x in s + ys <==> x in s || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_9821","instance":9821,"id":196492,"goal":"lemma SeqAppendLen_9821(s: seq, ys: seq)\n ensures |s + ys| == |s| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_9822","instance":9822,"id":196493,"goal":"lemma SeqAppendNil_9822(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_9823","instance":9823,"id":196494,"goal":"lemma SeqNilAppend_9823(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_9824","instance":9824,"id":196495,"goal":"lemma SeqAppendAssoc_9824(xs: seq, u: seq, ys: seq)\n ensures (xs + u) + ys == xs + (u + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_9825","instance":9825,"id":196496,"goal":"lemma SeqTakeDrop_9825(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_9826","instance":9826,"id":196497,"goal":"lemma SeqReverseLen_9826(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_9827","instance":9827,"id":196498,"goal":"lemma SeqReverseIdem_9827(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_9828","instance":9828,"id":196499,"goal":"lemma SeqMapLen_9828(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_9829","instance":9829,"id":196500,"goal":"lemma SeqFilterLe_9829(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_9830","instance":9830,"id":196501,"goal":"lemma SeqMemberAppend_9830(zs: seq, xs: seq)\n ensures x in zs + xs <==> x in zs || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_9831","instance":9831,"id":196502,"goal":"lemma SeqAppendLen_9831(ys: seq, xs: seq)\n ensures |ys + xs| == |ys| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_9832","instance":9832,"id":196503,"goal":"lemma SeqAppendNil_9832(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_9833","instance":9833,"id":196504,"goal":"lemma SeqNilAppend_9833(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_9834","instance":9834,"id":196505,"goal":"lemma SeqAppendAssoc_9834(ys: seq, t: seq, zs: seq)\n ensures (ys + t) + zs == ys + (t + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_9835","instance":9835,"id":196506,"goal":"lemma SeqTakeDrop_9835(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_9836","instance":9836,"id":196507,"goal":"lemma SeqReverseLen_9836(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_9837","instance":9837,"id":196508,"goal":"lemma SeqReverseIdem_9837(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_9838","instance":9838,"id":196509,"goal":"lemma SeqMapLen_9838(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_9839","instance":9839,"id":196510,"goal":"lemma SeqFilterLe_9839(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_9840","instance":9840,"id":196511,"goal":"lemma SeqMemberAppend_9840(s: seq, ys: seq)\n ensures x in s + ys <==> x in s || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_9841","instance":9841,"id":196512,"goal":"lemma SeqAppendLen_9841(s: seq, ys: seq)\n ensures |s + ys| == |s| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_9842","instance":9842,"id":196513,"goal":"lemma SeqAppendNil_9842(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_9843","instance":9843,"id":196514,"goal":"lemma SeqNilAppend_9843(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_9844","instance":9844,"id":196515,"goal":"lemma SeqAppendAssoc_9844(xs: seq, ys: seq, s: seq)\n ensures (xs + ys) + s == xs + (ys + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_9845","instance":9845,"id":196516,"goal":"lemma SeqTakeDrop_9845(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_9846","instance":9846,"id":196517,"goal":"lemma SeqReverseLen_9846(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_9847","instance":9847,"id":196518,"goal":"lemma SeqReverseIdem_9847(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_9848","instance":9848,"id":196519,"goal":"lemma SeqMapLen_9848(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_9849","instance":9849,"id":196520,"goal":"lemma SeqFilterLe_9849(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_9850","instance":9850,"id":196521,"goal":"lemma SeqMemberAppend_9850(u: seq, xs: seq)\n ensures x in u + xs <==> x in u || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_9851","instance":9851,"id":196522,"goal":"lemma SeqAppendLen_9851(zs: seq, u: seq)\n ensures |zs + u| == |zs| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_9852","instance":9852,"id":196523,"goal":"lemma SeqAppendNil_9852(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_9853","instance":9853,"id":196524,"goal":"lemma SeqNilAppend_9853(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_9854","instance":9854,"id":196525,"goal":"lemma SeqAppendAssoc_9854(ys: seq, u: seq, t: seq)\n ensures (ys + u) + t == ys + (u + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_9855","instance":9855,"id":196526,"goal":"lemma SeqTakeDrop_9855(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_9856","instance":9856,"id":196527,"goal":"lemma SeqReverseLen_9856(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_9857","instance":9857,"id":196528,"goal":"lemma SeqReverseIdem_9857(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_9858","instance":9858,"id":196529,"goal":"lemma SeqMapLen_9858(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_9859","instance":9859,"id":196530,"goal":"lemma SeqFilterLe_9859(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_9860","instance":9860,"id":196531,"goal":"lemma SeqMemberAppend_9860(u: seq, zs: seq)\n ensures x in u + zs <==> x in u || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_9861","instance":9861,"id":196532,"goal":"lemma SeqAppendLen_9861(xs: seq, s: seq)\n ensures |xs + s| == |xs| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_9862","instance":9862,"id":196533,"goal":"lemma SeqAppendNil_9862(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_9863","instance":9863,"id":196534,"goal":"lemma SeqNilAppend_9863(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_9864","instance":9864,"id":196535,"goal":"lemma SeqAppendAssoc_9864(s: seq, zs: seq, xs: seq)\n ensures (s + zs) + xs == s + (zs + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_9865","instance":9865,"id":196536,"goal":"lemma SeqTakeDrop_9865(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_9866","instance":9866,"id":196537,"goal":"lemma SeqReverseLen_9866(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_9867","instance":9867,"id":196538,"goal":"lemma SeqReverseIdem_9867(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_9868","instance":9868,"id":196539,"goal":"lemma SeqMapLen_9868(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_9869","instance":9869,"id":196540,"goal":"lemma SeqFilterLe_9869(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_9870","instance":9870,"id":196541,"goal":"lemma SeqMemberAppend_9870(ys: seq, xs: seq)\n ensures x in ys + xs <==> x in ys || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_9871","instance":9871,"id":196542,"goal":"lemma SeqAppendLen_9871(t: seq, zs: seq)\n ensures |t + zs| == |t| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_9872","instance":9872,"id":196543,"goal":"lemma SeqAppendNil_9872(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_9873","instance":9873,"id":196544,"goal":"lemma SeqNilAppend_9873(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_9874","instance":9874,"id":196545,"goal":"lemma SeqAppendAssoc_9874(xs: seq, ys: seq, zs: seq)\n ensures (xs + ys) + zs == xs + (ys + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_9875","instance":9875,"id":196546,"goal":"lemma SeqTakeDrop_9875(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_9876","instance":9876,"id":196547,"goal":"lemma SeqReverseLen_9876(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_9877","instance":9877,"id":196548,"goal":"lemma SeqReverseIdem_9877(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_9878","instance":9878,"id":196549,"goal":"lemma SeqMapLen_9878(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_9879","instance":9879,"id":196550,"goal":"lemma SeqFilterLe_9879(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_9880","instance":9880,"id":196551,"goal":"lemma SeqMemberAppend_9880(t: seq, ys: seq)\n ensures x in t + ys <==> x in t || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_9881","instance":9881,"id":196552,"goal":"lemma SeqAppendLen_9881(t: seq, u: seq)\n ensures |t + u| == |t| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_9882","instance":9882,"id":196553,"goal":"lemma SeqAppendNil_9882(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_9883","instance":9883,"id":196554,"goal":"lemma SeqNilAppend_9883(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_9884","instance":9884,"id":196555,"goal":"lemma SeqAppendAssoc_9884(zs: seq, xs: seq, u: seq)\n ensures (zs + xs) + u == zs + (xs + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_9885","instance":9885,"id":196556,"goal":"lemma SeqTakeDrop_9885(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_9886","instance":9886,"id":196557,"goal":"lemma SeqReverseLen_9886(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_9887","instance":9887,"id":196558,"goal":"lemma SeqReverseIdem_9887(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_9888","instance":9888,"id":196559,"goal":"lemma SeqMapLen_9888(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_9889","instance":9889,"id":196560,"goal":"lemma SeqFilterLe_9889(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_9890","instance":9890,"id":196561,"goal":"lemma SeqMemberAppend_9890(zs: seq, xs: seq)\n ensures x in zs + xs <==> x in zs || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_9891","instance":9891,"id":196562,"goal":"lemma SeqAppendLen_9891(xs: seq, s: seq)\n ensures |xs + s| == |xs| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_9892","instance":9892,"id":196563,"goal":"lemma SeqAppendNil_9892(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_9893","instance":9893,"id":196564,"goal":"lemma SeqNilAppend_9893(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_9894","instance":9894,"id":196565,"goal":"lemma SeqAppendAssoc_9894(s: seq, u: seq, t: seq)\n ensures (s + u) + t == s + (u + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_9895","instance":9895,"id":196566,"goal":"lemma SeqTakeDrop_9895(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_9896","instance":9896,"id":196567,"goal":"lemma SeqReverseLen_9896(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_9897","instance":9897,"id":196568,"goal":"lemma SeqReverseIdem_9897(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_9898","instance":9898,"id":196569,"goal":"lemma SeqMapLen_9898(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_9899","instance":9899,"id":196570,"goal":"lemma SeqFilterLe_9899(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_9900","instance":9900,"id":196571,"goal":"lemma SeqMemberAppend_9900(xs: seq, s: seq)\n ensures x in xs + s <==> x in xs || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_9901","instance":9901,"id":196572,"goal":"lemma SeqAppendLen_9901(ys: seq, s: seq)\n ensures |ys + s| == |ys| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_9902","instance":9902,"id":196573,"goal":"lemma SeqAppendNil_9902(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_9903","instance":9903,"id":196574,"goal":"lemma SeqNilAppend_9903(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_9904","instance":9904,"id":196575,"goal":"lemma SeqAppendAssoc_9904(u: seq, xs: seq, t: seq)\n ensures (u + xs) + t == u + (xs + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_9905","instance":9905,"id":196576,"goal":"lemma SeqTakeDrop_9905(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_9906","instance":9906,"id":196577,"goal":"lemma SeqReverseLen_9906(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_9907","instance":9907,"id":196578,"goal":"lemma SeqReverseIdem_9907(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_9908","instance":9908,"id":196579,"goal":"lemma SeqMapLen_9908(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_9909","instance":9909,"id":196580,"goal":"lemma SeqFilterLe_9909(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_9910","instance":9910,"id":196581,"goal":"lemma SeqMemberAppend_9910(t: seq, ys: seq)\n ensures x in t + ys <==> x in t || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_9911","instance":9911,"id":196582,"goal":"lemma SeqAppendLen_9911(t: seq, u: seq)\n ensures |t + u| == |t| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_9912","instance":9912,"id":196583,"goal":"lemma SeqAppendNil_9912(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_9913","instance":9913,"id":196584,"goal":"lemma SeqNilAppend_9913(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_9914","instance":9914,"id":196585,"goal":"lemma SeqAppendAssoc_9914(u: seq, xs: seq, t: seq)\n ensures (u + xs) + t == u + (xs + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_9915","instance":9915,"id":196586,"goal":"lemma SeqTakeDrop_9915(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_9916","instance":9916,"id":196587,"goal":"lemma SeqReverseLen_9916(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_9917","instance":9917,"id":196588,"goal":"lemma SeqReverseIdem_9917(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_9918","instance":9918,"id":196589,"goal":"lemma SeqMapLen_9918(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_9919","instance":9919,"id":196590,"goal":"lemma SeqFilterLe_9919(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_9920","instance":9920,"id":196591,"goal":"lemma SeqMemberAppend_9920(u: seq, zs: seq)\n ensures x in u + zs <==> x in u || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_9921","instance":9921,"id":196592,"goal":"lemma SeqAppendLen_9921(t: seq, s: seq)\n ensures |t + s| == |t| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_9922","instance":9922,"id":196593,"goal":"lemma SeqAppendNil_9922(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_9923","instance":9923,"id":196594,"goal":"lemma SeqNilAppend_9923(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_9924","instance":9924,"id":196595,"goal":"lemma SeqAppendAssoc_9924(ys: seq, t: seq, s: seq)\n ensures (ys + t) + s == ys + (t + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_9925","instance":9925,"id":196596,"goal":"lemma SeqTakeDrop_9925(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_9926","instance":9926,"id":196597,"goal":"lemma SeqReverseLen_9926(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_9927","instance":9927,"id":196598,"goal":"lemma SeqReverseIdem_9927(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_9928","instance":9928,"id":196599,"goal":"lemma SeqMapLen_9928(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_9929","instance":9929,"id":196600,"goal":"lemma SeqFilterLe_9929(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_9930","instance":9930,"id":196601,"goal":"lemma SeqMemberAppend_9930(t: seq, zs: seq)\n ensures x in t + zs <==> x in t || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_9931","instance":9931,"id":196602,"goal":"lemma SeqAppendLen_9931(zs: seq, s: seq)\n ensures |zs + s| == |zs| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_9932","instance":9932,"id":196603,"goal":"lemma SeqAppendNil_9932(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_9933","instance":9933,"id":196604,"goal":"lemma SeqNilAppend_9933(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_9934","instance":9934,"id":196605,"goal":"lemma SeqAppendAssoc_9934(s: seq, u: seq, zs: seq)\n ensures (s + u) + zs == s + (u + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_9935","instance":9935,"id":196606,"goal":"lemma SeqTakeDrop_9935(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_9936","instance":9936,"id":196607,"goal":"lemma SeqReverseLen_9936(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_9937","instance":9937,"id":196608,"goal":"lemma SeqReverseIdem_9937(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_9938","instance":9938,"id":196609,"goal":"lemma SeqMapLen_9938(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_9939","instance":9939,"id":196610,"goal":"lemma SeqFilterLe_9939(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_9940","instance":9940,"id":196611,"goal":"lemma SeqMemberAppend_9940(zs: seq, t: seq)\n ensures x in zs + t <==> x in zs || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_9941","instance":9941,"id":196612,"goal":"lemma SeqAppendLen_9941(zs: seq, xs: seq)\n ensures |zs + xs| == |zs| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_9942","instance":9942,"id":196613,"goal":"lemma SeqAppendNil_9942(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_9943","instance":9943,"id":196614,"goal":"lemma SeqNilAppend_9943(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_9944","instance":9944,"id":196615,"goal":"lemma SeqAppendAssoc_9944(xs: seq, s: seq, t: seq)\n ensures (xs + s) + t == xs + (s + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_9945","instance":9945,"id":196616,"goal":"lemma SeqTakeDrop_9945(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_9946","instance":9946,"id":196617,"goal":"lemma SeqReverseLen_9946(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_9947","instance":9947,"id":196618,"goal":"lemma SeqReverseIdem_9947(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_9948","instance":9948,"id":196619,"goal":"lemma SeqMapLen_9948(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_9949","instance":9949,"id":196620,"goal":"lemma SeqFilterLe_9949(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_9950","instance":9950,"id":196621,"goal":"lemma SeqMemberAppend_9950(ys: seq, zs: seq)\n ensures x in ys + zs <==> x in ys || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_9951","instance":9951,"id":196622,"goal":"lemma SeqAppendLen_9951(s: seq, xs: seq)\n ensures |s + xs| == |s| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_9952","instance":9952,"id":196623,"goal":"lemma SeqAppendNil_9952(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_9953","instance":9953,"id":196624,"goal":"lemma SeqNilAppend_9953(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_9954","instance":9954,"id":196625,"goal":"lemma SeqAppendAssoc_9954(xs: seq, u: seq, zs: seq)\n ensures (xs + u) + zs == xs + (u + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_9955","instance":9955,"id":196626,"goal":"lemma SeqTakeDrop_9955(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_9956","instance":9956,"id":196627,"goal":"lemma SeqReverseLen_9956(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_9957","instance":9957,"id":196628,"goal":"lemma SeqReverseIdem_9957(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_9958","instance":9958,"id":196629,"goal":"lemma SeqMapLen_9958(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_9959","instance":9959,"id":196630,"goal":"lemma SeqFilterLe_9959(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_9960","instance":9960,"id":196631,"goal":"lemma SeqMemberAppend_9960(s: seq, u: seq)\n ensures x in s + u <==> x in s || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_9961","instance":9961,"id":196632,"goal":"lemma SeqAppendLen_9961(s: seq, zs: seq)\n ensures |s + zs| == |s| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_9962","instance":9962,"id":196633,"goal":"lemma SeqAppendNil_9962(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_9963","instance":9963,"id":196634,"goal":"lemma SeqNilAppend_9963(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_9964","instance":9964,"id":196635,"goal":"lemma SeqAppendAssoc_9964(xs: seq, t: seq, s: seq)\n ensures (xs + t) + s == xs + (t + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_9965","instance":9965,"id":196636,"goal":"lemma SeqTakeDrop_9965(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_9966","instance":9966,"id":196637,"goal":"lemma SeqReverseLen_9966(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_9967","instance":9967,"id":196638,"goal":"lemma SeqReverseIdem_9967(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_9968","instance":9968,"id":196639,"goal":"lemma SeqMapLen_9968(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_9969","instance":9969,"id":196640,"goal":"lemma SeqFilterLe_9969(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_9970","instance":9970,"id":196641,"goal":"lemma SeqMemberAppend_9970(u: seq, s: seq)\n ensures x in u + s <==> x in u || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_9971","instance":9971,"id":196642,"goal":"lemma SeqAppendLen_9971(t: seq, xs: seq)\n ensures |t + xs| == |t| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_9972","instance":9972,"id":196643,"goal":"lemma SeqAppendNil_9972(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_9973","instance":9973,"id":196644,"goal":"lemma SeqNilAppend_9973(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_9974","instance":9974,"id":196645,"goal":"lemma SeqAppendAssoc_9974(u: seq, ys: seq, zs: seq)\n ensures (u + ys) + zs == u + (ys + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_9975","instance":9975,"id":196646,"goal":"lemma SeqTakeDrop_9975(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_9976","instance":9976,"id":196647,"goal":"lemma SeqReverseLen_9976(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_9977","instance":9977,"id":196648,"goal":"lemma SeqReverseIdem_9977(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_9978","instance":9978,"id":196649,"goal":"lemma SeqMapLen_9978(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_9979","instance":9979,"id":196650,"goal":"lemma SeqFilterLe_9979(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_9980","instance":9980,"id":196651,"goal":"lemma SeqMemberAppend_9980(zs: seq, t: seq)\n ensures x in zs + t <==> x in zs || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_9981","instance":9981,"id":196652,"goal":"lemma SeqAppendLen_9981(t: seq, zs: seq)\n ensures |t + zs| == |t| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_9982","instance":9982,"id":196653,"goal":"lemma SeqAppendNil_9982(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_9983","instance":9983,"id":196654,"goal":"lemma SeqNilAppend_9983(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_9984","instance":9984,"id":196655,"goal":"lemma SeqAppendAssoc_9984(xs: seq, t: seq, zs: seq)\n ensures (xs + t) + zs == xs + (t + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_9985","instance":9985,"id":196656,"goal":"lemma SeqTakeDrop_9985(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_9986","instance":9986,"id":196657,"goal":"lemma SeqReverseLen_9986(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_9987","instance":9987,"id":196658,"goal":"lemma SeqReverseIdem_9987(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_9988","instance":9988,"id":196659,"goal":"lemma SeqMapLen_9988(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_9989","instance":9989,"id":196660,"goal":"lemma SeqFilterLe_9989(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_9990","instance":9990,"id":196661,"goal":"lemma SeqMemberAppend_9990(ys: seq, s: seq)\n ensures x in ys + s <==> x in ys || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_9991","instance":9991,"id":196662,"goal":"lemma SeqAppendLen_9991(s: seq, ys: seq)\n ensures |s + ys| == |s| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_9992","instance":9992,"id":196663,"goal":"lemma SeqAppendNil_9992(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_9993","instance":9993,"id":196664,"goal":"lemma SeqNilAppend_9993(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_9994","instance":9994,"id":196665,"goal":"lemma SeqAppendAssoc_9994(zs: seq, xs: seq, u: seq)\n ensures (zs + xs) + u == zs + (xs + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_9995","instance":9995,"id":196666,"goal":"lemma SeqTakeDrop_9995(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_9996","instance":9996,"id":196667,"goal":"lemma SeqReverseLen_9996(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_9997","instance":9997,"id":196668,"goal":"lemma SeqReverseIdem_9997(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_9998","instance":9998,"id":196669,"goal":"lemma SeqMapLen_9998(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_9999","instance":9999,"id":196670,"goal":"lemma SeqFilterLe_9999(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_10000","instance":10000,"id":196671,"goal":"lemma SeqMemberAppend_10000(xs: seq, u: seq)\n ensures x in xs + u <==> x in xs || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_10001","instance":10001,"id":196672,"goal":"lemma SeqAppendLen_10001(t: seq, xs: seq)\n ensures |t + xs| == |t| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_10002","instance":10002,"id":196673,"goal":"lemma SeqAppendNil_10002(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_10003","instance":10003,"id":196674,"goal":"lemma SeqNilAppend_10003(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_10004","instance":10004,"id":196675,"goal":"lemma SeqAppendAssoc_10004(zs: seq, t: seq, u: seq)\n ensures (zs + t) + u == zs + (t + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_10005","instance":10005,"id":196676,"goal":"lemma SeqTakeDrop_10005(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_10006","instance":10006,"id":196677,"goal":"lemma SeqReverseLen_10006(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_10007","instance":10007,"id":196678,"goal":"lemma SeqReverseIdem_10007(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_10008","instance":10008,"id":196679,"goal":"lemma SeqMapLen_10008(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_10009","instance":10009,"id":196680,"goal":"lemma SeqFilterLe_10009(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_10010","instance":10010,"id":196681,"goal":"lemma SeqMemberAppend_10010(ys: seq, zs: seq)\n ensures x in ys + zs <==> x in ys || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_10011","instance":10011,"id":196682,"goal":"lemma SeqAppendLen_10011(t: seq, xs: seq)\n ensures |t + xs| == |t| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_10012","instance":10012,"id":196683,"goal":"lemma SeqAppendNil_10012(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_10013","instance":10013,"id":196684,"goal":"lemma SeqNilAppend_10013(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_10014","instance":10014,"id":196685,"goal":"lemma SeqAppendAssoc_10014(s: seq, t: seq, xs: seq)\n ensures (s + t) + xs == s + (t + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_10015","instance":10015,"id":196686,"goal":"lemma SeqTakeDrop_10015(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_10016","instance":10016,"id":196687,"goal":"lemma SeqReverseLen_10016(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_10017","instance":10017,"id":196688,"goal":"lemma SeqReverseIdem_10017(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_10018","instance":10018,"id":196689,"goal":"lemma SeqMapLen_10018(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_10019","instance":10019,"id":196690,"goal":"lemma SeqFilterLe_10019(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_10020","instance":10020,"id":196691,"goal":"lemma SeqMemberAppend_10020(t: seq, u: seq)\n ensures x in t + u <==> x in t || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_10021","instance":10021,"id":196692,"goal":"lemma SeqAppendLen_10021(zs: seq, u: seq)\n ensures |zs + u| == |zs| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_10022","instance":10022,"id":196693,"goal":"lemma SeqAppendNil_10022(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_10023","instance":10023,"id":196694,"goal":"lemma SeqNilAppend_10023(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_10024","instance":10024,"id":196695,"goal":"lemma SeqAppendAssoc_10024(u: seq, ys: seq, s: seq)\n ensures (u + ys) + s == u + (ys + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_10025","instance":10025,"id":196696,"goal":"lemma SeqTakeDrop_10025(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_10026","instance":10026,"id":196697,"goal":"lemma SeqReverseLen_10026(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_10027","instance":10027,"id":196698,"goal":"lemma SeqReverseIdem_10027(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_10028","instance":10028,"id":196699,"goal":"lemma SeqMapLen_10028(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_10029","instance":10029,"id":196700,"goal":"lemma SeqFilterLe_10029(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_10030","instance":10030,"id":196701,"goal":"lemma SeqMemberAppend_10030(ys: seq, t: seq)\n ensures x in ys + t <==> x in ys || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_10031","instance":10031,"id":196702,"goal":"lemma SeqAppendLen_10031(s: seq, zs: seq)\n ensures |s + zs| == |s| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_10032","instance":10032,"id":196703,"goal":"lemma SeqAppendNil_10032(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_10033","instance":10033,"id":196704,"goal":"lemma SeqNilAppend_10033(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_10034","instance":10034,"id":196705,"goal":"lemma SeqAppendAssoc_10034(u: seq, t: seq, xs: seq)\n ensures (u + t) + xs == u + (t + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_10035","instance":10035,"id":196706,"goal":"lemma SeqTakeDrop_10035(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_10036","instance":10036,"id":196707,"goal":"lemma SeqReverseLen_10036(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_10037","instance":10037,"id":196708,"goal":"lemma SeqReverseIdem_10037(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_10038","instance":10038,"id":196709,"goal":"lemma SeqMapLen_10038(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_10039","instance":10039,"id":196710,"goal":"lemma SeqFilterLe_10039(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_10040","instance":10040,"id":196711,"goal":"lemma SeqMemberAppend_10040(u: seq, s: seq)\n ensures x in u + s <==> x in u || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_10041","instance":10041,"id":196712,"goal":"lemma SeqAppendLen_10041(xs: seq, s: seq)\n ensures |xs + s| == |xs| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_10042","instance":10042,"id":196713,"goal":"lemma SeqAppendNil_10042(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_10043","instance":10043,"id":196714,"goal":"lemma SeqNilAppend_10043(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_10044","instance":10044,"id":196715,"goal":"lemma SeqAppendAssoc_10044(u: seq, xs: seq, t: seq)\n ensures (u + xs) + t == u + (xs + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_10045","instance":10045,"id":196716,"goal":"lemma SeqTakeDrop_10045(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_10046","instance":10046,"id":196717,"goal":"lemma SeqReverseLen_10046(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_10047","instance":10047,"id":196718,"goal":"lemma SeqReverseIdem_10047(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_10048","instance":10048,"id":196719,"goal":"lemma SeqMapLen_10048(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_10049","instance":10049,"id":196720,"goal":"lemma SeqFilterLe_10049(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_10050","instance":10050,"id":196721,"goal":"lemma SeqMemberAppend_10050(t: seq, xs: seq)\n ensures x in t + xs <==> x in t || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_10051","instance":10051,"id":196722,"goal":"lemma SeqAppendLen_10051(s: seq, t: seq)\n ensures |s + t| == |s| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_10052","instance":10052,"id":196723,"goal":"lemma SeqAppendNil_10052(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_10053","instance":10053,"id":196724,"goal":"lemma SeqNilAppend_10053(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_10054","instance":10054,"id":196725,"goal":"lemma SeqAppendAssoc_10054(u: seq, t: seq, ys: seq)\n ensures (u + t) + ys == u + (t + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_10055","instance":10055,"id":196726,"goal":"lemma SeqTakeDrop_10055(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_10056","instance":10056,"id":196727,"goal":"lemma SeqReverseLen_10056(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_10057","instance":10057,"id":196728,"goal":"lemma SeqReverseIdem_10057(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_10058","instance":10058,"id":196729,"goal":"lemma SeqMapLen_10058(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_10059","instance":10059,"id":196730,"goal":"lemma SeqFilterLe_10059(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_10060","instance":10060,"id":196731,"goal":"lemma SeqMemberAppend_10060(zs: seq, s: seq)\n ensures x in zs + s <==> x in zs || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_10061","instance":10061,"id":196732,"goal":"lemma SeqAppendLen_10061(ys: seq, xs: seq)\n ensures |ys + xs| == |ys| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_10062","instance":10062,"id":196733,"goal":"lemma SeqAppendNil_10062(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_10063","instance":10063,"id":196734,"goal":"lemma SeqNilAppend_10063(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_10064","instance":10064,"id":196735,"goal":"lemma SeqAppendAssoc_10064(t: seq, zs: seq, u: seq)\n ensures (t + zs) + u == t + (zs + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_10065","instance":10065,"id":196736,"goal":"lemma SeqTakeDrop_10065(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_10066","instance":10066,"id":196737,"goal":"lemma SeqReverseLen_10066(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_10067","instance":10067,"id":196738,"goal":"lemma SeqReverseIdem_10067(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_10068","instance":10068,"id":196739,"goal":"lemma SeqMapLen_10068(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_10069","instance":10069,"id":196740,"goal":"lemma SeqFilterLe_10069(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_10070","instance":10070,"id":196741,"goal":"lemma SeqMemberAppend_10070(u: seq, zs: seq)\n ensures x in u + zs <==> x in u || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_10071","instance":10071,"id":196742,"goal":"lemma SeqAppendLen_10071(ys: seq, xs: seq)\n ensures |ys + xs| == |ys| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_10072","instance":10072,"id":196743,"goal":"lemma SeqAppendNil_10072(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_10073","instance":10073,"id":196744,"goal":"lemma SeqNilAppend_10073(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_10074","instance":10074,"id":196745,"goal":"lemma SeqAppendAssoc_10074(ys: seq, xs: seq, u: seq)\n ensures (ys + xs) + u == ys + (xs + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_10075","instance":10075,"id":196746,"goal":"lemma SeqTakeDrop_10075(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_10076","instance":10076,"id":196747,"goal":"lemma SeqReverseLen_10076(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_10077","instance":10077,"id":196748,"goal":"lemma SeqReverseIdem_10077(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_10078","instance":10078,"id":196749,"goal":"lemma SeqMapLen_10078(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_10079","instance":10079,"id":196750,"goal":"lemma SeqFilterLe_10079(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_10080","instance":10080,"id":196751,"goal":"lemma SeqMemberAppend_10080(u: seq, xs: seq)\n ensures x in u + xs <==> x in u || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_10081","instance":10081,"id":196752,"goal":"lemma SeqAppendLen_10081(ys: seq, u: seq)\n ensures |ys + u| == |ys| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_10082","instance":10082,"id":196753,"goal":"lemma SeqAppendNil_10082(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_10083","instance":10083,"id":196754,"goal":"lemma SeqNilAppend_10083(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_10084","instance":10084,"id":196755,"goal":"lemma SeqAppendAssoc_10084(t: seq, u: seq, xs: seq)\n ensures (t + u) + xs == t + (u + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_10085","instance":10085,"id":196756,"goal":"lemma SeqTakeDrop_10085(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_10086","instance":10086,"id":196757,"goal":"lemma SeqReverseLen_10086(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_10087","instance":10087,"id":196758,"goal":"lemma SeqReverseIdem_10087(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_10088","instance":10088,"id":196759,"goal":"lemma SeqMapLen_10088(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_10089","instance":10089,"id":196760,"goal":"lemma SeqFilterLe_10089(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_10090","instance":10090,"id":196761,"goal":"lemma SeqMemberAppend_10090(s: seq, ys: seq)\n ensures x in s + ys <==> x in s || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_10091","instance":10091,"id":196762,"goal":"lemma SeqAppendLen_10091(ys: seq, u: seq)\n ensures |ys + u| == |ys| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_10092","instance":10092,"id":196763,"goal":"lemma SeqAppendNil_10092(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_10093","instance":10093,"id":196764,"goal":"lemma SeqNilAppend_10093(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_10094","instance":10094,"id":196765,"goal":"lemma SeqAppendAssoc_10094(xs: seq, ys: seq, s: seq)\n ensures (xs + ys) + s == xs + (ys + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_10095","instance":10095,"id":196766,"goal":"lemma SeqTakeDrop_10095(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_10096","instance":10096,"id":196767,"goal":"lemma SeqReverseLen_10096(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_10097","instance":10097,"id":196768,"goal":"lemma SeqReverseIdem_10097(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_10098","instance":10098,"id":196769,"goal":"lemma SeqMapLen_10098(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_10099","instance":10099,"id":196770,"goal":"lemma SeqFilterLe_10099(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_10100","instance":10100,"id":196771,"goal":"lemma SeqMemberAppend_10100(t: seq, ys: seq)\n ensures x in t + ys <==> x in t || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_10101","instance":10101,"id":196772,"goal":"lemma SeqAppendLen_10101(s: seq, xs: seq)\n ensures |s + xs| == |s| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_10102","instance":10102,"id":196773,"goal":"lemma SeqAppendNil_10102(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_10103","instance":10103,"id":196774,"goal":"lemma SeqNilAppend_10103(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_10104","instance":10104,"id":196775,"goal":"lemma SeqAppendAssoc_10104(t: seq, u: seq, xs: seq)\n ensures (t + u) + xs == t + (u + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_10105","instance":10105,"id":196776,"goal":"lemma SeqTakeDrop_10105(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_10106","instance":10106,"id":196777,"goal":"lemma SeqReverseLen_10106(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_10107","instance":10107,"id":196778,"goal":"lemma SeqReverseIdem_10107(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_10108","instance":10108,"id":196779,"goal":"lemma SeqMapLen_10108(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_10109","instance":10109,"id":196780,"goal":"lemma SeqFilterLe_10109(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_10110","instance":10110,"id":196781,"goal":"lemma SeqMemberAppend_10110(ys: seq, zs: seq)\n ensures x in ys + zs <==> x in ys || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_10111","instance":10111,"id":196782,"goal":"lemma SeqAppendLen_10111(zs: seq, xs: seq)\n ensures |zs + xs| == |zs| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_10112","instance":10112,"id":196783,"goal":"lemma SeqAppendNil_10112(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_10113","instance":10113,"id":196784,"goal":"lemma SeqNilAppend_10113(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_10114","instance":10114,"id":196785,"goal":"lemma SeqAppendAssoc_10114(zs: seq, u: seq, xs: seq)\n ensures (zs + u) + xs == zs + (u + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_10115","instance":10115,"id":196786,"goal":"lemma SeqTakeDrop_10115(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_10116","instance":10116,"id":196787,"goal":"lemma SeqReverseLen_10116(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_10117","instance":10117,"id":196788,"goal":"lemma SeqReverseIdem_10117(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_10118","instance":10118,"id":196789,"goal":"lemma SeqMapLen_10118(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_10119","instance":10119,"id":196790,"goal":"lemma SeqFilterLe_10119(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_10120","instance":10120,"id":196791,"goal":"lemma SeqMemberAppend_10120(zs: seq, xs: seq)\n ensures x in zs + xs <==> x in zs || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_10121","instance":10121,"id":196792,"goal":"lemma SeqAppendLen_10121(s: seq, t: seq)\n ensures |s + t| == |s| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_10122","instance":10122,"id":196793,"goal":"lemma SeqAppendNil_10122(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_10123","instance":10123,"id":196794,"goal":"lemma SeqNilAppend_10123(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_10124","instance":10124,"id":196795,"goal":"lemma SeqAppendAssoc_10124(u: seq, s: seq, xs: seq)\n ensures (u + s) + xs == u + (s + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_10125","instance":10125,"id":196796,"goal":"lemma SeqTakeDrop_10125(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_10126","instance":10126,"id":196797,"goal":"lemma SeqReverseLen_10126(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_10127","instance":10127,"id":196798,"goal":"lemma SeqReverseIdem_10127(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_10128","instance":10128,"id":196799,"goal":"lemma SeqMapLen_10128(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_10129","instance":10129,"id":196800,"goal":"lemma SeqFilterLe_10129(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_10130","instance":10130,"id":196801,"goal":"lemma SeqMemberAppend_10130(zs: seq, ys: seq)\n ensures x in zs + ys <==> x in zs || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_10131","instance":10131,"id":196802,"goal":"lemma SeqAppendLen_10131(t: seq, u: seq)\n ensures |t + u| == |t| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_10132","instance":10132,"id":196803,"goal":"lemma SeqAppendNil_10132(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_10133","instance":10133,"id":196804,"goal":"lemma SeqNilAppend_10133(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_10134","instance":10134,"id":196805,"goal":"lemma SeqAppendAssoc_10134(u: seq, t: seq, zs: seq)\n ensures (u + t) + zs == u + (t + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_10135","instance":10135,"id":196806,"goal":"lemma SeqTakeDrop_10135(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_10136","instance":10136,"id":196807,"goal":"lemma SeqReverseLen_10136(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_10137","instance":10137,"id":196808,"goal":"lemma SeqReverseIdem_10137(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_10138","instance":10138,"id":196809,"goal":"lemma SeqMapLen_10138(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_10139","instance":10139,"id":196810,"goal":"lemma SeqFilterLe_10139(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_10140","instance":10140,"id":196811,"goal":"lemma SeqMemberAppend_10140(zs: seq, u: seq)\n ensures x in zs + u <==> x in zs || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_10141","instance":10141,"id":196812,"goal":"lemma SeqAppendLen_10141(ys: seq, t: seq)\n ensures |ys + t| == |ys| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_10142","instance":10142,"id":196813,"goal":"lemma SeqAppendNil_10142(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_10143","instance":10143,"id":196814,"goal":"lemma SeqNilAppend_10143(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_10144","instance":10144,"id":196815,"goal":"lemma SeqAppendAssoc_10144(zs: seq, u: seq, ys: seq)\n ensures (zs + u) + ys == zs + (u + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_10145","instance":10145,"id":196816,"goal":"lemma SeqTakeDrop_10145(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_10146","instance":10146,"id":196817,"goal":"lemma SeqReverseLen_10146(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_10147","instance":10147,"id":196818,"goal":"lemma SeqReverseIdem_10147(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_10148","instance":10148,"id":196819,"goal":"lemma SeqMapLen_10148(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_10149","instance":10149,"id":196820,"goal":"lemma SeqFilterLe_10149(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_10150","instance":10150,"id":196821,"goal":"lemma SeqMemberAppend_10150(t: seq, s: seq)\n ensures x in t + s <==> x in t || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_10151","instance":10151,"id":196822,"goal":"lemma SeqAppendLen_10151(ys: seq, zs: seq)\n ensures |ys + zs| == |ys| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_10152","instance":10152,"id":196823,"goal":"lemma SeqAppendNil_10152(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_10153","instance":10153,"id":196824,"goal":"lemma SeqNilAppend_10153(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_10154","instance":10154,"id":196825,"goal":"lemma SeqAppendAssoc_10154(ys: seq, s: seq, xs: seq)\n ensures (ys + s) + xs == ys + (s + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_10155","instance":10155,"id":196826,"goal":"lemma SeqTakeDrop_10155(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_10156","instance":10156,"id":196827,"goal":"lemma SeqReverseLen_10156(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_10157","instance":10157,"id":196828,"goal":"lemma SeqReverseIdem_10157(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_10158","instance":10158,"id":196829,"goal":"lemma SeqMapLen_10158(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_10159","instance":10159,"id":196830,"goal":"lemma SeqFilterLe_10159(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_10160","instance":10160,"id":196831,"goal":"lemma SeqMemberAppend_10160(zs: seq, u: seq)\n ensures x in zs + u <==> x in zs || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_10161","instance":10161,"id":196832,"goal":"lemma SeqAppendLen_10161(zs: seq, u: seq)\n ensures |zs + u| == |zs| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_10162","instance":10162,"id":196833,"goal":"lemma SeqAppendNil_10162(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_10163","instance":10163,"id":196834,"goal":"lemma SeqNilAppend_10163(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_10164","instance":10164,"id":196835,"goal":"lemma SeqAppendAssoc_10164(u: seq, t: seq, ys: seq)\n ensures (u + t) + ys == u + (t + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_10165","instance":10165,"id":196836,"goal":"lemma SeqTakeDrop_10165(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_10166","instance":10166,"id":196837,"goal":"lemma SeqReverseLen_10166(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_10167","instance":10167,"id":196838,"goal":"lemma SeqReverseIdem_10167(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_10168","instance":10168,"id":196839,"goal":"lemma SeqMapLen_10168(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_10169","instance":10169,"id":196840,"goal":"lemma SeqFilterLe_10169(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_10170","instance":10170,"id":196841,"goal":"lemma SeqMemberAppend_10170(xs: seq, ys: seq)\n ensures x in xs + ys <==> x in xs || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_10171","instance":10171,"id":196842,"goal":"lemma SeqAppendLen_10171(s: seq, u: seq)\n ensures |s + u| == |s| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_10172","instance":10172,"id":196843,"goal":"lemma SeqAppendNil_10172(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_10173","instance":10173,"id":196844,"goal":"lemma SeqNilAppend_10173(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_10174","instance":10174,"id":196845,"goal":"lemma SeqAppendAssoc_10174(t: seq, s: seq, zs: seq)\n ensures (t + s) + zs == t + (s + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_10175","instance":10175,"id":196846,"goal":"lemma SeqTakeDrop_10175(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_10176","instance":10176,"id":196847,"goal":"lemma SeqReverseLen_10176(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_10177","instance":10177,"id":196848,"goal":"lemma SeqReverseIdem_10177(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_10178","instance":10178,"id":196849,"goal":"lemma SeqMapLen_10178(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_10179","instance":10179,"id":196850,"goal":"lemma SeqFilterLe_10179(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_10180","instance":10180,"id":196851,"goal":"lemma SeqMemberAppend_10180(ys: seq, zs: seq)\n ensures x in ys + zs <==> x in ys || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_10181","instance":10181,"id":196852,"goal":"lemma SeqAppendLen_10181(t: seq, ys: seq)\n ensures |t + ys| == |t| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_10182","instance":10182,"id":196853,"goal":"lemma SeqAppendNil_10182(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_10183","instance":10183,"id":196854,"goal":"lemma SeqNilAppend_10183(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_10184","instance":10184,"id":196855,"goal":"lemma SeqAppendAssoc_10184(xs: seq, zs: seq, s: seq)\n ensures (xs + zs) + s == xs + (zs + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_10185","instance":10185,"id":196856,"goal":"lemma SeqTakeDrop_10185(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_10186","instance":10186,"id":196857,"goal":"lemma SeqReverseLen_10186(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_10187","instance":10187,"id":196858,"goal":"lemma SeqReverseIdem_10187(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_10188","instance":10188,"id":196859,"goal":"lemma SeqMapLen_10188(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_10189","instance":10189,"id":196860,"goal":"lemma SeqFilterLe_10189(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_10190","instance":10190,"id":196861,"goal":"lemma SeqMemberAppend_10190(ys: seq, s: seq)\n ensures x in ys + s <==> x in ys || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_10191","instance":10191,"id":196862,"goal":"lemma SeqAppendLen_10191(s: seq, xs: seq)\n ensures |s + xs| == |s| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_10192","instance":10192,"id":196863,"goal":"lemma SeqAppendNil_10192(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_10193","instance":10193,"id":196864,"goal":"lemma SeqNilAppend_10193(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_10194","instance":10194,"id":196865,"goal":"lemma SeqAppendAssoc_10194(ys: seq, t: seq, xs: seq)\n ensures (ys + t) + xs == ys + (t + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_10195","instance":10195,"id":196866,"goal":"lemma SeqTakeDrop_10195(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_10196","instance":10196,"id":196867,"goal":"lemma SeqReverseLen_10196(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_10197","instance":10197,"id":196868,"goal":"lemma SeqReverseIdem_10197(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_10198","instance":10198,"id":196869,"goal":"lemma SeqMapLen_10198(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_10199","instance":10199,"id":196870,"goal":"lemma SeqFilterLe_10199(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_10200","instance":10200,"id":196871,"goal":"lemma SeqMemberAppend_10200(zs: seq, xs: seq)\n ensures x in zs + xs <==> x in zs || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_10201","instance":10201,"id":196872,"goal":"lemma SeqAppendLen_10201(t: seq, s: seq)\n ensures |t + s| == |t| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_10202","instance":10202,"id":196873,"goal":"lemma SeqAppendNil_10202(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_10203","instance":10203,"id":196874,"goal":"lemma SeqNilAppend_10203(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_10204","instance":10204,"id":196875,"goal":"lemma SeqAppendAssoc_10204(zs: seq, u: seq, s: seq)\n ensures (zs + u) + s == zs + (u + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_10205","instance":10205,"id":196876,"goal":"lemma SeqTakeDrop_10205(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_10206","instance":10206,"id":196877,"goal":"lemma SeqReverseLen_10206(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_10207","instance":10207,"id":196878,"goal":"lemma SeqReverseIdem_10207(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_10208","instance":10208,"id":196879,"goal":"lemma SeqMapLen_10208(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_10209","instance":10209,"id":196880,"goal":"lemma SeqFilterLe_10209(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_10210","instance":10210,"id":196881,"goal":"lemma SeqMemberAppend_10210(ys: seq, xs: seq)\n ensures x in ys + xs <==> x in ys || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_10211","instance":10211,"id":196882,"goal":"lemma SeqAppendLen_10211(zs: seq, u: seq)\n ensures |zs + u| == |zs| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_10212","instance":10212,"id":196883,"goal":"lemma SeqAppendNil_10212(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_10213","instance":10213,"id":196884,"goal":"lemma SeqNilAppend_10213(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_10214","instance":10214,"id":196885,"goal":"lemma SeqAppendAssoc_10214(xs: seq, s: seq, zs: seq)\n ensures (xs + s) + zs == xs + (s + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_10215","instance":10215,"id":196886,"goal":"lemma SeqTakeDrop_10215(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_10216","instance":10216,"id":196887,"goal":"lemma SeqReverseLen_10216(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_10217","instance":10217,"id":196888,"goal":"lemma SeqReverseIdem_10217(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_10218","instance":10218,"id":196889,"goal":"lemma SeqMapLen_10218(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_10219","instance":10219,"id":196890,"goal":"lemma SeqFilterLe_10219(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_10220","instance":10220,"id":196891,"goal":"lemma SeqMemberAppend_10220(zs: seq, t: seq)\n ensures x in zs + t <==> x in zs || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_10221","instance":10221,"id":196892,"goal":"lemma SeqAppendLen_10221(u: seq, s: seq)\n ensures |u + s| == |u| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_10222","instance":10222,"id":196893,"goal":"lemma SeqAppendNil_10222(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_10223","instance":10223,"id":196894,"goal":"lemma SeqNilAppend_10223(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_10224","instance":10224,"id":196895,"goal":"lemma SeqAppendAssoc_10224(s: seq, xs: seq, ys: seq)\n ensures (s + xs) + ys == s + (xs + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_10225","instance":10225,"id":196896,"goal":"lemma SeqTakeDrop_10225(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_10226","instance":10226,"id":196897,"goal":"lemma SeqReverseLen_10226(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_10227","instance":10227,"id":196898,"goal":"lemma SeqReverseIdem_10227(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_10228","instance":10228,"id":196899,"goal":"lemma SeqMapLen_10228(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_10229","instance":10229,"id":196900,"goal":"lemma SeqFilterLe_10229(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_10230","instance":10230,"id":196901,"goal":"lemma SeqMemberAppend_10230(u: seq, xs: seq)\n ensures x in u + xs <==> x in u || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_10231","instance":10231,"id":196902,"goal":"lemma SeqAppendLen_10231(zs: seq, ys: seq)\n ensures |zs + ys| == |zs| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_10232","instance":10232,"id":196903,"goal":"lemma SeqAppendNil_10232(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_10233","instance":10233,"id":196904,"goal":"lemma SeqNilAppend_10233(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_10234","instance":10234,"id":196905,"goal":"lemma SeqAppendAssoc_10234(xs: seq, ys: seq, zs: seq)\n ensures (xs + ys) + zs == xs + (ys + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_10235","instance":10235,"id":196906,"goal":"lemma SeqTakeDrop_10235(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_10236","instance":10236,"id":196907,"goal":"lemma SeqReverseLen_10236(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_10237","instance":10237,"id":196908,"goal":"lemma SeqReverseIdem_10237(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_10238","instance":10238,"id":196909,"goal":"lemma SeqMapLen_10238(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_10239","instance":10239,"id":196910,"goal":"lemma SeqFilterLe_10239(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_10240","instance":10240,"id":196911,"goal":"lemma SeqMemberAppend_10240(t: seq, u: seq)\n ensures x in t + u <==> x in t || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_10241","instance":10241,"id":196912,"goal":"lemma SeqAppendLen_10241(t: seq, zs: seq)\n ensures |t + zs| == |t| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_10242","instance":10242,"id":196913,"goal":"lemma SeqAppendNil_10242(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_10243","instance":10243,"id":196914,"goal":"lemma SeqNilAppend_10243(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_10244","instance":10244,"id":196915,"goal":"lemma SeqAppendAssoc_10244(ys: seq, s: seq, zs: seq)\n ensures (ys + s) + zs == ys + (s + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_10245","instance":10245,"id":196916,"goal":"lemma SeqTakeDrop_10245(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_10246","instance":10246,"id":196917,"goal":"lemma SeqReverseLen_10246(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_10247","instance":10247,"id":196918,"goal":"lemma SeqReverseIdem_10247(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_10248","instance":10248,"id":196919,"goal":"lemma SeqMapLen_10248(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_10249","instance":10249,"id":196920,"goal":"lemma SeqFilterLe_10249(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_10250","instance":10250,"id":196921,"goal":"lemma SeqMemberAppend_10250(t: seq, ys: seq)\n ensures x in t + ys <==> x in t || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_10251","instance":10251,"id":196922,"goal":"lemma SeqAppendLen_10251(ys: seq, s: seq)\n ensures |ys + s| == |ys| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_10252","instance":10252,"id":196923,"goal":"lemma SeqAppendNil_10252(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_10253","instance":10253,"id":196924,"goal":"lemma SeqNilAppend_10253(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_10254","instance":10254,"id":196925,"goal":"lemma SeqAppendAssoc_10254(ys: seq, u: seq, t: seq)\n ensures (ys + u) + t == ys + (u + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_10255","instance":10255,"id":196926,"goal":"lemma SeqTakeDrop_10255(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_10256","instance":10256,"id":196927,"goal":"lemma SeqReverseLen_10256(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_10257","instance":10257,"id":196928,"goal":"lemma SeqReverseIdem_10257(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_10258","instance":10258,"id":196929,"goal":"lemma SeqMapLen_10258(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_10259","instance":10259,"id":196930,"goal":"lemma SeqFilterLe_10259(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_10260","instance":10260,"id":196931,"goal":"lemma SeqMemberAppend_10260(ys: seq, s: seq)\n ensures x in ys + s <==> x in ys || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_10261","instance":10261,"id":196932,"goal":"lemma SeqAppendLen_10261(s: seq, zs: seq)\n ensures |s + zs| == |s| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_10262","instance":10262,"id":196933,"goal":"lemma SeqAppendNil_10262(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_10263","instance":10263,"id":196934,"goal":"lemma SeqNilAppend_10263(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_10264","instance":10264,"id":196935,"goal":"lemma SeqAppendAssoc_10264(xs: seq, t: seq, zs: seq)\n ensures (xs + t) + zs == xs + (t + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_10265","instance":10265,"id":196936,"goal":"lemma SeqTakeDrop_10265(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_10266","instance":10266,"id":196937,"goal":"lemma SeqReverseLen_10266(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_10267","instance":10267,"id":196938,"goal":"lemma SeqReverseIdem_10267(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_10268","instance":10268,"id":196939,"goal":"lemma SeqMapLen_10268(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_10269","instance":10269,"id":196940,"goal":"lemma SeqFilterLe_10269(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_10270","instance":10270,"id":196941,"goal":"lemma SeqMemberAppend_10270(ys: seq, xs: seq)\n ensures x in ys + xs <==> x in ys || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_10271","instance":10271,"id":196942,"goal":"lemma SeqAppendLen_10271(s: seq, t: seq)\n ensures |s + t| == |s| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_10272","instance":10272,"id":196943,"goal":"lemma SeqAppendNil_10272(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_10273","instance":10273,"id":196944,"goal":"lemma SeqNilAppend_10273(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_10274","instance":10274,"id":196945,"goal":"lemma SeqAppendAssoc_10274(t: seq, zs: seq, u: seq)\n ensures (t + zs) + u == t + (zs + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_10275","instance":10275,"id":196946,"goal":"lemma SeqTakeDrop_10275(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_10276","instance":10276,"id":196947,"goal":"lemma SeqReverseLen_10276(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_10277","instance":10277,"id":196948,"goal":"lemma SeqReverseIdem_10277(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_10278","instance":10278,"id":196949,"goal":"lemma SeqMapLen_10278(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_10279","instance":10279,"id":196950,"goal":"lemma SeqFilterLe_10279(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_10280","instance":10280,"id":196951,"goal":"lemma SeqMemberAppend_10280(s: seq, ys: seq)\n ensures x in s + ys <==> x in s || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_10281","instance":10281,"id":196952,"goal":"lemma SeqAppendLen_10281(zs: seq, s: seq)\n ensures |zs + s| == |zs| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_10282","instance":10282,"id":196953,"goal":"lemma SeqAppendNil_10282(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_10283","instance":10283,"id":196954,"goal":"lemma SeqNilAppend_10283(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_10284","instance":10284,"id":196955,"goal":"lemma SeqAppendAssoc_10284(xs: seq, ys: seq, zs: seq)\n ensures (xs + ys) + zs == xs + (ys + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_10285","instance":10285,"id":196956,"goal":"lemma SeqTakeDrop_10285(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_10286","instance":10286,"id":196957,"goal":"lemma SeqReverseLen_10286(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_10287","instance":10287,"id":196958,"goal":"lemma SeqReverseIdem_10287(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_10288","instance":10288,"id":196959,"goal":"lemma SeqMapLen_10288(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_10289","instance":10289,"id":196960,"goal":"lemma SeqFilterLe_10289(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_10290","instance":10290,"id":196961,"goal":"lemma SeqMemberAppend_10290(ys: seq, xs: seq)\n ensures x in ys + xs <==> x in ys || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_10291","instance":10291,"id":196962,"goal":"lemma SeqAppendLen_10291(s: seq, u: seq)\n ensures |s + u| == |s| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_10292","instance":10292,"id":196963,"goal":"lemma SeqAppendNil_10292(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_10293","instance":10293,"id":196964,"goal":"lemma SeqNilAppend_10293(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_10294","instance":10294,"id":196965,"goal":"lemma SeqAppendAssoc_10294(ys: seq, zs: seq, t: seq)\n ensures (ys + zs) + t == ys + (zs + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_10295","instance":10295,"id":196966,"goal":"lemma SeqTakeDrop_10295(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_10296","instance":10296,"id":196967,"goal":"lemma SeqReverseLen_10296(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_10297","instance":10297,"id":196968,"goal":"lemma SeqReverseIdem_10297(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_10298","instance":10298,"id":196969,"goal":"lemma SeqMapLen_10298(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_10299","instance":10299,"id":196970,"goal":"lemma SeqFilterLe_10299(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_10300","instance":10300,"id":196971,"goal":"lemma SeqMemberAppend_10300(s: seq, u: seq)\n ensures x in s + u <==> x in s || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_10301","instance":10301,"id":196972,"goal":"lemma SeqAppendLen_10301(zs: seq, t: seq)\n ensures |zs + t| == |zs| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_10302","instance":10302,"id":196973,"goal":"lemma SeqAppendNil_10302(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_10303","instance":10303,"id":196974,"goal":"lemma SeqNilAppend_10303(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_10304","instance":10304,"id":196975,"goal":"lemma SeqAppendAssoc_10304(xs: seq, t: seq, u: seq)\n ensures (xs + t) + u == xs + (t + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_10305","instance":10305,"id":196976,"goal":"lemma SeqTakeDrop_10305(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_10306","instance":10306,"id":196977,"goal":"lemma SeqReverseLen_10306(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_10307","instance":10307,"id":196978,"goal":"lemma SeqReverseIdem_10307(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_10308","instance":10308,"id":196979,"goal":"lemma SeqMapLen_10308(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_10309","instance":10309,"id":196980,"goal":"lemma SeqFilterLe_10309(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_10310","instance":10310,"id":196981,"goal":"lemma SeqMemberAppend_10310(ys: seq, xs: seq)\n ensures x in ys + xs <==> x in ys || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_10311","instance":10311,"id":196982,"goal":"lemma SeqAppendLen_10311(ys: seq, s: seq)\n ensures |ys + s| == |ys| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_10312","instance":10312,"id":196983,"goal":"lemma SeqAppendNil_10312(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_10313","instance":10313,"id":196984,"goal":"lemma SeqNilAppend_10313(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_10314","instance":10314,"id":196985,"goal":"lemma SeqAppendAssoc_10314(zs: seq, u: seq, xs: seq)\n ensures (zs + u) + xs == zs + (u + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_10315","instance":10315,"id":196986,"goal":"lemma SeqTakeDrop_10315(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_10316","instance":10316,"id":196987,"goal":"lemma SeqReverseLen_10316(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_10317","instance":10317,"id":196988,"goal":"lemma SeqReverseIdem_10317(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_10318","instance":10318,"id":196989,"goal":"lemma SeqMapLen_10318(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_10319","instance":10319,"id":196990,"goal":"lemma SeqFilterLe_10319(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_10320","instance":10320,"id":196991,"goal":"lemma SeqMemberAppend_10320(ys: seq, u: seq)\n ensures x in ys + u <==> x in ys || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_10321","instance":10321,"id":196992,"goal":"lemma SeqAppendLen_10321(zs: seq, u: seq)\n ensures |zs + u| == |zs| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_10322","instance":10322,"id":196993,"goal":"lemma SeqAppendNil_10322(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_10323","instance":10323,"id":196994,"goal":"lemma SeqNilAppend_10323(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_10324","instance":10324,"id":196995,"goal":"lemma SeqAppendAssoc_10324(t: seq, xs: seq, ys: seq)\n ensures (t + xs) + ys == t + (xs + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_10325","instance":10325,"id":196996,"goal":"lemma SeqTakeDrop_10325(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_10326","instance":10326,"id":196997,"goal":"lemma SeqReverseLen_10326(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_10327","instance":10327,"id":196998,"goal":"lemma SeqReverseIdem_10327(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_10328","instance":10328,"id":196999,"goal":"lemma SeqMapLen_10328(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_10329","instance":10329,"id":197000,"goal":"lemma SeqFilterLe_10329(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_10330","instance":10330,"id":197001,"goal":"lemma SeqMemberAppend_10330(zs: seq, xs: seq)\n ensures x in zs + xs <==> x in zs || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_10331","instance":10331,"id":197002,"goal":"lemma SeqAppendLen_10331(ys: seq, xs: seq)\n ensures |ys + xs| == |ys| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_10332","instance":10332,"id":197003,"goal":"lemma SeqAppendNil_10332(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_10333","instance":10333,"id":197004,"goal":"lemma SeqNilAppend_10333(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_10334","instance":10334,"id":197005,"goal":"lemma SeqAppendAssoc_10334(zs: seq, s: seq, t: seq)\n ensures (zs + s) + t == zs + (s + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_10335","instance":10335,"id":197006,"goal":"lemma SeqTakeDrop_10335(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_10336","instance":10336,"id":197007,"goal":"lemma SeqReverseLen_10336(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_10337","instance":10337,"id":197008,"goal":"lemma SeqReverseIdem_10337(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_10338","instance":10338,"id":197009,"goal":"lemma SeqMapLen_10338(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_10339","instance":10339,"id":197010,"goal":"lemma SeqFilterLe_10339(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_10340","instance":10340,"id":197011,"goal":"lemma SeqMemberAppend_10340(ys: seq, u: seq)\n ensures x in ys + u <==> x in ys || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_10341","instance":10341,"id":197012,"goal":"lemma SeqAppendLen_10341(zs: seq, ys: seq)\n ensures |zs + ys| == |zs| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_10342","instance":10342,"id":197013,"goal":"lemma SeqAppendNil_10342(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_10343","instance":10343,"id":197014,"goal":"lemma SeqNilAppend_10343(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_10344","instance":10344,"id":197015,"goal":"lemma SeqAppendAssoc_10344(s: seq, zs: seq, t: seq)\n ensures (s + zs) + t == s + (zs + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_10345","instance":10345,"id":197016,"goal":"lemma SeqTakeDrop_10345(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_10346","instance":10346,"id":197017,"goal":"lemma SeqReverseLen_10346(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_10347","instance":10347,"id":197018,"goal":"lemma SeqReverseIdem_10347(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_10348","instance":10348,"id":197019,"goal":"lemma SeqMapLen_10348(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_10349","instance":10349,"id":197020,"goal":"lemma SeqFilterLe_10349(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_10350","instance":10350,"id":197021,"goal":"lemma SeqMemberAppend_10350(zs: seq, t: seq)\n ensures x in zs + t <==> x in zs || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_10351","instance":10351,"id":197022,"goal":"lemma SeqAppendLen_10351(ys: seq, t: seq)\n ensures |ys + t| == |ys| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_10352","instance":10352,"id":197023,"goal":"lemma SeqAppendNil_10352(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_10353","instance":10353,"id":197024,"goal":"lemma SeqNilAppend_10353(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_10354","instance":10354,"id":197025,"goal":"lemma SeqAppendAssoc_10354(zs: seq, ys: seq, t: seq)\n ensures (zs + ys) + t == zs + (ys + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_10355","instance":10355,"id":197026,"goal":"lemma SeqTakeDrop_10355(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_10356","instance":10356,"id":197027,"goal":"lemma SeqReverseLen_10356(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_10357","instance":10357,"id":197028,"goal":"lemma SeqReverseIdem_10357(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_10358","instance":10358,"id":197029,"goal":"lemma SeqMapLen_10358(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_10359","instance":10359,"id":197030,"goal":"lemma SeqFilterLe_10359(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_10360","instance":10360,"id":197031,"goal":"lemma SeqMemberAppend_10360(u: seq, t: seq)\n ensures x in u + t <==> x in u || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_10361","instance":10361,"id":197032,"goal":"lemma SeqAppendLen_10361(xs: seq, ys: seq)\n ensures |xs + ys| == |xs| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_10362","instance":10362,"id":197033,"goal":"lemma SeqAppendNil_10362(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_10363","instance":10363,"id":197034,"goal":"lemma SeqNilAppend_10363(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_10364","instance":10364,"id":197035,"goal":"lemma SeqAppendAssoc_10364(t: seq, ys: seq, zs: seq)\n ensures (t + ys) + zs == t + (ys + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_10365","instance":10365,"id":197036,"goal":"lemma SeqTakeDrop_10365(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_10366","instance":10366,"id":197037,"goal":"lemma SeqReverseLen_10366(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_10367","instance":10367,"id":197038,"goal":"lemma SeqReverseIdem_10367(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_10368","instance":10368,"id":197039,"goal":"lemma SeqMapLen_10368(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_10369","instance":10369,"id":197040,"goal":"lemma SeqFilterLe_10369(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_10370","instance":10370,"id":197041,"goal":"lemma SeqMemberAppend_10370(u: seq, zs: seq)\n ensures x in u + zs <==> x in u || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_10371","instance":10371,"id":197042,"goal":"lemma SeqAppendLen_10371(t: seq, xs: seq)\n ensures |t + xs| == |t| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_10372","instance":10372,"id":197043,"goal":"lemma SeqAppendNil_10372(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_10373","instance":10373,"id":197044,"goal":"lemma SeqNilAppend_10373(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_10374","instance":10374,"id":197045,"goal":"lemma SeqAppendAssoc_10374(zs: seq, xs: seq, ys: seq)\n ensures (zs + xs) + ys == zs + (xs + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_10375","instance":10375,"id":197046,"goal":"lemma SeqTakeDrop_10375(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_10376","instance":10376,"id":197047,"goal":"lemma SeqReverseLen_10376(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_10377","instance":10377,"id":197048,"goal":"lemma SeqReverseIdem_10377(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_10378","instance":10378,"id":197049,"goal":"lemma SeqMapLen_10378(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_10379","instance":10379,"id":197050,"goal":"lemma SeqFilterLe_10379(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_10380","instance":10380,"id":197051,"goal":"lemma SeqMemberAppend_10380(zs: seq, xs: seq)\n ensures x in zs + xs <==> x in zs || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_10381","instance":10381,"id":197052,"goal":"lemma SeqAppendLen_10381(u: seq, xs: seq)\n ensures |u + xs| == |u| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_10382","instance":10382,"id":197053,"goal":"lemma SeqAppendNil_10382(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_10383","instance":10383,"id":197054,"goal":"lemma SeqNilAppend_10383(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_10384","instance":10384,"id":197055,"goal":"lemma SeqAppendAssoc_10384(zs: seq, u: seq, xs: seq)\n ensures (zs + u) + xs == zs + (u + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_10385","instance":10385,"id":197056,"goal":"lemma SeqTakeDrop_10385(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_10386","instance":10386,"id":197057,"goal":"lemma SeqReverseLen_10386(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_10387","instance":10387,"id":197058,"goal":"lemma SeqReverseIdem_10387(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_10388","instance":10388,"id":197059,"goal":"lemma SeqMapLen_10388(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_10389","instance":10389,"id":197060,"goal":"lemma SeqFilterLe_10389(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_10390","instance":10390,"id":197061,"goal":"lemma SeqMemberAppend_10390(xs: seq, ys: seq)\n ensures x in xs + ys <==> x in xs || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_10391","instance":10391,"id":197062,"goal":"lemma SeqAppendLen_10391(zs: seq, s: seq)\n ensures |zs + s| == |zs| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_10392","instance":10392,"id":197063,"goal":"lemma SeqAppendNil_10392(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_10393","instance":10393,"id":197064,"goal":"lemma SeqNilAppend_10393(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_10394","instance":10394,"id":197065,"goal":"lemma SeqAppendAssoc_10394(u: seq, zs: seq, t: seq)\n ensures (u + zs) + t == u + (zs + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_10395","instance":10395,"id":197066,"goal":"lemma SeqTakeDrop_10395(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_10396","instance":10396,"id":197067,"goal":"lemma SeqReverseLen_10396(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_10397","instance":10397,"id":197068,"goal":"lemma SeqReverseIdem_10397(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_10398","instance":10398,"id":197069,"goal":"lemma SeqMapLen_10398(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_10399","instance":10399,"id":197070,"goal":"lemma SeqFilterLe_10399(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_10400","instance":10400,"id":197071,"goal":"lemma SeqMemberAppend_10400(zs: seq, u: seq)\n ensures x in zs + u <==> x in zs || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_10401","instance":10401,"id":197072,"goal":"lemma SeqAppendLen_10401(s: seq, ys: seq)\n ensures |s + ys| == |s| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_10402","instance":10402,"id":197073,"goal":"lemma SeqAppendNil_10402(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_10403","instance":10403,"id":197074,"goal":"lemma SeqNilAppend_10403(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_10404","instance":10404,"id":197075,"goal":"lemma SeqAppendAssoc_10404(ys: seq, xs: seq, t: seq)\n ensures (ys + xs) + t == ys + (xs + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_10405","instance":10405,"id":197076,"goal":"lemma SeqTakeDrop_10405(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_10406","instance":10406,"id":197077,"goal":"lemma SeqReverseLen_10406(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_10407","instance":10407,"id":197078,"goal":"lemma SeqReverseIdem_10407(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_10408","instance":10408,"id":197079,"goal":"lemma SeqMapLen_10408(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_10409","instance":10409,"id":197080,"goal":"lemma SeqFilterLe_10409(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_10410","instance":10410,"id":197081,"goal":"lemma SeqMemberAppend_10410(ys: seq, zs: seq)\n ensures x in ys + zs <==> x in ys || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_10411","instance":10411,"id":197082,"goal":"lemma SeqAppendLen_10411(t: seq, zs: seq)\n ensures |t + zs| == |t| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_10412","instance":10412,"id":197083,"goal":"lemma SeqAppendNil_10412(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_10413","instance":10413,"id":197084,"goal":"lemma SeqNilAppend_10413(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_10414","instance":10414,"id":197085,"goal":"lemma SeqAppendAssoc_10414(t: seq, xs: seq, zs: seq)\n ensures (t + xs) + zs == t + (xs + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_10415","instance":10415,"id":197086,"goal":"lemma SeqTakeDrop_10415(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_10416","instance":10416,"id":197087,"goal":"lemma SeqReverseLen_10416(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_10417","instance":10417,"id":197088,"goal":"lemma SeqReverseIdem_10417(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_10418","instance":10418,"id":197089,"goal":"lemma SeqMapLen_10418(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_10419","instance":10419,"id":197090,"goal":"lemma SeqFilterLe_10419(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_10420","instance":10420,"id":197091,"goal":"lemma SeqMemberAppend_10420(ys: seq, zs: seq)\n ensures x in ys + zs <==> x in ys || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_10421","instance":10421,"id":197092,"goal":"lemma SeqAppendLen_10421(u: seq, s: seq)\n ensures |u + s| == |u| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_10422","instance":10422,"id":197093,"goal":"lemma SeqAppendNil_10422(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_10423","instance":10423,"id":197094,"goal":"lemma SeqNilAppend_10423(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_10424","instance":10424,"id":197095,"goal":"lemma SeqAppendAssoc_10424(xs: seq, u: seq, t: seq)\n ensures (xs + u) + t == xs + (u + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_10425","instance":10425,"id":197096,"goal":"lemma SeqTakeDrop_10425(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_10426","instance":10426,"id":197097,"goal":"lemma SeqReverseLen_10426(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_10427","instance":10427,"id":197098,"goal":"lemma SeqReverseIdem_10427(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_10428","instance":10428,"id":197099,"goal":"lemma SeqMapLen_10428(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_10429","instance":10429,"id":197100,"goal":"lemma SeqFilterLe_10429(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_10430","instance":10430,"id":197101,"goal":"lemma SeqMemberAppend_10430(t: seq, u: seq)\n ensures x in t + u <==> x in t || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_10431","instance":10431,"id":197102,"goal":"lemma SeqAppendLen_10431(t: seq, xs: seq)\n ensures |t + xs| == |t| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_10432","instance":10432,"id":197103,"goal":"lemma SeqAppendNil_10432(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_10433","instance":10433,"id":197104,"goal":"lemma SeqNilAppend_10433(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_10434","instance":10434,"id":197105,"goal":"lemma SeqAppendAssoc_10434(xs: seq, zs: seq, t: seq)\n ensures (xs + zs) + t == xs + (zs + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_10435","instance":10435,"id":197106,"goal":"lemma SeqTakeDrop_10435(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_10436","instance":10436,"id":197107,"goal":"lemma SeqReverseLen_10436(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_10437","instance":10437,"id":197108,"goal":"lemma SeqReverseIdem_10437(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_10438","instance":10438,"id":197109,"goal":"lemma SeqMapLen_10438(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_10439","instance":10439,"id":197110,"goal":"lemma SeqFilterLe_10439(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_10440","instance":10440,"id":197111,"goal":"lemma SeqMemberAppend_10440(ys: seq, xs: seq)\n ensures x in ys + xs <==> x in ys || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_10441","instance":10441,"id":197112,"goal":"lemma SeqAppendLen_10441(zs: seq, s: seq)\n ensures |zs + s| == |zs| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_10442","instance":10442,"id":197113,"goal":"lemma SeqAppendNil_10442(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_10443","instance":10443,"id":197114,"goal":"lemma SeqNilAppend_10443(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_10444","instance":10444,"id":197115,"goal":"lemma SeqAppendAssoc_10444(u: seq, zs: seq, xs: seq)\n ensures (u + zs) + xs == u + (zs + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_10445","instance":10445,"id":197116,"goal":"lemma SeqTakeDrop_10445(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_10446","instance":10446,"id":197117,"goal":"lemma SeqReverseLen_10446(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_10447","instance":10447,"id":197118,"goal":"lemma SeqReverseIdem_10447(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_10448","instance":10448,"id":197119,"goal":"lemma SeqMapLen_10448(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_10449","instance":10449,"id":197120,"goal":"lemma SeqFilterLe_10449(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_10450","instance":10450,"id":197121,"goal":"lemma SeqMemberAppend_10450(u: seq, s: seq)\n ensures x in u + s <==> x in u || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_10451","instance":10451,"id":197122,"goal":"lemma SeqAppendLen_10451(ys: seq, u: seq)\n ensures |ys + u| == |ys| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_10452","instance":10452,"id":197123,"goal":"lemma SeqAppendNil_10452(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_10453","instance":10453,"id":197124,"goal":"lemma SeqNilAppend_10453(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_10454","instance":10454,"id":197125,"goal":"lemma SeqAppendAssoc_10454(t: seq, ys: seq, u: seq)\n ensures (t + ys) + u == t + (ys + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_10455","instance":10455,"id":197126,"goal":"lemma SeqTakeDrop_10455(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_10456","instance":10456,"id":197127,"goal":"lemma SeqReverseLen_10456(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_10457","instance":10457,"id":197128,"goal":"lemma SeqReverseIdem_10457(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_10458","instance":10458,"id":197129,"goal":"lemma SeqMapLen_10458(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_10459","instance":10459,"id":197130,"goal":"lemma SeqFilterLe_10459(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_10460","instance":10460,"id":197131,"goal":"lemma SeqMemberAppend_10460(u: seq, ys: seq)\n ensures x in u + ys <==> x in u || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_10461","instance":10461,"id":197132,"goal":"lemma SeqAppendLen_10461(t: seq, s: seq)\n ensures |t + s| == |t| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_10462","instance":10462,"id":197133,"goal":"lemma SeqAppendNil_10462(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_10463","instance":10463,"id":197134,"goal":"lemma SeqNilAppend_10463(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_10464","instance":10464,"id":197135,"goal":"lemma SeqAppendAssoc_10464(xs: seq, zs: seq, ys: seq)\n ensures (xs + zs) + ys == xs + (zs + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_10465","instance":10465,"id":197136,"goal":"lemma SeqTakeDrop_10465(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_10466","instance":10466,"id":197137,"goal":"lemma SeqReverseLen_10466(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_10467","instance":10467,"id":197138,"goal":"lemma SeqReverseIdem_10467(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_10468","instance":10468,"id":197139,"goal":"lemma SeqMapLen_10468(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_10469","instance":10469,"id":197140,"goal":"lemma SeqFilterLe_10469(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_10470","instance":10470,"id":197141,"goal":"lemma SeqMemberAppend_10470(t: seq, zs: seq)\n ensures x in t + zs <==> x in t || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_10471","instance":10471,"id":197142,"goal":"lemma SeqAppendLen_10471(ys: seq, u: seq)\n ensures |ys + u| == |ys| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_10472","instance":10472,"id":197143,"goal":"lemma SeqAppendNil_10472(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_10473","instance":10473,"id":197144,"goal":"lemma SeqNilAppend_10473(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_10474","instance":10474,"id":197145,"goal":"lemma SeqAppendAssoc_10474(ys: seq, t: seq, xs: seq)\n ensures (ys + t) + xs == ys + (t + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_10475","instance":10475,"id":197146,"goal":"lemma SeqTakeDrop_10475(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_10476","instance":10476,"id":197147,"goal":"lemma SeqReverseLen_10476(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_10477","instance":10477,"id":197148,"goal":"lemma SeqReverseIdem_10477(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_10478","instance":10478,"id":197149,"goal":"lemma SeqMapLen_10478(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_10479","instance":10479,"id":197150,"goal":"lemma SeqFilterLe_10479(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_10480","instance":10480,"id":197151,"goal":"lemma SeqMemberAppend_10480(zs: seq, u: seq)\n ensures x in zs + u <==> x in zs || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_10481","instance":10481,"id":197152,"goal":"lemma SeqAppendLen_10481(ys: seq, zs: seq)\n ensures |ys + zs| == |ys| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_10482","instance":10482,"id":197153,"goal":"lemma SeqAppendNil_10482(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_10483","instance":10483,"id":197154,"goal":"lemma SeqNilAppend_10483(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_10484","instance":10484,"id":197155,"goal":"lemma SeqAppendAssoc_10484(ys: seq, s: seq, zs: seq)\n ensures (ys + s) + zs == ys + (s + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_10485","instance":10485,"id":197156,"goal":"lemma SeqTakeDrop_10485(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_10486","instance":10486,"id":197157,"goal":"lemma SeqReverseLen_10486(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_10487","instance":10487,"id":197158,"goal":"lemma SeqReverseIdem_10487(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_10488","instance":10488,"id":197159,"goal":"lemma SeqMapLen_10488(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_10489","instance":10489,"id":197160,"goal":"lemma SeqFilterLe_10489(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_10490","instance":10490,"id":197161,"goal":"lemma SeqMemberAppend_10490(ys: seq, zs: seq)\n ensures x in ys + zs <==> x in ys || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_10491","instance":10491,"id":197162,"goal":"lemma SeqAppendLen_10491(t: seq, ys: seq)\n ensures |t + ys| == |t| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_10492","instance":10492,"id":197163,"goal":"lemma SeqAppendNil_10492(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_10493","instance":10493,"id":197164,"goal":"lemma SeqNilAppend_10493(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_10494","instance":10494,"id":197165,"goal":"lemma SeqAppendAssoc_10494(ys: seq, s: seq, zs: seq)\n ensures (ys + s) + zs == ys + (s + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_10495","instance":10495,"id":197166,"goal":"lemma SeqTakeDrop_10495(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_10496","instance":10496,"id":197167,"goal":"lemma SeqReverseLen_10496(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_10497","instance":10497,"id":197168,"goal":"lemma SeqReverseIdem_10497(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_10498","instance":10498,"id":197169,"goal":"lemma SeqMapLen_10498(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_10499","instance":10499,"id":197170,"goal":"lemma SeqFilterLe_10499(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_10500","instance":10500,"id":197171,"goal":"lemma SeqMemberAppend_10500(t: seq, xs: seq)\n ensures x in t + xs <==> x in t || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_10501","instance":10501,"id":197172,"goal":"lemma SeqAppendLen_10501(zs: seq, t: seq)\n ensures |zs + t| == |zs| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_10502","instance":10502,"id":197173,"goal":"lemma SeqAppendNil_10502(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_10503","instance":10503,"id":197174,"goal":"lemma SeqNilAppend_10503(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_10504","instance":10504,"id":197175,"goal":"lemma SeqAppendAssoc_10504(u: seq, t: seq, ys: seq)\n ensures (u + t) + ys == u + (t + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_10505","instance":10505,"id":197176,"goal":"lemma SeqTakeDrop_10505(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_10506","instance":10506,"id":197177,"goal":"lemma SeqReverseLen_10506(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_10507","instance":10507,"id":197178,"goal":"lemma SeqReverseIdem_10507(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_10508","instance":10508,"id":197179,"goal":"lemma SeqMapLen_10508(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_10509","instance":10509,"id":197180,"goal":"lemma SeqFilterLe_10509(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_10510","instance":10510,"id":197181,"goal":"lemma SeqMemberAppend_10510(xs: seq, u: seq)\n ensures x in xs + u <==> x in xs || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_10511","instance":10511,"id":197182,"goal":"lemma SeqAppendLen_10511(zs: seq, ys: seq)\n ensures |zs + ys| == |zs| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_10512","instance":10512,"id":197183,"goal":"lemma SeqAppendNil_10512(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_10513","instance":10513,"id":197184,"goal":"lemma SeqNilAppend_10513(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_10514","instance":10514,"id":197185,"goal":"lemma SeqAppendAssoc_10514(u: seq, xs: seq, zs: seq)\n ensures (u + xs) + zs == u + (xs + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_10515","instance":10515,"id":197186,"goal":"lemma SeqTakeDrop_10515(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_10516","instance":10516,"id":197187,"goal":"lemma SeqReverseLen_10516(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_10517","instance":10517,"id":197188,"goal":"lemma SeqReverseIdem_10517(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_10518","instance":10518,"id":197189,"goal":"lemma SeqMapLen_10518(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_10519","instance":10519,"id":197190,"goal":"lemma SeqFilterLe_10519(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_10520","instance":10520,"id":197191,"goal":"lemma SeqMemberAppend_10520(zs: seq, s: seq)\n ensures x in zs + s <==> x in zs || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_10521","instance":10521,"id":197192,"goal":"lemma SeqAppendLen_10521(t: seq, ys: seq)\n ensures |t + ys| == |t| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_10522","instance":10522,"id":197193,"goal":"lemma SeqAppendNil_10522(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_10523","instance":10523,"id":197194,"goal":"lemma SeqNilAppend_10523(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_10524","instance":10524,"id":197195,"goal":"lemma SeqAppendAssoc_10524(xs: seq, ys: seq, s: seq)\n ensures (xs + ys) + s == xs + (ys + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_10525","instance":10525,"id":197196,"goal":"lemma SeqTakeDrop_10525(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_10526","instance":10526,"id":197197,"goal":"lemma SeqReverseLen_10526(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_10527","instance":10527,"id":197198,"goal":"lemma SeqReverseIdem_10527(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_10528","instance":10528,"id":197199,"goal":"lemma SeqMapLen_10528(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_10529","instance":10529,"id":197200,"goal":"lemma SeqFilterLe_10529(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_10530","instance":10530,"id":197201,"goal":"lemma SeqMemberAppend_10530(ys: seq, zs: seq)\n ensures x in ys + zs <==> x in ys || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_10531","instance":10531,"id":197202,"goal":"lemma SeqAppendLen_10531(t: seq, xs: seq)\n ensures |t + xs| == |t| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_10532","instance":10532,"id":197203,"goal":"lemma SeqAppendNil_10532(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_10533","instance":10533,"id":197204,"goal":"lemma SeqNilAppend_10533(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_10534","instance":10534,"id":197205,"goal":"lemma SeqAppendAssoc_10534(ys: seq, u: seq, t: seq)\n ensures (ys + u) + t == ys + (u + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_10535","instance":10535,"id":197206,"goal":"lemma SeqTakeDrop_10535(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_10536","instance":10536,"id":197207,"goal":"lemma SeqReverseLen_10536(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_10537","instance":10537,"id":197208,"goal":"lemma SeqReverseIdem_10537(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_10538","instance":10538,"id":197209,"goal":"lemma SeqMapLen_10538(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_10539","instance":10539,"id":197210,"goal":"lemma SeqFilterLe_10539(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_10540","instance":10540,"id":197211,"goal":"lemma SeqMemberAppend_10540(zs: seq, s: seq)\n ensures x in zs + s <==> x in zs || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_10541","instance":10541,"id":197212,"goal":"lemma SeqAppendLen_10541(s: seq, ys: seq)\n ensures |s + ys| == |s| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_10542","instance":10542,"id":197213,"goal":"lemma SeqAppendNil_10542(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_10543","instance":10543,"id":197214,"goal":"lemma SeqNilAppend_10543(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_10544","instance":10544,"id":197215,"goal":"lemma SeqAppendAssoc_10544(t: seq, u: seq, xs: seq)\n ensures (t + u) + xs == t + (u + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_10545","instance":10545,"id":197216,"goal":"lemma SeqTakeDrop_10545(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_10546","instance":10546,"id":197217,"goal":"lemma SeqReverseLen_10546(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_10547","instance":10547,"id":197218,"goal":"lemma SeqReverseIdem_10547(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_10548","instance":10548,"id":197219,"goal":"lemma SeqMapLen_10548(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_10549","instance":10549,"id":197220,"goal":"lemma SeqFilterLe_10549(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_10550","instance":10550,"id":197221,"goal":"lemma SeqMemberAppend_10550(u: seq, xs: seq)\n ensures x in u + xs <==> x in u || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_10551","instance":10551,"id":197222,"goal":"lemma SeqAppendLen_10551(t: seq, zs: seq)\n ensures |t + zs| == |t| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_10552","instance":10552,"id":197223,"goal":"lemma SeqAppendNil_10552(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_10553","instance":10553,"id":197224,"goal":"lemma SeqNilAppend_10553(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_10554","instance":10554,"id":197225,"goal":"lemma SeqAppendAssoc_10554(ys: seq, s: seq, zs: seq)\n ensures (ys + s) + zs == ys + (s + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_10555","instance":10555,"id":197226,"goal":"lemma SeqTakeDrop_10555(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_10556","instance":10556,"id":197227,"goal":"lemma SeqReverseLen_10556(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_10557","instance":10557,"id":197228,"goal":"lemma SeqReverseIdem_10557(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_10558","instance":10558,"id":197229,"goal":"lemma SeqMapLen_10558(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_10559","instance":10559,"id":197230,"goal":"lemma SeqFilterLe_10559(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_10560","instance":10560,"id":197231,"goal":"lemma SeqMemberAppend_10560(t: seq, u: seq)\n ensures x in t + u <==> x in t || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_10561","instance":10561,"id":197232,"goal":"lemma SeqAppendLen_10561(s: seq, t: seq)\n ensures |s + t| == |s| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_10562","instance":10562,"id":197233,"goal":"lemma SeqAppendNil_10562(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_10563","instance":10563,"id":197234,"goal":"lemma SeqNilAppend_10563(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_10564","instance":10564,"id":197235,"goal":"lemma SeqAppendAssoc_10564(u: seq, ys: seq, xs: seq)\n ensures (u + ys) + xs == u + (ys + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_10565","instance":10565,"id":197236,"goal":"lemma SeqTakeDrop_10565(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_10566","instance":10566,"id":197237,"goal":"lemma SeqReverseLen_10566(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_10567","instance":10567,"id":197238,"goal":"lemma SeqReverseIdem_10567(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_10568","instance":10568,"id":197239,"goal":"lemma SeqMapLen_10568(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_10569","instance":10569,"id":197240,"goal":"lemma SeqFilterLe_10569(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_10570","instance":10570,"id":197241,"goal":"lemma SeqMemberAppend_10570(zs: seq, u: seq)\n ensures x in zs + u <==> x in zs || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_10571","instance":10571,"id":197242,"goal":"lemma SeqAppendLen_10571(s: seq, u: seq)\n ensures |s + u| == |s| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_10572","instance":10572,"id":197243,"goal":"lemma SeqAppendNil_10572(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_10573","instance":10573,"id":197244,"goal":"lemma SeqNilAppend_10573(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_10574","instance":10574,"id":197245,"goal":"lemma SeqAppendAssoc_10574(xs: seq, t: seq, s: seq)\n ensures (xs + t) + s == xs + (t + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_10575","instance":10575,"id":197246,"goal":"lemma SeqTakeDrop_10575(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_10576","instance":10576,"id":197247,"goal":"lemma SeqReverseLen_10576(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_10577","instance":10577,"id":197248,"goal":"lemma SeqReverseIdem_10577(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_10578","instance":10578,"id":197249,"goal":"lemma SeqMapLen_10578(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_10579","instance":10579,"id":197250,"goal":"lemma SeqFilterLe_10579(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_10580","instance":10580,"id":197251,"goal":"lemma SeqMemberAppend_10580(s: seq, t: seq)\n ensures x in s + t <==> x in s || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_10581","instance":10581,"id":197252,"goal":"lemma SeqAppendLen_10581(s: seq, u: seq)\n ensures |s + u| == |s| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_10582","instance":10582,"id":197253,"goal":"lemma SeqAppendNil_10582(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_10583","instance":10583,"id":197254,"goal":"lemma SeqNilAppend_10583(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_10584","instance":10584,"id":197255,"goal":"lemma SeqAppendAssoc_10584(xs: seq, u: seq, s: seq)\n ensures (xs + u) + s == xs + (u + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_10585","instance":10585,"id":197256,"goal":"lemma SeqTakeDrop_10585(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_10586","instance":10586,"id":197257,"goal":"lemma SeqReverseLen_10586(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_10587","instance":10587,"id":197258,"goal":"lemma SeqReverseIdem_10587(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_10588","instance":10588,"id":197259,"goal":"lemma SeqMapLen_10588(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_10589","instance":10589,"id":197260,"goal":"lemma SeqFilterLe_10589(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_10590","instance":10590,"id":197261,"goal":"lemma SeqMemberAppend_10590(s: seq, ys: seq)\n ensures x in s + ys <==> x in s || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_10591","instance":10591,"id":197262,"goal":"lemma SeqAppendLen_10591(u: seq, ys: seq)\n ensures |u + ys| == |u| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_10592","instance":10592,"id":197263,"goal":"lemma SeqAppendNil_10592(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_10593","instance":10593,"id":197264,"goal":"lemma SeqNilAppend_10593(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_10594","instance":10594,"id":197265,"goal":"lemma SeqAppendAssoc_10594(zs: seq, u: seq, s: seq)\n ensures (zs + u) + s == zs + (u + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_10595","instance":10595,"id":197266,"goal":"lemma SeqTakeDrop_10595(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_10596","instance":10596,"id":197267,"goal":"lemma SeqReverseLen_10596(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_10597","instance":10597,"id":197268,"goal":"lemma SeqReverseIdem_10597(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_10598","instance":10598,"id":197269,"goal":"lemma SeqMapLen_10598(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_10599","instance":10599,"id":197270,"goal":"lemma SeqFilterLe_10599(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_10600","instance":10600,"id":197271,"goal":"lemma SeqMemberAppend_10600(xs: seq, zs: seq)\n ensures x in xs + zs <==> x in xs || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_10601","instance":10601,"id":197272,"goal":"lemma SeqAppendLen_10601(ys: seq, zs: seq)\n ensures |ys + zs| == |ys| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_10602","instance":10602,"id":197273,"goal":"lemma SeqAppendNil_10602(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_10603","instance":10603,"id":197274,"goal":"lemma SeqNilAppend_10603(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_10604","instance":10604,"id":197275,"goal":"lemma SeqAppendAssoc_10604(s: seq, ys: seq, xs: seq)\n ensures (s + ys) + xs == s + (ys + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_10605","instance":10605,"id":197276,"goal":"lemma SeqTakeDrop_10605(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_10606","instance":10606,"id":197277,"goal":"lemma SeqReverseLen_10606(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_10607","instance":10607,"id":197278,"goal":"lemma SeqReverseIdem_10607(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_10608","instance":10608,"id":197279,"goal":"lemma SeqMapLen_10608(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_10609","instance":10609,"id":197280,"goal":"lemma SeqFilterLe_10609(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_10610","instance":10610,"id":197281,"goal":"lemma SeqMemberAppend_10610(ys: seq, s: seq)\n ensures x in ys + s <==> x in ys || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_10611","instance":10611,"id":197282,"goal":"lemma SeqAppendLen_10611(u: seq, t: seq)\n ensures |u + t| == |u| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_10612","instance":10612,"id":197283,"goal":"lemma SeqAppendNil_10612(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_10613","instance":10613,"id":197284,"goal":"lemma SeqNilAppend_10613(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_10614","instance":10614,"id":197285,"goal":"lemma SeqAppendAssoc_10614(ys: seq, xs: seq, u: seq)\n ensures (ys + xs) + u == ys + (xs + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_10615","instance":10615,"id":197286,"goal":"lemma SeqTakeDrop_10615(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_10616","instance":10616,"id":197287,"goal":"lemma SeqReverseLen_10616(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_10617","instance":10617,"id":197288,"goal":"lemma SeqReverseIdem_10617(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_10618","instance":10618,"id":197289,"goal":"lemma SeqMapLen_10618(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_10619","instance":10619,"id":197290,"goal":"lemma SeqFilterLe_10619(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_10620","instance":10620,"id":197291,"goal":"lemma SeqMemberAppend_10620(zs: seq, t: seq)\n ensures x in zs + t <==> x in zs || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_10621","instance":10621,"id":197292,"goal":"lemma SeqAppendLen_10621(t: seq, ys: seq)\n ensures |t + ys| == |t| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_10622","instance":10622,"id":197293,"goal":"lemma SeqAppendNil_10622(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_10623","instance":10623,"id":197294,"goal":"lemma SeqNilAppend_10623(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_10624","instance":10624,"id":197295,"goal":"lemma SeqAppendAssoc_10624(xs: seq, zs: seq, s: seq)\n ensures (xs + zs) + s == xs + (zs + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_10625","instance":10625,"id":197296,"goal":"lemma SeqTakeDrop_10625(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_10626","instance":10626,"id":197297,"goal":"lemma SeqReverseLen_10626(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_10627","instance":10627,"id":197298,"goal":"lemma SeqReverseIdem_10627(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_10628","instance":10628,"id":197299,"goal":"lemma SeqMapLen_10628(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_10629","instance":10629,"id":197300,"goal":"lemma SeqFilterLe_10629(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_10630","instance":10630,"id":197301,"goal":"lemma SeqMemberAppend_10630(t: seq, s: seq)\n ensures x in t + s <==> x in t || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_10631","instance":10631,"id":197302,"goal":"lemma SeqAppendLen_10631(ys: seq, t: seq)\n ensures |ys + t| == |ys| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_10632","instance":10632,"id":197303,"goal":"lemma SeqAppendNil_10632(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_10633","instance":10633,"id":197304,"goal":"lemma SeqNilAppend_10633(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_10634","instance":10634,"id":197305,"goal":"lemma SeqAppendAssoc_10634(t: seq, xs: seq, u: seq)\n ensures (t + xs) + u == t + (xs + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_10635","instance":10635,"id":197306,"goal":"lemma SeqTakeDrop_10635(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_10636","instance":10636,"id":197307,"goal":"lemma SeqReverseLen_10636(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_10637","instance":10637,"id":197308,"goal":"lemma SeqReverseIdem_10637(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_10638","instance":10638,"id":197309,"goal":"lemma SeqMapLen_10638(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_10639","instance":10639,"id":197310,"goal":"lemma SeqFilterLe_10639(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_10640","instance":10640,"id":197311,"goal":"lemma SeqMemberAppend_10640(ys: seq, t: seq)\n ensures x in ys + t <==> x in ys || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_10641","instance":10641,"id":197312,"goal":"lemma SeqAppendLen_10641(xs: seq, u: seq)\n ensures |xs + u| == |xs| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_10642","instance":10642,"id":197313,"goal":"lemma SeqAppendNil_10642(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_10643","instance":10643,"id":197314,"goal":"lemma SeqNilAppend_10643(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_10644","instance":10644,"id":197315,"goal":"lemma SeqAppendAssoc_10644(ys: seq, xs: seq, s: seq)\n ensures (ys + xs) + s == ys + (xs + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_10645","instance":10645,"id":197316,"goal":"lemma SeqTakeDrop_10645(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_10646","instance":10646,"id":197317,"goal":"lemma SeqReverseLen_10646(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_10647","instance":10647,"id":197318,"goal":"lemma SeqReverseIdem_10647(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_10648","instance":10648,"id":197319,"goal":"lemma SeqMapLen_10648(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_10649","instance":10649,"id":197320,"goal":"lemma SeqFilterLe_10649(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_10650","instance":10650,"id":197321,"goal":"lemma SeqMemberAppend_10650(s: seq, ys: seq)\n ensures x in s + ys <==> x in s || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_10651","instance":10651,"id":197322,"goal":"lemma SeqAppendLen_10651(zs: seq, xs: seq)\n ensures |zs + xs| == |zs| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_10652","instance":10652,"id":197323,"goal":"lemma SeqAppendNil_10652(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_10653","instance":10653,"id":197324,"goal":"lemma SeqNilAppend_10653(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_10654","instance":10654,"id":197325,"goal":"lemma SeqAppendAssoc_10654(xs: seq, zs: seq, ys: seq)\n ensures (xs + zs) + ys == xs + (zs + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_10655","instance":10655,"id":197326,"goal":"lemma SeqTakeDrop_10655(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_10656","instance":10656,"id":197327,"goal":"lemma SeqReverseLen_10656(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_10657","instance":10657,"id":197328,"goal":"lemma SeqReverseIdem_10657(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_10658","instance":10658,"id":197329,"goal":"lemma SeqMapLen_10658(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_10659","instance":10659,"id":197330,"goal":"lemma SeqFilterLe_10659(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_10660","instance":10660,"id":197331,"goal":"lemma SeqMemberAppend_10660(xs: seq, ys: seq)\n ensures x in xs + ys <==> x in xs || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_10661","instance":10661,"id":197332,"goal":"lemma SeqAppendLen_10661(s: seq, ys: seq)\n ensures |s + ys| == |s| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_10662","instance":10662,"id":197333,"goal":"lemma SeqAppendNil_10662(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_10663","instance":10663,"id":197334,"goal":"lemma SeqNilAppend_10663(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_10664","instance":10664,"id":197335,"goal":"lemma SeqAppendAssoc_10664(u: seq, t: seq, ys: seq)\n ensures (u + t) + ys == u + (t + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_10665","instance":10665,"id":197336,"goal":"lemma SeqTakeDrop_10665(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_10666","instance":10666,"id":197337,"goal":"lemma SeqReverseLen_10666(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_10667","instance":10667,"id":197338,"goal":"lemma SeqReverseIdem_10667(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_10668","instance":10668,"id":197339,"goal":"lemma SeqMapLen_10668(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_10669","instance":10669,"id":197340,"goal":"lemma SeqFilterLe_10669(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_10670","instance":10670,"id":197341,"goal":"lemma SeqMemberAppend_10670(t: seq, zs: seq)\n ensures x in t + zs <==> x in t || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_10671","instance":10671,"id":197342,"goal":"lemma SeqAppendLen_10671(xs: seq, zs: seq)\n ensures |xs + zs| == |xs| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_10672","instance":10672,"id":197343,"goal":"lemma SeqAppendNil_10672(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_10673","instance":10673,"id":197344,"goal":"lemma SeqNilAppend_10673(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_10674","instance":10674,"id":197345,"goal":"lemma SeqAppendAssoc_10674(ys: seq, zs: seq, s: seq)\n ensures (ys + zs) + s == ys + (zs + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_10675","instance":10675,"id":197346,"goal":"lemma SeqTakeDrop_10675(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_10676","instance":10676,"id":197347,"goal":"lemma SeqReverseLen_10676(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_10677","instance":10677,"id":197348,"goal":"lemma SeqReverseIdem_10677(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_10678","instance":10678,"id":197349,"goal":"lemma SeqMapLen_10678(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_10679","instance":10679,"id":197350,"goal":"lemma SeqFilterLe_10679(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_10680","instance":10680,"id":197351,"goal":"lemma SeqMemberAppend_10680(xs: seq, zs: seq)\n ensures x in xs + zs <==> x in xs || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_10681","instance":10681,"id":197352,"goal":"lemma SeqAppendLen_10681(t: seq, s: seq)\n ensures |t + s| == |t| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_10682","instance":10682,"id":197353,"goal":"lemma SeqAppendNil_10682(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_10683","instance":10683,"id":197354,"goal":"lemma SeqNilAppend_10683(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_10684","instance":10684,"id":197355,"goal":"lemma SeqAppendAssoc_10684(u: seq, s: seq, ys: seq)\n ensures (u + s) + ys == u + (s + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_10685","instance":10685,"id":197356,"goal":"lemma SeqTakeDrop_10685(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_10686","instance":10686,"id":197357,"goal":"lemma SeqReverseLen_10686(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_10687","instance":10687,"id":197358,"goal":"lemma SeqReverseIdem_10687(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_10688","instance":10688,"id":197359,"goal":"lemma SeqMapLen_10688(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_10689","instance":10689,"id":197360,"goal":"lemma SeqFilterLe_10689(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_10690","instance":10690,"id":197361,"goal":"lemma SeqMemberAppend_10690(xs: seq, s: seq)\n ensures x in xs + s <==> x in xs || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_10691","instance":10691,"id":197362,"goal":"lemma SeqAppendLen_10691(u: seq, s: seq)\n ensures |u + s| == |u| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_10692","instance":10692,"id":197363,"goal":"lemma SeqAppendNil_10692(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_10693","instance":10693,"id":197364,"goal":"lemma SeqNilAppend_10693(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_10694","instance":10694,"id":197365,"goal":"lemma SeqAppendAssoc_10694(zs: seq, u: seq, ys: seq)\n ensures (zs + u) + ys == zs + (u + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_10695","instance":10695,"id":197366,"goal":"lemma SeqTakeDrop_10695(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_10696","instance":10696,"id":197367,"goal":"lemma SeqReverseLen_10696(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_10697","instance":10697,"id":197368,"goal":"lemma SeqReverseIdem_10697(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_10698","instance":10698,"id":197369,"goal":"lemma SeqMapLen_10698(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_10699","instance":10699,"id":197370,"goal":"lemma SeqFilterLe_10699(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_10700","instance":10700,"id":197371,"goal":"lemma SeqMemberAppend_10700(s: seq, zs: seq)\n ensures x in s + zs <==> x in s || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_10701","instance":10701,"id":197372,"goal":"lemma SeqAppendLen_10701(xs: seq, u: seq)\n ensures |xs + u| == |xs| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_10702","instance":10702,"id":197373,"goal":"lemma SeqAppendNil_10702(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_10703","instance":10703,"id":197374,"goal":"lemma SeqNilAppend_10703(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_10704","instance":10704,"id":197375,"goal":"lemma SeqAppendAssoc_10704(zs: seq, xs: seq, ys: seq)\n ensures (zs + xs) + ys == zs + (xs + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_10705","instance":10705,"id":197376,"goal":"lemma SeqTakeDrop_10705(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_10706","instance":10706,"id":197377,"goal":"lemma SeqReverseLen_10706(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_10707","instance":10707,"id":197378,"goal":"lemma SeqReverseIdem_10707(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_10708","instance":10708,"id":197379,"goal":"lemma SeqMapLen_10708(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_10709","instance":10709,"id":197380,"goal":"lemma SeqFilterLe_10709(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_10710","instance":10710,"id":197381,"goal":"lemma SeqMemberAppend_10710(xs: seq, t: seq)\n ensures x in xs + t <==> x in xs || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_10711","instance":10711,"id":197382,"goal":"lemma SeqAppendLen_10711(xs: seq, zs: seq)\n ensures |xs + zs| == |xs| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_10712","instance":10712,"id":197383,"goal":"lemma SeqAppendNil_10712(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_10713","instance":10713,"id":197384,"goal":"lemma SeqNilAppend_10713(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_10714","instance":10714,"id":197385,"goal":"lemma SeqAppendAssoc_10714(s: seq, xs: seq, zs: seq)\n ensures (s + xs) + zs == s + (xs + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_10715","instance":10715,"id":197386,"goal":"lemma SeqTakeDrop_10715(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_10716","instance":10716,"id":197387,"goal":"lemma SeqReverseLen_10716(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_10717","instance":10717,"id":197388,"goal":"lemma SeqReverseIdem_10717(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_10718","instance":10718,"id":197389,"goal":"lemma SeqMapLen_10718(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_10719","instance":10719,"id":197390,"goal":"lemma SeqFilterLe_10719(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_10720","instance":10720,"id":197391,"goal":"lemma SeqMemberAppend_10720(s: seq, ys: seq)\n ensures x in s + ys <==> x in s || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_10721","instance":10721,"id":197392,"goal":"lemma SeqAppendLen_10721(zs: seq, u: seq)\n ensures |zs + u| == |zs| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_10722","instance":10722,"id":197393,"goal":"lemma SeqAppendNil_10722(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_10723","instance":10723,"id":197394,"goal":"lemma SeqNilAppend_10723(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_10724","instance":10724,"id":197395,"goal":"lemma SeqAppendAssoc_10724(u: seq, ys: seq, zs: seq)\n ensures (u + ys) + zs == u + (ys + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_10725","instance":10725,"id":197396,"goal":"lemma SeqTakeDrop_10725(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_10726","instance":10726,"id":197397,"goal":"lemma SeqReverseLen_10726(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_10727","instance":10727,"id":197398,"goal":"lemma SeqReverseIdem_10727(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_10728","instance":10728,"id":197399,"goal":"lemma SeqMapLen_10728(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_10729","instance":10729,"id":197400,"goal":"lemma SeqFilterLe_10729(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_10730","instance":10730,"id":197401,"goal":"lemma SeqMemberAppend_10730(xs: seq, t: seq)\n ensures x in xs + t <==> x in xs || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_10731","instance":10731,"id":197402,"goal":"lemma SeqAppendLen_10731(ys: seq, s: seq)\n ensures |ys + s| == |ys| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_10732","instance":10732,"id":197403,"goal":"lemma SeqAppendNil_10732(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_10733","instance":10733,"id":197404,"goal":"lemma SeqNilAppend_10733(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_10734","instance":10734,"id":197405,"goal":"lemma SeqAppendAssoc_10734(xs: seq, zs: seq, s: seq)\n ensures (xs + zs) + s == xs + (zs + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_10735","instance":10735,"id":197406,"goal":"lemma SeqTakeDrop_10735(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_10736","instance":10736,"id":197407,"goal":"lemma SeqReverseLen_10736(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_10737","instance":10737,"id":197408,"goal":"lemma SeqReverseIdem_10737(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_10738","instance":10738,"id":197409,"goal":"lemma SeqMapLen_10738(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_10739","instance":10739,"id":197410,"goal":"lemma SeqFilterLe_10739(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_10740","instance":10740,"id":197411,"goal":"lemma SeqMemberAppend_10740(u: seq, zs: seq)\n ensures x in u + zs <==> x in u || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_10741","instance":10741,"id":197412,"goal":"lemma SeqAppendLen_10741(zs: seq, s: seq)\n ensures |zs + s| == |zs| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_10742","instance":10742,"id":197413,"goal":"lemma SeqAppendNil_10742(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_10743","instance":10743,"id":197414,"goal":"lemma SeqNilAppend_10743(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_10744","instance":10744,"id":197415,"goal":"lemma SeqAppendAssoc_10744(ys: seq, t: seq, zs: seq)\n ensures (ys + t) + zs == ys + (t + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_10745","instance":10745,"id":197416,"goal":"lemma SeqTakeDrop_10745(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_10746","instance":10746,"id":197417,"goal":"lemma SeqReverseLen_10746(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_10747","instance":10747,"id":197418,"goal":"lemma SeqReverseIdem_10747(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_10748","instance":10748,"id":197419,"goal":"lemma SeqMapLen_10748(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_10749","instance":10749,"id":197420,"goal":"lemma SeqFilterLe_10749(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_10750","instance":10750,"id":197421,"goal":"lemma SeqMemberAppend_10750(xs: seq, ys: seq)\n ensures x in xs + ys <==> x in xs || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_10751","instance":10751,"id":197422,"goal":"lemma SeqAppendLen_10751(ys: seq, u: seq)\n ensures |ys + u| == |ys| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_10752","instance":10752,"id":197423,"goal":"lemma SeqAppendNil_10752(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_10753","instance":10753,"id":197424,"goal":"lemma SeqNilAppend_10753(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_10754","instance":10754,"id":197425,"goal":"lemma SeqAppendAssoc_10754(u: seq, zs: seq, t: seq)\n ensures (u + zs) + t == u + (zs + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_10755","instance":10755,"id":197426,"goal":"lemma SeqTakeDrop_10755(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_10756","instance":10756,"id":197427,"goal":"lemma SeqReverseLen_10756(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_10757","instance":10757,"id":197428,"goal":"lemma SeqReverseIdem_10757(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_10758","instance":10758,"id":197429,"goal":"lemma SeqMapLen_10758(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_10759","instance":10759,"id":197430,"goal":"lemma SeqFilterLe_10759(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_10760","instance":10760,"id":197431,"goal":"lemma SeqMemberAppend_10760(xs: seq, ys: seq)\n ensures x in xs + ys <==> x in xs || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_10761","instance":10761,"id":197432,"goal":"lemma SeqAppendLen_10761(zs: seq, ys: seq)\n ensures |zs + ys| == |zs| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_10762","instance":10762,"id":197433,"goal":"lemma SeqAppendNil_10762(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_10763","instance":10763,"id":197434,"goal":"lemma SeqNilAppend_10763(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_10764","instance":10764,"id":197435,"goal":"lemma SeqAppendAssoc_10764(u: seq, zs: seq, ys: seq)\n ensures (u + zs) + ys == u + (zs + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_10765","instance":10765,"id":197436,"goal":"lemma SeqTakeDrop_10765(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_10766","instance":10766,"id":197437,"goal":"lemma SeqReverseLen_10766(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_10767","instance":10767,"id":197438,"goal":"lemma SeqReverseIdem_10767(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_10768","instance":10768,"id":197439,"goal":"lemma SeqMapLen_10768(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_10769","instance":10769,"id":197440,"goal":"lemma SeqFilterLe_10769(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_10770","instance":10770,"id":197441,"goal":"lemma SeqMemberAppend_10770(t: seq, xs: seq)\n ensures x in t + xs <==> x in t || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_10771","instance":10771,"id":197442,"goal":"lemma SeqAppendLen_10771(ys: seq, xs: seq)\n ensures |ys + xs| == |ys| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_10772","instance":10772,"id":197443,"goal":"lemma SeqAppendNil_10772(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_10773","instance":10773,"id":197444,"goal":"lemma SeqNilAppend_10773(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_10774","instance":10774,"id":197445,"goal":"lemma SeqAppendAssoc_10774(t: seq, s: seq, u: seq)\n ensures (t + s) + u == t + (s + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_10775","instance":10775,"id":197446,"goal":"lemma SeqTakeDrop_10775(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_10776","instance":10776,"id":197447,"goal":"lemma SeqReverseLen_10776(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_10777","instance":10777,"id":197448,"goal":"lemma SeqReverseIdem_10777(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_10778","instance":10778,"id":197449,"goal":"lemma SeqMapLen_10778(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_10779","instance":10779,"id":197450,"goal":"lemma SeqFilterLe_10779(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_10780","instance":10780,"id":197451,"goal":"lemma SeqMemberAppend_10780(s: seq, ys: seq)\n ensures x in s + ys <==> x in s || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_10781","instance":10781,"id":197452,"goal":"lemma SeqAppendLen_10781(t: seq, u: seq)\n ensures |t + u| == |t| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_10782","instance":10782,"id":197453,"goal":"lemma SeqAppendNil_10782(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_10783","instance":10783,"id":197454,"goal":"lemma SeqNilAppend_10783(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_10784","instance":10784,"id":197455,"goal":"lemma SeqAppendAssoc_10784(s: seq, zs: seq, t: seq)\n ensures (s + zs) + t == s + (zs + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_10785","instance":10785,"id":197456,"goal":"lemma SeqTakeDrop_10785(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_10786","instance":10786,"id":197457,"goal":"lemma SeqReverseLen_10786(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_10787","instance":10787,"id":197458,"goal":"lemma SeqReverseIdem_10787(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_10788","instance":10788,"id":197459,"goal":"lemma SeqMapLen_10788(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_10789","instance":10789,"id":197460,"goal":"lemma SeqFilterLe_10789(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_10790","instance":10790,"id":197461,"goal":"lemma SeqMemberAppend_10790(ys: seq, t: seq)\n ensures x in ys + t <==> x in ys || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_10791","instance":10791,"id":197462,"goal":"lemma SeqAppendLen_10791(zs: seq, xs: seq)\n ensures |zs + xs| == |zs| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_10792","instance":10792,"id":197463,"goal":"lemma SeqAppendNil_10792(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_10793","instance":10793,"id":197464,"goal":"lemma SeqNilAppend_10793(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_10794","instance":10794,"id":197465,"goal":"lemma SeqAppendAssoc_10794(u: seq, ys: seq, xs: seq)\n ensures (u + ys) + xs == u + (ys + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_10795","instance":10795,"id":197466,"goal":"lemma SeqTakeDrop_10795(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_10796","instance":10796,"id":197467,"goal":"lemma SeqReverseLen_10796(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_10797","instance":10797,"id":197468,"goal":"lemma SeqReverseIdem_10797(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_10798","instance":10798,"id":197469,"goal":"lemma SeqMapLen_10798(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_10799","instance":10799,"id":197470,"goal":"lemma SeqFilterLe_10799(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_10800","instance":10800,"id":197471,"goal":"lemma SeqMemberAppend_10800(u: seq, s: seq)\n ensures x in u + s <==> x in u || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_10801","instance":10801,"id":197472,"goal":"lemma SeqAppendLen_10801(zs: seq, ys: seq)\n ensures |zs + ys| == |zs| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_10802","instance":10802,"id":197473,"goal":"lemma SeqAppendNil_10802(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_10803","instance":10803,"id":197474,"goal":"lemma SeqNilAppend_10803(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_10804","instance":10804,"id":197475,"goal":"lemma SeqAppendAssoc_10804(t: seq, s: seq, xs: seq)\n ensures (t + s) + xs == t + (s + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_10805","instance":10805,"id":197476,"goal":"lemma SeqTakeDrop_10805(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_10806","instance":10806,"id":197477,"goal":"lemma SeqReverseLen_10806(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_10807","instance":10807,"id":197478,"goal":"lemma SeqReverseIdem_10807(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_10808","instance":10808,"id":197479,"goal":"lemma SeqMapLen_10808(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_10809","instance":10809,"id":197480,"goal":"lemma SeqFilterLe_10809(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_10810","instance":10810,"id":197481,"goal":"lemma SeqMemberAppend_10810(zs: seq, t: seq)\n ensures x in zs + t <==> x in zs || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_10811","instance":10811,"id":197482,"goal":"lemma SeqAppendLen_10811(u: seq, xs: seq)\n ensures |u + xs| == |u| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_10812","instance":10812,"id":197483,"goal":"lemma SeqAppendNil_10812(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_10813","instance":10813,"id":197484,"goal":"lemma SeqNilAppend_10813(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_10814","instance":10814,"id":197485,"goal":"lemma SeqAppendAssoc_10814(u: seq, t: seq, zs: seq)\n ensures (u + t) + zs == u + (t + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_10815","instance":10815,"id":197486,"goal":"lemma SeqTakeDrop_10815(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_10816","instance":10816,"id":197487,"goal":"lemma SeqReverseLen_10816(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_10817","instance":10817,"id":197488,"goal":"lemma SeqReverseIdem_10817(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_10818","instance":10818,"id":197489,"goal":"lemma SeqMapLen_10818(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_10819","instance":10819,"id":197490,"goal":"lemma SeqFilterLe_10819(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_10820","instance":10820,"id":197491,"goal":"lemma SeqMemberAppend_10820(xs: seq, u: seq)\n ensures x in xs + u <==> x in xs || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_10821","instance":10821,"id":197492,"goal":"lemma SeqAppendLen_10821(ys: seq, u: seq)\n ensures |ys + u| == |ys| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_10822","instance":10822,"id":197493,"goal":"lemma SeqAppendNil_10822(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_10823","instance":10823,"id":197494,"goal":"lemma SeqNilAppend_10823(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_10824","instance":10824,"id":197495,"goal":"lemma SeqAppendAssoc_10824(s: seq, u: seq, zs: seq)\n ensures (s + u) + zs == s + (u + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_10825","instance":10825,"id":197496,"goal":"lemma SeqTakeDrop_10825(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_10826","instance":10826,"id":197497,"goal":"lemma SeqReverseLen_10826(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_10827","instance":10827,"id":197498,"goal":"lemma SeqReverseIdem_10827(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_10828","instance":10828,"id":197499,"goal":"lemma SeqMapLen_10828(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_10829","instance":10829,"id":197500,"goal":"lemma SeqFilterLe_10829(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_10830","instance":10830,"id":197501,"goal":"lemma SeqMemberAppend_10830(ys: seq, s: seq)\n ensures x in ys + s <==> x in ys || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_10831","instance":10831,"id":197502,"goal":"lemma SeqAppendLen_10831(ys: seq, s: seq)\n ensures |ys + s| == |ys| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_10832","instance":10832,"id":197503,"goal":"lemma SeqAppendNil_10832(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_10833","instance":10833,"id":197504,"goal":"lemma SeqNilAppend_10833(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_10834","instance":10834,"id":197505,"goal":"lemma SeqAppendAssoc_10834(u: seq, xs: seq, ys: seq)\n ensures (u + xs) + ys == u + (xs + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_10835","instance":10835,"id":197506,"goal":"lemma SeqTakeDrop_10835(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_10836","instance":10836,"id":197507,"goal":"lemma SeqReverseLen_10836(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_10837","instance":10837,"id":197508,"goal":"lemma SeqReverseIdem_10837(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_10838","instance":10838,"id":197509,"goal":"lemma SeqMapLen_10838(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_10839","instance":10839,"id":197510,"goal":"lemma SeqFilterLe_10839(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_10840","instance":10840,"id":197511,"goal":"lemma SeqMemberAppend_10840(xs: seq, zs: seq)\n ensures x in xs + zs <==> x in xs || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_10841","instance":10841,"id":197512,"goal":"lemma SeqAppendLen_10841(u: seq, t: seq)\n ensures |u + t| == |u| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_10842","instance":10842,"id":197513,"goal":"lemma SeqAppendNil_10842(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_10843","instance":10843,"id":197514,"goal":"lemma SeqNilAppend_10843(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_10844","instance":10844,"id":197515,"goal":"lemma SeqAppendAssoc_10844(u: seq, s: seq, zs: seq)\n ensures (u + s) + zs == u + (s + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_10845","instance":10845,"id":197516,"goal":"lemma SeqTakeDrop_10845(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_10846","instance":10846,"id":197517,"goal":"lemma SeqReverseLen_10846(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_10847","instance":10847,"id":197518,"goal":"lemma SeqReverseIdem_10847(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_10848","instance":10848,"id":197519,"goal":"lemma SeqMapLen_10848(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_10849","instance":10849,"id":197520,"goal":"lemma SeqFilterLe_10849(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_10850","instance":10850,"id":197521,"goal":"lemma SeqMemberAppend_10850(t: seq, s: seq)\n ensures x in t + s <==> x in t || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_10851","instance":10851,"id":197522,"goal":"lemma SeqAppendLen_10851(s: seq, t: seq)\n ensures |s + t| == |s| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_10852","instance":10852,"id":197523,"goal":"lemma SeqAppendNil_10852(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_10853","instance":10853,"id":197524,"goal":"lemma SeqNilAppend_10853(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_10854","instance":10854,"id":197525,"goal":"lemma SeqAppendAssoc_10854(s: seq, u: seq, t: seq)\n ensures (s + u) + t == s + (u + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_10855","instance":10855,"id":197526,"goal":"lemma SeqTakeDrop_10855(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_10856","instance":10856,"id":197527,"goal":"lemma SeqReverseLen_10856(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_10857","instance":10857,"id":197528,"goal":"lemma SeqReverseIdem_10857(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_10858","instance":10858,"id":197529,"goal":"lemma SeqMapLen_10858(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_10859","instance":10859,"id":197530,"goal":"lemma SeqFilterLe_10859(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_10860","instance":10860,"id":197531,"goal":"lemma SeqMemberAppend_10860(s: seq, zs: seq)\n ensures x in s + zs <==> x in s || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_10861","instance":10861,"id":197532,"goal":"lemma SeqAppendLen_10861(zs: seq, t: seq)\n ensures |zs + t| == |zs| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_10862","instance":10862,"id":197533,"goal":"lemma SeqAppendNil_10862(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_10863","instance":10863,"id":197534,"goal":"lemma SeqNilAppend_10863(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_10864","instance":10864,"id":197535,"goal":"lemma SeqAppendAssoc_10864(xs: seq, zs: seq, t: seq)\n ensures (xs + zs) + t == xs + (zs + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_10865","instance":10865,"id":197536,"goal":"lemma SeqTakeDrop_10865(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_10866","instance":10866,"id":197537,"goal":"lemma SeqReverseLen_10866(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_10867","instance":10867,"id":197538,"goal":"lemma SeqReverseIdem_10867(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_10868","instance":10868,"id":197539,"goal":"lemma SeqMapLen_10868(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_10869","instance":10869,"id":197540,"goal":"lemma SeqFilterLe_10869(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_10870","instance":10870,"id":197541,"goal":"lemma SeqMemberAppend_10870(s: seq, ys: seq)\n ensures x in s + ys <==> x in s || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_10871","instance":10871,"id":197542,"goal":"lemma SeqAppendLen_10871(t: seq, u: seq)\n ensures |t + u| == |t| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_10872","instance":10872,"id":197543,"goal":"lemma SeqAppendNil_10872(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_10873","instance":10873,"id":197544,"goal":"lemma SeqNilAppend_10873(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_10874","instance":10874,"id":197545,"goal":"lemma SeqAppendAssoc_10874(t: seq, ys: seq, u: seq)\n ensures (t + ys) + u == t + (ys + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_10875","instance":10875,"id":197546,"goal":"lemma SeqTakeDrop_10875(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_10876","instance":10876,"id":197547,"goal":"lemma SeqReverseLen_10876(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_10877","instance":10877,"id":197548,"goal":"lemma SeqReverseIdem_10877(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_10878","instance":10878,"id":197549,"goal":"lemma SeqMapLen_10878(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_10879","instance":10879,"id":197550,"goal":"lemma SeqFilterLe_10879(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_10880","instance":10880,"id":197551,"goal":"lemma SeqMemberAppend_10880(s: seq, t: seq)\n ensures x in s + t <==> x in s || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_10881","instance":10881,"id":197552,"goal":"lemma SeqAppendLen_10881(zs: seq, ys: seq)\n ensures |zs + ys| == |zs| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_10882","instance":10882,"id":197553,"goal":"lemma SeqAppendNil_10882(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_10883","instance":10883,"id":197554,"goal":"lemma SeqNilAppend_10883(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_10884","instance":10884,"id":197555,"goal":"lemma SeqAppendAssoc_10884(s: seq, zs: seq, t: seq)\n ensures (s + zs) + t == s + (zs + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_10885","instance":10885,"id":197556,"goal":"lemma SeqTakeDrop_10885(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_10886","instance":10886,"id":197557,"goal":"lemma SeqReverseLen_10886(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_10887","instance":10887,"id":197558,"goal":"lemma SeqReverseIdem_10887(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_10888","instance":10888,"id":197559,"goal":"lemma SeqMapLen_10888(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_10889","instance":10889,"id":197560,"goal":"lemma SeqFilterLe_10889(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_10890","instance":10890,"id":197561,"goal":"lemma SeqMemberAppend_10890(zs: seq, u: seq)\n ensures x in zs + u <==> x in zs || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_10891","instance":10891,"id":197562,"goal":"lemma SeqAppendLen_10891(zs: seq, ys: seq)\n ensures |zs + ys| == |zs| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_10892","instance":10892,"id":197563,"goal":"lemma SeqAppendNil_10892(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_10893","instance":10893,"id":197564,"goal":"lemma SeqNilAppend_10893(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_10894","instance":10894,"id":197565,"goal":"lemma SeqAppendAssoc_10894(u: seq, xs: seq, zs: seq)\n ensures (u + xs) + zs == u + (xs + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_10895","instance":10895,"id":197566,"goal":"lemma SeqTakeDrop_10895(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_10896","instance":10896,"id":197567,"goal":"lemma SeqReverseLen_10896(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_10897","instance":10897,"id":197568,"goal":"lemma SeqReverseIdem_10897(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_10898","instance":10898,"id":197569,"goal":"lemma SeqMapLen_10898(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_10899","instance":10899,"id":197570,"goal":"lemma SeqFilterLe_10899(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_10900","instance":10900,"id":197571,"goal":"lemma SeqMemberAppend_10900(u: seq, zs: seq)\n ensures x in u + zs <==> x in u || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_10901","instance":10901,"id":197572,"goal":"lemma SeqAppendLen_10901(u: seq, t: seq)\n ensures |u + t| == |u| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_10902","instance":10902,"id":197573,"goal":"lemma SeqAppendNil_10902(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_10903","instance":10903,"id":197574,"goal":"lemma SeqNilAppend_10903(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_10904","instance":10904,"id":197575,"goal":"lemma SeqAppendAssoc_10904(xs: seq, s: seq, u: seq)\n ensures (xs + s) + u == xs + (s + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_10905","instance":10905,"id":197576,"goal":"lemma SeqTakeDrop_10905(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_10906","instance":10906,"id":197577,"goal":"lemma SeqReverseLen_10906(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_10907","instance":10907,"id":197578,"goal":"lemma SeqReverseIdem_10907(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_10908","instance":10908,"id":197579,"goal":"lemma SeqMapLen_10908(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_10909","instance":10909,"id":197580,"goal":"lemma SeqFilterLe_10909(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_10910","instance":10910,"id":197581,"goal":"lemma SeqMemberAppend_10910(zs: seq, u: seq)\n ensures x in zs + u <==> x in zs || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_10911","instance":10911,"id":197582,"goal":"lemma SeqAppendLen_10911(t: seq, zs: seq)\n ensures |t + zs| == |t| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_10912","instance":10912,"id":197583,"goal":"lemma SeqAppendNil_10912(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_10913","instance":10913,"id":197584,"goal":"lemma SeqNilAppend_10913(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_10914","instance":10914,"id":197585,"goal":"lemma SeqAppendAssoc_10914(u: seq, t: seq, zs: seq)\n ensures (u + t) + zs == u + (t + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_10915","instance":10915,"id":197586,"goal":"lemma SeqTakeDrop_10915(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_10916","instance":10916,"id":197587,"goal":"lemma SeqReverseLen_10916(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_10917","instance":10917,"id":197588,"goal":"lemma SeqReverseIdem_10917(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_10918","instance":10918,"id":197589,"goal":"lemma SeqMapLen_10918(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_10919","instance":10919,"id":197590,"goal":"lemma SeqFilterLe_10919(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_10920","instance":10920,"id":197591,"goal":"lemma SeqMemberAppend_10920(xs: seq, ys: seq)\n ensures x in xs + ys <==> x in xs || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_10921","instance":10921,"id":197592,"goal":"lemma SeqAppendLen_10921(ys: seq, t: seq)\n ensures |ys + t| == |ys| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_10922","instance":10922,"id":197593,"goal":"lemma SeqAppendNil_10922(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_10923","instance":10923,"id":197594,"goal":"lemma SeqNilAppend_10923(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_10924","instance":10924,"id":197595,"goal":"lemma SeqAppendAssoc_10924(t: seq, ys: seq, u: seq)\n ensures (t + ys) + u == t + (ys + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_10925","instance":10925,"id":197596,"goal":"lemma SeqTakeDrop_10925(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_10926","instance":10926,"id":197597,"goal":"lemma SeqReverseLen_10926(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_10927","instance":10927,"id":197598,"goal":"lemma SeqReverseIdem_10927(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_10928","instance":10928,"id":197599,"goal":"lemma SeqMapLen_10928(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_10929","instance":10929,"id":197600,"goal":"lemma SeqFilterLe_10929(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_10930","instance":10930,"id":197601,"goal":"lemma SeqMemberAppend_10930(zs: seq, ys: seq)\n ensures x in zs + ys <==> x in zs || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_10931","instance":10931,"id":197602,"goal":"lemma SeqAppendLen_10931(zs: seq, t: seq)\n ensures |zs + t| == |zs| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_10932","instance":10932,"id":197603,"goal":"lemma SeqAppendNil_10932(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_10933","instance":10933,"id":197604,"goal":"lemma SeqNilAppend_10933(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_10934","instance":10934,"id":197605,"goal":"lemma SeqAppendAssoc_10934(ys: seq, zs: seq, u: seq)\n ensures (ys + zs) + u == ys + (zs + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_10935","instance":10935,"id":197606,"goal":"lemma SeqTakeDrop_10935(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_10936","instance":10936,"id":197607,"goal":"lemma SeqReverseLen_10936(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_10937","instance":10937,"id":197608,"goal":"lemma SeqReverseIdem_10937(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_10938","instance":10938,"id":197609,"goal":"lemma SeqMapLen_10938(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_10939","instance":10939,"id":197610,"goal":"lemma SeqFilterLe_10939(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_10940","instance":10940,"id":197611,"goal":"lemma SeqMemberAppend_10940(xs: seq, s: seq)\n ensures x in xs + s <==> x in xs || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_10941","instance":10941,"id":197612,"goal":"lemma SeqAppendLen_10941(u: seq, t: seq)\n ensures |u + t| == |u| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_10942","instance":10942,"id":197613,"goal":"lemma SeqAppendNil_10942(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_10943","instance":10943,"id":197614,"goal":"lemma SeqNilAppend_10943(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_10944","instance":10944,"id":197615,"goal":"lemma SeqAppendAssoc_10944(u: seq, t: seq, ys: seq)\n ensures (u + t) + ys == u + (t + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_10945","instance":10945,"id":197616,"goal":"lemma SeqTakeDrop_10945(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_10946","instance":10946,"id":197617,"goal":"lemma SeqReverseLen_10946(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_10947","instance":10947,"id":197618,"goal":"lemma SeqReverseIdem_10947(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_10948","instance":10948,"id":197619,"goal":"lemma SeqMapLen_10948(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_10949","instance":10949,"id":197620,"goal":"lemma SeqFilterLe_10949(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_10950","instance":10950,"id":197621,"goal":"lemma SeqMemberAppend_10950(ys: seq, u: seq)\n ensures x in ys + u <==> x in ys || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_10951","instance":10951,"id":197622,"goal":"lemma SeqAppendLen_10951(s: seq, xs: seq)\n ensures |s + xs| == |s| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_10952","instance":10952,"id":197623,"goal":"lemma SeqAppendNil_10952(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_10953","instance":10953,"id":197624,"goal":"lemma SeqNilAppend_10953(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_10954","instance":10954,"id":197625,"goal":"lemma SeqAppendAssoc_10954(xs: seq, zs: seq, t: seq)\n ensures (xs + zs) + t == xs + (zs + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_10955","instance":10955,"id":197626,"goal":"lemma SeqTakeDrop_10955(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_10956","instance":10956,"id":197627,"goal":"lemma SeqReverseLen_10956(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_10957","instance":10957,"id":197628,"goal":"lemma SeqReverseIdem_10957(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_10958","instance":10958,"id":197629,"goal":"lemma SeqMapLen_10958(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_10959","instance":10959,"id":197630,"goal":"lemma SeqFilterLe_10959(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_10960","instance":10960,"id":197631,"goal":"lemma SeqMemberAppend_10960(s: seq, xs: seq)\n ensures x in s + xs <==> x in s || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_10961","instance":10961,"id":197632,"goal":"lemma SeqAppendLen_10961(u: seq, xs: seq)\n ensures |u + xs| == |u| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_10962","instance":10962,"id":197633,"goal":"lemma SeqAppendNil_10962(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_10963","instance":10963,"id":197634,"goal":"lemma SeqNilAppend_10963(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_10964","instance":10964,"id":197635,"goal":"lemma SeqAppendAssoc_10964(zs: seq, xs: seq, ys: seq)\n ensures (zs + xs) + ys == zs + (xs + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_10965","instance":10965,"id":197636,"goal":"lemma SeqTakeDrop_10965(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_10966","instance":10966,"id":197637,"goal":"lemma SeqReverseLen_10966(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_10967","instance":10967,"id":197638,"goal":"lemma SeqReverseIdem_10967(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_10968","instance":10968,"id":197639,"goal":"lemma SeqMapLen_10968(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_10969","instance":10969,"id":197640,"goal":"lemma SeqFilterLe_10969(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_10970","instance":10970,"id":197641,"goal":"lemma SeqMemberAppend_10970(zs: seq, u: seq)\n ensures x in zs + u <==> x in zs || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_10971","instance":10971,"id":197642,"goal":"lemma SeqAppendLen_10971(ys: seq, zs: seq)\n ensures |ys + zs| == |ys| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_10972","instance":10972,"id":197643,"goal":"lemma SeqAppendNil_10972(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_10973","instance":10973,"id":197644,"goal":"lemma SeqNilAppend_10973(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_10974","instance":10974,"id":197645,"goal":"lemma SeqAppendAssoc_10974(u: seq, s: seq, t: seq)\n ensures (u + s) + t == u + (s + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_10975","instance":10975,"id":197646,"goal":"lemma SeqTakeDrop_10975(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_10976","instance":10976,"id":197647,"goal":"lemma SeqReverseLen_10976(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_10977","instance":10977,"id":197648,"goal":"lemma SeqReverseIdem_10977(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_10978","instance":10978,"id":197649,"goal":"lemma SeqMapLen_10978(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_10979","instance":10979,"id":197650,"goal":"lemma SeqFilterLe_10979(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_10980","instance":10980,"id":197651,"goal":"lemma SeqMemberAppend_10980(xs: seq, t: seq)\n ensures x in xs + t <==> x in xs || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_10981","instance":10981,"id":197652,"goal":"lemma SeqAppendLen_10981(zs: seq, s: seq)\n ensures |zs + s| == |zs| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_10982","instance":10982,"id":197653,"goal":"lemma SeqAppendNil_10982(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_10983","instance":10983,"id":197654,"goal":"lemma SeqNilAppend_10983(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_10984","instance":10984,"id":197655,"goal":"lemma SeqAppendAssoc_10984(s: seq, zs: seq, u: seq)\n ensures (s + zs) + u == s + (zs + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_10985","instance":10985,"id":197656,"goal":"lemma SeqTakeDrop_10985(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_10986","instance":10986,"id":197657,"goal":"lemma SeqReverseLen_10986(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_10987","instance":10987,"id":197658,"goal":"lemma SeqReverseIdem_10987(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_10988","instance":10988,"id":197659,"goal":"lemma SeqMapLen_10988(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_10989","instance":10989,"id":197660,"goal":"lemma SeqFilterLe_10989(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_10990","instance":10990,"id":197661,"goal":"lemma SeqMemberAppend_10990(xs: seq, ys: seq)\n ensures x in xs + ys <==> x in xs || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_10991","instance":10991,"id":197662,"goal":"lemma SeqAppendLen_10991(xs: seq, ys: seq)\n ensures |xs + ys| == |xs| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_10992","instance":10992,"id":197663,"goal":"lemma SeqAppendNil_10992(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_10993","instance":10993,"id":197664,"goal":"lemma SeqNilAppend_10993(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_10994","instance":10994,"id":197665,"goal":"lemma SeqAppendAssoc_10994(zs: seq, ys: seq, s: seq)\n ensures (zs + ys) + s == zs + (ys + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_10995","instance":10995,"id":197666,"goal":"lemma SeqTakeDrop_10995(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_10996","instance":10996,"id":197667,"goal":"lemma SeqReverseLen_10996(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_10997","instance":10997,"id":197668,"goal":"lemma SeqReverseIdem_10997(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_10998","instance":10998,"id":197669,"goal":"lemma SeqMapLen_10998(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_10999","instance":10999,"id":197670,"goal":"lemma SeqFilterLe_10999(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_11000","instance":11000,"id":197671,"goal":"lemma SeqMemberAppend_11000(xs: seq, zs: seq)\n ensures x in xs + zs <==> x in xs || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_11001","instance":11001,"id":197672,"goal":"lemma SeqAppendLen_11001(ys: seq, zs: seq)\n ensures |ys + zs| == |ys| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_11002","instance":11002,"id":197673,"goal":"lemma SeqAppendNil_11002(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_11003","instance":11003,"id":197674,"goal":"lemma SeqNilAppend_11003(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_11004","instance":11004,"id":197675,"goal":"lemma SeqAppendAssoc_11004(xs: seq, t: seq, ys: seq)\n ensures (xs + t) + ys == xs + (t + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_11005","instance":11005,"id":197676,"goal":"lemma SeqTakeDrop_11005(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_11006","instance":11006,"id":197677,"goal":"lemma SeqReverseLen_11006(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_11007","instance":11007,"id":197678,"goal":"lemma SeqReverseIdem_11007(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_11008","instance":11008,"id":197679,"goal":"lemma SeqMapLen_11008(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_11009","instance":11009,"id":197680,"goal":"lemma SeqFilterLe_11009(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_11010","instance":11010,"id":197681,"goal":"lemma SeqMemberAppend_11010(s: seq, ys: seq)\n ensures x in s + ys <==> x in s || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_11011","instance":11011,"id":197682,"goal":"lemma SeqAppendLen_11011(zs: seq, u: seq)\n ensures |zs + u| == |zs| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_11012","instance":11012,"id":197683,"goal":"lemma SeqAppendNil_11012(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_11013","instance":11013,"id":197684,"goal":"lemma SeqNilAppend_11013(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_11014","instance":11014,"id":197685,"goal":"lemma SeqAppendAssoc_11014(ys: seq, t: seq, u: seq)\n ensures (ys + t) + u == ys + (t + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_11015","instance":11015,"id":197686,"goal":"lemma SeqTakeDrop_11015(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_11016","instance":11016,"id":197687,"goal":"lemma SeqReverseLen_11016(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_11017","instance":11017,"id":197688,"goal":"lemma SeqReverseIdem_11017(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_11018","instance":11018,"id":197689,"goal":"lemma SeqMapLen_11018(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_11019","instance":11019,"id":197690,"goal":"lemma SeqFilterLe_11019(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_11020","instance":11020,"id":197691,"goal":"lemma SeqMemberAppend_11020(t: seq, u: seq)\n ensures x in t + u <==> x in t || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_11021","instance":11021,"id":197692,"goal":"lemma SeqAppendLen_11021(t: seq, u: seq)\n ensures |t + u| == |t| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_11022","instance":11022,"id":197693,"goal":"lemma SeqAppendNil_11022(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_11023","instance":11023,"id":197694,"goal":"lemma SeqNilAppend_11023(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_11024","instance":11024,"id":197695,"goal":"lemma SeqAppendAssoc_11024(ys: seq, zs: seq, t: seq)\n ensures (ys + zs) + t == ys + (zs + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_11025","instance":11025,"id":197696,"goal":"lemma SeqTakeDrop_11025(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_11026","instance":11026,"id":197697,"goal":"lemma SeqReverseLen_11026(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_11027","instance":11027,"id":197698,"goal":"lemma SeqReverseIdem_11027(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_11028","instance":11028,"id":197699,"goal":"lemma SeqMapLen_11028(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_11029","instance":11029,"id":197700,"goal":"lemma SeqFilterLe_11029(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_11030","instance":11030,"id":197701,"goal":"lemma SeqMemberAppend_11030(zs: seq, xs: seq)\n ensures x in zs + xs <==> x in zs || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_11031","instance":11031,"id":197702,"goal":"lemma SeqAppendLen_11031(t: seq, ys: seq)\n ensures |t + ys| == |t| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_11032","instance":11032,"id":197703,"goal":"lemma SeqAppendNil_11032(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_11033","instance":11033,"id":197704,"goal":"lemma SeqNilAppend_11033(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_11034","instance":11034,"id":197705,"goal":"lemma SeqAppendAssoc_11034(ys: seq, u: seq, s: seq)\n ensures (ys + u) + s == ys + (u + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_11035","instance":11035,"id":197706,"goal":"lemma SeqTakeDrop_11035(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_11036","instance":11036,"id":197707,"goal":"lemma SeqReverseLen_11036(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_11037","instance":11037,"id":197708,"goal":"lemma SeqReverseIdem_11037(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_11038","instance":11038,"id":197709,"goal":"lemma SeqMapLen_11038(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_11039","instance":11039,"id":197710,"goal":"lemma SeqFilterLe_11039(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_11040","instance":11040,"id":197711,"goal":"lemma SeqMemberAppend_11040(zs: seq, t: seq)\n ensures x in zs + t <==> x in zs || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_11041","instance":11041,"id":197712,"goal":"lemma SeqAppendLen_11041(s: seq, ys: seq)\n ensures |s + ys| == |s| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_11042","instance":11042,"id":197713,"goal":"lemma SeqAppendNil_11042(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_11043","instance":11043,"id":197714,"goal":"lemma SeqNilAppend_11043(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_11044","instance":11044,"id":197715,"goal":"lemma SeqAppendAssoc_11044(t: seq, zs: seq, xs: seq)\n ensures (t + zs) + xs == t + (zs + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_11045","instance":11045,"id":197716,"goal":"lemma SeqTakeDrop_11045(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_11046","instance":11046,"id":197717,"goal":"lemma SeqReverseLen_11046(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_11047","instance":11047,"id":197718,"goal":"lemma SeqReverseIdem_11047(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_11048","instance":11048,"id":197719,"goal":"lemma SeqMapLen_11048(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_11049","instance":11049,"id":197720,"goal":"lemma SeqFilterLe_11049(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_11050","instance":11050,"id":197721,"goal":"lemma SeqMemberAppend_11050(s: seq, zs: seq)\n ensures x in s + zs <==> x in s || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_11051","instance":11051,"id":197722,"goal":"lemma SeqAppendLen_11051(u: seq, xs: seq)\n ensures |u + xs| == |u| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_11052","instance":11052,"id":197723,"goal":"lemma SeqAppendNil_11052(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_11053","instance":11053,"id":197724,"goal":"lemma SeqNilAppend_11053(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_11054","instance":11054,"id":197725,"goal":"lemma SeqAppendAssoc_11054(zs: seq, t: seq, xs: seq)\n ensures (zs + t) + xs == zs + (t + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_11055","instance":11055,"id":197726,"goal":"lemma SeqTakeDrop_11055(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_11056","instance":11056,"id":197727,"goal":"lemma SeqReverseLen_11056(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_11057","instance":11057,"id":197728,"goal":"lemma SeqReverseIdem_11057(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_11058","instance":11058,"id":197729,"goal":"lemma SeqMapLen_11058(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_11059","instance":11059,"id":197730,"goal":"lemma SeqFilterLe_11059(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_11060","instance":11060,"id":197731,"goal":"lemma SeqMemberAppend_11060(t: seq, xs: seq)\n ensures x in t + xs <==> x in t || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_11061","instance":11061,"id":197732,"goal":"lemma SeqAppendLen_11061(ys: seq, s: seq)\n ensures |ys + s| == |ys| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_11062","instance":11062,"id":197733,"goal":"lemma SeqAppendNil_11062(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_11063","instance":11063,"id":197734,"goal":"lemma SeqNilAppend_11063(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_11064","instance":11064,"id":197735,"goal":"lemma SeqAppendAssoc_11064(xs: seq, s: seq, zs: seq)\n ensures (xs + s) + zs == xs + (s + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_11065","instance":11065,"id":197736,"goal":"lemma SeqTakeDrop_11065(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_11066","instance":11066,"id":197737,"goal":"lemma SeqReverseLen_11066(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_11067","instance":11067,"id":197738,"goal":"lemma SeqReverseIdem_11067(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_11068","instance":11068,"id":197739,"goal":"lemma SeqMapLen_11068(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_11069","instance":11069,"id":197740,"goal":"lemma SeqFilterLe_11069(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_11070","instance":11070,"id":197741,"goal":"lemma SeqMemberAppend_11070(t: seq, s: seq)\n ensures x in t + s <==> x in t || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_11071","instance":11071,"id":197742,"goal":"lemma SeqAppendLen_11071(s: seq, t: seq)\n ensures |s + t| == |s| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_11072","instance":11072,"id":197743,"goal":"lemma SeqAppendNil_11072(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_11073","instance":11073,"id":197744,"goal":"lemma SeqNilAppend_11073(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_11074","instance":11074,"id":197745,"goal":"lemma SeqAppendAssoc_11074(t: seq, ys: seq, xs: seq)\n ensures (t + ys) + xs == t + (ys + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_11075","instance":11075,"id":197746,"goal":"lemma SeqTakeDrop_11075(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_11076","instance":11076,"id":197747,"goal":"lemma SeqReverseLen_11076(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_11077","instance":11077,"id":197748,"goal":"lemma SeqReverseIdem_11077(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_11078","instance":11078,"id":197749,"goal":"lemma SeqMapLen_11078(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_11079","instance":11079,"id":197750,"goal":"lemma SeqFilterLe_11079(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_11080","instance":11080,"id":197751,"goal":"lemma SeqMemberAppend_11080(zs: seq, ys: seq)\n ensures x in zs + ys <==> x in zs || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_11081","instance":11081,"id":197752,"goal":"lemma SeqAppendLen_11081(xs: seq, t: seq)\n ensures |xs + t| == |xs| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_11082","instance":11082,"id":197753,"goal":"lemma SeqAppendNil_11082(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_11083","instance":11083,"id":197754,"goal":"lemma SeqNilAppend_11083(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_11084","instance":11084,"id":197755,"goal":"lemma SeqAppendAssoc_11084(xs: seq, t: seq, zs: seq)\n ensures (xs + t) + zs == xs + (t + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_11085","instance":11085,"id":197756,"goal":"lemma SeqTakeDrop_11085(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_11086","instance":11086,"id":197757,"goal":"lemma SeqReverseLen_11086(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_11087","instance":11087,"id":197758,"goal":"lemma SeqReverseIdem_11087(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_11088","instance":11088,"id":197759,"goal":"lemma SeqMapLen_11088(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_11089","instance":11089,"id":197760,"goal":"lemma SeqFilterLe_11089(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_11090","instance":11090,"id":197761,"goal":"lemma SeqMemberAppend_11090(ys: seq, s: seq)\n ensures x in ys + s <==> x in ys || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_11091","instance":11091,"id":197762,"goal":"lemma SeqAppendLen_11091(u: seq, s: seq)\n ensures |u + s| == |u| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_11092","instance":11092,"id":197763,"goal":"lemma SeqAppendNil_11092(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_11093","instance":11093,"id":197764,"goal":"lemma SeqNilAppend_11093(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_11094","instance":11094,"id":197765,"goal":"lemma SeqAppendAssoc_11094(s: seq, xs: seq, t: seq)\n ensures (s + xs) + t == s + (xs + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_11095","instance":11095,"id":197766,"goal":"lemma SeqTakeDrop_11095(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_11096","instance":11096,"id":197767,"goal":"lemma SeqReverseLen_11096(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_11097","instance":11097,"id":197768,"goal":"lemma SeqReverseIdem_11097(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_11098","instance":11098,"id":197769,"goal":"lemma SeqMapLen_11098(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_11099","instance":11099,"id":197770,"goal":"lemma SeqFilterLe_11099(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_11100","instance":11100,"id":197771,"goal":"lemma SeqMemberAppend_11100(zs: seq, xs: seq)\n ensures x in zs + xs <==> x in zs || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_11101","instance":11101,"id":197772,"goal":"lemma SeqAppendLen_11101(xs: seq, s: seq)\n ensures |xs + s| == |xs| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_11102","instance":11102,"id":197773,"goal":"lemma SeqAppendNil_11102(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_11103","instance":11103,"id":197774,"goal":"lemma SeqNilAppend_11103(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_11104","instance":11104,"id":197775,"goal":"lemma SeqAppendAssoc_11104(t: seq, s: seq, xs: seq)\n ensures (t + s) + xs == t + (s + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_11105","instance":11105,"id":197776,"goal":"lemma SeqTakeDrop_11105(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_11106","instance":11106,"id":197777,"goal":"lemma SeqReverseLen_11106(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_11107","instance":11107,"id":197778,"goal":"lemma SeqReverseIdem_11107(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_11108","instance":11108,"id":197779,"goal":"lemma SeqMapLen_11108(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_11109","instance":11109,"id":197780,"goal":"lemma SeqFilterLe_11109(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_11110","instance":11110,"id":197781,"goal":"lemma SeqMemberAppend_11110(ys: seq, zs: seq)\n ensures x in ys + zs <==> x in ys || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_11111","instance":11111,"id":197782,"goal":"lemma SeqAppendLen_11111(zs: seq, s: seq)\n ensures |zs + s| == |zs| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_11112","instance":11112,"id":197783,"goal":"lemma SeqAppendNil_11112(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_11113","instance":11113,"id":197784,"goal":"lemma SeqNilAppend_11113(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_11114","instance":11114,"id":197785,"goal":"lemma SeqAppendAssoc_11114(u: seq, t: seq, ys: seq)\n ensures (u + t) + ys == u + (t + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_11115","instance":11115,"id":197786,"goal":"lemma SeqTakeDrop_11115(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_11116","instance":11116,"id":197787,"goal":"lemma SeqReverseLen_11116(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_11117","instance":11117,"id":197788,"goal":"lemma SeqReverseIdem_11117(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_11118","instance":11118,"id":197789,"goal":"lemma SeqMapLen_11118(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_11119","instance":11119,"id":197790,"goal":"lemma SeqFilterLe_11119(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_11120","instance":11120,"id":197791,"goal":"lemma SeqMemberAppend_11120(zs: seq, s: seq)\n ensures x in zs + s <==> x in zs || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_11121","instance":11121,"id":197792,"goal":"lemma SeqAppendLen_11121(t: seq, u: seq)\n ensures |t + u| == |t| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_11122","instance":11122,"id":197793,"goal":"lemma SeqAppendNil_11122(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_11123","instance":11123,"id":197794,"goal":"lemma SeqNilAppend_11123(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_11124","instance":11124,"id":197795,"goal":"lemma SeqAppendAssoc_11124(xs: seq, zs: seq, s: seq)\n ensures (xs + zs) + s == xs + (zs + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_11125","instance":11125,"id":197796,"goal":"lemma SeqTakeDrop_11125(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_11126","instance":11126,"id":197797,"goal":"lemma SeqReverseLen_11126(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_11127","instance":11127,"id":197798,"goal":"lemma SeqReverseIdem_11127(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_11128","instance":11128,"id":197799,"goal":"lemma SeqMapLen_11128(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_11129","instance":11129,"id":197800,"goal":"lemma SeqFilterLe_11129(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_11130","instance":11130,"id":197801,"goal":"lemma SeqMemberAppend_11130(zs: seq, xs: seq)\n ensures x in zs + xs <==> x in zs || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_11131","instance":11131,"id":197802,"goal":"lemma SeqAppendLen_11131(s: seq, xs: seq)\n ensures |s + xs| == |s| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_11132","instance":11132,"id":197803,"goal":"lemma SeqAppendNil_11132(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_11133","instance":11133,"id":197804,"goal":"lemma SeqNilAppend_11133(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_11134","instance":11134,"id":197805,"goal":"lemma SeqAppendAssoc_11134(u: seq, zs: seq, ys: seq)\n ensures (u + zs) + ys == u + (zs + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_11135","instance":11135,"id":197806,"goal":"lemma SeqTakeDrop_11135(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_11136","instance":11136,"id":197807,"goal":"lemma SeqReverseLen_11136(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_11137","instance":11137,"id":197808,"goal":"lemma SeqReverseIdem_11137(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_11138","instance":11138,"id":197809,"goal":"lemma SeqMapLen_11138(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_11139","instance":11139,"id":197810,"goal":"lemma SeqFilterLe_11139(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_11140","instance":11140,"id":197811,"goal":"lemma SeqMemberAppend_11140(ys: seq, s: seq)\n ensures x in ys + s <==> x in ys || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_11141","instance":11141,"id":197812,"goal":"lemma SeqAppendLen_11141(t: seq, xs: seq)\n ensures |t + xs| == |t| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_11142","instance":11142,"id":197813,"goal":"lemma SeqAppendNil_11142(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_11143","instance":11143,"id":197814,"goal":"lemma SeqNilAppend_11143(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_11144","instance":11144,"id":197815,"goal":"lemma SeqAppendAssoc_11144(zs: seq, u: seq, ys: seq)\n ensures (zs + u) + ys == zs + (u + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_11145","instance":11145,"id":197816,"goal":"lemma SeqTakeDrop_11145(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_11146","instance":11146,"id":197817,"goal":"lemma SeqReverseLen_11146(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_11147","instance":11147,"id":197818,"goal":"lemma SeqReverseIdem_11147(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_11148","instance":11148,"id":197819,"goal":"lemma SeqMapLen_11148(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_11149","instance":11149,"id":197820,"goal":"lemma SeqFilterLe_11149(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_11150","instance":11150,"id":197821,"goal":"lemma SeqMemberAppend_11150(ys: seq, u: seq)\n ensures x in ys + u <==> x in ys || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_11151","instance":11151,"id":197822,"goal":"lemma SeqAppendLen_11151(zs: seq, u: seq)\n ensures |zs + u| == |zs| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_11152","instance":11152,"id":197823,"goal":"lemma SeqAppendNil_11152(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_11153","instance":11153,"id":197824,"goal":"lemma SeqNilAppend_11153(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_11154","instance":11154,"id":197825,"goal":"lemma SeqAppendAssoc_11154(t: seq, s: seq, zs: seq)\n ensures (t + s) + zs == t + (s + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_11155","instance":11155,"id":197826,"goal":"lemma SeqTakeDrop_11155(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_11156","instance":11156,"id":197827,"goal":"lemma SeqReverseLen_11156(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_11157","instance":11157,"id":197828,"goal":"lemma SeqReverseIdem_11157(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_11158","instance":11158,"id":197829,"goal":"lemma SeqMapLen_11158(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_11159","instance":11159,"id":197830,"goal":"lemma SeqFilterLe_11159(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_11160","instance":11160,"id":197831,"goal":"lemma SeqMemberAppend_11160(xs: seq, zs: seq)\n ensures x in xs + zs <==> x in xs || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_11161","instance":11161,"id":197832,"goal":"lemma SeqAppendLen_11161(zs: seq, xs: seq)\n ensures |zs + xs| == |zs| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_11162","instance":11162,"id":197833,"goal":"lemma SeqAppendNil_11162(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_11163","instance":11163,"id":197834,"goal":"lemma SeqNilAppend_11163(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_11164","instance":11164,"id":197835,"goal":"lemma SeqAppendAssoc_11164(zs: seq, u: seq, t: seq)\n ensures (zs + u) + t == zs + (u + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_11165","instance":11165,"id":197836,"goal":"lemma SeqTakeDrop_11165(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_11166","instance":11166,"id":197837,"goal":"lemma SeqReverseLen_11166(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_11167","instance":11167,"id":197838,"goal":"lemma SeqReverseIdem_11167(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_11168","instance":11168,"id":197839,"goal":"lemma SeqMapLen_11168(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_11169","instance":11169,"id":197840,"goal":"lemma SeqFilterLe_11169(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_11170","instance":11170,"id":197841,"goal":"lemma SeqMemberAppend_11170(t: seq, zs: seq)\n ensures x in t + zs <==> x in t || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_11171","instance":11171,"id":197842,"goal":"lemma SeqAppendLen_11171(u: seq, s: seq)\n ensures |u + s| == |u| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_11172","instance":11172,"id":197843,"goal":"lemma SeqAppendNil_11172(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_11173","instance":11173,"id":197844,"goal":"lemma SeqNilAppend_11173(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_11174","instance":11174,"id":197845,"goal":"lemma SeqAppendAssoc_11174(u: seq, xs: seq, ys: seq)\n ensures (u + xs) + ys == u + (xs + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_11175","instance":11175,"id":197846,"goal":"lemma SeqTakeDrop_11175(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_11176","instance":11176,"id":197847,"goal":"lemma SeqReverseLen_11176(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_11177","instance":11177,"id":197848,"goal":"lemma SeqReverseIdem_11177(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_11178","instance":11178,"id":197849,"goal":"lemma SeqMapLen_11178(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_11179","instance":11179,"id":197850,"goal":"lemma SeqFilterLe_11179(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_11180","instance":11180,"id":197851,"goal":"lemma SeqMemberAppend_11180(xs: seq, s: seq)\n ensures x in xs + s <==> x in xs || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_11181","instance":11181,"id":197852,"goal":"lemma SeqAppendLen_11181(t: seq, s: seq)\n ensures |t + s| == |t| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_11182","instance":11182,"id":197853,"goal":"lemma SeqAppendNil_11182(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_11183","instance":11183,"id":197854,"goal":"lemma SeqNilAppend_11183(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_11184","instance":11184,"id":197855,"goal":"lemma SeqAppendAssoc_11184(xs: seq, s: seq, t: seq)\n ensures (xs + s) + t == xs + (s + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_11185","instance":11185,"id":197856,"goal":"lemma SeqTakeDrop_11185(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_11186","instance":11186,"id":197857,"goal":"lemma SeqReverseLen_11186(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_11187","instance":11187,"id":197858,"goal":"lemma SeqReverseIdem_11187(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_11188","instance":11188,"id":197859,"goal":"lemma SeqMapLen_11188(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_11189","instance":11189,"id":197860,"goal":"lemma SeqFilterLe_11189(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_11190","instance":11190,"id":197861,"goal":"lemma SeqMemberAppend_11190(zs: seq, u: seq)\n ensures x in zs + u <==> x in zs || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_11191","instance":11191,"id":197862,"goal":"lemma SeqAppendLen_11191(u: seq, zs: seq)\n ensures |u + zs| == |u| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_11192","instance":11192,"id":197863,"goal":"lemma SeqAppendNil_11192(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_11193","instance":11193,"id":197864,"goal":"lemma SeqNilAppend_11193(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_11194","instance":11194,"id":197865,"goal":"lemma SeqAppendAssoc_11194(xs: seq, u: seq, t: seq)\n ensures (xs + u) + t == xs + (u + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_11195","instance":11195,"id":197866,"goal":"lemma SeqTakeDrop_11195(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_11196","instance":11196,"id":197867,"goal":"lemma SeqReverseLen_11196(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_11197","instance":11197,"id":197868,"goal":"lemma SeqReverseIdem_11197(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_11198","instance":11198,"id":197869,"goal":"lemma SeqMapLen_11198(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_11199","instance":11199,"id":197870,"goal":"lemma SeqFilterLe_11199(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_11200","instance":11200,"id":197871,"goal":"lemma SeqMemberAppend_11200(u: seq, t: seq)\n ensures x in u + t <==> x in u || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_11201","instance":11201,"id":197872,"goal":"lemma SeqAppendLen_11201(u: seq, s: seq)\n ensures |u + s| == |u| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_11202","instance":11202,"id":197873,"goal":"lemma SeqAppendNil_11202(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_11203","instance":11203,"id":197874,"goal":"lemma SeqNilAppend_11203(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_11204","instance":11204,"id":197875,"goal":"lemma SeqAppendAssoc_11204(zs: seq, s: seq, ys: seq)\n ensures (zs + s) + ys == zs + (s + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_11205","instance":11205,"id":197876,"goal":"lemma SeqTakeDrop_11205(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_11206","instance":11206,"id":197877,"goal":"lemma SeqReverseLen_11206(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_11207","instance":11207,"id":197878,"goal":"lemma SeqReverseIdem_11207(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_11208","instance":11208,"id":197879,"goal":"lemma SeqMapLen_11208(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_11209","instance":11209,"id":197880,"goal":"lemma SeqFilterLe_11209(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_11210","instance":11210,"id":197881,"goal":"lemma SeqMemberAppend_11210(u: seq, s: seq)\n ensures x in u + s <==> x in u || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_11211","instance":11211,"id":197882,"goal":"lemma SeqAppendLen_11211(ys: seq, zs: seq)\n ensures |ys + zs| == |ys| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_11212","instance":11212,"id":197883,"goal":"lemma SeqAppendNil_11212(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_11213","instance":11213,"id":197884,"goal":"lemma SeqNilAppend_11213(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_11214","instance":11214,"id":197885,"goal":"lemma SeqAppendAssoc_11214(s: seq, u: seq, ys: seq)\n ensures (s + u) + ys == s + (u + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_11215","instance":11215,"id":197886,"goal":"lemma SeqTakeDrop_11215(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_11216","instance":11216,"id":197887,"goal":"lemma SeqReverseLen_11216(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_11217","instance":11217,"id":197888,"goal":"lemma SeqReverseIdem_11217(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_11218","instance":11218,"id":197889,"goal":"lemma SeqMapLen_11218(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_11219","instance":11219,"id":197890,"goal":"lemma SeqFilterLe_11219(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_11220","instance":11220,"id":197891,"goal":"lemma SeqMemberAppend_11220(zs: seq, t: seq)\n ensures x in zs + t <==> x in zs || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_11221","instance":11221,"id":197892,"goal":"lemma SeqAppendLen_11221(u: seq, ys: seq)\n ensures |u + ys| == |u| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_11222","instance":11222,"id":197893,"goal":"lemma SeqAppendNil_11222(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_11223","instance":11223,"id":197894,"goal":"lemma SeqNilAppend_11223(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_11224","instance":11224,"id":197895,"goal":"lemma SeqAppendAssoc_11224(zs: seq, xs: seq, s: seq)\n ensures (zs + xs) + s == zs + (xs + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_11225","instance":11225,"id":197896,"goal":"lemma SeqTakeDrop_11225(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_11226","instance":11226,"id":197897,"goal":"lemma SeqReverseLen_11226(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_11227","instance":11227,"id":197898,"goal":"lemma SeqReverseIdem_11227(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_11228","instance":11228,"id":197899,"goal":"lemma SeqMapLen_11228(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_11229","instance":11229,"id":197900,"goal":"lemma SeqFilterLe_11229(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_11230","instance":11230,"id":197901,"goal":"lemma SeqMemberAppend_11230(s: seq, ys: seq)\n ensures x in s + ys <==> x in s || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_11231","instance":11231,"id":197902,"goal":"lemma SeqAppendLen_11231(zs: seq, t: seq)\n ensures |zs + t| == |zs| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_11232","instance":11232,"id":197903,"goal":"lemma SeqAppendNil_11232(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_11233","instance":11233,"id":197904,"goal":"lemma SeqNilAppend_11233(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_11234","instance":11234,"id":197905,"goal":"lemma SeqAppendAssoc_11234(t: seq, u: seq, s: seq)\n ensures (t + u) + s == t + (u + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_11235","instance":11235,"id":197906,"goal":"lemma SeqTakeDrop_11235(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_11236","instance":11236,"id":197907,"goal":"lemma SeqReverseLen_11236(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_11237","instance":11237,"id":197908,"goal":"lemma SeqReverseIdem_11237(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_11238","instance":11238,"id":197909,"goal":"lemma SeqMapLen_11238(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_11239","instance":11239,"id":197910,"goal":"lemma SeqFilterLe_11239(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_11240","instance":11240,"id":197911,"goal":"lemma SeqMemberAppend_11240(u: seq, t: seq)\n ensures x in u + t <==> x in u || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_11241","instance":11241,"id":197912,"goal":"lemma SeqAppendLen_11241(zs: seq, s: seq)\n ensures |zs + s| == |zs| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_11242","instance":11242,"id":197913,"goal":"lemma SeqAppendNil_11242(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_11243","instance":11243,"id":197914,"goal":"lemma SeqNilAppend_11243(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_11244","instance":11244,"id":197915,"goal":"lemma SeqAppendAssoc_11244(s: seq, xs: seq, zs: seq)\n ensures (s + xs) + zs == s + (xs + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_11245","instance":11245,"id":197916,"goal":"lemma SeqTakeDrop_11245(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_11246","instance":11246,"id":197917,"goal":"lemma SeqReverseLen_11246(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_11247","instance":11247,"id":197918,"goal":"lemma SeqReverseIdem_11247(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_11248","instance":11248,"id":197919,"goal":"lemma SeqMapLen_11248(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_11249","instance":11249,"id":197920,"goal":"lemma SeqFilterLe_11249(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_11250","instance":11250,"id":197921,"goal":"lemma SeqMemberAppend_11250(s: seq, xs: seq)\n ensures x in s + xs <==> x in s || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_11251","instance":11251,"id":197922,"goal":"lemma SeqAppendLen_11251(t: seq, zs: seq)\n ensures |t + zs| == |t| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_11252","instance":11252,"id":197923,"goal":"lemma SeqAppendNil_11252(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_11253","instance":11253,"id":197924,"goal":"lemma SeqNilAppend_11253(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_11254","instance":11254,"id":197925,"goal":"lemma SeqAppendAssoc_11254(u: seq, zs: seq, xs: seq)\n ensures (u + zs) + xs == u + (zs + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_11255","instance":11255,"id":197926,"goal":"lemma SeqTakeDrop_11255(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_11256","instance":11256,"id":197927,"goal":"lemma SeqReverseLen_11256(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_11257","instance":11257,"id":197928,"goal":"lemma SeqReverseIdem_11257(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_11258","instance":11258,"id":197929,"goal":"lemma SeqMapLen_11258(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_11259","instance":11259,"id":197930,"goal":"lemma SeqFilterLe_11259(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_11260","instance":11260,"id":197931,"goal":"lemma SeqMemberAppend_11260(t: seq, s: seq)\n ensures x in t + s <==> x in t || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_11261","instance":11261,"id":197932,"goal":"lemma SeqAppendLen_11261(u: seq, ys: seq)\n ensures |u + ys| == |u| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_11262","instance":11262,"id":197933,"goal":"lemma SeqAppendNil_11262(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_11263","instance":11263,"id":197934,"goal":"lemma SeqNilAppend_11263(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_11264","instance":11264,"id":197935,"goal":"lemma SeqAppendAssoc_11264(t: seq, ys: seq, zs: seq)\n ensures (t + ys) + zs == t + (ys + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_11265","instance":11265,"id":197936,"goal":"lemma SeqTakeDrop_11265(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_11266","instance":11266,"id":197937,"goal":"lemma SeqReverseLen_11266(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_11267","instance":11267,"id":197938,"goal":"lemma SeqReverseIdem_11267(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_11268","instance":11268,"id":197939,"goal":"lemma SeqMapLen_11268(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_11269","instance":11269,"id":197940,"goal":"lemma SeqFilterLe_11269(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_11270","instance":11270,"id":197941,"goal":"lemma SeqMemberAppend_11270(s: seq, u: seq)\n ensures x in s + u <==> x in s || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_11271","instance":11271,"id":197942,"goal":"lemma SeqAppendLen_11271(s: seq, u: seq)\n ensures |s + u| == |s| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_11272","instance":11272,"id":197943,"goal":"lemma SeqAppendNil_11272(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_11273","instance":11273,"id":197944,"goal":"lemma SeqNilAppend_11273(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_11274","instance":11274,"id":197945,"goal":"lemma SeqAppendAssoc_11274(s: seq, ys: seq, xs: seq)\n ensures (s + ys) + xs == s + (ys + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_11275","instance":11275,"id":197946,"goal":"lemma SeqTakeDrop_11275(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_11276","instance":11276,"id":197947,"goal":"lemma SeqReverseLen_11276(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_11277","instance":11277,"id":197948,"goal":"lemma SeqReverseIdem_11277(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_11278","instance":11278,"id":197949,"goal":"lemma SeqMapLen_11278(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_11279","instance":11279,"id":197950,"goal":"lemma SeqFilterLe_11279(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_11280","instance":11280,"id":197951,"goal":"lemma SeqMemberAppend_11280(t: seq, zs: seq)\n ensures x in t + zs <==> x in t || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_11281","instance":11281,"id":197952,"goal":"lemma SeqAppendLen_11281(u: seq, ys: seq)\n ensures |u + ys| == |u| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_11282","instance":11282,"id":197953,"goal":"lemma SeqAppendNil_11282(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_11283","instance":11283,"id":197954,"goal":"lemma SeqNilAppend_11283(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_11284","instance":11284,"id":197955,"goal":"lemma SeqAppendAssoc_11284(ys: seq, xs: seq, t: seq)\n ensures (ys + xs) + t == ys + (xs + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_11285","instance":11285,"id":197956,"goal":"lemma SeqTakeDrop_11285(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_11286","instance":11286,"id":197957,"goal":"lemma SeqReverseLen_11286(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_11287","instance":11287,"id":197958,"goal":"lemma SeqReverseIdem_11287(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_11288","instance":11288,"id":197959,"goal":"lemma SeqMapLen_11288(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_11289","instance":11289,"id":197960,"goal":"lemma SeqFilterLe_11289(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_11290","instance":11290,"id":197961,"goal":"lemma SeqMemberAppend_11290(t: seq, zs: seq)\n ensures x in t + zs <==> x in t || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_11291","instance":11291,"id":197962,"goal":"lemma SeqAppendLen_11291(zs: seq, t: seq)\n ensures |zs + t| == |zs| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_11292","instance":11292,"id":197963,"goal":"lemma SeqAppendNil_11292(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_11293","instance":11293,"id":197964,"goal":"lemma SeqNilAppend_11293(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_11294","instance":11294,"id":197965,"goal":"lemma SeqAppendAssoc_11294(u: seq, xs: seq, s: seq)\n ensures (u + xs) + s == u + (xs + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_11295","instance":11295,"id":197966,"goal":"lemma SeqTakeDrop_11295(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_11296","instance":11296,"id":197967,"goal":"lemma SeqReverseLen_11296(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_11297","instance":11297,"id":197968,"goal":"lemma SeqReverseIdem_11297(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_11298","instance":11298,"id":197969,"goal":"lemma SeqMapLen_11298(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_11299","instance":11299,"id":197970,"goal":"lemma SeqFilterLe_11299(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_11300","instance":11300,"id":197971,"goal":"lemma SeqMemberAppend_11300(s: seq, ys: seq)\n ensures x in s + ys <==> x in s || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_11301","instance":11301,"id":197972,"goal":"lemma SeqAppendLen_11301(zs: seq, xs: seq)\n ensures |zs + xs| == |zs| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_11302","instance":11302,"id":197973,"goal":"lemma SeqAppendNil_11302(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_11303","instance":11303,"id":197974,"goal":"lemma SeqNilAppend_11303(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_11304","instance":11304,"id":197975,"goal":"lemma SeqAppendAssoc_11304(u: seq, zs: seq, xs: seq)\n ensures (u + zs) + xs == u + (zs + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_11305","instance":11305,"id":197976,"goal":"lemma SeqTakeDrop_11305(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_11306","instance":11306,"id":197977,"goal":"lemma SeqReverseLen_11306(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_11307","instance":11307,"id":197978,"goal":"lemma SeqReverseIdem_11307(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_11308","instance":11308,"id":197979,"goal":"lemma SeqMapLen_11308(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_11309","instance":11309,"id":197980,"goal":"lemma SeqFilterLe_11309(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_11310","instance":11310,"id":197981,"goal":"lemma SeqMemberAppend_11310(s: seq, u: seq)\n ensures x in s + u <==> x in s || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_11311","instance":11311,"id":197982,"goal":"lemma SeqAppendLen_11311(t: seq, u: seq)\n ensures |t + u| == |t| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_11312","instance":11312,"id":197983,"goal":"lemma SeqAppendNil_11312(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_11313","instance":11313,"id":197984,"goal":"lemma SeqNilAppend_11313(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_11314","instance":11314,"id":197985,"goal":"lemma SeqAppendAssoc_11314(xs: seq, s: seq, t: seq)\n ensures (xs + s) + t == xs + (s + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_11315","instance":11315,"id":197986,"goal":"lemma SeqTakeDrop_11315(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_11316","instance":11316,"id":197987,"goal":"lemma SeqReverseLen_11316(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_11317","instance":11317,"id":197988,"goal":"lemma SeqReverseIdem_11317(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_11318","instance":11318,"id":197989,"goal":"lemma SeqMapLen_11318(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_11319","instance":11319,"id":197990,"goal":"lemma SeqFilterLe_11319(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_11320","instance":11320,"id":197991,"goal":"lemma SeqMemberAppend_11320(u: seq, t: seq)\n ensures x in u + t <==> x in u || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_11321","instance":11321,"id":197992,"goal":"lemma SeqAppendLen_11321(xs: seq, zs: seq)\n ensures |xs + zs| == |xs| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_11322","instance":11322,"id":197993,"goal":"lemma SeqAppendNil_11322(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_11323","instance":11323,"id":197994,"goal":"lemma SeqNilAppend_11323(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_11324","instance":11324,"id":197995,"goal":"lemma SeqAppendAssoc_11324(zs: seq, t: seq, xs: seq)\n ensures (zs + t) + xs == zs + (t + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_11325","instance":11325,"id":197996,"goal":"lemma SeqTakeDrop_11325(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_11326","instance":11326,"id":197997,"goal":"lemma SeqReverseLen_11326(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_11327","instance":11327,"id":197998,"goal":"lemma SeqReverseIdem_11327(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_11328","instance":11328,"id":197999,"goal":"lemma SeqMapLen_11328(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_11329","instance":11329,"id":198000,"goal":"lemma SeqFilterLe_11329(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_11330","instance":11330,"id":198001,"goal":"lemma SeqMemberAppend_11330(zs: seq, t: seq)\n ensures x in zs + t <==> x in zs || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_11331","instance":11331,"id":198002,"goal":"lemma SeqAppendLen_11331(zs: seq, s: seq)\n ensures |zs + s| == |zs| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_11332","instance":11332,"id":198003,"goal":"lemma SeqAppendNil_11332(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_11333","instance":11333,"id":198004,"goal":"lemma SeqNilAppend_11333(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_11334","instance":11334,"id":198005,"goal":"lemma SeqAppendAssoc_11334(ys: seq, t: seq, xs: seq)\n ensures (ys + t) + xs == ys + (t + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_11335","instance":11335,"id":198006,"goal":"lemma SeqTakeDrop_11335(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_11336","instance":11336,"id":198007,"goal":"lemma SeqReverseLen_11336(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_11337","instance":11337,"id":198008,"goal":"lemma SeqReverseIdem_11337(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_11338","instance":11338,"id":198009,"goal":"lemma SeqMapLen_11338(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_11339","instance":11339,"id":198010,"goal":"lemma SeqFilterLe_11339(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_11340","instance":11340,"id":198011,"goal":"lemma SeqMemberAppend_11340(t: seq, zs: seq)\n ensures x in t + zs <==> x in t || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_11341","instance":11341,"id":198012,"goal":"lemma SeqAppendLen_11341(ys: seq, zs: seq)\n ensures |ys + zs| == |ys| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_11342","instance":11342,"id":198013,"goal":"lemma SeqAppendNil_11342(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_11343","instance":11343,"id":198014,"goal":"lemma SeqNilAppend_11343(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_11344","instance":11344,"id":198015,"goal":"lemma SeqAppendAssoc_11344(zs: seq, t: seq, xs: seq)\n ensures (zs + t) + xs == zs + (t + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_11345","instance":11345,"id":198016,"goal":"lemma SeqTakeDrop_11345(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_11346","instance":11346,"id":198017,"goal":"lemma SeqReverseLen_11346(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_11347","instance":11347,"id":198018,"goal":"lemma SeqReverseIdem_11347(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_11348","instance":11348,"id":198019,"goal":"lemma SeqMapLen_11348(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_11349","instance":11349,"id":198020,"goal":"lemma SeqFilterLe_11349(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_11350","instance":11350,"id":198021,"goal":"lemma SeqMemberAppend_11350(xs: seq, ys: seq)\n ensures x in xs + ys <==> x in xs || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_11351","instance":11351,"id":198022,"goal":"lemma SeqAppendLen_11351(t: seq, u: seq)\n ensures |t + u| == |t| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_11352","instance":11352,"id":198023,"goal":"lemma SeqAppendNil_11352(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_11353","instance":11353,"id":198024,"goal":"lemma SeqNilAppend_11353(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_11354","instance":11354,"id":198025,"goal":"lemma SeqAppendAssoc_11354(ys: seq, xs: seq, u: seq)\n ensures (ys + xs) + u == ys + (xs + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_11355","instance":11355,"id":198026,"goal":"lemma SeqTakeDrop_11355(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_11356","instance":11356,"id":198027,"goal":"lemma SeqReverseLen_11356(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_11357","instance":11357,"id":198028,"goal":"lemma SeqReverseIdem_11357(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_11358","instance":11358,"id":198029,"goal":"lemma SeqMapLen_11358(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_11359","instance":11359,"id":198030,"goal":"lemma SeqFilterLe_11359(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_11360","instance":11360,"id":198031,"goal":"lemma SeqMemberAppend_11360(ys: seq, u: seq)\n ensures x in ys + u <==> x in ys || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_11361","instance":11361,"id":198032,"goal":"lemma SeqAppendLen_11361(t: seq, ys: seq)\n ensures |t + ys| == |t| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_11362","instance":11362,"id":198033,"goal":"lemma SeqAppendNil_11362(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_11363","instance":11363,"id":198034,"goal":"lemma SeqNilAppend_11363(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_11364","instance":11364,"id":198035,"goal":"lemma SeqAppendAssoc_11364(t: seq, zs: seq, u: seq)\n ensures (t + zs) + u == t + (zs + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_11365","instance":11365,"id":198036,"goal":"lemma SeqTakeDrop_11365(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_11366","instance":11366,"id":198037,"goal":"lemma SeqReverseLen_11366(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_11367","instance":11367,"id":198038,"goal":"lemma SeqReverseIdem_11367(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_11368","instance":11368,"id":198039,"goal":"lemma SeqMapLen_11368(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_11369","instance":11369,"id":198040,"goal":"lemma SeqFilterLe_11369(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_11370","instance":11370,"id":198041,"goal":"lemma SeqMemberAppend_11370(u: seq, xs: seq)\n ensures x in u + xs <==> x in u || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_11371","instance":11371,"id":198042,"goal":"lemma SeqAppendLen_11371(xs: seq, t: seq)\n ensures |xs + t| == |xs| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_11372","instance":11372,"id":198043,"goal":"lemma SeqAppendNil_11372(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_11373","instance":11373,"id":198044,"goal":"lemma SeqNilAppend_11373(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_11374","instance":11374,"id":198045,"goal":"lemma SeqAppendAssoc_11374(ys: seq, xs: seq, u: seq)\n ensures (ys + xs) + u == ys + (xs + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_11375","instance":11375,"id":198046,"goal":"lemma SeqTakeDrop_11375(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_11376","instance":11376,"id":198047,"goal":"lemma SeqReverseLen_11376(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_11377","instance":11377,"id":198048,"goal":"lemma SeqReverseIdem_11377(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_11378","instance":11378,"id":198049,"goal":"lemma SeqMapLen_11378(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_11379","instance":11379,"id":198050,"goal":"lemma SeqFilterLe_11379(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_11380","instance":11380,"id":198051,"goal":"lemma SeqMemberAppend_11380(ys: seq, t: seq)\n ensures x in ys + t <==> x in ys || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_11381","instance":11381,"id":198052,"goal":"lemma SeqAppendLen_11381(ys: seq, t: seq)\n ensures |ys + t| == |ys| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_11382","instance":11382,"id":198053,"goal":"lemma SeqAppendNil_11382(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_11383","instance":11383,"id":198054,"goal":"lemma SeqNilAppend_11383(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_11384","instance":11384,"id":198055,"goal":"lemma SeqAppendAssoc_11384(xs: seq, s: seq, t: seq)\n ensures (xs + s) + t == xs + (s + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_11385","instance":11385,"id":198056,"goal":"lemma SeqTakeDrop_11385(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_11386","instance":11386,"id":198057,"goal":"lemma SeqReverseLen_11386(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_11387","instance":11387,"id":198058,"goal":"lemma SeqReverseIdem_11387(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_11388","instance":11388,"id":198059,"goal":"lemma SeqMapLen_11388(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_11389","instance":11389,"id":198060,"goal":"lemma SeqFilterLe_11389(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_11390","instance":11390,"id":198061,"goal":"lemma SeqMemberAppend_11390(ys: seq, u: seq)\n ensures x in ys + u <==> x in ys || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_11391","instance":11391,"id":198062,"goal":"lemma SeqAppendLen_11391(zs: seq, s: seq)\n ensures |zs + s| == |zs| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_11392","instance":11392,"id":198063,"goal":"lemma SeqAppendNil_11392(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_11393","instance":11393,"id":198064,"goal":"lemma SeqNilAppend_11393(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_11394","instance":11394,"id":198065,"goal":"lemma SeqAppendAssoc_11394(s: seq, xs: seq, zs: seq)\n ensures (s + xs) + zs == s + (xs + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_11395","instance":11395,"id":198066,"goal":"lemma SeqTakeDrop_11395(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_11396","instance":11396,"id":198067,"goal":"lemma SeqReverseLen_11396(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_11397","instance":11397,"id":198068,"goal":"lemma SeqReverseIdem_11397(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_11398","instance":11398,"id":198069,"goal":"lemma SeqMapLen_11398(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_11399","instance":11399,"id":198070,"goal":"lemma SeqFilterLe_11399(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_11400","instance":11400,"id":198071,"goal":"lemma SeqMemberAppend_11400(t: seq, ys: seq)\n ensures x in t + ys <==> x in t || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_11401","instance":11401,"id":198072,"goal":"lemma SeqAppendLen_11401(ys: seq, s: seq)\n ensures |ys + s| == |ys| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_11402","instance":11402,"id":198073,"goal":"lemma SeqAppendNil_11402(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_11403","instance":11403,"id":198074,"goal":"lemma SeqNilAppend_11403(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_11404","instance":11404,"id":198075,"goal":"lemma SeqAppendAssoc_11404(zs: seq, t: seq, u: seq)\n ensures (zs + t) + u == zs + (t + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_11405","instance":11405,"id":198076,"goal":"lemma SeqTakeDrop_11405(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_11406","instance":11406,"id":198077,"goal":"lemma SeqReverseLen_11406(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_11407","instance":11407,"id":198078,"goal":"lemma SeqReverseIdem_11407(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_11408","instance":11408,"id":198079,"goal":"lemma SeqMapLen_11408(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_11409","instance":11409,"id":198080,"goal":"lemma SeqFilterLe_11409(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_11410","instance":11410,"id":198081,"goal":"lemma SeqMemberAppend_11410(t: seq, ys: seq)\n ensures x in t + ys <==> x in t || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_11411","instance":11411,"id":198082,"goal":"lemma SeqAppendLen_11411(zs: seq, s: seq)\n ensures |zs + s| == |zs| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_11412","instance":11412,"id":198083,"goal":"lemma SeqAppendNil_11412(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_11413","instance":11413,"id":198084,"goal":"lemma SeqNilAppend_11413(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_11414","instance":11414,"id":198085,"goal":"lemma SeqAppendAssoc_11414(s: seq, zs: seq, ys: seq)\n ensures (s + zs) + ys == s + (zs + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_11415","instance":11415,"id":198086,"goal":"lemma SeqTakeDrop_11415(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_11416","instance":11416,"id":198087,"goal":"lemma SeqReverseLen_11416(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_11417","instance":11417,"id":198088,"goal":"lemma SeqReverseIdem_11417(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_11418","instance":11418,"id":198089,"goal":"lemma SeqMapLen_11418(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_11419","instance":11419,"id":198090,"goal":"lemma SeqFilterLe_11419(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_11420","instance":11420,"id":198091,"goal":"lemma SeqMemberAppend_11420(u: seq, s: seq)\n ensures x in u + s <==> x in u || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_11421","instance":11421,"id":198092,"goal":"lemma SeqAppendLen_11421(xs: seq, ys: seq)\n ensures |xs + ys| == |xs| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_11422","instance":11422,"id":198093,"goal":"lemma SeqAppendNil_11422(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_11423","instance":11423,"id":198094,"goal":"lemma SeqNilAppend_11423(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_11424","instance":11424,"id":198095,"goal":"lemma SeqAppendAssoc_11424(t: seq, ys: seq, xs: seq)\n ensures (t + ys) + xs == t + (ys + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_11425","instance":11425,"id":198096,"goal":"lemma SeqTakeDrop_11425(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_11426","instance":11426,"id":198097,"goal":"lemma SeqReverseLen_11426(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_11427","instance":11427,"id":198098,"goal":"lemma SeqReverseIdem_11427(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_11428","instance":11428,"id":198099,"goal":"lemma SeqMapLen_11428(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_11429","instance":11429,"id":198100,"goal":"lemma SeqFilterLe_11429(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_11430","instance":11430,"id":198101,"goal":"lemma SeqMemberAppend_11430(zs: seq, t: seq)\n ensures x in zs + t <==> x in zs || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_11431","instance":11431,"id":198102,"goal":"lemma SeqAppendLen_11431(s: seq, ys: seq)\n ensures |s + ys| == |s| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_11432","instance":11432,"id":198103,"goal":"lemma SeqAppendNil_11432(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_11433","instance":11433,"id":198104,"goal":"lemma SeqNilAppend_11433(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_11434","instance":11434,"id":198105,"goal":"lemma SeqAppendAssoc_11434(s: seq, xs: seq, zs: seq)\n ensures (s + xs) + zs == s + (xs + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_11435","instance":11435,"id":198106,"goal":"lemma SeqTakeDrop_11435(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_11436","instance":11436,"id":198107,"goal":"lemma SeqReverseLen_11436(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_11437","instance":11437,"id":198108,"goal":"lemma SeqReverseIdem_11437(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_11438","instance":11438,"id":198109,"goal":"lemma SeqMapLen_11438(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_11439","instance":11439,"id":198110,"goal":"lemma SeqFilterLe_11439(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_11440","instance":11440,"id":198111,"goal":"lemma SeqMemberAppend_11440(ys: seq, s: seq)\n ensures x in ys + s <==> x in ys || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_11441","instance":11441,"id":198112,"goal":"lemma SeqAppendLen_11441(t: seq, zs: seq)\n ensures |t + zs| == |t| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_11442","instance":11442,"id":198113,"goal":"lemma SeqAppendNil_11442(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_11443","instance":11443,"id":198114,"goal":"lemma SeqNilAppend_11443(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_11444","instance":11444,"id":198115,"goal":"lemma SeqAppendAssoc_11444(s: seq, u: seq, zs: seq)\n ensures (s + u) + zs == s + (u + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_11445","instance":11445,"id":198116,"goal":"lemma SeqTakeDrop_11445(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_11446","instance":11446,"id":198117,"goal":"lemma SeqReverseLen_11446(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_11447","instance":11447,"id":198118,"goal":"lemma SeqReverseIdem_11447(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_11448","instance":11448,"id":198119,"goal":"lemma SeqMapLen_11448(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_11449","instance":11449,"id":198120,"goal":"lemma SeqFilterLe_11449(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_11450","instance":11450,"id":198121,"goal":"lemma SeqMemberAppend_11450(u: seq, zs: seq)\n ensures x in u + zs <==> x in u || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_11451","instance":11451,"id":198122,"goal":"lemma SeqAppendLen_11451(xs: seq, t: seq)\n ensures |xs + t| == |xs| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_11452","instance":11452,"id":198123,"goal":"lemma SeqAppendNil_11452(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_11453","instance":11453,"id":198124,"goal":"lemma SeqNilAppend_11453(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_11454","instance":11454,"id":198125,"goal":"lemma SeqAppendAssoc_11454(u: seq, zs: seq, xs: seq)\n ensures (u + zs) + xs == u + (zs + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_11455","instance":11455,"id":198126,"goal":"lemma SeqTakeDrop_11455(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_11456","instance":11456,"id":198127,"goal":"lemma SeqReverseLen_11456(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_11457","instance":11457,"id":198128,"goal":"lemma SeqReverseIdem_11457(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_11458","instance":11458,"id":198129,"goal":"lemma SeqMapLen_11458(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_11459","instance":11459,"id":198130,"goal":"lemma SeqFilterLe_11459(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_11460","instance":11460,"id":198131,"goal":"lemma SeqMemberAppend_11460(zs: seq, t: seq)\n ensures x in zs + t <==> x in zs || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_11461","instance":11461,"id":198132,"goal":"lemma SeqAppendLen_11461(zs: seq, s: seq)\n ensures |zs + s| == |zs| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_11462","instance":11462,"id":198133,"goal":"lemma SeqAppendNil_11462(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_11463","instance":11463,"id":198134,"goal":"lemma SeqNilAppend_11463(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_11464","instance":11464,"id":198135,"goal":"lemma SeqAppendAssoc_11464(s: seq, ys: seq, xs: seq)\n ensures (s + ys) + xs == s + (ys + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_11465","instance":11465,"id":198136,"goal":"lemma SeqTakeDrop_11465(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_11466","instance":11466,"id":198137,"goal":"lemma SeqReverseLen_11466(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_11467","instance":11467,"id":198138,"goal":"lemma SeqReverseIdem_11467(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_11468","instance":11468,"id":198139,"goal":"lemma SeqMapLen_11468(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_11469","instance":11469,"id":198140,"goal":"lemma SeqFilterLe_11469(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_11470","instance":11470,"id":198141,"goal":"lemma SeqMemberAppend_11470(s: seq, zs: seq)\n ensures x in s + zs <==> x in s || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_11471","instance":11471,"id":198142,"goal":"lemma SeqAppendLen_11471(ys: seq, t: seq)\n ensures |ys + t| == |ys| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_11472","instance":11472,"id":198143,"goal":"lemma SeqAppendNil_11472(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_11473","instance":11473,"id":198144,"goal":"lemma SeqNilAppend_11473(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_11474","instance":11474,"id":198145,"goal":"lemma SeqAppendAssoc_11474(xs: seq, ys: seq, zs: seq)\n ensures (xs + ys) + zs == xs + (ys + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_11475","instance":11475,"id":198146,"goal":"lemma SeqTakeDrop_11475(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_11476","instance":11476,"id":198147,"goal":"lemma SeqReverseLen_11476(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_11477","instance":11477,"id":198148,"goal":"lemma SeqReverseIdem_11477(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_11478","instance":11478,"id":198149,"goal":"lemma SeqMapLen_11478(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_11479","instance":11479,"id":198150,"goal":"lemma SeqFilterLe_11479(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_11480","instance":11480,"id":198151,"goal":"lemma SeqMemberAppend_11480(xs: seq, t: seq)\n ensures x in xs + t <==> x in xs || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_11481","instance":11481,"id":198152,"goal":"lemma SeqAppendLen_11481(u: seq, xs: seq)\n ensures |u + xs| == |u| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_11482","instance":11482,"id":198153,"goal":"lemma SeqAppendNil_11482(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_11483","instance":11483,"id":198154,"goal":"lemma SeqNilAppend_11483(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_11484","instance":11484,"id":198155,"goal":"lemma SeqAppendAssoc_11484(t: seq, xs: seq, s: seq)\n ensures (t + xs) + s == t + (xs + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_11485","instance":11485,"id":198156,"goal":"lemma SeqTakeDrop_11485(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_11486","instance":11486,"id":198157,"goal":"lemma SeqReverseLen_11486(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_11487","instance":11487,"id":198158,"goal":"lemma SeqReverseIdem_11487(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_11488","instance":11488,"id":198159,"goal":"lemma SeqMapLen_11488(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_11489","instance":11489,"id":198160,"goal":"lemma SeqFilterLe_11489(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_11490","instance":11490,"id":198161,"goal":"lemma SeqMemberAppend_11490(u: seq, ys: seq)\n ensures x in u + ys <==> x in u || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_11491","instance":11491,"id":198162,"goal":"lemma SeqAppendLen_11491(t: seq, zs: seq)\n ensures |t + zs| == |t| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_11492","instance":11492,"id":198163,"goal":"lemma SeqAppendNil_11492(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_11493","instance":11493,"id":198164,"goal":"lemma SeqNilAppend_11493(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_11494","instance":11494,"id":198165,"goal":"lemma SeqAppendAssoc_11494(u: seq, xs: seq, zs: seq)\n ensures (u + xs) + zs == u + (xs + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_11495","instance":11495,"id":198166,"goal":"lemma SeqTakeDrop_11495(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_11496","instance":11496,"id":198167,"goal":"lemma SeqReverseLen_11496(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_11497","instance":11497,"id":198168,"goal":"lemma SeqReverseIdem_11497(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_11498","instance":11498,"id":198169,"goal":"lemma SeqMapLen_11498(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_11499","instance":11499,"id":198170,"goal":"lemma SeqFilterLe_11499(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_11500","instance":11500,"id":198171,"goal":"lemma SeqMemberAppend_11500(t: seq, zs: seq)\n ensures x in t + zs <==> x in t || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_11501","instance":11501,"id":198172,"goal":"lemma SeqAppendLen_11501(t: seq, u: seq)\n ensures |t + u| == |t| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_11502","instance":11502,"id":198173,"goal":"lemma SeqAppendNil_11502(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_11503","instance":11503,"id":198174,"goal":"lemma SeqNilAppend_11503(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_11504","instance":11504,"id":198175,"goal":"lemma SeqAppendAssoc_11504(u: seq, t: seq, zs: seq)\n ensures (u + t) + zs == u + (t + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_11505","instance":11505,"id":198176,"goal":"lemma SeqTakeDrop_11505(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_11506","instance":11506,"id":198177,"goal":"lemma SeqReverseLen_11506(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_11507","instance":11507,"id":198178,"goal":"lemma SeqReverseIdem_11507(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_11508","instance":11508,"id":198179,"goal":"lemma SeqMapLen_11508(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_11509","instance":11509,"id":198180,"goal":"lemma SeqFilterLe_11509(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_11510","instance":11510,"id":198181,"goal":"lemma SeqMemberAppend_11510(s: seq, xs: seq)\n ensures x in s + xs <==> x in s || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_11511","instance":11511,"id":198182,"goal":"lemma SeqAppendLen_11511(ys: seq, t: seq)\n ensures |ys + t| == |ys| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_11512","instance":11512,"id":198183,"goal":"lemma SeqAppendNil_11512(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_11513","instance":11513,"id":198184,"goal":"lemma SeqNilAppend_11513(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_11514","instance":11514,"id":198185,"goal":"lemma SeqAppendAssoc_11514(xs: seq, ys: seq, zs: seq)\n ensures (xs + ys) + zs == xs + (ys + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_11515","instance":11515,"id":198186,"goal":"lemma SeqTakeDrop_11515(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_11516","instance":11516,"id":198187,"goal":"lemma SeqReverseLen_11516(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_11517","instance":11517,"id":198188,"goal":"lemma SeqReverseIdem_11517(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_11518","instance":11518,"id":198189,"goal":"lemma SeqMapLen_11518(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_11519","instance":11519,"id":198190,"goal":"lemma SeqFilterLe_11519(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_11520","instance":11520,"id":198191,"goal":"lemma SeqMemberAppend_11520(t: seq, zs: seq)\n ensures x in t + zs <==> x in t || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_11521","instance":11521,"id":198192,"goal":"lemma SeqAppendLen_11521(zs: seq, s: seq)\n ensures |zs + s| == |zs| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_11522","instance":11522,"id":198193,"goal":"lemma SeqAppendNil_11522(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_11523","instance":11523,"id":198194,"goal":"lemma SeqNilAppend_11523(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_11524","instance":11524,"id":198195,"goal":"lemma SeqAppendAssoc_11524(xs: seq, ys: seq, u: seq)\n ensures (xs + ys) + u == xs + (ys + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_11525","instance":11525,"id":198196,"goal":"lemma SeqTakeDrop_11525(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_11526","instance":11526,"id":198197,"goal":"lemma SeqReverseLen_11526(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_11527","instance":11527,"id":198198,"goal":"lemma SeqReverseIdem_11527(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_11528","instance":11528,"id":198199,"goal":"lemma SeqMapLen_11528(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_11529","instance":11529,"id":198200,"goal":"lemma SeqFilterLe_11529(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_11530","instance":11530,"id":198201,"goal":"lemma SeqMemberAppend_11530(ys: seq, zs: seq)\n ensures x in ys + zs <==> x in ys || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_11531","instance":11531,"id":198202,"goal":"lemma SeqAppendLen_11531(s: seq, t: seq)\n ensures |s + t| == |s| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_11532","instance":11532,"id":198203,"goal":"lemma SeqAppendNil_11532(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_11533","instance":11533,"id":198204,"goal":"lemma SeqNilAppend_11533(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_11534","instance":11534,"id":198205,"goal":"lemma SeqAppendAssoc_11534(xs: seq, zs: seq, u: seq)\n ensures (xs + zs) + u == xs + (zs + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_11535","instance":11535,"id":198206,"goal":"lemma SeqTakeDrop_11535(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_11536","instance":11536,"id":198207,"goal":"lemma SeqReverseLen_11536(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_11537","instance":11537,"id":198208,"goal":"lemma SeqReverseIdem_11537(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_11538","instance":11538,"id":198209,"goal":"lemma SeqMapLen_11538(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_11539","instance":11539,"id":198210,"goal":"lemma SeqFilterLe_11539(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_11540","instance":11540,"id":198211,"goal":"lemma SeqMemberAppend_11540(t: seq, xs: seq)\n ensures x in t + xs <==> x in t || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_11541","instance":11541,"id":198212,"goal":"lemma SeqAppendLen_11541(s: seq, t: seq)\n ensures |s + t| == |s| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_11542","instance":11542,"id":198213,"goal":"lemma SeqAppendNil_11542(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_11543","instance":11543,"id":198214,"goal":"lemma SeqNilAppend_11543(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_11544","instance":11544,"id":198215,"goal":"lemma SeqAppendAssoc_11544(xs: seq, s: seq, u: seq)\n ensures (xs + s) + u == xs + (s + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_11545","instance":11545,"id":198216,"goal":"lemma SeqTakeDrop_11545(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_11546","instance":11546,"id":198217,"goal":"lemma SeqReverseLen_11546(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_11547","instance":11547,"id":198218,"goal":"lemma SeqReverseIdem_11547(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_11548","instance":11548,"id":198219,"goal":"lemma SeqMapLen_11548(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_11549","instance":11549,"id":198220,"goal":"lemma SeqFilterLe_11549(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_11550","instance":11550,"id":198221,"goal":"lemma SeqMemberAppend_11550(xs: seq, u: seq)\n ensures x in xs + u <==> x in xs || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_11551","instance":11551,"id":198222,"goal":"lemma SeqAppendLen_11551(ys: seq, s: seq)\n ensures |ys + s| == |ys| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_11552","instance":11552,"id":198223,"goal":"lemma SeqAppendNil_11552(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_11553","instance":11553,"id":198224,"goal":"lemma SeqNilAppend_11553(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_11554","instance":11554,"id":198225,"goal":"lemma SeqAppendAssoc_11554(s: seq, ys: seq, u: seq)\n ensures (s + ys) + u == s + (ys + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_11555","instance":11555,"id":198226,"goal":"lemma SeqTakeDrop_11555(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_11556","instance":11556,"id":198227,"goal":"lemma SeqReverseLen_11556(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_11557","instance":11557,"id":198228,"goal":"lemma SeqReverseIdem_11557(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_11558","instance":11558,"id":198229,"goal":"lemma SeqMapLen_11558(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_11559","instance":11559,"id":198230,"goal":"lemma SeqFilterLe_11559(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_11560","instance":11560,"id":198231,"goal":"lemma SeqMemberAppend_11560(zs: seq, t: seq)\n ensures x in zs + t <==> x in zs || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_11561","instance":11561,"id":198232,"goal":"lemma SeqAppendLen_11561(xs: seq, zs: seq)\n ensures |xs + zs| == |xs| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_11562","instance":11562,"id":198233,"goal":"lemma SeqAppendNil_11562(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_11563","instance":11563,"id":198234,"goal":"lemma SeqNilAppend_11563(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_11564","instance":11564,"id":198235,"goal":"lemma SeqAppendAssoc_11564(u: seq, s: seq, zs: seq)\n ensures (u + s) + zs == u + (s + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_11565","instance":11565,"id":198236,"goal":"lemma SeqTakeDrop_11565(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_11566","instance":11566,"id":198237,"goal":"lemma SeqReverseLen_11566(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_11567","instance":11567,"id":198238,"goal":"lemma SeqReverseIdem_11567(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_11568","instance":11568,"id":198239,"goal":"lemma SeqMapLen_11568(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_11569","instance":11569,"id":198240,"goal":"lemma SeqFilterLe_11569(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_11570","instance":11570,"id":198241,"goal":"lemma SeqMemberAppend_11570(ys: seq, zs: seq)\n ensures x in ys + zs <==> x in ys || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_11571","instance":11571,"id":198242,"goal":"lemma SeqAppendLen_11571(ys: seq, t: seq)\n ensures |ys + t| == |ys| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_11572","instance":11572,"id":198243,"goal":"lemma SeqAppendNil_11572(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_11573","instance":11573,"id":198244,"goal":"lemma SeqNilAppend_11573(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_11574","instance":11574,"id":198245,"goal":"lemma SeqAppendAssoc_11574(ys: seq, xs: seq, zs: seq)\n ensures (ys + xs) + zs == ys + (xs + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_11575","instance":11575,"id":198246,"goal":"lemma SeqTakeDrop_11575(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_11576","instance":11576,"id":198247,"goal":"lemma SeqReverseLen_11576(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_11577","instance":11577,"id":198248,"goal":"lemma SeqReverseIdem_11577(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_11578","instance":11578,"id":198249,"goal":"lemma SeqMapLen_11578(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_11579","instance":11579,"id":198250,"goal":"lemma SeqFilterLe_11579(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_11580","instance":11580,"id":198251,"goal":"lemma SeqMemberAppend_11580(u: seq, xs: seq)\n ensures x in u + xs <==> x in u || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_11581","instance":11581,"id":198252,"goal":"lemma SeqAppendLen_11581(u: seq, zs: seq)\n ensures |u + zs| == |u| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_11582","instance":11582,"id":198253,"goal":"lemma SeqAppendNil_11582(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_11583","instance":11583,"id":198254,"goal":"lemma SeqNilAppend_11583(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_11584","instance":11584,"id":198255,"goal":"lemma SeqAppendAssoc_11584(s: seq, u: seq, zs: seq)\n ensures (s + u) + zs == s + (u + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_11585","instance":11585,"id":198256,"goal":"lemma SeqTakeDrop_11585(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_11586","instance":11586,"id":198257,"goal":"lemma SeqReverseLen_11586(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_11587","instance":11587,"id":198258,"goal":"lemma SeqReverseIdem_11587(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_11588","instance":11588,"id":198259,"goal":"lemma SeqMapLen_11588(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_11589","instance":11589,"id":198260,"goal":"lemma SeqFilterLe_11589(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_11590","instance":11590,"id":198261,"goal":"lemma SeqMemberAppend_11590(zs: seq, xs: seq)\n ensures x in zs + xs <==> x in zs || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_11591","instance":11591,"id":198262,"goal":"lemma SeqAppendLen_11591(xs: seq, u: seq)\n ensures |xs + u| == |xs| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_11592","instance":11592,"id":198263,"goal":"lemma SeqAppendNil_11592(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_11593","instance":11593,"id":198264,"goal":"lemma SeqNilAppend_11593(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_11594","instance":11594,"id":198265,"goal":"lemma SeqAppendAssoc_11594(s: seq, u: seq, zs: seq)\n ensures (s + u) + zs == s + (u + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_11595","instance":11595,"id":198266,"goal":"lemma SeqTakeDrop_11595(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_11596","instance":11596,"id":198267,"goal":"lemma SeqReverseLen_11596(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_11597","instance":11597,"id":198268,"goal":"lemma SeqReverseIdem_11597(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_11598","instance":11598,"id":198269,"goal":"lemma SeqMapLen_11598(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_11599","instance":11599,"id":198270,"goal":"lemma SeqFilterLe_11599(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_11600","instance":11600,"id":198271,"goal":"lemma SeqMemberAppend_11600(xs: seq, zs: seq)\n ensures x in xs + zs <==> x in xs || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_11601","instance":11601,"id":198272,"goal":"lemma SeqAppendLen_11601(u: seq, ys: seq)\n ensures |u + ys| == |u| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_11602","instance":11602,"id":198273,"goal":"lemma SeqAppendNil_11602(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_11603","instance":11603,"id":198274,"goal":"lemma SeqNilAppend_11603(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_11604","instance":11604,"id":198275,"goal":"lemma SeqAppendAssoc_11604(ys: seq, u: seq, t: seq)\n ensures (ys + u) + t == ys + (u + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_11605","instance":11605,"id":198276,"goal":"lemma SeqTakeDrop_11605(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_11606","instance":11606,"id":198277,"goal":"lemma SeqReverseLen_11606(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_11607","instance":11607,"id":198278,"goal":"lemma SeqReverseIdem_11607(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_11608","instance":11608,"id":198279,"goal":"lemma SeqMapLen_11608(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_11609","instance":11609,"id":198280,"goal":"lemma SeqFilterLe_11609(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_11610","instance":11610,"id":198281,"goal":"lemma SeqMemberAppend_11610(t: seq, xs: seq)\n ensures x in t + xs <==> x in t || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_11611","instance":11611,"id":198282,"goal":"lemma SeqAppendLen_11611(s: seq, u: seq)\n ensures |s + u| == |s| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_11612","instance":11612,"id":198283,"goal":"lemma SeqAppendNil_11612(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_11613","instance":11613,"id":198284,"goal":"lemma SeqNilAppend_11613(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_11614","instance":11614,"id":198285,"goal":"lemma SeqAppendAssoc_11614(zs: seq, u: seq, ys: seq)\n ensures (zs + u) + ys == zs + (u + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_11615","instance":11615,"id":198286,"goal":"lemma SeqTakeDrop_11615(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_11616","instance":11616,"id":198287,"goal":"lemma SeqReverseLen_11616(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_11617","instance":11617,"id":198288,"goal":"lemma SeqReverseIdem_11617(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_11618","instance":11618,"id":198289,"goal":"lemma SeqMapLen_11618(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_11619","instance":11619,"id":198290,"goal":"lemma SeqFilterLe_11619(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_11620","instance":11620,"id":198291,"goal":"lemma SeqMemberAppend_11620(u: seq, ys: seq)\n ensures x in u + ys <==> x in u || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_11621","instance":11621,"id":198292,"goal":"lemma SeqAppendLen_11621(ys: seq, s: seq)\n ensures |ys + s| == |ys| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_11622","instance":11622,"id":198293,"goal":"lemma SeqAppendNil_11622(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_11623","instance":11623,"id":198294,"goal":"lemma SeqNilAppend_11623(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_11624","instance":11624,"id":198295,"goal":"lemma SeqAppendAssoc_11624(s: seq, u: seq, t: seq)\n ensures (s + u) + t == s + (u + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_11625","instance":11625,"id":198296,"goal":"lemma SeqTakeDrop_11625(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_11626","instance":11626,"id":198297,"goal":"lemma SeqReverseLen_11626(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_11627","instance":11627,"id":198298,"goal":"lemma SeqReverseIdem_11627(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_11628","instance":11628,"id":198299,"goal":"lemma SeqMapLen_11628(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_11629","instance":11629,"id":198300,"goal":"lemma SeqFilterLe_11629(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_11630","instance":11630,"id":198301,"goal":"lemma SeqMemberAppend_11630(t: seq, u: seq)\n ensures x in t + u <==> x in t || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_11631","instance":11631,"id":198302,"goal":"lemma SeqAppendLen_11631(ys: seq, u: seq)\n ensures |ys + u| == |ys| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_11632","instance":11632,"id":198303,"goal":"lemma SeqAppendNil_11632(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_11633","instance":11633,"id":198304,"goal":"lemma SeqNilAppend_11633(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_11634","instance":11634,"id":198305,"goal":"lemma SeqAppendAssoc_11634(zs: seq, xs: seq, ys: seq)\n ensures (zs + xs) + ys == zs + (xs + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_11635","instance":11635,"id":198306,"goal":"lemma SeqTakeDrop_11635(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_11636","instance":11636,"id":198307,"goal":"lemma SeqReverseLen_11636(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_11637","instance":11637,"id":198308,"goal":"lemma SeqReverseIdem_11637(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_11638","instance":11638,"id":198309,"goal":"lemma SeqMapLen_11638(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_11639","instance":11639,"id":198310,"goal":"lemma SeqFilterLe_11639(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_11640","instance":11640,"id":198311,"goal":"lemma SeqMemberAppend_11640(t: seq, zs: seq)\n ensures x in t + zs <==> x in t || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_11641","instance":11641,"id":198312,"goal":"lemma SeqAppendLen_11641(u: seq, xs: seq)\n ensures |u + xs| == |u| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_11642","instance":11642,"id":198313,"goal":"lemma SeqAppendNil_11642(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_11643","instance":11643,"id":198314,"goal":"lemma SeqNilAppend_11643(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_11644","instance":11644,"id":198315,"goal":"lemma SeqAppendAssoc_11644(zs: seq, u: seq, xs: seq)\n ensures (zs + u) + xs == zs + (u + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_11645","instance":11645,"id":198316,"goal":"lemma SeqTakeDrop_11645(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_11646","instance":11646,"id":198317,"goal":"lemma SeqReverseLen_11646(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_11647","instance":11647,"id":198318,"goal":"lemma SeqReverseIdem_11647(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_11648","instance":11648,"id":198319,"goal":"lemma SeqMapLen_11648(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_11649","instance":11649,"id":198320,"goal":"lemma SeqFilterLe_11649(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_11650","instance":11650,"id":198321,"goal":"lemma SeqMemberAppend_11650(s: seq, xs: seq)\n ensures x in s + xs <==> x in s || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_11651","instance":11651,"id":198322,"goal":"lemma SeqAppendLen_11651(t: seq, xs: seq)\n ensures |t + xs| == |t| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_11652","instance":11652,"id":198323,"goal":"lemma SeqAppendNil_11652(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_11653","instance":11653,"id":198324,"goal":"lemma SeqNilAppend_11653(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_11654","instance":11654,"id":198325,"goal":"lemma SeqAppendAssoc_11654(xs: seq, s: seq, ys: seq)\n ensures (xs + s) + ys == xs + (s + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_11655","instance":11655,"id":198326,"goal":"lemma SeqTakeDrop_11655(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_11656","instance":11656,"id":198327,"goal":"lemma SeqReverseLen_11656(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_11657","instance":11657,"id":198328,"goal":"lemma SeqReverseIdem_11657(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_11658","instance":11658,"id":198329,"goal":"lemma SeqMapLen_11658(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_11659","instance":11659,"id":198330,"goal":"lemma SeqFilterLe_11659(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_11660","instance":11660,"id":198331,"goal":"lemma SeqMemberAppend_11660(xs: seq, ys: seq)\n ensures x in xs + ys <==> x in xs || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_11661","instance":11661,"id":198332,"goal":"lemma SeqAppendLen_11661(xs: seq, zs: seq)\n ensures |xs + zs| == |xs| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_11662","instance":11662,"id":198333,"goal":"lemma SeqAppendNil_11662(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_11663","instance":11663,"id":198334,"goal":"lemma SeqNilAppend_11663(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_11664","instance":11664,"id":198335,"goal":"lemma SeqAppendAssoc_11664(xs: seq, t: seq, ys: seq)\n ensures (xs + t) + ys == xs + (t + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_11665","instance":11665,"id":198336,"goal":"lemma SeqTakeDrop_11665(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_11666","instance":11666,"id":198337,"goal":"lemma SeqReverseLen_11666(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_11667","instance":11667,"id":198338,"goal":"lemma SeqReverseIdem_11667(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_11668","instance":11668,"id":198339,"goal":"lemma SeqMapLen_11668(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_11669","instance":11669,"id":198340,"goal":"lemma SeqFilterLe_11669(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_11670","instance":11670,"id":198341,"goal":"lemma SeqMemberAppend_11670(xs: seq, u: seq)\n ensures x in xs + u <==> x in xs || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_11671","instance":11671,"id":198342,"goal":"lemma SeqAppendLen_11671(xs: seq, u: seq)\n ensures |xs + u| == |xs| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_11672","instance":11672,"id":198343,"goal":"lemma SeqAppendNil_11672(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_11673","instance":11673,"id":198344,"goal":"lemma SeqNilAppend_11673(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_11674","instance":11674,"id":198345,"goal":"lemma SeqAppendAssoc_11674(ys: seq, s: seq, t: seq)\n ensures (ys + s) + t == ys + (s + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_11675","instance":11675,"id":198346,"goal":"lemma SeqTakeDrop_11675(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_11676","instance":11676,"id":198347,"goal":"lemma SeqReverseLen_11676(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_11677","instance":11677,"id":198348,"goal":"lemma SeqReverseIdem_11677(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_11678","instance":11678,"id":198349,"goal":"lemma SeqMapLen_11678(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_11679","instance":11679,"id":198350,"goal":"lemma SeqFilterLe_11679(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_11680","instance":11680,"id":198351,"goal":"lemma SeqMemberAppend_11680(zs: seq, ys: seq)\n ensures x in zs + ys <==> x in zs || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_11681","instance":11681,"id":198352,"goal":"lemma SeqAppendLen_11681(u: seq, s: seq)\n ensures |u + s| == |u| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_11682","instance":11682,"id":198353,"goal":"lemma SeqAppendNil_11682(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_11683","instance":11683,"id":198354,"goal":"lemma SeqNilAppend_11683(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_11684","instance":11684,"id":198355,"goal":"lemma SeqAppendAssoc_11684(ys: seq, u: seq, t: seq)\n ensures (ys + u) + t == ys + (u + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_11685","instance":11685,"id":198356,"goal":"lemma SeqTakeDrop_11685(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_11686","instance":11686,"id":198357,"goal":"lemma SeqReverseLen_11686(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_11687","instance":11687,"id":198358,"goal":"lemma SeqReverseIdem_11687(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_11688","instance":11688,"id":198359,"goal":"lemma SeqMapLen_11688(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_11689","instance":11689,"id":198360,"goal":"lemma SeqFilterLe_11689(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_11690","instance":11690,"id":198361,"goal":"lemma SeqMemberAppend_11690(s: seq, xs: seq)\n ensures x in s + xs <==> x in s || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_11691","instance":11691,"id":198362,"goal":"lemma SeqAppendLen_11691(ys: seq, u: seq)\n ensures |ys + u| == |ys| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_11692","instance":11692,"id":198363,"goal":"lemma SeqAppendNil_11692(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_11693","instance":11693,"id":198364,"goal":"lemma SeqNilAppend_11693(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_11694","instance":11694,"id":198365,"goal":"lemma SeqAppendAssoc_11694(ys: seq, t: seq, zs: seq)\n ensures (ys + t) + zs == ys + (t + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_11695","instance":11695,"id":198366,"goal":"lemma SeqTakeDrop_11695(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_11696","instance":11696,"id":198367,"goal":"lemma SeqReverseLen_11696(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_11697","instance":11697,"id":198368,"goal":"lemma SeqReverseIdem_11697(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_11698","instance":11698,"id":198369,"goal":"lemma SeqMapLen_11698(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_11699","instance":11699,"id":198370,"goal":"lemma SeqFilterLe_11699(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_11700","instance":11700,"id":198371,"goal":"lemma SeqMemberAppend_11700(xs: seq, zs: seq)\n ensures x in xs + zs <==> x in xs || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_11701","instance":11701,"id":198372,"goal":"lemma SeqAppendLen_11701(zs: seq, u: seq)\n ensures |zs + u| == |zs| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_11702","instance":11702,"id":198373,"goal":"lemma SeqAppendNil_11702(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_11703","instance":11703,"id":198374,"goal":"lemma SeqNilAppend_11703(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_11704","instance":11704,"id":198375,"goal":"lemma SeqAppendAssoc_11704(ys: seq, xs: seq, u: seq)\n ensures (ys + xs) + u == ys + (xs + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_11705","instance":11705,"id":198376,"goal":"lemma SeqTakeDrop_11705(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_11706","instance":11706,"id":198377,"goal":"lemma SeqReverseLen_11706(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_11707","instance":11707,"id":198378,"goal":"lemma SeqReverseIdem_11707(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_11708","instance":11708,"id":198379,"goal":"lemma SeqMapLen_11708(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_11709","instance":11709,"id":198380,"goal":"lemma SeqFilterLe_11709(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_11710","instance":11710,"id":198381,"goal":"lemma SeqMemberAppend_11710(u: seq, t: seq)\n ensures x in u + t <==> x in u || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_11711","instance":11711,"id":198382,"goal":"lemma SeqAppendLen_11711(s: seq, xs: seq)\n ensures |s + xs| == |s| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_11712","instance":11712,"id":198383,"goal":"lemma SeqAppendNil_11712(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_11713","instance":11713,"id":198384,"goal":"lemma SeqNilAppend_11713(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_11714","instance":11714,"id":198385,"goal":"lemma SeqAppendAssoc_11714(zs: seq, xs: seq, s: seq)\n ensures (zs + xs) + s == zs + (xs + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_11715","instance":11715,"id":198386,"goal":"lemma SeqTakeDrop_11715(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_11716","instance":11716,"id":198387,"goal":"lemma SeqReverseLen_11716(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_11717","instance":11717,"id":198388,"goal":"lemma SeqReverseIdem_11717(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_11718","instance":11718,"id":198389,"goal":"lemma SeqMapLen_11718(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_11719","instance":11719,"id":198390,"goal":"lemma SeqFilterLe_11719(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_11720","instance":11720,"id":198391,"goal":"lemma SeqMemberAppend_11720(u: seq, xs: seq)\n ensures x in u + xs <==> x in u || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_11721","instance":11721,"id":198392,"goal":"lemma SeqAppendLen_11721(ys: seq, u: seq)\n ensures |ys + u| == |ys| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_11722","instance":11722,"id":198393,"goal":"lemma SeqAppendNil_11722(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_11723","instance":11723,"id":198394,"goal":"lemma SeqNilAppend_11723(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_11724","instance":11724,"id":198395,"goal":"lemma SeqAppendAssoc_11724(ys: seq, xs: seq, t: seq)\n ensures (ys + xs) + t == ys + (xs + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_11725","instance":11725,"id":198396,"goal":"lemma SeqTakeDrop_11725(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_11726","instance":11726,"id":198397,"goal":"lemma SeqReverseLen_11726(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_11727","instance":11727,"id":198398,"goal":"lemma SeqReverseIdem_11727(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_11728","instance":11728,"id":198399,"goal":"lemma SeqMapLen_11728(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_11729","instance":11729,"id":198400,"goal":"lemma SeqFilterLe_11729(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_11730","instance":11730,"id":198401,"goal":"lemma SeqMemberAppend_11730(t: seq, s: seq)\n ensures x in t + s <==> x in t || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_11731","instance":11731,"id":198402,"goal":"lemma SeqAppendLen_11731(ys: seq, t: seq)\n ensures |ys + t| == |ys| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_11732","instance":11732,"id":198403,"goal":"lemma SeqAppendNil_11732(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_11733","instance":11733,"id":198404,"goal":"lemma SeqNilAppend_11733(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_11734","instance":11734,"id":198405,"goal":"lemma SeqAppendAssoc_11734(zs: seq, u: seq, s: seq)\n ensures (zs + u) + s == zs + (u + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_11735","instance":11735,"id":198406,"goal":"lemma SeqTakeDrop_11735(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_11736","instance":11736,"id":198407,"goal":"lemma SeqReverseLen_11736(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_11737","instance":11737,"id":198408,"goal":"lemma SeqReverseIdem_11737(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_11738","instance":11738,"id":198409,"goal":"lemma SeqMapLen_11738(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_11739","instance":11739,"id":198410,"goal":"lemma SeqFilterLe_11739(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_11740","instance":11740,"id":198411,"goal":"lemma SeqMemberAppend_11740(t: seq, s: seq)\n ensures x in t + s <==> x in t || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_11741","instance":11741,"id":198412,"goal":"lemma SeqAppendLen_11741(t: seq, zs: seq)\n ensures |t + zs| == |t| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_11742","instance":11742,"id":198413,"goal":"lemma SeqAppendNil_11742(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_11743","instance":11743,"id":198414,"goal":"lemma SeqNilAppend_11743(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_11744","instance":11744,"id":198415,"goal":"lemma SeqAppendAssoc_11744(ys: seq, t: seq, zs: seq)\n ensures (ys + t) + zs == ys + (t + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_11745","instance":11745,"id":198416,"goal":"lemma SeqTakeDrop_11745(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_11746","instance":11746,"id":198417,"goal":"lemma SeqReverseLen_11746(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_11747","instance":11747,"id":198418,"goal":"lemma SeqReverseIdem_11747(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_11748","instance":11748,"id":198419,"goal":"lemma SeqMapLen_11748(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_11749","instance":11749,"id":198420,"goal":"lemma SeqFilterLe_11749(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_11750","instance":11750,"id":198421,"goal":"lemma SeqMemberAppend_11750(t: seq, ys: seq)\n ensures x in t + ys <==> x in t || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_11751","instance":11751,"id":198422,"goal":"lemma SeqAppendLen_11751(t: seq, u: seq)\n ensures |t + u| == |t| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_11752","instance":11752,"id":198423,"goal":"lemma SeqAppendNil_11752(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_11753","instance":11753,"id":198424,"goal":"lemma SeqNilAppend_11753(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_11754","instance":11754,"id":198425,"goal":"lemma SeqAppendAssoc_11754(s: seq, zs: seq, t: seq)\n ensures (s + zs) + t == s + (zs + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_11755","instance":11755,"id":198426,"goal":"lemma SeqTakeDrop_11755(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_11756","instance":11756,"id":198427,"goal":"lemma SeqReverseLen_11756(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_11757","instance":11757,"id":198428,"goal":"lemma SeqReverseIdem_11757(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_11758","instance":11758,"id":198429,"goal":"lemma SeqMapLen_11758(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_11759","instance":11759,"id":198430,"goal":"lemma SeqFilterLe_11759(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_11760","instance":11760,"id":198431,"goal":"lemma SeqMemberAppend_11760(s: seq, xs: seq)\n ensures x in s + xs <==> x in s || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_11761","instance":11761,"id":198432,"goal":"lemma SeqAppendLen_11761(t: seq, s: seq)\n ensures |t + s| == |t| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_11762","instance":11762,"id":198433,"goal":"lemma SeqAppendNil_11762(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_11763","instance":11763,"id":198434,"goal":"lemma SeqNilAppend_11763(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_11764","instance":11764,"id":198435,"goal":"lemma SeqAppendAssoc_11764(t: seq, u: seq, zs: seq)\n ensures (t + u) + zs == t + (u + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_11765","instance":11765,"id":198436,"goal":"lemma SeqTakeDrop_11765(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_11766","instance":11766,"id":198437,"goal":"lemma SeqReverseLen_11766(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_11767","instance":11767,"id":198438,"goal":"lemma SeqReverseIdem_11767(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_11768","instance":11768,"id":198439,"goal":"lemma SeqMapLen_11768(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_11769","instance":11769,"id":198440,"goal":"lemma SeqFilterLe_11769(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_11770","instance":11770,"id":198441,"goal":"lemma SeqMemberAppend_11770(s: seq, u: seq)\n ensures x in s + u <==> x in s || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_11771","instance":11771,"id":198442,"goal":"lemma SeqAppendLen_11771(zs: seq, ys: seq)\n ensures |zs + ys| == |zs| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_11772","instance":11772,"id":198443,"goal":"lemma SeqAppendNil_11772(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_11773","instance":11773,"id":198444,"goal":"lemma SeqNilAppend_11773(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_11774","instance":11774,"id":198445,"goal":"lemma SeqAppendAssoc_11774(ys: seq, xs: seq, u: seq)\n ensures (ys + xs) + u == ys + (xs + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_11775","instance":11775,"id":198446,"goal":"lemma SeqTakeDrop_11775(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_11776","instance":11776,"id":198447,"goal":"lemma SeqReverseLen_11776(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_11777","instance":11777,"id":198448,"goal":"lemma SeqReverseIdem_11777(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_11778","instance":11778,"id":198449,"goal":"lemma SeqMapLen_11778(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_11779","instance":11779,"id":198450,"goal":"lemma SeqFilterLe_11779(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_11780","instance":11780,"id":198451,"goal":"lemma SeqMemberAppend_11780(zs: seq, u: seq)\n ensures x in zs + u <==> x in zs || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_11781","instance":11781,"id":198452,"goal":"lemma SeqAppendLen_11781(zs: seq, u: seq)\n ensures |zs + u| == |zs| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_11782","instance":11782,"id":198453,"goal":"lemma SeqAppendNil_11782(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_11783","instance":11783,"id":198454,"goal":"lemma SeqNilAppend_11783(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_11784","instance":11784,"id":198455,"goal":"lemma SeqAppendAssoc_11784(s: seq, zs: seq, xs: seq)\n ensures (s + zs) + xs == s + (zs + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_11785","instance":11785,"id":198456,"goal":"lemma SeqTakeDrop_11785(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_11786","instance":11786,"id":198457,"goal":"lemma SeqReverseLen_11786(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_11787","instance":11787,"id":198458,"goal":"lemma SeqReverseIdem_11787(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_11788","instance":11788,"id":198459,"goal":"lemma SeqMapLen_11788(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_11789","instance":11789,"id":198460,"goal":"lemma SeqFilterLe_11789(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_11790","instance":11790,"id":198461,"goal":"lemma SeqMemberAppend_11790(ys: seq, t: seq)\n ensures x in ys + t <==> x in ys || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_11791","instance":11791,"id":198462,"goal":"lemma SeqAppendLen_11791(xs: seq, u: seq)\n ensures |xs + u| == |xs| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_11792","instance":11792,"id":198463,"goal":"lemma SeqAppendNil_11792(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_11793","instance":11793,"id":198464,"goal":"lemma SeqNilAppend_11793(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_11794","instance":11794,"id":198465,"goal":"lemma SeqAppendAssoc_11794(u: seq, zs: seq, t: seq)\n ensures (u + zs) + t == u + (zs + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_11795","instance":11795,"id":198466,"goal":"lemma SeqTakeDrop_11795(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_11796","instance":11796,"id":198467,"goal":"lemma SeqReverseLen_11796(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_11797","instance":11797,"id":198468,"goal":"lemma SeqReverseIdem_11797(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_11798","instance":11798,"id":198469,"goal":"lemma SeqMapLen_11798(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_11799","instance":11799,"id":198470,"goal":"lemma SeqFilterLe_11799(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_11800","instance":11800,"id":198471,"goal":"lemma SeqMemberAppend_11800(t: seq, ys: seq)\n ensures x in t + ys <==> x in t || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_11801","instance":11801,"id":198472,"goal":"lemma SeqAppendLen_11801(s: seq, ys: seq)\n ensures |s + ys| == |s| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_11802","instance":11802,"id":198473,"goal":"lemma SeqAppendNil_11802(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_11803","instance":11803,"id":198474,"goal":"lemma SeqNilAppend_11803(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_11804","instance":11804,"id":198475,"goal":"lemma SeqAppendAssoc_11804(s: seq, zs: seq, xs: seq)\n ensures (s + zs) + xs == s + (zs + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_11805","instance":11805,"id":198476,"goal":"lemma SeqTakeDrop_11805(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_11806","instance":11806,"id":198477,"goal":"lemma SeqReverseLen_11806(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_11807","instance":11807,"id":198478,"goal":"lemma SeqReverseIdem_11807(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_11808","instance":11808,"id":198479,"goal":"lemma SeqMapLen_11808(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_11809","instance":11809,"id":198480,"goal":"lemma SeqFilterLe_11809(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_11810","instance":11810,"id":198481,"goal":"lemma SeqMemberAppend_11810(ys: seq, zs: seq)\n ensures x in ys + zs <==> x in ys || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_11811","instance":11811,"id":198482,"goal":"lemma SeqAppendLen_11811(u: seq, xs: seq)\n ensures |u + xs| == |u| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_11812","instance":11812,"id":198483,"goal":"lemma SeqAppendNil_11812(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_11813","instance":11813,"id":198484,"goal":"lemma SeqNilAppend_11813(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_11814","instance":11814,"id":198485,"goal":"lemma SeqAppendAssoc_11814(u: seq, zs: seq, ys: seq)\n ensures (u + zs) + ys == u + (zs + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_11815","instance":11815,"id":198486,"goal":"lemma SeqTakeDrop_11815(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_11816","instance":11816,"id":198487,"goal":"lemma SeqReverseLen_11816(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_11817","instance":11817,"id":198488,"goal":"lemma SeqReverseIdem_11817(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_11818","instance":11818,"id":198489,"goal":"lemma SeqMapLen_11818(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_11819","instance":11819,"id":198490,"goal":"lemma SeqFilterLe_11819(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_11820","instance":11820,"id":198491,"goal":"lemma SeqMemberAppend_11820(ys: seq, xs: seq)\n ensures x in ys + xs <==> x in ys || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_11821","instance":11821,"id":198492,"goal":"lemma SeqAppendLen_11821(s: seq, ys: seq)\n ensures |s + ys| == |s| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_11822","instance":11822,"id":198493,"goal":"lemma SeqAppendNil_11822(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_11823","instance":11823,"id":198494,"goal":"lemma SeqNilAppend_11823(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_11824","instance":11824,"id":198495,"goal":"lemma SeqAppendAssoc_11824(s: seq, t: seq, u: seq)\n ensures (s + t) + u == s + (t + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_11825","instance":11825,"id":198496,"goal":"lemma SeqTakeDrop_11825(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_11826","instance":11826,"id":198497,"goal":"lemma SeqReverseLen_11826(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_11827","instance":11827,"id":198498,"goal":"lemma SeqReverseIdem_11827(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_11828","instance":11828,"id":198499,"goal":"lemma SeqMapLen_11828(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_11829","instance":11829,"id":198500,"goal":"lemma SeqFilterLe_11829(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_11830","instance":11830,"id":198501,"goal":"lemma SeqMemberAppend_11830(xs: seq, s: seq)\n ensures x in xs + s <==> x in xs || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_11831","instance":11831,"id":198502,"goal":"lemma SeqAppendLen_11831(zs: seq, u: seq)\n ensures |zs + u| == |zs| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_11832","instance":11832,"id":198503,"goal":"lemma SeqAppendNil_11832(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_11833","instance":11833,"id":198504,"goal":"lemma SeqNilAppend_11833(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_11834","instance":11834,"id":198505,"goal":"lemma SeqAppendAssoc_11834(ys: seq, u: seq, s: seq)\n ensures (ys + u) + s == ys + (u + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_11835","instance":11835,"id":198506,"goal":"lemma SeqTakeDrop_11835(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_11836","instance":11836,"id":198507,"goal":"lemma SeqReverseLen_11836(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_11837","instance":11837,"id":198508,"goal":"lemma SeqReverseIdem_11837(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_11838","instance":11838,"id":198509,"goal":"lemma SeqMapLen_11838(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_11839","instance":11839,"id":198510,"goal":"lemma SeqFilterLe_11839(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_11840","instance":11840,"id":198511,"goal":"lemma SeqMemberAppend_11840(u: seq, xs: seq)\n ensures x in u + xs <==> x in u || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_11841","instance":11841,"id":198512,"goal":"lemma SeqAppendLen_11841(u: seq, s: seq)\n ensures |u + s| == |u| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_11842","instance":11842,"id":198513,"goal":"lemma SeqAppendNil_11842(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_11843","instance":11843,"id":198514,"goal":"lemma SeqNilAppend_11843(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_11844","instance":11844,"id":198515,"goal":"lemma SeqAppendAssoc_11844(s: seq, t: seq, ys: seq)\n ensures (s + t) + ys == s + (t + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_11845","instance":11845,"id":198516,"goal":"lemma SeqTakeDrop_11845(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_11846","instance":11846,"id":198517,"goal":"lemma SeqReverseLen_11846(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_11847","instance":11847,"id":198518,"goal":"lemma SeqReverseIdem_11847(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_11848","instance":11848,"id":198519,"goal":"lemma SeqMapLen_11848(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_11849","instance":11849,"id":198520,"goal":"lemma SeqFilterLe_11849(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_11850","instance":11850,"id":198521,"goal":"lemma SeqMemberAppend_11850(u: seq, ys: seq)\n ensures x in u + ys <==> x in u || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_11851","instance":11851,"id":198522,"goal":"lemma SeqAppendLen_11851(t: seq, ys: seq)\n ensures |t + ys| == |t| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_11852","instance":11852,"id":198523,"goal":"lemma SeqAppendNil_11852(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_11853","instance":11853,"id":198524,"goal":"lemma SeqNilAppend_11853(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_11854","instance":11854,"id":198525,"goal":"lemma SeqAppendAssoc_11854(ys: seq, s: seq, zs: seq)\n ensures (ys + s) + zs == ys + (s + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_11855","instance":11855,"id":198526,"goal":"lemma SeqTakeDrop_11855(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_11856","instance":11856,"id":198527,"goal":"lemma SeqReverseLen_11856(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_11857","instance":11857,"id":198528,"goal":"lemma SeqReverseIdem_11857(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_11858","instance":11858,"id":198529,"goal":"lemma SeqMapLen_11858(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_11859","instance":11859,"id":198530,"goal":"lemma SeqFilterLe_11859(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_11860","instance":11860,"id":198531,"goal":"lemma SeqMemberAppend_11860(ys: seq, u: seq)\n ensures x in ys + u <==> x in ys || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_11861","instance":11861,"id":198532,"goal":"lemma SeqAppendLen_11861(xs: seq, ys: seq)\n ensures |xs + ys| == |xs| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_11862","instance":11862,"id":198533,"goal":"lemma SeqAppendNil_11862(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_11863","instance":11863,"id":198534,"goal":"lemma SeqNilAppend_11863(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_11864","instance":11864,"id":198535,"goal":"lemma SeqAppendAssoc_11864(u: seq, xs: seq, ys: seq)\n ensures (u + xs) + ys == u + (xs + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_11865","instance":11865,"id":198536,"goal":"lemma SeqTakeDrop_11865(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_11866","instance":11866,"id":198537,"goal":"lemma SeqReverseLen_11866(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_11867","instance":11867,"id":198538,"goal":"lemma SeqReverseIdem_11867(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_11868","instance":11868,"id":198539,"goal":"lemma SeqMapLen_11868(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_11869","instance":11869,"id":198540,"goal":"lemma SeqFilterLe_11869(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_11870","instance":11870,"id":198541,"goal":"lemma SeqMemberAppend_11870(s: seq, t: seq)\n ensures x in s + t <==> x in s || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_11871","instance":11871,"id":198542,"goal":"lemma SeqAppendLen_11871(t: seq, xs: seq)\n ensures |t + xs| == |t| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_11872","instance":11872,"id":198543,"goal":"lemma SeqAppendNil_11872(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_11873","instance":11873,"id":198544,"goal":"lemma SeqNilAppend_11873(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_11874","instance":11874,"id":198545,"goal":"lemma SeqAppendAssoc_11874(ys: seq, u: seq, s: seq)\n ensures (ys + u) + s == ys + (u + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_11875","instance":11875,"id":198546,"goal":"lemma SeqTakeDrop_11875(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_11876","instance":11876,"id":198547,"goal":"lemma SeqReverseLen_11876(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_11877","instance":11877,"id":198548,"goal":"lemma SeqReverseIdem_11877(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_11878","instance":11878,"id":198549,"goal":"lemma SeqMapLen_11878(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_11879","instance":11879,"id":198550,"goal":"lemma SeqFilterLe_11879(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_11880","instance":11880,"id":198551,"goal":"lemma SeqMemberAppend_11880(s: seq, t: seq)\n ensures x in s + t <==> x in s || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_11881","instance":11881,"id":198552,"goal":"lemma SeqAppendLen_11881(s: seq, zs: seq)\n ensures |s + zs| == |s| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_11882","instance":11882,"id":198553,"goal":"lemma SeqAppendNil_11882(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_11883","instance":11883,"id":198554,"goal":"lemma SeqNilAppend_11883(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_11884","instance":11884,"id":198555,"goal":"lemma SeqAppendAssoc_11884(s: seq, u: seq, ys: seq)\n ensures (s + u) + ys == s + (u + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_11885","instance":11885,"id":198556,"goal":"lemma SeqTakeDrop_11885(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_11886","instance":11886,"id":198557,"goal":"lemma SeqReverseLen_11886(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_11887","instance":11887,"id":198558,"goal":"lemma SeqReverseIdem_11887(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_11888","instance":11888,"id":198559,"goal":"lemma SeqMapLen_11888(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_11889","instance":11889,"id":198560,"goal":"lemma SeqFilterLe_11889(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_11890","instance":11890,"id":198561,"goal":"lemma SeqMemberAppend_11890(xs: seq, ys: seq)\n ensures x in xs + ys <==> x in xs || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_11891","instance":11891,"id":198562,"goal":"lemma SeqAppendLen_11891(zs: seq, t: seq)\n ensures |zs + t| == |zs| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_11892","instance":11892,"id":198563,"goal":"lemma SeqAppendNil_11892(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_11893","instance":11893,"id":198564,"goal":"lemma SeqNilAppend_11893(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_11894","instance":11894,"id":198565,"goal":"lemma SeqAppendAssoc_11894(ys: seq, s: seq, t: seq)\n ensures (ys + s) + t == ys + (s + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_11895","instance":11895,"id":198566,"goal":"lemma SeqTakeDrop_11895(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_11896","instance":11896,"id":198567,"goal":"lemma SeqReverseLen_11896(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_11897","instance":11897,"id":198568,"goal":"lemma SeqReverseIdem_11897(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_11898","instance":11898,"id":198569,"goal":"lemma SeqMapLen_11898(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_11899","instance":11899,"id":198570,"goal":"lemma SeqFilterLe_11899(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_11900","instance":11900,"id":198571,"goal":"lemma SeqMemberAppend_11900(ys: seq, s: seq)\n ensures x in ys + s <==> x in ys || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_11901","instance":11901,"id":198572,"goal":"lemma SeqAppendLen_11901(ys: seq, xs: seq)\n ensures |ys + xs| == |ys| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_11902","instance":11902,"id":198573,"goal":"lemma SeqAppendNil_11902(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_11903","instance":11903,"id":198574,"goal":"lemma SeqNilAppend_11903(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_11904","instance":11904,"id":198575,"goal":"lemma SeqAppendAssoc_11904(xs: seq, zs: seq, s: seq)\n ensures (xs + zs) + s == xs + (zs + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_11905","instance":11905,"id":198576,"goal":"lemma SeqTakeDrop_11905(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_11906","instance":11906,"id":198577,"goal":"lemma SeqReverseLen_11906(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_11907","instance":11907,"id":198578,"goal":"lemma SeqReverseIdem_11907(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_11908","instance":11908,"id":198579,"goal":"lemma SeqMapLen_11908(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_11909","instance":11909,"id":198580,"goal":"lemma SeqFilterLe_11909(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_11910","instance":11910,"id":198581,"goal":"lemma SeqMemberAppend_11910(zs: seq, s: seq)\n ensures x in zs + s <==> x in zs || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_11911","instance":11911,"id":198582,"goal":"lemma SeqAppendLen_11911(zs: seq, xs: seq)\n ensures |zs + xs| == |zs| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_11912","instance":11912,"id":198583,"goal":"lemma SeqAppendNil_11912(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_11913","instance":11913,"id":198584,"goal":"lemma SeqNilAppend_11913(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_11914","instance":11914,"id":198585,"goal":"lemma SeqAppendAssoc_11914(u: seq, s: seq, ys: seq)\n ensures (u + s) + ys == u + (s + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_11915","instance":11915,"id":198586,"goal":"lemma SeqTakeDrop_11915(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_11916","instance":11916,"id":198587,"goal":"lemma SeqReverseLen_11916(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_11917","instance":11917,"id":198588,"goal":"lemma SeqReverseIdem_11917(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_11918","instance":11918,"id":198589,"goal":"lemma SeqMapLen_11918(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_11919","instance":11919,"id":198590,"goal":"lemma SeqFilterLe_11919(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_11920","instance":11920,"id":198591,"goal":"lemma SeqMemberAppend_11920(t: seq, s: seq)\n ensures x in t + s <==> x in t || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_11921","instance":11921,"id":198592,"goal":"lemma SeqAppendLen_11921(u: seq, zs: seq)\n ensures |u + zs| == |u| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_11922","instance":11922,"id":198593,"goal":"lemma SeqAppendNil_11922(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_11923","instance":11923,"id":198594,"goal":"lemma SeqNilAppend_11923(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_11924","instance":11924,"id":198595,"goal":"lemma SeqAppendAssoc_11924(ys: seq, s: seq, u: seq)\n ensures (ys + s) + u == ys + (s + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_11925","instance":11925,"id":198596,"goal":"lemma SeqTakeDrop_11925(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_11926","instance":11926,"id":198597,"goal":"lemma SeqReverseLen_11926(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_11927","instance":11927,"id":198598,"goal":"lemma SeqReverseIdem_11927(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_11928","instance":11928,"id":198599,"goal":"lemma SeqMapLen_11928(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_11929","instance":11929,"id":198600,"goal":"lemma SeqFilterLe_11929(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_11930","instance":11930,"id":198601,"goal":"lemma SeqMemberAppend_11930(s: seq, zs: seq)\n ensures x in s + zs <==> x in s || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_11931","instance":11931,"id":198602,"goal":"lemma SeqAppendLen_11931(xs: seq, s: seq)\n ensures |xs + s| == |xs| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_11932","instance":11932,"id":198603,"goal":"lemma SeqAppendNil_11932(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_11933","instance":11933,"id":198604,"goal":"lemma SeqNilAppend_11933(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_11934","instance":11934,"id":198605,"goal":"lemma SeqAppendAssoc_11934(xs: seq, s: seq, ys: seq)\n ensures (xs + s) + ys == xs + (s + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_11935","instance":11935,"id":198606,"goal":"lemma SeqTakeDrop_11935(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_11936","instance":11936,"id":198607,"goal":"lemma SeqReverseLen_11936(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_11937","instance":11937,"id":198608,"goal":"lemma SeqReverseIdem_11937(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_11938","instance":11938,"id":198609,"goal":"lemma SeqMapLen_11938(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_11939","instance":11939,"id":198610,"goal":"lemma SeqFilterLe_11939(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_11940","instance":11940,"id":198611,"goal":"lemma SeqMemberAppend_11940(zs: seq, u: seq)\n ensures x in zs + u <==> x in zs || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_11941","instance":11941,"id":198612,"goal":"lemma SeqAppendLen_11941(t: seq, s: seq)\n ensures |t + s| == |t| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_11942","instance":11942,"id":198613,"goal":"lemma SeqAppendNil_11942(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_11943","instance":11943,"id":198614,"goal":"lemma SeqNilAppend_11943(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_11944","instance":11944,"id":198615,"goal":"lemma SeqAppendAssoc_11944(u: seq, t: seq, xs: seq)\n ensures (u + t) + xs == u + (t + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_11945","instance":11945,"id":198616,"goal":"lemma SeqTakeDrop_11945(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_11946","instance":11946,"id":198617,"goal":"lemma SeqReverseLen_11946(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_11947","instance":11947,"id":198618,"goal":"lemma SeqReverseIdem_11947(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_11948","instance":11948,"id":198619,"goal":"lemma SeqMapLen_11948(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_11949","instance":11949,"id":198620,"goal":"lemma SeqFilterLe_11949(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_11950","instance":11950,"id":198621,"goal":"lemma SeqMemberAppend_11950(ys: seq, zs: seq)\n ensures x in ys + zs <==> x in ys || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_11951","instance":11951,"id":198622,"goal":"lemma SeqAppendLen_11951(u: seq, ys: seq)\n ensures |u + ys| == |u| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_11952","instance":11952,"id":198623,"goal":"lemma SeqAppendNil_11952(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_11953","instance":11953,"id":198624,"goal":"lemma SeqNilAppend_11953(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_11954","instance":11954,"id":198625,"goal":"lemma SeqAppendAssoc_11954(xs: seq, u: seq, ys: seq)\n ensures (xs + u) + ys == xs + (u + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_11955","instance":11955,"id":198626,"goal":"lemma SeqTakeDrop_11955(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_11956","instance":11956,"id":198627,"goal":"lemma SeqReverseLen_11956(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_11957","instance":11957,"id":198628,"goal":"lemma SeqReverseIdem_11957(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_11958","instance":11958,"id":198629,"goal":"lemma SeqMapLen_11958(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_11959","instance":11959,"id":198630,"goal":"lemma SeqFilterLe_11959(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_11960","instance":11960,"id":198631,"goal":"lemma SeqMemberAppend_11960(zs: seq, xs: seq)\n ensures x in zs + xs <==> x in zs || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_11961","instance":11961,"id":198632,"goal":"lemma SeqAppendLen_11961(xs: seq, s: seq)\n ensures |xs + s| == |xs| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_11962","instance":11962,"id":198633,"goal":"lemma SeqAppendNil_11962(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_11963","instance":11963,"id":198634,"goal":"lemma SeqNilAppend_11963(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_11964","instance":11964,"id":198635,"goal":"lemma SeqAppendAssoc_11964(u: seq, zs: seq, ys: seq)\n ensures (u + zs) + ys == u + (zs + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_11965","instance":11965,"id":198636,"goal":"lemma SeqTakeDrop_11965(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_11966","instance":11966,"id":198637,"goal":"lemma SeqReverseLen_11966(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_11967","instance":11967,"id":198638,"goal":"lemma SeqReverseIdem_11967(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_11968","instance":11968,"id":198639,"goal":"lemma SeqMapLen_11968(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_11969","instance":11969,"id":198640,"goal":"lemma SeqFilterLe_11969(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_11970","instance":11970,"id":198641,"goal":"lemma SeqMemberAppend_11970(t: seq, ys: seq)\n ensures x in t + ys <==> x in t || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_11971","instance":11971,"id":198642,"goal":"lemma SeqAppendLen_11971(u: seq, xs: seq)\n ensures |u + xs| == |u| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_11972","instance":11972,"id":198643,"goal":"lemma SeqAppendNil_11972(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_11973","instance":11973,"id":198644,"goal":"lemma SeqNilAppend_11973(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_11974","instance":11974,"id":198645,"goal":"lemma SeqAppendAssoc_11974(s: seq, ys: seq, zs: seq)\n ensures (s + ys) + zs == s + (ys + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_11975","instance":11975,"id":198646,"goal":"lemma SeqTakeDrop_11975(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_11976","instance":11976,"id":198647,"goal":"lemma SeqReverseLen_11976(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_11977","instance":11977,"id":198648,"goal":"lemma SeqReverseIdem_11977(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_11978","instance":11978,"id":198649,"goal":"lemma SeqMapLen_11978(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_11979","instance":11979,"id":198650,"goal":"lemma SeqFilterLe_11979(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_11980","instance":11980,"id":198651,"goal":"lemma SeqMemberAppend_11980(ys: seq, u: seq)\n ensures x in ys + u <==> x in ys || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_11981","instance":11981,"id":198652,"goal":"lemma SeqAppendLen_11981(zs: seq, t: seq)\n ensures |zs + t| == |zs| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_11982","instance":11982,"id":198653,"goal":"lemma SeqAppendNil_11982(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_11983","instance":11983,"id":198654,"goal":"lemma SeqNilAppend_11983(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_11984","instance":11984,"id":198655,"goal":"lemma SeqAppendAssoc_11984(zs: seq, u: seq, s: seq)\n ensures (zs + u) + s == zs + (u + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_11985","instance":11985,"id":198656,"goal":"lemma SeqTakeDrop_11985(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_11986","instance":11986,"id":198657,"goal":"lemma SeqReverseLen_11986(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_11987","instance":11987,"id":198658,"goal":"lemma SeqReverseIdem_11987(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_11988","instance":11988,"id":198659,"goal":"lemma SeqMapLen_11988(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_11989","instance":11989,"id":198660,"goal":"lemma SeqFilterLe_11989(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_11990","instance":11990,"id":198661,"goal":"lemma SeqMemberAppend_11990(u: seq, xs: seq)\n ensures x in u + xs <==> x in u || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_11991","instance":11991,"id":198662,"goal":"lemma SeqAppendLen_11991(zs: seq, ys: seq)\n ensures |zs + ys| == |zs| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_11992","instance":11992,"id":198663,"goal":"lemma SeqAppendNil_11992(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_11993","instance":11993,"id":198664,"goal":"lemma SeqNilAppend_11993(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_11994","instance":11994,"id":198665,"goal":"lemma SeqAppendAssoc_11994(u: seq, xs: seq, s: seq)\n ensures (u + xs) + s == u + (xs + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_11995","instance":11995,"id":198666,"goal":"lemma SeqTakeDrop_11995(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_11996","instance":11996,"id":198667,"goal":"lemma SeqReverseLen_11996(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_11997","instance":11997,"id":198668,"goal":"lemma SeqReverseIdem_11997(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_11998","instance":11998,"id":198669,"goal":"lemma SeqMapLen_11998(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_11999","instance":11999,"id":198670,"goal":"lemma SeqFilterLe_11999(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_12000","instance":12000,"id":198671,"goal":"lemma SeqMemberAppend_12000(ys: seq, zs: seq)\n ensures x in ys + zs <==> x in ys || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_12001","instance":12001,"id":198672,"goal":"lemma SeqAppendLen_12001(u: seq, xs: seq)\n ensures |u + xs| == |u| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_12002","instance":12002,"id":198673,"goal":"lemma SeqAppendNil_12002(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_12003","instance":12003,"id":198674,"goal":"lemma SeqNilAppend_12003(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_12004","instance":12004,"id":198675,"goal":"lemma SeqAppendAssoc_12004(zs: seq, ys: seq, s: seq)\n ensures (zs + ys) + s == zs + (ys + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_12005","instance":12005,"id":198676,"goal":"lemma SeqTakeDrop_12005(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_12006","instance":12006,"id":198677,"goal":"lemma SeqReverseLen_12006(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_12007","instance":12007,"id":198678,"goal":"lemma SeqReverseIdem_12007(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_12008","instance":12008,"id":198679,"goal":"lemma SeqMapLen_12008(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_12009","instance":12009,"id":198680,"goal":"lemma SeqFilterLe_12009(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_12010","instance":12010,"id":198681,"goal":"lemma SeqMemberAppend_12010(s: seq, u: seq)\n ensures x in s + u <==> x in s || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_12011","instance":12011,"id":198682,"goal":"lemma SeqAppendLen_12011(ys: seq, u: seq)\n ensures |ys + u| == |ys| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_12012","instance":12012,"id":198683,"goal":"lemma SeqAppendNil_12012(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_12013","instance":12013,"id":198684,"goal":"lemma SeqNilAppend_12013(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_12014","instance":12014,"id":198685,"goal":"lemma SeqAppendAssoc_12014(xs: seq, zs: seq, s: seq)\n ensures (xs + zs) + s == xs + (zs + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_12015","instance":12015,"id":198686,"goal":"lemma SeqTakeDrop_12015(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_12016","instance":12016,"id":198687,"goal":"lemma SeqReverseLen_12016(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_12017","instance":12017,"id":198688,"goal":"lemma SeqReverseIdem_12017(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_12018","instance":12018,"id":198689,"goal":"lemma SeqMapLen_12018(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_12019","instance":12019,"id":198690,"goal":"lemma SeqFilterLe_12019(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_12020","instance":12020,"id":198691,"goal":"lemma SeqMemberAppend_12020(xs: seq, zs: seq)\n ensures x in xs + zs <==> x in xs || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_12021","instance":12021,"id":198692,"goal":"lemma SeqAppendLen_12021(xs: seq, t: seq)\n ensures |xs + t| == |xs| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_12022","instance":12022,"id":198693,"goal":"lemma SeqAppendNil_12022(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_12023","instance":12023,"id":198694,"goal":"lemma SeqNilAppend_12023(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_12024","instance":12024,"id":198695,"goal":"lemma SeqAppendAssoc_12024(zs: seq, s: seq, t: seq)\n ensures (zs + s) + t == zs + (s + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_12025","instance":12025,"id":198696,"goal":"lemma SeqTakeDrop_12025(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_12026","instance":12026,"id":198697,"goal":"lemma SeqReverseLen_12026(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_12027","instance":12027,"id":198698,"goal":"lemma SeqReverseIdem_12027(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_12028","instance":12028,"id":198699,"goal":"lemma SeqMapLen_12028(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_12029","instance":12029,"id":198700,"goal":"lemma SeqFilterLe_12029(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_12030","instance":12030,"id":198701,"goal":"lemma SeqMemberAppend_12030(ys: seq, t: seq)\n ensures x in ys + t <==> x in ys || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_12031","instance":12031,"id":198702,"goal":"lemma SeqAppendLen_12031(s: seq, u: seq)\n ensures |s + u| == |s| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_12032","instance":12032,"id":198703,"goal":"lemma SeqAppendNil_12032(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_12033","instance":12033,"id":198704,"goal":"lemma SeqNilAppend_12033(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_12034","instance":12034,"id":198705,"goal":"lemma SeqAppendAssoc_12034(u: seq, t: seq, s: seq)\n ensures (u + t) + s == u + (t + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_12035","instance":12035,"id":198706,"goal":"lemma SeqTakeDrop_12035(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_12036","instance":12036,"id":198707,"goal":"lemma SeqReverseLen_12036(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_12037","instance":12037,"id":198708,"goal":"lemma SeqReverseIdem_12037(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_12038","instance":12038,"id":198709,"goal":"lemma SeqMapLen_12038(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_12039","instance":12039,"id":198710,"goal":"lemma SeqFilterLe_12039(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_12040","instance":12040,"id":198711,"goal":"lemma SeqMemberAppend_12040(s: seq, u: seq)\n ensures x in s + u <==> x in s || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_12041","instance":12041,"id":198712,"goal":"lemma SeqAppendLen_12041(ys: seq, zs: seq)\n ensures |ys + zs| == |ys| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_12042","instance":12042,"id":198713,"goal":"lemma SeqAppendNil_12042(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_12043","instance":12043,"id":198714,"goal":"lemma SeqNilAppend_12043(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_12044","instance":12044,"id":198715,"goal":"lemma SeqAppendAssoc_12044(xs: seq, u: seq, t: seq)\n ensures (xs + u) + t == xs + (u + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_12045","instance":12045,"id":198716,"goal":"lemma SeqTakeDrop_12045(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_12046","instance":12046,"id":198717,"goal":"lemma SeqReverseLen_12046(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_12047","instance":12047,"id":198718,"goal":"lemma SeqReverseIdem_12047(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_12048","instance":12048,"id":198719,"goal":"lemma SeqMapLen_12048(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_12049","instance":12049,"id":198720,"goal":"lemma SeqFilterLe_12049(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_12050","instance":12050,"id":198721,"goal":"lemma SeqMemberAppend_12050(u: seq, xs: seq)\n ensures x in u + xs <==> x in u || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_12051","instance":12051,"id":198722,"goal":"lemma SeqAppendLen_12051(ys: seq, t: seq)\n ensures |ys + t| == |ys| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_12052","instance":12052,"id":198723,"goal":"lemma SeqAppendNil_12052(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_12053","instance":12053,"id":198724,"goal":"lemma SeqNilAppend_12053(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_12054","instance":12054,"id":198725,"goal":"lemma SeqAppendAssoc_12054(u: seq, zs: seq, s: seq)\n ensures (u + zs) + s == u + (zs + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_12055","instance":12055,"id":198726,"goal":"lemma SeqTakeDrop_12055(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_12056","instance":12056,"id":198727,"goal":"lemma SeqReverseLen_12056(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_12057","instance":12057,"id":198728,"goal":"lemma SeqReverseIdem_12057(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_12058","instance":12058,"id":198729,"goal":"lemma SeqMapLen_12058(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_12059","instance":12059,"id":198730,"goal":"lemma SeqFilterLe_12059(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_12060","instance":12060,"id":198731,"goal":"lemma SeqMemberAppend_12060(ys: seq, s: seq)\n ensures x in ys + s <==> x in ys || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_12061","instance":12061,"id":198732,"goal":"lemma SeqAppendLen_12061(xs: seq, u: seq)\n ensures |xs + u| == |xs| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_12062","instance":12062,"id":198733,"goal":"lemma SeqAppendNil_12062(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_12063","instance":12063,"id":198734,"goal":"lemma SeqNilAppend_12063(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_12064","instance":12064,"id":198735,"goal":"lemma SeqAppendAssoc_12064(u: seq, t: seq, s: seq)\n ensures (u + t) + s == u + (t + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_12065","instance":12065,"id":198736,"goal":"lemma SeqTakeDrop_12065(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_12066","instance":12066,"id":198737,"goal":"lemma SeqReverseLen_12066(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_12067","instance":12067,"id":198738,"goal":"lemma SeqReverseIdem_12067(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_12068","instance":12068,"id":198739,"goal":"lemma SeqMapLen_12068(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_12069","instance":12069,"id":198740,"goal":"lemma SeqFilterLe_12069(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_12070","instance":12070,"id":198741,"goal":"lemma SeqMemberAppend_12070(u: seq, zs: seq)\n ensures x in u + zs <==> x in u || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_12071","instance":12071,"id":198742,"goal":"lemma SeqAppendLen_12071(xs: seq, zs: seq)\n ensures |xs + zs| == |xs| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_12072","instance":12072,"id":198743,"goal":"lemma SeqAppendNil_12072(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_12073","instance":12073,"id":198744,"goal":"lemma SeqNilAppend_12073(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_12074","instance":12074,"id":198745,"goal":"lemma SeqAppendAssoc_12074(xs: seq, ys: seq, zs: seq)\n ensures (xs + ys) + zs == xs + (ys + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_12075","instance":12075,"id":198746,"goal":"lemma SeqTakeDrop_12075(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_12076","instance":12076,"id":198747,"goal":"lemma SeqReverseLen_12076(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_12077","instance":12077,"id":198748,"goal":"lemma SeqReverseIdem_12077(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_12078","instance":12078,"id":198749,"goal":"lemma SeqMapLen_12078(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_12079","instance":12079,"id":198750,"goal":"lemma SeqFilterLe_12079(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_12080","instance":12080,"id":198751,"goal":"lemma SeqMemberAppend_12080(ys: seq, zs: seq)\n ensures x in ys + zs <==> x in ys || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_12081","instance":12081,"id":198752,"goal":"lemma SeqAppendLen_12081(u: seq, ys: seq)\n ensures |u + ys| == |u| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_12082","instance":12082,"id":198753,"goal":"lemma SeqAppendNil_12082(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_12083","instance":12083,"id":198754,"goal":"lemma SeqNilAppend_12083(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_12084","instance":12084,"id":198755,"goal":"lemma SeqAppendAssoc_12084(zs: seq, ys: seq, s: seq)\n ensures (zs + ys) + s == zs + (ys + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_12085","instance":12085,"id":198756,"goal":"lemma SeqTakeDrop_12085(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_12086","instance":12086,"id":198757,"goal":"lemma SeqReverseLen_12086(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_12087","instance":12087,"id":198758,"goal":"lemma SeqReverseIdem_12087(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_12088","instance":12088,"id":198759,"goal":"lemma SeqMapLen_12088(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_12089","instance":12089,"id":198760,"goal":"lemma SeqFilterLe_12089(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_12090","instance":12090,"id":198761,"goal":"lemma SeqMemberAppend_12090(u: seq, xs: seq)\n ensures x in u + xs <==> x in u || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_12091","instance":12091,"id":198762,"goal":"lemma SeqAppendLen_12091(zs: seq, xs: seq)\n ensures |zs + xs| == |zs| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_12092","instance":12092,"id":198763,"goal":"lemma SeqAppendNil_12092(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_12093","instance":12093,"id":198764,"goal":"lemma SeqNilAppend_12093(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_12094","instance":12094,"id":198765,"goal":"lemma SeqAppendAssoc_12094(xs: seq, u: seq, zs: seq)\n ensures (xs + u) + zs == xs + (u + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_12095","instance":12095,"id":198766,"goal":"lemma SeqTakeDrop_12095(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_12096","instance":12096,"id":198767,"goal":"lemma SeqReverseLen_12096(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_12097","instance":12097,"id":198768,"goal":"lemma SeqReverseIdem_12097(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_12098","instance":12098,"id":198769,"goal":"lemma SeqMapLen_12098(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_12099","instance":12099,"id":198770,"goal":"lemma SeqFilterLe_12099(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_12100","instance":12100,"id":198771,"goal":"lemma SeqMemberAppend_12100(s: seq, u: seq)\n ensures x in s + u <==> x in s || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_12101","instance":12101,"id":198772,"goal":"lemma SeqAppendLen_12101(s: seq, u: seq)\n ensures |s + u| == |s| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_12102","instance":12102,"id":198773,"goal":"lemma SeqAppendNil_12102(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_12103","instance":12103,"id":198774,"goal":"lemma SeqNilAppend_12103(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_12104","instance":12104,"id":198775,"goal":"lemma SeqAppendAssoc_12104(xs: seq, s: seq, ys: seq)\n ensures (xs + s) + ys == xs + (s + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_12105","instance":12105,"id":198776,"goal":"lemma SeqTakeDrop_12105(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_12106","instance":12106,"id":198777,"goal":"lemma SeqReverseLen_12106(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_12107","instance":12107,"id":198778,"goal":"lemma SeqReverseIdem_12107(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_12108","instance":12108,"id":198779,"goal":"lemma SeqMapLen_12108(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_12109","instance":12109,"id":198780,"goal":"lemma SeqFilterLe_12109(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_12110","instance":12110,"id":198781,"goal":"lemma SeqMemberAppend_12110(t: seq, xs: seq)\n ensures x in t + xs <==> x in t || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_12111","instance":12111,"id":198782,"goal":"lemma SeqAppendLen_12111(zs: seq, t: seq)\n ensures |zs + t| == |zs| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_12112","instance":12112,"id":198783,"goal":"lemma SeqAppendNil_12112(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_12113","instance":12113,"id":198784,"goal":"lemma SeqNilAppend_12113(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_12114","instance":12114,"id":198785,"goal":"lemma SeqAppendAssoc_12114(xs: seq, t: seq, zs: seq)\n ensures (xs + t) + zs == xs + (t + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_12115","instance":12115,"id":198786,"goal":"lemma SeqTakeDrop_12115(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_12116","instance":12116,"id":198787,"goal":"lemma SeqReverseLen_12116(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_12117","instance":12117,"id":198788,"goal":"lemma SeqReverseIdem_12117(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_12118","instance":12118,"id":198789,"goal":"lemma SeqMapLen_12118(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_12119","instance":12119,"id":198790,"goal":"lemma SeqFilterLe_12119(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_12120","instance":12120,"id":198791,"goal":"lemma SeqMemberAppend_12120(ys: seq, u: seq)\n ensures x in ys + u <==> x in ys || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_12121","instance":12121,"id":198792,"goal":"lemma SeqAppendLen_12121(t: seq, s: seq)\n ensures |t + s| == |t| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_12122","instance":12122,"id":198793,"goal":"lemma SeqAppendNil_12122(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_12123","instance":12123,"id":198794,"goal":"lemma SeqNilAppend_12123(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_12124","instance":12124,"id":198795,"goal":"lemma SeqAppendAssoc_12124(ys: seq, xs: seq, t: seq)\n ensures (ys + xs) + t == ys + (xs + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_12125","instance":12125,"id":198796,"goal":"lemma SeqTakeDrop_12125(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_12126","instance":12126,"id":198797,"goal":"lemma SeqReverseLen_12126(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_12127","instance":12127,"id":198798,"goal":"lemma SeqReverseIdem_12127(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_12128","instance":12128,"id":198799,"goal":"lemma SeqMapLen_12128(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_12129","instance":12129,"id":198800,"goal":"lemma SeqFilterLe_12129(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_12130","instance":12130,"id":198801,"goal":"lemma SeqMemberAppend_12130(zs: seq, u: seq)\n ensures x in zs + u <==> x in zs || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_12131","instance":12131,"id":198802,"goal":"lemma SeqAppendLen_12131(zs: seq, xs: seq)\n ensures |zs + xs| == |zs| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_12132","instance":12132,"id":198803,"goal":"lemma SeqAppendNil_12132(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_12133","instance":12133,"id":198804,"goal":"lemma SeqNilAppend_12133(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_12134","instance":12134,"id":198805,"goal":"lemma SeqAppendAssoc_12134(ys: seq, xs: seq, t: seq)\n ensures (ys + xs) + t == ys + (xs + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_12135","instance":12135,"id":198806,"goal":"lemma SeqTakeDrop_12135(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_12136","instance":12136,"id":198807,"goal":"lemma SeqReverseLen_12136(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_12137","instance":12137,"id":198808,"goal":"lemma SeqReverseIdem_12137(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_12138","instance":12138,"id":198809,"goal":"lemma SeqMapLen_12138(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_12139","instance":12139,"id":198810,"goal":"lemma SeqFilterLe_12139(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_12140","instance":12140,"id":198811,"goal":"lemma SeqMemberAppend_12140(u: seq, s: seq)\n ensures x in u + s <==> x in u || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_12141","instance":12141,"id":198812,"goal":"lemma SeqAppendLen_12141(u: seq, t: seq)\n ensures |u + t| == |u| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_12142","instance":12142,"id":198813,"goal":"lemma SeqAppendNil_12142(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_12143","instance":12143,"id":198814,"goal":"lemma SeqNilAppend_12143(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_12144","instance":12144,"id":198815,"goal":"lemma SeqAppendAssoc_12144(xs: seq, zs: seq, s: seq)\n ensures (xs + zs) + s == xs + (zs + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_12145","instance":12145,"id":198816,"goal":"lemma SeqTakeDrop_12145(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_12146","instance":12146,"id":198817,"goal":"lemma SeqReverseLen_12146(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_12147","instance":12147,"id":198818,"goal":"lemma SeqReverseIdem_12147(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_12148","instance":12148,"id":198819,"goal":"lemma SeqMapLen_12148(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_12149","instance":12149,"id":198820,"goal":"lemma SeqFilterLe_12149(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_12150","instance":12150,"id":198821,"goal":"lemma SeqMemberAppend_12150(xs: seq, s: seq)\n ensures x in xs + s <==> x in xs || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_12151","instance":12151,"id":198822,"goal":"lemma SeqAppendLen_12151(u: seq, zs: seq)\n ensures |u + zs| == |u| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_12152","instance":12152,"id":198823,"goal":"lemma SeqAppendNil_12152(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_12153","instance":12153,"id":198824,"goal":"lemma SeqNilAppend_12153(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_12154","instance":12154,"id":198825,"goal":"lemma SeqAppendAssoc_12154(t: seq, zs: seq, s: seq)\n ensures (t + zs) + s == t + (zs + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_12155","instance":12155,"id":198826,"goal":"lemma SeqTakeDrop_12155(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_12156","instance":12156,"id":198827,"goal":"lemma SeqReverseLen_12156(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_12157","instance":12157,"id":198828,"goal":"lemma SeqReverseIdem_12157(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_12158","instance":12158,"id":198829,"goal":"lemma SeqMapLen_12158(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_12159","instance":12159,"id":198830,"goal":"lemma SeqFilterLe_12159(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_12160","instance":12160,"id":198831,"goal":"lemma SeqMemberAppend_12160(ys: seq, zs: seq)\n ensures x in ys + zs <==> x in ys || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_12161","instance":12161,"id":198832,"goal":"lemma SeqAppendLen_12161(ys: seq, t: seq)\n ensures |ys + t| == |ys| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_12162","instance":12162,"id":198833,"goal":"lemma SeqAppendNil_12162(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_12163","instance":12163,"id":198834,"goal":"lemma SeqNilAppend_12163(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_12164","instance":12164,"id":198835,"goal":"lemma SeqAppendAssoc_12164(t: seq, u: seq, s: seq)\n ensures (t + u) + s == t + (u + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_12165","instance":12165,"id":198836,"goal":"lemma SeqTakeDrop_12165(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_12166","instance":12166,"id":198837,"goal":"lemma SeqReverseLen_12166(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_12167","instance":12167,"id":198838,"goal":"lemma SeqReverseIdem_12167(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_12168","instance":12168,"id":198839,"goal":"lemma SeqMapLen_12168(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_12169","instance":12169,"id":198840,"goal":"lemma SeqFilterLe_12169(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_12170","instance":12170,"id":198841,"goal":"lemma SeqMemberAppend_12170(xs: seq, ys: seq)\n ensures x in xs + ys <==> x in xs || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_12171","instance":12171,"id":198842,"goal":"lemma SeqAppendLen_12171(s: seq, t: seq)\n ensures |s + t| == |s| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_12172","instance":12172,"id":198843,"goal":"lemma SeqAppendNil_12172(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_12173","instance":12173,"id":198844,"goal":"lemma SeqNilAppend_12173(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_12174","instance":12174,"id":198845,"goal":"lemma SeqAppendAssoc_12174(xs: seq, zs: seq, u: seq)\n ensures (xs + zs) + u == xs + (zs + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_12175","instance":12175,"id":198846,"goal":"lemma SeqTakeDrop_12175(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_12176","instance":12176,"id":198847,"goal":"lemma SeqReverseLen_12176(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_12177","instance":12177,"id":198848,"goal":"lemma SeqReverseIdem_12177(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_12178","instance":12178,"id":198849,"goal":"lemma SeqMapLen_12178(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_12179","instance":12179,"id":198850,"goal":"lemma SeqFilterLe_12179(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_12180","instance":12180,"id":198851,"goal":"lemma SeqMemberAppend_12180(xs: seq, u: seq)\n ensures x in xs + u <==> x in xs || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_12181","instance":12181,"id":198852,"goal":"lemma SeqAppendLen_12181(t: seq, xs: seq)\n ensures |t + xs| == |t| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_12182","instance":12182,"id":198853,"goal":"lemma SeqAppendNil_12182(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_12183","instance":12183,"id":198854,"goal":"lemma SeqNilAppend_12183(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_12184","instance":12184,"id":198855,"goal":"lemma SeqAppendAssoc_12184(ys: seq, s: seq, xs: seq)\n ensures (ys + s) + xs == ys + (s + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_12185","instance":12185,"id":198856,"goal":"lemma SeqTakeDrop_12185(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_12186","instance":12186,"id":198857,"goal":"lemma SeqReverseLen_12186(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_12187","instance":12187,"id":198858,"goal":"lemma SeqReverseIdem_12187(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_12188","instance":12188,"id":198859,"goal":"lemma SeqMapLen_12188(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_12189","instance":12189,"id":198860,"goal":"lemma SeqFilterLe_12189(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_12190","instance":12190,"id":198861,"goal":"lemma SeqMemberAppend_12190(zs: seq, ys: seq)\n ensures x in zs + ys <==> x in zs || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_12191","instance":12191,"id":198862,"goal":"lemma SeqAppendLen_12191(t: seq, xs: seq)\n ensures |t + xs| == |t| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_12192","instance":12192,"id":198863,"goal":"lemma SeqAppendNil_12192(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_12193","instance":12193,"id":198864,"goal":"lemma SeqNilAppend_12193(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_12194","instance":12194,"id":198865,"goal":"lemma SeqAppendAssoc_12194(s: seq, xs: seq, ys: seq)\n ensures (s + xs) + ys == s + (xs + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_12195","instance":12195,"id":198866,"goal":"lemma SeqTakeDrop_12195(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_12196","instance":12196,"id":198867,"goal":"lemma SeqReverseLen_12196(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_12197","instance":12197,"id":198868,"goal":"lemma SeqReverseIdem_12197(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_12198","instance":12198,"id":198869,"goal":"lemma SeqMapLen_12198(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_12199","instance":12199,"id":198870,"goal":"lemma SeqFilterLe_12199(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_12200","instance":12200,"id":198871,"goal":"lemma SeqMemberAppend_12200(zs: seq, xs: seq)\n ensures x in zs + xs <==> x in zs || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_12201","instance":12201,"id":198872,"goal":"lemma SeqAppendLen_12201(u: seq, xs: seq)\n ensures |u + xs| == |u| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_12202","instance":12202,"id":198873,"goal":"lemma SeqAppendNil_12202(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_12203","instance":12203,"id":198874,"goal":"lemma SeqNilAppend_12203(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_12204","instance":12204,"id":198875,"goal":"lemma SeqAppendAssoc_12204(xs: seq, zs: seq, s: seq)\n ensures (xs + zs) + s == xs + (zs + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_12205","instance":12205,"id":198876,"goal":"lemma SeqTakeDrop_12205(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_12206","instance":12206,"id":198877,"goal":"lemma SeqReverseLen_12206(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_12207","instance":12207,"id":198878,"goal":"lemma SeqReverseIdem_12207(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_12208","instance":12208,"id":198879,"goal":"lemma SeqMapLen_12208(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_12209","instance":12209,"id":198880,"goal":"lemma SeqFilterLe_12209(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_12210","instance":12210,"id":198881,"goal":"lemma SeqMemberAppend_12210(ys: seq, s: seq)\n ensures x in ys + s <==> x in ys || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_12211","instance":12211,"id":198882,"goal":"lemma SeqAppendLen_12211(t: seq, zs: seq)\n ensures |t + zs| == |t| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_12212","instance":12212,"id":198883,"goal":"lemma SeqAppendNil_12212(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_12213","instance":12213,"id":198884,"goal":"lemma SeqNilAppend_12213(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_12214","instance":12214,"id":198885,"goal":"lemma SeqAppendAssoc_12214(xs: seq, zs: seq, u: seq)\n ensures (xs + zs) + u == xs + (zs + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_12215","instance":12215,"id":198886,"goal":"lemma SeqTakeDrop_12215(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_12216","instance":12216,"id":198887,"goal":"lemma SeqReverseLen_12216(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_12217","instance":12217,"id":198888,"goal":"lemma SeqReverseIdem_12217(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_12218","instance":12218,"id":198889,"goal":"lemma SeqMapLen_12218(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_12219","instance":12219,"id":198890,"goal":"lemma SeqFilterLe_12219(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_12220","instance":12220,"id":198891,"goal":"lemma SeqMemberAppend_12220(u: seq, t: seq)\n ensures x in u + t <==> x in u || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_12221","instance":12221,"id":198892,"goal":"lemma SeqAppendLen_12221(xs: seq, zs: seq)\n ensures |xs + zs| == |xs| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_12222","instance":12222,"id":198893,"goal":"lemma SeqAppendNil_12222(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_12223","instance":12223,"id":198894,"goal":"lemma SeqNilAppend_12223(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_12224","instance":12224,"id":198895,"goal":"lemma SeqAppendAssoc_12224(t: seq, xs: seq, ys: seq)\n ensures (t + xs) + ys == t + (xs + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_12225","instance":12225,"id":198896,"goal":"lemma SeqTakeDrop_12225(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_12226","instance":12226,"id":198897,"goal":"lemma SeqReverseLen_12226(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_12227","instance":12227,"id":198898,"goal":"lemma SeqReverseIdem_12227(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_12228","instance":12228,"id":198899,"goal":"lemma SeqMapLen_12228(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_12229","instance":12229,"id":198900,"goal":"lemma SeqFilterLe_12229(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_12230","instance":12230,"id":198901,"goal":"lemma SeqMemberAppend_12230(t: seq, ys: seq)\n ensures x in t + ys <==> x in t || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_12231","instance":12231,"id":198902,"goal":"lemma SeqAppendLen_12231(xs: seq, zs: seq)\n ensures |xs + zs| == |xs| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_12232","instance":12232,"id":198903,"goal":"lemma SeqAppendNil_12232(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_12233","instance":12233,"id":198904,"goal":"lemma SeqNilAppend_12233(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_12234","instance":12234,"id":198905,"goal":"lemma SeqAppendAssoc_12234(xs: seq, t: seq, u: seq)\n ensures (xs + t) + u == xs + (t + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_12235","instance":12235,"id":198906,"goal":"lemma SeqTakeDrop_12235(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_12236","instance":12236,"id":198907,"goal":"lemma SeqReverseLen_12236(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_12237","instance":12237,"id":198908,"goal":"lemma SeqReverseIdem_12237(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_12238","instance":12238,"id":198909,"goal":"lemma SeqMapLen_12238(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_12239","instance":12239,"id":198910,"goal":"lemma SeqFilterLe_12239(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_12240","instance":12240,"id":198911,"goal":"lemma SeqMemberAppend_12240(zs: seq, t: seq)\n ensures x in zs + t <==> x in zs || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_12241","instance":12241,"id":198912,"goal":"lemma SeqAppendLen_12241(ys: seq, zs: seq)\n ensures |ys + zs| == |ys| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_12242","instance":12242,"id":198913,"goal":"lemma SeqAppendNil_12242(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_12243","instance":12243,"id":198914,"goal":"lemma SeqNilAppend_12243(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_12244","instance":12244,"id":198915,"goal":"lemma SeqAppendAssoc_12244(ys: seq, s: seq, xs: seq)\n ensures (ys + s) + xs == ys + (s + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_12245","instance":12245,"id":198916,"goal":"lemma SeqTakeDrop_12245(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_12246","instance":12246,"id":198917,"goal":"lemma SeqReverseLen_12246(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_12247","instance":12247,"id":198918,"goal":"lemma SeqReverseIdem_12247(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_12248","instance":12248,"id":198919,"goal":"lemma SeqMapLen_12248(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_12249","instance":12249,"id":198920,"goal":"lemma SeqFilterLe_12249(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_12250","instance":12250,"id":198921,"goal":"lemma SeqMemberAppend_12250(xs: seq, ys: seq)\n ensures x in xs + ys <==> x in xs || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_12251","instance":12251,"id":198922,"goal":"lemma SeqAppendLen_12251(ys: seq, zs: seq)\n ensures |ys + zs| == |ys| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_12252","instance":12252,"id":198923,"goal":"lemma SeqAppendNil_12252(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_12253","instance":12253,"id":198924,"goal":"lemma SeqNilAppend_12253(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_12254","instance":12254,"id":198925,"goal":"lemma SeqAppendAssoc_12254(t: seq, u: seq, s: seq)\n ensures (t + u) + s == t + (u + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_12255","instance":12255,"id":198926,"goal":"lemma SeqTakeDrop_12255(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_12256","instance":12256,"id":198927,"goal":"lemma SeqReverseLen_12256(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_12257","instance":12257,"id":198928,"goal":"lemma SeqReverseIdem_12257(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_12258","instance":12258,"id":198929,"goal":"lemma SeqMapLen_12258(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_12259","instance":12259,"id":198930,"goal":"lemma SeqFilterLe_12259(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_12260","instance":12260,"id":198931,"goal":"lemma SeqMemberAppend_12260(ys: seq, zs: seq)\n ensures x in ys + zs <==> x in ys || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_12261","instance":12261,"id":198932,"goal":"lemma SeqAppendLen_12261(zs: seq, ys: seq)\n ensures |zs + ys| == |zs| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_12262","instance":12262,"id":198933,"goal":"lemma SeqAppendNil_12262(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_12263","instance":12263,"id":198934,"goal":"lemma SeqNilAppend_12263(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_12264","instance":12264,"id":198935,"goal":"lemma SeqAppendAssoc_12264(u: seq, zs: seq, xs: seq)\n ensures (u + zs) + xs == u + (zs + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_12265","instance":12265,"id":198936,"goal":"lemma SeqTakeDrop_12265(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_12266","instance":12266,"id":198937,"goal":"lemma SeqReverseLen_12266(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_12267","instance":12267,"id":198938,"goal":"lemma SeqReverseIdem_12267(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_12268","instance":12268,"id":198939,"goal":"lemma SeqMapLen_12268(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_12269","instance":12269,"id":198940,"goal":"lemma SeqFilterLe_12269(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_12270","instance":12270,"id":198941,"goal":"lemma SeqMemberAppend_12270(ys: seq, zs: seq)\n ensures x in ys + zs <==> x in ys || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_12271","instance":12271,"id":198942,"goal":"lemma SeqAppendLen_12271(t: seq, s: seq)\n ensures |t + s| == |t| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_12272","instance":12272,"id":198943,"goal":"lemma SeqAppendNil_12272(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_12273","instance":12273,"id":198944,"goal":"lemma SeqNilAppend_12273(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_12274","instance":12274,"id":198945,"goal":"lemma SeqAppendAssoc_12274(t: seq, zs: seq, u: seq)\n ensures (t + zs) + u == t + (zs + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_12275","instance":12275,"id":198946,"goal":"lemma SeqTakeDrop_12275(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_12276","instance":12276,"id":198947,"goal":"lemma SeqReverseLen_12276(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_12277","instance":12277,"id":198948,"goal":"lemma SeqReverseIdem_12277(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_12278","instance":12278,"id":198949,"goal":"lemma SeqMapLen_12278(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_12279","instance":12279,"id":198950,"goal":"lemma SeqFilterLe_12279(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_12280","instance":12280,"id":198951,"goal":"lemma SeqMemberAppend_12280(s: seq, u: seq)\n ensures x in s + u <==> x in s || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_12281","instance":12281,"id":198952,"goal":"lemma SeqAppendLen_12281(s: seq, ys: seq)\n ensures |s + ys| == |s| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_12282","instance":12282,"id":198953,"goal":"lemma SeqAppendNil_12282(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_12283","instance":12283,"id":198954,"goal":"lemma SeqNilAppend_12283(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_12284","instance":12284,"id":198955,"goal":"lemma SeqAppendAssoc_12284(xs: seq, t: seq, ys: seq)\n ensures (xs + t) + ys == xs + (t + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_12285","instance":12285,"id":198956,"goal":"lemma SeqTakeDrop_12285(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_12286","instance":12286,"id":198957,"goal":"lemma SeqReverseLen_12286(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_12287","instance":12287,"id":198958,"goal":"lemma SeqReverseIdem_12287(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_12288","instance":12288,"id":198959,"goal":"lemma SeqMapLen_12288(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_12289","instance":12289,"id":198960,"goal":"lemma SeqFilterLe_12289(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_12290","instance":12290,"id":198961,"goal":"lemma SeqMemberAppend_12290(t: seq, zs: seq)\n ensures x in t + zs <==> x in t || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_12291","instance":12291,"id":198962,"goal":"lemma SeqAppendLen_12291(s: seq, u: seq)\n ensures |s + u| == |s| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_12292","instance":12292,"id":198963,"goal":"lemma SeqAppendNil_12292(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_12293","instance":12293,"id":198964,"goal":"lemma SeqNilAppend_12293(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_12294","instance":12294,"id":198965,"goal":"lemma SeqAppendAssoc_12294(ys: seq, xs: seq, zs: seq)\n ensures (ys + xs) + zs == ys + (xs + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_12295","instance":12295,"id":198966,"goal":"lemma SeqTakeDrop_12295(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_12296","instance":12296,"id":198967,"goal":"lemma SeqReverseLen_12296(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_12297","instance":12297,"id":198968,"goal":"lemma SeqReverseIdem_12297(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_12298","instance":12298,"id":198969,"goal":"lemma SeqMapLen_12298(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_12299","instance":12299,"id":198970,"goal":"lemma SeqFilterLe_12299(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_12300","instance":12300,"id":198971,"goal":"lemma SeqMemberAppend_12300(zs: seq, u: seq)\n ensures x in zs + u <==> x in zs || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_12301","instance":12301,"id":198972,"goal":"lemma SeqAppendLen_12301(t: seq, ys: seq)\n ensures |t + ys| == |t| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_12302","instance":12302,"id":198973,"goal":"lemma SeqAppendNil_12302(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_12303","instance":12303,"id":198974,"goal":"lemma SeqNilAppend_12303(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_12304","instance":12304,"id":198975,"goal":"lemma SeqAppendAssoc_12304(zs: seq, ys: seq, u: seq)\n ensures (zs + ys) + u == zs + (ys + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_12305","instance":12305,"id":198976,"goal":"lemma SeqTakeDrop_12305(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_12306","instance":12306,"id":198977,"goal":"lemma SeqReverseLen_12306(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_12307","instance":12307,"id":198978,"goal":"lemma SeqReverseIdem_12307(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_12308","instance":12308,"id":198979,"goal":"lemma SeqMapLen_12308(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_12309","instance":12309,"id":198980,"goal":"lemma SeqFilterLe_12309(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_12310","instance":12310,"id":198981,"goal":"lemma SeqMemberAppend_12310(ys: seq, xs: seq)\n ensures x in ys + xs <==> x in ys || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_12311","instance":12311,"id":198982,"goal":"lemma SeqAppendLen_12311(t: seq, zs: seq)\n ensures |t + zs| == |t| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_12312","instance":12312,"id":198983,"goal":"lemma SeqAppendNil_12312(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_12313","instance":12313,"id":198984,"goal":"lemma SeqNilAppend_12313(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_12314","instance":12314,"id":198985,"goal":"lemma SeqAppendAssoc_12314(s: seq, t: seq, zs: seq)\n ensures (s + t) + zs == s + (t + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_12315","instance":12315,"id":198986,"goal":"lemma SeqTakeDrop_12315(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_12316","instance":12316,"id":198987,"goal":"lemma SeqReverseLen_12316(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_12317","instance":12317,"id":198988,"goal":"lemma SeqReverseIdem_12317(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_12318","instance":12318,"id":198989,"goal":"lemma SeqMapLen_12318(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_12319","instance":12319,"id":198990,"goal":"lemma SeqFilterLe_12319(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_12320","instance":12320,"id":198991,"goal":"lemma SeqMemberAppend_12320(ys: seq, u: seq)\n ensures x in ys + u <==> x in ys || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_12321","instance":12321,"id":198992,"goal":"lemma SeqAppendLen_12321(t: seq, s: seq)\n ensures |t + s| == |t| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_12322","instance":12322,"id":198993,"goal":"lemma SeqAppendNil_12322(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_12323","instance":12323,"id":198994,"goal":"lemma SeqNilAppend_12323(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_12324","instance":12324,"id":198995,"goal":"lemma SeqAppendAssoc_12324(t: seq, u: seq, ys: seq)\n ensures (t + u) + ys == t + (u + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_12325","instance":12325,"id":198996,"goal":"lemma SeqTakeDrop_12325(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_12326","instance":12326,"id":198997,"goal":"lemma SeqReverseLen_12326(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_12327","instance":12327,"id":198998,"goal":"lemma SeqReverseIdem_12327(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_12328","instance":12328,"id":198999,"goal":"lemma SeqMapLen_12328(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_12329","instance":12329,"id":199000,"goal":"lemma SeqFilterLe_12329(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_12330","instance":12330,"id":199001,"goal":"lemma SeqMemberAppend_12330(t: seq, xs: seq)\n ensures x in t + xs <==> x in t || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_12331","instance":12331,"id":199002,"goal":"lemma SeqAppendLen_12331(zs: seq, ys: seq)\n ensures |zs + ys| == |zs| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_12332","instance":12332,"id":199003,"goal":"lemma SeqAppendNil_12332(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_12333","instance":12333,"id":199004,"goal":"lemma SeqNilAppend_12333(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_12334","instance":12334,"id":199005,"goal":"lemma SeqAppendAssoc_12334(zs: seq, u: seq, s: seq)\n ensures (zs + u) + s == zs + (u + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_12335","instance":12335,"id":199006,"goal":"lemma SeqTakeDrop_12335(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_12336","instance":12336,"id":199007,"goal":"lemma SeqReverseLen_12336(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_12337","instance":12337,"id":199008,"goal":"lemma SeqReverseIdem_12337(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_12338","instance":12338,"id":199009,"goal":"lemma SeqMapLen_12338(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_12339","instance":12339,"id":199010,"goal":"lemma SeqFilterLe_12339(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_12340","instance":12340,"id":199011,"goal":"lemma SeqMemberAppend_12340(t: seq, s: seq)\n ensures x in t + s <==> x in t || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_12341","instance":12341,"id":199012,"goal":"lemma SeqAppendLen_12341(t: seq, u: seq)\n ensures |t + u| == |t| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_12342","instance":12342,"id":199013,"goal":"lemma SeqAppendNil_12342(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_12343","instance":12343,"id":199014,"goal":"lemma SeqNilAppend_12343(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_12344","instance":12344,"id":199015,"goal":"lemma SeqAppendAssoc_12344(s: seq, zs: seq, ys: seq)\n ensures (s + zs) + ys == s + (zs + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_12345","instance":12345,"id":199016,"goal":"lemma SeqTakeDrop_12345(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_12346","instance":12346,"id":199017,"goal":"lemma SeqReverseLen_12346(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_12347","instance":12347,"id":199018,"goal":"lemma SeqReverseIdem_12347(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_12348","instance":12348,"id":199019,"goal":"lemma SeqMapLen_12348(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_12349","instance":12349,"id":199020,"goal":"lemma SeqFilterLe_12349(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_12350","instance":12350,"id":199021,"goal":"lemma SeqMemberAppend_12350(s: seq, u: seq)\n ensures x in s + u <==> x in s || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_12351","instance":12351,"id":199022,"goal":"lemma SeqAppendLen_12351(t: seq, ys: seq)\n ensures |t + ys| == |t| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_12352","instance":12352,"id":199023,"goal":"lemma SeqAppendNil_12352(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_12353","instance":12353,"id":199024,"goal":"lemma SeqNilAppend_12353(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_12354","instance":12354,"id":199025,"goal":"lemma SeqAppendAssoc_12354(t: seq, s: seq, xs: seq)\n ensures (t + s) + xs == t + (s + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_12355","instance":12355,"id":199026,"goal":"lemma SeqTakeDrop_12355(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_12356","instance":12356,"id":199027,"goal":"lemma SeqReverseLen_12356(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_12357","instance":12357,"id":199028,"goal":"lemma SeqReverseIdem_12357(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_12358","instance":12358,"id":199029,"goal":"lemma SeqMapLen_12358(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_12359","instance":12359,"id":199030,"goal":"lemma SeqFilterLe_12359(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_12360","instance":12360,"id":199031,"goal":"lemma SeqMemberAppend_12360(t: seq, u: seq)\n ensures x in t + u <==> x in t || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_12361","instance":12361,"id":199032,"goal":"lemma SeqAppendLen_12361(t: seq, u: seq)\n ensures |t + u| == |t| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_12362","instance":12362,"id":199033,"goal":"lemma SeqAppendNil_12362(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_12363","instance":12363,"id":199034,"goal":"lemma SeqNilAppend_12363(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_12364","instance":12364,"id":199035,"goal":"lemma SeqAppendAssoc_12364(t: seq, s: seq, ys: seq)\n ensures (t + s) + ys == t + (s + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_12365","instance":12365,"id":199036,"goal":"lemma SeqTakeDrop_12365(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_12366","instance":12366,"id":199037,"goal":"lemma SeqReverseLen_12366(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_12367","instance":12367,"id":199038,"goal":"lemma SeqReverseIdem_12367(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_12368","instance":12368,"id":199039,"goal":"lemma SeqMapLen_12368(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_12369","instance":12369,"id":199040,"goal":"lemma SeqFilterLe_12369(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_12370","instance":12370,"id":199041,"goal":"lemma SeqMemberAppend_12370(u: seq, s: seq)\n ensures x in u + s <==> x in u || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_12371","instance":12371,"id":199042,"goal":"lemma SeqAppendLen_12371(ys: seq, u: seq)\n ensures |ys + u| == |ys| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_12372","instance":12372,"id":199043,"goal":"lemma SeqAppendNil_12372(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_12373","instance":12373,"id":199044,"goal":"lemma SeqNilAppend_12373(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_12374","instance":12374,"id":199045,"goal":"lemma SeqAppendAssoc_12374(xs: seq, zs: seq, t: seq)\n ensures (xs + zs) + t == xs + (zs + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_12375","instance":12375,"id":199046,"goal":"lemma SeqTakeDrop_12375(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_12376","instance":12376,"id":199047,"goal":"lemma SeqReverseLen_12376(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_12377","instance":12377,"id":199048,"goal":"lemma SeqReverseIdem_12377(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_12378","instance":12378,"id":199049,"goal":"lemma SeqMapLen_12378(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_12379","instance":12379,"id":199050,"goal":"lemma SeqFilterLe_12379(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_12380","instance":12380,"id":199051,"goal":"lemma SeqMemberAppend_12380(u: seq, t: seq)\n ensures x in u + t <==> x in u || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_12381","instance":12381,"id":199052,"goal":"lemma SeqAppendLen_12381(u: seq, ys: seq)\n ensures |u + ys| == |u| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_12382","instance":12382,"id":199053,"goal":"lemma SeqAppendNil_12382(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_12383","instance":12383,"id":199054,"goal":"lemma SeqNilAppend_12383(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_12384","instance":12384,"id":199055,"goal":"lemma SeqAppendAssoc_12384(u: seq, t: seq, xs: seq)\n ensures (u + t) + xs == u + (t + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_12385","instance":12385,"id":199056,"goal":"lemma SeqTakeDrop_12385(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_12386","instance":12386,"id":199057,"goal":"lemma SeqReverseLen_12386(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_12387","instance":12387,"id":199058,"goal":"lemma SeqReverseIdem_12387(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_12388","instance":12388,"id":199059,"goal":"lemma SeqMapLen_12388(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_12389","instance":12389,"id":199060,"goal":"lemma SeqFilterLe_12389(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_12390","instance":12390,"id":199061,"goal":"lemma SeqMemberAppend_12390(xs: seq, u: seq)\n ensures x in xs + u <==> x in xs || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_12391","instance":12391,"id":199062,"goal":"lemma SeqAppendLen_12391(xs: seq, zs: seq)\n ensures |xs + zs| == |xs| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_12392","instance":12392,"id":199063,"goal":"lemma SeqAppendNil_12392(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_12393","instance":12393,"id":199064,"goal":"lemma SeqNilAppend_12393(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_12394","instance":12394,"id":199065,"goal":"lemma SeqAppendAssoc_12394(t: seq, xs: seq, ys: seq)\n ensures (t + xs) + ys == t + (xs + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_12395","instance":12395,"id":199066,"goal":"lemma SeqTakeDrop_12395(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_12396","instance":12396,"id":199067,"goal":"lemma SeqReverseLen_12396(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_12397","instance":12397,"id":199068,"goal":"lemma SeqReverseIdem_12397(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_12398","instance":12398,"id":199069,"goal":"lemma SeqMapLen_12398(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_12399","instance":12399,"id":199070,"goal":"lemma SeqFilterLe_12399(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_12400","instance":12400,"id":199071,"goal":"lemma SeqMemberAppend_12400(zs: seq, xs: seq)\n ensures x in zs + xs <==> x in zs || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_12401","instance":12401,"id":199072,"goal":"lemma SeqAppendLen_12401(u: seq, ys: seq)\n ensures |u + ys| == |u| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_12402","instance":12402,"id":199073,"goal":"lemma SeqAppendNil_12402(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_12403","instance":12403,"id":199074,"goal":"lemma SeqNilAppend_12403(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_12404","instance":12404,"id":199075,"goal":"lemma SeqAppendAssoc_12404(xs: seq, u: seq, t: seq)\n ensures (xs + u) + t == xs + (u + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_12405","instance":12405,"id":199076,"goal":"lemma SeqTakeDrop_12405(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_12406","instance":12406,"id":199077,"goal":"lemma SeqReverseLen_12406(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_12407","instance":12407,"id":199078,"goal":"lemma SeqReverseIdem_12407(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_12408","instance":12408,"id":199079,"goal":"lemma SeqMapLen_12408(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_12409","instance":12409,"id":199080,"goal":"lemma SeqFilterLe_12409(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_12410","instance":12410,"id":199081,"goal":"lemma SeqMemberAppend_12410(ys: seq, zs: seq)\n ensures x in ys + zs <==> x in ys || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_12411","instance":12411,"id":199082,"goal":"lemma SeqAppendLen_12411(xs: seq, s: seq)\n ensures |xs + s| == |xs| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_12412","instance":12412,"id":199083,"goal":"lemma SeqAppendNil_12412(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_12413","instance":12413,"id":199084,"goal":"lemma SeqNilAppend_12413(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_12414","instance":12414,"id":199085,"goal":"lemma SeqAppendAssoc_12414(xs: seq, s: seq, t: seq)\n ensures (xs + s) + t == xs + (s + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_12415","instance":12415,"id":199086,"goal":"lemma SeqTakeDrop_12415(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_12416","instance":12416,"id":199087,"goal":"lemma SeqReverseLen_12416(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_12417","instance":12417,"id":199088,"goal":"lemma SeqReverseIdem_12417(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_12418","instance":12418,"id":199089,"goal":"lemma SeqMapLen_12418(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_12419","instance":12419,"id":199090,"goal":"lemma SeqFilterLe_12419(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_12420","instance":12420,"id":199091,"goal":"lemma SeqMemberAppend_12420(u: seq, t: seq)\n ensures x in u + t <==> x in u || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_12421","instance":12421,"id":199092,"goal":"lemma SeqAppendLen_12421(zs: seq, xs: seq)\n ensures |zs + xs| == |zs| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_12422","instance":12422,"id":199093,"goal":"lemma SeqAppendNil_12422(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_12423","instance":12423,"id":199094,"goal":"lemma SeqNilAppend_12423(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_12424","instance":12424,"id":199095,"goal":"lemma SeqAppendAssoc_12424(ys: seq, t: seq, zs: seq)\n ensures (ys + t) + zs == ys + (t + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_12425","instance":12425,"id":199096,"goal":"lemma SeqTakeDrop_12425(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_12426","instance":12426,"id":199097,"goal":"lemma SeqReverseLen_12426(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_12427","instance":12427,"id":199098,"goal":"lemma SeqReverseIdem_12427(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_12428","instance":12428,"id":199099,"goal":"lemma SeqMapLen_12428(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_12429","instance":12429,"id":199100,"goal":"lemma SeqFilterLe_12429(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_12430","instance":12430,"id":199101,"goal":"lemma SeqMemberAppend_12430(u: seq, xs: seq)\n ensures x in u + xs <==> x in u || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_12431","instance":12431,"id":199102,"goal":"lemma SeqAppendLen_12431(zs: seq, ys: seq)\n ensures |zs + ys| == |zs| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_12432","instance":12432,"id":199103,"goal":"lemma SeqAppendNil_12432(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_12433","instance":12433,"id":199104,"goal":"lemma SeqNilAppend_12433(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_12434","instance":12434,"id":199105,"goal":"lemma SeqAppendAssoc_12434(t: seq, ys: seq, s: seq)\n ensures (t + ys) + s == t + (ys + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_12435","instance":12435,"id":199106,"goal":"lemma SeqTakeDrop_12435(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_12436","instance":12436,"id":199107,"goal":"lemma SeqReverseLen_12436(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_12437","instance":12437,"id":199108,"goal":"lemma SeqReverseIdem_12437(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_12438","instance":12438,"id":199109,"goal":"lemma SeqMapLen_12438(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_12439","instance":12439,"id":199110,"goal":"lemma SeqFilterLe_12439(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_12440","instance":12440,"id":199111,"goal":"lemma SeqMemberAppend_12440(s: seq, ys: seq)\n ensures x in s + ys <==> x in s || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_12441","instance":12441,"id":199112,"goal":"lemma SeqAppendLen_12441(zs: seq, ys: seq)\n ensures |zs + ys| == |zs| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_12442","instance":12442,"id":199113,"goal":"lemma SeqAppendNil_12442(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_12443","instance":12443,"id":199114,"goal":"lemma SeqNilAppend_12443(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_12444","instance":12444,"id":199115,"goal":"lemma SeqAppendAssoc_12444(t: seq, xs: seq, ys: seq)\n ensures (t + xs) + ys == t + (xs + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_12445","instance":12445,"id":199116,"goal":"lemma SeqTakeDrop_12445(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_12446","instance":12446,"id":199117,"goal":"lemma SeqReverseLen_12446(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_12447","instance":12447,"id":199118,"goal":"lemma SeqReverseIdem_12447(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_12448","instance":12448,"id":199119,"goal":"lemma SeqMapLen_12448(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_12449","instance":12449,"id":199120,"goal":"lemma SeqFilterLe_12449(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_12450","instance":12450,"id":199121,"goal":"lemma SeqMemberAppend_12450(u: seq, zs: seq)\n ensures x in u + zs <==> x in u || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_12451","instance":12451,"id":199122,"goal":"lemma SeqAppendLen_12451(ys: seq, u: seq)\n ensures |ys + u| == |ys| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_12452","instance":12452,"id":199123,"goal":"lemma SeqAppendNil_12452(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_12453","instance":12453,"id":199124,"goal":"lemma SeqNilAppend_12453(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_12454","instance":12454,"id":199125,"goal":"lemma SeqAppendAssoc_12454(s: seq, zs: seq, t: seq)\n ensures (s + zs) + t == s + (zs + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_12455","instance":12455,"id":199126,"goal":"lemma SeqTakeDrop_12455(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_12456","instance":12456,"id":199127,"goal":"lemma SeqReverseLen_12456(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_12457","instance":12457,"id":199128,"goal":"lemma SeqReverseIdem_12457(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_12458","instance":12458,"id":199129,"goal":"lemma SeqMapLen_12458(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_12459","instance":12459,"id":199130,"goal":"lemma SeqFilterLe_12459(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_12460","instance":12460,"id":199131,"goal":"lemma SeqMemberAppend_12460(s: seq, u: seq)\n ensures x in s + u <==> x in s || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_12461","instance":12461,"id":199132,"goal":"lemma SeqAppendLen_12461(ys: seq, u: seq)\n ensures |ys + u| == |ys| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_12462","instance":12462,"id":199133,"goal":"lemma SeqAppendNil_12462(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_12463","instance":12463,"id":199134,"goal":"lemma SeqNilAppend_12463(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_12464","instance":12464,"id":199135,"goal":"lemma SeqAppendAssoc_12464(ys: seq, s: seq, t: seq)\n ensures (ys + s) + t == ys + (s + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_12465","instance":12465,"id":199136,"goal":"lemma SeqTakeDrop_12465(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_12466","instance":12466,"id":199137,"goal":"lemma SeqReverseLen_12466(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_12467","instance":12467,"id":199138,"goal":"lemma SeqReverseIdem_12467(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_12468","instance":12468,"id":199139,"goal":"lemma SeqMapLen_12468(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_12469","instance":12469,"id":199140,"goal":"lemma SeqFilterLe_12469(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_12470","instance":12470,"id":199141,"goal":"lemma SeqMemberAppend_12470(t: seq, ys: seq)\n ensures x in t + ys <==> x in t || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_12471","instance":12471,"id":199142,"goal":"lemma SeqAppendLen_12471(zs: seq, s: seq)\n ensures |zs + s| == |zs| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_12472","instance":12472,"id":199143,"goal":"lemma SeqAppendNil_12472(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_12473","instance":12473,"id":199144,"goal":"lemma SeqNilAppend_12473(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_12474","instance":12474,"id":199145,"goal":"lemma SeqAppendAssoc_12474(u: seq, ys: seq, zs: seq)\n ensures (u + ys) + zs == u + (ys + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_12475","instance":12475,"id":199146,"goal":"lemma SeqTakeDrop_12475(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_12476","instance":12476,"id":199147,"goal":"lemma SeqReverseLen_12476(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_12477","instance":12477,"id":199148,"goal":"lemma SeqReverseIdem_12477(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_12478","instance":12478,"id":199149,"goal":"lemma SeqMapLen_12478(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_12479","instance":12479,"id":199150,"goal":"lemma SeqFilterLe_12479(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_12480","instance":12480,"id":199151,"goal":"lemma SeqMemberAppend_12480(u: seq, xs: seq)\n ensures x in u + xs <==> x in u || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_12481","instance":12481,"id":199152,"goal":"lemma SeqAppendLen_12481(u: seq, xs: seq)\n ensures |u + xs| == |u| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_12482","instance":12482,"id":199153,"goal":"lemma SeqAppendNil_12482(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_12483","instance":12483,"id":199154,"goal":"lemma SeqNilAppend_12483(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_12484","instance":12484,"id":199155,"goal":"lemma SeqAppendAssoc_12484(ys: seq, u: seq, t: seq)\n ensures (ys + u) + t == ys + (u + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_12485","instance":12485,"id":199156,"goal":"lemma SeqTakeDrop_12485(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_12486","instance":12486,"id":199157,"goal":"lemma SeqReverseLen_12486(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_12487","instance":12487,"id":199158,"goal":"lemma SeqReverseIdem_12487(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_12488","instance":12488,"id":199159,"goal":"lemma SeqMapLen_12488(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_12489","instance":12489,"id":199160,"goal":"lemma SeqFilterLe_12489(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_12490","instance":12490,"id":199161,"goal":"lemma SeqMemberAppend_12490(u: seq, s: seq)\n ensures x in u + s <==> x in u || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_12491","instance":12491,"id":199162,"goal":"lemma SeqAppendLen_12491(zs: seq, ys: seq)\n ensures |zs + ys| == |zs| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_12492","instance":12492,"id":199163,"goal":"lemma SeqAppendNil_12492(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_12493","instance":12493,"id":199164,"goal":"lemma SeqNilAppend_12493(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_12494","instance":12494,"id":199165,"goal":"lemma SeqAppendAssoc_12494(ys: seq, zs: seq, s: seq)\n ensures (ys + zs) + s == ys + (zs + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_12495","instance":12495,"id":199166,"goal":"lemma SeqTakeDrop_12495(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_12496","instance":12496,"id":199167,"goal":"lemma SeqReverseLen_12496(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_12497","instance":12497,"id":199168,"goal":"lemma SeqReverseIdem_12497(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_12498","instance":12498,"id":199169,"goal":"lemma SeqMapLen_12498(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_12499","instance":12499,"id":199170,"goal":"lemma SeqFilterLe_12499(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_12500","instance":12500,"id":199171,"goal":"lemma SeqMemberAppend_12500(xs: seq, t: seq)\n ensures x in xs + t <==> x in xs || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_12501","instance":12501,"id":199172,"goal":"lemma SeqAppendLen_12501(ys: seq, zs: seq)\n ensures |ys + zs| == |ys| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_12502","instance":12502,"id":199173,"goal":"lemma SeqAppendNil_12502(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_12503","instance":12503,"id":199174,"goal":"lemma SeqNilAppend_12503(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_12504","instance":12504,"id":199175,"goal":"lemma SeqAppendAssoc_12504(zs: seq, ys: seq, xs: seq)\n ensures (zs + ys) + xs == zs + (ys + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_12505","instance":12505,"id":199176,"goal":"lemma SeqTakeDrop_12505(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_12506","instance":12506,"id":199177,"goal":"lemma SeqReverseLen_12506(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_12507","instance":12507,"id":199178,"goal":"lemma SeqReverseIdem_12507(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_12508","instance":12508,"id":199179,"goal":"lemma SeqMapLen_12508(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_12509","instance":12509,"id":199180,"goal":"lemma SeqFilterLe_12509(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_12510","instance":12510,"id":199181,"goal":"lemma SeqMemberAppend_12510(u: seq, xs: seq)\n ensures x in u + xs <==> x in u || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_12511","instance":12511,"id":199182,"goal":"lemma SeqAppendLen_12511(xs: seq, t: seq)\n ensures |xs + t| == |xs| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_12512","instance":12512,"id":199183,"goal":"lemma SeqAppendNil_12512(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_12513","instance":12513,"id":199184,"goal":"lemma SeqNilAppend_12513(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_12514","instance":12514,"id":199185,"goal":"lemma SeqAppendAssoc_12514(zs: seq, s: seq, u: seq)\n ensures (zs + s) + u == zs + (s + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_12515","instance":12515,"id":199186,"goal":"lemma SeqTakeDrop_12515(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_12516","instance":12516,"id":199187,"goal":"lemma SeqReverseLen_12516(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_12517","instance":12517,"id":199188,"goal":"lemma SeqReverseIdem_12517(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_12518","instance":12518,"id":199189,"goal":"lemma SeqMapLen_12518(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_12519","instance":12519,"id":199190,"goal":"lemma SeqFilterLe_12519(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_12520","instance":12520,"id":199191,"goal":"lemma SeqMemberAppend_12520(ys: seq, t: seq)\n ensures x in ys + t <==> x in ys || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_12521","instance":12521,"id":199192,"goal":"lemma SeqAppendLen_12521(t: seq, u: seq)\n ensures |t + u| == |t| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_12522","instance":12522,"id":199193,"goal":"lemma SeqAppendNil_12522(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_12523","instance":12523,"id":199194,"goal":"lemma SeqNilAppend_12523(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_12524","instance":12524,"id":199195,"goal":"lemma SeqAppendAssoc_12524(t: seq, u: seq, s: seq)\n ensures (t + u) + s == t + (u + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_12525","instance":12525,"id":199196,"goal":"lemma SeqTakeDrop_12525(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_12526","instance":12526,"id":199197,"goal":"lemma SeqReverseLen_12526(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_12527","instance":12527,"id":199198,"goal":"lemma SeqReverseIdem_12527(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_12528","instance":12528,"id":199199,"goal":"lemma SeqMapLen_12528(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_12529","instance":12529,"id":199200,"goal":"lemma SeqFilterLe_12529(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_12530","instance":12530,"id":199201,"goal":"lemma SeqMemberAppend_12530(t: seq, s: seq)\n ensures x in t + s <==> x in t || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_12531","instance":12531,"id":199202,"goal":"lemma SeqAppendLen_12531(xs: seq, t: seq)\n ensures |xs + t| == |xs| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_12532","instance":12532,"id":199203,"goal":"lemma SeqAppendNil_12532(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_12533","instance":12533,"id":199204,"goal":"lemma SeqNilAppend_12533(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_12534","instance":12534,"id":199205,"goal":"lemma SeqAppendAssoc_12534(zs: seq, t: seq, ys: seq)\n ensures (zs + t) + ys == zs + (t + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_12535","instance":12535,"id":199206,"goal":"lemma SeqTakeDrop_12535(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_12536","instance":12536,"id":199207,"goal":"lemma SeqReverseLen_12536(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_12537","instance":12537,"id":199208,"goal":"lemma SeqReverseIdem_12537(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_12538","instance":12538,"id":199209,"goal":"lemma SeqMapLen_12538(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_12539","instance":12539,"id":199210,"goal":"lemma SeqFilterLe_12539(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_12540","instance":12540,"id":199211,"goal":"lemma SeqMemberAppend_12540(xs: seq, s: seq)\n ensures x in xs + s <==> x in xs || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_12541","instance":12541,"id":199212,"goal":"lemma SeqAppendLen_12541(zs: seq, xs: seq)\n ensures |zs + xs| == |zs| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_12542","instance":12542,"id":199213,"goal":"lemma SeqAppendNil_12542(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_12543","instance":12543,"id":199214,"goal":"lemma SeqNilAppend_12543(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_12544","instance":12544,"id":199215,"goal":"lemma SeqAppendAssoc_12544(ys: seq, xs: seq, zs: seq)\n ensures (ys + xs) + zs == ys + (xs + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_12545","instance":12545,"id":199216,"goal":"lemma SeqTakeDrop_12545(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_12546","instance":12546,"id":199217,"goal":"lemma SeqReverseLen_12546(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_12547","instance":12547,"id":199218,"goal":"lemma SeqReverseIdem_12547(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_12548","instance":12548,"id":199219,"goal":"lemma SeqMapLen_12548(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_12549","instance":12549,"id":199220,"goal":"lemma SeqFilterLe_12549(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_12550","instance":12550,"id":199221,"goal":"lemma SeqMemberAppend_12550(xs: seq, s: seq)\n ensures x in xs + s <==> x in xs || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_12551","instance":12551,"id":199222,"goal":"lemma SeqAppendLen_12551(s: seq, t: seq)\n ensures |s + t| == |s| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_12552","instance":12552,"id":199223,"goal":"lemma SeqAppendNil_12552(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_12553","instance":12553,"id":199224,"goal":"lemma SeqNilAppend_12553(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_12554","instance":12554,"id":199225,"goal":"lemma SeqAppendAssoc_12554(zs: seq, t: seq, ys: seq)\n ensures (zs + t) + ys == zs + (t + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_12555","instance":12555,"id":199226,"goal":"lemma SeqTakeDrop_12555(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_12556","instance":12556,"id":199227,"goal":"lemma SeqReverseLen_12556(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_12557","instance":12557,"id":199228,"goal":"lemma SeqReverseIdem_12557(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_12558","instance":12558,"id":199229,"goal":"lemma SeqMapLen_12558(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_12559","instance":12559,"id":199230,"goal":"lemma SeqFilterLe_12559(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_12560","instance":12560,"id":199231,"goal":"lemma SeqMemberAppend_12560(s: seq, t: seq)\n ensures x in s + t <==> x in s || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_12561","instance":12561,"id":199232,"goal":"lemma SeqAppendLen_12561(xs: seq, ys: seq)\n ensures |xs + ys| == |xs| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_12562","instance":12562,"id":199233,"goal":"lemma SeqAppendNil_12562(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_12563","instance":12563,"id":199234,"goal":"lemma SeqNilAppend_12563(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_12564","instance":12564,"id":199235,"goal":"lemma SeqAppendAssoc_12564(u: seq, xs: seq, t: seq)\n ensures (u + xs) + t == u + (xs + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_12565","instance":12565,"id":199236,"goal":"lemma SeqTakeDrop_12565(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_12566","instance":12566,"id":199237,"goal":"lemma SeqReverseLen_12566(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_12567","instance":12567,"id":199238,"goal":"lemma SeqReverseIdem_12567(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_12568","instance":12568,"id":199239,"goal":"lemma SeqMapLen_12568(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_12569","instance":12569,"id":199240,"goal":"lemma SeqFilterLe_12569(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_12570","instance":12570,"id":199241,"goal":"lemma SeqMemberAppend_12570(u: seq, xs: seq)\n ensures x in u + xs <==> x in u || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_12571","instance":12571,"id":199242,"goal":"lemma SeqAppendLen_12571(s: seq, zs: seq)\n ensures |s + zs| == |s| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_12572","instance":12572,"id":199243,"goal":"lemma SeqAppendNil_12572(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_12573","instance":12573,"id":199244,"goal":"lemma SeqNilAppend_12573(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_12574","instance":12574,"id":199245,"goal":"lemma SeqAppendAssoc_12574(u: seq, s: seq, zs: seq)\n ensures (u + s) + zs == u + (s + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_12575","instance":12575,"id":199246,"goal":"lemma SeqTakeDrop_12575(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_12576","instance":12576,"id":199247,"goal":"lemma SeqReverseLen_12576(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_12577","instance":12577,"id":199248,"goal":"lemma SeqReverseIdem_12577(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_12578","instance":12578,"id":199249,"goal":"lemma SeqMapLen_12578(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_12579","instance":12579,"id":199250,"goal":"lemma SeqFilterLe_12579(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_12580","instance":12580,"id":199251,"goal":"lemma SeqMemberAppend_12580(zs: seq, ys: seq)\n ensures x in zs + ys <==> x in zs || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_12581","instance":12581,"id":199252,"goal":"lemma SeqAppendLen_12581(t: seq, zs: seq)\n ensures |t + zs| == |t| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_12582","instance":12582,"id":199253,"goal":"lemma SeqAppendNil_12582(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_12583","instance":12583,"id":199254,"goal":"lemma SeqNilAppend_12583(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_12584","instance":12584,"id":199255,"goal":"lemma SeqAppendAssoc_12584(u: seq, s: seq, zs: seq)\n ensures (u + s) + zs == u + (s + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_12585","instance":12585,"id":199256,"goal":"lemma SeqTakeDrop_12585(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_12586","instance":12586,"id":199257,"goal":"lemma SeqReverseLen_12586(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_12587","instance":12587,"id":199258,"goal":"lemma SeqReverseIdem_12587(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_12588","instance":12588,"id":199259,"goal":"lemma SeqMapLen_12588(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_12589","instance":12589,"id":199260,"goal":"lemma SeqFilterLe_12589(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_12590","instance":12590,"id":199261,"goal":"lemma SeqMemberAppend_12590(zs: seq, ys: seq)\n ensures x in zs + ys <==> x in zs || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_12591","instance":12591,"id":199262,"goal":"lemma SeqAppendLen_12591(u: seq, ys: seq)\n ensures |u + ys| == |u| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_12592","instance":12592,"id":199263,"goal":"lemma SeqAppendNil_12592(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_12593","instance":12593,"id":199264,"goal":"lemma SeqNilAppend_12593(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_12594","instance":12594,"id":199265,"goal":"lemma SeqAppendAssoc_12594(zs: seq, u: seq, s: seq)\n ensures (zs + u) + s == zs + (u + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_12595","instance":12595,"id":199266,"goal":"lemma SeqTakeDrop_12595(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_12596","instance":12596,"id":199267,"goal":"lemma SeqReverseLen_12596(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_12597","instance":12597,"id":199268,"goal":"lemma SeqReverseIdem_12597(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_12598","instance":12598,"id":199269,"goal":"lemma SeqMapLen_12598(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_12599","instance":12599,"id":199270,"goal":"lemma SeqFilterLe_12599(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_12600","instance":12600,"id":199271,"goal":"lemma SeqMemberAppend_12600(s: seq, ys: seq)\n ensures x in s + ys <==> x in s || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_12601","instance":12601,"id":199272,"goal":"lemma SeqAppendLen_12601(zs: seq, u: seq)\n ensures |zs + u| == |zs| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_12602","instance":12602,"id":199273,"goal":"lemma SeqAppendNil_12602(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_12603","instance":12603,"id":199274,"goal":"lemma SeqNilAppend_12603(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_12604","instance":12604,"id":199275,"goal":"lemma SeqAppendAssoc_12604(xs: seq, zs: seq, ys: seq)\n ensures (xs + zs) + ys == xs + (zs + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_12605","instance":12605,"id":199276,"goal":"lemma SeqTakeDrop_12605(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_12606","instance":12606,"id":199277,"goal":"lemma SeqReverseLen_12606(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_12607","instance":12607,"id":199278,"goal":"lemma SeqReverseIdem_12607(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_12608","instance":12608,"id":199279,"goal":"lemma SeqMapLen_12608(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_12609","instance":12609,"id":199280,"goal":"lemma SeqFilterLe_12609(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_12610","instance":12610,"id":199281,"goal":"lemma SeqMemberAppend_12610(zs: seq, xs: seq)\n ensures x in zs + xs <==> x in zs || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_12611","instance":12611,"id":199282,"goal":"lemma SeqAppendLen_12611(xs: seq, t: seq)\n ensures |xs + t| == |xs| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_12612","instance":12612,"id":199283,"goal":"lemma SeqAppendNil_12612(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_12613","instance":12613,"id":199284,"goal":"lemma SeqNilAppend_12613(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_12614","instance":12614,"id":199285,"goal":"lemma SeqAppendAssoc_12614(zs: seq, t: seq, u: seq)\n ensures (zs + t) + u == zs + (t + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_12615","instance":12615,"id":199286,"goal":"lemma SeqTakeDrop_12615(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_12616","instance":12616,"id":199287,"goal":"lemma SeqReverseLen_12616(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_12617","instance":12617,"id":199288,"goal":"lemma SeqReverseIdem_12617(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_12618","instance":12618,"id":199289,"goal":"lemma SeqMapLen_12618(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_12619","instance":12619,"id":199290,"goal":"lemma SeqFilterLe_12619(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_12620","instance":12620,"id":199291,"goal":"lemma SeqMemberAppend_12620(zs: seq, xs: seq)\n ensures x in zs + xs <==> x in zs || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_12621","instance":12621,"id":199292,"goal":"lemma SeqAppendLen_12621(ys: seq, s: seq)\n ensures |ys + s| == |ys| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_12622","instance":12622,"id":199293,"goal":"lemma SeqAppendNil_12622(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_12623","instance":12623,"id":199294,"goal":"lemma SeqNilAppend_12623(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_12624","instance":12624,"id":199295,"goal":"lemma SeqAppendAssoc_12624(ys: seq, xs: seq, s: seq)\n ensures (ys + xs) + s == ys + (xs + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_12625","instance":12625,"id":199296,"goal":"lemma SeqTakeDrop_12625(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_12626","instance":12626,"id":199297,"goal":"lemma SeqReverseLen_12626(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_12627","instance":12627,"id":199298,"goal":"lemma SeqReverseIdem_12627(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_12628","instance":12628,"id":199299,"goal":"lemma SeqMapLen_12628(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_12629","instance":12629,"id":199300,"goal":"lemma SeqFilterLe_12629(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_12630","instance":12630,"id":199301,"goal":"lemma SeqMemberAppend_12630(u: seq, zs: seq)\n ensures x in u + zs <==> x in u || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_12631","instance":12631,"id":199302,"goal":"lemma SeqAppendLen_12631(xs: seq, s: seq)\n ensures |xs + s| == |xs| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_12632","instance":12632,"id":199303,"goal":"lemma SeqAppendNil_12632(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_12633","instance":12633,"id":199304,"goal":"lemma SeqNilAppend_12633(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_12634","instance":12634,"id":199305,"goal":"lemma SeqAppendAssoc_12634(s: seq, t: seq, zs: seq)\n ensures (s + t) + zs == s + (t + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_12635","instance":12635,"id":199306,"goal":"lemma SeqTakeDrop_12635(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_12636","instance":12636,"id":199307,"goal":"lemma SeqReverseLen_12636(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_12637","instance":12637,"id":199308,"goal":"lemma SeqReverseIdem_12637(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_12638","instance":12638,"id":199309,"goal":"lemma SeqMapLen_12638(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_12639","instance":12639,"id":199310,"goal":"lemma SeqFilterLe_12639(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_12640","instance":12640,"id":199311,"goal":"lemma SeqMemberAppend_12640(ys: seq, u: seq)\n ensures x in ys + u <==> x in ys || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_12641","instance":12641,"id":199312,"goal":"lemma SeqAppendLen_12641(s: seq, ys: seq)\n ensures |s + ys| == |s| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_12642","instance":12642,"id":199313,"goal":"lemma SeqAppendNil_12642(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_12643","instance":12643,"id":199314,"goal":"lemma SeqNilAppend_12643(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_12644","instance":12644,"id":199315,"goal":"lemma SeqAppendAssoc_12644(zs: seq, s: seq, u: seq)\n ensures (zs + s) + u == zs + (s + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_12645","instance":12645,"id":199316,"goal":"lemma SeqTakeDrop_12645(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_12646","instance":12646,"id":199317,"goal":"lemma SeqReverseLen_12646(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_12647","instance":12647,"id":199318,"goal":"lemma SeqReverseIdem_12647(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_12648","instance":12648,"id":199319,"goal":"lemma SeqMapLen_12648(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_12649","instance":12649,"id":199320,"goal":"lemma SeqFilterLe_12649(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_12650","instance":12650,"id":199321,"goal":"lemma SeqMemberAppend_12650(u: seq, s: seq)\n ensures x in u + s <==> x in u || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_12651","instance":12651,"id":199322,"goal":"lemma SeqAppendLen_12651(zs: seq, xs: seq)\n ensures |zs + xs| == |zs| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_12652","instance":12652,"id":199323,"goal":"lemma SeqAppendNil_12652(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_12653","instance":12653,"id":199324,"goal":"lemma SeqNilAppend_12653(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_12654","instance":12654,"id":199325,"goal":"lemma SeqAppendAssoc_12654(s: seq, xs: seq, t: seq)\n ensures (s + xs) + t == s + (xs + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_12655","instance":12655,"id":199326,"goal":"lemma SeqTakeDrop_12655(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_12656","instance":12656,"id":199327,"goal":"lemma SeqReverseLen_12656(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_12657","instance":12657,"id":199328,"goal":"lemma SeqReverseIdem_12657(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_12658","instance":12658,"id":199329,"goal":"lemma SeqMapLen_12658(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_12659","instance":12659,"id":199330,"goal":"lemma SeqFilterLe_12659(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_12660","instance":12660,"id":199331,"goal":"lemma SeqMemberAppend_12660(ys: seq, xs: seq)\n ensures x in ys + xs <==> x in ys || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_12661","instance":12661,"id":199332,"goal":"lemma SeqAppendLen_12661(ys: seq, s: seq)\n ensures |ys + s| == |ys| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_12662","instance":12662,"id":199333,"goal":"lemma SeqAppendNil_12662(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_12663","instance":12663,"id":199334,"goal":"lemma SeqNilAppend_12663(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_12664","instance":12664,"id":199335,"goal":"lemma SeqAppendAssoc_12664(ys: seq, s: seq, xs: seq)\n ensures (ys + s) + xs == ys + (s + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_12665","instance":12665,"id":199336,"goal":"lemma SeqTakeDrop_12665(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_12666","instance":12666,"id":199337,"goal":"lemma SeqReverseLen_12666(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_12667","instance":12667,"id":199338,"goal":"lemma SeqReverseIdem_12667(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_12668","instance":12668,"id":199339,"goal":"lemma SeqMapLen_12668(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_12669","instance":12669,"id":199340,"goal":"lemma SeqFilterLe_12669(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_12670","instance":12670,"id":199341,"goal":"lemma SeqMemberAppend_12670(xs: seq, u: seq)\n ensures x in xs + u <==> x in xs || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_12671","instance":12671,"id":199342,"goal":"lemma SeqAppendLen_12671(zs: seq, s: seq)\n ensures |zs + s| == |zs| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_12672","instance":12672,"id":199343,"goal":"lemma SeqAppendNil_12672(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_12673","instance":12673,"id":199344,"goal":"lemma SeqNilAppend_12673(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_12674","instance":12674,"id":199345,"goal":"lemma SeqAppendAssoc_12674(xs: seq, t: seq, ys: seq)\n ensures (xs + t) + ys == xs + (t + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_12675","instance":12675,"id":199346,"goal":"lemma SeqTakeDrop_12675(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_12676","instance":12676,"id":199347,"goal":"lemma SeqReverseLen_12676(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_12677","instance":12677,"id":199348,"goal":"lemma SeqReverseIdem_12677(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_12678","instance":12678,"id":199349,"goal":"lemma SeqMapLen_12678(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_12679","instance":12679,"id":199350,"goal":"lemma SeqFilterLe_12679(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_12680","instance":12680,"id":199351,"goal":"lemma SeqMemberAppend_12680(t: seq, ys: seq)\n ensures x in t + ys <==> x in t || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_12681","instance":12681,"id":199352,"goal":"lemma SeqAppendLen_12681(s: seq, xs: seq)\n ensures |s + xs| == |s| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_12682","instance":12682,"id":199353,"goal":"lemma SeqAppendNil_12682(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_12683","instance":12683,"id":199354,"goal":"lemma SeqNilAppend_12683(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_12684","instance":12684,"id":199355,"goal":"lemma SeqAppendAssoc_12684(s: seq, t: seq, xs: seq)\n ensures (s + t) + xs == s + (t + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_12685","instance":12685,"id":199356,"goal":"lemma SeqTakeDrop_12685(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_12686","instance":12686,"id":199357,"goal":"lemma SeqReverseLen_12686(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_12687","instance":12687,"id":199358,"goal":"lemma SeqReverseIdem_12687(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_12688","instance":12688,"id":199359,"goal":"lemma SeqMapLen_12688(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_12689","instance":12689,"id":199360,"goal":"lemma SeqFilterLe_12689(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_12690","instance":12690,"id":199361,"goal":"lemma SeqMemberAppend_12690(s: seq, xs: seq)\n ensures x in s + xs <==> x in s || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_12691","instance":12691,"id":199362,"goal":"lemma SeqAppendLen_12691(s: seq, xs: seq)\n ensures |s + xs| == |s| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_12692","instance":12692,"id":199363,"goal":"lemma SeqAppendNil_12692(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_12693","instance":12693,"id":199364,"goal":"lemma SeqNilAppend_12693(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_12694","instance":12694,"id":199365,"goal":"lemma SeqAppendAssoc_12694(s: seq, zs: seq, u: seq)\n ensures (s + zs) + u == s + (zs + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_12695","instance":12695,"id":199366,"goal":"lemma SeqTakeDrop_12695(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_12696","instance":12696,"id":199367,"goal":"lemma SeqReverseLen_12696(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_12697","instance":12697,"id":199368,"goal":"lemma SeqReverseIdem_12697(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_12698","instance":12698,"id":199369,"goal":"lemma SeqMapLen_12698(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_12699","instance":12699,"id":199370,"goal":"lemma SeqFilterLe_12699(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_12700","instance":12700,"id":199371,"goal":"lemma SeqMemberAppend_12700(zs: seq, ys: seq)\n ensures x in zs + ys <==> x in zs || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_12701","instance":12701,"id":199372,"goal":"lemma SeqAppendLen_12701(xs: seq, zs: seq)\n ensures |xs + zs| == |xs| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_12702","instance":12702,"id":199373,"goal":"lemma SeqAppendNil_12702(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_12703","instance":12703,"id":199374,"goal":"lemma SeqNilAppend_12703(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_12704","instance":12704,"id":199375,"goal":"lemma SeqAppendAssoc_12704(xs: seq, ys: seq, u: seq)\n ensures (xs + ys) + u == xs + (ys + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_12705","instance":12705,"id":199376,"goal":"lemma SeqTakeDrop_12705(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_12706","instance":12706,"id":199377,"goal":"lemma SeqReverseLen_12706(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_12707","instance":12707,"id":199378,"goal":"lemma SeqReverseIdem_12707(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_12708","instance":12708,"id":199379,"goal":"lemma SeqMapLen_12708(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_12709","instance":12709,"id":199380,"goal":"lemma SeqFilterLe_12709(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_12710","instance":12710,"id":199381,"goal":"lemma SeqMemberAppend_12710(u: seq, zs: seq)\n ensures x in u + zs <==> x in u || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_12711","instance":12711,"id":199382,"goal":"lemma SeqAppendLen_12711(zs: seq, xs: seq)\n ensures |zs + xs| == |zs| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_12712","instance":12712,"id":199383,"goal":"lemma SeqAppendNil_12712(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_12713","instance":12713,"id":199384,"goal":"lemma SeqNilAppend_12713(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_12714","instance":12714,"id":199385,"goal":"lemma SeqAppendAssoc_12714(ys: seq, u: seq, xs: seq)\n ensures (ys + u) + xs == ys + (u + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_12715","instance":12715,"id":199386,"goal":"lemma SeqTakeDrop_12715(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_12716","instance":12716,"id":199387,"goal":"lemma SeqReverseLen_12716(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_12717","instance":12717,"id":199388,"goal":"lemma SeqReverseIdem_12717(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_12718","instance":12718,"id":199389,"goal":"lemma SeqMapLen_12718(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_12719","instance":12719,"id":199390,"goal":"lemma SeqFilterLe_12719(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_12720","instance":12720,"id":199391,"goal":"lemma SeqMemberAppend_12720(ys: seq, xs: seq)\n ensures x in ys + xs <==> x in ys || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_12721","instance":12721,"id":199392,"goal":"lemma SeqAppendLen_12721(t: seq, s: seq)\n ensures |t + s| == |t| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_12722","instance":12722,"id":199393,"goal":"lemma SeqAppendNil_12722(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_12723","instance":12723,"id":199394,"goal":"lemma SeqNilAppend_12723(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_12724","instance":12724,"id":199395,"goal":"lemma SeqAppendAssoc_12724(zs: seq, s: seq, ys: seq)\n ensures (zs + s) + ys == zs + (s + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_12725","instance":12725,"id":199396,"goal":"lemma SeqTakeDrop_12725(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_12726","instance":12726,"id":199397,"goal":"lemma SeqReverseLen_12726(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_12727","instance":12727,"id":199398,"goal":"lemma SeqReverseIdem_12727(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_12728","instance":12728,"id":199399,"goal":"lemma SeqMapLen_12728(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_12729","instance":12729,"id":199400,"goal":"lemma SeqFilterLe_12729(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_12730","instance":12730,"id":199401,"goal":"lemma SeqMemberAppend_12730(zs: seq, xs: seq)\n ensures x in zs + xs <==> x in zs || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_12731","instance":12731,"id":199402,"goal":"lemma SeqAppendLen_12731(xs: seq, zs: seq)\n ensures |xs + zs| == |xs| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_12732","instance":12732,"id":199403,"goal":"lemma SeqAppendNil_12732(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_12733","instance":12733,"id":199404,"goal":"lemma SeqNilAppend_12733(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_12734","instance":12734,"id":199405,"goal":"lemma SeqAppendAssoc_12734(u: seq, xs: seq, t: seq)\n ensures (u + xs) + t == u + (xs + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_12735","instance":12735,"id":199406,"goal":"lemma SeqTakeDrop_12735(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_12736","instance":12736,"id":199407,"goal":"lemma SeqReverseLen_12736(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_12737","instance":12737,"id":199408,"goal":"lemma SeqReverseIdem_12737(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_12738","instance":12738,"id":199409,"goal":"lemma SeqMapLen_12738(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_12739","instance":12739,"id":199410,"goal":"lemma SeqFilterLe_12739(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_12740","instance":12740,"id":199411,"goal":"lemma SeqMemberAppend_12740(ys: seq, u: seq)\n ensures x in ys + u <==> x in ys || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_12741","instance":12741,"id":199412,"goal":"lemma SeqAppendLen_12741(s: seq, xs: seq)\n ensures |s + xs| == |s| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_12742","instance":12742,"id":199413,"goal":"lemma SeqAppendNil_12742(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_12743","instance":12743,"id":199414,"goal":"lemma SeqNilAppend_12743(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_12744","instance":12744,"id":199415,"goal":"lemma SeqAppendAssoc_12744(s: seq, t: seq, xs: seq)\n ensures (s + t) + xs == s + (t + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_12745","instance":12745,"id":199416,"goal":"lemma SeqTakeDrop_12745(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_12746","instance":12746,"id":199417,"goal":"lemma SeqReverseLen_12746(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_12747","instance":12747,"id":199418,"goal":"lemma SeqReverseIdem_12747(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_12748","instance":12748,"id":199419,"goal":"lemma SeqMapLen_12748(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_12749","instance":12749,"id":199420,"goal":"lemma SeqFilterLe_12749(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_12750","instance":12750,"id":199421,"goal":"lemma SeqMemberAppend_12750(zs: seq, s: seq)\n ensures x in zs + s <==> x in zs || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_12751","instance":12751,"id":199422,"goal":"lemma SeqAppendLen_12751(zs: seq, xs: seq)\n ensures |zs + xs| == |zs| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_12752","instance":12752,"id":199423,"goal":"lemma SeqAppendNil_12752(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_12753","instance":12753,"id":199424,"goal":"lemma SeqNilAppend_12753(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_12754","instance":12754,"id":199425,"goal":"lemma SeqAppendAssoc_12754(xs: seq, zs: seq, s: seq)\n ensures (xs + zs) + s == xs + (zs + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_12755","instance":12755,"id":199426,"goal":"lemma SeqTakeDrop_12755(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_12756","instance":12756,"id":199427,"goal":"lemma SeqReverseLen_12756(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_12757","instance":12757,"id":199428,"goal":"lemma SeqReverseIdem_12757(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_12758","instance":12758,"id":199429,"goal":"lemma SeqMapLen_12758(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_12759","instance":12759,"id":199430,"goal":"lemma SeqFilterLe_12759(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_12760","instance":12760,"id":199431,"goal":"lemma SeqMemberAppend_12760(zs: seq, ys: seq)\n ensures x in zs + ys <==> x in zs || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_12761","instance":12761,"id":199432,"goal":"lemma SeqAppendLen_12761(t: seq, ys: seq)\n ensures |t + ys| == |t| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_12762","instance":12762,"id":199433,"goal":"lemma SeqAppendNil_12762(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_12763","instance":12763,"id":199434,"goal":"lemma SeqNilAppend_12763(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_12764","instance":12764,"id":199435,"goal":"lemma SeqAppendAssoc_12764(s: seq, xs: seq, zs: seq)\n ensures (s + xs) + zs == s + (xs + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_12765","instance":12765,"id":199436,"goal":"lemma SeqTakeDrop_12765(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_12766","instance":12766,"id":199437,"goal":"lemma SeqReverseLen_12766(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_12767","instance":12767,"id":199438,"goal":"lemma SeqReverseIdem_12767(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_12768","instance":12768,"id":199439,"goal":"lemma SeqMapLen_12768(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_12769","instance":12769,"id":199440,"goal":"lemma SeqFilterLe_12769(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_12770","instance":12770,"id":199441,"goal":"lemma SeqMemberAppend_12770(t: seq, u: seq)\n ensures x in t + u <==> x in t || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_12771","instance":12771,"id":199442,"goal":"lemma SeqAppendLen_12771(t: seq, xs: seq)\n ensures |t + xs| == |t| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_12772","instance":12772,"id":199443,"goal":"lemma SeqAppendNil_12772(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_12773","instance":12773,"id":199444,"goal":"lemma SeqNilAppend_12773(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_12774","instance":12774,"id":199445,"goal":"lemma SeqAppendAssoc_12774(t: seq, s: seq, zs: seq)\n ensures (t + s) + zs == t + (s + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_12775","instance":12775,"id":199446,"goal":"lemma SeqTakeDrop_12775(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_12776","instance":12776,"id":199447,"goal":"lemma SeqReverseLen_12776(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_12777","instance":12777,"id":199448,"goal":"lemma SeqReverseIdem_12777(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_12778","instance":12778,"id":199449,"goal":"lemma SeqMapLen_12778(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_12779","instance":12779,"id":199450,"goal":"lemma SeqFilterLe_12779(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_12780","instance":12780,"id":199451,"goal":"lemma SeqMemberAppend_12780(t: seq, xs: seq)\n ensures x in t + xs <==> x in t || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_12781","instance":12781,"id":199452,"goal":"lemma SeqAppendLen_12781(t: seq, zs: seq)\n ensures |t + zs| == |t| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_12782","instance":12782,"id":199453,"goal":"lemma SeqAppendNil_12782(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_12783","instance":12783,"id":199454,"goal":"lemma SeqNilAppend_12783(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_12784","instance":12784,"id":199455,"goal":"lemma SeqAppendAssoc_12784(zs: seq, t: seq, s: seq)\n ensures (zs + t) + s == zs + (t + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_12785","instance":12785,"id":199456,"goal":"lemma SeqTakeDrop_12785(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_12786","instance":12786,"id":199457,"goal":"lemma SeqReverseLen_12786(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_12787","instance":12787,"id":199458,"goal":"lemma SeqReverseIdem_12787(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_12788","instance":12788,"id":199459,"goal":"lemma SeqMapLen_12788(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_12789","instance":12789,"id":199460,"goal":"lemma SeqFilterLe_12789(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_12790","instance":12790,"id":199461,"goal":"lemma SeqMemberAppend_12790(zs: seq, xs: seq)\n ensures x in zs + xs <==> x in zs || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_12791","instance":12791,"id":199462,"goal":"lemma SeqAppendLen_12791(t: seq, zs: seq)\n ensures |t + zs| == |t| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_12792","instance":12792,"id":199463,"goal":"lemma SeqAppendNil_12792(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_12793","instance":12793,"id":199464,"goal":"lemma SeqNilAppend_12793(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_12794","instance":12794,"id":199465,"goal":"lemma SeqAppendAssoc_12794(xs: seq, t: seq, ys: seq)\n ensures (xs + t) + ys == xs + (t + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_12795","instance":12795,"id":199466,"goal":"lemma SeqTakeDrop_12795(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_12796","instance":12796,"id":199467,"goal":"lemma SeqReverseLen_12796(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_12797","instance":12797,"id":199468,"goal":"lemma SeqReverseIdem_12797(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_12798","instance":12798,"id":199469,"goal":"lemma SeqMapLen_12798(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_12799","instance":12799,"id":199470,"goal":"lemma SeqFilterLe_12799(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_12800","instance":12800,"id":199471,"goal":"lemma SeqMemberAppend_12800(t: seq, ys: seq)\n ensures x in t + ys <==> x in t || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_12801","instance":12801,"id":199472,"goal":"lemma SeqAppendLen_12801(u: seq, s: seq)\n ensures |u + s| == |u| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_12802","instance":12802,"id":199473,"goal":"lemma SeqAppendNil_12802(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_12803","instance":12803,"id":199474,"goal":"lemma SeqNilAppend_12803(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_12804","instance":12804,"id":199475,"goal":"lemma SeqAppendAssoc_12804(ys: seq, zs: seq, xs: seq)\n ensures (ys + zs) + xs == ys + (zs + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_12805","instance":12805,"id":199476,"goal":"lemma SeqTakeDrop_12805(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_12806","instance":12806,"id":199477,"goal":"lemma SeqReverseLen_12806(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_12807","instance":12807,"id":199478,"goal":"lemma SeqReverseIdem_12807(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_12808","instance":12808,"id":199479,"goal":"lemma SeqMapLen_12808(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_12809","instance":12809,"id":199480,"goal":"lemma SeqFilterLe_12809(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_12810","instance":12810,"id":199481,"goal":"lemma SeqMemberAppend_12810(xs: seq, zs: seq)\n ensures x in xs + zs <==> x in xs || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_12811","instance":12811,"id":199482,"goal":"lemma SeqAppendLen_12811(ys: seq, s: seq)\n ensures |ys + s| == |ys| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_12812","instance":12812,"id":199483,"goal":"lemma SeqAppendNil_12812(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_12813","instance":12813,"id":199484,"goal":"lemma SeqNilAppend_12813(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_12814","instance":12814,"id":199485,"goal":"lemma SeqAppendAssoc_12814(u: seq, xs: seq, t: seq)\n ensures (u + xs) + t == u + (xs + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_12815","instance":12815,"id":199486,"goal":"lemma SeqTakeDrop_12815(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_12816","instance":12816,"id":199487,"goal":"lemma SeqReverseLen_12816(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_12817","instance":12817,"id":199488,"goal":"lemma SeqReverseIdem_12817(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_12818","instance":12818,"id":199489,"goal":"lemma SeqMapLen_12818(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_12819","instance":12819,"id":199490,"goal":"lemma SeqFilterLe_12819(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_12820","instance":12820,"id":199491,"goal":"lemma SeqMemberAppend_12820(s: seq, zs: seq)\n ensures x in s + zs <==> x in s || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_12821","instance":12821,"id":199492,"goal":"lemma SeqAppendLen_12821(s: seq, xs: seq)\n ensures |s + xs| == |s| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_12822","instance":12822,"id":199493,"goal":"lemma SeqAppendNil_12822(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_12823","instance":12823,"id":199494,"goal":"lemma SeqNilAppend_12823(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_12824","instance":12824,"id":199495,"goal":"lemma SeqAppendAssoc_12824(ys: seq, u: seq, xs: seq)\n ensures (ys + u) + xs == ys + (u + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_12825","instance":12825,"id":199496,"goal":"lemma SeqTakeDrop_12825(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_12826","instance":12826,"id":199497,"goal":"lemma SeqReverseLen_12826(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_12827","instance":12827,"id":199498,"goal":"lemma SeqReverseIdem_12827(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_12828","instance":12828,"id":199499,"goal":"lemma SeqMapLen_12828(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_12829","instance":12829,"id":199500,"goal":"lemma SeqFilterLe_12829(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_12830","instance":12830,"id":199501,"goal":"lemma SeqMemberAppend_12830(u: seq, xs: seq)\n ensures x in u + xs <==> x in u || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_12831","instance":12831,"id":199502,"goal":"lemma SeqAppendLen_12831(s: seq, ys: seq)\n ensures |s + ys| == |s| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_12832","instance":12832,"id":199503,"goal":"lemma SeqAppendNil_12832(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_12833","instance":12833,"id":199504,"goal":"lemma SeqNilAppend_12833(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_12834","instance":12834,"id":199505,"goal":"lemma SeqAppendAssoc_12834(ys: seq, s: seq, zs: seq)\n ensures (ys + s) + zs == ys + (s + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_12835","instance":12835,"id":199506,"goal":"lemma SeqTakeDrop_12835(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_12836","instance":12836,"id":199507,"goal":"lemma SeqReverseLen_12836(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_12837","instance":12837,"id":199508,"goal":"lemma SeqReverseIdem_12837(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_12838","instance":12838,"id":199509,"goal":"lemma SeqMapLen_12838(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_12839","instance":12839,"id":199510,"goal":"lemma SeqFilterLe_12839(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_12840","instance":12840,"id":199511,"goal":"lemma SeqMemberAppend_12840(ys: seq, zs: seq)\n ensures x in ys + zs <==> x in ys || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_12841","instance":12841,"id":199512,"goal":"lemma SeqAppendLen_12841(zs: seq, u: seq)\n ensures |zs + u| == |zs| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_12842","instance":12842,"id":199513,"goal":"lemma SeqAppendNil_12842(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_12843","instance":12843,"id":199514,"goal":"lemma SeqNilAppend_12843(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_12844","instance":12844,"id":199515,"goal":"lemma SeqAppendAssoc_12844(ys: seq, t: seq, zs: seq)\n ensures (ys + t) + zs == ys + (t + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_12845","instance":12845,"id":199516,"goal":"lemma SeqTakeDrop_12845(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_12846","instance":12846,"id":199517,"goal":"lemma SeqReverseLen_12846(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_12847","instance":12847,"id":199518,"goal":"lemma SeqReverseIdem_12847(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_12848","instance":12848,"id":199519,"goal":"lemma SeqMapLen_12848(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_12849","instance":12849,"id":199520,"goal":"lemma SeqFilterLe_12849(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_12850","instance":12850,"id":199521,"goal":"lemma SeqMemberAppend_12850(s: seq, ys: seq)\n ensures x in s + ys <==> x in s || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_12851","instance":12851,"id":199522,"goal":"lemma SeqAppendLen_12851(xs: seq, t: seq)\n ensures |xs + t| == |xs| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_12852","instance":12852,"id":199523,"goal":"lemma SeqAppendNil_12852(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_12853","instance":12853,"id":199524,"goal":"lemma SeqNilAppend_12853(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_12854","instance":12854,"id":199525,"goal":"lemma SeqAppendAssoc_12854(xs: seq, u: seq, zs: seq)\n ensures (xs + u) + zs == xs + (u + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_12855","instance":12855,"id":199526,"goal":"lemma SeqTakeDrop_12855(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_12856","instance":12856,"id":199527,"goal":"lemma SeqReverseLen_12856(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_12857","instance":12857,"id":199528,"goal":"lemma SeqReverseIdem_12857(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_12858","instance":12858,"id":199529,"goal":"lemma SeqMapLen_12858(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_12859","instance":12859,"id":199530,"goal":"lemma SeqFilterLe_12859(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_12860","instance":12860,"id":199531,"goal":"lemma SeqMemberAppend_12860(xs: seq, u: seq)\n ensures x in xs + u <==> x in xs || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_12861","instance":12861,"id":199532,"goal":"lemma SeqAppendLen_12861(ys: seq, u: seq)\n ensures |ys + u| == |ys| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_12862","instance":12862,"id":199533,"goal":"lemma SeqAppendNil_12862(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_12863","instance":12863,"id":199534,"goal":"lemma SeqNilAppend_12863(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_12864","instance":12864,"id":199535,"goal":"lemma SeqAppendAssoc_12864(xs: seq, zs: seq, ys: seq)\n ensures (xs + zs) + ys == xs + (zs + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_12865","instance":12865,"id":199536,"goal":"lemma SeqTakeDrop_12865(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_12866","instance":12866,"id":199537,"goal":"lemma SeqReverseLen_12866(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_12867","instance":12867,"id":199538,"goal":"lemma SeqReverseIdem_12867(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_12868","instance":12868,"id":199539,"goal":"lemma SeqMapLen_12868(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_12869","instance":12869,"id":199540,"goal":"lemma SeqFilterLe_12869(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_12870","instance":12870,"id":199541,"goal":"lemma SeqMemberAppend_12870(s: seq, u: seq)\n ensures x in s + u <==> x in s || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_12871","instance":12871,"id":199542,"goal":"lemma SeqAppendLen_12871(u: seq, s: seq)\n ensures |u + s| == |u| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_12872","instance":12872,"id":199543,"goal":"lemma SeqAppendNil_12872(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_12873","instance":12873,"id":199544,"goal":"lemma SeqNilAppend_12873(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_12874","instance":12874,"id":199545,"goal":"lemma SeqAppendAssoc_12874(zs: seq, u: seq, t: seq)\n ensures (zs + u) + t == zs + (u + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_12875","instance":12875,"id":199546,"goal":"lemma SeqTakeDrop_12875(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_12876","instance":12876,"id":199547,"goal":"lemma SeqReverseLen_12876(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_12877","instance":12877,"id":199548,"goal":"lemma SeqReverseIdem_12877(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_12878","instance":12878,"id":199549,"goal":"lemma SeqMapLen_12878(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_12879","instance":12879,"id":199550,"goal":"lemma SeqFilterLe_12879(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_12880","instance":12880,"id":199551,"goal":"lemma SeqMemberAppend_12880(t: seq, zs: seq)\n ensures x in t + zs <==> x in t || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_12881","instance":12881,"id":199552,"goal":"lemma SeqAppendLen_12881(t: seq, xs: seq)\n ensures |t + xs| == |t| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_12882","instance":12882,"id":199553,"goal":"lemma SeqAppendNil_12882(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_12883","instance":12883,"id":199554,"goal":"lemma SeqNilAppend_12883(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_12884","instance":12884,"id":199555,"goal":"lemma SeqAppendAssoc_12884(xs: seq, s: seq, t: seq)\n ensures (xs + s) + t == xs + (s + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_12885","instance":12885,"id":199556,"goal":"lemma SeqTakeDrop_12885(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_12886","instance":12886,"id":199557,"goal":"lemma SeqReverseLen_12886(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_12887","instance":12887,"id":199558,"goal":"lemma SeqReverseIdem_12887(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_12888","instance":12888,"id":199559,"goal":"lemma SeqMapLen_12888(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_12889","instance":12889,"id":199560,"goal":"lemma SeqFilterLe_12889(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_12890","instance":12890,"id":199561,"goal":"lemma SeqMemberAppend_12890(zs: seq, s: seq)\n ensures x in zs + s <==> x in zs || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_12891","instance":12891,"id":199562,"goal":"lemma SeqAppendLen_12891(t: seq, u: seq)\n ensures |t + u| == |t| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_12892","instance":12892,"id":199563,"goal":"lemma SeqAppendNil_12892(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_12893","instance":12893,"id":199564,"goal":"lemma SeqNilAppend_12893(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_12894","instance":12894,"id":199565,"goal":"lemma SeqAppendAssoc_12894(zs: seq, u: seq, t: seq)\n ensures (zs + u) + t == zs + (u + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_12895","instance":12895,"id":199566,"goal":"lemma SeqTakeDrop_12895(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_12896","instance":12896,"id":199567,"goal":"lemma SeqReverseLen_12896(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_12897","instance":12897,"id":199568,"goal":"lemma SeqReverseIdem_12897(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_12898","instance":12898,"id":199569,"goal":"lemma SeqMapLen_12898(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_12899","instance":12899,"id":199570,"goal":"lemma SeqFilterLe_12899(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_12900","instance":12900,"id":199571,"goal":"lemma SeqMemberAppend_12900(s: seq, xs: seq)\n ensures x in s + xs <==> x in s || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_12901","instance":12901,"id":199572,"goal":"lemma SeqAppendLen_12901(ys: seq, xs: seq)\n ensures |ys + xs| == |ys| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_12902","instance":12902,"id":199573,"goal":"lemma SeqAppendNil_12902(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_12903","instance":12903,"id":199574,"goal":"lemma SeqNilAppend_12903(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_12904","instance":12904,"id":199575,"goal":"lemma SeqAppendAssoc_12904(s: seq, xs: seq, ys: seq)\n ensures (s + xs) + ys == s + (xs + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_12905","instance":12905,"id":199576,"goal":"lemma SeqTakeDrop_12905(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_12906","instance":12906,"id":199577,"goal":"lemma SeqReverseLen_12906(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_12907","instance":12907,"id":199578,"goal":"lemma SeqReverseIdem_12907(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_12908","instance":12908,"id":199579,"goal":"lemma SeqMapLen_12908(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_12909","instance":12909,"id":199580,"goal":"lemma SeqFilterLe_12909(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_12910","instance":12910,"id":199581,"goal":"lemma SeqMemberAppend_12910(s: seq, zs: seq)\n ensures x in s + zs <==> x in s || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_12911","instance":12911,"id":199582,"goal":"lemma SeqAppendLen_12911(s: seq, xs: seq)\n ensures |s + xs| == |s| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_12912","instance":12912,"id":199583,"goal":"lemma SeqAppendNil_12912(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_12913","instance":12913,"id":199584,"goal":"lemma SeqNilAppend_12913(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_12914","instance":12914,"id":199585,"goal":"lemma SeqAppendAssoc_12914(u: seq, ys: seq, xs: seq)\n ensures (u + ys) + xs == u + (ys + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_12915","instance":12915,"id":199586,"goal":"lemma SeqTakeDrop_12915(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_12916","instance":12916,"id":199587,"goal":"lemma SeqReverseLen_12916(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_12917","instance":12917,"id":199588,"goal":"lemma SeqReverseIdem_12917(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_12918","instance":12918,"id":199589,"goal":"lemma SeqMapLen_12918(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_12919","instance":12919,"id":199590,"goal":"lemma SeqFilterLe_12919(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_12920","instance":12920,"id":199591,"goal":"lemma SeqMemberAppend_12920(t: seq, s: seq)\n ensures x in t + s <==> x in t || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_12921","instance":12921,"id":199592,"goal":"lemma SeqAppendLen_12921(xs: seq, t: seq)\n ensures |xs + t| == |xs| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_12922","instance":12922,"id":199593,"goal":"lemma SeqAppendNil_12922(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_12923","instance":12923,"id":199594,"goal":"lemma SeqNilAppend_12923(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_12924","instance":12924,"id":199595,"goal":"lemma SeqAppendAssoc_12924(zs: seq, s: seq, u: seq)\n ensures (zs + s) + u == zs + (s + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_12925","instance":12925,"id":199596,"goal":"lemma SeqTakeDrop_12925(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_12926","instance":12926,"id":199597,"goal":"lemma SeqReverseLen_12926(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_12927","instance":12927,"id":199598,"goal":"lemma SeqReverseIdem_12927(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_12928","instance":12928,"id":199599,"goal":"lemma SeqMapLen_12928(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_12929","instance":12929,"id":199600,"goal":"lemma SeqFilterLe_12929(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_12930","instance":12930,"id":199601,"goal":"lemma SeqMemberAppend_12930(ys: seq, t: seq)\n ensures x in ys + t <==> x in ys || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_12931","instance":12931,"id":199602,"goal":"lemma SeqAppendLen_12931(s: seq, xs: seq)\n ensures |s + xs| == |s| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_12932","instance":12932,"id":199603,"goal":"lemma SeqAppendNil_12932(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_12933","instance":12933,"id":199604,"goal":"lemma SeqNilAppend_12933(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_12934","instance":12934,"id":199605,"goal":"lemma SeqAppendAssoc_12934(xs: seq, zs: seq, t: seq)\n ensures (xs + zs) + t == xs + (zs + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_12935","instance":12935,"id":199606,"goal":"lemma SeqTakeDrop_12935(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_12936","instance":12936,"id":199607,"goal":"lemma SeqReverseLen_12936(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_12937","instance":12937,"id":199608,"goal":"lemma SeqReverseIdem_12937(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_12938","instance":12938,"id":199609,"goal":"lemma SeqMapLen_12938(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_12939","instance":12939,"id":199610,"goal":"lemma SeqFilterLe_12939(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_12940","instance":12940,"id":199611,"goal":"lemma SeqMemberAppend_12940(s: seq, xs: seq)\n ensures x in s + xs <==> x in s || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_12941","instance":12941,"id":199612,"goal":"lemma SeqAppendLen_12941(u: seq, s: seq)\n ensures |u + s| == |u| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_12942","instance":12942,"id":199613,"goal":"lemma SeqAppendNil_12942(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_12943","instance":12943,"id":199614,"goal":"lemma SeqNilAppend_12943(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_12944","instance":12944,"id":199615,"goal":"lemma SeqAppendAssoc_12944(t: seq, ys: seq, zs: seq)\n ensures (t + ys) + zs == t + (ys + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_12945","instance":12945,"id":199616,"goal":"lemma SeqTakeDrop_12945(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_12946","instance":12946,"id":199617,"goal":"lemma SeqReverseLen_12946(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_12947","instance":12947,"id":199618,"goal":"lemma SeqReverseIdem_12947(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_12948","instance":12948,"id":199619,"goal":"lemma SeqMapLen_12948(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_12949","instance":12949,"id":199620,"goal":"lemma SeqFilterLe_12949(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_12950","instance":12950,"id":199621,"goal":"lemma SeqMemberAppend_12950(xs: seq, zs: seq)\n ensures x in xs + zs <==> x in xs || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_12951","instance":12951,"id":199622,"goal":"lemma SeqAppendLen_12951(ys: seq, t: seq)\n ensures |ys + t| == |ys| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_12952","instance":12952,"id":199623,"goal":"lemma SeqAppendNil_12952(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_12953","instance":12953,"id":199624,"goal":"lemma SeqNilAppend_12953(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_12954","instance":12954,"id":199625,"goal":"lemma SeqAppendAssoc_12954(s: seq, zs: seq, xs: seq)\n ensures (s + zs) + xs == s + (zs + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_12955","instance":12955,"id":199626,"goal":"lemma SeqTakeDrop_12955(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_12956","instance":12956,"id":199627,"goal":"lemma SeqReverseLen_12956(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_12957","instance":12957,"id":199628,"goal":"lemma SeqReverseIdem_12957(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_12958","instance":12958,"id":199629,"goal":"lemma SeqMapLen_12958(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_12959","instance":12959,"id":199630,"goal":"lemma SeqFilterLe_12959(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_12960","instance":12960,"id":199631,"goal":"lemma SeqMemberAppend_12960(zs: seq, t: seq)\n ensures x in zs + t <==> x in zs || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_12961","instance":12961,"id":199632,"goal":"lemma SeqAppendLen_12961(zs: seq, ys: seq)\n ensures |zs + ys| == |zs| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_12962","instance":12962,"id":199633,"goal":"lemma SeqAppendNil_12962(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_12963","instance":12963,"id":199634,"goal":"lemma SeqNilAppend_12963(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_12964","instance":12964,"id":199635,"goal":"lemma SeqAppendAssoc_12964(t: seq, ys: seq, zs: seq)\n ensures (t + ys) + zs == t + (ys + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_12965","instance":12965,"id":199636,"goal":"lemma SeqTakeDrop_12965(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_12966","instance":12966,"id":199637,"goal":"lemma SeqReverseLen_12966(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_12967","instance":12967,"id":199638,"goal":"lemma SeqReverseIdem_12967(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_12968","instance":12968,"id":199639,"goal":"lemma SeqMapLen_12968(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_12969","instance":12969,"id":199640,"goal":"lemma SeqFilterLe_12969(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_12970","instance":12970,"id":199641,"goal":"lemma SeqMemberAppend_12970(xs: seq, zs: seq)\n ensures x in xs + zs <==> x in xs || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_12971","instance":12971,"id":199642,"goal":"lemma SeqAppendLen_12971(ys: seq, zs: seq)\n ensures |ys + zs| == |ys| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_12972","instance":12972,"id":199643,"goal":"lemma SeqAppendNil_12972(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_12973","instance":12973,"id":199644,"goal":"lemma SeqNilAppend_12973(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_12974","instance":12974,"id":199645,"goal":"lemma SeqAppendAssoc_12974(xs: seq, s: seq, t: seq)\n ensures (xs + s) + t == xs + (s + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_12975","instance":12975,"id":199646,"goal":"lemma SeqTakeDrop_12975(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_12976","instance":12976,"id":199647,"goal":"lemma SeqReverseLen_12976(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_12977","instance":12977,"id":199648,"goal":"lemma SeqReverseIdem_12977(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_12978","instance":12978,"id":199649,"goal":"lemma SeqMapLen_12978(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_12979","instance":12979,"id":199650,"goal":"lemma SeqFilterLe_12979(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_12980","instance":12980,"id":199651,"goal":"lemma SeqMemberAppend_12980(t: seq, s: seq)\n ensures x in t + s <==> x in t || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_12981","instance":12981,"id":199652,"goal":"lemma SeqAppendLen_12981(s: seq, t: seq)\n ensures |s + t| == |s| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_12982","instance":12982,"id":199653,"goal":"lemma SeqAppendNil_12982(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_12983","instance":12983,"id":199654,"goal":"lemma SeqNilAppend_12983(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_12984","instance":12984,"id":199655,"goal":"lemma SeqAppendAssoc_12984(u: seq, xs: seq, ys: seq)\n ensures (u + xs) + ys == u + (xs + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_12985","instance":12985,"id":199656,"goal":"lemma SeqTakeDrop_12985(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_12986","instance":12986,"id":199657,"goal":"lemma SeqReverseLen_12986(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_12987","instance":12987,"id":199658,"goal":"lemma SeqReverseIdem_12987(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_12988","instance":12988,"id":199659,"goal":"lemma SeqMapLen_12988(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_12989","instance":12989,"id":199660,"goal":"lemma SeqFilterLe_12989(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_12990","instance":12990,"id":199661,"goal":"lemma SeqMemberAppend_12990(zs: seq, t: seq)\n ensures x in zs + t <==> x in zs || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_12991","instance":12991,"id":199662,"goal":"lemma SeqAppendLen_12991(ys: seq, s: seq)\n ensures |ys + s| == |ys| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_12992","instance":12992,"id":199663,"goal":"lemma SeqAppendNil_12992(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_12993","instance":12993,"id":199664,"goal":"lemma SeqNilAppend_12993(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_12994","instance":12994,"id":199665,"goal":"lemma SeqAppendAssoc_12994(xs: seq, ys: seq, t: seq)\n ensures (xs + ys) + t == xs + (ys + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_12995","instance":12995,"id":199666,"goal":"lemma SeqTakeDrop_12995(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_12996","instance":12996,"id":199667,"goal":"lemma SeqReverseLen_12996(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_12997","instance":12997,"id":199668,"goal":"lemma SeqReverseIdem_12997(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_12998","instance":12998,"id":199669,"goal":"lemma SeqMapLen_12998(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_12999","instance":12999,"id":199670,"goal":"lemma SeqFilterLe_12999(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_13000","instance":13000,"id":199671,"goal":"lemma SeqMemberAppend_13000(xs: seq, zs: seq)\n ensures x in xs + zs <==> x in xs || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_13001","instance":13001,"id":199672,"goal":"lemma SeqAppendLen_13001(zs: seq, u: seq)\n ensures |zs + u| == |zs| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_13002","instance":13002,"id":199673,"goal":"lemma SeqAppendNil_13002(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_13003","instance":13003,"id":199674,"goal":"lemma SeqNilAppend_13003(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_13004","instance":13004,"id":199675,"goal":"lemma SeqAppendAssoc_13004(ys: seq, s: seq, xs: seq)\n ensures (ys + s) + xs == ys + (s + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_13005","instance":13005,"id":199676,"goal":"lemma SeqTakeDrop_13005(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_13006","instance":13006,"id":199677,"goal":"lemma SeqReverseLen_13006(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_13007","instance":13007,"id":199678,"goal":"lemma SeqReverseIdem_13007(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_13008","instance":13008,"id":199679,"goal":"lemma SeqMapLen_13008(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_13009","instance":13009,"id":199680,"goal":"lemma SeqFilterLe_13009(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_13010","instance":13010,"id":199681,"goal":"lemma SeqMemberAppend_13010(s: seq, t: seq)\n ensures x in s + t <==> x in s || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_13011","instance":13011,"id":199682,"goal":"lemma SeqAppendLen_13011(xs: seq, t: seq)\n ensures |xs + t| == |xs| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_13012","instance":13012,"id":199683,"goal":"lemma SeqAppendNil_13012(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_13013","instance":13013,"id":199684,"goal":"lemma SeqNilAppend_13013(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_13014","instance":13014,"id":199685,"goal":"lemma SeqAppendAssoc_13014(u: seq, xs: seq, ys: seq)\n ensures (u + xs) + ys == u + (xs + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_13015","instance":13015,"id":199686,"goal":"lemma SeqTakeDrop_13015(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_13016","instance":13016,"id":199687,"goal":"lemma SeqReverseLen_13016(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_13017","instance":13017,"id":199688,"goal":"lemma SeqReverseIdem_13017(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_13018","instance":13018,"id":199689,"goal":"lemma SeqMapLen_13018(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_13019","instance":13019,"id":199690,"goal":"lemma SeqFilterLe_13019(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_13020","instance":13020,"id":199691,"goal":"lemma SeqMemberAppend_13020(u: seq, t: seq)\n ensures x in u + t <==> x in u || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_13021","instance":13021,"id":199692,"goal":"lemma SeqAppendLen_13021(t: seq, zs: seq)\n ensures |t + zs| == |t| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_13022","instance":13022,"id":199693,"goal":"lemma SeqAppendNil_13022(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_13023","instance":13023,"id":199694,"goal":"lemma SeqNilAppend_13023(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_13024","instance":13024,"id":199695,"goal":"lemma SeqAppendAssoc_13024(s: seq, t: seq, u: seq)\n ensures (s + t) + u == s + (t + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_13025","instance":13025,"id":199696,"goal":"lemma SeqTakeDrop_13025(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_13026","instance":13026,"id":199697,"goal":"lemma SeqReverseLen_13026(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_13027","instance":13027,"id":199698,"goal":"lemma SeqReverseIdem_13027(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_13028","instance":13028,"id":199699,"goal":"lemma SeqMapLen_13028(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_13029","instance":13029,"id":199700,"goal":"lemma SeqFilterLe_13029(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_13030","instance":13030,"id":199701,"goal":"lemma SeqMemberAppend_13030(s: seq, ys: seq)\n ensures x in s + ys <==> x in s || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_13031","instance":13031,"id":199702,"goal":"lemma SeqAppendLen_13031(s: seq, u: seq)\n ensures |s + u| == |s| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_13032","instance":13032,"id":199703,"goal":"lemma SeqAppendNil_13032(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_13033","instance":13033,"id":199704,"goal":"lemma SeqNilAppend_13033(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_13034","instance":13034,"id":199705,"goal":"lemma SeqAppendAssoc_13034(xs: seq, s: seq, ys: seq)\n ensures (xs + s) + ys == xs + (s + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_13035","instance":13035,"id":199706,"goal":"lemma SeqTakeDrop_13035(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_13036","instance":13036,"id":199707,"goal":"lemma SeqReverseLen_13036(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_13037","instance":13037,"id":199708,"goal":"lemma SeqReverseIdem_13037(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_13038","instance":13038,"id":199709,"goal":"lemma SeqMapLen_13038(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_13039","instance":13039,"id":199710,"goal":"lemma SeqFilterLe_13039(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_13040","instance":13040,"id":199711,"goal":"lemma SeqMemberAppend_13040(s: seq, ys: seq)\n ensures x in s + ys <==> x in s || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_13041","instance":13041,"id":199712,"goal":"lemma SeqAppendLen_13041(zs: seq, u: seq)\n ensures |zs + u| == |zs| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_13042","instance":13042,"id":199713,"goal":"lemma SeqAppendNil_13042(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_13043","instance":13043,"id":199714,"goal":"lemma SeqNilAppend_13043(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_13044","instance":13044,"id":199715,"goal":"lemma SeqAppendAssoc_13044(xs: seq, t: seq, ys: seq)\n ensures (xs + t) + ys == xs + (t + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_13045","instance":13045,"id":199716,"goal":"lemma SeqTakeDrop_13045(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_13046","instance":13046,"id":199717,"goal":"lemma SeqReverseLen_13046(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_13047","instance":13047,"id":199718,"goal":"lemma SeqReverseIdem_13047(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_13048","instance":13048,"id":199719,"goal":"lemma SeqMapLen_13048(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_13049","instance":13049,"id":199720,"goal":"lemma SeqFilterLe_13049(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_13050","instance":13050,"id":199721,"goal":"lemma SeqMemberAppend_13050(s: seq, ys: seq)\n ensures x in s + ys <==> x in s || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_13051","instance":13051,"id":199722,"goal":"lemma SeqAppendLen_13051(xs: seq, t: seq)\n ensures |xs + t| == |xs| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_13052","instance":13052,"id":199723,"goal":"lemma SeqAppendNil_13052(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_13053","instance":13053,"id":199724,"goal":"lemma SeqNilAppend_13053(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_13054","instance":13054,"id":199725,"goal":"lemma SeqAppendAssoc_13054(xs: seq, zs: seq, t: seq)\n ensures (xs + zs) + t == xs + (zs + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_13055","instance":13055,"id":199726,"goal":"lemma SeqTakeDrop_13055(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_13056","instance":13056,"id":199727,"goal":"lemma SeqReverseLen_13056(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_13057","instance":13057,"id":199728,"goal":"lemma SeqReverseIdem_13057(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_13058","instance":13058,"id":199729,"goal":"lemma SeqMapLen_13058(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_13059","instance":13059,"id":199730,"goal":"lemma SeqFilterLe_13059(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_13060","instance":13060,"id":199731,"goal":"lemma SeqMemberAppend_13060(u: seq, s: seq)\n ensures x in u + s <==> x in u || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_13061","instance":13061,"id":199732,"goal":"lemma SeqAppendLen_13061(xs: seq, s: seq)\n ensures |xs + s| == |xs| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_13062","instance":13062,"id":199733,"goal":"lemma SeqAppendNil_13062(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_13063","instance":13063,"id":199734,"goal":"lemma SeqNilAppend_13063(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_13064","instance":13064,"id":199735,"goal":"lemma SeqAppendAssoc_13064(s: seq, ys: seq, zs: seq)\n ensures (s + ys) + zs == s + (ys + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_13065","instance":13065,"id":199736,"goal":"lemma SeqTakeDrop_13065(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_13066","instance":13066,"id":199737,"goal":"lemma SeqReverseLen_13066(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_13067","instance":13067,"id":199738,"goal":"lemma SeqReverseIdem_13067(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_13068","instance":13068,"id":199739,"goal":"lemma SeqMapLen_13068(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_13069","instance":13069,"id":199740,"goal":"lemma SeqFilterLe_13069(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_13070","instance":13070,"id":199741,"goal":"lemma SeqMemberAppend_13070(s: seq, t: seq)\n ensures x in s + t <==> x in s || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_13071","instance":13071,"id":199742,"goal":"lemma SeqAppendLen_13071(ys: seq, zs: seq)\n ensures |ys + zs| == |ys| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_13072","instance":13072,"id":199743,"goal":"lemma SeqAppendNil_13072(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_13073","instance":13073,"id":199744,"goal":"lemma SeqNilAppend_13073(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_13074","instance":13074,"id":199745,"goal":"lemma SeqAppendAssoc_13074(xs: seq, s: seq, zs: seq)\n ensures (xs + s) + zs == xs + (s + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_13075","instance":13075,"id":199746,"goal":"lemma SeqTakeDrop_13075(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_13076","instance":13076,"id":199747,"goal":"lemma SeqReverseLen_13076(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_13077","instance":13077,"id":199748,"goal":"lemma SeqReverseIdem_13077(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_13078","instance":13078,"id":199749,"goal":"lemma SeqMapLen_13078(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_13079","instance":13079,"id":199750,"goal":"lemma SeqFilterLe_13079(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_13080","instance":13080,"id":199751,"goal":"lemma SeqMemberAppend_13080(s: seq, t: seq)\n ensures x in s + t <==> x in s || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_13081","instance":13081,"id":199752,"goal":"lemma SeqAppendLen_13081(s: seq, u: seq)\n ensures |s + u| == |s| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_13082","instance":13082,"id":199753,"goal":"lemma SeqAppendNil_13082(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_13083","instance":13083,"id":199754,"goal":"lemma SeqNilAppend_13083(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_13084","instance":13084,"id":199755,"goal":"lemma SeqAppendAssoc_13084(s: seq, u: seq, zs: seq)\n ensures (s + u) + zs == s + (u + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_13085","instance":13085,"id":199756,"goal":"lemma SeqTakeDrop_13085(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_13086","instance":13086,"id":199757,"goal":"lemma SeqReverseLen_13086(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_13087","instance":13087,"id":199758,"goal":"lemma SeqReverseIdem_13087(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_13088","instance":13088,"id":199759,"goal":"lemma SeqMapLen_13088(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_13089","instance":13089,"id":199760,"goal":"lemma SeqFilterLe_13089(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_13090","instance":13090,"id":199761,"goal":"lemma SeqMemberAppend_13090(s: seq, zs: seq)\n ensures x in s + zs <==> x in s || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_13091","instance":13091,"id":199762,"goal":"lemma SeqAppendLen_13091(xs: seq, t: seq)\n ensures |xs + t| == |xs| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_13092","instance":13092,"id":199763,"goal":"lemma SeqAppendNil_13092(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_13093","instance":13093,"id":199764,"goal":"lemma SeqNilAppend_13093(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_13094","instance":13094,"id":199765,"goal":"lemma SeqAppendAssoc_13094(xs: seq, ys: seq, s: seq)\n ensures (xs + ys) + s == xs + (ys + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_13095","instance":13095,"id":199766,"goal":"lemma SeqTakeDrop_13095(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_13096","instance":13096,"id":199767,"goal":"lemma SeqReverseLen_13096(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_13097","instance":13097,"id":199768,"goal":"lemma SeqReverseIdem_13097(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_13098","instance":13098,"id":199769,"goal":"lemma SeqMapLen_13098(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_13099","instance":13099,"id":199770,"goal":"lemma SeqFilterLe_13099(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_13100","instance":13100,"id":199771,"goal":"lemma SeqMemberAppend_13100(ys: seq, s: seq)\n ensures x in ys + s <==> x in ys || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_13101","instance":13101,"id":199772,"goal":"lemma SeqAppendLen_13101(t: seq, s: seq)\n ensures |t + s| == |t| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_13102","instance":13102,"id":199773,"goal":"lemma SeqAppendNil_13102(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_13103","instance":13103,"id":199774,"goal":"lemma SeqNilAppend_13103(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_13104","instance":13104,"id":199775,"goal":"lemma SeqAppendAssoc_13104(ys: seq, s: seq, t: seq)\n ensures (ys + s) + t == ys + (s + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_13105","instance":13105,"id":199776,"goal":"lemma SeqTakeDrop_13105(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_13106","instance":13106,"id":199777,"goal":"lemma SeqReverseLen_13106(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_13107","instance":13107,"id":199778,"goal":"lemma SeqReverseIdem_13107(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_13108","instance":13108,"id":199779,"goal":"lemma SeqMapLen_13108(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_13109","instance":13109,"id":199780,"goal":"lemma SeqFilterLe_13109(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_13110","instance":13110,"id":199781,"goal":"lemma SeqMemberAppend_13110(xs: seq, u: seq)\n ensures x in xs + u <==> x in xs || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_13111","instance":13111,"id":199782,"goal":"lemma SeqAppendLen_13111(s: seq, xs: seq)\n ensures |s + xs| == |s| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_13112","instance":13112,"id":199783,"goal":"lemma SeqAppendNil_13112(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_13113","instance":13113,"id":199784,"goal":"lemma SeqNilAppend_13113(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_13114","instance":13114,"id":199785,"goal":"lemma SeqAppendAssoc_13114(t: seq, ys: seq, u: seq)\n ensures (t + ys) + u == t + (ys + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_13115","instance":13115,"id":199786,"goal":"lemma SeqTakeDrop_13115(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_13116","instance":13116,"id":199787,"goal":"lemma SeqReverseLen_13116(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_13117","instance":13117,"id":199788,"goal":"lemma SeqReverseIdem_13117(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_13118","instance":13118,"id":199789,"goal":"lemma SeqMapLen_13118(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_13119","instance":13119,"id":199790,"goal":"lemma SeqFilterLe_13119(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_13120","instance":13120,"id":199791,"goal":"lemma SeqMemberAppend_13120(xs: seq, t: seq)\n ensures x in xs + t <==> x in xs || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_13121","instance":13121,"id":199792,"goal":"lemma SeqAppendLen_13121(xs: seq, ys: seq)\n ensures |xs + ys| == |xs| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_13122","instance":13122,"id":199793,"goal":"lemma SeqAppendNil_13122(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_13123","instance":13123,"id":199794,"goal":"lemma SeqNilAppend_13123(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_13124","instance":13124,"id":199795,"goal":"lemma SeqAppendAssoc_13124(xs: seq, s: seq, zs: seq)\n ensures (xs + s) + zs == xs + (s + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_13125","instance":13125,"id":199796,"goal":"lemma SeqTakeDrop_13125(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_13126","instance":13126,"id":199797,"goal":"lemma SeqReverseLen_13126(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_13127","instance":13127,"id":199798,"goal":"lemma SeqReverseIdem_13127(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_13128","instance":13128,"id":199799,"goal":"lemma SeqMapLen_13128(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_13129","instance":13129,"id":199800,"goal":"lemma SeqFilterLe_13129(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_13130","instance":13130,"id":199801,"goal":"lemma SeqMemberAppend_13130(s: seq, u: seq)\n ensures x in s + u <==> x in s || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_13131","instance":13131,"id":199802,"goal":"lemma SeqAppendLen_13131(ys: seq, t: seq)\n ensures |ys + t| == |ys| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_13132","instance":13132,"id":199803,"goal":"lemma SeqAppendNil_13132(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_13133","instance":13133,"id":199804,"goal":"lemma SeqNilAppend_13133(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_13134","instance":13134,"id":199805,"goal":"lemma SeqAppendAssoc_13134(xs: seq, ys: seq, u: seq)\n ensures (xs + ys) + u == xs + (ys + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_13135","instance":13135,"id":199806,"goal":"lemma SeqTakeDrop_13135(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_13136","instance":13136,"id":199807,"goal":"lemma SeqReverseLen_13136(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_13137","instance":13137,"id":199808,"goal":"lemma SeqReverseIdem_13137(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_13138","instance":13138,"id":199809,"goal":"lemma SeqMapLen_13138(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_13139","instance":13139,"id":199810,"goal":"lemma SeqFilterLe_13139(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_13140","instance":13140,"id":199811,"goal":"lemma SeqMemberAppend_13140(zs: seq, s: seq)\n ensures x in zs + s <==> x in zs || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_13141","instance":13141,"id":199812,"goal":"lemma SeqAppendLen_13141(ys: seq, u: seq)\n ensures |ys + u| == |ys| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_13142","instance":13142,"id":199813,"goal":"lemma SeqAppendNil_13142(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_13143","instance":13143,"id":199814,"goal":"lemma SeqNilAppend_13143(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_13144","instance":13144,"id":199815,"goal":"lemma SeqAppendAssoc_13144(t: seq, zs: seq, ys: seq)\n ensures (t + zs) + ys == t + (zs + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_13145","instance":13145,"id":199816,"goal":"lemma SeqTakeDrop_13145(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_13146","instance":13146,"id":199817,"goal":"lemma SeqReverseLen_13146(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_13147","instance":13147,"id":199818,"goal":"lemma SeqReverseIdem_13147(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_13148","instance":13148,"id":199819,"goal":"lemma SeqMapLen_13148(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_13149","instance":13149,"id":199820,"goal":"lemma SeqFilterLe_13149(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_13150","instance":13150,"id":199821,"goal":"lemma SeqMemberAppend_13150(u: seq, ys: seq)\n ensures x in u + ys <==> x in u || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_13151","instance":13151,"id":199822,"goal":"lemma SeqAppendLen_13151(s: seq, t: seq)\n ensures |s + t| == |s| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_13152","instance":13152,"id":199823,"goal":"lemma SeqAppendNil_13152(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_13153","instance":13153,"id":199824,"goal":"lemma SeqNilAppend_13153(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_13154","instance":13154,"id":199825,"goal":"lemma SeqAppendAssoc_13154(zs: seq, xs: seq, t: seq)\n ensures (zs + xs) + t == zs + (xs + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_13155","instance":13155,"id":199826,"goal":"lemma SeqTakeDrop_13155(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_13156","instance":13156,"id":199827,"goal":"lemma SeqReverseLen_13156(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_13157","instance":13157,"id":199828,"goal":"lemma SeqReverseIdem_13157(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_13158","instance":13158,"id":199829,"goal":"lemma SeqMapLen_13158(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_13159","instance":13159,"id":199830,"goal":"lemma SeqFilterLe_13159(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_13160","instance":13160,"id":199831,"goal":"lemma SeqMemberAppend_13160(u: seq, s: seq)\n ensures x in u + s <==> x in u || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_13161","instance":13161,"id":199832,"goal":"lemma SeqAppendLen_13161(t: seq, ys: seq)\n ensures |t + ys| == |t| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_13162","instance":13162,"id":199833,"goal":"lemma SeqAppendNil_13162(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_13163","instance":13163,"id":199834,"goal":"lemma SeqNilAppend_13163(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_13164","instance":13164,"id":199835,"goal":"lemma SeqAppendAssoc_13164(zs: seq, u: seq, xs: seq)\n ensures (zs + u) + xs == zs + (u + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_13165","instance":13165,"id":199836,"goal":"lemma SeqTakeDrop_13165(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_13166","instance":13166,"id":199837,"goal":"lemma SeqReverseLen_13166(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_13167","instance":13167,"id":199838,"goal":"lemma SeqReverseIdem_13167(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_13168","instance":13168,"id":199839,"goal":"lemma SeqMapLen_13168(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_13169","instance":13169,"id":199840,"goal":"lemma SeqFilterLe_13169(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_13170","instance":13170,"id":199841,"goal":"lemma SeqMemberAppend_13170(xs: seq, t: seq)\n ensures x in xs + t <==> x in xs || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_13171","instance":13171,"id":199842,"goal":"lemma SeqAppendLen_13171(t: seq, zs: seq)\n ensures |t + zs| == |t| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_13172","instance":13172,"id":199843,"goal":"lemma SeqAppendNil_13172(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_13173","instance":13173,"id":199844,"goal":"lemma SeqNilAppend_13173(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_13174","instance":13174,"id":199845,"goal":"lemma SeqAppendAssoc_13174(s: seq, ys: seq, u: seq)\n ensures (s + ys) + u == s + (ys + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_13175","instance":13175,"id":199846,"goal":"lemma SeqTakeDrop_13175(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_13176","instance":13176,"id":199847,"goal":"lemma SeqReverseLen_13176(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_13177","instance":13177,"id":199848,"goal":"lemma SeqReverseIdem_13177(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_13178","instance":13178,"id":199849,"goal":"lemma SeqMapLen_13178(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_13179","instance":13179,"id":199850,"goal":"lemma SeqFilterLe_13179(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_13180","instance":13180,"id":199851,"goal":"lemma SeqMemberAppend_13180(s: seq, t: seq)\n ensures x in s + t <==> x in s || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_13181","instance":13181,"id":199852,"goal":"lemma SeqAppendLen_13181(s: seq, ys: seq)\n ensures |s + ys| == |s| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_13182","instance":13182,"id":199853,"goal":"lemma SeqAppendNil_13182(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_13183","instance":13183,"id":199854,"goal":"lemma SeqNilAppend_13183(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_13184","instance":13184,"id":199855,"goal":"lemma SeqAppendAssoc_13184(xs: seq, s: seq, t: seq)\n ensures (xs + s) + t == xs + (s + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_13185","instance":13185,"id":199856,"goal":"lemma SeqTakeDrop_13185(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_13186","instance":13186,"id":199857,"goal":"lemma SeqReverseLen_13186(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_13187","instance":13187,"id":199858,"goal":"lemma SeqReverseIdem_13187(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_13188","instance":13188,"id":199859,"goal":"lemma SeqMapLen_13188(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_13189","instance":13189,"id":199860,"goal":"lemma SeqFilterLe_13189(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_13190","instance":13190,"id":199861,"goal":"lemma SeqMemberAppend_13190(u: seq, t: seq)\n ensures x in u + t <==> x in u || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_13191","instance":13191,"id":199862,"goal":"lemma SeqAppendLen_13191(u: seq, s: seq)\n ensures |u + s| == |u| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_13192","instance":13192,"id":199863,"goal":"lemma SeqAppendNil_13192(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_13193","instance":13193,"id":199864,"goal":"lemma SeqNilAppend_13193(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_13194","instance":13194,"id":199865,"goal":"lemma SeqAppendAssoc_13194(t: seq, s: seq, ys: seq)\n ensures (t + s) + ys == t + (s + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_13195","instance":13195,"id":199866,"goal":"lemma SeqTakeDrop_13195(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_13196","instance":13196,"id":199867,"goal":"lemma SeqReverseLen_13196(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_13197","instance":13197,"id":199868,"goal":"lemma SeqReverseIdem_13197(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_13198","instance":13198,"id":199869,"goal":"lemma SeqMapLen_13198(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_13199","instance":13199,"id":199870,"goal":"lemma SeqFilterLe_13199(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_13200","instance":13200,"id":199871,"goal":"lemma SeqMemberAppend_13200(xs: seq, t: seq)\n ensures x in xs + t <==> x in xs || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_13201","instance":13201,"id":199872,"goal":"lemma SeqAppendLen_13201(u: seq, xs: seq)\n ensures |u + xs| == |u| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_13202","instance":13202,"id":199873,"goal":"lemma SeqAppendNil_13202(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_13203","instance":13203,"id":199874,"goal":"lemma SeqNilAppend_13203(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_13204","instance":13204,"id":199875,"goal":"lemma SeqAppendAssoc_13204(s: seq, zs: seq, u: seq)\n ensures (s + zs) + u == s + (zs + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_13205","instance":13205,"id":199876,"goal":"lemma SeqTakeDrop_13205(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_13206","instance":13206,"id":199877,"goal":"lemma SeqReverseLen_13206(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_13207","instance":13207,"id":199878,"goal":"lemma SeqReverseIdem_13207(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_13208","instance":13208,"id":199879,"goal":"lemma SeqMapLen_13208(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_13209","instance":13209,"id":199880,"goal":"lemma SeqFilterLe_13209(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_13210","instance":13210,"id":199881,"goal":"lemma SeqMemberAppend_13210(t: seq, s: seq)\n ensures x in t + s <==> x in t || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_13211","instance":13211,"id":199882,"goal":"lemma SeqAppendLen_13211(xs: seq, u: seq)\n ensures |xs + u| == |xs| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_13212","instance":13212,"id":199883,"goal":"lemma SeqAppendNil_13212(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_13213","instance":13213,"id":199884,"goal":"lemma SeqNilAppend_13213(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_13214","instance":13214,"id":199885,"goal":"lemma SeqAppendAssoc_13214(u: seq, t: seq, xs: seq)\n ensures (u + t) + xs == u + (t + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_13215","instance":13215,"id":199886,"goal":"lemma SeqTakeDrop_13215(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_13216","instance":13216,"id":199887,"goal":"lemma SeqReverseLen_13216(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_13217","instance":13217,"id":199888,"goal":"lemma SeqReverseIdem_13217(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_13218","instance":13218,"id":199889,"goal":"lemma SeqMapLen_13218(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_13219","instance":13219,"id":199890,"goal":"lemma SeqFilterLe_13219(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_13220","instance":13220,"id":199891,"goal":"lemma SeqMemberAppend_13220(u: seq, ys: seq)\n ensures x in u + ys <==> x in u || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_13221","instance":13221,"id":199892,"goal":"lemma SeqAppendLen_13221(ys: seq, u: seq)\n ensures |ys + u| == |ys| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_13222","instance":13222,"id":199893,"goal":"lemma SeqAppendNil_13222(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_13223","instance":13223,"id":199894,"goal":"lemma SeqNilAppend_13223(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_13224","instance":13224,"id":199895,"goal":"lemma SeqAppendAssoc_13224(s: seq, u: seq, t: seq)\n ensures (s + u) + t == s + (u + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_13225","instance":13225,"id":199896,"goal":"lemma SeqTakeDrop_13225(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_13226","instance":13226,"id":199897,"goal":"lemma SeqReverseLen_13226(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_13227","instance":13227,"id":199898,"goal":"lemma SeqReverseIdem_13227(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_13228","instance":13228,"id":199899,"goal":"lemma SeqMapLen_13228(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_13229","instance":13229,"id":199900,"goal":"lemma SeqFilterLe_13229(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_13230","instance":13230,"id":199901,"goal":"lemma SeqMemberAppend_13230(zs: seq, xs: seq)\n ensures x in zs + xs <==> x in zs || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_13231","instance":13231,"id":199902,"goal":"lemma SeqAppendLen_13231(ys: seq, xs: seq)\n ensures |ys + xs| == |ys| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_13232","instance":13232,"id":199903,"goal":"lemma SeqAppendNil_13232(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_13233","instance":13233,"id":199904,"goal":"lemma SeqNilAppend_13233(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_13234","instance":13234,"id":199905,"goal":"lemma SeqAppendAssoc_13234(t: seq, xs: seq, ys: seq)\n ensures (t + xs) + ys == t + (xs + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_13235","instance":13235,"id":199906,"goal":"lemma SeqTakeDrop_13235(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_13236","instance":13236,"id":199907,"goal":"lemma SeqReverseLen_13236(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_13237","instance":13237,"id":199908,"goal":"lemma SeqReverseIdem_13237(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_13238","instance":13238,"id":199909,"goal":"lemma SeqMapLen_13238(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_13239","instance":13239,"id":199910,"goal":"lemma SeqFilterLe_13239(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_13240","instance":13240,"id":199911,"goal":"lemma SeqMemberAppend_13240(xs: seq, u: seq)\n ensures x in xs + u <==> x in xs || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_13241","instance":13241,"id":199912,"goal":"lemma SeqAppendLen_13241(s: seq, zs: seq)\n ensures |s + zs| == |s| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_13242","instance":13242,"id":199913,"goal":"lemma SeqAppendNil_13242(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_13243","instance":13243,"id":199914,"goal":"lemma SeqNilAppend_13243(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_13244","instance":13244,"id":199915,"goal":"lemma SeqAppendAssoc_13244(t: seq, zs: seq, s: seq)\n ensures (t + zs) + s == t + (zs + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_13245","instance":13245,"id":199916,"goal":"lemma SeqTakeDrop_13245(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_13246","instance":13246,"id":199917,"goal":"lemma SeqReverseLen_13246(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_13247","instance":13247,"id":199918,"goal":"lemma SeqReverseIdem_13247(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_13248","instance":13248,"id":199919,"goal":"lemma SeqMapLen_13248(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_13249","instance":13249,"id":199920,"goal":"lemma SeqFilterLe_13249(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_13250","instance":13250,"id":199921,"goal":"lemma SeqMemberAppend_13250(t: seq, zs: seq)\n ensures x in t + zs <==> x in t || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_13251","instance":13251,"id":199922,"goal":"lemma SeqAppendLen_13251(t: seq, u: seq)\n ensures |t + u| == |t| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_13252","instance":13252,"id":199923,"goal":"lemma SeqAppendNil_13252(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_13253","instance":13253,"id":199924,"goal":"lemma SeqNilAppend_13253(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_13254","instance":13254,"id":199925,"goal":"lemma SeqAppendAssoc_13254(xs: seq, t: seq, zs: seq)\n ensures (xs + t) + zs == xs + (t + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_13255","instance":13255,"id":199926,"goal":"lemma SeqTakeDrop_13255(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_13256","instance":13256,"id":199927,"goal":"lemma SeqReverseLen_13256(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_13257","instance":13257,"id":199928,"goal":"lemma SeqReverseIdem_13257(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_13258","instance":13258,"id":199929,"goal":"lemma SeqMapLen_13258(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_13259","instance":13259,"id":199930,"goal":"lemma SeqFilterLe_13259(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_13260","instance":13260,"id":199931,"goal":"lemma SeqMemberAppend_13260(u: seq, t: seq)\n ensures x in u + t <==> x in u || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_13261","instance":13261,"id":199932,"goal":"lemma SeqAppendLen_13261(ys: seq, u: seq)\n ensures |ys + u| == |ys| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_13262","instance":13262,"id":199933,"goal":"lemma SeqAppendNil_13262(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_13263","instance":13263,"id":199934,"goal":"lemma SeqNilAppend_13263(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_13264","instance":13264,"id":199935,"goal":"lemma SeqAppendAssoc_13264(zs: seq, u: seq, xs: seq)\n ensures (zs + u) + xs == zs + (u + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_13265","instance":13265,"id":199936,"goal":"lemma SeqTakeDrop_13265(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_13266","instance":13266,"id":199937,"goal":"lemma SeqReverseLen_13266(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_13267","instance":13267,"id":199938,"goal":"lemma SeqReverseIdem_13267(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_13268","instance":13268,"id":199939,"goal":"lemma SeqMapLen_13268(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_13269","instance":13269,"id":199940,"goal":"lemma SeqFilterLe_13269(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_13270","instance":13270,"id":199941,"goal":"lemma SeqMemberAppend_13270(s: seq, zs: seq)\n ensures x in s + zs <==> x in s || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_13271","instance":13271,"id":199942,"goal":"lemma SeqAppendLen_13271(u: seq, t: seq)\n ensures |u + t| == |u| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_13272","instance":13272,"id":199943,"goal":"lemma SeqAppendNil_13272(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_13273","instance":13273,"id":199944,"goal":"lemma SeqNilAppend_13273(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_13274","instance":13274,"id":199945,"goal":"lemma SeqAppendAssoc_13274(zs: seq, u: seq, xs: seq)\n ensures (zs + u) + xs == zs + (u + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_13275","instance":13275,"id":199946,"goal":"lemma SeqTakeDrop_13275(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_13276","instance":13276,"id":199947,"goal":"lemma SeqReverseLen_13276(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_13277","instance":13277,"id":199948,"goal":"lemma SeqReverseIdem_13277(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_13278","instance":13278,"id":199949,"goal":"lemma SeqMapLen_13278(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_13279","instance":13279,"id":199950,"goal":"lemma SeqFilterLe_13279(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_13280","instance":13280,"id":199951,"goal":"lemma SeqMemberAppend_13280(ys: seq, s: seq)\n ensures x in ys + s <==> x in ys || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_13281","instance":13281,"id":199952,"goal":"lemma SeqAppendLen_13281(zs: seq, u: seq)\n ensures |zs + u| == |zs| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_13282","instance":13282,"id":199953,"goal":"lemma SeqAppendNil_13282(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_13283","instance":13283,"id":199954,"goal":"lemma SeqNilAppend_13283(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_13284","instance":13284,"id":199955,"goal":"lemma SeqAppendAssoc_13284(zs: seq, ys: seq, s: seq)\n ensures (zs + ys) + s == zs + (ys + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_13285","instance":13285,"id":199956,"goal":"lemma SeqTakeDrop_13285(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_13286","instance":13286,"id":199957,"goal":"lemma SeqReverseLen_13286(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_13287","instance":13287,"id":199958,"goal":"lemma SeqReverseIdem_13287(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_13288","instance":13288,"id":199959,"goal":"lemma SeqMapLen_13288(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_13289","instance":13289,"id":199960,"goal":"lemma SeqFilterLe_13289(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_13290","instance":13290,"id":199961,"goal":"lemma SeqMemberAppend_13290(zs: seq, ys: seq)\n ensures x in zs + ys <==> x in zs || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_13291","instance":13291,"id":199962,"goal":"lemma SeqAppendLen_13291(u: seq, t: seq)\n ensures |u + t| == |u| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_13292","instance":13292,"id":199963,"goal":"lemma SeqAppendNil_13292(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_13293","instance":13293,"id":199964,"goal":"lemma SeqNilAppend_13293(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_13294","instance":13294,"id":199965,"goal":"lemma SeqAppendAssoc_13294(zs: seq, xs: seq, ys: seq)\n ensures (zs + xs) + ys == zs + (xs + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_13295","instance":13295,"id":199966,"goal":"lemma SeqTakeDrop_13295(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_13296","instance":13296,"id":199967,"goal":"lemma SeqReverseLen_13296(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_13297","instance":13297,"id":199968,"goal":"lemma SeqReverseIdem_13297(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_13298","instance":13298,"id":199969,"goal":"lemma SeqMapLen_13298(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_13299","instance":13299,"id":199970,"goal":"lemma SeqFilterLe_13299(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_13300","instance":13300,"id":199971,"goal":"lemma SeqMemberAppend_13300(xs: seq, t: seq)\n ensures x in xs + t <==> x in xs || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_13301","instance":13301,"id":199972,"goal":"lemma SeqAppendLen_13301(u: seq, ys: seq)\n ensures |u + ys| == |u| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_13302","instance":13302,"id":199973,"goal":"lemma SeqAppendNil_13302(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_13303","instance":13303,"id":199974,"goal":"lemma SeqNilAppend_13303(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_13304","instance":13304,"id":199975,"goal":"lemma SeqAppendAssoc_13304(zs: seq, u: seq, ys: seq)\n ensures (zs + u) + ys == zs + (u + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_13305","instance":13305,"id":199976,"goal":"lemma SeqTakeDrop_13305(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_13306","instance":13306,"id":199977,"goal":"lemma SeqReverseLen_13306(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_13307","instance":13307,"id":199978,"goal":"lemma SeqReverseIdem_13307(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_13308","instance":13308,"id":199979,"goal":"lemma SeqMapLen_13308(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_13309","instance":13309,"id":199980,"goal":"lemma SeqFilterLe_13309(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_13310","instance":13310,"id":199981,"goal":"lemma SeqMemberAppend_13310(t: seq, xs: seq)\n ensures x in t + xs <==> x in t || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_13311","instance":13311,"id":199982,"goal":"lemma SeqAppendLen_13311(u: seq, ys: seq)\n ensures |u + ys| == |u| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_13312","instance":13312,"id":199983,"goal":"lemma SeqAppendNil_13312(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_13313","instance":13313,"id":199984,"goal":"lemma SeqNilAppend_13313(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_13314","instance":13314,"id":199985,"goal":"lemma SeqAppendAssoc_13314(u: seq, zs: seq, s: seq)\n ensures (u + zs) + s == u + (zs + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_13315","instance":13315,"id":199986,"goal":"lemma SeqTakeDrop_13315(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_13316","instance":13316,"id":199987,"goal":"lemma SeqReverseLen_13316(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_13317","instance":13317,"id":199988,"goal":"lemma SeqReverseIdem_13317(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_13318","instance":13318,"id":199989,"goal":"lemma SeqMapLen_13318(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_13319","instance":13319,"id":199990,"goal":"lemma SeqFilterLe_13319(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_13320","instance":13320,"id":199991,"goal":"lemma SeqMemberAppend_13320(s: seq, zs: seq)\n ensures x in s + zs <==> x in s || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_13321","instance":13321,"id":199992,"goal":"lemma SeqAppendLen_13321(zs: seq, ys: seq)\n ensures |zs + ys| == |zs| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_13322","instance":13322,"id":199993,"goal":"lemma SeqAppendNil_13322(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_13323","instance":13323,"id":199994,"goal":"lemma SeqNilAppend_13323(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_13324","instance":13324,"id":199995,"goal":"lemma SeqAppendAssoc_13324(ys: seq, s: seq, xs: seq)\n ensures (ys + s) + xs == ys + (s + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_13325","instance":13325,"id":199996,"goal":"lemma SeqTakeDrop_13325(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_13326","instance":13326,"id":199997,"goal":"lemma SeqReverseLen_13326(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_13327","instance":13327,"id":199998,"goal":"lemma SeqReverseIdem_13327(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_13328","instance":13328,"id":199999,"goal":"lemma SeqMapLen_13328(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_13329","instance":13329,"id":200000,"goal":"lemma SeqFilterLe_13329(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_13330","instance":13330,"id":200001,"goal":"lemma SeqMemberAppend_13330(ys: seq, zs: seq)\n ensures x in ys + zs <==> x in ys || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_13331","instance":13331,"id":200002,"goal":"lemma SeqAppendLen_13331(t: seq, zs: seq)\n ensures |t + zs| == |t| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_13332","instance":13332,"id":200003,"goal":"lemma SeqAppendNil_13332(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_13333","instance":13333,"id":200004,"goal":"lemma SeqNilAppend_13333(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_13334","instance":13334,"id":200005,"goal":"lemma SeqAppendAssoc_13334(zs: seq, xs: seq, t: seq)\n ensures (zs + xs) + t == zs + (xs + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_13335","instance":13335,"id":200006,"goal":"lemma SeqTakeDrop_13335(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_13336","instance":13336,"id":200007,"goal":"lemma SeqReverseLen_13336(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_13337","instance":13337,"id":200008,"goal":"lemma SeqReverseIdem_13337(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_13338","instance":13338,"id":200009,"goal":"lemma SeqMapLen_13338(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_13339","instance":13339,"id":200010,"goal":"lemma SeqFilterLe_13339(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_13340","instance":13340,"id":200011,"goal":"lemma SeqMemberAppend_13340(xs: seq, u: seq)\n ensures x in xs + u <==> x in xs || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_13341","instance":13341,"id":200012,"goal":"lemma SeqAppendLen_13341(t: seq, ys: seq)\n ensures |t + ys| == |t| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_13342","instance":13342,"id":200013,"goal":"lemma SeqAppendNil_13342(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_13343","instance":13343,"id":200014,"goal":"lemma SeqNilAppend_13343(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_13344","instance":13344,"id":200015,"goal":"lemma SeqAppendAssoc_13344(zs: seq, s: seq, ys: seq)\n ensures (zs + s) + ys == zs + (s + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_13345","instance":13345,"id":200016,"goal":"lemma SeqTakeDrop_13345(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_13346","instance":13346,"id":200017,"goal":"lemma SeqReverseLen_13346(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_13347","instance":13347,"id":200018,"goal":"lemma SeqReverseIdem_13347(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_13348","instance":13348,"id":200019,"goal":"lemma SeqMapLen_13348(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_13349","instance":13349,"id":200020,"goal":"lemma SeqFilterLe_13349(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_13350","instance":13350,"id":200021,"goal":"lemma SeqMemberAppend_13350(xs: seq, s: seq)\n ensures x in xs + s <==> x in xs || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_13351","instance":13351,"id":200022,"goal":"lemma SeqAppendLen_13351(u: seq, t: seq)\n ensures |u + t| == |u| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_13352","instance":13352,"id":200023,"goal":"lemma SeqAppendNil_13352(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_13353","instance":13353,"id":200024,"goal":"lemma SeqNilAppend_13353(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_13354","instance":13354,"id":200025,"goal":"lemma SeqAppendAssoc_13354(s: seq, zs: seq, u: seq)\n ensures (s + zs) + u == s + (zs + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_13355","instance":13355,"id":200026,"goal":"lemma SeqTakeDrop_13355(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_13356","instance":13356,"id":200027,"goal":"lemma SeqReverseLen_13356(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_13357","instance":13357,"id":200028,"goal":"lemma SeqReverseIdem_13357(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_13358","instance":13358,"id":200029,"goal":"lemma SeqMapLen_13358(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_13359","instance":13359,"id":200030,"goal":"lemma SeqFilterLe_13359(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_13360","instance":13360,"id":200031,"goal":"lemma SeqMemberAppend_13360(s: seq, zs: seq)\n ensures x in s + zs <==> x in s || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_13361","instance":13361,"id":200032,"goal":"lemma SeqAppendLen_13361(ys: seq, xs: seq)\n ensures |ys + xs| == |ys| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_13362","instance":13362,"id":200033,"goal":"lemma SeqAppendNil_13362(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_13363","instance":13363,"id":200034,"goal":"lemma SeqNilAppend_13363(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_13364","instance":13364,"id":200035,"goal":"lemma SeqAppendAssoc_13364(zs: seq, u: seq, s: seq)\n ensures (zs + u) + s == zs + (u + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_13365","instance":13365,"id":200036,"goal":"lemma SeqTakeDrop_13365(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_13366","instance":13366,"id":200037,"goal":"lemma SeqReverseLen_13366(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_13367","instance":13367,"id":200038,"goal":"lemma SeqReverseIdem_13367(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_13368","instance":13368,"id":200039,"goal":"lemma SeqMapLen_13368(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_13369","instance":13369,"id":200040,"goal":"lemma SeqFilterLe_13369(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_13370","instance":13370,"id":200041,"goal":"lemma SeqMemberAppend_13370(s: seq, xs: seq)\n ensures x in s + xs <==> x in s || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_13371","instance":13371,"id":200042,"goal":"lemma SeqAppendLen_13371(u: seq, t: seq)\n ensures |u + t| == |u| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_13372","instance":13372,"id":200043,"goal":"lemma SeqAppendNil_13372(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_13373","instance":13373,"id":200044,"goal":"lemma SeqNilAppend_13373(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_13374","instance":13374,"id":200045,"goal":"lemma SeqAppendAssoc_13374(t: seq, zs: seq, s: seq)\n ensures (t + zs) + s == t + (zs + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_13375","instance":13375,"id":200046,"goal":"lemma SeqTakeDrop_13375(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_13376","instance":13376,"id":200047,"goal":"lemma SeqReverseLen_13376(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_13377","instance":13377,"id":200048,"goal":"lemma SeqReverseIdem_13377(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_13378","instance":13378,"id":200049,"goal":"lemma SeqMapLen_13378(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_13379","instance":13379,"id":200050,"goal":"lemma SeqFilterLe_13379(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_13380","instance":13380,"id":200051,"goal":"lemma SeqMemberAppend_13380(u: seq, s: seq)\n ensures x in u + s <==> x in u || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_13381","instance":13381,"id":200052,"goal":"lemma SeqAppendLen_13381(s: seq, zs: seq)\n ensures |s + zs| == |s| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_13382","instance":13382,"id":200053,"goal":"lemma SeqAppendNil_13382(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_13383","instance":13383,"id":200054,"goal":"lemma SeqNilAppend_13383(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_13384","instance":13384,"id":200055,"goal":"lemma SeqAppendAssoc_13384(u: seq, ys: seq, xs: seq)\n ensures (u + ys) + xs == u + (ys + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_13385","instance":13385,"id":200056,"goal":"lemma SeqTakeDrop_13385(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_13386","instance":13386,"id":200057,"goal":"lemma SeqReverseLen_13386(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_13387","instance":13387,"id":200058,"goal":"lemma SeqReverseIdem_13387(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_13388","instance":13388,"id":200059,"goal":"lemma SeqMapLen_13388(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_13389","instance":13389,"id":200060,"goal":"lemma SeqFilterLe_13389(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_13390","instance":13390,"id":200061,"goal":"lemma SeqMemberAppend_13390(t: seq, u: seq)\n ensures x in t + u <==> x in t || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_13391","instance":13391,"id":200062,"goal":"lemma SeqAppendLen_13391(ys: seq, t: seq)\n ensures |ys + t| == |ys| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_13392","instance":13392,"id":200063,"goal":"lemma SeqAppendNil_13392(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_13393","instance":13393,"id":200064,"goal":"lemma SeqNilAppend_13393(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_13394","instance":13394,"id":200065,"goal":"lemma SeqAppendAssoc_13394(zs: seq, s: seq, xs: seq)\n ensures (zs + s) + xs == zs + (s + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_13395","instance":13395,"id":200066,"goal":"lemma SeqTakeDrop_13395(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_13396","instance":13396,"id":200067,"goal":"lemma SeqReverseLen_13396(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_13397","instance":13397,"id":200068,"goal":"lemma SeqReverseIdem_13397(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_13398","instance":13398,"id":200069,"goal":"lemma SeqMapLen_13398(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_13399","instance":13399,"id":200070,"goal":"lemma SeqFilterLe_13399(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_13400","instance":13400,"id":200071,"goal":"lemma SeqMemberAppend_13400(ys: seq, s: seq)\n ensures x in ys + s <==> x in ys || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_13401","instance":13401,"id":200072,"goal":"lemma SeqAppendLen_13401(u: seq, s: seq)\n ensures |u + s| == |u| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_13402","instance":13402,"id":200073,"goal":"lemma SeqAppendNil_13402(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_13403","instance":13403,"id":200074,"goal":"lemma SeqNilAppend_13403(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_13404","instance":13404,"id":200075,"goal":"lemma SeqAppendAssoc_13404(u: seq, zs: seq, ys: seq)\n ensures (u + zs) + ys == u + (zs + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_13405","instance":13405,"id":200076,"goal":"lemma SeqTakeDrop_13405(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_13406","instance":13406,"id":200077,"goal":"lemma SeqReverseLen_13406(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_13407","instance":13407,"id":200078,"goal":"lemma SeqReverseIdem_13407(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_13408","instance":13408,"id":200079,"goal":"lemma SeqMapLen_13408(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_13409","instance":13409,"id":200080,"goal":"lemma SeqFilterLe_13409(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_13410","instance":13410,"id":200081,"goal":"lemma SeqMemberAppend_13410(ys: seq, xs: seq)\n ensures x in ys + xs <==> x in ys || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_13411","instance":13411,"id":200082,"goal":"lemma SeqAppendLen_13411(u: seq, s: seq)\n ensures |u + s| == |u| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_13412","instance":13412,"id":200083,"goal":"lemma SeqAppendNil_13412(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_13413","instance":13413,"id":200084,"goal":"lemma SeqNilAppend_13413(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_13414","instance":13414,"id":200085,"goal":"lemma SeqAppendAssoc_13414(ys: seq, t: seq, xs: seq)\n ensures (ys + t) + xs == ys + (t + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_13415","instance":13415,"id":200086,"goal":"lemma SeqTakeDrop_13415(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_13416","instance":13416,"id":200087,"goal":"lemma SeqReverseLen_13416(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_13417","instance":13417,"id":200088,"goal":"lemma SeqReverseIdem_13417(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_13418","instance":13418,"id":200089,"goal":"lemma SeqMapLen_13418(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_13419","instance":13419,"id":200090,"goal":"lemma SeqFilterLe_13419(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_13420","instance":13420,"id":200091,"goal":"lemma SeqMemberAppend_13420(u: seq, ys: seq)\n ensures x in u + ys <==> x in u || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_13421","instance":13421,"id":200092,"goal":"lemma SeqAppendLen_13421(ys: seq, xs: seq)\n ensures |ys + xs| == |ys| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_13422","instance":13422,"id":200093,"goal":"lemma SeqAppendNil_13422(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_13423","instance":13423,"id":200094,"goal":"lemma SeqNilAppend_13423(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_13424","instance":13424,"id":200095,"goal":"lemma SeqAppendAssoc_13424(ys: seq, u: seq, xs: seq)\n ensures (ys + u) + xs == ys + (u + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_13425","instance":13425,"id":200096,"goal":"lemma SeqTakeDrop_13425(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_13426","instance":13426,"id":200097,"goal":"lemma SeqReverseLen_13426(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_13427","instance":13427,"id":200098,"goal":"lemma SeqReverseIdem_13427(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_13428","instance":13428,"id":200099,"goal":"lemma SeqMapLen_13428(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_13429","instance":13429,"id":200100,"goal":"lemma SeqFilterLe_13429(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_13430","instance":13430,"id":200101,"goal":"lemma SeqMemberAppend_13430(zs: seq, t: seq)\n ensures x in zs + t <==> x in zs || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_13431","instance":13431,"id":200102,"goal":"lemma SeqAppendLen_13431(zs: seq, xs: seq)\n ensures |zs + xs| == |zs| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_13432","instance":13432,"id":200103,"goal":"lemma SeqAppendNil_13432(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_13433","instance":13433,"id":200104,"goal":"lemma SeqNilAppend_13433(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_13434","instance":13434,"id":200105,"goal":"lemma SeqAppendAssoc_13434(u: seq, xs: seq, ys: seq)\n ensures (u + xs) + ys == u + (xs + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_13435","instance":13435,"id":200106,"goal":"lemma SeqTakeDrop_13435(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_13436","instance":13436,"id":200107,"goal":"lemma SeqReverseLen_13436(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_13437","instance":13437,"id":200108,"goal":"lemma SeqReverseIdem_13437(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_13438","instance":13438,"id":200109,"goal":"lemma SeqMapLen_13438(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_13439","instance":13439,"id":200110,"goal":"lemma SeqFilterLe_13439(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_13440","instance":13440,"id":200111,"goal":"lemma SeqMemberAppend_13440(s: seq, ys: seq)\n ensures x in s + ys <==> x in s || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_13441","instance":13441,"id":200112,"goal":"lemma SeqAppendLen_13441(s: seq, zs: seq)\n ensures |s + zs| == |s| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_13442","instance":13442,"id":200113,"goal":"lemma SeqAppendNil_13442(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_13443","instance":13443,"id":200114,"goal":"lemma SeqNilAppend_13443(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_13444","instance":13444,"id":200115,"goal":"lemma SeqAppendAssoc_13444(u: seq, t: seq, zs: seq)\n ensures (u + t) + zs == u + (t + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_13445","instance":13445,"id":200116,"goal":"lemma SeqTakeDrop_13445(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_13446","instance":13446,"id":200117,"goal":"lemma SeqReverseLen_13446(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_13447","instance":13447,"id":200118,"goal":"lemma SeqReverseIdem_13447(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_13448","instance":13448,"id":200119,"goal":"lemma SeqMapLen_13448(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_13449","instance":13449,"id":200120,"goal":"lemma SeqFilterLe_13449(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_13450","instance":13450,"id":200121,"goal":"lemma SeqMemberAppend_13450(s: seq, xs: seq)\n ensures x in s + xs <==> x in s || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_13451","instance":13451,"id":200122,"goal":"lemma SeqAppendLen_13451(u: seq, ys: seq)\n ensures |u + ys| == |u| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_13452","instance":13452,"id":200123,"goal":"lemma SeqAppendNil_13452(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_13453","instance":13453,"id":200124,"goal":"lemma SeqNilAppend_13453(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_13454","instance":13454,"id":200125,"goal":"lemma SeqAppendAssoc_13454(xs: seq, u: seq, s: seq)\n ensures (xs + u) + s == xs + (u + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_13455","instance":13455,"id":200126,"goal":"lemma SeqTakeDrop_13455(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_13456","instance":13456,"id":200127,"goal":"lemma SeqReverseLen_13456(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_13457","instance":13457,"id":200128,"goal":"lemma SeqReverseIdem_13457(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_13458","instance":13458,"id":200129,"goal":"lemma SeqMapLen_13458(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_13459","instance":13459,"id":200130,"goal":"lemma SeqFilterLe_13459(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_13460","instance":13460,"id":200131,"goal":"lemma SeqMemberAppend_13460(zs: seq, s: seq)\n ensures x in zs + s <==> x in zs || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_13461","instance":13461,"id":200132,"goal":"lemma SeqAppendLen_13461(ys: seq, zs: seq)\n ensures |ys + zs| == |ys| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_13462","instance":13462,"id":200133,"goal":"lemma SeqAppendNil_13462(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_13463","instance":13463,"id":200134,"goal":"lemma SeqNilAppend_13463(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_13464","instance":13464,"id":200135,"goal":"lemma SeqAppendAssoc_13464(s: seq, u: seq, t: seq)\n ensures (s + u) + t == s + (u + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_13465","instance":13465,"id":200136,"goal":"lemma SeqTakeDrop_13465(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_13466","instance":13466,"id":200137,"goal":"lemma SeqReverseLen_13466(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_13467","instance":13467,"id":200138,"goal":"lemma SeqReverseIdem_13467(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_13468","instance":13468,"id":200139,"goal":"lemma SeqMapLen_13468(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_13469","instance":13469,"id":200140,"goal":"lemma SeqFilterLe_13469(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_13470","instance":13470,"id":200141,"goal":"lemma SeqMemberAppend_13470(s: seq, zs: seq)\n ensures x in s + zs <==> x in s || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_13471","instance":13471,"id":200142,"goal":"lemma SeqAppendLen_13471(xs: seq, ys: seq)\n ensures |xs + ys| == |xs| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_13472","instance":13472,"id":200143,"goal":"lemma SeqAppendNil_13472(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_13473","instance":13473,"id":200144,"goal":"lemma SeqNilAppend_13473(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_13474","instance":13474,"id":200145,"goal":"lemma SeqAppendAssoc_13474(u: seq, ys: seq, s: seq)\n ensures (u + ys) + s == u + (ys + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_13475","instance":13475,"id":200146,"goal":"lemma SeqTakeDrop_13475(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_13476","instance":13476,"id":200147,"goal":"lemma SeqReverseLen_13476(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_13477","instance":13477,"id":200148,"goal":"lemma SeqReverseIdem_13477(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_13478","instance":13478,"id":200149,"goal":"lemma SeqMapLen_13478(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_13479","instance":13479,"id":200150,"goal":"lemma SeqFilterLe_13479(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_13480","instance":13480,"id":200151,"goal":"lemma SeqMemberAppend_13480(xs: seq, t: seq)\n ensures x in xs + t <==> x in xs || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_13481","instance":13481,"id":200152,"goal":"lemma SeqAppendLen_13481(t: seq, xs: seq)\n ensures |t + xs| == |t| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_13482","instance":13482,"id":200153,"goal":"lemma SeqAppendNil_13482(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_13483","instance":13483,"id":200154,"goal":"lemma SeqNilAppend_13483(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_13484","instance":13484,"id":200155,"goal":"lemma SeqAppendAssoc_13484(s: seq, ys: seq, t: seq)\n ensures (s + ys) + t == s + (ys + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_13485","instance":13485,"id":200156,"goal":"lemma SeqTakeDrop_13485(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_13486","instance":13486,"id":200157,"goal":"lemma SeqReverseLen_13486(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_13487","instance":13487,"id":200158,"goal":"lemma SeqReverseIdem_13487(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_13488","instance":13488,"id":200159,"goal":"lemma SeqMapLen_13488(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_13489","instance":13489,"id":200160,"goal":"lemma SeqFilterLe_13489(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_13490","instance":13490,"id":200161,"goal":"lemma SeqMemberAppend_13490(ys: seq, u: seq)\n ensures x in ys + u <==> x in ys || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_13491","instance":13491,"id":200162,"goal":"lemma SeqAppendLen_13491(u: seq, ys: seq)\n ensures |u + ys| == |u| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_13492","instance":13492,"id":200163,"goal":"lemma SeqAppendNil_13492(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_13493","instance":13493,"id":200164,"goal":"lemma SeqNilAppend_13493(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_13494","instance":13494,"id":200165,"goal":"lemma SeqAppendAssoc_13494(xs: seq, u: seq, s: seq)\n ensures (xs + u) + s == xs + (u + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_13495","instance":13495,"id":200166,"goal":"lemma SeqTakeDrop_13495(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_13496","instance":13496,"id":200167,"goal":"lemma SeqReverseLen_13496(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_13497","instance":13497,"id":200168,"goal":"lemma SeqReverseIdem_13497(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_13498","instance":13498,"id":200169,"goal":"lemma SeqMapLen_13498(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_13499","instance":13499,"id":200170,"goal":"lemma SeqFilterLe_13499(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_13500","instance":13500,"id":200171,"goal":"lemma SeqMemberAppend_13500(u: seq, zs: seq)\n ensures x in u + zs <==> x in u || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_13501","instance":13501,"id":200172,"goal":"lemma SeqAppendLen_13501(ys: seq, t: seq)\n ensures |ys + t| == |ys| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_13502","instance":13502,"id":200173,"goal":"lemma SeqAppendNil_13502(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_13503","instance":13503,"id":200174,"goal":"lemma SeqNilAppend_13503(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_13504","instance":13504,"id":200175,"goal":"lemma SeqAppendAssoc_13504(t: seq, u: seq, zs: seq)\n ensures (t + u) + zs == t + (u + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_13505","instance":13505,"id":200176,"goal":"lemma SeqTakeDrop_13505(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_13506","instance":13506,"id":200177,"goal":"lemma SeqReverseLen_13506(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_13507","instance":13507,"id":200178,"goal":"lemma SeqReverseIdem_13507(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_13508","instance":13508,"id":200179,"goal":"lemma SeqMapLen_13508(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_13509","instance":13509,"id":200180,"goal":"lemma SeqFilterLe_13509(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_13510","instance":13510,"id":200181,"goal":"lemma SeqMemberAppend_13510(s: seq, t: seq)\n ensures x in s + t <==> x in s || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_13511","instance":13511,"id":200182,"goal":"lemma SeqAppendLen_13511(s: seq, xs: seq)\n ensures |s + xs| == |s| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_13512","instance":13512,"id":200183,"goal":"lemma SeqAppendNil_13512(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_13513","instance":13513,"id":200184,"goal":"lemma SeqNilAppend_13513(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_13514","instance":13514,"id":200185,"goal":"lemma SeqAppendAssoc_13514(t: seq, zs: seq, xs: seq)\n ensures (t + zs) + xs == t + (zs + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_13515","instance":13515,"id":200186,"goal":"lemma SeqTakeDrop_13515(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_13516","instance":13516,"id":200187,"goal":"lemma SeqReverseLen_13516(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_13517","instance":13517,"id":200188,"goal":"lemma SeqReverseIdem_13517(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_13518","instance":13518,"id":200189,"goal":"lemma SeqMapLen_13518(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_13519","instance":13519,"id":200190,"goal":"lemma SeqFilterLe_13519(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_13520","instance":13520,"id":200191,"goal":"lemma SeqMemberAppend_13520(u: seq, t: seq)\n ensures x in u + t <==> x in u || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_13521","instance":13521,"id":200192,"goal":"lemma SeqAppendLen_13521(ys: seq, s: seq)\n ensures |ys + s| == |ys| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_13522","instance":13522,"id":200193,"goal":"lemma SeqAppendNil_13522(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_13523","instance":13523,"id":200194,"goal":"lemma SeqNilAppend_13523(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_13524","instance":13524,"id":200195,"goal":"lemma SeqAppendAssoc_13524(xs: seq, t: seq, u: seq)\n ensures (xs + t) + u == xs + (t + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_13525","instance":13525,"id":200196,"goal":"lemma SeqTakeDrop_13525(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_13526","instance":13526,"id":200197,"goal":"lemma SeqReverseLen_13526(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_13527","instance":13527,"id":200198,"goal":"lemma SeqReverseIdem_13527(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_13528","instance":13528,"id":200199,"goal":"lemma SeqMapLen_13528(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_13529","instance":13529,"id":200200,"goal":"lemma SeqFilterLe_13529(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_13530","instance":13530,"id":200201,"goal":"lemma SeqMemberAppend_13530(xs: seq, s: seq)\n ensures x in xs + s <==> x in xs || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_13531","instance":13531,"id":200202,"goal":"lemma SeqAppendLen_13531(t: seq, s: seq)\n ensures |t + s| == |t| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_13532","instance":13532,"id":200203,"goal":"lemma SeqAppendNil_13532(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_13533","instance":13533,"id":200204,"goal":"lemma SeqNilAppend_13533(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_13534","instance":13534,"id":200205,"goal":"lemma SeqAppendAssoc_13534(zs: seq, ys: seq, u: seq)\n ensures (zs + ys) + u == zs + (ys + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_13535","instance":13535,"id":200206,"goal":"lemma SeqTakeDrop_13535(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_13536","instance":13536,"id":200207,"goal":"lemma SeqReverseLen_13536(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_13537","instance":13537,"id":200208,"goal":"lemma SeqReverseIdem_13537(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_13538","instance":13538,"id":200209,"goal":"lemma SeqMapLen_13538(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_13539","instance":13539,"id":200210,"goal":"lemma SeqFilterLe_13539(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_13540","instance":13540,"id":200211,"goal":"lemma SeqMemberAppend_13540(u: seq, ys: seq)\n ensures x in u + ys <==> x in u || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_13541","instance":13541,"id":200212,"goal":"lemma SeqAppendLen_13541(xs: seq, u: seq)\n ensures |xs + u| == |xs| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_13542","instance":13542,"id":200213,"goal":"lemma SeqAppendNil_13542(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_13543","instance":13543,"id":200214,"goal":"lemma SeqNilAppend_13543(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_13544","instance":13544,"id":200215,"goal":"lemma SeqAppendAssoc_13544(s: seq, zs: seq, xs: seq)\n ensures (s + zs) + xs == s + (zs + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_13545","instance":13545,"id":200216,"goal":"lemma SeqTakeDrop_13545(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_13546","instance":13546,"id":200217,"goal":"lemma SeqReverseLen_13546(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_13547","instance":13547,"id":200218,"goal":"lemma SeqReverseIdem_13547(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_13548","instance":13548,"id":200219,"goal":"lemma SeqMapLen_13548(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_13549","instance":13549,"id":200220,"goal":"lemma SeqFilterLe_13549(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_13550","instance":13550,"id":200221,"goal":"lemma SeqMemberAppend_13550(u: seq, xs: seq)\n ensures x in u + xs <==> x in u || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_13551","instance":13551,"id":200222,"goal":"lemma SeqAppendLen_13551(xs: seq, zs: seq)\n ensures |xs + zs| == |xs| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_13552","instance":13552,"id":200223,"goal":"lemma SeqAppendNil_13552(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_13553","instance":13553,"id":200224,"goal":"lemma SeqNilAppend_13553(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_13554","instance":13554,"id":200225,"goal":"lemma SeqAppendAssoc_13554(u: seq, ys: seq, xs: seq)\n ensures (u + ys) + xs == u + (ys + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_13555","instance":13555,"id":200226,"goal":"lemma SeqTakeDrop_13555(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_13556","instance":13556,"id":200227,"goal":"lemma SeqReverseLen_13556(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_13557","instance":13557,"id":200228,"goal":"lemma SeqReverseIdem_13557(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_13558","instance":13558,"id":200229,"goal":"lemma SeqMapLen_13558(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_13559","instance":13559,"id":200230,"goal":"lemma SeqFilterLe_13559(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_13560","instance":13560,"id":200231,"goal":"lemma SeqMemberAppend_13560(zs: seq, ys: seq)\n ensures x in zs + ys <==> x in zs || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_13561","instance":13561,"id":200232,"goal":"lemma SeqAppendLen_13561(s: seq, u: seq)\n ensures |s + u| == |s| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_13562","instance":13562,"id":200233,"goal":"lemma SeqAppendNil_13562(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_13563","instance":13563,"id":200234,"goal":"lemma SeqNilAppend_13563(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_13564","instance":13564,"id":200235,"goal":"lemma SeqAppendAssoc_13564(xs: seq, ys: seq, t: seq)\n ensures (xs + ys) + t == xs + (ys + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_13565","instance":13565,"id":200236,"goal":"lemma SeqTakeDrop_13565(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_13566","instance":13566,"id":200237,"goal":"lemma SeqReverseLen_13566(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_13567","instance":13567,"id":200238,"goal":"lemma SeqReverseIdem_13567(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_13568","instance":13568,"id":200239,"goal":"lemma SeqMapLen_13568(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_13569","instance":13569,"id":200240,"goal":"lemma SeqFilterLe_13569(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_13570","instance":13570,"id":200241,"goal":"lemma SeqMemberAppend_13570(u: seq, zs: seq)\n ensures x in u + zs <==> x in u || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_13571","instance":13571,"id":200242,"goal":"lemma SeqAppendLen_13571(t: seq, s: seq)\n ensures |t + s| == |t| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_13572","instance":13572,"id":200243,"goal":"lemma SeqAppendNil_13572(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_13573","instance":13573,"id":200244,"goal":"lemma SeqNilAppend_13573(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_13574","instance":13574,"id":200245,"goal":"lemma SeqAppendAssoc_13574(ys: seq, t: seq, s: seq)\n ensures (ys + t) + s == ys + (t + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_13575","instance":13575,"id":200246,"goal":"lemma SeqTakeDrop_13575(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_13576","instance":13576,"id":200247,"goal":"lemma SeqReverseLen_13576(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_13577","instance":13577,"id":200248,"goal":"lemma SeqReverseIdem_13577(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_13578","instance":13578,"id":200249,"goal":"lemma SeqMapLen_13578(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_13579","instance":13579,"id":200250,"goal":"lemma SeqFilterLe_13579(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_13580","instance":13580,"id":200251,"goal":"lemma SeqMemberAppend_13580(zs: seq, xs: seq)\n ensures x in zs + xs <==> x in zs || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_13581","instance":13581,"id":200252,"goal":"lemma SeqAppendLen_13581(ys: seq, t: seq)\n ensures |ys + t| == |ys| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_13582","instance":13582,"id":200253,"goal":"lemma SeqAppendNil_13582(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_13583","instance":13583,"id":200254,"goal":"lemma SeqNilAppend_13583(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_13584","instance":13584,"id":200255,"goal":"lemma SeqAppendAssoc_13584(zs: seq, s: seq, ys: seq)\n ensures (zs + s) + ys == zs + (s + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_13585","instance":13585,"id":200256,"goal":"lemma SeqTakeDrop_13585(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_13586","instance":13586,"id":200257,"goal":"lemma SeqReverseLen_13586(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_13587","instance":13587,"id":200258,"goal":"lemma SeqReverseIdem_13587(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_13588","instance":13588,"id":200259,"goal":"lemma SeqMapLen_13588(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_13589","instance":13589,"id":200260,"goal":"lemma SeqFilterLe_13589(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_13590","instance":13590,"id":200261,"goal":"lemma SeqMemberAppend_13590(s: seq, zs: seq)\n ensures x in s + zs <==> x in s || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_13591","instance":13591,"id":200262,"goal":"lemma SeqAppendLen_13591(s: seq, u: seq)\n ensures |s + u| == |s| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_13592","instance":13592,"id":200263,"goal":"lemma SeqAppendNil_13592(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_13593","instance":13593,"id":200264,"goal":"lemma SeqNilAppend_13593(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_13594","instance":13594,"id":200265,"goal":"lemma SeqAppendAssoc_13594(zs: seq, xs: seq, t: seq)\n ensures (zs + xs) + t == zs + (xs + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_13595","instance":13595,"id":200266,"goal":"lemma SeqTakeDrop_13595(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_13596","instance":13596,"id":200267,"goal":"lemma SeqReverseLen_13596(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_13597","instance":13597,"id":200268,"goal":"lemma SeqReverseIdem_13597(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_13598","instance":13598,"id":200269,"goal":"lemma SeqMapLen_13598(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_13599","instance":13599,"id":200270,"goal":"lemma SeqFilterLe_13599(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_13600","instance":13600,"id":200271,"goal":"lemma SeqMemberAppend_13600(s: seq, ys: seq)\n ensures x in s + ys <==> x in s || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_13601","instance":13601,"id":200272,"goal":"lemma SeqAppendLen_13601(s: seq, t: seq)\n ensures |s + t| == |s| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_13602","instance":13602,"id":200273,"goal":"lemma SeqAppendNil_13602(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_13603","instance":13603,"id":200274,"goal":"lemma SeqNilAppend_13603(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_13604","instance":13604,"id":200275,"goal":"lemma SeqAppendAssoc_13604(ys: seq, u: seq, t: seq)\n ensures (ys + u) + t == ys + (u + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_13605","instance":13605,"id":200276,"goal":"lemma SeqTakeDrop_13605(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_13606","instance":13606,"id":200277,"goal":"lemma SeqReverseLen_13606(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_13607","instance":13607,"id":200278,"goal":"lemma SeqReverseIdem_13607(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_13608","instance":13608,"id":200279,"goal":"lemma SeqMapLen_13608(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_13609","instance":13609,"id":200280,"goal":"lemma SeqFilterLe_13609(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_13610","instance":13610,"id":200281,"goal":"lemma SeqMemberAppend_13610(xs: seq, zs: seq)\n ensures x in xs + zs <==> x in xs || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_13611","instance":13611,"id":200282,"goal":"lemma SeqAppendLen_13611(xs: seq, ys: seq)\n ensures |xs + ys| == |xs| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_13612","instance":13612,"id":200283,"goal":"lemma SeqAppendNil_13612(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_13613","instance":13613,"id":200284,"goal":"lemma SeqNilAppend_13613(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_13614","instance":13614,"id":200285,"goal":"lemma SeqAppendAssoc_13614(u: seq, zs: seq, t: seq)\n ensures (u + zs) + t == u + (zs + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_13615","instance":13615,"id":200286,"goal":"lemma SeqTakeDrop_13615(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_13616","instance":13616,"id":200287,"goal":"lemma SeqReverseLen_13616(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_13617","instance":13617,"id":200288,"goal":"lemma SeqReverseIdem_13617(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_13618","instance":13618,"id":200289,"goal":"lemma SeqMapLen_13618(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_13619","instance":13619,"id":200290,"goal":"lemma SeqFilterLe_13619(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_13620","instance":13620,"id":200291,"goal":"lemma SeqMemberAppend_13620(u: seq, s: seq)\n ensures x in u + s <==> x in u || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_13621","instance":13621,"id":200292,"goal":"lemma SeqAppendLen_13621(xs: seq, s: seq)\n ensures |xs + s| == |xs| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_13622","instance":13622,"id":200293,"goal":"lemma SeqAppendNil_13622(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_13623","instance":13623,"id":200294,"goal":"lemma SeqNilAppend_13623(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_13624","instance":13624,"id":200295,"goal":"lemma SeqAppendAssoc_13624(t: seq, s: seq, zs: seq)\n ensures (t + s) + zs == t + (s + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_13625","instance":13625,"id":200296,"goal":"lemma SeqTakeDrop_13625(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_13626","instance":13626,"id":200297,"goal":"lemma SeqReverseLen_13626(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_13627","instance":13627,"id":200298,"goal":"lemma SeqReverseIdem_13627(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_13628","instance":13628,"id":200299,"goal":"lemma SeqMapLen_13628(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_13629","instance":13629,"id":200300,"goal":"lemma SeqFilterLe_13629(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_13630","instance":13630,"id":200301,"goal":"lemma SeqMemberAppend_13630(s: seq, ys: seq)\n ensures x in s + ys <==> x in s || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_13631","instance":13631,"id":200302,"goal":"lemma SeqAppendLen_13631(xs: seq, t: seq)\n ensures |xs + t| == |xs| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_13632","instance":13632,"id":200303,"goal":"lemma SeqAppendNil_13632(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_13633","instance":13633,"id":200304,"goal":"lemma SeqNilAppend_13633(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_13634","instance":13634,"id":200305,"goal":"lemma SeqAppendAssoc_13634(s: seq, zs: seq, ys: seq)\n ensures (s + zs) + ys == s + (zs + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_13635","instance":13635,"id":200306,"goal":"lemma SeqTakeDrop_13635(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_13636","instance":13636,"id":200307,"goal":"lemma SeqReverseLen_13636(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_13637","instance":13637,"id":200308,"goal":"lemma SeqReverseIdem_13637(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_13638","instance":13638,"id":200309,"goal":"lemma SeqMapLen_13638(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_13639","instance":13639,"id":200310,"goal":"lemma SeqFilterLe_13639(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_13640","instance":13640,"id":200311,"goal":"lemma SeqMemberAppend_13640(ys: seq, t: seq)\n ensures x in ys + t <==> x in ys || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_13641","instance":13641,"id":200312,"goal":"lemma SeqAppendLen_13641(u: seq, ys: seq)\n ensures |u + ys| == |u| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_13642","instance":13642,"id":200313,"goal":"lemma SeqAppendNil_13642(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_13643","instance":13643,"id":200314,"goal":"lemma SeqNilAppend_13643(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_13644","instance":13644,"id":200315,"goal":"lemma SeqAppendAssoc_13644(ys: seq, zs: seq, t: seq)\n ensures (ys + zs) + t == ys + (zs + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_13645","instance":13645,"id":200316,"goal":"lemma SeqTakeDrop_13645(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_13646","instance":13646,"id":200317,"goal":"lemma SeqReverseLen_13646(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_13647","instance":13647,"id":200318,"goal":"lemma SeqReverseIdem_13647(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_13648","instance":13648,"id":200319,"goal":"lemma SeqMapLen_13648(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_13649","instance":13649,"id":200320,"goal":"lemma SeqFilterLe_13649(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_13650","instance":13650,"id":200321,"goal":"lemma SeqMemberAppend_13650(t: seq, s: seq)\n ensures x in t + s <==> x in t || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_13651","instance":13651,"id":200322,"goal":"lemma SeqAppendLen_13651(u: seq, t: seq)\n ensures |u + t| == |u| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_13652","instance":13652,"id":200323,"goal":"lemma SeqAppendNil_13652(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_13653","instance":13653,"id":200324,"goal":"lemma SeqNilAppend_13653(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_13654","instance":13654,"id":200325,"goal":"lemma SeqAppendAssoc_13654(s: seq, ys: seq, xs: seq)\n ensures (s + ys) + xs == s + (ys + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_13655","instance":13655,"id":200326,"goal":"lemma SeqTakeDrop_13655(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_13656","instance":13656,"id":200327,"goal":"lemma SeqReverseLen_13656(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_13657","instance":13657,"id":200328,"goal":"lemma SeqReverseIdem_13657(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_13658","instance":13658,"id":200329,"goal":"lemma SeqMapLen_13658(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_13659","instance":13659,"id":200330,"goal":"lemma SeqFilterLe_13659(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_13660","instance":13660,"id":200331,"goal":"lemma SeqMemberAppend_13660(xs: seq, zs: seq)\n ensures x in xs + zs <==> x in xs || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_13661","instance":13661,"id":200332,"goal":"lemma SeqAppendLen_13661(zs: seq, s: seq)\n ensures |zs + s| == |zs| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_13662","instance":13662,"id":200333,"goal":"lemma SeqAppendNil_13662(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_13663","instance":13663,"id":200334,"goal":"lemma SeqNilAppend_13663(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_13664","instance":13664,"id":200335,"goal":"lemma SeqAppendAssoc_13664(u: seq, xs: seq, t: seq)\n ensures (u + xs) + t == u + (xs + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_13665","instance":13665,"id":200336,"goal":"lemma SeqTakeDrop_13665(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_13666","instance":13666,"id":200337,"goal":"lemma SeqReverseLen_13666(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_13667","instance":13667,"id":200338,"goal":"lemma SeqReverseIdem_13667(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_13668","instance":13668,"id":200339,"goal":"lemma SeqMapLen_13668(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_13669","instance":13669,"id":200340,"goal":"lemma SeqFilterLe_13669(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_13670","instance":13670,"id":200341,"goal":"lemma SeqMemberAppend_13670(zs: seq, ys: seq)\n ensures x in zs + ys <==> x in zs || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_13671","instance":13671,"id":200342,"goal":"lemma SeqAppendLen_13671(s: seq, ys: seq)\n ensures |s + ys| == |s| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_13672","instance":13672,"id":200343,"goal":"lemma SeqAppendNil_13672(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_13673","instance":13673,"id":200344,"goal":"lemma SeqNilAppend_13673(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_13674","instance":13674,"id":200345,"goal":"lemma SeqAppendAssoc_13674(s: seq, t: seq, xs: seq)\n ensures (s + t) + xs == s + (t + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_13675","instance":13675,"id":200346,"goal":"lemma SeqTakeDrop_13675(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_13676","instance":13676,"id":200347,"goal":"lemma SeqReverseLen_13676(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_13677","instance":13677,"id":200348,"goal":"lemma SeqReverseIdem_13677(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_13678","instance":13678,"id":200349,"goal":"lemma SeqMapLen_13678(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_13679","instance":13679,"id":200350,"goal":"lemma SeqFilterLe_13679(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_13680","instance":13680,"id":200351,"goal":"lemma SeqMemberAppend_13680(zs: seq, ys: seq)\n ensures x in zs + ys <==> x in zs || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_13681","instance":13681,"id":200352,"goal":"lemma SeqAppendLen_13681(xs: seq, zs: seq)\n ensures |xs + zs| == |xs| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_13682","instance":13682,"id":200353,"goal":"lemma SeqAppendNil_13682(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_13683","instance":13683,"id":200354,"goal":"lemma SeqNilAppend_13683(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_13684","instance":13684,"id":200355,"goal":"lemma SeqAppendAssoc_13684(u: seq, t: seq, s: seq)\n ensures (u + t) + s == u + (t + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_13685","instance":13685,"id":200356,"goal":"lemma SeqTakeDrop_13685(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_13686","instance":13686,"id":200357,"goal":"lemma SeqReverseLen_13686(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_13687","instance":13687,"id":200358,"goal":"lemma SeqReverseIdem_13687(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_13688","instance":13688,"id":200359,"goal":"lemma SeqMapLen_13688(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_13689","instance":13689,"id":200360,"goal":"lemma SeqFilterLe_13689(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_13690","instance":13690,"id":200361,"goal":"lemma SeqMemberAppend_13690(t: seq, xs: seq)\n ensures x in t + xs <==> x in t || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_13691","instance":13691,"id":200362,"goal":"lemma SeqAppendLen_13691(zs: seq, t: seq)\n ensures |zs + t| == |zs| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_13692","instance":13692,"id":200363,"goal":"lemma SeqAppendNil_13692(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_13693","instance":13693,"id":200364,"goal":"lemma SeqNilAppend_13693(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_13694","instance":13694,"id":200365,"goal":"lemma SeqAppendAssoc_13694(s: seq, u: seq, zs: seq)\n ensures (s + u) + zs == s + (u + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_13695","instance":13695,"id":200366,"goal":"lemma SeqTakeDrop_13695(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_13696","instance":13696,"id":200367,"goal":"lemma SeqReverseLen_13696(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_13697","instance":13697,"id":200368,"goal":"lemma SeqReverseIdem_13697(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_13698","instance":13698,"id":200369,"goal":"lemma SeqMapLen_13698(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_13699","instance":13699,"id":200370,"goal":"lemma SeqFilterLe_13699(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_13700","instance":13700,"id":200371,"goal":"lemma SeqMemberAppend_13700(ys: seq, s: seq)\n ensures x in ys + s <==> x in ys || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_13701","instance":13701,"id":200372,"goal":"lemma SeqAppendLen_13701(zs: seq, u: seq)\n ensures |zs + u| == |zs| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_13702","instance":13702,"id":200373,"goal":"lemma SeqAppendNil_13702(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_13703","instance":13703,"id":200374,"goal":"lemma SeqNilAppend_13703(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_13704","instance":13704,"id":200375,"goal":"lemma SeqAppendAssoc_13704(u: seq, xs: seq, ys: seq)\n ensures (u + xs) + ys == u + (xs + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_13705","instance":13705,"id":200376,"goal":"lemma SeqTakeDrop_13705(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_13706","instance":13706,"id":200377,"goal":"lemma SeqReverseLen_13706(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_13707","instance":13707,"id":200378,"goal":"lemma SeqReverseIdem_13707(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_13708","instance":13708,"id":200379,"goal":"lemma SeqMapLen_13708(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_13709","instance":13709,"id":200380,"goal":"lemma SeqFilterLe_13709(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_13710","instance":13710,"id":200381,"goal":"lemma SeqMemberAppend_13710(s: seq, t: seq)\n ensures x in s + t <==> x in s || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_13711","instance":13711,"id":200382,"goal":"lemma SeqAppendLen_13711(ys: seq, zs: seq)\n ensures |ys + zs| == |ys| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_13712","instance":13712,"id":200383,"goal":"lemma SeqAppendNil_13712(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_13713","instance":13713,"id":200384,"goal":"lemma SeqNilAppend_13713(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_13714","instance":13714,"id":200385,"goal":"lemma SeqAppendAssoc_13714(u: seq, ys: seq, xs: seq)\n ensures (u + ys) + xs == u + (ys + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_13715","instance":13715,"id":200386,"goal":"lemma SeqTakeDrop_13715(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_13716","instance":13716,"id":200387,"goal":"lemma SeqReverseLen_13716(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_13717","instance":13717,"id":200388,"goal":"lemma SeqReverseIdem_13717(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_13718","instance":13718,"id":200389,"goal":"lemma SeqMapLen_13718(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_13719","instance":13719,"id":200390,"goal":"lemma SeqFilterLe_13719(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_13720","instance":13720,"id":200391,"goal":"lemma SeqMemberAppend_13720(xs: seq, u: seq)\n ensures x in xs + u <==> x in xs || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_13721","instance":13721,"id":200392,"goal":"lemma SeqAppendLen_13721(zs: seq, xs: seq)\n ensures |zs + xs| == |zs| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_13722","instance":13722,"id":200393,"goal":"lemma SeqAppendNil_13722(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_13723","instance":13723,"id":200394,"goal":"lemma SeqNilAppend_13723(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_13724","instance":13724,"id":200395,"goal":"lemma SeqAppendAssoc_13724(s: seq, xs: seq, ys: seq)\n ensures (s + xs) + ys == s + (xs + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_13725","instance":13725,"id":200396,"goal":"lemma SeqTakeDrop_13725(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_13726","instance":13726,"id":200397,"goal":"lemma SeqReverseLen_13726(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_13727","instance":13727,"id":200398,"goal":"lemma SeqReverseIdem_13727(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_13728","instance":13728,"id":200399,"goal":"lemma SeqMapLen_13728(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_13729","instance":13729,"id":200400,"goal":"lemma SeqFilterLe_13729(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_13730","instance":13730,"id":200401,"goal":"lemma SeqMemberAppend_13730(u: seq, t: seq)\n ensures x in u + t <==> x in u || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_13731","instance":13731,"id":200402,"goal":"lemma SeqAppendLen_13731(u: seq, ys: seq)\n ensures |u + ys| == |u| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_13732","instance":13732,"id":200403,"goal":"lemma SeqAppendNil_13732(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_13733","instance":13733,"id":200404,"goal":"lemma SeqNilAppend_13733(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_13734","instance":13734,"id":200405,"goal":"lemma SeqAppendAssoc_13734(t: seq, s: seq, zs: seq)\n ensures (t + s) + zs == t + (s + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_13735","instance":13735,"id":200406,"goal":"lemma SeqTakeDrop_13735(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_13736","instance":13736,"id":200407,"goal":"lemma SeqReverseLen_13736(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_13737","instance":13737,"id":200408,"goal":"lemma SeqReverseIdem_13737(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_13738","instance":13738,"id":200409,"goal":"lemma SeqMapLen_13738(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_13739","instance":13739,"id":200410,"goal":"lemma SeqFilterLe_13739(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_13740","instance":13740,"id":200411,"goal":"lemma SeqMemberAppend_13740(ys: seq, t: seq)\n ensures x in ys + t <==> x in ys || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_13741","instance":13741,"id":200412,"goal":"lemma SeqAppendLen_13741(xs: seq, zs: seq)\n ensures |xs + zs| == |xs| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_13742","instance":13742,"id":200413,"goal":"lemma SeqAppendNil_13742(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_13743","instance":13743,"id":200414,"goal":"lemma SeqNilAppend_13743(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_13744","instance":13744,"id":200415,"goal":"lemma SeqAppendAssoc_13744(u: seq, ys: seq, t: seq)\n ensures (u + ys) + t == u + (ys + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_13745","instance":13745,"id":200416,"goal":"lemma SeqTakeDrop_13745(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_13746","instance":13746,"id":200417,"goal":"lemma SeqReverseLen_13746(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_13747","instance":13747,"id":200418,"goal":"lemma SeqReverseIdem_13747(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_13748","instance":13748,"id":200419,"goal":"lemma SeqMapLen_13748(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_13749","instance":13749,"id":200420,"goal":"lemma SeqFilterLe_13749(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_13750","instance":13750,"id":200421,"goal":"lemma SeqMemberAppend_13750(xs: seq, u: seq)\n ensures x in xs + u <==> x in xs || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_13751","instance":13751,"id":200422,"goal":"lemma SeqAppendLen_13751(zs: seq, s: seq)\n ensures |zs + s| == |zs| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_13752","instance":13752,"id":200423,"goal":"lemma SeqAppendNil_13752(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_13753","instance":13753,"id":200424,"goal":"lemma SeqNilAppend_13753(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_13754","instance":13754,"id":200425,"goal":"lemma SeqAppendAssoc_13754(xs: seq, zs: seq, s: seq)\n ensures (xs + zs) + s == xs + (zs + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_13755","instance":13755,"id":200426,"goal":"lemma SeqTakeDrop_13755(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_13756","instance":13756,"id":200427,"goal":"lemma SeqReverseLen_13756(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_13757","instance":13757,"id":200428,"goal":"lemma SeqReverseIdem_13757(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_13758","instance":13758,"id":200429,"goal":"lemma SeqMapLen_13758(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_13759","instance":13759,"id":200430,"goal":"lemma SeqFilterLe_13759(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_13760","instance":13760,"id":200431,"goal":"lemma SeqMemberAppend_13760(zs: seq, u: seq)\n ensures x in zs + u <==> x in zs || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_13761","instance":13761,"id":200432,"goal":"lemma SeqAppendLen_13761(u: seq, xs: seq)\n ensures |u + xs| == |u| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_13762","instance":13762,"id":200433,"goal":"lemma SeqAppendNil_13762(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_13763","instance":13763,"id":200434,"goal":"lemma SeqNilAppend_13763(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_13764","instance":13764,"id":200435,"goal":"lemma SeqAppendAssoc_13764(u: seq, xs: seq, ys: seq)\n ensures (u + xs) + ys == u + (xs + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_13765","instance":13765,"id":200436,"goal":"lemma SeqTakeDrop_13765(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_13766","instance":13766,"id":200437,"goal":"lemma SeqReverseLen_13766(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_13767","instance":13767,"id":200438,"goal":"lemma SeqReverseIdem_13767(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_13768","instance":13768,"id":200439,"goal":"lemma SeqMapLen_13768(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_13769","instance":13769,"id":200440,"goal":"lemma SeqFilterLe_13769(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_13770","instance":13770,"id":200441,"goal":"lemma SeqMemberAppend_13770(xs: seq, zs: seq)\n ensures x in xs + zs <==> x in xs || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_13771","instance":13771,"id":200442,"goal":"lemma SeqAppendLen_13771(zs: seq, xs: seq)\n ensures |zs + xs| == |zs| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_13772","instance":13772,"id":200443,"goal":"lemma SeqAppendNil_13772(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_13773","instance":13773,"id":200444,"goal":"lemma SeqNilAppend_13773(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_13774","instance":13774,"id":200445,"goal":"lemma SeqAppendAssoc_13774(u: seq, xs: seq, zs: seq)\n ensures (u + xs) + zs == u + (xs + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_13775","instance":13775,"id":200446,"goal":"lemma SeqTakeDrop_13775(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_13776","instance":13776,"id":200447,"goal":"lemma SeqReverseLen_13776(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_13777","instance":13777,"id":200448,"goal":"lemma SeqReverseIdem_13777(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_13778","instance":13778,"id":200449,"goal":"lemma SeqMapLen_13778(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_13779","instance":13779,"id":200450,"goal":"lemma SeqFilterLe_13779(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_13780","instance":13780,"id":200451,"goal":"lemma SeqMemberAppend_13780(xs: seq, ys: seq)\n ensures x in xs + ys <==> x in xs || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_13781","instance":13781,"id":200452,"goal":"lemma SeqAppendLen_13781(u: seq, xs: seq)\n ensures |u + xs| == |u| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_13782","instance":13782,"id":200453,"goal":"lemma SeqAppendNil_13782(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_13783","instance":13783,"id":200454,"goal":"lemma SeqNilAppend_13783(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_13784","instance":13784,"id":200455,"goal":"lemma SeqAppendAssoc_13784(ys: seq, u: seq, s: seq)\n ensures (ys + u) + s == ys + (u + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_13785","instance":13785,"id":200456,"goal":"lemma SeqTakeDrop_13785(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_13786","instance":13786,"id":200457,"goal":"lemma SeqReverseLen_13786(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_13787","instance":13787,"id":200458,"goal":"lemma SeqReverseIdem_13787(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_13788","instance":13788,"id":200459,"goal":"lemma SeqMapLen_13788(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_13789","instance":13789,"id":200460,"goal":"lemma SeqFilterLe_13789(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_13790","instance":13790,"id":200461,"goal":"lemma SeqMemberAppend_13790(ys: seq, xs: seq)\n ensures x in ys + xs <==> x in ys || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_13791","instance":13791,"id":200462,"goal":"lemma SeqAppendLen_13791(s: seq, xs: seq)\n ensures |s + xs| == |s| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_13792","instance":13792,"id":200463,"goal":"lemma SeqAppendNil_13792(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_13793","instance":13793,"id":200464,"goal":"lemma SeqNilAppend_13793(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_13794","instance":13794,"id":200465,"goal":"lemma SeqAppendAssoc_13794(u: seq, xs: seq, ys: seq)\n ensures (u + xs) + ys == u + (xs + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_13795","instance":13795,"id":200466,"goal":"lemma SeqTakeDrop_13795(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_13796","instance":13796,"id":200467,"goal":"lemma SeqReverseLen_13796(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_13797","instance":13797,"id":200468,"goal":"lemma SeqReverseIdem_13797(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_13798","instance":13798,"id":200469,"goal":"lemma SeqMapLen_13798(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_13799","instance":13799,"id":200470,"goal":"lemma SeqFilterLe_13799(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_13800","instance":13800,"id":200471,"goal":"lemma SeqMemberAppend_13800(t: seq, ys: seq)\n ensures x in t + ys <==> x in t || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_13801","instance":13801,"id":200472,"goal":"lemma SeqAppendLen_13801(xs: seq, s: seq)\n ensures |xs + s| == |xs| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_13802","instance":13802,"id":200473,"goal":"lemma SeqAppendNil_13802(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_13803","instance":13803,"id":200474,"goal":"lemma SeqNilAppend_13803(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_13804","instance":13804,"id":200475,"goal":"lemma SeqAppendAssoc_13804(zs: seq, u: seq, xs: seq)\n ensures (zs + u) + xs == zs + (u + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_13805","instance":13805,"id":200476,"goal":"lemma SeqTakeDrop_13805(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_13806","instance":13806,"id":200477,"goal":"lemma SeqReverseLen_13806(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_13807","instance":13807,"id":200478,"goal":"lemma SeqReverseIdem_13807(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_13808","instance":13808,"id":200479,"goal":"lemma SeqMapLen_13808(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_13809","instance":13809,"id":200480,"goal":"lemma SeqFilterLe_13809(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_13810","instance":13810,"id":200481,"goal":"lemma SeqMemberAppend_13810(xs: seq, t: seq)\n ensures x in xs + t <==> x in xs || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_13811","instance":13811,"id":200482,"goal":"lemma SeqAppendLen_13811(zs: seq, t: seq)\n ensures |zs + t| == |zs| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_13812","instance":13812,"id":200483,"goal":"lemma SeqAppendNil_13812(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_13813","instance":13813,"id":200484,"goal":"lemma SeqNilAppend_13813(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_13814","instance":13814,"id":200485,"goal":"lemma SeqAppendAssoc_13814(t: seq, s: seq, u: seq)\n ensures (t + s) + u == t + (s + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_13815","instance":13815,"id":200486,"goal":"lemma SeqTakeDrop_13815(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_13816","instance":13816,"id":200487,"goal":"lemma SeqReverseLen_13816(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_13817","instance":13817,"id":200488,"goal":"lemma SeqReverseIdem_13817(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_13818","instance":13818,"id":200489,"goal":"lemma SeqMapLen_13818(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_13819","instance":13819,"id":200490,"goal":"lemma SeqFilterLe_13819(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_13820","instance":13820,"id":200491,"goal":"lemma SeqMemberAppend_13820(u: seq, ys: seq)\n ensures x in u + ys <==> x in u || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_13821","instance":13821,"id":200492,"goal":"lemma SeqAppendLen_13821(t: seq, u: seq)\n ensures |t + u| == |t| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_13822","instance":13822,"id":200493,"goal":"lemma SeqAppendNil_13822(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_13823","instance":13823,"id":200494,"goal":"lemma SeqNilAppend_13823(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_13824","instance":13824,"id":200495,"goal":"lemma SeqAppendAssoc_13824(zs: seq, ys: seq, s: seq)\n ensures (zs + ys) + s == zs + (ys + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_13825","instance":13825,"id":200496,"goal":"lemma SeqTakeDrop_13825(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_13826","instance":13826,"id":200497,"goal":"lemma SeqReverseLen_13826(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_13827","instance":13827,"id":200498,"goal":"lemma SeqReverseIdem_13827(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_13828","instance":13828,"id":200499,"goal":"lemma SeqMapLen_13828(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_13829","instance":13829,"id":200500,"goal":"lemma SeqFilterLe_13829(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_13830","instance":13830,"id":200501,"goal":"lemma SeqMemberAppend_13830(t: seq, xs: seq)\n ensures x in t + xs <==> x in t || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_13831","instance":13831,"id":200502,"goal":"lemma SeqAppendLen_13831(t: seq, xs: seq)\n ensures |t + xs| == |t| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_13832","instance":13832,"id":200503,"goal":"lemma SeqAppendNil_13832(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_13833","instance":13833,"id":200504,"goal":"lemma SeqNilAppend_13833(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_13834","instance":13834,"id":200505,"goal":"lemma SeqAppendAssoc_13834(zs: seq, xs: seq, s: seq)\n ensures (zs + xs) + s == zs + (xs + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_13835","instance":13835,"id":200506,"goal":"lemma SeqTakeDrop_13835(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_13836","instance":13836,"id":200507,"goal":"lemma SeqReverseLen_13836(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_13837","instance":13837,"id":200508,"goal":"lemma SeqReverseIdem_13837(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_13838","instance":13838,"id":200509,"goal":"lemma SeqMapLen_13838(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_13839","instance":13839,"id":200510,"goal":"lemma SeqFilterLe_13839(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_13840","instance":13840,"id":200511,"goal":"lemma SeqMemberAppend_13840(ys: seq, zs: seq)\n ensures x in ys + zs <==> x in ys || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_13841","instance":13841,"id":200512,"goal":"lemma SeqAppendLen_13841(t: seq, xs: seq)\n ensures |t + xs| == |t| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_13842","instance":13842,"id":200513,"goal":"lemma SeqAppendNil_13842(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_13843","instance":13843,"id":200514,"goal":"lemma SeqNilAppend_13843(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_13844","instance":13844,"id":200515,"goal":"lemma SeqAppendAssoc_13844(u: seq, zs: seq, t: seq)\n ensures (u + zs) + t == u + (zs + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_13845","instance":13845,"id":200516,"goal":"lemma SeqTakeDrop_13845(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_13846","instance":13846,"id":200517,"goal":"lemma SeqReverseLen_13846(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_13847","instance":13847,"id":200518,"goal":"lemma SeqReverseIdem_13847(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_13848","instance":13848,"id":200519,"goal":"lemma SeqMapLen_13848(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_13849","instance":13849,"id":200520,"goal":"lemma SeqFilterLe_13849(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_13850","instance":13850,"id":200521,"goal":"lemma SeqMemberAppend_13850(zs: seq, t: seq)\n ensures x in zs + t <==> x in zs || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_13851","instance":13851,"id":200522,"goal":"lemma SeqAppendLen_13851(s: seq, u: seq)\n ensures |s + u| == |s| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_13852","instance":13852,"id":200523,"goal":"lemma SeqAppendNil_13852(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_13853","instance":13853,"id":200524,"goal":"lemma SeqNilAppend_13853(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_13854","instance":13854,"id":200525,"goal":"lemma SeqAppendAssoc_13854(s: seq, ys: seq, zs: seq)\n ensures (s + ys) + zs == s + (ys + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_13855","instance":13855,"id":200526,"goal":"lemma SeqTakeDrop_13855(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_13856","instance":13856,"id":200527,"goal":"lemma SeqReverseLen_13856(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_13857","instance":13857,"id":200528,"goal":"lemma SeqReverseIdem_13857(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_13858","instance":13858,"id":200529,"goal":"lemma SeqMapLen_13858(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_13859","instance":13859,"id":200530,"goal":"lemma SeqFilterLe_13859(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_13860","instance":13860,"id":200531,"goal":"lemma SeqMemberAppend_13860(s: seq, ys: seq)\n ensures x in s + ys <==> x in s || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_13861","instance":13861,"id":200532,"goal":"lemma SeqAppendLen_13861(zs: seq, xs: seq)\n ensures |zs + xs| == |zs| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_13862","instance":13862,"id":200533,"goal":"lemma SeqAppendNil_13862(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_13863","instance":13863,"id":200534,"goal":"lemma SeqNilAppend_13863(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_13864","instance":13864,"id":200535,"goal":"lemma SeqAppendAssoc_13864(s: seq, t: seq, u: seq)\n ensures (s + t) + u == s + (t + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_13865","instance":13865,"id":200536,"goal":"lemma SeqTakeDrop_13865(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_13866","instance":13866,"id":200537,"goal":"lemma SeqReverseLen_13866(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_13867","instance":13867,"id":200538,"goal":"lemma SeqReverseIdem_13867(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_13868","instance":13868,"id":200539,"goal":"lemma SeqMapLen_13868(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_13869","instance":13869,"id":200540,"goal":"lemma SeqFilterLe_13869(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_13870","instance":13870,"id":200541,"goal":"lemma SeqMemberAppend_13870(s: seq, zs: seq)\n ensures x in s + zs <==> x in s || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_13871","instance":13871,"id":200542,"goal":"lemma SeqAppendLen_13871(t: seq, u: seq)\n ensures |t + u| == |t| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_13872","instance":13872,"id":200543,"goal":"lemma SeqAppendNil_13872(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_13873","instance":13873,"id":200544,"goal":"lemma SeqNilAppend_13873(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_13874","instance":13874,"id":200545,"goal":"lemma SeqAppendAssoc_13874(s: seq, t: seq, xs: seq)\n ensures (s + t) + xs == s + (t + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_13875","instance":13875,"id":200546,"goal":"lemma SeqTakeDrop_13875(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_13876","instance":13876,"id":200547,"goal":"lemma SeqReverseLen_13876(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_13877","instance":13877,"id":200548,"goal":"lemma SeqReverseIdem_13877(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_13878","instance":13878,"id":200549,"goal":"lemma SeqMapLen_13878(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_13879","instance":13879,"id":200550,"goal":"lemma SeqFilterLe_13879(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_13880","instance":13880,"id":200551,"goal":"lemma SeqMemberAppend_13880(u: seq, ys: seq)\n ensures x in u + ys <==> x in u || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_13881","instance":13881,"id":200552,"goal":"lemma SeqAppendLen_13881(s: seq, xs: seq)\n ensures |s + xs| == |s| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_13882","instance":13882,"id":200553,"goal":"lemma SeqAppendNil_13882(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_13883","instance":13883,"id":200554,"goal":"lemma SeqNilAppend_13883(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_13884","instance":13884,"id":200555,"goal":"lemma SeqAppendAssoc_13884(u: seq, zs: seq, t: seq)\n ensures (u + zs) + t == u + (zs + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_13885","instance":13885,"id":200556,"goal":"lemma SeqTakeDrop_13885(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_13886","instance":13886,"id":200557,"goal":"lemma SeqReverseLen_13886(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_13887","instance":13887,"id":200558,"goal":"lemma SeqReverseIdem_13887(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_13888","instance":13888,"id":200559,"goal":"lemma SeqMapLen_13888(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_13889","instance":13889,"id":200560,"goal":"lemma SeqFilterLe_13889(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_13890","instance":13890,"id":200561,"goal":"lemma SeqMemberAppend_13890(zs: seq, xs: seq)\n ensures x in zs + xs <==> x in zs || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_13891","instance":13891,"id":200562,"goal":"lemma SeqAppendLen_13891(xs: seq, ys: seq)\n ensures |xs + ys| == |xs| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_13892","instance":13892,"id":200563,"goal":"lemma SeqAppendNil_13892(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_13893","instance":13893,"id":200564,"goal":"lemma SeqNilAppend_13893(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_13894","instance":13894,"id":200565,"goal":"lemma SeqAppendAssoc_13894(t: seq, u: seq, ys: seq)\n ensures (t + u) + ys == t + (u + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_13895","instance":13895,"id":200566,"goal":"lemma SeqTakeDrop_13895(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_13896","instance":13896,"id":200567,"goal":"lemma SeqReverseLen_13896(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_13897","instance":13897,"id":200568,"goal":"lemma SeqReverseIdem_13897(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_13898","instance":13898,"id":200569,"goal":"lemma SeqMapLen_13898(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_13899","instance":13899,"id":200570,"goal":"lemma SeqFilterLe_13899(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_13900","instance":13900,"id":200571,"goal":"lemma SeqMemberAppend_13900(xs: seq, u: seq)\n ensures x in xs + u <==> x in xs || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_13901","instance":13901,"id":200572,"goal":"lemma SeqAppendLen_13901(ys: seq, s: seq)\n ensures |ys + s| == |ys| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_13902","instance":13902,"id":200573,"goal":"lemma SeqAppendNil_13902(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_13903","instance":13903,"id":200574,"goal":"lemma SeqNilAppend_13903(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_13904","instance":13904,"id":200575,"goal":"lemma SeqAppendAssoc_13904(u: seq, xs: seq, ys: seq)\n ensures (u + xs) + ys == u + (xs + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_13905","instance":13905,"id":200576,"goal":"lemma SeqTakeDrop_13905(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_13906","instance":13906,"id":200577,"goal":"lemma SeqReverseLen_13906(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_13907","instance":13907,"id":200578,"goal":"lemma SeqReverseIdem_13907(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_13908","instance":13908,"id":200579,"goal":"lemma SeqMapLen_13908(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_13909","instance":13909,"id":200580,"goal":"lemma SeqFilterLe_13909(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_13910","instance":13910,"id":200581,"goal":"lemma SeqMemberAppend_13910(zs: seq, t: seq)\n ensures x in zs + t <==> x in zs || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_13911","instance":13911,"id":200582,"goal":"lemma SeqAppendLen_13911(zs: seq, ys: seq)\n ensures |zs + ys| == |zs| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_13912","instance":13912,"id":200583,"goal":"lemma SeqAppendNil_13912(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_13913","instance":13913,"id":200584,"goal":"lemma SeqNilAppend_13913(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_13914","instance":13914,"id":200585,"goal":"lemma SeqAppendAssoc_13914(zs: seq, xs: seq, ys: seq)\n ensures (zs + xs) + ys == zs + (xs + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_13915","instance":13915,"id":200586,"goal":"lemma SeqTakeDrop_13915(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_13916","instance":13916,"id":200587,"goal":"lemma SeqReverseLen_13916(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_13917","instance":13917,"id":200588,"goal":"lemma SeqReverseIdem_13917(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_13918","instance":13918,"id":200589,"goal":"lemma SeqMapLen_13918(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_13919","instance":13919,"id":200590,"goal":"lemma SeqFilterLe_13919(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_13920","instance":13920,"id":200591,"goal":"lemma SeqMemberAppend_13920(ys: seq, u: seq)\n ensures x in ys + u <==> x in ys || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_13921","instance":13921,"id":200592,"goal":"lemma SeqAppendLen_13921(u: seq, s: seq)\n ensures |u + s| == |u| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_13922","instance":13922,"id":200593,"goal":"lemma SeqAppendNil_13922(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_13923","instance":13923,"id":200594,"goal":"lemma SeqNilAppend_13923(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_13924","instance":13924,"id":200595,"goal":"lemma SeqAppendAssoc_13924(u: seq, s: seq, ys: seq)\n ensures (u + s) + ys == u + (s + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_13925","instance":13925,"id":200596,"goal":"lemma SeqTakeDrop_13925(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_13926","instance":13926,"id":200597,"goal":"lemma SeqReverseLen_13926(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_13927","instance":13927,"id":200598,"goal":"lemma SeqReverseIdem_13927(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_13928","instance":13928,"id":200599,"goal":"lemma SeqMapLen_13928(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_13929","instance":13929,"id":200600,"goal":"lemma SeqFilterLe_13929(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_13930","instance":13930,"id":200601,"goal":"lemma SeqMemberAppend_13930(xs: seq, ys: seq)\n ensures x in xs + ys <==> x in xs || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_13931","instance":13931,"id":200602,"goal":"lemma SeqAppendLen_13931(zs: seq, xs: seq)\n ensures |zs + xs| == |zs| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_13932","instance":13932,"id":200603,"goal":"lemma SeqAppendNil_13932(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_13933","instance":13933,"id":200604,"goal":"lemma SeqNilAppend_13933(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_13934","instance":13934,"id":200605,"goal":"lemma SeqAppendAssoc_13934(t: seq, ys: seq, u: seq)\n ensures (t + ys) + u == t + (ys + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_13935","instance":13935,"id":200606,"goal":"lemma SeqTakeDrop_13935(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_13936","instance":13936,"id":200607,"goal":"lemma SeqReverseLen_13936(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_13937","instance":13937,"id":200608,"goal":"lemma SeqReverseIdem_13937(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_13938","instance":13938,"id":200609,"goal":"lemma SeqMapLen_13938(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_13939","instance":13939,"id":200610,"goal":"lemma SeqFilterLe_13939(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_13940","instance":13940,"id":200611,"goal":"lemma SeqMemberAppend_13940(s: seq, xs: seq)\n ensures x in s + xs <==> x in s || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_13941","instance":13941,"id":200612,"goal":"lemma SeqAppendLen_13941(t: seq, xs: seq)\n ensures |t + xs| == |t| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_13942","instance":13942,"id":200613,"goal":"lemma SeqAppendNil_13942(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_13943","instance":13943,"id":200614,"goal":"lemma SeqNilAppend_13943(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_13944","instance":13944,"id":200615,"goal":"lemma SeqAppendAssoc_13944(s: seq, u: seq, zs: seq)\n ensures (s + u) + zs == s + (u + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_13945","instance":13945,"id":200616,"goal":"lemma SeqTakeDrop_13945(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_13946","instance":13946,"id":200617,"goal":"lemma SeqReverseLen_13946(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_13947","instance":13947,"id":200618,"goal":"lemma SeqReverseIdem_13947(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_13948","instance":13948,"id":200619,"goal":"lemma SeqMapLen_13948(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_13949","instance":13949,"id":200620,"goal":"lemma SeqFilterLe_13949(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_13950","instance":13950,"id":200621,"goal":"lemma SeqMemberAppend_13950(s: seq, t: seq)\n ensures x in s + t <==> x in s || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_13951","instance":13951,"id":200622,"goal":"lemma SeqAppendLen_13951(s: seq, ys: seq)\n ensures |s + ys| == |s| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_13952","instance":13952,"id":200623,"goal":"lemma SeqAppendNil_13952(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_13953","instance":13953,"id":200624,"goal":"lemma SeqNilAppend_13953(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_13954","instance":13954,"id":200625,"goal":"lemma SeqAppendAssoc_13954(xs: seq, t: seq, ys: seq)\n ensures (xs + t) + ys == xs + (t + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_13955","instance":13955,"id":200626,"goal":"lemma SeqTakeDrop_13955(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_13956","instance":13956,"id":200627,"goal":"lemma SeqReverseLen_13956(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_13957","instance":13957,"id":200628,"goal":"lemma SeqReverseIdem_13957(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_13958","instance":13958,"id":200629,"goal":"lemma SeqMapLen_13958(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_13959","instance":13959,"id":200630,"goal":"lemma SeqFilterLe_13959(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_13960","instance":13960,"id":200631,"goal":"lemma SeqMemberAppend_13960(zs: seq, s: seq)\n ensures x in zs + s <==> x in zs || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_13961","instance":13961,"id":200632,"goal":"lemma SeqAppendLen_13961(s: seq, u: seq)\n ensures |s + u| == |s| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_13962","instance":13962,"id":200633,"goal":"lemma SeqAppendNil_13962(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_13963","instance":13963,"id":200634,"goal":"lemma SeqNilAppend_13963(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_13964","instance":13964,"id":200635,"goal":"lemma SeqAppendAssoc_13964(t: seq, s: seq, xs: seq)\n ensures (t + s) + xs == t + (s + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_13965","instance":13965,"id":200636,"goal":"lemma SeqTakeDrop_13965(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_13966","instance":13966,"id":200637,"goal":"lemma SeqReverseLen_13966(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_13967","instance":13967,"id":200638,"goal":"lemma SeqReverseIdem_13967(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_13968","instance":13968,"id":200639,"goal":"lemma SeqMapLen_13968(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_13969","instance":13969,"id":200640,"goal":"lemma SeqFilterLe_13969(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_13970","instance":13970,"id":200641,"goal":"lemma SeqMemberAppend_13970(u: seq, t: seq)\n ensures x in u + t <==> x in u || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_13971","instance":13971,"id":200642,"goal":"lemma SeqAppendLen_13971(xs: seq, ys: seq)\n ensures |xs + ys| == |xs| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_13972","instance":13972,"id":200643,"goal":"lemma SeqAppendNil_13972(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_13973","instance":13973,"id":200644,"goal":"lemma SeqNilAppend_13973(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_13974","instance":13974,"id":200645,"goal":"lemma SeqAppendAssoc_13974(s: seq, zs: seq, xs: seq)\n ensures (s + zs) + xs == s + (zs + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_13975","instance":13975,"id":200646,"goal":"lemma SeqTakeDrop_13975(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_13976","instance":13976,"id":200647,"goal":"lemma SeqReverseLen_13976(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_13977","instance":13977,"id":200648,"goal":"lemma SeqReverseIdem_13977(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_13978","instance":13978,"id":200649,"goal":"lemma SeqMapLen_13978(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_13979","instance":13979,"id":200650,"goal":"lemma SeqFilterLe_13979(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_13980","instance":13980,"id":200651,"goal":"lemma SeqMemberAppend_13980(zs: seq, u: seq)\n ensures x in zs + u <==> x in zs || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_13981","instance":13981,"id":200652,"goal":"lemma SeqAppendLen_13981(xs: seq, u: seq)\n ensures |xs + u| == |xs| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_13982","instance":13982,"id":200653,"goal":"lemma SeqAppendNil_13982(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_13983","instance":13983,"id":200654,"goal":"lemma SeqNilAppend_13983(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_13984","instance":13984,"id":200655,"goal":"lemma SeqAppendAssoc_13984(ys: seq, xs: seq, s: seq)\n ensures (ys + xs) + s == ys + (xs + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_13985","instance":13985,"id":200656,"goal":"lemma SeqTakeDrop_13985(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_13986","instance":13986,"id":200657,"goal":"lemma SeqReverseLen_13986(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_13987","instance":13987,"id":200658,"goal":"lemma SeqReverseIdem_13987(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_13988","instance":13988,"id":200659,"goal":"lemma SeqMapLen_13988(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_13989","instance":13989,"id":200660,"goal":"lemma SeqFilterLe_13989(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_13990","instance":13990,"id":200661,"goal":"lemma SeqMemberAppend_13990(zs: seq, ys: seq)\n ensures x in zs + ys <==> x in zs || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_13991","instance":13991,"id":200662,"goal":"lemma SeqAppendLen_13991(xs: seq, t: seq)\n ensures |xs + t| == |xs| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_13992","instance":13992,"id":200663,"goal":"lemma SeqAppendNil_13992(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_13993","instance":13993,"id":200664,"goal":"lemma SeqNilAppend_13993(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_13994","instance":13994,"id":200665,"goal":"lemma SeqAppendAssoc_13994(t: seq, ys: seq, u: seq)\n ensures (t + ys) + u == t + (ys + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_13995","instance":13995,"id":200666,"goal":"lemma SeqTakeDrop_13995(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_13996","instance":13996,"id":200667,"goal":"lemma SeqReverseLen_13996(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_13997","instance":13997,"id":200668,"goal":"lemma SeqReverseIdem_13997(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_13998","instance":13998,"id":200669,"goal":"lemma SeqMapLen_13998(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_13999","instance":13999,"id":200670,"goal":"lemma SeqFilterLe_13999(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_14000","instance":14000,"id":200671,"goal":"lemma SeqMemberAppend_14000(xs: seq, s: seq)\n ensures x in xs + s <==> x in xs || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_14001","instance":14001,"id":200672,"goal":"lemma SeqAppendLen_14001(ys: seq, u: seq)\n ensures |ys + u| == |ys| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_14002","instance":14002,"id":200673,"goal":"lemma SeqAppendNil_14002(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_14003","instance":14003,"id":200674,"goal":"lemma SeqNilAppend_14003(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_14004","instance":14004,"id":200675,"goal":"lemma SeqAppendAssoc_14004(t: seq, xs: seq, s: seq)\n ensures (t + xs) + s == t + (xs + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_14005","instance":14005,"id":200676,"goal":"lemma SeqTakeDrop_14005(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_14006","instance":14006,"id":200677,"goal":"lemma SeqReverseLen_14006(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_14007","instance":14007,"id":200678,"goal":"lemma SeqReverseIdem_14007(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_14008","instance":14008,"id":200679,"goal":"lemma SeqMapLen_14008(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_14009","instance":14009,"id":200680,"goal":"lemma SeqFilterLe_14009(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_14010","instance":14010,"id":200681,"goal":"lemma SeqMemberAppend_14010(zs: seq, xs: seq)\n ensures x in zs + xs <==> x in zs || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_14011","instance":14011,"id":200682,"goal":"lemma SeqAppendLen_14011(ys: seq, s: seq)\n ensures |ys + s| == |ys| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_14012","instance":14012,"id":200683,"goal":"lemma SeqAppendNil_14012(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_14013","instance":14013,"id":200684,"goal":"lemma SeqNilAppend_14013(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_14014","instance":14014,"id":200685,"goal":"lemma SeqAppendAssoc_14014(zs: seq, ys: seq, xs: seq)\n ensures (zs + ys) + xs == zs + (ys + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_14015","instance":14015,"id":200686,"goal":"lemma SeqTakeDrop_14015(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_14016","instance":14016,"id":200687,"goal":"lemma SeqReverseLen_14016(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_14017","instance":14017,"id":200688,"goal":"lemma SeqReverseIdem_14017(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_14018","instance":14018,"id":200689,"goal":"lemma SeqMapLen_14018(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_14019","instance":14019,"id":200690,"goal":"lemma SeqFilterLe_14019(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_14020","instance":14020,"id":200691,"goal":"lemma SeqMemberAppend_14020(t: seq, s: seq)\n ensures x in t + s <==> x in t || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_14021","instance":14021,"id":200692,"goal":"lemma SeqAppendLen_14021(u: seq, s: seq)\n ensures |u + s| == |u| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_14022","instance":14022,"id":200693,"goal":"lemma SeqAppendNil_14022(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_14023","instance":14023,"id":200694,"goal":"lemma SeqNilAppend_14023(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_14024","instance":14024,"id":200695,"goal":"lemma SeqAppendAssoc_14024(xs: seq, ys: seq, t: seq)\n ensures (xs + ys) + t == xs + (ys + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_14025","instance":14025,"id":200696,"goal":"lemma SeqTakeDrop_14025(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_14026","instance":14026,"id":200697,"goal":"lemma SeqReverseLen_14026(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_14027","instance":14027,"id":200698,"goal":"lemma SeqReverseIdem_14027(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_14028","instance":14028,"id":200699,"goal":"lemma SeqMapLen_14028(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_14029","instance":14029,"id":200700,"goal":"lemma SeqFilterLe_14029(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_14030","instance":14030,"id":200701,"goal":"lemma SeqMemberAppend_14030(u: seq, xs: seq)\n ensures x in u + xs <==> x in u || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_14031","instance":14031,"id":200702,"goal":"lemma SeqAppendLen_14031(u: seq, xs: seq)\n ensures |u + xs| == |u| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_14032","instance":14032,"id":200703,"goal":"lemma SeqAppendNil_14032(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_14033","instance":14033,"id":200704,"goal":"lemma SeqNilAppend_14033(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_14034","instance":14034,"id":200705,"goal":"lemma SeqAppendAssoc_14034(t: seq, zs: seq, s: seq)\n ensures (t + zs) + s == t + (zs + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_14035","instance":14035,"id":200706,"goal":"lemma SeqTakeDrop_14035(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_14036","instance":14036,"id":200707,"goal":"lemma SeqReverseLen_14036(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_14037","instance":14037,"id":200708,"goal":"lemma SeqReverseIdem_14037(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_14038","instance":14038,"id":200709,"goal":"lemma SeqMapLen_14038(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_14039","instance":14039,"id":200710,"goal":"lemma SeqFilterLe_14039(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_14040","instance":14040,"id":200711,"goal":"lemma SeqMemberAppend_14040(u: seq, s: seq)\n ensures x in u + s <==> x in u || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_14041","instance":14041,"id":200712,"goal":"lemma SeqAppendLen_14041(zs: seq, t: seq)\n ensures |zs + t| == |zs| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_14042","instance":14042,"id":200713,"goal":"lemma SeqAppendNil_14042(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_14043","instance":14043,"id":200714,"goal":"lemma SeqNilAppend_14043(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_14044","instance":14044,"id":200715,"goal":"lemma SeqAppendAssoc_14044(zs: seq, xs: seq, u: seq)\n ensures (zs + xs) + u == zs + (xs + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_14045","instance":14045,"id":200716,"goal":"lemma SeqTakeDrop_14045(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_14046","instance":14046,"id":200717,"goal":"lemma SeqReverseLen_14046(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_14047","instance":14047,"id":200718,"goal":"lemma SeqReverseIdem_14047(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_14048","instance":14048,"id":200719,"goal":"lemma SeqMapLen_14048(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_14049","instance":14049,"id":200720,"goal":"lemma SeqFilterLe_14049(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_14050","instance":14050,"id":200721,"goal":"lemma SeqMemberAppend_14050(ys: seq, t: seq)\n ensures x in ys + t <==> x in ys || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_14051","instance":14051,"id":200722,"goal":"lemma SeqAppendLen_14051(s: seq, ys: seq)\n ensures |s + ys| == |s| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_14052","instance":14052,"id":200723,"goal":"lemma SeqAppendNil_14052(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_14053","instance":14053,"id":200724,"goal":"lemma SeqNilAppend_14053(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_14054","instance":14054,"id":200725,"goal":"lemma SeqAppendAssoc_14054(u: seq, zs: seq, t: seq)\n ensures (u + zs) + t == u + (zs + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_14055","instance":14055,"id":200726,"goal":"lemma SeqTakeDrop_14055(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_14056","instance":14056,"id":200727,"goal":"lemma SeqReverseLen_14056(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_14057","instance":14057,"id":200728,"goal":"lemma SeqReverseIdem_14057(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_14058","instance":14058,"id":200729,"goal":"lemma SeqMapLen_14058(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_14059","instance":14059,"id":200730,"goal":"lemma SeqFilterLe_14059(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_14060","instance":14060,"id":200731,"goal":"lemma SeqMemberAppend_14060(u: seq, ys: seq)\n ensures x in u + ys <==> x in u || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_14061","instance":14061,"id":200732,"goal":"lemma SeqAppendLen_14061(ys: seq, zs: seq)\n ensures |ys + zs| == |ys| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_14062","instance":14062,"id":200733,"goal":"lemma SeqAppendNil_14062(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_14063","instance":14063,"id":200734,"goal":"lemma SeqNilAppend_14063(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_14064","instance":14064,"id":200735,"goal":"lemma SeqAppendAssoc_14064(u: seq, xs: seq, zs: seq)\n ensures (u + xs) + zs == u + (xs + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_14065","instance":14065,"id":200736,"goal":"lemma SeqTakeDrop_14065(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_14066","instance":14066,"id":200737,"goal":"lemma SeqReverseLen_14066(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_14067","instance":14067,"id":200738,"goal":"lemma SeqReverseIdem_14067(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_14068","instance":14068,"id":200739,"goal":"lemma SeqMapLen_14068(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_14069","instance":14069,"id":200740,"goal":"lemma SeqFilterLe_14069(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_14070","instance":14070,"id":200741,"goal":"lemma SeqMemberAppend_14070(u: seq, zs: seq)\n ensures x in u + zs <==> x in u || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_14071","instance":14071,"id":200742,"goal":"lemma SeqAppendLen_14071(ys: seq, u: seq)\n ensures |ys + u| == |ys| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_14072","instance":14072,"id":200743,"goal":"lemma SeqAppendNil_14072(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_14073","instance":14073,"id":200744,"goal":"lemma SeqNilAppend_14073(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_14074","instance":14074,"id":200745,"goal":"lemma SeqAppendAssoc_14074(xs: seq, s: seq, zs: seq)\n ensures (xs + s) + zs == xs + (s + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_14075","instance":14075,"id":200746,"goal":"lemma SeqTakeDrop_14075(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_14076","instance":14076,"id":200747,"goal":"lemma SeqReverseLen_14076(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_14077","instance":14077,"id":200748,"goal":"lemma SeqReverseIdem_14077(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_14078","instance":14078,"id":200749,"goal":"lemma SeqMapLen_14078(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_14079","instance":14079,"id":200750,"goal":"lemma SeqFilterLe_14079(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_14080","instance":14080,"id":200751,"goal":"lemma SeqMemberAppend_14080(u: seq, xs: seq)\n ensures x in u + xs <==> x in u || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_14081","instance":14081,"id":200752,"goal":"lemma SeqAppendLen_14081(ys: seq, s: seq)\n ensures |ys + s| == |ys| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_14082","instance":14082,"id":200753,"goal":"lemma SeqAppendNil_14082(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_14083","instance":14083,"id":200754,"goal":"lemma SeqNilAppend_14083(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_14084","instance":14084,"id":200755,"goal":"lemma SeqAppendAssoc_14084(t: seq, zs: seq, ys: seq)\n ensures (t + zs) + ys == t + (zs + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_14085","instance":14085,"id":200756,"goal":"lemma SeqTakeDrop_14085(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_14086","instance":14086,"id":200757,"goal":"lemma SeqReverseLen_14086(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_14087","instance":14087,"id":200758,"goal":"lemma SeqReverseIdem_14087(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_14088","instance":14088,"id":200759,"goal":"lemma SeqMapLen_14088(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_14089","instance":14089,"id":200760,"goal":"lemma SeqFilterLe_14089(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_14090","instance":14090,"id":200761,"goal":"lemma SeqMemberAppend_14090(ys: seq, u: seq)\n ensures x in ys + u <==> x in ys || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_14091","instance":14091,"id":200762,"goal":"lemma SeqAppendLen_14091(t: seq, zs: seq)\n ensures |t + zs| == |t| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_14092","instance":14092,"id":200763,"goal":"lemma SeqAppendNil_14092(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_14093","instance":14093,"id":200764,"goal":"lemma SeqNilAppend_14093(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_14094","instance":14094,"id":200765,"goal":"lemma SeqAppendAssoc_14094(s: seq, ys: seq, t: seq)\n ensures (s + ys) + t == s + (ys + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_14095","instance":14095,"id":200766,"goal":"lemma SeqTakeDrop_14095(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_14096","instance":14096,"id":200767,"goal":"lemma SeqReverseLen_14096(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_14097","instance":14097,"id":200768,"goal":"lemma SeqReverseIdem_14097(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_14098","instance":14098,"id":200769,"goal":"lemma SeqMapLen_14098(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_14099","instance":14099,"id":200770,"goal":"lemma SeqFilterLe_14099(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_14100","instance":14100,"id":200771,"goal":"lemma SeqMemberAppend_14100(u: seq, ys: seq)\n ensures x in u + ys <==> x in u || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_14101","instance":14101,"id":200772,"goal":"lemma SeqAppendLen_14101(s: seq, zs: seq)\n ensures |s + zs| == |s| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_14102","instance":14102,"id":200773,"goal":"lemma SeqAppendNil_14102(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_14103","instance":14103,"id":200774,"goal":"lemma SeqNilAppend_14103(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_14104","instance":14104,"id":200775,"goal":"lemma SeqAppendAssoc_14104(s: seq, u: seq, ys: seq)\n ensures (s + u) + ys == s + (u + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_14105","instance":14105,"id":200776,"goal":"lemma SeqTakeDrop_14105(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_14106","instance":14106,"id":200777,"goal":"lemma SeqReverseLen_14106(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_14107","instance":14107,"id":200778,"goal":"lemma SeqReverseIdem_14107(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_14108","instance":14108,"id":200779,"goal":"lemma SeqMapLen_14108(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_14109","instance":14109,"id":200780,"goal":"lemma SeqFilterLe_14109(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_14110","instance":14110,"id":200781,"goal":"lemma SeqMemberAppend_14110(s: seq, zs: seq)\n ensures x in s + zs <==> x in s || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_14111","instance":14111,"id":200782,"goal":"lemma SeqAppendLen_14111(s: seq, t: seq)\n ensures |s + t| == |s| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_14112","instance":14112,"id":200783,"goal":"lemma SeqAppendNil_14112(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_14113","instance":14113,"id":200784,"goal":"lemma SeqNilAppend_14113(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_14114","instance":14114,"id":200785,"goal":"lemma SeqAppendAssoc_14114(ys: seq, xs: seq, zs: seq)\n ensures (ys + xs) + zs == ys + (xs + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_14115","instance":14115,"id":200786,"goal":"lemma SeqTakeDrop_14115(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_14116","instance":14116,"id":200787,"goal":"lemma SeqReverseLen_14116(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_14117","instance":14117,"id":200788,"goal":"lemma SeqReverseIdem_14117(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_14118","instance":14118,"id":200789,"goal":"lemma SeqMapLen_14118(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_14119","instance":14119,"id":200790,"goal":"lemma SeqFilterLe_14119(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_14120","instance":14120,"id":200791,"goal":"lemma SeqMemberAppend_14120(t: seq, s: seq)\n ensures x in t + s <==> x in t || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_14121","instance":14121,"id":200792,"goal":"lemma SeqAppendLen_14121(u: seq, s: seq)\n ensures |u + s| == |u| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_14122","instance":14122,"id":200793,"goal":"lemma SeqAppendNil_14122(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_14123","instance":14123,"id":200794,"goal":"lemma SeqNilAppend_14123(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_14124","instance":14124,"id":200795,"goal":"lemma SeqAppendAssoc_14124(u: seq, s: seq, t: seq)\n ensures (u + s) + t == u + (s + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_14125","instance":14125,"id":200796,"goal":"lemma SeqTakeDrop_14125(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_14126","instance":14126,"id":200797,"goal":"lemma SeqReverseLen_14126(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_14127","instance":14127,"id":200798,"goal":"lemma SeqReverseIdem_14127(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_14128","instance":14128,"id":200799,"goal":"lemma SeqMapLen_14128(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_14129","instance":14129,"id":200800,"goal":"lemma SeqFilterLe_14129(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_14130","instance":14130,"id":200801,"goal":"lemma SeqMemberAppend_14130(ys: seq, s: seq)\n ensures x in ys + s <==> x in ys || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_14131","instance":14131,"id":200802,"goal":"lemma SeqAppendLen_14131(s: seq, t: seq)\n ensures |s + t| == |s| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_14132","instance":14132,"id":200803,"goal":"lemma SeqAppendNil_14132(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_14133","instance":14133,"id":200804,"goal":"lemma SeqNilAppend_14133(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_14134","instance":14134,"id":200805,"goal":"lemma SeqAppendAssoc_14134(u: seq, t: seq, s: seq)\n ensures (u + t) + s == u + (t + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_14135","instance":14135,"id":200806,"goal":"lemma SeqTakeDrop_14135(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_14136","instance":14136,"id":200807,"goal":"lemma SeqReverseLen_14136(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_14137","instance":14137,"id":200808,"goal":"lemma SeqReverseIdem_14137(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_14138","instance":14138,"id":200809,"goal":"lemma SeqMapLen_14138(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_14139","instance":14139,"id":200810,"goal":"lemma SeqFilterLe_14139(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_14140","instance":14140,"id":200811,"goal":"lemma SeqMemberAppend_14140(t: seq, u: seq)\n ensures x in t + u <==> x in t || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_14141","instance":14141,"id":200812,"goal":"lemma SeqAppendLen_14141(t: seq, ys: seq)\n ensures |t + ys| == |t| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_14142","instance":14142,"id":200813,"goal":"lemma SeqAppendNil_14142(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_14143","instance":14143,"id":200814,"goal":"lemma SeqNilAppend_14143(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_14144","instance":14144,"id":200815,"goal":"lemma SeqAppendAssoc_14144(xs: seq, t: seq, s: seq)\n ensures (xs + t) + s == xs + (t + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_14145","instance":14145,"id":200816,"goal":"lemma SeqTakeDrop_14145(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_14146","instance":14146,"id":200817,"goal":"lemma SeqReverseLen_14146(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_14147","instance":14147,"id":200818,"goal":"lemma SeqReverseIdem_14147(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_14148","instance":14148,"id":200819,"goal":"lemma SeqMapLen_14148(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_14149","instance":14149,"id":200820,"goal":"lemma SeqFilterLe_14149(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_14150","instance":14150,"id":200821,"goal":"lemma SeqMemberAppend_14150(s: seq, zs: seq)\n ensures x in s + zs <==> x in s || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_14151","instance":14151,"id":200822,"goal":"lemma SeqAppendLen_14151(u: seq, s: seq)\n ensures |u + s| == |u| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_14152","instance":14152,"id":200823,"goal":"lemma SeqAppendNil_14152(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_14153","instance":14153,"id":200824,"goal":"lemma SeqNilAppend_14153(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_14154","instance":14154,"id":200825,"goal":"lemma SeqAppendAssoc_14154(xs: seq, u: seq, zs: seq)\n ensures (xs + u) + zs == xs + (u + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_14155","instance":14155,"id":200826,"goal":"lemma SeqTakeDrop_14155(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_14156","instance":14156,"id":200827,"goal":"lemma SeqReverseLen_14156(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_14157","instance":14157,"id":200828,"goal":"lemma SeqReverseIdem_14157(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_14158","instance":14158,"id":200829,"goal":"lemma SeqMapLen_14158(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_14159","instance":14159,"id":200830,"goal":"lemma SeqFilterLe_14159(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_14160","instance":14160,"id":200831,"goal":"lemma SeqMemberAppend_14160(xs: seq, t: seq)\n ensures x in xs + t <==> x in xs || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_14161","instance":14161,"id":200832,"goal":"lemma SeqAppendLen_14161(u: seq, xs: seq)\n ensures |u + xs| == |u| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_14162","instance":14162,"id":200833,"goal":"lemma SeqAppendNil_14162(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_14163","instance":14163,"id":200834,"goal":"lemma SeqNilAppend_14163(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_14164","instance":14164,"id":200835,"goal":"lemma SeqAppendAssoc_14164(zs: seq, xs: seq, t: seq)\n ensures (zs + xs) + t == zs + (xs + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_14165","instance":14165,"id":200836,"goal":"lemma SeqTakeDrop_14165(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_14166","instance":14166,"id":200837,"goal":"lemma SeqReverseLen_14166(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_14167","instance":14167,"id":200838,"goal":"lemma SeqReverseIdem_14167(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_14168","instance":14168,"id":200839,"goal":"lemma SeqMapLen_14168(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_14169","instance":14169,"id":200840,"goal":"lemma SeqFilterLe_14169(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_14170","instance":14170,"id":200841,"goal":"lemma SeqMemberAppend_14170(zs: seq, t: seq)\n ensures x in zs + t <==> x in zs || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_14171","instance":14171,"id":200842,"goal":"lemma SeqAppendLen_14171(t: seq, zs: seq)\n ensures |t + zs| == |t| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_14172","instance":14172,"id":200843,"goal":"lemma SeqAppendNil_14172(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_14173","instance":14173,"id":200844,"goal":"lemma SeqNilAppend_14173(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_14174","instance":14174,"id":200845,"goal":"lemma SeqAppendAssoc_14174(u: seq, s: seq, xs: seq)\n ensures (u + s) + xs == u + (s + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_14175","instance":14175,"id":200846,"goal":"lemma SeqTakeDrop_14175(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_14176","instance":14176,"id":200847,"goal":"lemma SeqReverseLen_14176(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_14177","instance":14177,"id":200848,"goal":"lemma SeqReverseIdem_14177(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_14178","instance":14178,"id":200849,"goal":"lemma SeqMapLen_14178(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_14179","instance":14179,"id":200850,"goal":"lemma SeqFilterLe_14179(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_14180","instance":14180,"id":200851,"goal":"lemma SeqMemberAppend_14180(u: seq, zs: seq)\n ensures x in u + zs <==> x in u || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_14181","instance":14181,"id":200852,"goal":"lemma SeqAppendLen_14181(t: seq, s: seq)\n ensures |t + s| == |t| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_14182","instance":14182,"id":200853,"goal":"lemma SeqAppendNil_14182(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_14183","instance":14183,"id":200854,"goal":"lemma SeqNilAppend_14183(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_14184","instance":14184,"id":200855,"goal":"lemma SeqAppendAssoc_14184(s: seq, u: seq, zs: seq)\n ensures (s + u) + zs == s + (u + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_14185","instance":14185,"id":200856,"goal":"lemma SeqTakeDrop_14185(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_14186","instance":14186,"id":200857,"goal":"lemma SeqReverseLen_14186(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_14187","instance":14187,"id":200858,"goal":"lemma SeqReverseIdem_14187(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_14188","instance":14188,"id":200859,"goal":"lemma SeqMapLen_14188(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_14189","instance":14189,"id":200860,"goal":"lemma SeqFilterLe_14189(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_14190","instance":14190,"id":200861,"goal":"lemma SeqMemberAppend_14190(s: seq, u: seq)\n ensures x in s + u <==> x in s || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_14191","instance":14191,"id":200862,"goal":"lemma SeqAppendLen_14191(u: seq, zs: seq)\n ensures |u + zs| == |u| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_14192","instance":14192,"id":200863,"goal":"lemma SeqAppendNil_14192(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_14193","instance":14193,"id":200864,"goal":"lemma SeqNilAppend_14193(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_14194","instance":14194,"id":200865,"goal":"lemma SeqAppendAssoc_14194(u: seq, ys: seq, t: seq)\n ensures (u + ys) + t == u + (ys + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_14195","instance":14195,"id":200866,"goal":"lemma SeqTakeDrop_14195(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_14196","instance":14196,"id":200867,"goal":"lemma SeqReverseLen_14196(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_14197","instance":14197,"id":200868,"goal":"lemma SeqReverseIdem_14197(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_14198","instance":14198,"id":200869,"goal":"lemma SeqMapLen_14198(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_14199","instance":14199,"id":200870,"goal":"lemma SeqFilterLe_14199(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_14200","instance":14200,"id":200871,"goal":"lemma SeqMemberAppend_14200(ys: seq, t: seq)\n ensures x in ys + t <==> x in ys || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_14201","instance":14201,"id":200872,"goal":"lemma SeqAppendLen_14201(s: seq, ys: seq)\n ensures |s + ys| == |s| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_14202","instance":14202,"id":200873,"goal":"lemma SeqAppendNil_14202(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_14203","instance":14203,"id":200874,"goal":"lemma SeqNilAppend_14203(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_14204","instance":14204,"id":200875,"goal":"lemma SeqAppendAssoc_14204(u: seq, t: seq, s: seq)\n ensures (u + t) + s == u + (t + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_14205","instance":14205,"id":200876,"goal":"lemma SeqTakeDrop_14205(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_14206","instance":14206,"id":200877,"goal":"lemma SeqReverseLen_14206(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_14207","instance":14207,"id":200878,"goal":"lemma SeqReverseIdem_14207(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_14208","instance":14208,"id":200879,"goal":"lemma SeqMapLen_14208(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_14209","instance":14209,"id":200880,"goal":"lemma SeqFilterLe_14209(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_14210","instance":14210,"id":200881,"goal":"lemma SeqMemberAppend_14210(s: seq, ys: seq)\n ensures x in s + ys <==> x in s || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_14211","instance":14211,"id":200882,"goal":"lemma SeqAppendLen_14211(zs: seq, xs: seq)\n ensures |zs + xs| == |zs| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_14212","instance":14212,"id":200883,"goal":"lemma SeqAppendNil_14212(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_14213","instance":14213,"id":200884,"goal":"lemma SeqNilAppend_14213(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_14214","instance":14214,"id":200885,"goal":"lemma SeqAppendAssoc_14214(ys: seq, u: seq, xs: seq)\n ensures (ys + u) + xs == ys + (u + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_14215","instance":14215,"id":200886,"goal":"lemma SeqTakeDrop_14215(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_14216","instance":14216,"id":200887,"goal":"lemma SeqReverseLen_14216(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_14217","instance":14217,"id":200888,"goal":"lemma SeqReverseIdem_14217(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_14218","instance":14218,"id":200889,"goal":"lemma SeqMapLen_14218(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_14219","instance":14219,"id":200890,"goal":"lemma SeqFilterLe_14219(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_14220","instance":14220,"id":200891,"goal":"lemma SeqMemberAppend_14220(xs: seq, u: seq)\n ensures x in xs + u <==> x in xs || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_14221","instance":14221,"id":200892,"goal":"lemma SeqAppendLen_14221(t: seq, ys: seq)\n ensures |t + ys| == |t| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_14222","instance":14222,"id":200893,"goal":"lemma SeqAppendNil_14222(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_14223","instance":14223,"id":200894,"goal":"lemma SeqNilAppend_14223(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_14224","instance":14224,"id":200895,"goal":"lemma SeqAppendAssoc_14224(zs: seq, t: seq, xs: seq)\n ensures (zs + t) + xs == zs + (t + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_14225","instance":14225,"id":200896,"goal":"lemma SeqTakeDrop_14225(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_14226","instance":14226,"id":200897,"goal":"lemma SeqReverseLen_14226(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_14227","instance":14227,"id":200898,"goal":"lemma SeqReverseIdem_14227(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_14228","instance":14228,"id":200899,"goal":"lemma SeqMapLen_14228(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_14229","instance":14229,"id":200900,"goal":"lemma SeqFilterLe_14229(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_14230","instance":14230,"id":200901,"goal":"lemma SeqMemberAppend_14230(xs: seq, u: seq)\n ensures x in xs + u <==> x in xs || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_14231","instance":14231,"id":200902,"goal":"lemma SeqAppendLen_14231(u: seq, xs: seq)\n ensures |u + xs| == |u| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_14232","instance":14232,"id":200903,"goal":"lemma SeqAppendNil_14232(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_14233","instance":14233,"id":200904,"goal":"lemma SeqNilAppend_14233(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_14234","instance":14234,"id":200905,"goal":"lemma SeqAppendAssoc_14234(t: seq, zs: seq, xs: seq)\n ensures (t + zs) + xs == t + (zs + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_14235","instance":14235,"id":200906,"goal":"lemma SeqTakeDrop_14235(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_14236","instance":14236,"id":200907,"goal":"lemma SeqReverseLen_14236(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_14237","instance":14237,"id":200908,"goal":"lemma SeqReverseIdem_14237(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_14238","instance":14238,"id":200909,"goal":"lemma SeqMapLen_14238(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_14239","instance":14239,"id":200910,"goal":"lemma SeqFilterLe_14239(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_14240","instance":14240,"id":200911,"goal":"lemma SeqMemberAppend_14240(s: seq, ys: seq)\n ensures x in s + ys <==> x in s || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_14241","instance":14241,"id":200912,"goal":"lemma SeqAppendLen_14241(ys: seq, xs: seq)\n ensures |ys + xs| == |ys| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_14242","instance":14242,"id":200913,"goal":"lemma SeqAppendNil_14242(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_14243","instance":14243,"id":200914,"goal":"lemma SeqNilAppend_14243(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_14244","instance":14244,"id":200915,"goal":"lemma SeqAppendAssoc_14244(ys: seq, zs: seq, s: seq)\n ensures (ys + zs) + s == ys + (zs + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_14245","instance":14245,"id":200916,"goal":"lemma SeqTakeDrop_14245(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_14246","instance":14246,"id":200917,"goal":"lemma SeqReverseLen_14246(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_14247","instance":14247,"id":200918,"goal":"lemma SeqReverseIdem_14247(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_14248","instance":14248,"id":200919,"goal":"lemma SeqMapLen_14248(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_14249","instance":14249,"id":200920,"goal":"lemma SeqFilterLe_14249(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_14250","instance":14250,"id":200921,"goal":"lemma SeqMemberAppend_14250(ys: seq, xs: seq)\n ensures x in ys + xs <==> x in ys || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_14251","instance":14251,"id":200922,"goal":"lemma SeqAppendLen_14251(s: seq, t: seq)\n ensures |s + t| == |s| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_14252","instance":14252,"id":200923,"goal":"lemma SeqAppendNil_14252(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_14253","instance":14253,"id":200924,"goal":"lemma SeqNilAppend_14253(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_14254","instance":14254,"id":200925,"goal":"lemma SeqAppendAssoc_14254(s: seq, ys: seq, zs: seq)\n ensures (s + ys) + zs == s + (ys + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_14255","instance":14255,"id":200926,"goal":"lemma SeqTakeDrop_14255(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_14256","instance":14256,"id":200927,"goal":"lemma SeqReverseLen_14256(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_14257","instance":14257,"id":200928,"goal":"lemma SeqReverseIdem_14257(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_14258","instance":14258,"id":200929,"goal":"lemma SeqMapLen_14258(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_14259","instance":14259,"id":200930,"goal":"lemma SeqFilterLe_14259(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_14260","instance":14260,"id":200931,"goal":"lemma SeqMemberAppend_14260(ys: seq, u: seq)\n ensures x in ys + u <==> x in ys || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_14261","instance":14261,"id":200932,"goal":"lemma SeqAppendLen_14261(s: seq, t: seq)\n ensures |s + t| == |s| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_14262","instance":14262,"id":200933,"goal":"lemma SeqAppendNil_14262(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_14263","instance":14263,"id":200934,"goal":"lemma SeqNilAppend_14263(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_14264","instance":14264,"id":200935,"goal":"lemma SeqAppendAssoc_14264(u: seq, zs: seq, xs: seq)\n ensures (u + zs) + xs == u + (zs + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_14265","instance":14265,"id":200936,"goal":"lemma SeqTakeDrop_14265(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_14266","instance":14266,"id":200937,"goal":"lemma SeqReverseLen_14266(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_14267","instance":14267,"id":200938,"goal":"lemma SeqReverseIdem_14267(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_14268","instance":14268,"id":200939,"goal":"lemma SeqMapLen_14268(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_14269","instance":14269,"id":200940,"goal":"lemma SeqFilterLe_14269(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_14270","instance":14270,"id":200941,"goal":"lemma SeqMemberAppend_14270(s: seq, u: seq)\n ensures x in s + u <==> x in s || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_14271","instance":14271,"id":200942,"goal":"lemma SeqAppendLen_14271(u: seq, zs: seq)\n ensures |u + zs| == |u| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_14272","instance":14272,"id":200943,"goal":"lemma SeqAppendNil_14272(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_14273","instance":14273,"id":200944,"goal":"lemma SeqNilAppend_14273(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_14274","instance":14274,"id":200945,"goal":"lemma SeqAppendAssoc_14274(s: seq, t: seq, xs: seq)\n ensures (s + t) + xs == s + (t + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_14275","instance":14275,"id":200946,"goal":"lemma SeqTakeDrop_14275(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_14276","instance":14276,"id":200947,"goal":"lemma SeqReverseLen_14276(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_14277","instance":14277,"id":200948,"goal":"lemma SeqReverseIdem_14277(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_14278","instance":14278,"id":200949,"goal":"lemma SeqMapLen_14278(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_14279","instance":14279,"id":200950,"goal":"lemma SeqFilterLe_14279(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_14280","instance":14280,"id":200951,"goal":"lemma SeqMemberAppend_14280(t: seq, s: seq)\n ensures x in t + s <==> x in t || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_14281","instance":14281,"id":200952,"goal":"lemma SeqAppendLen_14281(xs: seq, t: seq)\n ensures |xs + t| == |xs| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_14282","instance":14282,"id":200953,"goal":"lemma SeqAppendNil_14282(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_14283","instance":14283,"id":200954,"goal":"lemma SeqNilAppend_14283(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_14284","instance":14284,"id":200955,"goal":"lemma SeqAppendAssoc_14284(u: seq, ys: seq, zs: seq)\n ensures (u + ys) + zs == u + (ys + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_14285","instance":14285,"id":200956,"goal":"lemma SeqTakeDrop_14285(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_14286","instance":14286,"id":200957,"goal":"lemma SeqReverseLen_14286(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_14287","instance":14287,"id":200958,"goal":"lemma SeqReverseIdem_14287(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_14288","instance":14288,"id":200959,"goal":"lemma SeqMapLen_14288(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_14289","instance":14289,"id":200960,"goal":"lemma SeqFilterLe_14289(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_14290","instance":14290,"id":200961,"goal":"lemma SeqMemberAppend_14290(ys: seq, t: seq)\n ensures x in ys + t <==> x in ys || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_14291","instance":14291,"id":200962,"goal":"lemma SeqAppendLen_14291(t: seq, ys: seq)\n ensures |t + ys| == |t| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_14292","instance":14292,"id":200963,"goal":"lemma SeqAppendNil_14292(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_14293","instance":14293,"id":200964,"goal":"lemma SeqNilAppend_14293(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_14294","instance":14294,"id":200965,"goal":"lemma SeqAppendAssoc_14294(zs: seq, s: seq, t: seq)\n ensures (zs + s) + t == zs + (s + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_14295","instance":14295,"id":200966,"goal":"lemma SeqTakeDrop_14295(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_14296","instance":14296,"id":200967,"goal":"lemma SeqReverseLen_14296(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_14297","instance":14297,"id":200968,"goal":"lemma SeqReverseIdem_14297(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_14298","instance":14298,"id":200969,"goal":"lemma SeqMapLen_14298(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_14299","instance":14299,"id":200970,"goal":"lemma SeqFilterLe_14299(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_14300","instance":14300,"id":200971,"goal":"lemma SeqMemberAppend_14300(t: seq, xs: seq)\n ensures x in t + xs <==> x in t || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_14301","instance":14301,"id":200972,"goal":"lemma SeqAppendLen_14301(s: seq, u: seq)\n ensures |s + u| == |s| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_14302","instance":14302,"id":200973,"goal":"lemma SeqAppendNil_14302(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_14303","instance":14303,"id":200974,"goal":"lemma SeqNilAppend_14303(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_14304","instance":14304,"id":200975,"goal":"lemma SeqAppendAssoc_14304(t: seq, s: seq, ys: seq)\n ensures (t + s) + ys == t + (s + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_14305","instance":14305,"id":200976,"goal":"lemma SeqTakeDrop_14305(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_14306","instance":14306,"id":200977,"goal":"lemma SeqReverseLen_14306(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_14307","instance":14307,"id":200978,"goal":"lemma SeqReverseIdem_14307(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_14308","instance":14308,"id":200979,"goal":"lemma SeqMapLen_14308(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_14309","instance":14309,"id":200980,"goal":"lemma SeqFilterLe_14309(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_14310","instance":14310,"id":200981,"goal":"lemma SeqMemberAppend_14310(zs: seq, u: seq)\n ensures x in zs + u <==> x in zs || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_14311","instance":14311,"id":200982,"goal":"lemma SeqAppendLen_14311(u: seq, ys: seq)\n ensures |u + ys| == |u| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_14312","instance":14312,"id":200983,"goal":"lemma SeqAppendNil_14312(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_14313","instance":14313,"id":200984,"goal":"lemma SeqNilAppend_14313(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_14314","instance":14314,"id":200985,"goal":"lemma SeqAppendAssoc_14314(u: seq, ys: seq, s: seq)\n ensures (u + ys) + s == u + (ys + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_14315","instance":14315,"id":200986,"goal":"lemma SeqTakeDrop_14315(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_14316","instance":14316,"id":200987,"goal":"lemma SeqReverseLen_14316(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_14317","instance":14317,"id":200988,"goal":"lemma SeqReverseIdem_14317(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_14318","instance":14318,"id":200989,"goal":"lemma SeqMapLen_14318(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_14319","instance":14319,"id":200990,"goal":"lemma SeqFilterLe_14319(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_14320","instance":14320,"id":200991,"goal":"lemma SeqMemberAppend_14320(u: seq, xs: seq)\n ensures x in u + xs <==> x in u || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_14321","instance":14321,"id":200992,"goal":"lemma SeqAppendLen_14321(ys: seq, u: seq)\n ensures |ys + u| == |ys| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_14322","instance":14322,"id":200993,"goal":"lemma SeqAppendNil_14322(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_14323","instance":14323,"id":200994,"goal":"lemma SeqNilAppend_14323(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_14324","instance":14324,"id":200995,"goal":"lemma SeqAppendAssoc_14324(s: seq, zs: seq, ys: seq)\n ensures (s + zs) + ys == s + (zs + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_14325","instance":14325,"id":200996,"goal":"lemma SeqTakeDrop_14325(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_14326","instance":14326,"id":200997,"goal":"lemma SeqReverseLen_14326(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_14327","instance":14327,"id":200998,"goal":"lemma SeqReverseIdem_14327(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_14328","instance":14328,"id":200999,"goal":"lemma SeqMapLen_14328(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_14329","instance":14329,"id":201000,"goal":"lemma SeqFilterLe_14329(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_14330","instance":14330,"id":201001,"goal":"lemma SeqMemberAppend_14330(s: seq, t: seq)\n ensures x in s + t <==> x in s || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_14331","instance":14331,"id":201002,"goal":"lemma SeqAppendLen_14331(t: seq, ys: seq)\n ensures |t + ys| == |t| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_14332","instance":14332,"id":201003,"goal":"lemma SeqAppendNil_14332(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_14333","instance":14333,"id":201004,"goal":"lemma SeqNilAppend_14333(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_14334","instance":14334,"id":201005,"goal":"lemma SeqAppendAssoc_14334(zs: seq, u: seq, ys: seq)\n ensures (zs + u) + ys == zs + (u + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_14335","instance":14335,"id":201006,"goal":"lemma SeqTakeDrop_14335(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_14336","instance":14336,"id":201007,"goal":"lemma SeqReverseLen_14336(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_14337","instance":14337,"id":201008,"goal":"lemma SeqReverseIdem_14337(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_14338","instance":14338,"id":201009,"goal":"lemma SeqMapLen_14338(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_14339","instance":14339,"id":201010,"goal":"lemma SeqFilterLe_14339(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_14340","instance":14340,"id":201011,"goal":"lemma SeqMemberAppend_14340(xs: seq, ys: seq)\n ensures x in xs + ys <==> x in xs || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_14341","instance":14341,"id":201012,"goal":"lemma SeqAppendLen_14341(ys: seq, xs: seq)\n ensures |ys + xs| == |ys| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_14342","instance":14342,"id":201013,"goal":"lemma SeqAppendNil_14342(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_14343","instance":14343,"id":201014,"goal":"lemma SeqNilAppend_14343(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_14344","instance":14344,"id":201015,"goal":"lemma SeqAppendAssoc_14344(xs: seq, u: seq, s: seq)\n ensures (xs + u) + s == xs + (u + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_14345","instance":14345,"id":201016,"goal":"lemma SeqTakeDrop_14345(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_14346","instance":14346,"id":201017,"goal":"lemma SeqReverseLen_14346(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_14347","instance":14347,"id":201018,"goal":"lemma SeqReverseIdem_14347(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_14348","instance":14348,"id":201019,"goal":"lemma SeqMapLen_14348(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_14349","instance":14349,"id":201020,"goal":"lemma SeqFilterLe_14349(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_14350","instance":14350,"id":201021,"goal":"lemma SeqMemberAppend_14350(ys: seq, u: seq)\n ensures x in ys + u <==> x in ys || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_14351","instance":14351,"id":201022,"goal":"lemma SeqAppendLen_14351(xs: seq, zs: seq)\n ensures |xs + zs| == |xs| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_14352","instance":14352,"id":201023,"goal":"lemma SeqAppendNil_14352(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_14353","instance":14353,"id":201024,"goal":"lemma SeqNilAppend_14353(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_14354","instance":14354,"id":201025,"goal":"lemma SeqAppendAssoc_14354(zs: seq, s: seq, ys: seq)\n ensures (zs + s) + ys == zs + (s + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_14355","instance":14355,"id":201026,"goal":"lemma SeqTakeDrop_14355(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_14356","instance":14356,"id":201027,"goal":"lemma SeqReverseLen_14356(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_14357","instance":14357,"id":201028,"goal":"lemma SeqReverseIdem_14357(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_14358","instance":14358,"id":201029,"goal":"lemma SeqMapLen_14358(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_14359","instance":14359,"id":201030,"goal":"lemma SeqFilterLe_14359(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_14360","instance":14360,"id":201031,"goal":"lemma SeqMemberAppend_14360(t: seq, xs: seq)\n ensures x in t + xs <==> x in t || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_14361","instance":14361,"id":201032,"goal":"lemma SeqAppendLen_14361(zs: seq, xs: seq)\n ensures |zs + xs| == |zs| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_14362","instance":14362,"id":201033,"goal":"lemma SeqAppendNil_14362(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_14363","instance":14363,"id":201034,"goal":"lemma SeqNilAppend_14363(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_14364","instance":14364,"id":201035,"goal":"lemma SeqAppendAssoc_14364(s: seq, xs: seq, ys: seq)\n ensures (s + xs) + ys == s + (xs + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_14365","instance":14365,"id":201036,"goal":"lemma SeqTakeDrop_14365(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_14366","instance":14366,"id":201037,"goal":"lemma SeqReverseLen_14366(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_14367","instance":14367,"id":201038,"goal":"lemma SeqReverseIdem_14367(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_14368","instance":14368,"id":201039,"goal":"lemma SeqMapLen_14368(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_14369","instance":14369,"id":201040,"goal":"lemma SeqFilterLe_14369(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_14370","instance":14370,"id":201041,"goal":"lemma SeqMemberAppend_14370(ys: seq, xs: seq)\n ensures x in ys + xs <==> x in ys || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_14371","instance":14371,"id":201042,"goal":"lemma SeqAppendLen_14371(zs: seq, ys: seq)\n ensures |zs + ys| == |zs| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_14372","instance":14372,"id":201043,"goal":"lemma SeqAppendNil_14372(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_14373","instance":14373,"id":201044,"goal":"lemma SeqNilAppend_14373(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_14374","instance":14374,"id":201045,"goal":"lemma SeqAppendAssoc_14374(zs: seq, xs: seq, s: seq)\n ensures (zs + xs) + s == zs + (xs + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_14375","instance":14375,"id":201046,"goal":"lemma SeqTakeDrop_14375(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_14376","instance":14376,"id":201047,"goal":"lemma SeqReverseLen_14376(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_14377","instance":14377,"id":201048,"goal":"lemma SeqReverseIdem_14377(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_14378","instance":14378,"id":201049,"goal":"lemma SeqMapLen_14378(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_14379","instance":14379,"id":201050,"goal":"lemma SeqFilterLe_14379(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_14380","instance":14380,"id":201051,"goal":"lemma SeqMemberAppend_14380(xs: seq, zs: seq)\n ensures x in xs + zs <==> x in xs || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_14381","instance":14381,"id":201052,"goal":"lemma SeqAppendLen_14381(ys: seq, xs: seq)\n ensures |ys + xs| == |ys| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_14382","instance":14382,"id":201053,"goal":"lemma SeqAppendNil_14382(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_14383","instance":14383,"id":201054,"goal":"lemma SeqNilAppend_14383(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_14384","instance":14384,"id":201055,"goal":"lemma SeqAppendAssoc_14384(t: seq, xs: seq, s: seq)\n ensures (t + xs) + s == t + (xs + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_14385","instance":14385,"id":201056,"goal":"lemma SeqTakeDrop_14385(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_14386","instance":14386,"id":201057,"goal":"lemma SeqReverseLen_14386(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_14387","instance":14387,"id":201058,"goal":"lemma SeqReverseIdem_14387(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_14388","instance":14388,"id":201059,"goal":"lemma SeqMapLen_14388(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_14389","instance":14389,"id":201060,"goal":"lemma SeqFilterLe_14389(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_14390","instance":14390,"id":201061,"goal":"lemma SeqMemberAppend_14390(u: seq, zs: seq)\n ensures x in u + zs <==> x in u || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_14391","instance":14391,"id":201062,"goal":"lemma SeqAppendLen_14391(ys: seq, s: seq)\n ensures |ys + s| == |ys| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_14392","instance":14392,"id":201063,"goal":"lemma SeqAppendNil_14392(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_14393","instance":14393,"id":201064,"goal":"lemma SeqNilAppend_14393(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_14394","instance":14394,"id":201065,"goal":"lemma SeqAppendAssoc_14394(t: seq, u: seq, s: seq)\n ensures (t + u) + s == t + (u + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_14395","instance":14395,"id":201066,"goal":"lemma SeqTakeDrop_14395(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_14396","instance":14396,"id":201067,"goal":"lemma SeqReverseLen_14396(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_14397","instance":14397,"id":201068,"goal":"lemma SeqReverseIdem_14397(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_14398","instance":14398,"id":201069,"goal":"lemma SeqMapLen_14398(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_14399","instance":14399,"id":201070,"goal":"lemma SeqFilterLe_14399(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_14400","instance":14400,"id":201071,"goal":"lemma SeqMemberAppend_14400(u: seq, s: seq)\n ensures x in u + s <==> x in u || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_14401","instance":14401,"id":201072,"goal":"lemma SeqAppendLen_14401(xs: seq, zs: seq)\n ensures |xs + zs| == |xs| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_14402","instance":14402,"id":201073,"goal":"lemma SeqAppendNil_14402(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_14403","instance":14403,"id":201074,"goal":"lemma SeqNilAppend_14403(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_14404","instance":14404,"id":201075,"goal":"lemma SeqAppendAssoc_14404(u: seq, xs: seq, zs: seq)\n ensures (u + xs) + zs == u + (xs + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_14405","instance":14405,"id":201076,"goal":"lemma SeqTakeDrop_14405(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_14406","instance":14406,"id":201077,"goal":"lemma SeqReverseLen_14406(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_14407","instance":14407,"id":201078,"goal":"lemma SeqReverseIdem_14407(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_14408","instance":14408,"id":201079,"goal":"lemma SeqMapLen_14408(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_14409","instance":14409,"id":201080,"goal":"lemma SeqFilterLe_14409(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_14410","instance":14410,"id":201081,"goal":"lemma SeqMemberAppend_14410(t: seq, xs: seq)\n ensures x in t + xs <==> x in t || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_14411","instance":14411,"id":201082,"goal":"lemma SeqAppendLen_14411(xs: seq, t: seq)\n ensures |xs + t| == |xs| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_14412","instance":14412,"id":201083,"goal":"lemma SeqAppendNil_14412(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_14413","instance":14413,"id":201084,"goal":"lemma SeqNilAppend_14413(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_14414","instance":14414,"id":201085,"goal":"lemma SeqAppendAssoc_14414(xs: seq, t: seq, s: seq)\n ensures (xs + t) + s == xs + (t + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_14415","instance":14415,"id":201086,"goal":"lemma SeqTakeDrop_14415(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_14416","instance":14416,"id":201087,"goal":"lemma SeqReverseLen_14416(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_14417","instance":14417,"id":201088,"goal":"lemma SeqReverseIdem_14417(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_14418","instance":14418,"id":201089,"goal":"lemma SeqMapLen_14418(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_14419","instance":14419,"id":201090,"goal":"lemma SeqFilterLe_14419(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_14420","instance":14420,"id":201091,"goal":"lemma SeqMemberAppend_14420(u: seq, zs: seq)\n ensures x in u + zs <==> x in u || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_14421","instance":14421,"id":201092,"goal":"lemma SeqAppendLen_14421(s: seq, ys: seq)\n ensures |s + ys| == |s| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_14422","instance":14422,"id":201093,"goal":"lemma SeqAppendNil_14422(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_14423","instance":14423,"id":201094,"goal":"lemma SeqNilAppend_14423(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_14424","instance":14424,"id":201095,"goal":"lemma SeqAppendAssoc_14424(zs: seq, xs: seq, s: seq)\n ensures (zs + xs) + s == zs + (xs + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_14425","instance":14425,"id":201096,"goal":"lemma SeqTakeDrop_14425(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_14426","instance":14426,"id":201097,"goal":"lemma SeqReverseLen_14426(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_14427","instance":14427,"id":201098,"goal":"lemma SeqReverseIdem_14427(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_14428","instance":14428,"id":201099,"goal":"lemma SeqMapLen_14428(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_14429","instance":14429,"id":201100,"goal":"lemma SeqFilterLe_14429(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_14430","instance":14430,"id":201101,"goal":"lemma SeqMemberAppend_14430(u: seq, xs: seq)\n ensures x in u + xs <==> x in u || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_14431","instance":14431,"id":201102,"goal":"lemma SeqAppendLen_14431(zs: seq, s: seq)\n ensures |zs + s| == |zs| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_14432","instance":14432,"id":201103,"goal":"lemma SeqAppendNil_14432(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_14433","instance":14433,"id":201104,"goal":"lemma SeqNilAppend_14433(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_14434","instance":14434,"id":201105,"goal":"lemma SeqAppendAssoc_14434(zs: seq, ys: seq, xs: seq)\n ensures (zs + ys) + xs == zs + (ys + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_14435","instance":14435,"id":201106,"goal":"lemma SeqTakeDrop_14435(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_14436","instance":14436,"id":201107,"goal":"lemma SeqReverseLen_14436(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_14437","instance":14437,"id":201108,"goal":"lemma SeqReverseIdem_14437(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_14438","instance":14438,"id":201109,"goal":"lemma SeqMapLen_14438(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_14439","instance":14439,"id":201110,"goal":"lemma SeqFilterLe_14439(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_14440","instance":14440,"id":201111,"goal":"lemma SeqMemberAppend_14440(s: seq, t: seq)\n ensures x in s + t <==> x in s || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_14441","instance":14441,"id":201112,"goal":"lemma SeqAppendLen_14441(u: seq, ys: seq)\n ensures |u + ys| == |u| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_14442","instance":14442,"id":201113,"goal":"lemma SeqAppendNil_14442(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_14443","instance":14443,"id":201114,"goal":"lemma SeqNilAppend_14443(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_14444","instance":14444,"id":201115,"goal":"lemma SeqAppendAssoc_14444(s: seq, xs: seq, u: seq)\n ensures (s + xs) + u == s + (xs + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_14445","instance":14445,"id":201116,"goal":"lemma SeqTakeDrop_14445(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_14446","instance":14446,"id":201117,"goal":"lemma SeqReverseLen_14446(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_14447","instance":14447,"id":201118,"goal":"lemma SeqReverseIdem_14447(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_14448","instance":14448,"id":201119,"goal":"lemma SeqMapLen_14448(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_14449","instance":14449,"id":201120,"goal":"lemma SeqFilterLe_14449(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_14450","instance":14450,"id":201121,"goal":"lemma SeqMemberAppend_14450(xs: seq, ys: seq)\n ensures x in xs + ys <==> x in xs || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_14451","instance":14451,"id":201122,"goal":"lemma SeqAppendLen_14451(t: seq, s: seq)\n ensures |t + s| == |t| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_14452","instance":14452,"id":201123,"goal":"lemma SeqAppendNil_14452(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_14453","instance":14453,"id":201124,"goal":"lemma SeqNilAppend_14453(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_14454","instance":14454,"id":201125,"goal":"lemma SeqAppendAssoc_14454(t: seq, u: seq, s: seq)\n ensures (t + u) + s == t + (u + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_14455","instance":14455,"id":201126,"goal":"lemma SeqTakeDrop_14455(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_14456","instance":14456,"id":201127,"goal":"lemma SeqReverseLen_14456(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_14457","instance":14457,"id":201128,"goal":"lemma SeqReverseIdem_14457(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_14458","instance":14458,"id":201129,"goal":"lemma SeqMapLen_14458(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_14459","instance":14459,"id":201130,"goal":"lemma SeqFilterLe_14459(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_14460","instance":14460,"id":201131,"goal":"lemma SeqMemberAppend_14460(zs: seq, xs: seq)\n ensures x in zs + xs <==> x in zs || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_14461","instance":14461,"id":201132,"goal":"lemma SeqAppendLen_14461(u: seq, s: seq)\n ensures |u + s| == |u| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_14462","instance":14462,"id":201133,"goal":"lemma SeqAppendNil_14462(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_14463","instance":14463,"id":201134,"goal":"lemma SeqNilAppend_14463(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_14464","instance":14464,"id":201135,"goal":"lemma SeqAppendAssoc_14464(ys: seq, s: seq, u: seq)\n ensures (ys + s) + u == ys + (s + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_14465","instance":14465,"id":201136,"goal":"lemma SeqTakeDrop_14465(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_14466","instance":14466,"id":201137,"goal":"lemma SeqReverseLen_14466(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_14467","instance":14467,"id":201138,"goal":"lemma SeqReverseIdem_14467(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_14468","instance":14468,"id":201139,"goal":"lemma SeqMapLen_14468(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_14469","instance":14469,"id":201140,"goal":"lemma SeqFilterLe_14469(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_14470","instance":14470,"id":201141,"goal":"lemma SeqMemberAppend_14470(s: seq, t: seq)\n ensures x in s + t <==> x in s || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_14471","instance":14471,"id":201142,"goal":"lemma SeqAppendLen_14471(t: seq, ys: seq)\n ensures |t + ys| == |t| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_14472","instance":14472,"id":201143,"goal":"lemma SeqAppendNil_14472(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_14473","instance":14473,"id":201144,"goal":"lemma SeqNilAppend_14473(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_14474","instance":14474,"id":201145,"goal":"lemma SeqAppendAssoc_14474(ys: seq, u: seq, t: seq)\n ensures (ys + u) + t == ys + (u + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_14475","instance":14475,"id":201146,"goal":"lemma SeqTakeDrop_14475(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_14476","instance":14476,"id":201147,"goal":"lemma SeqReverseLen_14476(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_14477","instance":14477,"id":201148,"goal":"lemma SeqReverseIdem_14477(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_14478","instance":14478,"id":201149,"goal":"lemma SeqMapLen_14478(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_14479","instance":14479,"id":201150,"goal":"lemma SeqFilterLe_14479(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_14480","instance":14480,"id":201151,"goal":"lemma SeqMemberAppend_14480(ys: seq, u: seq)\n ensures x in ys + u <==> x in ys || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_14481","instance":14481,"id":201152,"goal":"lemma SeqAppendLen_14481(ys: seq, s: seq)\n ensures |ys + s| == |ys| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_14482","instance":14482,"id":201153,"goal":"lemma SeqAppendNil_14482(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_14483","instance":14483,"id":201154,"goal":"lemma SeqNilAppend_14483(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_14484","instance":14484,"id":201155,"goal":"lemma SeqAppendAssoc_14484(t: seq, s: seq, zs: seq)\n ensures (t + s) + zs == t + (s + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_14485","instance":14485,"id":201156,"goal":"lemma SeqTakeDrop_14485(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_14486","instance":14486,"id":201157,"goal":"lemma SeqReverseLen_14486(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_14487","instance":14487,"id":201158,"goal":"lemma SeqReverseIdem_14487(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_14488","instance":14488,"id":201159,"goal":"lemma SeqMapLen_14488(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_14489","instance":14489,"id":201160,"goal":"lemma SeqFilterLe_14489(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_14490","instance":14490,"id":201161,"goal":"lemma SeqMemberAppend_14490(ys: seq, xs: seq)\n ensures x in ys + xs <==> x in ys || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_14491","instance":14491,"id":201162,"goal":"lemma SeqAppendLen_14491(xs: seq, ys: seq)\n ensures |xs + ys| == |xs| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_14492","instance":14492,"id":201163,"goal":"lemma SeqAppendNil_14492(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_14493","instance":14493,"id":201164,"goal":"lemma SeqNilAppend_14493(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_14494","instance":14494,"id":201165,"goal":"lemma SeqAppendAssoc_14494(xs: seq, t: seq, u: seq)\n ensures (xs + t) + u == xs + (t + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_14495","instance":14495,"id":201166,"goal":"lemma SeqTakeDrop_14495(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_14496","instance":14496,"id":201167,"goal":"lemma SeqReverseLen_14496(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_14497","instance":14497,"id":201168,"goal":"lemma SeqReverseIdem_14497(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_14498","instance":14498,"id":201169,"goal":"lemma SeqMapLen_14498(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_14499","instance":14499,"id":201170,"goal":"lemma SeqFilterLe_14499(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_14500","instance":14500,"id":201171,"goal":"lemma SeqMemberAppend_14500(zs: seq, xs: seq)\n ensures x in zs + xs <==> x in zs || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_14501","instance":14501,"id":201172,"goal":"lemma SeqAppendLen_14501(xs: seq, s: seq)\n ensures |xs + s| == |xs| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_14502","instance":14502,"id":201173,"goal":"lemma SeqAppendNil_14502(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_14503","instance":14503,"id":201174,"goal":"lemma SeqNilAppend_14503(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_14504","instance":14504,"id":201175,"goal":"lemma SeqAppendAssoc_14504(xs: seq, ys: seq, zs: seq)\n ensures (xs + ys) + zs == xs + (ys + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_14505","instance":14505,"id":201176,"goal":"lemma SeqTakeDrop_14505(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_14506","instance":14506,"id":201177,"goal":"lemma SeqReverseLen_14506(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_14507","instance":14507,"id":201178,"goal":"lemma SeqReverseIdem_14507(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_14508","instance":14508,"id":201179,"goal":"lemma SeqMapLen_14508(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_14509","instance":14509,"id":201180,"goal":"lemma SeqFilterLe_14509(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_14510","instance":14510,"id":201181,"goal":"lemma SeqMemberAppend_14510(t: seq, xs: seq)\n ensures x in t + xs <==> x in t || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_14511","instance":14511,"id":201182,"goal":"lemma SeqAppendLen_14511(xs: seq, s: seq)\n ensures |xs + s| == |xs| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_14512","instance":14512,"id":201183,"goal":"lemma SeqAppendNil_14512(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_14513","instance":14513,"id":201184,"goal":"lemma SeqNilAppend_14513(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_14514","instance":14514,"id":201185,"goal":"lemma SeqAppendAssoc_14514(u: seq, ys: seq, t: seq)\n ensures (u + ys) + t == u + (ys + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_14515","instance":14515,"id":201186,"goal":"lemma SeqTakeDrop_14515(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_14516","instance":14516,"id":201187,"goal":"lemma SeqReverseLen_14516(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_14517","instance":14517,"id":201188,"goal":"lemma SeqReverseIdem_14517(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_14518","instance":14518,"id":201189,"goal":"lemma SeqMapLen_14518(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_14519","instance":14519,"id":201190,"goal":"lemma SeqFilterLe_14519(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_14520","instance":14520,"id":201191,"goal":"lemma SeqMemberAppend_14520(xs: seq, t: seq)\n ensures x in xs + t <==> x in xs || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_14521","instance":14521,"id":201192,"goal":"lemma SeqAppendLen_14521(xs: seq, zs: seq)\n ensures |xs + zs| == |xs| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_14522","instance":14522,"id":201193,"goal":"lemma SeqAppendNil_14522(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_14523","instance":14523,"id":201194,"goal":"lemma SeqNilAppend_14523(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_14524","instance":14524,"id":201195,"goal":"lemma SeqAppendAssoc_14524(xs: seq, t: seq, zs: seq)\n ensures (xs + t) + zs == xs + (t + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_14525","instance":14525,"id":201196,"goal":"lemma SeqTakeDrop_14525(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_14526","instance":14526,"id":201197,"goal":"lemma SeqReverseLen_14526(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_14527","instance":14527,"id":201198,"goal":"lemma SeqReverseIdem_14527(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_14528","instance":14528,"id":201199,"goal":"lemma SeqMapLen_14528(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_14529","instance":14529,"id":201200,"goal":"lemma SeqFilterLe_14529(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_14530","instance":14530,"id":201201,"goal":"lemma SeqMemberAppend_14530(t: seq, u: seq)\n ensures x in t + u <==> x in t || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_14531","instance":14531,"id":201202,"goal":"lemma SeqAppendLen_14531(ys: seq, u: seq)\n ensures |ys + u| == |ys| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_14532","instance":14532,"id":201203,"goal":"lemma SeqAppendNil_14532(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_14533","instance":14533,"id":201204,"goal":"lemma SeqNilAppend_14533(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_14534","instance":14534,"id":201205,"goal":"lemma SeqAppendAssoc_14534(xs: seq, s: seq, u: seq)\n ensures (xs + s) + u == xs + (s + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_14535","instance":14535,"id":201206,"goal":"lemma SeqTakeDrop_14535(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_14536","instance":14536,"id":201207,"goal":"lemma SeqReverseLen_14536(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_14537","instance":14537,"id":201208,"goal":"lemma SeqReverseIdem_14537(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_14538","instance":14538,"id":201209,"goal":"lemma SeqMapLen_14538(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_14539","instance":14539,"id":201210,"goal":"lemma SeqFilterLe_14539(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_14540","instance":14540,"id":201211,"goal":"lemma SeqMemberAppend_14540(t: seq, xs: seq)\n ensures x in t + xs <==> x in t || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_14541","instance":14541,"id":201212,"goal":"lemma SeqAppendLen_14541(u: seq, s: seq)\n ensures |u + s| == |u| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_14542","instance":14542,"id":201213,"goal":"lemma SeqAppendNil_14542(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_14543","instance":14543,"id":201214,"goal":"lemma SeqNilAppend_14543(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_14544","instance":14544,"id":201215,"goal":"lemma SeqAppendAssoc_14544(xs: seq, zs: seq, u: seq)\n ensures (xs + zs) + u == xs + (zs + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_14545","instance":14545,"id":201216,"goal":"lemma SeqTakeDrop_14545(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_14546","instance":14546,"id":201217,"goal":"lemma SeqReverseLen_14546(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_14547","instance":14547,"id":201218,"goal":"lemma SeqReverseIdem_14547(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_14548","instance":14548,"id":201219,"goal":"lemma SeqMapLen_14548(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_14549","instance":14549,"id":201220,"goal":"lemma SeqFilterLe_14549(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_14550","instance":14550,"id":201221,"goal":"lemma SeqMemberAppend_14550(t: seq, zs: seq)\n ensures x in t + zs <==> x in t || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_14551","instance":14551,"id":201222,"goal":"lemma SeqAppendLen_14551(zs: seq, s: seq)\n ensures |zs + s| == |zs| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_14552","instance":14552,"id":201223,"goal":"lemma SeqAppendNil_14552(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_14553","instance":14553,"id":201224,"goal":"lemma SeqNilAppend_14553(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_14554","instance":14554,"id":201225,"goal":"lemma SeqAppendAssoc_14554(t: seq, zs: seq, s: seq)\n ensures (t + zs) + s == t + (zs + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_14555","instance":14555,"id":201226,"goal":"lemma SeqTakeDrop_14555(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_14556","instance":14556,"id":201227,"goal":"lemma SeqReverseLen_14556(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_14557","instance":14557,"id":201228,"goal":"lemma SeqReverseIdem_14557(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_14558","instance":14558,"id":201229,"goal":"lemma SeqMapLen_14558(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_14559","instance":14559,"id":201230,"goal":"lemma SeqFilterLe_14559(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_14560","instance":14560,"id":201231,"goal":"lemma SeqMemberAppend_14560(zs: seq, s: seq)\n ensures x in zs + s <==> x in zs || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_14561","instance":14561,"id":201232,"goal":"lemma SeqAppendLen_14561(t: seq, ys: seq)\n ensures |t + ys| == |t| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_14562","instance":14562,"id":201233,"goal":"lemma SeqAppendNil_14562(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_14563","instance":14563,"id":201234,"goal":"lemma SeqNilAppend_14563(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_14564","instance":14564,"id":201235,"goal":"lemma SeqAppendAssoc_14564(t: seq, s: seq, u: seq)\n ensures (t + s) + u == t + (s + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_14565","instance":14565,"id":201236,"goal":"lemma SeqTakeDrop_14565(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_14566","instance":14566,"id":201237,"goal":"lemma SeqReverseLen_14566(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_14567","instance":14567,"id":201238,"goal":"lemma SeqReverseIdem_14567(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_14568","instance":14568,"id":201239,"goal":"lemma SeqMapLen_14568(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_14569","instance":14569,"id":201240,"goal":"lemma SeqFilterLe_14569(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_14570","instance":14570,"id":201241,"goal":"lemma SeqMemberAppend_14570(xs: seq, ys: seq)\n ensures x in xs + ys <==> x in xs || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_14571","instance":14571,"id":201242,"goal":"lemma SeqAppendLen_14571(s: seq, xs: seq)\n ensures |s + xs| == |s| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_14572","instance":14572,"id":201243,"goal":"lemma SeqAppendNil_14572(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_14573","instance":14573,"id":201244,"goal":"lemma SeqNilAppend_14573(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_14574","instance":14574,"id":201245,"goal":"lemma SeqAppendAssoc_14574(ys: seq, u: seq, zs: seq)\n ensures (ys + u) + zs == ys + (u + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_14575","instance":14575,"id":201246,"goal":"lemma SeqTakeDrop_14575(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_14576","instance":14576,"id":201247,"goal":"lemma SeqReverseLen_14576(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_14577","instance":14577,"id":201248,"goal":"lemma SeqReverseIdem_14577(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_14578","instance":14578,"id":201249,"goal":"lemma SeqMapLen_14578(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_14579","instance":14579,"id":201250,"goal":"lemma SeqFilterLe_14579(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_14580","instance":14580,"id":201251,"goal":"lemma SeqMemberAppend_14580(u: seq, zs: seq)\n ensures x in u + zs <==> x in u || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_14581","instance":14581,"id":201252,"goal":"lemma SeqAppendLen_14581(s: seq, t: seq)\n ensures |s + t| == |s| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_14582","instance":14582,"id":201253,"goal":"lemma SeqAppendNil_14582(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_14583","instance":14583,"id":201254,"goal":"lemma SeqNilAppend_14583(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_14584","instance":14584,"id":201255,"goal":"lemma SeqAppendAssoc_14584(xs: seq, u: seq, t: seq)\n ensures (xs + u) + t == xs + (u + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_14585","instance":14585,"id":201256,"goal":"lemma SeqTakeDrop_14585(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_14586","instance":14586,"id":201257,"goal":"lemma SeqReverseLen_14586(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_14587","instance":14587,"id":201258,"goal":"lemma SeqReverseIdem_14587(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_14588","instance":14588,"id":201259,"goal":"lemma SeqMapLen_14588(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_14589","instance":14589,"id":201260,"goal":"lemma SeqFilterLe_14589(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_14590","instance":14590,"id":201261,"goal":"lemma SeqMemberAppend_14590(xs: seq, zs: seq)\n ensures x in xs + zs <==> x in xs || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_14591","instance":14591,"id":201262,"goal":"lemma SeqAppendLen_14591(xs: seq, ys: seq)\n ensures |xs + ys| == |xs| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_14592","instance":14592,"id":201263,"goal":"lemma SeqAppendNil_14592(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_14593","instance":14593,"id":201264,"goal":"lemma SeqNilAppend_14593(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_14594","instance":14594,"id":201265,"goal":"lemma SeqAppendAssoc_14594(t: seq, s: seq, ys: seq)\n ensures (t + s) + ys == t + (s + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_14595","instance":14595,"id":201266,"goal":"lemma SeqTakeDrop_14595(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_14596","instance":14596,"id":201267,"goal":"lemma SeqReverseLen_14596(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_14597","instance":14597,"id":201268,"goal":"lemma SeqReverseIdem_14597(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_14598","instance":14598,"id":201269,"goal":"lemma SeqMapLen_14598(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_14599","instance":14599,"id":201270,"goal":"lemma SeqFilterLe_14599(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_14600","instance":14600,"id":201271,"goal":"lemma SeqMemberAppend_14600(zs: seq, u: seq)\n ensures x in zs + u <==> x in zs || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_14601","instance":14601,"id":201272,"goal":"lemma SeqAppendLen_14601(xs: seq, t: seq)\n ensures |xs + t| == |xs| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_14602","instance":14602,"id":201273,"goal":"lemma SeqAppendNil_14602(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_14603","instance":14603,"id":201274,"goal":"lemma SeqNilAppend_14603(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_14604","instance":14604,"id":201275,"goal":"lemma SeqAppendAssoc_14604(xs: seq, u: seq, zs: seq)\n ensures (xs + u) + zs == xs + (u + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_14605","instance":14605,"id":201276,"goal":"lemma SeqTakeDrop_14605(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_14606","instance":14606,"id":201277,"goal":"lemma SeqReverseLen_14606(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_14607","instance":14607,"id":201278,"goal":"lemma SeqReverseIdem_14607(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_14608","instance":14608,"id":201279,"goal":"lemma SeqMapLen_14608(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_14609","instance":14609,"id":201280,"goal":"lemma SeqFilterLe_14609(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_14610","instance":14610,"id":201281,"goal":"lemma SeqMemberAppend_14610(s: seq, t: seq)\n ensures x in s + t <==> x in s || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_14611","instance":14611,"id":201282,"goal":"lemma SeqAppendLen_14611(zs: seq, ys: seq)\n ensures |zs + ys| == |zs| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_14612","instance":14612,"id":201283,"goal":"lemma SeqAppendNil_14612(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_14613","instance":14613,"id":201284,"goal":"lemma SeqNilAppend_14613(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_14614","instance":14614,"id":201285,"goal":"lemma SeqAppendAssoc_14614(xs: seq, zs: seq, t: seq)\n ensures (xs + zs) + t == xs + (zs + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_14615","instance":14615,"id":201286,"goal":"lemma SeqTakeDrop_14615(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_14616","instance":14616,"id":201287,"goal":"lemma SeqReverseLen_14616(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_14617","instance":14617,"id":201288,"goal":"lemma SeqReverseIdem_14617(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_14618","instance":14618,"id":201289,"goal":"lemma SeqMapLen_14618(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_14619","instance":14619,"id":201290,"goal":"lemma SeqFilterLe_14619(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_14620","instance":14620,"id":201291,"goal":"lemma SeqMemberAppend_14620(u: seq, zs: seq)\n ensures x in u + zs <==> x in u || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_14621","instance":14621,"id":201292,"goal":"lemma SeqAppendLen_14621(s: seq, xs: seq)\n ensures |s + xs| == |s| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_14622","instance":14622,"id":201293,"goal":"lemma SeqAppendNil_14622(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_14623","instance":14623,"id":201294,"goal":"lemma SeqNilAppend_14623(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_14624","instance":14624,"id":201295,"goal":"lemma SeqAppendAssoc_14624(u: seq, xs: seq, ys: seq)\n ensures (u + xs) + ys == u + (xs + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_14625","instance":14625,"id":201296,"goal":"lemma SeqTakeDrop_14625(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_14626","instance":14626,"id":201297,"goal":"lemma SeqReverseLen_14626(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_14627","instance":14627,"id":201298,"goal":"lemma SeqReverseIdem_14627(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_14628","instance":14628,"id":201299,"goal":"lemma SeqMapLen_14628(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_14629","instance":14629,"id":201300,"goal":"lemma SeqFilterLe_14629(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_14630","instance":14630,"id":201301,"goal":"lemma SeqMemberAppend_14630(u: seq, xs: seq)\n ensures x in u + xs <==> x in u || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_14631","instance":14631,"id":201302,"goal":"lemma SeqAppendLen_14631(u: seq, xs: seq)\n ensures |u + xs| == |u| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_14632","instance":14632,"id":201303,"goal":"lemma SeqAppendNil_14632(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_14633","instance":14633,"id":201304,"goal":"lemma SeqNilAppend_14633(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_14634","instance":14634,"id":201305,"goal":"lemma SeqAppendAssoc_14634(xs: seq, zs: seq, s: seq)\n ensures (xs + zs) + s == xs + (zs + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_14635","instance":14635,"id":201306,"goal":"lemma SeqTakeDrop_14635(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_14636","instance":14636,"id":201307,"goal":"lemma SeqReverseLen_14636(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_14637","instance":14637,"id":201308,"goal":"lemma SeqReverseIdem_14637(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_14638","instance":14638,"id":201309,"goal":"lemma SeqMapLen_14638(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_14639","instance":14639,"id":201310,"goal":"lemma SeqFilterLe_14639(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_14640","instance":14640,"id":201311,"goal":"lemma SeqMemberAppend_14640(u: seq, ys: seq)\n ensures x in u + ys <==> x in u || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_14641","instance":14641,"id":201312,"goal":"lemma SeqAppendLen_14641(u: seq, zs: seq)\n ensures |u + zs| == |u| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_14642","instance":14642,"id":201313,"goal":"lemma SeqAppendNil_14642(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_14643","instance":14643,"id":201314,"goal":"lemma SeqNilAppend_14643(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_14644","instance":14644,"id":201315,"goal":"lemma SeqAppendAssoc_14644(zs: seq, s: seq, u: seq)\n ensures (zs + s) + u == zs + (s + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_14645","instance":14645,"id":201316,"goal":"lemma SeqTakeDrop_14645(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_14646","instance":14646,"id":201317,"goal":"lemma SeqReverseLen_14646(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_14647","instance":14647,"id":201318,"goal":"lemma SeqReverseIdem_14647(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_14648","instance":14648,"id":201319,"goal":"lemma SeqMapLen_14648(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_14649","instance":14649,"id":201320,"goal":"lemma SeqFilterLe_14649(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_14650","instance":14650,"id":201321,"goal":"lemma SeqMemberAppend_14650(zs: seq, xs: seq)\n ensures x in zs + xs <==> x in zs || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_14651","instance":14651,"id":201322,"goal":"lemma SeqAppendLen_14651(t: seq, ys: seq)\n ensures |t + ys| == |t| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_14652","instance":14652,"id":201323,"goal":"lemma SeqAppendNil_14652(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_14653","instance":14653,"id":201324,"goal":"lemma SeqNilAppend_14653(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_14654","instance":14654,"id":201325,"goal":"lemma SeqAppendAssoc_14654(u: seq, s: seq, xs: seq)\n ensures (u + s) + xs == u + (s + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_14655","instance":14655,"id":201326,"goal":"lemma SeqTakeDrop_14655(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_14656","instance":14656,"id":201327,"goal":"lemma SeqReverseLen_14656(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_14657","instance":14657,"id":201328,"goal":"lemma SeqReverseIdem_14657(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_14658","instance":14658,"id":201329,"goal":"lemma SeqMapLen_14658(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_14659","instance":14659,"id":201330,"goal":"lemma SeqFilterLe_14659(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_14660","instance":14660,"id":201331,"goal":"lemma SeqMemberAppend_14660(s: seq, t: seq)\n ensures x in s + t <==> x in s || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_14661","instance":14661,"id":201332,"goal":"lemma SeqAppendLen_14661(s: seq, zs: seq)\n ensures |s + zs| == |s| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_14662","instance":14662,"id":201333,"goal":"lemma SeqAppendNil_14662(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_14663","instance":14663,"id":201334,"goal":"lemma SeqNilAppend_14663(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_14664","instance":14664,"id":201335,"goal":"lemma SeqAppendAssoc_14664(s: seq, u: seq, zs: seq)\n ensures (s + u) + zs == s + (u + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_14665","instance":14665,"id":201336,"goal":"lemma SeqTakeDrop_14665(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_14666","instance":14666,"id":201337,"goal":"lemma SeqReverseLen_14666(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_14667","instance":14667,"id":201338,"goal":"lemma SeqReverseIdem_14667(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_14668","instance":14668,"id":201339,"goal":"lemma SeqMapLen_14668(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_14669","instance":14669,"id":201340,"goal":"lemma SeqFilterLe_14669(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_14670","instance":14670,"id":201341,"goal":"lemma SeqMemberAppend_14670(ys: seq, zs: seq)\n ensures x in ys + zs <==> x in ys || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_14671","instance":14671,"id":201342,"goal":"lemma SeqAppendLen_14671(ys: seq, s: seq)\n ensures |ys + s| == |ys| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_14672","instance":14672,"id":201343,"goal":"lemma SeqAppendNil_14672(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_14673","instance":14673,"id":201344,"goal":"lemma SeqNilAppend_14673(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_14674","instance":14674,"id":201345,"goal":"lemma SeqAppendAssoc_14674(ys: seq, t: seq, zs: seq)\n ensures (ys + t) + zs == ys + (t + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_14675","instance":14675,"id":201346,"goal":"lemma SeqTakeDrop_14675(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_14676","instance":14676,"id":201347,"goal":"lemma SeqReverseLen_14676(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_14677","instance":14677,"id":201348,"goal":"lemma SeqReverseIdem_14677(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_14678","instance":14678,"id":201349,"goal":"lemma SeqMapLen_14678(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_14679","instance":14679,"id":201350,"goal":"lemma SeqFilterLe_14679(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_14680","instance":14680,"id":201351,"goal":"lemma SeqMemberAppend_14680(t: seq, ys: seq)\n ensures x in t + ys <==> x in t || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_14681","instance":14681,"id":201352,"goal":"lemma SeqAppendLen_14681(u: seq, s: seq)\n ensures |u + s| == |u| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_14682","instance":14682,"id":201353,"goal":"lemma SeqAppendNil_14682(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_14683","instance":14683,"id":201354,"goal":"lemma SeqNilAppend_14683(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_14684","instance":14684,"id":201355,"goal":"lemma SeqAppendAssoc_14684(t: seq, zs: seq, xs: seq)\n ensures (t + zs) + xs == t + (zs + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_14685","instance":14685,"id":201356,"goal":"lemma SeqTakeDrop_14685(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_14686","instance":14686,"id":201357,"goal":"lemma SeqReverseLen_14686(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_14687","instance":14687,"id":201358,"goal":"lemma SeqReverseIdem_14687(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_14688","instance":14688,"id":201359,"goal":"lemma SeqMapLen_14688(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_14689","instance":14689,"id":201360,"goal":"lemma SeqFilterLe_14689(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_14690","instance":14690,"id":201361,"goal":"lemma SeqMemberAppend_14690(ys: seq, s: seq)\n ensures x in ys + s <==> x in ys || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_14691","instance":14691,"id":201362,"goal":"lemma SeqAppendLen_14691(s: seq, u: seq)\n ensures |s + u| == |s| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_14692","instance":14692,"id":201363,"goal":"lemma SeqAppendNil_14692(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_14693","instance":14693,"id":201364,"goal":"lemma SeqNilAppend_14693(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_14694","instance":14694,"id":201365,"goal":"lemma SeqAppendAssoc_14694(u: seq, ys: seq, s: seq)\n ensures (u + ys) + s == u + (ys + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_14695","instance":14695,"id":201366,"goal":"lemma SeqTakeDrop_14695(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_14696","instance":14696,"id":201367,"goal":"lemma SeqReverseLen_14696(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_14697","instance":14697,"id":201368,"goal":"lemma SeqReverseIdem_14697(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_14698","instance":14698,"id":201369,"goal":"lemma SeqMapLen_14698(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_14699","instance":14699,"id":201370,"goal":"lemma SeqFilterLe_14699(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_14700","instance":14700,"id":201371,"goal":"lemma SeqMemberAppend_14700(s: seq, t: seq)\n ensures x in s + t <==> x in s || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_14701","instance":14701,"id":201372,"goal":"lemma SeqAppendLen_14701(xs: seq, ys: seq)\n ensures |xs + ys| == |xs| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_14702","instance":14702,"id":201373,"goal":"lemma SeqAppendNil_14702(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_14703","instance":14703,"id":201374,"goal":"lemma SeqNilAppend_14703(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_14704","instance":14704,"id":201375,"goal":"lemma SeqAppendAssoc_14704(zs: seq, t: seq, ys: seq)\n ensures (zs + t) + ys == zs + (t + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_14705","instance":14705,"id":201376,"goal":"lemma SeqTakeDrop_14705(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_14706","instance":14706,"id":201377,"goal":"lemma SeqReverseLen_14706(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_14707","instance":14707,"id":201378,"goal":"lemma SeqReverseIdem_14707(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_14708","instance":14708,"id":201379,"goal":"lemma SeqMapLen_14708(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_14709","instance":14709,"id":201380,"goal":"lemma SeqFilterLe_14709(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_14710","instance":14710,"id":201381,"goal":"lemma SeqMemberAppend_14710(u: seq, xs: seq)\n ensures x in u + xs <==> x in u || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_14711","instance":14711,"id":201382,"goal":"lemma SeqAppendLen_14711(u: seq, s: seq)\n ensures |u + s| == |u| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_14712","instance":14712,"id":201383,"goal":"lemma SeqAppendNil_14712(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_14713","instance":14713,"id":201384,"goal":"lemma SeqNilAppend_14713(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_14714","instance":14714,"id":201385,"goal":"lemma SeqAppendAssoc_14714(t: seq, ys: seq, u: seq)\n ensures (t + ys) + u == t + (ys + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_14715","instance":14715,"id":201386,"goal":"lemma SeqTakeDrop_14715(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_14716","instance":14716,"id":201387,"goal":"lemma SeqReverseLen_14716(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_14717","instance":14717,"id":201388,"goal":"lemma SeqReverseIdem_14717(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_14718","instance":14718,"id":201389,"goal":"lemma SeqMapLen_14718(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_14719","instance":14719,"id":201390,"goal":"lemma SeqFilterLe_14719(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_14720","instance":14720,"id":201391,"goal":"lemma SeqMemberAppend_14720(s: seq, u: seq)\n ensures x in s + u <==> x in s || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_14721","instance":14721,"id":201392,"goal":"lemma SeqAppendLen_14721(u: seq, zs: seq)\n ensures |u + zs| == |u| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_14722","instance":14722,"id":201393,"goal":"lemma SeqAppendNil_14722(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_14723","instance":14723,"id":201394,"goal":"lemma SeqNilAppend_14723(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_14724","instance":14724,"id":201395,"goal":"lemma SeqAppendAssoc_14724(u: seq, zs: seq, t: seq)\n ensures (u + zs) + t == u + (zs + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_14725","instance":14725,"id":201396,"goal":"lemma SeqTakeDrop_14725(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_14726","instance":14726,"id":201397,"goal":"lemma SeqReverseLen_14726(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_14727","instance":14727,"id":201398,"goal":"lemma SeqReverseIdem_14727(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_14728","instance":14728,"id":201399,"goal":"lemma SeqMapLen_14728(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_14729","instance":14729,"id":201400,"goal":"lemma SeqFilterLe_14729(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_14730","instance":14730,"id":201401,"goal":"lemma SeqMemberAppend_14730(t: seq, s: seq)\n ensures x in t + s <==> x in t || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_14731","instance":14731,"id":201402,"goal":"lemma SeqAppendLen_14731(u: seq, t: seq)\n ensures |u + t| == |u| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_14732","instance":14732,"id":201403,"goal":"lemma SeqAppendNil_14732(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_14733","instance":14733,"id":201404,"goal":"lemma SeqNilAppend_14733(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_14734","instance":14734,"id":201405,"goal":"lemma SeqAppendAssoc_14734(ys: seq, u: seq, zs: seq)\n ensures (ys + u) + zs == ys + (u + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_14735","instance":14735,"id":201406,"goal":"lemma SeqTakeDrop_14735(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_14736","instance":14736,"id":201407,"goal":"lemma SeqReverseLen_14736(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_14737","instance":14737,"id":201408,"goal":"lemma SeqReverseIdem_14737(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_14738","instance":14738,"id":201409,"goal":"lemma SeqMapLen_14738(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_14739","instance":14739,"id":201410,"goal":"lemma SeqFilterLe_14739(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_14740","instance":14740,"id":201411,"goal":"lemma SeqMemberAppend_14740(xs: seq, zs: seq)\n ensures x in xs + zs <==> x in xs || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_14741","instance":14741,"id":201412,"goal":"lemma SeqAppendLen_14741(xs: seq, t: seq)\n ensures |xs + t| == |xs| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_14742","instance":14742,"id":201413,"goal":"lemma SeqAppendNil_14742(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_14743","instance":14743,"id":201414,"goal":"lemma SeqNilAppend_14743(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_14744","instance":14744,"id":201415,"goal":"lemma SeqAppendAssoc_14744(xs: seq, s: seq, u: seq)\n ensures (xs + s) + u == xs + (s + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_14745","instance":14745,"id":201416,"goal":"lemma SeqTakeDrop_14745(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_14746","instance":14746,"id":201417,"goal":"lemma SeqReverseLen_14746(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_14747","instance":14747,"id":201418,"goal":"lemma SeqReverseIdem_14747(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_14748","instance":14748,"id":201419,"goal":"lemma SeqMapLen_14748(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_14749","instance":14749,"id":201420,"goal":"lemma SeqFilterLe_14749(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_14750","instance":14750,"id":201421,"goal":"lemma SeqMemberAppend_14750(t: seq, u: seq)\n ensures x in t + u <==> x in t || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_14751","instance":14751,"id":201422,"goal":"lemma SeqAppendLen_14751(t: seq, u: seq)\n ensures |t + u| == |t| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_14752","instance":14752,"id":201423,"goal":"lemma SeqAppendNil_14752(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_14753","instance":14753,"id":201424,"goal":"lemma SeqNilAppend_14753(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_14754","instance":14754,"id":201425,"goal":"lemma SeqAppendAssoc_14754(t: seq, xs: seq, ys: seq)\n ensures (t + xs) + ys == t + (xs + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_14755","instance":14755,"id":201426,"goal":"lemma SeqTakeDrop_14755(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_14756","instance":14756,"id":201427,"goal":"lemma SeqReverseLen_14756(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_14757","instance":14757,"id":201428,"goal":"lemma SeqReverseIdem_14757(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_14758","instance":14758,"id":201429,"goal":"lemma SeqMapLen_14758(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_14759","instance":14759,"id":201430,"goal":"lemma SeqFilterLe_14759(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_14760","instance":14760,"id":201431,"goal":"lemma SeqMemberAppend_14760(u: seq, t: seq)\n ensures x in u + t <==> x in u || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_14761","instance":14761,"id":201432,"goal":"lemma SeqAppendLen_14761(s: seq, ys: seq)\n ensures |s + ys| == |s| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_14762","instance":14762,"id":201433,"goal":"lemma SeqAppendNil_14762(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_14763","instance":14763,"id":201434,"goal":"lemma SeqNilAppend_14763(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_14764","instance":14764,"id":201435,"goal":"lemma SeqAppendAssoc_14764(t: seq, u: seq, s: seq)\n ensures (t + u) + s == t + (u + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_14765","instance":14765,"id":201436,"goal":"lemma SeqTakeDrop_14765(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_14766","instance":14766,"id":201437,"goal":"lemma SeqReverseLen_14766(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_14767","instance":14767,"id":201438,"goal":"lemma SeqReverseIdem_14767(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_14768","instance":14768,"id":201439,"goal":"lemma SeqMapLen_14768(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_14769","instance":14769,"id":201440,"goal":"lemma SeqFilterLe_14769(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_14770","instance":14770,"id":201441,"goal":"lemma SeqMemberAppend_14770(zs: seq, xs: seq)\n ensures x in zs + xs <==> x in zs || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_14771","instance":14771,"id":201442,"goal":"lemma SeqAppendLen_14771(ys: seq, s: seq)\n ensures |ys + s| == |ys| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_14772","instance":14772,"id":201443,"goal":"lemma SeqAppendNil_14772(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_14773","instance":14773,"id":201444,"goal":"lemma SeqNilAppend_14773(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_14774","instance":14774,"id":201445,"goal":"lemma SeqAppendAssoc_14774(s: seq, t: seq, xs: seq)\n ensures (s + t) + xs == s + (t + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_14775","instance":14775,"id":201446,"goal":"lemma SeqTakeDrop_14775(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_14776","instance":14776,"id":201447,"goal":"lemma SeqReverseLen_14776(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_14777","instance":14777,"id":201448,"goal":"lemma SeqReverseIdem_14777(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_14778","instance":14778,"id":201449,"goal":"lemma SeqMapLen_14778(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_14779","instance":14779,"id":201450,"goal":"lemma SeqFilterLe_14779(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_14780","instance":14780,"id":201451,"goal":"lemma SeqMemberAppend_14780(xs: seq, u: seq)\n ensures x in xs + u <==> x in xs || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_14781","instance":14781,"id":201452,"goal":"lemma SeqAppendLen_14781(t: seq, ys: seq)\n ensures |t + ys| == |t| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_14782","instance":14782,"id":201453,"goal":"lemma SeqAppendNil_14782(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_14783","instance":14783,"id":201454,"goal":"lemma SeqNilAppend_14783(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_14784","instance":14784,"id":201455,"goal":"lemma SeqAppendAssoc_14784(t: seq, s: seq, ys: seq)\n ensures (t + s) + ys == t + (s + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_14785","instance":14785,"id":201456,"goal":"lemma SeqTakeDrop_14785(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_14786","instance":14786,"id":201457,"goal":"lemma SeqReverseLen_14786(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_14787","instance":14787,"id":201458,"goal":"lemma SeqReverseIdem_14787(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_14788","instance":14788,"id":201459,"goal":"lemma SeqMapLen_14788(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_14789","instance":14789,"id":201460,"goal":"lemma SeqFilterLe_14789(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_14790","instance":14790,"id":201461,"goal":"lemma SeqMemberAppend_14790(zs: seq, u: seq)\n ensures x in zs + u <==> x in zs || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_14791","instance":14791,"id":201462,"goal":"lemma SeqAppendLen_14791(u: seq, s: seq)\n ensures |u + s| == |u| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_14792","instance":14792,"id":201463,"goal":"lemma SeqAppendNil_14792(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_14793","instance":14793,"id":201464,"goal":"lemma SeqNilAppend_14793(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_14794","instance":14794,"id":201465,"goal":"lemma SeqAppendAssoc_14794(ys: seq, zs: seq, s: seq)\n ensures (ys + zs) + s == ys + (zs + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_14795","instance":14795,"id":201466,"goal":"lemma SeqTakeDrop_14795(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_14796","instance":14796,"id":201467,"goal":"lemma SeqReverseLen_14796(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_14797","instance":14797,"id":201468,"goal":"lemma SeqReverseIdem_14797(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_14798","instance":14798,"id":201469,"goal":"lemma SeqMapLen_14798(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_14799","instance":14799,"id":201470,"goal":"lemma SeqFilterLe_14799(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_14800","instance":14800,"id":201471,"goal":"lemma SeqMemberAppend_14800(zs: seq, ys: seq)\n ensures x in zs + ys <==> x in zs || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_14801","instance":14801,"id":201472,"goal":"lemma SeqAppendLen_14801(t: seq, zs: seq)\n ensures |t + zs| == |t| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_14802","instance":14802,"id":201473,"goal":"lemma SeqAppendNil_14802(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_14803","instance":14803,"id":201474,"goal":"lemma SeqNilAppend_14803(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_14804","instance":14804,"id":201475,"goal":"lemma SeqAppendAssoc_14804(ys: seq, s: seq, u: seq)\n ensures (ys + s) + u == ys + (s + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_14805","instance":14805,"id":201476,"goal":"lemma SeqTakeDrop_14805(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_14806","instance":14806,"id":201477,"goal":"lemma SeqReverseLen_14806(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_14807","instance":14807,"id":201478,"goal":"lemma SeqReverseIdem_14807(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_14808","instance":14808,"id":201479,"goal":"lemma SeqMapLen_14808(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_14809","instance":14809,"id":201480,"goal":"lemma SeqFilterLe_14809(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_14810","instance":14810,"id":201481,"goal":"lemma SeqMemberAppend_14810(t: seq, ys: seq)\n ensures x in t + ys <==> x in t || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_14811","instance":14811,"id":201482,"goal":"lemma SeqAppendLen_14811(xs: seq, zs: seq)\n ensures |xs + zs| == |xs| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_14812","instance":14812,"id":201483,"goal":"lemma SeqAppendNil_14812(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_14813","instance":14813,"id":201484,"goal":"lemma SeqNilAppend_14813(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_14814","instance":14814,"id":201485,"goal":"lemma SeqAppendAssoc_14814(u: seq, zs: seq, s: seq)\n ensures (u + zs) + s == u + (zs + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_14815","instance":14815,"id":201486,"goal":"lemma SeqTakeDrop_14815(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_14816","instance":14816,"id":201487,"goal":"lemma SeqReverseLen_14816(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_14817","instance":14817,"id":201488,"goal":"lemma SeqReverseIdem_14817(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_14818","instance":14818,"id":201489,"goal":"lemma SeqMapLen_14818(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_14819","instance":14819,"id":201490,"goal":"lemma SeqFilterLe_14819(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_14820","instance":14820,"id":201491,"goal":"lemma SeqMemberAppend_14820(zs: seq, xs: seq)\n ensures x in zs + xs <==> x in zs || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_14821","instance":14821,"id":201492,"goal":"lemma SeqAppendLen_14821(u: seq, s: seq)\n ensures |u + s| == |u| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_14822","instance":14822,"id":201493,"goal":"lemma SeqAppendNil_14822(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_14823","instance":14823,"id":201494,"goal":"lemma SeqNilAppend_14823(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_14824","instance":14824,"id":201495,"goal":"lemma SeqAppendAssoc_14824(xs: seq, u: seq, t: seq)\n ensures (xs + u) + t == xs + (u + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_14825","instance":14825,"id":201496,"goal":"lemma SeqTakeDrop_14825(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_14826","instance":14826,"id":201497,"goal":"lemma SeqReverseLen_14826(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_14827","instance":14827,"id":201498,"goal":"lemma SeqReverseIdem_14827(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_14828","instance":14828,"id":201499,"goal":"lemma SeqMapLen_14828(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_14829","instance":14829,"id":201500,"goal":"lemma SeqFilterLe_14829(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_14830","instance":14830,"id":201501,"goal":"lemma SeqMemberAppend_14830(ys: seq, u: seq)\n ensures x in ys + u <==> x in ys || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_14831","instance":14831,"id":201502,"goal":"lemma SeqAppendLen_14831(ys: seq, u: seq)\n ensures |ys + u| == |ys| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_14832","instance":14832,"id":201503,"goal":"lemma SeqAppendNil_14832(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_14833","instance":14833,"id":201504,"goal":"lemma SeqNilAppend_14833(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_14834","instance":14834,"id":201505,"goal":"lemma SeqAppendAssoc_14834(ys: seq, xs: seq, u: seq)\n ensures (ys + xs) + u == ys + (xs + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_14835","instance":14835,"id":201506,"goal":"lemma SeqTakeDrop_14835(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_14836","instance":14836,"id":201507,"goal":"lemma SeqReverseLen_14836(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_14837","instance":14837,"id":201508,"goal":"lemma SeqReverseIdem_14837(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_14838","instance":14838,"id":201509,"goal":"lemma SeqMapLen_14838(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_14839","instance":14839,"id":201510,"goal":"lemma SeqFilterLe_14839(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_14840","instance":14840,"id":201511,"goal":"lemma SeqMemberAppend_14840(u: seq, s: seq)\n ensures x in u + s <==> x in u || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_14841","instance":14841,"id":201512,"goal":"lemma SeqAppendLen_14841(xs: seq, zs: seq)\n ensures |xs + zs| == |xs| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_14842","instance":14842,"id":201513,"goal":"lemma SeqAppendNil_14842(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_14843","instance":14843,"id":201514,"goal":"lemma SeqNilAppend_14843(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_14844","instance":14844,"id":201515,"goal":"lemma SeqAppendAssoc_14844(u: seq, t: seq, ys: seq)\n ensures (u + t) + ys == u + (t + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_14845","instance":14845,"id":201516,"goal":"lemma SeqTakeDrop_14845(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_14846","instance":14846,"id":201517,"goal":"lemma SeqReverseLen_14846(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_14847","instance":14847,"id":201518,"goal":"lemma SeqReverseIdem_14847(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_14848","instance":14848,"id":201519,"goal":"lemma SeqMapLen_14848(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_14849","instance":14849,"id":201520,"goal":"lemma SeqFilterLe_14849(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_14850","instance":14850,"id":201521,"goal":"lemma SeqMemberAppend_14850(u: seq, xs: seq)\n ensures x in u + xs <==> x in u || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_14851","instance":14851,"id":201522,"goal":"lemma SeqAppendLen_14851(t: seq, u: seq)\n ensures |t + u| == |t| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_14852","instance":14852,"id":201523,"goal":"lemma SeqAppendNil_14852(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_14853","instance":14853,"id":201524,"goal":"lemma SeqNilAppend_14853(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_14854","instance":14854,"id":201525,"goal":"lemma SeqAppendAssoc_14854(t: seq, zs: seq, xs: seq)\n ensures (t + zs) + xs == t + (zs + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_14855","instance":14855,"id":201526,"goal":"lemma SeqTakeDrop_14855(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_14856","instance":14856,"id":201527,"goal":"lemma SeqReverseLen_14856(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_14857","instance":14857,"id":201528,"goal":"lemma SeqReverseIdem_14857(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_14858","instance":14858,"id":201529,"goal":"lemma SeqMapLen_14858(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_14859","instance":14859,"id":201530,"goal":"lemma SeqFilterLe_14859(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_14860","instance":14860,"id":201531,"goal":"lemma SeqMemberAppend_14860(ys: seq, xs: seq)\n ensures x in ys + xs <==> x in ys || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_14861","instance":14861,"id":201532,"goal":"lemma SeqAppendLen_14861(zs: seq, xs: seq)\n ensures |zs + xs| == |zs| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_14862","instance":14862,"id":201533,"goal":"lemma SeqAppendNil_14862(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_14863","instance":14863,"id":201534,"goal":"lemma SeqNilAppend_14863(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_14864","instance":14864,"id":201535,"goal":"lemma SeqAppendAssoc_14864(t: seq, ys: seq, zs: seq)\n ensures (t + ys) + zs == t + (ys + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_14865","instance":14865,"id":201536,"goal":"lemma SeqTakeDrop_14865(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_14866","instance":14866,"id":201537,"goal":"lemma SeqReverseLen_14866(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_14867","instance":14867,"id":201538,"goal":"lemma SeqReverseIdem_14867(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_14868","instance":14868,"id":201539,"goal":"lemma SeqMapLen_14868(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_14869","instance":14869,"id":201540,"goal":"lemma SeqFilterLe_14869(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_14870","instance":14870,"id":201541,"goal":"lemma SeqMemberAppend_14870(zs: seq, t: seq)\n ensures x in zs + t <==> x in zs || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_14871","instance":14871,"id":201542,"goal":"lemma SeqAppendLen_14871(s: seq, ys: seq)\n ensures |s + ys| == |s| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_14872","instance":14872,"id":201543,"goal":"lemma SeqAppendNil_14872(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_14873","instance":14873,"id":201544,"goal":"lemma SeqNilAppend_14873(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_14874","instance":14874,"id":201545,"goal":"lemma SeqAppendAssoc_14874(t: seq, ys: seq, u: seq)\n ensures (t + ys) + u == t + (ys + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_14875","instance":14875,"id":201546,"goal":"lemma SeqTakeDrop_14875(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_14876","instance":14876,"id":201547,"goal":"lemma SeqReverseLen_14876(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_14877","instance":14877,"id":201548,"goal":"lemma SeqReverseIdem_14877(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_14878","instance":14878,"id":201549,"goal":"lemma SeqMapLen_14878(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_14879","instance":14879,"id":201550,"goal":"lemma SeqFilterLe_14879(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_14880","instance":14880,"id":201551,"goal":"lemma SeqMemberAppend_14880(xs: seq, s: seq)\n ensures x in xs + s <==> x in xs || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_14881","instance":14881,"id":201552,"goal":"lemma SeqAppendLen_14881(xs: seq, u: seq)\n ensures |xs + u| == |xs| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_14882","instance":14882,"id":201553,"goal":"lemma SeqAppendNil_14882(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_14883","instance":14883,"id":201554,"goal":"lemma SeqNilAppend_14883(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_14884","instance":14884,"id":201555,"goal":"lemma SeqAppendAssoc_14884(u: seq, t: seq, ys: seq)\n ensures (u + t) + ys == u + (t + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_14885","instance":14885,"id":201556,"goal":"lemma SeqTakeDrop_14885(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_14886","instance":14886,"id":201557,"goal":"lemma SeqReverseLen_14886(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_14887","instance":14887,"id":201558,"goal":"lemma SeqReverseIdem_14887(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_14888","instance":14888,"id":201559,"goal":"lemma SeqMapLen_14888(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_14889","instance":14889,"id":201560,"goal":"lemma SeqFilterLe_14889(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_14890","instance":14890,"id":201561,"goal":"lemma SeqMemberAppend_14890(ys: seq, s: seq)\n ensures x in ys + s <==> x in ys || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_14891","instance":14891,"id":201562,"goal":"lemma SeqAppendLen_14891(xs: seq, zs: seq)\n ensures |xs + zs| == |xs| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_14892","instance":14892,"id":201563,"goal":"lemma SeqAppendNil_14892(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_14893","instance":14893,"id":201564,"goal":"lemma SeqNilAppend_14893(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_14894","instance":14894,"id":201565,"goal":"lemma SeqAppendAssoc_14894(t: seq, ys: seq, u: seq)\n ensures (t + ys) + u == t + (ys + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_14895","instance":14895,"id":201566,"goal":"lemma SeqTakeDrop_14895(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_14896","instance":14896,"id":201567,"goal":"lemma SeqReverseLen_14896(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_14897","instance":14897,"id":201568,"goal":"lemma SeqReverseIdem_14897(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_14898","instance":14898,"id":201569,"goal":"lemma SeqMapLen_14898(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_14899","instance":14899,"id":201570,"goal":"lemma SeqFilterLe_14899(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_14900","instance":14900,"id":201571,"goal":"lemma SeqMemberAppend_14900(t: seq, u: seq)\n ensures x in t + u <==> x in t || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_14901","instance":14901,"id":201572,"goal":"lemma SeqAppendLen_14901(s: seq, ys: seq)\n ensures |s + ys| == |s| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_14902","instance":14902,"id":201573,"goal":"lemma SeqAppendNil_14902(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_14903","instance":14903,"id":201574,"goal":"lemma SeqNilAppend_14903(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_14904","instance":14904,"id":201575,"goal":"lemma SeqAppendAssoc_14904(s: seq, t: seq, u: seq)\n ensures (s + t) + u == s + (t + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_14905","instance":14905,"id":201576,"goal":"lemma SeqTakeDrop_14905(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_14906","instance":14906,"id":201577,"goal":"lemma SeqReverseLen_14906(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_14907","instance":14907,"id":201578,"goal":"lemma SeqReverseIdem_14907(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_14908","instance":14908,"id":201579,"goal":"lemma SeqMapLen_14908(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_14909","instance":14909,"id":201580,"goal":"lemma SeqFilterLe_14909(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_14910","instance":14910,"id":201581,"goal":"lemma SeqMemberAppend_14910(t: seq, xs: seq)\n ensures x in t + xs <==> x in t || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_14911","instance":14911,"id":201582,"goal":"lemma SeqAppendLen_14911(u: seq, zs: seq)\n ensures |u + zs| == |u| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_14912","instance":14912,"id":201583,"goal":"lemma SeqAppendNil_14912(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_14913","instance":14913,"id":201584,"goal":"lemma SeqNilAppend_14913(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_14914","instance":14914,"id":201585,"goal":"lemma SeqAppendAssoc_14914(ys: seq, t: seq, xs: seq)\n ensures (ys + t) + xs == ys + (t + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_14915","instance":14915,"id":201586,"goal":"lemma SeqTakeDrop_14915(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_14916","instance":14916,"id":201587,"goal":"lemma SeqReverseLen_14916(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_14917","instance":14917,"id":201588,"goal":"lemma SeqReverseIdem_14917(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_14918","instance":14918,"id":201589,"goal":"lemma SeqMapLen_14918(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_14919","instance":14919,"id":201590,"goal":"lemma SeqFilterLe_14919(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_14920","instance":14920,"id":201591,"goal":"lemma SeqMemberAppend_14920(zs: seq, u: seq)\n ensures x in zs + u <==> x in zs || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_14921","instance":14921,"id":201592,"goal":"lemma SeqAppendLen_14921(zs: seq, u: seq)\n ensures |zs + u| == |zs| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_14922","instance":14922,"id":201593,"goal":"lemma SeqAppendNil_14922(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_14923","instance":14923,"id":201594,"goal":"lemma SeqNilAppend_14923(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_14924","instance":14924,"id":201595,"goal":"lemma SeqAppendAssoc_14924(xs: seq, u: seq, zs: seq)\n ensures (xs + u) + zs == xs + (u + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_14925","instance":14925,"id":201596,"goal":"lemma SeqTakeDrop_14925(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_14926","instance":14926,"id":201597,"goal":"lemma SeqReverseLen_14926(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_14927","instance":14927,"id":201598,"goal":"lemma SeqReverseIdem_14927(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_14928","instance":14928,"id":201599,"goal":"lemma SeqMapLen_14928(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_14929","instance":14929,"id":201600,"goal":"lemma SeqFilterLe_14929(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_14930","instance":14930,"id":201601,"goal":"lemma SeqMemberAppend_14930(t: seq, ys: seq)\n ensures x in t + ys <==> x in t || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_14931","instance":14931,"id":201602,"goal":"lemma SeqAppendLen_14931(ys: seq, t: seq)\n ensures |ys + t| == |ys| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_14932","instance":14932,"id":201603,"goal":"lemma SeqAppendNil_14932(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_14933","instance":14933,"id":201604,"goal":"lemma SeqNilAppend_14933(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_14934","instance":14934,"id":201605,"goal":"lemma SeqAppendAssoc_14934(xs: seq, t: seq, s: seq)\n ensures (xs + t) + s == xs + (t + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_14935","instance":14935,"id":201606,"goal":"lemma SeqTakeDrop_14935(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_14936","instance":14936,"id":201607,"goal":"lemma SeqReverseLen_14936(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_14937","instance":14937,"id":201608,"goal":"lemma SeqReverseIdem_14937(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_14938","instance":14938,"id":201609,"goal":"lemma SeqMapLen_14938(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_14939","instance":14939,"id":201610,"goal":"lemma SeqFilterLe_14939(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_14940","instance":14940,"id":201611,"goal":"lemma SeqMemberAppend_14940(ys: seq, s: seq)\n ensures x in ys + s <==> x in ys || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_14941","instance":14941,"id":201612,"goal":"lemma SeqAppendLen_14941(t: seq, u: seq)\n ensures |t + u| == |t| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_14942","instance":14942,"id":201613,"goal":"lemma SeqAppendNil_14942(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_14943","instance":14943,"id":201614,"goal":"lemma SeqNilAppend_14943(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_14944","instance":14944,"id":201615,"goal":"lemma SeqAppendAssoc_14944(ys: seq, u: seq, t: seq)\n ensures (ys + u) + t == ys + (u + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_14945","instance":14945,"id":201616,"goal":"lemma SeqTakeDrop_14945(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_14946","instance":14946,"id":201617,"goal":"lemma SeqReverseLen_14946(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_14947","instance":14947,"id":201618,"goal":"lemma SeqReverseIdem_14947(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_14948","instance":14948,"id":201619,"goal":"lemma SeqMapLen_14948(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_14949","instance":14949,"id":201620,"goal":"lemma SeqFilterLe_14949(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_14950","instance":14950,"id":201621,"goal":"lemma SeqMemberAppend_14950(zs: seq, xs: seq)\n ensures x in zs + xs <==> x in zs || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_14951","instance":14951,"id":201622,"goal":"lemma SeqAppendLen_14951(u: seq, xs: seq)\n ensures |u + xs| == |u| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_14952","instance":14952,"id":201623,"goal":"lemma SeqAppendNil_14952(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_14953","instance":14953,"id":201624,"goal":"lemma SeqNilAppend_14953(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_14954","instance":14954,"id":201625,"goal":"lemma SeqAppendAssoc_14954(zs: seq, ys: seq, s: seq)\n ensures (zs + ys) + s == zs + (ys + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_14955","instance":14955,"id":201626,"goal":"lemma SeqTakeDrop_14955(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_14956","instance":14956,"id":201627,"goal":"lemma SeqReverseLen_14956(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_14957","instance":14957,"id":201628,"goal":"lemma SeqReverseIdem_14957(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_14958","instance":14958,"id":201629,"goal":"lemma SeqMapLen_14958(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_14959","instance":14959,"id":201630,"goal":"lemma SeqFilterLe_14959(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_14960","instance":14960,"id":201631,"goal":"lemma SeqMemberAppend_14960(u: seq, ys: seq)\n ensures x in u + ys <==> x in u || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_14961","instance":14961,"id":201632,"goal":"lemma SeqAppendLen_14961(zs: seq, xs: seq)\n ensures |zs + xs| == |zs| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_14962","instance":14962,"id":201633,"goal":"lemma SeqAppendNil_14962(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_14963","instance":14963,"id":201634,"goal":"lemma SeqNilAppend_14963(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_14964","instance":14964,"id":201635,"goal":"lemma SeqAppendAssoc_14964(t: seq, s: seq, u: seq)\n ensures (t + s) + u == t + (s + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_14965","instance":14965,"id":201636,"goal":"lemma SeqTakeDrop_14965(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_14966","instance":14966,"id":201637,"goal":"lemma SeqReverseLen_14966(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_14967","instance":14967,"id":201638,"goal":"lemma SeqReverseIdem_14967(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_14968","instance":14968,"id":201639,"goal":"lemma SeqMapLen_14968(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_14969","instance":14969,"id":201640,"goal":"lemma SeqFilterLe_14969(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_14970","instance":14970,"id":201641,"goal":"lemma SeqMemberAppend_14970(zs: seq, s: seq)\n ensures x in zs + s <==> x in zs || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_14971","instance":14971,"id":201642,"goal":"lemma SeqAppendLen_14971(s: seq, ys: seq)\n ensures |s + ys| == |s| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_14972","instance":14972,"id":201643,"goal":"lemma SeqAppendNil_14972(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_14973","instance":14973,"id":201644,"goal":"lemma SeqNilAppend_14973(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_14974","instance":14974,"id":201645,"goal":"lemma SeqAppendAssoc_14974(zs: seq, ys: seq, t: seq)\n ensures (zs + ys) + t == zs + (ys + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_14975","instance":14975,"id":201646,"goal":"lemma SeqTakeDrop_14975(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_14976","instance":14976,"id":201647,"goal":"lemma SeqReverseLen_14976(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_14977","instance":14977,"id":201648,"goal":"lemma SeqReverseIdem_14977(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_14978","instance":14978,"id":201649,"goal":"lemma SeqMapLen_14978(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_14979","instance":14979,"id":201650,"goal":"lemma SeqFilterLe_14979(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_14980","instance":14980,"id":201651,"goal":"lemma SeqMemberAppend_14980(zs: seq, t: seq)\n ensures x in zs + t <==> x in zs || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_14981","instance":14981,"id":201652,"goal":"lemma SeqAppendLen_14981(s: seq, ys: seq)\n ensures |s + ys| == |s| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_14982","instance":14982,"id":201653,"goal":"lemma SeqAppendNil_14982(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_14983","instance":14983,"id":201654,"goal":"lemma SeqNilAppend_14983(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_14984","instance":14984,"id":201655,"goal":"lemma SeqAppendAssoc_14984(t: seq, s: seq, zs: seq)\n ensures (t + s) + zs == t + (s + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_14985","instance":14985,"id":201656,"goal":"lemma SeqTakeDrop_14985(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_14986","instance":14986,"id":201657,"goal":"lemma SeqReverseLen_14986(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_14987","instance":14987,"id":201658,"goal":"lemma SeqReverseIdem_14987(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_14988","instance":14988,"id":201659,"goal":"lemma SeqMapLen_14988(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_14989","instance":14989,"id":201660,"goal":"lemma SeqFilterLe_14989(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_14990","instance":14990,"id":201661,"goal":"lemma SeqMemberAppend_14990(zs: seq, xs: seq)\n ensures x in zs + xs <==> x in zs || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_14991","instance":14991,"id":201662,"goal":"lemma SeqAppendLen_14991(s: seq, xs: seq)\n ensures |s + xs| == |s| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_14992","instance":14992,"id":201663,"goal":"lemma SeqAppendNil_14992(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_14993","instance":14993,"id":201664,"goal":"lemma SeqNilAppend_14993(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_14994","instance":14994,"id":201665,"goal":"lemma SeqAppendAssoc_14994(xs: seq, zs: seq, ys: seq)\n ensures (xs + zs) + ys == xs + (zs + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_14995","instance":14995,"id":201666,"goal":"lemma SeqTakeDrop_14995(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_14996","instance":14996,"id":201667,"goal":"lemma SeqReverseLen_14996(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_14997","instance":14997,"id":201668,"goal":"lemma SeqReverseIdem_14997(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_14998","instance":14998,"id":201669,"goal":"lemma SeqMapLen_14998(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_14999","instance":14999,"id":201670,"goal":"lemma SeqFilterLe_14999(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_15000","instance":15000,"id":201671,"goal":"lemma SeqMemberAppend_15000(ys: seq, u: seq)\n ensures x in ys + u <==> x in ys || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_15001","instance":15001,"id":201672,"goal":"lemma SeqAppendLen_15001(s: seq, ys: seq)\n ensures |s + ys| == |s| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_15002","instance":15002,"id":201673,"goal":"lemma SeqAppendNil_15002(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_15003","instance":15003,"id":201674,"goal":"lemma SeqNilAppend_15003(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_15004","instance":15004,"id":201675,"goal":"lemma SeqAppendAssoc_15004(t: seq, ys: seq, s: seq)\n ensures (t + ys) + s == t + (ys + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_15005","instance":15005,"id":201676,"goal":"lemma SeqTakeDrop_15005(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_15006","instance":15006,"id":201677,"goal":"lemma SeqReverseLen_15006(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_15007","instance":15007,"id":201678,"goal":"lemma SeqReverseIdem_15007(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_15008","instance":15008,"id":201679,"goal":"lemma SeqMapLen_15008(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_15009","instance":15009,"id":201680,"goal":"lemma SeqFilterLe_15009(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_15010","instance":15010,"id":201681,"goal":"lemma SeqMemberAppend_15010(xs: seq, u: seq)\n ensures x in xs + u <==> x in xs || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_15011","instance":15011,"id":201682,"goal":"lemma SeqAppendLen_15011(s: seq, xs: seq)\n ensures |s + xs| == |s| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_15012","instance":15012,"id":201683,"goal":"lemma SeqAppendNil_15012(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_15013","instance":15013,"id":201684,"goal":"lemma SeqNilAppend_15013(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_15014","instance":15014,"id":201685,"goal":"lemma SeqAppendAssoc_15014(xs: seq, ys: seq, zs: seq)\n ensures (xs + ys) + zs == xs + (ys + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_15015","instance":15015,"id":201686,"goal":"lemma SeqTakeDrop_15015(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_15016","instance":15016,"id":201687,"goal":"lemma SeqReverseLen_15016(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_15017","instance":15017,"id":201688,"goal":"lemma SeqReverseIdem_15017(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_15018","instance":15018,"id":201689,"goal":"lemma SeqMapLen_15018(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_15019","instance":15019,"id":201690,"goal":"lemma SeqFilterLe_15019(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_15020","instance":15020,"id":201691,"goal":"lemma SeqMemberAppend_15020(s: seq, xs: seq)\n ensures x in s + xs <==> x in s || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_15021","instance":15021,"id":201692,"goal":"lemma SeqAppendLen_15021(s: seq, zs: seq)\n ensures |s + zs| == |s| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_15022","instance":15022,"id":201693,"goal":"lemma SeqAppendNil_15022(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_15023","instance":15023,"id":201694,"goal":"lemma SeqNilAppend_15023(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_15024","instance":15024,"id":201695,"goal":"lemma SeqAppendAssoc_15024(t: seq, u: seq, s: seq)\n ensures (t + u) + s == t + (u + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_15025","instance":15025,"id":201696,"goal":"lemma SeqTakeDrop_15025(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_15026","instance":15026,"id":201697,"goal":"lemma SeqReverseLen_15026(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_15027","instance":15027,"id":201698,"goal":"lemma SeqReverseIdem_15027(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_15028","instance":15028,"id":201699,"goal":"lemma SeqMapLen_15028(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_15029","instance":15029,"id":201700,"goal":"lemma SeqFilterLe_15029(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_15030","instance":15030,"id":201701,"goal":"lemma SeqMemberAppend_15030(u: seq, s: seq)\n ensures x in u + s <==> x in u || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_15031","instance":15031,"id":201702,"goal":"lemma SeqAppendLen_15031(t: seq, zs: seq)\n ensures |t + zs| == |t| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_15032","instance":15032,"id":201703,"goal":"lemma SeqAppendNil_15032(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_15033","instance":15033,"id":201704,"goal":"lemma SeqNilAppend_15033(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_15034","instance":15034,"id":201705,"goal":"lemma SeqAppendAssoc_15034(xs: seq, s: seq, u: seq)\n ensures (xs + s) + u == xs + (s + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_15035","instance":15035,"id":201706,"goal":"lemma SeqTakeDrop_15035(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_15036","instance":15036,"id":201707,"goal":"lemma SeqReverseLen_15036(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_15037","instance":15037,"id":201708,"goal":"lemma SeqReverseIdem_15037(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_15038","instance":15038,"id":201709,"goal":"lemma SeqMapLen_15038(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_15039","instance":15039,"id":201710,"goal":"lemma SeqFilterLe_15039(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_15040","instance":15040,"id":201711,"goal":"lemma SeqMemberAppend_15040(u: seq, zs: seq)\n ensures x in u + zs <==> x in u || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_15041","instance":15041,"id":201712,"goal":"lemma SeqAppendLen_15041(t: seq, s: seq)\n ensures |t + s| == |t| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_15042","instance":15042,"id":201713,"goal":"lemma SeqAppendNil_15042(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_15043","instance":15043,"id":201714,"goal":"lemma SeqNilAppend_15043(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_15044","instance":15044,"id":201715,"goal":"lemma SeqAppendAssoc_15044(xs: seq, zs: seq, u: seq)\n ensures (xs + zs) + u == xs + (zs + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_15045","instance":15045,"id":201716,"goal":"lemma SeqTakeDrop_15045(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_15046","instance":15046,"id":201717,"goal":"lemma SeqReverseLen_15046(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_15047","instance":15047,"id":201718,"goal":"lemma SeqReverseIdem_15047(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_15048","instance":15048,"id":201719,"goal":"lemma SeqMapLen_15048(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_15049","instance":15049,"id":201720,"goal":"lemma SeqFilterLe_15049(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_15050","instance":15050,"id":201721,"goal":"lemma SeqMemberAppend_15050(ys: seq, xs: seq)\n ensures x in ys + xs <==> x in ys || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_15051","instance":15051,"id":201722,"goal":"lemma SeqAppendLen_15051(t: seq, xs: seq)\n ensures |t + xs| == |t| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_15052","instance":15052,"id":201723,"goal":"lemma SeqAppendNil_15052(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_15053","instance":15053,"id":201724,"goal":"lemma SeqNilAppend_15053(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_15054","instance":15054,"id":201725,"goal":"lemma SeqAppendAssoc_15054(xs: seq, ys: seq, t: seq)\n ensures (xs + ys) + t == xs + (ys + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_15055","instance":15055,"id":201726,"goal":"lemma SeqTakeDrop_15055(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_15056","instance":15056,"id":201727,"goal":"lemma SeqReverseLen_15056(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_15057","instance":15057,"id":201728,"goal":"lemma SeqReverseIdem_15057(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_15058","instance":15058,"id":201729,"goal":"lemma SeqMapLen_15058(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_15059","instance":15059,"id":201730,"goal":"lemma SeqFilterLe_15059(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_15060","instance":15060,"id":201731,"goal":"lemma SeqMemberAppend_15060(t: seq, ys: seq)\n ensures x in t + ys <==> x in t || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_15061","instance":15061,"id":201732,"goal":"lemma SeqAppendLen_15061(s: seq, t: seq)\n ensures |s + t| == |s| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_15062","instance":15062,"id":201733,"goal":"lemma SeqAppendNil_15062(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_15063","instance":15063,"id":201734,"goal":"lemma SeqNilAppend_15063(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_15064","instance":15064,"id":201735,"goal":"lemma SeqAppendAssoc_15064(zs: seq, u: seq, t: seq)\n ensures (zs + u) + t == zs + (u + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_15065","instance":15065,"id":201736,"goal":"lemma SeqTakeDrop_15065(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_15066","instance":15066,"id":201737,"goal":"lemma SeqReverseLen_15066(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_15067","instance":15067,"id":201738,"goal":"lemma SeqReverseIdem_15067(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_15068","instance":15068,"id":201739,"goal":"lemma SeqMapLen_15068(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_15069","instance":15069,"id":201740,"goal":"lemma SeqFilterLe_15069(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_15070","instance":15070,"id":201741,"goal":"lemma SeqMemberAppend_15070(s: seq, t: seq)\n ensures x in s + t <==> x in s || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_15071","instance":15071,"id":201742,"goal":"lemma SeqAppendLen_15071(u: seq, ys: seq)\n ensures |u + ys| == |u| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_15072","instance":15072,"id":201743,"goal":"lemma SeqAppendNil_15072(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_15073","instance":15073,"id":201744,"goal":"lemma SeqNilAppend_15073(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_15074","instance":15074,"id":201745,"goal":"lemma SeqAppendAssoc_15074(t: seq, xs: seq, u: seq)\n ensures (t + xs) + u == t + (xs + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_15075","instance":15075,"id":201746,"goal":"lemma SeqTakeDrop_15075(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_15076","instance":15076,"id":201747,"goal":"lemma SeqReverseLen_15076(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_15077","instance":15077,"id":201748,"goal":"lemma SeqReverseIdem_15077(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_15078","instance":15078,"id":201749,"goal":"lemma SeqMapLen_15078(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_15079","instance":15079,"id":201750,"goal":"lemma SeqFilterLe_15079(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_15080","instance":15080,"id":201751,"goal":"lemma SeqMemberAppend_15080(xs: seq, u: seq)\n ensures x in xs + u <==> x in xs || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_15081","instance":15081,"id":201752,"goal":"lemma SeqAppendLen_15081(xs: seq, zs: seq)\n ensures |xs + zs| == |xs| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_15082","instance":15082,"id":201753,"goal":"lemma SeqAppendNil_15082(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_15083","instance":15083,"id":201754,"goal":"lemma SeqNilAppend_15083(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_15084","instance":15084,"id":201755,"goal":"lemma SeqAppendAssoc_15084(s: seq, u: seq, ys: seq)\n ensures (s + u) + ys == s + (u + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_15085","instance":15085,"id":201756,"goal":"lemma SeqTakeDrop_15085(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_15086","instance":15086,"id":201757,"goal":"lemma SeqReverseLen_15086(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_15087","instance":15087,"id":201758,"goal":"lemma SeqReverseIdem_15087(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_15088","instance":15088,"id":201759,"goal":"lemma SeqMapLen_15088(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_15089","instance":15089,"id":201760,"goal":"lemma SeqFilterLe_15089(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_15090","instance":15090,"id":201761,"goal":"lemma SeqMemberAppend_15090(s: seq, xs: seq)\n ensures x in s + xs <==> x in s || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_15091","instance":15091,"id":201762,"goal":"lemma SeqAppendLen_15091(xs: seq, u: seq)\n ensures |xs + u| == |xs| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_15092","instance":15092,"id":201763,"goal":"lemma SeqAppendNil_15092(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_15093","instance":15093,"id":201764,"goal":"lemma SeqNilAppend_15093(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_15094","instance":15094,"id":201765,"goal":"lemma SeqAppendAssoc_15094(s: seq, xs: seq, ys: seq)\n ensures (s + xs) + ys == s + (xs + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_15095","instance":15095,"id":201766,"goal":"lemma SeqTakeDrop_15095(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_15096","instance":15096,"id":201767,"goal":"lemma SeqReverseLen_15096(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_15097","instance":15097,"id":201768,"goal":"lemma SeqReverseIdem_15097(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_15098","instance":15098,"id":201769,"goal":"lemma SeqMapLen_15098(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_15099","instance":15099,"id":201770,"goal":"lemma SeqFilterLe_15099(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_15100","instance":15100,"id":201771,"goal":"lemma SeqMemberAppend_15100(zs: seq, xs: seq)\n ensures x in zs + xs <==> x in zs || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_15101","instance":15101,"id":201772,"goal":"lemma SeqAppendLen_15101(u: seq, xs: seq)\n ensures |u + xs| == |u| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_15102","instance":15102,"id":201773,"goal":"lemma SeqAppendNil_15102(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_15103","instance":15103,"id":201774,"goal":"lemma SeqNilAppend_15103(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_15104","instance":15104,"id":201775,"goal":"lemma SeqAppendAssoc_15104(t: seq, s: seq, xs: seq)\n ensures (t + s) + xs == t + (s + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_15105","instance":15105,"id":201776,"goal":"lemma SeqTakeDrop_15105(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_15106","instance":15106,"id":201777,"goal":"lemma SeqReverseLen_15106(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_15107","instance":15107,"id":201778,"goal":"lemma SeqReverseIdem_15107(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_15108","instance":15108,"id":201779,"goal":"lemma SeqMapLen_15108(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_15109","instance":15109,"id":201780,"goal":"lemma SeqFilterLe_15109(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_15110","instance":15110,"id":201781,"goal":"lemma SeqMemberAppend_15110(t: seq, zs: seq)\n ensures x in t + zs <==> x in t || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_15111","instance":15111,"id":201782,"goal":"lemma SeqAppendLen_15111(t: seq, xs: seq)\n ensures |t + xs| == |t| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_15112","instance":15112,"id":201783,"goal":"lemma SeqAppendNil_15112(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_15113","instance":15113,"id":201784,"goal":"lemma SeqNilAppend_15113(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_15114","instance":15114,"id":201785,"goal":"lemma SeqAppendAssoc_15114(s: seq, u: seq, xs: seq)\n ensures (s + u) + xs == s + (u + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_15115","instance":15115,"id":201786,"goal":"lemma SeqTakeDrop_15115(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_15116","instance":15116,"id":201787,"goal":"lemma SeqReverseLen_15116(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_15117","instance":15117,"id":201788,"goal":"lemma SeqReverseIdem_15117(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_15118","instance":15118,"id":201789,"goal":"lemma SeqMapLen_15118(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_15119","instance":15119,"id":201790,"goal":"lemma SeqFilterLe_15119(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_15120","instance":15120,"id":201791,"goal":"lemma SeqMemberAppend_15120(t: seq, s: seq)\n ensures x in t + s <==> x in t || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_15121","instance":15121,"id":201792,"goal":"lemma SeqAppendLen_15121(zs: seq, u: seq)\n ensures |zs + u| == |zs| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_15122","instance":15122,"id":201793,"goal":"lemma SeqAppendNil_15122(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_15123","instance":15123,"id":201794,"goal":"lemma SeqNilAppend_15123(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_15124","instance":15124,"id":201795,"goal":"lemma SeqAppendAssoc_15124(xs: seq, t: seq, ys: seq)\n ensures (xs + t) + ys == xs + (t + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_15125","instance":15125,"id":201796,"goal":"lemma SeqTakeDrop_15125(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_15126","instance":15126,"id":201797,"goal":"lemma SeqReverseLen_15126(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_15127","instance":15127,"id":201798,"goal":"lemma SeqReverseIdem_15127(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_15128","instance":15128,"id":201799,"goal":"lemma SeqMapLen_15128(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_15129","instance":15129,"id":201800,"goal":"lemma SeqFilterLe_15129(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_15130","instance":15130,"id":201801,"goal":"lemma SeqMemberAppend_15130(s: seq, u: seq)\n ensures x in s + u <==> x in s || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_15131","instance":15131,"id":201802,"goal":"lemma SeqAppendLen_15131(ys: seq, u: seq)\n ensures |ys + u| == |ys| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_15132","instance":15132,"id":201803,"goal":"lemma SeqAppendNil_15132(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_15133","instance":15133,"id":201804,"goal":"lemma SeqNilAppend_15133(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_15134","instance":15134,"id":201805,"goal":"lemma SeqAppendAssoc_15134(ys: seq, xs: seq, zs: seq)\n ensures (ys + xs) + zs == ys + (xs + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_15135","instance":15135,"id":201806,"goal":"lemma SeqTakeDrop_15135(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_15136","instance":15136,"id":201807,"goal":"lemma SeqReverseLen_15136(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_15137","instance":15137,"id":201808,"goal":"lemma SeqReverseIdem_15137(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_15138","instance":15138,"id":201809,"goal":"lemma SeqMapLen_15138(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_15139","instance":15139,"id":201810,"goal":"lemma SeqFilterLe_15139(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_15140","instance":15140,"id":201811,"goal":"lemma SeqMemberAppend_15140(zs: seq, ys: seq)\n ensures x in zs + ys <==> x in zs || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_15141","instance":15141,"id":201812,"goal":"lemma SeqAppendLen_15141(xs: seq, s: seq)\n ensures |xs + s| == |xs| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_15142","instance":15142,"id":201813,"goal":"lemma SeqAppendNil_15142(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_15143","instance":15143,"id":201814,"goal":"lemma SeqNilAppend_15143(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_15144","instance":15144,"id":201815,"goal":"lemma SeqAppendAssoc_15144(u: seq, s: seq, ys: seq)\n ensures (u + s) + ys == u + (s + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_15145","instance":15145,"id":201816,"goal":"lemma SeqTakeDrop_15145(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_15146","instance":15146,"id":201817,"goal":"lemma SeqReverseLen_15146(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_15147","instance":15147,"id":201818,"goal":"lemma SeqReverseIdem_15147(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_15148","instance":15148,"id":201819,"goal":"lemma SeqMapLen_15148(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_15149","instance":15149,"id":201820,"goal":"lemma SeqFilterLe_15149(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_15150","instance":15150,"id":201821,"goal":"lemma SeqMemberAppend_15150(s: seq, zs: seq)\n ensures x in s + zs <==> x in s || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_15151","instance":15151,"id":201822,"goal":"lemma SeqAppendLen_15151(xs: seq, zs: seq)\n ensures |xs + zs| == |xs| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_15152","instance":15152,"id":201823,"goal":"lemma SeqAppendNil_15152(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_15153","instance":15153,"id":201824,"goal":"lemma SeqNilAppend_15153(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_15154","instance":15154,"id":201825,"goal":"lemma SeqAppendAssoc_15154(ys: seq, zs: seq, t: seq)\n ensures (ys + zs) + t == ys + (zs + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_15155","instance":15155,"id":201826,"goal":"lemma SeqTakeDrop_15155(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_15156","instance":15156,"id":201827,"goal":"lemma SeqReverseLen_15156(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_15157","instance":15157,"id":201828,"goal":"lemma SeqReverseIdem_15157(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_15158","instance":15158,"id":201829,"goal":"lemma SeqMapLen_15158(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_15159","instance":15159,"id":201830,"goal":"lemma SeqFilterLe_15159(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_15160","instance":15160,"id":201831,"goal":"lemma SeqMemberAppend_15160(u: seq, s: seq)\n ensures x in u + s <==> x in u || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_15161","instance":15161,"id":201832,"goal":"lemma SeqAppendLen_15161(zs: seq, s: seq)\n ensures |zs + s| == |zs| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_15162","instance":15162,"id":201833,"goal":"lemma SeqAppendNil_15162(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_15163","instance":15163,"id":201834,"goal":"lemma SeqNilAppend_15163(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_15164","instance":15164,"id":201835,"goal":"lemma SeqAppendAssoc_15164(ys: seq, xs: seq, u: seq)\n ensures (ys + xs) + u == ys + (xs + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_15165","instance":15165,"id":201836,"goal":"lemma SeqTakeDrop_15165(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_15166","instance":15166,"id":201837,"goal":"lemma SeqReverseLen_15166(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_15167","instance":15167,"id":201838,"goal":"lemma SeqReverseIdem_15167(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_15168","instance":15168,"id":201839,"goal":"lemma SeqMapLen_15168(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_15169","instance":15169,"id":201840,"goal":"lemma SeqFilterLe_15169(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_15170","instance":15170,"id":201841,"goal":"lemma SeqMemberAppend_15170(u: seq, zs: seq)\n ensures x in u + zs <==> x in u || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_15171","instance":15171,"id":201842,"goal":"lemma SeqAppendLen_15171(t: seq, u: seq)\n ensures |t + u| == |t| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_15172","instance":15172,"id":201843,"goal":"lemma SeqAppendNil_15172(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_15173","instance":15173,"id":201844,"goal":"lemma SeqNilAppend_15173(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_15174","instance":15174,"id":201845,"goal":"lemma SeqAppendAssoc_15174(xs: seq, s: seq, ys: seq)\n ensures (xs + s) + ys == xs + (s + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_15175","instance":15175,"id":201846,"goal":"lemma SeqTakeDrop_15175(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_15176","instance":15176,"id":201847,"goal":"lemma SeqReverseLen_15176(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_15177","instance":15177,"id":201848,"goal":"lemma SeqReverseIdem_15177(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_15178","instance":15178,"id":201849,"goal":"lemma SeqMapLen_15178(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_15179","instance":15179,"id":201850,"goal":"lemma SeqFilterLe_15179(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_15180","instance":15180,"id":201851,"goal":"lemma SeqMemberAppend_15180(zs: seq, t: seq)\n ensures x in zs + t <==> x in zs || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_15181","instance":15181,"id":201852,"goal":"lemma SeqAppendLen_15181(u: seq, zs: seq)\n ensures |u + zs| == |u| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_15182","instance":15182,"id":201853,"goal":"lemma SeqAppendNil_15182(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_15183","instance":15183,"id":201854,"goal":"lemma SeqNilAppend_15183(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_15184","instance":15184,"id":201855,"goal":"lemma SeqAppendAssoc_15184(xs: seq, s: seq, ys: seq)\n ensures (xs + s) + ys == xs + (s + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_15185","instance":15185,"id":201856,"goal":"lemma SeqTakeDrop_15185(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_15186","instance":15186,"id":201857,"goal":"lemma SeqReverseLen_15186(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_15187","instance":15187,"id":201858,"goal":"lemma SeqReverseIdem_15187(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_15188","instance":15188,"id":201859,"goal":"lemma SeqMapLen_15188(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_15189","instance":15189,"id":201860,"goal":"lemma SeqFilterLe_15189(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_15190","instance":15190,"id":201861,"goal":"lemma SeqMemberAppend_15190(t: seq, xs: seq)\n ensures x in t + xs <==> x in t || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_15191","instance":15191,"id":201862,"goal":"lemma SeqAppendLen_15191(t: seq, zs: seq)\n ensures |t + zs| == |t| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_15192","instance":15192,"id":201863,"goal":"lemma SeqAppendNil_15192(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_15193","instance":15193,"id":201864,"goal":"lemma SeqNilAppend_15193(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_15194","instance":15194,"id":201865,"goal":"lemma SeqAppendAssoc_15194(s: seq, t: seq, xs: seq)\n ensures (s + t) + xs == s + (t + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_15195","instance":15195,"id":201866,"goal":"lemma SeqTakeDrop_15195(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_15196","instance":15196,"id":201867,"goal":"lemma SeqReverseLen_15196(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_15197","instance":15197,"id":201868,"goal":"lemma SeqReverseIdem_15197(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_15198","instance":15198,"id":201869,"goal":"lemma SeqMapLen_15198(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_15199","instance":15199,"id":201870,"goal":"lemma SeqFilterLe_15199(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_15200","instance":15200,"id":201871,"goal":"lemma SeqMemberAppend_15200(t: seq, ys: seq)\n ensures x in t + ys <==> x in t || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_15201","instance":15201,"id":201872,"goal":"lemma SeqAppendLen_15201(s: seq, t: seq)\n ensures |s + t| == |s| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_15202","instance":15202,"id":201873,"goal":"lemma SeqAppendNil_15202(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_15203","instance":15203,"id":201874,"goal":"lemma SeqNilAppend_15203(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_15204","instance":15204,"id":201875,"goal":"lemma SeqAppendAssoc_15204(u: seq, t: seq, s: seq)\n ensures (u + t) + s == u + (t + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_15205","instance":15205,"id":201876,"goal":"lemma SeqTakeDrop_15205(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_15206","instance":15206,"id":201877,"goal":"lemma SeqReverseLen_15206(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_15207","instance":15207,"id":201878,"goal":"lemma SeqReverseIdem_15207(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_15208","instance":15208,"id":201879,"goal":"lemma SeqMapLen_15208(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_15209","instance":15209,"id":201880,"goal":"lemma SeqFilterLe_15209(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_15210","instance":15210,"id":201881,"goal":"lemma SeqMemberAppend_15210(u: seq, ys: seq)\n ensures x in u + ys <==> x in u || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_15211","instance":15211,"id":201882,"goal":"lemma SeqAppendLen_15211(t: seq, u: seq)\n ensures |t + u| == |t| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_15212","instance":15212,"id":201883,"goal":"lemma SeqAppendNil_15212(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_15213","instance":15213,"id":201884,"goal":"lemma SeqNilAppend_15213(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_15214","instance":15214,"id":201885,"goal":"lemma SeqAppendAssoc_15214(s: seq, zs: seq, u: seq)\n ensures (s + zs) + u == s + (zs + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_15215","instance":15215,"id":201886,"goal":"lemma SeqTakeDrop_15215(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_15216","instance":15216,"id":201887,"goal":"lemma SeqReverseLen_15216(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_15217","instance":15217,"id":201888,"goal":"lemma SeqReverseIdem_15217(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_15218","instance":15218,"id":201889,"goal":"lemma SeqMapLen_15218(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_15219","instance":15219,"id":201890,"goal":"lemma SeqFilterLe_15219(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_15220","instance":15220,"id":201891,"goal":"lemma SeqMemberAppend_15220(u: seq, ys: seq)\n ensures x in u + ys <==> x in u || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_15221","instance":15221,"id":201892,"goal":"lemma SeqAppendLen_15221(xs: seq, zs: seq)\n ensures |xs + zs| == |xs| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_15222","instance":15222,"id":201893,"goal":"lemma SeqAppendNil_15222(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_15223","instance":15223,"id":201894,"goal":"lemma SeqNilAppend_15223(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_15224","instance":15224,"id":201895,"goal":"lemma SeqAppendAssoc_15224(s: seq, u: seq, xs: seq)\n ensures (s + u) + xs == s + (u + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_15225","instance":15225,"id":201896,"goal":"lemma SeqTakeDrop_15225(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_15226","instance":15226,"id":201897,"goal":"lemma SeqReverseLen_15226(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_15227","instance":15227,"id":201898,"goal":"lemma SeqReverseIdem_15227(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_15228","instance":15228,"id":201899,"goal":"lemma SeqMapLen_15228(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_15229","instance":15229,"id":201900,"goal":"lemma SeqFilterLe_15229(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_15230","instance":15230,"id":201901,"goal":"lemma SeqMemberAppend_15230(zs: seq, ys: seq)\n ensures x in zs + ys <==> x in zs || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_15231","instance":15231,"id":201902,"goal":"lemma SeqAppendLen_15231(ys: seq, t: seq)\n ensures |ys + t| == |ys| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_15232","instance":15232,"id":201903,"goal":"lemma SeqAppendNil_15232(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_15233","instance":15233,"id":201904,"goal":"lemma SeqNilAppend_15233(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_15234","instance":15234,"id":201905,"goal":"lemma SeqAppendAssoc_15234(ys: seq, xs: seq, zs: seq)\n ensures (ys + xs) + zs == ys + (xs + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_15235","instance":15235,"id":201906,"goal":"lemma SeqTakeDrop_15235(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_15236","instance":15236,"id":201907,"goal":"lemma SeqReverseLen_15236(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_15237","instance":15237,"id":201908,"goal":"lemma SeqReverseIdem_15237(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_15238","instance":15238,"id":201909,"goal":"lemma SeqMapLen_15238(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_15239","instance":15239,"id":201910,"goal":"lemma SeqFilterLe_15239(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_15240","instance":15240,"id":201911,"goal":"lemma SeqMemberAppend_15240(ys: seq, t: seq)\n ensures x in ys + t <==> x in ys || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_15241","instance":15241,"id":201912,"goal":"lemma SeqAppendLen_15241(s: seq, zs: seq)\n ensures |s + zs| == |s| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_15242","instance":15242,"id":201913,"goal":"lemma SeqAppendNil_15242(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_15243","instance":15243,"id":201914,"goal":"lemma SeqNilAppend_15243(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_15244","instance":15244,"id":201915,"goal":"lemma SeqAppendAssoc_15244(xs: seq, ys: seq, u: seq)\n ensures (xs + ys) + u == xs + (ys + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_15245","instance":15245,"id":201916,"goal":"lemma SeqTakeDrop_15245(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_15246","instance":15246,"id":201917,"goal":"lemma SeqReverseLen_15246(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_15247","instance":15247,"id":201918,"goal":"lemma SeqReverseIdem_15247(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_15248","instance":15248,"id":201919,"goal":"lemma SeqMapLen_15248(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_15249","instance":15249,"id":201920,"goal":"lemma SeqFilterLe_15249(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_15250","instance":15250,"id":201921,"goal":"lemma SeqMemberAppend_15250(ys: seq, zs: seq)\n ensures x in ys + zs <==> x in ys || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_15251","instance":15251,"id":201922,"goal":"lemma SeqAppendLen_15251(t: seq, ys: seq)\n ensures |t + ys| == |t| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_15252","instance":15252,"id":201923,"goal":"lemma SeqAppendNil_15252(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_15253","instance":15253,"id":201924,"goal":"lemma SeqNilAppend_15253(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_15254","instance":15254,"id":201925,"goal":"lemma SeqAppendAssoc_15254(zs: seq, t: seq, u: seq)\n ensures (zs + t) + u == zs + (t + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_15255","instance":15255,"id":201926,"goal":"lemma SeqTakeDrop_15255(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_15256","instance":15256,"id":201927,"goal":"lemma SeqReverseLen_15256(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_15257","instance":15257,"id":201928,"goal":"lemma SeqReverseIdem_15257(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_15258","instance":15258,"id":201929,"goal":"lemma SeqMapLen_15258(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_15259","instance":15259,"id":201930,"goal":"lemma SeqFilterLe_15259(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_15260","instance":15260,"id":201931,"goal":"lemma SeqMemberAppend_15260(zs: seq, t: seq)\n ensures x in zs + t <==> x in zs || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_15261","instance":15261,"id":201932,"goal":"lemma SeqAppendLen_15261(ys: seq, u: seq)\n ensures |ys + u| == |ys| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_15262","instance":15262,"id":201933,"goal":"lemma SeqAppendNil_15262(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_15263","instance":15263,"id":201934,"goal":"lemma SeqNilAppend_15263(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_15264","instance":15264,"id":201935,"goal":"lemma SeqAppendAssoc_15264(ys: seq, t: seq, xs: seq)\n ensures (ys + t) + xs == ys + (t + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_15265","instance":15265,"id":201936,"goal":"lemma SeqTakeDrop_15265(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_15266","instance":15266,"id":201937,"goal":"lemma SeqReverseLen_15266(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_15267","instance":15267,"id":201938,"goal":"lemma SeqReverseIdem_15267(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_15268","instance":15268,"id":201939,"goal":"lemma SeqMapLen_15268(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_15269","instance":15269,"id":201940,"goal":"lemma SeqFilterLe_15269(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_15270","instance":15270,"id":201941,"goal":"lemma SeqMemberAppend_15270(ys: seq, t: seq)\n ensures x in ys + t <==> x in ys || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_15271","instance":15271,"id":201942,"goal":"lemma SeqAppendLen_15271(s: seq, xs: seq)\n ensures |s + xs| == |s| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_15272","instance":15272,"id":201943,"goal":"lemma SeqAppendNil_15272(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_15273","instance":15273,"id":201944,"goal":"lemma SeqNilAppend_15273(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_15274","instance":15274,"id":201945,"goal":"lemma SeqAppendAssoc_15274(t: seq, zs: seq, ys: seq)\n ensures (t + zs) + ys == t + (zs + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_15275","instance":15275,"id":201946,"goal":"lemma SeqTakeDrop_15275(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_15276","instance":15276,"id":201947,"goal":"lemma SeqReverseLen_15276(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_15277","instance":15277,"id":201948,"goal":"lemma SeqReverseIdem_15277(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_15278","instance":15278,"id":201949,"goal":"lemma SeqMapLen_15278(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_15279","instance":15279,"id":201950,"goal":"lemma SeqFilterLe_15279(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_15280","instance":15280,"id":201951,"goal":"lemma SeqMemberAppend_15280(u: seq, t: seq)\n ensures x in u + t <==> x in u || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_15281","instance":15281,"id":201952,"goal":"lemma SeqAppendLen_15281(zs: seq, t: seq)\n ensures |zs + t| == |zs| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_15282","instance":15282,"id":201953,"goal":"lemma SeqAppendNil_15282(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_15283","instance":15283,"id":201954,"goal":"lemma SeqNilAppend_15283(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_15284","instance":15284,"id":201955,"goal":"lemma SeqAppendAssoc_15284(ys: seq, t: seq, u: seq)\n ensures (ys + t) + u == ys + (t + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_15285","instance":15285,"id":201956,"goal":"lemma SeqTakeDrop_15285(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_15286","instance":15286,"id":201957,"goal":"lemma SeqReverseLen_15286(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_15287","instance":15287,"id":201958,"goal":"lemma SeqReverseIdem_15287(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_15288","instance":15288,"id":201959,"goal":"lemma SeqMapLen_15288(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_15289","instance":15289,"id":201960,"goal":"lemma SeqFilterLe_15289(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_15290","instance":15290,"id":201961,"goal":"lemma SeqMemberAppend_15290(u: seq, t: seq)\n ensures x in u + t <==> x in u || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_15291","instance":15291,"id":201962,"goal":"lemma SeqAppendLen_15291(zs: seq, u: seq)\n ensures |zs + u| == |zs| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_15292","instance":15292,"id":201963,"goal":"lemma SeqAppendNil_15292(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_15293","instance":15293,"id":201964,"goal":"lemma SeqNilAppend_15293(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_15294","instance":15294,"id":201965,"goal":"lemma SeqAppendAssoc_15294(xs: seq, s: seq, zs: seq)\n ensures (xs + s) + zs == xs + (s + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_15295","instance":15295,"id":201966,"goal":"lemma SeqTakeDrop_15295(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_15296","instance":15296,"id":201967,"goal":"lemma SeqReverseLen_15296(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_15297","instance":15297,"id":201968,"goal":"lemma SeqReverseIdem_15297(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_15298","instance":15298,"id":201969,"goal":"lemma SeqMapLen_15298(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_15299","instance":15299,"id":201970,"goal":"lemma SeqFilterLe_15299(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_15300","instance":15300,"id":201971,"goal":"lemma SeqMemberAppend_15300(t: seq, u: seq)\n ensures x in t + u <==> x in t || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_15301","instance":15301,"id":201972,"goal":"lemma SeqAppendLen_15301(ys: seq, t: seq)\n ensures |ys + t| == |ys| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_15302","instance":15302,"id":201973,"goal":"lemma SeqAppendNil_15302(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_15303","instance":15303,"id":201974,"goal":"lemma SeqNilAppend_15303(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_15304","instance":15304,"id":201975,"goal":"lemma SeqAppendAssoc_15304(xs: seq, u: seq, ys: seq)\n ensures (xs + u) + ys == xs + (u + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_15305","instance":15305,"id":201976,"goal":"lemma SeqTakeDrop_15305(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_15306","instance":15306,"id":201977,"goal":"lemma SeqReverseLen_15306(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_15307","instance":15307,"id":201978,"goal":"lemma SeqReverseIdem_15307(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_15308","instance":15308,"id":201979,"goal":"lemma SeqMapLen_15308(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_15309","instance":15309,"id":201980,"goal":"lemma SeqFilterLe_15309(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_15310","instance":15310,"id":201981,"goal":"lemma SeqMemberAppend_15310(zs: seq, u: seq)\n ensures x in zs + u <==> x in zs || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_15311","instance":15311,"id":201982,"goal":"lemma SeqAppendLen_15311(t: seq, s: seq)\n ensures |t + s| == |t| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_15312","instance":15312,"id":201983,"goal":"lemma SeqAppendNil_15312(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_15313","instance":15313,"id":201984,"goal":"lemma SeqNilAppend_15313(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_15314","instance":15314,"id":201985,"goal":"lemma SeqAppendAssoc_15314(s: seq, t: seq, zs: seq)\n ensures (s + t) + zs == s + (t + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_15315","instance":15315,"id":201986,"goal":"lemma SeqTakeDrop_15315(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_15316","instance":15316,"id":201987,"goal":"lemma SeqReverseLen_15316(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_15317","instance":15317,"id":201988,"goal":"lemma SeqReverseIdem_15317(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_15318","instance":15318,"id":201989,"goal":"lemma SeqMapLen_15318(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_15319","instance":15319,"id":201990,"goal":"lemma SeqFilterLe_15319(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_15320","instance":15320,"id":201991,"goal":"lemma SeqMemberAppend_15320(t: seq, s: seq)\n ensures x in t + s <==> x in t || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_15321","instance":15321,"id":201992,"goal":"lemma SeqAppendLen_15321(t: seq, u: seq)\n ensures |t + u| == |t| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_15322","instance":15322,"id":201993,"goal":"lemma SeqAppendNil_15322(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_15323","instance":15323,"id":201994,"goal":"lemma SeqNilAppend_15323(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_15324","instance":15324,"id":201995,"goal":"lemma SeqAppendAssoc_15324(s: seq, xs: seq, u: seq)\n ensures (s + xs) + u == s + (xs + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_15325","instance":15325,"id":201996,"goal":"lemma SeqTakeDrop_15325(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_15326","instance":15326,"id":201997,"goal":"lemma SeqReverseLen_15326(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_15327","instance":15327,"id":201998,"goal":"lemma SeqReverseIdem_15327(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_15328","instance":15328,"id":201999,"goal":"lemma SeqMapLen_15328(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_15329","instance":15329,"id":202000,"goal":"lemma SeqFilterLe_15329(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_15330","instance":15330,"id":202001,"goal":"lemma SeqMemberAppend_15330(xs: seq, zs: seq)\n ensures x in xs + zs <==> x in xs || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_15331","instance":15331,"id":202002,"goal":"lemma SeqAppendLen_15331(u: seq, zs: seq)\n ensures |u + zs| == |u| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_15332","instance":15332,"id":202003,"goal":"lemma SeqAppendNil_15332(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_15333","instance":15333,"id":202004,"goal":"lemma SeqNilAppend_15333(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_15334","instance":15334,"id":202005,"goal":"lemma SeqAppendAssoc_15334(u: seq, s: seq, xs: seq)\n ensures (u + s) + xs == u + (s + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_15335","instance":15335,"id":202006,"goal":"lemma SeqTakeDrop_15335(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_15336","instance":15336,"id":202007,"goal":"lemma SeqReverseLen_15336(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_15337","instance":15337,"id":202008,"goal":"lemma SeqReverseIdem_15337(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_15338","instance":15338,"id":202009,"goal":"lemma SeqMapLen_15338(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_15339","instance":15339,"id":202010,"goal":"lemma SeqFilterLe_15339(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_15340","instance":15340,"id":202011,"goal":"lemma SeqMemberAppend_15340(s: seq, zs: seq)\n ensures x in s + zs <==> x in s || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_15341","instance":15341,"id":202012,"goal":"lemma SeqAppendLen_15341(xs: seq, t: seq)\n ensures |xs + t| == |xs| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_15342","instance":15342,"id":202013,"goal":"lemma SeqAppendNil_15342(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_15343","instance":15343,"id":202014,"goal":"lemma SeqNilAppend_15343(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_15344","instance":15344,"id":202015,"goal":"lemma SeqAppendAssoc_15344(s: seq, ys: seq, t: seq)\n ensures (s + ys) + t == s + (ys + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_15345","instance":15345,"id":202016,"goal":"lemma SeqTakeDrop_15345(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_15346","instance":15346,"id":202017,"goal":"lemma SeqReverseLen_15346(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_15347","instance":15347,"id":202018,"goal":"lemma SeqReverseIdem_15347(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_15348","instance":15348,"id":202019,"goal":"lemma SeqMapLen_15348(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_15349","instance":15349,"id":202020,"goal":"lemma SeqFilterLe_15349(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_15350","instance":15350,"id":202021,"goal":"lemma SeqMemberAppend_15350(xs: seq, u: seq)\n ensures x in xs + u <==> x in xs || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_15351","instance":15351,"id":202022,"goal":"lemma SeqAppendLen_15351(ys: seq, xs: seq)\n ensures |ys + xs| == |ys| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_15352","instance":15352,"id":202023,"goal":"lemma SeqAppendNil_15352(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_15353","instance":15353,"id":202024,"goal":"lemma SeqNilAppend_15353(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_15354","instance":15354,"id":202025,"goal":"lemma SeqAppendAssoc_15354(zs: seq, s: seq, t: seq)\n ensures (zs + s) + t == zs + (s + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_15355","instance":15355,"id":202026,"goal":"lemma SeqTakeDrop_15355(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_15356","instance":15356,"id":202027,"goal":"lemma SeqReverseLen_15356(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_15357","instance":15357,"id":202028,"goal":"lemma SeqReverseIdem_15357(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_15358","instance":15358,"id":202029,"goal":"lemma SeqMapLen_15358(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_15359","instance":15359,"id":202030,"goal":"lemma SeqFilterLe_15359(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_15360","instance":15360,"id":202031,"goal":"lemma SeqMemberAppend_15360(zs: seq, s: seq)\n ensures x in zs + s <==> x in zs || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_15361","instance":15361,"id":202032,"goal":"lemma SeqAppendLen_15361(t: seq, ys: seq)\n ensures |t + ys| == |t| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_15362","instance":15362,"id":202033,"goal":"lemma SeqAppendNil_15362(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_15363","instance":15363,"id":202034,"goal":"lemma SeqNilAppend_15363(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_15364","instance":15364,"id":202035,"goal":"lemma SeqAppendAssoc_15364(t: seq, s: seq, u: seq)\n ensures (t + s) + u == t + (s + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_15365","instance":15365,"id":202036,"goal":"lemma SeqTakeDrop_15365(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_15366","instance":15366,"id":202037,"goal":"lemma SeqReverseLen_15366(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_15367","instance":15367,"id":202038,"goal":"lemma SeqReverseIdem_15367(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_15368","instance":15368,"id":202039,"goal":"lemma SeqMapLen_15368(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_15369","instance":15369,"id":202040,"goal":"lemma SeqFilterLe_15369(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_15370","instance":15370,"id":202041,"goal":"lemma SeqMemberAppend_15370(u: seq, s: seq)\n ensures x in u + s <==> x in u || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_15371","instance":15371,"id":202042,"goal":"lemma SeqAppendLen_15371(zs: seq, ys: seq)\n ensures |zs + ys| == |zs| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_15372","instance":15372,"id":202043,"goal":"lemma SeqAppendNil_15372(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_15373","instance":15373,"id":202044,"goal":"lemma SeqNilAppend_15373(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_15374","instance":15374,"id":202045,"goal":"lemma SeqAppendAssoc_15374(s: seq, ys: seq, zs: seq)\n ensures (s + ys) + zs == s + (ys + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_15375","instance":15375,"id":202046,"goal":"lemma SeqTakeDrop_15375(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_15376","instance":15376,"id":202047,"goal":"lemma SeqReverseLen_15376(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_15377","instance":15377,"id":202048,"goal":"lemma SeqReverseIdem_15377(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_15378","instance":15378,"id":202049,"goal":"lemma SeqMapLen_15378(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_15379","instance":15379,"id":202050,"goal":"lemma SeqFilterLe_15379(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_15380","instance":15380,"id":202051,"goal":"lemma SeqMemberAppend_15380(u: seq, ys: seq)\n ensures x in u + ys <==> x in u || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_15381","instance":15381,"id":202052,"goal":"lemma SeqAppendLen_15381(u: seq, ys: seq)\n ensures |u + ys| == |u| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_15382","instance":15382,"id":202053,"goal":"lemma SeqAppendNil_15382(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_15383","instance":15383,"id":202054,"goal":"lemma SeqNilAppend_15383(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_15384","instance":15384,"id":202055,"goal":"lemma SeqAppendAssoc_15384(xs: seq, u: seq, t: seq)\n ensures (xs + u) + t == xs + (u + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_15385","instance":15385,"id":202056,"goal":"lemma SeqTakeDrop_15385(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_15386","instance":15386,"id":202057,"goal":"lemma SeqReverseLen_15386(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_15387","instance":15387,"id":202058,"goal":"lemma SeqReverseIdem_15387(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_15388","instance":15388,"id":202059,"goal":"lemma SeqMapLen_15388(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_15389","instance":15389,"id":202060,"goal":"lemma SeqFilterLe_15389(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_15390","instance":15390,"id":202061,"goal":"lemma SeqMemberAppend_15390(u: seq, xs: seq)\n ensures x in u + xs <==> x in u || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_15391","instance":15391,"id":202062,"goal":"lemma SeqAppendLen_15391(xs: seq, u: seq)\n ensures |xs + u| == |xs| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_15392","instance":15392,"id":202063,"goal":"lemma SeqAppendNil_15392(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_15393","instance":15393,"id":202064,"goal":"lemma SeqNilAppend_15393(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_15394","instance":15394,"id":202065,"goal":"lemma SeqAppendAssoc_15394(zs: seq, xs: seq, ys: seq)\n ensures (zs + xs) + ys == zs + (xs + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_15395","instance":15395,"id":202066,"goal":"lemma SeqTakeDrop_15395(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_15396","instance":15396,"id":202067,"goal":"lemma SeqReverseLen_15396(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_15397","instance":15397,"id":202068,"goal":"lemma SeqReverseIdem_15397(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_15398","instance":15398,"id":202069,"goal":"lemma SeqMapLen_15398(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_15399","instance":15399,"id":202070,"goal":"lemma SeqFilterLe_15399(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_15400","instance":15400,"id":202071,"goal":"lemma SeqMemberAppend_15400(xs: seq, t: seq)\n ensures x in xs + t <==> x in xs || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_15401","instance":15401,"id":202072,"goal":"lemma SeqAppendLen_15401(xs: seq, t: seq)\n ensures |xs + t| == |xs| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_15402","instance":15402,"id":202073,"goal":"lemma SeqAppendNil_15402(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_15403","instance":15403,"id":202074,"goal":"lemma SeqNilAppend_15403(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_15404","instance":15404,"id":202075,"goal":"lemma SeqAppendAssoc_15404(ys: seq, u: seq, s: seq)\n ensures (ys + u) + s == ys + (u + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_15405","instance":15405,"id":202076,"goal":"lemma SeqTakeDrop_15405(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_15406","instance":15406,"id":202077,"goal":"lemma SeqReverseLen_15406(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_15407","instance":15407,"id":202078,"goal":"lemma SeqReverseIdem_15407(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_15408","instance":15408,"id":202079,"goal":"lemma SeqMapLen_15408(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_15409","instance":15409,"id":202080,"goal":"lemma SeqFilterLe_15409(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_15410","instance":15410,"id":202081,"goal":"lemma SeqMemberAppend_15410(u: seq, s: seq)\n ensures x in u + s <==> x in u || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_15411","instance":15411,"id":202082,"goal":"lemma SeqAppendLen_15411(s: seq, t: seq)\n ensures |s + t| == |s| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_15412","instance":15412,"id":202083,"goal":"lemma SeqAppendNil_15412(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_15413","instance":15413,"id":202084,"goal":"lemma SeqNilAppend_15413(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_15414","instance":15414,"id":202085,"goal":"lemma SeqAppendAssoc_15414(s: seq, zs: seq, xs: seq)\n ensures (s + zs) + xs == s + (zs + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_15415","instance":15415,"id":202086,"goal":"lemma SeqTakeDrop_15415(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_15416","instance":15416,"id":202087,"goal":"lemma SeqReverseLen_15416(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_15417","instance":15417,"id":202088,"goal":"lemma SeqReverseIdem_15417(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_15418","instance":15418,"id":202089,"goal":"lemma SeqMapLen_15418(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_15419","instance":15419,"id":202090,"goal":"lemma SeqFilterLe_15419(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_15420","instance":15420,"id":202091,"goal":"lemma SeqMemberAppend_15420(xs: seq, s: seq)\n ensures x in xs + s <==> x in xs || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_15421","instance":15421,"id":202092,"goal":"lemma SeqAppendLen_15421(s: seq, t: seq)\n ensures |s + t| == |s| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_15422","instance":15422,"id":202093,"goal":"lemma SeqAppendNil_15422(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_15423","instance":15423,"id":202094,"goal":"lemma SeqNilAppend_15423(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_15424","instance":15424,"id":202095,"goal":"lemma SeqAppendAssoc_15424(t: seq, zs: seq, ys: seq)\n ensures (t + zs) + ys == t + (zs + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_15425","instance":15425,"id":202096,"goal":"lemma SeqTakeDrop_15425(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_15426","instance":15426,"id":202097,"goal":"lemma SeqReverseLen_15426(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_15427","instance":15427,"id":202098,"goal":"lemma SeqReverseIdem_15427(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_15428","instance":15428,"id":202099,"goal":"lemma SeqMapLen_15428(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_15429","instance":15429,"id":202100,"goal":"lemma SeqFilterLe_15429(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_15430","instance":15430,"id":202101,"goal":"lemma SeqMemberAppend_15430(ys: seq, t: seq)\n ensures x in ys + t <==> x in ys || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_15431","instance":15431,"id":202102,"goal":"lemma SeqAppendLen_15431(s: seq, t: seq)\n ensures |s + t| == |s| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_15432","instance":15432,"id":202103,"goal":"lemma SeqAppendNil_15432(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_15433","instance":15433,"id":202104,"goal":"lemma SeqNilAppend_15433(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_15434","instance":15434,"id":202105,"goal":"lemma SeqAppendAssoc_15434(s: seq, t: seq, u: seq)\n ensures (s + t) + u == s + (t + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_15435","instance":15435,"id":202106,"goal":"lemma SeqTakeDrop_15435(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_15436","instance":15436,"id":202107,"goal":"lemma SeqReverseLen_15436(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_15437","instance":15437,"id":202108,"goal":"lemma SeqReverseIdem_15437(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_15438","instance":15438,"id":202109,"goal":"lemma SeqMapLen_15438(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_15439","instance":15439,"id":202110,"goal":"lemma SeqFilterLe_15439(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_15440","instance":15440,"id":202111,"goal":"lemma SeqMemberAppend_15440(zs: seq, ys: seq)\n ensures x in zs + ys <==> x in zs || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_15441","instance":15441,"id":202112,"goal":"lemma SeqAppendLen_15441(u: seq, t: seq)\n ensures |u + t| == |u| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_15442","instance":15442,"id":202113,"goal":"lemma SeqAppendNil_15442(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_15443","instance":15443,"id":202114,"goal":"lemma SeqNilAppend_15443(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_15444","instance":15444,"id":202115,"goal":"lemma SeqAppendAssoc_15444(t: seq, zs: seq, xs: seq)\n ensures (t + zs) + xs == t + (zs + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_15445","instance":15445,"id":202116,"goal":"lemma SeqTakeDrop_15445(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_15446","instance":15446,"id":202117,"goal":"lemma SeqReverseLen_15446(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_15447","instance":15447,"id":202118,"goal":"lemma SeqReverseIdem_15447(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_15448","instance":15448,"id":202119,"goal":"lemma SeqMapLen_15448(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_15449","instance":15449,"id":202120,"goal":"lemma SeqFilterLe_15449(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_15450","instance":15450,"id":202121,"goal":"lemma SeqMemberAppend_15450(xs: seq, ys: seq)\n ensures x in xs + ys <==> x in xs || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_15451","instance":15451,"id":202122,"goal":"lemma SeqAppendLen_15451(zs: seq, u: seq)\n ensures |zs + u| == |zs| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_15452","instance":15452,"id":202123,"goal":"lemma SeqAppendNil_15452(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_15453","instance":15453,"id":202124,"goal":"lemma SeqNilAppend_15453(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_15454","instance":15454,"id":202125,"goal":"lemma SeqAppendAssoc_15454(s: seq, ys: seq, zs: seq)\n ensures (s + ys) + zs == s + (ys + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_15455","instance":15455,"id":202126,"goal":"lemma SeqTakeDrop_15455(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_15456","instance":15456,"id":202127,"goal":"lemma SeqReverseLen_15456(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_15457","instance":15457,"id":202128,"goal":"lemma SeqReverseIdem_15457(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_15458","instance":15458,"id":202129,"goal":"lemma SeqMapLen_15458(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_15459","instance":15459,"id":202130,"goal":"lemma SeqFilterLe_15459(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_15460","instance":15460,"id":202131,"goal":"lemma SeqMemberAppend_15460(s: seq, ys: seq)\n ensures x in s + ys <==> x in s || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_15461","instance":15461,"id":202132,"goal":"lemma SeqAppendLen_15461(xs: seq, u: seq)\n ensures |xs + u| == |xs| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_15462","instance":15462,"id":202133,"goal":"lemma SeqAppendNil_15462(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_15463","instance":15463,"id":202134,"goal":"lemma SeqNilAppend_15463(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_15464","instance":15464,"id":202135,"goal":"lemma SeqAppendAssoc_15464(t: seq, s: seq, u: seq)\n ensures (t + s) + u == t + (s + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_15465","instance":15465,"id":202136,"goal":"lemma SeqTakeDrop_15465(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_15466","instance":15466,"id":202137,"goal":"lemma SeqReverseLen_15466(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_15467","instance":15467,"id":202138,"goal":"lemma SeqReverseIdem_15467(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_15468","instance":15468,"id":202139,"goal":"lemma SeqMapLen_15468(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_15469","instance":15469,"id":202140,"goal":"lemma SeqFilterLe_15469(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_15470","instance":15470,"id":202141,"goal":"lemma SeqMemberAppend_15470(xs: seq, u: seq)\n ensures x in xs + u <==> x in xs || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_15471","instance":15471,"id":202142,"goal":"lemma SeqAppendLen_15471(ys: seq, u: seq)\n ensures |ys + u| == |ys| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_15472","instance":15472,"id":202143,"goal":"lemma SeqAppendNil_15472(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_15473","instance":15473,"id":202144,"goal":"lemma SeqNilAppend_15473(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_15474","instance":15474,"id":202145,"goal":"lemma SeqAppendAssoc_15474(xs: seq, ys: seq, zs: seq)\n ensures (xs + ys) + zs == xs + (ys + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_15475","instance":15475,"id":202146,"goal":"lemma SeqTakeDrop_15475(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_15476","instance":15476,"id":202147,"goal":"lemma SeqReverseLen_15476(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_15477","instance":15477,"id":202148,"goal":"lemma SeqReverseIdem_15477(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_15478","instance":15478,"id":202149,"goal":"lemma SeqMapLen_15478(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_15479","instance":15479,"id":202150,"goal":"lemma SeqFilterLe_15479(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_15480","instance":15480,"id":202151,"goal":"lemma SeqMemberAppend_15480(zs: seq, ys: seq)\n ensures x in zs + ys <==> x in zs || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_15481","instance":15481,"id":202152,"goal":"lemma SeqAppendLen_15481(s: seq, zs: seq)\n ensures |s + zs| == |s| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_15482","instance":15482,"id":202153,"goal":"lemma SeqAppendNil_15482(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_15483","instance":15483,"id":202154,"goal":"lemma SeqNilAppend_15483(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_15484","instance":15484,"id":202155,"goal":"lemma SeqAppendAssoc_15484(u: seq, s: seq, t: seq)\n ensures (u + s) + t == u + (s + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_15485","instance":15485,"id":202156,"goal":"lemma SeqTakeDrop_15485(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_15486","instance":15486,"id":202157,"goal":"lemma SeqReverseLen_15486(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_15487","instance":15487,"id":202158,"goal":"lemma SeqReverseIdem_15487(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_15488","instance":15488,"id":202159,"goal":"lemma SeqMapLen_15488(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_15489","instance":15489,"id":202160,"goal":"lemma SeqFilterLe_15489(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_15490","instance":15490,"id":202161,"goal":"lemma SeqMemberAppend_15490(ys: seq, t: seq)\n ensures x in ys + t <==> x in ys || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_15491","instance":15491,"id":202162,"goal":"lemma SeqAppendLen_15491(zs: seq, u: seq)\n ensures |zs + u| == |zs| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_15492","instance":15492,"id":202163,"goal":"lemma SeqAppendNil_15492(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_15493","instance":15493,"id":202164,"goal":"lemma SeqNilAppend_15493(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_15494","instance":15494,"id":202165,"goal":"lemma SeqAppendAssoc_15494(u: seq, zs: seq, s: seq)\n ensures (u + zs) + s == u + (zs + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_15495","instance":15495,"id":202166,"goal":"lemma SeqTakeDrop_15495(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_15496","instance":15496,"id":202167,"goal":"lemma SeqReverseLen_15496(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_15497","instance":15497,"id":202168,"goal":"lemma SeqReverseIdem_15497(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_15498","instance":15498,"id":202169,"goal":"lemma SeqMapLen_15498(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_15499","instance":15499,"id":202170,"goal":"lemma SeqFilterLe_15499(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_15500","instance":15500,"id":202171,"goal":"lemma SeqMemberAppend_15500(u: seq, s: seq)\n ensures x in u + s <==> x in u || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_15501","instance":15501,"id":202172,"goal":"lemma SeqAppendLen_15501(ys: seq, zs: seq)\n ensures |ys + zs| == |ys| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_15502","instance":15502,"id":202173,"goal":"lemma SeqAppendNil_15502(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_15503","instance":15503,"id":202174,"goal":"lemma SeqNilAppend_15503(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_15504","instance":15504,"id":202175,"goal":"lemma SeqAppendAssoc_15504(xs: seq, ys: seq, zs: seq)\n ensures (xs + ys) + zs == xs + (ys + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_15505","instance":15505,"id":202176,"goal":"lemma SeqTakeDrop_15505(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_15506","instance":15506,"id":202177,"goal":"lemma SeqReverseLen_15506(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_15507","instance":15507,"id":202178,"goal":"lemma SeqReverseIdem_15507(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_15508","instance":15508,"id":202179,"goal":"lemma SeqMapLen_15508(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_15509","instance":15509,"id":202180,"goal":"lemma SeqFilterLe_15509(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_15510","instance":15510,"id":202181,"goal":"lemma SeqMemberAppend_15510(t: seq, ys: seq)\n ensures x in t + ys <==> x in t || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_15511","instance":15511,"id":202182,"goal":"lemma SeqAppendLen_15511(s: seq, u: seq)\n ensures |s + u| == |s| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_15512","instance":15512,"id":202183,"goal":"lemma SeqAppendNil_15512(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_15513","instance":15513,"id":202184,"goal":"lemma SeqNilAppend_15513(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_15514","instance":15514,"id":202185,"goal":"lemma SeqAppendAssoc_15514(xs: seq, ys: seq, t: seq)\n ensures (xs + ys) + t == xs + (ys + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_15515","instance":15515,"id":202186,"goal":"lemma SeqTakeDrop_15515(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_15516","instance":15516,"id":202187,"goal":"lemma SeqReverseLen_15516(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_15517","instance":15517,"id":202188,"goal":"lemma SeqReverseIdem_15517(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_15518","instance":15518,"id":202189,"goal":"lemma SeqMapLen_15518(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_15519","instance":15519,"id":202190,"goal":"lemma SeqFilterLe_15519(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_15520","instance":15520,"id":202191,"goal":"lemma SeqMemberAppend_15520(s: seq, ys: seq)\n ensures x in s + ys <==> x in s || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_15521","instance":15521,"id":202192,"goal":"lemma SeqAppendLen_15521(ys: seq, zs: seq)\n ensures |ys + zs| == |ys| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_15522","instance":15522,"id":202193,"goal":"lemma SeqAppendNil_15522(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_15523","instance":15523,"id":202194,"goal":"lemma SeqNilAppend_15523(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_15524","instance":15524,"id":202195,"goal":"lemma SeqAppendAssoc_15524(s: seq, zs: seq, xs: seq)\n ensures (s + zs) + xs == s + (zs + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_15525","instance":15525,"id":202196,"goal":"lemma SeqTakeDrop_15525(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_15526","instance":15526,"id":202197,"goal":"lemma SeqReverseLen_15526(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_15527","instance":15527,"id":202198,"goal":"lemma SeqReverseIdem_15527(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_15528","instance":15528,"id":202199,"goal":"lemma SeqMapLen_15528(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_15529","instance":15529,"id":202200,"goal":"lemma SeqFilterLe_15529(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_15530","instance":15530,"id":202201,"goal":"lemma SeqMemberAppend_15530(t: seq, u: seq)\n ensures x in t + u <==> x in t || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_15531","instance":15531,"id":202202,"goal":"lemma SeqAppendLen_15531(t: seq, ys: seq)\n ensures |t + ys| == |t| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_15532","instance":15532,"id":202203,"goal":"lemma SeqAppendNil_15532(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_15533","instance":15533,"id":202204,"goal":"lemma SeqNilAppend_15533(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_15534","instance":15534,"id":202205,"goal":"lemma SeqAppendAssoc_15534(t: seq, xs: seq, s: seq)\n ensures (t + xs) + s == t + (xs + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_15535","instance":15535,"id":202206,"goal":"lemma SeqTakeDrop_15535(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_15536","instance":15536,"id":202207,"goal":"lemma SeqReverseLen_15536(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_15537","instance":15537,"id":202208,"goal":"lemma SeqReverseIdem_15537(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_15538","instance":15538,"id":202209,"goal":"lemma SeqMapLen_15538(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_15539","instance":15539,"id":202210,"goal":"lemma SeqFilterLe_15539(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_15540","instance":15540,"id":202211,"goal":"lemma SeqMemberAppend_15540(u: seq, ys: seq)\n ensures x in u + ys <==> x in u || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_15541","instance":15541,"id":202212,"goal":"lemma SeqAppendLen_15541(ys: seq, t: seq)\n ensures |ys + t| == |ys| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_15542","instance":15542,"id":202213,"goal":"lemma SeqAppendNil_15542(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_15543","instance":15543,"id":202214,"goal":"lemma SeqNilAppend_15543(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_15544","instance":15544,"id":202215,"goal":"lemma SeqAppendAssoc_15544(u: seq, t: seq, s: seq)\n ensures (u + t) + s == u + (t + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_15545","instance":15545,"id":202216,"goal":"lemma SeqTakeDrop_15545(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_15546","instance":15546,"id":202217,"goal":"lemma SeqReverseLen_15546(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_15547","instance":15547,"id":202218,"goal":"lemma SeqReverseIdem_15547(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_15548","instance":15548,"id":202219,"goal":"lemma SeqMapLen_15548(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_15549","instance":15549,"id":202220,"goal":"lemma SeqFilterLe_15549(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_15550","instance":15550,"id":202221,"goal":"lemma SeqMemberAppend_15550(ys: seq, u: seq)\n ensures x in ys + u <==> x in ys || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_15551","instance":15551,"id":202222,"goal":"lemma SeqAppendLen_15551(s: seq, u: seq)\n ensures |s + u| == |s| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_15552","instance":15552,"id":202223,"goal":"lemma SeqAppendNil_15552(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_15553","instance":15553,"id":202224,"goal":"lemma SeqNilAppend_15553(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_15554","instance":15554,"id":202225,"goal":"lemma SeqAppendAssoc_15554(ys: seq, u: seq, s: seq)\n ensures (ys + u) + s == ys + (u + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_15555","instance":15555,"id":202226,"goal":"lemma SeqTakeDrop_15555(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_15556","instance":15556,"id":202227,"goal":"lemma SeqReverseLen_15556(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_15557","instance":15557,"id":202228,"goal":"lemma SeqReverseIdem_15557(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_15558","instance":15558,"id":202229,"goal":"lemma SeqMapLen_15558(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_15559","instance":15559,"id":202230,"goal":"lemma SeqFilterLe_15559(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_15560","instance":15560,"id":202231,"goal":"lemma SeqMemberAppend_15560(zs: seq, ys: seq)\n ensures x in zs + ys <==> x in zs || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_15561","instance":15561,"id":202232,"goal":"lemma SeqAppendLen_15561(s: seq, xs: seq)\n ensures |s + xs| == |s| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_15562","instance":15562,"id":202233,"goal":"lemma SeqAppendNil_15562(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_15563","instance":15563,"id":202234,"goal":"lemma SeqNilAppend_15563(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_15564","instance":15564,"id":202235,"goal":"lemma SeqAppendAssoc_15564(xs: seq, t: seq, zs: seq)\n ensures (xs + t) + zs == xs + (t + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_15565","instance":15565,"id":202236,"goal":"lemma SeqTakeDrop_15565(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_15566","instance":15566,"id":202237,"goal":"lemma SeqReverseLen_15566(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_15567","instance":15567,"id":202238,"goal":"lemma SeqReverseIdem_15567(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_15568","instance":15568,"id":202239,"goal":"lemma SeqMapLen_15568(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_15569","instance":15569,"id":202240,"goal":"lemma SeqFilterLe_15569(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_15570","instance":15570,"id":202241,"goal":"lemma SeqMemberAppend_15570(zs: seq, xs: seq)\n ensures x in zs + xs <==> x in zs || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_15571","instance":15571,"id":202242,"goal":"lemma SeqAppendLen_15571(zs: seq, s: seq)\n ensures |zs + s| == |zs| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_15572","instance":15572,"id":202243,"goal":"lemma SeqAppendNil_15572(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_15573","instance":15573,"id":202244,"goal":"lemma SeqNilAppend_15573(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_15574","instance":15574,"id":202245,"goal":"lemma SeqAppendAssoc_15574(t: seq, zs: seq, ys: seq)\n ensures (t + zs) + ys == t + (zs + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_15575","instance":15575,"id":202246,"goal":"lemma SeqTakeDrop_15575(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_15576","instance":15576,"id":202247,"goal":"lemma SeqReverseLen_15576(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_15577","instance":15577,"id":202248,"goal":"lemma SeqReverseIdem_15577(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_15578","instance":15578,"id":202249,"goal":"lemma SeqMapLen_15578(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_15579","instance":15579,"id":202250,"goal":"lemma SeqFilterLe_15579(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_15580","instance":15580,"id":202251,"goal":"lemma SeqMemberAppend_15580(s: seq, ys: seq)\n ensures x in s + ys <==> x in s || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_15581","instance":15581,"id":202252,"goal":"lemma SeqAppendLen_15581(t: seq, ys: seq)\n ensures |t + ys| == |t| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_15582","instance":15582,"id":202253,"goal":"lemma SeqAppendNil_15582(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_15583","instance":15583,"id":202254,"goal":"lemma SeqNilAppend_15583(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_15584","instance":15584,"id":202255,"goal":"lemma SeqAppendAssoc_15584(u: seq, ys: seq, zs: seq)\n ensures (u + ys) + zs == u + (ys + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_15585","instance":15585,"id":202256,"goal":"lemma SeqTakeDrop_15585(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_15586","instance":15586,"id":202257,"goal":"lemma SeqReverseLen_15586(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_15587","instance":15587,"id":202258,"goal":"lemma SeqReverseIdem_15587(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_15588","instance":15588,"id":202259,"goal":"lemma SeqMapLen_15588(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_15589","instance":15589,"id":202260,"goal":"lemma SeqFilterLe_15589(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_15590","instance":15590,"id":202261,"goal":"lemma SeqMemberAppend_15590(t: seq, u: seq)\n ensures x in t + u <==> x in t || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_15591","instance":15591,"id":202262,"goal":"lemma SeqAppendLen_15591(zs: seq, u: seq)\n ensures |zs + u| == |zs| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_15592","instance":15592,"id":202263,"goal":"lemma SeqAppendNil_15592(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_15593","instance":15593,"id":202264,"goal":"lemma SeqNilAppend_15593(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_15594","instance":15594,"id":202265,"goal":"lemma SeqAppendAssoc_15594(zs: seq, u: seq, t: seq)\n ensures (zs + u) + t == zs + (u + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_15595","instance":15595,"id":202266,"goal":"lemma SeqTakeDrop_15595(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_15596","instance":15596,"id":202267,"goal":"lemma SeqReverseLen_15596(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_15597","instance":15597,"id":202268,"goal":"lemma SeqReverseIdem_15597(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_15598","instance":15598,"id":202269,"goal":"lemma SeqMapLen_15598(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_15599","instance":15599,"id":202270,"goal":"lemma SeqFilterLe_15599(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_15600","instance":15600,"id":202271,"goal":"lemma SeqMemberAppend_15600(zs: seq, u: seq)\n ensures x in zs + u <==> x in zs || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_15601","instance":15601,"id":202272,"goal":"lemma SeqAppendLen_15601(s: seq, zs: seq)\n ensures |s + zs| == |s| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_15602","instance":15602,"id":202273,"goal":"lemma SeqAppendNil_15602(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_15603","instance":15603,"id":202274,"goal":"lemma SeqNilAppend_15603(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_15604","instance":15604,"id":202275,"goal":"lemma SeqAppendAssoc_15604(u: seq, xs: seq, t: seq)\n ensures (u + xs) + t == u + (xs + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_15605","instance":15605,"id":202276,"goal":"lemma SeqTakeDrop_15605(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_15606","instance":15606,"id":202277,"goal":"lemma SeqReverseLen_15606(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_15607","instance":15607,"id":202278,"goal":"lemma SeqReverseIdem_15607(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_15608","instance":15608,"id":202279,"goal":"lemma SeqMapLen_15608(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_15609","instance":15609,"id":202280,"goal":"lemma SeqFilterLe_15609(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_15610","instance":15610,"id":202281,"goal":"lemma SeqMemberAppend_15610(t: seq, xs: seq)\n ensures x in t + xs <==> x in t || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_15611","instance":15611,"id":202282,"goal":"lemma SeqAppendLen_15611(u: seq, t: seq)\n ensures |u + t| == |u| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_15612","instance":15612,"id":202283,"goal":"lemma SeqAppendNil_15612(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_15613","instance":15613,"id":202284,"goal":"lemma SeqNilAppend_15613(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_15614","instance":15614,"id":202285,"goal":"lemma SeqAppendAssoc_15614(ys: seq, zs: seq, s: seq)\n ensures (ys + zs) + s == ys + (zs + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_15615","instance":15615,"id":202286,"goal":"lemma SeqTakeDrop_15615(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_15616","instance":15616,"id":202287,"goal":"lemma SeqReverseLen_15616(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_15617","instance":15617,"id":202288,"goal":"lemma SeqReverseIdem_15617(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_15618","instance":15618,"id":202289,"goal":"lemma SeqMapLen_15618(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_15619","instance":15619,"id":202290,"goal":"lemma SeqFilterLe_15619(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_15620","instance":15620,"id":202291,"goal":"lemma SeqMemberAppend_15620(xs: seq, s: seq)\n ensures x in xs + s <==> x in xs || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_15621","instance":15621,"id":202292,"goal":"lemma SeqAppendLen_15621(t: seq, zs: seq)\n ensures |t + zs| == |t| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_15622","instance":15622,"id":202293,"goal":"lemma SeqAppendNil_15622(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_15623","instance":15623,"id":202294,"goal":"lemma SeqNilAppend_15623(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_15624","instance":15624,"id":202295,"goal":"lemma SeqAppendAssoc_15624(u: seq, ys: seq, s: seq)\n ensures (u + ys) + s == u + (ys + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_15625","instance":15625,"id":202296,"goal":"lemma SeqTakeDrop_15625(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_15626","instance":15626,"id":202297,"goal":"lemma SeqReverseLen_15626(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_15627","instance":15627,"id":202298,"goal":"lemma SeqReverseIdem_15627(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_15628","instance":15628,"id":202299,"goal":"lemma SeqMapLen_15628(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_15629","instance":15629,"id":202300,"goal":"lemma SeqFilterLe_15629(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_15630","instance":15630,"id":202301,"goal":"lemma SeqMemberAppend_15630(t: seq, zs: seq)\n ensures x in t + zs <==> x in t || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_15631","instance":15631,"id":202302,"goal":"lemma SeqAppendLen_15631(xs: seq, ys: seq)\n ensures |xs + ys| == |xs| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_15632","instance":15632,"id":202303,"goal":"lemma SeqAppendNil_15632(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_15633","instance":15633,"id":202304,"goal":"lemma SeqNilAppend_15633(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_15634","instance":15634,"id":202305,"goal":"lemma SeqAppendAssoc_15634(u: seq, xs: seq, t: seq)\n ensures (u + xs) + t == u + (xs + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_15635","instance":15635,"id":202306,"goal":"lemma SeqTakeDrop_15635(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_15636","instance":15636,"id":202307,"goal":"lemma SeqReverseLen_15636(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_15637","instance":15637,"id":202308,"goal":"lemma SeqReverseIdem_15637(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_15638","instance":15638,"id":202309,"goal":"lemma SeqMapLen_15638(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_15639","instance":15639,"id":202310,"goal":"lemma SeqFilterLe_15639(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_15640","instance":15640,"id":202311,"goal":"lemma SeqMemberAppend_15640(t: seq, xs: seq)\n ensures x in t + xs <==> x in t || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_15641","instance":15641,"id":202312,"goal":"lemma SeqAppendLen_15641(t: seq, u: seq)\n ensures |t + u| == |t| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_15642","instance":15642,"id":202313,"goal":"lemma SeqAppendNil_15642(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_15643","instance":15643,"id":202314,"goal":"lemma SeqNilAppend_15643(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_15644","instance":15644,"id":202315,"goal":"lemma SeqAppendAssoc_15644(s: seq, ys: seq, t: seq)\n ensures (s + ys) + t == s + (ys + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_15645","instance":15645,"id":202316,"goal":"lemma SeqTakeDrop_15645(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_15646","instance":15646,"id":202317,"goal":"lemma SeqReverseLen_15646(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_15647","instance":15647,"id":202318,"goal":"lemma SeqReverseIdem_15647(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_15648","instance":15648,"id":202319,"goal":"lemma SeqMapLen_15648(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_15649","instance":15649,"id":202320,"goal":"lemma SeqFilterLe_15649(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_15650","instance":15650,"id":202321,"goal":"lemma SeqMemberAppend_15650(u: seq, ys: seq)\n ensures x in u + ys <==> x in u || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_15651","instance":15651,"id":202322,"goal":"lemma SeqAppendLen_15651(u: seq, zs: seq)\n ensures |u + zs| == |u| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_15652","instance":15652,"id":202323,"goal":"lemma SeqAppendNil_15652(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_15653","instance":15653,"id":202324,"goal":"lemma SeqNilAppend_15653(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_15654","instance":15654,"id":202325,"goal":"lemma SeqAppendAssoc_15654(t: seq, ys: seq, xs: seq)\n ensures (t + ys) + xs == t + (ys + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_15655","instance":15655,"id":202326,"goal":"lemma SeqTakeDrop_15655(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_15656","instance":15656,"id":202327,"goal":"lemma SeqReverseLen_15656(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_15657","instance":15657,"id":202328,"goal":"lemma SeqReverseIdem_15657(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_15658","instance":15658,"id":202329,"goal":"lemma SeqMapLen_15658(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_15659","instance":15659,"id":202330,"goal":"lemma SeqFilterLe_15659(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_15660","instance":15660,"id":202331,"goal":"lemma SeqMemberAppend_15660(xs: seq, ys: seq)\n ensures x in xs + ys <==> x in xs || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_15661","instance":15661,"id":202332,"goal":"lemma SeqAppendLen_15661(t: seq, ys: seq)\n ensures |t + ys| == |t| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_15662","instance":15662,"id":202333,"goal":"lemma SeqAppendNil_15662(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_15663","instance":15663,"id":202334,"goal":"lemma SeqNilAppend_15663(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_15664","instance":15664,"id":202335,"goal":"lemma SeqAppendAssoc_15664(t: seq, ys: seq, s: seq)\n ensures (t + ys) + s == t + (ys + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_15665","instance":15665,"id":202336,"goal":"lemma SeqTakeDrop_15665(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_15666","instance":15666,"id":202337,"goal":"lemma SeqReverseLen_15666(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_15667","instance":15667,"id":202338,"goal":"lemma SeqReverseIdem_15667(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_15668","instance":15668,"id":202339,"goal":"lemma SeqMapLen_15668(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_15669","instance":15669,"id":202340,"goal":"lemma SeqFilterLe_15669(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_15670","instance":15670,"id":202341,"goal":"lemma SeqMemberAppend_15670(zs: seq, t: seq)\n ensures x in zs + t <==> x in zs || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_15671","instance":15671,"id":202342,"goal":"lemma SeqAppendLen_15671(t: seq, u: seq)\n ensures |t + u| == |t| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_15672","instance":15672,"id":202343,"goal":"lemma SeqAppendNil_15672(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_15673","instance":15673,"id":202344,"goal":"lemma SeqNilAppend_15673(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_15674","instance":15674,"id":202345,"goal":"lemma SeqAppendAssoc_15674(xs: seq, ys: seq, s: seq)\n ensures (xs + ys) + s == xs + (ys + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_15675","instance":15675,"id":202346,"goal":"lemma SeqTakeDrop_15675(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_15676","instance":15676,"id":202347,"goal":"lemma SeqReverseLen_15676(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_15677","instance":15677,"id":202348,"goal":"lemma SeqReverseIdem_15677(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_15678","instance":15678,"id":202349,"goal":"lemma SeqMapLen_15678(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_15679","instance":15679,"id":202350,"goal":"lemma SeqFilterLe_15679(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_15680","instance":15680,"id":202351,"goal":"lemma SeqMemberAppend_15680(xs: seq, ys: seq)\n ensures x in xs + ys <==> x in xs || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_15681","instance":15681,"id":202352,"goal":"lemma SeqAppendLen_15681(ys: seq, s: seq)\n ensures |ys + s| == |ys| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_15682","instance":15682,"id":202353,"goal":"lemma SeqAppendNil_15682(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_15683","instance":15683,"id":202354,"goal":"lemma SeqNilAppend_15683(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_15684","instance":15684,"id":202355,"goal":"lemma SeqAppendAssoc_15684(t: seq, ys: seq, u: seq)\n ensures (t + ys) + u == t + (ys + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_15685","instance":15685,"id":202356,"goal":"lemma SeqTakeDrop_15685(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_15686","instance":15686,"id":202357,"goal":"lemma SeqReverseLen_15686(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_15687","instance":15687,"id":202358,"goal":"lemma SeqReverseIdem_15687(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_15688","instance":15688,"id":202359,"goal":"lemma SeqMapLen_15688(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_15689","instance":15689,"id":202360,"goal":"lemma SeqFilterLe_15689(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_15690","instance":15690,"id":202361,"goal":"lemma SeqMemberAppend_15690(u: seq, s: seq)\n ensures x in u + s <==> x in u || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_15691","instance":15691,"id":202362,"goal":"lemma SeqAppendLen_15691(xs: seq, u: seq)\n ensures |xs + u| == |xs| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_15692","instance":15692,"id":202363,"goal":"lemma SeqAppendNil_15692(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_15693","instance":15693,"id":202364,"goal":"lemma SeqNilAppend_15693(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_15694","instance":15694,"id":202365,"goal":"lemma SeqAppendAssoc_15694(ys: seq, s: seq, zs: seq)\n ensures (ys + s) + zs == ys + (s + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_15695","instance":15695,"id":202366,"goal":"lemma SeqTakeDrop_15695(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_15696","instance":15696,"id":202367,"goal":"lemma SeqReverseLen_15696(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_15697","instance":15697,"id":202368,"goal":"lemma SeqReverseIdem_15697(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_15698","instance":15698,"id":202369,"goal":"lemma SeqMapLen_15698(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_15699","instance":15699,"id":202370,"goal":"lemma SeqFilterLe_15699(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_15700","instance":15700,"id":202371,"goal":"lemma SeqMemberAppend_15700(s: seq, t: seq)\n ensures x in s + t <==> x in s || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_15701","instance":15701,"id":202372,"goal":"lemma SeqAppendLen_15701(zs: seq, t: seq)\n ensures |zs + t| == |zs| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_15702","instance":15702,"id":202373,"goal":"lemma SeqAppendNil_15702(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_15703","instance":15703,"id":202374,"goal":"lemma SeqNilAppend_15703(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_15704","instance":15704,"id":202375,"goal":"lemma SeqAppendAssoc_15704(ys: seq, t: seq, u: seq)\n ensures (ys + t) + u == ys + (t + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_15705","instance":15705,"id":202376,"goal":"lemma SeqTakeDrop_15705(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_15706","instance":15706,"id":202377,"goal":"lemma SeqReverseLen_15706(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_15707","instance":15707,"id":202378,"goal":"lemma SeqReverseIdem_15707(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_15708","instance":15708,"id":202379,"goal":"lemma SeqMapLen_15708(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_15709","instance":15709,"id":202380,"goal":"lemma SeqFilterLe_15709(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_15710","instance":15710,"id":202381,"goal":"lemma SeqMemberAppend_15710(t: seq, s: seq)\n ensures x in t + s <==> x in t || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_15711","instance":15711,"id":202382,"goal":"lemma SeqAppendLen_15711(s: seq, t: seq)\n ensures |s + t| == |s| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_15712","instance":15712,"id":202383,"goal":"lemma SeqAppendNil_15712(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_15713","instance":15713,"id":202384,"goal":"lemma SeqNilAppend_15713(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_15714","instance":15714,"id":202385,"goal":"lemma SeqAppendAssoc_15714(ys: seq, u: seq, xs: seq)\n ensures (ys + u) + xs == ys + (u + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_15715","instance":15715,"id":202386,"goal":"lemma SeqTakeDrop_15715(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_15716","instance":15716,"id":202387,"goal":"lemma SeqReverseLen_15716(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_15717","instance":15717,"id":202388,"goal":"lemma SeqReverseIdem_15717(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_15718","instance":15718,"id":202389,"goal":"lemma SeqMapLen_15718(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_15719","instance":15719,"id":202390,"goal":"lemma SeqFilterLe_15719(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_15720","instance":15720,"id":202391,"goal":"lemma SeqMemberAppend_15720(ys: seq, xs: seq)\n ensures x in ys + xs <==> x in ys || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_15721","instance":15721,"id":202392,"goal":"lemma SeqAppendLen_15721(xs: seq, ys: seq)\n ensures |xs + ys| == |xs| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_15722","instance":15722,"id":202393,"goal":"lemma SeqAppendNil_15722(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_15723","instance":15723,"id":202394,"goal":"lemma SeqNilAppend_15723(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_15724","instance":15724,"id":202395,"goal":"lemma SeqAppendAssoc_15724(u: seq, s: seq, t: seq)\n ensures (u + s) + t == u + (s + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_15725","instance":15725,"id":202396,"goal":"lemma SeqTakeDrop_15725(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_15726","instance":15726,"id":202397,"goal":"lemma SeqReverseLen_15726(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_15727","instance":15727,"id":202398,"goal":"lemma SeqReverseIdem_15727(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_15728","instance":15728,"id":202399,"goal":"lemma SeqMapLen_15728(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_15729","instance":15729,"id":202400,"goal":"lemma SeqFilterLe_15729(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_15730","instance":15730,"id":202401,"goal":"lemma SeqMemberAppend_15730(t: seq, ys: seq)\n ensures x in t + ys <==> x in t || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_15731","instance":15731,"id":202402,"goal":"lemma SeqAppendLen_15731(xs: seq, zs: seq)\n ensures |xs + zs| == |xs| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_15732","instance":15732,"id":202403,"goal":"lemma SeqAppendNil_15732(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_15733","instance":15733,"id":202404,"goal":"lemma SeqNilAppend_15733(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_15734","instance":15734,"id":202405,"goal":"lemma SeqAppendAssoc_15734(s: seq, ys: seq, xs: seq)\n ensures (s + ys) + xs == s + (ys + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_15735","instance":15735,"id":202406,"goal":"lemma SeqTakeDrop_15735(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_15736","instance":15736,"id":202407,"goal":"lemma SeqReverseLen_15736(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_15737","instance":15737,"id":202408,"goal":"lemma SeqReverseIdem_15737(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_15738","instance":15738,"id":202409,"goal":"lemma SeqMapLen_15738(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_15739","instance":15739,"id":202410,"goal":"lemma SeqFilterLe_15739(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_15740","instance":15740,"id":202411,"goal":"lemma SeqMemberAppend_15740(t: seq, u: seq)\n ensures x in t + u <==> x in t || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_15741","instance":15741,"id":202412,"goal":"lemma SeqAppendLen_15741(zs: seq, ys: seq)\n ensures |zs + ys| == |zs| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_15742","instance":15742,"id":202413,"goal":"lemma SeqAppendNil_15742(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_15743","instance":15743,"id":202414,"goal":"lemma SeqNilAppend_15743(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_15744","instance":15744,"id":202415,"goal":"lemma SeqAppendAssoc_15744(s: seq, u: seq, xs: seq)\n ensures (s + u) + xs == s + (u + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_15745","instance":15745,"id":202416,"goal":"lemma SeqTakeDrop_15745(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_15746","instance":15746,"id":202417,"goal":"lemma SeqReverseLen_15746(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_15747","instance":15747,"id":202418,"goal":"lemma SeqReverseIdem_15747(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_15748","instance":15748,"id":202419,"goal":"lemma SeqMapLen_15748(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_15749","instance":15749,"id":202420,"goal":"lemma SeqFilterLe_15749(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_15750","instance":15750,"id":202421,"goal":"lemma SeqMemberAppend_15750(xs: seq, t: seq)\n ensures x in xs + t <==> x in xs || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_15751","instance":15751,"id":202422,"goal":"lemma SeqAppendLen_15751(xs: seq, s: seq)\n ensures |xs + s| == |xs| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_15752","instance":15752,"id":202423,"goal":"lemma SeqAppendNil_15752(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_15753","instance":15753,"id":202424,"goal":"lemma SeqNilAppend_15753(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_15754","instance":15754,"id":202425,"goal":"lemma SeqAppendAssoc_15754(xs: seq, u: seq, ys: seq)\n ensures (xs + u) + ys == xs + (u + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_15755","instance":15755,"id":202426,"goal":"lemma SeqTakeDrop_15755(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_15756","instance":15756,"id":202427,"goal":"lemma SeqReverseLen_15756(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_15757","instance":15757,"id":202428,"goal":"lemma SeqReverseIdem_15757(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_15758","instance":15758,"id":202429,"goal":"lemma SeqMapLen_15758(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_15759","instance":15759,"id":202430,"goal":"lemma SeqFilterLe_15759(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_15760","instance":15760,"id":202431,"goal":"lemma SeqMemberAppend_15760(ys: seq, zs: seq)\n ensures x in ys + zs <==> x in ys || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_15761","instance":15761,"id":202432,"goal":"lemma SeqAppendLen_15761(u: seq, xs: seq)\n ensures |u + xs| == |u| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_15762","instance":15762,"id":202433,"goal":"lemma SeqAppendNil_15762(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_15763","instance":15763,"id":202434,"goal":"lemma SeqNilAppend_15763(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_15764","instance":15764,"id":202435,"goal":"lemma SeqAppendAssoc_15764(u: seq, ys: seq, xs: seq)\n ensures (u + ys) + xs == u + (ys + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_15765","instance":15765,"id":202436,"goal":"lemma SeqTakeDrop_15765(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_15766","instance":15766,"id":202437,"goal":"lemma SeqReverseLen_15766(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_15767","instance":15767,"id":202438,"goal":"lemma SeqReverseIdem_15767(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_15768","instance":15768,"id":202439,"goal":"lemma SeqMapLen_15768(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_15769","instance":15769,"id":202440,"goal":"lemma SeqFilterLe_15769(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_15770","instance":15770,"id":202441,"goal":"lemma SeqMemberAppend_15770(zs: seq, s: seq)\n ensures x in zs + s <==> x in zs || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_15771","instance":15771,"id":202442,"goal":"lemma SeqAppendLen_15771(s: seq, t: seq)\n ensures |s + t| == |s| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_15772","instance":15772,"id":202443,"goal":"lemma SeqAppendNil_15772(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_15773","instance":15773,"id":202444,"goal":"lemma SeqNilAppend_15773(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_15774","instance":15774,"id":202445,"goal":"lemma SeqAppendAssoc_15774(s: seq, t: seq, xs: seq)\n ensures (s + t) + xs == s + (t + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_15775","instance":15775,"id":202446,"goal":"lemma SeqTakeDrop_15775(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_15776","instance":15776,"id":202447,"goal":"lemma SeqReverseLen_15776(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_15777","instance":15777,"id":202448,"goal":"lemma SeqReverseIdem_15777(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_15778","instance":15778,"id":202449,"goal":"lemma SeqMapLen_15778(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_15779","instance":15779,"id":202450,"goal":"lemma SeqFilterLe_15779(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_15780","instance":15780,"id":202451,"goal":"lemma SeqMemberAppend_15780(t: seq, s: seq)\n ensures x in t + s <==> x in t || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_15781","instance":15781,"id":202452,"goal":"lemma SeqAppendLen_15781(xs: seq, u: seq)\n ensures |xs + u| == |xs| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_15782","instance":15782,"id":202453,"goal":"lemma SeqAppendNil_15782(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_15783","instance":15783,"id":202454,"goal":"lemma SeqNilAppend_15783(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_15784","instance":15784,"id":202455,"goal":"lemma SeqAppendAssoc_15784(zs: seq, t: seq, xs: seq)\n ensures (zs + t) + xs == zs + (t + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_15785","instance":15785,"id":202456,"goal":"lemma SeqTakeDrop_15785(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_15786","instance":15786,"id":202457,"goal":"lemma SeqReverseLen_15786(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_15787","instance":15787,"id":202458,"goal":"lemma SeqReverseIdem_15787(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_15788","instance":15788,"id":202459,"goal":"lemma SeqMapLen_15788(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_15789","instance":15789,"id":202460,"goal":"lemma SeqFilterLe_15789(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_15790","instance":15790,"id":202461,"goal":"lemma SeqMemberAppend_15790(xs: seq, u: seq)\n ensures x in xs + u <==> x in xs || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_15791","instance":15791,"id":202462,"goal":"lemma SeqAppendLen_15791(u: seq, ys: seq)\n ensures |u + ys| == |u| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_15792","instance":15792,"id":202463,"goal":"lemma SeqAppendNil_15792(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_15793","instance":15793,"id":202464,"goal":"lemma SeqNilAppend_15793(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_15794","instance":15794,"id":202465,"goal":"lemma SeqAppendAssoc_15794(xs: seq, ys: seq, u: seq)\n ensures (xs + ys) + u == xs + (ys + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_15795","instance":15795,"id":202466,"goal":"lemma SeqTakeDrop_15795(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_15796","instance":15796,"id":202467,"goal":"lemma SeqReverseLen_15796(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_15797","instance":15797,"id":202468,"goal":"lemma SeqReverseIdem_15797(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_15798","instance":15798,"id":202469,"goal":"lemma SeqMapLen_15798(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_15799","instance":15799,"id":202470,"goal":"lemma SeqFilterLe_15799(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_15800","instance":15800,"id":202471,"goal":"lemma SeqMemberAppend_15800(s: seq, xs: seq)\n ensures x in s + xs <==> x in s || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_15801","instance":15801,"id":202472,"goal":"lemma SeqAppendLen_15801(s: seq, ys: seq)\n ensures |s + ys| == |s| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_15802","instance":15802,"id":202473,"goal":"lemma SeqAppendNil_15802(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_15803","instance":15803,"id":202474,"goal":"lemma SeqNilAppend_15803(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_15804","instance":15804,"id":202475,"goal":"lemma SeqAppendAssoc_15804(s: seq, zs: seq, t: seq)\n ensures (s + zs) + t == s + (zs + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_15805","instance":15805,"id":202476,"goal":"lemma SeqTakeDrop_15805(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_15806","instance":15806,"id":202477,"goal":"lemma SeqReverseLen_15806(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_15807","instance":15807,"id":202478,"goal":"lemma SeqReverseIdem_15807(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_15808","instance":15808,"id":202479,"goal":"lemma SeqMapLen_15808(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_15809","instance":15809,"id":202480,"goal":"lemma SeqFilterLe_15809(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_15810","instance":15810,"id":202481,"goal":"lemma SeqMemberAppend_15810(u: seq, xs: seq)\n ensures x in u + xs <==> x in u || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_15811","instance":15811,"id":202482,"goal":"lemma SeqAppendLen_15811(xs: seq, zs: seq)\n ensures |xs + zs| == |xs| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_15812","instance":15812,"id":202483,"goal":"lemma SeqAppendNil_15812(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_15813","instance":15813,"id":202484,"goal":"lemma SeqNilAppend_15813(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_15814","instance":15814,"id":202485,"goal":"lemma SeqAppendAssoc_15814(zs: seq, u: seq, t: seq)\n ensures (zs + u) + t == zs + (u + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_15815","instance":15815,"id":202486,"goal":"lemma SeqTakeDrop_15815(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_15816","instance":15816,"id":202487,"goal":"lemma SeqReverseLen_15816(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_15817","instance":15817,"id":202488,"goal":"lemma SeqReverseIdem_15817(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_15818","instance":15818,"id":202489,"goal":"lemma SeqMapLen_15818(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_15819","instance":15819,"id":202490,"goal":"lemma SeqFilterLe_15819(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_15820","instance":15820,"id":202491,"goal":"lemma SeqMemberAppend_15820(t: seq, zs: seq)\n ensures x in t + zs <==> x in t || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_15821","instance":15821,"id":202492,"goal":"lemma SeqAppendLen_15821(ys: seq, xs: seq)\n ensures |ys + xs| == |ys| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_15822","instance":15822,"id":202493,"goal":"lemma SeqAppendNil_15822(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_15823","instance":15823,"id":202494,"goal":"lemma SeqNilAppend_15823(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_15824","instance":15824,"id":202495,"goal":"lemma SeqAppendAssoc_15824(ys: seq, u: seq, s: seq)\n ensures (ys + u) + s == ys + (u + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_15825","instance":15825,"id":202496,"goal":"lemma SeqTakeDrop_15825(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_15826","instance":15826,"id":202497,"goal":"lemma SeqReverseLen_15826(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_15827","instance":15827,"id":202498,"goal":"lemma SeqReverseIdem_15827(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_15828","instance":15828,"id":202499,"goal":"lemma SeqMapLen_15828(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_15829","instance":15829,"id":202500,"goal":"lemma SeqFilterLe_15829(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_15830","instance":15830,"id":202501,"goal":"lemma SeqMemberAppend_15830(ys: seq, t: seq)\n ensures x in ys + t <==> x in ys || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_15831","instance":15831,"id":202502,"goal":"lemma SeqAppendLen_15831(ys: seq, u: seq)\n ensures |ys + u| == |ys| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_15832","instance":15832,"id":202503,"goal":"lemma SeqAppendNil_15832(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_15833","instance":15833,"id":202504,"goal":"lemma SeqNilAppend_15833(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_15834","instance":15834,"id":202505,"goal":"lemma SeqAppendAssoc_15834(zs: seq, t: seq, u: seq)\n ensures (zs + t) + u == zs + (t + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_15835","instance":15835,"id":202506,"goal":"lemma SeqTakeDrop_15835(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_15836","instance":15836,"id":202507,"goal":"lemma SeqReverseLen_15836(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_15837","instance":15837,"id":202508,"goal":"lemma SeqReverseIdem_15837(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_15838","instance":15838,"id":202509,"goal":"lemma SeqMapLen_15838(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_15839","instance":15839,"id":202510,"goal":"lemma SeqFilterLe_15839(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_15840","instance":15840,"id":202511,"goal":"lemma SeqMemberAppend_15840(t: seq, xs: seq)\n ensures x in t + xs <==> x in t || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_15841","instance":15841,"id":202512,"goal":"lemma SeqAppendLen_15841(xs: seq, zs: seq)\n ensures |xs + zs| == |xs| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_15842","instance":15842,"id":202513,"goal":"lemma SeqAppendNil_15842(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_15843","instance":15843,"id":202514,"goal":"lemma SeqNilAppend_15843(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_15844","instance":15844,"id":202515,"goal":"lemma SeqAppendAssoc_15844(u: seq, ys: seq, s: seq)\n ensures (u + ys) + s == u + (ys + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_15845","instance":15845,"id":202516,"goal":"lemma SeqTakeDrop_15845(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_15846","instance":15846,"id":202517,"goal":"lemma SeqReverseLen_15846(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_15847","instance":15847,"id":202518,"goal":"lemma SeqReverseIdem_15847(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_15848","instance":15848,"id":202519,"goal":"lemma SeqMapLen_15848(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_15849","instance":15849,"id":202520,"goal":"lemma SeqFilterLe_15849(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_15850","instance":15850,"id":202521,"goal":"lemma SeqMemberAppend_15850(u: seq, zs: seq)\n ensures x in u + zs <==> x in u || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_15851","instance":15851,"id":202522,"goal":"lemma SeqAppendLen_15851(xs: seq, t: seq)\n ensures |xs + t| == |xs| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_15852","instance":15852,"id":202523,"goal":"lemma SeqAppendNil_15852(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_15853","instance":15853,"id":202524,"goal":"lemma SeqNilAppend_15853(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_15854","instance":15854,"id":202525,"goal":"lemma SeqAppendAssoc_15854(ys: seq, zs: seq, u: seq)\n ensures (ys + zs) + u == ys + (zs + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_15855","instance":15855,"id":202526,"goal":"lemma SeqTakeDrop_15855(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_15856","instance":15856,"id":202527,"goal":"lemma SeqReverseLen_15856(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_15857","instance":15857,"id":202528,"goal":"lemma SeqReverseIdem_15857(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_15858","instance":15858,"id":202529,"goal":"lemma SeqMapLen_15858(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_15859","instance":15859,"id":202530,"goal":"lemma SeqFilterLe_15859(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_15860","instance":15860,"id":202531,"goal":"lemma SeqMemberAppend_15860(zs: seq, u: seq)\n ensures x in zs + u <==> x in zs || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_15861","instance":15861,"id":202532,"goal":"lemma SeqAppendLen_15861(u: seq, s: seq)\n ensures |u + s| == |u| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_15862","instance":15862,"id":202533,"goal":"lemma SeqAppendNil_15862(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_15863","instance":15863,"id":202534,"goal":"lemma SeqNilAppend_15863(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_15864","instance":15864,"id":202535,"goal":"lemma SeqAppendAssoc_15864(xs: seq, u: seq, ys: seq)\n ensures (xs + u) + ys == xs + (u + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_15865","instance":15865,"id":202536,"goal":"lemma SeqTakeDrop_15865(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_15866","instance":15866,"id":202537,"goal":"lemma SeqReverseLen_15866(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_15867","instance":15867,"id":202538,"goal":"lemma SeqReverseIdem_15867(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_15868","instance":15868,"id":202539,"goal":"lemma SeqMapLen_15868(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_15869","instance":15869,"id":202540,"goal":"lemma SeqFilterLe_15869(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_15870","instance":15870,"id":202541,"goal":"lemma SeqMemberAppend_15870(t: seq, zs: seq)\n ensures x in t + zs <==> x in t || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_15871","instance":15871,"id":202542,"goal":"lemma SeqAppendLen_15871(s: seq, u: seq)\n ensures |s + u| == |s| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_15872","instance":15872,"id":202543,"goal":"lemma SeqAppendNil_15872(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_15873","instance":15873,"id":202544,"goal":"lemma SeqNilAppend_15873(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_15874","instance":15874,"id":202545,"goal":"lemma SeqAppendAssoc_15874(xs: seq, t: seq, ys: seq)\n ensures (xs + t) + ys == xs + (t + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_15875","instance":15875,"id":202546,"goal":"lemma SeqTakeDrop_15875(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_15876","instance":15876,"id":202547,"goal":"lemma SeqReverseLen_15876(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_15877","instance":15877,"id":202548,"goal":"lemma SeqReverseIdem_15877(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_15878","instance":15878,"id":202549,"goal":"lemma SeqMapLen_15878(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_15879","instance":15879,"id":202550,"goal":"lemma SeqFilterLe_15879(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_15880","instance":15880,"id":202551,"goal":"lemma SeqMemberAppend_15880(s: seq, zs: seq)\n ensures x in s + zs <==> x in s || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_15881","instance":15881,"id":202552,"goal":"lemma SeqAppendLen_15881(ys: seq, zs: seq)\n ensures |ys + zs| == |ys| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_15882","instance":15882,"id":202553,"goal":"lemma SeqAppendNil_15882(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_15883","instance":15883,"id":202554,"goal":"lemma SeqNilAppend_15883(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_15884","instance":15884,"id":202555,"goal":"lemma SeqAppendAssoc_15884(u: seq, t: seq, s: seq)\n ensures (u + t) + s == u + (t + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_15885","instance":15885,"id":202556,"goal":"lemma SeqTakeDrop_15885(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_15886","instance":15886,"id":202557,"goal":"lemma SeqReverseLen_15886(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_15887","instance":15887,"id":202558,"goal":"lemma SeqReverseIdem_15887(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_15888","instance":15888,"id":202559,"goal":"lemma SeqMapLen_15888(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_15889","instance":15889,"id":202560,"goal":"lemma SeqFilterLe_15889(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_15890","instance":15890,"id":202561,"goal":"lemma SeqMemberAppend_15890(u: seq, s: seq)\n ensures x in u + s <==> x in u || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_15891","instance":15891,"id":202562,"goal":"lemma SeqAppendLen_15891(ys: seq, zs: seq)\n ensures |ys + zs| == |ys| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_15892","instance":15892,"id":202563,"goal":"lemma SeqAppendNil_15892(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_15893","instance":15893,"id":202564,"goal":"lemma SeqNilAppend_15893(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_15894","instance":15894,"id":202565,"goal":"lemma SeqAppendAssoc_15894(zs: seq, t: seq, xs: seq)\n ensures (zs + t) + xs == zs + (t + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_15895","instance":15895,"id":202566,"goal":"lemma SeqTakeDrop_15895(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_15896","instance":15896,"id":202567,"goal":"lemma SeqReverseLen_15896(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_15897","instance":15897,"id":202568,"goal":"lemma SeqReverseIdem_15897(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_15898","instance":15898,"id":202569,"goal":"lemma SeqMapLen_15898(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_15899","instance":15899,"id":202570,"goal":"lemma SeqFilterLe_15899(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_15900","instance":15900,"id":202571,"goal":"lemma SeqMemberAppend_15900(u: seq, s: seq)\n ensures x in u + s <==> x in u || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_15901","instance":15901,"id":202572,"goal":"lemma SeqAppendLen_15901(t: seq, u: seq)\n ensures |t + u| == |t| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_15902","instance":15902,"id":202573,"goal":"lemma SeqAppendNil_15902(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_15903","instance":15903,"id":202574,"goal":"lemma SeqNilAppend_15903(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_15904","instance":15904,"id":202575,"goal":"lemma SeqAppendAssoc_15904(zs: seq, s: seq, u: seq)\n ensures (zs + s) + u == zs + (s + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_15905","instance":15905,"id":202576,"goal":"lemma SeqTakeDrop_15905(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_15906","instance":15906,"id":202577,"goal":"lemma SeqReverseLen_15906(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_15907","instance":15907,"id":202578,"goal":"lemma SeqReverseIdem_15907(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_15908","instance":15908,"id":202579,"goal":"lemma SeqMapLen_15908(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_15909","instance":15909,"id":202580,"goal":"lemma SeqFilterLe_15909(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_15910","instance":15910,"id":202581,"goal":"lemma SeqMemberAppend_15910(u: seq, zs: seq)\n ensures x in u + zs <==> x in u || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_15911","instance":15911,"id":202582,"goal":"lemma SeqAppendLen_15911(zs: seq, s: seq)\n ensures |zs + s| == |zs| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_15912","instance":15912,"id":202583,"goal":"lemma SeqAppendNil_15912(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_15913","instance":15913,"id":202584,"goal":"lemma SeqNilAppend_15913(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_15914","instance":15914,"id":202585,"goal":"lemma SeqAppendAssoc_15914(zs: seq, u: seq, t: seq)\n ensures (zs + u) + t == zs + (u + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_15915","instance":15915,"id":202586,"goal":"lemma SeqTakeDrop_15915(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_15916","instance":15916,"id":202587,"goal":"lemma SeqReverseLen_15916(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_15917","instance":15917,"id":202588,"goal":"lemma SeqReverseIdem_15917(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_15918","instance":15918,"id":202589,"goal":"lemma SeqMapLen_15918(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_15919","instance":15919,"id":202590,"goal":"lemma SeqFilterLe_15919(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_15920","instance":15920,"id":202591,"goal":"lemma SeqMemberAppend_15920(t: seq, s: seq)\n ensures x in t + s <==> x in t || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_15921","instance":15921,"id":202592,"goal":"lemma SeqAppendLen_15921(ys: seq, u: seq)\n ensures |ys + u| == |ys| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_15922","instance":15922,"id":202593,"goal":"lemma SeqAppendNil_15922(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_15923","instance":15923,"id":202594,"goal":"lemma SeqNilAppend_15923(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_15924","instance":15924,"id":202595,"goal":"lemma SeqAppendAssoc_15924(u: seq, ys: seq, zs: seq)\n ensures (u + ys) + zs == u + (ys + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_15925","instance":15925,"id":202596,"goal":"lemma SeqTakeDrop_15925(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_15926","instance":15926,"id":202597,"goal":"lemma SeqReverseLen_15926(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_15927","instance":15927,"id":202598,"goal":"lemma SeqReverseIdem_15927(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_15928","instance":15928,"id":202599,"goal":"lemma SeqMapLen_15928(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_15929","instance":15929,"id":202600,"goal":"lemma SeqFilterLe_15929(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_15930","instance":15930,"id":202601,"goal":"lemma SeqMemberAppend_15930(xs: seq, t: seq)\n ensures x in xs + t <==> x in xs || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_15931","instance":15931,"id":202602,"goal":"lemma SeqAppendLen_15931(xs: seq, t: seq)\n ensures |xs + t| == |xs| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_15932","instance":15932,"id":202603,"goal":"lemma SeqAppendNil_15932(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_15933","instance":15933,"id":202604,"goal":"lemma SeqNilAppend_15933(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_15934","instance":15934,"id":202605,"goal":"lemma SeqAppendAssoc_15934(ys: seq, zs: seq, u: seq)\n ensures (ys + zs) + u == ys + (zs + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_15935","instance":15935,"id":202606,"goal":"lemma SeqTakeDrop_15935(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_15936","instance":15936,"id":202607,"goal":"lemma SeqReverseLen_15936(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_15937","instance":15937,"id":202608,"goal":"lemma SeqReverseIdem_15937(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_15938","instance":15938,"id":202609,"goal":"lemma SeqMapLen_15938(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_15939","instance":15939,"id":202610,"goal":"lemma SeqFilterLe_15939(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_15940","instance":15940,"id":202611,"goal":"lemma SeqMemberAppend_15940(zs: seq, u: seq)\n ensures x in zs + u <==> x in zs || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_15941","instance":15941,"id":202612,"goal":"lemma SeqAppendLen_15941(zs: seq, u: seq)\n ensures |zs + u| == |zs| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_15942","instance":15942,"id":202613,"goal":"lemma SeqAppendNil_15942(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_15943","instance":15943,"id":202614,"goal":"lemma SeqNilAppend_15943(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_15944","instance":15944,"id":202615,"goal":"lemma SeqAppendAssoc_15944(t: seq, ys: seq, xs: seq)\n ensures (t + ys) + xs == t + (ys + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_15945","instance":15945,"id":202616,"goal":"lemma SeqTakeDrop_15945(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_15946","instance":15946,"id":202617,"goal":"lemma SeqReverseLen_15946(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_15947","instance":15947,"id":202618,"goal":"lemma SeqReverseIdem_15947(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_15948","instance":15948,"id":202619,"goal":"lemma SeqMapLen_15948(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_15949","instance":15949,"id":202620,"goal":"lemma SeqFilterLe_15949(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_15950","instance":15950,"id":202621,"goal":"lemma SeqMemberAppend_15950(xs: seq, zs: seq)\n ensures x in xs + zs <==> x in xs || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_15951","instance":15951,"id":202622,"goal":"lemma SeqAppendLen_15951(xs: seq, u: seq)\n ensures |xs + u| == |xs| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_15952","instance":15952,"id":202623,"goal":"lemma SeqAppendNil_15952(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_15953","instance":15953,"id":202624,"goal":"lemma SeqNilAppend_15953(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_15954","instance":15954,"id":202625,"goal":"lemma SeqAppendAssoc_15954(u: seq, t: seq, ys: seq)\n ensures (u + t) + ys == u + (t + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_15955","instance":15955,"id":202626,"goal":"lemma SeqTakeDrop_15955(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_15956","instance":15956,"id":202627,"goal":"lemma SeqReverseLen_15956(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_15957","instance":15957,"id":202628,"goal":"lemma SeqReverseIdem_15957(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_15958","instance":15958,"id":202629,"goal":"lemma SeqMapLen_15958(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_15959","instance":15959,"id":202630,"goal":"lemma SeqFilterLe_15959(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_15960","instance":15960,"id":202631,"goal":"lemma SeqMemberAppend_15960(u: seq, s: seq)\n ensures x in u + s <==> x in u || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_15961","instance":15961,"id":202632,"goal":"lemma SeqAppendLen_15961(s: seq, t: seq)\n ensures |s + t| == |s| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_15962","instance":15962,"id":202633,"goal":"lemma SeqAppendNil_15962(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_15963","instance":15963,"id":202634,"goal":"lemma SeqNilAppend_15963(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_15964","instance":15964,"id":202635,"goal":"lemma SeqAppendAssoc_15964(xs: seq, u: seq, s: seq)\n ensures (xs + u) + s == xs + (u + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_15965","instance":15965,"id":202636,"goal":"lemma SeqTakeDrop_15965(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_15966","instance":15966,"id":202637,"goal":"lemma SeqReverseLen_15966(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_15967","instance":15967,"id":202638,"goal":"lemma SeqReverseIdem_15967(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_15968","instance":15968,"id":202639,"goal":"lemma SeqMapLen_15968(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_15969","instance":15969,"id":202640,"goal":"lemma SeqFilterLe_15969(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_15970","instance":15970,"id":202641,"goal":"lemma SeqMemberAppend_15970(s: seq, u: seq)\n ensures x in s + u <==> x in s || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_15971","instance":15971,"id":202642,"goal":"lemma SeqAppendLen_15971(s: seq, ys: seq)\n ensures |s + ys| == |s| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_15972","instance":15972,"id":202643,"goal":"lemma SeqAppendNil_15972(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_15973","instance":15973,"id":202644,"goal":"lemma SeqNilAppend_15973(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_15974","instance":15974,"id":202645,"goal":"lemma SeqAppendAssoc_15974(t: seq, zs: seq, ys: seq)\n ensures (t + zs) + ys == t + (zs + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_15975","instance":15975,"id":202646,"goal":"lemma SeqTakeDrop_15975(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_15976","instance":15976,"id":202647,"goal":"lemma SeqReverseLen_15976(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_15977","instance":15977,"id":202648,"goal":"lemma SeqReverseIdem_15977(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_15978","instance":15978,"id":202649,"goal":"lemma SeqMapLen_15978(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_15979","instance":15979,"id":202650,"goal":"lemma SeqFilterLe_15979(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_15980","instance":15980,"id":202651,"goal":"lemma SeqMemberAppend_15980(t: seq, u: seq)\n ensures x in t + u <==> x in t || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_15981","instance":15981,"id":202652,"goal":"lemma SeqAppendLen_15981(t: seq, zs: seq)\n ensures |t + zs| == |t| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_15982","instance":15982,"id":202653,"goal":"lemma SeqAppendNil_15982(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_15983","instance":15983,"id":202654,"goal":"lemma SeqNilAppend_15983(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_15984","instance":15984,"id":202655,"goal":"lemma SeqAppendAssoc_15984(xs: seq, zs: seq, t: seq)\n ensures (xs + zs) + t == xs + (zs + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_15985","instance":15985,"id":202656,"goal":"lemma SeqTakeDrop_15985(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_15986","instance":15986,"id":202657,"goal":"lemma SeqReverseLen_15986(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_15987","instance":15987,"id":202658,"goal":"lemma SeqReverseIdem_15987(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_15988","instance":15988,"id":202659,"goal":"lemma SeqMapLen_15988(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_15989","instance":15989,"id":202660,"goal":"lemma SeqFilterLe_15989(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_15990","instance":15990,"id":202661,"goal":"lemma SeqMemberAppend_15990(s: seq, t: seq)\n ensures x in s + t <==> x in s || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_15991","instance":15991,"id":202662,"goal":"lemma SeqAppendLen_15991(t: seq, u: seq)\n ensures |t + u| == |t| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_15992","instance":15992,"id":202663,"goal":"lemma SeqAppendNil_15992(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_15993","instance":15993,"id":202664,"goal":"lemma SeqNilAppend_15993(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_15994","instance":15994,"id":202665,"goal":"lemma SeqAppendAssoc_15994(xs: seq, u: seq, s: seq)\n ensures (xs + u) + s == xs + (u + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_15995","instance":15995,"id":202666,"goal":"lemma SeqTakeDrop_15995(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_15996","instance":15996,"id":202667,"goal":"lemma SeqReverseLen_15996(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_15997","instance":15997,"id":202668,"goal":"lemma SeqReverseIdem_15997(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_15998","instance":15998,"id":202669,"goal":"lemma SeqMapLen_15998(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_15999","instance":15999,"id":202670,"goal":"lemma SeqFilterLe_15999(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_16000","instance":16000,"id":202671,"goal":"lemma SeqMemberAppend_16000(s: seq, u: seq)\n ensures x in s + u <==> x in s || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_16001","instance":16001,"id":202672,"goal":"lemma SeqAppendLen_16001(s: seq, ys: seq)\n ensures |s + ys| == |s| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_16002","instance":16002,"id":202673,"goal":"lemma SeqAppendNil_16002(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_16003","instance":16003,"id":202674,"goal":"lemma SeqNilAppend_16003(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_16004","instance":16004,"id":202675,"goal":"lemma SeqAppendAssoc_16004(u: seq, zs: seq, xs: seq)\n ensures (u + zs) + xs == u + (zs + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_16005","instance":16005,"id":202676,"goal":"lemma SeqTakeDrop_16005(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_16006","instance":16006,"id":202677,"goal":"lemma SeqReverseLen_16006(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_16007","instance":16007,"id":202678,"goal":"lemma SeqReverseIdem_16007(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_16008","instance":16008,"id":202679,"goal":"lemma SeqMapLen_16008(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_16009","instance":16009,"id":202680,"goal":"lemma SeqFilterLe_16009(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_16010","instance":16010,"id":202681,"goal":"lemma SeqMemberAppend_16010(zs: seq, t: seq)\n ensures x in zs + t <==> x in zs || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_16011","instance":16011,"id":202682,"goal":"lemma SeqAppendLen_16011(xs: seq, s: seq)\n ensures |xs + s| == |xs| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_16012","instance":16012,"id":202683,"goal":"lemma SeqAppendNil_16012(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_16013","instance":16013,"id":202684,"goal":"lemma SeqNilAppend_16013(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_16014","instance":16014,"id":202685,"goal":"lemma SeqAppendAssoc_16014(t: seq, u: seq, ys: seq)\n ensures (t + u) + ys == t + (u + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_16015","instance":16015,"id":202686,"goal":"lemma SeqTakeDrop_16015(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_16016","instance":16016,"id":202687,"goal":"lemma SeqReverseLen_16016(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_16017","instance":16017,"id":202688,"goal":"lemma SeqReverseIdem_16017(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_16018","instance":16018,"id":202689,"goal":"lemma SeqMapLen_16018(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_16019","instance":16019,"id":202690,"goal":"lemma SeqFilterLe_16019(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_16020","instance":16020,"id":202691,"goal":"lemma SeqMemberAppend_16020(ys: seq, xs: seq)\n ensures x in ys + xs <==> x in ys || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_16021","instance":16021,"id":202692,"goal":"lemma SeqAppendLen_16021(u: seq, t: seq)\n ensures |u + t| == |u| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_16022","instance":16022,"id":202693,"goal":"lemma SeqAppendNil_16022(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_16023","instance":16023,"id":202694,"goal":"lemma SeqNilAppend_16023(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_16024","instance":16024,"id":202695,"goal":"lemma SeqAppendAssoc_16024(zs: seq, u: seq, t: seq)\n ensures (zs + u) + t == zs + (u + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_16025","instance":16025,"id":202696,"goal":"lemma SeqTakeDrop_16025(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_16026","instance":16026,"id":202697,"goal":"lemma SeqReverseLen_16026(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_16027","instance":16027,"id":202698,"goal":"lemma SeqReverseIdem_16027(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_16028","instance":16028,"id":202699,"goal":"lemma SeqMapLen_16028(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_16029","instance":16029,"id":202700,"goal":"lemma SeqFilterLe_16029(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_16030","instance":16030,"id":202701,"goal":"lemma SeqMemberAppend_16030(s: seq, t: seq)\n ensures x in s + t <==> x in s || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_16031","instance":16031,"id":202702,"goal":"lemma SeqAppendLen_16031(ys: seq, t: seq)\n ensures |ys + t| == |ys| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_16032","instance":16032,"id":202703,"goal":"lemma SeqAppendNil_16032(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_16033","instance":16033,"id":202704,"goal":"lemma SeqNilAppend_16033(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_16034","instance":16034,"id":202705,"goal":"lemma SeqAppendAssoc_16034(xs: seq, zs: seq, u: seq)\n ensures (xs + zs) + u == xs + (zs + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_16035","instance":16035,"id":202706,"goal":"lemma SeqTakeDrop_16035(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_16036","instance":16036,"id":202707,"goal":"lemma SeqReverseLen_16036(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_16037","instance":16037,"id":202708,"goal":"lemma SeqReverseIdem_16037(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_16038","instance":16038,"id":202709,"goal":"lemma SeqMapLen_16038(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_16039","instance":16039,"id":202710,"goal":"lemma SeqFilterLe_16039(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_16040","instance":16040,"id":202711,"goal":"lemma SeqMemberAppend_16040(t: seq, ys: seq)\n ensures x in t + ys <==> x in t || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_16041","instance":16041,"id":202712,"goal":"lemma SeqAppendLen_16041(s: seq, ys: seq)\n ensures |s + ys| == |s| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_16042","instance":16042,"id":202713,"goal":"lemma SeqAppendNil_16042(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_16043","instance":16043,"id":202714,"goal":"lemma SeqNilAppend_16043(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_16044","instance":16044,"id":202715,"goal":"lemma SeqAppendAssoc_16044(u: seq, xs: seq, s: seq)\n ensures (u + xs) + s == u + (xs + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_16045","instance":16045,"id":202716,"goal":"lemma SeqTakeDrop_16045(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_16046","instance":16046,"id":202717,"goal":"lemma SeqReverseLen_16046(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_16047","instance":16047,"id":202718,"goal":"lemma SeqReverseIdem_16047(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_16048","instance":16048,"id":202719,"goal":"lemma SeqMapLen_16048(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_16049","instance":16049,"id":202720,"goal":"lemma SeqFilterLe_16049(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_16050","instance":16050,"id":202721,"goal":"lemma SeqMemberAppend_16050(s: seq, ys: seq)\n ensures x in s + ys <==> x in s || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_16051","instance":16051,"id":202722,"goal":"lemma SeqAppendLen_16051(ys: seq, s: seq)\n ensures |ys + s| == |ys| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_16052","instance":16052,"id":202723,"goal":"lemma SeqAppendNil_16052(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_16053","instance":16053,"id":202724,"goal":"lemma SeqNilAppend_16053(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_16054","instance":16054,"id":202725,"goal":"lemma SeqAppendAssoc_16054(t: seq, zs: seq, s: seq)\n ensures (t + zs) + s == t + (zs + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_16055","instance":16055,"id":202726,"goal":"lemma SeqTakeDrop_16055(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_16056","instance":16056,"id":202727,"goal":"lemma SeqReverseLen_16056(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_16057","instance":16057,"id":202728,"goal":"lemma SeqReverseIdem_16057(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_16058","instance":16058,"id":202729,"goal":"lemma SeqMapLen_16058(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_16059","instance":16059,"id":202730,"goal":"lemma SeqFilterLe_16059(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_16060","instance":16060,"id":202731,"goal":"lemma SeqMemberAppend_16060(t: seq, u: seq)\n ensures x in t + u <==> x in t || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_16061","instance":16061,"id":202732,"goal":"lemma SeqAppendLen_16061(t: seq, u: seq)\n ensures |t + u| == |t| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_16062","instance":16062,"id":202733,"goal":"lemma SeqAppendNil_16062(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_16063","instance":16063,"id":202734,"goal":"lemma SeqNilAppend_16063(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_16064","instance":16064,"id":202735,"goal":"lemma SeqAppendAssoc_16064(xs: seq, t: seq, ys: seq)\n ensures (xs + t) + ys == xs + (t + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_16065","instance":16065,"id":202736,"goal":"lemma SeqTakeDrop_16065(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_16066","instance":16066,"id":202737,"goal":"lemma SeqReverseLen_16066(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_16067","instance":16067,"id":202738,"goal":"lemma SeqReverseIdem_16067(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_16068","instance":16068,"id":202739,"goal":"lemma SeqMapLen_16068(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_16069","instance":16069,"id":202740,"goal":"lemma SeqFilterLe_16069(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_16070","instance":16070,"id":202741,"goal":"lemma SeqMemberAppend_16070(zs: seq, u: seq)\n ensures x in zs + u <==> x in zs || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_16071","instance":16071,"id":202742,"goal":"lemma SeqAppendLen_16071(xs: seq, ys: seq)\n ensures |xs + ys| == |xs| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_16072","instance":16072,"id":202743,"goal":"lemma SeqAppendNil_16072(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_16073","instance":16073,"id":202744,"goal":"lemma SeqNilAppend_16073(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_16074","instance":16074,"id":202745,"goal":"lemma SeqAppendAssoc_16074(t: seq, u: seq, s: seq)\n ensures (t + u) + s == t + (u + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_16075","instance":16075,"id":202746,"goal":"lemma SeqTakeDrop_16075(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_16076","instance":16076,"id":202747,"goal":"lemma SeqReverseLen_16076(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_16077","instance":16077,"id":202748,"goal":"lemma SeqReverseIdem_16077(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_16078","instance":16078,"id":202749,"goal":"lemma SeqMapLen_16078(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_16079","instance":16079,"id":202750,"goal":"lemma SeqFilterLe_16079(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_16080","instance":16080,"id":202751,"goal":"lemma SeqMemberAppend_16080(ys: seq, xs: seq)\n ensures x in ys + xs <==> x in ys || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_16081","instance":16081,"id":202752,"goal":"lemma SeqAppendLen_16081(t: seq, zs: seq)\n ensures |t + zs| == |t| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_16082","instance":16082,"id":202753,"goal":"lemma SeqAppendNil_16082(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_16083","instance":16083,"id":202754,"goal":"lemma SeqNilAppend_16083(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_16084","instance":16084,"id":202755,"goal":"lemma SeqAppendAssoc_16084(u: seq, xs: seq, zs: seq)\n ensures (u + xs) + zs == u + (xs + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_16085","instance":16085,"id":202756,"goal":"lemma SeqTakeDrop_16085(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_16086","instance":16086,"id":202757,"goal":"lemma SeqReverseLen_16086(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_16087","instance":16087,"id":202758,"goal":"lemma SeqReverseIdem_16087(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_16088","instance":16088,"id":202759,"goal":"lemma SeqMapLen_16088(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_16089","instance":16089,"id":202760,"goal":"lemma SeqFilterLe_16089(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_16090","instance":16090,"id":202761,"goal":"lemma SeqMemberAppend_16090(t: seq, zs: seq)\n ensures x in t + zs <==> x in t || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_16091","instance":16091,"id":202762,"goal":"lemma SeqAppendLen_16091(xs: seq, ys: seq)\n ensures |xs + ys| == |xs| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_16092","instance":16092,"id":202763,"goal":"lemma SeqAppendNil_16092(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_16093","instance":16093,"id":202764,"goal":"lemma SeqNilAppend_16093(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_16094","instance":16094,"id":202765,"goal":"lemma SeqAppendAssoc_16094(u: seq, zs: seq, ys: seq)\n ensures (u + zs) + ys == u + (zs + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_16095","instance":16095,"id":202766,"goal":"lemma SeqTakeDrop_16095(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_16096","instance":16096,"id":202767,"goal":"lemma SeqReverseLen_16096(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_16097","instance":16097,"id":202768,"goal":"lemma SeqReverseIdem_16097(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_16098","instance":16098,"id":202769,"goal":"lemma SeqMapLen_16098(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_16099","instance":16099,"id":202770,"goal":"lemma SeqFilterLe_16099(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_16100","instance":16100,"id":202771,"goal":"lemma SeqMemberAppend_16100(s: seq, ys: seq)\n ensures x in s + ys <==> x in s || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_16101","instance":16101,"id":202772,"goal":"lemma SeqAppendLen_16101(u: seq, s: seq)\n ensures |u + s| == |u| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_16102","instance":16102,"id":202773,"goal":"lemma SeqAppendNil_16102(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_16103","instance":16103,"id":202774,"goal":"lemma SeqNilAppend_16103(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_16104","instance":16104,"id":202775,"goal":"lemma SeqAppendAssoc_16104(zs: seq, ys: seq, t: seq)\n ensures (zs + ys) + t == zs + (ys + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_16105","instance":16105,"id":202776,"goal":"lemma SeqTakeDrop_16105(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_16106","instance":16106,"id":202777,"goal":"lemma SeqReverseLen_16106(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_16107","instance":16107,"id":202778,"goal":"lemma SeqReverseIdem_16107(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_16108","instance":16108,"id":202779,"goal":"lemma SeqMapLen_16108(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_16109","instance":16109,"id":202780,"goal":"lemma SeqFilterLe_16109(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_16110","instance":16110,"id":202781,"goal":"lemma SeqMemberAppend_16110(s: seq, u: seq)\n ensures x in s + u <==> x in s || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_16111","instance":16111,"id":202782,"goal":"lemma SeqAppendLen_16111(xs: seq, ys: seq)\n ensures |xs + ys| == |xs| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_16112","instance":16112,"id":202783,"goal":"lemma SeqAppendNil_16112(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_16113","instance":16113,"id":202784,"goal":"lemma SeqNilAppend_16113(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_16114","instance":16114,"id":202785,"goal":"lemma SeqAppendAssoc_16114(s: seq, zs: seq, ys: seq)\n ensures (s + zs) + ys == s + (zs + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_16115","instance":16115,"id":202786,"goal":"lemma SeqTakeDrop_16115(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_16116","instance":16116,"id":202787,"goal":"lemma SeqReverseLen_16116(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_16117","instance":16117,"id":202788,"goal":"lemma SeqReverseIdem_16117(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_16118","instance":16118,"id":202789,"goal":"lemma SeqMapLen_16118(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_16119","instance":16119,"id":202790,"goal":"lemma SeqFilterLe_16119(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_16120","instance":16120,"id":202791,"goal":"lemma SeqMemberAppend_16120(zs: seq, xs: seq)\n ensures x in zs + xs <==> x in zs || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_16121","instance":16121,"id":202792,"goal":"lemma SeqAppendLen_16121(t: seq, u: seq)\n ensures |t + u| == |t| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_16122","instance":16122,"id":202793,"goal":"lemma SeqAppendNil_16122(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_16123","instance":16123,"id":202794,"goal":"lemma SeqNilAppend_16123(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_16124","instance":16124,"id":202795,"goal":"lemma SeqAppendAssoc_16124(xs: seq, u: seq, s: seq)\n ensures (xs + u) + s == xs + (u + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_16125","instance":16125,"id":202796,"goal":"lemma SeqTakeDrop_16125(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_16126","instance":16126,"id":202797,"goal":"lemma SeqReverseLen_16126(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_16127","instance":16127,"id":202798,"goal":"lemma SeqReverseIdem_16127(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_16128","instance":16128,"id":202799,"goal":"lemma SeqMapLen_16128(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_16129","instance":16129,"id":202800,"goal":"lemma SeqFilterLe_16129(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_16130","instance":16130,"id":202801,"goal":"lemma SeqMemberAppend_16130(zs: seq, u: seq)\n ensures x in zs + u <==> x in zs || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_16131","instance":16131,"id":202802,"goal":"lemma SeqAppendLen_16131(zs: seq, xs: seq)\n ensures |zs + xs| == |zs| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_16132","instance":16132,"id":202803,"goal":"lemma SeqAppendNil_16132(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_16133","instance":16133,"id":202804,"goal":"lemma SeqNilAppend_16133(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_16134","instance":16134,"id":202805,"goal":"lemma SeqAppendAssoc_16134(ys: seq, s: seq, u: seq)\n ensures (ys + s) + u == ys + (s + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_16135","instance":16135,"id":202806,"goal":"lemma SeqTakeDrop_16135(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_16136","instance":16136,"id":202807,"goal":"lemma SeqReverseLen_16136(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_16137","instance":16137,"id":202808,"goal":"lemma SeqReverseIdem_16137(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_16138","instance":16138,"id":202809,"goal":"lemma SeqMapLen_16138(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_16139","instance":16139,"id":202810,"goal":"lemma SeqFilterLe_16139(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_16140","instance":16140,"id":202811,"goal":"lemma SeqMemberAppend_16140(ys: seq, u: seq)\n ensures x in ys + u <==> x in ys || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_16141","instance":16141,"id":202812,"goal":"lemma SeqAppendLen_16141(u: seq, s: seq)\n ensures |u + s| == |u| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_16142","instance":16142,"id":202813,"goal":"lemma SeqAppendNil_16142(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_16143","instance":16143,"id":202814,"goal":"lemma SeqNilAppend_16143(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_16144","instance":16144,"id":202815,"goal":"lemma SeqAppendAssoc_16144(t: seq, s: seq, xs: seq)\n ensures (t + s) + xs == t + (s + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_16145","instance":16145,"id":202816,"goal":"lemma SeqTakeDrop_16145(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_16146","instance":16146,"id":202817,"goal":"lemma SeqReverseLen_16146(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_16147","instance":16147,"id":202818,"goal":"lemma SeqReverseIdem_16147(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_16148","instance":16148,"id":202819,"goal":"lemma SeqMapLen_16148(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_16149","instance":16149,"id":202820,"goal":"lemma SeqFilterLe_16149(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_16150","instance":16150,"id":202821,"goal":"lemma SeqMemberAppend_16150(ys: seq, xs: seq)\n ensures x in ys + xs <==> x in ys || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_16151","instance":16151,"id":202822,"goal":"lemma SeqAppendLen_16151(t: seq, xs: seq)\n ensures |t + xs| == |t| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_16152","instance":16152,"id":202823,"goal":"lemma SeqAppendNil_16152(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_16153","instance":16153,"id":202824,"goal":"lemma SeqNilAppend_16153(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_16154","instance":16154,"id":202825,"goal":"lemma SeqAppendAssoc_16154(ys: seq, s: seq, xs: seq)\n ensures (ys + s) + xs == ys + (s + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_16155","instance":16155,"id":202826,"goal":"lemma SeqTakeDrop_16155(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_16156","instance":16156,"id":202827,"goal":"lemma SeqReverseLen_16156(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_16157","instance":16157,"id":202828,"goal":"lemma SeqReverseIdem_16157(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_16158","instance":16158,"id":202829,"goal":"lemma SeqMapLen_16158(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_16159","instance":16159,"id":202830,"goal":"lemma SeqFilterLe_16159(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_16160","instance":16160,"id":202831,"goal":"lemma SeqMemberAppend_16160(ys: seq, s: seq)\n ensures x in ys + s <==> x in ys || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_16161","instance":16161,"id":202832,"goal":"lemma SeqAppendLen_16161(zs: seq, u: seq)\n ensures |zs + u| == |zs| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_16162","instance":16162,"id":202833,"goal":"lemma SeqAppendNil_16162(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_16163","instance":16163,"id":202834,"goal":"lemma SeqNilAppend_16163(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_16164","instance":16164,"id":202835,"goal":"lemma SeqAppendAssoc_16164(xs: seq, t: seq, zs: seq)\n ensures (xs + t) + zs == xs + (t + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_16165","instance":16165,"id":202836,"goal":"lemma SeqTakeDrop_16165(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_16166","instance":16166,"id":202837,"goal":"lemma SeqReverseLen_16166(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_16167","instance":16167,"id":202838,"goal":"lemma SeqReverseIdem_16167(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_16168","instance":16168,"id":202839,"goal":"lemma SeqMapLen_16168(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_16169","instance":16169,"id":202840,"goal":"lemma SeqFilterLe_16169(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_16170","instance":16170,"id":202841,"goal":"lemma SeqMemberAppend_16170(ys: seq, xs: seq)\n ensures x in ys + xs <==> x in ys || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_16171","instance":16171,"id":202842,"goal":"lemma SeqAppendLen_16171(t: seq, xs: seq)\n ensures |t + xs| == |t| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_16172","instance":16172,"id":202843,"goal":"lemma SeqAppendNil_16172(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_16173","instance":16173,"id":202844,"goal":"lemma SeqNilAppend_16173(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_16174","instance":16174,"id":202845,"goal":"lemma SeqAppendAssoc_16174(s: seq, xs: seq, t: seq)\n ensures (s + xs) + t == s + (xs + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_16175","instance":16175,"id":202846,"goal":"lemma SeqTakeDrop_16175(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_16176","instance":16176,"id":202847,"goal":"lemma SeqReverseLen_16176(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_16177","instance":16177,"id":202848,"goal":"lemma SeqReverseIdem_16177(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_16178","instance":16178,"id":202849,"goal":"lemma SeqMapLen_16178(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_16179","instance":16179,"id":202850,"goal":"lemma SeqFilterLe_16179(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_16180","instance":16180,"id":202851,"goal":"lemma SeqMemberAppend_16180(u: seq, t: seq)\n ensures x in u + t <==> x in u || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_16181","instance":16181,"id":202852,"goal":"lemma SeqAppendLen_16181(ys: seq, t: seq)\n ensures |ys + t| == |ys| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_16182","instance":16182,"id":202853,"goal":"lemma SeqAppendNil_16182(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_16183","instance":16183,"id":202854,"goal":"lemma SeqNilAppend_16183(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_16184","instance":16184,"id":202855,"goal":"lemma SeqAppendAssoc_16184(s: seq, t: seq, u: seq)\n ensures (s + t) + u == s + (t + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_16185","instance":16185,"id":202856,"goal":"lemma SeqTakeDrop_16185(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_16186","instance":16186,"id":202857,"goal":"lemma SeqReverseLen_16186(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_16187","instance":16187,"id":202858,"goal":"lemma SeqReverseIdem_16187(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_16188","instance":16188,"id":202859,"goal":"lemma SeqMapLen_16188(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_16189","instance":16189,"id":202860,"goal":"lemma SeqFilterLe_16189(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_16190","instance":16190,"id":202861,"goal":"lemma SeqMemberAppend_16190(s: seq, zs: seq)\n ensures x in s + zs <==> x in s || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_16191","instance":16191,"id":202862,"goal":"lemma SeqAppendLen_16191(t: seq, ys: seq)\n ensures |t + ys| == |t| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_16192","instance":16192,"id":202863,"goal":"lemma SeqAppendNil_16192(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_16193","instance":16193,"id":202864,"goal":"lemma SeqNilAppend_16193(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_16194","instance":16194,"id":202865,"goal":"lemma SeqAppendAssoc_16194(s: seq, u: seq, zs: seq)\n ensures (s + u) + zs == s + (u + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_16195","instance":16195,"id":202866,"goal":"lemma SeqTakeDrop_16195(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_16196","instance":16196,"id":202867,"goal":"lemma SeqReverseLen_16196(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_16197","instance":16197,"id":202868,"goal":"lemma SeqReverseIdem_16197(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_16198","instance":16198,"id":202869,"goal":"lemma SeqMapLen_16198(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_16199","instance":16199,"id":202870,"goal":"lemma SeqFilterLe_16199(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_16200","instance":16200,"id":202871,"goal":"lemma SeqMemberAppend_16200(ys: seq, xs: seq)\n ensures x in ys + xs <==> x in ys || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_16201","instance":16201,"id":202872,"goal":"lemma SeqAppendLen_16201(t: seq, zs: seq)\n ensures |t + zs| == |t| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_16202","instance":16202,"id":202873,"goal":"lemma SeqAppendNil_16202(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_16203","instance":16203,"id":202874,"goal":"lemma SeqNilAppend_16203(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_16204","instance":16204,"id":202875,"goal":"lemma SeqAppendAssoc_16204(s: seq, zs: seq, t: seq)\n ensures (s + zs) + t == s + (zs + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_16205","instance":16205,"id":202876,"goal":"lemma SeqTakeDrop_16205(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_16206","instance":16206,"id":202877,"goal":"lemma SeqReverseLen_16206(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_16207","instance":16207,"id":202878,"goal":"lemma SeqReverseIdem_16207(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_16208","instance":16208,"id":202879,"goal":"lemma SeqMapLen_16208(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_16209","instance":16209,"id":202880,"goal":"lemma SeqFilterLe_16209(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_16210","instance":16210,"id":202881,"goal":"lemma SeqMemberAppend_16210(u: seq, zs: seq)\n ensures x in u + zs <==> x in u || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_16211","instance":16211,"id":202882,"goal":"lemma SeqAppendLen_16211(t: seq, s: seq)\n ensures |t + s| == |t| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_16212","instance":16212,"id":202883,"goal":"lemma SeqAppendNil_16212(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_16213","instance":16213,"id":202884,"goal":"lemma SeqNilAppend_16213(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_16214","instance":16214,"id":202885,"goal":"lemma SeqAppendAssoc_16214(u: seq, xs: seq, ys: seq)\n ensures (u + xs) + ys == u + (xs + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_16215","instance":16215,"id":202886,"goal":"lemma SeqTakeDrop_16215(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_16216","instance":16216,"id":202887,"goal":"lemma SeqReverseLen_16216(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_16217","instance":16217,"id":202888,"goal":"lemma SeqReverseIdem_16217(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_16218","instance":16218,"id":202889,"goal":"lemma SeqMapLen_16218(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_16219","instance":16219,"id":202890,"goal":"lemma SeqFilterLe_16219(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_16220","instance":16220,"id":202891,"goal":"lemma SeqMemberAppend_16220(s: seq, ys: seq)\n ensures x in s + ys <==> x in s || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_16221","instance":16221,"id":202892,"goal":"lemma SeqAppendLen_16221(xs: seq, u: seq)\n ensures |xs + u| == |xs| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_16222","instance":16222,"id":202893,"goal":"lemma SeqAppendNil_16222(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_16223","instance":16223,"id":202894,"goal":"lemma SeqNilAppend_16223(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_16224","instance":16224,"id":202895,"goal":"lemma SeqAppendAssoc_16224(zs: seq, s: seq, ys: seq)\n ensures (zs + s) + ys == zs + (s + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_16225","instance":16225,"id":202896,"goal":"lemma SeqTakeDrop_16225(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_16226","instance":16226,"id":202897,"goal":"lemma SeqReverseLen_16226(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_16227","instance":16227,"id":202898,"goal":"lemma SeqReverseIdem_16227(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_16228","instance":16228,"id":202899,"goal":"lemma SeqMapLen_16228(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_16229","instance":16229,"id":202900,"goal":"lemma SeqFilterLe_16229(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_16230","instance":16230,"id":202901,"goal":"lemma SeqMemberAppend_16230(ys: seq, u: seq)\n ensures x in ys + u <==> x in ys || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_16231","instance":16231,"id":202902,"goal":"lemma SeqAppendLen_16231(zs: seq, t: seq)\n ensures |zs + t| == |zs| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_16232","instance":16232,"id":202903,"goal":"lemma SeqAppendNil_16232(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_16233","instance":16233,"id":202904,"goal":"lemma SeqNilAppend_16233(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_16234","instance":16234,"id":202905,"goal":"lemma SeqAppendAssoc_16234(s: seq, u: seq, ys: seq)\n ensures (s + u) + ys == s + (u + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_16235","instance":16235,"id":202906,"goal":"lemma SeqTakeDrop_16235(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_16236","instance":16236,"id":202907,"goal":"lemma SeqReverseLen_16236(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_16237","instance":16237,"id":202908,"goal":"lemma SeqReverseIdem_16237(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_16238","instance":16238,"id":202909,"goal":"lemma SeqMapLen_16238(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_16239","instance":16239,"id":202910,"goal":"lemma SeqFilterLe_16239(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_16240","instance":16240,"id":202911,"goal":"lemma SeqMemberAppend_16240(zs: seq, ys: seq)\n ensures x in zs + ys <==> x in zs || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_16241","instance":16241,"id":202912,"goal":"lemma SeqAppendLen_16241(t: seq, xs: seq)\n ensures |t + xs| == |t| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_16242","instance":16242,"id":202913,"goal":"lemma SeqAppendNil_16242(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_16243","instance":16243,"id":202914,"goal":"lemma SeqNilAppend_16243(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_16244","instance":16244,"id":202915,"goal":"lemma SeqAppendAssoc_16244(t: seq, u: seq, ys: seq)\n ensures (t + u) + ys == t + (u + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_16245","instance":16245,"id":202916,"goal":"lemma SeqTakeDrop_16245(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_16246","instance":16246,"id":202917,"goal":"lemma SeqReverseLen_16246(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_16247","instance":16247,"id":202918,"goal":"lemma SeqReverseIdem_16247(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_16248","instance":16248,"id":202919,"goal":"lemma SeqMapLen_16248(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_16249","instance":16249,"id":202920,"goal":"lemma SeqFilterLe_16249(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_16250","instance":16250,"id":202921,"goal":"lemma SeqMemberAppend_16250(u: seq, t: seq)\n ensures x in u + t <==> x in u || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_16251","instance":16251,"id":202922,"goal":"lemma SeqAppendLen_16251(u: seq, ys: seq)\n ensures |u + ys| == |u| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_16252","instance":16252,"id":202923,"goal":"lemma SeqAppendNil_16252(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_16253","instance":16253,"id":202924,"goal":"lemma SeqNilAppend_16253(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_16254","instance":16254,"id":202925,"goal":"lemma SeqAppendAssoc_16254(ys: seq, zs: seq, s: seq)\n ensures (ys + zs) + s == ys + (zs + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_16255","instance":16255,"id":202926,"goal":"lemma SeqTakeDrop_16255(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_16256","instance":16256,"id":202927,"goal":"lemma SeqReverseLen_16256(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_16257","instance":16257,"id":202928,"goal":"lemma SeqReverseIdem_16257(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_16258","instance":16258,"id":202929,"goal":"lemma SeqMapLen_16258(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_16259","instance":16259,"id":202930,"goal":"lemma SeqFilterLe_16259(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_16260","instance":16260,"id":202931,"goal":"lemma SeqMemberAppend_16260(s: seq, u: seq)\n ensures x in s + u <==> x in s || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_16261","instance":16261,"id":202932,"goal":"lemma SeqAppendLen_16261(xs: seq, t: seq)\n ensures |xs + t| == |xs| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_16262","instance":16262,"id":202933,"goal":"lemma SeqAppendNil_16262(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_16263","instance":16263,"id":202934,"goal":"lemma SeqNilAppend_16263(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_16264","instance":16264,"id":202935,"goal":"lemma SeqAppendAssoc_16264(ys: seq, t: seq, s: seq)\n ensures (ys + t) + s == ys + (t + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_16265","instance":16265,"id":202936,"goal":"lemma SeqTakeDrop_16265(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_16266","instance":16266,"id":202937,"goal":"lemma SeqReverseLen_16266(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_16267","instance":16267,"id":202938,"goal":"lemma SeqReverseIdem_16267(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_16268","instance":16268,"id":202939,"goal":"lemma SeqMapLen_16268(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_16269","instance":16269,"id":202940,"goal":"lemma SeqFilterLe_16269(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_16270","instance":16270,"id":202941,"goal":"lemma SeqMemberAppend_16270(u: seq, s: seq)\n ensures x in u + s <==> x in u || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_16271","instance":16271,"id":202942,"goal":"lemma SeqAppendLen_16271(ys: seq, t: seq)\n ensures |ys + t| == |ys| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_16272","instance":16272,"id":202943,"goal":"lemma SeqAppendNil_16272(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_16273","instance":16273,"id":202944,"goal":"lemma SeqNilAppend_16273(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_16274","instance":16274,"id":202945,"goal":"lemma SeqAppendAssoc_16274(xs: seq, zs: seq, ys: seq)\n ensures (xs + zs) + ys == xs + (zs + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_16275","instance":16275,"id":202946,"goal":"lemma SeqTakeDrop_16275(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_16276","instance":16276,"id":202947,"goal":"lemma SeqReverseLen_16276(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_16277","instance":16277,"id":202948,"goal":"lemma SeqReverseIdem_16277(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_16278","instance":16278,"id":202949,"goal":"lemma SeqMapLen_16278(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_16279","instance":16279,"id":202950,"goal":"lemma SeqFilterLe_16279(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_16280","instance":16280,"id":202951,"goal":"lemma SeqMemberAppend_16280(t: seq, zs: seq)\n ensures x in t + zs <==> x in t || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_16281","instance":16281,"id":202952,"goal":"lemma SeqAppendLen_16281(zs: seq, t: seq)\n ensures |zs + t| == |zs| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_16282","instance":16282,"id":202953,"goal":"lemma SeqAppendNil_16282(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_16283","instance":16283,"id":202954,"goal":"lemma SeqNilAppend_16283(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_16284","instance":16284,"id":202955,"goal":"lemma SeqAppendAssoc_16284(u: seq, xs: seq, zs: seq)\n ensures (u + xs) + zs == u + (xs + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_16285","instance":16285,"id":202956,"goal":"lemma SeqTakeDrop_16285(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_16286","instance":16286,"id":202957,"goal":"lemma SeqReverseLen_16286(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_16287","instance":16287,"id":202958,"goal":"lemma SeqReverseIdem_16287(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_16288","instance":16288,"id":202959,"goal":"lemma SeqMapLen_16288(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_16289","instance":16289,"id":202960,"goal":"lemma SeqFilterLe_16289(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_16290","instance":16290,"id":202961,"goal":"lemma SeqMemberAppend_16290(u: seq, xs: seq)\n ensures x in u + xs <==> x in u || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_16291","instance":16291,"id":202962,"goal":"lemma SeqAppendLen_16291(zs: seq, t: seq)\n ensures |zs + t| == |zs| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_16292","instance":16292,"id":202963,"goal":"lemma SeqAppendNil_16292(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_16293","instance":16293,"id":202964,"goal":"lemma SeqNilAppend_16293(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_16294","instance":16294,"id":202965,"goal":"lemma SeqAppendAssoc_16294(xs: seq, ys: seq, zs: seq)\n ensures (xs + ys) + zs == xs + (ys + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_16295","instance":16295,"id":202966,"goal":"lemma SeqTakeDrop_16295(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_16296","instance":16296,"id":202967,"goal":"lemma SeqReverseLen_16296(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_16297","instance":16297,"id":202968,"goal":"lemma SeqReverseIdem_16297(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_16298","instance":16298,"id":202969,"goal":"lemma SeqMapLen_16298(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_16299","instance":16299,"id":202970,"goal":"lemma SeqFilterLe_16299(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_16300","instance":16300,"id":202971,"goal":"lemma SeqMemberAppend_16300(t: seq, ys: seq)\n ensures x in t + ys <==> x in t || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_16301","instance":16301,"id":202972,"goal":"lemma SeqAppendLen_16301(ys: seq, zs: seq)\n ensures |ys + zs| == |ys| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_16302","instance":16302,"id":202973,"goal":"lemma SeqAppendNil_16302(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_16303","instance":16303,"id":202974,"goal":"lemma SeqNilAppend_16303(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_16304","instance":16304,"id":202975,"goal":"lemma SeqAppendAssoc_16304(s: seq, t: seq, u: seq)\n ensures (s + t) + u == s + (t + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_16305","instance":16305,"id":202976,"goal":"lemma SeqTakeDrop_16305(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_16306","instance":16306,"id":202977,"goal":"lemma SeqReverseLen_16306(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_16307","instance":16307,"id":202978,"goal":"lemma SeqReverseIdem_16307(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_16308","instance":16308,"id":202979,"goal":"lemma SeqMapLen_16308(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_16309","instance":16309,"id":202980,"goal":"lemma SeqFilterLe_16309(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_16310","instance":16310,"id":202981,"goal":"lemma SeqMemberAppend_16310(zs: seq, u: seq)\n ensures x in zs + u <==> x in zs || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_16311","instance":16311,"id":202982,"goal":"lemma SeqAppendLen_16311(xs: seq, s: seq)\n ensures |xs + s| == |xs| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_16312","instance":16312,"id":202983,"goal":"lemma SeqAppendNil_16312(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_16313","instance":16313,"id":202984,"goal":"lemma SeqNilAppend_16313(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_16314","instance":16314,"id":202985,"goal":"lemma SeqAppendAssoc_16314(t: seq, s: seq, ys: seq)\n ensures (t + s) + ys == t + (s + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_16315","instance":16315,"id":202986,"goal":"lemma SeqTakeDrop_16315(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_16316","instance":16316,"id":202987,"goal":"lemma SeqReverseLen_16316(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_16317","instance":16317,"id":202988,"goal":"lemma SeqReverseIdem_16317(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_16318","instance":16318,"id":202989,"goal":"lemma SeqMapLen_16318(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_16319","instance":16319,"id":202990,"goal":"lemma SeqFilterLe_16319(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_16320","instance":16320,"id":202991,"goal":"lemma SeqMemberAppend_16320(zs: seq, xs: seq)\n ensures x in zs + xs <==> x in zs || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_16321","instance":16321,"id":202992,"goal":"lemma SeqAppendLen_16321(ys: seq, xs: seq)\n ensures |ys + xs| == |ys| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_16322","instance":16322,"id":202993,"goal":"lemma SeqAppendNil_16322(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_16323","instance":16323,"id":202994,"goal":"lemma SeqNilAppend_16323(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_16324","instance":16324,"id":202995,"goal":"lemma SeqAppendAssoc_16324(xs: seq, ys: seq, s: seq)\n ensures (xs + ys) + s == xs + (ys + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_16325","instance":16325,"id":202996,"goal":"lemma SeqTakeDrop_16325(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_16326","instance":16326,"id":202997,"goal":"lemma SeqReverseLen_16326(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_16327","instance":16327,"id":202998,"goal":"lemma SeqReverseIdem_16327(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_16328","instance":16328,"id":202999,"goal":"lemma SeqMapLen_16328(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_16329","instance":16329,"id":203000,"goal":"lemma SeqFilterLe_16329(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_16330","instance":16330,"id":203001,"goal":"lemma SeqMemberAppend_16330(xs: seq, u: seq)\n ensures x in xs + u <==> x in xs || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_16331","instance":16331,"id":203002,"goal":"lemma SeqAppendLen_16331(xs: seq, zs: seq)\n ensures |xs + zs| == |xs| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_16332","instance":16332,"id":203003,"goal":"lemma SeqAppendNil_16332(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_16333","instance":16333,"id":203004,"goal":"lemma SeqNilAppend_16333(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_16334","instance":16334,"id":203005,"goal":"lemma SeqAppendAssoc_16334(u: seq, zs: seq, xs: seq)\n ensures (u + zs) + xs == u + (zs + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_16335","instance":16335,"id":203006,"goal":"lemma SeqTakeDrop_16335(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_16336","instance":16336,"id":203007,"goal":"lemma SeqReverseLen_16336(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_16337","instance":16337,"id":203008,"goal":"lemma SeqReverseIdem_16337(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_16338","instance":16338,"id":203009,"goal":"lemma SeqMapLen_16338(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_16339","instance":16339,"id":203010,"goal":"lemma SeqFilterLe_16339(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_16340","instance":16340,"id":203011,"goal":"lemma SeqMemberAppend_16340(s: seq, t: seq)\n ensures x in s + t <==> x in s || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_16341","instance":16341,"id":203012,"goal":"lemma SeqAppendLen_16341(xs: seq, ys: seq)\n ensures |xs + ys| == |xs| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_16342","instance":16342,"id":203013,"goal":"lemma SeqAppendNil_16342(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_16343","instance":16343,"id":203014,"goal":"lemma SeqNilAppend_16343(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_16344","instance":16344,"id":203015,"goal":"lemma SeqAppendAssoc_16344(t: seq, u: seq, ys: seq)\n ensures (t + u) + ys == t + (u + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_16345","instance":16345,"id":203016,"goal":"lemma SeqTakeDrop_16345(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_16346","instance":16346,"id":203017,"goal":"lemma SeqReverseLen_16346(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_16347","instance":16347,"id":203018,"goal":"lemma SeqReverseIdem_16347(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_16348","instance":16348,"id":203019,"goal":"lemma SeqMapLen_16348(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_16349","instance":16349,"id":203020,"goal":"lemma SeqFilterLe_16349(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_16350","instance":16350,"id":203021,"goal":"lemma SeqMemberAppend_16350(xs: seq, ys: seq)\n ensures x in xs + ys <==> x in xs || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_16351","instance":16351,"id":203022,"goal":"lemma SeqAppendLen_16351(zs: seq, u: seq)\n ensures |zs + u| == |zs| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_16352","instance":16352,"id":203023,"goal":"lemma SeqAppendNil_16352(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_16353","instance":16353,"id":203024,"goal":"lemma SeqNilAppend_16353(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_16354","instance":16354,"id":203025,"goal":"lemma SeqAppendAssoc_16354(ys: seq, t: seq, zs: seq)\n ensures (ys + t) + zs == ys + (t + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_16355","instance":16355,"id":203026,"goal":"lemma SeqTakeDrop_16355(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_16356","instance":16356,"id":203027,"goal":"lemma SeqReverseLen_16356(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_16357","instance":16357,"id":203028,"goal":"lemma SeqReverseIdem_16357(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_16358","instance":16358,"id":203029,"goal":"lemma SeqMapLen_16358(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_16359","instance":16359,"id":203030,"goal":"lemma SeqFilterLe_16359(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_16360","instance":16360,"id":203031,"goal":"lemma SeqMemberAppend_16360(zs: seq, ys: seq)\n ensures x in zs + ys <==> x in zs || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_16361","instance":16361,"id":203032,"goal":"lemma SeqAppendLen_16361(ys: seq, s: seq)\n ensures |ys + s| == |ys| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_16362","instance":16362,"id":203033,"goal":"lemma SeqAppendNil_16362(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_16363","instance":16363,"id":203034,"goal":"lemma SeqNilAppend_16363(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_16364","instance":16364,"id":203035,"goal":"lemma SeqAppendAssoc_16364(s: seq, ys: seq, xs: seq)\n ensures (s + ys) + xs == s + (ys + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_16365","instance":16365,"id":203036,"goal":"lemma SeqTakeDrop_16365(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_16366","instance":16366,"id":203037,"goal":"lemma SeqReverseLen_16366(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_16367","instance":16367,"id":203038,"goal":"lemma SeqReverseIdem_16367(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_16368","instance":16368,"id":203039,"goal":"lemma SeqMapLen_16368(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_16369","instance":16369,"id":203040,"goal":"lemma SeqFilterLe_16369(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_16370","instance":16370,"id":203041,"goal":"lemma SeqMemberAppend_16370(s: seq, t: seq)\n ensures x in s + t <==> x in s || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_16371","instance":16371,"id":203042,"goal":"lemma SeqAppendLen_16371(ys: seq, t: seq)\n ensures |ys + t| == |ys| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_16372","instance":16372,"id":203043,"goal":"lemma SeqAppendNil_16372(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_16373","instance":16373,"id":203044,"goal":"lemma SeqNilAppend_16373(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_16374","instance":16374,"id":203045,"goal":"lemma SeqAppendAssoc_16374(t: seq, zs: seq, u: seq)\n ensures (t + zs) + u == t + (zs + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_16375","instance":16375,"id":203046,"goal":"lemma SeqTakeDrop_16375(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_16376","instance":16376,"id":203047,"goal":"lemma SeqReverseLen_16376(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_16377","instance":16377,"id":203048,"goal":"lemma SeqReverseIdem_16377(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_16378","instance":16378,"id":203049,"goal":"lemma SeqMapLen_16378(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_16379","instance":16379,"id":203050,"goal":"lemma SeqFilterLe_16379(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_16380","instance":16380,"id":203051,"goal":"lemma SeqMemberAppend_16380(ys: seq, zs: seq)\n ensures x in ys + zs <==> x in ys || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_16381","instance":16381,"id":203052,"goal":"lemma SeqAppendLen_16381(xs: seq, u: seq)\n ensures |xs + u| == |xs| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_16382","instance":16382,"id":203053,"goal":"lemma SeqAppendNil_16382(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_16383","instance":16383,"id":203054,"goal":"lemma SeqNilAppend_16383(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_16384","instance":16384,"id":203055,"goal":"lemma SeqAppendAssoc_16384(zs: seq, xs: seq, ys: seq)\n ensures (zs + xs) + ys == zs + (xs + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_16385","instance":16385,"id":203056,"goal":"lemma SeqTakeDrop_16385(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_16386","instance":16386,"id":203057,"goal":"lemma SeqReverseLen_16386(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_16387","instance":16387,"id":203058,"goal":"lemma SeqReverseIdem_16387(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_16388","instance":16388,"id":203059,"goal":"lemma SeqMapLen_16388(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_16389","instance":16389,"id":203060,"goal":"lemma SeqFilterLe_16389(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_16390","instance":16390,"id":203061,"goal":"lemma SeqMemberAppend_16390(t: seq, ys: seq)\n ensures x in t + ys <==> x in t || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_16391","instance":16391,"id":203062,"goal":"lemma SeqAppendLen_16391(xs: seq, t: seq)\n ensures |xs + t| == |xs| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_16392","instance":16392,"id":203063,"goal":"lemma SeqAppendNil_16392(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_16393","instance":16393,"id":203064,"goal":"lemma SeqNilAppend_16393(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_16394","instance":16394,"id":203065,"goal":"lemma SeqAppendAssoc_16394(zs: seq, t: seq, ys: seq)\n ensures (zs + t) + ys == zs + (t + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_16395","instance":16395,"id":203066,"goal":"lemma SeqTakeDrop_16395(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_16396","instance":16396,"id":203067,"goal":"lemma SeqReverseLen_16396(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_16397","instance":16397,"id":203068,"goal":"lemma SeqReverseIdem_16397(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_16398","instance":16398,"id":203069,"goal":"lemma SeqMapLen_16398(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_16399","instance":16399,"id":203070,"goal":"lemma SeqFilterLe_16399(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_16400","instance":16400,"id":203071,"goal":"lemma SeqMemberAppend_16400(s: seq, xs: seq)\n ensures x in s + xs <==> x in s || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_16401","instance":16401,"id":203072,"goal":"lemma SeqAppendLen_16401(t: seq, xs: seq)\n ensures |t + xs| == |t| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_16402","instance":16402,"id":203073,"goal":"lemma SeqAppendNil_16402(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_16403","instance":16403,"id":203074,"goal":"lemma SeqNilAppend_16403(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_16404","instance":16404,"id":203075,"goal":"lemma SeqAppendAssoc_16404(u: seq, zs: seq, s: seq)\n ensures (u + zs) + s == u + (zs + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_16405","instance":16405,"id":203076,"goal":"lemma SeqTakeDrop_16405(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_16406","instance":16406,"id":203077,"goal":"lemma SeqReverseLen_16406(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_16407","instance":16407,"id":203078,"goal":"lemma SeqReverseIdem_16407(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_16408","instance":16408,"id":203079,"goal":"lemma SeqMapLen_16408(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_16409","instance":16409,"id":203080,"goal":"lemma SeqFilterLe_16409(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_16410","instance":16410,"id":203081,"goal":"lemma SeqMemberAppend_16410(s: seq, u: seq)\n ensures x in s + u <==> x in s || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_16411","instance":16411,"id":203082,"goal":"lemma SeqAppendLen_16411(zs: seq, s: seq)\n ensures |zs + s| == |zs| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_16412","instance":16412,"id":203083,"goal":"lemma SeqAppendNil_16412(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_16413","instance":16413,"id":203084,"goal":"lemma SeqNilAppend_16413(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_16414","instance":16414,"id":203085,"goal":"lemma SeqAppendAssoc_16414(zs: seq, u: seq, ys: seq)\n ensures (zs + u) + ys == zs + (u + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_16415","instance":16415,"id":203086,"goal":"lemma SeqTakeDrop_16415(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_16416","instance":16416,"id":203087,"goal":"lemma SeqReverseLen_16416(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_16417","instance":16417,"id":203088,"goal":"lemma SeqReverseIdem_16417(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_16418","instance":16418,"id":203089,"goal":"lemma SeqMapLen_16418(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_16419","instance":16419,"id":203090,"goal":"lemma SeqFilterLe_16419(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_16420","instance":16420,"id":203091,"goal":"lemma SeqMemberAppend_16420(xs: seq, ys: seq)\n ensures x in xs + ys <==> x in xs || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_16421","instance":16421,"id":203092,"goal":"lemma SeqAppendLen_16421(ys: seq, s: seq)\n ensures |ys + s| == |ys| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_16422","instance":16422,"id":203093,"goal":"lemma SeqAppendNil_16422(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_16423","instance":16423,"id":203094,"goal":"lemma SeqNilAppend_16423(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_16424","instance":16424,"id":203095,"goal":"lemma SeqAppendAssoc_16424(t: seq, xs: seq, u: seq)\n ensures (t + xs) + u == t + (xs + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_16425","instance":16425,"id":203096,"goal":"lemma SeqTakeDrop_16425(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_16426","instance":16426,"id":203097,"goal":"lemma SeqReverseLen_16426(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_16427","instance":16427,"id":203098,"goal":"lemma SeqReverseIdem_16427(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_16428","instance":16428,"id":203099,"goal":"lemma SeqMapLen_16428(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_16429","instance":16429,"id":203100,"goal":"lemma SeqFilterLe_16429(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_16430","instance":16430,"id":203101,"goal":"lemma SeqMemberAppend_16430(u: seq, s: seq)\n ensures x in u + s <==> x in u || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_16431","instance":16431,"id":203102,"goal":"lemma SeqAppendLen_16431(u: seq, xs: seq)\n ensures |u + xs| == |u| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_16432","instance":16432,"id":203103,"goal":"lemma SeqAppendNil_16432(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_16433","instance":16433,"id":203104,"goal":"lemma SeqNilAppend_16433(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_16434","instance":16434,"id":203105,"goal":"lemma SeqAppendAssoc_16434(zs: seq, t: seq, u: seq)\n ensures (zs + t) + u == zs + (t + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_16435","instance":16435,"id":203106,"goal":"lemma SeqTakeDrop_16435(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_16436","instance":16436,"id":203107,"goal":"lemma SeqReverseLen_16436(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_16437","instance":16437,"id":203108,"goal":"lemma SeqReverseIdem_16437(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_16438","instance":16438,"id":203109,"goal":"lemma SeqMapLen_16438(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_16439","instance":16439,"id":203110,"goal":"lemma SeqFilterLe_16439(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_16440","instance":16440,"id":203111,"goal":"lemma SeqMemberAppend_16440(zs: seq, ys: seq)\n ensures x in zs + ys <==> x in zs || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_16441","instance":16441,"id":203112,"goal":"lemma SeqAppendLen_16441(zs: seq, t: seq)\n ensures |zs + t| == |zs| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_16442","instance":16442,"id":203113,"goal":"lemma SeqAppendNil_16442(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_16443","instance":16443,"id":203114,"goal":"lemma SeqNilAppend_16443(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_16444","instance":16444,"id":203115,"goal":"lemma SeqAppendAssoc_16444(t: seq, s: seq, ys: seq)\n ensures (t + s) + ys == t + (s + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_16445","instance":16445,"id":203116,"goal":"lemma SeqTakeDrop_16445(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_16446","instance":16446,"id":203117,"goal":"lemma SeqReverseLen_16446(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_16447","instance":16447,"id":203118,"goal":"lemma SeqReverseIdem_16447(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_16448","instance":16448,"id":203119,"goal":"lemma SeqMapLen_16448(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_16449","instance":16449,"id":203120,"goal":"lemma SeqFilterLe_16449(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_16450","instance":16450,"id":203121,"goal":"lemma SeqMemberAppend_16450(s: seq, xs: seq)\n ensures x in s + xs <==> x in s || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_16451","instance":16451,"id":203122,"goal":"lemma SeqAppendLen_16451(xs: seq, zs: seq)\n ensures |xs + zs| == |xs| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_16452","instance":16452,"id":203123,"goal":"lemma SeqAppendNil_16452(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_16453","instance":16453,"id":203124,"goal":"lemma SeqNilAppend_16453(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_16454","instance":16454,"id":203125,"goal":"lemma SeqAppendAssoc_16454(xs: seq, u: seq, t: seq)\n ensures (xs + u) + t == xs + (u + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_16455","instance":16455,"id":203126,"goal":"lemma SeqTakeDrop_16455(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_16456","instance":16456,"id":203127,"goal":"lemma SeqReverseLen_16456(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_16457","instance":16457,"id":203128,"goal":"lemma SeqReverseIdem_16457(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_16458","instance":16458,"id":203129,"goal":"lemma SeqMapLen_16458(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_16459","instance":16459,"id":203130,"goal":"lemma SeqFilterLe_16459(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_16460","instance":16460,"id":203131,"goal":"lemma SeqMemberAppend_16460(s: seq, t: seq)\n ensures x in s + t <==> x in s || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_16461","instance":16461,"id":203132,"goal":"lemma SeqAppendLen_16461(ys: seq, u: seq)\n ensures |ys + u| == |ys| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_16462","instance":16462,"id":203133,"goal":"lemma SeqAppendNil_16462(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_16463","instance":16463,"id":203134,"goal":"lemma SeqNilAppend_16463(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_16464","instance":16464,"id":203135,"goal":"lemma SeqAppendAssoc_16464(u: seq, t: seq, xs: seq)\n ensures (u + t) + xs == u + (t + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_16465","instance":16465,"id":203136,"goal":"lemma SeqTakeDrop_16465(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_16466","instance":16466,"id":203137,"goal":"lemma SeqReverseLen_16466(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_16467","instance":16467,"id":203138,"goal":"lemma SeqReverseIdem_16467(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_16468","instance":16468,"id":203139,"goal":"lemma SeqMapLen_16468(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_16469","instance":16469,"id":203140,"goal":"lemma SeqFilterLe_16469(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_16470","instance":16470,"id":203141,"goal":"lemma SeqMemberAppend_16470(u: seq, s: seq)\n ensures x in u + s <==> x in u || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_16471","instance":16471,"id":203142,"goal":"lemma SeqAppendLen_16471(u: seq, ys: seq)\n ensures |u + ys| == |u| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_16472","instance":16472,"id":203143,"goal":"lemma SeqAppendNil_16472(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_16473","instance":16473,"id":203144,"goal":"lemma SeqNilAppend_16473(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_16474","instance":16474,"id":203145,"goal":"lemma SeqAppendAssoc_16474(t: seq, ys: seq, xs: seq)\n ensures (t + ys) + xs == t + (ys + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_16475","instance":16475,"id":203146,"goal":"lemma SeqTakeDrop_16475(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_16476","instance":16476,"id":203147,"goal":"lemma SeqReverseLen_16476(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_16477","instance":16477,"id":203148,"goal":"lemma SeqReverseIdem_16477(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_16478","instance":16478,"id":203149,"goal":"lemma SeqMapLen_16478(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_16479","instance":16479,"id":203150,"goal":"lemma SeqFilterLe_16479(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_16480","instance":16480,"id":203151,"goal":"lemma SeqMemberAppend_16480(zs: seq, ys: seq)\n ensures x in zs + ys <==> x in zs || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_16481","instance":16481,"id":203152,"goal":"lemma SeqAppendLen_16481(u: seq, ys: seq)\n ensures |u + ys| == |u| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_16482","instance":16482,"id":203153,"goal":"lemma SeqAppendNil_16482(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_16483","instance":16483,"id":203154,"goal":"lemma SeqNilAppend_16483(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_16484","instance":16484,"id":203155,"goal":"lemma SeqAppendAssoc_16484(t: seq, zs: seq, s: seq)\n ensures (t + zs) + s == t + (zs + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_16485","instance":16485,"id":203156,"goal":"lemma SeqTakeDrop_16485(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_16486","instance":16486,"id":203157,"goal":"lemma SeqReverseLen_16486(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_16487","instance":16487,"id":203158,"goal":"lemma SeqReverseIdem_16487(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_16488","instance":16488,"id":203159,"goal":"lemma SeqMapLen_16488(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_16489","instance":16489,"id":203160,"goal":"lemma SeqFilterLe_16489(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_16490","instance":16490,"id":203161,"goal":"lemma SeqMemberAppend_16490(xs: seq, zs: seq)\n ensures x in xs + zs <==> x in xs || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_16491","instance":16491,"id":203162,"goal":"lemma SeqAppendLen_16491(s: seq, u: seq)\n ensures |s + u| == |s| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_16492","instance":16492,"id":203163,"goal":"lemma SeqAppendNil_16492(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_16493","instance":16493,"id":203164,"goal":"lemma SeqNilAppend_16493(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_16494","instance":16494,"id":203165,"goal":"lemma SeqAppendAssoc_16494(t: seq, ys: seq, xs: seq)\n ensures (t + ys) + xs == t + (ys + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_16495","instance":16495,"id":203166,"goal":"lemma SeqTakeDrop_16495(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_16496","instance":16496,"id":203167,"goal":"lemma SeqReverseLen_16496(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_16497","instance":16497,"id":203168,"goal":"lemma SeqReverseIdem_16497(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_16498","instance":16498,"id":203169,"goal":"lemma SeqMapLen_16498(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_16499","instance":16499,"id":203170,"goal":"lemma SeqFilterLe_16499(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_16500","instance":16500,"id":203171,"goal":"lemma SeqMemberAppend_16500(ys: seq, t: seq)\n ensures x in ys + t <==> x in ys || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_16501","instance":16501,"id":203172,"goal":"lemma SeqAppendLen_16501(u: seq, t: seq)\n ensures |u + t| == |u| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_16502","instance":16502,"id":203173,"goal":"lemma SeqAppendNil_16502(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_16503","instance":16503,"id":203174,"goal":"lemma SeqNilAppend_16503(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_16504","instance":16504,"id":203175,"goal":"lemma SeqAppendAssoc_16504(t: seq, ys: seq, u: seq)\n ensures (t + ys) + u == t + (ys + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_16505","instance":16505,"id":203176,"goal":"lemma SeqTakeDrop_16505(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_16506","instance":16506,"id":203177,"goal":"lemma SeqReverseLen_16506(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_16507","instance":16507,"id":203178,"goal":"lemma SeqReverseIdem_16507(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_16508","instance":16508,"id":203179,"goal":"lemma SeqMapLen_16508(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_16509","instance":16509,"id":203180,"goal":"lemma SeqFilterLe_16509(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_16510","instance":16510,"id":203181,"goal":"lemma SeqMemberAppend_16510(zs: seq, xs: seq)\n ensures x in zs + xs <==> x in zs || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_16511","instance":16511,"id":203182,"goal":"lemma SeqAppendLen_16511(zs: seq, s: seq)\n ensures |zs + s| == |zs| + |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_16512","instance":16512,"id":203183,"goal":"lemma SeqAppendNil_16512(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_16513","instance":16513,"id":203184,"goal":"lemma SeqNilAppend_16513(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_16514","instance":16514,"id":203185,"goal":"lemma SeqAppendAssoc_16514(s: seq, ys: seq, zs: seq)\n ensures (s + ys) + zs == s + (ys + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_16515","instance":16515,"id":203186,"goal":"lemma SeqTakeDrop_16515(zs: seq)\n ensures zs == zs[..|zs|] + zs[|zs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_16516","instance":16516,"id":203187,"goal":"lemma SeqReverseLen_16516(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_16517","instance":16517,"id":203188,"goal":"lemma SeqReverseIdem_16517(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_16518","instance":16518,"id":203189,"goal":"lemma SeqMapLen_16518(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_16519","instance":16519,"id":203190,"goal":"lemma SeqFilterLe_16519(zs: seq)\n ensures |Filter(P, zs)| <= |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_16520","instance":16520,"id":203191,"goal":"lemma SeqMemberAppend_16520(s: seq, u: seq)\n ensures x in s + u <==> x in s || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_16521","instance":16521,"id":203192,"goal":"lemma SeqAppendLen_16521(u: seq, zs: seq)\n ensures |u + zs| == |u| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_16522","instance":16522,"id":203193,"goal":"lemma SeqAppendNil_16522(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_16523","instance":16523,"id":203194,"goal":"lemma SeqNilAppend_16523(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_16524","instance":16524,"id":203195,"goal":"lemma SeqAppendAssoc_16524(s: seq, t: seq, zs: seq)\n ensures (s + t) + zs == s + (t + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_16525","instance":16525,"id":203196,"goal":"lemma SeqTakeDrop_16525(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_16526","instance":16526,"id":203197,"goal":"lemma SeqReverseLen_16526(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_16527","instance":16527,"id":203198,"goal":"lemma SeqReverseIdem_16527(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_16528","instance":16528,"id":203199,"goal":"lemma SeqMapLen_16528(s: seq)\n ensures |Map(f, s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_16529","instance":16529,"id":203200,"goal":"lemma SeqFilterLe_16529(xs: seq)\n ensures |Filter(P, xs)| <= |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_16530","instance":16530,"id":203201,"goal":"lemma SeqMemberAppend_16530(zs: seq, ys: seq)\n ensures x in zs + ys <==> x in zs || x in ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_16531","instance":16531,"id":203202,"goal":"lemma SeqAppendLen_16531(ys: seq, xs: seq)\n ensures |ys + xs| == |ys| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_16532","instance":16532,"id":203203,"goal":"lemma SeqAppendNil_16532(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_16533","instance":16533,"id":203204,"goal":"lemma SeqNilAppend_16533(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_16534","instance":16534,"id":203205,"goal":"lemma SeqAppendAssoc_16534(xs: seq, t: seq, u: seq)\n ensures (xs + t) + u == xs + (t + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_16535","instance":16535,"id":203206,"goal":"lemma SeqTakeDrop_16535(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_16536","instance":16536,"id":203207,"goal":"lemma SeqReverseLen_16536(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_16537","instance":16537,"id":203208,"goal":"lemma SeqReverseIdem_16537(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_16538","instance":16538,"id":203209,"goal":"lemma SeqMapLen_16538(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_16539","instance":16539,"id":203210,"goal":"lemma SeqFilterLe_16539(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_16540","instance":16540,"id":203211,"goal":"lemma SeqMemberAppend_16540(s: seq, t: seq)\n ensures x in s + t <==> x in s || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_16541","instance":16541,"id":203212,"goal":"lemma SeqAppendLen_16541(zs: seq, ys: seq)\n ensures |zs + ys| == |zs| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_16542","instance":16542,"id":203213,"goal":"lemma SeqAppendNil_16542(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_16543","instance":16543,"id":203214,"goal":"lemma SeqNilAppend_16543(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_16544","instance":16544,"id":203215,"goal":"lemma SeqAppendAssoc_16544(xs: seq, s: seq, ys: seq)\n ensures (xs + s) + ys == xs + (s + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_16545","instance":16545,"id":203216,"goal":"lemma SeqTakeDrop_16545(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_16546","instance":16546,"id":203217,"goal":"lemma SeqReverseLen_16546(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_16547","instance":16547,"id":203218,"goal":"lemma SeqReverseIdem_16547(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_16548","instance":16548,"id":203219,"goal":"lemma SeqMapLen_16548(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_16549","instance":16549,"id":203220,"goal":"lemma SeqFilterLe_16549(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_16550","instance":16550,"id":203221,"goal":"lemma SeqMemberAppend_16550(xs: seq, s: seq)\n ensures x in xs + s <==> x in xs || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_16551","instance":16551,"id":203222,"goal":"lemma SeqAppendLen_16551(s: seq, zs: seq)\n ensures |s + zs| == |s| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_16552","instance":16552,"id":203223,"goal":"lemma SeqAppendNil_16552(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_16553","instance":16553,"id":203224,"goal":"lemma SeqNilAppend_16553(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_16554","instance":16554,"id":203225,"goal":"lemma SeqAppendAssoc_16554(s: seq, u: seq, zs: seq)\n ensures (s + u) + zs == s + (u + zs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_16555","instance":16555,"id":203226,"goal":"lemma SeqTakeDrop_16555(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_16556","instance":16556,"id":203227,"goal":"lemma SeqReverseLen_16556(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_16557","instance":16557,"id":203228,"goal":"lemma SeqReverseIdem_16557(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_16558","instance":16558,"id":203229,"goal":"lemma SeqMapLen_16558(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_16559","instance":16559,"id":203230,"goal":"lemma SeqFilterLe_16559(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_16560","instance":16560,"id":203231,"goal":"lemma SeqMemberAppend_16560(s: seq, u: seq)\n ensures x in s + u <==> x in s || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_16561","instance":16561,"id":203232,"goal":"lemma SeqAppendLen_16561(xs: seq, t: seq)\n ensures |xs + t| == |xs| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_16562","instance":16562,"id":203233,"goal":"lemma SeqAppendNil_16562(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_16563","instance":16563,"id":203234,"goal":"lemma SeqNilAppend_16563(xs: seq)\n ensures [] + xs == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_16564","instance":16564,"id":203235,"goal":"lemma SeqAppendAssoc_16564(u: seq, ys: seq, t: seq)\n ensures (u + ys) + t == u + (ys + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_16565","instance":16565,"id":203236,"goal":"lemma SeqTakeDrop_16565(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_16566","instance":16566,"id":203237,"goal":"lemma SeqReverseLen_16566(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_16567","instance":16567,"id":203238,"goal":"lemma SeqReverseIdem_16567(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_16568","instance":16568,"id":203239,"goal":"lemma SeqMapLen_16568(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_16569","instance":16569,"id":203240,"goal":"lemma SeqFilterLe_16569(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_16570","instance":16570,"id":203241,"goal":"lemma SeqMemberAppend_16570(t: seq, xs: seq)\n ensures x in t + xs <==> x in t || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_16571","instance":16571,"id":203242,"goal":"lemma SeqAppendLen_16571(xs: seq, t: seq)\n ensures |xs + t| == |xs| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_16572","instance":16572,"id":203243,"goal":"lemma SeqAppendNil_16572(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_16573","instance":16573,"id":203244,"goal":"lemma SeqNilAppend_16573(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_16574","instance":16574,"id":203245,"goal":"lemma SeqAppendAssoc_16574(ys: seq, u: seq, t: seq)\n ensures (ys + u) + t == ys + (u + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_16575","instance":16575,"id":203246,"goal":"lemma SeqTakeDrop_16575(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_16576","instance":16576,"id":203247,"goal":"lemma SeqReverseLen_16576(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_16577","instance":16577,"id":203248,"goal":"lemma SeqReverseIdem_16577(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_16578","instance":16578,"id":203249,"goal":"lemma SeqMapLen_16578(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_16579","instance":16579,"id":203250,"goal":"lemma SeqFilterLe_16579(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_16580","instance":16580,"id":203251,"goal":"lemma SeqMemberAppend_16580(xs: seq, zs: seq)\n ensures x in xs + zs <==> x in xs || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_16581","instance":16581,"id":203252,"goal":"lemma SeqAppendLen_16581(zs: seq, xs: seq)\n ensures |zs + xs| == |zs| + |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_16582","instance":16582,"id":203253,"goal":"lemma SeqAppendNil_16582(t: seq)\n ensures t + [] == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_16583","instance":16583,"id":203254,"goal":"lemma SeqNilAppend_16583(s: seq)\n ensures [] + s == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_16584","instance":16584,"id":203255,"goal":"lemma SeqAppendAssoc_16584(zs: seq, t: seq, xs: seq)\n ensures (zs + t) + xs == zs + (t + xs)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_16585","instance":16585,"id":203256,"goal":"lemma SeqTakeDrop_16585(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_16586","instance":16586,"id":203257,"goal":"lemma SeqReverseLen_16586(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_16587","instance":16587,"id":203258,"goal":"lemma SeqReverseIdem_16587(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_16588","instance":16588,"id":203259,"goal":"lemma SeqMapLen_16588(u: seq)\n ensures |Map(f, u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_16589","instance":16589,"id":203260,"goal":"lemma SeqFilterLe_16589(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_16590","instance":16590,"id":203261,"goal":"lemma SeqMemberAppend_16590(xs: seq, s: seq)\n ensures x in xs + s <==> x in xs || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_16591","instance":16591,"id":203262,"goal":"lemma SeqAppendLen_16591(u: seq, ys: seq)\n ensures |u + ys| == |u| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_16592","instance":16592,"id":203263,"goal":"lemma SeqAppendNil_16592(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_16593","instance":16593,"id":203264,"goal":"lemma SeqNilAppend_16593(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_16594","instance":16594,"id":203265,"goal":"lemma SeqAppendAssoc_16594(s: seq, xs: seq, ys: seq)\n ensures (s + xs) + ys == s + (xs + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_16595","instance":16595,"id":203266,"goal":"lemma SeqTakeDrop_16595(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_16596","instance":16596,"id":203267,"goal":"lemma SeqReverseLen_16596(ys: seq)\n ensures |Reverse(ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_16597","instance":16597,"id":203268,"goal":"lemma SeqReverseIdem_16597(s: seq)\n ensures Reverse(Reverse(s)) == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_16598","instance":16598,"id":203269,"goal":"lemma SeqMapLen_16598(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_16599","instance":16599,"id":203270,"goal":"lemma SeqFilterLe_16599(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_16600","instance":16600,"id":203271,"goal":"lemma SeqMemberAppend_16600(zs: seq, s: seq)\n ensures x in zs + s <==> x in zs || x in s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_16601","instance":16601,"id":203272,"goal":"lemma SeqAppendLen_16601(xs: seq, ys: seq)\n ensures |xs + ys| == |xs| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_16602","instance":16602,"id":203273,"goal":"lemma SeqAppendNil_16602(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_16603","instance":16603,"id":203274,"goal":"lemma SeqNilAppend_16603(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_16604","instance":16604,"id":203275,"goal":"lemma SeqAppendAssoc_16604(xs: seq, t: seq, ys: seq)\n ensures (xs + t) + ys == xs + (t + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_16605","instance":16605,"id":203276,"goal":"lemma SeqTakeDrop_16605(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_16606","instance":16606,"id":203277,"goal":"lemma SeqReverseLen_16606(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_16607","instance":16607,"id":203278,"goal":"lemma SeqReverseIdem_16607(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_16608","instance":16608,"id":203279,"goal":"lemma SeqMapLen_16608(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_16609","instance":16609,"id":203280,"goal":"lemma SeqFilterLe_16609(t: seq)\n ensures |Filter(P, t)| <= |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_16610","instance":16610,"id":203281,"goal":"lemma SeqMemberAppend_16610(s: seq, u: seq)\n ensures x in s + u <==> x in s || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_16611","instance":16611,"id":203282,"goal":"lemma SeqAppendLen_16611(s: seq, u: seq)\n ensures |s + u| == |s| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_16612","instance":16612,"id":203283,"goal":"lemma SeqAppendNil_16612(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_16613","instance":16613,"id":203284,"goal":"lemma SeqNilAppend_16613(zs: seq)\n ensures [] + zs == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_16614","instance":16614,"id":203285,"goal":"lemma SeqAppendAssoc_16614(s: seq, xs: seq, u: seq)\n ensures (s + xs) + u == s + (xs + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_16615","instance":16615,"id":203286,"goal":"lemma SeqTakeDrop_16615(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_16616","instance":16616,"id":203287,"goal":"lemma SeqReverseLen_16616(xs: seq)\n ensures |Reverse(xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_16617","instance":16617,"id":203288,"goal":"lemma SeqReverseIdem_16617(xs: seq)\n ensures Reverse(Reverse(xs)) == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_16618","instance":16618,"id":203289,"goal":"lemma SeqMapLen_16618(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_16619","instance":16619,"id":203290,"goal":"lemma SeqFilterLe_16619(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_16620","instance":16620,"id":203291,"goal":"lemma SeqMemberAppend_16620(zs: seq, xs: seq)\n ensures x in zs + xs <==> x in zs || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_16621","instance":16621,"id":203292,"goal":"lemma SeqAppendLen_16621(ys: seq, u: seq)\n ensures |ys + u| == |ys| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_16622","instance":16622,"id":203293,"goal":"lemma SeqAppendNil_16622(xs: seq)\n ensures xs + [] == xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_16623","instance":16623,"id":203294,"goal":"lemma SeqNilAppend_16623(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_16624","instance":16624,"id":203295,"goal":"lemma SeqAppendAssoc_16624(u: seq, t: seq, s: seq)\n ensures (u + t) + s == u + (t + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_16625","instance":16625,"id":203296,"goal":"lemma SeqTakeDrop_16625(ys: seq)\n ensures ys == ys[..|ys|] + ys[|ys|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_16626","instance":16626,"id":203297,"goal":"lemma SeqReverseLen_16626(zs: seq)\n ensures |Reverse(zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_16627","instance":16627,"id":203298,"goal":"lemma SeqReverseIdem_16627(u: seq)\n ensures Reverse(Reverse(u)) == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_16628","instance":16628,"id":203299,"goal":"lemma SeqMapLen_16628(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_16629","instance":16629,"id":203300,"goal":"lemma SeqFilterLe_16629(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_16630","instance":16630,"id":203301,"goal":"lemma SeqMemberAppend_16630(ys: seq, xs: seq)\n ensures x in ys + xs <==> x in ys || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_16631","instance":16631,"id":203302,"goal":"lemma SeqAppendLen_16631(xs: seq, u: seq)\n ensures |xs + u| == |xs| + |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_16632","instance":16632,"id":203303,"goal":"lemma SeqAppendNil_16632(s: seq)\n ensures s + [] == s\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_16633","instance":16633,"id":203304,"goal":"lemma SeqNilAppend_16633(t: seq)\n ensures [] + t == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_16634","instance":16634,"id":203305,"goal":"lemma SeqAppendAssoc_16634(t: seq, zs: seq, u: seq)\n ensures (t + zs) + u == t + (zs + u)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_16635","instance":16635,"id":203306,"goal":"lemma SeqTakeDrop_16635(xs: seq)\n ensures xs == xs[..|xs|] + xs[|xs|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_16636","instance":16636,"id":203307,"goal":"lemma SeqReverseLen_16636(u: seq)\n ensures |Reverse(u)| == |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_16637","instance":16637,"id":203308,"goal":"lemma SeqReverseIdem_16637(zs: seq)\n ensures Reverse(Reverse(zs)) == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_16638","instance":16638,"id":203309,"goal":"lemma SeqMapLen_16638(ys: seq)\n ensures |Map(f, ys)| == |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_16639","instance":16639,"id":203310,"goal":"lemma SeqFilterLe_16639(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_16640","instance":16640,"id":203311,"goal":"lemma SeqMemberAppend_16640(xs: seq, u: seq)\n ensures x in xs + u <==> x in xs || x in u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_16641","instance":16641,"id":203312,"goal":"lemma SeqAppendLen_16641(u: seq, ys: seq)\n ensures |u + ys| == |u| + |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_16642","instance":16642,"id":203313,"goal":"lemma SeqAppendNil_16642(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_16643","instance":16643,"id":203314,"goal":"lemma SeqNilAppend_16643(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_16644","instance":16644,"id":203315,"goal":"lemma SeqAppendAssoc_16644(zs: seq, u: seq, t: seq)\n ensures (zs + u) + t == zs + (u + t)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_16645","instance":16645,"id":203316,"goal":"lemma SeqTakeDrop_16645(u: seq)\n ensures u == u[..|u|] + u[|u|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_16646","instance":16646,"id":203317,"goal":"lemma SeqReverseLen_16646(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_16647","instance":16647,"id":203318,"goal":"lemma SeqReverseIdem_16647(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_16648","instance":16648,"id":203319,"goal":"lemma SeqMapLen_16648(zs: seq)\n ensures |Map(f, zs)| == |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_16649","instance":16649,"id":203320,"goal":"lemma SeqFilterLe_16649(ys: seq)\n ensures |Filter(P, ys)| <= |ys|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_16650","instance":16650,"id":203321,"goal":"lemma SeqMemberAppend_16650(t: seq, xs: seq)\n ensures x in t + xs <==> x in t || x in xs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_16651","instance":16651,"id":203322,"goal":"lemma SeqAppendLen_16651(u: seq, t: seq)\n ensures |u + t| == |u| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_16652","instance":16652,"id":203323,"goal":"lemma SeqAppendNil_16652(ys: seq)\n ensures ys + [] == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_16653","instance":16653,"id":203324,"goal":"lemma SeqNilAppend_16653(u: seq)\n ensures [] + u == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_16654","instance":16654,"id":203325,"goal":"lemma SeqAppendAssoc_16654(t: seq, zs: seq, ys: seq)\n ensures (t + zs) + ys == t + (zs + ys)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_16655","instance":16655,"id":203326,"goal":"lemma SeqTakeDrop_16655(s: seq)\n ensures s == s[..|s|] + s[|s|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_16656","instance":16656,"id":203327,"goal":"lemma SeqReverseLen_16656(s: seq)\n ensures |Reverse(s)| == |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_16657","instance":16657,"id":203328,"goal":"lemma SeqReverseIdem_16657(t: seq)\n ensures Reverse(Reverse(t)) == t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_16658","instance":16658,"id":203329,"goal":"lemma SeqMapLen_16658(xs: seq)\n ensures |Map(f, xs)| == |xs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_16659","instance":16659,"id":203330,"goal":"lemma SeqFilterLe_16659(u: seq)\n ensures |Filter(P, u)| <= |u|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_16660","instance":16660,"id":203331,"goal":"lemma SeqMemberAppend_16660(xs: seq, zs: seq)\n ensures x in xs + zs <==> x in xs || x in zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_16661","instance":16661,"id":203332,"goal":"lemma SeqAppendLen_16661(xs: seq, zs: seq)\n ensures |xs + zs| == |xs| + |zs|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_16662","instance":16662,"id":203333,"goal":"lemma SeqAppendNil_16662(u: seq)\n ensures u + [] == u\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqNilAppend","theorem":"SeqNilAppend_16663","instance":16663,"id":203334,"goal":"lemma SeqNilAppend_16663(ys: seq)\n ensures [] + ys == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendAssoc","theorem":"SeqAppendAssoc_16664","instance":16664,"id":203335,"goal":"lemma SeqAppendAssoc_16664(t: seq, xs: seq, s: seq)\n ensures (t + xs) + s == t + (xs + s)\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqTakeDrop","theorem":"SeqTakeDrop_16665","instance":16665,"id":203336,"goal":"lemma SeqTakeDrop_16665(t: seq)\n ensures t == t[..|t|] + t[|t|..]\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseLen","theorem":"SeqReverseLen_16666","instance":16666,"id":203337,"goal":"lemma SeqReverseLen_16666(t: seq)\n ensures |Reverse(t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqReverseIdem","theorem":"SeqReverseIdem_16667","instance":16667,"id":203338,"goal":"lemma SeqReverseIdem_16667(ys: seq)\n ensures Reverse(Reverse(ys)) == ys\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMapLen","theorem":"SeqMapLen_16668","instance":16668,"id":203339,"goal":"lemma SeqMapLen_16668(t: seq)\n ensures |Map(f, t)| == |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqFilterLe","theorem":"SeqFilterLe_16669","instance":16669,"id":203340,"goal":"lemma SeqFilterLe_16669(s: seq)\n ensures |Filter(P, s)| <= |s|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqMemberAppend","theorem":"SeqMemberAppend_16670","instance":16670,"id":203341,"goal":"lemma SeqMemberAppend_16670(xs: seq, t: seq)\n ensures x in xs + t <==> x in xs || x in t\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendLen","theorem":"SeqAppendLen_16671","instance":16671,"id":203342,"goal":"lemma SeqAppendLen_16671(zs: seq, t: seq)\n ensures |zs + t| == |zs| + |t|\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sequences","variant":"SeqAppendNil","theorem":"SeqAppendNil_16672","instance":16672,"id":203343,"goal":"lemma SeqAppendNil_16672(zs: seq)\n ensures zs + [] == zs\n{}","type_family":"seq","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_1","instance":1,"id":203344,"goal":"lemma SetUnionComm_1(A: set, T: set)\n ensures A + T == T + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_2","instance":2,"id":203345,"goal":"lemma SetInterComm_2(U: set, T: set)\n ensures U * T == T * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_3","instance":3,"id":203346,"goal":"lemma SetUnionAssoc_3(A: set, T: set, B: set)\n ensures (A + T) + B == A + (T + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_4","instance":4,"id":203347,"goal":"lemma SetSubsetRefl_4(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_5","instance":5,"id":203348,"goal":"lemma SetSubsetTrans_5(B: set, S: set, A: set)\n requires B <= S && S <= A\n ensures B <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_6","instance":6,"id":203349,"goal":"lemma SetUnionEmpty_6(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_7","instance":7,"id":203350,"goal":"lemma SetInterEmpty_7(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_8","instance":8,"id":203351,"goal":"lemma SetInterSubset_8(U: set, S: set)\n ensures U * S <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_9","instance":9,"id":203352,"goal":"lemma SetCardSubset_9(S: set, A: set)\n requires S <= A\n ensures |S| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_10","instance":10,"id":203353,"goal":"lemma SetUnionCard_10(S: set, U: set)\n requires S * U == {}\n ensures |S + U| == |S| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_11","instance":11,"id":203354,"goal":"lemma SetUnionComm_11(T: set, U: set)\n ensures T + U == U + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_12","instance":12,"id":203355,"goal":"lemma SetInterComm_12(S: set, B: set)\n ensures S * B == B * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_13","instance":13,"id":203356,"goal":"lemma SetUnionAssoc_13(S: set, B: set, U: set)\n ensures (S + B) + U == S + (B + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_14","instance":14,"id":203357,"goal":"lemma SetSubsetRefl_14(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_15","instance":15,"id":203358,"goal":"lemma SetSubsetTrans_15(T: set, A: set, B: set)\n requires T <= A && A <= B\n ensures T <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_16","instance":16,"id":203359,"goal":"lemma SetUnionEmpty_16(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_17","instance":17,"id":203360,"goal":"lemma SetInterEmpty_17(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_18","instance":18,"id":203361,"goal":"lemma SetInterSubset_18(U: set, S: set)\n ensures U * S <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_19","instance":19,"id":203362,"goal":"lemma SetCardSubset_19(A: set, S: set)\n requires A <= S\n ensures |A| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_20","instance":20,"id":203363,"goal":"lemma SetUnionCard_20(T: set, B: set)\n requires T * B == {}\n ensures |T + B| == |T| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_21","instance":21,"id":203364,"goal":"lemma SetUnionComm_21(S: set, T: set)\n ensures S + T == T + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_22","instance":22,"id":203365,"goal":"lemma SetInterComm_22(B: set, T: set)\n ensures B * T == T * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_23","instance":23,"id":203366,"goal":"lemma SetUnionAssoc_23(U: set, B: set, T: set)\n ensures (U + B) + T == U + (B + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_24","instance":24,"id":203367,"goal":"lemma SetSubsetRefl_24(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_25","instance":25,"id":203368,"goal":"lemma SetSubsetTrans_25(B: set, A: set, U: set)\n requires B <= A && A <= U\n ensures B <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_26","instance":26,"id":203369,"goal":"lemma SetUnionEmpty_26(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_27","instance":27,"id":203370,"goal":"lemma SetInterEmpty_27(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_28","instance":28,"id":203371,"goal":"lemma SetInterSubset_28(T: set, B: set)\n ensures T * B <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_29","instance":29,"id":203372,"goal":"lemma SetCardSubset_29(U: set, A: set)\n requires U <= A\n ensures |U| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_30","instance":30,"id":203373,"goal":"lemma SetUnionCard_30(U: set, T: set)\n requires U * T == {}\n ensures |U + T| == |U| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_31","instance":31,"id":203374,"goal":"lemma SetUnionComm_31(B: set, S: set)\n ensures B + S == S + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_32","instance":32,"id":203375,"goal":"lemma SetInterComm_32(B: set, S: set)\n ensures B * S == S * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_33","instance":33,"id":203376,"goal":"lemma SetUnionAssoc_33(B: set, A: set, T: set)\n ensures (B + A) + T == B + (A + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_34","instance":34,"id":203377,"goal":"lemma SetSubsetRefl_34(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_35","instance":35,"id":203378,"goal":"lemma SetSubsetTrans_35(S: set, B: set, A: set)\n requires S <= B && B <= A\n ensures S <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_36","instance":36,"id":203379,"goal":"lemma SetUnionEmpty_36(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_37","instance":37,"id":203380,"goal":"lemma SetInterEmpty_37(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_38","instance":38,"id":203381,"goal":"lemma SetInterSubset_38(U: set, S: set)\n ensures U * S <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_39","instance":39,"id":203382,"goal":"lemma SetCardSubset_39(T: set, S: set)\n requires T <= S\n ensures |T| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_40","instance":40,"id":203383,"goal":"lemma SetUnionCard_40(B: set, A: set)\n requires B * A == {}\n ensures |B + A| == |B| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_41","instance":41,"id":203384,"goal":"lemma SetUnionComm_41(T: set, U: set)\n ensures T + U == U + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_42","instance":42,"id":203385,"goal":"lemma SetInterComm_42(S: set, T: set)\n ensures S * T == T * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_43","instance":43,"id":203386,"goal":"lemma SetUnionAssoc_43(A: set, U: set, B: set)\n ensures (A + U) + B == A + (U + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_44","instance":44,"id":203387,"goal":"lemma SetSubsetRefl_44(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_45","instance":45,"id":203388,"goal":"lemma SetSubsetTrans_45(T: set, U: set, S: set)\n requires T <= U && U <= S\n ensures T <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_46","instance":46,"id":203389,"goal":"lemma SetUnionEmpty_46(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_47","instance":47,"id":203390,"goal":"lemma SetInterEmpty_47(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_48","instance":48,"id":203391,"goal":"lemma SetInterSubset_48(S: set, U: set)\n ensures S * U <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_49","instance":49,"id":203392,"goal":"lemma SetCardSubset_49(A: set, S: set)\n requires A <= S\n ensures |A| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_50","instance":50,"id":203393,"goal":"lemma SetUnionCard_50(U: set, A: set)\n requires U * A == {}\n ensures |U + A| == |U| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_51","instance":51,"id":203394,"goal":"lemma SetUnionComm_51(T: set, U: set)\n ensures T + U == U + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_52","instance":52,"id":203395,"goal":"lemma SetInterComm_52(A: set, S: set)\n ensures A * S == S * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_53","instance":53,"id":203396,"goal":"lemma SetUnionAssoc_53(U: set, S: set, T: set)\n ensures (U + S) + T == U + (S + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_54","instance":54,"id":203397,"goal":"lemma SetSubsetRefl_54(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_55","instance":55,"id":203398,"goal":"lemma SetSubsetTrans_55(T: set, A: set, U: set)\n requires T <= A && A <= U\n ensures T <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_56","instance":56,"id":203399,"goal":"lemma SetUnionEmpty_56(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_57","instance":57,"id":203400,"goal":"lemma SetInterEmpty_57(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_58","instance":58,"id":203401,"goal":"lemma SetInterSubset_58(A: set, S: set)\n ensures A * S <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_59","instance":59,"id":203402,"goal":"lemma SetCardSubset_59(U: set, B: set)\n requires U <= B\n ensures |U| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_60","instance":60,"id":203403,"goal":"lemma SetUnionCard_60(U: set, B: set)\n requires U * B == {}\n ensures |U + B| == |U| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_61","instance":61,"id":203404,"goal":"lemma SetUnionComm_61(B: set, T: set)\n ensures B + T == T + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_62","instance":62,"id":203405,"goal":"lemma SetInterComm_62(T: set, A: set)\n ensures T * A == A * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_63","instance":63,"id":203406,"goal":"lemma SetUnionAssoc_63(A: set, B: set, S: set)\n ensures (A + B) + S == A + (B + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_64","instance":64,"id":203407,"goal":"lemma SetSubsetRefl_64(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_65","instance":65,"id":203408,"goal":"lemma SetSubsetTrans_65(T: set, S: set, A: set)\n requires T <= S && S <= A\n ensures T <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_66","instance":66,"id":203409,"goal":"lemma SetUnionEmpty_66(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_67","instance":67,"id":203410,"goal":"lemma SetInterEmpty_67(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_68","instance":68,"id":203411,"goal":"lemma SetInterSubset_68(A: set, B: set)\n ensures A * B <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_69","instance":69,"id":203412,"goal":"lemma SetCardSubset_69(S: set, T: set)\n requires S <= T\n ensures |S| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_70","instance":70,"id":203413,"goal":"lemma SetUnionCard_70(S: set, U: set)\n requires S * U == {}\n ensures |S + U| == |S| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_71","instance":71,"id":203414,"goal":"lemma SetUnionComm_71(A: set, T: set)\n ensures A + T == T + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_72","instance":72,"id":203415,"goal":"lemma SetInterComm_72(U: set, A: set)\n ensures U * A == A * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_73","instance":73,"id":203416,"goal":"lemma SetUnionAssoc_73(S: set, B: set, T: set)\n ensures (S + B) + T == S + (B + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_74","instance":74,"id":203417,"goal":"lemma SetSubsetRefl_74(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_75","instance":75,"id":203418,"goal":"lemma SetSubsetTrans_75(B: set, T: set, U: set)\n requires B <= T && T <= U\n ensures B <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_76","instance":76,"id":203419,"goal":"lemma SetUnionEmpty_76(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_77","instance":77,"id":203420,"goal":"lemma SetInterEmpty_77(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_78","instance":78,"id":203421,"goal":"lemma SetInterSubset_78(S: set, A: set)\n ensures S * A <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_79","instance":79,"id":203422,"goal":"lemma SetCardSubset_79(U: set, A: set)\n requires U <= A\n ensures |U| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_80","instance":80,"id":203423,"goal":"lemma SetUnionCard_80(S: set, A: set)\n requires S * A == {}\n ensures |S + A| == |S| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_81","instance":81,"id":203424,"goal":"lemma SetUnionComm_81(U: set, A: set)\n ensures U + A == A + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_82","instance":82,"id":203425,"goal":"lemma SetInterComm_82(A: set, S: set)\n ensures A * S == S * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_83","instance":83,"id":203426,"goal":"lemma SetUnionAssoc_83(B: set, U: set, A: set)\n ensures (B + U) + A == B + (U + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_84","instance":84,"id":203427,"goal":"lemma SetSubsetRefl_84(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_85","instance":85,"id":203428,"goal":"lemma SetSubsetTrans_85(U: set, B: set, S: set)\n requires U <= B && B <= S\n ensures U <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_86","instance":86,"id":203429,"goal":"lemma SetUnionEmpty_86(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_87","instance":87,"id":203430,"goal":"lemma SetInterEmpty_87(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_88","instance":88,"id":203431,"goal":"lemma SetInterSubset_88(S: set, A: set)\n ensures S * A <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_89","instance":89,"id":203432,"goal":"lemma SetCardSubset_89(B: set, T: set)\n requires B <= T\n ensures |B| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_90","instance":90,"id":203433,"goal":"lemma SetUnionCard_90(B: set, A: set)\n requires B * A == {}\n ensures |B + A| == |B| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_91","instance":91,"id":203434,"goal":"lemma SetUnionComm_91(T: set, S: set)\n ensures T + S == S + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_92","instance":92,"id":203435,"goal":"lemma SetInterComm_92(A: set, U: set)\n ensures A * U == U * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_93","instance":93,"id":203436,"goal":"lemma SetUnionAssoc_93(B: set, T: set, A: set)\n ensures (B + T) + A == B + (T + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_94","instance":94,"id":203437,"goal":"lemma SetSubsetRefl_94(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_95","instance":95,"id":203438,"goal":"lemma SetSubsetTrans_95(B: set, U: set, A: set)\n requires B <= U && U <= A\n ensures B <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_96","instance":96,"id":203439,"goal":"lemma SetUnionEmpty_96(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_97","instance":97,"id":203440,"goal":"lemma SetInterEmpty_97(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_98","instance":98,"id":203441,"goal":"lemma SetInterSubset_98(B: set, T: set)\n ensures B * T <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_99","instance":99,"id":203442,"goal":"lemma SetCardSubset_99(U: set, A: set)\n requires U <= A\n ensures |U| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_100","instance":100,"id":203443,"goal":"lemma SetUnionCard_100(A: set, B: set)\n requires A * B == {}\n ensures |A + B| == |A| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_101","instance":101,"id":203444,"goal":"lemma SetUnionComm_101(B: set, S: set)\n ensures B + S == S + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_102","instance":102,"id":203445,"goal":"lemma SetInterComm_102(B: set, U: set)\n ensures B * U == U * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_103","instance":103,"id":203446,"goal":"lemma SetUnionAssoc_103(T: set, A: set, B: set)\n ensures (T + A) + B == T + (A + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_104","instance":104,"id":203447,"goal":"lemma SetSubsetRefl_104(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_105","instance":105,"id":203448,"goal":"lemma SetSubsetTrans_105(T: set, S: set, B: set)\n requires T <= S && S <= B\n ensures T <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_106","instance":106,"id":203449,"goal":"lemma SetUnionEmpty_106(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_107","instance":107,"id":203450,"goal":"lemma SetInterEmpty_107(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_108","instance":108,"id":203451,"goal":"lemma SetInterSubset_108(B: set, S: set)\n ensures B * S <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_109","instance":109,"id":203452,"goal":"lemma SetCardSubset_109(S: set, A: set)\n requires S <= A\n ensures |S| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_110","instance":110,"id":203453,"goal":"lemma SetUnionCard_110(A: set, B: set)\n requires A * B == {}\n ensures |A + B| == |A| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_111","instance":111,"id":203454,"goal":"lemma SetUnionComm_111(A: set, B: set)\n ensures A + B == B + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_112","instance":112,"id":203455,"goal":"lemma SetInterComm_112(U: set, T: set)\n ensures U * T == T * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_113","instance":113,"id":203456,"goal":"lemma SetUnionAssoc_113(B: set, T: set, A: set)\n ensures (B + T) + A == B + (T + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_114","instance":114,"id":203457,"goal":"lemma SetSubsetRefl_114(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_115","instance":115,"id":203458,"goal":"lemma SetSubsetTrans_115(U: set, B: set, A: set)\n requires U <= B && B <= A\n ensures U <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_116","instance":116,"id":203459,"goal":"lemma SetUnionEmpty_116(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_117","instance":117,"id":203460,"goal":"lemma SetInterEmpty_117(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_118","instance":118,"id":203461,"goal":"lemma SetInterSubset_118(U: set, T: set)\n ensures U * T <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_119","instance":119,"id":203462,"goal":"lemma SetCardSubset_119(T: set, A: set)\n requires T <= A\n ensures |T| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_120","instance":120,"id":203463,"goal":"lemma SetUnionCard_120(S: set, U: set)\n requires S * U == {}\n ensures |S + U| == |S| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_121","instance":121,"id":203464,"goal":"lemma SetUnionComm_121(T: set, B: set)\n ensures T + B == B + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_122","instance":122,"id":203465,"goal":"lemma SetInterComm_122(U: set, A: set)\n ensures U * A == A * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_123","instance":123,"id":203466,"goal":"lemma SetUnionAssoc_123(T: set, S: set, B: set)\n ensures (T + S) + B == T + (S + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_124","instance":124,"id":203467,"goal":"lemma SetSubsetRefl_124(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_125","instance":125,"id":203468,"goal":"lemma SetSubsetTrans_125(B: set, S: set, A: set)\n requires B <= S && S <= A\n ensures B <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_126","instance":126,"id":203469,"goal":"lemma SetUnionEmpty_126(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_127","instance":127,"id":203470,"goal":"lemma SetInterEmpty_127(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_128","instance":128,"id":203471,"goal":"lemma SetInterSubset_128(S: set, T: set)\n ensures S * T <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_129","instance":129,"id":203472,"goal":"lemma SetCardSubset_129(T: set, U: set)\n requires T <= U\n ensures |T| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_130","instance":130,"id":203473,"goal":"lemma SetUnionCard_130(A: set, S: set)\n requires A * S == {}\n ensures |A + S| == |A| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_131","instance":131,"id":203474,"goal":"lemma SetUnionComm_131(T: set, S: set)\n ensures T + S == S + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_132","instance":132,"id":203475,"goal":"lemma SetInterComm_132(U: set, T: set)\n ensures U * T == T * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_133","instance":133,"id":203476,"goal":"lemma SetUnionAssoc_133(U: set, T: set, A: set)\n ensures (U + T) + A == U + (T + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_134","instance":134,"id":203477,"goal":"lemma SetSubsetRefl_134(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_135","instance":135,"id":203478,"goal":"lemma SetSubsetTrans_135(S: set, T: set, B: set)\n requires S <= T && T <= B\n ensures S <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_136","instance":136,"id":203479,"goal":"lemma SetUnionEmpty_136(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_137","instance":137,"id":203480,"goal":"lemma SetInterEmpty_137(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_138","instance":138,"id":203481,"goal":"lemma SetInterSubset_138(S: set, T: set)\n ensures S * T <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_139","instance":139,"id":203482,"goal":"lemma SetCardSubset_139(U: set, B: set)\n requires U <= B\n ensures |U| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_140","instance":140,"id":203483,"goal":"lemma SetUnionCard_140(U: set, B: set)\n requires U * B == {}\n ensures |U + B| == |U| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_141","instance":141,"id":203484,"goal":"lemma SetUnionComm_141(U: set, B: set)\n ensures U + B == B + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_142","instance":142,"id":203485,"goal":"lemma SetInterComm_142(U: set, T: set)\n ensures U * T == T * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_143","instance":143,"id":203486,"goal":"lemma SetUnionAssoc_143(S: set, A: set, B: set)\n ensures (S + A) + B == S + (A + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_144","instance":144,"id":203487,"goal":"lemma SetSubsetRefl_144(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_145","instance":145,"id":203488,"goal":"lemma SetSubsetTrans_145(S: set, U: set, B: set)\n requires S <= U && U <= B\n ensures S <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_146","instance":146,"id":203489,"goal":"lemma SetUnionEmpty_146(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_147","instance":147,"id":203490,"goal":"lemma SetInterEmpty_147(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_148","instance":148,"id":203491,"goal":"lemma SetInterSubset_148(B: set, U: set)\n ensures B * U <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_149","instance":149,"id":203492,"goal":"lemma SetCardSubset_149(T: set, U: set)\n requires T <= U\n ensures |T| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_150","instance":150,"id":203493,"goal":"lemma SetUnionCard_150(B: set, A: set)\n requires B * A == {}\n ensures |B + A| == |B| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_151","instance":151,"id":203494,"goal":"lemma SetUnionComm_151(T: set, U: set)\n ensures T + U == U + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_152","instance":152,"id":203495,"goal":"lemma SetInterComm_152(A: set, U: set)\n ensures A * U == U * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_153","instance":153,"id":203496,"goal":"lemma SetUnionAssoc_153(T: set, U: set, B: set)\n ensures (T + U) + B == T + (U + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_154","instance":154,"id":203497,"goal":"lemma SetSubsetRefl_154(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_155","instance":155,"id":203498,"goal":"lemma SetSubsetTrans_155(A: set, S: set, U: set)\n requires A <= S && S <= U\n ensures A <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_156","instance":156,"id":203499,"goal":"lemma SetUnionEmpty_156(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_157","instance":157,"id":203500,"goal":"lemma SetInterEmpty_157(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_158","instance":158,"id":203501,"goal":"lemma SetInterSubset_158(T: set, B: set)\n ensures T * B <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_159","instance":159,"id":203502,"goal":"lemma SetCardSubset_159(S: set, A: set)\n requires S <= A\n ensures |S| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_160","instance":160,"id":203503,"goal":"lemma SetUnionCard_160(B: set, T: set)\n requires B * T == {}\n ensures |B + T| == |B| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_161","instance":161,"id":203504,"goal":"lemma SetUnionComm_161(U: set, S: set)\n ensures U + S == S + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_162","instance":162,"id":203505,"goal":"lemma SetInterComm_162(U: set, B: set)\n ensures U * B == B * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_163","instance":163,"id":203506,"goal":"lemma SetUnionAssoc_163(T: set, A: set, S: set)\n ensures (T + A) + S == T + (A + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_164","instance":164,"id":203507,"goal":"lemma SetSubsetRefl_164(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_165","instance":165,"id":203508,"goal":"lemma SetSubsetTrans_165(B: set, A: set, T: set)\n requires B <= A && A <= T\n ensures B <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_166","instance":166,"id":203509,"goal":"lemma SetUnionEmpty_166(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_167","instance":167,"id":203510,"goal":"lemma SetInterEmpty_167(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_168","instance":168,"id":203511,"goal":"lemma SetInterSubset_168(S: set, A: set)\n ensures S * A <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_169","instance":169,"id":203512,"goal":"lemma SetCardSubset_169(T: set, B: set)\n requires T <= B\n ensures |T| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_170","instance":170,"id":203513,"goal":"lemma SetUnionCard_170(B: set, S: set)\n requires B * S == {}\n ensures |B + S| == |B| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_171","instance":171,"id":203514,"goal":"lemma SetUnionComm_171(U: set, A: set)\n ensures U + A == A + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_172","instance":172,"id":203515,"goal":"lemma SetInterComm_172(S: set, A: set)\n ensures S * A == A * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_173","instance":173,"id":203516,"goal":"lemma SetUnionAssoc_173(T: set, B: set, U: set)\n ensures (T + B) + U == T + (B + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_174","instance":174,"id":203517,"goal":"lemma SetSubsetRefl_174(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_175","instance":175,"id":203518,"goal":"lemma SetSubsetTrans_175(T: set, S: set, B: set)\n requires T <= S && S <= B\n ensures T <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_176","instance":176,"id":203519,"goal":"lemma SetUnionEmpty_176(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_177","instance":177,"id":203520,"goal":"lemma SetInterEmpty_177(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_178","instance":178,"id":203521,"goal":"lemma SetInterSubset_178(A: set, B: set)\n ensures A * B <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_179","instance":179,"id":203522,"goal":"lemma SetCardSubset_179(A: set, S: set)\n requires A <= S\n ensures |A| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_180","instance":180,"id":203523,"goal":"lemma SetUnionCard_180(T: set, B: set)\n requires T * B == {}\n ensures |T + B| == |T| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_181","instance":181,"id":203524,"goal":"lemma SetUnionComm_181(A: set, B: set)\n ensures A + B == B + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_182","instance":182,"id":203525,"goal":"lemma SetInterComm_182(U: set, A: set)\n ensures U * A == A * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_183","instance":183,"id":203526,"goal":"lemma SetUnionAssoc_183(T: set, S: set, B: set)\n ensures (T + S) + B == T + (S + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_184","instance":184,"id":203527,"goal":"lemma SetSubsetRefl_184(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_185","instance":185,"id":203528,"goal":"lemma SetSubsetTrans_185(U: set, A: set, T: set)\n requires U <= A && A <= T\n ensures U <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_186","instance":186,"id":203529,"goal":"lemma SetUnionEmpty_186(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_187","instance":187,"id":203530,"goal":"lemma SetInterEmpty_187(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_188","instance":188,"id":203531,"goal":"lemma SetInterSubset_188(S: set, U: set)\n ensures S * U <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_189","instance":189,"id":203532,"goal":"lemma SetCardSubset_189(U: set, T: set)\n requires U <= T\n ensures |U| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_190","instance":190,"id":203533,"goal":"lemma SetUnionCard_190(S: set, U: set)\n requires S * U == {}\n ensures |S + U| == |S| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_191","instance":191,"id":203534,"goal":"lemma SetUnionComm_191(S: set, B: set)\n ensures S + B == B + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_192","instance":192,"id":203535,"goal":"lemma SetInterComm_192(T: set, S: set)\n ensures T * S == S * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_193","instance":193,"id":203536,"goal":"lemma SetUnionAssoc_193(T: set, U: set, B: set)\n ensures (T + U) + B == T + (U + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_194","instance":194,"id":203537,"goal":"lemma SetSubsetRefl_194(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_195","instance":195,"id":203538,"goal":"lemma SetSubsetTrans_195(A: set, S: set, T: set)\n requires A <= S && S <= T\n ensures A <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_196","instance":196,"id":203539,"goal":"lemma SetUnionEmpty_196(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_197","instance":197,"id":203540,"goal":"lemma SetInterEmpty_197(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_198","instance":198,"id":203541,"goal":"lemma SetInterSubset_198(S: set, A: set)\n ensures S * A <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_199","instance":199,"id":203542,"goal":"lemma SetCardSubset_199(A: set, B: set)\n requires A <= B\n ensures |A| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_200","instance":200,"id":203543,"goal":"lemma SetUnionCard_200(T: set, B: set)\n requires T * B == {}\n ensures |T + B| == |T| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_201","instance":201,"id":203544,"goal":"lemma SetUnionComm_201(U: set, S: set)\n ensures U + S == S + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_202","instance":202,"id":203545,"goal":"lemma SetInterComm_202(A: set, U: set)\n ensures A * U == U * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_203","instance":203,"id":203546,"goal":"lemma SetUnionAssoc_203(S: set, T: set, A: set)\n ensures (S + T) + A == S + (T + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_204","instance":204,"id":203547,"goal":"lemma SetSubsetRefl_204(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_205","instance":205,"id":203548,"goal":"lemma SetSubsetTrans_205(B: set, S: set, U: set)\n requires B <= S && S <= U\n ensures B <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_206","instance":206,"id":203549,"goal":"lemma SetUnionEmpty_206(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_207","instance":207,"id":203550,"goal":"lemma SetInterEmpty_207(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_208","instance":208,"id":203551,"goal":"lemma SetInterSubset_208(U: set, B: set)\n ensures U * B <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_209","instance":209,"id":203552,"goal":"lemma SetCardSubset_209(A: set, S: set)\n requires A <= S\n ensures |A| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_210","instance":210,"id":203553,"goal":"lemma SetUnionCard_210(T: set, S: set)\n requires T * S == {}\n ensures |T + S| == |T| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_211","instance":211,"id":203554,"goal":"lemma SetUnionComm_211(A: set, U: set)\n ensures A + U == U + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_212","instance":212,"id":203555,"goal":"lemma SetInterComm_212(A: set, S: set)\n ensures A * S == S * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_213","instance":213,"id":203556,"goal":"lemma SetUnionAssoc_213(S: set, B: set, T: set)\n ensures (S + B) + T == S + (B + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_214","instance":214,"id":203557,"goal":"lemma SetSubsetRefl_214(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_215","instance":215,"id":203558,"goal":"lemma SetSubsetTrans_215(S: set, U: set, A: set)\n requires S <= U && U <= A\n ensures S <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_216","instance":216,"id":203559,"goal":"lemma SetUnionEmpty_216(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_217","instance":217,"id":203560,"goal":"lemma SetInterEmpty_217(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_218","instance":218,"id":203561,"goal":"lemma SetInterSubset_218(S: set, T: set)\n ensures S * T <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_219","instance":219,"id":203562,"goal":"lemma SetCardSubset_219(U: set, B: set)\n requires U <= B\n ensures |U| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_220","instance":220,"id":203563,"goal":"lemma SetUnionCard_220(A: set, T: set)\n requires A * T == {}\n ensures |A + T| == |A| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_221","instance":221,"id":203564,"goal":"lemma SetUnionComm_221(T: set, S: set)\n ensures T + S == S + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_222","instance":222,"id":203565,"goal":"lemma SetInterComm_222(B: set, S: set)\n ensures B * S == S * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_223","instance":223,"id":203566,"goal":"lemma SetUnionAssoc_223(U: set, S: set, A: set)\n ensures (U + S) + A == U + (S + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_224","instance":224,"id":203567,"goal":"lemma SetSubsetRefl_224(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_225","instance":225,"id":203568,"goal":"lemma SetSubsetTrans_225(S: set, B: set, T: set)\n requires S <= B && B <= T\n ensures S <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_226","instance":226,"id":203569,"goal":"lemma SetUnionEmpty_226(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_227","instance":227,"id":203570,"goal":"lemma SetInterEmpty_227(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_228","instance":228,"id":203571,"goal":"lemma SetInterSubset_228(B: set, U: set)\n ensures B * U <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_229","instance":229,"id":203572,"goal":"lemma SetCardSubset_229(A: set, T: set)\n requires A <= T\n ensures |A| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_230","instance":230,"id":203573,"goal":"lemma SetUnionCard_230(U: set, S: set)\n requires U * S == {}\n ensures |U + S| == |U| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_231","instance":231,"id":203574,"goal":"lemma SetUnionComm_231(U: set, A: set)\n ensures U + A == A + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_232","instance":232,"id":203575,"goal":"lemma SetInterComm_232(U: set, T: set)\n ensures U * T == T * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_233","instance":233,"id":203576,"goal":"lemma SetUnionAssoc_233(S: set, U: set, A: set)\n ensures (S + U) + A == S + (U + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_234","instance":234,"id":203577,"goal":"lemma SetSubsetRefl_234(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_235","instance":235,"id":203578,"goal":"lemma SetSubsetTrans_235(U: set, A: set, B: set)\n requires U <= A && A <= B\n ensures U <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_236","instance":236,"id":203579,"goal":"lemma SetUnionEmpty_236(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_237","instance":237,"id":203580,"goal":"lemma SetInterEmpty_237(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_238","instance":238,"id":203581,"goal":"lemma SetInterSubset_238(T: set, U: set)\n ensures T * U <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_239","instance":239,"id":203582,"goal":"lemma SetCardSubset_239(A: set, U: set)\n requires A <= U\n ensures |A| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_240","instance":240,"id":203583,"goal":"lemma SetUnionCard_240(U: set, B: set)\n requires U * B == {}\n ensures |U + B| == |U| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_241","instance":241,"id":203584,"goal":"lemma SetUnionComm_241(U: set, B: set)\n ensures U + B == B + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_242","instance":242,"id":203585,"goal":"lemma SetInterComm_242(U: set, A: set)\n ensures U * A == A * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_243","instance":243,"id":203586,"goal":"lemma SetUnionAssoc_243(U: set, S: set, A: set)\n ensures (U + S) + A == U + (S + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_244","instance":244,"id":203587,"goal":"lemma SetSubsetRefl_244(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_245","instance":245,"id":203588,"goal":"lemma SetSubsetTrans_245(A: set, S: set, T: set)\n requires A <= S && S <= T\n ensures A <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_246","instance":246,"id":203589,"goal":"lemma SetUnionEmpty_246(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_247","instance":247,"id":203590,"goal":"lemma SetInterEmpty_247(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_248","instance":248,"id":203591,"goal":"lemma SetInterSubset_248(B: set, T: set)\n ensures B * T <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_249","instance":249,"id":203592,"goal":"lemma SetCardSubset_249(S: set, B: set)\n requires S <= B\n ensures |S| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_250","instance":250,"id":203593,"goal":"lemma SetUnionCard_250(S: set, B: set)\n requires S * B == {}\n ensures |S + B| == |S| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_251","instance":251,"id":203594,"goal":"lemma SetUnionComm_251(A: set, S: set)\n ensures A + S == S + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_252","instance":252,"id":203595,"goal":"lemma SetInterComm_252(A: set, B: set)\n ensures A * B == B * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_253","instance":253,"id":203596,"goal":"lemma SetUnionAssoc_253(B: set, S: set, A: set)\n ensures (B + S) + A == B + (S + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_254","instance":254,"id":203597,"goal":"lemma SetSubsetRefl_254(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_255","instance":255,"id":203598,"goal":"lemma SetSubsetTrans_255(U: set, S: set, B: set)\n requires U <= S && S <= B\n ensures U <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_256","instance":256,"id":203599,"goal":"lemma SetUnionEmpty_256(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_257","instance":257,"id":203600,"goal":"lemma SetInterEmpty_257(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_258","instance":258,"id":203601,"goal":"lemma SetInterSubset_258(S: set, U: set)\n ensures S * U <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_259","instance":259,"id":203602,"goal":"lemma SetCardSubset_259(T: set, S: set)\n requires T <= S\n ensures |T| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_260","instance":260,"id":203603,"goal":"lemma SetUnionCard_260(B: set, A: set)\n requires B * A == {}\n ensures |B + A| == |B| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_261","instance":261,"id":203604,"goal":"lemma SetUnionComm_261(A: set, U: set)\n ensures A + U == U + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_262","instance":262,"id":203605,"goal":"lemma SetInterComm_262(S: set, U: set)\n ensures S * U == U * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_263","instance":263,"id":203606,"goal":"lemma SetUnionAssoc_263(B: set, S: set, T: set)\n ensures (B + S) + T == B + (S + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_264","instance":264,"id":203607,"goal":"lemma SetSubsetRefl_264(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_265","instance":265,"id":203608,"goal":"lemma SetSubsetTrans_265(U: set, B: set, T: set)\n requires U <= B && B <= T\n ensures U <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_266","instance":266,"id":203609,"goal":"lemma SetUnionEmpty_266(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_267","instance":267,"id":203610,"goal":"lemma SetInterEmpty_267(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_268","instance":268,"id":203611,"goal":"lemma SetInterSubset_268(U: set, S: set)\n ensures U * S <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_269","instance":269,"id":203612,"goal":"lemma SetCardSubset_269(A: set, B: set)\n requires A <= B\n ensures |A| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_270","instance":270,"id":203613,"goal":"lemma SetUnionCard_270(U: set, T: set)\n requires U * T == {}\n ensures |U + T| == |U| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_271","instance":271,"id":203614,"goal":"lemma SetUnionComm_271(A: set, S: set)\n ensures A + S == S + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_272","instance":272,"id":203615,"goal":"lemma SetInterComm_272(U: set, S: set)\n ensures U * S == S * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_273","instance":273,"id":203616,"goal":"lemma SetUnionAssoc_273(S: set, B: set, U: set)\n ensures (S + B) + U == S + (B + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_274","instance":274,"id":203617,"goal":"lemma SetSubsetRefl_274(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_275","instance":275,"id":203618,"goal":"lemma SetSubsetTrans_275(B: set, A: set, U: set)\n requires B <= A && A <= U\n ensures B <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_276","instance":276,"id":203619,"goal":"lemma SetUnionEmpty_276(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_277","instance":277,"id":203620,"goal":"lemma SetInterEmpty_277(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_278","instance":278,"id":203621,"goal":"lemma SetInterSubset_278(B: set, A: set)\n ensures B * A <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_279","instance":279,"id":203622,"goal":"lemma SetCardSubset_279(B: set, A: set)\n requires B <= A\n ensures |B| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_280","instance":280,"id":203623,"goal":"lemma SetUnionCard_280(S: set, B: set)\n requires S * B == {}\n ensures |S + B| == |S| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_281","instance":281,"id":203624,"goal":"lemma SetUnionComm_281(B: set, S: set)\n ensures B + S == S + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_282","instance":282,"id":203625,"goal":"lemma SetInterComm_282(T: set, A: set)\n ensures T * A == A * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_283","instance":283,"id":203626,"goal":"lemma SetUnionAssoc_283(U: set, B: set, T: set)\n ensures (U + B) + T == U + (B + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_284","instance":284,"id":203627,"goal":"lemma SetSubsetRefl_284(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_285","instance":285,"id":203628,"goal":"lemma SetSubsetTrans_285(A: set, U: set, B: set)\n requires A <= U && U <= B\n ensures A <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_286","instance":286,"id":203629,"goal":"lemma SetUnionEmpty_286(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_287","instance":287,"id":203630,"goal":"lemma SetInterEmpty_287(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_288","instance":288,"id":203631,"goal":"lemma SetInterSubset_288(S: set, A: set)\n ensures S * A <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_289","instance":289,"id":203632,"goal":"lemma SetCardSubset_289(T: set, A: set)\n requires T <= A\n ensures |T| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_290","instance":290,"id":203633,"goal":"lemma SetUnionCard_290(T: set, S: set)\n requires T * S == {}\n ensures |T + S| == |T| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_291","instance":291,"id":203634,"goal":"lemma SetUnionComm_291(B: set, U: set)\n ensures B + U == U + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_292","instance":292,"id":203635,"goal":"lemma SetInterComm_292(T: set, B: set)\n ensures T * B == B * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_293","instance":293,"id":203636,"goal":"lemma SetUnionAssoc_293(B: set, A: set, T: set)\n ensures (B + A) + T == B + (A + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_294","instance":294,"id":203637,"goal":"lemma SetSubsetRefl_294(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_295","instance":295,"id":203638,"goal":"lemma SetSubsetTrans_295(U: set, A: set, T: set)\n requires U <= A && A <= T\n ensures U <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_296","instance":296,"id":203639,"goal":"lemma SetUnionEmpty_296(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_297","instance":297,"id":203640,"goal":"lemma SetInterEmpty_297(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_298","instance":298,"id":203641,"goal":"lemma SetInterSubset_298(T: set, B: set)\n ensures T * B <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_299","instance":299,"id":203642,"goal":"lemma SetCardSubset_299(A: set, U: set)\n requires A <= U\n ensures |A| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_300","instance":300,"id":203643,"goal":"lemma SetUnionCard_300(T: set, A: set)\n requires T * A == {}\n ensures |T + A| == |T| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_301","instance":301,"id":203644,"goal":"lemma SetUnionComm_301(A: set, U: set)\n ensures A + U == U + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_302","instance":302,"id":203645,"goal":"lemma SetInterComm_302(A: set, B: set)\n ensures A * B == B * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_303","instance":303,"id":203646,"goal":"lemma SetUnionAssoc_303(S: set, A: set, T: set)\n ensures (S + A) + T == S + (A + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_304","instance":304,"id":203647,"goal":"lemma SetSubsetRefl_304(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_305","instance":305,"id":203648,"goal":"lemma SetSubsetTrans_305(A: set, S: set, T: set)\n requires A <= S && S <= T\n ensures A <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_306","instance":306,"id":203649,"goal":"lemma SetUnionEmpty_306(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_307","instance":307,"id":203650,"goal":"lemma SetInterEmpty_307(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_308","instance":308,"id":203651,"goal":"lemma SetInterSubset_308(A: set, U: set)\n ensures A * U <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_309","instance":309,"id":203652,"goal":"lemma SetCardSubset_309(S: set, B: set)\n requires S <= B\n ensures |S| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_310","instance":310,"id":203653,"goal":"lemma SetUnionCard_310(A: set, U: set)\n requires A * U == {}\n ensures |A + U| == |A| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_311","instance":311,"id":203654,"goal":"lemma SetUnionComm_311(T: set, A: set)\n ensures T + A == A + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_312","instance":312,"id":203655,"goal":"lemma SetInterComm_312(T: set, S: set)\n ensures T * S == S * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_313","instance":313,"id":203656,"goal":"lemma SetUnionAssoc_313(T: set, B: set, S: set)\n ensures (T + B) + S == T + (B + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_314","instance":314,"id":203657,"goal":"lemma SetSubsetRefl_314(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_315","instance":315,"id":203658,"goal":"lemma SetSubsetTrans_315(T: set, B: set, S: set)\n requires T <= B && B <= S\n ensures T <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_316","instance":316,"id":203659,"goal":"lemma SetUnionEmpty_316(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_317","instance":317,"id":203660,"goal":"lemma SetInterEmpty_317(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_318","instance":318,"id":203661,"goal":"lemma SetInterSubset_318(S: set, B: set)\n ensures S * B <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_319","instance":319,"id":203662,"goal":"lemma SetCardSubset_319(A: set, S: set)\n requires A <= S\n ensures |A| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_320","instance":320,"id":203663,"goal":"lemma SetUnionCard_320(T: set, U: set)\n requires T * U == {}\n ensures |T + U| == |T| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_321","instance":321,"id":203664,"goal":"lemma SetUnionComm_321(B: set, U: set)\n ensures B + U == U + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_322","instance":322,"id":203665,"goal":"lemma SetInterComm_322(A: set, B: set)\n ensures A * B == B * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_323","instance":323,"id":203666,"goal":"lemma SetUnionAssoc_323(B: set, T: set, U: set)\n ensures (B + T) + U == B + (T + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_324","instance":324,"id":203667,"goal":"lemma SetSubsetRefl_324(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_325","instance":325,"id":203668,"goal":"lemma SetSubsetTrans_325(S: set, A: set, U: set)\n requires S <= A && A <= U\n ensures S <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_326","instance":326,"id":203669,"goal":"lemma SetUnionEmpty_326(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_327","instance":327,"id":203670,"goal":"lemma SetInterEmpty_327(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_328","instance":328,"id":203671,"goal":"lemma SetInterSubset_328(S: set, B: set)\n ensures S * B <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_329","instance":329,"id":203672,"goal":"lemma SetCardSubset_329(U: set, A: set)\n requires U <= A\n ensures |U| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_330","instance":330,"id":203673,"goal":"lemma SetUnionCard_330(A: set, S: set)\n requires A * S == {}\n ensures |A + S| == |A| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_331","instance":331,"id":203674,"goal":"lemma SetUnionComm_331(S: set, T: set)\n ensures S + T == T + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_332","instance":332,"id":203675,"goal":"lemma SetInterComm_332(T: set, U: set)\n ensures T * U == U * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_333","instance":333,"id":203676,"goal":"lemma SetUnionAssoc_333(S: set, U: set, B: set)\n ensures (S + U) + B == S + (U + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_334","instance":334,"id":203677,"goal":"lemma SetSubsetRefl_334(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_335","instance":335,"id":203678,"goal":"lemma SetSubsetTrans_335(S: set, A: set, B: set)\n requires S <= A && A <= B\n ensures S <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_336","instance":336,"id":203679,"goal":"lemma SetUnionEmpty_336(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_337","instance":337,"id":203680,"goal":"lemma SetInterEmpty_337(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_338","instance":338,"id":203681,"goal":"lemma SetInterSubset_338(A: set, S: set)\n ensures A * S <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_339","instance":339,"id":203682,"goal":"lemma SetCardSubset_339(T: set, B: set)\n requires T <= B\n ensures |T| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_340","instance":340,"id":203683,"goal":"lemma SetUnionCard_340(T: set, B: set)\n requires T * B == {}\n ensures |T + B| == |T| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_341","instance":341,"id":203684,"goal":"lemma SetUnionComm_341(A: set, S: set)\n ensures A + S == S + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_342","instance":342,"id":203685,"goal":"lemma SetInterComm_342(T: set, U: set)\n ensures T * U == U * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_343","instance":343,"id":203686,"goal":"lemma SetUnionAssoc_343(A: set, S: set, B: set)\n ensures (A + S) + B == A + (S + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_344","instance":344,"id":203687,"goal":"lemma SetSubsetRefl_344(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_345","instance":345,"id":203688,"goal":"lemma SetSubsetTrans_345(A: set, S: set, T: set)\n requires A <= S && S <= T\n ensures A <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_346","instance":346,"id":203689,"goal":"lemma SetUnionEmpty_346(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_347","instance":347,"id":203690,"goal":"lemma SetInterEmpty_347(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_348","instance":348,"id":203691,"goal":"lemma SetInterSubset_348(A: set, T: set)\n ensures A * T <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_349","instance":349,"id":203692,"goal":"lemma SetCardSubset_349(S: set, U: set)\n requires S <= U\n ensures |S| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_350","instance":350,"id":203693,"goal":"lemma SetUnionCard_350(T: set, U: set)\n requires T * U == {}\n ensures |T + U| == |T| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_351","instance":351,"id":203694,"goal":"lemma SetUnionComm_351(S: set, T: set)\n ensures S + T == T + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_352","instance":352,"id":203695,"goal":"lemma SetInterComm_352(U: set, A: set)\n ensures U * A == A * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_353","instance":353,"id":203696,"goal":"lemma SetUnionAssoc_353(S: set, T: set, U: set)\n ensures (S + T) + U == S + (T + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_354","instance":354,"id":203697,"goal":"lemma SetSubsetRefl_354(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_355","instance":355,"id":203698,"goal":"lemma SetSubsetTrans_355(A: set, B: set, U: set)\n requires A <= B && B <= U\n ensures A <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_356","instance":356,"id":203699,"goal":"lemma SetUnionEmpty_356(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_357","instance":357,"id":203700,"goal":"lemma SetInterEmpty_357(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_358","instance":358,"id":203701,"goal":"lemma SetInterSubset_358(A: set, B: set)\n ensures A * B <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_359","instance":359,"id":203702,"goal":"lemma SetCardSubset_359(A: set, B: set)\n requires A <= B\n ensures |A| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_360","instance":360,"id":203703,"goal":"lemma SetUnionCard_360(B: set, U: set)\n requires B * U == {}\n ensures |B + U| == |B| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_361","instance":361,"id":203704,"goal":"lemma SetUnionComm_361(U: set, T: set)\n ensures U + T == T + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_362","instance":362,"id":203705,"goal":"lemma SetInterComm_362(A: set, U: set)\n ensures A * U == U * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_363","instance":363,"id":203706,"goal":"lemma SetUnionAssoc_363(B: set, S: set, A: set)\n ensures (B + S) + A == B + (S + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_364","instance":364,"id":203707,"goal":"lemma SetSubsetRefl_364(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_365","instance":365,"id":203708,"goal":"lemma SetSubsetTrans_365(B: set, T: set, U: set)\n requires B <= T && T <= U\n ensures B <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_366","instance":366,"id":203709,"goal":"lemma SetUnionEmpty_366(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_367","instance":367,"id":203710,"goal":"lemma SetInterEmpty_367(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_368","instance":368,"id":203711,"goal":"lemma SetInterSubset_368(B: set, U: set)\n ensures B * U <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_369","instance":369,"id":203712,"goal":"lemma SetCardSubset_369(T: set, B: set)\n requires T <= B\n ensures |T| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_370","instance":370,"id":203713,"goal":"lemma SetUnionCard_370(B: set, U: set)\n requires B * U == {}\n ensures |B + U| == |B| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_371","instance":371,"id":203714,"goal":"lemma SetUnionComm_371(B: set, T: set)\n ensures B + T == T + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_372","instance":372,"id":203715,"goal":"lemma SetInterComm_372(U: set, A: set)\n ensures U * A == A * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_373","instance":373,"id":203716,"goal":"lemma SetUnionAssoc_373(U: set, A: set, T: set)\n ensures (U + A) + T == U + (A + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_374","instance":374,"id":203717,"goal":"lemma SetSubsetRefl_374(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_375","instance":375,"id":203718,"goal":"lemma SetSubsetTrans_375(A: set, B: set, S: set)\n requires A <= B && B <= S\n ensures A <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_376","instance":376,"id":203719,"goal":"lemma SetUnionEmpty_376(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_377","instance":377,"id":203720,"goal":"lemma SetInterEmpty_377(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_378","instance":378,"id":203721,"goal":"lemma SetInterSubset_378(S: set, B: set)\n ensures S * B <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_379","instance":379,"id":203722,"goal":"lemma SetCardSubset_379(A: set, T: set)\n requires A <= T\n ensures |A| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_380","instance":380,"id":203723,"goal":"lemma SetUnionCard_380(B: set, S: set)\n requires B * S == {}\n ensures |B + S| == |B| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_381","instance":381,"id":203724,"goal":"lemma SetUnionComm_381(S: set, B: set)\n ensures S + B == B + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_382","instance":382,"id":203725,"goal":"lemma SetInterComm_382(T: set, S: set)\n ensures T * S == S * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_383","instance":383,"id":203726,"goal":"lemma SetUnionAssoc_383(T: set, U: set, A: set)\n ensures (T + U) + A == T + (U + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_384","instance":384,"id":203727,"goal":"lemma SetSubsetRefl_384(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_385","instance":385,"id":203728,"goal":"lemma SetSubsetTrans_385(S: set, B: set, T: set)\n requires S <= B && B <= T\n ensures S <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_386","instance":386,"id":203729,"goal":"lemma SetUnionEmpty_386(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_387","instance":387,"id":203730,"goal":"lemma SetInterEmpty_387(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_388","instance":388,"id":203731,"goal":"lemma SetInterSubset_388(B: set, A: set)\n ensures B * A <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_389","instance":389,"id":203732,"goal":"lemma SetCardSubset_389(T: set, A: set)\n requires T <= A\n ensures |T| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_390","instance":390,"id":203733,"goal":"lemma SetUnionCard_390(A: set, B: set)\n requires A * B == {}\n ensures |A + B| == |A| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_391","instance":391,"id":203734,"goal":"lemma SetUnionComm_391(B: set, U: set)\n ensures B + U == U + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_392","instance":392,"id":203735,"goal":"lemma SetInterComm_392(A: set, T: set)\n ensures A * T == T * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_393","instance":393,"id":203736,"goal":"lemma SetUnionAssoc_393(U: set, B: set, A: set)\n ensures (U + B) + A == U + (B + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_394","instance":394,"id":203737,"goal":"lemma SetSubsetRefl_394(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_395","instance":395,"id":203738,"goal":"lemma SetSubsetTrans_395(A: set, T: set, U: set)\n requires A <= T && T <= U\n ensures A <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_396","instance":396,"id":203739,"goal":"lemma SetUnionEmpty_396(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_397","instance":397,"id":203740,"goal":"lemma SetInterEmpty_397(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_398","instance":398,"id":203741,"goal":"lemma SetInterSubset_398(T: set, A: set)\n ensures T * A <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_399","instance":399,"id":203742,"goal":"lemma SetCardSubset_399(U: set, B: set)\n requires U <= B\n ensures |U| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_400","instance":400,"id":203743,"goal":"lemma SetUnionCard_400(S: set, A: set)\n requires S * A == {}\n ensures |S + A| == |S| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_401","instance":401,"id":203744,"goal":"lemma SetUnionComm_401(S: set, U: set)\n ensures S + U == U + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_402","instance":402,"id":203745,"goal":"lemma SetInterComm_402(A: set, S: set)\n ensures A * S == S * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_403","instance":403,"id":203746,"goal":"lemma SetUnionAssoc_403(S: set, A: set, B: set)\n ensures (S + A) + B == S + (A + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_404","instance":404,"id":203747,"goal":"lemma SetSubsetRefl_404(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_405","instance":405,"id":203748,"goal":"lemma SetSubsetTrans_405(U: set, B: set, S: set)\n requires U <= B && B <= S\n ensures U <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_406","instance":406,"id":203749,"goal":"lemma SetUnionEmpty_406(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_407","instance":407,"id":203750,"goal":"lemma SetInterEmpty_407(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_408","instance":408,"id":203751,"goal":"lemma SetInterSubset_408(B: set, T: set)\n ensures B * T <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_409","instance":409,"id":203752,"goal":"lemma SetCardSubset_409(T: set, B: set)\n requires T <= B\n ensures |T| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_410","instance":410,"id":203753,"goal":"lemma SetUnionCard_410(A: set, U: set)\n requires A * U == {}\n ensures |A + U| == |A| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_411","instance":411,"id":203754,"goal":"lemma SetUnionComm_411(A: set, S: set)\n ensures A + S == S + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_412","instance":412,"id":203755,"goal":"lemma SetInterComm_412(T: set, U: set)\n ensures T * U == U * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_413","instance":413,"id":203756,"goal":"lemma SetUnionAssoc_413(U: set, B: set, S: set)\n ensures (U + B) + S == U + (B + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_414","instance":414,"id":203757,"goal":"lemma SetSubsetRefl_414(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_415","instance":415,"id":203758,"goal":"lemma SetSubsetTrans_415(A: set, S: set, T: set)\n requires A <= S && S <= T\n ensures A <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_416","instance":416,"id":203759,"goal":"lemma SetUnionEmpty_416(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_417","instance":417,"id":203760,"goal":"lemma SetInterEmpty_417(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_418","instance":418,"id":203761,"goal":"lemma SetInterSubset_418(A: set, U: set)\n ensures A * U <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_419","instance":419,"id":203762,"goal":"lemma SetCardSubset_419(B: set, S: set)\n requires B <= S\n ensures |B| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_420","instance":420,"id":203763,"goal":"lemma SetUnionCard_420(U: set, S: set)\n requires U * S == {}\n ensures |U + S| == |U| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_421","instance":421,"id":203764,"goal":"lemma SetUnionComm_421(S: set, T: set)\n ensures S + T == T + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_422","instance":422,"id":203765,"goal":"lemma SetInterComm_422(U: set, S: set)\n ensures U * S == S * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_423","instance":423,"id":203766,"goal":"lemma SetUnionAssoc_423(U: set, S: set, T: set)\n ensures (U + S) + T == U + (S + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_424","instance":424,"id":203767,"goal":"lemma SetSubsetRefl_424(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_425","instance":425,"id":203768,"goal":"lemma SetSubsetTrans_425(S: set, T: set, U: set)\n requires S <= T && T <= U\n ensures S <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_426","instance":426,"id":203769,"goal":"lemma SetUnionEmpty_426(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_427","instance":427,"id":203770,"goal":"lemma SetInterEmpty_427(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_428","instance":428,"id":203771,"goal":"lemma SetInterSubset_428(B: set, U: set)\n ensures B * U <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_429","instance":429,"id":203772,"goal":"lemma SetCardSubset_429(B: set, A: set)\n requires B <= A\n ensures |B| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_430","instance":430,"id":203773,"goal":"lemma SetUnionCard_430(S: set, B: set)\n requires S * B == {}\n ensures |S + B| == |S| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_431","instance":431,"id":203774,"goal":"lemma SetUnionComm_431(A: set, T: set)\n ensures A + T == T + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_432","instance":432,"id":203775,"goal":"lemma SetInterComm_432(A: set, S: set)\n ensures A * S == S * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_433","instance":433,"id":203776,"goal":"lemma SetUnionAssoc_433(S: set, T: set, A: set)\n ensures (S + T) + A == S + (T + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_434","instance":434,"id":203777,"goal":"lemma SetSubsetRefl_434(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_435","instance":435,"id":203778,"goal":"lemma SetSubsetTrans_435(S: set, U: set, B: set)\n requires S <= U && U <= B\n ensures S <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_436","instance":436,"id":203779,"goal":"lemma SetUnionEmpty_436(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_437","instance":437,"id":203780,"goal":"lemma SetInterEmpty_437(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_438","instance":438,"id":203781,"goal":"lemma SetInterSubset_438(A: set, B: set)\n ensures A * B <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_439","instance":439,"id":203782,"goal":"lemma SetCardSubset_439(B: set, U: set)\n requires B <= U\n ensures |B| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_440","instance":440,"id":203783,"goal":"lemma SetUnionCard_440(A: set, B: set)\n requires A * B == {}\n ensures |A + B| == |A| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_441","instance":441,"id":203784,"goal":"lemma SetUnionComm_441(S: set, A: set)\n ensures S + A == A + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_442","instance":442,"id":203785,"goal":"lemma SetInterComm_442(B: set, A: set)\n ensures B * A == A * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_443","instance":443,"id":203786,"goal":"lemma SetUnionAssoc_443(A: set, S: set, U: set)\n ensures (A + S) + U == A + (S + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_444","instance":444,"id":203787,"goal":"lemma SetSubsetRefl_444(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_445","instance":445,"id":203788,"goal":"lemma SetSubsetTrans_445(A: set, T: set, B: set)\n requires A <= T && T <= B\n ensures A <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_446","instance":446,"id":203789,"goal":"lemma SetUnionEmpty_446(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_447","instance":447,"id":203790,"goal":"lemma SetInterEmpty_447(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_448","instance":448,"id":203791,"goal":"lemma SetInterSubset_448(S: set, A: set)\n ensures S * A <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_449","instance":449,"id":203792,"goal":"lemma SetCardSubset_449(A: set, T: set)\n requires A <= T\n ensures |A| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_450","instance":450,"id":203793,"goal":"lemma SetUnionCard_450(U: set, B: set)\n requires U * B == {}\n ensures |U + B| == |U| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_451","instance":451,"id":203794,"goal":"lemma SetUnionComm_451(B: set, A: set)\n ensures B + A == A + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_452","instance":452,"id":203795,"goal":"lemma SetInterComm_452(B: set, T: set)\n ensures B * T == T * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_453","instance":453,"id":203796,"goal":"lemma SetUnionAssoc_453(S: set, A: set, T: set)\n ensures (S + A) + T == S + (A + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_454","instance":454,"id":203797,"goal":"lemma SetSubsetRefl_454(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_455","instance":455,"id":203798,"goal":"lemma SetSubsetTrans_455(B: set, T: set, U: set)\n requires B <= T && T <= U\n ensures B <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_456","instance":456,"id":203799,"goal":"lemma SetUnionEmpty_456(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_457","instance":457,"id":203800,"goal":"lemma SetInterEmpty_457(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_458","instance":458,"id":203801,"goal":"lemma SetInterSubset_458(S: set, A: set)\n ensures S * A <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_459","instance":459,"id":203802,"goal":"lemma SetCardSubset_459(T: set, U: set)\n requires T <= U\n ensures |T| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_460","instance":460,"id":203803,"goal":"lemma SetUnionCard_460(T: set, A: set)\n requires T * A == {}\n ensures |T + A| == |T| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_461","instance":461,"id":203804,"goal":"lemma SetUnionComm_461(B: set, U: set)\n ensures B + U == U + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_462","instance":462,"id":203805,"goal":"lemma SetInterComm_462(U: set, T: set)\n ensures U * T == T * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_463","instance":463,"id":203806,"goal":"lemma SetUnionAssoc_463(A: set, U: set, B: set)\n ensures (A + U) + B == A + (U + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_464","instance":464,"id":203807,"goal":"lemma SetSubsetRefl_464(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_465","instance":465,"id":203808,"goal":"lemma SetSubsetTrans_465(T: set, S: set, U: set)\n requires T <= S && S <= U\n ensures T <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_466","instance":466,"id":203809,"goal":"lemma SetUnionEmpty_466(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_467","instance":467,"id":203810,"goal":"lemma SetInterEmpty_467(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_468","instance":468,"id":203811,"goal":"lemma SetInterSubset_468(A: set, T: set)\n ensures A * T <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_469","instance":469,"id":203812,"goal":"lemma SetCardSubset_469(T: set, U: set)\n requires T <= U\n ensures |T| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_470","instance":470,"id":203813,"goal":"lemma SetUnionCard_470(T: set, B: set)\n requires T * B == {}\n ensures |T + B| == |T| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_471","instance":471,"id":203814,"goal":"lemma SetUnionComm_471(B: set, S: set)\n ensures B + S == S + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_472","instance":472,"id":203815,"goal":"lemma SetInterComm_472(U: set, S: set)\n ensures U * S == S * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_473","instance":473,"id":203816,"goal":"lemma SetUnionAssoc_473(U: set, A: set, B: set)\n ensures (U + A) + B == U + (A + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_474","instance":474,"id":203817,"goal":"lemma SetSubsetRefl_474(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_475","instance":475,"id":203818,"goal":"lemma SetSubsetTrans_475(A: set, T: set, S: set)\n requires A <= T && T <= S\n ensures A <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_476","instance":476,"id":203819,"goal":"lemma SetUnionEmpty_476(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_477","instance":477,"id":203820,"goal":"lemma SetInterEmpty_477(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_478","instance":478,"id":203821,"goal":"lemma SetInterSubset_478(T: set, B: set)\n ensures T * B <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_479","instance":479,"id":203822,"goal":"lemma SetCardSubset_479(S: set, U: set)\n requires S <= U\n ensures |S| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_480","instance":480,"id":203823,"goal":"lemma SetUnionCard_480(T: set, U: set)\n requires T * U == {}\n ensures |T + U| == |T| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_481","instance":481,"id":203824,"goal":"lemma SetUnionComm_481(B: set, A: set)\n ensures B + A == A + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_482","instance":482,"id":203825,"goal":"lemma SetInterComm_482(U: set, B: set)\n ensures U * B == B * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_483","instance":483,"id":203826,"goal":"lemma SetUnionAssoc_483(T: set, U: set, S: set)\n ensures (T + U) + S == T + (U + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_484","instance":484,"id":203827,"goal":"lemma SetSubsetRefl_484(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_485","instance":485,"id":203828,"goal":"lemma SetSubsetTrans_485(S: set, T: set, A: set)\n requires S <= T && T <= A\n ensures S <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_486","instance":486,"id":203829,"goal":"lemma SetUnionEmpty_486(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_487","instance":487,"id":203830,"goal":"lemma SetInterEmpty_487(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_488","instance":488,"id":203831,"goal":"lemma SetInterSubset_488(U: set, A: set)\n ensures U * A <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_489","instance":489,"id":203832,"goal":"lemma SetCardSubset_489(A: set, T: set)\n requires A <= T\n ensures |A| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_490","instance":490,"id":203833,"goal":"lemma SetUnionCard_490(T: set, B: set)\n requires T * B == {}\n ensures |T + B| == |T| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_491","instance":491,"id":203834,"goal":"lemma SetUnionComm_491(B: set, T: set)\n ensures B + T == T + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_492","instance":492,"id":203835,"goal":"lemma SetInterComm_492(B: set, S: set)\n ensures B * S == S * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_493","instance":493,"id":203836,"goal":"lemma SetUnionAssoc_493(A: set, T: set, S: set)\n ensures (A + T) + S == A + (T + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_494","instance":494,"id":203837,"goal":"lemma SetSubsetRefl_494(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_495","instance":495,"id":203838,"goal":"lemma SetSubsetTrans_495(U: set, B: set, A: set)\n requires U <= B && B <= A\n ensures U <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_496","instance":496,"id":203839,"goal":"lemma SetUnionEmpty_496(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_497","instance":497,"id":203840,"goal":"lemma SetInterEmpty_497(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_498","instance":498,"id":203841,"goal":"lemma SetInterSubset_498(B: set, U: set)\n ensures B * U <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_499","instance":499,"id":203842,"goal":"lemma SetCardSubset_499(U: set, T: set)\n requires U <= T\n ensures |U| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_500","instance":500,"id":203843,"goal":"lemma SetUnionCard_500(T: set, A: set)\n requires T * A == {}\n ensures |T + A| == |T| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_501","instance":501,"id":203844,"goal":"lemma SetUnionComm_501(A: set, U: set)\n ensures A + U == U + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_502","instance":502,"id":203845,"goal":"lemma SetInterComm_502(S: set, B: set)\n ensures S * B == B * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_503","instance":503,"id":203846,"goal":"lemma SetUnionAssoc_503(B: set, T: set, S: set)\n ensures (B + T) + S == B + (T + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_504","instance":504,"id":203847,"goal":"lemma SetSubsetRefl_504(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_505","instance":505,"id":203848,"goal":"lemma SetSubsetTrans_505(U: set, S: set, T: set)\n requires U <= S && S <= T\n ensures U <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_506","instance":506,"id":203849,"goal":"lemma SetUnionEmpty_506(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_507","instance":507,"id":203850,"goal":"lemma SetInterEmpty_507(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_508","instance":508,"id":203851,"goal":"lemma SetInterSubset_508(S: set, U: set)\n ensures S * U <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_509","instance":509,"id":203852,"goal":"lemma SetCardSubset_509(A: set, S: set)\n requires A <= S\n ensures |A| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_510","instance":510,"id":203853,"goal":"lemma SetUnionCard_510(T: set, A: set)\n requires T * A == {}\n ensures |T + A| == |T| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_511","instance":511,"id":203854,"goal":"lemma SetUnionComm_511(A: set, T: set)\n ensures A + T == T + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_512","instance":512,"id":203855,"goal":"lemma SetInterComm_512(B: set, A: set)\n ensures B * A == A * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_513","instance":513,"id":203856,"goal":"lemma SetUnionAssoc_513(U: set, S: set, A: set)\n ensures (U + S) + A == U + (S + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_514","instance":514,"id":203857,"goal":"lemma SetSubsetRefl_514(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_515","instance":515,"id":203858,"goal":"lemma SetSubsetTrans_515(S: set, T: set, B: set)\n requires S <= T && T <= B\n ensures S <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_516","instance":516,"id":203859,"goal":"lemma SetUnionEmpty_516(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_517","instance":517,"id":203860,"goal":"lemma SetInterEmpty_517(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_518","instance":518,"id":203861,"goal":"lemma SetInterSubset_518(U: set, A: set)\n ensures U * A <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_519","instance":519,"id":203862,"goal":"lemma SetCardSubset_519(B: set, T: set)\n requires B <= T\n ensures |B| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_520","instance":520,"id":203863,"goal":"lemma SetUnionCard_520(A: set, T: set)\n requires A * T == {}\n ensures |A + T| == |A| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_521","instance":521,"id":203864,"goal":"lemma SetUnionComm_521(A: set, B: set)\n ensures A + B == B + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_522","instance":522,"id":203865,"goal":"lemma SetInterComm_522(A: set, B: set)\n ensures A * B == B * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_523","instance":523,"id":203866,"goal":"lemma SetUnionAssoc_523(B: set, U: set, A: set)\n ensures (B + U) + A == B + (U + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_524","instance":524,"id":203867,"goal":"lemma SetSubsetRefl_524(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_525","instance":525,"id":203868,"goal":"lemma SetSubsetTrans_525(A: set, B: set, T: set)\n requires A <= B && B <= T\n ensures A <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_526","instance":526,"id":203869,"goal":"lemma SetUnionEmpty_526(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_527","instance":527,"id":203870,"goal":"lemma SetInterEmpty_527(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_528","instance":528,"id":203871,"goal":"lemma SetInterSubset_528(S: set, U: set)\n ensures S * U <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_529","instance":529,"id":203872,"goal":"lemma SetCardSubset_529(U: set, S: set)\n requires U <= S\n ensures |U| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_530","instance":530,"id":203873,"goal":"lemma SetUnionCard_530(A: set, S: set)\n requires A * S == {}\n ensures |A + S| == |A| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_531","instance":531,"id":203874,"goal":"lemma SetUnionComm_531(S: set, T: set)\n ensures S + T == T + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_532","instance":532,"id":203875,"goal":"lemma SetInterComm_532(T: set, B: set)\n ensures T * B == B * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_533","instance":533,"id":203876,"goal":"lemma SetUnionAssoc_533(S: set, T: set, B: set)\n ensures (S + T) + B == S + (T + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_534","instance":534,"id":203877,"goal":"lemma SetSubsetRefl_534(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_535","instance":535,"id":203878,"goal":"lemma SetSubsetTrans_535(S: set, B: set, A: set)\n requires S <= B && B <= A\n ensures S <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_536","instance":536,"id":203879,"goal":"lemma SetUnionEmpty_536(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_537","instance":537,"id":203880,"goal":"lemma SetInterEmpty_537(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_538","instance":538,"id":203881,"goal":"lemma SetInterSubset_538(A: set, S: set)\n ensures A * S <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_539","instance":539,"id":203882,"goal":"lemma SetCardSubset_539(A: set, S: set)\n requires A <= S\n ensures |A| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_540","instance":540,"id":203883,"goal":"lemma SetUnionCard_540(A: set, T: set)\n requires A * T == {}\n ensures |A + T| == |A| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_541","instance":541,"id":203884,"goal":"lemma SetUnionComm_541(T: set, A: set)\n ensures T + A == A + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_542","instance":542,"id":203885,"goal":"lemma SetInterComm_542(S: set, U: set)\n ensures S * U == U * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_543","instance":543,"id":203886,"goal":"lemma SetUnionAssoc_543(B: set, A: set, T: set)\n ensures (B + A) + T == B + (A + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_544","instance":544,"id":203887,"goal":"lemma SetSubsetRefl_544(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_545","instance":545,"id":203888,"goal":"lemma SetSubsetTrans_545(S: set, U: set, T: set)\n requires S <= U && U <= T\n ensures S <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_546","instance":546,"id":203889,"goal":"lemma SetUnionEmpty_546(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_547","instance":547,"id":203890,"goal":"lemma SetInterEmpty_547(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_548","instance":548,"id":203891,"goal":"lemma SetInterSubset_548(A: set, T: set)\n ensures A * T <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_549","instance":549,"id":203892,"goal":"lemma SetCardSubset_549(A: set, U: set)\n requires A <= U\n ensures |A| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_550","instance":550,"id":203893,"goal":"lemma SetUnionCard_550(U: set, S: set)\n requires U * S == {}\n ensures |U + S| == |U| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_551","instance":551,"id":203894,"goal":"lemma SetUnionComm_551(T: set, U: set)\n ensures T + U == U + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_552","instance":552,"id":203895,"goal":"lemma SetInterComm_552(B: set, A: set)\n ensures B * A == A * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_553","instance":553,"id":203896,"goal":"lemma SetUnionAssoc_553(A: set, U: set, T: set)\n ensures (A + U) + T == A + (U + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_554","instance":554,"id":203897,"goal":"lemma SetSubsetRefl_554(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_555","instance":555,"id":203898,"goal":"lemma SetSubsetTrans_555(T: set, B: set, S: set)\n requires T <= B && B <= S\n ensures T <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_556","instance":556,"id":203899,"goal":"lemma SetUnionEmpty_556(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_557","instance":557,"id":203900,"goal":"lemma SetInterEmpty_557(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_558","instance":558,"id":203901,"goal":"lemma SetInterSubset_558(T: set, S: set)\n ensures T * S <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_559","instance":559,"id":203902,"goal":"lemma SetCardSubset_559(B: set, S: set)\n requires B <= S\n ensures |B| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_560","instance":560,"id":203903,"goal":"lemma SetUnionCard_560(S: set, T: set)\n requires S * T == {}\n ensures |S + T| == |S| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_561","instance":561,"id":203904,"goal":"lemma SetUnionComm_561(S: set, T: set)\n ensures S + T == T + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_562","instance":562,"id":203905,"goal":"lemma SetInterComm_562(T: set, S: set)\n ensures T * S == S * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_563","instance":563,"id":203906,"goal":"lemma SetUnionAssoc_563(B: set, A: set, T: set)\n ensures (B + A) + T == B + (A + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_564","instance":564,"id":203907,"goal":"lemma SetSubsetRefl_564(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_565","instance":565,"id":203908,"goal":"lemma SetSubsetTrans_565(B: set, U: set, T: set)\n requires B <= U && U <= T\n ensures B <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_566","instance":566,"id":203909,"goal":"lemma SetUnionEmpty_566(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_567","instance":567,"id":203910,"goal":"lemma SetInterEmpty_567(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_568","instance":568,"id":203911,"goal":"lemma SetInterSubset_568(A: set, T: set)\n ensures A * T <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_569","instance":569,"id":203912,"goal":"lemma SetCardSubset_569(B: set, U: set)\n requires B <= U\n ensures |B| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_570","instance":570,"id":203913,"goal":"lemma SetUnionCard_570(S: set, B: set)\n requires S * B == {}\n ensures |S + B| == |S| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_571","instance":571,"id":203914,"goal":"lemma SetUnionComm_571(U: set, A: set)\n ensures U + A == A + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_572","instance":572,"id":203915,"goal":"lemma SetInterComm_572(B: set, U: set)\n ensures B * U == U * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_573","instance":573,"id":203916,"goal":"lemma SetUnionAssoc_573(U: set, B: set, S: set)\n ensures (U + B) + S == U + (B + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_574","instance":574,"id":203917,"goal":"lemma SetSubsetRefl_574(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_575","instance":575,"id":203918,"goal":"lemma SetSubsetTrans_575(S: set, T: set, U: set)\n requires S <= T && T <= U\n ensures S <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_576","instance":576,"id":203919,"goal":"lemma SetUnionEmpty_576(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_577","instance":577,"id":203920,"goal":"lemma SetInterEmpty_577(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_578","instance":578,"id":203921,"goal":"lemma SetInterSubset_578(T: set, B: set)\n ensures T * B <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_579","instance":579,"id":203922,"goal":"lemma SetCardSubset_579(U: set, T: set)\n requires U <= T\n ensures |U| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_580","instance":580,"id":203923,"goal":"lemma SetUnionCard_580(U: set, T: set)\n requires U * T == {}\n ensures |U + T| == |U| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_581","instance":581,"id":203924,"goal":"lemma SetUnionComm_581(B: set, U: set)\n ensures B + U == U + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_582","instance":582,"id":203925,"goal":"lemma SetInterComm_582(S: set, A: set)\n ensures S * A == A * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_583","instance":583,"id":203926,"goal":"lemma SetUnionAssoc_583(B: set, T: set, A: set)\n ensures (B + T) + A == B + (T + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_584","instance":584,"id":203927,"goal":"lemma SetSubsetRefl_584(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_585","instance":585,"id":203928,"goal":"lemma SetSubsetTrans_585(B: set, T: set, A: set)\n requires B <= T && T <= A\n ensures B <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_586","instance":586,"id":203929,"goal":"lemma SetUnionEmpty_586(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_587","instance":587,"id":203930,"goal":"lemma SetInterEmpty_587(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_588","instance":588,"id":203931,"goal":"lemma SetInterSubset_588(T: set, U: set)\n ensures T * U <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_589","instance":589,"id":203932,"goal":"lemma SetCardSubset_589(U: set, B: set)\n requires U <= B\n ensures |U| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_590","instance":590,"id":203933,"goal":"lemma SetUnionCard_590(A: set, U: set)\n requires A * U == {}\n ensures |A + U| == |A| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_591","instance":591,"id":203934,"goal":"lemma SetUnionComm_591(U: set, S: set)\n ensures U + S == S + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_592","instance":592,"id":203935,"goal":"lemma SetInterComm_592(A: set, T: set)\n ensures A * T == T * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_593","instance":593,"id":203936,"goal":"lemma SetUnionAssoc_593(B: set, A: set, T: set)\n ensures (B + A) + T == B + (A + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_594","instance":594,"id":203937,"goal":"lemma SetSubsetRefl_594(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_595","instance":595,"id":203938,"goal":"lemma SetSubsetTrans_595(B: set, T: set, S: set)\n requires B <= T && T <= S\n ensures B <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_596","instance":596,"id":203939,"goal":"lemma SetUnionEmpty_596(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_597","instance":597,"id":203940,"goal":"lemma SetInterEmpty_597(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_598","instance":598,"id":203941,"goal":"lemma SetInterSubset_598(U: set, B: set)\n ensures U * B <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_599","instance":599,"id":203942,"goal":"lemma SetCardSubset_599(S: set, B: set)\n requires S <= B\n ensures |S| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_600","instance":600,"id":203943,"goal":"lemma SetUnionCard_600(T: set, U: set)\n requires T * U == {}\n ensures |T + U| == |T| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_601","instance":601,"id":203944,"goal":"lemma SetUnionComm_601(B: set, S: set)\n ensures B + S == S + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_602","instance":602,"id":203945,"goal":"lemma SetInterComm_602(T: set, U: set)\n ensures T * U == U * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_603","instance":603,"id":203946,"goal":"lemma SetUnionAssoc_603(U: set, A: set, S: set)\n ensures (U + A) + S == U + (A + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_604","instance":604,"id":203947,"goal":"lemma SetSubsetRefl_604(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_605","instance":605,"id":203948,"goal":"lemma SetSubsetTrans_605(S: set, T: set, A: set)\n requires S <= T && T <= A\n ensures S <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_606","instance":606,"id":203949,"goal":"lemma SetUnionEmpty_606(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_607","instance":607,"id":203950,"goal":"lemma SetInterEmpty_607(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_608","instance":608,"id":203951,"goal":"lemma SetInterSubset_608(B: set, U: set)\n ensures B * U <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_609","instance":609,"id":203952,"goal":"lemma SetCardSubset_609(B: set, S: set)\n requires B <= S\n ensures |B| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_610","instance":610,"id":203953,"goal":"lemma SetUnionCard_610(U: set, B: set)\n requires U * B == {}\n ensures |U + B| == |U| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_611","instance":611,"id":203954,"goal":"lemma SetUnionComm_611(A: set, S: set)\n ensures A + S == S + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_612","instance":612,"id":203955,"goal":"lemma SetInterComm_612(B: set, S: set)\n ensures B * S == S * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_613","instance":613,"id":203956,"goal":"lemma SetUnionAssoc_613(S: set, B: set, T: set)\n ensures (S + B) + T == S + (B + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_614","instance":614,"id":203957,"goal":"lemma SetSubsetRefl_614(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_615","instance":615,"id":203958,"goal":"lemma SetSubsetTrans_615(U: set, T: set, S: set)\n requires U <= T && T <= S\n ensures U <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_616","instance":616,"id":203959,"goal":"lemma SetUnionEmpty_616(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_617","instance":617,"id":203960,"goal":"lemma SetInterEmpty_617(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_618","instance":618,"id":203961,"goal":"lemma SetInterSubset_618(U: set, A: set)\n ensures U * A <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_619","instance":619,"id":203962,"goal":"lemma SetCardSubset_619(B: set, T: set)\n requires B <= T\n ensures |B| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_620","instance":620,"id":203963,"goal":"lemma SetUnionCard_620(T: set, A: set)\n requires T * A == {}\n ensures |T + A| == |T| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_621","instance":621,"id":203964,"goal":"lemma SetUnionComm_621(T: set, B: set)\n ensures T + B == B + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_622","instance":622,"id":203965,"goal":"lemma SetInterComm_622(B: set, T: set)\n ensures B * T == T * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_623","instance":623,"id":203966,"goal":"lemma SetUnionAssoc_623(T: set, S: set, A: set)\n ensures (T + S) + A == T + (S + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_624","instance":624,"id":203967,"goal":"lemma SetSubsetRefl_624(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_625","instance":625,"id":203968,"goal":"lemma SetSubsetTrans_625(S: set, U: set, B: set)\n requires S <= U && U <= B\n ensures S <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_626","instance":626,"id":203969,"goal":"lemma SetUnionEmpty_626(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_627","instance":627,"id":203970,"goal":"lemma SetInterEmpty_627(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_628","instance":628,"id":203971,"goal":"lemma SetInterSubset_628(U: set, A: set)\n ensures U * A <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_629","instance":629,"id":203972,"goal":"lemma SetCardSubset_629(T: set, A: set)\n requires T <= A\n ensures |T| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_630","instance":630,"id":203973,"goal":"lemma SetUnionCard_630(U: set, T: set)\n requires U * T == {}\n ensures |U + T| == |U| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_631","instance":631,"id":203974,"goal":"lemma SetUnionComm_631(T: set, A: set)\n ensures T + A == A + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_632","instance":632,"id":203975,"goal":"lemma SetInterComm_632(U: set, A: set)\n ensures U * A == A * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_633","instance":633,"id":203976,"goal":"lemma SetUnionAssoc_633(T: set, B: set, A: set)\n ensures (T + B) + A == T + (B + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_634","instance":634,"id":203977,"goal":"lemma SetSubsetRefl_634(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_635","instance":635,"id":203978,"goal":"lemma SetSubsetTrans_635(T: set, A: set, S: set)\n requires T <= A && A <= S\n ensures T <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_636","instance":636,"id":203979,"goal":"lemma SetUnionEmpty_636(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_637","instance":637,"id":203980,"goal":"lemma SetInterEmpty_637(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_638","instance":638,"id":203981,"goal":"lemma SetInterSubset_638(B: set, A: set)\n ensures B * A <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_639","instance":639,"id":203982,"goal":"lemma SetCardSubset_639(B: set, U: set)\n requires B <= U\n ensures |B| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_640","instance":640,"id":203983,"goal":"lemma SetUnionCard_640(B: set, T: set)\n requires B * T == {}\n ensures |B + T| == |B| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_641","instance":641,"id":203984,"goal":"lemma SetUnionComm_641(T: set, U: set)\n ensures T + U == U + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_642","instance":642,"id":203985,"goal":"lemma SetInterComm_642(A: set, S: set)\n ensures A * S == S * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_643","instance":643,"id":203986,"goal":"lemma SetUnionAssoc_643(T: set, B: set, A: set)\n ensures (T + B) + A == T + (B + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_644","instance":644,"id":203987,"goal":"lemma SetSubsetRefl_644(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_645","instance":645,"id":203988,"goal":"lemma SetSubsetTrans_645(T: set, U: set, B: set)\n requires T <= U && U <= B\n ensures T <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_646","instance":646,"id":203989,"goal":"lemma SetUnionEmpty_646(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_647","instance":647,"id":203990,"goal":"lemma SetInterEmpty_647(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_648","instance":648,"id":203991,"goal":"lemma SetInterSubset_648(U: set, T: set)\n ensures U * T <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_649","instance":649,"id":203992,"goal":"lemma SetCardSubset_649(T: set, S: set)\n requires T <= S\n ensures |T| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_650","instance":650,"id":203993,"goal":"lemma SetUnionCard_650(S: set, B: set)\n requires S * B == {}\n ensures |S + B| == |S| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_651","instance":651,"id":203994,"goal":"lemma SetUnionComm_651(T: set, S: set)\n ensures T + S == S + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_652","instance":652,"id":203995,"goal":"lemma SetInterComm_652(U: set, B: set)\n ensures U * B == B * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_653","instance":653,"id":203996,"goal":"lemma SetUnionAssoc_653(T: set, B: set, A: set)\n ensures (T + B) + A == T + (B + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_654","instance":654,"id":203997,"goal":"lemma SetSubsetRefl_654(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_655","instance":655,"id":203998,"goal":"lemma SetSubsetTrans_655(B: set, T: set, S: set)\n requires B <= T && T <= S\n ensures B <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_656","instance":656,"id":203999,"goal":"lemma SetUnionEmpty_656(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_657","instance":657,"id":204000,"goal":"lemma SetInterEmpty_657(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_658","instance":658,"id":204001,"goal":"lemma SetInterSubset_658(U: set, B: set)\n ensures U * B <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_659","instance":659,"id":204002,"goal":"lemma SetCardSubset_659(T: set, S: set)\n requires T <= S\n ensures |T| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_660","instance":660,"id":204003,"goal":"lemma SetUnionCard_660(A: set, B: set)\n requires A * B == {}\n ensures |A + B| == |A| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_661","instance":661,"id":204004,"goal":"lemma SetUnionComm_661(T: set, S: set)\n ensures T + S == S + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_662","instance":662,"id":204005,"goal":"lemma SetInterComm_662(A: set, U: set)\n ensures A * U == U * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_663","instance":663,"id":204006,"goal":"lemma SetUnionAssoc_663(T: set, B: set, S: set)\n ensures (T + B) + S == T + (B + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_664","instance":664,"id":204007,"goal":"lemma SetSubsetRefl_664(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_665","instance":665,"id":204008,"goal":"lemma SetSubsetTrans_665(S: set, U: set, B: set)\n requires S <= U && U <= B\n ensures S <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_666","instance":666,"id":204009,"goal":"lemma SetUnionEmpty_666(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_667","instance":667,"id":204010,"goal":"lemma SetInterEmpty_667(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_668","instance":668,"id":204011,"goal":"lemma SetInterSubset_668(B: set, T: set)\n ensures B * T <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_669","instance":669,"id":204012,"goal":"lemma SetCardSubset_669(S: set, B: set)\n requires S <= B\n ensures |S| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_670","instance":670,"id":204013,"goal":"lemma SetUnionCard_670(A: set, S: set)\n requires A * S == {}\n ensures |A + S| == |A| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_671","instance":671,"id":204014,"goal":"lemma SetUnionComm_671(B: set, A: set)\n ensures B + A == A + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_672","instance":672,"id":204015,"goal":"lemma SetInterComm_672(S: set, T: set)\n ensures S * T == T * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_673","instance":673,"id":204016,"goal":"lemma SetUnionAssoc_673(T: set, U: set, A: set)\n ensures (T + U) + A == T + (U + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_674","instance":674,"id":204017,"goal":"lemma SetSubsetRefl_674(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_675","instance":675,"id":204018,"goal":"lemma SetSubsetTrans_675(T: set, B: set, A: set)\n requires T <= B && B <= A\n ensures T <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_676","instance":676,"id":204019,"goal":"lemma SetUnionEmpty_676(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_677","instance":677,"id":204020,"goal":"lemma SetInterEmpty_677(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_678","instance":678,"id":204021,"goal":"lemma SetInterSubset_678(T: set, S: set)\n ensures T * S <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_679","instance":679,"id":204022,"goal":"lemma SetCardSubset_679(U: set, A: set)\n requires U <= A\n ensures |U| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_680","instance":680,"id":204023,"goal":"lemma SetUnionCard_680(U: set, A: set)\n requires U * A == {}\n ensures |U + A| == |U| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_681","instance":681,"id":204024,"goal":"lemma SetUnionComm_681(B: set, U: set)\n ensures B + U == U + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_682","instance":682,"id":204025,"goal":"lemma SetInterComm_682(U: set, T: set)\n ensures U * T == T * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_683","instance":683,"id":204026,"goal":"lemma SetUnionAssoc_683(S: set, B: set, A: set)\n ensures (S + B) + A == S + (B + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_684","instance":684,"id":204027,"goal":"lemma SetSubsetRefl_684(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_685","instance":685,"id":204028,"goal":"lemma SetSubsetTrans_685(U: set, T: set, S: set)\n requires U <= T && T <= S\n ensures U <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_686","instance":686,"id":204029,"goal":"lemma SetUnionEmpty_686(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_687","instance":687,"id":204030,"goal":"lemma SetInterEmpty_687(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_688","instance":688,"id":204031,"goal":"lemma SetInterSubset_688(T: set, S: set)\n ensures T * S <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_689","instance":689,"id":204032,"goal":"lemma SetCardSubset_689(T: set, U: set)\n requires T <= U\n ensures |T| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_690","instance":690,"id":204033,"goal":"lemma SetUnionCard_690(A: set, B: set)\n requires A * B == {}\n ensures |A + B| == |A| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_691","instance":691,"id":204034,"goal":"lemma SetUnionComm_691(A: set, S: set)\n ensures A + S == S + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_692","instance":692,"id":204035,"goal":"lemma SetInterComm_692(T: set, B: set)\n ensures T * B == B * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_693","instance":693,"id":204036,"goal":"lemma SetUnionAssoc_693(T: set, A: set, S: set)\n ensures (T + A) + S == T + (A + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_694","instance":694,"id":204037,"goal":"lemma SetSubsetRefl_694(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_695","instance":695,"id":204038,"goal":"lemma SetSubsetTrans_695(S: set, A: set, T: set)\n requires S <= A && A <= T\n ensures S <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_696","instance":696,"id":204039,"goal":"lemma SetUnionEmpty_696(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_697","instance":697,"id":204040,"goal":"lemma SetInterEmpty_697(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_698","instance":698,"id":204041,"goal":"lemma SetInterSubset_698(U: set, B: set)\n ensures U * B <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_699","instance":699,"id":204042,"goal":"lemma SetCardSubset_699(T: set, U: set)\n requires T <= U\n ensures |T| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_700","instance":700,"id":204043,"goal":"lemma SetUnionCard_700(A: set, U: set)\n requires A * U == {}\n ensures |A + U| == |A| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_701","instance":701,"id":204044,"goal":"lemma SetUnionComm_701(U: set, A: set)\n ensures U + A == A + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_702","instance":702,"id":204045,"goal":"lemma SetInterComm_702(T: set, S: set)\n ensures T * S == S * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_703","instance":703,"id":204046,"goal":"lemma SetUnionAssoc_703(B: set, A: set, T: set)\n ensures (B + A) + T == B + (A + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_704","instance":704,"id":204047,"goal":"lemma SetSubsetRefl_704(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_705","instance":705,"id":204048,"goal":"lemma SetSubsetTrans_705(T: set, B: set, S: set)\n requires T <= B && B <= S\n ensures T <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_706","instance":706,"id":204049,"goal":"lemma SetUnionEmpty_706(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_707","instance":707,"id":204050,"goal":"lemma SetInterEmpty_707(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_708","instance":708,"id":204051,"goal":"lemma SetInterSubset_708(S: set, B: set)\n ensures S * B <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_709","instance":709,"id":204052,"goal":"lemma SetCardSubset_709(S: set, U: set)\n requires S <= U\n ensures |S| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_710","instance":710,"id":204053,"goal":"lemma SetUnionCard_710(U: set, B: set)\n requires U * B == {}\n ensures |U + B| == |U| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_711","instance":711,"id":204054,"goal":"lemma SetUnionComm_711(B: set, T: set)\n ensures B + T == T + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_712","instance":712,"id":204055,"goal":"lemma SetInterComm_712(T: set, A: set)\n ensures T * A == A * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_713","instance":713,"id":204056,"goal":"lemma SetUnionAssoc_713(U: set, B: set, A: set)\n ensures (U + B) + A == U + (B + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_714","instance":714,"id":204057,"goal":"lemma SetSubsetRefl_714(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_715","instance":715,"id":204058,"goal":"lemma SetSubsetTrans_715(U: set, B: set, S: set)\n requires U <= B && B <= S\n ensures U <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_716","instance":716,"id":204059,"goal":"lemma SetUnionEmpty_716(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_717","instance":717,"id":204060,"goal":"lemma SetInterEmpty_717(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_718","instance":718,"id":204061,"goal":"lemma SetInterSubset_718(U: set, T: set)\n ensures U * T <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_719","instance":719,"id":204062,"goal":"lemma SetCardSubset_719(S: set, A: set)\n requires S <= A\n ensures |S| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_720","instance":720,"id":204063,"goal":"lemma SetUnionCard_720(S: set, U: set)\n requires S * U == {}\n ensures |S + U| == |S| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_721","instance":721,"id":204064,"goal":"lemma SetUnionComm_721(S: set, A: set)\n ensures S + A == A + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_722","instance":722,"id":204065,"goal":"lemma SetInterComm_722(U: set, A: set)\n ensures U * A == A * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_723","instance":723,"id":204066,"goal":"lemma SetUnionAssoc_723(S: set, T: set, A: set)\n ensures (S + T) + A == S + (T + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_724","instance":724,"id":204067,"goal":"lemma SetSubsetRefl_724(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_725","instance":725,"id":204068,"goal":"lemma SetSubsetTrans_725(B: set, T: set, A: set)\n requires B <= T && T <= A\n ensures B <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_726","instance":726,"id":204069,"goal":"lemma SetUnionEmpty_726(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_727","instance":727,"id":204070,"goal":"lemma SetInterEmpty_727(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_728","instance":728,"id":204071,"goal":"lemma SetInterSubset_728(U: set, B: set)\n ensures U * B <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_729","instance":729,"id":204072,"goal":"lemma SetCardSubset_729(A: set, B: set)\n requires A <= B\n ensures |A| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_730","instance":730,"id":204073,"goal":"lemma SetUnionCard_730(U: set, B: set)\n requires U * B == {}\n ensures |U + B| == |U| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_731","instance":731,"id":204074,"goal":"lemma SetUnionComm_731(T: set, S: set)\n ensures T + S == S + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_732","instance":732,"id":204075,"goal":"lemma SetInterComm_732(T: set, A: set)\n ensures T * A == A * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_733","instance":733,"id":204076,"goal":"lemma SetUnionAssoc_733(B: set, T: set, A: set)\n ensures (B + T) + A == B + (T + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_734","instance":734,"id":204077,"goal":"lemma SetSubsetRefl_734(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_735","instance":735,"id":204078,"goal":"lemma SetSubsetTrans_735(T: set, A: set, U: set)\n requires T <= A && A <= U\n ensures T <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_736","instance":736,"id":204079,"goal":"lemma SetUnionEmpty_736(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_737","instance":737,"id":204080,"goal":"lemma SetInterEmpty_737(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_738","instance":738,"id":204081,"goal":"lemma SetInterSubset_738(U: set, B: set)\n ensures U * B <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_739","instance":739,"id":204082,"goal":"lemma SetCardSubset_739(S: set, B: set)\n requires S <= B\n ensures |S| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_740","instance":740,"id":204083,"goal":"lemma SetUnionCard_740(B: set, A: set)\n requires B * A == {}\n ensures |B + A| == |B| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_741","instance":741,"id":204084,"goal":"lemma SetUnionComm_741(B: set, S: set)\n ensures B + S == S + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_742","instance":742,"id":204085,"goal":"lemma SetInterComm_742(S: set, A: set)\n ensures S * A == A * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_743","instance":743,"id":204086,"goal":"lemma SetUnionAssoc_743(S: set, U: set, B: set)\n ensures (S + U) + B == S + (U + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_744","instance":744,"id":204087,"goal":"lemma SetSubsetRefl_744(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_745","instance":745,"id":204088,"goal":"lemma SetSubsetTrans_745(S: set, U: set, A: set)\n requires S <= U && U <= A\n ensures S <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_746","instance":746,"id":204089,"goal":"lemma SetUnionEmpty_746(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_747","instance":747,"id":204090,"goal":"lemma SetInterEmpty_747(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_748","instance":748,"id":204091,"goal":"lemma SetInterSubset_748(A: set, S: set)\n ensures A * S <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_749","instance":749,"id":204092,"goal":"lemma SetCardSubset_749(T: set, B: set)\n requires T <= B\n ensures |T| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_750","instance":750,"id":204093,"goal":"lemma SetUnionCard_750(S: set, B: set)\n requires S * B == {}\n ensures |S + B| == |S| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_751","instance":751,"id":204094,"goal":"lemma SetUnionComm_751(B: set, S: set)\n ensures B + S == S + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_752","instance":752,"id":204095,"goal":"lemma SetInterComm_752(U: set, T: set)\n ensures U * T == T * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_753","instance":753,"id":204096,"goal":"lemma SetUnionAssoc_753(B: set, A: set, U: set)\n ensures (B + A) + U == B + (A + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_754","instance":754,"id":204097,"goal":"lemma SetSubsetRefl_754(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_755","instance":755,"id":204098,"goal":"lemma SetSubsetTrans_755(T: set, U: set, B: set)\n requires T <= U && U <= B\n ensures T <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_756","instance":756,"id":204099,"goal":"lemma SetUnionEmpty_756(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_757","instance":757,"id":204100,"goal":"lemma SetInterEmpty_757(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_758","instance":758,"id":204101,"goal":"lemma SetInterSubset_758(S: set, A: set)\n ensures S * A <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_759","instance":759,"id":204102,"goal":"lemma SetCardSubset_759(B: set, A: set)\n requires B <= A\n ensures |B| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_760","instance":760,"id":204103,"goal":"lemma SetUnionCard_760(B: set, T: set)\n requires B * T == {}\n ensures |B + T| == |B| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_761","instance":761,"id":204104,"goal":"lemma SetUnionComm_761(A: set, S: set)\n ensures A + S == S + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_762","instance":762,"id":204105,"goal":"lemma SetInterComm_762(B: set, A: set)\n ensures B * A == A * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_763","instance":763,"id":204106,"goal":"lemma SetUnionAssoc_763(A: set, T: set, S: set)\n ensures (A + T) + S == A + (T + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_764","instance":764,"id":204107,"goal":"lemma SetSubsetRefl_764(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_765","instance":765,"id":204108,"goal":"lemma SetSubsetTrans_765(A: set, B: set, T: set)\n requires A <= B && B <= T\n ensures A <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_766","instance":766,"id":204109,"goal":"lemma SetUnionEmpty_766(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_767","instance":767,"id":204110,"goal":"lemma SetInterEmpty_767(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_768","instance":768,"id":204111,"goal":"lemma SetInterSubset_768(T: set, B: set)\n ensures T * B <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_769","instance":769,"id":204112,"goal":"lemma SetCardSubset_769(U: set, S: set)\n requires U <= S\n ensures |U| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_770","instance":770,"id":204113,"goal":"lemma SetUnionCard_770(S: set, U: set)\n requires S * U == {}\n ensures |S + U| == |S| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_771","instance":771,"id":204114,"goal":"lemma SetUnionComm_771(U: set, S: set)\n ensures U + S == S + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_772","instance":772,"id":204115,"goal":"lemma SetInterComm_772(T: set, S: set)\n ensures T * S == S * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_773","instance":773,"id":204116,"goal":"lemma SetUnionAssoc_773(A: set, T: set, B: set)\n ensures (A + T) + B == A + (T + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_774","instance":774,"id":204117,"goal":"lemma SetSubsetRefl_774(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_775","instance":775,"id":204118,"goal":"lemma SetSubsetTrans_775(A: set, T: set, U: set)\n requires A <= T && T <= U\n ensures A <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_776","instance":776,"id":204119,"goal":"lemma SetUnionEmpty_776(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_777","instance":777,"id":204120,"goal":"lemma SetInterEmpty_777(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_778","instance":778,"id":204121,"goal":"lemma SetInterSubset_778(A: set, U: set)\n ensures A * U <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_779","instance":779,"id":204122,"goal":"lemma SetCardSubset_779(A: set, U: set)\n requires A <= U\n ensures |A| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_780","instance":780,"id":204123,"goal":"lemma SetUnionCard_780(B: set, S: set)\n requires B * S == {}\n ensures |B + S| == |B| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_781","instance":781,"id":204124,"goal":"lemma SetUnionComm_781(T: set, S: set)\n ensures T + S == S + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_782","instance":782,"id":204125,"goal":"lemma SetInterComm_782(U: set, T: set)\n ensures U * T == T * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_783","instance":783,"id":204126,"goal":"lemma SetUnionAssoc_783(S: set, B: set, A: set)\n ensures (S + B) + A == S + (B + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_784","instance":784,"id":204127,"goal":"lemma SetSubsetRefl_784(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_785","instance":785,"id":204128,"goal":"lemma SetSubsetTrans_785(A: set, S: set, B: set)\n requires A <= S && S <= B\n ensures A <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_786","instance":786,"id":204129,"goal":"lemma SetUnionEmpty_786(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_787","instance":787,"id":204130,"goal":"lemma SetInterEmpty_787(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_788","instance":788,"id":204131,"goal":"lemma SetInterSubset_788(B: set, A: set)\n ensures B * A <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_789","instance":789,"id":204132,"goal":"lemma SetCardSubset_789(A: set, U: set)\n requires A <= U\n ensures |A| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_790","instance":790,"id":204133,"goal":"lemma SetUnionCard_790(T: set, U: set)\n requires T * U == {}\n ensures |T + U| == |T| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_791","instance":791,"id":204134,"goal":"lemma SetUnionComm_791(A: set, S: set)\n ensures A + S == S + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_792","instance":792,"id":204135,"goal":"lemma SetInterComm_792(T: set, A: set)\n ensures T * A == A * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_793","instance":793,"id":204136,"goal":"lemma SetUnionAssoc_793(A: set, T: set, U: set)\n ensures (A + T) + U == A + (T + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_794","instance":794,"id":204137,"goal":"lemma SetSubsetRefl_794(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_795","instance":795,"id":204138,"goal":"lemma SetSubsetTrans_795(A: set, T: set, S: set)\n requires A <= T && T <= S\n ensures A <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_796","instance":796,"id":204139,"goal":"lemma SetUnionEmpty_796(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_797","instance":797,"id":204140,"goal":"lemma SetInterEmpty_797(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_798","instance":798,"id":204141,"goal":"lemma SetInterSubset_798(S: set, B: set)\n ensures S * B <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_799","instance":799,"id":204142,"goal":"lemma SetCardSubset_799(A: set, S: set)\n requires A <= S\n ensures |A| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_800","instance":800,"id":204143,"goal":"lemma SetUnionCard_800(U: set, S: set)\n requires U * S == {}\n ensures |U + S| == |U| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_801","instance":801,"id":204144,"goal":"lemma SetUnionComm_801(T: set, A: set)\n ensures T + A == A + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_802","instance":802,"id":204145,"goal":"lemma SetInterComm_802(U: set, T: set)\n ensures U * T == T * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_803","instance":803,"id":204146,"goal":"lemma SetUnionAssoc_803(T: set, S: set, A: set)\n ensures (T + S) + A == T + (S + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_804","instance":804,"id":204147,"goal":"lemma SetSubsetRefl_804(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_805","instance":805,"id":204148,"goal":"lemma SetSubsetTrans_805(B: set, A: set, T: set)\n requires B <= A && A <= T\n ensures B <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_806","instance":806,"id":204149,"goal":"lemma SetUnionEmpty_806(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_807","instance":807,"id":204150,"goal":"lemma SetInterEmpty_807(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_808","instance":808,"id":204151,"goal":"lemma SetInterSubset_808(T: set, U: set)\n ensures T * U <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_809","instance":809,"id":204152,"goal":"lemma SetCardSubset_809(A: set, S: set)\n requires A <= S\n ensures |A| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_810","instance":810,"id":204153,"goal":"lemma SetUnionCard_810(T: set, S: set)\n requires T * S == {}\n ensures |T + S| == |T| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_811","instance":811,"id":204154,"goal":"lemma SetUnionComm_811(B: set, T: set)\n ensures B + T == T + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_812","instance":812,"id":204155,"goal":"lemma SetInterComm_812(U: set, B: set)\n ensures U * B == B * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_813","instance":813,"id":204156,"goal":"lemma SetUnionAssoc_813(A: set, S: set, T: set)\n ensures (A + S) + T == A + (S + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_814","instance":814,"id":204157,"goal":"lemma SetSubsetRefl_814(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_815","instance":815,"id":204158,"goal":"lemma SetSubsetTrans_815(B: set, T: set, S: set)\n requires B <= T && T <= S\n ensures B <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_816","instance":816,"id":204159,"goal":"lemma SetUnionEmpty_816(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_817","instance":817,"id":204160,"goal":"lemma SetInterEmpty_817(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_818","instance":818,"id":204161,"goal":"lemma SetInterSubset_818(A: set, S: set)\n ensures A * S <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_819","instance":819,"id":204162,"goal":"lemma SetCardSubset_819(B: set, S: set)\n requires B <= S\n ensures |B| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_820","instance":820,"id":204163,"goal":"lemma SetUnionCard_820(T: set, S: set)\n requires T * S == {}\n ensures |T + S| == |T| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_821","instance":821,"id":204164,"goal":"lemma SetUnionComm_821(S: set, U: set)\n ensures S + U == U + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_822","instance":822,"id":204165,"goal":"lemma SetInterComm_822(S: set, B: set)\n ensures S * B == B * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_823","instance":823,"id":204166,"goal":"lemma SetUnionAssoc_823(U: set, T: set, B: set)\n ensures (U + T) + B == U + (T + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_824","instance":824,"id":204167,"goal":"lemma SetSubsetRefl_824(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_825","instance":825,"id":204168,"goal":"lemma SetSubsetTrans_825(S: set, T: set, U: set)\n requires S <= T && T <= U\n ensures S <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_826","instance":826,"id":204169,"goal":"lemma SetUnionEmpty_826(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_827","instance":827,"id":204170,"goal":"lemma SetInterEmpty_827(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_828","instance":828,"id":204171,"goal":"lemma SetInterSubset_828(U: set, A: set)\n ensures U * A <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_829","instance":829,"id":204172,"goal":"lemma SetCardSubset_829(B: set, A: set)\n requires B <= A\n ensures |B| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_830","instance":830,"id":204173,"goal":"lemma SetUnionCard_830(T: set, B: set)\n requires T * B == {}\n ensures |T + B| == |T| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_831","instance":831,"id":204174,"goal":"lemma SetUnionComm_831(S: set, T: set)\n ensures S + T == T + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_832","instance":832,"id":204175,"goal":"lemma SetInterComm_832(T: set, S: set)\n ensures T * S == S * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_833","instance":833,"id":204176,"goal":"lemma SetUnionAssoc_833(U: set, A: set, B: set)\n ensures (U + A) + B == U + (A + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_834","instance":834,"id":204177,"goal":"lemma SetSubsetRefl_834(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_835","instance":835,"id":204178,"goal":"lemma SetSubsetTrans_835(A: set, B: set, S: set)\n requires A <= B && B <= S\n ensures A <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_836","instance":836,"id":204179,"goal":"lemma SetUnionEmpty_836(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_837","instance":837,"id":204180,"goal":"lemma SetInterEmpty_837(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_838","instance":838,"id":204181,"goal":"lemma SetInterSubset_838(S: set, U: set)\n ensures S * U <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_839","instance":839,"id":204182,"goal":"lemma SetCardSubset_839(T: set, A: set)\n requires T <= A\n ensures |T| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_840","instance":840,"id":204183,"goal":"lemma SetUnionCard_840(B: set, T: set)\n requires B * T == {}\n ensures |B + T| == |B| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_841","instance":841,"id":204184,"goal":"lemma SetUnionComm_841(B: set, S: set)\n ensures B + S == S + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_842","instance":842,"id":204185,"goal":"lemma SetInterComm_842(U: set, T: set)\n ensures U * T == T * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_843","instance":843,"id":204186,"goal":"lemma SetUnionAssoc_843(T: set, A: set, U: set)\n ensures (T + A) + U == T + (A + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_844","instance":844,"id":204187,"goal":"lemma SetSubsetRefl_844(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_845","instance":845,"id":204188,"goal":"lemma SetSubsetTrans_845(T: set, B: set, A: set)\n requires T <= B && B <= A\n ensures T <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_846","instance":846,"id":204189,"goal":"lemma SetUnionEmpty_846(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_847","instance":847,"id":204190,"goal":"lemma SetInterEmpty_847(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_848","instance":848,"id":204191,"goal":"lemma SetInterSubset_848(U: set, B: set)\n ensures U * B <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_849","instance":849,"id":204192,"goal":"lemma SetCardSubset_849(A: set, B: set)\n requires A <= B\n ensures |A| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_850","instance":850,"id":204193,"goal":"lemma SetUnionCard_850(A: set, S: set)\n requires A * S == {}\n ensures |A + S| == |A| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_851","instance":851,"id":204194,"goal":"lemma SetUnionComm_851(T: set, A: set)\n ensures T + A == A + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_852","instance":852,"id":204195,"goal":"lemma SetInterComm_852(A: set, U: set)\n ensures A * U == U * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_853","instance":853,"id":204196,"goal":"lemma SetUnionAssoc_853(A: set, B: set, U: set)\n ensures (A + B) + U == A + (B + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_854","instance":854,"id":204197,"goal":"lemma SetSubsetRefl_854(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_855","instance":855,"id":204198,"goal":"lemma SetSubsetTrans_855(B: set, A: set, T: set)\n requires B <= A && A <= T\n ensures B <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_856","instance":856,"id":204199,"goal":"lemma SetUnionEmpty_856(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_857","instance":857,"id":204200,"goal":"lemma SetInterEmpty_857(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_858","instance":858,"id":204201,"goal":"lemma SetInterSubset_858(U: set, T: set)\n ensures U * T <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_859","instance":859,"id":204202,"goal":"lemma SetCardSubset_859(U: set, A: set)\n requires U <= A\n ensures |U| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_860","instance":860,"id":204203,"goal":"lemma SetUnionCard_860(B: set, T: set)\n requires B * T == {}\n ensures |B + T| == |B| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_861","instance":861,"id":204204,"goal":"lemma SetUnionComm_861(B: set, S: set)\n ensures B + S == S + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_862","instance":862,"id":204205,"goal":"lemma SetInterComm_862(B: set, S: set)\n ensures B * S == S * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_863","instance":863,"id":204206,"goal":"lemma SetUnionAssoc_863(A: set, S: set, B: set)\n ensures (A + S) + B == A + (S + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_864","instance":864,"id":204207,"goal":"lemma SetSubsetRefl_864(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_865","instance":865,"id":204208,"goal":"lemma SetSubsetTrans_865(T: set, A: set, U: set)\n requires T <= A && A <= U\n ensures T <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_866","instance":866,"id":204209,"goal":"lemma SetUnionEmpty_866(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_867","instance":867,"id":204210,"goal":"lemma SetInterEmpty_867(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_868","instance":868,"id":204211,"goal":"lemma SetInterSubset_868(S: set, A: set)\n ensures S * A <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_869","instance":869,"id":204212,"goal":"lemma SetCardSubset_869(S: set, T: set)\n requires S <= T\n ensures |S| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_870","instance":870,"id":204213,"goal":"lemma SetUnionCard_870(T: set, B: set)\n requires T * B == {}\n ensures |T + B| == |T| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_871","instance":871,"id":204214,"goal":"lemma SetUnionComm_871(S: set, B: set)\n ensures S + B == B + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_872","instance":872,"id":204215,"goal":"lemma SetInterComm_872(T: set, A: set)\n ensures T * A == A * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_873","instance":873,"id":204216,"goal":"lemma SetUnionAssoc_873(A: set, U: set, T: set)\n ensures (A + U) + T == A + (U + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_874","instance":874,"id":204217,"goal":"lemma SetSubsetRefl_874(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_875","instance":875,"id":204218,"goal":"lemma SetSubsetTrans_875(T: set, U: set, A: set)\n requires T <= U && U <= A\n ensures T <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_876","instance":876,"id":204219,"goal":"lemma SetUnionEmpty_876(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_877","instance":877,"id":204220,"goal":"lemma SetInterEmpty_877(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_878","instance":878,"id":204221,"goal":"lemma SetInterSubset_878(B: set, S: set)\n ensures B * S <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_879","instance":879,"id":204222,"goal":"lemma SetCardSubset_879(A: set, U: set)\n requires A <= U\n ensures |A| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_880","instance":880,"id":204223,"goal":"lemma SetUnionCard_880(B: set, S: set)\n requires B * S == {}\n ensures |B + S| == |B| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_881","instance":881,"id":204224,"goal":"lemma SetUnionComm_881(A: set, S: set)\n ensures A + S == S + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_882","instance":882,"id":204225,"goal":"lemma SetInterComm_882(S: set, A: set)\n ensures S * A == A * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_883","instance":883,"id":204226,"goal":"lemma SetUnionAssoc_883(U: set, B: set, T: set)\n ensures (U + B) + T == U + (B + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_884","instance":884,"id":204227,"goal":"lemma SetSubsetRefl_884(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_885","instance":885,"id":204228,"goal":"lemma SetSubsetTrans_885(T: set, S: set, U: set)\n requires T <= S && S <= U\n ensures T <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_886","instance":886,"id":204229,"goal":"lemma SetUnionEmpty_886(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_887","instance":887,"id":204230,"goal":"lemma SetInterEmpty_887(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_888","instance":888,"id":204231,"goal":"lemma SetInterSubset_888(A: set, B: set)\n ensures A * B <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_889","instance":889,"id":204232,"goal":"lemma SetCardSubset_889(A: set, U: set)\n requires A <= U\n ensures |A| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_890","instance":890,"id":204233,"goal":"lemma SetUnionCard_890(A: set, U: set)\n requires A * U == {}\n ensures |A + U| == |A| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_891","instance":891,"id":204234,"goal":"lemma SetUnionComm_891(A: set, B: set)\n ensures A + B == B + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_892","instance":892,"id":204235,"goal":"lemma SetInterComm_892(S: set, A: set)\n ensures S * A == A * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_893","instance":893,"id":204236,"goal":"lemma SetUnionAssoc_893(T: set, S: set, U: set)\n ensures (T + S) + U == T + (S + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_894","instance":894,"id":204237,"goal":"lemma SetSubsetRefl_894(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_895","instance":895,"id":204238,"goal":"lemma SetSubsetTrans_895(B: set, T: set, U: set)\n requires B <= T && T <= U\n ensures B <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_896","instance":896,"id":204239,"goal":"lemma SetUnionEmpty_896(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_897","instance":897,"id":204240,"goal":"lemma SetInterEmpty_897(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_898","instance":898,"id":204241,"goal":"lemma SetInterSubset_898(B: set, S: set)\n ensures B * S <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_899","instance":899,"id":204242,"goal":"lemma SetCardSubset_899(T: set, S: set)\n requires T <= S\n ensures |T| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_900","instance":900,"id":204243,"goal":"lemma SetUnionCard_900(S: set, T: set)\n requires S * T == {}\n ensures |S + T| == |S| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_901","instance":901,"id":204244,"goal":"lemma SetUnionComm_901(B: set, S: set)\n ensures B + S == S + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_902","instance":902,"id":204245,"goal":"lemma SetInterComm_902(B: set, T: set)\n ensures B * T == T * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_903","instance":903,"id":204246,"goal":"lemma SetUnionAssoc_903(B: set, U: set, S: set)\n ensures (B + U) + S == B + (U + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_904","instance":904,"id":204247,"goal":"lemma SetSubsetRefl_904(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_905","instance":905,"id":204248,"goal":"lemma SetSubsetTrans_905(U: set, S: set, B: set)\n requires U <= S && S <= B\n ensures U <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_906","instance":906,"id":204249,"goal":"lemma SetUnionEmpty_906(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_907","instance":907,"id":204250,"goal":"lemma SetInterEmpty_907(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_908","instance":908,"id":204251,"goal":"lemma SetInterSubset_908(S: set, A: set)\n ensures S * A <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_909","instance":909,"id":204252,"goal":"lemma SetCardSubset_909(A: set, B: set)\n requires A <= B\n ensures |A| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_910","instance":910,"id":204253,"goal":"lemma SetUnionCard_910(S: set, A: set)\n requires S * A == {}\n ensures |S + A| == |S| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_911","instance":911,"id":204254,"goal":"lemma SetUnionComm_911(A: set, S: set)\n ensures A + S == S + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_912","instance":912,"id":204255,"goal":"lemma SetInterComm_912(B: set, T: set)\n ensures B * T == T * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_913","instance":913,"id":204256,"goal":"lemma SetUnionAssoc_913(S: set, A: set, U: set)\n ensures (S + A) + U == S + (A + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_914","instance":914,"id":204257,"goal":"lemma SetSubsetRefl_914(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_915","instance":915,"id":204258,"goal":"lemma SetSubsetTrans_915(B: set, U: set, A: set)\n requires B <= U && U <= A\n ensures B <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_916","instance":916,"id":204259,"goal":"lemma SetUnionEmpty_916(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_917","instance":917,"id":204260,"goal":"lemma SetInterEmpty_917(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_918","instance":918,"id":204261,"goal":"lemma SetInterSubset_918(A: set, S: set)\n ensures A * S <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_919","instance":919,"id":204262,"goal":"lemma SetCardSubset_919(B: set, A: set)\n requires B <= A\n ensures |B| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_920","instance":920,"id":204263,"goal":"lemma SetUnionCard_920(A: set, T: set)\n requires A * T == {}\n ensures |A + T| == |A| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_921","instance":921,"id":204264,"goal":"lemma SetUnionComm_921(A: set, S: set)\n ensures A + S == S + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_922","instance":922,"id":204265,"goal":"lemma SetInterComm_922(S: set, B: set)\n ensures S * B == B * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_923","instance":923,"id":204266,"goal":"lemma SetUnionAssoc_923(B: set, T: set, U: set)\n ensures (B + T) + U == B + (T + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_924","instance":924,"id":204267,"goal":"lemma SetSubsetRefl_924(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_925","instance":925,"id":204268,"goal":"lemma SetSubsetTrans_925(T: set, U: set, B: set)\n requires T <= U && U <= B\n ensures T <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_926","instance":926,"id":204269,"goal":"lemma SetUnionEmpty_926(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_927","instance":927,"id":204270,"goal":"lemma SetInterEmpty_927(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_928","instance":928,"id":204271,"goal":"lemma SetInterSubset_928(B: set, U: set)\n ensures B * U <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_929","instance":929,"id":204272,"goal":"lemma SetCardSubset_929(A: set, U: set)\n requires A <= U\n ensures |A| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_930","instance":930,"id":204273,"goal":"lemma SetUnionCard_930(U: set, B: set)\n requires U * B == {}\n ensures |U + B| == |U| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_931","instance":931,"id":204274,"goal":"lemma SetUnionComm_931(S: set, T: set)\n ensures S + T == T + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_932","instance":932,"id":204275,"goal":"lemma SetInterComm_932(T: set, B: set)\n ensures T * B == B * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_933","instance":933,"id":204276,"goal":"lemma SetUnionAssoc_933(A: set, U: set, B: set)\n ensures (A + U) + B == A + (U + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_934","instance":934,"id":204277,"goal":"lemma SetSubsetRefl_934(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_935","instance":935,"id":204278,"goal":"lemma SetSubsetTrans_935(U: set, T: set, S: set)\n requires U <= T && T <= S\n ensures U <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_936","instance":936,"id":204279,"goal":"lemma SetUnionEmpty_936(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_937","instance":937,"id":204280,"goal":"lemma SetInterEmpty_937(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_938","instance":938,"id":204281,"goal":"lemma SetInterSubset_938(T: set, B: set)\n ensures T * B <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_939","instance":939,"id":204282,"goal":"lemma SetCardSubset_939(A: set, S: set)\n requires A <= S\n ensures |A| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_940","instance":940,"id":204283,"goal":"lemma SetUnionCard_940(A: set, T: set)\n requires A * T == {}\n ensures |A + T| == |A| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_941","instance":941,"id":204284,"goal":"lemma SetUnionComm_941(B: set, U: set)\n ensures B + U == U + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_942","instance":942,"id":204285,"goal":"lemma SetInterComm_942(A: set, S: set)\n ensures A * S == S * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_943","instance":943,"id":204286,"goal":"lemma SetUnionAssoc_943(A: set, U: set, S: set)\n ensures (A + U) + S == A + (U + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_944","instance":944,"id":204287,"goal":"lemma SetSubsetRefl_944(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_945","instance":945,"id":204288,"goal":"lemma SetSubsetTrans_945(S: set, A: set, U: set)\n requires S <= A && A <= U\n ensures S <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_946","instance":946,"id":204289,"goal":"lemma SetUnionEmpty_946(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_947","instance":947,"id":204290,"goal":"lemma SetInterEmpty_947(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_948","instance":948,"id":204291,"goal":"lemma SetInterSubset_948(S: set, U: set)\n ensures S * U <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_949","instance":949,"id":204292,"goal":"lemma SetCardSubset_949(S: set, A: set)\n requires S <= A\n ensures |S| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_950","instance":950,"id":204293,"goal":"lemma SetUnionCard_950(A: set, B: set)\n requires A * B == {}\n ensures |A + B| == |A| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_951","instance":951,"id":204294,"goal":"lemma SetUnionComm_951(B: set, T: set)\n ensures B + T == T + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_952","instance":952,"id":204295,"goal":"lemma SetInterComm_952(T: set, B: set)\n ensures T * B == B * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_953","instance":953,"id":204296,"goal":"lemma SetUnionAssoc_953(B: set, T: set, U: set)\n ensures (B + T) + U == B + (T + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_954","instance":954,"id":204297,"goal":"lemma SetSubsetRefl_954(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_955","instance":955,"id":204298,"goal":"lemma SetSubsetTrans_955(S: set, T: set, B: set)\n requires S <= T && T <= B\n ensures S <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_956","instance":956,"id":204299,"goal":"lemma SetUnionEmpty_956(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_957","instance":957,"id":204300,"goal":"lemma SetInterEmpty_957(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_958","instance":958,"id":204301,"goal":"lemma SetInterSubset_958(U: set, A: set)\n ensures U * A <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_959","instance":959,"id":204302,"goal":"lemma SetCardSubset_959(A: set, B: set)\n requires A <= B\n ensures |A| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_960","instance":960,"id":204303,"goal":"lemma SetUnionCard_960(B: set, U: set)\n requires B * U == {}\n ensures |B + U| == |B| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_961","instance":961,"id":204304,"goal":"lemma SetUnionComm_961(A: set, U: set)\n ensures A + U == U + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_962","instance":962,"id":204305,"goal":"lemma SetInterComm_962(U: set, T: set)\n ensures U * T == T * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_963","instance":963,"id":204306,"goal":"lemma SetUnionAssoc_963(B: set, S: set, T: set)\n ensures (B + S) + T == B + (S + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_964","instance":964,"id":204307,"goal":"lemma SetSubsetRefl_964(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_965","instance":965,"id":204308,"goal":"lemma SetSubsetTrans_965(U: set, B: set, S: set)\n requires U <= B && B <= S\n ensures U <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_966","instance":966,"id":204309,"goal":"lemma SetUnionEmpty_966(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_967","instance":967,"id":204310,"goal":"lemma SetInterEmpty_967(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_968","instance":968,"id":204311,"goal":"lemma SetInterSubset_968(A: set, T: set)\n ensures A * T <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_969","instance":969,"id":204312,"goal":"lemma SetCardSubset_969(B: set, S: set)\n requires B <= S\n ensures |B| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_970","instance":970,"id":204313,"goal":"lemma SetUnionCard_970(S: set, B: set)\n requires S * B == {}\n ensures |S + B| == |S| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_971","instance":971,"id":204314,"goal":"lemma SetUnionComm_971(S: set, U: set)\n ensures S + U == U + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_972","instance":972,"id":204315,"goal":"lemma SetInterComm_972(S: set, T: set)\n ensures S * T == T * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_973","instance":973,"id":204316,"goal":"lemma SetUnionAssoc_973(A: set, U: set, B: set)\n ensures (A + U) + B == A + (U + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_974","instance":974,"id":204317,"goal":"lemma SetSubsetRefl_974(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_975","instance":975,"id":204318,"goal":"lemma SetSubsetTrans_975(A: set, U: set, B: set)\n requires A <= U && U <= B\n ensures A <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_976","instance":976,"id":204319,"goal":"lemma SetUnionEmpty_976(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_977","instance":977,"id":204320,"goal":"lemma SetInterEmpty_977(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_978","instance":978,"id":204321,"goal":"lemma SetInterSubset_978(A: set, S: set)\n ensures A * S <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_979","instance":979,"id":204322,"goal":"lemma SetCardSubset_979(B: set, A: set)\n requires B <= A\n ensures |B| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_980","instance":980,"id":204323,"goal":"lemma SetUnionCard_980(T: set, U: set)\n requires T * U == {}\n ensures |T + U| == |T| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_981","instance":981,"id":204324,"goal":"lemma SetUnionComm_981(T: set, A: set)\n ensures T + A == A + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_982","instance":982,"id":204325,"goal":"lemma SetInterComm_982(B: set, T: set)\n ensures B * T == T * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_983","instance":983,"id":204326,"goal":"lemma SetUnionAssoc_983(S: set, U: set, A: set)\n ensures (S + U) + A == S + (U + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_984","instance":984,"id":204327,"goal":"lemma SetSubsetRefl_984(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_985","instance":985,"id":204328,"goal":"lemma SetSubsetTrans_985(U: set, A: set, B: set)\n requires U <= A && A <= B\n ensures U <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_986","instance":986,"id":204329,"goal":"lemma SetUnionEmpty_986(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_987","instance":987,"id":204330,"goal":"lemma SetInterEmpty_987(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_988","instance":988,"id":204331,"goal":"lemma SetInterSubset_988(U: set, A: set)\n ensures U * A <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_989","instance":989,"id":204332,"goal":"lemma SetCardSubset_989(U: set, T: set)\n requires U <= T\n ensures |U| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_990","instance":990,"id":204333,"goal":"lemma SetUnionCard_990(A: set, S: set)\n requires A * S == {}\n ensures |A + S| == |A| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_991","instance":991,"id":204334,"goal":"lemma SetUnionComm_991(T: set, U: set)\n ensures T + U == U + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_992","instance":992,"id":204335,"goal":"lemma SetInterComm_992(T: set, A: set)\n ensures T * A == A * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_993","instance":993,"id":204336,"goal":"lemma SetUnionAssoc_993(B: set, T: set, S: set)\n ensures (B + T) + S == B + (T + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_994","instance":994,"id":204337,"goal":"lemma SetSubsetRefl_994(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_995","instance":995,"id":204338,"goal":"lemma SetSubsetTrans_995(S: set, A: set, T: set)\n requires S <= A && A <= T\n ensures S <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_996","instance":996,"id":204339,"goal":"lemma SetUnionEmpty_996(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_997","instance":997,"id":204340,"goal":"lemma SetInterEmpty_997(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_998","instance":998,"id":204341,"goal":"lemma SetInterSubset_998(B: set, T: set)\n ensures B * T <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_999","instance":999,"id":204342,"goal":"lemma SetCardSubset_999(A: set, U: set)\n requires A <= U\n ensures |A| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_1000","instance":1000,"id":204343,"goal":"lemma SetUnionCard_1000(S: set, U: set)\n requires S * U == {}\n ensures |S + U| == |S| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_1001","instance":1001,"id":204344,"goal":"lemma SetUnionComm_1001(A: set, T: set)\n ensures A + T == T + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_1002","instance":1002,"id":204345,"goal":"lemma SetInterComm_1002(S: set, U: set)\n ensures S * U == U * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_1003","instance":1003,"id":204346,"goal":"lemma SetUnionAssoc_1003(A: set, S: set, B: set)\n ensures (A + S) + B == A + (S + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_1004","instance":1004,"id":204347,"goal":"lemma SetSubsetRefl_1004(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_1005","instance":1005,"id":204348,"goal":"lemma SetSubsetTrans_1005(A: set, B: set, S: set)\n requires A <= B && B <= S\n ensures A <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_1006","instance":1006,"id":204349,"goal":"lemma SetUnionEmpty_1006(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_1007","instance":1007,"id":204350,"goal":"lemma SetInterEmpty_1007(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_1008","instance":1008,"id":204351,"goal":"lemma SetInterSubset_1008(A: set, B: set)\n ensures A * B <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_1009","instance":1009,"id":204352,"goal":"lemma SetCardSubset_1009(A: set, B: set)\n requires A <= B\n ensures |A| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_1010","instance":1010,"id":204353,"goal":"lemma SetUnionCard_1010(T: set, U: set)\n requires T * U == {}\n ensures |T + U| == |T| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_1011","instance":1011,"id":204354,"goal":"lemma SetUnionComm_1011(B: set, A: set)\n ensures B + A == A + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_1012","instance":1012,"id":204355,"goal":"lemma SetInterComm_1012(U: set, A: set)\n ensures U * A == A * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_1013","instance":1013,"id":204356,"goal":"lemma SetUnionAssoc_1013(S: set, A: set, B: set)\n ensures (S + A) + B == S + (A + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_1014","instance":1014,"id":204357,"goal":"lemma SetSubsetRefl_1014(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_1015","instance":1015,"id":204358,"goal":"lemma SetSubsetTrans_1015(B: set, A: set, S: set)\n requires B <= A && A <= S\n ensures B <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_1016","instance":1016,"id":204359,"goal":"lemma SetUnionEmpty_1016(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_1017","instance":1017,"id":204360,"goal":"lemma SetInterEmpty_1017(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_1018","instance":1018,"id":204361,"goal":"lemma SetInterSubset_1018(U: set, A: set)\n ensures U * A <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_1019","instance":1019,"id":204362,"goal":"lemma SetCardSubset_1019(B: set, A: set)\n requires B <= A\n ensures |B| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_1020","instance":1020,"id":204363,"goal":"lemma SetUnionCard_1020(B: set, S: set)\n requires B * S == {}\n ensures |B + S| == |B| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_1021","instance":1021,"id":204364,"goal":"lemma SetUnionComm_1021(T: set, U: set)\n ensures T + U == U + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_1022","instance":1022,"id":204365,"goal":"lemma SetInterComm_1022(B: set, U: set)\n ensures B * U == U * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_1023","instance":1023,"id":204366,"goal":"lemma SetUnionAssoc_1023(B: set, T: set, U: set)\n ensures (B + T) + U == B + (T + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_1024","instance":1024,"id":204367,"goal":"lemma SetSubsetRefl_1024(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_1025","instance":1025,"id":204368,"goal":"lemma SetSubsetTrans_1025(T: set, S: set, U: set)\n requires T <= S && S <= U\n ensures T <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_1026","instance":1026,"id":204369,"goal":"lemma SetUnionEmpty_1026(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_1027","instance":1027,"id":204370,"goal":"lemma SetInterEmpty_1027(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_1028","instance":1028,"id":204371,"goal":"lemma SetInterSubset_1028(S: set, T: set)\n ensures S * T <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_1029","instance":1029,"id":204372,"goal":"lemma SetCardSubset_1029(A: set, T: set)\n requires A <= T\n ensures |A| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_1030","instance":1030,"id":204373,"goal":"lemma SetUnionCard_1030(U: set, A: set)\n requires U * A == {}\n ensures |U + A| == |U| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_1031","instance":1031,"id":204374,"goal":"lemma SetUnionComm_1031(T: set, A: set)\n ensures T + A == A + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_1032","instance":1032,"id":204375,"goal":"lemma SetInterComm_1032(B: set, A: set)\n ensures B * A == A * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_1033","instance":1033,"id":204376,"goal":"lemma SetUnionAssoc_1033(T: set, U: set, S: set)\n ensures (T + U) + S == T + (U + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_1034","instance":1034,"id":204377,"goal":"lemma SetSubsetRefl_1034(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_1035","instance":1035,"id":204378,"goal":"lemma SetSubsetTrans_1035(A: set, S: set, U: set)\n requires A <= S && S <= U\n ensures A <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_1036","instance":1036,"id":204379,"goal":"lemma SetUnionEmpty_1036(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_1037","instance":1037,"id":204380,"goal":"lemma SetInterEmpty_1037(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_1038","instance":1038,"id":204381,"goal":"lemma SetInterSubset_1038(S: set, U: set)\n ensures S * U <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_1039","instance":1039,"id":204382,"goal":"lemma SetCardSubset_1039(A: set, B: set)\n requires A <= B\n ensures |A| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_1040","instance":1040,"id":204383,"goal":"lemma SetUnionCard_1040(S: set, U: set)\n requires S * U == {}\n ensures |S + U| == |S| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_1041","instance":1041,"id":204384,"goal":"lemma SetUnionComm_1041(U: set, B: set)\n ensures U + B == B + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_1042","instance":1042,"id":204385,"goal":"lemma SetInterComm_1042(T: set, A: set)\n ensures T * A == A * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_1043","instance":1043,"id":204386,"goal":"lemma SetUnionAssoc_1043(B: set, T: set, S: set)\n ensures (B + T) + S == B + (T + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_1044","instance":1044,"id":204387,"goal":"lemma SetSubsetRefl_1044(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_1045","instance":1045,"id":204388,"goal":"lemma SetSubsetTrans_1045(T: set, B: set, U: set)\n requires T <= B && B <= U\n ensures T <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_1046","instance":1046,"id":204389,"goal":"lemma SetUnionEmpty_1046(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_1047","instance":1047,"id":204390,"goal":"lemma SetInterEmpty_1047(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_1048","instance":1048,"id":204391,"goal":"lemma SetInterSubset_1048(A: set, T: set)\n ensures A * T <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_1049","instance":1049,"id":204392,"goal":"lemma SetCardSubset_1049(B: set, T: set)\n requires B <= T\n ensures |B| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_1050","instance":1050,"id":204393,"goal":"lemma SetUnionCard_1050(B: set, T: set)\n requires B * T == {}\n ensures |B + T| == |B| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_1051","instance":1051,"id":204394,"goal":"lemma SetUnionComm_1051(A: set, B: set)\n ensures A + B == B + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_1052","instance":1052,"id":204395,"goal":"lemma SetInterComm_1052(U: set, S: set)\n ensures U * S == S * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_1053","instance":1053,"id":204396,"goal":"lemma SetUnionAssoc_1053(T: set, B: set, U: set)\n ensures (T + B) + U == T + (B + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_1054","instance":1054,"id":204397,"goal":"lemma SetSubsetRefl_1054(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_1055","instance":1055,"id":204398,"goal":"lemma SetSubsetTrans_1055(S: set, T: set, B: set)\n requires S <= T && T <= B\n ensures S <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_1056","instance":1056,"id":204399,"goal":"lemma SetUnionEmpty_1056(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_1057","instance":1057,"id":204400,"goal":"lemma SetInterEmpty_1057(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_1058","instance":1058,"id":204401,"goal":"lemma SetInterSubset_1058(B: set, A: set)\n ensures B * A <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_1059","instance":1059,"id":204402,"goal":"lemma SetCardSubset_1059(T: set, U: set)\n requires T <= U\n ensures |T| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_1060","instance":1060,"id":204403,"goal":"lemma SetUnionCard_1060(T: set, S: set)\n requires T * S == {}\n ensures |T + S| == |T| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_1061","instance":1061,"id":204404,"goal":"lemma SetUnionComm_1061(T: set, S: set)\n ensures T + S == S + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_1062","instance":1062,"id":204405,"goal":"lemma SetInterComm_1062(U: set, S: set)\n ensures U * S == S * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_1063","instance":1063,"id":204406,"goal":"lemma SetUnionAssoc_1063(T: set, A: set, B: set)\n ensures (T + A) + B == T + (A + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_1064","instance":1064,"id":204407,"goal":"lemma SetSubsetRefl_1064(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_1065","instance":1065,"id":204408,"goal":"lemma SetSubsetTrans_1065(U: set, S: set, B: set)\n requires U <= S && S <= B\n ensures U <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_1066","instance":1066,"id":204409,"goal":"lemma SetUnionEmpty_1066(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_1067","instance":1067,"id":204410,"goal":"lemma SetInterEmpty_1067(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_1068","instance":1068,"id":204411,"goal":"lemma SetInterSubset_1068(S: set, A: set)\n ensures S * A <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_1069","instance":1069,"id":204412,"goal":"lemma SetCardSubset_1069(A: set, T: set)\n requires A <= T\n ensures |A| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_1070","instance":1070,"id":204413,"goal":"lemma SetUnionCard_1070(U: set, T: set)\n requires U * T == {}\n ensures |U + T| == |U| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_1071","instance":1071,"id":204414,"goal":"lemma SetUnionComm_1071(T: set, U: set)\n ensures T + U == U + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_1072","instance":1072,"id":204415,"goal":"lemma SetInterComm_1072(A: set, T: set)\n ensures A * T == T * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_1073","instance":1073,"id":204416,"goal":"lemma SetUnionAssoc_1073(B: set, A: set, U: set)\n ensures (B + A) + U == B + (A + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_1074","instance":1074,"id":204417,"goal":"lemma SetSubsetRefl_1074(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_1075","instance":1075,"id":204418,"goal":"lemma SetSubsetTrans_1075(T: set, A: set, S: set)\n requires T <= A && A <= S\n ensures T <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_1076","instance":1076,"id":204419,"goal":"lemma SetUnionEmpty_1076(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_1077","instance":1077,"id":204420,"goal":"lemma SetInterEmpty_1077(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_1078","instance":1078,"id":204421,"goal":"lemma SetInterSubset_1078(B: set, A: set)\n ensures B * A <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_1079","instance":1079,"id":204422,"goal":"lemma SetCardSubset_1079(B: set, T: set)\n requires B <= T\n ensures |B| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_1080","instance":1080,"id":204423,"goal":"lemma SetUnionCard_1080(S: set, A: set)\n requires S * A == {}\n ensures |S + A| == |S| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_1081","instance":1081,"id":204424,"goal":"lemma SetUnionComm_1081(A: set, U: set)\n ensures A + U == U + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_1082","instance":1082,"id":204425,"goal":"lemma SetInterComm_1082(S: set, B: set)\n ensures S * B == B * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_1083","instance":1083,"id":204426,"goal":"lemma SetUnionAssoc_1083(S: set, B: set, T: set)\n ensures (S + B) + T == S + (B + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_1084","instance":1084,"id":204427,"goal":"lemma SetSubsetRefl_1084(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_1085","instance":1085,"id":204428,"goal":"lemma SetSubsetTrans_1085(B: set, S: set, U: set)\n requires B <= S && S <= U\n ensures B <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_1086","instance":1086,"id":204429,"goal":"lemma SetUnionEmpty_1086(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_1087","instance":1087,"id":204430,"goal":"lemma SetInterEmpty_1087(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_1088","instance":1088,"id":204431,"goal":"lemma SetInterSubset_1088(S: set, T: set)\n ensures S * T <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_1089","instance":1089,"id":204432,"goal":"lemma SetCardSubset_1089(S: set, A: set)\n requires S <= A\n ensures |S| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_1090","instance":1090,"id":204433,"goal":"lemma SetUnionCard_1090(B: set, A: set)\n requires B * A == {}\n ensures |B + A| == |B| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_1091","instance":1091,"id":204434,"goal":"lemma SetUnionComm_1091(U: set, A: set)\n ensures U + A == A + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_1092","instance":1092,"id":204435,"goal":"lemma SetInterComm_1092(T: set, U: set)\n ensures T * U == U * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_1093","instance":1093,"id":204436,"goal":"lemma SetUnionAssoc_1093(S: set, U: set, B: set)\n ensures (S + U) + B == S + (U + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_1094","instance":1094,"id":204437,"goal":"lemma SetSubsetRefl_1094(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_1095","instance":1095,"id":204438,"goal":"lemma SetSubsetTrans_1095(S: set, T: set, A: set)\n requires S <= T && T <= A\n ensures S <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_1096","instance":1096,"id":204439,"goal":"lemma SetUnionEmpty_1096(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_1097","instance":1097,"id":204440,"goal":"lemma SetInterEmpty_1097(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_1098","instance":1098,"id":204441,"goal":"lemma SetInterSubset_1098(S: set, T: set)\n ensures S * T <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_1099","instance":1099,"id":204442,"goal":"lemma SetCardSubset_1099(B: set, U: set)\n requires B <= U\n ensures |B| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_1100","instance":1100,"id":204443,"goal":"lemma SetUnionCard_1100(S: set, A: set)\n requires S * A == {}\n ensures |S + A| == |S| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_1101","instance":1101,"id":204444,"goal":"lemma SetUnionComm_1101(S: set, T: set)\n ensures S + T == T + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_1102","instance":1102,"id":204445,"goal":"lemma SetInterComm_1102(S: set, U: set)\n ensures S * U == U * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_1103","instance":1103,"id":204446,"goal":"lemma SetUnionAssoc_1103(U: set, B: set, S: set)\n ensures (U + B) + S == U + (B + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_1104","instance":1104,"id":204447,"goal":"lemma SetSubsetRefl_1104(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_1105","instance":1105,"id":204448,"goal":"lemma SetSubsetTrans_1105(T: set, U: set, A: set)\n requires T <= U && U <= A\n ensures T <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_1106","instance":1106,"id":204449,"goal":"lemma SetUnionEmpty_1106(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_1107","instance":1107,"id":204450,"goal":"lemma SetInterEmpty_1107(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_1108","instance":1108,"id":204451,"goal":"lemma SetInterSubset_1108(U: set, B: set)\n ensures U * B <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_1109","instance":1109,"id":204452,"goal":"lemma SetCardSubset_1109(B: set, A: set)\n requires B <= A\n ensures |B| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_1110","instance":1110,"id":204453,"goal":"lemma SetUnionCard_1110(S: set, A: set)\n requires S * A == {}\n ensures |S + A| == |S| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_1111","instance":1111,"id":204454,"goal":"lemma SetUnionComm_1111(A: set, U: set)\n ensures A + U == U + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_1112","instance":1112,"id":204455,"goal":"lemma SetInterComm_1112(S: set, T: set)\n ensures S * T == T * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_1113","instance":1113,"id":204456,"goal":"lemma SetUnionAssoc_1113(S: set, B: set, T: set)\n ensures (S + B) + T == S + (B + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_1114","instance":1114,"id":204457,"goal":"lemma SetSubsetRefl_1114(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_1115","instance":1115,"id":204458,"goal":"lemma SetSubsetTrans_1115(B: set, U: set, S: set)\n requires B <= U && U <= S\n ensures B <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_1116","instance":1116,"id":204459,"goal":"lemma SetUnionEmpty_1116(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_1117","instance":1117,"id":204460,"goal":"lemma SetInterEmpty_1117(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_1118","instance":1118,"id":204461,"goal":"lemma SetInterSubset_1118(B: set, T: set)\n ensures B * T <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_1119","instance":1119,"id":204462,"goal":"lemma SetCardSubset_1119(U: set, B: set)\n requires U <= B\n ensures |U| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_1120","instance":1120,"id":204463,"goal":"lemma SetUnionCard_1120(A: set, S: set)\n requires A * S == {}\n ensures |A + S| == |A| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_1121","instance":1121,"id":204464,"goal":"lemma SetUnionComm_1121(B: set, T: set)\n ensures B + T == T + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_1122","instance":1122,"id":204465,"goal":"lemma SetInterComm_1122(U: set, A: set)\n ensures U * A == A * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_1123","instance":1123,"id":204466,"goal":"lemma SetUnionAssoc_1123(S: set, A: set, U: set)\n ensures (S + A) + U == S + (A + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_1124","instance":1124,"id":204467,"goal":"lemma SetSubsetRefl_1124(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_1125","instance":1125,"id":204468,"goal":"lemma SetSubsetTrans_1125(T: set, B: set, U: set)\n requires T <= B && B <= U\n ensures T <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_1126","instance":1126,"id":204469,"goal":"lemma SetUnionEmpty_1126(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_1127","instance":1127,"id":204470,"goal":"lemma SetInterEmpty_1127(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_1128","instance":1128,"id":204471,"goal":"lemma SetInterSubset_1128(T: set, U: set)\n ensures T * U <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_1129","instance":1129,"id":204472,"goal":"lemma SetCardSubset_1129(B: set, A: set)\n requires B <= A\n ensures |B| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_1130","instance":1130,"id":204473,"goal":"lemma SetUnionCard_1130(B: set, U: set)\n requires B * U == {}\n ensures |B + U| == |B| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_1131","instance":1131,"id":204474,"goal":"lemma SetUnionComm_1131(T: set, A: set)\n ensures T + A == A + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_1132","instance":1132,"id":204475,"goal":"lemma SetInterComm_1132(S: set, U: set)\n ensures S * U == U * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_1133","instance":1133,"id":204476,"goal":"lemma SetUnionAssoc_1133(A: set, S: set, B: set)\n ensures (A + S) + B == A + (S + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_1134","instance":1134,"id":204477,"goal":"lemma SetSubsetRefl_1134(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_1135","instance":1135,"id":204478,"goal":"lemma SetSubsetTrans_1135(B: set, U: set, T: set)\n requires B <= U && U <= T\n ensures B <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_1136","instance":1136,"id":204479,"goal":"lemma SetUnionEmpty_1136(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_1137","instance":1137,"id":204480,"goal":"lemma SetInterEmpty_1137(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_1138","instance":1138,"id":204481,"goal":"lemma SetInterSubset_1138(T: set, B: set)\n ensures T * B <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_1139","instance":1139,"id":204482,"goal":"lemma SetCardSubset_1139(A: set, B: set)\n requires A <= B\n ensures |A| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_1140","instance":1140,"id":204483,"goal":"lemma SetUnionCard_1140(T: set, U: set)\n requires T * U == {}\n ensures |T + U| == |T| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_1141","instance":1141,"id":204484,"goal":"lemma SetUnionComm_1141(A: set, B: set)\n ensures A + B == B + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_1142","instance":1142,"id":204485,"goal":"lemma SetInterComm_1142(T: set, S: set)\n ensures T * S == S * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_1143","instance":1143,"id":204486,"goal":"lemma SetUnionAssoc_1143(T: set, B: set, A: set)\n ensures (T + B) + A == T + (B + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_1144","instance":1144,"id":204487,"goal":"lemma SetSubsetRefl_1144(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_1145","instance":1145,"id":204488,"goal":"lemma SetSubsetTrans_1145(A: set, S: set, T: set)\n requires A <= S && S <= T\n ensures A <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_1146","instance":1146,"id":204489,"goal":"lemma SetUnionEmpty_1146(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_1147","instance":1147,"id":204490,"goal":"lemma SetInterEmpty_1147(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_1148","instance":1148,"id":204491,"goal":"lemma SetInterSubset_1148(A: set, T: set)\n ensures A * T <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_1149","instance":1149,"id":204492,"goal":"lemma SetCardSubset_1149(B: set, S: set)\n requires B <= S\n ensures |B| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_1150","instance":1150,"id":204493,"goal":"lemma SetUnionCard_1150(B: set, S: set)\n requires B * S == {}\n ensures |B + S| == |B| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_1151","instance":1151,"id":204494,"goal":"lemma SetUnionComm_1151(U: set, S: set)\n ensures U + S == S + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_1152","instance":1152,"id":204495,"goal":"lemma SetInterComm_1152(U: set, B: set)\n ensures U * B == B * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_1153","instance":1153,"id":204496,"goal":"lemma SetUnionAssoc_1153(T: set, U: set, S: set)\n ensures (T + U) + S == T + (U + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_1154","instance":1154,"id":204497,"goal":"lemma SetSubsetRefl_1154(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_1155","instance":1155,"id":204498,"goal":"lemma SetSubsetTrans_1155(A: set, U: set, B: set)\n requires A <= U && U <= B\n ensures A <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_1156","instance":1156,"id":204499,"goal":"lemma SetUnionEmpty_1156(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_1157","instance":1157,"id":204500,"goal":"lemma SetInterEmpty_1157(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_1158","instance":1158,"id":204501,"goal":"lemma SetInterSubset_1158(S: set, T: set)\n ensures S * T <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_1159","instance":1159,"id":204502,"goal":"lemma SetCardSubset_1159(A: set, T: set)\n requires A <= T\n ensures |A| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_1160","instance":1160,"id":204503,"goal":"lemma SetUnionCard_1160(B: set, A: set)\n requires B * A == {}\n ensures |B + A| == |B| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_1161","instance":1161,"id":204504,"goal":"lemma SetUnionComm_1161(A: set, T: set)\n ensures A + T == T + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_1162","instance":1162,"id":204505,"goal":"lemma SetInterComm_1162(B: set, U: set)\n ensures B * U == U * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_1163","instance":1163,"id":204506,"goal":"lemma SetUnionAssoc_1163(U: set, S: set, A: set)\n ensures (U + S) + A == U + (S + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_1164","instance":1164,"id":204507,"goal":"lemma SetSubsetRefl_1164(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_1165","instance":1165,"id":204508,"goal":"lemma SetSubsetTrans_1165(S: set, B: set, U: set)\n requires S <= B && B <= U\n ensures S <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_1166","instance":1166,"id":204509,"goal":"lemma SetUnionEmpty_1166(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_1167","instance":1167,"id":204510,"goal":"lemma SetInterEmpty_1167(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_1168","instance":1168,"id":204511,"goal":"lemma SetInterSubset_1168(S: set, A: set)\n ensures S * A <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_1169","instance":1169,"id":204512,"goal":"lemma SetCardSubset_1169(T: set, U: set)\n requires T <= U\n ensures |T| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_1170","instance":1170,"id":204513,"goal":"lemma SetUnionCard_1170(T: set, A: set)\n requires T * A == {}\n ensures |T + A| == |T| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_1171","instance":1171,"id":204514,"goal":"lemma SetUnionComm_1171(T: set, U: set)\n ensures T + U == U + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_1172","instance":1172,"id":204515,"goal":"lemma SetInterComm_1172(B: set, T: set)\n ensures B * T == T * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_1173","instance":1173,"id":204516,"goal":"lemma SetUnionAssoc_1173(U: set, T: set, S: set)\n ensures (U + T) + S == U + (T + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_1174","instance":1174,"id":204517,"goal":"lemma SetSubsetRefl_1174(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_1175","instance":1175,"id":204518,"goal":"lemma SetSubsetTrans_1175(B: set, U: set, A: set)\n requires B <= U && U <= A\n ensures B <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_1176","instance":1176,"id":204519,"goal":"lemma SetUnionEmpty_1176(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_1177","instance":1177,"id":204520,"goal":"lemma SetInterEmpty_1177(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_1178","instance":1178,"id":204521,"goal":"lemma SetInterSubset_1178(T: set, B: set)\n ensures T * B <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_1179","instance":1179,"id":204522,"goal":"lemma SetCardSubset_1179(B: set, U: set)\n requires B <= U\n ensures |B| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_1180","instance":1180,"id":204523,"goal":"lemma SetUnionCard_1180(S: set, A: set)\n requires S * A == {}\n ensures |S + A| == |S| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_1181","instance":1181,"id":204524,"goal":"lemma SetUnionComm_1181(A: set, B: set)\n ensures A + B == B + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_1182","instance":1182,"id":204525,"goal":"lemma SetInterComm_1182(T: set, U: set)\n ensures T * U == U * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_1183","instance":1183,"id":204526,"goal":"lemma SetUnionAssoc_1183(B: set, S: set, U: set)\n ensures (B + S) + U == B + (S + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_1184","instance":1184,"id":204527,"goal":"lemma SetSubsetRefl_1184(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_1185","instance":1185,"id":204528,"goal":"lemma SetSubsetTrans_1185(S: set, A: set, B: set)\n requires S <= A && A <= B\n ensures S <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_1186","instance":1186,"id":204529,"goal":"lemma SetUnionEmpty_1186(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_1187","instance":1187,"id":204530,"goal":"lemma SetInterEmpty_1187(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_1188","instance":1188,"id":204531,"goal":"lemma SetInterSubset_1188(S: set, T: set)\n ensures S * T <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_1189","instance":1189,"id":204532,"goal":"lemma SetCardSubset_1189(A: set, U: set)\n requires A <= U\n ensures |A| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_1190","instance":1190,"id":204533,"goal":"lemma SetUnionCard_1190(B: set, A: set)\n requires B * A == {}\n ensures |B + A| == |B| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_1191","instance":1191,"id":204534,"goal":"lemma SetUnionComm_1191(U: set, B: set)\n ensures U + B == B + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_1192","instance":1192,"id":204535,"goal":"lemma SetInterComm_1192(U: set, S: set)\n ensures U * S == S * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_1193","instance":1193,"id":204536,"goal":"lemma SetUnionAssoc_1193(S: set, T: set, A: set)\n ensures (S + T) + A == S + (T + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_1194","instance":1194,"id":204537,"goal":"lemma SetSubsetRefl_1194(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_1195","instance":1195,"id":204538,"goal":"lemma SetSubsetTrans_1195(A: set, S: set, B: set)\n requires A <= S && S <= B\n ensures A <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_1196","instance":1196,"id":204539,"goal":"lemma SetUnionEmpty_1196(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_1197","instance":1197,"id":204540,"goal":"lemma SetInterEmpty_1197(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_1198","instance":1198,"id":204541,"goal":"lemma SetInterSubset_1198(S: set, U: set)\n ensures S * U <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_1199","instance":1199,"id":204542,"goal":"lemma SetCardSubset_1199(S: set, T: set)\n requires S <= T\n ensures |S| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_1200","instance":1200,"id":204543,"goal":"lemma SetUnionCard_1200(T: set, U: set)\n requires T * U == {}\n ensures |T + U| == |T| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_1201","instance":1201,"id":204544,"goal":"lemma SetUnionComm_1201(A: set, B: set)\n ensures A + B == B + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_1202","instance":1202,"id":204545,"goal":"lemma SetInterComm_1202(A: set, T: set)\n ensures A * T == T * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_1203","instance":1203,"id":204546,"goal":"lemma SetUnionAssoc_1203(T: set, S: set, B: set)\n ensures (T + S) + B == T + (S + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_1204","instance":1204,"id":204547,"goal":"lemma SetSubsetRefl_1204(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_1205","instance":1205,"id":204548,"goal":"lemma SetSubsetTrans_1205(S: set, U: set, T: set)\n requires S <= U && U <= T\n ensures S <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_1206","instance":1206,"id":204549,"goal":"lemma SetUnionEmpty_1206(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_1207","instance":1207,"id":204550,"goal":"lemma SetInterEmpty_1207(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_1208","instance":1208,"id":204551,"goal":"lemma SetInterSubset_1208(T: set, B: set)\n ensures T * B <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_1209","instance":1209,"id":204552,"goal":"lemma SetCardSubset_1209(T: set, S: set)\n requires T <= S\n ensures |T| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_1210","instance":1210,"id":204553,"goal":"lemma SetUnionCard_1210(B: set, U: set)\n requires B * U == {}\n ensures |B + U| == |B| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_1211","instance":1211,"id":204554,"goal":"lemma SetUnionComm_1211(T: set, S: set)\n ensures T + S == S + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_1212","instance":1212,"id":204555,"goal":"lemma SetInterComm_1212(T: set, B: set)\n ensures T * B == B * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_1213","instance":1213,"id":204556,"goal":"lemma SetUnionAssoc_1213(S: set, A: set, T: set)\n ensures (S + A) + T == S + (A + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_1214","instance":1214,"id":204557,"goal":"lemma SetSubsetRefl_1214(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_1215","instance":1215,"id":204558,"goal":"lemma SetSubsetTrans_1215(T: set, A: set, S: set)\n requires T <= A && A <= S\n ensures T <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_1216","instance":1216,"id":204559,"goal":"lemma SetUnionEmpty_1216(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_1217","instance":1217,"id":204560,"goal":"lemma SetInterEmpty_1217(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_1218","instance":1218,"id":204561,"goal":"lemma SetInterSubset_1218(A: set, U: set)\n ensures A * U <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_1219","instance":1219,"id":204562,"goal":"lemma SetCardSubset_1219(T: set, A: set)\n requires T <= A\n ensures |T| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_1220","instance":1220,"id":204563,"goal":"lemma SetUnionCard_1220(S: set, B: set)\n requires S * B == {}\n ensures |S + B| == |S| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_1221","instance":1221,"id":204564,"goal":"lemma SetUnionComm_1221(U: set, T: set)\n ensures U + T == T + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_1222","instance":1222,"id":204565,"goal":"lemma SetInterComm_1222(T: set, A: set)\n ensures T * A == A * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_1223","instance":1223,"id":204566,"goal":"lemma SetUnionAssoc_1223(B: set, U: set, T: set)\n ensures (B + U) + T == B + (U + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_1224","instance":1224,"id":204567,"goal":"lemma SetSubsetRefl_1224(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_1225","instance":1225,"id":204568,"goal":"lemma SetSubsetTrans_1225(U: set, S: set, T: set)\n requires U <= S && S <= T\n ensures U <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_1226","instance":1226,"id":204569,"goal":"lemma SetUnionEmpty_1226(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_1227","instance":1227,"id":204570,"goal":"lemma SetInterEmpty_1227(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_1228","instance":1228,"id":204571,"goal":"lemma SetInterSubset_1228(T: set, U: set)\n ensures T * U <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_1229","instance":1229,"id":204572,"goal":"lemma SetCardSubset_1229(S: set, B: set)\n requires S <= B\n ensures |S| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_1230","instance":1230,"id":204573,"goal":"lemma SetUnionCard_1230(T: set, A: set)\n requires T * A == {}\n ensures |T + A| == |T| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_1231","instance":1231,"id":204574,"goal":"lemma SetUnionComm_1231(U: set, A: set)\n ensures U + A == A + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_1232","instance":1232,"id":204575,"goal":"lemma SetInterComm_1232(A: set, S: set)\n ensures A * S == S * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_1233","instance":1233,"id":204576,"goal":"lemma SetUnionAssoc_1233(U: set, A: set, T: set)\n ensures (U + A) + T == U + (A + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_1234","instance":1234,"id":204577,"goal":"lemma SetSubsetRefl_1234(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_1235","instance":1235,"id":204578,"goal":"lemma SetSubsetTrans_1235(T: set, B: set, U: set)\n requires T <= B && B <= U\n ensures T <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_1236","instance":1236,"id":204579,"goal":"lemma SetUnionEmpty_1236(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_1237","instance":1237,"id":204580,"goal":"lemma SetInterEmpty_1237(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_1238","instance":1238,"id":204581,"goal":"lemma SetInterSubset_1238(T: set, S: set)\n ensures T * S <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_1239","instance":1239,"id":204582,"goal":"lemma SetCardSubset_1239(A: set, B: set)\n requires A <= B\n ensures |A| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_1240","instance":1240,"id":204583,"goal":"lemma SetUnionCard_1240(U: set, A: set)\n requires U * A == {}\n ensures |U + A| == |U| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_1241","instance":1241,"id":204584,"goal":"lemma SetUnionComm_1241(T: set, B: set)\n ensures T + B == B + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_1242","instance":1242,"id":204585,"goal":"lemma SetInterComm_1242(S: set, A: set)\n ensures S * A == A * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_1243","instance":1243,"id":204586,"goal":"lemma SetUnionAssoc_1243(B: set, S: set, T: set)\n ensures (B + S) + T == B + (S + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_1244","instance":1244,"id":204587,"goal":"lemma SetSubsetRefl_1244(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_1245","instance":1245,"id":204588,"goal":"lemma SetSubsetTrans_1245(B: set, A: set, U: set)\n requires B <= A && A <= U\n ensures B <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_1246","instance":1246,"id":204589,"goal":"lemma SetUnionEmpty_1246(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_1247","instance":1247,"id":204590,"goal":"lemma SetInterEmpty_1247(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_1248","instance":1248,"id":204591,"goal":"lemma SetInterSubset_1248(A: set, U: set)\n ensures A * U <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_1249","instance":1249,"id":204592,"goal":"lemma SetCardSubset_1249(S: set, U: set)\n requires S <= U\n ensures |S| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_1250","instance":1250,"id":204593,"goal":"lemma SetUnionCard_1250(S: set, A: set)\n requires S * A == {}\n ensures |S + A| == |S| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_1251","instance":1251,"id":204594,"goal":"lemma SetUnionComm_1251(T: set, U: set)\n ensures T + U == U + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_1252","instance":1252,"id":204595,"goal":"lemma SetInterComm_1252(S: set, T: set)\n ensures S * T == T * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_1253","instance":1253,"id":204596,"goal":"lemma SetUnionAssoc_1253(A: set, T: set, S: set)\n ensures (A + T) + S == A + (T + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_1254","instance":1254,"id":204597,"goal":"lemma SetSubsetRefl_1254(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_1255","instance":1255,"id":204598,"goal":"lemma SetSubsetTrans_1255(B: set, A: set, U: set)\n requires B <= A && A <= U\n ensures B <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_1256","instance":1256,"id":204599,"goal":"lemma SetUnionEmpty_1256(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_1257","instance":1257,"id":204600,"goal":"lemma SetInterEmpty_1257(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_1258","instance":1258,"id":204601,"goal":"lemma SetInterSubset_1258(T: set, A: set)\n ensures T * A <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_1259","instance":1259,"id":204602,"goal":"lemma SetCardSubset_1259(B: set, T: set)\n requires B <= T\n ensures |B| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_1260","instance":1260,"id":204603,"goal":"lemma SetUnionCard_1260(S: set, U: set)\n requires S * U == {}\n ensures |S + U| == |S| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_1261","instance":1261,"id":204604,"goal":"lemma SetUnionComm_1261(U: set, A: set)\n ensures U + A == A + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_1262","instance":1262,"id":204605,"goal":"lemma SetInterComm_1262(U: set, B: set)\n ensures U * B == B * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_1263","instance":1263,"id":204606,"goal":"lemma SetUnionAssoc_1263(U: set, T: set, S: set)\n ensures (U + T) + S == U + (T + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_1264","instance":1264,"id":204607,"goal":"lemma SetSubsetRefl_1264(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_1265","instance":1265,"id":204608,"goal":"lemma SetSubsetTrans_1265(S: set, A: set, U: set)\n requires S <= A && A <= U\n ensures S <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_1266","instance":1266,"id":204609,"goal":"lemma SetUnionEmpty_1266(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_1267","instance":1267,"id":204610,"goal":"lemma SetInterEmpty_1267(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_1268","instance":1268,"id":204611,"goal":"lemma SetInterSubset_1268(B: set, A: set)\n ensures B * A <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_1269","instance":1269,"id":204612,"goal":"lemma SetCardSubset_1269(A: set, T: set)\n requires A <= T\n ensures |A| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_1270","instance":1270,"id":204613,"goal":"lemma SetUnionCard_1270(B: set, T: set)\n requires B * T == {}\n ensures |B + T| == |B| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_1271","instance":1271,"id":204614,"goal":"lemma SetUnionComm_1271(U: set, S: set)\n ensures U + S == S + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_1272","instance":1272,"id":204615,"goal":"lemma SetInterComm_1272(B: set, T: set)\n ensures B * T == T * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_1273","instance":1273,"id":204616,"goal":"lemma SetUnionAssoc_1273(A: set, S: set, T: set)\n ensures (A + S) + T == A + (S + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_1274","instance":1274,"id":204617,"goal":"lemma SetSubsetRefl_1274(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_1275","instance":1275,"id":204618,"goal":"lemma SetSubsetTrans_1275(U: set, B: set, T: set)\n requires U <= B && B <= T\n ensures U <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_1276","instance":1276,"id":204619,"goal":"lemma SetUnionEmpty_1276(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_1277","instance":1277,"id":204620,"goal":"lemma SetInterEmpty_1277(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_1278","instance":1278,"id":204621,"goal":"lemma SetInterSubset_1278(A: set, B: set)\n ensures A * B <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_1279","instance":1279,"id":204622,"goal":"lemma SetCardSubset_1279(U: set, A: set)\n requires U <= A\n ensures |U| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_1280","instance":1280,"id":204623,"goal":"lemma SetUnionCard_1280(T: set, S: set)\n requires T * S == {}\n ensures |T + S| == |T| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_1281","instance":1281,"id":204624,"goal":"lemma SetUnionComm_1281(A: set, T: set)\n ensures A + T == T + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_1282","instance":1282,"id":204625,"goal":"lemma SetInterComm_1282(S: set, B: set)\n ensures S * B == B * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_1283","instance":1283,"id":204626,"goal":"lemma SetUnionAssoc_1283(S: set, A: set, T: set)\n ensures (S + A) + T == S + (A + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_1284","instance":1284,"id":204627,"goal":"lemma SetSubsetRefl_1284(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_1285","instance":1285,"id":204628,"goal":"lemma SetSubsetTrans_1285(A: set, S: set, U: set)\n requires A <= S && S <= U\n ensures A <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_1286","instance":1286,"id":204629,"goal":"lemma SetUnionEmpty_1286(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_1287","instance":1287,"id":204630,"goal":"lemma SetInterEmpty_1287(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_1288","instance":1288,"id":204631,"goal":"lemma SetInterSubset_1288(S: set, B: set)\n ensures S * B <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_1289","instance":1289,"id":204632,"goal":"lemma SetCardSubset_1289(U: set, B: set)\n requires U <= B\n ensures |U| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_1290","instance":1290,"id":204633,"goal":"lemma SetUnionCard_1290(B: set, S: set)\n requires B * S == {}\n ensures |B + S| == |B| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_1291","instance":1291,"id":204634,"goal":"lemma SetUnionComm_1291(T: set, S: set)\n ensures T + S == S + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_1292","instance":1292,"id":204635,"goal":"lemma SetInterComm_1292(B: set, A: set)\n ensures B * A == A * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_1293","instance":1293,"id":204636,"goal":"lemma SetUnionAssoc_1293(B: set, A: set, S: set)\n ensures (B + A) + S == B + (A + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_1294","instance":1294,"id":204637,"goal":"lemma SetSubsetRefl_1294(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_1295","instance":1295,"id":204638,"goal":"lemma SetSubsetTrans_1295(U: set, A: set, S: set)\n requires U <= A && A <= S\n ensures U <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_1296","instance":1296,"id":204639,"goal":"lemma SetUnionEmpty_1296(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_1297","instance":1297,"id":204640,"goal":"lemma SetInterEmpty_1297(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_1298","instance":1298,"id":204641,"goal":"lemma SetInterSubset_1298(S: set, T: set)\n ensures S * T <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_1299","instance":1299,"id":204642,"goal":"lemma SetCardSubset_1299(T: set, A: set)\n requires T <= A\n ensures |T| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_1300","instance":1300,"id":204643,"goal":"lemma SetUnionCard_1300(S: set, T: set)\n requires S * T == {}\n ensures |S + T| == |S| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_1301","instance":1301,"id":204644,"goal":"lemma SetUnionComm_1301(T: set, B: set)\n ensures T + B == B + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_1302","instance":1302,"id":204645,"goal":"lemma SetInterComm_1302(A: set, T: set)\n ensures A * T == T * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_1303","instance":1303,"id":204646,"goal":"lemma SetUnionAssoc_1303(A: set, T: set, B: set)\n ensures (A + T) + B == A + (T + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_1304","instance":1304,"id":204647,"goal":"lemma SetSubsetRefl_1304(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_1305","instance":1305,"id":204648,"goal":"lemma SetSubsetTrans_1305(S: set, U: set, A: set)\n requires S <= U && U <= A\n ensures S <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_1306","instance":1306,"id":204649,"goal":"lemma SetUnionEmpty_1306(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_1307","instance":1307,"id":204650,"goal":"lemma SetInterEmpty_1307(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_1308","instance":1308,"id":204651,"goal":"lemma SetInterSubset_1308(S: set, U: set)\n ensures S * U <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_1309","instance":1309,"id":204652,"goal":"lemma SetCardSubset_1309(A: set, B: set)\n requires A <= B\n ensures |A| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_1310","instance":1310,"id":204653,"goal":"lemma SetUnionCard_1310(T: set, A: set)\n requires T * A == {}\n ensures |T + A| == |T| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_1311","instance":1311,"id":204654,"goal":"lemma SetUnionComm_1311(S: set, U: set)\n ensures S + U == U + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_1312","instance":1312,"id":204655,"goal":"lemma SetInterComm_1312(B: set, T: set)\n ensures B * T == T * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_1313","instance":1313,"id":204656,"goal":"lemma SetUnionAssoc_1313(B: set, S: set, T: set)\n ensures (B + S) + T == B + (S + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_1314","instance":1314,"id":204657,"goal":"lemma SetSubsetRefl_1314(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_1315","instance":1315,"id":204658,"goal":"lemma SetSubsetTrans_1315(S: set, A: set, T: set)\n requires S <= A && A <= T\n ensures S <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_1316","instance":1316,"id":204659,"goal":"lemma SetUnionEmpty_1316(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_1317","instance":1317,"id":204660,"goal":"lemma SetInterEmpty_1317(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_1318","instance":1318,"id":204661,"goal":"lemma SetInterSubset_1318(A: set, B: set)\n ensures A * B <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_1319","instance":1319,"id":204662,"goal":"lemma SetCardSubset_1319(U: set, T: set)\n requires U <= T\n ensures |U| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_1320","instance":1320,"id":204663,"goal":"lemma SetUnionCard_1320(S: set, B: set)\n requires S * B == {}\n ensures |S + B| == |S| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_1321","instance":1321,"id":204664,"goal":"lemma SetUnionComm_1321(B: set, A: set)\n ensures B + A == A + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_1322","instance":1322,"id":204665,"goal":"lemma SetInterComm_1322(A: set, U: set)\n ensures A * U == U * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_1323","instance":1323,"id":204666,"goal":"lemma SetUnionAssoc_1323(A: set, S: set, T: set)\n ensures (A + S) + T == A + (S + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_1324","instance":1324,"id":204667,"goal":"lemma SetSubsetRefl_1324(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_1325","instance":1325,"id":204668,"goal":"lemma SetSubsetTrans_1325(T: set, A: set, U: set)\n requires T <= A && A <= U\n ensures T <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_1326","instance":1326,"id":204669,"goal":"lemma SetUnionEmpty_1326(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_1327","instance":1327,"id":204670,"goal":"lemma SetInterEmpty_1327(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_1328","instance":1328,"id":204671,"goal":"lemma SetInterSubset_1328(B: set, S: set)\n ensures B * S <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_1329","instance":1329,"id":204672,"goal":"lemma SetCardSubset_1329(U: set, B: set)\n requires U <= B\n ensures |U| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_1330","instance":1330,"id":204673,"goal":"lemma SetUnionCard_1330(S: set, T: set)\n requires S * T == {}\n ensures |S + T| == |S| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_1331","instance":1331,"id":204674,"goal":"lemma SetUnionComm_1331(T: set, A: set)\n ensures T + A == A + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_1332","instance":1332,"id":204675,"goal":"lemma SetInterComm_1332(S: set, U: set)\n ensures S * U == U * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_1333","instance":1333,"id":204676,"goal":"lemma SetUnionAssoc_1333(A: set, T: set, S: set)\n ensures (A + T) + S == A + (T + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_1334","instance":1334,"id":204677,"goal":"lemma SetSubsetRefl_1334(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_1335","instance":1335,"id":204678,"goal":"lemma SetSubsetTrans_1335(S: set, U: set, B: set)\n requires S <= U && U <= B\n ensures S <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_1336","instance":1336,"id":204679,"goal":"lemma SetUnionEmpty_1336(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_1337","instance":1337,"id":204680,"goal":"lemma SetInterEmpty_1337(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_1338","instance":1338,"id":204681,"goal":"lemma SetInterSubset_1338(B: set, T: set)\n ensures B * T <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_1339","instance":1339,"id":204682,"goal":"lemma SetCardSubset_1339(S: set, U: set)\n requires S <= U\n ensures |S| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_1340","instance":1340,"id":204683,"goal":"lemma SetUnionCard_1340(U: set, S: set)\n requires U * S == {}\n ensures |U + S| == |U| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_1341","instance":1341,"id":204684,"goal":"lemma SetUnionComm_1341(A: set, U: set)\n ensures A + U == U + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_1342","instance":1342,"id":204685,"goal":"lemma SetInterComm_1342(B: set, S: set)\n ensures B * S == S * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_1343","instance":1343,"id":204686,"goal":"lemma SetUnionAssoc_1343(T: set, U: set, A: set)\n ensures (T + U) + A == T + (U + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_1344","instance":1344,"id":204687,"goal":"lemma SetSubsetRefl_1344(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_1345","instance":1345,"id":204688,"goal":"lemma SetSubsetTrans_1345(B: set, T: set, U: set)\n requires B <= T && T <= U\n ensures B <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_1346","instance":1346,"id":204689,"goal":"lemma SetUnionEmpty_1346(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_1347","instance":1347,"id":204690,"goal":"lemma SetInterEmpty_1347(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_1348","instance":1348,"id":204691,"goal":"lemma SetInterSubset_1348(B: set, S: set)\n ensures B * S <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_1349","instance":1349,"id":204692,"goal":"lemma SetCardSubset_1349(U: set, B: set)\n requires U <= B\n ensures |U| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_1350","instance":1350,"id":204693,"goal":"lemma SetUnionCard_1350(A: set, S: set)\n requires A * S == {}\n ensures |A + S| == |A| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_1351","instance":1351,"id":204694,"goal":"lemma SetUnionComm_1351(T: set, B: set)\n ensures T + B == B + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_1352","instance":1352,"id":204695,"goal":"lemma SetInterComm_1352(S: set, B: set)\n ensures S * B == B * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_1353","instance":1353,"id":204696,"goal":"lemma SetUnionAssoc_1353(U: set, T: set, B: set)\n ensures (U + T) + B == U + (T + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_1354","instance":1354,"id":204697,"goal":"lemma SetSubsetRefl_1354(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_1355","instance":1355,"id":204698,"goal":"lemma SetSubsetTrans_1355(T: set, S: set, A: set)\n requires T <= S && S <= A\n ensures T <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_1356","instance":1356,"id":204699,"goal":"lemma SetUnionEmpty_1356(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_1357","instance":1357,"id":204700,"goal":"lemma SetInterEmpty_1357(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_1358","instance":1358,"id":204701,"goal":"lemma SetInterSubset_1358(B: set, T: set)\n ensures B * T <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_1359","instance":1359,"id":204702,"goal":"lemma SetCardSubset_1359(U: set, S: set)\n requires U <= S\n ensures |U| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_1360","instance":1360,"id":204703,"goal":"lemma SetUnionCard_1360(S: set, A: set)\n requires S * A == {}\n ensures |S + A| == |S| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_1361","instance":1361,"id":204704,"goal":"lemma SetUnionComm_1361(U: set, A: set)\n ensures U + A == A + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_1362","instance":1362,"id":204705,"goal":"lemma SetInterComm_1362(S: set, U: set)\n ensures S * U == U * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_1363","instance":1363,"id":204706,"goal":"lemma SetUnionAssoc_1363(U: set, B: set, A: set)\n ensures (U + B) + A == U + (B + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_1364","instance":1364,"id":204707,"goal":"lemma SetSubsetRefl_1364(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_1365","instance":1365,"id":204708,"goal":"lemma SetSubsetTrans_1365(T: set, A: set, B: set)\n requires T <= A && A <= B\n ensures T <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_1366","instance":1366,"id":204709,"goal":"lemma SetUnionEmpty_1366(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_1367","instance":1367,"id":204710,"goal":"lemma SetInterEmpty_1367(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_1368","instance":1368,"id":204711,"goal":"lemma SetInterSubset_1368(T: set, B: set)\n ensures T * B <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_1369","instance":1369,"id":204712,"goal":"lemma SetCardSubset_1369(S: set, T: set)\n requires S <= T\n ensures |S| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_1370","instance":1370,"id":204713,"goal":"lemma SetUnionCard_1370(T: set, A: set)\n requires T * A == {}\n ensures |T + A| == |T| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_1371","instance":1371,"id":204714,"goal":"lemma SetUnionComm_1371(T: set, U: set)\n ensures T + U == U + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_1372","instance":1372,"id":204715,"goal":"lemma SetInterComm_1372(U: set, T: set)\n ensures U * T == T * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_1373","instance":1373,"id":204716,"goal":"lemma SetUnionAssoc_1373(T: set, A: set, S: set)\n ensures (T + A) + S == T + (A + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_1374","instance":1374,"id":204717,"goal":"lemma SetSubsetRefl_1374(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_1375","instance":1375,"id":204718,"goal":"lemma SetSubsetTrans_1375(A: set, S: set, T: set)\n requires A <= S && S <= T\n ensures A <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_1376","instance":1376,"id":204719,"goal":"lemma SetUnionEmpty_1376(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_1377","instance":1377,"id":204720,"goal":"lemma SetInterEmpty_1377(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_1378","instance":1378,"id":204721,"goal":"lemma SetInterSubset_1378(B: set, S: set)\n ensures B * S <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_1379","instance":1379,"id":204722,"goal":"lemma SetCardSubset_1379(A: set, T: set)\n requires A <= T\n ensures |A| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_1380","instance":1380,"id":204723,"goal":"lemma SetUnionCard_1380(U: set, S: set)\n requires U * S == {}\n ensures |U + S| == |U| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_1381","instance":1381,"id":204724,"goal":"lemma SetUnionComm_1381(T: set, B: set)\n ensures T + B == B + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_1382","instance":1382,"id":204725,"goal":"lemma SetInterComm_1382(S: set, A: set)\n ensures S * A == A * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_1383","instance":1383,"id":204726,"goal":"lemma SetUnionAssoc_1383(A: set, S: set, T: set)\n ensures (A + S) + T == A + (S + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_1384","instance":1384,"id":204727,"goal":"lemma SetSubsetRefl_1384(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_1385","instance":1385,"id":204728,"goal":"lemma SetSubsetTrans_1385(A: set, T: set, B: set)\n requires A <= T && T <= B\n ensures A <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_1386","instance":1386,"id":204729,"goal":"lemma SetUnionEmpty_1386(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_1387","instance":1387,"id":204730,"goal":"lemma SetInterEmpty_1387(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_1388","instance":1388,"id":204731,"goal":"lemma SetInterSubset_1388(S: set, B: set)\n ensures S * B <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_1389","instance":1389,"id":204732,"goal":"lemma SetCardSubset_1389(U: set, T: set)\n requires U <= T\n ensures |U| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_1390","instance":1390,"id":204733,"goal":"lemma SetUnionCard_1390(A: set, S: set)\n requires A * S == {}\n ensures |A + S| == |A| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_1391","instance":1391,"id":204734,"goal":"lemma SetUnionComm_1391(A: set, U: set)\n ensures A + U == U + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_1392","instance":1392,"id":204735,"goal":"lemma SetInterComm_1392(U: set, A: set)\n ensures U * A == A * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_1393","instance":1393,"id":204736,"goal":"lemma SetUnionAssoc_1393(B: set, A: set, S: set)\n ensures (B + A) + S == B + (A + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_1394","instance":1394,"id":204737,"goal":"lemma SetSubsetRefl_1394(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_1395","instance":1395,"id":204738,"goal":"lemma SetSubsetTrans_1395(A: set, S: set, T: set)\n requires A <= S && S <= T\n ensures A <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_1396","instance":1396,"id":204739,"goal":"lemma SetUnionEmpty_1396(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_1397","instance":1397,"id":204740,"goal":"lemma SetInterEmpty_1397(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_1398","instance":1398,"id":204741,"goal":"lemma SetInterSubset_1398(A: set, U: set)\n ensures A * U <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_1399","instance":1399,"id":204742,"goal":"lemma SetCardSubset_1399(T: set, B: set)\n requires T <= B\n ensures |T| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_1400","instance":1400,"id":204743,"goal":"lemma SetUnionCard_1400(T: set, A: set)\n requires T * A == {}\n ensures |T + A| == |T| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_1401","instance":1401,"id":204744,"goal":"lemma SetUnionComm_1401(U: set, S: set)\n ensures U + S == S + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_1402","instance":1402,"id":204745,"goal":"lemma SetInterComm_1402(T: set, A: set)\n ensures T * A == A * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_1403","instance":1403,"id":204746,"goal":"lemma SetUnionAssoc_1403(B: set, A: set, S: set)\n ensures (B + A) + S == B + (A + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_1404","instance":1404,"id":204747,"goal":"lemma SetSubsetRefl_1404(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_1405","instance":1405,"id":204748,"goal":"lemma SetSubsetTrans_1405(S: set, T: set, U: set)\n requires S <= T && T <= U\n ensures S <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_1406","instance":1406,"id":204749,"goal":"lemma SetUnionEmpty_1406(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_1407","instance":1407,"id":204750,"goal":"lemma SetInterEmpty_1407(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_1408","instance":1408,"id":204751,"goal":"lemma SetInterSubset_1408(S: set, T: set)\n ensures S * T <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_1409","instance":1409,"id":204752,"goal":"lemma SetCardSubset_1409(U: set, S: set)\n requires U <= S\n ensures |U| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_1410","instance":1410,"id":204753,"goal":"lemma SetUnionCard_1410(A: set, S: set)\n requires A * S == {}\n ensures |A + S| == |A| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_1411","instance":1411,"id":204754,"goal":"lemma SetUnionComm_1411(U: set, T: set)\n ensures U + T == T + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_1412","instance":1412,"id":204755,"goal":"lemma SetInterComm_1412(S: set, B: set)\n ensures S * B == B * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_1413","instance":1413,"id":204756,"goal":"lemma SetUnionAssoc_1413(S: set, U: set, A: set)\n ensures (S + U) + A == S + (U + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_1414","instance":1414,"id":204757,"goal":"lemma SetSubsetRefl_1414(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_1415","instance":1415,"id":204758,"goal":"lemma SetSubsetTrans_1415(B: set, T: set, A: set)\n requires B <= T && T <= A\n ensures B <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_1416","instance":1416,"id":204759,"goal":"lemma SetUnionEmpty_1416(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_1417","instance":1417,"id":204760,"goal":"lemma SetInterEmpty_1417(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_1418","instance":1418,"id":204761,"goal":"lemma SetInterSubset_1418(A: set, B: set)\n ensures A * B <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_1419","instance":1419,"id":204762,"goal":"lemma SetCardSubset_1419(T: set, A: set)\n requires T <= A\n ensures |T| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_1420","instance":1420,"id":204763,"goal":"lemma SetUnionCard_1420(T: set, B: set)\n requires T * B == {}\n ensures |T + B| == |T| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_1421","instance":1421,"id":204764,"goal":"lemma SetUnionComm_1421(T: set, A: set)\n ensures T + A == A + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_1422","instance":1422,"id":204765,"goal":"lemma SetInterComm_1422(A: set, B: set)\n ensures A * B == B * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_1423","instance":1423,"id":204766,"goal":"lemma SetUnionAssoc_1423(A: set, S: set, U: set)\n ensures (A + S) + U == A + (S + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_1424","instance":1424,"id":204767,"goal":"lemma SetSubsetRefl_1424(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_1425","instance":1425,"id":204768,"goal":"lemma SetSubsetTrans_1425(A: set, B: set, U: set)\n requires A <= B && B <= U\n ensures A <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_1426","instance":1426,"id":204769,"goal":"lemma SetUnionEmpty_1426(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_1427","instance":1427,"id":204770,"goal":"lemma SetInterEmpty_1427(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_1428","instance":1428,"id":204771,"goal":"lemma SetInterSubset_1428(U: set, B: set)\n ensures U * B <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_1429","instance":1429,"id":204772,"goal":"lemma SetCardSubset_1429(U: set, S: set)\n requires U <= S\n ensures |U| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_1430","instance":1430,"id":204773,"goal":"lemma SetUnionCard_1430(S: set, U: set)\n requires S * U == {}\n ensures |S + U| == |S| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_1431","instance":1431,"id":204774,"goal":"lemma SetUnionComm_1431(B: set, S: set)\n ensures B + S == S + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_1432","instance":1432,"id":204775,"goal":"lemma SetInterComm_1432(S: set, U: set)\n ensures S * U == U * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_1433","instance":1433,"id":204776,"goal":"lemma SetUnionAssoc_1433(U: set, B: set, A: set)\n ensures (U + B) + A == U + (B + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_1434","instance":1434,"id":204777,"goal":"lemma SetSubsetRefl_1434(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_1435","instance":1435,"id":204778,"goal":"lemma SetSubsetTrans_1435(T: set, B: set, U: set)\n requires T <= B && B <= U\n ensures T <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_1436","instance":1436,"id":204779,"goal":"lemma SetUnionEmpty_1436(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_1437","instance":1437,"id":204780,"goal":"lemma SetInterEmpty_1437(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_1438","instance":1438,"id":204781,"goal":"lemma SetInterSubset_1438(T: set, B: set)\n ensures T * B <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_1439","instance":1439,"id":204782,"goal":"lemma SetCardSubset_1439(U: set, S: set)\n requires U <= S\n ensures |U| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_1440","instance":1440,"id":204783,"goal":"lemma SetUnionCard_1440(U: set, S: set)\n requires U * S == {}\n ensures |U + S| == |U| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_1441","instance":1441,"id":204784,"goal":"lemma SetUnionComm_1441(T: set, S: set)\n ensures T + S == S + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_1442","instance":1442,"id":204785,"goal":"lemma SetInterComm_1442(S: set, U: set)\n ensures S * U == U * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_1443","instance":1443,"id":204786,"goal":"lemma SetUnionAssoc_1443(T: set, B: set, A: set)\n ensures (T + B) + A == T + (B + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_1444","instance":1444,"id":204787,"goal":"lemma SetSubsetRefl_1444(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_1445","instance":1445,"id":204788,"goal":"lemma SetSubsetTrans_1445(A: set, B: set, U: set)\n requires A <= B && B <= U\n ensures A <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_1446","instance":1446,"id":204789,"goal":"lemma SetUnionEmpty_1446(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_1447","instance":1447,"id":204790,"goal":"lemma SetInterEmpty_1447(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_1448","instance":1448,"id":204791,"goal":"lemma SetInterSubset_1448(T: set, U: set)\n ensures T * U <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_1449","instance":1449,"id":204792,"goal":"lemma SetCardSubset_1449(U: set, S: set)\n requires U <= S\n ensures |U| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_1450","instance":1450,"id":204793,"goal":"lemma SetUnionCard_1450(S: set, T: set)\n requires S * T == {}\n ensures |S + T| == |S| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_1451","instance":1451,"id":204794,"goal":"lemma SetUnionComm_1451(A: set, T: set)\n ensures A + T == T + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_1452","instance":1452,"id":204795,"goal":"lemma SetInterComm_1452(A: set, U: set)\n ensures A * U == U * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_1453","instance":1453,"id":204796,"goal":"lemma SetUnionAssoc_1453(S: set, B: set, U: set)\n ensures (S + B) + U == S + (B + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_1454","instance":1454,"id":204797,"goal":"lemma SetSubsetRefl_1454(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_1455","instance":1455,"id":204798,"goal":"lemma SetSubsetTrans_1455(T: set, A: set, S: set)\n requires T <= A && A <= S\n ensures T <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_1456","instance":1456,"id":204799,"goal":"lemma SetUnionEmpty_1456(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_1457","instance":1457,"id":204800,"goal":"lemma SetInterEmpty_1457(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_1458","instance":1458,"id":204801,"goal":"lemma SetInterSubset_1458(S: set, A: set)\n ensures S * A <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_1459","instance":1459,"id":204802,"goal":"lemma SetCardSubset_1459(U: set, T: set)\n requires U <= T\n ensures |U| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_1460","instance":1460,"id":204803,"goal":"lemma SetUnionCard_1460(U: set, S: set)\n requires U * S == {}\n ensures |U + S| == |U| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_1461","instance":1461,"id":204804,"goal":"lemma SetUnionComm_1461(B: set, A: set)\n ensures B + A == A + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_1462","instance":1462,"id":204805,"goal":"lemma SetInterComm_1462(S: set, T: set)\n ensures S * T == T * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_1463","instance":1463,"id":204806,"goal":"lemma SetUnionAssoc_1463(S: set, A: set, U: set)\n ensures (S + A) + U == S + (A + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_1464","instance":1464,"id":204807,"goal":"lemma SetSubsetRefl_1464(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_1465","instance":1465,"id":204808,"goal":"lemma SetSubsetTrans_1465(S: set, A: set, U: set)\n requires S <= A && A <= U\n ensures S <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_1466","instance":1466,"id":204809,"goal":"lemma SetUnionEmpty_1466(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_1467","instance":1467,"id":204810,"goal":"lemma SetInterEmpty_1467(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_1468","instance":1468,"id":204811,"goal":"lemma SetInterSubset_1468(A: set, T: set)\n ensures A * T <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_1469","instance":1469,"id":204812,"goal":"lemma SetCardSubset_1469(S: set, T: set)\n requires S <= T\n ensures |S| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_1470","instance":1470,"id":204813,"goal":"lemma SetUnionCard_1470(U: set, T: set)\n requires U * T == {}\n ensures |U + T| == |U| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_1471","instance":1471,"id":204814,"goal":"lemma SetUnionComm_1471(T: set, S: set)\n ensures T + S == S + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_1472","instance":1472,"id":204815,"goal":"lemma SetInterComm_1472(U: set, T: set)\n ensures U * T == T * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_1473","instance":1473,"id":204816,"goal":"lemma SetUnionAssoc_1473(B: set, S: set, A: set)\n ensures (B + S) + A == B + (S + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_1474","instance":1474,"id":204817,"goal":"lemma SetSubsetRefl_1474(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_1475","instance":1475,"id":204818,"goal":"lemma SetSubsetTrans_1475(T: set, A: set, S: set)\n requires T <= A && A <= S\n ensures T <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_1476","instance":1476,"id":204819,"goal":"lemma SetUnionEmpty_1476(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_1477","instance":1477,"id":204820,"goal":"lemma SetInterEmpty_1477(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_1478","instance":1478,"id":204821,"goal":"lemma SetInterSubset_1478(S: set, B: set)\n ensures S * B <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_1479","instance":1479,"id":204822,"goal":"lemma SetCardSubset_1479(A: set, S: set)\n requires A <= S\n ensures |A| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_1480","instance":1480,"id":204823,"goal":"lemma SetUnionCard_1480(B: set, T: set)\n requires B * T == {}\n ensures |B + T| == |B| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_1481","instance":1481,"id":204824,"goal":"lemma SetUnionComm_1481(A: set, S: set)\n ensures A + S == S + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_1482","instance":1482,"id":204825,"goal":"lemma SetInterComm_1482(S: set, U: set)\n ensures S * U == U * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_1483","instance":1483,"id":204826,"goal":"lemma SetUnionAssoc_1483(U: set, B: set, A: set)\n ensures (U + B) + A == U + (B + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_1484","instance":1484,"id":204827,"goal":"lemma SetSubsetRefl_1484(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_1485","instance":1485,"id":204828,"goal":"lemma SetSubsetTrans_1485(A: set, T: set, B: set)\n requires A <= T && T <= B\n ensures A <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_1486","instance":1486,"id":204829,"goal":"lemma SetUnionEmpty_1486(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_1487","instance":1487,"id":204830,"goal":"lemma SetInterEmpty_1487(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_1488","instance":1488,"id":204831,"goal":"lemma SetInterSubset_1488(T: set, S: set)\n ensures T * S <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_1489","instance":1489,"id":204832,"goal":"lemma SetCardSubset_1489(U: set, T: set)\n requires U <= T\n ensures |U| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_1490","instance":1490,"id":204833,"goal":"lemma SetUnionCard_1490(B: set, T: set)\n requires B * T == {}\n ensures |B + T| == |B| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_1491","instance":1491,"id":204834,"goal":"lemma SetUnionComm_1491(A: set, B: set)\n ensures A + B == B + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_1492","instance":1492,"id":204835,"goal":"lemma SetInterComm_1492(A: set, U: set)\n ensures A * U == U * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_1493","instance":1493,"id":204836,"goal":"lemma SetUnionAssoc_1493(T: set, S: set, A: set)\n ensures (T + S) + A == T + (S + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_1494","instance":1494,"id":204837,"goal":"lemma SetSubsetRefl_1494(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_1495","instance":1495,"id":204838,"goal":"lemma SetSubsetTrans_1495(U: set, A: set, T: set)\n requires U <= A && A <= T\n ensures U <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_1496","instance":1496,"id":204839,"goal":"lemma SetUnionEmpty_1496(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_1497","instance":1497,"id":204840,"goal":"lemma SetInterEmpty_1497(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_1498","instance":1498,"id":204841,"goal":"lemma SetInterSubset_1498(U: set, B: set)\n ensures U * B <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_1499","instance":1499,"id":204842,"goal":"lemma SetCardSubset_1499(A: set, T: set)\n requires A <= T\n ensures |A| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_1500","instance":1500,"id":204843,"goal":"lemma SetUnionCard_1500(B: set, S: set)\n requires B * S == {}\n ensures |B + S| == |B| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_1501","instance":1501,"id":204844,"goal":"lemma SetUnionComm_1501(U: set, S: set)\n ensures U + S == S + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_1502","instance":1502,"id":204845,"goal":"lemma SetInterComm_1502(A: set, S: set)\n ensures A * S == S * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_1503","instance":1503,"id":204846,"goal":"lemma SetUnionAssoc_1503(S: set, T: set, B: set)\n ensures (S + T) + B == S + (T + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_1504","instance":1504,"id":204847,"goal":"lemma SetSubsetRefl_1504(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_1505","instance":1505,"id":204848,"goal":"lemma SetSubsetTrans_1505(S: set, B: set, A: set)\n requires S <= B && B <= A\n ensures S <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_1506","instance":1506,"id":204849,"goal":"lemma SetUnionEmpty_1506(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_1507","instance":1507,"id":204850,"goal":"lemma SetInterEmpty_1507(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_1508","instance":1508,"id":204851,"goal":"lemma SetInterSubset_1508(U: set, B: set)\n ensures U * B <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_1509","instance":1509,"id":204852,"goal":"lemma SetCardSubset_1509(T: set, U: set)\n requires T <= U\n ensures |T| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_1510","instance":1510,"id":204853,"goal":"lemma SetUnionCard_1510(B: set, U: set)\n requires B * U == {}\n ensures |B + U| == |B| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_1511","instance":1511,"id":204854,"goal":"lemma SetUnionComm_1511(B: set, U: set)\n ensures B + U == U + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_1512","instance":1512,"id":204855,"goal":"lemma SetInterComm_1512(T: set, B: set)\n ensures T * B == B * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_1513","instance":1513,"id":204856,"goal":"lemma SetUnionAssoc_1513(S: set, B: set, U: set)\n ensures (S + B) + U == S + (B + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_1514","instance":1514,"id":204857,"goal":"lemma SetSubsetRefl_1514(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_1515","instance":1515,"id":204858,"goal":"lemma SetSubsetTrans_1515(U: set, A: set, S: set)\n requires U <= A && A <= S\n ensures U <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_1516","instance":1516,"id":204859,"goal":"lemma SetUnionEmpty_1516(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_1517","instance":1517,"id":204860,"goal":"lemma SetInterEmpty_1517(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_1518","instance":1518,"id":204861,"goal":"lemma SetInterSubset_1518(A: set, B: set)\n ensures A * B <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_1519","instance":1519,"id":204862,"goal":"lemma SetCardSubset_1519(A: set, B: set)\n requires A <= B\n ensures |A| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_1520","instance":1520,"id":204863,"goal":"lemma SetUnionCard_1520(B: set, S: set)\n requires B * S == {}\n ensures |B + S| == |B| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_1521","instance":1521,"id":204864,"goal":"lemma SetUnionComm_1521(A: set, B: set)\n ensures A + B == B + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_1522","instance":1522,"id":204865,"goal":"lemma SetInterComm_1522(A: set, B: set)\n ensures A * B == B * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_1523","instance":1523,"id":204866,"goal":"lemma SetUnionAssoc_1523(U: set, A: set, B: set)\n ensures (U + A) + B == U + (A + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_1524","instance":1524,"id":204867,"goal":"lemma SetSubsetRefl_1524(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_1525","instance":1525,"id":204868,"goal":"lemma SetSubsetTrans_1525(B: set, S: set, T: set)\n requires B <= S && S <= T\n ensures B <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_1526","instance":1526,"id":204869,"goal":"lemma SetUnionEmpty_1526(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_1527","instance":1527,"id":204870,"goal":"lemma SetInterEmpty_1527(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_1528","instance":1528,"id":204871,"goal":"lemma SetInterSubset_1528(B: set, T: set)\n ensures B * T <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_1529","instance":1529,"id":204872,"goal":"lemma SetCardSubset_1529(U: set, T: set)\n requires U <= T\n ensures |U| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_1530","instance":1530,"id":204873,"goal":"lemma SetUnionCard_1530(B: set, A: set)\n requires B * A == {}\n ensures |B + A| == |B| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_1531","instance":1531,"id":204874,"goal":"lemma SetUnionComm_1531(B: set, S: set)\n ensures B + S == S + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_1532","instance":1532,"id":204875,"goal":"lemma SetInterComm_1532(A: set, B: set)\n ensures A * B == B * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_1533","instance":1533,"id":204876,"goal":"lemma SetUnionAssoc_1533(U: set, T: set, B: set)\n ensures (U + T) + B == U + (T + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_1534","instance":1534,"id":204877,"goal":"lemma SetSubsetRefl_1534(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_1535","instance":1535,"id":204878,"goal":"lemma SetSubsetTrans_1535(S: set, T: set, A: set)\n requires S <= T && T <= A\n ensures S <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_1536","instance":1536,"id":204879,"goal":"lemma SetUnionEmpty_1536(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_1537","instance":1537,"id":204880,"goal":"lemma SetInterEmpty_1537(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_1538","instance":1538,"id":204881,"goal":"lemma SetInterSubset_1538(T: set, S: set)\n ensures T * S <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_1539","instance":1539,"id":204882,"goal":"lemma SetCardSubset_1539(U: set, A: set)\n requires U <= A\n ensures |U| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_1540","instance":1540,"id":204883,"goal":"lemma SetUnionCard_1540(T: set, U: set)\n requires T * U == {}\n ensures |T + U| == |T| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_1541","instance":1541,"id":204884,"goal":"lemma SetUnionComm_1541(S: set, A: set)\n ensures S + A == A + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_1542","instance":1542,"id":204885,"goal":"lemma SetInterComm_1542(B: set, T: set)\n ensures B * T == T * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_1543","instance":1543,"id":204886,"goal":"lemma SetUnionAssoc_1543(U: set, S: set, T: set)\n ensures (U + S) + T == U + (S + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_1544","instance":1544,"id":204887,"goal":"lemma SetSubsetRefl_1544(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_1545","instance":1545,"id":204888,"goal":"lemma SetSubsetTrans_1545(S: set, B: set, U: set)\n requires S <= B && B <= U\n ensures S <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_1546","instance":1546,"id":204889,"goal":"lemma SetUnionEmpty_1546(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_1547","instance":1547,"id":204890,"goal":"lemma SetInterEmpty_1547(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_1548","instance":1548,"id":204891,"goal":"lemma SetInterSubset_1548(T: set, S: set)\n ensures T * S <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_1549","instance":1549,"id":204892,"goal":"lemma SetCardSubset_1549(A: set, U: set)\n requires A <= U\n ensures |A| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_1550","instance":1550,"id":204893,"goal":"lemma SetUnionCard_1550(S: set, T: set)\n requires S * T == {}\n ensures |S + T| == |S| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_1551","instance":1551,"id":204894,"goal":"lemma SetUnionComm_1551(B: set, S: set)\n ensures B + S == S + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_1552","instance":1552,"id":204895,"goal":"lemma SetInterComm_1552(B: set, A: set)\n ensures B * A == A * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_1553","instance":1553,"id":204896,"goal":"lemma SetUnionAssoc_1553(B: set, A: set, T: set)\n ensures (B + A) + T == B + (A + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_1554","instance":1554,"id":204897,"goal":"lemma SetSubsetRefl_1554(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_1555","instance":1555,"id":204898,"goal":"lemma SetSubsetTrans_1555(A: set, T: set, B: set)\n requires A <= T && T <= B\n ensures A <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_1556","instance":1556,"id":204899,"goal":"lemma SetUnionEmpty_1556(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_1557","instance":1557,"id":204900,"goal":"lemma SetInterEmpty_1557(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_1558","instance":1558,"id":204901,"goal":"lemma SetInterSubset_1558(U: set, S: set)\n ensures U * S <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_1559","instance":1559,"id":204902,"goal":"lemma SetCardSubset_1559(T: set, B: set)\n requires T <= B\n ensures |T| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_1560","instance":1560,"id":204903,"goal":"lemma SetUnionCard_1560(A: set, U: set)\n requires A * U == {}\n ensures |A + U| == |A| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_1561","instance":1561,"id":204904,"goal":"lemma SetUnionComm_1561(S: set, B: set)\n ensures S + B == B + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_1562","instance":1562,"id":204905,"goal":"lemma SetInterComm_1562(T: set, A: set)\n ensures T * A == A * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_1563","instance":1563,"id":204906,"goal":"lemma SetUnionAssoc_1563(T: set, S: set, U: set)\n ensures (T + S) + U == T + (S + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_1564","instance":1564,"id":204907,"goal":"lemma SetSubsetRefl_1564(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_1565","instance":1565,"id":204908,"goal":"lemma SetSubsetTrans_1565(S: set, B: set, A: set)\n requires S <= B && B <= A\n ensures S <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_1566","instance":1566,"id":204909,"goal":"lemma SetUnionEmpty_1566(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_1567","instance":1567,"id":204910,"goal":"lemma SetInterEmpty_1567(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_1568","instance":1568,"id":204911,"goal":"lemma SetInterSubset_1568(U: set, B: set)\n ensures U * B <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_1569","instance":1569,"id":204912,"goal":"lemma SetCardSubset_1569(A: set, B: set)\n requires A <= B\n ensures |A| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_1570","instance":1570,"id":204913,"goal":"lemma SetUnionCard_1570(T: set, S: set)\n requires T * S == {}\n ensures |T + S| == |T| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_1571","instance":1571,"id":204914,"goal":"lemma SetUnionComm_1571(B: set, U: set)\n ensures B + U == U + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_1572","instance":1572,"id":204915,"goal":"lemma SetInterComm_1572(T: set, U: set)\n ensures T * U == U * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_1573","instance":1573,"id":204916,"goal":"lemma SetUnionAssoc_1573(U: set, A: set, B: set)\n ensures (U + A) + B == U + (A + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_1574","instance":1574,"id":204917,"goal":"lemma SetSubsetRefl_1574(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_1575","instance":1575,"id":204918,"goal":"lemma SetSubsetTrans_1575(B: set, S: set, T: set)\n requires B <= S && S <= T\n ensures B <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_1576","instance":1576,"id":204919,"goal":"lemma SetUnionEmpty_1576(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_1577","instance":1577,"id":204920,"goal":"lemma SetInterEmpty_1577(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_1578","instance":1578,"id":204921,"goal":"lemma SetInterSubset_1578(U: set, B: set)\n ensures U * B <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_1579","instance":1579,"id":204922,"goal":"lemma SetCardSubset_1579(U: set, A: set)\n requires U <= A\n ensures |U| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_1580","instance":1580,"id":204923,"goal":"lemma SetUnionCard_1580(B: set, S: set)\n requires B * S == {}\n ensures |B + S| == |B| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_1581","instance":1581,"id":204924,"goal":"lemma SetUnionComm_1581(A: set, B: set)\n ensures A + B == B + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_1582","instance":1582,"id":204925,"goal":"lemma SetInterComm_1582(U: set, T: set)\n ensures U * T == T * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_1583","instance":1583,"id":204926,"goal":"lemma SetUnionAssoc_1583(T: set, A: set, U: set)\n ensures (T + A) + U == T + (A + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_1584","instance":1584,"id":204927,"goal":"lemma SetSubsetRefl_1584(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_1585","instance":1585,"id":204928,"goal":"lemma SetSubsetTrans_1585(B: set, T: set, A: set)\n requires B <= T && T <= A\n ensures B <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_1586","instance":1586,"id":204929,"goal":"lemma SetUnionEmpty_1586(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_1587","instance":1587,"id":204930,"goal":"lemma SetInterEmpty_1587(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_1588","instance":1588,"id":204931,"goal":"lemma SetInterSubset_1588(S: set, T: set)\n ensures S * T <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_1589","instance":1589,"id":204932,"goal":"lemma SetCardSubset_1589(A: set, T: set)\n requires A <= T\n ensures |A| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_1590","instance":1590,"id":204933,"goal":"lemma SetUnionCard_1590(T: set, S: set)\n requires T * S == {}\n ensures |T + S| == |T| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_1591","instance":1591,"id":204934,"goal":"lemma SetUnionComm_1591(B: set, T: set)\n ensures B + T == T + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_1592","instance":1592,"id":204935,"goal":"lemma SetInterComm_1592(B: set, S: set)\n ensures B * S == S * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_1593","instance":1593,"id":204936,"goal":"lemma SetUnionAssoc_1593(T: set, U: set, A: set)\n ensures (T + U) + A == T + (U + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_1594","instance":1594,"id":204937,"goal":"lemma SetSubsetRefl_1594(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_1595","instance":1595,"id":204938,"goal":"lemma SetSubsetTrans_1595(S: set, T: set, A: set)\n requires S <= T && T <= A\n ensures S <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_1596","instance":1596,"id":204939,"goal":"lemma SetUnionEmpty_1596(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_1597","instance":1597,"id":204940,"goal":"lemma SetInterEmpty_1597(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_1598","instance":1598,"id":204941,"goal":"lemma SetInterSubset_1598(A: set, U: set)\n ensures A * U <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_1599","instance":1599,"id":204942,"goal":"lemma SetCardSubset_1599(A: set, U: set)\n requires A <= U\n ensures |A| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_1600","instance":1600,"id":204943,"goal":"lemma SetUnionCard_1600(B: set, S: set)\n requires B * S == {}\n ensures |B + S| == |B| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_1601","instance":1601,"id":204944,"goal":"lemma SetUnionComm_1601(S: set, A: set)\n ensures S + A == A + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_1602","instance":1602,"id":204945,"goal":"lemma SetInterComm_1602(A: set, B: set)\n ensures A * B == B * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_1603","instance":1603,"id":204946,"goal":"lemma SetUnionAssoc_1603(T: set, B: set, S: set)\n ensures (T + B) + S == T + (B + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_1604","instance":1604,"id":204947,"goal":"lemma SetSubsetRefl_1604(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_1605","instance":1605,"id":204948,"goal":"lemma SetSubsetTrans_1605(U: set, B: set, A: set)\n requires U <= B && B <= A\n ensures U <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_1606","instance":1606,"id":204949,"goal":"lemma SetUnionEmpty_1606(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_1607","instance":1607,"id":204950,"goal":"lemma SetInterEmpty_1607(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_1608","instance":1608,"id":204951,"goal":"lemma SetInterSubset_1608(S: set, A: set)\n ensures S * A <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_1609","instance":1609,"id":204952,"goal":"lemma SetCardSubset_1609(U: set, B: set)\n requires U <= B\n ensures |U| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_1610","instance":1610,"id":204953,"goal":"lemma SetUnionCard_1610(A: set, U: set)\n requires A * U == {}\n ensures |A + U| == |A| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_1611","instance":1611,"id":204954,"goal":"lemma SetUnionComm_1611(A: set, T: set)\n ensures A + T == T + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_1612","instance":1612,"id":204955,"goal":"lemma SetInterComm_1612(T: set, S: set)\n ensures T * S == S * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_1613","instance":1613,"id":204956,"goal":"lemma SetUnionAssoc_1613(A: set, T: set, B: set)\n ensures (A + T) + B == A + (T + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_1614","instance":1614,"id":204957,"goal":"lemma SetSubsetRefl_1614(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_1615","instance":1615,"id":204958,"goal":"lemma SetSubsetTrans_1615(B: set, T: set, S: set)\n requires B <= T && T <= S\n ensures B <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_1616","instance":1616,"id":204959,"goal":"lemma SetUnionEmpty_1616(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_1617","instance":1617,"id":204960,"goal":"lemma SetInterEmpty_1617(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_1618","instance":1618,"id":204961,"goal":"lemma SetInterSubset_1618(U: set, T: set)\n ensures U * T <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_1619","instance":1619,"id":204962,"goal":"lemma SetCardSubset_1619(A: set, S: set)\n requires A <= S\n ensures |A| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_1620","instance":1620,"id":204963,"goal":"lemma SetUnionCard_1620(S: set, U: set)\n requires S * U == {}\n ensures |S + U| == |S| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_1621","instance":1621,"id":204964,"goal":"lemma SetUnionComm_1621(A: set, S: set)\n ensures A + S == S + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_1622","instance":1622,"id":204965,"goal":"lemma SetInterComm_1622(B: set, S: set)\n ensures B * S == S * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_1623","instance":1623,"id":204966,"goal":"lemma SetUnionAssoc_1623(U: set, B: set, A: set)\n ensures (U + B) + A == U + (B + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_1624","instance":1624,"id":204967,"goal":"lemma SetSubsetRefl_1624(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_1625","instance":1625,"id":204968,"goal":"lemma SetSubsetTrans_1625(T: set, B: set, A: set)\n requires T <= B && B <= A\n ensures T <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_1626","instance":1626,"id":204969,"goal":"lemma SetUnionEmpty_1626(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_1627","instance":1627,"id":204970,"goal":"lemma SetInterEmpty_1627(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_1628","instance":1628,"id":204971,"goal":"lemma SetInterSubset_1628(U: set, T: set)\n ensures U * T <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_1629","instance":1629,"id":204972,"goal":"lemma SetCardSubset_1629(S: set, A: set)\n requires S <= A\n ensures |S| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_1630","instance":1630,"id":204973,"goal":"lemma SetUnionCard_1630(A: set, T: set)\n requires A * T == {}\n ensures |A + T| == |A| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_1631","instance":1631,"id":204974,"goal":"lemma SetUnionComm_1631(U: set, A: set)\n ensures U + A == A + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_1632","instance":1632,"id":204975,"goal":"lemma SetInterComm_1632(U: set, S: set)\n ensures U * S == S * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_1633","instance":1633,"id":204976,"goal":"lemma SetUnionAssoc_1633(T: set, S: set, U: set)\n ensures (T + S) + U == T + (S + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_1634","instance":1634,"id":204977,"goal":"lemma SetSubsetRefl_1634(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_1635","instance":1635,"id":204978,"goal":"lemma SetSubsetTrans_1635(S: set, U: set, T: set)\n requires S <= U && U <= T\n ensures S <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_1636","instance":1636,"id":204979,"goal":"lemma SetUnionEmpty_1636(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_1637","instance":1637,"id":204980,"goal":"lemma SetInterEmpty_1637(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_1638","instance":1638,"id":204981,"goal":"lemma SetInterSubset_1638(T: set, S: set)\n ensures T * S <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_1639","instance":1639,"id":204982,"goal":"lemma SetCardSubset_1639(T: set, B: set)\n requires T <= B\n ensures |T| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_1640","instance":1640,"id":204983,"goal":"lemma SetUnionCard_1640(S: set, U: set)\n requires S * U == {}\n ensures |S + U| == |S| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_1641","instance":1641,"id":204984,"goal":"lemma SetUnionComm_1641(S: set, A: set)\n ensures S + A == A + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_1642","instance":1642,"id":204985,"goal":"lemma SetInterComm_1642(B: set, U: set)\n ensures B * U == U * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_1643","instance":1643,"id":204986,"goal":"lemma SetUnionAssoc_1643(T: set, B: set, U: set)\n ensures (T + B) + U == T + (B + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_1644","instance":1644,"id":204987,"goal":"lemma SetSubsetRefl_1644(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_1645","instance":1645,"id":204988,"goal":"lemma SetSubsetTrans_1645(S: set, B: set, U: set)\n requires S <= B && B <= U\n ensures S <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_1646","instance":1646,"id":204989,"goal":"lemma SetUnionEmpty_1646(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_1647","instance":1647,"id":204990,"goal":"lemma SetInterEmpty_1647(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_1648","instance":1648,"id":204991,"goal":"lemma SetInterSubset_1648(B: set, T: set)\n ensures B * T <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_1649","instance":1649,"id":204992,"goal":"lemma SetCardSubset_1649(U: set, S: set)\n requires U <= S\n ensures |U| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_1650","instance":1650,"id":204993,"goal":"lemma SetUnionCard_1650(T: set, A: set)\n requires T * A == {}\n ensures |T + A| == |T| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_1651","instance":1651,"id":204994,"goal":"lemma SetUnionComm_1651(U: set, B: set)\n ensures U + B == B + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_1652","instance":1652,"id":204995,"goal":"lemma SetInterComm_1652(U: set, T: set)\n ensures U * T == T * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_1653","instance":1653,"id":204996,"goal":"lemma SetUnionAssoc_1653(A: set, S: set, B: set)\n ensures (A + S) + B == A + (S + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_1654","instance":1654,"id":204997,"goal":"lemma SetSubsetRefl_1654(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_1655","instance":1655,"id":204998,"goal":"lemma SetSubsetTrans_1655(A: set, B: set, S: set)\n requires A <= B && B <= S\n ensures A <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_1656","instance":1656,"id":204999,"goal":"lemma SetUnionEmpty_1656(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_1657","instance":1657,"id":205000,"goal":"lemma SetInterEmpty_1657(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_1658","instance":1658,"id":205001,"goal":"lemma SetInterSubset_1658(T: set, A: set)\n ensures T * A <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_1659","instance":1659,"id":205002,"goal":"lemma SetCardSubset_1659(A: set, S: set)\n requires A <= S\n ensures |A| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_1660","instance":1660,"id":205003,"goal":"lemma SetUnionCard_1660(S: set, T: set)\n requires S * T == {}\n ensures |S + T| == |S| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_1661","instance":1661,"id":205004,"goal":"lemma SetUnionComm_1661(T: set, U: set)\n ensures T + U == U + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_1662","instance":1662,"id":205005,"goal":"lemma SetInterComm_1662(S: set, T: set)\n ensures S * T == T * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_1663","instance":1663,"id":205006,"goal":"lemma SetUnionAssoc_1663(A: set, B: set, U: set)\n ensures (A + B) + U == A + (B + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_1664","instance":1664,"id":205007,"goal":"lemma SetSubsetRefl_1664(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_1665","instance":1665,"id":205008,"goal":"lemma SetSubsetTrans_1665(U: set, B: set, A: set)\n requires U <= B && B <= A\n ensures U <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_1666","instance":1666,"id":205009,"goal":"lemma SetUnionEmpty_1666(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_1667","instance":1667,"id":205010,"goal":"lemma SetInterEmpty_1667(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_1668","instance":1668,"id":205011,"goal":"lemma SetInterSubset_1668(T: set, S: set)\n ensures T * S <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_1669","instance":1669,"id":205012,"goal":"lemma SetCardSubset_1669(S: set, T: set)\n requires S <= T\n ensures |S| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_1670","instance":1670,"id":205013,"goal":"lemma SetUnionCard_1670(A: set, T: set)\n requires A * T == {}\n ensures |A + T| == |A| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_1671","instance":1671,"id":205014,"goal":"lemma SetUnionComm_1671(B: set, A: set)\n ensures B + A == A + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_1672","instance":1672,"id":205015,"goal":"lemma SetInterComm_1672(A: set, S: set)\n ensures A * S == S * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_1673","instance":1673,"id":205016,"goal":"lemma SetUnionAssoc_1673(B: set, U: set, A: set)\n ensures (B + U) + A == B + (U + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_1674","instance":1674,"id":205017,"goal":"lemma SetSubsetRefl_1674(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_1675","instance":1675,"id":205018,"goal":"lemma SetSubsetTrans_1675(U: set, A: set, T: set)\n requires U <= A && A <= T\n ensures U <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_1676","instance":1676,"id":205019,"goal":"lemma SetUnionEmpty_1676(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_1677","instance":1677,"id":205020,"goal":"lemma SetInterEmpty_1677(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_1678","instance":1678,"id":205021,"goal":"lemma SetInterSubset_1678(T: set, B: set)\n ensures T * B <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_1679","instance":1679,"id":205022,"goal":"lemma SetCardSubset_1679(S: set, U: set)\n requires S <= U\n ensures |S| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_1680","instance":1680,"id":205023,"goal":"lemma SetUnionCard_1680(A: set, S: set)\n requires A * S == {}\n ensures |A + S| == |A| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_1681","instance":1681,"id":205024,"goal":"lemma SetUnionComm_1681(T: set, U: set)\n ensures T + U == U + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_1682","instance":1682,"id":205025,"goal":"lemma SetInterComm_1682(B: set, A: set)\n ensures B * A == A * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_1683","instance":1683,"id":205026,"goal":"lemma SetUnionAssoc_1683(U: set, A: set, S: set)\n ensures (U + A) + S == U + (A + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_1684","instance":1684,"id":205027,"goal":"lemma SetSubsetRefl_1684(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_1685","instance":1685,"id":205028,"goal":"lemma SetSubsetTrans_1685(U: set, T: set, S: set)\n requires U <= T && T <= S\n ensures U <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_1686","instance":1686,"id":205029,"goal":"lemma SetUnionEmpty_1686(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_1687","instance":1687,"id":205030,"goal":"lemma SetInterEmpty_1687(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_1688","instance":1688,"id":205031,"goal":"lemma SetInterSubset_1688(A: set, B: set)\n ensures A * B <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_1689","instance":1689,"id":205032,"goal":"lemma SetCardSubset_1689(T: set, A: set)\n requires T <= A\n ensures |T| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_1690","instance":1690,"id":205033,"goal":"lemma SetUnionCard_1690(T: set, S: set)\n requires T * S == {}\n ensures |T + S| == |T| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_1691","instance":1691,"id":205034,"goal":"lemma SetUnionComm_1691(A: set, T: set)\n ensures A + T == T + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_1692","instance":1692,"id":205035,"goal":"lemma SetInterComm_1692(S: set, T: set)\n ensures S * T == T * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_1693","instance":1693,"id":205036,"goal":"lemma SetUnionAssoc_1693(B: set, U: set, T: set)\n ensures (B + U) + T == B + (U + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_1694","instance":1694,"id":205037,"goal":"lemma SetSubsetRefl_1694(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_1695","instance":1695,"id":205038,"goal":"lemma SetSubsetTrans_1695(B: set, S: set, U: set)\n requires B <= S && S <= U\n ensures B <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_1696","instance":1696,"id":205039,"goal":"lemma SetUnionEmpty_1696(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_1697","instance":1697,"id":205040,"goal":"lemma SetInterEmpty_1697(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_1698","instance":1698,"id":205041,"goal":"lemma SetInterSubset_1698(B: set, A: set)\n ensures B * A <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_1699","instance":1699,"id":205042,"goal":"lemma SetCardSubset_1699(T: set, A: set)\n requires T <= A\n ensures |T| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_1700","instance":1700,"id":205043,"goal":"lemma SetUnionCard_1700(T: set, S: set)\n requires T * S == {}\n ensures |T + S| == |T| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_1701","instance":1701,"id":205044,"goal":"lemma SetUnionComm_1701(U: set, B: set)\n ensures U + B == B + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_1702","instance":1702,"id":205045,"goal":"lemma SetInterComm_1702(U: set, S: set)\n ensures U * S == S * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_1703","instance":1703,"id":205046,"goal":"lemma SetUnionAssoc_1703(B: set, S: set, A: set)\n ensures (B + S) + A == B + (S + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_1704","instance":1704,"id":205047,"goal":"lemma SetSubsetRefl_1704(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_1705","instance":1705,"id":205048,"goal":"lemma SetSubsetTrans_1705(U: set, S: set, B: set)\n requires U <= S && S <= B\n ensures U <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_1706","instance":1706,"id":205049,"goal":"lemma SetUnionEmpty_1706(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_1707","instance":1707,"id":205050,"goal":"lemma SetInterEmpty_1707(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_1708","instance":1708,"id":205051,"goal":"lemma SetInterSubset_1708(B: set, S: set)\n ensures B * S <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_1709","instance":1709,"id":205052,"goal":"lemma SetCardSubset_1709(B: set, T: set)\n requires B <= T\n ensures |B| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_1710","instance":1710,"id":205053,"goal":"lemma SetUnionCard_1710(T: set, U: set)\n requires T * U == {}\n ensures |T + U| == |T| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_1711","instance":1711,"id":205054,"goal":"lemma SetUnionComm_1711(S: set, U: set)\n ensures S + U == U + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_1712","instance":1712,"id":205055,"goal":"lemma SetInterComm_1712(T: set, U: set)\n ensures T * U == U * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_1713","instance":1713,"id":205056,"goal":"lemma SetUnionAssoc_1713(T: set, S: set, B: set)\n ensures (T + S) + B == T + (S + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_1714","instance":1714,"id":205057,"goal":"lemma SetSubsetRefl_1714(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_1715","instance":1715,"id":205058,"goal":"lemma SetSubsetTrans_1715(S: set, A: set, U: set)\n requires S <= A && A <= U\n ensures S <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_1716","instance":1716,"id":205059,"goal":"lemma SetUnionEmpty_1716(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_1717","instance":1717,"id":205060,"goal":"lemma SetInterEmpty_1717(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_1718","instance":1718,"id":205061,"goal":"lemma SetInterSubset_1718(U: set, A: set)\n ensures U * A <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_1719","instance":1719,"id":205062,"goal":"lemma SetCardSubset_1719(S: set, T: set)\n requires S <= T\n ensures |S| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_1720","instance":1720,"id":205063,"goal":"lemma SetUnionCard_1720(S: set, U: set)\n requires S * U == {}\n ensures |S + U| == |S| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_1721","instance":1721,"id":205064,"goal":"lemma SetUnionComm_1721(B: set, A: set)\n ensures B + A == A + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_1722","instance":1722,"id":205065,"goal":"lemma SetInterComm_1722(B: set, U: set)\n ensures B * U == U * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_1723","instance":1723,"id":205066,"goal":"lemma SetUnionAssoc_1723(A: set, T: set, S: set)\n ensures (A + T) + S == A + (T + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_1724","instance":1724,"id":205067,"goal":"lemma SetSubsetRefl_1724(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_1725","instance":1725,"id":205068,"goal":"lemma SetSubsetTrans_1725(S: set, B: set, T: set)\n requires S <= B && B <= T\n ensures S <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_1726","instance":1726,"id":205069,"goal":"lemma SetUnionEmpty_1726(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_1727","instance":1727,"id":205070,"goal":"lemma SetInterEmpty_1727(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_1728","instance":1728,"id":205071,"goal":"lemma SetInterSubset_1728(A: set, T: set)\n ensures A * T <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_1729","instance":1729,"id":205072,"goal":"lemma SetCardSubset_1729(U: set, A: set)\n requires U <= A\n ensures |U| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_1730","instance":1730,"id":205073,"goal":"lemma SetUnionCard_1730(T: set, U: set)\n requires T * U == {}\n ensures |T + U| == |T| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_1731","instance":1731,"id":205074,"goal":"lemma SetUnionComm_1731(U: set, B: set)\n ensures U + B == B + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_1732","instance":1732,"id":205075,"goal":"lemma SetInterComm_1732(B: set, A: set)\n ensures B * A == A * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_1733","instance":1733,"id":205076,"goal":"lemma SetUnionAssoc_1733(U: set, A: set, T: set)\n ensures (U + A) + T == U + (A + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_1734","instance":1734,"id":205077,"goal":"lemma SetSubsetRefl_1734(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_1735","instance":1735,"id":205078,"goal":"lemma SetSubsetTrans_1735(B: set, S: set, U: set)\n requires B <= S && S <= U\n ensures B <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_1736","instance":1736,"id":205079,"goal":"lemma SetUnionEmpty_1736(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_1737","instance":1737,"id":205080,"goal":"lemma SetInterEmpty_1737(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_1738","instance":1738,"id":205081,"goal":"lemma SetInterSubset_1738(T: set, U: set)\n ensures T * U <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_1739","instance":1739,"id":205082,"goal":"lemma SetCardSubset_1739(U: set, B: set)\n requires U <= B\n ensures |U| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_1740","instance":1740,"id":205083,"goal":"lemma SetUnionCard_1740(S: set, T: set)\n requires S * T == {}\n ensures |S + T| == |S| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_1741","instance":1741,"id":205084,"goal":"lemma SetUnionComm_1741(B: set, S: set)\n ensures B + S == S + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_1742","instance":1742,"id":205085,"goal":"lemma SetInterComm_1742(T: set, A: set)\n ensures T * A == A * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_1743","instance":1743,"id":205086,"goal":"lemma SetUnionAssoc_1743(A: set, U: set, B: set)\n ensures (A + U) + B == A + (U + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_1744","instance":1744,"id":205087,"goal":"lemma SetSubsetRefl_1744(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_1745","instance":1745,"id":205088,"goal":"lemma SetSubsetTrans_1745(S: set, U: set, A: set)\n requires S <= U && U <= A\n ensures S <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_1746","instance":1746,"id":205089,"goal":"lemma SetUnionEmpty_1746(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_1747","instance":1747,"id":205090,"goal":"lemma SetInterEmpty_1747(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_1748","instance":1748,"id":205091,"goal":"lemma SetInterSubset_1748(S: set, B: set)\n ensures S * B <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_1749","instance":1749,"id":205092,"goal":"lemma SetCardSubset_1749(T: set, B: set)\n requires T <= B\n ensures |T| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_1750","instance":1750,"id":205093,"goal":"lemma SetUnionCard_1750(A: set, B: set)\n requires A * B == {}\n ensures |A + B| == |A| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_1751","instance":1751,"id":205094,"goal":"lemma SetUnionComm_1751(T: set, U: set)\n ensures T + U == U + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_1752","instance":1752,"id":205095,"goal":"lemma SetInterComm_1752(A: set, U: set)\n ensures A * U == U * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_1753","instance":1753,"id":205096,"goal":"lemma SetUnionAssoc_1753(U: set, T: set, B: set)\n ensures (U + T) + B == U + (T + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_1754","instance":1754,"id":205097,"goal":"lemma SetSubsetRefl_1754(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_1755","instance":1755,"id":205098,"goal":"lemma SetSubsetTrans_1755(S: set, T: set, B: set)\n requires S <= T && T <= B\n ensures S <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_1756","instance":1756,"id":205099,"goal":"lemma SetUnionEmpty_1756(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_1757","instance":1757,"id":205100,"goal":"lemma SetInterEmpty_1757(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_1758","instance":1758,"id":205101,"goal":"lemma SetInterSubset_1758(A: set, B: set)\n ensures A * B <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_1759","instance":1759,"id":205102,"goal":"lemma SetCardSubset_1759(A: set, U: set)\n requires A <= U\n ensures |A| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_1760","instance":1760,"id":205103,"goal":"lemma SetUnionCard_1760(U: set, T: set)\n requires U * T == {}\n ensures |U + T| == |U| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_1761","instance":1761,"id":205104,"goal":"lemma SetUnionComm_1761(S: set, T: set)\n ensures S + T == T + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_1762","instance":1762,"id":205105,"goal":"lemma SetInterComm_1762(B: set, A: set)\n ensures B * A == A * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_1763","instance":1763,"id":205106,"goal":"lemma SetUnionAssoc_1763(S: set, T: set, B: set)\n ensures (S + T) + B == S + (T + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_1764","instance":1764,"id":205107,"goal":"lemma SetSubsetRefl_1764(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_1765","instance":1765,"id":205108,"goal":"lemma SetSubsetTrans_1765(U: set, A: set, B: set)\n requires U <= A && A <= B\n ensures U <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_1766","instance":1766,"id":205109,"goal":"lemma SetUnionEmpty_1766(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_1767","instance":1767,"id":205110,"goal":"lemma SetInterEmpty_1767(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_1768","instance":1768,"id":205111,"goal":"lemma SetInterSubset_1768(B: set, U: set)\n ensures B * U <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_1769","instance":1769,"id":205112,"goal":"lemma SetCardSubset_1769(B: set, S: set)\n requires B <= S\n ensures |B| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_1770","instance":1770,"id":205113,"goal":"lemma SetUnionCard_1770(S: set, A: set)\n requires S * A == {}\n ensures |S + A| == |S| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_1771","instance":1771,"id":205114,"goal":"lemma SetUnionComm_1771(A: set, S: set)\n ensures A + S == S + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_1772","instance":1772,"id":205115,"goal":"lemma SetInterComm_1772(U: set, A: set)\n ensures U * A == A * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_1773","instance":1773,"id":205116,"goal":"lemma SetUnionAssoc_1773(B: set, S: set, T: set)\n ensures (B + S) + T == B + (S + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_1774","instance":1774,"id":205117,"goal":"lemma SetSubsetRefl_1774(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_1775","instance":1775,"id":205118,"goal":"lemma SetSubsetTrans_1775(S: set, B: set, A: set)\n requires S <= B && B <= A\n ensures S <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_1776","instance":1776,"id":205119,"goal":"lemma SetUnionEmpty_1776(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_1777","instance":1777,"id":205120,"goal":"lemma SetInterEmpty_1777(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_1778","instance":1778,"id":205121,"goal":"lemma SetInterSubset_1778(T: set, U: set)\n ensures T * U <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_1779","instance":1779,"id":205122,"goal":"lemma SetCardSubset_1779(B: set, U: set)\n requires B <= U\n ensures |B| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_1780","instance":1780,"id":205123,"goal":"lemma SetUnionCard_1780(S: set, T: set)\n requires S * T == {}\n ensures |S + T| == |S| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_1781","instance":1781,"id":205124,"goal":"lemma SetUnionComm_1781(U: set, A: set)\n ensures U + A == A + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_1782","instance":1782,"id":205125,"goal":"lemma SetInterComm_1782(S: set, B: set)\n ensures S * B == B * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_1783","instance":1783,"id":205126,"goal":"lemma SetUnionAssoc_1783(B: set, A: set, U: set)\n ensures (B + A) + U == B + (A + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_1784","instance":1784,"id":205127,"goal":"lemma SetSubsetRefl_1784(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_1785","instance":1785,"id":205128,"goal":"lemma SetSubsetTrans_1785(S: set, T: set, U: set)\n requires S <= T && T <= U\n ensures S <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_1786","instance":1786,"id":205129,"goal":"lemma SetUnionEmpty_1786(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_1787","instance":1787,"id":205130,"goal":"lemma SetInterEmpty_1787(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_1788","instance":1788,"id":205131,"goal":"lemma SetInterSubset_1788(A: set, T: set)\n ensures A * T <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_1789","instance":1789,"id":205132,"goal":"lemma SetCardSubset_1789(S: set, U: set)\n requires S <= U\n ensures |S| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_1790","instance":1790,"id":205133,"goal":"lemma SetUnionCard_1790(A: set, S: set)\n requires A * S == {}\n ensures |A + S| == |A| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_1791","instance":1791,"id":205134,"goal":"lemma SetUnionComm_1791(U: set, T: set)\n ensures U + T == T + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_1792","instance":1792,"id":205135,"goal":"lemma SetInterComm_1792(A: set, B: set)\n ensures A * B == B * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_1793","instance":1793,"id":205136,"goal":"lemma SetUnionAssoc_1793(U: set, S: set, B: set)\n ensures (U + S) + B == U + (S + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_1794","instance":1794,"id":205137,"goal":"lemma SetSubsetRefl_1794(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_1795","instance":1795,"id":205138,"goal":"lemma SetSubsetTrans_1795(S: set, U: set, T: set)\n requires S <= U && U <= T\n ensures S <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_1796","instance":1796,"id":205139,"goal":"lemma SetUnionEmpty_1796(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_1797","instance":1797,"id":205140,"goal":"lemma SetInterEmpty_1797(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_1798","instance":1798,"id":205141,"goal":"lemma SetInterSubset_1798(S: set, A: set)\n ensures S * A <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_1799","instance":1799,"id":205142,"goal":"lemma SetCardSubset_1799(U: set, S: set)\n requires U <= S\n ensures |U| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_1800","instance":1800,"id":205143,"goal":"lemma SetUnionCard_1800(B: set, A: set)\n requires B * A == {}\n ensures |B + A| == |B| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_1801","instance":1801,"id":205144,"goal":"lemma SetUnionComm_1801(U: set, T: set)\n ensures U + T == T + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_1802","instance":1802,"id":205145,"goal":"lemma SetInterComm_1802(U: set, B: set)\n ensures U * B == B * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_1803","instance":1803,"id":205146,"goal":"lemma SetUnionAssoc_1803(U: set, A: set, T: set)\n ensures (U + A) + T == U + (A + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_1804","instance":1804,"id":205147,"goal":"lemma SetSubsetRefl_1804(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_1805","instance":1805,"id":205148,"goal":"lemma SetSubsetTrans_1805(B: set, U: set, A: set)\n requires B <= U && U <= A\n ensures B <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_1806","instance":1806,"id":205149,"goal":"lemma SetUnionEmpty_1806(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_1807","instance":1807,"id":205150,"goal":"lemma SetInterEmpty_1807(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_1808","instance":1808,"id":205151,"goal":"lemma SetInterSubset_1808(B: set, S: set)\n ensures B * S <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_1809","instance":1809,"id":205152,"goal":"lemma SetCardSubset_1809(T: set, U: set)\n requires T <= U\n ensures |T| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_1810","instance":1810,"id":205153,"goal":"lemma SetUnionCard_1810(T: set, A: set)\n requires T * A == {}\n ensures |T + A| == |T| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_1811","instance":1811,"id":205154,"goal":"lemma SetUnionComm_1811(U: set, S: set)\n ensures U + S == S + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_1812","instance":1812,"id":205155,"goal":"lemma SetInterComm_1812(A: set, T: set)\n ensures A * T == T * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_1813","instance":1813,"id":205156,"goal":"lemma SetUnionAssoc_1813(B: set, T: set, A: set)\n ensures (B + T) + A == B + (T + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_1814","instance":1814,"id":205157,"goal":"lemma SetSubsetRefl_1814(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_1815","instance":1815,"id":205158,"goal":"lemma SetSubsetTrans_1815(A: set, S: set, B: set)\n requires A <= S && S <= B\n ensures A <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_1816","instance":1816,"id":205159,"goal":"lemma SetUnionEmpty_1816(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_1817","instance":1817,"id":205160,"goal":"lemma SetInterEmpty_1817(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_1818","instance":1818,"id":205161,"goal":"lemma SetInterSubset_1818(A: set, T: set)\n ensures A * T <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_1819","instance":1819,"id":205162,"goal":"lemma SetCardSubset_1819(B: set, U: set)\n requires B <= U\n ensures |B| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_1820","instance":1820,"id":205163,"goal":"lemma SetUnionCard_1820(S: set, U: set)\n requires S * U == {}\n ensures |S + U| == |S| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_1821","instance":1821,"id":205164,"goal":"lemma SetUnionComm_1821(T: set, S: set)\n ensures T + S == S + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_1822","instance":1822,"id":205165,"goal":"lemma SetInterComm_1822(T: set, B: set)\n ensures T * B == B * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_1823","instance":1823,"id":205166,"goal":"lemma SetUnionAssoc_1823(U: set, S: set, T: set)\n ensures (U + S) + T == U + (S + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_1824","instance":1824,"id":205167,"goal":"lemma SetSubsetRefl_1824(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_1825","instance":1825,"id":205168,"goal":"lemma SetSubsetTrans_1825(S: set, T: set, A: set)\n requires S <= T && T <= A\n ensures S <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_1826","instance":1826,"id":205169,"goal":"lemma SetUnionEmpty_1826(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_1827","instance":1827,"id":205170,"goal":"lemma SetInterEmpty_1827(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_1828","instance":1828,"id":205171,"goal":"lemma SetInterSubset_1828(A: set, T: set)\n ensures A * T <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_1829","instance":1829,"id":205172,"goal":"lemma SetCardSubset_1829(B: set, U: set)\n requires B <= U\n ensures |B| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_1830","instance":1830,"id":205173,"goal":"lemma SetUnionCard_1830(B: set, S: set)\n requires B * S == {}\n ensures |B + S| == |B| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_1831","instance":1831,"id":205174,"goal":"lemma SetUnionComm_1831(S: set, B: set)\n ensures S + B == B + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_1832","instance":1832,"id":205175,"goal":"lemma SetInterComm_1832(T: set, S: set)\n ensures T * S == S * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_1833","instance":1833,"id":205176,"goal":"lemma SetUnionAssoc_1833(T: set, S: set, U: set)\n ensures (T + S) + U == T + (S + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_1834","instance":1834,"id":205177,"goal":"lemma SetSubsetRefl_1834(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_1835","instance":1835,"id":205178,"goal":"lemma SetSubsetTrans_1835(A: set, S: set, B: set)\n requires A <= S && S <= B\n ensures A <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_1836","instance":1836,"id":205179,"goal":"lemma SetUnionEmpty_1836(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_1837","instance":1837,"id":205180,"goal":"lemma SetInterEmpty_1837(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_1838","instance":1838,"id":205181,"goal":"lemma SetInterSubset_1838(S: set, A: set)\n ensures S * A <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_1839","instance":1839,"id":205182,"goal":"lemma SetCardSubset_1839(S: set, U: set)\n requires S <= U\n ensures |S| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_1840","instance":1840,"id":205183,"goal":"lemma SetUnionCard_1840(T: set, B: set)\n requires T * B == {}\n ensures |T + B| == |T| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_1841","instance":1841,"id":205184,"goal":"lemma SetUnionComm_1841(A: set, T: set)\n ensures A + T == T + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_1842","instance":1842,"id":205185,"goal":"lemma SetInterComm_1842(T: set, U: set)\n ensures T * U == U * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_1843","instance":1843,"id":205186,"goal":"lemma SetUnionAssoc_1843(U: set, T: set, A: set)\n ensures (U + T) + A == U + (T + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_1844","instance":1844,"id":205187,"goal":"lemma SetSubsetRefl_1844(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_1845","instance":1845,"id":205188,"goal":"lemma SetSubsetTrans_1845(T: set, S: set, B: set)\n requires T <= S && S <= B\n ensures T <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_1846","instance":1846,"id":205189,"goal":"lemma SetUnionEmpty_1846(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_1847","instance":1847,"id":205190,"goal":"lemma SetInterEmpty_1847(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_1848","instance":1848,"id":205191,"goal":"lemma SetInterSubset_1848(S: set, B: set)\n ensures S * B <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_1849","instance":1849,"id":205192,"goal":"lemma SetCardSubset_1849(A: set, T: set)\n requires A <= T\n ensures |A| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_1850","instance":1850,"id":205193,"goal":"lemma SetUnionCard_1850(U: set, T: set)\n requires U * T == {}\n ensures |U + T| == |U| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_1851","instance":1851,"id":205194,"goal":"lemma SetUnionComm_1851(A: set, T: set)\n ensures A + T == T + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_1852","instance":1852,"id":205195,"goal":"lemma SetInterComm_1852(T: set, A: set)\n ensures T * A == A * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_1853","instance":1853,"id":205196,"goal":"lemma SetUnionAssoc_1853(S: set, U: set, T: set)\n ensures (S + U) + T == S + (U + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_1854","instance":1854,"id":205197,"goal":"lemma SetSubsetRefl_1854(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_1855","instance":1855,"id":205198,"goal":"lemma SetSubsetTrans_1855(S: set, A: set, B: set)\n requires S <= A && A <= B\n ensures S <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_1856","instance":1856,"id":205199,"goal":"lemma SetUnionEmpty_1856(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_1857","instance":1857,"id":205200,"goal":"lemma SetInterEmpty_1857(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_1858","instance":1858,"id":205201,"goal":"lemma SetInterSubset_1858(U: set, S: set)\n ensures U * S <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_1859","instance":1859,"id":205202,"goal":"lemma SetCardSubset_1859(B: set, A: set)\n requires B <= A\n ensures |B| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_1860","instance":1860,"id":205203,"goal":"lemma SetUnionCard_1860(T: set, A: set)\n requires T * A == {}\n ensures |T + A| == |T| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_1861","instance":1861,"id":205204,"goal":"lemma SetUnionComm_1861(U: set, B: set)\n ensures U + B == B + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_1862","instance":1862,"id":205205,"goal":"lemma SetInterComm_1862(U: set, A: set)\n ensures U * A == A * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_1863","instance":1863,"id":205206,"goal":"lemma SetUnionAssoc_1863(S: set, A: set, B: set)\n ensures (S + A) + B == S + (A + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_1864","instance":1864,"id":205207,"goal":"lemma SetSubsetRefl_1864(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_1865","instance":1865,"id":205208,"goal":"lemma SetSubsetTrans_1865(T: set, U: set, A: set)\n requires T <= U && U <= A\n ensures T <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_1866","instance":1866,"id":205209,"goal":"lemma SetUnionEmpty_1866(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_1867","instance":1867,"id":205210,"goal":"lemma SetInterEmpty_1867(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_1868","instance":1868,"id":205211,"goal":"lemma SetInterSubset_1868(A: set, B: set)\n ensures A * B <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_1869","instance":1869,"id":205212,"goal":"lemma SetCardSubset_1869(U: set, T: set)\n requires U <= T\n ensures |U| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_1870","instance":1870,"id":205213,"goal":"lemma SetUnionCard_1870(T: set, S: set)\n requires T * S == {}\n ensures |T + S| == |T| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_1871","instance":1871,"id":205214,"goal":"lemma SetUnionComm_1871(T: set, A: set)\n ensures T + A == A + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_1872","instance":1872,"id":205215,"goal":"lemma SetInterComm_1872(A: set, S: set)\n ensures A * S == S * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_1873","instance":1873,"id":205216,"goal":"lemma SetUnionAssoc_1873(A: set, B: set, U: set)\n ensures (A + B) + U == A + (B + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_1874","instance":1874,"id":205217,"goal":"lemma SetSubsetRefl_1874(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_1875","instance":1875,"id":205218,"goal":"lemma SetSubsetTrans_1875(A: set, U: set, B: set)\n requires A <= U && U <= B\n ensures A <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_1876","instance":1876,"id":205219,"goal":"lemma SetUnionEmpty_1876(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_1877","instance":1877,"id":205220,"goal":"lemma SetInterEmpty_1877(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_1878","instance":1878,"id":205221,"goal":"lemma SetInterSubset_1878(U: set, T: set)\n ensures U * T <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_1879","instance":1879,"id":205222,"goal":"lemma SetCardSubset_1879(B: set, U: set)\n requires B <= U\n ensures |B| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_1880","instance":1880,"id":205223,"goal":"lemma SetUnionCard_1880(S: set, B: set)\n requires S * B == {}\n ensures |S + B| == |S| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_1881","instance":1881,"id":205224,"goal":"lemma SetUnionComm_1881(S: set, B: set)\n ensures S + B == B + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_1882","instance":1882,"id":205225,"goal":"lemma SetInterComm_1882(S: set, U: set)\n ensures S * U == U * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_1883","instance":1883,"id":205226,"goal":"lemma SetUnionAssoc_1883(B: set, T: set, U: set)\n ensures (B + T) + U == B + (T + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_1884","instance":1884,"id":205227,"goal":"lemma SetSubsetRefl_1884(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_1885","instance":1885,"id":205228,"goal":"lemma SetSubsetTrans_1885(B: set, S: set, U: set)\n requires B <= S && S <= U\n ensures B <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_1886","instance":1886,"id":205229,"goal":"lemma SetUnionEmpty_1886(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_1887","instance":1887,"id":205230,"goal":"lemma SetInterEmpty_1887(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_1888","instance":1888,"id":205231,"goal":"lemma SetInterSubset_1888(U: set, B: set)\n ensures U * B <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_1889","instance":1889,"id":205232,"goal":"lemma SetCardSubset_1889(B: set, S: set)\n requires B <= S\n ensures |B| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_1890","instance":1890,"id":205233,"goal":"lemma SetUnionCard_1890(T: set, B: set)\n requires T * B == {}\n ensures |T + B| == |T| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_1891","instance":1891,"id":205234,"goal":"lemma SetUnionComm_1891(U: set, T: set)\n ensures U + T == T + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_1892","instance":1892,"id":205235,"goal":"lemma SetInterComm_1892(T: set, U: set)\n ensures T * U == U * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_1893","instance":1893,"id":205236,"goal":"lemma SetUnionAssoc_1893(U: set, T: set, S: set)\n ensures (U + T) + S == U + (T + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_1894","instance":1894,"id":205237,"goal":"lemma SetSubsetRefl_1894(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_1895","instance":1895,"id":205238,"goal":"lemma SetSubsetTrans_1895(B: set, A: set, S: set)\n requires B <= A && A <= S\n ensures B <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_1896","instance":1896,"id":205239,"goal":"lemma SetUnionEmpty_1896(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_1897","instance":1897,"id":205240,"goal":"lemma SetInterEmpty_1897(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_1898","instance":1898,"id":205241,"goal":"lemma SetInterSubset_1898(B: set, U: set)\n ensures B * U <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_1899","instance":1899,"id":205242,"goal":"lemma SetCardSubset_1899(A: set, U: set)\n requires A <= U\n ensures |A| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_1900","instance":1900,"id":205243,"goal":"lemma SetUnionCard_1900(B: set, U: set)\n requires B * U == {}\n ensures |B + U| == |B| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_1901","instance":1901,"id":205244,"goal":"lemma SetUnionComm_1901(S: set, U: set)\n ensures S + U == U + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_1902","instance":1902,"id":205245,"goal":"lemma SetInterComm_1902(T: set, S: set)\n ensures T * S == S * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_1903","instance":1903,"id":205246,"goal":"lemma SetUnionAssoc_1903(A: set, B: set, U: set)\n ensures (A + B) + U == A + (B + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_1904","instance":1904,"id":205247,"goal":"lemma SetSubsetRefl_1904(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_1905","instance":1905,"id":205248,"goal":"lemma SetSubsetTrans_1905(B: set, T: set, S: set)\n requires B <= T && T <= S\n ensures B <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_1906","instance":1906,"id":205249,"goal":"lemma SetUnionEmpty_1906(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_1907","instance":1907,"id":205250,"goal":"lemma SetInterEmpty_1907(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_1908","instance":1908,"id":205251,"goal":"lemma SetInterSubset_1908(U: set, T: set)\n ensures U * T <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_1909","instance":1909,"id":205252,"goal":"lemma SetCardSubset_1909(T: set, U: set)\n requires T <= U\n ensures |T| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_1910","instance":1910,"id":205253,"goal":"lemma SetUnionCard_1910(T: set, A: set)\n requires T * A == {}\n ensures |T + A| == |T| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_1911","instance":1911,"id":205254,"goal":"lemma SetUnionComm_1911(S: set, T: set)\n ensures S + T == T + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_1912","instance":1912,"id":205255,"goal":"lemma SetInterComm_1912(U: set, T: set)\n ensures U * T == T * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_1913","instance":1913,"id":205256,"goal":"lemma SetUnionAssoc_1913(T: set, S: set, U: set)\n ensures (T + S) + U == T + (S + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_1914","instance":1914,"id":205257,"goal":"lemma SetSubsetRefl_1914(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_1915","instance":1915,"id":205258,"goal":"lemma SetSubsetTrans_1915(T: set, S: set, A: set)\n requires T <= S && S <= A\n ensures T <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_1916","instance":1916,"id":205259,"goal":"lemma SetUnionEmpty_1916(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_1917","instance":1917,"id":205260,"goal":"lemma SetInterEmpty_1917(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_1918","instance":1918,"id":205261,"goal":"lemma SetInterSubset_1918(A: set, B: set)\n ensures A * B <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_1919","instance":1919,"id":205262,"goal":"lemma SetCardSubset_1919(S: set, B: set)\n requires S <= B\n ensures |S| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_1920","instance":1920,"id":205263,"goal":"lemma SetUnionCard_1920(U: set, B: set)\n requires U * B == {}\n ensures |U + B| == |U| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_1921","instance":1921,"id":205264,"goal":"lemma SetUnionComm_1921(U: set, S: set)\n ensures U + S == S + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_1922","instance":1922,"id":205265,"goal":"lemma SetInterComm_1922(T: set, S: set)\n ensures T * S == S * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_1923","instance":1923,"id":205266,"goal":"lemma SetUnionAssoc_1923(T: set, U: set, A: set)\n ensures (T + U) + A == T + (U + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_1924","instance":1924,"id":205267,"goal":"lemma SetSubsetRefl_1924(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_1925","instance":1925,"id":205268,"goal":"lemma SetSubsetTrans_1925(S: set, U: set, T: set)\n requires S <= U && U <= T\n ensures S <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_1926","instance":1926,"id":205269,"goal":"lemma SetUnionEmpty_1926(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_1927","instance":1927,"id":205270,"goal":"lemma SetInterEmpty_1927(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_1928","instance":1928,"id":205271,"goal":"lemma SetInterSubset_1928(A: set, T: set)\n ensures A * T <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_1929","instance":1929,"id":205272,"goal":"lemma SetCardSubset_1929(B: set, T: set)\n requires B <= T\n ensures |B| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_1930","instance":1930,"id":205273,"goal":"lemma SetUnionCard_1930(A: set, U: set)\n requires A * U == {}\n ensures |A + U| == |A| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_1931","instance":1931,"id":205274,"goal":"lemma SetUnionComm_1931(S: set, T: set)\n ensures S + T == T + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_1932","instance":1932,"id":205275,"goal":"lemma SetInterComm_1932(A: set, T: set)\n ensures A * T == T * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_1933","instance":1933,"id":205276,"goal":"lemma SetUnionAssoc_1933(S: set, U: set, A: set)\n ensures (S + U) + A == S + (U + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_1934","instance":1934,"id":205277,"goal":"lemma SetSubsetRefl_1934(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_1935","instance":1935,"id":205278,"goal":"lemma SetSubsetTrans_1935(U: set, B: set, S: set)\n requires U <= B && B <= S\n ensures U <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_1936","instance":1936,"id":205279,"goal":"lemma SetUnionEmpty_1936(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_1937","instance":1937,"id":205280,"goal":"lemma SetInterEmpty_1937(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_1938","instance":1938,"id":205281,"goal":"lemma SetInterSubset_1938(S: set, U: set)\n ensures S * U <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_1939","instance":1939,"id":205282,"goal":"lemma SetCardSubset_1939(B: set, T: set)\n requires B <= T\n ensures |B| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_1940","instance":1940,"id":205283,"goal":"lemma SetUnionCard_1940(S: set, B: set)\n requires S * B == {}\n ensures |S + B| == |S| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_1941","instance":1941,"id":205284,"goal":"lemma SetUnionComm_1941(S: set, A: set)\n ensures S + A == A + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_1942","instance":1942,"id":205285,"goal":"lemma SetInterComm_1942(B: set, S: set)\n ensures B * S == S * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_1943","instance":1943,"id":205286,"goal":"lemma SetUnionAssoc_1943(A: set, S: set, B: set)\n ensures (A + S) + B == A + (S + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_1944","instance":1944,"id":205287,"goal":"lemma SetSubsetRefl_1944(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_1945","instance":1945,"id":205288,"goal":"lemma SetSubsetTrans_1945(A: set, B: set, U: set)\n requires A <= B && B <= U\n ensures A <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_1946","instance":1946,"id":205289,"goal":"lemma SetUnionEmpty_1946(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_1947","instance":1947,"id":205290,"goal":"lemma SetInterEmpty_1947(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_1948","instance":1948,"id":205291,"goal":"lemma SetInterSubset_1948(A: set, U: set)\n ensures A * U <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_1949","instance":1949,"id":205292,"goal":"lemma SetCardSubset_1949(A: set, T: set)\n requires A <= T\n ensures |A| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_1950","instance":1950,"id":205293,"goal":"lemma SetUnionCard_1950(S: set, T: set)\n requires S * T == {}\n ensures |S + T| == |S| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_1951","instance":1951,"id":205294,"goal":"lemma SetUnionComm_1951(U: set, T: set)\n ensures U + T == T + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_1952","instance":1952,"id":205295,"goal":"lemma SetInterComm_1952(T: set, S: set)\n ensures T * S == S * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_1953","instance":1953,"id":205296,"goal":"lemma SetUnionAssoc_1953(U: set, S: set, B: set)\n ensures (U + S) + B == U + (S + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_1954","instance":1954,"id":205297,"goal":"lemma SetSubsetRefl_1954(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_1955","instance":1955,"id":205298,"goal":"lemma SetSubsetTrans_1955(S: set, A: set, B: set)\n requires S <= A && A <= B\n ensures S <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_1956","instance":1956,"id":205299,"goal":"lemma SetUnionEmpty_1956(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_1957","instance":1957,"id":205300,"goal":"lemma SetInterEmpty_1957(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_1958","instance":1958,"id":205301,"goal":"lemma SetInterSubset_1958(T: set, U: set)\n ensures T * U <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_1959","instance":1959,"id":205302,"goal":"lemma SetCardSubset_1959(A: set, S: set)\n requires A <= S\n ensures |A| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_1960","instance":1960,"id":205303,"goal":"lemma SetUnionCard_1960(S: set, U: set)\n requires S * U == {}\n ensures |S + U| == |S| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_1961","instance":1961,"id":205304,"goal":"lemma SetUnionComm_1961(U: set, B: set)\n ensures U + B == B + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_1962","instance":1962,"id":205305,"goal":"lemma SetInterComm_1962(U: set, A: set)\n ensures U * A == A * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_1963","instance":1963,"id":205306,"goal":"lemma SetUnionAssoc_1963(B: set, S: set, T: set)\n ensures (B + S) + T == B + (S + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_1964","instance":1964,"id":205307,"goal":"lemma SetSubsetRefl_1964(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_1965","instance":1965,"id":205308,"goal":"lemma SetSubsetTrans_1965(S: set, T: set, B: set)\n requires S <= T && T <= B\n ensures S <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_1966","instance":1966,"id":205309,"goal":"lemma SetUnionEmpty_1966(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_1967","instance":1967,"id":205310,"goal":"lemma SetInterEmpty_1967(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_1968","instance":1968,"id":205311,"goal":"lemma SetInterSubset_1968(A: set, B: set)\n ensures A * B <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_1969","instance":1969,"id":205312,"goal":"lemma SetCardSubset_1969(A: set, T: set)\n requires A <= T\n ensures |A| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_1970","instance":1970,"id":205313,"goal":"lemma SetUnionCard_1970(T: set, B: set)\n requires T * B == {}\n ensures |T + B| == |T| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_1971","instance":1971,"id":205314,"goal":"lemma SetUnionComm_1971(U: set, B: set)\n ensures U + B == B + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_1972","instance":1972,"id":205315,"goal":"lemma SetInterComm_1972(B: set, T: set)\n ensures B * T == T * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_1973","instance":1973,"id":205316,"goal":"lemma SetUnionAssoc_1973(T: set, B: set, A: set)\n ensures (T + B) + A == T + (B + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_1974","instance":1974,"id":205317,"goal":"lemma SetSubsetRefl_1974(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_1975","instance":1975,"id":205318,"goal":"lemma SetSubsetTrans_1975(B: set, U: set, S: set)\n requires B <= U && U <= S\n ensures B <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_1976","instance":1976,"id":205319,"goal":"lemma SetUnionEmpty_1976(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_1977","instance":1977,"id":205320,"goal":"lemma SetInterEmpty_1977(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_1978","instance":1978,"id":205321,"goal":"lemma SetInterSubset_1978(U: set, S: set)\n ensures U * S <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_1979","instance":1979,"id":205322,"goal":"lemma SetCardSubset_1979(U: set, A: set)\n requires U <= A\n ensures |U| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_1980","instance":1980,"id":205323,"goal":"lemma SetUnionCard_1980(S: set, U: set)\n requires S * U == {}\n ensures |S + U| == |S| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_1981","instance":1981,"id":205324,"goal":"lemma SetUnionComm_1981(U: set, B: set)\n ensures U + B == B + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_1982","instance":1982,"id":205325,"goal":"lemma SetInterComm_1982(A: set, S: set)\n ensures A * S == S * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_1983","instance":1983,"id":205326,"goal":"lemma SetUnionAssoc_1983(B: set, S: set, A: set)\n ensures (B + S) + A == B + (S + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_1984","instance":1984,"id":205327,"goal":"lemma SetSubsetRefl_1984(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_1985","instance":1985,"id":205328,"goal":"lemma SetSubsetTrans_1985(A: set, B: set, T: set)\n requires A <= B && B <= T\n ensures A <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_1986","instance":1986,"id":205329,"goal":"lemma SetUnionEmpty_1986(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_1987","instance":1987,"id":205330,"goal":"lemma SetInterEmpty_1987(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_1988","instance":1988,"id":205331,"goal":"lemma SetInterSubset_1988(B: set, S: set)\n ensures B * S <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_1989","instance":1989,"id":205332,"goal":"lemma SetCardSubset_1989(T: set, A: set)\n requires T <= A\n ensures |T| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_1990","instance":1990,"id":205333,"goal":"lemma SetUnionCard_1990(S: set, A: set)\n requires S * A == {}\n ensures |S + A| == |S| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_1991","instance":1991,"id":205334,"goal":"lemma SetUnionComm_1991(B: set, A: set)\n ensures B + A == A + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_1992","instance":1992,"id":205335,"goal":"lemma SetInterComm_1992(U: set, T: set)\n ensures U * T == T * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_1993","instance":1993,"id":205336,"goal":"lemma SetUnionAssoc_1993(A: set, B: set, U: set)\n ensures (A + B) + U == A + (B + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_1994","instance":1994,"id":205337,"goal":"lemma SetSubsetRefl_1994(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_1995","instance":1995,"id":205338,"goal":"lemma SetSubsetTrans_1995(A: set, S: set, U: set)\n requires A <= S && S <= U\n ensures A <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_1996","instance":1996,"id":205339,"goal":"lemma SetUnionEmpty_1996(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_1997","instance":1997,"id":205340,"goal":"lemma SetInterEmpty_1997(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_1998","instance":1998,"id":205341,"goal":"lemma SetInterSubset_1998(A: set, B: set)\n ensures A * B <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_1999","instance":1999,"id":205342,"goal":"lemma SetCardSubset_1999(B: set, S: set)\n requires B <= S\n ensures |B| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_2000","instance":2000,"id":205343,"goal":"lemma SetUnionCard_2000(A: set, T: set)\n requires A * T == {}\n ensures |A + T| == |A| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_2001","instance":2001,"id":205344,"goal":"lemma SetUnionComm_2001(T: set, S: set)\n ensures T + S == S + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_2002","instance":2002,"id":205345,"goal":"lemma SetInterComm_2002(A: set, U: set)\n ensures A * U == U * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_2003","instance":2003,"id":205346,"goal":"lemma SetUnionAssoc_2003(S: set, U: set, T: set)\n ensures (S + U) + T == S + (U + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_2004","instance":2004,"id":205347,"goal":"lemma SetSubsetRefl_2004(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_2005","instance":2005,"id":205348,"goal":"lemma SetSubsetTrans_2005(S: set, A: set, T: set)\n requires S <= A && A <= T\n ensures S <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_2006","instance":2006,"id":205349,"goal":"lemma SetUnionEmpty_2006(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_2007","instance":2007,"id":205350,"goal":"lemma SetInterEmpty_2007(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_2008","instance":2008,"id":205351,"goal":"lemma SetInterSubset_2008(A: set, B: set)\n ensures A * B <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_2009","instance":2009,"id":205352,"goal":"lemma SetCardSubset_2009(A: set, T: set)\n requires A <= T\n ensures |A| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_2010","instance":2010,"id":205353,"goal":"lemma SetUnionCard_2010(A: set, U: set)\n requires A * U == {}\n ensures |A + U| == |A| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_2011","instance":2011,"id":205354,"goal":"lemma SetUnionComm_2011(T: set, U: set)\n ensures T + U == U + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_2012","instance":2012,"id":205355,"goal":"lemma SetInterComm_2012(U: set, T: set)\n ensures U * T == T * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_2013","instance":2013,"id":205356,"goal":"lemma SetUnionAssoc_2013(B: set, T: set, S: set)\n ensures (B + T) + S == B + (T + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_2014","instance":2014,"id":205357,"goal":"lemma SetSubsetRefl_2014(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_2015","instance":2015,"id":205358,"goal":"lemma SetSubsetTrans_2015(S: set, T: set, U: set)\n requires S <= T && T <= U\n ensures S <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_2016","instance":2016,"id":205359,"goal":"lemma SetUnionEmpty_2016(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_2017","instance":2017,"id":205360,"goal":"lemma SetInterEmpty_2017(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_2018","instance":2018,"id":205361,"goal":"lemma SetInterSubset_2018(T: set, S: set)\n ensures T * S <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_2019","instance":2019,"id":205362,"goal":"lemma SetCardSubset_2019(S: set, B: set)\n requires S <= B\n ensures |S| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_2020","instance":2020,"id":205363,"goal":"lemma SetUnionCard_2020(U: set, A: set)\n requires U * A == {}\n ensures |U + A| == |U| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_2021","instance":2021,"id":205364,"goal":"lemma SetUnionComm_2021(T: set, A: set)\n ensures T + A == A + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_2022","instance":2022,"id":205365,"goal":"lemma SetInterComm_2022(T: set, A: set)\n ensures T * A == A * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_2023","instance":2023,"id":205366,"goal":"lemma SetUnionAssoc_2023(S: set, T: set, B: set)\n ensures (S + T) + B == S + (T + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_2024","instance":2024,"id":205367,"goal":"lemma SetSubsetRefl_2024(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_2025","instance":2025,"id":205368,"goal":"lemma SetSubsetTrans_2025(S: set, B: set, A: set)\n requires S <= B && B <= A\n ensures S <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_2026","instance":2026,"id":205369,"goal":"lemma SetUnionEmpty_2026(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_2027","instance":2027,"id":205370,"goal":"lemma SetInterEmpty_2027(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_2028","instance":2028,"id":205371,"goal":"lemma SetInterSubset_2028(S: set, U: set)\n ensures S * U <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_2029","instance":2029,"id":205372,"goal":"lemma SetCardSubset_2029(T: set, S: set)\n requires T <= S\n ensures |T| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_2030","instance":2030,"id":205373,"goal":"lemma SetUnionCard_2030(U: set, S: set)\n requires U * S == {}\n ensures |U + S| == |U| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_2031","instance":2031,"id":205374,"goal":"lemma SetUnionComm_2031(A: set, T: set)\n ensures A + T == T + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_2032","instance":2032,"id":205375,"goal":"lemma SetInterComm_2032(S: set, B: set)\n ensures S * B == B * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_2033","instance":2033,"id":205376,"goal":"lemma SetUnionAssoc_2033(A: set, U: set, S: set)\n ensures (A + U) + S == A + (U + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_2034","instance":2034,"id":205377,"goal":"lemma SetSubsetRefl_2034(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_2035","instance":2035,"id":205378,"goal":"lemma SetSubsetTrans_2035(A: set, S: set, T: set)\n requires A <= S && S <= T\n ensures A <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_2036","instance":2036,"id":205379,"goal":"lemma SetUnionEmpty_2036(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_2037","instance":2037,"id":205380,"goal":"lemma SetInterEmpty_2037(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_2038","instance":2038,"id":205381,"goal":"lemma SetInterSubset_2038(B: set, S: set)\n ensures B * S <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_2039","instance":2039,"id":205382,"goal":"lemma SetCardSubset_2039(T: set, B: set)\n requires T <= B\n ensures |T| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_2040","instance":2040,"id":205383,"goal":"lemma SetUnionCard_2040(U: set, A: set)\n requires U * A == {}\n ensures |U + A| == |U| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_2041","instance":2041,"id":205384,"goal":"lemma SetUnionComm_2041(B: set, U: set)\n ensures B + U == U + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_2042","instance":2042,"id":205385,"goal":"lemma SetInterComm_2042(B: set, T: set)\n ensures B * T == T * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_2043","instance":2043,"id":205386,"goal":"lemma SetUnionAssoc_2043(U: set, B: set, A: set)\n ensures (U + B) + A == U + (B + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_2044","instance":2044,"id":205387,"goal":"lemma SetSubsetRefl_2044(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_2045","instance":2045,"id":205388,"goal":"lemma SetSubsetTrans_2045(T: set, S: set, U: set)\n requires T <= S && S <= U\n ensures T <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_2046","instance":2046,"id":205389,"goal":"lemma SetUnionEmpty_2046(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_2047","instance":2047,"id":205390,"goal":"lemma SetInterEmpty_2047(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_2048","instance":2048,"id":205391,"goal":"lemma SetInterSubset_2048(U: set, T: set)\n ensures U * T <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_2049","instance":2049,"id":205392,"goal":"lemma SetCardSubset_2049(A: set, T: set)\n requires A <= T\n ensures |A| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_2050","instance":2050,"id":205393,"goal":"lemma SetUnionCard_2050(A: set, S: set)\n requires A * S == {}\n ensures |A + S| == |A| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_2051","instance":2051,"id":205394,"goal":"lemma SetUnionComm_2051(A: set, B: set)\n ensures A + B == B + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_2052","instance":2052,"id":205395,"goal":"lemma SetInterComm_2052(T: set, S: set)\n ensures T * S == S * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_2053","instance":2053,"id":205396,"goal":"lemma SetUnionAssoc_2053(U: set, T: set, A: set)\n ensures (U + T) + A == U + (T + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_2054","instance":2054,"id":205397,"goal":"lemma SetSubsetRefl_2054(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_2055","instance":2055,"id":205398,"goal":"lemma SetSubsetTrans_2055(T: set, A: set, B: set)\n requires T <= A && A <= B\n ensures T <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_2056","instance":2056,"id":205399,"goal":"lemma SetUnionEmpty_2056(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_2057","instance":2057,"id":205400,"goal":"lemma SetInterEmpty_2057(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_2058","instance":2058,"id":205401,"goal":"lemma SetInterSubset_2058(A: set, T: set)\n ensures A * T <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_2059","instance":2059,"id":205402,"goal":"lemma SetCardSubset_2059(B: set, A: set)\n requires B <= A\n ensures |B| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_2060","instance":2060,"id":205403,"goal":"lemma SetUnionCard_2060(T: set, A: set)\n requires T * A == {}\n ensures |T + A| == |T| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_2061","instance":2061,"id":205404,"goal":"lemma SetUnionComm_2061(B: set, A: set)\n ensures B + A == A + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_2062","instance":2062,"id":205405,"goal":"lemma SetInterComm_2062(U: set, A: set)\n ensures U * A == A * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_2063","instance":2063,"id":205406,"goal":"lemma SetUnionAssoc_2063(B: set, A: set, U: set)\n ensures (B + A) + U == B + (A + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_2064","instance":2064,"id":205407,"goal":"lemma SetSubsetRefl_2064(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_2065","instance":2065,"id":205408,"goal":"lemma SetSubsetTrans_2065(B: set, T: set, U: set)\n requires B <= T && T <= U\n ensures B <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_2066","instance":2066,"id":205409,"goal":"lemma SetUnionEmpty_2066(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_2067","instance":2067,"id":205410,"goal":"lemma SetInterEmpty_2067(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_2068","instance":2068,"id":205411,"goal":"lemma SetInterSubset_2068(T: set, B: set)\n ensures T * B <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_2069","instance":2069,"id":205412,"goal":"lemma SetCardSubset_2069(B: set, A: set)\n requires B <= A\n ensures |B| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_2070","instance":2070,"id":205413,"goal":"lemma SetUnionCard_2070(S: set, U: set)\n requires S * U == {}\n ensures |S + U| == |S| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_2071","instance":2071,"id":205414,"goal":"lemma SetUnionComm_2071(T: set, B: set)\n ensures T + B == B + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_2072","instance":2072,"id":205415,"goal":"lemma SetInterComm_2072(A: set, T: set)\n ensures A * T == T * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_2073","instance":2073,"id":205416,"goal":"lemma SetUnionAssoc_2073(B: set, S: set, T: set)\n ensures (B + S) + T == B + (S + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_2074","instance":2074,"id":205417,"goal":"lemma SetSubsetRefl_2074(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_2075","instance":2075,"id":205418,"goal":"lemma SetSubsetTrans_2075(U: set, T: set, S: set)\n requires U <= T && T <= S\n ensures U <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_2076","instance":2076,"id":205419,"goal":"lemma SetUnionEmpty_2076(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_2077","instance":2077,"id":205420,"goal":"lemma SetInterEmpty_2077(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_2078","instance":2078,"id":205421,"goal":"lemma SetInterSubset_2078(A: set, T: set)\n ensures A * T <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_2079","instance":2079,"id":205422,"goal":"lemma SetCardSubset_2079(A: set, S: set)\n requires A <= S\n ensures |A| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_2080","instance":2080,"id":205423,"goal":"lemma SetUnionCard_2080(U: set, A: set)\n requires U * A == {}\n ensures |U + A| == |U| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_2081","instance":2081,"id":205424,"goal":"lemma SetUnionComm_2081(T: set, S: set)\n ensures T + S == S + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_2082","instance":2082,"id":205425,"goal":"lemma SetInterComm_2082(B: set, T: set)\n ensures B * T == T * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_2083","instance":2083,"id":205426,"goal":"lemma SetUnionAssoc_2083(A: set, S: set, U: set)\n ensures (A + S) + U == A + (S + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_2084","instance":2084,"id":205427,"goal":"lemma SetSubsetRefl_2084(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_2085","instance":2085,"id":205428,"goal":"lemma SetSubsetTrans_2085(U: set, S: set, T: set)\n requires U <= S && S <= T\n ensures U <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_2086","instance":2086,"id":205429,"goal":"lemma SetUnionEmpty_2086(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_2087","instance":2087,"id":205430,"goal":"lemma SetInterEmpty_2087(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_2088","instance":2088,"id":205431,"goal":"lemma SetInterSubset_2088(S: set, T: set)\n ensures S * T <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_2089","instance":2089,"id":205432,"goal":"lemma SetCardSubset_2089(S: set, T: set)\n requires S <= T\n ensures |S| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_2090","instance":2090,"id":205433,"goal":"lemma SetUnionCard_2090(A: set, S: set)\n requires A * S == {}\n ensures |A + S| == |A| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_2091","instance":2091,"id":205434,"goal":"lemma SetUnionComm_2091(A: set, U: set)\n ensures A + U == U + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_2092","instance":2092,"id":205435,"goal":"lemma SetInterComm_2092(B: set, U: set)\n ensures B * U == U * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_2093","instance":2093,"id":205436,"goal":"lemma SetUnionAssoc_2093(A: set, U: set, T: set)\n ensures (A + U) + T == A + (U + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_2094","instance":2094,"id":205437,"goal":"lemma SetSubsetRefl_2094(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_2095","instance":2095,"id":205438,"goal":"lemma SetSubsetTrans_2095(T: set, S: set, U: set)\n requires T <= S && S <= U\n ensures T <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_2096","instance":2096,"id":205439,"goal":"lemma SetUnionEmpty_2096(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_2097","instance":2097,"id":205440,"goal":"lemma SetInterEmpty_2097(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_2098","instance":2098,"id":205441,"goal":"lemma SetInterSubset_2098(B: set, T: set)\n ensures B * T <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_2099","instance":2099,"id":205442,"goal":"lemma SetCardSubset_2099(T: set, U: set)\n requires T <= U\n ensures |T| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_2100","instance":2100,"id":205443,"goal":"lemma SetUnionCard_2100(A: set, T: set)\n requires A * T == {}\n ensures |A + T| == |A| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_2101","instance":2101,"id":205444,"goal":"lemma SetUnionComm_2101(U: set, B: set)\n ensures U + B == B + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_2102","instance":2102,"id":205445,"goal":"lemma SetInterComm_2102(S: set, B: set)\n ensures S * B == B * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_2103","instance":2103,"id":205446,"goal":"lemma SetUnionAssoc_2103(T: set, S: set, U: set)\n ensures (T + S) + U == T + (S + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_2104","instance":2104,"id":205447,"goal":"lemma SetSubsetRefl_2104(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_2105","instance":2105,"id":205448,"goal":"lemma SetSubsetTrans_2105(U: set, A: set, B: set)\n requires U <= A && A <= B\n ensures U <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_2106","instance":2106,"id":205449,"goal":"lemma SetUnionEmpty_2106(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_2107","instance":2107,"id":205450,"goal":"lemma SetInterEmpty_2107(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_2108","instance":2108,"id":205451,"goal":"lemma SetInterSubset_2108(B: set, T: set)\n ensures B * T <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_2109","instance":2109,"id":205452,"goal":"lemma SetCardSubset_2109(B: set, T: set)\n requires B <= T\n ensures |B| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_2110","instance":2110,"id":205453,"goal":"lemma SetUnionCard_2110(S: set, T: set)\n requires S * T == {}\n ensures |S + T| == |S| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_2111","instance":2111,"id":205454,"goal":"lemma SetUnionComm_2111(B: set, T: set)\n ensures B + T == T + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_2112","instance":2112,"id":205455,"goal":"lemma SetInterComm_2112(U: set, T: set)\n ensures U * T == T * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_2113","instance":2113,"id":205456,"goal":"lemma SetUnionAssoc_2113(U: set, S: set, A: set)\n ensures (U + S) + A == U + (S + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_2114","instance":2114,"id":205457,"goal":"lemma SetSubsetRefl_2114(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_2115","instance":2115,"id":205458,"goal":"lemma SetSubsetTrans_2115(A: set, T: set, B: set)\n requires A <= T && T <= B\n ensures A <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_2116","instance":2116,"id":205459,"goal":"lemma SetUnionEmpty_2116(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_2117","instance":2117,"id":205460,"goal":"lemma SetInterEmpty_2117(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_2118","instance":2118,"id":205461,"goal":"lemma SetInterSubset_2118(U: set, A: set)\n ensures U * A <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_2119","instance":2119,"id":205462,"goal":"lemma SetCardSubset_2119(T: set, A: set)\n requires T <= A\n ensures |T| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_2120","instance":2120,"id":205463,"goal":"lemma SetUnionCard_2120(S: set, U: set)\n requires S * U == {}\n ensures |S + U| == |S| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_2121","instance":2121,"id":205464,"goal":"lemma SetUnionComm_2121(B: set, T: set)\n ensures B + T == T + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_2122","instance":2122,"id":205465,"goal":"lemma SetInterComm_2122(S: set, U: set)\n ensures S * U == U * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_2123","instance":2123,"id":205466,"goal":"lemma SetUnionAssoc_2123(T: set, U: set, A: set)\n ensures (T + U) + A == T + (U + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_2124","instance":2124,"id":205467,"goal":"lemma SetSubsetRefl_2124(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_2125","instance":2125,"id":205468,"goal":"lemma SetSubsetTrans_2125(U: set, A: set, S: set)\n requires U <= A && A <= S\n ensures U <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_2126","instance":2126,"id":205469,"goal":"lemma SetUnionEmpty_2126(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_2127","instance":2127,"id":205470,"goal":"lemma SetInterEmpty_2127(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_2128","instance":2128,"id":205471,"goal":"lemma SetInterSubset_2128(A: set, T: set)\n ensures A * T <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_2129","instance":2129,"id":205472,"goal":"lemma SetCardSubset_2129(U: set, A: set)\n requires U <= A\n ensures |U| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_2130","instance":2130,"id":205473,"goal":"lemma SetUnionCard_2130(S: set, B: set)\n requires S * B == {}\n ensures |S + B| == |S| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_2131","instance":2131,"id":205474,"goal":"lemma SetUnionComm_2131(S: set, B: set)\n ensures S + B == B + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_2132","instance":2132,"id":205475,"goal":"lemma SetInterComm_2132(A: set, U: set)\n ensures A * U == U * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_2133","instance":2133,"id":205476,"goal":"lemma SetUnionAssoc_2133(U: set, A: set, S: set)\n ensures (U + A) + S == U + (A + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_2134","instance":2134,"id":205477,"goal":"lemma SetSubsetRefl_2134(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_2135","instance":2135,"id":205478,"goal":"lemma SetSubsetTrans_2135(B: set, U: set, T: set)\n requires B <= U && U <= T\n ensures B <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_2136","instance":2136,"id":205479,"goal":"lemma SetUnionEmpty_2136(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_2137","instance":2137,"id":205480,"goal":"lemma SetInterEmpty_2137(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_2138","instance":2138,"id":205481,"goal":"lemma SetInterSubset_2138(A: set, B: set)\n ensures A * B <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_2139","instance":2139,"id":205482,"goal":"lemma SetCardSubset_2139(U: set, B: set)\n requires U <= B\n ensures |U| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_2140","instance":2140,"id":205483,"goal":"lemma SetUnionCard_2140(S: set, A: set)\n requires S * A == {}\n ensures |S + A| == |S| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_2141","instance":2141,"id":205484,"goal":"lemma SetUnionComm_2141(U: set, T: set)\n ensures U + T == T + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_2142","instance":2142,"id":205485,"goal":"lemma SetInterComm_2142(U: set, B: set)\n ensures U * B == B * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_2143","instance":2143,"id":205486,"goal":"lemma SetUnionAssoc_2143(T: set, A: set, S: set)\n ensures (T + A) + S == T + (A + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_2144","instance":2144,"id":205487,"goal":"lemma SetSubsetRefl_2144(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_2145","instance":2145,"id":205488,"goal":"lemma SetSubsetTrans_2145(S: set, B: set, A: set)\n requires S <= B && B <= A\n ensures S <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_2146","instance":2146,"id":205489,"goal":"lemma SetUnionEmpty_2146(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_2147","instance":2147,"id":205490,"goal":"lemma SetInterEmpty_2147(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_2148","instance":2148,"id":205491,"goal":"lemma SetInterSubset_2148(T: set, A: set)\n ensures T * A <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_2149","instance":2149,"id":205492,"goal":"lemma SetCardSubset_2149(S: set, T: set)\n requires S <= T\n ensures |S| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_2150","instance":2150,"id":205493,"goal":"lemma SetUnionCard_2150(B: set, A: set)\n requires B * A == {}\n ensures |B + A| == |B| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_2151","instance":2151,"id":205494,"goal":"lemma SetUnionComm_2151(B: set, S: set)\n ensures B + S == S + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_2152","instance":2152,"id":205495,"goal":"lemma SetInterComm_2152(T: set, A: set)\n ensures T * A == A * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_2153","instance":2153,"id":205496,"goal":"lemma SetUnionAssoc_2153(U: set, S: set, A: set)\n ensures (U + S) + A == U + (S + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_2154","instance":2154,"id":205497,"goal":"lemma SetSubsetRefl_2154(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_2155","instance":2155,"id":205498,"goal":"lemma SetSubsetTrans_2155(S: set, A: set, U: set)\n requires S <= A && A <= U\n ensures S <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_2156","instance":2156,"id":205499,"goal":"lemma SetUnionEmpty_2156(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_2157","instance":2157,"id":205500,"goal":"lemma SetInterEmpty_2157(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_2158","instance":2158,"id":205501,"goal":"lemma SetInterSubset_2158(U: set, T: set)\n ensures U * T <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_2159","instance":2159,"id":205502,"goal":"lemma SetCardSubset_2159(S: set, T: set)\n requires S <= T\n ensures |S| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_2160","instance":2160,"id":205503,"goal":"lemma SetUnionCard_2160(B: set, S: set)\n requires B * S == {}\n ensures |B + S| == |B| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_2161","instance":2161,"id":205504,"goal":"lemma SetUnionComm_2161(S: set, A: set)\n ensures S + A == A + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_2162","instance":2162,"id":205505,"goal":"lemma SetInterComm_2162(U: set, T: set)\n ensures U * T == T * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_2163","instance":2163,"id":205506,"goal":"lemma SetUnionAssoc_2163(T: set, U: set, A: set)\n ensures (T + U) + A == T + (U + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_2164","instance":2164,"id":205507,"goal":"lemma SetSubsetRefl_2164(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_2165","instance":2165,"id":205508,"goal":"lemma SetSubsetTrans_2165(S: set, A: set, T: set)\n requires S <= A && A <= T\n ensures S <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_2166","instance":2166,"id":205509,"goal":"lemma SetUnionEmpty_2166(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_2167","instance":2167,"id":205510,"goal":"lemma SetInterEmpty_2167(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_2168","instance":2168,"id":205511,"goal":"lemma SetInterSubset_2168(S: set, B: set)\n ensures S * B <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_2169","instance":2169,"id":205512,"goal":"lemma SetCardSubset_2169(S: set, U: set)\n requires S <= U\n ensures |S| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_2170","instance":2170,"id":205513,"goal":"lemma SetUnionCard_2170(B: set, A: set)\n requires B * A == {}\n ensures |B + A| == |B| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_2171","instance":2171,"id":205514,"goal":"lemma SetUnionComm_2171(S: set, A: set)\n ensures S + A == A + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_2172","instance":2172,"id":205515,"goal":"lemma SetInterComm_2172(T: set, B: set)\n ensures T * B == B * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_2173","instance":2173,"id":205516,"goal":"lemma SetUnionAssoc_2173(U: set, T: set, A: set)\n ensures (U + T) + A == U + (T + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_2174","instance":2174,"id":205517,"goal":"lemma SetSubsetRefl_2174(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_2175","instance":2175,"id":205518,"goal":"lemma SetSubsetTrans_2175(B: set, A: set, T: set)\n requires B <= A && A <= T\n ensures B <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_2176","instance":2176,"id":205519,"goal":"lemma SetUnionEmpty_2176(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_2177","instance":2177,"id":205520,"goal":"lemma SetInterEmpty_2177(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_2178","instance":2178,"id":205521,"goal":"lemma SetInterSubset_2178(U: set, A: set)\n ensures U * A <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_2179","instance":2179,"id":205522,"goal":"lemma SetCardSubset_2179(U: set, S: set)\n requires U <= S\n ensures |U| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_2180","instance":2180,"id":205523,"goal":"lemma SetUnionCard_2180(A: set, S: set)\n requires A * S == {}\n ensures |A + S| == |A| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_2181","instance":2181,"id":205524,"goal":"lemma SetUnionComm_2181(U: set, A: set)\n ensures U + A == A + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_2182","instance":2182,"id":205525,"goal":"lemma SetInterComm_2182(U: set, S: set)\n ensures U * S == S * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_2183","instance":2183,"id":205526,"goal":"lemma SetUnionAssoc_2183(T: set, B: set, U: set)\n ensures (T + B) + U == T + (B + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_2184","instance":2184,"id":205527,"goal":"lemma SetSubsetRefl_2184(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_2185","instance":2185,"id":205528,"goal":"lemma SetSubsetTrans_2185(T: set, A: set, S: set)\n requires T <= A && A <= S\n ensures T <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_2186","instance":2186,"id":205529,"goal":"lemma SetUnionEmpty_2186(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_2187","instance":2187,"id":205530,"goal":"lemma SetInterEmpty_2187(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_2188","instance":2188,"id":205531,"goal":"lemma SetInterSubset_2188(A: set, U: set)\n ensures A * U <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_2189","instance":2189,"id":205532,"goal":"lemma SetCardSubset_2189(U: set, B: set)\n requires U <= B\n ensures |U| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_2190","instance":2190,"id":205533,"goal":"lemma SetUnionCard_2190(T: set, B: set)\n requires T * B == {}\n ensures |T + B| == |T| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_2191","instance":2191,"id":205534,"goal":"lemma SetUnionComm_2191(S: set, U: set)\n ensures S + U == U + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_2192","instance":2192,"id":205535,"goal":"lemma SetInterComm_2192(U: set, A: set)\n ensures U * A == A * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_2193","instance":2193,"id":205536,"goal":"lemma SetUnionAssoc_2193(B: set, S: set, T: set)\n ensures (B + S) + T == B + (S + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_2194","instance":2194,"id":205537,"goal":"lemma SetSubsetRefl_2194(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_2195","instance":2195,"id":205538,"goal":"lemma SetSubsetTrans_2195(A: set, T: set, B: set)\n requires A <= T && T <= B\n ensures A <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_2196","instance":2196,"id":205539,"goal":"lemma SetUnionEmpty_2196(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_2197","instance":2197,"id":205540,"goal":"lemma SetInterEmpty_2197(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_2198","instance":2198,"id":205541,"goal":"lemma SetInterSubset_2198(S: set, U: set)\n ensures S * U <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_2199","instance":2199,"id":205542,"goal":"lemma SetCardSubset_2199(S: set, T: set)\n requires S <= T\n ensures |S| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_2200","instance":2200,"id":205543,"goal":"lemma SetUnionCard_2200(B: set, A: set)\n requires B * A == {}\n ensures |B + A| == |B| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_2201","instance":2201,"id":205544,"goal":"lemma SetUnionComm_2201(T: set, B: set)\n ensures T + B == B + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_2202","instance":2202,"id":205545,"goal":"lemma SetInterComm_2202(U: set, A: set)\n ensures U * A == A * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_2203","instance":2203,"id":205546,"goal":"lemma SetUnionAssoc_2203(A: set, S: set, B: set)\n ensures (A + S) + B == A + (S + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_2204","instance":2204,"id":205547,"goal":"lemma SetSubsetRefl_2204(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_2205","instance":2205,"id":205548,"goal":"lemma SetSubsetTrans_2205(T: set, U: set, B: set)\n requires T <= U && U <= B\n ensures T <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_2206","instance":2206,"id":205549,"goal":"lemma SetUnionEmpty_2206(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_2207","instance":2207,"id":205550,"goal":"lemma SetInterEmpty_2207(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_2208","instance":2208,"id":205551,"goal":"lemma SetInterSubset_2208(S: set, T: set)\n ensures S * T <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_2209","instance":2209,"id":205552,"goal":"lemma SetCardSubset_2209(A: set, B: set)\n requires A <= B\n ensures |A| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_2210","instance":2210,"id":205553,"goal":"lemma SetUnionCard_2210(A: set, T: set)\n requires A * T == {}\n ensures |A + T| == |A| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_2211","instance":2211,"id":205554,"goal":"lemma SetUnionComm_2211(S: set, A: set)\n ensures S + A == A + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_2212","instance":2212,"id":205555,"goal":"lemma SetInterComm_2212(T: set, U: set)\n ensures T * U == U * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_2213","instance":2213,"id":205556,"goal":"lemma SetUnionAssoc_2213(B: set, T: set, S: set)\n ensures (B + T) + S == B + (T + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_2214","instance":2214,"id":205557,"goal":"lemma SetSubsetRefl_2214(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_2215","instance":2215,"id":205558,"goal":"lemma SetSubsetTrans_2215(T: set, S: set, B: set)\n requires T <= S && S <= B\n ensures T <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_2216","instance":2216,"id":205559,"goal":"lemma SetUnionEmpty_2216(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_2217","instance":2217,"id":205560,"goal":"lemma SetInterEmpty_2217(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_2218","instance":2218,"id":205561,"goal":"lemma SetInterSubset_2218(T: set, B: set)\n ensures T * B <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_2219","instance":2219,"id":205562,"goal":"lemma SetCardSubset_2219(A: set, U: set)\n requires A <= U\n ensures |A| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_2220","instance":2220,"id":205563,"goal":"lemma SetUnionCard_2220(A: set, S: set)\n requires A * S == {}\n ensures |A + S| == |A| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_2221","instance":2221,"id":205564,"goal":"lemma SetUnionComm_2221(B: set, U: set)\n ensures B + U == U + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_2222","instance":2222,"id":205565,"goal":"lemma SetInterComm_2222(A: set, T: set)\n ensures A * T == T * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_2223","instance":2223,"id":205566,"goal":"lemma SetUnionAssoc_2223(A: set, T: set, U: set)\n ensures (A + T) + U == A + (T + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_2224","instance":2224,"id":205567,"goal":"lemma SetSubsetRefl_2224(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_2225","instance":2225,"id":205568,"goal":"lemma SetSubsetTrans_2225(A: set, B: set, U: set)\n requires A <= B && B <= U\n ensures A <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_2226","instance":2226,"id":205569,"goal":"lemma SetUnionEmpty_2226(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_2227","instance":2227,"id":205570,"goal":"lemma SetInterEmpty_2227(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_2228","instance":2228,"id":205571,"goal":"lemma SetInterSubset_2228(U: set, B: set)\n ensures U * B <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_2229","instance":2229,"id":205572,"goal":"lemma SetCardSubset_2229(U: set, T: set)\n requires U <= T\n ensures |U| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_2230","instance":2230,"id":205573,"goal":"lemma SetUnionCard_2230(B: set, S: set)\n requires B * S == {}\n ensures |B + S| == |B| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_2231","instance":2231,"id":205574,"goal":"lemma SetUnionComm_2231(T: set, U: set)\n ensures T + U == U + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_2232","instance":2232,"id":205575,"goal":"lemma SetInterComm_2232(S: set, B: set)\n ensures S * B == B * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_2233","instance":2233,"id":205576,"goal":"lemma SetUnionAssoc_2233(B: set, A: set, S: set)\n ensures (B + A) + S == B + (A + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_2234","instance":2234,"id":205577,"goal":"lemma SetSubsetRefl_2234(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_2235","instance":2235,"id":205578,"goal":"lemma SetSubsetTrans_2235(U: set, T: set, B: set)\n requires U <= T && T <= B\n ensures U <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_2236","instance":2236,"id":205579,"goal":"lemma SetUnionEmpty_2236(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_2237","instance":2237,"id":205580,"goal":"lemma SetInterEmpty_2237(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_2238","instance":2238,"id":205581,"goal":"lemma SetInterSubset_2238(U: set, S: set)\n ensures U * S <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_2239","instance":2239,"id":205582,"goal":"lemma SetCardSubset_2239(B: set, S: set)\n requires B <= S\n ensures |B| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_2240","instance":2240,"id":205583,"goal":"lemma SetUnionCard_2240(S: set, U: set)\n requires S * U == {}\n ensures |S + U| == |S| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_2241","instance":2241,"id":205584,"goal":"lemma SetUnionComm_2241(S: set, A: set)\n ensures S + A == A + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_2242","instance":2242,"id":205585,"goal":"lemma SetInterComm_2242(S: set, U: set)\n ensures S * U == U * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_2243","instance":2243,"id":205586,"goal":"lemma SetUnionAssoc_2243(U: set, B: set, A: set)\n ensures (U + B) + A == U + (B + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_2244","instance":2244,"id":205587,"goal":"lemma SetSubsetRefl_2244(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_2245","instance":2245,"id":205588,"goal":"lemma SetSubsetTrans_2245(T: set, A: set, U: set)\n requires T <= A && A <= U\n ensures T <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_2246","instance":2246,"id":205589,"goal":"lemma SetUnionEmpty_2246(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_2247","instance":2247,"id":205590,"goal":"lemma SetInterEmpty_2247(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_2248","instance":2248,"id":205591,"goal":"lemma SetInterSubset_2248(T: set, U: set)\n ensures T * U <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_2249","instance":2249,"id":205592,"goal":"lemma SetCardSubset_2249(S: set, B: set)\n requires S <= B\n ensures |S| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_2250","instance":2250,"id":205593,"goal":"lemma SetUnionCard_2250(U: set, T: set)\n requires U * T == {}\n ensures |U + T| == |U| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_2251","instance":2251,"id":205594,"goal":"lemma SetUnionComm_2251(U: set, B: set)\n ensures U + B == B + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_2252","instance":2252,"id":205595,"goal":"lemma SetInterComm_2252(U: set, A: set)\n ensures U * A == A * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_2253","instance":2253,"id":205596,"goal":"lemma SetUnionAssoc_2253(B: set, A: set, S: set)\n ensures (B + A) + S == B + (A + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_2254","instance":2254,"id":205597,"goal":"lemma SetSubsetRefl_2254(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_2255","instance":2255,"id":205598,"goal":"lemma SetSubsetTrans_2255(U: set, B: set, A: set)\n requires U <= B && B <= A\n ensures U <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_2256","instance":2256,"id":205599,"goal":"lemma SetUnionEmpty_2256(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_2257","instance":2257,"id":205600,"goal":"lemma SetInterEmpty_2257(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_2258","instance":2258,"id":205601,"goal":"lemma SetInterSubset_2258(T: set, U: set)\n ensures T * U <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_2259","instance":2259,"id":205602,"goal":"lemma SetCardSubset_2259(A: set, S: set)\n requires A <= S\n ensures |A| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_2260","instance":2260,"id":205603,"goal":"lemma SetUnionCard_2260(S: set, B: set)\n requires S * B == {}\n ensures |S + B| == |S| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_2261","instance":2261,"id":205604,"goal":"lemma SetUnionComm_2261(T: set, A: set)\n ensures T + A == A + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_2262","instance":2262,"id":205605,"goal":"lemma SetInterComm_2262(T: set, U: set)\n ensures T * U == U * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_2263","instance":2263,"id":205606,"goal":"lemma SetUnionAssoc_2263(S: set, T: set, U: set)\n ensures (S + T) + U == S + (T + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_2264","instance":2264,"id":205607,"goal":"lemma SetSubsetRefl_2264(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_2265","instance":2265,"id":205608,"goal":"lemma SetSubsetTrans_2265(B: set, A: set, U: set)\n requires B <= A && A <= U\n ensures B <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_2266","instance":2266,"id":205609,"goal":"lemma SetUnionEmpty_2266(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_2267","instance":2267,"id":205610,"goal":"lemma SetInterEmpty_2267(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_2268","instance":2268,"id":205611,"goal":"lemma SetInterSubset_2268(U: set, A: set)\n ensures U * A <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_2269","instance":2269,"id":205612,"goal":"lemma SetCardSubset_2269(T: set, B: set)\n requires T <= B\n ensures |T| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_2270","instance":2270,"id":205613,"goal":"lemma SetUnionCard_2270(A: set, S: set)\n requires A * S == {}\n ensures |A + S| == |A| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_2271","instance":2271,"id":205614,"goal":"lemma SetUnionComm_2271(U: set, B: set)\n ensures U + B == B + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_2272","instance":2272,"id":205615,"goal":"lemma SetInterComm_2272(B: set, S: set)\n ensures B * S == S * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_2273","instance":2273,"id":205616,"goal":"lemma SetUnionAssoc_2273(B: set, T: set, U: set)\n ensures (B + T) + U == B + (T + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_2274","instance":2274,"id":205617,"goal":"lemma SetSubsetRefl_2274(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_2275","instance":2275,"id":205618,"goal":"lemma SetSubsetTrans_2275(T: set, S: set, B: set)\n requires T <= S && S <= B\n ensures T <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_2276","instance":2276,"id":205619,"goal":"lemma SetUnionEmpty_2276(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_2277","instance":2277,"id":205620,"goal":"lemma SetInterEmpty_2277(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_2278","instance":2278,"id":205621,"goal":"lemma SetInterSubset_2278(T: set, U: set)\n ensures T * U <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_2279","instance":2279,"id":205622,"goal":"lemma SetCardSubset_2279(S: set, B: set)\n requires S <= B\n ensures |S| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_2280","instance":2280,"id":205623,"goal":"lemma SetUnionCard_2280(U: set, T: set)\n requires U * T == {}\n ensures |U + T| == |U| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_2281","instance":2281,"id":205624,"goal":"lemma SetUnionComm_2281(T: set, B: set)\n ensures T + B == B + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_2282","instance":2282,"id":205625,"goal":"lemma SetInterComm_2282(B: set, A: set)\n ensures B * A == A * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_2283","instance":2283,"id":205626,"goal":"lemma SetUnionAssoc_2283(U: set, T: set, A: set)\n ensures (U + T) + A == U + (T + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_2284","instance":2284,"id":205627,"goal":"lemma SetSubsetRefl_2284(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_2285","instance":2285,"id":205628,"goal":"lemma SetSubsetTrans_2285(S: set, U: set, B: set)\n requires S <= U && U <= B\n ensures S <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_2286","instance":2286,"id":205629,"goal":"lemma SetUnionEmpty_2286(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_2287","instance":2287,"id":205630,"goal":"lemma SetInterEmpty_2287(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_2288","instance":2288,"id":205631,"goal":"lemma SetInterSubset_2288(B: set, A: set)\n ensures B * A <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_2289","instance":2289,"id":205632,"goal":"lemma SetCardSubset_2289(U: set, S: set)\n requires U <= S\n ensures |U| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_2290","instance":2290,"id":205633,"goal":"lemma SetUnionCard_2290(B: set, U: set)\n requires B * U == {}\n ensures |B + U| == |B| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_2291","instance":2291,"id":205634,"goal":"lemma SetUnionComm_2291(B: set, A: set)\n ensures B + A == A + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_2292","instance":2292,"id":205635,"goal":"lemma SetInterComm_2292(B: set, U: set)\n ensures B * U == U * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_2293","instance":2293,"id":205636,"goal":"lemma SetUnionAssoc_2293(B: set, T: set, S: set)\n ensures (B + T) + S == B + (T + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_2294","instance":2294,"id":205637,"goal":"lemma SetSubsetRefl_2294(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_2295","instance":2295,"id":205638,"goal":"lemma SetSubsetTrans_2295(U: set, B: set, S: set)\n requires U <= B && B <= S\n ensures U <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_2296","instance":2296,"id":205639,"goal":"lemma SetUnionEmpty_2296(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_2297","instance":2297,"id":205640,"goal":"lemma SetInterEmpty_2297(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_2298","instance":2298,"id":205641,"goal":"lemma SetInterSubset_2298(S: set, A: set)\n ensures S * A <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_2299","instance":2299,"id":205642,"goal":"lemma SetCardSubset_2299(A: set, T: set)\n requires A <= T\n ensures |A| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_2300","instance":2300,"id":205643,"goal":"lemma SetUnionCard_2300(T: set, B: set)\n requires T * B == {}\n ensures |T + B| == |T| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_2301","instance":2301,"id":205644,"goal":"lemma SetUnionComm_2301(U: set, T: set)\n ensures U + T == T + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_2302","instance":2302,"id":205645,"goal":"lemma SetInterComm_2302(S: set, A: set)\n ensures S * A == A * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_2303","instance":2303,"id":205646,"goal":"lemma SetUnionAssoc_2303(S: set, T: set, B: set)\n ensures (S + T) + B == S + (T + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_2304","instance":2304,"id":205647,"goal":"lemma SetSubsetRefl_2304(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_2305","instance":2305,"id":205648,"goal":"lemma SetSubsetTrans_2305(A: set, T: set, B: set)\n requires A <= T && T <= B\n ensures A <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_2306","instance":2306,"id":205649,"goal":"lemma SetUnionEmpty_2306(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_2307","instance":2307,"id":205650,"goal":"lemma SetInterEmpty_2307(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_2308","instance":2308,"id":205651,"goal":"lemma SetInterSubset_2308(A: set, S: set)\n ensures A * S <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_2309","instance":2309,"id":205652,"goal":"lemma SetCardSubset_2309(A: set, T: set)\n requires A <= T\n ensures |A| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_2310","instance":2310,"id":205653,"goal":"lemma SetUnionCard_2310(T: set, A: set)\n requires T * A == {}\n ensures |T + A| == |T| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_2311","instance":2311,"id":205654,"goal":"lemma SetUnionComm_2311(B: set, A: set)\n ensures B + A == A + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_2312","instance":2312,"id":205655,"goal":"lemma SetInterComm_2312(T: set, A: set)\n ensures T * A == A * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_2313","instance":2313,"id":205656,"goal":"lemma SetUnionAssoc_2313(U: set, A: set, B: set)\n ensures (U + A) + B == U + (A + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_2314","instance":2314,"id":205657,"goal":"lemma SetSubsetRefl_2314(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_2315","instance":2315,"id":205658,"goal":"lemma SetSubsetTrans_2315(U: set, B: set, T: set)\n requires U <= B && B <= T\n ensures U <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_2316","instance":2316,"id":205659,"goal":"lemma SetUnionEmpty_2316(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_2317","instance":2317,"id":205660,"goal":"lemma SetInterEmpty_2317(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_2318","instance":2318,"id":205661,"goal":"lemma SetInterSubset_2318(S: set, T: set)\n ensures S * T <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_2319","instance":2319,"id":205662,"goal":"lemma SetCardSubset_2319(A: set, U: set)\n requires A <= U\n ensures |A| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_2320","instance":2320,"id":205663,"goal":"lemma SetUnionCard_2320(T: set, B: set)\n requires T * B == {}\n ensures |T + B| == |T| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_2321","instance":2321,"id":205664,"goal":"lemma SetUnionComm_2321(S: set, A: set)\n ensures S + A == A + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_2322","instance":2322,"id":205665,"goal":"lemma SetInterComm_2322(A: set, B: set)\n ensures A * B == B * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_2323","instance":2323,"id":205666,"goal":"lemma SetUnionAssoc_2323(U: set, T: set, S: set)\n ensures (U + T) + S == U + (T + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_2324","instance":2324,"id":205667,"goal":"lemma SetSubsetRefl_2324(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_2325","instance":2325,"id":205668,"goal":"lemma SetSubsetTrans_2325(U: set, B: set, S: set)\n requires U <= B && B <= S\n ensures U <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_2326","instance":2326,"id":205669,"goal":"lemma SetUnionEmpty_2326(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_2327","instance":2327,"id":205670,"goal":"lemma SetInterEmpty_2327(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_2328","instance":2328,"id":205671,"goal":"lemma SetInterSubset_2328(B: set, S: set)\n ensures B * S <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_2329","instance":2329,"id":205672,"goal":"lemma SetCardSubset_2329(A: set, U: set)\n requires A <= U\n ensures |A| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_2330","instance":2330,"id":205673,"goal":"lemma SetUnionCard_2330(S: set, A: set)\n requires S * A == {}\n ensures |S + A| == |S| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_2331","instance":2331,"id":205674,"goal":"lemma SetUnionComm_2331(T: set, U: set)\n ensures T + U == U + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_2332","instance":2332,"id":205675,"goal":"lemma SetInterComm_2332(U: set, B: set)\n ensures U * B == B * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_2333","instance":2333,"id":205676,"goal":"lemma SetUnionAssoc_2333(B: set, S: set, U: set)\n ensures (B + S) + U == B + (S + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_2334","instance":2334,"id":205677,"goal":"lemma SetSubsetRefl_2334(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_2335","instance":2335,"id":205678,"goal":"lemma SetSubsetTrans_2335(A: set, S: set, B: set)\n requires A <= S && S <= B\n ensures A <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_2336","instance":2336,"id":205679,"goal":"lemma SetUnionEmpty_2336(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_2337","instance":2337,"id":205680,"goal":"lemma SetInterEmpty_2337(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_2338","instance":2338,"id":205681,"goal":"lemma SetInterSubset_2338(A: set, S: set)\n ensures A * S <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_2339","instance":2339,"id":205682,"goal":"lemma SetCardSubset_2339(B: set, S: set)\n requires B <= S\n ensures |B| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_2340","instance":2340,"id":205683,"goal":"lemma SetUnionCard_2340(U: set, B: set)\n requires U * B == {}\n ensures |U + B| == |U| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_2341","instance":2341,"id":205684,"goal":"lemma SetUnionComm_2341(S: set, T: set)\n ensures S + T == T + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_2342","instance":2342,"id":205685,"goal":"lemma SetInterComm_2342(S: set, B: set)\n ensures S * B == B * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_2343","instance":2343,"id":205686,"goal":"lemma SetUnionAssoc_2343(B: set, S: set, T: set)\n ensures (B + S) + T == B + (S + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_2344","instance":2344,"id":205687,"goal":"lemma SetSubsetRefl_2344(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_2345","instance":2345,"id":205688,"goal":"lemma SetSubsetTrans_2345(B: set, A: set, T: set)\n requires B <= A && A <= T\n ensures B <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_2346","instance":2346,"id":205689,"goal":"lemma SetUnionEmpty_2346(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_2347","instance":2347,"id":205690,"goal":"lemma SetInterEmpty_2347(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_2348","instance":2348,"id":205691,"goal":"lemma SetInterSubset_2348(B: set, S: set)\n ensures B * S <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_2349","instance":2349,"id":205692,"goal":"lemma SetCardSubset_2349(U: set, T: set)\n requires U <= T\n ensures |U| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_2350","instance":2350,"id":205693,"goal":"lemma SetUnionCard_2350(A: set, U: set)\n requires A * U == {}\n ensures |A + U| == |A| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_2351","instance":2351,"id":205694,"goal":"lemma SetUnionComm_2351(U: set, A: set)\n ensures U + A == A + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_2352","instance":2352,"id":205695,"goal":"lemma SetInterComm_2352(U: set, T: set)\n ensures U * T == T * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_2353","instance":2353,"id":205696,"goal":"lemma SetUnionAssoc_2353(T: set, U: set, A: set)\n ensures (T + U) + A == T + (U + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_2354","instance":2354,"id":205697,"goal":"lemma SetSubsetRefl_2354(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_2355","instance":2355,"id":205698,"goal":"lemma SetSubsetTrans_2355(T: set, S: set, U: set)\n requires T <= S && S <= U\n ensures T <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_2356","instance":2356,"id":205699,"goal":"lemma SetUnionEmpty_2356(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_2357","instance":2357,"id":205700,"goal":"lemma SetInterEmpty_2357(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_2358","instance":2358,"id":205701,"goal":"lemma SetInterSubset_2358(B: set, A: set)\n ensures B * A <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_2359","instance":2359,"id":205702,"goal":"lemma SetCardSubset_2359(B: set, U: set)\n requires B <= U\n ensures |B| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_2360","instance":2360,"id":205703,"goal":"lemma SetUnionCard_2360(T: set, U: set)\n requires T * U == {}\n ensures |T + U| == |T| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_2361","instance":2361,"id":205704,"goal":"lemma SetUnionComm_2361(A: set, B: set)\n ensures A + B == B + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_2362","instance":2362,"id":205705,"goal":"lemma SetInterComm_2362(B: set, A: set)\n ensures B * A == A * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_2363","instance":2363,"id":205706,"goal":"lemma SetUnionAssoc_2363(B: set, S: set, U: set)\n ensures (B + S) + U == B + (S + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_2364","instance":2364,"id":205707,"goal":"lemma SetSubsetRefl_2364(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_2365","instance":2365,"id":205708,"goal":"lemma SetSubsetTrans_2365(U: set, T: set, B: set)\n requires U <= T && T <= B\n ensures U <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_2366","instance":2366,"id":205709,"goal":"lemma SetUnionEmpty_2366(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_2367","instance":2367,"id":205710,"goal":"lemma SetInterEmpty_2367(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_2368","instance":2368,"id":205711,"goal":"lemma SetInterSubset_2368(S: set, U: set)\n ensures S * U <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_2369","instance":2369,"id":205712,"goal":"lemma SetCardSubset_2369(B: set, U: set)\n requires B <= U\n ensures |B| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_2370","instance":2370,"id":205713,"goal":"lemma SetUnionCard_2370(B: set, S: set)\n requires B * S == {}\n ensures |B + S| == |B| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_2371","instance":2371,"id":205714,"goal":"lemma SetUnionComm_2371(S: set, T: set)\n ensures S + T == T + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_2372","instance":2372,"id":205715,"goal":"lemma SetInterComm_2372(S: set, T: set)\n ensures S * T == T * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_2373","instance":2373,"id":205716,"goal":"lemma SetUnionAssoc_2373(A: set, T: set, S: set)\n ensures (A + T) + S == A + (T + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_2374","instance":2374,"id":205717,"goal":"lemma SetSubsetRefl_2374(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_2375","instance":2375,"id":205718,"goal":"lemma SetSubsetTrans_2375(A: set, S: set, B: set)\n requires A <= S && S <= B\n ensures A <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_2376","instance":2376,"id":205719,"goal":"lemma SetUnionEmpty_2376(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_2377","instance":2377,"id":205720,"goal":"lemma SetInterEmpty_2377(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_2378","instance":2378,"id":205721,"goal":"lemma SetInterSubset_2378(S: set, A: set)\n ensures S * A <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_2379","instance":2379,"id":205722,"goal":"lemma SetCardSubset_2379(S: set, A: set)\n requires S <= A\n ensures |S| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_2380","instance":2380,"id":205723,"goal":"lemma SetUnionCard_2380(T: set, U: set)\n requires T * U == {}\n ensures |T + U| == |T| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_2381","instance":2381,"id":205724,"goal":"lemma SetUnionComm_2381(T: set, B: set)\n ensures T + B == B + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_2382","instance":2382,"id":205725,"goal":"lemma SetInterComm_2382(U: set, A: set)\n ensures U * A == A * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_2383","instance":2383,"id":205726,"goal":"lemma SetUnionAssoc_2383(T: set, B: set, S: set)\n ensures (T + B) + S == T + (B + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_2384","instance":2384,"id":205727,"goal":"lemma SetSubsetRefl_2384(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_2385","instance":2385,"id":205728,"goal":"lemma SetSubsetTrans_2385(B: set, U: set, A: set)\n requires B <= U && U <= A\n ensures B <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_2386","instance":2386,"id":205729,"goal":"lemma SetUnionEmpty_2386(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_2387","instance":2387,"id":205730,"goal":"lemma SetInterEmpty_2387(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_2388","instance":2388,"id":205731,"goal":"lemma SetInterSubset_2388(A: set, B: set)\n ensures A * B <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_2389","instance":2389,"id":205732,"goal":"lemma SetCardSubset_2389(T: set, U: set)\n requires T <= U\n ensures |T| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_2390","instance":2390,"id":205733,"goal":"lemma SetUnionCard_2390(B: set, U: set)\n requires B * U == {}\n ensures |B + U| == |B| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_2391","instance":2391,"id":205734,"goal":"lemma SetUnionComm_2391(B: set, T: set)\n ensures B + T == T + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_2392","instance":2392,"id":205735,"goal":"lemma SetInterComm_2392(S: set, B: set)\n ensures S * B == B * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_2393","instance":2393,"id":205736,"goal":"lemma SetUnionAssoc_2393(S: set, T: set, B: set)\n ensures (S + T) + B == S + (T + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_2394","instance":2394,"id":205737,"goal":"lemma SetSubsetRefl_2394(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_2395","instance":2395,"id":205738,"goal":"lemma SetSubsetTrans_2395(T: set, B: set, A: set)\n requires T <= B && B <= A\n ensures T <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_2396","instance":2396,"id":205739,"goal":"lemma SetUnionEmpty_2396(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_2397","instance":2397,"id":205740,"goal":"lemma SetInterEmpty_2397(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_2398","instance":2398,"id":205741,"goal":"lemma SetInterSubset_2398(A: set, U: set)\n ensures A * U <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_2399","instance":2399,"id":205742,"goal":"lemma SetCardSubset_2399(A: set, T: set)\n requires A <= T\n ensures |A| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_2400","instance":2400,"id":205743,"goal":"lemma SetUnionCard_2400(A: set, B: set)\n requires A * B == {}\n ensures |A + B| == |A| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_2401","instance":2401,"id":205744,"goal":"lemma SetUnionComm_2401(S: set, U: set)\n ensures S + U == U + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_2402","instance":2402,"id":205745,"goal":"lemma SetInterComm_2402(S: set, B: set)\n ensures S * B == B * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_2403","instance":2403,"id":205746,"goal":"lemma SetUnionAssoc_2403(U: set, A: set, T: set)\n ensures (U + A) + T == U + (A + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_2404","instance":2404,"id":205747,"goal":"lemma SetSubsetRefl_2404(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_2405","instance":2405,"id":205748,"goal":"lemma SetSubsetTrans_2405(S: set, A: set, B: set)\n requires S <= A && A <= B\n ensures S <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_2406","instance":2406,"id":205749,"goal":"lemma SetUnionEmpty_2406(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_2407","instance":2407,"id":205750,"goal":"lemma SetInterEmpty_2407(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_2408","instance":2408,"id":205751,"goal":"lemma SetInterSubset_2408(U: set, A: set)\n ensures U * A <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_2409","instance":2409,"id":205752,"goal":"lemma SetCardSubset_2409(B: set, S: set)\n requires B <= S\n ensures |B| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_2410","instance":2410,"id":205753,"goal":"lemma SetUnionCard_2410(A: set, U: set)\n requires A * U == {}\n ensures |A + U| == |A| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_2411","instance":2411,"id":205754,"goal":"lemma SetUnionComm_2411(B: set, A: set)\n ensures B + A == A + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_2412","instance":2412,"id":205755,"goal":"lemma SetInterComm_2412(S: set, U: set)\n ensures S * U == U * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_2413","instance":2413,"id":205756,"goal":"lemma SetUnionAssoc_2413(T: set, U: set, A: set)\n ensures (T + U) + A == T + (U + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_2414","instance":2414,"id":205757,"goal":"lemma SetSubsetRefl_2414(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_2415","instance":2415,"id":205758,"goal":"lemma SetSubsetTrans_2415(S: set, A: set, T: set)\n requires S <= A && A <= T\n ensures S <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_2416","instance":2416,"id":205759,"goal":"lemma SetUnionEmpty_2416(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_2417","instance":2417,"id":205760,"goal":"lemma SetInterEmpty_2417(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_2418","instance":2418,"id":205761,"goal":"lemma SetInterSubset_2418(S: set, T: set)\n ensures S * T <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_2419","instance":2419,"id":205762,"goal":"lemma SetCardSubset_2419(B: set, S: set)\n requires B <= S\n ensures |B| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_2420","instance":2420,"id":205763,"goal":"lemma SetUnionCard_2420(B: set, T: set)\n requires B * T == {}\n ensures |B + T| == |B| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_2421","instance":2421,"id":205764,"goal":"lemma SetUnionComm_2421(T: set, U: set)\n ensures T + U == U + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_2422","instance":2422,"id":205765,"goal":"lemma SetInterComm_2422(T: set, A: set)\n ensures T * A == A * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_2423","instance":2423,"id":205766,"goal":"lemma SetUnionAssoc_2423(S: set, A: set, U: set)\n ensures (S + A) + U == S + (A + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_2424","instance":2424,"id":205767,"goal":"lemma SetSubsetRefl_2424(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_2425","instance":2425,"id":205768,"goal":"lemma SetSubsetTrans_2425(B: set, A: set, U: set)\n requires B <= A && A <= U\n ensures B <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_2426","instance":2426,"id":205769,"goal":"lemma SetUnionEmpty_2426(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_2427","instance":2427,"id":205770,"goal":"lemma SetInterEmpty_2427(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_2428","instance":2428,"id":205771,"goal":"lemma SetInterSubset_2428(U: set, B: set)\n ensures U * B <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_2429","instance":2429,"id":205772,"goal":"lemma SetCardSubset_2429(B: set, T: set)\n requires B <= T\n ensures |B| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_2430","instance":2430,"id":205773,"goal":"lemma SetUnionCard_2430(T: set, A: set)\n requires T * A == {}\n ensures |T + A| == |T| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_2431","instance":2431,"id":205774,"goal":"lemma SetUnionComm_2431(A: set, T: set)\n ensures A + T == T + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_2432","instance":2432,"id":205775,"goal":"lemma SetInterComm_2432(S: set, T: set)\n ensures S * T == T * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_2433","instance":2433,"id":205776,"goal":"lemma SetUnionAssoc_2433(A: set, U: set, S: set)\n ensures (A + U) + S == A + (U + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_2434","instance":2434,"id":205777,"goal":"lemma SetSubsetRefl_2434(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_2435","instance":2435,"id":205778,"goal":"lemma SetSubsetTrans_2435(U: set, B: set, S: set)\n requires U <= B && B <= S\n ensures U <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_2436","instance":2436,"id":205779,"goal":"lemma SetUnionEmpty_2436(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_2437","instance":2437,"id":205780,"goal":"lemma SetInterEmpty_2437(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_2438","instance":2438,"id":205781,"goal":"lemma SetInterSubset_2438(S: set, U: set)\n ensures S * U <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_2439","instance":2439,"id":205782,"goal":"lemma SetCardSubset_2439(B: set, A: set)\n requires B <= A\n ensures |B| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_2440","instance":2440,"id":205783,"goal":"lemma SetUnionCard_2440(T: set, S: set)\n requires T * S == {}\n ensures |T + S| == |T| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_2441","instance":2441,"id":205784,"goal":"lemma SetUnionComm_2441(T: set, S: set)\n ensures T + S == S + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_2442","instance":2442,"id":205785,"goal":"lemma SetInterComm_2442(B: set, S: set)\n ensures B * S == S * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_2443","instance":2443,"id":205786,"goal":"lemma SetUnionAssoc_2443(U: set, S: set, T: set)\n ensures (U + S) + T == U + (S + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_2444","instance":2444,"id":205787,"goal":"lemma SetSubsetRefl_2444(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_2445","instance":2445,"id":205788,"goal":"lemma SetSubsetTrans_2445(A: set, T: set, S: set)\n requires A <= T && T <= S\n ensures A <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_2446","instance":2446,"id":205789,"goal":"lemma SetUnionEmpty_2446(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_2447","instance":2447,"id":205790,"goal":"lemma SetInterEmpty_2447(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_2448","instance":2448,"id":205791,"goal":"lemma SetInterSubset_2448(B: set, U: set)\n ensures B * U <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_2449","instance":2449,"id":205792,"goal":"lemma SetCardSubset_2449(B: set, U: set)\n requires B <= U\n ensures |B| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_2450","instance":2450,"id":205793,"goal":"lemma SetUnionCard_2450(T: set, U: set)\n requires T * U == {}\n ensures |T + U| == |T| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_2451","instance":2451,"id":205794,"goal":"lemma SetUnionComm_2451(U: set, T: set)\n ensures U + T == T + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_2452","instance":2452,"id":205795,"goal":"lemma SetInterComm_2452(S: set, U: set)\n ensures S * U == U * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_2453","instance":2453,"id":205796,"goal":"lemma SetUnionAssoc_2453(B: set, A: set, T: set)\n ensures (B + A) + T == B + (A + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_2454","instance":2454,"id":205797,"goal":"lemma SetSubsetRefl_2454(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_2455","instance":2455,"id":205798,"goal":"lemma SetSubsetTrans_2455(U: set, B: set, A: set)\n requires U <= B && B <= A\n ensures U <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_2456","instance":2456,"id":205799,"goal":"lemma SetUnionEmpty_2456(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_2457","instance":2457,"id":205800,"goal":"lemma SetInterEmpty_2457(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_2458","instance":2458,"id":205801,"goal":"lemma SetInterSubset_2458(A: set, B: set)\n ensures A * B <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_2459","instance":2459,"id":205802,"goal":"lemma SetCardSubset_2459(S: set, T: set)\n requires S <= T\n ensures |S| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_2460","instance":2460,"id":205803,"goal":"lemma SetUnionCard_2460(A: set, T: set)\n requires A * T == {}\n ensures |A + T| == |A| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_2461","instance":2461,"id":205804,"goal":"lemma SetUnionComm_2461(S: set, U: set)\n ensures S + U == U + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_2462","instance":2462,"id":205805,"goal":"lemma SetInterComm_2462(U: set, B: set)\n ensures U * B == B * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_2463","instance":2463,"id":205806,"goal":"lemma SetUnionAssoc_2463(U: set, A: set, T: set)\n ensures (U + A) + T == U + (A + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_2464","instance":2464,"id":205807,"goal":"lemma SetSubsetRefl_2464(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_2465","instance":2465,"id":205808,"goal":"lemma SetSubsetTrans_2465(B: set, S: set, T: set)\n requires B <= S && S <= T\n ensures B <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_2466","instance":2466,"id":205809,"goal":"lemma SetUnionEmpty_2466(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_2467","instance":2467,"id":205810,"goal":"lemma SetInterEmpty_2467(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_2468","instance":2468,"id":205811,"goal":"lemma SetInterSubset_2468(U: set, A: set)\n ensures U * A <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_2469","instance":2469,"id":205812,"goal":"lemma SetCardSubset_2469(A: set, S: set)\n requires A <= S\n ensures |A| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_2470","instance":2470,"id":205813,"goal":"lemma SetUnionCard_2470(U: set, A: set)\n requires U * A == {}\n ensures |U + A| == |U| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_2471","instance":2471,"id":205814,"goal":"lemma SetUnionComm_2471(S: set, A: set)\n ensures S + A == A + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_2472","instance":2472,"id":205815,"goal":"lemma SetInterComm_2472(S: set, A: set)\n ensures S * A == A * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_2473","instance":2473,"id":205816,"goal":"lemma SetUnionAssoc_2473(S: set, U: set, T: set)\n ensures (S + U) + T == S + (U + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_2474","instance":2474,"id":205817,"goal":"lemma SetSubsetRefl_2474(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_2475","instance":2475,"id":205818,"goal":"lemma SetSubsetTrans_2475(B: set, T: set, U: set)\n requires B <= T && T <= U\n ensures B <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_2476","instance":2476,"id":205819,"goal":"lemma SetUnionEmpty_2476(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_2477","instance":2477,"id":205820,"goal":"lemma SetInterEmpty_2477(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_2478","instance":2478,"id":205821,"goal":"lemma SetInterSubset_2478(U: set, S: set)\n ensures U * S <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_2479","instance":2479,"id":205822,"goal":"lemma SetCardSubset_2479(U: set, A: set)\n requires U <= A\n ensures |U| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_2480","instance":2480,"id":205823,"goal":"lemma SetUnionCard_2480(B: set, U: set)\n requires B * U == {}\n ensures |B + U| == |B| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_2481","instance":2481,"id":205824,"goal":"lemma SetUnionComm_2481(T: set, B: set)\n ensures T + B == B + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_2482","instance":2482,"id":205825,"goal":"lemma SetInterComm_2482(S: set, A: set)\n ensures S * A == A * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_2483","instance":2483,"id":205826,"goal":"lemma SetUnionAssoc_2483(A: set, S: set, B: set)\n ensures (A + S) + B == A + (S + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_2484","instance":2484,"id":205827,"goal":"lemma SetSubsetRefl_2484(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_2485","instance":2485,"id":205828,"goal":"lemma SetSubsetTrans_2485(T: set, A: set, U: set)\n requires T <= A && A <= U\n ensures T <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_2486","instance":2486,"id":205829,"goal":"lemma SetUnionEmpty_2486(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_2487","instance":2487,"id":205830,"goal":"lemma SetInterEmpty_2487(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_2488","instance":2488,"id":205831,"goal":"lemma SetInterSubset_2488(U: set, A: set)\n ensures U * A <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_2489","instance":2489,"id":205832,"goal":"lemma SetCardSubset_2489(A: set, U: set)\n requires A <= U\n ensures |A| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_2490","instance":2490,"id":205833,"goal":"lemma SetUnionCard_2490(U: set, S: set)\n requires U * S == {}\n ensures |U + S| == |U| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_2491","instance":2491,"id":205834,"goal":"lemma SetUnionComm_2491(U: set, B: set)\n ensures U + B == B + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_2492","instance":2492,"id":205835,"goal":"lemma SetInterComm_2492(U: set, A: set)\n ensures U * A == A * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_2493","instance":2493,"id":205836,"goal":"lemma SetUnionAssoc_2493(B: set, U: set, A: set)\n ensures (B + U) + A == B + (U + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_2494","instance":2494,"id":205837,"goal":"lemma SetSubsetRefl_2494(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_2495","instance":2495,"id":205838,"goal":"lemma SetSubsetTrans_2495(B: set, T: set, S: set)\n requires B <= T && T <= S\n ensures B <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_2496","instance":2496,"id":205839,"goal":"lemma SetUnionEmpty_2496(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_2497","instance":2497,"id":205840,"goal":"lemma SetInterEmpty_2497(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_2498","instance":2498,"id":205841,"goal":"lemma SetInterSubset_2498(T: set, A: set)\n ensures T * A <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_2499","instance":2499,"id":205842,"goal":"lemma SetCardSubset_2499(B: set, A: set)\n requires B <= A\n ensures |B| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_2500","instance":2500,"id":205843,"goal":"lemma SetUnionCard_2500(A: set, S: set)\n requires A * S == {}\n ensures |A + S| == |A| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_2501","instance":2501,"id":205844,"goal":"lemma SetUnionComm_2501(U: set, A: set)\n ensures U + A == A + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_2502","instance":2502,"id":205845,"goal":"lemma SetInterComm_2502(B: set, A: set)\n ensures B * A == A * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_2503","instance":2503,"id":205846,"goal":"lemma SetUnionAssoc_2503(A: set, S: set, B: set)\n ensures (A + S) + B == A + (S + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_2504","instance":2504,"id":205847,"goal":"lemma SetSubsetRefl_2504(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_2505","instance":2505,"id":205848,"goal":"lemma SetSubsetTrans_2505(A: set, S: set, T: set)\n requires A <= S && S <= T\n ensures A <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_2506","instance":2506,"id":205849,"goal":"lemma SetUnionEmpty_2506(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_2507","instance":2507,"id":205850,"goal":"lemma SetInterEmpty_2507(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_2508","instance":2508,"id":205851,"goal":"lemma SetInterSubset_2508(A: set, U: set)\n ensures A * U <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_2509","instance":2509,"id":205852,"goal":"lemma SetCardSubset_2509(U: set, S: set)\n requires U <= S\n ensures |U| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_2510","instance":2510,"id":205853,"goal":"lemma SetUnionCard_2510(S: set, T: set)\n requires S * T == {}\n ensures |S + T| == |S| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_2511","instance":2511,"id":205854,"goal":"lemma SetUnionComm_2511(A: set, S: set)\n ensures A + S == S + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_2512","instance":2512,"id":205855,"goal":"lemma SetInterComm_2512(T: set, A: set)\n ensures T * A == A * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_2513","instance":2513,"id":205856,"goal":"lemma SetUnionAssoc_2513(U: set, B: set, A: set)\n ensures (U + B) + A == U + (B + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_2514","instance":2514,"id":205857,"goal":"lemma SetSubsetRefl_2514(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_2515","instance":2515,"id":205858,"goal":"lemma SetSubsetTrans_2515(U: set, A: set, T: set)\n requires U <= A && A <= T\n ensures U <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_2516","instance":2516,"id":205859,"goal":"lemma SetUnionEmpty_2516(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_2517","instance":2517,"id":205860,"goal":"lemma SetInterEmpty_2517(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_2518","instance":2518,"id":205861,"goal":"lemma SetInterSubset_2518(S: set, U: set)\n ensures S * U <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_2519","instance":2519,"id":205862,"goal":"lemma SetCardSubset_2519(U: set, S: set)\n requires U <= S\n ensures |U| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_2520","instance":2520,"id":205863,"goal":"lemma SetUnionCard_2520(B: set, A: set)\n requires B * A == {}\n ensures |B + A| == |B| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_2521","instance":2521,"id":205864,"goal":"lemma SetUnionComm_2521(U: set, S: set)\n ensures U + S == S + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_2522","instance":2522,"id":205865,"goal":"lemma SetInterComm_2522(A: set, U: set)\n ensures A * U == U * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_2523","instance":2523,"id":205866,"goal":"lemma SetUnionAssoc_2523(U: set, A: set, S: set)\n ensures (U + A) + S == U + (A + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_2524","instance":2524,"id":205867,"goal":"lemma SetSubsetRefl_2524(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_2525","instance":2525,"id":205868,"goal":"lemma SetSubsetTrans_2525(S: set, B: set, T: set)\n requires S <= B && B <= T\n ensures S <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_2526","instance":2526,"id":205869,"goal":"lemma SetUnionEmpty_2526(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_2527","instance":2527,"id":205870,"goal":"lemma SetInterEmpty_2527(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_2528","instance":2528,"id":205871,"goal":"lemma SetInterSubset_2528(B: set, A: set)\n ensures B * A <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_2529","instance":2529,"id":205872,"goal":"lemma SetCardSubset_2529(S: set, A: set)\n requires S <= A\n ensures |S| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_2530","instance":2530,"id":205873,"goal":"lemma SetUnionCard_2530(S: set, B: set)\n requires S * B == {}\n ensures |S + B| == |S| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_2531","instance":2531,"id":205874,"goal":"lemma SetUnionComm_2531(U: set, T: set)\n ensures U + T == T + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_2532","instance":2532,"id":205875,"goal":"lemma SetInterComm_2532(U: set, A: set)\n ensures U * A == A * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_2533","instance":2533,"id":205876,"goal":"lemma SetUnionAssoc_2533(S: set, T: set, U: set)\n ensures (S + T) + U == S + (T + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_2534","instance":2534,"id":205877,"goal":"lemma SetSubsetRefl_2534(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_2535","instance":2535,"id":205878,"goal":"lemma SetSubsetTrans_2535(T: set, U: set, B: set)\n requires T <= U && U <= B\n ensures T <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_2536","instance":2536,"id":205879,"goal":"lemma SetUnionEmpty_2536(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_2537","instance":2537,"id":205880,"goal":"lemma SetInterEmpty_2537(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_2538","instance":2538,"id":205881,"goal":"lemma SetInterSubset_2538(S: set, A: set)\n ensures S * A <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_2539","instance":2539,"id":205882,"goal":"lemma SetCardSubset_2539(B: set, T: set)\n requires B <= T\n ensures |B| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_2540","instance":2540,"id":205883,"goal":"lemma SetUnionCard_2540(B: set, S: set)\n requires B * S == {}\n ensures |B + S| == |B| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_2541","instance":2541,"id":205884,"goal":"lemma SetUnionComm_2541(U: set, B: set)\n ensures U + B == B + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_2542","instance":2542,"id":205885,"goal":"lemma SetInterComm_2542(T: set, A: set)\n ensures T * A == A * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_2543","instance":2543,"id":205886,"goal":"lemma SetUnionAssoc_2543(T: set, U: set, S: set)\n ensures (T + U) + S == T + (U + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_2544","instance":2544,"id":205887,"goal":"lemma SetSubsetRefl_2544(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_2545","instance":2545,"id":205888,"goal":"lemma SetSubsetTrans_2545(A: set, T: set, B: set)\n requires A <= T && T <= B\n ensures A <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_2546","instance":2546,"id":205889,"goal":"lemma SetUnionEmpty_2546(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_2547","instance":2547,"id":205890,"goal":"lemma SetInterEmpty_2547(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_2548","instance":2548,"id":205891,"goal":"lemma SetInterSubset_2548(S: set, T: set)\n ensures S * T <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_2549","instance":2549,"id":205892,"goal":"lemma SetCardSubset_2549(B: set, T: set)\n requires B <= T\n ensures |B| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_2550","instance":2550,"id":205893,"goal":"lemma SetUnionCard_2550(B: set, T: set)\n requires B * T == {}\n ensures |B + T| == |B| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_2551","instance":2551,"id":205894,"goal":"lemma SetUnionComm_2551(B: set, A: set)\n ensures B + A == A + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_2552","instance":2552,"id":205895,"goal":"lemma SetInterComm_2552(B: set, A: set)\n ensures B * A == A * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_2553","instance":2553,"id":205896,"goal":"lemma SetUnionAssoc_2553(U: set, T: set, S: set)\n ensures (U + T) + S == U + (T + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_2554","instance":2554,"id":205897,"goal":"lemma SetSubsetRefl_2554(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_2555","instance":2555,"id":205898,"goal":"lemma SetSubsetTrans_2555(T: set, S: set, A: set)\n requires T <= S && S <= A\n ensures T <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_2556","instance":2556,"id":205899,"goal":"lemma SetUnionEmpty_2556(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_2557","instance":2557,"id":205900,"goal":"lemma SetInterEmpty_2557(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_2558","instance":2558,"id":205901,"goal":"lemma SetInterSubset_2558(A: set, S: set)\n ensures A * S <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_2559","instance":2559,"id":205902,"goal":"lemma SetCardSubset_2559(A: set, S: set)\n requires A <= S\n ensures |A| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_2560","instance":2560,"id":205903,"goal":"lemma SetUnionCard_2560(S: set, T: set)\n requires S * T == {}\n ensures |S + T| == |S| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_2561","instance":2561,"id":205904,"goal":"lemma SetUnionComm_2561(T: set, A: set)\n ensures T + A == A + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_2562","instance":2562,"id":205905,"goal":"lemma SetInterComm_2562(U: set, S: set)\n ensures U * S == S * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_2563","instance":2563,"id":205906,"goal":"lemma SetUnionAssoc_2563(B: set, S: set, T: set)\n ensures (B + S) + T == B + (S + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_2564","instance":2564,"id":205907,"goal":"lemma SetSubsetRefl_2564(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_2565","instance":2565,"id":205908,"goal":"lemma SetSubsetTrans_2565(U: set, B: set, A: set)\n requires U <= B && B <= A\n ensures U <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_2566","instance":2566,"id":205909,"goal":"lemma SetUnionEmpty_2566(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_2567","instance":2567,"id":205910,"goal":"lemma SetInterEmpty_2567(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_2568","instance":2568,"id":205911,"goal":"lemma SetInterSubset_2568(U: set, A: set)\n ensures U * A <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_2569","instance":2569,"id":205912,"goal":"lemma SetCardSubset_2569(B: set, T: set)\n requires B <= T\n ensures |B| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_2570","instance":2570,"id":205913,"goal":"lemma SetUnionCard_2570(U: set, A: set)\n requires U * A == {}\n ensures |U + A| == |U| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_2571","instance":2571,"id":205914,"goal":"lemma SetUnionComm_2571(B: set, S: set)\n ensures B + S == S + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_2572","instance":2572,"id":205915,"goal":"lemma SetInterComm_2572(A: set, S: set)\n ensures A * S == S * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_2573","instance":2573,"id":205916,"goal":"lemma SetUnionAssoc_2573(S: set, T: set, B: set)\n ensures (S + T) + B == S + (T + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_2574","instance":2574,"id":205917,"goal":"lemma SetSubsetRefl_2574(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_2575","instance":2575,"id":205918,"goal":"lemma SetSubsetTrans_2575(S: set, B: set, T: set)\n requires S <= B && B <= T\n ensures S <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_2576","instance":2576,"id":205919,"goal":"lemma SetUnionEmpty_2576(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_2577","instance":2577,"id":205920,"goal":"lemma SetInterEmpty_2577(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_2578","instance":2578,"id":205921,"goal":"lemma SetInterSubset_2578(A: set, S: set)\n ensures A * S <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_2579","instance":2579,"id":205922,"goal":"lemma SetCardSubset_2579(T: set, A: set)\n requires T <= A\n ensures |T| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_2580","instance":2580,"id":205923,"goal":"lemma SetUnionCard_2580(S: set, A: set)\n requires S * A == {}\n ensures |S + A| == |S| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_2581","instance":2581,"id":205924,"goal":"lemma SetUnionComm_2581(S: set, B: set)\n ensures S + B == B + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_2582","instance":2582,"id":205925,"goal":"lemma SetInterComm_2582(T: set, S: set)\n ensures T * S == S * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_2583","instance":2583,"id":205926,"goal":"lemma SetUnionAssoc_2583(S: set, A: set, T: set)\n ensures (S + A) + T == S + (A + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_2584","instance":2584,"id":205927,"goal":"lemma SetSubsetRefl_2584(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_2585","instance":2585,"id":205928,"goal":"lemma SetSubsetTrans_2585(T: set, U: set, A: set)\n requires T <= U && U <= A\n ensures T <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_2586","instance":2586,"id":205929,"goal":"lemma SetUnionEmpty_2586(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_2587","instance":2587,"id":205930,"goal":"lemma SetInterEmpty_2587(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_2588","instance":2588,"id":205931,"goal":"lemma SetInterSubset_2588(S: set, T: set)\n ensures S * T <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_2589","instance":2589,"id":205932,"goal":"lemma SetCardSubset_2589(S: set, A: set)\n requires S <= A\n ensures |S| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_2590","instance":2590,"id":205933,"goal":"lemma SetUnionCard_2590(A: set, U: set)\n requires A * U == {}\n ensures |A + U| == |A| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_2591","instance":2591,"id":205934,"goal":"lemma SetUnionComm_2591(B: set, A: set)\n ensures B + A == A + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_2592","instance":2592,"id":205935,"goal":"lemma SetInterComm_2592(A: set, B: set)\n ensures A * B == B * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_2593","instance":2593,"id":205936,"goal":"lemma SetUnionAssoc_2593(U: set, B: set, T: set)\n ensures (U + B) + T == U + (B + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_2594","instance":2594,"id":205937,"goal":"lemma SetSubsetRefl_2594(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_2595","instance":2595,"id":205938,"goal":"lemma SetSubsetTrans_2595(S: set, A: set, U: set)\n requires S <= A && A <= U\n ensures S <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_2596","instance":2596,"id":205939,"goal":"lemma SetUnionEmpty_2596(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_2597","instance":2597,"id":205940,"goal":"lemma SetInterEmpty_2597(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_2598","instance":2598,"id":205941,"goal":"lemma SetInterSubset_2598(B: set, S: set)\n ensures B * S <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_2599","instance":2599,"id":205942,"goal":"lemma SetCardSubset_2599(B: set, T: set)\n requires B <= T\n ensures |B| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_2600","instance":2600,"id":205943,"goal":"lemma SetUnionCard_2600(B: set, S: set)\n requires B * S == {}\n ensures |B + S| == |B| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_2601","instance":2601,"id":205944,"goal":"lemma SetUnionComm_2601(S: set, B: set)\n ensures S + B == B + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_2602","instance":2602,"id":205945,"goal":"lemma SetInterComm_2602(S: set, A: set)\n ensures S * A == A * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_2603","instance":2603,"id":205946,"goal":"lemma SetUnionAssoc_2603(U: set, T: set, S: set)\n ensures (U + T) + S == U + (T + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_2604","instance":2604,"id":205947,"goal":"lemma SetSubsetRefl_2604(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_2605","instance":2605,"id":205948,"goal":"lemma SetSubsetTrans_2605(S: set, T: set, U: set)\n requires S <= T && T <= U\n ensures S <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_2606","instance":2606,"id":205949,"goal":"lemma SetUnionEmpty_2606(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_2607","instance":2607,"id":205950,"goal":"lemma SetInterEmpty_2607(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_2608","instance":2608,"id":205951,"goal":"lemma SetInterSubset_2608(U: set, S: set)\n ensures U * S <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_2609","instance":2609,"id":205952,"goal":"lemma SetCardSubset_2609(S: set, T: set)\n requires S <= T\n ensures |S| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_2610","instance":2610,"id":205953,"goal":"lemma SetUnionCard_2610(A: set, S: set)\n requires A * S == {}\n ensures |A + S| == |A| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_2611","instance":2611,"id":205954,"goal":"lemma SetUnionComm_2611(A: set, B: set)\n ensures A + B == B + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_2612","instance":2612,"id":205955,"goal":"lemma SetInterComm_2612(B: set, U: set)\n ensures B * U == U * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_2613","instance":2613,"id":205956,"goal":"lemma SetUnionAssoc_2613(S: set, U: set, B: set)\n ensures (S + U) + B == S + (U + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_2614","instance":2614,"id":205957,"goal":"lemma SetSubsetRefl_2614(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_2615","instance":2615,"id":205958,"goal":"lemma SetSubsetTrans_2615(S: set, U: set, B: set)\n requires S <= U && U <= B\n ensures S <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_2616","instance":2616,"id":205959,"goal":"lemma SetUnionEmpty_2616(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_2617","instance":2617,"id":205960,"goal":"lemma SetInterEmpty_2617(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_2618","instance":2618,"id":205961,"goal":"lemma SetInterSubset_2618(S: set, U: set)\n ensures S * U <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_2619","instance":2619,"id":205962,"goal":"lemma SetCardSubset_2619(B: set, U: set)\n requires B <= U\n ensures |B| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_2620","instance":2620,"id":205963,"goal":"lemma SetUnionCard_2620(A: set, T: set)\n requires A * T == {}\n ensures |A + T| == |A| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_2621","instance":2621,"id":205964,"goal":"lemma SetUnionComm_2621(T: set, U: set)\n ensures T + U == U + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_2622","instance":2622,"id":205965,"goal":"lemma SetInterComm_2622(B: set, U: set)\n ensures B * U == U * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_2623","instance":2623,"id":205966,"goal":"lemma SetUnionAssoc_2623(A: set, B: set, U: set)\n ensures (A + B) + U == A + (B + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_2624","instance":2624,"id":205967,"goal":"lemma SetSubsetRefl_2624(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_2625","instance":2625,"id":205968,"goal":"lemma SetSubsetTrans_2625(B: set, T: set, S: set)\n requires B <= T && T <= S\n ensures B <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_2626","instance":2626,"id":205969,"goal":"lemma SetUnionEmpty_2626(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_2627","instance":2627,"id":205970,"goal":"lemma SetInterEmpty_2627(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_2628","instance":2628,"id":205971,"goal":"lemma SetInterSubset_2628(T: set, A: set)\n ensures T * A <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_2629","instance":2629,"id":205972,"goal":"lemma SetCardSubset_2629(B: set, A: set)\n requires B <= A\n ensures |B| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_2630","instance":2630,"id":205973,"goal":"lemma SetUnionCard_2630(T: set, B: set)\n requires T * B == {}\n ensures |T + B| == |T| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_2631","instance":2631,"id":205974,"goal":"lemma SetUnionComm_2631(B: set, S: set)\n ensures B + S == S + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_2632","instance":2632,"id":205975,"goal":"lemma SetInterComm_2632(S: set, B: set)\n ensures S * B == B * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_2633","instance":2633,"id":205976,"goal":"lemma SetUnionAssoc_2633(A: set, U: set, T: set)\n ensures (A + U) + T == A + (U + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_2634","instance":2634,"id":205977,"goal":"lemma SetSubsetRefl_2634(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_2635","instance":2635,"id":205978,"goal":"lemma SetSubsetTrans_2635(U: set, A: set, S: set)\n requires U <= A && A <= S\n ensures U <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_2636","instance":2636,"id":205979,"goal":"lemma SetUnionEmpty_2636(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_2637","instance":2637,"id":205980,"goal":"lemma SetInterEmpty_2637(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_2638","instance":2638,"id":205981,"goal":"lemma SetInterSubset_2638(T: set, A: set)\n ensures T * A <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_2639","instance":2639,"id":205982,"goal":"lemma SetCardSubset_2639(U: set, T: set)\n requires U <= T\n ensures |U| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_2640","instance":2640,"id":205983,"goal":"lemma SetUnionCard_2640(A: set, S: set)\n requires A * S == {}\n ensures |A + S| == |A| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_2641","instance":2641,"id":205984,"goal":"lemma SetUnionComm_2641(A: set, T: set)\n ensures A + T == T + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_2642","instance":2642,"id":205985,"goal":"lemma SetInterComm_2642(S: set, B: set)\n ensures S * B == B * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_2643","instance":2643,"id":205986,"goal":"lemma SetUnionAssoc_2643(A: set, T: set, B: set)\n ensures (A + T) + B == A + (T + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_2644","instance":2644,"id":205987,"goal":"lemma SetSubsetRefl_2644(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_2645","instance":2645,"id":205988,"goal":"lemma SetSubsetTrans_2645(A: set, B: set, U: set)\n requires A <= B && B <= U\n ensures A <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_2646","instance":2646,"id":205989,"goal":"lemma SetUnionEmpty_2646(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_2647","instance":2647,"id":205990,"goal":"lemma SetInterEmpty_2647(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_2648","instance":2648,"id":205991,"goal":"lemma SetInterSubset_2648(T: set, U: set)\n ensures T * U <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_2649","instance":2649,"id":205992,"goal":"lemma SetCardSubset_2649(T: set, B: set)\n requires T <= B\n ensures |T| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_2650","instance":2650,"id":205993,"goal":"lemma SetUnionCard_2650(S: set, T: set)\n requires S * T == {}\n ensures |S + T| == |S| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_2651","instance":2651,"id":205994,"goal":"lemma SetUnionComm_2651(U: set, T: set)\n ensures U + T == T + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_2652","instance":2652,"id":205995,"goal":"lemma SetInterComm_2652(B: set, T: set)\n ensures B * T == T * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_2653","instance":2653,"id":205996,"goal":"lemma SetUnionAssoc_2653(B: set, U: set, A: set)\n ensures (B + U) + A == B + (U + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_2654","instance":2654,"id":205997,"goal":"lemma SetSubsetRefl_2654(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_2655","instance":2655,"id":205998,"goal":"lemma SetSubsetTrans_2655(S: set, U: set, A: set)\n requires S <= U && U <= A\n ensures S <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_2656","instance":2656,"id":205999,"goal":"lemma SetUnionEmpty_2656(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_2657","instance":2657,"id":206000,"goal":"lemma SetInterEmpty_2657(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_2658","instance":2658,"id":206001,"goal":"lemma SetInterSubset_2658(S: set, U: set)\n ensures S * U <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_2659","instance":2659,"id":206002,"goal":"lemma SetCardSubset_2659(U: set, A: set)\n requires U <= A\n ensures |U| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_2660","instance":2660,"id":206003,"goal":"lemma SetUnionCard_2660(S: set, T: set)\n requires S * T == {}\n ensures |S + T| == |S| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_2661","instance":2661,"id":206004,"goal":"lemma SetUnionComm_2661(U: set, T: set)\n ensures U + T == T + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_2662","instance":2662,"id":206005,"goal":"lemma SetInterComm_2662(B: set, T: set)\n ensures B * T == T * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_2663","instance":2663,"id":206006,"goal":"lemma SetUnionAssoc_2663(B: set, S: set, A: set)\n ensures (B + S) + A == B + (S + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_2664","instance":2664,"id":206007,"goal":"lemma SetSubsetRefl_2664(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_2665","instance":2665,"id":206008,"goal":"lemma SetSubsetTrans_2665(S: set, A: set, B: set)\n requires S <= A && A <= B\n ensures S <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_2666","instance":2666,"id":206009,"goal":"lemma SetUnionEmpty_2666(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_2667","instance":2667,"id":206010,"goal":"lemma SetInterEmpty_2667(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_2668","instance":2668,"id":206011,"goal":"lemma SetInterSubset_2668(T: set, A: set)\n ensures T * A <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_2669","instance":2669,"id":206012,"goal":"lemma SetCardSubset_2669(B: set, U: set)\n requires B <= U\n ensures |B| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_2670","instance":2670,"id":206013,"goal":"lemma SetUnionCard_2670(S: set, T: set)\n requires S * T == {}\n ensures |S + T| == |S| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_2671","instance":2671,"id":206014,"goal":"lemma SetUnionComm_2671(A: set, B: set)\n ensures A + B == B + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_2672","instance":2672,"id":206015,"goal":"lemma SetInterComm_2672(U: set, B: set)\n ensures U * B == B * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_2673","instance":2673,"id":206016,"goal":"lemma SetUnionAssoc_2673(S: set, B: set, T: set)\n ensures (S + B) + T == S + (B + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_2674","instance":2674,"id":206017,"goal":"lemma SetSubsetRefl_2674(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_2675","instance":2675,"id":206018,"goal":"lemma SetSubsetTrans_2675(U: set, B: set, A: set)\n requires U <= B && B <= A\n ensures U <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_2676","instance":2676,"id":206019,"goal":"lemma SetUnionEmpty_2676(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_2677","instance":2677,"id":206020,"goal":"lemma SetInterEmpty_2677(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_2678","instance":2678,"id":206021,"goal":"lemma SetInterSubset_2678(S: set, B: set)\n ensures S * B <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_2679","instance":2679,"id":206022,"goal":"lemma SetCardSubset_2679(S: set, B: set)\n requires S <= B\n ensures |S| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_2680","instance":2680,"id":206023,"goal":"lemma SetUnionCard_2680(S: set, A: set)\n requires S * A == {}\n ensures |S + A| == |S| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_2681","instance":2681,"id":206024,"goal":"lemma SetUnionComm_2681(A: set, S: set)\n ensures A + S == S + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_2682","instance":2682,"id":206025,"goal":"lemma SetInterComm_2682(S: set, U: set)\n ensures S * U == U * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_2683","instance":2683,"id":206026,"goal":"lemma SetUnionAssoc_2683(S: set, T: set, B: set)\n ensures (S + T) + B == S + (T + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_2684","instance":2684,"id":206027,"goal":"lemma SetSubsetRefl_2684(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_2685","instance":2685,"id":206028,"goal":"lemma SetSubsetTrans_2685(A: set, T: set, S: set)\n requires A <= T && T <= S\n ensures A <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_2686","instance":2686,"id":206029,"goal":"lemma SetUnionEmpty_2686(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_2687","instance":2687,"id":206030,"goal":"lemma SetInterEmpty_2687(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_2688","instance":2688,"id":206031,"goal":"lemma SetInterSubset_2688(T: set, A: set)\n ensures T * A <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_2689","instance":2689,"id":206032,"goal":"lemma SetCardSubset_2689(T: set, A: set)\n requires T <= A\n ensures |T| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_2690","instance":2690,"id":206033,"goal":"lemma SetUnionCard_2690(S: set, B: set)\n requires S * B == {}\n ensures |S + B| == |S| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_2691","instance":2691,"id":206034,"goal":"lemma SetUnionComm_2691(A: set, T: set)\n ensures A + T == T + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_2692","instance":2692,"id":206035,"goal":"lemma SetInterComm_2692(A: set, S: set)\n ensures A * S == S * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_2693","instance":2693,"id":206036,"goal":"lemma SetUnionAssoc_2693(A: set, T: set, B: set)\n ensures (A + T) + B == A + (T + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_2694","instance":2694,"id":206037,"goal":"lemma SetSubsetRefl_2694(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_2695","instance":2695,"id":206038,"goal":"lemma SetSubsetTrans_2695(S: set, B: set, T: set)\n requires S <= B && B <= T\n ensures S <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_2696","instance":2696,"id":206039,"goal":"lemma SetUnionEmpty_2696(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_2697","instance":2697,"id":206040,"goal":"lemma SetInterEmpty_2697(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_2698","instance":2698,"id":206041,"goal":"lemma SetInterSubset_2698(U: set, S: set)\n ensures U * S <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_2699","instance":2699,"id":206042,"goal":"lemma SetCardSubset_2699(B: set, A: set)\n requires B <= A\n ensures |B| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_2700","instance":2700,"id":206043,"goal":"lemma SetUnionCard_2700(U: set, B: set)\n requires U * B == {}\n ensures |U + B| == |U| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_2701","instance":2701,"id":206044,"goal":"lemma SetUnionComm_2701(A: set, T: set)\n ensures A + T == T + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_2702","instance":2702,"id":206045,"goal":"lemma SetInterComm_2702(S: set, T: set)\n ensures S * T == T * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_2703","instance":2703,"id":206046,"goal":"lemma SetUnionAssoc_2703(T: set, S: set, A: set)\n ensures (T + S) + A == T + (S + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_2704","instance":2704,"id":206047,"goal":"lemma SetSubsetRefl_2704(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_2705","instance":2705,"id":206048,"goal":"lemma SetSubsetTrans_2705(S: set, T: set, U: set)\n requires S <= T && T <= U\n ensures S <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_2706","instance":2706,"id":206049,"goal":"lemma SetUnionEmpty_2706(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_2707","instance":2707,"id":206050,"goal":"lemma SetInterEmpty_2707(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_2708","instance":2708,"id":206051,"goal":"lemma SetInterSubset_2708(B: set, U: set)\n ensures B * U <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_2709","instance":2709,"id":206052,"goal":"lemma SetCardSubset_2709(U: set, A: set)\n requires U <= A\n ensures |U| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_2710","instance":2710,"id":206053,"goal":"lemma SetUnionCard_2710(S: set, A: set)\n requires S * A == {}\n ensures |S + A| == |S| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_2711","instance":2711,"id":206054,"goal":"lemma SetUnionComm_2711(T: set, A: set)\n ensures T + A == A + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_2712","instance":2712,"id":206055,"goal":"lemma SetInterComm_2712(A: set, B: set)\n ensures A * B == B * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_2713","instance":2713,"id":206056,"goal":"lemma SetUnionAssoc_2713(S: set, T: set, A: set)\n ensures (S + T) + A == S + (T + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_2714","instance":2714,"id":206057,"goal":"lemma SetSubsetRefl_2714(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_2715","instance":2715,"id":206058,"goal":"lemma SetSubsetTrans_2715(S: set, T: set, B: set)\n requires S <= T && T <= B\n ensures S <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_2716","instance":2716,"id":206059,"goal":"lemma SetUnionEmpty_2716(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_2717","instance":2717,"id":206060,"goal":"lemma SetInterEmpty_2717(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_2718","instance":2718,"id":206061,"goal":"lemma SetInterSubset_2718(S: set, A: set)\n ensures S * A <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_2719","instance":2719,"id":206062,"goal":"lemma SetCardSubset_2719(B: set, T: set)\n requires B <= T\n ensures |B| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_2720","instance":2720,"id":206063,"goal":"lemma SetUnionCard_2720(B: set, U: set)\n requires B * U == {}\n ensures |B + U| == |B| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_2721","instance":2721,"id":206064,"goal":"lemma SetUnionComm_2721(T: set, A: set)\n ensures T + A == A + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_2722","instance":2722,"id":206065,"goal":"lemma SetInterComm_2722(T: set, U: set)\n ensures T * U == U * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_2723","instance":2723,"id":206066,"goal":"lemma SetUnionAssoc_2723(T: set, A: set, S: set)\n ensures (T + A) + S == T + (A + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_2724","instance":2724,"id":206067,"goal":"lemma SetSubsetRefl_2724(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_2725","instance":2725,"id":206068,"goal":"lemma SetSubsetTrans_2725(S: set, U: set, T: set)\n requires S <= U && U <= T\n ensures S <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_2726","instance":2726,"id":206069,"goal":"lemma SetUnionEmpty_2726(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_2727","instance":2727,"id":206070,"goal":"lemma SetInterEmpty_2727(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_2728","instance":2728,"id":206071,"goal":"lemma SetInterSubset_2728(A: set, S: set)\n ensures A * S <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_2729","instance":2729,"id":206072,"goal":"lemma SetCardSubset_2729(A: set, T: set)\n requires A <= T\n ensures |A| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_2730","instance":2730,"id":206073,"goal":"lemma SetUnionCard_2730(S: set, B: set)\n requires S * B == {}\n ensures |S + B| == |S| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_2731","instance":2731,"id":206074,"goal":"lemma SetUnionComm_2731(T: set, B: set)\n ensures T + B == B + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_2732","instance":2732,"id":206075,"goal":"lemma SetInterComm_2732(S: set, T: set)\n ensures S * T == T * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_2733","instance":2733,"id":206076,"goal":"lemma SetUnionAssoc_2733(S: set, A: set, B: set)\n ensures (S + A) + B == S + (A + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_2734","instance":2734,"id":206077,"goal":"lemma SetSubsetRefl_2734(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_2735","instance":2735,"id":206078,"goal":"lemma SetSubsetTrans_2735(A: set, B: set, S: set)\n requires A <= B && B <= S\n ensures A <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_2736","instance":2736,"id":206079,"goal":"lemma SetUnionEmpty_2736(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_2737","instance":2737,"id":206080,"goal":"lemma SetInterEmpty_2737(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_2738","instance":2738,"id":206081,"goal":"lemma SetInterSubset_2738(A: set, T: set)\n ensures A * T <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_2739","instance":2739,"id":206082,"goal":"lemma SetCardSubset_2739(A: set, B: set)\n requires A <= B\n ensures |A| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_2740","instance":2740,"id":206083,"goal":"lemma SetUnionCard_2740(U: set, B: set)\n requires U * B == {}\n ensures |U + B| == |U| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_2741","instance":2741,"id":206084,"goal":"lemma SetUnionComm_2741(S: set, A: set)\n ensures S + A == A + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_2742","instance":2742,"id":206085,"goal":"lemma SetInterComm_2742(U: set, S: set)\n ensures U * S == S * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_2743","instance":2743,"id":206086,"goal":"lemma SetUnionAssoc_2743(A: set, U: set, B: set)\n ensures (A + U) + B == A + (U + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_2744","instance":2744,"id":206087,"goal":"lemma SetSubsetRefl_2744(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_2745","instance":2745,"id":206088,"goal":"lemma SetSubsetTrans_2745(B: set, U: set, A: set)\n requires B <= U && U <= A\n ensures B <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_2746","instance":2746,"id":206089,"goal":"lemma SetUnionEmpty_2746(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_2747","instance":2747,"id":206090,"goal":"lemma SetInterEmpty_2747(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_2748","instance":2748,"id":206091,"goal":"lemma SetInterSubset_2748(A: set, T: set)\n ensures A * T <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_2749","instance":2749,"id":206092,"goal":"lemma SetCardSubset_2749(U: set, A: set)\n requires U <= A\n ensures |U| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_2750","instance":2750,"id":206093,"goal":"lemma SetUnionCard_2750(T: set, B: set)\n requires T * B == {}\n ensures |T + B| == |T| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_2751","instance":2751,"id":206094,"goal":"lemma SetUnionComm_2751(B: set, S: set)\n ensures B + S == S + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_2752","instance":2752,"id":206095,"goal":"lemma SetInterComm_2752(U: set, T: set)\n ensures U * T == T * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_2753","instance":2753,"id":206096,"goal":"lemma SetUnionAssoc_2753(B: set, T: set, U: set)\n ensures (B + T) + U == B + (T + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_2754","instance":2754,"id":206097,"goal":"lemma SetSubsetRefl_2754(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_2755","instance":2755,"id":206098,"goal":"lemma SetSubsetTrans_2755(A: set, T: set, U: set)\n requires A <= T && T <= U\n ensures A <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_2756","instance":2756,"id":206099,"goal":"lemma SetUnionEmpty_2756(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_2757","instance":2757,"id":206100,"goal":"lemma SetInterEmpty_2757(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_2758","instance":2758,"id":206101,"goal":"lemma SetInterSubset_2758(T: set, S: set)\n ensures T * S <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_2759","instance":2759,"id":206102,"goal":"lemma SetCardSubset_2759(B: set, S: set)\n requires B <= S\n ensures |B| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_2760","instance":2760,"id":206103,"goal":"lemma SetUnionCard_2760(T: set, U: set)\n requires T * U == {}\n ensures |T + U| == |T| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_2761","instance":2761,"id":206104,"goal":"lemma SetUnionComm_2761(T: set, A: set)\n ensures T + A == A + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_2762","instance":2762,"id":206105,"goal":"lemma SetInterComm_2762(S: set, A: set)\n ensures S * A == A * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_2763","instance":2763,"id":206106,"goal":"lemma SetUnionAssoc_2763(S: set, B: set, T: set)\n ensures (S + B) + T == S + (B + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_2764","instance":2764,"id":206107,"goal":"lemma SetSubsetRefl_2764(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_2765","instance":2765,"id":206108,"goal":"lemma SetSubsetTrans_2765(U: set, A: set, B: set)\n requires U <= A && A <= B\n ensures U <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_2766","instance":2766,"id":206109,"goal":"lemma SetUnionEmpty_2766(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_2767","instance":2767,"id":206110,"goal":"lemma SetInterEmpty_2767(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_2768","instance":2768,"id":206111,"goal":"lemma SetInterSubset_2768(A: set, B: set)\n ensures A * B <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_2769","instance":2769,"id":206112,"goal":"lemma SetCardSubset_2769(A: set, T: set)\n requires A <= T\n ensures |A| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_2770","instance":2770,"id":206113,"goal":"lemma SetUnionCard_2770(A: set, S: set)\n requires A * S == {}\n ensures |A + S| == |A| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_2771","instance":2771,"id":206114,"goal":"lemma SetUnionComm_2771(U: set, S: set)\n ensures U + S == S + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_2772","instance":2772,"id":206115,"goal":"lemma SetInterComm_2772(A: set, T: set)\n ensures A * T == T * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_2773","instance":2773,"id":206116,"goal":"lemma SetUnionAssoc_2773(A: set, B: set, S: set)\n ensures (A + B) + S == A + (B + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_2774","instance":2774,"id":206117,"goal":"lemma SetSubsetRefl_2774(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_2775","instance":2775,"id":206118,"goal":"lemma SetSubsetTrans_2775(U: set, S: set, A: set)\n requires U <= S && S <= A\n ensures U <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_2776","instance":2776,"id":206119,"goal":"lemma SetUnionEmpty_2776(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_2777","instance":2777,"id":206120,"goal":"lemma SetInterEmpty_2777(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_2778","instance":2778,"id":206121,"goal":"lemma SetInterSubset_2778(A: set, T: set)\n ensures A * T <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_2779","instance":2779,"id":206122,"goal":"lemma SetCardSubset_2779(A: set, B: set)\n requires A <= B\n ensures |A| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_2780","instance":2780,"id":206123,"goal":"lemma SetUnionCard_2780(T: set, S: set)\n requires T * S == {}\n ensures |T + S| == |T| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_2781","instance":2781,"id":206124,"goal":"lemma SetUnionComm_2781(A: set, T: set)\n ensures A + T == T + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_2782","instance":2782,"id":206125,"goal":"lemma SetInterComm_2782(S: set, B: set)\n ensures S * B == B * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_2783","instance":2783,"id":206126,"goal":"lemma SetUnionAssoc_2783(S: set, T: set, A: set)\n ensures (S + T) + A == S + (T + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_2784","instance":2784,"id":206127,"goal":"lemma SetSubsetRefl_2784(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_2785","instance":2785,"id":206128,"goal":"lemma SetSubsetTrans_2785(S: set, B: set, A: set)\n requires S <= B && B <= A\n ensures S <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_2786","instance":2786,"id":206129,"goal":"lemma SetUnionEmpty_2786(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_2787","instance":2787,"id":206130,"goal":"lemma SetInterEmpty_2787(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_2788","instance":2788,"id":206131,"goal":"lemma SetInterSubset_2788(S: set, U: set)\n ensures S * U <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_2789","instance":2789,"id":206132,"goal":"lemma SetCardSubset_2789(T: set, B: set)\n requires T <= B\n ensures |T| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_2790","instance":2790,"id":206133,"goal":"lemma SetUnionCard_2790(U: set, B: set)\n requires U * B == {}\n ensures |U + B| == |U| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_2791","instance":2791,"id":206134,"goal":"lemma SetUnionComm_2791(A: set, U: set)\n ensures A + U == U + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_2792","instance":2792,"id":206135,"goal":"lemma SetInterComm_2792(T: set, S: set)\n ensures T * S == S * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_2793","instance":2793,"id":206136,"goal":"lemma SetUnionAssoc_2793(T: set, A: set, S: set)\n ensures (T + A) + S == T + (A + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_2794","instance":2794,"id":206137,"goal":"lemma SetSubsetRefl_2794(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_2795","instance":2795,"id":206138,"goal":"lemma SetSubsetTrans_2795(B: set, A: set, T: set)\n requires B <= A && A <= T\n ensures B <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_2796","instance":2796,"id":206139,"goal":"lemma SetUnionEmpty_2796(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_2797","instance":2797,"id":206140,"goal":"lemma SetInterEmpty_2797(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_2798","instance":2798,"id":206141,"goal":"lemma SetInterSubset_2798(U: set, T: set)\n ensures U * T <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_2799","instance":2799,"id":206142,"goal":"lemma SetCardSubset_2799(S: set, A: set)\n requires S <= A\n ensures |S| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_2800","instance":2800,"id":206143,"goal":"lemma SetUnionCard_2800(U: set, A: set)\n requires U * A == {}\n ensures |U + A| == |U| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_2801","instance":2801,"id":206144,"goal":"lemma SetUnionComm_2801(T: set, A: set)\n ensures T + A == A + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_2802","instance":2802,"id":206145,"goal":"lemma SetInterComm_2802(B: set, U: set)\n ensures B * U == U * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_2803","instance":2803,"id":206146,"goal":"lemma SetUnionAssoc_2803(B: set, T: set, U: set)\n ensures (B + T) + U == B + (T + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_2804","instance":2804,"id":206147,"goal":"lemma SetSubsetRefl_2804(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_2805","instance":2805,"id":206148,"goal":"lemma SetSubsetTrans_2805(A: set, T: set, S: set)\n requires A <= T && T <= S\n ensures A <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_2806","instance":2806,"id":206149,"goal":"lemma SetUnionEmpty_2806(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_2807","instance":2807,"id":206150,"goal":"lemma SetInterEmpty_2807(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_2808","instance":2808,"id":206151,"goal":"lemma SetInterSubset_2808(A: set, T: set)\n ensures A * T <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_2809","instance":2809,"id":206152,"goal":"lemma SetCardSubset_2809(S: set, A: set)\n requires S <= A\n ensures |S| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_2810","instance":2810,"id":206153,"goal":"lemma SetUnionCard_2810(U: set, A: set)\n requires U * A == {}\n ensures |U + A| == |U| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_2811","instance":2811,"id":206154,"goal":"lemma SetUnionComm_2811(U: set, B: set)\n ensures U + B == B + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_2812","instance":2812,"id":206155,"goal":"lemma SetInterComm_2812(S: set, A: set)\n ensures S * A == A * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_2813","instance":2813,"id":206156,"goal":"lemma SetUnionAssoc_2813(T: set, B: set, A: set)\n ensures (T + B) + A == T + (B + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_2814","instance":2814,"id":206157,"goal":"lemma SetSubsetRefl_2814(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_2815","instance":2815,"id":206158,"goal":"lemma SetSubsetTrans_2815(U: set, B: set, S: set)\n requires U <= B && B <= S\n ensures U <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_2816","instance":2816,"id":206159,"goal":"lemma SetUnionEmpty_2816(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_2817","instance":2817,"id":206160,"goal":"lemma SetInterEmpty_2817(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_2818","instance":2818,"id":206161,"goal":"lemma SetInterSubset_2818(S: set, U: set)\n ensures S * U <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_2819","instance":2819,"id":206162,"goal":"lemma SetCardSubset_2819(U: set, B: set)\n requires U <= B\n ensures |U| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_2820","instance":2820,"id":206163,"goal":"lemma SetUnionCard_2820(T: set, U: set)\n requires T * U == {}\n ensures |T + U| == |T| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_2821","instance":2821,"id":206164,"goal":"lemma SetUnionComm_2821(T: set, A: set)\n ensures T + A == A + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_2822","instance":2822,"id":206165,"goal":"lemma SetInterComm_2822(T: set, U: set)\n ensures T * U == U * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_2823","instance":2823,"id":206166,"goal":"lemma SetUnionAssoc_2823(A: set, S: set, B: set)\n ensures (A + S) + B == A + (S + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_2824","instance":2824,"id":206167,"goal":"lemma SetSubsetRefl_2824(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_2825","instance":2825,"id":206168,"goal":"lemma SetSubsetTrans_2825(T: set, B: set, A: set)\n requires T <= B && B <= A\n ensures T <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_2826","instance":2826,"id":206169,"goal":"lemma SetUnionEmpty_2826(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_2827","instance":2827,"id":206170,"goal":"lemma SetInterEmpty_2827(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_2828","instance":2828,"id":206171,"goal":"lemma SetInterSubset_2828(S: set, B: set)\n ensures S * B <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_2829","instance":2829,"id":206172,"goal":"lemma SetCardSubset_2829(B: set, U: set)\n requires B <= U\n ensures |B| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_2830","instance":2830,"id":206173,"goal":"lemma SetUnionCard_2830(A: set, T: set)\n requires A * T == {}\n ensures |A + T| == |A| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_2831","instance":2831,"id":206174,"goal":"lemma SetUnionComm_2831(B: set, S: set)\n ensures B + S == S + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_2832","instance":2832,"id":206175,"goal":"lemma SetInterComm_2832(S: set, U: set)\n ensures S * U == U * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_2833","instance":2833,"id":206176,"goal":"lemma SetUnionAssoc_2833(U: set, B: set, T: set)\n ensures (U + B) + T == U + (B + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_2834","instance":2834,"id":206177,"goal":"lemma SetSubsetRefl_2834(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_2835","instance":2835,"id":206178,"goal":"lemma SetSubsetTrans_2835(S: set, A: set, T: set)\n requires S <= A && A <= T\n ensures S <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_2836","instance":2836,"id":206179,"goal":"lemma SetUnionEmpty_2836(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_2837","instance":2837,"id":206180,"goal":"lemma SetInterEmpty_2837(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_2838","instance":2838,"id":206181,"goal":"lemma SetInterSubset_2838(B: set, A: set)\n ensures B * A <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_2839","instance":2839,"id":206182,"goal":"lemma SetCardSubset_2839(T: set, U: set)\n requires T <= U\n ensures |T| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_2840","instance":2840,"id":206183,"goal":"lemma SetUnionCard_2840(B: set, T: set)\n requires B * T == {}\n ensures |B + T| == |B| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_2841","instance":2841,"id":206184,"goal":"lemma SetUnionComm_2841(U: set, T: set)\n ensures U + T == T + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_2842","instance":2842,"id":206185,"goal":"lemma SetInterComm_2842(S: set, U: set)\n ensures S * U == U * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_2843","instance":2843,"id":206186,"goal":"lemma SetUnionAssoc_2843(T: set, S: set, A: set)\n ensures (T + S) + A == T + (S + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_2844","instance":2844,"id":206187,"goal":"lemma SetSubsetRefl_2844(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_2845","instance":2845,"id":206188,"goal":"lemma SetSubsetTrans_2845(A: set, S: set, U: set)\n requires A <= S && S <= U\n ensures A <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_2846","instance":2846,"id":206189,"goal":"lemma SetUnionEmpty_2846(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_2847","instance":2847,"id":206190,"goal":"lemma SetInterEmpty_2847(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_2848","instance":2848,"id":206191,"goal":"lemma SetInterSubset_2848(U: set, A: set)\n ensures U * A <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_2849","instance":2849,"id":206192,"goal":"lemma SetCardSubset_2849(B: set, A: set)\n requires B <= A\n ensures |B| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_2850","instance":2850,"id":206193,"goal":"lemma SetUnionCard_2850(B: set, U: set)\n requires B * U == {}\n ensures |B + U| == |B| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_2851","instance":2851,"id":206194,"goal":"lemma SetUnionComm_2851(S: set, U: set)\n ensures S + U == U + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_2852","instance":2852,"id":206195,"goal":"lemma SetInterComm_2852(S: set, A: set)\n ensures S * A == A * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_2853","instance":2853,"id":206196,"goal":"lemma SetUnionAssoc_2853(A: set, T: set, B: set)\n ensures (A + T) + B == A + (T + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_2854","instance":2854,"id":206197,"goal":"lemma SetSubsetRefl_2854(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_2855","instance":2855,"id":206198,"goal":"lemma SetSubsetTrans_2855(B: set, U: set, A: set)\n requires B <= U && U <= A\n ensures B <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_2856","instance":2856,"id":206199,"goal":"lemma SetUnionEmpty_2856(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_2857","instance":2857,"id":206200,"goal":"lemma SetInterEmpty_2857(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_2858","instance":2858,"id":206201,"goal":"lemma SetInterSubset_2858(U: set, S: set)\n ensures U * S <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_2859","instance":2859,"id":206202,"goal":"lemma SetCardSubset_2859(B: set, S: set)\n requires B <= S\n ensures |B| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_2860","instance":2860,"id":206203,"goal":"lemma SetUnionCard_2860(U: set, B: set)\n requires U * B == {}\n ensures |U + B| == |U| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_2861","instance":2861,"id":206204,"goal":"lemma SetUnionComm_2861(U: set, B: set)\n ensures U + B == B + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_2862","instance":2862,"id":206205,"goal":"lemma SetInterComm_2862(S: set, A: set)\n ensures S * A == A * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_2863","instance":2863,"id":206206,"goal":"lemma SetUnionAssoc_2863(S: set, A: set, U: set)\n ensures (S + A) + U == S + (A + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_2864","instance":2864,"id":206207,"goal":"lemma SetSubsetRefl_2864(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_2865","instance":2865,"id":206208,"goal":"lemma SetSubsetTrans_2865(B: set, S: set, U: set)\n requires B <= S && S <= U\n ensures B <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_2866","instance":2866,"id":206209,"goal":"lemma SetUnionEmpty_2866(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_2867","instance":2867,"id":206210,"goal":"lemma SetInterEmpty_2867(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_2868","instance":2868,"id":206211,"goal":"lemma SetInterSubset_2868(A: set, U: set)\n ensures A * U <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_2869","instance":2869,"id":206212,"goal":"lemma SetCardSubset_2869(U: set, A: set)\n requires U <= A\n ensures |U| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_2870","instance":2870,"id":206213,"goal":"lemma SetUnionCard_2870(U: set, S: set)\n requires U * S == {}\n ensures |U + S| == |U| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_2871","instance":2871,"id":206214,"goal":"lemma SetUnionComm_2871(A: set, U: set)\n ensures A + U == U + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_2872","instance":2872,"id":206215,"goal":"lemma SetInterComm_2872(T: set, A: set)\n ensures T * A == A * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_2873","instance":2873,"id":206216,"goal":"lemma SetUnionAssoc_2873(U: set, B: set, A: set)\n ensures (U + B) + A == U + (B + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_2874","instance":2874,"id":206217,"goal":"lemma SetSubsetRefl_2874(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_2875","instance":2875,"id":206218,"goal":"lemma SetSubsetTrans_2875(B: set, T: set, S: set)\n requires B <= T && T <= S\n ensures B <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_2876","instance":2876,"id":206219,"goal":"lemma SetUnionEmpty_2876(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_2877","instance":2877,"id":206220,"goal":"lemma SetInterEmpty_2877(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_2878","instance":2878,"id":206221,"goal":"lemma SetInterSubset_2878(T: set, U: set)\n ensures T * U <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_2879","instance":2879,"id":206222,"goal":"lemma SetCardSubset_2879(S: set, T: set)\n requires S <= T\n ensures |S| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_2880","instance":2880,"id":206223,"goal":"lemma SetUnionCard_2880(T: set, B: set)\n requires T * B == {}\n ensures |T + B| == |T| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_2881","instance":2881,"id":206224,"goal":"lemma SetUnionComm_2881(S: set, U: set)\n ensures S + U == U + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_2882","instance":2882,"id":206225,"goal":"lemma SetInterComm_2882(S: set, U: set)\n ensures S * U == U * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_2883","instance":2883,"id":206226,"goal":"lemma SetUnionAssoc_2883(U: set, A: set, S: set)\n ensures (U + A) + S == U + (A + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_2884","instance":2884,"id":206227,"goal":"lemma SetSubsetRefl_2884(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_2885","instance":2885,"id":206228,"goal":"lemma SetSubsetTrans_2885(S: set, U: set, A: set)\n requires S <= U && U <= A\n ensures S <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_2886","instance":2886,"id":206229,"goal":"lemma SetUnionEmpty_2886(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_2887","instance":2887,"id":206230,"goal":"lemma SetInterEmpty_2887(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_2888","instance":2888,"id":206231,"goal":"lemma SetInterSubset_2888(T: set, S: set)\n ensures T * S <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_2889","instance":2889,"id":206232,"goal":"lemma SetCardSubset_2889(T: set, S: set)\n requires T <= S\n ensures |T| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_2890","instance":2890,"id":206233,"goal":"lemma SetUnionCard_2890(T: set, A: set)\n requires T * A == {}\n ensures |T + A| == |T| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_2891","instance":2891,"id":206234,"goal":"lemma SetUnionComm_2891(U: set, T: set)\n ensures U + T == T + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_2892","instance":2892,"id":206235,"goal":"lemma SetInterComm_2892(U: set, T: set)\n ensures U * T == T * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_2893","instance":2893,"id":206236,"goal":"lemma SetUnionAssoc_2893(A: set, U: set, T: set)\n ensures (A + U) + T == A + (U + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_2894","instance":2894,"id":206237,"goal":"lemma SetSubsetRefl_2894(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_2895","instance":2895,"id":206238,"goal":"lemma SetSubsetTrans_2895(A: set, U: set, S: set)\n requires A <= U && U <= S\n ensures A <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_2896","instance":2896,"id":206239,"goal":"lemma SetUnionEmpty_2896(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_2897","instance":2897,"id":206240,"goal":"lemma SetInterEmpty_2897(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_2898","instance":2898,"id":206241,"goal":"lemma SetInterSubset_2898(U: set, S: set)\n ensures U * S <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_2899","instance":2899,"id":206242,"goal":"lemma SetCardSubset_2899(T: set, B: set)\n requires T <= B\n ensures |T| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_2900","instance":2900,"id":206243,"goal":"lemma SetUnionCard_2900(U: set, T: set)\n requires U * T == {}\n ensures |U + T| == |U| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_2901","instance":2901,"id":206244,"goal":"lemma SetUnionComm_2901(S: set, U: set)\n ensures S + U == U + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_2902","instance":2902,"id":206245,"goal":"lemma SetInterComm_2902(B: set, S: set)\n ensures B * S == S * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_2903","instance":2903,"id":206246,"goal":"lemma SetUnionAssoc_2903(S: set, T: set, B: set)\n ensures (S + T) + B == S + (T + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_2904","instance":2904,"id":206247,"goal":"lemma SetSubsetRefl_2904(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_2905","instance":2905,"id":206248,"goal":"lemma SetSubsetTrans_2905(B: set, U: set, T: set)\n requires B <= U && U <= T\n ensures B <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_2906","instance":2906,"id":206249,"goal":"lemma SetUnionEmpty_2906(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_2907","instance":2907,"id":206250,"goal":"lemma SetInterEmpty_2907(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_2908","instance":2908,"id":206251,"goal":"lemma SetInterSubset_2908(U: set, B: set)\n ensures U * B <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_2909","instance":2909,"id":206252,"goal":"lemma SetCardSubset_2909(A: set, T: set)\n requires A <= T\n ensures |A| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_2910","instance":2910,"id":206253,"goal":"lemma SetUnionCard_2910(B: set, T: set)\n requires B * T == {}\n ensures |B + T| == |B| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_2911","instance":2911,"id":206254,"goal":"lemma SetUnionComm_2911(A: set, B: set)\n ensures A + B == B + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_2912","instance":2912,"id":206255,"goal":"lemma SetInterComm_2912(A: set, T: set)\n ensures A * T == T * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_2913","instance":2913,"id":206256,"goal":"lemma SetUnionAssoc_2913(A: set, U: set, T: set)\n ensures (A + U) + T == A + (U + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_2914","instance":2914,"id":206257,"goal":"lemma SetSubsetRefl_2914(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_2915","instance":2915,"id":206258,"goal":"lemma SetSubsetTrans_2915(B: set, A: set, U: set)\n requires B <= A && A <= U\n ensures B <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_2916","instance":2916,"id":206259,"goal":"lemma SetUnionEmpty_2916(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_2917","instance":2917,"id":206260,"goal":"lemma SetInterEmpty_2917(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_2918","instance":2918,"id":206261,"goal":"lemma SetInterSubset_2918(U: set, A: set)\n ensures U * A <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_2919","instance":2919,"id":206262,"goal":"lemma SetCardSubset_2919(T: set, B: set)\n requires T <= B\n ensures |T| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_2920","instance":2920,"id":206263,"goal":"lemma SetUnionCard_2920(U: set, A: set)\n requires U * A == {}\n ensures |U + A| == |U| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_2921","instance":2921,"id":206264,"goal":"lemma SetUnionComm_2921(U: set, S: set)\n ensures U + S == S + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_2922","instance":2922,"id":206265,"goal":"lemma SetInterComm_2922(A: set, T: set)\n ensures A * T == T * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_2923","instance":2923,"id":206266,"goal":"lemma SetUnionAssoc_2923(A: set, T: set, U: set)\n ensures (A + T) + U == A + (T + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_2924","instance":2924,"id":206267,"goal":"lemma SetSubsetRefl_2924(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_2925","instance":2925,"id":206268,"goal":"lemma SetSubsetTrans_2925(S: set, U: set, B: set)\n requires S <= U && U <= B\n ensures S <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_2926","instance":2926,"id":206269,"goal":"lemma SetUnionEmpty_2926(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_2927","instance":2927,"id":206270,"goal":"lemma SetInterEmpty_2927(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_2928","instance":2928,"id":206271,"goal":"lemma SetInterSubset_2928(T: set, B: set)\n ensures T * B <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_2929","instance":2929,"id":206272,"goal":"lemma SetCardSubset_2929(B: set, S: set)\n requires B <= S\n ensures |B| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_2930","instance":2930,"id":206273,"goal":"lemma SetUnionCard_2930(U: set, A: set)\n requires U * A == {}\n ensures |U + A| == |U| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_2931","instance":2931,"id":206274,"goal":"lemma SetUnionComm_2931(U: set, A: set)\n ensures U + A == A + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_2932","instance":2932,"id":206275,"goal":"lemma SetInterComm_2932(A: set, T: set)\n ensures A * T == T * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_2933","instance":2933,"id":206276,"goal":"lemma SetUnionAssoc_2933(A: set, S: set, U: set)\n ensures (A + S) + U == A + (S + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_2934","instance":2934,"id":206277,"goal":"lemma SetSubsetRefl_2934(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_2935","instance":2935,"id":206278,"goal":"lemma SetSubsetTrans_2935(T: set, S: set, B: set)\n requires T <= S && S <= B\n ensures T <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_2936","instance":2936,"id":206279,"goal":"lemma SetUnionEmpty_2936(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_2937","instance":2937,"id":206280,"goal":"lemma SetInterEmpty_2937(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_2938","instance":2938,"id":206281,"goal":"lemma SetInterSubset_2938(B: set, S: set)\n ensures B * S <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_2939","instance":2939,"id":206282,"goal":"lemma SetCardSubset_2939(T: set, S: set)\n requires T <= S\n ensures |T| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_2940","instance":2940,"id":206283,"goal":"lemma SetUnionCard_2940(S: set, U: set)\n requires S * U == {}\n ensures |S + U| == |S| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_2941","instance":2941,"id":206284,"goal":"lemma SetUnionComm_2941(B: set, S: set)\n ensures B + S == S + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_2942","instance":2942,"id":206285,"goal":"lemma SetInterComm_2942(B: set, U: set)\n ensures B * U == U * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_2943","instance":2943,"id":206286,"goal":"lemma SetUnionAssoc_2943(U: set, A: set, T: set)\n ensures (U + A) + T == U + (A + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_2944","instance":2944,"id":206287,"goal":"lemma SetSubsetRefl_2944(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_2945","instance":2945,"id":206288,"goal":"lemma SetSubsetTrans_2945(T: set, B: set, U: set)\n requires T <= B && B <= U\n ensures T <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_2946","instance":2946,"id":206289,"goal":"lemma SetUnionEmpty_2946(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_2947","instance":2947,"id":206290,"goal":"lemma SetInterEmpty_2947(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_2948","instance":2948,"id":206291,"goal":"lemma SetInterSubset_2948(U: set, B: set)\n ensures U * B <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_2949","instance":2949,"id":206292,"goal":"lemma SetCardSubset_2949(U: set, A: set)\n requires U <= A\n ensures |U| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_2950","instance":2950,"id":206293,"goal":"lemma SetUnionCard_2950(U: set, S: set)\n requires U * S == {}\n ensures |U + S| == |U| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_2951","instance":2951,"id":206294,"goal":"lemma SetUnionComm_2951(U: set, T: set)\n ensures U + T == T + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_2952","instance":2952,"id":206295,"goal":"lemma SetInterComm_2952(U: set, A: set)\n ensures U * A == A * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_2953","instance":2953,"id":206296,"goal":"lemma SetUnionAssoc_2953(S: set, U: set, T: set)\n ensures (S + U) + T == S + (U + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_2954","instance":2954,"id":206297,"goal":"lemma SetSubsetRefl_2954(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_2955","instance":2955,"id":206298,"goal":"lemma SetSubsetTrans_2955(S: set, U: set, A: set)\n requires S <= U && U <= A\n ensures S <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_2956","instance":2956,"id":206299,"goal":"lemma SetUnionEmpty_2956(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_2957","instance":2957,"id":206300,"goal":"lemma SetInterEmpty_2957(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_2958","instance":2958,"id":206301,"goal":"lemma SetInterSubset_2958(A: set, S: set)\n ensures A * S <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_2959","instance":2959,"id":206302,"goal":"lemma SetCardSubset_2959(T: set, U: set)\n requires T <= U\n ensures |T| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_2960","instance":2960,"id":206303,"goal":"lemma SetUnionCard_2960(S: set, B: set)\n requires S * B == {}\n ensures |S + B| == |S| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_2961","instance":2961,"id":206304,"goal":"lemma SetUnionComm_2961(U: set, S: set)\n ensures U + S == S + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_2962","instance":2962,"id":206305,"goal":"lemma SetInterComm_2962(U: set, B: set)\n ensures U * B == B * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_2963","instance":2963,"id":206306,"goal":"lemma SetUnionAssoc_2963(A: set, T: set, S: set)\n ensures (A + T) + S == A + (T + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_2964","instance":2964,"id":206307,"goal":"lemma SetSubsetRefl_2964(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_2965","instance":2965,"id":206308,"goal":"lemma SetSubsetTrans_2965(U: set, T: set, S: set)\n requires U <= T && T <= S\n ensures U <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_2966","instance":2966,"id":206309,"goal":"lemma SetUnionEmpty_2966(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_2967","instance":2967,"id":206310,"goal":"lemma SetInterEmpty_2967(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_2968","instance":2968,"id":206311,"goal":"lemma SetInterSubset_2968(U: set, A: set)\n ensures U * A <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_2969","instance":2969,"id":206312,"goal":"lemma SetCardSubset_2969(T: set, A: set)\n requires T <= A\n ensures |T| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_2970","instance":2970,"id":206313,"goal":"lemma SetUnionCard_2970(U: set, S: set)\n requires U * S == {}\n ensures |U + S| == |U| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_2971","instance":2971,"id":206314,"goal":"lemma SetUnionComm_2971(T: set, B: set)\n ensures T + B == B + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_2972","instance":2972,"id":206315,"goal":"lemma SetInterComm_2972(U: set, B: set)\n ensures U * B == B * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_2973","instance":2973,"id":206316,"goal":"lemma SetUnionAssoc_2973(U: set, A: set, T: set)\n ensures (U + A) + T == U + (A + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_2974","instance":2974,"id":206317,"goal":"lemma SetSubsetRefl_2974(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_2975","instance":2975,"id":206318,"goal":"lemma SetSubsetTrans_2975(S: set, U: set, T: set)\n requires S <= U && U <= T\n ensures S <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_2976","instance":2976,"id":206319,"goal":"lemma SetUnionEmpty_2976(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_2977","instance":2977,"id":206320,"goal":"lemma SetInterEmpty_2977(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_2978","instance":2978,"id":206321,"goal":"lemma SetInterSubset_2978(T: set, B: set)\n ensures T * B <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_2979","instance":2979,"id":206322,"goal":"lemma SetCardSubset_2979(U: set, T: set)\n requires U <= T\n ensures |U| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_2980","instance":2980,"id":206323,"goal":"lemma SetUnionCard_2980(B: set, U: set)\n requires B * U == {}\n ensures |B + U| == |B| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_2981","instance":2981,"id":206324,"goal":"lemma SetUnionComm_2981(U: set, T: set)\n ensures U + T == T + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_2982","instance":2982,"id":206325,"goal":"lemma SetInterComm_2982(T: set, S: set)\n ensures T * S == S * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_2983","instance":2983,"id":206326,"goal":"lemma SetUnionAssoc_2983(B: set, T: set, U: set)\n ensures (B + T) + U == B + (T + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_2984","instance":2984,"id":206327,"goal":"lemma SetSubsetRefl_2984(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_2985","instance":2985,"id":206328,"goal":"lemma SetSubsetTrans_2985(T: set, B: set, S: set)\n requires T <= B && B <= S\n ensures T <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_2986","instance":2986,"id":206329,"goal":"lemma SetUnionEmpty_2986(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_2987","instance":2987,"id":206330,"goal":"lemma SetInterEmpty_2987(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_2988","instance":2988,"id":206331,"goal":"lemma SetInterSubset_2988(A: set, T: set)\n ensures A * T <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_2989","instance":2989,"id":206332,"goal":"lemma SetCardSubset_2989(T: set, A: set)\n requires T <= A\n ensures |T| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_2990","instance":2990,"id":206333,"goal":"lemma SetUnionCard_2990(T: set, B: set)\n requires T * B == {}\n ensures |T + B| == |T| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_2991","instance":2991,"id":206334,"goal":"lemma SetUnionComm_2991(S: set, T: set)\n ensures S + T == T + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_2992","instance":2992,"id":206335,"goal":"lemma SetInterComm_2992(U: set, B: set)\n ensures U * B == B * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_2993","instance":2993,"id":206336,"goal":"lemma SetUnionAssoc_2993(A: set, U: set, T: set)\n ensures (A + U) + T == A + (U + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_2994","instance":2994,"id":206337,"goal":"lemma SetSubsetRefl_2994(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_2995","instance":2995,"id":206338,"goal":"lemma SetSubsetTrans_2995(A: set, B: set, U: set)\n requires A <= B && B <= U\n ensures A <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_2996","instance":2996,"id":206339,"goal":"lemma SetUnionEmpty_2996(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_2997","instance":2997,"id":206340,"goal":"lemma SetInterEmpty_2997(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_2998","instance":2998,"id":206341,"goal":"lemma SetInterSubset_2998(T: set, U: set)\n ensures T * U <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_2999","instance":2999,"id":206342,"goal":"lemma SetCardSubset_2999(U: set, A: set)\n requires U <= A\n ensures |U| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_3000","instance":3000,"id":206343,"goal":"lemma SetUnionCard_3000(A: set, B: set)\n requires A * B == {}\n ensures |A + B| == |A| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_3001","instance":3001,"id":206344,"goal":"lemma SetUnionComm_3001(S: set, T: set)\n ensures S + T == T + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_3002","instance":3002,"id":206345,"goal":"lemma SetInterComm_3002(A: set, S: set)\n ensures A * S == S * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_3003","instance":3003,"id":206346,"goal":"lemma SetUnionAssoc_3003(U: set, A: set, S: set)\n ensures (U + A) + S == U + (A + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_3004","instance":3004,"id":206347,"goal":"lemma SetSubsetRefl_3004(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_3005","instance":3005,"id":206348,"goal":"lemma SetSubsetTrans_3005(T: set, U: set, S: set)\n requires T <= U && U <= S\n ensures T <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_3006","instance":3006,"id":206349,"goal":"lemma SetUnionEmpty_3006(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_3007","instance":3007,"id":206350,"goal":"lemma SetInterEmpty_3007(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_3008","instance":3008,"id":206351,"goal":"lemma SetInterSubset_3008(U: set, S: set)\n ensures U * S <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_3009","instance":3009,"id":206352,"goal":"lemma SetCardSubset_3009(U: set, S: set)\n requires U <= S\n ensures |U| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_3010","instance":3010,"id":206353,"goal":"lemma SetUnionCard_3010(B: set, U: set)\n requires B * U == {}\n ensures |B + U| == |B| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_3011","instance":3011,"id":206354,"goal":"lemma SetUnionComm_3011(B: set, T: set)\n ensures B + T == T + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_3012","instance":3012,"id":206355,"goal":"lemma SetInterComm_3012(U: set, B: set)\n ensures U * B == B * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_3013","instance":3013,"id":206356,"goal":"lemma SetUnionAssoc_3013(A: set, B: set, T: set)\n ensures (A + B) + T == A + (B + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_3014","instance":3014,"id":206357,"goal":"lemma SetSubsetRefl_3014(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_3015","instance":3015,"id":206358,"goal":"lemma SetSubsetTrans_3015(T: set, S: set, U: set)\n requires T <= S && S <= U\n ensures T <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_3016","instance":3016,"id":206359,"goal":"lemma SetUnionEmpty_3016(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_3017","instance":3017,"id":206360,"goal":"lemma SetInterEmpty_3017(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_3018","instance":3018,"id":206361,"goal":"lemma SetInterSubset_3018(U: set, T: set)\n ensures U * T <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_3019","instance":3019,"id":206362,"goal":"lemma SetCardSubset_3019(U: set, B: set)\n requires U <= B\n ensures |U| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_3020","instance":3020,"id":206363,"goal":"lemma SetUnionCard_3020(U: set, A: set)\n requires U * A == {}\n ensures |U + A| == |U| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_3021","instance":3021,"id":206364,"goal":"lemma SetUnionComm_3021(S: set, B: set)\n ensures S + B == B + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_3022","instance":3022,"id":206365,"goal":"lemma SetInterComm_3022(A: set, T: set)\n ensures A * T == T * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_3023","instance":3023,"id":206366,"goal":"lemma SetUnionAssoc_3023(U: set, S: set, A: set)\n ensures (U + S) + A == U + (S + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_3024","instance":3024,"id":206367,"goal":"lemma SetSubsetRefl_3024(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_3025","instance":3025,"id":206368,"goal":"lemma SetSubsetTrans_3025(A: set, T: set, U: set)\n requires A <= T && T <= U\n ensures A <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_3026","instance":3026,"id":206369,"goal":"lemma SetUnionEmpty_3026(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_3027","instance":3027,"id":206370,"goal":"lemma SetInterEmpty_3027(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_3028","instance":3028,"id":206371,"goal":"lemma SetInterSubset_3028(T: set, B: set)\n ensures T * B <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_3029","instance":3029,"id":206372,"goal":"lemma SetCardSubset_3029(T: set, U: set)\n requires T <= U\n ensures |T| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_3030","instance":3030,"id":206373,"goal":"lemma SetUnionCard_3030(A: set, U: set)\n requires A * U == {}\n ensures |A + U| == |A| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_3031","instance":3031,"id":206374,"goal":"lemma SetUnionComm_3031(B: set, U: set)\n ensures B + U == U + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_3032","instance":3032,"id":206375,"goal":"lemma SetInterComm_3032(T: set, U: set)\n ensures T * U == U * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_3033","instance":3033,"id":206376,"goal":"lemma SetUnionAssoc_3033(S: set, B: set, A: set)\n ensures (S + B) + A == S + (B + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_3034","instance":3034,"id":206377,"goal":"lemma SetSubsetRefl_3034(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_3035","instance":3035,"id":206378,"goal":"lemma SetSubsetTrans_3035(B: set, A: set, S: set)\n requires B <= A && A <= S\n ensures B <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_3036","instance":3036,"id":206379,"goal":"lemma SetUnionEmpty_3036(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_3037","instance":3037,"id":206380,"goal":"lemma SetInterEmpty_3037(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_3038","instance":3038,"id":206381,"goal":"lemma SetInterSubset_3038(U: set, T: set)\n ensures U * T <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_3039","instance":3039,"id":206382,"goal":"lemma SetCardSubset_3039(A: set, T: set)\n requires A <= T\n ensures |A| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_3040","instance":3040,"id":206383,"goal":"lemma SetUnionCard_3040(U: set, A: set)\n requires U * A == {}\n ensures |U + A| == |U| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_3041","instance":3041,"id":206384,"goal":"lemma SetUnionComm_3041(S: set, A: set)\n ensures S + A == A + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_3042","instance":3042,"id":206385,"goal":"lemma SetInterComm_3042(T: set, A: set)\n ensures T * A == A * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_3043","instance":3043,"id":206386,"goal":"lemma SetUnionAssoc_3043(S: set, U: set, B: set)\n ensures (S + U) + B == S + (U + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_3044","instance":3044,"id":206387,"goal":"lemma SetSubsetRefl_3044(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_3045","instance":3045,"id":206388,"goal":"lemma SetSubsetTrans_3045(A: set, B: set, U: set)\n requires A <= B && B <= U\n ensures A <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_3046","instance":3046,"id":206389,"goal":"lemma SetUnionEmpty_3046(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_3047","instance":3047,"id":206390,"goal":"lemma SetInterEmpty_3047(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_3048","instance":3048,"id":206391,"goal":"lemma SetInterSubset_3048(T: set, B: set)\n ensures T * B <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_3049","instance":3049,"id":206392,"goal":"lemma SetCardSubset_3049(B: set, S: set)\n requires B <= S\n ensures |B| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_3050","instance":3050,"id":206393,"goal":"lemma SetUnionCard_3050(T: set, B: set)\n requires T * B == {}\n ensures |T + B| == |T| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_3051","instance":3051,"id":206394,"goal":"lemma SetUnionComm_3051(A: set, U: set)\n ensures A + U == U + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_3052","instance":3052,"id":206395,"goal":"lemma SetInterComm_3052(B: set, U: set)\n ensures B * U == U * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_3053","instance":3053,"id":206396,"goal":"lemma SetUnionAssoc_3053(B: set, A: set, S: set)\n ensures (B + A) + S == B + (A + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_3054","instance":3054,"id":206397,"goal":"lemma SetSubsetRefl_3054(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_3055","instance":3055,"id":206398,"goal":"lemma SetSubsetTrans_3055(T: set, B: set, A: set)\n requires T <= B && B <= A\n ensures T <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_3056","instance":3056,"id":206399,"goal":"lemma SetUnionEmpty_3056(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_3057","instance":3057,"id":206400,"goal":"lemma SetInterEmpty_3057(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_3058","instance":3058,"id":206401,"goal":"lemma SetInterSubset_3058(T: set, U: set)\n ensures T * U <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_3059","instance":3059,"id":206402,"goal":"lemma SetCardSubset_3059(S: set, U: set)\n requires S <= U\n ensures |S| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_3060","instance":3060,"id":206403,"goal":"lemma SetUnionCard_3060(T: set, A: set)\n requires T * A == {}\n ensures |T + A| == |T| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_3061","instance":3061,"id":206404,"goal":"lemma SetUnionComm_3061(B: set, T: set)\n ensures B + T == T + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_3062","instance":3062,"id":206405,"goal":"lemma SetInterComm_3062(T: set, S: set)\n ensures T * S == S * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_3063","instance":3063,"id":206406,"goal":"lemma SetUnionAssoc_3063(A: set, S: set, U: set)\n ensures (A + S) + U == A + (S + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_3064","instance":3064,"id":206407,"goal":"lemma SetSubsetRefl_3064(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_3065","instance":3065,"id":206408,"goal":"lemma SetSubsetTrans_3065(U: set, T: set, A: set)\n requires U <= T && T <= A\n ensures U <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_3066","instance":3066,"id":206409,"goal":"lemma SetUnionEmpty_3066(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_3067","instance":3067,"id":206410,"goal":"lemma SetInterEmpty_3067(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_3068","instance":3068,"id":206411,"goal":"lemma SetInterSubset_3068(S: set, U: set)\n ensures S * U <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_3069","instance":3069,"id":206412,"goal":"lemma SetCardSubset_3069(S: set, T: set)\n requires S <= T\n ensures |S| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_3070","instance":3070,"id":206413,"goal":"lemma SetUnionCard_3070(S: set, T: set)\n requires S * T == {}\n ensures |S + T| == |S| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_3071","instance":3071,"id":206414,"goal":"lemma SetUnionComm_3071(S: set, B: set)\n ensures S + B == B + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_3072","instance":3072,"id":206415,"goal":"lemma SetInterComm_3072(S: set, T: set)\n ensures S * T == T * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_3073","instance":3073,"id":206416,"goal":"lemma SetUnionAssoc_3073(T: set, B: set, S: set)\n ensures (T + B) + S == T + (B + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_3074","instance":3074,"id":206417,"goal":"lemma SetSubsetRefl_3074(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_3075","instance":3075,"id":206418,"goal":"lemma SetSubsetTrans_3075(U: set, B: set, S: set)\n requires U <= B && B <= S\n ensures U <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_3076","instance":3076,"id":206419,"goal":"lemma SetUnionEmpty_3076(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_3077","instance":3077,"id":206420,"goal":"lemma SetInterEmpty_3077(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_3078","instance":3078,"id":206421,"goal":"lemma SetInterSubset_3078(A: set, U: set)\n ensures A * U <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_3079","instance":3079,"id":206422,"goal":"lemma SetCardSubset_3079(S: set, U: set)\n requires S <= U\n ensures |S| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_3080","instance":3080,"id":206423,"goal":"lemma SetUnionCard_3080(B: set, S: set)\n requires B * S == {}\n ensures |B + S| == |B| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_3081","instance":3081,"id":206424,"goal":"lemma SetUnionComm_3081(B: set, U: set)\n ensures B + U == U + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_3082","instance":3082,"id":206425,"goal":"lemma SetInterComm_3082(U: set, S: set)\n ensures U * S == S * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_3083","instance":3083,"id":206426,"goal":"lemma SetUnionAssoc_3083(U: set, A: set, B: set)\n ensures (U + A) + B == U + (A + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_3084","instance":3084,"id":206427,"goal":"lemma SetSubsetRefl_3084(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_3085","instance":3085,"id":206428,"goal":"lemma SetSubsetTrans_3085(U: set, T: set, B: set)\n requires U <= T && T <= B\n ensures U <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_3086","instance":3086,"id":206429,"goal":"lemma SetUnionEmpty_3086(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_3087","instance":3087,"id":206430,"goal":"lemma SetInterEmpty_3087(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_3088","instance":3088,"id":206431,"goal":"lemma SetInterSubset_3088(B: set, T: set)\n ensures B * T <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_3089","instance":3089,"id":206432,"goal":"lemma SetCardSubset_3089(T: set, A: set)\n requires T <= A\n ensures |T| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_3090","instance":3090,"id":206433,"goal":"lemma SetUnionCard_3090(U: set, A: set)\n requires U * A == {}\n ensures |U + A| == |U| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_3091","instance":3091,"id":206434,"goal":"lemma SetUnionComm_3091(A: set, B: set)\n ensures A + B == B + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_3092","instance":3092,"id":206435,"goal":"lemma SetInterComm_3092(B: set, A: set)\n ensures B * A == A * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_3093","instance":3093,"id":206436,"goal":"lemma SetUnionAssoc_3093(T: set, U: set, S: set)\n ensures (T + U) + S == T + (U + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_3094","instance":3094,"id":206437,"goal":"lemma SetSubsetRefl_3094(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_3095","instance":3095,"id":206438,"goal":"lemma SetSubsetTrans_3095(A: set, B: set, T: set)\n requires A <= B && B <= T\n ensures A <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_3096","instance":3096,"id":206439,"goal":"lemma SetUnionEmpty_3096(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_3097","instance":3097,"id":206440,"goal":"lemma SetInterEmpty_3097(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_3098","instance":3098,"id":206441,"goal":"lemma SetInterSubset_3098(B: set, S: set)\n ensures B * S <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_3099","instance":3099,"id":206442,"goal":"lemma SetCardSubset_3099(S: set, T: set)\n requires S <= T\n ensures |S| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_3100","instance":3100,"id":206443,"goal":"lemma SetUnionCard_3100(B: set, A: set)\n requires B * A == {}\n ensures |B + A| == |B| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_3101","instance":3101,"id":206444,"goal":"lemma SetUnionComm_3101(B: set, T: set)\n ensures B + T == T + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_3102","instance":3102,"id":206445,"goal":"lemma SetInterComm_3102(U: set, T: set)\n ensures U * T == T * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_3103","instance":3103,"id":206446,"goal":"lemma SetUnionAssoc_3103(S: set, A: set, U: set)\n ensures (S + A) + U == S + (A + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_3104","instance":3104,"id":206447,"goal":"lemma SetSubsetRefl_3104(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_3105","instance":3105,"id":206448,"goal":"lemma SetSubsetTrans_3105(A: set, B: set, U: set)\n requires A <= B && B <= U\n ensures A <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_3106","instance":3106,"id":206449,"goal":"lemma SetUnionEmpty_3106(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_3107","instance":3107,"id":206450,"goal":"lemma SetInterEmpty_3107(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_3108","instance":3108,"id":206451,"goal":"lemma SetInterSubset_3108(S: set, B: set)\n ensures S * B <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_3109","instance":3109,"id":206452,"goal":"lemma SetCardSubset_3109(S: set, T: set)\n requires S <= T\n ensures |S| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_3110","instance":3110,"id":206453,"goal":"lemma SetUnionCard_3110(T: set, U: set)\n requires T * U == {}\n ensures |T + U| == |T| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_3111","instance":3111,"id":206454,"goal":"lemma SetUnionComm_3111(A: set, B: set)\n ensures A + B == B + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_3112","instance":3112,"id":206455,"goal":"lemma SetInterComm_3112(S: set, U: set)\n ensures S * U == U * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_3113","instance":3113,"id":206456,"goal":"lemma SetUnionAssoc_3113(B: set, U: set, S: set)\n ensures (B + U) + S == B + (U + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_3114","instance":3114,"id":206457,"goal":"lemma SetSubsetRefl_3114(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_3115","instance":3115,"id":206458,"goal":"lemma SetSubsetTrans_3115(A: set, S: set, U: set)\n requires A <= S && S <= U\n ensures A <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_3116","instance":3116,"id":206459,"goal":"lemma SetUnionEmpty_3116(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_3117","instance":3117,"id":206460,"goal":"lemma SetInterEmpty_3117(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_3118","instance":3118,"id":206461,"goal":"lemma SetInterSubset_3118(A: set, B: set)\n ensures A * B <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_3119","instance":3119,"id":206462,"goal":"lemma SetCardSubset_3119(A: set, S: set)\n requires A <= S\n ensures |A| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_3120","instance":3120,"id":206463,"goal":"lemma SetUnionCard_3120(B: set, T: set)\n requires B * T == {}\n ensures |B + T| == |B| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_3121","instance":3121,"id":206464,"goal":"lemma SetUnionComm_3121(B: set, T: set)\n ensures B + T == T + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_3122","instance":3122,"id":206465,"goal":"lemma SetInterComm_3122(B: set, S: set)\n ensures B * S == S * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_3123","instance":3123,"id":206466,"goal":"lemma SetUnionAssoc_3123(B: set, A: set, U: set)\n ensures (B + A) + U == B + (A + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_3124","instance":3124,"id":206467,"goal":"lemma SetSubsetRefl_3124(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_3125","instance":3125,"id":206468,"goal":"lemma SetSubsetTrans_3125(U: set, T: set, A: set)\n requires U <= T && T <= A\n ensures U <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_3126","instance":3126,"id":206469,"goal":"lemma SetUnionEmpty_3126(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_3127","instance":3127,"id":206470,"goal":"lemma SetInterEmpty_3127(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_3128","instance":3128,"id":206471,"goal":"lemma SetInterSubset_3128(U: set, A: set)\n ensures U * A <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_3129","instance":3129,"id":206472,"goal":"lemma SetCardSubset_3129(T: set, U: set)\n requires T <= U\n ensures |T| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_3130","instance":3130,"id":206473,"goal":"lemma SetUnionCard_3130(A: set, U: set)\n requires A * U == {}\n ensures |A + U| == |A| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_3131","instance":3131,"id":206474,"goal":"lemma SetUnionComm_3131(U: set, T: set)\n ensures U + T == T + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_3132","instance":3132,"id":206475,"goal":"lemma SetInterComm_3132(T: set, S: set)\n ensures T * S == S * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_3133","instance":3133,"id":206476,"goal":"lemma SetUnionAssoc_3133(A: set, B: set, U: set)\n ensures (A + B) + U == A + (B + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_3134","instance":3134,"id":206477,"goal":"lemma SetSubsetRefl_3134(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_3135","instance":3135,"id":206478,"goal":"lemma SetSubsetTrans_3135(A: set, S: set, T: set)\n requires A <= S && S <= T\n ensures A <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_3136","instance":3136,"id":206479,"goal":"lemma SetUnionEmpty_3136(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_3137","instance":3137,"id":206480,"goal":"lemma SetInterEmpty_3137(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_3138","instance":3138,"id":206481,"goal":"lemma SetInterSubset_3138(S: set, U: set)\n ensures S * U <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_3139","instance":3139,"id":206482,"goal":"lemma SetCardSubset_3139(A: set, U: set)\n requires A <= U\n ensures |A| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_3140","instance":3140,"id":206483,"goal":"lemma SetUnionCard_3140(S: set, T: set)\n requires S * T == {}\n ensures |S + T| == |S| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_3141","instance":3141,"id":206484,"goal":"lemma SetUnionComm_3141(U: set, T: set)\n ensures U + T == T + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_3142","instance":3142,"id":206485,"goal":"lemma SetInterComm_3142(U: set, B: set)\n ensures U * B == B * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_3143","instance":3143,"id":206486,"goal":"lemma SetUnionAssoc_3143(T: set, A: set, S: set)\n ensures (T + A) + S == T + (A + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_3144","instance":3144,"id":206487,"goal":"lemma SetSubsetRefl_3144(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_3145","instance":3145,"id":206488,"goal":"lemma SetSubsetTrans_3145(U: set, B: set, S: set)\n requires U <= B && B <= S\n ensures U <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_3146","instance":3146,"id":206489,"goal":"lemma SetUnionEmpty_3146(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_3147","instance":3147,"id":206490,"goal":"lemma SetInterEmpty_3147(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_3148","instance":3148,"id":206491,"goal":"lemma SetInterSubset_3148(A: set, B: set)\n ensures A * B <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_3149","instance":3149,"id":206492,"goal":"lemma SetCardSubset_3149(U: set, T: set)\n requires U <= T\n ensures |U| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_3150","instance":3150,"id":206493,"goal":"lemma SetUnionCard_3150(T: set, U: set)\n requires T * U == {}\n ensures |T + U| == |T| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_3151","instance":3151,"id":206494,"goal":"lemma SetUnionComm_3151(B: set, U: set)\n ensures B + U == U + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_3152","instance":3152,"id":206495,"goal":"lemma SetInterComm_3152(S: set, A: set)\n ensures S * A == A * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_3153","instance":3153,"id":206496,"goal":"lemma SetUnionAssoc_3153(U: set, B: set, T: set)\n ensures (U + B) + T == U + (B + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_3154","instance":3154,"id":206497,"goal":"lemma SetSubsetRefl_3154(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_3155","instance":3155,"id":206498,"goal":"lemma SetSubsetTrans_3155(S: set, B: set, U: set)\n requires S <= B && B <= U\n ensures S <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_3156","instance":3156,"id":206499,"goal":"lemma SetUnionEmpty_3156(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_3157","instance":3157,"id":206500,"goal":"lemma SetInterEmpty_3157(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_3158","instance":3158,"id":206501,"goal":"lemma SetInterSubset_3158(B: set, U: set)\n ensures B * U <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_3159","instance":3159,"id":206502,"goal":"lemma SetCardSubset_3159(U: set, S: set)\n requires U <= S\n ensures |U| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_3160","instance":3160,"id":206503,"goal":"lemma SetUnionCard_3160(S: set, T: set)\n requires S * T == {}\n ensures |S + T| == |S| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_3161","instance":3161,"id":206504,"goal":"lemma SetUnionComm_3161(T: set, B: set)\n ensures T + B == B + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_3162","instance":3162,"id":206505,"goal":"lemma SetInterComm_3162(A: set, U: set)\n ensures A * U == U * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_3163","instance":3163,"id":206506,"goal":"lemma SetUnionAssoc_3163(A: set, B: set, U: set)\n ensures (A + B) + U == A + (B + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_3164","instance":3164,"id":206507,"goal":"lemma SetSubsetRefl_3164(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_3165","instance":3165,"id":206508,"goal":"lemma SetSubsetTrans_3165(T: set, A: set, B: set)\n requires T <= A && A <= B\n ensures T <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_3166","instance":3166,"id":206509,"goal":"lemma SetUnionEmpty_3166(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_3167","instance":3167,"id":206510,"goal":"lemma SetInterEmpty_3167(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_3168","instance":3168,"id":206511,"goal":"lemma SetInterSubset_3168(S: set, B: set)\n ensures S * B <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_3169","instance":3169,"id":206512,"goal":"lemma SetCardSubset_3169(U: set, S: set)\n requires U <= S\n ensures |U| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_3170","instance":3170,"id":206513,"goal":"lemma SetUnionCard_3170(S: set, B: set)\n requires S * B == {}\n ensures |S + B| == |S| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_3171","instance":3171,"id":206514,"goal":"lemma SetUnionComm_3171(B: set, T: set)\n ensures B + T == T + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_3172","instance":3172,"id":206515,"goal":"lemma SetInterComm_3172(U: set, A: set)\n ensures U * A == A * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_3173","instance":3173,"id":206516,"goal":"lemma SetUnionAssoc_3173(U: set, S: set, B: set)\n ensures (U + S) + B == U + (S + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_3174","instance":3174,"id":206517,"goal":"lemma SetSubsetRefl_3174(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_3175","instance":3175,"id":206518,"goal":"lemma SetSubsetTrans_3175(A: set, T: set, U: set)\n requires A <= T && T <= U\n ensures A <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_3176","instance":3176,"id":206519,"goal":"lemma SetUnionEmpty_3176(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_3177","instance":3177,"id":206520,"goal":"lemma SetInterEmpty_3177(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_3178","instance":3178,"id":206521,"goal":"lemma SetInterSubset_3178(B: set, A: set)\n ensures B * A <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_3179","instance":3179,"id":206522,"goal":"lemma SetCardSubset_3179(T: set, U: set)\n requires T <= U\n ensures |T| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_3180","instance":3180,"id":206523,"goal":"lemma SetUnionCard_3180(B: set, U: set)\n requires B * U == {}\n ensures |B + U| == |B| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_3181","instance":3181,"id":206524,"goal":"lemma SetUnionComm_3181(U: set, T: set)\n ensures U + T == T + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_3182","instance":3182,"id":206525,"goal":"lemma SetInterComm_3182(A: set, S: set)\n ensures A * S == S * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_3183","instance":3183,"id":206526,"goal":"lemma SetUnionAssoc_3183(A: set, U: set, S: set)\n ensures (A + U) + S == A + (U + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_3184","instance":3184,"id":206527,"goal":"lemma SetSubsetRefl_3184(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_3185","instance":3185,"id":206528,"goal":"lemma SetSubsetTrans_3185(U: set, A: set, B: set)\n requires U <= A && A <= B\n ensures U <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_3186","instance":3186,"id":206529,"goal":"lemma SetUnionEmpty_3186(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_3187","instance":3187,"id":206530,"goal":"lemma SetInterEmpty_3187(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_3188","instance":3188,"id":206531,"goal":"lemma SetInterSubset_3188(U: set, A: set)\n ensures U * A <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_3189","instance":3189,"id":206532,"goal":"lemma SetCardSubset_3189(T: set, U: set)\n requires T <= U\n ensures |T| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_3190","instance":3190,"id":206533,"goal":"lemma SetUnionCard_3190(A: set, T: set)\n requires A * T == {}\n ensures |A + T| == |A| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_3191","instance":3191,"id":206534,"goal":"lemma SetUnionComm_3191(U: set, A: set)\n ensures U + A == A + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_3192","instance":3192,"id":206535,"goal":"lemma SetInterComm_3192(B: set, U: set)\n ensures B * U == U * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_3193","instance":3193,"id":206536,"goal":"lemma SetUnionAssoc_3193(T: set, U: set, B: set)\n ensures (T + U) + B == T + (U + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_3194","instance":3194,"id":206537,"goal":"lemma SetSubsetRefl_3194(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_3195","instance":3195,"id":206538,"goal":"lemma SetSubsetTrans_3195(T: set, B: set, U: set)\n requires T <= B && B <= U\n ensures T <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_3196","instance":3196,"id":206539,"goal":"lemma SetUnionEmpty_3196(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_3197","instance":3197,"id":206540,"goal":"lemma SetInterEmpty_3197(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_3198","instance":3198,"id":206541,"goal":"lemma SetInterSubset_3198(B: set, U: set)\n ensures B * U <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_3199","instance":3199,"id":206542,"goal":"lemma SetCardSubset_3199(T: set, U: set)\n requires T <= U\n ensures |T| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_3200","instance":3200,"id":206543,"goal":"lemma SetUnionCard_3200(T: set, A: set)\n requires T * A == {}\n ensures |T + A| == |T| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_3201","instance":3201,"id":206544,"goal":"lemma SetUnionComm_3201(S: set, A: set)\n ensures S + A == A + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_3202","instance":3202,"id":206545,"goal":"lemma SetInterComm_3202(U: set, A: set)\n ensures U * A == A * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_3203","instance":3203,"id":206546,"goal":"lemma SetUnionAssoc_3203(B: set, U: set, T: set)\n ensures (B + U) + T == B + (U + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_3204","instance":3204,"id":206547,"goal":"lemma SetSubsetRefl_3204(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_3205","instance":3205,"id":206548,"goal":"lemma SetSubsetTrans_3205(U: set, B: set, A: set)\n requires U <= B && B <= A\n ensures U <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_3206","instance":3206,"id":206549,"goal":"lemma SetUnionEmpty_3206(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_3207","instance":3207,"id":206550,"goal":"lemma SetInterEmpty_3207(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_3208","instance":3208,"id":206551,"goal":"lemma SetInterSubset_3208(B: set, U: set)\n ensures B * U <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_3209","instance":3209,"id":206552,"goal":"lemma SetCardSubset_3209(B: set, U: set)\n requires B <= U\n ensures |B| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_3210","instance":3210,"id":206553,"goal":"lemma SetUnionCard_3210(A: set, S: set)\n requires A * S == {}\n ensures |A + S| == |A| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_3211","instance":3211,"id":206554,"goal":"lemma SetUnionComm_3211(A: set, U: set)\n ensures A + U == U + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_3212","instance":3212,"id":206555,"goal":"lemma SetInterComm_3212(U: set, B: set)\n ensures U * B == B * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_3213","instance":3213,"id":206556,"goal":"lemma SetUnionAssoc_3213(S: set, B: set, U: set)\n ensures (S + B) + U == S + (B + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_3214","instance":3214,"id":206557,"goal":"lemma SetSubsetRefl_3214(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_3215","instance":3215,"id":206558,"goal":"lemma SetSubsetTrans_3215(S: set, A: set, T: set)\n requires S <= A && A <= T\n ensures S <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_3216","instance":3216,"id":206559,"goal":"lemma SetUnionEmpty_3216(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_3217","instance":3217,"id":206560,"goal":"lemma SetInterEmpty_3217(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_3218","instance":3218,"id":206561,"goal":"lemma SetInterSubset_3218(A: set, U: set)\n ensures A * U <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_3219","instance":3219,"id":206562,"goal":"lemma SetCardSubset_3219(T: set, B: set)\n requires T <= B\n ensures |T| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_3220","instance":3220,"id":206563,"goal":"lemma SetUnionCard_3220(B: set, T: set)\n requires B * T == {}\n ensures |B + T| == |B| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_3221","instance":3221,"id":206564,"goal":"lemma SetUnionComm_3221(U: set, B: set)\n ensures U + B == B + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_3222","instance":3222,"id":206565,"goal":"lemma SetInterComm_3222(T: set, B: set)\n ensures T * B == B * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_3223","instance":3223,"id":206566,"goal":"lemma SetUnionAssoc_3223(S: set, U: set, T: set)\n ensures (S + U) + T == S + (U + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_3224","instance":3224,"id":206567,"goal":"lemma SetSubsetRefl_3224(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_3225","instance":3225,"id":206568,"goal":"lemma SetSubsetTrans_3225(S: set, T: set, A: set)\n requires S <= T && T <= A\n ensures S <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_3226","instance":3226,"id":206569,"goal":"lemma SetUnionEmpty_3226(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_3227","instance":3227,"id":206570,"goal":"lemma SetInterEmpty_3227(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_3228","instance":3228,"id":206571,"goal":"lemma SetInterSubset_3228(B: set, S: set)\n ensures B * S <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_3229","instance":3229,"id":206572,"goal":"lemma SetCardSubset_3229(S: set, A: set)\n requires S <= A\n ensures |S| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_3230","instance":3230,"id":206573,"goal":"lemma SetUnionCard_3230(T: set, B: set)\n requires T * B == {}\n ensures |T + B| == |T| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_3231","instance":3231,"id":206574,"goal":"lemma SetUnionComm_3231(B: set, A: set)\n ensures B + A == A + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_3232","instance":3232,"id":206575,"goal":"lemma SetInterComm_3232(U: set, A: set)\n ensures U * A == A * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_3233","instance":3233,"id":206576,"goal":"lemma SetUnionAssoc_3233(S: set, U: set, T: set)\n ensures (S + U) + T == S + (U + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_3234","instance":3234,"id":206577,"goal":"lemma SetSubsetRefl_3234(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_3235","instance":3235,"id":206578,"goal":"lemma SetSubsetTrans_3235(T: set, S: set, B: set)\n requires T <= S && S <= B\n ensures T <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_3236","instance":3236,"id":206579,"goal":"lemma SetUnionEmpty_3236(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_3237","instance":3237,"id":206580,"goal":"lemma SetInterEmpty_3237(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_3238","instance":3238,"id":206581,"goal":"lemma SetInterSubset_3238(T: set, B: set)\n ensures T * B <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_3239","instance":3239,"id":206582,"goal":"lemma SetCardSubset_3239(U: set, T: set)\n requires U <= T\n ensures |U| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_3240","instance":3240,"id":206583,"goal":"lemma SetUnionCard_3240(S: set, A: set)\n requires S * A == {}\n ensures |S + A| == |S| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_3241","instance":3241,"id":206584,"goal":"lemma SetUnionComm_3241(A: set, S: set)\n ensures A + S == S + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_3242","instance":3242,"id":206585,"goal":"lemma SetInterComm_3242(S: set, U: set)\n ensures S * U == U * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_3243","instance":3243,"id":206586,"goal":"lemma SetUnionAssoc_3243(T: set, U: set, S: set)\n ensures (T + U) + S == T + (U + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_3244","instance":3244,"id":206587,"goal":"lemma SetSubsetRefl_3244(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_3245","instance":3245,"id":206588,"goal":"lemma SetSubsetTrans_3245(S: set, U: set, B: set)\n requires S <= U && U <= B\n ensures S <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_3246","instance":3246,"id":206589,"goal":"lemma SetUnionEmpty_3246(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_3247","instance":3247,"id":206590,"goal":"lemma SetInterEmpty_3247(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_3248","instance":3248,"id":206591,"goal":"lemma SetInterSubset_3248(T: set, S: set)\n ensures T * S <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_3249","instance":3249,"id":206592,"goal":"lemma SetCardSubset_3249(U: set, A: set)\n requires U <= A\n ensures |U| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_3250","instance":3250,"id":206593,"goal":"lemma SetUnionCard_3250(T: set, U: set)\n requires T * U == {}\n ensures |T + U| == |T| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_3251","instance":3251,"id":206594,"goal":"lemma SetUnionComm_3251(A: set, T: set)\n ensures A + T == T + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_3252","instance":3252,"id":206595,"goal":"lemma SetInterComm_3252(B: set, S: set)\n ensures B * S == S * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_3253","instance":3253,"id":206596,"goal":"lemma SetUnionAssoc_3253(S: set, A: set, U: set)\n ensures (S + A) + U == S + (A + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_3254","instance":3254,"id":206597,"goal":"lemma SetSubsetRefl_3254(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_3255","instance":3255,"id":206598,"goal":"lemma SetSubsetTrans_3255(B: set, T: set, S: set)\n requires B <= T && T <= S\n ensures B <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_3256","instance":3256,"id":206599,"goal":"lemma SetUnionEmpty_3256(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_3257","instance":3257,"id":206600,"goal":"lemma SetInterEmpty_3257(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_3258","instance":3258,"id":206601,"goal":"lemma SetInterSubset_3258(S: set, B: set)\n ensures S * B <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_3259","instance":3259,"id":206602,"goal":"lemma SetCardSubset_3259(U: set, A: set)\n requires U <= A\n ensures |U| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_3260","instance":3260,"id":206603,"goal":"lemma SetUnionCard_3260(S: set, T: set)\n requires S * T == {}\n ensures |S + T| == |S| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_3261","instance":3261,"id":206604,"goal":"lemma SetUnionComm_3261(S: set, U: set)\n ensures S + U == U + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_3262","instance":3262,"id":206605,"goal":"lemma SetInterComm_3262(A: set, U: set)\n ensures A * U == U * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_3263","instance":3263,"id":206606,"goal":"lemma SetUnionAssoc_3263(T: set, A: set, S: set)\n ensures (T + A) + S == T + (A + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_3264","instance":3264,"id":206607,"goal":"lemma SetSubsetRefl_3264(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_3265","instance":3265,"id":206608,"goal":"lemma SetSubsetTrans_3265(U: set, S: set, T: set)\n requires U <= S && S <= T\n ensures U <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_3266","instance":3266,"id":206609,"goal":"lemma SetUnionEmpty_3266(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_3267","instance":3267,"id":206610,"goal":"lemma SetInterEmpty_3267(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_3268","instance":3268,"id":206611,"goal":"lemma SetInterSubset_3268(T: set, S: set)\n ensures T * S <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_3269","instance":3269,"id":206612,"goal":"lemma SetCardSubset_3269(S: set, A: set)\n requires S <= A\n ensures |S| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_3270","instance":3270,"id":206613,"goal":"lemma SetUnionCard_3270(A: set, S: set)\n requires A * S == {}\n ensures |A + S| == |A| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_3271","instance":3271,"id":206614,"goal":"lemma SetUnionComm_3271(U: set, T: set)\n ensures U + T == T + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_3272","instance":3272,"id":206615,"goal":"lemma SetInterComm_3272(T: set, A: set)\n ensures T * A == A * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_3273","instance":3273,"id":206616,"goal":"lemma SetUnionAssoc_3273(T: set, A: set, U: set)\n ensures (T + A) + U == T + (A + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_3274","instance":3274,"id":206617,"goal":"lemma SetSubsetRefl_3274(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_3275","instance":3275,"id":206618,"goal":"lemma SetSubsetTrans_3275(A: set, T: set, S: set)\n requires A <= T && T <= S\n ensures A <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_3276","instance":3276,"id":206619,"goal":"lemma SetUnionEmpty_3276(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_3277","instance":3277,"id":206620,"goal":"lemma SetInterEmpty_3277(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_3278","instance":3278,"id":206621,"goal":"lemma SetInterSubset_3278(S: set, A: set)\n ensures S * A <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_3279","instance":3279,"id":206622,"goal":"lemma SetCardSubset_3279(B: set, U: set)\n requires B <= U\n ensures |B| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_3280","instance":3280,"id":206623,"goal":"lemma SetUnionCard_3280(S: set, U: set)\n requires S * U == {}\n ensures |S + U| == |S| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_3281","instance":3281,"id":206624,"goal":"lemma SetUnionComm_3281(T: set, S: set)\n ensures T + S == S + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_3282","instance":3282,"id":206625,"goal":"lemma SetInterComm_3282(S: set, T: set)\n ensures S * T == T * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_3283","instance":3283,"id":206626,"goal":"lemma SetUnionAssoc_3283(A: set, B: set, T: set)\n ensures (A + B) + T == A + (B + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_3284","instance":3284,"id":206627,"goal":"lemma SetSubsetRefl_3284(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_3285","instance":3285,"id":206628,"goal":"lemma SetSubsetTrans_3285(A: set, T: set, B: set)\n requires A <= T && T <= B\n ensures A <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_3286","instance":3286,"id":206629,"goal":"lemma SetUnionEmpty_3286(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_3287","instance":3287,"id":206630,"goal":"lemma SetInterEmpty_3287(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_3288","instance":3288,"id":206631,"goal":"lemma SetInterSubset_3288(A: set, T: set)\n ensures A * T <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_3289","instance":3289,"id":206632,"goal":"lemma SetCardSubset_3289(S: set, B: set)\n requires S <= B\n ensures |S| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_3290","instance":3290,"id":206633,"goal":"lemma SetUnionCard_3290(U: set, T: set)\n requires U * T == {}\n ensures |U + T| == |U| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_3291","instance":3291,"id":206634,"goal":"lemma SetUnionComm_3291(A: set, S: set)\n ensures A + S == S + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_3292","instance":3292,"id":206635,"goal":"lemma SetInterComm_3292(B: set, U: set)\n ensures B * U == U * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_3293","instance":3293,"id":206636,"goal":"lemma SetUnionAssoc_3293(T: set, U: set, A: set)\n ensures (T + U) + A == T + (U + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_3294","instance":3294,"id":206637,"goal":"lemma SetSubsetRefl_3294(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_3295","instance":3295,"id":206638,"goal":"lemma SetSubsetTrans_3295(B: set, T: set, A: set)\n requires B <= T && T <= A\n ensures B <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_3296","instance":3296,"id":206639,"goal":"lemma SetUnionEmpty_3296(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_3297","instance":3297,"id":206640,"goal":"lemma SetInterEmpty_3297(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_3298","instance":3298,"id":206641,"goal":"lemma SetInterSubset_3298(B: set, S: set)\n ensures B * S <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_3299","instance":3299,"id":206642,"goal":"lemma SetCardSubset_3299(B: set, S: set)\n requires B <= S\n ensures |B| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_3300","instance":3300,"id":206643,"goal":"lemma SetUnionCard_3300(T: set, U: set)\n requires T * U == {}\n ensures |T + U| == |T| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_3301","instance":3301,"id":206644,"goal":"lemma SetUnionComm_3301(B: set, A: set)\n ensures B + A == A + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_3302","instance":3302,"id":206645,"goal":"lemma SetInterComm_3302(T: set, U: set)\n ensures T * U == U * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_3303","instance":3303,"id":206646,"goal":"lemma SetUnionAssoc_3303(B: set, T: set, U: set)\n ensures (B + T) + U == B + (T + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_3304","instance":3304,"id":206647,"goal":"lemma SetSubsetRefl_3304(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_3305","instance":3305,"id":206648,"goal":"lemma SetSubsetTrans_3305(U: set, T: set, B: set)\n requires U <= T && T <= B\n ensures U <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_3306","instance":3306,"id":206649,"goal":"lemma SetUnionEmpty_3306(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_3307","instance":3307,"id":206650,"goal":"lemma SetInterEmpty_3307(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_3308","instance":3308,"id":206651,"goal":"lemma SetInterSubset_3308(A: set, S: set)\n ensures A * S <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_3309","instance":3309,"id":206652,"goal":"lemma SetCardSubset_3309(A: set, S: set)\n requires A <= S\n ensures |A| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_3310","instance":3310,"id":206653,"goal":"lemma SetUnionCard_3310(S: set, A: set)\n requires S * A == {}\n ensures |S + A| == |S| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_3311","instance":3311,"id":206654,"goal":"lemma SetUnionComm_3311(A: set, T: set)\n ensures A + T == T + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_3312","instance":3312,"id":206655,"goal":"lemma SetInterComm_3312(T: set, A: set)\n ensures T * A == A * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_3313","instance":3313,"id":206656,"goal":"lemma SetUnionAssoc_3313(S: set, A: set, B: set)\n ensures (S + A) + B == S + (A + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_3314","instance":3314,"id":206657,"goal":"lemma SetSubsetRefl_3314(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_3315","instance":3315,"id":206658,"goal":"lemma SetSubsetTrans_3315(U: set, S: set, T: set)\n requires U <= S && S <= T\n ensures U <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_3316","instance":3316,"id":206659,"goal":"lemma SetUnionEmpty_3316(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_3317","instance":3317,"id":206660,"goal":"lemma SetInterEmpty_3317(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_3318","instance":3318,"id":206661,"goal":"lemma SetInterSubset_3318(A: set, B: set)\n ensures A * B <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_3319","instance":3319,"id":206662,"goal":"lemma SetCardSubset_3319(U: set, A: set)\n requires U <= A\n ensures |U| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_3320","instance":3320,"id":206663,"goal":"lemma SetUnionCard_3320(T: set, U: set)\n requires T * U == {}\n ensures |T + U| == |T| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_3321","instance":3321,"id":206664,"goal":"lemma SetUnionComm_3321(S: set, B: set)\n ensures S + B == B + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_3322","instance":3322,"id":206665,"goal":"lemma SetInterComm_3322(S: set, A: set)\n ensures S * A == A * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_3323","instance":3323,"id":206666,"goal":"lemma SetUnionAssoc_3323(T: set, U: set, B: set)\n ensures (T + U) + B == T + (U + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_3324","instance":3324,"id":206667,"goal":"lemma SetSubsetRefl_3324(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_3325","instance":3325,"id":206668,"goal":"lemma SetSubsetTrans_3325(A: set, U: set, T: set)\n requires A <= U && U <= T\n ensures A <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_3326","instance":3326,"id":206669,"goal":"lemma SetUnionEmpty_3326(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_3327","instance":3327,"id":206670,"goal":"lemma SetInterEmpty_3327(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_3328","instance":3328,"id":206671,"goal":"lemma SetInterSubset_3328(A: set, U: set)\n ensures A * U <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_3329","instance":3329,"id":206672,"goal":"lemma SetCardSubset_3329(S: set, B: set)\n requires S <= B\n ensures |S| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_3330","instance":3330,"id":206673,"goal":"lemma SetUnionCard_3330(A: set, U: set)\n requires A * U == {}\n ensures |A + U| == |A| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_3331","instance":3331,"id":206674,"goal":"lemma SetUnionComm_3331(B: set, U: set)\n ensures B + U == U + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_3332","instance":3332,"id":206675,"goal":"lemma SetInterComm_3332(T: set, A: set)\n ensures T * A == A * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_3333","instance":3333,"id":206676,"goal":"lemma SetUnionAssoc_3333(S: set, B: set, A: set)\n ensures (S + B) + A == S + (B + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_3334","instance":3334,"id":206677,"goal":"lemma SetSubsetRefl_3334(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_3335","instance":3335,"id":206678,"goal":"lemma SetSubsetTrans_3335(B: set, S: set, U: set)\n requires B <= S && S <= U\n ensures B <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_3336","instance":3336,"id":206679,"goal":"lemma SetUnionEmpty_3336(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_3337","instance":3337,"id":206680,"goal":"lemma SetInterEmpty_3337(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_3338","instance":3338,"id":206681,"goal":"lemma SetInterSubset_3338(U: set, T: set)\n ensures U * T <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_3339","instance":3339,"id":206682,"goal":"lemma SetCardSubset_3339(S: set, A: set)\n requires S <= A\n ensures |S| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_3340","instance":3340,"id":206683,"goal":"lemma SetUnionCard_3340(B: set, U: set)\n requires B * U == {}\n ensures |B + U| == |B| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_3341","instance":3341,"id":206684,"goal":"lemma SetUnionComm_3341(A: set, U: set)\n ensures A + U == U + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_3342","instance":3342,"id":206685,"goal":"lemma SetInterComm_3342(U: set, A: set)\n ensures U * A == A * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_3343","instance":3343,"id":206686,"goal":"lemma SetUnionAssoc_3343(S: set, A: set, T: set)\n ensures (S + A) + T == S + (A + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_3344","instance":3344,"id":206687,"goal":"lemma SetSubsetRefl_3344(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_3345","instance":3345,"id":206688,"goal":"lemma SetSubsetTrans_3345(U: set, S: set, T: set)\n requires U <= S && S <= T\n ensures U <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_3346","instance":3346,"id":206689,"goal":"lemma SetUnionEmpty_3346(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_3347","instance":3347,"id":206690,"goal":"lemma SetInterEmpty_3347(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_3348","instance":3348,"id":206691,"goal":"lemma SetInterSubset_3348(B: set, S: set)\n ensures B * S <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_3349","instance":3349,"id":206692,"goal":"lemma SetCardSubset_3349(A: set, S: set)\n requires A <= S\n ensures |A| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_3350","instance":3350,"id":206693,"goal":"lemma SetUnionCard_3350(B: set, U: set)\n requires B * U == {}\n ensures |B + U| == |B| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_3351","instance":3351,"id":206694,"goal":"lemma SetUnionComm_3351(S: set, A: set)\n ensures S + A == A + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_3352","instance":3352,"id":206695,"goal":"lemma SetInterComm_3352(A: set, S: set)\n ensures A * S == S * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_3353","instance":3353,"id":206696,"goal":"lemma SetUnionAssoc_3353(S: set, U: set, B: set)\n ensures (S + U) + B == S + (U + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_3354","instance":3354,"id":206697,"goal":"lemma SetSubsetRefl_3354(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_3355","instance":3355,"id":206698,"goal":"lemma SetSubsetTrans_3355(T: set, U: set, S: set)\n requires T <= U && U <= S\n ensures T <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_3356","instance":3356,"id":206699,"goal":"lemma SetUnionEmpty_3356(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_3357","instance":3357,"id":206700,"goal":"lemma SetInterEmpty_3357(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_3358","instance":3358,"id":206701,"goal":"lemma SetInterSubset_3358(S: set, U: set)\n ensures S * U <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_3359","instance":3359,"id":206702,"goal":"lemma SetCardSubset_3359(A: set, B: set)\n requires A <= B\n ensures |A| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_3360","instance":3360,"id":206703,"goal":"lemma SetUnionCard_3360(T: set, U: set)\n requires T * U == {}\n ensures |T + U| == |T| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_3361","instance":3361,"id":206704,"goal":"lemma SetUnionComm_3361(A: set, B: set)\n ensures A + B == B + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_3362","instance":3362,"id":206705,"goal":"lemma SetInterComm_3362(U: set, T: set)\n ensures U * T == T * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_3363","instance":3363,"id":206706,"goal":"lemma SetUnionAssoc_3363(B: set, A: set, S: set)\n ensures (B + A) + S == B + (A + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_3364","instance":3364,"id":206707,"goal":"lemma SetSubsetRefl_3364(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_3365","instance":3365,"id":206708,"goal":"lemma SetSubsetTrans_3365(A: set, U: set, B: set)\n requires A <= U && U <= B\n ensures A <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_3366","instance":3366,"id":206709,"goal":"lemma SetUnionEmpty_3366(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_3367","instance":3367,"id":206710,"goal":"lemma SetInterEmpty_3367(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_3368","instance":3368,"id":206711,"goal":"lemma SetInterSubset_3368(S: set, B: set)\n ensures S * B <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_3369","instance":3369,"id":206712,"goal":"lemma SetCardSubset_3369(B: set, A: set)\n requires B <= A\n ensures |B| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_3370","instance":3370,"id":206713,"goal":"lemma SetUnionCard_3370(A: set, T: set)\n requires A * T == {}\n ensures |A + T| == |A| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_3371","instance":3371,"id":206714,"goal":"lemma SetUnionComm_3371(B: set, A: set)\n ensures B + A == A + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_3372","instance":3372,"id":206715,"goal":"lemma SetInterComm_3372(B: set, T: set)\n ensures B * T == T * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_3373","instance":3373,"id":206716,"goal":"lemma SetUnionAssoc_3373(U: set, S: set, B: set)\n ensures (U + S) + B == U + (S + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_3374","instance":3374,"id":206717,"goal":"lemma SetSubsetRefl_3374(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_3375","instance":3375,"id":206718,"goal":"lemma SetSubsetTrans_3375(U: set, T: set, S: set)\n requires U <= T && T <= S\n ensures U <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_3376","instance":3376,"id":206719,"goal":"lemma SetUnionEmpty_3376(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_3377","instance":3377,"id":206720,"goal":"lemma SetInterEmpty_3377(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_3378","instance":3378,"id":206721,"goal":"lemma SetInterSubset_3378(B: set, U: set)\n ensures B * U <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_3379","instance":3379,"id":206722,"goal":"lemma SetCardSubset_3379(U: set, T: set)\n requires U <= T\n ensures |U| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_3380","instance":3380,"id":206723,"goal":"lemma SetUnionCard_3380(U: set, B: set)\n requires U * B == {}\n ensures |U + B| == |U| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_3381","instance":3381,"id":206724,"goal":"lemma SetUnionComm_3381(U: set, B: set)\n ensures U + B == B + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_3382","instance":3382,"id":206725,"goal":"lemma SetInterComm_3382(S: set, T: set)\n ensures S * T == T * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_3383","instance":3383,"id":206726,"goal":"lemma SetUnionAssoc_3383(A: set, B: set, S: set)\n ensures (A + B) + S == A + (B + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_3384","instance":3384,"id":206727,"goal":"lemma SetSubsetRefl_3384(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_3385","instance":3385,"id":206728,"goal":"lemma SetSubsetTrans_3385(U: set, A: set, T: set)\n requires U <= A && A <= T\n ensures U <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_3386","instance":3386,"id":206729,"goal":"lemma SetUnionEmpty_3386(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_3387","instance":3387,"id":206730,"goal":"lemma SetInterEmpty_3387(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_3388","instance":3388,"id":206731,"goal":"lemma SetInterSubset_3388(A: set, B: set)\n ensures A * B <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_3389","instance":3389,"id":206732,"goal":"lemma SetCardSubset_3389(A: set, U: set)\n requires A <= U\n ensures |A| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_3390","instance":3390,"id":206733,"goal":"lemma SetUnionCard_3390(B: set, S: set)\n requires B * S == {}\n ensures |B + S| == |B| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_3391","instance":3391,"id":206734,"goal":"lemma SetUnionComm_3391(U: set, A: set)\n ensures U + A == A + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_3392","instance":3392,"id":206735,"goal":"lemma SetInterComm_3392(A: set, B: set)\n ensures A * B == B * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_3393","instance":3393,"id":206736,"goal":"lemma SetUnionAssoc_3393(S: set, U: set, T: set)\n ensures (S + U) + T == S + (U + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_3394","instance":3394,"id":206737,"goal":"lemma SetSubsetRefl_3394(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_3395","instance":3395,"id":206738,"goal":"lemma SetSubsetTrans_3395(T: set, A: set, B: set)\n requires T <= A && A <= B\n ensures T <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_3396","instance":3396,"id":206739,"goal":"lemma SetUnionEmpty_3396(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_3397","instance":3397,"id":206740,"goal":"lemma SetInterEmpty_3397(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_3398","instance":3398,"id":206741,"goal":"lemma SetInterSubset_3398(B: set, U: set)\n ensures B * U <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_3399","instance":3399,"id":206742,"goal":"lemma SetCardSubset_3399(S: set, B: set)\n requires S <= B\n ensures |S| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_3400","instance":3400,"id":206743,"goal":"lemma SetUnionCard_3400(A: set, S: set)\n requires A * S == {}\n ensures |A + S| == |A| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_3401","instance":3401,"id":206744,"goal":"lemma SetUnionComm_3401(A: set, U: set)\n ensures A + U == U + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_3402","instance":3402,"id":206745,"goal":"lemma SetInterComm_3402(U: set, T: set)\n ensures U * T == T * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_3403","instance":3403,"id":206746,"goal":"lemma SetUnionAssoc_3403(U: set, S: set, T: set)\n ensures (U + S) + T == U + (S + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_3404","instance":3404,"id":206747,"goal":"lemma SetSubsetRefl_3404(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_3405","instance":3405,"id":206748,"goal":"lemma SetSubsetTrans_3405(U: set, B: set, A: set)\n requires U <= B && B <= A\n ensures U <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_3406","instance":3406,"id":206749,"goal":"lemma SetUnionEmpty_3406(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_3407","instance":3407,"id":206750,"goal":"lemma SetInterEmpty_3407(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_3408","instance":3408,"id":206751,"goal":"lemma SetInterSubset_3408(B: set, S: set)\n ensures B * S <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_3409","instance":3409,"id":206752,"goal":"lemma SetCardSubset_3409(A: set, S: set)\n requires A <= S\n ensures |A| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_3410","instance":3410,"id":206753,"goal":"lemma SetUnionCard_3410(S: set, T: set)\n requires S * T == {}\n ensures |S + T| == |S| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_3411","instance":3411,"id":206754,"goal":"lemma SetUnionComm_3411(T: set, U: set)\n ensures T + U == U + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_3412","instance":3412,"id":206755,"goal":"lemma SetInterComm_3412(T: set, U: set)\n ensures T * U == U * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_3413","instance":3413,"id":206756,"goal":"lemma SetUnionAssoc_3413(A: set, S: set, T: set)\n ensures (A + S) + T == A + (S + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_3414","instance":3414,"id":206757,"goal":"lemma SetSubsetRefl_3414(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_3415","instance":3415,"id":206758,"goal":"lemma SetSubsetTrans_3415(A: set, B: set, S: set)\n requires A <= B && B <= S\n ensures A <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_3416","instance":3416,"id":206759,"goal":"lemma SetUnionEmpty_3416(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_3417","instance":3417,"id":206760,"goal":"lemma SetInterEmpty_3417(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_3418","instance":3418,"id":206761,"goal":"lemma SetInterSubset_3418(S: set, T: set)\n ensures S * T <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_3419","instance":3419,"id":206762,"goal":"lemma SetCardSubset_3419(A: set, S: set)\n requires A <= S\n ensures |A| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_3420","instance":3420,"id":206763,"goal":"lemma SetUnionCard_3420(S: set, A: set)\n requires S * A == {}\n ensures |S + A| == |S| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_3421","instance":3421,"id":206764,"goal":"lemma SetUnionComm_3421(S: set, B: set)\n ensures S + B == B + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_3422","instance":3422,"id":206765,"goal":"lemma SetInterComm_3422(U: set, S: set)\n ensures U * S == S * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_3423","instance":3423,"id":206766,"goal":"lemma SetUnionAssoc_3423(T: set, B: set, S: set)\n ensures (T + B) + S == T + (B + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_3424","instance":3424,"id":206767,"goal":"lemma SetSubsetRefl_3424(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_3425","instance":3425,"id":206768,"goal":"lemma SetSubsetTrans_3425(A: set, U: set, S: set)\n requires A <= U && U <= S\n ensures A <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_3426","instance":3426,"id":206769,"goal":"lemma SetUnionEmpty_3426(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_3427","instance":3427,"id":206770,"goal":"lemma SetInterEmpty_3427(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_3428","instance":3428,"id":206771,"goal":"lemma SetInterSubset_3428(T: set, U: set)\n ensures T * U <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_3429","instance":3429,"id":206772,"goal":"lemma SetCardSubset_3429(A: set, U: set)\n requires A <= U\n ensures |A| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_3430","instance":3430,"id":206773,"goal":"lemma SetUnionCard_3430(U: set, S: set)\n requires U * S == {}\n ensures |U + S| == |U| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_3431","instance":3431,"id":206774,"goal":"lemma SetUnionComm_3431(S: set, T: set)\n ensures S + T == T + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_3432","instance":3432,"id":206775,"goal":"lemma SetInterComm_3432(T: set, U: set)\n ensures T * U == U * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_3433","instance":3433,"id":206776,"goal":"lemma SetUnionAssoc_3433(S: set, U: set, A: set)\n ensures (S + U) + A == S + (U + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_3434","instance":3434,"id":206777,"goal":"lemma SetSubsetRefl_3434(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_3435","instance":3435,"id":206778,"goal":"lemma SetSubsetTrans_3435(S: set, B: set, U: set)\n requires S <= B && B <= U\n ensures S <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_3436","instance":3436,"id":206779,"goal":"lemma SetUnionEmpty_3436(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_3437","instance":3437,"id":206780,"goal":"lemma SetInterEmpty_3437(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_3438","instance":3438,"id":206781,"goal":"lemma SetInterSubset_3438(T: set, B: set)\n ensures T * B <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_3439","instance":3439,"id":206782,"goal":"lemma SetCardSubset_3439(S: set, A: set)\n requires S <= A\n ensures |S| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_3440","instance":3440,"id":206783,"goal":"lemma SetUnionCard_3440(S: set, U: set)\n requires S * U == {}\n ensures |S + U| == |S| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_3441","instance":3441,"id":206784,"goal":"lemma SetUnionComm_3441(T: set, U: set)\n ensures T + U == U + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_3442","instance":3442,"id":206785,"goal":"lemma SetInterComm_3442(T: set, U: set)\n ensures T * U == U * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_3443","instance":3443,"id":206786,"goal":"lemma SetUnionAssoc_3443(S: set, T: set, U: set)\n ensures (S + T) + U == S + (T + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_3444","instance":3444,"id":206787,"goal":"lemma SetSubsetRefl_3444(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_3445","instance":3445,"id":206788,"goal":"lemma SetSubsetTrans_3445(B: set, A: set, T: set)\n requires B <= A && A <= T\n ensures B <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_3446","instance":3446,"id":206789,"goal":"lemma SetUnionEmpty_3446(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_3447","instance":3447,"id":206790,"goal":"lemma SetInterEmpty_3447(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_3448","instance":3448,"id":206791,"goal":"lemma SetInterSubset_3448(U: set, A: set)\n ensures U * A <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_3449","instance":3449,"id":206792,"goal":"lemma SetCardSubset_3449(B: set, T: set)\n requires B <= T\n ensures |B| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_3450","instance":3450,"id":206793,"goal":"lemma SetUnionCard_3450(S: set, U: set)\n requires S * U == {}\n ensures |S + U| == |S| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_3451","instance":3451,"id":206794,"goal":"lemma SetUnionComm_3451(U: set, S: set)\n ensures U + S == S + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_3452","instance":3452,"id":206795,"goal":"lemma SetInterComm_3452(A: set, B: set)\n ensures A * B == B * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_3453","instance":3453,"id":206796,"goal":"lemma SetUnionAssoc_3453(B: set, U: set, S: set)\n ensures (B + U) + S == B + (U + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_3454","instance":3454,"id":206797,"goal":"lemma SetSubsetRefl_3454(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_3455","instance":3455,"id":206798,"goal":"lemma SetSubsetTrans_3455(B: set, T: set, U: set)\n requires B <= T && T <= U\n ensures B <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_3456","instance":3456,"id":206799,"goal":"lemma SetUnionEmpty_3456(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_3457","instance":3457,"id":206800,"goal":"lemma SetInterEmpty_3457(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_3458","instance":3458,"id":206801,"goal":"lemma SetInterSubset_3458(A: set, B: set)\n ensures A * B <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_3459","instance":3459,"id":206802,"goal":"lemma SetCardSubset_3459(S: set, U: set)\n requires S <= U\n ensures |S| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_3460","instance":3460,"id":206803,"goal":"lemma SetUnionCard_3460(A: set, U: set)\n requires A * U == {}\n ensures |A + U| == |A| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_3461","instance":3461,"id":206804,"goal":"lemma SetUnionComm_3461(U: set, B: set)\n ensures U + B == B + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_3462","instance":3462,"id":206805,"goal":"lemma SetInterComm_3462(S: set, U: set)\n ensures S * U == U * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_3463","instance":3463,"id":206806,"goal":"lemma SetUnionAssoc_3463(S: set, B: set, A: set)\n ensures (S + B) + A == S + (B + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_3464","instance":3464,"id":206807,"goal":"lemma SetSubsetRefl_3464(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_3465","instance":3465,"id":206808,"goal":"lemma SetSubsetTrans_3465(T: set, A: set, B: set)\n requires T <= A && A <= B\n ensures T <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_3466","instance":3466,"id":206809,"goal":"lemma SetUnionEmpty_3466(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_3467","instance":3467,"id":206810,"goal":"lemma SetInterEmpty_3467(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_3468","instance":3468,"id":206811,"goal":"lemma SetInterSubset_3468(T: set, S: set)\n ensures T * S <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_3469","instance":3469,"id":206812,"goal":"lemma SetCardSubset_3469(T: set, S: set)\n requires T <= S\n ensures |T| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_3470","instance":3470,"id":206813,"goal":"lemma SetUnionCard_3470(U: set, A: set)\n requires U * A == {}\n ensures |U + A| == |U| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_3471","instance":3471,"id":206814,"goal":"lemma SetUnionComm_3471(B: set, S: set)\n ensures B + S == S + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_3472","instance":3472,"id":206815,"goal":"lemma SetInterComm_3472(U: set, S: set)\n ensures U * S == S * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_3473","instance":3473,"id":206816,"goal":"lemma SetUnionAssoc_3473(U: set, T: set, S: set)\n ensures (U + T) + S == U + (T + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_3474","instance":3474,"id":206817,"goal":"lemma SetSubsetRefl_3474(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_3475","instance":3475,"id":206818,"goal":"lemma SetSubsetTrans_3475(S: set, B: set, T: set)\n requires S <= B && B <= T\n ensures S <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_3476","instance":3476,"id":206819,"goal":"lemma SetUnionEmpty_3476(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_3477","instance":3477,"id":206820,"goal":"lemma SetInterEmpty_3477(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_3478","instance":3478,"id":206821,"goal":"lemma SetInterSubset_3478(T: set, A: set)\n ensures T * A <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_3479","instance":3479,"id":206822,"goal":"lemma SetCardSubset_3479(A: set, S: set)\n requires A <= S\n ensures |A| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_3480","instance":3480,"id":206823,"goal":"lemma SetUnionCard_3480(U: set, T: set)\n requires U * T == {}\n ensures |U + T| == |U| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_3481","instance":3481,"id":206824,"goal":"lemma SetUnionComm_3481(T: set, B: set)\n ensures T + B == B + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_3482","instance":3482,"id":206825,"goal":"lemma SetInterComm_3482(A: set, B: set)\n ensures A * B == B * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_3483","instance":3483,"id":206826,"goal":"lemma SetUnionAssoc_3483(T: set, B: set, S: set)\n ensures (T + B) + S == T + (B + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_3484","instance":3484,"id":206827,"goal":"lemma SetSubsetRefl_3484(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_3485","instance":3485,"id":206828,"goal":"lemma SetSubsetTrans_3485(A: set, T: set, U: set)\n requires A <= T && T <= U\n ensures A <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_3486","instance":3486,"id":206829,"goal":"lemma SetUnionEmpty_3486(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_3487","instance":3487,"id":206830,"goal":"lemma SetInterEmpty_3487(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_3488","instance":3488,"id":206831,"goal":"lemma SetInterSubset_3488(T: set, A: set)\n ensures T * A <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_3489","instance":3489,"id":206832,"goal":"lemma SetCardSubset_3489(A: set, U: set)\n requires A <= U\n ensures |A| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_3490","instance":3490,"id":206833,"goal":"lemma SetUnionCard_3490(U: set, A: set)\n requires U * A == {}\n ensures |U + A| == |U| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_3491","instance":3491,"id":206834,"goal":"lemma SetUnionComm_3491(S: set, A: set)\n ensures S + A == A + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_3492","instance":3492,"id":206835,"goal":"lemma SetInterComm_3492(B: set, T: set)\n ensures B * T == T * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_3493","instance":3493,"id":206836,"goal":"lemma SetUnionAssoc_3493(B: set, A: set, S: set)\n ensures (B + A) + S == B + (A + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_3494","instance":3494,"id":206837,"goal":"lemma SetSubsetRefl_3494(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_3495","instance":3495,"id":206838,"goal":"lemma SetSubsetTrans_3495(B: set, A: set, S: set)\n requires B <= A && A <= S\n ensures B <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_3496","instance":3496,"id":206839,"goal":"lemma SetUnionEmpty_3496(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_3497","instance":3497,"id":206840,"goal":"lemma SetInterEmpty_3497(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_3498","instance":3498,"id":206841,"goal":"lemma SetInterSubset_3498(T: set, B: set)\n ensures T * B <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_3499","instance":3499,"id":206842,"goal":"lemma SetCardSubset_3499(S: set, B: set)\n requires S <= B\n ensures |S| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_3500","instance":3500,"id":206843,"goal":"lemma SetUnionCard_3500(B: set, U: set)\n requires B * U == {}\n ensures |B + U| == |B| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_3501","instance":3501,"id":206844,"goal":"lemma SetUnionComm_3501(U: set, A: set)\n ensures U + A == A + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_3502","instance":3502,"id":206845,"goal":"lemma SetInterComm_3502(T: set, U: set)\n ensures T * U == U * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_3503","instance":3503,"id":206846,"goal":"lemma SetUnionAssoc_3503(B: set, A: set, T: set)\n ensures (B + A) + T == B + (A + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_3504","instance":3504,"id":206847,"goal":"lemma SetSubsetRefl_3504(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_3505","instance":3505,"id":206848,"goal":"lemma SetSubsetTrans_3505(T: set, U: set, S: set)\n requires T <= U && U <= S\n ensures T <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_3506","instance":3506,"id":206849,"goal":"lemma SetUnionEmpty_3506(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_3507","instance":3507,"id":206850,"goal":"lemma SetInterEmpty_3507(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_3508","instance":3508,"id":206851,"goal":"lemma SetInterSubset_3508(A: set, S: set)\n ensures A * S <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_3509","instance":3509,"id":206852,"goal":"lemma SetCardSubset_3509(B: set, S: set)\n requires B <= S\n ensures |B| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_3510","instance":3510,"id":206853,"goal":"lemma SetUnionCard_3510(U: set, S: set)\n requires U * S == {}\n ensures |U + S| == |U| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_3511","instance":3511,"id":206854,"goal":"lemma SetUnionComm_3511(S: set, T: set)\n ensures S + T == T + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_3512","instance":3512,"id":206855,"goal":"lemma SetInterComm_3512(B: set, T: set)\n ensures B * T == T * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_3513","instance":3513,"id":206856,"goal":"lemma SetUnionAssoc_3513(T: set, B: set, S: set)\n ensures (T + B) + S == T + (B + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_3514","instance":3514,"id":206857,"goal":"lemma SetSubsetRefl_3514(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_3515","instance":3515,"id":206858,"goal":"lemma SetSubsetTrans_3515(S: set, B: set, U: set)\n requires S <= B && B <= U\n ensures S <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_3516","instance":3516,"id":206859,"goal":"lemma SetUnionEmpty_3516(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_3517","instance":3517,"id":206860,"goal":"lemma SetInterEmpty_3517(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_3518","instance":3518,"id":206861,"goal":"lemma SetInterSubset_3518(B: set, T: set)\n ensures B * T <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_3519","instance":3519,"id":206862,"goal":"lemma SetCardSubset_3519(T: set, A: set)\n requires T <= A\n ensures |T| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_3520","instance":3520,"id":206863,"goal":"lemma SetUnionCard_3520(S: set, U: set)\n requires S * U == {}\n ensures |S + U| == |S| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_3521","instance":3521,"id":206864,"goal":"lemma SetUnionComm_3521(U: set, S: set)\n ensures U + S == S + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_3522","instance":3522,"id":206865,"goal":"lemma SetInterComm_3522(B: set, S: set)\n ensures B * S == S * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_3523","instance":3523,"id":206866,"goal":"lemma SetUnionAssoc_3523(T: set, B: set, S: set)\n ensures (T + B) + S == T + (B + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_3524","instance":3524,"id":206867,"goal":"lemma SetSubsetRefl_3524(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_3525","instance":3525,"id":206868,"goal":"lemma SetSubsetTrans_3525(S: set, B: set, T: set)\n requires S <= B && B <= T\n ensures S <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_3526","instance":3526,"id":206869,"goal":"lemma SetUnionEmpty_3526(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_3527","instance":3527,"id":206870,"goal":"lemma SetInterEmpty_3527(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_3528","instance":3528,"id":206871,"goal":"lemma SetInterSubset_3528(A: set, S: set)\n ensures A * S <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_3529","instance":3529,"id":206872,"goal":"lemma SetCardSubset_3529(S: set, U: set)\n requires S <= U\n ensures |S| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_3530","instance":3530,"id":206873,"goal":"lemma SetUnionCard_3530(B: set, S: set)\n requires B * S == {}\n ensures |B + S| == |B| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_3531","instance":3531,"id":206874,"goal":"lemma SetUnionComm_3531(B: set, A: set)\n ensures B + A == A + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_3532","instance":3532,"id":206875,"goal":"lemma SetInterComm_3532(A: set, T: set)\n ensures A * T == T * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_3533","instance":3533,"id":206876,"goal":"lemma SetUnionAssoc_3533(S: set, B: set, T: set)\n ensures (S + B) + T == S + (B + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_3534","instance":3534,"id":206877,"goal":"lemma SetSubsetRefl_3534(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_3535","instance":3535,"id":206878,"goal":"lemma SetSubsetTrans_3535(B: set, U: set, T: set)\n requires B <= U && U <= T\n ensures B <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_3536","instance":3536,"id":206879,"goal":"lemma SetUnionEmpty_3536(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_3537","instance":3537,"id":206880,"goal":"lemma SetInterEmpty_3537(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_3538","instance":3538,"id":206881,"goal":"lemma SetInterSubset_3538(U: set, B: set)\n ensures U * B <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_3539","instance":3539,"id":206882,"goal":"lemma SetCardSubset_3539(S: set, B: set)\n requires S <= B\n ensures |S| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_3540","instance":3540,"id":206883,"goal":"lemma SetUnionCard_3540(A: set, B: set)\n requires A * B == {}\n ensures |A + B| == |A| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_3541","instance":3541,"id":206884,"goal":"lemma SetUnionComm_3541(A: set, T: set)\n ensures A + T == T + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_3542","instance":3542,"id":206885,"goal":"lemma SetInterComm_3542(S: set, A: set)\n ensures S * A == A * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_3543","instance":3543,"id":206886,"goal":"lemma SetUnionAssoc_3543(U: set, S: set, A: set)\n ensures (U + S) + A == U + (S + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_3544","instance":3544,"id":206887,"goal":"lemma SetSubsetRefl_3544(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_3545","instance":3545,"id":206888,"goal":"lemma SetSubsetTrans_3545(S: set, U: set, T: set)\n requires S <= U && U <= T\n ensures S <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_3546","instance":3546,"id":206889,"goal":"lemma SetUnionEmpty_3546(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_3547","instance":3547,"id":206890,"goal":"lemma SetInterEmpty_3547(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_3548","instance":3548,"id":206891,"goal":"lemma SetInterSubset_3548(T: set, U: set)\n ensures T * U <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_3549","instance":3549,"id":206892,"goal":"lemma SetCardSubset_3549(T: set, U: set)\n requires T <= U\n ensures |T| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_3550","instance":3550,"id":206893,"goal":"lemma SetUnionCard_3550(S: set, T: set)\n requires S * T == {}\n ensures |S + T| == |S| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_3551","instance":3551,"id":206894,"goal":"lemma SetUnionComm_3551(U: set, B: set)\n ensures U + B == B + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_3552","instance":3552,"id":206895,"goal":"lemma SetInterComm_3552(A: set, U: set)\n ensures A * U == U * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_3553","instance":3553,"id":206896,"goal":"lemma SetUnionAssoc_3553(U: set, B: set, S: set)\n ensures (U + B) + S == U + (B + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_3554","instance":3554,"id":206897,"goal":"lemma SetSubsetRefl_3554(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_3555","instance":3555,"id":206898,"goal":"lemma SetSubsetTrans_3555(T: set, S: set, U: set)\n requires T <= S && S <= U\n ensures T <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_3556","instance":3556,"id":206899,"goal":"lemma SetUnionEmpty_3556(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_3557","instance":3557,"id":206900,"goal":"lemma SetInterEmpty_3557(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_3558","instance":3558,"id":206901,"goal":"lemma SetInterSubset_3558(T: set, A: set)\n ensures T * A <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_3559","instance":3559,"id":206902,"goal":"lemma SetCardSubset_3559(T: set, U: set)\n requires T <= U\n ensures |T| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_3560","instance":3560,"id":206903,"goal":"lemma SetUnionCard_3560(S: set, T: set)\n requires S * T == {}\n ensures |S + T| == |S| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_3561","instance":3561,"id":206904,"goal":"lemma SetUnionComm_3561(U: set, T: set)\n ensures U + T == T + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_3562","instance":3562,"id":206905,"goal":"lemma SetInterComm_3562(B: set, U: set)\n ensures B * U == U * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_3563","instance":3563,"id":206906,"goal":"lemma SetUnionAssoc_3563(U: set, B: set, A: set)\n ensures (U + B) + A == U + (B + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_3564","instance":3564,"id":206907,"goal":"lemma SetSubsetRefl_3564(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_3565","instance":3565,"id":206908,"goal":"lemma SetSubsetTrans_3565(B: set, S: set, A: set)\n requires B <= S && S <= A\n ensures B <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_3566","instance":3566,"id":206909,"goal":"lemma SetUnionEmpty_3566(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_3567","instance":3567,"id":206910,"goal":"lemma SetInterEmpty_3567(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_3568","instance":3568,"id":206911,"goal":"lemma SetInterSubset_3568(A: set, U: set)\n ensures A * U <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_3569","instance":3569,"id":206912,"goal":"lemma SetCardSubset_3569(T: set, S: set)\n requires T <= S\n ensures |T| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_3570","instance":3570,"id":206913,"goal":"lemma SetUnionCard_3570(A: set, B: set)\n requires A * B == {}\n ensures |A + B| == |A| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_3571","instance":3571,"id":206914,"goal":"lemma SetUnionComm_3571(A: set, T: set)\n ensures A + T == T + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_3572","instance":3572,"id":206915,"goal":"lemma SetInterComm_3572(A: set, B: set)\n ensures A * B == B * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_3573","instance":3573,"id":206916,"goal":"lemma SetUnionAssoc_3573(A: set, U: set, S: set)\n ensures (A + U) + S == A + (U + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_3574","instance":3574,"id":206917,"goal":"lemma SetSubsetRefl_3574(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_3575","instance":3575,"id":206918,"goal":"lemma SetSubsetTrans_3575(T: set, A: set, U: set)\n requires T <= A && A <= U\n ensures T <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_3576","instance":3576,"id":206919,"goal":"lemma SetUnionEmpty_3576(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_3577","instance":3577,"id":206920,"goal":"lemma SetInterEmpty_3577(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_3578","instance":3578,"id":206921,"goal":"lemma SetInterSubset_3578(B: set, U: set)\n ensures B * U <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_3579","instance":3579,"id":206922,"goal":"lemma SetCardSubset_3579(S: set, T: set)\n requires S <= T\n ensures |S| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_3580","instance":3580,"id":206923,"goal":"lemma SetUnionCard_3580(T: set, U: set)\n requires T * U == {}\n ensures |T + U| == |T| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_3581","instance":3581,"id":206924,"goal":"lemma SetUnionComm_3581(A: set, T: set)\n ensures A + T == T + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_3582","instance":3582,"id":206925,"goal":"lemma SetInterComm_3582(U: set, T: set)\n ensures U * T == T * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_3583","instance":3583,"id":206926,"goal":"lemma SetUnionAssoc_3583(B: set, T: set, S: set)\n ensures (B + T) + S == B + (T + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_3584","instance":3584,"id":206927,"goal":"lemma SetSubsetRefl_3584(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_3585","instance":3585,"id":206928,"goal":"lemma SetSubsetTrans_3585(T: set, B: set, U: set)\n requires T <= B && B <= U\n ensures T <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_3586","instance":3586,"id":206929,"goal":"lemma SetUnionEmpty_3586(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_3587","instance":3587,"id":206930,"goal":"lemma SetInterEmpty_3587(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_3588","instance":3588,"id":206931,"goal":"lemma SetInterSubset_3588(T: set, S: set)\n ensures T * S <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_3589","instance":3589,"id":206932,"goal":"lemma SetCardSubset_3589(B: set, A: set)\n requires B <= A\n ensures |B| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_3590","instance":3590,"id":206933,"goal":"lemma SetUnionCard_3590(U: set, B: set)\n requires U * B == {}\n ensures |U + B| == |U| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_3591","instance":3591,"id":206934,"goal":"lemma SetUnionComm_3591(B: set, A: set)\n ensures B + A == A + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_3592","instance":3592,"id":206935,"goal":"lemma SetInterComm_3592(S: set, U: set)\n ensures S * U == U * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_3593","instance":3593,"id":206936,"goal":"lemma SetUnionAssoc_3593(A: set, U: set, S: set)\n ensures (A + U) + S == A + (U + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_3594","instance":3594,"id":206937,"goal":"lemma SetSubsetRefl_3594(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_3595","instance":3595,"id":206938,"goal":"lemma SetSubsetTrans_3595(T: set, U: set, S: set)\n requires T <= U && U <= S\n ensures T <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_3596","instance":3596,"id":206939,"goal":"lemma SetUnionEmpty_3596(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_3597","instance":3597,"id":206940,"goal":"lemma SetInterEmpty_3597(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_3598","instance":3598,"id":206941,"goal":"lemma SetInterSubset_3598(S: set, U: set)\n ensures S * U <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_3599","instance":3599,"id":206942,"goal":"lemma SetCardSubset_3599(S: set, B: set)\n requires S <= B\n ensures |S| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_3600","instance":3600,"id":206943,"goal":"lemma SetUnionCard_3600(T: set, U: set)\n requires T * U == {}\n ensures |T + U| == |T| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_3601","instance":3601,"id":206944,"goal":"lemma SetUnionComm_3601(B: set, S: set)\n ensures B + S == S + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_3602","instance":3602,"id":206945,"goal":"lemma SetInterComm_3602(S: set, T: set)\n ensures S * T == T * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_3603","instance":3603,"id":206946,"goal":"lemma SetUnionAssoc_3603(A: set, T: set, B: set)\n ensures (A + T) + B == A + (T + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_3604","instance":3604,"id":206947,"goal":"lemma SetSubsetRefl_3604(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_3605","instance":3605,"id":206948,"goal":"lemma SetSubsetTrans_3605(A: set, U: set, B: set)\n requires A <= U && U <= B\n ensures A <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_3606","instance":3606,"id":206949,"goal":"lemma SetUnionEmpty_3606(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_3607","instance":3607,"id":206950,"goal":"lemma SetInterEmpty_3607(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_3608","instance":3608,"id":206951,"goal":"lemma SetInterSubset_3608(T: set, U: set)\n ensures T * U <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_3609","instance":3609,"id":206952,"goal":"lemma SetCardSubset_3609(U: set, S: set)\n requires U <= S\n ensures |U| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_3610","instance":3610,"id":206953,"goal":"lemma SetUnionCard_3610(T: set, B: set)\n requires T * B == {}\n ensures |T + B| == |T| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_3611","instance":3611,"id":206954,"goal":"lemma SetUnionComm_3611(T: set, A: set)\n ensures T + A == A + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_3612","instance":3612,"id":206955,"goal":"lemma SetInterComm_3612(B: set, S: set)\n ensures B * S == S * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_3613","instance":3613,"id":206956,"goal":"lemma SetUnionAssoc_3613(B: set, U: set, T: set)\n ensures (B + U) + T == B + (U + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_3614","instance":3614,"id":206957,"goal":"lemma SetSubsetRefl_3614(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_3615","instance":3615,"id":206958,"goal":"lemma SetSubsetTrans_3615(T: set, S: set, B: set)\n requires T <= S && S <= B\n ensures T <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_3616","instance":3616,"id":206959,"goal":"lemma SetUnionEmpty_3616(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_3617","instance":3617,"id":206960,"goal":"lemma SetInterEmpty_3617(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_3618","instance":3618,"id":206961,"goal":"lemma SetInterSubset_3618(U: set, S: set)\n ensures U * S <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_3619","instance":3619,"id":206962,"goal":"lemma SetCardSubset_3619(A: set, S: set)\n requires A <= S\n ensures |A| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_3620","instance":3620,"id":206963,"goal":"lemma SetUnionCard_3620(S: set, A: set)\n requires S * A == {}\n ensures |S + A| == |S| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_3621","instance":3621,"id":206964,"goal":"lemma SetUnionComm_3621(T: set, U: set)\n ensures T + U == U + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_3622","instance":3622,"id":206965,"goal":"lemma SetInterComm_3622(U: set, B: set)\n ensures U * B == B * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_3623","instance":3623,"id":206966,"goal":"lemma SetUnionAssoc_3623(U: set, T: set, A: set)\n ensures (U + T) + A == U + (T + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_3624","instance":3624,"id":206967,"goal":"lemma SetSubsetRefl_3624(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_3625","instance":3625,"id":206968,"goal":"lemma SetSubsetTrans_3625(B: set, U: set, T: set)\n requires B <= U && U <= T\n ensures B <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_3626","instance":3626,"id":206969,"goal":"lemma SetUnionEmpty_3626(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_3627","instance":3627,"id":206970,"goal":"lemma SetInterEmpty_3627(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_3628","instance":3628,"id":206971,"goal":"lemma SetInterSubset_3628(B: set, S: set)\n ensures B * S <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_3629","instance":3629,"id":206972,"goal":"lemma SetCardSubset_3629(S: set, A: set)\n requires S <= A\n ensures |S| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_3630","instance":3630,"id":206973,"goal":"lemma SetUnionCard_3630(U: set, A: set)\n requires U * A == {}\n ensures |U + A| == |U| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_3631","instance":3631,"id":206974,"goal":"lemma SetUnionComm_3631(S: set, U: set)\n ensures S + U == U + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_3632","instance":3632,"id":206975,"goal":"lemma SetInterComm_3632(A: set, S: set)\n ensures A * S == S * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_3633","instance":3633,"id":206976,"goal":"lemma SetUnionAssoc_3633(B: set, T: set, A: set)\n ensures (B + T) + A == B + (T + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_3634","instance":3634,"id":206977,"goal":"lemma SetSubsetRefl_3634(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_3635","instance":3635,"id":206978,"goal":"lemma SetSubsetTrans_3635(B: set, A: set, T: set)\n requires B <= A && A <= T\n ensures B <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_3636","instance":3636,"id":206979,"goal":"lemma SetUnionEmpty_3636(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_3637","instance":3637,"id":206980,"goal":"lemma SetInterEmpty_3637(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_3638","instance":3638,"id":206981,"goal":"lemma SetInterSubset_3638(A: set, S: set)\n ensures A * S <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_3639","instance":3639,"id":206982,"goal":"lemma SetCardSubset_3639(S: set, A: set)\n requires S <= A\n ensures |S| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_3640","instance":3640,"id":206983,"goal":"lemma SetUnionCard_3640(A: set, S: set)\n requires A * S == {}\n ensures |A + S| == |A| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_3641","instance":3641,"id":206984,"goal":"lemma SetUnionComm_3641(S: set, T: set)\n ensures S + T == T + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_3642","instance":3642,"id":206985,"goal":"lemma SetInterComm_3642(B: set, S: set)\n ensures B * S == S * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_3643","instance":3643,"id":206986,"goal":"lemma SetUnionAssoc_3643(A: set, B: set, T: set)\n ensures (A + B) + T == A + (B + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_3644","instance":3644,"id":206987,"goal":"lemma SetSubsetRefl_3644(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_3645","instance":3645,"id":206988,"goal":"lemma SetSubsetTrans_3645(T: set, S: set, A: set)\n requires T <= S && S <= A\n ensures T <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_3646","instance":3646,"id":206989,"goal":"lemma SetUnionEmpty_3646(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_3647","instance":3647,"id":206990,"goal":"lemma SetInterEmpty_3647(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_3648","instance":3648,"id":206991,"goal":"lemma SetInterSubset_3648(T: set, A: set)\n ensures T * A <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_3649","instance":3649,"id":206992,"goal":"lemma SetCardSubset_3649(B: set, S: set)\n requires B <= S\n ensures |B| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_3650","instance":3650,"id":206993,"goal":"lemma SetUnionCard_3650(S: set, A: set)\n requires S * A == {}\n ensures |S + A| == |S| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_3651","instance":3651,"id":206994,"goal":"lemma SetUnionComm_3651(A: set, S: set)\n ensures A + S == S + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_3652","instance":3652,"id":206995,"goal":"lemma SetInterComm_3652(B: set, A: set)\n ensures B * A == A * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_3653","instance":3653,"id":206996,"goal":"lemma SetUnionAssoc_3653(T: set, A: set, U: set)\n ensures (T + A) + U == T + (A + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_3654","instance":3654,"id":206997,"goal":"lemma SetSubsetRefl_3654(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_3655","instance":3655,"id":206998,"goal":"lemma SetSubsetTrans_3655(S: set, B: set, U: set)\n requires S <= B && B <= U\n ensures S <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_3656","instance":3656,"id":206999,"goal":"lemma SetUnionEmpty_3656(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_3657","instance":3657,"id":207000,"goal":"lemma SetInterEmpty_3657(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_3658","instance":3658,"id":207001,"goal":"lemma SetInterSubset_3658(U: set, B: set)\n ensures U * B <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_3659","instance":3659,"id":207002,"goal":"lemma SetCardSubset_3659(A: set, T: set)\n requires A <= T\n ensures |A| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_3660","instance":3660,"id":207003,"goal":"lemma SetUnionCard_3660(A: set, T: set)\n requires A * T == {}\n ensures |A + T| == |A| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_3661","instance":3661,"id":207004,"goal":"lemma SetUnionComm_3661(T: set, U: set)\n ensures T + U == U + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_3662","instance":3662,"id":207005,"goal":"lemma SetInterComm_3662(T: set, A: set)\n ensures T * A == A * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_3663","instance":3663,"id":207006,"goal":"lemma SetUnionAssoc_3663(A: set, B: set, U: set)\n ensures (A + B) + U == A + (B + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_3664","instance":3664,"id":207007,"goal":"lemma SetSubsetRefl_3664(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_3665","instance":3665,"id":207008,"goal":"lemma SetSubsetTrans_3665(S: set, U: set, B: set)\n requires S <= U && U <= B\n ensures S <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_3666","instance":3666,"id":207009,"goal":"lemma SetUnionEmpty_3666(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_3667","instance":3667,"id":207010,"goal":"lemma SetInterEmpty_3667(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_3668","instance":3668,"id":207011,"goal":"lemma SetInterSubset_3668(B: set, S: set)\n ensures B * S <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_3669","instance":3669,"id":207012,"goal":"lemma SetCardSubset_3669(A: set, S: set)\n requires A <= S\n ensures |A| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_3670","instance":3670,"id":207013,"goal":"lemma SetUnionCard_3670(B: set, T: set)\n requires B * T == {}\n ensures |B + T| == |B| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_3671","instance":3671,"id":207014,"goal":"lemma SetUnionComm_3671(B: set, U: set)\n ensures B + U == U + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_3672","instance":3672,"id":207015,"goal":"lemma SetInterComm_3672(U: set, A: set)\n ensures U * A == A * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_3673","instance":3673,"id":207016,"goal":"lemma SetUnionAssoc_3673(T: set, U: set, A: set)\n ensures (T + U) + A == T + (U + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_3674","instance":3674,"id":207017,"goal":"lemma SetSubsetRefl_3674(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_3675","instance":3675,"id":207018,"goal":"lemma SetSubsetTrans_3675(B: set, U: set, T: set)\n requires B <= U && U <= T\n ensures B <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_3676","instance":3676,"id":207019,"goal":"lemma SetUnionEmpty_3676(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_3677","instance":3677,"id":207020,"goal":"lemma SetInterEmpty_3677(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_3678","instance":3678,"id":207021,"goal":"lemma SetInterSubset_3678(B: set, T: set)\n ensures B * T <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_3679","instance":3679,"id":207022,"goal":"lemma SetCardSubset_3679(S: set, B: set)\n requires S <= B\n ensures |S| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_3680","instance":3680,"id":207023,"goal":"lemma SetUnionCard_3680(S: set, T: set)\n requires S * T == {}\n ensures |S + T| == |S| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_3681","instance":3681,"id":207024,"goal":"lemma SetUnionComm_3681(S: set, B: set)\n ensures S + B == B + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_3682","instance":3682,"id":207025,"goal":"lemma SetInterComm_3682(U: set, B: set)\n ensures U * B == B * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_3683","instance":3683,"id":207026,"goal":"lemma SetUnionAssoc_3683(A: set, T: set, S: set)\n ensures (A + T) + S == A + (T + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_3684","instance":3684,"id":207027,"goal":"lemma SetSubsetRefl_3684(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_3685","instance":3685,"id":207028,"goal":"lemma SetSubsetTrans_3685(T: set, B: set, S: set)\n requires T <= B && B <= S\n ensures T <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_3686","instance":3686,"id":207029,"goal":"lemma SetUnionEmpty_3686(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_3687","instance":3687,"id":207030,"goal":"lemma SetInterEmpty_3687(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_3688","instance":3688,"id":207031,"goal":"lemma SetInterSubset_3688(T: set, S: set)\n ensures T * S <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_3689","instance":3689,"id":207032,"goal":"lemma SetCardSubset_3689(B: set, T: set)\n requires B <= T\n ensures |B| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_3690","instance":3690,"id":207033,"goal":"lemma SetUnionCard_3690(A: set, T: set)\n requires A * T == {}\n ensures |A + T| == |A| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_3691","instance":3691,"id":207034,"goal":"lemma SetUnionComm_3691(S: set, U: set)\n ensures S + U == U + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_3692","instance":3692,"id":207035,"goal":"lemma SetInterComm_3692(S: set, T: set)\n ensures S * T == T * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_3693","instance":3693,"id":207036,"goal":"lemma SetUnionAssoc_3693(T: set, U: set, A: set)\n ensures (T + U) + A == T + (U + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_3694","instance":3694,"id":207037,"goal":"lemma SetSubsetRefl_3694(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_3695","instance":3695,"id":207038,"goal":"lemma SetSubsetTrans_3695(T: set, U: set, S: set)\n requires T <= U && U <= S\n ensures T <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_3696","instance":3696,"id":207039,"goal":"lemma SetUnionEmpty_3696(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_3697","instance":3697,"id":207040,"goal":"lemma SetInterEmpty_3697(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_3698","instance":3698,"id":207041,"goal":"lemma SetInterSubset_3698(B: set, S: set)\n ensures B * S <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_3699","instance":3699,"id":207042,"goal":"lemma SetCardSubset_3699(U: set, A: set)\n requires U <= A\n ensures |U| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_3700","instance":3700,"id":207043,"goal":"lemma SetUnionCard_3700(T: set, A: set)\n requires T * A == {}\n ensures |T + A| == |T| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_3701","instance":3701,"id":207044,"goal":"lemma SetUnionComm_3701(U: set, A: set)\n ensures U + A == A + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_3702","instance":3702,"id":207045,"goal":"lemma SetInterComm_3702(A: set, U: set)\n ensures A * U == U * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_3703","instance":3703,"id":207046,"goal":"lemma SetUnionAssoc_3703(U: set, B: set, S: set)\n ensures (U + B) + S == U + (B + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_3704","instance":3704,"id":207047,"goal":"lemma SetSubsetRefl_3704(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_3705","instance":3705,"id":207048,"goal":"lemma SetSubsetTrans_3705(T: set, S: set, B: set)\n requires T <= S && S <= B\n ensures T <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_3706","instance":3706,"id":207049,"goal":"lemma SetUnionEmpty_3706(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_3707","instance":3707,"id":207050,"goal":"lemma SetInterEmpty_3707(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_3708","instance":3708,"id":207051,"goal":"lemma SetInterSubset_3708(S: set, B: set)\n ensures S * B <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_3709","instance":3709,"id":207052,"goal":"lemma SetCardSubset_3709(B: set, U: set)\n requires B <= U\n ensures |B| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_3710","instance":3710,"id":207053,"goal":"lemma SetUnionCard_3710(B: set, S: set)\n requires B * S == {}\n ensures |B + S| == |B| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_3711","instance":3711,"id":207054,"goal":"lemma SetUnionComm_3711(T: set, B: set)\n ensures T + B == B + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_3712","instance":3712,"id":207055,"goal":"lemma SetInterComm_3712(A: set, U: set)\n ensures A * U == U * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_3713","instance":3713,"id":207056,"goal":"lemma SetUnionAssoc_3713(U: set, A: set, S: set)\n ensures (U + A) + S == U + (A + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_3714","instance":3714,"id":207057,"goal":"lemma SetSubsetRefl_3714(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_3715","instance":3715,"id":207058,"goal":"lemma SetSubsetTrans_3715(T: set, A: set, S: set)\n requires T <= A && A <= S\n ensures T <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_3716","instance":3716,"id":207059,"goal":"lemma SetUnionEmpty_3716(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_3717","instance":3717,"id":207060,"goal":"lemma SetInterEmpty_3717(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_3718","instance":3718,"id":207061,"goal":"lemma SetInterSubset_3718(A: set, U: set)\n ensures A * U <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_3719","instance":3719,"id":207062,"goal":"lemma SetCardSubset_3719(U: set, B: set)\n requires U <= B\n ensures |U| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_3720","instance":3720,"id":207063,"goal":"lemma SetUnionCard_3720(B: set, T: set)\n requires B * T == {}\n ensures |B + T| == |B| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_3721","instance":3721,"id":207064,"goal":"lemma SetUnionComm_3721(A: set, S: set)\n ensures A + S == S + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_3722","instance":3722,"id":207065,"goal":"lemma SetInterComm_3722(T: set, B: set)\n ensures T * B == B * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_3723","instance":3723,"id":207066,"goal":"lemma SetUnionAssoc_3723(T: set, S: set, A: set)\n ensures (T + S) + A == T + (S + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_3724","instance":3724,"id":207067,"goal":"lemma SetSubsetRefl_3724(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_3725","instance":3725,"id":207068,"goal":"lemma SetSubsetTrans_3725(A: set, U: set, B: set)\n requires A <= U && U <= B\n ensures A <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_3726","instance":3726,"id":207069,"goal":"lemma SetUnionEmpty_3726(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_3727","instance":3727,"id":207070,"goal":"lemma SetInterEmpty_3727(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_3728","instance":3728,"id":207071,"goal":"lemma SetInterSubset_3728(U: set, S: set)\n ensures U * S <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_3729","instance":3729,"id":207072,"goal":"lemma SetCardSubset_3729(S: set, U: set)\n requires S <= U\n ensures |S| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_3730","instance":3730,"id":207073,"goal":"lemma SetUnionCard_3730(A: set, U: set)\n requires A * U == {}\n ensures |A + U| == |A| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_3731","instance":3731,"id":207074,"goal":"lemma SetUnionComm_3731(S: set, T: set)\n ensures S + T == T + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_3732","instance":3732,"id":207075,"goal":"lemma SetInterComm_3732(S: set, B: set)\n ensures S * B == B * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_3733","instance":3733,"id":207076,"goal":"lemma SetUnionAssoc_3733(B: set, T: set, S: set)\n ensures (B + T) + S == B + (T + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_3734","instance":3734,"id":207077,"goal":"lemma SetSubsetRefl_3734(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_3735","instance":3735,"id":207078,"goal":"lemma SetSubsetTrans_3735(S: set, B: set, T: set)\n requires S <= B && B <= T\n ensures S <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_3736","instance":3736,"id":207079,"goal":"lemma SetUnionEmpty_3736(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_3737","instance":3737,"id":207080,"goal":"lemma SetInterEmpty_3737(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_3738","instance":3738,"id":207081,"goal":"lemma SetInterSubset_3738(B: set, U: set)\n ensures B * U <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_3739","instance":3739,"id":207082,"goal":"lemma SetCardSubset_3739(A: set, U: set)\n requires A <= U\n ensures |A| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_3740","instance":3740,"id":207083,"goal":"lemma SetUnionCard_3740(T: set, U: set)\n requires T * U == {}\n ensures |T + U| == |T| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_3741","instance":3741,"id":207084,"goal":"lemma SetUnionComm_3741(T: set, A: set)\n ensures T + A == A + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_3742","instance":3742,"id":207085,"goal":"lemma SetInterComm_3742(T: set, S: set)\n ensures T * S == S * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_3743","instance":3743,"id":207086,"goal":"lemma SetUnionAssoc_3743(U: set, B: set, S: set)\n ensures (U + B) + S == U + (B + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_3744","instance":3744,"id":207087,"goal":"lemma SetSubsetRefl_3744(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_3745","instance":3745,"id":207088,"goal":"lemma SetSubsetTrans_3745(A: set, S: set, T: set)\n requires A <= S && S <= T\n ensures A <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_3746","instance":3746,"id":207089,"goal":"lemma SetUnionEmpty_3746(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_3747","instance":3747,"id":207090,"goal":"lemma SetInterEmpty_3747(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_3748","instance":3748,"id":207091,"goal":"lemma SetInterSubset_3748(U: set, A: set)\n ensures U * A <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_3749","instance":3749,"id":207092,"goal":"lemma SetCardSubset_3749(A: set, S: set)\n requires A <= S\n ensures |A| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_3750","instance":3750,"id":207093,"goal":"lemma SetUnionCard_3750(U: set, S: set)\n requires U * S == {}\n ensures |U + S| == |U| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_3751","instance":3751,"id":207094,"goal":"lemma SetUnionComm_3751(T: set, B: set)\n ensures T + B == B + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_3752","instance":3752,"id":207095,"goal":"lemma SetInterComm_3752(B: set, T: set)\n ensures B * T == T * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_3753","instance":3753,"id":207096,"goal":"lemma SetUnionAssoc_3753(U: set, T: set, B: set)\n ensures (U + T) + B == U + (T + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_3754","instance":3754,"id":207097,"goal":"lemma SetSubsetRefl_3754(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_3755","instance":3755,"id":207098,"goal":"lemma SetSubsetTrans_3755(T: set, A: set, S: set)\n requires T <= A && A <= S\n ensures T <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_3756","instance":3756,"id":207099,"goal":"lemma SetUnionEmpty_3756(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_3757","instance":3757,"id":207100,"goal":"lemma SetInterEmpty_3757(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_3758","instance":3758,"id":207101,"goal":"lemma SetInterSubset_3758(U: set, B: set)\n ensures U * B <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_3759","instance":3759,"id":207102,"goal":"lemma SetCardSubset_3759(U: set, S: set)\n requires U <= S\n ensures |U| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_3760","instance":3760,"id":207103,"goal":"lemma SetUnionCard_3760(A: set, T: set)\n requires A * T == {}\n ensures |A + T| == |A| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_3761","instance":3761,"id":207104,"goal":"lemma SetUnionComm_3761(A: set, T: set)\n ensures A + T == T + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_3762","instance":3762,"id":207105,"goal":"lemma SetInterComm_3762(T: set, A: set)\n ensures T * A == A * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_3763","instance":3763,"id":207106,"goal":"lemma SetUnionAssoc_3763(A: set, S: set, T: set)\n ensures (A + S) + T == A + (S + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_3764","instance":3764,"id":207107,"goal":"lemma SetSubsetRefl_3764(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_3765","instance":3765,"id":207108,"goal":"lemma SetSubsetTrans_3765(A: set, T: set, S: set)\n requires A <= T && T <= S\n ensures A <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_3766","instance":3766,"id":207109,"goal":"lemma SetUnionEmpty_3766(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_3767","instance":3767,"id":207110,"goal":"lemma SetInterEmpty_3767(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_3768","instance":3768,"id":207111,"goal":"lemma SetInterSubset_3768(B: set, U: set)\n ensures B * U <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_3769","instance":3769,"id":207112,"goal":"lemma SetCardSubset_3769(U: set, S: set)\n requires U <= S\n ensures |U| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_3770","instance":3770,"id":207113,"goal":"lemma SetUnionCard_3770(A: set, S: set)\n requires A * S == {}\n ensures |A + S| == |A| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_3771","instance":3771,"id":207114,"goal":"lemma SetUnionComm_3771(U: set, A: set)\n ensures U + A == A + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_3772","instance":3772,"id":207115,"goal":"lemma SetInterComm_3772(B: set, U: set)\n ensures B * U == U * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_3773","instance":3773,"id":207116,"goal":"lemma SetUnionAssoc_3773(U: set, S: set, T: set)\n ensures (U + S) + T == U + (S + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_3774","instance":3774,"id":207117,"goal":"lemma SetSubsetRefl_3774(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_3775","instance":3775,"id":207118,"goal":"lemma SetSubsetTrans_3775(T: set, S: set, B: set)\n requires T <= S && S <= B\n ensures T <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_3776","instance":3776,"id":207119,"goal":"lemma SetUnionEmpty_3776(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_3777","instance":3777,"id":207120,"goal":"lemma SetInterEmpty_3777(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_3778","instance":3778,"id":207121,"goal":"lemma SetInterSubset_3778(A: set, T: set)\n ensures A * T <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_3779","instance":3779,"id":207122,"goal":"lemma SetCardSubset_3779(S: set, U: set)\n requires S <= U\n ensures |S| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_3780","instance":3780,"id":207123,"goal":"lemma SetUnionCard_3780(B: set, T: set)\n requires B * T == {}\n ensures |B + T| == |B| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_3781","instance":3781,"id":207124,"goal":"lemma SetUnionComm_3781(T: set, A: set)\n ensures T + A == A + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_3782","instance":3782,"id":207125,"goal":"lemma SetInterComm_3782(T: set, A: set)\n ensures T * A == A * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_3783","instance":3783,"id":207126,"goal":"lemma SetUnionAssoc_3783(A: set, T: set, B: set)\n ensures (A + T) + B == A + (T + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_3784","instance":3784,"id":207127,"goal":"lemma SetSubsetRefl_3784(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_3785","instance":3785,"id":207128,"goal":"lemma SetSubsetTrans_3785(S: set, B: set, A: set)\n requires S <= B && B <= A\n ensures S <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_3786","instance":3786,"id":207129,"goal":"lemma SetUnionEmpty_3786(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_3787","instance":3787,"id":207130,"goal":"lemma SetInterEmpty_3787(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_3788","instance":3788,"id":207131,"goal":"lemma SetInterSubset_3788(B: set, T: set)\n ensures B * T <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_3789","instance":3789,"id":207132,"goal":"lemma SetCardSubset_3789(U: set, T: set)\n requires U <= T\n ensures |U| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_3790","instance":3790,"id":207133,"goal":"lemma SetUnionCard_3790(S: set, A: set)\n requires S * A == {}\n ensures |S + A| == |S| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_3791","instance":3791,"id":207134,"goal":"lemma SetUnionComm_3791(B: set, T: set)\n ensures B + T == T + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_3792","instance":3792,"id":207135,"goal":"lemma SetInterComm_3792(T: set, S: set)\n ensures T * S == S * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_3793","instance":3793,"id":207136,"goal":"lemma SetUnionAssoc_3793(U: set, T: set, A: set)\n ensures (U + T) + A == U + (T + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_3794","instance":3794,"id":207137,"goal":"lemma SetSubsetRefl_3794(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_3795","instance":3795,"id":207138,"goal":"lemma SetSubsetTrans_3795(T: set, S: set, B: set)\n requires T <= S && S <= B\n ensures T <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_3796","instance":3796,"id":207139,"goal":"lemma SetUnionEmpty_3796(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_3797","instance":3797,"id":207140,"goal":"lemma SetInterEmpty_3797(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_3798","instance":3798,"id":207141,"goal":"lemma SetInterSubset_3798(S: set, U: set)\n ensures S * U <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_3799","instance":3799,"id":207142,"goal":"lemma SetCardSubset_3799(T: set, A: set)\n requires T <= A\n ensures |T| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_3800","instance":3800,"id":207143,"goal":"lemma SetUnionCard_3800(T: set, S: set)\n requires T * S == {}\n ensures |T + S| == |T| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_3801","instance":3801,"id":207144,"goal":"lemma SetUnionComm_3801(S: set, B: set)\n ensures S + B == B + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_3802","instance":3802,"id":207145,"goal":"lemma SetInterComm_3802(U: set, T: set)\n ensures U * T == T * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_3803","instance":3803,"id":207146,"goal":"lemma SetUnionAssoc_3803(U: set, A: set, S: set)\n ensures (U + A) + S == U + (A + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_3804","instance":3804,"id":207147,"goal":"lemma SetSubsetRefl_3804(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_3805","instance":3805,"id":207148,"goal":"lemma SetSubsetTrans_3805(A: set, B: set, S: set)\n requires A <= B && B <= S\n ensures A <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_3806","instance":3806,"id":207149,"goal":"lemma SetUnionEmpty_3806(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_3807","instance":3807,"id":207150,"goal":"lemma SetInterEmpty_3807(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_3808","instance":3808,"id":207151,"goal":"lemma SetInterSubset_3808(T: set, U: set)\n ensures T * U <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_3809","instance":3809,"id":207152,"goal":"lemma SetCardSubset_3809(B: set, U: set)\n requires B <= U\n ensures |B| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_3810","instance":3810,"id":207153,"goal":"lemma SetUnionCard_3810(A: set, T: set)\n requires A * T == {}\n ensures |A + T| == |A| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_3811","instance":3811,"id":207154,"goal":"lemma SetUnionComm_3811(S: set, T: set)\n ensures S + T == T + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_3812","instance":3812,"id":207155,"goal":"lemma SetInterComm_3812(B: set, A: set)\n ensures B * A == A * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_3813","instance":3813,"id":207156,"goal":"lemma SetUnionAssoc_3813(A: set, T: set, B: set)\n ensures (A + T) + B == A + (T + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_3814","instance":3814,"id":207157,"goal":"lemma SetSubsetRefl_3814(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_3815","instance":3815,"id":207158,"goal":"lemma SetSubsetTrans_3815(U: set, A: set, B: set)\n requires U <= A && A <= B\n ensures U <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_3816","instance":3816,"id":207159,"goal":"lemma SetUnionEmpty_3816(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_3817","instance":3817,"id":207160,"goal":"lemma SetInterEmpty_3817(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_3818","instance":3818,"id":207161,"goal":"lemma SetInterSubset_3818(T: set, U: set)\n ensures T * U <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_3819","instance":3819,"id":207162,"goal":"lemma SetCardSubset_3819(U: set, A: set)\n requires U <= A\n ensures |U| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_3820","instance":3820,"id":207163,"goal":"lemma SetUnionCard_3820(A: set, S: set)\n requires A * S == {}\n ensures |A + S| == |A| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_3821","instance":3821,"id":207164,"goal":"lemma SetUnionComm_3821(A: set, S: set)\n ensures A + S == S + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_3822","instance":3822,"id":207165,"goal":"lemma SetInterComm_3822(A: set, S: set)\n ensures A * S == S * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_3823","instance":3823,"id":207166,"goal":"lemma SetUnionAssoc_3823(T: set, S: set, A: set)\n ensures (T + S) + A == T + (S + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_3824","instance":3824,"id":207167,"goal":"lemma SetSubsetRefl_3824(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_3825","instance":3825,"id":207168,"goal":"lemma SetSubsetTrans_3825(S: set, U: set, B: set)\n requires S <= U && U <= B\n ensures S <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_3826","instance":3826,"id":207169,"goal":"lemma SetUnionEmpty_3826(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_3827","instance":3827,"id":207170,"goal":"lemma SetInterEmpty_3827(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_3828","instance":3828,"id":207171,"goal":"lemma SetInterSubset_3828(B: set, U: set)\n ensures B * U <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_3829","instance":3829,"id":207172,"goal":"lemma SetCardSubset_3829(U: set, A: set)\n requires U <= A\n ensures |U| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_3830","instance":3830,"id":207173,"goal":"lemma SetUnionCard_3830(B: set, T: set)\n requires B * T == {}\n ensures |B + T| == |B| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_3831","instance":3831,"id":207174,"goal":"lemma SetUnionComm_3831(B: set, T: set)\n ensures B + T == T + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_3832","instance":3832,"id":207175,"goal":"lemma SetInterComm_3832(B: set, U: set)\n ensures B * U == U * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_3833","instance":3833,"id":207176,"goal":"lemma SetUnionAssoc_3833(A: set, B: set, U: set)\n ensures (A + B) + U == A + (B + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_3834","instance":3834,"id":207177,"goal":"lemma SetSubsetRefl_3834(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_3835","instance":3835,"id":207178,"goal":"lemma SetSubsetTrans_3835(U: set, B: set, T: set)\n requires U <= B && B <= T\n ensures U <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_3836","instance":3836,"id":207179,"goal":"lemma SetUnionEmpty_3836(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_3837","instance":3837,"id":207180,"goal":"lemma SetInterEmpty_3837(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_3838","instance":3838,"id":207181,"goal":"lemma SetInterSubset_3838(B: set, U: set)\n ensures B * U <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_3839","instance":3839,"id":207182,"goal":"lemma SetCardSubset_3839(S: set, U: set)\n requires S <= U\n ensures |S| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_3840","instance":3840,"id":207183,"goal":"lemma SetUnionCard_3840(A: set, T: set)\n requires A * T == {}\n ensures |A + T| == |A| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_3841","instance":3841,"id":207184,"goal":"lemma SetUnionComm_3841(U: set, B: set)\n ensures U + B == B + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_3842","instance":3842,"id":207185,"goal":"lemma SetInterComm_3842(B: set, S: set)\n ensures B * S == S * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_3843","instance":3843,"id":207186,"goal":"lemma SetUnionAssoc_3843(U: set, T: set, B: set)\n ensures (U + T) + B == U + (T + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_3844","instance":3844,"id":207187,"goal":"lemma SetSubsetRefl_3844(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_3845","instance":3845,"id":207188,"goal":"lemma SetSubsetTrans_3845(U: set, S: set, T: set)\n requires U <= S && S <= T\n ensures U <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_3846","instance":3846,"id":207189,"goal":"lemma SetUnionEmpty_3846(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_3847","instance":3847,"id":207190,"goal":"lemma SetInterEmpty_3847(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_3848","instance":3848,"id":207191,"goal":"lemma SetInterSubset_3848(S: set, A: set)\n ensures S * A <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_3849","instance":3849,"id":207192,"goal":"lemma SetCardSubset_3849(U: set, T: set)\n requires U <= T\n ensures |U| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_3850","instance":3850,"id":207193,"goal":"lemma SetUnionCard_3850(U: set, S: set)\n requires U * S == {}\n ensures |U + S| == |U| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_3851","instance":3851,"id":207194,"goal":"lemma SetUnionComm_3851(B: set, A: set)\n ensures B + A == A + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_3852","instance":3852,"id":207195,"goal":"lemma SetInterComm_3852(U: set, S: set)\n ensures U * S == S * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_3853","instance":3853,"id":207196,"goal":"lemma SetUnionAssoc_3853(B: set, U: set, T: set)\n ensures (B + U) + T == B + (U + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_3854","instance":3854,"id":207197,"goal":"lemma SetSubsetRefl_3854(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_3855","instance":3855,"id":207198,"goal":"lemma SetSubsetTrans_3855(U: set, A: set, B: set)\n requires U <= A && A <= B\n ensures U <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_3856","instance":3856,"id":207199,"goal":"lemma SetUnionEmpty_3856(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_3857","instance":3857,"id":207200,"goal":"lemma SetInterEmpty_3857(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_3858","instance":3858,"id":207201,"goal":"lemma SetInterSubset_3858(S: set, U: set)\n ensures S * U <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_3859","instance":3859,"id":207202,"goal":"lemma SetCardSubset_3859(S: set, B: set)\n requires S <= B\n ensures |S| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_3860","instance":3860,"id":207203,"goal":"lemma SetUnionCard_3860(B: set, U: set)\n requires B * U == {}\n ensures |B + U| == |B| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_3861","instance":3861,"id":207204,"goal":"lemma SetUnionComm_3861(B: set, T: set)\n ensures B + T == T + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_3862","instance":3862,"id":207205,"goal":"lemma SetInterComm_3862(S: set, U: set)\n ensures S * U == U * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_3863","instance":3863,"id":207206,"goal":"lemma SetUnionAssoc_3863(U: set, B: set, T: set)\n ensures (U + B) + T == U + (B + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_3864","instance":3864,"id":207207,"goal":"lemma SetSubsetRefl_3864(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_3865","instance":3865,"id":207208,"goal":"lemma SetSubsetTrans_3865(T: set, A: set, S: set)\n requires T <= A && A <= S\n ensures T <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_3866","instance":3866,"id":207209,"goal":"lemma SetUnionEmpty_3866(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_3867","instance":3867,"id":207210,"goal":"lemma SetInterEmpty_3867(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_3868","instance":3868,"id":207211,"goal":"lemma SetInterSubset_3868(S: set, T: set)\n ensures S * T <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_3869","instance":3869,"id":207212,"goal":"lemma SetCardSubset_3869(S: set, A: set)\n requires S <= A\n ensures |S| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_3870","instance":3870,"id":207213,"goal":"lemma SetUnionCard_3870(U: set, S: set)\n requires U * S == {}\n ensures |U + S| == |U| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_3871","instance":3871,"id":207214,"goal":"lemma SetUnionComm_3871(T: set, S: set)\n ensures T + S == S + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_3872","instance":3872,"id":207215,"goal":"lemma SetInterComm_3872(A: set, T: set)\n ensures A * T == T * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_3873","instance":3873,"id":207216,"goal":"lemma SetUnionAssoc_3873(U: set, A: set, B: set)\n ensures (U + A) + B == U + (A + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_3874","instance":3874,"id":207217,"goal":"lemma SetSubsetRefl_3874(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_3875","instance":3875,"id":207218,"goal":"lemma SetSubsetTrans_3875(U: set, T: set, S: set)\n requires U <= T && T <= S\n ensures U <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_3876","instance":3876,"id":207219,"goal":"lemma SetUnionEmpty_3876(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_3877","instance":3877,"id":207220,"goal":"lemma SetInterEmpty_3877(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_3878","instance":3878,"id":207221,"goal":"lemma SetInterSubset_3878(S: set, A: set)\n ensures S * A <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_3879","instance":3879,"id":207222,"goal":"lemma SetCardSubset_3879(U: set, S: set)\n requires U <= S\n ensures |U| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_3880","instance":3880,"id":207223,"goal":"lemma SetUnionCard_3880(S: set, T: set)\n requires S * T == {}\n ensures |S + T| == |S| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_3881","instance":3881,"id":207224,"goal":"lemma SetUnionComm_3881(S: set, U: set)\n ensures S + U == U + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_3882","instance":3882,"id":207225,"goal":"lemma SetInterComm_3882(U: set, B: set)\n ensures U * B == B * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_3883","instance":3883,"id":207226,"goal":"lemma SetUnionAssoc_3883(A: set, T: set, S: set)\n ensures (A + T) + S == A + (T + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_3884","instance":3884,"id":207227,"goal":"lemma SetSubsetRefl_3884(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_3885","instance":3885,"id":207228,"goal":"lemma SetSubsetTrans_3885(A: set, T: set, B: set)\n requires A <= T && T <= B\n ensures A <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_3886","instance":3886,"id":207229,"goal":"lemma SetUnionEmpty_3886(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_3887","instance":3887,"id":207230,"goal":"lemma SetInterEmpty_3887(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_3888","instance":3888,"id":207231,"goal":"lemma SetInterSubset_3888(T: set, U: set)\n ensures T * U <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_3889","instance":3889,"id":207232,"goal":"lemma SetCardSubset_3889(U: set, B: set)\n requires U <= B\n ensures |U| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_3890","instance":3890,"id":207233,"goal":"lemma SetUnionCard_3890(S: set, T: set)\n requires S * T == {}\n ensures |S + T| == |S| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_3891","instance":3891,"id":207234,"goal":"lemma SetUnionComm_3891(B: set, U: set)\n ensures B + U == U + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_3892","instance":3892,"id":207235,"goal":"lemma SetInterComm_3892(T: set, B: set)\n ensures T * B == B * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_3893","instance":3893,"id":207236,"goal":"lemma SetUnionAssoc_3893(U: set, B: set, A: set)\n ensures (U + B) + A == U + (B + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_3894","instance":3894,"id":207237,"goal":"lemma SetSubsetRefl_3894(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_3895","instance":3895,"id":207238,"goal":"lemma SetSubsetTrans_3895(A: set, T: set, B: set)\n requires A <= T && T <= B\n ensures A <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_3896","instance":3896,"id":207239,"goal":"lemma SetUnionEmpty_3896(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_3897","instance":3897,"id":207240,"goal":"lemma SetInterEmpty_3897(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_3898","instance":3898,"id":207241,"goal":"lemma SetInterSubset_3898(A: set, B: set)\n ensures A * B <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_3899","instance":3899,"id":207242,"goal":"lemma SetCardSubset_3899(T: set, U: set)\n requires T <= U\n ensures |T| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_3900","instance":3900,"id":207243,"goal":"lemma SetUnionCard_3900(A: set, S: set)\n requires A * S == {}\n ensures |A + S| == |A| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_3901","instance":3901,"id":207244,"goal":"lemma SetUnionComm_3901(A: set, B: set)\n ensures A + B == B + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_3902","instance":3902,"id":207245,"goal":"lemma SetInterComm_3902(B: set, T: set)\n ensures B * T == T * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_3903","instance":3903,"id":207246,"goal":"lemma SetUnionAssoc_3903(T: set, S: set, U: set)\n ensures (T + S) + U == T + (S + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_3904","instance":3904,"id":207247,"goal":"lemma SetSubsetRefl_3904(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_3905","instance":3905,"id":207248,"goal":"lemma SetSubsetTrans_3905(T: set, U: set, A: set)\n requires T <= U && U <= A\n ensures T <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_3906","instance":3906,"id":207249,"goal":"lemma SetUnionEmpty_3906(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_3907","instance":3907,"id":207250,"goal":"lemma SetInterEmpty_3907(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_3908","instance":3908,"id":207251,"goal":"lemma SetInterSubset_3908(S: set, U: set)\n ensures S * U <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_3909","instance":3909,"id":207252,"goal":"lemma SetCardSubset_3909(A: set, B: set)\n requires A <= B\n ensures |A| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_3910","instance":3910,"id":207253,"goal":"lemma SetUnionCard_3910(S: set, T: set)\n requires S * T == {}\n ensures |S + T| == |S| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_3911","instance":3911,"id":207254,"goal":"lemma SetUnionComm_3911(A: set, U: set)\n ensures A + U == U + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_3912","instance":3912,"id":207255,"goal":"lemma SetInterComm_3912(T: set, S: set)\n ensures T * S == S * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_3913","instance":3913,"id":207256,"goal":"lemma SetUnionAssoc_3913(B: set, S: set, A: set)\n ensures (B + S) + A == B + (S + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_3914","instance":3914,"id":207257,"goal":"lemma SetSubsetRefl_3914(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_3915","instance":3915,"id":207258,"goal":"lemma SetSubsetTrans_3915(T: set, U: set, A: set)\n requires T <= U && U <= A\n ensures T <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_3916","instance":3916,"id":207259,"goal":"lemma SetUnionEmpty_3916(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_3917","instance":3917,"id":207260,"goal":"lemma SetInterEmpty_3917(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_3918","instance":3918,"id":207261,"goal":"lemma SetInterSubset_3918(U: set, A: set)\n ensures U * A <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_3919","instance":3919,"id":207262,"goal":"lemma SetCardSubset_3919(B: set, A: set)\n requires B <= A\n ensures |B| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_3920","instance":3920,"id":207263,"goal":"lemma SetUnionCard_3920(S: set, A: set)\n requires S * A == {}\n ensures |S + A| == |S| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_3921","instance":3921,"id":207264,"goal":"lemma SetUnionComm_3921(B: set, U: set)\n ensures B + U == U + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_3922","instance":3922,"id":207265,"goal":"lemma SetInterComm_3922(S: set, T: set)\n ensures S * T == T * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_3923","instance":3923,"id":207266,"goal":"lemma SetUnionAssoc_3923(U: set, S: set, A: set)\n ensures (U + S) + A == U + (S + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_3924","instance":3924,"id":207267,"goal":"lemma SetSubsetRefl_3924(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_3925","instance":3925,"id":207268,"goal":"lemma SetSubsetTrans_3925(A: set, T: set, U: set)\n requires A <= T && T <= U\n ensures A <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_3926","instance":3926,"id":207269,"goal":"lemma SetUnionEmpty_3926(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_3927","instance":3927,"id":207270,"goal":"lemma SetInterEmpty_3927(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_3928","instance":3928,"id":207271,"goal":"lemma SetInterSubset_3928(T: set, A: set)\n ensures T * A <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_3929","instance":3929,"id":207272,"goal":"lemma SetCardSubset_3929(A: set, U: set)\n requires A <= U\n ensures |A| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_3930","instance":3930,"id":207273,"goal":"lemma SetUnionCard_3930(S: set, B: set)\n requires S * B == {}\n ensures |S + B| == |S| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_3931","instance":3931,"id":207274,"goal":"lemma SetUnionComm_3931(A: set, U: set)\n ensures A + U == U + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_3932","instance":3932,"id":207275,"goal":"lemma SetInterComm_3932(T: set, A: set)\n ensures T * A == A * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_3933","instance":3933,"id":207276,"goal":"lemma SetUnionAssoc_3933(T: set, S: set, B: set)\n ensures (T + S) + B == T + (S + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_3934","instance":3934,"id":207277,"goal":"lemma SetSubsetRefl_3934(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_3935","instance":3935,"id":207278,"goal":"lemma SetSubsetTrans_3935(S: set, A: set, B: set)\n requires S <= A && A <= B\n ensures S <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_3936","instance":3936,"id":207279,"goal":"lemma SetUnionEmpty_3936(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_3937","instance":3937,"id":207280,"goal":"lemma SetInterEmpty_3937(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_3938","instance":3938,"id":207281,"goal":"lemma SetInterSubset_3938(S: set, T: set)\n ensures S * T <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_3939","instance":3939,"id":207282,"goal":"lemma SetCardSubset_3939(B: set, U: set)\n requires B <= U\n ensures |B| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_3940","instance":3940,"id":207283,"goal":"lemma SetUnionCard_3940(S: set, A: set)\n requires S * A == {}\n ensures |S + A| == |S| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_3941","instance":3941,"id":207284,"goal":"lemma SetUnionComm_3941(B: set, S: set)\n ensures B + S == S + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_3942","instance":3942,"id":207285,"goal":"lemma SetInterComm_3942(S: set, A: set)\n ensures S * A == A * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_3943","instance":3943,"id":207286,"goal":"lemma SetUnionAssoc_3943(U: set, B: set, A: set)\n ensures (U + B) + A == U + (B + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_3944","instance":3944,"id":207287,"goal":"lemma SetSubsetRefl_3944(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_3945","instance":3945,"id":207288,"goal":"lemma SetSubsetTrans_3945(B: set, A: set, S: set)\n requires B <= A && A <= S\n ensures B <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_3946","instance":3946,"id":207289,"goal":"lemma SetUnionEmpty_3946(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_3947","instance":3947,"id":207290,"goal":"lemma SetInterEmpty_3947(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_3948","instance":3948,"id":207291,"goal":"lemma SetInterSubset_3948(U: set, A: set)\n ensures U * A <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_3949","instance":3949,"id":207292,"goal":"lemma SetCardSubset_3949(T: set, S: set)\n requires T <= S\n ensures |T| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_3950","instance":3950,"id":207293,"goal":"lemma SetUnionCard_3950(T: set, B: set)\n requires T * B == {}\n ensures |T + B| == |T| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_3951","instance":3951,"id":207294,"goal":"lemma SetUnionComm_3951(S: set, T: set)\n ensures S + T == T + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_3952","instance":3952,"id":207295,"goal":"lemma SetInterComm_3952(S: set, T: set)\n ensures S * T == T * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_3953","instance":3953,"id":207296,"goal":"lemma SetUnionAssoc_3953(B: set, U: set, A: set)\n ensures (B + U) + A == B + (U + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_3954","instance":3954,"id":207297,"goal":"lemma SetSubsetRefl_3954(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_3955","instance":3955,"id":207298,"goal":"lemma SetSubsetTrans_3955(T: set, S: set, A: set)\n requires T <= S && S <= A\n ensures T <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_3956","instance":3956,"id":207299,"goal":"lemma SetUnionEmpty_3956(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_3957","instance":3957,"id":207300,"goal":"lemma SetInterEmpty_3957(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_3958","instance":3958,"id":207301,"goal":"lemma SetInterSubset_3958(B: set, S: set)\n ensures B * S <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_3959","instance":3959,"id":207302,"goal":"lemma SetCardSubset_3959(S: set, B: set)\n requires S <= B\n ensures |S| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_3960","instance":3960,"id":207303,"goal":"lemma SetUnionCard_3960(T: set, U: set)\n requires T * U == {}\n ensures |T + U| == |T| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_3961","instance":3961,"id":207304,"goal":"lemma SetUnionComm_3961(U: set, B: set)\n ensures U + B == B + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_3962","instance":3962,"id":207305,"goal":"lemma SetInterComm_3962(U: set, S: set)\n ensures U * S == S * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_3963","instance":3963,"id":207306,"goal":"lemma SetUnionAssoc_3963(U: set, S: set, B: set)\n ensures (U + S) + B == U + (S + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_3964","instance":3964,"id":207307,"goal":"lemma SetSubsetRefl_3964(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_3965","instance":3965,"id":207308,"goal":"lemma SetSubsetTrans_3965(A: set, U: set, T: set)\n requires A <= U && U <= T\n ensures A <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_3966","instance":3966,"id":207309,"goal":"lemma SetUnionEmpty_3966(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_3967","instance":3967,"id":207310,"goal":"lemma SetInterEmpty_3967(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_3968","instance":3968,"id":207311,"goal":"lemma SetInterSubset_3968(T: set, U: set)\n ensures T * U <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_3969","instance":3969,"id":207312,"goal":"lemma SetCardSubset_3969(A: set, S: set)\n requires A <= S\n ensures |A| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_3970","instance":3970,"id":207313,"goal":"lemma SetUnionCard_3970(S: set, B: set)\n requires S * B == {}\n ensures |S + B| == |S| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_3971","instance":3971,"id":207314,"goal":"lemma SetUnionComm_3971(U: set, S: set)\n ensures U + S == S + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_3972","instance":3972,"id":207315,"goal":"lemma SetInterComm_3972(T: set, A: set)\n ensures T * A == A * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_3973","instance":3973,"id":207316,"goal":"lemma SetUnionAssoc_3973(A: set, B: set, T: set)\n ensures (A + B) + T == A + (B + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_3974","instance":3974,"id":207317,"goal":"lemma SetSubsetRefl_3974(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_3975","instance":3975,"id":207318,"goal":"lemma SetSubsetTrans_3975(B: set, U: set, A: set)\n requires B <= U && U <= A\n ensures B <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_3976","instance":3976,"id":207319,"goal":"lemma SetUnionEmpty_3976(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_3977","instance":3977,"id":207320,"goal":"lemma SetInterEmpty_3977(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_3978","instance":3978,"id":207321,"goal":"lemma SetInterSubset_3978(A: set, T: set)\n ensures A * T <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_3979","instance":3979,"id":207322,"goal":"lemma SetCardSubset_3979(T: set, A: set)\n requires T <= A\n ensures |T| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_3980","instance":3980,"id":207323,"goal":"lemma SetUnionCard_3980(T: set, B: set)\n requires T * B == {}\n ensures |T + B| == |T| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_3981","instance":3981,"id":207324,"goal":"lemma SetUnionComm_3981(A: set, T: set)\n ensures A + T == T + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_3982","instance":3982,"id":207325,"goal":"lemma SetInterComm_3982(B: set, A: set)\n ensures B * A == A * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_3983","instance":3983,"id":207326,"goal":"lemma SetUnionAssoc_3983(A: set, T: set, S: set)\n ensures (A + T) + S == A + (T + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_3984","instance":3984,"id":207327,"goal":"lemma SetSubsetRefl_3984(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_3985","instance":3985,"id":207328,"goal":"lemma SetSubsetTrans_3985(A: set, B: set, T: set)\n requires A <= B && B <= T\n ensures A <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_3986","instance":3986,"id":207329,"goal":"lemma SetUnionEmpty_3986(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_3987","instance":3987,"id":207330,"goal":"lemma SetInterEmpty_3987(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_3988","instance":3988,"id":207331,"goal":"lemma SetInterSubset_3988(B: set, S: set)\n ensures B * S <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_3989","instance":3989,"id":207332,"goal":"lemma SetCardSubset_3989(A: set, B: set)\n requires A <= B\n ensures |A| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_3990","instance":3990,"id":207333,"goal":"lemma SetUnionCard_3990(T: set, B: set)\n requires T * B == {}\n ensures |T + B| == |T| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_3991","instance":3991,"id":207334,"goal":"lemma SetUnionComm_3991(U: set, S: set)\n ensures U + S == S + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_3992","instance":3992,"id":207335,"goal":"lemma SetInterComm_3992(A: set, U: set)\n ensures A * U == U * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_3993","instance":3993,"id":207336,"goal":"lemma SetUnionAssoc_3993(A: set, U: set, T: set)\n ensures (A + U) + T == A + (U + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_3994","instance":3994,"id":207337,"goal":"lemma SetSubsetRefl_3994(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_3995","instance":3995,"id":207338,"goal":"lemma SetSubsetTrans_3995(U: set, T: set, B: set)\n requires U <= T && T <= B\n ensures U <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_3996","instance":3996,"id":207339,"goal":"lemma SetUnionEmpty_3996(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_3997","instance":3997,"id":207340,"goal":"lemma SetInterEmpty_3997(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_3998","instance":3998,"id":207341,"goal":"lemma SetInterSubset_3998(B: set, T: set)\n ensures B * T <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_3999","instance":3999,"id":207342,"goal":"lemma SetCardSubset_3999(A: set, T: set)\n requires A <= T\n ensures |A| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_4000","instance":4000,"id":207343,"goal":"lemma SetUnionCard_4000(S: set, A: set)\n requires S * A == {}\n ensures |S + A| == |S| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_4001","instance":4001,"id":207344,"goal":"lemma SetUnionComm_4001(A: set, U: set)\n ensures A + U == U + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_4002","instance":4002,"id":207345,"goal":"lemma SetInterComm_4002(A: set, S: set)\n ensures A * S == S * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_4003","instance":4003,"id":207346,"goal":"lemma SetUnionAssoc_4003(B: set, T: set, A: set)\n ensures (B + T) + A == B + (T + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_4004","instance":4004,"id":207347,"goal":"lemma SetSubsetRefl_4004(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_4005","instance":4005,"id":207348,"goal":"lemma SetSubsetTrans_4005(A: set, U: set, S: set)\n requires A <= U && U <= S\n ensures A <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_4006","instance":4006,"id":207349,"goal":"lemma SetUnionEmpty_4006(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_4007","instance":4007,"id":207350,"goal":"lemma SetInterEmpty_4007(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_4008","instance":4008,"id":207351,"goal":"lemma SetInterSubset_4008(A: set, B: set)\n ensures A * B <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_4009","instance":4009,"id":207352,"goal":"lemma SetCardSubset_4009(B: set, S: set)\n requires B <= S\n ensures |B| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_4010","instance":4010,"id":207353,"goal":"lemma SetUnionCard_4010(A: set, T: set)\n requires A * T == {}\n ensures |A + T| == |A| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_4011","instance":4011,"id":207354,"goal":"lemma SetUnionComm_4011(U: set, A: set)\n ensures U + A == A + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_4012","instance":4012,"id":207355,"goal":"lemma SetInterComm_4012(S: set, U: set)\n ensures S * U == U * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_4013","instance":4013,"id":207356,"goal":"lemma SetUnionAssoc_4013(B: set, U: set, T: set)\n ensures (B + U) + T == B + (U + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_4014","instance":4014,"id":207357,"goal":"lemma SetSubsetRefl_4014(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_4015","instance":4015,"id":207358,"goal":"lemma SetSubsetTrans_4015(S: set, T: set, A: set)\n requires S <= T && T <= A\n ensures S <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_4016","instance":4016,"id":207359,"goal":"lemma SetUnionEmpty_4016(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_4017","instance":4017,"id":207360,"goal":"lemma SetInterEmpty_4017(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_4018","instance":4018,"id":207361,"goal":"lemma SetInterSubset_4018(U: set, A: set)\n ensures U * A <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_4019","instance":4019,"id":207362,"goal":"lemma SetCardSubset_4019(S: set, T: set)\n requires S <= T\n ensures |S| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_4020","instance":4020,"id":207363,"goal":"lemma SetUnionCard_4020(S: set, U: set)\n requires S * U == {}\n ensures |S + U| == |S| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_4021","instance":4021,"id":207364,"goal":"lemma SetUnionComm_4021(A: set, T: set)\n ensures A + T == T + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_4022","instance":4022,"id":207365,"goal":"lemma SetInterComm_4022(A: set, U: set)\n ensures A * U == U * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_4023","instance":4023,"id":207366,"goal":"lemma SetUnionAssoc_4023(T: set, S: set, U: set)\n ensures (T + S) + U == T + (S + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_4024","instance":4024,"id":207367,"goal":"lemma SetSubsetRefl_4024(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_4025","instance":4025,"id":207368,"goal":"lemma SetSubsetTrans_4025(S: set, T: set, U: set)\n requires S <= T && T <= U\n ensures S <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_4026","instance":4026,"id":207369,"goal":"lemma SetUnionEmpty_4026(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_4027","instance":4027,"id":207370,"goal":"lemma SetInterEmpty_4027(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_4028","instance":4028,"id":207371,"goal":"lemma SetInterSubset_4028(S: set, A: set)\n ensures S * A <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_4029","instance":4029,"id":207372,"goal":"lemma SetCardSubset_4029(A: set, U: set)\n requires A <= U\n ensures |A| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_4030","instance":4030,"id":207373,"goal":"lemma SetUnionCard_4030(U: set, B: set)\n requires U * B == {}\n ensures |U + B| == |U| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_4031","instance":4031,"id":207374,"goal":"lemma SetUnionComm_4031(A: set, U: set)\n ensures A + U == U + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_4032","instance":4032,"id":207375,"goal":"lemma SetInterComm_4032(S: set, B: set)\n ensures S * B == B * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_4033","instance":4033,"id":207376,"goal":"lemma SetUnionAssoc_4033(T: set, B: set, U: set)\n ensures (T + B) + U == T + (B + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_4034","instance":4034,"id":207377,"goal":"lemma SetSubsetRefl_4034(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_4035","instance":4035,"id":207378,"goal":"lemma SetSubsetTrans_4035(T: set, U: set, S: set)\n requires T <= U && U <= S\n ensures T <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_4036","instance":4036,"id":207379,"goal":"lemma SetUnionEmpty_4036(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_4037","instance":4037,"id":207380,"goal":"lemma SetInterEmpty_4037(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_4038","instance":4038,"id":207381,"goal":"lemma SetInterSubset_4038(A: set, B: set)\n ensures A * B <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_4039","instance":4039,"id":207382,"goal":"lemma SetCardSubset_4039(A: set, U: set)\n requires A <= U\n ensures |A| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_4040","instance":4040,"id":207383,"goal":"lemma SetUnionCard_4040(T: set, A: set)\n requires T * A == {}\n ensures |T + A| == |T| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_4041","instance":4041,"id":207384,"goal":"lemma SetUnionComm_4041(A: set, B: set)\n ensures A + B == B + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_4042","instance":4042,"id":207385,"goal":"lemma SetInterComm_4042(S: set, A: set)\n ensures S * A == A * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_4043","instance":4043,"id":207386,"goal":"lemma SetUnionAssoc_4043(B: set, U: set, S: set)\n ensures (B + U) + S == B + (U + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_4044","instance":4044,"id":207387,"goal":"lemma SetSubsetRefl_4044(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_4045","instance":4045,"id":207388,"goal":"lemma SetSubsetTrans_4045(S: set, A: set, U: set)\n requires S <= A && A <= U\n ensures S <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_4046","instance":4046,"id":207389,"goal":"lemma SetUnionEmpty_4046(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_4047","instance":4047,"id":207390,"goal":"lemma SetInterEmpty_4047(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_4048","instance":4048,"id":207391,"goal":"lemma SetInterSubset_4048(A: set, T: set)\n ensures A * T <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_4049","instance":4049,"id":207392,"goal":"lemma SetCardSubset_4049(S: set, U: set)\n requires S <= U\n ensures |S| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_4050","instance":4050,"id":207393,"goal":"lemma SetUnionCard_4050(T: set, U: set)\n requires T * U == {}\n ensures |T + U| == |T| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_4051","instance":4051,"id":207394,"goal":"lemma SetUnionComm_4051(T: set, B: set)\n ensures T + B == B + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_4052","instance":4052,"id":207395,"goal":"lemma SetInterComm_4052(A: set, B: set)\n ensures A * B == B * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_4053","instance":4053,"id":207396,"goal":"lemma SetUnionAssoc_4053(T: set, A: set, B: set)\n ensures (T + A) + B == T + (A + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_4054","instance":4054,"id":207397,"goal":"lemma SetSubsetRefl_4054(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_4055","instance":4055,"id":207398,"goal":"lemma SetSubsetTrans_4055(T: set, S: set, U: set)\n requires T <= S && S <= U\n ensures T <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_4056","instance":4056,"id":207399,"goal":"lemma SetUnionEmpty_4056(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_4057","instance":4057,"id":207400,"goal":"lemma SetInterEmpty_4057(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_4058","instance":4058,"id":207401,"goal":"lemma SetInterSubset_4058(T: set, U: set)\n ensures T * U <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_4059","instance":4059,"id":207402,"goal":"lemma SetCardSubset_4059(B: set, U: set)\n requires B <= U\n ensures |B| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_4060","instance":4060,"id":207403,"goal":"lemma SetUnionCard_4060(T: set, S: set)\n requires T * S == {}\n ensures |T + S| == |T| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_4061","instance":4061,"id":207404,"goal":"lemma SetUnionComm_4061(S: set, A: set)\n ensures S + A == A + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_4062","instance":4062,"id":207405,"goal":"lemma SetInterComm_4062(B: set, S: set)\n ensures B * S == S * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_4063","instance":4063,"id":207406,"goal":"lemma SetUnionAssoc_4063(T: set, S: set, B: set)\n ensures (T + S) + B == T + (S + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_4064","instance":4064,"id":207407,"goal":"lemma SetSubsetRefl_4064(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_4065","instance":4065,"id":207408,"goal":"lemma SetSubsetTrans_4065(U: set, S: set, B: set)\n requires U <= S && S <= B\n ensures U <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_4066","instance":4066,"id":207409,"goal":"lemma SetUnionEmpty_4066(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_4067","instance":4067,"id":207410,"goal":"lemma SetInterEmpty_4067(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_4068","instance":4068,"id":207411,"goal":"lemma SetInterSubset_4068(T: set, B: set)\n ensures T * B <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_4069","instance":4069,"id":207412,"goal":"lemma SetCardSubset_4069(S: set, T: set)\n requires S <= T\n ensures |S| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_4070","instance":4070,"id":207413,"goal":"lemma SetUnionCard_4070(S: set, T: set)\n requires S * T == {}\n ensures |S + T| == |S| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_4071","instance":4071,"id":207414,"goal":"lemma SetUnionComm_4071(U: set, S: set)\n ensures U + S == S + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_4072","instance":4072,"id":207415,"goal":"lemma SetInterComm_4072(B: set, T: set)\n ensures B * T == T * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_4073","instance":4073,"id":207416,"goal":"lemma SetUnionAssoc_4073(T: set, S: set, B: set)\n ensures (T + S) + B == T + (S + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_4074","instance":4074,"id":207417,"goal":"lemma SetSubsetRefl_4074(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_4075","instance":4075,"id":207418,"goal":"lemma SetSubsetTrans_4075(T: set, B: set, A: set)\n requires T <= B && B <= A\n ensures T <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_4076","instance":4076,"id":207419,"goal":"lemma SetUnionEmpty_4076(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_4077","instance":4077,"id":207420,"goal":"lemma SetInterEmpty_4077(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_4078","instance":4078,"id":207421,"goal":"lemma SetInterSubset_4078(U: set, A: set)\n ensures U * A <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_4079","instance":4079,"id":207422,"goal":"lemma SetCardSubset_4079(A: set, U: set)\n requires A <= U\n ensures |A| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_4080","instance":4080,"id":207423,"goal":"lemma SetUnionCard_4080(T: set, B: set)\n requires T * B == {}\n ensures |T + B| == |T| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_4081","instance":4081,"id":207424,"goal":"lemma SetUnionComm_4081(T: set, U: set)\n ensures T + U == U + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_4082","instance":4082,"id":207425,"goal":"lemma SetInterComm_4082(U: set, T: set)\n ensures U * T == T * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_4083","instance":4083,"id":207426,"goal":"lemma SetUnionAssoc_4083(U: set, A: set, S: set)\n ensures (U + A) + S == U + (A + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_4084","instance":4084,"id":207427,"goal":"lemma SetSubsetRefl_4084(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_4085","instance":4085,"id":207428,"goal":"lemma SetSubsetTrans_4085(U: set, B: set, S: set)\n requires U <= B && B <= S\n ensures U <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_4086","instance":4086,"id":207429,"goal":"lemma SetUnionEmpty_4086(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_4087","instance":4087,"id":207430,"goal":"lemma SetInterEmpty_4087(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_4088","instance":4088,"id":207431,"goal":"lemma SetInterSubset_4088(B: set, U: set)\n ensures B * U <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_4089","instance":4089,"id":207432,"goal":"lemma SetCardSubset_4089(U: set, B: set)\n requires U <= B\n ensures |U| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_4090","instance":4090,"id":207433,"goal":"lemma SetUnionCard_4090(U: set, A: set)\n requires U * A == {}\n ensures |U + A| == |U| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_4091","instance":4091,"id":207434,"goal":"lemma SetUnionComm_4091(T: set, S: set)\n ensures T + S == S + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_4092","instance":4092,"id":207435,"goal":"lemma SetInterComm_4092(U: set, S: set)\n ensures U * S == S * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_4093","instance":4093,"id":207436,"goal":"lemma SetUnionAssoc_4093(U: set, S: set, T: set)\n ensures (U + S) + T == U + (S + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_4094","instance":4094,"id":207437,"goal":"lemma SetSubsetRefl_4094(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_4095","instance":4095,"id":207438,"goal":"lemma SetSubsetTrans_4095(T: set, A: set, B: set)\n requires T <= A && A <= B\n ensures T <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_4096","instance":4096,"id":207439,"goal":"lemma SetUnionEmpty_4096(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_4097","instance":4097,"id":207440,"goal":"lemma SetInterEmpty_4097(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_4098","instance":4098,"id":207441,"goal":"lemma SetInterSubset_4098(B: set, S: set)\n ensures B * S <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_4099","instance":4099,"id":207442,"goal":"lemma SetCardSubset_4099(U: set, T: set)\n requires U <= T\n ensures |U| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_4100","instance":4100,"id":207443,"goal":"lemma SetUnionCard_4100(U: set, T: set)\n requires U * T == {}\n ensures |U + T| == |U| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_4101","instance":4101,"id":207444,"goal":"lemma SetUnionComm_4101(B: set, T: set)\n ensures B + T == T + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_4102","instance":4102,"id":207445,"goal":"lemma SetInterComm_4102(A: set, B: set)\n ensures A * B == B * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_4103","instance":4103,"id":207446,"goal":"lemma SetUnionAssoc_4103(S: set, T: set, U: set)\n ensures (S + T) + U == S + (T + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_4104","instance":4104,"id":207447,"goal":"lemma SetSubsetRefl_4104(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_4105","instance":4105,"id":207448,"goal":"lemma SetSubsetTrans_4105(S: set, T: set, A: set)\n requires S <= T && T <= A\n ensures S <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_4106","instance":4106,"id":207449,"goal":"lemma SetUnionEmpty_4106(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_4107","instance":4107,"id":207450,"goal":"lemma SetInterEmpty_4107(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_4108","instance":4108,"id":207451,"goal":"lemma SetInterSubset_4108(S: set, A: set)\n ensures S * A <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_4109","instance":4109,"id":207452,"goal":"lemma SetCardSubset_4109(A: set, B: set)\n requires A <= B\n ensures |A| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_4110","instance":4110,"id":207453,"goal":"lemma SetUnionCard_4110(S: set, A: set)\n requires S * A == {}\n ensures |S + A| == |S| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_4111","instance":4111,"id":207454,"goal":"lemma SetUnionComm_4111(S: set, B: set)\n ensures S + B == B + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_4112","instance":4112,"id":207455,"goal":"lemma SetInterComm_4112(B: set, U: set)\n ensures B * U == U * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_4113","instance":4113,"id":207456,"goal":"lemma SetUnionAssoc_4113(S: set, T: set, B: set)\n ensures (S + T) + B == S + (T + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_4114","instance":4114,"id":207457,"goal":"lemma SetSubsetRefl_4114(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_4115","instance":4115,"id":207458,"goal":"lemma SetSubsetTrans_4115(B: set, U: set, T: set)\n requires B <= U && U <= T\n ensures B <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_4116","instance":4116,"id":207459,"goal":"lemma SetUnionEmpty_4116(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_4117","instance":4117,"id":207460,"goal":"lemma SetInterEmpty_4117(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_4118","instance":4118,"id":207461,"goal":"lemma SetInterSubset_4118(U: set, S: set)\n ensures U * S <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_4119","instance":4119,"id":207462,"goal":"lemma SetCardSubset_4119(T: set, S: set)\n requires T <= S\n ensures |T| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_4120","instance":4120,"id":207463,"goal":"lemma SetUnionCard_4120(T: set, U: set)\n requires T * U == {}\n ensures |T + U| == |T| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_4121","instance":4121,"id":207464,"goal":"lemma SetUnionComm_4121(S: set, A: set)\n ensures S + A == A + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_4122","instance":4122,"id":207465,"goal":"lemma SetInterComm_4122(U: set, S: set)\n ensures U * S == S * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_4123","instance":4123,"id":207466,"goal":"lemma SetUnionAssoc_4123(B: set, T: set, S: set)\n ensures (B + T) + S == B + (T + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_4124","instance":4124,"id":207467,"goal":"lemma SetSubsetRefl_4124(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_4125","instance":4125,"id":207468,"goal":"lemma SetSubsetTrans_4125(A: set, S: set, U: set)\n requires A <= S && S <= U\n ensures A <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_4126","instance":4126,"id":207469,"goal":"lemma SetUnionEmpty_4126(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_4127","instance":4127,"id":207470,"goal":"lemma SetInterEmpty_4127(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_4128","instance":4128,"id":207471,"goal":"lemma SetInterSubset_4128(U: set, B: set)\n ensures U * B <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_4129","instance":4129,"id":207472,"goal":"lemma SetCardSubset_4129(T: set, S: set)\n requires T <= S\n ensures |T| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_4130","instance":4130,"id":207473,"goal":"lemma SetUnionCard_4130(B: set, A: set)\n requires B * A == {}\n ensures |B + A| == |B| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_4131","instance":4131,"id":207474,"goal":"lemma SetUnionComm_4131(U: set, B: set)\n ensures U + B == B + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_4132","instance":4132,"id":207475,"goal":"lemma SetInterComm_4132(T: set, B: set)\n ensures T * B == B * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_4133","instance":4133,"id":207476,"goal":"lemma SetUnionAssoc_4133(S: set, A: set, B: set)\n ensures (S + A) + B == S + (A + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_4134","instance":4134,"id":207477,"goal":"lemma SetSubsetRefl_4134(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_4135","instance":4135,"id":207478,"goal":"lemma SetSubsetTrans_4135(B: set, U: set, A: set)\n requires B <= U && U <= A\n ensures B <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_4136","instance":4136,"id":207479,"goal":"lemma SetUnionEmpty_4136(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_4137","instance":4137,"id":207480,"goal":"lemma SetInterEmpty_4137(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_4138","instance":4138,"id":207481,"goal":"lemma SetInterSubset_4138(B: set, A: set)\n ensures B * A <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_4139","instance":4139,"id":207482,"goal":"lemma SetCardSubset_4139(B: set, T: set)\n requires B <= T\n ensures |B| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_4140","instance":4140,"id":207483,"goal":"lemma SetUnionCard_4140(U: set, T: set)\n requires U * T == {}\n ensures |U + T| == |U| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_4141","instance":4141,"id":207484,"goal":"lemma SetUnionComm_4141(A: set, B: set)\n ensures A + B == B + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_4142","instance":4142,"id":207485,"goal":"lemma SetInterComm_4142(T: set, U: set)\n ensures T * U == U * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_4143","instance":4143,"id":207486,"goal":"lemma SetUnionAssoc_4143(S: set, T: set, A: set)\n ensures (S + T) + A == S + (T + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_4144","instance":4144,"id":207487,"goal":"lemma SetSubsetRefl_4144(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_4145","instance":4145,"id":207488,"goal":"lemma SetSubsetTrans_4145(U: set, T: set, B: set)\n requires U <= T && T <= B\n ensures U <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_4146","instance":4146,"id":207489,"goal":"lemma SetUnionEmpty_4146(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_4147","instance":4147,"id":207490,"goal":"lemma SetInterEmpty_4147(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_4148","instance":4148,"id":207491,"goal":"lemma SetInterSubset_4148(T: set, B: set)\n ensures T * B <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_4149","instance":4149,"id":207492,"goal":"lemma SetCardSubset_4149(U: set, S: set)\n requires U <= S\n ensures |U| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_4150","instance":4150,"id":207493,"goal":"lemma SetUnionCard_4150(S: set, T: set)\n requires S * T == {}\n ensures |S + T| == |S| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_4151","instance":4151,"id":207494,"goal":"lemma SetUnionComm_4151(U: set, T: set)\n ensures U + T == T + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_4152","instance":4152,"id":207495,"goal":"lemma SetInterComm_4152(A: set, U: set)\n ensures A * U == U * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_4153","instance":4153,"id":207496,"goal":"lemma SetUnionAssoc_4153(S: set, T: set, A: set)\n ensures (S + T) + A == S + (T + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_4154","instance":4154,"id":207497,"goal":"lemma SetSubsetRefl_4154(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_4155","instance":4155,"id":207498,"goal":"lemma SetSubsetTrans_4155(T: set, U: set, A: set)\n requires T <= U && U <= A\n ensures T <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_4156","instance":4156,"id":207499,"goal":"lemma SetUnionEmpty_4156(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_4157","instance":4157,"id":207500,"goal":"lemma SetInterEmpty_4157(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_4158","instance":4158,"id":207501,"goal":"lemma SetInterSubset_4158(B: set, U: set)\n ensures B * U <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_4159","instance":4159,"id":207502,"goal":"lemma SetCardSubset_4159(T: set, U: set)\n requires T <= U\n ensures |T| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_4160","instance":4160,"id":207503,"goal":"lemma SetUnionCard_4160(S: set, B: set)\n requires S * B == {}\n ensures |S + B| == |S| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_4161","instance":4161,"id":207504,"goal":"lemma SetUnionComm_4161(B: set, A: set)\n ensures B + A == A + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_4162","instance":4162,"id":207505,"goal":"lemma SetInterComm_4162(B: set, U: set)\n ensures B * U == U * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_4163","instance":4163,"id":207506,"goal":"lemma SetUnionAssoc_4163(A: set, S: set, T: set)\n ensures (A + S) + T == A + (S + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_4164","instance":4164,"id":207507,"goal":"lemma SetSubsetRefl_4164(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_4165","instance":4165,"id":207508,"goal":"lemma SetSubsetTrans_4165(S: set, U: set, A: set)\n requires S <= U && U <= A\n ensures S <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_4166","instance":4166,"id":207509,"goal":"lemma SetUnionEmpty_4166(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_4167","instance":4167,"id":207510,"goal":"lemma SetInterEmpty_4167(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_4168","instance":4168,"id":207511,"goal":"lemma SetInterSubset_4168(A: set, T: set)\n ensures A * T <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_4169","instance":4169,"id":207512,"goal":"lemma SetCardSubset_4169(T: set, S: set)\n requires T <= S\n ensures |T| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_4170","instance":4170,"id":207513,"goal":"lemma SetUnionCard_4170(B: set, T: set)\n requires B * T == {}\n ensures |B + T| == |B| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_4171","instance":4171,"id":207514,"goal":"lemma SetUnionComm_4171(T: set, S: set)\n ensures T + S == S + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_4172","instance":4172,"id":207515,"goal":"lemma SetInterComm_4172(B: set, T: set)\n ensures B * T == T * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_4173","instance":4173,"id":207516,"goal":"lemma SetUnionAssoc_4173(T: set, B: set, A: set)\n ensures (T + B) + A == T + (B + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_4174","instance":4174,"id":207517,"goal":"lemma SetSubsetRefl_4174(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_4175","instance":4175,"id":207518,"goal":"lemma SetSubsetTrans_4175(U: set, B: set, S: set)\n requires U <= B && B <= S\n ensures U <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_4176","instance":4176,"id":207519,"goal":"lemma SetUnionEmpty_4176(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_4177","instance":4177,"id":207520,"goal":"lemma SetInterEmpty_4177(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_4178","instance":4178,"id":207521,"goal":"lemma SetInterSubset_4178(S: set, U: set)\n ensures S * U <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_4179","instance":4179,"id":207522,"goal":"lemma SetCardSubset_4179(A: set, B: set)\n requires A <= B\n ensures |A| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_4180","instance":4180,"id":207523,"goal":"lemma SetUnionCard_4180(U: set, B: set)\n requires U * B == {}\n ensures |U + B| == |U| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_4181","instance":4181,"id":207524,"goal":"lemma SetUnionComm_4181(S: set, U: set)\n ensures S + U == U + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_4182","instance":4182,"id":207525,"goal":"lemma SetInterComm_4182(U: set, S: set)\n ensures U * S == S * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_4183","instance":4183,"id":207526,"goal":"lemma SetUnionAssoc_4183(A: set, T: set, U: set)\n ensures (A + T) + U == A + (T + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_4184","instance":4184,"id":207527,"goal":"lemma SetSubsetRefl_4184(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_4185","instance":4185,"id":207528,"goal":"lemma SetSubsetTrans_4185(U: set, B: set, T: set)\n requires U <= B && B <= T\n ensures U <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_4186","instance":4186,"id":207529,"goal":"lemma SetUnionEmpty_4186(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_4187","instance":4187,"id":207530,"goal":"lemma SetInterEmpty_4187(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_4188","instance":4188,"id":207531,"goal":"lemma SetInterSubset_4188(T: set, S: set)\n ensures T * S <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_4189","instance":4189,"id":207532,"goal":"lemma SetCardSubset_4189(S: set, B: set)\n requires S <= B\n ensures |S| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_4190","instance":4190,"id":207533,"goal":"lemma SetUnionCard_4190(U: set, T: set)\n requires U * T == {}\n ensures |U + T| == |U| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_4191","instance":4191,"id":207534,"goal":"lemma SetUnionComm_4191(A: set, B: set)\n ensures A + B == B + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_4192","instance":4192,"id":207535,"goal":"lemma SetInterComm_4192(T: set, A: set)\n ensures T * A == A * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_4193","instance":4193,"id":207536,"goal":"lemma SetUnionAssoc_4193(B: set, T: set, S: set)\n ensures (B + T) + S == B + (T + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_4194","instance":4194,"id":207537,"goal":"lemma SetSubsetRefl_4194(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_4195","instance":4195,"id":207538,"goal":"lemma SetSubsetTrans_4195(T: set, U: set, A: set)\n requires T <= U && U <= A\n ensures T <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_4196","instance":4196,"id":207539,"goal":"lemma SetUnionEmpty_4196(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_4197","instance":4197,"id":207540,"goal":"lemma SetInterEmpty_4197(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_4198","instance":4198,"id":207541,"goal":"lemma SetInterSubset_4198(T: set, U: set)\n ensures T * U <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_4199","instance":4199,"id":207542,"goal":"lemma SetCardSubset_4199(T: set, U: set)\n requires T <= U\n ensures |T| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_4200","instance":4200,"id":207543,"goal":"lemma SetUnionCard_4200(U: set, S: set)\n requires U * S == {}\n ensures |U + S| == |U| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_4201","instance":4201,"id":207544,"goal":"lemma SetUnionComm_4201(A: set, U: set)\n ensures A + U == U + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_4202","instance":4202,"id":207545,"goal":"lemma SetInterComm_4202(U: set, A: set)\n ensures U * A == A * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_4203","instance":4203,"id":207546,"goal":"lemma SetUnionAssoc_4203(T: set, U: set, S: set)\n ensures (T + U) + S == T + (U + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_4204","instance":4204,"id":207547,"goal":"lemma SetSubsetRefl_4204(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_4205","instance":4205,"id":207548,"goal":"lemma SetSubsetTrans_4205(T: set, S: set, U: set)\n requires T <= S && S <= U\n ensures T <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_4206","instance":4206,"id":207549,"goal":"lemma SetUnionEmpty_4206(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_4207","instance":4207,"id":207550,"goal":"lemma SetInterEmpty_4207(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_4208","instance":4208,"id":207551,"goal":"lemma SetInterSubset_4208(S: set, B: set)\n ensures S * B <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_4209","instance":4209,"id":207552,"goal":"lemma SetCardSubset_4209(U: set, B: set)\n requires U <= B\n ensures |U| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_4210","instance":4210,"id":207553,"goal":"lemma SetUnionCard_4210(U: set, T: set)\n requires U * T == {}\n ensures |U + T| == |U| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_4211","instance":4211,"id":207554,"goal":"lemma SetUnionComm_4211(T: set, B: set)\n ensures T + B == B + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_4212","instance":4212,"id":207555,"goal":"lemma SetInterComm_4212(B: set, T: set)\n ensures B * T == T * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_4213","instance":4213,"id":207556,"goal":"lemma SetUnionAssoc_4213(A: set, S: set, T: set)\n ensures (A + S) + T == A + (S + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_4214","instance":4214,"id":207557,"goal":"lemma SetSubsetRefl_4214(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_4215","instance":4215,"id":207558,"goal":"lemma SetSubsetTrans_4215(S: set, B: set, U: set)\n requires S <= B && B <= U\n ensures S <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_4216","instance":4216,"id":207559,"goal":"lemma SetUnionEmpty_4216(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_4217","instance":4217,"id":207560,"goal":"lemma SetInterEmpty_4217(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_4218","instance":4218,"id":207561,"goal":"lemma SetInterSubset_4218(T: set, S: set)\n ensures T * S <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_4219","instance":4219,"id":207562,"goal":"lemma SetCardSubset_4219(T: set, A: set)\n requires T <= A\n ensures |T| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_4220","instance":4220,"id":207563,"goal":"lemma SetUnionCard_4220(B: set, A: set)\n requires B * A == {}\n ensures |B + A| == |B| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_4221","instance":4221,"id":207564,"goal":"lemma SetUnionComm_4221(B: set, S: set)\n ensures B + S == S + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_4222","instance":4222,"id":207565,"goal":"lemma SetInterComm_4222(A: set, U: set)\n ensures A * U == U * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_4223","instance":4223,"id":207566,"goal":"lemma SetUnionAssoc_4223(T: set, A: set, U: set)\n ensures (T + A) + U == T + (A + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_4224","instance":4224,"id":207567,"goal":"lemma SetSubsetRefl_4224(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_4225","instance":4225,"id":207568,"goal":"lemma SetSubsetTrans_4225(T: set, S: set, U: set)\n requires T <= S && S <= U\n ensures T <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_4226","instance":4226,"id":207569,"goal":"lemma SetUnionEmpty_4226(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_4227","instance":4227,"id":207570,"goal":"lemma SetInterEmpty_4227(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_4228","instance":4228,"id":207571,"goal":"lemma SetInterSubset_4228(T: set, B: set)\n ensures T * B <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_4229","instance":4229,"id":207572,"goal":"lemma SetCardSubset_4229(S: set, T: set)\n requires S <= T\n ensures |S| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_4230","instance":4230,"id":207573,"goal":"lemma SetUnionCard_4230(A: set, S: set)\n requires A * S == {}\n ensures |A + S| == |A| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_4231","instance":4231,"id":207574,"goal":"lemma SetUnionComm_4231(T: set, A: set)\n ensures T + A == A + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_4232","instance":4232,"id":207575,"goal":"lemma SetInterComm_4232(B: set, S: set)\n ensures B * S == S * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_4233","instance":4233,"id":207576,"goal":"lemma SetUnionAssoc_4233(T: set, B: set, S: set)\n ensures (T + B) + S == T + (B + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_4234","instance":4234,"id":207577,"goal":"lemma SetSubsetRefl_4234(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_4235","instance":4235,"id":207578,"goal":"lemma SetSubsetTrans_4235(S: set, U: set, B: set)\n requires S <= U && U <= B\n ensures S <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_4236","instance":4236,"id":207579,"goal":"lemma SetUnionEmpty_4236(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_4237","instance":4237,"id":207580,"goal":"lemma SetInterEmpty_4237(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_4238","instance":4238,"id":207581,"goal":"lemma SetInterSubset_4238(A: set, U: set)\n ensures A * U <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_4239","instance":4239,"id":207582,"goal":"lemma SetCardSubset_4239(S: set, B: set)\n requires S <= B\n ensures |S| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_4240","instance":4240,"id":207583,"goal":"lemma SetUnionCard_4240(B: set, T: set)\n requires B * T == {}\n ensures |B + T| == |B| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_4241","instance":4241,"id":207584,"goal":"lemma SetUnionComm_4241(A: set, B: set)\n ensures A + B == B + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_4242","instance":4242,"id":207585,"goal":"lemma SetInterComm_4242(U: set, S: set)\n ensures U * S == S * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_4243","instance":4243,"id":207586,"goal":"lemma SetUnionAssoc_4243(T: set, S: set, B: set)\n ensures (T + S) + B == T + (S + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_4244","instance":4244,"id":207587,"goal":"lemma SetSubsetRefl_4244(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_4245","instance":4245,"id":207588,"goal":"lemma SetSubsetTrans_4245(B: set, A: set, T: set)\n requires B <= A && A <= T\n ensures B <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_4246","instance":4246,"id":207589,"goal":"lemma SetUnionEmpty_4246(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_4247","instance":4247,"id":207590,"goal":"lemma SetInterEmpty_4247(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_4248","instance":4248,"id":207591,"goal":"lemma SetInterSubset_4248(S: set, A: set)\n ensures S * A <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_4249","instance":4249,"id":207592,"goal":"lemma SetCardSubset_4249(T: set, S: set)\n requires T <= S\n ensures |T| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_4250","instance":4250,"id":207593,"goal":"lemma SetUnionCard_4250(U: set, S: set)\n requires U * S == {}\n ensures |U + S| == |U| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_4251","instance":4251,"id":207594,"goal":"lemma SetUnionComm_4251(A: set, T: set)\n ensures A + T == T + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_4252","instance":4252,"id":207595,"goal":"lemma SetInterComm_4252(U: set, B: set)\n ensures U * B == B * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_4253","instance":4253,"id":207596,"goal":"lemma SetUnionAssoc_4253(B: set, S: set, U: set)\n ensures (B + S) + U == B + (S + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_4254","instance":4254,"id":207597,"goal":"lemma SetSubsetRefl_4254(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_4255","instance":4255,"id":207598,"goal":"lemma SetSubsetTrans_4255(T: set, B: set, U: set)\n requires T <= B && B <= U\n ensures T <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_4256","instance":4256,"id":207599,"goal":"lemma SetUnionEmpty_4256(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_4257","instance":4257,"id":207600,"goal":"lemma SetInterEmpty_4257(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_4258","instance":4258,"id":207601,"goal":"lemma SetInterSubset_4258(U: set, S: set)\n ensures U * S <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_4259","instance":4259,"id":207602,"goal":"lemma SetCardSubset_4259(T: set, S: set)\n requires T <= S\n ensures |T| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_4260","instance":4260,"id":207603,"goal":"lemma SetUnionCard_4260(T: set, B: set)\n requires T * B == {}\n ensures |T + B| == |T| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_4261","instance":4261,"id":207604,"goal":"lemma SetUnionComm_4261(T: set, A: set)\n ensures T + A == A + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_4262","instance":4262,"id":207605,"goal":"lemma SetInterComm_4262(B: set, A: set)\n ensures B * A == A * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_4263","instance":4263,"id":207606,"goal":"lemma SetUnionAssoc_4263(S: set, A: set, B: set)\n ensures (S + A) + B == S + (A + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_4264","instance":4264,"id":207607,"goal":"lemma SetSubsetRefl_4264(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_4265","instance":4265,"id":207608,"goal":"lemma SetSubsetTrans_4265(U: set, A: set, S: set)\n requires U <= A && A <= S\n ensures U <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_4266","instance":4266,"id":207609,"goal":"lemma SetUnionEmpty_4266(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_4267","instance":4267,"id":207610,"goal":"lemma SetInterEmpty_4267(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_4268","instance":4268,"id":207611,"goal":"lemma SetInterSubset_4268(A: set, S: set)\n ensures A * S <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_4269","instance":4269,"id":207612,"goal":"lemma SetCardSubset_4269(A: set, T: set)\n requires A <= T\n ensures |A| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_4270","instance":4270,"id":207613,"goal":"lemma SetUnionCard_4270(B: set, T: set)\n requires B * T == {}\n ensures |B + T| == |B| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_4271","instance":4271,"id":207614,"goal":"lemma SetUnionComm_4271(T: set, U: set)\n ensures T + U == U + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_4272","instance":4272,"id":207615,"goal":"lemma SetInterComm_4272(S: set, B: set)\n ensures S * B == B * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_4273","instance":4273,"id":207616,"goal":"lemma SetUnionAssoc_4273(U: set, A: set, S: set)\n ensures (U + A) + S == U + (A + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_4274","instance":4274,"id":207617,"goal":"lemma SetSubsetRefl_4274(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_4275","instance":4275,"id":207618,"goal":"lemma SetSubsetTrans_4275(B: set, U: set, T: set)\n requires B <= U && U <= T\n ensures B <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_4276","instance":4276,"id":207619,"goal":"lemma SetUnionEmpty_4276(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_4277","instance":4277,"id":207620,"goal":"lemma SetInterEmpty_4277(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_4278","instance":4278,"id":207621,"goal":"lemma SetInterSubset_4278(T: set, U: set)\n ensures T * U <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_4279","instance":4279,"id":207622,"goal":"lemma SetCardSubset_4279(S: set, A: set)\n requires S <= A\n ensures |S| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_4280","instance":4280,"id":207623,"goal":"lemma SetUnionCard_4280(B: set, T: set)\n requires B * T == {}\n ensures |B + T| == |B| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_4281","instance":4281,"id":207624,"goal":"lemma SetUnionComm_4281(A: set, U: set)\n ensures A + U == U + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_4282","instance":4282,"id":207625,"goal":"lemma SetInterComm_4282(U: set, S: set)\n ensures U * S == S * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_4283","instance":4283,"id":207626,"goal":"lemma SetUnionAssoc_4283(T: set, S: set, A: set)\n ensures (T + S) + A == T + (S + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_4284","instance":4284,"id":207627,"goal":"lemma SetSubsetRefl_4284(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_4285","instance":4285,"id":207628,"goal":"lemma SetSubsetTrans_4285(U: set, B: set, S: set)\n requires U <= B && B <= S\n ensures U <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_4286","instance":4286,"id":207629,"goal":"lemma SetUnionEmpty_4286(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_4287","instance":4287,"id":207630,"goal":"lemma SetInterEmpty_4287(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_4288","instance":4288,"id":207631,"goal":"lemma SetInterSubset_4288(S: set, A: set)\n ensures S * A <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_4289","instance":4289,"id":207632,"goal":"lemma SetCardSubset_4289(T: set, B: set)\n requires T <= B\n ensures |T| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_4290","instance":4290,"id":207633,"goal":"lemma SetUnionCard_4290(U: set, S: set)\n requires U * S == {}\n ensures |U + S| == |U| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_4291","instance":4291,"id":207634,"goal":"lemma SetUnionComm_4291(B: set, T: set)\n ensures B + T == T + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_4292","instance":4292,"id":207635,"goal":"lemma SetInterComm_4292(B: set, T: set)\n ensures B * T == T * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_4293","instance":4293,"id":207636,"goal":"lemma SetUnionAssoc_4293(U: set, A: set, B: set)\n ensures (U + A) + B == U + (A + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_4294","instance":4294,"id":207637,"goal":"lemma SetSubsetRefl_4294(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_4295","instance":4295,"id":207638,"goal":"lemma SetSubsetTrans_4295(S: set, U: set, A: set)\n requires S <= U && U <= A\n ensures S <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_4296","instance":4296,"id":207639,"goal":"lemma SetUnionEmpty_4296(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_4297","instance":4297,"id":207640,"goal":"lemma SetInterEmpty_4297(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_4298","instance":4298,"id":207641,"goal":"lemma SetInterSubset_4298(S: set, B: set)\n ensures S * B <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_4299","instance":4299,"id":207642,"goal":"lemma SetCardSubset_4299(A: set, B: set)\n requires A <= B\n ensures |A| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_4300","instance":4300,"id":207643,"goal":"lemma SetUnionCard_4300(A: set, T: set)\n requires A * T == {}\n ensures |A + T| == |A| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_4301","instance":4301,"id":207644,"goal":"lemma SetUnionComm_4301(U: set, T: set)\n ensures U + T == T + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_4302","instance":4302,"id":207645,"goal":"lemma SetInterComm_4302(A: set, B: set)\n ensures A * B == B * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_4303","instance":4303,"id":207646,"goal":"lemma SetUnionAssoc_4303(A: set, T: set, B: set)\n ensures (A + T) + B == A + (T + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_4304","instance":4304,"id":207647,"goal":"lemma SetSubsetRefl_4304(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_4305","instance":4305,"id":207648,"goal":"lemma SetSubsetTrans_4305(A: set, B: set, T: set)\n requires A <= B && B <= T\n ensures A <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_4306","instance":4306,"id":207649,"goal":"lemma SetUnionEmpty_4306(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_4307","instance":4307,"id":207650,"goal":"lemma SetInterEmpty_4307(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_4308","instance":4308,"id":207651,"goal":"lemma SetInterSubset_4308(A: set, B: set)\n ensures A * B <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_4309","instance":4309,"id":207652,"goal":"lemma SetCardSubset_4309(T: set, S: set)\n requires T <= S\n ensures |T| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_4310","instance":4310,"id":207653,"goal":"lemma SetUnionCard_4310(B: set, U: set)\n requires B * U == {}\n ensures |B + U| == |B| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_4311","instance":4311,"id":207654,"goal":"lemma SetUnionComm_4311(B: set, T: set)\n ensures B + T == T + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_4312","instance":4312,"id":207655,"goal":"lemma SetInterComm_4312(B: set, A: set)\n ensures B * A == A * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_4313","instance":4313,"id":207656,"goal":"lemma SetUnionAssoc_4313(T: set, U: set, S: set)\n ensures (T + U) + S == T + (U + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_4314","instance":4314,"id":207657,"goal":"lemma SetSubsetRefl_4314(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_4315","instance":4315,"id":207658,"goal":"lemma SetSubsetTrans_4315(A: set, T: set, U: set)\n requires A <= T && T <= U\n ensures A <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_4316","instance":4316,"id":207659,"goal":"lemma SetUnionEmpty_4316(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_4317","instance":4317,"id":207660,"goal":"lemma SetInterEmpty_4317(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_4318","instance":4318,"id":207661,"goal":"lemma SetInterSubset_4318(S: set, A: set)\n ensures S * A <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_4319","instance":4319,"id":207662,"goal":"lemma SetCardSubset_4319(T: set, B: set)\n requires T <= B\n ensures |T| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_4320","instance":4320,"id":207663,"goal":"lemma SetUnionCard_4320(S: set, B: set)\n requires S * B == {}\n ensures |S + B| == |S| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_4321","instance":4321,"id":207664,"goal":"lemma SetUnionComm_4321(T: set, B: set)\n ensures T + B == B + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_4322","instance":4322,"id":207665,"goal":"lemma SetInterComm_4322(T: set, U: set)\n ensures T * U == U * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_4323","instance":4323,"id":207666,"goal":"lemma SetUnionAssoc_4323(A: set, B: set, S: set)\n ensures (A + B) + S == A + (B + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_4324","instance":4324,"id":207667,"goal":"lemma SetSubsetRefl_4324(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_4325","instance":4325,"id":207668,"goal":"lemma SetSubsetTrans_4325(T: set, B: set, S: set)\n requires T <= B && B <= S\n ensures T <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_4326","instance":4326,"id":207669,"goal":"lemma SetUnionEmpty_4326(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_4327","instance":4327,"id":207670,"goal":"lemma SetInterEmpty_4327(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_4328","instance":4328,"id":207671,"goal":"lemma SetInterSubset_4328(U: set, T: set)\n ensures U * T <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_4329","instance":4329,"id":207672,"goal":"lemma SetCardSubset_4329(B: set, A: set)\n requires B <= A\n ensures |B| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_4330","instance":4330,"id":207673,"goal":"lemma SetUnionCard_4330(U: set, A: set)\n requires U * A == {}\n ensures |U + A| == |U| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_4331","instance":4331,"id":207674,"goal":"lemma SetUnionComm_4331(B: set, T: set)\n ensures B + T == T + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_4332","instance":4332,"id":207675,"goal":"lemma SetInterComm_4332(B: set, S: set)\n ensures B * S == S * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_4333","instance":4333,"id":207676,"goal":"lemma SetUnionAssoc_4333(A: set, T: set, S: set)\n ensures (A + T) + S == A + (T + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_4334","instance":4334,"id":207677,"goal":"lemma SetSubsetRefl_4334(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_4335","instance":4335,"id":207678,"goal":"lemma SetSubsetTrans_4335(T: set, A: set, U: set)\n requires T <= A && A <= U\n ensures T <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_4336","instance":4336,"id":207679,"goal":"lemma SetUnionEmpty_4336(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_4337","instance":4337,"id":207680,"goal":"lemma SetInterEmpty_4337(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_4338","instance":4338,"id":207681,"goal":"lemma SetInterSubset_4338(B: set, T: set)\n ensures B * T <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_4339","instance":4339,"id":207682,"goal":"lemma SetCardSubset_4339(B: set, U: set)\n requires B <= U\n ensures |B| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_4340","instance":4340,"id":207683,"goal":"lemma SetUnionCard_4340(B: set, A: set)\n requires B * A == {}\n ensures |B + A| == |B| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_4341","instance":4341,"id":207684,"goal":"lemma SetUnionComm_4341(B: set, U: set)\n ensures B + U == U + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_4342","instance":4342,"id":207685,"goal":"lemma SetInterComm_4342(U: set, S: set)\n ensures U * S == S * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_4343","instance":4343,"id":207686,"goal":"lemma SetUnionAssoc_4343(A: set, T: set, S: set)\n ensures (A + T) + S == A + (T + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_4344","instance":4344,"id":207687,"goal":"lemma SetSubsetRefl_4344(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_4345","instance":4345,"id":207688,"goal":"lemma SetSubsetTrans_4345(B: set, S: set, T: set)\n requires B <= S && S <= T\n ensures B <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_4346","instance":4346,"id":207689,"goal":"lemma SetUnionEmpty_4346(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_4347","instance":4347,"id":207690,"goal":"lemma SetInterEmpty_4347(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_4348","instance":4348,"id":207691,"goal":"lemma SetInterSubset_4348(T: set, B: set)\n ensures T * B <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_4349","instance":4349,"id":207692,"goal":"lemma SetCardSubset_4349(A: set, T: set)\n requires A <= T\n ensures |A| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_4350","instance":4350,"id":207693,"goal":"lemma SetUnionCard_4350(A: set, T: set)\n requires A * T == {}\n ensures |A + T| == |A| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_4351","instance":4351,"id":207694,"goal":"lemma SetUnionComm_4351(B: set, S: set)\n ensures B + S == S + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_4352","instance":4352,"id":207695,"goal":"lemma SetInterComm_4352(S: set, B: set)\n ensures S * B == B * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_4353","instance":4353,"id":207696,"goal":"lemma SetUnionAssoc_4353(U: set, A: set, T: set)\n ensures (U + A) + T == U + (A + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_4354","instance":4354,"id":207697,"goal":"lemma SetSubsetRefl_4354(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_4355","instance":4355,"id":207698,"goal":"lemma SetSubsetTrans_4355(A: set, S: set, T: set)\n requires A <= S && S <= T\n ensures A <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_4356","instance":4356,"id":207699,"goal":"lemma SetUnionEmpty_4356(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_4357","instance":4357,"id":207700,"goal":"lemma SetInterEmpty_4357(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_4358","instance":4358,"id":207701,"goal":"lemma SetInterSubset_4358(A: set, B: set)\n ensures A * B <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_4359","instance":4359,"id":207702,"goal":"lemma SetCardSubset_4359(T: set, U: set)\n requires T <= U\n ensures |T| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_4360","instance":4360,"id":207703,"goal":"lemma SetUnionCard_4360(S: set, A: set)\n requires S * A == {}\n ensures |S + A| == |S| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_4361","instance":4361,"id":207704,"goal":"lemma SetUnionComm_4361(B: set, A: set)\n ensures B + A == A + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_4362","instance":4362,"id":207705,"goal":"lemma SetInterComm_4362(S: set, T: set)\n ensures S * T == T * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_4363","instance":4363,"id":207706,"goal":"lemma SetUnionAssoc_4363(A: set, B: set, T: set)\n ensures (A + B) + T == A + (B + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_4364","instance":4364,"id":207707,"goal":"lemma SetSubsetRefl_4364(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_4365","instance":4365,"id":207708,"goal":"lemma SetSubsetTrans_4365(B: set, S: set, A: set)\n requires B <= S && S <= A\n ensures B <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_4366","instance":4366,"id":207709,"goal":"lemma SetUnionEmpty_4366(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_4367","instance":4367,"id":207710,"goal":"lemma SetInterEmpty_4367(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_4368","instance":4368,"id":207711,"goal":"lemma SetInterSubset_4368(A: set, S: set)\n ensures A * S <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_4369","instance":4369,"id":207712,"goal":"lemma SetCardSubset_4369(U: set, B: set)\n requires U <= B\n ensures |U| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_4370","instance":4370,"id":207713,"goal":"lemma SetUnionCard_4370(T: set, B: set)\n requires T * B == {}\n ensures |T + B| == |T| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_4371","instance":4371,"id":207714,"goal":"lemma SetUnionComm_4371(A: set, U: set)\n ensures A + U == U + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_4372","instance":4372,"id":207715,"goal":"lemma SetInterComm_4372(S: set, A: set)\n ensures S * A == A * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_4373","instance":4373,"id":207716,"goal":"lemma SetUnionAssoc_4373(A: set, T: set, B: set)\n ensures (A + T) + B == A + (T + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_4374","instance":4374,"id":207717,"goal":"lemma SetSubsetRefl_4374(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_4375","instance":4375,"id":207718,"goal":"lemma SetSubsetTrans_4375(T: set, A: set, B: set)\n requires T <= A && A <= B\n ensures T <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_4376","instance":4376,"id":207719,"goal":"lemma SetUnionEmpty_4376(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_4377","instance":4377,"id":207720,"goal":"lemma SetInterEmpty_4377(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_4378","instance":4378,"id":207721,"goal":"lemma SetInterSubset_4378(A: set, U: set)\n ensures A * U <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_4379","instance":4379,"id":207722,"goal":"lemma SetCardSubset_4379(S: set, A: set)\n requires S <= A\n ensures |S| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_4380","instance":4380,"id":207723,"goal":"lemma SetUnionCard_4380(S: set, A: set)\n requires S * A == {}\n ensures |S + A| == |S| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_4381","instance":4381,"id":207724,"goal":"lemma SetUnionComm_4381(U: set, A: set)\n ensures U + A == A + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_4382","instance":4382,"id":207725,"goal":"lemma SetInterComm_4382(S: set, A: set)\n ensures S * A == A * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_4383","instance":4383,"id":207726,"goal":"lemma SetUnionAssoc_4383(T: set, A: set, B: set)\n ensures (T + A) + B == T + (A + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_4384","instance":4384,"id":207727,"goal":"lemma SetSubsetRefl_4384(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_4385","instance":4385,"id":207728,"goal":"lemma SetSubsetTrans_4385(S: set, U: set, A: set)\n requires S <= U && U <= A\n ensures S <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_4386","instance":4386,"id":207729,"goal":"lemma SetUnionEmpty_4386(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_4387","instance":4387,"id":207730,"goal":"lemma SetInterEmpty_4387(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_4388","instance":4388,"id":207731,"goal":"lemma SetInterSubset_4388(S: set, U: set)\n ensures S * U <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_4389","instance":4389,"id":207732,"goal":"lemma SetCardSubset_4389(S: set, U: set)\n requires S <= U\n ensures |S| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_4390","instance":4390,"id":207733,"goal":"lemma SetUnionCard_4390(A: set, B: set)\n requires A * B == {}\n ensures |A + B| == |A| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_4391","instance":4391,"id":207734,"goal":"lemma SetUnionComm_4391(B: set, U: set)\n ensures B + U == U + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_4392","instance":4392,"id":207735,"goal":"lemma SetInterComm_4392(B: set, A: set)\n ensures B * A == A * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_4393","instance":4393,"id":207736,"goal":"lemma SetUnionAssoc_4393(U: set, A: set, B: set)\n ensures (U + A) + B == U + (A + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_4394","instance":4394,"id":207737,"goal":"lemma SetSubsetRefl_4394(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_4395","instance":4395,"id":207738,"goal":"lemma SetSubsetTrans_4395(T: set, A: set, S: set)\n requires T <= A && A <= S\n ensures T <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_4396","instance":4396,"id":207739,"goal":"lemma SetUnionEmpty_4396(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_4397","instance":4397,"id":207740,"goal":"lemma SetInterEmpty_4397(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_4398","instance":4398,"id":207741,"goal":"lemma SetInterSubset_4398(U: set, T: set)\n ensures U * T <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_4399","instance":4399,"id":207742,"goal":"lemma SetCardSubset_4399(T: set, A: set)\n requires T <= A\n ensures |T| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_4400","instance":4400,"id":207743,"goal":"lemma SetUnionCard_4400(S: set, A: set)\n requires S * A == {}\n ensures |S + A| == |S| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_4401","instance":4401,"id":207744,"goal":"lemma SetUnionComm_4401(A: set, T: set)\n ensures A + T == T + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_4402","instance":4402,"id":207745,"goal":"lemma SetInterComm_4402(S: set, B: set)\n ensures S * B == B * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_4403","instance":4403,"id":207746,"goal":"lemma SetUnionAssoc_4403(S: set, B: set, A: set)\n ensures (S + B) + A == S + (B + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_4404","instance":4404,"id":207747,"goal":"lemma SetSubsetRefl_4404(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_4405","instance":4405,"id":207748,"goal":"lemma SetSubsetTrans_4405(U: set, S: set, B: set)\n requires U <= S && S <= B\n ensures U <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_4406","instance":4406,"id":207749,"goal":"lemma SetUnionEmpty_4406(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_4407","instance":4407,"id":207750,"goal":"lemma SetInterEmpty_4407(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_4408","instance":4408,"id":207751,"goal":"lemma SetInterSubset_4408(A: set, S: set)\n ensures A * S <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_4409","instance":4409,"id":207752,"goal":"lemma SetCardSubset_4409(A: set, U: set)\n requires A <= U\n ensures |A| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_4410","instance":4410,"id":207753,"goal":"lemma SetUnionCard_4410(B: set, U: set)\n requires B * U == {}\n ensures |B + U| == |B| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_4411","instance":4411,"id":207754,"goal":"lemma SetUnionComm_4411(T: set, S: set)\n ensures T + S == S + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_4412","instance":4412,"id":207755,"goal":"lemma SetInterComm_4412(U: set, B: set)\n ensures U * B == B * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_4413","instance":4413,"id":207756,"goal":"lemma SetUnionAssoc_4413(S: set, B: set, A: set)\n ensures (S + B) + A == S + (B + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_4414","instance":4414,"id":207757,"goal":"lemma SetSubsetRefl_4414(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_4415","instance":4415,"id":207758,"goal":"lemma SetSubsetTrans_4415(U: set, T: set, A: set)\n requires U <= T && T <= A\n ensures U <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_4416","instance":4416,"id":207759,"goal":"lemma SetUnionEmpty_4416(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_4417","instance":4417,"id":207760,"goal":"lemma SetInterEmpty_4417(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_4418","instance":4418,"id":207761,"goal":"lemma SetInterSubset_4418(A: set, B: set)\n ensures A * B <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_4419","instance":4419,"id":207762,"goal":"lemma SetCardSubset_4419(S: set, U: set)\n requires S <= U\n ensures |S| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_4420","instance":4420,"id":207763,"goal":"lemma SetUnionCard_4420(T: set, S: set)\n requires T * S == {}\n ensures |T + S| == |T| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_4421","instance":4421,"id":207764,"goal":"lemma SetUnionComm_4421(A: set, U: set)\n ensures A + U == U + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_4422","instance":4422,"id":207765,"goal":"lemma SetInterComm_4422(U: set, B: set)\n ensures U * B == B * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_4423","instance":4423,"id":207766,"goal":"lemma SetUnionAssoc_4423(B: set, S: set, A: set)\n ensures (B + S) + A == B + (S + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_4424","instance":4424,"id":207767,"goal":"lemma SetSubsetRefl_4424(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_4425","instance":4425,"id":207768,"goal":"lemma SetSubsetTrans_4425(S: set, U: set, B: set)\n requires S <= U && U <= B\n ensures S <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_4426","instance":4426,"id":207769,"goal":"lemma SetUnionEmpty_4426(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_4427","instance":4427,"id":207770,"goal":"lemma SetInterEmpty_4427(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_4428","instance":4428,"id":207771,"goal":"lemma SetInterSubset_4428(S: set, B: set)\n ensures S * B <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_4429","instance":4429,"id":207772,"goal":"lemma SetCardSubset_4429(T: set, U: set)\n requires T <= U\n ensures |T| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_4430","instance":4430,"id":207773,"goal":"lemma SetUnionCard_4430(A: set, B: set)\n requires A * B == {}\n ensures |A + B| == |A| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_4431","instance":4431,"id":207774,"goal":"lemma SetUnionComm_4431(U: set, T: set)\n ensures U + T == T + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_4432","instance":4432,"id":207775,"goal":"lemma SetInterComm_4432(U: set, B: set)\n ensures U * B == B * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_4433","instance":4433,"id":207776,"goal":"lemma SetUnionAssoc_4433(T: set, B: set, U: set)\n ensures (T + B) + U == T + (B + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_4434","instance":4434,"id":207777,"goal":"lemma SetSubsetRefl_4434(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_4435","instance":4435,"id":207778,"goal":"lemma SetSubsetTrans_4435(A: set, B: set, T: set)\n requires A <= B && B <= T\n ensures A <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_4436","instance":4436,"id":207779,"goal":"lemma SetUnionEmpty_4436(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_4437","instance":4437,"id":207780,"goal":"lemma SetInterEmpty_4437(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_4438","instance":4438,"id":207781,"goal":"lemma SetInterSubset_4438(U: set, A: set)\n ensures U * A <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_4439","instance":4439,"id":207782,"goal":"lemma SetCardSubset_4439(S: set, A: set)\n requires S <= A\n ensures |S| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_4440","instance":4440,"id":207783,"goal":"lemma SetUnionCard_4440(U: set, B: set)\n requires U * B == {}\n ensures |U + B| == |U| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_4441","instance":4441,"id":207784,"goal":"lemma SetUnionComm_4441(S: set, B: set)\n ensures S + B == B + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_4442","instance":4442,"id":207785,"goal":"lemma SetInterComm_4442(B: set, S: set)\n ensures B * S == S * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_4443","instance":4443,"id":207786,"goal":"lemma SetUnionAssoc_4443(T: set, S: set, B: set)\n ensures (T + S) + B == T + (S + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_4444","instance":4444,"id":207787,"goal":"lemma SetSubsetRefl_4444(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_4445","instance":4445,"id":207788,"goal":"lemma SetSubsetTrans_4445(B: set, T: set, U: set)\n requires B <= T && T <= U\n ensures B <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_4446","instance":4446,"id":207789,"goal":"lemma SetUnionEmpty_4446(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_4447","instance":4447,"id":207790,"goal":"lemma SetInterEmpty_4447(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_4448","instance":4448,"id":207791,"goal":"lemma SetInterSubset_4448(B: set, U: set)\n ensures B * U <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_4449","instance":4449,"id":207792,"goal":"lemma SetCardSubset_4449(B: set, S: set)\n requires B <= S\n ensures |B| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_4450","instance":4450,"id":207793,"goal":"lemma SetUnionCard_4450(U: set, S: set)\n requires U * S == {}\n ensures |U + S| == |U| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_4451","instance":4451,"id":207794,"goal":"lemma SetUnionComm_4451(S: set, B: set)\n ensures S + B == B + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_4452","instance":4452,"id":207795,"goal":"lemma SetInterComm_4452(B: set, T: set)\n ensures B * T == T * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_4453","instance":4453,"id":207796,"goal":"lemma SetUnionAssoc_4453(B: set, S: set, U: set)\n ensures (B + S) + U == B + (S + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_4454","instance":4454,"id":207797,"goal":"lemma SetSubsetRefl_4454(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_4455","instance":4455,"id":207798,"goal":"lemma SetSubsetTrans_4455(T: set, U: set, S: set)\n requires T <= U && U <= S\n ensures T <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_4456","instance":4456,"id":207799,"goal":"lemma SetUnionEmpty_4456(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_4457","instance":4457,"id":207800,"goal":"lemma SetInterEmpty_4457(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_4458","instance":4458,"id":207801,"goal":"lemma SetInterSubset_4458(A: set, B: set)\n ensures A * B <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_4459","instance":4459,"id":207802,"goal":"lemma SetCardSubset_4459(A: set, S: set)\n requires A <= S\n ensures |A| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_4460","instance":4460,"id":207803,"goal":"lemma SetUnionCard_4460(S: set, U: set)\n requires S * U == {}\n ensures |S + U| == |S| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_4461","instance":4461,"id":207804,"goal":"lemma SetUnionComm_4461(S: set, A: set)\n ensures S + A == A + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_4462","instance":4462,"id":207805,"goal":"lemma SetInterComm_4462(A: set, T: set)\n ensures A * T == T * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_4463","instance":4463,"id":207806,"goal":"lemma SetUnionAssoc_4463(A: set, T: set, B: set)\n ensures (A + T) + B == A + (T + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_4464","instance":4464,"id":207807,"goal":"lemma SetSubsetRefl_4464(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_4465","instance":4465,"id":207808,"goal":"lemma SetSubsetTrans_4465(S: set, U: set, T: set)\n requires S <= U && U <= T\n ensures S <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_4466","instance":4466,"id":207809,"goal":"lemma SetUnionEmpty_4466(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_4467","instance":4467,"id":207810,"goal":"lemma SetInterEmpty_4467(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_4468","instance":4468,"id":207811,"goal":"lemma SetInterSubset_4468(U: set, B: set)\n ensures U * B <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_4469","instance":4469,"id":207812,"goal":"lemma SetCardSubset_4469(S: set, A: set)\n requires S <= A\n ensures |S| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_4470","instance":4470,"id":207813,"goal":"lemma SetUnionCard_4470(T: set, A: set)\n requires T * A == {}\n ensures |T + A| == |T| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_4471","instance":4471,"id":207814,"goal":"lemma SetUnionComm_4471(T: set, S: set)\n ensures T + S == S + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_4472","instance":4472,"id":207815,"goal":"lemma SetInterComm_4472(T: set, B: set)\n ensures T * B == B * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_4473","instance":4473,"id":207816,"goal":"lemma SetUnionAssoc_4473(S: set, U: set, B: set)\n ensures (S + U) + B == S + (U + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_4474","instance":4474,"id":207817,"goal":"lemma SetSubsetRefl_4474(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_4475","instance":4475,"id":207818,"goal":"lemma SetSubsetTrans_4475(A: set, U: set, T: set)\n requires A <= U && U <= T\n ensures A <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_4476","instance":4476,"id":207819,"goal":"lemma SetUnionEmpty_4476(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_4477","instance":4477,"id":207820,"goal":"lemma SetInterEmpty_4477(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_4478","instance":4478,"id":207821,"goal":"lemma SetInterSubset_4478(B: set, T: set)\n ensures B * T <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_4479","instance":4479,"id":207822,"goal":"lemma SetCardSubset_4479(A: set, B: set)\n requires A <= B\n ensures |A| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_4480","instance":4480,"id":207823,"goal":"lemma SetUnionCard_4480(S: set, U: set)\n requires S * U == {}\n ensures |S + U| == |S| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_4481","instance":4481,"id":207824,"goal":"lemma SetUnionComm_4481(B: set, T: set)\n ensures B + T == T + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_4482","instance":4482,"id":207825,"goal":"lemma SetInterComm_4482(S: set, B: set)\n ensures S * B == B * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_4483","instance":4483,"id":207826,"goal":"lemma SetUnionAssoc_4483(U: set, B: set, S: set)\n ensures (U + B) + S == U + (B + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_4484","instance":4484,"id":207827,"goal":"lemma SetSubsetRefl_4484(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_4485","instance":4485,"id":207828,"goal":"lemma SetSubsetTrans_4485(S: set, U: set, B: set)\n requires S <= U && U <= B\n ensures S <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_4486","instance":4486,"id":207829,"goal":"lemma SetUnionEmpty_4486(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_4487","instance":4487,"id":207830,"goal":"lemma SetInterEmpty_4487(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_4488","instance":4488,"id":207831,"goal":"lemma SetInterSubset_4488(U: set, S: set)\n ensures U * S <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_4489","instance":4489,"id":207832,"goal":"lemma SetCardSubset_4489(B: set, T: set)\n requires B <= T\n ensures |B| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_4490","instance":4490,"id":207833,"goal":"lemma SetUnionCard_4490(A: set, B: set)\n requires A * B == {}\n ensures |A + B| == |A| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_4491","instance":4491,"id":207834,"goal":"lemma SetUnionComm_4491(A: set, T: set)\n ensures A + T == T + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_4492","instance":4492,"id":207835,"goal":"lemma SetInterComm_4492(T: set, S: set)\n ensures T * S == S * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_4493","instance":4493,"id":207836,"goal":"lemma SetUnionAssoc_4493(T: set, A: set, B: set)\n ensures (T + A) + B == T + (A + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_4494","instance":4494,"id":207837,"goal":"lemma SetSubsetRefl_4494(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_4495","instance":4495,"id":207838,"goal":"lemma SetSubsetTrans_4495(B: set, A: set, T: set)\n requires B <= A && A <= T\n ensures B <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_4496","instance":4496,"id":207839,"goal":"lemma SetUnionEmpty_4496(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_4497","instance":4497,"id":207840,"goal":"lemma SetInterEmpty_4497(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_4498","instance":4498,"id":207841,"goal":"lemma SetInterSubset_4498(T: set, U: set)\n ensures T * U <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_4499","instance":4499,"id":207842,"goal":"lemma SetCardSubset_4499(B: set, A: set)\n requires B <= A\n ensures |B| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_4500","instance":4500,"id":207843,"goal":"lemma SetUnionCard_4500(B: set, T: set)\n requires B * T == {}\n ensures |B + T| == |B| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_4501","instance":4501,"id":207844,"goal":"lemma SetUnionComm_4501(B: set, T: set)\n ensures B + T == T + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_4502","instance":4502,"id":207845,"goal":"lemma SetInterComm_4502(A: set, T: set)\n ensures A * T == T * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_4503","instance":4503,"id":207846,"goal":"lemma SetUnionAssoc_4503(T: set, S: set, U: set)\n ensures (T + S) + U == T + (S + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_4504","instance":4504,"id":207847,"goal":"lemma SetSubsetRefl_4504(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_4505","instance":4505,"id":207848,"goal":"lemma SetSubsetTrans_4505(U: set, B: set, A: set)\n requires U <= B && B <= A\n ensures U <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_4506","instance":4506,"id":207849,"goal":"lemma SetUnionEmpty_4506(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_4507","instance":4507,"id":207850,"goal":"lemma SetInterEmpty_4507(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_4508","instance":4508,"id":207851,"goal":"lemma SetInterSubset_4508(S: set, U: set)\n ensures S * U <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_4509","instance":4509,"id":207852,"goal":"lemma SetCardSubset_4509(U: set, A: set)\n requires U <= A\n ensures |U| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_4510","instance":4510,"id":207853,"goal":"lemma SetUnionCard_4510(S: set, U: set)\n requires S * U == {}\n ensures |S + U| == |S| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_4511","instance":4511,"id":207854,"goal":"lemma SetUnionComm_4511(B: set, S: set)\n ensures B + S == S + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_4512","instance":4512,"id":207855,"goal":"lemma SetInterComm_4512(S: set, B: set)\n ensures S * B == B * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_4513","instance":4513,"id":207856,"goal":"lemma SetUnionAssoc_4513(A: set, S: set, B: set)\n ensures (A + S) + B == A + (S + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_4514","instance":4514,"id":207857,"goal":"lemma SetSubsetRefl_4514(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_4515","instance":4515,"id":207858,"goal":"lemma SetSubsetTrans_4515(A: set, B: set, T: set)\n requires A <= B && B <= T\n ensures A <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_4516","instance":4516,"id":207859,"goal":"lemma SetUnionEmpty_4516(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_4517","instance":4517,"id":207860,"goal":"lemma SetInterEmpty_4517(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_4518","instance":4518,"id":207861,"goal":"lemma SetInterSubset_4518(U: set, B: set)\n ensures U * B <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_4519","instance":4519,"id":207862,"goal":"lemma SetCardSubset_4519(B: set, S: set)\n requires B <= S\n ensures |B| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_4520","instance":4520,"id":207863,"goal":"lemma SetUnionCard_4520(B: set, U: set)\n requires B * U == {}\n ensures |B + U| == |B| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_4521","instance":4521,"id":207864,"goal":"lemma SetUnionComm_4521(B: set, A: set)\n ensures B + A == A + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_4522","instance":4522,"id":207865,"goal":"lemma SetInterComm_4522(U: set, T: set)\n ensures U * T == T * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_4523","instance":4523,"id":207866,"goal":"lemma SetUnionAssoc_4523(S: set, A: set, T: set)\n ensures (S + A) + T == S + (A + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_4524","instance":4524,"id":207867,"goal":"lemma SetSubsetRefl_4524(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_4525","instance":4525,"id":207868,"goal":"lemma SetSubsetTrans_4525(B: set, U: set, A: set)\n requires B <= U && U <= A\n ensures B <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_4526","instance":4526,"id":207869,"goal":"lemma SetUnionEmpty_4526(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_4527","instance":4527,"id":207870,"goal":"lemma SetInterEmpty_4527(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_4528","instance":4528,"id":207871,"goal":"lemma SetInterSubset_4528(U: set, A: set)\n ensures U * A <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_4529","instance":4529,"id":207872,"goal":"lemma SetCardSubset_4529(S: set, U: set)\n requires S <= U\n ensures |S| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_4530","instance":4530,"id":207873,"goal":"lemma SetUnionCard_4530(A: set, B: set)\n requires A * B == {}\n ensures |A + B| == |A| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_4531","instance":4531,"id":207874,"goal":"lemma SetUnionComm_4531(S: set, B: set)\n ensures S + B == B + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_4532","instance":4532,"id":207875,"goal":"lemma SetInterComm_4532(A: set, B: set)\n ensures A * B == B * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_4533","instance":4533,"id":207876,"goal":"lemma SetUnionAssoc_4533(T: set, S: set, A: set)\n ensures (T + S) + A == T + (S + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_4534","instance":4534,"id":207877,"goal":"lemma SetSubsetRefl_4534(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_4535","instance":4535,"id":207878,"goal":"lemma SetSubsetTrans_4535(A: set, B: set, T: set)\n requires A <= B && B <= T\n ensures A <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_4536","instance":4536,"id":207879,"goal":"lemma SetUnionEmpty_4536(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_4537","instance":4537,"id":207880,"goal":"lemma SetInterEmpty_4537(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_4538","instance":4538,"id":207881,"goal":"lemma SetInterSubset_4538(T: set, S: set)\n ensures T * S <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_4539","instance":4539,"id":207882,"goal":"lemma SetCardSubset_4539(T: set, U: set)\n requires T <= U\n ensures |T| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_4540","instance":4540,"id":207883,"goal":"lemma SetUnionCard_4540(S: set, B: set)\n requires S * B == {}\n ensures |S + B| == |S| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_4541","instance":4541,"id":207884,"goal":"lemma SetUnionComm_4541(B: set, U: set)\n ensures B + U == U + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_4542","instance":4542,"id":207885,"goal":"lemma SetInterComm_4542(S: set, U: set)\n ensures S * U == U * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_4543","instance":4543,"id":207886,"goal":"lemma SetUnionAssoc_4543(U: set, A: set, S: set)\n ensures (U + A) + S == U + (A + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_4544","instance":4544,"id":207887,"goal":"lemma SetSubsetRefl_4544(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_4545","instance":4545,"id":207888,"goal":"lemma SetSubsetTrans_4545(U: set, B: set, A: set)\n requires U <= B && B <= A\n ensures U <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_4546","instance":4546,"id":207889,"goal":"lemma SetUnionEmpty_4546(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_4547","instance":4547,"id":207890,"goal":"lemma SetInterEmpty_4547(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_4548","instance":4548,"id":207891,"goal":"lemma SetInterSubset_4548(T: set, S: set)\n ensures T * S <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_4549","instance":4549,"id":207892,"goal":"lemma SetCardSubset_4549(S: set, B: set)\n requires S <= B\n ensures |S| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_4550","instance":4550,"id":207893,"goal":"lemma SetUnionCard_4550(T: set, S: set)\n requires T * S == {}\n ensures |T + S| == |T| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_4551","instance":4551,"id":207894,"goal":"lemma SetUnionComm_4551(U: set, S: set)\n ensures U + S == S + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_4552","instance":4552,"id":207895,"goal":"lemma SetInterComm_4552(B: set, U: set)\n ensures B * U == U * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_4553","instance":4553,"id":207896,"goal":"lemma SetUnionAssoc_4553(A: set, B: set, U: set)\n ensures (A + B) + U == A + (B + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_4554","instance":4554,"id":207897,"goal":"lemma SetSubsetRefl_4554(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_4555","instance":4555,"id":207898,"goal":"lemma SetSubsetTrans_4555(T: set, A: set, U: set)\n requires T <= A && A <= U\n ensures T <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_4556","instance":4556,"id":207899,"goal":"lemma SetUnionEmpty_4556(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_4557","instance":4557,"id":207900,"goal":"lemma SetInterEmpty_4557(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_4558","instance":4558,"id":207901,"goal":"lemma SetInterSubset_4558(T: set, B: set)\n ensures T * B <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_4559","instance":4559,"id":207902,"goal":"lemma SetCardSubset_4559(B: set, S: set)\n requires B <= S\n ensures |B| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_4560","instance":4560,"id":207903,"goal":"lemma SetUnionCard_4560(A: set, B: set)\n requires A * B == {}\n ensures |A + B| == |A| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_4561","instance":4561,"id":207904,"goal":"lemma SetUnionComm_4561(T: set, U: set)\n ensures T + U == U + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_4562","instance":4562,"id":207905,"goal":"lemma SetInterComm_4562(S: set, T: set)\n ensures S * T == T * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_4563","instance":4563,"id":207906,"goal":"lemma SetUnionAssoc_4563(S: set, U: set, A: set)\n ensures (S + U) + A == S + (U + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_4564","instance":4564,"id":207907,"goal":"lemma SetSubsetRefl_4564(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_4565","instance":4565,"id":207908,"goal":"lemma SetSubsetTrans_4565(T: set, U: set, S: set)\n requires T <= U && U <= S\n ensures T <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_4566","instance":4566,"id":207909,"goal":"lemma SetUnionEmpty_4566(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_4567","instance":4567,"id":207910,"goal":"lemma SetInterEmpty_4567(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_4568","instance":4568,"id":207911,"goal":"lemma SetInterSubset_4568(U: set, S: set)\n ensures U * S <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_4569","instance":4569,"id":207912,"goal":"lemma SetCardSubset_4569(S: set, U: set)\n requires S <= U\n ensures |S| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_4570","instance":4570,"id":207913,"goal":"lemma SetUnionCard_4570(U: set, T: set)\n requires U * T == {}\n ensures |U + T| == |U| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_4571","instance":4571,"id":207914,"goal":"lemma SetUnionComm_4571(S: set, B: set)\n ensures S + B == B + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_4572","instance":4572,"id":207915,"goal":"lemma SetInterComm_4572(A: set, U: set)\n ensures A * U == U * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_4573","instance":4573,"id":207916,"goal":"lemma SetUnionAssoc_4573(B: set, S: set, A: set)\n ensures (B + S) + A == B + (S + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_4574","instance":4574,"id":207917,"goal":"lemma SetSubsetRefl_4574(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_4575","instance":4575,"id":207918,"goal":"lemma SetSubsetTrans_4575(B: set, S: set, U: set)\n requires B <= S && S <= U\n ensures B <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_4576","instance":4576,"id":207919,"goal":"lemma SetUnionEmpty_4576(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_4577","instance":4577,"id":207920,"goal":"lemma SetInterEmpty_4577(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_4578","instance":4578,"id":207921,"goal":"lemma SetInterSubset_4578(T: set, S: set)\n ensures T * S <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_4579","instance":4579,"id":207922,"goal":"lemma SetCardSubset_4579(A: set, T: set)\n requires A <= T\n ensures |A| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_4580","instance":4580,"id":207923,"goal":"lemma SetUnionCard_4580(B: set, A: set)\n requires B * A == {}\n ensures |B + A| == |B| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_4581","instance":4581,"id":207924,"goal":"lemma SetUnionComm_4581(U: set, A: set)\n ensures U + A == A + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_4582","instance":4582,"id":207925,"goal":"lemma SetInterComm_4582(S: set, T: set)\n ensures S * T == T * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_4583","instance":4583,"id":207926,"goal":"lemma SetUnionAssoc_4583(T: set, U: set, A: set)\n ensures (T + U) + A == T + (U + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_4584","instance":4584,"id":207927,"goal":"lemma SetSubsetRefl_4584(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_4585","instance":4585,"id":207928,"goal":"lemma SetSubsetTrans_4585(U: set, T: set, B: set)\n requires U <= T && T <= B\n ensures U <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_4586","instance":4586,"id":207929,"goal":"lemma SetUnionEmpty_4586(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_4587","instance":4587,"id":207930,"goal":"lemma SetInterEmpty_4587(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_4588","instance":4588,"id":207931,"goal":"lemma SetInterSubset_4588(T: set, B: set)\n ensures T * B <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_4589","instance":4589,"id":207932,"goal":"lemma SetCardSubset_4589(U: set, T: set)\n requires U <= T\n ensures |U| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_4590","instance":4590,"id":207933,"goal":"lemma SetUnionCard_4590(S: set, U: set)\n requires S * U == {}\n ensures |S + U| == |S| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_4591","instance":4591,"id":207934,"goal":"lemma SetUnionComm_4591(B: set, A: set)\n ensures B + A == A + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_4592","instance":4592,"id":207935,"goal":"lemma SetInterComm_4592(T: set, U: set)\n ensures T * U == U * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_4593","instance":4593,"id":207936,"goal":"lemma SetUnionAssoc_4593(T: set, B: set, A: set)\n ensures (T + B) + A == T + (B + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_4594","instance":4594,"id":207937,"goal":"lemma SetSubsetRefl_4594(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_4595","instance":4595,"id":207938,"goal":"lemma SetSubsetTrans_4595(S: set, U: set, B: set)\n requires S <= U && U <= B\n ensures S <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_4596","instance":4596,"id":207939,"goal":"lemma SetUnionEmpty_4596(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_4597","instance":4597,"id":207940,"goal":"lemma SetInterEmpty_4597(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_4598","instance":4598,"id":207941,"goal":"lemma SetInterSubset_4598(A: set, T: set)\n ensures A * T <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_4599","instance":4599,"id":207942,"goal":"lemma SetCardSubset_4599(B: set, T: set)\n requires B <= T\n ensures |B| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_4600","instance":4600,"id":207943,"goal":"lemma SetUnionCard_4600(A: set, T: set)\n requires A * T == {}\n ensures |A + T| == |A| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_4601","instance":4601,"id":207944,"goal":"lemma SetUnionComm_4601(B: set, A: set)\n ensures B + A == A + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_4602","instance":4602,"id":207945,"goal":"lemma SetInterComm_4602(U: set, A: set)\n ensures U * A == A * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_4603","instance":4603,"id":207946,"goal":"lemma SetUnionAssoc_4603(A: set, T: set, B: set)\n ensures (A + T) + B == A + (T + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_4604","instance":4604,"id":207947,"goal":"lemma SetSubsetRefl_4604(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_4605","instance":4605,"id":207948,"goal":"lemma SetSubsetTrans_4605(A: set, U: set, S: set)\n requires A <= U && U <= S\n ensures A <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_4606","instance":4606,"id":207949,"goal":"lemma SetUnionEmpty_4606(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_4607","instance":4607,"id":207950,"goal":"lemma SetInterEmpty_4607(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_4608","instance":4608,"id":207951,"goal":"lemma SetInterSubset_4608(A: set, S: set)\n ensures A * S <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_4609","instance":4609,"id":207952,"goal":"lemma SetCardSubset_4609(T: set, S: set)\n requires T <= S\n ensures |T| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_4610","instance":4610,"id":207953,"goal":"lemma SetUnionCard_4610(B: set, T: set)\n requires B * T == {}\n ensures |B + T| == |B| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_4611","instance":4611,"id":207954,"goal":"lemma SetUnionComm_4611(T: set, A: set)\n ensures T + A == A + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_4612","instance":4612,"id":207955,"goal":"lemma SetInterComm_4612(A: set, S: set)\n ensures A * S == S * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_4613","instance":4613,"id":207956,"goal":"lemma SetUnionAssoc_4613(T: set, U: set, S: set)\n ensures (T + U) + S == T + (U + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_4614","instance":4614,"id":207957,"goal":"lemma SetSubsetRefl_4614(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_4615","instance":4615,"id":207958,"goal":"lemma SetSubsetTrans_4615(S: set, A: set, B: set)\n requires S <= A && A <= B\n ensures S <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_4616","instance":4616,"id":207959,"goal":"lemma SetUnionEmpty_4616(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_4617","instance":4617,"id":207960,"goal":"lemma SetInterEmpty_4617(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_4618","instance":4618,"id":207961,"goal":"lemma SetInterSubset_4618(S: set, B: set)\n ensures S * B <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_4619","instance":4619,"id":207962,"goal":"lemma SetCardSubset_4619(A: set, T: set)\n requires A <= T\n ensures |A| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_4620","instance":4620,"id":207963,"goal":"lemma SetUnionCard_4620(U: set, T: set)\n requires U * T == {}\n ensures |U + T| == |U| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_4621","instance":4621,"id":207964,"goal":"lemma SetUnionComm_4621(A: set, U: set)\n ensures A + U == U + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_4622","instance":4622,"id":207965,"goal":"lemma SetInterComm_4622(U: set, B: set)\n ensures U * B == B * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_4623","instance":4623,"id":207966,"goal":"lemma SetUnionAssoc_4623(A: set, T: set, S: set)\n ensures (A + T) + S == A + (T + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_4624","instance":4624,"id":207967,"goal":"lemma SetSubsetRefl_4624(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_4625","instance":4625,"id":207968,"goal":"lemma SetSubsetTrans_4625(S: set, A: set, T: set)\n requires S <= A && A <= T\n ensures S <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_4626","instance":4626,"id":207969,"goal":"lemma SetUnionEmpty_4626(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_4627","instance":4627,"id":207970,"goal":"lemma SetInterEmpty_4627(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_4628","instance":4628,"id":207971,"goal":"lemma SetInterSubset_4628(A: set, B: set)\n ensures A * B <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_4629","instance":4629,"id":207972,"goal":"lemma SetCardSubset_4629(S: set, B: set)\n requires S <= B\n ensures |S| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_4630","instance":4630,"id":207973,"goal":"lemma SetUnionCard_4630(U: set, A: set)\n requires U * A == {}\n ensures |U + A| == |U| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_4631","instance":4631,"id":207974,"goal":"lemma SetUnionComm_4631(T: set, U: set)\n ensures T + U == U + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_4632","instance":4632,"id":207975,"goal":"lemma SetInterComm_4632(U: set, B: set)\n ensures U * B == B * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_4633","instance":4633,"id":207976,"goal":"lemma SetUnionAssoc_4633(S: set, U: set, B: set)\n ensures (S + U) + B == S + (U + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_4634","instance":4634,"id":207977,"goal":"lemma SetSubsetRefl_4634(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_4635","instance":4635,"id":207978,"goal":"lemma SetSubsetTrans_4635(T: set, B: set, S: set)\n requires T <= B && B <= S\n ensures T <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_4636","instance":4636,"id":207979,"goal":"lemma SetUnionEmpty_4636(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_4637","instance":4637,"id":207980,"goal":"lemma SetInterEmpty_4637(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_4638","instance":4638,"id":207981,"goal":"lemma SetInterSubset_4638(A: set, U: set)\n ensures A * U <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_4639","instance":4639,"id":207982,"goal":"lemma SetCardSubset_4639(B: set, U: set)\n requires B <= U\n ensures |B| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_4640","instance":4640,"id":207983,"goal":"lemma SetUnionCard_4640(T: set, B: set)\n requires T * B == {}\n ensures |T + B| == |T| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_4641","instance":4641,"id":207984,"goal":"lemma SetUnionComm_4641(S: set, B: set)\n ensures S + B == B + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_4642","instance":4642,"id":207985,"goal":"lemma SetInterComm_4642(B: set, S: set)\n ensures B * S == S * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_4643","instance":4643,"id":207986,"goal":"lemma SetUnionAssoc_4643(T: set, A: set, S: set)\n ensures (T + A) + S == T + (A + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_4644","instance":4644,"id":207987,"goal":"lemma SetSubsetRefl_4644(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_4645","instance":4645,"id":207988,"goal":"lemma SetSubsetTrans_4645(S: set, A: set, B: set)\n requires S <= A && A <= B\n ensures S <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_4646","instance":4646,"id":207989,"goal":"lemma SetUnionEmpty_4646(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_4647","instance":4647,"id":207990,"goal":"lemma SetInterEmpty_4647(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_4648","instance":4648,"id":207991,"goal":"lemma SetInterSubset_4648(S: set, A: set)\n ensures S * A <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_4649","instance":4649,"id":207992,"goal":"lemma SetCardSubset_4649(S: set, B: set)\n requires S <= B\n ensures |S| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_4650","instance":4650,"id":207993,"goal":"lemma SetUnionCard_4650(U: set, S: set)\n requires U * S == {}\n ensures |U + S| == |U| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_4651","instance":4651,"id":207994,"goal":"lemma SetUnionComm_4651(T: set, A: set)\n ensures T + A == A + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_4652","instance":4652,"id":207995,"goal":"lemma SetInterComm_4652(S: set, U: set)\n ensures S * U == U * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_4653","instance":4653,"id":207996,"goal":"lemma SetUnionAssoc_4653(U: set, T: set, S: set)\n ensures (U + T) + S == U + (T + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_4654","instance":4654,"id":207997,"goal":"lemma SetSubsetRefl_4654(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_4655","instance":4655,"id":207998,"goal":"lemma SetSubsetTrans_4655(U: set, T: set, B: set)\n requires U <= T && T <= B\n ensures U <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_4656","instance":4656,"id":207999,"goal":"lemma SetUnionEmpty_4656(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_4657","instance":4657,"id":208000,"goal":"lemma SetInterEmpty_4657(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_4658","instance":4658,"id":208001,"goal":"lemma SetInterSubset_4658(U: set, A: set)\n ensures U * A <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_4659","instance":4659,"id":208002,"goal":"lemma SetCardSubset_4659(U: set, S: set)\n requires U <= S\n ensures |U| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_4660","instance":4660,"id":208003,"goal":"lemma SetUnionCard_4660(A: set, S: set)\n requires A * S == {}\n ensures |A + S| == |A| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_4661","instance":4661,"id":208004,"goal":"lemma SetUnionComm_4661(T: set, B: set)\n ensures T + B == B + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_4662","instance":4662,"id":208005,"goal":"lemma SetInterComm_4662(B: set, T: set)\n ensures B * T == T * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_4663","instance":4663,"id":208006,"goal":"lemma SetUnionAssoc_4663(T: set, B: set, A: set)\n ensures (T + B) + A == T + (B + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_4664","instance":4664,"id":208007,"goal":"lemma SetSubsetRefl_4664(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_4665","instance":4665,"id":208008,"goal":"lemma SetSubsetTrans_4665(T: set, B: set, S: set)\n requires T <= B && B <= S\n ensures T <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_4666","instance":4666,"id":208009,"goal":"lemma SetUnionEmpty_4666(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_4667","instance":4667,"id":208010,"goal":"lemma SetInterEmpty_4667(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_4668","instance":4668,"id":208011,"goal":"lemma SetInterSubset_4668(U: set, T: set)\n ensures U * T <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_4669","instance":4669,"id":208012,"goal":"lemma SetCardSubset_4669(S: set, B: set)\n requires S <= B\n ensures |S| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_4670","instance":4670,"id":208013,"goal":"lemma SetUnionCard_4670(A: set, T: set)\n requires A * T == {}\n ensures |A + T| == |A| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_4671","instance":4671,"id":208014,"goal":"lemma SetUnionComm_4671(S: set, U: set)\n ensures S + U == U + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_4672","instance":4672,"id":208015,"goal":"lemma SetInterComm_4672(T: set, B: set)\n ensures T * B == B * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_4673","instance":4673,"id":208016,"goal":"lemma SetUnionAssoc_4673(U: set, T: set, A: set)\n ensures (U + T) + A == U + (T + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_4674","instance":4674,"id":208017,"goal":"lemma SetSubsetRefl_4674(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_4675","instance":4675,"id":208018,"goal":"lemma SetSubsetTrans_4675(S: set, T: set, U: set)\n requires S <= T && T <= U\n ensures S <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_4676","instance":4676,"id":208019,"goal":"lemma SetUnionEmpty_4676(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_4677","instance":4677,"id":208020,"goal":"lemma SetInterEmpty_4677(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_4678","instance":4678,"id":208021,"goal":"lemma SetInterSubset_4678(A: set, U: set)\n ensures A * U <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_4679","instance":4679,"id":208022,"goal":"lemma SetCardSubset_4679(T: set, A: set)\n requires T <= A\n ensures |T| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_4680","instance":4680,"id":208023,"goal":"lemma SetUnionCard_4680(U: set, A: set)\n requires U * A == {}\n ensures |U + A| == |U| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_4681","instance":4681,"id":208024,"goal":"lemma SetUnionComm_4681(T: set, S: set)\n ensures T + S == S + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_4682","instance":4682,"id":208025,"goal":"lemma SetInterComm_4682(T: set, B: set)\n ensures T * B == B * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_4683","instance":4683,"id":208026,"goal":"lemma SetUnionAssoc_4683(T: set, A: set, B: set)\n ensures (T + A) + B == T + (A + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_4684","instance":4684,"id":208027,"goal":"lemma SetSubsetRefl_4684(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_4685","instance":4685,"id":208028,"goal":"lemma SetSubsetTrans_4685(B: set, U: set, S: set)\n requires B <= U && U <= S\n ensures B <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_4686","instance":4686,"id":208029,"goal":"lemma SetUnionEmpty_4686(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_4687","instance":4687,"id":208030,"goal":"lemma SetInterEmpty_4687(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_4688","instance":4688,"id":208031,"goal":"lemma SetInterSubset_4688(T: set, U: set)\n ensures T * U <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_4689","instance":4689,"id":208032,"goal":"lemma SetCardSubset_4689(U: set, T: set)\n requires U <= T\n ensures |U| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_4690","instance":4690,"id":208033,"goal":"lemma SetUnionCard_4690(T: set, U: set)\n requires T * U == {}\n ensures |T + U| == |T| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_4691","instance":4691,"id":208034,"goal":"lemma SetUnionComm_4691(U: set, A: set)\n ensures U + A == A + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_4692","instance":4692,"id":208035,"goal":"lemma SetInterComm_4692(A: set, B: set)\n ensures A * B == B * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_4693","instance":4693,"id":208036,"goal":"lemma SetUnionAssoc_4693(S: set, T: set, B: set)\n ensures (S + T) + B == S + (T + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_4694","instance":4694,"id":208037,"goal":"lemma SetSubsetRefl_4694(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_4695","instance":4695,"id":208038,"goal":"lemma SetSubsetTrans_4695(T: set, B: set, U: set)\n requires T <= B && B <= U\n ensures T <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_4696","instance":4696,"id":208039,"goal":"lemma SetUnionEmpty_4696(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_4697","instance":4697,"id":208040,"goal":"lemma SetInterEmpty_4697(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_4698","instance":4698,"id":208041,"goal":"lemma SetInterSubset_4698(T: set, U: set)\n ensures T * U <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_4699","instance":4699,"id":208042,"goal":"lemma SetCardSubset_4699(T: set, A: set)\n requires T <= A\n ensures |T| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_4700","instance":4700,"id":208043,"goal":"lemma SetUnionCard_4700(T: set, U: set)\n requires T * U == {}\n ensures |T + U| == |T| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_4701","instance":4701,"id":208044,"goal":"lemma SetUnionComm_4701(B: set, U: set)\n ensures B + U == U + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_4702","instance":4702,"id":208045,"goal":"lemma SetInterComm_4702(U: set, S: set)\n ensures U * S == S * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_4703","instance":4703,"id":208046,"goal":"lemma SetUnionAssoc_4703(T: set, U: set, B: set)\n ensures (T + U) + B == T + (U + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_4704","instance":4704,"id":208047,"goal":"lemma SetSubsetRefl_4704(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_4705","instance":4705,"id":208048,"goal":"lemma SetSubsetTrans_4705(A: set, T: set, U: set)\n requires A <= T && T <= U\n ensures A <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_4706","instance":4706,"id":208049,"goal":"lemma SetUnionEmpty_4706(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_4707","instance":4707,"id":208050,"goal":"lemma SetInterEmpty_4707(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_4708","instance":4708,"id":208051,"goal":"lemma SetInterSubset_4708(S: set, B: set)\n ensures S * B <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_4709","instance":4709,"id":208052,"goal":"lemma SetCardSubset_4709(U: set, A: set)\n requires U <= A\n ensures |U| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_4710","instance":4710,"id":208053,"goal":"lemma SetUnionCard_4710(A: set, T: set)\n requires A * T == {}\n ensures |A + T| == |A| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_4711","instance":4711,"id":208054,"goal":"lemma SetUnionComm_4711(T: set, B: set)\n ensures T + B == B + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_4712","instance":4712,"id":208055,"goal":"lemma SetInterComm_4712(B: set, A: set)\n ensures B * A == A * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_4713","instance":4713,"id":208056,"goal":"lemma SetUnionAssoc_4713(A: set, S: set, T: set)\n ensures (A + S) + T == A + (S + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_4714","instance":4714,"id":208057,"goal":"lemma SetSubsetRefl_4714(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_4715","instance":4715,"id":208058,"goal":"lemma SetSubsetTrans_4715(S: set, T: set, U: set)\n requires S <= T && T <= U\n ensures S <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_4716","instance":4716,"id":208059,"goal":"lemma SetUnionEmpty_4716(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_4717","instance":4717,"id":208060,"goal":"lemma SetInterEmpty_4717(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_4718","instance":4718,"id":208061,"goal":"lemma SetInterSubset_4718(A: set, U: set)\n ensures A * U <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_4719","instance":4719,"id":208062,"goal":"lemma SetCardSubset_4719(U: set, A: set)\n requires U <= A\n ensures |U| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_4720","instance":4720,"id":208063,"goal":"lemma SetUnionCard_4720(U: set, T: set)\n requires U * T == {}\n ensures |U + T| == |U| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_4721","instance":4721,"id":208064,"goal":"lemma SetUnionComm_4721(U: set, S: set)\n ensures U + S == S + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_4722","instance":4722,"id":208065,"goal":"lemma SetInterComm_4722(T: set, B: set)\n ensures T * B == B * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_4723","instance":4723,"id":208066,"goal":"lemma SetUnionAssoc_4723(T: set, B: set, A: set)\n ensures (T + B) + A == T + (B + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_4724","instance":4724,"id":208067,"goal":"lemma SetSubsetRefl_4724(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_4725","instance":4725,"id":208068,"goal":"lemma SetSubsetTrans_4725(U: set, T: set, A: set)\n requires U <= T && T <= A\n ensures U <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_4726","instance":4726,"id":208069,"goal":"lemma SetUnionEmpty_4726(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_4727","instance":4727,"id":208070,"goal":"lemma SetInterEmpty_4727(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_4728","instance":4728,"id":208071,"goal":"lemma SetInterSubset_4728(U: set, B: set)\n ensures U * B <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_4729","instance":4729,"id":208072,"goal":"lemma SetCardSubset_4729(S: set, B: set)\n requires S <= B\n ensures |S| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_4730","instance":4730,"id":208073,"goal":"lemma SetUnionCard_4730(A: set, U: set)\n requires A * U == {}\n ensures |A + U| == |A| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_4731","instance":4731,"id":208074,"goal":"lemma SetUnionComm_4731(S: set, T: set)\n ensures S + T == T + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_4732","instance":4732,"id":208075,"goal":"lemma SetInterComm_4732(U: set, T: set)\n ensures U * T == T * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_4733","instance":4733,"id":208076,"goal":"lemma SetUnionAssoc_4733(U: set, B: set, T: set)\n ensures (U + B) + T == U + (B + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_4734","instance":4734,"id":208077,"goal":"lemma SetSubsetRefl_4734(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_4735","instance":4735,"id":208078,"goal":"lemma SetSubsetTrans_4735(A: set, U: set, B: set)\n requires A <= U && U <= B\n ensures A <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_4736","instance":4736,"id":208079,"goal":"lemma SetUnionEmpty_4736(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_4737","instance":4737,"id":208080,"goal":"lemma SetInterEmpty_4737(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_4738","instance":4738,"id":208081,"goal":"lemma SetInterSubset_4738(B: set, S: set)\n ensures B * S <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_4739","instance":4739,"id":208082,"goal":"lemma SetCardSubset_4739(U: set, S: set)\n requires U <= S\n ensures |U| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_4740","instance":4740,"id":208083,"goal":"lemma SetUnionCard_4740(A: set, T: set)\n requires A * T == {}\n ensures |A + T| == |A| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_4741","instance":4741,"id":208084,"goal":"lemma SetUnionComm_4741(T: set, U: set)\n ensures T + U == U + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_4742","instance":4742,"id":208085,"goal":"lemma SetInterComm_4742(B: set, U: set)\n ensures B * U == U * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_4743","instance":4743,"id":208086,"goal":"lemma SetUnionAssoc_4743(S: set, A: set, U: set)\n ensures (S + A) + U == S + (A + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_4744","instance":4744,"id":208087,"goal":"lemma SetSubsetRefl_4744(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_4745","instance":4745,"id":208088,"goal":"lemma SetSubsetTrans_4745(U: set, S: set, B: set)\n requires U <= S && S <= B\n ensures U <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_4746","instance":4746,"id":208089,"goal":"lemma SetUnionEmpty_4746(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_4747","instance":4747,"id":208090,"goal":"lemma SetInterEmpty_4747(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_4748","instance":4748,"id":208091,"goal":"lemma SetInterSubset_4748(B: set, S: set)\n ensures B * S <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_4749","instance":4749,"id":208092,"goal":"lemma SetCardSubset_4749(S: set, U: set)\n requires S <= U\n ensures |S| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_4750","instance":4750,"id":208093,"goal":"lemma SetUnionCard_4750(S: set, T: set)\n requires S * T == {}\n ensures |S + T| == |S| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_4751","instance":4751,"id":208094,"goal":"lemma SetUnionComm_4751(U: set, A: set)\n ensures U + A == A + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_4752","instance":4752,"id":208095,"goal":"lemma SetInterComm_4752(U: set, B: set)\n ensures U * B == B * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_4753","instance":4753,"id":208096,"goal":"lemma SetUnionAssoc_4753(A: set, B: set, S: set)\n ensures (A + B) + S == A + (B + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_4754","instance":4754,"id":208097,"goal":"lemma SetSubsetRefl_4754(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_4755","instance":4755,"id":208098,"goal":"lemma SetSubsetTrans_4755(U: set, B: set, T: set)\n requires U <= B && B <= T\n ensures U <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_4756","instance":4756,"id":208099,"goal":"lemma SetUnionEmpty_4756(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_4757","instance":4757,"id":208100,"goal":"lemma SetInterEmpty_4757(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_4758","instance":4758,"id":208101,"goal":"lemma SetInterSubset_4758(T: set, A: set)\n ensures T * A <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_4759","instance":4759,"id":208102,"goal":"lemma SetCardSubset_4759(A: set, T: set)\n requires A <= T\n ensures |A| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_4760","instance":4760,"id":208103,"goal":"lemma SetUnionCard_4760(T: set, B: set)\n requires T * B == {}\n ensures |T + B| == |T| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_4761","instance":4761,"id":208104,"goal":"lemma SetUnionComm_4761(U: set, T: set)\n ensures U + T == T + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_4762","instance":4762,"id":208105,"goal":"lemma SetInterComm_4762(T: set, U: set)\n ensures T * U == U * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_4763","instance":4763,"id":208106,"goal":"lemma SetUnionAssoc_4763(U: set, T: set, A: set)\n ensures (U + T) + A == U + (T + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_4764","instance":4764,"id":208107,"goal":"lemma SetSubsetRefl_4764(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_4765","instance":4765,"id":208108,"goal":"lemma SetSubsetTrans_4765(B: set, T: set, A: set)\n requires B <= T && T <= A\n ensures B <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_4766","instance":4766,"id":208109,"goal":"lemma SetUnionEmpty_4766(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_4767","instance":4767,"id":208110,"goal":"lemma SetInterEmpty_4767(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_4768","instance":4768,"id":208111,"goal":"lemma SetInterSubset_4768(B: set, T: set)\n ensures B * T <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_4769","instance":4769,"id":208112,"goal":"lemma SetCardSubset_4769(A: set, B: set)\n requires A <= B\n ensures |A| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_4770","instance":4770,"id":208113,"goal":"lemma SetUnionCard_4770(A: set, T: set)\n requires A * T == {}\n ensures |A + T| == |A| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_4771","instance":4771,"id":208114,"goal":"lemma SetUnionComm_4771(U: set, T: set)\n ensures U + T == T + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_4772","instance":4772,"id":208115,"goal":"lemma SetInterComm_4772(S: set, B: set)\n ensures S * B == B * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_4773","instance":4773,"id":208116,"goal":"lemma SetUnionAssoc_4773(S: set, U: set, A: set)\n ensures (S + U) + A == S + (U + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_4774","instance":4774,"id":208117,"goal":"lemma SetSubsetRefl_4774(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_4775","instance":4775,"id":208118,"goal":"lemma SetSubsetTrans_4775(U: set, T: set, B: set)\n requires U <= T && T <= B\n ensures U <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_4776","instance":4776,"id":208119,"goal":"lemma SetUnionEmpty_4776(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_4777","instance":4777,"id":208120,"goal":"lemma SetInterEmpty_4777(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_4778","instance":4778,"id":208121,"goal":"lemma SetInterSubset_4778(B: set, S: set)\n ensures B * S <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_4779","instance":4779,"id":208122,"goal":"lemma SetCardSubset_4779(A: set, S: set)\n requires A <= S\n ensures |A| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_4780","instance":4780,"id":208123,"goal":"lemma SetUnionCard_4780(U: set, A: set)\n requires U * A == {}\n ensures |U + A| == |U| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_4781","instance":4781,"id":208124,"goal":"lemma SetUnionComm_4781(T: set, S: set)\n ensures T + S == S + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_4782","instance":4782,"id":208125,"goal":"lemma SetInterComm_4782(U: set, A: set)\n ensures U * A == A * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_4783","instance":4783,"id":208126,"goal":"lemma SetUnionAssoc_4783(A: set, S: set, U: set)\n ensures (A + S) + U == A + (S + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_4784","instance":4784,"id":208127,"goal":"lemma SetSubsetRefl_4784(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_4785","instance":4785,"id":208128,"goal":"lemma SetSubsetTrans_4785(S: set, A: set, U: set)\n requires S <= A && A <= U\n ensures S <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_4786","instance":4786,"id":208129,"goal":"lemma SetUnionEmpty_4786(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_4787","instance":4787,"id":208130,"goal":"lemma SetInterEmpty_4787(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_4788","instance":4788,"id":208131,"goal":"lemma SetInterSubset_4788(A: set, B: set)\n ensures A * B <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_4789","instance":4789,"id":208132,"goal":"lemma SetCardSubset_4789(S: set, B: set)\n requires S <= B\n ensures |S| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_4790","instance":4790,"id":208133,"goal":"lemma SetUnionCard_4790(B: set, T: set)\n requires B * T == {}\n ensures |B + T| == |B| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_4791","instance":4791,"id":208134,"goal":"lemma SetUnionComm_4791(B: set, S: set)\n ensures B + S == S + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_4792","instance":4792,"id":208135,"goal":"lemma SetInterComm_4792(A: set, B: set)\n ensures A * B == B * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_4793","instance":4793,"id":208136,"goal":"lemma SetUnionAssoc_4793(T: set, S: set, A: set)\n ensures (T + S) + A == T + (S + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_4794","instance":4794,"id":208137,"goal":"lemma SetSubsetRefl_4794(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_4795","instance":4795,"id":208138,"goal":"lemma SetSubsetTrans_4795(U: set, A: set, B: set)\n requires U <= A && A <= B\n ensures U <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_4796","instance":4796,"id":208139,"goal":"lemma SetUnionEmpty_4796(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_4797","instance":4797,"id":208140,"goal":"lemma SetInterEmpty_4797(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_4798","instance":4798,"id":208141,"goal":"lemma SetInterSubset_4798(B: set, U: set)\n ensures B * U <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_4799","instance":4799,"id":208142,"goal":"lemma SetCardSubset_4799(A: set, S: set)\n requires A <= S\n ensures |A| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_4800","instance":4800,"id":208143,"goal":"lemma SetUnionCard_4800(B: set, T: set)\n requires B * T == {}\n ensures |B + T| == |B| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_4801","instance":4801,"id":208144,"goal":"lemma SetUnionComm_4801(U: set, S: set)\n ensures U + S == S + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_4802","instance":4802,"id":208145,"goal":"lemma SetInterComm_4802(B: set, U: set)\n ensures B * U == U * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_4803","instance":4803,"id":208146,"goal":"lemma SetUnionAssoc_4803(S: set, T: set, A: set)\n ensures (S + T) + A == S + (T + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_4804","instance":4804,"id":208147,"goal":"lemma SetSubsetRefl_4804(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_4805","instance":4805,"id":208148,"goal":"lemma SetSubsetTrans_4805(T: set, B: set, A: set)\n requires T <= B && B <= A\n ensures T <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_4806","instance":4806,"id":208149,"goal":"lemma SetUnionEmpty_4806(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_4807","instance":4807,"id":208150,"goal":"lemma SetInterEmpty_4807(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_4808","instance":4808,"id":208151,"goal":"lemma SetInterSubset_4808(B: set, A: set)\n ensures B * A <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_4809","instance":4809,"id":208152,"goal":"lemma SetCardSubset_4809(T: set, U: set)\n requires T <= U\n ensures |T| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_4810","instance":4810,"id":208153,"goal":"lemma SetUnionCard_4810(S: set, U: set)\n requires S * U == {}\n ensures |S + U| == |S| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_4811","instance":4811,"id":208154,"goal":"lemma SetUnionComm_4811(U: set, T: set)\n ensures U + T == T + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_4812","instance":4812,"id":208155,"goal":"lemma SetInterComm_4812(B: set, U: set)\n ensures B * U == U * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_4813","instance":4813,"id":208156,"goal":"lemma SetUnionAssoc_4813(S: set, U: set, A: set)\n ensures (S + U) + A == S + (U + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_4814","instance":4814,"id":208157,"goal":"lemma SetSubsetRefl_4814(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_4815","instance":4815,"id":208158,"goal":"lemma SetSubsetTrans_4815(A: set, T: set, U: set)\n requires A <= T && T <= U\n ensures A <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_4816","instance":4816,"id":208159,"goal":"lemma SetUnionEmpty_4816(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_4817","instance":4817,"id":208160,"goal":"lemma SetInterEmpty_4817(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_4818","instance":4818,"id":208161,"goal":"lemma SetInterSubset_4818(U: set, A: set)\n ensures U * A <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_4819","instance":4819,"id":208162,"goal":"lemma SetCardSubset_4819(B: set, T: set)\n requires B <= T\n ensures |B| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_4820","instance":4820,"id":208163,"goal":"lemma SetUnionCard_4820(B: set, T: set)\n requires B * T == {}\n ensures |B + T| == |B| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_4821","instance":4821,"id":208164,"goal":"lemma SetUnionComm_4821(S: set, U: set)\n ensures S + U == U + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_4822","instance":4822,"id":208165,"goal":"lemma SetInterComm_4822(S: set, A: set)\n ensures S * A == A * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_4823","instance":4823,"id":208166,"goal":"lemma SetUnionAssoc_4823(S: set, U: set, A: set)\n ensures (S + U) + A == S + (U + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_4824","instance":4824,"id":208167,"goal":"lemma SetSubsetRefl_4824(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_4825","instance":4825,"id":208168,"goal":"lemma SetSubsetTrans_4825(U: set, A: set, T: set)\n requires U <= A && A <= T\n ensures U <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_4826","instance":4826,"id":208169,"goal":"lemma SetUnionEmpty_4826(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_4827","instance":4827,"id":208170,"goal":"lemma SetInterEmpty_4827(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_4828","instance":4828,"id":208171,"goal":"lemma SetInterSubset_4828(A: set, B: set)\n ensures A * B <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_4829","instance":4829,"id":208172,"goal":"lemma SetCardSubset_4829(B: set, T: set)\n requires B <= T\n ensures |B| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_4830","instance":4830,"id":208173,"goal":"lemma SetUnionCard_4830(S: set, A: set)\n requires S * A == {}\n ensures |S + A| == |S| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_4831","instance":4831,"id":208174,"goal":"lemma SetUnionComm_4831(B: set, U: set)\n ensures B + U == U + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_4832","instance":4832,"id":208175,"goal":"lemma SetInterComm_4832(T: set, B: set)\n ensures T * B == B * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_4833","instance":4833,"id":208176,"goal":"lemma SetUnionAssoc_4833(A: set, S: set, T: set)\n ensures (A + S) + T == A + (S + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_4834","instance":4834,"id":208177,"goal":"lemma SetSubsetRefl_4834(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_4835","instance":4835,"id":208178,"goal":"lemma SetSubsetTrans_4835(A: set, T: set, S: set)\n requires A <= T && T <= S\n ensures A <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_4836","instance":4836,"id":208179,"goal":"lemma SetUnionEmpty_4836(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_4837","instance":4837,"id":208180,"goal":"lemma SetInterEmpty_4837(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_4838","instance":4838,"id":208181,"goal":"lemma SetInterSubset_4838(S: set, B: set)\n ensures S * B <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_4839","instance":4839,"id":208182,"goal":"lemma SetCardSubset_4839(A: set, T: set)\n requires A <= T\n ensures |A| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_4840","instance":4840,"id":208183,"goal":"lemma SetUnionCard_4840(U: set, A: set)\n requires U * A == {}\n ensures |U + A| == |U| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_4841","instance":4841,"id":208184,"goal":"lemma SetUnionComm_4841(A: set, U: set)\n ensures A + U == U + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_4842","instance":4842,"id":208185,"goal":"lemma SetInterComm_4842(U: set, B: set)\n ensures U * B == B * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_4843","instance":4843,"id":208186,"goal":"lemma SetUnionAssoc_4843(B: set, U: set, A: set)\n ensures (B + U) + A == B + (U + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_4844","instance":4844,"id":208187,"goal":"lemma SetSubsetRefl_4844(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_4845","instance":4845,"id":208188,"goal":"lemma SetSubsetTrans_4845(B: set, A: set, U: set)\n requires B <= A && A <= U\n ensures B <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_4846","instance":4846,"id":208189,"goal":"lemma SetUnionEmpty_4846(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_4847","instance":4847,"id":208190,"goal":"lemma SetInterEmpty_4847(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_4848","instance":4848,"id":208191,"goal":"lemma SetInterSubset_4848(U: set, A: set)\n ensures U * A <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_4849","instance":4849,"id":208192,"goal":"lemma SetCardSubset_4849(S: set, T: set)\n requires S <= T\n ensures |S| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_4850","instance":4850,"id":208193,"goal":"lemma SetUnionCard_4850(S: set, U: set)\n requires S * U == {}\n ensures |S + U| == |S| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_4851","instance":4851,"id":208194,"goal":"lemma SetUnionComm_4851(S: set, U: set)\n ensures S + U == U + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_4852","instance":4852,"id":208195,"goal":"lemma SetInterComm_4852(S: set, A: set)\n ensures S * A == A * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_4853","instance":4853,"id":208196,"goal":"lemma SetUnionAssoc_4853(S: set, B: set, A: set)\n ensures (S + B) + A == S + (B + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_4854","instance":4854,"id":208197,"goal":"lemma SetSubsetRefl_4854(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_4855","instance":4855,"id":208198,"goal":"lemma SetSubsetTrans_4855(U: set, S: set, A: set)\n requires U <= S && S <= A\n ensures U <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_4856","instance":4856,"id":208199,"goal":"lemma SetUnionEmpty_4856(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_4857","instance":4857,"id":208200,"goal":"lemma SetInterEmpty_4857(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_4858","instance":4858,"id":208201,"goal":"lemma SetInterSubset_4858(S: set, B: set)\n ensures S * B <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_4859","instance":4859,"id":208202,"goal":"lemma SetCardSubset_4859(S: set, A: set)\n requires S <= A\n ensures |S| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_4860","instance":4860,"id":208203,"goal":"lemma SetUnionCard_4860(T: set, A: set)\n requires T * A == {}\n ensures |T + A| == |T| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_4861","instance":4861,"id":208204,"goal":"lemma SetUnionComm_4861(A: set, U: set)\n ensures A + U == U + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_4862","instance":4862,"id":208205,"goal":"lemma SetInterComm_4862(U: set, S: set)\n ensures U * S == S * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_4863","instance":4863,"id":208206,"goal":"lemma SetUnionAssoc_4863(S: set, B: set, U: set)\n ensures (S + B) + U == S + (B + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_4864","instance":4864,"id":208207,"goal":"lemma SetSubsetRefl_4864(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_4865","instance":4865,"id":208208,"goal":"lemma SetSubsetTrans_4865(U: set, B: set, A: set)\n requires U <= B && B <= A\n ensures U <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_4866","instance":4866,"id":208209,"goal":"lemma SetUnionEmpty_4866(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_4867","instance":4867,"id":208210,"goal":"lemma SetInterEmpty_4867(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_4868","instance":4868,"id":208211,"goal":"lemma SetInterSubset_4868(A: set, S: set)\n ensures A * S <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_4869","instance":4869,"id":208212,"goal":"lemma SetCardSubset_4869(A: set, T: set)\n requires A <= T\n ensures |A| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_4870","instance":4870,"id":208213,"goal":"lemma SetUnionCard_4870(A: set, T: set)\n requires A * T == {}\n ensures |A + T| == |A| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_4871","instance":4871,"id":208214,"goal":"lemma SetUnionComm_4871(S: set, A: set)\n ensures S + A == A + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_4872","instance":4872,"id":208215,"goal":"lemma SetInterComm_4872(B: set, A: set)\n ensures B * A == A * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_4873","instance":4873,"id":208216,"goal":"lemma SetUnionAssoc_4873(A: set, B: set, S: set)\n ensures (A + B) + S == A + (B + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_4874","instance":4874,"id":208217,"goal":"lemma SetSubsetRefl_4874(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_4875","instance":4875,"id":208218,"goal":"lemma SetSubsetTrans_4875(B: set, U: set, A: set)\n requires B <= U && U <= A\n ensures B <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_4876","instance":4876,"id":208219,"goal":"lemma SetUnionEmpty_4876(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_4877","instance":4877,"id":208220,"goal":"lemma SetInterEmpty_4877(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_4878","instance":4878,"id":208221,"goal":"lemma SetInterSubset_4878(T: set, S: set)\n ensures T * S <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_4879","instance":4879,"id":208222,"goal":"lemma SetCardSubset_4879(S: set, B: set)\n requires S <= B\n ensures |S| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_4880","instance":4880,"id":208223,"goal":"lemma SetUnionCard_4880(S: set, B: set)\n requires S * B == {}\n ensures |S + B| == |S| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_4881","instance":4881,"id":208224,"goal":"lemma SetUnionComm_4881(S: set, U: set)\n ensures S + U == U + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_4882","instance":4882,"id":208225,"goal":"lemma SetInterComm_4882(B: set, T: set)\n ensures B * T == T * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_4883","instance":4883,"id":208226,"goal":"lemma SetUnionAssoc_4883(S: set, A: set, U: set)\n ensures (S + A) + U == S + (A + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_4884","instance":4884,"id":208227,"goal":"lemma SetSubsetRefl_4884(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_4885","instance":4885,"id":208228,"goal":"lemma SetSubsetTrans_4885(A: set, T: set, U: set)\n requires A <= T && T <= U\n ensures A <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_4886","instance":4886,"id":208229,"goal":"lemma SetUnionEmpty_4886(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_4887","instance":4887,"id":208230,"goal":"lemma SetInterEmpty_4887(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_4888","instance":4888,"id":208231,"goal":"lemma SetInterSubset_4888(A: set, B: set)\n ensures A * B <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_4889","instance":4889,"id":208232,"goal":"lemma SetCardSubset_4889(B: set, S: set)\n requires B <= S\n ensures |B| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_4890","instance":4890,"id":208233,"goal":"lemma SetUnionCard_4890(A: set, U: set)\n requires A * U == {}\n ensures |A + U| == |A| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_4891","instance":4891,"id":208234,"goal":"lemma SetUnionComm_4891(U: set, A: set)\n ensures U + A == A + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_4892","instance":4892,"id":208235,"goal":"lemma SetInterComm_4892(T: set, U: set)\n ensures T * U == U * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_4893","instance":4893,"id":208236,"goal":"lemma SetUnionAssoc_4893(T: set, S: set, A: set)\n ensures (T + S) + A == T + (S + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_4894","instance":4894,"id":208237,"goal":"lemma SetSubsetRefl_4894(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_4895","instance":4895,"id":208238,"goal":"lemma SetSubsetTrans_4895(U: set, B: set, T: set)\n requires U <= B && B <= T\n ensures U <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_4896","instance":4896,"id":208239,"goal":"lemma SetUnionEmpty_4896(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_4897","instance":4897,"id":208240,"goal":"lemma SetInterEmpty_4897(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_4898","instance":4898,"id":208241,"goal":"lemma SetInterSubset_4898(A: set, B: set)\n ensures A * B <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_4899","instance":4899,"id":208242,"goal":"lemma SetCardSubset_4899(A: set, U: set)\n requires A <= U\n ensures |A| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_4900","instance":4900,"id":208243,"goal":"lemma SetUnionCard_4900(U: set, A: set)\n requires U * A == {}\n ensures |U + A| == |U| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_4901","instance":4901,"id":208244,"goal":"lemma SetUnionComm_4901(U: set, T: set)\n ensures U + T == T + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_4902","instance":4902,"id":208245,"goal":"lemma SetInterComm_4902(A: set, S: set)\n ensures A * S == S * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_4903","instance":4903,"id":208246,"goal":"lemma SetUnionAssoc_4903(A: set, U: set, T: set)\n ensures (A + U) + T == A + (U + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_4904","instance":4904,"id":208247,"goal":"lemma SetSubsetRefl_4904(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_4905","instance":4905,"id":208248,"goal":"lemma SetSubsetTrans_4905(U: set, A: set, S: set)\n requires U <= A && A <= S\n ensures U <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_4906","instance":4906,"id":208249,"goal":"lemma SetUnionEmpty_4906(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_4907","instance":4907,"id":208250,"goal":"lemma SetInterEmpty_4907(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_4908","instance":4908,"id":208251,"goal":"lemma SetInterSubset_4908(B: set, A: set)\n ensures B * A <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_4909","instance":4909,"id":208252,"goal":"lemma SetCardSubset_4909(A: set, T: set)\n requires A <= T\n ensures |A| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_4910","instance":4910,"id":208253,"goal":"lemma SetUnionCard_4910(B: set, U: set)\n requires B * U == {}\n ensures |B + U| == |B| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_4911","instance":4911,"id":208254,"goal":"lemma SetUnionComm_4911(U: set, S: set)\n ensures U + S == S + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_4912","instance":4912,"id":208255,"goal":"lemma SetInterComm_4912(B: set, A: set)\n ensures B * A == A * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_4913","instance":4913,"id":208256,"goal":"lemma SetUnionAssoc_4913(S: set, B: set, T: set)\n ensures (S + B) + T == S + (B + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_4914","instance":4914,"id":208257,"goal":"lemma SetSubsetRefl_4914(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_4915","instance":4915,"id":208258,"goal":"lemma SetSubsetTrans_4915(U: set, A: set, B: set)\n requires U <= A && A <= B\n ensures U <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_4916","instance":4916,"id":208259,"goal":"lemma SetUnionEmpty_4916(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_4917","instance":4917,"id":208260,"goal":"lemma SetInterEmpty_4917(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_4918","instance":4918,"id":208261,"goal":"lemma SetInterSubset_4918(T: set, S: set)\n ensures T * S <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_4919","instance":4919,"id":208262,"goal":"lemma SetCardSubset_4919(S: set, B: set)\n requires S <= B\n ensures |S| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_4920","instance":4920,"id":208263,"goal":"lemma SetUnionCard_4920(T: set, A: set)\n requires T * A == {}\n ensures |T + A| == |T| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_4921","instance":4921,"id":208264,"goal":"lemma SetUnionComm_4921(U: set, T: set)\n ensures U + T == T + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_4922","instance":4922,"id":208265,"goal":"lemma SetInterComm_4922(B: set, U: set)\n ensures B * U == U * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_4923","instance":4923,"id":208266,"goal":"lemma SetUnionAssoc_4923(S: set, T: set, A: set)\n ensures (S + T) + A == S + (T + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_4924","instance":4924,"id":208267,"goal":"lemma SetSubsetRefl_4924(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_4925","instance":4925,"id":208268,"goal":"lemma SetSubsetTrans_4925(U: set, A: set, B: set)\n requires U <= A && A <= B\n ensures U <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_4926","instance":4926,"id":208269,"goal":"lemma SetUnionEmpty_4926(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_4927","instance":4927,"id":208270,"goal":"lemma SetInterEmpty_4927(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_4928","instance":4928,"id":208271,"goal":"lemma SetInterSubset_4928(S: set, A: set)\n ensures S * A <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_4929","instance":4929,"id":208272,"goal":"lemma SetCardSubset_4929(S: set, T: set)\n requires S <= T\n ensures |S| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_4930","instance":4930,"id":208273,"goal":"lemma SetUnionCard_4930(U: set, T: set)\n requires U * T == {}\n ensures |U + T| == |U| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_4931","instance":4931,"id":208274,"goal":"lemma SetUnionComm_4931(T: set, U: set)\n ensures T + U == U + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_4932","instance":4932,"id":208275,"goal":"lemma SetInterComm_4932(B: set, A: set)\n ensures B * A == A * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_4933","instance":4933,"id":208276,"goal":"lemma SetUnionAssoc_4933(U: set, T: set, A: set)\n ensures (U + T) + A == U + (T + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_4934","instance":4934,"id":208277,"goal":"lemma SetSubsetRefl_4934(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_4935","instance":4935,"id":208278,"goal":"lemma SetSubsetTrans_4935(S: set, T: set, A: set)\n requires S <= T && T <= A\n ensures S <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_4936","instance":4936,"id":208279,"goal":"lemma SetUnionEmpty_4936(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_4937","instance":4937,"id":208280,"goal":"lemma SetInterEmpty_4937(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_4938","instance":4938,"id":208281,"goal":"lemma SetInterSubset_4938(S: set, U: set)\n ensures S * U <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_4939","instance":4939,"id":208282,"goal":"lemma SetCardSubset_4939(S: set, U: set)\n requires S <= U\n ensures |S| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_4940","instance":4940,"id":208283,"goal":"lemma SetUnionCard_4940(S: set, B: set)\n requires S * B == {}\n ensures |S + B| == |S| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_4941","instance":4941,"id":208284,"goal":"lemma SetUnionComm_4941(A: set, B: set)\n ensures A + B == B + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_4942","instance":4942,"id":208285,"goal":"lemma SetInterComm_4942(S: set, A: set)\n ensures S * A == A * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_4943","instance":4943,"id":208286,"goal":"lemma SetUnionAssoc_4943(U: set, A: set, T: set)\n ensures (U + A) + T == U + (A + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_4944","instance":4944,"id":208287,"goal":"lemma SetSubsetRefl_4944(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_4945","instance":4945,"id":208288,"goal":"lemma SetSubsetTrans_4945(T: set, A: set, U: set)\n requires T <= A && A <= U\n ensures T <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_4946","instance":4946,"id":208289,"goal":"lemma SetUnionEmpty_4946(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_4947","instance":4947,"id":208290,"goal":"lemma SetInterEmpty_4947(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_4948","instance":4948,"id":208291,"goal":"lemma SetInterSubset_4948(T: set, B: set)\n ensures T * B <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_4949","instance":4949,"id":208292,"goal":"lemma SetCardSubset_4949(T: set, A: set)\n requires T <= A\n ensures |T| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_4950","instance":4950,"id":208293,"goal":"lemma SetUnionCard_4950(T: set, U: set)\n requires T * U == {}\n ensures |T + U| == |T| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_4951","instance":4951,"id":208294,"goal":"lemma SetUnionComm_4951(U: set, S: set)\n ensures U + S == S + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_4952","instance":4952,"id":208295,"goal":"lemma SetInterComm_4952(B: set, A: set)\n ensures B * A == A * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_4953","instance":4953,"id":208296,"goal":"lemma SetUnionAssoc_4953(U: set, T: set, A: set)\n ensures (U + T) + A == U + (T + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_4954","instance":4954,"id":208297,"goal":"lemma SetSubsetRefl_4954(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_4955","instance":4955,"id":208298,"goal":"lemma SetSubsetTrans_4955(B: set, T: set, S: set)\n requires B <= T && T <= S\n ensures B <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_4956","instance":4956,"id":208299,"goal":"lemma SetUnionEmpty_4956(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_4957","instance":4957,"id":208300,"goal":"lemma SetInterEmpty_4957(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_4958","instance":4958,"id":208301,"goal":"lemma SetInterSubset_4958(B: set, T: set)\n ensures B * T <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_4959","instance":4959,"id":208302,"goal":"lemma SetCardSubset_4959(B: set, U: set)\n requires B <= U\n ensures |B| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_4960","instance":4960,"id":208303,"goal":"lemma SetUnionCard_4960(B: set, S: set)\n requires B * S == {}\n ensures |B + S| == |B| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_4961","instance":4961,"id":208304,"goal":"lemma SetUnionComm_4961(S: set, T: set)\n ensures S + T == T + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_4962","instance":4962,"id":208305,"goal":"lemma SetInterComm_4962(T: set, U: set)\n ensures T * U == U * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_4963","instance":4963,"id":208306,"goal":"lemma SetUnionAssoc_4963(S: set, A: set, T: set)\n ensures (S + A) + T == S + (A + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_4964","instance":4964,"id":208307,"goal":"lemma SetSubsetRefl_4964(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_4965","instance":4965,"id":208308,"goal":"lemma SetSubsetTrans_4965(B: set, U: set, S: set)\n requires B <= U && U <= S\n ensures B <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_4966","instance":4966,"id":208309,"goal":"lemma SetUnionEmpty_4966(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_4967","instance":4967,"id":208310,"goal":"lemma SetInterEmpty_4967(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_4968","instance":4968,"id":208311,"goal":"lemma SetInterSubset_4968(B: set, A: set)\n ensures B * A <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_4969","instance":4969,"id":208312,"goal":"lemma SetCardSubset_4969(U: set, T: set)\n requires U <= T\n ensures |U| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_4970","instance":4970,"id":208313,"goal":"lemma SetUnionCard_4970(U: set, T: set)\n requires U * T == {}\n ensures |U + T| == |U| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_4971","instance":4971,"id":208314,"goal":"lemma SetUnionComm_4971(A: set, S: set)\n ensures A + S == S + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_4972","instance":4972,"id":208315,"goal":"lemma SetInterComm_4972(T: set, S: set)\n ensures T * S == S * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_4973","instance":4973,"id":208316,"goal":"lemma SetUnionAssoc_4973(B: set, T: set, A: set)\n ensures (B + T) + A == B + (T + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_4974","instance":4974,"id":208317,"goal":"lemma SetSubsetRefl_4974(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_4975","instance":4975,"id":208318,"goal":"lemma SetSubsetTrans_4975(B: set, S: set, U: set)\n requires B <= S && S <= U\n ensures B <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_4976","instance":4976,"id":208319,"goal":"lemma SetUnionEmpty_4976(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_4977","instance":4977,"id":208320,"goal":"lemma SetInterEmpty_4977(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_4978","instance":4978,"id":208321,"goal":"lemma SetInterSubset_4978(U: set, S: set)\n ensures U * S <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_4979","instance":4979,"id":208322,"goal":"lemma SetCardSubset_4979(A: set, S: set)\n requires A <= S\n ensures |A| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_4980","instance":4980,"id":208323,"goal":"lemma SetUnionCard_4980(B: set, U: set)\n requires B * U == {}\n ensures |B + U| == |B| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_4981","instance":4981,"id":208324,"goal":"lemma SetUnionComm_4981(S: set, B: set)\n ensures S + B == B + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_4982","instance":4982,"id":208325,"goal":"lemma SetInterComm_4982(B: set, A: set)\n ensures B * A == A * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_4983","instance":4983,"id":208326,"goal":"lemma SetUnionAssoc_4983(T: set, U: set, S: set)\n ensures (T + U) + S == T + (U + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_4984","instance":4984,"id":208327,"goal":"lemma SetSubsetRefl_4984(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_4985","instance":4985,"id":208328,"goal":"lemma SetSubsetTrans_4985(B: set, A: set, S: set)\n requires B <= A && A <= S\n ensures B <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_4986","instance":4986,"id":208329,"goal":"lemma SetUnionEmpty_4986(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_4987","instance":4987,"id":208330,"goal":"lemma SetInterEmpty_4987(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_4988","instance":4988,"id":208331,"goal":"lemma SetInterSubset_4988(A: set, T: set)\n ensures A * T <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_4989","instance":4989,"id":208332,"goal":"lemma SetCardSubset_4989(A: set, U: set)\n requires A <= U\n ensures |A| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_4990","instance":4990,"id":208333,"goal":"lemma SetUnionCard_4990(S: set, A: set)\n requires S * A == {}\n ensures |S + A| == |S| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_4991","instance":4991,"id":208334,"goal":"lemma SetUnionComm_4991(U: set, S: set)\n ensures U + S == S + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_4992","instance":4992,"id":208335,"goal":"lemma SetInterComm_4992(T: set, B: set)\n ensures T * B == B * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_4993","instance":4993,"id":208336,"goal":"lemma SetUnionAssoc_4993(B: set, T: set, A: set)\n ensures (B + T) + A == B + (T + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_4994","instance":4994,"id":208337,"goal":"lemma SetSubsetRefl_4994(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_4995","instance":4995,"id":208338,"goal":"lemma SetSubsetTrans_4995(B: set, S: set, A: set)\n requires B <= S && S <= A\n ensures B <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_4996","instance":4996,"id":208339,"goal":"lemma SetUnionEmpty_4996(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_4997","instance":4997,"id":208340,"goal":"lemma SetInterEmpty_4997(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_4998","instance":4998,"id":208341,"goal":"lemma SetInterSubset_4998(B: set, A: set)\n ensures B * A <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_4999","instance":4999,"id":208342,"goal":"lemma SetCardSubset_4999(A: set, U: set)\n requires A <= U\n ensures |A| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_5000","instance":5000,"id":208343,"goal":"lemma SetUnionCard_5000(T: set, B: set)\n requires T * B == {}\n ensures |T + B| == |T| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_5001","instance":5001,"id":208344,"goal":"lemma SetUnionComm_5001(U: set, B: set)\n ensures U + B == B + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_5002","instance":5002,"id":208345,"goal":"lemma SetInterComm_5002(T: set, B: set)\n ensures T * B == B * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_5003","instance":5003,"id":208346,"goal":"lemma SetUnionAssoc_5003(A: set, U: set, B: set)\n ensures (A + U) + B == A + (U + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_5004","instance":5004,"id":208347,"goal":"lemma SetSubsetRefl_5004(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_5005","instance":5005,"id":208348,"goal":"lemma SetSubsetTrans_5005(S: set, B: set, U: set)\n requires S <= B && B <= U\n ensures S <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_5006","instance":5006,"id":208349,"goal":"lemma SetUnionEmpty_5006(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_5007","instance":5007,"id":208350,"goal":"lemma SetInterEmpty_5007(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_5008","instance":5008,"id":208351,"goal":"lemma SetInterSubset_5008(T: set, S: set)\n ensures T * S <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_5009","instance":5009,"id":208352,"goal":"lemma SetCardSubset_5009(A: set, T: set)\n requires A <= T\n ensures |A| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_5010","instance":5010,"id":208353,"goal":"lemma SetUnionCard_5010(S: set, A: set)\n requires S * A == {}\n ensures |S + A| == |S| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_5011","instance":5011,"id":208354,"goal":"lemma SetUnionComm_5011(B: set, S: set)\n ensures B + S == S + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_5012","instance":5012,"id":208355,"goal":"lemma SetInterComm_5012(A: set, T: set)\n ensures A * T == T * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_5013","instance":5013,"id":208356,"goal":"lemma SetUnionAssoc_5013(S: set, U: set, T: set)\n ensures (S + U) + T == S + (U + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_5014","instance":5014,"id":208357,"goal":"lemma SetSubsetRefl_5014(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_5015","instance":5015,"id":208358,"goal":"lemma SetSubsetTrans_5015(U: set, T: set, B: set)\n requires U <= T && T <= B\n ensures U <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_5016","instance":5016,"id":208359,"goal":"lemma SetUnionEmpty_5016(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_5017","instance":5017,"id":208360,"goal":"lemma SetInterEmpty_5017(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_5018","instance":5018,"id":208361,"goal":"lemma SetInterSubset_5018(S: set, A: set)\n ensures S * A <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_5019","instance":5019,"id":208362,"goal":"lemma SetCardSubset_5019(A: set, T: set)\n requires A <= T\n ensures |A| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_5020","instance":5020,"id":208363,"goal":"lemma SetUnionCard_5020(U: set, S: set)\n requires U * S == {}\n ensures |U + S| == |U| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_5021","instance":5021,"id":208364,"goal":"lemma SetUnionComm_5021(B: set, A: set)\n ensures B + A == A + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_5022","instance":5022,"id":208365,"goal":"lemma SetInterComm_5022(S: set, U: set)\n ensures S * U == U * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_5023","instance":5023,"id":208366,"goal":"lemma SetUnionAssoc_5023(A: set, S: set, B: set)\n ensures (A + S) + B == A + (S + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_5024","instance":5024,"id":208367,"goal":"lemma SetSubsetRefl_5024(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_5025","instance":5025,"id":208368,"goal":"lemma SetSubsetTrans_5025(S: set, A: set, B: set)\n requires S <= A && A <= B\n ensures S <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_5026","instance":5026,"id":208369,"goal":"lemma SetUnionEmpty_5026(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_5027","instance":5027,"id":208370,"goal":"lemma SetInterEmpty_5027(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_5028","instance":5028,"id":208371,"goal":"lemma SetInterSubset_5028(B: set, T: set)\n ensures B * T <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_5029","instance":5029,"id":208372,"goal":"lemma SetCardSubset_5029(B: set, A: set)\n requires B <= A\n ensures |B| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_5030","instance":5030,"id":208373,"goal":"lemma SetUnionCard_5030(T: set, A: set)\n requires T * A == {}\n ensures |T + A| == |T| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_5031","instance":5031,"id":208374,"goal":"lemma SetUnionComm_5031(A: set, B: set)\n ensures A + B == B + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_5032","instance":5032,"id":208375,"goal":"lemma SetInterComm_5032(S: set, A: set)\n ensures S * A == A * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_5033","instance":5033,"id":208376,"goal":"lemma SetUnionAssoc_5033(U: set, A: set, T: set)\n ensures (U + A) + T == U + (A + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_5034","instance":5034,"id":208377,"goal":"lemma SetSubsetRefl_5034(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_5035","instance":5035,"id":208378,"goal":"lemma SetSubsetTrans_5035(B: set, A: set, S: set)\n requires B <= A && A <= S\n ensures B <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_5036","instance":5036,"id":208379,"goal":"lemma SetUnionEmpty_5036(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_5037","instance":5037,"id":208380,"goal":"lemma SetInterEmpty_5037(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_5038","instance":5038,"id":208381,"goal":"lemma SetInterSubset_5038(U: set, S: set)\n ensures U * S <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_5039","instance":5039,"id":208382,"goal":"lemma SetCardSubset_5039(A: set, T: set)\n requires A <= T\n ensures |A| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_5040","instance":5040,"id":208383,"goal":"lemma SetUnionCard_5040(B: set, S: set)\n requires B * S == {}\n ensures |B + S| == |B| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_5041","instance":5041,"id":208384,"goal":"lemma SetUnionComm_5041(T: set, U: set)\n ensures T + U == U + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_5042","instance":5042,"id":208385,"goal":"lemma SetInterComm_5042(U: set, S: set)\n ensures U * S == S * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_5043","instance":5043,"id":208386,"goal":"lemma SetUnionAssoc_5043(B: set, U: set, A: set)\n ensures (B + U) + A == B + (U + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_5044","instance":5044,"id":208387,"goal":"lemma SetSubsetRefl_5044(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_5045","instance":5045,"id":208388,"goal":"lemma SetSubsetTrans_5045(S: set, U: set, A: set)\n requires S <= U && U <= A\n ensures S <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_5046","instance":5046,"id":208389,"goal":"lemma SetUnionEmpty_5046(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_5047","instance":5047,"id":208390,"goal":"lemma SetInterEmpty_5047(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_5048","instance":5048,"id":208391,"goal":"lemma SetInterSubset_5048(A: set, S: set)\n ensures A * S <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_5049","instance":5049,"id":208392,"goal":"lemma SetCardSubset_5049(T: set, A: set)\n requires T <= A\n ensures |T| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_5050","instance":5050,"id":208393,"goal":"lemma SetUnionCard_5050(U: set, A: set)\n requires U * A == {}\n ensures |U + A| == |U| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_5051","instance":5051,"id":208394,"goal":"lemma SetUnionComm_5051(A: set, T: set)\n ensures A + T == T + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_5052","instance":5052,"id":208395,"goal":"lemma SetInterComm_5052(U: set, S: set)\n ensures U * S == S * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_5053","instance":5053,"id":208396,"goal":"lemma SetUnionAssoc_5053(U: set, T: set, S: set)\n ensures (U + T) + S == U + (T + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_5054","instance":5054,"id":208397,"goal":"lemma SetSubsetRefl_5054(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_5055","instance":5055,"id":208398,"goal":"lemma SetSubsetTrans_5055(U: set, A: set, S: set)\n requires U <= A && A <= S\n ensures U <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_5056","instance":5056,"id":208399,"goal":"lemma SetUnionEmpty_5056(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_5057","instance":5057,"id":208400,"goal":"lemma SetInterEmpty_5057(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_5058","instance":5058,"id":208401,"goal":"lemma SetInterSubset_5058(B: set, S: set)\n ensures B * S <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_5059","instance":5059,"id":208402,"goal":"lemma SetCardSubset_5059(U: set, S: set)\n requires U <= S\n ensures |U| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_5060","instance":5060,"id":208403,"goal":"lemma SetUnionCard_5060(A: set, B: set)\n requires A * B == {}\n ensures |A + B| == |A| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_5061","instance":5061,"id":208404,"goal":"lemma SetUnionComm_5061(S: set, B: set)\n ensures S + B == B + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_5062","instance":5062,"id":208405,"goal":"lemma SetInterComm_5062(T: set, U: set)\n ensures T * U == U * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_5063","instance":5063,"id":208406,"goal":"lemma SetUnionAssoc_5063(A: set, B: set, S: set)\n ensures (A + B) + S == A + (B + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_5064","instance":5064,"id":208407,"goal":"lemma SetSubsetRefl_5064(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_5065","instance":5065,"id":208408,"goal":"lemma SetSubsetTrans_5065(T: set, B: set, S: set)\n requires T <= B && B <= S\n ensures T <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_5066","instance":5066,"id":208409,"goal":"lemma SetUnionEmpty_5066(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_5067","instance":5067,"id":208410,"goal":"lemma SetInterEmpty_5067(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_5068","instance":5068,"id":208411,"goal":"lemma SetInterSubset_5068(T: set, B: set)\n ensures T * B <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_5069","instance":5069,"id":208412,"goal":"lemma SetCardSubset_5069(A: set, B: set)\n requires A <= B\n ensures |A| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_5070","instance":5070,"id":208413,"goal":"lemma SetUnionCard_5070(B: set, S: set)\n requires B * S == {}\n ensures |B + S| == |B| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_5071","instance":5071,"id":208414,"goal":"lemma SetUnionComm_5071(B: set, S: set)\n ensures B + S == S + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_5072","instance":5072,"id":208415,"goal":"lemma SetInterComm_5072(B: set, A: set)\n ensures B * A == A * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_5073","instance":5073,"id":208416,"goal":"lemma SetUnionAssoc_5073(S: set, A: set, B: set)\n ensures (S + A) + B == S + (A + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_5074","instance":5074,"id":208417,"goal":"lemma SetSubsetRefl_5074(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_5075","instance":5075,"id":208418,"goal":"lemma SetSubsetTrans_5075(A: set, B: set, U: set)\n requires A <= B && B <= U\n ensures A <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_5076","instance":5076,"id":208419,"goal":"lemma SetUnionEmpty_5076(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_5077","instance":5077,"id":208420,"goal":"lemma SetInterEmpty_5077(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_5078","instance":5078,"id":208421,"goal":"lemma SetInterSubset_5078(S: set, T: set)\n ensures S * T <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_5079","instance":5079,"id":208422,"goal":"lemma SetCardSubset_5079(T: set, S: set)\n requires T <= S\n ensures |T| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_5080","instance":5080,"id":208423,"goal":"lemma SetUnionCard_5080(T: set, B: set)\n requires T * B == {}\n ensures |T + B| == |T| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_5081","instance":5081,"id":208424,"goal":"lemma SetUnionComm_5081(U: set, T: set)\n ensures U + T == T + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_5082","instance":5082,"id":208425,"goal":"lemma SetInterComm_5082(U: set, B: set)\n ensures U * B == B * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_5083","instance":5083,"id":208426,"goal":"lemma SetUnionAssoc_5083(S: set, B: set, A: set)\n ensures (S + B) + A == S + (B + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_5084","instance":5084,"id":208427,"goal":"lemma SetSubsetRefl_5084(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_5085","instance":5085,"id":208428,"goal":"lemma SetSubsetTrans_5085(T: set, A: set, B: set)\n requires T <= A && A <= B\n ensures T <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_5086","instance":5086,"id":208429,"goal":"lemma SetUnionEmpty_5086(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_5087","instance":5087,"id":208430,"goal":"lemma SetInterEmpty_5087(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_5088","instance":5088,"id":208431,"goal":"lemma SetInterSubset_5088(A: set, T: set)\n ensures A * T <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_5089","instance":5089,"id":208432,"goal":"lemma SetCardSubset_5089(A: set, B: set)\n requires A <= B\n ensures |A| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_5090","instance":5090,"id":208433,"goal":"lemma SetUnionCard_5090(S: set, B: set)\n requires S * B == {}\n ensures |S + B| == |S| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_5091","instance":5091,"id":208434,"goal":"lemma SetUnionComm_5091(B: set, T: set)\n ensures B + T == T + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_5092","instance":5092,"id":208435,"goal":"lemma SetInterComm_5092(S: set, B: set)\n ensures S * B == B * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_5093","instance":5093,"id":208436,"goal":"lemma SetUnionAssoc_5093(A: set, S: set, U: set)\n ensures (A + S) + U == A + (S + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_5094","instance":5094,"id":208437,"goal":"lemma SetSubsetRefl_5094(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_5095","instance":5095,"id":208438,"goal":"lemma SetSubsetTrans_5095(B: set, A: set, S: set)\n requires B <= A && A <= S\n ensures B <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_5096","instance":5096,"id":208439,"goal":"lemma SetUnionEmpty_5096(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_5097","instance":5097,"id":208440,"goal":"lemma SetInterEmpty_5097(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_5098","instance":5098,"id":208441,"goal":"lemma SetInterSubset_5098(A: set, S: set)\n ensures A * S <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_5099","instance":5099,"id":208442,"goal":"lemma SetCardSubset_5099(B: set, U: set)\n requires B <= U\n ensures |B| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_5100","instance":5100,"id":208443,"goal":"lemma SetUnionCard_5100(A: set, B: set)\n requires A * B == {}\n ensures |A + B| == |A| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_5101","instance":5101,"id":208444,"goal":"lemma SetUnionComm_5101(B: set, S: set)\n ensures B + S == S + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_5102","instance":5102,"id":208445,"goal":"lemma SetInterComm_5102(S: set, U: set)\n ensures S * U == U * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_5103","instance":5103,"id":208446,"goal":"lemma SetUnionAssoc_5103(U: set, B: set, T: set)\n ensures (U + B) + T == U + (B + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_5104","instance":5104,"id":208447,"goal":"lemma SetSubsetRefl_5104(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_5105","instance":5105,"id":208448,"goal":"lemma SetSubsetTrans_5105(T: set, B: set, S: set)\n requires T <= B && B <= S\n ensures T <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_5106","instance":5106,"id":208449,"goal":"lemma SetUnionEmpty_5106(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_5107","instance":5107,"id":208450,"goal":"lemma SetInterEmpty_5107(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_5108","instance":5108,"id":208451,"goal":"lemma SetInterSubset_5108(U: set, T: set)\n ensures U * T <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_5109","instance":5109,"id":208452,"goal":"lemma SetCardSubset_5109(U: set, S: set)\n requires U <= S\n ensures |U| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_5110","instance":5110,"id":208453,"goal":"lemma SetUnionCard_5110(U: set, B: set)\n requires U * B == {}\n ensures |U + B| == |U| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_5111","instance":5111,"id":208454,"goal":"lemma SetUnionComm_5111(B: set, A: set)\n ensures B + A == A + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_5112","instance":5112,"id":208455,"goal":"lemma SetInterComm_5112(B: set, T: set)\n ensures B * T == T * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_5113","instance":5113,"id":208456,"goal":"lemma SetUnionAssoc_5113(T: set, U: set, B: set)\n ensures (T + U) + B == T + (U + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_5114","instance":5114,"id":208457,"goal":"lemma SetSubsetRefl_5114(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_5115","instance":5115,"id":208458,"goal":"lemma SetSubsetTrans_5115(T: set, B: set, U: set)\n requires T <= B && B <= U\n ensures T <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_5116","instance":5116,"id":208459,"goal":"lemma SetUnionEmpty_5116(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_5117","instance":5117,"id":208460,"goal":"lemma SetInterEmpty_5117(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_5118","instance":5118,"id":208461,"goal":"lemma SetInterSubset_5118(B: set, U: set)\n ensures B * U <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_5119","instance":5119,"id":208462,"goal":"lemma SetCardSubset_5119(S: set, A: set)\n requires S <= A\n ensures |S| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_5120","instance":5120,"id":208463,"goal":"lemma SetUnionCard_5120(U: set, A: set)\n requires U * A == {}\n ensures |U + A| == |U| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_5121","instance":5121,"id":208464,"goal":"lemma SetUnionComm_5121(U: set, B: set)\n ensures U + B == B + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_5122","instance":5122,"id":208465,"goal":"lemma SetInterComm_5122(A: set, U: set)\n ensures A * U == U * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_5123","instance":5123,"id":208466,"goal":"lemma SetUnionAssoc_5123(T: set, U: set, A: set)\n ensures (T + U) + A == T + (U + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_5124","instance":5124,"id":208467,"goal":"lemma SetSubsetRefl_5124(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_5125","instance":5125,"id":208468,"goal":"lemma SetSubsetTrans_5125(S: set, B: set, A: set)\n requires S <= B && B <= A\n ensures S <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_5126","instance":5126,"id":208469,"goal":"lemma SetUnionEmpty_5126(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_5127","instance":5127,"id":208470,"goal":"lemma SetInterEmpty_5127(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_5128","instance":5128,"id":208471,"goal":"lemma SetInterSubset_5128(T: set, U: set)\n ensures T * U <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_5129","instance":5129,"id":208472,"goal":"lemma SetCardSubset_5129(U: set, B: set)\n requires U <= B\n ensures |U| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_5130","instance":5130,"id":208473,"goal":"lemma SetUnionCard_5130(U: set, T: set)\n requires U * T == {}\n ensures |U + T| == |U| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_5131","instance":5131,"id":208474,"goal":"lemma SetUnionComm_5131(T: set, A: set)\n ensures T + A == A + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_5132","instance":5132,"id":208475,"goal":"lemma SetInterComm_5132(T: set, A: set)\n ensures T * A == A * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_5133","instance":5133,"id":208476,"goal":"lemma SetUnionAssoc_5133(A: set, T: set, B: set)\n ensures (A + T) + B == A + (T + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_5134","instance":5134,"id":208477,"goal":"lemma SetSubsetRefl_5134(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_5135","instance":5135,"id":208478,"goal":"lemma SetSubsetTrans_5135(A: set, U: set, B: set)\n requires A <= U && U <= B\n ensures A <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_5136","instance":5136,"id":208479,"goal":"lemma SetUnionEmpty_5136(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_5137","instance":5137,"id":208480,"goal":"lemma SetInterEmpty_5137(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_5138","instance":5138,"id":208481,"goal":"lemma SetInterSubset_5138(U: set, S: set)\n ensures U * S <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_5139","instance":5139,"id":208482,"goal":"lemma SetCardSubset_5139(T: set, A: set)\n requires T <= A\n ensures |T| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_5140","instance":5140,"id":208483,"goal":"lemma SetUnionCard_5140(S: set, U: set)\n requires S * U == {}\n ensures |S + U| == |S| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_5141","instance":5141,"id":208484,"goal":"lemma SetUnionComm_5141(A: set, B: set)\n ensures A + B == B + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_5142","instance":5142,"id":208485,"goal":"lemma SetInterComm_5142(A: set, U: set)\n ensures A * U == U * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_5143","instance":5143,"id":208486,"goal":"lemma SetUnionAssoc_5143(A: set, T: set, S: set)\n ensures (A + T) + S == A + (T + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_5144","instance":5144,"id":208487,"goal":"lemma SetSubsetRefl_5144(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_5145","instance":5145,"id":208488,"goal":"lemma SetSubsetTrans_5145(A: set, B: set, S: set)\n requires A <= B && B <= S\n ensures A <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_5146","instance":5146,"id":208489,"goal":"lemma SetUnionEmpty_5146(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_5147","instance":5147,"id":208490,"goal":"lemma SetInterEmpty_5147(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_5148","instance":5148,"id":208491,"goal":"lemma SetInterSubset_5148(A: set, T: set)\n ensures A * T <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_5149","instance":5149,"id":208492,"goal":"lemma SetCardSubset_5149(U: set, A: set)\n requires U <= A\n ensures |U| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_5150","instance":5150,"id":208493,"goal":"lemma SetUnionCard_5150(S: set, A: set)\n requires S * A == {}\n ensures |S + A| == |S| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_5151","instance":5151,"id":208494,"goal":"lemma SetUnionComm_5151(U: set, A: set)\n ensures U + A == A + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_5152","instance":5152,"id":208495,"goal":"lemma SetInterComm_5152(T: set, A: set)\n ensures T * A == A * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_5153","instance":5153,"id":208496,"goal":"lemma SetUnionAssoc_5153(B: set, A: set, T: set)\n ensures (B + A) + T == B + (A + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_5154","instance":5154,"id":208497,"goal":"lemma SetSubsetRefl_5154(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_5155","instance":5155,"id":208498,"goal":"lemma SetSubsetTrans_5155(B: set, S: set, U: set)\n requires B <= S && S <= U\n ensures B <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_5156","instance":5156,"id":208499,"goal":"lemma SetUnionEmpty_5156(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_5157","instance":5157,"id":208500,"goal":"lemma SetInterEmpty_5157(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_5158","instance":5158,"id":208501,"goal":"lemma SetInterSubset_5158(T: set, S: set)\n ensures T * S <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_5159","instance":5159,"id":208502,"goal":"lemma SetCardSubset_5159(T: set, B: set)\n requires T <= B\n ensures |T| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_5160","instance":5160,"id":208503,"goal":"lemma SetUnionCard_5160(B: set, A: set)\n requires B * A == {}\n ensures |B + A| == |B| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_5161","instance":5161,"id":208504,"goal":"lemma SetUnionComm_5161(A: set, B: set)\n ensures A + B == B + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_5162","instance":5162,"id":208505,"goal":"lemma SetInterComm_5162(U: set, B: set)\n ensures U * B == B * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_5163","instance":5163,"id":208506,"goal":"lemma SetUnionAssoc_5163(B: set, A: set, U: set)\n ensures (B + A) + U == B + (A + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_5164","instance":5164,"id":208507,"goal":"lemma SetSubsetRefl_5164(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_5165","instance":5165,"id":208508,"goal":"lemma SetSubsetTrans_5165(B: set, A: set, U: set)\n requires B <= A && A <= U\n ensures B <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_5166","instance":5166,"id":208509,"goal":"lemma SetUnionEmpty_5166(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_5167","instance":5167,"id":208510,"goal":"lemma SetInterEmpty_5167(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_5168","instance":5168,"id":208511,"goal":"lemma SetInterSubset_5168(A: set, B: set)\n ensures A * B <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_5169","instance":5169,"id":208512,"goal":"lemma SetCardSubset_5169(S: set, B: set)\n requires S <= B\n ensures |S| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_5170","instance":5170,"id":208513,"goal":"lemma SetUnionCard_5170(S: set, A: set)\n requires S * A == {}\n ensures |S + A| == |S| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_5171","instance":5171,"id":208514,"goal":"lemma SetUnionComm_5171(A: set, S: set)\n ensures A + S == S + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_5172","instance":5172,"id":208515,"goal":"lemma SetInterComm_5172(S: set, A: set)\n ensures S * A == A * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_5173","instance":5173,"id":208516,"goal":"lemma SetUnionAssoc_5173(U: set, A: set, T: set)\n ensures (U + A) + T == U + (A + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_5174","instance":5174,"id":208517,"goal":"lemma SetSubsetRefl_5174(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_5175","instance":5175,"id":208518,"goal":"lemma SetSubsetTrans_5175(U: set, B: set, T: set)\n requires U <= B && B <= T\n ensures U <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_5176","instance":5176,"id":208519,"goal":"lemma SetUnionEmpty_5176(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_5177","instance":5177,"id":208520,"goal":"lemma SetInterEmpty_5177(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_5178","instance":5178,"id":208521,"goal":"lemma SetInterSubset_5178(S: set, T: set)\n ensures S * T <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_5179","instance":5179,"id":208522,"goal":"lemma SetCardSubset_5179(U: set, S: set)\n requires U <= S\n ensures |U| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_5180","instance":5180,"id":208523,"goal":"lemma SetUnionCard_5180(B: set, T: set)\n requires B * T == {}\n ensures |B + T| == |B| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_5181","instance":5181,"id":208524,"goal":"lemma SetUnionComm_5181(B: set, T: set)\n ensures B + T == T + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_5182","instance":5182,"id":208525,"goal":"lemma SetInterComm_5182(A: set, S: set)\n ensures A * S == S * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_5183","instance":5183,"id":208526,"goal":"lemma SetUnionAssoc_5183(B: set, U: set, A: set)\n ensures (B + U) + A == B + (U + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_5184","instance":5184,"id":208527,"goal":"lemma SetSubsetRefl_5184(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_5185","instance":5185,"id":208528,"goal":"lemma SetSubsetTrans_5185(S: set, T: set, A: set)\n requires S <= T && T <= A\n ensures S <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_5186","instance":5186,"id":208529,"goal":"lemma SetUnionEmpty_5186(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_5187","instance":5187,"id":208530,"goal":"lemma SetInterEmpty_5187(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_5188","instance":5188,"id":208531,"goal":"lemma SetInterSubset_5188(B: set, U: set)\n ensures B * U <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_5189","instance":5189,"id":208532,"goal":"lemma SetCardSubset_5189(T: set, U: set)\n requires T <= U\n ensures |T| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_5190","instance":5190,"id":208533,"goal":"lemma SetUnionCard_5190(B: set, A: set)\n requires B * A == {}\n ensures |B + A| == |B| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_5191","instance":5191,"id":208534,"goal":"lemma SetUnionComm_5191(S: set, T: set)\n ensures S + T == T + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_5192","instance":5192,"id":208535,"goal":"lemma SetInterComm_5192(B: set, U: set)\n ensures B * U == U * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_5193","instance":5193,"id":208536,"goal":"lemma SetUnionAssoc_5193(U: set, T: set, B: set)\n ensures (U + T) + B == U + (T + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_5194","instance":5194,"id":208537,"goal":"lemma SetSubsetRefl_5194(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_5195","instance":5195,"id":208538,"goal":"lemma SetSubsetTrans_5195(T: set, S: set, B: set)\n requires T <= S && S <= B\n ensures T <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_5196","instance":5196,"id":208539,"goal":"lemma SetUnionEmpty_5196(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_5197","instance":5197,"id":208540,"goal":"lemma SetInterEmpty_5197(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_5198","instance":5198,"id":208541,"goal":"lemma SetInterSubset_5198(U: set, A: set)\n ensures U * A <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_5199","instance":5199,"id":208542,"goal":"lemma SetCardSubset_5199(S: set, A: set)\n requires S <= A\n ensures |S| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_5200","instance":5200,"id":208543,"goal":"lemma SetUnionCard_5200(A: set, S: set)\n requires A * S == {}\n ensures |A + S| == |A| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_5201","instance":5201,"id":208544,"goal":"lemma SetUnionComm_5201(A: set, T: set)\n ensures A + T == T + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_5202","instance":5202,"id":208545,"goal":"lemma SetInterComm_5202(B: set, T: set)\n ensures B * T == T * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_5203","instance":5203,"id":208546,"goal":"lemma SetUnionAssoc_5203(A: set, U: set, T: set)\n ensures (A + U) + T == A + (U + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_5204","instance":5204,"id":208547,"goal":"lemma SetSubsetRefl_5204(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_5205","instance":5205,"id":208548,"goal":"lemma SetSubsetTrans_5205(S: set, A: set, U: set)\n requires S <= A && A <= U\n ensures S <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_5206","instance":5206,"id":208549,"goal":"lemma SetUnionEmpty_5206(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_5207","instance":5207,"id":208550,"goal":"lemma SetInterEmpty_5207(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_5208","instance":5208,"id":208551,"goal":"lemma SetInterSubset_5208(T: set, A: set)\n ensures T * A <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_5209","instance":5209,"id":208552,"goal":"lemma SetCardSubset_5209(B: set, A: set)\n requires B <= A\n ensures |B| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_5210","instance":5210,"id":208553,"goal":"lemma SetUnionCard_5210(A: set, B: set)\n requires A * B == {}\n ensures |A + B| == |A| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_5211","instance":5211,"id":208554,"goal":"lemma SetUnionComm_5211(U: set, S: set)\n ensures U + S == S + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_5212","instance":5212,"id":208555,"goal":"lemma SetInterComm_5212(U: set, B: set)\n ensures U * B == B * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_5213","instance":5213,"id":208556,"goal":"lemma SetUnionAssoc_5213(B: set, T: set, S: set)\n ensures (B + T) + S == B + (T + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_5214","instance":5214,"id":208557,"goal":"lemma SetSubsetRefl_5214(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_5215","instance":5215,"id":208558,"goal":"lemma SetSubsetTrans_5215(A: set, B: set, S: set)\n requires A <= B && B <= S\n ensures A <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_5216","instance":5216,"id":208559,"goal":"lemma SetUnionEmpty_5216(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_5217","instance":5217,"id":208560,"goal":"lemma SetInterEmpty_5217(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_5218","instance":5218,"id":208561,"goal":"lemma SetInterSubset_5218(U: set, A: set)\n ensures U * A <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_5219","instance":5219,"id":208562,"goal":"lemma SetCardSubset_5219(A: set, T: set)\n requires A <= T\n ensures |A| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_5220","instance":5220,"id":208563,"goal":"lemma SetUnionCard_5220(U: set, T: set)\n requires U * T == {}\n ensures |U + T| == |U| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_5221","instance":5221,"id":208564,"goal":"lemma SetUnionComm_5221(T: set, U: set)\n ensures T + U == U + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_5222","instance":5222,"id":208565,"goal":"lemma SetInterComm_5222(T: set, A: set)\n ensures T * A == A * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_5223","instance":5223,"id":208566,"goal":"lemma SetUnionAssoc_5223(S: set, B: set, U: set)\n ensures (S + B) + U == S + (B + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_5224","instance":5224,"id":208567,"goal":"lemma SetSubsetRefl_5224(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_5225","instance":5225,"id":208568,"goal":"lemma SetSubsetTrans_5225(B: set, A: set, T: set)\n requires B <= A && A <= T\n ensures B <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_5226","instance":5226,"id":208569,"goal":"lemma SetUnionEmpty_5226(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_5227","instance":5227,"id":208570,"goal":"lemma SetInterEmpty_5227(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_5228","instance":5228,"id":208571,"goal":"lemma SetInterSubset_5228(B: set, T: set)\n ensures B * T <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_5229","instance":5229,"id":208572,"goal":"lemma SetCardSubset_5229(A: set, U: set)\n requires A <= U\n ensures |A| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_5230","instance":5230,"id":208573,"goal":"lemma SetUnionCard_5230(S: set, U: set)\n requires S * U == {}\n ensures |S + U| == |S| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_5231","instance":5231,"id":208574,"goal":"lemma SetUnionComm_5231(S: set, T: set)\n ensures S + T == T + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_5232","instance":5232,"id":208575,"goal":"lemma SetInterComm_5232(B: set, U: set)\n ensures B * U == U * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_5233","instance":5233,"id":208576,"goal":"lemma SetUnionAssoc_5233(T: set, S: set, U: set)\n ensures (T + S) + U == T + (S + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_5234","instance":5234,"id":208577,"goal":"lemma SetSubsetRefl_5234(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_5235","instance":5235,"id":208578,"goal":"lemma SetSubsetTrans_5235(T: set, S: set, U: set)\n requires T <= S && S <= U\n ensures T <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_5236","instance":5236,"id":208579,"goal":"lemma SetUnionEmpty_5236(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_5237","instance":5237,"id":208580,"goal":"lemma SetInterEmpty_5237(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_5238","instance":5238,"id":208581,"goal":"lemma SetInterSubset_5238(S: set, B: set)\n ensures S * B <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_5239","instance":5239,"id":208582,"goal":"lemma SetCardSubset_5239(S: set, T: set)\n requires S <= T\n ensures |S| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_5240","instance":5240,"id":208583,"goal":"lemma SetUnionCard_5240(T: set, S: set)\n requires T * S == {}\n ensures |T + S| == |T| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_5241","instance":5241,"id":208584,"goal":"lemma SetUnionComm_5241(S: set, U: set)\n ensures S + U == U + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_5242","instance":5242,"id":208585,"goal":"lemma SetInterComm_5242(B: set, A: set)\n ensures B * A == A * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_5243","instance":5243,"id":208586,"goal":"lemma SetUnionAssoc_5243(S: set, A: set, T: set)\n ensures (S + A) + T == S + (A + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_5244","instance":5244,"id":208587,"goal":"lemma SetSubsetRefl_5244(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_5245","instance":5245,"id":208588,"goal":"lemma SetSubsetTrans_5245(B: set, T: set, S: set)\n requires B <= T && T <= S\n ensures B <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_5246","instance":5246,"id":208589,"goal":"lemma SetUnionEmpty_5246(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_5247","instance":5247,"id":208590,"goal":"lemma SetInterEmpty_5247(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_5248","instance":5248,"id":208591,"goal":"lemma SetInterSubset_5248(S: set, T: set)\n ensures S * T <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_5249","instance":5249,"id":208592,"goal":"lemma SetCardSubset_5249(A: set, S: set)\n requires A <= S\n ensures |A| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_5250","instance":5250,"id":208593,"goal":"lemma SetUnionCard_5250(U: set, A: set)\n requires U * A == {}\n ensures |U + A| == |U| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_5251","instance":5251,"id":208594,"goal":"lemma SetUnionComm_5251(S: set, B: set)\n ensures S + B == B + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_5252","instance":5252,"id":208595,"goal":"lemma SetInterComm_5252(B: set, A: set)\n ensures B * A == A * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_5253","instance":5253,"id":208596,"goal":"lemma SetUnionAssoc_5253(B: set, U: set, S: set)\n ensures (B + U) + S == B + (U + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_5254","instance":5254,"id":208597,"goal":"lemma SetSubsetRefl_5254(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_5255","instance":5255,"id":208598,"goal":"lemma SetSubsetTrans_5255(T: set, B: set, S: set)\n requires T <= B && B <= S\n ensures T <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_5256","instance":5256,"id":208599,"goal":"lemma SetUnionEmpty_5256(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_5257","instance":5257,"id":208600,"goal":"lemma SetInterEmpty_5257(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_5258","instance":5258,"id":208601,"goal":"lemma SetInterSubset_5258(U: set, S: set)\n ensures U * S <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_5259","instance":5259,"id":208602,"goal":"lemma SetCardSubset_5259(S: set, B: set)\n requires S <= B\n ensures |S| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_5260","instance":5260,"id":208603,"goal":"lemma SetUnionCard_5260(S: set, B: set)\n requires S * B == {}\n ensures |S + B| == |S| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_5261","instance":5261,"id":208604,"goal":"lemma SetUnionComm_5261(S: set, T: set)\n ensures S + T == T + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_5262","instance":5262,"id":208605,"goal":"lemma SetInterComm_5262(S: set, B: set)\n ensures S * B == B * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_5263","instance":5263,"id":208606,"goal":"lemma SetUnionAssoc_5263(T: set, B: set, A: set)\n ensures (T + B) + A == T + (B + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_5264","instance":5264,"id":208607,"goal":"lemma SetSubsetRefl_5264(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_5265","instance":5265,"id":208608,"goal":"lemma SetSubsetTrans_5265(B: set, S: set, T: set)\n requires B <= S && S <= T\n ensures B <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_5266","instance":5266,"id":208609,"goal":"lemma SetUnionEmpty_5266(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_5267","instance":5267,"id":208610,"goal":"lemma SetInterEmpty_5267(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_5268","instance":5268,"id":208611,"goal":"lemma SetInterSubset_5268(B: set, S: set)\n ensures B * S <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_5269","instance":5269,"id":208612,"goal":"lemma SetCardSubset_5269(T: set, B: set)\n requires T <= B\n ensures |T| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_5270","instance":5270,"id":208613,"goal":"lemma SetUnionCard_5270(T: set, B: set)\n requires T * B == {}\n ensures |T + B| == |T| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_5271","instance":5271,"id":208614,"goal":"lemma SetUnionComm_5271(U: set, T: set)\n ensures U + T == T + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_5272","instance":5272,"id":208615,"goal":"lemma SetInterComm_5272(S: set, T: set)\n ensures S * T == T * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_5273","instance":5273,"id":208616,"goal":"lemma SetUnionAssoc_5273(S: set, A: set, U: set)\n ensures (S + A) + U == S + (A + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_5274","instance":5274,"id":208617,"goal":"lemma SetSubsetRefl_5274(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_5275","instance":5275,"id":208618,"goal":"lemma SetSubsetTrans_5275(S: set, A: set, B: set)\n requires S <= A && A <= B\n ensures S <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_5276","instance":5276,"id":208619,"goal":"lemma SetUnionEmpty_5276(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_5277","instance":5277,"id":208620,"goal":"lemma SetInterEmpty_5277(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_5278","instance":5278,"id":208621,"goal":"lemma SetInterSubset_5278(T: set, U: set)\n ensures T * U <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_5279","instance":5279,"id":208622,"goal":"lemma SetCardSubset_5279(U: set, B: set)\n requires U <= B\n ensures |U| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_5280","instance":5280,"id":208623,"goal":"lemma SetUnionCard_5280(S: set, A: set)\n requires S * A == {}\n ensures |S + A| == |S| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_5281","instance":5281,"id":208624,"goal":"lemma SetUnionComm_5281(U: set, T: set)\n ensures U + T == T + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_5282","instance":5282,"id":208625,"goal":"lemma SetInterComm_5282(A: set, S: set)\n ensures A * S == S * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_5283","instance":5283,"id":208626,"goal":"lemma SetUnionAssoc_5283(B: set, A: set, S: set)\n ensures (B + A) + S == B + (A + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_5284","instance":5284,"id":208627,"goal":"lemma SetSubsetRefl_5284(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_5285","instance":5285,"id":208628,"goal":"lemma SetSubsetTrans_5285(U: set, B: set, A: set)\n requires U <= B && B <= A\n ensures U <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_5286","instance":5286,"id":208629,"goal":"lemma SetUnionEmpty_5286(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_5287","instance":5287,"id":208630,"goal":"lemma SetInterEmpty_5287(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_5288","instance":5288,"id":208631,"goal":"lemma SetInterSubset_5288(B: set, S: set)\n ensures B * S <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_5289","instance":5289,"id":208632,"goal":"lemma SetCardSubset_5289(S: set, A: set)\n requires S <= A\n ensures |S| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_5290","instance":5290,"id":208633,"goal":"lemma SetUnionCard_5290(A: set, U: set)\n requires A * U == {}\n ensures |A + U| == |A| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_5291","instance":5291,"id":208634,"goal":"lemma SetUnionComm_5291(B: set, A: set)\n ensures B + A == A + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_5292","instance":5292,"id":208635,"goal":"lemma SetInterComm_5292(A: set, T: set)\n ensures A * T == T * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_5293","instance":5293,"id":208636,"goal":"lemma SetUnionAssoc_5293(S: set, B: set, U: set)\n ensures (S + B) + U == S + (B + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_5294","instance":5294,"id":208637,"goal":"lemma SetSubsetRefl_5294(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_5295","instance":5295,"id":208638,"goal":"lemma SetSubsetTrans_5295(T: set, B: set, A: set)\n requires T <= B && B <= A\n ensures T <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_5296","instance":5296,"id":208639,"goal":"lemma SetUnionEmpty_5296(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_5297","instance":5297,"id":208640,"goal":"lemma SetInterEmpty_5297(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_5298","instance":5298,"id":208641,"goal":"lemma SetInterSubset_5298(U: set, B: set)\n ensures U * B <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_5299","instance":5299,"id":208642,"goal":"lemma SetCardSubset_5299(B: set, T: set)\n requires B <= T\n ensures |B| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_5300","instance":5300,"id":208643,"goal":"lemma SetUnionCard_5300(T: set, S: set)\n requires T * S == {}\n ensures |T + S| == |T| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_5301","instance":5301,"id":208644,"goal":"lemma SetUnionComm_5301(T: set, U: set)\n ensures T + U == U + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_5302","instance":5302,"id":208645,"goal":"lemma SetInterComm_5302(U: set, B: set)\n ensures U * B == B * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_5303","instance":5303,"id":208646,"goal":"lemma SetUnionAssoc_5303(T: set, S: set, U: set)\n ensures (T + S) + U == T + (S + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_5304","instance":5304,"id":208647,"goal":"lemma SetSubsetRefl_5304(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_5305","instance":5305,"id":208648,"goal":"lemma SetSubsetTrans_5305(B: set, S: set, T: set)\n requires B <= S && S <= T\n ensures B <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_5306","instance":5306,"id":208649,"goal":"lemma SetUnionEmpty_5306(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_5307","instance":5307,"id":208650,"goal":"lemma SetInterEmpty_5307(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_5308","instance":5308,"id":208651,"goal":"lemma SetInterSubset_5308(A: set, B: set)\n ensures A * B <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_5309","instance":5309,"id":208652,"goal":"lemma SetCardSubset_5309(S: set, U: set)\n requires S <= U\n ensures |S| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_5310","instance":5310,"id":208653,"goal":"lemma SetUnionCard_5310(U: set, A: set)\n requires U * A == {}\n ensures |U + A| == |U| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_5311","instance":5311,"id":208654,"goal":"lemma SetUnionComm_5311(T: set, A: set)\n ensures T + A == A + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_5312","instance":5312,"id":208655,"goal":"lemma SetInterComm_5312(S: set, A: set)\n ensures S * A == A * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_5313","instance":5313,"id":208656,"goal":"lemma SetUnionAssoc_5313(U: set, B: set, A: set)\n ensures (U + B) + A == U + (B + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_5314","instance":5314,"id":208657,"goal":"lemma SetSubsetRefl_5314(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_5315","instance":5315,"id":208658,"goal":"lemma SetSubsetTrans_5315(T: set, S: set, A: set)\n requires T <= S && S <= A\n ensures T <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_5316","instance":5316,"id":208659,"goal":"lemma SetUnionEmpty_5316(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_5317","instance":5317,"id":208660,"goal":"lemma SetInterEmpty_5317(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_5318","instance":5318,"id":208661,"goal":"lemma SetInterSubset_5318(T: set, S: set)\n ensures T * S <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_5319","instance":5319,"id":208662,"goal":"lemma SetCardSubset_5319(S: set, B: set)\n requires S <= B\n ensures |S| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_5320","instance":5320,"id":208663,"goal":"lemma SetUnionCard_5320(S: set, U: set)\n requires S * U == {}\n ensures |S + U| == |S| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_5321","instance":5321,"id":208664,"goal":"lemma SetUnionComm_5321(T: set, U: set)\n ensures T + U == U + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_5322","instance":5322,"id":208665,"goal":"lemma SetInterComm_5322(S: set, T: set)\n ensures S * T == T * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_5323","instance":5323,"id":208666,"goal":"lemma SetUnionAssoc_5323(U: set, B: set, A: set)\n ensures (U + B) + A == U + (B + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_5324","instance":5324,"id":208667,"goal":"lemma SetSubsetRefl_5324(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_5325","instance":5325,"id":208668,"goal":"lemma SetSubsetTrans_5325(S: set, B: set, A: set)\n requires S <= B && B <= A\n ensures S <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_5326","instance":5326,"id":208669,"goal":"lemma SetUnionEmpty_5326(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_5327","instance":5327,"id":208670,"goal":"lemma SetInterEmpty_5327(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_5328","instance":5328,"id":208671,"goal":"lemma SetInterSubset_5328(T: set, U: set)\n ensures T * U <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_5329","instance":5329,"id":208672,"goal":"lemma SetCardSubset_5329(B: set, A: set)\n requires B <= A\n ensures |B| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_5330","instance":5330,"id":208673,"goal":"lemma SetUnionCard_5330(B: set, A: set)\n requires B * A == {}\n ensures |B + A| == |B| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_5331","instance":5331,"id":208674,"goal":"lemma SetUnionComm_5331(U: set, B: set)\n ensures U + B == B + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_5332","instance":5332,"id":208675,"goal":"lemma SetInterComm_5332(B: set, A: set)\n ensures B * A == A * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_5333","instance":5333,"id":208676,"goal":"lemma SetUnionAssoc_5333(U: set, S: set, A: set)\n ensures (U + S) + A == U + (S + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_5334","instance":5334,"id":208677,"goal":"lemma SetSubsetRefl_5334(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_5335","instance":5335,"id":208678,"goal":"lemma SetSubsetTrans_5335(B: set, A: set, S: set)\n requires B <= A && A <= S\n ensures B <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_5336","instance":5336,"id":208679,"goal":"lemma SetUnionEmpty_5336(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_5337","instance":5337,"id":208680,"goal":"lemma SetInterEmpty_5337(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_5338","instance":5338,"id":208681,"goal":"lemma SetInterSubset_5338(S: set, U: set)\n ensures S * U <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_5339","instance":5339,"id":208682,"goal":"lemma SetCardSubset_5339(T: set, A: set)\n requires T <= A\n ensures |T| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_5340","instance":5340,"id":208683,"goal":"lemma SetUnionCard_5340(T: set, U: set)\n requires T * U == {}\n ensures |T + U| == |T| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_5341","instance":5341,"id":208684,"goal":"lemma SetUnionComm_5341(U: set, A: set)\n ensures U + A == A + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_5342","instance":5342,"id":208685,"goal":"lemma SetInterComm_5342(U: set, T: set)\n ensures U * T == T * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_5343","instance":5343,"id":208686,"goal":"lemma SetUnionAssoc_5343(B: set, A: set, S: set)\n ensures (B + A) + S == B + (A + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_5344","instance":5344,"id":208687,"goal":"lemma SetSubsetRefl_5344(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_5345","instance":5345,"id":208688,"goal":"lemma SetSubsetTrans_5345(S: set, B: set, A: set)\n requires S <= B && B <= A\n ensures S <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_5346","instance":5346,"id":208689,"goal":"lemma SetUnionEmpty_5346(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_5347","instance":5347,"id":208690,"goal":"lemma SetInterEmpty_5347(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_5348","instance":5348,"id":208691,"goal":"lemma SetInterSubset_5348(S: set, A: set)\n ensures S * A <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_5349","instance":5349,"id":208692,"goal":"lemma SetCardSubset_5349(A: set, B: set)\n requires A <= B\n ensures |A| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_5350","instance":5350,"id":208693,"goal":"lemma SetUnionCard_5350(S: set, U: set)\n requires S * U == {}\n ensures |S + U| == |S| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_5351","instance":5351,"id":208694,"goal":"lemma SetUnionComm_5351(U: set, T: set)\n ensures U + T == T + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_5352","instance":5352,"id":208695,"goal":"lemma SetInterComm_5352(B: set, S: set)\n ensures B * S == S * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_5353","instance":5353,"id":208696,"goal":"lemma SetUnionAssoc_5353(B: set, U: set, A: set)\n ensures (B + U) + A == B + (U + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_5354","instance":5354,"id":208697,"goal":"lemma SetSubsetRefl_5354(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_5355","instance":5355,"id":208698,"goal":"lemma SetSubsetTrans_5355(S: set, U: set, T: set)\n requires S <= U && U <= T\n ensures S <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_5356","instance":5356,"id":208699,"goal":"lemma SetUnionEmpty_5356(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_5357","instance":5357,"id":208700,"goal":"lemma SetInterEmpty_5357(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_5358","instance":5358,"id":208701,"goal":"lemma SetInterSubset_5358(T: set, B: set)\n ensures T * B <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_5359","instance":5359,"id":208702,"goal":"lemma SetCardSubset_5359(B: set, U: set)\n requires B <= U\n ensures |B| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_5360","instance":5360,"id":208703,"goal":"lemma SetUnionCard_5360(U: set, S: set)\n requires U * S == {}\n ensures |U + S| == |U| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_5361","instance":5361,"id":208704,"goal":"lemma SetUnionComm_5361(U: set, B: set)\n ensures U + B == B + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_5362","instance":5362,"id":208705,"goal":"lemma SetInterComm_5362(A: set, U: set)\n ensures A * U == U * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_5363","instance":5363,"id":208706,"goal":"lemma SetUnionAssoc_5363(U: set, B: set, T: set)\n ensures (U + B) + T == U + (B + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_5364","instance":5364,"id":208707,"goal":"lemma SetSubsetRefl_5364(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_5365","instance":5365,"id":208708,"goal":"lemma SetSubsetTrans_5365(B: set, S: set, U: set)\n requires B <= S && S <= U\n ensures B <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_5366","instance":5366,"id":208709,"goal":"lemma SetUnionEmpty_5366(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_5367","instance":5367,"id":208710,"goal":"lemma SetInterEmpty_5367(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_5368","instance":5368,"id":208711,"goal":"lemma SetInterSubset_5368(A: set, S: set)\n ensures A * S <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_5369","instance":5369,"id":208712,"goal":"lemma SetCardSubset_5369(T: set, S: set)\n requires T <= S\n ensures |T| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_5370","instance":5370,"id":208713,"goal":"lemma SetUnionCard_5370(A: set, B: set)\n requires A * B == {}\n ensures |A + B| == |A| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_5371","instance":5371,"id":208714,"goal":"lemma SetUnionComm_5371(T: set, S: set)\n ensures T + S == S + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_5372","instance":5372,"id":208715,"goal":"lemma SetInterComm_5372(T: set, U: set)\n ensures T * U == U * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_5373","instance":5373,"id":208716,"goal":"lemma SetUnionAssoc_5373(B: set, S: set, U: set)\n ensures (B + S) + U == B + (S + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_5374","instance":5374,"id":208717,"goal":"lemma SetSubsetRefl_5374(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_5375","instance":5375,"id":208718,"goal":"lemma SetSubsetTrans_5375(S: set, T: set, B: set)\n requires S <= T && T <= B\n ensures S <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_5376","instance":5376,"id":208719,"goal":"lemma SetUnionEmpty_5376(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_5377","instance":5377,"id":208720,"goal":"lemma SetInterEmpty_5377(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_5378","instance":5378,"id":208721,"goal":"lemma SetInterSubset_5378(S: set, B: set)\n ensures S * B <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_5379","instance":5379,"id":208722,"goal":"lemma SetCardSubset_5379(T: set, S: set)\n requires T <= S\n ensures |T| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_5380","instance":5380,"id":208723,"goal":"lemma SetUnionCard_5380(S: set, B: set)\n requires S * B == {}\n ensures |S + B| == |S| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_5381","instance":5381,"id":208724,"goal":"lemma SetUnionComm_5381(T: set, A: set)\n ensures T + A == A + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_5382","instance":5382,"id":208725,"goal":"lemma SetInterComm_5382(A: set, B: set)\n ensures A * B == B * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_5383","instance":5383,"id":208726,"goal":"lemma SetUnionAssoc_5383(U: set, A: set, B: set)\n ensures (U + A) + B == U + (A + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_5384","instance":5384,"id":208727,"goal":"lemma SetSubsetRefl_5384(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_5385","instance":5385,"id":208728,"goal":"lemma SetSubsetTrans_5385(A: set, T: set, U: set)\n requires A <= T && T <= U\n ensures A <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_5386","instance":5386,"id":208729,"goal":"lemma SetUnionEmpty_5386(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_5387","instance":5387,"id":208730,"goal":"lemma SetInterEmpty_5387(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_5388","instance":5388,"id":208731,"goal":"lemma SetInterSubset_5388(U: set, T: set)\n ensures U * T <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_5389","instance":5389,"id":208732,"goal":"lemma SetCardSubset_5389(A: set, S: set)\n requires A <= S\n ensures |A| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_5390","instance":5390,"id":208733,"goal":"lemma SetUnionCard_5390(A: set, U: set)\n requires A * U == {}\n ensures |A + U| == |A| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_5391","instance":5391,"id":208734,"goal":"lemma SetUnionComm_5391(T: set, B: set)\n ensures T + B == B + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_5392","instance":5392,"id":208735,"goal":"lemma SetInterComm_5392(S: set, T: set)\n ensures S * T == T * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_5393","instance":5393,"id":208736,"goal":"lemma SetUnionAssoc_5393(A: set, T: set, S: set)\n ensures (A + T) + S == A + (T + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_5394","instance":5394,"id":208737,"goal":"lemma SetSubsetRefl_5394(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_5395","instance":5395,"id":208738,"goal":"lemma SetSubsetTrans_5395(B: set, S: set, A: set)\n requires B <= S && S <= A\n ensures B <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_5396","instance":5396,"id":208739,"goal":"lemma SetUnionEmpty_5396(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_5397","instance":5397,"id":208740,"goal":"lemma SetInterEmpty_5397(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_5398","instance":5398,"id":208741,"goal":"lemma SetInterSubset_5398(A: set, U: set)\n ensures A * U <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_5399","instance":5399,"id":208742,"goal":"lemma SetCardSubset_5399(U: set, T: set)\n requires U <= T\n ensures |U| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_5400","instance":5400,"id":208743,"goal":"lemma SetUnionCard_5400(A: set, B: set)\n requires A * B == {}\n ensures |A + B| == |A| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_5401","instance":5401,"id":208744,"goal":"lemma SetUnionComm_5401(S: set, B: set)\n ensures S + B == B + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_5402","instance":5402,"id":208745,"goal":"lemma SetInterComm_5402(A: set, B: set)\n ensures A * B == B * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_5403","instance":5403,"id":208746,"goal":"lemma SetUnionAssoc_5403(A: set, U: set, S: set)\n ensures (A + U) + S == A + (U + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_5404","instance":5404,"id":208747,"goal":"lemma SetSubsetRefl_5404(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_5405","instance":5405,"id":208748,"goal":"lemma SetSubsetTrans_5405(A: set, B: set, T: set)\n requires A <= B && B <= T\n ensures A <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_5406","instance":5406,"id":208749,"goal":"lemma SetUnionEmpty_5406(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_5407","instance":5407,"id":208750,"goal":"lemma SetInterEmpty_5407(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_5408","instance":5408,"id":208751,"goal":"lemma SetInterSubset_5408(S: set, A: set)\n ensures S * A <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_5409","instance":5409,"id":208752,"goal":"lemma SetCardSubset_5409(T: set, B: set)\n requires T <= B\n ensures |T| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_5410","instance":5410,"id":208753,"goal":"lemma SetUnionCard_5410(A: set, S: set)\n requires A * S == {}\n ensures |A + S| == |A| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_5411","instance":5411,"id":208754,"goal":"lemma SetUnionComm_5411(T: set, A: set)\n ensures T + A == A + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_5412","instance":5412,"id":208755,"goal":"lemma SetInterComm_5412(A: set, B: set)\n ensures A * B == B * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_5413","instance":5413,"id":208756,"goal":"lemma SetUnionAssoc_5413(B: set, A: set, U: set)\n ensures (B + A) + U == B + (A + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_5414","instance":5414,"id":208757,"goal":"lemma SetSubsetRefl_5414(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_5415","instance":5415,"id":208758,"goal":"lemma SetSubsetTrans_5415(U: set, B: set, S: set)\n requires U <= B && B <= S\n ensures U <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_5416","instance":5416,"id":208759,"goal":"lemma SetUnionEmpty_5416(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_5417","instance":5417,"id":208760,"goal":"lemma SetInterEmpty_5417(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_5418","instance":5418,"id":208761,"goal":"lemma SetInterSubset_5418(S: set, B: set)\n ensures S * B <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_5419","instance":5419,"id":208762,"goal":"lemma SetCardSubset_5419(B: set, S: set)\n requires B <= S\n ensures |B| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_5420","instance":5420,"id":208763,"goal":"lemma SetUnionCard_5420(T: set, A: set)\n requires T * A == {}\n ensures |T + A| == |T| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_5421","instance":5421,"id":208764,"goal":"lemma SetUnionComm_5421(B: set, U: set)\n ensures B + U == U + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_5422","instance":5422,"id":208765,"goal":"lemma SetInterComm_5422(U: set, A: set)\n ensures U * A == A * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_5423","instance":5423,"id":208766,"goal":"lemma SetUnionAssoc_5423(U: set, B: set, S: set)\n ensures (U + B) + S == U + (B + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_5424","instance":5424,"id":208767,"goal":"lemma SetSubsetRefl_5424(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_5425","instance":5425,"id":208768,"goal":"lemma SetSubsetTrans_5425(S: set, U: set, B: set)\n requires S <= U && U <= B\n ensures S <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_5426","instance":5426,"id":208769,"goal":"lemma SetUnionEmpty_5426(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_5427","instance":5427,"id":208770,"goal":"lemma SetInterEmpty_5427(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_5428","instance":5428,"id":208771,"goal":"lemma SetInterSubset_5428(T: set, U: set)\n ensures T * U <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_5429","instance":5429,"id":208772,"goal":"lemma SetCardSubset_5429(T: set, A: set)\n requires T <= A\n ensures |T| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_5430","instance":5430,"id":208773,"goal":"lemma SetUnionCard_5430(U: set, B: set)\n requires U * B == {}\n ensures |U + B| == |U| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_5431","instance":5431,"id":208774,"goal":"lemma SetUnionComm_5431(B: set, U: set)\n ensures B + U == U + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_5432","instance":5432,"id":208775,"goal":"lemma SetInterComm_5432(B: set, A: set)\n ensures B * A == A * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_5433","instance":5433,"id":208776,"goal":"lemma SetUnionAssoc_5433(S: set, A: set, T: set)\n ensures (S + A) + T == S + (A + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_5434","instance":5434,"id":208777,"goal":"lemma SetSubsetRefl_5434(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_5435","instance":5435,"id":208778,"goal":"lemma SetSubsetTrans_5435(T: set, A: set, B: set)\n requires T <= A && A <= B\n ensures T <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_5436","instance":5436,"id":208779,"goal":"lemma SetUnionEmpty_5436(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_5437","instance":5437,"id":208780,"goal":"lemma SetInterEmpty_5437(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_5438","instance":5438,"id":208781,"goal":"lemma SetInterSubset_5438(T: set, A: set)\n ensures T * A <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_5439","instance":5439,"id":208782,"goal":"lemma SetCardSubset_5439(B: set, U: set)\n requires B <= U\n ensures |B| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_5440","instance":5440,"id":208783,"goal":"lemma SetUnionCard_5440(U: set, T: set)\n requires U * T == {}\n ensures |U + T| == |U| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_5441","instance":5441,"id":208784,"goal":"lemma SetUnionComm_5441(T: set, S: set)\n ensures T + S == S + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_5442","instance":5442,"id":208785,"goal":"lemma SetInterComm_5442(A: set, S: set)\n ensures A * S == S * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_5443","instance":5443,"id":208786,"goal":"lemma SetUnionAssoc_5443(U: set, T: set, S: set)\n ensures (U + T) + S == U + (T + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_5444","instance":5444,"id":208787,"goal":"lemma SetSubsetRefl_5444(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_5445","instance":5445,"id":208788,"goal":"lemma SetSubsetTrans_5445(B: set, A: set, U: set)\n requires B <= A && A <= U\n ensures B <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_5446","instance":5446,"id":208789,"goal":"lemma SetUnionEmpty_5446(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_5447","instance":5447,"id":208790,"goal":"lemma SetInterEmpty_5447(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_5448","instance":5448,"id":208791,"goal":"lemma SetInterSubset_5448(A: set, U: set)\n ensures A * U <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_5449","instance":5449,"id":208792,"goal":"lemma SetCardSubset_5449(S: set, A: set)\n requires S <= A\n ensures |S| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_5450","instance":5450,"id":208793,"goal":"lemma SetUnionCard_5450(B: set, T: set)\n requires B * T == {}\n ensures |B + T| == |B| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_5451","instance":5451,"id":208794,"goal":"lemma SetUnionComm_5451(S: set, U: set)\n ensures S + U == U + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_5452","instance":5452,"id":208795,"goal":"lemma SetInterComm_5452(S: set, B: set)\n ensures S * B == B * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_5453","instance":5453,"id":208796,"goal":"lemma SetUnionAssoc_5453(A: set, T: set, S: set)\n ensures (A + T) + S == A + (T + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_5454","instance":5454,"id":208797,"goal":"lemma SetSubsetRefl_5454(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_5455","instance":5455,"id":208798,"goal":"lemma SetSubsetTrans_5455(U: set, T: set, S: set)\n requires U <= T && T <= S\n ensures U <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_5456","instance":5456,"id":208799,"goal":"lemma SetUnionEmpty_5456(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_5457","instance":5457,"id":208800,"goal":"lemma SetInterEmpty_5457(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_5458","instance":5458,"id":208801,"goal":"lemma SetInterSubset_5458(S: set, A: set)\n ensures S * A <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_5459","instance":5459,"id":208802,"goal":"lemma SetCardSubset_5459(T: set, B: set)\n requires T <= B\n ensures |T| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_5460","instance":5460,"id":208803,"goal":"lemma SetUnionCard_5460(S: set, T: set)\n requires S * T == {}\n ensures |S + T| == |S| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_5461","instance":5461,"id":208804,"goal":"lemma SetUnionComm_5461(S: set, B: set)\n ensures S + B == B + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_5462","instance":5462,"id":208805,"goal":"lemma SetInterComm_5462(S: set, U: set)\n ensures S * U == U * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_5463","instance":5463,"id":208806,"goal":"lemma SetUnionAssoc_5463(T: set, A: set, S: set)\n ensures (T + A) + S == T + (A + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_5464","instance":5464,"id":208807,"goal":"lemma SetSubsetRefl_5464(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_5465","instance":5465,"id":208808,"goal":"lemma SetSubsetTrans_5465(A: set, S: set, U: set)\n requires A <= S && S <= U\n ensures A <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_5466","instance":5466,"id":208809,"goal":"lemma SetUnionEmpty_5466(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_5467","instance":5467,"id":208810,"goal":"lemma SetInterEmpty_5467(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_5468","instance":5468,"id":208811,"goal":"lemma SetInterSubset_5468(A: set, T: set)\n ensures A * T <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_5469","instance":5469,"id":208812,"goal":"lemma SetCardSubset_5469(T: set, S: set)\n requires T <= S\n ensures |T| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_5470","instance":5470,"id":208813,"goal":"lemma SetUnionCard_5470(T: set, A: set)\n requires T * A == {}\n ensures |T + A| == |T| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_5471","instance":5471,"id":208814,"goal":"lemma SetUnionComm_5471(A: set, B: set)\n ensures A + B == B + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_5472","instance":5472,"id":208815,"goal":"lemma SetInterComm_5472(U: set, A: set)\n ensures U * A == A * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_5473","instance":5473,"id":208816,"goal":"lemma SetUnionAssoc_5473(U: set, S: set, T: set)\n ensures (U + S) + T == U + (S + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_5474","instance":5474,"id":208817,"goal":"lemma SetSubsetRefl_5474(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_5475","instance":5475,"id":208818,"goal":"lemma SetSubsetTrans_5475(T: set, A: set, B: set)\n requires T <= A && A <= B\n ensures T <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_5476","instance":5476,"id":208819,"goal":"lemma SetUnionEmpty_5476(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_5477","instance":5477,"id":208820,"goal":"lemma SetInterEmpty_5477(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_5478","instance":5478,"id":208821,"goal":"lemma SetInterSubset_5478(B: set, U: set)\n ensures B * U <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_5479","instance":5479,"id":208822,"goal":"lemma SetCardSubset_5479(T: set, U: set)\n requires T <= U\n ensures |T| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_5480","instance":5480,"id":208823,"goal":"lemma SetUnionCard_5480(U: set, A: set)\n requires U * A == {}\n ensures |U + A| == |U| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_5481","instance":5481,"id":208824,"goal":"lemma SetUnionComm_5481(B: set, U: set)\n ensures B + U == U + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_5482","instance":5482,"id":208825,"goal":"lemma SetInterComm_5482(S: set, T: set)\n ensures S * T == T * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_5483","instance":5483,"id":208826,"goal":"lemma SetUnionAssoc_5483(A: set, U: set, T: set)\n ensures (A + U) + T == A + (U + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_5484","instance":5484,"id":208827,"goal":"lemma SetSubsetRefl_5484(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_5485","instance":5485,"id":208828,"goal":"lemma SetSubsetTrans_5485(A: set, B: set, U: set)\n requires A <= B && B <= U\n ensures A <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_5486","instance":5486,"id":208829,"goal":"lemma SetUnionEmpty_5486(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_5487","instance":5487,"id":208830,"goal":"lemma SetInterEmpty_5487(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_5488","instance":5488,"id":208831,"goal":"lemma SetInterSubset_5488(S: set, A: set)\n ensures S * A <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_5489","instance":5489,"id":208832,"goal":"lemma SetCardSubset_5489(A: set, B: set)\n requires A <= B\n ensures |A| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_5490","instance":5490,"id":208833,"goal":"lemma SetUnionCard_5490(S: set, A: set)\n requires S * A == {}\n ensures |S + A| == |S| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_5491","instance":5491,"id":208834,"goal":"lemma SetUnionComm_5491(B: set, U: set)\n ensures B + U == U + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_5492","instance":5492,"id":208835,"goal":"lemma SetInterComm_5492(S: set, U: set)\n ensures S * U == U * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_5493","instance":5493,"id":208836,"goal":"lemma SetUnionAssoc_5493(S: set, T: set, A: set)\n ensures (S + T) + A == S + (T + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_5494","instance":5494,"id":208837,"goal":"lemma SetSubsetRefl_5494(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_5495","instance":5495,"id":208838,"goal":"lemma SetSubsetTrans_5495(U: set, S: set, B: set)\n requires U <= S && S <= B\n ensures U <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_5496","instance":5496,"id":208839,"goal":"lemma SetUnionEmpty_5496(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_5497","instance":5497,"id":208840,"goal":"lemma SetInterEmpty_5497(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_5498","instance":5498,"id":208841,"goal":"lemma SetInterSubset_5498(T: set, U: set)\n ensures T * U <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_5499","instance":5499,"id":208842,"goal":"lemma SetCardSubset_5499(B: set, S: set)\n requires B <= S\n ensures |B| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_5500","instance":5500,"id":208843,"goal":"lemma SetUnionCard_5500(T: set, A: set)\n requires T * A == {}\n ensures |T + A| == |T| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_5501","instance":5501,"id":208844,"goal":"lemma SetUnionComm_5501(A: set, S: set)\n ensures A + S == S + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_5502","instance":5502,"id":208845,"goal":"lemma SetInterComm_5502(T: set, B: set)\n ensures T * B == B * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_5503","instance":5503,"id":208846,"goal":"lemma SetUnionAssoc_5503(A: set, T: set, B: set)\n ensures (A + T) + B == A + (T + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_5504","instance":5504,"id":208847,"goal":"lemma SetSubsetRefl_5504(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_5505","instance":5505,"id":208848,"goal":"lemma SetSubsetTrans_5505(A: set, B: set, T: set)\n requires A <= B && B <= T\n ensures A <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_5506","instance":5506,"id":208849,"goal":"lemma SetUnionEmpty_5506(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_5507","instance":5507,"id":208850,"goal":"lemma SetInterEmpty_5507(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_5508","instance":5508,"id":208851,"goal":"lemma SetInterSubset_5508(S: set, B: set)\n ensures S * B <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_5509","instance":5509,"id":208852,"goal":"lemma SetCardSubset_5509(B: set, U: set)\n requires B <= U\n ensures |B| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_5510","instance":5510,"id":208853,"goal":"lemma SetUnionCard_5510(T: set, U: set)\n requires T * U == {}\n ensures |T + U| == |T| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_5511","instance":5511,"id":208854,"goal":"lemma SetUnionComm_5511(S: set, B: set)\n ensures S + B == B + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_5512","instance":5512,"id":208855,"goal":"lemma SetInterComm_5512(T: set, A: set)\n ensures T * A == A * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_5513","instance":5513,"id":208856,"goal":"lemma SetUnionAssoc_5513(A: set, U: set, T: set)\n ensures (A + U) + T == A + (U + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_5514","instance":5514,"id":208857,"goal":"lemma SetSubsetRefl_5514(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_5515","instance":5515,"id":208858,"goal":"lemma SetSubsetTrans_5515(B: set, S: set, T: set)\n requires B <= S && S <= T\n ensures B <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_5516","instance":5516,"id":208859,"goal":"lemma SetUnionEmpty_5516(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_5517","instance":5517,"id":208860,"goal":"lemma SetInterEmpty_5517(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_5518","instance":5518,"id":208861,"goal":"lemma SetInterSubset_5518(S: set, B: set)\n ensures S * B <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_5519","instance":5519,"id":208862,"goal":"lemma SetCardSubset_5519(A: set, U: set)\n requires A <= U\n ensures |A| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_5520","instance":5520,"id":208863,"goal":"lemma SetUnionCard_5520(A: set, S: set)\n requires A * S == {}\n ensures |A + S| == |A| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_5521","instance":5521,"id":208864,"goal":"lemma SetUnionComm_5521(S: set, U: set)\n ensures S + U == U + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_5522","instance":5522,"id":208865,"goal":"lemma SetInterComm_5522(S: set, U: set)\n ensures S * U == U * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_5523","instance":5523,"id":208866,"goal":"lemma SetUnionAssoc_5523(B: set, U: set, S: set)\n ensures (B + U) + S == B + (U + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_5524","instance":5524,"id":208867,"goal":"lemma SetSubsetRefl_5524(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_5525","instance":5525,"id":208868,"goal":"lemma SetSubsetTrans_5525(U: set, B: set, T: set)\n requires U <= B && B <= T\n ensures U <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_5526","instance":5526,"id":208869,"goal":"lemma SetUnionEmpty_5526(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_5527","instance":5527,"id":208870,"goal":"lemma SetInterEmpty_5527(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_5528","instance":5528,"id":208871,"goal":"lemma SetInterSubset_5528(T: set, B: set)\n ensures T * B <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_5529","instance":5529,"id":208872,"goal":"lemma SetCardSubset_5529(T: set, S: set)\n requires T <= S\n ensures |T| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_5530","instance":5530,"id":208873,"goal":"lemma SetUnionCard_5530(A: set, U: set)\n requires A * U == {}\n ensures |A + U| == |A| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_5531","instance":5531,"id":208874,"goal":"lemma SetUnionComm_5531(T: set, A: set)\n ensures T + A == A + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_5532","instance":5532,"id":208875,"goal":"lemma SetInterComm_5532(A: set, U: set)\n ensures A * U == U * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_5533","instance":5533,"id":208876,"goal":"lemma SetUnionAssoc_5533(U: set, B: set, T: set)\n ensures (U + B) + T == U + (B + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_5534","instance":5534,"id":208877,"goal":"lemma SetSubsetRefl_5534(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_5535","instance":5535,"id":208878,"goal":"lemma SetSubsetTrans_5535(S: set, A: set, B: set)\n requires S <= A && A <= B\n ensures S <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_5536","instance":5536,"id":208879,"goal":"lemma SetUnionEmpty_5536(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_5537","instance":5537,"id":208880,"goal":"lemma SetInterEmpty_5537(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_5538","instance":5538,"id":208881,"goal":"lemma SetInterSubset_5538(A: set, U: set)\n ensures A * U <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_5539","instance":5539,"id":208882,"goal":"lemma SetCardSubset_5539(U: set, A: set)\n requires U <= A\n ensures |U| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_5540","instance":5540,"id":208883,"goal":"lemma SetUnionCard_5540(A: set, U: set)\n requires A * U == {}\n ensures |A + U| == |A| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_5541","instance":5541,"id":208884,"goal":"lemma SetUnionComm_5541(T: set, A: set)\n ensures T + A == A + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_5542","instance":5542,"id":208885,"goal":"lemma SetInterComm_5542(A: set, S: set)\n ensures A * S == S * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_5543","instance":5543,"id":208886,"goal":"lemma SetUnionAssoc_5543(B: set, S: set, A: set)\n ensures (B + S) + A == B + (S + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_5544","instance":5544,"id":208887,"goal":"lemma SetSubsetRefl_5544(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_5545","instance":5545,"id":208888,"goal":"lemma SetSubsetTrans_5545(T: set, U: set, S: set)\n requires T <= U && U <= S\n ensures T <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_5546","instance":5546,"id":208889,"goal":"lemma SetUnionEmpty_5546(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_5547","instance":5547,"id":208890,"goal":"lemma SetInterEmpty_5547(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_5548","instance":5548,"id":208891,"goal":"lemma SetInterSubset_5548(S: set, T: set)\n ensures S * T <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_5549","instance":5549,"id":208892,"goal":"lemma SetCardSubset_5549(S: set, A: set)\n requires S <= A\n ensures |S| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_5550","instance":5550,"id":208893,"goal":"lemma SetUnionCard_5550(A: set, S: set)\n requires A * S == {}\n ensures |A + S| == |A| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_5551","instance":5551,"id":208894,"goal":"lemma SetUnionComm_5551(A: set, T: set)\n ensures A + T == T + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_5552","instance":5552,"id":208895,"goal":"lemma SetInterComm_5552(U: set, T: set)\n ensures U * T == T * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_5553","instance":5553,"id":208896,"goal":"lemma SetUnionAssoc_5553(S: set, A: set, T: set)\n ensures (S + A) + T == S + (A + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_5554","instance":5554,"id":208897,"goal":"lemma SetSubsetRefl_5554(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_5555","instance":5555,"id":208898,"goal":"lemma SetSubsetTrans_5555(T: set, B: set, U: set)\n requires T <= B && B <= U\n ensures T <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_5556","instance":5556,"id":208899,"goal":"lemma SetUnionEmpty_5556(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_5557","instance":5557,"id":208900,"goal":"lemma SetInterEmpty_5557(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_5558","instance":5558,"id":208901,"goal":"lemma SetInterSubset_5558(S: set, U: set)\n ensures S * U <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_5559","instance":5559,"id":208902,"goal":"lemma SetCardSubset_5559(T: set, S: set)\n requires T <= S\n ensures |T| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_5560","instance":5560,"id":208903,"goal":"lemma SetUnionCard_5560(T: set, U: set)\n requires T * U == {}\n ensures |T + U| == |T| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_5561","instance":5561,"id":208904,"goal":"lemma SetUnionComm_5561(S: set, U: set)\n ensures S + U == U + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_5562","instance":5562,"id":208905,"goal":"lemma SetInterComm_5562(U: set, A: set)\n ensures U * A == A * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_5563","instance":5563,"id":208906,"goal":"lemma SetUnionAssoc_5563(B: set, S: set, A: set)\n ensures (B + S) + A == B + (S + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_5564","instance":5564,"id":208907,"goal":"lemma SetSubsetRefl_5564(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_5565","instance":5565,"id":208908,"goal":"lemma SetSubsetTrans_5565(T: set, S: set, B: set)\n requires T <= S && S <= B\n ensures T <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_5566","instance":5566,"id":208909,"goal":"lemma SetUnionEmpty_5566(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_5567","instance":5567,"id":208910,"goal":"lemma SetInterEmpty_5567(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_5568","instance":5568,"id":208911,"goal":"lemma SetInterSubset_5568(S: set, U: set)\n ensures S * U <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_5569","instance":5569,"id":208912,"goal":"lemma SetCardSubset_5569(B: set, S: set)\n requires B <= S\n ensures |B| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_5570","instance":5570,"id":208913,"goal":"lemma SetUnionCard_5570(S: set, B: set)\n requires S * B == {}\n ensures |S + B| == |S| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_5571","instance":5571,"id":208914,"goal":"lemma SetUnionComm_5571(T: set, S: set)\n ensures T + S == S + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_5572","instance":5572,"id":208915,"goal":"lemma SetInterComm_5572(T: set, U: set)\n ensures T * U == U * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_5573","instance":5573,"id":208916,"goal":"lemma SetUnionAssoc_5573(S: set, B: set, A: set)\n ensures (S + B) + A == S + (B + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_5574","instance":5574,"id":208917,"goal":"lemma SetSubsetRefl_5574(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_5575","instance":5575,"id":208918,"goal":"lemma SetSubsetTrans_5575(A: set, T: set, U: set)\n requires A <= T && T <= U\n ensures A <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_5576","instance":5576,"id":208919,"goal":"lemma SetUnionEmpty_5576(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_5577","instance":5577,"id":208920,"goal":"lemma SetInterEmpty_5577(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_5578","instance":5578,"id":208921,"goal":"lemma SetInterSubset_5578(A: set, S: set)\n ensures A * S <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_5579","instance":5579,"id":208922,"goal":"lemma SetCardSubset_5579(B: set, T: set)\n requires B <= T\n ensures |B| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_5580","instance":5580,"id":208923,"goal":"lemma SetUnionCard_5580(A: set, B: set)\n requires A * B == {}\n ensures |A + B| == |A| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_5581","instance":5581,"id":208924,"goal":"lemma SetUnionComm_5581(A: set, B: set)\n ensures A + B == B + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_5582","instance":5582,"id":208925,"goal":"lemma SetInterComm_5582(A: set, U: set)\n ensures A * U == U * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_5583","instance":5583,"id":208926,"goal":"lemma SetUnionAssoc_5583(U: set, S: set, B: set)\n ensures (U + S) + B == U + (S + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_5584","instance":5584,"id":208927,"goal":"lemma SetSubsetRefl_5584(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_5585","instance":5585,"id":208928,"goal":"lemma SetSubsetTrans_5585(S: set, U: set, T: set)\n requires S <= U && U <= T\n ensures S <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_5586","instance":5586,"id":208929,"goal":"lemma SetUnionEmpty_5586(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_5587","instance":5587,"id":208930,"goal":"lemma SetInterEmpty_5587(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_5588","instance":5588,"id":208931,"goal":"lemma SetInterSubset_5588(S: set, T: set)\n ensures S * T <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_5589","instance":5589,"id":208932,"goal":"lemma SetCardSubset_5589(S: set, T: set)\n requires S <= T\n ensures |S| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_5590","instance":5590,"id":208933,"goal":"lemma SetUnionCard_5590(T: set, S: set)\n requires T * S == {}\n ensures |T + S| == |T| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_5591","instance":5591,"id":208934,"goal":"lemma SetUnionComm_5591(U: set, T: set)\n ensures U + T == T + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_5592","instance":5592,"id":208935,"goal":"lemma SetInterComm_5592(U: set, B: set)\n ensures U * B == B * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_5593","instance":5593,"id":208936,"goal":"lemma SetUnionAssoc_5593(A: set, S: set, U: set)\n ensures (A + S) + U == A + (S + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_5594","instance":5594,"id":208937,"goal":"lemma SetSubsetRefl_5594(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_5595","instance":5595,"id":208938,"goal":"lemma SetSubsetTrans_5595(A: set, T: set, U: set)\n requires A <= T && T <= U\n ensures A <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_5596","instance":5596,"id":208939,"goal":"lemma SetUnionEmpty_5596(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_5597","instance":5597,"id":208940,"goal":"lemma SetInterEmpty_5597(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_5598","instance":5598,"id":208941,"goal":"lemma SetInterSubset_5598(T: set, B: set)\n ensures T * B <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_5599","instance":5599,"id":208942,"goal":"lemma SetCardSubset_5599(B: set, A: set)\n requires B <= A\n ensures |B| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_5600","instance":5600,"id":208943,"goal":"lemma SetUnionCard_5600(T: set, B: set)\n requires T * B == {}\n ensures |T + B| == |T| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_5601","instance":5601,"id":208944,"goal":"lemma SetUnionComm_5601(U: set, A: set)\n ensures U + A == A + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_5602","instance":5602,"id":208945,"goal":"lemma SetInterComm_5602(B: set, S: set)\n ensures B * S == S * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_5603","instance":5603,"id":208946,"goal":"lemma SetUnionAssoc_5603(S: set, A: set, T: set)\n ensures (S + A) + T == S + (A + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_5604","instance":5604,"id":208947,"goal":"lemma SetSubsetRefl_5604(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_5605","instance":5605,"id":208948,"goal":"lemma SetSubsetTrans_5605(B: set, A: set, S: set)\n requires B <= A && A <= S\n ensures B <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_5606","instance":5606,"id":208949,"goal":"lemma SetUnionEmpty_5606(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_5607","instance":5607,"id":208950,"goal":"lemma SetInterEmpty_5607(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_5608","instance":5608,"id":208951,"goal":"lemma SetInterSubset_5608(A: set, S: set)\n ensures A * S <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_5609","instance":5609,"id":208952,"goal":"lemma SetCardSubset_5609(B: set, U: set)\n requires B <= U\n ensures |B| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_5610","instance":5610,"id":208953,"goal":"lemma SetUnionCard_5610(T: set, A: set)\n requires T * A == {}\n ensures |T + A| == |T| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_5611","instance":5611,"id":208954,"goal":"lemma SetUnionComm_5611(B: set, U: set)\n ensures B + U == U + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_5612","instance":5612,"id":208955,"goal":"lemma SetInterComm_5612(S: set, T: set)\n ensures S * T == T * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_5613","instance":5613,"id":208956,"goal":"lemma SetUnionAssoc_5613(B: set, T: set, U: set)\n ensures (B + T) + U == B + (T + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_5614","instance":5614,"id":208957,"goal":"lemma SetSubsetRefl_5614(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_5615","instance":5615,"id":208958,"goal":"lemma SetSubsetTrans_5615(U: set, A: set, T: set)\n requires U <= A && A <= T\n ensures U <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_5616","instance":5616,"id":208959,"goal":"lemma SetUnionEmpty_5616(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_5617","instance":5617,"id":208960,"goal":"lemma SetInterEmpty_5617(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_5618","instance":5618,"id":208961,"goal":"lemma SetInterSubset_5618(B: set, S: set)\n ensures B * S <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_5619","instance":5619,"id":208962,"goal":"lemma SetCardSubset_5619(A: set, U: set)\n requires A <= U\n ensures |A| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_5620","instance":5620,"id":208963,"goal":"lemma SetUnionCard_5620(S: set, T: set)\n requires S * T == {}\n ensures |S + T| == |S| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_5621","instance":5621,"id":208964,"goal":"lemma SetUnionComm_5621(T: set, S: set)\n ensures T + S == S + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_5622","instance":5622,"id":208965,"goal":"lemma SetInterComm_5622(U: set, S: set)\n ensures U * S == S * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_5623","instance":5623,"id":208966,"goal":"lemma SetUnionAssoc_5623(B: set, A: set, U: set)\n ensures (B + A) + U == B + (A + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_5624","instance":5624,"id":208967,"goal":"lemma SetSubsetRefl_5624(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_5625","instance":5625,"id":208968,"goal":"lemma SetSubsetTrans_5625(A: set, T: set, U: set)\n requires A <= T && T <= U\n ensures A <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_5626","instance":5626,"id":208969,"goal":"lemma SetUnionEmpty_5626(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_5627","instance":5627,"id":208970,"goal":"lemma SetInterEmpty_5627(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_5628","instance":5628,"id":208971,"goal":"lemma SetInterSubset_5628(T: set, B: set)\n ensures T * B <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_5629","instance":5629,"id":208972,"goal":"lemma SetCardSubset_5629(U: set, B: set)\n requires U <= B\n ensures |U| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_5630","instance":5630,"id":208973,"goal":"lemma SetUnionCard_5630(B: set, S: set)\n requires B * S == {}\n ensures |B + S| == |B| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_5631","instance":5631,"id":208974,"goal":"lemma SetUnionComm_5631(B: set, A: set)\n ensures B + A == A + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_5632","instance":5632,"id":208975,"goal":"lemma SetInterComm_5632(S: set, A: set)\n ensures S * A == A * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_5633","instance":5633,"id":208976,"goal":"lemma SetUnionAssoc_5633(B: set, S: set, U: set)\n ensures (B + S) + U == B + (S + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_5634","instance":5634,"id":208977,"goal":"lemma SetSubsetRefl_5634(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_5635","instance":5635,"id":208978,"goal":"lemma SetSubsetTrans_5635(A: set, U: set, T: set)\n requires A <= U && U <= T\n ensures A <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_5636","instance":5636,"id":208979,"goal":"lemma SetUnionEmpty_5636(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_5637","instance":5637,"id":208980,"goal":"lemma SetInterEmpty_5637(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_5638","instance":5638,"id":208981,"goal":"lemma SetInterSubset_5638(S: set, U: set)\n ensures S * U <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_5639","instance":5639,"id":208982,"goal":"lemma SetCardSubset_5639(A: set, T: set)\n requires A <= T\n ensures |A| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_5640","instance":5640,"id":208983,"goal":"lemma SetUnionCard_5640(S: set, T: set)\n requires S * T == {}\n ensures |S + T| == |S| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_5641","instance":5641,"id":208984,"goal":"lemma SetUnionComm_5641(B: set, T: set)\n ensures B + T == T + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_5642","instance":5642,"id":208985,"goal":"lemma SetInterComm_5642(S: set, B: set)\n ensures S * B == B * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_5643","instance":5643,"id":208986,"goal":"lemma SetUnionAssoc_5643(B: set, S: set, U: set)\n ensures (B + S) + U == B + (S + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_5644","instance":5644,"id":208987,"goal":"lemma SetSubsetRefl_5644(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_5645","instance":5645,"id":208988,"goal":"lemma SetSubsetTrans_5645(S: set, B: set, T: set)\n requires S <= B && B <= T\n ensures S <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_5646","instance":5646,"id":208989,"goal":"lemma SetUnionEmpty_5646(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_5647","instance":5647,"id":208990,"goal":"lemma SetInterEmpty_5647(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_5648","instance":5648,"id":208991,"goal":"lemma SetInterSubset_5648(B: set, S: set)\n ensures B * S <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_5649","instance":5649,"id":208992,"goal":"lemma SetCardSubset_5649(T: set, A: set)\n requires T <= A\n ensures |T| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_5650","instance":5650,"id":208993,"goal":"lemma SetUnionCard_5650(B: set, A: set)\n requires B * A == {}\n ensures |B + A| == |B| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_5651","instance":5651,"id":208994,"goal":"lemma SetUnionComm_5651(B: set, T: set)\n ensures B + T == T + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_5652","instance":5652,"id":208995,"goal":"lemma SetInterComm_5652(U: set, B: set)\n ensures U * B == B * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_5653","instance":5653,"id":208996,"goal":"lemma SetUnionAssoc_5653(B: set, S: set, A: set)\n ensures (B + S) + A == B + (S + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_5654","instance":5654,"id":208997,"goal":"lemma SetSubsetRefl_5654(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_5655","instance":5655,"id":208998,"goal":"lemma SetSubsetTrans_5655(B: set, S: set, A: set)\n requires B <= S && S <= A\n ensures B <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_5656","instance":5656,"id":208999,"goal":"lemma SetUnionEmpty_5656(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_5657","instance":5657,"id":209000,"goal":"lemma SetInterEmpty_5657(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_5658","instance":5658,"id":209001,"goal":"lemma SetInterSubset_5658(B: set, S: set)\n ensures B * S <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_5659","instance":5659,"id":209002,"goal":"lemma SetCardSubset_5659(T: set, S: set)\n requires T <= S\n ensures |T| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_5660","instance":5660,"id":209003,"goal":"lemma SetUnionCard_5660(T: set, B: set)\n requires T * B == {}\n ensures |T + B| == |T| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_5661","instance":5661,"id":209004,"goal":"lemma SetUnionComm_5661(T: set, A: set)\n ensures T + A == A + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_5662","instance":5662,"id":209005,"goal":"lemma SetInterComm_5662(U: set, A: set)\n ensures U * A == A * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_5663","instance":5663,"id":209006,"goal":"lemma SetUnionAssoc_5663(S: set, U: set, B: set)\n ensures (S + U) + B == S + (U + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_5664","instance":5664,"id":209007,"goal":"lemma SetSubsetRefl_5664(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_5665","instance":5665,"id":209008,"goal":"lemma SetSubsetTrans_5665(B: set, T: set, S: set)\n requires B <= T && T <= S\n ensures B <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_5666","instance":5666,"id":209009,"goal":"lemma SetUnionEmpty_5666(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_5667","instance":5667,"id":209010,"goal":"lemma SetInterEmpty_5667(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_5668","instance":5668,"id":209011,"goal":"lemma SetInterSubset_5668(A: set, S: set)\n ensures A * S <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_5669","instance":5669,"id":209012,"goal":"lemma SetCardSubset_5669(A: set, B: set)\n requires A <= B\n ensures |A| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_5670","instance":5670,"id":209013,"goal":"lemma SetUnionCard_5670(S: set, A: set)\n requires S * A == {}\n ensures |S + A| == |S| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_5671","instance":5671,"id":209014,"goal":"lemma SetUnionComm_5671(B: set, A: set)\n ensures B + A == A + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_5672","instance":5672,"id":209015,"goal":"lemma SetInterComm_5672(B: set, A: set)\n ensures B * A == A * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_5673","instance":5673,"id":209016,"goal":"lemma SetUnionAssoc_5673(U: set, T: set, S: set)\n ensures (U + T) + S == U + (T + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_5674","instance":5674,"id":209017,"goal":"lemma SetSubsetRefl_5674(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_5675","instance":5675,"id":209018,"goal":"lemma SetSubsetTrans_5675(A: set, B: set, T: set)\n requires A <= B && B <= T\n ensures A <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_5676","instance":5676,"id":209019,"goal":"lemma SetUnionEmpty_5676(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_5677","instance":5677,"id":209020,"goal":"lemma SetInterEmpty_5677(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_5678","instance":5678,"id":209021,"goal":"lemma SetInterSubset_5678(S: set, B: set)\n ensures S * B <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_5679","instance":5679,"id":209022,"goal":"lemma SetCardSubset_5679(B: set, U: set)\n requires B <= U\n ensures |B| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_5680","instance":5680,"id":209023,"goal":"lemma SetUnionCard_5680(B: set, A: set)\n requires B * A == {}\n ensures |B + A| == |B| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_5681","instance":5681,"id":209024,"goal":"lemma SetUnionComm_5681(U: set, B: set)\n ensures U + B == B + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_5682","instance":5682,"id":209025,"goal":"lemma SetInterComm_5682(A: set, T: set)\n ensures A * T == T * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_5683","instance":5683,"id":209026,"goal":"lemma SetUnionAssoc_5683(A: set, U: set, B: set)\n ensures (A + U) + B == A + (U + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_5684","instance":5684,"id":209027,"goal":"lemma SetSubsetRefl_5684(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_5685","instance":5685,"id":209028,"goal":"lemma SetSubsetTrans_5685(S: set, T: set, B: set)\n requires S <= T && T <= B\n ensures S <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_5686","instance":5686,"id":209029,"goal":"lemma SetUnionEmpty_5686(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_5687","instance":5687,"id":209030,"goal":"lemma SetInterEmpty_5687(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_5688","instance":5688,"id":209031,"goal":"lemma SetInterSubset_5688(S: set, T: set)\n ensures S * T <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_5689","instance":5689,"id":209032,"goal":"lemma SetCardSubset_5689(U: set, T: set)\n requires U <= T\n ensures |U| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_5690","instance":5690,"id":209033,"goal":"lemma SetUnionCard_5690(U: set, S: set)\n requires U * S == {}\n ensures |U + S| == |U| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_5691","instance":5691,"id":209034,"goal":"lemma SetUnionComm_5691(A: set, U: set)\n ensures A + U == U + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_5692","instance":5692,"id":209035,"goal":"lemma SetInterComm_5692(A: set, S: set)\n ensures A * S == S * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_5693","instance":5693,"id":209036,"goal":"lemma SetUnionAssoc_5693(B: set, U: set, A: set)\n ensures (B + U) + A == B + (U + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_5694","instance":5694,"id":209037,"goal":"lemma SetSubsetRefl_5694(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_5695","instance":5695,"id":209038,"goal":"lemma SetSubsetTrans_5695(U: set, A: set, S: set)\n requires U <= A && A <= S\n ensures U <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_5696","instance":5696,"id":209039,"goal":"lemma SetUnionEmpty_5696(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_5697","instance":5697,"id":209040,"goal":"lemma SetInterEmpty_5697(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_5698","instance":5698,"id":209041,"goal":"lemma SetInterSubset_5698(B: set, S: set)\n ensures B * S <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_5699","instance":5699,"id":209042,"goal":"lemma SetCardSubset_5699(A: set, T: set)\n requires A <= T\n ensures |A| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_5700","instance":5700,"id":209043,"goal":"lemma SetUnionCard_5700(T: set, A: set)\n requires T * A == {}\n ensures |T + A| == |T| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_5701","instance":5701,"id":209044,"goal":"lemma SetUnionComm_5701(A: set, T: set)\n ensures A + T == T + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_5702","instance":5702,"id":209045,"goal":"lemma SetInterComm_5702(B: set, T: set)\n ensures B * T == T * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_5703","instance":5703,"id":209046,"goal":"lemma SetUnionAssoc_5703(B: set, S: set, A: set)\n ensures (B + S) + A == B + (S + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_5704","instance":5704,"id":209047,"goal":"lemma SetSubsetRefl_5704(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_5705","instance":5705,"id":209048,"goal":"lemma SetSubsetTrans_5705(B: set, A: set, S: set)\n requires B <= A && A <= S\n ensures B <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_5706","instance":5706,"id":209049,"goal":"lemma SetUnionEmpty_5706(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_5707","instance":5707,"id":209050,"goal":"lemma SetInterEmpty_5707(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_5708","instance":5708,"id":209051,"goal":"lemma SetInterSubset_5708(S: set, T: set)\n ensures S * T <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_5709","instance":5709,"id":209052,"goal":"lemma SetCardSubset_5709(S: set, B: set)\n requires S <= B\n ensures |S| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_5710","instance":5710,"id":209053,"goal":"lemma SetUnionCard_5710(S: set, B: set)\n requires S * B == {}\n ensures |S + B| == |S| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_5711","instance":5711,"id":209054,"goal":"lemma SetUnionComm_5711(S: set, B: set)\n ensures S + B == B + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_5712","instance":5712,"id":209055,"goal":"lemma SetInterComm_5712(S: set, A: set)\n ensures S * A == A * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_5713","instance":5713,"id":209056,"goal":"lemma SetUnionAssoc_5713(U: set, S: set, A: set)\n ensures (U + S) + A == U + (S + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_5714","instance":5714,"id":209057,"goal":"lemma SetSubsetRefl_5714(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_5715","instance":5715,"id":209058,"goal":"lemma SetSubsetTrans_5715(B: set, S: set, T: set)\n requires B <= S && S <= T\n ensures B <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_5716","instance":5716,"id":209059,"goal":"lemma SetUnionEmpty_5716(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_5717","instance":5717,"id":209060,"goal":"lemma SetInterEmpty_5717(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_5718","instance":5718,"id":209061,"goal":"lemma SetInterSubset_5718(A: set, S: set)\n ensures A * S <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_5719","instance":5719,"id":209062,"goal":"lemma SetCardSubset_5719(S: set, T: set)\n requires S <= T\n ensures |S| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_5720","instance":5720,"id":209063,"goal":"lemma SetUnionCard_5720(U: set, A: set)\n requires U * A == {}\n ensures |U + A| == |U| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_5721","instance":5721,"id":209064,"goal":"lemma SetUnionComm_5721(U: set, B: set)\n ensures U + B == B + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_5722","instance":5722,"id":209065,"goal":"lemma SetInterComm_5722(U: set, S: set)\n ensures U * S == S * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_5723","instance":5723,"id":209066,"goal":"lemma SetUnionAssoc_5723(T: set, S: set, B: set)\n ensures (T + S) + B == T + (S + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_5724","instance":5724,"id":209067,"goal":"lemma SetSubsetRefl_5724(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_5725","instance":5725,"id":209068,"goal":"lemma SetSubsetTrans_5725(A: set, B: set, U: set)\n requires A <= B && B <= U\n ensures A <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_5726","instance":5726,"id":209069,"goal":"lemma SetUnionEmpty_5726(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_5727","instance":5727,"id":209070,"goal":"lemma SetInterEmpty_5727(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_5728","instance":5728,"id":209071,"goal":"lemma SetInterSubset_5728(T: set, U: set)\n ensures T * U <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_5729","instance":5729,"id":209072,"goal":"lemma SetCardSubset_5729(U: set, A: set)\n requires U <= A\n ensures |U| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_5730","instance":5730,"id":209073,"goal":"lemma SetUnionCard_5730(B: set, T: set)\n requires B * T == {}\n ensures |B + T| == |B| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_5731","instance":5731,"id":209074,"goal":"lemma SetUnionComm_5731(U: set, B: set)\n ensures U + B == B + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_5732","instance":5732,"id":209075,"goal":"lemma SetInterComm_5732(T: set, U: set)\n ensures T * U == U * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_5733","instance":5733,"id":209076,"goal":"lemma SetUnionAssoc_5733(A: set, U: set, S: set)\n ensures (A + U) + S == A + (U + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_5734","instance":5734,"id":209077,"goal":"lemma SetSubsetRefl_5734(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_5735","instance":5735,"id":209078,"goal":"lemma SetSubsetTrans_5735(B: set, U: set, A: set)\n requires B <= U && U <= A\n ensures B <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_5736","instance":5736,"id":209079,"goal":"lemma SetUnionEmpty_5736(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_5737","instance":5737,"id":209080,"goal":"lemma SetInterEmpty_5737(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_5738","instance":5738,"id":209081,"goal":"lemma SetInterSubset_5738(U: set, S: set)\n ensures U * S <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_5739","instance":5739,"id":209082,"goal":"lemma SetCardSubset_5739(T: set, U: set)\n requires T <= U\n ensures |T| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_5740","instance":5740,"id":209083,"goal":"lemma SetUnionCard_5740(S: set, U: set)\n requires S * U == {}\n ensures |S + U| == |S| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_5741","instance":5741,"id":209084,"goal":"lemma SetUnionComm_5741(U: set, B: set)\n ensures U + B == B + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_5742","instance":5742,"id":209085,"goal":"lemma SetInterComm_5742(A: set, B: set)\n ensures A * B == B * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_5743","instance":5743,"id":209086,"goal":"lemma SetUnionAssoc_5743(S: set, A: set, T: set)\n ensures (S + A) + T == S + (A + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_5744","instance":5744,"id":209087,"goal":"lemma SetSubsetRefl_5744(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_5745","instance":5745,"id":209088,"goal":"lemma SetSubsetTrans_5745(T: set, B: set, U: set)\n requires T <= B && B <= U\n ensures T <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_5746","instance":5746,"id":209089,"goal":"lemma SetUnionEmpty_5746(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_5747","instance":5747,"id":209090,"goal":"lemma SetInterEmpty_5747(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_5748","instance":5748,"id":209091,"goal":"lemma SetInterSubset_5748(U: set, T: set)\n ensures U * T <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_5749","instance":5749,"id":209092,"goal":"lemma SetCardSubset_5749(A: set, U: set)\n requires A <= U\n ensures |A| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_5750","instance":5750,"id":209093,"goal":"lemma SetUnionCard_5750(A: set, S: set)\n requires A * S == {}\n ensures |A + S| == |A| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_5751","instance":5751,"id":209094,"goal":"lemma SetUnionComm_5751(U: set, B: set)\n ensures U + B == B + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_5752","instance":5752,"id":209095,"goal":"lemma SetInterComm_5752(T: set, B: set)\n ensures T * B == B * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_5753","instance":5753,"id":209096,"goal":"lemma SetUnionAssoc_5753(S: set, B: set, U: set)\n ensures (S + B) + U == S + (B + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_5754","instance":5754,"id":209097,"goal":"lemma SetSubsetRefl_5754(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_5755","instance":5755,"id":209098,"goal":"lemma SetSubsetTrans_5755(U: set, T: set, S: set)\n requires U <= T && T <= S\n ensures U <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_5756","instance":5756,"id":209099,"goal":"lemma SetUnionEmpty_5756(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_5757","instance":5757,"id":209100,"goal":"lemma SetInterEmpty_5757(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_5758","instance":5758,"id":209101,"goal":"lemma SetInterSubset_5758(A: set, B: set)\n ensures A * B <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_5759","instance":5759,"id":209102,"goal":"lemma SetCardSubset_5759(B: set, S: set)\n requires B <= S\n ensures |B| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_5760","instance":5760,"id":209103,"goal":"lemma SetUnionCard_5760(S: set, A: set)\n requires S * A == {}\n ensures |S + A| == |S| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_5761","instance":5761,"id":209104,"goal":"lemma SetUnionComm_5761(B: set, S: set)\n ensures B + S == S + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_5762","instance":5762,"id":209105,"goal":"lemma SetInterComm_5762(S: set, T: set)\n ensures S * T == T * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_5763","instance":5763,"id":209106,"goal":"lemma SetUnionAssoc_5763(S: set, A: set, T: set)\n ensures (S + A) + T == S + (A + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_5764","instance":5764,"id":209107,"goal":"lemma SetSubsetRefl_5764(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_5765","instance":5765,"id":209108,"goal":"lemma SetSubsetTrans_5765(U: set, B: set, T: set)\n requires U <= B && B <= T\n ensures U <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_5766","instance":5766,"id":209109,"goal":"lemma SetUnionEmpty_5766(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_5767","instance":5767,"id":209110,"goal":"lemma SetInterEmpty_5767(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_5768","instance":5768,"id":209111,"goal":"lemma SetInterSubset_5768(A: set, S: set)\n ensures A * S <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_5769","instance":5769,"id":209112,"goal":"lemma SetCardSubset_5769(T: set, A: set)\n requires T <= A\n ensures |T| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_5770","instance":5770,"id":209113,"goal":"lemma SetUnionCard_5770(S: set, A: set)\n requires S * A == {}\n ensures |S + A| == |S| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_5771","instance":5771,"id":209114,"goal":"lemma SetUnionComm_5771(U: set, B: set)\n ensures U + B == B + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_5772","instance":5772,"id":209115,"goal":"lemma SetInterComm_5772(S: set, A: set)\n ensures S * A == A * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_5773","instance":5773,"id":209116,"goal":"lemma SetUnionAssoc_5773(U: set, A: set, S: set)\n ensures (U + A) + S == U + (A + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_5774","instance":5774,"id":209117,"goal":"lemma SetSubsetRefl_5774(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_5775","instance":5775,"id":209118,"goal":"lemma SetSubsetTrans_5775(A: set, B: set, U: set)\n requires A <= B && B <= U\n ensures A <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_5776","instance":5776,"id":209119,"goal":"lemma SetUnionEmpty_5776(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_5777","instance":5777,"id":209120,"goal":"lemma SetInterEmpty_5777(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_5778","instance":5778,"id":209121,"goal":"lemma SetInterSubset_5778(T: set, S: set)\n ensures T * S <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_5779","instance":5779,"id":209122,"goal":"lemma SetCardSubset_5779(B: set, U: set)\n requires B <= U\n ensures |B| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_5780","instance":5780,"id":209123,"goal":"lemma SetUnionCard_5780(T: set, B: set)\n requires T * B == {}\n ensures |T + B| == |T| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_5781","instance":5781,"id":209124,"goal":"lemma SetUnionComm_5781(U: set, A: set)\n ensures U + A == A + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_5782","instance":5782,"id":209125,"goal":"lemma SetInterComm_5782(S: set, A: set)\n ensures S * A == A * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_5783","instance":5783,"id":209126,"goal":"lemma SetUnionAssoc_5783(B: set, T: set, A: set)\n ensures (B + T) + A == B + (T + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_5784","instance":5784,"id":209127,"goal":"lemma SetSubsetRefl_5784(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_5785","instance":5785,"id":209128,"goal":"lemma SetSubsetTrans_5785(A: set, U: set, B: set)\n requires A <= U && U <= B\n ensures A <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_5786","instance":5786,"id":209129,"goal":"lemma SetUnionEmpty_5786(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_5787","instance":5787,"id":209130,"goal":"lemma SetInterEmpty_5787(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_5788","instance":5788,"id":209131,"goal":"lemma SetInterSubset_5788(S: set, U: set)\n ensures S * U <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_5789","instance":5789,"id":209132,"goal":"lemma SetCardSubset_5789(B: set, T: set)\n requires B <= T\n ensures |B| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_5790","instance":5790,"id":209133,"goal":"lemma SetUnionCard_5790(A: set, U: set)\n requires A * U == {}\n ensures |A + U| == |A| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_5791","instance":5791,"id":209134,"goal":"lemma SetUnionComm_5791(B: set, T: set)\n ensures B + T == T + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_5792","instance":5792,"id":209135,"goal":"lemma SetInterComm_5792(S: set, A: set)\n ensures S * A == A * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_5793","instance":5793,"id":209136,"goal":"lemma SetUnionAssoc_5793(S: set, B: set, T: set)\n ensures (S + B) + T == S + (B + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_5794","instance":5794,"id":209137,"goal":"lemma SetSubsetRefl_5794(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_5795","instance":5795,"id":209138,"goal":"lemma SetSubsetTrans_5795(A: set, S: set, T: set)\n requires A <= S && S <= T\n ensures A <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_5796","instance":5796,"id":209139,"goal":"lemma SetUnionEmpty_5796(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_5797","instance":5797,"id":209140,"goal":"lemma SetInterEmpty_5797(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_5798","instance":5798,"id":209141,"goal":"lemma SetInterSubset_5798(A: set, B: set)\n ensures A * B <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_5799","instance":5799,"id":209142,"goal":"lemma SetCardSubset_5799(U: set, S: set)\n requires U <= S\n ensures |U| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_5800","instance":5800,"id":209143,"goal":"lemma SetUnionCard_5800(U: set, B: set)\n requires U * B == {}\n ensures |U + B| == |U| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_5801","instance":5801,"id":209144,"goal":"lemma SetUnionComm_5801(T: set, U: set)\n ensures T + U == U + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_5802","instance":5802,"id":209145,"goal":"lemma SetInterComm_5802(S: set, A: set)\n ensures S * A == A * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_5803","instance":5803,"id":209146,"goal":"lemma SetUnionAssoc_5803(A: set, S: set, U: set)\n ensures (A + S) + U == A + (S + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_5804","instance":5804,"id":209147,"goal":"lemma SetSubsetRefl_5804(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_5805","instance":5805,"id":209148,"goal":"lemma SetSubsetTrans_5805(A: set, T: set, S: set)\n requires A <= T && T <= S\n ensures A <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_5806","instance":5806,"id":209149,"goal":"lemma SetUnionEmpty_5806(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_5807","instance":5807,"id":209150,"goal":"lemma SetInterEmpty_5807(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_5808","instance":5808,"id":209151,"goal":"lemma SetInterSubset_5808(A: set, T: set)\n ensures A * T <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_5809","instance":5809,"id":209152,"goal":"lemma SetCardSubset_5809(U: set, T: set)\n requires U <= T\n ensures |U| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_5810","instance":5810,"id":209153,"goal":"lemma SetUnionCard_5810(B: set, A: set)\n requires B * A == {}\n ensures |B + A| == |B| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_5811","instance":5811,"id":209154,"goal":"lemma SetUnionComm_5811(S: set, T: set)\n ensures S + T == T + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_5812","instance":5812,"id":209155,"goal":"lemma SetInterComm_5812(T: set, U: set)\n ensures T * U == U * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_5813","instance":5813,"id":209156,"goal":"lemma SetUnionAssoc_5813(T: set, B: set, S: set)\n ensures (T + B) + S == T + (B + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_5814","instance":5814,"id":209157,"goal":"lemma SetSubsetRefl_5814(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_5815","instance":5815,"id":209158,"goal":"lemma SetSubsetTrans_5815(A: set, B: set, S: set)\n requires A <= B && B <= S\n ensures A <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_5816","instance":5816,"id":209159,"goal":"lemma SetUnionEmpty_5816(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_5817","instance":5817,"id":209160,"goal":"lemma SetInterEmpty_5817(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_5818","instance":5818,"id":209161,"goal":"lemma SetInterSubset_5818(U: set, A: set)\n ensures U * A <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_5819","instance":5819,"id":209162,"goal":"lemma SetCardSubset_5819(B: set, A: set)\n requires B <= A\n ensures |B| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_5820","instance":5820,"id":209163,"goal":"lemma SetUnionCard_5820(A: set, U: set)\n requires A * U == {}\n ensures |A + U| == |A| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_5821","instance":5821,"id":209164,"goal":"lemma SetUnionComm_5821(S: set, A: set)\n ensures S + A == A + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_5822","instance":5822,"id":209165,"goal":"lemma SetInterComm_5822(U: set, B: set)\n ensures U * B == B * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_5823","instance":5823,"id":209166,"goal":"lemma SetUnionAssoc_5823(B: set, S: set, A: set)\n ensures (B + S) + A == B + (S + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_5824","instance":5824,"id":209167,"goal":"lemma SetSubsetRefl_5824(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_5825","instance":5825,"id":209168,"goal":"lemma SetSubsetTrans_5825(T: set, B: set, S: set)\n requires T <= B && B <= S\n ensures T <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_5826","instance":5826,"id":209169,"goal":"lemma SetUnionEmpty_5826(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_5827","instance":5827,"id":209170,"goal":"lemma SetInterEmpty_5827(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_5828","instance":5828,"id":209171,"goal":"lemma SetInterSubset_5828(S: set, T: set)\n ensures S * T <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_5829","instance":5829,"id":209172,"goal":"lemma SetCardSubset_5829(A: set, T: set)\n requires A <= T\n ensures |A| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_5830","instance":5830,"id":209173,"goal":"lemma SetUnionCard_5830(B: set, S: set)\n requires B * S == {}\n ensures |B + S| == |B| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_5831","instance":5831,"id":209174,"goal":"lemma SetUnionComm_5831(T: set, B: set)\n ensures T + B == B + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_5832","instance":5832,"id":209175,"goal":"lemma SetInterComm_5832(U: set, A: set)\n ensures U * A == A * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_5833","instance":5833,"id":209176,"goal":"lemma SetUnionAssoc_5833(A: set, U: set, B: set)\n ensures (A + U) + B == A + (U + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_5834","instance":5834,"id":209177,"goal":"lemma SetSubsetRefl_5834(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_5835","instance":5835,"id":209178,"goal":"lemma SetSubsetTrans_5835(U: set, S: set, T: set)\n requires U <= S && S <= T\n ensures U <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_5836","instance":5836,"id":209179,"goal":"lemma SetUnionEmpty_5836(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_5837","instance":5837,"id":209180,"goal":"lemma SetInterEmpty_5837(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_5838","instance":5838,"id":209181,"goal":"lemma SetInterSubset_5838(A: set, S: set)\n ensures A * S <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_5839","instance":5839,"id":209182,"goal":"lemma SetCardSubset_5839(A: set, T: set)\n requires A <= T\n ensures |A| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_5840","instance":5840,"id":209183,"goal":"lemma SetUnionCard_5840(U: set, B: set)\n requires U * B == {}\n ensures |U + B| == |U| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_5841","instance":5841,"id":209184,"goal":"lemma SetUnionComm_5841(U: set, A: set)\n ensures U + A == A + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_5842","instance":5842,"id":209185,"goal":"lemma SetInterComm_5842(U: set, A: set)\n ensures U * A == A * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_5843","instance":5843,"id":209186,"goal":"lemma SetUnionAssoc_5843(S: set, B: set, U: set)\n ensures (S + B) + U == S + (B + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_5844","instance":5844,"id":209187,"goal":"lemma SetSubsetRefl_5844(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_5845","instance":5845,"id":209188,"goal":"lemma SetSubsetTrans_5845(B: set, A: set, U: set)\n requires B <= A && A <= U\n ensures B <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_5846","instance":5846,"id":209189,"goal":"lemma SetUnionEmpty_5846(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_5847","instance":5847,"id":209190,"goal":"lemma SetInterEmpty_5847(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_5848","instance":5848,"id":209191,"goal":"lemma SetInterSubset_5848(S: set, U: set)\n ensures S * U <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_5849","instance":5849,"id":209192,"goal":"lemma SetCardSubset_5849(S: set, U: set)\n requires S <= U\n ensures |S| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_5850","instance":5850,"id":209193,"goal":"lemma SetUnionCard_5850(B: set, U: set)\n requires B * U == {}\n ensures |B + U| == |B| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_5851","instance":5851,"id":209194,"goal":"lemma SetUnionComm_5851(S: set, B: set)\n ensures S + B == B + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_5852","instance":5852,"id":209195,"goal":"lemma SetInterComm_5852(U: set, A: set)\n ensures U * A == A * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_5853","instance":5853,"id":209196,"goal":"lemma SetUnionAssoc_5853(S: set, T: set, A: set)\n ensures (S + T) + A == S + (T + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_5854","instance":5854,"id":209197,"goal":"lemma SetSubsetRefl_5854(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_5855","instance":5855,"id":209198,"goal":"lemma SetSubsetTrans_5855(S: set, U: set, A: set)\n requires S <= U && U <= A\n ensures S <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_5856","instance":5856,"id":209199,"goal":"lemma SetUnionEmpty_5856(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_5857","instance":5857,"id":209200,"goal":"lemma SetInterEmpty_5857(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_5858","instance":5858,"id":209201,"goal":"lemma SetInterSubset_5858(A: set, S: set)\n ensures A * S <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_5859","instance":5859,"id":209202,"goal":"lemma SetCardSubset_5859(U: set, S: set)\n requires U <= S\n ensures |U| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_5860","instance":5860,"id":209203,"goal":"lemma SetUnionCard_5860(T: set, A: set)\n requires T * A == {}\n ensures |T + A| == |T| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_5861","instance":5861,"id":209204,"goal":"lemma SetUnionComm_5861(A: set, U: set)\n ensures A + U == U + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_5862","instance":5862,"id":209205,"goal":"lemma SetInterComm_5862(A: set, B: set)\n ensures A * B == B * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_5863","instance":5863,"id":209206,"goal":"lemma SetUnionAssoc_5863(A: set, U: set, T: set)\n ensures (A + U) + T == A + (U + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_5864","instance":5864,"id":209207,"goal":"lemma SetSubsetRefl_5864(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_5865","instance":5865,"id":209208,"goal":"lemma SetSubsetTrans_5865(T: set, S: set, A: set)\n requires T <= S && S <= A\n ensures T <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_5866","instance":5866,"id":209209,"goal":"lemma SetUnionEmpty_5866(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_5867","instance":5867,"id":209210,"goal":"lemma SetInterEmpty_5867(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_5868","instance":5868,"id":209211,"goal":"lemma SetInterSubset_5868(A: set, T: set)\n ensures A * T <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_5869","instance":5869,"id":209212,"goal":"lemma SetCardSubset_5869(T: set, S: set)\n requires T <= S\n ensures |T| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_5870","instance":5870,"id":209213,"goal":"lemma SetUnionCard_5870(S: set, A: set)\n requires S * A == {}\n ensures |S + A| == |S| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_5871","instance":5871,"id":209214,"goal":"lemma SetUnionComm_5871(B: set, S: set)\n ensures B + S == S + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_5872","instance":5872,"id":209215,"goal":"lemma SetInterComm_5872(U: set, A: set)\n ensures U * A == A * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_5873","instance":5873,"id":209216,"goal":"lemma SetUnionAssoc_5873(T: set, S: set, B: set)\n ensures (T + S) + B == T + (S + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_5874","instance":5874,"id":209217,"goal":"lemma SetSubsetRefl_5874(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_5875","instance":5875,"id":209218,"goal":"lemma SetSubsetTrans_5875(B: set, T: set, S: set)\n requires B <= T && T <= S\n ensures B <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_5876","instance":5876,"id":209219,"goal":"lemma SetUnionEmpty_5876(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_5877","instance":5877,"id":209220,"goal":"lemma SetInterEmpty_5877(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_5878","instance":5878,"id":209221,"goal":"lemma SetInterSubset_5878(T: set, S: set)\n ensures T * S <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_5879","instance":5879,"id":209222,"goal":"lemma SetCardSubset_5879(B: set, U: set)\n requires B <= U\n ensures |B| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_5880","instance":5880,"id":209223,"goal":"lemma SetUnionCard_5880(U: set, B: set)\n requires U * B == {}\n ensures |U + B| == |U| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_5881","instance":5881,"id":209224,"goal":"lemma SetUnionComm_5881(S: set, U: set)\n ensures S + U == U + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_5882","instance":5882,"id":209225,"goal":"lemma SetInterComm_5882(S: set, T: set)\n ensures S * T == T * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_5883","instance":5883,"id":209226,"goal":"lemma SetUnionAssoc_5883(B: set, T: set, A: set)\n ensures (B + T) + A == B + (T + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_5884","instance":5884,"id":209227,"goal":"lemma SetSubsetRefl_5884(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_5885","instance":5885,"id":209228,"goal":"lemma SetSubsetTrans_5885(A: set, S: set, B: set)\n requires A <= S && S <= B\n ensures A <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_5886","instance":5886,"id":209229,"goal":"lemma SetUnionEmpty_5886(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_5887","instance":5887,"id":209230,"goal":"lemma SetInterEmpty_5887(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_5888","instance":5888,"id":209231,"goal":"lemma SetInterSubset_5888(B: set, T: set)\n ensures B * T <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_5889","instance":5889,"id":209232,"goal":"lemma SetCardSubset_5889(S: set, U: set)\n requires S <= U\n ensures |S| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_5890","instance":5890,"id":209233,"goal":"lemma SetUnionCard_5890(S: set, U: set)\n requires S * U == {}\n ensures |S + U| == |S| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_5891","instance":5891,"id":209234,"goal":"lemma SetUnionComm_5891(A: set, B: set)\n ensures A + B == B + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_5892","instance":5892,"id":209235,"goal":"lemma SetInterComm_5892(T: set, U: set)\n ensures T * U == U * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_5893","instance":5893,"id":209236,"goal":"lemma SetUnionAssoc_5893(T: set, B: set, U: set)\n ensures (T + B) + U == T + (B + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_5894","instance":5894,"id":209237,"goal":"lemma SetSubsetRefl_5894(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_5895","instance":5895,"id":209238,"goal":"lemma SetSubsetTrans_5895(T: set, A: set, S: set)\n requires T <= A && A <= S\n ensures T <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_5896","instance":5896,"id":209239,"goal":"lemma SetUnionEmpty_5896(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_5897","instance":5897,"id":209240,"goal":"lemma SetInterEmpty_5897(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_5898","instance":5898,"id":209241,"goal":"lemma SetInterSubset_5898(S: set, U: set)\n ensures S * U <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_5899","instance":5899,"id":209242,"goal":"lemma SetCardSubset_5899(B: set, A: set)\n requires B <= A\n ensures |B| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_5900","instance":5900,"id":209243,"goal":"lemma SetUnionCard_5900(U: set, B: set)\n requires U * B == {}\n ensures |U + B| == |U| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_5901","instance":5901,"id":209244,"goal":"lemma SetUnionComm_5901(T: set, U: set)\n ensures T + U == U + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_5902","instance":5902,"id":209245,"goal":"lemma SetInterComm_5902(T: set, S: set)\n ensures T * S == S * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_5903","instance":5903,"id":209246,"goal":"lemma SetUnionAssoc_5903(U: set, A: set, S: set)\n ensures (U + A) + S == U + (A + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_5904","instance":5904,"id":209247,"goal":"lemma SetSubsetRefl_5904(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_5905","instance":5905,"id":209248,"goal":"lemma SetSubsetTrans_5905(B: set, S: set, U: set)\n requires B <= S && S <= U\n ensures B <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_5906","instance":5906,"id":209249,"goal":"lemma SetUnionEmpty_5906(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_5907","instance":5907,"id":209250,"goal":"lemma SetInterEmpty_5907(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_5908","instance":5908,"id":209251,"goal":"lemma SetInterSubset_5908(A: set, B: set)\n ensures A * B <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_5909","instance":5909,"id":209252,"goal":"lemma SetCardSubset_5909(A: set, T: set)\n requires A <= T\n ensures |A| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_5910","instance":5910,"id":209253,"goal":"lemma SetUnionCard_5910(U: set, S: set)\n requires U * S == {}\n ensures |U + S| == |U| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_5911","instance":5911,"id":209254,"goal":"lemma SetUnionComm_5911(T: set, S: set)\n ensures T + S == S + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_5912","instance":5912,"id":209255,"goal":"lemma SetInterComm_5912(A: set, U: set)\n ensures A * U == U * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_5913","instance":5913,"id":209256,"goal":"lemma SetUnionAssoc_5913(T: set, S: set, B: set)\n ensures (T + S) + B == T + (S + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_5914","instance":5914,"id":209257,"goal":"lemma SetSubsetRefl_5914(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_5915","instance":5915,"id":209258,"goal":"lemma SetSubsetTrans_5915(B: set, U: set, S: set)\n requires B <= U && U <= S\n ensures B <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_5916","instance":5916,"id":209259,"goal":"lemma SetUnionEmpty_5916(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_5917","instance":5917,"id":209260,"goal":"lemma SetInterEmpty_5917(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_5918","instance":5918,"id":209261,"goal":"lemma SetInterSubset_5918(S: set, T: set)\n ensures S * T <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_5919","instance":5919,"id":209262,"goal":"lemma SetCardSubset_5919(U: set, A: set)\n requires U <= A\n ensures |U| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_5920","instance":5920,"id":209263,"goal":"lemma SetUnionCard_5920(B: set, A: set)\n requires B * A == {}\n ensures |B + A| == |B| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_5921","instance":5921,"id":209264,"goal":"lemma SetUnionComm_5921(U: set, A: set)\n ensures U + A == A + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_5922","instance":5922,"id":209265,"goal":"lemma SetInterComm_5922(T: set, U: set)\n ensures T * U == U * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_5923","instance":5923,"id":209266,"goal":"lemma SetUnionAssoc_5923(A: set, U: set, B: set)\n ensures (A + U) + B == A + (U + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_5924","instance":5924,"id":209267,"goal":"lemma SetSubsetRefl_5924(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_5925","instance":5925,"id":209268,"goal":"lemma SetSubsetTrans_5925(T: set, B: set, U: set)\n requires T <= B && B <= U\n ensures T <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_5926","instance":5926,"id":209269,"goal":"lemma SetUnionEmpty_5926(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_5927","instance":5927,"id":209270,"goal":"lemma SetInterEmpty_5927(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_5928","instance":5928,"id":209271,"goal":"lemma SetInterSubset_5928(A: set, B: set)\n ensures A * B <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_5929","instance":5929,"id":209272,"goal":"lemma SetCardSubset_5929(A: set, B: set)\n requires A <= B\n ensures |A| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_5930","instance":5930,"id":209273,"goal":"lemma SetUnionCard_5930(U: set, A: set)\n requires U * A == {}\n ensures |U + A| == |U| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_5931","instance":5931,"id":209274,"goal":"lemma SetUnionComm_5931(A: set, T: set)\n ensures A + T == T + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_5932","instance":5932,"id":209275,"goal":"lemma SetInterComm_5932(A: set, T: set)\n ensures A * T == T * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_5933","instance":5933,"id":209276,"goal":"lemma SetUnionAssoc_5933(A: set, T: set, U: set)\n ensures (A + T) + U == A + (T + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_5934","instance":5934,"id":209277,"goal":"lemma SetSubsetRefl_5934(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_5935","instance":5935,"id":209278,"goal":"lemma SetSubsetTrans_5935(A: set, B: set, T: set)\n requires A <= B && B <= T\n ensures A <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_5936","instance":5936,"id":209279,"goal":"lemma SetUnionEmpty_5936(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_5937","instance":5937,"id":209280,"goal":"lemma SetInterEmpty_5937(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_5938","instance":5938,"id":209281,"goal":"lemma SetInterSubset_5938(S: set, B: set)\n ensures S * B <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_5939","instance":5939,"id":209282,"goal":"lemma SetCardSubset_5939(A: set, S: set)\n requires A <= S\n ensures |A| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_5940","instance":5940,"id":209283,"goal":"lemma SetUnionCard_5940(B: set, T: set)\n requires B * T == {}\n ensures |B + T| == |B| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_5941","instance":5941,"id":209284,"goal":"lemma SetUnionComm_5941(U: set, B: set)\n ensures U + B == B + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_5942","instance":5942,"id":209285,"goal":"lemma SetInterComm_5942(U: set, T: set)\n ensures U * T == T * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_5943","instance":5943,"id":209286,"goal":"lemma SetUnionAssoc_5943(B: set, S: set, U: set)\n ensures (B + S) + U == B + (S + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_5944","instance":5944,"id":209287,"goal":"lemma SetSubsetRefl_5944(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_5945","instance":5945,"id":209288,"goal":"lemma SetSubsetTrans_5945(A: set, B: set, S: set)\n requires A <= B && B <= S\n ensures A <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_5946","instance":5946,"id":209289,"goal":"lemma SetUnionEmpty_5946(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_5947","instance":5947,"id":209290,"goal":"lemma SetInterEmpty_5947(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_5948","instance":5948,"id":209291,"goal":"lemma SetInterSubset_5948(A: set, U: set)\n ensures A * U <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_5949","instance":5949,"id":209292,"goal":"lemma SetCardSubset_5949(B: set, S: set)\n requires B <= S\n ensures |B| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_5950","instance":5950,"id":209293,"goal":"lemma SetUnionCard_5950(S: set, U: set)\n requires S * U == {}\n ensures |S + U| == |S| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_5951","instance":5951,"id":209294,"goal":"lemma SetUnionComm_5951(U: set, B: set)\n ensures U + B == B + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_5952","instance":5952,"id":209295,"goal":"lemma SetInterComm_5952(A: set, S: set)\n ensures A * S == S * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_5953","instance":5953,"id":209296,"goal":"lemma SetUnionAssoc_5953(U: set, A: set, B: set)\n ensures (U + A) + B == U + (A + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_5954","instance":5954,"id":209297,"goal":"lemma SetSubsetRefl_5954(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_5955","instance":5955,"id":209298,"goal":"lemma SetSubsetTrans_5955(U: set, A: set, T: set)\n requires U <= A && A <= T\n ensures U <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_5956","instance":5956,"id":209299,"goal":"lemma SetUnionEmpty_5956(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_5957","instance":5957,"id":209300,"goal":"lemma SetInterEmpty_5957(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_5958","instance":5958,"id":209301,"goal":"lemma SetInterSubset_5958(B: set, S: set)\n ensures B * S <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_5959","instance":5959,"id":209302,"goal":"lemma SetCardSubset_5959(B: set, U: set)\n requires B <= U\n ensures |B| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_5960","instance":5960,"id":209303,"goal":"lemma SetUnionCard_5960(T: set, U: set)\n requires T * U == {}\n ensures |T + U| == |T| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_5961","instance":5961,"id":209304,"goal":"lemma SetUnionComm_5961(S: set, T: set)\n ensures S + T == T + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_5962","instance":5962,"id":209305,"goal":"lemma SetInterComm_5962(S: set, U: set)\n ensures S * U == U * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_5963","instance":5963,"id":209306,"goal":"lemma SetUnionAssoc_5963(T: set, U: set, A: set)\n ensures (T + U) + A == T + (U + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_5964","instance":5964,"id":209307,"goal":"lemma SetSubsetRefl_5964(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_5965","instance":5965,"id":209308,"goal":"lemma SetSubsetTrans_5965(B: set, S: set, U: set)\n requires B <= S && S <= U\n ensures B <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_5966","instance":5966,"id":209309,"goal":"lemma SetUnionEmpty_5966(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_5967","instance":5967,"id":209310,"goal":"lemma SetInterEmpty_5967(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_5968","instance":5968,"id":209311,"goal":"lemma SetInterSubset_5968(U: set, B: set)\n ensures U * B <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_5969","instance":5969,"id":209312,"goal":"lemma SetCardSubset_5969(U: set, T: set)\n requires U <= T\n ensures |U| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_5970","instance":5970,"id":209313,"goal":"lemma SetUnionCard_5970(T: set, S: set)\n requires T * S == {}\n ensures |T + S| == |T| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_5971","instance":5971,"id":209314,"goal":"lemma SetUnionComm_5971(S: set, A: set)\n ensures S + A == A + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_5972","instance":5972,"id":209315,"goal":"lemma SetInterComm_5972(T: set, S: set)\n ensures T * S == S * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_5973","instance":5973,"id":209316,"goal":"lemma SetUnionAssoc_5973(U: set, S: set, A: set)\n ensures (U + S) + A == U + (S + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_5974","instance":5974,"id":209317,"goal":"lemma SetSubsetRefl_5974(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_5975","instance":5975,"id":209318,"goal":"lemma SetSubsetTrans_5975(A: set, B: set, U: set)\n requires A <= B && B <= U\n ensures A <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_5976","instance":5976,"id":209319,"goal":"lemma SetUnionEmpty_5976(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_5977","instance":5977,"id":209320,"goal":"lemma SetInterEmpty_5977(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_5978","instance":5978,"id":209321,"goal":"lemma SetInterSubset_5978(A: set, B: set)\n ensures A * B <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_5979","instance":5979,"id":209322,"goal":"lemma SetCardSubset_5979(U: set, B: set)\n requires U <= B\n ensures |U| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_5980","instance":5980,"id":209323,"goal":"lemma SetUnionCard_5980(T: set, S: set)\n requires T * S == {}\n ensures |T + S| == |T| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_5981","instance":5981,"id":209324,"goal":"lemma SetUnionComm_5981(A: set, S: set)\n ensures A + S == S + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_5982","instance":5982,"id":209325,"goal":"lemma SetInterComm_5982(T: set, U: set)\n ensures T * U == U * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_5983","instance":5983,"id":209326,"goal":"lemma SetUnionAssoc_5983(A: set, U: set, B: set)\n ensures (A + U) + B == A + (U + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_5984","instance":5984,"id":209327,"goal":"lemma SetSubsetRefl_5984(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_5985","instance":5985,"id":209328,"goal":"lemma SetSubsetTrans_5985(T: set, S: set, A: set)\n requires T <= S && S <= A\n ensures T <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_5986","instance":5986,"id":209329,"goal":"lemma SetUnionEmpty_5986(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_5987","instance":5987,"id":209330,"goal":"lemma SetInterEmpty_5987(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_5988","instance":5988,"id":209331,"goal":"lemma SetInterSubset_5988(A: set, B: set)\n ensures A * B <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_5989","instance":5989,"id":209332,"goal":"lemma SetCardSubset_5989(U: set, A: set)\n requires U <= A\n ensures |U| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_5990","instance":5990,"id":209333,"goal":"lemma SetUnionCard_5990(B: set, U: set)\n requires B * U == {}\n ensures |B + U| == |B| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_5991","instance":5991,"id":209334,"goal":"lemma SetUnionComm_5991(U: set, B: set)\n ensures U + B == B + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_5992","instance":5992,"id":209335,"goal":"lemma SetInterComm_5992(B: set, U: set)\n ensures B * U == U * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_5993","instance":5993,"id":209336,"goal":"lemma SetUnionAssoc_5993(A: set, S: set, T: set)\n ensures (A + S) + T == A + (S + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_5994","instance":5994,"id":209337,"goal":"lemma SetSubsetRefl_5994(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_5995","instance":5995,"id":209338,"goal":"lemma SetSubsetTrans_5995(S: set, U: set, A: set)\n requires S <= U && U <= A\n ensures S <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_5996","instance":5996,"id":209339,"goal":"lemma SetUnionEmpty_5996(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_5997","instance":5997,"id":209340,"goal":"lemma SetInterEmpty_5997(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_5998","instance":5998,"id":209341,"goal":"lemma SetInterSubset_5998(U: set, T: set)\n ensures U * T <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_5999","instance":5999,"id":209342,"goal":"lemma SetCardSubset_5999(T: set, U: set)\n requires T <= U\n ensures |T| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_6000","instance":6000,"id":209343,"goal":"lemma SetUnionCard_6000(B: set, T: set)\n requires B * T == {}\n ensures |B + T| == |B| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_6001","instance":6001,"id":209344,"goal":"lemma SetUnionComm_6001(T: set, U: set)\n ensures T + U == U + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_6002","instance":6002,"id":209345,"goal":"lemma SetInterComm_6002(A: set, B: set)\n ensures A * B == B * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_6003","instance":6003,"id":209346,"goal":"lemma SetUnionAssoc_6003(U: set, B: set, A: set)\n ensures (U + B) + A == U + (B + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_6004","instance":6004,"id":209347,"goal":"lemma SetSubsetRefl_6004(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_6005","instance":6005,"id":209348,"goal":"lemma SetSubsetTrans_6005(T: set, B: set, A: set)\n requires T <= B && B <= A\n ensures T <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_6006","instance":6006,"id":209349,"goal":"lemma SetUnionEmpty_6006(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_6007","instance":6007,"id":209350,"goal":"lemma SetInterEmpty_6007(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_6008","instance":6008,"id":209351,"goal":"lemma SetInterSubset_6008(T: set, B: set)\n ensures T * B <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_6009","instance":6009,"id":209352,"goal":"lemma SetCardSubset_6009(A: set, U: set)\n requires A <= U\n ensures |A| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_6010","instance":6010,"id":209353,"goal":"lemma SetUnionCard_6010(U: set, T: set)\n requires U * T == {}\n ensures |U + T| == |U| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_6011","instance":6011,"id":209354,"goal":"lemma SetUnionComm_6011(T: set, U: set)\n ensures T + U == U + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_6012","instance":6012,"id":209355,"goal":"lemma SetInterComm_6012(B: set, U: set)\n ensures B * U == U * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_6013","instance":6013,"id":209356,"goal":"lemma SetUnionAssoc_6013(B: set, U: set, T: set)\n ensures (B + U) + T == B + (U + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_6014","instance":6014,"id":209357,"goal":"lemma SetSubsetRefl_6014(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_6015","instance":6015,"id":209358,"goal":"lemma SetSubsetTrans_6015(S: set, U: set, B: set)\n requires S <= U && U <= B\n ensures S <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_6016","instance":6016,"id":209359,"goal":"lemma SetUnionEmpty_6016(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_6017","instance":6017,"id":209360,"goal":"lemma SetInterEmpty_6017(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_6018","instance":6018,"id":209361,"goal":"lemma SetInterSubset_6018(A: set, B: set)\n ensures A * B <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_6019","instance":6019,"id":209362,"goal":"lemma SetCardSubset_6019(S: set, U: set)\n requires S <= U\n ensures |S| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_6020","instance":6020,"id":209363,"goal":"lemma SetUnionCard_6020(T: set, S: set)\n requires T * S == {}\n ensures |T + S| == |T| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_6021","instance":6021,"id":209364,"goal":"lemma SetUnionComm_6021(U: set, A: set)\n ensures U + A == A + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_6022","instance":6022,"id":209365,"goal":"lemma SetInterComm_6022(T: set, S: set)\n ensures T * S == S * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_6023","instance":6023,"id":209366,"goal":"lemma SetUnionAssoc_6023(S: set, A: set, U: set)\n ensures (S + A) + U == S + (A + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_6024","instance":6024,"id":209367,"goal":"lemma SetSubsetRefl_6024(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_6025","instance":6025,"id":209368,"goal":"lemma SetSubsetTrans_6025(A: set, U: set, T: set)\n requires A <= U && U <= T\n ensures A <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_6026","instance":6026,"id":209369,"goal":"lemma SetUnionEmpty_6026(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_6027","instance":6027,"id":209370,"goal":"lemma SetInterEmpty_6027(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_6028","instance":6028,"id":209371,"goal":"lemma SetInterSubset_6028(A: set, T: set)\n ensures A * T <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_6029","instance":6029,"id":209372,"goal":"lemma SetCardSubset_6029(A: set, S: set)\n requires A <= S\n ensures |A| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_6030","instance":6030,"id":209373,"goal":"lemma SetUnionCard_6030(S: set, B: set)\n requires S * B == {}\n ensures |S + B| == |S| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_6031","instance":6031,"id":209374,"goal":"lemma SetUnionComm_6031(S: set, U: set)\n ensures S + U == U + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_6032","instance":6032,"id":209375,"goal":"lemma SetInterComm_6032(A: set, B: set)\n ensures A * B == B * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_6033","instance":6033,"id":209376,"goal":"lemma SetUnionAssoc_6033(A: set, U: set, B: set)\n ensures (A + U) + B == A + (U + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_6034","instance":6034,"id":209377,"goal":"lemma SetSubsetRefl_6034(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_6035","instance":6035,"id":209378,"goal":"lemma SetSubsetTrans_6035(B: set, A: set, S: set)\n requires B <= A && A <= S\n ensures B <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_6036","instance":6036,"id":209379,"goal":"lemma SetUnionEmpty_6036(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_6037","instance":6037,"id":209380,"goal":"lemma SetInterEmpty_6037(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_6038","instance":6038,"id":209381,"goal":"lemma SetInterSubset_6038(T: set, A: set)\n ensures T * A <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_6039","instance":6039,"id":209382,"goal":"lemma SetCardSubset_6039(S: set, A: set)\n requires S <= A\n ensures |S| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_6040","instance":6040,"id":209383,"goal":"lemma SetUnionCard_6040(T: set, U: set)\n requires T * U == {}\n ensures |T + U| == |T| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_6041","instance":6041,"id":209384,"goal":"lemma SetUnionComm_6041(U: set, B: set)\n ensures U + B == B + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_6042","instance":6042,"id":209385,"goal":"lemma SetInterComm_6042(A: set, U: set)\n ensures A * U == U * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_6043","instance":6043,"id":209386,"goal":"lemma SetUnionAssoc_6043(A: set, B: set, S: set)\n ensures (A + B) + S == A + (B + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_6044","instance":6044,"id":209387,"goal":"lemma SetSubsetRefl_6044(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_6045","instance":6045,"id":209388,"goal":"lemma SetSubsetTrans_6045(A: set, B: set, S: set)\n requires A <= B && B <= S\n ensures A <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_6046","instance":6046,"id":209389,"goal":"lemma SetUnionEmpty_6046(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_6047","instance":6047,"id":209390,"goal":"lemma SetInterEmpty_6047(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_6048","instance":6048,"id":209391,"goal":"lemma SetInterSubset_6048(T: set, A: set)\n ensures T * A <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_6049","instance":6049,"id":209392,"goal":"lemma SetCardSubset_6049(T: set, A: set)\n requires T <= A\n ensures |T| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_6050","instance":6050,"id":209393,"goal":"lemma SetUnionCard_6050(A: set, U: set)\n requires A * U == {}\n ensures |A + U| == |A| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_6051","instance":6051,"id":209394,"goal":"lemma SetUnionComm_6051(U: set, T: set)\n ensures U + T == T + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_6052","instance":6052,"id":209395,"goal":"lemma SetInterComm_6052(T: set, A: set)\n ensures T * A == A * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_6053","instance":6053,"id":209396,"goal":"lemma SetUnionAssoc_6053(U: set, T: set, B: set)\n ensures (U + T) + B == U + (T + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_6054","instance":6054,"id":209397,"goal":"lemma SetSubsetRefl_6054(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_6055","instance":6055,"id":209398,"goal":"lemma SetSubsetTrans_6055(S: set, B: set, T: set)\n requires S <= B && B <= T\n ensures S <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_6056","instance":6056,"id":209399,"goal":"lemma SetUnionEmpty_6056(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_6057","instance":6057,"id":209400,"goal":"lemma SetInterEmpty_6057(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_6058","instance":6058,"id":209401,"goal":"lemma SetInterSubset_6058(S: set, U: set)\n ensures S * U <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_6059","instance":6059,"id":209402,"goal":"lemma SetCardSubset_6059(S: set, B: set)\n requires S <= B\n ensures |S| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_6060","instance":6060,"id":209403,"goal":"lemma SetUnionCard_6060(T: set, S: set)\n requires T * S == {}\n ensures |T + S| == |T| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_6061","instance":6061,"id":209404,"goal":"lemma SetUnionComm_6061(S: set, U: set)\n ensures S + U == U + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_6062","instance":6062,"id":209405,"goal":"lemma SetInterComm_6062(A: set, U: set)\n ensures A * U == U * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_6063","instance":6063,"id":209406,"goal":"lemma SetUnionAssoc_6063(B: set, A: set, U: set)\n ensures (B + A) + U == B + (A + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_6064","instance":6064,"id":209407,"goal":"lemma SetSubsetRefl_6064(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_6065","instance":6065,"id":209408,"goal":"lemma SetSubsetTrans_6065(T: set, A: set, U: set)\n requires T <= A && A <= U\n ensures T <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_6066","instance":6066,"id":209409,"goal":"lemma SetUnionEmpty_6066(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_6067","instance":6067,"id":209410,"goal":"lemma SetInterEmpty_6067(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_6068","instance":6068,"id":209411,"goal":"lemma SetInterSubset_6068(T: set, U: set)\n ensures T * U <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_6069","instance":6069,"id":209412,"goal":"lemma SetCardSubset_6069(T: set, A: set)\n requires T <= A\n ensures |T| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_6070","instance":6070,"id":209413,"goal":"lemma SetUnionCard_6070(B: set, S: set)\n requires B * S == {}\n ensures |B + S| == |B| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_6071","instance":6071,"id":209414,"goal":"lemma SetUnionComm_6071(U: set, B: set)\n ensures U + B == B + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_6072","instance":6072,"id":209415,"goal":"lemma SetInterComm_6072(U: set, B: set)\n ensures U * B == B * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_6073","instance":6073,"id":209416,"goal":"lemma SetUnionAssoc_6073(T: set, B: set, U: set)\n ensures (T + B) + U == T + (B + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_6074","instance":6074,"id":209417,"goal":"lemma SetSubsetRefl_6074(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_6075","instance":6075,"id":209418,"goal":"lemma SetSubsetTrans_6075(B: set, A: set, S: set)\n requires B <= A && A <= S\n ensures B <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_6076","instance":6076,"id":209419,"goal":"lemma SetUnionEmpty_6076(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_6077","instance":6077,"id":209420,"goal":"lemma SetInterEmpty_6077(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_6078","instance":6078,"id":209421,"goal":"lemma SetInterSubset_6078(T: set, U: set)\n ensures T * U <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_6079","instance":6079,"id":209422,"goal":"lemma SetCardSubset_6079(T: set, S: set)\n requires T <= S\n ensures |T| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_6080","instance":6080,"id":209423,"goal":"lemma SetUnionCard_6080(U: set, S: set)\n requires U * S == {}\n ensures |U + S| == |U| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_6081","instance":6081,"id":209424,"goal":"lemma SetUnionComm_6081(S: set, B: set)\n ensures S + B == B + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_6082","instance":6082,"id":209425,"goal":"lemma SetInterComm_6082(S: set, U: set)\n ensures S * U == U * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_6083","instance":6083,"id":209426,"goal":"lemma SetUnionAssoc_6083(A: set, S: set, U: set)\n ensures (A + S) + U == A + (S + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_6084","instance":6084,"id":209427,"goal":"lemma SetSubsetRefl_6084(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_6085","instance":6085,"id":209428,"goal":"lemma SetSubsetTrans_6085(S: set, T: set, A: set)\n requires S <= T && T <= A\n ensures S <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_6086","instance":6086,"id":209429,"goal":"lemma SetUnionEmpty_6086(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_6087","instance":6087,"id":209430,"goal":"lemma SetInterEmpty_6087(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_6088","instance":6088,"id":209431,"goal":"lemma SetInterSubset_6088(T: set, B: set)\n ensures T * B <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_6089","instance":6089,"id":209432,"goal":"lemma SetCardSubset_6089(S: set, A: set)\n requires S <= A\n ensures |S| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_6090","instance":6090,"id":209433,"goal":"lemma SetUnionCard_6090(A: set, U: set)\n requires A * U == {}\n ensures |A + U| == |A| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_6091","instance":6091,"id":209434,"goal":"lemma SetUnionComm_6091(T: set, U: set)\n ensures T + U == U + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_6092","instance":6092,"id":209435,"goal":"lemma SetInterComm_6092(A: set, S: set)\n ensures A * S == S * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_6093","instance":6093,"id":209436,"goal":"lemma SetUnionAssoc_6093(B: set, U: set, T: set)\n ensures (B + U) + T == B + (U + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_6094","instance":6094,"id":209437,"goal":"lemma SetSubsetRefl_6094(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_6095","instance":6095,"id":209438,"goal":"lemma SetSubsetTrans_6095(A: set, U: set, T: set)\n requires A <= U && U <= T\n ensures A <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_6096","instance":6096,"id":209439,"goal":"lemma SetUnionEmpty_6096(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_6097","instance":6097,"id":209440,"goal":"lemma SetInterEmpty_6097(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_6098","instance":6098,"id":209441,"goal":"lemma SetInterSubset_6098(A: set, S: set)\n ensures A * S <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_6099","instance":6099,"id":209442,"goal":"lemma SetCardSubset_6099(S: set, U: set)\n requires S <= U\n ensures |S| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_6100","instance":6100,"id":209443,"goal":"lemma SetUnionCard_6100(B: set, S: set)\n requires B * S == {}\n ensures |B + S| == |B| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_6101","instance":6101,"id":209444,"goal":"lemma SetUnionComm_6101(B: set, T: set)\n ensures B + T == T + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_6102","instance":6102,"id":209445,"goal":"lemma SetInterComm_6102(T: set, A: set)\n ensures T * A == A * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_6103","instance":6103,"id":209446,"goal":"lemma SetUnionAssoc_6103(B: set, A: set, U: set)\n ensures (B + A) + U == B + (A + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_6104","instance":6104,"id":209447,"goal":"lemma SetSubsetRefl_6104(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_6105","instance":6105,"id":209448,"goal":"lemma SetSubsetTrans_6105(T: set, U: set, B: set)\n requires T <= U && U <= B\n ensures T <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_6106","instance":6106,"id":209449,"goal":"lemma SetUnionEmpty_6106(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_6107","instance":6107,"id":209450,"goal":"lemma SetInterEmpty_6107(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_6108","instance":6108,"id":209451,"goal":"lemma SetInterSubset_6108(B: set, U: set)\n ensures B * U <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_6109","instance":6109,"id":209452,"goal":"lemma SetCardSubset_6109(A: set, B: set)\n requires A <= B\n ensures |A| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_6110","instance":6110,"id":209453,"goal":"lemma SetUnionCard_6110(B: set, T: set)\n requires B * T == {}\n ensures |B + T| == |B| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_6111","instance":6111,"id":209454,"goal":"lemma SetUnionComm_6111(A: set, U: set)\n ensures A + U == U + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_6112","instance":6112,"id":209455,"goal":"lemma SetInterComm_6112(S: set, U: set)\n ensures S * U == U * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_6113","instance":6113,"id":209456,"goal":"lemma SetUnionAssoc_6113(A: set, B: set, T: set)\n ensures (A + B) + T == A + (B + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_6114","instance":6114,"id":209457,"goal":"lemma SetSubsetRefl_6114(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_6115","instance":6115,"id":209458,"goal":"lemma SetSubsetTrans_6115(S: set, U: set, A: set)\n requires S <= U && U <= A\n ensures S <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_6116","instance":6116,"id":209459,"goal":"lemma SetUnionEmpty_6116(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_6117","instance":6117,"id":209460,"goal":"lemma SetInterEmpty_6117(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_6118","instance":6118,"id":209461,"goal":"lemma SetInterSubset_6118(T: set, U: set)\n ensures T * U <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_6119","instance":6119,"id":209462,"goal":"lemma SetCardSubset_6119(U: set, T: set)\n requires U <= T\n ensures |U| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_6120","instance":6120,"id":209463,"goal":"lemma SetUnionCard_6120(T: set, U: set)\n requires T * U == {}\n ensures |T + U| == |T| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_6121","instance":6121,"id":209464,"goal":"lemma SetUnionComm_6121(A: set, B: set)\n ensures A + B == B + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_6122","instance":6122,"id":209465,"goal":"lemma SetInterComm_6122(B: set, A: set)\n ensures B * A == A * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_6123","instance":6123,"id":209466,"goal":"lemma SetUnionAssoc_6123(U: set, A: set, S: set)\n ensures (U + A) + S == U + (A + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_6124","instance":6124,"id":209467,"goal":"lemma SetSubsetRefl_6124(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_6125","instance":6125,"id":209468,"goal":"lemma SetSubsetTrans_6125(B: set, U: set, A: set)\n requires B <= U && U <= A\n ensures B <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_6126","instance":6126,"id":209469,"goal":"lemma SetUnionEmpty_6126(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_6127","instance":6127,"id":209470,"goal":"lemma SetInterEmpty_6127(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_6128","instance":6128,"id":209471,"goal":"lemma SetInterSubset_6128(B: set, A: set)\n ensures B * A <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_6129","instance":6129,"id":209472,"goal":"lemma SetCardSubset_6129(B: set, S: set)\n requires B <= S\n ensures |B| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_6130","instance":6130,"id":209473,"goal":"lemma SetUnionCard_6130(T: set, S: set)\n requires T * S == {}\n ensures |T + S| == |T| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_6131","instance":6131,"id":209474,"goal":"lemma SetUnionComm_6131(S: set, A: set)\n ensures S + A == A + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_6132","instance":6132,"id":209475,"goal":"lemma SetInterComm_6132(B: set, U: set)\n ensures B * U == U * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_6133","instance":6133,"id":209476,"goal":"lemma SetUnionAssoc_6133(B: set, T: set, U: set)\n ensures (B + T) + U == B + (T + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_6134","instance":6134,"id":209477,"goal":"lemma SetSubsetRefl_6134(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_6135","instance":6135,"id":209478,"goal":"lemma SetSubsetTrans_6135(U: set, S: set, B: set)\n requires U <= S && S <= B\n ensures U <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_6136","instance":6136,"id":209479,"goal":"lemma SetUnionEmpty_6136(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_6137","instance":6137,"id":209480,"goal":"lemma SetInterEmpty_6137(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_6138","instance":6138,"id":209481,"goal":"lemma SetInterSubset_6138(A: set, B: set)\n ensures A * B <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_6139","instance":6139,"id":209482,"goal":"lemma SetCardSubset_6139(U: set, T: set)\n requires U <= T\n ensures |U| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_6140","instance":6140,"id":209483,"goal":"lemma SetUnionCard_6140(U: set, T: set)\n requires U * T == {}\n ensures |U + T| == |U| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_6141","instance":6141,"id":209484,"goal":"lemma SetUnionComm_6141(B: set, S: set)\n ensures B + S == S + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_6142","instance":6142,"id":209485,"goal":"lemma SetInterComm_6142(U: set, A: set)\n ensures U * A == A * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_6143","instance":6143,"id":209486,"goal":"lemma SetUnionAssoc_6143(T: set, U: set, A: set)\n ensures (T + U) + A == T + (U + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_6144","instance":6144,"id":209487,"goal":"lemma SetSubsetRefl_6144(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_6145","instance":6145,"id":209488,"goal":"lemma SetSubsetTrans_6145(B: set, U: set, S: set)\n requires B <= U && U <= S\n ensures B <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_6146","instance":6146,"id":209489,"goal":"lemma SetUnionEmpty_6146(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_6147","instance":6147,"id":209490,"goal":"lemma SetInterEmpty_6147(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_6148","instance":6148,"id":209491,"goal":"lemma SetInterSubset_6148(T: set, S: set)\n ensures T * S <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_6149","instance":6149,"id":209492,"goal":"lemma SetCardSubset_6149(A: set, T: set)\n requires A <= T\n ensures |A| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_6150","instance":6150,"id":209493,"goal":"lemma SetUnionCard_6150(B: set, U: set)\n requires B * U == {}\n ensures |B + U| == |B| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_6151","instance":6151,"id":209494,"goal":"lemma SetUnionComm_6151(A: set, T: set)\n ensures A + T == T + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_6152","instance":6152,"id":209495,"goal":"lemma SetInterComm_6152(T: set, A: set)\n ensures T * A == A * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_6153","instance":6153,"id":209496,"goal":"lemma SetUnionAssoc_6153(B: set, S: set, U: set)\n ensures (B + S) + U == B + (S + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_6154","instance":6154,"id":209497,"goal":"lemma SetSubsetRefl_6154(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_6155","instance":6155,"id":209498,"goal":"lemma SetSubsetTrans_6155(S: set, U: set, B: set)\n requires S <= U && U <= B\n ensures S <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_6156","instance":6156,"id":209499,"goal":"lemma SetUnionEmpty_6156(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_6157","instance":6157,"id":209500,"goal":"lemma SetInterEmpty_6157(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_6158","instance":6158,"id":209501,"goal":"lemma SetInterSubset_6158(B: set, A: set)\n ensures B * A <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_6159","instance":6159,"id":209502,"goal":"lemma SetCardSubset_6159(B: set, A: set)\n requires B <= A\n ensures |B| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_6160","instance":6160,"id":209503,"goal":"lemma SetUnionCard_6160(A: set, T: set)\n requires A * T == {}\n ensures |A + T| == |A| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_6161","instance":6161,"id":209504,"goal":"lemma SetUnionComm_6161(B: set, S: set)\n ensures B + S == S + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_6162","instance":6162,"id":209505,"goal":"lemma SetInterComm_6162(B: set, A: set)\n ensures B * A == A * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_6163","instance":6163,"id":209506,"goal":"lemma SetUnionAssoc_6163(A: set, S: set, B: set)\n ensures (A + S) + B == A + (S + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_6164","instance":6164,"id":209507,"goal":"lemma SetSubsetRefl_6164(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_6165","instance":6165,"id":209508,"goal":"lemma SetSubsetTrans_6165(S: set, A: set, U: set)\n requires S <= A && A <= U\n ensures S <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_6166","instance":6166,"id":209509,"goal":"lemma SetUnionEmpty_6166(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_6167","instance":6167,"id":209510,"goal":"lemma SetInterEmpty_6167(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_6168","instance":6168,"id":209511,"goal":"lemma SetInterSubset_6168(B: set, S: set)\n ensures B * S <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_6169","instance":6169,"id":209512,"goal":"lemma SetCardSubset_6169(B: set, T: set)\n requires B <= T\n ensures |B| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_6170","instance":6170,"id":209513,"goal":"lemma SetUnionCard_6170(U: set, A: set)\n requires U * A == {}\n ensures |U + A| == |U| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_6171","instance":6171,"id":209514,"goal":"lemma SetUnionComm_6171(A: set, T: set)\n ensures A + T == T + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_6172","instance":6172,"id":209515,"goal":"lemma SetInterComm_6172(B: set, S: set)\n ensures B * S == S * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_6173","instance":6173,"id":209516,"goal":"lemma SetUnionAssoc_6173(B: set, A: set, U: set)\n ensures (B + A) + U == B + (A + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_6174","instance":6174,"id":209517,"goal":"lemma SetSubsetRefl_6174(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_6175","instance":6175,"id":209518,"goal":"lemma SetSubsetTrans_6175(A: set, T: set, B: set)\n requires A <= T && T <= B\n ensures A <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_6176","instance":6176,"id":209519,"goal":"lemma SetUnionEmpty_6176(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_6177","instance":6177,"id":209520,"goal":"lemma SetInterEmpty_6177(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_6178","instance":6178,"id":209521,"goal":"lemma SetInterSubset_6178(S: set, U: set)\n ensures S * U <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_6179","instance":6179,"id":209522,"goal":"lemma SetCardSubset_6179(A: set, S: set)\n requires A <= S\n ensures |A| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_6180","instance":6180,"id":209523,"goal":"lemma SetUnionCard_6180(U: set, S: set)\n requires U * S == {}\n ensures |U + S| == |U| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_6181","instance":6181,"id":209524,"goal":"lemma SetUnionComm_6181(A: set, U: set)\n ensures A + U == U + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_6182","instance":6182,"id":209525,"goal":"lemma SetInterComm_6182(B: set, A: set)\n ensures B * A == A * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_6183","instance":6183,"id":209526,"goal":"lemma SetUnionAssoc_6183(A: set, S: set, B: set)\n ensures (A + S) + B == A + (S + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_6184","instance":6184,"id":209527,"goal":"lemma SetSubsetRefl_6184(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_6185","instance":6185,"id":209528,"goal":"lemma SetSubsetTrans_6185(B: set, T: set, U: set)\n requires B <= T && T <= U\n ensures B <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_6186","instance":6186,"id":209529,"goal":"lemma SetUnionEmpty_6186(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_6187","instance":6187,"id":209530,"goal":"lemma SetInterEmpty_6187(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_6188","instance":6188,"id":209531,"goal":"lemma SetInterSubset_6188(U: set, T: set)\n ensures U * T <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_6189","instance":6189,"id":209532,"goal":"lemma SetCardSubset_6189(B: set, U: set)\n requires B <= U\n ensures |B| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_6190","instance":6190,"id":209533,"goal":"lemma SetUnionCard_6190(T: set, U: set)\n requires T * U == {}\n ensures |T + U| == |T| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_6191","instance":6191,"id":209534,"goal":"lemma SetUnionComm_6191(B: set, S: set)\n ensures B + S == S + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_6192","instance":6192,"id":209535,"goal":"lemma SetInterComm_6192(U: set, T: set)\n ensures U * T == T * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_6193","instance":6193,"id":209536,"goal":"lemma SetUnionAssoc_6193(A: set, B: set, S: set)\n ensures (A + B) + S == A + (B + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_6194","instance":6194,"id":209537,"goal":"lemma SetSubsetRefl_6194(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_6195","instance":6195,"id":209538,"goal":"lemma SetSubsetTrans_6195(T: set, A: set, B: set)\n requires T <= A && A <= B\n ensures T <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_6196","instance":6196,"id":209539,"goal":"lemma SetUnionEmpty_6196(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_6197","instance":6197,"id":209540,"goal":"lemma SetInterEmpty_6197(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_6198","instance":6198,"id":209541,"goal":"lemma SetInterSubset_6198(S: set, A: set)\n ensures S * A <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_6199","instance":6199,"id":209542,"goal":"lemma SetCardSubset_6199(S: set, U: set)\n requires S <= U\n ensures |S| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_6200","instance":6200,"id":209543,"goal":"lemma SetUnionCard_6200(B: set, A: set)\n requires B * A == {}\n ensures |B + A| == |B| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_6201","instance":6201,"id":209544,"goal":"lemma SetUnionComm_6201(U: set, A: set)\n ensures U + A == A + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_6202","instance":6202,"id":209545,"goal":"lemma SetInterComm_6202(A: set, U: set)\n ensures A * U == U * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_6203","instance":6203,"id":209546,"goal":"lemma SetUnionAssoc_6203(S: set, U: set, B: set)\n ensures (S + U) + B == S + (U + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_6204","instance":6204,"id":209547,"goal":"lemma SetSubsetRefl_6204(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_6205","instance":6205,"id":209548,"goal":"lemma SetSubsetTrans_6205(A: set, S: set, T: set)\n requires A <= S && S <= T\n ensures A <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_6206","instance":6206,"id":209549,"goal":"lemma SetUnionEmpty_6206(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_6207","instance":6207,"id":209550,"goal":"lemma SetInterEmpty_6207(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_6208","instance":6208,"id":209551,"goal":"lemma SetInterSubset_6208(B: set, S: set)\n ensures B * S <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_6209","instance":6209,"id":209552,"goal":"lemma SetCardSubset_6209(U: set, A: set)\n requires U <= A\n ensures |U| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_6210","instance":6210,"id":209553,"goal":"lemma SetUnionCard_6210(T: set, A: set)\n requires T * A == {}\n ensures |T + A| == |T| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_6211","instance":6211,"id":209554,"goal":"lemma SetUnionComm_6211(T: set, A: set)\n ensures T + A == A + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_6212","instance":6212,"id":209555,"goal":"lemma SetInterComm_6212(S: set, T: set)\n ensures S * T == T * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_6213","instance":6213,"id":209556,"goal":"lemma SetUnionAssoc_6213(U: set, A: set, T: set)\n ensures (U + A) + T == U + (A + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_6214","instance":6214,"id":209557,"goal":"lemma SetSubsetRefl_6214(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_6215","instance":6215,"id":209558,"goal":"lemma SetSubsetTrans_6215(U: set, B: set, S: set)\n requires U <= B && B <= S\n ensures U <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_6216","instance":6216,"id":209559,"goal":"lemma SetUnionEmpty_6216(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_6217","instance":6217,"id":209560,"goal":"lemma SetInterEmpty_6217(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_6218","instance":6218,"id":209561,"goal":"lemma SetInterSubset_6218(B: set, A: set)\n ensures B * A <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_6219","instance":6219,"id":209562,"goal":"lemma SetCardSubset_6219(S: set, U: set)\n requires S <= U\n ensures |S| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_6220","instance":6220,"id":209563,"goal":"lemma SetUnionCard_6220(T: set, U: set)\n requires T * U == {}\n ensures |T + U| == |T| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_6221","instance":6221,"id":209564,"goal":"lemma SetUnionComm_6221(B: set, S: set)\n ensures B + S == S + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_6222","instance":6222,"id":209565,"goal":"lemma SetInterComm_6222(T: set, A: set)\n ensures T * A == A * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_6223","instance":6223,"id":209566,"goal":"lemma SetUnionAssoc_6223(A: set, S: set, T: set)\n ensures (A + S) + T == A + (S + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_6224","instance":6224,"id":209567,"goal":"lemma SetSubsetRefl_6224(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_6225","instance":6225,"id":209568,"goal":"lemma SetSubsetTrans_6225(A: set, S: set, B: set)\n requires A <= S && S <= B\n ensures A <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_6226","instance":6226,"id":209569,"goal":"lemma SetUnionEmpty_6226(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_6227","instance":6227,"id":209570,"goal":"lemma SetInterEmpty_6227(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_6228","instance":6228,"id":209571,"goal":"lemma SetInterSubset_6228(U: set, S: set)\n ensures U * S <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_6229","instance":6229,"id":209572,"goal":"lemma SetCardSubset_6229(T: set, S: set)\n requires T <= S\n ensures |T| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_6230","instance":6230,"id":209573,"goal":"lemma SetUnionCard_6230(A: set, B: set)\n requires A * B == {}\n ensures |A + B| == |A| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_6231","instance":6231,"id":209574,"goal":"lemma SetUnionComm_6231(T: set, U: set)\n ensures T + U == U + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_6232","instance":6232,"id":209575,"goal":"lemma SetInterComm_6232(S: set, T: set)\n ensures S * T == T * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_6233","instance":6233,"id":209576,"goal":"lemma SetUnionAssoc_6233(B: set, A: set, S: set)\n ensures (B + A) + S == B + (A + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_6234","instance":6234,"id":209577,"goal":"lemma SetSubsetRefl_6234(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_6235","instance":6235,"id":209578,"goal":"lemma SetSubsetTrans_6235(A: set, S: set, T: set)\n requires A <= S && S <= T\n ensures A <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_6236","instance":6236,"id":209579,"goal":"lemma SetUnionEmpty_6236(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_6237","instance":6237,"id":209580,"goal":"lemma SetInterEmpty_6237(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_6238","instance":6238,"id":209581,"goal":"lemma SetInterSubset_6238(T: set, S: set)\n ensures T * S <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_6239","instance":6239,"id":209582,"goal":"lemma SetCardSubset_6239(A: set, T: set)\n requires A <= T\n ensures |A| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_6240","instance":6240,"id":209583,"goal":"lemma SetUnionCard_6240(U: set, A: set)\n requires U * A == {}\n ensures |U + A| == |U| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_6241","instance":6241,"id":209584,"goal":"lemma SetUnionComm_6241(U: set, T: set)\n ensures U + T == T + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_6242","instance":6242,"id":209585,"goal":"lemma SetInterComm_6242(T: set, A: set)\n ensures T * A == A * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_6243","instance":6243,"id":209586,"goal":"lemma SetUnionAssoc_6243(T: set, A: set, U: set)\n ensures (T + A) + U == T + (A + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_6244","instance":6244,"id":209587,"goal":"lemma SetSubsetRefl_6244(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_6245","instance":6245,"id":209588,"goal":"lemma SetSubsetTrans_6245(B: set, A: set, T: set)\n requires B <= A && A <= T\n ensures B <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_6246","instance":6246,"id":209589,"goal":"lemma SetUnionEmpty_6246(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_6247","instance":6247,"id":209590,"goal":"lemma SetInterEmpty_6247(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_6248","instance":6248,"id":209591,"goal":"lemma SetInterSubset_6248(A: set, S: set)\n ensures A * S <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_6249","instance":6249,"id":209592,"goal":"lemma SetCardSubset_6249(A: set, U: set)\n requires A <= U\n ensures |A| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_6250","instance":6250,"id":209593,"goal":"lemma SetUnionCard_6250(S: set, A: set)\n requires S * A == {}\n ensures |S + A| == |S| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_6251","instance":6251,"id":209594,"goal":"lemma SetUnionComm_6251(S: set, U: set)\n ensures S + U == U + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_6252","instance":6252,"id":209595,"goal":"lemma SetInterComm_6252(B: set, S: set)\n ensures B * S == S * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_6253","instance":6253,"id":209596,"goal":"lemma SetUnionAssoc_6253(T: set, U: set, S: set)\n ensures (T + U) + S == T + (U + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_6254","instance":6254,"id":209597,"goal":"lemma SetSubsetRefl_6254(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_6255","instance":6255,"id":209598,"goal":"lemma SetSubsetTrans_6255(S: set, T: set, B: set)\n requires S <= T && T <= B\n ensures S <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_6256","instance":6256,"id":209599,"goal":"lemma SetUnionEmpty_6256(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_6257","instance":6257,"id":209600,"goal":"lemma SetInterEmpty_6257(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_6258","instance":6258,"id":209601,"goal":"lemma SetInterSubset_6258(S: set, T: set)\n ensures S * T <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_6259","instance":6259,"id":209602,"goal":"lemma SetCardSubset_6259(A: set, S: set)\n requires A <= S\n ensures |A| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_6260","instance":6260,"id":209603,"goal":"lemma SetUnionCard_6260(T: set, A: set)\n requires T * A == {}\n ensures |T + A| == |T| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_6261","instance":6261,"id":209604,"goal":"lemma SetUnionComm_6261(B: set, S: set)\n ensures B + S == S + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_6262","instance":6262,"id":209605,"goal":"lemma SetInterComm_6262(U: set, T: set)\n ensures U * T == T * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_6263","instance":6263,"id":209606,"goal":"lemma SetUnionAssoc_6263(B: set, U: set, S: set)\n ensures (B + U) + S == B + (U + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_6264","instance":6264,"id":209607,"goal":"lemma SetSubsetRefl_6264(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_6265","instance":6265,"id":209608,"goal":"lemma SetSubsetTrans_6265(S: set, A: set, B: set)\n requires S <= A && A <= B\n ensures S <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_6266","instance":6266,"id":209609,"goal":"lemma SetUnionEmpty_6266(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_6267","instance":6267,"id":209610,"goal":"lemma SetInterEmpty_6267(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_6268","instance":6268,"id":209611,"goal":"lemma SetInterSubset_6268(S: set, U: set)\n ensures S * U <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_6269","instance":6269,"id":209612,"goal":"lemma SetCardSubset_6269(U: set, B: set)\n requires U <= B\n ensures |U| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_6270","instance":6270,"id":209613,"goal":"lemma SetUnionCard_6270(A: set, U: set)\n requires A * U == {}\n ensures |A + U| == |A| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_6271","instance":6271,"id":209614,"goal":"lemma SetUnionComm_6271(T: set, A: set)\n ensures T + A == A + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_6272","instance":6272,"id":209615,"goal":"lemma SetInterComm_6272(T: set, U: set)\n ensures T * U == U * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_6273","instance":6273,"id":209616,"goal":"lemma SetUnionAssoc_6273(B: set, A: set, T: set)\n ensures (B + A) + T == B + (A + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_6274","instance":6274,"id":209617,"goal":"lemma SetSubsetRefl_6274(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_6275","instance":6275,"id":209618,"goal":"lemma SetSubsetTrans_6275(A: set, S: set, T: set)\n requires A <= S && S <= T\n ensures A <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_6276","instance":6276,"id":209619,"goal":"lemma SetUnionEmpty_6276(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_6277","instance":6277,"id":209620,"goal":"lemma SetInterEmpty_6277(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_6278","instance":6278,"id":209621,"goal":"lemma SetInterSubset_6278(U: set, S: set)\n ensures U * S <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_6279","instance":6279,"id":209622,"goal":"lemma SetCardSubset_6279(A: set, B: set)\n requires A <= B\n ensures |A| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_6280","instance":6280,"id":209623,"goal":"lemma SetUnionCard_6280(B: set, S: set)\n requires B * S == {}\n ensures |B + S| == |B| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_6281","instance":6281,"id":209624,"goal":"lemma SetUnionComm_6281(U: set, B: set)\n ensures U + B == B + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_6282","instance":6282,"id":209625,"goal":"lemma SetInterComm_6282(T: set, S: set)\n ensures T * S == S * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_6283","instance":6283,"id":209626,"goal":"lemma SetUnionAssoc_6283(T: set, S: set, B: set)\n ensures (T + S) + B == T + (S + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_6284","instance":6284,"id":209627,"goal":"lemma SetSubsetRefl_6284(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_6285","instance":6285,"id":209628,"goal":"lemma SetSubsetTrans_6285(S: set, A: set, T: set)\n requires S <= A && A <= T\n ensures S <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_6286","instance":6286,"id":209629,"goal":"lemma SetUnionEmpty_6286(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_6287","instance":6287,"id":209630,"goal":"lemma SetInterEmpty_6287(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_6288","instance":6288,"id":209631,"goal":"lemma SetInterSubset_6288(B: set, A: set)\n ensures B * A <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_6289","instance":6289,"id":209632,"goal":"lemma SetCardSubset_6289(A: set, B: set)\n requires A <= B\n ensures |A| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_6290","instance":6290,"id":209633,"goal":"lemma SetUnionCard_6290(A: set, T: set)\n requires A * T == {}\n ensures |A + T| == |A| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_6291","instance":6291,"id":209634,"goal":"lemma SetUnionComm_6291(A: set, S: set)\n ensures A + S == S + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_6292","instance":6292,"id":209635,"goal":"lemma SetInterComm_6292(S: set, U: set)\n ensures S * U == U * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_6293","instance":6293,"id":209636,"goal":"lemma SetUnionAssoc_6293(B: set, T: set, U: set)\n ensures (B + T) + U == B + (T + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_6294","instance":6294,"id":209637,"goal":"lemma SetSubsetRefl_6294(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_6295","instance":6295,"id":209638,"goal":"lemma SetSubsetTrans_6295(B: set, S: set, A: set)\n requires B <= S && S <= A\n ensures B <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_6296","instance":6296,"id":209639,"goal":"lemma SetUnionEmpty_6296(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_6297","instance":6297,"id":209640,"goal":"lemma SetInterEmpty_6297(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_6298","instance":6298,"id":209641,"goal":"lemma SetInterSubset_6298(U: set, T: set)\n ensures U * T <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_6299","instance":6299,"id":209642,"goal":"lemma SetCardSubset_6299(B: set, T: set)\n requires B <= T\n ensures |B| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_6300","instance":6300,"id":209643,"goal":"lemma SetUnionCard_6300(U: set, S: set)\n requires U * S == {}\n ensures |U + S| == |U| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_6301","instance":6301,"id":209644,"goal":"lemma SetUnionComm_6301(T: set, B: set)\n ensures T + B == B + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_6302","instance":6302,"id":209645,"goal":"lemma SetInterComm_6302(T: set, A: set)\n ensures T * A == A * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_6303","instance":6303,"id":209646,"goal":"lemma SetUnionAssoc_6303(B: set, A: set, U: set)\n ensures (B + A) + U == B + (A + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_6304","instance":6304,"id":209647,"goal":"lemma SetSubsetRefl_6304(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_6305","instance":6305,"id":209648,"goal":"lemma SetSubsetTrans_6305(S: set, B: set, U: set)\n requires S <= B && B <= U\n ensures S <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_6306","instance":6306,"id":209649,"goal":"lemma SetUnionEmpty_6306(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_6307","instance":6307,"id":209650,"goal":"lemma SetInterEmpty_6307(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_6308","instance":6308,"id":209651,"goal":"lemma SetInterSubset_6308(A: set, U: set)\n ensures A * U <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_6309","instance":6309,"id":209652,"goal":"lemma SetCardSubset_6309(B: set, T: set)\n requires B <= T\n ensures |B| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_6310","instance":6310,"id":209653,"goal":"lemma SetUnionCard_6310(T: set, S: set)\n requires T * S == {}\n ensures |T + S| == |T| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_6311","instance":6311,"id":209654,"goal":"lemma SetUnionComm_6311(B: set, S: set)\n ensures B + S == S + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_6312","instance":6312,"id":209655,"goal":"lemma SetInterComm_6312(A: set, B: set)\n ensures A * B == B * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_6313","instance":6313,"id":209656,"goal":"lemma SetUnionAssoc_6313(U: set, S: set, A: set)\n ensures (U + S) + A == U + (S + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_6314","instance":6314,"id":209657,"goal":"lemma SetSubsetRefl_6314(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_6315","instance":6315,"id":209658,"goal":"lemma SetSubsetTrans_6315(U: set, B: set, S: set)\n requires U <= B && B <= S\n ensures U <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_6316","instance":6316,"id":209659,"goal":"lemma SetUnionEmpty_6316(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_6317","instance":6317,"id":209660,"goal":"lemma SetInterEmpty_6317(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_6318","instance":6318,"id":209661,"goal":"lemma SetInterSubset_6318(B: set, S: set)\n ensures B * S <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_6319","instance":6319,"id":209662,"goal":"lemma SetCardSubset_6319(A: set, U: set)\n requires A <= U\n ensures |A| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_6320","instance":6320,"id":209663,"goal":"lemma SetUnionCard_6320(B: set, A: set)\n requires B * A == {}\n ensures |B + A| == |B| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_6321","instance":6321,"id":209664,"goal":"lemma SetUnionComm_6321(B: set, S: set)\n ensures B + S == S + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_6322","instance":6322,"id":209665,"goal":"lemma SetInterComm_6322(S: set, B: set)\n ensures S * B == B * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_6323","instance":6323,"id":209666,"goal":"lemma SetUnionAssoc_6323(U: set, B: set, A: set)\n ensures (U + B) + A == U + (B + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_6324","instance":6324,"id":209667,"goal":"lemma SetSubsetRefl_6324(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_6325","instance":6325,"id":209668,"goal":"lemma SetSubsetTrans_6325(T: set, U: set, B: set)\n requires T <= U && U <= B\n ensures T <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_6326","instance":6326,"id":209669,"goal":"lemma SetUnionEmpty_6326(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_6327","instance":6327,"id":209670,"goal":"lemma SetInterEmpty_6327(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_6328","instance":6328,"id":209671,"goal":"lemma SetInterSubset_6328(S: set, A: set)\n ensures S * A <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_6329","instance":6329,"id":209672,"goal":"lemma SetCardSubset_6329(S: set, T: set)\n requires S <= T\n ensures |S| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_6330","instance":6330,"id":209673,"goal":"lemma SetUnionCard_6330(S: set, A: set)\n requires S * A == {}\n ensures |S + A| == |S| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_6331","instance":6331,"id":209674,"goal":"lemma SetUnionComm_6331(T: set, B: set)\n ensures T + B == B + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_6332","instance":6332,"id":209675,"goal":"lemma SetInterComm_6332(A: set, B: set)\n ensures A * B == B * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_6333","instance":6333,"id":209676,"goal":"lemma SetUnionAssoc_6333(A: set, B: set, U: set)\n ensures (A + B) + U == A + (B + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_6334","instance":6334,"id":209677,"goal":"lemma SetSubsetRefl_6334(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_6335","instance":6335,"id":209678,"goal":"lemma SetSubsetTrans_6335(S: set, B: set, T: set)\n requires S <= B && B <= T\n ensures S <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_6336","instance":6336,"id":209679,"goal":"lemma SetUnionEmpty_6336(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_6337","instance":6337,"id":209680,"goal":"lemma SetInterEmpty_6337(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_6338","instance":6338,"id":209681,"goal":"lemma SetInterSubset_6338(B: set, S: set)\n ensures B * S <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_6339","instance":6339,"id":209682,"goal":"lemma SetCardSubset_6339(T: set, B: set)\n requires T <= B\n ensures |T| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_6340","instance":6340,"id":209683,"goal":"lemma SetUnionCard_6340(S: set, B: set)\n requires S * B == {}\n ensures |S + B| == |S| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_6341","instance":6341,"id":209684,"goal":"lemma SetUnionComm_6341(B: set, A: set)\n ensures B + A == A + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_6342","instance":6342,"id":209685,"goal":"lemma SetInterComm_6342(A: set, B: set)\n ensures A * B == B * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_6343","instance":6343,"id":209686,"goal":"lemma SetUnionAssoc_6343(A: set, T: set, B: set)\n ensures (A + T) + B == A + (T + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_6344","instance":6344,"id":209687,"goal":"lemma SetSubsetRefl_6344(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_6345","instance":6345,"id":209688,"goal":"lemma SetSubsetTrans_6345(T: set, U: set, S: set)\n requires T <= U && U <= S\n ensures T <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_6346","instance":6346,"id":209689,"goal":"lemma SetUnionEmpty_6346(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_6347","instance":6347,"id":209690,"goal":"lemma SetInterEmpty_6347(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_6348","instance":6348,"id":209691,"goal":"lemma SetInterSubset_6348(T: set, B: set)\n ensures T * B <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_6349","instance":6349,"id":209692,"goal":"lemma SetCardSubset_6349(A: set, S: set)\n requires A <= S\n ensures |A| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_6350","instance":6350,"id":209693,"goal":"lemma SetUnionCard_6350(A: set, U: set)\n requires A * U == {}\n ensures |A + U| == |A| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_6351","instance":6351,"id":209694,"goal":"lemma SetUnionComm_6351(A: set, B: set)\n ensures A + B == B + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_6352","instance":6352,"id":209695,"goal":"lemma SetInterComm_6352(B: set, A: set)\n ensures B * A == A * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_6353","instance":6353,"id":209696,"goal":"lemma SetUnionAssoc_6353(T: set, A: set, U: set)\n ensures (T + A) + U == T + (A + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_6354","instance":6354,"id":209697,"goal":"lemma SetSubsetRefl_6354(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_6355","instance":6355,"id":209698,"goal":"lemma SetSubsetTrans_6355(B: set, A: set, S: set)\n requires B <= A && A <= S\n ensures B <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_6356","instance":6356,"id":209699,"goal":"lemma SetUnionEmpty_6356(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_6357","instance":6357,"id":209700,"goal":"lemma SetInterEmpty_6357(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_6358","instance":6358,"id":209701,"goal":"lemma SetInterSubset_6358(S: set, U: set)\n ensures S * U <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_6359","instance":6359,"id":209702,"goal":"lemma SetCardSubset_6359(U: set, B: set)\n requires U <= B\n ensures |U| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_6360","instance":6360,"id":209703,"goal":"lemma SetUnionCard_6360(A: set, T: set)\n requires A * T == {}\n ensures |A + T| == |A| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_6361","instance":6361,"id":209704,"goal":"lemma SetUnionComm_6361(S: set, U: set)\n ensures S + U == U + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_6362","instance":6362,"id":209705,"goal":"lemma SetInterComm_6362(B: set, U: set)\n ensures B * U == U * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_6363","instance":6363,"id":209706,"goal":"lemma SetUnionAssoc_6363(U: set, B: set, S: set)\n ensures (U + B) + S == U + (B + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_6364","instance":6364,"id":209707,"goal":"lemma SetSubsetRefl_6364(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_6365","instance":6365,"id":209708,"goal":"lemma SetSubsetTrans_6365(T: set, S: set, B: set)\n requires T <= S && S <= B\n ensures T <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_6366","instance":6366,"id":209709,"goal":"lemma SetUnionEmpty_6366(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_6367","instance":6367,"id":209710,"goal":"lemma SetInterEmpty_6367(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_6368","instance":6368,"id":209711,"goal":"lemma SetInterSubset_6368(T: set, S: set)\n ensures T * S <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_6369","instance":6369,"id":209712,"goal":"lemma SetCardSubset_6369(U: set, T: set)\n requires U <= T\n ensures |U| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_6370","instance":6370,"id":209713,"goal":"lemma SetUnionCard_6370(B: set, A: set)\n requires B * A == {}\n ensures |B + A| == |B| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_6371","instance":6371,"id":209714,"goal":"lemma SetUnionComm_6371(T: set, A: set)\n ensures T + A == A + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_6372","instance":6372,"id":209715,"goal":"lemma SetInterComm_6372(T: set, S: set)\n ensures T * S == S * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_6373","instance":6373,"id":209716,"goal":"lemma SetUnionAssoc_6373(B: set, A: set, T: set)\n ensures (B + A) + T == B + (A + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_6374","instance":6374,"id":209717,"goal":"lemma SetSubsetRefl_6374(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_6375","instance":6375,"id":209718,"goal":"lemma SetSubsetTrans_6375(A: set, U: set, S: set)\n requires A <= U && U <= S\n ensures A <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_6376","instance":6376,"id":209719,"goal":"lemma SetUnionEmpty_6376(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_6377","instance":6377,"id":209720,"goal":"lemma SetInterEmpty_6377(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_6378","instance":6378,"id":209721,"goal":"lemma SetInterSubset_6378(A: set, B: set)\n ensures A * B <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_6379","instance":6379,"id":209722,"goal":"lemma SetCardSubset_6379(S: set, B: set)\n requires S <= B\n ensures |S| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_6380","instance":6380,"id":209723,"goal":"lemma SetUnionCard_6380(U: set, B: set)\n requires U * B == {}\n ensures |U + B| == |U| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_6381","instance":6381,"id":209724,"goal":"lemma SetUnionComm_6381(U: set, S: set)\n ensures U + S == S + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_6382","instance":6382,"id":209725,"goal":"lemma SetInterComm_6382(T: set, U: set)\n ensures T * U == U * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_6383","instance":6383,"id":209726,"goal":"lemma SetUnionAssoc_6383(U: set, A: set, T: set)\n ensures (U + A) + T == U + (A + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_6384","instance":6384,"id":209727,"goal":"lemma SetSubsetRefl_6384(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_6385","instance":6385,"id":209728,"goal":"lemma SetSubsetTrans_6385(A: set, U: set, S: set)\n requires A <= U && U <= S\n ensures A <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_6386","instance":6386,"id":209729,"goal":"lemma SetUnionEmpty_6386(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_6387","instance":6387,"id":209730,"goal":"lemma SetInterEmpty_6387(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_6388","instance":6388,"id":209731,"goal":"lemma SetInterSubset_6388(A: set, T: set)\n ensures A * T <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_6389","instance":6389,"id":209732,"goal":"lemma SetCardSubset_6389(A: set, T: set)\n requires A <= T\n ensures |A| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_6390","instance":6390,"id":209733,"goal":"lemma SetUnionCard_6390(T: set, S: set)\n requires T * S == {}\n ensures |T + S| == |T| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_6391","instance":6391,"id":209734,"goal":"lemma SetUnionComm_6391(A: set, U: set)\n ensures A + U == U + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_6392","instance":6392,"id":209735,"goal":"lemma SetInterComm_6392(T: set, B: set)\n ensures T * B == B * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_6393","instance":6393,"id":209736,"goal":"lemma SetUnionAssoc_6393(T: set, A: set, S: set)\n ensures (T + A) + S == T + (A + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_6394","instance":6394,"id":209737,"goal":"lemma SetSubsetRefl_6394(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_6395","instance":6395,"id":209738,"goal":"lemma SetSubsetTrans_6395(A: set, U: set, T: set)\n requires A <= U && U <= T\n ensures A <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_6396","instance":6396,"id":209739,"goal":"lemma SetUnionEmpty_6396(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_6397","instance":6397,"id":209740,"goal":"lemma SetInterEmpty_6397(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_6398","instance":6398,"id":209741,"goal":"lemma SetInterSubset_6398(U: set, T: set)\n ensures U * T <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_6399","instance":6399,"id":209742,"goal":"lemma SetCardSubset_6399(B: set, T: set)\n requires B <= T\n ensures |B| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_6400","instance":6400,"id":209743,"goal":"lemma SetUnionCard_6400(U: set, T: set)\n requires U * T == {}\n ensures |U + T| == |U| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_6401","instance":6401,"id":209744,"goal":"lemma SetUnionComm_6401(B: set, U: set)\n ensures B + U == U + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_6402","instance":6402,"id":209745,"goal":"lemma SetInterComm_6402(B: set, A: set)\n ensures B * A == A * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_6403","instance":6403,"id":209746,"goal":"lemma SetUnionAssoc_6403(T: set, A: set, U: set)\n ensures (T + A) + U == T + (A + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_6404","instance":6404,"id":209747,"goal":"lemma SetSubsetRefl_6404(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_6405","instance":6405,"id":209748,"goal":"lemma SetSubsetTrans_6405(T: set, U: set, A: set)\n requires T <= U && U <= A\n ensures T <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_6406","instance":6406,"id":209749,"goal":"lemma SetUnionEmpty_6406(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_6407","instance":6407,"id":209750,"goal":"lemma SetInterEmpty_6407(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_6408","instance":6408,"id":209751,"goal":"lemma SetInterSubset_6408(U: set, A: set)\n ensures U * A <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_6409","instance":6409,"id":209752,"goal":"lemma SetCardSubset_6409(U: set, B: set)\n requires U <= B\n ensures |U| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_6410","instance":6410,"id":209753,"goal":"lemma SetUnionCard_6410(B: set, U: set)\n requires B * U == {}\n ensures |B + U| == |B| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_6411","instance":6411,"id":209754,"goal":"lemma SetUnionComm_6411(T: set, A: set)\n ensures T + A == A + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_6412","instance":6412,"id":209755,"goal":"lemma SetInterComm_6412(A: set, U: set)\n ensures A * U == U * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_6413","instance":6413,"id":209756,"goal":"lemma SetUnionAssoc_6413(A: set, U: set, S: set)\n ensures (A + U) + S == A + (U + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_6414","instance":6414,"id":209757,"goal":"lemma SetSubsetRefl_6414(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_6415","instance":6415,"id":209758,"goal":"lemma SetSubsetTrans_6415(S: set, T: set, U: set)\n requires S <= T && T <= U\n ensures S <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_6416","instance":6416,"id":209759,"goal":"lemma SetUnionEmpty_6416(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_6417","instance":6417,"id":209760,"goal":"lemma SetInterEmpty_6417(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_6418","instance":6418,"id":209761,"goal":"lemma SetInterSubset_6418(U: set, T: set)\n ensures U * T <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_6419","instance":6419,"id":209762,"goal":"lemma SetCardSubset_6419(T: set, S: set)\n requires T <= S\n ensures |T| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_6420","instance":6420,"id":209763,"goal":"lemma SetUnionCard_6420(A: set, B: set)\n requires A * B == {}\n ensures |A + B| == |A| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_6421","instance":6421,"id":209764,"goal":"lemma SetUnionComm_6421(A: set, B: set)\n ensures A + B == B + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_6422","instance":6422,"id":209765,"goal":"lemma SetInterComm_6422(S: set, U: set)\n ensures S * U == U * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_6423","instance":6423,"id":209766,"goal":"lemma SetUnionAssoc_6423(U: set, A: set, S: set)\n ensures (U + A) + S == U + (A + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_6424","instance":6424,"id":209767,"goal":"lemma SetSubsetRefl_6424(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_6425","instance":6425,"id":209768,"goal":"lemma SetSubsetTrans_6425(B: set, T: set, S: set)\n requires B <= T && T <= S\n ensures B <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_6426","instance":6426,"id":209769,"goal":"lemma SetUnionEmpty_6426(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_6427","instance":6427,"id":209770,"goal":"lemma SetInterEmpty_6427(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_6428","instance":6428,"id":209771,"goal":"lemma SetInterSubset_6428(B: set, T: set)\n ensures B * T <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_6429","instance":6429,"id":209772,"goal":"lemma SetCardSubset_6429(S: set, U: set)\n requires S <= U\n ensures |S| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_6430","instance":6430,"id":209773,"goal":"lemma SetUnionCard_6430(A: set, B: set)\n requires A * B == {}\n ensures |A + B| == |A| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_6431","instance":6431,"id":209774,"goal":"lemma SetUnionComm_6431(B: set, T: set)\n ensures B + T == T + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_6432","instance":6432,"id":209775,"goal":"lemma SetInterComm_6432(A: set, U: set)\n ensures A * U == U * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_6433","instance":6433,"id":209776,"goal":"lemma SetUnionAssoc_6433(B: set, U: set, T: set)\n ensures (B + U) + T == B + (U + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_6434","instance":6434,"id":209777,"goal":"lemma SetSubsetRefl_6434(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_6435","instance":6435,"id":209778,"goal":"lemma SetSubsetTrans_6435(S: set, U: set, A: set)\n requires S <= U && U <= A\n ensures S <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_6436","instance":6436,"id":209779,"goal":"lemma SetUnionEmpty_6436(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_6437","instance":6437,"id":209780,"goal":"lemma SetInterEmpty_6437(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_6438","instance":6438,"id":209781,"goal":"lemma SetInterSubset_6438(S: set, B: set)\n ensures S * B <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_6439","instance":6439,"id":209782,"goal":"lemma SetCardSubset_6439(U: set, A: set)\n requires U <= A\n ensures |U| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_6440","instance":6440,"id":209783,"goal":"lemma SetUnionCard_6440(S: set, A: set)\n requires S * A == {}\n ensures |S + A| == |S| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_6441","instance":6441,"id":209784,"goal":"lemma SetUnionComm_6441(A: set, U: set)\n ensures A + U == U + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_6442","instance":6442,"id":209785,"goal":"lemma SetInterComm_6442(A: set, U: set)\n ensures A * U == U * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_6443","instance":6443,"id":209786,"goal":"lemma SetUnionAssoc_6443(U: set, B: set, S: set)\n ensures (U + B) + S == U + (B + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_6444","instance":6444,"id":209787,"goal":"lemma SetSubsetRefl_6444(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_6445","instance":6445,"id":209788,"goal":"lemma SetSubsetTrans_6445(A: set, U: set, S: set)\n requires A <= U && U <= S\n ensures A <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_6446","instance":6446,"id":209789,"goal":"lemma SetUnionEmpty_6446(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_6447","instance":6447,"id":209790,"goal":"lemma SetInterEmpty_6447(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_6448","instance":6448,"id":209791,"goal":"lemma SetInterSubset_6448(U: set, A: set)\n ensures U * A <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_6449","instance":6449,"id":209792,"goal":"lemma SetCardSubset_6449(S: set, A: set)\n requires S <= A\n ensures |S| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_6450","instance":6450,"id":209793,"goal":"lemma SetUnionCard_6450(S: set, T: set)\n requires S * T == {}\n ensures |S + T| == |S| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_6451","instance":6451,"id":209794,"goal":"lemma SetUnionComm_6451(U: set, S: set)\n ensures U + S == S + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_6452","instance":6452,"id":209795,"goal":"lemma SetInterComm_6452(A: set, U: set)\n ensures A * U == U * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_6453","instance":6453,"id":209796,"goal":"lemma SetUnionAssoc_6453(B: set, U: set, A: set)\n ensures (B + U) + A == B + (U + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_6454","instance":6454,"id":209797,"goal":"lemma SetSubsetRefl_6454(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_6455","instance":6455,"id":209798,"goal":"lemma SetSubsetTrans_6455(T: set, B: set, A: set)\n requires T <= B && B <= A\n ensures T <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_6456","instance":6456,"id":209799,"goal":"lemma SetUnionEmpty_6456(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_6457","instance":6457,"id":209800,"goal":"lemma SetInterEmpty_6457(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_6458","instance":6458,"id":209801,"goal":"lemma SetInterSubset_6458(U: set, T: set)\n ensures U * T <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_6459","instance":6459,"id":209802,"goal":"lemma SetCardSubset_6459(B: set, U: set)\n requires B <= U\n ensures |B| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_6460","instance":6460,"id":209803,"goal":"lemma SetUnionCard_6460(U: set, T: set)\n requires U * T == {}\n ensures |U + T| == |U| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_6461","instance":6461,"id":209804,"goal":"lemma SetUnionComm_6461(U: set, A: set)\n ensures U + A == A + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_6462","instance":6462,"id":209805,"goal":"lemma SetInterComm_6462(T: set, B: set)\n ensures T * B == B * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_6463","instance":6463,"id":209806,"goal":"lemma SetUnionAssoc_6463(A: set, T: set, S: set)\n ensures (A + T) + S == A + (T + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_6464","instance":6464,"id":209807,"goal":"lemma SetSubsetRefl_6464(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_6465","instance":6465,"id":209808,"goal":"lemma SetSubsetTrans_6465(T: set, S: set, B: set)\n requires T <= S && S <= B\n ensures T <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_6466","instance":6466,"id":209809,"goal":"lemma SetUnionEmpty_6466(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_6467","instance":6467,"id":209810,"goal":"lemma SetInterEmpty_6467(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_6468","instance":6468,"id":209811,"goal":"lemma SetInterSubset_6468(S: set, U: set)\n ensures S * U <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_6469","instance":6469,"id":209812,"goal":"lemma SetCardSubset_6469(B: set, U: set)\n requires B <= U\n ensures |B| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_6470","instance":6470,"id":209813,"goal":"lemma SetUnionCard_6470(T: set, A: set)\n requires T * A == {}\n ensures |T + A| == |T| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_6471","instance":6471,"id":209814,"goal":"lemma SetUnionComm_6471(A: set, T: set)\n ensures A + T == T + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_6472","instance":6472,"id":209815,"goal":"lemma SetInterComm_6472(B: set, T: set)\n ensures B * T == T * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_6473","instance":6473,"id":209816,"goal":"lemma SetUnionAssoc_6473(T: set, U: set, A: set)\n ensures (T + U) + A == T + (U + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_6474","instance":6474,"id":209817,"goal":"lemma SetSubsetRefl_6474(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_6475","instance":6475,"id":209818,"goal":"lemma SetSubsetTrans_6475(A: set, B: set, S: set)\n requires A <= B && B <= S\n ensures A <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_6476","instance":6476,"id":209819,"goal":"lemma SetUnionEmpty_6476(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_6477","instance":6477,"id":209820,"goal":"lemma SetInterEmpty_6477(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_6478","instance":6478,"id":209821,"goal":"lemma SetInterSubset_6478(A: set, T: set)\n ensures A * T <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_6479","instance":6479,"id":209822,"goal":"lemma SetCardSubset_6479(S: set, B: set)\n requires S <= B\n ensures |S| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_6480","instance":6480,"id":209823,"goal":"lemma SetUnionCard_6480(B: set, A: set)\n requires B * A == {}\n ensures |B + A| == |B| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_6481","instance":6481,"id":209824,"goal":"lemma SetUnionComm_6481(B: set, S: set)\n ensures B + S == S + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_6482","instance":6482,"id":209825,"goal":"lemma SetInterComm_6482(S: set, B: set)\n ensures S * B == B * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_6483","instance":6483,"id":209826,"goal":"lemma SetUnionAssoc_6483(T: set, U: set, A: set)\n ensures (T + U) + A == T + (U + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_6484","instance":6484,"id":209827,"goal":"lemma SetSubsetRefl_6484(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_6485","instance":6485,"id":209828,"goal":"lemma SetSubsetTrans_6485(A: set, S: set, T: set)\n requires A <= S && S <= T\n ensures A <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_6486","instance":6486,"id":209829,"goal":"lemma SetUnionEmpty_6486(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_6487","instance":6487,"id":209830,"goal":"lemma SetInterEmpty_6487(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_6488","instance":6488,"id":209831,"goal":"lemma SetInterSubset_6488(S: set, T: set)\n ensures S * T <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_6489","instance":6489,"id":209832,"goal":"lemma SetCardSubset_6489(U: set, S: set)\n requires U <= S\n ensures |U| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_6490","instance":6490,"id":209833,"goal":"lemma SetUnionCard_6490(S: set, U: set)\n requires S * U == {}\n ensures |S + U| == |S| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_6491","instance":6491,"id":209834,"goal":"lemma SetUnionComm_6491(B: set, T: set)\n ensures B + T == T + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_6492","instance":6492,"id":209835,"goal":"lemma SetInterComm_6492(T: set, B: set)\n ensures T * B == B * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_6493","instance":6493,"id":209836,"goal":"lemma SetUnionAssoc_6493(A: set, B: set, S: set)\n ensures (A + B) + S == A + (B + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_6494","instance":6494,"id":209837,"goal":"lemma SetSubsetRefl_6494(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_6495","instance":6495,"id":209838,"goal":"lemma SetSubsetTrans_6495(T: set, B: set, A: set)\n requires T <= B && B <= A\n ensures T <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_6496","instance":6496,"id":209839,"goal":"lemma SetUnionEmpty_6496(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_6497","instance":6497,"id":209840,"goal":"lemma SetInterEmpty_6497(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_6498","instance":6498,"id":209841,"goal":"lemma SetInterSubset_6498(S: set, A: set)\n ensures S * A <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_6499","instance":6499,"id":209842,"goal":"lemma SetCardSubset_6499(S: set, U: set)\n requires S <= U\n ensures |S| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_6500","instance":6500,"id":209843,"goal":"lemma SetUnionCard_6500(T: set, U: set)\n requires T * U == {}\n ensures |T + U| == |T| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_6501","instance":6501,"id":209844,"goal":"lemma SetUnionComm_6501(B: set, S: set)\n ensures B + S == S + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_6502","instance":6502,"id":209845,"goal":"lemma SetInterComm_6502(U: set, T: set)\n ensures U * T == T * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_6503","instance":6503,"id":209846,"goal":"lemma SetUnionAssoc_6503(A: set, S: set, T: set)\n ensures (A + S) + T == A + (S + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_6504","instance":6504,"id":209847,"goal":"lemma SetSubsetRefl_6504(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_6505","instance":6505,"id":209848,"goal":"lemma SetSubsetTrans_6505(U: set, S: set, B: set)\n requires U <= S && S <= B\n ensures U <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_6506","instance":6506,"id":209849,"goal":"lemma SetUnionEmpty_6506(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_6507","instance":6507,"id":209850,"goal":"lemma SetInterEmpty_6507(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_6508","instance":6508,"id":209851,"goal":"lemma SetInterSubset_6508(U: set, T: set)\n ensures U * T <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_6509","instance":6509,"id":209852,"goal":"lemma SetCardSubset_6509(T: set, U: set)\n requires T <= U\n ensures |T| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_6510","instance":6510,"id":209853,"goal":"lemma SetUnionCard_6510(A: set, B: set)\n requires A * B == {}\n ensures |A + B| == |A| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_6511","instance":6511,"id":209854,"goal":"lemma SetUnionComm_6511(T: set, A: set)\n ensures T + A == A + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_6512","instance":6512,"id":209855,"goal":"lemma SetInterComm_6512(U: set, S: set)\n ensures U * S == S * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_6513","instance":6513,"id":209856,"goal":"lemma SetUnionAssoc_6513(B: set, A: set, S: set)\n ensures (B + A) + S == B + (A + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_6514","instance":6514,"id":209857,"goal":"lemma SetSubsetRefl_6514(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_6515","instance":6515,"id":209858,"goal":"lemma SetSubsetTrans_6515(T: set, B: set, S: set)\n requires T <= B && B <= S\n ensures T <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_6516","instance":6516,"id":209859,"goal":"lemma SetUnionEmpty_6516(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_6517","instance":6517,"id":209860,"goal":"lemma SetInterEmpty_6517(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_6518","instance":6518,"id":209861,"goal":"lemma SetInterSubset_6518(T: set, S: set)\n ensures T * S <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_6519","instance":6519,"id":209862,"goal":"lemma SetCardSubset_6519(A: set, S: set)\n requires A <= S\n ensures |A| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_6520","instance":6520,"id":209863,"goal":"lemma SetUnionCard_6520(S: set, B: set)\n requires S * B == {}\n ensures |S + B| == |S| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_6521","instance":6521,"id":209864,"goal":"lemma SetUnionComm_6521(S: set, T: set)\n ensures S + T == T + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_6522","instance":6522,"id":209865,"goal":"lemma SetInterComm_6522(T: set, U: set)\n ensures T * U == U * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_6523","instance":6523,"id":209866,"goal":"lemma SetUnionAssoc_6523(T: set, B: set, S: set)\n ensures (T + B) + S == T + (B + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_6524","instance":6524,"id":209867,"goal":"lemma SetSubsetRefl_6524(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_6525","instance":6525,"id":209868,"goal":"lemma SetSubsetTrans_6525(B: set, A: set, S: set)\n requires B <= A && A <= S\n ensures B <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_6526","instance":6526,"id":209869,"goal":"lemma SetUnionEmpty_6526(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_6527","instance":6527,"id":209870,"goal":"lemma SetInterEmpty_6527(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_6528","instance":6528,"id":209871,"goal":"lemma SetInterSubset_6528(U: set, A: set)\n ensures U * A <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_6529","instance":6529,"id":209872,"goal":"lemma SetCardSubset_6529(A: set, S: set)\n requires A <= S\n ensures |A| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_6530","instance":6530,"id":209873,"goal":"lemma SetUnionCard_6530(U: set, T: set)\n requires U * T == {}\n ensures |U + T| == |U| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_6531","instance":6531,"id":209874,"goal":"lemma SetUnionComm_6531(T: set, U: set)\n ensures T + U == U + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_6532","instance":6532,"id":209875,"goal":"lemma SetInterComm_6532(A: set, S: set)\n ensures A * S == S * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_6533","instance":6533,"id":209876,"goal":"lemma SetUnionAssoc_6533(B: set, T: set, U: set)\n ensures (B + T) + U == B + (T + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_6534","instance":6534,"id":209877,"goal":"lemma SetSubsetRefl_6534(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_6535","instance":6535,"id":209878,"goal":"lemma SetSubsetTrans_6535(B: set, U: set, T: set)\n requires B <= U && U <= T\n ensures B <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_6536","instance":6536,"id":209879,"goal":"lemma SetUnionEmpty_6536(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_6537","instance":6537,"id":209880,"goal":"lemma SetInterEmpty_6537(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_6538","instance":6538,"id":209881,"goal":"lemma SetInterSubset_6538(T: set, B: set)\n ensures T * B <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_6539","instance":6539,"id":209882,"goal":"lemma SetCardSubset_6539(B: set, T: set)\n requires B <= T\n ensures |B| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_6540","instance":6540,"id":209883,"goal":"lemma SetUnionCard_6540(T: set, U: set)\n requires T * U == {}\n ensures |T + U| == |T| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_6541","instance":6541,"id":209884,"goal":"lemma SetUnionComm_6541(S: set, T: set)\n ensures S + T == T + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_6542","instance":6542,"id":209885,"goal":"lemma SetInterComm_6542(T: set, B: set)\n ensures T * B == B * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_6543","instance":6543,"id":209886,"goal":"lemma SetUnionAssoc_6543(T: set, A: set, U: set)\n ensures (T + A) + U == T + (A + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_6544","instance":6544,"id":209887,"goal":"lemma SetSubsetRefl_6544(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_6545","instance":6545,"id":209888,"goal":"lemma SetSubsetTrans_6545(S: set, A: set, B: set)\n requires S <= A && A <= B\n ensures S <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_6546","instance":6546,"id":209889,"goal":"lemma SetUnionEmpty_6546(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_6547","instance":6547,"id":209890,"goal":"lemma SetInterEmpty_6547(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_6548","instance":6548,"id":209891,"goal":"lemma SetInterSubset_6548(T: set, B: set)\n ensures T * B <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_6549","instance":6549,"id":209892,"goal":"lemma SetCardSubset_6549(T: set, S: set)\n requires T <= S\n ensures |T| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_6550","instance":6550,"id":209893,"goal":"lemma SetUnionCard_6550(U: set, T: set)\n requires U * T == {}\n ensures |U + T| == |U| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_6551","instance":6551,"id":209894,"goal":"lemma SetUnionComm_6551(S: set, T: set)\n ensures S + T == T + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_6552","instance":6552,"id":209895,"goal":"lemma SetInterComm_6552(T: set, A: set)\n ensures T * A == A * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_6553","instance":6553,"id":209896,"goal":"lemma SetUnionAssoc_6553(B: set, T: set, U: set)\n ensures (B + T) + U == B + (T + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_6554","instance":6554,"id":209897,"goal":"lemma SetSubsetRefl_6554(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_6555","instance":6555,"id":209898,"goal":"lemma SetSubsetTrans_6555(T: set, A: set, B: set)\n requires T <= A && A <= B\n ensures T <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_6556","instance":6556,"id":209899,"goal":"lemma SetUnionEmpty_6556(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_6557","instance":6557,"id":209900,"goal":"lemma SetInterEmpty_6557(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_6558","instance":6558,"id":209901,"goal":"lemma SetInterSubset_6558(A: set, S: set)\n ensures A * S <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_6559","instance":6559,"id":209902,"goal":"lemma SetCardSubset_6559(T: set, A: set)\n requires T <= A\n ensures |T| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_6560","instance":6560,"id":209903,"goal":"lemma SetUnionCard_6560(B: set, T: set)\n requires B * T == {}\n ensures |B + T| == |B| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_6561","instance":6561,"id":209904,"goal":"lemma SetUnionComm_6561(B: set, T: set)\n ensures B + T == T + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_6562","instance":6562,"id":209905,"goal":"lemma SetInterComm_6562(S: set, U: set)\n ensures S * U == U * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_6563","instance":6563,"id":209906,"goal":"lemma SetUnionAssoc_6563(T: set, A: set, U: set)\n ensures (T + A) + U == T + (A + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_6564","instance":6564,"id":209907,"goal":"lemma SetSubsetRefl_6564(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_6565","instance":6565,"id":209908,"goal":"lemma SetSubsetTrans_6565(B: set, S: set, T: set)\n requires B <= S && S <= T\n ensures B <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_6566","instance":6566,"id":209909,"goal":"lemma SetUnionEmpty_6566(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_6567","instance":6567,"id":209910,"goal":"lemma SetInterEmpty_6567(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_6568","instance":6568,"id":209911,"goal":"lemma SetInterSubset_6568(T: set, S: set)\n ensures T * S <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_6569","instance":6569,"id":209912,"goal":"lemma SetCardSubset_6569(T: set, U: set)\n requires T <= U\n ensures |T| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_6570","instance":6570,"id":209913,"goal":"lemma SetUnionCard_6570(B: set, A: set)\n requires B * A == {}\n ensures |B + A| == |B| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_6571","instance":6571,"id":209914,"goal":"lemma SetUnionComm_6571(U: set, A: set)\n ensures U + A == A + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_6572","instance":6572,"id":209915,"goal":"lemma SetInterComm_6572(U: set, S: set)\n ensures U * S == S * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_6573","instance":6573,"id":209916,"goal":"lemma SetUnionAssoc_6573(U: set, T: set, A: set)\n ensures (U + T) + A == U + (T + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_6574","instance":6574,"id":209917,"goal":"lemma SetSubsetRefl_6574(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_6575","instance":6575,"id":209918,"goal":"lemma SetSubsetTrans_6575(B: set, A: set, U: set)\n requires B <= A && A <= U\n ensures B <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_6576","instance":6576,"id":209919,"goal":"lemma SetUnionEmpty_6576(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_6577","instance":6577,"id":209920,"goal":"lemma SetInterEmpty_6577(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_6578","instance":6578,"id":209921,"goal":"lemma SetInterSubset_6578(U: set, S: set)\n ensures U * S <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_6579","instance":6579,"id":209922,"goal":"lemma SetCardSubset_6579(A: set, S: set)\n requires A <= S\n ensures |A| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_6580","instance":6580,"id":209923,"goal":"lemma SetUnionCard_6580(S: set, U: set)\n requires S * U == {}\n ensures |S + U| == |S| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_6581","instance":6581,"id":209924,"goal":"lemma SetUnionComm_6581(A: set, U: set)\n ensures A + U == U + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_6582","instance":6582,"id":209925,"goal":"lemma SetInterComm_6582(T: set, B: set)\n ensures T * B == B * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_6583","instance":6583,"id":209926,"goal":"lemma SetUnionAssoc_6583(A: set, S: set, B: set)\n ensures (A + S) + B == A + (S + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_6584","instance":6584,"id":209927,"goal":"lemma SetSubsetRefl_6584(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_6585","instance":6585,"id":209928,"goal":"lemma SetSubsetTrans_6585(S: set, B: set, T: set)\n requires S <= B && B <= T\n ensures S <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_6586","instance":6586,"id":209929,"goal":"lemma SetUnionEmpty_6586(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_6587","instance":6587,"id":209930,"goal":"lemma SetInterEmpty_6587(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_6588","instance":6588,"id":209931,"goal":"lemma SetInterSubset_6588(T: set, B: set)\n ensures T * B <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_6589","instance":6589,"id":209932,"goal":"lemma SetCardSubset_6589(S: set, A: set)\n requires S <= A\n ensures |S| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_6590","instance":6590,"id":209933,"goal":"lemma SetUnionCard_6590(A: set, U: set)\n requires A * U == {}\n ensures |A + U| == |A| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_6591","instance":6591,"id":209934,"goal":"lemma SetUnionComm_6591(T: set, U: set)\n ensures T + U == U + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_6592","instance":6592,"id":209935,"goal":"lemma SetInterComm_6592(B: set, T: set)\n ensures B * T == T * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_6593","instance":6593,"id":209936,"goal":"lemma SetUnionAssoc_6593(T: set, A: set, B: set)\n ensures (T + A) + B == T + (A + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_6594","instance":6594,"id":209937,"goal":"lemma SetSubsetRefl_6594(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_6595","instance":6595,"id":209938,"goal":"lemma SetSubsetTrans_6595(S: set, T: set, A: set)\n requires S <= T && T <= A\n ensures S <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_6596","instance":6596,"id":209939,"goal":"lemma SetUnionEmpty_6596(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_6597","instance":6597,"id":209940,"goal":"lemma SetInterEmpty_6597(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_6598","instance":6598,"id":209941,"goal":"lemma SetInterSubset_6598(B: set, U: set)\n ensures B * U <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_6599","instance":6599,"id":209942,"goal":"lemma SetCardSubset_6599(B: set, S: set)\n requires B <= S\n ensures |B| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_6600","instance":6600,"id":209943,"goal":"lemma SetUnionCard_6600(U: set, A: set)\n requires U * A == {}\n ensures |U + A| == |U| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_6601","instance":6601,"id":209944,"goal":"lemma SetUnionComm_6601(S: set, A: set)\n ensures S + A == A + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_6602","instance":6602,"id":209945,"goal":"lemma SetInterComm_6602(S: set, U: set)\n ensures S * U == U * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_6603","instance":6603,"id":209946,"goal":"lemma SetUnionAssoc_6603(A: set, U: set, B: set)\n ensures (A + U) + B == A + (U + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_6604","instance":6604,"id":209947,"goal":"lemma SetSubsetRefl_6604(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_6605","instance":6605,"id":209948,"goal":"lemma SetSubsetTrans_6605(T: set, B: set, U: set)\n requires T <= B && B <= U\n ensures T <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_6606","instance":6606,"id":209949,"goal":"lemma SetUnionEmpty_6606(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_6607","instance":6607,"id":209950,"goal":"lemma SetInterEmpty_6607(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_6608","instance":6608,"id":209951,"goal":"lemma SetInterSubset_6608(T: set, B: set)\n ensures T * B <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_6609","instance":6609,"id":209952,"goal":"lemma SetCardSubset_6609(B: set, T: set)\n requires B <= T\n ensures |B| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_6610","instance":6610,"id":209953,"goal":"lemma SetUnionCard_6610(A: set, U: set)\n requires A * U == {}\n ensures |A + U| == |A| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_6611","instance":6611,"id":209954,"goal":"lemma SetUnionComm_6611(T: set, A: set)\n ensures T + A == A + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_6612","instance":6612,"id":209955,"goal":"lemma SetInterComm_6612(U: set, B: set)\n ensures U * B == B * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_6613","instance":6613,"id":209956,"goal":"lemma SetUnionAssoc_6613(S: set, U: set, T: set)\n ensures (S + U) + T == S + (U + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_6614","instance":6614,"id":209957,"goal":"lemma SetSubsetRefl_6614(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_6615","instance":6615,"id":209958,"goal":"lemma SetSubsetTrans_6615(B: set, T: set, U: set)\n requires B <= T && T <= U\n ensures B <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_6616","instance":6616,"id":209959,"goal":"lemma SetUnionEmpty_6616(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_6617","instance":6617,"id":209960,"goal":"lemma SetInterEmpty_6617(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_6618","instance":6618,"id":209961,"goal":"lemma SetInterSubset_6618(B: set, T: set)\n ensures B * T <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_6619","instance":6619,"id":209962,"goal":"lemma SetCardSubset_6619(B: set, U: set)\n requires B <= U\n ensures |B| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_6620","instance":6620,"id":209963,"goal":"lemma SetUnionCard_6620(S: set, U: set)\n requires S * U == {}\n ensures |S + U| == |S| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_6621","instance":6621,"id":209964,"goal":"lemma SetUnionComm_6621(T: set, B: set)\n ensures T + B == B + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_6622","instance":6622,"id":209965,"goal":"lemma SetInterComm_6622(T: set, B: set)\n ensures T * B == B * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_6623","instance":6623,"id":209966,"goal":"lemma SetUnionAssoc_6623(A: set, S: set, B: set)\n ensures (A + S) + B == A + (S + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_6624","instance":6624,"id":209967,"goal":"lemma SetSubsetRefl_6624(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_6625","instance":6625,"id":209968,"goal":"lemma SetSubsetTrans_6625(T: set, U: set, S: set)\n requires T <= U && U <= S\n ensures T <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_6626","instance":6626,"id":209969,"goal":"lemma SetUnionEmpty_6626(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_6627","instance":6627,"id":209970,"goal":"lemma SetInterEmpty_6627(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_6628","instance":6628,"id":209971,"goal":"lemma SetInterSubset_6628(A: set, T: set)\n ensures A * T <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_6629","instance":6629,"id":209972,"goal":"lemma SetCardSubset_6629(T: set, S: set)\n requires T <= S\n ensures |T| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_6630","instance":6630,"id":209973,"goal":"lemma SetUnionCard_6630(A: set, B: set)\n requires A * B == {}\n ensures |A + B| == |A| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_6631","instance":6631,"id":209974,"goal":"lemma SetUnionComm_6631(B: set, A: set)\n ensures B + A == A + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_6632","instance":6632,"id":209975,"goal":"lemma SetInterComm_6632(U: set, S: set)\n ensures U * S == S * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_6633","instance":6633,"id":209976,"goal":"lemma SetUnionAssoc_6633(B: set, T: set, U: set)\n ensures (B + T) + U == B + (T + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_6634","instance":6634,"id":209977,"goal":"lemma SetSubsetRefl_6634(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_6635","instance":6635,"id":209978,"goal":"lemma SetSubsetTrans_6635(S: set, B: set, U: set)\n requires S <= B && B <= U\n ensures S <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_6636","instance":6636,"id":209979,"goal":"lemma SetUnionEmpty_6636(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_6637","instance":6637,"id":209980,"goal":"lemma SetInterEmpty_6637(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_6638","instance":6638,"id":209981,"goal":"lemma SetInterSubset_6638(A: set, S: set)\n ensures A * S <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_6639","instance":6639,"id":209982,"goal":"lemma SetCardSubset_6639(B: set, S: set)\n requires B <= S\n ensures |B| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_6640","instance":6640,"id":209983,"goal":"lemma SetUnionCard_6640(B: set, S: set)\n requires B * S == {}\n ensures |B + S| == |B| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_6641","instance":6641,"id":209984,"goal":"lemma SetUnionComm_6641(U: set, T: set)\n ensures U + T == T + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_6642","instance":6642,"id":209985,"goal":"lemma SetInterComm_6642(S: set, U: set)\n ensures S * U == U * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_6643","instance":6643,"id":209986,"goal":"lemma SetUnionAssoc_6643(A: set, T: set, S: set)\n ensures (A + T) + S == A + (T + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_6644","instance":6644,"id":209987,"goal":"lemma SetSubsetRefl_6644(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_6645","instance":6645,"id":209988,"goal":"lemma SetSubsetTrans_6645(A: set, U: set, S: set)\n requires A <= U && U <= S\n ensures A <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_6646","instance":6646,"id":209989,"goal":"lemma SetUnionEmpty_6646(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_6647","instance":6647,"id":209990,"goal":"lemma SetInterEmpty_6647(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_6648","instance":6648,"id":209991,"goal":"lemma SetInterSubset_6648(B: set, S: set)\n ensures B * S <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_6649","instance":6649,"id":209992,"goal":"lemma SetCardSubset_6649(S: set, A: set)\n requires S <= A\n ensures |S| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_6650","instance":6650,"id":209993,"goal":"lemma SetUnionCard_6650(T: set, U: set)\n requires T * U == {}\n ensures |T + U| == |T| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_6651","instance":6651,"id":209994,"goal":"lemma SetUnionComm_6651(U: set, A: set)\n ensures U + A == A + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_6652","instance":6652,"id":209995,"goal":"lemma SetInterComm_6652(T: set, A: set)\n ensures T * A == A * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_6653","instance":6653,"id":209996,"goal":"lemma SetUnionAssoc_6653(S: set, A: set, U: set)\n ensures (S + A) + U == S + (A + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_6654","instance":6654,"id":209997,"goal":"lemma SetSubsetRefl_6654(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_6655","instance":6655,"id":209998,"goal":"lemma SetSubsetTrans_6655(U: set, A: set, T: set)\n requires U <= A && A <= T\n ensures U <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_6656","instance":6656,"id":209999,"goal":"lemma SetUnionEmpty_6656(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_6657","instance":6657,"id":210000,"goal":"lemma SetInterEmpty_6657(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_6658","instance":6658,"id":210001,"goal":"lemma SetInterSubset_6658(T: set, A: set)\n ensures T * A <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_6659","instance":6659,"id":210002,"goal":"lemma SetCardSubset_6659(S: set, U: set)\n requires S <= U\n ensures |S| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_6660","instance":6660,"id":210003,"goal":"lemma SetUnionCard_6660(T: set, B: set)\n requires T * B == {}\n ensures |T + B| == |T| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_6661","instance":6661,"id":210004,"goal":"lemma SetUnionComm_6661(A: set, T: set)\n ensures A + T == T + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_6662","instance":6662,"id":210005,"goal":"lemma SetInterComm_6662(S: set, U: set)\n ensures S * U == U * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_6663","instance":6663,"id":210006,"goal":"lemma SetUnionAssoc_6663(T: set, U: set, B: set)\n ensures (T + U) + B == T + (U + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_6664","instance":6664,"id":210007,"goal":"lemma SetSubsetRefl_6664(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_6665","instance":6665,"id":210008,"goal":"lemma SetSubsetTrans_6665(A: set, B: set, T: set)\n requires A <= B && B <= T\n ensures A <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_6666","instance":6666,"id":210009,"goal":"lemma SetUnionEmpty_6666(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_6667","instance":6667,"id":210010,"goal":"lemma SetInterEmpty_6667(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_6668","instance":6668,"id":210011,"goal":"lemma SetInterSubset_6668(T: set, B: set)\n ensures T * B <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_6669","instance":6669,"id":210012,"goal":"lemma SetCardSubset_6669(T: set, A: set)\n requires T <= A\n ensures |T| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_6670","instance":6670,"id":210013,"goal":"lemma SetUnionCard_6670(T: set, U: set)\n requires T * U == {}\n ensures |T + U| == |T| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_6671","instance":6671,"id":210014,"goal":"lemma SetUnionComm_6671(S: set, A: set)\n ensures S + A == A + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_6672","instance":6672,"id":210015,"goal":"lemma SetInterComm_6672(U: set, B: set)\n ensures U * B == B * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_6673","instance":6673,"id":210016,"goal":"lemma SetUnionAssoc_6673(A: set, T: set, U: set)\n ensures (A + T) + U == A + (T + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_6674","instance":6674,"id":210017,"goal":"lemma SetSubsetRefl_6674(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_6675","instance":6675,"id":210018,"goal":"lemma SetSubsetTrans_6675(T: set, B: set, U: set)\n requires T <= B && B <= U\n ensures T <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_6676","instance":6676,"id":210019,"goal":"lemma SetUnionEmpty_6676(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_6677","instance":6677,"id":210020,"goal":"lemma SetInterEmpty_6677(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_6678","instance":6678,"id":210021,"goal":"lemma SetInterSubset_6678(U: set, A: set)\n ensures U * A <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_6679","instance":6679,"id":210022,"goal":"lemma SetCardSubset_6679(B: set, S: set)\n requires B <= S\n ensures |B| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_6680","instance":6680,"id":210023,"goal":"lemma SetUnionCard_6680(S: set, A: set)\n requires S * A == {}\n ensures |S + A| == |S| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_6681","instance":6681,"id":210024,"goal":"lemma SetUnionComm_6681(U: set, A: set)\n ensures U + A == A + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_6682","instance":6682,"id":210025,"goal":"lemma SetInterComm_6682(U: set, A: set)\n ensures U * A == A * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_6683","instance":6683,"id":210026,"goal":"lemma SetUnionAssoc_6683(B: set, U: set, A: set)\n ensures (B + U) + A == B + (U + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_6684","instance":6684,"id":210027,"goal":"lemma SetSubsetRefl_6684(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_6685","instance":6685,"id":210028,"goal":"lemma SetSubsetTrans_6685(S: set, B: set, U: set)\n requires S <= B && B <= U\n ensures S <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_6686","instance":6686,"id":210029,"goal":"lemma SetUnionEmpty_6686(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_6687","instance":6687,"id":210030,"goal":"lemma SetInterEmpty_6687(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_6688","instance":6688,"id":210031,"goal":"lemma SetInterSubset_6688(U: set, B: set)\n ensures U * B <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_6689","instance":6689,"id":210032,"goal":"lemma SetCardSubset_6689(T: set, U: set)\n requires T <= U\n ensures |T| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_6690","instance":6690,"id":210033,"goal":"lemma SetUnionCard_6690(T: set, A: set)\n requires T * A == {}\n ensures |T + A| == |T| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_6691","instance":6691,"id":210034,"goal":"lemma SetUnionComm_6691(S: set, B: set)\n ensures S + B == B + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_6692","instance":6692,"id":210035,"goal":"lemma SetInterComm_6692(A: set, B: set)\n ensures A * B == B * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_6693","instance":6693,"id":210036,"goal":"lemma SetUnionAssoc_6693(T: set, U: set, S: set)\n ensures (T + U) + S == T + (U + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_6694","instance":6694,"id":210037,"goal":"lemma SetSubsetRefl_6694(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_6695","instance":6695,"id":210038,"goal":"lemma SetSubsetTrans_6695(U: set, B: set, S: set)\n requires U <= B && B <= S\n ensures U <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_6696","instance":6696,"id":210039,"goal":"lemma SetUnionEmpty_6696(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_6697","instance":6697,"id":210040,"goal":"lemma SetInterEmpty_6697(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_6698","instance":6698,"id":210041,"goal":"lemma SetInterSubset_6698(B: set, T: set)\n ensures B * T <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_6699","instance":6699,"id":210042,"goal":"lemma SetCardSubset_6699(T: set, A: set)\n requires T <= A\n ensures |T| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_6700","instance":6700,"id":210043,"goal":"lemma SetUnionCard_6700(A: set, S: set)\n requires A * S == {}\n ensures |A + S| == |A| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_6701","instance":6701,"id":210044,"goal":"lemma SetUnionComm_6701(U: set, T: set)\n ensures U + T == T + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_6702","instance":6702,"id":210045,"goal":"lemma SetInterComm_6702(T: set, B: set)\n ensures T * B == B * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_6703","instance":6703,"id":210046,"goal":"lemma SetUnionAssoc_6703(B: set, T: set, S: set)\n ensures (B + T) + S == B + (T + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_6704","instance":6704,"id":210047,"goal":"lemma SetSubsetRefl_6704(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_6705","instance":6705,"id":210048,"goal":"lemma SetSubsetTrans_6705(U: set, A: set, T: set)\n requires U <= A && A <= T\n ensures U <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_6706","instance":6706,"id":210049,"goal":"lemma SetUnionEmpty_6706(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_6707","instance":6707,"id":210050,"goal":"lemma SetInterEmpty_6707(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_6708","instance":6708,"id":210051,"goal":"lemma SetInterSubset_6708(T: set, A: set)\n ensures T * A <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_6709","instance":6709,"id":210052,"goal":"lemma SetCardSubset_6709(B: set, A: set)\n requires B <= A\n ensures |B| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_6710","instance":6710,"id":210053,"goal":"lemma SetUnionCard_6710(B: set, U: set)\n requires B * U == {}\n ensures |B + U| == |B| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_6711","instance":6711,"id":210054,"goal":"lemma SetUnionComm_6711(B: set, A: set)\n ensures B + A == A + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_6712","instance":6712,"id":210055,"goal":"lemma SetInterComm_6712(T: set, B: set)\n ensures T * B == B * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_6713","instance":6713,"id":210056,"goal":"lemma SetUnionAssoc_6713(U: set, S: set, B: set)\n ensures (U + S) + B == U + (S + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_6714","instance":6714,"id":210057,"goal":"lemma SetSubsetRefl_6714(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_6715","instance":6715,"id":210058,"goal":"lemma SetSubsetTrans_6715(T: set, B: set, U: set)\n requires T <= B && B <= U\n ensures T <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_6716","instance":6716,"id":210059,"goal":"lemma SetUnionEmpty_6716(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_6717","instance":6717,"id":210060,"goal":"lemma SetInterEmpty_6717(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_6718","instance":6718,"id":210061,"goal":"lemma SetInterSubset_6718(S: set, B: set)\n ensures S * B <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_6719","instance":6719,"id":210062,"goal":"lemma SetCardSubset_6719(S: set, B: set)\n requires S <= B\n ensures |S| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_6720","instance":6720,"id":210063,"goal":"lemma SetUnionCard_6720(B: set, U: set)\n requires B * U == {}\n ensures |B + U| == |B| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_6721","instance":6721,"id":210064,"goal":"lemma SetUnionComm_6721(S: set, B: set)\n ensures S + B == B + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_6722","instance":6722,"id":210065,"goal":"lemma SetInterComm_6722(U: set, B: set)\n ensures U * B == B * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_6723","instance":6723,"id":210066,"goal":"lemma SetUnionAssoc_6723(U: set, S: set, B: set)\n ensures (U + S) + B == U + (S + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_6724","instance":6724,"id":210067,"goal":"lemma SetSubsetRefl_6724(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_6725","instance":6725,"id":210068,"goal":"lemma SetSubsetTrans_6725(B: set, T: set, A: set)\n requires B <= T && T <= A\n ensures B <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_6726","instance":6726,"id":210069,"goal":"lemma SetUnionEmpty_6726(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_6727","instance":6727,"id":210070,"goal":"lemma SetInterEmpty_6727(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_6728","instance":6728,"id":210071,"goal":"lemma SetInterSubset_6728(B: set, T: set)\n ensures B * T <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_6729","instance":6729,"id":210072,"goal":"lemma SetCardSubset_6729(T: set, U: set)\n requires T <= U\n ensures |T| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_6730","instance":6730,"id":210073,"goal":"lemma SetUnionCard_6730(B: set, A: set)\n requires B * A == {}\n ensures |B + A| == |B| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_6731","instance":6731,"id":210074,"goal":"lemma SetUnionComm_6731(B: set, T: set)\n ensures B + T == T + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_6732","instance":6732,"id":210075,"goal":"lemma SetInterComm_6732(B: set, U: set)\n ensures B * U == U * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_6733","instance":6733,"id":210076,"goal":"lemma SetUnionAssoc_6733(S: set, A: set, U: set)\n ensures (S + A) + U == S + (A + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_6734","instance":6734,"id":210077,"goal":"lemma SetSubsetRefl_6734(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_6735","instance":6735,"id":210078,"goal":"lemma SetSubsetTrans_6735(B: set, A: set, T: set)\n requires B <= A && A <= T\n ensures B <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_6736","instance":6736,"id":210079,"goal":"lemma SetUnionEmpty_6736(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_6737","instance":6737,"id":210080,"goal":"lemma SetInterEmpty_6737(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_6738","instance":6738,"id":210081,"goal":"lemma SetInterSubset_6738(S: set, B: set)\n ensures S * B <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_6739","instance":6739,"id":210082,"goal":"lemma SetCardSubset_6739(S: set, A: set)\n requires S <= A\n ensures |S| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_6740","instance":6740,"id":210083,"goal":"lemma SetUnionCard_6740(T: set, A: set)\n requires T * A == {}\n ensures |T + A| == |T| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_6741","instance":6741,"id":210084,"goal":"lemma SetUnionComm_6741(T: set, A: set)\n ensures T + A == A + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_6742","instance":6742,"id":210085,"goal":"lemma SetInterComm_6742(A: set, T: set)\n ensures A * T == T * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_6743","instance":6743,"id":210086,"goal":"lemma SetUnionAssoc_6743(S: set, T: set, A: set)\n ensures (S + T) + A == S + (T + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_6744","instance":6744,"id":210087,"goal":"lemma SetSubsetRefl_6744(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_6745","instance":6745,"id":210088,"goal":"lemma SetSubsetTrans_6745(T: set, B: set, U: set)\n requires T <= B && B <= U\n ensures T <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_6746","instance":6746,"id":210089,"goal":"lemma SetUnionEmpty_6746(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_6747","instance":6747,"id":210090,"goal":"lemma SetInterEmpty_6747(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_6748","instance":6748,"id":210091,"goal":"lemma SetInterSubset_6748(B: set, T: set)\n ensures B * T <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_6749","instance":6749,"id":210092,"goal":"lemma SetCardSubset_6749(U: set, S: set)\n requires U <= S\n ensures |U| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_6750","instance":6750,"id":210093,"goal":"lemma SetUnionCard_6750(S: set, A: set)\n requires S * A == {}\n ensures |S + A| == |S| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_6751","instance":6751,"id":210094,"goal":"lemma SetUnionComm_6751(A: set, B: set)\n ensures A + B == B + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_6752","instance":6752,"id":210095,"goal":"lemma SetInterComm_6752(S: set, T: set)\n ensures S * T == T * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_6753","instance":6753,"id":210096,"goal":"lemma SetUnionAssoc_6753(U: set, S: set, B: set)\n ensures (U + S) + B == U + (S + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_6754","instance":6754,"id":210097,"goal":"lemma SetSubsetRefl_6754(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_6755","instance":6755,"id":210098,"goal":"lemma SetSubsetTrans_6755(B: set, S: set, U: set)\n requires B <= S && S <= U\n ensures B <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_6756","instance":6756,"id":210099,"goal":"lemma SetUnionEmpty_6756(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_6757","instance":6757,"id":210100,"goal":"lemma SetInterEmpty_6757(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_6758","instance":6758,"id":210101,"goal":"lemma SetInterSubset_6758(A: set, T: set)\n ensures A * T <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_6759","instance":6759,"id":210102,"goal":"lemma SetCardSubset_6759(U: set, B: set)\n requires U <= B\n ensures |U| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_6760","instance":6760,"id":210103,"goal":"lemma SetUnionCard_6760(A: set, U: set)\n requires A * U == {}\n ensures |A + U| == |A| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_6761","instance":6761,"id":210104,"goal":"lemma SetUnionComm_6761(T: set, U: set)\n ensures T + U == U + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_6762","instance":6762,"id":210105,"goal":"lemma SetInterComm_6762(B: set, T: set)\n ensures B * T == T * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_6763","instance":6763,"id":210106,"goal":"lemma SetUnionAssoc_6763(T: set, S: set, B: set)\n ensures (T + S) + B == T + (S + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_6764","instance":6764,"id":210107,"goal":"lemma SetSubsetRefl_6764(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_6765","instance":6765,"id":210108,"goal":"lemma SetSubsetTrans_6765(S: set, U: set, A: set)\n requires S <= U && U <= A\n ensures S <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_6766","instance":6766,"id":210109,"goal":"lemma SetUnionEmpty_6766(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_6767","instance":6767,"id":210110,"goal":"lemma SetInterEmpty_6767(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_6768","instance":6768,"id":210111,"goal":"lemma SetInterSubset_6768(A: set, T: set)\n ensures A * T <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_6769","instance":6769,"id":210112,"goal":"lemma SetCardSubset_6769(A: set, S: set)\n requires A <= S\n ensures |A| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_6770","instance":6770,"id":210113,"goal":"lemma SetUnionCard_6770(T: set, U: set)\n requires T * U == {}\n ensures |T + U| == |T| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_6771","instance":6771,"id":210114,"goal":"lemma SetUnionComm_6771(T: set, U: set)\n ensures T + U == U + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_6772","instance":6772,"id":210115,"goal":"lemma SetInterComm_6772(S: set, B: set)\n ensures S * B == B * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_6773","instance":6773,"id":210116,"goal":"lemma SetUnionAssoc_6773(A: set, B: set, U: set)\n ensures (A + B) + U == A + (B + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_6774","instance":6774,"id":210117,"goal":"lemma SetSubsetRefl_6774(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_6775","instance":6775,"id":210118,"goal":"lemma SetSubsetTrans_6775(S: set, B: set, U: set)\n requires S <= B && B <= U\n ensures S <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_6776","instance":6776,"id":210119,"goal":"lemma SetUnionEmpty_6776(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_6777","instance":6777,"id":210120,"goal":"lemma SetInterEmpty_6777(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_6778","instance":6778,"id":210121,"goal":"lemma SetInterSubset_6778(A: set, T: set)\n ensures A * T <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_6779","instance":6779,"id":210122,"goal":"lemma SetCardSubset_6779(U: set, S: set)\n requires U <= S\n ensures |U| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_6780","instance":6780,"id":210123,"goal":"lemma SetUnionCard_6780(T: set, S: set)\n requires T * S == {}\n ensures |T + S| == |T| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_6781","instance":6781,"id":210124,"goal":"lemma SetUnionComm_6781(B: set, S: set)\n ensures B + S == S + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_6782","instance":6782,"id":210125,"goal":"lemma SetInterComm_6782(U: set, B: set)\n ensures U * B == B * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_6783","instance":6783,"id":210126,"goal":"lemma SetUnionAssoc_6783(T: set, A: set, U: set)\n ensures (T + A) + U == T + (A + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_6784","instance":6784,"id":210127,"goal":"lemma SetSubsetRefl_6784(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_6785","instance":6785,"id":210128,"goal":"lemma SetSubsetTrans_6785(U: set, A: set, T: set)\n requires U <= A && A <= T\n ensures U <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_6786","instance":6786,"id":210129,"goal":"lemma SetUnionEmpty_6786(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_6787","instance":6787,"id":210130,"goal":"lemma SetInterEmpty_6787(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_6788","instance":6788,"id":210131,"goal":"lemma SetInterSubset_6788(S: set, B: set)\n ensures S * B <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_6789","instance":6789,"id":210132,"goal":"lemma SetCardSubset_6789(B: set, T: set)\n requires B <= T\n ensures |B| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_6790","instance":6790,"id":210133,"goal":"lemma SetUnionCard_6790(U: set, S: set)\n requires U * S == {}\n ensures |U + S| == |U| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_6791","instance":6791,"id":210134,"goal":"lemma SetUnionComm_6791(A: set, S: set)\n ensures A + S == S + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_6792","instance":6792,"id":210135,"goal":"lemma SetInterComm_6792(B: set, S: set)\n ensures B * S == S * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_6793","instance":6793,"id":210136,"goal":"lemma SetUnionAssoc_6793(S: set, A: set, T: set)\n ensures (S + A) + T == S + (A + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_6794","instance":6794,"id":210137,"goal":"lemma SetSubsetRefl_6794(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_6795","instance":6795,"id":210138,"goal":"lemma SetSubsetTrans_6795(S: set, T: set, A: set)\n requires S <= T && T <= A\n ensures S <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_6796","instance":6796,"id":210139,"goal":"lemma SetUnionEmpty_6796(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_6797","instance":6797,"id":210140,"goal":"lemma SetInterEmpty_6797(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_6798","instance":6798,"id":210141,"goal":"lemma SetInterSubset_6798(B: set, T: set)\n ensures B * T <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_6799","instance":6799,"id":210142,"goal":"lemma SetCardSubset_6799(A: set, U: set)\n requires A <= U\n ensures |A| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_6800","instance":6800,"id":210143,"goal":"lemma SetUnionCard_6800(T: set, A: set)\n requires T * A == {}\n ensures |T + A| == |T| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_6801","instance":6801,"id":210144,"goal":"lemma SetUnionComm_6801(U: set, S: set)\n ensures U + S == S + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_6802","instance":6802,"id":210145,"goal":"lemma SetInterComm_6802(A: set, S: set)\n ensures A * S == S * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_6803","instance":6803,"id":210146,"goal":"lemma SetUnionAssoc_6803(U: set, T: set, S: set)\n ensures (U + T) + S == U + (T + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_6804","instance":6804,"id":210147,"goal":"lemma SetSubsetRefl_6804(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_6805","instance":6805,"id":210148,"goal":"lemma SetSubsetTrans_6805(B: set, U: set, T: set)\n requires B <= U && U <= T\n ensures B <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_6806","instance":6806,"id":210149,"goal":"lemma SetUnionEmpty_6806(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_6807","instance":6807,"id":210150,"goal":"lemma SetInterEmpty_6807(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_6808","instance":6808,"id":210151,"goal":"lemma SetInterSubset_6808(A: set, S: set)\n ensures A * S <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_6809","instance":6809,"id":210152,"goal":"lemma SetCardSubset_6809(A: set, T: set)\n requires A <= T\n ensures |A| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_6810","instance":6810,"id":210153,"goal":"lemma SetUnionCard_6810(U: set, B: set)\n requires U * B == {}\n ensures |U + B| == |U| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_6811","instance":6811,"id":210154,"goal":"lemma SetUnionComm_6811(S: set, A: set)\n ensures S + A == A + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_6812","instance":6812,"id":210155,"goal":"lemma SetInterComm_6812(B: set, S: set)\n ensures B * S == S * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_6813","instance":6813,"id":210156,"goal":"lemma SetUnionAssoc_6813(A: set, B: set, T: set)\n ensures (A + B) + T == A + (B + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_6814","instance":6814,"id":210157,"goal":"lemma SetSubsetRefl_6814(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_6815","instance":6815,"id":210158,"goal":"lemma SetSubsetTrans_6815(B: set, T: set, U: set)\n requires B <= T && T <= U\n ensures B <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_6816","instance":6816,"id":210159,"goal":"lemma SetUnionEmpty_6816(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_6817","instance":6817,"id":210160,"goal":"lemma SetInterEmpty_6817(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_6818","instance":6818,"id":210161,"goal":"lemma SetInterSubset_6818(T: set, U: set)\n ensures T * U <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_6819","instance":6819,"id":210162,"goal":"lemma SetCardSubset_6819(B: set, U: set)\n requires B <= U\n ensures |B| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_6820","instance":6820,"id":210163,"goal":"lemma SetUnionCard_6820(T: set, A: set)\n requires T * A == {}\n ensures |T + A| == |T| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_6821","instance":6821,"id":210164,"goal":"lemma SetUnionComm_6821(B: set, U: set)\n ensures B + U == U + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_6822","instance":6822,"id":210165,"goal":"lemma SetInterComm_6822(T: set, S: set)\n ensures T * S == S * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_6823","instance":6823,"id":210166,"goal":"lemma SetUnionAssoc_6823(B: set, S: set, A: set)\n ensures (B + S) + A == B + (S + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_6824","instance":6824,"id":210167,"goal":"lemma SetSubsetRefl_6824(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_6825","instance":6825,"id":210168,"goal":"lemma SetSubsetTrans_6825(U: set, S: set, A: set)\n requires U <= S && S <= A\n ensures U <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_6826","instance":6826,"id":210169,"goal":"lemma SetUnionEmpty_6826(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_6827","instance":6827,"id":210170,"goal":"lemma SetInterEmpty_6827(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_6828","instance":6828,"id":210171,"goal":"lemma SetInterSubset_6828(T: set, U: set)\n ensures T * U <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_6829","instance":6829,"id":210172,"goal":"lemma SetCardSubset_6829(T: set, U: set)\n requires T <= U\n ensures |T| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_6830","instance":6830,"id":210173,"goal":"lemma SetUnionCard_6830(U: set, A: set)\n requires U * A == {}\n ensures |U + A| == |U| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_6831","instance":6831,"id":210174,"goal":"lemma SetUnionComm_6831(T: set, A: set)\n ensures T + A == A + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_6832","instance":6832,"id":210175,"goal":"lemma SetInterComm_6832(A: set, T: set)\n ensures A * T == T * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_6833","instance":6833,"id":210176,"goal":"lemma SetUnionAssoc_6833(T: set, B: set, S: set)\n ensures (T + B) + S == T + (B + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_6834","instance":6834,"id":210177,"goal":"lemma SetSubsetRefl_6834(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_6835","instance":6835,"id":210178,"goal":"lemma SetSubsetTrans_6835(S: set, A: set, U: set)\n requires S <= A && A <= U\n ensures S <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_6836","instance":6836,"id":210179,"goal":"lemma SetUnionEmpty_6836(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_6837","instance":6837,"id":210180,"goal":"lemma SetInterEmpty_6837(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_6838","instance":6838,"id":210181,"goal":"lemma SetInterSubset_6838(B: set, A: set)\n ensures B * A <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_6839","instance":6839,"id":210182,"goal":"lemma SetCardSubset_6839(S: set, B: set)\n requires S <= B\n ensures |S| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_6840","instance":6840,"id":210183,"goal":"lemma SetUnionCard_6840(T: set, B: set)\n requires T * B == {}\n ensures |T + B| == |T| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_6841","instance":6841,"id":210184,"goal":"lemma SetUnionComm_6841(T: set, S: set)\n ensures T + S == S + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_6842","instance":6842,"id":210185,"goal":"lemma SetInterComm_6842(U: set, S: set)\n ensures U * S == S * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_6843","instance":6843,"id":210186,"goal":"lemma SetUnionAssoc_6843(T: set, U: set, S: set)\n ensures (T + U) + S == T + (U + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_6844","instance":6844,"id":210187,"goal":"lemma SetSubsetRefl_6844(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_6845","instance":6845,"id":210188,"goal":"lemma SetSubsetTrans_6845(T: set, S: set, A: set)\n requires T <= S && S <= A\n ensures T <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_6846","instance":6846,"id":210189,"goal":"lemma SetUnionEmpty_6846(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_6847","instance":6847,"id":210190,"goal":"lemma SetInterEmpty_6847(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_6848","instance":6848,"id":210191,"goal":"lemma SetInterSubset_6848(S: set, U: set)\n ensures S * U <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_6849","instance":6849,"id":210192,"goal":"lemma SetCardSubset_6849(U: set, B: set)\n requires U <= B\n ensures |U| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_6850","instance":6850,"id":210193,"goal":"lemma SetUnionCard_6850(A: set, T: set)\n requires A * T == {}\n ensures |A + T| == |A| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_6851","instance":6851,"id":210194,"goal":"lemma SetUnionComm_6851(B: set, S: set)\n ensures B + S == S + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_6852","instance":6852,"id":210195,"goal":"lemma SetInterComm_6852(A: set, B: set)\n ensures A * B == B * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_6853","instance":6853,"id":210196,"goal":"lemma SetUnionAssoc_6853(U: set, B: set, T: set)\n ensures (U + B) + T == U + (B + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_6854","instance":6854,"id":210197,"goal":"lemma SetSubsetRefl_6854(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_6855","instance":6855,"id":210198,"goal":"lemma SetSubsetTrans_6855(A: set, T: set, U: set)\n requires A <= T && T <= U\n ensures A <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_6856","instance":6856,"id":210199,"goal":"lemma SetUnionEmpty_6856(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_6857","instance":6857,"id":210200,"goal":"lemma SetInterEmpty_6857(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_6858","instance":6858,"id":210201,"goal":"lemma SetInterSubset_6858(A: set, S: set)\n ensures A * S <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_6859","instance":6859,"id":210202,"goal":"lemma SetCardSubset_6859(B: set, S: set)\n requires B <= S\n ensures |B| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_6860","instance":6860,"id":210203,"goal":"lemma SetUnionCard_6860(S: set, U: set)\n requires S * U == {}\n ensures |S + U| == |S| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_6861","instance":6861,"id":210204,"goal":"lemma SetUnionComm_6861(S: set, A: set)\n ensures S + A == A + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_6862","instance":6862,"id":210205,"goal":"lemma SetInterComm_6862(S: set, U: set)\n ensures S * U == U * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_6863","instance":6863,"id":210206,"goal":"lemma SetUnionAssoc_6863(U: set, S: set, B: set)\n ensures (U + S) + B == U + (S + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_6864","instance":6864,"id":210207,"goal":"lemma SetSubsetRefl_6864(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_6865","instance":6865,"id":210208,"goal":"lemma SetSubsetTrans_6865(U: set, S: set, T: set)\n requires U <= S && S <= T\n ensures U <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_6866","instance":6866,"id":210209,"goal":"lemma SetUnionEmpty_6866(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_6867","instance":6867,"id":210210,"goal":"lemma SetInterEmpty_6867(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_6868","instance":6868,"id":210211,"goal":"lemma SetInterSubset_6868(U: set, S: set)\n ensures U * S <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_6869","instance":6869,"id":210212,"goal":"lemma SetCardSubset_6869(B: set, A: set)\n requires B <= A\n ensures |B| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_6870","instance":6870,"id":210213,"goal":"lemma SetUnionCard_6870(S: set, T: set)\n requires S * T == {}\n ensures |S + T| == |S| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_6871","instance":6871,"id":210214,"goal":"lemma SetUnionComm_6871(T: set, A: set)\n ensures T + A == A + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_6872","instance":6872,"id":210215,"goal":"lemma SetInterComm_6872(U: set, T: set)\n ensures U * T == T * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_6873","instance":6873,"id":210216,"goal":"lemma SetUnionAssoc_6873(S: set, T: set, B: set)\n ensures (S + T) + B == S + (T + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_6874","instance":6874,"id":210217,"goal":"lemma SetSubsetRefl_6874(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_6875","instance":6875,"id":210218,"goal":"lemma SetSubsetTrans_6875(U: set, B: set, S: set)\n requires U <= B && B <= S\n ensures U <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_6876","instance":6876,"id":210219,"goal":"lemma SetUnionEmpty_6876(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_6877","instance":6877,"id":210220,"goal":"lemma SetInterEmpty_6877(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_6878","instance":6878,"id":210221,"goal":"lemma SetInterSubset_6878(S: set, U: set)\n ensures S * U <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_6879","instance":6879,"id":210222,"goal":"lemma SetCardSubset_6879(T: set, S: set)\n requires T <= S\n ensures |T| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_6880","instance":6880,"id":210223,"goal":"lemma SetUnionCard_6880(T: set, U: set)\n requires T * U == {}\n ensures |T + U| == |T| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_6881","instance":6881,"id":210224,"goal":"lemma SetUnionComm_6881(U: set, A: set)\n ensures U + A == A + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_6882","instance":6882,"id":210225,"goal":"lemma SetInterComm_6882(U: set, S: set)\n ensures U * S == S * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_6883","instance":6883,"id":210226,"goal":"lemma SetUnionAssoc_6883(A: set, T: set, S: set)\n ensures (A + T) + S == A + (T + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_6884","instance":6884,"id":210227,"goal":"lemma SetSubsetRefl_6884(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_6885","instance":6885,"id":210228,"goal":"lemma SetSubsetTrans_6885(S: set, A: set, B: set)\n requires S <= A && A <= B\n ensures S <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_6886","instance":6886,"id":210229,"goal":"lemma SetUnionEmpty_6886(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_6887","instance":6887,"id":210230,"goal":"lemma SetInterEmpty_6887(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_6888","instance":6888,"id":210231,"goal":"lemma SetInterSubset_6888(B: set, A: set)\n ensures B * A <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_6889","instance":6889,"id":210232,"goal":"lemma SetCardSubset_6889(A: set, T: set)\n requires A <= T\n ensures |A| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_6890","instance":6890,"id":210233,"goal":"lemma SetUnionCard_6890(A: set, S: set)\n requires A * S == {}\n ensures |A + S| == |A| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_6891","instance":6891,"id":210234,"goal":"lemma SetUnionComm_6891(A: set, T: set)\n ensures A + T == T + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_6892","instance":6892,"id":210235,"goal":"lemma SetInterComm_6892(A: set, B: set)\n ensures A * B == B * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_6893","instance":6893,"id":210236,"goal":"lemma SetUnionAssoc_6893(T: set, B: set, S: set)\n ensures (T + B) + S == T + (B + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_6894","instance":6894,"id":210237,"goal":"lemma SetSubsetRefl_6894(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_6895","instance":6895,"id":210238,"goal":"lemma SetSubsetTrans_6895(S: set, U: set, B: set)\n requires S <= U && U <= B\n ensures S <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_6896","instance":6896,"id":210239,"goal":"lemma SetUnionEmpty_6896(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_6897","instance":6897,"id":210240,"goal":"lemma SetInterEmpty_6897(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_6898","instance":6898,"id":210241,"goal":"lemma SetInterSubset_6898(T: set, A: set)\n ensures T * A <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_6899","instance":6899,"id":210242,"goal":"lemma SetCardSubset_6899(U: set, T: set)\n requires U <= T\n ensures |U| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_6900","instance":6900,"id":210243,"goal":"lemma SetUnionCard_6900(S: set, A: set)\n requires S * A == {}\n ensures |S + A| == |S| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_6901","instance":6901,"id":210244,"goal":"lemma SetUnionComm_6901(A: set, T: set)\n ensures A + T == T + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_6902","instance":6902,"id":210245,"goal":"lemma SetInterComm_6902(T: set, B: set)\n ensures T * B == B * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_6903","instance":6903,"id":210246,"goal":"lemma SetUnionAssoc_6903(T: set, S: set, U: set)\n ensures (T + S) + U == T + (S + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_6904","instance":6904,"id":210247,"goal":"lemma SetSubsetRefl_6904(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_6905","instance":6905,"id":210248,"goal":"lemma SetSubsetTrans_6905(S: set, T: set, U: set)\n requires S <= T && T <= U\n ensures S <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_6906","instance":6906,"id":210249,"goal":"lemma SetUnionEmpty_6906(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_6907","instance":6907,"id":210250,"goal":"lemma SetInterEmpty_6907(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_6908","instance":6908,"id":210251,"goal":"lemma SetInterSubset_6908(T: set, B: set)\n ensures T * B <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_6909","instance":6909,"id":210252,"goal":"lemma SetCardSubset_6909(T: set, S: set)\n requires T <= S\n ensures |T| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_6910","instance":6910,"id":210253,"goal":"lemma SetUnionCard_6910(A: set, S: set)\n requires A * S == {}\n ensures |A + S| == |A| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_6911","instance":6911,"id":210254,"goal":"lemma SetUnionComm_6911(B: set, S: set)\n ensures B + S == S + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_6912","instance":6912,"id":210255,"goal":"lemma SetInterComm_6912(A: set, U: set)\n ensures A * U == U * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_6913","instance":6913,"id":210256,"goal":"lemma SetUnionAssoc_6913(A: set, B: set, U: set)\n ensures (A + B) + U == A + (B + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_6914","instance":6914,"id":210257,"goal":"lemma SetSubsetRefl_6914(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_6915","instance":6915,"id":210258,"goal":"lemma SetSubsetTrans_6915(A: set, U: set, S: set)\n requires A <= U && U <= S\n ensures A <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_6916","instance":6916,"id":210259,"goal":"lemma SetUnionEmpty_6916(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_6917","instance":6917,"id":210260,"goal":"lemma SetInterEmpty_6917(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_6918","instance":6918,"id":210261,"goal":"lemma SetInterSubset_6918(S: set, U: set)\n ensures S * U <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_6919","instance":6919,"id":210262,"goal":"lemma SetCardSubset_6919(S: set, A: set)\n requires S <= A\n ensures |S| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_6920","instance":6920,"id":210263,"goal":"lemma SetUnionCard_6920(S: set, B: set)\n requires S * B == {}\n ensures |S + B| == |S| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_6921","instance":6921,"id":210264,"goal":"lemma SetUnionComm_6921(S: set, U: set)\n ensures S + U == U + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_6922","instance":6922,"id":210265,"goal":"lemma SetInterComm_6922(U: set, B: set)\n ensures U * B == B * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_6923","instance":6923,"id":210266,"goal":"lemma SetUnionAssoc_6923(A: set, S: set, T: set)\n ensures (A + S) + T == A + (S + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_6924","instance":6924,"id":210267,"goal":"lemma SetSubsetRefl_6924(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_6925","instance":6925,"id":210268,"goal":"lemma SetSubsetTrans_6925(U: set, S: set, T: set)\n requires U <= S && S <= T\n ensures U <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_6926","instance":6926,"id":210269,"goal":"lemma SetUnionEmpty_6926(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_6927","instance":6927,"id":210270,"goal":"lemma SetInterEmpty_6927(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_6928","instance":6928,"id":210271,"goal":"lemma SetInterSubset_6928(B: set, A: set)\n ensures B * A <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_6929","instance":6929,"id":210272,"goal":"lemma SetCardSubset_6929(B: set, S: set)\n requires B <= S\n ensures |B| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_6930","instance":6930,"id":210273,"goal":"lemma SetUnionCard_6930(T: set, U: set)\n requires T * U == {}\n ensures |T + U| == |T| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_6931","instance":6931,"id":210274,"goal":"lemma SetUnionComm_6931(B: set, S: set)\n ensures B + S == S + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_6932","instance":6932,"id":210275,"goal":"lemma SetInterComm_6932(B: set, U: set)\n ensures B * U == U * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_6933","instance":6933,"id":210276,"goal":"lemma SetUnionAssoc_6933(S: set, T: set, A: set)\n ensures (S + T) + A == S + (T + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_6934","instance":6934,"id":210277,"goal":"lemma SetSubsetRefl_6934(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_6935","instance":6935,"id":210278,"goal":"lemma SetSubsetTrans_6935(B: set, S: set, A: set)\n requires B <= S && S <= A\n ensures B <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_6936","instance":6936,"id":210279,"goal":"lemma SetUnionEmpty_6936(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_6937","instance":6937,"id":210280,"goal":"lemma SetInterEmpty_6937(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_6938","instance":6938,"id":210281,"goal":"lemma SetInterSubset_6938(S: set, U: set)\n ensures S * U <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_6939","instance":6939,"id":210282,"goal":"lemma SetCardSubset_6939(T: set, B: set)\n requires T <= B\n ensures |T| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_6940","instance":6940,"id":210283,"goal":"lemma SetUnionCard_6940(S: set, T: set)\n requires S * T == {}\n ensures |S + T| == |S| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_6941","instance":6941,"id":210284,"goal":"lemma SetUnionComm_6941(B: set, T: set)\n ensures B + T == T + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_6942","instance":6942,"id":210285,"goal":"lemma SetInterComm_6942(B: set, T: set)\n ensures B * T == T * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_6943","instance":6943,"id":210286,"goal":"lemma SetUnionAssoc_6943(S: set, U: set, T: set)\n ensures (S + U) + T == S + (U + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_6944","instance":6944,"id":210287,"goal":"lemma SetSubsetRefl_6944(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_6945","instance":6945,"id":210288,"goal":"lemma SetSubsetTrans_6945(A: set, S: set, U: set)\n requires A <= S && S <= U\n ensures A <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_6946","instance":6946,"id":210289,"goal":"lemma SetUnionEmpty_6946(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_6947","instance":6947,"id":210290,"goal":"lemma SetInterEmpty_6947(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_6948","instance":6948,"id":210291,"goal":"lemma SetInterSubset_6948(U: set, A: set)\n ensures U * A <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_6949","instance":6949,"id":210292,"goal":"lemma SetCardSubset_6949(S: set, A: set)\n requires S <= A\n ensures |S| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_6950","instance":6950,"id":210293,"goal":"lemma SetUnionCard_6950(T: set, U: set)\n requires T * U == {}\n ensures |T + U| == |T| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_6951","instance":6951,"id":210294,"goal":"lemma SetUnionComm_6951(S: set, A: set)\n ensures S + A == A + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_6952","instance":6952,"id":210295,"goal":"lemma SetInterComm_6952(T: set, B: set)\n ensures T * B == B * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_6953","instance":6953,"id":210296,"goal":"lemma SetUnionAssoc_6953(A: set, B: set, U: set)\n ensures (A + B) + U == A + (B + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_6954","instance":6954,"id":210297,"goal":"lemma SetSubsetRefl_6954(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_6955","instance":6955,"id":210298,"goal":"lemma SetSubsetTrans_6955(A: set, S: set, B: set)\n requires A <= S && S <= B\n ensures A <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_6956","instance":6956,"id":210299,"goal":"lemma SetUnionEmpty_6956(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_6957","instance":6957,"id":210300,"goal":"lemma SetInterEmpty_6957(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_6958","instance":6958,"id":210301,"goal":"lemma SetInterSubset_6958(T: set, S: set)\n ensures T * S <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_6959","instance":6959,"id":210302,"goal":"lemma SetCardSubset_6959(T: set, S: set)\n requires T <= S\n ensures |T| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_6960","instance":6960,"id":210303,"goal":"lemma SetUnionCard_6960(B: set, T: set)\n requires B * T == {}\n ensures |B + T| == |B| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_6961","instance":6961,"id":210304,"goal":"lemma SetUnionComm_6961(B: set, U: set)\n ensures B + U == U + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_6962","instance":6962,"id":210305,"goal":"lemma SetInterComm_6962(A: set, S: set)\n ensures A * S == S * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_6963","instance":6963,"id":210306,"goal":"lemma SetUnionAssoc_6963(A: set, S: set, T: set)\n ensures (A + S) + T == A + (S + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_6964","instance":6964,"id":210307,"goal":"lemma SetSubsetRefl_6964(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_6965","instance":6965,"id":210308,"goal":"lemma SetSubsetTrans_6965(T: set, B: set, A: set)\n requires T <= B && B <= A\n ensures T <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_6966","instance":6966,"id":210309,"goal":"lemma SetUnionEmpty_6966(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_6967","instance":6967,"id":210310,"goal":"lemma SetInterEmpty_6967(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_6968","instance":6968,"id":210311,"goal":"lemma SetInterSubset_6968(U: set, B: set)\n ensures U * B <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_6969","instance":6969,"id":210312,"goal":"lemma SetCardSubset_6969(U: set, S: set)\n requires U <= S\n ensures |U| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_6970","instance":6970,"id":210313,"goal":"lemma SetUnionCard_6970(T: set, U: set)\n requires T * U == {}\n ensures |T + U| == |T| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_6971","instance":6971,"id":210314,"goal":"lemma SetUnionComm_6971(S: set, A: set)\n ensures S + A == A + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_6972","instance":6972,"id":210315,"goal":"lemma SetInterComm_6972(T: set, B: set)\n ensures T * B == B * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_6973","instance":6973,"id":210316,"goal":"lemma SetUnionAssoc_6973(U: set, A: set, S: set)\n ensures (U + A) + S == U + (A + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_6974","instance":6974,"id":210317,"goal":"lemma SetSubsetRefl_6974(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_6975","instance":6975,"id":210318,"goal":"lemma SetSubsetTrans_6975(A: set, S: set, U: set)\n requires A <= S && S <= U\n ensures A <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_6976","instance":6976,"id":210319,"goal":"lemma SetUnionEmpty_6976(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_6977","instance":6977,"id":210320,"goal":"lemma SetInterEmpty_6977(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_6978","instance":6978,"id":210321,"goal":"lemma SetInterSubset_6978(A: set, B: set)\n ensures A * B <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_6979","instance":6979,"id":210322,"goal":"lemma SetCardSubset_6979(A: set, U: set)\n requires A <= U\n ensures |A| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_6980","instance":6980,"id":210323,"goal":"lemma SetUnionCard_6980(S: set, U: set)\n requires S * U == {}\n ensures |S + U| == |S| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_6981","instance":6981,"id":210324,"goal":"lemma SetUnionComm_6981(T: set, U: set)\n ensures T + U == U + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_6982","instance":6982,"id":210325,"goal":"lemma SetInterComm_6982(U: set, A: set)\n ensures U * A == A * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_6983","instance":6983,"id":210326,"goal":"lemma SetUnionAssoc_6983(A: set, T: set, U: set)\n ensures (A + T) + U == A + (T + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_6984","instance":6984,"id":210327,"goal":"lemma SetSubsetRefl_6984(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_6985","instance":6985,"id":210328,"goal":"lemma SetSubsetTrans_6985(A: set, T: set, B: set)\n requires A <= T && T <= B\n ensures A <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_6986","instance":6986,"id":210329,"goal":"lemma SetUnionEmpty_6986(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_6987","instance":6987,"id":210330,"goal":"lemma SetInterEmpty_6987(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_6988","instance":6988,"id":210331,"goal":"lemma SetInterSubset_6988(T: set, B: set)\n ensures T * B <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_6989","instance":6989,"id":210332,"goal":"lemma SetCardSubset_6989(U: set, A: set)\n requires U <= A\n ensures |U| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_6990","instance":6990,"id":210333,"goal":"lemma SetUnionCard_6990(U: set, A: set)\n requires U * A == {}\n ensures |U + A| == |U| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_6991","instance":6991,"id":210334,"goal":"lemma SetUnionComm_6991(T: set, A: set)\n ensures T + A == A + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_6992","instance":6992,"id":210335,"goal":"lemma SetInterComm_6992(U: set, T: set)\n ensures U * T == T * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_6993","instance":6993,"id":210336,"goal":"lemma SetUnionAssoc_6993(T: set, S: set, U: set)\n ensures (T + S) + U == T + (S + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_6994","instance":6994,"id":210337,"goal":"lemma SetSubsetRefl_6994(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_6995","instance":6995,"id":210338,"goal":"lemma SetSubsetTrans_6995(A: set, T: set, S: set)\n requires A <= T && T <= S\n ensures A <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_6996","instance":6996,"id":210339,"goal":"lemma SetUnionEmpty_6996(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_6997","instance":6997,"id":210340,"goal":"lemma SetInterEmpty_6997(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_6998","instance":6998,"id":210341,"goal":"lemma SetInterSubset_6998(S: set, A: set)\n ensures S * A <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_6999","instance":6999,"id":210342,"goal":"lemma SetCardSubset_6999(S: set, U: set)\n requires S <= U\n ensures |S| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_7000","instance":7000,"id":210343,"goal":"lemma SetUnionCard_7000(B: set, T: set)\n requires B * T == {}\n ensures |B + T| == |B| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_7001","instance":7001,"id":210344,"goal":"lemma SetUnionComm_7001(A: set, S: set)\n ensures A + S == S + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_7002","instance":7002,"id":210345,"goal":"lemma SetInterComm_7002(A: set, B: set)\n ensures A * B == B * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_7003","instance":7003,"id":210346,"goal":"lemma SetUnionAssoc_7003(U: set, B: set, T: set)\n ensures (U + B) + T == U + (B + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_7004","instance":7004,"id":210347,"goal":"lemma SetSubsetRefl_7004(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_7005","instance":7005,"id":210348,"goal":"lemma SetSubsetTrans_7005(A: set, U: set, T: set)\n requires A <= U && U <= T\n ensures A <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_7006","instance":7006,"id":210349,"goal":"lemma SetUnionEmpty_7006(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_7007","instance":7007,"id":210350,"goal":"lemma SetInterEmpty_7007(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_7008","instance":7008,"id":210351,"goal":"lemma SetInterSubset_7008(T: set, S: set)\n ensures T * S <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_7009","instance":7009,"id":210352,"goal":"lemma SetCardSubset_7009(S: set, A: set)\n requires S <= A\n ensures |S| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_7010","instance":7010,"id":210353,"goal":"lemma SetUnionCard_7010(U: set, T: set)\n requires U * T == {}\n ensures |U + T| == |U| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_7011","instance":7011,"id":210354,"goal":"lemma SetUnionComm_7011(T: set, U: set)\n ensures T + U == U + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_7012","instance":7012,"id":210355,"goal":"lemma SetInterComm_7012(A: set, U: set)\n ensures A * U == U * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_7013","instance":7013,"id":210356,"goal":"lemma SetUnionAssoc_7013(S: set, U: set, A: set)\n ensures (S + U) + A == S + (U + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_7014","instance":7014,"id":210357,"goal":"lemma SetSubsetRefl_7014(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_7015","instance":7015,"id":210358,"goal":"lemma SetSubsetTrans_7015(A: set, T: set, U: set)\n requires A <= T && T <= U\n ensures A <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_7016","instance":7016,"id":210359,"goal":"lemma SetUnionEmpty_7016(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_7017","instance":7017,"id":210360,"goal":"lemma SetInterEmpty_7017(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_7018","instance":7018,"id":210361,"goal":"lemma SetInterSubset_7018(B: set, U: set)\n ensures B * U <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_7019","instance":7019,"id":210362,"goal":"lemma SetCardSubset_7019(A: set, B: set)\n requires A <= B\n ensures |A| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_7020","instance":7020,"id":210363,"goal":"lemma SetUnionCard_7020(S: set, B: set)\n requires S * B == {}\n ensures |S + B| == |S| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_7021","instance":7021,"id":210364,"goal":"lemma SetUnionComm_7021(U: set, T: set)\n ensures U + T == T + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_7022","instance":7022,"id":210365,"goal":"lemma SetInterComm_7022(A: set, T: set)\n ensures A * T == T * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_7023","instance":7023,"id":210366,"goal":"lemma SetUnionAssoc_7023(A: set, S: set, B: set)\n ensures (A + S) + B == A + (S + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_7024","instance":7024,"id":210367,"goal":"lemma SetSubsetRefl_7024(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_7025","instance":7025,"id":210368,"goal":"lemma SetSubsetTrans_7025(B: set, T: set, A: set)\n requires B <= T && T <= A\n ensures B <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_7026","instance":7026,"id":210369,"goal":"lemma SetUnionEmpty_7026(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_7027","instance":7027,"id":210370,"goal":"lemma SetInterEmpty_7027(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_7028","instance":7028,"id":210371,"goal":"lemma SetInterSubset_7028(S: set, B: set)\n ensures S * B <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_7029","instance":7029,"id":210372,"goal":"lemma SetCardSubset_7029(S: set, A: set)\n requires S <= A\n ensures |S| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_7030","instance":7030,"id":210373,"goal":"lemma SetUnionCard_7030(T: set, B: set)\n requires T * B == {}\n ensures |T + B| == |T| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_7031","instance":7031,"id":210374,"goal":"lemma SetUnionComm_7031(A: set, U: set)\n ensures A + U == U + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_7032","instance":7032,"id":210375,"goal":"lemma SetInterComm_7032(S: set, T: set)\n ensures S * T == T * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_7033","instance":7033,"id":210376,"goal":"lemma SetUnionAssoc_7033(S: set, T: set, U: set)\n ensures (S + T) + U == S + (T + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_7034","instance":7034,"id":210377,"goal":"lemma SetSubsetRefl_7034(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_7035","instance":7035,"id":210378,"goal":"lemma SetSubsetTrans_7035(T: set, A: set, S: set)\n requires T <= A && A <= S\n ensures T <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_7036","instance":7036,"id":210379,"goal":"lemma SetUnionEmpty_7036(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_7037","instance":7037,"id":210380,"goal":"lemma SetInterEmpty_7037(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_7038","instance":7038,"id":210381,"goal":"lemma SetInterSubset_7038(U: set, S: set)\n ensures U * S <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_7039","instance":7039,"id":210382,"goal":"lemma SetCardSubset_7039(T: set, B: set)\n requires T <= B\n ensures |T| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_7040","instance":7040,"id":210383,"goal":"lemma SetUnionCard_7040(B: set, U: set)\n requires B * U == {}\n ensures |B + U| == |B| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_7041","instance":7041,"id":210384,"goal":"lemma SetUnionComm_7041(B: set, S: set)\n ensures B + S == S + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_7042","instance":7042,"id":210385,"goal":"lemma SetInterComm_7042(T: set, U: set)\n ensures T * U == U * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_7043","instance":7043,"id":210386,"goal":"lemma SetUnionAssoc_7043(S: set, B: set, U: set)\n ensures (S + B) + U == S + (B + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_7044","instance":7044,"id":210387,"goal":"lemma SetSubsetRefl_7044(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_7045","instance":7045,"id":210388,"goal":"lemma SetSubsetTrans_7045(T: set, U: set, B: set)\n requires T <= U && U <= B\n ensures T <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_7046","instance":7046,"id":210389,"goal":"lemma SetUnionEmpty_7046(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_7047","instance":7047,"id":210390,"goal":"lemma SetInterEmpty_7047(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_7048","instance":7048,"id":210391,"goal":"lemma SetInterSubset_7048(S: set, T: set)\n ensures S * T <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_7049","instance":7049,"id":210392,"goal":"lemma SetCardSubset_7049(U: set, A: set)\n requires U <= A\n ensures |U| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_7050","instance":7050,"id":210393,"goal":"lemma SetUnionCard_7050(A: set, B: set)\n requires A * B == {}\n ensures |A + B| == |A| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_7051","instance":7051,"id":210394,"goal":"lemma SetUnionComm_7051(B: set, A: set)\n ensures B + A == A + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_7052","instance":7052,"id":210395,"goal":"lemma SetInterComm_7052(A: set, B: set)\n ensures A * B == B * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_7053","instance":7053,"id":210396,"goal":"lemma SetUnionAssoc_7053(T: set, S: set, A: set)\n ensures (T + S) + A == T + (S + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_7054","instance":7054,"id":210397,"goal":"lemma SetSubsetRefl_7054(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_7055","instance":7055,"id":210398,"goal":"lemma SetSubsetTrans_7055(T: set, B: set, A: set)\n requires T <= B && B <= A\n ensures T <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_7056","instance":7056,"id":210399,"goal":"lemma SetUnionEmpty_7056(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_7057","instance":7057,"id":210400,"goal":"lemma SetInterEmpty_7057(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_7058","instance":7058,"id":210401,"goal":"lemma SetInterSubset_7058(U: set, S: set)\n ensures U * S <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_7059","instance":7059,"id":210402,"goal":"lemma SetCardSubset_7059(S: set, B: set)\n requires S <= B\n ensures |S| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_7060","instance":7060,"id":210403,"goal":"lemma SetUnionCard_7060(S: set, U: set)\n requires S * U == {}\n ensures |S + U| == |S| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_7061","instance":7061,"id":210404,"goal":"lemma SetUnionComm_7061(A: set, B: set)\n ensures A + B == B + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_7062","instance":7062,"id":210405,"goal":"lemma SetInterComm_7062(S: set, U: set)\n ensures S * U == U * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_7063","instance":7063,"id":210406,"goal":"lemma SetUnionAssoc_7063(S: set, T: set, U: set)\n ensures (S + T) + U == S + (T + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_7064","instance":7064,"id":210407,"goal":"lemma SetSubsetRefl_7064(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_7065","instance":7065,"id":210408,"goal":"lemma SetSubsetTrans_7065(U: set, S: set, B: set)\n requires U <= S && S <= B\n ensures U <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_7066","instance":7066,"id":210409,"goal":"lemma SetUnionEmpty_7066(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_7067","instance":7067,"id":210410,"goal":"lemma SetInterEmpty_7067(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_7068","instance":7068,"id":210411,"goal":"lemma SetInterSubset_7068(B: set, S: set)\n ensures B * S <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_7069","instance":7069,"id":210412,"goal":"lemma SetCardSubset_7069(A: set, U: set)\n requires A <= U\n ensures |A| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_7070","instance":7070,"id":210413,"goal":"lemma SetUnionCard_7070(U: set, B: set)\n requires U * B == {}\n ensures |U + B| == |U| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_7071","instance":7071,"id":210414,"goal":"lemma SetUnionComm_7071(U: set, S: set)\n ensures U + S == S + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_7072","instance":7072,"id":210415,"goal":"lemma SetInterComm_7072(S: set, B: set)\n ensures S * B == B * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_7073","instance":7073,"id":210416,"goal":"lemma SetUnionAssoc_7073(A: set, S: set, B: set)\n ensures (A + S) + B == A + (S + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_7074","instance":7074,"id":210417,"goal":"lemma SetSubsetRefl_7074(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_7075","instance":7075,"id":210418,"goal":"lemma SetSubsetTrans_7075(U: set, B: set, A: set)\n requires U <= B && B <= A\n ensures U <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_7076","instance":7076,"id":210419,"goal":"lemma SetUnionEmpty_7076(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_7077","instance":7077,"id":210420,"goal":"lemma SetInterEmpty_7077(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_7078","instance":7078,"id":210421,"goal":"lemma SetInterSubset_7078(T: set, A: set)\n ensures T * A <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_7079","instance":7079,"id":210422,"goal":"lemma SetCardSubset_7079(U: set, A: set)\n requires U <= A\n ensures |U| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_7080","instance":7080,"id":210423,"goal":"lemma SetUnionCard_7080(U: set, T: set)\n requires U * T == {}\n ensures |U + T| == |U| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_7081","instance":7081,"id":210424,"goal":"lemma SetUnionComm_7081(B: set, T: set)\n ensures B + T == T + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_7082","instance":7082,"id":210425,"goal":"lemma SetInterComm_7082(U: set, S: set)\n ensures U * S == S * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_7083","instance":7083,"id":210426,"goal":"lemma SetUnionAssoc_7083(A: set, U: set, T: set)\n ensures (A + U) + T == A + (U + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_7084","instance":7084,"id":210427,"goal":"lemma SetSubsetRefl_7084(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_7085","instance":7085,"id":210428,"goal":"lemma SetSubsetTrans_7085(U: set, B: set, A: set)\n requires U <= B && B <= A\n ensures U <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_7086","instance":7086,"id":210429,"goal":"lemma SetUnionEmpty_7086(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_7087","instance":7087,"id":210430,"goal":"lemma SetInterEmpty_7087(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_7088","instance":7088,"id":210431,"goal":"lemma SetInterSubset_7088(U: set, T: set)\n ensures U * T <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_7089","instance":7089,"id":210432,"goal":"lemma SetCardSubset_7089(U: set, A: set)\n requires U <= A\n ensures |U| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_7090","instance":7090,"id":210433,"goal":"lemma SetUnionCard_7090(A: set, U: set)\n requires A * U == {}\n ensures |A + U| == |A| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_7091","instance":7091,"id":210434,"goal":"lemma SetUnionComm_7091(U: set, S: set)\n ensures U + S == S + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_7092","instance":7092,"id":210435,"goal":"lemma SetInterComm_7092(U: set, B: set)\n ensures U * B == B * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_7093","instance":7093,"id":210436,"goal":"lemma SetUnionAssoc_7093(S: set, T: set, A: set)\n ensures (S + T) + A == S + (T + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_7094","instance":7094,"id":210437,"goal":"lemma SetSubsetRefl_7094(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_7095","instance":7095,"id":210438,"goal":"lemma SetSubsetTrans_7095(B: set, A: set, U: set)\n requires B <= A && A <= U\n ensures B <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_7096","instance":7096,"id":210439,"goal":"lemma SetUnionEmpty_7096(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_7097","instance":7097,"id":210440,"goal":"lemma SetInterEmpty_7097(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_7098","instance":7098,"id":210441,"goal":"lemma SetInterSubset_7098(U: set, T: set)\n ensures U * T <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_7099","instance":7099,"id":210442,"goal":"lemma SetCardSubset_7099(U: set, S: set)\n requires U <= S\n ensures |U| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_7100","instance":7100,"id":210443,"goal":"lemma SetUnionCard_7100(S: set, B: set)\n requires S * B == {}\n ensures |S + B| == |S| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_7101","instance":7101,"id":210444,"goal":"lemma SetUnionComm_7101(S: set, A: set)\n ensures S + A == A + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_7102","instance":7102,"id":210445,"goal":"lemma SetInterComm_7102(U: set, T: set)\n ensures U * T == T * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_7103","instance":7103,"id":210446,"goal":"lemma SetUnionAssoc_7103(T: set, U: set, B: set)\n ensures (T + U) + B == T + (U + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_7104","instance":7104,"id":210447,"goal":"lemma SetSubsetRefl_7104(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_7105","instance":7105,"id":210448,"goal":"lemma SetSubsetTrans_7105(U: set, A: set, T: set)\n requires U <= A && A <= T\n ensures U <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_7106","instance":7106,"id":210449,"goal":"lemma SetUnionEmpty_7106(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_7107","instance":7107,"id":210450,"goal":"lemma SetInterEmpty_7107(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_7108","instance":7108,"id":210451,"goal":"lemma SetInterSubset_7108(A: set, T: set)\n ensures A * T <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_7109","instance":7109,"id":210452,"goal":"lemma SetCardSubset_7109(A: set, B: set)\n requires A <= B\n ensures |A| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_7110","instance":7110,"id":210453,"goal":"lemma SetUnionCard_7110(B: set, U: set)\n requires B * U == {}\n ensures |B + U| == |B| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_7111","instance":7111,"id":210454,"goal":"lemma SetUnionComm_7111(B: set, U: set)\n ensures B + U == U + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_7112","instance":7112,"id":210455,"goal":"lemma SetInterComm_7112(T: set, B: set)\n ensures T * B == B * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_7113","instance":7113,"id":210456,"goal":"lemma SetUnionAssoc_7113(S: set, U: set, A: set)\n ensures (S + U) + A == S + (U + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_7114","instance":7114,"id":210457,"goal":"lemma SetSubsetRefl_7114(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_7115","instance":7115,"id":210458,"goal":"lemma SetSubsetTrans_7115(A: set, B: set, U: set)\n requires A <= B && B <= U\n ensures A <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_7116","instance":7116,"id":210459,"goal":"lemma SetUnionEmpty_7116(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_7117","instance":7117,"id":210460,"goal":"lemma SetInterEmpty_7117(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_7118","instance":7118,"id":210461,"goal":"lemma SetInterSubset_7118(A: set, S: set)\n ensures A * S <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_7119","instance":7119,"id":210462,"goal":"lemma SetCardSubset_7119(U: set, B: set)\n requires U <= B\n ensures |U| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_7120","instance":7120,"id":210463,"goal":"lemma SetUnionCard_7120(T: set, S: set)\n requires T * S == {}\n ensures |T + S| == |T| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_7121","instance":7121,"id":210464,"goal":"lemma SetUnionComm_7121(T: set, S: set)\n ensures T + S == S + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_7122","instance":7122,"id":210465,"goal":"lemma SetInterComm_7122(A: set, U: set)\n ensures A * U == U * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_7123","instance":7123,"id":210466,"goal":"lemma SetUnionAssoc_7123(U: set, A: set, T: set)\n ensures (U + A) + T == U + (A + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_7124","instance":7124,"id":210467,"goal":"lemma SetSubsetRefl_7124(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_7125","instance":7125,"id":210468,"goal":"lemma SetSubsetTrans_7125(B: set, T: set, S: set)\n requires B <= T && T <= S\n ensures B <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_7126","instance":7126,"id":210469,"goal":"lemma SetUnionEmpty_7126(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_7127","instance":7127,"id":210470,"goal":"lemma SetInterEmpty_7127(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_7128","instance":7128,"id":210471,"goal":"lemma SetInterSubset_7128(T: set, S: set)\n ensures T * S <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_7129","instance":7129,"id":210472,"goal":"lemma SetCardSubset_7129(A: set, T: set)\n requires A <= T\n ensures |A| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_7130","instance":7130,"id":210473,"goal":"lemma SetUnionCard_7130(A: set, S: set)\n requires A * S == {}\n ensures |A + S| == |A| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_7131","instance":7131,"id":210474,"goal":"lemma SetUnionComm_7131(S: set, A: set)\n ensures S + A == A + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_7132","instance":7132,"id":210475,"goal":"lemma SetInterComm_7132(A: set, T: set)\n ensures A * T == T * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_7133","instance":7133,"id":210476,"goal":"lemma SetUnionAssoc_7133(U: set, S: set, T: set)\n ensures (U + S) + T == U + (S + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_7134","instance":7134,"id":210477,"goal":"lemma SetSubsetRefl_7134(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_7135","instance":7135,"id":210478,"goal":"lemma SetSubsetTrans_7135(A: set, U: set, B: set)\n requires A <= U && U <= B\n ensures A <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_7136","instance":7136,"id":210479,"goal":"lemma SetUnionEmpty_7136(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_7137","instance":7137,"id":210480,"goal":"lemma SetInterEmpty_7137(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_7138","instance":7138,"id":210481,"goal":"lemma SetInterSubset_7138(U: set, S: set)\n ensures U * S <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_7139","instance":7139,"id":210482,"goal":"lemma SetCardSubset_7139(A: set, U: set)\n requires A <= U\n ensures |A| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_7140","instance":7140,"id":210483,"goal":"lemma SetUnionCard_7140(B: set, U: set)\n requires B * U == {}\n ensures |B + U| == |B| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_7141","instance":7141,"id":210484,"goal":"lemma SetUnionComm_7141(B: set, T: set)\n ensures B + T == T + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_7142","instance":7142,"id":210485,"goal":"lemma SetInterComm_7142(T: set, A: set)\n ensures T * A == A * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_7143","instance":7143,"id":210486,"goal":"lemma SetUnionAssoc_7143(T: set, U: set, S: set)\n ensures (T + U) + S == T + (U + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_7144","instance":7144,"id":210487,"goal":"lemma SetSubsetRefl_7144(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_7145","instance":7145,"id":210488,"goal":"lemma SetSubsetTrans_7145(T: set, A: set, S: set)\n requires T <= A && A <= S\n ensures T <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_7146","instance":7146,"id":210489,"goal":"lemma SetUnionEmpty_7146(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_7147","instance":7147,"id":210490,"goal":"lemma SetInterEmpty_7147(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_7148","instance":7148,"id":210491,"goal":"lemma SetInterSubset_7148(T: set, S: set)\n ensures T * S <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_7149","instance":7149,"id":210492,"goal":"lemma SetCardSubset_7149(U: set, A: set)\n requires U <= A\n ensures |U| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_7150","instance":7150,"id":210493,"goal":"lemma SetUnionCard_7150(B: set, U: set)\n requires B * U == {}\n ensures |B + U| == |B| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_7151","instance":7151,"id":210494,"goal":"lemma SetUnionComm_7151(T: set, U: set)\n ensures T + U == U + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_7152","instance":7152,"id":210495,"goal":"lemma SetInterComm_7152(A: set, U: set)\n ensures A * U == U * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_7153","instance":7153,"id":210496,"goal":"lemma SetUnionAssoc_7153(A: set, S: set, U: set)\n ensures (A + S) + U == A + (S + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_7154","instance":7154,"id":210497,"goal":"lemma SetSubsetRefl_7154(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_7155","instance":7155,"id":210498,"goal":"lemma SetSubsetTrans_7155(B: set, T: set, U: set)\n requires B <= T && T <= U\n ensures B <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_7156","instance":7156,"id":210499,"goal":"lemma SetUnionEmpty_7156(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_7157","instance":7157,"id":210500,"goal":"lemma SetInterEmpty_7157(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_7158","instance":7158,"id":210501,"goal":"lemma SetInterSubset_7158(U: set, S: set)\n ensures U * S <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_7159","instance":7159,"id":210502,"goal":"lemma SetCardSubset_7159(U: set, S: set)\n requires U <= S\n ensures |U| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_7160","instance":7160,"id":210503,"goal":"lemma SetUnionCard_7160(S: set, B: set)\n requires S * B == {}\n ensures |S + B| == |S| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_7161","instance":7161,"id":210504,"goal":"lemma SetUnionComm_7161(S: set, B: set)\n ensures S + B == B + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_7162","instance":7162,"id":210505,"goal":"lemma SetInterComm_7162(U: set, T: set)\n ensures U * T == T * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_7163","instance":7163,"id":210506,"goal":"lemma SetUnionAssoc_7163(A: set, U: set, T: set)\n ensures (A + U) + T == A + (U + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_7164","instance":7164,"id":210507,"goal":"lemma SetSubsetRefl_7164(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_7165","instance":7165,"id":210508,"goal":"lemma SetSubsetTrans_7165(B: set, U: set, A: set)\n requires B <= U && U <= A\n ensures B <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_7166","instance":7166,"id":210509,"goal":"lemma SetUnionEmpty_7166(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_7167","instance":7167,"id":210510,"goal":"lemma SetInterEmpty_7167(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_7168","instance":7168,"id":210511,"goal":"lemma SetInterSubset_7168(A: set, S: set)\n ensures A * S <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_7169","instance":7169,"id":210512,"goal":"lemma SetCardSubset_7169(B: set, A: set)\n requires B <= A\n ensures |B| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_7170","instance":7170,"id":210513,"goal":"lemma SetUnionCard_7170(S: set, B: set)\n requires S * B == {}\n ensures |S + B| == |S| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_7171","instance":7171,"id":210514,"goal":"lemma SetUnionComm_7171(T: set, A: set)\n ensures T + A == A + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_7172","instance":7172,"id":210515,"goal":"lemma SetInterComm_7172(A: set, T: set)\n ensures A * T == T * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_7173","instance":7173,"id":210516,"goal":"lemma SetUnionAssoc_7173(S: set, T: set, B: set)\n ensures (S + T) + B == S + (T + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_7174","instance":7174,"id":210517,"goal":"lemma SetSubsetRefl_7174(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_7175","instance":7175,"id":210518,"goal":"lemma SetSubsetTrans_7175(A: set, T: set, U: set)\n requires A <= T && T <= U\n ensures A <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_7176","instance":7176,"id":210519,"goal":"lemma SetUnionEmpty_7176(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_7177","instance":7177,"id":210520,"goal":"lemma SetInterEmpty_7177(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_7178","instance":7178,"id":210521,"goal":"lemma SetInterSubset_7178(S: set, A: set)\n ensures S * A <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_7179","instance":7179,"id":210522,"goal":"lemma SetCardSubset_7179(A: set, T: set)\n requires A <= T\n ensures |A| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_7180","instance":7180,"id":210523,"goal":"lemma SetUnionCard_7180(B: set, S: set)\n requires B * S == {}\n ensures |B + S| == |B| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_7181","instance":7181,"id":210524,"goal":"lemma SetUnionComm_7181(U: set, S: set)\n ensures U + S == S + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_7182","instance":7182,"id":210525,"goal":"lemma SetInterComm_7182(A: set, U: set)\n ensures A * U == U * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_7183","instance":7183,"id":210526,"goal":"lemma SetUnionAssoc_7183(T: set, S: set, U: set)\n ensures (T + S) + U == T + (S + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_7184","instance":7184,"id":210527,"goal":"lemma SetSubsetRefl_7184(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_7185","instance":7185,"id":210528,"goal":"lemma SetSubsetTrans_7185(S: set, B: set, U: set)\n requires S <= B && B <= U\n ensures S <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_7186","instance":7186,"id":210529,"goal":"lemma SetUnionEmpty_7186(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_7187","instance":7187,"id":210530,"goal":"lemma SetInterEmpty_7187(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_7188","instance":7188,"id":210531,"goal":"lemma SetInterSubset_7188(S: set, U: set)\n ensures S * U <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_7189","instance":7189,"id":210532,"goal":"lemma SetCardSubset_7189(S: set, U: set)\n requires S <= U\n ensures |S| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_7190","instance":7190,"id":210533,"goal":"lemma SetUnionCard_7190(B: set, A: set)\n requires B * A == {}\n ensures |B + A| == |B| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_7191","instance":7191,"id":210534,"goal":"lemma SetUnionComm_7191(B: set, U: set)\n ensures B + U == U + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_7192","instance":7192,"id":210535,"goal":"lemma SetInterComm_7192(A: set, S: set)\n ensures A * S == S * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_7193","instance":7193,"id":210536,"goal":"lemma SetUnionAssoc_7193(B: set, U: set, S: set)\n ensures (B + U) + S == B + (U + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_7194","instance":7194,"id":210537,"goal":"lemma SetSubsetRefl_7194(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_7195","instance":7195,"id":210538,"goal":"lemma SetSubsetTrans_7195(T: set, A: set, S: set)\n requires T <= A && A <= S\n ensures T <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_7196","instance":7196,"id":210539,"goal":"lemma SetUnionEmpty_7196(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_7197","instance":7197,"id":210540,"goal":"lemma SetInterEmpty_7197(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_7198","instance":7198,"id":210541,"goal":"lemma SetInterSubset_7198(T: set, B: set)\n ensures T * B <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_7199","instance":7199,"id":210542,"goal":"lemma SetCardSubset_7199(T: set, B: set)\n requires T <= B\n ensures |T| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_7200","instance":7200,"id":210543,"goal":"lemma SetUnionCard_7200(T: set, S: set)\n requires T * S == {}\n ensures |T + S| == |T| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_7201","instance":7201,"id":210544,"goal":"lemma SetUnionComm_7201(T: set, U: set)\n ensures T + U == U + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_7202","instance":7202,"id":210545,"goal":"lemma SetInterComm_7202(B: set, S: set)\n ensures B * S == S * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_7203","instance":7203,"id":210546,"goal":"lemma SetUnionAssoc_7203(U: set, T: set, B: set)\n ensures (U + T) + B == U + (T + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_7204","instance":7204,"id":210547,"goal":"lemma SetSubsetRefl_7204(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_7205","instance":7205,"id":210548,"goal":"lemma SetSubsetTrans_7205(T: set, A: set, U: set)\n requires T <= A && A <= U\n ensures T <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_7206","instance":7206,"id":210549,"goal":"lemma SetUnionEmpty_7206(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_7207","instance":7207,"id":210550,"goal":"lemma SetInterEmpty_7207(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_7208","instance":7208,"id":210551,"goal":"lemma SetInterSubset_7208(B: set, U: set)\n ensures B * U <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_7209","instance":7209,"id":210552,"goal":"lemma SetCardSubset_7209(B: set, T: set)\n requires B <= T\n ensures |B| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_7210","instance":7210,"id":210553,"goal":"lemma SetUnionCard_7210(S: set, B: set)\n requires S * B == {}\n ensures |S + B| == |S| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_7211","instance":7211,"id":210554,"goal":"lemma SetUnionComm_7211(T: set, A: set)\n ensures T + A == A + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_7212","instance":7212,"id":210555,"goal":"lemma SetInterComm_7212(A: set, S: set)\n ensures A * S == S * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_7213","instance":7213,"id":210556,"goal":"lemma SetUnionAssoc_7213(U: set, A: set, T: set)\n ensures (U + A) + T == U + (A + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_7214","instance":7214,"id":210557,"goal":"lemma SetSubsetRefl_7214(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_7215","instance":7215,"id":210558,"goal":"lemma SetSubsetTrans_7215(U: set, B: set, S: set)\n requires U <= B && B <= S\n ensures U <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_7216","instance":7216,"id":210559,"goal":"lemma SetUnionEmpty_7216(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_7217","instance":7217,"id":210560,"goal":"lemma SetInterEmpty_7217(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_7218","instance":7218,"id":210561,"goal":"lemma SetInterSubset_7218(A: set, B: set)\n ensures A * B <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_7219","instance":7219,"id":210562,"goal":"lemma SetCardSubset_7219(B: set, U: set)\n requires B <= U\n ensures |B| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_7220","instance":7220,"id":210563,"goal":"lemma SetUnionCard_7220(T: set, B: set)\n requires T * B == {}\n ensures |T + B| == |T| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_7221","instance":7221,"id":210564,"goal":"lemma SetUnionComm_7221(B: set, U: set)\n ensures B + U == U + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_7222","instance":7222,"id":210565,"goal":"lemma SetInterComm_7222(A: set, S: set)\n ensures A * S == S * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_7223","instance":7223,"id":210566,"goal":"lemma SetUnionAssoc_7223(B: set, U: set, T: set)\n ensures (B + U) + T == B + (U + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_7224","instance":7224,"id":210567,"goal":"lemma SetSubsetRefl_7224(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_7225","instance":7225,"id":210568,"goal":"lemma SetSubsetTrans_7225(B: set, S: set, T: set)\n requires B <= S && S <= T\n ensures B <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_7226","instance":7226,"id":210569,"goal":"lemma SetUnionEmpty_7226(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_7227","instance":7227,"id":210570,"goal":"lemma SetInterEmpty_7227(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_7228","instance":7228,"id":210571,"goal":"lemma SetInterSubset_7228(T: set, A: set)\n ensures T * A <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_7229","instance":7229,"id":210572,"goal":"lemma SetCardSubset_7229(T: set, U: set)\n requires T <= U\n ensures |T| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_7230","instance":7230,"id":210573,"goal":"lemma SetUnionCard_7230(U: set, A: set)\n requires U * A == {}\n ensures |U + A| == |U| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_7231","instance":7231,"id":210574,"goal":"lemma SetUnionComm_7231(T: set, B: set)\n ensures T + B == B + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_7232","instance":7232,"id":210575,"goal":"lemma SetInterComm_7232(T: set, U: set)\n ensures T * U == U * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_7233","instance":7233,"id":210576,"goal":"lemma SetUnionAssoc_7233(A: set, B: set, S: set)\n ensures (A + B) + S == A + (B + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_7234","instance":7234,"id":210577,"goal":"lemma SetSubsetRefl_7234(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_7235","instance":7235,"id":210578,"goal":"lemma SetSubsetTrans_7235(U: set, S: set, A: set)\n requires U <= S && S <= A\n ensures U <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_7236","instance":7236,"id":210579,"goal":"lemma SetUnionEmpty_7236(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_7237","instance":7237,"id":210580,"goal":"lemma SetInterEmpty_7237(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_7238","instance":7238,"id":210581,"goal":"lemma SetInterSubset_7238(A: set, T: set)\n ensures A * T <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_7239","instance":7239,"id":210582,"goal":"lemma SetCardSubset_7239(S: set, T: set)\n requires S <= T\n ensures |S| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_7240","instance":7240,"id":210583,"goal":"lemma SetUnionCard_7240(U: set, B: set)\n requires U * B == {}\n ensures |U + B| == |U| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_7241","instance":7241,"id":210584,"goal":"lemma SetUnionComm_7241(S: set, A: set)\n ensures S + A == A + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_7242","instance":7242,"id":210585,"goal":"lemma SetInterComm_7242(S: set, U: set)\n ensures S * U == U * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_7243","instance":7243,"id":210586,"goal":"lemma SetUnionAssoc_7243(U: set, B: set, T: set)\n ensures (U + B) + T == U + (B + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_7244","instance":7244,"id":210587,"goal":"lemma SetSubsetRefl_7244(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_7245","instance":7245,"id":210588,"goal":"lemma SetSubsetTrans_7245(B: set, T: set, A: set)\n requires B <= T && T <= A\n ensures B <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_7246","instance":7246,"id":210589,"goal":"lemma SetUnionEmpty_7246(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_7247","instance":7247,"id":210590,"goal":"lemma SetInterEmpty_7247(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_7248","instance":7248,"id":210591,"goal":"lemma SetInterSubset_7248(T: set, S: set)\n ensures T * S <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_7249","instance":7249,"id":210592,"goal":"lemma SetCardSubset_7249(S: set, A: set)\n requires S <= A\n ensures |S| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_7250","instance":7250,"id":210593,"goal":"lemma SetUnionCard_7250(T: set, S: set)\n requires T * S == {}\n ensures |T + S| == |T| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_7251","instance":7251,"id":210594,"goal":"lemma SetUnionComm_7251(U: set, S: set)\n ensures U + S == S + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_7252","instance":7252,"id":210595,"goal":"lemma SetInterComm_7252(T: set, A: set)\n ensures T * A == A * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_7253","instance":7253,"id":210596,"goal":"lemma SetUnionAssoc_7253(B: set, S: set, T: set)\n ensures (B + S) + T == B + (S + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_7254","instance":7254,"id":210597,"goal":"lemma SetSubsetRefl_7254(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_7255","instance":7255,"id":210598,"goal":"lemma SetSubsetTrans_7255(U: set, A: set, T: set)\n requires U <= A && A <= T\n ensures U <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_7256","instance":7256,"id":210599,"goal":"lemma SetUnionEmpty_7256(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_7257","instance":7257,"id":210600,"goal":"lemma SetInterEmpty_7257(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_7258","instance":7258,"id":210601,"goal":"lemma SetInterSubset_7258(S: set, T: set)\n ensures S * T <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_7259","instance":7259,"id":210602,"goal":"lemma SetCardSubset_7259(T: set, B: set)\n requires T <= B\n ensures |T| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_7260","instance":7260,"id":210603,"goal":"lemma SetUnionCard_7260(U: set, S: set)\n requires U * S == {}\n ensures |U + S| == |U| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_7261","instance":7261,"id":210604,"goal":"lemma SetUnionComm_7261(U: set, A: set)\n ensures U + A == A + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_7262","instance":7262,"id":210605,"goal":"lemma SetInterComm_7262(A: set, B: set)\n ensures A * B == B * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_7263","instance":7263,"id":210606,"goal":"lemma SetUnionAssoc_7263(A: set, S: set, T: set)\n ensures (A + S) + T == A + (S + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_7264","instance":7264,"id":210607,"goal":"lemma SetSubsetRefl_7264(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_7265","instance":7265,"id":210608,"goal":"lemma SetSubsetTrans_7265(U: set, A: set, B: set)\n requires U <= A && A <= B\n ensures U <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_7266","instance":7266,"id":210609,"goal":"lemma SetUnionEmpty_7266(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_7267","instance":7267,"id":210610,"goal":"lemma SetInterEmpty_7267(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_7268","instance":7268,"id":210611,"goal":"lemma SetInterSubset_7268(B: set, T: set)\n ensures B * T <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_7269","instance":7269,"id":210612,"goal":"lemma SetCardSubset_7269(T: set, A: set)\n requires T <= A\n ensures |T| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_7270","instance":7270,"id":210613,"goal":"lemma SetUnionCard_7270(U: set, A: set)\n requires U * A == {}\n ensures |U + A| == |U| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_7271","instance":7271,"id":210614,"goal":"lemma SetUnionComm_7271(S: set, U: set)\n ensures S + U == U + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_7272","instance":7272,"id":210615,"goal":"lemma SetInterComm_7272(B: set, U: set)\n ensures B * U == U * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_7273","instance":7273,"id":210616,"goal":"lemma SetUnionAssoc_7273(T: set, A: set, S: set)\n ensures (T + A) + S == T + (A + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_7274","instance":7274,"id":210617,"goal":"lemma SetSubsetRefl_7274(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_7275","instance":7275,"id":210618,"goal":"lemma SetSubsetTrans_7275(S: set, U: set, A: set)\n requires S <= U && U <= A\n ensures S <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_7276","instance":7276,"id":210619,"goal":"lemma SetUnionEmpty_7276(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_7277","instance":7277,"id":210620,"goal":"lemma SetInterEmpty_7277(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_7278","instance":7278,"id":210621,"goal":"lemma SetInterSubset_7278(B: set, A: set)\n ensures B * A <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_7279","instance":7279,"id":210622,"goal":"lemma SetCardSubset_7279(S: set, U: set)\n requires S <= U\n ensures |S| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_7280","instance":7280,"id":210623,"goal":"lemma SetUnionCard_7280(A: set, B: set)\n requires A * B == {}\n ensures |A + B| == |A| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_7281","instance":7281,"id":210624,"goal":"lemma SetUnionComm_7281(U: set, T: set)\n ensures U + T == T + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_7282","instance":7282,"id":210625,"goal":"lemma SetInterComm_7282(S: set, A: set)\n ensures S * A == A * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_7283","instance":7283,"id":210626,"goal":"lemma SetUnionAssoc_7283(B: set, S: set, T: set)\n ensures (B + S) + T == B + (S + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_7284","instance":7284,"id":210627,"goal":"lemma SetSubsetRefl_7284(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_7285","instance":7285,"id":210628,"goal":"lemma SetSubsetTrans_7285(T: set, U: set, S: set)\n requires T <= U && U <= S\n ensures T <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_7286","instance":7286,"id":210629,"goal":"lemma SetUnionEmpty_7286(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_7287","instance":7287,"id":210630,"goal":"lemma SetInterEmpty_7287(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_7288","instance":7288,"id":210631,"goal":"lemma SetInterSubset_7288(B: set, U: set)\n ensures B * U <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_7289","instance":7289,"id":210632,"goal":"lemma SetCardSubset_7289(B: set, A: set)\n requires B <= A\n ensures |B| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_7290","instance":7290,"id":210633,"goal":"lemma SetUnionCard_7290(T: set, A: set)\n requires T * A == {}\n ensures |T + A| == |T| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_7291","instance":7291,"id":210634,"goal":"lemma SetUnionComm_7291(S: set, A: set)\n ensures S + A == A + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_7292","instance":7292,"id":210635,"goal":"lemma SetInterComm_7292(T: set, S: set)\n ensures T * S == S * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_7293","instance":7293,"id":210636,"goal":"lemma SetUnionAssoc_7293(S: set, A: set, T: set)\n ensures (S + A) + T == S + (A + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_7294","instance":7294,"id":210637,"goal":"lemma SetSubsetRefl_7294(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_7295","instance":7295,"id":210638,"goal":"lemma SetSubsetTrans_7295(A: set, U: set, T: set)\n requires A <= U && U <= T\n ensures A <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_7296","instance":7296,"id":210639,"goal":"lemma SetUnionEmpty_7296(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_7297","instance":7297,"id":210640,"goal":"lemma SetInterEmpty_7297(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_7298","instance":7298,"id":210641,"goal":"lemma SetInterSubset_7298(S: set, B: set)\n ensures S * B <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_7299","instance":7299,"id":210642,"goal":"lemma SetCardSubset_7299(T: set, B: set)\n requires T <= B\n ensures |T| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_7300","instance":7300,"id":210643,"goal":"lemma SetUnionCard_7300(S: set, U: set)\n requires S * U == {}\n ensures |S + U| == |S| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_7301","instance":7301,"id":210644,"goal":"lemma SetUnionComm_7301(S: set, U: set)\n ensures S + U == U + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_7302","instance":7302,"id":210645,"goal":"lemma SetInterComm_7302(A: set, T: set)\n ensures A * T == T * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_7303","instance":7303,"id":210646,"goal":"lemma SetUnionAssoc_7303(T: set, A: set, S: set)\n ensures (T + A) + S == T + (A + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_7304","instance":7304,"id":210647,"goal":"lemma SetSubsetRefl_7304(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_7305","instance":7305,"id":210648,"goal":"lemma SetSubsetTrans_7305(B: set, A: set, S: set)\n requires B <= A && A <= S\n ensures B <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_7306","instance":7306,"id":210649,"goal":"lemma SetUnionEmpty_7306(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_7307","instance":7307,"id":210650,"goal":"lemma SetInterEmpty_7307(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_7308","instance":7308,"id":210651,"goal":"lemma SetInterSubset_7308(T: set, B: set)\n ensures T * B <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_7309","instance":7309,"id":210652,"goal":"lemma SetCardSubset_7309(S: set, T: set)\n requires S <= T\n ensures |S| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_7310","instance":7310,"id":210653,"goal":"lemma SetUnionCard_7310(U: set, B: set)\n requires U * B == {}\n ensures |U + B| == |U| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_7311","instance":7311,"id":210654,"goal":"lemma SetUnionComm_7311(B: set, T: set)\n ensures B + T == T + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_7312","instance":7312,"id":210655,"goal":"lemma SetInterComm_7312(B: set, A: set)\n ensures B * A == A * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_7313","instance":7313,"id":210656,"goal":"lemma SetUnionAssoc_7313(U: set, B: set, S: set)\n ensures (U + B) + S == U + (B + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_7314","instance":7314,"id":210657,"goal":"lemma SetSubsetRefl_7314(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_7315","instance":7315,"id":210658,"goal":"lemma SetSubsetTrans_7315(A: set, S: set, B: set)\n requires A <= S && S <= B\n ensures A <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_7316","instance":7316,"id":210659,"goal":"lemma SetUnionEmpty_7316(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_7317","instance":7317,"id":210660,"goal":"lemma SetInterEmpty_7317(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_7318","instance":7318,"id":210661,"goal":"lemma SetInterSubset_7318(T: set, B: set)\n ensures T * B <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_7319","instance":7319,"id":210662,"goal":"lemma SetCardSubset_7319(A: set, B: set)\n requires A <= B\n ensures |A| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_7320","instance":7320,"id":210663,"goal":"lemma SetUnionCard_7320(A: set, U: set)\n requires A * U == {}\n ensures |A + U| == |A| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_7321","instance":7321,"id":210664,"goal":"lemma SetUnionComm_7321(A: set, S: set)\n ensures A + S == S + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_7322","instance":7322,"id":210665,"goal":"lemma SetInterComm_7322(T: set, A: set)\n ensures T * A == A * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_7323","instance":7323,"id":210666,"goal":"lemma SetUnionAssoc_7323(B: set, S: set, T: set)\n ensures (B + S) + T == B + (S + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_7324","instance":7324,"id":210667,"goal":"lemma SetSubsetRefl_7324(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_7325","instance":7325,"id":210668,"goal":"lemma SetSubsetTrans_7325(U: set, B: set, S: set)\n requires U <= B && B <= S\n ensures U <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_7326","instance":7326,"id":210669,"goal":"lemma SetUnionEmpty_7326(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_7327","instance":7327,"id":210670,"goal":"lemma SetInterEmpty_7327(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_7328","instance":7328,"id":210671,"goal":"lemma SetInterSubset_7328(S: set, A: set)\n ensures S * A <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_7329","instance":7329,"id":210672,"goal":"lemma SetCardSubset_7329(U: set, B: set)\n requires U <= B\n ensures |U| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_7330","instance":7330,"id":210673,"goal":"lemma SetUnionCard_7330(A: set, S: set)\n requires A * S == {}\n ensures |A + S| == |A| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_7331","instance":7331,"id":210674,"goal":"lemma SetUnionComm_7331(S: set, U: set)\n ensures S + U == U + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_7332","instance":7332,"id":210675,"goal":"lemma SetInterComm_7332(U: set, B: set)\n ensures U * B == B * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_7333","instance":7333,"id":210676,"goal":"lemma SetUnionAssoc_7333(S: set, B: set, U: set)\n ensures (S + B) + U == S + (B + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_7334","instance":7334,"id":210677,"goal":"lemma SetSubsetRefl_7334(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_7335","instance":7335,"id":210678,"goal":"lemma SetSubsetTrans_7335(S: set, A: set, U: set)\n requires S <= A && A <= U\n ensures S <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_7336","instance":7336,"id":210679,"goal":"lemma SetUnionEmpty_7336(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_7337","instance":7337,"id":210680,"goal":"lemma SetInterEmpty_7337(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_7338","instance":7338,"id":210681,"goal":"lemma SetInterSubset_7338(T: set, B: set)\n ensures T * B <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_7339","instance":7339,"id":210682,"goal":"lemma SetCardSubset_7339(S: set, U: set)\n requires S <= U\n ensures |S| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_7340","instance":7340,"id":210683,"goal":"lemma SetUnionCard_7340(S: set, A: set)\n requires S * A == {}\n ensures |S + A| == |S| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_7341","instance":7341,"id":210684,"goal":"lemma SetUnionComm_7341(S: set, B: set)\n ensures S + B == B + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_7342","instance":7342,"id":210685,"goal":"lemma SetInterComm_7342(B: set, S: set)\n ensures B * S == S * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_7343","instance":7343,"id":210686,"goal":"lemma SetUnionAssoc_7343(S: set, U: set, T: set)\n ensures (S + U) + T == S + (U + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_7344","instance":7344,"id":210687,"goal":"lemma SetSubsetRefl_7344(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_7345","instance":7345,"id":210688,"goal":"lemma SetSubsetTrans_7345(S: set, A: set, U: set)\n requires S <= A && A <= U\n ensures S <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_7346","instance":7346,"id":210689,"goal":"lemma SetUnionEmpty_7346(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_7347","instance":7347,"id":210690,"goal":"lemma SetInterEmpty_7347(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_7348","instance":7348,"id":210691,"goal":"lemma SetInterSubset_7348(S: set, T: set)\n ensures S * T <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_7349","instance":7349,"id":210692,"goal":"lemma SetCardSubset_7349(T: set, B: set)\n requires T <= B\n ensures |T| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_7350","instance":7350,"id":210693,"goal":"lemma SetUnionCard_7350(B: set, A: set)\n requires B * A == {}\n ensures |B + A| == |B| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_7351","instance":7351,"id":210694,"goal":"lemma SetUnionComm_7351(T: set, S: set)\n ensures T + S == S + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_7352","instance":7352,"id":210695,"goal":"lemma SetInterComm_7352(B: set, S: set)\n ensures B * S == S * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_7353","instance":7353,"id":210696,"goal":"lemma SetUnionAssoc_7353(T: set, S: set, A: set)\n ensures (T + S) + A == T + (S + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_7354","instance":7354,"id":210697,"goal":"lemma SetSubsetRefl_7354(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_7355","instance":7355,"id":210698,"goal":"lemma SetSubsetTrans_7355(B: set, A: set, S: set)\n requires B <= A && A <= S\n ensures B <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_7356","instance":7356,"id":210699,"goal":"lemma SetUnionEmpty_7356(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_7357","instance":7357,"id":210700,"goal":"lemma SetInterEmpty_7357(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_7358","instance":7358,"id":210701,"goal":"lemma SetInterSubset_7358(B: set, T: set)\n ensures B * T <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_7359","instance":7359,"id":210702,"goal":"lemma SetCardSubset_7359(S: set, A: set)\n requires S <= A\n ensures |S| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_7360","instance":7360,"id":210703,"goal":"lemma SetUnionCard_7360(U: set, T: set)\n requires U * T == {}\n ensures |U + T| == |U| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_7361","instance":7361,"id":210704,"goal":"lemma SetUnionComm_7361(U: set, S: set)\n ensures U + S == S + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_7362","instance":7362,"id":210705,"goal":"lemma SetInterComm_7362(A: set, S: set)\n ensures A * S == S * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_7363","instance":7363,"id":210706,"goal":"lemma SetUnionAssoc_7363(T: set, U: set, B: set)\n ensures (T + U) + B == T + (U + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_7364","instance":7364,"id":210707,"goal":"lemma SetSubsetRefl_7364(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_7365","instance":7365,"id":210708,"goal":"lemma SetSubsetTrans_7365(T: set, S: set, U: set)\n requires T <= S && S <= U\n ensures T <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_7366","instance":7366,"id":210709,"goal":"lemma SetUnionEmpty_7366(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_7367","instance":7367,"id":210710,"goal":"lemma SetInterEmpty_7367(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_7368","instance":7368,"id":210711,"goal":"lemma SetInterSubset_7368(T: set, B: set)\n ensures T * B <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_7369","instance":7369,"id":210712,"goal":"lemma SetCardSubset_7369(B: set, T: set)\n requires B <= T\n ensures |B| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_7370","instance":7370,"id":210713,"goal":"lemma SetUnionCard_7370(S: set, B: set)\n requires S * B == {}\n ensures |S + B| == |S| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_7371","instance":7371,"id":210714,"goal":"lemma SetUnionComm_7371(T: set, B: set)\n ensures T + B == B + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_7372","instance":7372,"id":210715,"goal":"lemma SetInterComm_7372(T: set, U: set)\n ensures T * U == U * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_7373","instance":7373,"id":210716,"goal":"lemma SetUnionAssoc_7373(A: set, T: set, S: set)\n ensures (A + T) + S == A + (T + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_7374","instance":7374,"id":210717,"goal":"lemma SetSubsetRefl_7374(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_7375","instance":7375,"id":210718,"goal":"lemma SetSubsetTrans_7375(T: set, U: set, S: set)\n requires T <= U && U <= S\n ensures T <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_7376","instance":7376,"id":210719,"goal":"lemma SetUnionEmpty_7376(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_7377","instance":7377,"id":210720,"goal":"lemma SetInterEmpty_7377(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_7378","instance":7378,"id":210721,"goal":"lemma SetInterSubset_7378(A: set, S: set)\n ensures A * S <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_7379","instance":7379,"id":210722,"goal":"lemma SetCardSubset_7379(A: set, S: set)\n requires A <= S\n ensures |A| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_7380","instance":7380,"id":210723,"goal":"lemma SetUnionCard_7380(A: set, U: set)\n requires A * U == {}\n ensures |A + U| == |A| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_7381","instance":7381,"id":210724,"goal":"lemma SetUnionComm_7381(B: set, S: set)\n ensures B + S == S + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_7382","instance":7382,"id":210725,"goal":"lemma SetInterComm_7382(S: set, B: set)\n ensures S * B == B * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_7383","instance":7383,"id":210726,"goal":"lemma SetUnionAssoc_7383(S: set, B: set, T: set)\n ensures (S + B) + T == S + (B + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_7384","instance":7384,"id":210727,"goal":"lemma SetSubsetRefl_7384(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_7385","instance":7385,"id":210728,"goal":"lemma SetSubsetTrans_7385(S: set, B: set, U: set)\n requires S <= B && B <= U\n ensures S <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_7386","instance":7386,"id":210729,"goal":"lemma SetUnionEmpty_7386(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_7387","instance":7387,"id":210730,"goal":"lemma SetInterEmpty_7387(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_7388","instance":7388,"id":210731,"goal":"lemma SetInterSubset_7388(S: set, U: set)\n ensures S * U <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_7389","instance":7389,"id":210732,"goal":"lemma SetCardSubset_7389(A: set, T: set)\n requires A <= T\n ensures |A| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_7390","instance":7390,"id":210733,"goal":"lemma SetUnionCard_7390(T: set, B: set)\n requires T * B == {}\n ensures |T + B| == |T| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_7391","instance":7391,"id":210734,"goal":"lemma SetUnionComm_7391(A: set, S: set)\n ensures A + S == S + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_7392","instance":7392,"id":210735,"goal":"lemma SetInterComm_7392(S: set, A: set)\n ensures S * A == A * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_7393","instance":7393,"id":210736,"goal":"lemma SetUnionAssoc_7393(T: set, U: set, S: set)\n ensures (T + U) + S == T + (U + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_7394","instance":7394,"id":210737,"goal":"lemma SetSubsetRefl_7394(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_7395","instance":7395,"id":210738,"goal":"lemma SetSubsetTrans_7395(S: set, A: set, B: set)\n requires S <= A && A <= B\n ensures S <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_7396","instance":7396,"id":210739,"goal":"lemma SetUnionEmpty_7396(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_7397","instance":7397,"id":210740,"goal":"lemma SetInterEmpty_7397(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_7398","instance":7398,"id":210741,"goal":"lemma SetInterSubset_7398(A: set, U: set)\n ensures A * U <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_7399","instance":7399,"id":210742,"goal":"lemma SetCardSubset_7399(U: set, B: set)\n requires U <= B\n ensures |U| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_7400","instance":7400,"id":210743,"goal":"lemma SetUnionCard_7400(A: set, S: set)\n requires A * S == {}\n ensures |A + S| == |A| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_7401","instance":7401,"id":210744,"goal":"lemma SetUnionComm_7401(A: set, T: set)\n ensures A + T == T + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_7402","instance":7402,"id":210745,"goal":"lemma SetInterComm_7402(S: set, B: set)\n ensures S * B == B * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_7403","instance":7403,"id":210746,"goal":"lemma SetUnionAssoc_7403(B: set, S: set, A: set)\n ensures (B + S) + A == B + (S + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_7404","instance":7404,"id":210747,"goal":"lemma SetSubsetRefl_7404(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_7405","instance":7405,"id":210748,"goal":"lemma SetSubsetTrans_7405(T: set, S: set, B: set)\n requires T <= S && S <= B\n ensures T <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_7406","instance":7406,"id":210749,"goal":"lemma SetUnionEmpty_7406(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_7407","instance":7407,"id":210750,"goal":"lemma SetInterEmpty_7407(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_7408","instance":7408,"id":210751,"goal":"lemma SetInterSubset_7408(B: set, S: set)\n ensures B * S <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_7409","instance":7409,"id":210752,"goal":"lemma SetCardSubset_7409(U: set, A: set)\n requires U <= A\n ensures |U| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_7410","instance":7410,"id":210753,"goal":"lemma SetUnionCard_7410(S: set, U: set)\n requires S * U == {}\n ensures |S + U| == |S| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_7411","instance":7411,"id":210754,"goal":"lemma SetUnionComm_7411(A: set, S: set)\n ensures A + S == S + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_7412","instance":7412,"id":210755,"goal":"lemma SetInterComm_7412(T: set, S: set)\n ensures T * S == S * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_7413","instance":7413,"id":210756,"goal":"lemma SetUnionAssoc_7413(B: set, U: set, A: set)\n ensures (B + U) + A == B + (U + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_7414","instance":7414,"id":210757,"goal":"lemma SetSubsetRefl_7414(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_7415","instance":7415,"id":210758,"goal":"lemma SetSubsetTrans_7415(T: set, B: set, S: set)\n requires T <= B && B <= S\n ensures T <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_7416","instance":7416,"id":210759,"goal":"lemma SetUnionEmpty_7416(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_7417","instance":7417,"id":210760,"goal":"lemma SetInterEmpty_7417(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_7418","instance":7418,"id":210761,"goal":"lemma SetInterSubset_7418(U: set, B: set)\n ensures U * B <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_7419","instance":7419,"id":210762,"goal":"lemma SetCardSubset_7419(A: set, B: set)\n requires A <= B\n ensures |A| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_7420","instance":7420,"id":210763,"goal":"lemma SetUnionCard_7420(S: set, U: set)\n requires S * U == {}\n ensures |S + U| == |S| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_7421","instance":7421,"id":210764,"goal":"lemma SetUnionComm_7421(A: set, B: set)\n ensures A + B == B + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_7422","instance":7422,"id":210765,"goal":"lemma SetInterComm_7422(B: set, T: set)\n ensures B * T == T * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_7423","instance":7423,"id":210766,"goal":"lemma SetUnionAssoc_7423(A: set, U: set, B: set)\n ensures (A + U) + B == A + (U + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_7424","instance":7424,"id":210767,"goal":"lemma SetSubsetRefl_7424(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_7425","instance":7425,"id":210768,"goal":"lemma SetSubsetTrans_7425(B: set, U: set, A: set)\n requires B <= U && U <= A\n ensures B <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_7426","instance":7426,"id":210769,"goal":"lemma SetUnionEmpty_7426(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_7427","instance":7427,"id":210770,"goal":"lemma SetInterEmpty_7427(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_7428","instance":7428,"id":210771,"goal":"lemma SetInterSubset_7428(T: set, S: set)\n ensures T * S <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_7429","instance":7429,"id":210772,"goal":"lemma SetCardSubset_7429(A: set, S: set)\n requires A <= S\n ensures |A| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_7430","instance":7430,"id":210773,"goal":"lemma SetUnionCard_7430(A: set, T: set)\n requires A * T == {}\n ensures |A + T| == |A| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_7431","instance":7431,"id":210774,"goal":"lemma SetUnionComm_7431(T: set, S: set)\n ensures T + S == S + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_7432","instance":7432,"id":210775,"goal":"lemma SetInterComm_7432(A: set, B: set)\n ensures A * B == B * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_7433","instance":7433,"id":210776,"goal":"lemma SetUnionAssoc_7433(B: set, A: set, U: set)\n ensures (B + A) + U == B + (A + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_7434","instance":7434,"id":210777,"goal":"lemma SetSubsetRefl_7434(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_7435","instance":7435,"id":210778,"goal":"lemma SetSubsetTrans_7435(T: set, A: set, B: set)\n requires T <= A && A <= B\n ensures T <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_7436","instance":7436,"id":210779,"goal":"lemma SetUnionEmpty_7436(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_7437","instance":7437,"id":210780,"goal":"lemma SetInterEmpty_7437(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_7438","instance":7438,"id":210781,"goal":"lemma SetInterSubset_7438(T: set, A: set)\n ensures T * A <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_7439","instance":7439,"id":210782,"goal":"lemma SetCardSubset_7439(A: set, B: set)\n requires A <= B\n ensures |A| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_7440","instance":7440,"id":210783,"goal":"lemma SetUnionCard_7440(S: set, A: set)\n requires S * A == {}\n ensures |S + A| == |S| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_7441","instance":7441,"id":210784,"goal":"lemma SetUnionComm_7441(B: set, S: set)\n ensures B + S == S + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_7442","instance":7442,"id":210785,"goal":"lemma SetInterComm_7442(B: set, A: set)\n ensures B * A == A * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_7443","instance":7443,"id":210786,"goal":"lemma SetUnionAssoc_7443(B: set, A: set, T: set)\n ensures (B + A) + T == B + (A + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_7444","instance":7444,"id":210787,"goal":"lemma SetSubsetRefl_7444(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_7445","instance":7445,"id":210788,"goal":"lemma SetSubsetTrans_7445(U: set, A: set, T: set)\n requires U <= A && A <= T\n ensures U <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_7446","instance":7446,"id":210789,"goal":"lemma SetUnionEmpty_7446(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_7447","instance":7447,"id":210790,"goal":"lemma SetInterEmpty_7447(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_7448","instance":7448,"id":210791,"goal":"lemma SetInterSubset_7448(B: set, A: set)\n ensures B * A <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_7449","instance":7449,"id":210792,"goal":"lemma SetCardSubset_7449(U: set, B: set)\n requires U <= B\n ensures |U| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_7450","instance":7450,"id":210793,"goal":"lemma SetUnionCard_7450(A: set, T: set)\n requires A * T == {}\n ensures |A + T| == |A| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_7451","instance":7451,"id":210794,"goal":"lemma SetUnionComm_7451(T: set, U: set)\n ensures T + U == U + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_7452","instance":7452,"id":210795,"goal":"lemma SetInterComm_7452(U: set, A: set)\n ensures U * A == A * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_7453","instance":7453,"id":210796,"goal":"lemma SetUnionAssoc_7453(S: set, A: set, B: set)\n ensures (S + A) + B == S + (A + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_7454","instance":7454,"id":210797,"goal":"lemma SetSubsetRefl_7454(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_7455","instance":7455,"id":210798,"goal":"lemma SetSubsetTrans_7455(U: set, S: set, T: set)\n requires U <= S && S <= T\n ensures U <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_7456","instance":7456,"id":210799,"goal":"lemma SetUnionEmpty_7456(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_7457","instance":7457,"id":210800,"goal":"lemma SetInterEmpty_7457(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_7458","instance":7458,"id":210801,"goal":"lemma SetInterSubset_7458(B: set, S: set)\n ensures B * S <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_7459","instance":7459,"id":210802,"goal":"lemma SetCardSubset_7459(U: set, B: set)\n requires U <= B\n ensures |U| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_7460","instance":7460,"id":210803,"goal":"lemma SetUnionCard_7460(B: set, T: set)\n requires B * T == {}\n ensures |B + T| == |B| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_7461","instance":7461,"id":210804,"goal":"lemma SetUnionComm_7461(U: set, T: set)\n ensures U + T == T + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_7462","instance":7462,"id":210805,"goal":"lemma SetInterComm_7462(B: set, T: set)\n ensures B * T == T * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_7463","instance":7463,"id":210806,"goal":"lemma SetUnionAssoc_7463(A: set, T: set, S: set)\n ensures (A + T) + S == A + (T + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_7464","instance":7464,"id":210807,"goal":"lemma SetSubsetRefl_7464(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_7465","instance":7465,"id":210808,"goal":"lemma SetSubsetTrans_7465(B: set, A: set, T: set)\n requires B <= A && A <= T\n ensures B <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_7466","instance":7466,"id":210809,"goal":"lemma SetUnionEmpty_7466(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_7467","instance":7467,"id":210810,"goal":"lemma SetInterEmpty_7467(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_7468","instance":7468,"id":210811,"goal":"lemma SetInterSubset_7468(U: set, A: set)\n ensures U * A <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_7469","instance":7469,"id":210812,"goal":"lemma SetCardSubset_7469(S: set, B: set)\n requires S <= B\n ensures |S| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_7470","instance":7470,"id":210813,"goal":"lemma SetUnionCard_7470(A: set, S: set)\n requires A * S == {}\n ensures |A + S| == |A| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_7471","instance":7471,"id":210814,"goal":"lemma SetUnionComm_7471(U: set, S: set)\n ensures U + S == S + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_7472","instance":7472,"id":210815,"goal":"lemma SetInterComm_7472(S: set, B: set)\n ensures S * B == B * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_7473","instance":7473,"id":210816,"goal":"lemma SetUnionAssoc_7473(A: set, U: set, T: set)\n ensures (A + U) + T == A + (U + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_7474","instance":7474,"id":210817,"goal":"lemma SetSubsetRefl_7474(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_7475","instance":7475,"id":210818,"goal":"lemma SetSubsetTrans_7475(A: set, T: set, B: set)\n requires A <= T && T <= B\n ensures A <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_7476","instance":7476,"id":210819,"goal":"lemma SetUnionEmpty_7476(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_7477","instance":7477,"id":210820,"goal":"lemma SetInterEmpty_7477(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_7478","instance":7478,"id":210821,"goal":"lemma SetInterSubset_7478(S: set, B: set)\n ensures S * B <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_7479","instance":7479,"id":210822,"goal":"lemma SetCardSubset_7479(B: set, U: set)\n requires B <= U\n ensures |B| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_7480","instance":7480,"id":210823,"goal":"lemma SetUnionCard_7480(U: set, S: set)\n requires U * S == {}\n ensures |U + S| == |U| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_7481","instance":7481,"id":210824,"goal":"lemma SetUnionComm_7481(U: set, A: set)\n ensures U + A == A + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_7482","instance":7482,"id":210825,"goal":"lemma SetInterComm_7482(B: set, S: set)\n ensures B * S == S * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_7483","instance":7483,"id":210826,"goal":"lemma SetUnionAssoc_7483(U: set, A: set, S: set)\n ensures (U + A) + S == U + (A + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_7484","instance":7484,"id":210827,"goal":"lemma SetSubsetRefl_7484(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_7485","instance":7485,"id":210828,"goal":"lemma SetSubsetTrans_7485(U: set, B: set, S: set)\n requires U <= B && B <= S\n ensures U <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_7486","instance":7486,"id":210829,"goal":"lemma SetUnionEmpty_7486(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_7487","instance":7487,"id":210830,"goal":"lemma SetInterEmpty_7487(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_7488","instance":7488,"id":210831,"goal":"lemma SetInterSubset_7488(S: set, U: set)\n ensures S * U <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_7489","instance":7489,"id":210832,"goal":"lemma SetCardSubset_7489(B: set, T: set)\n requires B <= T\n ensures |B| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_7490","instance":7490,"id":210833,"goal":"lemma SetUnionCard_7490(B: set, A: set)\n requires B * A == {}\n ensures |B + A| == |B| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_7491","instance":7491,"id":210834,"goal":"lemma SetUnionComm_7491(S: set, B: set)\n ensures S + B == B + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_7492","instance":7492,"id":210835,"goal":"lemma SetInterComm_7492(T: set, U: set)\n ensures T * U == U * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_7493","instance":7493,"id":210836,"goal":"lemma SetUnionAssoc_7493(U: set, S: set, B: set)\n ensures (U + S) + B == U + (S + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_7494","instance":7494,"id":210837,"goal":"lemma SetSubsetRefl_7494(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_7495","instance":7495,"id":210838,"goal":"lemma SetSubsetTrans_7495(U: set, T: set, A: set)\n requires U <= T && T <= A\n ensures U <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_7496","instance":7496,"id":210839,"goal":"lemma SetUnionEmpty_7496(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_7497","instance":7497,"id":210840,"goal":"lemma SetInterEmpty_7497(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_7498","instance":7498,"id":210841,"goal":"lemma SetInterSubset_7498(A: set, S: set)\n ensures A * S <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_7499","instance":7499,"id":210842,"goal":"lemma SetCardSubset_7499(B: set, S: set)\n requires B <= S\n ensures |B| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_7500","instance":7500,"id":210843,"goal":"lemma SetUnionCard_7500(U: set, B: set)\n requires U * B == {}\n ensures |U + B| == |U| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_7501","instance":7501,"id":210844,"goal":"lemma SetUnionComm_7501(A: set, T: set)\n ensures A + T == T + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_7502","instance":7502,"id":210845,"goal":"lemma SetInterComm_7502(S: set, T: set)\n ensures S * T == T * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_7503","instance":7503,"id":210846,"goal":"lemma SetUnionAssoc_7503(B: set, T: set, S: set)\n ensures (B + T) + S == B + (T + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_7504","instance":7504,"id":210847,"goal":"lemma SetSubsetRefl_7504(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_7505","instance":7505,"id":210848,"goal":"lemma SetSubsetTrans_7505(B: set, T: set, A: set)\n requires B <= T && T <= A\n ensures B <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_7506","instance":7506,"id":210849,"goal":"lemma SetUnionEmpty_7506(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_7507","instance":7507,"id":210850,"goal":"lemma SetInterEmpty_7507(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_7508","instance":7508,"id":210851,"goal":"lemma SetInterSubset_7508(B: set, A: set)\n ensures B * A <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_7509","instance":7509,"id":210852,"goal":"lemma SetCardSubset_7509(U: set, T: set)\n requires U <= T\n ensures |U| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_7510","instance":7510,"id":210853,"goal":"lemma SetUnionCard_7510(S: set, B: set)\n requires S * B == {}\n ensures |S + B| == |S| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_7511","instance":7511,"id":210854,"goal":"lemma SetUnionComm_7511(A: set, S: set)\n ensures A + S == S + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_7512","instance":7512,"id":210855,"goal":"lemma SetInterComm_7512(S: set, A: set)\n ensures S * A == A * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_7513","instance":7513,"id":210856,"goal":"lemma SetUnionAssoc_7513(B: set, S: set, A: set)\n ensures (B + S) + A == B + (S + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_7514","instance":7514,"id":210857,"goal":"lemma SetSubsetRefl_7514(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_7515","instance":7515,"id":210858,"goal":"lemma SetSubsetTrans_7515(T: set, B: set, U: set)\n requires T <= B && B <= U\n ensures T <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_7516","instance":7516,"id":210859,"goal":"lemma SetUnionEmpty_7516(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_7517","instance":7517,"id":210860,"goal":"lemma SetInterEmpty_7517(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_7518","instance":7518,"id":210861,"goal":"lemma SetInterSubset_7518(U: set, B: set)\n ensures U * B <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_7519","instance":7519,"id":210862,"goal":"lemma SetCardSubset_7519(T: set, A: set)\n requires T <= A\n ensures |T| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_7520","instance":7520,"id":210863,"goal":"lemma SetUnionCard_7520(S: set, U: set)\n requires S * U == {}\n ensures |S + U| == |S| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_7521","instance":7521,"id":210864,"goal":"lemma SetUnionComm_7521(B: set, T: set)\n ensures B + T == T + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_7522","instance":7522,"id":210865,"goal":"lemma SetInterComm_7522(A: set, B: set)\n ensures A * B == B * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_7523","instance":7523,"id":210866,"goal":"lemma SetUnionAssoc_7523(S: set, U: set, A: set)\n ensures (S + U) + A == S + (U + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_7524","instance":7524,"id":210867,"goal":"lemma SetSubsetRefl_7524(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_7525","instance":7525,"id":210868,"goal":"lemma SetSubsetTrans_7525(S: set, U: set, T: set)\n requires S <= U && U <= T\n ensures S <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_7526","instance":7526,"id":210869,"goal":"lemma SetUnionEmpty_7526(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_7527","instance":7527,"id":210870,"goal":"lemma SetInterEmpty_7527(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_7528","instance":7528,"id":210871,"goal":"lemma SetInterSubset_7528(U: set, T: set)\n ensures U * T <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_7529","instance":7529,"id":210872,"goal":"lemma SetCardSubset_7529(A: set, T: set)\n requires A <= T\n ensures |A| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_7530","instance":7530,"id":210873,"goal":"lemma SetUnionCard_7530(B: set, S: set)\n requires B * S == {}\n ensures |B + S| == |B| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_7531","instance":7531,"id":210874,"goal":"lemma SetUnionComm_7531(A: set, S: set)\n ensures A + S == S + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_7532","instance":7532,"id":210875,"goal":"lemma SetInterComm_7532(B: set, T: set)\n ensures B * T == T * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_7533","instance":7533,"id":210876,"goal":"lemma SetUnionAssoc_7533(S: set, U: set, T: set)\n ensures (S + U) + T == S + (U + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_7534","instance":7534,"id":210877,"goal":"lemma SetSubsetRefl_7534(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_7535","instance":7535,"id":210878,"goal":"lemma SetSubsetTrans_7535(B: set, U: set, T: set)\n requires B <= U && U <= T\n ensures B <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_7536","instance":7536,"id":210879,"goal":"lemma SetUnionEmpty_7536(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_7537","instance":7537,"id":210880,"goal":"lemma SetInterEmpty_7537(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_7538","instance":7538,"id":210881,"goal":"lemma SetInterSubset_7538(A: set, U: set)\n ensures A * U <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_7539","instance":7539,"id":210882,"goal":"lemma SetCardSubset_7539(T: set, B: set)\n requires T <= B\n ensures |T| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_7540","instance":7540,"id":210883,"goal":"lemma SetUnionCard_7540(U: set, S: set)\n requires U * S == {}\n ensures |U + S| == |U| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_7541","instance":7541,"id":210884,"goal":"lemma SetUnionComm_7541(B: set, T: set)\n ensures B + T == T + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_7542","instance":7542,"id":210885,"goal":"lemma SetInterComm_7542(B: set, T: set)\n ensures B * T == T * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_7543","instance":7543,"id":210886,"goal":"lemma SetUnionAssoc_7543(B: set, T: set, A: set)\n ensures (B + T) + A == B + (T + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_7544","instance":7544,"id":210887,"goal":"lemma SetSubsetRefl_7544(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_7545","instance":7545,"id":210888,"goal":"lemma SetSubsetTrans_7545(A: set, S: set, T: set)\n requires A <= S && S <= T\n ensures A <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_7546","instance":7546,"id":210889,"goal":"lemma SetUnionEmpty_7546(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_7547","instance":7547,"id":210890,"goal":"lemma SetInterEmpty_7547(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_7548","instance":7548,"id":210891,"goal":"lemma SetInterSubset_7548(B: set, T: set)\n ensures B * T <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_7549","instance":7549,"id":210892,"goal":"lemma SetCardSubset_7549(B: set, T: set)\n requires B <= T\n ensures |B| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_7550","instance":7550,"id":210893,"goal":"lemma SetUnionCard_7550(S: set, U: set)\n requires S * U == {}\n ensures |S + U| == |S| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_7551","instance":7551,"id":210894,"goal":"lemma SetUnionComm_7551(T: set, S: set)\n ensures T + S == S + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_7552","instance":7552,"id":210895,"goal":"lemma SetInterComm_7552(U: set, B: set)\n ensures U * B == B * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_7553","instance":7553,"id":210896,"goal":"lemma SetUnionAssoc_7553(U: set, A: set, S: set)\n ensures (U + A) + S == U + (A + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_7554","instance":7554,"id":210897,"goal":"lemma SetSubsetRefl_7554(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_7555","instance":7555,"id":210898,"goal":"lemma SetSubsetTrans_7555(U: set, T: set, S: set)\n requires U <= T && T <= S\n ensures U <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_7556","instance":7556,"id":210899,"goal":"lemma SetUnionEmpty_7556(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_7557","instance":7557,"id":210900,"goal":"lemma SetInterEmpty_7557(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_7558","instance":7558,"id":210901,"goal":"lemma SetInterSubset_7558(A: set, S: set)\n ensures A * S <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_7559","instance":7559,"id":210902,"goal":"lemma SetCardSubset_7559(B: set, A: set)\n requires B <= A\n ensures |B| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_7560","instance":7560,"id":210903,"goal":"lemma SetUnionCard_7560(A: set, U: set)\n requires A * U == {}\n ensures |A + U| == |A| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_7561","instance":7561,"id":210904,"goal":"lemma SetUnionComm_7561(A: set, T: set)\n ensures A + T == T + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_7562","instance":7562,"id":210905,"goal":"lemma SetInterComm_7562(A: set, U: set)\n ensures A * U == U * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_7563","instance":7563,"id":210906,"goal":"lemma SetUnionAssoc_7563(S: set, T: set, A: set)\n ensures (S + T) + A == S + (T + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_7564","instance":7564,"id":210907,"goal":"lemma SetSubsetRefl_7564(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_7565","instance":7565,"id":210908,"goal":"lemma SetSubsetTrans_7565(B: set, T: set, A: set)\n requires B <= T && T <= A\n ensures B <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_7566","instance":7566,"id":210909,"goal":"lemma SetUnionEmpty_7566(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_7567","instance":7567,"id":210910,"goal":"lemma SetInterEmpty_7567(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_7568","instance":7568,"id":210911,"goal":"lemma SetInterSubset_7568(U: set, S: set)\n ensures U * S <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_7569","instance":7569,"id":210912,"goal":"lemma SetCardSubset_7569(B: set, S: set)\n requires B <= S\n ensures |B| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_7570","instance":7570,"id":210913,"goal":"lemma SetUnionCard_7570(B: set, T: set)\n requires B * T == {}\n ensures |B + T| == |B| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_7571","instance":7571,"id":210914,"goal":"lemma SetUnionComm_7571(A: set, S: set)\n ensures A + S == S + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_7572","instance":7572,"id":210915,"goal":"lemma SetInterComm_7572(S: set, T: set)\n ensures S * T == T * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_7573","instance":7573,"id":210916,"goal":"lemma SetUnionAssoc_7573(B: set, T: set, S: set)\n ensures (B + T) + S == B + (T + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_7574","instance":7574,"id":210917,"goal":"lemma SetSubsetRefl_7574(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_7575","instance":7575,"id":210918,"goal":"lemma SetSubsetTrans_7575(B: set, T: set, A: set)\n requires B <= T && T <= A\n ensures B <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_7576","instance":7576,"id":210919,"goal":"lemma SetUnionEmpty_7576(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_7577","instance":7577,"id":210920,"goal":"lemma SetInterEmpty_7577(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_7578","instance":7578,"id":210921,"goal":"lemma SetInterSubset_7578(U: set, S: set)\n ensures U * S <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_7579","instance":7579,"id":210922,"goal":"lemma SetCardSubset_7579(B: set, S: set)\n requires B <= S\n ensures |B| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_7580","instance":7580,"id":210923,"goal":"lemma SetUnionCard_7580(S: set, A: set)\n requires S * A == {}\n ensures |S + A| == |S| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_7581","instance":7581,"id":210924,"goal":"lemma SetUnionComm_7581(A: set, U: set)\n ensures A + U == U + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_7582","instance":7582,"id":210925,"goal":"lemma SetInterComm_7582(B: set, A: set)\n ensures B * A == A * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_7583","instance":7583,"id":210926,"goal":"lemma SetUnionAssoc_7583(U: set, B: set, T: set)\n ensures (U + B) + T == U + (B + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_7584","instance":7584,"id":210927,"goal":"lemma SetSubsetRefl_7584(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_7585","instance":7585,"id":210928,"goal":"lemma SetSubsetTrans_7585(T: set, S: set, B: set)\n requires T <= S && S <= B\n ensures T <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_7586","instance":7586,"id":210929,"goal":"lemma SetUnionEmpty_7586(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_7587","instance":7587,"id":210930,"goal":"lemma SetInterEmpty_7587(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_7588","instance":7588,"id":210931,"goal":"lemma SetInterSubset_7588(T: set, S: set)\n ensures T * S <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_7589","instance":7589,"id":210932,"goal":"lemma SetCardSubset_7589(T: set, S: set)\n requires T <= S\n ensures |T| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_7590","instance":7590,"id":210933,"goal":"lemma SetUnionCard_7590(B: set, T: set)\n requires B * T == {}\n ensures |B + T| == |B| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_7591","instance":7591,"id":210934,"goal":"lemma SetUnionComm_7591(U: set, S: set)\n ensures U + S == S + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_7592","instance":7592,"id":210935,"goal":"lemma SetInterComm_7592(B: set, U: set)\n ensures B * U == U * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_7593","instance":7593,"id":210936,"goal":"lemma SetUnionAssoc_7593(S: set, U: set, T: set)\n ensures (S + U) + T == S + (U + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_7594","instance":7594,"id":210937,"goal":"lemma SetSubsetRefl_7594(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_7595","instance":7595,"id":210938,"goal":"lemma SetSubsetTrans_7595(S: set, A: set, U: set)\n requires S <= A && A <= U\n ensures S <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_7596","instance":7596,"id":210939,"goal":"lemma SetUnionEmpty_7596(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_7597","instance":7597,"id":210940,"goal":"lemma SetInterEmpty_7597(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_7598","instance":7598,"id":210941,"goal":"lemma SetInterSubset_7598(U: set, T: set)\n ensures U * T <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_7599","instance":7599,"id":210942,"goal":"lemma SetCardSubset_7599(S: set, T: set)\n requires S <= T\n ensures |S| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_7600","instance":7600,"id":210943,"goal":"lemma SetUnionCard_7600(B: set, T: set)\n requires B * T == {}\n ensures |B + T| == |B| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_7601","instance":7601,"id":210944,"goal":"lemma SetUnionComm_7601(A: set, U: set)\n ensures A + U == U + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_7602","instance":7602,"id":210945,"goal":"lemma SetInterComm_7602(T: set, B: set)\n ensures T * B == B * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_7603","instance":7603,"id":210946,"goal":"lemma SetUnionAssoc_7603(B: set, U: set, T: set)\n ensures (B + U) + T == B + (U + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_7604","instance":7604,"id":210947,"goal":"lemma SetSubsetRefl_7604(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_7605","instance":7605,"id":210948,"goal":"lemma SetSubsetTrans_7605(T: set, B: set, A: set)\n requires T <= B && B <= A\n ensures T <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_7606","instance":7606,"id":210949,"goal":"lemma SetUnionEmpty_7606(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_7607","instance":7607,"id":210950,"goal":"lemma SetInterEmpty_7607(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_7608","instance":7608,"id":210951,"goal":"lemma SetInterSubset_7608(A: set, U: set)\n ensures A * U <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_7609","instance":7609,"id":210952,"goal":"lemma SetCardSubset_7609(B: set, T: set)\n requires B <= T\n ensures |B| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_7610","instance":7610,"id":210953,"goal":"lemma SetUnionCard_7610(S: set, U: set)\n requires S * U == {}\n ensures |S + U| == |S| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_7611","instance":7611,"id":210954,"goal":"lemma SetUnionComm_7611(U: set, T: set)\n ensures U + T == T + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_7612","instance":7612,"id":210955,"goal":"lemma SetInterComm_7612(S: set, T: set)\n ensures S * T == T * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_7613","instance":7613,"id":210956,"goal":"lemma SetUnionAssoc_7613(A: set, B: set, U: set)\n ensures (A + B) + U == A + (B + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_7614","instance":7614,"id":210957,"goal":"lemma SetSubsetRefl_7614(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_7615","instance":7615,"id":210958,"goal":"lemma SetSubsetTrans_7615(U: set, T: set, B: set)\n requires U <= T && T <= B\n ensures U <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_7616","instance":7616,"id":210959,"goal":"lemma SetUnionEmpty_7616(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_7617","instance":7617,"id":210960,"goal":"lemma SetInterEmpty_7617(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_7618","instance":7618,"id":210961,"goal":"lemma SetInterSubset_7618(U: set, B: set)\n ensures U * B <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_7619","instance":7619,"id":210962,"goal":"lemma SetCardSubset_7619(T: set, B: set)\n requires T <= B\n ensures |T| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_7620","instance":7620,"id":210963,"goal":"lemma SetUnionCard_7620(U: set, B: set)\n requires U * B == {}\n ensures |U + B| == |U| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_7621","instance":7621,"id":210964,"goal":"lemma SetUnionComm_7621(T: set, U: set)\n ensures T + U == U + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_7622","instance":7622,"id":210965,"goal":"lemma SetInterComm_7622(A: set, T: set)\n ensures A * T == T * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_7623","instance":7623,"id":210966,"goal":"lemma SetUnionAssoc_7623(B: set, S: set, A: set)\n ensures (B + S) + A == B + (S + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_7624","instance":7624,"id":210967,"goal":"lemma SetSubsetRefl_7624(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_7625","instance":7625,"id":210968,"goal":"lemma SetSubsetTrans_7625(S: set, T: set, B: set)\n requires S <= T && T <= B\n ensures S <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_7626","instance":7626,"id":210969,"goal":"lemma SetUnionEmpty_7626(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_7627","instance":7627,"id":210970,"goal":"lemma SetInterEmpty_7627(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_7628","instance":7628,"id":210971,"goal":"lemma SetInterSubset_7628(S: set, U: set)\n ensures S * U <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_7629","instance":7629,"id":210972,"goal":"lemma SetCardSubset_7629(S: set, U: set)\n requires S <= U\n ensures |S| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_7630","instance":7630,"id":210973,"goal":"lemma SetUnionCard_7630(S: set, B: set)\n requires S * B == {}\n ensures |S + B| == |S| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_7631","instance":7631,"id":210974,"goal":"lemma SetUnionComm_7631(A: set, B: set)\n ensures A + B == B + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_7632","instance":7632,"id":210975,"goal":"lemma SetInterComm_7632(U: set, B: set)\n ensures U * B == B * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_7633","instance":7633,"id":210976,"goal":"lemma SetUnionAssoc_7633(T: set, U: set, A: set)\n ensures (T + U) + A == T + (U + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_7634","instance":7634,"id":210977,"goal":"lemma SetSubsetRefl_7634(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_7635","instance":7635,"id":210978,"goal":"lemma SetSubsetTrans_7635(T: set, U: set, S: set)\n requires T <= U && U <= S\n ensures T <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_7636","instance":7636,"id":210979,"goal":"lemma SetUnionEmpty_7636(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_7637","instance":7637,"id":210980,"goal":"lemma SetInterEmpty_7637(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_7638","instance":7638,"id":210981,"goal":"lemma SetInterSubset_7638(U: set, B: set)\n ensures U * B <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_7639","instance":7639,"id":210982,"goal":"lemma SetCardSubset_7639(A: set, B: set)\n requires A <= B\n ensures |A| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_7640","instance":7640,"id":210983,"goal":"lemma SetUnionCard_7640(A: set, T: set)\n requires A * T == {}\n ensures |A + T| == |A| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_7641","instance":7641,"id":210984,"goal":"lemma SetUnionComm_7641(B: set, S: set)\n ensures B + S == S + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_7642","instance":7642,"id":210985,"goal":"lemma SetInterComm_7642(A: set, T: set)\n ensures A * T == T * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_7643","instance":7643,"id":210986,"goal":"lemma SetUnionAssoc_7643(B: set, A: set, S: set)\n ensures (B + A) + S == B + (A + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_7644","instance":7644,"id":210987,"goal":"lemma SetSubsetRefl_7644(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_7645","instance":7645,"id":210988,"goal":"lemma SetSubsetTrans_7645(S: set, T: set, A: set)\n requires S <= T && T <= A\n ensures S <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_7646","instance":7646,"id":210989,"goal":"lemma SetUnionEmpty_7646(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_7647","instance":7647,"id":210990,"goal":"lemma SetInterEmpty_7647(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_7648","instance":7648,"id":210991,"goal":"lemma SetInterSubset_7648(S: set, A: set)\n ensures S * A <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_7649","instance":7649,"id":210992,"goal":"lemma SetCardSubset_7649(A: set, S: set)\n requires A <= S\n ensures |A| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_7650","instance":7650,"id":210993,"goal":"lemma SetUnionCard_7650(B: set, T: set)\n requires B * T == {}\n ensures |B + T| == |B| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_7651","instance":7651,"id":210994,"goal":"lemma SetUnionComm_7651(S: set, U: set)\n ensures S + U == U + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_7652","instance":7652,"id":210995,"goal":"lemma SetInterComm_7652(T: set, A: set)\n ensures T * A == A * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_7653","instance":7653,"id":210996,"goal":"lemma SetUnionAssoc_7653(B: set, S: set, U: set)\n ensures (B + S) + U == B + (S + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_7654","instance":7654,"id":210997,"goal":"lemma SetSubsetRefl_7654(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_7655","instance":7655,"id":210998,"goal":"lemma SetSubsetTrans_7655(U: set, A: set, T: set)\n requires U <= A && A <= T\n ensures U <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_7656","instance":7656,"id":210999,"goal":"lemma SetUnionEmpty_7656(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_7657","instance":7657,"id":211000,"goal":"lemma SetInterEmpty_7657(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_7658","instance":7658,"id":211001,"goal":"lemma SetInterSubset_7658(B: set, U: set)\n ensures B * U <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_7659","instance":7659,"id":211002,"goal":"lemma SetCardSubset_7659(B: set, A: set)\n requires B <= A\n ensures |B| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_7660","instance":7660,"id":211003,"goal":"lemma SetUnionCard_7660(S: set, U: set)\n requires S * U == {}\n ensures |S + U| == |S| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_7661","instance":7661,"id":211004,"goal":"lemma SetUnionComm_7661(S: set, B: set)\n ensures S + B == B + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_7662","instance":7662,"id":211005,"goal":"lemma SetInterComm_7662(S: set, B: set)\n ensures S * B == B * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_7663","instance":7663,"id":211006,"goal":"lemma SetUnionAssoc_7663(T: set, A: set, S: set)\n ensures (T + A) + S == T + (A + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_7664","instance":7664,"id":211007,"goal":"lemma SetSubsetRefl_7664(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_7665","instance":7665,"id":211008,"goal":"lemma SetSubsetTrans_7665(A: set, T: set, S: set)\n requires A <= T && T <= S\n ensures A <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_7666","instance":7666,"id":211009,"goal":"lemma SetUnionEmpty_7666(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_7667","instance":7667,"id":211010,"goal":"lemma SetInterEmpty_7667(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_7668","instance":7668,"id":211011,"goal":"lemma SetInterSubset_7668(A: set, B: set)\n ensures A * B <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_7669","instance":7669,"id":211012,"goal":"lemma SetCardSubset_7669(U: set, T: set)\n requires U <= T\n ensures |U| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_7670","instance":7670,"id":211013,"goal":"lemma SetUnionCard_7670(A: set, T: set)\n requires A * T == {}\n ensures |A + T| == |A| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_7671","instance":7671,"id":211014,"goal":"lemma SetUnionComm_7671(U: set, A: set)\n ensures U + A == A + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_7672","instance":7672,"id":211015,"goal":"lemma SetInterComm_7672(A: set, S: set)\n ensures A * S == S * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_7673","instance":7673,"id":211016,"goal":"lemma SetUnionAssoc_7673(A: set, U: set, S: set)\n ensures (A + U) + S == A + (U + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_7674","instance":7674,"id":211017,"goal":"lemma SetSubsetRefl_7674(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_7675","instance":7675,"id":211018,"goal":"lemma SetSubsetTrans_7675(U: set, B: set, A: set)\n requires U <= B && B <= A\n ensures U <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_7676","instance":7676,"id":211019,"goal":"lemma SetUnionEmpty_7676(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_7677","instance":7677,"id":211020,"goal":"lemma SetInterEmpty_7677(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_7678","instance":7678,"id":211021,"goal":"lemma SetInterSubset_7678(A: set, U: set)\n ensures A * U <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_7679","instance":7679,"id":211022,"goal":"lemma SetCardSubset_7679(T: set, U: set)\n requires T <= U\n ensures |T| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_7680","instance":7680,"id":211023,"goal":"lemma SetUnionCard_7680(B: set, S: set)\n requires B * S == {}\n ensures |B + S| == |B| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_7681","instance":7681,"id":211024,"goal":"lemma SetUnionComm_7681(T: set, A: set)\n ensures T + A == A + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_7682","instance":7682,"id":211025,"goal":"lemma SetInterComm_7682(S: set, U: set)\n ensures S * U == U * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_7683","instance":7683,"id":211026,"goal":"lemma SetUnionAssoc_7683(S: set, B: set, A: set)\n ensures (S + B) + A == S + (B + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_7684","instance":7684,"id":211027,"goal":"lemma SetSubsetRefl_7684(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_7685","instance":7685,"id":211028,"goal":"lemma SetSubsetTrans_7685(U: set, A: set, B: set)\n requires U <= A && A <= B\n ensures U <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_7686","instance":7686,"id":211029,"goal":"lemma SetUnionEmpty_7686(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_7687","instance":7687,"id":211030,"goal":"lemma SetInterEmpty_7687(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_7688","instance":7688,"id":211031,"goal":"lemma SetInterSubset_7688(B: set, A: set)\n ensures B * A <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_7689","instance":7689,"id":211032,"goal":"lemma SetCardSubset_7689(T: set, A: set)\n requires T <= A\n ensures |T| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_7690","instance":7690,"id":211033,"goal":"lemma SetUnionCard_7690(U: set, B: set)\n requires U * B == {}\n ensures |U + B| == |U| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_7691","instance":7691,"id":211034,"goal":"lemma SetUnionComm_7691(U: set, S: set)\n ensures U + S == S + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_7692","instance":7692,"id":211035,"goal":"lemma SetInterComm_7692(A: set, T: set)\n ensures A * T == T * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_7693","instance":7693,"id":211036,"goal":"lemma SetUnionAssoc_7693(T: set, U: set, B: set)\n ensures (T + U) + B == T + (U + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_7694","instance":7694,"id":211037,"goal":"lemma SetSubsetRefl_7694(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_7695","instance":7695,"id":211038,"goal":"lemma SetSubsetTrans_7695(U: set, A: set, T: set)\n requires U <= A && A <= T\n ensures U <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_7696","instance":7696,"id":211039,"goal":"lemma SetUnionEmpty_7696(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_7697","instance":7697,"id":211040,"goal":"lemma SetInterEmpty_7697(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_7698","instance":7698,"id":211041,"goal":"lemma SetInterSubset_7698(S: set, U: set)\n ensures S * U <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_7699","instance":7699,"id":211042,"goal":"lemma SetCardSubset_7699(T: set, U: set)\n requires T <= U\n ensures |T| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_7700","instance":7700,"id":211043,"goal":"lemma SetUnionCard_7700(S: set, A: set)\n requires S * A == {}\n ensures |S + A| == |S| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_7701","instance":7701,"id":211044,"goal":"lemma SetUnionComm_7701(U: set, A: set)\n ensures U + A == A + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_7702","instance":7702,"id":211045,"goal":"lemma SetInterComm_7702(A: set, T: set)\n ensures A * T == T * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_7703","instance":7703,"id":211046,"goal":"lemma SetUnionAssoc_7703(U: set, T: set, B: set)\n ensures (U + T) + B == U + (T + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_7704","instance":7704,"id":211047,"goal":"lemma SetSubsetRefl_7704(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_7705","instance":7705,"id":211048,"goal":"lemma SetSubsetTrans_7705(B: set, T: set, A: set)\n requires B <= T && T <= A\n ensures B <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_7706","instance":7706,"id":211049,"goal":"lemma SetUnionEmpty_7706(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_7707","instance":7707,"id":211050,"goal":"lemma SetInterEmpty_7707(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_7708","instance":7708,"id":211051,"goal":"lemma SetInterSubset_7708(A: set, S: set)\n ensures A * S <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_7709","instance":7709,"id":211052,"goal":"lemma SetCardSubset_7709(U: set, S: set)\n requires U <= S\n ensures |U| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_7710","instance":7710,"id":211053,"goal":"lemma SetUnionCard_7710(A: set, B: set)\n requires A * B == {}\n ensures |A + B| == |A| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_7711","instance":7711,"id":211054,"goal":"lemma SetUnionComm_7711(B: set, U: set)\n ensures B + U == U + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_7712","instance":7712,"id":211055,"goal":"lemma SetInterComm_7712(T: set, S: set)\n ensures T * S == S * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_7713","instance":7713,"id":211056,"goal":"lemma SetUnionAssoc_7713(S: set, A: set, B: set)\n ensures (S + A) + B == S + (A + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_7714","instance":7714,"id":211057,"goal":"lemma SetSubsetRefl_7714(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_7715","instance":7715,"id":211058,"goal":"lemma SetSubsetTrans_7715(B: set, U: set, S: set)\n requires B <= U && U <= S\n ensures B <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_7716","instance":7716,"id":211059,"goal":"lemma SetUnionEmpty_7716(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_7717","instance":7717,"id":211060,"goal":"lemma SetInterEmpty_7717(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_7718","instance":7718,"id":211061,"goal":"lemma SetInterSubset_7718(B: set, A: set)\n ensures B * A <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_7719","instance":7719,"id":211062,"goal":"lemma SetCardSubset_7719(U: set, B: set)\n requires U <= B\n ensures |U| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_7720","instance":7720,"id":211063,"goal":"lemma SetUnionCard_7720(B: set, U: set)\n requires B * U == {}\n ensures |B + U| == |B| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_7721","instance":7721,"id":211064,"goal":"lemma SetUnionComm_7721(S: set, T: set)\n ensures S + T == T + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_7722","instance":7722,"id":211065,"goal":"lemma SetInterComm_7722(U: set, B: set)\n ensures U * B == B * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_7723","instance":7723,"id":211066,"goal":"lemma SetUnionAssoc_7723(T: set, A: set, B: set)\n ensures (T + A) + B == T + (A + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_7724","instance":7724,"id":211067,"goal":"lemma SetSubsetRefl_7724(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_7725","instance":7725,"id":211068,"goal":"lemma SetSubsetTrans_7725(A: set, B: set, T: set)\n requires A <= B && B <= T\n ensures A <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_7726","instance":7726,"id":211069,"goal":"lemma SetUnionEmpty_7726(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_7727","instance":7727,"id":211070,"goal":"lemma SetInterEmpty_7727(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_7728","instance":7728,"id":211071,"goal":"lemma SetInterSubset_7728(U: set, B: set)\n ensures U * B <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_7729","instance":7729,"id":211072,"goal":"lemma SetCardSubset_7729(A: set, S: set)\n requires A <= S\n ensures |A| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_7730","instance":7730,"id":211073,"goal":"lemma SetUnionCard_7730(S: set, B: set)\n requires S * B == {}\n ensures |S + B| == |S| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_7731","instance":7731,"id":211074,"goal":"lemma SetUnionComm_7731(S: set, T: set)\n ensures S + T == T + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_7732","instance":7732,"id":211075,"goal":"lemma SetInterComm_7732(A: set, T: set)\n ensures A * T == T * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_7733","instance":7733,"id":211076,"goal":"lemma SetUnionAssoc_7733(U: set, A: set, B: set)\n ensures (U + A) + B == U + (A + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_7734","instance":7734,"id":211077,"goal":"lemma SetSubsetRefl_7734(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_7735","instance":7735,"id":211078,"goal":"lemma SetSubsetTrans_7735(B: set, S: set, A: set)\n requires B <= S && S <= A\n ensures B <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_7736","instance":7736,"id":211079,"goal":"lemma SetUnionEmpty_7736(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_7737","instance":7737,"id":211080,"goal":"lemma SetInterEmpty_7737(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_7738","instance":7738,"id":211081,"goal":"lemma SetInterSubset_7738(T: set, S: set)\n ensures T * S <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_7739","instance":7739,"id":211082,"goal":"lemma SetCardSubset_7739(B: set, A: set)\n requires B <= A\n ensures |B| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_7740","instance":7740,"id":211083,"goal":"lemma SetUnionCard_7740(T: set, S: set)\n requires T * S == {}\n ensures |T + S| == |T| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_7741","instance":7741,"id":211084,"goal":"lemma SetUnionComm_7741(B: set, S: set)\n ensures B + S == S + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_7742","instance":7742,"id":211085,"goal":"lemma SetInterComm_7742(U: set, S: set)\n ensures U * S == S * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_7743","instance":7743,"id":211086,"goal":"lemma SetUnionAssoc_7743(B: set, A: set, T: set)\n ensures (B + A) + T == B + (A + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_7744","instance":7744,"id":211087,"goal":"lemma SetSubsetRefl_7744(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_7745","instance":7745,"id":211088,"goal":"lemma SetSubsetTrans_7745(U: set, A: set, S: set)\n requires U <= A && A <= S\n ensures U <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_7746","instance":7746,"id":211089,"goal":"lemma SetUnionEmpty_7746(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_7747","instance":7747,"id":211090,"goal":"lemma SetInterEmpty_7747(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_7748","instance":7748,"id":211091,"goal":"lemma SetInterSubset_7748(U: set, T: set)\n ensures U * T <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_7749","instance":7749,"id":211092,"goal":"lemma SetCardSubset_7749(S: set, U: set)\n requires S <= U\n ensures |S| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_7750","instance":7750,"id":211093,"goal":"lemma SetUnionCard_7750(U: set, A: set)\n requires U * A == {}\n ensures |U + A| == |U| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_7751","instance":7751,"id":211094,"goal":"lemma SetUnionComm_7751(U: set, T: set)\n ensures U + T == T + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_7752","instance":7752,"id":211095,"goal":"lemma SetInterComm_7752(S: set, A: set)\n ensures S * A == A * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_7753","instance":7753,"id":211096,"goal":"lemma SetUnionAssoc_7753(S: set, A: set, U: set)\n ensures (S + A) + U == S + (A + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_7754","instance":7754,"id":211097,"goal":"lemma SetSubsetRefl_7754(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_7755","instance":7755,"id":211098,"goal":"lemma SetSubsetTrans_7755(A: set, S: set, T: set)\n requires A <= S && S <= T\n ensures A <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_7756","instance":7756,"id":211099,"goal":"lemma SetUnionEmpty_7756(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_7757","instance":7757,"id":211100,"goal":"lemma SetInterEmpty_7757(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_7758","instance":7758,"id":211101,"goal":"lemma SetInterSubset_7758(B: set, A: set)\n ensures B * A <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_7759","instance":7759,"id":211102,"goal":"lemma SetCardSubset_7759(B: set, S: set)\n requires B <= S\n ensures |B| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_7760","instance":7760,"id":211103,"goal":"lemma SetUnionCard_7760(T: set, B: set)\n requires T * B == {}\n ensures |T + B| == |T| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_7761","instance":7761,"id":211104,"goal":"lemma SetUnionComm_7761(A: set, S: set)\n ensures A + S == S + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_7762","instance":7762,"id":211105,"goal":"lemma SetInterComm_7762(B: set, A: set)\n ensures B * A == A * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_7763","instance":7763,"id":211106,"goal":"lemma SetUnionAssoc_7763(S: set, A: set, T: set)\n ensures (S + A) + T == S + (A + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_7764","instance":7764,"id":211107,"goal":"lemma SetSubsetRefl_7764(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_7765","instance":7765,"id":211108,"goal":"lemma SetSubsetTrans_7765(S: set, A: set, T: set)\n requires S <= A && A <= T\n ensures S <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_7766","instance":7766,"id":211109,"goal":"lemma SetUnionEmpty_7766(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_7767","instance":7767,"id":211110,"goal":"lemma SetInterEmpty_7767(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_7768","instance":7768,"id":211111,"goal":"lemma SetInterSubset_7768(S: set, B: set)\n ensures S * B <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_7769","instance":7769,"id":211112,"goal":"lemma SetCardSubset_7769(B: set, S: set)\n requires B <= S\n ensures |B| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_7770","instance":7770,"id":211113,"goal":"lemma SetUnionCard_7770(A: set, U: set)\n requires A * U == {}\n ensures |A + U| == |A| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_7771","instance":7771,"id":211114,"goal":"lemma SetUnionComm_7771(A: set, B: set)\n ensures A + B == B + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_7772","instance":7772,"id":211115,"goal":"lemma SetInterComm_7772(S: set, A: set)\n ensures S * A == A * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_7773","instance":7773,"id":211116,"goal":"lemma SetUnionAssoc_7773(S: set, B: set, U: set)\n ensures (S + B) + U == S + (B + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_7774","instance":7774,"id":211117,"goal":"lemma SetSubsetRefl_7774(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_7775","instance":7775,"id":211118,"goal":"lemma SetSubsetTrans_7775(S: set, B: set, A: set)\n requires S <= B && B <= A\n ensures S <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_7776","instance":7776,"id":211119,"goal":"lemma SetUnionEmpty_7776(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_7777","instance":7777,"id":211120,"goal":"lemma SetInterEmpty_7777(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_7778","instance":7778,"id":211121,"goal":"lemma SetInterSubset_7778(B: set, T: set)\n ensures B * T <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_7779","instance":7779,"id":211122,"goal":"lemma SetCardSubset_7779(T: set, A: set)\n requires T <= A\n ensures |T| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_7780","instance":7780,"id":211123,"goal":"lemma SetUnionCard_7780(S: set, U: set)\n requires S * U == {}\n ensures |S + U| == |S| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_7781","instance":7781,"id":211124,"goal":"lemma SetUnionComm_7781(A: set, B: set)\n ensures A + B == B + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_7782","instance":7782,"id":211125,"goal":"lemma SetInterComm_7782(A: set, B: set)\n ensures A * B == B * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_7783","instance":7783,"id":211126,"goal":"lemma SetUnionAssoc_7783(U: set, T: set, S: set)\n ensures (U + T) + S == U + (T + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_7784","instance":7784,"id":211127,"goal":"lemma SetSubsetRefl_7784(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_7785","instance":7785,"id":211128,"goal":"lemma SetSubsetTrans_7785(U: set, B: set, A: set)\n requires U <= B && B <= A\n ensures U <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_7786","instance":7786,"id":211129,"goal":"lemma SetUnionEmpty_7786(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_7787","instance":7787,"id":211130,"goal":"lemma SetInterEmpty_7787(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_7788","instance":7788,"id":211131,"goal":"lemma SetInterSubset_7788(B: set, U: set)\n ensures B * U <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_7789","instance":7789,"id":211132,"goal":"lemma SetCardSubset_7789(T: set, A: set)\n requires T <= A\n ensures |T| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_7790","instance":7790,"id":211133,"goal":"lemma SetUnionCard_7790(U: set, B: set)\n requires U * B == {}\n ensures |U + B| == |U| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_7791","instance":7791,"id":211134,"goal":"lemma SetUnionComm_7791(T: set, U: set)\n ensures T + U == U + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_7792","instance":7792,"id":211135,"goal":"lemma SetInterComm_7792(B: set, T: set)\n ensures B * T == T * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_7793","instance":7793,"id":211136,"goal":"lemma SetUnionAssoc_7793(S: set, A: set, T: set)\n ensures (S + A) + T == S + (A + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_7794","instance":7794,"id":211137,"goal":"lemma SetSubsetRefl_7794(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_7795","instance":7795,"id":211138,"goal":"lemma SetSubsetTrans_7795(T: set, A: set, B: set)\n requires T <= A && A <= B\n ensures T <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_7796","instance":7796,"id":211139,"goal":"lemma SetUnionEmpty_7796(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_7797","instance":7797,"id":211140,"goal":"lemma SetInterEmpty_7797(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_7798","instance":7798,"id":211141,"goal":"lemma SetInterSubset_7798(A: set, U: set)\n ensures A * U <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_7799","instance":7799,"id":211142,"goal":"lemma SetCardSubset_7799(U: set, S: set)\n requires U <= S\n ensures |U| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_7800","instance":7800,"id":211143,"goal":"lemma SetUnionCard_7800(B: set, U: set)\n requires B * U == {}\n ensures |B + U| == |B| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_7801","instance":7801,"id":211144,"goal":"lemma SetUnionComm_7801(T: set, U: set)\n ensures T + U == U + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_7802","instance":7802,"id":211145,"goal":"lemma SetInterComm_7802(A: set, B: set)\n ensures A * B == B * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_7803","instance":7803,"id":211146,"goal":"lemma SetUnionAssoc_7803(T: set, U: set, S: set)\n ensures (T + U) + S == T + (U + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_7804","instance":7804,"id":211147,"goal":"lemma SetSubsetRefl_7804(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_7805","instance":7805,"id":211148,"goal":"lemma SetSubsetTrans_7805(A: set, T: set, S: set)\n requires A <= T && T <= S\n ensures A <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_7806","instance":7806,"id":211149,"goal":"lemma SetUnionEmpty_7806(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_7807","instance":7807,"id":211150,"goal":"lemma SetInterEmpty_7807(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_7808","instance":7808,"id":211151,"goal":"lemma SetInterSubset_7808(S: set, U: set)\n ensures S * U <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_7809","instance":7809,"id":211152,"goal":"lemma SetCardSubset_7809(B: set, S: set)\n requires B <= S\n ensures |B| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_7810","instance":7810,"id":211153,"goal":"lemma SetUnionCard_7810(U: set, S: set)\n requires U * S == {}\n ensures |U + S| == |U| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_7811","instance":7811,"id":211154,"goal":"lemma SetUnionComm_7811(T: set, S: set)\n ensures T + S == S + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_7812","instance":7812,"id":211155,"goal":"lemma SetInterComm_7812(A: set, S: set)\n ensures A * S == S * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_7813","instance":7813,"id":211156,"goal":"lemma SetUnionAssoc_7813(A: set, B: set, U: set)\n ensures (A + B) + U == A + (B + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_7814","instance":7814,"id":211157,"goal":"lemma SetSubsetRefl_7814(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_7815","instance":7815,"id":211158,"goal":"lemma SetSubsetTrans_7815(B: set, U: set, T: set)\n requires B <= U && U <= T\n ensures B <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_7816","instance":7816,"id":211159,"goal":"lemma SetUnionEmpty_7816(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_7817","instance":7817,"id":211160,"goal":"lemma SetInterEmpty_7817(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_7818","instance":7818,"id":211161,"goal":"lemma SetInterSubset_7818(B: set, A: set)\n ensures B * A <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_7819","instance":7819,"id":211162,"goal":"lemma SetCardSubset_7819(A: set, T: set)\n requires A <= T\n ensures |A| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_7820","instance":7820,"id":211163,"goal":"lemma SetUnionCard_7820(A: set, S: set)\n requires A * S == {}\n ensures |A + S| == |A| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_7821","instance":7821,"id":211164,"goal":"lemma SetUnionComm_7821(U: set, S: set)\n ensures U + S == S + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_7822","instance":7822,"id":211165,"goal":"lemma SetInterComm_7822(A: set, U: set)\n ensures A * U == U * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_7823","instance":7823,"id":211166,"goal":"lemma SetUnionAssoc_7823(S: set, T: set, U: set)\n ensures (S + T) + U == S + (T + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_7824","instance":7824,"id":211167,"goal":"lemma SetSubsetRefl_7824(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_7825","instance":7825,"id":211168,"goal":"lemma SetSubsetTrans_7825(U: set, B: set, A: set)\n requires U <= B && B <= A\n ensures U <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_7826","instance":7826,"id":211169,"goal":"lemma SetUnionEmpty_7826(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_7827","instance":7827,"id":211170,"goal":"lemma SetInterEmpty_7827(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_7828","instance":7828,"id":211171,"goal":"lemma SetInterSubset_7828(B: set, U: set)\n ensures B * U <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_7829","instance":7829,"id":211172,"goal":"lemma SetCardSubset_7829(T: set, U: set)\n requires T <= U\n ensures |T| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_7830","instance":7830,"id":211173,"goal":"lemma SetUnionCard_7830(U: set, T: set)\n requires U * T == {}\n ensures |U + T| == |U| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_7831","instance":7831,"id":211174,"goal":"lemma SetUnionComm_7831(A: set, B: set)\n ensures A + B == B + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_7832","instance":7832,"id":211175,"goal":"lemma SetInterComm_7832(B: set, U: set)\n ensures B * U == U * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_7833","instance":7833,"id":211176,"goal":"lemma SetUnionAssoc_7833(A: set, U: set, S: set)\n ensures (A + U) + S == A + (U + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_7834","instance":7834,"id":211177,"goal":"lemma SetSubsetRefl_7834(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_7835","instance":7835,"id":211178,"goal":"lemma SetSubsetTrans_7835(S: set, U: set, T: set)\n requires S <= U && U <= T\n ensures S <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_7836","instance":7836,"id":211179,"goal":"lemma SetUnionEmpty_7836(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_7837","instance":7837,"id":211180,"goal":"lemma SetInterEmpty_7837(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_7838","instance":7838,"id":211181,"goal":"lemma SetInterSubset_7838(A: set, S: set)\n ensures A * S <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_7839","instance":7839,"id":211182,"goal":"lemma SetCardSubset_7839(A: set, T: set)\n requires A <= T\n ensures |A| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_7840","instance":7840,"id":211183,"goal":"lemma SetUnionCard_7840(S: set, U: set)\n requires S * U == {}\n ensures |S + U| == |S| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_7841","instance":7841,"id":211184,"goal":"lemma SetUnionComm_7841(T: set, S: set)\n ensures T + S == S + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_7842","instance":7842,"id":211185,"goal":"lemma SetInterComm_7842(T: set, B: set)\n ensures T * B == B * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_7843","instance":7843,"id":211186,"goal":"lemma SetUnionAssoc_7843(U: set, T: set, B: set)\n ensures (U + T) + B == U + (T + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_7844","instance":7844,"id":211187,"goal":"lemma SetSubsetRefl_7844(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_7845","instance":7845,"id":211188,"goal":"lemma SetSubsetTrans_7845(T: set, B: set, S: set)\n requires T <= B && B <= S\n ensures T <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_7846","instance":7846,"id":211189,"goal":"lemma SetUnionEmpty_7846(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_7847","instance":7847,"id":211190,"goal":"lemma SetInterEmpty_7847(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_7848","instance":7848,"id":211191,"goal":"lemma SetInterSubset_7848(U: set, T: set)\n ensures U * T <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_7849","instance":7849,"id":211192,"goal":"lemma SetCardSubset_7849(B: set, S: set)\n requires B <= S\n ensures |B| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_7850","instance":7850,"id":211193,"goal":"lemma SetUnionCard_7850(U: set, A: set)\n requires U * A == {}\n ensures |U + A| == |U| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_7851","instance":7851,"id":211194,"goal":"lemma SetUnionComm_7851(T: set, B: set)\n ensures T + B == B + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_7852","instance":7852,"id":211195,"goal":"lemma SetInterComm_7852(U: set, S: set)\n ensures U * S == S * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_7853","instance":7853,"id":211196,"goal":"lemma SetUnionAssoc_7853(U: set, A: set, S: set)\n ensures (U + A) + S == U + (A + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_7854","instance":7854,"id":211197,"goal":"lemma SetSubsetRefl_7854(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_7855","instance":7855,"id":211198,"goal":"lemma SetSubsetTrans_7855(S: set, B: set, T: set)\n requires S <= B && B <= T\n ensures S <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_7856","instance":7856,"id":211199,"goal":"lemma SetUnionEmpty_7856(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_7857","instance":7857,"id":211200,"goal":"lemma SetInterEmpty_7857(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_7858","instance":7858,"id":211201,"goal":"lemma SetInterSubset_7858(A: set, S: set)\n ensures A * S <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_7859","instance":7859,"id":211202,"goal":"lemma SetCardSubset_7859(A: set, S: set)\n requires A <= S\n ensures |A| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_7860","instance":7860,"id":211203,"goal":"lemma SetUnionCard_7860(T: set, B: set)\n requires T * B == {}\n ensures |T + B| == |T| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_7861","instance":7861,"id":211204,"goal":"lemma SetUnionComm_7861(A: set, U: set)\n ensures A + U == U + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_7862","instance":7862,"id":211205,"goal":"lemma SetInterComm_7862(A: set, T: set)\n ensures A * T == T * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_7863","instance":7863,"id":211206,"goal":"lemma SetUnionAssoc_7863(S: set, A: set, U: set)\n ensures (S + A) + U == S + (A + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_7864","instance":7864,"id":211207,"goal":"lemma SetSubsetRefl_7864(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_7865","instance":7865,"id":211208,"goal":"lemma SetSubsetTrans_7865(A: set, T: set, U: set)\n requires A <= T && T <= U\n ensures A <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_7866","instance":7866,"id":211209,"goal":"lemma SetUnionEmpty_7866(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_7867","instance":7867,"id":211210,"goal":"lemma SetInterEmpty_7867(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_7868","instance":7868,"id":211211,"goal":"lemma SetInterSubset_7868(S: set, T: set)\n ensures S * T <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_7869","instance":7869,"id":211212,"goal":"lemma SetCardSubset_7869(S: set, A: set)\n requires S <= A\n ensures |S| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_7870","instance":7870,"id":211213,"goal":"lemma SetUnionCard_7870(S: set, T: set)\n requires S * T == {}\n ensures |S + T| == |S| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_7871","instance":7871,"id":211214,"goal":"lemma SetUnionComm_7871(B: set, T: set)\n ensures B + T == T + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_7872","instance":7872,"id":211215,"goal":"lemma SetInterComm_7872(B: set, U: set)\n ensures B * U == U * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_7873","instance":7873,"id":211216,"goal":"lemma SetUnionAssoc_7873(A: set, T: set, B: set)\n ensures (A + T) + B == A + (T + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_7874","instance":7874,"id":211217,"goal":"lemma SetSubsetRefl_7874(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_7875","instance":7875,"id":211218,"goal":"lemma SetSubsetTrans_7875(U: set, B: set, S: set)\n requires U <= B && B <= S\n ensures U <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_7876","instance":7876,"id":211219,"goal":"lemma SetUnionEmpty_7876(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_7877","instance":7877,"id":211220,"goal":"lemma SetInterEmpty_7877(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_7878","instance":7878,"id":211221,"goal":"lemma SetInterSubset_7878(U: set, A: set)\n ensures U * A <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_7879","instance":7879,"id":211222,"goal":"lemma SetCardSubset_7879(U: set, B: set)\n requires U <= B\n ensures |U| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_7880","instance":7880,"id":211223,"goal":"lemma SetUnionCard_7880(A: set, S: set)\n requires A * S == {}\n ensures |A + S| == |A| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_7881","instance":7881,"id":211224,"goal":"lemma SetUnionComm_7881(S: set, A: set)\n ensures S + A == A + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_7882","instance":7882,"id":211225,"goal":"lemma SetInterComm_7882(T: set, A: set)\n ensures T * A == A * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_7883","instance":7883,"id":211226,"goal":"lemma SetUnionAssoc_7883(T: set, A: set, B: set)\n ensures (T + A) + B == T + (A + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_7884","instance":7884,"id":211227,"goal":"lemma SetSubsetRefl_7884(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_7885","instance":7885,"id":211228,"goal":"lemma SetSubsetTrans_7885(U: set, B: set, T: set)\n requires U <= B && B <= T\n ensures U <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_7886","instance":7886,"id":211229,"goal":"lemma SetUnionEmpty_7886(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_7887","instance":7887,"id":211230,"goal":"lemma SetInterEmpty_7887(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_7888","instance":7888,"id":211231,"goal":"lemma SetInterSubset_7888(S: set, A: set)\n ensures S * A <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_7889","instance":7889,"id":211232,"goal":"lemma SetCardSubset_7889(B: set, S: set)\n requires B <= S\n ensures |B| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_7890","instance":7890,"id":211233,"goal":"lemma SetUnionCard_7890(A: set, B: set)\n requires A * B == {}\n ensures |A + B| == |A| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_7891","instance":7891,"id":211234,"goal":"lemma SetUnionComm_7891(U: set, B: set)\n ensures U + B == B + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_7892","instance":7892,"id":211235,"goal":"lemma SetInterComm_7892(U: set, A: set)\n ensures U * A == A * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_7893","instance":7893,"id":211236,"goal":"lemma SetUnionAssoc_7893(S: set, B: set, T: set)\n ensures (S + B) + T == S + (B + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_7894","instance":7894,"id":211237,"goal":"lemma SetSubsetRefl_7894(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_7895","instance":7895,"id":211238,"goal":"lemma SetSubsetTrans_7895(U: set, S: set, A: set)\n requires U <= S && S <= A\n ensures U <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_7896","instance":7896,"id":211239,"goal":"lemma SetUnionEmpty_7896(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_7897","instance":7897,"id":211240,"goal":"lemma SetInterEmpty_7897(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_7898","instance":7898,"id":211241,"goal":"lemma SetInterSubset_7898(S: set, T: set)\n ensures S * T <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_7899","instance":7899,"id":211242,"goal":"lemma SetCardSubset_7899(U: set, A: set)\n requires U <= A\n ensures |U| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_7900","instance":7900,"id":211243,"goal":"lemma SetUnionCard_7900(T: set, U: set)\n requires T * U == {}\n ensures |T + U| == |T| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_7901","instance":7901,"id":211244,"goal":"lemma SetUnionComm_7901(A: set, U: set)\n ensures A + U == U + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_7902","instance":7902,"id":211245,"goal":"lemma SetInterComm_7902(U: set, B: set)\n ensures U * B == B * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_7903","instance":7903,"id":211246,"goal":"lemma SetUnionAssoc_7903(A: set, B: set, T: set)\n ensures (A + B) + T == A + (B + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_7904","instance":7904,"id":211247,"goal":"lemma SetSubsetRefl_7904(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_7905","instance":7905,"id":211248,"goal":"lemma SetSubsetTrans_7905(S: set, A: set, B: set)\n requires S <= A && A <= B\n ensures S <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_7906","instance":7906,"id":211249,"goal":"lemma SetUnionEmpty_7906(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_7907","instance":7907,"id":211250,"goal":"lemma SetInterEmpty_7907(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_7908","instance":7908,"id":211251,"goal":"lemma SetInterSubset_7908(B: set, U: set)\n ensures B * U <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_7909","instance":7909,"id":211252,"goal":"lemma SetCardSubset_7909(S: set, B: set)\n requires S <= B\n ensures |S| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_7910","instance":7910,"id":211253,"goal":"lemma SetUnionCard_7910(T: set, U: set)\n requires T * U == {}\n ensures |T + U| == |T| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_7911","instance":7911,"id":211254,"goal":"lemma SetUnionComm_7911(U: set, T: set)\n ensures U + T == T + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_7912","instance":7912,"id":211255,"goal":"lemma SetInterComm_7912(A: set, S: set)\n ensures A * S == S * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_7913","instance":7913,"id":211256,"goal":"lemma SetUnionAssoc_7913(U: set, B: set, A: set)\n ensures (U + B) + A == U + (B + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_7914","instance":7914,"id":211257,"goal":"lemma SetSubsetRefl_7914(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_7915","instance":7915,"id":211258,"goal":"lemma SetSubsetTrans_7915(A: set, U: set, S: set)\n requires A <= U && U <= S\n ensures A <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_7916","instance":7916,"id":211259,"goal":"lemma SetUnionEmpty_7916(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_7917","instance":7917,"id":211260,"goal":"lemma SetInterEmpty_7917(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_7918","instance":7918,"id":211261,"goal":"lemma SetInterSubset_7918(B: set, S: set)\n ensures B * S <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_7919","instance":7919,"id":211262,"goal":"lemma SetCardSubset_7919(U: set, A: set)\n requires U <= A\n ensures |U| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_7920","instance":7920,"id":211263,"goal":"lemma SetUnionCard_7920(B: set, S: set)\n requires B * S == {}\n ensures |B + S| == |B| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_7921","instance":7921,"id":211264,"goal":"lemma SetUnionComm_7921(A: set, T: set)\n ensures A + T == T + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_7922","instance":7922,"id":211265,"goal":"lemma SetInterComm_7922(S: set, A: set)\n ensures S * A == A * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_7923","instance":7923,"id":211266,"goal":"lemma SetUnionAssoc_7923(B: set, S: set, A: set)\n ensures (B + S) + A == B + (S + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_7924","instance":7924,"id":211267,"goal":"lemma SetSubsetRefl_7924(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_7925","instance":7925,"id":211268,"goal":"lemma SetSubsetTrans_7925(B: set, A: set, T: set)\n requires B <= A && A <= T\n ensures B <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_7926","instance":7926,"id":211269,"goal":"lemma SetUnionEmpty_7926(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_7927","instance":7927,"id":211270,"goal":"lemma SetInterEmpty_7927(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_7928","instance":7928,"id":211271,"goal":"lemma SetInterSubset_7928(T: set, B: set)\n ensures T * B <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_7929","instance":7929,"id":211272,"goal":"lemma SetCardSubset_7929(T: set, U: set)\n requires T <= U\n ensures |T| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_7930","instance":7930,"id":211273,"goal":"lemma SetUnionCard_7930(S: set, T: set)\n requires S * T == {}\n ensures |S + T| == |S| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_7931","instance":7931,"id":211274,"goal":"lemma SetUnionComm_7931(U: set, A: set)\n ensures U + A == A + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_7932","instance":7932,"id":211275,"goal":"lemma SetInterComm_7932(T: set, A: set)\n ensures T * A == A * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_7933","instance":7933,"id":211276,"goal":"lemma SetUnionAssoc_7933(T: set, A: set, B: set)\n ensures (T + A) + B == T + (A + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_7934","instance":7934,"id":211277,"goal":"lemma SetSubsetRefl_7934(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_7935","instance":7935,"id":211278,"goal":"lemma SetSubsetTrans_7935(B: set, T: set, U: set)\n requires B <= T && T <= U\n ensures B <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_7936","instance":7936,"id":211279,"goal":"lemma SetUnionEmpty_7936(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_7937","instance":7937,"id":211280,"goal":"lemma SetInterEmpty_7937(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_7938","instance":7938,"id":211281,"goal":"lemma SetInterSubset_7938(A: set, B: set)\n ensures A * B <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_7939","instance":7939,"id":211282,"goal":"lemma SetCardSubset_7939(S: set, B: set)\n requires S <= B\n ensures |S| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_7940","instance":7940,"id":211283,"goal":"lemma SetUnionCard_7940(S: set, B: set)\n requires S * B == {}\n ensures |S + B| == |S| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_7941","instance":7941,"id":211284,"goal":"lemma SetUnionComm_7941(A: set, B: set)\n ensures A + B == B + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_7942","instance":7942,"id":211285,"goal":"lemma SetInterComm_7942(U: set, T: set)\n ensures U * T == T * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_7943","instance":7943,"id":211286,"goal":"lemma SetUnionAssoc_7943(U: set, A: set, T: set)\n ensures (U + A) + T == U + (A + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_7944","instance":7944,"id":211287,"goal":"lemma SetSubsetRefl_7944(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_7945","instance":7945,"id":211288,"goal":"lemma SetSubsetTrans_7945(S: set, B: set, T: set)\n requires S <= B && B <= T\n ensures S <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_7946","instance":7946,"id":211289,"goal":"lemma SetUnionEmpty_7946(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_7947","instance":7947,"id":211290,"goal":"lemma SetInterEmpty_7947(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_7948","instance":7948,"id":211291,"goal":"lemma SetInterSubset_7948(S: set, U: set)\n ensures S * U <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_7949","instance":7949,"id":211292,"goal":"lemma SetCardSubset_7949(A: set, B: set)\n requires A <= B\n ensures |A| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_7950","instance":7950,"id":211293,"goal":"lemma SetUnionCard_7950(U: set, S: set)\n requires U * S == {}\n ensures |U + S| == |U| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_7951","instance":7951,"id":211294,"goal":"lemma SetUnionComm_7951(U: set, T: set)\n ensures U + T == T + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_7952","instance":7952,"id":211295,"goal":"lemma SetInterComm_7952(T: set, U: set)\n ensures T * U == U * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_7953","instance":7953,"id":211296,"goal":"lemma SetUnionAssoc_7953(A: set, U: set, S: set)\n ensures (A + U) + S == A + (U + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_7954","instance":7954,"id":211297,"goal":"lemma SetSubsetRefl_7954(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_7955","instance":7955,"id":211298,"goal":"lemma SetSubsetTrans_7955(T: set, A: set, U: set)\n requires T <= A && A <= U\n ensures T <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_7956","instance":7956,"id":211299,"goal":"lemma SetUnionEmpty_7956(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_7957","instance":7957,"id":211300,"goal":"lemma SetInterEmpty_7957(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_7958","instance":7958,"id":211301,"goal":"lemma SetInterSubset_7958(U: set, A: set)\n ensures U * A <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_7959","instance":7959,"id":211302,"goal":"lemma SetCardSubset_7959(B: set, S: set)\n requires B <= S\n ensures |B| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_7960","instance":7960,"id":211303,"goal":"lemma SetUnionCard_7960(T: set, B: set)\n requires T * B == {}\n ensures |T + B| == |T| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_7961","instance":7961,"id":211304,"goal":"lemma SetUnionComm_7961(B: set, A: set)\n ensures B + A == A + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_7962","instance":7962,"id":211305,"goal":"lemma SetInterComm_7962(U: set, B: set)\n ensures U * B == B * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_7963","instance":7963,"id":211306,"goal":"lemma SetUnionAssoc_7963(S: set, U: set, B: set)\n ensures (S + U) + B == S + (U + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_7964","instance":7964,"id":211307,"goal":"lemma SetSubsetRefl_7964(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_7965","instance":7965,"id":211308,"goal":"lemma SetSubsetTrans_7965(T: set, A: set, S: set)\n requires T <= A && A <= S\n ensures T <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_7966","instance":7966,"id":211309,"goal":"lemma SetUnionEmpty_7966(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_7967","instance":7967,"id":211310,"goal":"lemma SetInterEmpty_7967(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_7968","instance":7968,"id":211311,"goal":"lemma SetInterSubset_7968(U: set, S: set)\n ensures U * S <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_7969","instance":7969,"id":211312,"goal":"lemma SetCardSubset_7969(S: set, B: set)\n requires S <= B\n ensures |S| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_7970","instance":7970,"id":211313,"goal":"lemma SetUnionCard_7970(T: set, A: set)\n requires T * A == {}\n ensures |T + A| == |T| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_7971","instance":7971,"id":211314,"goal":"lemma SetUnionComm_7971(T: set, B: set)\n ensures T + B == B + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_7972","instance":7972,"id":211315,"goal":"lemma SetInterComm_7972(A: set, S: set)\n ensures A * S == S * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_7973","instance":7973,"id":211316,"goal":"lemma SetUnionAssoc_7973(S: set, T: set, B: set)\n ensures (S + T) + B == S + (T + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_7974","instance":7974,"id":211317,"goal":"lemma SetSubsetRefl_7974(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_7975","instance":7975,"id":211318,"goal":"lemma SetSubsetTrans_7975(S: set, B: set, T: set)\n requires S <= B && B <= T\n ensures S <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_7976","instance":7976,"id":211319,"goal":"lemma SetUnionEmpty_7976(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_7977","instance":7977,"id":211320,"goal":"lemma SetInterEmpty_7977(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_7978","instance":7978,"id":211321,"goal":"lemma SetInterSubset_7978(T: set, U: set)\n ensures T * U <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_7979","instance":7979,"id":211322,"goal":"lemma SetCardSubset_7979(U: set, B: set)\n requires U <= B\n ensures |U| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_7980","instance":7980,"id":211323,"goal":"lemma SetUnionCard_7980(B: set, S: set)\n requires B * S == {}\n ensures |B + S| == |B| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_7981","instance":7981,"id":211324,"goal":"lemma SetUnionComm_7981(S: set, A: set)\n ensures S + A == A + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_7982","instance":7982,"id":211325,"goal":"lemma SetInterComm_7982(A: set, S: set)\n ensures A * S == S * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_7983","instance":7983,"id":211326,"goal":"lemma SetUnionAssoc_7983(S: set, A: set, B: set)\n ensures (S + A) + B == S + (A + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_7984","instance":7984,"id":211327,"goal":"lemma SetSubsetRefl_7984(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_7985","instance":7985,"id":211328,"goal":"lemma SetSubsetTrans_7985(T: set, S: set, U: set)\n requires T <= S && S <= U\n ensures T <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_7986","instance":7986,"id":211329,"goal":"lemma SetUnionEmpty_7986(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_7987","instance":7987,"id":211330,"goal":"lemma SetInterEmpty_7987(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_7988","instance":7988,"id":211331,"goal":"lemma SetInterSubset_7988(A: set, S: set)\n ensures A * S <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_7989","instance":7989,"id":211332,"goal":"lemma SetCardSubset_7989(U: set, B: set)\n requires U <= B\n ensures |U| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_7990","instance":7990,"id":211333,"goal":"lemma SetUnionCard_7990(T: set, B: set)\n requires T * B == {}\n ensures |T + B| == |T| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_7991","instance":7991,"id":211334,"goal":"lemma SetUnionComm_7991(U: set, A: set)\n ensures U + A == A + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_7992","instance":7992,"id":211335,"goal":"lemma SetInterComm_7992(S: set, U: set)\n ensures S * U == U * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_7993","instance":7993,"id":211336,"goal":"lemma SetUnionAssoc_7993(B: set, T: set, U: set)\n ensures (B + T) + U == B + (T + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_7994","instance":7994,"id":211337,"goal":"lemma SetSubsetRefl_7994(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_7995","instance":7995,"id":211338,"goal":"lemma SetSubsetTrans_7995(A: set, B: set, S: set)\n requires A <= B && B <= S\n ensures A <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_7996","instance":7996,"id":211339,"goal":"lemma SetUnionEmpty_7996(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_7997","instance":7997,"id":211340,"goal":"lemma SetInterEmpty_7997(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_7998","instance":7998,"id":211341,"goal":"lemma SetInterSubset_7998(B: set, T: set)\n ensures B * T <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_7999","instance":7999,"id":211342,"goal":"lemma SetCardSubset_7999(S: set, B: set)\n requires S <= B\n ensures |S| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_8000","instance":8000,"id":211343,"goal":"lemma SetUnionCard_8000(U: set, B: set)\n requires U * B == {}\n ensures |U + B| == |U| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_8001","instance":8001,"id":211344,"goal":"lemma SetUnionComm_8001(S: set, U: set)\n ensures S + U == U + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_8002","instance":8002,"id":211345,"goal":"lemma SetInterComm_8002(U: set, T: set)\n ensures U * T == T * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_8003","instance":8003,"id":211346,"goal":"lemma SetUnionAssoc_8003(S: set, U: set, T: set)\n ensures (S + U) + T == S + (U + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_8004","instance":8004,"id":211347,"goal":"lemma SetSubsetRefl_8004(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_8005","instance":8005,"id":211348,"goal":"lemma SetSubsetTrans_8005(T: set, S: set, B: set)\n requires T <= S && S <= B\n ensures T <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_8006","instance":8006,"id":211349,"goal":"lemma SetUnionEmpty_8006(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_8007","instance":8007,"id":211350,"goal":"lemma SetInterEmpty_8007(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_8008","instance":8008,"id":211351,"goal":"lemma SetInterSubset_8008(S: set, B: set)\n ensures S * B <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_8009","instance":8009,"id":211352,"goal":"lemma SetCardSubset_8009(S: set, B: set)\n requires S <= B\n ensures |S| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_8010","instance":8010,"id":211353,"goal":"lemma SetUnionCard_8010(A: set, T: set)\n requires A * T == {}\n ensures |A + T| == |A| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_8011","instance":8011,"id":211354,"goal":"lemma SetUnionComm_8011(A: set, S: set)\n ensures A + S == S + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_8012","instance":8012,"id":211355,"goal":"lemma SetInterComm_8012(S: set, T: set)\n ensures S * T == T * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_8013","instance":8013,"id":211356,"goal":"lemma SetUnionAssoc_8013(A: set, U: set, B: set)\n ensures (A + U) + B == A + (U + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_8014","instance":8014,"id":211357,"goal":"lemma SetSubsetRefl_8014(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_8015","instance":8015,"id":211358,"goal":"lemma SetSubsetTrans_8015(T: set, U: set, A: set)\n requires T <= U && U <= A\n ensures T <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_8016","instance":8016,"id":211359,"goal":"lemma SetUnionEmpty_8016(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_8017","instance":8017,"id":211360,"goal":"lemma SetInterEmpty_8017(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_8018","instance":8018,"id":211361,"goal":"lemma SetInterSubset_8018(S: set, U: set)\n ensures S * U <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_8019","instance":8019,"id":211362,"goal":"lemma SetCardSubset_8019(T: set, U: set)\n requires T <= U\n ensures |T| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_8020","instance":8020,"id":211363,"goal":"lemma SetUnionCard_8020(S: set, A: set)\n requires S * A == {}\n ensures |S + A| == |S| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_8021","instance":8021,"id":211364,"goal":"lemma SetUnionComm_8021(S: set, U: set)\n ensures S + U == U + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_8022","instance":8022,"id":211365,"goal":"lemma SetInterComm_8022(S: set, B: set)\n ensures S * B == B * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_8023","instance":8023,"id":211366,"goal":"lemma SetUnionAssoc_8023(A: set, T: set, B: set)\n ensures (A + T) + B == A + (T + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_8024","instance":8024,"id":211367,"goal":"lemma SetSubsetRefl_8024(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_8025","instance":8025,"id":211368,"goal":"lemma SetSubsetTrans_8025(T: set, B: set, U: set)\n requires T <= B && B <= U\n ensures T <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_8026","instance":8026,"id":211369,"goal":"lemma SetUnionEmpty_8026(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_8027","instance":8027,"id":211370,"goal":"lemma SetInterEmpty_8027(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_8028","instance":8028,"id":211371,"goal":"lemma SetInterSubset_8028(B: set, A: set)\n ensures B * A <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_8029","instance":8029,"id":211372,"goal":"lemma SetCardSubset_8029(U: set, T: set)\n requires U <= T\n ensures |U| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_8030","instance":8030,"id":211373,"goal":"lemma SetUnionCard_8030(B: set, T: set)\n requires B * T == {}\n ensures |B + T| == |B| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_8031","instance":8031,"id":211374,"goal":"lemma SetUnionComm_8031(S: set, B: set)\n ensures S + B == B + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_8032","instance":8032,"id":211375,"goal":"lemma SetInterComm_8032(S: set, U: set)\n ensures S * U == U * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_8033","instance":8033,"id":211376,"goal":"lemma SetUnionAssoc_8033(S: set, U: set, B: set)\n ensures (S + U) + B == S + (U + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_8034","instance":8034,"id":211377,"goal":"lemma SetSubsetRefl_8034(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_8035","instance":8035,"id":211378,"goal":"lemma SetSubsetTrans_8035(S: set, A: set, T: set)\n requires S <= A && A <= T\n ensures S <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_8036","instance":8036,"id":211379,"goal":"lemma SetUnionEmpty_8036(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_8037","instance":8037,"id":211380,"goal":"lemma SetInterEmpty_8037(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_8038","instance":8038,"id":211381,"goal":"lemma SetInterSubset_8038(S: set, T: set)\n ensures S * T <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_8039","instance":8039,"id":211382,"goal":"lemma SetCardSubset_8039(T: set, A: set)\n requires T <= A\n ensures |T| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_8040","instance":8040,"id":211383,"goal":"lemma SetUnionCard_8040(T: set, B: set)\n requires T * B == {}\n ensures |T + B| == |T| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_8041","instance":8041,"id":211384,"goal":"lemma SetUnionComm_8041(U: set, B: set)\n ensures U + B == B + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_8042","instance":8042,"id":211385,"goal":"lemma SetInterComm_8042(U: set, A: set)\n ensures U * A == A * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_8043","instance":8043,"id":211386,"goal":"lemma SetUnionAssoc_8043(A: set, T: set, S: set)\n ensures (A + T) + S == A + (T + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_8044","instance":8044,"id":211387,"goal":"lemma SetSubsetRefl_8044(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_8045","instance":8045,"id":211388,"goal":"lemma SetSubsetTrans_8045(T: set, A: set, S: set)\n requires T <= A && A <= S\n ensures T <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_8046","instance":8046,"id":211389,"goal":"lemma SetUnionEmpty_8046(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_8047","instance":8047,"id":211390,"goal":"lemma SetInterEmpty_8047(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_8048","instance":8048,"id":211391,"goal":"lemma SetInterSubset_8048(T: set, A: set)\n ensures T * A <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_8049","instance":8049,"id":211392,"goal":"lemma SetCardSubset_8049(S: set, U: set)\n requires S <= U\n ensures |S| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_8050","instance":8050,"id":211393,"goal":"lemma SetUnionCard_8050(T: set, U: set)\n requires T * U == {}\n ensures |T + U| == |T| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_8051","instance":8051,"id":211394,"goal":"lemma SetUnionComm_8051(T: set, U: set)\n ensures T + U == U + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_8052","instance":8052,"id":211395,"goal":"lemma SetInterComm_8052(B: set, A: set)\n ensures B * A == A * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_8053","instance":8053,"id":211396,"goal":"lemma SetUnionAssoc_8053(S: set, U: set, B: set)\n ensures (S + U) + B == S + (U + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_8054","instance":8054,"id":211397,"goal":"lemma SetSubsetRefl_8054(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_8055","instance":8055,"id":211398,"goal":"lemma SetSubsetTrans_8055(A: set, T: set, B: set)\n requires A <= T && T <= B\n ensures A <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_8056","instance":8056,"id":211399,"goal":"lemma SetUnionEmpty_8056(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_8057","instance":8057,"id":211400,"goal":"lemma SetInterEmpty_8057(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_8058","instance":8058,"id":211401,"goal":"lemma SetInterSubset_8058(S: set, A: set)\n ensures S * A <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_8059","instance":8059,"id":211402,"goal":"lemma SetCardSubset_8059(B: set, T: set)\n requires B <= T\n ensures |B| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_8060","instance":8060,"id":211403,"goal":"lemma SetUnionCard_8060(S: set, T: set)\n requires S * T == {}\n ensures |S + T| == |S| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_8061","instance":8061,"id":211404,"goal":"lemma SetUnionComm_8061(U: set, S: set)\n ensures U + S == S + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_8062","instance":8062,"id":211405,"goal":"lemma SetInterComm_8062(B: set, U: set)\n ensures B * U == U * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_8063","instance":8063,"id":211406,"goal":"lemma SetUnionAssoc_8063(U: set, A: set, B: set)\n ensures (U + A) + B == U + (A + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_8064","instance":8064,"id":211407,"goal":"lemma SetSubsetRefl_8064(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_8065","instance":8065,"id":211408,"goal":"lemma SetSubsetTrans_8065(U: set, B: set, T: set)\n requires U <= B && B <= T\n ensures U <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_8066","instance":8066,"id":211409,"goal":"lemma SetUnionEmpty_8066(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_8067","instance":8067,"id":211410,"goal":"lemma SetInterEmpty_8067(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_8068","instance":8068,"id":211411,"goal":"lemma SetInterSubset_8068(T: set, U: set)\n ensures T * U <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_8069","instance":8069,"id":211412,"goal":"lemma SetCardSubset_8069(T: set, U: set)\n requires T <= U\n ensures |T| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_8070","instance":8070,"id":211413,"goal":"lemma SetUnionCard_8070(B: set, S: set)\n requires B * S == {}\n ensures |B + S| == |B| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_8071","instance":8071,"id":211414,"goal":"lemma SetUnionComm_8071(A: set, S: set)\n ensures A + S == S + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_8072","instance":8072,"id":211415,"goal":"lemma SetInterComm_8072(S: set, B: set)\n ensures S * B == B * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_8073","instance":8073,"id":211416,"goal":"lemma SetUnionAssoc_8073(S: set, U: set, T: set)\n ensures (S + U) + T == S + (U + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_8074","instance":8074,"id":211417,"goal":"lemma SetSubsetRefl_8074(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_8075","instance":8075,"id":211418,"goal":"lemma SetSubsetTrans_8075(S: set, B: set, U: set)\n requires S <= B && B <= U\n ensures S <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_8076","instance":8076,"id":211419,"goal":"lemma SetUnionEmpty_8076(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_8077","instance":8077,"id":211420,"goal":"lemma SetInterEmpty_8077(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_8078","instance":8078,"id":211421,"goal":"lemma SetInterSubset_8078(S: set, T: set)\n ensures S * T <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_8079","instance":8079,"id":211422,"goal":"lemma SetCardSubset_8079(U: set, S: set)\n requires U <= S\n ensures |U| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_8080","instance":8080,"id":211423,"goal":"lemma SetUnionCard_8080(U: set, T: set)\n requires U * T == {}\n ensures |U + T| == |U| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_8081","instance":8081,"id":211424,"goal":"lemma SetUnionComm_8081(S: set, T: set)\n ensures S + T == T + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_8082","instance":8082,"id":211425,"goal":"lemma SetInterComm_8082(S: set, T: set)\n ensures S * T == T * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_8083","instance":8083,"id":211426,"goal":"lemma SetUnionAssoc_8083(A: set, U: set, B: set)\n ensures (A + U) + B == A + (U + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_8084","instance":8084,"id":211427,"goal":"lemma SetSubsetRefl_8084(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_8085","instance":8085,"id":211428,"goal":"lemma SetSubsetTrans_8085(S: set, A: set, B: set)\n requires S <= A && A <= B\n ensures S <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_8086","instance":8086,"id":211429,"goal":"lemma SetUnionEmpty_8086(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_8087","instance":8087,"id":211430,"goal":"lemma SetInterEmpty_8087(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_8088","instance":8088,"id":211431,"goal":"lemma SetInterSubset_8088(T: set, B: set)\n ensures T * B <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_8089","instance":8089,"id":211432,"goal":"lemma SetCardSubset_8089(B: set, A: set)\n requires B <= A\n ensures |B| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_8090","instance":8090,"id":211433,"goal":"lemma SetUnionCard_8090(U: set, T: set)\n requires U * T == {}\n ensures |U + T| == |U| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_8091","instance":8091,"id":211434,"goal":"lemma SetUnionComm_8091(B: set, T: set)\n ensures B + T == T + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_8092","instance":8092,"id":211435,"goal":"lemma SetInterComm_8092(T: set, B: set)\n ensures T * B == B * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_8093","instance":8093,"id":211436,"goal":"lemma SetUnionAssoc_8093(T: set, S: set, A: set)\n ensures (T + S) + A == T + (S + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_8094","instance":8094,"id":211437,"goal":"lemma SetSubsetRefl_8094(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_8095","instance":8095,"id":211438,"goal":"lemma SetSubsetTrans_8095(A: set, U: set, S: set)\n requires A <= U && U <= S\n ensures A <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_8096","instance":8096,"id":211439,"goal":"lemma SetUnionEmpty_8096(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_8097","instance":8097,"id":211440,"goal":"lemma SetInterEmpty_8097(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_8098","instance":8098,"id":211441,"goal":"lemma SetInterSubset_8098(S: set, T: set)\n ensures S * T <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_8099","instance":8099,"id":211442,"goal":"lemma SetCardSubset_8099(U: set, S: set)\n requires U <= S\n ensures |U| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_8100","instance":8100,"id":211443,"goal":"lemma SetUnionCard_8100(B: set, S: set)\n requires B * S == {}\n ensures |B + S| == |B| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_8101","instance":8101,"id":211444,"goal":"lemma SetUnionComm_8101(S: set, U: set)\n ensures S + U == U + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_8102","instance":8102,"id":211445,"goal":"lemma SetInterComm_8102(U: set, S: set)\n ensures U * S == S * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_8103","instance":8103,"id":211446,"goal":"lemma SetUnionAssoc_8103(S: set, T: set, U: set)\n ensures (S + T) + U == S + (T + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_8104","instance":8104,"id":211447,"goal":"lemma SetSubsetRefl_8104(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_8105","instance":8105,"id":211448,"goal":"lemma SetSubsetTrans_8105(S: set, T: set, U: set)\n requires S <= T && T <= U\n ensures S <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_8106","instance":8106,"id":211449,"goal":"lemma SetUnionEmpty_8106(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_8107","instance":8107,"id":211450,"goal":"lemma SetInterEmpty_8107(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_8108","instance":8108,"id":211451,"goal":"lemma SetInterSubset_8108(A: set, S: set)\n ensures A * S <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_8109","instance":8109,"id":211452,"goal":"lemma SetCardSubset_8109(T: set, S: set)\n requires T <= S\n ensures |T| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_8110","instance":8110,"id":211453,"goal":"lemma SetUnionCard_8110(S: set, U: set)\n requires S * U == {}\n ensures |S + U| == |S| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_8111","instance":8111,"id":211454,"goal":"lemma SetUnionComm_8111(A: set, S: set)\n ensures A + S == S + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_8112","instance":8112,"id":211455,"goal":"lemma SetInterComm_8112(U: set, A: set)\n ensures U * A == A * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_8113","instance":8113,"id":211456,"goal":"lemma SetUnionAssoc_8113(A: set, T: set, B: set)\n ensures (A + T) + B == A + (T + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_8114","instance":8114,"id":211457,"goal":"lemma SetSubsetRefl_8114(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_8115","instance":8115,"id":211458,"goal":"lemma SetSubsetTrans_8115(T: set, B: set, U: set)\n requires T <= B && B <= U\n ensures T <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_8116","instance":8116,"id":211459,"goal":"lemma SetUnionEmpty_8116(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_8117","instance":8117,"id":211460,"goal":"lemma SetInterEmpty_8117(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_8118","instance":8118,"id":211461,"goal":"lemma SetInterSubset_8118(U: set, S: set)\n ensures U * S <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_8119","instance":8119,"id":211462,"goal":"lemma SetCardSubset_8119(T: set, U: set)\n requires T <= U\n ensures |T| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_8120","instance":8120,"id":211463,"goal":"lemma SetUnionCard_8120(T: set, S: set)\n requires T * S == {}\n ensures |T + S| == |T| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_8121","instance":8121,"id":211464,"goal":"lemma SetUnionComm_8121(U: set, B: set)\n ensures U + B == B + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_8122","instance":8122,"id":211465,"goal":"lemma SetInterComm_8122(A: set, T: set)\n ensures A * T == T * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_8123","instance":8123,"id":211466,"goal":"lemma SetUnionAssoc_8123(T: set, S: set, B: set)\n ensures (T + S) + B == T + (S + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_8124","instance":8124,"id":211467,"goal":"lemma SetSubsetRefl_8124(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_8125","instance":8125,"id":211468,"goal":"lemma SetSubsetTrans_8125(T: set, B: set, S: set)\n requires T <= B && B <= S\n ensures T <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_8126","instance":8126,"id":211469,"goal":"lemma SetUnionEmpty_8126(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_8127","instance":8127,"id":211470,"goal":"lemma SetInterEmpty_8127(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_8128","instance":8128,"id":211471,"goal":"lemma SetInterSubset_8128(T: set, S: set)\n ensures T * S <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_8129","instance":8129,"id":211472,"goal":"lemma SetCardSubset_8129(S: set, B: set)\n requires S <= B\n ensures |S| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_8130","instance":8130,"id":211473,"goal":"lemma SetUnionCard_8130(B: set, A: set)\n requires B * A == {}\n ensures |B + A| == |B| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_8131","instance":8131,"id":211474,"goal":"lemma SetUnionComm_8131(T: set, S: set)\n ensures T + S == S + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_8132","instance":8132,"id":211475,"goal":"lemma SetInterComm_8132(T: set, A: set)\n ensures T * A == A * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_8133","instance":8133,"id":211476,"goal":"lemma SetUnionAssoc_8133(B: set, S: set, A: set)\n ensures (B + S) + A == B + (S + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_8134","instance":8134,"id":211477,"goal":"lemma SetSubsetRefl_8134(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_8135","instance":8135,"id":211478,"goal":"lemma SetSubsetTrans_8135(T: set, B: set, U: set)\n requires T <= B && B <= U\n ensures T <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_8136","instance":8136,"id":211479,"goal":"lemma SetUnionEmpty_8136(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_8137","instance":8137,"id":211480,"goal":"lemma SetInterEmpty_8137(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_8138","instance":8138,"id":211481,"goal":"lemma SetInterSubset_8138(U: set, B: set)\n ensures U * B <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_8139","instance":8139,"id":211482,"goal":"lemma SetCardSubset_8139(B: set, U: set)\n requires B <= U\n ensures |B| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_8140","instance":8140,"id":211483,"goal":"lemma SetUnionCard_8140(U: set, B: set)\n requires U * B == {}\n ensures |U + B| == |U| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_8141","instance":8141,"id":211484,"goal":"lemma SetUnionComm_8141(A: set, U: set)\n ensures A + U == U + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_8142","instance":8142,"id":211485,"goal":"lemma SetInterComm_8142(T: set, S: set)\n ensures T * S == S * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_8143","instance":8143,"id":211486,"goal":"lemma SetUnionAssoc_8143(T: set, B: set, A: set)\n ensures (T + B) + A == T + (B + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_8144","instance":8144,"id":211487,"goal":"lemma SetSubsetRefl_8144(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_8145","instance":8145,"id":211488,"goal":"lemma SetSubsetTrans_8145(B: set, T: set, A: set)\n requires B <= T && T <= A\n ensures B <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_8146","instance":8146,"id":211489,"goal":"lemma SetUnionEmpty_8146(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_8147","instance":8147,"id":211490,"goal":"lemma SetInterEmpty_8147(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_8148","instance":8148,"id":211491,"goal":"lemma SetInterSubset_8148(U: set, A: set)\n ensures U * A <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_8149","instance":8149,"id":211492,"goal":"lemma SetCardSubset_8149(S: set, U: set)\n requires S <= U\n ensures |S| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_8150","instance":8150,"id":211493,"goal":"lemma SetUnionCard_8150(B: set, T: set)\n requires B * T == {}\n ensures |B + T| == |B| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_8151","instance":8151,"id":211494,"goal":"lemma SetUnionComm_8151(B: set, A: set)\n ensures B + A == A + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_8152","instance":8152,"id":211495,"goal":"lemma SetInterComm_8152(U: set, A: set)\n ensures U * A == A * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_8153","instance":8153,"id":211496,"goal":"lemma SetUnionAssoc_8153(T: set, S: set, B: set)\n ensures (T + S) + B == T + (S + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_8154","instance":8154,"id":211497,"goal":"lemma SetSubsetRefl_8154(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_8155","instance":8155,"id":211498,"goal":"lemma SetSubsetTrans_8155(U: set, A: set, B: set)\n requires U <= A && A <= B\n ensures U <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_8156","instance":8156,"id":211499,"goal":"lemma SetUnionEmpty_8156(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_8157","instance":8157,"id":211500,"goal":"lemma SetInterEmpty_8157(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_8158","instance":8158,"id":211501,"goal":"lemma SetInterSubset_8158(A: set, S: set)\n ensures A * S <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_8159","instance":8159,"id":211502,"goal":"lemma SetCardSubset_8159(B: set, S: set)\n requires B <= S\n ensures |B| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_8160","instance":8160,"id":211503,"goal":"lemma SetUnionCard_8160(B: set, T: set)\n requires B * T == {}\n ensures |B + T| == |B| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_8161","instance":8161,"id":211504,"goal":"lemma SetUnionComm_8161(B: set, U: set)\n ensures B + U == U + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_8162","instance":8162,"id":211505,"goal":"lemma SetInterComm_8162(T: set, U: set)\n ensures T * U == U * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_8163","instance":8163,"id":211506,"goal":"lemma SetUnionAssoc_8163(U: set, S: set, T: set)\n ensures (U + S) + T == U + (S + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_8164","instance":8164,"id":211507,"goal":"lemma SetSubsetRefl_8164(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_8165","instance":8165,"id":211508,"goal":"lemma SetSubsetTrans_8165(U: set, A: set, T: set)\n requires U <= A && A <= T\n ensures U <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_8166","instance":8166,"id":211509,"goal":"lemma SetUnionEmpty_8166(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_8167","instance":8167,"id":211510,"goal":"lemma SetInterEmpty_8167(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_8168","instance":8168,"id":211511,"goal":"lemma SetInterSubset_8168(S: set, T: set)\n ensures S * T <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_8169","instance":8169,"id":211512,"goal":"lemma SetCardSubset_8169(A: set, B: set)\n requires A <= B\n ensures |A| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_8170","instance":8170,"id":211513,"goal":"lemma SetUnionCard_8170(B: set, S: set)\n requires B * S == {}\n ensures |B + S| == |B| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_8171","instance":8171,"id":211514,"goal":"lemma SetUnionComm_8171(U: set, T: set)\n ensures U + T == T + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_8172","instance":8172,"id":211515,"goal":"lemma SetInterComm_8172(B: set, A: set)\n ensures B * A == A * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_8173","instance":8173,"id":211516,"goal":"lemma SetUnionAssoc_8173(T: set, U: set, B: set)\n ensures (T + U) + B == T + (U + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_8174","instance":8174,"id":211517,"goal":"lemma SetSubsetRefl_8174(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_8175","instance":8175,"id":211518,"goal":"lemma SetSubsetTrans_8175(T: set, U: set, A: set)\n requires T <= U && U <= A\n ensures T <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_8176","instance":8176,"id":211519,"goal":"lemma SetUnionEmpty_8176(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_8177","instance":8177,"id":211520,"goal":"lemma SetInterEmpty_8177(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_8178","instance":8178,"id":211521,"goal":"lemma SetInterSubset_8178(U: set, B: set)\n ensures U * B <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_8179","instance":8179,"id":211522,"goal":"lemma SetCardSubset_8179(T: set, A: set)\n requires T <= A\n ensures |T| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_8180","instance":8180,"id":211523,"goal":"lemma SetUnionCard_8180(B: set, A: set)\n requires B * A == {}\n ensures |B + A| == |B| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_8181","instance":8181,"id":211524,"goal":"lemma SetUnionComm_8181(U: set, B: set)\n ensures U + B == B + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_8182","instance":8182,"id":211525,"goal":"lemma SetInterComm_8182(S: set, U: set)\n ensures S * U == U * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_8183","instance":8183,"id":211526,"goal":"lemma SetUnionAssoc_8183(B: set, A: set, T: set)\n ensures (B + A) + T == B + (A + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_8184","instance":8184,"id":211527,"goal":"lemma SetSubsetRefl_8184(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_8185","instance":8185,"id":211528,"goal":"lemma SetSubsetTrans_8185(S: set, U: set, T: set)\n requires S <= U && U <= T\n ensures S <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_8186","instance":8186,"id":211529,"goal":"lemma SetUnionEmpty_8186(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_8187","instance":8187,"id":211530,"goal":"lemma SetInterEmpty_8187(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_8188","instance":8188,"id":211531,"goal":"lemma SetInterSubset_8188(A: set, B: set)\n ensures A * B <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_8189","instance":8189,"id":211532,"goal":"lemma SetCardSubset_8189(U: set, B: set)\n requires U <= B\n ensures |U| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_8190","instance":8190,"id":211533,"goal":"lemma SetUnionCard_8190(B: set, A: set)\n requires B * A == {}\n ensures |B + A| == |B| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_8191","instance":8191,"id":211534,"goal":"lemma SetUnionComm_8191(B: set, T: set)\n ensures B + T == T + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_8192","instance":8192,"id":211535,"goal":"lemma SetInterComm_8192(U: set, T: set)\n ensures U * T == T * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_8193","instance":8193,"id":211536,"goal":"lemma SetUnionAssoc_8193(T: set, A: set, S: set)\n ensures (T + A) + S == T + (A + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_8194","instance":8194,"id":211537,"goal":"lemma SetSubsetRefl_8194(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_8195","instance":8195,"id":211538,"goal":"lemma SetSubsetTrans_8195(U: set, T: set, A: set)\n requires U <= T && T <= A\n ensures U <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_8196","instance":8196,"id":211539,"goal":"lemma SetUnionEmpty_8196(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_8197","instance":8197,"id":211540,"goal":"lemma SetInterEmpty_8197(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_8198","instance":8198,"id":211541,"goal":"lemma SetInterSubset_8198(S: set, T: set)\n ensures S * T <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_8199","instance":8199,"id":211542,"goal":"lemma SetCardSubset_8199(A: set, T: set)\n requires A <= T\n ensures |A| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_8200","instance":8200,"id":211543,"goal":"lemma SetUnionCard_8200(A: set, B: set)\n requires A * B == {}\n ensures |A + B| == |A| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_8201","instance":8201,"id":211544,"goal":"lemma SetUnionComm_8201(U: set, T: set)\n ensures U + T == T + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_8202","instance":8202,"id":211545,"goal":"lemma SetInterComm_8202(S: set, U: set)\n ensures S * U == U * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_8203","instance":8203,"id":211546,"goal":"lemma SetUnionAssoc_8203(A: set, B: set, S: set)\n ensures (A + B) + S == A + (B + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_8204","instance":8204,"id":211547,"goal":"lemma SetSubsetRefl_8204(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_8205","instance":8205,"id":211548,"goal":"lemma SetSubsetTrans_8205(A: set, S: set, T: set)\n requires A <= S && S <= T\n ensures A <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_8206","instance":8206,"id":211549,"goal":"lemma SetUnionEmpty_8206(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_8207","instance":8207,"id":211550,"goal":"lemma SetInterEmpty_8207(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_8208","instance":8208,"id":211551,"goal":"lemma SetInterSubset_8208(B: set, S: set)\n ensures B * S <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_8209","instance":8209,"id":211552,"goal":"lemma SetCardSubset_8209(S: set, A: set)\n requires S <= A\n ensures |S| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_8210","instance":8210,"id":211553,"goal":"lemma SetUnionCard_8210(B: set, A: set)\n requires B * A == {}\n ensures |B + A| == |B| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_8211","instance":8211,"id":211554,"goal":"lemma SetUnionComm_8211(U: set, A: set)\n ensures U + A == A + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_8212","instance":8212,"id":211555,"goal":"lemma SetInterComm_8212(T: set, B: set)\n ensures T * B == B * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_8213","instance":8213,"id":211556,"goal":"lemma SetUnionAssoc_8213(B: set, S: set, A: set)\n ensures (B + S) + A == B + (S + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_8214","instance":8214,"id":211557,"goal":"lemma SetSubsetRefl_8214(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_8215","instance":8215,"id":211558,"goal":"lemma SetSubsetTrans_8215(A: set, S: set, U: set)\n requires A <= S && S <= U\n ensures A <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_8216","instance":8216,"id":211559,"goal":"lemma SetUnionEmpty_8216(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_8217","instance":8217,"id":211560,"goal":"lemma SetInterEmpty_8217(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_8218","instance":8218,"id":211561,"goal":"lemma SetInterSubset_8218(U: set, T: set)\n ensures U * T <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_8219","instance":8219,"id":211562,"goal":"lemma SetCardSubset_8219(S: set, B: set)\n requires S <= B\n ensures |S| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_8220","instance":8220,"id":211563,"goal":"lemma SetUnionCard_8220(U: set, A: set)\n requires U * A == {}\n ensures |U + A| == |U| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_8221","instance":8221,"id":211564,"goal":"lemma SetUnionComm_8221(U: set, B: set)\n ensures U + B == B + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_8222","instance":8222,"id":211565,"goal":"lemma SetInterComm_8222(T: set, A: set)\n ensures T * A == A * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_8223","instance":8223,"id":211566,"goal":"lemma SetUnionAssoc_8223(A: set, B: set, S: set)\n ensures (A + B) + S == A + (B + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_8224","instance":8224,"id":211567,"goal":"lemma SetSubsetRefl_8224(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_8225","instance":8225,"id":211568,"goal":"lemma SetSubsetTrans_8225(T: set, U: set, S: set)\n requires T <= U && U <= S\n ensures T <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_8226","instance":8226,"id":211569,"goal":"lemma SetUnionEmpty_8226(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_8227","instance":8227,"id":211570,"goal":"lemma SetInterEmpty_8227(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_8228","instance":8228,"id":211571,"goal":"lemma SetInterSubset_8228(B: set, T: set)\n ensures B * T <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_8229","instance":8229,"id":211572,"goal":"lemma SetCardSubset_8229(U: set, A: set)\n requires U <= A\n ensures |U| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_8230","instance":8230,"id":211573,"goal":"lemma SetUnionCard_8230(U: set, A: set)\n requires U * A == {}\n ensures |U + A| == |U| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_8231","instance":8231,"id":211574,"goal":"lemma SetUnionComm_8231(S: set, A: set)\n ensures S + A == A + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_8232","instance":8232,"id":211575,"goal":"lemma SetInterComm_8232(A: set, S: set)\n ensures A * S == S * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_8233","instance":8233,"id":211576,"goal":"lemma SetUnionAssoc_8233(A: set, S: set, T: set)\n ensures (A + S) + T == A + (S + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_8234","instance":8234,"id":211577,"goal":"lemma SetSubsetRefl_8234(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_8235","instance":8235,"id":211578,"goal":"lemma SetSubsetTrans_8235(T: set, A: set, B: set)\n requires T <= A && A <= B\n ensures T <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_8236","instance":8236,"id":211579,"goal":"lemma SetUnionEmpty_8236(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_8237","instance":8237,"id":211580,"goal":"lemma SetInterEmpty_8237(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_8238","instance":8238,"id":211581,"goal":"lemma SetInterSubset_8238(A: set, U: set)\n ensures A * U <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_8239","instance":8239,"id":211582,"goal":"lemma SetCardSubset_8239(A: set, B: set)\n requires A <= B\n ensures |A| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_8240","instance":8240,"id":211583,"goal":"lemma SetUnionCard_8240(T: set, U: set)\n requires T * U == {}\n ensures |T + U| == |T| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_8241","instance":8241,"id":211584,"goal":"lemma SetUnionComm_8241(B: set, A: set)\n ensures B + A == A + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_8242","instance":8242,"id":211585,"goal":"lemma SetInterComm_8242(S: set, A: set)\n ensures S * A == A * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_8243","instance":8243,"id":211586,"goal":"lemma SetUnionAssoc_8243(B: set, S: set, T: set)\n ensures (B + S) + T == B + (S + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_8244","instance":8244,"id":211587,"goal":"lemma SetSubsetRefl_8244(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_8245","instance":8245,"id":211588,"goal":"lemma SetSubsetTrans_8245(T: set, B: set, S: set)\n requires T <= B && B <= S\n ensures T <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_8246","instance":8246,"id":211589,"goal":"lemma SetUnionEmpty_8246(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_8247","instance":8247,"id":211590,"goal":"lemma SetInterEmpty_8247(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_8248","instance":8248,"id":211591,"goal":"lemma SetInterSubset_8248(T: set, U: set)\n ensures T * U <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_8249","instance":8249,"id":211592,"goal":"lemma SetCardSubset_8249(S: set, B: set)\n requires S <= B\n ensures |S| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_8250","instance":8250,"id":211593,"goal":"lemma SetUnionCard_8250(U: set, S: set)\n requires U * S == {}\n ensures |U + S| == |U| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_8251","instance":8251,"id":211594,"goal":"lemma SetUnionComm_8251(A: set, T: set)\n ensures A + T == T + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_8252","instance":8252,"id":211595,"goal":"lemma SetInterComm_8252(S: set, U: set)\n ensures S * U == U * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_8253","instance":8253,"id":211596,"goal":"lemma SetUnionAssoc_8253(S: set, U: set, A: set)\n ensures (S + U) + A == S + (U + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_8254","instance":8254,"id":211597,"goal":"lemma SetSubsetRefl_8254(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_8255","instance":8255,"id":211598,"goal":"lemma SetSubsetTrans_8255(U: set, T: set, S: set)\n requires U <= T && T <= S\n ensures U <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_8256","instance":8256,"id":211599,"goal":"lemma SetUnionEmpty_8256(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_8257","instance":8257,"id":211600,"goal":"lemma SetInterEmpty_8257(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_8258","instance":8258,"id":211601,"goal":"lemma SetInterSubset_8258(T: set, S: set)\n ensures T * S <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_8259","instance":8259,"id":211602,"goal":"lemma SetCardSubset_8259(T: set, A: set)\n requires T <= A\n ensures |T| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_8260","instance":8260,"id":211603,"goal":"lemma SetUnionCard_8260(U: set, T: set)\n requires U * T == {}\n ensures |U + T| == |U| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_8261","instance":8261,"id":211604,"goal":"lemma SetUnionComm_8261(U: set, A: set)\n ensures U + A == A + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_8262","instance":8262,"id":211605,"goal":"lemma SetInterComm_8262(U: set, S: set)\n ensures U * S == S * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_8263","instance":8263,"id":211606,"goal":"lemma SetUnionAssoc_8263(B: set, S: set, A: set)\n ensures (B + S) + A == B + (S + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_8264","instance":8264,"id":211607,"goal":"lemma SetSubsetRefl_8264(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_8265","instance":8265,"id":211608,"goal":"lemma SetSubsetTrans_8265(B: set, U: set, S: set)\n requires B <= U && U <= S\n ensures B <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_8266","instance":8266,"id":211609,"goal":"lemma SetUnionEmpty_8266(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_8267","instance":8267,"id":211610,"goal":"lemma SetInterEmpty_8267(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_8268","instance":8268,"id":211611,"goal":"lemma SetInterSubset_8268(B: set, A: set)\n ensures B * A <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_8269","instance":8269,"id":211612,"goal":"lemma SetCardSubset_8269(U: set, S: set)\n requires U <= S\n ensures |U| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_8270","instance":8270,"id":211613,"goal":"lemma SetUnionCard_8270(A: set, U: set)\n requires A * U == {}\n ensures |A + U| == |A| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_8271","instance":8271,"id":211614,"goal":"lemma SetUnionComm_8271(U: set, B: set)\n ensures U + B == B + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_8272","instance":8272,"id":211615,"goal":"lemma SetInterComm_8272(U: set, A: set)\n ensures U * A == A * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_8273","instance":8273,"id":211616,"goal":"lemma SetUnionAssoc_8273(T: set, U: set, S: set)\n ensures (T + U) + S == T + (U + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_8274","instance":8274,"id":211617,"goal":"lemma SetSubsetRefl_8274(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_8275","instance":8275,"id":211618,"goal":"lemma SetSubsetTrans_8275(A: set, S: set, B: set)\n requires A <= S && S <= B\n ensures A <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_8276","instance":8276,"id":211619,"goal":"lemma SetUnionEmpty_8276(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_8277","instance":8277,"id":211620,"goal":"lemma SetInterEmpty_8277(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_8278","instance":8278,"id":211621,"goal":"lemma SetInterSubset_8278(A: set, S: set)\n ensures A * S <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_8279","instance":8279,"id":211622,"goal":"lemma SetCardSubset_8279(S: set, U: set)\n requires S <= U\n ensures |S| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_8280","instance":8280,"id":211623,"goal":"lemma SetUnionCard_8280(U: set, S: set)\n requires U * S == {}\n ensures |U + S| == |U| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_8281","instance":8281,"id":211624,"goal":"lemma SetUnionComm_8281(S: set, U: set)\n ensures S + U == U + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_8282","instance":8282,"id":211625,"goal":"lemma SetInterComm_8282(B: set, S: set)\n ensures B * S == S * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_8283","instance":8283,"id":211626,"goal":"lemma SetUnionAssoc_8283(U: set, B: set, T: set)\n ensures (U + B) + T == U + (B + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_8284","instance":8284,"id":211627,"goal":"lemma SetSubsetRefl_8284(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_8285","instance":8285,"id":211628,"goal":"lemma SetSubsetTrans_8285(T: set, B: set, U: set)\n requires T <= B && B <= U\n ensures T <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_8286","instance":8286,"id":211629,"goal":"lemma SetUnionEmpty_8286(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_8287","instance":8287,"id":211630,"goal":"lemma SetInterEmpty_8287(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_8288","instance":8288,"id":211631,"goal":"lemma SetInterSubset_8288(T: set, B: set)\n ensures T * B <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_8289","instance":8289,"id":211632,"goal":"lemma SetCardSubset_8289(S: set, A: set)\n requires S <= A\n ensures |S| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_8290","instance":8290,"id":211633,"goal":"lemma SetUnionCard_8290(B: set, S: set)\n requires B * S == {}\n ensures |B + S| == |B| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_8291","instance":8291,"id":211634,"goal":"lemma SetUnionComm_8291(T: set, U: set)\n ensures T + U == U + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_8292","instance":8292,"id":211635,"goal":"lemma SetInterComm_8292(S: set, A: set)\n ensures S * A == A * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_8293","instance":8293,"id":211636,"goal":"lemma SetUnionAssoc_8293(B: set, U: set, S: set)\n ensures (B + U) + S == B + (U + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_8294","instance":8294,"id":211637,"goal":"lemma SetSubsetRefl_8294(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_8295","instance":8295,"id":211638,"goal":"lemma SetSubsetTrans_8295(T: set, S: set, U: set)\n requires T <= S && S <= U\n ensures T <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_8296","instance":8296,"id":211639,"goal":"lemma SetUnionEmpty_8296(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_8297","instance":8297,"id":211640,"goal":"lemma SetInterEmpty_8297(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_8298","instance":8298,"id":211641,"goal":"lemma SetInterSubset_8298(T: set, U: set)\n ensures T * U <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_8299","instance":8299,"id":211642,"goal":"lemma SetCardSubset_8299(B: set, S: set)\n requires B <= S\n ensures |B| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_8300","instance":8300,"id":211643,"goal":"lemma SetUnionCard_8300(A: set, B: set)\n requires A * B == {}\n ensures |A + B| == |A| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_8301","instance":8301,"id":211644,"goal":"lemma SetUnionComm_8301(U: set, S: set)\n ensures U + S == S + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_8302","instance":8302,"id":211645,"goal":"lemma SetInterComm_8302(A: set, B: set)\n ensures A * B == B * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_8303","instance":8303,"id":211646,"goal":"lemma SetUnionAssoc_8303(B: set, T: set, S: set)\n ensures (B + T) + S == B + (T + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_8304","instance":8304,"id":211647,"goal":"lemma SetSubsetRefl_8304(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_8305","instance":8305,"id":211648,"goal":"lemma SetSubsetTrans_8305(A: set, S: set, T: set)\n requires A <= S && S <= T\n ensures A <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_8306","instance":8306,"id":211649,"goal":"lemma SetUnionEmpty_8306(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_8307","instance":8307,"id":211650,"goal":"lemma SetInterEmpty_8307(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_8308","instance":8308,"id":211651,"goal":"lemma SetInterSubset_8308(B: set, T: set)\n ensures B * T <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_8309","instance":8309,"id":211652,"goal":"lemma SetCardSubset_8309(U: set, B: set)\n requires U <= B\n ensures |U| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_8310","instance":8310,"id":211653,"goal":"lemma SetUnionCard_8310(U: set, T: set)\n requires U * T == {}\n ensures |U + T| == |U| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_8311","instance":8311,"id":211654,"goal":"lemma SetUnionComm_8311(U: set, A: set)\n ensures U + A == A + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_8312","instance":8312,"id":211655,"goal":"lemma SetInterComm_8312(B: set, A: set)\n ensures B * A == A * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_8313","instance":8313,"id":211656,"goal":"lemma SetUnionAssoc_8313(U: set, S: set, A: set)\n ensures (U + S) + A == U + (S + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_8314","instance":8314,"id":211657,"goal":"lemma SetSubsetRefl_8314(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_8315","instance":8315,"id":211658,"goal":"lemma SetSubsetTrans_8315(T: set, A: set, B: set)\n requires T <= A && A <= B\n ensures T <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_8316","instance":8316,"id":211659,"goal":"lemma SetUnionEmpty_8316(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_8317","instance":8317,"id":211660,"goal":"lemma SetInterEmpty_8317(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_8318","instance":8318,"id":211661,"goal":"lemma SetInterSubset_8318(S: set, T: set)\n ensures S * T <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_8319","instance":8319,"id":211662,"goal":"lemma SetCardSubset_8319(U: set, B: set)\n requires U <= B\n ensures |U| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_8320","instance":8320,"id":211663,"goal":"lemma SetUnionCard_8320(T: set, U: set)\n requires T * U == {}\n ensures |T + U| == |T| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_8321","instance":8321,"id":211664,"goal":"lemma SetUnionComm_8321(A: set, U: set)\n ensures A + U == U + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_8322","instance":8322,"id":211665,"goal":"lemma SetInterComm_8322(B: set, S: set)\n ensures B * S == S * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_8323","instance":8323,"id":211666,"goal":"lemma SetUnionAssoc_8323(A: set, S: set, B: set)\n ensures (A + S) + B == A + (S + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_8324","instance":8324,"id":211667,"goal":"lemma SetSubsetRefl_8324(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_8325","instance":8325,"id":211668,"goal":"lemma SetSubsetTrans_8325(B: set, A: set, T: set)\n requires B <= A && A <= T\n ensures B <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_8326","instance":8326,"id":211669,"goal":"lemma SetUnionEmpty_8326(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_8327","instance":8327,"id":211670,"goal":"lemma SetInterEmpty_8327(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_8328","instance":8328,"id":211671,"goal":"lemma SetInterSubset_8328(T: set, S: set)\n ensures T * S <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_8329","instance":8329,"id":211672,"goal":"lemma SetCardSubset_8329(S: set, A: set)\n requires S <= A\n ensures |S| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_8330","instance":8330,"id":211673,"goal":"lemma SetUnionCard_8330(A: set, T: set)\n requires A * T == {}\n ensures |A + T| == |A| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_8331","instance":8331,"id":211674,"goal":"lemma SetUnionComm_8331(U: set, T: set)\n ensures U + T == T + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_8332","instance":8332,"id":211675,"goal":"lemma SetInterComm_8332(T: set, S: set)\n ensures T * S == S * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_8333","instance":8333,"id":211676,"goal":"lemma SetUnionAssoc_8333(S: set, T: set, A: set)\n ensures (S + T) + A == S + (T + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_8334","instance":8334,"id":211677,"goal":"lemma SetSubsetRefl_8334(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_8335","instance":8335,"id":211678,"goal":"lemma SetSubsetTrans_8335(T: set, U: set, A: set)\n requires T <= U && U <= A\n ensures T <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_8336","instance":8336,"id":211679,"goal":"lemma SetUnionEmpty_8336(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_8337","instance":8337,"id":211680,"goal":"lemma SetInterEmpty_8337(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_8338","instance":8338,"id":211681,"goal":"lemma SetInterSubset_8338(S: set, T: set)\n ensures S * T <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_8339","instance":8339,"id":211682,"goal":"lemma SetCardSubset_8339(B: set, T: set)\n requires B <= T\n ensures |B| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_8340","instance":8340,"id":211683,"goal":"lemma SetUnionCard_8340(B: set, T: set)\n requires B * T == {}\n ensures |B + T| == |B| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_8341","instance":8341,"id":211684,"goal":"lemma SetUnionComm_8341(T: set, B: set)\n ensures T + B == B + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_8342","instance":8342,"id":211685,"goal":"lemma SetInterComm_8342(T: set, U: set)\n ensures T * U == U * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_8343","instance":8343,"id":211686,"goal":"lemma SetUnionAssoc_8343(U: set, A: set, S: set)\n ensures (U + A) + S == U + (A + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_8344","instance":8344,"id":211687,"goal":"lemma SetSubsetRefl_8344(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_8345","instance":8345,"id":211688,"goal":"lemma SetSubsetTrans_8345(U: set, T: set, A: set)\n requires U <= T && T <= A\n ensures U <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_8346","instance":8346,"id":211689,"goal":"lemma SetUnionEmpty_8346(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_8347","instance":8347,"id":211690,"goal":"lemma SetInterEmpty_8347(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_8348","instance":8348,"id":211691,"goal":"lemma SetInterSubset_8348(B: set, U: set)\n ensures B * U <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_8349","instance":8349,"id":211692,"goal":"lemma SetCardSubset_8349(U: set, A: set)\n requires U <= A\n ensures |U| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_8350","instance":8350,"id":211693,"goal":"lemma SetUnionCard_8350(T: set, S: set)\n requires T * S == {}\n ensures |T + S| == |T| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_8351","instance":8351,"id":211694,"goal":"lemma SetUnionComm_8351(T: set, B: set)\n ensures T + B == B + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_8352","instance":8352,"id":211695,"goal":"lemma SetInterComm_8352(S: set, U: set)\n ensures S * U == U * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_8353","instance":8353,"id":211696,"goal":"lemma SetUnionAssoc_8353(B: set, U: set, A: set)\n ensures (B + U) + A == B + (U + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_8354","instance":8354,"id":211697,"goal":"lemma SetSubsetRefl_8354(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_8355","instance":8355,"id":211698,"goal":"lemma SetSubsetTrans_8355(A: set, S: set, B: set)\n requires A <= S && S <= B\n ensures A <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_8356","instance":8356,"id":211699,"goal":"lemma SetUnionEmpty_8356(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_8357","instance":8357,"id":211700,"goal":"lemma SetInterEmpty_8357(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_8358","instance":8358,"id":211701,"goal":"lemma SetInterSubset_8358(U: set, T: set)\n ensures U * T <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_8359","instance":8359,"id":211702,"goal":"lemma SetCardSubset_8359(S: set, U: set)\n requires S <= U\n ensures |S| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_8360","instance":8360,"id":211703,"goal":"lemma SetUnionCard_8360(U: set, T: set)\n requires U * T == {}\n ensures |U + T| == |U| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_8361","instance":8361,"id":211704,"goal":"lemma SetUnionComm_8361(S: set, B: set)\n ensures S + B == B + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_8362","instance":8362,"id":211705,"goal":"lemma SetInterComm_8362(S: set, T: set)\n ensures S * T == T * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_8363","instance":8363,"id":211706,"goal":"lemma SetUnionAssoc_8363(U: set, A: set, B: set)\n ensures (U + A) + B == U + (A + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_8364","instance":8364,"id":211707,"goal":"lemma SetSubsetRefl_8364(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_8365","instance":8365,"id":211708,"goal":"lemma SetSubsetTrans_8365(U: set, T: set, S: set)\n requires U <= T && T <= S\n ensures U <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_8366","instance":8366,"id":211709,"goal":"lemma SetUnionEmpty_8366(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_8367","instance":8367,"id":211710,"goal":"lemma SetInterEmpty_8367(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_8368","instance":8368,"id":211711,"goal":"lemma SetInterSubset_8368(S: set, A: set)\n ensures S * A <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_8369","instance":8369,"id":211712,"goal":"lemma SetCardSubset_8369(B: set, A: set)\n requires B <= A\n ensures |B| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_8370","instance":8370,"id":211713,"goal":"lemma SetUnionCard_8370(A: set, B: set)\n requires A * B == {}\n ensures |A + B| == |A| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_8371","instance":8371,"id":211714,"goal":"lemma SetUnionComm_8371(A: set, U: set)\n ensures A + U == U + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_8372","instance":8372,"id":211715,"goal":"lemma SetInterComm_8372(U: set, T: set)\n ensures U * T == T * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_8373","instance":8373,"id":211716,"goal":"lemma SetUnionAssoc_8373(S: set, U: set, A: set)\n ensures (S + U) + A == S + (U + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_8374","instance":8374,"id":211717,"goal":"lemma SetSubsetRefl_8374(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_8375","instance":8375,"id":211718,"goal":"lemma SetSubsetTrans_8375(A: set, U: set, S: set)\n requires A <= U && U <= S\n ensures A <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_8376","instance":8376,"id":211719,"goal":"lemma SetUnionEmpty_8376(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_8377","instance":8377,"id":211720,"goal":"lemma SetInterEmpty_8377(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_8378","instance":8378,"id":211721,"goal":"lemma SetInterSubset_8378(T: set, B: set)\n ensures T * B <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_8379","instance":8379,"id":211722,"goal":"lemma SetCardSubset_8379(U: set, A: set)\n requires U <= A\n ensures |U| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_8380","instance":8380,"id":211723,"goal":"lemma SetUnionCard_8380(S: set, U: set)\n requires S * U == {}\n ensures |S + U| == |S| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_8381","instance":8381,"id":211724,"goal":"lemma SetUnionComm_8381(B: set, T: set)\n ensures B + T == T + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_8382","instance":8382,"id":211725,"goal":"lemma SetInterComm_8382(A: set, U: set)\n ensures A * U == U * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_8383","instance":8383,"id":211726,"goal":"lemma SetUnionAssoc_8383(U: set, B: set, S: set)\n ensures (U + B) + S == U + (B + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_8384","instance":8384,"id":211727,"goal":"lemma SetSubsetRefl_8384(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_8385","instance":8385,"id":211728,"goal":"lemma SetSubsetTrans_8385(A: set, T: set, B: set)\n requires A <= T && T <= B\n ensures A <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_8386","instance":8386,"id":211729,"goal":"lemma SetUnionEmpty_8386(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_8387","instance":8387,"id":211730,"goal":"lemma SetInterEmpty_8387(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_8388","instance":8388,"id":211731,"goal":"lemma SetInterSubset_8388(S: set, B: set)\n ensures S * B <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_8389","instance":8389,"id":211732,"goal":"lemma SetCardSubset_8389(U: set, B: set)\n requires U <= B\n ensures |U| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_8390","instance":8390,"id":211733,"goal":"lemma SetUnionCard_8390(S: set, B: set)\n requires S * B == {}\n ensures |S + B| == |S| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_8391","instance":8391,"id":211734,"goal":"lemma SetUnionComm_8391(T: set, S: set)\n ensures T + S == S + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_8392","instance":8392,"id":211735,"goal":"lemma SetInterComm_8392(B: set, U: set)\n ensures B * U == U * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_8393","instance":8393,"id":211736,"goal":"lemma SetUnionAssoc_8393(S: set, T: set, B: set)\n ensures (S + T) + B == S + (T + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_8394","instance":8394,"id":211737,"goal":"lemma SetSubsetRefl_8394(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_8395","instance":8395,"id":211738,"goal":"lemma SetSubsetTrans_8395(T: set, A: set, B: set)\n requires T <= A && A <= B\n ensures T <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_8396","instance":8396,"id":211739,"goal":"lemma SetUnionEmpty_8396(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_8397","instance":8397,"id":211740,"goal":"lemma SetInterEmpty_8397(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_8398","instance":8398,"id":211741,"goal":"lemma SetInterSubset_8398(B: set, T: set)\n ensures B * T <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_8399","instance":8399,"id":211742,"goal":"lemma SetCardSubset_8399(T: set, A: set)\n requires T <= A\n ensures |T| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_8400","instance":8400,"id":211743,"goal":"lemma SetUnionCard_8400(U: set, S: set)\n requires U * S == {}\n ensures |U + S| == |U| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_8401","instance":8401,"id":211744,"goal":"lemma SetUnionComm_8401(A: set, B: set)\n ensures A + B == B + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_8402","instance":8402,"id":211745,"goal":"lemma SetInterComm_8402(B: set, A: set)\n ensures B * A == A * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_8403","instance":8403,"id":211746,"goal":"lemma SetUnionAssoc_8403(T: set, A: set, B: set)\n ensures (T + A) + B == T + (A + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_8404","instance":8404,"id":211747,"goal":"lemma SetSubsetRefl_8404(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_8405","instance":8405,"id":211748,"goal":"lemma SetSubsetTrans_8405(U: set, A: set, B: set)\n requires U <= A && A <= B\n ensures U <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_8406","instance":8406,"id":211749,"goal":"lemma SetUnionEmpty_8406(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_8407","instance":8407,"id":211750,"goal":"lemma SetInterEmpty_8407(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_8408","instance":8408,"id":211751,"goal":"lemma SetInterSubset_8408(U: set, A: set)\n ensures U * A <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_8409","instance":8409,"id":211752,"goal":"lemma SetCardSubset_8409(A: set, B: set)\n requires A <= B\n ensures |A| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_8410","instance":8410,"id":211753,"goal":"lemma SetUnionCard_8410(S: set, T: set)\n requires S * T == {}\n ensures |S + T| == |S| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_8411","instance":8411,"id":211754,"goal":"lemma SetUnionComm_8411(T: set, A: set)\n ensures T + A == A + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_8412","instance":8412,"id":211755,"goal":"lemma SetInterComm_8412(A: set, U: set)\n ensures A * U == U * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_8413","instance":8413,"id":211756,"goal":"lemma SetUnionAssoc_8413(A: set, T: set, S: set)\n ensures (A + T) + S == A + (T + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_8414","instance":8414,"id":211757,"goal":"lemma SetSubsetRefl_8414(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_8415","instance":8415,"id":211758,"goal":"lemma SetSubsetTrans_8415(B: set, S: set, A: set)\n requires B <= S && S <= A\n ensures B <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_8416","instance":8416,"id":211759,"goal":"lemma SetUnionEmpty_8416(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_8417","instance":8417,"id":211760,"goal":"lemma SetInterEmpty_8417(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_8418","instance":8418,"id":211761,"goal":"lemma SetInterSubset_8418(T: set, S: set)\n ensures T * S <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_8419","instance":8419,"id":211762,"goal":"lemma SetCardSubset_8419(B: set, U: set)\n requires B <= U\n ensures |B| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_8420","instance":8420,"id":211763,"goal":"lemma SetUnionCard_8420(S: set, B: set)\n requires S * B == {}\n ensures |S + B| == |S| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_8421","instance":8421,"id":211764,"goal":"lemma SetUnionComm_8421(A: set, T: set)\n ensures A + T == T + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_8422","instance":8422,"id":211765,"goal":"lemma SetInterComm_8422(U: set, A: set)\n ensures U * A == A * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_8423","instance":8423,"id":211766,"goal":"lemma SetUnionAssoc_8423(U: set, T: set, B: set)\n ensures (U + T) + B == U + (T + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_8424","instance":8424,"id":211767,"goal":"lemma SetSubsetRefl_8424(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_8425","instance":8425,"id":211768,"goal":"lemma SetSubsetTrans_8425(U: set, A: set, S: set)\n requires U <= A && A <= S\n ensures U <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_8426","instance":8426,"id":211769,"goal":"lemma SetUnionEmpty_8426(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_8427","instance":8427,"id":211770,"goal":"lemma SetInterEmpty_8427(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_8428","instance":8428,"id":211771,"goal":"lemma SetInterSubset_8428(U: set, A: set)\n ensures U * A <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_8429","instance":8429,"id":211772,"goal":"lemma SetCardSubset_8429(A: set, B: set)\n requires A <= B\n ensures |A| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_8430","instance":8430,"id":211773,"goal":"lemma SetUnionCard_8430(B: set, A: set)\n requires B * A == {}\n ensures |B + A| == |B| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_8431","instance":8431,"id":211774,"goal":"lemma SetUnionComm_8431(U: set, A: set)\n ensures U + A == A + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_8432","instance":8432,"id":211775,"goal":"lemma SetInterComm_8432(B: set, T: set)\n ensures B * T == T * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_8433","instance":8433,"id":211776,"goal":"lemma SetUnionAssoc_8433(S: set, A: set, B: set)\n ensures (S + A) + B == S + (A + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_8434","instance":8434,"id":211777,"goal":"lemma SetSubsetRefl_8434(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_8435","instance":8435,"id":211778,"goal":"lemma SetSubsetTrans_8435(U: set, B: set, T: set)\n requires U <= B && B <= T\n ensures U <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_8436","instance":8436,"id":211779,"goal":"lemma SetUnionEmpty_8436(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_8437","instance":8437,"id":211780,"goal":"lemma SetInterEmpty_8437(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_8438","instance":8438,"id":211781,"goal":"lemma SetInterSubset_8438(T: set, U: set)\n ensures T * U <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_8439","instance":8439,"id":211782,"goal":"lemma SetCardSubset_8439(U: set, S: set)\n requires U <= S\n ensures |U| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_8440","instance":8440,"id":211783,"goal":"lemma SetUnionCard_8440(U: set, S: set)\n requires U * S == {}\n ensures |U + S| == |U| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_8441","instance":8441,"id":211784,"goal":"lemma SetUnionComm_8441(B: set, U: set)\n ensures B + U == U + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_8442","instance":8442,"id":211785,"goal":"lemma SetInterComm_8442(S: set, B: set)\n ensures S * B == B * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_8443","instance":8443,"id":211786,"goal":"lemma SetUnionAssoc_8443(A: set, B: set, U: set)\n ensures (A + B) + U == A + (B + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_8444","instance":8444,"id":211787,"goal":"lemma SetSubsetRefl_8444(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_8445","instance":8445,"id":211788,"goal":"lemma SetSubsetTrans_8445(U: set, T: set, A: set)\n requires U <= T && T <= A\n ensures U <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_8446","instance":8446,"id":211789,"goal":"lemma SetUnionEmpty_8446(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_8447","instance":8447,"id":211790,"goal":"lemma SetInterEmpty_8447(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_8448","instance":8448,"id":211791,"goal":"lemma SetInterSubset_8448(B: set, T: set)\n ensures B * T <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_8449","instance":8449,"id":211792,"goal":"lemma SetCardSubset_8449(S: set, T: set)\n requires S <= T\n ensures |S| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_8450","instance":8450,"id":211793,"goal":"lemma SetUnionCard_8450(T: set, U: set)\n requires T * U == {}\n ensures |T + U| == |T| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_8451","instance":8451,"id":211794,"goal":"lemma SetUnionComm_8451(S: set, T: set)\n ensures S + T == T + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_8452","instance":8452,"id":211795,"goal":"lemma SetInterComm_8452(B: set, U: set)\n ensures B * U == U * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_8453","instance":8453,"id":211796,"goal":"lemma SetUnionAssoc_8453(B: set, T: set, A: set)\n ensures (B + T) + A == B + (T + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_8454","instance":8454,"id":211797,"goal":"lemma SetSubsetRefl_8454(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_8455","instance":8455,"id":211798,"goal":"lemma SetSubsetTrans_8455(T: set, B: set, S: set)\n requires T <= B && B <= S\n ensures T <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_8456","instance":8456,"id":211799,"goal":"lemma SetUnionEmpty_8456(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_8457","instance":8457,"id":211800,"goal":"lemma SetInterEmpty_8457(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_8458","instance":8458,"id":211801,"goal":"lemma SetInterSubset_8458(B: set, U: set)\n ensures B * U <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_8459","instance":8459,"id":211802,"goal":"lemma SetCardSubset_8459(S: set, U: set)\n requires S <= U\n ensures |S| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_8460","instance":8460,"id":211803,"goal":"lemma SetUnionCard_8460(A: set, U: set)\n requires A * U == {}\n ensures |A + U| == |A| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_8461","instance":8461,"id":211804,"goal":"lemma SetUnionComm_8461(B: set, S: set)\n ensures B + S == S + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_8462","instance":8462,"id":211805,"goal":"lemma SetInterComm_8462(A: set, B: set)\n ensures A * B == B * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_8463","instance":8463,"id":211806,"goal":"lemma SetUnionAssoc_8463(B: set, A: set, U: set)\n ensures (B + A) + U == B + (A + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_8464","instance":8464,"id":211807,"goal":"lemma SetSubsetRefl_8464(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_8465","instance":8465,"id":211808,"goal":"lemma SetSubsetTrans_8465(A: set, T: set, S: set)\n requires A <= T && T <= S\n ensures A <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_8466","instance":8466,"id":211809,"goal":"lemma SetUnionEmpty_8466(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_8467","instance":8467,"id":211810,"goal":"lemma SetInterEmpty_8467(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_8468","instance":8468,"id":211811,"goal":"lemma SetInterSubset_8468(B: set, T: set)\n ensures B * T <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_8469","instance":8469,"id":211812,"goal":"lemma SetCardSubset_8469(B: set, T: set)\n requires B <= T\n ensures |B| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_8470","instance":8470,"id":211813,"goal":"lemma SetUnionCard_8470(A: set, S: set)\n requires A * S == {}\n ensures |A + S| == |A| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_8471","instance":8471,"id":211814,"goal":"lemma SetUnionComm_8471(S: set, A: set)\n ensures S + A == A + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_8472","instance":8472,"id":211815,"goal":"lemma SetInterComm_8472(U: set, A: set)\n ensures U * A == A * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_8473","instance":8473,"id":211816,"goal":"lemma SetUnionAssoc_8473(B: set, A: set, S: set)\n ensures (B + A) + S == B + (A + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_8474","instance":8474,"id":211817,"goal":"lemma SetSubsetRefl_8474(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_8475","instance":8475,"id":211818,"goal":"lemma SetSubsetTrans_8475(T: set, S: set, A: set)\n requires T <= S && S <= A\n ensures T <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_8476","instance":8476,"id":211819,"goal":"lemma SetUnionEmpty_8476(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_8477","instance":8477,"id":211820,"goal":"lemma SetInterEmpty_8477(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_8478","instance":8478,"id":211821,"goal":"lemma SetInterSubset_8478(B: set, U: set)\n ensures B * U <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_8479","instance":8479,"id":211822,"goal":"lemma SetCardSubset_8479(U: set, T: set)\n requires U <= T\n ensures |U| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_8480","instance":8480,"id":211823,"goal":"lemma SetUnionCard_8480(B: set, A: set)\n requires B * A == {}\n ensures |B + A| == |B| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_8481","instance":8481,"id":211824,"goal":"lemma SetUnionComm_8481(T: set, B: set)\n ensures T + B == B + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_8482","instance":8482,"id":211825,"goal":"lemma SetInterComm_8482(T: set, B: set)\n ensures T * B == B * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_8483","instance":8483,"id":211826,"goal":"lemma SetUnionAssoc_8483(A: set, U: set, S: set)\n ensures (A + U) + S == A + (U + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_8484","instance":8484,"id":211827,"goal":"lemma SetSubsetRefl_8484(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_8485","instance":8485,"id":211828,"goal":"lemma SetSubsetTrans_8485(U: set, A: set, S: set)\n requires U <= A && A <= S\n ensures U <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_8486","instance":8486,"id":211829,"goal":"lemma SetUnionEmpty_8486(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_8487","instance":8487,"id":211830,"goal":"lemma SetInterEmpty_8487(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_8488","instance":8488,"id":211831,"goal":"lemma SetInterSubset_8488(U: set, B: set)\n ensures U * B <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_8489","instance":8489,"id":211832,"goal":"lemma SetCardSubset_8489(S: set, A: set)\n requires S <= A\n ensures |S| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_8490","instance":8490,"id":211833,"goal":"lemma SetUnionCard_8490(T: set, A: set)\n requires T * A == {}\n ensures |T + A| == |T| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_8491","instance":8491,"id":211834,"goal":"lemma SetUnionComm_8491(T: set, B: set)\n ensures T + B == B + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_8492","instance":8492,"id":211835,"goal":"lemma SetInterComm_8492(S: set, U: set)\n ensures S * U == U * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_8493","instance":8493,"id":211836,"goal":"lemma SetUnionAssoc_8493(A: set, B: set, T: set)\n ensures (A + B) + T == A + (B + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_8494","instance":8494,"id":211837,"goal":"lemma SetSubsetRefl_8494(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_8495","instance":8495,"id":211838,"goal":"lemma SetSubsetTrans_8495(T: set, A: set, S: set)\n requires T <= A && A <= S\n ensures T <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_8496","instance":8496,"id":211839,"goal":"lemma SetUnionEmpty_8496(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_8497","instance":8497,"id":211840,"goal":"lemma SetInterEmpty_8497(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_8498","instance":8498,"id":211841,"goal":"lemma SetInterSubset_8498(A: set, U: set)\n ensures A * U <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_8499","instance":8499,"id":211842,"goal":"lemma SetCardSubset_8499(A: set, U: set)\n requires A <= U\n ensures |A| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_8500","instance":8500,"id":211843,"goal":"lemma SetUnionCard_8500(T: set, U: set)\n requires T * U == {}\n ensures |T + U| == |T| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_8501","instance":8501,"id":211844,"goal":"lemma SetUnionComm_8501(B: set, T: set)\n ensures B + T == T + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_8502","instance":8502,"id":211845,"goal":"lemma SetInterComm_8502(S: set, T: set)\n ensures S * T == T * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_8503","instance":8503,"id":211846,"goal":"lemma SetUnionAssoc_8503(B: set, U: set, T: set)\n ensures (B + U) + T == B + (U + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_8504","instance":8504,"id":211847,"goal":"lemma SetSubsetRefl_8504(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_8505","instance":8505,"id":211848,"goal":"lemma SetSubsetTrans_8505(S: set, U: set, A: set)\n requires S <= U && U <= A\n ensures S <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_8506","instance":8506,"id":211849,"goal":"lemma SetUnionEmpty_8506(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_8507","instance":8507,"id":211850,"goal":"lemma SetInterEmpty_8507(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_8508","instance":8508,"id":211851,"goal":"lemma SetInterSubset_8508(U: set, B: set)\n ensures U * B <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_8509","instance":8509,"id":211852,"goal":"lemma SetCardSubset_8509(A: set, U: set)\n requires A <= U\n ensures |A| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_8510","instance":8510,"id":211853,"goal":"lemma SetUnionCard_8510(S: set, A: set)\n requires S * A == {}\n ensures |S + A| == |S| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_8511","instance":8511,"id":211854,"goal":"lemma SetUnionComm_8511(U: set, A: set)\n ensures U + A == A + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_8512","instance":8512,"id":211855,"goal":"lemma SetInterComm_8512(B: set, U: set)\n ensures B * U == U * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_8513","instance":8513,"id":211856,"goal":"lemma SetUnionAssoc_8513(U: set, A: set, T: set)\n ensures (U + A) + T == U + (A + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_8514","instance":8514,"id":211857,"goal":"lemma SetSubsetRefl_8514(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_8515","instance":8515,"id":211858,"goal":"lemma SetSubsetTrans_8515(T: set, U: set, S: set)\n requires T <= U && U <= S\n ensures T <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_8516","instance":8516,"id":211859,"goal":"lemma SetUnionEmpty_8516(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_8517","instance":8517,"id":211860,"goal":"lemma SetInterEmpty_8517(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_8518","instance":8518,"id":211861,"goal":"lemma SetInterSubset_8518(S: set, B: set)\n ensures S * B <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_8519","instance":8519,"id":211862,"goal":"lemma SetCardSubset_8519(U: set, A: set)\n requires U <= A\n ensures |U| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_8520","instance":8520,"id":211863,"goal":"lemma SetUnionCard_8520(B: set, A: set)\n requires B * A == {}\n ensures |B + A| == |B| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_8521","instance":8521,"id":211864,"goal":"lemma SetUnionComm_8521(B: set, A: set)\n ensures B + A == A + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_8522","instance":8522,"id":211865,"goal":"lemma SetInterComm_8522(T: set, A: set)\n ensures T * A == A * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_8523","instance":8523,"id":211866,"goal":"lemma SetUnionAssoc_8523(U: set, S: set, B: set)\n ensures (U + S) + B == U + (S + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_8524","instance":8524,"id":211867,"goal":"lemma SetSubsetRefl_8524(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_8525","instance":8525,"id":211868,"goal":"lemma SetSubsetTrans_8525(B: set, U: set, T: set)\n requires B <= U && U <= T\n ensures B <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_8526","instance":8526,"id":211869,"goal":"lemma SetUnionEmpty_8526(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_8527","instance":8527,"id":211870,"goal":"lemma SetInterEmpty_8527(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_8528","instance":8528,"id":211871,"goal":"lemma SetInterSubset_8528(S: set, B: set)\n ensures S * B <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_8529","instance":8529,"id":211872,"goal":"lemma SetCardSubset_8529(T: set, U: set)\n requires T <= U\n ensures |T| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_8530","instance":8530,"id":211873,"goal":"lemma SetUnionCard_8530(S: set, B: set)\n requires S * B == {}\n ensures |S + B| == |S| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_8531","instance":8531,"id":211874,"goal":"lemma SetUnionComm_8531(A: set, S: set)\n ensures A + S == S + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_8532","instance":8532,"id":211875,"goal":"lemma SetInterComm_8532(T: set, S: set)\n ensures T * S == S * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_8533","instance":8533,"id":211876,"goal":"lemma SetUnionAssoc_8533(B: set, S: set, U: set)\n ensures (B + S) + U == B + (S + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_8534","instance":8534,"id":211877,"goal":"lemma SetSubsetRefl_8534(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_8535","instance":8535,"id":211878,"goal":"lemma SetSubsetTrans_8535(T: set, B: set, S: set)\n requires T <= B && B <= S\n ensures T <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_8536","instance":8536,"id":211879,"goal":"lemma SetUnionEmpty_8536(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_8537","instance":8537,"id":211880,"goal":"lemma SetInterEmpty_8537(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_8538","instance":8538,"id":211881,"goal":"lemma SetInterSubset_8538(S: set, A: set)\n ensures S * A <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_8539","instance":8539,"id":211882,"goal":"lemma SetCardSubset_8539(A: set, U: set)\n requires A <= U\n ensures |A| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_8540","instance":8540,"id":211883,"goal":"lemma SetUnionCard_8540(U: set, B: set)\n requires U * B == {}\n ensures |U + B| == |U| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_8541","instance":8541,"id":211884,"goal":"lemma SetUnionComm_8541(A: set, B: set)\n ensures A + B == B + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_8542","instance":8542,"id":211885,"goal":"lemma SetInterComm_8542(S: set, T: set)\n ensures S * T == T * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_8543","instance":8543,"id":211886,"goal":"lemma SetUnionAssoc_8543(B: set, U: set, S: set)\n ensures (B + U) + S == B + (U + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_8544","instance":8544,"id":211887,"goal":"lemma SetSubsetRefl_8544(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_8545","instance":8545,"id":211888,"goal":"lemma SetSubsetTrans_8545(S: set, B: set, T: set)\n requires S <= B && B <= T\n ensures S <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_8546","instance":8546,"id":211889,"goal":"lemma SetUnionEmpty_8546(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_8547","instance":8547,"id":211890,"goal":"lemma SetInterEmpty_8547(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_8548","instance":8548,"id":211891,"goal":"lemma SetInterSubset_8548(T: set, S: set)\n ensures T * S <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_8549","instance":8549,"id":211892,"goal":"lemma SetCardSubset_8549(A: set, U: set)\n requires A <= U\n ensures |A| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_8550","instance":8550,"id":211893,"goal":"lemma SetUnionCard_8550(T: set, B: set)\n requires T * B == {}\n ensures |T + B| == |T| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_8551","instance":8551,"id":211894,"goal":"lemma SetUnionComm_8551(U: set, B: set)\n ensures U + B == B + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_8552","instance":8552,"id":211895,"goal":"lemma SetInterComm_8552(U: set, A: set)\n ensures U * A == A * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_8553","instance":8553,"id":211896,"goal":"lemma SetUnionAssoc_8553(S: set, U: set, B: set)\n ensures (S + U) + B == S + (U + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_8554","instance":8554,"id":211897,"goal":"lemma SetSubsetRefl_8554(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_8555","instance":8555,"id":211898,"goal":"lemma SetSubsetTrans_8555(B: set, U: set, S: set)\n requires B <= U && U <= S\n ensures B <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_8556","instance":8556,"id":211899,"goal":"lemma SetUnionEmpty_8556(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_8557","instance":8557,"id":211900,"goal":"lemma SetInterEmpty_8557(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_8558","instance":8558,"id":211901,"goal":"lemma SetInterSubset_8558(T: set, U: set)\n ensures T * U <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_8559","instance":8559,"id":211902,"goal":"lemma SetCardSubset_8559(T: set, S: set)\n requires T <= S\n ensures |T| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_8560","instance":8560,"id":211903,"goal":"lemma SetUnionCard_8560(U: set, T: set)\n requires U * T == {}\n ensures |U + T| == |U| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_8561","instance":8561,"id":211904,"goal":"lemma SetUnionComm_8561(B: set, S: set)\n ensures B + S == S + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_8562","instance":8562,"id":211905,"goal":"lemma SetInterComm_8562(S: set, U: set)\n ensures S * U == U * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_8563","instance":8563,"id":211906,"goal":"lemma SetUnionAssoc_8563(U: set, A: set, B: set)\n ensures (U + A) + B == U + (A + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_8564","instance":8564,"id":211907,"goal":"lemma SetSubsetRefl_8564(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_8565","instance":8565,"id":211908,"goal":"lemma SetSubsetTrans_8565(U: set, B: set, S: set)\n requires U <= B && B <= S\n ensures U <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_8566","instance":8566,"id":211909,"goal":"lemma SetUnionEmpty_8566(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_8567","instance":8567,"id":211910,"goal":"lemma SetInterEmpty_8567(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_8568","instance":8568,"id":211911,"goal":"lemma SetInterSubset_8568(U: set, T: set)\n ensures U * T <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_8569","instance":8569,"id":211912,"goal":"lemma SetCardSubset_8569(A: set, B: set)\n requires A <= B\n ensures |A| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_8570","instance":8570,"id":211913,"goal":"lemma SetUnionCard_8570(T: set, B: set)\n requires T * B == {}\n ensures |T + B| == |T| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_8571","instance":8571,"id":211914,"goal":"lemma SetUnionComm_8571(T: set, S: set)\n ensures T + S == S + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_8572","instance":8572,"id":211915,"goal":"lemma SetInterComm_8572(S: set, A: set)\n ensures S * A == A * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_8573","instance":8573,"id":211916,"goal":"lemma SetUnionAssoc_8573(B: set, A: set, T: set)\n ensures (B + A) + T == B + (A + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_8574","instance":8574,"id":211917,"goal":"lemma SetSubsetRefl_8574(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_8575","instance":8575,"id":211918,"goal":"lemma SetSubsetTrans_8575(B: set, T: set, A: set)\n requires B <= T && T <= A\n ensures B <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_8576","instance":8576,"id":211919,"goal":"lemma SetUnionEmpty_8576(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_8577","instance":8577,"id":211920,"goal":"lemma SetInterEmpty_8577(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_8578","instance":8578,"id":211921,"goal":"lemma SetInterSubset_8578(A: set, U: set)\n ensures A * U <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_8579","instance":8579,"id":211922,"goal":"lemma SetCardSubset_8579(B: set, S: set)\n requires B <= S\n ensures |B| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_8580","instance":8580,"id":211923,"goal":"lemma SetUnionCard_8580(S: set, A: set)\n requires S * A == {}\n ensures |S + A| == |S| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_8581","instance":8581,"id":211924,"goal":"lemma SetUnionComm_8581(A: set, B: set)\n ensures A + B == B + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_8582","instance":8582,"id":211925,"goal":"lemma SetInterComm_8582(A: set, B: set)\n ensures A * B == B * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_8583","instance":8583,"id":211926,"goal":"lemma SetUnionAssoc_8583(A: set, B: set, T: set)\n ensures (A + B) + T == A + (B + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_8584","instance":8584,"id":211927,"goal":"lemma SetSubsetRefl_8584(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_8585","instance":8585,"id":211928,"goal":"lemma SetSubsetTrans_8585(B: set, U: set, T: set)\n requires B <= U && U <= T\n ensures B <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_8586","instance":8586,"id":211929,"goal":"lemma SetUnionEmpty_8586(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_8587","instance":8587,"id":211930,"goal":"lemma SetInterEmpty_8587(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_8588","instance":8588,"id":211931,"goal":"lemma SetInterSubset_8588(T: set, U: set)\n ensures T * U <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_8589","instance":8589,"id":211932,"goal":"lemma SetCardSubset_8589(A: set, S: set)\n requires A <= S\n ensures |A| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_8590","instance":8590,"id":211933,"goal":"lemma SetUnionCard_8590(A: set, U: set)\n requires A * U == {}\n ensures |A + U| == |A| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_8591","instance":8591,"id":211934,"goal":"lemma SetUnionComm_8591(S: set, U: set)\n ensures S + U == U + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_8592","instance":8592,"id":211935,"goal":"lemma SetInterComm_8592(T: set, B: set)\n ensures T * B == B * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_8593","instance":8593,"id":211936,"goal":"lemma SetUnionAssoc_8593(T: set, S: set, B: set)\n ensures (T + S) + B == T + (S + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_8594","instance":8594,"id":211937,"goal":"lemma SetSubsetRefl_8594(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_8595","instance":8595,"id":211938,"goal":"lemma SetSubsetTrans_8595(U: set, T: set, B: set)\n requires U <= T && T <= B\n ensures U <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_8596","instance":8596,"id":211939,"goal":"lemma SetUnionEmpty_8596(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_8597","instance":8597,"id":211940,"goal":"lemma SetInterEmpty_8597(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_8598","instance":8598,"id":211941,"goal":"lemma SetInterSubset_8598(U: set, T: set)\n ensures U * T <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_8599","instance":8599,"id":211942,"goal":"lemma SetCardSubset_8599(U: set, A: set)\n requires U <= A\n ensures |U| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_8600","instance":8600,"id":211943,"goal":"lemma SetUnionCard_8600(A: set, S: set)\n requires A * S == {}\n ensures |A + S| == |A| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_8601","instance":8601,"id":211944,"goal":"lemma SetUnionComm_8601(T: set, A: set)\n ensures T + A == A + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_8602","instance":8602,"id":211945,"goal":"lemma SetInterComm_8602(U: set, S: set)\n ensures U * S == S * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_8603","instance":8603,"id":211946,"goal":"lemma SetUnionAssoc_8603(S: set, U: set, A: set)\n ensures (S + U) + A == S + (U + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_8604","instance":8604,"id":211947,"goal":"lemma SetSubsetRefl_8604(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_8605","instance":8605,"id":211948,"goal":"lemma SetSubsetTrans_8605(T: set, B: set, U: set)\n requires T <= B && B <= U\n ensures T <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_8606","instance":8606,"id":211949,"goal":"lemma SetUnionEmpty_8606(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_8607","instance":8607,"id":211950,"goal":"lemma SetInterEmpty_8607(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_8608","instance":8608,"id":211951,"goal":"lemma SetInterSubset_8608(U: set, A: set)\n ensures U * A <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_8609","instance":8609,"id":211952,"goal":"lemma SetCardSubset_8609(A: set, U: set)\n requires A <= U\n ensures |A| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_8610","instance":8610,"id":211953,"goal":"lemma SetUnionCard_8610(S: set, T: set)\n requires S * T == {}\n ensures |S + T| == |S| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_8611","instance":8611,"id":211954,"goal":"lemma SetUnionComm_8611(B: set, A: set)\n ensures B + A == A + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_8612","instance":8612,"id":211955,"goal":"lemma SetInterComm_8612(A: set, S: set)\n ensures A * S == S * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_8613","instance":8613,"id":211956,"goal":"lemma SetUnionAssoc_8613(B: set, T: set, U: set)\n ensures (B + T) + U == B + (T + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_8614","instance":8614,"id":211957,"goal":"lemma SetSubsetRefl_8614(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_8615","instance":8615,"id":211958,"goal":"lemma SetSubsetTrans_8615(B: set, U: set, S: set)\n requires B <= U && U <= S\n ensures B <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_8616","instance":8616,"id":211959,"goal":"lemma SetUnionEmpty_8616(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_8617","instance":8617,"id":211960,"goal":"lemma SetInterEmpty_8617(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_8618","instance":8618,"id":211961,"goal":"lemma SetInterSubset_8618(B: set, T: set)\n ensures B * T <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_8619","instance":8619,"id":211962,"goal":"lemma SetCardSubset_8619(B: set, A: set)\n requires B <= A\n ensures |B| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_8620","instance":8620,"id":211963,"goal":"lemma SetUnionCard_8620(U: set, T: set)\n requires U * T == {}\n ensures |U + T| == |U| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_8621","instance":8621,"id":211964,"goal":"lemma SetUnionComm_8621(U: set, S: set)\n ensures U + S == S + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_8622","instance":8622,"id":211965,"goal":"lemma SetInterComm_8622(B: set, T: set)\n ensures B * T == T * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_8623","instance":8623,"id":211966,"goal":"lemma SetUnionAssoc_8623(U: set, B: set, S: set)\n ensures (U + B) + S == U + (B + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_8624","instance":8624,"id":211967,"goal":"lemma SetSubsetRefl_8624(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_8625","instance":8625,"id":211968,"goal":"lemma SetSubsetTrans_8625(U: set, T: set, A: set)\n requires U <= T && T <= A\n ensures U <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_8626","instance":8626,"id":211969,"goal":"lemma SetUnionEmpty_8626(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_8627","instance":8627,"id":211970,"goal":"lemma SetInterEmpty_8627(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_8628","instance":8628,"id":211971,"goal":"lemma SetInterSubset_8628(U: set, B: set)\n ensures U * B <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_8629","instance":8629,"id":211972,"goal":"lemma SetCardSubset_8629(A: set, U: set)\n requires A <= U\n ensures |A| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_8630","instance":8630,"id":211973,"goal":"lemma SetUnionCard_8630(A: set, B: set)\n requires A * B == {}\n ensures |A + B| == |A| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_8631","instance":8631,"id":211974,"goal":"lemma SetUnionComm_8631(B: set, T: set)\n ensures B + T == T + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_8632","instance":8632,"id":211975,"goal":"lemma SetInterComm_8632(T: set, S: set)\n ensures T * S == S * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_8633","instance":8633,"id":211976,"goal":"lemma SetUnionAssoc_8633(U: set, S: set, T: set)\n ensures (U + S) + T == U + (S + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_8634","instance":8634,"id":211977,"goal":"lemma SetSubsetRefl_8634(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_8635","instance":8635,"id":211978,"goal":"lemma SetSubsetTrans_8635(B: set, S: set, T: set)\n requires B <= S && S <= T\n ensures B <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_8636","instance":8636,"id":211979,"goal":"lemma SetUnionEmpty_8636(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_8637","instance":8637,"id":211980,"goal":"lemma SetInterEmpty_8637(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_8638","instance":8638,"id":211981,"goal":"lemma SetInterSubset_8638(B: set, U: set)\n ensures B * U <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_8639","instance":8639,"id":211982,"goal":"lemma SetCardSubset_8639(T: set, B: set)\n requires T <= B\n ensures |T| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_8640","instance":8640,"id":211983,"goal":"lemma SetUnionCard_8640(T: set, A: set)\n requires T * A == {}\n ensures |T + A| == |T| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_8641","instance":8641,"id":211984,"goal":"lemma SetUnionComm_8641(T: set, B: set)\n ensures T + B == B + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_8642","instance":8642,"id":211985,"goal":"lemma SetInterComm_8642(B: set, S: set)\n ensures B * S == S * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_8643","instance":8643,"id":211986,"goal":"lemma SetUnionAssoc_8643(B: set, A: set, U: set)\n ensures (B + A) + U == B + (A + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_8644","instance":8644,"id":211987,"goal":"lemma SetSubsetRefl_8644(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_8645","instance":8645,"id":211988,"goal":"lemma SetSubsetTrans_8645(U: set, A: set, B: set)\n requires U <= A && A <= B\n ensures U <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_8646","instance":8646,"id":211989,"goal":"lemma SetUnionEmpty_8646(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_8647","instance":8647,"id":211990,"goal":"lemma SetInterEmpty_8647(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_8648","instance":8648,"id":211991,"goal":"lemma SetInterSubset_8648(A: set, B: set)\n ensures A * B <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_8649","instance":8649,"id":211992,"goal":"lemma SetCardSubset_8649(U: set, A: set)\n requires U <= A\n ensures |U| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_8650","instance":8650,"id":211993,"goal":"lemma SetUnionCard_8650(B: set, T: set)\n requires B * T == {}\n ensures |B + T| == |B| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_8651","instance":8651,"id":211994,"goal":"lemma SetUnionComm_8651(B: set, S: set)\n ensures B + S == S + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_8652","instance":8652,"id":211995,"goal":"lemma SetInterComm_8652(U: set, B: set)\n ensures U * B == B * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_8653","instance":8653,"id":211996,"goal":"lemma SetUnionAssoc_8653(U: set, A: set, B: set)\n ensures (U + A) + B == U + (A + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_8654","instance":8654,"id":211997,"goal":"lemma SetSubsetRefl_8654(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_8655","instance":8655,"id":211998,"goal":"lemma SetSubsetTrans_8655(U: set, S: set, B: set)\n requires U <= S && S <= B\n ensures U <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_8656","instance":8656,"id":211999,"goal":"lemma SetUnionEmpty_8656(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_8657","instance":8657,"id":212000,"goal":"lemma SetInterEmpty_8657(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_8658","instance":8658,"id":212001,"goal":"lemma SetInterSubset_8658(A: set, U: set)\n ensures A * U <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_8659","instance":8659,"id":212002,"goal":"lemma SetCardSubset_8659(U: set, T: set)\n requires U <= T\n ensures |U| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_8660","instance":8660,"id":212003,"goal":"lemma SetUnionCard_8660(B: set, T: set)\n requires B * T == {}\n ensures |B + T| == |B| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_8661","instance":8661,"id":212004,"goal":"lemma SetUnionComm_8661(U: set, T: set)\n ensures U + T == T + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_8662","instance":8662,"id":212005,"goal":"lemma SetInterComm_8662(T: set, B: set)\n ensures T * B == B * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_8663","instance":8663,"id":212006,"goal":"lemma SetUnionAssoc_8663(U: set, S: set, A: set)\n ensures (U + S) + A == U + (S + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_8664","instance":8664,"id":212007,"goal":"lemma SetSubsetRefl_8664(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_8665","instance":8665,"id":212008,"goal":"lemma SetSubsetTrans_8665(T: set, S: set, B: set)\n requires T <= S && S <= B\n ensures T <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_8666","instance":8666,"id":212009,"goal":"lemma SetUnionEmpty_8666(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_8667","instance":8667,"id":212010,"goal":"lemma SetInterEmpty_8667(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_8668","instance":8668,"id":212011,"goal":"lemma SetInterSubset_8668(U: set, A: set)\n ensures U * A <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_8669","instance":8669,"id":212012,"goal":"lemma SetCardSubset_8669(B: set, A: set)\n requires B <= A\n ensures |B| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_8670","instance":8670,"id":212013,"goal":"lemma SetUnionCard_8670(S: set, U: set)\n requires S * U == {}\n ensures |S + U| == |S| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_8671","instance":8671,"id":212014,"goal":"lemma SetUnionComm_8671(U: set, T: set)\n ensures U + T == T + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_8672","instance":8672,"id":212015,"goal":"lemma SetInterComm_8672(B: set, U: set)\n ensures B * U == U * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_8673","instance":8673,"id":212016,"goal":"lemma SetUnionAssoc_8673(A: set, T: set, S: set)\n ensures (A + T) + S == A + (T + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_8674","instance":8674,"id":212017,"goal":"lemma SetSubsetRefl_8674(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_8675","instance":8675,"id":212018,"goal":"lemma SetSubsetTrans_8675(A: set, U: set, S: set)\n requires A <= U && U <= S\n ensures A <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_8676","instance":8676,"id":212019,"goal":"lemma SetUnionEmpty_8676(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_8677","instance":8677,"id":212020,"goal":"lemma SetInterEmpty_8677(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_8678","instance":8678,"id":212021,"goal":"lemma SetInterSubset_8678(U: set, A: set)\n ensures U * A <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_8679","instance":8679,"id":212022,"goal":"lemma SetCardSubset_8679(A: set, U: set)\n requires A <= U\n ensures |A| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_8680","instance":8680,"id":212023,"goal":"lemma SetUnionCard_8680(A: set, S: set)\n requires A * S == {}\n ensures |A + S| == |A| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_8681","instance":8681,"id":212024,"goal":"lemma SetUnionComm_8681(B: set, S: set)\n ensures B + S == S + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_8682","instance":8682,"id":212025,"goal":"lemma SetInterComm_8682(U: set, S: set)\n ensures U * S == S * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_8683","instance":8683,"id":212026,"goal":"lemma SetUnionAssoc_8683(B: set, A: set, S: set)\n ensures (B + A) + S == B + (A + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_8684","instance":8684,"id":212027,"goal":"lemma SetSubsetRefl_8684(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_8685","instance":8685,"id":212028,"goal":"lemma SetSubsetTrans_8685(U: set, T: set, S: set)\n requires U <= T && T <= S\n ensures U <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_8686","instance":8686,"id":212029,"goal":"lemma SetUnionEmpty_8686(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_8687","instance":8687,"id":212030,"goal":"lemma SetInterEmpty_8687(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_8688","instance":8688,"id":212031,"goal":"lemma SetInterSubset_8688(B: set, U: set)\n ensures B * U <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_8689","instance":8689,"id":212032,"goal":"lemma SetCardSubset_8689(A: set, U: set)\n requires A <= U\n ensures |A| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_8690","instance":8690,"id":212033,"goal":"lemma SetUnionCard_8690(B: set, S: set)\n requires B * S == {}\n ensures |B + S| == |B| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_8691","instance":8691,"id":212034,"goal":"lemma SetUnionComm_8691(B: set, S: set)\n ensures B + S == S + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_8692","instance":8692,"id":212035,"goal":"lemma SetInterComm_8692(T: set, A: set)\n ensures T * A == A * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_8693","instance":8693,"id":212036,"goal":"lemma SetUnionAssoc_8693(A: set, B: set, U: set)\n ensures (A + B) + U == A + (B + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_8694","instance":8694,"id":212037,"goal":"lemma SetSubsetRefl_8694(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_8695","instance":8695,"id":212038,"goal":"lemma SetSubsetTrans_8695(S: set, B: set, A: set)\n requires S <= B && B <= A\n ensures S <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_8696","instance":8696,"id":212039,"goal":"lemma SetUnionEmpty_8696(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_8697","instance":8697,"id":212040,"goal":"lemma SetInterEmpty_8697(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_8698","instance":8698,"id":212041,"goal":"lemma SetInterSubset_8698(S: set, B: set)\n ensures S * B <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_8699","instance":8699,"id":212042,"goal":"lemma SetCardSubset_8699(T: set, B: set)\n requires T <= B\n ensures |T| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_8700","instance":8700,"id":212043,"goal":"lemma SetUnionCard_8700(S: set, T: set)\n requires S * T == {}\n ensures |S + T| == |S| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_8701","instance":8701,"id":212044,"goal":"lemma SetUnionComm_8701(B: set, S: set)\n ensures B + S == S + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_8702","instance":8702,"id":212045,"goal":"lemma SetInterComm_8702(B: set, A: set)\n ensures B * A == A * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_8703","instance":8703,"id":212046,"goal":"lemma SetUnionAssoc_8703(A: set, U: set, B: set)\n ensures (A + U) + B == A + (U + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_8704","instance":8704,"id":212047,"goal":"lemma SetSubsetRefl_8704(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_8705","instance":8705,"id":212048,"goal":"lemma SetSubsetTrans_8705(A: set, U: set, S: set)\n requires A <= U && U <= S\n ensures A <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_8706","instance":8706,"id":212049,"goal":"lemma SetUnionEmpty_8706(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_8707","instance":8707,"id":212050,"goal":"lemma SetInterEmpty_8707(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_8708","instance":8708,"id":212051,"goal":"lemma SetInterSubset_8708(B: set, A: set)\n ensures B * A <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_8709","instance":8709,"id":212052,"goal":"lemma SetCardSubset_8709(S: set, T: set)\n requires S <= T\n ensures |S| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_8710","instance":8710,"id":212053,"goal":"lemma SetUnionCard_8710(S: set, U: set)\n requires S * U == {}\n ensures |S + U| == |S| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_8711","instance":8711,"id":212054,"goal":"lemma SetUnionComm_8711(B: set, U: set)\n ensures B + U == U + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_8712","instance":8712,"id":212055,"goal":"lemma SetInterComm_8712(T: set, U: set)\n ensures T * U == U * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_8713","instance":8713,"id":212056,"goal":"lemma SetUnionAssoc_8713(S: set, B: set, A: set)\n ensures (S + B) + A == S + (B + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_8714","instance":8714,"id":212057,"goal":"lemma SetSubsetRefl_8714(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_8715","instance":8715,"id":212058,"goal":"lemma SetSubsetTrans_8715(S: set, T: set, A: set)\n requires S <= T && T <= A\n ensures S <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_8716","instance":8716,"id":212059,"goal":"lemma SetUnionEmpty_8716(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_8717","instance":8717,"id":212060,"goal":"lemma SetInterEmpty_8717(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_8718","instance":8718,"id":212061,"goal":"lemma SetInterSubset_8718(T: set, A: set)\n ensures T * A <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_8719","instance":8719,"id":212062,"goal":"lemma SetCardSubset_8719(A: set, T: set)\n requires A <= T\n ensures |A| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_8720","instance":8720,"id":212063,"goal":"lemma SetUnionCard_8720(A: set, T: set)\n requires A * T == {}\n ensures |A + T| == |A| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_8721","instance":8721,"id":212064,"goal":"lemma SetUnionComm_8721(U: set, T: set)\n ensures U + T == T + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_8722","instance":8722,"id":212065,"goal":"lemma SetInterComm_8722(A: set, B: set)\n ensures A * B == B * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_8723","instance":8723,"id":212066,"goal":"lemma SetUnionAssoc_8723(A: set, U: set, S: set)\n ensures (A + U) + S == A + (U + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_8724","instance":8724,"id":212067,"goal":"lemma SetSubsetRefl_8724(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_8725","instance":8725,"id":212068,"goal":"lemma SetSubsetTrans_8725(U: set, B: set, A: set)\n requires U <= B && B <= A\n ensures U <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_8726","instance":8726,"id":212069,"goal":"lemma SetUnionEmpty_8726(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_8727","instance":8727,"id":212070,"goal":"lemma SetInterEmpty_8727(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_8728","instance":8728,"id":212071,"goal":"lemma SetInterSubset_8728(U: set, T: set)\n ensures U * T <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_8729","instance":8729,"id":212072,"goal":"lemma SetCardSubset_8729(U: set, T: set)\n requires U <= T\n ensures |U| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_8730","instance":8730,"id":212073,"goal":"lemma SetUnionCard_8730(B: set, T: set)\n requires B * T == {}\n ensures |B + T| == |B| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_8731","instance":8731,"id":212074,"goal":"lemma SetUnionComm_8731(A: set, S: set)\n ensures A + S == S + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_8732","instance":8732,"id":212075,"goal":"lemma SetInterComm_8732(T: set, A: set)\n ensures T * A == A * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_8733","instance":8733,"id":212076,"goal":"lemma SetUnionAssoc_8733(A: set, B: set, T: set)\n ensures (A + B) + T == A + (B + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_8734","instance":8734,"id":212077,"goal":"lemma SetSubsetRefl_8734(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_8735","instance":8735,"id":212078,"goal":"lemma SetSubsetTrans_8735(B: set, T: set, S: set)\n requires B <= T && T <= S\n ensures B <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_8736","instance":8736,"id":212079,"goal":"lemma SetUnionEmpty_8736(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_8737","instance":8737,"id":212080,"goal":"lemma SetInterEmpty_8737(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_8738","instance":8738,"id":212081,"goal":"lemma SetInterSubset_8738(T: set, S: set)\n ensures T * S <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_8739","instance":8739,"id":212082,"goal":"lemma SetCardSubset_8739(A: set, B: set)\n requires A <= B\n ensures |A| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_8740","instance":8740,"id":212083,"goal":"lemma SetUnionCard_8740(T: set, A: set)\n requires T * A == {}\n ensures |T + A| == |T| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_8741","instance":8741,"id":212084,"goal":"lemma SetUnionComm_8741(U: set, B: set)\n ensures U + B == B + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_8742","instance":8742,"id":212085,"goal":"lemma SetInterComm_8742(U: set, B: set)\n ensures U * B == B * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_8743","instance":8743,"id":212086,"goal":"lemma SetUnionAssoc_8743(S: set, B: set, A: set)\n ensures (S + B) + A == S + (B + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_8744","instance":8744,"id":212087,"goal":"lemma SetSubsetRefl_8744(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_8745","instance":8745,"id":212088,"goal":"lemma SetSubsetTrans_8745(A: set, T: set, S: set)\n requires A <= T && T <= S\n ensures A <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_8746","instance":8746,"id":212089,"goal":"lemma SetUnionEmpty_8746(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_8747","instance":8747,"id":212090,"goal":"lemma SetInterEmpty_8747(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_8748","instance":8748,"id":212091,"goal":"lemma SetInterSubset_8748(A: set, B: set)\n ensures A * B <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_8749","instance":8749,"id":212092,"goal":"lemma SetCardSubset_8749(S: set, U: set)\n requires S <= U\n ensures |S| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_8750","instance":8750,"id":212093,"goal":"lemma SetUnionCard_8750(S: set, U: set)\n requires S * U == {}\n ensures |S + U| == |S| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_8751","instance":8751,"id":212094,"goal":"lemma SetUnionComm_8751(T: set, B: set)\n ensures T + B == B + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_8752","instance":8752,"id":212095,"goal":"lemma SetInterComm_8752(B: set, S: set)\n ensures B * S == S * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_8753","instance":8753,"id":212096,"goal":"lemma SetUnionAssoc_8753(B: set, U: set, A: set)\n ensures (B + U) + A == B + (U + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_8754","instance":8754,"id":212097,"goal":"lemma SetSubsetRefl_8754(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_8755","instance":8755,"id":212098,"goal":"lemma SetSubsetTrans_8755(A: set, B: set, T: set)\n requires A <= B && B <= T\n ensures A <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_8756","instance":8756,"id":212099,"goal":"lemma SetUnionEmpty_8756(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_8757","instance":8757,"id":212100,"goal":"lemma SetInterEmpty_8757(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_8758","instance":8758,"id":212101,"goal":"lemma SetInterSubset_8758(B: set, T: set)\n ensures B * T <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_8759","instance":8759,"id":212102,"goal":"lemma SetCardSubset_8759(T: set, A: set)\n requires T <= A\n ensures |T| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_8760","instance":8760,"id":212103,"goal":"lemma SetUnionCard_8760(T: set, U: set)\n requires T * U == {}\n ensures |T + U| == |T| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_8761","instance":8761,"id":212104,"goal":"lemma SetUnionComm_8761(A: set, B: set)\n ensures A + B == B + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_8762","instance":8762,"id":212105,"goal":"lemma SetInterComm_8762(S: set, A: set)\n ensures S * A == A * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_8763","instance":8763,"id":212106,"goal":"lemma SetUnionAssoc_8763(T: set, U: set, B: set)\n ensures (T + U) + B == T + (U + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_8764","instance":8764,"id":212107,"goal":"lemma SetSubsetRefl_8764(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_8765","instance":8765,"id":212108,"goal":"lemma SetSubsetTrans_8765(U: set, B: set, T: set)\n requires U <= B && B <= T\n ensures U <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_8766","instance":8766,"id":212109,"goal":"lemma SetUnionEmpty_8766(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_8767","instance":8767,"id":212110,"goal":"lemma SetInterEmpty_8767(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_8768","instance":8768,"id":212111,"goal":"lemma SetInterSubset_8768(B: set, S: set)\n ensures B * S <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_8769","instance":8769,"id":212112,"goal":"lemma SetCardSubset_8769(B: set, A: set)\n requires B <= A\n ensures |B| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_8770","instance":8770,"id":212113,"goal":"lemma SetUnionCard_8770(A: set, S: set)\n requires A * S == {}\n ensures |A + S| == |A| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_8771","instance":8771,"id":212114,"goal":"lemma SetUnionComm_8771(T: set, B: set)\n ensures T + B == B + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_8772","instance":8772,"id":212115,"goal":"lemma SetInterComm_8772(B: set, S: set)\n ensures B * S == S * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_8773","instance":8773,"id":212116,"goal":"lemma SetUnionAssoc_8773(T: set, B: set, A: set)\n ensures (T + B) + A == T + (B + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_8774","instance":8774,"id":212117,"goal":"lemma SetSubsetRefl_8774(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_8775","instance":8775,"id":212118,"goal":"lemma SetSubsetTrans_8775(T: set, B: set, A: set)\n requires T <= B && B <= A\n ensures T <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_8776","instance":8776,"id":212119,"goal":"lemma SetUnionEmpty_8776(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_8777","instance":8777,"id":212120,"goal":"lemma SetInterEmpty_8777(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_8778","instance":8778,"id":212121,"goal":"lemma SetInterSubset_8778(U: set, T: set)\n ensures U * T <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_8779","instance":8779,"id":212122,"goal":"lemma SetCardSubset_8779(A: set, B: set)\n requires A <= B\n ensures |A| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_8780","instance":8780,"id":212123,"goal":"lemma SetUnionCard_8780(B: set, T: set)\n requires B * T == {}\n ensures |B + T| == |B| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_8781","instance":8781,"id":212124,"goal":"lemma SetUnionComm_8781(S: set, B: set)\n ensures S + B == B + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_8782","instance":8782,"id":212125,"goal":"lemma SetInterComm_8782(A: set, T: set)\n ensures A * T == T * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_8783","instance":8783,"id":212126,"goal":"lemma SetUnionAssoc_8783(A: set, S: set, B: set)\n ensures (A + S) + B == A + (S + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_8784","instance":8784,"id":212127,"goal":"lemma SetSubsetRefl_8784(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_8785","instance":8785,"id":212128,"goal":"lemma SetSubsetTrans_8785(A: set, S: set, B: set)\n requires A <= S && S <= B\n ensures A <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_8786","instance":8786,"id":212129,"goal":"lemma SetUnionEmpty_8786(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_8787","instance":8787,"id":212130,"goal":"lemma SetInterEmpty_8787(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_8788","instance":8788,"id":212131,"goal":"lemma SetInterSubset_8788(B: set, A: set)\n ensures B * A <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_8789","instance":8789,"id":212132,"goal":"lemma SetCardSubset_8789(U: set, B: set)\n requires U <= B\n ensures |U| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_8790","instance":8790,"id":212133,"goal":"lemma SetUnionCard_8790(A: set, U: set)\n requires A * U == {}\n ensures |A + U| == |A| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_8791","instance":8791,"id":212134,"goal":"lemma SetUnionComm_8791(U: set, B: set)\n ensures U + B == B + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_8792","instance":8792,"id":212135,"goal":"lemma SetInterComm_8792(T: set, U: set)\n ensures T * U == U * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_8793","instance":8793,"id":212136,"goal":"lemma SetUnionAssoc_8793(A: set, U: set, B: set)\n ensures (A + U) + B == A + (U + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_8794","instance":8794,"id":212137,"goal":"lemma SetSubsetRefl_8794(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_8795","instance":8795,"id":212138,"goal":"lemma SetSubsetTrans_8795(A: set, B: set, T: set)\n requires A <= B && B <= T\n ensures A <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_8796","instance":8796,"id":212139,"goal":"lemma SetUnionEmpty_8796(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_8797","instance":8797,"id":212140,"goal":"lemma SetInterEmpty_8797(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_8798","instance":8798,"id":212141,"goal":"lemma SetInterSubset_8798(A: set, S: set)\n ensures A * S <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_8799","instance":8799,"id":212142,"goal":"lemma SetCardSubset_8799(A: set, B: set)\n requires A <= B\n ensures |A| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_8800","instance":8800,"id":212143,"goal":"lemma SetUnionCard_8800(T: set, U: set)\n requires T * U == {}\n ensures |T + U| == |T| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_8801","instance":8801,"id":212144,"goal":"lemma SetUnionComm_8801(A: set, B: set)\n ensures A + B == B + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_8802","instance":8802,"id":212145,"goal":"lemma SetInterComm_8802(B: set, A: set)\n ensures B * A == A * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_8803","instance":8803,"id":212146,"goal":"lemma SetUnionAssoc_8803(U: set, A: set, S: set)\n ensures (U + A) + S == U + (A + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_8804","instance":8804,"id":212147,"goal":"lemma SetSubsetRefl_8804(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_8805","instance":8805,"id":212148,"goal":"lemma SetSubsetTrans_8805(S: set, B: set, A: set)\n requires S <= B && B <= A\n ensures S <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_8806","instance":8806,"id":212149,"goal":"lemma SetUnionEmpty_8806(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_8807","instance":8807,"id":212150,"goal":"lemma SetInterEmpty_8807(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_8808","instance":8808,"id":212151,"goal":"lemma SetInterSubset_8808(S: set, T: set)\n ensures S * T <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_8809","instance":8809,"id":212152,"goal":"lemma SetCardSubset_8809(S: set, T: set)\n requires S <= T\n ensures |S| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_8810","instance":8810,"id":212153,"goal":"lemma SetUnionCard_8810(A: set, T: set)\n requires A * T == {}\n ensures |A + T| == |A| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_8811","instance":8811,"id":212154,"goal":"lemma SetUnionComm_8811(B: set, T: set)\n ensures B + T == T + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_8812","instance":8812,"id":212155,"goal":"lemma SetInterComm_8812(B: set, A: set)\n ensures B * A == A * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_8813","instance":8813,"id":212156,"goal":"lemma SetUnionAssoc_8813(B: set, S: set, T: set)\n ensures (B + S) + T == B + (S + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_8814","instance":8814,"id":212157,"goal":"lemma SetSubsetRefl_8814(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_8815","instance":8815,"id":212158,"goal":"lemma SetSubsetTrans_8815(T: set, A: set, B: set)\n requires T <= A && A <= B\n ensures T <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_8816","instance":8816,"id":212159,"goal":"lemma SetUnionEmpty_8816(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_8817","instance":8817,"id":212160,"goal":"lemma SetInterEmpty_8817(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_8818","instance":8818,"id":212161,"goal":"lemma SetInterSubset_8818(U: set, S: set)\n ensures U * S <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_8819","instance":8819,"id":212162,"goal":"lemma SetCardSubset_8819(U: set, A: set)\n requires U <= A\n ensures |U| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_8820","instance":8820,"id":212163,"goal":"lemma SetUnionCard_8820(S: set, T: set)\n requires S * T == {}\n ensures |S + T| == |S| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_8821","instance":8821,"id":212164,"goal":"lemma SetUnionComm_8821(S: set, T: set)\n ensures S + T == T + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_8822","instance":8822,"id":212165,"goal":"lemma SetInterComm_8822(A: set, U: set)\n ensures A * U == U * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_8823","instance":8823,"id":212166,"goal":"lemma SetUnionAssoc_8823(U: set, B: set, T: set)\n ensures (U + B) + T == U + (B + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_8824","instance":8824,"id":212167,"goal":"lemma SetSubsetRefl_8824(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_8825","instance":8825,"id":212168,"goal":"lemma SetSubsetTrans_8825(S: set, T: set, U: set)\n requires S <= T && T <= U\n ensures S <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_8826","instance":8826,"id":212169,"goal":"lemma SetUnionEmpty_8826(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_8827","instance":8827,"id":212170,"goal":"lemma SetInterEmpty_8827(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_8828","instance":8828,"id":212171,"goal":"lemma SetInterSubset_8828(S: set, A: set)\n ensures S * A <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_8829","instance":8829,"id":212172,"goal":"lemma SetCardSubset_8829(U: set, B: set)\n requires U <= B\n ensures |U| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_8830","instance":8830,"id":212173,"goal":"lemma SetUnionCard_8830(A: set, T: set)\n requires A * T == {}\n ensures |A + T| == |A| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_8831","instance":8831,"id":212174,"goal":"lemma SetUnionComm_8831(U: set, A: set)\n ensures U + A == A + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_8832","instance":8832,"id":212175,"goal":"lemma SetInterComm_8832(B: set, U: set)\n ensures B * U == U * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_8833","instance":8833,"id":212176,"goal":"lemma SetUnionAssoc_8833(S: set, U: set, A: set)\n ensures (S + U) + A == S + (U + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_8834","instance":8834,"id":212177,"goal":"lemma SetSubsetRefl_8834(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_8835","instance":8835,"id":212178,"goal":"lemma SetSubsetTrans_8835(T: set, S: set, U: set)\n requires T <= S && S <= U\n ensures T <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_8836","instance":8836,"id":212179,"goal":"lemma SetUnionEmpty_8836(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_8837","instance":8837,"id":212180,"goal":"lemma SetInterEmpty_8837(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_8838","instance":8838,"id":212181,"goal":"lemma SetInterSubset_8838(T: set, B: set)\n ensures T * B <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_8839","instance":8839,"id":212182,"goal":"lemma SetCardSubset_8839(A: set, B: set)\n requires A <= B\n ensures |A| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_8840","instance":8840,"id":212183,"goal":"lemma SetUnionCard_8840(U: set, A: set)\n requires U * A == {}\n ensures |U + A| == |U| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_8841","instance":8841,"id":212184,"goal":"lemma SetUnionComm_8841(S: set, T: set)\n ensures S + T == T + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_8842","instance":8842,"id":212185,"goal":"lemma SetInterComm_8842(T: set, B: set)\n ensures T * B == B * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_8843","instance":8843,"id":212186,"goal":"lemma SetUnionAssoc_8843(U: set, B: set, T: set)\n ensures (U + B) + T == U + (B + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_8844","instance":8844,"id":212187,"goal":"lemma SetSubsetRefl_8844(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_8845","instance":8845,"id":212188,"goal":"lemma SetSubsetTrans_8845(T: set, U: set, B: set)\n requires T <= U && U <= B\n ensures T <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_8846","instance":8846,"id":212189,"goal":"lemma SetUnionEmpty_8846(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_8847","instance":8847,"id":212190,"goal":"lemma SetInterEmpty_8847(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_8848","instance":8848,"id":212191,"goal":"lemma SetInterSubset_8848(B: set, T: set)\n ensures B * T <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_8849","instance":8849,"id":212192,"goal":"lemma SetCardSubset_8849(T: set, B: set)\n requires T <= B\n ensures |T| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_8850","instance":8850,"id":212193,"goal":"lemma SetUnionCard_8850(B: set, U: set)\n requires B * U == {}\n ensures |B + U| == |B| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_8851","instance":8851,"id":212194,"goal":"lemma SetUnionComm_8851(U: set, T: set)\n ensures U + T == T + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_8852","instance":8852,"id":212195,"goal":"lemma SetInterComm_8852(S: set, U: set)\n ensures S * U == U * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_8853","instance":8853,"id":212196,"goal":"lemma SetUnionAssoc_8853(T: set, B: set, S: set)\n ensures (T + B) + S == T + (B + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_8854","instance":8854,"id":212197,"goal":"lemma SetSubsetRefl_8854(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_8855","instance":8855,"id":212198,"goal":"lemma SetSubsetTrans_8855(S: set, T: set, A: set)\n requires S <= T && T <= A\n ensures S <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_8856","instance":8856,"id":212199,"goal":"lemma SetUnionEmpty_8856(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_8857","instance":8857,"id":212200,"goal":"lemma SetInterEmpty_8857(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_8858","instance":8858,"id":212201,"goal":"lemma SetInterSubset_8858(S: set, A: set)\n ensures S * A <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_8859","instance":8859,"id":212202,"goal":"lemma SetCardSubset_8859(S: set, T: set)\n requires S <= T\n ensures |S| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_8860","instance":8860,"id":212203,"goal":"lemma SetUnionCard_8860(B: set, A: set)\n requires B * A == {}\n ensures |B + A| == |B| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_8861","instance":8861,"id":212204,"goal":"lemma SetUnionComm_8861(T: set, B: set)\n ensures T + B == B + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_8862","instance":8862,"id":212205,"goal":"lemma SetInterComm_8862(U: set, T: set)\n ensures U * T == T * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_8863","instance":8863,"id":212206,"goal":"lemma SetUnionAssoc_8863(B: set, S: set, A: set)\n ensures (B + S) + A == B + (S + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_8864","instance":8864,"id":212207,"goal":"lemma SetSubsetRefl_8864(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_8865","instance":8865,"id":212208,"goal":"lemma SetSubsetTrans_8865(T: set, A: set, U: set)\n requires T <= A && A <= U\n ensures T <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_8866","instance":8866,"id":212209,"goal":"lemma SetUnionEmpty_8866(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_8867","instance":8867,"id":212210,"goal":"lemma SetInterEmpty_8867(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_8868","instance":8868,"id":212211,"goal":"lemma SetInterSubset_8868(T: set, U: set)\n ensures T * U <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_8869","instance":8869,"id":212212,"goal":"lemma SetCardSubset_8869(U: set, S: set)\n requires U <= S\n ensures |U| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_8870","instance":8870,"id":212213,"goal":"lemma SetUnionCard_8870(S: set, B: set)\n requires S * B == {}\n ensures |S + B| == |S| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_8871","instance":8871,"id":212214,"goal":"lemma SetUnionComm_8871(S: set, U: set)\n ensures S + U == U + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_8872","instance":8872,"id":212215,"goal":"lemma SetInterComm_8872(A: set, B: set)\n ensures A * B == B * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_8873","instance":8873,"id":212216,"goal":"lemma SetUnionAssoc_8873(S: set, T: set, B: set)\n ensures (S + T) + B == S + (T + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_8874","instance":8874,"id":212217,"goal":"lemma SetSubsetRefl_8874(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_8875","instance":8875,"id":212218,"goal":"lemma SetSubsetTrans_8875(T: set, U: set, A: set)\n requires T <= U && U <= A\n ensures T <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_8876","instance":8876,"id":212219,"goal":"lemma SetUnionEmpty_8876(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_8877","instance":8877,"id":212220,"goal":"lemma SetInterEmpty_8877(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_8878","instance":8878,"id":212221,"goal":"lemma SetInterSubset_8878(B: set, T: set)\n ensures B * T <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_8879","instance":8879,"id":212222,"goal":"lemma SetCardSubset_8879(S: set, T: set)\n requires S <= T\n ensures |S| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_8880","instance":8880,"id":212223,"goal":"lemma SetUnionCard_8880(U: set, S: set)\n requires U * S == {}\n ensures |U + S| == |U| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_8881","instance":8881,"id":212224,"goal":"lemma SetUnionComm_8881(A: set, T: set)\n ensures A + T == T + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_8882","instance":8882,"id":212225,"goal":"lemma SetInterComm_8882(A: set, B: set)\n ensures A * B == B * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_8883","instance":8883,"id":212226,"goal":"lemma SetUnionAssoc_8883(T: set, A: set, U: set)\n ensures (T + A) + U == T + (A + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_8884","instance":8884,"id":212227,"goal":"lemma SetSubsetRefl_8884(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_8885","instance":8885,"id":212228,"goal":"lemma SetSubsetTrans_8885(U: set, A: set, S: set)\n requires U <= A && A <= S\n ensures U <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_8886","instance":8886,"id":212229,"goal":"lemma SetUnionEmpty_8886(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_8887","instance":8887,"id":212230,"goal":"lemma SetInterEmpty_8887(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_8888","instance":8888,"id":212231,"goal":"lemma SetInterSubset_8888(U: set, S: set)\n ensures U * S <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_8889","instance":8889,"id":212232,"goal":"lemma SetCardSubset_8889(B: set, T: set)\n requires B <= T\n ensures |B| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_8890","instance":8890,"id":212233,"goal":"lemma SetUnionCard_8890(A: set, B: set)\n requires A * B == {}\n ensures |A + B| == |A| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_8891","instance":8891,"id":212234,"goal":"lemma SetUnionComm_8891(A: set, T: set)\n ensures A + T == T + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_8892","instance":8892,"id":212235,"goal":"lemma SetInterComm_8892(A: set, B: set)\n ensures A * B == B * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_8893","instance":8893,"id":212236,"goal":"lemma SetUnionAssoc_8893(U: set, A: set, B: set)\n ensures (U + A) + B == U + (A + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_8894","instance":8894,"id":212237,"goal":"lemma SetSubsetRefl_8894(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_8895","instance":8895,"id":212238,"goal":"lemma SetSubsetTrans_8895(A: set, U: set, T: set)\n requires A <= U && U <= T\n ensures A <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_8896","instance":8896,"id":212239,"goal":"lemma SetUnionEmpty_8896(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_8897","instance":8897,"id":212240,"goal":"lemma SetInterEmpty_8897(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_8898","instance":8898,"id":212241,"goal":"lemma SetInterSubset_8898(U: set, S: set)\n ensures U * S <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_8899","instance":8899,"id":212242,"goal":"lemma SetCardSubset_8899(S: set, B: set)\n requires S <= B\n ensures |S| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_8900","instance":8900,"id":212243,"goal":"lemma SetUnionCard_8900(B: set, A: set)\n requires B * A == {}\n ensures |B + A| == |B| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_8901","instance":8901,"id":212244,"goal":"lemma SetUnionComm_8901(B: set, T: set)\n ensures B + T == T + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_8902","instance":8902,"id":212245,"goal":"lemma SetInterComm_8902(T: set, A: set)\n ensures T * A == A * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_8903","instance":8903,"id":212246,"goal":"lemma SetUnionAssoc_8903(A: set, U: set, B: set)\n ensures (A + U) + B == A + (U + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_8904","instance":8904,"id":212247,"goal":"lemma SetSubsetRefl_8904(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_8905","instance":8905,"id":212248,"goal":"lemma SetSubsetTrans_8905(B: set, T: set, A: set)\n requires B <= T && T <= A\n ensures B <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_8906","instance":8906,"id":212249,"goal":"lemma SetUnionEmpty_8906(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_8907","instance":8907,"id":212250,"goal":"lemma SetInterEmpty_8907(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_8908","instance":8908,"id":212251,"goal":"lemma SetInterSubset_8908(U: set, A: set)\n ensures U * A <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_8909","instance":8909,"id":212252,"goal":"lemma SetCardSubset_8909(A: set, S: set)\n requires A <= S\n ensures |A| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_8910","instance":8910,"id":212253,"goal":"lemma SetUnionCard_8910(S: set, B: set)\n requires S * B == {}\n ensures |S + B| == |S| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_8911","instance":8911,"id":212254,"goal":"lemma SetUnionComm_8911(B: set, S: set)\n ensures B + S == S + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_8912","instance":8912,"id":212255,"goal":"lemma SetInterComm_8912(U: set, A: set)\n ensures U * A == A * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_8913","instance":8913,"id":212256,"goal":"lemma SetUnionAssoc_8913(T: set, U: set, A: set)\n ensures (T + U) + A == T + (U + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_8914","instance":8914,"id":212257,"goal":"lemma SetSubsetRefl_8914(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_8915","instance":8915,"id":212258,"goal":"lemma SetSubsetTrans_8915(B: set, A: set, S: set)\n requires B <= A && A <= S\n ensures B <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_8916","instance":8916,"id":212259,"goal":"lemma SetUnionEmpty_8916(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_8917","instance":8917,"id":212260,"goal":"lemma SetInterEmpty_8917(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_8918","instance":8918,"id":212261,"goal":"lemma SetInterSubset_8918(B: set, T: set)\n ensures B * T <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_8919","instance":8919,"id":212262,"goal":"lemma SetCardSubset_8919(B: set, A: set)\n requires B <= A\n ensures |B| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_8920","instance":8920,"id":212263,"goal":"lemma SetUnionCard_8920(A: set, U: set)\n requires A * U == {}\n ensures |A + U| == |A| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_8921","instance":8921,"id":212264,"goal":"lemma SetUnionComm_8921(S: set, T: set)\n ensures S + T == T + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_8922","instance":8922,"id":212265,"goal":"lemma SetInterComm_8922(A: set, U: set)\n ensures A * U == U * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_8923","instance":8923,"id":212266,"goal":"lemma SetUnionAssoc_8923(U: set, B: set, A: set)\n ensures (U + B) + A == U + (B + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_8924","instance":8924,"id":212267,"goal":"lemma SetSubsetRefl_8924(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_8925","instance":8925,"id":212268,"goal":"lemma SetSubsetTrans_8925(S: set, U: set, B: set)\n requires S <= U && U <= B\n ensures S <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_8926","instance":8926,"id":212269,"goal":"lemma SetUnionEmpty_8926(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_8927","instance":8927,"id":212270,"goal":"lemma SetInterEmpty_8927(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_8928","instance":8928,"id":212271,"goal":"lemma SetInterSubset_8928(T: set, A: set)\n ensures T * A <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_8929","instance":8929,"id":212272,"goal":"lemma SetCardSubset_8929(U: set, T: set)\n requires U <= T\n ensures |U| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_8930","instance":8930,"id":212273,"goal":"lemma SetUnionCard_8930(S: set, U: set)\n requires S * U == {}\n ensures |S + U| == |S| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_8931","instance":8931,"id":212274,"goal":"lemma SetUnionComm_8931(U: set, S: set)\n ensures U + S == S + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_8932","instance":8932,"id":212275,"goal":"lemma SetInterComm_8932(U: set, A: set)\n ensures U * A == A * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_8933","instance":8933,"id":212276,"goal":"lemma SetUnionAssoc_8933(T: set, A: set, U: set)\n ensures (T + A) + U == T + (A + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_8934","instance":8934,"id":212277,"goal":"lemma SetSubsetRefl_8934(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_8935","instance":8935,"id":212278,"goal":"lemma SetSubsetTrans_8935(A: set, S: set, B: set)\n requires A <= S && S <= B\n ensures A <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_8936","instance":8936,"id":212279,"goal":"lemma SetUnionEmpty_8936(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_8937","instance":8937,"id":212280,"goal":"lemma SetInterEmpty_8937(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_8938","instance":8938,"id":212281,"goal":"lemma SetInterSubset_8938(S: set, A: set)\n ensures S * A <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_8939","instance":8939,"id":212282,"goal":"lemma SetCardSubset_8939(U: set, T: set)\n requires U <= T\n ensures |U| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_8940","instance":8940,"id":212283,"goal":"lemma SetUnionCard_8940(S: set, A: set)\n requires S * A == {}\n ensures |S + A| == |S| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_8941","instance":8941,"id":212284,"goal":"lemma SetUnionComm_8941(B: set, S: set)\n ensures B + S == S + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_8942","instance":8942,"id":212285,"goal":"lemma SetInterComm_8942(B: set, U: set)\n ensures B * U == U * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_8943","instance":8943,"id":212286,"goal":"lemma SetUnionAssoc_8943(T: set, S: set, B: set)\n ensures (T + S) + B == T + (S + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_8944","instance":8944,"id":212287,"goal":"lemma SetSubsetRefl_8944(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_8945","instance":8945,"id":212288,"goal":"lemma SetSubsetTrans_8945(S: set, U: set, B: set)\n requires S <= U && U <= B\n ensures S <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_8946","instance":8946,"id":212289,"goal":"lemma SetUnionEmpty_8946(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_8947","instance":8947,"id":212290,"goal":"lemma SetInterEmpty_8947(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_8948","instance":8948,"id":212291,"goal":"lemma SetInterSubset_8948(T: set, B: set)\n ensures T * B <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_8949","instance":8949,"id":212292,"goal":"lemma SetCardSubset_8949(A: set, S: set)\n requires A <= S\n ensures |A| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_8950","instance":8950,"id":212293,"goal":"lemma SetUnionCard_8950(T: set, S: set)\n requires T * S == {}\n ensures |T + S| == |T| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_8951","instance":8951,"id":212294,"goal":"lemma SetUnionComm_8951(B: set, S: set)\n ensures B + S == S + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_8952","instance":8952,"id":212295,"goal":"lemma SetInterComm_8952(S: set, T: set)\n ensures S * T == T * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_8953","instance":8953,"id":212296,"goal":"lemma SetUnionAssoc_8953(T: set, S: set, U: set)\n ensures (T + S) + U == T + (S + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_8954","instance":8954,"id":212297,"goal":"lemma SetSubsetRefl_8954(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_8955","instance":8955,"id":212298,"goal":"lemma SetSubsetTrans_8955(B: set, A: set, U: set)\n requires B <= A && A <= U\n ensures B <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_8956","instance":8956,"id":212299,"goal":"lemma SetUnionEmpty_8956(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_8957","instance":8957,"id":212300,"goal":"lemma SetInterEmpty_8957(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_8958","instance":8958,"id":212301,"goal":"lemma SetInterSubset_8958(T: set, S: set)\n ensures T * S <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_8959","instance":8959,"id":212302,"goal":"lemma SetCardSubset_8959(B: set, A: set)\n requires B <= A\n ensures |B| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_8960","instance":8960,"id":212303,"goal":"lemma SetUnionCard_8960(S: set, U: set)\n requires S * U == {}\n ensures |S + U| == |S| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_8961","instance":8961,"id":212304,"goal":"lemma SetUnionComm_8961(S: set, U: set)\n ensures S + U == U + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_8962","instance":8962,"id":212305,"goal":"lemma SetInterComm_8962(S: set, B: set)\n ensures S * B == B * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_8963","instance":8963,"id":212306,"goal":"lemma SetUnionAssoc_8963(B: set, U: set, A: set)\n ensures (B + U) + A == B + (U + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_8964","instance":8964,"id":212307,"goal":"lemma SetSubsetRefl_8964(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_8965","instance":8965,"id":212308,"goal":"lemma SetSubsetTrans_8965(U: set, A: set, T: set)\n requires U <= A && A <= T\n ensures U <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_8966","instance":8966,"id":212309,"goal":"lemma SetUnionEmpty_8966(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_8967","instance":8967,"id":212310,"goal":"lemma SetInterEmpty_8967(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_8968","instance":8968,"id":212311,"goal":"lemma SetInterSubset_8968(U: set, S: set)\n ensures U * S <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_8969","instance":8969,"id":212312,"goal":"lemma SetCardSubset_8969(U: set, A: set)\n requires U <= A\n ensures |U| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_8970","instance":8970,"id":212313,"goal":"lemma SetUnionCard_8970(S: set, T: set)\n requires S * T == {}\n ensures |S + T| == |S| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_8971","instance":8971,"id":212314,"goal":"lemma SetUnionComm_8971(B: set, T: set)\n ensures B + T == T + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_8972","instance":8972,"id":212315,"goal":"lemma SetInterComm_8972(U: set, T: set)\n ensures U * T == T * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_8973","instance":8973,"id":212316,"goal":"lemma SetUnionAssoc_8973(S: set, B: set, A: set)\n ensures (S + B) + A == S + (B + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_8974","instance":8974,"id":212317,"goal":"lemma SetSubsetRefl_8974(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_8975","instance":8975,"id":212318,"goal":"lemma SetSubsetTrans_8975(B: set, S: set, T: set)\n requires B <= S && S <= T\n ensures B <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_8976","instance":8976,"id":212319,"goal":"lemma SetUnionEmpty_8976(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_8977","instance":8977,"id":212320,"goal":"lemma SetInterEmpty_8977(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_8978","instance":8978,"id":212321,"goal":"lemma SetInterSubset_8978(S: set, U: set)\n ensures S * U <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_8979","instance":8979,"id":212322,"goal":"lemma SetCardSubset_8979(B: set, A: set)\n requires B <= A\n ensures |B| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_8980","instance":8980,"id":212323,"goal":"lemma SetUnionCard_8980(T: set, S: set)\n requires T * S == {}\n ensures |T + S| == |T| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_8981","instance":8981,"id":212324,"goal":"lemma SetUnionComm_8981(U: set, B: set)\n ensures U + B == B + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_8982","instance":8982,"id":212325,"goal":"lemma SetInterComm_8982(S: set, B: set)\n ensures S * B == B * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_8983","instance":8983,"id":212326,"goal":"lemma SetUnionAssoc_8983(U: set, T: set, A: set)\n ensures (U + T) + A == U + (T + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_8984","instance":8984,"id":212327,"goal":"lemma SetSubsetRefl_8984(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_8985","instance":8985,"id":212328,"goal":"lemma SetSubsetTrans_8985(T: set, U: set, A: set)\n requires T <= U && U <= A\n ensures T <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_8986","instance":8986,"id":212329,"goal":"lemma SetUnionEmpty_8986(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_8987","instance":8987,"id":212330,"goal":"lemma SetInterEmpty_8987(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_8988","instance":8988,"id":212331,"goal":"lemma SetInterSubset_8988(T: set, U: set)\n ensures T * U <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_8989","instance":8989,"id":212332,"goal":"lemma SetCardSubset_8989(U: set, T: set)\n requires U <= T\n ensures |U| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_8990","instance":8990,"id":212333,"goal":"lemma SetUnionCard_8990(B: set, S: set)\n requires B * S == {}\n ensures |B + S| == |B| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_8991","instance":8991,"id":212334,"goal":"lemma SetUnionComm_8991(T: set, A: set)\n ensures T + A == A + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_8992","instance":8992,"id":212335,"goal":"lemma SetInterComm_8992(B: set, T: set)\n ensures B * T == T * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_8993","instance":8993,"id":212336,"goal":"lemma SetUnionAssoc_8993(B: set, S: set, A: set)\n ensures (B + S) + A == B + (S + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_8994","instance":8994,"id":212337,"goal":"lemma SetSubsetRefl_8994(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_8995","instance":8995,"id":212338,"goal":"lemma SetSubsetTrans_8995(U: set, T: set, S: set)\n requires U <= T && T <= S\n ensures U <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_8996","instance":8996,"id":212339,"goal":"lemma SetUnionEmpty_8996(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_8997","instance":8997,"id":212340,"goal":"lemma SetInterEmpty_8997(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_8998","instance":8998,"id":212341,"goal":"lemma SetInterSubset_8998(A: set, S: set)\n ensures A * S <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_8999","instance":8999,"id":212342,"goal":"lemma SetCardSubset_8999(T: set, U: set)\n requires T <= U\n ensures |T| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_9000","instance":9000,"id":212343,"goal":"lemma SetUnionCard_9000(A: set, U: set)\n requires A * U == {}\n ensures |A + U| == |A| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_9001","instance":9001,"id":212344,"goal":"lemma SetUnionComm_9001(A: set, B: set)\n ensures A + B == B + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_9002","instance":9002,"id":212345,"goal":"lemma SetInterComm_9002(T: set, S: set)\n ensures T * S == S * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_9003","instance":9003,"id":212346,"goal":"lemma SetUnionAssoc_9003(S: set, A: set, B: set)\n ensures (S + A) + B == S + (A + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_9004","instance":9004,"id":212347,"goal":"lemma SetSubsetRefl_9004(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_9005","instance":9005,"id":212348,"goal":"lemma SetSubsetTrans_9005(B: set, A: set, S: set)\n requires B <= A && A <= S\n ensures B <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_9006","instance":9006,"id":212349,"goal":"lemma SetUnionEmpty_9006(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_9007","instance":9007,"id":212350,"goal":"lemma SetInterEmpty_9007(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_9008","instance":9008,"id":212351,"goal":"lemma SetInterSubset_9008(A: set, S: set)\n ensures A * S <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_9009","instance":9009,"id":212352,"goal":"lemma SetCardSubset_9009(U: set, B: set)\n requires U <= B\n ensures |U| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_9010","instance":9010,"id":212353,"goal":"lemma SetUnionCard_9010(U: set, T: set)\n requires U * T == {}\n ensures |U + T| == |U| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_9011","instance":9011,"id":212354,"goal":"lemma SetUnionComm_9011(T: set, A: set)\n ensures T + A == A + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_9012","instance":9012,"id":212355,"goal":"lemma SetInterComm_9012(S: set, T: set)\n ensures S * T == T * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_9013","instance":9013,"id":212356,"goal":"lemma SetUnionAssoc_9013(B: set, T: set, A: set)\n ensures (B + T) + A == B + (T + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_9014","instance":9014,"id":212357,"goal":"lemma SetSubsetRefl_9014(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_9015","instance":9015,"id":212358,"goal":"lemma SetSubsetTrans_9015(A: set, U: set, B: set)\n requires A <= U && U <= B\n ensures A <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_9016","instance":9016,"id":212359,"goal":"lemma SetUnionEmpty_9016(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_9017","instance":9017,"id":212360,"goal":"lemma SetInterEmpty_9017(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_9018","instance":9018,"id":212361,"goal":"lemma SetInterSubset_9018(U: set, A: set)\n ensures U * A <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_9019","instance":9019,"id":212362,"goal":"lemma SetCardSubset_9019(T: set, S: set)\n requires T <= S\n ensures |T| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_9020","instance":9020,"id":212363,"goal":"lemma SetUnionCard_9020(A: set, S: set)\n requires A * S == {}\n ensures |A + S| == |A| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_9021","instance":9021,"id":212364,"goal":"lemma SetUnionComm_9021(U: set, B: set)\n ensures U + B == B + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_9022","instance":9022,"id":212365,"goal":"lemma SetInterComm_9022(T: set, U: set)\n ensures T * U == U * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_9023","instance":9023,"id":212366,"goal":"lemma SetUnionAssoc_9023(B: set, U: set, A: set)\n ensures (B + U) + A == B + (U + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_9024","instance":9024,"id":212367,"goal":"lemma SetSubsetRefl_9024(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_9025","instance":9025,"id":212368,"goal":"lemma SetSubsetTrans_9025(S: set, T: set, A: set)\n requires S <= T && T <= A\n ensures S <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_9026","instance":9026,"id":212369,"goal":"lemma SetUnionEmpty_9026(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_9027","instance":9027,"id":212370,"goal":"lemma SetInterEmpty_9027(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_9028","instance":9028,"id":212371,"goal":"lemma SetInterSubset_9028(B: set, T: set)\n ensures B * T <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_9029","instance":9029,"id":212372,"goal":"lemma SetCardSubset_9029(U: set, T: set)\n requires U <= T\n ensures |U| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_9030","instance":9030,"id":212373,"goal":"lemma SetUnionCard_9030(A: set, U: set)\n requires A * U == {}\n ensures |A + U| == |A| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_9031","instance":9031,"id":212374,"goal":"lemma SetUnionComm_9031(U: set, B: set)\n ensures U + B == B + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_9032","instance":9032,"id":212375,"goal":"lemma SetInterComm_9032(A: set, S: set)\n ensures A * S == S * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_9033","instance":9033,"id":212376,"goal":"lemma SetUnionAssoc_9033(A: set, B: set, U: set)\n ensures (A + B) + U == A + (B + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_9034","instance":9034,"id":212377,"goal":"lemma SetSubsetRefl_9034(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_9035","instance":9035,"id":212378,"goal":"lemma SetSubsetTrans_9035(A: set, S: set, T: set)\n requires A <= S && S <= T\n ensures A <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_9036","instance":9036,"id":212379,"goal":"lemma SetUnionEmpty_9036(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_9037","instance":9037,"id":212380,"goal":"lemma SetInterEmpty_9037(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_9038","instance":9038,"id":212381,"goal":"lemma SetInterSubset_9038(S: set, B: set)\n ensures S * B <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_9039","instance":9039,"id":212382,"goal":"lemma SetCardSubset_9039(S: set, B: set)\n requires S <= B\n ensures |S| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_9040","instance":9040,"id":212383,"goal":"lemma SetUnionCard_9040(T: set, U: set)\n requires T * U == {}\n ensures |T + U| == |T| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_9041","instance":9041,"id":212384,"goal":"lemma SetUnionComm_9041(U: set, T: set)\n ensures U + T == T + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_9042","instance":9042,"id":212385,"goal":"lemma SetInterComm_9042(T: set, U: set)\n ensures T * U == U * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_9043","instance":9043,"id":212386,"goal":"lemma SetUnionAssoc_9043(S: set, A: set, U: set)\n ensures (S + A) + U == S + (A + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_9044","instance":9044,"id":212387,"goal":"lemma SetSubsetRefl_9044(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_9045","instance":9045,"id":212388,"goal":"lemma SetSubsetTrans_9045(S: set, A: set, U: set)\n requires S <= A && A <= U\n ensures S <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_9046","instance":9046,"id":212389,"goal":"lemma SetUnionEmpty_9046(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_9047","instance":9047,"id":212390,"goal":"lemma SetInterEmpty_9047(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_9048","instance":9048,"id":212391,"goal":"lemma SetInterSubset_9048(B: set, A: set)\n ensures B * A <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_9049","instance":9049,"id":212392,"goal":"lemma SetCardSubset_9049(A: set, S: set)\n requires A <= S\n ensures |A| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_9050","instance":9050,"id":212393,"goal":"lemma SetUnionCard_9050(A: set, B: set)\n requires A * B == {}\n ensures |A + B| == |A| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_9051","instance":9051,"id":212394,"goal":"lemma SetUnionComm_9051(B: set, A: set)\n ensures B + A == A + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_9052","instance":9052,"id":212395,"goal":"lemma SetInterComm_9052(B: set, U: set)\n ensures B * U == U * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_9053","instance":9053,"id":212396,"goal":"lemma SetUnionAssoc_9053(T: set, S: set, B: set)\n ensures (T + S) + B == T + (S + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_9054","instance":9054,"id":212397,"goal":"lemma SetSubsetRefl_9054(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_9055","instance":9055,"id":212398,"goal":"lemma SetSubsetTrans_9055(A: set, T: set, S: set)\n requires A <= T && T <= S\n ensures A <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_9056","instance":9056,"id":212399,"goal":"lemma SetUnionEmpty_9056(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_9057","instance":9057,"id":212400,"goal":"lemma SetInterEmpty_9057(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_9058","instance":9058,"id":212401,"goal":"lemma SetInterSubset_9058(A: set, B: set)\n ensures A * B <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_9059","instance":9059,"id":212402,"goal":"lemma SetCardSubset_9059(B: set, U: set)\n requires B <= U\n ensures |B| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_9060","instance":9060,"id":212403,"goal":"lemma SetUnionCard_9060(S: set, U: set)\n requires S * U == {}\n ensures |S + U| == |S| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_9061","instance":9061,"id":212404,"goal":"lemma SetUnionComm_9061(A: set, T: set)\n ensures A + T == T + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_9062","instance":9062,"id":212405,"goal":"lemma SetInterComm_9062(B: set, S: set)\n ensures B * S == S * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_9063","instance":9063,"id":212406,"goal":"lemma SetUnionAssoc_9063(B: set, T: set, A: set)\n ensures (B + T) + A == B + (T + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_9064","instance":9064,"id":212407,"goal":"lemma SetSubsetRefl_9064(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_9065","instance":9065,"id":212408,"goal":"lemma SetSubsetTrans_9065(S: set, A: set, B: set)\n requires S <= A && A <= B\n ensures S <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_9066","instance":9066,"id":212409,"goal":"lemma SetUnionEmpty_9066(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_9067","instance":9067,"id":212410,"goal":"lemma SetInterEmpty_9067(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_9068","instance":9068,"id":212411,"goal":"lemma SetInterSubset_9068(S: set, U: set)\n ensures S * U <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_9069","instance":9069,"id":212412,"goal":"lemma SetCardSubset_9069(B: set, A: set)\n requires B <= A\n ensures |B| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_9070","instance":9070,"id":212413,"goal":"lemma SetUnionCard_9070(A: set, T: set)\n requires A * T == {}\n ensures |A + T| == |A| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_9071","instance":9071,"id":212414,"goal":"lemma SetUnionComm_9071(A: set, S: set)\n ensures A + S == S + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_9072","instance":9072,"id":212415,"goal":"lemma SetInterComm_9072(S: set, A: set)\n ensures S * A == A * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_9073","instance":9073,"id":212416,"goal":"lemma SetUnionAssoc_9073(U: set, B: set, A: set)\n ensures (U + B) + A == U + (B + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_9074","instance":9074,"id":212417,"goal":"lemma SetSubsetRefl_9074(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_9075","instance":9075,"id":212418,"goal":"lemma SetSubsetTrans_9075(S: set, T: set, A: set)\n requires S <= T && T <= A\n ensures S <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_9076","instance":9076,"id":212419,"goal":"lemma SetUnionEmpty_9076(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_9077","instance":9077,"id":212420,"goal":"lemma SetInterEmpty_9077(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_9078","instance":9078,"id":212421,"goal":"lemma SetInterSubset_9078(T: set, B: set)\n ensures T * B <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_9079","instance":9079,"id":212422,"goal":"lemma SetCardSubset_9079(T: set, U: set)\n requires T <= U\n ensures |T| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_9080","instance":9080,"id":212423,"goal":"lemma SetUnionCard_9080(A: set, T: set)\n requires A * T == {}\n ensures |A + T| == |A| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_9081","instance":9081,"id":212424,"goal":"lemma SetUnionComm_9081(T: set, S: set)\n ensures T + S == S + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_9082","instance":9082,"id":212425,"goal":"lemma SetInterComm_9082(B: set, S: set)\n ensures B * S == S * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_9083","instance":9083,"id":212426,"goal":"lemma SetUnionAssoc_9083(S: set, U: set, B: set)\n ensures (S + U) + B == S + (U + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_9084","instance":9084,"id":212427,"goal":"lemma SetSubsetRefl_9084(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_9085","instance":9085,"id":212428,"goal":"lemma SetSubsetTrans_9085(T: set, A: set, S: set)\n requires T <= A && A <= S\n ensures T <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_9086","instance":9086,"id":212429,"goal":"lemma SetUnionEmpty_9086(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_9087","instance":9087,"id":212430,"goal":"lemma SetInterEmpty_9087(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_9088","instance":9088,"id":212431,"goal":"lemma SetInterSubset_9088(U: set, A: set)\n ensures U * A <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_9089","instance":9089,"id":212432,"goal":"lemma SetCardSubset_9089(A: set, U: set)\n requires A <= U\n ensures |A| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_9090","instance":9090,"id":212433,"goal":"lemma SetUnionCard_9090(S: set, B: set)\n requires S * B == {}\n ensures |S + B| == |S| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_9091","instance":9091,"id":212434,"goal":"lemma SetUnionComm_9091(S: set, A: set)\n ensures S + A == A + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_9092","instance":9092,"id":212435,"goal":"lemma SetInterComm_9092(B: set, A: set)\n ensures B * A == A * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_9093","instance":9093,"id":212436,"goal":"lemma SetUnionAssoc_9093(U: set, B: set, S: set)\n ensures (U + B) + S == U + (B + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_9094","instance":9094,"id":212437,"goal":"lemma SetSubsetRefl_9094(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_9095","instance":9095,"id":212438,"goal":"lemma SetSubsetTrans_9095(B: set, A: set, S: set)\n requires B <= A && A <= S\n ensures B <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_9096","instance":9096,"id":212439,"goal":"lemma SetUnionEmpty_9096(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_9097","instance":9097,"id":212440,"goal":"lemma SetInterEmpty_9097(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_9098","instance":9098,"id":212441,"goal":"lemma SetInterSubset_9098(T: set, U: set)\n ensures T * U <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_9099","instance":9099,"id":212442,"goal":"lemma SetCardSubset_9099(T: set, S: set)\n requires T <= S\n ensures |T| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_9100","instance":9100,"id":212443,"goal":"lemma SetUnionCard_9100(A: set, S: set)\n requires A * S == {}\n ensures |A + S| == |A| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_9101","instance":9101,"id":212444,"goal":"lemma SetUnionComm_9101(U: set, B: set)\n ensures U + B == B + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_9102","instance":9102,"id":212445,"goal":"lemma SetInterComm_9102(S: set, B: set)\n ensures S * B == B * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_9103","instance":9103,"id":212446,"goal":"lemma SetUnionAssoc_9103(T: set, U: set, B: set)\n ensures (T + U) + B == T + (U + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_9104","instance":9104,"id":212447,"goal":"lemma SetSubsetRefl_9104(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_9105","instance":9105,"id":212448,"goal":"lemma SetSubsetTrans_9105(B: set, A: set, U: set)\n requires B <= A && A <= U\n ensures B <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_9106","instance":9106,"id":212449,"goal":"lemma SetUnionEmpty_9106(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_9107","instance":9107,"id":212450,"goal":"lemma SetInterEmpty_9107(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_9108","instance":9108,"id":212451,"goal":"lemma SetInterSubset_9108(S: set, U: set)\n ensures S * U <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_9109","instance":9109,"id":212452,"goal":"lemma SetCardSubset_9109(T: set, A: set)\n requires T <= A\n ensures |T| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_9110","instance":9110,"id":212453,"goal":"lemma SetUnionCard_9110(U: set, A: set)\n requires U * A == {}\n ensures |U + A| == |U| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_9111","instance":9111,"id":212454,"goal":"lemma SetUnionComm_9111(U: set, T: set)\n ensures U + T == T + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_9112","instance":9112,"id":212455,"goal":"lemma SetInterComm_9112(B: set, U: set)\n ensures B * U == U * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_9113","instance":9113,"id":212456,"goal":"lemma SetUnionAssoc_9113(U: set, B: set, T: set)\n ensures (U + B) + T == U + (B + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_9114","instance":9114,"id":212457,"goal":"lemma SetSubsetRefl_9114(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_9115","instance":9115,"id":212458,"goal":"lemma SetSubsetTrans_9115(B: set, T: set, U: set)\n requires B <= T && T <= U\n ensures B <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_9116","instance":9116,"id":212459,"goal":"lemma SetUnionEmpty_9116(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_9117","instance":9117,"id":212460,"goal":"lemma SetInterEmpty_9117(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_9118","instance":9118,"id":212461,"goal":"lemma SetInterSubset_9118(S: set, A: set)\n ensures S * A <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_9119","instance":9119,"id":212462,"goal":"lemma SetCardSubset_9119(U: set, S: set)\n requires U <= S\n ensures |U| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_9120","instance":9120,"id":212463,"goal":"lemma SetUnionCard_9120(U: set, T: set)\n requires U * T == {}\n ensures |U + T| == |U| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_9121","instance":9121,"id":212464,"goal":"lemma SetUnionComm_9121(A: set, B: set)\n ensures A + B == B + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_9122","instance":9122,"id":212465,"goal":"lemma SetInterComm_9122(T: set, U: set)\n ensures T * U == U * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_9123","instance":9123,"id":212466,"goal":"lemma SetUnionAssoc_9123(B: set, U: set, S: set)\n ensures (B + U) + S == B + (U + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_9124","instance":9124,"id":212467,"goal":"lemma SetSubsetRefl_9124(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_9125","instance":9125,"id":212468,"goal":"lemma SetSubsetTrans_9125(B: set, U: set, A: set)\n requires B <= U && U <= A\n ensures B <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_9126","instance":9126,"id":212469,"goal":"lemma SetUnionEmpty_9126(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_9127","instance":9127,"id":212470,"goal":"lemma SetInterEmpty_9127(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_9128","instance":9128,"id":212471,"goal":"lemma SetInterSubset_9128(S: set, T: set)\n ensures S * T <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_9129","instance":9129,"id":212472,"goal":"lemma SetCardSubset_9129(B: set, U: set)\n requires B <= U\n ensures |B| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_9130","instance":9130,"id":212473,"goal":"lemma SetUnionCard_9130(S: set, T: set)\n requires S * T == {}\n ensures |S + T| == |S| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_9131","instance":9131,"id":212474,"goal":"lemma SetUnionComm_9131(B: set, A: set)\n ensures B + A == A + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_9132","instance":9132,"id":212475,"goal":"lemma SetInterComm_9132(S: set, T: set)\n ensures S * T == T * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_9133","instance":9133,"id":212476,"goal":"lemma SetUnionAssoc_9133(S: set, A: set, T: set)\n ensures (S + A) + T == S + (A + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_9134","instance":9134,"id":212477,"goal":"lemma SetSubsetRefl_9134(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_9135","instance":9135,"id":212478,"goal":"lemma SetSubsetTrans_9135(A: set, T: set, S: set)\n requires A <= T && T <= S\n ensures A <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_9136","instance":9136,"id":212479,"goal":"lemma SetUnionEmpty_9136(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_9137","instance":9137,"id":212480,"goal":"lemma SetInterEmpty_9137(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_9138","instance":9138,"id":212481,"goal":"lemma SetInterSubset_9138(U: set, A: set)\n ensures U * A <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_9139","instance":9139,"id":212482,"goal":"lemma SetCardSubset_9139(U: set, S: set)\n requires U <= S\n ensures |U| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_9140","instance":9140,"id":212483,"goal":"lemma SetUnionCard_9140(U: set, S: set)\n requires U * S == {}\n ensures |U + S| == |U| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_9141","instance":9141,"id":212484,"goal":"lemma SetUnionComm_9141(A: set, S: set)\n ensures A + S == S + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_9142","instance":9142,"id":212485,"goal":"lemma SetInterComm_9142(S: set, B: set)\n ensures S * B == B * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_9143","instance":9143,"id":212486,"goal":"lemma SetUnionAssoc_9143(S: set, T: set, B: set)\n ensures (S + T) + B == S + (T + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_9144","instance":9144,"id":212487,"goal":"lemma SetSubsetRefl_9144(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_9145","instance":9145,"id":212488,"goal":"lemma SetSubsetTrans_9145(T: set, S: set, A: set)\n requires T <= S && S <= A\n ensures T <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_9146","instance":9146,"id":212489,"goal":"lemma SetUnionEmpty_9146(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_9147","instance":9147,"id":212490,"goal":"lemma SetInterEmpty_9147(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_9148","instance":9148,"id":212491,"goal":"lemma SetInterSubset_9148(T: set, S: set)\n ensures T * S <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_9149","instance":9149,"id":212492,"goal":"lemma SetCardSubset_9149(T: set, U: set)\n requires T <= U\n ensures |T| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_9150","instance":9150,"id":212493,"goal":"lemma SetUnionCard_9150(B: set, T: set)\n requires B * T == {}\n ensures |B + T| == |B| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_9151","instance":9151,"id":212494,"goal":"lemma SetUnionComm_9151(S: set, A: set)\n ensures S + A == A + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_9152","instance":9152,"id":212495,"goal":"lemma SetInterComm_9152(T: set, S: set)\n ensures T * S == S * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_9153","instance":9153,"id":212496,"goal":"lemma SetUnionAssoc_9153(A: set, S: set, U: set)\n ensures (A + S) + U == A + (S + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_9154","instance":9154,"id":212497,"goal":"lemma SetSubsetRefl_9154(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_9155","instance":9155,"id":212498,"goal":"lemma SetSubsetTrans_9155(U: set, S: set, A: set)\n requires U <= S && S <= A\n ensures U <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_9156","instance":9156,"id":212499,"goal":"lemma SetUnionEmpty_9156(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_9157","instance":9157,"id":212500,"goal":"lemma SetInterEmpty_9157(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_9158","instance":9158,"id":212501,"goal":"lemma SetInterSubset_9158(B: set, T: set)\n ensures B * T <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_9159","instance":9159,"id":212502,"goal":"lemma SetCardSubset_9159(B: set, A: set)\n requires B <= A\n ensures |B| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_9160","instance":9160,"id":212503,"goal":"lemma SetUnionCard_9160(B: set, A: set)\n requires B * A == {}\n ensures |B + A| == |B| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_9161","instance":9161,"id":212504,"goal":"lemma SetUnionComm_9161(T: set, S: set)\n ensures T + S == S + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_9162","instance":9162,"id":212505,"goal":"lemma SetInterComm_9162(T: set, A: set)\n ensures T * A == A * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_9163","instance":9163,"id":212506,"goal":"lemma SetUnionAssoc_9163(T: set, S: set, B: set)\n ensures (T + S) + B == T + (S + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_9164","instance":9164,"id":212507,"goal":"lemma SetSubsetRefl_9164(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_9165","instance":9165,"id":212508,"goal":"lemma SetSubsetTrans_9165(S: set, B: set, A: set)\n requires S <= B && B <= A\n ensures S <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_9166","instance":9166,"id":212509,"goal":"lemma SetUnionEmpty_9166(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_9167","instance":9167,"id":212510,"goal":"lemma SetInterEmpty_9167(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_9168","instance":9168,"id":212511,"goal":"lemma SetInterSubset_9168(B: set, S: set)\n ensures B * S <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_9169","instance":9169,"id":212512,"goal":"lemma SetCardSubset_9169(U: set, S: set)\n requires U <= S\n ensures |U| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_9170","instance":9170,"id":212513,"goal":"lemma SetUnionCard_9170(S: set, A: set)\n requires S * A == {}\n ensures |S + A| == |S| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_9171","instance":9171,"id":212514,"goal":"lemma SetUnionComm_9171(A: set, T: set)\n ensures A + T == T + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_9172","instance":9172,"id":212515,"goal":"lemma SetInterComm_9172(S: set, T: set)\n ensures S * T == T * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_9173","instance":9173,"id":212516,"goal":"lemma SetUnionAssoc_9173(S: set, U: set, B: set)\n ensures (S + U) + B == S + (U + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_9174","instance":9174,"id":212517,"goal":"lemma SetSubsetRefl_9174(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_9175","instance":9175,"id":212518,"goal":"lemma SetSubsetTrans_9175(B: set, S: set, U: set)\n requires B <= S && S <= U\n ensures B <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_9176","instance":9176,"id":212519,"goal":"lemma SetUnionEmpty_9176(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_9177","instance":9177,"id":212520,"goal":"lemma SetInterEmpty_9177(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_9178","instance":9178,"id":212521,"goal":"lemma SetInterSubset_9178(T: set, B: set)\n ensures T * B <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_9179","instance":9179,"id":212522,"goal":"lemma SetCardSubset_9179(S: set, B: set)\n requires S <= B\n ensures |S| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_9180","instance":9180,"id":212523,"goal":"lemma SetUnionCard_9180(T: set, U: set)\n requires T * U == {}\n ensures |T + U| == |T| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_9181","instance":9181,"id":212524,"goal":"lemma SetUnionComm_9181(B: set, U: set)\n ensures B + U == U + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_9182","instance":9182,"id":212525,"goal":"lemma SetInterComm_9182(S: set, T: set)\n ensures S * T == T * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_9183","instance":9183,"id":212526,"goal":"lemma SetUnionAssoc_9183(T: set, U: set, A: set)\n ensures (T + U) + A == T + (U + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_9184","instance":9184,"id":212527,"goal":"lemma SetSubsetRefl_9184(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_9185","instance":9185,"id":212528,"goal":"lemma SetSubsetTrans_9185(S: set, T: set, B: set)\n requires S <= T && T <= B\n ensures S <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_9186","instance":9186,"id":212529,"goal":"lemma SetUnionEmpty_9186(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_9187","instance":9187,"id":212530,"goal":"lemma SetInterEmpty_9187(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_9188","instance":9188,"id":212531,"goal":"lemma SetInterSubset_9188(T: set, S: set)\n ensures T * S <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_9189","instance":9189,"id":212532,"goal":"lemma SetCardSubset_9189(U: set, S: set)\n requires U <= S\n ensures |U| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_9190","instance":9190,"id":212533,"goal":"lemma SetUnionCard_9190(S: set, T: set)\n requires S * T == {}\n ensures |S + T| == |S| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_9191","instance":9191,"id":212534,"goal":"lemma SetUnionComm_9191(S: set, T: set)\n ensures S + T == T + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_9192","instance":9192,"id":212535,"goal":"lemma SetInterComm_9192(B: set, S: set)\n ensures B * S == S * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_9193","instance":9193,"id":212536,"goal":"lemma SetUnionAssoc_9193(T: set, A: set, U: set)\n ensures (T + A) + U == T + (A + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_9194","instance":9194,"id":212537,"goal":"lemma SetSubsetRefl_9194(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_9195","instance":9195,"id":212538,"goal":"lemma SetSubsetTrans_9195(B: set, T: set, U: set)\n requires B <= T && T <= U\n ensures B <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_9196","instance":9196,"id":212539,"goal":"lemma SetUnionEmpty_9196(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_9197","instance":9197,"id":212540,"goal":"lemma SetInterEmpty_9197(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_9198","instance":9198,"id":212541,"goal":"lemma SetInterSubset_9198(T: set, S: set)\n ensures T * S <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_9199","instance":9199,"id":212542,"goal":"lemma SetCardSubset_9199(U: set, S: set)\n requires U <= S\n ensures |U| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_9200","instance":9200,"id":212543,"goal":"lemma SetUnionCard_9200(B: set, S: set)\n requires B * S == {}\n ensures |B + S| == |B| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_9201","instance":9201,"id":212544,"goal":"lemma SetUnionComm_9201(A: set, S: set)\n ensures A + S == S + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_9202","instance":9202,"id":212545,"goal":"lemma SetInterComm_9202(T: set, A: set)\n ensures T * A == A * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_9203","instance":9203,"id":212546,"goal":"lemma SetUnionAssoc_9203(U: set, A: set, T: set)\n ensures (U + A) + T == U + (A + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_9204","instance":9204,"id":212547,"goal":"lemma SetSubsetRefl_9204(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_9205","instance":9205,"id":212548,"goal":"lemma SetSubsetTrans_9205(T: set, A: set, B: set)\n requires T <= A && A <= B\n ensures T <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_9206","instance":9206,"id":212549,"goal":"lemma SetUnionEmpty_9206(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_9207","instance":9207,"id":212550,"goal":"lemma SetInterEmpty_9207(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_9208","instance":9208,"id":212551,"goal":"lemma SetInterSubset_9208(A: set, U: set)\n ensures A * U <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_9209","instance":9209,"id":212552,"goal":"lemma SetCardSubset_9209(A: set, T: set)\n requires A <= T\n ensures |A| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_9210","instance":9210,"id":212553,"goal":"lemma SetUnionCard_9210(U: set, B: set)\n requires U * B == {}\n ensures |U + B| == |U| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_9211","instance":9211,"id":212554,"goal":"lemma SetUnionComm_9211(U: set, T: set)\n ensures U + T == T + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_9212","instance":9212,"id":212555,"goal":"lemma SetInterComm_9212(A: set, B: set)\n ensures A * B == B * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_9213","instance":9213,"id":212556,"goal":"lemma SetUnionAssoc_9213(A: set, U: set, T: set)\n ensures (A + U) + T == A + (U + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_9214","instance":9214,"id":212557,"goal":"lemma SetSubsetRefl_9214(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_9215","instance":9215,"id":212558,"goal":"lemma SetSubsetTrans_9215(S: set, B: set, A: set)\n requires S <= B && B <= A\n ensures S <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_9216","instance":9216,"id":212559,"goal":"lemma SetUnionEmpty_9216(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_9217","instance":9217,"id":212560,"goal":"lemma SetInterEmpty_9217(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_9218","instance":9218,"id":212561,"goal":"lemma SetInterSubset_9218(U: set, A: set)\n ensures U * A <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_9219","instance":9219,"id":212562,"goal":"lemma SetCardSubset_9219(A: set, S: set)\n requires A <= S\n ensures |A| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_9220","instance":9220,"id":212563,"goal":"lemma SetUnionCard_9220(A: set, U: set)\n requires A * U == {}\n ensures |A + U| == |A| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_9221","instance":9221,"id":212564,"goal":"lemma SetUnionComm_9221(U: set, S: set)\n ensures U + S == S + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_9222","instance":9222,"id":212565,"goal":"lemma SetInterComm_9222(B: set, S: set)\n ensures B * S == S * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_9223","instance":9223,"id":212566,"goal":"lemma SetUnionAssoc_9223(U: set, B: set, A: set)\n ensures (U + B) + A == U + (B + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_9224","instance":9224,"id":212567,"goal":"lemma SetSubsetRefl_9224(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_9225","instance":9225,"id":212568,"goal":"lemma SetSubsetTrans_9225(U: set, A: set, S: set)\n requires U <= A && A <= S\n ensures U <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_9226","instance":9226,"id":212569,"goal":"lemma SetUnionEmpty_9226(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_9227","instance":9227,"id":212570,"goal":"lemma SetInterEmpty_9227(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_9228","instance":9228,"id":212571,"goal":"lemma SetInterSubset_9228(T: set, B: set)\n ensures T * B <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_9229","instance":9229,"id":212572,"goal":"lemma SetCardSubset_9229(T: set, S: set)\n requires T <= S\n ensures |T| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_9230","instance":9230,"id":212573,"goal":"lemma SetUnionCard_9230(T: set, B: set)\n requires T * B == {}\n ensures |T + B| == |T| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_9231","instance":9231,"id":212574,"goal":"lemma SetUnionComm_9231(A: set, B: set)\n ensures A + B == B + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_9232","instance":9232,"id":212575,"goal":"lemma SetInterComm_9232(A: set, S: set)\n ensures A * S == S * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_9233","instance":9233,"id":212576,"goal":"lemma SetUnionAssoc_9233(B: set, U: set, T: set)\n ensures (B + U) + T == B + (U + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_9234","instance":9234,"id":212577,"goal":"lemma SetSubsetRefl_9234(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_9235","instance":9235,"id":212578,"goal":"lemma SetSubsetTrans_9235(U: set, B: set, T: set)\n requires U <= B && B <= T\n ensures U <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_9236","instance":9236,"id":212579,"goal":"lemma SetUnionEmpty_9236(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_9237","instance":9237,"id":212580,"goal":"lemma SetInterEmpty_9237(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_9238","instance":9238,"id":212581,"goal":"lemma SetInterSubset_9238(S: set, A: set)\n ensures S * A <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_9239","instance":9239,"id":212582,"goal":"lemma SetCardSubset_9239(U: set, A: set)\n requires U <= A\n ensures |U| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_9240","instance":9240,"id":212583,"goal":"lemma SetUnionCard_9240(T: set, B: set)\n requires T * B == {}\n ensures |T + B| == |T| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_9241","instance":9241,"id":212584,"goal":"lemma SetUnionComm_9241(B: set, S: set)\n ensures B + S == S + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_9242","instance":9242,"id":212585,"goal":"lemma SetInterComm_9242(U: set, A: set)\n ensures U * A == A * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_9243","instance":9243,"id":212586,"goal":"lemma SetUnionAssoc_9243(U: set, A: set, B: set)\n ensures (U + A) + B == U + (A + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_9244","instance":9244,"id":212587,"goal":"lemma SetSubsetRefl_9244(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_9245","instance":9245,"id":212588,"goal":"lemma SetSubsetTrans_9245(B: set, S: set, A: set)\n requires B <= S && S <= A\n ensures B <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_9246","instance":9246,"id":212589,"goal":"lemma SetUnionEmpty_9246(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_9247","instance":9247,"id":212590,"goal":"lemma SetInterEmpty_9247(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_9248","instance":9248,"id":212591,"goal":"lemma SetInterSubset_9248(A: set, U: set)\n ensures A * U <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_9249","instance":9249,"id":212592,"goal":"lemma SetCardSubset_9249(T: set, S: set)\n requires T <= S\n ensures |T| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_9250","instance":9250,"id":212593,"goal":"lemma SetUnionCard_9250(B: set, S: set)\n requires B * S == {}\n ensures |B + S| == |B| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_9251","instance":9251,"id":212594,"goal":"lemma SetUnionComm_9251(S: set, T: set)\n ensures S + T == T + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_9252","instance":9252,"id":212595,"goal":"lemma SetInterComm_9252(B: set, U: set)\n ensures B * U == U * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_9253","instance":9253,"id":212596,"goal":"lemma SetUnionAssoc_9253(B: set, A: set, S: set)\n ensures (B + A) + S == B + (A + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_9254","instance":9254,"id":212597,"goal":"lemma SetSubsetRefl_9254(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_9255","instance":9255,"id":212598,"goal":"lemma SetSubsetTrans_9255(S: set, B: set, A: set)\n requires S <= B && B <= A\n ensures S <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_9256","instance":9256,"id":212599,"goal":"lemma SetUnionEmpty_9256(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_9257","instance":9257,"id":212600,"goal":"lemma SetInterEmpty_9257(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_9258","instance":9258,"id":212601,"goal":"lemma SetInterSubset_9258(T: set, B: set)\n ensures T * B <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_9259","instance":9259,"id":212602,"goal":"lemma SetCardSubset_9259(U: set, B: set)\n requires U <= B\n ensures |U| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_9260","instance":9260,"id":212603,"goal":"lemma SetUnionCard_9260(T: set, U: set)\n requires T * U == {}\n ensures |T + U| == |T| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_9261","instance":9261,"id":212604,"goal":"lemma SetUnionComm_9261(S: set, A: set)\n ensures S + A == A + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_9262","instance":9262,"id":212605,"goal":"lemma SetInterComm_9262(U: set, T: set)\n ensures U * T == T * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_9263","instance":9263,"id":212606,"goal":"lemma SetUnionAssoc_9263(S: set, U: set, T: set)\n ensures (S + U) + T == S + (U + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_9264","instance":9264,"id":212607,"goal":"lemma SetSubsetRefl_9264(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_9265","instance":9265,"id":212608,"goal":"lemma SetSubsetTrans_9265(T: set, B: set, A: set)\n requires T <= B && B <= A\n ensures T <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_9266","instance":9266,"id":212609,"goal":"lemma SetUnionEmpty_9266(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_9267","instance":9267,"id":212610,"goal":"lemma SetInterEmpty_9267(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_9268","instance":9268,"id":212611,"goal":"lemma SetInterSubset_9268(T: set, S: set)\n ensures T * S <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_9269","instance":9269,"id":212612,"goal":"lemma SetCardSubset_9269(B: set, A: set)\n requires B <= A\n ensures |B| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_9270","instance":9270,"id":212613,"goal":"lemma SetUnionCard_9270(B: set, A: set)\n requires B * A == {}\n ensures |B + A| == |B| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_9271","instance":9271,"id":212614,"goal":"lemma SetUnionComm_9271(S: set, T: set)\n ensures S + T == T + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_9272","instance":9272,"id":212615,"goal":"lemma SetInterComm_9272(B: set, U: set)\n ensures B * U == U * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_9273","instance":9273,"id":212616,"goal":"lemma SetUnionAssoc_9273(B: set, S: set, A: set)\n ensures (B + S) + A == B + (S + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_9274","instance":9274,"id":212617,"goal":"lemma SetSubsetRefl_9274(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_9275","instance":9275,"id":212618,"goal":"lemma SetSubsetTrans_9275(U: set, B: set, T: set)\n requires U <= B && B <= T\n ensures U <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_9276","instance":9276,"id":212619,"goal":"lemma SetUnionEmpty_9276(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_9277","instance":9277,"id":212620,"goal":"lemma SetInterEmpty_9277(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_9278","instance":9278,"id":212621,"goal":"lemma SetInterSubset_9278(B: set, S: set)\n ensures B * S <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_9279","instance":9279,"id":212622,"goal":"lemma SetCardSubset_9279(T: set, B: set)\n requires T <= B\n ensures |T| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_9280","instance":9280,"id":212623,"goal":"lemma SetUnionCard_9280(S: set, T: set)\n requires S * T == {}\n ensures |S + T| == |S| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_9281","instance":9281,"id":212624,"goal":"lemma SetUnionComm_9281(U: set, B: set)\n ensures U + B == B + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_9282","instance":9282,"id":212625,"goal":"lemma SetInterComm_9282(T: set, S: set)\n ensures T * S == S * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_9283","instance":9283,"id":212626,"goal":"lemma SetUnionAssoc_9283(U: set, S: set, A: set)\n ensures (U + S) + A == U + (S + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_9284","instance":9284,"id":212627,"goal":"lemma SetSubsetRefl_9284(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_9285","instance":9285,"id":212628,"goal":"lemma SetSubsetTrans_9285(S: set, U: set, T: set)\n requires S <= U && U <= T\n ensures S <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_9286","instance":9286,"id":212629,"goal":"lemma SetUnionEmpty_9286(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_9287","instance":9287,"id":212630,"goal":"lemma SetInterEmpty_9287(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_9288","instance":9288,"id":212631,"goal":"lemma SetInterSubset_9288(B: set, T: set)\n ensures B * T <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_9289","instance":9289,"id":212632,"goal":"lemma SetCardSubset_9289(T: set, U: set)\n requires T <= U\n ensures |T| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_9290","instance":9290,"id":212633,"goal":"lemma SetUnionCard_9290(T: set, S: set)\n requires T * S == {}\n ensures |T + S| == |T| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_9291","instance":9291,"id":212634,"goal":"lemma SetUnionComm_9291(A: set, S: set)\n ensures A + S == S + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_9292","instance":9292,"id":212635,"goal":"lemma SetInterComm_9292(A: set, B: set)\n ensures A * B == B * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_9293","instance":9293,"id":212636,"goal":"lemma SetUnionAssoc_9293(A: set, T: set, S: set)\n ensures (A + T) + S == A + (T + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_9294","instance":9294,"id":212637,"goal":"lemma SetSubsetRefl_9294(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_9295","instance":9295,"id":212638,"goal":"lemma SetSubsetTrans_9295(T: set, A: set, S: set)\n requires T <= A && A <= S\n ensures T <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_9296","instance":9296,"id":212639,"goal":"lemma SetUnionEmpty_9296(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_9297","instance":9297,"id":212640,"goal":"lemma SetInterEmpty_9297(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_9298","instance":9298,"id":212641,"goal":"lemma SetInterSubset_9298(B: set, A: set)\n ensures B * A <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_9299","instance":9299,"id":212642,"goal":"lemma SetCardSubset_9299(S: set, A: set)\n requires S <= A\n ensures |S| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_9300","instance":9300,"id":212643,"goal":"lemma SetUnionCard_9300(A: set, S: set)\n requires A * S == {}\n ensures |A + S| == |A| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_9301","instance":9301,"id":212644,"goal":"lemma SetUnionComm_9301(T: set, S: set)\n ensures T + S == S + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_9302","instance":9302,"id":212645,"goal":"lemma SetInterComm_9302(A: set, U: set)\n ensures A * U == U * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_9303","instance":9303,"id":212646,"goal":"lemma SetUnionAssoc_9303(A: set, B: set, S: set)\n ensures (A + B) + S == A + (B + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_9304","instance":9304,"id":212647,"goal":"lemma SetSubsetRefl_9304(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_9305","instance":9305,"id":212648,"goal":"lemma SetSubsetTrans_9305(S: set, U: set, B: set)\n requires S <= U && U <= B\n ensures S <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_9306","instance":9306,"id":212649,"goal":"lemma SetUnionEmpty_9306(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_9307","instance":9307,"id":212650,"goal":"lemma SetInterEmpty_9307(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_9308","instance":9308,"id":212651,"goal":"lemma SetInterSubset_9308(B: set, A: set)\n ensures B * A <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_9309","instance":9309,"id":212652,"goal":"lemma SetCardSubset_9309(T: set, U: set)\n requires T <= U\n ensures |T| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_9310","instance":9310,"id":212653,"goal":"lemma SetUnionCard_9310(A: set, U: set)\n requires A * U == {}\n ensures |A + U| == |A| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_9311","instance":9311,"id":212654,"goal":"lemma SetUnionComm_9311(U: set, B: set)\n ensures U + B == B + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_9312","instance":9312,"id":212655,"goal":"lemma SetInterComm_9312(A: set, U: set)\n ensures A * U == U * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_9313","instance":9313,"id":212656,"goal":"lemma SetUnionAssoc_9313(U: set, T: set, A: set)\n ensures (U + T) + A == U + (T + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_9314","instance":9314,"id":212657,"goal":"lemma SetSubsetRefl_9314(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_9315","instance":9315,"id":212658,"goal":"lemma SetSubsetTrans_9315(S: set, U: set, T: set)\n requires S <= U && U <= T\n ensures S <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_9316","instance":9316,"id":212659,"goal":"lemma SetUnionEmpty_9316(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_9317","instance":9317,"id":212660,"goal":"lemma SetInterEmpty_9317(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_9318","instance":9318,"id":212661,"goal":"lemma SetInterSubset_9318(B: set, A: set)\n ensures B * A <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_9319","instance":9319,"id":212662,"goal":"lemma SetCardSubset_9319(B: set, U: set)\n requires B <= U\n ensures |B| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_9320","instance":9320,"id":212663,"goal":"lemma SetUnionCard_9320(S: set, A: set)\n requires S * A == {}\n ensures |S + A| == |S| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_9321","instance":9321,"id":212664,"goal":"lemma SetUnionComm_9321(A: set, U: set)\n ensures A + U == U + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_9322","instance":9322,"id":212665,"goal":"lemma SetInterComm_9322(T: set, S: set)\n ensures T * S == S * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_9323","instance":9323,"id":212666,"goal":"lemma SetUnionAssoc_9323(S: set, A: set, B: set)\n ensures (S + A) + B == S + (A + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_9324","instance":9324,"id":212667,"goal":"lemma SetSubsetRefl_9324(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_9325","instance":9325,"id":212668,"goal":"lemma SetSubsetTrans_9325(A: set, U: set, B: set)\n requires A <= U && U <= B\n ensures A <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_9326","instance":9326,"id":212669,"goal":"lemma SetUnionEmpty_9326(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_9327","instance":9327,"id":212670,"goal":"lemma SetInterEmpty_9327(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_9328","instance":9328,"id":212671,"goal":"lemma SetInterSubset_9328(S: set, A: set)\n ensures S * A <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_9329","instance":9329,"id":212672,"goal":"lemma SetCardSubset_9329(U: set, T: set)\n requires U <= T\n ensures |U| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_9330","instance":9330,"id":212673,"goal":"lemma SetUnionCard_9330(A: set, T: set)\n requires A * T == {}\n ensures |A + T| == |A| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_9331","instance":9331,"id":212674,"goal":"lemma SetUnionComm_9331(B: set, T: set)\n ensures B + T == T + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_9332","instance":9332,"id":212675,"goal":"lemma SetInterComm_9332(U: set, T: set)\n ensures U * T == T * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_9333","instance":9333,"id":212676,"goal":"lemma SetUnionAssoc_9333(A: set, U: set, S: set)\n ensures (A + U) + S == A + (U + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_9334","instance":9334,"id":212677,"goal":"lemma SetSubsetRefl_9334(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_9335","instance":9335,"id":212678,"goal":"lemma SetSubsetTrans_9335(U: set, S: set, T: set)\n requires U <= S && S <= T\n ensures U <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_9336","instance":9336,"id":212679,"goal":"lemma SetUnionEmpty_9336(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_9337","instance":9337,"id":212680,"goal":"lemma SetInterEmpty_9337(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_9338","instance":9338,"id":212681,"goal":"lemma SetInterSubset_9338(A: set, S: set)\n ensures A * S <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_9339","instance":9339,"id":212682,"goal":"lemma SetCardSubset_9339(U: set, S: set)\n requires U <= S\n ensures |U| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_9340","instance":9340,"id":212683,"goal":"lemma SetUnionCard_9340(U: set, S: set)\n requires U * S == {}\n ensures |U + S| == |U| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_9341","instance":9341,"id":212684,"goal":"lemma SetUnionComm_9341(B: set, S: set)\n ensures B + S == S + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_9342","instance":9342,"id":212685,"goal":"lemma SetInterComm_9342(A: set, S: set)\n ensures A * S == S * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_9343","instance":9343,"id":212686,"goal":"lemma SetUnionAssoc_9343(A: set, B: set, T: set)\n ensures (A + B) + T == A + (B + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_9344","instance":9344,"id":212687,"goal":"lemma SetSubsetRefl_9344(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_9345","instance":9345,"id":212688,"goal":"lemma SetSubsetTrans_9345(B: set, A: set, U: set)\n requires B <= A && A <= U\n ensures B <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_9346","instance":9346,"id":212689,"goal":"lemma SetUnionEmpty_9346(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_9347","instance":9347,"id":212690,"goal":"lemma SetInterEmpty_9347(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_9348","instance":9348,"id":212691,"goal":"lemma SetInterSubset_9348(S: set, A: set)\n ensures S * A <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_9349","instance":9349,"id":212692,"goal":"lemma SetCardSubset_9349(S: set, A: set)\n requires S <= A\n ensures |S| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_9350","instance":9350,"id":212693,"goal":"lemma SetUnionCard_9350(U: set, S: set)\n requires U * S == {}\n ensures |U + S| == |U| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_9351","instance":9351,"id":212694,"goal":"lemma SetUnionComm_9351(B: set, A: set)\n ensures B + A == A + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_9352","instance":9352,"id":212695,"goal":"lemma SetInterComm_9352(U: set, S: set)\n ensures U * S == S * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_9353","instance":9353,"id":212696,"goal":"lemma SetUnionAssoc_9353(S: set, A: set, U: set)\n ensures (S + A) + U == S + (A + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_9354","instance":9354,"id":212697,"goal":"lemma SetSubsetRefl_9354(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_9355","instance":9355,"id":212698,"goal":"lemma SetSubsetTrans_9355(S: set, A: set, B: set)\n requires S <= A && A <= B\n ensures S <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_9356","instance":9356,"id":212699,"goal":"lemma SetUnionEmpty_9356(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_9357","instance":9357,"id":212700,"goal":"lemma SetInterEmpty_9357(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_9358","instance":9358,"id":212701,"goal":"lemma SetInterSubset_9358(A: set, B: set)\n ensures A * B <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_9359","instance":9359,"id":212702,"goal":"lemma SetCardSubset_9359(U: set, T: set)\n requires U <= T\n ensures |U| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_9360","instance":9360,"id":212703,"goal":"lemma SetUnionCard_9360(T: set, U: set)\n requires T * U == {}\n ensures |T + U| == |T| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_9361","instance":9361,"id":212704,"goal":"lemma SetUnionComm_9361(U: set, S: set)\n ensures U + S == S + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_9362","instance":9362,"id":212705,"goal":"lemma SetInterComm_9362(U: set, A: set)\n ensures U * A == A * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_9363","instance":9363,"id":212706,"goal":"lemma SetUnionAssoc_9363(T: set, S: set, U: set)\n ensures (T + S) + U == T + (S + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_9364","instance":9364,"id":212707,"goal":"lemma SetSubsetRefl_9364(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_9365","instance":9365,"id":212708,"goal":"lemma SetSubsetTrans_9365(U: set, S: set, T: set)\n requires U <= S && S <= T\n ensures U <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_9366","instance":9366,"id":212709,"goal":"lemma SetUnionEmpty_9366(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_9367","instance":9367,"id":212710,"goal":"lemma SetInterEmpty_9367(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_9368","instance":9368,"id":212711,"goal":"lemma SetInterSubset_9368(A: set, S: set)\n ensures A * S <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_9369","instance":9369,"id":212712,"goal":"lemma SetCardSubset_9369(B: set, T: set)\n requires B <= T\n ensures |B| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_9370","instance":9370,"id":212713,"goal":"lemma SetUnionCard_9370(U: set, S: set)\n requires U * S == {}\n ensures |U + S| == |U| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_9371","instance":9371,"id":212714,"goal":"lemma SetUnionComm_9371(B: set, A: set)\n ensures B + A == A + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_9372","instance":9372,"id":212715,"goal":"lemma SetInterComm_9372(T: set, B: set)\n ensures T * B == B * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_9373","instance":9373,"id":212716,"goal":"lemma SetUnionAssoc_9373(A: set, U: set, S: set)\n ensures (A + U) + S == A + (U + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_9374","instance":9374,"id":212717,"goal":"lemma SetSubsetRefl_9374(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_9375","instance":9375,"id":212718,"goal":"lemma SetSubsetTrans_9375(U: set, A: set, S: set)\n requires U <= A && A <= S\n ensures U <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_9376","instance":9376,"id":212719,"goal":"lemma SetUnionEmpty_9376(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_9377","instance":9377,"id":212720,"goal":"lemma SetInterEmpty_9377(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_9378","instance":9378,"id":212721,"goal":"lemma SetInterSubset_9378(B: set, U: set)\n ensures B * U <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_9379","instance":9379,"id":212722,"goal":"lemma SetCardSubset_9379(S: set, U: set)\n requires S <= U\n ensures |S| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_9380","instance":9380,"id":212723,"goal":"lemma SetUnionCard_9380(S: set, B: set)\n requires S * B == {}\n ensures |S + B| == |S| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_9381","instance":9381,"id":212724,"goal":"lemma SetUnionComm_9381(U: set, A: set)\n ensures U + A == A + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_9382","instance":9382,"id":212725,"goal":"lemma SetInterComm_9382(T: set, A: set)\n ensures T * A == A * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_9383","instance":9383,"id":212726,"goal":"lemma SetUnionAssoc_9383(B: set, T: set, A: set)\n ensures (B + T) + A == B + (T + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_9384","instance":9384,"id":212727,"goal":"lemma SetSubsetRefl_9384(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_9385","instance":9385,"id":212728,"goal":"lemma SetSubsetTrans_9385(T: set, S: set, U: set)\n requires T <= S && S <= U\n ensures T <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_9386","instance":9386,"id":212729,"goal":"lemma SetUnionEmpty_9386(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_9387","instance":9387,"id":212730,"goal":"lemma SetInterEmpty_9387(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_9388","instance":9388,"id":212731,"goal":"lemma SetInterSubset_9388(T: set, B: set)\n ensures T * B <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_9389","instance":9389,"id":212732,"goal":"lemma SetCardSubset_9389(T: set, B: set)\n requires T <= B\n ensures |T| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_9390","instance":9390,"id":212733,"goal":"lemma SetUnionCard_9390(B: set, T: set)\n requires B * T == {}\n ensures |B + T| == |B| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_9391","instance":9391,"id":212734,"goal":"lemma SetUnionComm_9391(U: set, S: set)\n ensures U + S == S + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_9392","instance":9392,"id":212735,"goal":"lemma SetInterComm_9392(S: set, A: set)\n ensures S * A == A * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_9393","instance":9393,"id":212736,"goal":"lemma SetUnionAssoc_9393(T: set, S: set, U: set)\n ensures (T + S) + U == T + (S + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_9394","instance":9394,"id":212737,"goal":"lemma SetSubsetRefl_9394(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_9395","instance":9395,"id":212738,"goal":"lemma SetSubsetTrans_9395(A: set, B: set, T: set)\n requires A <= B && B <= T\n ensures A <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_9396","instance":9396,"id":212739,"goal":"lemma SetUnionEmpty_9396(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_9397","instance":9397,"id":212740,"goal":"lemma SetInterEmpty_9397(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_9398","instance":9398,"id":212741,"goal":"lemma SetInterSubset_9398(U: set, A: set)\n ensures U * A <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_9399","instance":9399,"id":212742,"goal":"lemma SetCardSubset_9399(T: set, S: set)\n requires T <= S\n ensures |T| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_9400","instance":9400,"id":212743,"goal":"lemma SetUnionCard_9400(T: set, S: set)\n requires T * S == {}\n ensures |T + S| == |T| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_9401","instance":9401,"id":212744,"goal":"lemma SetUnionComm_9401(B: set, T: set)\n ensures B + T == T + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_9402","instance":9402,"id":212745,"goal":"lemma SetInterComm_9402(U: set, B: set)\n ensures U * B == B * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_9403","instance":9403,"id":212746,"goal":"lemma SetUnionAssoc_9403(U: set, T: set, B: set)\n ensures (U + T) + B == U + (T + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_9404","instance":9404,"id":212747,"goal":"lemma SetSubsetRefl_9404(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_9405","instance":9405,"id":212748,"goal":"lemma SetSubsetTrans_9405(A: set, B: set, U: set)\n requires A <= B && B <= U\n ensures A <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_9406","instance":9406,"id":212749,"goal":"lemma SetUnionEmpty_9406(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_9407","instance":9407,"id":212750,"goal":"lemma SetInterEmpty_9407(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_9408","instance":9408,"id":212751,"goal":"lemma SetInterSubset_9408(U: set, S: set)\n ensures U * S <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_9409","instance":9409,"id":212752,"goal":"lemma SetCardSubset_9409(T: set, S: set)\n requires T <= S\n ensures |T| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_9410","instance":9410,"id":212753,"goal":"lemma SetUnionCard_9410(B: set, U: set)\n requires B * U == {}\n ensures |B + U| == |B| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_9411","instance":9411,"id":212754,"goal":"lemma SetUnionComm_9411(A: set, B: set)\n ensures A + B == B + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_9412","instance":9412,"id":212755,"goal":"lemma SetInterComm_9412(S: set, T: set)\n ensures S * T == T * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_9413","instance":9413,"id":212756,"goal":"lemma SetUnionAssoc_9413(A: set, S: set, B: set)\n ensures (A + S) + B == A + (S + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_9414","instance":9414,"id":212757,"goal":"lemma SetSubsetRefl_9414(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_9415","instance":9415,"id":212758,"goal":"lemma SetSubsetTrans_9415(S: set, B: set, T: set)\n requires S <= B && B <= T\n ensures S <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_9416","instance":9416,"id":212759,"goal":"lemma SetUnionEmpty_9416(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_9417","instance":9417,"id":212760,"goal":"lemma SetInterEmpty_9417(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_9418","instance":9418,"id":212761,"goal":"lemma SetInterSubset_9418(A: set, U: set)\n ensures A * U <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_9419","instance":9419,"id":212762,"goal":"lemma SetCardSubset_9419(A: set, S: set)\n requires A <= S\n ensures |A| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_9420","instance":9420,"id":212763,"goal":"lemma SetUnionCard_9420(B: set, S: set)\n requires B * S == {}\n ensures |B + S| == |B| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_9421","instance":9421,"id":212764,"goal":"lemma SetUnionComm_9421(A: set, U: set)\n ensures A + U == U + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_9422","instance":9422,"id":212765,"goal":"lemma SetInterComm_9422(T: set, A: set)\n ensures T * A == A * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_9423","instance":9423,"id":212766,"goal":"lemma SetUnionAssoc_9423(T: set, U: set, B: set)\n ensures (T + U) + B == T + (U + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_9424","instance":9424,"id":212767,"goal":"lemma SetSubsetRefl_9424(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_9425","instance":9425,"id":212768,"goal":"lemma SetSubsetTrans_9425(S: set, U: set, T: set)\n requires S <= U && U <= T\n ensures S <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_9426","instance":9426,"id":212769,"goal":"lemma SetUnionEmpty_9426(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_9427","instance":9427,"id":212770,"goal":"lemma SetInterEmpty_9427(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_9428","instance":9428,"id":212771,"goal":"lemma SetInterSubset_9428(B: set, T: set)\n ensures B * T <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_9429","instance":9429,"id":212772,"goal":"lemma SetCardSubset_9429(S: set, T: set)\n requires S <= T\n ensures |S| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_9430","instance":9430,"id":212773,"goal":"lemma SetUnionCard_9430(U: set, A: set)\n requires U * A == {}\n ensures |U + A| == |U| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_9431","instance":9431,"id":212774,"goal":"lemma SetUnionComm_9431(A: set, T: set)\n ensures A + T == T + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_9432","instance":9432,"id":212775,"goal":"lemma SetInterComm_9432(B: set, U: set)\n ensures B * U == U * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_9433","instance":9433,"id":212776,"goal":"lemma SetUnionAssoc_9433(B: set, U: set, S: set)\n ensures (B + U) + S == B + (U + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_9434","instance":9434,"id":212777,"goal":"lemma SetSubsetRefl_9434(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_9435","instance":9435,"id":212778,"goal":"lemma SetSubsetTrans_9435(U: set, B: set, T: set)\n requires U <= B && B <= T\n ensures U <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_9436","instance":9436,"id":212779,"goal":"lemma SetUnionEmpty_9436(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_9437","instance":9437,"id":212780,"goal":"lemma SetInterEmpty_9437(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_9438","instance":9438,"id":212781,"goal":"lemma SetInterSubset_9438(T: set, A: set)\n ensures T * A <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_9439","instance":9439,"id":212782,"goal":"lemma SetCardSubset_9439(S: set, T: set)\n requires S <= T\n ensures |S| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_9440","instance":9440,"id":212783,"goal":"lemma SetUnionCard_9440(A: set, T: set)\n requires A * T == {}\n ensures |A + T| == |A| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_9441","instance":9441,"id":212784,"goal":"lemma SetUnionComm_9441(S: set, T: set)\n ensures S + T == T + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_9442","instance":9442,"id":212785,"goal":"lemma SetInterComm_9442(S: set, B: set)\n ensures S * B == B * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_9443","instance":9443,"id":212786,"goal":"lemma SetUnionAssoc_9443(S: set, A: set, U: set)\n ensures (S + A) + U == S + (A + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_9444","instance":9444,"id":212787,"goal":"lemma SetSubsetRefl_9444(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_9445","instance":9445,"id":212788,"goal":"lemma SetSubsetTrans_9445(S: set, T: set, A: set)\n requires S <= T && T <= A\n ensures S <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_9446","instance":9446,"id":212789,"goal":"lemma SetUnionEmpty_9446(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_9447","instance":9447,"id":212790,"goal":"lemma SetInterEmpty_9447(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_9448","instance":9448,"id":212791,"goal":"lemma SetInterSubset_9448(S: set, T: set)\n ensures S * T <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_9449","instance":9449,"id":212792,"goal":"lemma SetCardSubset_9449(S: set, A: set)\n requires S <= A\n ensures |S| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_9450","instance":9450,"id":212793,"goal":"lemma SetUnionCard_9450(S: set, T: set)\n requires S * T == {}\n ensures |S + T| == |S| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_9451","instance":9451,"id":212794,"goal":"lemma SetUnionComm_9451(T: set, B: set)\n ensures T + B == B + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_9452","instance":9452,"id":212795,"goal":"lemma SetInterComm_9452(T: set, B: set)\n ensures T * B == B * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_9453","instance":9453,"id":212796,"goal":"lemma SetUnionAssoc_9453(T: set, U: set, A: set)\n ensures (T + U) + A == T + (U + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_9454","instance":9454,"id":212797,"goal":"lemma SetSubsetRefl_9454(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_9455","instance":9455,"id":212798,"goal":"lemma SetSubsetTrans_9455(A: set, U: set, T: set)\n requires A <= U && U <= T\n ensures A <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_9456","instance":9456,"id":212799,"goal":"lemma SetUnionEmpty_9456(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_9457","instance":9457,"id":212800,"goal":"lemma SetInterEmpty_9457(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_9458","instance":9458,"id":212801,"goal":"lemma SetInterSubset_9458(T: set, S: set)\n ensures T * S <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_9459","instance":9459,"id":212802,"goal":"lemma SetCardSubset_9459(A: set, S: set)\n requires A <= S\n ensures |A| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_9460","instance":9460,"id":212803,"goal":"lemma SetUnionCard_9460(S: set, T: set)\n requires S * T == {}\n ensures |S + T| == |S| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_9461","instance":9461,"id":212804,"goal":"lemma SetUnionComm_9461(S: set, U: set)\n ensures S + U == U + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_9462","instance":9462,"id":212805,"goal":"lemma SetInterComm_9462(A: set, B: set)\n ensures A * B == B * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_9463","instance":9463,"id":212806,"goal":"lemma SetUnionAssoc_9463(A: set, T: set, U: set)\n ensures (A + T) + U == A + (T + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_9464","instance":9464,"id":212807,"goal":"lemma SetSubsetRefl_9464(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_9465","instance":9465,"id":212808,"goal":"lemma SetSubsetTrans_9465(U: set, B: set, T: set)\n requires U <= B && B <= T\n ensures U <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_9466","instance":9466,"id":212809,"goal":"lemma SetUnionEmpty_9466(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_9467","instance":9467,"id":212810,"goal":"lemma SetInterEmpty_9467(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_9468","instance":9468,"id":212811,"goal":"lemma SetInterSubset_9468(B: set, A: set)\n ensures B * A <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_9469","instance":9469,"id":212812,"goal":"lemma SetCardSubset_9469(B: set, T: set)\n requires B <= T\n ensures |B| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_9470","instance":9470,"id":212813,"goal":"lemma SetUnionCard_9470(S: set, A: set)\n requires S * A == {}\n ensures |S + A| == |S| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_9471","instance":9471,"id":212814,"goal":"lemma SetUnionComm_9471(A: set, U: set)\n ensures A + U == U + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_9472","instance":9472,"id":212815,"goal":"lemma SetInterComm_9472(S: set, A: set)\n ensures S * A == A * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_9473","instance":9473,"id":212816,"goal":"lemma SetUnionAssoc_9473(S: set, A: set, U: set)\n ensures (S + A) + U == S + (A + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_9474","instance":9474,"id":212817,"goal":"lemma SetSubsetRefl_9474(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_9475","instance":9475,"id":212818,"goal":"lemma SetSubsetTrans_9475(S: set, T: set, U: set)\n requires S <= T && T <= U\n ensures S <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_9476","instance":9476,"id":212819,"goal":"lemma SetUnionEmpty_9476(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_9477","instance":9477,"id":212820,"goal":"lemma SetInterEmpty_9477(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_9478","instance":9478,"id":212821,"goal":"lemma SetInterSubset_9478(T: set, S: set)\n ensures T * S <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_9479","instance":9479,"id":212822,"goal":"lemma SetCardSubset_9479(T: set, A: set)\n requires T <= A\n ensures |T| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_9480","instance":9480,"id":212823,"goal":"lemma SetUnionCard_9480(T: set, U: set)\n requires T * U == {}\n ensures |T + U| == |T| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_9481","instance":9481,"id":212824,"goal":"lemma SetUnionComm_9481(B: set, T: set)\n ensures B + T == T + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_9482","instance":9482,"id":212825,"goal":"lemma SetInterComm_9482(T: set, A: set)\n ensures T * A == A * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_9483","instance":9483,"id":212826,"goal":"lemma SetUnionAssoc_9483(S: set, U: set, B: set)\n ensures (S + U) + B == S + (U + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_9484","instance":9484,"id":212827,"goal":"lemma SetSubsetRefl_9484(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_9485","instance":9485,"id":212828,"goal":"lemma SetSubsetTrans_9485(S: set, B: set, U: set)\n requires S <= B && B <= U\n ensures S <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_9486","instance":9486,"id":212829,"goal":"lemma SetUnionEmpty_9486(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_9487","instance":9487,"id":212830,"goal":"lemma SetInterEmpty_9487(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_9488","instance":9488,"id":212831,"goal":"lemma SetInterSubset_9488(U: set, T: set)\n ensures U * T <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_9489","instance":9489,"id":212832,"goal":"lemma SetCardSubset_9489(A: set, U: set)\n requires A <= U\n ensures |A| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_9490","instance":9490,"id":212833,"goal":"lemma SetUnionCard_9490(U: set, B: set)\n requires U * B == {}\n ensures |U + B| == |U| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_9491","instance":9491,"id":212834,"goal":"lemma SetUnionComm_9491(A: set, S: set)\n ensures A + S == S + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_9492","instance":9492,"id":212835,"goal":"lemma SetInterComm_9492(A: set, U: set)\n ensures A * U == U * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_9493","instance":9493,"id":212836,"goal":"lemma SetUnionAssoc_9493(S: set, A: set, B: set)\n ensures (S + A) + B == S + (A + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_9494","instance":9494,"id":212837,"goal":"lemma SetSubsetRefl_9494(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_9495","instance":9495,"id":212838,"goal":"lemma SetSubsetTrans_9495(A: set, T: set, S: set)\n requires A <= T && T <= S\n ensures A <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_9496","instance":9496,"id":212839,"goal":"lemma SetUnionEmpty_9496(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_9497","instance":9497,"id":212840,"goal":"lemma SetInterEmpty_9497(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_9498","instance":9498,"id":212841,"goal":"lemma SetInterSubset_9498(B: set, T: set)\n ensures B * T <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_9499","instance":9499,"id":212842,"goal":"lemma SetCardSubset_9499(A: set, B: set)\n requires A <= B\n ensures |A| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_9500","instance":9500,"id":212843,"goal":"lemma SetUnionCard_9500(A: set, B: set)\n requires A * B == {}\n ensures |A + B| == |A| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_9501","instance":9501,"id":212844,"goal":"lemma SetUnionComm_9501(T: set, U: set)\n ensures T + U == U + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_9502","instance":9502,"id":212845,"goal":"lemma SetInterComm_9502(B: set, U: set)\n ensures B * U == U * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_9503","instance":9503,"id":212846,"goal":"lemma SetUnionAssoc_9503(B: set, A: set, T: set)\n ensures (B + A) + T == B + (A + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_9504","instance":9504,"id":212847,"goal":"lemma SetSubsetRefl_9504(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_9505","instance":9505,"id":212848,"goal":"lemma SetSubsetTrans_9505(U: set, S: set, A: set)\n requires U <= S && S <= A\n ensures U <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_9506","instance":9506,"id":212849,"goal":"lemma SetUnionEmpty_9506(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_9507","instance":9507,"id":212850,"goal":"lemma SetInterEmpty_9507(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_9508","instance":9508,"id":212851,"goal":"lemma SetInterSubset_9508(U: set, B: set)\n ensures U * B <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_9509","instance":9509,"id":212852,"goal":"lemma SetCardSubset_9509(U: set, A: set)\n requires U <= A\n ensures |U| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_9510","instance":9510,"id":212853,"goal":"lemma SetUnionCard_9510(A: set, B: set)\n requires A * B == {}\n ensures |A + B| == |A| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_9511","instance":9511,"id":212854,"goal":"lemma SetUnionComm_9511(A: set, T: set)\n ensures A + T == T + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_9512","instance":9512,"id":212855,"goal":"lemma SetInterComm_9512(T: set, S: set)\n ensures T * S == S * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_9513","instance":9513,"id":212856,"goal":"lemma SetUnionAssoc_9513(B: set, A: set, T: set)\n ensures (B + A) + T == B + (A + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_9514","instance":9514,"id":212857,"goal":"lemma SetSubsetRefl_9514(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_9515","instance":9515,"id":212858,"goal":"lemma SetSubsetTrans_9515(A: set, T: set, U: set)\n requires A <= T && T <= U\n ensures A <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_9516","instance":9516,"id":212859,"goal":"lemma SetUnionEmpty_9516(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_9517","instance":9517,"id":212860,"goal":"lemma SetInterEmpty_9517(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_9518","instance":9518,"id":212861,"goal":"lemma SetInterSubset_9518(T: set, A: set)\n ensures T * A <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_9519","instance":9519,"id":212862,"goal":"lemma SetCardSubset_9519(T: set, S: set)\n requires T <= S\n ensures |T| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_9520","instance":9520,"id":212863,"goal":"lemma SetUnionCard_9520(B: set, U: set)\n requires B * U == {}\n ensures |B + U| == |B| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_9521","instance":9521,"id":212864,"goal":"lemma SetUnionComm_9521(S: set, A: set)\n ensures S + A == A + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_9522","instance":9522,"id":212865,"goal":"lemma SetInterComm_9522(A: set, B: set)\n ensures A * B == B * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_9523","instance":9523,"id":212866,"goal":"lemma SetUnionAssoc_9523(B: set, A: set, T: set)\n ensures (B + A) + T == B + (A + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_9524","instance":9524,"id":212867,"goal":"lemma SetSubsetRefl_9524(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_9525","instance":9525,"id":212868,"goal":"lemma SetSubsetTrans_9525(A: set, U: set, T: set)\n requires A <= U && U <= T\n ensures A <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_9526","instance":9526,"id":212869,"goal":"lemma SetUnionEmpty_9526(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_9527","instance":9527,"id":212870,"goal":"lemma SetInterEmpty_9527(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_9528","instance":9528,"id":212871,"goal":"lemma SetInterSubset_9528(U: set, S: set)\n ensures U * S <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_9529","instance":9529,"id":212872,"goal":"lemma SetCardSubset_9529(U: set, S: set)\n requires U <= S\n ensures |U| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_9530","instance":9530,"id":212873,"goal":"lemma SetUnionCard_9530(U: set, A: set)\n requires U * A == {}\n ensures |U + A| == |U| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_9531","instance":9531,"id":212874,"goal":"lemma SetUnionComm_9531(U: set, B: set)\n ensures U + B == B + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_9532","instance":9532,"id":212875,"goal":"lemma SetInterComm_9532(U: set, A: set)\n ensures U * A == A * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_9533","instance":9533,"id":212876,"goal":"lemma SetUnionAssoc_9533(T: set, B: set, A: set)\n ensures (T + B) + A == T + (B + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_9534","instance":9534,"id":212877,"goal":"lemma SetSubsetRefl_9534(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_9535","instance":9535,"id":212878,"goal":"lemma SetSubsetTrans_9535(B: set, S: set, U: set)\n requires B <= S && S <= U\n ensures B <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_9536","instance":9536,"id":212879,"goal":"lemma SetUnionEmpty_9536(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_9537","instance":9537,"id":212880,"goal":"lemma SetInterEmpty_9537(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_9538","instance":9538,"id":212881,"goal":"lemma SetInterSubset_9538(B: set, A: set)\n ensures B * A <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_9539","instance":9539,"id":212882,"goal":"lemma SetCardSubset_9539(U: set, T: set)\n requires U <= T\n ensures |U| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_9540","instance":9540,"id":212883,"goal":"lemma SetUnionCard_9540(B: set, U: set)\n requires B * U == {}\n ensures |B + U| == |B| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_9541","instance":9541,"id":212884,"goal":"lemma SetUnionComm_9541(S: set, T: set)\n ensures S + T == T + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_9542","instance":9542,"id":212885,"goal":"lemma SetInterComm_9542(U: set, B: set)\n ensures U * B == B * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_9543","instance":9543,"id":212886,"goal":"lemma SetUnionAssoc_9543(A: set, T: set, B: set)\n ensures (A + T) + B == A + (T + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_9544","instance":9544,"id":212887,"goal":"lemma SetSubsetRefl_9544(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_9545","instance":9545,"id":212888,"goal":"lemma SetSubsetTrans_9545(B: set, U: set, T: set)\n requires B <= U && U <= T\n ensures B <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_9546","instance":9546,"id":212889,"goal":"lemma SetUnionEmpty_9546(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_9547","instance":9547,"id":212890,"goal":"lemma SetInterEmpty_9547(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_9548","instance":9548,"id":212891,"goal":"lemma SetInterSubset_9548(S: set, U: set)\n ensures S * U <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_9549","instance":9549,"id":212892,"goal":"lemma SetCardSubset_9549(U: set, B: set)\n requires U <= B\n ensures |U| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_9550","instance":9550,"id":212893,"goal":"lemma SetUnionCard_9550(T: set, S: set)\n requires T * S == {}\n ensures |T + S| == |T| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_9551","instance":9551,"id":212894,"goal":"lemma SetUnionComm_9551(T: set, B: set)\n ensures T + B == B + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_9552","instance":9552,"id":212895,"goal":"lemma SetInterComm_9552(U: set, B: set)\n ensures U * B == B * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_9553","instance":9553,"id":212896,"goal":"lemma SetUnionAssoc_9553(T: set, U: set, B: set)\n ensures (T + U) + B == T + (U + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_9554","instance":9554,"id":212897,"goal":"lemma SetSubsetRefl_9554(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_9555","instance":9555,"id":212898,"goal":"lemma SetSubsetTrans_9555(B: set, T: set, U: set)\n requires B <= T && T <= U\n ensures B <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_9556","instance":9556,"id":212899,"goal":"lemma SetUnionEmpty_9556(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_9557","instance":9557,"id":212900,"goal":"lemma SetInterEmpty_9557(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_9558","instance":9558,"id":212901,"goal":"lemma SetInterSubset_9558(T: set, A: set)\n ensures T * A <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_9559","instance":9559,"id":212902,"goal":"lemma SetCardSubset_9559(S: set, A: set)\n requires S <= A\n ensures |S| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_9560","instance":9560,"id":212903,"goal":"lemma SetUnionCard_9560(S: set, U: set)\n requires S * U == {}\n ensures |S + U| == |S| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_9561","instance":9561,"id":212904,"goal":"lemma SetUnionComm_9561(S: set, B: set)\n ensures S + B == B + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_9562","instance":9562,"id":212905,"goal":"lemma SetInterComm_9562(T: set, A: set)\n ensures T * A == A * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_9563","instance":9563,"id":212906,"goal":"lemma SetUnionAssoc_9563(T: set, B: set, S: set)\n ensures (T + B) + S == T + (B + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_9564","instance":9564,"id":212907,"goal":"lemma SetSubsetRefl_9564(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_9565","instance":9565,"id":212908,"goal":"lemma SetSubsetTrans_9565(U: set, A: set, S: set)\n requires U <= A && A <= S\n ensures U <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_9566","instance":9566,"id":212909,"goal":"lemma SetUnionEmpty_9566(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_9567","instance":9567,"id":212910,"goal":"lemma SetInterEmpty_9567(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_9568","instance":9568,"id":212911,"goal":"lemma SetInterSubset_9568(S: set, U: set)\n ensures S * U <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_9569","instance":9569,"id":212912,"goal":"lemma SetCardSubset_9569(S: set, A: set)\n requires S <= A\n ensures |S| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_9570","instance":9570,"id":212913,"goal":"lemma SetUnionCard_9570(A: set, T: set)\n requires A * T == {}\n ensures |A + T| == |A| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_9571","instance":9571,"id":212914,"goal":"lemma SetUnionComm_9571(U: set, S: set)\n ensures U + S == S + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_9572","instance":9572,"id":212915,"goal":"lemma SetInterComm_9572(A: set, T: set)\n ensures A * T == T * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_9573","instance":9573,"id":212916,"goal":"lemma SetUnionAssoc_9573(S: set, A: set, U: set)\n ensures (S + A) + U == S + (A + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_9574","instance":9574,"id":212917,"goal":"lemma SetSubsetRefl_9574(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_9575","instance":9575,"id":212918,"goal":"lemma SetSubsetTrans_9575(B: set, T: set, S: set)\n requires B <= T && T <= S\n ensures B <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_9576","instance":9576,"id":212919,"goal":"lemma SetUnionEmpty_9576(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_9577","instance":9577,"id":212920,"goal":"lemma SetInterEmpty_9577(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_9578","instance":9578,"id":212921,"goal":"lemma SetInterSubset_9578(B: set, U: set)\n ensures B * U <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_9579","instance":9579,"id":212922,"goal":"lemma SetCardSubset_9579(B: set, S: set)\n requires B <= S\n ensures |B| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_9580","instance":9580,"id":212923,"goal":"lemma SetUnionCard_9580(A: set, S: set)\n requires A * S == {}\n ensures |A + S| == |A| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_9581","instance":9581,"id":212924,"goal":"lemma SetUnionComm_9581(B: set, A: set)\n ensures B + A == A + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_9582","instance":9582,"id":212925,"goal":"lemma SetInterComm_9582(U: set, T: set)\n ensures U * T == T * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_9583","instance":9583,"id":212926,"goal":"lemma SetUnionAssoc_9583(T: set, S: set, B: set)\n ensures (T + S) + B == T + (S + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_9584","instance":9584,"id":212927,"goal":"lemma SetSubsetRefl_9584(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_9585","instance":9585,"id":212928,"goal":"lemma SetSubsetTrans_9585(A: set, B: set, S: set)\n requires A <= B && B <= S\n ensures A <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_9586","instance":9586,"id":212929,"goal":"lemma SetUnionEmpty_9586(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_9587","instance":9587,"id":212930,"goal":"lemma SetInterEmpty_9587(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_9588","instance":9588,"id":212931,"goal":"lemma SetInterSubset_9588(A: set, B: set)\n ensures A * B <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_9589","instance":9589,"id":212932,"goal":"lemma SetCardSubset_9589(T: set, U: set)\n requires T <= U\n ensures |T| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_9590","instance":9590,"id":212933,"goal":"lemma SetUnionCard_9590(S: set, T: set)\n requires S * T == {}\n ensures |S + T| == |S| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_9591","instance":9591,"id":212934,"goal":"lemma SetUnionComm_9591(B: set, A: set)\n ensures B + A == A + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_9592","instance":9592,"id":212935,"goal":"lemma SetInterComm_9592(A: set, B: set)\n ensures A * B == B * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_9593","instance":9593,"id":212936,"goal":"lemma SetUnionAssoc_9593(S: set, A: set, U: set)\n ensures (S + A) + U == S + (A + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_9594","instance":9594,"id":212937,"goal":"lemma SetSubsetRefl_9594(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_9595","instance":9595,"id":212938,"goal":"lemma SetSubsetTrans_9595(A: set, B: set, U: set)\n requires A <= B && B <= U\n ensures A <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_9596","instance":9596,"id":212939,"goal":"lemma SetUnionEmpty_9596(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_9597","instance":9597,"id":212940,"goal":"lemma SetInterEmpty_9597(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_9598","instance":9598,"id":212941,"goal":"lemma SetInterSubset_9598(S: set, T: set)\n ensures S * T <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_9599","instance":9599,"id":212942,"goal":"lemma SetCardSubset_9599(A: set, S: set)\n requires A <= S\n ensures |A| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_9600","instance":9600,"id":212943,"goal":"lemma SetUnionCard_9600(S: set, U: set)\n requires S * U == {}\n ensures |S + U| == |S| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_9601","instance":9601,"id":212944,"goal":"lemma SetUnionComm_9601(U: set, B: set)\n ensures U + B == B + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_9602","instance":9602,"id":212945,"goal":"lemma SetInterComm_9602(S: set, U: set)\n ensures S * U == U * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_9603","instance":9603,"id":212946,"goal":"lemma SetUnionAssoc_9603(T: set, A: set, B: set)\n ensures (T + A) + B == T + (A + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_9604","instance":9604,"id":212947,"goal":"lemma SetSubsetRefl_9604(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_9605","instance":9605,"id":212948,"goal":"lemma SetSubsetTrans_9605(A: set, S: set, U: set)\n requires A <= S && S <= U\n ensures A <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_9606","instance":9606,"id":212949,"goal":"lemma SetUnionEmpty_9606(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_9607","instance":9607,"id":212950,"goal":"lemma SetInterEmpty_9607(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_9608","instance":9608,"id":212951,"goal":"lemma SetInterSubset_9608(U: set, B: set)\n ensures U * B <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_9609","instance":9609,"id":212952,"goal":"lemma SetCardSubset_9609(T: set, U: set)\n requires T <= U\n ensures |T| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_9610","instance":9610,"id":212953,"goal":"lemma SetUnionCard_9610(B: set, S: set)\n requires B * S == {}\n ensures |B + S| == |B| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_9611","instance":9611,"id":212954,"goal":"lemma SetUnionComm_9611(A: set, B: set)\n ensures A + B == B + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_9612","instance":9612,"id":212955,"goal":"lemma SetInterComm_9612(U: set, B: set)\n ensures U * B == B * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_9613","instance":9613,"id":212956,"goal":"lemma SetUnionAssoc_9613(S: set, B: set, U: set)\n ensures (S + B) + U == S + (B + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_9614","instance":9614,"id":212957,"goal":"lemma SetSubsetRefl_9614(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_9615","instance":9615,"id":212958,"goal":"lemma SetSubsetTrans_9615(S: set, T: set, B: set)\n requires S <= T && T <= B\n ensures S <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_9616","instance":9616,"id":212959,"goal":"lemma SetUnionEmpty_9616(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_9617","instance":9617,"id":212960,"goal":"lemma SetInterEmpty_9617(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_9618","instance":9618,"id":212961,"goal":"lemma SetInterSubset_9618(S: set, T: set)\n ensures S * T <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_9619","instance":9619,"id":212962,"goal":"lemma SetCardSubset_9619(S: set, B: set)\n requires S <= B\n ensures |S| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_9620","instance":9620,"id":212963,"goal":"lemma SetUnionCard_9620(T: set, A: set)\n requires T * A == {}\n ensures |T + A| == |T| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_9621","instance":9621,"id":212964,"goal":"lemma SetUnionComm_9621(S: set, B: set)\n ensures S + B == B + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_9622","instance":9622,"id":212965,"goal":"lemma SetInterComm_9622(S: set, T: set)\n ensures S * T == T * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_9623","instance":9623,"id":212966,"goal":"lemma SetUnionAssoc_9623(U: set, B: set, T: set)\n ensures (U + B) + T == U + (B + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_9624","instance":9624,"id":212967,"goal":"lemma SetSubsetRefl_9624(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_9625","instance":9625,"id":212968,"goal":"lemma SetSubsetTrans_9625(T: set, B: set, U: set)\n requires T <= B && B <= U\n ensures T <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_9626","instance":9626,"id":212969,"goal":"lemma SetUnionEmpty_9626(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_9627","instance":9627,"id":212970,"goal":"lemma SetInterEmpty_9627(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_9628","instance":9628,"id":212971,"goal":"lemma SetInterSubset_9628(A: set, U: set)\n ensures A * U <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_9629","instance":9629,"id":212972,"goal":"lemma SetCardSubset_9629(S: set, A: set)\n requires S <= A\n ensures |S| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_9630","instance":9630,"id":212973,"goal":"lemma SetUnionCard_9630(T: set, U: set)\n requires T * U == {}\n ensures |T + U| == |T| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_9631","instance":9631,"id":212974,"goal":"lemma SetUnionComm_9631(S: set, T: set)\n ensures S + T == T + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_9632","instance":9632,"id":212975,"goal":"lemma SetInterComm_9632(T: set, B: set)\n ensures T * B == B * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_9633","instance":9633,"id":212976,"goal":"lemma SetUnionAssoc_9633(T: set, U: set, A: set)\n ensures (T + U) + A == T + (U + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_9634","instance":9634,"id":212977,"goal":"lemma SetSubsetRefl_9634(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_9635","instance":9635,"id":212978,"goal":"lemma SetSubsetTrans_9635(U: set, A: set, S: set)\n requires U <= A && A <= S\n ensures U <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_9636","instance":9636,"id":212979,"goal":"lemma SetUnionEmpty_9636(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_9637","instance":9637,"id":212980,"goal":"lemma SetInterEmpty_9637(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_9638","instance":9638,"id":212981,"goal":"lemma SetInterSubset_9638(U: set, B: set)\n ensures U * B <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_9639","instance":9639,"id":212982,"goal":"lemma SetCardSubset_9639(A: set, B: set)\n requires A <= B\n ensures |A| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_9640","instance":9640,"id":212983,"goal":"lemma SetUnionCard_9640(U: set, T: set)\n requires U * T == {}\n ensures |U + T| == |U| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_9641","instance":9641,"id":212984,"goal":"lemma SetUnionComm_9641(S: set, A: set)\n ensures S + A == A + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_9642","instance":9642,"id":212985,"goal":"lemma SetInterComm_9642(A: set, S: set)\n ensures A * S == S * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_9643","instance":9643,"id":212986,"goal":"lemma SetUnionAssoc_9643(T: set, A: set, S: set)\n ensures (T + A) + S == T + (A + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_9644","instance":9644,"id":212987,"goal":"lemma SetSubsetRefl_9644(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_9645","instance":9645,"id":212988,"goal":"lemma SetSubsetTrans_9645(A: set, T: set, U: set)\n requires A <= T && T <= U\n ensures A <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_9646","instance":9646,"id":212989,"goal":"lemma SetUnionEmpty_9646(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_9647","instance":9647,"id":212990,"goal":"lemma SetInterEmpty_9647(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_9648","instance":9648,"id":212991,"goal":"lemma SetInterSubset_9648(T: set, S: set)\n ensures T * S <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_9649","instance":9649,"id":212992,"goal":"lemma SetCardSubset_9649(S: set, A: set)\n requires S <= A\n ensures |S| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_9650","instance":9650,"id":212993,"goal":"lemma SetUnionCard_9650(S: set, B: set)\n requires S * B == {}\n ensures |S + B| == |S| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_9651","instance":9651,"id":212994,"goal":"lemma SetUnionComm_9651(A: set, S: set)\n ensures A + S == S + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_9652","instance":9652,"id":212995,"goal":"lemma SetInterComm_9652(U: set, S: set)\n ensures U * S == S * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_9653","instance":9653,"id":212996,"goal":"lemma SetUnionAssoc_9653(A: set, U: set, S: set)\n ensures (A + U) + S == A + (U + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_9654","instance":9654,"id":212997,"goal":"lemma SetSubsetRefl_9654(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_9655","instance":9655,"id":212998,"goal":"lemma SetSubsetTrans_9655(B: set, U: set, T: set)\n requires B <= U && U <= T\n ensures B <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_9656","instance":9656,"id":212999,"goal":"lemma SetUnionEmpty_9656(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_9657","instance":9657,"id":213000,"goal":"lemma SetInterEmpty_9657(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_9658","instance":9658,"id":213001,"goal":"lemma SetInterSubset_9658(S: set, B: set)\n ensures S * B <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_9659","instance":9659,"id":213002,"goal":"lemma SetCardSubset_9659(A: set, T: set)\n requires A <= T\n ensures |A| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_9660","instance":9660,"id":213003,"goal":"lemma SetUnionCard_9660(S: set, A: set)\n requires S * A == {}\n ensures |S + A| == |S| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_9661","instance":9661,"id":213004,"goal":"lemma SetUnionComm_9661(B: set, A: set)\n ensures B + A == A + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_9662","instance":9662,"id":213005,"goal":"lemma SetInterComm_9662(B: set, T: set)\n ensures B * T == T * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_9663","instance":9663,"id":213006,"goal":"lemma SetUnionAssoc_9663(A: set, S: set, B: set)\n ensures (A + S) + B == A + (S + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_9664","instance":9664,"id":213007,"goal":"lemma SetSubsetRefl_9664(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_9665","instance":9665,"id":213008,"goal":"lemma SetSubsetTrans_9665(S: set, T: set, A: set)\n requires S <= T && T <= A\n ensures S <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_9666","instance":9666,"id":213009,"goal":"lemma SetUnionEmpty_9666(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_9667","instance":9667,"id":213010,"goal":"lemma SetInterEmpty_9667(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_9668","instance":9668,"id":213011,"goal":"lemma SetInterSubset_9668(B: set, S: set)\n ensures B * S <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_9669","instance":9669,"id":213012,"goal":"lemma SetCardSubset_9669(A: set, B: set)\n requires A <= B\n ensures |A| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_9670","instance":9670,"id":213013,"goal":"lemma SetUnionCard_9670(B: set, U: set)\n requires B * U == {}\n ensures |B + U| == |B| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_9671","instance":9671,"id":213014,"goal":"lemma SetUnionComm_9671(U: set, A: set)\n ensures U + A == A + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_9672","instance":9672,"id":213015,"goal":"lemma SetInterComm_9672(B: set, S: set)\n ensures B * S == S * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_9673","instance":9673,"id":213016,"goal":"lemma SetUnionAssoc_9673(B: set, A: set, T: set)\n ensures (B + A) + T == B + (A + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_9674","instance":9674,"id":213017,"goal":"lemma SetSubsetRefl_9674(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_9675","instance":9675,"id":213018,"goal":"lemma SetSubsetTrans_9675(U: set, A: set, B: set)\n requires U <= A && A <= B\n ensures U <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_9676","instance":9676,"id":213019,"goal":"lemma SetUnionEmpty_9676(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_9677","instance":9677,"id":213020,"goal":"lemma SetInterEmpty_9677(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_9678","instance":9678,"id":213021,"goal":"lemma SetInterSubset_9678(U: set, T: set)\n ensures U * T <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_9679","instance":9679,"id":213022,"goal":"lemma SetCardSubset_9679(U: set, A: set)\n requires U <= A\n ensures |U| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_9680","instance":9680,"id":213023,"goal":"lemma SetUnionCard_9680(T: set, A: set)\n requires T * A == {}\n ensures |T + A| == |T| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_9681","instance":9681,"id":213024,"goal":"lemma SetUnionComm_9681(U: set, B: set)\n ensures U + B == B + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_9682","instance":9682,"id":213025,"goal":"lemma SetInterComm_9682(S: set, T: set)\n ensures S * T == T * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_9683","instance":9683,"id":213026,"goal":"lemma SetUnionAssoc_9683(S: set, U: set, A: set)\n ensures (S + U) + A == S + (U + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_9684","instance":9684,"id":213027,"goal":"lemma SetSubsetRefl_9684(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_9685","instance":9685,"id":213028,"goal":"lemma SetSubsetTrans_9685(S: set, A: set, B: set)\n requires S <= A && A <= B\n ensures S <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_9686","instance":9686,"id":213029,"goal":"lemma SetUnionEmpty_9686(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_9687","instance":9687,"id":213030,"goal":"lemma SetInterEmpty_9687(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_9688","instance":9688,"id":213031,"goal":"lemma SetInterSubset_9688(A: set, S: set)\n ensures A * S <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_9689","instance":9689,"id":213032,"goal":"lemma SetCardSubset_9689(B: set, A: set)\n requires B <= A\n ensures |B| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_9690","instance":9690,"id":213033,"goal":"lemma SetUnionCard_9690(U: set, B: set)\n requires U * B == {}\n ensures |U + B| == |U| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_9691","instance":9691,"id":213034,"goal":"lemma SetUnionComm_9691(A: set, B: set)\n ensures A + B == B + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_9692","instance":9692,"id":213035,"goal":"lemma SetInterComm_9692(U: set, B: set)\n ensures U * B == B * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_9693","instance":9693,"id":213036,"goal":"lemma SetUnionAssoc_9693(B: set, T: set, S: set)\n ensures (B + T) + S == B + (T + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_9694","instance":9694,"id":213037,"goal":"lemma SetSubsetRefl_9694(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_9695","instance":9695,"id":213038,"goal":"lemma SetSubsetTrans_9695(A: set, S: set, B: set)\n requires A <= S && S <= B\n ensures A <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_9696","instance":9696,"id":213039,"goal":"lemma SetUnionEmpty_9696(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_9697","instance":9697,"id":213040,"goal":"lemma SetInterEmpty_9697(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_9698","instance":9698,"id":213041,"goal":"lemma SetInterSubset_9698(A: set, U: set)\n ensures A * U <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_9699","instance":9699,"id":213042,"goal":"lemma SetCardSubset_9699(U: set, T: set)\n requires U <= T\n ensures |U| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_9700","instance":9700,"id":213043,"goal":"lemma SetUnionCard_9700(B: set, A: set)\n requires B * A == {}\n ensures |B + A| == |B| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_9701","instance":9701,"id":213044,"goal":"lemma SetUnionComm_9701(A: set, T: set)\n ensures A + T == T + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_9702","instance":9702,"id":213045,"goal":"lemma SetInterComm_9702(U: set, B: set)\n ensures U * B == B * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_9703","instance":9703,"id":213046,"goal":"lemma SetUnionAssoc_9703(B: set, T: set, A: set)\n ensures (B + T) + A == B + (T + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_9704","instance":9704,"id":213047,"goal":"lemma SetSubsetRefl_9704(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_9705","instance":9705,"id":213048,"goal":"lemma SetSubsetTrans_9705(B: set, T: set, U: set)\n requires B <= T && T <= U\n ensures B <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_9706","instance":9706,"id":213049,"goal":"lemma SetUnionEmpty_9706(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_9707","instance":9707,"id":213050,"goal":"lemma SetInterEmpty_9707(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_9708","instance":9708,"id":213051,"goal":"lemma SetInterSubset_9708(U: set, S: set)\n ensures U * S <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_9709","instance":9709,"id":213052,"goal":"lemma SetCardSubset_9709(T: set, A: set)\n requires T <= A\n ensures |T| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_9710","instance":9710,"id":213053,"goal":"lemma SetUnionCard_9710(U: set, B: set)\n requires U * B == {}\n ensures |U + B| == |U| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_9711","instance":9711,"id":213054,"goal":"lemma SetUnionComm_9711(U: set, T: set)\n ensures U + T == T + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_9712","instance":9712,"id":213055,"goal":"lemma SetInterComm_9712(T: set, S: set)\n ensures T * S == S * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_9713","instance":9713,"id":213056,"goal":"lemma SetUnionAssoc_9713(S: set, T: set, U: set)\n ensures (S + T) + U == S + (T + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_9714","instance":9714,"id":213057,"goal":"lemma SetSubsetRefl_9714(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_9715","instance":9715,"id":213058,"goal":"lemma SetSubsetTrans_9715(S: set, T: set, B: set)\n requires S <= T && T <= B\n ensures S <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_9716","instance":9716,"id":213059,"goal":"lemma SetUnionEmpty_9716(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_9717","instance":9717,"id":213060,"goal":"lemma SetInterEmpty_9717(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_9718","instance":9718,"id":213061,"goal":"lemma SetInterSubset_9718(S: set, A: set)\n ensures S * A <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_9719","instance":9719,"id":213062,"goal":"lemma SetCardSubset_9719(S: set, U: set)\n requires S <= U\n ensures |S| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_9720","instance":9720,"id":213063,"goal":"lemma SetUnionCard_9720(U: set, S: set)\n requires U * S == {}\n ensures |U + S| == |U| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_9721","instance":9721,"id":213064,"goal":"lemma SetUnionComm_9721(T: set, S: set)\n ensures T + S == S + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_9722","instance":9722,"id":213065,"goal":"lemma SetInterComm_9722(T: set, U: set)\n ensures T * U == U * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_9723","instance":9723,"id":213066,"goal":"lemma SetUnionAssoc_9723(U: set, B: set, A: set)\n ensures (U + B) + A == U + (B + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_9724","instance":9724,"id":213067,"goal":"lemma SetSubsetRefl_9724(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_9725","instance":9725,"id":213068,"goal":"lemma SetSubsetTrans_9725(U: set, B: set, T: set)\n requires U <= B && B <= T\n ensures U <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_9726","instance":9726,"id":213069,"goal":"lemma SetUnionEmpty_9726(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_9727","instance":9727,"id":213070,"goal":"lemma SetInterEmpty_9727(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_9728","instance":9728,"id":213071,"goal":"lemma SetInterSubset_9728(S: set, A: set)\n ensures S * A <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_9729","instance":9729,"id":213072,"goal":"lemma SetCardSubset_9729(U: set, T: set)\n requires U <= T\n ensures |U| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_9730","instance":9730,"id":213073,"goal":"lemma SetUnionCard_9730(S: set, U: set)\n requires S * U == {}\n ensures |S + U| == |S| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_9731","instance":9731,"id":213074,"goal":"lemma SetUnionComm_9731(S: set, U: set)\n ensures S + U == U + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_9732","instance":9732,"id":213075,"goal":"lemma SetInterComm_9732(U: set, A: set)\n ensures U * A == A * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_9733","instance":9733,"id":213076,"goal":"lemma SetUnionAssoc_9733(A: set, B: set, U: set)\n ensures (A + B) + U == A + (B + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_9734","instance":9734,"id":213077,"goal":"lemma SetSubsetRefl_9734(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_9735","instance":9735,"id":213078,"goal":"lemma SetSubsetTrans_9735(S: set, T: set, B: set)\n requires S <= T && T <= B\n ensures S <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_9736","instance":9736,"id":213079,"goal":"lemma SetUnionEmpty_9736(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_9737","instance":9737,"id":213080,"goal":"lemma SetInterEmpty_9737(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_9738","instance":9738,"id":213081,"goal":"lemma SetInterSubset_9738(B: set, A: set)\n ensures B * A <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_9739","instance":9739,"id":213082,"goal":"lemma SetCardSubset_9739(B: set, U: set)\n requires B <= U\n ensures |B| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_9740","instance":9740,"id":213083,"goal":"lemma SetUnionCard_9740(U: set, S: set)\n requires U * S == {}\n ensures |U + S| == |U| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_9741","instance":9741,"id":213084,"goal":"lemma SetUnionComm_9741(T: set, U: set)\n ensures T + U == U + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_9742","instance":9742,"id":213085,"goal":"lemma SetInterComm_9742(T: set, B: set)\n ensures T * B == B * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_9743","instance":9743,"id":213086,"goal":"lemma SetUnionAssoc_9743(B: set, T: set, U: set)\n ensures (B + T) + U == B + (T + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_9744","instance":9744,"id":213087,"goal":"lemma SetSubsetRefl_9744(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_9745","instance":9745,"id":213088,"goal":"lemma SetSubsetTrans_9745(A: set, U: set, S: set)\n requires A <= U && U <= S\n ensures A <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_9746","instance":9746,"id":213089,"goal":"lemma SetUnionEmpty_9746(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_9747","instance":9747,"id":213090,"goal":"lemma SetInterEmpty_9747(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_9748","instance":9748,"id":213091,"goal":"lemma SetInterSubset_9748(S: set, T: set)\n ensures S * T <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_9749","instance":9749,"id":213092,"goal":"lemma SetCardSubset_9749(S: set, A: set)\n requires S <= A\n ensures |S| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_9750","instance":9750,"id":213093,"goal":"lemma SetUnionCard_9750(U: set, S: set)\n requires U * S == {}\n ensures |U + S| == |U| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_9751","instance":9751,"id":213094,"goal":"lemma SetUnionComm_9751(A: set, S: set)\n ensures A + S == S + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_9752","instance":9752,"id":213095,"goal":"lemma SetInterComm_9752(U: set, T: set)\n ensures U * T == T * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_9753","instance":9753,"id":213096,"goal":"lemma SetUnionAssoc_9753(A: set, T: set, B: set)\n ensures (A + T) + B == A + (T + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_9754","instance":9754,"id":213097,"goal":"lemma SetSubsetRefl_9754(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_9755","instance":9755,"id":213098,"goal":"lemma SetSubsetTrans_9755(T: set, U: set, B: set)\n requires T <= U && U <= B\n ensures T <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_9756","instance":9756,"id":213099,"goal":"lemma SetUnionEmpty_9756(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_9757","instance":9757,"id":213100,"goal":"lemma SetInterEmpty_9757(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_9758","instance":9758,"id":213101,"goal":"lemma SetInterSubset_9758(S: set, T: set)\n ensures S * T <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_9759","instance":9759,"id":213102,"goal":"lemma SetCardSubset_9759(B: set, S: set)\n requires B <= S\n ensures |B| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_9760","instance":9760,"id":213103,"goal":"lemma SetUnionCard_9760(T: set, A: set)\n requires T * A == {}\n ensures |T + A| == |T| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_9761","instance":9761,"id":213104,"goal":"lemma SetUnionComm_9761(S: set, B: set)\n ensures S + B == B + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_9762","instance":9762,"id":213105,"goal":"lemma SetInterComm_9762(U: set, S: set)\n ensures U * S == S * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_9763","instance":9763,"id":213106,"goal":"lemma SetUnionAssoc_9763(U: set, B: set, A: set)\n ensures (U + B) + A == U + (B + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_9764","instance":9764,"id":213107,"goal":"lemma SetSubsetRefl_9764(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_9765","instance":9765,"id":213108,"goal":"lemma SetSubsetTrans_9765(B: set, S: set, A: set)\n requires B <= S && S <= A\n ensures B <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_9766","instance":9766,"id":213109,"goal":"lemma SetUnionEmpty_9766(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_9767","instance":9767,"id":213110,"goal":"lemma SetInterEmpty_9767(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_9768","instance":9768,"id":213111,"goal":"lemma SetInterSubset_9768(A: set, U: set)\n ensures A * U <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_9769","instance":9769,"id":213112,"goal":"lemma SetCardSubset_9769(U: set, B: set)\n requires U <= B\n ensures |U| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_9770","instance":9770,"id":213113,"goal":"lemma SetUnionCard_9770(A: set, T: set)\n requires A * T == {}\n ensures |A + T| == |A| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_9771","instance":9771,"id":213114,"goal":"lemma SetUnionComm_9771(A: set, B: set)\n ensures A + B == B + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_9772","instance":9772,"id":213115,"goal":"lemma SetInterComm_9772(A: set, S: set)\n ensures A * S == S * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_9773","instance":9773,"id":213116,"goal":"lemma SetUnionAssoc_9773(S: set, T: set, A: set)\n ensures (S + T) + A == S + (T + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_9774","instance":9774,"id":213117,"goal":"lemma SetSubsetRefl_9774(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_9775","instance":9775,"id":213118,"goal":"lemma SetSubsetTrans_9775(U: set, A: set, T: set)\n requires U <= A && A <= T\n ensures U <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_9776","instance":9776,"id":213119,"goal":"lemma SetUnionEmpty_9776(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_9777","instance":9777,"id":213120,"goal":"lemma SetInterEmpty_9777(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_9778","instance":9778,"id":213121,"goal":"lemma SetInterSubset_9778(U: set, S: set)\n ensures U * S <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_9779","instance":9779,"id":213122,"goal":"lemma SetCardSubset_9779(B: set, U: set)\n requires B <= U\n ensures |B| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_9780","instance":9780,"id":213123,"goal":"lemma SetUnionCard_9780(U: set, B: set)\n requires U * B == {}\n ensures |U + B| == |U| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_9781","instance":9781,"id":213124,"goal":"lemma SetUnionComm_9781(B: set, S: set)\n ensures B + S == S + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_9782","instance":9782,"id":213125,"goal":"lemma SetInterComm_9782(A: set, B: set)\n ensures A * B == B * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_9783","instance":9783,"id":213126,"goal":"lemma SetUnionAssoc_9783(T: set, U: set, B: set)\n ensures (T + U) + B == T + (U + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_9784","instance":9784,"id":213127,"goal":"lemma SetSubsetRefl_9784(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_9785","instance":9785,"id":213128,"goal":"lemma SetSubsetTrans_9785(B: set, A: set, U: set)\n requires B <= A && A <= U\n ensures B <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_9786","instance":9786,"id":213129,"goal":"lemma SetUnionEmpty_9786(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_9787","instance":9787,"id":213130,"goal":"lemma SetInterEmpty_9787(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_9788","instance":9788,"id":213131,"goal":"lemma SetInterSubset_9788(S: set, B: set)\n ensures S * B <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_9789","instance":9789,"id":213132,"goal":"lemma SetCardSubset_9789(A: set, B: set)\n requires A <= B\n ensures |A| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_9790","instance":9790,"id":213133,"goal":"lemma SetUnionCard_9790(T: set, U: set)\n requires T * U == {}\n ensures |T + U| == |T| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_9791","instance":9791,"id":213134,"goal":"lemma SetUnionComm_9791(S: set, B: set)\n ensures S + B == B + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_9792","instance":9792,"id":213135,"goal":"lemma SetInterComm_9792(S: set, T: set)\n ensures S * T == T * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_9793","instance":9793,"id":213136,"goal":"lemma SetUnionAssoc_9793(A: set, U: set, B: set)\n ensures (A + U) + B == A + (U + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_9794","instance":9794,"id":213137,"goal":"lemma SetSubsetRefl_9794(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_9795","instance":9795,"id":213138,"goal":"lemma SetSubsetTrans_9795(S: set, T: set, B: set)\n requires S <= T && T <= B\n ensures S <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_9796","instance":9796,"id":213139,"goal":"lemma SetUnionEmpty_9796(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_9797","instance":9797,"id":213140,"goal":"lemma SetInterEmpty_9797(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_9798","instance":9798,"id":213141,"goal":"lemma SetInterSubset_9798(A: set, B: set)\n ensures A * B <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_9799","instance":9799,"id":213142,"goal":"lemma SetCardSubset_9799(B: set, S: set)\n requires B <= S\n ensures |B| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_9800","instance":9800,"id":213143,"goal":"lemma SetUnionCard_9800(A: set, S: set)\n requires A * S == {}\n ensures |A + S| == |A| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_9801","instance":9801,"id":213144,"goal":"lemma SetUnionComm_9801(B: set, S: set)\n ensures B + S == S + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_9802","instance":9802,"id":213145,"goal":"lemma SetInterComm_9802(S: set, U: set)\n ensures S * U == U * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_9803","instance":9803,"id":213146,"goal":"lemma SetUnionAssoc_9803(A: set, U: set, B: set)\n ensures (A + U) + B == A + (U + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_9804","instance":9804,"id":213147,"goal":"lemma SetSubsetRefl_9804(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_9805","instance":9805,"id":213148,"goal":"lemma SetSubsetTrans_9805(U: set, A: set, T: set)\n requires U <= A && A <= T\n ensures U <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_9806","instance":9806,"id":213149,"goal":"lemma SetUnionEmpty_9806(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_9807","instance":9807,"id":213150,"goal":"lemma SetInterEmpty_9807(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_9808","instance":9808,"id":213151,"goal":"lemma SetInterSubset_9808(U: set, S: set)\n ensures U * S <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_9809","instance":9809,"id":213152,"goal":"lemma SetCardSubset_9809(S: set, B: set)\n requires S <= B\n ensures |S| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_9810","instance":9810,"id":213153,"goal":"lemma SetUnionCard_9810(T: set, A: set)\n requires T * A == {}\n ensures |T + A| == |T| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_9811","instance":9811,"id":213154,"goal":"lemma SetUnionComm_9811(A: set, U: set)\n ensures A + U == U + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_9812","instance":9812,"id":213155,"goal":"lemma SetInterComm_9812(A: set, B: set)\n ensures A * B == B * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_9813","instance":9813,"id":213156,"goal":"lemma SetUnionAssoc_9813(A: set, S: set, T: set)\n ensures (A + S) + T == A + (S + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_9814","instance":9814,"id":213157,"goal":"lemma SetSubsetRefl_9814(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_9815","instance":9815,"id":213158,"goal":"lemma SetSubsetTrans_9815(B: set, A: set, S: set)\n requires B <= A && A <= S\n ensures B <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_9816","instance":9816,"id":213159,"goal":"lemma SetUnionEmpty_9816(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_9817","instance":9817,"id":213160,"goal":"lemma SetInterEmpty_9817(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_9818","instance":9818,"id":213161,"goal":"lemma SetInterSubset_9818(U: set, B: set)\n ensures U * B <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_9819","instance":9819,"id":213162,"goal":"lemma SetCardSubset_9819(B: set, U: set)\n requires B <= U\n ensures |B| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_9820","instance":9820,"id":213163,"goal":"lemma SetUnionCard_9820(A: set, T: set)\n requires A * T == {}\n ensures |A + T| == |A| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_9821","instance":9821,"id":213164,"goal":"lemma SetUnionComm_9821(B: set, S: set)\n ensures B + S == S + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_9822","instance":9822,"id":213165,"goal":"lemma SetInterComm_9822(A: set, T: set)\n ensures A * T == T * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_9823","instance":9823,"id":213166,"goal":"lemma SetUnionAssoc_9823(T: set, B: set, A: set)\n ensures (T + B) + A == T + (B + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_9824","instance":9824,"id":213167,"goal":"lemma SetSubsetRefl_9824(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_9825","instance":9825,"id":213168,"goal":"lemma SetSubsetTrans_9825(A: set, U: set, B: set)\n requires A <= U && U <= B\n ensures A <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_9826","instance":9826,"id":213169,"goal":"lemma SetUnionEmpty_9826(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_9827","instance":9827,"id":213170,"goal":"lemma SetInterEmpty_9827(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_9828","instance":9828,"id":213171,"goal":"lemma SetInterSubset_9828(B: set, S: set)\n ensures B * S <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_9829","instance":9829,"id":213172,"goal":"lemma SetCardSubset_9829(U: set, B: set)\n requires U <= B\n ensures |U| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_9830","instance":9830,"id":213173,"goal":"lemma SetUnionCard_9830(B: set, U: set)\n requires B * U == {}\n ensures |B + U| == |B| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_9831","instance":9831,"id":213174,"goal":"lemma SetUnionComm_9831(T: set, B: set)\n ensures T + B == B + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_9832","instance":9832,"id":213175,"goal":"lemma SetInterComm_9832(S: set, T: set)\n ensures S * T == T * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_9833","instance":9833,"id":213176,"goal":"lemma SetUnionAssoc_9833(U: set, A: set, B: set)\n ensures (U + A) + B == U + (A + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_9834","instance":9834,"id":213177,"goal":"lemma SetSubsetRefl_9834(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_9835","instance":9835,"id":213178,"goal":"lemma SetSubsetTrans_9835(S: set, A: set, T: set)\n requires S <= A && A <= T\n ensures S <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_9836","instance":9836,"id":213179,"goal":"lemma SetUnionEmpty_9836(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_9837","instance":9837,"id":213180,"goal":"lemma SetInterEmpty_9837(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_9838","instance":9838,"id":213181,"goal":"lemma SetInterSubset_9838(A: set, T: set)\n ensures A * T <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_9839","instance":9839,"id":213182,"goal":"lemma SetCardSubset_9839(B: set, A: set)\n requires B <= A\n ensures |B| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_9840","instance":9840,"id":213183,"goal":"lemma SetUnionCard_9840(U: set, A: set)\n requires U * A == {}\n ensures |U + A| == |U| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_9841","instance":9841,"id":213184,"goal":"lemma SetUnionComm_9841(S: set, U: set)\n ensures S + U == U + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_9842","instance":9842,"id":213185,"goal":"lemma SetInterComm_9842(S: set, A: set)\n ensures S * A == A * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_9843","instance":9843,"id":213186,"goal":"lemma SetUnionAssoc_9843(B: set, T: set, A: set)\n ensures (B + T) + A == B + (T + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_9844","instance":9844,"id":213187,"goal":"lemma SetSubsetRefl_9844(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_9845","instance":9845,"id":213188,"goal":"lemma SetSubsetTrans_9845(U: set, T: set, B: set)\n requires U <= T && T <= B\n ensures U <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_9846","instance":9846,"id":213189,"goal":"lemma SetUnionEmpty_9846(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_9847","instance":9847,"id":213190,"goal":"lemma SetInterEmpty_9847(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_9848","instance":9848,"id":213191,"goal":"lemma SetInterSubset_9848(A: set, S: set)\n ensures A * S <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_9849","instance":9849,"id":213192,"goal":"lemma SetCardSubset_9849(T: set, S: set)\n requires T <= S\n ensures |T| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_9850","instance":9850,"id":213193,"goal":"lemma SetUnionCard_9850(T: set, U: set)\n requires T * U == {}\n ensures |T + U| == |T| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_9851","instance":9851,"id":213194,"goal":"lemma SetUnionComm_9851(B: set, T: set)\n ensures B + T == T + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_9852","instance":9852,"id":213195,"goal":"lemma SetInterComm_9852(B: set, A: set)\n ensures B * A == A * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_9853","instance":9853,"id":213196,"goal":"lemma SetUnionAssoc_9853(T: set, A: set, B: set)\n ensures (T + A) + B == T + (A + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_9854","instance":9854,"id":213197,"goal":"lemma SetSubsetRefl_9854(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_9855","instance":9855,"id":213198,"goal":"lemma SetSubsetTrans_9855(T: set, B: set, A: set)\n requires T <= B && B <= A\n ensures T <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_9856","instance":9856,"id":213199,"goal":"lemma SetUnionEmpty_9856(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_9857","instance":9857,"id":213200,"goal":"lemma SetInterEmpty_9857(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_9858","instance":9858,"id":213201,"goal":"lemma SetInterSubset_9858(U: set, A: set)\n ensures U * A <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_9859","instance":9859,"id":213202,"goal":"lemma SetCardSubset_9859(S: set, T: set)\n requires S <= T\n ensures |S| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_9860","instance":9860,"id":213203,"goal":"lemma SetUnionCard_9860(T: set, B: set)\n requires T * B == {}\n ensures |T + B| == |T| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_9861","instance":9861,"id":213204,"goal":"lemma SetUnionComm_9861(U: set, B: set)\n ensures U + B == B + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_9862","instance":9862,"id":213205,"goal":"lemma SetInterComm_9862(A: set, B: set)\n ensures A * B == B * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_9863","instance":9863,"id":213206,"goal":"lemma SetUnionAssoc_9863(B: set, T: set, U: set)\n ensures (B + T) + U == B + (T + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_9864","instance":9864,"id":213207,"goal":"lemma SetSubsetRefl_9864(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_9865","instance":9865,"id":213208,"goal":"lemma SetSubsetTrans_9865(A: set, U: set, S: set)\n requires A <= U && U <= S\n ensures A <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_9866","instance":9866,"id":213209,"goal":"lemma SetUnionEmpty_9866(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_9867","instance":9867,"id":213210,"goal":"lemma SetInterEmpty_9867(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_9868","instance":9868,"id":213211,"goal":"lemma SetInterSubset_9868(A: set, S: set)\n ensures A * S <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_9869","instance":9869,"id":213212,"goal":"lemma SetCardSubset_9869(S: set, B: set)\n requires S <= B\n ensures |S| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_9870","instance":9870,"id":213213,"goal":"lemma SetUnionCard_9870(U: set, T: set)\n requires U * T == {}\n ensures |U + T| == |U| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_9871","instance":9871,"id":213214,"goal":"lemma SetUnionComm_9871(S: set, T: set)\n ensures S + T == T + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_9872","instance":9872,"id":213215,"goal":"lemma SetInterComm_9872(S: set, U: set)\n ensures S * U == U * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_9873","instance":9873,"id":213216,"goal":"lemma SetUnionAssoc_9873(B: set, U: set, T: set)\n ensures (B + U) + T == B + (U + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_9874","instance":9874,"id":213217,"goal":"lemma SetSubsetRefl_9874(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_9875","instance":9875,"id":213218,"goal":"lemma SetSubsetTrans_9875(U: set, B: set, A: set)\n requires U <= B && B <= A\n ensures U <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_9876","instance":9876,"id":213219,"goal":"lemma SetUnionEmpty_9876(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_9877","instance":9877,"id":213220,"goal":"lemma SetInterEmpty_9877(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_9878","instance":9878,"id":213221,"goal":"lemma SetInterSubset_9878(B: set, U: set)\n ensures B * U <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_9879","instance":9879,"id":213222,"goal":"lemma SetCardSubset_9879(S: set, T: set)\n requires S <= T\n ensures |S| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_9880","instance":9880,"id":213223,"goal":"lemma SetUnionCard_9880(S: set, A: set)\n requires S * A == {}\n ensures |S + A| == |S| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_9881","instance":9881,"id":213224,"goal":"lemma SetUnionComm_9881(A: set, S: set)\n ensures A + S == S + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_9882","instance":9882,"id":213225,"goal":"lemma SetInterComm_9882(T: set, S: set)\n ensures T * S == S * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_9883","instance":9883,"id":213226,"goal":"lemma SetUnionAssoc_9883(A: set, U: set, S: set)\n ensures (A + U) + S == A + (U + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_9884","instance":9884,"id":213227,"goal":"lemma SetSubsetRefl_9884(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_9885","instance":9885,"id":213228,"goal":"lemma SetSubsetTrans_9885(U: set, B: set, T: set)\n requires U <= B && B <= T\n ensures U <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_9886","instance":9886,"id":213229,"goal":"lemma SetUnionEmpty_9886(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_9887","instance":9887,"id":213230,"goal":"lemma SetInterEmpty_9887(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_9888","instance":9888,"id":213231,"goal":"lemma SetInterSubset_9888(T: set, U: set)\n ensures T * U <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_9889","instance":9889,"id":213232,"goal":"lemma SetCardSubset_9889(B: set, S: set)\n requires B <= S\n ensures |B| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_9890","instance":9890,"id":213233,"goal":"lemma SetUnionCard_9890(S: set, B: set)\n requires S * B == {}\n ensures |S + B| == |S| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_9891","instance":9891,"id":213234,"goal":"lemma SetUnionComm_9891(T: set, S: set)\n ensures T + S == S + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_9892","instance":9892,"id":213235,"goal":"lemma SetInterComm_9892(U: set, B: set)\n ensures U * B == B * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_9893","instance":9893,"id":213236,"goal":"lemma SetUnionAssoc_9893(A: set, B: set, U: set)\n ensures (A + B) + U == A + (B + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_9894","instance":9894,"id":213237,"goal":"lemma SetSubsetRefl_9894(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_9895","instance":9895,"id":213238,"goal":"lemma SetSubsetTrans_9895(U: set, B: set, T: set)\n requires U <= B && B <= T\n ensures U <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_9896","instance":9896,"id":213239,"goal":"lemma SetUnionEmpty_9896(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_9897","instance":9897,"id":213240,"goal":"lemma SetInterEmpty_9897(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_9898","instance":9898,"id":213241,"goal":"lemma SetInterSubset_9898(B: set, A: set)\n ensures B * A <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_9899","instance":9899,"id":213242,"goal":"lemma SetCardSubset_9899(A: set, B: set)\n requires A <= B\n ensures |A| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_9900","instance":9900,"id":213243,"goal":"lemma SetUnionCard_9900(T: set, U: set)\n requires T * U == {}\n ensures |T + U| == |T| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_9901","instance":9901,"id":213244,"goal":"lemma SetUnionComm_9901(A: set, U: set)\n ensures A + U == U + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_9902","instance":9902,"id":213245,"goal":"lemma SetInterComm_9902(U: set, S: set)\n ensures U * S == S * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_9903","instance":9903,"id":213246,"goal":"lemma SetUnionAssoc_9903(B: set, A: set, U: set)\n ensures (B + A) + U == B + (A + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_9904","instance":9904,"id":213247,"goal":"lemma SetSubsetRefl_9904(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_9905","instance":9905,"id":213248,"goal":"lemma SetSubsetTrans_9905(U: set, A: set, S: set)\n requires U <= A && A <= S\n ensures U <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_9906","instance":9906,"id":213249,"goal":"lemma SetUnionEmpty_9906(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_9907","instance":9907,"id":213250,"goal":"lemma SetInterEmpty_9907(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_9908","instance":9908,"id":213251,"goal":"lemma SetInterSubset_9908(S: set, U: set)\n ensures S * U <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_9909","instance":9909,"id":213252,"goal":"lemma SetCardSubset_9909(T: set, S: set)\n requires T <= S\n ensures |T| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_9910","instance":9910,"id":213253,"goal":"lemma SetUnionCard_9910(A: set, B: set)\n requires A * B == {}\n ensures |A + B| == |A| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_9911","instance":9911,"id":213254,"goal":"lemma SetUnionComm_9911(T: set, U: set)\n ensures T + U == U + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_9912","instance":9912,"id":213255,"goal":"lemma SetInterComm_9912(B: set, U: set)\n ensures B * U == U * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_9913","instance":9913,"id":213256,"goal":"lemma SetUnionAssoc_9913(S: set, A: set, U: set)\n ensures (S + A) + U == S + (A + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_9914","instance":9914,"id":213257,"goal":"lemma SetSubsetRefl_9914(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_9915","instance":9915,"id":213258,"goal":"lemma SetSubsetTrans_9915(S: set, U: set, T: set)\n requires S <= U && U <= T\n ensures S <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_9916","instance":9916,"id":213259,"goal":"lemma SetUnionEmpty_9916(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_9917","instance":9917,"id":213260,"goal":"lemma SetInterEmpty_9917(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_9918","instance":9918,"id":213261,"goal":"lemma SetInterSubset_9918(S: set, U: set)\n ensures S * U <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_9919","instance":9919,"id":213262,"goal":"lemma SetCardSubset_9919(B: set, A: set)\n requires B <= A\n ensures |B| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_9920","instance":9920,"id":213263,"goal":"lemma SetUnionCard_9920(A: set, B: set)\n requires A * B == {}\n ensures |A + B| == |A| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_9921","instance":9921,"id":213264,"goal":"lemma SetUnionComm_9921(U: set, S: set)\n ensures U + S == S + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_9922","instance":9922,"id":213265,"goal":"lemma SetInterComm_9922(B: set, U: set)\n ensures B * U == U * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_9923","instance":9923,"id":213266,"goal":"lemma SetUnionAssoc_9923(T: set, B: set, U: set)\n ensures (T + B) + U == T + (B + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_9924","instance":9924,"id":213267,"goal":"lemma SetSubsetRefl_9924(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_9925","instance":9925,"id":213268,"goal":"lemma SetSubsetTrans_9925(S: set, A: set, U: set)\n requires S <= A && A <= U\n ensures S <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_9926","instance":9926,"id":213269,"goal":"lemma SetUnionEmpty_9926(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_9927","instance":9927,"id":213270,"goal":"lemma SetInterEmpty_9927(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_9928","instance":9928,"id":213271,"goal":"lemma SetInterSubset_9928(S: set, B: set)\n ensures S * B <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_9929","instance":9929,"id":213272,"goal":"lemma SetCardSubset_9929(S: set, T: set)\n requires S <= T\n ensures |S| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_9930","instance":9930,"id":213273,"goal":"lemma SetUnionCard_9930(S: set, B: set)\n requires S * B == {}\n ensures |S + B| == |S| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_9931","instance":9931,"id":213274,"goal":"lemma SetUnionComm_9931(S: set, U: set)\n ensures S + U == U + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_9932","instance":9932,"id":213275,"goal":"lemma SetInterComm_9932(A: set, S: set)\n ensures A * S == S * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_9933","instance":9933,"id":213276,"goal":"lemma SetUnionAssoc_9933(T: set, U: set, A: set)\n ensures (T + U) + A == T + (U + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_9934","instance":9934,"id":213277,"goal":"lemma SetSubsetRefl_9934(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_9935","instance":9935,"id":213278,"goal":"lemma SetSubsetTrans_9935(B: set, S: set, T: set)\n requires B <= S && S <= T\n ensures B <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_9936","instance":9936,"id":213279,"goal":"lemma SetUnionEmpty_9936(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_9937","instance":9937,"id":213280,"goal":"lemma SetInterEmpty_9937(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_9938","instance":9938,"id":213281,"goal":"lemma SetInterSubset_9938(U: set, B: set)\n ensures U * B <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_9939","instance":9939,"id":213282,"goal":"lemma SetCardSubset_9939(B: set, U: set)\n requires B <= U\n ensures |B| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_9940","instance":9940,"id":213283,"goal":"lemma SetUnionCard_9940(U: set, S: set)\n requires U * S == {}\n ensures |U + S| == |U| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_9941","instance":9941,"id":213284,"goal":"lemma SetUnionComm_9941(B: set, A: set)\n ensures B + A == A + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_9942","instance":9942,"id":213285,"goal":"lemma SetInterComm_9942(B: set, T: set)\n ensures B * T == T * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_9943","instance":9943,"id":213286,"goal":"lemma SetUnionAssoc_9943(B: set, U: set, A: set)\n ensures (B + U) + A == B + (U + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_9944","instance":9944,"id":213287,"goal":"lemma SetSubsetRefl_9944(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_9945","instance":9945,"id":213288,"goal":"lemma SetSubsetTrans_9945(B: set, U: set, A: set)\n requires B <= U && U <= A\n ensures B <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_9946","instance":9946,"id":213289,"goal":"lemma SetUnionEmpty_9946(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_9947","instance":9947,"id":213290,"goal":"lemma SetInterEmpty_9947(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_9948","instance":9948,"id":213291,"goal":"lemma SetInterSubset_9948(U: set, B: set)\n ensures U * B <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_9949","instance":9949,"id":213292,"goal":"lemma SetCardSubset_9949(A: set, U: set)\n requires A <= U\n ensures |A| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_9950","instance":9950,"id":213293,"goal":"lemma SetUnionCard_9950(T: set, U: set)\n requires T * U == {}\n ensures |T + U| == |T| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_9951","instance":9951,"id":213294,"goal":"lemma SetUnionComm_9951(S: set, A: set)\n ensures S + A == A + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_9952","instance":9952,"id":213295,"goal":"lemma SetInterComm_9952(U: set, B: set)\n ensures U * B == B * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_9953","instance":9953,"id":213296,"goal":"lemma SetUnionAssoc_9953(A: set, S: set, U: set)\n ensures (A + S) + U == A + (S + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_9954","instance":9954,"id":213297,"goal":"lemma SetSubsetRefl_9954(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_9955","instance":9955,"id":213298,"goal":"lemma SetSubsetTrans_9955(U: set, T: set, B: set)\n requires U <= T && T <= B\n ensures U <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_9956","instance":9956,"id":213299,"goal":"lemma SetUnionEmpty_9956(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_9957","instance":9957,"id":213300,"goal":"lemma SetInterEmpty_9957(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_9958","instance":9958,"id":213301,"goal":"lemma SetInterSubset_9958(A: set, T: set)\n ensures A * T <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_9959","instance":9959,"id":213302,"goal":"lemma SetCardSubset_9959(A: set, T: set)\n requires A <= T\n ensures |A| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_9960","instance":9960,"id":213303,"goal":"lemma SetUnionCard_9960(U: set, S: set)\n requires U * S == {}\n ensures |U + S| == |U| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_9961","instance":9961,"id":213304,"goal":"lemma SetUnionComm_9961(S: set, T: set)\n ensures S + T == T + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_9962","instance":9962,"id":213305,"goal":"lemma SetInterComm_9962(S: set, A: set)\n ensures S * A == A * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_9963","instance":9963,"id":213306,"goal":"lemma SetUnionAssoc_9963(B: set, U: set, T: set)\n ensures (B + U) + T == B + (U + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_9964","instance":9964,"id":213307,"goal":"lemma SetSubsetRefl_9964(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_9965","instance":9965,"id":213308,"goal":"lemma SetSubsetTrans_9965(U: set, T: set, B: set)\n requires U <= T && T <= B\n ensures U <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_9966","instance":9966,"id":213309,"goal":"lemma SetUnionEmpty_9966(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_9967","instance":9967,"id":213310,"goal":"lemma SetInterEmpty_9967(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_9968","instance":9968,"id":213311,"goal":"lemma SetInterSubset_9968(U: set, T: set)\n ensures U * T <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_9969","instance":9969,"id":213312,"goal":"lemma SetCardSubset_9969(A: set, T: set)\n requires A <= T\n ensures |A| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_9970","instance":9970,"id":213313,"goal":"lemma SetUnionCard_9970(S: set, A: set)\n requires S * A == {}\n ensures |S + A| == |S| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_9971","instance":9971,"id":213314,"goal":"lemma SetUnionComm_9971(T: set, B: set)\n ensures T + B == B + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_9972","instance":9972,"id":213315,"goal":"lemma SetInterComm_9972(B: set, A: set)\n ensures B * A == A * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_9973","instance":9973,"id":213316,"goal":"lemma SetUnionAssoc_9973(U: set, S: set, T: set)\n ensures (U + S) + T == U + (S + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_9974","instance":9974,"id":213317,"goal":"lemma SetSubsetRefl_9974(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_9975","instance":9975,"id":213318,"goal":"lemma SetSubsetTrans_9975(U: set, A: set, B: set)\n requires U <= A && A <= B\n ensures U <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_9976","instance":9976,"id":213319,"goal":"lemma SetUnionEmpty_9976(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_9977","instance":9977,"id":213320,"goal":"lemma SetInterEmpty_9977(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_9978","instance":9978,"id":213321,"goal":"lemma SetInterSubset_9978(A: set, B: set)\n ensures A * B <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_9979","instance":9979,"id":213322,"goal":"lemma SetCardSubset_9979(A: set, B: set)\n requires A <= B\n ensures |A| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_9980","instance":9980,"id":213323,"goal":"lemma SetUnionCard_9980(T: set, B: set)\n requires T * B == {}\n ensures |T + B| == |T| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_9981","instance":9981,"id":213324,"goal":"lemma SetUnionComm_9981(T: set, S: set)\n ensures T + S == S + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_9982","instance":9982,"id":213325,"goal":"lemma SetInterComm_9982(B: set, S: set)\n ensures B * S == S * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_9983","instance":9983,"id":213326,"goal":"lemma SetUnionAssoc_9983(A: set, B: set, T: set)\n ensures (A + B) + T == A + (B + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_9984","instance":9984,"id":213327,"goal":"lemma SetSubsetRefl_9984(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_9985","instance":9985,"id":213328,"goal":"lemma SetSubsetTrans_9985(B: set, T: set, U: set)\n requires B <= T && T <= U\n ensures B <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_9986","instance":9986,"id":213329,"goal":"lemma SetUnionEmpty_9986(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_9987","instance":9987,"id":213330,"goal":"lemma SetInterEmpty_9987(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_9988","instance":9988,"id":213331,"goal":"lemma SetInterSubset_9988(U: set, S: set)\n ensures U * S <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_9989","instance":9989,"id":213332,"goal":"lemma SetCardSubset_9989(B: set, U: set)\n requires B <= U\n ensures |B| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_9990","instance":9990,"id":213333,"goal":"lemma SetUnionCard_9990(U: set, A: set)\n requires U * A == {}\n ensures |U + A| == |U| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_9991","instance":9991,"id":213334,"goal":"lemma SetUnionComm_9991(A: set, U: set)\n ensures A + U == U + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_9992","instance":9992,"id":213335,"goal":"lemma SetInterComm_9992(U: set, B: set)\n ensures U * B == B * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_9993","instance":9993,"id":213336,"goal":"lemma SetUnionAssoc_9993(T: set, S: set, A: set)\n ensures (T + S) + A == T + (S + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_9994","instance":9994,"id":213337,"goal":"lemma SetSubsetRefl_9994(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_9995","instance":9995,"id":213338,"goal":"lemma SetSubsetTrans_9995(S: set, B: set, U: set)\n requires S <= B && B <= U\n ensures S <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_9996","instance":9996,"id":213339,"goal":"lemma SetUnionEmpty_9996(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_9997","instance":9997,"id":213340,"goal":"lemma SetInterEmpty_9997(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_9998","instance":9998,"id":213341,"goal":"lemma SetInterSubset_9998(U: set, T: set)\n ensures U * T <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_9999","instance":9999,"id":213342,"goal":"lemma SetCardSubset_9999(T: set, S: set)\n requires T <= S\n ensures |T| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_10000","instance":10000,"id":213343,"goal":"lemma SetUnionCard_10000(S: set, B: set)\n requires S * B == {}\n ensures |S + B| == |S| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_10001","instance":10001,"id":213344,"goal":"lemma SetUnionComm_10001(U: set, A: set)\n ensures U + A == A + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_10002","instance":10002,"id":213345,"goal":"lemma SetInterComm_10002(A: set, S: set)\n ensures A * S == S * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_10003","instance":10003,"id":213346,"goal":"lemma SetUnionAssoc_10003(B: set, A: set, S: set)\n ensures (B + A) + S == B + (A + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_10004","instance":10004,"id":213347,"goal":"lemma SetSubsetRefl_10004(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_10005","instance":10005,"id":213348,"goal":"lemma SetSubsetTrans_10005(B: set, A: set, T: set)\n requires B <= A && A <= T\n ensures B <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_10006","instance":10006,"id":213349,"goal":"lemma SetUnionEmpty_10006(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_10007","instance":10007,"id":213350,"goal":"lemma SetInterEmpty_10007(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_10008","instance":10008,"id":213351,"goal":"lemma SetInterSubset_10008(U: set, S: set)\n ensures U * S <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_10009","instance":10009,"id":213352,"goal":"lemma SetCardSubset_10009(T: set, B: set)\n requires T <= B\n ensures |T| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_10010","instance":10010,"id":213353,"goal":"lemma SetUnionCard_10010(T: set, S: set)\n requires T * S == {}\n ensures |T + S| == |T| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_10011","instance":10011,"id":213354,"goal":"lemma SetUnionComm_10011(T: set, A: set)\n ensures T + A == A + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_10012","instance":10012,"id":213355,"goal":"lemma SetInterComm_10012(S: set, B: set)\n ensures S * B == B * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_10013","instance":10013,"id":213356,"goal":"lemma SetUnionAssoc_10013(S: set, U: set, B: set)\n ensures (S + U) + B == S + (U + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_10014","instance":10014,"id":213357,"goal":"lemma SetSubsetRefl_10014(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_10015","instance":10015,"id":213358,"goal":"lemma SetSubsetTrans_10015(U: set, T: set, A: set)\n requires U <= T && T <= A\n ensures U <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_10016","instance":10016,"id":213359,"goal":"lemma SetUnionEmpty_10016(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_10017","instance":10017,"id":213360,"goal":"lemma SetInterEmpty_10017(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_10018","instance":10018,"id":213361,"goal":"lemma SetInterSubset_10018(U: set, T: set)\n ensures U * T <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_10019","instance":10019,"id":213362,"goal":"lemma SetCardSubset_10019(A: set, S: set)\n requires A <= S\n ensures |A| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_10020","instance":10020,"id":213363,"goal":"lemma SetUnionCard_10020(U: set, A: set)\n requires U * A == {}\n ensures |U + A| == |U| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_10021","instance":10021,"id":213364,"goal":"lemma SetUnionComm_10021(U: set, S: set)\n ensures U + S == S + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_10022","instance":10022,"id":213365,"goal":"lemma SetInterComm_10022(A: set, S: set)\n ensures A * S == S * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_10023","instance":10023,"id":213366,"goal":"lemma SetUnionAssoc_10023(A: set, U: set, T: set)\n ensures (A + U) + T == A + (U + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_10024","instance":10024,"id":213367,"goal":"lemma SetSubsetRefl_10024(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_10025","instance":10025,"id":213368,"goal":"lemma SetSubsetTrans_10025(T: set, U: set, B: set)\n requires T <= U && U <= B\n ensures T <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_10026","instance":10026,"id":213369,"goal":"lemma SetUnionEmpty_10026(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_10027","instance":10027,"id":213370,"goal":"lemma SetInterEmpty_10027(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_10028","instance":10028,"id":213371,"goal":"lemma SetInterSubset_10028(B: set, S: set)\n ensures B * S <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_10029","instance":10029,"id":213372,"goal":"lemma SetCardSubset_10029(B: set, U: set)\n requires B <= U\n ensures |B| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_10030","instance":10030,"id":213373,"goal":"lemma SetUnionCard_10030(U: set, A: set)\n requires U * A == {}\n ensures |U + A| == |U| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_10031","instance":10031,"id":213374,"goal":"lemma SetUnionComm_10031(B: set, S: set)\n ensures B + S == S + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_10032","instance":10032,"id":213375,"goal":"lemma SetInterComm_10032(A: set, T: set)\n ensures A * T == T * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_10033","instance":10033,"id":213376,"goal":"lemma SetUnionAssoc_10033(U: set, T: set, B: set)\n ensures (U + T) + B == U + (T + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_10034","instance":10034,"id":213377,"goal":"lemma SetSubsetRefl_10034(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_10035","instance":10035,"id":213378,"goal":"lemma SetSubsetTrans_10035(A: set, T: set, U: set)\n requires A <= T && T <= U\n ensures A <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_10036","instance":10036,"id":213379,"goal":"lemma SetUnionEmpty_10036(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_10037","instance":10037,"id":213380,"goal":"lemma SetInterEmpty_10037(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_10038","instance":10038,"id":213381,"goal":"lemma SetInterSubset_10038(U: set, T: set)\n ensures U * T <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_10039","instance":10039,"id":213382,"goal":"lemma SetCardSubset_10039(S: set, B: set)\n requires S <= B\n ensures |S| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_10040","instance":10040,"id":213383,"goal":"lemma SetUnionCard_10040(S: set, U: set)\n requires S * U == {}\n ensures |S + U| == |S| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_10041","instance":10041,"id":213384,"goal":"lemma SetUnionComm_10041(T: set, U: set)\n ensures T + U == U + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_10042","instance":10042,"id":213385,"goal":"lemma SetInterComm_10042(A: set, U: set)\n ensures A * U == U * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_10043","instance":10043,"id":213386,"goal":"lemma SetUnionAssoc_10043(T: set, B: set, A: set)\n ensures (T + B) + A == T + (B + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_10044","instance":10044,"id":213387,"goal":"lemma SetSubsetRefl_10044(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_10045","instance":10045,"id":213388,"goal":"lemma SetSubsetTrans_10045(A: set, S: set, U: set)\n requires A <= S && S <= U\n ensures A <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_10046","instance":10046,"id":213389,"goal":"lemma SetUnionEmpty_10046(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_10047","instance":10047,"id":213390,"goal":"lemma SetInterEmpty_10047(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_10048","instance":10048,"id":213391,"goal":"lemma SetInterSubset_10048(B: set, A: set)\n ensures B * A <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_10049","instance":10049,"id":213392,"goal":"lemma SetCardSubset_10049(S: set, T: set)\n requires S <= T\n ensures |S| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_10050","instance":10050,"id":213393,"goal":"lemma SetUnionCard_10050(S: set, T: set)\n requires S * T == {}\n ensures |S + T| == |S| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_10051","instance":10051,"id":213394,"goal":"lemma SetUnionComm_10051(T: set, S: set)\n ensures T + S == S + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_10052","instance":10052,"id":213395,"goal":"lemma SetInterComm_10052(S: set, T: set)\n ensures S * T == T * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_10053","instance":10053,"id":213396,"goal":"lemma SetUnionAssoc_10053(U: set, T: set, B: set)\n ensures (U + T) + B == U + (T + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_10054","instance":10054,"id":213397,"goal":"lemma SetSubsetRefl_10054(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_10055","instance":10055,"id":213398,"goal":"lemma SetSubsetTrans_10055(U: set, S: set, A: set)\n requires U <= S && S <= A\n ensures U <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_10056","instance":10056,"id":213399,"goal":"lemma SetUnionEmpty_10056(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_10057","instance":10057,"id":213400,"goal":"lemma SetInterEmpty_10057(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_10058","instance":10058,"id":213401,"goal":"lemma SetInterSubset_10058(B: set, U: set)\n ensures B * U <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_10059","instance":10059,"id":213402,"goal":"lemma SetCardSubset_10059(U: set, S: set)\n requires U <= S\n ensures |U| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_10060","instance":10060,"id":213403,"goal":"lemma SetUnionCard_10060(U: set, A: set)\n requires U * A == {}\n ensures |U + A| == |U| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_10061","instance":10061,"id":213404,"goal":"lemma SetUnionComm_10061(U: set, A: set)\n ensures U + A == A + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_10062","instance":10062,"id":213405,"goal":"lemma SetInterComm_10062(S: set, U: set)\n ensures S * U == U * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_10063","instance":10063,"id":213406,"goal":"lemma SetUnionAssoc_10063(S: set, A: set, B: set)\n ensures (S + A) + B == S + (A + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_10064","instance":10064,"id":213407,"goal":"lemma SetSubsetRefl_10064(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_10065","instance":10065,"id":213408,"goal":"lemma SetSubsetTrans_10065(T: set, S: set, A: set)\n requires T <= S && S <= A\n ensures T <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_10066","instance":10066,"id":213409,"goal":"lemma SetUnionEmpty_10066(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_10067","instance":10067,"id":213410,"goal":"lemma SetInterEmpty_10067(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_10068","instance":10068,"id":213411,"goal":"lemma SetInterSubset_10068(A: set, U: set)\n ensures A * U <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_10069","instance":10069,"id":213412,"goal":"lemma SetCardSubset_10069(U: set, T: set)\n requires U <= T\n ensures |U| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_10070","instance":10070,"id":213413,"goal":"lemma SetUnionCard_10070(B: set, S: set)\n requires B * S == {}\n ensures |B + S| == |B| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_10071","instance":10071,"id":213414,"goal":"lemma SetUnionComm_10071(S: set, B: set)\n ensures S + B == B + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_10072","instance":10072,"id":213415,"goal":"lemma SetInterComm_10072(T: set, B: set)\n ensures T * B == B * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_10073","instance":10073,"id":213416,"goal":"lemma SetUnionAssoc_10073(A: set, B: set, U: set)\n ensures (A + B) + U == A + (B + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_10074","instance":10074,"id":213417,"goal":"lemma SetSubsetRefl_10074(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_10075","instance":10075,"id":213418,"goal":"lemma SetSubsetTrans_10075(A: set, B: set, S: set)\n requires A <= B && B <= S\n ensures A <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_10076","instance":10076,"id":213419,"goal":"lemma SetUnionEmpty_10076(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_10077","instance":10077,"id":213420,"goal":"lemma SetInterEmpty_10077(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_10078","instance":10078,"id":213421,"goal":"lemma SetInterSubset_10078(A: set, T: set)\n ensures A * T <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_10079","instance":10079,"id":213422,"goal":"lemma SetCardSubset_10079(B: set, T: set)\n requires B <= T\n ensures |B| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_10080","instance":10080,"id":213423,"goal":"lemma SetUnionCard_10080(A: set, B: set)\n requires A * B == {}\n ensures |A + B| == |A| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_10081","instance":10081,"id":213424,"goal":"lemma SetUnionComm_10081(B: set, U: set)\n ensures B + U == U + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_10082","instance":10082,"id":213425,"goal":"lemma SetInterComm_10082(T: set, U: set)\n ensures T * U == U * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_10083","instance":10083,"id":213426,"goal":"lemma SetUnionAssoc_10083(S: set, T: set, B: set)\n ensures (S + T) + B == S + (T + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_10084","instance":10084,"id":213427,"goal":"lemma SetSubsetRefl_10084(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_10085","instance":10085,"id":213428,"goal":"lemma SetSubsetTrans_10085(B: set, A: set, S: set)\n requires B <= A && A <= S\n ensures B <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_10086","instance":10086,"id":213429,"goal":"lemma SetUnionEmpty_10086(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_10087","instance":10087,"id":213430,"goal":"lemma SetInterEmpty_10087(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_10088","instance":10088,"id":213431,"goal":"lemma SetInterSubset_10088(T: set, U: set)\n ensures T * U <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_10089","instance":10089,"id":213432,"goal":"lemma SetCardSubset_10089(A: set, S: set)\n requires A <= S\n ensures |A| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_10090","instance":10090,"id":213433,"goal":"lemma SetUnionCard_10090(S: set, T: set)\n requires S * T == {}\n ensures |S + T| == |S| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_10091","instance":10091,"id":213434,"goal":"lemma SetUnionComm_10091(B: set, A: set)\n ensures B + A == A + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_10092","instance":10092,"id":213435,"goal":"lemma SetInterComm_10092(B: set, A: set)\n ensures B * A == A * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_10093","instance":10093,"id":213436,"goal":"lemma SetUnionAssoc_10093(T: set, U: set, B: set)\n ensures (T + U) + B == T + (U + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_10094","instance":10094,"id":213437,"goal":"lemma SetSubsetRefl_10094(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_10095","instance":10095,"id":213438,"goal":"lemma SetSubsetTrans_10095(B: set, T: set, U: set)\n requires B <= T && T <= U\n ensures B <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_10096","instance":10096,"id":213439,"goal":"lemma SetUnionEmpty_10096(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_10097","instance":10097,"id":213440,"goal":"lemma SetInterEmpty_10097(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_10098","instance":10098,"id":213441,"goal":"lemma SetInterSubset_10098(A: set, B: set)\n ensures A * B <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_10099","instance":10099,"id":213442,"goal":"lemma SetCardSubset_10099(U: set, T: set)\n requires U <= T\n ensures |U| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_10100","instance":10100,"id":213443,"goal":"lemma SetUnionCard_10100(T: set, S: set)\n requires T * S == {}\n ensures |T + S| == |T| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_10101","instance":10101,"id":213444,"goal":"lemma SetUnionComm_10101(A: set, T: set)\n ensures A + T == T + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_10102","instance":10102,"id":213445,"goal":"lemma SetInterComm_10102(B: set, T: set)\n ensures B * T == T * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_10103","instance":10103,"id":213446,"goal":"lemma SetUnionAssoc_10103(U: set, B: set, A: set)\n ensures (U + B) + A == U + (B + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_10104","instance":10104,"id":213447,"goal":"lemma SetSubsetRefl_10104(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_10105","instance":10105,"id":213448,"goal":"lemma SetSubsetTrans_10105(A: set, T: set, U: set)\n requires A <= T && T <= U\n ensures A <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_10106","instance":10106,"id":213449,"goal":"lemma SetUnionEmpty_10106(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_10107","instance":10107,"id":213450,"goal":"lemma SetInterEmpty_10107(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_10108","instance":10108,"id":213451,"goal":"lemma SetInterSubset_10108(T: set, A: set)\n ensures T * A <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_10109","instance":10109,"id":213452,"goal":"lemma SetCardSubset_10109(U: set, S: set)\n requires U <= S\n ensures |U| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_10110","instance":10110,"id":213453,"goal":"lemma SetUnionCard_10110(S: set, U: set)\n requires S * U == {}\n ensures |S + U| == |S| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_10111","instance":10111,"id":213454,"goal":"lemma SetUnionComm_10111(T: set, A: set)\n ensures T + A == A + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_10112","instance":10112,"id":213455,"goal":"lemma SetInterComm_10112(B: set, S: set)\n ensures B * S == S * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_10113","instance":10113,"id":213456,"goal":"lemma SetUnionAssoc_10113(S: set, A: set, B: set)\n ensures (S + A) + B == S + (A + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_10114","instance":10114,"id":213457,"goal":"lemma SetSubsetRefl_10114(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_10115","instance":10115,"id":213458,"goal":"lemma SetSubsetTrans_10115(B: set, U: set, T: set)\n requires B <= U && U <= T\n ensures B <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_10116","instance":10116,"id":213459,"goal":"lemma SetUnionEmpty_10116(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_10117","instance":10117,"id":213460,"goal":"lemma SetInterEmpty_10117(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_10118","instance":10118,"id":213461,"goal":"lemma SetInterSubset_10118(S: set, B: set)\n ensures S * B <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_10119","instance":10119,"id":213462,"goal":"lemma SetCardSubset_10119(B: set, U: set)\n requires B <= U\n ensures |B| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_10120","instance":10120,"id":213463,"goal":"lemma SetUnionCard_10120(U: set, A: set)\n requires U * A == {}\n ensures |U + A| == |U| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_10121","instance":10121,"id":213464,"goal":"lemma SetUnionComm_10121(S: set, A: set)\n ensures S + A == A + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_10122","instance":10122,"id":213465,"goal":"lemma SetInterComm_10122(S: set, A: set)\n ensures S * A == A * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_10123","instance":10123,"id":213466,"goal":"lemma SetUnionAssoc_10123(A: set, U: set, S: set)\n ensures (A + U) + S == A + (U + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_10124","instance":10124,"id":213467,"goal":"lemma SetSubsetRefl_10124(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_10125","instance":10125,"id":213468,"goal":"lemma SetSubsetTrans_10125(S: set, A: set, U: set)\n requires S <= A && A <= U\n ensures S <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_10126","instance":10126,"id":213469,"goal":"lemma SetUnionEmpty_10126(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_10127","instance":10127,"id":213470,"goal":"lemma SetInterEmpty_10127(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_10128","instance":10128,"id":213471,"goal":"lemma SetInterSubset_10128(A: set, U: set)\n ensures A * U <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_10129","instance":10129,"id":213472,"goal":"lemma SetCardSubset_10129(B: set, A: set)\n requires B <= A\n ensures |B| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_10130","instance":10130,"id":213473,"goal":"lemma SetUnionCard_10130(U: set, B: set)\n requires U * B == {}\n ensures |U + B| == |U| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_10131","instance":10131,"id":213474,"goal":"lemma SetUnionComm_10131(S: set, A: set)\n ensures S + A == A + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_10132","instance":10132,"id":213475,"goal":"lemma SetInterComm_10132(A: set, B: set)\n ensures A * B == B * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_10133","instance":10133,"id":213476,"goal":"lemma SetUnionAssoc_10133(S: set, U: set, T: set)\n ensures (S + U) + T == S + (U + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_10134","instance":10134,"id":213477,"goal":"lemma SetSubsetRefl_10134(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_10135","instance":10135,"id":213478,"goal":"lemma SetSubsetTrans_10135(B: set, A: set, U: set)\n requires B <= A && A <= U\n ensures B <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_10136","instance":10136,"id":213479,"goal":"lemma SetUnionEmpty_10136(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_10137","instance":10137,"id":213480,"goal":"lemma SetInterEmpty_10137(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_10138","instance":10138,"id":213481,"goal":"lemma SetInterSubset_10138(A: set, T: set)\n ensures A * T <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_10139","instance":10139,"id":213482,"goal":"lemma SetCardSubset_10139(B: set, T: set)\n requires B <= T\n ensures |B| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_10140","instance":10140,"id":213483,"goal":"lemma SetUnionCard_10140(A: set, T: set)\n requires A * T == {}\n ensures |A + T| == |A| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_10141","instance":10141,"id":213484,"goal":"lemma SetUnionComm_10141(A: set, S: set)\n ensures A + S == S + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_10142","instance":10142,"id":213485,"goal":"lemma SetInterComm_10142(U: set, A: set)\n ensures U * A == A * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_10143","instance":10143,"id":213486,"goal":"lemma SetUnionAssoc_10143(U: set, B: set, T: set)\n ensures (U + B) + T == U + (B + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_10144","instance":10144,"id":213487,"goal":"lemma SetSubsetRefl_10144(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_10145","instance":10145,"id":213488,"goal":"lemma SetSubsetTrans_10145(U: set, B: set, T: set)\n requires U <= B && B <= T\n ensures U <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_10146","instance":10146,"id":213489,"goal":"lemma SetUnionEmpty_10146(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_10147","instance":10147,"id":213490,"goal":"lemma SetInterEmpty_10147(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_10148","instance":10148,"id":213491,"goal":"lemma SetInterSubset_10148(S: set, B: set)\n ensures S * B <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_10149","instance":10149,"id":213492,"goal":"lemma SetCardSubset_10149(A: set, T: set)\n requires A <= T\n ensures |A| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_10150","instance":10150,"id":213493,"goal":"lemma SetUnionCard_10150(S: set, U: set)\n requires S * U == {}\n ensures |S + U| == |S| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_10151","instance":10151,"id":213494,"goal":"lemma SetUnionComm_10151(T: set, U: set)\n ensures T + U == U + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_10152","instance":10152,"id":213495,"goal":"lemma SetInterComm_10152(B: set, T: set)\n ensures B * T == T * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_10153","instance":10153,"id":213496,"goal":"lemma SetUnionAssoc_10153(A: set, B: set, U: set)\n ensures (A + B) + U == A + (B + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_10154","instance":10154,"id":213497,"goal":"lemma SetSubsetRefl_10154(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_10155","instance":10155,"id":213498,"goal":"lemma SetSubsetTrans_10155(S: set, B: set, T: set)\n requires S <= B && B <= T\n ensures S <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_10156","instance":10156,"id":213499,"goal":"lemma SetUnionEmpty_10156(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_10157","instance":10157,"id":213500,"goal":"lemma SetInterEmpty_10157(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_10158","instance":10158,"id":213501,"goal":"lemma SetInterSubset_10158(A: set, S: set)\n ensures A * S <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_10159","instance":10159,"id":213502,"goal":"lemma SetCardSubset_10159(S: set, A: set)\n requires S <= A\n ensures |S| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_10160","instance":10160,"id":213503,"goal":"lemma SetUnionCard_10160(B: set, A: set)\n requires B * A == {}\n ensures |B + A| == |B| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_10161","instance":10161,"id":213504,"goal":"lemma SetUnionComm_10161(B: set, T: set)\n ensures B + T == T + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_10162","instance":10162,"id":213505,"goal":"lemma SetInterComm_10162(B: set, S: set)\n ensures B * S == S * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_10163","instance":10163,"id":213506,"goal":"lemma SetUnionAssoc_10163(T: set, U: set, B: set)\n ensures (T + U) + B == T + (U + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_10164","instance":10164,"id":213507,"goal":"lemma SetSubsetRefl_10164(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_10165","instance":10165,"id":213508,"goal":"lemma SetSubsetTrans_10165(S: set, A: set, T: set)\n requires S <= A && A <= T\n ensures S <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_10166","instance":10166,"id":213509,"goal":"lemma SetUnionEmpty_10166(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_10167","instance":10167,"id":213510,"goal":"lemma SetInterEmpty_10167(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_10168","instance":10168,"id":213511,"goal":"lemma SetInterSubset_10168(T: set, U: set)\n ensures T * U <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_10169","instance":10169,"id":213512,"goal":"lemma SetCardSubset_10169(B: set, A: set)\n requires B <= A\n ensures |B| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_10170","instance":10170,"id":213513,"goal":"lemma SetUnionCard_10170(T: set, B: set)\n requires T * B == {}\n ensures |T + B| == |T| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_10171","instance":10171,"id":213514,"goal":"lemma SetUnionComm_10171(A: set, U: set)\n ensures A + U == U + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_10172","instance":10172,"id":213515,"goal":"lemma SetInterComm_10172(T: set, U: set)\n ensures T * U == U * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_10173","instance":10173,"id":213516,"goal":"lemma SetUnionAssoc_10173(S: set, T: set, A: set)\n ensures (S + T) + A == S + (T + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_10174","instance":10174,"id":213517,"goal":"lemma SetSubsetRefl_10174(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_10175","instance":10175,"id":213518,"goal":"lemma SetSubsetTrans_10175(A: set, U: set, B: set)\n requires A <= U && U <= B\n ensures A <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_10176","instance":10176,"id":213519,"goal":"lemma SetUnionEmpty_10176(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_10177","instance":10177,"id":213520,"goal":"lemma SetInterEmpty_10177(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_10178","instance":10178,"id":213521,"goal":"lemma SetInterSubset_10178(T: set, S: set)\n ensures T * S <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_10179","instance":10179,"id":213522,"goal":"lemma SetCardSubset_10179(T: set, B: set)\n requires T <= B\n ensures |T| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_10180","instance":10180,"id":213523,"goal":"lemma SetUnionCard_10180(U: set, T: set)\n requires U * T == {}\n ensures |U + T| == |U| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_10181","instance":10181,"id":213524,"goal":"lemma SetUnionComm_10181(A: set, T: set)\n ensures A + T == T + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_10182","instance":10182,"id":213525,"goal":"lemma SetInterComm_10182(T: set, S: set)\n ensures T * S == S * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_10183","instance":10183,"id":213526,"goal":"lemma SetUnionAssoc_10183(A: set, U: set, T: set)\n ensures (A + U) + T == A + (U + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_10184","instance":10184,"id":213527,"goal":"lemma SetSubsetRefl_10184(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_10185","instance":10185,"id":213528,"goal":"lemma SetSubsetTrans_10185(S: set, B: set, A: set)\n requires S <= B && B <= A\n ensures S <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_10186","instance":10186,"id":213529,"goal":"lemma SetUnionEmpty_10186(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_10187","instance":10187,"id":213530,"goal":"lemma SetInterEmpty_10187(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_10188","instance":10188,"id":213531,"goal":"lemma SetInterSubset_10188(T: set, A: set)\n ensures T * A <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_10189","instance":10189,"id":213532,"goal":"lemma SetCardSubset_10189(B: set, T: set)\n requires B <= T\n ensures |B| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_10190","instance":10190,"id":213533,"goal":"lemma SetUnionCard_10190(T: set, A: set)\n requires T * A == {}\n ensures |T + A| == |T| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_10191","instance":10191,"id":213534,"goal":"lemma SetUnionComm_10191(T: set, A: set)\n ensures T + A == A + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_10192","instance":10192,"id":213535,"goal":"lemma SetInterComm_10192(B: set, S: set)\n ensures B * S == S * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_10193","instance":10193,"id":213536,"goal":"lemma SetUnionAssoc_10193(T: set, S: set, B: set)\n ensures (T + S) + B == T + (S + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_10194","instance":10194,"id":213537,"goal":"lemma SetSubsetRefl_10194(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_10195","instance":10195,"id":213538,"goal":"lemma SetSubsetTrans_10195(B: set, T: set, S: set)\n requires B <= T && T <= S\n ensures B <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_10196","instance":10196,"id":213539,"goal":"lemma SetUnionEmpty_10196(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_10197","instance":10197,"id":213540,"goal":"lemma SetInterEmpty_10197(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_10198","instance":10198,"id":213541,"goal":"lemma SetInterSubset_10198(U: set, S: set)\n ensures U * S <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_10199","instance":10199,"id":213542,"goal":"lemma SetCardSubset_10199(U: set, A: set)\n requires U <= A\n ensures |U| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_10200","instance":10200,"id":213543,"goal":"lemma SetUnionCard_10200(S: set, U: set)\n requires S * U == {}\n ensures |S + U| == |S| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_10201","instance":10201,"id":213544,"goal":"lemma SetUnionComm_10201(S: set, A: set)\n ensures S + A == A + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_10202","instance":10202,"id":213545,"goal":"lemma SetInterComm_10202(U: set, S: set)\n ensures U * S == S * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_10203","instance":10203,"id":213546,"goal":"lemma SetUnionAssoc_10203(T: set, S: set, U: set)\n ensures (T + S) + U == T + (S + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_10204","instance":10204,"id":213547,"goal":"lemma SetSubsetRefl_10204(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_10205","instance":10205,"id":213548,"goal":"lemma SetSubsetTrans_10205(T: set, S: set, B: set)\n requires T <= S && S <= B\n ensures T <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_10206","instance":10206,"id":213549,"goal":"lemma SetUnionEmpty_10206(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_10207","instance":10207,"id":213550,"goal":"lemma SetInterEmpty_10207(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_10208","instance":10208,"id":213551,"goal":"lemma SetInterSubset_10208(B: set, U: set)\n ensures B * U <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_10209","instance":10209,"id":213552,"goal":"lemma SetCardSubset_10209(U: set, B: set)\n requires U <= B\n ensures |U| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_10210","instance":10210,"id":213553,"goal":"lemma SetUnionCard_10210(U: set, B: set)\n requires U * B == {}\n ensures |U + B| == |U| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_10211","instance":10211,"id":213554,"goal":"lemma SetUnionComm_10211(U: set, S: set)\n ensures U + S == S + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_10212","instance":10212,"id":213555,"goal":"lemma SetInterComm_10212(U: set, T: set)\n ensures U * T == T * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_10213","instance":10213,"id":213556,"goal":"lemma SetUnionAssoc_10213(B: set, T: set, S: set)\n ensures (B + T) + S == B + (T + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_10214","instance":10214,"id":213557,"goal":"lemma SetSubsetRefl_10214(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_10215","instance":10215,"id":213558,"goal":"lemma SetSubsetTrans_10215(S: set, B: set, A: set)\n requires S <= B && B <= A\n ensures S <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_10216","instance":10216,"id":213559,"goal":"lemma SetUnionEmpty_10216(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_10217","instance":10217,"id":213560,"goal":"lemma SetInterEmpty_10217(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_10218","instance":10218,"id":213561,"goal":"lemma SetInterSubset_10218(A: set, B: set)\n ensures A * B <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_10219","instance":10219,"id":213562,"goal":"lemma SetCardSubset_10219(T: set, B: set)\n requires T <= B\n ensures |T| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_10220","instance":10220,"id":213563,"goal":"lemma SetUnionCard_10220(T: set, S: set)\n requires T * S == {}\n ensures |T + S| == |T| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_10221","instance":10221,"id":213564,"goal":"lemma SetUnionComm_10221(S: set, T: set)\n ensures S + T == T + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_10222","instance":10222,"id":213565,"goal":"lemma SetInterComm_10222(A: set, U: set)\n ensures A * U == U * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_10223","instance":10223,"id":213566,"goal":"lemma SetUnionAssoc_10223(A: set, T: set, U: set)\n ensures (A + T) + U == A + (T + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_10224","instance":10224,"id":213567,"goal":"lemma SetSubsetRefl_10224(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_10225","instance":10225,"id":213568,"goal":"lemma SetSubsetTrans_10225(U: set, T: set, A: set)\n requires U <= T && T <= A\n ensures U <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_10226","instance":10226,"id":213569,"goal":"lemma SetUnionEmpty_10226(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_10227","instance":10227,"id":213570,"goal":"lemma SetInterEmpty_10227(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_10228","instance":10228,"id":213571,"goal":"lemma SetInterSubset_10228(T: set, S: set)\n ensures T * S <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_10229","instance":10229,"id":213572,"goal":"lemma SetCardSubset_10229(B: set, U: set)\n requires B <= U\n ensures |B| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_10230","instance":10230,"id":213573,"goal":"lemma SetUnionCard_10230(S: set, A: set)\n requires S * A == {}\n ensures |S + A| == |S| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_10231","instance":10231,"id":213574,"goal":"lemma SetUnionComm_10231(S: set, U: set)\n ensures S + U == U + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_10232","instance":10232,"id":213575,"goal":"lemma SetInterComm_10232(B: set, T: set)\n ensures B * T == T * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_10233","instance":10233,"id":213576,"goal":"lemma SetUnionAssoc_10233(B: set, S: set, U: set)\n ensures (B + S) + U == B + (S + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_10234","instance":10234,"id":213577,"goal":"lemma SetSubsetRefl_10234(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_10235","instance":10235,"id":213578,"goal":"lemma SetSubsetTrans_10235(T: set, B: set, S: set)\n requires T <= B && B <= S\n ensures T <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_10236","instance":10236,"id":213579,"goal":"lemma SetUnionEmpty_10236(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_10237","instance":10237,"id":213580,"goal":"lemma SetInterEmpty_10237(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_10238","instance":10238,"id":213581,"goal":"lemma SetInterSubset_10238(B: set, A: set)\n ensures B * A <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_10239","instance":10239,"id":213582,"goal":"lemma SetCardSubset_10239(S: set, B: set)\n requires S <= B\n ensures |S| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_10240","instance":10240,"id":213583,"goal":"lemma SetUnionCard_10240(B: set, T: set)\n requires B * T == {}\n ensures |B + T| == |B| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_10241","instance":10241,"id":213584,"goal":"lemma SetUnionComm_10241(T: set, B: set)\n ensures T + B == B + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_10242","instance":10242,"id":213585,"goal":"lemma SetInterComm_10242(A: set, U: set)\n ensures A * U == U * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_10243","instance":10243,"id":213586,"goal":"lemma SetUnionAssoc_10243(S: set, B: set, A: set)\n ensures (S + B) + A == S + (B + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_10244","instance":10244,"id":213587,"goal":"lemma SetSubsetRefl_10244(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_10245","instance":10245,"id":213588,"goal":"lemma SetSubsetTrans_10245(U: set, B: set, T: set)\n requires U <= B && B <= T\n ensures U <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_10246","instance":10246,"id":213589,"goal":"lemma SetUnionEmpty_10246(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_10247","instance":10247,"id":213590,"goal":"lemma SetInterEmpty_10247(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_10248","instance":10248,"id":213591,"goal":"lemma SetInterSubset_10248(B: set, U: set)\n ensures B * U <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_10249","instance":10249,"id":213592,"goal":"lemma SetCardSubset_10249(U: set, T: set)\n requires U <= T\n ensures |U| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_10250","instance":10250,"id":213593,"goal":"lemma SetUnionCard_10250(T: set, A: set)\n requires T * A == {}\n ensures |T + A| == |T| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_10251","instance":10251,"id":213594,"goal":"lemma SetUnionComm_10251(U: set, B: set)\n ensures U + B == B + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_10252","instance":10252,"id":213595,"goal":"lemma SetInterComm_10252(B: set, S: set)\n ensures B * S == S * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_10253","instance":10253,"id":213596,"goal":"lemma SetUnionAssoc_10253(A: set, S: set, T: set)\n ensures (A + S) + T == A + (S + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_10254","instance":10254,"id":213597,"goal":"lemma SetSubsetRefl_10254(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_10255","instance":10255,"id":213598,"goal":"lemma SetSubsetTrans_10255(U: set, A: set, S: set)\n requires U <= A && A <= S\n ensures U <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_10256","instance":10256,"id":213599,"goal":"lemma SetUnionEmpty_10256(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_10257","instance":10257,"id":213600,"goal":"lemma SetInterEmpty_10257(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_10258","instance":10258,"id":213601,"goal":"lemma SetInterSubset_10258(U: set, S: set)\n ensures U * S <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_10259","instance":10259,"id":213602,"goal":"lemma SetCardSubset_10259(B: set, U: set)\n requires B <= U\n ensures |B| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_10260","instance":10260,"id":213603,"goal":"lemma SetUnionCard_10260(S: set, A: set)\n requires S * A == {}\n ensures |S + A| == |S| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_10261","instance":10261,"id":213604,"goal":"lemma SetUnionComm_10261(S: set, U: set)\n ensures S + U == U + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_10262","instance":10262,"id":213605,"goal":"lemma SetInterComm_10262(U: set, T: set)\n ensures U * T == T * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_10263","instance":10263,"id":213606,"goal":"lemma SetUnionAssoc_10263(T: set, A: set, S: set)\n ensures (T + A) + S == T + (A + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_10264","instance":10264,"id":213607,"goal":"lemma SetSubsetRefl_10264(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_10265","instance":10265,"id":213608,"goal":"lemma SetSubsetTrans_10265(U: set, S: set, B: set)\n requires U <= S && S <= B\n ensures U <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_10266","instance":10266,"id":213609,"goal":"lemma SetUnionEmpty_10266(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_10267","instance":10267,"id":213610,"goal":"lemma SetInterEmpty_10267(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_10268","instance":10268,"id":213611,"goal":"lemma SetInterSubset_10268(B: set, U: set)\n ensures B * U <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_10269","instance":10269,"id":213612,"goal":"lemma SetCardSubset_10269(A: set, U: set)\n requires A <= U\n ensures |A| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_10270","instance":10270,"id":213613,"goal":"lemma SetUnionCard_10270(B: set, S: set)\n requires B * S == {}\n ensures |B + S| == |B| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_10271","instance":10271,"id":213614,"goal":"lemma SetUnionComm_10271(S: set, B: set)\n ensures S + B == B + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_10272","instance":10272,"id":213615,"goal":"lemma SetInterComm_10272(S: set, U: set)\n ensures S * U == U * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_10273","instance":10273,"id":213616,"goal":"lemma SetUnionAssoc_10273(A: set, U: set, T: set)\n ensures (A + U) + T == A + (U + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_10274","instance":10274,"id":213617,"goal":"lemma SetSubsetRefl_10274(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_10275","instance":10275,"id":213618,"goal":"lemma SetSubsetTrans_10275(U: set, T: set, B: set)\n requires U <= T && T <= B\n ensures U <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_10276","instance":10276,"id":213619,"goal":"lemma SetUnionEmpty_10276(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_10277","instance":10277,"id":213620,"goal":"lemma SetInterEmpty_10277(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_10278","instance":10278,"id":213621,"goal":"lemma SetInterSubset_10278(U: set, S: set)\n ensures U * S <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_10279","instance":10279,"id":213622,"goal":"lemma SetCardSubset_10279(U: set, T: set)\n requires U <= T\n ensures |U| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_10280","instance":10280,"id":213623,"goal":"lemma SetUnionCard_10280(T: set, B: set)\n requires T * B == {}\n ensures |T + B| == |T| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_10281","instance":10281,"id":213624,"goal":"lemma SetUnionComm_10281(B: set, S: set)\n ensures B + S == S + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_10282","instance":10282,"id":213625,"goal":"lemma SetInterComm_10282(T: set, U: set)\n ensures T * U == U * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_10283","instance":10283,"id":213626,"goal":"lemma SetUnionAssoc_10283(T: set, U: set, S: set)\n ensures (T + U) + S == T + (U + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_10284","instance":10284,"id":213627,"goal":"lemma SetSubsetRefl_10284(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_10285","instance":10285,"id":213628,"goal":"lemma SetSubsetTrans_10285(A: set, S: set, B: set)\n requires A <= S && S <= B\n ensures A <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_10286","instance":10286,"id":213629,"goal":"lemma SetUnionEmpty_10286(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_10287","instance":10287,"id":213630,"goal":"lemma SetInterEmpty_10287(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_10288","instance":10288,"id":213631,"goal":"lemma SetInterSubset_10288(B: set, S: set)\n ensures B * S <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_10289","instance":10289,"id":213632,"goal":"lemma SetCardSubset_10289(S: set, U: set)\n requires S <= U\n ensures |S| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_10290","instance":10290,"id":213633,"goal":"lemma SetUnionCard_10290(B: set, S: set)\n requires B * S == {}\n ensures |B + S| == |B| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_10291","instance":10291,"id":213634,"goal":"lemma SetUnionComm_10291(A: set, S: set)\n ensures A + S == S + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_10292","instance":10292,"id":213635,"goal":"lemma SetInterComm_10292(B: set, A: set)\n ensures B * A == A * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_10293","instance":10293,"id":213636,"goal":"lemma SetUnionAssoc_10293(S: set, U: set, A: set)\n ensures (S + U) + A == S + (U + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_10294","instance":10294,"id":213637,"goal":"lemma SetSubsetRefl_10294(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_10295","instance":10295,"id":213638,"goal":"lemma SetSubsetTrans_10295(A: set, B: set, T: set)\n requires A <= B && B <= T\n ensures A <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_10296","instance":10296,"id":213639,"goal":"lemma SetUnionEmpty_10296(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_10297","instance":10297,"id":213640,"goal":"lemma SetInterEmpty_10297(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_10298","instance":10298,"id":213641,"goal":"lemma SetInterSubset_10298(U: set, A: set)\n ensures U * A <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_10299","instance":10299,"id":213642,"goal":"lemma SetCardSubset_10299(S: set, A: set)\n requires S <= A\n ensures |S| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_10300","instance":10300,"id":213643,"goal":"lemma SetUnionCard_10300(S: set, T: set)\n requires S * T == {}\n ensures |S + T| == |S| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_10301","instance":10301,"id":213644,"goal":"lemma SetUnionComm_10301(T: set, U: set)\n ensures T + U == U + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_10302","instance":10302,"id":213645,"goal":"lemma SetInterComm_10302(B: set, A: set)\n ensures B * A == A * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_10303","instance":10303,"id":213646,"goal":"lemma SetUnionAssoc_10303(S: set, A: set, U: set)\n ensures (S + A) + U == S + (A + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_10304","instance":10304,"id":213647,"goal":"lemma SetSubsetRefl_10304(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_10305","instance":10305,"id":213648,"goal":"lemma SetSubsetTrans_10305(A: set, U: set, S: set)\n requires A <= U && U <= S\n ensures A <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_10306","instance":10306,"id":213649,"goal":"lemma SetUnionEmpty_10306(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_10307","instance":10307,"id":213650,"goal":"lemma SetInterEmpty_10307(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_10308","instance":10308,"id":213651,"goal":"lemma SetInterSubset_10308(S: set, T: set)\n ensures S * T <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_10309","instance":10309,"id":213652,"goal":"lemma SetCardSubset_10309(S: set, T: set)\n requires S <= T\n ensures |S| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_10310","instance":10310,"id":213653,"goal":"lemma SetUnionCard_10310(B: set, S: set)\n requires B * S == {}\n ensures |B + S| == |B| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_10311","instance":10311,"id":213654,"goal":"lemma SetUnionComm_10311(A: set, T: set)\n ensures A + T == T + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_10312","instance":10312,"id":213655,"goal":"lemma SetInterComm_10312(B: set, U: set)\n ensures B * U == U * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_10313","instance":10313,"id":213656,"goal":"lemma SetUnionAssoc_10313(A: set, S: set, T: set)\n ensures (A + S) + T == A + (S + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_10314","instance":10314,"id":213657,"goal":"lemma SetSubsetRefl_10314(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_10315","instance":10315,"id":213658,"goal":"lemma SetSubsetTrans_10315(A: set, S: set, T: set)\n requires A <= S && S <= T\n ensures A <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_10316","instance":10316,"id":213659,"goal":"lemma SetUnionEmpty_10316(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_10317","instance":10317,"id":213660,"goal":"lemma SetInterEmpty_10317(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_10318","instance":10318,"id":213661,"goal":"lemma SetInterSubset_10318(U: set, B: set)\n ensures U * B <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_10319","instance":10319,"id":213662,"goal":"lemma SetCardSubset_10319(U: set, S: set)\n requires U <= S\n ensures |U| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_10320","instance":10320,"id":213663,"goal":"lemma SetUnionCard_10320(T: set, S: set)\n requires T * S == {}\n ensures |T + S| == |T| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_10321","instance":10321,"id":213664,"goal":"lemma SetUnionComm_10321(A: set, S: set)\n ensures A + S == S + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_10322","instance":10322,"id":213665,"goal":"lemma SetInterComm_10322(A: set, B: set)\n ensures A * B == B * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_10323","instance":10323,"id":213666,"goal":"lemma SetUnionAssoc_10323(T: set, U: set, A: set)\n ensures (T + U) + A == T + (U + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_10324","instance":10324,"id":213667,"goal":"lemma SetSubsetRefl_10324(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_10325","instance":10325,"id":213668,"goal":"lemma SetSubsetTrans_10325(B: set, U: set, S: set)\n requires B <= U && U <= S\n ensures B <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_10326","instance":10326,"id":213669,"goal":"lemma SetUnionEmpty_10326(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_10327","instance":10327,"id":213670,"goal":"lemma SetInterEmpty_10327(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_10328","instance":10328,"id":213671,"goal":"lemma SetInterSubset_10328(U: set, A: set)\n ensures U * A <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_10329","instance":10329,"id":213672,"goal":"lemma SetCardSubset_10329(B: set, T: set)\n requires B <= T\n ensures |B| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_10330","instance":10330,"id":213673,"goal":"lemma SetUnionCard_10330(S: set, B: set)\n requires S * B == {}\n ensures |S + B| == |S| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_10331","instance":10331,"id":213674,"goal":"lemma SetUnionComm_10331(B: set, T: set)\n ensures B + T == T + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_10332","instance":10332,"id":213675,"goal":"lemma SetInterComm_10332(S: set, T: set)\n ensures S * T == T * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_10333","instance":10333,"id":213676,"goal":"lemma SetUnionAssoc_10333(U: set, B: set, A: set)\n ensures (U + B) + A == U + (B + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_10334","instance":10334,"id":213677,"goal":"lemma SetSubsetRefl_10334(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_10335","instance":10335,"id":213678,"goal":"lemma SetSubsetTrans_10335(A: set, T: set, B: set)\n requires A <= T && T <= B\n ensures A <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_10336","instance":10336,"id":213679,"goal":"lemma SetUnionEmpty_10336(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_10337","instance":10337,"id":213680,"goal":"lemma SetInterEmpty_10337(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_10338","instance":10338,"id":213681,"goal":"lemma SetInterSubset_10338(T: set, A: set)\n ensures T * A <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_10339","instance":10339,"id":213682,"goal":"lemma SetCardSubset_10339(B: set, S: set)\n requires B <= S\n ensures |B| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_10340","instance":10340,"id":213683,"goal":"lemma SetUnionCard_10340(S: set, U: set)\n requires S * U == {}\n ensures |S + U| == |S| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_10341","instance":10341,"id":213684,"goal":"lemma SetUnionComm_10341(U: set, A: set)\n ensures U + A == A + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_10342","instance":10342,"id":213685,"goal":"lemma SetInterComm_10342(U: set, T: set)\n ensures U * T == T * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_10343","instance":10343,"id":213686,"goal":"lemma SetUnionAssoc_10343(S: set, B: set, U: set)\n ensures (S + B) + U == S + (B + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_10344","instance":10344,"id":213687,"goal":"lemma SetSubsetRefl_10344(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_10345","instance":10345,"id":213688,"goal":"lemma SetSubsetTrans_10345(S: set, A: set, B: set)\n requires S <= A && A <= B\n ensures S <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_10346","instance":10346,"id":213689,"goal":"lemma SetUnionEmpty_10346(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_10347","instance":10347,"id":213690,"goal":"lemma SetInterEmpty_10347(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_10348","instance":10348,"id":213691,"goal":"lemma SetInterSubset_10348(B: set, U: set)\n ensures B * U <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_10349","instance":10349,"id":213692,"goal":"lemma SetCardSubset_10349(A: set, U: set)\n requires A <= U\n ensures |A| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_10350","instance":10350,"id":213693,"goal":"lemma SetUnionCard_10350(U: set, B: set)\n requires U * B == {}\n ensures |U + B| == |U| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_10351","instance":10351,"id":213694,"goal":"lemma SetUnionComm_10351(S: set, U: set)\n ensures S + U == U + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_10352","instance":10352,"id":213695,"goal":"lemma SetInterComm_10352(T: set, U: set)\n ensures T * U == U * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_10353","instance":10353,"id":213696,"goal":"lemma SetUnionAssoc_10353(U: set, A: set, B: set)\n ensures (U + A) + B == U + (A + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_10354","instance":10354,"id":213697,"goal":"lemma SetSubsetRefl_10354(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_10355","instance":10355,"id":213698,"goal":"lemma SetSubsetTrans_10355(T: set, B: set, A: set)\n requires T <= B && B <= A\n ensures T <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_10356","instance":10356,"id":213699,"goal":"lemma SetUnionEmpty_10356(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_10357","instance":10357,"id":213700,"goal":"lemma SetInterEmpty_10357(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_10358","instance":10358,"id":213701,"goal":"lemma SetInterSubset_10358(T: set, S: set)\n ensures T * S <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_10359","instance":10359,"id":213702,"goal":"lemma SetCardSubset_10359(T: set, B: set)\n requires T <= B\n ensures |T| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_10360","instance":10360,"id":213703,"goal":"lemma SetUnionCard_10360(B: set, T: set)\n requires B * T == {}\n ensures |B + T| == |B| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_10361","instance":10361,"id":213704,"goal":"lemma SetUnionComm_10361(A: set, T: set)\n ensures A + T == T + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_10362","instance":10362,"id":213705,"goal":"lemma SetInterComm_10362(T: set, U: set)\n ensures T * U == U * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_10363","instance":10363,"id":213706,"goal":"lemma SetUnionAssoc_10363(T: set, B: set, U: set)\n ensures (T + B) + U == T + (B + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_10364","instance":10364,"id":213707,"goal":"lemma SetSubsetRefl_10364(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_10365","instance":10365,"id":213708,"goal":"lemma SetSubsetTrans_10365(A: set, S: set, B: set)\n requires A <= S && S <= B\n ensures A <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_10366","instance":10366,"id":213709,"goal":"lemma SetUnionEmpty_10366(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_10367","instance":10367,"id":213710,"goal":"lemma SetInterEmpty_10367(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_10368","instance":10368,"id":213711,"goal":"lemma SetInterSubset_10368(U: set, B: set)\n ensures U * B <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_10369","instance":10369,"id":213712,"goal":"lemma SetCardSubset_10369(S: set, B: set)\n requires S <= B\n ensures |S| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_10370","instance":10370,"id":213713,"goal":"lemma SetUnionCard_10370(B: set, U: set)\n requires B * U == {}\n ensures |B + U| == |B| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_10371","instance":10371,"id":213714,"goal":"lemma SetUnionComm_10371(S: set, B: set)\n ensures S + B == B + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_10372","instance":10372,"id":213715,"goal":"lemma SetInterComm_10372(A: set, T: set)\n ensures A * T == T * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_10373","instance":10373,"id":213716,"goal":"lemma SetUnionAssoc_10373(S: set, B: set, T: set)\n ensures (S + B) + T == S + (B + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_10374","instance":10374,"id":213717,"goal":"lemma SetSubsetRefl_10374(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_10375","instance":10375,"id":213718,"goal":"lemma SetSubsetTrans_10375(A: set, T: set, S: set)\n requires A <= T && T <= S\n ensures A <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_10376","instance":10376,"id":213719,"goal":"lemma SetUnionEmpty_10376(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_10377","instance":10377,"id":213720,"goal":"lemma SetInterEmpty_10377(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_10378","instance":10378,"id":213721,"goal":"lemma SetInterSubset_10378(U: set, A: set)\n ensures U * A <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_10379","instance":10379,"id":213722,"goal":"lemma SetCardSubset_10379(B: set, T: set)\n requires B <= T\n ensures |B| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_10380","instance":10380,"id":213723,"goal":"lemma SetUnionCard_10380(T: set, U: set)\n requires T * U == {}\n ensures |T + U| == |T| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_10381","instance":10381,"id":213724,"goal":"lemma SetUnionComm_10381(S: set, U: set)\n ensures S + U == U + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_10382","instance":10382,"id":213725,"goal":"lemma SetInterComm_10382(B: set, S: set)\n ensures B * S == S * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_10383","instance":10383,"id":213726,"goal":"lemma SetUnionAssoc_10383(T: set, U: set, B: set)\n ensures (T + U) + B == T + (U + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_10384","instance":10384,"id":213727,"goal":"lemma SetSubsetRefl_10384(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_10385","instance":10385,"id":213728,"goal":"lemma SetSubsetTrans_10385(T: set, B: set, A: set)\n requires T <= B && B <= A\n ensures T <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_10386","instance":10386,"id":213729,"goal":"lemma SetUnionEmpty_10386(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_10387","instance":10387,"id":213730,"goal":"lemma SetInterEmpty_10387(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_10388","instance":10388,"id":213731,"goal":"lemma SetInterSubset_10388(A: set, U: set)\n ensures A * U <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_10389","instance":10389,"id":213732,"goal":"lemma SetCardSubset_10389(A: set, S: set)\n requires A <= S\n ensures |A| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_10390","instance":10390,"id":213733,"goal":"lemma SetUnionCard_10390(U: set, T: set)\n requires U * T == {}\n ensures |U + T| == |U| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_10391","instance":10391,"id":213734,"goal":"lemma SetUnionComm_10391(B: set, T: set)\n ensures B + T == T + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_10392","instance":10392,"id":213735,"goal":"lemma SetInterComm_10392(B: set, T: set)\n ensures B * T == T * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_10393","instance":10393,"id":213736,"goal":"lemma SetUnionAssoc_10393(A: set, T: set, S: set)\n ensures (A + T) + S == A + (T + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_10394","instance":10394,"id":213737,"goal":"lemma SetSubsetRefl_10394(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_10395","instance":10395,"id":213738,"goal":"lemma SetSubsetTrans_10395(B: set, U: set, A: set)\n requires B <= U && U <= A\n ensures B <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_10396","instance":10396,"id":213739,"goal":"lemma SetUnionEmpty_10396(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_10397","instance":10397,"id":213740,"goal":"lemma SetInterEmpty_10397(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_10398","instance":10398,"id":213741,"goal":"lemma SetInterSubset_10398(S: set, T: set)\n ensures S * T <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_10399","instance":10399,"id":213742,"goal":"lemma SetCardSubset_10399(S: set, T: set)\n requires S <= T\n ensures |S| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_10400","instance":10400,"id":213743,"goal":"lemma SetUnionCard_10400(U: set, S: set)\n requires U * S == {}\n ensures |U + S| == |U| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_10401","instance":10401,"id":213744,"goal":"lemma SetUnionComm_10401(U: set, S: set)\n ensures U + S == S + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_10402","instance":10402,"id":213745,"goal":"lemma SetInterComm_10402(U: set, S: set)\n ensures U * S == S * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_10403","instance":10403,"id":213746,"goal":"lemma SetUnionAssoc_10403(U: set, S: set, A: set)\n ensures (U + S) + A == U + (S + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_10404","instance":10404,"id":213747,"goal":"lemma SetSubsetRefl_10404(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_10405","instance":10405,"id":213748,"goal":"lemma SetSubsetTrans_10405(T: set, B: set, A: set)\n requires T <= B && B <= A\n ensures T <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_10406","instance":10406,"id":213749,"goal":"lemma SetUnionEmpty_10406(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_10407","instance":10407,"id":213750,"goal":"lemma SetInterEmpty_10407(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_10408","instance":10408,"id":213751,"goal":"lemma SetInterSubset_10408(A: set, S: set)\n ensures A * S <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_10409","instance":10409,"id":213752,"goal":"lemma SetCardSubset_10409(U: set, S: set)\n requires U <= S\n ensures |U| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_10410","instance":10410,"id":213753,"goal":"lemma SetUnionCard_10410(A: set, S: set)\n requires A * S == {}\n ensures |A + S| == |A| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_10411","instance":10411,"id":213754,"goal":"lemma SetUnionComm_10411(A: set, S: set)\n ensures A + S == S + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_10412","instance":10412,"id":213755,"goal":"lemma SetInterComm_10412(B: set, A: set)\n ensures B * A == A * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_10413","instance":10413,"id":213756,"goal":"lemma SetUnionAssoc_10413(A: set, S: set, U: set)\n ensures (A + S) + U == A + (S + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_10414","instance":10414,"id":213757,"goal":"lemma SetSubsetRefl_10414(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_10415","instance":10415,"id":213758,"goal":"lemma SetSubsetTrans_10415(T: set, U: set, S: set)\n requires T <= U && U <= S\n ensures T <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_10416","instance":10416,"id":213759,"goal":"lemma SetUnionEmpty_10416(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_10417","instance":10417,"id":213760,"goal":"lemma SetInterEmpty_10417(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_10418","instance":10418,"id":213761,"goal":"lemma SetInterSubset_10418(B: set, U: set)\n ensures B * U <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_10419","instance":10419,"id":213762,"goal":"lemma SetCardSubset_10419(B: set, S: set)\n requires B <= S\n ensures |B| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_10420","instance":10420,"id":213763,"goal":"lemma SetUnionCard_10420(S: set, T: set)\n requires S * T == {}\n ensures |S + T| == |S| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_10421","instance":10421,"id":213764,"goal":"lemma SetUnionComm_10421(T: set, S: set)\n ensures T + S == S + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_10422","instance":10422,"id":213765,"goal":"lemma SetInterComm_10422(B: set, T: set)\n ensures B * T == T * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_10423","instance":10423,"id":213766,"goal":"lemma SetUnionAssoc_10423(T: set, S: set, U: set)\n ensures (T + S) + U == T + (S + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_10424","instance":10424,"id":213767,"goal":"lemma SetSubsetRefl_10424(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_10425","instance":10425,"id":213768,"goal":"lemma SetSubsetTrans_10425(B: set, S: set, T: set)\n requires B <= S && S <= T\n ensures B <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_10426","instance":10426,"id":213769,"goal":"lemma SetUnionEmpty_10426(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_10427","instance":10427,"id":213770,"goal":"lemma SetInterEmpty_10427(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_10428","instance":10428,"id":213771,"goal":"lemma SetInterSubset_10428(A: set, T: set)\n ensures A * T <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_10429","instance":10429,"id":213772,"goal":"lemma SetCardSubset_10429(S: set, U: set)\n requires S <= U\n ensures |S| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_10430","instance":10430,"id":213773,"goal":"lemma SetUnionCard_10430(U: set, S: set)\n requires U * S == {}\n ensures |U + S| == |U| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_10431","instance":10431,"id":213774,"goal":"lemma SetUnionComm_10431(A: set, B: set)\n ensures A + B == B + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_10432","instance":10432,"id":213775,"goal":"lemma SetInterComm_10432(T: set, U: set)\n ensures T * U == U * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_10433","instance":10433,"id":213776,"goal":"lemma SetUnionAssoc_10433(A: set, U: set, T: set)\n ensures (A + U) + T == A + (U + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_10434","instance":10434,"id":213777,"goal":"lemma SetSubsetRefl_10434(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_10435","instance":10435,"id":213778,"goal":"lemma SetSubsetTrans_10435(A: set, U: set, B: set)\n requires A <= U && U <= B\n ensures A <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_10436","instance":10436,"id":213779,"goal":"lemma SetUnionEmpty_10436(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_10437","instance":10437,"id":213780,"goal":"lemma SetInterEmpty_10437(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_10438","instance":10438,"id":213781,"goal":"lemma SetInterSubset_10438(T: set, S: set)\n ensures T * S <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_10439","instance":10439,"id":213782,"goal":"lemma SetCardSubset_10439(A: set, T: set)\n requires A <= T\n ensures |A| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_10440","instance":10440,"id":213783,"goal":"lemma SetUnionCard_10440(T: set, S: set)\n requires T * S == {}\n ensures |T + S| == |T| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_10441","instance":10441,"id":213784,"goal":"lemma SetUnionComm_10441(U: set, S: set)\n ensures U + S == S + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_10442","instance":10442,"id":213785,"goal":"lemma SetInterComm_10442(S: set, A: set)\n ensures S * A == A * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_10443","instance":10443,"id":213786,"goal":"lemma SetUnionAssoc_10443(A: set, S: set, T: set)\n ensures (A + S) + T == A + (S + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_10444","instance":10444,"id":213787,"goal":"lemma SetSubsetRefl_10444(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_10445","instance":10445,"id":213788,"goal":"lemma SetSubsetTrans_10445(S: set, B: set, T: set)\n requires S <= B && B <= T\n ensures S <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_10446","instance":10446,"id":213789,"goal":"lemma SetUnionEmpty_10446(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_10447","instance":10447,"id":213790,"goal":"lemma SetInterEmpty_10447(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_10448","instance":10448,"id":213791,"goal":"lemma SetInterSubset_10448(T: set, U: set)\n ensures T * U <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_10449","instance":10449,"id":213792,"goal":"lemma SetCardSubset_10449(B: set, T: set)\n requires B <= T\n ensures |B| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_10450","instance":10450,"id":213793,"goal":"lemma SetUnionCard_10450(U: set, T: set)\n requires U * T == {}\n ensures |U + T| == |U| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_10451","instance":10451,"id":213794,"goal":"lemma SetUnionComm_10451(B: set, U: set)\n ensures B + U == U + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_10452","instance":10452,"id":213795,"goal":"lemma SetInterComm_10452(T: set, U: set)\n ensures T * U == U * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_10453","instance":10453,"id":213796,"goal":"lemma SetUnionAssoc_10453(U: set, A: set, S: set)\n ensures (U + A) + S == U + (A + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_10454","instance":10454,"id":213797,"goal":"lemma SetSubsetRefl_10454(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_10455","instance":10455,"id":213798,"goal":"lemma SetSubsetTrans_10455(B: set, U: set, T: set)\n requires B <= U && U <= T\n ensures B <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_10456","instance":10456,"id":213799,"goal":"lemma SetUnionEmpty_10456(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_10457","instance":10457,"id":213800,"goal":"lemma SetInterEmpty_10457(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_10458","instance":10458,"id":213801,"goal":"lemma SetInterSubset_10458(A: set, U: set)\n ensures A * U <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_10459","instance":10459,"id":213802,"goal":"lemma SetCardSubset_10459(S: set, T: set)\n requires S <= T\n ensures |S| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_10460","instance":10460,"id":213803,"goal":"lemma SetUnionCard_10460(T: set, U: set)\n requires T * U == {}\n ensures |T + U| == |T| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_10461","instance":10461,"id":213804,"goal":"lemma SetUnionComm_10461(B: set, T: set)\n ensures B + T == T + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_10462","instance":10462,"id":213805,"goal":"lemma SetInterComm_10462(B: set, A: set)\n ensures B * A == A * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_10463","instance":10463,"id":213806,"goal":"lemma SetUnionAssoc_10463(T: set, A: set, U: set)\n ensures (T + A) + U == T + (A + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_10464","instance":10464,"id":213807,"goal":"lemma SetSubsetRefl_10464(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_10465","instance":10465,"id":213808,"goal":"lemma SetSubsetTrans_10465(B: set, U: set, S: set)\n requires B <= U && U <= S\n ensures B <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_10466","instance":10466,"id":213809,"goal":"lemma SetUnionEmpty_10466(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_10467","instance":10467,"id":213810,"goal":"lemma SetInterEmpty_10467(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_10468","instance":10468,"id":213811,"goal":"lemma SetInterSubset_10468(B: set, T: set)\n ensures B * T <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_10469","instance":10469,"id":213812,"goal":"lemma SetCardSubset_10469(T: set, A: set)\n requires T <= A\n ensures |T| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_10470","instance":10470,"id":213813,"goal":"lemma SetUnionCard_10470(T: set, A: set)\n requires T * A == {}\n ensures |T + A| == |T| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_10471","instance":10471,"id":213814,"goal":"lemma SetUnionComm_10471(B: set, S: set)\n ensures B + S == S + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_10472","instance":10472,"id":213815,"goal":"lemma SetInterComm_10472(S: set, T: set)\n ensures S * T == T * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_10473","instance":10473,"id":213816,"goal":"lemma SetUnionAssoc_10473(T: set, B: set, U: set)\n ensures (T + B) + U == T + (B + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_10474","instance":10474,"id":213817,"goal":"lemma SetSubsetRefl_10474(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_10475","instance":10475,"id":213818,"goal":"lemma SetSubsetTrans_10475(S: set, A: set, B: set)\n requires S <= A && A <= B\n ensures S <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_10476","instance":10476,"id":213819,"goal":"lemma SetUnionEmpty_10476(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_10477","instance":10477,"id":213820,"goal":"lemma SetInterEmpty_10477(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_10478","instance":10478,"id":213821,"goal":"lemma SetInterSubset_10478(S: set, B: set)\n ensures S * B <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_10479","instance":10479,"id":213822,"goal":"lemma SetCardSubset_10479(A: set, U: set)\n requires A <= U\n ensures |A| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_10480","instance":10480,"id":213823,"goal":"lemma SetUnionCard_10480(U: set, S: set)\n requires U * S == {}\n ensures |U + S| == |U| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_10481","instance":10481,"id":213824,"goal":"lemma SetUnionComm_10481(T: set, S: set)\n ensures T + S == S + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_10482","instance":10482,"id":213825,"goal":"lemma SetInterComm_10482(A: set, U: set)\n ensures A * U == U * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_10483","instance":10483,"id":213826,"goal":"lemma SetUnionAssoc_10483(T: set, B: set, S: set)\n ensures (T + B) + S == T + (B + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_10484","instance":10484,"id":213827,"goal":"lemma SetSubsetRefl_10484(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_10485","instance":10485,"id":213828,"goal":"lemma SetSubsetTrans_10485(A: set, U: set, S: set)\n requires A <= U && U <= S\n ensures A <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_10486","instance":10486,"id":213829,"goal":"lemma SetUnionEmpty_10486(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_10487","instance":10487,"id":213830,"goal":"lemma SetInterEmpty_10487(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_10488","instance":10488,"id":213831,"goal":"lemma SetInterSubset_10488(U: set, A: set)\n ensures U * A <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_10489","instance":10489,"id":213832,"goal":"lemma SetCardSubset_10489(S: set, B: set)\n requires S <= B\n ensures |S| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_10490","instance":10490,"id":213833,"goal":"lemma SetUnionCard_10490(U: set, T: set)\n requires U * T == {}\n ensures |U + T| == |U| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_10491","instance":10491,"id":213834,"goal":"lemma SetUnionComm_10491(T: set, B: set)\n ensures T + B == B + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_10492","instance":10492,"id":213835,"goal":"lemma SetInterComm_10492(T: set, U: set)\n ensures T * U == U * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_10493","instance":10493,"id":213836,"goal":"lemma SetUnionAssoc_10493(T: set, S: set, A: set)\n ensures (T + S) + A == T + (S + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_10494","instance":10494,"id":213837,"goal":"lemma SetSubsetRefl_10494(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_10495","instance":10495,"id":213838,"goal":"lemma SetSubsetTrans_10495(S: set, A: set, T: set)\n requires S <= A && A <= T\n ensures S <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_10496","instance":10496,"id":213839,"goal":"lemma SetUnionEmpty_10496(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_10497","instance":10497,"id":213840,"goal":"lemma SetInterEmpty_10497(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_10498","instance":10498,"id":213841,"goal":"lemma SetInterSubset_10498(T: set, B: set)\n ensures T * B <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_10499","instance":10499,"id":213842,"goal":"lemma SetCardSubset_10499(A: set, U: set)\n requires A <= U\n ensures |A| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_10500","instance":10500,"id":213843,"goal":"lemma SetUnionCard_10500(B: set, T: set)\n requires B * T == {}\n ensures |B + T| == |B| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_10501","instance":10501,"id":213844,"goal":"lemma SetUnionComm_10501(U: set, A: set)\n ensures U + A == A + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_10502","instance":10502,"id":213845,"goal":"lemma SetInterComm_10502(A: set, T: set)\n ensures A * T == T * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_10503","instance":10503,"id":213846,"goal":"lemma SetUnionAssoc_10503(B: set, A: set, U: set)\n ensures (B + A) + U == B + (A + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_10504","instance":10504,"id":213847,"goal":"lemma SetSubsetRefl_10504(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_10505","instance":10505,"id":213848,"goal":"lemma SetSubsetTrans_10505(T: set, B: set, U: set)\n requires T <= B && B <= U\n ensures T <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_10506","instance":10506,"id":213849,"goal":"lemma SetUnionEmpty_10506(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_10507","instance":10507,"id":213850,"goal":"lemma SetInterEmpty_10507(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_10508","instance":10508,"id":213851,"goal":"lemma SetInterSubset_10508(B: set, A: set)\n ensures B * A <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_10509","instance":10509,"id":213852,"goal":"lemma SetCardSubset_10509(A: set, B: set)\n requires A <= B\n ensures |A| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_10510","instance":10510,"id":213853,"goal":"lemma SetUnionCard_10510(U: set, T: set)\n requires U * T == {}\n ensures |U + T| == |U| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_10511","instance":10511,"id":213854,"goal":"lemma SetUnionComm_10511(B: set, T: set)\n ensures B + T == T + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_10512","instance":10512,"id":213855,"goal":"lemma SetInterComm_10512(B: set, U: set)\n ensures B * U == U * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_10513","instance":10513,"id":213856,"goal":"lemma SetUnionAssoc_10513(A: set, U: set, S: set)\n ensures (A + U) + S == A + (U + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_10514","instance":10514,"id":213857,"goal":"lemma SetSubsetRefl_10514(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_10515","instance":10515,"id":213858,"goal":"lemma SetSubsetTrans_10515(T: set, U: set, A: set)\n requires T <= U && U <= A\n ensures T <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_10516","instance":10516,"id":213859,"goal":"lemma SetUnionEmpty_10516(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_10517","instance":10517,"id":213860,"goal":"lemma SetInterEmpty_10517(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_10518","instance":10518,"id":213861,"goal":"lemma SetInterSubset_10518(T: set, S: set)\n ensures T * S <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_10519","instance":10519,"id":213862,"goal":"lemma SetCardSubset_10519(A: set, T: set)\n requires A <= T\n ensures |A| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_10520","instance":10520,"id":213863,"goal":"lemma SetUnionCard_10520(S: set, U: set)\n requires S * U == {}\n ensures |S + U| == |S| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_10521","instance":10521,"id":213864,"goal":"lemma SetUnionComm_10521(B: set, S: set)\n ensures B + S == S + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_10522","instance":10522,"id":213865,"goal":"lemma SetInterComm_10522(T: set, B: set)\n ensures T * B == B * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_10523","instance":10523,"id":213866,"goal":"lemma SetUnionAssoc_10523(U: set, B: set, S: set)\n ensures (U + B) + S == U + (B + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_10524","instance":10524,"id":213867,"goal":"lemma SetSubsetRefl_10524(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_10525","instance":10525,"id":213868,"goal":"lemma SetSubsetTrans_10525(B: set, S: set, T: set)\n requires B <= S && S <= T\n ensures B <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_10526","instance":10526,"id":213869,"goal":"lemma SetUnionEmpty_10526(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_10527","instance":10527,"id":213870,"goal":"lemma SetInterEmpty_10527(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_10528","instance":10528,"id":213871,"goal":"lemma SetInterSubset_10528(B: set, A: set)\n ensures B * A <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_10529","instance":10529,"id":213872,"goal":"lemma SetCardSubset_10529(S: set, B: set)\n requires S <= B\n ensures |S| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_10530","instance":10530,"id":213873,"goal":"lemma SetUnionCard_10530(B: set, T: set)\n requires B * T == {}\n ensures |B + T| == |B| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_10531","instance":10531,"id":213874,"goal":"lemma SetUnionComm_10531(A: set, T: set)\n ensures A + T == T + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_10532","instance":10532,"id":213875,"goal":"lemma SetInterComm_10532(B: set, S: set)\n ensures B * S == S * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_10533","instance":10533,"id":213876,"goal":"lemma SetUnionAssoc_10533(S: set, B: set, A: set)\n ensures (S + B) + A == S + (B + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_10534","instance":10534,"id":213877,"goal":"lemma SetSubsetRefl_10534(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_10535","instance":10535,"id":213878,"goal":"lemma SetSubsetTrans_10535(S: set, U: set, B: set)\n requires S <= U && U <= B\n ensures S <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_10536","instance":10536,"id":213879,"goal":"lemma SetUnionEmpty_10536(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_10537","instance":10537,"id":213880,"goal":"lemma SetInterEmpty_10537(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_10538","instance":10538,"id":213881,"goal":"lemma SetInterSubset_10538(U: set, S: set)\n ensures U * S <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_10539","instance":10539,"id":213882,"goal":"lemma SetCardSubset_10539(A: set, T: set)\n requires A <= T\n ensures |A| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_10540","instance":10540,"id":213883,"goal":"lemma SetUnionCard_10540(A: set, B: set)\n requires A * B == {}\n ensures |A + B| == |A| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_10541","instance":10541,"id":213884,"goal":"lemma SetUnionComm_10541(T: set, U: set)\n ensures T + U == U + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_10542","instance":10542,"id":213885,"goal":"lemma SetInterComm_10542(A: set, T: set)\n ensures A * T == T * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_10543","instance":10543,"id":213886,"goal":"lemma SetUnionAssoc_10543(T: set, U: set, S: set)\n ensures (T + U) + S == T + (U + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_10544","instance":10544,"id":213887,"goal":"lemma SetSubsetRefl_10544(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_10545","instance":10545,"id":213888,"goal":"lemma SetSubsetTrans_10545(A: set, T: set, B: set)\n requires A <= T && T <= B\n ensures A <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_10546","instance":10546,"id":213889,"goal":"lemma SetUnionEmpty_10546(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_10547","instance":10547,"id":213890,"goal":"lemma SetInterEmpty_10547(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_10548","instance":10548,"id":213891,"goal":"lemma SetInterSubset_10548(U: set, T: set)\n ensures U * T <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_10549","instance":10549,"id":213892,"goal":"lemma SetCardSubset_10549(A: set, U: set)\n requires A <= U\n ensures |A| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_10550","instance":10550,"id":213893,"goal":"lemma SetUnionCard_10550(S: set, U: set)\n requires S * U == {}\n ensures |S + U| == |S| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_10551","instance":10551,"id":213894,"goal":"lemma SetUnionComm_10551(S: set, A: set)\n ensures S + A == A + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_10552","instance":10552,"id":213895,"goal":"lemma SetInterComm_10552(A: set, U: set)\n ensures A * U == U * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_10553","instance":10553,"id":213896,"goal":"lemma SetUnionAssoc_10553(U: set, S: set, A: set)\n ensures (U + S) + A == U + (S + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_10554","instance":10554,"id":213897,"goal":"lemma SetSubsetRefl_10554(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_10555","instance":10555,"id":213898,"goal":"lemma SetSubsetTrans_10555(T: set, B: set, U: set)\n requires T <= B && B <= U\n ensures T <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_10556","instance":10556,"id":213899,"goal":"lemma SetUnionEmpty_10556(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_10557","instance":10557,"id":213900,"goal":"lemma SetInterEmpty_10557(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_10558","instance":10558,"id":213901,"goal":"lemma SetInterSubset_10558(S: set, U: set)\n ensures S * U <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_10559","instance":10559,"id":213902,"goal":"lemma SetCardSubset_10559(T: set, U: set)\n requires T <= U\n ensures |T| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_10560","instance":10560,"id":213903,"goal":"lemma SetUnionCard_10560(S: set, T: set)\n requires S * T == {}\n ensures |S + T| == |S| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_10561","instance":10561,"id":213904,"goal":"lemma SetUnionComm_10561(U: set, B: set)\n ensures U + B == B + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_10562","instance":10562,"id":213905,"goal":"lemma SetInterComm_10562(U: set, B: set)\n ensures U * B == B * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_10563","instance":10563,"id":213906,"goal":"lemma SetUnionAssoc_10563(B: set, A: set, U: set)\n ensures (B + A) + U == B + (A + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_10564","instance":10564,"id":213907,"goal":"lemma SetSubsetRefl_10564(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_10565","instance":10565,"id":213908,"goal":"lemma SetSubsetTrans_10565(U: set, S: set, A: set)\n requires U <= S && S <= A\n ensures U <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_10566","instance":10566,"id":213909,"goal":"lemma SetUnionEmpty_10566(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_10567","instance":10567,"id":213910,"goal":"lemma SetInterEmpty_10567(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_10568","instance":10568,"id":213911,"goal":"lemma SetInterSubset_10568(U: set, T: set)\n ensures U * T <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_10569","instance":10569,"id":213912,"goal":"lemma SetCardSubset_10569(A: set, U: set)\n requires A <= U\n ensures |A| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_10570","instance":10570,"id":213913,"goal":"lemma SetUnionCard_10570(S: set, U: set)\n requires S * U == {}\n ensures |S + U| == |S| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_10571","instance":10571,"id":213914,"goal":"lemma SetUnionComm_10571(U: set, A: set)\n ensures U + A == A + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_10572","instance":10572,"id":213915,"goal":"lemma SetInterComm_10572(T: set, B: set)\n ensures T * B == B * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_10573","instance":10573,"id":213916,"goal":"lemma SetUnionAssoc_10573(A: set, S: set, T: set)\n ensures (A + S) + T == A + (S + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_10574","instance":10574,"id":213917,"goal":"lemma SetSubsetRefl_10574(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_10575","instance":10575,"id":213918,"goal":"lemma SetSubsetTrans_10575(T: set, A: set, S: set)\n requires T <= A && A <= S\n ensures T <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_10576","instance":10576,"id":213919,"goal":"lemma SetUnionEmpty_10576(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_10577","instance":10577,"id":213920,"goal":"lemma SetInterEmpty_10577(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_10578","instance":10578,"id":213921,"goal":"lemma SetInterSubset_10578(T: set, B: set)\n ensures T * B <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_10579","instance":10579,"id":213922,"goal":"lemma SetCardSubset_10579(T: set, S: set)\n requires T <= S\n ensures |T| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_10580","instance":10580,"id":213923,"goal":"lemma SetUnionCard_10580(T: set, A: set)\n requires T * A == {}\n ensures |T + A| == |T| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_10581","instance":10581,"id":213924,"goal":"lemma SetUnionComm_10581(S: set, T: set)\n ensures S + T == T + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_10582","instance":10582,"id":213925,"goal":"lemma SetInterComm_10582(A: set, T: set)\n ensures A * T == T * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_10583","instance":10583,"id":213926,"goal":"lemma SetUnionAssoc_10583(U: set, B: set, A: set)\n ensures (U + B) + A == U + (B + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_10584","instance":10584,"id":213927,"goal":"lemma SetSubsetRefl_10584(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_10585","instance":10585,"id":213928,"goal":"lemma SetSubsetTrans_10585(T: set, A: set, S: set)\n requires T <= A && A <= S\n ensures T <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_10586","instance":10586,"id":213929,"goal":"lemma SetUnionEmpty_10586(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_10587","instance":10587,"id":213930,"goal":"lemma SetInterEmpty_10587(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_10588","instance":10588,"id":213931,"goal":"lemma SetInterSubset_10588(U: set, T: set)\n ensures U * T <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_10589","instance":10589,"id":213932,"goal":"lemma SetCardSubset_10589(A: set, T: set)\n requires A <= T\n ensures |A| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_10590","instance":10590,"id":213933,"goal":"lemma SetUnionCard_10590(A: set, T: set)\n requires A * T == {}\n ensures |A + T| == |A| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_10591","instance":10591,"id":213934,"goal":"lemma SetUnionComm_10591(U: set, A: set)\n ensures U + A == A + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_10592","instance":10592,"id":213935,"goal":"lemma SetInterComm_10592(S: set, B: set)\n ensures S * B == B * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_10593","instance":10593,"id":213936,"goal":"lemma SetUnionAssoc_10593(U: set, T: set, S: set)\n ensures (U + T) + S == U + (T + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_10594","instance":10594,"id":213937,"goal":"lemma SetSubsetRefl_10594(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_10595","instance":10595,"id":213938,"goal":"lemma SetSubsetTrans_10595(S: set, T: set, U: set)\n requires S <= T && T <= U\n ensures S <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_10596","instance":10596,"id":213939,"goal":"lemma SetUnionEmpty_10596(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_10597","instance":10597,"id":213940,"goal":"lemma SetInterEmpty_10597(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_10598","instance":10598,"id":213941,"goal":"lemma SetInterSubset_10598(U: set, A: set)\n ensures U * A <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_10599","instance":10599,"id":213942,"goal":"lemma SetCardSubset_10599(U: set, S: set)\n requires U <= S\n ensures |U| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_10600","instance":10600,"id":213943,"goal":"lemma SetUnionCard_10600(T: set, U: set)\n requires T * U == {}\n ensures |T + U| == |T| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_10601","instance":10601,"id":213944,"goal":"lemma SetUnionComm_10601(B: set, T: set)\n ensures B + T == T + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_10602","instance":10602,"id":213945,"goal":"lemma SetInterComm_10602(S: set, A: set)\n ensures S * A == A * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_10603","instance":10603,"id":213946,"goal":"lemma SetUnionAssoc_10603(S: set, B: set, T: set)\n ensures (S + B) + T == S + (B + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_10604","instance":10604,"id":213947,"goal":"lemma SetSubsetRefl_10604(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_10605","instance":10605,"id":213948,"goal":"lemma SetSubsetTrans_10605(B: set, T: set, S: set)\n requires B <= T && T <= S\n ensures B <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_10606","instance":10606,"id":213949,"goal":"lemma SetUnionEmpty_10606(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_10607","instance":10607,"id":213950,"goal":"lemma SetInterEmpty_10607(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_10608","instance":10608,"id":213951,"goal":"lemma SetInterSubset_10608(A: set, S: set)\n ensures A * S <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_10609","instance":10609,"id":213952,"goal":"lemma SetCardSubset_10609(S: set, B: set)\n requires S <= B\n ensures |S| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_10610","instance":10610,"id":213953,"goal":"lemma SetUnionCard_10610(A: set, B: set)\n requires A * B == {}\n ensures |A + B| == |A| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_10611","instance":10611,"id":213954,"goal":"lemma SetUnionComm_10611(S: set, U: set)\n ensures S + U == U + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_10612","instance":10612,"id":213955,"goal":"lemma SetInterComm_10612(A: set, U: set)\n ensures A * U == U * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_10613","instance":10613,"id":213956,"goal":"lemma SetUnionAssoc_10613(U: set, B: set, T: set)\n ensures (U + B) + T == U + (B + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_10614","instance":10614,"id":213957,"goal":"lemma SetSubsetRefl_10614(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_10615","instance":10615,"id":213958,"goal":"lemma SetSubsetTrans_10615(U: set, T: set, A: set)\n requires U <= T && T <= A\n ensures U <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_10616","instance":10616,"id":213959,"goal":"lemma SetUnionEmpty_10616(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_10617","instance":10617,"id":213960,"goal":"lemma SetInterEmpty_10617(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_10618","instance":10618,"id":213961,"goal":"lemma SetInterSubset_10618(S: set, T: set)\n ensures S * T <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_10619","instance":10619,"id":213962,"goal":"lemma SetCardSubset_10619(A: set, U: set)\n requires A <= U\n ensures |A| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_10620","instance":10620,"id":213963,"goal":"lemma SetUnionCard_10620(T: set, B: set)\n requires T * B == {}\n ensures |T + B| == |T| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_10621","instance":10621,"id":213964,"goal":"lemma SetUnionComm_10621(U: set, T: set)\n ensures U + T == T + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_10622","instance":10622,"id":213965,"goal":"lemma SetInterComm_10622(T: set, U: set)\n ensures T * U == U * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_10623","instance":10623,"id":213966,"goal":"lemma SetUnionAssoc_10623(A: set, T: set, S: set)\n ensures (A + T) + S == A + (T + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_10624","instance":10624,"id":213967,"goal":"lemma SetSubsetRefl_10624(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_10625","instance":10625,"id":213968,"goal":"lemma SetSubsetTrans_10625(S: set, U: set, T: set)\n requires S <= U && U <= T\n ensures S <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_10626","instance":10626,"id":213969,"goal":"lemma SetUnionEmpty_10626(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_10627","instance":10627,"id":213970,"goal":"lemma SetInterEmpty_10627(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_10628","instance":10628,"id":213971,"goal":"lemma SetInterSubset_10628(S: set, B: set)\n ensures S * B <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_10629","instance":10629,"id":213972,"goal":"lemma SetCardSubset_10629(A: set, B: set)\n requires A <= B\n ensures |A| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_10630","instance":10630,"id":213973,"goal":"lemma SetUnionCard_10630(A: set, T: set)\n requires A * T == {}\n ensures |A + T| == |A| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_10631","instance":10631,"id":213974,"goal":"lemma SetUnionComm_10631(T: set, B: set)\n ensures T + B == B + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_10632","instance":10632,"id":213975,"goal":"lemma SetInterComm_10632(S: set, U: set)\n ensures S * U == U * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_10633","instance":10633,"id":213976,"goal":"lemma SetUnionAssoc_10633(S: set, T: set, B: set)\n ensures (S + T) + B == S + (T + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_10634","instance":10634,"id":213977,"goal":"lemma SetSubsetRefl_10634(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_10635","instance":10635,"id":213978,"goal":"lemma SetSubsetTrans_10635(B: set, A: set, S: set)\n requires B <= A && A <= S\n ensures B <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_10636","instance":10636,"id":213979,"goal":"lemma SetUnionEmpty_10636(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_10637","instance":10637,"id":213980,"goal":"lemma SetInterEmpty_10637(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_10638","instance":10638,"id":213981,"goal":"lemma SetInterSubset_10638(U: set, A: set)\n ensures U * A <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_10639","instance":10639,"id":213982,"goal":"lemma SetCardSubset_10639(U: set, A: set)\n requires U <= A\n ensures |U| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_10640","instance":10640,"id":213983,"goal":"lemma SetUnionCard_10640(B: set, U: set)\n requires B * U == {}\n ensures |B + U| == |B| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_10641","instance":10641,"id":213984,"goal":"lemma SetUnionComm_10641(U: set, A: set)\n ensures U + A == A + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_10642","instance":10642,"id":213985,"goal":"lemma SetInterComm_10642(S: set, U: set)\n ensures S * U == U * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_10643","instance":10643,"id":213986,"goal":"lemma SetUnionAssoc_10643(U: set, A: set, T: set)\n ensures (U + A) + T == U + (A + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_10644","instance":10644,"id":213987,"goal":"lemma SetSubsetRefl_10644(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_10645","instance":10645,"id":213988,"goal":"lemma SetSubsetTrans_10645(T: set, S: set, U: set)\n requires T <= S && S <= U\n ensures T <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_10646","instance":10646,"id":213989,"goal":"lemma SetUnionEmpty_10646(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_10647","instance":10647,"id":213990,"goal":"lemma SetInterEmpty_10647(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_10648","instance":10648,"id":213991,"goal":"lemma SetInterSubset_10648(S: set, T: set)\n ensures S * T <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_10649","instance":10649,"id":213992,"goal":"lemma SetCardSubset_10649(A: set, U: set)\n requires A <= U\n ensures |A| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_10650","instance":10650,"id":213993,"goal":"lemma SetUnionCard_10650(A: set, U: set)\n requires A * U == {}\n ensures |A + U| == |A| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_10651","instance":10651,"id":213994,"goal":"lemma SetUnionComm_10651(S: set, U: set)\n ensures S + U == U + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_10652","instance":10652,"id":213995,"goal":"lemma SetInterComm_10652(B: set, U: set)\n ensures B * U == U * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_10653","instance":10653,"id":213996,"goal":"lemma SetUnionAssoc_10653(B: set, U: set, T: set)\n ensures (B + U) + T == B + (U + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_10654","instance":10654,"id":213997,"goal":"lemma SetSubsetRefl_10654(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_10655","instance":10655,"id":213998,"goal":"lemma SetSubsetTrans_10655(T: set, A: set, B: set)\n requires T <= A && A <= B\n ensures T <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_10656","instance":10656,"id":213999,"goal":"lemma SetUnionEmpty_10656(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_10657","instance":10657,"id":214000,"goal":"lemma SetInterEmpty_10657(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_10658","instance":10658,"id":214001,"goal":"lemma SetInterSubset_10658(B: set, U: set)\n ensures B * U <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_10659","instance":10659,"id":214002,"goal":"lemma SetCardSubset_10659(B: set, T: set)\n requires B <= T\n ensures |B| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_10660","instance":10660,"id":214003,"goal":"lemma SetUnionCard_10660(U: set, S: set)\n requires U * S == {}\n ensures |U + S| == |U| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_10661","instance":10661,"id":214004,"goal":"lemma SetUnionComm_10661(A: set, T: set)\n ensures A + T == T + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_10662","instance":10662,"id":214005,"goal":"lemma SetInterComm_10662(T: set, U: set)\n ensures T * U == U * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_10663","instance":10663,"id":214006,"goal":"lemma SetUnionAssoc_10663(U: set, S: set, B: set)\n ensures (U + S) + B == U + (S + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_10664","instance":10664,"id":214007,"goal":"lemma SetSubsetRefl_10664(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_10665","instance":10665,"id":214008,"goal":"lemma SetSubsetTrans_10665(S: set, T: set, U: set)\n requires S <= T && T <= U\n ensures S <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_10666","instance":10666,"id":214009,"goal":"lemma SetUnionEmpty_10666(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_10667","instance":10667,"id":214010,"goal":"lemma SetInterEmpty_10667(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_10668","instance":10668,"id":214011,"goal":"lemma SetInterSubset_10668(A: set, B: set)\n ensures A * B <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_10669","instance":10669,"id":214012,"goal":"lemma SetCardSubset_10669(B: set, U: set)\n requires B <= U\n ensures |B| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_10670","instance":10670,"id":214013,"goal":"lemma SetUnionCard_10670(S: set, U: set)\n requires S * U == {}\n ensures |S + U| == |S| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_10671","instance":10671,"id":214014,"goal":"lemma SetUnionComm_10671(S: set, A: set)\n ensures S + A == A + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_10672","instance":10672,"id":214015,"goal":"lemma SetInterComm_10672(B: set, T: set)\n ensures B * T == T * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_10673","instance":10673,"id":214016,"goal":"lemma SetUnionAssoc_10673(A: set, B: set, T: set)\n ensures (A + B) + T == A + (B + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_10674","instance":10674,"id":214017,"goal":"lemma SetSubsetRefl_10674(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_10675","instance":10675,"id":214018,"goal":"lemma SetSubsetTrans_10675(A: set, U: set, S: set)\n requires A <= U && U <= S\n ensures A <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_10676","instance":10676,"id":214019,"goal":"lemma SetUnionEmpty_10676(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_10677","instance":10677,"id":214020,"goal":"lemma SetInterEmpty_10677(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_10678","instance":10678,"id":214021,"goal":"lemma SetInterSubset_10678(A: set, B: set)\n ensures A * B <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_10679","instance":10679,"id":214022,"goal":"lemma SetCardSubset_10679(T: set, A: set)\n requires T <= A\n ensures |T| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_10680","instance":10680,"id":214023,"goal":"lemma SetUnionCard_10680(U: set, S: set)\n requires U * S == {}\n ensures |U + S| == |U| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_10681","instance":10681,"id":214024,"goal":"lemma SetUnionComm_10681(T: set, U: set)\n ensures T + U == U + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_10682","instance":10682,"id":214025,"goal":"lemma SetInterComm_10682(T: set, B: set)\n ensures T * B == B * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_10683","instance":10683,"id":214026,"goal":"lemma SetUnionAssoc_10683(U: set, S: set, B: set)\n ensures (U + S) + B == U + (S + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_10684","instance":10684,"id":214027,"goal":"lemma SetSubsetRefl_10684(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_10685","instance":10685,"id":214028,"goal":"lemma SetSubsetTrans_10685(T: set, S: set, A: set)\n requires T <= S && S <= A\n ensures T <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_10686","instance":10686,"id":214029,"goal":"lemma SetUnionEmpty_10686(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_10687","instance":10687,"id":214030,"goal":"lemma SetInterEmpty_10687(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_10688","instance":10688,"id":214031,"goal":"lemma SetInterSubset_10688(S: set, U: set)\n ensures S * U <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_10689","instance":10689,"id":214032,"goal":"lemma SetCardSubset_10689(U: set, B: set)\n requires U <= B\n ensures |U| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_10690","instance":10690,"id":214033,"goal":"lemma SetUnionCard_10690(S: set, U: set)\n requires S * U == {}\n ensures |S + U| == |S| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_10691","instance":10691,"id":214034,"goal":"lemma SetUnionComm_10691(S: set, T: set)\n ensures S + T == T + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_10692","instance":10692,"id":214035,"goal":"lemma SetInterComm_10692(U: set, A: set)\n ensures U * A == A * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_10693","instance":10693,"id":214036,"goal":"lemma SetUnionAssoc_10693(U: set, A: set, T: set)\n ensures (U + A) + T == U + (A + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_10694","instance":10694,"id":214037,"goal":"lemma SetSubsetRefl_10694(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_10695","instance":10695,"id":214038,"goal":"lemma SetSubsetTrans_10695(U: set, B: set, T: set)\n requires U <= B && B <= T\n ensures U <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_10696","instance":10696,"id":214039,"goal":"lemma SetUnionEmpty_10696(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_10697","instance":10697,"id":214040,"goal":"lemma SetInterEmpty_10697(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_10698","instance":10698,"id":214041,"goal":"lemma SetInterSubset_10698(S: set, A: set)\n ensures S * A <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_10699","instance":10699,"id":214042,"goal":"lemma SetCardSubset_10699(A: set, U: set)\n requires A <= U\n ensures |A| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_10700","instance":10700,"id":214043,"goal":"lemma SetUnionCard_10700(A: set, S: set)\n requires A * S == {}\n ensures |A + S| == |A| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_10701","instance":10701,"id":214044,"goal":"lemma SetUnionComm_10701(B: set, T: set)\n ensures B + T == T + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_10702","instance":10702,"id":214045,"goal":"lemma SetInterComm_10702(U: set, B: set)\n ensures U * B == B * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_10703","instance":10703,"id":214046,"goal":"lemma SetUnionAssoc_10703(T: set, A: set, S: set)\n ensures (T + A) + S == T + (A + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_10704","instance":10704,"id":214047,"goal":"lemma SetSubsetRefl_10704(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_10705","instance":10705,"id":214048,"goal":"lemma SetSubsetTrans_10705(T: set, B: set, A: set)\n requires T <= B && B <= A\n ensures T <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_10706","instance":10706,"id":214049,"goal":"lemma SetUnionEmpty_10706(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_10707","instance":10707,"id":214050,"goal":"lemma SetInterEmpty_10707(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_10708","instance":10708,"id":214051,"goal":"lemma SetInterSubset_10708(T: set, S: set)\n ensures T * S <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_10709","instance":10709,"id":214052,"goal":"lemma SetCardSubset_10709(U: set, B: set)\n requires U <= B\n ensures |U| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_10710","instance":10710,"id":214053,"goal":"lemma SetUnionCard_10710(B: set, U: set)\n requires B * U == {}\n ensures |B + U| == |B| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_10711","instance":10711,"id":214054,"goal":"lemma SetUnionComm_10711(U: set, A: set)\n ensures U + A == A + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_10712","instance":10712,"id":214055,"goal":"lemma SetInterComm_10712(B: set, U: set)\n ensures B * U == U * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_10713","instance":10713,"id":214056,"goal":"lemma SetUnionAssoc_10713(S: set, U: set, A: set)\n ensures (S + U) + A == S + (U + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_10714","instance":10714,"id":214057,"goal":"lemma SetSubsetRefl_10714(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_10715","instance":10715,"id":214058,"goal":"lemma SetSubsetTrans_10715(U: set, T: set, S: set)\n requires U <= T && T <= S\n ensures U <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_10716","instance":10716,"id":214059,"goal":"lemma SetUnionEmpty_10716(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_10717","instance":10717,"id":214060,"goal":"lemma SetInterEmpty_10717(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_10718","instance":10718,"id":214061,"goal":"lemma SetInterSubset_10718(A: set, B: set)\n ensures A * B <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_10719","instance":10719,"id":214062,"goal":"lemma SetCardSubset_10719(B: set, U: set)\n requires B <= U\n ensures |B| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_10720","instance":10720,"id":214063,"goal":"lemma SetUnionCard_10720(S: set, U: set)\n requires S * U == {}\n ensures |S + U| == |S| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_10721","instance":10721,"id":214064,"goal":"lemma SetUnionComm_10721(B: set, T: set)\n ensures B + T == T + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_10722","instance":10722,"id":214065,"goal":"lemma SetInterComm_10722(S: set, B: set)\n ensures S * B == B * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_10723","instance":10723,"id":214066,"goal":"lemma SetUnionAssoc_10723(S: set, U: set, B: set)\n ensures (S + U) + B == S + (U + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_10724","instance":10724,"id":214067,"goal":"lemma SetSubsetRefl_10724(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_10725","instance":10725,"id":214068,"goal":"lemma SetSubsetTrans_10725(A: set, S: set, B: set)\n requires A <= S && S <= B\n ensures A <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_10726","instance":10726,"id":214069,"goal":"lemma SetUnionEmpty_10726(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_10727","instance":10727,"id":214070,"goal":"lemma SetInterEmpty_10727(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_10728","instance":10728,"id":214071,"goal":"lemma SetInterSubset_10728(U: set, S: set)\n ensures U * S <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_10729","instance":10729,"id":214072,"goal":"lemma SetCardSubset_10729(T: set, U: set)\n requires T <= U\n ensures |T| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_10730","instance":10730,"id":214073,"goal":"lemma SetUnionCard_10730(A: set, U: set)\n requires A * U == {}\n ensures |A + U| == |A| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_10731","instance":10731,"id":214074,"goal":"lemma SetUnionComm_10731(T: set, B: set)\n ensures T + B == B + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_10732","instance":10732,"id":214075,"goal":"lemma SetInterComm_10732(T: set, U: set)\n ensures T * U == U * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_10733","instance":10733,"id":214076,"goal":"lemma SetUnionAssoc_10733(A: set, U: set, B: set)\n ensures (A + U) + B == A + (U + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_10734","instance":10734,"id":214077,"goal":"lemma SetSubsetRefl_10734(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_10735","instance":10735,"id":214078,"goal":"lemma SetSubsetTrans_10735(A: set, U: set, S: set)\n requires A <= U && U <= S\n ensures A <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_10736","instance":10736,"id":214079,"goal":"lemma SetUnionEmpty_10736(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_10737","instance":10737,"id":214080,"goal":"lemma SetInterEmpty_10737(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_10738","instance":10738,"id":214081,"goal":"lemma SetInterSubset_10738(B: set, S: set)\n ensures B * S <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_10739","instance":10739,"id":214082,"goal":"lemma SetCardSubset_10739(S: set, T: set)\n requires S <= T\n ensures |S| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_10740","instance":10740,"id":214083,"goal":"lemma SetUnionCard_10740(T: set, U: set)\n requires T * U == {}\n ensures |T + U| == |T| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_10741","instance":10741,"id":214084,"goal":"lemma SetUnionComm_10741(S: set, U: set)\n ensures S + U == U + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_10742","instance":10742,"id":214085,"goal":"lemma SetInterComm_10742(S: set, A: set)\n ensures S * A == A * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_10743","instance":10743,"id":214086,"goal":"lemma SetUnionAssoc_10743(B: set, A: set, T: set)\n ensures (B + A) + T == B + (A + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_10744","instance":10744,"id":214087,"goal":"lemma SetSubsetRefl_10744(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_10745","instance":10745,"id":214088,"goal":"lemma SetSubsetTrans_10745(S: set, U: set, B: set)\n requires S <= U && U <= B\n ensures S <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_10746","instance":10746,"id":214089,"goal":"lemma SetUnionEmpty_10746(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_10747","instance":10747,"id":214090,"goal":"lemma SetInterEmpty_10747(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_10748","instance":10748,"id":214091,"goal":"lemma SetInterSubset_10748(A: set, S: set)\n ensures A * S <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_10749","instance":10749,"id":214092,"goal":"lemma SetCardSubset_10749(S: set, A: set)\n requires S <= A\n ensures |S| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_10750","instance":10750,"id":214093,"goal":"lemma SetUnionCard_10750(U: set, T: set)\n requires U * T == {}\n ensures |U + T| == |U| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_10751","instance":10751,"id":214094,"goal":"lemma SetUnionComm_10751(A: set, S: set)\n ensures A + S == S + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_10752","instance":10752,"id":214095,"goal":"lemma SetInterComm_10752(T: set, U: set)\n ensures T * U == U * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_10753","instance":10753,"id":214096,"goal":"lemma SetUnionAssoc_10753(T: set, U: set, S: set)\n ensures (T + U) + S == T + (U + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_10754","instance":10754,"id":214097,"goal":"lemma SetSubsetRefl_10754(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_10755","instance":10755,"id":214098,"goal":"lemma SetSubsetTrans_10755(U: set, A: set, B: set)\n requires U <= A && A <= B\n ensures U <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_10756","instance":10756,"id":214099,"goal":"lemma SetUnionEmpty_10756(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_10757","instance":10757,"id":214100,"goal":"lemma SetInterEmpty_10757(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_10758","instance":10758,"id":214101,"goal":"lemma SetInterSubset_10758(U: set, B: set)\n ensures U * B <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_10759","instance":10759,"id":214102,"goal":"lemma SetCardSubset_10759(B: set, U: set)\n requires B <= U\n ensures |B| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_10760","instance":10760,"id":214103,"goal":"lemma SetUnionCard_10760(A: set, U: set)\n requires A * U == {}\n ensures |A + U| == |A| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_10761","instance":10761,"id":214104,"goal":"lemma SetUnionComm_10761(A: set, U: set)\n ensures A + U == U + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_10762","instance":10762,"id":214105,"goal":"lemma SetInterComm_10762(T: set, B: set)\n ensures T * B == B * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_10763","instance":10763,"id":214106,"goal":"lemma SetUnionAssoc_10763(B: set, S: set, A: set)\n ensures (B + S) + A == B + (S + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_10764","instance":10764,"id":214107,"goal":"lemma SetSubsetRefl_10764(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_10765","instance":10765,"id":214108,"goal":"lemma SetSubsetTrans_10765(S: set, B: set, T: set)\n requires S <= B && B <= T\n ensures S <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_10766","instance":10766,"id":214109,"goal":"lemma SetUnionEmpty_10766(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_10767","instance":10767,"id":214110,"goal":"lemma SetInterEmpty_10767(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_10768","instance":10768,"id":214111,"goal":"lemma SetInterSubset_10768(S: set, A: set)\n ensures S * A <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_10769","instance":10769,"id":214112,"goal":"lemma SetCardSubset_10769(T: set, A: set)\n requires T <= A\n ensures |T| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_10770","instance":10770,"id":214113,"goal":"lemma SetUnionCard_10770(T: set, S: set)\n requires T * S == {}\n ensures |T + S| == |T| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_10771","instance":10771,"id":214114,"goal":"lemma SetUnionComm_10771(B: set, S: set)\n ensures B + S == S + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_10772","instance":10772,"id":214115,"goal":"lemma SetInterComm_10772(U: set, T: set)\n ensures U * T == T * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_10773","instance":10773,"id":214116,"goal":"lemma SetUnionAssoc_10773(S: set, U: set, A: set)\n ensures (S + U) + A == S + (U + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_10774","instance":10774,"id":214117,"goal":"lemma SetSubsetRefl_10774(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_10775","instance":10775,"id":214118,"goal":"lemma SetSubsetTrans_10775(S: set, U: set, T: set)\n requires S <= U && U <= T\n ensures S <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_10776","instance":10776,"id":214119,"goal":"lemma SetUnionEmpty_10776(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_10777","instance":10777,"id":214120,"goal":"lemma SetInterEmpty_10777(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_10778","instance":10778,"id":214121,"goal":"lemma SetInterSubset_10778(A: set, B: set)\n ensures A * B <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_10779","instance":10779,"id":214122,"goal":"lemma SetCardSubset_10779(U: set, S: set)\n requires U <= S\n ensures |U| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_10780","instance":10780,"id":214123,"goal":"lemma SetUnionCard_10780(S: set, B: set)\n requires S * B == {}\n ensures |S + B| == |S| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_10781","instance":10781,"id":214124,"goal":"lemma SetUnionComm_10781(A: set, B: set)\n ensures A + B == B + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_10782","instance":10782,"id":214125,"goal":"lemma SetInterComm_10782(T: set, S: set)\n ensures T * S == S * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_10783","instance":10783,"id":214126,"goal":"lemma SetUnionAssoc_10783(S: set, U: set, T: set)\n ensures (S + U) + T == S + (U + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_10784","instance":10784,"id":214127,"goal":"lemma SetSubsetRefl_10784(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_10785","instance":10785,"id":214128,"goal":"lemma SetSubsetTrans_10785(T: set, B: set, U: set)\n requires T <= B && B <= U\n ensures T <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_10786","instance":10786,"id":214129,"goal":"lemma SetUnionEmpty_10786(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_10787","instance":10787,"id":214130,"goal":"lemma SetInterEmpty_10787(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_10788","instance":10788,"id":214131,"goal":"lemma SetInterSubset_10788(T: set, S: set)\n ensures T * S <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_10789","instance":10789,"id":214132,"goal":"lemma SetCardSubset_10789(A: set, S: set)\n requires A <= S\n ensures |A| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_10790","instance":10790,"id":214133,"goal":"lemma SetUnionCard_10790(B: set, T: set)\n requires B * T == {}\n ensures |B + T| == |B| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_10791","instance":10791,"id":214134,"goal":"lemma SetUnionComm_10791(S: set, B: set)\n ensures S + B == B + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_10792","instance":10792,"id":214135,"goal":"lemma SetInterComm_10792(S: set, A: set)\n ensures S * A == A * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_10793","instance":10793,"id":214136,"goal":"lemma SetUnionAssoc_10793(B: set, S: set, U: set)\n ensures (B + S) + U == B + (S + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_10794","instance":10794,"id":214137,"goal":"lemma SetSubsetRefl_10794(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_10795","instance":10795,"id":214138,"goal":"lemma SetSubsetTrans_10795(S: set, U: set, T: set)\n requires S <= U && U <= T\n ensures S <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_10796","instance":10796,"id":214139,"goal":"lemma SetUnionEmpty_10796(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_10797","instance":10797,"id":214140,"goal":"lemma SetInterEmpty_10797(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_10798","instance":10798,"id":214141,"goal":"lemma SetInterSubset_10798(S: set, T: set)\n ensures S * T <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_10799","instance":10799,"id":214142,"goal":"lemma SetCardSubset_10799(T: set, U: set)\n requires T <= U\n ensures |T| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_10800","instance":10800,"id":214143,"goal":"lemma SetUnionCard_10800(U: set, A: set)\n requires U * A == {}\n ensures |U + A| == |U| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_10801","instance":10801,"id":214144,"goal":"lemma SetUnionComm_10801(U: set, B: set)\n ensures U + B == B + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_10802","instance":10802,"id":214145,"goal":"lemma SetInterComm_10802(U: set, S: set)\n ensures U * S == S * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_10803","instance":10803,"id":214146,"goal":"lemma SetUnionAssoc_10803(T: set, A: set, S: set)\n ensures (T + A) + S == T + (A + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_10804","instance":10804,"id":214147,"goal":"lemma SetSubsetRefl_10804(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_10805","instance":10805,"id":214148,"goal":"lemma SetSubsetTrans_10805(S: set, A: set, U: set)\n requires S <= A && A <= U\n ensures S <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_10806","instance":10806,"id":214149,"goal":"lemma SetUnionEmpty_10806(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_10807","instance":10807,"id":214150,"goal":"lemma SetInterEmpty_10807(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_10808","instance":10808,"id":214151,"goal":"lemma SetInterSubset_10808(A: set, T: set)\n ensures A * T <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_10809","instance":10809,"id":214152,"goal":"lemma SetCardSubset_10809(S: set, T: set)\n requires S <= T\n ensures |S| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_10810","instance":10810,"id":214153,"goal":"lemma SetUnionCard_10810(A: set, U: set)\n requires A * U == {}\n ensures |A + U| == |A| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_10811","instance":10811,"id":214154,"goal":"lemma SetUnionComm_10811(U: set, T: set)\n ensures U + T == T + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_10812","instance":10812,"id":214155,"goal":"lemma SetInterComm_10812(S: set, B: set)\n ensures S * B == B * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_10813","instance":10813,"id":214156,"goal":"lemma SetUnionAssoc_10813(A: set, B: set, U: set)\n ensures (A + B) + U == A + (B + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_10814","instance":10814,"id":214157,"goal":"lemma SetSubsetRefl_10814(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_10815","instance":10815,"id":214158,"goal":"lemma SetSubsetTrans_10815(S: set, U: set, A: set)\n requires S <= U && U <= A\n ensures S <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_10816","instance":10816,"id":214159,"goal":"lemma SetUnionEmpty_10816(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_10817","instance":10817,"id":214160,"goal":"lemma SetInterEmpty_10817(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_10818","instance":10818,"id":214161,"goal":"lemma SetInterSubset_10818(A: set, T: set)\n ensures A * T <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_10819","instance":10819,"id":214162,"goal":"lemma SetCardSubset_10819(A: set, S: set)\n requires A <= S\n ensures |A| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_10820","instance":10820,"id":214163,"goal":"lemma SetUnionCard_10820(U: set, A: set)\n requires U * A == {}\n ensures |U + A| == |U| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_10821","instance":10821,"id":214164,"goal":"lemma SetUnionComm_10821(S: set, A: set)\n ensures S + A == A + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_10822","instance":10822,"id":214165,"goal":"lemma SetInterComm_10822(A: set, S: set)\n ensures A * S == S * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_10823","instance":10823,"id":214166,"goal":"lemma SetUnionAssoc_10823(B: set, T: set, A: set)\n ensures (B + T) + A == B + (T + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_10824","instance":10824,"id":214167,"goal":"lemma SetSubsetRefl_10824(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_10825","instance":10825,"id":214168,"goal":"lemma SetSubsetTrans_10825(U: set, B: set, S: set)\n requires U <= B && B <= S\n ensures U <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_10826","instance":10826,"id":214169,"goal":"lemma SetUnionEmpty_10826(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_10827","instance":10827,"id":214170,"goal":"lemma SetInterEmpty_10827(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_10828","instance":10828,"id":214171,"goal":"lemma SetInterSubset_10828(S: set, B: set)\n ensures S * B <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_10829","instance":10829,"id":214172,"goal":"lemma SetCardSubset_10829(U: set, A: set)\n requires U <= A\n ensures |U| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_10830","instance":10830,"id":214173,"goal":"lemma SetUnionCard_10830(U: set, A: set)\n requires U * A == {}\n ensures |U + A| == |U| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_10831","instance":10831,"id":214174,"goal":"lemma SetUnionComm_10831(T: set, S: set)\n ensures T + S == S + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_10832","instance":10832,"id":214175,"goal":"lemma SetInterComm_10832(T: set, U: set)\n ensures T * U == U * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_10833","instance":10833,"id":214176,"goal":"lemma SetUnionAssoc_10833(U: set, S: set, B: set)\n ensures (U + S) + B == U + (S + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_10834","instance":10834,"id":214177,"goal":"lemma SetSubsetRefl_10834(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_10835","instance":10835,"id":214178,"goal":"lemma SetSubsetTrans_10835(B: set, S: set, U: set)\n requires B <= S && S <= U\n ensures B <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_10836","instance":10836,"id":214179,"goal":"lemma SetUnionEmpty_10836(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_10837","instance":10837,"id":214180,"goal":"lemma SetInterEmpty_10837(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_10838","instance":10838,"id":214181,"goal":"lemma SetInterSubset_10838(B: set, A: set)\n ensures B * A <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_10839","instance":10839,"id":214182,"goal":"lemma SetCardSubset_10839(U: set, B: set)\n requires U <= B\n ensures |U| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_10840","instance":10840,"id":214183,"goal":"lemma SetUnionCard_10840(S: set, A: set)\n requires S * A == {}\n ensures |S + A| == |S| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_10841","instance":10841,"id":214184,"goal":"lemma SetUnionComm_10841(U: set, A: set)\n ensures U + A == A + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_10842","instance":10842,"id":214185,"goal":"lemma SetInterComm_10842(T: set, U: set)\n ensures T * U == U * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_10843","instance":10843,"id":214186,"goal":"lemma SetUnionAssoc_10843(U: set, S: set, T: set)\n ensures (U + S) + T == U + (S + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_10844","instance":10844,"id":214187,"goal":"lemma SetSubsetRefl_10844(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_10845","instance":10845,"id":214188,"goal":"lemma SetSubsetTrans_10845(S: set, U: set, B: set)\n requires S <= U && U <= B\n ensures S <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_10846","instance":10846,"id":214189,"goal":"lemma SetUnionEmpty_10846(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_10847","instance":10847,"id":214190,"goal":"lemma SetInterEmpty_10847(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_10848","instance":10848,"id":214191,"goal":"lemma SetInterSubset_10848(B: set, T: set)\n ensures B * T <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_10849","instance":10849,"id":214192,"goal":"lemma SetCardSubset_10849(S: set, T: set)\n requires S <= T\n ensures |S| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_10850","instance":10850,"id":214193,"goal":"lemma SetUnionCard_10850(A: set, U: set)\n requires A * U == {}\n ensures |A + U| == |A| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_10851","instance":10851,"id":214194,"goal":"lemma SetUnionComm_10851(A: set, B: set)\n ensures A + B == B + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_10852","instance":10852,"id":214195,"goal":"lemma SetInterComm_10852(B: set, U: set)\n ensures B * U == U * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_10853","instance":10853,"id":214196,"goal":"lemma SetUnionAssoc_10853(T: set, U: set, B: set)\n ensures (T + U) + B == T + (U + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_10854","instance":10854,"id":214197,"goal":"lemma SetSubsetRefl_10854(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_10855","instance":10855,"id":214198,"goal":"lemma SetSubsetTrans_10855(A: set, U: set, S: set)\n requires A <= U && U <= S\n ensures A <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_10856","instance":10856,"id":214199,"goal":"lemma SetUnionEmpty_10856(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_10857","instance":10857,"id":214200,"goal":"lemma SetInterEmpty_10857(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_10858","instance":10858,"id":214201,"goal":"lemma SetInterSubset_10858(S: set, T: set)\n ensures S * T <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_10859","instance":10859,"id":214202,"goal":"lemma SetCardSubset_10859(S: set, B: set)\n requires S <= B\n ensures |S| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_10860","instance":10860,"id":214203,"goal":"lemma SetUnionCard_10860(B: set, U: set)\n requires B * U == {}\n ensures |B + U| == |B| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_10861","instance":10861,"id":214204,"goal":"lemma SetUnionComm_10861(T: set, B: set)\n ensures T + B == B + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_10862","instance":10862,"id":214205,"goal":"lemma SetInterComm_10862(A: set, B: set)\n ensures A * B == B * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_10863","instance":10863,"id":214206,"goal":"lemma SetUnionAssoc_10863(T: set, S: set, U: set)\n ensures (T + S) + U == T + (S + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_10864","instance":10864,"id":214207,"goal":"lemma SetSubsetRefl_10864(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_10865","instance":10865,"id":214208,"goal":"lemma SetSubsetTrans_10865(U: set, A: set, T: set)\n requires U <= A && A <= T\n ensures U <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_10866","instance":10866,"id":214209,"goal":"lemma SetUnionEmpty_10866(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_10867","instance":10867,"id":214210,"goal":"lemma SetInterEmpty_10867(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_10868","instance":10868,"id":214211,"goal":"lemma SetInterSubset_10868(A: set, S: set)\n ensures A * S <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_10869","instance":10869,"id":214212,"goal":"lemma SetCardSubset_10869(B: set, A: set)\n requires B <= A\n ensures |B| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_10870","instance":10870,"id":214213,"goal":"lemma SetUnionCard_10870(B: set, T: set)\n requires B * T == {}\n ensures |B + T| == |B| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_10871","instance":10871,"id":214214,"goal":"lemma SetUnionComm_10871(B: set, T: set)\n ensures B + T == T + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_10872","instance":10872,"id":214215,"goal":"lemma SetInterComm_10872(B: set, A: set)\n ensures B * A == A * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_10873","instance":10873,"id":214216,"goal":"lemma SetUnionAssoc_10873(S: set, U: set, T: set)\n ensures (S + U) + T == S + (U + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_10874","instance":10874,"id":214217,"goal":"lemma SetSubsetRefl_10874(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_10875","instance":10875,"id":214218,"goal":"lemma SetSubsetTrans_10875(U: set, A: set, B: set)\n requires U <= A && A <= B\n ensures U <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_10876","instance":10876,"id":214219,"goal":"lemma SetUnionEmpty_10876(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_10877","instance":10877,"id":214220,"goal":"lemma SetInterEmpty_10877(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_10878","instance":10878,"id":214221,"goal":"lemma SetInterSubset_10878(U: set, A: set)\n ensures U * A <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_10879","instance":10879,"id":214222,"goal":"lemma SetCardSubset_10879(B: set, U: set)\n requires B <= U\n ensures |B| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_10880","instance":10880,"id":214223,"goal":"lemma SetUnionCard_10880(U: set, S: set)\n requires U * S == {}\n ensures |U + S| == |U| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_10881","instance":10881,"id":214224,"goal":"lemma SetUnionComm_10881(T: set, U: set)\n ensures T + U == U + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_10882","instance":10882,"id":214225,"goal":"lemma SetInterComm_10882(B: set, S: set)\n ensures B * S == S * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_10883","instance":10883,"id":214226,"goal":"lemma SetUnionAssoc_10883(S: set, T: set, B: set)\n ensures (S + T) + B == S + (T + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_10884","instance":10884,"id":214227,"goal":"lemma SetSubsetRefl_10884(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_10885","instance":10885,"id":214228,"goal":"lemma SetSubsetTrans_10885(T: set, U: set, A: set)\n requires T <= U && U <= A\n ensures T <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_10886","instance":10886,"id":214229,"goal":"lemma SetUnionEmpty_10886(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_10887","instance":10887,"id":214230,"goal":"lemma SetInterEmpty_10887(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_10888","instance":10888,"id":214231,"goal":"lemma SetInterSubset_10888(T: set, A: set)\n ensures T * A <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_10889","instance":10889,"id":214232,"goal":"lemma SetCardSubset_10889(A: set, U: set)\n requires A <= U\n ensures |A| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_10890","instance":10890,"id":214233,"goal":"lemma SetUnionCard_10890(A: set, T: set)\n requires A * T == {}\n ensures |A + T| == |A| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_10891","instance":10891,"id":214234,"goal":"lemma SetUnionComm_10891(U: set, T: set)\n ensures U + T == T + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_10892","instance":10892,"id":214235,"goal":"lemma SetInterComm_10892(B: set, S: set)\n ensures B * S == S * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_10893","instance":10893,"id":214236,"goal":"lemma SetUnionAssoc_10893(A: set, B: set, T: set)\n ensures (A + B) + T == A + (B + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_10894","instance":10894,"id":214237,"goal":"lemma SetSubsetRefl_10894(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_10895","instance":10895,"id":214238,"goal":"lemma SetSubsetTrans_10895(T: set, A: set, S: set)\n requires T <= A && A <= S\n ensures T <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_10896","instance":10896,"id":214239,"goal":"lemma SetUnionEmpty_10896(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_10897","instance":10897,"id":214240,"goal":"lemma SetInterEmpty_10897(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_10898","instance":10898,"id":214241,"goal":"lemma SetInterSubset_10898(A: set, B: set)\n ensures A * B <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_10899","instance":10899,"id":214242,"goal":"lemma SetCardSubset_10899(B: set, A: set)\n requires B <= A\n ensures |B| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_10900","instance":10900,"id":214243,"goal":"lemma SetUnionCard_10900(S: set, T: set)\n requires S * T == {}\n ensures |S + T| == |S| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_10901","instance":10901,"id":214244,"goal":"lemma SetUnionComm_10901(A: set, U: set)\n ensures A + U == U + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_10902","instance":10902,"id":214245,"goal":"lemma SetInterComm_10902(U: set, T: set)\n ensures U * T == T * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_10903","instance":10903,"id":214246,"goal":"lemma SetUnionAssoc_10903(B: set, U: set, T: set)\n ensures (B + U) + T == B + (U + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_10904","instance":10904,"id":214247,"goal":"lemma SetSubsetRefl_10904(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_10905","instance":10905,"id":214248,"goal":"lemma SetSubsetTrans_10905(B: set, A: set, T: set)\n requires B <= A && A <= T\n ensures B <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_10906","instance":10906,"id":214249,"goal":"lemma SetUnionEmpty_10906(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_10907","instance":10907,"id":214250,"goal":"lemma SetInterEmpty_10907(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_10908","instance":10908,"id":214251,"goal":"lemma SetInterSubset_10908(B: set, U: set)\n ensures B * U <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_10909","instance":10909,"id":214252,"goal":"lemma SetCardSubset_10909(B: set, T: set)\n requires B <= T\n ensures |B| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_10910","instance":10910,"id":214253,"goal":"lemma SetUnionCard_10910(B: set, S: set)\n requires B * S == {}\n ensures |B + S| == |B| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_10911","instance":10911,"id":214254,"goal":"lemma SetUnionComm_10911(T: set, B: set)\n ensures T + B == B + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_10912","instance":10912,"id":214255,"goal":"lemma SetInterComm_10912(A: set, B: set)\n ensures A * B == B * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_10913","instance":10913,"id":214256,"goal":"lemma SetUnionAssoc_10913(U: set, A: set, B: set)\n ensures (U + A) + B == U + (A + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_10914","instance":10914,"id":214257,"goal":"lemma SetSubsetRefl_10914(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_10915","instance":10915,"id":214258,"goal":"lemma SetSubsetTrans_10915(B: set, U: set, T: set)\n requires B <= U && U <= T\n ensures B <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_10916","instance":10916,"id":214259,"goal":"lemma SetUnionEmpty_10916(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_10917","instance":10917,"id":214260,"goal":"lemma SetInterEmpty_10917(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_10918","instance":10918,"id":214261,"goal":"lemma SetInterSubset_10918(A: set, S: set)\n ensures A * S <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_10919","instance":10919,"id":214262,"goal":"lemma SetCardSubset_10919(S: set, T: set)\n requires S <= T\n ensures |S| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_10920","instance":10920,"id":214263,"goal":"lemma SetUnionCard_10920(T: set, U: set)\n requires T * U == {}\n ensures |T + U| == |T| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_10921","instance":10921,"id":214264,"goal":"lemma SetUnionComm_10921(A: set, B: set)\n ensures A + B == B + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_10922","instance":10922,"id":214265,"goal":"lemma SetInterComm_10922(A: set, U: set)\n ensures A * U == U * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_10923","instance":10923,"id":214266,"goal":"lemma SetUnionAssoc_10923(A: set, B: set, S: set)\n ensures (A + B) + S == A + (B + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_10924","instance":10924,"id":214267,"goal":"lemma SetSubsetRefl_10924(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_10925","instance":10925,"id":214268,"goal":"lemma SetSubsetTrans_10925(B: set, T: set, S: set)\n requires B <= T && T <= S\n ensures B <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_10926","instance":10926,"id":214269,"goal":"lemma SetUnionEmpty_10926(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_10927","instance":10927,"id":214270,"goal":"lemma SetInterEmpty_10927(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_10928","instance":10928,"id":214271,"goal":"lemma SetInterSubset_10928(A: set, B: set)\n ensures A * B <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_10929","instance":10929,"id":214272,"goal":"lemma SetCardSubset_10929(B: set, U: set)\n requires B <= U\n ensures |B| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_10930","instance":10930,"id":214273,"goal":"lemma SetUnionCard_10930(B: set, S: set)\n requires B * S == {}\n ensures |B + S| == |B| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_10931","instance":10931,"id":214274,"goal":"lemma SetUnionComm_10931(T: set, S: set)\n ensures T + S == S + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_10932","instance":10932,"id":214275,"goal":"lemma SetInterComm_10932(T: set, B: set)\n ensures T * B == B * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_10933","instance":10933,"id":214276,"goal":"lemma SetUnionAssoc_10933(U: set, B: set, S: set)\n ensures (U + B) + S == U + (B + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_10934","instance":10934,"id":214277,"goal":"lemma SetSubsetRefl_10934(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_10935","instance":10935,"id":214278,"goal":"lemma SetSubsetTrans_10935(A: set, S: set, T: set)\n requires A <= S && S <= T\n ensures A <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_10936","instance":10936,"id":214279,"goal":"lemma SetUnionEmpty_10936(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_10937","instance":10937,"id":214280,"goal":"lemma SetInterEmpty_10937(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_10938","instance":10938,"id":214281,"goal":"lemma SetInterSubset_10938(T: set, S: set)\n ensures T * S <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_10939","instance":10939,"id":214282,"goal":"lemma SetCardSubset_10939(B: set, T: set)\n requires B <= T\n ensures |B| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_10940","instance":10940,"id":214283,"goal":"lemma SetUnionCard_10940(B: set, T: set)\n requires B * T == {}\n ensures |B + T| == |B| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_10941","instance":10941,"id":214284,"goal":"lemma SetUnionComm_10941(S: set, U: set)\n ensures S + U == U + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_10942","instance":10942,"id":214285,"goal":"lemma SetInterComm_10942(U: set, A: set)\n ensures U * A == A * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_10943","instance":10943,"id":214286,"goal":"lemma SetUnionAssoc_10943(T: set, U: set, B: set)\n ensures (T + U) + B == T + (U + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_10944","instance":10944,"id":214287,"goal":"lemma SetSubsetRefl_10944(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_10945","instance":10945,"id":214288,"goal":"lemma SetSubsetTrans_10945(B: set, A: set, U: set)\n requires B <= A && A <= U\n ensures B <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_10946","instance":10946,"id":214289,"goal":"lemma SetUnionEmpty_10946(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_10947","instance":10947,"id":214290,"goal":"lemma SetInterEmpty_10947(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_10948","instance":10948,"id":214291,"goal":"lemma SetInterSubset_10948(A: set, T: set)\n ensures A * T <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_10949","instance":10949,"id":214292,"goal":"lemma SetCardSubset_10949(T: set, S: set)\n requires T <= S\n ensures |T| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_10950","instance":10950,"id":214293,"goal":"lemma SetUnionCard_10950(U: set, A: set)\n requires U * A == {}\n ensures |U + A| == |U| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_10951","instance":10951,"id":214294,"goal":"lemma SetUnionComm_10951(S: set, T: set)\n ensures S + T == T + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_10952","instance":10952,"id":214295,"goal":"lemma SetInterComm_10952(B: set, A: set)\n ensures B * A == A * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_10953","instance":10953,"id":214296,"goal":"lemma SetUnionAssoc_10953(A: set, B: set, T: set)\n ensures (A + B) + T == A + (B + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_10954","instance":10954,"id":214297,"goal":"lemma SetSubsetRefl_10954(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_10955","instance":10955,"id":214298,"goal":"lemma SetSubsetTrans_10955(A: set, B: set, U: set)\n requires A <= B && B <= U\n ensures A <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_10956","instance":10956,"id":214299,"goal":"lemma SetUnionEmpty_10956(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_10957","instance":10957,"id":214300,"goal":"lemma SetInterEmpty_10957(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_10958","instance":10958,"id":214301,"goal":"lemma SetInterSubset_10958(S: set, B: set)\n ensures S * B <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_10959","instance":10959,"id":214302,"goal":"lemma SetCardSubset_10959(A: set, U: set)\n requires A <= U\n ensures |A| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_10960","instance":10960,"id":214303,"goal":"lemma SetUnionCard_10960(S: set, U: set)\n requires S * U == {}\n ensures |S + U| == |S| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_10961","instance":10961,"id":214304,"goal":"lemma SetUnionComm_10961(B: set, S: set)\n ensures B + S == S + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_10962","instance":10962,"id":214305,"goal":"lemma SetInterComm_10962(S: set, A: set)\n ensures S * A == A * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_10963","instance":10963,"id":214306,"goal":"lemma SetUnionAssoc_10963(S: set, A: set, T: set)\n ensures (S + A) + T == S + (A + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_10964","instance":10964,"id":214307,"goal":"lemma SetSubsetRefl_10964(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_10965","instance":10965,"id":214308,"goal":"lemma SetSubsetTrans_10965(A: set, U: set, T: set)\n requires A <= U && U <= T\n ensures A <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_10966","instance":10966,"id":214309,"goal":"lemma SetUnionEmpty_10966(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_10967","instance":10967,"id":214310,"goal":"lemma SetInterEmpty_10967(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_10968","instance":10968,"id":214311,"goal":"lemma SetInterSubset_10968(T: set, U: set)\n ensures T * U <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_10969","instance":10969,"id":214312,"goal":"lemma SetCardSubset_10969(U: set, S: set)\n requires U <= S\n ensures |U| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_10970","instance":10970,"id":214313,"goal":"lemma SetUnionCard_10970(U: set, T: set)\n requires U * T == {}\n ensures |U + T| == |U| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_10971","instance":10971,"id":214314,"goal":"lemma SetUnionComm_10971(S: set, T: set)\n ensures S + T == T + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_10972","instance":10972,"id":214315,"goal":"lemma SetInterComm_10972(B: set, A: set)\n ensures B * A == A * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_10973","instance":10973,"id":214316,"goal":"lemma SetUnionAssoc_10973(S: set, A: set, U: set)\n ensures (S + A) + U == S + (A + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_10974","instance":10974,"id":214317,"goal":"lemma SetSubsetRefl_10974(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_10975","instance":10975,"id":214318,"goal":"lemma SetSubsetTrans_10975(S: set, B: set, T: set)\n requires S <= B && B <= T\n ensures S <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_10976","instance":10976,"id":214319,"goal":"lemma SetUnionEmpty_10976(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_10977","instance":10977,"id":214320,"goal":"lemma SetInterEmpty_10977(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_10978","instance":10978,"id":214321,"goal":"lemma SetInterSubset_10978(U: set, A: set)\n ensures U * A <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_10979","instance":10979,"id":214322,"goal":"lemma SetCardSubset_10979(T: set, S: set)\n requires T <= S\n ensures |T| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_10980","instance":10980,"id":214323,"goal":"lemma SetUnionCard_10980(U: set, T: set)\n requires U * T == {}\n ensures |U + T| == |U| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_10981","instance":10981,"id":214324,"goal":"lemma SetUnionComm_10981(U: set, T: set)\n ensures U + T == T + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_10982","instance":10982,"id":214325,"goal":"lemma SetInterComm_10982(A: set, S: set)\n ensures A * S == S * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_10983","instance":10983,"id":214326,"goal":"lemma SetUnionAssoc_10983(A: set, U: set, T: set)\n ensures (A + U) + T == A + (U + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_10984","instance":10984,"id":214327,"goal":"lemma SetSubsetRefl_10984(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_10985","instance":10985,"id":214328,"goal":"lemma SetSubsetTrans_10985(B: set, T: set, U: set)\n requires B <= T && T <= U\n ensures B <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_10986","instance":10986,"id":214329,"goal":"lemma SetUnionEmpty_10986(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_10987","instance":10987,"id":214330,"goal":"lemma SetInterEmpty_10987(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_10988","instance":10988,"id":214331,"goal":"lemma SetInterSubset_10988(A: set, T: set)\n ensures A * T <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_10989","instance":10989,"id":214332,"goal":"lemma SetCardSubset_10989(U: set, S: set)\n requires U <= S\n ensures |U| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_10990","instance":10990,"id":214333,"goal":"lemma SetUnionCard_10990(B: set, T: set)\n requires B * T == {}\n ensures |B + T| == |B| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_10991","instance":10991,"id":214334,"goal":"lemma SetUnionComm_10991(A: set, T: set)\n ensures A + T == T + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_10992","instance":10992,"id":214335,"goal":"lemma SetInterComm_10992(A: set, S: set)\n ensures A * S == S * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_10993","instance":10993,"id":214336,"goal":"lemma SetUnionAssoc_10993(T: set, S: set, A: set)\n ensures (T + S) + A == T + (S + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_10994","instance":10994,"id":214337,"goal":"lemma SetSubsetRefl_10994(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_10995","instance":10995,"id":214338,"goal":"lemma SetSubsetTrans_10995(B: set, S: set, T: set)\n requires B <= S && S <= T\n ensures B <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_10996","instance":10996,"id":214339,"goal":"lemma SetUnionEmpty_10996(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_10997","instance":10997,"id":214340,"goal":"lemma SetInterEmpty_10997(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_10998","instance":10998,"id":214341,"goal":"lemma SetInterSubset_10998(S: set, U: set)\n ensures S * U <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_10999","instance":10999,"id":214342,"goal":"lemma SetCardSubset_10999(A: set, S: set)\n requires A <= S\n ensures |A| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_11000","instance":11000,"id":214343,"goal":"lemma SetUnionCard_11000(B: set, S: set)\n requires B * S == {}\n ensures |B + S| == |B| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_11001","instance":11001,"id":214344,"goal":"lemma SetUnionComm_11001(A: set, U: set)\n ensures A + U == U + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_11002","instance":11002,"id":214345,"goal":"lemma SetInterComm_11002(U: set, T: set)\n ensures U * T == T * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_11003","instance":11003,"id":214346,"goal":"lemma SetUnionAssoc_11003(T: set, U: set, A: set)\n ensures (T + U) + A == T + (U + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_11004","instance":11004,"id":214347,"goal":"lemma SetSubsetRefl_11004(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_11005","instance":11005,"id":214348,"goal":"lemma SetSubsetTrans_11005(S: set, B: set, A: set)\n requires S <= B && B <= A\n ensures S <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_11006","instance":11006,"id":214349,"goal":"lemma SetUnionEmpty_11006(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_11007","instance":11007,"id":214350,"goal":"lemma SetInterEmpty_11007(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_11008","instance":11008,"id":214351,"goal":"lemma SetInterSubset_11008(T: set, S: set)\n ensures T * S <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_11009","instance":11009,"id":214352,"goal":"lemma SetCardSubset_11009(U: set, S: set)\n requires U <= S\n ensures |U| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_11010","instance":11010,"id":214353,"goal":"lemma SetUnionCard_11010(B: set, S: set)\n requires B * S == {}\n ensures |B + S| == |B| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_11011","instance":11011,"id":214354,"goal":"lemma SetUnionComm_11011(B: set, U: set)\n ensures B + U == U + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_11012","instance":11012,"id":214355,"goal":"lemma SetInterComm_11012(A: set, U: set)\n ensures A * U == U * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_11013","instance":11013,"id":214356,"goal":"lemma SetUnionAssoc_11013(S: set, A: set, U: set)\n ensures (S + A) + U == S + (A + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_11014","instance":11014,"id":214357,"goal":"lemma SetSubsetRefl_11014(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_11015","instance":11015,"id":214358,"goal":"lemma SetSubsetTrans_11015(T: set, A: set, U: set)\n requires T <= A && A <= U\n ensures T <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_11016","instance":11016,"id":214359,"goal":"lemma SetUnionEmpty_11016(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_11017","instance":11017,"id":214360,"goal":"lemma SetInterEmpty_11017(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_11018","instance":11018,"id":214361,"goal":"lemma SetInterSubset_11018(B: set, A: set)\n ensures B * A <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_11019","instance":11019,"id":214362,"goal":"lemma SetCardSubset_11019(S: set, A: set)\n requires S <= A\n ensures |S| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_11020","instance":11020,"id":214363,"goal":"lemma SetUnionCard_11020(S: set, U: set)\n requires S * U == {}\n ensures |S + U| == |S| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_11021","instance":11021,"id":214364,"goal":"lemma SetUnionComm_11021(S: set, A: set)\n ensures S + A == A + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_11022","instance":11022,"id":214365,"goal":"lemma SetInterComm_11022(S: set, A: set)\n ensures S * A == A * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_11023","instance":11023,"id":214366,"goal":"lemma SetUnionAssoc_11023(B: set, A: set, U: set)\n ensures (B + A) + U == B + (A + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_11024","instance":11024,"id":214367,"goal":"lemma SetSubsetRefl_11024(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_11025","instance":11025,"id":214368,"goal":"lemma SetSubsetTrans_11025(S: set, U: set, B: set)\n requires S <= U && U <= B\n ensures S <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_11026","instance":11026,"id":214369,"goal":"lemma SetUnionEmpty_11026(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_11027","instance":11027,"id":214370,"goal":"lemma SetInterEmpty_11027(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_11028","instance":11028,"id":214371,"goal":"lemma SetInterSubset_11028(U: set, A: set)\n ensures U * A <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_11029","instance":11029,"id":214372,"goal":"lemma SetCardSubset_11029(S: set, U: set)\n requires S <= U\n ensures |S| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_11030","instance":11030,"id":214373,"goal":"lemma SetUnionCard_11030(A: set, T: set)\n requires A * T == {}\n ensures |A + T| == |A| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_11031","instance":11031,"id":214374,"goal":"lemma SetUnionComm_11031(U: set, S: set)\n ensures U + S == S + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_11032","instance":11032,"id":214375,"goal":"lemma SetInterComm_11032(U: set, S: set)\n ensures U * S == S * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_11033","instance":11033,"id":214376,"goal":"lemma SetUnionAssoc_11033(T: set, S: set, U: set)\n ensures (T + S) + U == T + (S + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_11034","instance":11034,"id":214377,"goal":"lemma SetSubsetRefl_11034(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_11035","instance":11035,"id":214378,"goal":"lemma SetSubsetTrans_11035(A: set, U: set, S: set)\n requires A <= U && U <= S\n ensures A <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_11036","instance":11036,"id":214379,"goal":"lemma SetUnionEmpty_11036(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_11037","instance":11037,"id":214380,"goal":"lemma SetInterEmpty_11037(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_11038","instance":11038,"id":214381,"goal":"lemma SetInterSubset_11038(S: set, U: set)\n ensures S * U <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_11039","instance":11039,"id":214382,"goal":"lemma SetCardSubset_11039(U: set, S: set)\n requires U <= S\n ensures |U| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_11040","instance":11040,"id":214383,"goal":"lemma SetUnionCard_11040(S: set, U: set)\n requires S * U == {}\n ensures |S + U| == |S| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_11041","instance":11041,"id":214384,"goal":"lemma SetUnionComm_11041(U: set, B: set)\n ensures U + B == B + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_11042","instance":11042,"id":214385,"goal":"lemma SetInterComm_11042(B: set, T: set)\n ensures B * T == T * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_11043","instance":11043,"id":214386,"goal":"lemma SetUnionAssoc_11043(S: set, T: set, B: set)\n ensures (S + T) + B == S + (T + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_11044","instance":11044,"id":214387,"goal":"lemma SetSubsetRefl_11044(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_11045","instance":11045,"id":214388,"goal":"lemma SetSubsetTrans_11045(U: set, S: set, A: set)\n requires U <= S && S <= A\n ensures U <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_11046","instance":11046,"id":214389,"goal":"lemma SetUnionEmpty_11046(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_11047","instance":11047,"id":214390,"goal":"lemma SetInterEmpty_11047(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_11048","instance":11048,"id":214391,"goal":"lemma SetInterSubset_11048(U: set, B: set)\n ensures U * B <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_11049","instance":11049,"id":214392,"goal":"lemma SetCardSubset_11049(B: set, U: set)\n requires B <= U\n ensures |B| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_11050","instance":11050,"id":214393,"goal":"lemma SetUnionCard_11050(B: set, U: set)\n requires B * U == {}\n ensures |B + U| == |B| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_11051","instance":11051,"id":214394,"goal":"lemma SetUnionComm_11051(T: set, U: set)\n ensures T + U == U + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_11052","instance":11052,"id":214395,"goal":"lemma SetInterComm_11052(A: set, S: set)\n ensures A * S == S * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_11053","instance":11053,"id":214396,"goal":"lemma SetUnionAssoc_11053(B: set, U: set, S: set)\n ensures (B + U) + S == B + (U + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_11054","instance":11054,"id":214397,"goal":"lemma SetSubsetRefl_11054(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_11055","instance":11055,"id":214398,"goal":"lemma SetSubsetTrans_11055(A: set, U: set, B: set)\n requires A <= U && U <= B\n ensures A <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_11056","instance":11056,"id":214399,"goal":"lemma SetUnionEmpty_11056(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_11057","instance":11057,"id":214400,"goal":"lemma SetInterEmpty_11057(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_11058","instance":11058,"id":214401,"goal":"lemma SetInterSubset_11058(A: set, S: set)\n ensures A * S <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_11059","instance":11059,"id":214402,"goal":"lemma SetCardSubset_11059(T: set, S: set)\n requires T <= S\n ensures |T| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_11060","instance":11060,"id":214403,"goal":"lemma SetUnionCard_11060(S: set, T: set)\n requires S * T == {}\n ensures |S + T| == |S| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_11061","instance":11061,"id":214404,"goal":"lemma SetUnionComm_11061(U: set, S: set)\n ensures U + S == S + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_11062","instance":11062,"id":214405,"goal":"lemma SetInterComm_11062(B: set, A: set)\n ensures B * A == A * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_11063","instance":11063,"id":214406,"goal":"lemma SetUnionAssoc_11063(S: set, U: set, T: set)\n ensures (S + U) + T == S + (U + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_11064","instance":11064,"id":214407,"goal":"lemma SetSubsetRefl_11064(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_11065","instance":11065,"id":214408,"goal":"lemma SetSubsetTrans_11065(T: set, B: set, U: set)\n requires T <= B && B <= U\n ensures T <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_11066","instance":11066,"id":214409,"goal":"lemma SetUnionEmpty_11066(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_11067","instance":11067,"id":214410,"goal":"lemma SetInterEmpty_11067(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_11068","instance":11068,"id":214411,"goal":"lemma SetInterSubset_11068(A: set, B: set)\n ensures A * B <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_11069","instance":11069,"id":214412,"goal":"lemma SetCardSubset_11069(A: set, T: set)\n requires A <= T\n ensures |A| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_11070","instance":11070,"id":214413,"goal":"lemma SetUnionCard_11070(T: set, S: set)\n requires T * S == {}\n ensures |T + S| == |T| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_11071","instance":11071,"id":214414,"goal":"lemma SetUnionComm_11071(U: set, S: set)\n ensures U + S == S + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_11072","instance":11072,"id":214415,"goal":"lemma SetInterComm_11072(B: set, U: set)\n ensures B * U == U * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_11073","instance":11073,"id":214416,"goal":"lemma SetUnionAssoc_11073(T: set, B: set, U: set)\n ensures (T + B) + U == T + (B + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_11074","instance":11074,"id":214417,"goal":"lemma SetSubsetRefl_11074(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_11075","instance":11075,"id":214418,"goal":"lemma SetSubsetTrans_11075(T: set, S: set, U: set)\n requires T <= S && S <= U\n ensures T <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_11076","instance":11076,"id":214419,"goal":"lemma SetUnionEmpty_11076(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_11077","instance":11077,"id":214420,"goal":"lemma SetInterEmpty_11077(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_11078","instance":11078,"id":214421,"goal":"lemma SetInterSubset_11078(B: set, T: set)\n ensures B * T <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_11079","instance":11079,"id":214422,"goal":"lemma SetCardSubset_11079(S: set, U: set)\n requires S <= U\n ensures |S| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_11080","instance":11080,"id":214423,"goal":"lemma SetUnionCard_11080(U: set, T: set)\n requires U * T == {}\n ensures |U + T| == |U| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_11081","instance":11081,"id":214424,"goal":"lemma SetUnionComm_11081(T: set, A: set)\n ensures T + A == A + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_11082","instance":11082,"id":214425,"goal":"lemma SetInterComm_11082(B: set, U: set)\n ensures B * U == U * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_11083","instance":11083,"id":214426,"goal":"lemma SetUnionAssoc_11083(S: set, A: set, T: set)\n ensures (S + A) + T == S + (A + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_11084","instance":11084,"id":214427,"goal":"lemma SetSubsetRefl_11084(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_11085","instance":11085,"id":214428,"goal":"lemma SetSubsetTrans_11085(U: set, B: set, S: set)\n requires U <= B && B <= S\n ensures U <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_11086","instance":11086,"id":214429,"goal":"lemma SetUnionEmpty_11086(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_11087","instance":11087,"id":214430,"goal":"lemma SetInterEmpty_11087(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_11088","instance":11088,"id":214431,"goal":"lemma SetInterSubset_11088(S: set, U: set)\n ensures S * U <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_11089","instance":11089,"id":214432,"goal":"lemma SetCardSubset_11089(S: set, B: set)\n requires S <= B\n ensures |S| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_11090","instance":11090,"id":214433,"goal":"lemma SetUnionCard_11090(S: set, A: set)\n requires S * A == {}\n ensures |S + A| == |S| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_11091","instance":11091,"id":214434,"goal":"lemma SetUnionComm_11091(T: set, B: set)\n ensures T + B == B + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_11092","instance":11092,"id":214435,"goal":"lemma SetInterComm_11092(S: set, B: set)\n ensures S * B == B * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_11093","instance":11093,"id":214436,"goal":"lemma SetUnionAssoc_11093(S: set, T: set, U: set)\n ensures (S + T) + U == S + (T + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_11094","instance":11094,"id":214437,"goal":"lemma SetSubsetRefl_11094(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_11095","instance":11095,"id":214438,"goal":"lemma SetSubsetTrans_11095(A: set, U: set, B: set)\n requires A <= U && U <= B\n ensures A <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_11096","instance":11096,"id":214439,"goal":"lemma SetUnionEmpty_11096(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_11097","instance":11097,"id":214440,"goal":"lemma SetInterEmpty_11097(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_11098","instance":11098,"id":214441,"goal":"lemma SetInterSubset_11098(S: set, A: set)\n ensures S * A <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_11099","instance":11099,"id":214442,"goal":"lemma SetCardSubset_11099(S: set, B: set)\n requires S <= B\n ensures |S| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_11100","instance":11100,"id":214443,"goal":"lemma SetUnionCard_11100(A: set, S: set)\n requires A * S == {}\n ensures |A + S| == |A| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_11101","instance":11101,"id":214444,"goal":"lemma SetUnionComm_11101(S: set, U: set)\n ensures S + U == U + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_11102","instance":11102,"id":214445,"goal":"lemma SetInterComm_11102(S: set, T: set)\n ensures S * T == T * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_11103","instance":11103,"id":214446,"goal":"lemma SetUnionAssoc_11103(T: set, S: set, B: set)\n ensures (T + S) + B == T + (S + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_11104","instance":11104,"id":214447,"goal":"lemma SetSubsetRefl_11104(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_11105","instance":11105,"id":214448,"goal":"lemma SetSubsetTrans_11105(T: set, U: set, S: set)\n requires T <= U && U <= S\n ensures T <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_11106","instance":11106,"id":214449,"goal":"lemma SetUnionEmpty_11106(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_11107","instance":11107,"id":214450,"goal":"lemma SetInterEmpty_11107(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_11108","instance":11108,"id":214451,"goal":"lemma SetInterSubset_11108(U: set, T: set)\n ensures U * T <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_11109","instance":11109,"id":214452,"goal":"lemma SetCardSubset_11109(T: set, S: set)\n requires T <= S\n ensures |T| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_11110","instance":11110,"id":214453,"goal":"lemma SetUnionCard_11110(A: set, T: set)\n requires A * T == {}\n ensures |A + T| == |A| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_11111","instance":11111,"id":214454,"goal":"lemma SetUnionComm_11111(T: set, A: set)\n ensures T + A == A + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_11112","instance":11112,"id":214455,"goal":"lemma SetInterComm_11112(U: set, S: set)\n ensures U * S == S * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_11113","instance":11113,"id":214456,"goal":"lemma SetUnionAssoc_11113(T: set, B: set, A: set)\n ensures (T + B) + A == T + (B + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_11114","instance":11114,"id":214457,"goal":"lemma SetSubsetRefl_11114(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_11115","instance":11115,"id":214458,"goal":"lemma SetSubsetTrans_11115(S: set, B: set, T: set)\n requires S <= B && B <= T\n ensures S <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_11116","instance":11116,"id":214459,"goal":"lemma SetUnionEmpty_11116(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_11117","instance":11117,"id":214460,"goal":"lemma SetInterEmpty_11117(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_11118","instance":11118,"id":214461,"goal":"lemma SetInterSubset_11118(T: set, S: set)\n ensures T * S <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_11119","instance":11119,"id":214462,"goal":"lemma SetCardSubset_11119(B: set, A: set)\n requires B <= A\n ensures |B| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_11120","instance":11120,"id":214463,"goal":"lemma SetUnionCard_11120(U: set, T: set)\n requires U * T == {}\n ensures |U + T| == |U| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_11121","instance":11121,"id":214464,"goal":"lemma SetUnionComm_11121(A: set, T: set)\n ensures A + T == T + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_11122","instance":11122,"id":214465,"goal":"lemma SetInterComm_11122(T: set, A: set)\n ensures T * A == A * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_11123","instance":11123,"id":214466,"goal":"lemma SetUnionAssoc_11123(B: set, S: set, U: set)\n ensures (B + S) + U == B + (S + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_11124","instance":11124,"id":214467,"goal":"lemma SetSubsetRefl_11124(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_11125","instance":11125,"id":214468,"goal":"lemma SetSubsetTrans_11125(B: set, S: set, U: set)\n requires B <= S && S <= U\n ensures B <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_11126","instance":11126,"id":214469,"goal":"lemma SetUnionEmpty_11126(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_11127","instance":11127,"id":214470,"goal":"lemma SetInterEmpty_11127(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_11128","instance":11128,"id":214471,"goal":"lemma SetInterSubset_11128(U: set, T: set)\n ensures U * T <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_11129","instance":11129,"id":214472,"goal":"lemma SetCardSubset_11129(B: set, A: set)\n requires B <= A\n ensures |B| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_11130","instance":11130,"id":214473,"goal":"lemma SetUnionCard_11130(U: set, S: set)\n requires U * S == {}\n ensures |U + S| == |U| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_11131","instance":11131,"id":214474,"goal":"lemma SetUnionComm_11131(B: set, S: set)\n ensures B + S == S + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_11132","instance":11132,"id":214475,"goal":"lemma SetInterComm_11132(T: set, B: set)\n ensures T * B == B * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_11133","instance":11133,"id":214476,"goal":"lemma SetUnionAssoc_11133(A: set, U: set, B: set)\n ensures (A + U) + B == A + (U + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_11134","instance":11134,"id":214477,"goal":"lemma SetSubsetRefl_11134(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_11135","instance":11135,"id":214478,"goal":"lemma SetSubsetTrans_11135(S: set, U: set, A: set)\n requires S <= U && U <= A\n ensures S <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_11136","instance":11136,"id":214479,"goal":"lemma SetUnionEmpty_11136(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_11137","instance":11137,"id":214480,"goal":"lemma SetInterEmpty_11137(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_11138","instance":11138,"id":214481,"goal":"lemma SetInterSubset_11138(S: set, T: set)\n ensures S * T <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_11139","instance":11139,"id":214482,"goal":"lemma SetCardSubset_11139(A: set, U: set)\n requires A <= U\n ensures |A| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_11140","instance":11140,"id":214483,"goal":"lemma SetUnionCard_11140(B: set, S: set)\n requires B * S == {}\n ensures |B + S| == |B| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_11141","instance":11141,"id":214484,"goal":"lemma SetUnionComm_11141(U: set, B: set)\n ensures U + B == B + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_11142","instance":11142,"id":214485,"goal":"lemma SetInterComm_11142(A: set, B: set)\n ensures A * B == B * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_11143","instance":11143,"id":214486,"goal":"lemma SetUnionAssoc_11143(A: set, U: set, T: set)\n ensures (A + U) + T == A + (U + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_11144","instance":11144,"id":214487,"goal":"lemma SetSubsetRefl_11144(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_11145","instance":11145,"id":214488,"goal":"lemma SetSubsetTrans_11145(B: set, A: set, T: set)\n requires B <= A && A <= T\n ensures B <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_11146","instance":11146,"id":214489,"goal":"lemma SetUnionEmpty_11146(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_11147","instance":11147,"id":214490,"goal":"lemma SetInterEmpty_11147(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_11148","instance":11148,"id":214491,"goal":"lemma SetInterSubset_11148(A: set, S: set)\n ensures A * S <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_11149","instance":11149,"id":214492,"goal":"lemma SetCardSubset_11149(S: set, A: set)\n requires S <= A\n ensures |S| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_11150","instance":11150,"id":214493,"goal":"lemma SetUnionCard_11150(B: set, S: set)\n requires B * S == {}\n ensures |B + S| == |B| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_11151","instance":11151,"id":214494,"goal":"lemma SetUnionComm_11151(A: set, S: set)\n ensures A + S == S + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_11152","instance":11152,"id":214495,"goal":"lemma SetInterComm_11152(S: set, A: set)\n ensures S * A == A * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_11153","instance":11153,"id":214496,"goal":"lemma SetUnionAssoc_11153(U: set, T: set, S: set)\n ensures (U + T) + S == U + (T + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_11154","instance":11154,"id":214497,"goal":"lemma SetSubsetRefl_11154(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_11155","instance":11155,"id":214498,"goal":"lemma SetSubsetTrans_11155(S: set, A: set, T: set)\n requires S <= A && A <= T\n ensures S <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_11156","instance":11156,"id":214499,"goal":"lemma SetUnionEmpty_11156(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_11157","instance":11157,"id":214500,"goal":"lemma SetInterEmpty_11157(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_11158","instance":11158,"id":214501,"goal":"lemma SetInterSubset_11158(T: set, A: set)\n ensures T * A <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_11159","instance":11159,"id":214502,"goal":"lemma SetCardSubset_11159(U: set, S: set)\n requires U <= S\n ensures |U| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_11160","instance":11160,"id":214503,"goal":"lemma SetUnionCard_11160(B: set, T: set)\n requires B * T == {}\n ensures |B + T| == |B| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_11161","instance":11161,"id":214504,"goal":"lemma SetUnionComm_11161(B: set, U: set)\n ensures B + U == U + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_11162","instance":11162,"id":214505,"goal":"lemma SetInterComm_11162(U: set, S: set)\n ensures U * S == S * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_11163","instance":11163,"id":214506,"goal":"lemma SetUnionAssoc_11163(T: set, A: set, S: set)\n ensures (T + A) + S == T + (A + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_11164","instance":11164,"id":214507,"goal":"lemma SetSubsetRefl_11164(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_11165","instance":11165,"id":214508,"goal":"lemma SetSubsetTrans_11165(S: set, U: set, B: set)\n requires S <= U && U <= B\n ensures S <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_11166","instance":11166,"id":214509,"goal":"lemma SetUnionEmpty_11166(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_11167","instance":11167,"id":214510,"goal":"lemma SetInterEmpty_11167(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_11168","instance":11168,"id":214511,"goal":"lemma SetInterSubset_11168(A: set, S: set)\n ensures A * S <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_11169","instance":11169,"id":214512,"goal":"lemma SetCardSubset_11169(S: set, U: set)\n requires S <= U\n ensures |S| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_11170","instance":11170,"id":214513,"goal":"lemma SetUnionCard_11170(B: set, U: set)\n requires B * U == {}\n ensures |B + U| == |B| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_11171","instance":11171,"id":214514,"goal":"lemma SetUnionComm_11171(A: set, S: set)\n ensures A + S == S + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_11172","instance":11172,"id":214515,"goal":"lemma SetInterComm_11172(A: set, B: set)\n ensures A * B == B * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_11173","instance":11173,"id":214516,"goal":"lemma SetUnionAssoc_11173(B: set, U: set, S: set)\n ensures (B + U) + S == B + (U + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_11174","instance":11174,"id":214517,"goal":"lemma SetSubsetRefl_11174(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_11175","instance":11175,"id":214518,"goal":"lemma SetSubsetTrans_11175(A: set, U: set, T: set)\n requires A <= U && U <= T\n ensures A <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_11176","instance":11176,"id":214519,"goal":"lemma SetUnionEmpty_11176(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_11177","instance":11177,"id":214520,"goal":"lemma SetInterEmpty_11177(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_11178","instance":11178,"id":214521,"goal":"lemma SetInterSubset_11178(S: set, B: set)\n ensures S * B <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_11179","instance":11179,"id":214522,"goal":"lemma SetCardSubset_11179(T: set, A: set)\n requires T <= A\n ensures |T| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_11180","instance":11180,"id":214523,"goal":"lemma SetUnionCard_11180(T: set, B: set)\n requires T * B == {}\n ensures |T + B| == |T| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_11181","instance":11181,"id":214524,"goal":"lemma SetUnionComm_11181(B: set, T: set)\n ensures B + T == T + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_11182","instance":11182,"id":214525,"goal":"lemma SetInterComm_11182(A: set, U: set)\n ensures A * U == U * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_11183","instance":11183,"id":214526,"goal":"lemma SetUnionAssoc_11183(U: set, S: set, B: set)\n ensures (U + S) + B == U + (S + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_11184","instance":11184,"id":214527,"goal":"lemma SetSubsetRefl_11184(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_11185","instance":11185,"id":214528,"goal":"lemma SetSubsetTrans_11185(A: set, U: set, T: set)\n requires A <= U && U <= T\n ensures A <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_11186","instance":11186,"id":214529,"goal":"lemma SetUnionEmpty_11186(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_11187","instance":11187,"id":214530,"goal":"lemma SetInterEmpty_11187(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_11188","instance":11188,"id":214531,"goal":"lemma SetInterSubset_11188(U: set, A: set)\n ensures U * A <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_11189","instance":11189,"id":214532,"goal":"lemma SetCardSubset_11189(B: set, A: set)\n requires B <= A\n ensures |B| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_11190","instance":11190,"id":214533,"goal":"lemma SetUnionCard_11190(U: set, A: set)\n requires U * A == {}\n ensures |U + A| == |U| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_11191","instance":11191,"id":214534,"goal":"lemma SetUnionComm_11191(B: set, S: set)\n ensures B + S == S + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_11192","instance":11192,"id":214535,"goal":"lemma SetInterComm_11192(T: set, A: set)\n ensures T * A == A * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_11193","instance":11193,"id":214536,"goal":"lemma SetUnionAssoc_11193(U: set, A: set, B: set)\n ensures (U + A) + B == U + (A + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_11194","instance":11194,"id":214537,"goal":"lemma SetSubsetRefl_11194(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_11195","instance":11195,"id":214538,"goal":"lemma SetSubsetTrans_11195(B: set, A: set, U: set)\n requires B <= A && A <= U\n ensures B <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_11196","instance":11196,"id":214539,"goal":"lemma SetUnionEmpty_11196(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_11197","instance":11197,"id":214540,"goal":"lemma SetInterEmpty_11197(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_11198","instance":11198,"id":214541,"goal":"lemma SetInterSubset_11198(S: set, A: set)\n ensures S * A <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_11199","instance":11199,"id":214542,"goal":"lemma SetCardSubset_11199(T: set, U: set)\n requires T <= U\n ensures |T| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_11200","instance":11200,"id":214543,"goal":"lemma SetUnionCard_11200(B: set, A: set)\n requires B * A == {}\n ensures |B + A| == |B| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_11201","instance":11201,"id":214544,"goal":"lemma SetUnionComm_11201(B: set, U: set)\n ensures B + U == U + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_11202","instance":11202,"id":214545,"goal":"lemma SetInterComm_11202(U: set, T: set)\n ensures U * T == T * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_11203","instance":11203,"id":214546,"goal":"lemma SetUnionAssoc_11203(B: set, U: set, A: set)\n ensures (B + U) + A == B + (U + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_11204","instance":11204,"id":214547,"goal":"lemma SetSubsetRefl_11204(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_11205","instance":11205,"id":214548,"goal":"lemma SetSubsetTrans_11205(B: set, S: set, A: set)\n requires B <= S && S <= A\n ensures B <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_11206","instance":11206,"id":214549,"goal":"lemma SetUnionEmpty_11206(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_11207","instance":11207,"id":214550,"goal":"lemma SetInterEmpty_11207(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_11208","instance":11208,"id":214551,"goal":"lemma SetInterSubset_11208(B: set, T: set)\n ensures B * T <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_11209","instance":11209,"id":214552,"goal":"lemma SetCardSubset_11209(S: set, B: set)\n requires S <= B\n ensures |S| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_11210","instance":11210,"id":214553,"goal":"lemma SetUnionCard_11210(B: set, U: set)\n requires B * U == {}\n ensures |B + U| == |B| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_11211","instance":11211,"id":214554,"goal":"lemma SetUnionComm_11211(T: set, U: set)\n ensures T + U == U + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_11212","instance":11212,"id":214555,"goal":"lemma SetInterComm_11212(T: set, B: set)\n ensures T * B == B * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_11213","instance":11213,"id":214556,"goal":"lemma SetUnionAssoc_11213(S: set, U: set, B: set)\n ensures (S + U) + B == S + (U + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_11214","instance":11214,"id":214557,"goal":"lemma SetSubsetRefl_11214(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_11215","instance":11215,"id":214558,"goal":"lemma SetSubsetTrans_11215(T: set, A: set, B: set)\n requires T <= A && A <= B\n ensures T <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_11216","instance":11216,"id":214559,"goal":"lemma SetUnionEmpty_11216(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_11217","instance":11217,"id":214560,"goal":"lemma SetInterEmpty_11217(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_11218","instance":11218,"id":214561,"goal":"lemma SetInterSubset_11218(B: set, U: set)\n ensures B * U <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_11219","instance":11219,"id":214562,"goal":"lemma SetCardSubset_11219(A: set, B: set)\n requires A <= B\n ensures |A| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_11220","instance":11220,"id":214563,"goal":"lemma SetUnionCard_11220(B: set, A: set)\n requires B * A == {}\n ensures |B + A| == |B| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_11221","instance":11221,"id":214564,"goal":"lemma SetUnionComm_11221(U: set, S: set)\n ensures U + S == S + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_11222","instance":11222,"id":214565,"goal":"lemma SetInterComm_11222(U: set, A: set)\n ensures U * A == A * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_11223","instance":11223,"id":214566,"goal":"lemma SetUnionAssoc_11223(S: set, T: set, B: set)\n ensures (S + T) + B == S + (T + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_11224","instance":11224,"id":214567,"goal":"lemma SetSubsetRefl_11224(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_11225","instance":11225,"id":214568,"goal":"lemma SetSubsetTrans_11225(S: set, U: set, T: set)\n requires S <= U && U <= T\n ensures S <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_11226","instance":11226,"id":214569,"goal":"lemma SetUnionEmpty_11226(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_11227","instance":11227,"id":214570,"goal":"lemma SetInterEmpty_11227(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_11228","instance":11228,"id":214571,"goal":"lemma SetInterSubset_11228(U: set, S: set)\n ensures U * S <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_11229","instance":11229,"id":214572,"goal":"lemma SetCardSubset_11229(S: set, A: set)\n requires S <= A\n ensures |S| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_11230","instance":11230,"id":214573,"goal":"lemma SetUnionCard_11230(U: set, B: set)\n requires U * B == {}\n ensures |U + B| == |U| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_11231","instance":11231,"id":214574,"goal":"lemma SetUnionComm_11231(S: set, B: set)\n ensures S + B == B + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_11232","instance":11232,"id":214575,"goal":"lemma SetInterComm_11232(B: set, S: set)\n ensures B * S == S * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_11233","instance":11233,"id":214576,"goal":"lemma SetUnionAssoc_11233(U: set, S: set, B: set)\n ensures (U + S) + B == U + (S + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_11234","instance":11234,"id":214577,"goal":"lemma SetSubsetRefl_11234(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_11235","instance":11235,"id":214578,"goal":"lemma SetSubsetTrans_11235(U: set, T: set, B: set)\n requires U <= T && T <= B\n ensures U <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_11236","instance":11236,"id":214579,"goal":"lemma SetUnionEmpty_11236(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_11237","instance":11237,"id":214580,"goal":"lemma SetInterEmpty_11237(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_11238","instance":11238,"id":214581,"goal":"lemma SetInterSubset_11238(U: set, A: set)\n ensures U * A <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_11239","instance":11239,"id":214582,"goal":"lemma SetCardSubset_11239(T: set, S: set)\n requires T <= S\n ensures |T| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_11240","instance":11240,"id":214583,"goal":"lemma SetUnionCard_11240(A: set, B: set)\n requires A * B == {}\n ensures |A + B| == |A| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_11241","instance":11241,"id":214584,"goal":"lemma SetUnionComm_11241(S: set, U: set)\n ensures S + U == U + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_11242","instance":11242,"id":214585,"goal":"lemma SetInterComm_11242(B: set, T: set)\n ensures B * T == T * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_11243","instance":11243,"id":214586,"goal":"lemma SetUnionAssoc_11243(B: set, T: set, A: set)\n ensures (B + T) + A == B + (T + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_11244","instance":11244,"id":214587,"goal":"lemma SetSubsetRefl_11244(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_11245","instance":11245,"id":214588,"goal":"lemma SetSubsetTrans_11245(B: set, S: set, T: set)\n requires B <= S && S <= T\n ensures B <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_11246","instance":11246,"id":214589,"goal":"lemma SetUnionEmpty_11246(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_11247","instance":11247,"id":214590,"goal":"lemma SetInterEmpty_11247(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_11248","instance":11248,"id":214591,"goal":"lemma SetInterSubset_11248(T: set, B: set)\n ensures T * B <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_11249","instance":11249,"id":214592,"goal":"lemma SetCardSubset_11249(S: set, A: set)\n requires S <= A\n ensures |S| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_11250","instance":11250,"id":214593,"goal":"lemma SetUnionCard_11250(T: set, U: set)\n requires T * U == {}\n ensures |T + U| == |T| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_11251","instance":11251,"id":214594,"goal":"lemma SetUnionComm_11251(U: set, B: set)\n ensures U + B == B + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_11252","instance":11252,"id":214595,"goal":"lemma SetInterComm_11252(U: set, A: set)\n ensures U * A == A * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_11253","instance":11253,"id":214596,"goal":"lemma SetUnionAssoc_11253(A: set, T: set, S: set)\n ensures (A + T) + S == A + (T + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_11254","instance":11254,"id":214597,"goal":"lemma SetSubsetRefl_11254(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_11255","instance":11255,"id":214598,"goal":"lemma SetSubsetTrans_11255(T: set, B: set, U: set)\n requires T <= B && B <= U\n ensures T <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_11256","instance":11256,"id":214599,"goal":"lemma SetUnionEmpty_11256(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_11257","instance":11257,"id":214600,"goal":"lemma SetInterEmpty_11257(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_11258","instance":11258,"id":214601,"goal":"lemma SetInterSubset_11258(B: set, T: set)\n ensures B * T <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_11259","instance":11259,"id":214602,"goal":"lemma SetCardSubset_11259(T: set, A: set)\n requires T <= A\n ensures |T| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_11260","instance":11260,"id":214603,"goal":"lemma SetUnionCard_11260(B: set, U: set)\n requires B * U == {}\n ensures |B + U| == |B| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_11261","instance":11261,"id":214604,"goal":"lemma SetUnionComm_11261(T: set, A: set)\n ensures T + A == A + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_11262","instance":11262,"id":214605,"goal":"lemma SetInterComm_11262(A: set, T: set)\n ensures A * T == T * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_11263","instance":11263,"id":214606,"goal":"lemma SetUnionAssoc_11263(T: set, B: set, U: set)\n ensures (T + B) + U == T + (B + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_11264","instance":11264,"id":214607,"goal":"lemma SetSubsetRefl_11264(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_11265","instance":11265,"id":214608,"goal":"lemma SetSubsetTrans_11265(B: set, A: set, S: set)\n requires B <= A && A <= S\n ensures B <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_11266","instance":11266,"id":214609,"goal":"lemma SetUnionEmpty_11266(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_11267","instance":11267,"id":214610,"goal":"lemma SetInterEmpty_11267(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_11268","instance":11268,"id":214611,"goal":"lemma SetInterSubset_11268(B: set, A: set)\n ensures B * A <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_11269","instance":11269,"id":214612,"goal":"lemma SetCardSubset_11269(U: set, B: set)\n requires U <= B\n ensures |U| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_11270","instance":11270,"id":214613,"goal":"lemma SetUnionCard_11270(A: set, U: set)\n requires A * U == {}\n ensures |A + U| == |A| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_11271","instance":11271,"id":214614,"goal":"lemma SetUnionComm_11271(A: set, T: set)\n ensures A + T == T + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_11272","instance":11272,"id":214615,"goal":"lemma SetInterComm_11272(S: set, T: set)\n ensures S * T == T * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_11273","instance":11273,"id":214616,"goal":"lemma SetUnionAssoc_11273(B: set, S: set, T: set)\n ensures (B + S) + T == B + (S + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_11274","instance":11274,"id":214617,"goal":"lemma SetSubsetRefl_11274(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_11275","instance":11275,"id":214618,"goal":"lemma SetSubsetTrans_11275(T: set, A: set, B: set)\n requires T <= A && A <= B\n ensures T <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_11276","instance":11276,"id":214619,"goal":"lemma SetUnionEmpty_11276(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_11277","instance":11277,"id":214620,"goal":"lemma SetInterEmpty_11277(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_11278","instance":11278,"id":214621,"goal":"lemma SetInterSubset_11278(T: set, B: set)\n ensures T * B <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_11279","instance":11279,"id":214622,"goal":"lemma SetCardSubset_11279(A: set, B: set)\n requires A <= B\n ensures |A| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_11280","instance":11280,"id":214623,"goal":"lemma SetUnionCard_11280(B: set, S: set)\n requires B * S == {}\n ensures |B + S| == |B| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_11281","instance":11281,"id":214624,"goal":"lemma SetUnionComm_11281(A: set, U: set)\n ensures A + U == U + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_11282","instance":11282,"id":214625,"goal":"lemma SetInterComm_11282(S: set, U: set)\n ensures S * U == U * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_11283","instance":11283,"id":214626,"goal":"lemma SetUnionAssoc_11283(T: set, U: set, B: set)\n ensures (T + U) + B == T + (U + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_11284","instance":11284,"id":214627,"goal":"lemma SetSubsetRefl_11284(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_11285","instance":11285,"id":214628,"goal":"lemma SetSubsetTrans_11285(T: set, B: set, A: set)\n requires T <= B && B <= A\n ensures T <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_11286","instance":11286,"id":214629,"goal":"lemma SetUnionEmpty_11286(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_11287","instance":11287,"id":214630,"goal":"lemma SetInterEmpty_11287(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_11288","instance":11288,"id":214631,"goal":"lemma SetInterSubset_11288(T: set, B: set)\n ensures T * B <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_11289","instance":11289,"id":214632,"goal":"lemma SetCardSubset_11289(B: set, T: set)\n requires B <= T\n ensures |B| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_11290","instance":11290,"id":214633,"goal":"lemma SetUnionCard_11290(S: set, B: set)\n requires S * B == {}\n ensures |S + B| == |S| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_11291","instance":11291,"id":214634,"goal":"lemma SetUnionComm_11291(A: set, S: set)\n ensures A + S == S + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_11292","instance":11292,"id":214635,"goal":"lemma SetInterComm_11292(A: set, U: set)\n ensures A * U == U * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_11293","instance":11293,"id":214636,"goal":"lemma SetUnionAssoc_11293(B: set, S: set, U: set)\n ensures (B + S) + U == B + (S + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_11294","instance":11294,"id":214637,"goal":"lemma SetSubsetRefl_11294(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_11295","instance":11295,"id":214638,"goal":"lemma SetSubsetTrans_11295(S: set, B: set, T: set)\n requires S <= B && B <= T\n ensures S <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_11296","instance":11296,"id":214639,"goal":"lemma SetUnionEmpty_11296(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_11297","instance":11297,"id":214640,"goal":"lemma SetInterEmpty_11297(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_11298","instance":11298,"id":214641,"goal":"lemma SetInterSubset_11298(A: set, U: set)\n ensures A * U <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_11299","instance":11299,"id":214642,"goal":"lemma SetCardSubset_11299(B: set, A: set)\n requires B <= A\n ensures |B| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_11300","instance":11300,"id":214643,"goal":"lemma SetUnionCard_11300(U: set, S: set)\n requires U * S == {}\n ensures |U + S| == |U| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_11301","instance":11301,"id":214644,"goal":"lemma SetUnionComm_11301(A: set, T: set)\n ensures A + T == T + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_11302","instance":11302,"id":214645,"goal":"lemma SetInterComm_11302(U: set, S: set)\n ensures U * S == S * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_11303","instance":11303,"id":214646,"goal":"lemma SetUnionAssoc_11303(U: set, A: set, T: set)\n ensures (U + A) + T == U + (A + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_11304","instance":11304,"id":214647,"goal":"lemma SetSubsetRefl_11304(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_11305","instance":11305,"id":214648,"goal":"lemma SetSubsetTrans_11305(U: set, T: set, B: set)\n requires U <= T && T <= B\n ensures U <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_11306","instance":11306,"id":214649,"goal":"lemma SetUnionEmpty_11306(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_11307","instance":11307,"id":214650,"goal":"lemma SetInterEmpty_11307(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_11308","instance":11308,"id":214651,"goal":"lemma SetInterSubset_11308(B: set, A: set)\n ensures B * A <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_11309","instance":11309,"id":214652,"goal":"lemma SetCardSubset_11309(U: set, B: set)\n requires U <= B\n ensures |U| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_11310","instance":11310,"id":214653,"goal":"lemma SetUnionCard_11310(T: set, U: set)\n requires T * U == {}\n ensures |T + U| == |T| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_11311","instance":11311,"id":214654,"goal":"lemma SetUnionComm_11311(T: set, B: set)\n ensures T + B == B + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_11312","instance":11312,"id":214655,"goal":"lemma SetInterComm_11312(S: set, U: set)\n ensures S * U == U * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_11313","instance":11313,"id":214656,"goal":"lemma SetUnionAssoc_11313(U: set, S: set, A: set)\n ensures (U + S) + A == U + (S + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_11314","instance":11314,"id":214657,"goal":"lemma SetSubsetRefl_11314(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_11315","instance":11315,"id":214658,"goal":"lemma SetSubsetTrans_11315(U: set, A: set, B: set)\n requires U <= A && A <= B\n ensures U <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_11316","instance":11316,"id":214659,"goal":"lemma SetUnionEmpty_11316(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_11317","instance":11317,"id":214660,"goal":"lemma SetInterEmpty_11317(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_11318","instance":11318,"id":214661,"goal":"lemma SetInterSubset_11318(U: set, S: set)\n ensures U * S <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_11319","instance":11319,"id":214662,"goal":"lemma SetCardSubset_11319(A: set, U: set)\n requires A <= U\n ensures |A| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_11320","instance":11320,"id":214663,"goal":"lemma SetUnionCard_11320(S: set, A: set)\n requires S * A == {}\n ensures |S + A| == |S| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_11321","instance":11321,"id":214664,"goal":"lemma SetUnionComm_11321(A: set, S: set)\n ensures A + S == S + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_11322","instance":11322,"id":214665,"goal":"lemma SetInterComm_11322(U: set, B: set)\n ensures U * B == B * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_11323","instance":11323,"id":214666,"goal":"lemma SetUnionAssoc_11323(S: set, A: set, B: set)\n ensures (S + A) + B == S + (A + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_11324","instance":11324,"id":214667,"goal":"lemma SetSubsetRefl_11324(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_11325","instance":11325,"id":214668,"goal":"lemma SetSubsetTrans_11325(T: set, B: set, A: set)\n requires T <= B && B <= A\n ensures T <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_11326","instance":11326,"id":214669,"goal":"lemma SetUnionEmpty_11326(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_11327","instance":11327,"id":214670,"goal":"lemma SetInterEmpty_11327(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_11328","instance":11328,"id":214671,"goal":"lemma SetInterSubset_11328(S: set, B: set)\n ensures S * B <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_11329","instance":11329,"id":214672,"goal":"lemma SetCardSubset_11329(U: set, T: set)\n requires U <= T\n ensures |U| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_11330","instance":11330,"id":214673,"goal":"lemma SetUnionCard_11330(T: set, A: set)\n requires T * A == {}\n ensures |T + A| == |T| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_11331","instance":11331,"id":214674,"goal":"lemma SetUnionComm_11331(U: set, A: set)\n ensures U + A == A + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_11332","instance":11332,"id":214675,"goal":"lemma SetInterComm_11332(S: set, B: set)\n ensures S * B == B * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_11333","instance":11333,"id":214676,"goal":"lemma SetUnionAssoc_11333(U: set, A: set, T: set)\n ensures (U + A) + T == U + (A + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_11334","instance":11334,"id":214677,"goal":"lemma SetSubsetRefl_11334(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_11335","instance":11335,"id":214678,"goal":"lemma SetSubsetTrans_11335(S: set, A: set, B: set)\n requires S <= A && A <= B\n ensures S <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_11336","instance":11336,"id":214679,"goal":"lemma SetUnionEmpty_11336(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_11337","instance":11337,"id":214680,"goal":"lemma SetInterEmpty_11337(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_11338","instance":11338,"id":214681,"goal":"lemma SetInterSubset_11338(T: set, A: set)\n ensures T * A <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_11339","instance":11339,"id":214682,"goal":"lemma SetCardSubset_11339(A: set, U: set)\n requires A <= U\n ensures |A| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_11340","instance":11340,"id":214683,"goal":"lemma SetUnionCard_11340(B: set, T: set)\n requires B * T == {}\n ensures |B + T| == |B| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_11341","instance":11341,"id":214684,"goal":"lemma SetUnionComm_11341(T: set, U: set)\n ensures T + U == U + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_11342","instance":11342,"id":214685,"goal":"lemma SetInterComm_11342(T: set, A: set)\n ensures T * A == A * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_11343","instance":11343,"id":214686,"goal":"lemma SetUnionAssoc_11343(U: set, B: set, A: set)\n ensures (U + B) + A == U + (B + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_11344","instance":11344,"id":214687,"goal":"lemma SetSubsetRefl_11344(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_11345","instance":11345,"id":214688,"goal":"lemma SetSubsetTrans_11345(T: set, U: set, A: set)\n requires T <= U && U <= A\n ensures T <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_11346","instance":11346,"id":214689,"goal":"lemma SetUnionEmpty_11346(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_11347","instance":11347,"id":214690,"goal":"lemma SetInterEmpty_11347(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_11348","instance":11348,"id":214691,"goal":"lemma SetInterSubset_11348(B: set, U: set)\n ensures B * U <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_11349","instance":11349,"id":214692,"goal":"lemma SetCardSubset_11349(T: set, A: set)\n requires T <= A\n ensures |T| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_11350","instance":11350,"id":214693,"goal":"lemma SetUnionCard_11350(S: set, B: set)\n requires S * B == {}\n ensures |S + B| == |S| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_11351","instance":11351,"id":214694,"goal":"lemma SetUnionComm_11351(S: set, U: set)\n ensures S + U == U + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_11352","instance":11352,"id":214695,"goal":"lemma SetInterComm_11352(T: set, S: set)\n ensures T * S == S * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_11353","instance":11353,"id":214696,"goal":"lemma SetUnionAssoc_11353(U: set, B: set, A: set)\n ensures (U + B) + A == U + (B + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_11354","instance":11354,"id":214697,"goal":"lemma SetSubsetRefl_11354(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_11355","instance":11355,"id":214698,"goal":"lemma SetSubsetTrans_11355(T: set, U: set, B: set)\n requires T <= U && U <= B\n ensures T <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_11356","instance":11356,"id":214699,"goal":"lemma SetUnionEmpty_11356(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_11357","instance":11357,"id":214700,"goal":"lemma SetInterEmpty_11357(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_11358","instance":11358,"id":214701,"goal":"lemma SetInterSubset_11358(T: set, S: set)\n ensures T * S <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_11359","instance":11359,"id":214702,"goal":"lemma SetCardSubset_11359(B: set, A: set)\n requires B <= A\n ensures |B| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_11360","instance":11360,"id":214703,"goal":"lemma SetUnionCard_11360(A: set, B: set)\n requires A * B == {}\n ensures |A + B| == |A| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_11361","instance":11361,"id":214704,"goal":"lemma SetUnionComm_11361(U: set, T: set)\n ensures U + T == T + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_11362","instance":11362,"id":214705,"goal":"lemma SetInterComm_11362(T: set, S: set)\n ensures T * S == S * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_11363","instance":11363,"id":214706,"goal":"lemma SetUnionAssoc_11363(B: set, U: set, S: set)\n ensures (B + U) + S == B + (U + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_11364","instance":11364,"id":214707,"goal":"lemma SetSubsetRefl_11364(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_11365","instance":11365,"id":214708,"goal":"lemma SetSubsetTrans_11365(A: set, T: set, U: set)\n requires A <= T && T <= U\n ensures A <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_11366","instance":11366,"id":214709,"goal":"lemma SetUnionEmpty_11366(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_11367","instance":11367,"id":214710,"goal":"lemma SetInterEmpty_11367(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_11368","instance":11368,"id":214711,"goal":"lemma SetInterSubset_11368(B: set, A: set)\n ensures B * A <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_11369","instance":11369,"id":214712,"goal":"lemma SetCardSubset_11369(S: set, A: set)\n requires S <= A\n ensures |S| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_11370","instance":11370,"id":214713,"goal":"lemma SetUnionCard_11370(T: set, S: set)\n requires T * S == {}\n ensures |T + S| == |T| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_11371","instance":11371,"id":214714,"goal":"lemma SetUnionComm_11371(U: set, S: set)\n ensures U + S == S + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_11372","instance":11372,"id":214715,"goal":"lemma SetInterComm_11372(T: set, B: set)\n ensures T * B == B * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_11373","instance":11373,"id":214716,"goal":"lemma SetUnionAssoc_11373(U: set, T: set, A: set)\n ensures (U + T) + A == U + (T + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_11374","instance":11374,"id":214717,"goal":"lemma SetSubsetRefl_11374(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_11375","instance":11375,"id":214718,"goal":"lemma SetSubsetTrans_11375(U: set, A: set, B: set)\n requires U <= A && A <= B\n ensures U <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_11376","instance":11376,"id":214719,"goal":"lemma SetUnionEmpty_11376(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_11377","instance":11377,"id":214720,"goal":"lemma SetInterEmpty_11377(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_11378","instance":11378,"id":214721,"goal":"lemma SetInterSubset_11378(B: set, A: set)\n ensures B * A <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_11379","instance":11379,"id":214722,"goal":"lemma SetCardSubset_11379(S: set, A: set)\n requires S <= A\n ensures |S| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_11380","instance":11380,"id":214723,"goal":"lemma SetUnionCard_11380(U: set, T: set)\n requires U * T == {}\n ensures |U + T| == |U| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_11381","instance":11381,"id":214724,"goal":"lemma SetUnionComm_11381(T: set, A: set)\n ensures T + A == A + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_11382","instance":11382,"id":214725,"goal":"lemma SetInterComm_11382(U: set, S: set)\n ensures U * S == S * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_11383","instance":11383,"id":214726,"goal":"lemma SetUnionAssoc_11383(A: set, B: set, T: set)\n ensures (A + B) + T == A + (B + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_11384","instance":11384,"id":214727,"goal":"lemma SetSubsetRefl_11384(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_11385","instance":11385,"id":214728,"goal":"lemma SetSubsetTrans_11385(T: set, S: set, U: set)\n requires T <= S && S <= U\n ensures T <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_11386","instance":11386,"id":214729,"goal":"lemma SetUnionEmpty_11386(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_11387","instance":11387,"id":214730,"goal":"lemma SetInterEmpty_11387(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_11388","instance":11388,"id":214731,"goal":"lemma SetInterSubset_11388(T: set, A: set)\n ensures T * A <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_11389","instance":11389,"id":214732,"goal":"lemma SetCardSubset_11389(S: set, U: set)\n requires S <= U\n ensures |S| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_11390","instance":11390,"id":214733,"goal":"lemma SetUnionCard_11390(S: set, B: set)\n requires S * B == {}\n ensures |S + B| == |S| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_11391","instance":11391,"id":214734,"goal":"lemma SetUnionComm_11391(T: set, A: set)\n ensures T + A == A + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_11392","instance":11392,"id":214735,"goal":"lemma SetInterComm_11392(B: set, S: set)\n ensures B * S == S * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_11393","instance":11393,"id":214736,"goal":"lemma SetUnionAssoc_11393(A: set, B: set, T: set)\n ensures (A + B) + T == A + (B + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_11394","instance":11394,"id":214737,"goal":"lemma SetSubsetRefl_11394(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_11395","instance":11395,"id":214738,"goal":"lemma SetSubsetTrans_11395(U: set, T: set, B: set)\n requires U <= T && T <= B\n ensures U <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_11396","instance":11396,"id":214739,"goal":"lemma SetUnionEmpty_11396(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_11397","instance":11397,"id":214740,"goal":"lemma SetInterEmpty_11397(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_11398","instance":11398,"id":214741,"goal":"lemma SetInterSubset_11398(A: set, B: set)\n ensures A * B <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_11399","instance":11399,"id":214742,"goal":"lemma SetCardSubset_11399(U: set, T: set)\n requires U <= T\n ensures |U| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_11400","instance":11400,"id":214743,"goal":"lemma SetUnionCard_11400(T: set, U: set)\n requires T * U == {}\n ensures |T + U| == |T| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_11401","instance":11401,"id":214744,"goal":"lemma SetUnionComm_11401(U: set, T: set)\n ensures U + T == T + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_11402","instance":11402,"id":214745,"goal":"lemma SetInterComm_11402(A: set, T: set)\n ensures A * T == T * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_11403","instance":11403,"id":214746,"goal":"lemma SetUnionAssoc_11403(U: set, B: set, S: set)\n ensures (U + B) + S == U + (B + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_11404","instance":11404,"id":214747,"goal":"lemma SetSubsetRefl_11404(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_11405","instance":11405,"id":214748,"goal":"lemma SetSubsetTrans_11405(T: set, U: set, A: set)\n requires T <= U && U <= A\n ensures T <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_11406","instance":11406,"id":214749,"goal":"lemma SetUnionEmpty_11406(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_11407","instance":11407,"id":214750,"goal":"lemma SetInterEmpty_11407(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_11408","instance":11408,"id":214751,"goal":"lemma SetInterSubset_11408(T: set, S: set)\n ensures T * S <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_11409","instance":11409,"id":214752,"goal":"lemma SetCardSubset_11409(B: set, U: set)\n requires B <= U\n ensures |B| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_11410","instance":11410,"id":214753,"goal":"lemma SetUnionCard_11410(U: set, B: set)\n requires U * B == {}\n ensures |U + B| == |U| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_11411","instance":11411,"id":214754,"goal":"lemma SetUnionComm_11411(S: set, B: set)\n ensures S + B == B + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_11412","instance":11412,"id":214755,"goal":"lemma SetInterComm_11412(T: set, S: set)\n ensures T * S == S * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_11413","instance":11413,"id":214756,"goal":"lemma SetUnionAssoc_11413(S: set, U: set, T: set)\n ensures (S + U) + T == S + (U + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_11414","instance":11414,"id":214757,"goal":"lemma SetSubsetRefl_11414(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_11415","instance":11415,"id":214758,"goal":"lemma SetSubsetTrans_11415(T: set, B: set, A: set)\n requires T <= B && B <= A\n ensures T <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_11416","instance":11416,"id":214759,"goal":"lemma SetUnionEmpty_11416(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_11417","instance":11417,"id":214760,"goal":"lemma SetInterEmpty_11417(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_11418","instance":11418,"id":214761,"goal":"lemma SetInterSubset_11418(S: set, B: set)\n ensures S * B <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_11419","instance":11419,"id":214762,"goal":"lemma SetCardSubset_11419(T: set, B: set)\n requires T <= B\n ensures |T| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_11420","instance":11420,"id":214763,"goal":"lemma SetUnionCard_11420(B: set, A: set)\n requires B * A == {}\n ensures |B + A| == |B| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_11421","instance":11421,"id":214764,"goal":"lemma SetUnionComm_11421(A: set, U: set)\n ensures A + U == U + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_11422","instance":11422,"id":214765,"goal":"lemma SetInterComm_11422(A: set, S: set)\n ensures A * S == S * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_11423","instance":11423,"id":214766,"goal":"lemma SetUnionAssoc_11423(U: set, T: set, S: set)\n ensures (U + T) + S == U + (T + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_11424","instance":11424,"id":214767,"goal":"lemma SetSubsetRefl_11424(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_11425","instance":11425,"id":214768,"goal":"lemma SetSubsetTrans_11425(A: set, S: set, U: set)\n requires A <= S && S <= U\n ensures A <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_11426","instance":11426,"id":214769,"goal":"lemma SetUnionEmpty_11426(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_11427","instance":11427,"id":214770,"goal":"lemma SetInterEmpty_11427(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_11428","instance":11428,"id":214771,"goal":"lemma SetInterSubset_11428(T: set, U: set)\n ensures T * U <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_11429","instance":11429,"id":214772,"goal":"lemma SetCardSubset_11429(U: set, A: set)\n requires U <= A\n ensures |U| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_11430","instance":11430,"id":214773,"goal":"lemma SetUnionCard_11430(S: set, B: set)\n requires S * B == {}\n ensures |S + B| == |S| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_11431","instance":11431,"id":214774,"goal":"lemma SetUnionComm_11431(A: set, U: set)\n ensures A + U == U + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_11432","instance":11432,"id":214775,"goal":"lemma SetInterComm_11432(U: set, S: set)\n ensures U * S == S * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_11433","instance":11433,"id":214776,"goal":"lemma SetUnionAssoc_11433(U: set, B: set, A: set)\n ensures (U + B) + A == U + (B + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_11434","instance":11434,"id":214777,"goal":"lemma SetSubsetRefl_11434(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_11435","instance":11435,"id":214778,"goal":"lemma SetSubsetTrans_11435(S: set, B: set, U: set)\n requires S <= B && B <= U\n ensures S <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_11436","instance":11436,"id":214779,"goal":"lemma SetUnionEmpty_11436(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_11437","instance":11437,"id":214780,"goal":"lemma SetInterEmpty_11437(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_11438","instance":11438,"id":214781,"goal":"lemma SetInterSubset_11438(A: set, S: set)\n ensures A * S <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_11439","instance":11439,"id":214782,"goal":"lemma SetCardSubset_11439(U: set, T: set)\n requires U <= T\n ensures |U| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_11440","instance":11440,"id":214783,"goal":"lemma SetUnionCard_11440(S: set, T: set)\n requires S * T == {}\n ensures |S + T| == |S| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_11441","instance":11441,"id":214784,"goal":"lemma SetUnionComm_11441(T: set, B: set)\n ensures T + B == B + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_11442","instance":11442,"id":214785,"goal":"lemma SetInterComm_11442(U: set, S: set)\n ensures U * S == S * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_11443","instance":11443,"id":214786,"goal":"lemma SetUnionAssoc_11443(U: set, S: set, B: set)\n ensures (U + S) + B == U + (S + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_11444","instance":11444,"id":214787,"goal":"lemma SetSubsetRefl_11444(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_11445","instance":11445,"id":214788,"goal":"lemma SetSubsetTrans_11445(B: set, U: set, T: set)\n requires B <= U && U <= T\n ensures B <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_11446","instance":11446,"id":214789,"goal":"lemma SetUnionEmpty_11446(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_11447","instance":11447,"id":214790,"goal":"lemma SetInterEmpty_11447(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_11448","instance":11448,"id":214791,"goal":"lemma SetInterSubset_11448(A: set, B: set)\n ensures A * B <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_11449","instance":11449,"id":214792,"goal":"lemma SetCardSubset_11449(U: set, A: set)\n requires U <= A\n ensures |U| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_11450","instance":11450,"id":214793,"goal":"lemma SetUnionCard_11450(A: set, T: set)\n requires A * T == {}\n ensures |A + T| == |A| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_11451","instance":11451,"id":214794,"goal":"lemma SetUnionComm_11451(T: set, S: set)\n ensures T + S == S + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_11452","instance":11452,"id":214795,"goal":"lemma SetInterComm_11452(U: set, A: set)\n ensures U * A == A * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_11453","instance":11453,"id":214796,"goal":"lemma SetUnionAssoc_11453(U: set, S: set, B: set)\n ensures (U + S) + B == U + (S + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_11454","instance":11454,"id":214797,"goal":"lemma SetSubsetRefl_11454(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_11455","instance":11455,"id":214798,"goal":"lemma SetSubsetTrans_11455(T: set, A: set, B: set)\n requires T <= A && A <= B\n ensures T <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_11456","instance":11456,"id":214799,"goal":"lemma SetUnionEmpty_11456(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_11457","instance":11457,"id":214800,"goal":"lemma SetInterEmpty_11457(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_11458","instance":11458,"id":214801,"goal":"lemma SetInterSubset_11458(S: set, U: set)\n ensures S * U <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_11459","instance":11459,"id":214802,"goal":"lemma SetCardSubset_11459(S: set, B: set)\n requires S <= B\n ensures |S| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_11460","instance":11460,"id":214803,"goal":"lemma SetUnionCard_11460(S: set, B: set)\n requires S * B == {}\n ensures |S + B| == |S| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_11461","instance":11461,"id":214804,"goal":"lemma SetUnionComm_11461(S: set, B: set)\n ensures S + B == B + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_11462","instance":11462,"id":214805,"goal":"lemma SetInterComm_11462(A: set, B: set)\n ensures A * B == B * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_11463","instance":11463,"id":214806,"goal":"lemma SetUnionAssoc_11463(U: set, B: set, A: set)\n ensures (U + B) + A == U + (B + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_11464","instance":11464,"id":214807,"goal":"lemma SetSubsetRefl_11464(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_11465","instance":11465,"id":214808,"goal":"lemma SetSubsetTrans_11465(U: set, B: set, T: set)\n requires U <= B && B <= T\n ensures U <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_11466","instance":11466,"id":214809,"goal":"lemma SetUnionEmpty_11466(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_11467","instance":11467,"id":214810,"goal":"lemma SetInterEmpty_11467(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_11468","instance":11468,"id":214811,"goal":"lemma SetInterSubset_11468(U: set, S: set)\n ensures U * S <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_11469","instance":11469,"id":214812,"goal":"lemma SetCardSubset_11469(U: set, B: set)\n requires U <= B\n ensures |U| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_11470","instance":11470,"id":214813,"goal":"lemma SetUnionCard_11470(S: set, B: set)\n requires S * B == {}\n ensures |S + B| == |S| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_11471","instance":11471,"id":214814,"goal":"lemma SetUnionComm_11471(U: set, T: set)\n ensures U + T == T + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_11472","instance":11472,"id":214815,"goal":"lemma SetInterComm_11472(A: set, S: set)\n ensures A * S == S * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_11473","instance":11473,"id":214816,"goal":"lemma SetUnionAssoc_11473(B: set, U: set, A: set)\n ensures (B + U) + A == B + (U + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_11474","instance":11474,"id":214817,"goal":"lemma SetSubsetRefl_11474(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_11475","instance":11475,"id":214818,"goal":"lemma SetSubsetTrans_11475(S: set, U: set, T: set)\n requires S <= U && U <= T\n ensures S <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_11476","instance":11476,"id":214819,"goal":"lemma SetUnionEmpty_11476(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_11477","instance":11477,"id":214820,"goal":"lemma SetInterEmpty_11477(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_11478","instance":11478,"id":214821,"goal":"lemma SetInterSubset_11478(S: set, B: set)\n ensures S * B <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_11479","instance":11479,"id":214822,"goal":"lemma SetCardSubset_11479(A: set, B: set)\n requires A <= B\n ensures |A| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_11480","instance":11480,"id":214823,"goal":"lemma SetUnionCard_11480(A: set, S: set)\n requires A * S == {}\n ensures |A + S| == |A| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_11481","instance":11481,"id":214824,"goal":"lemma SetUnionComm_11481(T: set, B: set)\n ensures T + B == B + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_11482","instance":11482,"id":214825,"goal":"lemma SetInterComm_11482(B: set, U: set)\n ensures B * U == U * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_11483","instance":11483,"id":214826,"goal":"lemma SetUnionAssoc_11483(A: set, B: set, T: set)\n ensures (A + B) + T == A + (B + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_11484","instance":11484,"id":214827,"goal":"lemma SetSubsetRefl_11484(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_11485","instance":11485,"id":214828,"goal":"lemma SetSubsetTrans_11485(A: set, S: set, U: set)\n requires A <= S && S <= U\n ensures A <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_11486","instance":11486,"id":214829,"goal":"lemma SetUnionEmpty_11486(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_11487","instance":11487,"id":214830,"goal":"lemma SetInterEmpty_11487(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_11488","instance":11488,"id":214831,"goal":"lemma SetInterSubset_11488(A: set, U: set)\n ensures A * U <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_11489","instance":11489,"id":214832,"goal":"lemma SetCardSubset_11489(T: set, B: set)\n requires T <= B\n ensures |T| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_11490","instance":11490,"id":214833,"goal":"lemma SetUnionCard_11490(T: set, U: set)\n requires T * U == {}\n ensures |T + U| == |T| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_11491","instance":11491,"id":214834,"goal":"lemma SetUnionComm_11491(B: set, T: set)\n ensures B + T == T + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_11492","instance":11492,"id":214835,"goal":"lemma SetInterComm_11492(B: set, U: set)\n ensures B * U == U * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_11493","instance":11493,"id":214836,"goal":"lemma SetUnionAssoc_11493(U: set, S: set, T: set)\n ensures (U + S) + T == U + (S + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_11494","instance":11494,"id":214837,"goal":"lemma SetSubsetRefl_11494(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_11495","instance":11495,"id":214838,"goal":"lemma SetSubsetTrans_11495(T: set, U: set, A: set)\n requires T <= U && U <= A\n ensures T <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_11496","instance":11496,"id":214839,"goal":"lemma SetUnionEmpty_11496(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_11497","instance":11497,"id":214840,"goal":"lemma SetInterEmpty_11497(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_11498","instance":11498,"id":214841,"goal":"lemma SetInterSubset_11498(S: set, U: set)\n ensures S * U <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_11499","instance":11499,"id":214842,"goal":"lemma SetCardSubset_11499(T: set, U: set)\n requires T <= U\n ensures |T| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_11500","instance":11500,"id":214843,"goal":"lemma SetUnionCard_11500(B: set, T: set)\n requires B * T == {}\n ensures |B + T| == |B| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_11501","instance":11501,"id":214844,"goal":"lemma SetUnionComm_11501(B: set, T: set)\n ensures B + T == T + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_11502","instance":11502,"id":214845,"goal":"lemma SetInterComm_11502(T: set, U: set)\n ensures T * U == U * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_11503","instance":11503,"id":214846,"goal":"lemma SetUnionAssoc_11503(B: set, U: set, A: set)\n ensures (B + U) + A == B + (U + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_11504","instance":11504,"id":214847,"goal":"lemma SetSubsetRefl_11504(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_11505","instance":11505,"id":214848,"goal":"lemma SetSubsetTrans_11505(T: set, S: set, U: set)\n requires T <= S && S <= U\n ensures T <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_11506","instance":11506,"id":214849,"goal":"lemma SetUnionEmpty_11506(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_11507","instance":11507,"id":214850,"goal":"lemma SetInterEmpty_11507(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_11508","instance":11508,"id":214851,"goal":"lemma SetInterSubset_11508(S: set, B: set)\n ensures S * B <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_11509","instance":11509,"id":214852,"goal":"lemma SetCardSubset_11509(T: set, U: set)\n requires T <= U\n ensures |T| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_11510","instance":11510,"id":214853,"goal":"lemma SetUnionCard_11510(S: set, A: set)\n requires S * A == {}\n ensures |S + A| == |S| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_11511","instance":11511,"id":214854,"goal":"lemma SetUnionComm_11511(A: set, T: set)\n ensures A + T == T + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_11512","instance":11512,"id":214855,"goal":"lemma SetInterComm_11512(A: set, U: set)\n ensures A * U == U * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_11513","instance":11513,"id":214856,"goal":"lemma SetUnionAssoc_11513(S: set, U: set, A: set)\n ensures (S + U) + A == S + (U + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_11514","instance":11514,"id":214857,"goal":"lemma SetSubsetRefl_11514(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_11515","instance":11515,"id":214858,"goal":"lemma SetSubsetTrans_11515(U: set, T: set, A: set)\n requires U <= T && T <= A\n ensures U <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_11516","instance":11516,"id":214859,"goal":"lemma SetUnionEmpty_11516(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_11517","instance":11517,"id":214860,"goal":"lemma SetInterEmpty_11517(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_11518","instance":11518,"id":214861,"goal":"lemma SetInterSubset_11518(A: set, U: set)\n ensures A * U <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_11519","instance":11519,"id":214862,"goal":"lemma SetCardSubset_11519(B: set, T: set)\n requires B <= T\n ensures |B| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_11520","instance":11520,"id":214863,"goal":"lemma SetUnionCard_11520(B: set, U: set)\n requires B * U == {}\n ensures |B + U| == |B| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_11521","instance":11521,"id":214864,"goal":"lemma SetUnionComm_11521(U: set, A: set)\n ensures U + A == A + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_11522","instance":11522,"id":214865,"goal":"lemma SetInterComm_11522(T: set, S: set)\n ensures T * S == S * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_11523","instance":11523,"id":214866,"goal":"lemma SetUnionAssoc_11523(B: set, U: set, S: set)\n ensures (B + U) + S == B + (U + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_11524","instance":11524,"id":214867,"goal":"lemma SetSubsetRefl_11524(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_11525","instance":11525,"id":214868,"goal":"lemma SetSubsetTrans_11525(T: set, U: set, A: set)\n requires T <= U && U <= A\n ensures T <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_11526","instance":11526,"id":214869,"goal":"lemma SetUnionEmpty_11526(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_11527","instance":11527,"id":214870,"goal":"lemma SetInterEmpty_11527(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_11528","instance":11528,"id":214871,"goal":"lemma SetInterSubset_11528(A: set, S: set)\n ensures A * S <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_11529","instance":11529,"id":214872,"goal":"lemma SetCardSubset_11529(U: set, S: set)\n requires U <= S\n ensures |U| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_11530","instance":11530,"id":214873,"goal":"lemma SetUnionCard_11530(T: set, S: set)\n requires T * S == {}\n ensures |T + S| == |T| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_11531","instance":11531,"id":214874,"goal":"lemma SetUnionComm_11531(U: set, T: set)\n ensures U + T == T + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_11532","instance":11532,"id":214875,"goal":"lemma SetInterComm_11532(U: set, B: set)\n ensures U * B == B * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_11533","instance":11533,"id":214876,"goal":"lemma SetUnionAssoc_11533(A: set, B: set, U: set)\n ensures (A + B) + U == A + (B + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_11534","instance":11534,"id":214877,"goal":"lemma SetSubsetRefl_11534(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_11535","instance":11535,"id":214878,"goal":"lemma SetSubsetTrans_11535(B: set, T: set, S: set)\n requires B <= T && T <= S\n ensures B <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_11536","instance":11536,"id":214879,"goal":"lemma SetUnionEmpty_11536(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_11537","instance":11537,"id":214880,"goal":"lemma SetInterEmpty_11537(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_11538","instance":11538,"id":214881,"goal":"lemma SetInterSubset_11538(A: set, S: set)\n ensures A * S <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_11539","instance":11539,"id":214882,"goal":"lemma SetCardSubset_11539(T: set, S: set)\n requires T <= S\n ensures |T| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_11540","instance":11540,"id":214883,"goal":"lemma SetUnionCard_11540(A: set, U: set)\n requires A * U == {}\n ensures |A + U| == |A| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_11541","instance":11541,"id":214884,"goal":"lemma SetUnionComm_11541(B: set, A: set)\n ensures B + A == A + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_11542","instance":11542,"id":214885,"goal":"lemma SetInterComm_11542(T: set, A: set)\n ensures T * A == A * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_11543","instance":11543,"id":214886,"goal":"lemma SetUnionAssoc_11543(B: set, U: set, A: set)\n ensures (B + U) + A == B + (U + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_11544","instance":11544,"id":214887,"goal":"lemma SetSubsetRefl_11544(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_11545","instance":11545,"id":214888,"goal":"lemma SetSubsetTrans_11545(T: set, B: set, A: set)\n requires T <= B && B <= A\n ensures T <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_11546","instance":11546,"id":214889,"goal":"lemma SetUnionEmpty_11546(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_11547","instance":11547,"id":214890,"goal":"lemma SetInterEmpty_11547(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_11548","instance":11548,"id":214891,"goal":"lemma SetInterSubset_11548(S: set, B: set)\n ensures S * B <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_11549","instance":11549,"id":214892,"goal":"lemma SetCardSubset_11549(S: set, B: set)\n requires S <= B\n ensures |S| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_11550","instance":11550,"id":214893,"goal":"lemma SetUnionCard_11550(T: set, B: set)\n requires T * B == {}\n ensures |T + B| == |T| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_11551","instance":11551,"id":214894,"goal":"lemma SetUnionComm_11551(A: set, S: set)\n ensures A + S == S + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_11552","instance":11552,"id":214895,"goal":"lemma SetInterComm_11552(U: set, T: set)\n ensures U * T == T * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_11553","instance":11553,"id":214896,"goal":"lemma SetUnionAssoc_11553(U: set, S: set, B: set)\n ensures (U + S) + B == U + (S + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_11554","instance":11554,"id":214897,"goal":"lemma SetSubsetRefl_11554(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_11555","instance":11555,"id":214898,"goal":"lemma SetSubsetTrans_11555(A: set, S: set, B: set)\n requires A <= S && S <= B\n ensures A <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_11556","instance":11556,"id":214899,"goal":"lemma SetUnionEmpty_11556(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_11557","instance":11557,"id":214900,"goal":"lemma SetInterEmpty_11557(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_11558","instance":11558,"id":214901,"goal":"lemma SetInterSubset_11558(B: set, U: set)\n ensures B * U <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_11559","instance":11559,"id":214902,"goal":"lemma SetCardSubset_11559(S: set, T: set)\n requires S <= T\n ensures |S| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_11560","instance":11560,"id":214903,"goal":"lemma SetUnionCard_11560(S: set, U: set)\n requires S * U == {}\n ensures |S + U| == |S| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_11561","instance":11561,"id":214904,"goal":"lemma SetUnionComm_11561(U: set, B: set)\n ensures U + B == B + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_11562","instance":11562,"id":214905,"goal":"lemma SetInterComm_11562(T: set, U: set)\n ensures T * U == U * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_11563","instance":11563,"id":214906,"goal":"lemma SetUnionAssoc_11563(T: set, A: set, S: set)\n ensures (T + A) + S == T + (A + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_11564","instance":11564,"id":214907,"goal":"lemma SetSubsetRefl_11564(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_11565","instance":11565,"id":214908,"goal":"lemma SetSubsetTrans_11565(A: set, S: set, U: set)\n requires A <= S && S <= U\n ensures A <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_11566","instance":11566,"id":214909,"goal":"lemma SetUnionEmpty_11566(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_11567","instance":11567,"id":214910,"goal":"lemma SetInterEmpty_11567(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_11568","instance":11568,"id":214911,"goal":"lemma SetInterSubset_11568(S: set, T: set)\n ensures S * T <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_11569","instance":11569,"id":214912,"goal":"lemma SetCardSubset_11569(U: set, A: set)\n requires U <= A\n ensures |U| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_11570","instance":11570,"id":214913,"goal":"lemma SetUnionCard_11570(A: set, T: set)\n requires A * T == {}\n ensures |A + T| == |A| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_11571","instance":11571,"id":214914,"goal":"lemma SetUnionComm_11571(T: set, S: set)\n ensures T + S == S + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_11572","instance":11572,"id":214915,"goal":"lemma SetInterComm_11572(A: set, B: set)\n ensures A * B == B * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_11573","instance":11573,"id":214916,"goal":"lemma SetUnionAssoc_11573(T: set, B: set, S: set)\n ensures (T + B) + S == T + (B + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_11574","instance":11574,"id":214917,"goal":"lemma SetSubsetRefl_11574(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_11575","instance":11575,"id":214918,"goal":"lemma SetSubsetTrans_11575(B: set, U: set, A: set)\n requires B <= U && U <= A\n ensures B <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_11576","instance":11576,"id":214919,"goal":"lemma SetUnionEmpty_11576(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_11577","instance":11577,"id":214920,"goal":"lemma SetInterEmpty_11577(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_11578","instance":11578,"id":214921,"goal":"lemma SetInterSubset_11578(T: set, A: set)\n ensures T * A <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_11579","instance":11579,"id":214922,"goal":"lemma SetCardSubset_11579(S: set, A: set)\n requires S <= A\n ensures |S| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_11580","instance":11580,"id":214923,"goal":"lemma SetUnionCard_11580(B: set, S: set)\n requires B * S == {}\n ensures |B + S| == |B| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_11581","instance":11581,"id":214924,"goal":"lemma SetUnionComm_11581(S: set, U: set)\n ensures S + U == U + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_11582","instance":11582,"id":214925,"goal":"lemma SetInterComm_11582(B: set, T: set)\n ensures B * T == T * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_11583","instance":11583,"id":214926,"goal":"lemma SetUnionAssoc_11583(A: set, S: set, T: set)\n ensures (A + S) + T == A + (S + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_11584","instance":11584,"id":214927,"goal":"lemma SetSubsetRefl_11584(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_11585","instance":11585,"id":214928,"goal":"lemma SetSubsetTrans_11585(A: set, B: set, S: set)\n requires A <= B && B <= S\n ensures A <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_11586","instance":11586,"id":214929,"goal":"lemma SetUnionEmpty_11586(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_11587","instance":11587,"id":214930,"goal":"lemma SetInterEmpty_11587(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_11588","instance":11588,"id":214931,"goal":"lemma SetInterSubset_11588(U: set, B: set)\n ensures U * B <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_11589","instance":11589,"id":214932,"goal":"lemma SetCardSubset_11589(B: set, T: set)\n requires B <= T\n ensures |B| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_11590","instance":11590,"id":214933,"goal":"lemma SetUnionCard_11590(U: set, A: set)\n requires U * A == {}\n ensures |U + A| == |U| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_11591","instance":11591,"id":214934,"goal":"lemma SetUnionComm_11591(S: set, B: set)\n ensures S + B == B + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_11592","instance":11592,"id":214935,"goal":"lemma SetInterComm_11592(B: set, A: set)\n ensures B * A == A * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_11593","instance":11593,"id":214936,"goal":"lemma SetUnionAssoc_11593(A: set, U: set, S: set)\n ensures (A + U) + S == A + (U + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_11594","instance":11594,"id":214937,"goal":"lemma SetSubsetRefl_11594(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_11595","instance":11595,"id":214938,"goal":"lemma SetSubsetTrans_11595(U: set, B: set, A: set)\n requires U <= B && B <= A\n ensures U <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_11596","instance":11596,"id":214939,"goal":"lemma SetUnionEmpty_11596(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_11597","instance":11597,"id":214940,"goal":"lemma SetInterEmpty_11597(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_11598","instance":11598,"id":214941,"goal":"lemma SetInterSubset_11598(U: set, A: set)\n ensures U * A <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_11599","instance":11599,"id":214942,"goal":"lemma SetCardSubset_11599(A: set, S: set)\n requires A <= S\n ensures |A| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_11600","instance":11600,"id":214943,"goal":"lemma SetUnionCard_11600(T: set, S: set)\n requires T * S == {}\n ensures |T + S| == |T| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_11601","instance":11601,"id":214944,"goal":"lemma SetUnionComm_11601(T: set, U: set)\n ensures T + U == U + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_11602","instance":11602,"id":214945,"goal":"lemma SetInterComm_11602(S: set, T: set)\n ensures S * T == T * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_11603","instance":11603,"id":214946,"goal":"lemma SetUnionAssoc_11603(B: set, T: set, A: set)\n ensures (B + T) + A == B + (T + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_11604","instance":11604,"id":214947,"goal":"lemma SetSubsetRefl_11604(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_11605","instance":11605,"id":214948,"goal":"lemma SetSubsetTrans_11605(B: set, A: set, T: set)\n requires B <= A && A <= T\n ensures B <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_11606","instance":11606,"id":214949,"goal":"lemma SetUnionEmpty_11606(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_11607","instance":11607,"id":214950,"goal":"lemma SetInterEmpty_11607(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_11608","instance":11608,"id":214951,"goal":"lemma SetInterSubset_11608(T: set, S: set)\n ensures T * S <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_11609","instance":11609,"id":214952,"goal":"lemma SetCardSubset_11609(U: set, A: set)\n requires U <= A\n ensures |U| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_11610","instance":11610,"id":214953,"goal":"lemma SetUnionCard_11610(A: set, T: set)\n requires A * T == {}\n ensures |A + T| == |A| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_11611","instance":11611,"id":214954,"goal":"lemma SetUnionComm_11611(A: set, T: set)\n ensures A + T == T + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_11612","instance":11612,"id":214955,"goal":"lemma SetInterComm_11612(A: set, T: set)\n ensures A * T == T * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_11613","instance":11613,"id":214956,"goal":"lemma SetUnionAssoc_11613(T: set, U: set, S: set)\n ensures (T + U) + S == T + (U + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_11614","instance":11614,"id":214957,"goal":"lemma SetSubsetRefl_11614(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_11615","instance":11615,"id":214958,"goal":"lemma SetSubsetTrans_11615(U: set, T: set, A: set)\n requires U <= T && T <= A\n ensures U <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_11616","instance":11616,"id":214959,"goal":"lemma SetUnionEmpty_11616(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_11617","instance":11617,"id":214960,"goal":"lemma SetInterEmpty_11617(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_11618","instance":11618,"id":214961,"goal":"lemma SetInterSubset_11618(U: set, S: set)\n ensures U * S <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_11619","instance":11619,"id":214962,"goal":"lemma SetCardSubset_11619(S: set, U: set)\n requires S <= U\n ensures |S| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_11620","instance":11620,"id":214963,"goal":"lemma SetUnionCard_11620(A: set, T: set)\n requires A * T == {}\n ensures |A + T| == |A| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_11621","instance":11621,"id":214964,"goal":"lemma SetUnionComm_11621(T: set, U: set)\n ensures T + U == U + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_11622","instance":11622,"id":214965,"goal":"lemma SetInterComm_11622(B: set, S: set)\n ensures B * S == S * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_11623","instance":11623,"id":214966,"goal":"lemma SetUnionAssoc_11623(T: set, U: set, A: set)\n ensures (T + U) + A == T + (U + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_11624","instance":11624,"id":214967,"goal":"lemma SetSubsetRefl_11624(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_11625","instance":11625,"id":214968,"goal":"lemma SetSubsetTrans_11625(S: set, B: set, A: set)\n requires S <= B && B <= A\n ensures S <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_11626","instance":11626,"id":214969,"goal":"lemma SetUnionEmpty_11626(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_11627","instance":11627,"id":214970,"goal":"lemma SetInterEmpty_11627(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_11628","instance":11628,"id":214971,"goal":"lemma SetInterSubset_11628(B: set, A: set)\n ensures B * A <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_11629","instance":11629,"id":214972,"goal":"lemma SetCardSubset_11629(T: set, B: set)\n requires T <= B\n ensures |T| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_11630","instance":11630,"id":214973,"goal":"lemma SetUnionCard_11630(S: set, U: set)\n requires S * U == {}\n ensures |S + U| == |S| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_11631","instance":11631,"id":214974,"goal":"lemma SetUnionComm_11631(A: set, U: set)\n ensures A + U == U + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_11632","instance":11632,"id":214975,"goal":"lemma SetInterComm_11632(B: set, U: set)\n ensures B * U == U * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_11633","instance":11633,"id":214976,"goal":"lemma SetUnionAssoc_11633(U: set, S: set, T: set)\n ensures (U + S) + T == U + (S + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_11634","instance":11634,"id":214977,"goal":"lemma SetSubsetRefl_11634(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_11635","instance":11635,"id":214978,"goal":"lemma SetSubsetTrans_11635(T: set, B: set, S: set)\n requires T <= B && B <= S\n ensures T <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_11636","instance":11636,"id":214979,"goal":"lemma SetUnionEmpty_11636(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_11637","instance":11637,"id":214980,"goal":"lemma SetInterEmpty_11637(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_11638","instance":11638,"id":214981,"goal":"lemma SetInterSubset_11638(U: set, B: set)\n ensures U * B <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_11639","instance":11639,"id":214982,"goal":"lemma SetCardSubset_11639(U: set, A: set)\n requires U <= A\n ensures |U| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_11640","instance":11640,"id":214983,"goal":"lemma SetUnionCard_11640(B: set, A: set)\n requires B * A == {}\n ensures |B + A| == |B| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_11641","instance":11641,"id":214984,"goal":"lemma SetUnionComm_11641(T: set, A: set)\n ensures T + A == A + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_11642","instance":11642,"id":214985,"goal":"lemma SetInterComm_11642(A: set, S: set)\n ensures A * S == S * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_11643","instance":11643,"id":214986,"goal":"lemma SetUnionAssoc_11643(S: set, B: set, T: set)\n ensures (S + B) + T == S + (B + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_11644","instance":11644,"id":214987,"goal":"lemma SetSubsetRefl_11644(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_11645","instance":11645,"id":214988,"goal":"lemma SetSubsetTrans_11645(U: set, B: set, A: set)\n requires U <= B && B <= A\n ensures U <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_11646","instance":11646,"id":214989,"goal":"lemma SetUnionEmpty_11646(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_11647","instance":11647,"id":214990,"goal":"lemma SetInterEmpty_11647(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_11648","instance":11648,"id":214991,"goal":"lemma SetInterSubset_11648(A: set, U: set)\n ensures A * U <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_11649","instance":11649,"id":214992,"goal":"lemma SetCardSubset_11649(A: set, U: set)\n requires A <= U\n ensures |A| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_11650","instance":11650,"id":214993,"goal":"lemma SetUnionCard_11650(B: set, U: set)\n requires B * U == {}\n ensures |B + U| == |B| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_11651","instance":11651,"id":214994,"goal":"lemma SetUnionComm_11651(T: set, S: set)\n ensures T + S == S + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_11652","instance":11652,"id":214995,"goal":"lemma SetInterComm_11652(S: set, B: set)\n ensures S * B == B * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_11653","instance":11653,"id":214996,"goal":"lemma SetUnionAssoc_11653(S: set, B: set, A: set)\n ensures (S + B) + A == S + (B + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_11654","instance":11654,"id":214997,"goal":"lemma SetSubsetRefl_11654(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_11655","instance":11655,"id":214998,"goal":"lemma SetSubsetTrans_11655(A: set, U: set, T: set)\n requires A <= U && U <= T\n ensures A <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_11656","instance":11656,"id":214999,"goal":"lemma SetUnionEmpty_11656(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_11657","instance":11657,"id":215000,"goal":"lemma SetInterEmpty_11657(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_11658","instance":11658,"id":215001,"goal":"lemma SetInterSubset_11658(T: set, S: set)\n ensures T * S <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_11659","instance":11659,"id":215002,"goal":"lemma SetCardSubset_11659(U: set, S: set)\n requires U <= S\n ensures |U| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_11660","instance":11660,"id":215003,"goal":"lemma SetUnionCard_11660(S: set, B: set)\n requires S * B == {}\n ensures |S + B| == |S| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_11661","instance":11661,"id":215004,"goal":"lemma SetUnionComm_11661(U: set, T: set)\n ensures U + T == T + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_11662","instance":11662,"id":215005,"goal":"lemma SetInterComm_11662(T: set, U: set)\n ensures T * U == U * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_11663","instance":11663,"id":215006,"goal":"lemma SetUnionAssoc_11663(A: set, B: set, T: set)\n ensures (A + B) + T == A + (B + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_11664","instance":11664,"id":215007,"goal":"lemma SetSubsetRefl_11664(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_11665","instance":11665,"id":215008,"goal":"lemma SetSubsetTrans_11665(S: set, T: set, A: set)\n requires S <= T && T <= A\n ensures S <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_11666","instance":11666,"id":215009,"goal":"lemma SetUnionEmpty_11666(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_11667","instance":11667,"id":215010,"goal":"lemma SetInterEmpty_11667(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_11668","instance":11668,"id":215011,"goal":"lemma SetInterSubset_11668(B: set, T: set)\n ensures B * T <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_11669","instance":11669,"id":215012,"goal":"lemma SetCardSubset_11669(B: set, T: set)\n requires B <= T\n ensures |B| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_11670","instance":11670,"id":215013,"goal":"lemma SetUnionCard_11670(B: set, T: set)\n requires B * T == {}\n ensures |B + T| == |B| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_11671","instance":11671,"id":215014,"goal":"lemma SetUnionComm_11671(U: set, B: set)\n ensures U + B == B + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_11672","instance":11672,"id":215015,"goal":"lemma SetInterComm_11672(A: set, U: set)\n ensures A * U == U * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_11673","instance":11673,"id":215016,"goal":"lemma SetUnionAssoc_11673(A: set, S: set, B: set)\n ensures (A + S) + B == A + (S + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_11674","instance":11674,"id":215017,"goal":"lemma SetSubsetRefl_11674(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_11675","instance":11675,"id":215018,"goal":"lemma SetSubsetTrans_11675(U: set, B: set, T: set)\n requires U <= B && B <= T\n ensures U <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_11676","instance":11676,"id":215019,"goal":"lemma SetUnionEmpty_11676(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_11677","instance":11677,"id":215020,"goal":"lemma SetInterEmpty_11677(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_11678","instance":11678,"id":215021,"goal":"lemma SetInterSubset_11678(T: set, U: set)\n ensures T * U <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_11679","instance":11679,"id":215022,"goal":"lemma SetCardSubset_11679(S: set, U: set)\n requires S <= U\n ensures |S| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_11680","instance":11680,"id":215023,"goal":"lemma SetUnionCard_11680(A: set, S: set)\n requires A * S == {}\n ensures |A + S| == |A| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_11681","instance":11681,"id":215024,"goal":"lemma SetUnionComm_11681(S: set, A: set)\n ensures S + A == A + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_11682","instance":11682,"id":215025,"goal":"lemma SetInterComm_11682(U: set, A: set)\n ensures U * A == A * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_11683","instance":11683,"id":215026,"goal":"lemma SetUnionAssoc_11683(B: set, U: set, A: set)\n ensures (B + U) + A == B + (U + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_11684","instance":11684,"id":215027,"goal":"lemma SetSubsetRefl_11684(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_11685","instance":11685,"id":215028,"goal":"lemma SetSubsetTrans_11685(U: set, B: set, S: set)\n requires U <= B && B <= S\n ensures U <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_11686","instance":11686,"id":215029,"goal":"lemma SetUnionEmpty_11686(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_11687","instance":11687,"id":215030,"goal":"lemma SetInterEmpty_11687(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_11688","instance":11688,"id":215031,"goal":"lemma SetInterSubset_11688(B: set, S: set)\n ensures B * S <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_11689","instance":11689,"id":215032,"goal":"lemma SetCardSubset_11689(B: set, A: set)\n requires B <= A\n ensures |B| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_11690","instance":11690,"id":215033,"goal":"lemma SetUnionCard_11690(U: set, S: set)\n requires U * S == {}\n ensures |U + S| == |U| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_11691","instance":11691,"id":215034,"goal":"lemma SetUnionComm_11691(B: set, A: set)\n ensures B + A == A + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_11692","instance":11692,"id":215035,"goal":"lemma SetInterComm_11692(A: set, U: set)\n ensures A * U == U * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_11693","instance":11693,"id":215036,"goal":"lemma SetUnionAssoc_11693(U: set, A: set, S: set)\n ensures (U + A) + S == U + (A + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_11694","instance":11694,"id":215037,"goal":"lemma SetSubsetRefl_11694(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_11695","instance":11695,"id":215038,"goal":"lemma SetSubsetTrans_11695(S: set, U: set, T: set)\n requires S <= U && U <= T\n ensures S <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_11696","instance":11696,"id":215039,"goal":"lemma SetUnionEmpty_11696(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_11697","instance":11697,"id":215040,"goal":"lemma SetInterEmpty_11697(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_11698","instance":11698,"id":215041,"goal":"lemma SetInterSubset_11698(U: set, T: set)\n ensures U * T <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_11699","instance":11699,"id":215042,"goal":"lemma SetCardSubset_11699(S: set, B: set)\n requires S <= B\n ensures |S| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_11700","instance":11700,"id":215043,"goal":"lemma SetUnionCard_11700(T: set, B: set)\n requires T * B == {}\n ensures |T + B| == |T| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_11701","instance":11701,"id":215044,"goal":"lemma SetUnionComm_11701(B: set, A: set)\n ensures B + A == A + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_11702","instance":11702,"id":215045,"goal":"lemma SetInterComm_11702(B: set, U: set)\n ensures B * U == U * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_11703","instance":11703,"id":215046,"goal":"lemma SetUnionAssoc_11703(U: set, A: set, S: set)\n ensures (U + A) + S == U + (A + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_11704","instance":11704,"id":215047,"goal":"lemma SetSubsetRefl_11704(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_11705","instance":11705,"id":215048,"goal":"lemma SetSubsetTrans_11705(T: set, U: set, S: set)\n requires T <= U && U <= S\n ensures T <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_11706","instance":11706,"id":215049,"goal":"lemma SetUnionEmpty_11706(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_11707","instance":11707,"id":215050,"goal":"lemma SetInterEmpty_11707(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_11708","instance":11708,"id":215051,"goal":"lemma SetInterSubset_11708(A: set, T: set)\n ensures A * T <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_11709","instance":11709,"id":215052,"goal":"lemma SetCardSubset_11709(S: set, T: set)\n requires S <= T\n ensures |S| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_11710","instance":11710,"id":215053,"goal":"lemma SetUnionCard_11710(U: set, B: set)\n requires U * B == {}\n ensures |U + B| == |U| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_11711","instance":11711,"id":215054,"goal":"lemma SetUnionComm_11711(T: set, A: set)\n ensures T + A == A + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_11712","instance":11712,"id":215055,"goal":"lemma SetInterComm_11712(S: set, U: set)\n ensures S * U == U * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_11713","instance":11713,"id":215056,"goal":"lemma SetUnionAssoc_11713(B: set, U: set, S: set)\n ensures (B + U) + S == B + (U + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_11714","instance":11714,"id":215057,"goal":"lemma SetSubsetRefl_11714(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_11715","instance":11715,"id":215058,"goal":"lemma SetSubsetTrans_11715(A: set, U: set, T: set)\n requires A <= U && U <= T\n ensures A <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_11716","instance":11716,"id":215059,"goal":"lemma SetUnionEmpty_11716(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_11717","instance":11717,"id":215060,"goal":"lemma SetInterEmpty_11717(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_11718","instance":11718,"id":215061,"goal":"lemma SetInterSubset_11718(A: set, S: set)\n ensures A * S <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_11719","instance":11719,"id":215062,"goal":"lemma SetCardSubset_11719(A: set, T: set)\n requires A <= T\n ensures |A| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_11720","instance":11720,"id":215063,"goal":"lemma SetUnionCard_11720(U: set, B: set)\n requires U * B == {}\n ensures |U + B| == |U| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_11721","instance":11721,"id":215064,"goal":"lemma SetUnionComm_11721(A: set, U: set)\n ensures A + U == U + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_11722","instance":11722,"id":215065,"goal":"lemma SetInterComm_11722(A: set, U: set)\n ensures A * U == U * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_11723","instance":11723,"id":215066,"goal":"lemma SetUnionAssoc_11723(U: set, A: set, T: set)\n ensures (U + A) + T == U + (A + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_11724","instance":11724,"id":215067,"goal":"lemma SetSubsetRefl_11724(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_11725","instance":11725,"id":215068,"goal":"lemma SetSubsetTrans_11725(T: set, A: set, B: set)\n requires T <= A && A <= B\n ensures T <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_11726","instance":11726,"id":215069,"goal":"lemma SetUnionEmpty_11726(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_11727","instance":11727,"id":215070,"goal":"lemma SetInterEmpty_11727(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_11728","instance":11728,"id":215071,"goal":"lemma SetInterSubset_11728(S: set, T: set)\n ensures S * T <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_11729","instance":11729,"id":215072,"goal":"lemma SetCardSubset_11729(U: set, S: set)\n requires U <= S\n ensures |U| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_11730","instance":11730,"id":215073,"goal":"lemma SetUnionCard_11730(U: set, T: set)\n requires U * T == {}\n ensures |U + T| == |U| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_11731","instance":11731,"id":215074,"goal":"lemma SetUnionComm_11731(B: set, S: set)\n ensures B + S == S + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_11732","instance":11732,"id":215075,"goal":"lemma SetInterComm_11732(S: set, A: set)\n ensures S * A == A * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_11733","instance":11733,"id":215076,"goal":"lemma SetUnionAssoc_11733(A: set, T: set, S: set)\n ensures (A + T) + S == A + (T + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_11734","instance":11734,"id":215077,"goal":"lemma SetSubsetRefl_11734(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_11735","instance":11735,"id":215078,"goal":"lemma SetSubsetTrans_11735(S: set, U: set, A: set)\n requires S <= U && U <= A\n ensures S <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_11736","instance":11736,"id":215079,"goal":"lemma SetUnionEmpty_11736(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_11737","instance":11737,"id":215080,"goal":"lemma SetInterEmpty_11737(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_11738","instance":11738,"id":215081,"goal":"lemma SetInterSubset_11738(S: set, T: set)\n ensures S * T <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_11739","instance":11739,"id":215082,"goal":"lemma SetCardSubset_11739(T: set, U: set)\n requires T <= U\n ensures |T| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_11740","instance":11740,"id":215083,"goal":"lemma SetUnionCard_11740(S: set, T: set)\n requires S * T == {}\n ensures |S + T| == |S| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_11741","instance":11741,"id":215084,"goal":"lemma SetUnionComm_11741(B: set, A: set)\n ensures B + A == A + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_11742","instance":11742,"id":215085,"goal":"lemma SetInterComm_11742(A: set, S: set)\n ensures A * S == S * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_11743","instance":11743,"id":215086,"goal":"lemma SetUnionAssoc_11743(T: set, S: set, A: set)\n ensures (T + S) + A == T + (S + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_11744","instance":11744,"id":215087,"goal":"lemma SetSubsetRefl_11744(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_11745","instance":11745,"id":215088,"goal":"lemma SetSubsetTrans_11745(S: set, A: set, T: set)\n requires S <= A && A <= T\n ensures S <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_11746","instance":11746,"id":215089,"goal":"lemma SetUnionEmpty_11746(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_11747","instance":11747,"id":215090,"goal":"lemma SetInterEmpty_11747(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_11748","instance":11748,"id":215091,"goal":"lemma SetInterSubset_11748(B: set, U: set)\n ensures B * U <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_11749","instance":11749,"id":215092,"goal":"lemma SetCardSubset_11749(S: set, U: set)\n requires S <= U\n ensures |S| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_11750","instance":11750,"id":215093,"goal":"lemma SetUnionCard_11750(B: set, S: set)\n requires B * S == {}\n ensures |B + S| == |B| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_11751","instance":11751,"id":215094,"goal":"lemma SetUnionComm_11751(B: set, S: set)\n ensures B + S == S + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_11752","instance":11752,"id":215095,"goal":"lemma SetInterComm_11752(U: set, S: set)\n ensures U * S == S * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_11753","instance":11753,"id":215096,"goal":"lemma SetUnionAssoc_11753(S: set, A: set, B: set)\n ensures (S + A) + B == S + (A + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_11754","instance":11754,"id":215097,"goal":"lemma SetSubsetRefl_11754(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_11755","instance":11755,"id":215098,"goal":"lemma SetSubsetTrans_11755(U: set, A: set, S: set)\n requires U <= A && A <= S\n ensures U <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_11756","instance":11756,"id":215099,"goal":"lemma SetUnionEmpty_11756(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_11757","instance":11757,"id":215100,"goal":"lemma SetInterEmpty_11757(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_11758","instance":11758,"id":215101,"goal":"lemma SetInterSubset_11758(T: set, U: set)\n ensures T * U <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_11759","instance":11759,"id":215102,"goal":"lemma SetCardSubset_11759(A: set, T: set)\n requires A <= T\n ensures |A| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_11760","instance":11760,"id":215103,"goal":"lemma SetUnionCard_11760(A: set, B: set)\n requires A * B == {}\n ensures |A + B| == |A| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_11761","instance":11761,"id":215104,"goal":"lemma SetUnionComm_11761(U: set, A: set)\n ensures U + A == A + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_11762","instance":11762,"id":215105,"goal":"lemma SetInterComm_11762(A: set, T: set)\n ensures A * T == T * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_11763","instance":11763,"id":215106,"goal":"lemma SetUnionAssoc_11763(A: set, B: set, S: set)\n ensures (A + B) + S == A + (B + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_11764","instance":11764,"id":215107,"goal":"lemma SetSubsetRefl_11764(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_11765","instance":11765,"id":215108,"goal":"lemma SetSubsetTrans_11765(T: set, U: set, A: set)\n requires T <= U && U <= A\n ensures T <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_11766","instance":11766,"id":215109,"goal":"lemma SetUnionEmpty_11766(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_11767","instance":11767,"id":215110,"goal":"lemma SetInterEmpty_11767(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_11768","instance":11768,"id":215111,"goal":"lemma SetInterSubset_11768(U: set, A: set)\n ensures U * A <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_11769","instance":11769,"id":215112,"goal":"lemma SetCardSubset_11769(T: set, U: set)\n requires T <= U\n ensures |T| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_11770","instance":11770,"id":215113,"goal":"lemma SetUnionCard_11770(U: set, S: set)\n requires U * S == {}\n ensures |U + S| == |U| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_11771","instance":11771,"id":215114,"goal":"lemma SetUnionComm_11771(B: set, U: set)\n ensures B + U == U + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_11772","instance":11772,"id":215115,"goal":"lemma SetInterComm_11772(B: set, A: set)\n ensures B * A == A * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_11773","instance":11773,"id":215116,"goal":"lemma SetUnionAssoc_11773(S: set, B: set, A: set)\n ensures (S + B) + A == S + (B + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_11774","instance":11774,"id":215117,"goal":"lemma SetSubsetRefl_11774(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_11775","instance":11775,"id":215118,"goal":"lemma SetSubsetTrans_11775(U: set, S: set, T: set)\n requires U <= S && S <= T\n ensures U <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_11776","instance":11776,"id":215119,"goal":"lemma SetUnionEmpty_11776(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_11777","instance":11777,"id":215120,"goal":"lemma SetInterEmpty_11777(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_11778","instance":11778,"id":215121,"goal":"lemma SetInterSubset_11778(S: set, T: set)\n ensures S * T <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_11779","instance":11779,"id":215122,"goal":"lemma SetCardSubset_11779(B: set, U: set)\n requires B <= U\n ensures |B| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_11780","instance":11780,"id":215123,"goal":"lemma SetUnionCard_11780(B: set, U: set)\n requires B * U == {}\n ensures |B + U| == |B| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_11781","instance":11781,"id":215124,"goal":"lemma SetUnionComm_11781(A: set, S: set)\n ensures A + S == S + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_11782","instance":11782,"id":215125,"goal":"lemma SetInterComm_11782(B: set, A: set)\n ensures B * A == A * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_11783","instance":11783,"id":215126,"goal":"lemma SetUnionAssoc_11783(U: set, T: set, A: set)\n ensures (U + T) + A == U + (T + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_11784","instance":11784,"id":215127,"goal":"lemma SetSubsetRefl_11784(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_11785","instance":11785,"id":215128,"goal":"lemma SetSubsetTrans_11785(S: set, U: set, B: set)\n requires S <= U && U <= B\n ensures S <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_11786","instance":11786,"id":215129,"goal":"lemma SetUnionEmpty_11786(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_11787","instance":11787,"id":215130,"goal":"lemma SetInterEmpty_11787(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_11788","instance":11788,"id":215131,"goal":"lemma SetInterSubset_11788(B: set, T: set)\n ensures B * T <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_11789","instance":11789,"id":215132,"goal":"lemma SetCardSubset_11789(S: set, B: set)\n requires S <= B\n ensures |S| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_11790","instance":11790,"id":215133,"goal":"lemma SetUnionCard_11790(B: set, T: set)\n requires B * T == {}\n ensures |B + T| == |B| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_11791","instance":11791,"id":215134,"goal":"lemma SetUnionComm_11791(T: set, S: set)\n ensures T + S == S + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_11792","instance":11792,"id":215135,"goal":"lemma SetInterComm_11792(B: set, T: set)\n ensures B * T == T * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_11793","instance":11793,"id":215136,"goal":"lemma SetUnionAssoc_11793(A: set, B: set, U: set)\n ensures (A + B) + U == A + (B + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_11794","instance":11794,"id":215137,"goal":"lemma SetSubsetRefl_11794(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_11795","instance":11795,"id":215138,"goal":"lemma SetSubsetTrans_11795(B: set, S: set, A: set)\n requires B <= S && S <= A\n ensures B <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_11796","instance":11796,"id":215139,"goal":"lemma SetUnionEmpty_11796(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_11797","instance":11797,"id":215140,"goal":"lemma SetInterEmpty_11797(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_11798","instance":11798,"id":215141,"goal":"lemma SetInterSubset_11798(A: set, S: set)\n ensures A * S <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_11799","instance":11799,"id":215142,"goal":"lemma SetCardSubset_11799(T: set, U: set)\n requires T <= U\n ensures |T| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_11800","instance":11800,"id":215143,"goal":"lemma SetUnionCard_11800(S: set, B: set)\n requires S * B == {}\n ensures |S + B| == |S| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_11801","instance":11801,"id":215144,"goal":"lemma SetUnionComm_11801(U: set, A: set)\n ensures U + A == A + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_11802","instance":11802,"id":215145,"goal":"lemma SetInterComm_11802(B: set, S: set)\n ensures B * S == S * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_11803","instance":11803,"id":215146,"goal":"lemma SetUnionAssoc_11803(B: set, T: set, S: set)\n ensures (B + T) + S == B + (T + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_11804","instance":11804,"id":215147,"goal":"lemma SetSubsetRefl_11804(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_11805","instance":11805,"id":215148,"goal":"lemma SetSubsetTrans_11805(A: set, B: set, U: set)\n requires A <= B && B <= U\n ensures A <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_11806","instance":11806,"id":215149,"goal":"lemma SetUnionEmpty_11806(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_11807","instance":11807,"id":215150,"goal":"lemma SetInterEmpty_11807(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_11808","instance":11808,"id":215151,"goal":"lemma SetInterSubset_11808(U: set, B: set)\n ensures U * B <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_11809","instance":11809,"id":215152,"goal":"lemma SetCardSubset_11809(B: set, S: set)\n requires B <= S\n ensures |B| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_11810","instance":11810,"id":215153,"goal":"lemma SetUnionCard_11810(U: set, T: set)\n requires U * T == {}\n ensures |U + T| == |U| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_11811","instance":11811,"id":215154,"goal":"lemma SetUnionComm_11811(U: set, B: set)\n ensures U + B == B + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_11812","instance":11812,"id":215155,"goal":"lemma SetInterComm_11812(T: set, A: set)\n ensures T * A == A * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_11813","instance":11813,"id":215156,"goal":"lemma SetUnionAssoc_11813(A: set, U: set, B: set)\n ensures (A + U) + B == A + (U + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_11814","instance":11814,"id":215157,"goal":"lemma SetSubsetRefl_11814(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_11815","instance":11815,"id":215158,"goal":"lemma SetSubsetTrans_11815(S: set, T: set, A: set)\n requires S <= T && T <= A\n ensures S <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_11816","instance":11816,"id":215159,"goal":"lemma SetUnionEmpty_11816(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_11817","instance":11817,"id":215160,"goal":"lemma SetInterEmpty_11817(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_11818","instance":11818,"id":215161,"goal":"lemma SetInterSubset_11818(T: set, B: set)\n ensures T * B <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_11819","instance":11819,"id":215162,"goal":"lemma SetCardSubset_11819(A: set, S: set)\n requires A <= S\n ensures |A| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_11820","instance":11820,"id":215163,"goal":"lemma SetUnionCard_11820(B: set, U: set)\n requires B * U == {}\n ensures |B + U| == |B| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_11821","instance":11821,"id":215164,"goal":"lemma SetUnionComm_11821(A: set, S: set)\n ensures A + S == S + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_11822","instance":11822,"id":215165,"goal":"lemma SetInterComm_11822(B: set, T: set)\n ensures B * T == T * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_11823","instance":11823,"id":215166,"goal":"lemma SetUnionAssoc_11823(A: set, T: set, B: set)\n ensures (A + T) + B == A + (T + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_11824","instance":11824,"id":215167,"goal":"lemma SetSubsetRefl_11824(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_11825","instance":11825,"id":215168,"goal":"lemma SetSubsetTrans_11825(A: set, U: set, B: set)\n requires A <= U && U <= B\n ensures A <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_11826","instance":11826,"id":215169,"goal":"lemma SetUnionEmpty_11826(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_11827","instance":11827,"id":215170,"goal":"lemma SetInterEmpty_11827(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_11828","instance":11828,"id":215171,"goal":"lemma SetInterSubset_11828(U: set, A: set)\n ensures U * A <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_11829","instance":11829,"id":215172,"goal":"lemma SetCardSubset_11829(T: set, S: set)\n requires T <= S\n ensures |T| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_11830","instance":11830,"id":215173,"goal":"lemma SetUnionCard_11830(B: set, A: set)\n requires B * A == {}\n ensures |B + A| == |B| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_11831","instance":11831,"id":215174,"goal":"lemma SetUnionComm_11831(T: set, B: set)\n ensures T + B == B + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_11832","instance":11832,"id":215175,"goal":"lemma SetInterComm_11832(A: set, B: set)\n ensures A * B == B * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_11833","instance":11833,"id":215176,"goal":"lemma SetUnionAssoc_11833(S: set, U: set, A: set)\n ensures (S + U) + A == S + (U + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_11834","instance":11834,"id":215177,"goal":"lemma SetSubsetRefl_11834(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_11835","instance":11835,"id":215178,"goal":"lemma SetSubsetTrans_11835(A: set, S: set, U: set)\n requires A <= S && S <= U\n ensures A <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_11836","instance":11836,"id":215179,"goal":"lemma SetUnionEmpty_11836(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_11837","instance":11837,"id":215180,"goal":"lemma SetInterEmpty_11837(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_11838","instance":11838,"id":215181,"goal":"lemma SetInterSubset_11838(B: set, S: set)\n ensures B * S <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_11839","instance":11839,"id":215182,"goal":"lemma SetCardSubset_11839(T: set, A: set)\n requires T <= A\n ensures |T| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_11840","instance":11840,"id":215183,"goal":"lemma SetUnionCard_11840(U: set, S: set)\n requires U * S == {}\n ensures |U + S| == |U| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_11841","instance":11841,"id":215184,"goal":"lemma SetUnionComm_11841(B: set, U: set)\n ensures B + U == U + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_11842","instance":11842,"id":215185,"goal":"lemma SetInterComm_11842(U: set, T: set)\n ensures U * T == T * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_11843","instance":11843,"id":215186,"goal":"lemma SetUnionAssoc_11843(U: set, T: set, B: set)\n ensures (U + T) + B == U + (T + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_11844","instance":11844,"id":215187,"goal":"lemma SetSubsetRefl_11844(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_11845","instance":11845,"id":215188,"goal":"lemma SetSubsetTrans_11845(T: set, S: set, B: set)\n requires T <= S && S <= B\n ensures T <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_11846","instance":11846,"id":215189,"goal":"lemma SetUnionEmpty_11846(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_11847","instance":11847,"id":215190,"goal":"lemma SetInterEmpty_11847(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_11848","instance":11848,"id":215191,"goal":"lemma SetInterSubset_11848(T: set, A: set)\n ensures T * A <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_11849","instance":11849,"id":215192,"goal":"lemma SetCardSubset_11849(A: set, U: set)\n requires A <= U\n ensures |A| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_11850","instance":11850,"id":215193,"goal":"lemma SetUnionCard_11850(A: set, T: set)\n requires A * T == {}\n ensures |A + T| == |A| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_11851","instance":11851,"id":215194,"goal":"lemma SetUnionComm_11851(T: set, S: set)\n ensures T + S == S + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_11852","instance":11852,"id":215195,"goal":"lemma SetInterComm_11852(B: set, S: set)\n ensures B * S == S * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_11853","instance":11853,"id":215196,"goal":"lemma SetUnionAssoc_11853(T: set, B: set, U: set)\n ensures (T + B) + U == T + (B + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_11854","instance":11854,"id":215197,"goal":"lemma SetSubsetRefl_11854(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_11855","instance":11855,"id":215198,"goal":"lemma SetSubsetTrans_11855(U: set, T: set, A: set)\n requires U <= T && T <= A\n ensures U <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_11856","instance":11856,"id":215199,"goal":"lemma SetUnionEmpty_11856(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_11857","instance":11857,"id":215200,"goal":"lemma SetInterEmpty_11857(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_11858","instance":11858,"id":215201,"goal":"lemma SetInterSubset_11858(U: set, T: set)\n ensures U * T <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_11859","instance":11859,"id":215202,"goal":"lemma SetCardSubset_11859(B: set, S: set)\n requires B <= S\n ensures |B| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_11860","instance":11860,"id":215203,"goal":"lemma SetUnionCard_11860(S: set, U: set)\n requires S * U == {}\n ensures |S + U| == |S| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_11861","instance":11861,"id":215204,"goal":"lemma SetUnionComm_11861(T: set, U: set)\n ensures T + U == U + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_11862","instance":11862,"id":215205,"goal":"lemma SetInterComm_11862(B: set, T: set)\n ensures B * T == T * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_11863","instance":11863,"id":215206,"goal":"lemma SetUnionAssoc_11863(A: set, T: set, B: set)\n ensures (A + T) + B == A + (T + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_11864","instance":11864,"id":215207,"goal":"lemma SetSubsetRefl_11864(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_11865","instance":11865,"id":215208,"goal":"lemma SetSubsetTrans_11865(S: set, T: set, U: set)\n requires S <= T && T <= U\n ensures S <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_11866","instance":11866,"id":215209,"goal":"lemma SetUnionEmpty_11866(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_11867","instance":11867,"id":215210,"goal":"lemma SetInterEmpty_11867(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_11868","instance":11868,"id":215211,"goal":"lemma SetInterSubset_11868(B: set, A: set)\n ensures B * A <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_11869","instance":11869,"id":215212,"goal":"lemma SetCardSubset_11869(A: set, T: set)\n requires A <= T\n ensures |A| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_11870","instance":11870,"id":215213,"goal":"lemma SetUnionCard_11870(B: set, T: set)\n requires B * T == {}\n ensures |B + T| == |B| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_11871","instance":11871,"id":215214,"goal":"lemma SetUnionComm_11871(T: set, U: set)\n ensures T + U == U + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_11872","instance":11872,"id":215215,"goal":"lemma SetInterComm_11872(T: set, A: set)\n ensures T * A == A * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_11873","instance":11873,"id":215216,"goal":"lemma SetUnionAssoc_11873(U: set, B: set, T: set)\n ensures (U + B) + T == U + (B + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_11874","instance":11874,"id":215217,"goal":"lemma SetSubsetRefl_11874(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_11875","instance":11875,"id":215218,"goal":"lemma SetSubsetTrans_11875(T: set, B: set, A: set)\n requires T <= B && B <= A\n ensures T <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_11876","instance":11876,"id":215219,"goal":"lemma SetUnionEmpty_11876(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_11877","instance":11877,"id":215220,"goal":"lemma SetInterEmpty_11877(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_11878","instance":11878,"id":215221,"goal":"lemma SetInterSubset_11878(A: set, S: set)\n ensures A * S <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_11879","instance":11879,"id":215222,"goal":"lemma SetCardSubset_11879(U: set, B: set)\n requires U <= B\n ensures |U| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_11880","instance":11880,"id":215223,"goal":"lemma SetUnionCard_11880(U: set, T: set)\n requires U * T == {}\n ensures |U + T| == |U| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_11881","instance":11881,"id":215224,"goal":"lemma SetUnionComm_11881(S: set, U: set)\n ensures S + U == U + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_11882","instance":11882,"id":215225,"goal":"lemma SetInterComm_11882(U: set, S: set)\n ensures U * S == S * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_11883","instance":11883,"id":215226,"goal":"lemma SetUnionAssoc_11883(S: set, T: set, U: set)\n ensures (S + T) + U == S + (T + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_11884","instance":11884,"id":215227,"goal":"lemma SetSubsetRefl_11884(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_11885","instance":11885,"id":215228,"goal":"lemma SetSubsetTrans_11885(T: set, S: set, A: set)\n requires T <= S && S <= A\n ensures T <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_11886","instance":11886,"id":215229,"goal":"lemma SetUnionEmpty_11886(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_11887","instance":11887,"id":215230,"goal":"lemma SetInterEmpty_11887(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_11888","instance":11888,"id":215231,"goal":"lemma SetInterSubset_11888(U: set, B: set)\n ensures U * B <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_11889","instance":11889,"id":215232,"goal":"lemma SetCardSubset_11889(U: set, T: set)\n requires U <= T\n ensures |U| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_11890","instance":11890,"id":215233,"goal":"lemma SetUnionCard_11890(S: set, B: set)\n requires S * B == {}\n ensures |S + B| == |S| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_11891","instance":11891,"id":215234,"goal":"lemma SetUnionComm_11891(B: set, U: set)\n ensures B + U == U + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_11892","instance":11892,"id":215235,"goal":"lemma SetInterComm_11892(U: set, A: set)\n ensures U * A == A * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_11893","instance":11893,"id":215236,"goal":"lemma SetUnionAssoc_11893(U: set, T: set, A: set)\n ensures (U + T) + A == U + (T + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_11894","instance":11894,"id":215237,"goal":"lemma SetSubsetRefl_11894(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_11895","instance":11895,"id":215238,"goal":"lemma SetSubsetTrans_11895(T: set, B: set, S: set)\n requires T <= B && B <= S\n ensures T <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_11896","instance":11896,"id":215239,"goal":"lemma SetUnionEmpty_11896(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_11897","instance":11897,"id":215240,"goal":"lemma SetInterEmpty_11897(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_11898","instance":11898,"id":215241,"goal":"lemma SetInterSubset_11898(U: set, A: set)\n ensures U * A <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_11899","instance":11899,"id":215242,"goal":"lemma SetCardSubset_11899(A: set, S: set)\n requires A <= S\n ensures |A| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_11900","instance":11900,"id":215243,"goal":"lemma SetUnionCard_11900(T: set, S: set)\n requires T * S == {}\n ensures |T + S| == |T| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_11901","instance":11901,"id":215244,"goal":"lemma SetUnionComm_11901(A: set, B: set)\n ensures A + B == B + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_11902","instance":11902,"id":215245,"goal":"lemma SetInterComm_11902(A: set, S: set)\n ensures A * S == S * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_11903","instance":11903,"id":215246,"goal":"lemma SetUnionAssoc_11903(A: set, B: set, T: set)\n ensures (A + B) + T == A + (B + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_11904","instance":11904,"id":215247,"goal":"lemma SetSubsetRefl_11904(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_11905","instance":11905,"id":215248,"goal":"lemma SetSubsetTrans_11905(B: set, A: set, S: set)\n requires B <= A && A <= S\n ensures B <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_11906","instance":11906,"id":215249,"goal":"lemma SetUnionEmpty_11906(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_11907","instance":11907,"id":215250,"goal":"lemma SetInterEmpty_11907(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_11908","instance":11908,"id":215251,"goal":"lemma SetInterSubset_11908(T: set, B: set)\n ensures T * B <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_11909","instance":11909,"id":215252,"goal":"lemma SetCardSubset_11909(A: set, B: set)\n requires A <= B\n ensures |A| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_11910","instance":11910,"id":215253,"goal":"lemma SetUnionCard_11910(A: set, T: set)\n requires A * T == {}\n ensures |A + T| == |A| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_11911","instance":11911,"id":215254,"goal":"lemma SetUnionComm_11911(A: set, B: set)\n ensures A + B == B + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_11912","instance":11912,"id":215255,"goal":"lemma SetInterComm_11912(U: set, B: set)\n ensures U * B == B * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_11913","instance":11913,"id":215256,"goal":"lemma SetUnionAssoc_11913(B: set, T: set, U: set)\n ensures (B + T) + U == B + (T + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_11914","instance":11914,"id":215257,"goal":"lemma SetSubsetRefl_11914(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_11915","instance":11915,"id":215258,"goal":"lemma SetSubsetTrans_11915(S: set, T: set, A: set)\n requires S <= T && T <= A\n ensures S <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_11916","instance":11916,"id":215259,"goal":"lemma SetUnionEmpty_11916(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_11917","instance":11917,"id":215260,"goal":"lemma SetInterEmpty_11917(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_11918","instance":11918,"id":215261,"goal":"lemma SetInterSubset_11918(B: set, T: set)\n ensures B * T <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_11919","instance":11919,"id":215262,"goal":"lemma SetCardSubset_11919(A: set, T: set)\n requires A <= T\n ensures |A| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_11920","instance":11920,"id":215263,"goal":"lemma SetUnionCard_11920(S: set, T: set)\n requires S * T == {}\n ensures |S + T| == |S| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_11921","instance":11921,"id":215264,"goal":"lemma SetUnionComm_11921(S: set, U: set)\n ensures S + U == U + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_11922","instance":11922,"id":215265,"goal":"lemma SetInterComm_11922(S: set, B: set)\n ensures S * B == B * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_11923","instance":11923,"id":215266,"goal":"lemma SetUnionAssoc_11923(U: set, T: set, A: set)\n ensures (U + T) + A == U + (T + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_11924","instance":11924,"id":215267,"goal":"lemma SetSubsetRefl_11924(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_11925","instance":11925,"id":215268,"goal":"lemma SetSubsetTrans_11925(U: set, A: set, T: set)\n requires U <= A && A <= T\n ensures U <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_11926","instance":11926,"id":215269,"goal":"lemma SetUnionEmpty_11926(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_11927","instance":11927,"id":215270,"goal":"lemma SetInterEmpty_11927(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_11928","instance":11928,"id":215271,"goal":"lemma SetInterSubset_11928(A: set, U: set)\n ensures A * U <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_11929","instance":11929,"id":215272,"goal":"lemma SetCardSubset_11929(T: set, B: set)\n requires T <= B\n ensures |T| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_11930","instance":11930,"id":215273,"goal":"lemma SetUnionCard_11930(S: set, U: set)\n requires S * U == {}\n ensures |S + U| == |S| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_11931","instance":11931,"id":215274,"goal":"lemma SetUnionComm_11931(S: set, B: set)\n ensures S + B == B + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_11932","instance":11932,"id":215275,"goal":"lemma SetInterComm_11932(T: set, U: set)\n ensures T * U == U * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_11933","instance":11933,"id":215276,"goal":"lemma SetUnionAssoc_11933(S: set, T: set, A: set)\n ensures (S + T) + A == S + (T + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_11934","instance":11934,"id":215277,"goal":"lemma SetSubsetRefl_11934(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_11935","instance":11935,"id":215278,"goal":"lemma SetSubsetTrans_11935(T: set, S: set, A: set)\n requires T <= S && S <= A\n ensures T <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_11936","instance":11936,"id":215279,"goal":"lemma SetUnionEmpty_11936(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_11937","instance":11937,"id":215280,"goal":"lemma SetInterEmpty_11937(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_11938","instance":11938,"id":215281,"goal":"lemma SetInterSubset_11938(U: set, A: set)\n ensures U * A <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_11939","instance":11939,"id":215282,"goal":"lemma SetCardSubset_11939(T: set, S: set)\n requires T <= S\n ensures |T| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_11940","instance":11940,"id":215283,"goal":"lemma SetUnionCard_11940(T: set, B: set)\n requires T * B == {}\n ensures |T + B| == |T| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_11941","instance":11941,"id":215284,"goal":"lemma SetUnionComm_11941(A: set, S: set)\n ensures A + S == S + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_11942","instance":11942,"id":215285,"goal":"lemma SetInterComm_11942(S: set, U: set)\n ensures S * U == U * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_11943","instance":11943,"id":215286,"goal":"lemma SetUnionAssoc_11943(A: set, U: set, T: set)\n ensures (A + U) + T == A + (U + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_11944","instance":11944,"id":215287,"goal":"lemma SetSubsetRefl_11944(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_11945","instance":11945,"id":215288,"goal":"lemma SetSubsetTrans_11945(U: set, T: set, B: set)\n requires U <= T && T <= B\n ensures U <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_11946","instance":11946,"id":215289,"goal":"lemma SetUnionEmpty_11946(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_11947","instance":11947,"id":215290,"goal":"lemma SetInterEmpty_11947(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_11948","instance":11948,"id":215291,"goal":"lemma SetInterSubset_11948(S: set, A: set)\n ensures S * A <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_11949","instance":11949,"id":215292,"goal":"lemma SetCardSubset_11949(S: set, T: set)\n requires S <= T\n ensures |S| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_11950","instance":11950,"id":215293,"goal":"lemma SetUnionCard_11950(S: set, A: set)\n requires S * A == {}\n ensures |S + A| == |S| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_11951","instance":11951,"id":215294,"goal":"lemma SetUnionComm_11951(B: set, S: set)\n ensures B + S == S + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_11952","instance":11952,"id":215295,"goal":"lemma SetInterComm_11952(T: set, U: set)\n ensures T * U == U * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_11953","instance":11953,"id":215296,"goal":"lemma SetUnionAssoc_11953(U: set, S: set, A: set)\n ensures (U + S) + A == U + (S + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_11954","instance":11954,"id":215297,"goal":"lemma SetSubsetRefl_11954(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_11955","instance":11955,"id":215298,"goal":"lemma SetSubsetTrans_11955(U: set, S: set, T: set)\n requires U <= S && S <= T\n ensures U <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_11956","instance":11956,"id":215299,"goal":"lemma SetUnionEmpty_11956(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_11957","instance":11957,"id":215300,"goal":"lemma SetInterEmpty_11957(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_11958","instance":11958,"id":215301,"goal":"lemma SetInterSubset_11958(B: set, S: set)\n ensures B * S <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_11959","instance":11959,"id":215302,"goal":"lemma SetCardSubset_11959(A: set, B: set)\n requires A <= B\n ensures |A| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_11960","instance":11960,"id":215303,"goal":"lemma SetUnionCard_11960(B: set, A: set)\n requires B * A == {}\n ensures |B + A| == |B| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_11961","instance":11961,"id":215304,"goal":"lemma SetUnionComm_11961(A: set, T: set)\n ensures A + T == T + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_11962","instance":11962,"id":215305,"goal":"lemma SetInterComm_11962(S: set, A: set)\n ensures S * A == A * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_11963","instance":11963,"id":215306,"goal":"lemma SetUnionAssoc_11963(B: set, U: set, S: set)\n ensures (B + U) + S == B + (U + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_11964","instance":11964,"id":215307,"goal":"lemma SetSubsetRefl_11964(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_11965","instance":11965,"id":215308,"goal":"lemma SetSubsetTrans_11965(U: set, B: set, S: set)\n requires U <= B && B <= S\n ensures U <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_11966","instance":11966,"id":215309,"goal":"lemma SetUnionEmpty_11966(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_11967","instance":11967,"id":215310,"goal":"lemma SetInterEmpty_11967(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_11968","instance":11968,"id":215311,"goal":"lemma SetInterSubset_11968(S: set, U: set)\n ensures S * U <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_11969","instance":11969,"id":215312,"goal":"lemma SetCardSubset_11969(S: set, U: set)\n requires S <= U\n ensures |S| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_11970","instance":11970,"id":215313,"goal":"lemma SetUnionCard_11970(A: set, U: set)\n requires A * U == {}\n ensures |A + U| == |A| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_11971","instance":11971,"id":215314,"goal":"lemma SetUnionComm_11971(T: set, B: set)\n ensures T + B == B + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_11972","instance":11972,"id":215315,"goal":"lemma SetInterComm_11972(U: set, A: set)\n ensures U * A == A * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_11973","instance":11973,"id":215316,"goal":"lemma SetUnionAssoc_11973(U: set, B: set, S: set)\n ensures (U + B) + S == U + (B + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_11974","instance":11974,"id":215317,"goal":"lemma SetSubsetRefl_11974(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_11975","instance":11975,"id":215318,"goal":"lemma SetSubsetTrans_11975(A: set, S: set, B: set)\n requires A <= S && S <= B\n ensures A <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_11976","instance":11976,"id":215319,"goal":"lemma SetUnionEmpty_11976(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_11977","instance":11977,"id":215320,"goal":"lemma SetInterEmpty_11977(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_11978","instance":11978,"id":215321,"goal":"lemma SetInterSubset_11978(T: set, U: set)\n ensures T * U <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_11979","instance":11979,"id":215322,"goal":"lemma SetCardSubset_11979(T: set, U: set)\n requires T <= U\n ensures |T| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_11980","instance":11980,"id":215323,"goal":"lemma SetUnionCard_11980(A: set, U: set)\n requires A * U == {}\n ensures |A + U| == |A| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_11981","instance":11981,"id":215324,"goal":"lemma SetUnionComm_11981(S: set, A: set)\n ensures S + A == A + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_11982","instance":11982,"id":215325,"goal":"lemma SetInterComm_11982(U: set, A: set)\n ensures U * A == A * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_11983","instance":11983,"id":215326,"goal":"lemma SetUnionAssoc_11983(A: set, S: set, B: set)\n ensures (A + S) + B == A + (S + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_11984","instance":11984,"id":215327,"goal":"lemma SetSubsetRefl_11984(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_11985","instance":11985,"id":215328,"goal":"lemma SetSubsetTrans_11985(U: set, B: set, T: set)\n requires U <= B && B <= T\n ensures U <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_11986","instance":11986,"id":215329,"goal":"lemma SetUnionEmpty_11986(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_11987","instance":11987,"id":215330,"goal":"lemma SetInterEmpty_11987(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_11988","instance":11988,"id":215331,"goal":"lemma SetInterSubset_11988(U: set, A: set)\n ensures U * A <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_11989","instance":11989,"id":215332,"goal":"lemma SetCardSubset_11989(S: set, A: set)\n requires S <= A\n ensures |S| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_11990","instance":11990,"id":215333,"goal":"lemma SetUnionCard_11990(S: set, B: set)\n requires S * B == {}\n ensures |S + B| == |S| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_11991","instance":11991,"id":215334,"goal":"lemma SetUnionComm_11991(U: set, A: set)\n ensures U + A == A + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_11992","instance":11992,"id":215335,"goal":"lemma SetInterComm_11992(T: set, A: set)\n ensures T * A == A * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_11993","instance":11993,"id":215336,"goal":"lemma SetUnionAssoc_11993(S: set, B: set, U: set)\n ensures (S + B) + U == S + (B + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_11994","instance":11994,"id":215337,"goal":"lemma SetSubsetRefl_11994(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_11995","instance":11995,"id":215338,"goal":"lemma SetSubsetTrans_11995(T: set, A: set, U: set)\n requires T <= A && A <= U\n ensures T <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_11996","instance":11996,"id":215339,"goal":"lemma SetUnionEmpty_11996(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_11997","instance":11997,"id":215340,"goal":"lemma SetInterEmpty_11997(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_11998","instance":11998,"id":215341,"goal":"lemma SetInterSubset_11998(A: set, S: set)\n ensures A * S <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_11999","instance":11999,"id":215342,"goal":"lemma SetCardSubset_11999(S: set, A: set)\n requires S <= A\n ensures |S| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_12000","instance":12000,"id":215343,"goal":"lemma SetUnionCard_12000(U: set, S: set)\n requires U * S == {}\n ensures |U + S| == |U| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_12001","instance":12001,"id":215344,"goal":"lemma SetUnionComm_12001(A: set, S: set)\n ensures A + S == S + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_12002","instance":12002,"id":215345,"goal":"lemma SetInterComm_12002(U: set, T: set)\n ensures U * T == T * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_12003","instance":12003,"id":215346,"goal":"lemma SetUnionAssoc_12003(U: set, T: set, B: set)\n ensures (U + T) + B == U + (T + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_12004","instance":12004,"id":215347,"goal":"lemma SetSubsetRefl_12004(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_12005","instance":12005,"id":215348,"goal":"lemma SetSubsetTrans_12005(S: set, T: set, A: set)\n requires S <= T && T <= A\n ensures S <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_12006","instance":12006,"id":215349,"goal":"lemma SetUnionEmpty_12006(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_12007","instance":12007,"id":215350,"goal":"lemma SetInterEmpty_12007(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_12008","instance":12008,"id":215351,"goal":"lemma SetInterSubset_12008(B: set, U: set)\n ensures B * U <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_12009","instance":12009,"id":215352,"goal":"lemma SetCardSubset_12009(T: set, U: set)\n requires T <= U\n ensures |T| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_12010","instance":12010,"id":215353,"goal":"lemma SetUnionCard_12010(U: set, A: set)\n requires U * A == {}\n ensures |U + A| == |U| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_12011","instance":12011,"id":215354,"goal":"lemma SetUnionComm_12011(T: set, S: set)\n ensures T + S == S + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_12012","instance":12012,"id":215355,"goal":"lemma SetInterComm_12012(A: set, S: set)\n ensures A * S == S * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_12013","instance":12013,"id":215356,"goal":"lemma SetUnionAssoc_12013(U: set, B: set, S: set)\n ensures (U + B) + S == U + (B + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_12014","instance":12014,"id":215357,"goal":"lemma SetSubsetRefl_12014(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_12015","instance":12015,"id":215358,"goal":"lemma SetSubsetTrans_12015(U: set, T: set, A: set)\n requires U <= T && T <= A\n ensures U <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_12016","instance":12016,"id":215359,"goal":"lemma SetUnionEmpty_12016(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_12017","instance":12017,"id":215360,"goal":"lemma SetInterEmpty_12017(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_12018","instance":12018,"id":215361,"goal":"lemma SetInterSubset_12018(U: set, B: set)\n ensures U * B <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_12019","instance":12019,"id":215362,"goal":"lemma SetCardSubset_12019(S: set, A: set)\n requires S <= A\n ensures |S| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_12020","instance":12020,"id":215363,"goal":"lemma SetUnionCard_12020(T: set, B: set)\n requires T * B == {}\n ensures |T + B| == |T| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_12021","instance":12021,"id":215364,"goal":"lemma SetUnionComm_12021(A: set, U: set)\n ensures A + U == U + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_12022","instance":12022,"id":215365,"goal":"lemma SetInterComm_12022(T: set, S: set)\n ensures T * S == S * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_12023","instance":12023,"id":215366,"goal":"lemma SetUnionAssoc_12023(U: set, S: set, A: set)\n ensures (U + S) + A == U + (S + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_12024","instance":12024,"id":215367,"goal":"lemma SetSubsetRefl_12024(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_12025","instance":12025,"id":215368,"goal":"lemma SetSubsetTrans_12025(B: set, T: set, A: set)\n requires B <= T && T <= A\n ensures B <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_12026","instance":12026,"id":215369,"goal":"lemma SetUnionEmpty_12026(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_12027","instance":12027,"id":215370,"goal":"lemma SetInterEmpty_12027(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_12028","instance":12028,"id":215371,"goal":"lemma SetInterSubset_12028(T: set, B: set)\n ensures T * B <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_12029","instance":12029,"id":215372,"goal":"lemma SetCardSubset_12029(T: set, A: set)\n requires T <= A\n ensures |T| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_12030","instance":12030,"id":215373,"goal":"lemma SetUnionCard_12030(A: set, B: set)\n requires A * B == {}\n ensures |A + B| == |A| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_12031","instance":12031,"id":215374,"goal":"lemma SetUnionComm_12031(S: set, U: set)\n ensures S + U == U + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_12032","instance":12032,"id":215375,"goal":"lemma SetInterComm_12032(A: set, U: set)\n ensures A * U == U * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_12033","instance":12033,"id":215376,"goal":"lemma SetUnionAssoc_12033(S: set, B: set, T: set)\n ensures (S + B) + T == S + (B + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_12034","instance":12034,"id":215377,"goal":"lemma SetSubsetRefl_12034(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_12035","instance":12035,"id":215378,"goal":"lemma SetSubsetTrans_12035(S: set, A: set, U: set)\n requires S <= A && A <= U\n ensures S <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_12036","instance":12036,"id":215379,"goal":"lemma SetUnionEmpty_12036(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_12037","instance":12037,"id":215380,"goal":"lemma SetInterEmpty_12037(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_12038","instance":12038,"id":215381,"goal":"lemma SetInterSubset_12038(B: set, U: set)\n ensures B * U <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_12039","instance":12039,"id":215382,"goal":"lemma SetCardSubset_12039(T: set, A: set)\n requires T <= A\n ensures |T| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_12040","instance":12040,"id":215383,"goal":"lemma SetUnionCard_12040(S: set, T: set)\n requires S * T == {}\n ensures |S + T| == |S| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_12041","instance":12041,"id":215384,"goal":"lemma SetUnionComm_12041(A: set, T: set)\n ensures A + T == T + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_12042","instance":12042,"id":215385,"goal":"lemma SetInterComm_12042(B: set, U: set)\n ensures B * U == U * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_12043","instance":12043,"id":215386,"goal":"lemma SetUnionAssoc_12043(S: set, T: set, A: set)\n ensures (S + T) + A == S + (T + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_12044","instance":12044,"id":215387,"goal":"lemma SetSubsetRefl_12044(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_12045","instance":12045,"id":215388,"goal":"lemma SetSubsetTrans_12045(T: set, A: set, S: set)\n requires T <= A && A <= S\n ensures T <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_12046","instance":12046,"id":215389,"goal":"lemma SetUnionEmpty_12046(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_12047","instance":12047,"id":215390,"goal":"lemma SetInterEmpty_12047(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_12048","instance":12048,"id":215391,"goal":"lemma SetInterSubset_12048(T: set, U: set)\n ensures T * U <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_12049","instance":12049,"id":215392,"goal":"lemma SetCardSubset_12049(A: set, B: set)\n requires A <= B\n ensures |A| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_12050","instance":12050,"id":215393,"goal":"lemma SetUnionCard_12050(B: set, S: set)\n requires B * S == {}\n ensures |B + S| == |B| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_12051","instance":12051,"id":215394,"goal":"lemma SetUnionComm_12051(S: set, A: set)\n ensures S + A == A + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_12052","instance":12052,"id":215395,"goal":"lemma SetInterComm_12052(A: set, U: set)\n ensures A * U == U * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_12053","instance":12053,"id":215396,"goal":"lemma SetUnionAssoc_12053(A: set, U: set, T: set)\n ensures (A + U) + T == A + (U + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_12054","instance":12054,"id":215397,"goal":"lemma SetSubsetRefl_12054(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_12055","instance":12055,"id":215398,"goal":"lemma SetSubsetTrans_12055(U: set, T: set, S: set)\n requires U <= T && T <= S\n ensures U <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_12056","instance":12056,"id":215399,"goal":"lemma SetUnionEmpty_12056(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_12057","instance":12057,"id":215400,"goal":"lemma SetInterEmpty_12057(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_12058","instance":12058,"id":215401,"goal":"lemma SetInterSubset_12058(S: set, U: set)\n ensures S * U <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_12059","instance":12059,"id":215402,"goal":"lemma SetCardSubset_12059(U: set, T: set)\n requires U <= T\n ensures |U| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_12060","instance":12060,"id":215403,"goal":"lemma SetUnionCard_12060(B: set, U: set)\n requires B * U == {}\n ensures |B + U| == |B| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_12061","instance":12061,"id":215404,"goal":"lemma SetUnionComm_12061(A: set, S: set)\n ensures A + S == S + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_12062","instance":12062,"id":215405,"goal":"lemma SetInterComm_12062(A: set, S: set)\n ensures A * S == S * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_12063","instance":12063,"id":215406,"goal":"lemma SetUnionAssoc_12063(U: set, S: set, T: set)\n ensures (U + S) + T == U + (S + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_12064","instance":12064,"id":215407,"goal":"lemma SetSubsetRefl_12064(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_12065","instance":12065,"id":215408,"goal":"lemma SetSubsetTrans_12065(U: set, B: set, A: set)\n requires U <= B && B <= A\n ensures U <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_12066","instance":12066,"id":215409,"goal":"lemma SetUnionEmpty_12066(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_12067","instance":12067,"id":215410,"goal":"lemma SetInterEmpty_12067(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_12068","instance":12068,"id":215411,"goal":"lemma SetInterSubset_12068(U: set, T: set)\n ensures U * T <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_12069","instance":12069,"id":215412,"goal":"lemma SetCardSubset_12069(U: set, S: set)\n requires U <= S\n ensures |U| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_12070","instance":12070,"id":215413,"goal":"lemma SetUnionCard_12070(S: set, B: set)\n requires S * B == {}\n ensures |S + B| == |S| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_12071","instance":12071,"id":215414,"goal":"lemma SetUnionComm_12071(A: set, S: set)\n ensures A + S == S + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_12072","instance":12072,"id":215415,"goal":"lemma SetInterComm_12072(S: set, T: set)\n ensures S * T == T * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_12073","instance":12073,"id":215416,"goal":"lemma SetUnionAssoc_12073(U: set, T: set, B: set)\n ensures (U + T) + B == U + (T + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_12074","instance":12074,"id":215417,"goal":"lemma SetSubsetRefl_12074(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_12075","instance":12075,"id":215418,"goal":"lemma SetSubsetTrans_12075(T: set, A: set, U: set)\n requires T <= A && A <= U\n ensures T <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_12076","instance":12076,"id":215419,"goal":"lemma SetUnionEmpty_12076(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_12077","instance":12077,"id":215420,"goal":"lemma SetInterEmpty_12077(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_12078","instance":12078,"id":215421,"goal":"lemma SetInterSubset_12078(B: set, T: set)\n ensures B * T <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_12079","instance":12079,"id":215422,"goal":"lemma SetCardSubset_12079(B: set, A: set)\n requires B <= A\n ensures |B| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_12080","instance":12080,"id":215423,"goal":"lemma SetUnionCard_12080(U: set, A: set)\n requires U * A == {}\n ensures |U + A| == |U| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_12081","instance":12081,"id":215424,"goal":"lemma SetUnionComm_12081(T: set, U: set)\n ensures T + U == U + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_12082","instance":12082,"id":215425,"goal":"lemma SetInterComm_12082(B: set, S: set)\n ensures B * S == S * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_12083","instance":12083,"id":215426,"goal":"lemma SetUnionAssoc_12083(B: set, S: set, A: set)\n ensures (B + S) + A == B + (S + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_12084","instance":12084,"id":215427,"goal":"lemma SetSubsetRefl_12084(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_12085","instance":12085,"id":215428,"goal":"lemma SetSubsetTrans_12085(S: set, A: set, U: set)\n requires S <= A && A <= U\n ensures S <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_12086","instance":12086,"id":215429,"goal":"lemma SetUnionEmpty_12086(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_12087","instance":12087,"id":215430,"goal":"lemma SetInterEmpty_12087(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_12088","instance":12088,"id":215431,"goal":"lemma SetInterSubset_12088(B: set, T: set)\n ensures B * T <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_12089","instance":12089,"id":215432,"goal":"lemma SetCardSubset_12089(B: set, T: set)\n requires B <= T\n ensures |B| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_12090","instance":12090,"id":215433,"goal":"lemma SetUnionCard_12090(S: set, A: set)\n requires S * A == {}\n ensures |S + A| == |S| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_12091","instance":12091,"id":215434,"goal":"lemma SetUnionComm_12091(S: set, A: set)\n ensures S + A == A + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_12092","instance":12092,"id":215435,"goal":"lemma SetInterComm_12092(S: set, A: set)\n ensures S * A == A * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_12093","instance":12093,"id":215436,"goal":"lemma SetUnionAssoc_12093(T: set, B: set, A: set)\n ensures (T + B) + A == T + (B + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_12094","instance":12094,"id":215437,"goal":"lemma SetSubsetRefl_12094(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_12095","instance":12095,"id":215438,"goal":"lemma SetSubsetTrans_12095(U: set, A: set, S: set)\n requires U <= A && A <= S\n ensures U <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_12096","instance":12096,"id":215439,"goal":"lemma SetUnionEmpty_12096(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_12097","instance":12097,"id":215440,"goal":"lemma SetInterEmpty_12097(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_12098","instance":12098,"id":215441,"goal":"lemma SetInterSubset_12098(S: set, U: set)\n ensures S * U <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_12099","instance":12099,"id":215442,"goal":"lemma SetCardSubset_12099(T: set, S: set)\n requires T <= S\n ensures |T| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_12100","instance":12100,"id":215443,"goal":"lemma SetUnionCard_12100(U: set, T: set)\n requires U * T == {}\n ensures |U + T| == |U| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_12101","instance":12101,"id":215444,"goal":"lemma SetUnionComm_12101(S: set, U: set)\n ensures S + U == U + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_12102","instance":12102,"id":215445,"goal":"lemma SetInterComm_12102(U: set, B: set)\n ensures U * B == B * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_12103","instance":12103,"id":215446,"goal":"lemma SetUnionAssoc_12103(S: set, B: set, T: set)\n ensures (S + B) + T == S + (B + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_12104","instance":12104,"id":215447,"goal":"lemma SetSubsetRefl_12104(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_12105","instance":12105,"id":215448,"goal":"lemma SetSubsetTrans_12105(A: set, S: set, T: set)\n requires A <= S && S <= T\n ensures A <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_12106","instance":12106,"id":215449,"goal":"lemma SetUnionEmpty_12106(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_12107","instance":12107,"id":215450,"goal":"lemma SetInterEmpty_12107(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_12108","instance":12108,"id":215451,"goal":"lemma SetInterSubset_12108(U: set, A: set)\n ensures U * A <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_12109","instance":12109,"id":215452,"goal":"lemma SetCardSubset_12109(T: set, U: set)\n requires T <= U\n ensures |T| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_12110","instance":12110,"id":215453,"goal":"lemma SetUnionCard_12110(B: set, T: set)\n requires B * T == {}\n ensures |B + T| == |B| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_12111","instance":12111,"id":215454,"goal":"lemma SetUnionComm_12111(U: set, T: set)\n ensures U + T == T + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_12112","instance":12112,"id":215455,"goal":"lemma SetInterComm_12112(S: set, A: set)\n ensures S * A == A * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_12113","instance":12113,"id":215456,"goal":"lemma SetUnionAssoc_12113(A: set, U: set, T: set)\n ensures (A + U) + T == A + (U + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_12114","instance":12114,"id":215457,"goal":"lemma SetSubsetRefl_12114(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_12115","instance":12115,"id":215458,"goal":"lemma SetSubsetTrans_12115(B: set, U: set, T: set)\n requires B <= U && U <= T\n ensures B <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_12116","instance":12116,"id":215459,"goal":"lemma SetUnionEmpty_12116(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_12117","instance":12117,"id":215460,"goal":"lemma SetInterEmpty_12117(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_12118","instance":12118,"id":215461,"goal":"lemma SetInterSubset_12118(A: set, B: set)\n ensures A * B <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_12119","instance":12119,"id":215462,"goal":"lemma SetCardSubset_12119(S: set, A: set)\n requires S <= A\n ensures |S| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_12120","instance":12120,"id":215463,"goal":"lemma SetUnionCard_12120(S: set, T: set)\n requires S * T == {}\n ensures |S + T| == |S| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_12121","instance":12121,"id":215464,"goal":"lemma SetUnionComm_12121(T: set, A: set)\n ensures T + A == A + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_12122","instance":12122,"id":215465,"goal":"lemma SetInterComm_12122(U: set, A: set)\n ensures U * A == A * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_12123","instance":12123,"id":215466,"goal":"lemma SetUnionAssoc_12123(T: set, U: set, S: set)\n ensures (T + U) + S == T + (U + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_12124","instance":12124,"id":215467,"goal":"lemma SetSubsetRefl_12124(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_12125","instance":12125,"id":215468,"goal":"lemma SetSubsetTrans_12125(B: set, S: set, T: set)\n requires B <= S && S <= T\n ensures B <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_12126","instance":12126,"id":215469,"goal":"lemma SetUnionEmpty_12126(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_12127","instance":12127,"id":215470,"goal":"lemma SetInterEmpty_12127(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_12128","instance":12128,"id":215471,"goal":"lemma SetInterSubset_12128(T: set, U: set)\n ensures T * U <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_12129","instance":12129,"id":215472,"goal":"lemma SetCardSubset_12129(U: set, S: set)\n requires U <= S\n ensures |U| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_12130","instance":12130,"id":215473,"goal":"lemma SetUnionCard_12130(U: set, T: set)\n requires U * T == {}\n ensures |U + T| == |U| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_12131","instance":12131,"id":215474,"goal":"lemma SetUnionComm_12131(U: set, T: set)\n ensures U + T == T + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_12132","instance":12132,"id":215475,"goal":"lemma SetInterComm_12132(T: set, A: set)\n ensures T * A == A * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_12133","instance":12133,"id":215476,"goal":"lemma SetUnionAssoc_12133(T: set, U: set, B: set)\n ensures (T + U) + B == T + (U + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_12134","instance":12134,"id":215477,"goal":"lemma SetSubsetRefl_12134(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_12135","instance":12135,"id":215478,"goal":"lemma SetSubsetTrans_12135(S: set, A: set, U: set)\n requires S <= A && A <= U\n ensures S <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_12136","instance":12136,"id":215479,"goal":"lemma SetUnionEmpty_12136(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_12137","instance":12137,"id":215480,"goal":"lemma SetInterEmpty_12137(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_12138","instance":12138,"id":215481,"goal":"lemma SetInterSubset_12138(B: set, T: set)\n ensures B * T <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_12139","instance":12139,"id":215482,"goal":"lemma SetCardSubset_12139(A: set, S: set)\n requires A <= S\n ensures |A| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_12140","instance":12140,"id":215483,"goal":"lemma SetUnionCard_12140(A: set, T: set)\n requires A * T == {}\n ensures |A + T| == |A| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_12141","instance":12141,"id":215484,"goal":"lemma SetUnionComm_12141(A: set, B: set)\n ensures A + B == B + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_12142","instance":12142,"id":215485,"goal":"lemma SetInterComm_12142(B: set, S: set)\n ensures B * S == S * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_12143","instance":12143,"id":215486,"goal":"lemma SetUnionAssoc_12143(B: set, T: set, S: set)\n ensures (B + T) + S == B + (T + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_12144","instance":12144,"id":215487,"goal":"lemma SetSubsetRefl_12144(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_12145","instance":12145,"id":215488,"goal":"lemma SetSubsetTrans_12145(U: set, B: set, A: set)\n requires U <= B && B <= A\n ensures U <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_12146","instance":12146,"id":215489,"goal":"lemma SetUnionEmpty_12146(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_12147","instance":12147,"id":215490,"goal":"lemma SetInterEmpty_12147(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_12148","instance":12148,"id":215491,"goal":"lemma SetInterSubset_12148(B: set, T: set)\n ensures B * T <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_12149","instance":12149,"id":215492,"goal":"lemma SetCardSubset_12149(U: set, A: set)\n requires U <= A\n ensures |U| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_12150","instance":12150,"id":215493,"goal":"lemma SetUnionCard_12150(U: set, B: set)\n requires U * B == {}\n ensures |U + B| == |U| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_12151","instance":12151,"id":215494,"goal":"lemma SetUnionComm_12151(T: set, S: set)\n ensures T + S == S + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_12152","instance":12152,"id":215495,"goal":"lemma SetInterComm_12152(S: set, T: set)\n ensures S * T == T * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_12153","instance":12153,"id":215496,"goal":"lemma SetUnionAssoc_12153(U: set, S: set, B: set)\n ensures (U + S) + B == U + (S + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_12154","instance":12154,"id":215497,"goal":"lemma SetSubsetRefl_12154(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_12155","instance":12155,"id":215498,"goal":"lemma SetSubsetTrans_12155(T: set, S: set, B: set)\n requires T <= S && S <= B\n ensures T <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_12156","instance":12156,"id":215499,"goal":"lemma SetUnionEmpty_12156(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_12157","instance":12157,"id":215500,"goal":"lemma SetInterEmpty_12157(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_12158","instance":12158,"id":215501,"goal":"lemma SetInterSubset_12158(S: set, U: set)\n ensures S * U <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_12159","instance":12159,"id":215502,"goal":"lemma SetCardSubset_12159(U: set, S: set)\n requires U <= S\n ensures |U| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_12160","instance":12160,"id":215503,"goal":"lemma SetUnionCard_12160(T: set, S: set)\n requires T * S == {}\n ensures |T + S| == |T| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_12161","instance":12161,"id":215504,"goal":"lemma SetUnionComm_12161(A: set, T: set)\n ensures A + T == T + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_12162","instance":12162,"id":215505,"goal":"lemma SetInterComm_12162(A: set, T: set)\n ensures A * T == T * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_12163","instance":12163,"id":215506,"goal":"lemma SetUnionAssoc_12163(B: set, T: set, A: set)\n ensures (B + T) + A == B + (T + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_12164","instance":12164,"id":215507,"goal":"lemma SetSubsetRefl_12164(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_12165","instance":12165,"id":215508,"goal":"lemma SetSubsetTrans_12165(T: set, A: set, S: set)\n requires T <= A && A <= S\n ensures T <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_12166","instance":12166,"id":215509,"goal":"lemma SetUnionEmpty_12166(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_12167","instance":12167,"id":215510,"goal":"lemma SetInterEmpty_12167(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_12168","instance":12168,"id":215511,"goal":"lemma SetInterSubset_12168(T: set, A: set)\n ensures T * A <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_12169","instance":12169,"id":215512,"goal":"lemma SetCardSubset_12169(U: set, B: set)\n requires U <= B\n ensures |U| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_12170","instance":12170,"id":215513,"goal":"lemma SetUnionCard_12170(U: set, S: set)\n requires U * S == {}\n ensures |U + S| == |U| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_12171","instance":12171,"id":215514,"goal":"lemma SetUnionComm_12171(A: set, T: set)\n ensures A + T == T + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_12172","instance":12172,"id":215515,"goal":"lemma SetInterComm_12172(S: set, U: set)\n ensures S * U == U * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_12173","instance":12173,"id":215516,"goal":"lemma SetUnionAssoc_12173(B: set, A: set, S: set)\n ensures (B + A) + S == B + (A + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_12174","instance":12174,"id":215517,"goal":"lemma SetSubsetRefl_12174(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_12175","instance":12175,"id":215518,"goal":"lemma SetSubsetTrans_12175(T: set, U: set, S: set)\n requires T <= U && U <= S\n ensures T <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_12176","instance":12176,"id":215519,"goal":"lemma SetUnionEmpty_12176(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_12177","instance":12177,"id":215520,"goal":"lemma SetInterEmpty_12177(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_12178","instance":12178,"id":215521,"goal":"lemma SetInterSubset_12178(S: set, B: set)\n ensures S * B <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_12179","instance":12179,"id":215522,"goal":"lemma SetCardSubset_12179(B: set, U: set)\n requires B <= U\n ensures |B| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_12180","instance":12180,"id":215523,"goal":"lemma SetUnionCard_12180(B: set, S: set)\n requires B * S == {}\n ensures |B + S| == |B| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_12181","instance":12181,"id":215524,"goal":"lemma SetUnionComm_12181(T: set, A: set)\n ensures T + A == A + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_12182","instance":12182,"id":215525,"goal":"lemma SetInterComm_12182(A: set, U: set)\n ensures A * U == U * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_12183","instance":12183,"id":215526,"goal":"lemma SetUnionAssoc_12183(T: set, S: set, A: set)\n ensures (T + S) + A == T + (S + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_12184","instance":12184,"id":215527,"goal":"lemma SetSubsetRefl_12184(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_12185","instance":12185,"id":215528,"goal":"lemma SetSubsetTrans_12185(B: set, T: set, S: set)\n requires B <= T && T <= S\n ensures B <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_12186","instance":12186,"id":215529,"goal":"lemma SetUnionEmpty_12186(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_12187","instance":12187,"id":215530,"goal":"lemma SetInterEmpty_12187(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_12188","instance":12188,"id":215531,"goal":"lemma SetInterSubset_12188(T: set, S: set)\n ensures T * S <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_12189","instance":12189,"id":215532,"goal":"lemma SetCardSubset_12189(T: set, B: set)\n requires T <= B\n ensures |T| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_12190","instance":12190,"id":215533,"goal":"lemma SetUnionCard_12190(U: set, S: set)\n requires U * S == {}\n ensures |U + S| == |U| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_12191","instance":12191,"id":215534,"goal":"lemma SetUnionComm_12191(A: set, S: set)\n ensures A + S == S + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_12192","instance":12192,"id":215535,"goal":"lemma SetInterComm_12192(S: set, A: set)\n ensures S * A == A * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_12193","instance":12193,"id":215536,"goal":"lemma SetUnionAssoc_12193(A: set, S: set, T: set)\n ensures (A + S) + T == A + (S + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_12194","instance":12194,"id":215537,"goal":"lemma SetSubsetRefl_12194(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_12195","instance":12195,"id":215538,"goal":"lemma SetSubsetTrans_12195(S: set, T: set, A: set)\n requires S <= T && T <= A\n ensures S <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_12196","instance":12196,"id":215539,"goal":"lemma SetUnionEmpty_12196(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_12197","instance":12197,"id":215540,"goal":"lemma SetInterEmpty_12197(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_12198","instance":12198,"id":215541,"goal":"lemma SetInterSubset_12198(B: set, A: set)\n ensures B * A <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_12199","instance":12199,"id":215542,"goal":"lemma SetCardSubset_12199(A: set, U: set)\n requires A <= U\n ensures |A| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_12200","instance":12200,"id":215543,"goal":"lemma SetUnionCard_12200(U: set, B: set)\n requires U * B == {}\n ensures |U + B| == |U| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_12201","instance":12201,"id":215544,"goal":"lemma SetUnionComm_12201(S: set, T: set)\n ensures S + T == T + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_12202","instance":12202,"id":215545,"goal":"lemma SetInterComm_12202(S: set, A: set)\n ensures S * A == A * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_12203","instance":12203,"id":215546,"goal":"lemma SetUnionAssoc_12203(A: set, S: set, B: set)\n ensures (A + S) + B == A + (S + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_12204","instance":12204,"id":215547,"goal":"lemma SetSubsetRefl_12204(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_12205","instance":12205,"id":215548,"goal":"lemma SetSubsetTrans_12205(U: set, S: set, B: set)\n requires U <= S && S <= B\n ensures U <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_12206","instance":12206,"id":215549,"goal":"lemma SetUnionEmpty_12206(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_12207","instance":12207,"id":215550,"goal":"lemma SetInterEmpty_12207(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_12208","instance":12208,"id":215551,"goal":"lemma SetInterSubset_12208(B: set, A: set)\n ensures B * A <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_12209","instance":12209,"id":215552,"goal":"lemma SetCardSubset_12209(B: set, U: set)\n requires B <= U\n ensures |B| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_12210","instance":12210,"id":215553,"goal":"lemma SetUnionCard_12210(B: set, T: set)\n requires B * T == {}\n ensures |B + T| == |B| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_12211","instance":12211,"id":215554,"goal":"lemma SetUnionComm_12211(T: set, S: set)\n ensures T + S == S + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_12212","instance":12212,"id":215555,"goal":"lemma SetInterComm_12212(S: set, B: set)\n ensures S * B == B * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_12213","instance":12213,"id":215556,"goal":"lemma SetUnionAssoc_12213(S: set, U: set, A: set)\n ensures (S + U) + A == S + (U + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_12214","instance":12214,"id":215557,"goal":"lemma SetSubsetRefl_12214(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_12215","instance":12215,"id":215558,"goal":"lemma SetSubsetTrans_12215(T: set, A: set, B: set)\n requires T <= A && A <= B\n ensures T <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_12216","instance":12216,"id":215559,"goal":"lemma SetUnionEmpty_12216(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_12217","instance":12217,"id":215560,"goal":"lemma SetInterEmpty_12217(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_12218","instance":12218,"id":215561,"goal":"lemma SetInterSubset_12218(U: set, T: set)\n ensures U * T <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_12219","instance":12219,"id":215562,"goal":"lemma SetCardSubset_12219(S: set, B: set)\n requires S <= B\n ensures |S| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_12220","instance":12220,"id":215563,"goal":"lemma SetUnionCard_12220(U: set, A: set)\n requires U * A == {}\n ensures |U + A| == |U| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_12221","instance":12221,"id":215564,"goal":"lemma SetUnionComm_12221(B: set, A: set)\n ensures B + A == A + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_12222","instance":12222,"id":215565,"goal":"lemma SetInterComm_12222(U: set, S: set)\n ensures U * S == S * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_12223","instance":12223,"id":215566,"goal":"lemma SetUnionAssoc_12223(S: set, T: set, B: set)\n ensures (S + T) + B == S + (T + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_12224","instance":12224,"id":215567,"goal":"lemma SetSubsetRefl_12224(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_12225","instance":12225,"id":215568,"goal":"lemma SetSubsetTrans_12225(T: set, B: set, U: set)\n requires T <= B && B <= U\n ensures T <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_12226","instance":12226,"id":215569,"goal":"lemma SetUnionEmpty_12226(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_12227","instance":12227,"id":215570,"goal":"lemma SetInterEmpty_12227(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_12228","instance":12228,"id":215571,"goal":"lemma SetInterSubset_12228(T: set, S: set)\n ensures T * S <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_12229","instance":12229,"id":215572,"goal":"lemma SetCardSubset_12229(U: set, S: set)\n requires U <= S\n ensures |U| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_12230","instance":12230,"id":215573,"goal":"lemma SetUnionCard_12230(A: set, U: set)\n requires A * U == {}\n ensures |A + U| == |A| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_12231","instance":12231,"id":215574,"goal":"lemma SetUnionComm_12231(S: set, U: set)\n ensures S + U == U + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_12232","instance":12232,"id":215575,"goal":"lemma SetInterComm_12232(T: set, B: set)\n ensures T * B == B * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_12233","instance":12233,"id":215576,"goal":"lemma SetUnionAssoc_12233(U: set, S: set, T: set)\n ensures (U + S) + T == U + (S + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_12234","instance":12234,"id":215577,"goal":"lemma SetSubsetRefl_12234(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_12235","instance":12235,"id":215578,"goal":"lemma SetSubsetTrans_12235(B: set, U: set, A: set)\n requires B <= U && U <= A\n ensures B <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_12236","instance":12236,"id":215579,"goal":"lemma SetUnionEmpty_12236(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_12237","instance":12237,"id":215580,"goal":"lemma SetInterEmpty_12237(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_12238","instance":12238,"id":215581,"goal":"lemma SetInterSubset_12238(B: set, U: set)\n ensures B * U <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_12239","instance":12239,"id":215582,"goal":"lemma SetCardSubset_12239(T: set, U: set)\n requires T <= U\n ensures |T| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_12240","instance":12240,"id":215583,"goal":"lemma SetUnionCard_12240(T: set, U: set)\n requires T * U == {}\n ensures |T + U| == |T| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_12241","instance":12241,"id":215584,"goal":"lemma SetUnionComm_12241(A: set, T: set)\n ensures A + T == T + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_12242","instance":12242,"id":215585,"goal":"lemma SetInterComm_12242(U: set, B: set)\n ensures U * B == B * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_12243","instance":12243,"id":215586,"goal":"lemma SetUnionAssoc_12243(T: set, S: set, B: set)\n ensures (T + S) + B == T + (S + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_12244","instance":12244,"id":215587,"goal":"lemma SetSubsetRefl_12244(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_12245","instance":12245,"id":215588,"goal":"lemma SetSubsetTrans_12245(U: set, S: set, A: set)\n requires U <= S && S <= A\n ensures U <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_12246","instance":12246,"id":215589,"goal":"lemma SetUnionEmpty_12246(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_12247","instance":12247,"id":215590,"goal":"lemma SetInterEmpty_12247(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_12248","instance":12248,"id":215591,"goal":"lemma SetInterSubset_12248(U: set, A: set)\n ensures U * A <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_12249","instance":12249,"id":215592,"goal":"lemma SetCardSubset_12249(S: set, B: set)\n requires S <= B\n ensures |S| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_12250","instance":12250,"id":215593,"goal":"lemma SetUnionCard_12250(T: set, U: set)\n requires T * U == {}\n ensures |T + U| == |T| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_12251","instance":12251,"id":215594,"goal":"lemma SetUnionComm_12251(A: set, B: set)\n ensures A + B == B + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_12252","instance":12252,"id":215595,"goal":"lemma SetInterComm_12252(B: set, S: set)\n ensures B * S == S * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_12253","instance":12253,"id":215596,"goal":"lemma SetUnionAssoc_12253(A: set, U: set, B: set)\n ensures (A + U) + B == A + (U + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_12254","instance":12254,"id":215597,"goal":"lemma SetSubsetRefl_12254(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_12255","instance":12255,"id":215598,"goal":"lemma SetSubsetTrans_12255(B: set, U: set, S: set)\n requires B <= U && U <= S\n ensures B <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_12256","instance":12256,"id":215599,"goal":"lemma SetUnionEmpty_12256(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_12257","instance":12257,"id":215600,"goal":"lemma SetInterEmpty_12257(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_12258","instance":12258,"id":215601,"goal":"lemma SetInterSubset_12258(A: set, S: set)\n ensures A * S <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_12259","instance":12259,"id":215602,"goal":"lemma SetCardSubset_12259(S: set, A: set)\n requires S <= A\n ensures |S| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_12260","instance":12260,"id":215603,"goal":"lemma SetUnionCard_12260(B: set, A: set)\n requires B * A == {}\n ensures |B + A| == |B| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_12261","instance":12261,"id":215604,"goal":"lemma SetUnionComm_12261(A: set, T: set)\n ensures A + T == T + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_12262","instance":12262,"id":215605,"goal":"lemma SetInterComm_12262(U: set, B: set)\n ensures U * B == B * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_12263","instance":12263,"id":215606,"goal":"lemma SetUnionAssoc_12263(U: set, T: set, A: set)\n ensures (U + T) + A == U + (T + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_12264","instance":12264,"id":215607,"goal":"lemma SetSubsetRefl_12264(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_12265","instance":12265,"id":215608,"goal":"lemma SetSubsetTrans_12265(B: set, U: set, A: set)\n requires B <= U && U <= A\n ensures B <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_12266","instance":12266,"id":215609,"goal":"lemma SetUnionEmpty_12266(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_12267","instance":12267,"id":215610,"goal":"lemma SetInterEmpty_12267(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_12268","instance":12268,"id":215611,"goal":"lemma SetInterSubset_12268(S: set, T: set)\n ensures S * T <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_12269","instance":12269,"id":215612,"goal":"lemma SetCardSubset_12269(U: set, S: set)\n requires U <= S\n ensures |U| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_12270","instance":12270,"id":215613,"goal":"lemma SetUnionCard_12270(A: set, S: set)\n requires A * S == {}\n ensures |A + S| == |A| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_12271","instance":12271,"id":215614,"goal":"lemma SetUnionComm_12271(S: set, T: set)\n ensures S + T == T + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_12272","instance":12272,"id":215615,"goal":"lemma SetInterComm_12272(T: set, B: set)\n ensures T * B == B * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_12273","instance":12273,"id":215616,"goal":"lemma SetUnionAssoc_12273(B: set, T: set, A: set)\n ensures (B + T) + A == B + (T + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_12274","instance":12274,"id":215617,"goal":"lemma SetSubsetRefl_12274(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_12275","instance":12275,"id":215618,"goal":"lemma SetSubsetTrans_12275(S: set, U: set, B: set)\n requires S <= U && U <= B\n ensures S <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_12276","instance":12276,"id":215619,"goal":"lemma SetUnionEmpty_12276(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_12277","instance":12277,"id":215620,"goal":"lemma SetInterEmpty_12277(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_12278","instance":12278,"id":215621,"goal":"lemma SetInterSubset_12278(T: set, U: set)\n ensures T * U <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_12279","instance":12279,"id":215622,"goal":"lemma SetCardSubset_12279(S: set, U: set)\n requires S <= U\n ensures |S| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_12280","instance":12280,"id":215623,"goal":"lemma SetUnionCard_12280(T: set, A: set)\n requires T * A == {}\n ensures |T + A| == |T| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_12281","instance":12281,"id":215624,"goal":"lemma SetUnionComm_12281(U: set, S: set)\n ensures U + S == S + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_12282","instance":12282,"id":215625,"goal":"lemma SetInterComm_12282(S: set, T: set)\n ensures S * T == T * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_12283","instance":12283,"id":215626,"goal":"lemma SetUnionAssoc_12283(A: set, B: set, U: set)\n ensures (A + B) + U == A + (B + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_12284","instance":12284,"id":215627,"goal":"lemma SetSubsetRefl_12284(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_12285","instance":12285,"id":215628,"goal":"lemma SetSubsetTrans_12285(B: set, S: set, U: set)\n requires B <= S && S <= U\n ensures B <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_12286","instance":12286,"id":215629,"goal":"lemma SetUnionEmpty_12286(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_12287","instance":12287,"id":215630,"goal":"lemma SetInterEmpty_12287(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_12288","instance":12288,"id":215631,"goal":"lemma SetInterSubset_12288(B: set, A: set)\n ensures B * A <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_12289","instance":12289,"id":215632,"goal":"lemma SetCardSubset_12289(U: set, B: set)\n requires U <= B\n ensures |U| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_12290","instance":12290,"id":215633,"goal":"lemma SetUnionCard_12290(S: set, B: set)\n requires S * B == {}\n ensures |S + B| == |S| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_12291","instance":12291,"id":215634,"goal":"lemma SetUnionComm_12291(T: set, U: set)\n ensures T + U == U + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_12292","instance":12292,"id":215635,"goal":"lemma SetInterComm_12292(T: set, B: set)\n ensures T * B == B * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_12293","instance":12293,"id":215636,"goal":"lemma SetUnionAssoc_12293(B: set, U: set, A: set)\n ensures (B + U) + A == B + (U + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_12294","instance":12294,"id":215637,"goal":"lemma SetSubsetRefl_12294(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_12295","instance":12295,"id":215638,"goal":"lemma SetSubsetTrans_12295(S: set, U: set, T: set)\n requires S <= U && U <= T\n ensures S <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_12296","instance":12296,"id":215639,"goal":"lemma SetUnionEmpty_12296(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_12297","instance":12297,"id":215640,"goal":"lemma SetInterEmpty_12297(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_12298","instance":12298,"id":215641,"goal":"lemma SetInterSubset_12298(U: set, B: set)\n ensures U * B <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_12299","instance":12299,"id":215642,"goal":"lemma SetCardSubset_12299(B: set, S: set)\n requires B <= S\n ensures |B| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_12300","instance":12300,"id":215643,"goal":"lemma SetUnionCard_12300(A: set, T: set)\n requires A * T == {}\n ensures |A + T| == |A| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_12301","instance":12301,"id":215644,"goal":"lemma SetUnionComm_12301(T: set, U: set)\n ensures T + U == U + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_12302","instance":12302,"id":215645,"goal":"lemma SetInterComm_12302(A: set, S: set)\n ensures A * S == S * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_12303","instance":12303,"id":215646,"goal":"lemma SetUnionAssoc_12303(U: set, T: set, B: set)\n ensures (U + T) + B == U + (T + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_12304","instance":12304,"id":215647,"goal":"lemma SetSubsetRefl_12304(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_12305","instance":12305,"id":215648,"goal":"lemma SetSubsetTrans_12305(A: set, S: set, B: set)\n requires A <= S && S <= B\n ensures A <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_12306","instance":12306,"id":215649,"goal":"lemma SetUnionEmpty_12306(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_12307","instance":12307,"id":215650,"goal":"lemma SetInterEmpty_12307(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_12308","instance":12308,"id":215651,"goal":"lemma SetInterSubset_12308(A: set, U: set)\n ensures A * U <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_12309","instance":12309,"id":215652,"goal":"lemma SetCardSubset_12309(A: set, B: set)\n requires A <= B\n ensures |A| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_12310","instance":12310,"id":215653,"goal":"lemma SetUnionCard_12310(S: set, A: set)\n requires S * A == {}\n ensures |S + A| == |S| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_12311","instance":12311,"id":215654,"goal":"lemma SetUnionComm_12311(S: set, B: set)\n ensures S + B == B + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_12312","instance":12312,"id":215655,"goal":"lemma SetInterComm_12312(A: set, U: set)\n ensures A * U == U * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_12313","instance":12313,"id":215656,"goal":"lemma SetUnionAssoc_12313(A: set, T: set, B: set)\n ensures (A + T) + B == A + (T + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_12314","instance":12314,"id":215657,"goal":"lemma SetSubsetRefl_12314(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_12315","instance":12315,"id":215658,"goal":"lemma SetSubsetTrans_12315(U: set, B: set, T: set)\n requires U <= B && B <= T\n ensures U <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_12316","instance":12316,"id":215659,"goal":"lemma SetUnionEmpty_12316(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_12317","instance":12317,"id":215660,"goal":"lemma SetInterEmpty_12317(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_12318","instance":12318,"id":215661,"goal":"lemma SetInterSubset_12318(A: set, B: set)\n ensures A * B <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_12319","instance":12319,"id":215662,"goal":"lemma SetCardSubset_12319(T: set, U: set)\n requires T <= U\n ensures |T| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_12320","instance":12320,"id":215663,"goal":"lemma SetUnionCard_12320(S: set, B: set)\n requires S * B == {}\n ensures |S + B| == |S| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_12321","instance":12321,"id":215664,"goal":"lemma SetUnionComm_12321(S: set, A: set)\n ensures S + A == A + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_12322","instance":12322,"id":215665,"goal":"lemma SetInterComm_12322(T: set, B: set)\n ensures T * B == B * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_12323","instance":12323,"id":215666,"goal":"lemma SetUnionAssoc_12323(A: set, U: set, T: set)\n ensures (A + U) + T == A + (U + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_12324","instance":12324,"id":215667,"goal":"lemma SetSubsetRefl_12324(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_12325","instance":12325,"id":215668,"goal":"lemma SetSubsetTrans_12325(U: set, A: set, B: set)\n requires U <= A && A <= B\n ensures U <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_12326","instance":12326,"id":215669,"goal":"lemma SetUnionEmpty_12326(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_12327","instance":12327,"id":215670,"goal":"lemma SetInterEmpty_12327(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_12328","instance":12328,"id":215671,"goal":"lemma SetInterSubset_12328(B: set, S: set)\n ensures B * S <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_12329","instance":12329,"id":215672,"goal":"lemma SetCardSubset_12329(S: set, U: set)\n requires S <= U\n ensures |S| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_12330","instance":12330,"id":215673,"goal":"lemma SetUnionCard_12330(U: set, S: set)\n requires U * S == {}\n ensures |U + S| == |U| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_12331","instance":12331,"id":215674,"goal":"lemma SetUnionComm_12331(B: set, S: set)\n ensures B + S == S + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_12332","instance":12332,"id":215675,"goal":"lemma SetInterComm_12332(A: set, B: set)\n ensures A * B == B * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_12333","instance":12333,"id":215676,"goal":"lemma SetUnionAssoc_12333(B: set, T: set, A: set)\n ensures (B + T) + A == B + (T + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_12334","instance":12334,"id":215677,"goal":"lemma SetSubsetRefl_12334(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_12335","instance":12335,"id":215678,"goal":"lemma SetSubsetTrans_12335(T: set, S: set, B: set)\n requires T <= S && S <= B\n ensures T <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_12336","instance":12336,"id":215679,"goal":"lemma SetUnionEmpty_12336(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_12337","instance":12337,"id":215680,"goal":"lemma SetInterEmpty_12337(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_12338","instance":12338,"id":215681,"goal":"lemma SetInterSubset_12338(A: set, B: set)\n ensures A * B <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_12339","instance":12339,"id":215682,"goal":"lemma SetCardSubset_12339(U: set, A: set)\n requires U <= A\n ensures |U| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_12340","instance":12340,"id":215683,"goal":"lemma SetUnionCard_12340(T: set, B: set)\n requires T * B == {}\n ensures |T + B| == |T| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_12341","instance":12341,"id":215684,"goal":"lemma SetUnionComm_12341(T: set, B: set)\n ensures T + B == B + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_12342","instance":12342,"id":215685,"goal":"lemma SetInterComm_12342(U: set, A: set)\n ensures U * A == A * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_12343","instance":12343,"id":215686,"goal":"lemma SetUnionAssoc_12343(U: set, S: set, T: set)\n ensures (U + S) + T == U + (S + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_12344","instance":12344,"id":215687,"goal":"lemma SetSubsetRefl_12344(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_12345","instance":12345,"id":215688,"goal":"lemma SetSubsetTrans_12345(B: set, U: set, T: set)\n requires B <= U && U <= T\n ensures B <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_12346","instance":12346,"id":215689,"goal":"lemma SetUnionEmpty_12346(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_12347","instance":12347,"id":215690,"goal":"lemma SetInterEmpty_12347(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_12348","instance":12348,"id":215691,"goal":"lemma SetInterSubset_12348(B: set, A: set)\n ensures B * A <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_12349","instance":12349,"id":215692,"goal":"lemma SetCardSubset_12349(A: set, B: set)\n requires A <= B\n ensures |A| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_12350","instance":12350,"id":215693,"goal":"lemma SetUnionCard_12350(B: set, S: set)\n requires B * S == {}\n ensures |B + S| == |B| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_12351","instance":12351,"id":215694,"goal":"lemma SetUnionComm_12351(T: set, S: set)\n ensures T + S == S + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_12352","instance":12352,"id":215695,"goal":"lemma SetInterComm_12352(S: set, A: set)\n ensures S * A == A * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_12353","instance":12353,"id":215696,"goal":"lemma SetUnionAssoc_12353(A: set, U: set, T: set)\n ensures (A + U) + T == A + (U + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_12354","instance":12354,"id":215697,"goal":"lemma SetSubsetRefl_12354(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_12355","instance":12355,"id":215698,"goal":"lemma SetSubsetTrans_12355(B: set, T: set, A: set)\n requires B <= T && T <= A\n ensures B <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_12356","instance":12356,"id":215699,"goal":"lemma SetUnionEmpty_12356(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_12357","instance":12357,"id":215700,"goal":"lemma SetInterEmpty_12357(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_12358","instance":12358,"id":215701,"goal":"lemma SetInterSubset_12358(S: set, A: set)\n ensures S * A <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_12359","instance":12359,"id":215702,"goal":"lemma SetCardSubset_12359(A: set, B: set)\n requires A <= B\n ensures |A| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_12360","instance":12360,"id":215703,"goal":"lemma SetUnionCard_12360(S: set, B: set)\n requires S * B == {}\n ensures |S + B| == |S| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_12361","instance":12361,"id":215704,"goal":"lemma SetUnionComm_12361(U: set, A: set)\n ensures U + A == A + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_12362","instance":12362,"id":215705,"goal":"lemma SetInterComm_12362(T: set, B: set)\n ensures T * B == B * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_12363","instance":12363,"id":215706,"goal":"lemma SetUnionAssoc_12363(B: set, U: set, S: set)\n ensures (B + U) + S == B + (U + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_12364","instance":12364,"id":215707,"goal":"lemma SetSubsetRefl_12364(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_12365","instance":12365,"id":215708,"goal":"lemma SetSubsetTrans_12365(S: set, U: set, A: set)\n requires S <= U && U <= A\n ensures S <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_12366","instance":12366,"id":215709,"goal":"lemma SetUnionEmpty_12366(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_12367","instance":12367,"id":215710,"goal":"lemma SetInterEmpty_12367(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_12368","instance":12368,"id":215711,"goal":"lemma SetInterSubset_12368(T: set, A: set)\n ensures T * A <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_12369","instance":12369,"id":215712,"goal":"lemma SetCardSubset_12369(U: set, A: set)\n requires U <= A\n ensures |U| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_12370","instance":12370,"id":215713,"goal":"lemma SetUnionCard_12370(S: set, A: set)\n requires S * A == {}\n ensures |S + A| == |S| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_12371","instance":12371,"id":215714,"goal":"lemma SetUnionComm_12371(A: set, T: set)\n ensures A + T == T + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_12372","instance":12372,"id":215715,"goal":"lemma SetInterComm_12372(S: set, U: set)\n ensures S * U == U * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_12373","instance":12373,"id":215716,"goal":"lemma SetUnionAssoc_12373(A: set, T: set, S: set)\n ensures (A + T) + S == A + (T + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_12374","instance":12374,"id":215717,"goal":"lemma SetSubsetRefl_12374(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_12375","instance":12375,"id":215718,"goal":"lemma SetSubsetTrans_12375(U: set, S: set, T: set)\n requires U <= S && S <= T\n ensures U <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_12376","instance":12376,"id":215719,"goal":"lemma SetUnionEmpty_12376(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_12377","instance":12377,"id":215720,"goal":"lemma SetInterEmpty_12377(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_12378","instance":12378,"id":215721,"goal":"lemma SetInterSubset_12378(U: set, B: set)\n ensures U * B <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_12379","instance":12379,"id":215722,"goal":"lemma SetCardSubset_12379(B: set, T: set)\n requires B <= T\n ensures |B| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_12380","instance":12380,"id":215723,"goal":"lemma SetUnionCard_12380(T: set, A: set)\n requires T * A == {}\n ensures |T + A| == |T| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_12381","instance":12381,"id":215724,"goal":"lemma SetUnionComm_12381(U: set, B: set)\n ensures U + B == B + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_12382","instance":12382,"id":215725,"goal":"lemma SetInterComm_12382(S: set, A: set)\n ensures S * A == A * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_12383","instance":12383,"id":215726,"goal":"lemma SetUnionAssoc_12383(U: set, A: set, T: set)\n ensures (U + A) + T == U + (A + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_12384","instance":12384,"id":215727,"goal":"lemma SetSubsetRefl_12384(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_12385","instance":12385,"id":215728,"goal":"lemma SetSubsetTrans_12385(A: set, T: set, U: set)\n requires A <= T && T <= U\n ensures A <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_12386","instance":12386,"id":215729,"goal":"lemma SetUnionEmpty_12386(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_12387","instance":12387,"id":215730,"goal":"lemma SetInterEmpty_12387(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_12388","instance":12388,"id":215731,"goal":"lemma SetInterSubset_12388(U: set, B: set)\n ensures U * B <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_12389","instance":12389,"id":215732,"goal":"lemma SetCardSubset_12389(A: set, U: set)\n requires A <= U\n ensures |A| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_12390","instance":12390,"id":215733,"goal":"lemma SetUnionCard_12390(S: set, B: set)\n requires S * B == {}\n ensures |S + B| == |S| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_12391","instance":12391,"id":215734,"goal":"lemma SetUnionComm_12391(A: set, U: set)\n ensures A + U == U + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_12392","instance":12392,"id":215735,"goal":"lemma SetInterComm_12392(T: set, S: set)\n ensures T * S == S * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_12393","instance":12393,"id":215736,"goal":"lemma SetUnionAssoc_12393(S: set, T: set, U: set)\n ensures (S + T) + U == S + (T + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_12394","instance":12394,"id":215737,"goal":"lemma SetSubsetRefl_12394(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_12395","instance":12395,"id":215738,"goal":"lemma SetSubsetTrans_12395(U: set, T: set, A: set)\n requires U <= T && T <= A\n ensures U <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_12396","instance":12396,"id":215739,"goal":"lemma SetUnionEmpty_12396(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_12397","instance":12397,"id":215740,"goal":"lemma SetInterEmpty_12397(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_12398","instance":12398,"id":215741,"goal":"lemma SetInterSubset_12398(B: set, U: set)\n ensures B * U <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_12399","instance":12399,"id":215742,"goal":"lemma SetCardSubset_12399(S: set, U: set)\n requires S <= U\n ensures |S| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_12400","instance":12400,"id":215743,"goal":"lemma SetUnionCard_12400(A: set, U: set)\n requires A * U == {}\n ensures |A + U| == |A| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_12401","instance":12401,"id":215744,"goal":"lemma SetUnionComm_12401(A: set, S: set)\n ensures A + S == S + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_12402","instance":12402,"id":215745,"goal":"lemma SetInterComm_12402(T: set, A: set)\n ensures T * A == A * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_12403","instance":12403,"id":215746,"goal":"lemma SetUnionAssoc_12403(A: set, S: set, T: set)\n ensures (A + S) + T == A + (S + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_12404","instance":12404,"id":215747,"goal":"lemma SetSubsetRefl_12404(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_12405","instance":12405,"id":215748,"goal":"lemma SetSubsetTrans_12405(B: set, T: set, S: set)\n requires B <= T && T <= S\n ensures B <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_12406","instance":12406,"id":215749,"goal":"lemma SetUnionEmpty_12406(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_12407","instance":12407,"id":215750,"goal":"lemma SetInterEmpty_12407(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_12408","instance":12408,"id":215751,"goal":"lemma SetInterSubset_12408(U: set, T: set)\n ensures U * T <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_12409","instance":12409,"id":215752,"goal":"lemma SetCardSubset_12409(S: set, B: set)\n requires S <= B\n ensures |S| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_12410","instance":12410,"id":215753,"goal":"lemma SetUnionCard_12410(A: set, S: set)\n requires A * S == {}\n ensures |A + S| == |A| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_12411","instance":12411,"id":215754,"goal":"lemma SetUnionComm_12411(S: set, U: set)\n ensures S + U == U + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_12412","instance":12412,"id":215755,"goal":"lemma SetInterComm_12412(T: set, B: set)\n ensures T * B == B * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_12413","instance":12413,"id":215756,"goal":"lemma SetUnionAssoc_12413(A: set, S: set, U: set)\n ensures (A + S) + U == A + (S + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_12414","instance":12414,"id":215757,"goal":"lemma SetSubsetRefl_12414(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_12415","instance":12415,"id":215758,"goal":"lemma SetSubsetTrans_12415(S: set, B: set, U: set)\n requires S <= B && B <= U\n ensures S <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_12416","instance":12416,"id":215759,"goal":"lemma SetUnionEmpty_12416(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_12417","instance":12417,"id":215760,"goal":"lemma SetInterEmpty_12417(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_12418","instance":12418,"id":215761,"goal":"lemma SetInterSubset_12418(T: set, S: set)\n ensures T * S <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_12419","instance":12419,"id":215762,"goal":"lemma SetCardSubset_12419(S: set, A: set)\n requires S <= A\n ensures |S| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_12420","instance":12420,"id":215763,"goal":"lemma SetUnionCard_12420(S: set, T: set)\n requires S * T == {}\n ensures |S + T| == |S| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_12421","instance":12421,"id":215764,"goal":"lemma SetUnionComm_12421(T: set, S: set)\n ensures T + S == S + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_12422","instance":12422,"id":215765,"goal":"lemma SetInterComm_12422(A: set, U: set)\n ensures A * U == U * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_12423","instance":12423,"id":215766,"goal":"lemma SetUnionAssoc_12423(B: set, T: set, A: set)\n ensures (B + T) + A == B + (T + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_12424","instance":12424,"id":215767,"goal":"lemma SetSubsetRefl_12424(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_12425","instance":12425,"id":215768,"goal":"lemma SetSubsetTrans_12425(U: set, B: set, A: set)\n requires U <= B && B <= A\n ensures U <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_12426","instance":12426,"id":215769,"goal":"lemma SetUnionEmpty_12426(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_12427","instance":12427,"id":215770,"goal":"lemma SetInterEmpty_12427(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_12428","instance":12428,"id":215771,"goal":"lemma SetInterSubset_12428(B: set, A: set)\n ensures B * A <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_12429","instance":12429,"id":215772,"goal":"lemma SetCardSubset_12429(U: set, S: set)\n requires U <= S\n ensures |U| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_12430","instance":12430,"id":215773,"goal":"lemma SetUnionCard_12430(S: set, A: set)\n requires S * A == {}\n ensures |S + A| == |S| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_12431","instance":12431,"id":215774,"goal":"lemma SetUnionComm_12431(T: set, A: set)\n ensures T + A == A + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_12432","instance":12432,"id":215775,"goal":"lemma SetInterComm_12432(U: set, T: set)\n ensures U * T == T * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_12433","instance":12433,"id":215776,"goal":"lemma SetUnionAssoc_12433(S: set, U: set, A: set)\n ensures (S + U) + A == S + (U + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_12434","instance":12434,"id":215777,"goal":"lemma SetSubsetRefl_12434(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_12435","instance":12435,"id":215778,"goal":"lemma SetSubsetTrans_12435(A: set, S: set, T: set)\n requires A <= S && S <= T\n ensures A <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_12436","instance":12436,"id":215779,"goal":"lemma SetUnionEmpty_12436(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_12437","instance":12437,"id":215780,"goal":"lemma SetInterEmpty_12437(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_12438","instance":12438,"id":215781,"goal":"lemma SetInterSubset_12438(S: set, A: set)\n ensures S * A <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_12439","instance":12439,"id":215782,"goal":"lemma SetCardSubset_12439(T: set, U: set)\n requires T <= U\n ensures |T| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_12440","instance":12440,"id":215783,"goal":"lemma SetUnionCard_12440(U: set, T: set)\n requires U * T == {}\n ensures |U + T| == |U| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_12441","instance":12441,"id":215784,"goal":"lemma SetUnionComm_12441(A: set, B: set)\n ensures A + B == B + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_12442","instance":12442,"id":215785,"goal":"lemma SetInterComm_12442(U: set, S: set)\n ensures U * S == S * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_12443","instance":12443,"id":215786,"goal":"lemma SetUnionAssoc_12443(B: set, A: set, S: set)\n ensures (B + A) + S == B + (A + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_12444","instance":12444,"id":215787,"goal":"lemma SetSubsetRefl_12444(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_12445","instance":12445,"id":215788,"goal":"lemma SetSubsetTrans_12445(A: set, B: set, S: set)\n requires A <= B && B <= S\n ensures A <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_12446","instance":12446,"id":215789,"goal":"lemma SetUnionEmpty_12446(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_12447","instance":12447,"id":215790,"goal":"lemma SetInterEmpty_12447(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_12448","instance":12448,"id":215791,"goal":"lemma SetInterSubset_12448(U: set, B: set)\n ensures U * B <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_12449","instance":12449,"id":215792,"goal":"lemma SetCardSubset_12449(U: set, B: set)\n requires U <= B\n ensures |U| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_12450","instance":12450,"id":215793,"goal":"lemma SetUnionCard_12450(U: set, A: set)\n requires U * A == {}\n ensures |U + A| == |U| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_12451","instance":12451,"id":215794,"goal":"lemma SetUnionComm_12451(B: set, A: set)\n ensures B + A == A + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_12452","instance":12452,"id":215795,"goal":"lemma SetInterComm_12452(U: set, B: set)\n ensures U * B == B * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_12453","instance":12453,"id":215796,"goal":"lemma SetUnionAssoc_12453(A: set, S: set, T: set)\n ensures (A + S) + T == A + (S + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_12454","instance":12454,"id":215797,"goal":"lemma SetSubsetRefl_12454(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_12455","instance":12455,"id":215798,"goal":"lemma SetSubsetTrans_12455(B: set, U: set, A: set)\n requires B <= U && U <= A\n ensures B <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_12456","instance":12456,"id":215799,"goal":"lemma SetUnionEmpty_12456(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_12457","instance":12457,"id":215800,"goal":"lemma SetInterEmpty_12457(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_12458","instance":12458,"id":215801,"goal":"lemma SetInterSubset_12458(S: set, U: set)\n ensures S * U <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_12459","instance":12459,"id":215802,"goal":"lemma SetCardSubset_12459(T: set, B: set)\n requires T <= B\n ensures |T| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_12460","instance":12460,"id":215803,"goal":"lemma SetUnionCard_12460(U: set, B: set)\n requires U * B == {}\n ensures |U + B| == |U| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_12461","instance":12461,"id":215804,"goal":"lemma SetUnionComm_12461(A: set, S: set)\n ensures A + S == S + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_12462","instance":12462,"id":215805,"goal":"lemma SetInterComm_12462(A: set, U: set)\n ensures A * U == U * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_12463","instance":12463,"id":215806,"goal":"lemma SetUnionAssoc_12463(U: set, A: set, S: set)\n ensures (U + A) + S == U + (A + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_12464","instance":12464,"id":215807,"goal":"lemma SetSubsetRefl_12464(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_12465","instance":12465,"id":215808,"goal":"lemma SetSubsetTrans_12465(B: set, U: set, A: set)\n requires B <= U && U <= A\n ensures B <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_12466","instance":12466,"id":215809,"goal":"lemma SetUnionEmpty_12466(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_12467","instance":12467,"id":215810,"goal":"lemma SetInterEmpty_12467(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_12468","instance":12468,"id":215811,"goal":"lemma SetInterSubset_12468(S: set, T: set)\n ensures S * T <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_12469","instance":12469,"id":215812,"goal":"lemma SetCardSubset_12469(A: set, S: set)\n requires A <= S\n ensures |A| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_12470","instance":12470,"id":215813,"goal":"lemma SetUnionCard_12470(T: set, A: set)\n requires T * A == {}\n ensures |T + A| == |T| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_12471","instance":12471,"id":215814,"goal":"lemma SetUnionComm_12471(B: set, U: set)\n ensures B + U == U + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_12472","instance":12472,"id":215815,"goal":"lemma SetInterComm_12472(T: set, U: set)\n ensures T * U == U * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_12473","instance":12473,"id":215816,"goal":"lemma SetUnionAssoc_12473(A: set, U: set, T: set)\n ensures (A + U) + T == A + (U + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_12474","instance":12474,"id":215817,"goal":"lemma SetSubsetRefl_12474(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_12475","instance":12475,"id":215818,"goal":"lemma SetSubsetTrans_12475(T: set, U: set, B: set)\n requires T <= U && U <= B\n ensures T <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_12476","instance":12476,"id":215819,"goal":"lemma SetUnionEmpty_12476(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_12477","instance":12477,"id":215820,"goal":"lemma SetInterEmpty_12477(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_12478","instance":12478,"id":215821,"goal":"lemma SetInterSubset_12478(B: set, S: set)\n ensures B * S <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_12479","instance":12479,"id":215822,"goal":"lemma SetCardSubset_12479(B: set, A: set)\n requires B <= A\n ensures |B| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_12480","instance":12480,"id":215823,"goal":"lemma SetUnionCard_12480(S: set, B: set)\n requires S * B == {}\n ensures |S + B| == |S| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_12481","instance":12481,"id":215824,"goal":"lemma SetUnionComm_12481(A: set, B: set)\n ensures A + B == B + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_12482","instance":12482,"id":215825,"goal":"lemma SetInterComm_12482(B: set, A: set)\n ensures B * A == A * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_12483","instance":12483,"id":215826,"goal":"lemma SetUnionAssoc_12483(S: set, T: set, U: set)\n ensures (S + T) + U == S + (T + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_12484","instance":12484,"id":215827,"goal":"lemma SetSubsetRefl_12484(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_12485","instance":12485,"id":215828,"goal":"lemma SetSubsetTrans_12485(T: set, A: set, B: set)\n requires T <= A && A <= B\n ensures T <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_12486","instance":12486,"id":215829,"goal":"lemma SetUnionEmpty_12486(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_12487","instance":12487,"id":215830,"goal":"lemma SetInterEmpty_12487(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_12488","instance":12488,"id":215831,"goal":"lemma SetInterSubset_12488(T: set, A: set)\n ensures T * A <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_12489","instance":12489,"id":215832,"goal":"lemma SetCardSubset_12489(S: set, U: set)\n requires S <= U\n ensures |S| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_12490","instance":12490,"id":215833,"goal":"lemma SetUnionCard_12490(S: set, B: set)\n requires S * B == {}\n ensures |S + B| == |S| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_12491","instance":12491,"id":215834,"goal":"lemma SetUnionComm_12491(B: set, U: set)\n ensures B + U == U + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_12492","instance":12492,"id":215835,"goal":"lemma SetInterComm_12492(S: set, U: set)\n ensures S * U == U * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_12493","instance":12493,"id":215836,"goal":"lemma SetUnionAssoc_12493(U: set, A: set, S: set)\n ensures (U + A) + S == U + (A + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_12494","instance":12494,"id":215837,"goal":"lemma SetSubsetRefl_12494(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_12495","instance":12495,"id":215838,"goal":"lemma SetSubsetTrans_12495(U: set, B: set, S: set)\n requires U <= B && B <= S\n ensures U <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_12496","instance":12496,"id":215839,"goal":"lemma SetUnionEmpty_12496(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_12497","instance":12497,"id":215840,"goal":"lemma SetInterEmpty_12497(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_12498","instance":12498,"id":215841,"goal":"lemma SetInterSubset_12498(S: set, B: set)\n ensures S * B <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_12499","instance":12499,"id":215842,"goal":"lemma SetCardSubset_12499(S: set, B: set)\n requires S <= B\n ensures |S| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_12500","instance":12500,"id":215843,"goal":"lemma SetUnionCard_12500(S: set, T: set)\n requires S * T == {}\n ensures |S + T| == |S| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_12501","instance":12501,"id":215844,"goal":"lemma SetUnionComm_12501(B: set, S: set)\n ensures B + S == S + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_12502","instance":12502,"id":215845,"goal":"lemma SetInterComm_12502(B: set, S: set)\n ensures B * S == S * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_12503","instance":12503,"id":215846,"goal":"lemma SetUnionAssoc_12503(S: set, U: set, T: set)\n ensures (S + U) + T == S + (U + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_12504","instance":12504,"id":215847,"goal":"lemma SetSubsetRefl_12504(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_12505","instance":12505,"id":215848,"goal":"lemma SetSubsetTrans_12505(B: set, S: set, T: set)\n requires B <= S && S <= T\n ensures B <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_12506","instance":12506,"id":215849,"goal":"lemma SetUnionEmpty_12506(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_12507","instance":12507,"id":215850,"goal":"lemma SetInterEmpty_12507(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_12508","instance":12508,"id":215851,"goal":"lemma SetInterSubset_12508(A: set, S: set)\n ensures A * S <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_12509","instance":12509,"id":215852,"goal":"lemma SetCardSubset_12509(A: set, U: set)\n requires A <= U\n ensures |A| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_12510","instance":12510,"id":215853,"goal":"lemma SetUnionCard_12510(A: set, T: set)\n requires A * T == {}\n ensures |A + T| == |A| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_12511","instance":12511,"id":215854,"goal":"lemma SetUnionComm_12511(B: set, T: set)\n ensures B + T == T + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_12512","instance":12512,"id":215855,"goal":"lemma SetInterComm_12512(A: set, B: set)\n ensures A * B == B * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_12513","instance":12513,"id":215856,"goal":"lemma SetUnionAssoc_12513(A: set, U: set, T: set)\n ensures (A + U) + T == A + (U + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_12514","instance":12514,"id":215857,"goal":"lemma SetSubsetRefl_12514(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_12515","instance":12515,"id":215858,"goal":"lemma SetSubsetTrans_12515(S: set, B: set, U: set)\n requires S <= B && B <= U\n ensures S <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_12516","instance":12516,"id":215859,"goal":"lemma SetUnionEmpty_12516(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_12517","instance":12517,"id":215860,"goal":"lemma SetInterEmpty_12517(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_12518","instance":12518,"id":215861,"goal":"lemma SetInterSubset_12518(U: set, S: set)\n ensures U * S <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_12519","instance":12519,"id":215862,"goal":"lemma SetCardSubset_12519(S: set, T: set)\n requires S <= T\n ensures |S| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_12520","instance":12520,"id":215863,"goal":"lemma SetUnionCard_12520(A: set, B: set)\n requires A * B == {}\n ensures |A + B| == |A| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_12521","instance":12521,"id":215864,"goal":"lemma SetUnionComm_12521(S: set, U: set)\n ensures S + U == U + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_12522","instance":12522,"id":215865,"goal":"lemma SetInterComm_12522(T: set, A: set)\n ensures T * A == A * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_12523","instance":12523,"id":215866,"goal":"lemma SetUnionAssoc_12523(S: set, U: set, B: set)\n ensures (S + U) + B == S + (U + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_12524","instance":12524,"id":215867,"goal":"lemma SetSubsetRefl_12524(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_12525","instance":12525,"id":215868,"goal":"lemma SetSubsetTrans_12525(A: set, U: set, T: set)\n requires A <= U && U <= T\n ensures A <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_12526","instance":12526,"id":215869,"goal":"lemma SetUnionEmpty_12526(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_12527","instance":12527,"id":215870,"goal":"lemma SetInterEmpty_12527(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_12528","instance":12528,"id":215871,"goal":"lemma SetInterSubset_12528(B: set, T: set)\n ensures B * T <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_12529","instance":12529,"id":215872,"goal":"lemma SetCardSubset_12529(U: set, S: set)\n requires U <= S\n ensures |U| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_12530","instance":12530,"id":215873,"goal":"lemma SetUnionCard_12530(A: set, B: set)\n requires A * B == {}\n ensures |A + B| == |A| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_12531","instance":12531,"id":215874,"goal":"lemma SetUnionComm_12531(U: set, A: set)\n ensures U + A == A + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_12532","instance":12532,"id":215875,"goal":"lemma SetInterComm_12532(T: set, U: set)\n ensures T * U == U * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_12533","instance":12533,"id":215876,"goal":"lemma SetUnionAssoc_12533(B: set, A: set, T: set)\n ensures (B + A) + T == B + (A + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_12534","instance":12534,"id":215877,"goal":"lemma SetSubsetRefl_12534(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_12535","instance":12535,"id":215878,"goal":"lemma SetSubsetTrans_12535(A: set, B: set, S: set)\n requires A <= B && B <= S\n ensures A <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_12536","instance":12536,"id":215879,"goal":"lemma SetUnionEmpty_12536(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_12537","instance":12537,"id":215880,"goal":"lemma SetInterEmpty_12537(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_12538","instance":12538,"id":215881,"goal":"lemma SetInterSubset_12538(S: set, U: set)\n ensures S * U <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_12539","instance":12539,"id":215882,"goal":"lemma SetCardSubset_12539(B: set, T: set)\n requires B <= T\n ensures |B| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_12540","instance":12540,"id":215883,"goal":"lemma SetUnionCard_12540(T: set, S: set)\n requires T * S == {}\n ensures |T + S| == |T| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_12541","instance":12541,"id":215884,"goal":"lemma SetUnionComm_12541(U: set, B: set)\n ensures U + B == B + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_12542","instance":12542,"id":215885,"goal":"lemma SetInterComm_12542(U: set, A: set)\n ensures U * A == A * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_12543","instance":12543,"id":215886,"goal":"lemma SetUnionAssoc_12543(B: set, S: set, T: set)\n ensures (B + S) + T == B + (S + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_12544","instance":12544,"id":215887,"goal":"lemma SetSubsetRefl_12544(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_12545","instance":12545,"id":215888,"goal":"lemma SetSubsetTrans_12545(A: set, B: set, S: set)\n requires A <= B && B <= S\n ensures A <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_12546","instance":12546,"id":215889,"goal":"lemma SetUnionEmpty_12546(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_12547","instance":12547,"id":215890,"goal":"lemma SetInterEmpty_12547(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_12548","instance":12548,"id":215891,"goal":"lemma SetInterSubset_12548(S: set, U: set)\n ensures S * U <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_12549","instance":12549,"id":215892,"goal":"lemma SetCardSubset_12549(U: set, S: set)\n requires U <= S\n ensures |U| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_12550","instance":12550,"id":215893,"goal":"lemma SetUnionCard_12550(A: set, T: set)\n requires A * T == {}\n ensures |A + T| == |A| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_12551","instance":12551,"id":215894,"goal":"lemma SetUnionComm_12551(U: set, T: set)\n ensures U + T == T + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_12552","instance":12552,"id":215895,"goal":"lemma SetInterComm_12552(U: set, B: set)\n ensures U * B == B * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_12553","instance":12553,"id":215896,"goal":"lemma SetUnionAssoc_12553(A: set, T: set, U: set)\n ensures (A + T) + U == A + (T + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_12554","instance":12554,"id":215897,"goal":"lemma SetSubsetRefl_12554(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_12555","instance":12555,"id":215898,"goal":"lemma SetSubsetTrans_12555(B: set, T: set, S: set)\n requires B <= T && T <= S\n ensures B <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_12556","instance":12556,"id":215899,"goal":"lemma SetUnionEmpty_12556(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_12557","instance":12557,"id":215900,"goal":"lemma SetInterEmpty_12557(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_12558","instance":12558,"id":215901,"goal":"lemma SetInterSubset_12558(B: set, T: set)\n ensures B * T <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_12559","instance":12559,"id":215902,"goal":"lemma SetCardSubset_12559(B: set, U: set)\n requires B <= U\n ensures |B| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_12560","instance":12560,"id":215903,"goal":"lemma SetUnionCard_12560(S: set, T: set)\n requires S * T == {}\n ensures |S + T| == |S| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_12561","instance":12561,"id":215904,"goal":"lemma SetUnionComm_12561(B: set, S: set)\n ensures B + S == S + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_12562","instance":12562,"id":215905,"goal":"lemma SetInterComm_12562(S: set, U: set)\n ensures S * U == U * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_12563","instance":12563,"id":215906,"goal":"lemma SetUnionAssoc_12563(T: set, A: set, U: set)\n ensures (T + A) + U == T + (A + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_12564","instance":12564,"id":215907,"goal":"lemma SetSubsetRefl_12564(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_12565","instance":12565,"id":215908,"goal":"lemma SetSubsetTrans_12565(B: set, T: set, U: set)\n requires B <= T && T <= U\n ensures B <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_12566","instance":12566,"id":215909,"goal":"lemma SetUnionEmpty_12566(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_12567","instance":12567,"id":215910,"goal":"lemma SetInterEmpty_12567(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_12568","instance":12568,"id":215911,"goal":"lemma SetInterSubset_12568(S: set, T: set)\n ensures S * T <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_12569","instance":12569,"id":215912,"goal":"lemma SetCardSubset_12569(B: set, S: set)\n requires B <= S\n ensures |B| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_12570","instance":12570,"id":215913,"goal":"lemma SetUnionCard_12570(S: set, A: set)\n requires S * A == {}\n ensures |S + A| == |S| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_12571","instance":12571,"id":215914,"goal":"lemma SetUnionComm_12571(U: set, S: set)\n ensures U + S == S + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_12572","instance":12572,"id":215915,"goal":"lemma SetInterComm_12572(U: set, A: set)\n ensures U * A == A * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_12573","instance":12573,"id":215916,"goal":"lemma SetUnionAssoc_12573(B: set, A: set, T: set)\n ensures (B + A) + T == B + (A + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_12574","instance":12574,"id":215917,"goal":"lemma SetSubsetRefl_12574(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_12575","instance":12575,"id":215918,"goal":"lemma SetSubsetTrans_12575(T: set, A: set, S: set)\n requires T <= A && A <= S\n ensures T <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_12576","instance":12576,"id":215919,"goal":"lemma SetUnionEmpty_12576(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_12577","instance":12577,"id":215920,"goal":"lemma SetInterEmpty_12577(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_12578","instance":12578,"id":215921,"goal":"lemma SetInterSubset_12578(S: set, T: set)\n ensures S * T <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_12579","instance":12579,"id":215922,"goal":"lemma SetCardSubset_12579(T: set, B: set)\n requires T <= B\n ensures |T| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_12580","instance":12580,"id":215923,"goal":"lemma SetUnionCard_12580(A: set, S: set)\n requires A * S == {}\n ensures |A + S| == |A| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_12581","instance":12581,"id":215924,"goal":"lemma SetUnionComm_12581(U: set, S: set)\n ensures U + S == S + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_12582","instance":12582,"id":215925,"goal":"lemma SetInterComm_12582(U: set, T: set)\n ensures U * T == T * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_12583","instance":12583,"id":215926,"goal":"lemma SetUnionAssoc_12583(U: set, S: set, B: set)\n ensures (U + S) + B == U + (S + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_12584","instance":12584,"id":215927,"goal":"lemma SetSubsetRefl_12584(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_12585","instance":12585,"id":215928,"goal":"lemma SetSubsetTrans_12585(U: set, B: set, A: set)\n requires U <= B && B <= A\n ensures U <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_12586","instance":12586,"id":215929,"goal":"lemma SetUnionEmpty_12586(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_12587","instance":12587,"id":215930,"goal":"lemma SetInterEmpty_12587(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_12588","instance":12588,"id":215931,"goal":"lemma SetInterSubset_12588(B: set, S: set)\n ensures B * S <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_12589","instance":12589,"id":215932,"goal":"lemma SetCardSubset_12589(B: set, S: set)\n requires B <= S\n ensures |B| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_12590","instance":12590,"id":215933,"goal":"lemma SetUnionCard_12590(S: set, B: set)\n requires S * B == {}\n ensures |S + B| == |S| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_12591","instance":12591,"id":215934,"goal":"lemma SetUnionComm_12591(A: set, B: set)\n ensures A + B == B + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_12592","instance":12592,"id":215935,"goal":"lemma SetInterComm_12592(A: set, T: set)\n ensures A * T == T * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_12593","instance":12593,"id":215936,"goal":"lemma SetUnionAssoc_12593(B: set, A: set, S: set)\n ensures (B + A) + S == B + (A + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_12594","instance":12594,"id":215937,"goal":"lemma SetSubsetRefl_12594(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_12595","instance":12595,"id":215938,"goal":"lemma SetSubsetTrans_12595(T: set, U: set, B: set)\n requires T <= U && U <= B\n ensures T <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_12596","instance":12596,"id":215939,"goal":"lemma SetUnionEmpty_12596(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_12597","instance":12597,"id":215940,"goal":"lemma SetInterEmpty_12597(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_12598","instance":12598,"id":215941,"goal":"lemma SetInterSubset_12598(U: set, B: set)\n ensures U * B <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_12599","instance":12599,"id":215942,"goal":"lemma SetCardSubset_12599(A: set, S: set)\n requires A <= S\n ensures |A| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_12600","instance":12600,"id":215943,"goal":"lemma SetUnionCard_12600(A: set, U: set)\n requires A * U == {}\n ensures |A + U| == |A| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_12601","instance":12601,"id":215944,"goal":"lemma SetUnionComm_12601(B: set, S: set)\n ensures B + S == S + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_12602","instance":12602,"id":215945,"goal":"lemma SetInterComm_12602(U: set, S: set)\n ensures U * S == S * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_12603","instance":12603,"id":215946,"goal":"lemma SetUnionAssoc_12603(A: set, T: set, B: set)\n ensures (A + T) + B == A + (T + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_12604","instance":12604,"id":215947,"goal":"lemma SetSubsetRefl_12604(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_12605","instance":12605,"id":215948,"goal":"lemma SetSubsetTrans_12605(U: set, A: set, B: set)\n requires U <= A && A <= B\n ensures U <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_12606","instance":12606,"id":215949,"goal":"lemma SetUnionEmpty_12606(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_12607","instance":12607,"id":215950,"goal":"lemma SetInterEmpty_12607(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_12608","instance":12608,"id":215951,"goal":"lemma SetInterSubset_12608(U: set, B: set)\n ensures U * B <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_12609","instance":12609,"id":215952,"goal":"lemma SetCardSubset_12609(S: set, U: set)\n requires S <= U\n ensures |S| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_12610","instance":12610,"id":215953,"goal":"lemma SetUnionCard_12610(B: set, S: set)\n requires B * S == {}\n ensures |B + S| == |B| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_12611","instance":12611,"id":215954,"goal":"lemma SetUnionComm_12611(B: set, A: set)\n ensures B + A == A + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_12612","instance":12612,"id":215955,"goal":"lemma SetInterComm_12612(T: set, S: set)\n ensures T * S == S * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_12613","instance":12613,"id":215956,"goal":"lemma SetUnionAssoc_12613(T: set, B: set, U: set)\n ensures (T + B) + U == T + (B + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_12614","instance":12614,"id":215957,"goal":"lemma SetSubsetRefl_12614(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_12615","instance":12615,"id":215958,"goal":"lemma SetSubsetTrans_12615(U: set, B: set, A: set)\n requires U <= B && B <= A\n ensures U <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_12616","instance":12616,"id":215959,"goal":"lemma SetUnionEmpty_12616(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_12617","instance":12617,"id":215960,"goal":"lemma SetInterEmpty_12617(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_12618","instance":12618,"id":215961,"goal":"lemma SetInterSubset_12618(S: set, T: set)\n ensures S * T <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_12619","instance":12619,"id":215962,"goal":"lemma SetCardSubset_12619(A: set, U: set)\n requires A <= U\n ensures |A| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_12620","instance":12620,"id":215963,"goal":"lemma SetUnionCard_12620(B: set, S: set)\n requires B * S == {}\n ensures |B + S| == |B| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_12621","instance":12621,"id":215964,"goal":"lemma SetUnionComm_12621(U: set, S: set)\n ensures U + S == S + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_12622","instance":12622,"id":215965,"goal":"lemma SetInterComm_12622(A: set, U: set)\n ensures A * U == U * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_12623","instance":12623,"id":215966,"goal":"lemma SetUnionAssoc_12623(U: set, T: set, B: set)\n ensures (U + T) + B == U + (T + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_12624","instance":12624,"id":215967,"goal":"lemma SetSubsetRefl_12624(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_12625","instance":12625,"id":215968,"goal":"lemma SetSubsetTrans_12625(U: set, S: set, B: set)\n requires U <= S && S <= B\n ensures U <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_12626","instance":12626,"id":215969,"goal":"lemma SetUnionEmpty_12626(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_12627","instance":12627,"id":215970,"goal":"lemma SetInterEmpty_12627(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_12628","instance":12628,"id":215971,"goal":"lemma SetInterSubset_12628(A: set, U: set)\n ensures A * U <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_12629","instance":12629,"id":215972,"goal":"lemma SetCardSubset_12629(U: set, B: set)\n requires U <= B\n ensures |U| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_12630","instance":12630,"id":215973,"goal":"lemma SetUnionCard_12630(U: set, S: set)\n requires U * S == {}\n ensures |U + S| == |U| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_12631","instance":12631,"id":215974,"goal":"lemma SetUnionComm_12631(T: set, S: set)\n ensures T + S == S + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_12632","instance":12632,"id":215975,"goal":"lemma SetInterComm_12632(B: set, A: set)\n ensures B * A == A * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_12633","instance":12633,"id":215976,"goal":"lemma SetUnionAssoc_12633(U: set, A: set, B: set)\n ensures (U + A) + B == U + (A + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_12634","instance":12634,"id":215977,"goal":"lemma SetSubsetRefl_12634(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_12635","instance":12635,"id":215978,"goal":"lemma SetSubsetTrans_12635(A: set, B: set, U: set)\n requires A <= B && B <= U\n ensures A <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_12636","instance":12636,"id":215979,"goal":"lemma SetUnionEmpty_12636(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_12637","instance":12637,"id":215980,"goal":"lemma SetInterEmpty_12637(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_12638","instance":12638,"id":215981,"goal":"lemma SetInterSubset_12638(B: set, T: set)\n ensures B * T <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_12639","instance":12639,"id":215982,"goal":"lemma SetCardSubset_12639(T: set, B: set)\n requires T <= B\n ensures |T| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_12640","instance":12640,"id":215983,"goal":"lemma SetUnionCard_12640(A: set, U: set)\n requires A * U == {}\n ensures |A + U| == |A| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_12641","instance":12641,"id":215984,"goal":"lemma SetUnionComm_12641(S: set, B: set)\n ensures S + B == B + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_12642","instance":12642,"id":215985,"goal":"lemma SetInterComm_12642(U: set, S: set)\n ensures U * S == S * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_12643","instance":12643,"id":215986,"goal":"lemma SetUnionAssoc_12643(S: set, A: set, U: set)\n ensures (S + A) + U == S + (A + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_12644","instance":12644,"id":215987,"goal":"lemma SetSubsetRefl_12644(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_12645","instance":12645,"id":215988,"goal":"lemma SetSubsetTrans_12645(A: set, B: set, T: set)\n requires A <= B && B <= T\n ensures A <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_12646","instance":12646,"id":215989,"goal":"lemma SetUnionEmpty_12646(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_12647","instance":12647,"id":215990,"goal":"lemma SetInterEmpty_12647(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_12648","instance":12648,"id":215991,"goal":"lemma SetInterSubset_12648(U: set, B: set)\n ensures U * B <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_12649","instance":12649,"id":215992,"goal":"lemma SetCardSubset_12649(A: set, T: set)\n requires A <= T\n ensures |A| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_12650","instance":12650,"id":215993,"goal":"lemma SetUnionCard_12650(A: set, U: set)\n requires A * U == {}\n ensures |A + U| == |A| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_12651","instance":12651,"id":215994,"goal":"lemma SetUnionComm_12651(A: set, U: set)\n ensures A + U == U + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_12652","instance":12652,"id":215995,"goal":"lemma SetInterComm_12652(T: set, B: set)\n ensures T * B == B * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_12653","instance":12653,"id":215996,"goal":"lemma SetUnionAssoc_12653(S: set, A: set, T: set)\n ensures (S + A) + T == S + (A + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_12654","instance":12654,"id":215997,"goal":"lemma SetSubsetRefl_12654(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_12655","instance":12655,"id":215998,"goal":"lemma SetSubsetTrans_12655(S: set, U: set, B: set)\n requires S <= U && U <= B\n ensures S <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_12656","instance":12656,"id":215999,"goal":"lemma SetUnionEmpty_12656(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_12657","instance":12657,"id":216000,"goal":"lemma SetInterEmpty_12657(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_12658","instance":12658,"id":216001,"goal":"lemma SetInterSubset_12658(B: set, U: set)\n ensures B * U <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_12659","instance":12659,"id":216002,"goal":"lemma SetCardSubset_12659(B: set, A: set)\n requires B <= A\n ensures |B| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_12660","instance":12660,"id":216003,"goal":"lemma SetUnionCard_12660(A: set, U: set)\n requires A * U == {}\n ensures |A + U| == |A| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_12661","instance":12661,"id":216004,"goal":"lemma SetUnionComm_12661(S: set, T: set)\n ensures S + T == T + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_12662","instance":12662,"id":216005,"goal":"lemma SetInterComm_12662(T: set, B: set)\n ensures T * B == B * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_12663","instance":12663,"id":216006,"goal":"lemma SetUnionAssoc_12663(A: set, U: set, T: set)\n ensures (A + U) + T == A + (U + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_12664","instance":12664,"id":216007,"goal":"lemma SetSubsetRefl_12664(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_12665","instance":12665,"id":216008,"goal":"lemma SetSubsetTrans_12665(B: set, T: set, A: set)\n requires B <= T && T <= A\n ensures B <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_12666","instance":12666,"id":216009,"goal":"lemma SetUnionEmpty_12666(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_12667","instance":12667,"id":216010,"goal":"lemma SetInterEmpty_12667(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_12668","instance":12668,"id":216011,"goal":"lemma SetInterSubset_12668(A: set, T: set)\n ensures A * T <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_12669","instance":12669,"id":216012,"goal":"lemma SetCardSubset_12669(S: set, U: set)\n requires S <= U\n ensures |S| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_12670","instance":12670,"id":216013,"goal":"lemma SetUnionCard_12670(A: set, T: set)\n requires A * T == {}\n ensures |A + T| == |A| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_12671","instance":12671,"id":216014,"goal":"lemma SetUnionComm_12671(B: set, T: set)\n ensures B + T == T + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_12672","instance":12672,"id":216015,"goal":"lemma SetInterComm_12672(U: set, B: set)\n ensures U * B == B * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_12673","instance":12673,"id":216016,"goal":"lemma SetUnionAssoc_12673(T: set, B: set, S: set)\n ensures (T + B) + S == T + (B + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_12674","instance":12674,"id":216017,"goal":"lemma SetSubsetRefl_12674(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_12675","instance":12675,"id":216018,"goal":"lemma SetSubsetTrans_12675(A: set, T: set, S: set)\n requires A <= T && T <= S\n ensures A <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_12676","instance":12676,"id":216019,"goal":"lemma SetUnionEmpty_12676(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_12677","instance":12677,"id":216020,"goal":"lemma SetInterEmpty_12677(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_12678","instance":12678,"id":216021,"goal":"lemma SetInterSubset_12678(B: set, A: set)\n ensures B * A <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_12679","instance":12679,"id":216022,"goal":"lemma SetCardSubset_12679(T: set, B: set)\n requires T <= B\n ensures |T| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_12680","instance":12680,"id":216023,"goal":"lemma SetUnionCard_12680(B: set, S: set)\n requires B * S == {}\n ensures |B + S| == |B| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_12681","instance":12681,"id":216024,"goal":"lemma SetUnionComm_12681(S: set, A: set)\n ensures S + A == A + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_12682","instance":12682,"id":216025,"goal":"lemma SetInterComm_12682(A: set, B: set)\n ensures A * B == B * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_12683","instance":12683,"id":216026,"goal":"lemma SetUnionAssoc_12683(U: set, T: set, B: set)\n ensures (U + T) + B == U + (T + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_12684","instance":12684,"id":216027,"goal":"lemma SetSubsetRefl_12684(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_12685","instance":12685,"id":216028,"goal":"lemma SetSubsetTrans_12685(A: set, B: set, U: set)\n requires A <= B && B <= U\n ensures A <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_12686","instance":12686,"id":216029,"goal":"lemma SetUnionEmpty_12686(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_12687","instance":12687,"id":216030,"goal":"lemma SetInterEmpty_12687(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_12688","instance":12688,"id":216031,"goal":"lemma SetInterSubset_12688(S: set, A: set)\n ensures S * A <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_12689","instance":12689,"id":216032,"goal":"lemma SetCardSubset_12689(S: set, T: set)\n requires S <= T\n ensures |S| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_12690","instance":12690,"id":216033,"goal":"lemma SetUnionCard_12690(B: set, S: set)\n requires B * S == {}\n ensures |B + S| == |B| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_12691","instance":12691,"id":216034,"goal":"lemma SetUnionComm_12691(S: set, A: set)\n ensures S + A == A + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_12692","instance":12692,"id":216035,"goal":"lemma SetInterComm_12692(A: set, S: set)\n ensures A * S == S * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_12693","instance":12693,"id":216036,"goal":"lemma SetUnionAssoc_12693(S: set, U: set, B: set)\n ensures (S + U) + B == S + (U + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_12694","instance":12694,"id":216037,"goal":"lemma SetSubsetRefl_12694(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_12695","instance":12695,"id":216038,"goal":"lemma SetSubsetTrans_12695(A: set, B: set, T: set)\n requires A <= B && B <= T\n ensures A <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_12696","instance":12696,"id":216039,"goal":"lemma SetUnionEmpty_12696(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_12697","instance":12697,"id":216040,"goal":"lemma SetInterEmpty_12697(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_12698","instance":12698,"id":216041,"goal":"lemma SetInterSubset_12698(S: set, U: set)\n ensures S * U <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_12699","instance":12699,"id":216042,"goal":"lemma SetCardSubset_12699(U: set, A: set)\n requires U <= A\n ensures |U| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_12700","instance":12700,"id":216043,"goal":"lemma SetUnionCard_12700(U: set, T: set)\n requires U * T == {}\n ensures |U + T| == |U| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_12701","instance":12701,"id":216044,"goal":"lemma SetUnionComm_12701(U: set, A: set)\n ensures U + A == A + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_12702","instance":12702,"id":216045,"goal":"lemma SetInterComm_12702(T: set, B: set)\n ensures T * B == B * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_12703","instance":12703,"id":216046,"goal":"lemma SetUnionAssoc_12703(S: set, U: set, T: set)\n ensures (S + U) + T == S + (U + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_12704","instance":12704,"id":216047,"goal":"lemma SetSubsetRefl_12704(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_12705","instance":12705,"id":216048,"goal":"lemma SetSubsetTrans_12705(A: set, B: set, T: set)\n requires A <= B && B <= T\n ensures A <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_12706","instance":12706,"id":216049,"goal":"lemma SetUnionEmpty_12706(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_12707","instance":12707,"id":216050,"goal":"lemma SetInterEmpty_12707(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_12708","instance":12708,"id":216051,"goal":"lemma SetInterSubset_12708(U: set, B: set)\n ensures U * B <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_12709","instance":12709,"id":216052,"goal":"lemma SetCardSubset_12709(B: set, T: set)\n requires B <= T\n ensures |B| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_12710","instance":12710,"id":216053,"goal":"lemma SetUnionCard_12710(U: set, B: set)\n requires U * B == {}\n ensures |U + B| == |U| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_12711","instance":12711,"id":216054,"goal":"lemma SetUnionComm_12711(S: set, T: set)\n ensures S + T == T + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_12712","instance":12712,"id":216055,"goal":"lemma SetInterComm_12712(B: set, U: set)\n ensures B * U == U * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_12713","instance":12713,"id":216056,"goal":"lemma SetUnionAssoc_12713(U: set, B: set, S: set)\n ensures (U + B) + S == U + (B + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_12714","instance":12714,"id":216057,"goal":"lemma SetSubsetRefl_12714(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_12715","instance":12715,"id":216058,"goal":"lemma SetSubsetTrans_12715(B: set, S: set, A: set)\n requires B <= S && S <= A\n ensures B <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_12716","instance":12716,"id":216059,"goal":"lemma SetUnionEmpty_12716(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_12717","instance":12717,"id":216060,"goal":"lemma SetInterEmpty_12717(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_12718","instance":12718,"id":216061,"goal":"lemma SetInterSubset_12718(S: set, T: set)\n ensures S * T <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_12719","instance":12719,"id":216062,"goal":"lemma SetCardSubset_12719(A: set, U: set)\n requires A <= U\n ensures |A| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_12720","instance":12720,"id":216063,"goal":"lemma SetUnionCard_12720(S: set, T: set)\n requires S * T == {}\n ensures |S + T| == |S| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_12721","instance":12721,"id":216064,"goal":"lemma SetUnionComm_12721(U: set, T: set)\n ensures U + T == T + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_12722","instance":12722,"id":216065,"goal":"lemma SetInterComm_12722(S: set, A: set)\n ensures S * A == A * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_12723","instance":12723,"id":216066,"goal":"lemma SetUnionAssoc_12723(T: set, S: set, A: set)\n ensures (T + S) + A == T + (S + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_12724","instance":12724,"id":216067,"goal":"lemma SetSubsetRefl_12724(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_12725","instance":12725,"id":216068,"goal":"lemma SetSubsetTrans_12725(A: set, U: set, S: set)\n requires A <= U && U <= S\n ensures A <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_12726","instance":12726,"id":216069,"goal":"lemma SetUnionEmpty_12726(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_12727","instance":12727,"id":216070,"goal":"lemma SetInterEmpty_12727(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_12728","instance":12728,"id":216071,"goal":"lemma SetInterSubset_12728(B: set, S: set)\n ensures B * S <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_12729","instance":12729,"id":216072,"goal":"lemma SetCardSubset_12729(T: set, A: set)\n requires T <= A\n ensures |T| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_12730","instance":12730,"id":216073,"goal":"lemma SetUnionCard_12730(T: set, A: set)\n requires T * A == {}\n ensures |T + A| == |T| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_12731","instance":12731,"id":216074,"goal":"lemma SetUnionComm_12731(S: set, U: set)\n ensures S + U == U + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_12732","instance":12732,"id":216075,"goal":"lemma SetInterComm_12732(B: set, U: set)\n ensures B * U == U * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_12733","instance":12733,"id":216076,"goal":"lemma SetUnionAssoc_12733(U: set, T: set, A: set)\n ensures (U + T) + A == U + (T + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_12734","instance":12734,"id":216077,"goal":"lemma SetSubsetRefl_12734(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_12735","instance":12735,"id":216078,"goal":"lemma SetSubsetTrans_12735(S: set, T: set, U: set)\n requires S <= T && T <= U\n ensures S <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_12736","instance":12736,"id":216079,"goal":"lemma SetUnionEmpty_12736(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_12737","instance":12737,"id":216080,"goal":"lemma SetInterEmpty_12737(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_12738","instance":12738,"id":216081,"goal":"lemma SetInterSubset_12738(S: set, T: set)\n ensures S * T <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_12739","instance":12739,"id":216082,"goal":"lemma SetCardSubset_12739(A: set, B: set)\n requires A <= B\n ensures |A| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_12740","instance":12740,"id":216083,"goal":"lemma SetUnionCard_12740(U: set, B: set)\n requires U * B == {}\n ensures |U + B| == |U| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_12741","instance":12741,"id":216084,"goal":"lemma SetUnionComm_12741(A: set, S: set)\n ensures A + S == S + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_12742","instance":12742,"id":216085,"goal":"lemma SetInterComm_12742(U: set, B: set)\n ensures U * B == B * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_12743","instance":12743,"id":216086,"goal":"lemma SetUnionAssoc_12743(U: set, A: set, S: set)\n ensures (U + A) + S == U + (A + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_12744","instance":12744,"id":216087,"goal":"lemma SetSubsetRefl_12744(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_12745","instance":12745,"id":216088,"goal":"lemma SetSubsetTrans_12745(T: set, U: set, S: set)\n requires T <= U && U <= S\n ensures T <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_12746","instance":12746,"id":216089,"goal":"lemma SetUnionEmpty_12746(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_12747","instance":12747,"id":216090,"goal":"lemma SetInterEmpty_12747(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_12748","instance":12748,"id":216091,"goal":"lemma SetInterSubset_12748(B: set, A: set)\n ensures B * A <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_12749","instance":12749,"id":216092,"goal":"lemma SetCardSubset_12749(T: set, S: set)\n requires T <= S\n ensures |T| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_12750","instance":12750,"id":216093,"goal":"lemma SetUnionCard_12750(A: set, B: set)\n requires A * B == {}\n ensures |A + B| == |A| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_12751","instance":12751,"id":216094,"goal":"lemma SetUnionComm_12751(T: set, B: set)\n ensures T + B == B + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_12752","instance":12752,"id":216095,"goal":"lemma SetInterComm_12752(U: set, A: set)\n ensures U * A == A * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_12753","instance":12753,"id":216096,"goal":"lemma SetUnionAssoc_12753(A: set, T: set, U: set)\n ensures (A + T) + U == A + (T + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_12754","instance":12754,"id":216097,"goal":"lemma SetSubsetRefl_12754(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_12755","instance":12755,"id":216098,"goal":"lemma SetSubsetTrans_12755(T: set, S: set, A: set)\n requires T <= S && S <= A\n ensures T <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_12756","instance":12756,"id":216099,"goal":"lemma SetUnionEmpty_12756(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_12757","instance":12757,"id":216100,"goal":"lemma SetInterEmpty_12757(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_12758","instance":12758,"id":216101,"goal":"lemma SetInterSubset_12758(B: set, A: set)\n ensures B * A <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_12759","instance":12759,"id":216102,"goal":"lemma SetCardSubset_12759(A: set, T: set)\n requires A <= T\n ensures |A| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_12760","instance":12760,"id":216103,"goal":"lemma SetUnionCard_12760(B: set, A: set)\n requires B * A == {}\n ensures |B + A| == |B| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_12761","instance":12761,"id":216104,"goal":"lemma SetUnionComm_12761(B: set, T: set)\n ensures B + T == T + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_12762","instance":12762,"id":216105,"goal":"lemma SetInterComm_12762(B: set, U: set)\n ensures B * U == U * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_12763","instance":12763,"id":216106,"goal":"lemma SetUnionAssoc_12763(U: set, S: set, B: set)\n ensures (U + S) + B == U + (S + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_12764","instance":12764,"id":216107,"goal":"lemma SetSubsetRefl_12764(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_12765","instance":12765,"id":216108,"goal":"lemma SetSubsetTrans_12765(U: set, B: set, T: set)\n requires U <= B && B <= T\n ensures U <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_12766","instance":12766,"id":216109,"goal":"lemma SetUnionEmpty_12766(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_12767","instance":12767,"id":216110,"goal":"lemma SetInterEmpty_12767(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_12768","instance":12768,"id":216111,"goal":"lemma SetInterSubset_12768(S: set, T: set)\n ensures S * T <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_12769","instance":12769,"id":216112,"goal":"lemma SetCardSubset_12769(U: set, A: set)\n requires U <= A\n ensures |U| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_12770","instance":12770,"id":216113,"goal":"lemma SetUnionCard_12770(T: set, S: set)\n requires T * S == {}\n ensures |T + S| == |T| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_12771","instance":12771,"id":216114,"goal":"lemma SetUnionComm_12771(T: set, B: set)\n ensures T + B == B + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_12772","instance":12772,"id":216115,"goal":"lemma SetInterComm_12772(B: set, U: set)\n ensures B * U == U * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_12773","instance":12773,"id":216116,"goal":"lemma SetUnionAssoc_12773(T: set, A: set, B: set)\n ensures (T + A) + B == T + (A + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_12774","instance":12774,"id":216117,"goal":"lemma SetSubsetRefl_12774(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_12775","instance":12775,"id":216118,"goal":"lemma SetSubsetTrans_12775(A: set, U: set, S: set)\n requires A <= U && U <= S\n ensures A <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_12776","instance":12776,"id":216119,"goal":"lemma SetUnionEmpty_12776(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_12777","instance":12777,"id":216120,"goal":"lemma SetInterEmpty_12777(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_12778","instance":12778,"id":216121,"goal":"lemma SetInterSubset_12778(T: set, A: set)\n ensures T * A <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_12779","instance":12779,"id":216122,"goal":"lemma SetCardSubset_12779(B: set, U: set)\n requires B <= U\n ensures |B| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_12780","instance":12780,"id":216123,"goal":"lemma SetUnionCard_12780(A: set, U: set)\n requires A * U == {}\n ensures |A + U| == |A| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_12781","instance":12781,"id":216124,"goal":"lemma SetUnionComm_12781(B: set, T: set)\n ensures B + T == T + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_12782","instance":12782,"id":216125,"goal":"lemma SetInterComm_12782(U: set, B: set)\n ensures U * B == B * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_12783","instance":12783,"id":216126,"goal":"lemma SetUnionAssoc_12783(U: set, T: set, S: set)\n ensures (U + T) + S == U + (T + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_12784","instance":12784,"id":216127,"goal":"lemma SetSubsetRefl_12784(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_12785","instance":12785,"id":216128,"goal":"lemma SetSubsetTrans_12785(U: set, S: set, T: set)\n requires U <= S && S <= T\n ensures U <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_12786","instance":12786,"id":216129,"goal":"lemma SetUnionEmpty_12786(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_12787","instance":12787,"id":216130,"goal":"lemma SetInterEmpty_12787(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_12788","instance":12788,"id":216131,"goal":"lemma SetInterSubset_12788(U: set, S: set)\n ensures U * S <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_12789","instance":12789,"id":216132,"goal":"lemma SetCardSubset_12789(T: set, B: set)\n requires T <= B\n ensures |T| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_12790","instance":12790,"id":216133,"goal":"lemma SetUnionCard_12790(B: set, A: set)\n requires B * A == {}\n ensures |B + A| == |B| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_12791","instance":12791,"id":216134,"goal":"lemma SetUnionComm_12791(T: set, S: set)\n ensures T + S == S + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_12792","instance":12792,"id":216135,"goal":"lemma SetInterComm_12792(T: set, B: set)\n ensures T * B == B * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_12793","instance":12793,"id":216136,"goal":"lemma SetUnionAssoc_12793(B: set, U: set, S: set)\n ensures (B + U) + S == B + (U + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_12794","instance":12794,"id":216137,"goal":"lemma SetSubsetRefl_12794(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_12795","instance":12795,"id":216138,"goal":"lemma SetSubsetTrans_12795(S: set, U: set, B: set)\n requires S <= U && U <= B\n ensures S <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_12796","instance":12796,"id":216139,"goal":"lemma SetUnionEmpty_12796(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_12797","instance":12797,"id":216140,"goal":"lemma SetInterEmpty_12797(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_12798","instance":12798,"id":216141,"goal":"lemma SetInterSubset_12798(S: set, U: set)\n ensures S * U <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_12799","instance":12799,"id":216142,"goal":"lemma SetCardSubset_12799(T: set, S: set)\n requires T <= S\n ensures |T| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_12800","instance":12800,"id":216143,"goal":"lemma SetUnionCard_12800(A: set, U: set)\n requires A * U == {}\n ensures |A + U| == |A| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_12801","instance":12801,"id":216144,"goal":"lemma SetUnionComm_12801(S: set, U: set)\n ensures S + U == U + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_12802","instance":12802,"id":216145,"goal":"lemma SetInterComm_12802(S: set, T: set)\n ensures S * T == T * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_12803","instance":12803,"id":216146,"goal":"lemma SetUnionAssoc_12803(T: set, A: set, B: set)\n ensures (T + A) + B == T + (A + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_12804","instance":12804,"id":216147,"goal":"lemma SetSubsetRefl_12804(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_12805","instance":12805,"id":216148,"goal":"lemma SetSubsetTrans_12805(A: set, T: set, U: set)\n requires A <= T && T <= U\n ensures A <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_12806","instance":12806,"id":216149,"goal":"lemma SetUnionEmpty_12806(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_12807","instance":12807,"id":216150,"goal":"lemma SetInterEmpty_12807(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_12808","instance":12808,"id":216151,"goal":"lemma SetInterSubset_12808(U: set, A: set)\n ensures U * A <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_12809","instance":12809,"id":216152,"goal":"lemma SetCardSubset_12809(B: set, A: set)\n requires B <= A\n ensures |B| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_12810","instance":12810,"id":216153,"goal":"lemma SetUnionCard_12810(S: set, A: set)\n requires S * A == {}\n ensures |S + A| == |S| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_12811","instance":12811,"id":216154,"goal":"lemma SetUnionComm_12811(T: set, A: set)\n ensures T + A == A + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_12812","instance":12812,"id":216155,"goal":"lemma SetInterComm_12812(A: set, S: set)\n ensures A * S == S * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_12813","instance":12813,"id":216156,"goal":"lemma SetUnionAssoc_12813(A: set, U: set, B: set)\n ensures (A + U) + B == A + (U + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_12814","instance":12814,"id":216157,"goal":"lemma SetSubsetRefl_12814(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_12815","instance":12815,"id":216158,"goal":"lemma SetSubsetTrans_12815(B: set, A: set, S: set)\n requires B <= A && A <= S\n ensures B <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_12816","instance":12816,"id":216159,"goal":"lemma SetUnionEmpty_12816(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_12817","instance":12817,"id":216160,"goal":"lemma SetInterEmpty_12817(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_12818","instance":12818,"id":216161,"goal":"lemma SetInterSubset_12818(A: set, S: set)\n ensures A * S <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_12819","instance":12819,"id":216162,"goal":"lemma SetCardSubset_12819(S: set, T: set)\n requires S <= T\n ensures |S| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_12820","instance":12820,"id":216163,"goal":"lemma SetUnionCard_12820(B: set, S: set)\n requires B * S == {}\n ensures |B + S| == |B| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_12821","instance":12821,"id":216164,"goal":"lemma SetUnionComm_12821(B: set, T: set)\n ensures B + T == T + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_12822","instance":12822,"id":216165,"goal":"lemma SetInterComm_12822(S: set, T: set)\n ensures S * T == T * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_12823","instance":12823,"id":216166,"goal":"lemma SetUnionAssoc_12823(B: set, A: set, U: set)\n ensures (B + A) + U == B + (A + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_12824","instance":12824,"id":216167,"goal":"lemma SetSubsetRefl_12824(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_12825","instance":12825,"id":216168,"goal":"lemma SetSubsetTrans_12825(B: set, S: set, A: set)\n requires B <= S && S <= A\n ensures B <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_12826","instance":12826,"id":216169,"goal":"lemma SetUnionEmpty_12826(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_12827","instance":12827,"id":216170,"goal":"lemma SetInterEmpty_12827(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_12828","instance":12828,"id":216171,"goal":"lemma SetInterSubset_12828(B: set, U: set)\n ensures B * U <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_12829","instance":12829,"id":216172,"goal":"lemma SetCardSubset_12829(U: set, S: set)\n requires U <= S\n ensures |U| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_12830","instance":12830,"id":216173,"goal":"lemma SetUnionCard_12830(T: set, A: set)\n requires T * A == {}\n ensures |T + A| == |T| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_12831","instance":12831,"id":216174,"goal":"lemma SetUnionComm_12831(B: set, U: set)\n ensures B + U == U + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_12832","instance":12832,"id":216175,"goal":"lemma SetInterComm_12832(A: set, T: set)\n ensures A * T == T * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_12833","instance":12833,"id":216176,"goal":"lemma SetUnionAssoc_12833(U: set, S: set, B: set)\n ensures (U + S) + B == U + (S + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_12834","instance":12834,"id":216177,"goal":"lemma SetSubsetRefl_12834(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_12835","instance":12835,"id":216178,"goal":"lemma SetSubsetTrans_12835(B: set, U: set, T: set)\n requires B <= U && U <= T\n ensures B <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_12836","instance":12836,"id":216179,"goal":"lemma SetUnionEmpty_12836(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_12837","instance":12837,"id":216180,"goal":"lemma SetInterEmpty_12837(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_12838","instance":12838,"id":216181,"goal":"lemma SetInterSubset_12838(B: set, S: set)\n ensures B * S <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_12839","instance":12839,"id":216182,"goal":"lemma SetCardSubset_12839(U: set, S: set)\n requires U <= S\n ensures |U| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_12840","instance":12840,"id":216183,"goal":"lemma SetUnionCard_12840(B: set, U: set)\n requires B * U == {}\n ensures |B + U| == |B| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_12841","instance":12841,"id":216184,"goal":"lemma SetUnionComm_12841(T: set, S: set)\n ensures T + S == S + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_12842","instance":12842,"id":216185,"goal":"lemma SetInterComm_12842(B: set, T: set)\n ensures B * T == T * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_12843","instance":12843,"id":216186,"goal":"lemma SetUnionAssoc_12843(A: set, S: set, U: set)\n ensures (A + S) + U == A + (S + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_12844","instance":12844,"id":216187,"goal":"lemma SetSubsetRefl_12844(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_12845","instance":12845,"id":216188,"goal":"lemma SetSubsetTrans_12845(A: set, S: set, U: set)\n requires A <= S && S <= U\n ensures A <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_12846","instance":12846,"id":216189,"goal":"lemma SetUnionEmpty_12846(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_12847","instance":12847,"id":216190,"goal":"lemma SetInterEmpty_12847(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_12848","instance":12848,"id":216191,"goal":"lemma SetInterSubset_12848(U: set, A: set)\n ensures U * A <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_12849","instance":12849,"id":216192,"goal":"lemma SetCardSubset_12849(A: set, T: set)\n requires A <= T\n ensures |A| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_12850","instance":12850,"id":216193,"goal":"lemma SetUnionCard_12850(A: set, U: set)\n requires A * U == {}\n ensures |A + U| == |A| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_12851","instance":12851,"id":216194,"goal":"lemma SetUnionComm_12851(A: set, T: set)\n ensures A + T == T + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_12852","instance":12852,"id":216195,"goal":"lemma SetInterComm_12852(U: set, B: set)\n ensures U * B == B * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_12853","instance":12853,"id":216196,"goal":"lemma SetUnionAssoc_12853(S: set, B: set, A: set)\n ensures (S + B) + A == S + (B + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_12854","instance":12854,"id":216197,"goal":"lemma SetSubsetRefl_12854(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_12855","instance":12855,"id":216198,"goal":"lemma SetSubsetTrans_12855(T: set, B: set, A: set)\n requires T <= B && B <= A\n ensures T <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_12856","instance":12856,"id":216199,"goal":"lemma SetUnionEmpty_12856(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_12857","instance":12857,"id":216200,"goal":"lemma SetInterEmpty_12857(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_12858","instance":12858,"id":216201,"goal":"lemma SetInterSubset_12858(U: set, A: set)\n ensures U * A <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_12859","instance":12859,"id":216202,"goal":"lemma SetCardSubset_12859(T: set, U: set)\n requires T <= U\n ensures |T| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_12860","instance":12860,"id":216203,"goal":"lemma SetUnionCard_12860(U: set, T: set)\n requires U * T == {}\n ensures |U + T| == |U| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_12861","instance":12861,"id":216204,"goal":"lemma SetUnionComm_12861(A: set, T: set)\n ensures A + T == T + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_12862","instance":12862,"id":216205,"goal":"lemma SetInterComm_12862(B: set, A: set)\n ensures B * A == A * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_12863","instance":12863,"id":216206,"goal":"lemma SetUnionAssoc_12863(T: set, A: set, B: set)\n ensures (T + A) + B == T + (A + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_12864","instance":12864,"id":216207,"goal":"lemma SetSubsetRefl_12864(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_12865","instance":12865,"id":216208,"goal":"lemma SetSubsetTrans_12865(A: set, T: set, S: set)\n requires A <= T && T <= S\n ensures A <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_12866","instance":12866,"id":216209,"goal":"lemma SetUnionEmpty_12866(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_12867","instance":12867,"id":216210,"goal":"lemma SetInterEmpty_12867(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_12868","instance":12868,"id":216211,"goal":"lemma SetInterSubset_12868(T: set, U: set)\n ensures T * U <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_12869","instance":12869,"id":216212,"goal":"lemma SetCardSubset_12869(S: set, A: set)\n requires S <= A\n ensures |S| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_12870","instance":12870,"id":216213,"goal":"lemma SetUnionCard_12870(B: set, U: set)\n requires B * U == {}\n ensures |B + U| == |B| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_12871","instance":12871,"id":216214,"goal":"lemma SetUnionComm_12871(T: set, S: set)\n ensures T + S == S + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_12872","instance":12872,"id":216215,"goal":"lemma SetInterComm_12872(T: set, A: set)\n ensures T * A == A * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_12873","instance":12873,"id":216216,"goal":"lemma SetUnionAssoc_12873(A: set, T: set, U: set)\n ensures (A + T) + U == A + (T + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_12874","instance":12874,"id":216217,"goal":"lemma SetSubsetRefl_12874(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_12875","instance":12875,"id":216218,"goal":"lemma SetSubsetTrans_12875(A: set, T: set, S: set)\n requires A <= T && T <= S\n ensures A <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_12876","instance":12876,"id":216219,"goal":"lemma SetUnionEmpty_12876(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_12877","instance":12877,"id":216220,"goal":"lemma SetInterEmpty_12877(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_12878","instance":12878,"id":216221,"goal":"lemma SetInterSubset_12878(U: set, A: set)\n ensures U * A <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_12879","instance":12879,"id":216222,"goal":"lemma SetCardSubset_12879(S: set, T: set)\n requires S <= T\n ensures |S| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_12880","instance":12880,"id":216223,"goal":"lemma SetUnionCard_12880(A: set, S: set)\n requires A * S == {}\n ensures |A + S| == |A| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_12881","instance":12881,"id":216224,"goal":"lemma SetUnionComm_12881(U: set, A: set)\n ensures U + A == A + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_12882","instance":12882,"id":216225,"goal":"lemma SetInterComm_12882(T: set, U: set)\n ensures T * U == U * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_12883","instance":12883,"id":216226,"goal":"lemma SetUnionAssoc_12883(A: set, U: set, B: set)\n ensures (A + U) + B == A + (U + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_12884","instance":12884,"id":216227,"goal":"lemma SetSubsetRefl_12884(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_12885","instance":12885,"id":216228,"goal":"lemma SetSubsetTrans_12885(T: set, B: set, S: set)\n requires T <= B && B <= S\n ensures T <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_12886","instance":12886,"id":216229,"goal":"lemma SetUnionEmpty_12886(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_12887","instance":12887,"id":216230,"goal":"lemma SetInterEmpty_12887(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_12888","instance":12888,"id":216231,"goal":"lemma SetInterSubset_12888(B: set, A: set)\n ensures B * A <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_12889","instance":12889,"id":216232,"goal":"lemma SetCardSubset_12889(T: set, A: set)\n requires T <= A\n ensures |T| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_12890","instance":12890,"id":216233,"goal":"lemma SetUnionCard_12890(A: set, T: set)\n requires A * T == {}\n ensures |A + T| == |A| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_12891","instance":12891,"id":216234,"goal":"lemma SetUnionComm_12891(A: set, U: set)\n ensures A + U == U + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_12892","instance":12892,"id":216235,"goal":"lemma SetInterComm_12892(T: set, S: set)\n ensures T * S == S * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_12893","instance":12893,"id":216236,"goal":"lemma SetUnionAssoc_12893(A: set, T: set, U: set)\n ensures (A + T) + U == A + (T + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_12894","instance":12894,"id":216237,"goal":"lemma SetSubsetRefl_12894(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_12895","instance":12895,"id":216238,"goal":"lemma SetSubsetTrans_12895(T: set, B: set, U: set)\n requires T <= B && B <= U\n ensures T <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_12896","instance":12896,"id":216239,"goal":"lemma SetUnionEmpty_12896(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_12897","instance":12897,"id":216240,"goal":"lemma SetInterEmpty_12897(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_12898","instance":12898,"id":216241,"goal":"lemma SetInterSubset_12898(T: set, B: set)\n ensures T * B <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_12899","instance":12899,"id":216242,"goal":"lemma SetCardSubset_12899(A: set, T: set)\n requires A <= T\n ensures |A| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_12900","instance":12900,"id":216243,"goal":"lemma SetUnionCard_12900(A: set, T: set)\n requires A * T == {}\n ensures |A + T| == |A| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_12901","instance":12901,"id":216244,"goal":"lemma SetUnionComm_12901(U: set, S: set)\n ensures U + S == S + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_12902","instance":12902,"id":216245,"goal":"lemma SetInterComm_12902(B: set, S: set)\n ensures B * S == S * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_12903","instance":12903,"id":216246,"goal":"lemma SetUnionAssoc_12903(B: set, U: set, T: set)\n ensures (B + U) + T == B + (U + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_12904","instance":12904,"id":216247,"goal":"lemma SetSubsetRefl_12904(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_12905","instance":12905,"id":216248,"goal":"lemma SetSubsetTrans_12905(U: set, B: set, A: set)\n requires U <= B && B <= A\n ensures U <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_12906","instance":12906,"id":216249,"goal":"lemma SetUnionEmpty_12906(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_12907","instance":12907,"id":216250,"goal":"lemma SetInterEmpty_12907(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_12908","instance":12908,"id":216251,"goal":"lemma SetInterSubset_12908(B: set, A: set)\n ensures B * A <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_12909","instance":12909,"id":216252,"goal":"lemma SetCardSubset_12909(T: set, S: set)\n requires T <= S\n ensures |T| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_12910","instance":12910,"id":216253,"goal":"lemma SetUnionCard_12910(B: set, U: set)\n requires B * U == {}\n ensures |B + U| == |B| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_12911","instance":12911,"id":216254,"goal":"lemma SetUnionComm_12911(T: set, A: set)\n ensures T + A == A + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_12912","instance":12912,"id":216255,"goal":"lemma SetInterComm_12912(A: set, U: set)\n ensures A * U == U * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_12913","instance":12913,"id":216256,"goal":"lemma SetUnionAssoc_12913(U: set, S: set, T: set)\n ensures (U + S) + T == U + (S + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_12914","instance":12914,"id":216257,"goal":"lemma SetSubsetRefl_12914(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_12915","instance":12915,"id":216258,"goal":"lemma SetSubsetTrans_12915(S: set, A: set, U: set)\n requires S <= A && A <= U\n ensures S <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_12916","instance":12916,"id":216259,"goal":"lemma SetUnionEmpty_12916(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_12917","instance":12917,"id":216260,"goal":"lemma SetInterEmpty_12917(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_12918","instance":12918,"id":216261,"goal":"lemma SetInterSubset_12918(U: set, S: set)\n ensures U * S <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_12919","instance":12919,"id":216262,"goal":"lemma SetCardSubset_12919(B: set, U: set)\n requires B <= U\n ensures |B| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_12920","instance":12920,"id":216263,"goal":"lemma SetUnionCard_12920(A: set, U: set)\n requires A * U == {}\n ensures |A + U| == |A| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_12921","instance":12921,"id":216264,"goal":"lemma SetUnionComm_12921(T: set, A: set)\n ensures T + A == A + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_12922","instance":12922,"id":216265,"goal":"lemma SetInterComm_12922(A: set, T: set)\n ensures A * T == T * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_12923","instance":12923,"id":216266,"goal":"lemma SetUnionAssoc_12923(A: set, S: set, T: set)\n ensures (A + S) + T == A + (S + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_12924","instance":12924,"id":216267,"goal":"lemma SetSubsetRefl_12924(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_12925","instance":12925,"id":216268,"goal":"lemma SetSubsetTrans_12925(A: set, S: set, B: set)\n requires A <= S && S <= B\n ensures A <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_12926","instance":12926,"id":216269,"goal":"lemma SetUnionEmpty_12926(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_12927","instance":12927,"id":216270,"goal":"lemma SetInterEmpty_12927(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_12928","instance":12928,"id":216271,"goal":"lemma SetInterSubset_12928(B: set, T: set)\n ensures B * T <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_12929","instance":12929,"id":216272,"goal":"lemma SetCardSubset_12929(T: set, A: set)\n requires T <= A\n ensures |T| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_12930","instance":12930,"id":216273,"goal":"lemma SetUnionCard_12930(S: set, T: set)\n requires S * T == {}\n ensures |S + T| == |S| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_12931","instance":12931,"id":216274,"goal":"lemma SetUnionComm_12931(T: set, S: set)\n ensures T + S == S + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_12932","instance":12932,"id":216275,"goal":"lemma SetInterComm_12932(S: set, U: set)\n ensures S * U == U * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_12933","instance":12933,"id":216276,"goal":"lemma SetUnionAssoc_12933(B: set, U: set, T: set)\n ensures (B + U) + T == B + (U + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_12934","instance":12934,"id":216277,"goal":"lemma SetSubsetRefl_12934(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_12935","instance":12935,"id":216278,"goal":"lemma SetSubsetTrans_12935(B: set, A: set, S: set)\n requires B <= A && A <= S\n ensures B <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_12936","instance":12936,"id":216279,"goal":"lemma SetUnionEmpty_12936(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_12937","instance":12937,"id":216280,"goal":"lemma SetInterEmpty_12937(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_12938","instance":12938,"id":216281,"goal":"lemma SetInterSubset_12938(T: set, S: set)\n ensures T * S <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_12939","instance":12939,"id":216282,"goal":"lemma SetCardSubset_12939(S: set, T: set)\n requires S <= T\n ensures |S| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_12940","instance":12940,"id":216283,"goal":"lemma SetUnionCard_12940(U: set, A: set)\n requires U * A == {}\n ensures |U + A| == |U| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_12941","instance":12941,"id":216284,"goal":"lemma SetUnionComm_12941(U: set, S: set)\n ensures U + S == S + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_12942","instance":12942,"id":216285,"goal":"lemma SetInterComm_12942(A: set, S: set)\n ensures A * S == S * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_12943","instance":12943,"id":216286,"goal":"lemma SetUnionAssoc_12943(B: set, T: set, U: set)\n ensures (B + T) + U == B + (T + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_12944","instance":12944,"id":216287,"goal":"lemma SetSubsetRefl_12944(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_12945","instance":12945,"id":216288,"goal":"lemma SetSubsetTrans_12945(T: set, S: set, U: set)\n requires T <= S && S <= U\n ensures T <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_12946","instance":12946,"id":216289,"goal":"lemma SetUnionEmpty_12946(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_12947","instance":12947,"id":216290,"goal":"lemma SetInterEmpty_12947(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_12948","instance":12948,"id":216291,"goal":"lemma SetInterSubset_12948(T: set, A: set)\n ensures T * A <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_12949","instance":12949,"id":216292,"goal":"lemma SetCardSubset_12949(S: set, T: set)\n requires S <= T\n ensures |S| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_12950","instance":12950,"id":216293,"goal":"lemma SetUnionCard_12950(S: set, T: set)\n requires S * T == {}\n ensures |S + T| == |S| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_12951","instance":12951,"id":216294,"goal":"lemma SetUnionComm_12951(U: set, T: set)\n ensures U + T == T + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_12952","instance":12952,"id":216295,"goal":"lemma SetInterComm_12952(T: set, B: set)\n ensures T * B == B * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_12953","instance":12953,"id":216296,"goal":"lemma SetUnionAssoc_12953(A: set, B: set, S: set)\n ensures (A + B) + S == A + (B + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_12954","instance":12954,"id":216297,"goal":"lemma SetSubsetRefl_12954(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_12955","instance":12955,"id":216298,"goal":"lemma SetSubsetTrans_12955(U: set, B: set, A: set)\n requires U <= B && B <= A\n ensures U <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_12956","instance":12956,"id":216299,"goal":"lemma SetUnionEmpty_12956(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_12957","instance":12957,"id":216300,"goal":"lemma SetInterEmpty_12957(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_12958","instance":12958,"id":216301,"goal":"lemma SetInterSubset_12958(T: set, A: set)\n ensures T * A <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_12959","instance":12959,"id":216302,"goal":"lemma SetCardSubset_12959(B: set, U: set)\n requires B <= U\n ensures |B| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_12960","instance":12960,"id":216303,"goal":"lemma SetUnionCard_12960(S: set, U: set)\n requires S * U == {}\n ensures |S + U| == |S| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_12961","instance":12961,"id":216304,"goal":"lemma SetUnionComm_12961(U: set, T: set)\n ensures U + T == T + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_12962","instance":12962,"id":216305,"goal":"lemma SetInterComm_12962(U: set, B: set)\n ensures U * B == B * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_12963","instance":12963,"id":216306,"goal":"lemma SetUnionAssoc_12963(T: set, S: set, A: set)\n ensures (T + S) + A == T + (S + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_12964","instance":12964,"id":216307,"goal":"lemma SetSubsetRefl_12964(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_12965","instance":12965,"id":216308,"goal":"lemma SetSubsetTrans_12965(T: set, U: set, B: set)\n requires T <= U && U <= B\n ensures T <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_12966","instance":12966,"id":216309,"goal":"lemma SetUnionEmpty_12966(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_12967","instance":12967,"id":216310,"goal":"lemma SetInterEmpty_12967(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_12968","instance":12968,"id":216311,"goal":"lemma SetInterSubset_12968(B: set, U: set)\n ensures B * U <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_12969","instance":12969,"id":216312,"goal":"lemma SetCardSubset_12969(T: set, B: set)\n requires T <= B\n ensures |T| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_12970","instance":12970,"id":216313,"goal":"lemma SetUnionCard_12970(B: set, A: set)\n requires B * A == {}\n ensures |B + A| == |B| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_12971","instance":12971,"id":216314,"goal":"lemma SetUnionComm_12971(U: set, A: set)\n ensures U + A == A + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_12972","instance":12972,"id":216315,"goal":"lemma SetInterComm_12972(B: set, T: set)\n ensures B * T == T * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_12973","instance":12973,"id":216316,"goal":"lemma SetUnionAssoc_12973(T: set, B: set, A: set)\n ensures (T + B) + A == T + (B + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_12974","instance":12974,"id":216317,"goal":"lemma SetSubsetRefl_12974(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_12975","instance":12975,"id":216318,"goal":"lemma SetSubsetTrans_12975(B: set, T: set, A: set)\n requires B <= T && T <= A\n ensures B <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_12976","instance":12976,"id":216319,"goal":"lemma SetUnionEmpty_12976(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_12977","instance":12977,"id":216320,"goal":"lemma SetInterEmpty_12977(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_12978","instance":12978,"id":216321,"goal":"lemma SetInterSubset_12978(B: set, T: set)\n ensures B * T <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_12979","instance":12979,"id":216322,"goal":"lemma SetCardSubset_12979(U: set, A: set)\n requires U <= A\n ensures |U| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_12980","instance":12980,"id":216323,"goal":"lemma SetUnionCard_12980(T: set, A: set)\n requires T * A == {}\n ensures |T + A| == |T| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_12981","instance":12981,"id":216324,"goal":"lemma SetUnionComm_12981(S: set, T: set)\n ensures S + T == T + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_12982","instance":12982,"id":216325,"goal":"lemma SetInterComm_12982(A: set, S: set)\n ensures A * S == S * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_12983","instance":12983,"id":216326,"goal":"lemma SetUnionAssoc_12983(A: set, U: set, S: set)\n ensures (A + U) + S == A + (U + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_12984","instance":12984,"id":216327,"goal":"lemma SetSubsetRefl_12984(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_12985","instance":12985,"id":216328,"goal":"lemma SetSubsetTrans_12985(A: set, B: set, S: set)\n requires A <= B && B <= S\n ensures A <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_12986","instance":12986,"id":216329,"goal":"lemma SetUnionEmpty_12986(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_12987","instance":12987,"id":216330,"goal":"lemma SetInterEmpty_12987(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_12988","instance":12988,"id":216331,"goal":"lemma SetInterSubset_12988(S: set, A: set)\n ensures S * A <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_12989","instance":12989,"id":216332,"goal":"lemma SetCardSubset_12989(A: set, U: set)\n requires A <= U\n ensures |A| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_12990","instance":12990,"id":216333,"goal":"lemma SetUnionCard_12990(T: set, U: set)\n requires T * U == {}\n ensures |T + U| == |T| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_12991","instance":12991,"id":216334,"goal":"lemma SetUnionComm_12991(U: set, T: set)\n ensures U + T == T + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_12992","instance":12992,"id":216335,"goal":"lemma SetInterComm_12992(U: set, A: set)\n ensures U * A == A * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_12993","instance":12993,"id":216336,"goal":"lemma SetUnionAssoc_12993(U: set, T: set, S: set)\n ensures (U + T) + S == U + (T + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_12994","instance":12994,"id":216337,"goal":"lemma SetSubsetRefl_12994(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_12995","instance":12995,"id":216338,"goal":"lemma SetSubsetTrans_12995(U: set, S: set, B: set)\n requires U <= S && S <= B\n ensures U <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_12996","instance":12996,"id":216339,"goal":"lemma SetUnionEmpty_12996(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_12997","instance":12997,"id":216340,"goal":"lemma SetInterEmpty_12997(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_12998","instance":12998,"id":216341,"goal":"lemma SetInterSubset_12998(A: set, B: set)\n ensures A * B <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_12999","instance":12999,"id":216342,"goal":"lemma SetCardSubset_12999(S: set, A: set)\n requires S <= A\n ensures |S| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_13000","instance":13000,"id":216343,"goal":"lemma SetUnionCard_13000(T: set, S: set)\n requires T * S == {}\n ensures |T + S| == |T| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_13001","instance":13001,"id":216344,"goal":"lemma SetUnionComm_13001(A: set, B: set)\n ensures A + B == B + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_13002","instance":13002,"id":216345,"goal":"lemma SetInterComm_13002(T: set, A: set)\n ensures T * A == A * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_13003","instance":13003,"id":216346,"goal":"lemma SetUnionAssoc_13003(U: set, A: set, T: set)\n ensures (U + A) + T == U + (A + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_13004","instance":13004,"id":216347,"goal":"lemma SetSubsetRefl_13004(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_13005","instance":13005,"id":216348,"goal":"lemma SetSubsetTrans_13005(A: set, B: set, T: set)\n requires A <= B && B <= T\n ensures A <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_13006","instance":13006,"id":216349,"goal":"lemma SetUnionEmpty_13006(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_13007","instance":13007,"id":216350,"goal":"lemma SetInterEmpty_13007(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_13008","instance":13008,"id":216351,"goal":"lemma SetInterSubset_13008(U: set, A: set)\n ensures U * A <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_13009","instance":13009,"id":216352,"goal":"lemma SetCardSubset_13009(A: set, S: set)\n requires A <= S\n ensures |A| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_13010","instance":13010,"id":216353,"goal":"lemma SetUnionCard_13010(U: set, A: set)\n requires U * A == {}\n ensures |U + A| == |U| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_13011","instance":13011,"id":216354,"goal":"lemma SetUnionComm_13011(A: set, U: set)\n ensures A + U == U + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_13012","instance":13012,"id":216355,"goal":"lemma SetInterComm_13012(T: set, A: set)\n ensures T * A == A * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_13013","instance":13013,"id":216356,"goal":"lemma SetUnionAssoc_13013(A: set, U: set, B: set)\n ensures (A + U) + B == A + (U + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_13014","instance":13014,"id":216357,"goal":"lemma SetSubsetRefl_13014(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_13015","instance":13015,"id":216358,"goal":"lemma SetSubsetTrans_13015(T: set, U: set, B: set)\n requires T <= U && U <= B\n ensures T <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_13016","instance":13016,"id":216359,"goal":"lemma SetUnionEmpty_13016(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_13017","instance":13017,"id":216360,"goal":"lemma SetInterEmpty_13017(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_13018","instance":13018,"id":216361,"goal":"lemma SetInterSubset_13018(T: set, A: set)\n ensures T * A <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_13019","instance":13019,"id":216362,"goal":"lemma SetCardSubset_13019(U: set, B: set)\n requires U <= B\n ensures |U| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_13020","instance":13020,"id":216363,"goal":"lemma SetUnionCard_13020(T: set, B: set)\n requires T * B == {}\n ensures |T + B| == |T| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_13021","instance":13021,"id":216364,"goal":"lemma SetUnionComm_13021(B: set, S: set)\n ensures B + S == S + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_13022","instance":13022,"id":216365,"goal":"lemma SetInterComm_13022(B: set, U: set)\n ensures B * U == U * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_13023","instance":13023,"id":216366,"goal":"lemma SetUnionAssoc_13023(A: set, T: set, S: set)\n ensures (A + T) + S == A + (T + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_13024","instance":13024,"id":216367,"goal":"lemma SetSubsetRefl_13024(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_13025","instance":13025,"id":216368,"goal":"lemma SetSubsetTrans_13025(T: set, A: set, B: set)\n requires T <= A && A <= B\n ensures T <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_13026","instance":13026,"id":216369,"goal":"lemma SetUnionEmpty_13026(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_13027","instance":13027,"id":216370,"goal":"lemma SetInterEmpty_13027(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_13028","instance":13028,"id":216371,"goal":"lemma SetInterSubset_13028(U: set, T: set)\n ensures U * T <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_13029","instance":13029,"id":216372,"goal":"lemma SetCardSubset_13029(U: set, B: set)\n requires U <= B\n ensures |U| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_13030","instance":13030,"id":216373,"goal":"lemma SetUnionCard_13030(T: set, A: set)\n requires T * A == {}\n ensures |T + A| == |T| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_13031","instance":13031,"id":216374,"goal":"lemma SetUnionComm_13031(B: set, T: set)\n ensures B + T == T + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_13032","instance":13032,"id":216375,"goal":"lemma SetInterComm_13032(B: set, A: set)\n ensures B * A == A * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_13033","instance":13033,"id":216376,"goal":"lemma SetUnionAssoc_13033(B: set, S: set, T: set)\n ensures (B + S) + T == B + (S + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_13034","instance":13034,"id":216377,"goal":"lemma SetSubsetRefl_13034(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_13035","instance":13035,"id":216378,"goal":"lemma SetSubsetTrans_13035(T: set, U: set, S: set)\n requires T <= U && U <= S\n ensures T <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_13036","instance":13036,"id":216379,"goal":"lemma SetUnionEmpty_13036(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_13037","instance":13037,"id":216380,"goal":"lemma SetInterEmpty_13037(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_13038","instance":13038,"id":216381,"goal":"lemma SetInterSubset_13038(T: set, S: set)\n ensures T * S <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_13039","instance":13039,"id":216382,"goal":"lemma SetCardSubset_13039(S: set, T: set)\n requires S <= T\n ensures |S| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_13040","instance":13040,"id":216383,"goal":"lemma SetUnionCard_13040(T: set, S: set)\n requires T * S == {}\n ensures |T + S| == |T| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_13041","instance":13041,"id":216384,"goal":"lemma SetUnionComm_13041(T: set, B: set)\n ensures T + B == B + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_13042","instance":13042,"id":216385,"goal":"lemma SetInterComm_13042(T: set, U: set)\n ensures T * U == U * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_13043","instance":13043,"id":216386,"goal":"lemma SetUnionAssoc_13043(B: set, A: set, U: set)\n ensures (B + A) + U == B + (A + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_13044","instance":13044,"id":216387,"goal":"lemma SetSubsetRefl_13044(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_13045","instance":13045,"id":216388,"goal":"lemma SetSubsetTrans_13045(U: set, B: set, A: set)\n requires U <= B && B <= A\n ensures U <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_13046","instance":13046,"id":216389,"goal":"lemma SetUnionEmpty_13046(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_13047","instance":13047,"id":216390,"goal":"lemma SetInterEmpty_13047(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_13048","instance":13048,"id":216391,"goal":"lemma SetInterSubset_13048(S: set, U: set)\n ensures S * U <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_13049","instance":13049,"id":216392,"goal":"lemma SetCardSubset_13049(T: set, A: set)\n requires T <= A\n ensures |T| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_13050","instance":13050,"id":216393,"goal":"lemma SetUnionCard_13050(U: set, T: set)\n requires U * T == {}\n ensures |U + T| == |U| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_13051","instance":13051,"id":216394,"goal":"lemma SetUnionComm_13051(S: set, T: set)\n ensures S + T == T + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_13052","instance":13052,"id":216395,"goal":"lemma SetInterComm_13052(S: set, T: set)\n ensures S * T == T * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_13053","instance":13053,"id":216396,"goal":"lemma SetUnionAssoc_13053(B: set, A: set, U: set)\n ensures (B + A) + U == B + (A + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_13054","instance":13054,"id":216397,"goal":"lemma SetSubsetRefl_13054(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_13055","instance":13055,"id":216398,"goal":"lemma SetSubsetTrans_13055(T: set, S: set, B: set)\n requires T <= S && S <= B\n ensures T <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_13056","instance":13056,"id":216399,"goal":"lemma SetUnionEmpty_13056(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_13057","instance":13057,"id":216400,"goal":"lemma SetInterEmpty_13057(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_13058","instance":13058,"id":216401,"goal":"lemma SetInterSubset_13058(S: set, B: set)\n ensures S * B <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_13059","instance":13059,"id":216402,"goal":"lemma SetCardSubset_13059(A: set, T: set)\n requires A <= T\n ensures |A| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_13060","instance":13060,"id":216403,"goal":"lemma SetUnionCard_13060(T: set, A: set)\n requires T * A == {}\n ensures |T + A| == |T| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_13061","instance":13061,"id":216404,"goal":"lemma SetUnionComm_13061(U: set, B: set)\n ensures U + B == B + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_13062","instance":13062,"id":216405,"goal":"lemma SetInterComm_13062(T: set, B: set)\n ensures T * B == B * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_13063","instance":13063,"id":216406,"goal":"lemma SetUnionAssoc_13063(A: set, T: set, S: set)\n ensures (A + T) + S == A + (T + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_13064","instance":13064,"id":216407,"goal":"lemma SetSubsetRefl_13064(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_13065","instance":13065,"id":216408,"goal":"lemma SetSubsetTrans_13065(B: set, S: set, A: set)\n requires B <= S && S <= A\n ensures B <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_13066","instance":13066,"id":216409,"goal":"lemma SetUnionEmpty_13066(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_13067","instance":13067,"id":216410,"goal":"lemma SetInterEmpty_13067(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_13068","instance":13068,"id":216411,"goal":"lemma SetInterSubset_13068(S: set, B: set)\n ensures S * B <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_13069","instance":13069,"id":216412,"goal":"lemma SetCardSubset_13069(A: set, T: set)\n requires A <= T\n ensures |A| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_13070","instance":13070,"id":216413,"goal":"lemma SetUnionCard_13070(B: set, A: set)\n requires B * A == {}\n ensures |B + A| == |B| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_13071","instance":13071,"id":216414,"goal":"lemma SetUnionComm_13071(T: set, A: set)\n ensures T + A == A + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_13072","instance":13072,"id":216415,"goal":"lemma SetInterComm_13072(U: set, B: set)\n ensures U * B == B * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_13073","instance":13073,"id":216416,"goal":"lemma SetUnionAssoc_13073(T: set, S: set, U: set)\n ensures (T + S) + U == T + (S + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_13074","instance":13074,"id":216417,"goal":"lemma SetSubsetRefl_13074(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_13075","instance":13075,"id":216418,"goal":"lemma SetSubsetTrans_13075(B: set, A: set, T: set)\n requires B <= A && A <= T\n ensures B <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_13076","instance":13076,"id":216419,"goal":"lemma SetUnionEmpty_13076(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_13077","instance":13077,"id":216420,"goal":"lemma SetInterEmpty_13077(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_13078","instance":13078,"id":216421,"goal":"lemma SetInterSubset_13078(B: set, S: set)\n ensures B * S <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_13079","instance":13079,"id":216422,"goal":"lemma SetCardSubset_13079(T: set, B: set)\n requires T <= B\n ensures |T| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_13080","instance":13080,"id":216423,"goal":"lemma SetUnionCard_13080(A: set, B: set)\n requires A * B == {}\n ensures |A + B| == |A| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_13081","instance":13081,"id":216424,"goal":"lemma SetUnionComm_13081(B: set, S: set)\n ensures B + S == S + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_13082","instance":13082,"id":216425,"goal":"lemma SetInterComm_13082(B: set, T: set)\n ensures B * T == T * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_13083","instance":13083,"id":216426,"goal":"lemma SetUnionAssoc_13083(A: set, S: set, U: set)\n ensures (A + S) + U == A + (S + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_13084","instance":13084,"id":216427,"goal":"lemma SetSubsetRefl_13084(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_13085","instance":13085,"id":216428,"goal":"lemma SetSubsetTrans_13085(U: set, T: set, A: set)\n requires U <= T && T <= A\n ensures U <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_13086","instance":13086,"id":216429,"goal":"lemma SetUnionEmpty_13086(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_13087","instance":13087,"id":216430,"goal":"lemma SetInterEmpty_13087(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_13088","instance":13088,"id":216431,"goal":"lemma SetInterSubset_13088(U: set, T: set)\n ensures U * T <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_13089","instance":13089,"id":216432,"goal":"lemma SetCardSubset_13089(U: set, T: set)\n requires U <= T\n ensures |U| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_13090","instance":13090,"id":216433,"goal":"lemma SetUnionCard_13090(U: set, A: set)\n requires U * A == {}\n ensures |U + A| == |U| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_13091","instance":13091,"id":216434,"goal":"lemma SetUnionComm_13091(T: set, S: set)\n ensures T + S == S + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_13092","instance":13092,"id":216435,"goal":"lemma SetInterComm_13092(S: set, U: set)\n ensures S * U == U * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_13093","instance":13093,"id":216436,"goal":"lemma SetUnionAssoc_13093(S: set, U: set, B: set)\n ensures (S + U) + B == S + (U + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_13094","instance":13094,"id":216437,"goal":"lemma SetSubsetRefl_13094(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_13095","instance":13095,"id":216438,"goal":"lemma SetSubsetTrans_13095(S: set, T: set, U: set)\n requires S <= T && T <= U\n ensures S <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_13096","instance":13096,"id":216439,"goal":"lemma SetUnionEmpty_13096(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_13097","instance":13097,"id":216440,"goal":"lemma SetInterEmpty_13097(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_13098","instance":13098,"id":216441,"goal":"lemma SetInterSubset_13098(B: set, T: set)\n ensures B * T <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_13099","instance":13099,"id":216442,"goal":"lemma SetCardSubset_13099(U: set, T: set)\n requires U <= T\n ensures |U| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_13100","instance":13100,"id":216443,"goal":"lemma SetUnionCard_13100(A: set, S: set)\n requires A * S == {}\n ensures |A + S| == |A| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_13101","instance":13101,"id":216444,"goal":"lemma SetUnionComm_13101(A: set, S: set)\n ensures A + S == S + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_13102","instance":13102,"id":216445,"goal":"lemma SetInterComm_13102(T: set, A: set)\n ensures T * A == A * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_13103","instance":13103,"id":216446,"goal":"lemma SetUnionAssoc_13103(A: set, T: set, U: set)\n ensures (A + T) + U == A + (T + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_13104","instance":13104,"id":216447,"goal":"lemma SetSubsetRefl_13104(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_13105","instance":13105,"id":216448,"goal":"lemma SetSubsetTrans_13105(T: set, S: set, A: set)\n requires T <= S && S <= A\n ensures T <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_13106","instance":13106,"id":216449,"goal":"lemma SetUnionEmpty_13106(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_13107","instance":13107,"id":216450,"goal":"lemma SetInterEmpty_13107(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_13108","instance":13108,"id":216451,"goal":"lemma SetInterSubset_13108(A: set, U: set)\n ensures A * U <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_13109","instance":13109,"id":216452,"goal":"lemma SetCardSubset_13109(U: set, B: set)\n requires U <= B\n ensures |U| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_13110","instance":13110,"id":216453,"goal":"lemma SetUnionCard_13110(T: set, B: set)\n requires T * B == {}\n ensures |T + B| == |T| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_13111","instance":13111,"id":216454,"goal":"lemma SetUnionComm_13111(B: set, A: set)\n ensures B + A == A + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_13112","instance":13112,"id":216455,"goal":"lemma SetInterComm_13112(U: set, S: set)\n ensures U * S == S * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_13113","instance":13113,"id":216456,"goal":"lemma SetUnionAssoc_13113(A: set, T: set, S: set)\n ensures (A + T) + S == A + (T + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_13114","instance":13114,"id":216457,"goal":"lemma SetSubsetRefl_13114(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_13115","instance":13115,"id":216458,"goal":"lemma SetSubsetTrans_13115(S: set, B: set, A: set)\n requires S <= B && B <= A\n ensures S <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_13116","instance":13116,"id":216459,"goal":"lemma SetUnionEmpty_13116(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_13117","instance":13117,"id":216460,"goal":"lemma SetInterEmpty_13117(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_13118","instance":13118,"id":216461,"goal":"lemma SetInterSubset_13118(B: set, T: set)\n ensures B * T <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_13119","instance":13119,"id":216462,"goal":"lemma SetCardSubset_13119(S: set, T: set)\n requires S <= T\n ensures |S| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_13120","instance":13120,"id":216463,"goal":"lemma SetUnionCard_13120(B: set, U: set)\n requires B * U == {}\n ensures |B + U| == |B| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_13121","instance":13121,"id":216464,"goal":"lemma SetUnionComm_13121(B: set, T: set)\n ensures B + T == T + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_13122","instance":13122,"id":216465,"goal":"lemma SetInterComm_13122(U: set, T: set)\n ensures U * T == T * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_13123","instance":13123,"id":216466,"goal":"lemma SetUnionAssoc_13123(S: set, B: set, T: set)\n ensures (S + B) + T == S + (B + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_13124","instance":13124,"id":216467,"goal":"lemma SetSubsetRefl_13124(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_13125","instance":13125,"id":216468,"goal":"lemma SetSubsetTrans_13125(U: set, T: set, A: set)\n requires U <= T && T <= A\n ensures U <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_13126","instance":13126,"id":216469,"goal":"lemma SetUnionEmpty_13126(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_13127","instance":13127,"id":216470,"goal":"lemma SetInterEmpty_13127(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_13128","instance":13128,"id":216471,"goal":"lemma SetInterSubset_13128(T: set, U: set)\n ensures T * U <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_13129","instance":13129,"id":216472,"goal":"lemma SetCardSubset_13129(T: set, B: set)\n requires T <= B\n ensures |T| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_13130","instance":13130,"id":216473,"goal":"lemma SetUnionCard_13130(B: set, A: set)\n requires B * A == {}\n ensures |B + A| == |B| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_13131","instance":13131,"id":216474,"goal":"lemma SetUnionComm_13131(S: set, U: set)\n ensures S + U == U + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_13132","instance":13132,"id":216475,"goal":"lemma SetInterComm_13132(A: set, S: set)\n ensures A * S == S * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_13133","instance":13133,"id":216476,"goal":"lemma SetUnionAssoc_13133(A: set, T: set, U: set)\n ensures (A + T) + U == A + (T + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_13134","instance":13134,"id":216477,"goal":"lemma SetSubsetRefl_13134(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_13135","instance":13135,"id":216478,"goal":"lemma SetSubsetTrans_13135(T: set, B: set, S: set)\n requires T <= B && B <= S\n ensures T <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_13136","instance":13136,"id":216479,"goal":"lemma SetUnionEmpty_13136(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_13137","instance":13137,"id":216480,"goal":"lemma SetInterEmpty_13137(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_13138","instance":13138,"id":216481,"goal":"lemma SetInterSubset_13138(T: set, U: set)\n ensures T * U <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_13139","instance":13139,"id":216482,"goal":"lemma SetCardSubset_13139(A: set, B: set)\n requires A <= B\n ensures |A| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_13140","instance":13140,"id":216483,"goal":"lemma SetUnionCard_13140(B: set, S: set)\n requires B * S == {}\n ensures |B + S| == |B| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_13141","instance":13141,"id":216484,"goal":"lemma SetUnionComm_13141(T: set, A: set)\n ensures T + A == A + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_13142","instance":13142,"id":216485,"goal":"lemma SetInterComm_13142(A: set, U: set)\n ensures A * U == U * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_13143","instance":13143,"id":216486,"goal":"lemma SetUnionAssoc_13143(T: set, U: set, S: set)\n ensures (T + U) + S == T + (U + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_13144","instance":13144,"id":216487,"goal":"lemma SetSubsetRefl_13144(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_13145","instance":13145,"id":216488,"goal":"lemma SetSubsetTrans_13145(A: set, S: set, U: set)\n requires A <= S && S <= U\n ensures A <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_13146","instance":13146,"id":216489,"goal":"lemma SetUnionEmpty_13146(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_13147","instance":13147,"id":216490,"goal":"lemma SetInterEmpty_13147(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_13148","instance":13148,"id":216491,"goal":"lemma SetInterSubset_13148(U: set, T: set)\n ensures U * T <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_13149","instance":13149,"id":216492,"goal":"lemma SetCardSubset_13149(U: set, S: set)\n requires U <= S\n ensures |U| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_13150","instance":13150,"id":216493,"goal":"lemma SetUnionCard_13150(B: set, A: set)\n requires B * A == {}\n ensures |B + A| == |B| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_13151","instance":13151,"id":216494,"goal":"lemma SetUnionComm_13151(B: set, T: set)\n ensures B + T == T + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_13152","instance":13152,"id":216495,"goal":"lemma SetInterComm_13152(A: set, B: set)\n ensures A * B == B * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_13153","instance":13153,"id":216496,"goal":"lemma SetUnionAssoc_13153(U: set, S: set, A: set)\n ensures (U + S) + A == U + (S + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_13154","instance":13154,"id":216497,"goal":"lemma SetSubsetRefl_13154(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_13155","instance":13155,"id":216498,"goal":"lemma SetSubsetTrans_13155(U: set, S: set, B: set)\n requires U <= S && S <= B\n ensures U <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_13156","instance":13156,"id":216499,"goal":"lemma SetUnionEmpty_13156(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_13157","instance":13157,"id":216500,"goal":"lemma SetInterEmpty_13157(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_13158","instance":13158,"id":216501,"goal":"lemma SetInterSubset_13158(B: set, U: set)\n ensures B * U <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_13159","instance":13159,"id":216502,"goal":"lemma SetCardSubset_13159(T: set, U: set)\n requires T <= U\n ensures |T| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_13160","instance":13160,"id":216503,"goal":"lemma SetUnionCard_13160(U: set, B: set)\n requires U * B == {}\n ensures |U + B| == |U| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_13161","instance":13161,"id":216504,"goal":"lemma SetUnionComm_13161(A: set, B: set)\n ensures A + B == B + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_13162","instance":13162,"id":216505,"goal":"lemma SetInterComm_13162(B: set, S: set)\n ensures B * S == S * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_13163","instance":13163,"id":216506,"goal":"lemma SetUnionAssoc_13163(A: set, B: set, S: set)\n ensures (A + B) + S == A + (B + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_13164","instance":13164,"id":216507,"goal":"lemma SetSubsetRefl_13164(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_13165","instance":13165,"id":216508,"goal":"lemma SetSubsetTrans_13165(T: set, S: set, A: set)\n requires T <= S && S <= A\n ensures T <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_13166","instance":13166,"id":216509,"goal":"lemma SetUnionEmpty_13166(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_13167","instance":13167,"id":216510,"goal":"lemma SetInterEmpty_13167(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_13168","instance":13168,"id":216511,"goal":"lemma SetInterSubset_13168(U: set, S: set)\n ensures U * S <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_13169","instance":13169,"id":216512,"goal":"lemma SetCardSubset_13169(A: set, B: set)\n requires A <= B\n ensures |A| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_13170","instance":13170,"id":216513,"goal":"lemma SetUnionCard_13170(U: set, S: set)\n requires U * S == {}\n ensures |U + S| == |U| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_13171","instance":13171,"id":216514,"goal":"lemma SetUnionComm_13171(U: set, S: set)\n ensures U + S == S + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_13172","instance":13172,"id":216515,"goal":"lemma SetInterComm_13172(B: set, S: set)\n ensures B * S == S * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_13173","instance":13173,"id":216516,"goal":"lemma SetUnionAssoc_13173(T: set, U: set, A: set)\n ensures (T + U) + A == T + (U + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_13174","instance":13174,"id":216517,"goal":"lemma SetSubsetRefl_13174(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_13175","instance":13175,"id":216518,"goal":"lemma SetSubsetTrans_13175(A: set, B: set, S: set)\n requires A <= B && B <= S\n ensures A <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_13176","instance":13176,"id":216519,"goal":"lemma SetUnionEmpty_13176(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_13177","instance":13177,"id":216520,"goal":"lemma SetInterEmpty_13177(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_13178","instance":13178,"id":216521,"goal":"lemma SetInterSubset_13178(A: set, B: set)\n ensures A * B <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_13179","instance":13179,"id":216522,"goal":"lemma SetCardSubset_13179(U: set, T: set)\n requires U <= T\n ensures |U| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_13180","instance":13180,"id":216523,"goal":"lemma SetUnionCard_13180(A: set, T: set)\n requires A * T == {}\n ensures |A + T| == |A| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_13181","instance":13181,"id":216524,"goal":"lemma SetUnionComm_13181(S: set, B: set)\n ensures S + B == B + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_13182","instance":13182,"id":216525,"goal":"lemma SetInterComm_13182(S: set, A: set)\n ensures S * A == A * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_13183","instance":13183,"id":216526,"goal":"lemma SetUnionAssoc_13183(A: set, T: set, U: set)\n ensures (A + T) + U == A + (T + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_13184","instance":13184,"id":216527,"goal":"lemma SetSubsetRefl_13184(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_13185","instance":13185,"id":216528,"goal":"lemma SetSubsetTrans_13185(B: set, A: set, S: set)\n requires B <= A && A <= S\n ensures B <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_13186","instance":13186,"id":216529,"goal":"lemma SetUnionEmpty_13186(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_13187","instance":13187,"id":216530,"goal":"lemma SetInterEmpty_13187(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_13188","instance":13188,"id":216531,"goal":"lemma SetInterSubset_13188(A: set, S: set)\n ensures A * S <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_13189","instance":13189,"id":216532,"goal":"lemma SetCardSubset_13189(U: set, B: set)\n requires U <= B\n ensures |U| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_13190","instance":13190,"id":216533,"goal":"lemma SetUnionCard_13190(T: set, S: set)\n requires T * S == {}\n ensures |T + S| == |T| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_13191","instance":13191,"id":216534,"goal":"lemma SetUnionComm_13191(B: set, U: set)\n ensures B + U == U + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_13192","instance":13192,"id":216535,"goal":"lemma SetInterComm_13192(A: set, S: set)\n ensures A * S == S * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_13193","instance":13193,"id":216536,"goal":"lemma SetUnionAssoc_13193(T: set, S: set, A: set)\n ensures (T + S) + A == T + (S + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_13194","instance":13194,"id":216537,"goal":"lemma SetSubsetRefl_13194(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_13195","instance":13195,"id":216538,"goal":"lemma SetSubsetTrans_13195(B: set, U: set, S: set)\n requires B <= U && U <= S\n ensures B <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_13196","instance":13196,"id":216539,"goal":"lemma SetUnionEmpty_13196(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_13197","instance":13197,"id":216540,"goal":"lemma SetInterEmpty_13197(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_13198","instance":13198,"id":216541,"goal":"lemma SetInterSubset_13198(B: set, T: set)\n ensures B * T <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_13199","instance":13199,"id":216542,"goal":"lemma SetCardSubset_13199(B: set, U: set)\n requires B <= U\n ensures |B| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_13200","instance":13200,"id":216543,"goal":"lemma SetUnionCard_13200(S: set, B: set)\n requires S * B == {}\n ensures |S + B| == |S| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_13201","instance":13201,"id":216544,"goal":"lemma SetUnionComm_13201(B: set, S: set)\n ensures B + S == S + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_13202","instance":13202,"id":216545,"goal":"lemma SetInterComm_13202(B: set, A: set)\n ensures B * A == A * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_13203","instance":13203,"id":216546,"goal":"lemma SetUnionAssoc_13203(U: set, B: set, A: set)\n ensures (U + B) + A == U + (B + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_13204","instance":13204,"id":216547,"goal":"lemma SetSubsetRefl_13204(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_13205","instance":13205,"id":216548,"goal":"lemma SetSubsetTrans_13205(B: set, U: set, A: set)\n requires B <= U && U <= A\n ensures B <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_13206","instance":13206,"id":216549,"goal":"lemma SetUnionEmpty_13206(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_13207","instance":13207,"id":216550,"goal":"lemma SetInterEmpty_13207(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_13208","instance":13208,"id":216551,"goal":"lemma SetInterSubset_13208(S: set, U: set)\n ensures S * U <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_13209","instance":13209,"id":216552,"goal":"lemma SetCardSubset_13209(U: set, T: set)\n requires U <= T\n ensures |U| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_13210","instance":13210,"id":216553,"goal":"lemma SetUnionCard_13210(S: set, B: set)\n requires S * B == {}\n ensures |S + B| == |S| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_13211","instance":13211,"id":216554,"goal":"lemma SetUnionComm_13211(A: set, S: set)\n ensures A + S == S + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_13212","instance":13212,"id":216555,"goal":"lemma SetInterComm_13212(U: set, A: set)\n ensures U * A == A * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_13213","instance":13213,"id":216556,"goal":"lemma SetUnionAssoc_13213(A: set, B: set, U: set)\n ensures (A + B) + U == A + (B + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_13214","instance":13214,"id":216557,"goal":"lemma SetSubsetRefl_13214(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_13215","instance":13215,"id":216558,"goal":"lemma SetSubsetTrans_13215(A: set, B: set, S: set)\n requires A <= B && B <= S\n ensures A <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_13216","instance":13216,"id":216559,"goal":"lemma SetUnionEmpty_13216(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_13217","instance":13217,"id":216560,"goal":"lemma SetInterEmpty_13217(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_13218","instance":13218,"id":216561,"goal":"lemma SetInterSubset_13218(U: set, T: set)\n ensures U * T <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_13219","instance":13219,"id":216562,"goal":"lemma SetCardSubset_13219(A: set, U: set)\n requires A <= U\n ensures |A| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_13220","instance":13220,"id":216563,"goal":"lemma SetUnionCard_13220(U: set, T: set)\n requires U * T == {}\n ensures |U + T| == |U| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_13221","instance":13221,"id":216564,"goal":"lemma SetUnionComm_13221(A: set, T: set)\n ensures A + T == T + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_13222","instance":13222,"id":216565,"goal":"lemma SetInterComm_13222(A: set, U: set)\n ensures A * U == U * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_13223","instance":13223,"id":216566,"goal":"lemma SetUnionAssoc_13223(B: set, S: set, T: set)\n ensures (B + S) + T == B + (S + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_13224","instance":13224,"id":216567,"goal":"lemma SetSubsetRefl_13224(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_13225","instance":13225,"id":216568,"goal":"lemma SetSubsetTrans_13225(B: set, S: set, A: set)\n requires B <= S && S <= A\n ensures B <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_13226","instance":13226,"id":216569,"goal":"lemma SetUnionEmpty_13226(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_13227","instance":13227,"id":216570,"goal":"lemma SetInterEmpty_13227(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_13228","instance":13228,"id":216571,"goal":"lemma SetInterSubset_13228(S: set, B: set)\n ensures S * B <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_13229","instance":13229,"id":216572,"goal":"lemma SetCardSubset_13229(T: set, U: set)\n requires T <= U\n ensures |T| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_13230","instance":13230,"id":216573,"goal":"lemma SetUnionCard_13230(B: set, S: set)\n requires B * S == {}\n ensures |B + S| == |B| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_13231","instance":13231,"id":216574,"goal":"lemma SetUnionComm_13231(U: set, S: set)\n ensures U + S == S + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_13232","instance":13232,"id":216575,"goal":"lemma SetInterComm_13232(T: set, B: set)\n ensures T * B == B * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_13233","instance":13233,"id":216576,"goal":"lemma SetUnionAssoc_13233(A: set, S: set, T: set)\n ensures (A + S) + T == A + (S + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_13234","instance":13234,"id":216577,"goal":"lemma SetSubsetRefl_13234(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_13235","instance":13235,"id":216578,"goal":"lemma SetSubsetTrans_13235(A: set, T: set, B: set)\n requires A <= T && T <= B\n ensures A <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_13236","instance":13236,"id":216579,"goal":"lemma SetUnionEmpty_13236(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_13237","instance":13237,"id":216580,"goal":"lemma SetInterEmpty_13237(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_13238","instance":13238,"id":216581,"goal":"lemma SetInterSubset_13238(S: set, T: set)\n ensures S * T <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_13239","instance":13239,"id":216582,"goal":"lemma SetCardSubset_13239(A: set, U: set)\n requires A <= U\n ensures |A| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_13240","instance":13240,"id":216583,"goal":"lemma SetUnionCard_13240(U: set, A: set)\n requires U * A == {}\n ensures |U + A| == |U| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_13241","instance":13241,"id":216584,"goal":"lemma SetUnionComm_13241(B: set, A: set)\n ensures B + A == A + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_13242","instance":13242,"id":216585,"goal":"lemma SetInterComm_13242(S: set, U: set)\n ensures S * U == U * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_13243","instance":13243,"id":216586,"goal":"lemma SetUnionAssoc_13243(A: set, T: set, U: set)\n ensures (A + T) + U == A + (T + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_13244","instance":13244,"id":216587,"goal":"lemma SetSubsetRefl_13244(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_13245","instance":13245,"id":216588,"goal":"lemma SetSubsetTrans_13245(A: set, U: set, B: set)\n requires A <= U && U <= B\n ensures A <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_13246","instance":13246,"id":216589,"goal":"lemma SetUnionEmpty_13246(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_13247","instance":13247,"id":216590,"goal":"lemma SetInterEmpty_13247(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_13248","instance":13248,"id":216591,"goal":"lemma SetInterSubset_13248(T: set, B: set)\n ensures T * B <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_13249","instance":13249,"id":216592,"goal":"lemma SetCardSubset_13249(B: set, A: set)\n requires B <= A\n ensures |B| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_13250","instance":13250,"id":216593,"goal":"lemma SetUnionCard_13250(S: set, B: set)\n requires S * B == {}\n ensures |S + B| == |S| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_13251","instance":13251,"id":216594,"goal":"lemma SetUnionComm_13251(B: set, T: set)\n ensures B + T == T + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_13252","instance":13252,"id":216595,"goal":"lemma SetInterComm_13252(U: set, A: set)\n ensures U * A == A * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_13253","instance":13253,"id":216596,"goal":"lemma SetUnionAssoc_13253(S: set, A: set, B: set)\n ensures (S + A) + B == S + (A + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_13254","instance":13254,"id":216597,"goal":"lemma SetSubsetRefl_13254(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_13255","instance":13255,"id":216598,"goal":"lemma SetSubsetTrans_13255(A: set, B: set, T: set)\n requires A <= B && B <= T\n ensures A <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_13256","instance":13256,"id":216599,"goal":"lemma SetUnionEmpty_13256(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_13257","instance":13257,"id":216600,"goal":"lemma SetInterEmpty_13257(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_13258","instance":13258,"id":216601,"goal":"lemma SetInterSubset_13258(A: set, U: set)\n ensures A * U <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_13259","instance":13259,"id":216602,"goal":"lemma SetCardSubset_13259(T: set, B: set)\n requires T <= B\n ensures |T| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_13260","instance":13260,"id":216603,"goal":"lemma SetUnionCard_13260(T: set, U: set)\n requires T * U == {}\n ensures |T + U| == |T| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_13261","instance":13261,"id":216604,"goal":"lemma SetUnionComm_13261(S: set, T: set)\n ensures S + T == T + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_13262","instance":13262,"id":216605,"goal":"lemma SetInterComm_13262(B: set, U: set)\n ensures B * U == U * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_13263","instance":13263,"id":216606,"goal":"lemma SetUnionAssoc_13263(S: set, B: set, T: set)\n ensures (S + B) + T == S + (B + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_13264","instance":13264,"id":216607,"goal":"lemma SetSubsetRefl_13264(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_13265","instance":13265,"id":216608,"goal":"lemma SetSubsetTrans_13265(U: set, S: set, A: set)\n requires U <= S && S <= A\n ensures U <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_13266","instance":13266,"id":216609,"goal":"lemma SetUnionEmpty_13266(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_13267","instance":13267,"id":216610,"goal":"lemma SetInterEmpty_13267(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_13268","instance":13268,"id":216611,"goal":"lemma SetInterSubset_13268(U: set, T: set)\n ensures U * T <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_13269","instance":13269,"id":216612,"goal":"lemma SetCardSubset_13269(B: set, S: set)\n requires B <= S\n ensures |B| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_13270","instance":13270,"id":216613,"goal":"lemma SetUnionCard_13270(S: set, A: set)\n requires S * A == {}\n ensures |S + A| == |S| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_13271","instance":13271,"id":216614,"goal":"lemma SetUnionComm_13271(T: set, S: set)\n ensures T + S == S + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_13272","instance":13272,"id":216615,"goal":"lemma SetInterComm_13272(U: set, B: set)\n ensures U * B == B * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_13273","instance":13273,"id":216616,"goal":"lemma SetUnionAssoc_13273(A: set, U: set, S: set)\n ensures (A + U) + S == A + (U + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_13274","instance":13274,"id":216617,"goal":"lemma SetSubsetRefl_13274(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_13275","instance":13275,"id":216618,"goal":"lemma SetSubsetTrans_13275(T: set, U: set, S: set)\n requires T <= U && U <= S\n ensures T <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_13276","instance":13276,"id":216619,"goal":"lemma SetUnionEmpty_13276(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_13277","instance":13277,"id":216620,"goal":"lemma SetInterEmpty_13277(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_13278","instance":13278,"id":216621,"goal":"lemma SetInterSubset_13278(B: set, A: set)\n ensures B * A <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_13279","instance":13279,"id":216622,"goal":"lemma SetCardSubset_13279(T: set, S: set)\n requires T <= S\n ensures |T| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_13280","instance":13280,"id":216623,"goal":"lemma SetUnionCard_13280(T: set, B: set)\n requires T * B == {}\n ensures |T + B| == |T| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_13281","instance":13281,"id":216624,"goal":"lemma SetUnionComm_13281(T: set, S: set)\n ensures T + S == S + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_13282","instance":13282,"id":216625,"goal":"lemma SetInterComm_13282(T: set, B: set)\n ensures T * B == B * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_13283","instance":13283,"id":216626,"goal":"lemma SetUnionAssoc_13283(B: set, S: set, U: set)\n ensures (B + S) + U == B + (S + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_13284","instance":13284,"id":216627,"goal":"lemma SetSubsetRefl_13284(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_13285","instance":13285,"id":216628,"goal":"lemma SetSubsetTrans_13285(B: set, A: set, S: set)\n requires B <= A && A <= S\n ensures B <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_13286","instance":13286,"id":216629,"goal":"lemma SetUnionEmpty_13286(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_13287","instance":13287,"id":216630,"goal":"lemma SetInterEmpty_13287(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_13288","instance":13288,"id":216631,"goal":"lemma SetInterSubset_13288(U: set, T: set)\n ensures U * T <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_13289","instance":13289,"id":216632,"goal":"lemma SetCardSubset_13289(B: set, S: set)\n requires B <= S\n ensures |B| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_13290","instance":13290,"id":216633,"goal":"lemma SetUnionCard_13290(T: set, U: set)\n requires T * U == {}\n ensures |T + U| == |T| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_13291","instance":13291,"id":216634,"goal":"lemma SetUnionComm_13291(U: set, A: set)\n ensures U + A == A + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_13292","instance":13292,"id":216635,"goal":"lemma SetInterComm_13292(A: set, S: set)\n ensures A * S == S * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_13293","instance":13293,"id":216636,"goal":"lemma SetUnionAssoc_13293(S: set, B: set, U: set)\n ensures (S + B) + U == S + (B + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_13294","instance":13294,"id":216637,"goal":"lemma SetSubsetRefl_13294(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_13295","instance":13295,"id":216638,"goal":"lemma SetSubsetTrans_13295(T: set, B: set, A: set)\n requires T <= B && B <= A\n ensures T <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_13296","instance":13296,"id":216639,"goal":"lemma SetUnionEmpty_13296(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_13297","instance":13297,"id":216640,"goal":"lemma SetInterEmpty_13297(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_13298","instance":13298,"id":216641,"goal":"lemma SetInterSubset_13298(U: set, A: set)\n ensures U * A <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_13299","instance":13299,"id":216642,"goal":"lemma SetCardSubset_13299(T: set, A: set)\n requires T <= A\n ensures |T| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_13300","instance":13300,"id":216643,"goal":"lemma SetUnionCard_13300(T: set, B: set)\n requires T * B == {}\n ensures |T + B| == |T| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_13301","instance":13301,"id":216644,"goal":"lemma SetUnionComm_13301(S: set, A: set)\n ensures S + A == A + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_13302","instance":13302,"id":216645,"goal":"lemma SetInterComm_13302(T: set, S: set)\n ensures T * S == S * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_13303","instance":13303,"id":216646,"goal":"lemma SetUnionAssoc_13303(S: set, A: set, B: set)\n ensures (S + A) + B == S + (A + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_13304","instance":13304,"id":216647,"goal":"lemma SetSubsetRefl_13304(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_13305","instance":13305,"id":216648,"goal":"lemma SetSubsetTrans_13305(B: set, U: set, S: set)\n requires B <= U && U <= S\n ensures B <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_13306","instance":13306,"id":216649,"goal":"lemma SetUnionEmpty_13306(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_13307","instance":13307,"id":216650,"goal":"lemma SetInterEmpty_13307(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_13308","instance":13308,"id":216651,"goal":"lemma SetInterSubset_13308(B: set, S: set)\n ensures B * S <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_13309","instance":13309,"id":216652,"goal":"lemma SetCardSubset_13309(U: set, A: set)\n requires U <= A\n ensures |U| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_13310","instance":13310,"id":216653,"goal":"lemma SetUnionCard_13310(U: set, A: set)\n requires U * A == {}\n ensures |U + A| == |U| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_13311","instance":13311,"id":216654,"goal":"lemma SetUnionComm_13311(U: set, T: set)\n ensures U + T == T + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_13312","instance":13312,"id":216655,"goal":"lemma SetInterComm_13312(S: set, T: set)\n ensures S * T == T * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_13313","instance":13313,"id":216656,"goal":"lemma SetUnionAssoc_13313(U: set, T: set, A: set)\n ensures (U + T) + A == U + (T + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_13314","instance":13314,"id":216657,"goal":"lemma SetSubsetRefl_13314(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_13315","instance":13315,"id":216658,"goal":"lemma SetSubsetTrans_13315(A: set, T: set, U: set)\n requires A <= T && T <= U\n ensures A <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_13316","instance":13316,"id":216659,"goal":"lemma SetUnionEmpty_13316(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_13317","instance":13317,"id":216660,"goal":"lemma SetInterEmpty_13317(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_13318","instance":13318,"id":216661,"goal":"lemma SetInterSubset_13318(A: set, B: set)\n ensures A * B <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_13319","instance":13319,"id":216662,"goal":"lemma SetCardSubset_13319(S: set, A: set)\n requires S <= A\n ensures |S| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_13320","instance":13320,"id":216663,"goal":"lemma SetUnionCard_13320(T: set, B: set)\n requires T * B == {}\n ensures |T + B| == |T| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_13321","instance":13321,"id":216664,"goal":"lemma SetUnionComm_13321(T: set, U: set)\n ensures T + U == U + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_13322","instance":13322,"id":216665,"goal":"lemma SetInterComm_13322(T: set, S: set)\n ensures T * S == S * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_13323","instance":13323,"id":216666,"goal":"lemma SetUnionAssoc_13323(U: set, B: set, S: set)\n ensures (U + B) + S == U + (B + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_13324","instance":13324,"id":216667,"goal":"lemma SetSubsetRefl_13324(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_13325","instance":13325,"id":216668,"goal":"lemma SetSubsetTrans_13325(A: set, B: set, T: set)\n requires A <= B && B <= T\n ensures A <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_13326","instance":13326,"id":216669,"goal":"lemma SetUnionEmpty_13326(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_13327","instance":13327,"id":216670,"goal":"lemma SetInterEmpty_13327(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_13328","instance":13328,"id":216671,"goal":"lemma SetInterSubset_13328(A: set, S: set)\n ensures A * S <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_13329","instance":13329,"id":216672,"goal":"lemma SetCardSubset_13329(A: set, S: set)\n requires A <= S\n ensures |A| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_13330","instance":13330,"id":216673,"goal":"lemma SetUnionCard_13330(S: set, T: set)\n requires S * T == {}\n ensures |S + T| == |S| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_13331","instance":13331,"id":216674,"goal":"lemma SetUnionComm_13331(T: set, S: set)\n ensures T + S == S + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_13332","instance":13332,"id":216675,"goal":"lemma SetInterComm_13332(B: set, A: set)\n ensures B * A == A * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_13333","instance":13333,"id":216676,"goal":"lemma SetUnionAssoc_13333(A: set, U: set, B: set)\n ensures (A + U) + B == A + (U + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_13334","instance":13334,"id":216677,"goal":"lemma SetSubsetRefl_13334(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_13335","instance":13335,"id":216678,"goal":"lemma SetSubsetTrans_13335(S: set, A: set, B: set)\n requires S <= A && A <= B\n ensures S <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_13336","instance":13336,"id":216679,"goal":"lemma SetUnionEmpty_13336(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_13337","instance":13337,"id":216680,"goal":"lemma SetInterEmpty_13337(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_13338","instance":13338,"id":216681,"goal":"lemma SetInterSubset_13338(A: set, S: set)\n ensures A * S <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_13339","instance":13339,"id":216682,"goal":"lemma SetCardSubset_13339(B: set, S: set)\n requires B <= S\n ensures |B| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_13340","instance":13340,"id":216683,"goal":"lemma SetUnionCard_13340(B: set, A: set)\n requires B * A == {}\n ensures |B + A| == |B| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_13341","instance":13341,"id":216684,"goal":"lemma SetUnionComm_13341(B: set, T: set)\n ensures B + T == T + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_13342","instance":13342,"id":216685,"goal":"lemma SetInterComm_13342(B: set, S: set)\n ensures B * S == S * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_13343","instance":13343,"id":216686,"goal":"lemma SetUnionAssoc_13343(A: set, S: set, B: set)\n ensures (A + S) + B == A + (S + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_13344","instance":13344,"id":216687,"goal":"lemma SetSubsetRefl_13344(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_13345","instance":13345,"id":216688,"goal":"lemma SetSubsetTrans_13345(B: set, A: set, T: set)\n requires B <= A && A <= T\n ensures B <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_13346","instance":13346,"id":216689,"goal":"lemma SetUnionEmpty_13346(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_13347","instance":13347,"id":216690,"goal":"lemma SetInterEmpty_13347(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_13348","instance":13348,"id":216691,"goal":"lemma SetInterSubset_13348(B: set, A: set)\n ensures B * A <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_13349","instance":13349,"id":216692,"goal":"lemma SetCardSubset_13349(B: set, T: set)\n requires B <= T\n ensures |B| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_13350","instance":13350,"id":216693,"goal":"lemma SetUnionCard_13350(S: set, B: set)\n requires S * B == {}\n ensures |S + B| == |S| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_13351","instance":13351,"id":216694,"goal":"lemma SetUnionComm_13351(B: set, U: set)\n ensures B + U == U + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_13352","instance":13352,"id":216695,"goal":"lemma SetInterComm_13352(U: set, A: set)\n ensures U * A == A * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_13353","instance":13353,"id":216696,"goal":"lemma SetUnionAssoc_13353(T: set, B: set, S: set)\n ensures (T + B) + S == T + (B + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_13354","instance":13354,"id":216697,"goal":"lemma SetSubsetRefl_13354(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_13355","instance":13355,"id":216698,"goal":"lemma SetSubsetTrans_13355(U: set, A: set, T: set)\n requires U <= A && A <= T\n ensures U <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_13356","instance":13356,"id":216699,"goal":"lemma SetUnionEmpty_13356(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_13357","instance":13357,"id":216700,"goal":"lemma SetInterEmpty_13357(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_13358","instance":13358,"id":216701,"goal":"lemma SetInterSubset_13358(B: set, A: set)\n ensures B * A <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_13359","instance":13359,"id":216702,"goal":"lemma SetCardSubset_13359(T: set, B: set)\n requires T <= B\n ensures |T| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_13360","instance":13360,"id":216703,"goal":"lemma SetUnionCard_13360(U: set, A: set)\n requires U * A == {}\n ensures |U + A| == |U| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_13361","instance":13361,"id":216704,"goal":"lemma SetUnionComm_13361(S: set, A: set)\n ensures S + A == A + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_13362","instance":13362,"id":216705,"goal":"lemma SetInterComm_13362(U: set, B: set)\n ensures U * B == B * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_13363","instance":13363,"id":216706,"goal":"lemma SetUnionAssoc_13363(A: set, U: set, T: set)\n ensures (A + U) + T == A + (U + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_13364","instance":13364,"id":216707,"goal":"lemma SetSubsetRefl_13364(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_13365","instance":13365,"id":216708,"goal":"lemma SetSubsetTrans_13365(T: set, U: set, S: set)\n requires T <= U && U <= S\n ensures T <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_13366","instance":13366,"id":216709,"goal":"lemma SetUnionEmpty_13366(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_13367","instance":13367,"id":216710,"goal":"lemma SetInterEmpty_13367(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_13368","instance":13368,"id":216711,"goal":"lemma SetInterSubset_13368(S: set, B: set)\n ensures S * B <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_13369","instance":13369,"id":216712,"goal":"lemma SetCardSubset_13369(U: set, S: set)\n requires U <= S\n ensures |U| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_13370","instance":13370,"id":216713,"goal":"lemma SetUnionCard_13370(T: set, U: set)\n requires T * U == {}\n ensures |T + U| == |T| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_13371","instance":13371,"id":216714,"goal":"lemma SetUnionComm_13371(U: set, S: set)\n ensures U + S == S + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_13372","instance":13372,"id":216715,"goal":"lemma SetInterComm_13372(S: set, U: set)\n ensures S * U == U * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_13373","instance":13373,"id":216716,"goal":"lemma SetUnionAssoc_13373(U: set, A: set, S: set)\n ensures (U + A) + S == U + (A + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_13374","instance":13374,"id":216717,"goal":"lemma SetSubsetRefl_13374(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_13375","instance":13375,"id":216718,"goal":"lemma SetSubsetTrans_13375(A: set, S: set, T: set)\n requires A <= S && S <= T\n ensures A <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_13376","instance":13376,"id":216719,"goal":"lemma SetUnionEmpty_13376(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_13377","instance":13377,"id":216720,"goal":"lemma SetInterEmpty_13377(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_13378","instance":13378,"id":216721,"goal":"lemma SetInterSubset_13378(S: set, B: set)\n ensures S * B <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_13379","instance":13379,"id":216722,"goal":"lemma SetCardSubset_13379(T: set, A: set)\n requires T <= A\n ensures |T| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_13380","instance":13380,"id":216723,"goal":"lemma SetUnionCard_13380(B: set, S: set)\n requires B * S == {}\n ensures |B + S| == |B| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_13381","instance":13381,"id":216724,"goal":"lemma SetUnionComm_13381(A: set, S: set)\n ensures A + S == S + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_13382","instance":13382,"id":216725,"goal":"lemma SetInterComm_13382(S: set, A: set)\n ensures S * A == A * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_13383","instance":13383,"id":216726,"goal":"lemma SetUnionAssoc_13383(A: set, U: set, T: set)\n ensures (A + U) + T == A + (U + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_13384","instance":13384,"id":216727,"goal":"lemma SetSubsetRefl_13384(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_13385","instance":13385,"id":216728,"goal":"lemma SetSubsetTrans_13385(S: set, U: set, A: set)\n requires S <= U && U <= A\n ensures S <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_13386","instance":13386,"id":216729,"goal":"lemma SetUnionEmpty_13386(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_13387","instance":13387,"id":216730,"goal":"lemma SetInterEmpty_13387(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_13388","instance":13388,"id":216731,"goal":"lemma SetInterSubset_13388(B: set, S: set)\n ensures B * S <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_13389","instance":13389,"id":216732,"goal":"lemma SetCardSubset_13389(A: set, S: set)\n requires A <= S\n ensures |A| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_13390","instance":13390,"id":216733,"goal":"lemma SetUnionCard_13390(T: set, B: set)\n requires T * B == {}\n ensures |T + B| == |T| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_13391","instance":13391,"id":216734,"goal":"lemma SetUnionComm_13391(U: set, S: set)\n ensures U + S == S + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_13392","instance":13392,"id":216735,"goal":"lemma SetInterComm_13392(T: set, S: set)\n ensures T * S == S * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_13393","instance":13393,"id":216736,"goal":"lemma SetUnionAssoc_13393(A: set, S: set, T: set)\n ensures (A + S) + T == A + (S + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_13394","instance":13394,"id":216737,"goal":"lemma SetSubsetRefl_13394(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_13395","instance":13395,"id":216738,"goal":"lemma SetSubsetTrans_13395(S: set, B: set, A: set)\n requires S <= B && B <= A\n ensures S <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_13396","instance":13396,"id":216739,"goal":"lemma SetUnionEmpty_13396(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_13397","instance":13397,"id":216740,"goal":"lemma SetInterEmpty_13397(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_13398","instance":13398,"id":216741,"goal":"lemma SetInterSubset_13398(T: set, B: set)\n ensures T * B <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_13399","instance":13399,"id":216742,"goal":"lemma SetCardSubset_13399(U: set, T: set)\n requires U <= T\n ensures |U| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_13400","instance":13400,"id":216743,"goal":"lemma SetUnionCard_13400(A: set, U: set)\n requires A * U == {}\n ensures |A + U| == |A| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_13401","instance":13401,"id":216744,"goal":"lemma SetUnionComm_13401(A: set, B: set)\n ensures A + B == B + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_13402","instance":13402,"id":216745,"goal":"lemma SetInterComm_13402(S: set, U: set)\n ensures S * U == U * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_13403","instance":13403,"id":216746,"goal":"lemma SetUnionAssoc_13403(B: set, A: set, T: set)\n ensures (B + A) + T == B + (A + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_13404","instance":13404,"id":216747,"goal":"lemma SetSubsetRefl_13404(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_13405","instance":13405,"id":216748,"goal":"lemma SetSubsetTrans_13405(U: set, T: set, A: set)\n requires U <= T && T <= A\n ensures U <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_13406","instance":13406,"id":216749,"goal":"lemma SetUnionEmpty_13406(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_13407","instance":13407,"id":216750,"goal":"lemma SetInterEmpty_13407(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_13408","instance":13408,"id":216751,"goal":"lemma SetInterSubset_13408(T: set, S: set)\n ensures T * S <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_13409","instance":13409,"id":216752,"goal":"lemma SetCardSubset_13409(A: set, B: set)\n requires A <= B\n ensures |A| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_13410","instance":13410,"id":216753,"goal":"lemma SetUnionCard_13410(U: set, T: set)\n requires U * T == {}\n ensures |U + T| == |U| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_13411","instance":13411,"id":216754,"goal":"lemma SetUnionComm_13411(S: set, U: set)\n ensures S + U == U + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_13412","instance":13412,"id":216755,"goal":"lemma SetInterComm_13412(U: set, T: set)\n ensures U * T == T * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_13413","instance":13413,"id":216756,"goal":"lemma SetUnionAssoc_13413(A: set, B: set, U: set)\n ensures (A + B) + U == A + (B + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_13414","instance":13414,"id":216757,"goal":"lemma SetSubsetRefl_13414(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_13415","instance":13415,"id":216758,"goal":"lemma SetSubsetTrans_13415(S: set, T: set, U: set)\n requires S <= T && T <= U\n ensures S <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_13416","instance":13416,"id":216759,"goal":"lemma SetUnionEmpty_13416(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_13417","instance":13417,"id":216760,"goal":"lemma SetInterEmpty_13417(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_13418","instance":13418,"id":216761,"goal":"lemma SetInterSubset_13418(U: set, B: set)\n ensures U * B <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_13419","instance":13419,"id":216762,"goal":"lemma SetCardSubset_13419(U: set, B: set)\n requires U <= B\n ensures |U| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_13420","instance":13420,"id":216763,"goal":"lemma SetUnionCard_13420(S: set, B: set)\n requires S * B == {}\n ensures |S + B| == |S| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_13421","instance":13421,"id":216764,"goal":"lemma SetUnionComm_13421(A: set, U: set)\n ensures A + U == U + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_13422","instance":13422,"id":216765,"goal":"lemma SetInterComm_13422(S: set, A: set)\n ensures S * A == A * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_13423","instance":13423,"id":216766,"goal":"lemma SetUnionAssoc_13423(B: set, T: set, S: set)\n ensures (B + T) + S == B + (T + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_13424","instance":13424,"id":216767,"goal":"lemma SetSubsetRefl_13424(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_13425","instance":13425,"id":216768,"goal":"lemma SetSubsetTrans_13425(T: set, U: set, S: set)\n requires T <= U && U <= S\n ensures T <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_13426","instance":13426,"id":216769,"goal":"lemma SetUnionEmpty_13426(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_13427","instance":13427,"id":216770,"goal":"lemma SetInterEmpty_13427(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_13428","instance":13428,"id":216771,"goal":"lemma SetInterSubset_13428(A: set, B: set)\n ensures A * B <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_13429","instance":13429,"id":216772,"goal":"lemma SetCardSubset_13429(T: set, S: set)\n requires T <= S\n ensures |T| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_13430","instance":13430,"id":216773,"goal":"lemma SetUnionCard_13430(B: set, T: set)\n requires B * T == {}\n ensures |B + T| == |B| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_13431","instance":13431,"id":216774,"goal":"lemma SetUnionComm_13431(A: set, T: set)\n ensures A + T == T + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_13432","instance":13432,"id":216775,"goal":"lemma SetInterComm_13432(T: set, S: set)\n ensures T * S == S * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_13433","instance":13433,"id":216776,"goal":"lemma SetUnionAssoc_13433(S: set, B: set, A: set)\n ensures (S + B) + A == S + (B + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_13434","instance":13434,"id":216777,"goal":"lemma SetSubsetRefl_13434(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_13435","instance":13435,"id":216778,"goal":"lemma SetSubsetTrans_13435(B: set, S: set, T: set)\n requires B <= S && S <= T\n ensures B <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_13436","instance":13436,"id":216779,"goal":"lemma SetUnionEmpty_13436(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_13437","instance":13437,"id":216780,"goal":"lemma SetInterEmpty_13437(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_13438","instance":13438,"id":216781,"goal":"lemma SetInterSubset_13438(T: set, B: set)\n ensures T * B <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_13439","instance":13439,"id":216782,"goal":"lemma SetCardSubset_13439(U: set, T: set)\n requires U <= T\n ensures |U| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_13440","instance":13440,"id":216783,"goal":"lemma SetUnionCard_13440(T: set, S: set)\n requires T * S == {}\n ensures |T + S| == |T| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_13441","instance":13441,"id":216784,"goal":"lemma SetUnionComm_13441(S: set, B: set)\n ensures S + B == B + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_13442","instance":13442,"id":216785,"goal":"lemma SetInterComm_13442(U: set, B: set)\n ensures U * B == B * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_13443","instance":13443,"id":216786,"goal":"lemma SetUnionAssoc_13443(T: set, U: set, S: set)\n ensures (T + U) + S == T + (U + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_13444","instance":13444,"id":216787,"goal":"lemma SetSubsetRefl_13444(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_13445","instance":13445,"id":216788,"goal":"lemma SetSubsetTrans_13445(A: set, B: set, T: set)\n requires A <= B && B <= T\n ensures A <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_13446","instance":13446,"id":216789,"goal":"lemma SetUnionEmpty_13446(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_13447","instance":13447,"id":216790,"goal":"lemma SetInterEmpty_13447(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_13448","instance":13448,"id":216791,"goal":"lemma SetInterSubset_13448(B: set, U: set)\n ensures B * U <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_13449","instance":13449,"id":216792,"goal":"lemma SetCardSubset_13449(U: set, A: set)\n requires U <= A\n ensures |U| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_13450","instance":13450,"id":216793,"goal":"lemma SetUnionCard_13450(T: set, U: set)\n requires T * U == {}\n ensures |T + U| == |T| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_13451","instance":13451,"id":216794,"goal":"lemma SetUnionComm_13451(S: set, B: set)\n ensures S + B == B + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_13452","instance":13452,"id":216795,"goal":"lemma SetInterComm_13452(T: set, A: set)\n ensures T * A == A * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_13453","instance":13453,"id":216796,"goal":"lemma SetUnionAssoc_13453(A: set, T: set, U: set)\n ensures (A + T) + U == A + (T + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_13454","instance":13454,"id":216797,"goal":"lemma SetSubsetRefl_13454(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_13455","instance":13455,"id":216798,"goal":"lemma SetSubsetTrans_13455(U: set, T: set, B: set)\n requires U <= T && T <= B\n ensures U <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_13456","instance":13456,"id":216799,"goal":"lemma SetUnionEmpty_13456(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_13457","instance":13457,"id":216800,"goal":"lemma SetInterEmpty_13457(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_13458","instance":13458,"id":216801,"goal":"lemma SetInterSubset_13458(U: set, A: set)\n ensures U * A <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_13459","instance":13459,"id":216802,"goal":"lemma SetCardSubset_13459(T: set, U: set)\n requires T <= U\n ensures |T| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_13460","instance":13460,"id":216803,"goal":"lemma SetUnionCard_13460(U: set, S: set)\n requires U * S == {}\n ensures |U + S| == |U| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_13461","instance":13461,"id":216804,"goal":"lemma SetUnionComm_13461(B: set, S: set)\n ensures B + S == S + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_13462","instance":13462,"id":216805,"goal":"lemma SetInterComm_13462(A: set, T: set)\n ensures A * T == T * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_13463","instance":13463,"id":216806,"goal":"lemma SetUnionAssoc_13463(S: set, U: set, T: set)\n ensures (S + U) + T == S + (U + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_13464","instance":13464,"id":216807,"goal":"lemma SetSubsetRefl_13464(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_13465","instance":13465,"id":216808,"goal":"lemma SetSubsetTrans_13465(S: set, T: set, A: set)\n requires S <= T && T <= A\n ensures S <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_13466","instance":13466,"id":216809,"goal":"lemma SetUnionEmpty_13466(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_13467","instance":13467,"id":216810,"goal":"lemma SetInterEmpty_13467(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_13468","instance":13468,"id":216811,"goal":"lemma SetInterSubset_13468(U: set, B: set)\n ensures U * B <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_13469","instance":13469,"id":216812,"goal":"lemma SetCardSubset_13469(S: set, A: set)\n requires S <= A\n ensures |S| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_13470","instance":13470,"id":216813,"goal":"lemma SetUnionCard_13470(A: set, T: set)\n requires A * T == {}\n ensures |A + T| == |A| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_13471","instance":13471,"id":216814,"goal":"lemma SetUnionComm_13471(U: set, A: set)\n ensures U + A == A + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_13472","instance":13472,"id":216815,"goal":"lemma SetInterComm_13472(S: set, A: set)\n ensures S * A == A * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_13473","instance":13473,"id":216816,"goal":"lemma SetUnionAssoc_13473(U: set, S: set, A: set)\n ensures (U + S) + A == U + (S + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_13474","instance":13474,"id":216817,"goal":"lemma SetSubsetRefl_13474(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_13475","instance":13475,"id":216818,"goal":"lemma SetSubsetTrans_13475(A: set, T: set, U: set)\n requires A <= T && T <= U\n ensures A <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_13476","instance":13476,"id":216819,"goal":"lemma SetUnionEmpty_13476(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_13477","instance":13477,"id":216820,"goal":"lemma SetInterEmpty_13477(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_13478","instance":13478,"id":216821,"goal":"lemma SetInterSubset_13478(U: set, S: set)\n ensures U * S <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_13479","instance":13479,"id":216822,"goal":"lemma SetCardSubset_13479(U: set, T: set)\n requires U <= T\n ensures |U| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_13480","instance":13480,"id":216823,"goal":"lemma SetUnionCard_13480(A: set, T: set)\n requires A * T == {}\n ensures |A + T| == |A| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_13481","instance":13481,"id":216824,"goal":"lemma SetUnionComm_13481(B: set, T: set)\n ensures B + T == T + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_13482","instance":13482,"id":216825,"goal":"lemma SetInterComm_13482(B: set, S: set)\n ensures B * S == S * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_13483","instance":13483,"id":216826,"goal":"lemma SetUnionAssoc_13483(A: set, B: set, U: set)\n ensures (A + B) + U == A + (B + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_13484","instance":13484,"id":216827,"goal":"lemma SetSubsetRefl_13484(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_13485","instance":13485,"id":216828,"goal":"lemma SetSubsetTrans_13485(U: set, S: set, A: set)\n requires U <= S && S <= A\n ensures U <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_13486","instance":13486,"id":216829,"goal":"lemma SetUnionEmpty_13486(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_13487","instance":13487,"id":216830,"goal":"lemma SetInterEmpty_13487(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_13488","instance":13488,"id":216831,"goal":"lemma SetInterSubset_13488(A: set, B: set)\n ensures A * B <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_13489","instance":13489,"id":216832,"goal":"lemma SetCardSubset_13489(S: set, A: set)\n requires S <= A\n ensures |S| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_13490","instance":13490,"id":216833,"goal":"lemma SetUnionCard_13490(A: set, B: set)\n requires A * B == {}\n ensures |A + B| == |A| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_13491","instance":13491,"id":216834,"goal":"lemma SetUnionComm_13491(U: set, S: set)\n ensures U + S == S + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_13492","instance":13492,"id":216835,"goal":"lemma SetInterComm_13492(S: set, U: set)\n ensures S * U == U * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_13493","instance":13493,"id":216836,"goal":"lemma SetUnionAssoc_13493(B: set, U: set, A: set)\n ensures (B + U) + A == B + (U + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_13494","instance":13494,"id":216837,"goal":"lemma SetSubsetRefl_13494(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_13495","instance":13495,"id":216838,"goal":"lemma SetSubsetTrans_13495(U: set, B: set, S: set)\n requires U <= B && B <= S\n ensures U <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_13496","instance":13496,"id":216839,"goal":"lemma SetUnionEmpty_13496(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_13497","instance":13497,"id":216840,"goal":"lemma SetInterEmpty_13497(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_13498","instance":13498,"id":216841,"goal":"lemma SetInterSubset_13498(B: set, A: set)\n ensures B * A <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_13499","instance":13499,"id":216842,"goal":"lemma SetCardSubset_13499(B: set, A: set)\n requires B <= A\n ensures |B| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_13500","instance":13500,"id":216843,"goal":"lemma SetUnionCard_13500(B: set, U: set)\n requires B * U == {}\n ensures |B + U| == |B| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_13501","instance":13501,"id":216844,"goal":"lemma SetUnionComm_13501(A: set, T: set)\n ensures A + T == T + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_13502","instance":13502,"id":216845,"goal":"lemma SetInterComm_13502(U: set, B: set)\n ensures U * B == B * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_13503","instance":13503,"id":216846,"goal":"lemma SetUnionAssoc_13503(T: set, B: set, U: set)\n ensures (T + B) + U == T + (B + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_13504","instance":13504,"id":216847,"goal":"lemma SetSubsetRefl_13504(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_13505","instance":13505,"id":216848,"goal":"lemma SetSubsetTrans_13505(B: set, T: set, U: set)\n requires B <= T && T <= U\n ensures B <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_13506","instance":13506,"id":216849,"goal":"lemma SetUnionEmpty_13506(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_13507","instance":13507,"id":216850,"goal":"lemma SetInterEmpty_13507(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_13508","instance":13508,"id":216851,"goal":"lemma SetInterSubset_13508(T: set, U: set)\n ensures T * U <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_13509","instance":13509,"id":216852,"goal":"lemma SetCardSubset_13509(U: set, S: set)\n requires U <= S\n ensures |U| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_13510","instance":13510,"id":216853,"goal":"lemma SetUnionCard_13510(S: set, B: set)\n requires S * B == {}\n ensures |S + B| == |S| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_13511","instance":13511,"id":216854,"goal":"lemma SetUnionComm_13511(T: set, B: set)\n ensures T + B == B + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_13512","instance":13512,"id":216855,"goal":"lemma SetInterComm_13512(B: set, T: set)\n ensures B * T == T * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_13513","instance":13513,"id":216856,"goal":"lemma SetUnionAssoc_13513(B: set, A: set, S: set)\n ensures (B + A) + S == B + (A + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_13514","instance":13514,"id":216857,"goal":"lemma SetSubsetRefl_13514(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_13515","instance":13515,"id":216858,"goal":"lemma SetSubsetTrans_13515(T: set, B: set, U: set)\n requires T <= B && B <= U\n ensures T <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_13516","instance":13516,"id":216859,"goal":"lemma SetUnionEmpty_13516(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_13517","instance":13517,"id":216860,"goal":"lemma SetInterEmpty_13517(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_13518","instance":13518,"id":216861,"goal":"lemma SetInterSubset_13518(A: set, S: set)\n ensures A * S <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_13519","instance":13519,"id":216862,"goal":"lemma SetCardSubset_13519(U: set, T: set)\n requires U <= T\n ensures |U| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_13520","instance":13520,"id":216863,"goal":"lemma SetUnionCard_13520(B: set, S: set)\n requires B * S == {}\n ensures |B + S| == |B| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_13521","instance":13521,"id":216864,"goal":"lemma SetUnionComm_13521(T: set, B: set)\n ensures T + B == B + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_13522","instance":13522,"id":216865,"goal":"lemma SetInterComm_13522(B: set, A: set)\n ensures B * A == A * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_13523","instance":13523,"id":216866,"goal":"lemma SetUnionAssoc_13523(A: set, T: set, S: set)\n ensures (A + T) + S == A + (T + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_13524","instance":13524,"id":216867,"goal":"lemma SetSubsetRefl_13524(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_13525","instance":13525,"id":216868,"goal":"lemma SetSubsetTrans_13525(T: set, U: set, B: set)\n requires T <= U && U <= B\n ensures T <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_13526","instance":13526,"id":216869,"goal":"lemma SetUnionEmpty_13526(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_13527","instance":13527,"id":216870,"goal":"lemma SetInterEmpty_13527(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_13528","instance":13528,"id":216871,"goal":"lemma SetInterSubset_13528(U: set, T: set)\n ensures U * T <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_13529","instance":13529,"id":216872,"goal":"lemma SetCardSubset_13529(U: set, A: set)\n requires U <= A\n ensures |U| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_13530","instance":13530,"id":216873,"goal":"lemma SetUnionCard_13530(B: set, U: set)\n requires B * U == {}\n ensures |B + U| == |B| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_13531","instance":13531,"id":216874,"goal":"lemma SetUnionComm_13531(A: set, B: set)\n ensures A + B == B + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_13532","instance":13532,"id":216875,"goal":"lemma SetInterComm_13532(B: set, T: set)\n ensures B * T == T * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_13533","instance":13533,"id":216876,"goal":"lemma SetUnionAssoc_13533(B: set, A: set, T: set)\n ensures (B + A) + T == B + (A + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_13534","instance":13534,"id":216877,"goal":"lemma SetSubsetRefl_13534(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_13535","instance":13535,"id":216878,"goal":"lemma SetSubsetTrans_13535(B: set, U: set, S: set)\n requires B <= U && U <= S\n ensures B <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_13536","instance":13536,"id":216879,"goal":"lemma SetUnionEmpty_13536(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_13537","instance":13537,"id":216880,"goal":"lemma SetInterEmpty_13537(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_13538","instance":13538,"id":216881,"goal":"lemma SetInterSubset_13538(S: set, A: set)\n ensures S * A <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_13539","instance":13539,"id":216882,"goal":"lemma SetCardSubset_13539(B: set, T: set)\n requires B <= T\n ensures |B| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_13540","instance":13540,"id":216883,"goal":"lemma SetUnionCard_13540(S: set, U: set)\n requires S * U == {}\n ensures |S + U| == |S| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_13541","instance":13541,"id":216884,"goal":"lemma SetUnionComm_13541(A: set, U: set)\n ensures A + U == U + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_13542","instance":13542,"id":216885,"goal":"lemma SetInterComm_13542(T: set, B: set)\n ensures T * B == B * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_13543","instance":13543,"id":216886,"goal":"lemma SetUnionAssoc_13543(T: set, U: set, S: set)\n ensures (T + U) + S == T + (U + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_13544","instance":13544,"id":216887,"goal":"lemma SetSubsetRefl_13544(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_13545","instance":13545,"id":216888,"goal":"lemma SetSubsetTrans_13545(B: set, A: set, S: set)\n requires B <= A && A <= S\n ensures B <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_13546","instance":13546,"id":216889,"goal":"lemma SetUnionEmpty_13546(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_13547","instance":13547,"id":216890,"goal":"lemma SetInterEmpty_13547(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_13548","instance":13548,"id":216891,"goal":"lemma SetInterSubset_13548(U: set, A: set)\n ensures U * A <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_13549","instance":13549,"id":216892,"goal":"lemma SetCardSubset_13549(B: set, U: set)\n requires B <= U\n ensures |B| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_13550","instance":13550,"id":216893,"goal":"lemma SetUnionCard_13550(S: set, B: set)\n requires S * B == {}\n ensures |S + B| == |S| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_13551","instance":13551,"id":216894,"goal":"lemma SetUnionComm_13551(S: set, B: set)\n ensures S + B == B + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_13552","instance":13552,"id":216895,"goal":"lemma SetInterComm_13552(T: set, S: set)\n ensures T * S == S * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_13553","instance":13553,"id":216896,"goal":"lemma SetUnionAssoc_13553(B: set, A: set, S: set)\n ensures (B + A) + S == B + (A + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_13554","instance":13554,"id":216897,"goal":"lemma SetSubsetRefl_13554(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_13555","instance":13555,"id":216898,"goal":"lemma SetSubsetTrans_13555(T: set, A: set, U: set)\n requires T <= A && A <= U\n ensures T <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_13556","instance":13556,"id":216899,"goal":"lemma SetUnionEmpty_13556(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_13557","instance":13557,"id":216900,"goal":"lemma SetInterEmpty_13557(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_13558","instance":13558,"id":216901,"goal":"lemma SetInterSubset_13558(U: set, T: set)\n ensures U * T <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_13559","instance":13559,"id":216902,"goal":"lemma SetCardSubset_13559(A: set, B: set)\n requires A <= B\n ensures |A| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_13560","instance":13560,"id":216903,"goal":"lemma SetUnionCard_13560(S: set, A: set)\n requires S * A == {}\n ensures |S + A| == |S| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_13561","instance":13561,"id":216904,"goal":"lemma SetUnionComm_13561(S: set, U: set)\n ensures S + U == U + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_13562","instance":13562,"id":216905,"goal":"lemma SetInterComm_13562(B: set, A: set)\n ensures B * A == A * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_13563","instance":13563,"id":216906,"goal":"lemma SetUnionAssoc_13563(A: set, B: set, U: set)\n ensures (A + B) + U == A + (B + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_13564","instance":13564,"id":216907,"goal":"lemma SetSubsetRefl_13564(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_13565","instance":13565,"id":216908,"goal":"lemma SetSubsetTrans_13565(A: set, S: set, B: set)\n requires A <= S && S <= B\n ensures A <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_13566","instance":13566,"id":216909,"goal":"lemma SetUnionEmpty_13566(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_13567","instance":13567,"id":216910,"goal":"lemma SetInterEmpty_13567(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_13568","instance":13568,"id":216911,"goal":"lemma SetInterSubset_13568(T: set, U: set)\n ensures T * U <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_13569","instance":13569,"id":216912,"goal":"lemma SetCardSubset_13569(A: set, T: set)\n requires A <= T\n ensures |A| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_13570","instance":13570,"id":216913,"goal":"lemma SetUnionCard_13570(B: set, A: set)\n requires B * A == {}\n ensures |B + A| == |B| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_13571","instance":13571,"id":216914,"goal":"lemma SetUnionComm_13571(T: set, A: set)\n ensures T + A == A + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_13572","instance":13572,"id":216915,"goal":"lemma SetInterComm_13572(S: set, A: set)\n ensures S * A == A * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_13573","instance":13573,"id":216916,"goal":"lemma SetUnionAssoc_13573(U: set, B: set, A: set)\n ensures (U + B) + A == U + (B + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_13574","instance":13574,"id":216917,"goal":"lemma SetSubsetRefl_13574(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_13575","instance":13575,"id":216918,"goal":"lemma SetSubsetTrans_13575(A: set, U: set, T: set)\n requires A <= U && U <= T\n ensures A <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_13576","instance":13576,"id":216919,"goal":"lemma SetUnionEmpty_13576(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_13577","instance":13577,"id":216920,"goal":"lemma SetInterEmpty_13577(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_13578","instance":13578,"id":216921,"goal":"lemma SetInterSubset_13578(S: set, A: set)\n ensures S * A <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_13579","instance":13579,"id":216922,"goal":"lemma SetCardSubset_13579(S: set, U: set)\n requires S <= U\n ensures |S| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_13580","instance":13580,"id":216923,"goal":"lemma SetUnionCard_13580(B: set, T: set)\n requires B * T == {}\n ensures |B + T| == |B| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_13581","instance":13581,"id":216924,"goal":"lemma SetUnionComm_13581(T: set, B: set)\n ensures T + B == B + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_13582","instance":13582,"id":216925,"goal":"lemma SetInterComm_13582(T: set, U: set)\n ensures T * U == U * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_13583","instance":13583,"id":216926,"goal":"lemma SetUnionAssoc_13583(B: set, T: set, S: set)\n ensures (B + T) + S == B + (T + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_13584","instance":13584,"id":216927,"goal":"lemma SetSubsetRefl_13584(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_13585","instance":13585,"id":216928,"goal":"lemma SetSubsetTrans_13585(T: set, A: set, U: set)\n requires T <= A && A <= U\n ensures T <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_13586","instance":13586,"id":216929,"goal":"lemma SetUnionEmpty_13586(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_13587","instance":13587,"id":216930,"goal":"lemma SetInterEmpty_13587(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_13588","instance":13588,"id":216931,"goal":"lemma SetInterSubset_13588(B: set, U: set)\n ensures B * U <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_13589","instance":13589,"id":216932,"goal":"lemma SetCardSubset_13589(U: set, S: set)\n requires U <= S\n ensures |U| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_13590","instance":13590,"id":216933,"goal":"lemma SetUnionCard_13590(B: set, U: set)\n requires B * U == {}\n ensures |B + U| == |B| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_13591","instance":13591,"id":216934,"goal":"lemma SetUnionComm_13591(B: set, A: set)\n ensures B + A == A + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_13592","instance":13592,"id":216935,"goal":"lemma SetInterComm_13592(U: set, A: set)\n ensures U * A == A * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_13593","instance":13593,"id":216936,"goal":"lemma SetUnionAssoc_13593(T: set, B: set, S: set)\n ensures (T + B) + S == T + (B + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_13594","instance":13594,"id":216937,"goal":"lemma SetSubsetRefl_13594(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_13595","instance":13595,"id":216938,"goal":"lemma SetSubsetTrans_13595(B: set, S: set, A: set)\n requires B <= S && S <= A\n ensures B <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_13596","instance":13596,"id":216939,"goal":"lemma SetUnionEmpty_13596(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_13597","instance":13597,"id":216940,"goal":"lemma SetInterEmpty_13597(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_13598","instance":13598,"id":216941,"goal":"lemma SetInterSubset_13598(S: set, A: set)\n ensures S * A <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_13599","instance":13599,"id":216942,"goal":"lemma SetCardSubset_13599(T: set, S: set)\n requires T <= S\n ensures |T| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_13600","instance":13600,"id":216943,"goal":"lemma SetUnionCard_13600(B: set, T: set)\n requires B * T == {}\n ensures |B + T| == |B| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_13601","instance":13601,"id":216944,"goal":"lemma SetUnionComm_13601(A: set, U: set)\n ensures A + U == U + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_13602","instance":13602,"id":216945,"goal":"lemma SetInterComm_13602(U: set, A: set)\n ensures U * A == A * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_13603","instance":13603,"id":216946,"goal":"lemma SetUnionAssoc_13603(S: set, A: set, T: set)\n ensures (S + A) + T == S + (A + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_13604","instance":13604,"id":216947,"goal":"lemma SetSubsetRefl_13604(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_13605","instance":13605,"id":216948,"goal":"lemma SetSubsetTrans_13605(A: set, T: set, B: set)\n requires A <= T && T <= B\n ensures A <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_13606","instance":13606,"id":216949,"goal":"lemma SetUnionEmpty_13606(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_13607","instance":13607,"id":216950,"goal":"lemma SetInterEmpty_13607(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_13608","instance":13608,"id":216951,"goal":"lemma SetInterSubset_13608(A: set, S: set)\n ensures A * S <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_13609","instance":13609,"id":216952,"goal":"lemma SetCardSubset_13609(A: set, U: set)\n requires A <= U\n ensures |A| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_13610","instance":13610,"id":216953,"goal":"lemma SetUnionCard_13610(A: set, S: set)\n requires A * S == {}\n ensures |A + S| == |A| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_13611","instance":13611,"id":216954,"goal":"lemma SetUnionComm_13611(U: set, S: set)\n ensures U + S == S + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_13612","instance":13612,"id":216955,"goal":"lemma SetInterComm_13612(B: set, A: set)\n ensures B * A == A * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_13613","instance":13613,"id":216956,"goal":"lemma SetUnionAssoc_13613(A: set, S: set, B: set)\n ensures (A + S) + B == A + (S + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_13614","instance":13614,"id":216957,"goal":"lemma SetSubsetRefl_13614(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_13615","instance":13615,"id":216958,"goal":"lemma SetSubsetTrans_13615(B: set, U: set, T: set)\n requires B <= U && U <= T\n ensures B <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_13616","instance":13616,"id":216959,"goal":"lemma SetUnionEmpty_13616(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_13617","instance":13617,"id":216960,"goal":"lemma SetInterEmpty_13617(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_13618","instance":13618,"id":216961,"goal":"lemma SetInterSubset_13618(S: set, U: set)\n ensures S * U <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_13619","instance":13619,"id":216962,"goal":"lemma SetCardSubset_13619(U: set, A: set)\n requires U <= A\n ensures |U| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_13620","instance":13620,"id":216963,"goal":"lemma SetUnionCard_13620(B: set, U: set)\n requires B * U == {}\n ensures |B + U| == |B| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_13621","instance":13621,"id":216964,"goal":"lemma SetUnionComm_13621(S: set, B: set)\n ensures S + B == B + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_13622","instance":13622,"id":216965,"goal":"lemma SetInterComm_13622(S: set, T: set)\n ensures S * T == T * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_13623","instance":13623,"id":216966,"goal":"lemma SetUnionAssoc_13623(B: set, A: set, S: set)\n ensures (B + A) + S == B + (A + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_13624","instance":13624,"id":216967,"goal":"lemma SetSubsetRefl_13624(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_13625","instance":13625,"id":216968,"goal":"lemma SetSubsetTrans_13625(U: set, S: set, B: set)\n requires U <= S && S <= B\n ensures U <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_13626","instance":13626,"id":216969,"goal":"lemma SetUnionEmpty_13626(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_13627","instance":13627,"id":216970,"goal":"lemma SetInterEmpty_13627(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_13628","instance":13628,"id":216971,"goal":"lemma SetInterSubset_13628(B: set, S: set)\n ensures B * S <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_13629","instance":13629,"id":216972,"goal":"lemma SetCardSubset_13629(A: set, T: set)\n requires A <= T\n ensures |A| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_13630","instance":13630,"id":216973,"goal":"lemma SetUnionCard_13630(A: set, B: set)\n requires A * B == {}\n ensures |A + B| == |A| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_13631","instance":13631,"id":216974,"goal":"lemma SetUnionComm_13631(U: set, A: set)\n ensures U + A == A + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_13632","instance":13632,"id":216975,"goal":"lemma SetInterComm_13632(U: set, T: set)\n ensures U * T == T * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_13633","instance":13633,"id":216976,"goal":"lemma SetUnionAssoc_13633(B: set, U: set, T: set)\n ensures (B + U) + T == B + (U + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_13634","instance":13634,"id":216977,"goal":"lemma SetSubsetRefl_13634(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_13635","instance":13635,"id":216978,"goal":"lemma SetSubsetTrans_13635(S: set, A: set, T: set)\n requires S <= A && A <= T\n ensures S <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_13636","instance":13636,"id":216979,"goal":"lemma SetUnionEmpty_13636(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_13637","instance":13637,"id":216980,"goal":"lemma SetInterEmpty_13637(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_13638","instance":13638,"id":216981,"goal":"lemma SetInterSubset_13638(U: set, T: set)\n ensures U * T <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_13639","instance":13639,"id":216982,"goal":"lemma SetCardSubset_13639(U: set, S: set)\n requires U <= S\n ensures |U| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_13640","instance":13640,"id":216983,"goal":"lemma SetUnionCard_13640(T: set, A: set)\n requires T * A == {}\n ensures |T + A| == |T| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_13641","instance":13641,"id":216984,"goal":"lemma SetUnionComm_13641(A: set, T: set)\n ensures A + T == T + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_13642","instance":13642,"id":216985,"goal":"lemma SetInterComm_13642(S: set, A: set)\n ensures S * A == A * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_13643","instance":13643,"id":216986,"goal":"lemma SetUnionAssoc_13643(A: set, T: set, U: set)\n ensures (A + T) + U == A + (T + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_13644","instance":13644,"id":216987,"goal":"lemma SetSubsetRefl_13644(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_13645","instance":13645,"id":216988,"goal":"lemma SetSubsetTrans_13645(B: set, A: set, S: set)\n requires B <= A && A <= S\n ensures B <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_13646","instance":13646,"id":216989,"goal":"lemma SetUnionEmpty_13646(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_13647","instance":13647,"id":216990,"goal":"lemma SetInterEmpty_13647(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_13648","instance":13648,"id":216991,"goal":"lemma SetInterSubset_13648(S: set, T: set)\n ensures S * T <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_13649","instance":13649,"id":216992,"goal":"lemma SetCardSubset_13649(B: set, S: set)\n requires B <= S\n ensures |B| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_13650","instance":13650,"id":216993,"goal":"lemma SetUnionCard_13650(B: set, A: set)\n requires B * A == {}\n ensures |B + A| == |B| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_13651","instance":13651,"id":216994,"goal":"lemma SetUnionComm_13651(A: set, S: set)\n ensures A + S == S + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_13652","instance":13652,"id":216995,"goal":"lemma SetInterComm_13652(B: set, A: set)\n ensures B * A == A * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_13653","instance":13653,"id":216996,"goal":"lemma SetUnionAssoc_13653(T: set, B: set, U: set)\n ensures (T + B) + U == T + (B + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_13654","instance":13654,"id":216997,"goal":"lemma SetSubsetRefl_13654(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_13655","instance":13655,"id":216998,"goal":"lemma SetSubsetTrans_13655(T: set, A: set, U: set)\n requires T <= A && A <= U\n ensures T <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_13656","instance":13656,"id":216999,"goal":"lemma SetUnionEmpty_13656(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_13657","instance":13657,"id":217000,"goal":"lemma SetInterEmpty_13657(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_13658","instance":13658,"id":217001,"goal":"lemma SetInterSubset_13658(U: set, S: set)\n ensures U * S <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_13659","instance":13659,"id":217002,"goal":"lemma SetCardSubset_13659(B: set, S: set)\n requires B <= S\n ensures |B| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_13660","instance":13660,"id":217003,"goal":"lemma SetUnionCard_13660(A: set, S: set)\n requires A * S == {}\n ensures |A + S| == |A| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_13661","instance":13661,"id":217004,"goal":"lemma SetUnionComm_13661(U: set, A: set)\n ensures U + A == A + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_13662","instance":13662,"id":217005,"goal":"lemma SetInterComm_13662(S: set, B: set)\n ensures S * B == B * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_13663","instance":13663,"id":217006,"goal":"lemma SetUnionAssoc_13663(B: set, T: set, A: set)\n ensures (B + T) + A == B + (T + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_13664","instance":13664,"id":217007,"goal":"lemma SetSubsetRefl_13664(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_13665","instance":13665,"id":217008,"goal":"lemma SetSubsetTrans_13665(S: set, T: set, A: set)\n requires S <= T && T <= A\n ensures S <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_13666","instance":13666,"id":217009,"goal":"lemma SetUnionEmpty_13666(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_13667","instance":13667,"id":217010,"goal":"lemma SetInterEmpty_13667(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_13668","instance":13668,"id":217011,"goal":"lemma SetInterSubset_13668(U: set, B: set)\n ensures U * B <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_13669","instance":13669,"id":217012,"goal":"lemma SetCardSubset_13669(A: set, U: set)\n requires A <= U\n ensures |A| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_13670","instance":13670,"id":217013,"goal":"lemma SetUnionCard_13670(A: set, B: set)\n requires A * B == {}\n ensures |A + B| == |A| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_13671","instance":13671,"id":217014,"goal":"lemma SetUnionComm_13671(U: set, T: set)\n ensures U + T == T + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_13672","instance":13672,"id":217015,"goal":"lemma SetInterComm_13672(A: set, U: set)\n ensures A * U == U * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_13673","instance":13673,"id":217016,"goal":"lemma SetUnionAssoc_13673(B: set, S: set, T: set)\n ensures (B + S) + T == B + (S + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_13674","instance":13674,"id":217017,"goal":"lemma SetSubsetRefl_13674(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_13675","instance":13675,"id":217018,"goal":"lemma SetSubsetTrans_13675(U: set, T: set, S: set)\n requires U <= T && T <= S\n ensures U <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_13676","instance":13676,"id":217019,"goal":"lemma SetUnionEmpty_13676(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_13677","instance":13677,"id":217020,"goal":"lemma SetInterEmpty_13677(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_13678","instance":13678,"id":217021,"goal":"lemma SetInterSubset_13678(T: set, A: set)\n ensures T * A <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_13679","instance":13679,"id":217022,"goal":"lemma SetCardSubset_13679(B: set, T: set)\n requires B <= T\n ensures |B| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_13680","instance":13680,"id":217023,"goal":"lemma SetUnionCard_13680(A: set, B: set)\n requires A * B == {}\n ensures |A + B| == |A| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_13681","instance":13681,"id":217024,"goal":"lemma SetUnionComm_13681(A: set, U: set)\n ensures A + U == U + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_13682","instance":13682,"id":217025,"goal":"lemma SetInterComm_13682(U: set, A: set)\n ensures U * A == A * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_13683","instance":13683,"id":217026,"goal":"lemma SetUnionAssoc_13683(B: set, U: set, T: set)\n ensures (B + U) + T == B + (U + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_13684","instance":13684,"id":217027,"goal":"lemma SetSubsetRefl_13684(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_13685","instance":13685,"id":217028,"goal":"lemma SetSubsetTrans_13685(U: set, S: set, B: set)\n requires U <= S && S <= B\n ensures U <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_13686","instance":13686,"id":217029,"goal":"lemma SetUnionEmpty_13686(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_13687","instance":13687,"id":217030,"goal":"lemma SetInterEmpty_13687(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_13688","instance":13688,"id":217031,"goal":"lemma SetInterSubset_13688(U: set, A: set)\n ensures U * A <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_13689","instance":13689,"id":217032,"goal":"lemma SetCardSubset_13689(S: set, U: set)\n requires S <= U\n ensures |S| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_13690","instance":13690,"id":217033,"goal":"lemma SetUnionCard_13690(B: set, S: set)\n requires B * S == {}\n ensures |B + S| == |B| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_13691","instance":13691,"id":217034,"goal":"lemma SetUnionComm_13691(S: set, B: set)\n ensures S + B == B + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_13692","instance":13692,"id":217035,"goal":"lemma SetInterComm_13692(B: set, S: set)\n ensures B * S == S * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_13693","instance":13693,"id":217036,"goal":"lemma SetUnionAssoc_13693(B: set, S: set, T: set)\n ensures (B + S) + T == B + (S + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_13694","instance":13694,"id":217037,"goal":"lemma SetSubsetRefl_13694(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_13695","instance":13695,"id":217038,"goal":"lemma SetSubsetTrans_13695(U: set, B: set, T: set)\n requires U <= B && B <= T\n ensures U <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_13696","instance":13696,"id":217039,"goal":"lemma SetUnionEmpty_13696(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_13697","instance":13697,"id":217040,"goal":"lemma SetInterEmpty_13697(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_13698","instance":13698,"id":217041,"goal":"lemma SetInterSubset_13698(S: set, B: set)\n ensures S * B <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_13699","instance":13699,"id":217042,"goal":"lemma SetCardSubset_13699(A: set, S: set)\n requires A <= S\n ensures |A| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_13700","instance":13700,"id":217043,"goal":"lemma SetUnionCard_13700(T: set, S: set)\n requires T * S == {}\n ensures |T + S| == |T| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_13701","instance":13701,"id":217044,"goal":"lemma SetUnionComm_13701(S: set, B: set)\n ensures S + B == B + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_13702","instance":13702,"id":217045,"goal":"lemma SetInterComm_13702(S: set, A: set)\n ensures S * A == A * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_13703","instance":13703,"id":217046,"goal":"lemma SetUnionAssoc_13703(B: set, T: set, S: set)\n ensures (B + T) + S == B + (T + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_13704","instance":13704,"id":217047,"goal":"lemma SetSubsetRefl_13704(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_13705","instance":13705,"id":217048,"goal":"lemma SetSubsetTrans_13705(A: set, U: set, S: set)\n requires A <= U && U <= S\n ensures A <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_13706","instance":13706,"id":217049,"goal":"lemma SetUnionEmpty_13706(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_13707","instance":13707,"id":217050,"goal":"lemma SetInterEmpty_13707(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_13708","instance":13708,"id":217051,"goal":"lemma SetInterSubset_13708(A: set, T: set)\n ensures A * T <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_13709","instance":13709,"id":217052,"goal":"lemma SetCardSubset_13709(T: set, B: set)\n requires T <= B\n ensures |T| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_13710","instance":13710,"id":217053,"goal":"lemma SetUnionCard_13710(U: set, A: set)\n requires U * A == {}\n ensures |U + A| == |U| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_13711","instance":13711,"id":217054,"goal":"lemma SetUnionComm_13711(S: set, T: set)\n ensures S + T == T + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_13712","instance":13712,"id":217055,"goal":"lemma SetInterComm_13712(U: set, B: set)\n ensures U * B == B * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_13713","instance":13713,"id":217056,"goal":"lemma SetUnionAssoc_13713(B: set, U: set, A: set)\n ensures (B + U) + A == B + (U + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_13714","instance":13714,"id":217057,"goal":"lemma SetSubsetRefl_13714(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_13715","instance":13715,"id":217058,"goal":"lemma SetSubsetTrans_13715(A: set, U: set, T: set)\n requires A <= U && U <= T\n ensures A <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_13716","instance":13716,"id":217059,"goal":"lemma SetUnionEmpty_13716(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_13717","instance":13717,"id":217060,"goal":"lemma SetInterEmpty_13717(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_13718","instance":13718,"id":217061,"goal":"lemma SetInterSubset_13718(A: set, T: set)\n ensures A * T <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_13719","instance":13719,"id":217062,"goal":"lemma SetCardSubset_13719(A: set, B: set)\n requires A <= B\n ensures |A| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_13720","instance":13720,"id":217063,"goal":"lemma SetUnionCard_13720(S: set, A: set)\n requires S * A == {}\n ensures |S + A| == |S| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_13721","instance":13721,"id":217064,"goal":"lemma SetUnionComm_13721(U: set, T: set)\n ensures U + T == T + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_13722","instance":13722,"id":217065,"goal":"lemma SetInterComm_13722(A: set, T: set)\n ensures A * T == T * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_13723","instance":13723,"id":217066,"goal":"lemma SetUnionAssoc_13723(A: set, S: set, B: set)\n ensures (A + S) + B == A + (S + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_13724","instance":13724,"id":217067,"goal":"lemma SetSubsetRefl_13724(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_13725","instance":13725,"id":217068,"goal":"lemma SetSubsetTrans_13725(B: set, T: set, S: set)\n requires B <= T && T <= S\n ensures B <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_13726","instance":13726,"id":217069,"goal":"lemma SetUnionEmpty_13726(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_13727","instance":13727,"id":217070,"goal":"lemma SetInterEmpty_13727(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_13728","instance":13728,"id":217071,"goal":"lemma SetInterSubset_13728(A: set, T: set)\n ensures A * T <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_13729","instance":13729,"id":217072,"goal":"lemma SetCardSubset_13729(B: set, U: set)\n requires B <= U\n ensures |B| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_13730","instance":13730,"id":217073,"goal":"lemma SetUnionCard_13730(U: set, S: set)\n requires U * S == {}\n ensures |U + S| == |U| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_13731","instance":13731,"id":217074,"goal":"lemma SetUnionComm_13731(B: set, S: set)\n ensures B + S == S + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_13732","instance":13732,"id":217075,"goal":"lemma SetInterComm_13732(B: set, S: set)\n ensures B * S == S * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_13733","instance":13733,"id":217076,"goal":"lemma SetUnionAssoc_13733(A: set, U: set, T: set)\n ensures (A + U) + T == A + (U + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_13734","instance":13734,"id":217077,"goal":"lemma SetSubsetRefl_13734(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_13735","instance":13735,"id":217078,"goal":"lemma SetSubsetTrans_13735(B: set, A: set, T: set)\n requires B <= A && A <= T\n ensures B <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_13736","instance":13736,"id":217079,"goal":"lemma SetUnionEmpty_13736(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_13737","instance":13737,"id":217080,"goal":"lemma SetInterEmpty_13737(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_13738","instance":13738,"id":217081,"goal":"lemma SetInterSubset_13738(A: set, S: set)\n ensures A * S <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_13739","instance":13739,"id":217082,"goal":"lemma SetCardSubset_13739(A: set, U: set)\n requires A <= U\n ensures |A| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_13740","instance":13740,"id":217083,"goal":"lemma SetUnionCard_13740(B: set, S: set)\n requires B * S == {}\n ensures |B + S| == |B| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_13741","instance":13741,"id":217084,"goal":"lemma SetUnionComm_13741(T: set, U: set)\n ensures T + U == U + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_13742","instance":13742,"id":217085,"goal":"lemma SetInterComm_13742(A: set, T: set)\n ensures A * T == T * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_13743","instance":13743,"id":217086,"goal":"lemma SetUnionAssoc_13743(A: set, T: set, U: set)\n ensures (A + T) + U == A + (T + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_13744","instance":13744,"id":217087,"goal":"lemma SetSubsetRefl_13744(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_13745","instance":13745,"id":217088,"goal":"lemma SetSubsetTrans_13745(A: set, B: set, U: set)\n requires A <= B && B <= U\n ensures A <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_13746","instance":13746,"id":217089,"goal":"lemma SetUnionEmpty_13746(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_13747","instance":13747,"id":217090,"goal":"lemma SetInterEmpty_13747(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_13748","instance":13748,"id":217091,"goal":"lemma SetInterSubset_13748(A: set, T: set)\n ensures A * T <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_13749","instance":13749,"id":217092,"goal":"lemma SetCardSubset_13749(B: set, S: set)\n requires B <= S\n ensures |B| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_13750","instance":13750,"id":217093,"goal":"lemma SetUnionCard_13750(S: set, A: set)\n requires S * A == {}\n ensures |S + A| == |S| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_13751","instance":13751,"id":217094,"goal":"lemma SetUnionComm_13751(B: set, A: set)\n ensures B + A == A + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_13752","instance":13752,"id":217095,"goal":"lemma SetInterComm_13752(T: set, U: set)\n ensures T * U == U * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_13753","instance":13753,"id":217096,"goal":"lemma SetUnionAssoc_13753(S: set, U: set, A: set)\n ensures (S + U) + A == S + (U + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_13754","instance":13754,"id":217097,"goal":"lemma SetSubsetRefl_13754(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_13755","instance":13755,"id":217098,"goal":"lemma SetSubsetTrans_13755(B: set, T: set, U: set)\n requires B <= T && T <= U\n ensures B <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_13756","instance":13756,"id":217099,"goal":"lemma SetUnionEmpty_13756(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_13757","instance":13757,"id":217100,"goal":"lemma SetInterEmpty_13757(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_13758","instance":13758,"id":217101,"goal":"lemma SetInterSubset_13758(S: set, B: set)\n ensures S * B <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_13759","instance":13759,"id":217102,"goal":"lemma SetCardSubset_13759(U: set, B: set)\n requires U <= B\n ensures |U| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_13760","instance":13760,"id":217103,"goal":"lemma SetUnionCard_13760(T: set, U: set)\n requires T * U == {}\n ensures |T + U| == |T| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_13761","instance":13761,"id":217104,"goal":"lemma SetUnionComm_13761(U: set, S: set)\n ensures U + S == S + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_13762","instance":13762,"id":217105,"goal":"lemma SetInterComm_13762(B: set, T: set)\n ensures B * T == T * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_13763","instance":13763,"id":217106,"goal":"lemma SetUnionAssoc_13763(T: set, U: set, A: set)\n ensures (T + U) + A == T + (U + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_13764","instance":13764,"id":217107,"goal":"lemma SetSubsetRefl_13764(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_13765","instance":13765,"id":217108,"goal":"lemma SetSubsetTrans_13765(A: set, S: set, U: set)\n requires A <= S && S <= U\n ensures A <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_13766","instance":13766,"id":217109,"goal":"lemma SetUnionEmpty_13766(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_13767","instance":13767,"id":217110,"goal":"lemma SetInterEmpty_13767(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_13768","instance":13768,"id":217111,"goal":"lemma SetInterSubset_13768(S: set, B: set)\n ensures S * B <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_13769","instance":13769,"id":217112,"goal":"lemma SetCardSubset_13769(A: set, T: set)\n requires A <= T\n ensures |A| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_13770","instance":13770,"id":217113,"goal":"lemma SetUnionCard_13770(S: set, A: set)\n requires S * A == {}\n ensures |S + A| == |S| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_13771","instance":13771,"id":217114,"goal":"lemma SetUnionComm_13771(B: set, A: set)\n ensures B + A == A + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_13772","instance":13772,"id":217115,"goal":"lemma SetInterComm_13772(U: set, B: set)\n ensures U * B == B * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_13773","instance":13773,"id":217116,"goal":"lemma SetUnionAssoc_13773(A: set, B: set, U: set)\n ensures (A + B) + U == A + (B + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_13774","instance":13774,"id":217117,"goal":"lemma SetSubsetRefl_13774(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_13775","instance":13775,"id":217118,"goal":"lemma SetSubsetTrans_13775(S: set, B: set, A: set)\n requires S <= B && B <= A\n ensures S <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_13776","instance":13776,"id":217119,"goal":"lemma SetUnionEmpty_13776(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_13777","instance":13777,"id":217120,"goal":"lemma SetInterEmpty_13777(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_13778","instance":13778,"id":217121,"goal":"lemma SetInterSubset_13778(T: set, B: set)\n ensures T * B <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_13779","instance":13779,"id":217122,"goal":"lemma SetCardSubset_13779(T: set, S: set)\n requires T <= S\n ensures |T| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_13780","instance":13780,"id":217123,"goal":"lemma SetUnionCard_13780(B: set, U: set)\n requires B * U == {}\n ensures |B + U| == |B| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_13781","instance":13781,"id":217124,"goal":"lemma SetUnionComm_13781(T: set, U: set)\n ensures T + U == U + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_13782","instance":13782,"id":217125,"goal":"lemma SetInterComm_13782(B: set, U: set)\n ensures B * U == U * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_13783","instance":13783,"id":217126,"goal":"lemma SetUnionAssoc_13783(S: set, T: set, U: set)\n ensures (S + T) + U == S + (T + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_13784","instance":13784,"id":217127,"goal":"lemma SetSubsetRefl_13784(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_13785","instance":13785,"id":217128,"goal":"lemma SetSubsetTrans_13785(U: set, B: set, T: set)\n requires U <= B && B <= T\n ensures U <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_13786","instance":13786,"id":217129,"goal":"lemma SetUnionEmpty_13786(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_13787","instance":13787,"id":217130,"goal":"lemma SetInterEmpty_13787(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_13788","instance":13788,"id":217131,"goal":"lemma SetInterSubset_13788(T: set, U: set)\n ensures T * U <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_13789","instance":13789,"id":217132,"goal":"lemma SetCardSubset_13789(B: set, U: set)\n requires B <= U\n ensures |B| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_13790","instance":13790,"id":217133,"goal":"lemma SetUnionCard_13790(U: set, T: set)\n requires U * T == {}\n ensures |U + T| == |U| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_13791","instance":13791,"id":217134,"goal":"lemma SetUnionComm_13791(S: set, U: set)\n ensures S + U == U + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_13792","instance":13792,"id":217135,"goal":"lemma SetInterComm_13792(A: set, T: set)\n ensures A * T == T * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_13793","instance":13793,"id":217136,"goal":"lemma SetUnionAssoc_13793(T: set, S: set, A: set)\n ensures (T + S) + A == T + (S + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_13794","instance":13794,"id":217137,"goal":"lemma SetSubsetRefl_13794(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_13795","instance":13795,"id":217138,"goal":"lemma SetSubsetTrans_13795(T: set, U: set, S: set)\n requires T <= U && U <= S\n ensures T <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_13796","instance":13796,"id":217139,"goal":"lemma SetUnionEmpty_13796(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_13797","instance":13797,"id":217140,"goal":"lemma SetInterEmpty_13797(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_13798","instance":13798,"id":217141,"goal":"lemma SetInterSubset_13798(U: set, T: set)\n ensures U * T <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_13799","instance":13799,"id":217142,"goal":"lemma SetCardSubset_13799(A: set, B: set)\n requires A <= B\n ensures |A| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_13800","instance":13800,"id":217143,"goal":"lemma SetUnionCard_13800(B: set, T: set)\n requires B * T == {}\n ensures |B + T| == |B| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_13801","instance":13801,"id":217144,"goal":"lemma SetUnionComm_13801(U: set, S: set)\n ensures U + S == S + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_13802","instance":13802,"id":217145,"goal":"lemma SetInterComm_13802(B: set, A: set)\n ensures B * A == A * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_13803","instance":13803,"id":217146,"goal":"lemma SetUnionAssoc_13803(B: set, T: set, U: set)\n ensures (B + T) + U == B + (T + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_13804","instance":13804,"id":217147,"goal":"lemma SetSubsetRefl_13804(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_13805","instance":13805,"id":217148,"goal":"lemma SetSubsetTrans_13805(A: set, T: set, U: set)\n requires A <= T && T <= U\n ensures A <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_13806","instance":13806,"id":217149,"goal":"lemma SetUnionEmpty_13806(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_13807","instance":13807,"id":217150,"goal":"lemma SetInterEmpty_13807(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_13808","instance":13808,"id":217151,"goal":"lemma SetInterSubset_13808(B: set, S: set)\n ensures B * S <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_13809","instance":13809,"id":217152,"goal":"lemma SetCardSubset_13809(B: set, T: set)\n requires B <= T\n ensures |B| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_13810","instance":13810,"id":217153,"goal":"lemma SetUnionCard_13810(S: set, A: set)\n requires S * A == {}\n ensures |S + A| == |S| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_13811","instance":13811,"id":217154,"goal":"lemma SetUnionComm_13811(A: set, B: set)\n ensures A + B == B + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_13812","instance":13812,"id":217155,"goal":"lemma SetInterComm_13812(A: set, S: set)\n ensures A * S == S * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_13813","instance":13813,"id":217156,"goal":"lemma SetUnionAssoc_13813(T: set, A: set, B: set)\n ensures (T + A) + B == T + (A + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_13814","instance":13814,"id":217157,"goal":"lemma SetSubsetRefl_13814(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_13815","instance":13815,"id":217158,"goal":"lemma SetSubsetTrans_13815(S: set, T: set, U: set)\n requires S <= T && T <= U\n ensures S <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_13816","instance":13816,"id":217159,"goal":"lemma SetUnionEmpty_13816(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_13817","instance":13817,"id":217160,"goal":"lemma SetInterEmpty_13817(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_13818","instance":13818,"id":217161,"goal":"lemma SetInterSubset_13818(B: set, S: set)\n ensures B * S <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_13819","instance":13819,"id":217162,"goal":"lemma SetCardSubset_13819(B: set, A: set)\n requires B <= A\n ensures |B| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_13820","instance":13820,"id":217163,"goal":"lemma SetUnionCard_13820(S: set, A: set)\n requires S * A == {}\n ensures |S + A| == |S| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_13821","instance":13821,"id":217164,"goal":"lemma SetUnionComm_13821(U: set, A: set)\n ensures U + A == A + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_13822","instance":13822,"id":217165,"goal":"lemma SetInterComm_13822(T: set, S: set)\n ensures T * S == S * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_13823","instance":13823,"id":217166,"goal":"lemma SetUnionAssoc_13823(T: set, U: set, B: set)\n ensures (T + U) + B == T + (U + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_13824","instance":13824,"id":217167,"goal":"lemma SetSubsetRefl_13824(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_13825","instance":13825,"id":217168,"goal":"lemma SetSubsetTrans_13825(A: set, U: set, T: set)\n requires A <= U && U <= T\n ensures A <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_13826","instance":13826,"id":217169,"goal":"lemma SetUnionEmpty_13826(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_13827","instance":13827,"id":217170,"goal":"lemma SetInterEmpty_13827(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_13828","instance":13828,"id":217171,"goal":"lemma SetInterSubset_13828(U: set, A: set)\n ensures U * A <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_13829","instance":13829,"id":217172,"goal":"lemma SetCardSubset_13829(U: set, B: set)\n requires U <= B\n ensures |U| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_13830","instance":13830,"id":217173,"goal":"lemma SetUnionCard_13830(A: set, T: set)\n requires A * T == {}\n ensures |A + T| == |A| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_13831","instance":13831,"id":217174,"goal":"lemma SetUnionComm_13831(S: set, U: set)\n ensures S + U == U + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_13832","instance":13832,"id":217175,"goal":"lemma SetInterComm_13832(S: set, B: set)\n ensures S * B == B * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_13833","instance":13833,"id":217176,"goal":"lemma SetUnionAssoc_13833(S: set, B: set, T: set)\n ensures (S + B) + T == S + (B + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_13834","instance":13834,"id":217177,"goal":"lemma SetSubsetRefl_13834(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_13835","instance":13835,"id":217178,"goal":"lemma SetSubsetTrans_13835(T: set, S: set, B: set)\n requires T <= S && S <= B\n ensures T <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_13836","instance":13836,"id":217179,"goal":"lemma SetUnionEmpty_13836(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_13837","instance":13837,"id":217180,"goal":"lemma SetInterEmpty_13837(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_13838","instance":13838,"id":217181,"goal":"lemma SetInterSubset_13838(U: set, B: set)\n ensures U * B <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_13839","instance":13839,"id":217182,"goal":"lemma SetCardSubset_13839(S: set, U: set)\n requires S <= U\n ensures |S| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_13840","instance":13840,"id":217183,"goal":"lemma SetUnionCard_13840(A: set, T: set)\n requires A * T == {}\n ensures |A + T| == |A| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_13841","instance":13841,"id":217184,"goal":"lemma SetUnionComm_13841(B: set, A: set)\n ensures B + A == A + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_13842","instance":13842,"id":217185,"goal":"lemma SetInterComm_13842(T: set, B: set)\n ensures T * B == B * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_13843","instance":13843,"id":217186,"goal":"lemma SetUnionAssoc_13843(T: set, U: set, S: set)\n ensures (T + U) + S == T + (U + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_13844","instance":13844,"id":217187,"goal":"lemma SetSubsetRefl_13844(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_13845","instance":13845,"id":217188,"goal":"lemma SetSubsetTrans_13845(B: set, T: set, A: set)\n requires B <= T && T <= A\n ensures B <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_13846","instance":13846,"id":217189,"goal":"lemma SetUnionEmpty_13846(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_13847","instance":13847,"id":217190,"goal":"lemma SetInterEmpty_13847(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_13848","instance":13848,"id":217191,"goal":"lemma SetInterSubset_13848(B: set, U: set)\n ensures B * U <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_13849","instance":13849,"id":217192,"goal":"lemma SetCardSubset_13849(B: set, A: set)\n requires B <= A\n ensures |B| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_13850","instance":13850,"id":217193,"goal":"lemma SetUnionCard_13850(B: set, T: set)\n requires B * T == {}\n ensures |B + T| == |B| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_13851","instance":13851,"id":217194,"goal":"lemma SetUnionComm_13851(U: set, S: set)\n ensures U + S == S + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_13852","instance":13852,"id":217195,"goal":"lemma SetInterComm_13852(A: set, S: set)\n ensures A * S == S * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_13853","instance":13853,"id":217196,"goal":"lemma SetUnionAssoc_13853(B: set, T: set, S: set)\n ensures (B + T) + S == B + (T + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_13854","instance":13854,"id":217197,"goal":"lemma SetSubsetRefl_13854(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_13855","instance":13855,"id":217198,"goal":"lemma SetSubsetTrans_13855(B: set, A: set, S: set)\n requires B <= A && A <= S\n ensures B <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_13856","instance":13856,"id":217199,"goal":"lemma SetUnionEmpty_13856(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_13857","instance":13857,"id":217200,"goal":"lemma SetInterEmpty_13857(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_13858","instance":13858,"id":217201,"goal":"lemma SetInterSubset_13858(T: set, B: set)\n ensures T * B <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_13859","instance":13859,"id":217202,"goal":"lemma SetCardSubset_13859(B: set, A: set)\n requires B <= A\n ensures |B| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_13860","instance":13860,"id":217203,"goal":"lemma SetUnionCard_13860(A: set, U: set)\n requires A * U == {}\n ensures |A + U| == |A| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_13861","instance":13861,"id":217204,"goal":"lemma SetUnionComm_13861(T: set, S: set)\n ensures T + S == S + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_13862","instance":13862,"id":217205,"goal":"lemma SetInterComm_13862(B: set, S: set)\n ensures B * S == S * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_13863","instance":13863,"id":217206,"goal":"lemma SetUnionAssoc_13863(U: set, B: set, S: set)\n ensures (U + B) + S == U + (B + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_13864","instance":13864,"id":217207,"goal":"lemma SetSubsetRefl_13864(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_13865","instance":13865,"id":217208,"goal":"lemma SetSubsetTrans_13865(U: set, A: set, B: set)\n requires U <= A && A <= B\n ensures U <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_13866","instance":13866,"id":217209,"goal":"lemma SetUnionEmpty_13866(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_13867","instance":13867,"id":217210,"goal":"lemma SetInterEmpty_13867(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_13868","instance":13868,"id":217211,"goal":"lemma SetInterSubset_13868(T: set, S: set)\n ensures T * S <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_13869","instance":13869,"id":217212,"goal":"lemma SetCardSubset_13869(A: set, U: set)\n requires A <= U\n ensures |A| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_13870","instance":13870,"id":217213,"goal":"lemma SetUnionCard_13870(B: set, A: set)\n requires B * A == {}\n ensures |B + A| == |B| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_13871","instance":13871,"id":217214,"goal":"lemma SetUnionComm_13871(S: set, U: set)\n ensures S + U == U + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_13872","instance":13872,"id":217215,"goal":"lemma SetInterComm_13872(U: set, T: set)\n ensures U * T == T * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_13873","instance":13873,"id":217216,"goal":"lemma SetUnionAssoc_13873(A: set, T: set, S: set)\n ensures (A + T) + S == A + (T + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_13874","instance":13874,"id":217217,"goal":"lemma SetSubsetRefl_13874(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_13875","instance":13875,"id":217218,"goal":"lemma SetSubsetTrans_13875(S: set, U: set, T: set)\n requires S <= U && U <= T\n ensures S <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_13876","instance":13876,"id":217219,"goal":"lemma SetUnionEmpty_13876(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_13877","instance":13877,"id":217220,"goal":"lemma SetInterEmpty_13877(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_13878","instance":13878,"id":217221,"goal":"lemma SetInterSubset_13878(T: set, U: set)\n ensures T * U <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_13879","instance":13879,"id":217222,"goal":"lemma SetCardSubset_13879(A: set, S: set)\n requires A <= S\n ensures |A| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_13880","instance":13880,"id":217223,"goal":"lemma SetUnionCard_13880(S: set, T: set)\n requires S * T == {}\n ensures |S + T| == |S| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_13881","instance":13881,"id":217224,"goal":"lemma SetUnionComm_13881(B: set, A: set)\n ensures B + A == A + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_13882","instance":13882,"id":217225,"goal":"lemma SetInterComm_13882(S: set, A: set)\n ensures S * A == A * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_13883","instance":13883,"id":217226,"goal":"lemma SetUnionAssoc_13883(U: set, S: set, A: set)\n ensures (U + S) + A == U + (S + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_13884","instance":13884,"id":217227,"goal":"lemma SetSubsetRefl_13884(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_13885","instance":13885,"id":217228,"goal":"lemma SetSubsetTrans_13885(U: set, B: set, T: set)\n requires U <= B && B <= T\n ensures U <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_13886","instance":13886,"id":217229,"goal":"lemma SetUnionEmpty_13886(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_13887","instance":13887,"id":217230,"goal":"lemma SetInterEmpty_13887(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_13888","instance":13888,"id":217231,"goal":"lemma SetInterSubset_13888(T: set, A: set)\n ensures T * A <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_13889","instance":13889,"id":217232,"goal":"lemma SetCardSubset_13889(T: set, A: set)\n requires T <= A\n ensures |T| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_13890","instance":13890,"id":217233,"goal":"lemma SetUnionCard_13890(B: set, T: set)\n requires B * T == {}\n ensures |B + T| == |B| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_13891","instance":13891,"id":217234,"goal":"lemma SetUnionComm_13891(T: set, B: set)\n ensures T + B == B + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_13892","instance":13892,"id":217235,"goal":"lemma SetInterComm_13892(S: set, A: set)\n ensures S * A == A * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_13893","instance":13893,"id":217236,"goal":"lemma SetUnionAssoc_13893(S: set, U: set, B: set)\n ensures (S + U) + B == S + (U + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_13894","instance":13894,"id":217237,"goal":"lemma SetSubsetRefl_13894(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_13895","instance":13895,"id":217238,"goal":"lemma SetSubsetTrans_13895(T: set, U: set, A: set)\n requires T <= U && U <= A\n ensures T <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_13896","instance":13896,"id":217239,"goal":"lemma SetUnionEmpty_13896(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_13897","instance":13897,"id":217240,"goal":"lemma SetInterEmpty_13897(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_13898","instance":13898,"id":217241,"goal":"lemma SetInterSubset_13898(B: set, A: set)\n ensures B * A <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_13899","instance":13899,"id":217242,"goal":"lemma SetCardSubset_13899(T: set, S: set)\n requires T <= S\n ensures |T| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_13900","instance":13900,"id":217243,"goal":"lemma SetUnionCard_13900(T: set, A: set)\n requires T * A == {}\n ensures |T + A| == |T| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_13901","instance":13901,"id":217244,"goal":"lemma SetUnionComm_13901(T: set, B: set)\n ensures T + B == B + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_13902","instance":13902,"id":217245,"goal":"lemma SetInterComm_13902(B: set, T: set)\n ensures B * T == T * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_13903","instance":13903,"id":217246,"goal":"lemma SetUnionAssoc_13903(T: set, U: set, A: set)\n ensures (T + U) + A == T + (U + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_13904","instance":13904,"id":217247,"goal":"lemma SetSubsetRefl_13904(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_13905","instance":13905,"id":217248,"goal":"lemma SetSubsetTrans_13905(U: set, T: set, S: set)\n requires U <= T && T <= S\n ensures U <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_13906","instance":13906,"id":217249,"goal":"lemma SetUnionEmpty_13906(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_13907","instance":13907,"id":217250,"goal":"lemma SetInterEmpty_13907(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_13908","instance":13908,"id":217251,"goal":"lemma SetInterSubset_13908(S: set, U: set)\n ensures S * U <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_13909","instance":13909,"id":217252,"goal":"lemma SetCardSubset_13909(A: set, U: set)\n requires A <= U\n ensures |A| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_13910","instance":13910,"id":217253,"goal":"lemma SetUnionCard_13910(A: set, S: set)\n requires A * S == {}\n ensures |A + S| == |A| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_13911","instance":13911,"id":217254,"goal":"lemma SetUnionComm_13911(T: set, A: set)\n ensures T + A == A + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_13912","instance":13912,"id":217255,"goal":"lemma SetInterComm_13912(A: set, T: set)\n ensures A * T == T * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_13913","instance":13913,"id":217256,"goal":"lemma SetUnionAssoc_13913(S: set, U: set, B: set)\n ensures (S + U) + B == S + (U + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_13914","instance":13914,"id":217257,"goal":"lemma SetSubsetRefl_13914(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_13915","instance":13915,"id":217258,"goal":"lemma SetSubsetTrans_13915(S: set, B: set, A: set)\n requires S <= B && B <= A\n ensures S <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_13916","instance":13916,"id":217259,"goal":"lemma SetUnionEmpty_13916(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_13917","instance":13917,"id":217260,"goal":"lemma SetInterEmpty_13917(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_13918","instance":13918,"id":217261,"goal":"lemma SetInterSubset_13918(T: set, U: set)\n ensures T * U <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_13919","instance":13919,"id":217262,"goal":"lemma SetCardSubset_13919(B: set, A: set)\n requires B <= A\n ensures |B| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_13920","instance":13920,"id":217263,"goal":"lemma SetUnionCard_13920(T: set, B: set)\n requires T * B == {}\n ensures |T + B| == |T| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_13921","instance":13921,"id":217264,"goal":"lemma SetUnionComm_13921(S: set, U: set)\n ensures S + U == U + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_13922","instance":13922,"id":217265,"goal":"lemma SetInterComm_13922(T: set, B: set)\n ensures T * B == B * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_13923","instance":13923,"id":217266,"goal":"lemma SetUnionAssoc_13923(T: set, B: set, S: set)\n ensures (T + B) + S == T + (B + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_13924","instance":13924,"id":217267,"goal":"lemma SetSubsetRefl_13924(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_13925","instance":13925,"id":217268,"goal":"lemma SetSubsetTrans_13925(U: set, A: set, B: set)\n requires U <= A && A <= B\n ensures U <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_13926","instance":13926,"id":217269,"goal":"lemma SetUnionEmpty_13926(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_13927","instance":13927,"id":217270,"goal":"lemma SetInterEmpty_13927(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_13928","instance":13928,"id":217271,"goal":"lemma SetInterSubset_13928(A: set, B: set)\n ensures A * B <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_13929","instance":13929,"id":217272,"goal":"lemma SetCardSubset_13929(U: set, T: set)\n requires U <= T\n ensures |U| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_13930","instance":13930,"id":217273,"goal":"lemma SetUnionCard_13930(B: set, S: set)\n requires B * S == {}\n ensures |B + S| == |B| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_13931","instance":13931,"id":217274,"goal":"lemma SetUnionComm_13931(A: set, U: set)\n ensures A + U == U + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_13932","instance":13932,"id":217275,"goal":"lemma SetInterComm_13932(U: set, T: set)\n ensures U * T == T * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_13933","instance":13933,"id":217276,"goal":"lemma SetUnionAssoc_13933(A: set, U: set, T: set)\n ensures (A + U) + T == A + (U + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_13934","instance":13934,"id":217277,"goal":"lemma SetSubsetRefl_13934(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_13935","instance":13935,"id":217278,"goal":"lemma SetSubsetTrans_13935(U: set, T: set, A: set)\n requires U <= T && T <= A\n ensures U <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_13936","instance":13936,"id":217279,"goal":"lemma SetUnionEmpty_13936(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_13937","instance":13937,"id":217280,"goal":"lemma SetInterEmpty_13937(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_13938","instance":13938,"id":217281,"goal":"lemma SetInterSubset_13938(A: set, B: set)\n ensures A * B <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_13939","instance":13939,"id":217282,"goal":"lemma SetCardSubset_13939(T: set, S: set)\n requires T <= S\n ensures |T| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_13940","instance":13940,"id":217283,"goal":"lemma SetUnionCard_13940(U: set, B: set)\n requires U * B == {}\n ensures |U + B| == |U| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_13941","instance":13941,"id":217284,"goal":"lemma SetUnionComm_13941(A: set, B: set)\n ensures A + B == B + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_13942","instance":13942,"id":217285,"goal":"lemma SetInterComm_13942(T: set, U: set)\n ensures T * U == U * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_13943","instance":13943,"id":217286,"goal":"lemma SetUnionAssoc_13943(T: set, S: set, B: set)\n ensures (T + S) + B == T + (S + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_13944","instance":13944,"id":217287,"goal":"lemma SetSubsetRefl_13944(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_13945","instance":13945,"id":217288,"goal":"lemma SetSubsetTrans_13945(B: set, S: set, T: set)\n requires B <= S && S <= T\n ensures B <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_13946","instance":13946,"id":217289,"goal":"lemma SetUnionEmpty_13946(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_13947","instance":13947,"id":217290,"goal":"lemma SetInterEmpty_13947(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_13948","instance":13948,"id":217291,"goal":"lemma SetInterSubset_13948(S: set, A: set)\n ensures S * A <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_13949","instance":13949,"id":217292,"goal":"lemma SetCardSubset_13949(B: set, S: set)\n requires B <= S\n ensures |B| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_13950","instance":13950,"id":217293,"goal":"lemma SetUnionCard_13950(T: set, B: set)\n requires T * B == {}\n ensures |T + B| == |T| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_13951","instance":13951,"id":217294,"goal":"lemma SetUnionComm_13951(A: set, T: set)\n ensures A + T == T + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_13952","instance":13952,"id":217295,"goal":"lemma SetInterComm_13952(T: set, S: set)\n ensures T * S == S * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_13953","instance":13953,"id":217296,"goal":"lemma SetUnionAssoc_13953(T: set, U: set, B: set)\n ensures (T + U) + B == T + (U + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_13954","instance":13954,"id":217297,"goal":"lemma SetSubsetRefl_13954(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_13955","instance":13955,"id":217298,"goal":"lemma SetSubsetTrans_13955(A: set, B: set, S: set)\n requires A <= B && B <= S\n ensures A <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_13956","instance":13956,"id":217299,"goal":"lemma SetUnionEmpty_13956(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_13957","instance":13957,"id":217300,"goal":"lemma SetInterEmpty_13957(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_13958","instance":13958,"id":217301,"goal":"lemma SetInterSubset_13958(B: set, A: set)\n ensures B * A <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_13959","instance":13959,"id":217302,"goal":"lemma SetCardSubset_13959(U: set, A: set)\n requires U <= A\n ensures |U| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_13960","instance":13960,"id":217303,"goal":"lemma SetUnionCard_13960(B: set, S: set)\n requires B * S == {}\n ensures |B + S| == |B| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_13961","instance":13961,"id":217304,"goal":"lemma SetUnionComm_13961(B: set, S: set)\n ensures B + S == S + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_13962","instance":13962,"id":217305,"goal":"lemma SetInterComm_13962(T: set, A: set)\n ensures T * A == A * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_13963","instance":13963,"id":217306,"goal":"lemma SetUnionAssoc_13963(A: set, B: set, T: set)\n ensures (A + B) + T == A + (B + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_13964","instance":13964,"id":217307,"goal":"lemma SetSubsetRefl_13964(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_13965","instance":13965,"id":217308,"goal":"lemma SetSubsetTrans_13965(U: set, S: set, A: set)\n requires U <= S && S <= A\n ensures U <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_13966","instance":13966,"id":217309,"goal":"lemma SetUnionEmpty_13966(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_13967","instance":13967,"id":217310,"goal":"lemma SetInterEmpty_13967(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_13968","instance":13968,"id":217311,"goal":"lemma SetInterSubset_13968(T: set, B: set)\n ensures T * B <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_13969","instance":13969,"id":217312,"goal":"lemma SetCardSubset_13969(B: set, S: set)\n requires B <= S\n ensures |B| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_13970","instance":13970,"id":217313,"goal":"lemma SetUnionCard_13970(S: set, B: set)\n requires S * B == {}\n ensures |S + B| == |S| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_13971","instance":13971,"id":217314,"goal":"lemma SetUnionComm_13971(T: set, A: set)\n ensures T + A == A + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_13972","instance":13972,"id":217315,"goal":"lemma SetInterComm_13972(A: set, S: set)\n ensures A * S == S * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_13973","instance":13973,"id":217316,"goal":"lemma SetUnionAssoc_13973(A: set, B: set, U: set)\n ensures (A + B) + U == A + (B + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_13974","instance":13974,"id":217317,"goal":"lemma SetSubsetRefl_13974(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_13975","instance":13975,"id":217318,"goal":"lemma SetSubsetTrans_13975(T: set, B: set, A: set)\n requires T <= B && B <= A\n ensures T <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_13976","instance":13976,"id":217319,"goal":"lemma SetUnionEmpty_13976(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_13977","instance":13977,"id":217320,"goal":"lemma SetInterEmpty_13977(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_13978","instance":13978,"id":217321,"goal":"lemma SetInterSubset_13978(U: set, S: set)\n ensures U * S <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_13979","instance":13979,"id":217322,"goal":"lemma SetCardSubset_13979(S: set, T: set)\n requires S <= T\n ensures |S| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_13980","instance":13980,"id":217323,"goal":"lemma SetUnionCard_13980(A: set, T: set)\n requires A * T == {}\n ensures |A + T| == |A| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_13981","instance":13981,"id":217324,"goal":"lemma SetUnionComm_13981(A: set, B: set)\n ensures A + B == B + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_13982","instance":13982,"id":217325,"goal":"lemma SetInterComm_13982(U: set, T: set)\n ensures U * T == T * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_13983","instance":13983,"id":217326,"goal":"lemma SetUnionAssoc_13983(B: set, A: set, T: set)\n ensures (B + A) + T == B + (A + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_13984","instance":13984,"id":217327,"goal":"lemma SetSubsetRefl_13984(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_13985","instance":13985,"id":217328,"goal":"lemma SetSubsetTrans_13985(U: set, B: set, S: set)\n requires U <= B && B <= S\n ensures U <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_13986","instance":13986,"id":217329,"goal":"lemma SetUnionEmpty_13986(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_13987","instance":13987,"id":217330,"goal":"lemma SetInterEmpty_13987(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_13988","instance":13988,"id":217331,"goal":"lemma SetInterSubset_13988(A: set, S: set)\n ensures A * S <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_13989","instance":13989,"id":217332,"goal":"lemma SetCardSubset_13989(T: set, U: set)\n requires T <= U\n ensures |T| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_13990","instance":13990,"id":217333,"goal":"lemma SetUnionCard_13990(B: set, A: set)\n requires B * A == {}\n ensures |B + A| == |B| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_13991","instance":13991,"id":217334,"goal":"lemma SetUnionComm_13991(A: set, S: set)\n ensures A + S == S + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_13992","instance":13992,"id":217335,"goal":"lemma SetInterComm_13992(A: set, B: set)\n ensures A * B == B * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_13993","instance":13993,"id":217336,"goal":"lemma SetUnionAssoc_13993(U: set, A: set, T: set)\n ensures (U + A) + T == U + (A + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_13994","instance":13994,"id":217337,"goal":"lemma SetSubsetRefl_13994(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_13995","instance":13995,"id":217338,"goal":"lemma SetSubsetTrans_13995(S: set, T: set, U: set)\n requires S <= T && T <= U\n ensures S <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_13996","instance":13996,"id":217339,"goal":"lemma SetUnionEmpty_13996(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_13997","instance":13997,"id":217340,"goal":"lemma SetInterEmpty_13997(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_13998","instance":13998,"id":217341,"goal":"lemma SetInterSubset_13998(T: set, S: set)\n ensures T * S <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_13999","instance":13999,"id":217342,"goal":"lemma SetCardSubset_13999(T: set, B: set)\n requires T <= B\n ensures |T| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_14000","instance":14000,"id":217343,"goal":"lemma SetUnionCard_14000(T: set, B: set)\n requires T * B == {}\n ensures |T + B| == |T| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_14001","instance":14001,"id":217344,"goal":"lemma SetUnionComm_14001(B: set, T: set)\n ensures B + T == T + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_14002","instance":14002,"id":217345,"goal":"lemma SetInterComm_14002(B: set, U: set)\n ensures B * U == U * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_14003","instance":14003,"id":217346,"goal":"lemma SetUnionAssoc_14003(S: set, T: set, B: set)\n ensures (S + T) + B == S + (T + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_14004","instance":14004,"id":217347,"goal":"lemma SetSubsetRefl_14004(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_14005","instance":14005,"id":217348,"goal":"lemma SetSubsetTrans_14005(A: set, U: set, S: set)\n requires A <= U && U <= S\n ensures A <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_14006","instance":14006,"id":217349,"goal":"lemma SetUnionEmpty_14006(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_14007","instance":14007,"id":217350,"goal":"lemma SetInterEmpty_14007(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_14008","instance":14008,"id":217351,"goal":"lemma SetInterSubset_14008(B: set, A: set)\n ensures B * A <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_14009","instance":14009,"id":217352,"goal":"lemma SetCardSubset_14009(T: set, A: set)\n requires T <= A\n ensures |T| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_14010","instance":14010,"id":217353,"goal":"lemma SetUnionCard_14010(S: set, B: set)\n requires S * B == {}\n ensures |S + B| == |S| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_14011","instance":14011,"id":217354,"goal":"lemma SetUnionComm_14011(S: set, A: set)\n ensures S + A == A + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_14012","instance":14012,"id":217355,"goal":"lemma SetInterComm_14012(B: set, U: set)\n ensures B * U == U * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_14013","instance":14013,"id":217356,"goal":"lemma SetUnionAssoc_14013(U: set, T: set, A: set)\n ensures (U + T) + A == U + (T + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_14014","instance":14014,"id":217357,"goal":"lemma SetSubsetRefl_14014(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_14015","instance":14015,"id":217358,"goal":"lemma SetSubsetTrans_14015(A: set, U: set, S: set)\n requires A <= U && U <= S\n ensures A <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_14016","instance":14016,"id":217359,"goal":"lemma SetUnionEmpty_14016(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_14017","instance":14017,"id":217360,"goal":"lemma SetInterEmpty_14017(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_14018","instance":14018,"id":217361,"goal":"lemma SetInterSubset_14018(U: set, S: set)\n ensures U * S <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_14019","instance":14019,"id":217362,"goal":"lemma SetCardSubset_14019(S: set, T: set)\n requires S <= T\n ensures |S| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_14020","instance":14020,"id":217363,"goal":"lemma SetUnionCard_14020(B: set, S: set)\n requires B * S == {}\n ensures |B + S| == |B| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_14021","instance":14021,"id":217364,"goal":"lemma SetUnionComm_14021(B: set, U: set)\n ensures B + U == U + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_14022","instance":14022,"id":217365,"goal":"lemma SetInterComm_14022(A: set, U: set)\n ensures A * U == U * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_14023","instance":14023,"id":217366,"goal":"lemma SetUnionAssoc_14023(U: set, A: set, B: set)\n ensures (U + A) + B == U + (A + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_14024","instance":14024,"id":217367,"goal":"lemma SetSubsetRefl_14024(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_14025","instance":14025,"id":217368,"goal":"lemma SetSubsetTrans_14025(B: set, U: set, S: set)\n requires B <= U && U <= S\n ensures B <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_14026","instance":14026,"id":217369,"goal":"lemma SetUnionEmpty_14026(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_14027","instance":14027,"id":217370,"goal":"lemma SetInterEmpty_14027(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_14028","instance":14028,"id":217371,"goal":"lemma SetInterSubset_14028(A: set, B: set)\n ensures A * B <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_14029","instance":14029,"id":217372,"goal":"lemma SetCardSubset_14029(B: set, A: set)\n requires B <= A\n ensures |B| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_14030","instance":14030,"id":217373,"goal":"lemma SetUnionCard_14030(B: set, U: set)\n requires B * U == {}\n ensures |B + U| == |B| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_14031","instance":14031,"id":217374,"goal":"lemma SetUnionComm_14031(S: set, U: set)\n ensures S + U == U + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_14032","instance":14032,"id":217375,"goal":"lemma SetInterComm_14032(T: set, S: set)\n ensures T * S == S * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_14033","instance":14033,"id":217376,"goal":"lemma SetUnionAssoc_14033(A: set, S: set, T: set)\n ensures (A + S) + T == A + (S + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_14034","instance":14034,"id":217377,"goal":"lemma SetSubsetRefl_14034(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_14035","instance":14035,"id":217378,"goal":"lemma SetSubsetTrans_14035(A: set, T: set, U: set)\n requires A <= T && T <= U\n ensures A <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_14036","instance":14036,"id":217379,"goal":"lemma SetUnionEmpty_14036(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_14037","instance":14037,"id":217380,"goal":"lemma SetInterEmpty_14037(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_14038","instance":14038,"id":217381,"goal":"lemma SetInterSubset_14038(S: set, T: set)\n ensures S * T <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_14039","instance":14039,"id":217382,"goal":"lemma SetCardSubset_14039(S: set, A: set)\n requires S <= A\n ensures |S| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_14040","instance":14040,"id":217383,"goal":"lemma SetUnionCard_14040(A: set, T: set)\n requires A * T == {}\n ensures |A + T| == |A| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_14041","instance":14041,"id":217384,"goal":"lemma SetUnionComm_14041(A: set, U: set)\n ensures A + U == U + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_14042","instance":14042,"id":217385,"goal":"lemma SetInterComm_14042(A: set, S: set)\n ensures A * S == S * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_14043","instance":14043,"id":217386,"goal":"lemma SetUnionAssoc_14043(U: set, S: set, T: set)\n ensures (U + S) + T == U + (S + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_14044","instance":14044,"id":217387,"goal":"lemma SetSubsetRefl_14044(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_14045","instance":14045,"id":217388,"goal":"lemma SetSubsetTrans_14045(B: set, T: set, S: set)\n requires B <= T && T <= S\n ensures B <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_14046","instance":14046,"id":217389,"goal":"lemma SetUnionEmpty_14046(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_14047","instance":14047,"id":217390,"goal":"lemma SetInterEmpty_14047(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_14048","instance":14048,"id":217391,"goal":"lemma SetInterSubset_14048(A: set, S: set)\n ensures A * S <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_14049","instance":14049,"id":217392,"goal":"lemma SetCardSubset_14049(B: set, T: set)\n requires B <= T\n ensures |B| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_14050","instance":14050,"id":217393,"goal":"lemma SetUnionCard_14050(S: set, B: set)\n requires S * B == {}\n ensures |S + B| == |S| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_14051","instance":14051,"id":217394,"goal":"lemma SetUnionComm_14051(S: set, B: set)\n ensures S + B == B + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_14052","instance":14052,"id":217395,"goal":"lemma SetInterComm_14052(B: set, A: set)\n ensures B * A == A * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_14053","instance":14053,"id":217396,"goal":"lemma SetUnionAssoc_14053(A: set, S: set, B: set)\n ensures (A + S) + B == A + (S + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_14054","instance":14054,"id":217397,"goal":"lemma SetSubsetRefl_14054(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_14055","instance":14055,"id":217398,"goal":"lemma SetSubsetTrans_14055(B: set, A: set, T: set)\n requires B <= A && A <= T\n ensures B <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_14056","instance":14056,"id":217399,"goal":"lemma SetUnionEmpty_14056(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_14057","instance":14057,"id":217400,"goal":"lemma SetInterEmpty_14057(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_14058","instance":14058,"id":217401,"goal":"lemma SetInterSubset_14058(S: set, A: set)\n ensures S * A <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_14059","instance":14059,"id":217402,"goal":"lemma SetCardSubset_14059(A: set, S: set)\n requires A <= S\n ensures |A| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_14060","instance":14060,"id":217403,"goal":"lemma SetUnionCard_14060(A: set, B: set)\n requires A * B == {}\n ensures |A + B| == |A| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_14061","instance":14061,"id":217404,"goal":"lemma SetUnionComm_14061(T: set, A: set)\n ensures T + A == A + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_14062","instance":14062,"id":217405,"goal":"lemma SetInterComm_14062(U: set, S: set)\n ensures U * S == S * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_14063","instance":14063,"id":217406,"goal":"lemma SetUnionAssoc_14063(A: set, U: set, S: set)\n ensures (A + U) + S == A + (U + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_14064","instance":14064,"id":217407,"goal":"lemma SetSubsetRefl_14064(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_14065","instance":14065,"id":217408,"goal":"lemma SetSubsetTrans_14065(A: set, U: set, S: set)\n requires A <= U && U <= S\n ensures A <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_14066","instance":14066,"id":217409,"goal":"lemma SetUnionEmpty_14066(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_14067","instance":14067,"id":217410,"goal":"lemma SetInterEmpty_14067(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_14068","instance":14068,"id":217411,"goal":"lemma SetInterSubset_14068(A: set, U: set)\n ensures A * U <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_14069","instance":14069,"id":217412,"goal":"lemma SetCardSubset_14069(T: set, U: set)\n requires T <= U\n ensures |T| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_14070","instance":14070,"id":217413,"goal":"lemma SetUnionCard_14070(S: set, T: set)\n requires S * T == {}\n ensures |S + T| == |S| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_14071","instance":14071,"id":217414,"goal":"lemma SetUnionComm_14071(S: set, U: set)\n ensures S + U == U + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_14072","instance":14072,"id":217415,"goal":"lemma SetInterComm_14072(U: set, A: set)\n ensures U * A == A * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_14073","instance":14073,"id":217416,"goal":"lemma SetUnionAssoc_14073(S: set, B: set, A: set)\n ensures (S + B) + A == S + (B + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_14074","instance":14074,"id":217417,"goal":"lemma SetSubsetRefl_14074(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_14075","instance":14075,"id":217418,"goal":"lemma SetSubsetTrans_14075(A: set, B: set, U: set)\n requires A <= B && B <= U\n ensures A <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_14076","instance":14076,"id":217419,"goal":"lemma SetUnionEmpty_14076(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_14077","instance":14077,"id":217420,"goal":"lemma SetInterEmpty_14077(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_14078","instance":14078,"id":217421,"goal":"lemma SetInterSubset_14078(B: set, T: set)\n ensures B * T <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_14079","instance":14079,"id":217422,"goal":"lemma SetCardSubset_14079(U: set, A: set)\n requires U <= A\n ensures |U| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_14080","instance":14080,"id":217423,"goal":"lemma SetUnionCard_14080(S: set, B: set)\n requires S * B == {}\n ensures |S + B| == |S| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_14081","instance":14081,"id":217424,"goal":"lemma SetUnionComm_14081(U: set, B: set)\n ensures U + B == B + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_14082","instance":14082,"id":217425,"goal":"lemma SetInterComm_14082(S: set, A: set)\n ensures S * A == A * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_14083","instance":14083,"id":217426,"goal":"lemma SetUnionAssoc_14083(A: set, S: set, U: set)\n ensures (A + S) + U == A + (S + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_14084","instance":14084,"id":217427,"goal":"lemma SetSubsetRefl_14084(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_14085","instance":14085,"id":217428,"goal":"lemma SetSubsetTrans_14085(T: set, A: set, B: set)\n requires T <= A && A <= B\n ensures T <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_14086","instance":14086,"id":217429,"goal":"lemma SetUnionEmpty_14086(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_14087","instance":14087,"id":217430,"goal":"lemma SetInterEmpty_14087(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_14088","instance":14088,"id":217431,"goal":"lemma SetInterSubset_14088(S: set, B: set)\n ensures S * B <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_14089","instance":14089,"id":217432,"goal":"lemma SetCardSubset_14089(B: set, A: set)\n requires B <= A\n ensures |B| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_14090","instance":14090,"id":217433,"goal":"lemma SetUnionCard_14090(T: set, B: set)\n requires T * B == {}\n ensures |T + B| == |T| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_14091","instance":14091,"id":217434,"goal":"lemma SetUnionComm_14091(T: set, A: set)\n ensures T + A == A + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_14092","instance":14092,"id":217435,"goal":"lemma SetInterComm_14092(T: set, U: set)\n ensures T * U == U * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_14093","instance":14093,"id":217436,"goal":"lemma SetUnionAssoc_14093(A: set, S: set, U: set)\n ensures (A + S) + U == A + (S + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_14094","instance":14094,"id":217437,"goal":"lemma SetSubsetRefl_14094(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_14095","instance":14095,"id":217438,"goal":"lemma SetSubsetTrans_14095(A: set, T: set, B: set)\n requires A <= T && T <= B\n ensures A <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_14096","instance":14096,"id":217439,"goal":"lemma SetUnionEmpty_14096(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_14097","instance":14097,"id":217440,"goal":"lemma SetInterEmpty_14097(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_14098","instance":14098,"id":217441,"goal":"lemma SetInterSubset_14098(U: set, A: set)\n ensures U * A <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_14099","instance":14099,"id":217442,"goal":"lemma SetCardSubset_14099(U: set, A: set)\n requires U <= A\n ensures |U| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_14100","instance":14100,"id":217443,"goal":"lemma SetUnionCard_14100(T: set, A: set)\n requires T * A == {}\n ensures |T + A| == |T| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_14101","instance":14101,"id":217444,"goal":"lemma SetUnionComm_14101(T: set, U: set)\n ensures T + U == U + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_14102","instance":14102,"id":217445,"goal":"lemma SetInterComm_14102(A: set, B: set)\n ensures A * B == B * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_14103","instance":14103,"id":217446,"goal":"lemma SetUnionAssoc_14103(A: set, S: set, B: set)\n ensures (A + S) + B == A + (S + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_14104","instance":14104,"id":217447,"goal":"lemma SetSubsetRefl_14104(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_14105","instance":14105,"id":217448,"goal":"lemma SetSubsetTrans_14105(B: set, S: set, A: set)\n requires B <= S && S <= A\n ensures B <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_14106","instance":14106,"id":217449,"goal":"lemma SetUnionEmpty_14106(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_14107","instance":14107,"id":217450,"goal":"lemma SetInterEmpty_14107(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_14108","instance":14108,"id":217451,"goal":"lemma SetInterSubset_14108(U: set, S: set)\n ensures U * S <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_14109","instance":14109,"id":217452,"goal":"lemma SetCardSubset_14109(U: set, B: set)\n requires U <= B\n ensures |U| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_14110","instance":14110,"id":217453,"goal":"lemma SetUnionCard_14110(U: set, A: set)\n requires U * A == {}\n ensures |U + A| == |U| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_14111","instance":14111,"id":217454,"goal":"lemma SetUnionComm_14111(B: set, T: set)\n ensures B + T == T + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_14112","instance":14112,"id":217455,"goal":"lemma SetInterComm_14112(T: set, A: set)\n ensures T * A == A * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_14113","instance":14113,"id":217456,"goal":"lemma SetUnionAssoc_14113(U: set, A: set, T: set)\n ensures (U + A) + T == U + (A + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_14114","instance":14114,"id":217457,"goal":"lemma SetSubsetRefl_14114(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_14115","instance":14115,"id":217458,"goal":"lemma SetSubsetTrans_14115(S: set, U: set, T: set)\n requires S <= U && U <= T\n ensures S <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_14116","instance":14116,"id":217459,"goal":"lemma SetUnionEmpty_14116(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_14117","instance":14117,"id":217460,"goal":"lemma SetInterEmpty_14117(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_14118","instance":14118,"id":217461,"goal":"lemma SetInterSubset_14118(B: set, S: set)\n ensures B * S <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_14119","instance":14119,"id":217462,"goal":"lemma SetCardSubset_14119(U: set, A: set)\n requires U <= A\n ensures |U| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_14120","instance":14120,"id":217463,"goal":"lemma SetUnionCard_14120(A: set, U: set)\n requires A * U == {}\n ensures |A + U| == |A| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_14121","instance":14121,"id":217464,"goal":"lemma SetUnionComm_14121(S: set, U: set)\n ensures S + U == U + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_14122","instance":14122,"id":217465,"goal":"lemma SetInterComm_14122(U: set, T: set)\n ensures U * T == T * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_14123","instance":14123,"id":217466,"goal":"lemma SetUnionAssoc_14123(T: set, U: set, B: set)\n ensures (T + U) + B == T + (U + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_14124","instance":14124,"id":217467,"goal":"lemma SetSubsetRefl_14124(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_14125","instance":14125,"id":217468,"goal":"lemma SetSubsetTrans_14125(S: set, B: set, A: set)\n requires S <= B && B <= A\n ensures S <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_14126","instance":14126,"id":217469,"goal":"lemma SetUnionEmpty_14126(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_14127","instance":14127,"id":217470,"goal":"lemma SetInterEmpty_14127(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_14128","instance":14128,"id":217471,"goal":"lemma SetInterSubset_14128(U: set, S: set)\n ensures U * S <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_14129","instance":14129,"id":217472,"goal":"lemma SetCardSubset_14129(A: set, T: set)\n requires A <= T\n ensures |A| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_14130","instance":14130,"id":217473,"goal":"lemma SetUnionCard_14130(B: set, S: set)\n requires B * S == {}\n ensures |B + S| == |B| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_14131","instance":14131,"id":217474,"goal":"lemma SetUnionComm_14131(B: set, U: set)\n ensures B + U == U + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_14132","instance":14132,"id":217475,"goal":"lemma SetInterComm_14132(A: set, S: set)\n ensures A * S == S * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_14133","instance":14133,"id":217476,"goal":"lemma SetUnionAssoc_14133(A: set, B: set, S: set)\n ensures (A + B) + S == A + (B + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_14134","instance":14134,"id":217477,"goal":"lemma SetSubsetRefl_14134(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_14135","instance":14135,"id":217478,"goal":"lemma SetSubsetTrans_14135(T: set, S: set, U: set)\n requires T <= S && S <= U\n ensures T <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_14136","instance":14136,"id":217479,"goal":"lemma SetUnionEmpty_14136(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_14137","instance":14137,"id":217480,"goal":"lemma SetInterEmpty_14137(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_14138","instance":14138,"id":217481,"goal":"lemma SetInterSubset_14138(U: set, A: set)\n ensures U * A <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_14139","instance":14139,"id":217482,"goal":"lemma SetCardSubset_14139(A: set, U: set)\n requires A <= U\n ensures |A| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_14140","instance":14140,"id":217483,"goal":"lemma SetUnionCard_14140(B: set, T: set)\n requires B * T == {}\n ensures |B + T| == |B| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_14141","instance":14141,"id":217484,"goal":"lemma SetUnionComm_14141(T: set, B: set)\n ensures T + B == B + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_14142","instance":14142,"id":217485,"goal":"lemma SetInterComm_14142(S: set, U: set)\n ensures S * U == U * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_14143","instance":14143,"id":217486,"goal":"lemma SetUnionAssoc_14143(T: set, S: set, U: set)\n ensures (T + S) + U == T + (S + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_14144","instance":14144,"id":217487,"goal":"lemma SetSubsetRefl_14144(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_14145","instance":14145,"id":217488,"goal":"lemma SetSubsetTrans_14145(U: set, A: set, S: set)\n requires U <= A && A <= S\n ensures U <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_14146","instance":14146,"id":217489,"goal":"lemma SetUnionEmpty_14146(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_14147","instance":14147,"id":217490,"goal":"lemma SetInterEmpty_14147(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_14148","instance":14148,"id":217491,"goal":"lemma SetInterSubset_14148(A: set, U: set)\n ensures A * U <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_14149","instance":14149,"id":217492,"goal":"lemma SetCardSubset_14149(U: set, B: set)\n requires U <= B\n ensures |U| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_14150","instance":14150,"id":217493,"goal":"lemma SetUnionCard_14150(A: set, T: set)\n requires A * T == {}\n ensures |A + T| == |A| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_14151","instance":14151,"id":217494,"goal":"lemma SetUnionComm_14151(A: set, U: set)\n ensures A + U == U + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_14152","instance":14152,"id":217495,"goal":"lemma SetInterComm_14152(B: set, S: set)\n ensures B * S == S * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_14153","instance":14153,"id":217496,"goal":"lemma SetUnionAssoc_14153(A: set, U: set, S: set)\n ensures (A + U) + S == A + (U + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_14154","instance":14154,"id":217497,"goal":"lemma SetSubsetRefl_14154(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_14155","instance":14155,"id":217498,"goal":"lemma SetSubsetTrans_14155(U: set, A: set, S: set)\n requires U <= A && A <= S\n ensures U <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_14156","instance":14156,"id":217499,"goal":"lemma SetUnionEmpty_14156(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_14157","instance":14157,"id":217500,"goal":"lemma SetInterEmpty_14157(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_14158","instance":14158,"id":217501,"goal":"lemma SetInterSubset_14158(A: set, B: set)\n ensures A * B <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_14159","instance":14159,"id":217502,"goal":"lemma SetCardSubset_14159(A: set, S: set)\n requires A <= S\n ensures |A| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_14160","instance":14160,"id":217503,"goal":"lemma SetUnionCard_14160(T: set, B: set)\n requires T * B == {}\n ensures |T + B| == |T| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_14161","instance":14161,"id":217504,"goal":"lemma SetUnionComm_14161(S: set, A: set)\n ensures S + A == A + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_14162","instance":14162,"id":217505,"goal":"lemma SetInterComm_14162(T: set, B: set)\n ensures T * B == B * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_14163","instance":14163,"id":217506,"goal":"lemma SetUnionAssoc_14163(A: set, U: set, S: set)\n ensures (A + U) + S == A + (U + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_14164","instance":14164,"id":217507,"goal":"lemma SetSubsetRefl_14164(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_14165","instance":14165,"id":217508,"goal":"lemma SetSubsetTrans_14165(U: set, B: set, A: set)\n requires U <= B && B <= A\n ensures U <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_14166","instance":14166,"id":217509,"goal":"lemma SetUnionEmpty_14166(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_14167","instance":14167,"id":217510,"goal":"lemma SetInterEmpty_14167(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_14168","instance":14168,"id":217511,"goal":"lemma SetInterSubset_14168(B: set, U: set)\n ensures B * U <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_14169","instance":14169,"id":217512,"goal":"lemma SetCardSubset_14169(A: set, S: set)\n requires A <= S\n ensures |A| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_14170","instance":14170,"id":217513,"goal":"lemma SetUnionCard_14170(U: set, A: set)\n requires U * A == {}\n ensures |U + A| == |U| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_14171","instance":14171,"id":217514,"goal":"lemma SetUnionComm_14171(U: set, A: set)\n ensures U + A == A + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_14172","instance":14172,"id":217515,"goal":"lemma SetInterComm_14172(T: set, A: set)\n ensures T * A == A * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_14173","instance":14173,"id":217516,"goal":"lemma SetUnionAssoc_14173(T: set, S: set, A: set)\n ensures (T + S) + A == T + (S + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_14174","instance":14174,"id":217517,"goal":"lemma SetSubsetRefl_14174(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_14175","instance":14175,"id":217518,"goal":"lemma SetSubsetTrans_14175(T: set, U: set, B: set)\n requires T <= U && U <= B\n ensures T <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_14176","instance":14176,"id":217519,"goal":"lemma SetUnionEmpty_14176(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_14177","instance":14177,"id":217520,"goal":"lemma SetInterEmpty_14177(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_14178","instance":14178,"id":217521,"goal":"lemma SetInterSubset_14178(U: set, S: set)\n ensures U * S <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_14179","instance":14179,"id":217522,"goal":"lemma SetCardSubset_14179(T: set, S: set)\n requires T <= S\n ensures |T| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_14180","instance":14180,"id":217523,"goal":"lemma SetUnionCard_14180(S: set, U: set)\n requires S * U == {}\n ensures |S + U| == |S| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_14181","instance":14181,"id":217524,"goal":"lemma SetUnionComm_14181(A: set, T: set)\n ensures A + T == T + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_14182","instance":14182,"id":217525,"goal":"lemma SetInterComm_14182(T: set, B: set)\n ensures T * B == B * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_14183","instance":14183,"id":217526,"goal":"lemma SetUnionAssoc_14183(B: set, S: set, A: set)\n ensures (B + S) + A == B + (S + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_14184","instance":14184,"id":217527,"goal":"lemma SetSubsetRefl_14184(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_14185","instance":14185,"id":217528,"goal":"lemma SetSubsetTrans_14185(T: set, B: set, U: set)\n requires T <= B && B <= U\n ensures T <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_14186","instance":14186,"id":217529,"goal":"lemma SetUnionEmpty_14186(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_14187","instance":14187,"id":217530,"goal":"lemma SetInterEmpty_14187(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_14188","instance":14188,"id":217531,"goal":"lemma SetInterSubset_14188(T: set, U: set)\n ensures T * U <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_14189","instance":14189,"id":217532,"goal":"lemma SetCardSubset_14189(B: set, U: set)\n requires B <= U\n ensures |B| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_14190","instance":14190,"id":217533,"goal":"lemma SetUnionCard_14190(A: set, T: set)\n requires A * T == {}\n ensures |A + T| == |A| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_14191","instance":14191,"id":217534,"goal":"lemma SetUnionComm_14191(A: set, S: set)\n ensures A + S == S + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_14192","instance":14192,"id":217535,"goal":"lemma SetInterComm_14192(S: set, U: set)\n ensures S * U == U * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_14193","instance":14193,"id":217536,"goal":"lemma SetUnionAssoc_14193(A: set, S: set, T: set)\n ensures (A + S) + T == A + (S + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_14194","instance":14194,"id":217537,"goal":"lemma SetSubsetRefl_14194(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_14195","instance":14195,"id":217538,"goal":"lemma SetSubsetTrans_14195(B: set, T: set, U: set)\n requires B <= T && T <= U\n ensures B <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_14196","instance":14196,"id":217539,"goal":"lemma SetUnionEmpty_14196(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_14197","instance":14197,"id":217540,"goal":"lemma SetInterEmpty_14197(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_14198","instance":14198,"id":217541,"goal":"lemma SetInterSubset_14198(B: set, S: set)\n ensures B * S <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_14199","instance":14199,"id":217542,"goal":"lemma SetCardSubset_14199(T: set, S: set)\n requires T <= S\n ensures |T| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_14200","instance":14200,"id":217543,"goal":"lemma SetUnionCard_14200(S: set, B: set)\n requires S * B == {}\n ensures |S + B| == |S| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_14201","instance":14201,"id":217544,"goal":"lemma SetUnionComm_14201(A: set, B: set)\n ensures A + B == B + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_14202","instance":14202,"id":217545,"goal":"lemma SetInterComm_14202(S: set, U: set)\n ensures S * U == U * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_14203","instance":14203,"id":217546,"goal":"lemma SetUnionAssoc_14203(B: set, T: set, U: set)\n ensures (B + T) + U == B + (T + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_14204","instance":14204,"id":217547,"goal":"lemma SetSubsetRefl_14204(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_14205","instance":14205,"id":217548,"goal":"lemma SetSubsetTrans_14205(S: set, T: set, U: set)\n requires S <= T && T <= U\n ensures S <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_14206","instance":14206,"id":217549,"goal":"lemma SetUnionEmpty_14206(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_14207","instance":14207,"id":217550,"goal":"lemma SetInterEmpty_14207(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_14208","instance":14208,"id":217551,"goal":"lemma SetInterSubset_14208(U: set, A: set)\n ensures U * A <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_14209","instance":14209,"id":217552,"goal":"lemma SetCardSubset_14209(T: set, U: set)\n requires T <= U\n ensures |T| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_14210","instance":14210,"id":217553,"goal":"lemma SetUnionCard_14210(B: set, T: set)\n requires B * T == {}\n ensures |B + T| == |B| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_14211","instance":14211,"id":217554,"goal":"lemma SetUnionComm_14211(A: set, S: set)\n ensures A + S == S + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_14212","instance":14212,"id":217555,"goal":"lemma SetInterComm_14212(B: set, A: set)\n ensures B * A == A * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_14213","instance":14213,"id":217556,"goal":"lemma SetUnionAssoc_14213(B: set, U: set, A: set)\n ensures (B + U) + A == B + (U + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_14214","instance":14214,"id":217557,"goal":"lemma SetSubsetRefl_14214(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_14215","instance":14215,"id":217558,"goal":"lemma SetSubsetTrans_14215(A: set, B: set, S: set)\n requires A <= B && B <= S\n ensures A <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_14216","instance":14216,"id":217559,"goal":"lemma SetUnionEmpty_14216(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_14217","instance":14217,"id":217560,"goal":"lemma SetInterEmpty_14217(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_14218","instance":14218,"id":217561,"goal":"lemma SetInterSubset_14218(T: set, U: set)\n ensures T * U <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_14219","instance":14219,"id":217562,"goal":"lemma SetCardSubset_14219(B: set, T: set)\n requires B <= T\n ensures |B| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_14220","instance":14220,"id":217563,"goal":"lemma SetUnionCard_14220(T: set, U: set)\n requires T * U == {}\n ensures |T + U| == |T| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_14221","instance":14221,"id":217564,"goal":"lemma SetUnionComm_14221(U: set, A: set)\n ensures U + A == A + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_14222","instance":14222,"id":217565,"goal":"lemma SetInterComm_14222(S: set, U: set)\n ensures S * U == U * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_14223","instance":14223,"id":217566,"goal":"lemma SetUnionAssoc_14223(A: set, S: set, T: set)\n ensures (A + S) + T == A + (S + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_14224","instance":14224,"id":217567,"goal":"lemma SetSubsetRefl_14224(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_14225","instance":14225,"id":217568,"goal":"lemma SetSubsetTrans_14225(T: set, B: set, S: set)\n requires T <= B && B <= S\n ensures T <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_14226","instance":14226,"id":217569,"goal":"lemma SetUnionEmpty_14226(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_14227","instance":14227,"id":217570,"goal":"lemma SetInterEmpty_14227(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_14228","instance":14228,"id":217571,"goal":"lemma SetInterSubset_14228(A: set, T: set)\n ensures A * T <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_14229","instance":14229,"id":217572,"goal":"lemma SetCardSubset_14229(B: set, A: set)\n requires B <= A\n ensures |B| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_14230","instance":14230,"id":217573,"goal":"lemma SetUnionCard_14230(A: set, U: set)\n requires A * U == {}\n ensures |A + U| == |A| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_14231","instance":14231,"id":217574,"goal":"lemma SetUnionComm_14231(U: set, B: set)\n ensures U + B == B + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_14232","instance":14232,"id":217575,"goal":"lemma SetInterComm_14232(T: set, U: set)\n ensures T * U == U * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_14233","instance":14233,"id":217576,"goal":"lemma SetUnionAssoc_14233(S: set, B: set, T: set)\n ensures (S + B) + T == S + (B + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_14234","instance":14234,"id":217577,"goal":"lemma SetSubsetRefl_14234(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_14235","instance":14235,"id":217578,"goal":"lemma SetSubsetTrans_14235(S: set, B: set, T: set)\n requires S <= B && B <= T\n ensures S <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_14236","instance":14236,"id":217579,"goal":"lemma SetUnionEmpty_14236(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_14237","instance":14237,"id":217580,"goal":"lemma SetInterEmpty_14237(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_14238","instance":14238,"id":217581,"goal":"lemma SetInterSubset_14238(S: set, B: set)\n ensures S * B <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_14239","instance":14239,"id":217582,"goal":"lemma SetCardSubset_14239(B: set, U: set)\n requires B <= U\n ensures |B| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_14240","instance":14240,"id":217583,"goal":"lemma SetUnionCard_14240(B: set, A: set)\n requires B * A == {}\n ensures |B + A| == |B| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_14241","instance":14241,"id":217584,"goal":"lemma SetUnionComm_14241(S: set, A: set)\n ensures S + A == A + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_14242","instance":14242,"id":217585,"goal":"lemma SetInterComm_14242(A: set, U: set)\n ensures A * U == U * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_14243","instance":14243,"id":217586,"goal":"lemma SetUnionAssoc_14243(S: set, B: set, A: set)\n ensures (S + B) + A == S + (B + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_14244","instance":14244,"id":217587,"goal":"lemma SetSubsetRefl_14244(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_14245","instance":14245,"id":217588,"goal":"lemma SetSubsetTrans_14245(U: set, T: set, A: set)\n requires U <= T && T <= A\n ensures U <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_14246","instance":14246,"id":217589,"goal":"lemma SetUnionEmpty_14246(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_14247","instance":14247,"id":217590,"goal":"lemma SetInterEmpty_14247(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_14248","instance":14248,"id":217591,"goal":"lemma SetInterSubset_14248(S: set, U: set)\n ensures S * U <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_14249","instance":14249,"id":217592,"goal":"lemma SetCardSubset_14249(T: set, S: set)\n requires T <= S\n ensures |T| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_14250","instance":14250,"id":217593,"goal":"lemma SetUnionCard_14250(U: set, T: set)\n requires U * T == {}\n ensures |U + T| == |U| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_14251","instance":14251,"id":217594,"goal":"lemma SetUnionComm_14251(A: set, S: set)\n ensures A + S == S + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_14252","instance":14252,"id":217595,"goal":"lemma SetInterComm_14252(U: set, S: set)\n ensures U * S == S * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_14253","instance":14253,"id":217596,"goal":"lemma SetUnionAssoc_14253(U: set, T: set, S: set)\n ensures (U + T) + S == U + (T + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_14254","instance":14254,"id":217597,"goal":"lemma SetSubsetRefl_14254(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_14255","instance":14255,"id":217598,"goal":"lemma SetSubsetTrans_14255(B: set, S: set, T: set)\n requires B <= S && S <= T\n ensures B <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_14256","instance":14256,"id":217599,"goal":"lemma SetUnionEmpty_14256(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_14257","instance":14257,"id":217600,"goal":"lemma SetInterEmpty_14257(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_14258","instance":14258,"id":217601,"goal":"lemma SetInterSubset_14258(S: set, A: set)\n ensures S * A <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_14259","instance":14259,"id":217602,"goal":"lemma SetCardSubset_14259(A: set, T: set)\n requires A <= T\n ensures |A| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_14260","instance":14260,"id":217603,"goal":"lemma SetUnionCard_14260(T: set, B: set)\n requires T * B == {}\n ensures |T + B| == |T| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_14261","instance":14261,"id":217604,"goal":"lemma SetUnionComm_14261(U: set, T: set)\n ensures U + T == T + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_14262","instance":14262,"id":217605,"goal":"lemma SetInterComm_14262(T: set, A: set)\n ensures T * A == A * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_14263","instance":14263,"id":217606,"goal":"lemma SetUnionAssoc_14263(A: set, B: set, U: set)\n ensures (A + B) + U == A + (B + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_14264","instance":14264,"id":217607,"goal":"lemma SetSubsetRefl_14264(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_14265","instance":14265,"id":217608,"goal":"lemma SetSubsetTrans_14265(T: set, A: set, B: set)\n requires T <= A && A <= B\n ensures T <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_14266","instance":14266,"id":217609,"goal":"lemma SetUnionEmpty_14266(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_14267","instance":14267,"id":217610,"goal":"lemma SetInterEmpty_14267(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_14268","instance":14268,"id":217611,"goal":"lemma SetInterSubset_14268(B: set, U: set)\n ensures B * U <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_14269","instance":14269,"id":217612,"goal":"lemma SetCardSubset_14269(B: set, U: set)\n requires B <= U\n ensures |B| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_14270","instance":14270,"id":217613,"goal":"lemma SetUnionCard_14270(A: set, B: set)\n requires A * B == {}\n ensures |A + B| == |A| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_14271","instance":14271,"id":217614,"goal":"lemma SetUnionComm_14271(U: set, S: set)\n ensures U + S == S + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_14272","instance":14272,"id":217615,"goal":"lemma SetInterComm_14272(T: set, B: set)\n ensures T * B == B * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_14273","instance":14273,"id":217616,"goal":"lemma SetUnionAssoc_14273(B: set, A: set, U: set)\n ensures (B + A) + U == B + (A + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_14274","instance":14274,"id":217617,"goal":"lemma SetSubsetRefl_14274(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_14275","instance":14275,"id":217618,"goal":"lemma SetSubsetTrans_14275(U: set, S: set, A: set)\n requires U <= S && S <= A\n ensures U <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_14276","instance":14276,"id":217619,"goal":"lemma SetUnionEmpty_14276(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_14277","instance":14277,"id":217620,"goal":"lemma SetInterEmpty_14277(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_14278","instance":14278,"id":217621,"goal":"lemma SetInterSubset_14278(A: set, S: set)\n ensures A * S <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_14279","instance":14279,"id":217622,"goal":"lemma SetCardSubset_14279(U: set, T: set)\n requires U <= T\n ensures |U| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_14280","instance":14280,"id":217623,"goal":"lemma SetUnionCard_14280(T: set, A: set)\n requires T * A == {}\n ensures |T + A| == |T| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_14281","instance":14281,"id":217624,"goal":"lemma SetUnionComm_14281(A: set, S: set)\n ensures A + S == S + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_14282","instance":14282,"id":217625,"goal":"lemma SetInterComm_14282(B: set, U: set)\n ensures B * U == U * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_14283","instance":14283,"id":217626,"goal":"lemma SetUnionAssoc_14283(A: set, T: set, U: set)\n ensures (A + T) + U == A + (T + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_14284","instance":14284,"id":217627,"goal":"lemma SetSubsetRefl_14284(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_14285","instance":14285,"id":217628,"goal":"lemma SetSubsetTrans_14285(A: set, U: set, B: set)\n requires A <= U && U <= B\n ensures A <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_14286","instance":14286,"id":217629,"goal":"lemma SetUnionEmpty_14286(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_14287","instance":14287,"id":217630,"goal":"lemma SetInterEmpty_14287(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_14288","instance":14288,"id":217631,"goal":"lemma SetInterSubset_14288(S: set, A: set)\n ensures S * A <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_14289","instance":14289,"id":217632,"goal":"lemma SetCardSubset_14289(U: set, T: set)\n requires U <= T\n ensures |U| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_14290","instance":14290,"id":217633,"goal":"lemma SetUnionCard_14290(T: set, S: set)\n requires T * S == {}\n ensures |T + S| == |T| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_14291","instance":14291,"id":217634,"goal":"lemma SetUnionComm_14291(T: set, B: set)\n ensures T + B == B + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_14292","instance":14292,"id":217635,"goal":"lemma SetInterComm_14292(A: set, T: set)\n ensures A * T == T * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_14293","instance":14293,"id":217636,"goal":"lemma SetUnionAssoc_14293(A: set, S: set, T: set)\n ensures (A + S) + T == A + (S + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_14294","instance":14294,"id":217637,"goal":"lemma SetSubsetRefl_14294(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_14295","instance":14295,"id":217638,"goal":"lemma SetSubsetTrans_14295(S: set, T: set, A: set)\n requires S <= T && T <= A\n ensures S <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_14296","instance":14296,"id":217639,"goal":"lemma SetUnionEmpty_14296(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_14297","instance":14297,"id":217640,"goal":"lemma SetInterEmpty_14297(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_14298","instance":14298,"id":217641,"goal":"lemma SetInterSubset_14298(T: set, A: set)\n ensures T * A <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_14299","instance":14299,"id":217642,"goal":"lemma SetCardSubset_14299(S: set, A: set)\n requires S <= A\n ensures |S| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_14300","instance":14300,"id":217643,"goal":"lemma SetUnionCard_14300(S: set, A: set)\n requires S * A == {}\n ensures |S + A| == |S| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_14301","instance":14301,"id":217644,"goal":"lemma SetUnionComm_14301(T: set, S: set)\n ensures T + S == S + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_14302","instance":14302,"id":217645,"goal":"lemma SetInterComm_14302(A: set, B: set)\n ensures A * B == B * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_14303","instance":14303,"id":217646,"goal":"lemma SetUnionAssoc_14303(B: set, U: set, A: set)\n ensures (B + U) + A == B + (U + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_14304","instance":14304,"id":217647,"goal":"lemma SetSubsetRefl_14304(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_14305","instance":14305,"id":217648,"goal":"lemma SetSubsetTrans_14305(S: set, T: set, B: set)\n requires S <= T && T <= B\n ensures S <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_14306","instance":14306,"id":217649,"goal":"lemma SetUnionEmpty_14306(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_14307","instance":14307,"id":217650,"goal":"lemma SetInterEmpty_14307(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_14308","instance":14308,"id":217651,"goal":"lemma SetInterSubset_14308(B: set, T: set)\n ensures B * T <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_14309","instance":14309,"id":217652,"goal":"lemma SetCardSubset_14309(T: set, B: set)\n requires T <= B\n ensures |T| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_14310","instance":14310,"id":217653,"goal":"lemma SetUnionCard_14310(B: set, T: set)\n requires B * T == {}\n ensures |B + T| == |B| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_14311","instance":14311,"id":217654,"goal":"lemma SetUnionComm_14311(S: set, T: set)\n ensures S + T == T + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_14312","instance":14312,"id":217655,"goal":"lemma SetInterComm_14312(B: set, U: set)\n ensures B * U == U * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_14313","instance":14313,"id":217656,"goal":"lemma SetUnionAssoc_14313(T: set, B: set, S: set)\n ensures (T + B) + S == T + (B + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_14314","instance":14314,"id":217657,"goal":"lemma SetSubsetRefl_14314(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_14315","instance":14315,"id":217658,"goal":"lemma SetSubsetTrans_14315(A: set, T: set, B: set)\n requires A <= T && T <= B\n ensures A <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_14316","instance":14316,"id":217659,"goal":"lemma SetUnionEmpty_14316(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_14317","instance":14317,"id":217660,"goal":"lemma SetInterEmpty_14317(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_14318","instance":14318,"id":217661,"goal":"lemma SetInterSubset_14318(S: set, A: set)\n ensures S * A <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_14319","instance":14319,"id":217662,"goal":"lemma SetCardSubset_14319(A: set, S: set)\n requires A <= S\n ensures |A| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_14320","instance":14320,"id":217663,"goal":"lemma SetUnionCard_14320(U: set, B: set)\n requires U * B == {}\n ensures |U + B| == |U| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_14321","instance":14321,"id":217664,"goal":"lemma SetUnionComm_14321(U: set, B: set)\n ensures U + B == B + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_14322","instance":14322,"id":217665,"goal":"lemma SetInterComm_14322(S: set, U: set)\n ensures S * U == U * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_14323","instance":14323,"id":217666,"goal":"lemma SetUnionAssoc_14323(B: set, A: set, U: set)\n ensures (B + A) + U == B + (A + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_14324","instance":14324,"id":217667,"goal":"lemma SetSubsetRefl_14324(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_14325","instance":14325,"id":217668,"goal":"lemma SetSubsetTrans_14325(S: set, T: set, B: set)\n requires S <= T && T <= B\n ensures S <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_14326","instance":14326,"id":217669,"goal":"lemma SetUnionEmpty_14326(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_14327","instance":14327,"id":217670,"goal":"lemma SetInterEmpty_14327(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_14328","instance":14328,"id":217671,"goal":"lemma SetInterSubset_14328(B: set, S: set)\n ensures B * S <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_14329","instance":14329,"id":217672,"goal":"lemma SetCardSubset_14329(T: set, A: set)\n requires T <= A\n ensures |T| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_14330","instance":14330,"id":217673,"goal":"lemma SetUnionCard_14330(U: set, B: set)\n requires U * B == {}\n ensures |U + B| == |U| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_14331","instance":14331,"id":217674,"goal":"lemma SetUnionComm_14331(A: set, T: set)\n ensures A + T == T + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_14332","instance":14332,"id":217675,"goal":"lemma SetInterComm_14332(S: set, T: set)\n ensures S * T == T * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_14333","instance":14333,"id":217676,"goal":"lemma SetUnionAssoc_14333(S: set, T: set, A: set)\n ensures (S + T) + A == S + (T + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_14334","instance":14334,"id":217677,"goal":"lemma SetSubsetRefl_14334(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_14335","instance":14335,"id":217678,"goal":"lemma SetSubsetTrans_14335(U: set, A: set, S: set)\n requires U <= A && A <= S\n ensures U <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_14336","instance":14336,"id":217679,"goal":"lemma SetUnionEmpty_14336(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_14337","instance":14337,"id":217680,"goal":"lemma SetInterEmpty_14337(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_14338","instance":14338,"id":217681,"goal":"lemma SetInterSubset_14338(B: set, U: set)\n ensures B * U <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_14339","instance":14339,"id":217682,"goal":"lemma SetCardSubset_14339(U: set, B: set)\n requires U <= B\n ensures |U| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_14340","instance":14340,"id":217683,"goal":"lemma SetUnionCard_14340(U: set, B: set)\n requires U * B == {}\n ensures |U + B| == |U| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_14341","instance":14341,"id":217684,"goal":"lemma SetUnionComm_14341(B: set, U: set)\n ensures B + U == U + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_14342","instance":14342,"id":217685,"goal":"lemma SetInterComm_14342(U: set, A: set)\n ensures U * A == A * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_14343","instance":14343,"id":217686,"goal":"lemma SetUnionAssoc_14343(S: set, U: set, A: set)\n ensures (S + U) + A == S + (U + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_14344","instance":14344,"id":217687,"goal":"lemma SetSubsetRefl_14344(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_14345","instance":14345,"id":217688,"goal":"lemma SetSubsetTrans_14345(U: set, B: set, T: set)\n requires U <= B && B <= T\n ensures U <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_14346","instance":14346,"id":217689,"goal":"lemma SetUnionEmpty_14346(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_14347","instance":14347,"id":217690,"goal":"lemma SetInterEmpty_14347(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_14348","instance":14348,"id":217691,"goal":"lemma SetInterSubset_14348(B: set, U: set)\n ensures B * U <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_14349","instance":14349,"id":217692,"goal":"lemma SetCardSubset_14349(A: set, U: set)\n requires A <= U\n ensures |A| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_14350","instance":14350,"id":217693,"goal":"lemma SetUnionCard_14350(S: set, B: set)\n requires S * B == {}\n ensures |S + B| == |S| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_14351","instance":14351,"id":217694,"goal":"lemma SetUnionComm_14351(A: set, B: set)\n ensures A + B == B + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_14352","instance":14352,"id":217695,"goal":"lemma SetInterComm_14352(T: set, S: set)\n ensures T * S == S * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_14353","instance":14353,"id":217696,"goal":"lemma SetUnionAssoc_14353(T: set, S: set, U: set)\n ensures (T + S) + U == T + (S + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_14354","instance":14354,"id":217697,"goal":"lemma SetSubsetRefl_14354(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_14355","instance":14355,"id":217698,"goal":"lemma SetSubsetTrans_14355(U: set, S: set, B: set)\n requires U <= S && S <= B\n ensures U <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_14356","instance":14356,"id":217699,"goal":"lemma SetUnionEmpty_14356(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_14357","instance":14357,"id":217700,"goal":"lemma SetInterEmpty_14357(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_14358","instance":14358,"id":217701,"goal":"lemma SetInterSubset_14358(S: set, A: set)\n ensures S * A <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_14359","instance":14359,"id":217702,"goal":"lemma SetCardSubset_14359(S: set, B: set)\n requires S <= B\n ensures |S| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_14360","instance":14360,"id":217703,"goal":"lemma SetUnionCard_14360(A: set, B: set)\n requires A * B == {}\n ensures |A + B| == |A| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_14361","instance":14361,"id":217704,"goal":"lemma SetUnionComm_14361(A: set, B: set)\n ensures A + B == B + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_14362","instance":14362,"id":217705,"goal":"lemma SetInterComm_14362(U: set, T: set)\n ensures U * T == T * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_14363","instance":14363,"id":217706,"goal":"lemma SetUnionAssoc_14363(S: set, A: set, U: set)\n ensures (S + A) + U == S + (A + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_14364","instance":14364,"id":217707,"goal":"lemma SetSubsetRefl_14364(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_14365","instance":14365,"id":217708,"goal":"lemma SetSubsetTrans_14365(A: set, S: set, T: set)\n requires A <= S && S <= T\n ensures A <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_14366","instance":14366,"id":217709,"goal":"lemma SetUnionEmpty_14366(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_14367","instance":14367,"id":217710,"goal":"lemma SetInterEmpty_14367(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_14368","instance":14368,"id":217711,"goal":"lemma SetInterSubset_14368(T: set, S: set)\n ensures T * S <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_14369","instance":14369,"id":217712,"goal":"lemma SetCardSubset_14369(B: set, A: set)\n requires B <= A\n ensures |B| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_14370","instance":14370,"id":217713,"goal":"lemma SetUnionCard_14370(T: set, B: set)\n requires T * B == {}\n ensures |T + B| == |T| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_14371","instance":14371,"id":217714,"goal":"lemma SetUnionComm_14371(S: set, A: set)\n ensures S + A == A + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_14372","instance":14372,"id":217715,"goal":"lemma SetInterComm_14372(U: set, A: set)\n ensures U * A == A * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_14373","instance":14373,"id":217716,"goal":"lemma SetUnionAssoc_14373(U: set, A: set, B: set)\n ensures (U + A) + B == U + (A + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_14374","instance":14374,"id":217717,"goal":"lemma SetSubsetRefl_14374(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_14375","instance":14375,"id":217718,"goal":"lemma SetSubsetTrans_14375(T: set, S: set, B: set)\n requires T <= S && S <= B\n ensures T <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_14376","instance":14376,"id":217719,"goal":"lemma SetUnionEmpty_14376(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_14377","instance":14377,"id":217720,"goal":"lemma SetInterEmpty_14377(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_14378","instance":14378,"id":217721,"goal":"lemma SetInterSubset_14378(U: set, T: set)\n ensures U * T <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_14379","instance":14379,"id":217722,"goal":"lemma SetCardSubset_14379(A: set, S: set)\n requires A <= S\n ensures |A| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_14380","instance":14380,"id":217723,"goal":"lemma SetUnionCard_14380(A: set, T: set)\n requires A * T == {}\n ensures |A + T| == |A| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_14381","instance":14381,"id":217724,"goal":"lemma SetUnionComm_14381(A: set, U: set)\n ensures A + U == U + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_14382","instance":14382,"id":217725,"goal":"lemma SetInterComm_14382(S: set, B: set)\n ensures S * B == B * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_14383","instance":14383,"id":217726,"goal":"lemma SetUnionAssoc_14383(T: set, B: set, S: set)\n ensures (T + B) + S == T + (B + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_14384","instance":14384,"id":217727,"goal":"lemma SetSubsetRefl_14384(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_14385","instance":14385,"id":217728,"goal":"lemma SetSubsetTrans_14385(S: set, A: set, B: set)\n requires S <= A && A <= B\n ensures S <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_14386","instance":14386,"id":217729,"goal":"lemma SetUnionEmpty_14386(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_14387","instance":14387,"id":217730,"goal":"lemma SetInterEmpty_14387(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_14388","instance":14388,"id":217731,"goal":"lemma SetInterSubset_14388(B: set, S: set)\n ensures B * S <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_14389","instance":14389,"id":217732,"goal":"lemma SetCardSubset_14389(S: set, U: set)\n requires S <= U\n ensures |S| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_14390","instance":14390,"id":217733,"goal":"lemma SetUnionCard_14390(T: set, U: set)\n requires T * U == {}\n ensures |T + U| == |T| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_14391","instance":14391,"id":217734,"goal":"lemma SetUnionComm_14391(S: set, U: set)\n ensures S + U == U + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_14392","instance":14392,"id":217735,"goal":"lemma SetInterComm_14392(U: set, T: set)\n ensures U * T == T * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_14393","instance":14393,"id":217736,"goal":"lemma SetUnionAssoc_14393(A: set, T: set, B: set)\n ensures (A + T) + B == A + (T + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_14394","instance":14394,"id":217737,"goal":"lemma SetSubsetRefl_14394(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_14395","instance":14395,"id":217738,"goal":"lemma SetSubsetTrans_14395(T: set, A: set, U: set)\n requires T <= A && A <= U\n ensures T <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_14396","instance":14396,"id":217739,"goal":"lemma SetUnionEmpty_14396(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_14397","instance":14397,"id":217740,"goal":"lemma SetInterEmpty_14397(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_14398","instance":14398,"id":217741,"goal":"lemma SetInterSubset_14398(S: set, B: set)\n ensures S * B <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_14399","instance":14399,"id":217742,"goal":"lemma SetCardSubset_14399(A: set, B: set)\n requires A <= B\n ensures |A| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_14400","instance":14400,"id":217743,"goal":"lemma SetUnionCard_14400(S: set, U: set)\n requires S * U == {}\n ensures |S + U| == |S| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_14401","instance":14401,"id":217744,"goal":"lemma SetUnionComm_14401(A: set, B: set)\n ensures A + B == B + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_14402","instance":14402,"id":217745,"goal":"lemma SetInterComm_14402(B: set, T: set)\n ensures B * T == T * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_14403","instance":14403,"id":217746,"goal":"lemma SetUnionAssoc_14403(B: set, U: set, A: set)\n ensures (B + U) + A == B + (U + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_14404","instance":14404,"id":217747,"goal":"lemma SetSubsetRefl_14404(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_14405","instance":14405,"id":217748,"goal":"lemma SetSubsetTrans_14405(U: set, T: set, A: set)\n requires U <= T && T <= A\n ensures U <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_14406","instance":14406,"id":217749,"goal":"lemma SetUnionEmpty_14406(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_14407","instance":14407,"id":217750,"goal":"lemma SetInterEmpty_14407(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_14408","instance":14408,"id":217751,"goal":"lemma SetInterSubset_14408(B: set, S: set)\n ensures B * S <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_14409","instance":14409,"id":217752,"goal":"lemma SetCardSubset_14409(A: set, U: set)\n requires A <= U\n ensures |A| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_14410","instance":14410,"id":217753,"goal":"lemma SetUnionCard_14410(U: set, A: set)\n requires U * A == {}\n ensures |U + A| == |U| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_14411","instance":14411,"id":217754,"goal":"lemma SetUnionComm_14411(S: set, B: set)\n ensures S + B == B + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_14412","instance":14412,"id":217755,"goal":"lemma SetInterComm_14412(A: set, B: set)\n ensures A * B == B * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_14413","instance":14413,"id":217756,"goal":"lemma SetUnionAssoc_14413(T: set, S: set, U: set)\n ensures (T + S) + U == T + (S + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_14414","instance":14414,"id":217757,"goal":"lemma SetSubsetRefl_14414(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_14415","instance":14415,"id":217758,"goal":"lemma SetSubsetTrans_14415(T: set, U: set, A: set)\n requires T <= U && U <= A\n ensures T <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_14416","instance":14416,"id":217759,"goal":"lemma SetUnionEmpty_14416(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_14417","instance":14417,"id":217760,"goal":"lemma SetInterEmpty_14417(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_14418","instance":14418,"id":217761,"goal":"lemma SetInterSubset_14418(T: set, S: set)\n ensures T * S <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_14419","instance":14419,"id":217762,"goal":"lemma SetCardSubset_14419(B: set, S: set)\n requires B <= S\n ensures |B| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_14420","instance":14420,"id":217763,"goal":"lemma SetUnionCard_14420(B: set, A: set)\n requires B * A == {}\n ensures |B + A| == |B| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_14421","instance":14421,"id":217764,"goal":"lemma SetUnionComm_14421(T: set, S: set)\n ensures T + S == S + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_14422","instance":14422,"id":217765,"goal":"lemma SetInterComm_14422(A: set, T: set)\n ensures A * T == T * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_14423","instance":14423,"id":217766,"goal":"lemma SetUnionAssoc_14423(T: set, S: set, U: set)\n ensures (T + S) + U == T + (S + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_14424","instance":14424,"id":217767,"goal":"lemma SetSubsetRefl_14424(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_14425","instance":14425,"id":217768,"goal":"lemma SetSubsetTrans_14425(U: set, T: set, S: set)\n requires U <= T && T <= S\n ensures U <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_14426","instance":14426,"id":217769,"goal":"lemma SetUnionEmpty_14426(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_14427","instance":14427,"id":217770,"goal":"lemma SetInterEmpty_14427(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_14428","instance":14428,"id":217771,"goal":"lemma SetInterSubset_14428(S: set, A: set)\n ensures S * A <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_14429","instance":14429,"id":217772,"goal":"lemma SetCardSubset_14429(S: set, A: set)\n requires S <= A\n ensures |S| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_14430","instance":14430,"id":217773,"goal":"lemma SetUnionCard_14430(T: set, B: set)\n requires T * B == {}\n ensures |T + B| == |T| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_14431","instance":14431,"id":217774,"goal":"lemma SetUnionComm_14431(T: set, A: set)\n ensures T + A == A + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_14432","instance":14432,"id":217775,"goal":"lemma SetInterComm_14432(A: set, S: set)\n ensures A * S == S * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_14433","instance":14433,"id":217776,"goal":"lemma SetUnionAssoc_14433(B: set, T: set, S: set)\n ensures (B + T) + S == B + (T + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_14434","instance":14434,"id":217777,"goal":"lemma SetSubsetRefl_14434(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_14435","instance":14435,"id":217778,"goal":"lemma SetSubsetTrans_14435(T: set, B: set, A: set)\n requires T <= B && B <= A\n ensures T <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_14436","instance":14436,"id":217779,"goal":"lemma SetUnionEmpty_14436(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_14437","instance":14437,"id":217780,"goal":"lemma SetInterEmpty_14437(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_14438","instance":14438,"id":217781,"goal":"lemma SetInterSubset_14438(T: set, S: set)\n ensures T * S <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_14439","instance":14439,"id":217782,"goal":"lemma SetCardSubset_14439(U: set, T: set)\n requires U <= T\n ensures |U| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_14440","instance":14440,"id":217783,"goal":"lemma SetUnionCard_14440(T: set, A: set)\n requires T * A == {}\n ensures |T + A| == |T| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_14441","instance":14441,"id":217784,"goal":"lemma SetUnionComm_14441(B: set, U: set)\n ensures B + U == U + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_14442","instance":14442,"id":217785,"goal":"lemma SetInterComm_14442(U: set, B: set)\n ensures U * B == B * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_14443","instance":14443,"id":217786,"goal":"lemma SetUnionAssoc_14443(T: set, U: set, B: set)\n ensures (T + U) + B == T + (U + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_14444","instance":14444,"id":217787,"goal":"lemma SetSubsetRefl_14444(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_14445","instance":14445,"id":217788,"goal":"lemma SetSubsetTrans_14445(S: set, T: set, U: set)\n requires S <= T && T <= U\n ensures S <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_14446","instance":14446,"id":217789,"goal":"lemma SetUnionEmpty_14446(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_14447","instance":14447,"id":217790,"goal":"lemma SetInterEmpty_14447(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_14448","instance":14448,"id":217791,"goal":"lemma SetInterSubset_14448(A: set, T: set)\n ensures A * T <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_14449","instance":14449,"id":217792,"goal":"lemma SetCardSubset_14449(T: set, B: set)\n requires T <= B\n ensures |T| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_14450","instance":14450,"id":217793,"goal":"lemma SetUnionCard_14450(T: set, U: set)\n requires T * U == {}\n ensures |T + U| == |T| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_14451","instance":14451,"id":217794,"goal":"lemma SetUnionComm_14451(B: set, S: set)\n ensures B + S == S + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_14452","instance":14452,"id":217795,"goal":"lemma SetInterComm_14452(A: set, T: set)\n ensures A * T == T * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_14453","instance":14453,"id":217796,"goal":"lemma SetUnionAssoc_14453(A: set, T: set, U: set)\n ensures (A + T) + U == A + (T + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_14454","instance":14454,"id":217797,"goal":"lemma SetSubsetRefl_14454(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_14455","instance":14455,"id":217798,"goal":"lemma SetSubsetTrans_14455(T: set, S: set, A: set)\n requires T <= S && S <= A\n ensures T <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_14456","instance":14456,"id":217799,"goal":"lemma SetUnionEmpty_14456(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_14457","instance":14457,"id":217800,"goal":"lemma SetInterEmpty_14457(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_14458","instance":14458,"id":217801,"goal":"lemma SetInterSubset_14458(U: set, S: set)\n ensures U * S <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_14459","instance":14459,"id":217802,"goal":"lemma SetCardSubset_14459(B: set, A: set)\n requires B <= A\n ensures |B| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_14460","instance":14460,"id":217803,"goal":"lemma SetUnionCard_14460(U: set, B: set)\n requires U * B == {}\n ensures |U + B| == |U| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_14461","instance":14461,"id":217804,"goal":"lemma SetUnionComm_14461(T: set, S: set)\n ensures T + S == S + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_14462","instance":14462,"id":217805,"goal":"lemma SetInterComm_14462(A: set, S: set)\n ensures A * S == S * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_14463","instance":14463,"id":217806,"goal":"lemma SetUnionAssoc_14463(U: set, S: set, T: set)\n ensures (U + S) + T == U + (S + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_14464","instance":14464,"id":217807,"goal":"lemma SetSubsetRefl_14464(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_14465","instance":14465,"id":217808,"goal":"lemma SetSubsetTrans_14465(S: set, T: set, U: set)\n requires S <= T && T <= U\n ensures S <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_14466","instance":14466,"id":217809,"goal":"lemma SetUnionEmpty_14466(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_14467","instance":14467,"id":217810,"goal":"lemma SetInterEmpty_14467(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_14468","instance":14468,"id":217811,"goal":"lemma SetInterSubset_14468(U: set, S: set)\n ensures U * S <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_14469","instance":14469,"id":217812,"goal":"lemma SetCardSubset_14469(U: set, B: set)\n requires U <= B\n ensures |U| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_14470","instance":14470,"id":217813,"goal":"lemma SetUnionCard_14470(S: set, A: set)\n requires S * A == {}\n ensures |S + A| == |S| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_14471","instance":14471,"id":217814,"goal":"lemma SetUnionComm_14471(U: set, B: set)\n ensures U + B == B + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_14472","instance":14472,"id":217815,"goal":"lemma SetInterComm_14472(U: set, T: set)\n ensures U * T == T * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_14473","instance":14473,"id":217816,"goal":"lemma SetUnionAssoc_14473(S: set, T: set, A: set)\n ensures (S + T) + A == S + (T + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_14474","instance":14474,"id":217817,"goal":"lemma SetSubsetRefl_14474(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_14475","instance":14475,"id":217818,"goal":"lemma SetSubsetTrans_14475(T: set, A: set, S: set)\n requires T <= A && A <= S\n ensures T <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_14476","instance":14476,"id":217819,"goal":"lemma SetUnionEmpty_14476(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_14477","instance":14477,"id":217820,"goal":"lemma SetInterEmpty_14477(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_14478","instance":14478,"id":217821,"goal":"lemma SetInterSubset_14478(B: set, A: set)\n ensures B * A <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_14479","instance":14479,"id":217822,"goal":"lemma SetCardSubset_14479(B: set, S: set)\n requires B <= S\n ensures |B| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_14480","instance":14480,"id":217823,"goal":"lemma SetUnionCard_14480(A: set, B: set)\n requires A * B == {}\n ensures |A + B| == |A| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_14481","instance":14481,"id":217824,"goal":"lemma SetUnionComm_14481(S: set, U: set)\n ensures S + U == U + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_14482","instance":14482,"id":217825,"goal":"lemma SetInterComm_14482(A: set, B: set)\n ensures A * B == B * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_14483","instance":14483,"id":217826,"goal":"lemma SetUnionAssoc_14483(T: set, S: set, A: set)\n ensures (T + S) + A == T + (S + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_14484","instance":14484,"id":217827,"goal":"lemma SetSubsetRefl_14484(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_14485","instance":14485,"id":217828,"goal":"lemma SetSubsetTrans_14485(T: set, S: set, B: set)\n requires T <= S && S <= B\n ensures T <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_14486","instance":14486,"id":217829,"goal":"lemma SetUnionEmpty_14486(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_14487","instance":14487,"id":217830,"goal":"lemma SetInterEmpty_14487(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_14488","instance":14488,"id":217831,"goal":"lemma SetInterSubset_14488(T: set, B: set)\n ensures T * B <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_14489","instance":14489,"id":217832,"goal":"lemma SetCardSubset_14489(B: set, U: set)\n requires B <= U\n ensures |B| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_14490","instance":14490,"id":217833,"goal":"lemma SetUnionCard_14490(T: set, B: set)\n requires T * B == {}\n ensures |T + B| == |T| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_14491","instance":14491,"id":217834,"goal":"lemma SetUnionComm_14491(S: set, A: set)\n ensures S + A == A + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_14492","instance":14492,"id":217835,"goal":"lemma SetInterComm_14492(U: set, B: set)\n ensures U * B == B * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_14493","instance":14493,"id":217836,"goal":"lemma SetUnionAssoc_14493(U: set, A: set, T: set)\n ensures (U + A) + T == U + (A + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_14494","instance":14494,"id":217837,"goal":"lemma SetSubsetRefl_14494(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_14495","instance":14495,"id":217838,"goal":"lemma SetSubsetTrans_14495(T: set, B: set, A: set)\n requires T <= B && B <= A\n ensures T <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_14496","instance":14496,"id":217839,"goal":"lemma SetUnionEmpty_14496(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_14497","instance":14497,"id":217840,"goal":"lemma SetInterEmpty_14497(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_14498","instance":14498,"id":217841,"goal":"lemma SetInterSubset_14498(U: set, B: set)\n ensures U * B <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_14499","instance":14499,"id":217842,"goal":"lemma SetCardSubset_14499(U: set, T: set)\n requires U <= T\n ensures |U| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_14500","instance":14500,"id":217843,"goal":"lemma SetUnionCard_14500(T: set, A: set)\n requires T * A == {}\n ensures |T + A| == |T| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_14501","instance":14501,"id":217844,"goal":"lemma SetUnionComm_14501(S: set, T: set)\n ensures S + T == T + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_14502","instance":14502,"id":217845,"goal":"lemma SetInterComm_14502(T: set, U: set)\n ensures T * U == U * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_14503","instance":14503,"id":217846,"goal":"lemma SetUnionAssoc_14503(S: set, U: set, B: set)\n ensures (S + U) + B == S + (U + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_14504","instance":14504,"id":217847,"goal":"lemma SetSubsetRefl_14504(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_14505","instance":14505,"id":217848,"goal":"lemma SetSubsetTrans_14505(T: set, S: set, U: set)\n requires T <= S && S <= U\n ensures T <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_14506","instance":14506,"id":217849,"goal":"lemma SetUnionEmpty_14506(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_14507","instance":14507,"id":217850,"goal":"lemma SetInterEmpty_14507(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_14508","instance":14508,"id":217851,"goal":"lemma SetInterSubset_14508(B: set, A: set)\n ensures B * A <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_14509","instance":14509,"id":217852,"goal":"lemma SetCardSubset_14509(B: set, U: set)\n requires B <= U\n ensures |B| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_14510","instance":14510,"id":217853,"goal":"lemma SetUnionCard_14510(T: set, A: set)\n requires T * A == {}\n ensures |T + A| == |T| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_14511","instance":14511,"id":217854,"goal":"lemma SetUnionComm_14511(U: set, B: set)\n ensures U + B == B + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_14512","instance":14512,"id":217855,"goal":"lemma SetInterComm_14512(S: set, A: set)\n ensures S * A == A * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_14513","instance":14513,"id":217856,"goal":"lemma SetUnionAssoc_14513(S: set, U: set, B: set)\n ensures (S + U) + B == S + (U + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_14514","instance":14514,"id":217857,"goal":"lemma SetSubsetRefl_14514(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_14515","instance":14515,"id":217858,"goal":"lemma SetSubsetTrans_14515(T: set, A: set, U: set)\n requires T <= A && A <= U\n ensures T <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_14516","instance":14516,"id":217859,"goal":"lemma SetUnionEmpty_14516(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_14517","instance":14517,"id":217860,"goal":"lemma SetInterEmpty_14517(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_14518","instance":14518,"id":217861,"goal":"lemma SetInterSubset_14518(A: set, T: set)\n ensures A * T <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_14519","instance":14519,"id":217862,"goal":"lemma SetCardSubset_14519(S: set, U: set)\n requires S <= U\n ensures |S| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_14520","instance":14520,"id":217863,"goal":"lemma SetUnionCard_14520(U: set, B: set)\n requires U * B == {}\n ensures |U + B| == |U| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_14521","instance":14521,"id":217864,"goal":"lemma SetUnionComm_14521(U: set, A: set)\n ensures U + A == A + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_14522","instance":14522,"id":217865,"goal":"lemma SetInterComm_14522(T: set, B: set)\n ensures T * B == B * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_14523","instance":14523,"id":217866,"goal":"lemma SetUnionAssoc_14523(S: set, U: set, T: set)\n ensures (S + U) + T == S + (U + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_14524","instance":14524,"id":217867,"goal":"lemma SetSubsetRefl_14524(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_14525","instance":14525,"id":217868,"goal":"lemma SetSubsetTrans_14525(B: set, A: set, S: set)\n requires B <= A && A <= S\n ensures B <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_14526","instance":14526,"id":217869,"goal":"lemma SetUnionEmpty_14526(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_14527","instance":14527,"id":217870,"goal":"lemma SetInterEmpty_14527(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_14528","instance":14528,"id":217871,"goal":"lemma SetInterSubset_14528(U: set, S: set)\n ensures U * S <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_14529","instance":14529,"id":217872,"goal":"lemma SetCardSubset_14529(A: set, B: set)\n requires A <= B\n ensures |A| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_14530","instance":14530,"id":217873,"goal":"lemma SetUnionCard_14530(B: set, U: set)\n requires B * U == {}\n ensures |B + U| == |B| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_14531","instance":14531,"id":217874,"goal":"lemma SetUnionComm_14531(S: set, A: set)\n ensures S + A == A + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_14532","instance":14532,"id":217875,"goal":"lemma SetInterComm_14532(U: set, S: set)\n ensures U * S == S * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_14533","instance":14533,"id":217876,"goal":"lemma SetUnionAssoc_14533(S: set, T: set, A: set)\n ensures (S + T) + A == S + (T + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_14534","instance":14534,"id":217877,"goal":"lemma SetSubsetRefl_14534(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_14535","instance":14535,"id":217878,"goal":"lemma SetSubsetTrans_14535(S: set, B: set, T: set)\n requires S <= B && B <= T\n ensures S <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_14536","instance":14536,"id":217879,"goal":"lemma SetUnionEmpty_14536(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_14537","instance":14537,"id":217880,"goal":"lemma SetInterEmpty_14537(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_14538","instance":14538,"id":217881,"goal":"lemma SetInterSubset_14538(S: set, U: set)\n ensures S * U <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_14539","instance":14539,"id":217882,"goal":"lemma SetCardSubset_14539(T: set, U: set)\n requires T <= U\n ensures |T| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_14540","instance":14540,"id":217883,"goal":"lemma SetUnionCard_14540(A: set, U: set)\n requires A * U == {}\n ensures |A + U| == |A| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_14541","instance":14541,"id":217884,"goal":"lemma SetUnionComm_14541(S: set, A: set)\n ensures S + A == A + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_14542","instance":14542,"id":217885,"goal":"lemma SetInterComm_14542(S: set, T: set)\n ensures S * T == T * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_14543","instance":14543,"id":217886,"goal":"lemma SetUnionAssoc_14543(B: set, T: set, A: set)\n ensures (B + T) + A == B + (T + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_14544","instance":14544,"id":217887,"goal":"lemma SetSubsetRefl_14544(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_14545","instance":14545,"id":217888,"goal":"lemma SetSubsetTrans_14545(U: set, A: set, T: set)\n requires U <= A && A <= T\n ensures U <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_14546","instance":14546,"id":217889,"goal":"lemma SetUnionEmpty_14546(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_14547","instance":14547,"id":217890,"goal":"lemma SetInterEmpty_14547(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_14548","instance":14548,"id":217891,"goal":"lemma SetInterSubset_14548(A: set, B: set)\n ensures A * B <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_14549","instance":14549,"id":217892,"goal":"lemma SetCardSubset_14549(A: set, U: set)\n requires A <= U\n ensures |A| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_14550","instance":14550,"id":217893,"goal":"lemma SetUnionCard_14550(S: set, U: set)\n requires S * U == {}\n ensures |S + U| == |S| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_14551","instance":14551,"id":217894,"goal":"lemma SetUnionComm_14551(A: set, B: set)\n ensures A + B == B + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_14552","instance":14552,"id":217895,"goal":"lemma SetInterComm_14552(U: set, B: set)\n ensures U * B == B * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_14553","instance":14553,"id":217896,"goal":"lemma SetUnionAssoc_14553(U: set, A: set, S: set)\n ensures (U + A) + S == U + (A + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_14554","instance":14554,"id":217897,"goal":"lemma SetSubsetRefl_14554(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_14555","instance":14555,"id":217898,"goal":"lemma SetSubsetTrans_14555(U: set, A: set, B: set)\n requires U <= A && A <= B\n ensures U <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_14556","instance":14556,"id":217899,"goal":"lemma SetUnionEmpty_14556(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_14557","instance":14557,"id":217900,"goal":"lemma SetInterEmpty_14557(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_14558","instance":14558,"id":217901,"goal":"lemma SetInterSubset_14558(S: set, A: set)\n ensures S * A <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_14559","instance":14559,"id":217902,"goal":"lemma SetCardSubset_14559(S: set, T: set)\n requires S <= T\n ensures |S| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_14560","instance":14560,"id":217903,"goal":"lemma SetUnionCard_14560(T: set, U: set)\n requires T * U == {}\n ensures |T + U| == |T| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_14561","instance":14561,"id":217904,"goal":"lemma SetUnionComm_14561(T: set, B: set)\n ensures T + B == B + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_14562","instance":14562,"id":217905,"goal":"lemma SetInterComm_14562(S: set, T: set)\n ensures S * T == T * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_14563","instance":14563,"id":217906,"goal":"lemma SetUnionAssoc_14563(U: set, B: set, T: set)\n ensures (U + B) + T == U + (B + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_14564","instance":14564,"id":217907,"goal":"lemma SetSubsetRefl_14564(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_14565","instance":14565,"id":217908,"goal":"lemma SetSubsetTrans_14565(S: set, U: set, A: set)\n requires S <= U && U <= A\n ensures S <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_14566","instance":14566,"id":217909,"goal":"lemma SetUnionEmpty_14566(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_14567","instance":14567,"id":217910,"goal":"lemma SetInterEmpty_14567(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_14568","instance":14568,"id":217911,"goal":"lemma SetInterSubset_14568(B: set, T: set)\n ensures B * T <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_14569","instance":14569,"id":217912,"goal":"lemma SetCardSubset_14569(B: set, T: set)\n requires B <= T\n ensures |B| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_14570","instance":14570,"id":217913,"goal":"lemma SetUnionCard_14570(S: set, B: set)\n requires S * B == {}\n ensures |S + B| == |S| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_14571","instance":14571,"id":217914,"goal":"lemma SetUnionComm_14571(U: set, B: set)\n ensures U + B == B + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_14572","instance":14572,"id":217915,"goal":"lemma SetInterComm_14572(U: set, T: set)\n ensures U * T == T * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_14573","instance":14573,"id":217916,"goal":"lemma SetUnionAssoc_14573(B: set, S: set, U: set)\n ensures (B + S) + U == B + (S + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_14574","instance":14574,"id":217917,"goal":"lemma SetSubsetRefl_14574(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_14575","instance":14575,"id":217918,"goal":"lemma SetSubsetTrans_14575(S: set, A: set, T: set)\n requires S <= A && A <= T\n ensures S <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_14576","instance":14576,"id":217919,"goal":"lemma SetUnionEmpty_14576(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_14577","instance":14577,"id":217920,"goal":"lemma SetInterEmpty_14577(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_14578","instance":14578,"id":217921,"goal":"lemma SetInterSubset_14578(T: set, B: set)\n ensures T * B <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_14579","instance":14579,"id":217922,"goal":"lemma SetCardSubset_14579(T: set, S: set)\n requires T <= S\n ensures |T| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_14580","instance":14580,"id":217923,"goal":"lemma SetUnionCard_14580(T: set, A: set)\n requires T * A == {}\n ensures |T + A| == |T| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_14581","instance":14581,"id":217924,"goal":"lemma SetUnionComm_14581(B: set, T: set)\n ensures B + T == T + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_14582","instance":14582,"id":217925,"goal":"lemma SetInterComm_14582(B: set, T: set)\n ensures B * T == T * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_14583","instance":14583,"id":217926,"goal":"lemma SetUnionAssoc_14583(B: set, S: set, A: set)\n ensures (B + S) + A == B + (S + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_14584","instance":14584,"id":217927,"goal":"lemma SetSubsetRefl_14584(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_14585","instance":14585,"id":217928,"goal":"lemma SetSubsetTrans_14585(S: set, U: set, A: set)\n requires S <= U && U <= A\n ensures S <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_14586","instance":14586,"id":217929,"goal":"lemma SetUnionEmpty_14586(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_14587","instance":14587,"id":217930,"goal":"lemma SetInterEmpty_14587(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_14588","instance":14588,"id":217931,"goal":"lemma SetInterSubset_14588(B: set, T: set)\n ensures B * T <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_14589","instance":14589,"id":217932,"goal":"lemma SetCardSubset_14589(A: set, U: set)\n requires A <= U\n ensures |A| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_14590","instance":14590,"id":217933,"goal":"lemma SetUnionCard_14590(T: set, B: set)\n requires T * B == {}\n ensures |T + B| == |T| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_14591","instance":14591,"id":217934,"goal":"lemma SetUnionComm_14591(S: set, B: set)\n ensures S + B == B + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_14592","instance":14592,"id":217935,"goal":"lemma SetInterComm_14592(S: set, A: set)\n ensures S * A == A * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_14593","instance":14593,"id":217936,"goal":"lemma SetUnionAssoc_14593(A: set, B: set, T: set)\n ensures (A + B) + T == A + (B + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_14594","instance":14594,"id":217937,"goal":"lemma SetSubsetRefl_14594(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_14595","instance":14595,"id":217938,"goal":"lemma SetSubsetTrans_14595(S: set, A: set, U: set)\n requires S <= A && A <= U\n ensures S <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_14596","instance":14596,"id":217939,"goal":"lemma SetUnionEmpty_14596(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_14597","instance":14597,"id":217940,"goal":"lemma SetInterEmpty_14597(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_14598","instance":14598,"id":217941,"goal":"lemma SetInterSubset_14598(A: set, S: set)\n ensures A * S <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_14599","instance":14599,"id":217942,"goal":"lemma SetCardSubset_14599(T: set, B: set)\n requires T <= B\n ensures |T| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_14600","instance":14600,"id":217943,"goal":"lemma SetUnionCard_14600(A: set, U: set)\n requires A * U == {}\n ensures |A + U| == |A| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_14601","instance":14601,"id":217944,"goal":"lemma SetUnionComm_14601(S: set, A: set)\n ensures S + A == A + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_14602","instance":14602,"id":217945,"goal":"lemma SetInterComm_14602(B: set, A: set)\n ensures B * A == A * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_14603","instance":14603,"id":217946,"goal":"lemma SetUnionAssoc_14603(S: set, U: set, T: set)\n ensures (S + U) + T == S + (U + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_14604","instance":14604,"id":217947,"goal":"lemma SetSubsetRefl_14604(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_14605","instance":14605,"id":217948,"goal":"lemma SetSubsetTrans_14605(U: set, B: set, A: set)\n requires U <= B && B <= A\n ensures U <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_14606","instance":14606,"id":217949,"goal":"lemma SetUnionEmpty_14606(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_14607","instance":14607,"id":217950,"goal":"lemma SetInterEmpty_14607(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_14608","instance":14608,"id":217951,"goal":"lemma SetInterSubset_14608(A: set, S: set)\n ensures A * S <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_14609","instance":14609,"id":217952,"goal":"lemma SetCardSubset_14609(A: set, U: set)\n requires A <= U\n ensures |A| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_14610","instance":14610,"id":217953,"goal":"lemma SetUnionCard_14610(S: set, U: set)\n requires S * U == {}\n ensures |S + U| == |S| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_14611","instance":14611,"id":217954,"goal":"lemma SetUnionComm_14611(S: set, B: set)\n ensures S + B == B + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_14612","instance":14612,"id":217955,"goal":"lemma SetInterComm_14612(U: set, B: set)\n ensures U * B == B * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_14613","instance":14613,"id":217956,"goal":"lemma SetUnionAssoc_14613(S: set, T: set, A: set)\n ensures (S + T) + A == S + (T + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_14614","instance":14614,"id":217957,"goal":"lemma SetSubsetRefl_14614(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_14615","instance":14615,"id":217958,"goal":"lemma SetSubsetTrans_14615(A: set, S: set, U: set)\n requires A <= S && S <= U\n ensures A <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_14616","instance":14616,"id":217959,"goal":"lemma SetUnionEmpty_14616(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_14617","instance":14617,"id":217960,"goal":"lemma SetInterEmpty_14617(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_14618","instance":14618,"id":217961,"goal":"lemma SetInterSubset_14618(T: set, A: set)\n ensures T * A <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_14619","instance":14619,"id":217962,"goal":"lemma SetCardSubset_14619(A: set, T: set)\n requires A <= T\n ensures |A| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_14620","instance":14620,"id":217963,"goal":"lemma SetUnionCard_14620(S: set, B: set)\n requires S * B == {}\n ensures |S + B| == |S| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_14621","instance":14621,"id":217964,"goal":"lemma SetUnionComm_14621(B: set, A: set)\n ensures B + A == A + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_14622","instance":14622,"id":217965,"goal":"lemma SetInterComm_14622(A: set, T: set)\n ensures A * T == T * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_14623","instance":14623,"id":217966,"goal":"lemma SetUnionAssoc_14623(B: set, A: set, U: set)\n ensures (B + A) + U == B + (A + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_14624","instance":14624,"id":217967,"goal":"lemma SetSubsetRefl_14624(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_14625","instance":14625,"id":217968,"goal":"lemma SetSubsetTrans_14625(S: set, U: set, B: set)\n requires S <= U && U <= B\n ensures S <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_14626","instance":14626,"id":217969,"goal":"lemma SetUnionEmpty_14626(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_14627","instance":14627,"id":217970,"goal":"lemma SetInterEmpty_14627(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_14628","instance":14628,"id":217971,"goal":"lemma SetInterSubset_14628(A: set, T: set)\n ensures A * T <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_14629","instance":14629,"id":217972,"goal":"lemma SetCardSubset_14629(S: set, T: set)\n requires S <= T\n ensures |S| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_14630","instance":14630,"id":217973,"goal":"lemma SetUnionCard_14630(T: set, A: set)\n requires T * A == {}\n ensures |T + A| == |T| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_14631","instance":14631,"id":217974,"goal":"lemma SetUnionComm_14631(S: set, U: set)\n ensures S + U == U + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_14632","instance":14632,"id":217975,"goal":"lemma SetInterComm_14632(B: set, U: set)\n ensures B * U == U * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_14633","instance":14633,"id":217976,"goal":"lemma SetUnionAssoc_14633(S: set, T: set, U: set)\n ensures (S + T) + U == S + (T + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_14634","instance":14634,"id":217977,"goal":"lemma SetSubsetRefl_14634(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_14635","instance":14635,"id":217978,"goal":"lemma SetSubsetTrans_14635(S: set, B: set, A: set)\n requires S <= B && B <= A\n ensures S <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_14636","instance":14636,"id":217979,"goal":"lemma SetUnionEmpty_14636(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_14637","instance":14637,"id":217980,"goal":"lemma SetInterEmpty_14637(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_14638","instance":14638,"id":217981,"goal":"lemma SetInterSubset_14638(U: set, S: set)\n ensures U * S <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_14639","instance":14639,"id":217982,"goal":"lemma SetCardSubset_14639(B: set, S: set)\n requires B <= S\n ensures |B| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_14640","instance":14640,"id":217983,"goal":"lemma SetUnionCard_14640(S: set, T: set)\n requires S * T == {}\n ensures |S + T| == |S| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_14641","instance":14641,"id":217984,"goal":"lemma SetUnionComm_14641(S: set, B: set)\n ensures S + B == B + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_14642","instance":14642,"id":217985,"goal":"lemma SetInterComm_14642(S: set, T: set)\n ensures S * T == T * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_14643","instance":14643,"id":217986,"goal":"lemma SetUnionAssoc_14643(S: set, T: set, U: set)\n ensures (S + T) + U == S + (T + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_14644","instance":14644,"id":217987,"goal":"lemma SetSubsetRefl_14644(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_14645","instance":14645,"id":217988,"goal":"lemma SetSubsetTrans_14645(B: set, S: set, T: set)\n requires B <= S && S <= T\n ensures B <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_14646","instance":14646,"id":217989,"goal":"lemma SetUnionEmpty_14646(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_14647","instance":14647,"id":217990,"goal":"lemma SetInterEmpty_14647(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_14648","instance":14648,"id":217991,"goal":"lemma SetInterSubset_14648(U: set, B: set)\n ensures U * B <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_14649","instance":14649,"id":217992,"goal":"lemma SetCardSubset_14649(A: set, S: set)\n requires A <= S\n ensures |A| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_14650","instance":14650,"id":217993,"goal":"lemma SetUnionCard_14650(T: set, A: set)\n requires T * A == {}\n ensures |T + A| == |T| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_14651","instance":14651,"id":217994,"goal":"lemma SetUnionComm_14651(B: set, U: set)\n ensures B + U == U + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_14652","instance":14652,"id":217995,"goal":"lemma SetInterComm_14652(S: set, B: set)\n ensures S * B == B * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_14653","instance":14653,"id":217996,"goal":"lemma SetUnionAssoc_14653(A: set, U: set, S: set)\n ensures (A + U) + S == A + (U + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_14654","instance":14654,"id":217997,"goal":"lemma SetSubsetRefl_14654(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_14655","instance":14655,"id":217998,"goal":"lemma SetSubsetTrans_14655(A: set, B: set, T: set)\n requires A <= B && B <= T\n ensures A <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_14656","instance":14656,"id":217999,"goal":"lemma SetUnionEmpty_14656(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_14657","instance":14657,"id":218000,"goal":"lemma SetInterEmpty_14657(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_14658","instance":14658,"id":218001,"goal":"lemma SetInterSubset_14658(A: set, B: set)\n ensures A * B <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_14659","instance":14659,"id":218002,"goal":"lemma SetCardSubset_14659(U: set, T: set)\n requires U <= T\n ensures |U| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_14660","instance":14660,"id":218003,"goal":"lemma SetUnionCard_14660(T: set, U: set)\n requires T * U == {}\n ensures |T + U| == |T| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_14661","instance":14661,"id":218004,"goal":"lemma SetUnionComm_14661(S: set, T: set)\n ensures S + T == T + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_14662","instance":14662,"id":218005,"goal":"lemma SetInterComm_14662(B: set, T: set)\n ensures B * T == T * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_14663","instance":14663,"id":218006,"goal":"lemma SetUnionAssoc_14663(A: set, B: set, U: set)\n ensures (A + B) + U == A + (B + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_14664","instance":14664,"id":218007,"goal":"lemma SetSubsetRefl_14664(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_14665","instance":14665,"id":218008,"goal":"lemma SetSubsetTrans_14665(B: set, T: set, A: set)\n requires B <= T && T <= A\n ensures B <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_14666","instance":14666,"id":218009,"goal":"lemma SetUnionEmpty_14666(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_14667","instance":14667,"id":218010,"goal":"lemma SetInterEmpty_14667(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_14668","instance":14668,"id":218011,"goal":"lemma SetInterSubset_14668(S: set, B: set)\n ensures S * B <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_14669","instance":14669,"id":218012,"goal":"lemma SetCardSubset_14669(B: set, A: set)\n requires B <= A\n ensures |B| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_14670","instance":14670,"id":218013,"goal":"lemma SetUnionCard_14670(B: set, A: set)\n requires B * A == {}\n ensures |B + A| == |B| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_14671","instance":14671,"id":218014,"goal":"lemma SetUnionComm_14671(A: set, U: set)\n ensures A + U == U + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_14672","instance":14672,"id":218015,"goal":"lemma SetInterComm_14672(A: set, T: set)\n ensures A * T == T * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_14673","instance":14673,"id":218016,"goal":"lemma SetUnionAssoc_14673(A: set, B: set, S: set)\n ensures (A + B) + S == A + (B + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_14674","instance":14674,"id":218017,"goal":"lemma SetSubsetRefl_14674(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_14675","instance":14675,"id":218018,"goal":"lemma SetSubsetTrans_14675(B: set, A: set, S: set)\n requires B <= A && A <= S\n ensures B <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_14676","instance":14676,"id":218019,"goal":"lemma SetUnionEmpty_14676(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_14677","instance":14677,"id":218020,"goal":"lemma SetInterEmpty_14677(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_14678","instance":14678,"id":218021,"goal":"lemma SetInterSubset_14678(T: set, U: set)\n ensures T * U <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_14679","instance":14679,"id":218022,"goal":"lemma SetCardSubset_14679(U: set, T: set)\n requires U <= T\n ensures |U| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_14680","instance":14680,"id":218023,"goal":"lemma SetUnionCard_14680(S: set, A: set)\n requires S * A == {}\n ensures |S + A| == |S| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_14681","instance":14681,"id":218024,"goal":"lemma SetUnionComm_14681(B: set, U: set)\n ensures B + U == U + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_14682","instance":14682,"id":218025,"goal":"lemma SetInterComm_14682(A: set, U: set)\n ensures A * U == U * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_14683","instance":14683,"id":218026,"goal":"lemma SetUnionAssoc_14683(A: set, B: set, T: set)\n ensures (A + B) + T == A + (B + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_14684","instance":14684,"id":218027,"goal":"lemma SetSubsetRefl_14684(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_14685","instance":14685,"id":218028,"goal":"lemma SetSubsetTrans_14685(A: set, S: set, U: set)\n requires A <= S && S <= U\n ensures A <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_14686","instance":14686,"id":218029,"goal":"lemma SetUnionEmpty_14686(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_14687","instance":14687,"id":218030,"goal":"lemma SetInterEmpty_14687(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_14688","instance":14688,"id":218031,"goal":"lemma SetInterSubset_14688(S: set, T: set)\n ensures S * T <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_14689","instance":14689,"id":218032,"goal":"lemma SetCardSubset_14689(U: set, A: set)\n requires U <= A\n ensures |U| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_14690","instance":14690,"id":218033,"goal":"lemma SetUnionCard_14690(T: set, U: set)\n requires T * U == {}\n ensures |T + U| == |T| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_14691","instance":14691,"id":218034,"goal":"lemma SetUnionComm_14691(T: set, B: set)\n ensures T + B == B + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_14692","instance":14692,"id":218035,"goal":"lemma SetInterComm_14692(B: set, T: set)\n ensures B * T == T * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_14693","instance":14693,"id":218036,"goal":"lemma SetUnionAssoc_14693(S: set, A: set, U: set)\n ensures (S + A) + U == S + (A + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_14694","instance":14694,"id":218037,"goal":"lemma SetSubsetRefl_14694(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_14695","instance":14695,"id":218038,"goal":"lemma SetSubsetTrans_14695(B: set, U: set, T: set)\n requires B <= U && U <= T\n ensures B <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_14696","instance":14696,"id":218039,"goal":"lemma SetUnionEmpty_14696(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_14697","instance":14697,"id":218040,"goal":"lemma SetInterEmpty_14697(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_14698","instance":14698,"id":218041,"goal":"lemma SetInterSubset_14698(U: set, A: set)\n ensures U * A <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_14699","instance":14699,"id":218042,"goal":"lemma SetCardSubset_14699(B: set, T: set)\n requires B <= T\n ensures |B| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_14700","instance":14700,"id":218043,"goal":"lemma SetUnionCard_14700(S: set, U: set)\n requires S * U == {}\n ensures |S + U| == |S| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_14701","instance":14701,"id":218044,"goal":"lemma SetUnionComm_14701(U: set, A: set)\n ensures U + A == A + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_14702","instance":14702,"id":218045,"goal":"lemma SetInterComm_14702(B: set, A: set)\n ensures B * A == A * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_14703","instance":14703,"id":218046,"goal":"lemma SetUnionAssoc_14703(A: set, U: set, S: set)\n ensures (A + U) + S == A + (U + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_14704","instance":14704,"id":218047,"goal":"lemma SetSubsetRefl_14704(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_14705","instance":14705,"id":218048,"goal":"lemma SetSubsetTrans_14705(B: set, A: set, S: set)\n requires B <= A && A <= S\n ensures B <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_14706","instance":14706,"id":218049,"goal":"lemma SetUnionEmpty_14706(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_14707","instance":14707,"id":218050,"goal":"lemma SetInterEmpty_14707(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_14708","instance":14708,"id":218051,"goal":"lemma SetInterSubset_14708(S: set, A: set)\n ensures S * A <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_14709","instance":14709,"id":218052,"goal":"lemma SetCardSubset_14709(S: set, B: set)\n requires S <= B\n ensures |S| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_14710","instance":14710,"id":218053,"goal":"lemma SetUnionCard_14710(U: set, T: set)\n requires U * T == {}\n ensures |U + T| == |U| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_14711","instance":14711,"id":218054,"goal":"lemma SetUnionComm_14711(U: set, A: set)\n ensures U + A == A + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_14712","instance":14712,"id":218055,"goal":"lemma SetInterComm_14712(S: set, U: set)\n ensures S * U == U * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_14713","instance":14713,"id":218056,"goal":"lemma SetUnionAssoc_14713(B: set, U: set, S: set)\n ensures (B + U) + S == B + (U + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_14714","instance":14714,"id":218057,"goal":"lemma SetSubsetRefl_14714(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_14715","instance":14715,"id":218058,"goal":"lemma SetSubsetTrans_14715(B: set, T: set, A: set)\n requires B <= T && T <= A\n ensures B <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_14716","instance":14716,"id":218059,"goal":"lemma SetUnionEmpty_14716(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_14717","instance":14717,"id":218060,"goal":"lemma SetInterEmpty_14717(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_14718","instance":14718,"id":218061,"goal":"lemma SetInterSubset_14718(S: set, B: set)\n ensures S * B <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_14719","instance":14719,"id":218062,"goal":"lemma SetCardSubset_14719(A: set, T: set)\n requires A <= T\n ensures |A| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_14720","instance":14720,"id":218063,"goal":"lemma SetUnionCard_14720(T: set, U: set)\n requires T * U == {}\n ensures |T + U| == |T| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_14721","instance":14721,"id":218064,"goal":"lemma SetUnionComm_14721(B: set, A: set)\n ensures B + A == A + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_14722","instance":14722,"id":218065,"goal":"lemma SetInterComm_14722(S: set, U: set)\n ensures S * U == U * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_14723","instance":14723,"id":218066,"goal":"lemma SetUnionAssoc_14723(B: set, S: set, T: set)\n ensures (B + S) + T == B + (S + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_14724","instance":14724,"id":218067,"goal":"lemma SetSubsetRefl_14724(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_14725","instance":14725,"id":218068,"goal":"lemma SetSubsetTrans_14725(S: set, A: set, B: set)\n requires S <= A && A <= B\n ensures S <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_14726","instance":14726,"id":218069,"goal":"lemma SetUnionEmpty_14726(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_14727","instance":14727,"id":218070,"goal":"lemma SetInterEmpty_14727(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_14728","instance":14728,"id":218071,"goal":"lemma SetInterSubset_14728(S: set, B: set)\n ensures S * B <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_14729","instance":14729,"id":218072,"goal":"lemma SetCardSubset_14729(A: set, U: set)\n requires A <= U\n ensures |A| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_14730","instance":14730,"id":218073,"goal":"lemma SetUnionCard_14730(A: set, S: set)\n requires A * S == {}\n ensures |A + S| == |A| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_14731","instance":14731,"id":218074,"goal":"lemma SetUnionComm_14731(S: set, T: set)\n ensures S + T == T + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_14732","instance":14732,"id":218075,"goal":"lemma SetInterComm_14732(A: set, U: set)\n ensures A * U == U * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_14733","instance":14733,"id":218076,"goal":"lemma SetUnionAssoc_14733(T: set, B: set, S: set)\n ensures (T + B) + S == T + (B + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_14734","instance":14734,"id":218077,"goal":"lemma SetSubsetRefl_14734(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_14735","instance":14735,"id":218078,"goal":"lemma SetSubsetTrans_14735(S: set, A: set, U: set)\n requires S <= A && A <= U\n ensures S <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_14736","instance":14736,"id":218079,"goal":"lemma SetUnionEmpty_14736(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_14737","instance":14737,"id":218080,"goal":"lemma SetInterEmpty_14737(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_14738","instance":14738,"id":218081,"goal":"lemma SetInterSubset_14738(U: set, A: set)\n ensures U * A <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_14739","instance":14739,"id":218082,"goal":"lemma SetCardSubset_14739(S: set, T: set)\n requires S <= T\n ensures |S| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_14740","instance":14740,"id":218083,"goal":"lemma SetUnionCard_14740(S: set, T: set)\n requires S * T == {}\n ensures |S + T| == |S| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_14741","instance":14741,"id":218084,"goal":"lemma SetUnionComm_14741(U: set, A: set)\n ensures U + A == A + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_14742","instance":14742,"id":218085,"goal":"lemma SetInterComm_14742(S: set, U: set)\n ensures S * U == U * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_14743","instance":14743,"id":218086,"goal":"lemma SetUnionAssoc_14743(B: set, A: set, T: set)\n ensures (B + A) + T == B + (A + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_14744","instance":14744,"id":218087,"goal":"lemma SetSubsetRefl_14744(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_14745","instance":14745,"id":218088,"goal":"lemma SetSubsetTrans_14745(T: set, A: set, B: set)\n requires T <= A && A <= B\n ensures T <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_14746","instance":14746,"id":218089,"goal":"lemma SetUnionEmpty_14746(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_14747","instance":14747,"id":218090,"goal":"lemma SetInterEmpty_14747(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_14748","instance":14748,"id":218091,"goal":"lemma SetInterSubset_14748(T: set, B: set)\n ensures T * B <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_14749","instance":14749,"id":218092,"goal":"lemma SetCardSubset_14749(U: set, A: set)\n requires U <= A\n ensures |U| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_14750","instance":14750,"id":218093,"goal":"lemma SetUnionCard_14750(T: set, S: set)\n requires T * S == {}\n ensures |T + S| == |T| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_14751","instance":14751,"id":218094,"goal":"lemma SetUnionComm_14751(S: set, A: set)\n ensures S + A == A + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_14752","instance":14752,"id":218095,"goal":"lemma SetInterComm_14752(S: set, B: set)\n ensures S * B == B * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_14753","instance":14753,"id":218096,"goal":"lemma SetUnionAssoc_14753(B: set, T: set, U: set)\n ensures (B + T) + U == B + (T + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_14754","instance":14754,"id":218097,"goal":"lemma SetSubsetRefl_14754(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_14755","instance":14755,"id":218098,"goal":"lemma SetSubsetTrans_14755(A: set, B: set, T: set)\n requires A <= B && B <= T\n ensures A <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_14756","instance":14756,"id":218099,"goal":"lemma SetUnionEmpty_14756(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_14757","instance":14757,"id":218100,"goal":"lemma SetInterEmpty_14757(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_14758","instance":14758,"id":218101,"goal":"lemma SetInterSubset_14758(U: set, B: set)\n ensures U * B <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_14759","instance":14759,"id":218102,"goal":"lemma SetCardSubset_14759(U: set, S: set)\n requires U <= S\n ensures |U| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_14760","instance":14760,"id":218103,"goal":"lemma SetUnionCard_14760(B: set, A: set)\n requires B * A == {}\n ensures |B + A| == |B| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_14761","instance":14761,"id":218104,"goal":"lemma SetUnionComm_14761(B: set, A: set)\n ensures B + A == A + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_14762","instance":14762,"id":218105,"goal":"lemma SetInterComm_14762(T: set, U: set)\n ensures T * U == U * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_14763","instance":14763,"id":218106,"goal":"lemma SetUnionAssoc_14763(A: set, U: set, S: set)\n ensures (A + U) + S == A + (U + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_14764","instance":14764,"id":218107,"goal":"lemma SetSubsetRefl_14764(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_14765","instance":14765,"id":218108,"goal":"lemma SetSubsetTrans_14765(A: set, T: set, U: set)\n requires A <= T && T <= U\n ensures A <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_14766","instance":14766,"id":218109,"goal":"lemma SetUnionEmpty_14766(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_14767","instance":14767,"id":218110,"goal":"lemma SetInterEmpty_14767(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_14768","instance":14768,"id":218111,"goal":"lemma SetInterSubset_14768(U: set, B: set)\n ensures U * B <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_14769","instance":14769,"id":218112,"goal":"lemma SetCardSubset_14769(B: set, S: set)\n requires B <= S\n ensures |B| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_14770","instance":14770,"id":218113,"goal":"lemma SetUnionCard_14770(S: set, T: set)\n requires S * T == {}\n ensures |S + T| == |S| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_14771","instance":14771,"id":218114,"goal":"lemma SetUnionComm_14771(U: set, S: set)\n ensures U + S == S + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_14772","instance":14772,"id":218115,"goal":"lemma SetInterComm_14772(S: set, T: set)\n ensures S * T == T * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_14773","instance":14773,"id":218116,"goal":"lemma SetUnionAssoc_14773(S: set, U: set, B: set)\n ensures (S + U) + B == S + (U + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_14774","instance":14774,"id":218117,"goal":"lemma SetSubsetRefl_14774(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_14775","instance":14775,"id":218118,"goal":"lemma SetSubsetTrans_14775(S: set, T: set, U: set)\n requires S <= T && T <= U\n ensures S <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_14776","instance":14776,"id":218119,"goal":"lemma SetUnionEmpty_14776(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_14777","instance":14777,"id":218120,"goal":"lemma SetInterEmpty_14777(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_14778","instance":14778,"id":218121,"goal":"lemma SetInterSubset_14778(U: set, A: set)\n ensures U * A <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_14779","instance":14779,"id":218122,"goal":"lemma SetCardSubset_14779(B: set, T: set)\n requires B <= T\n ensures |B| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_14780","instance":14780,"id":218123,"goal":"lemma SetUnionCard_14780(S: set, B: set)\n requires S * B == {}\n ensures |S + B| == |S| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_14781","instance":14781,"id":218124,"goal":"lemma SetUnionComm_14781(U: set, S: set)\n ensures U + S == S + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_14782","instance":14782,"id":218125,"goal":"lemma SetInterComm_14782(T: set, U: set)\n ensures T * U == U * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_14783","instance":14783,"id":218126,"goal":"lemma SetUnionAssoc_14783(T: set, B: set, A: set)\n ensures (T + B) + A == T + (B + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_14784","instance":14784,"id":218127,"goal":"lemma SetSubsetRefl_14784(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_14785","instance":14785,"id":218128,"goal":"lemma SetSubsetTrans_14785(S: set, U: set, A: set)\n requires S <= U && U <= A\n ensures S <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_14786","instance":14786,"id":218129,"goal":"lemma SetUnionEmpty_14786(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_14787","instance":14787,"id":218130,"goal":"lemma SetInterEmpty_14787(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_14788","instance":14788,"id":218131,"goal":"lemma SetInterSubset_14788(T: set, S: set)\n ensures T * S <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_14789","instance":14789,"id":218132,"goal":"lemma SetCardSubset_14789(B: set, U: set)\n requires B <= U\n ensures |B| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_14790","instance":14790,"id":218133,"goal":"lemma SetUnionCard_14790(U: set, S: set)\n requires U * S == {}\n ensures |U + S| == |U| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_14791","instance":14791,"id":218134,"goal":"lemma SetUnionComm_14791(A: set, U: set)\n ensures A + U == U + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_14792","instance":14792,"id":218135,"goal":"lemma SetInterComm_14792(S: set, B: set)\n ensures S * B == B * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_14793","instance":14793,"id":218136,"goal":"lemma SetUnionAssoc_14793(T: set, A: set, S: set)\n ensures (T + A) + S == T + (A + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_14794","instance":14794,"id":218137,"goal":"lemma SetSubsetRefl_14794(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_14795","instance":14795,"id":218138,"goal":"lemma SetSubsetTrans_14795(A: set, B: set, U: set)\n requires A <= B && B <= U\n ensures A <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_14796","instance":14796,"id":218139,"goal":"lemma SetUnionEmpty_14796(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_14797","instance":14797,"id":218140,"goal":"lemma SetInterEmpty_14797(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_14798","instance":14798,"id":218141,"goal":"lemma SetInterSubset_14798(B: set, A: set)\n ensures B * A <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_14799","instance":14799,"id":218142,"goal":"lemma SetCardSubset_14799(S: set, B: set)\n requires S <= B\n ensures |S| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_14800","instance":14800,"id":218143,"goal":"lemma SetUnionCard_14800(S: set, A: set)\n requires S * A == {}\n ensures |S + A| == |S| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_14801","instance":14801,"id":218144,"goal":"lemma SetUnionComm_14801(S: set, T: set)\n ensures S + T == T + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_14802","instance":14802,"id":218145,"goal":"lemma SetInterComm_14802(S: set, T: set)\n ensures S * T == T * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_14803","instance":14803,"id":218146,"goal":"lemma SetUnionAssoc_14803(B: set, U: set, S: set)\n ensures (B + U) + S == B + (U + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_14804","instance":14804,"id":218147,"goal":"lemma SetSubsetRefl_14804(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_14805","instance":14805,"id":218148,"goal":"lemma SetSubsetTrans_14805(S: set, T: set, B: set)\n requires S <= T && T <= B\n ensures S <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_14806","instance":14806,"id":218149,"goal":"lemma SetUnionEmpty_14806(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_14807","instance":14807,"id":218150,"goal":"lemma SetInterEmpty_14807(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_14808","instance":14808,"id":218151,"goal":"lemma SetInterSubset_14808(B: set, A: set)\n ensures B * A <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_14809","instance":14809,"id":218152,"goal":"lemma SetCardSubset_14809(T: set, U: set)\n requires T <= U\n ensures |T| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_14810","instance":14810,"id":218153,"goal":"lemma SetUnionCard_14810(B: set, T: set)\n requires B * T == {}\n ensures |B + T| == |B| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_14811","instance":14811,"id":218154,"goal":"lemma SetUnionComm_14811(S: set, T: set)\n ensures S + T == T + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_14812","instance":14812,"id":218155,"goal":"lemma SetInterComm_14812(A: set, U: set)\n ensures A * U == U * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_14813","instance":14813,"id":218156,"goal":"lemma SetUnionAssoc_14813(U: set, S: set, B: set)\n ensures (U + S) + B == U + (S + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_14814","instance":14814,"id":218157,"goal":"lemma SetSubsetRefl_14814(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_14815","instance":14815,"id":218158,"goal":"lemma SetSubsetTrans_14815(A: set, B: set, T: set)\n requires A <= B && B <= T\n ensures A <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_14816","instance":14816,"id":218159,"goal":"lemma SetUnionEmpty_14816(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_14817","instance":14817,"id":218160,"goal":"lemma SetInterEmpty_14817(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_14818","instance":14818,"id":218161,"goal":"lemma SetInterSubset_14818(S: set, U: set)\n ensures S * U <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_14819","instance":14819,"id":218162,"goal":"lemma SetCardSubset_14819(A: set, U: set)\n requires A <= U\n ensures |A| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_14820","instance":14820,"id":218163,"goal":"lemma SetUnionCard_14820(U: set, T: set)\n requires U * T == {}\n ensures |U + T| == |U| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_14821","instance":14821,"id":218164,"goal":"lemma SetUnionComm_14821(T: set, A: set)\n ensures T + A == A + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_14822","instance":14822,"id":218165,"goal":"lemma SetInterComm_14822(S: set, A: set)\n ensures S * A == A * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_14823","instance":14823,"id":218166,"goal":"lemma SetUnionAssoc_14823(A: set, U: set, S: set)\n ensures (A + U) + S == A + (U + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_14824","instance":14824,"id":218167,"goal":"lemma SetSubsetRefl_14824(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_14825","instance":14825,"id":218168,"goal":"lemma SetSubsetTrans_14825(T: set, A: set, S: set)\n requires T <= A && A <= S\n ensures T <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_14826","instance":14826,"id":218169,"goal":"lemma SetUnionEmpty_14826(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_14827","instance":14827,"id":218170,"goal":"lemma SetInterEmpty_14827(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_14828","instance":14828,"id":218171,"goal":"lemma SetInterSubset_14828(A: set, S: set)\n ensures A * S <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_14829","instance":14829,"id":218172,"goal":"lemma SetCardSubset_14829(U: set, S: set)\n requires U <= S\n ensures |U| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_14830","instance":14830,"id":218173,"goal":"lemma SetUnionCard_14830(S: set, B: set)\n requires S * B == {}\n ensures |S + B| == |S| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_14831","instance":14831,"id":218174,"goal":"lemma SetUnionComm_14831(U: set, S: set)\n ensures U + S == S + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_14832","instance":14832,"id":218175,"goal":"lemma SetInterComm_14832(T: set, A: set)\n ensures T * A == A * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_14833","instance":14833,"id":218176,"goal":"lemma SetUnionAssoc_14833(U: set, T: set, A: set)\n ensures (U + T) + A == U + (T + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_14834","instance":14834,"id":218177,"goal":"lemma SetSubsetRefl_14834(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_14835","instance":14835,"id":218178,"goal":"lemma SetSubsetTrans_14835(T: set, B: set, A: set)\n requires T <= B && B <= A\n ensures T <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_14836","instance":14836,"id":218179,"goal":"lemma SetUnionEmpty_14836(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_14837","instance":14837,"id":218180,"goal":"lemma SetInterEmpty_14837(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_14838","instance":14838,"id":218181,"goal":"lemma SetInterSubset_14838(T: set, U: set)\n ensures T * U <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_14839","instance":14839,"id":218182,"goal":"lemma SetCardSubset_14839(A: set, U: set)\n requires A <= U\n ensures |A| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_14840","instance":14840,"id":218183,"goal":"lemma SetUnionCard_14840(U: set, A: set)\n requires U * A == {}\n ensures |U + A| == |U| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_14841","instance":14841,"id":218184,"goal":"lemma SetUnionComm_14841(A: set, U: set)\n ensures A + U == U + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_14842","instance":14842,"id":218185,"goal":"lemma SetInterComm_14842(T: set, B: set)\n ensures T * B == B * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_14843","instance":14843,"id":218186,"goal":"lemma SetUnionAssoc_14843(U: set, S: set, B: set)\n ensures (U + S) + B == U + (S + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_14844","instance":14844,"id":218187,"goal":"lemma SetSubsetRefl_14844(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_14845","instance":14845,"id":218188,"goal":"lemma SetSubsetTrans_14845(S: set, B: set, U: set)\n requires S <= B && B <= U\n ensures S <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_14846","instance":14846,"id":218189,"goal":"lemma SetUnionEmpty_14846(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_14847","instance":14847,"id":218190,"goal":"lemma SetInterEmpty_14847(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_14848","instance":14848,"id":218191,"goal":"lemma SetInterSubset_14848(B: set, S: set)\n ensures B * S <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_14849","instance":14849,"id":218192,"goal":"lemma SetCardSubset_14849(S: set, U: set)\n requires S <= U\n ensures |S| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_14850","instance":14850,"id":218193,"goal":"lemma SetUnionCard_14850(A: set, U: set)\n requires A * U == {}\n ensures |A + U| == |A| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_14851","instance":14851,"id":218194,"goal":"lemma SetUnionComm_14851(U: set, T: set)\n ensures U + T == T + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_14852","instance":14852,"id":218195,"goal":"lemma SetInterComm_14852(B: set, S: set)\n ensures B * S == S * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_14853","instance":14853,"id":218196,"goal":"lemma SetUnionAssoc_14853(B: set, T: set, S: set)\n ensures (B + T) + S == B + (T + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_14854","instance":14854,"id":218197,"goal":"lemma SetSubsetRefl_14854(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_14855","instance":14855,"id":218198,"goal":"lemma SetSubsetTrans_14855(S: set, T: set, B: set)\n requires S <= T && T <= B\n ensures S <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_14856","instance":14856,"id":218199,"goal":"lemma SetUnionEmpty_14856(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_14857","instance":14857,"id":218200,"goal":"lemma SetInterEmpty_14857(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_14858","instance":14858,"id":218201,"goal":"lemma SetInterSubset_14858(U: set, B: set)\n ensures U * B <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_14859","instance":14859,"id":218202,"goal":"lemma SetCardSubset_14859(U: set, T: set)\n requires U <= T\n ensures |U| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_14860","instance":14860,"id":218203,"goal":"lemma SetUnionCard_14860(A: set, T: set)\n requires A * T == {}\n ensures |A + T| == |A| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_14861","instance":14861,"id":218204,"goal":"lemma SetUnionComm_14861(S: set, A: set)\n ensures S + A == A + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_14862","instance":14862,"id":218205,"goal":"lemma SetInterComm_14862(U: set, S: set)\n ensures U * S == S * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_14863","instance":14863,"id":218206,"goal":"lemma SetUnionAssoc_14863(B: set, T: set, S: set)\n ensures (B + T) + S == B + (T + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_14864","instance":14864,"id":218207,"goal":"lemma SetSubsetRefl_14864(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_14865","instance":14865,"id":218208,"goal":"lemma SetSubsetTrans_14865(B: set, S: set, U: set)\n requires B <= S && S <= U\n ensures B <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_14866","instance":14866,"id":218209,"goal":"lemma SetUnionEmpty_14866(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_14867","instance":14867,"id":218210,"goal":"lemma SetInterEmpty_14867(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_14868","instance":14868,"id":218211,"goal":"lemma SetInterSubset_14868(U: set, A: set)\n ensures U * A <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_14869","instance":14869,"id":218212,"goal":"lemma SetCardSubset_14869(U: set, B: set)\n requires U <= B\n ensures |U| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_14870","instance":14870,"id":218213,"goal":"lemma SetUnionCard_14870(T: set, U: set)\n requires T * U == {}\n ensures |T + U| == |T| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_14871","instance":14871,"id":218214,"goal":"lemma SetUnionComm_14871(B: set, U: set)\n ensures B + U == U + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_14872","instance":14872,"id":218215,"goal":"lemma SetInterComm_14872(S: set, A: set)\n ensures S * A == A * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_14873","instance":14873,"id":218216,"goal":"lemma SetUnionAssoc_14873(U: set, B: set, A: set)\n ensures (U + B) + A == U + (B + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_14874","instance":14874,"id":218217,"goal":"lemma SetSubsetRefl_14874(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_14875","instance":14875,"id":218218,"goal":"lemma SetSubsetTrans_14875(T: set, A: set, S: set)\n requires T <= A && A <= S\n ensures T <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_14876","instance":14876,"id":218219,"goal":"lemma SetUnionEmpty_14876(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_14877","instance":14877,"id":218220,"goal":"lemma SetInterEmpty_14877(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_14878","instance":14878,"id":218221,"goal":"lemma SetInterSubset_14878(U: set, A: set)\n ensures U * A <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_14879","instance":14879,"id":218222,"goal":"lemma SetCardSubset_14879(B: set, A: set)\n requires B <= A\n ensures |B| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_14880","instance":14880,"id":218223,"goal":"lemma SetUnionCard_14880(T: set, B: set)\n requires T * B == {}\n ensures |T + B| == |T| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_14881","instance":14881,"id":218224,"goal":"lemma SetUnionComm_14881(T: set, A: set)\n ensures T + A == A + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_14882","instance":14882,"id":218225,"goal":"lemma SetInterComm_14882(S: set, T: set)\n ensures S * T == T * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_14883","instance":14883,"id":218226,"goal":"lemma SetUnionAssoc_14883(B: set, U: set, T: set)\n ensures (B + U) + T == B + (U + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_14884","instance":14884,"id":218227,"goal":"lemma SetSubsetRefl_14884(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_14885","instance":14885,"id":218228,"goal":"lemma SetSubsetTrans_14885(U: set, A: set, B: set)\n requires U <= A && A <= B\n ensures U <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_14886","instance":14886,"id":218229,"goal":"lemma SetUnionEmpty_14886(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_14887","instance":14887,"id":218230,"goal":"lemma SetInterEmpty_14887(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_14888","instance":14888,"id":218231,"goal":"lemma SetInterSubset_14888(B: set, U: set)\n ensures B * U <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_14889","instance":14889,"id":218232,"goal":"lemma SetCardSubset_14889(T: set, U: set)\n requires T <= U\n ensures |T| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_14890","instance":14890,"id":218233,"goal":"lemma SetUnionCard_14890(S: set, T: set)\n requires S * T == {}\n ensures |S + T| == |S| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_14891","instance":14891,"id":218234,"goal":"lemma SetUnionComm_14891(U: set, A: set)\n ensures U + A == A + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_14892","instance":14892,"id":218235,"goal":"lemma SetInterComm_14892(A: set, B: set)\n ensures A * B == B * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_14893","instance":14893,"id":218236,"goal":"lemma SetUnionAssoc_14893(U: set, B: set, S: set)\n ensures (U + B) + S == U + (B + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_14894","instance":14894,"id":218237,"goal":"lemma SetSubsetRefl_14894(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_14895","instance":14895,"id":218238,"goal":"lemma SetSubsetTrans_14895(T: set, B: set, S: set)\n requires T <= B && B <= S\n ensures T <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_14896","instance":14896,"id":218239,"goal":"lemma SetUnionEmpty_14896(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_14897","instance":14897,"id":218240,"goal":"lemma SetInterEmpty_14897(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_14898","instance":14898,"id":218241,"goal":"lemma SetInterSubset_14898(T: set, U: set)\n ensures T * U <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_14899","instance":14899,"id":218242,"goal":"lemma SetCardSubset_14899(A: set, T: set)\n requires A <= T\n ensures |A| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_14900","instance":14900,"id":218243,"goal":"lemma SetUnionCard_14900(A: set, B: set)\n requires A * B == {}\n ensures |A + B| == |A| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_14901","instance":14901,"id":218244,"goal":"lemma SetUnionComm_14901(S: set, T: set)\n ensures S + T == T + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_14902","instance":14902,"id":218245,"goal":"lemma SetInterComm_14902(T: set, A: set)\n ensures T * A == A * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_14903","instance":14903,"id":218246,"goal":"lemma SetUnionAssoc_14903(U: set, T: set, A: set)\n ensures (U + T) + A == U + (T + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_14904","instance":14904,"id":218247,"goal":"lemma SetSubsetRefl_14904(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_14905","instance":14905,"id":218248,"goal":"lemma SetSubsetTrans_14905(U: set, T: set, A: set)\n requires U <= T && T <= A\n ensures U <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_14906","instance":14906,"id":218249,"goal":"lemma SetUnionEmpty_14906(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_14907","instance":14907,"id":218250,"goal":"lemma SetInterEmpty_14907(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_14908","instance":14908,"id":218251,"goal":"lemma SetInterSubset_14908(A: set, T: set)\n ensures A * T <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_14909","instance":14909,"id":218252,"goal":"lemma SetCardSubset_14909(U: set, S: set)\n requires U <= S\n ensures |U| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_14910","instance":14910,"id":218253,"goal":"lemma SetUnionCard_14910(A: set, B: set)\n requires A * B == {}\n ensures |A + B| == |A| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_14911","instance":14911,"id":218254,"goal":"lemma SetUnionComm_14911(A: set, T: set)\n ensures A + T == T + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_14912","instance":14912,"id":218255,"goal":"lemma SetInterComm_14912(S: set, A: set)\n ensures S * A == A * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_14913","instance":14913,"id":218256,"goal":"lemma SetUnionAssoc_14913(B: set, U: set, S: set)\n ensures (B + U) + S == B + (U + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_14914","instance":14914,"id":218257,"goal":"lemma SetSubsetRefl_14914(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_14915","instance":14915,"id":218258,"goal":"lemma SetSubsetTrans_14915(S: set, A: set, T: set)\n requires S <= A && A <= T\n ensures S <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_14916","instance":14916,"id":218259,"goal":"lemma SetUnionEmpty_14916(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_14917","instance":14917,"id":218260,"goal":"lemma SetInterEmpty_14917(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_14918","instance":14918,"id":218261,"goal":"lemma SetInterSubset_14918(U: set, A: set)\n ensures U * A <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_14919","instance":14919,"id":218262,"goal":"lemma SetCardSubset_14919(S: set, U: set)\n requires S <= U\n ensures |S| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_14920","instance":14920,"id":218263,"goal":"lemma SetUnionCard_14920(B: set, T: set)\n requires B * T == {}\n ensures |B + T| == |B| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_14921","instance":14921,"id":218264,"goal":"lemma SetUnionComm_14921(T: set, B: set)\n ensures T + B == B + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_14922","instance":14922,"id":218265,"goal":"lemma SetInterComm_14922(A: set, U: set)\n ensures A * U == U * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_14923","instance":14923,"id":218266,"goal":"lemma SetUnionAssoc_14923(U: set, B: set, S: set)\n ensures (U + B) + S == U + (B + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_14924","instance":14924,"id":218267,"goal":"lemma SetSubsetRefl_14924(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_14925","instance":14925,"id":218268,"goal":"lemma SetSubsetTrans_14925(T: set, B: set, A: set)\n requires T <= B && B <= A\n ensures T <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_14926","instance":14926,"id":218269,"goal":"lemma SetUnionEmpty_14926(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_14927","instance":14927,"id":218270,"goal":"lemma SetInterEmpty_14927(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_14928","instance":14928,"id":218271,"goal":"lemma SetInterSubset_14928(A: set, S: set)\n ensures A * S <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_14929","instance":14929,"id":218272,"goal":"lemma SetCardSubset_14929(A: set, T: set)\n requires A <= T\n ensures |A| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_14930","instance":14930,"id":218273,"goal":"lemma SetUnionCard_14930(A: set, T: set)\n requires A * T == {}\n ensures |A + T| == |A| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_14931","instance":14931,"id":218274,"goal":"lemma SetUnionComm_14931(U: set, B: set)\n ensures U + B == B + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_14932","instance":14932,"id":218275,"goal":"lemma SetInterComm_14932(T: set, U: set)\n ensures T * U == U * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_14933","instance":14933,"id":218276,"goal":"lemma SetUnionAssoc_14933(A: set, T: set, S: set)\n ensures (A + T) + S == A + (T + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_14934","instance":14934,"id":218277,"goal":"lemma SetSubsetRefl_14934(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_14935","instance":14935,"id":218278,"goal":"lemma SetSubsetTrans_14935(T: set, A: set, B: set)\n requires T <= A && A <= B\n ensures T <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_14936","instance":14936,"id":218279,"goal":"lemma SetUnionEmpty_14936(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_14937","instance":14937,"id":218280,"goal":"lemma SetInterEmpty_14937(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_14938","instance":14938,"id":218281,"goal":"lemma SetInterSubset_14938(S: set, U: set)\n ensures S * U <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_14939","instance":14939,"id":218282,"goal":"lemma SetCardSubset_14939(U: set, S: set)\n requires U <= S\n ensures |U| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_14940","instance":14940,"id":218283,"goal":"lemma SetUnionCard_14940(T: set, U: set)\n requires T * U == {}\n ensures |T + U| == |T| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_14941","instance":14941,"id":218284,"goal":"lemma SetUnionComm_14941(U: set, B: set)\n ensures U + B == B + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_14942","instance":14942,"id":218285,"goal":"lemma SetInterComm_14942(T: set, A: set)\n ensures T * A == A * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_14943","instance":14943,"id":218286,"goal":"lemma SetUnionAssoc_14943(B: set, S: set, U: set)\n ensures (B + S) + U == B + (S + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_14944","instance":14944,"id":218287,"goal":"lemma SetSubsetRefl_14944(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_14945","instance":14945,"id":218288,"goal":"lemma SetSubsetTrans_14945(S: set, T: set, U: set)\n requires S <= T && T <= U\n ensures S <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_14946","instance":14946,"id":218289,"goal":"lemma SetUnionEmpty_14946(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_14947","instance":14947,"id":218290,"goal":"lemma SetInterEmpty_14947(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_14948","instance":14948,"id":218291,"goal":"lemma SetInterSubset_14948(T: set, B: set)\n ensures T * B <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_14949","instance":14949,"id":218292,"goal":"lemma SetCardSubset_14949(B: set, T: set)\n requires B <= T\n ensures |B| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_14950","instance":14950,"id":218293,"goal":"lemma SetUnionCard_14950(B: set, T: set)\n requires B * T == {}\n ensures |B + T| == |B| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_14951","instance":14951,"id":218294,"goal":"lemma SetUnionComm_14951(U: set, S: set)\n ensures U + S == S + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_14952","instance":14952,"id":218295,"goal":"lemma SetInterComm_14952(U: set, T: set)\n ensures U * T == T * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_14953","instance":14953,"id":218296,"goal":"lemma SetUnionAssoc_14953(T: set, S: set, B: set)\n ensures (T + S) + B == T + (S + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_14954","instance":14954,"id":218297,"goal":"lemma SetSubsetRefl_14954(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_14955","instance":14955,"id":218298,"goal":"lemma SetSubsetTrans_14955(B: set, S: set, A: set)\n requires B <= S && S <= A\n ensures B <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_14956","instance":14956,"id":218299,"goal":"lemma SetUnionEmpty_14956(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_14957","instance":14957,"id":218300,"goal":"lemma SetInterEmpty_14957(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_14958","instance":14958,"id":218301,"goal":"lemma SetInterSubset_14958(A: set, T: set)\n ensures A * T <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_14959","instance":14959,"id":218302,"goal":"lemma SetCardSubset_14959(A: set, T: set)\n requires A <= T\n ensures |A| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_14960","instance":14960,"id":218303,"goal":"lemma SetUnionCard_14960(S: set, U: set)\n requires S * U == {}\n ensures |S + U| == |S| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_14961","instance":14961,"id":218304,"goal":"lemma SetUnionComm_14961(T: set, U: set)\n ensures T + U == U + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_14962","instance":14962,"id":218305,"goal":"lemma SetInterComm_14962(T: set, A: set)\n ensures T * A == A * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_14963","instance":14963,"id":218306,"goal":"lemma SetUnionAssoc_14963(S: set, B: set, U: set)\n ensures (S + B) + U == S + (B + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_14964","instance":14964,"id":218307,"goal":"lemma SetSubsetRefl_14964(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_14965","instance":14965,"id":218308,"goal":"lemma SetSubsetTrans_14965(U: set, T: set, B: set)\n requires U <= T && T <= B\n ensures U <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_14966","instance":14966,"id":218309,"goal":"lemma SetUnionEmpty_14966(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_14967","instance":14967,"id":218310,"goal":"lemma SetInterEmpty_14967(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_14968","instance":14968,"id":218311,"goal":"lemma SetInterSubset_14968(S: set, A: set)\n ensures S * A <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_14969","instance":14969,"id":218312,"goal":"lemma SetCardSubset_14969(S: set, B: set)\n requires S <= B\n ensures |S| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_14970","instance":14970,"id":218313,"goal":"lemma SetUnionCard_14970(B: set, A: set)\n requires B * A == {}\n ensures |B + A| == |B| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_14971","instance":14971,"id":218314,"goal":"lemma SetUnionComm_14971(B: set, A: set)\n ensures B + A == A + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_14972","instance":14972,"id":218315,"goal":"lemma SetInterComm_14972(A: set, T: set)\n ensures A * T == T * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_14973","instance":14973,"id":218316,"goal":"lemma SetUnionAssoc_14973(S: set, U: set, T: set)\n ensures (S + U) + T == S + (U + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_14974","instance":14974,"id":218317,"goal":"lemma SetSubsetRefl_14974(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_14975","instance":14975,"id":218318,"goal":"lemma SetSubsetTrans_14975(S: set, U: set, B: set)\n requires S <= U && U <= B\n ensures S <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_14976","instance":14976,"id":218319,"goal":"lemma SetUnionEmpty_14976(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_14977","instance":14977,"id":218320,"goal":"lemma SetInterEmpty_14977(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_14978","instance":14978,"id":218321,"goal":"lemma SetInterSubset_14978(T: set, U: set)\n ensures T * U <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_14979","instance":14979,"id":218322,"goal":"lemma SetCardSubset_14979(A: set, T: set)\n requires A <= T\n ensures |A| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_14980","instance":14980,"id":218323,"goal":"lemma SetUnionCard_14980(A: set, T: set)\n requires A * T == {}\n ensures |A + T| == |A| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_14981","instance":14981,"id":218324,"goal":"lemma SetUnionComm_14981(S: set, U: set)\n ensures S + U == U + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_14982","instance":14982,"id":218325,"goal":"lemma SetInterComm_14982(B: set, U: set)\n ensures B * U == U * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_14983","instance":14983,"id":218326,"goal":"lemma SetUnionAssoc_14983(U: set, S: set, A: set)\n ensures (U + S) + A == U + (S + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_14984","instance":14984,"id":218327,"goal":"lemma SetSubsetRefl_14984(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_14985","instance":14985,"id":218328,"goal":"lemma SetSubsetTrans_14985(U: set, A: set, B: set)\n requires U <= A && A <= B\n ensures U <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_14986","instance":14986,"id":218329,"goal":"lemma SetUnionEmpty_14986(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_14987","instance":14987,"id":218330,"goal":"lemma SetInterEmpty_14987(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_14988","instance":14988,"id":218331,"goal":"lemma SetInterSubset_14988(A: set, T: set)\n ensures A * T <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_14989","instance":14989,"id":218332,"goal":"lemma SetCardSubset_14989(B: set, T: set)\n requires B <= T\n ensures |B| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_14990","instance":14990,"id":218333,"goal":"lemma SetUnionCard_14990(B: set, T: set)\n requires B * T == {}\n ensures |B + T| == |B| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_14991","instance":14991,"id":218334,"goal":"lemma SetUnionComm_14991(U: set, A: set)\n ensures U + A == A + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_14992","instance":14992,"id":218335,"goal":"lemma SetInterComm_14992(T: set, S: set)\n ensures T * S == S * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_14993","instance":14993,"id":218336,"goal":"lemma SetUnionAssoc_14993(U: set, A: set, B: set)\n ensures (U + A) + B == U + (A + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_14994","instance":14994,"id":218337,"goal":"lemma SetSubsetRefl_14994(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_14995","instance":14995,"id":218338,"goal":"lemma SetSubsetTrans_14995(U: set, A: set, B: set)\n requires U <= A && A <= B\n ensures U <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_14996","instance":14996,"id":218339,"goal":"lemma SetUnionEmpty_14996(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_14997","instance":14997,"id":218340,"goal":"lemma SetInterEmpty_14997(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_14998","instance":14998,"id":218341,"goal":"lemma SetInterSubset_14998(B: set, A: set)\n ensures B * A <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_14999","instance":14999,"id":218342,"goal":"lemma SetCardSubset_14999(A: set, B: set)\n requires A <= B\n ensures |A| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_15000","instance":15000,"id":218343,"goal":"lemma SetUnionCard_15000(S: set, A: set)\n requires S * A == {}\n ensures |S + A| == |S| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_15001","instance":15001,"id":218344,"goal":"lemma SetUnionComm_15001(U: set, A: set)\n ensures U + A == A + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_15002","instance":15002,"id":218345,"goal":"lemma SetInterComm_15002(U: set, T: set)\n ensures U * T == T * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_15003","instance":15003,"id":218346,"goal":"lemma SetUnionAssoc_15003(A: set, B: set, T: set)\n ensures (A + B) + T == A + (B + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_15004","instance":15004,"id":218347,"goal":"lemma SetSubsetRefl_15004(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_15005","instance":15005,"id":218348,"goal":"lemma SetSubsetTrans_15005(S: set, T: set, B: set)\n requires S <= T && T <= B\n ensures S <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_15006","instance":15006,"id":218349,"goal":"lemma SetUnionEmpty_15006(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_15007","instance":15007,"id":218350,"goal":"lemma SetInterEmpty_15007(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_15008","instance":15008,"id":218351,"goal":"lemma SetInterSubset_15008(A: set, B: set)\n ensures A * B <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_15009","instance":15009,"id":218352,"goal":"lemma SetCardSubset_15009(U: set, A: set)\n requires U <= A\n ensures |U| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_15010","instance":15010,"id":218353,"goal":"lemma SetUnionCard_15010(T: set, B: set)\n requires T * B == {}\n ensures |T + B| == |T| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_15011","instance":15011,"id":218354,"goal":"lemma SetUnionComm_15011(A: set, U: set)\n ensures A + U == U + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_15012","instance":15012,"id":218355,"goal":"lemma SetInterComm_15012(B: set, T: set)\n ensures B * T == T * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_15013","instance":15013,"id":218356,"goal":"lemma SetUnionAssoc_15013(T: set, B: set, A: set)\n ensures (T + B) + A == T + (B + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_15014","instance":15014,"id":218357,"goal":"lemma SetSubsetRefl_15014(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_15015","instance":15015,"id":218358,"goal":"lemma SetSubsetTrans_15015(S: set, B: set, T: set)\n requires S <= B && B <= T\n ensures S <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_15016","instance":15016,"id":218359,"goal":"lemma SetUnionEmpty_15016(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_15017","instance":15017,"id":218360,"goal":"lemma SetInterEmpty_15017(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_15018","instance":15018,"id":218361,"goal":"lemma SetInterSubset_15018(B: set, A: set)\n ensures B * A <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_15019","instance":15019,"id":218362,"goal":"lemma SetCardSubset_15019(B: set, U: set)\n requires B <= U\n ensures |B| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_15020","instance":15020,"id":218363,"goal":"lemma SetUnionCard_15020(B: set, U: set)\n requires B * U == {}\n ensures |B + U| == |B| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_15021","instance":15021,"id":218364,"goal":"lemma SetUnionComm_15021(A: set, S: set)\n ensures A + S == S + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_15022","instance":15022,"id":218365,"goal":"lemma SetInterComm_15022(B: set, S: set)\n ensures B * S == S * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_15023","instance":15023,"id":218366,"goal":"lemma SetUnionAssoc_15023(B: set, A: set, T: set)\n ensures (B + A) + T == B + (A + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_15024","instance":15024,"id":218367,"goal":"lemma SetSubsetRefl_15024(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_15025","instance":15025,"id":218368,"goal":"lemma SetSubsetTrans_15025(A: set, B: set, T: set)\n requires A <= B && B <= T\n ensures A <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_15026","instance":15026,"id":218369,"goal":"lemma SetUnionEmpty_15026(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_15027","instance":15027,"id":218370,"goal":"lemma SetInterEmpty_15027(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_15028","instance":15028,"id":218371,"goal":"lemma SetInterSubset_15028(B: set, T: set)\n ensures B * T <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_15029","instance":15029,"id":218372,"goal":"lemma SetCardSubset_15029(S: set, U: set)\n requires S <= U\n ensures |S| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_15030","instance":15030,"id":218373,"goal":"lemma SetUnionCard_15030(A: set, S: set)\n requires A * S == {}\n ensures |A + S| == |A| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_15031","instance":15031,"id":218374,"goal":"lemma SetUnionComm_15031(A: set, S: set)\n ensures A + S == S + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_15032","instance":15032,"id":218375,"goal":"lemma SetInterComm_15032(S: set, B: set)\n ensures S * B == B * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_15033","instance":15033,"id":218376,"goal":"lemma SetUnionAssoc_15033(S: set, T: set, A: set)\n ensures (S + T) + A == S + (T + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_15034","instance":15034,"id":218377,"goal":"lemma SetSubsetRefl_15034(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_15035","instance":15035,"id":218378,"goal":"lemma SetSubsetTrans_15035(T: set, A: set, B: set)\n requires T <= A && A <= B\n ensures T <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_15036","instance":15036,"id":218379,"goal":"lemma SetUnionEmpty_15036(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_15037","instance":15037,"id":218380,"goal":"lemma SetInterEmpty_15037(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_15038","instance":15038,"id":218381,"goal":"lemma SetInterSubset_15038(U: set, T: set)\n ensures U * T <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_15039","instance":15039,"id":218382,"goal":"lemma SetCardSubset_15039(B: set, A: set)\n requires B <= A\n ensures |B| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_15040","instance":15040,"id":218383,"goal":"lemma SetUnionCard_15040(S: set, A: set)\n requires S * A == {}\n ensures |S + A| == |S| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_15041","instance":15041,"id":218384,"goal":"lemma SetUnionComm_15041(U: set, A: set)\n ensures U + A == A + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_15042","instance":15042,"id":218385,"goal":"lemma SetInterComm_15042(B: set, U: set)\n ensures B * U == U * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_15043","instance":15043,"id":218386,"goal":"lemma SetUnionAssoc_15043(T: set, A: set, S: set)\n ensures (T + A) + S == T + (A + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_15044","instance":15044,"id":218387,"goal":"lemma SetSubsetRefl_15044(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_15045","instance":15045,"id":218388,"goal":"lemma SetSubsetTrans_15045(U: set, B: set, S: set)\n requires U <= B && B <= S\n ensures U <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_15046","instance":15046,"id":218389,"goal":"lemma SetUnionEmpty_15046(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_15047","instance":15047,"id":218390,"goal":"lemma SetInterEmpty_15047(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_15048","instance":15048,"id":218391,"goal":"lemma SetInterSubset_15048(A: set, T: set)\n ensures A * T <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_15049","instance":15049,"id":218392,"goal":"lemma SetCardSubset_15049(T: set, A: set)\n requires T <= A\n ensures |T| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_15050","instance":15050,"id":218393,"goal":"lemma SetUnionCard_15050(S: set, U: set)\n requires S * U == {}\n ensures |S + U| == |S| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_15051","instance":15051,"id":218394,"goal":"lemma SetUnionComm_15051(B: set, A: set)\n ensures B + A == A + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_15052","instance":15052,"id":218395,"goal":"lemma SetInterComm_15052(A: set, B: set)\n ensures A * B == B * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_15053","instance":15053,"id":218396,"goal":"lemma SetUnionAssoc_15053(A: set, B: set, T: set)\n ensures (A + B) + T == A + (B + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_15054","instance":15054,"id":218397,"goal":"lemma SetSubsetRefl_15054(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_15055","instance":15055,"id":218398,"goal":"lemma SetSubsetTrans_15055(S: set, A: set, T: set)\n requires S <= A && A <= T\n ensures S <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_15056","instance":15056,"id":218399,"goal":"lemma SetUnionEmpty_15056(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_15057","instance":15057,"id":218400,"goal":"lemma SetInterEmpty_15057(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_15058","instance":15058,"id":218401,"goal":"lemma SetInterSubset_15058(A: set, S: set)\n ensures A * S <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_15059","instance":15059,"id":218402,"goal":"lemma SetCardSubset_15059(B: set, U: set)\n requires B <= U\n ensures |B| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_15060","instance":15060,"id":218403,"goal":"lemma SetUnionCard_15060(T: set, A: set)\n requires T * A == {}\n ensures |T + A| == |T| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_15061","instance":15061,"id":218404,"goal":"lemma SetUnionComm_15061(A: set, T: set)\n ensures A + T == T + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_15062","instance":15062,"id":218405,"goal":"lemma SetInterComm_15062(U: set, T: set)\n ensures U * T == T * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_15063","instance":15063,"id":218406,"goal":"lemma SetUnionAssoc_15063(A: set, U: set, B: set)\n ensures (A + U) + B == A + (U + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_15064","instance":15064,"id":218407,"goal":"lemma SetSubsetRefl_15064(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_15065","instance":15065,"id":218408,"goal":"lemma SetSubsetTrans_15065(S: set, A: set, B: set)\n requires S <= A && A <= B\n ensures S <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_15066","instance":15066,"id":218409,"goal":"lemma SetUnionEmpty_15066(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_15067","instance":15067,"id":218410,"goal":"lemma SetInterEmpty_15067(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_15068","instance":15068,"id":218411,"goal":"lemma SetInterSubset_15068(B: set, T: set)\n ensures B * T <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_15069","instance":15069,"id":218412,"goal":"lemma SetCardSubset_15069(U: set, T: set)\n requires U <= T\n ensures |U| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_15070","instance":15070,"id":218413,"goal":"lemma SetUnionCard_15070(B: set, A: set)\n requires B * A == {}\n ensures |B + A| == |B| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_15071","instance":15071,"id":218414,"goal":"lemma SetUnionComm_15071(B: set, T: set)\n ensures B + T == T + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_15072","instance":15072,"id":218415,"goal":"lemma SetInterComm_15072(A: set, T: set)\n ensures A * T == T * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_15073","instance":15073,"id":218416,"goal":"lemma SetUnionAssoc_15073(A: set, B: set, T: set)\n ensures (A + B) + T == A + (B + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_15074","instance":15074,"id":218417,"goal":"lemma SetSubsetRefl_15074(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_15075","instance":15075,"id":218418,"goal":"lemma SetSubsetTrans_15075(T: set, S: set, A: set)\n requires T <= S && S <= A\n ensures T <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_15076","instance":15076,"id":218419,"goal":"lemma SetUnionEmpty_15076(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_15077","instance":15077,"id":218420,"goal":"lemma SetInterEmpty_15077(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_15078","instance":15078,"id":218421,"goal":"lemma SetInterSubset_15078(S: set, U: set)\n ensures S * U <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_15079","instance":15079,"id":218422,"goal":"lemma SetCardSubset_15079(B: set, S: set)\n requires B <= S\n ensures |B| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_15080","instance":15080,"id":218423,"goal":"lemma SetUnionCard_15080(U: set, A: set)\n requires U * A == {}\n ensures |U + A| == |U| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_15081","instance":15081,"id":218424,"goal":"lemma SetUnionComm_15081(U: set, A: set)\n ensures U + A == A + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_15082","instance":15082,"id":218425,"goal":"lemma SetInterComm_15082(T: set, S: set)\n ensures T * S == S * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_15083","instance":15083,"id":218426,"goal":"lemma SetUnionAssoc_15083(B: set, U: set, T: set)\n ensures (B + U) + T == B + (U + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_15084","instance":15084,"id":218427,"goal":"lemma SetSubsetRefl_15084(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_15085","instance":15085,"id":218428,"goal":"lemma SetSubsetTrans_15085(U: set, A: set, T: set)\n requires U <= A && A <= T\n ensures U <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_15086","instance":15086,"id":218429,"goal":"lemma SetUnionEmpty_15086(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_15087","instance":15087,"id":218430,"goal":"lemma SetInterEmpty_15087(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_15088","instance":15088,"id":218431,"goal":"lemma SetInterSubset_15088(S: set, B: set)\n ensures S * B <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_15089","instance":15089,"id":218432,"goal":"lemma SetCardSubset_15089(A: set, U: set)\n requires A <= U\n ensures |A| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_15090","instance":15090,"id":218433,"goal":"lemma SetUnionCard_15090(S: set, A: set)\n requires S * A == {}\n ensures |S + A| == |S| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_15091","instance":15091,"id":218434,"goal":"lemma SetUnionComm_15091(B: set, S: set)\n ensures B + S == S + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_15092","instance":15092,"id":218435,"goal":"lemma SetInterComm_15092(A: set, T: set)\n ensures A * T == T * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_15093","instance":15093,"id":218436,"goal":"lemma SetUnionAssoc_15093(A: set, S: set, U: set)\n ensures (A + S) + U == A + (S + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_15094","instance":15094,"id":218437,"goal":"lemma SetSubsetRefl_15094(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_15095","instance":15095,"id":218438,"goal":"lemma SetSubsetTrans_15095(S: set, T: set, U: set)\n requires S <= T && T <= U\n ensures S <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_15096","instance":15096,"id":218439,"goal":"lemma SetUnionEmpty_15096(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_15097","instance":15097,"id":218440,"goal":"lemma SetInterEmpty_15097(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_15098","instance":15098,"id":218441,"goal":"lemma SetInterSubset_15098(B: set, U: set)\n ensures B * U <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_15099","instance":15099,"id":218442,"goal":"lemma SetCardSubset_15099(B: set, S: set)\n requires B <= S\n ensures |B| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_15100","instance":15100,"id":218443,"goal":"lemma SetUnionCard_15100(B: set, U: set)\n requires B * U == {}\n ensures |B + U| == |B| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_15101","instance":15101,"id":218444,"goal":"lemma SetUnionComm_15101(T: set, A: set)\n ensures T + A == A + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_15102","instance":15102,"id":218445,"goal":"lemma SetInterComm_15102(U: set, B: set)\n ensures U * B == B * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_15103","instance":15103,"id":218446,"goal":"lemma SetUnionAssoc_15103(S: set, U: set, B: set)\n ensures (S + U) + B == S + (U + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_15104","instance":15104,"id":218447,"goal":"lemma SetSubsetRefl_15104(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_15105","instance":15105,"id":218448,"goal":"lemma SetSubsetTrans_15105(S: set, T: set, B: set)\n requires S <= T && T <= B\n ensures S <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_15106","instance":15106,"id":218449,"goal":"lemma SetUnionEmpty_15106(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_15107","instance":15107,"id":218450,"goal":"lemma SetInterEmpty_15107(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_15108","instance":15108,"id":218451,"goal":"lemma SetInterSubset_15108(B: set, U: set)\n ensures B * U <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_15109","instance":15109,"id":218452,"goal":"lemma SetCardSubset_15109(S: set, U: set)\n requires S <= U\n ensures |S| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_15110","instance":15110,"id":218453,"goal":"lemma SetUnionCard_15110(B: set, U: set)\n requires B * U == {}\n ensures |B + U| == |B| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_15111","instance":15111,"id":218454,"goal":"lemma SetUnionComm_15111(A: set, B: set)\n ensures A + B == B + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_15112","instance":15112,"id":218455,"goal":"lemma SetInterComm_15112(A: set, S: set)\n ensures A * S == S * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_15113","instance":15113,"id":218456,"goal":"lemma SetUnionAssoc_15113(S: set, B: set, U: set)\n ensures (S + B) + U == S + (B + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_15114","instance":15114,"id":218457,"goal":"lemma SetSubsetRefl_15114(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_15115","instance":15115,"id":218458,"goal":"lemma SetSubsetTrans_15115(U: set, T: set, B: set)\n requires U <= T && T <= B\n ensures U <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_15116","instance":15116,"id":218459,"goal":"lemma SetUnionEmpty_15116(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_15117","instance":15117,"id":218460,"goal":"lemma SetInterEmpty_15117(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_15118","instance":15118,"id":218461,"goal":"lemma SetInterSubset_15118(T: set, A: set)\n ensures T * A <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_15119","instance":15119,"id":218462,"goal":"lemma SetCardSubset_15119(S: set, B: set)\n requires S <= B\n ensures |S| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_15120","instance":15120,"id":218463,"goal":"lemma SetUnionCard_15120(T: set, S: set)\n requires T * S == {}\n ensures |T + S| == |T| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_15121","instance":15121,"id":218464,"goal":"lemma SetUnionComm_15121(A: set, T: set)\n ensures A + T == T + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_15122","instance":15122,"id":218465,"goal":"lemma SetInterComm_15122(B: set, U: set)\n ensures B * U == U * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_15123","instance":15123,"id":218466,"goal":"lemma SetUnionAssoc_15123(T: set, U: set, S: set)\n ensures (T + U) + S == T + (U + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_15124","instance":15124,"id":218467,"goal":"lemma SetSubsetRefl_15124(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_15125","instance":15125,"id":218468,"goal":"lemma SetSubsetTrans_15125(B: set, U: set, S: set)\n requires B <= U && U <= S\n ensures B <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_15126","instance":15126,"id":218469,"goal":"lemma SetUnionEmpty_15126(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_15127","instance":15127,"id":218470,"goal":"lemma SetInterEmpty_15127(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_15128","instance":15128,"id":218471,"goal":"lemma SetInterSubset_15128(A: set, B: set)\n ensures A * B <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_15129","instance":15129,"id":218472,"goal":"lemma SetCardSubset_15129(T: set, A: set)\n requires T <= A\n ensures |T| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_15130","instance":15130,"id":218473,"goal":"lemma SetUnionCard_15130(T: set, U: set)\n requires T * U == {}\n ensures |T + U| == |T| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_15131","instance":15131,"id":218474,"goal":"lemma SetUnionComm_15131(T: set, A: set)\n ensures T + A == A + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_15132","instance":15132,"id":218475,"goal":"lemma SetInterComm_15132(U: set, S: set)\n ensures U * S == S * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_15133","instance":15133,"id":218476,"goal":"lemma SetUnionAssoc_15133(S: set, T: set, U: set)\n ensures (S + T) + U == S + (T + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_15134","instance":15134,"id":218477,"goal":"lemma SetSubsetRefl_15134(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_15135","instance":15135,"id":218478,"goal":"lemma SetSubsetTrans_15135(U: set, B: set, T: set)\n requires U <= B && B <= T\n ensures U <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_15136","instance":15136,"id":218479,"goal":"lemma SetUnionEmpty_15136(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_15137","instance":15137,"id":218480,"goal":"lemma SetInterEmpty_15137(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_15138","instance":15138,"id":218481,"goal":"lemma SetInterSubset_15138(B: set, S: set)\n ensures B * S <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_15139","instance":15139,"id":218482,"goal":"lemma SetCardSubset_15139(U: set, A: set)\n requires U <= A\n ensures |U| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_15140","instance":15140,"id":218483,"goal":"lemma SetUnionCard_15140(U: set, A: set)\n requires U * A == {}\n ensures |U + A| == |U| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_15141","instance":15141,"id":218484,"goal":"lemma SetUnionComm_15141(U: set, T: set)\n ensures U + T == T + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_15142","instance":15142,"id":218485,"goal":"lemma SetInterComm_15142(B: set, A: set)\n ensures B * A == A * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_15143","instance":15143,"id":218486,"goal":"lemma SetUnionAssoc_15143(U: set, A: set, T: set)\n ensures (U + A) + T == U + (A + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_15144","instance":15144,"id":218487,"goal":"lemma SetSubsetRefl_15144(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_15145","instance":15145,"id":218488,"goal":"lemma SetSubsetTrans_15145(U: set, B: set, A: set)\n requires U <= B && B <= A\n ensures U <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_15146","instance":15146,"id":218489,"goal":"lemma SetUnionEmpty_15146(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_15147","instance":15147,"id":218490,"goal":"lemma SetInterEmpty_15147(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_15148","instance":15148,"id":218491,"goal":"lemma SetInterSubset_15148(S: set, A: set)\n ensures S * A <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_15149","instance":15149,"id":218492,"goal":"lemma SetCardSubset_15149(U: set, T: set)\n requires U <= T\n ensures |U| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_15150","instance":15150,"id":218493,"goal":"lemma SetUnionCard_15150(T: set, S: set)\n requires T * S == {}\n ensures |T + S| == |T| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_15151","instance":15151,"id":218494,"goal":"lemma SetUnionComm_15151(U: set, T: set)\n ensures U + T == T + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_15152","instance":15152,"id":218495,"goal":"lemma SetInterComm_15152(B: set, S: set)\n ensures B * S == S * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_15153","instance":15153,"id":218496,"goal":"lemma SetUnionAssoc_15153(T: set, B: set, A: set)\n ensures (T + B) + A == T + (B + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_15154","instance":15154,"id":218497,"goal":"lemma SetSubsetRefl_15154(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_15155","instance":15155,"id":218498,"goal":"lemma SetSubsetTrans_15155(T: set, U: set, A: set)\n requires T <= U && U <= A\n ensures T <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_15156","instance":15156,"id":218499,"goal":"lemma SetUnionEmpty_15156(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_15157","instance":15157,"id":218500,"goal":"lemma SetInterEmpty_15157(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_15158","instance":15158,"id":218501,"goal":"lemma SetInterSubset_15158(T: set, U: set)\n ensures T * U <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_15159","instance":15159,"id":218502,"goal":"lemma SetCardSubset_15159(A: set, T: set)\n requires A <= T\n ensures |A| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_15160","instance":15160,"id":218503,"goal":"lemma SetUnionCard_15160(B: set, A: set)\n requires B * A == {}\n ensures |B + A| == |B| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_15161","instance":15161,"id":218504,"goal":"lemma SetUnionComm_15161(T: set, A: set)\n ensures T + A == A + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_15162","instance":15162,"id":218505,"goal":"lemma SetInterComm_15162(S: set, U: set)\n ensures S * U == U * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_15163","instance":15163,"id":218506,"goal":"lemma SetUnionAssoc_15163(B: set, T: set, U: set)\n ensures (B + T) + U == B + (T + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_15164","instance":15164,"id":218507,"goal":"lemma SetSubsetRefl_15164(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_15165","instance":15165,"id":218508,"goal":"lemma SetSubsetTrans_15165(S: set, A: set, T: set)\n requires S <= A && A <= T\n ensures S <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_15166","instance":15166,"id":218509,"goal":"lemma SetUnionEmpty_15166(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_15167","instance":15167,"id":218510,"goal":"lemma SetInterEmpty_15167(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_15168","instance":15168,"id":218511,"goal":"lemma SetInterSubset_15168(S: set, T: set)\n ensures S * T <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_15169","instance":15169,"id":218512,"goal":"lemma SetCardSubset_15169(S: set, B: set)\n requires S <= B\n ensures |S| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_15170","instance":15170,"id":218513,"goal":"lemma SetUnionCard_15170(U: set, S: set)\n requires U * S == {}\n ensures |U + S| == |U| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_15171","instance":15171,"id":218514,"goal":"lemma SetUnionComm_15171(B: set, U: set)\n ensures B + U == U + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_15172","instance":15172,"id":218515,"goal":"lemma SetInterComm_15172(A: set, U: set)\n ensures A * U == U * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_15173","instance":15173,"id":218516,"goal":"lemma SetUnionAssoc_15173(B: set, S: set, T: set)\n ensures (B + S) + T == B + (S + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_15174","instance":15174,"id":218517,"goal":"lemma SetSubsetRefl_15174(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_15175","instance":15175,"id":218518,"goal":"lemma SetSubsetTrans_15175(U: set, A: set, T: set)\n requires U <= A && A <= T\n ensures U <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_15176","instance":15176,"id":218519,"goal":"lemma SetUnionEmpty_15176(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_15177","instance":15177,"id":218520,"goal":"lemma SetInterEmpty_15177(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_15178","instance":15178,"id":218521,"goal":"lemma SetInterSubset_15178(U: set, S: set)\n ensures U * S <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_15179","instance":15179,"id":218522,"goal":"lemma SetCardSubset_15179(A: set, B: set)\n requires A <= B\n ensures |A| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_15180","instance":15180,"id":218523,"goal":"lemma SetUnionCard_15180(A: set, T: set)\n requires A * T == {}\n ensures |A + T| == |A| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_15181","instance":15181,"id":218524,"goal":"lemma SetUnionComm_15181(T: set, A: set)\n ensures T + A == A + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_15182","instance":15182,"id":218525,"goal":"lemma SetInterComm_15182(S: set, A: set)\n ensures S * A == A * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_15183","instance":15183,"id":218526,"goal":"lemma SetUnionAssoc_15183(S: set, U: set, T: set)\n ensures (S + U) + T == S + (U + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_15184","instance":15184,"id":218527,"goal":"lemma SetSubsetRefl_15184(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_15185","instance":15185,"id":218528,"goal":"lemma SetSubsetTrans_15185(B: set, U: set, S: set)\n requires B <= U && U <= S\n ensures B <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_15186","instance":15186,"id":218529,"goal":"lemma SetUnionEmpty_15186(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_15187","instance":15187,"id":218530,"goal":"lemma SetInterEmpty_15187(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_15188","instance":15188,"id":218531,"goal":"lemma SetInterSubset_15188(A: set, S: set)\n ensures A * S <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_15189","instance":15189,"id":218532,"goal":"lemma SetCardSubset_15189(B: set, T: set)\n requires B <= T\n ensures |B| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_15190","instance":15190,"id":218533,"goal":"lemma SetUnionCard_15190(U: set, B: set)\n requires U * B == {}\n ensures |U + B| == |U| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_15191","instance":15191,"id":218534,"goal":"lemma SetUnionComm_15191(U: set, B: set)\n ensures U + B == B + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_15192","instance":15192,"id":218535,"goal":"lemma SetInterComm_15192(B: set, U: set)\n ensures B * U == U * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_15193","instance":15193,"id":218536,"goal":"lemma SetUnionAssoc_15193(A: set, B: set, U: set)\n ensures (A + B) + U == A + (B + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_15194","instance":15194,"id":218537,"goal":"lemma SetSubsetRefl_15194(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_15195","instance":15195,"id":218538,"goal":"lemma SetSubsetTrans_15195(A: set, T: set, S: set)\n requires A <= T && T <= S\n ensures A <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_15196","instance":15196,"id":218539,"goal":"lemma SetUnionEmpty_15196(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_15197","instance":15197,"id":218540,"goal":"lemma SetInterEmpty_15197(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_15198","instance":15198,"id":218541,"goal":"lemma SetInterSubset_15198(T: set, S: set)\n ensures T * S <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_15199","instance":15199,"id":218542,"goal":"lemma SetCardSubset_15199(T: set, U: set)\n requires T <= U\n ensures |T| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_15200","instance":15200,"id":218543,"goal":"lemma SetUnionCard_15200(A: set, U: set)\n requires A * U == {}\n ensures |A + U| == |A| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_15201","instance":15201,"id":218544,"goal":"lemma SetUnionComm_15201(T: set, A: set)\n ensures T + A == A + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_15202","instance":15202,"id":218545,"goal":"lemma SetInterComm_15202(U: set, S: set)\n ensures U * S == S * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_15203","instance":15203,"id":218546,"goal":"lemma SetUnionAssoc_15203(T: set, B: set, S: set)\n ensures (T + B) + S == T + (B + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_15204","instance":15204,"id":218547,"goal":"lemma SetSubsetRefl_15204(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_15205","instance":15205,"id":218548,"goal":"lemma SetSubsetTrans_15205(S: set, B: set, U: set)\n requires S <= B && B <= U\n ensures S <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_15206","instance":15206,"id":218549,"goal":"lemma SetUnionEmpty_15206(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_15207","instance":15207,"id":218550,"goal":"lemma SetInterEmpty_15207(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_15208","instance":15208,"id":218551,"goal":"lemma SetInterSubset_15208(S: set, T: set)\n ensures S * T <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_15209","instance":15209,"id":218552,"goal":"lemma SetCardSubset_15209(U: set, S: set)\n requires U <= S\n ensures |U| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_15210","instance":15210,"id":218553,"goal":"lemma SetUnionCard_15210(T: set, B: set)\n requires T * B == {}\n ensures |T + B| == |T| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_15211","instance":15211,"id":218554,"goal":"lemma SetUnionComm_15211(T: set, A: set)\n ensures T + A == A + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_15212","instance":15212,"id":218555,"goal":"lemma SetInterComm_15212(S: set, A: set)\n ensures S * A == A * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_15213","instance":15213,"id":218556,"goal":"lemma SetUnionAssoc_15213(S: set, B: set, T: set)\n ensures (S + B) + T == S + (B + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_15214","instance":15214,"id":218557,"goal":"lemma SetSubsetRefl_15214(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_15215","instance":15215,"id":218558,"goal":"lemma SetSubsetTrans_15215(S: set, T: set, A: set)\n requires S <= T && T <= A\n ensures S <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_15216","instance":15216,"id":218559,"goal":"lemma SetUnionEmpty_15216(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_15217","instance":15217,"id":218560,"goal":"lemma SetInterEmpty_15217(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_15218","instance":15218,"id":218561,"goal":"lemma SetInterSubset_15218(A: set, B: set)\n ensures A * B <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_15219","instance":15219,"id":218562,"goal":"lemma SetCardSubset_15219(A: set, T: set)\n requires A <= T\n ensures |A| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_15220","instance":15220,"id":218563,"goal":"lemma SetUnionCard_15220(T: set, A: set)\n requires T * A == {}\n ensures |T + A| == |T| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_15221","instance":15221,"id":218564,"goal":"lemma SetUnionComm_15221(T: set, S: set)\n ensures T + S == S + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_15222","instance":15222,"id":218565,"goal":"lemma SetInterComm_15222(T: set, S: set)\n ensures T * S == S * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_15223","instance":15223,"id":218566,"goal":"lemma SetUnionAssoc_15223(U: set, S: set, B: set)\n ensures (U + S) + B == U + (S + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_15224","instance":15224,"id":218567,"goal":"lemma SetSubsetRefl_15224(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_15225","instance":15225,"id":218568,"goal":"lemma SetSubsetTrans_15225(T: set, U: set, S: set)\n requires T <= U && U <= S\n ensures T <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_15226","instance":15226,"id":218569,"goal":"lemma SetUnionEmpty_15226(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_15227","instance":15227,"id":218570,"goal":"lemma SetInterEmpty_15227(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_15228","instance":15228,"id":218571,"goal":"lemma SetInterSubset_15228(B: set, T: set)\n ensures B * T <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_15229","instance":15229,"id":218572,"goal":"lemma SetCardSubset_15229(A: set, S: set)\n requires A <= S\n ensures |A| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_15230","instance":15230,"id":218573,"goal":"lemma SetUnionCard_15230(A: set, U: set)\n requires A * U == {}\n ensures |A + U| == |A| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_15231","instance":15231,"id":218574,"goal":"lemma SetUnionComm_15231(A: set, S: set)\n ensures A + S == S + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_15232","instance":15232,"id":218575,"goal":"lemma SetInterComm_15232(A: set, S: set)\n ensures A * S == S * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_15233","instance":15233,"id":218576,"goal":"lemma SetUnionAssoc_15233(A: set, T: set, S: set)\n ensures (A + T) + S == A + (T + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_15234","instance":15234,"id":218577,"goal":"lemma SetSubsetRefl_15234(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_15235","instance":15235,"id":218578,"goal":"lemma SetSubsetTrans_15235(U: set, S: set, B: set)\n requires U <= S && S <= B\n ensures U <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_15236","instance":15236,"id":218579,"goal":"lemma SetUnionEmpty_15236(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_15237","instance":15237,"id":218580,"goal":"lemma SetInterEmpty_15237(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_15238","instance":15238,"id":218581,"goal":"lemma SetInterSubset_15238(T: set, B: set)\n ensures T * B <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_15239","instance":15239,"id":218582,"goal":"lemma SetCardSubset_15239(B: set, S: set)\n requires B <= S\n ensures |B| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_15240","instance":15240,"id":218583,"goal":"lemma SetUnionCard_15240(B: set, A: set)\n requires B * A == {}\n ensures |B + A| == |B| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_15241","instance":15241,"id":218584,"goal":"lemma SetUnionComm_15241(B: set, S: set)\n ensures B + S == S + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_15242","instance":15242,"id":218585,"goal":"lemma SetInterComm_15242(S: set, A: set)\n ensures S * A == A * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_15243","instance":15243,"id":218586,"goal":"lemma SetUnionAssoc_15243(U: set, T: set, B: set)\n ensures (U + T) + B == U + (T + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_15244","instance":15244,"id":218587,"goal":"lemma SetSubsetRefl_15244(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_15245","instance":15245,"id":218588,"goal":"lemma SetSubsetTrans_15245(A: set, T: set, S: set)\n requires A <= T && T <= S\n ensures A <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_15246","instance":15246,"id":218589,"goal":"lemma SetUnionEmpty_15246(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_15247","instance":15247,"id":218590,"goal":"lemma SetInterEmpty_15247(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_15248","instance":15248,"id":218591,"goal":"lemma SetInterSubset_15248(U: set, T: set)\n ensures U * T <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_15249","instance":15249,"id":218592,"goal":"lemma SetCardSubset_15249(A: set, S: set)\n requires A <= S\n ensures |A| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_15250","instance":15250,"id":218593,"goal":"lemma SetUnionCard_15250(S: set, T: set)\n requires S * T == {}\n ensures |S + T| == |S| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_15251","instance":15251,"id":218594,"goal":"lemma SetUnionComm_15251(B: set, A: set)\n ensures B + A == A + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_15252","instance":15252,"id":218595,"goal":"lemma SetInterComm_15252(U: set, B: set)\n ensures U * B == B * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_15253","instance":15253,"id":218596,"goal":"lemma SetUnionAssoc_15253(T: set, B: set, U: set)\n ensures (T + B) + U == T + (B + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_15254","instance":15254,"id":218597,"goal":"lemma SetSubsetRefl_15254(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_15255","instance":15255,"id":218598,"goal":"lemma SetSubsetTrans_15255(S: set, A: set, U: set)\n requires S <= A && A <= U\n ensures S <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_15256","instance":15256,"id":218599,"goal":"lemma SetUnionEmpty_15256(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_15257","instance":15257,"id":218600,"goal":"lemma SetInterEmpty_15257(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_15258","instance":15258,"id":218601,"goal":"lemma SetInterSubset_15258(S: set, A: set)\n ensures S * A <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_15259","instance":15259,"id":218602,"goal":"lemma SetCardSubset_15259(S: set, T: set)\n requires S <= T\n ensures |S| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_15260","instance":15260,"id":218603,"goal":"lemma SetUnionCard_15260(U: set, T: set)\n requires U * T == {}\n ensures |U + T| == |U| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_15261","instance":15261,"id":218604,"goal":"lemma SetUnionComm_15261(U: set, S: set)\n ensures U + S == S + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_15262","instance":15262,"id":218605,"goal":"lemma SetInterComm_15262(A: set, S: set)\n ensures A * S == S * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_15263","instance":15263,"id":218606,"goal":"lemma SetUnionAssoc_15263(T: set, U: set, S: set)\n ensures (T + U) + S == T + (U + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_15264","instance":15264,"id":218607,"goal":"lemma SetSubsetRefl_15264(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_15265","instance":15265,"id":218608,"goal":"lemma SetSubsetTrans_15265(U: set, T: set, A: set)\n requires U <= T && T <= A\n ensures U <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_15266","instance":15266,"id":218609,"goal":"lemma SetUnionEmpty_15266(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_15267","instance":15267,"id":218610,"goal":"lemma SetInterEmpty_15267(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_15268","instance":15268,"id":218611,"goal":"lemma SetInterSubset_15268(B: set, T: set)\n ensures B * T <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_15269","instance":15269,"id":218612,"goal":"lemma SetCardSubset_15269(B: set, A: set)\n requires B <= A\n ensures |B| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_15270","instance":15270,"id":218613,"goal":"lemma SetUnionCard_15270(S: set, B: set)\n requires S * B == {}\n ensures |S + B| == |S| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_15271","instance":15271,"id":218614,"goal":"lemma SetUnionComm_15271(U: set, S: set)\n ensures U + S == S + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_15272","instance":15272,"id":218615,"goal":"lemma SetInterComm_15272(B: set, U: set)\n ensures B * U == U * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_15273","instance":15273,"id":218616,"goal":"lemma SetUnionAssoc_15273(U: set, B: set, A: set)\n ensures (U + B) + A == U + (B + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_15274","instance":15274,"id":218617,"goal":"lemma SetSubsetRefl_15274(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_15275","instance":15275,"id":218618,"goal":"lemma SetSubsetTrans_15275(S: set, T: set, B: set)\n requires S <= T && T <= B\n ensures S <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_15276","instance":15276,"id":218619,"goal":"lemma SetUnionEmpty_15276(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_15277","instance":15277,"id":218620,"goal":"lemma SetInterEmpty_15277(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_15278","instance":15278,"id":218621,"goal":"lemma SetInterSubset_15278(B: set, A: set)\n ensures B * A <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_15279","instance":15279,"id":218622,"goal":"lemma SetCardSubset_15279(A: set, B: set)\n requires A <= B\n ensures |A| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_15280","instance":15280,"id":218623,"goal":"lemma SetUnionCard_15280(B: set, S: set)\n requires B * S == {}\n ensures |B + S| == |B| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_15281","instance":15281,"id":218624,"goal":"lemma SetUnionComm_15281(B: set, T: set)\n ensures B + T == T + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_15282","instance":15282,"id":218625,"goal":"lemma SetInterComm_15282(A: set, U: set)\n ensures A * U == U * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_15283","instance":15283,"id":218626,"goal":"lemma SetUnionAssoc_15283(U: set, A: set, T: set)\n ensures (U + A) + T == U + (A + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_15284","instance":15284,"id":218627,"goal":"lemma SetSubsetRefl_15284(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_15285","instance":15285,"id":218628,"goal":"lemma SetSubsetTrans_15285(U: set, S: set, B: set)\n requires U <= S && S <= B\n ensures U <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_15286","instance":15286,"id":218629,"goal":"lemma SetUnionEmpty_15286(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_15287","instance":15287,"id":218630,"goal":"lemma SetInterEmpty_15287(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_15288","instance":15288,"id":218631,"goal":"lemma SetInterSubset_15288(S: set, B: set)\n ensures S * B <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_15289","instance":15289,"id":218632,"goal":"lemma SetCardSubset_15289(B: set, T: set)\n requires B <= T\n ensures |B| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_15290","instance":15290,"id":218633,"goal":"lemma SetUnionCard_15290(T: set, B: set)\n requires T * B == {}\n ensures |T + B| == |T| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_15291","instance":15291,"id":218634,"goal":"lemma SetUnionComm_15291(S: set, T: set)\n ensures S + T == T + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_15292","instance":15292,"id":218635,"goal":"lemma SetInterComm_15292(T: set, U: set)\n ensures T * U == U * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_15293","instance":15293,"id":218636,"goal":"lemma SetUnionAssoc_15293(S: set, B: set, U: set)\n ensures (S + B) + U == S + (B + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_15294","instance":15294,"id":218637,"goal":"lemma SetSubsetRefl_15294(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_15295","instance":15295,"id":218638,"goal":"lemma SetSubsetTrans_15295(U: set, T: set, B: set)\n requires U <= T && T <= B\n ensures U <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_15296","instance":15296,"id":218639,"goal":"lemma SetUnionEmpty_15296(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_15297","instance":15297,"id":218640,"goal":"lemma SetInterEmpty_15297(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_15298","instance":15298,"id":218641,"goal":"lemma SetInterSubset_15298(B: set, A: set)\n ensures B * A <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_15299","instance":15299,"id":218642,"goal":"lemma SetCardSubset_15299(U: set, A: set)\n requires U <= A\n ensures |U| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_15300","instance":15300,"id":218643,"goal":"lemma SetUnionCard_15300(B: set, U: set)\n requires B * U == {}\n ensures |B + U| == |B| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_15301","instance":15301,"id":218644,"goal":"lemma SetUnionComm_15301(T: set, B: set)\n ensures T + B == B + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_15302","instance":15302,"id":218645,"goal":"lemma SetInterComm_15302(A: set, S: set)\n ensures A * S == S * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_15303","instance":15303,"id":218646,"goal":"lemma SetUnionAssoc_15303(B: set, T: set, U: set)\n ensures (B + T) + U == B + (T + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_15304","instance":15304,"id":218647,"goal":"lemma SetSubsetRefl_15304(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_15305","instance":15305,"id":218648,"goal":"lemma SetSubsetTrans_15305(B: set, T: set, S: set)\n requires B <= T && T <= S\n ensures B <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_15306","instance":15306,"id":218649,"goal":"lemma SetUnionEmpty_15306(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_15307","instance":15307,"id":218650,"goal":"lemma SetInterEmpty_15307(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_15308","instance":15308,"id":218651,"goal":"lemma SetInterSubset_15308(S: set, U: set)\n ensures S * U <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_15309","instance":15309,"id":218652,"goal":"lemma SetCardSubset_15309(T: set, S: set)\n requires T <= S\n ensures |T| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_15310","instance":15310,"id":218653,"goal":"lemma SetUnionCard_15310(B: set, U: set)\n requires B * U == {}\n ensures |B + U| == |B| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_15311","instance":15311,"id":218654,"goal":"lemma SetUnionComm_15311(T: set, S: set)\n ensures T + S == S + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_15312","instance":15312,"id":218655,"goal":"lemma SetInterComm_15312(U: set, B: set)\n ensures U * B == B * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_15313","instance":15313,"id":218656,"goal":"lemma SetUnionAssoc_15313(A: set, B: set, T: set)\n ensures (A + B) + T == A + (B + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_15314","instance":15314,"id":218657,"goal":"lemma SetSubsetRefl_15314(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_15315","instance":15315,"id":218658,"goal":"lemma SetSubsetTrans_15315(S: set, A: set, B: set)\n requires S <= A && A <= B\n ensures S <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_15316","instance":15316,"id":218659,"goal":"lemma SetUnionEmpty_15316(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_15317","instance":15317,"id":218660,"goal":"lemma SetInterEmpty_15317(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_15318","instance":15318,"id":218661,"goal":"lemma SetInterSubset_15318(U: set, T: set)\n ensures U * T <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_15319","instance":15319,"id":218662,"goal":"lemma SetCardSubset_15319(S: set, U: set)\n requires S <= U\n ensures |S| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_15320","instance":15320,"id":218663,"goal":"lemma SetUnionCard_15320(U: set, T: set)\n requires U * T == {}\n ensures |U + T| == |U| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_15321","instance":15321,"id":218664,"goal":"lemma SetUnionComm_15321(U: set, A: set)\n ensures U + A == A + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_15322","instance":15322,"id":218665,"goal":"lemma SetInterComm_15322(S: set, U: set)\n ensures S * U == U * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_15323","instance":15323,"id":218666,"goal":"lemma SetUnionAssoc_15323(S: set, B: set, T: set)\n ensures (S + B) + T == S + (B + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_15324","instance":15324,"id":218667,"goal":"lemma SetSubsetRefl_15324(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_15325","instance":15325,"id":218668,"goal":"lemma SetSubsetTrans_15325(A: set, S: set, U: set)\n requires A <= S && S <= U\n ensures A <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_15326","instance":15326,"id":218669,"goal":"lemma SetUnionEmpty_15326(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_15327","instance":15327,"id":218670,"goal":"lemma SetInterEmpty_15327(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_15328","instance":15328,"id":218671,"goal":"lemma SetInterSubset_15328(B: set, T: set)\n ensures B * T <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_15329","instance":15329,"id":218672,"goal":"lemma SetCardSubset_15329(U: set, B: set)\n requires U <= B\n ensures |U| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_15330","instance":15330,"id":218673,"goal":"lemma SetUnionCard_15330(T: set, U: set)\n requires T * U == {}\n ensures |T + U| == |T| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_15331","instance":15331,"id":218674,"goal":"lemma SetUnionComm_15331(A: set, T: set)\n ensures A + T == T + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_15332","instance":15332,"id":218675,"goal":"lemma SetInterComm_15332(A: set, T: set)\n ensures A * T == T * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_15333","instance":15333,"id":218676,"goal":"lemma SetUnionAssoc_15333(S: set, A: set, B: set)\n ensures (S + A) + B == S + (A + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_15334","instance":15334,"id":218677,"goal":"lemma SetSubsetRefl_15334(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_15335","instance":15335,"id":218678,"goal":"lemma SetSubsetTrans_15335(A: set, S: set, B: set)\n requires A <= S && S <= B\n ensures A <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_15336","instance":15336,"id":218679,"goal":"lemma SetUnionEmpty_15336(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_15337","instance":15337,"id":218680,"goal":"lemma SetInterEmpty_15337(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_15338","instance":15338,"id":218681,"goal":"lemma SetInterSubset_15338(A: set, S: set)\n ensures A * S <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_15339","instance":15339,"id":218682,"goal":"lemma SetCardSubset_15339(B: set, U: set)\n requires B <= U\n ensures |B| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_15340","instance":15340,"id":218683,"goal":"lemma SetUnionCard_15340(S: set, U: set)\n requires S * U == {}\n ensures |S + U| == |S| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_15341","instance":15341,"id":218684,"goal":"lemma SetUnionComm_15341(U: set, T: set)\n ensures U + T == T + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_15342","instance":15342,"id":218685,"goal":"lemma SetInterComm_15342(U: set, T: set)\n ensures U * T == T * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_15343","instance":15343,"id":218686,"goal":"lemma SetUnionAssoc_15343(T: set, B: set, U: set)\n ensures (T + B) + U == T + (B + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_15344","instance":15344,"id":218687,"goal":"lemma SetSubsetRefl_15344(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_15345","instance":15345,"id":218688,"goal":"lemma SetSubsetTrans_15345(U: set, B: set, S: set)\n requires U <= B && B <= S\n ensures U <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_15346","instance":15346,"id":218689,"goal":"lemma SetUnionEmpty_15346(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_15347","instance":15347,"id":218690,"goal":"lemma SetInterEmpty_15347(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_15348","instance":15348,"id":218691,"goal":"lemma SetInterSubset_15348(T: set, U: set)\n ensures T * U <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_15349","instance":15349,"id":218692,"goal":"lemma SetCardSubset_15349(T: set, S: set)\n requires T <= S\n ensures |T| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_15350","instance":15350,"id":218693,"goal":"lemma SetUnionCard_15350(S: set, U: set)\n requires S * U == {}\n ensures |S + U| == |S| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_15351","instance":15351,"id":218694,"goal":"lemma SetUnionComm_15351(A: set, B: set)\n ensures A + B == B + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_15352","instance":15352,"id":218695,"goal":"lemma SetInterComm_15352(A: set, B: set)\n ensures A * B == B * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_15353","instance":15353,"id":218696,"goal":"lemma SetUnionAssoc_15353(A: set, B: set, U: set)\n ensures (A + B) + U == A + (B + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_15354","instance":15354,"id":218697,"goal":"lemma SetSubsetRefl_15354(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_15355","instance":15355,"id":218698,"goal":"lemma SetSubsetTrans_15355(U: set, T: set, B: set)\n requires U <= T && T <= B\n ensures U <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_15356","instance":15356,"id":218699,"goal":"lemma SetUnionEmpty_15356(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_15357","instance":15357,"id":218700,"goal":"lemma SetInterEmpty_15357(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_15358","instance":15358,"id":218701,"goal":"lemma SetInterSubset_15358(U: set, A: set)\n ensures U * A <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_15359","instance":15359,"id":218702,"goal":"lemma SetCardSubset_15359(S: set, B: set)\n requires S <= B\n ensures |S| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_15360","instance":15360,"id":218703,"goal":"lemma SetUnionCard_15360(T: set, U: set)\n requires T * U == {}\n ensures |T + U| == |T| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_15361","instance":15361,"id":218704,"goal":"lemma SetUnionComm_15361(B: set, U: set)\n ensures B + U == U + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_15362","instance":15362,"id":218705,"goal":"lemma SetInterComm_15362(A: set, U: set)\n ensures A * U == U * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_15363","instance":15363,"id":218706,"goal":"lemma SetUnionAssoc_15363(S: set, B: set, U: set)\n ensures (S + B) + U == S + (B + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_15364","instance":15364,"id":218707,"goal":"lemma SetSubsetRefl_15364(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_15365","instance":15365,"id":218708,"goal":"lemma SetSubsetTrans_15365(S: set, B: set, U: set)\n requires S <= B && B <= U\n ensures S <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_15366","instance":15366,"id":218709,"goal":"lemma SetUnionEmpty_15366(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_15367","instance":15367,"id":218710,"goal":"lemma SetInterEmpty_15367(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_15368","instance":15368,"id":218711,"goal":"lemma SetInterSubset_15368(A: set, B: set)\n ensures A * B <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_15369","instance":15369,"id":218712,"goal":"lemma SetCardSubset_15369(T: set, S: set)\n requires T <= S\n ensures |T| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_15370","instance":15370,"id":218713,"goal":"lemma SetUnionCard_15370(A: set, T: set)\n requires A * T == {}\n ensures |A + T| == |A| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_15371","instance":15371,"id":218714,"goal":"lemma SetUnionComm_15371(U: set, T: set)\n ensures U + T == T + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_15372","instance":15372,"id":218715,"goal":"lemma SetInterComm_15372(S: set, A: set)\n ensures S * A == A * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_15373","instance":15373,"id":218716,"goal":"lemma SetUnionAssoc_15373(T: set, A: set, U: set)\n ensures (T + A) + U == T + (A + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_15374","instance":15374,"id":218717,"goal":"lemma SetSubsetRefl_15374(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_15375","instance":15375,"id":218718,"goal":"lemma SetSubsetTrans_15375(T: set, U: set, B: set)\n requires T <= U && U <= B\n ensures T <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_15376","instance":15376,"id":218719,"goal":"lemma SetUnionEmpty_15376(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_15377","instance":15377,"id":218720,"goal":"lemma SetInterEmpty_15377(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_15378","instance":15378,"id":218721,"goal":"lemma SetInterSubset_15378(A: set, T: set)\n ensures A * T <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_15379","instance":15379,"id":218722,"goal":"lemma SetCardSubset_15379(B: set, A: set)\n requires B <= A\n ensures |B| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_15380","instance":15380,"id":218723,"goal":"lemma SetUnionCard_15380(B: set, T: set)\n requires B * T == {}\n ensures |B + T| == |B| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_15381","instance":15381,"id":218724,"goal":"lemma SetUnionComm_15381(S: set, B: set)\n ensures S + B == B + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_15382","instance":15382,"id":218725,"goal":"lemma SetInterComm_15382(S: set, U: set)\n ensures S * U == U * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_15383","instance":15383,"id":218726,"goal":"lemma SetUnionAssoc_15383(S: set, U: set, B: set)\n ensures (S + U) + B == S + (U + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_15384","instance":15384,"id":218727,"goal":"lemma SetSubsetRefl_15384(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_15385","instance":15385,"id":218728,"goal":"lemma SetSubsetTrans_15385(T: set, U: set, B: set)\n requires T <= U && U <= B\n ensures T <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_15386","instance":15386,"id":218729,"goal":"lemma SetUnionEmpty_15386(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_15387","instance":15387,"id":218730,"goal":"lemma SetInterEmpty_15387(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_15388","instance":15388,"id":218731,"goal":"lemma SetInterSubset_15388(U: set, B: set)\n ensures U * B <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_15389","instance":15389,"id":218732,"goal":"lemma SetCardSubset_15389(A: set, T: set)\n requires A <= T\n ensures |A| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_15390","instance":15390,"id":218733,"goal":"lemma SetUnionCard_15390(U: set, S: set)\n requires U * S == {}\n ensures |U + S| == |U| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_15391","instance":15391,"id":218734,"goal":"lemma SetUnionComm_15391(S: set, U: set)\n ensures S + U == U + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_15392","instance":15392,"id":218735,"goal":"lemma SetInterComm_15392(U: set, S: set)\n ensures U * S == S * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_15393","instance":15393,"id":218736,"goal":"lemma SetUnionAssoc_15393(B: set, T: set, S: set)\n ensures (B + T) + S == B + (T + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_15394","instance":15394,"id":218737,"goal":"lemma SetSubsetRefl_15394(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_15395","instance":15395,"id":218738,"goal":"lemma SetSubsetTrans_15395(T: set, S: set, A: set)\n requires T <= S && S <= A\n ensures T <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_15396","instance":15396,"id":218739,"goal":"lemma SetUnionEmpty_15396(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_15397","instance":15397,"id":218740,"goal":"lemma SetInterEmpty_15397(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_15398","instance":15398,"id":218741,"goal":"lemma SetInterSubset_15398(B: set, T: set)\n ensures B * T <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_15399","instance":15399,"id":218742,"goal":"lemma SetCardSubset_15399(U: set, B: set)\n requires U <= B\n ensures |U| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_15400","instance":15400,"id":218743,"goal":"lemma SetUnionCard_15400(U: set, B: set)\n requires U * B == {}\n ensures |U + B| == |U| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_15401","instance":15401,"id":218744,"goal":"lemma SetUnionComm_15401(A: set, U: set)\n ensures A + U == U + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_15402","instance":15402,"id":218745,"goal":"lemma SetInterComm_15402(A: set, U: set)\n ensures A * U == U * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_15403","instance":15403,"id":218746,"goal":"lemma SetUnionAssoc_15403(A: set, T: set, B: set)\n ensures (A + T) + B == A + (T + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_15404","instance":15404,"id":218747,"goal":"lemma SetSubsetRefl_15404(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_15405","instance":15405,"id":218748,"goal":"lemma SetSubsetTrans_15405(T: set, U: set, B: set)\n requires T <= U && U <= B\n ensures T <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_15406","instance":15406,"id":218749,"goal":"lemma SetUnionEmpty_15406(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_15407","instance":15407,"id":218750,"goal":"lemma SetInterEmpty_15407(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_15408","instance":15408,"id":218751,"goal":"lemma SetInterSubset_15408(A: set, B: set)\n ensures A * B <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_15409","instance":15409,"id":218752,"goal":"lemma SetCardSubset_15409(S: set, U: set)\n requires S <= U\n ensures |S| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_15410","instance":15410,"id":218753,"goal":"lemma SetUnionCard_15410(B: set, A: set)\n requires B * A == {}\n ensures |B + A| == |B| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_15411","instance":15411,"id":218754,"goal":"lemma SetUnionComm_15411(B: set, U: set)\n ensures B + U == U + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_15412","instance":15412,"id":218755,"goal":"lemma SetInterComm_15412(U: set, S: set)\n ensures U * S == S * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_15413","instance":15413,"id":218756,"goal":"lemma SetUnionAssoc_15413(S: set, A: set, T: set)\n ensures (S + A) + T == S + (A + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_15414","instance":15414,"id":218757,"goal":"lemma SetSubsetRefl_15414(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_15415","instance":15415,"id":218758,"goal":"lemma SetSubsetTrans_15415(U: set, B: set, S: set)\n requires U <= B && B <= S\n ensures U <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_15416","instance":15416,"id":218759,"goal":"lemma SetUnionEmpty_15416(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_15417","instance":15417,"id":218760,"goal":"lemma SetInterEmpty_15417(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_15418","instance":15418,"id":218761,"goal":"lemma SetInterSubset_15418(S: set, U: set)\n ensures S * U <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_15419","instance":15419,"id":218762,"goal":"lemma SetCardSubset_15419(B: set, A: set)\n requires B <= A\n ensures |B| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_15420","instance":15420,"id":218763,"goal":"lemma SetUnionCard_15420(U: set, S: set)\n requires U * S == {}\n ensures |U + S| == |U| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_15421","instance":15421,"id":218764,"goal":"lemma SetUnionComm_15421(T: set, U: set)\n ensures T + U == U + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_15422","instance":15422,"id":218765,"goal":"lemma SetInterComm_15422(S: set, B: set)\n ensures S * B == B * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_15423","instance":15423,"id":218766,"goal":"lemma SetUnionAssoc_15423(U: set, T: set, A: set)\n ensures (U + T) + A == U + (T + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_15424","instance":15424,"id":218767,"goal":"lemma SetSubsetRefl_15424(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_15425","instance":15425,"id":218768,"goal":"lemma SetSubsetTrans_15425(T: set, A: set, B: set)\n requires T <= A && A <= B\n ensures T <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_15426","instance":15426,"id":218769,"goal":"lemma SetUnionEmpty_15426(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_15427","instance":15427,"id":218770,"goal":"lemma SetInterEmpty_15427(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_15428","instance":15428,"id":218771,"goal":"lemma SetInterSubset_15428(A: set, B: set)\n ensures A * B <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_15429","instance":15429,"id":218772,"goal":"lemma SetCardSubset_15429(T: set, A: set)\n requires T <= A\n ensures |T| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_15430","instance":15430,"id":218773,"goal":"lemma SetUnionCard_15430(U: set, T: set)\n requires U * T == {}\n ensures |U + T| == |U| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_15431","instance":15431,"id":218774,"goal":"lemma SetUnionComm_15431(U: set, B: set)\n ensures U + B == B + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_15432","instance":15432,"id":218775,"goal":"lemma SetInterComm_15432(B: set, A: set)\n ensures B * A == A * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_15433","instance":15433,"id":218776,"goal":"lemma SetUnionAssoc_15433(S: set, B: set, T: set)\n ensures (S + B) + T == S + (B + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_15434","instance":15434,"id":218777,"goal":"lemma SetSubsetRefl_15434(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_15435","instance":15435,"id":218778,"goal":"lemma SetSubsetTrans_15435(B: set, U: set, S: set)\n requires B <= U && U <= S\n ensures B <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_15436","instance":15436,"id":218779,"goal":"lemma SetUnionEmpty_15436(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_15437","instance":15437,"id":218780,"goal":"lemma SetInterEmpty_15437(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_15438","instance":15438,"id":218781,"goal":"lemma SetInterSubset_15438(S: set, T: set)\n ensures S * T <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_15439","instance":15439,"id":218782,"goal":"lemma SetCardSubset_15439(U: set, A: set)\n requires U <= A\n ensures |U| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_15440","instance":15440,"id":218783,"goal":"lemma SetUnionCard_15440(U: set, A: set)\n requires U * A == {}\n ensures |U + A| == |U| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_15441","instance":15441,"id":218784,"goal":"lemma SetUnionComm_15441(S: set, U: set)\n ensures S + U == U + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_15442","instance":15442,"id":218785,"goal":"lemma SetInterComm_15442(U: set, S: set)\n ensures U * S == S * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_15443","instance":15443,"id":218786,"goal":"lemma SetUnionAssoc_15443(U: set, A: set, T: set)\n ensures (U + A) + T == U + (A + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_15444","instance":15444,"id":218787,"goal":"lemma SetSubsetRefl_15444(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_15445","instance":15445,"id":218788,"goal":"lemma SetSubsetTrans_15445(U: set, T: set, S: set)\n requires U <= T && T <= S\n ensures U <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_15446","instance":15446,"id":218789,"goal":"lemma SetUnionEmpty_15446(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_15447","instance":15447,"id":218790,"goal":"lemma SetInterEmpty_15447(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_15448","instance":15448,"id":218791,"goal":"lemma SetInterSubset_15448(S: set, A: set)\n ensures S * A <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_15449","instance":15449,"id":218792,"goal":"lemma SetCardSubset_15449(A: set, U: set)\n requires A <= U\n ensures |A| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_15450","instance":15450,"id":218793,"goal":"lemma SetUnionCard_15450(T: set, B: set)\n requires T * B == {}\n ensures |T + B| == |T| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_15451","instance":15451,"id":218794,"goal":"lemma SetUnionComm_15451(U: set, A: set)\n ensures U + A == A + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_15452","instance":15452,"id":218795,"goal":"lemma SetInterComm_15452(B: set, U: set)\n ensures B * U == U * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_15453","instance":15453,"id":218796,"goal":"lemma SetUnionAssoc_15453(S: set, U: set, B: set)\n ensures (S + U) + B == S + (U + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_15454","instance":15454,"id":218797,"goal":"lemma SetSubsetRefl_15454(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_15455","instance":15455,"id":218798,"goal":"lemma SetSubsetTrans_15455(A: set, B: set, U: set)\n requires A <= B && B <= U\n ensures A <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_15456","instance":15456,"id":218799,"goal":"lemma SetUnionEmpty_15456(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_15457","instance":15457,"id":218800,"goal":"lemma SetInterEmpty_15457(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_15458","instance":15458,"id":218801,"goal":"lemma SetInterSubset_15458(A: set, U: set)\n ensures A * U <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_15459","instance":15459,"id":218802,"goal":"lemma SetCardSubset_15459(T: set, U: set)\n requires T <= U\n ensures |T| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_15460","instance":15460,"id":218803,"goal":"lemma SetUnionCard_15460(S: set, T: set)\n requires S * T == {}\n ensures |S + T| == |S| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_15461","instance":15461,"id":218804,"goal":"lemma SetUnionComm_15461(S: set, T: set)\n ensures S + T == T + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_15462","instance":15462,"id":218805,"goal":"lemma SetInterComm_15462(T: set, A: set)\n ensures T * A == A * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_15463","instance":15463,"id":218806,"goal":"lemma SetUnionAssoc_15463(A: set, B: set, S: set)\n ensures (A + B) + S == A + (B + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_15464","instance":15464,"id":218807,"goal":"lemma SetSubsetRefl_15464(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_15465","instance":15465,"id":218808,"goal":"lemma SetSubsetTrans_15465(U: set, B: set, T: set)\n requires U <= B && B <= T\n ensures U <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_15466","instance":15466,"id":218809,"goal":"lemma SetUnionEmpty_15466(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_15467","instance":15467,"id":218810,"goal":"lemma SetInterEmpty_15467(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_15468","instance":15468,"id":218811,"goal":"lemma SetInterSubset_15468(S: set, A: set)\n ensures S * A <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_15469","instance":15469,"id":218812,"goal":"lemma SetCardSubset_15469(S: set, A: set)\n requires S <= A\n ensures |S| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_15470","instance":15470,"id":218813,"goal":"lemma SetUnionCard_15470(S: set, A: set)\n requires S * A == {}\n ensures |S + A| == |S| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_15471","instance":15471,"id":218814,"goal":"lemma SetUnionComm_15471(A: set, T: set)\n ensures A + T == T + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_15472","instance":15472,"id":218815,"goal":"lemma SetInterComm_15472(T: set, S: set)\n ensures T * S == S * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_15473","instance":15473,"id":218816,"goal":"lemma SetUnionAssoc_15473(S: set, T: set, U: set)\n ensures (S + T) + U == S + (T + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_15474","instance":15474,"id":218817,"goal":"lemma SetSubsetRefl_15474(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_15475","instance":15475,"id":218818,"goal":"lemma SetSubsetTrans_15475(A: set, U: set, S: set)\n requires A <= U && U <= S\n ensures A <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_15476","instance":15476,"id":218819,"goal":"lemma SetUnionEmpty_15476(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_15477","instance":15477,"id":218820,"goal":"lemma SetInterEmpty_15477(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_15478","instance":15478,"id":218821,"goal":"lemma SetInterSubset_15478(A: set, U: set)\n ensures A * U <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_15479","instance":15479,"id":218822,"goal":"lemma SetCardSubset_15479(S: set, B: set)\n requires S <= B\n ensures |S| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_15480","instance":15480,"id":218823,"goal":"lemma SetUnionCard_15480(S: set, B: set)\n requires S * B == {}\n ensures |S + B| == |S| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_15481","instance":15481,"id":218824,"goal":"lemma SetUnionComm_15481(U: set, T: set)\n ensures U + T == T + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_15482","instance":15482,"id":218825,"goal":"lemma SetInterComm_15482(T: set, S: set)\n ensures T * S == S * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_15483","instance":15483,"id":218826,"goal":"lemma SetUnionAssoc_15483(T: set, S: set, A: set)\n ensures (T + S) + A == T + (S + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_15484","instance":15484,"id":218827,"goal":"lemma SetSubsetRefl_15484(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_15485","instance":15485,"id":218828,"goal":"lemma SetSubsetTrans_15485(U: set, B: set, A: set)\n requires U <= B && B <= A\n ensures U <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_15486","instance":15486,"id":218829,"goal":"lemma SetUnionEmpty_15486(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_15487","instance":15487,"id":218830,"goal":"lemma SetInterEmpty_15487(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_15488","instance":15488,"id":218831,"goal":"lemma SetInterSubset_15488(B: set, A: set)\n ensures B * A <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_15489","instance":15489,"id":218832,"goal":"lemma SetCardSubset_15489(B: set, T: set)\n requires B <= T\n ensures |B| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_15490","instance":15490,"id":218833,"goal":"lemma SetUnionCard_15490(T: set, B: set)\n requires T * B == {}\n ensures |T + B| == |T| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_15491","instance":15491,"id":218834,"goal":"lemma SetUnionComm_15491(U: set, A: set)\n ensures U + A == A + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_15492","instance":15492,"id":218835,"goal":"lemma SetInterComm_15492(B: set, A: set)\n ensures B * A == A * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_15493","instance":15493,"id":218836,"goal":"lemma SetUnionAssoc_15493(T: set, A: set, U: set)\n ensures (T + A) + U == T + (A + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_15494","instance":15494,"id":218837,"goal":"lemma SetSubsetRefl_15494(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_15495","instance":15495,"id":218838,"goal":"lemma SetSubsetTrans_15495(U: set, S: set, B: set)\n requires U <= S && S <= B\n ensures U <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_15496","instance":15496,"id":218839,"goal":"lemma SetUnionEmpty_15496(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_15497","instance":15497,"id":218840,"goal":"lemma SetInterEmpty_15497(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_15498","instance":15498,"id":218841,"goal":"lemma SetInterSubset_15498(B: set, S: set)\n ensures B * S <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_15499","instance":15499,"id":218842,"goal":"lemma SetCardSubset_15499(U: set, S: set)\n requires U <= S\n ensures |U| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_15500","instance":15500,"id":218843,"goal":"lemma SetUnionCard_15500(U: set, T: set)\n requires U * T == {}\n ensures |U + T| == |U| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_15501","instance":15501,"id":218844,"goal":"lemma SetUnionComm_15501(B: set, A: set)\n ensures B + A == A + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_15502","instance":15502,"id":218845,"goal":"lemma SetInterComm_15502(T: set, B: set)\n ensures T * B == B * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_15503","instance":15503,"id":218846,"goal":"lemma SetUnionAssoc_15503(S: set, A: set, U: set)\n ensures (S + A) + U == S + (A + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_15504","instance":15504,"id":218847,"goal":"lemma SetSubsetRefl_15504(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_15505","instance":15505,"id":218848,"goal":"lemma SetSubsetTrans_15505(A: set, U: set, T: set)\n requires A <= U && U <= T\n ensures A <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_15506","instance":15506,"id":218849,"goal":"lemma SetUnionEmpty_15506(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_15507","instance":15507,"id":218850,"goal":"lemma SetInterEmpty_15507(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_15508","instance":15508,"id":218851,"goal":"lemma SetInterSubset_15508(B: set, S: set)\n ensures B * S <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_15509","instance":15509,"id":218852,"goal":"lemma SetCardSubset_15509(T: set, B: set)\n requires T <= B\n ensures |T| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_15510","instance":15510,"id":218853,"goal":"lemma SetUnionCard_15510(A: set, T: set)\n requires A * T == {}\n ensures |A + T| == |A| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_15511","instance":15511,"id":218854,"goal":"lemma SetUnionComm_15511(U: set, S: set)\n ensures U + S == S + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_15512","instance":15512,"id":218855,"goal":"lemma SetInterComm_15512(S: set, U: set)\n ensures S * U == U * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_15513","instance":15513,"id":218856,"goal":"lemma SetUnionAssoc_15513(B: set, A: set, U: set)\n ensures (B + A) + U == B + (A + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_15514","instance":15514,"id":218857,"goal":"lemma SetSubsetRefl_15514(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_15515","instance":15515,"id":218858,"goal":"lemma SetSubsetTrans_15515(U: set, A: set, T: set)\n requires U <= A && A <= T\n ensures U <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_15516","instance":15516,"id":218859,"goal":"lemma SetUnionEmpty_15516(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_15517","instance":15517,"id":218860,"goal":"lemma SetInterEmpty_15517(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_15518","instance":15518,"id":218861,"goal":"lemma SetInterSubset_15518(U: set, T: set)\n ensures U * T <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_15519","instance":15519,"id":218862,"goal":"lemma SetCardSubset_15519(U: set, A: set)\n requires U <= A\n ensures |U| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_15520","instance":15520,"id":218863,"goal":"lemma SetUnionCard_15520(A: set, S: set)\n requires A * S == {}\n ensures |A + S| == |A| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_15521","instance":15521,"id":218864,"goal":"lemma SetUnionComm_15521(A: set, T: set)\n ensures A + T == T + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_15522","instance":15522,"id":218865,"goal":"lemma SetInterComm_15522(B: set, A: set)\n ensures B * A == A * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_15523","instance":15523,"id":218866,"goal":"lemma SetUnionAssoc_15523(B: set, S: set, T: set)\n ensures (B + S) + T == B + (S + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_15524","instance":15524,"id":218867,"goal":"lemma SetSubsetRefl_15524(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_15525","instance":15525,"id":218868,"goal":"lemma SetSubsetTrans_15525(U: set, A: set, S: set)\n requires U <= A && A <= S\n ensures U <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_15526","instance":15526,"id":218869,"goal":"lemma SetUnionEmpty_15526(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_15527","instance":15527,"id":218870,"goal":"lemma SetInterEmpty_15527(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_15528","instance":15528,"id":218871,"goal":"lemma SetInterSubset_15528(U: set, S: set)\n ensures U * S <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_15529","instance":15529,"id":218872,"goal":"lemma SetCardSubset_15529(A: set, S: set)\n requires A <= S\n ensures |A| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_15530","instance":15530,"id":218873,"goal":"lemma SetUnionCard_15530(A: set, T: set)\n requires A * T == {}\n ensures |A + T| == |A| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_15531","instance":15531,"id":218874,"goal":"lemma SetUnionComm_15531(U: set, T: set)\n ensures U + T == T + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_15532","instance":15532,"id":218875,"goal":"lemma SetInterComm_15532(S: set, A: set)\n ensures S * A == A * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_15533","instance":15533,"id":218876,"goal":"lemma SetUnionAssoc_15533(B: set, U: set, A: set)\n ensures (B + U) + A == B + (U + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_15534","instance":15534,"id":218877,"goal":"lemma SetSubsetRefl_15534(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_15535","instance":15535,"id":218878,"goal":"lemma SetSubsetTrans_15535(A: set, B: set, T: set)\n requires A <= B && B <= T\n ensures A <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_15536","instance":15536,"id":218879,"goal":"lemma SetUnionEmpty_15536(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_15537","instance":15537,"id":218880,"goal":"lemma SetInterEmpty_15537(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_15538","instance":15538,"id":218881,"goal":"lemma SetInterSubset_15538(S: set, T: set)\n ensures S * T <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_15539","instance":15539,"id":218882,"goal":"lemma SetCardSubset_15539(S: set, U: set)\n requires S <= U\n ensures |S| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_15540","instance":15540,"id":218883,"goal":"lemma SetUnionCard_15540(U: set, T: set)\n requires U * T == {}\n ensures |U + T| == |U| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_15541","instance":15541,"id":218884,"goal":"lemma SetUnionComm_15541(A: set, S: set)\n ensures A + S == S + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_15542","instance":15542,"id":218885,"goal":"lemma SetInterComm_15542(B: set, U: set)\n ensures B * U == U * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_15543","instance":15543,"id":218886,"goal":"lemma SetUnionAssoc_15543(T: set, S: set, U: set)\n ensures (T + S) + U == T + (S + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_15544","instance":15544,"id":218887,"goal":"lemma SetSubsetRefl_15544(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_15545","instance":15545,"id":218888,"goal":"lemma SetSubsetTrans_15545(A: set, T: set, S: set)\n requires A <= T && T <= S\n ensures A <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_15546","instance":15546,"id":218889,"goal":"lemma SetUnionEmpty_15546(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_15547","instance":15547,"id":218890,"goal":"lemma SetInterEmpty_15547(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_15548","instance":15548,"id":218891,"goal":"lemma SetInterSubset_15548(T: set, B: set)\n ensures T * B <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_15549","instance":15549,"id":218892,"goal":"lemma SetCardSubset_15549(T: set, U: set)\n requires T <= U\n ensures |T| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_15550","instance":15550,"id":218893,"goal":"lemma SetUnionCard_15550(U: set, T: set)\n requires U * T == {}\n ensures |U + T| == |U| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_15551","instance":15551,"id":218894,"goal":"lemma SetUnionComm_15551(U: set, B: set)\n ensures U + B == B + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_15552","instance":15552,"id":218895,"goal":"lemma SetInterComm_15552(B: set, A: set)\n ensures B * A == A * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_15553","instance":15553,"id":218896,"goal":"lemma SetUnionAssoc_15553(U: set, A: set, B: set)\n ensures (U + A) + B == U + (A + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_15554","instance":15554,"id":218897,"goal":"lemma SetSubsetRefl_15554(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_15555","instance":15555,"id":218898,"goal":"lemma SetSubsetTrans_15555(U: set, S: set, T: set)\n requires U <= S && S <= T\n ensures U <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_15556","instance":15556,"id":218899,"goal":"lemma SetUnionEmpty_15556(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_15557","instance":15557,"id":218900,"goal":"lemma SetInterEmpty_15557(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_15558","instance":15558,"id":218901,"goal":"lemma SetInterSubset_15558(A: set, U: set)\n ensures A * U <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_15559","instance":15559,"id":218902,"goal":"lemma SetCardSubset_15559(T: set, S: set)\n requires T <= S\n ensures |T| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_15560","instance":15560,"id":218903,"goal":"lemma SetUnionCard_15560(T: set, U: set)\n requires T * U == {}\n ensures |T + U| == |T| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_15561","instance":15561,"id":218904,"goal":"lemma SetUnionComm_15561(B: set, S: set)\n ensures B + S == S + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_15562","instance":15562,"id":218905,"goal":"lemma SetInterComm_15562(A: set, U: set)\n ensures A * U == U * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_15563","instance":15563,"id":218906,"goal":"lemma SetUnionAssoc_15563(T: set, B: set, A: set)\n ensures (T + B) + A == T + (B + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_15564","instance":15564,"id":218907,"goal":"lemma SetSubsetRefl_15564(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_15565","instance":15565,"id":218908,"goal":"lemma SetSubsetTrans_15565(T: set, A: set, U: set)\n requires T <= A && A <= U\n ensures T <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_15566","instance":15566,"id":218909,"goal":"lemma SetUnionEmpty_15566(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_15567","instance":15567,"id":218910,"goal":"lemma SetInterEmpty_15567(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_15568","instance":15568,"id":218911,"goal":"lemma SetInterSubset_15568(S: set, U: set)\n ensures S * U <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_15569","instance":15569,"id":218912,"goal":"lemma SetCardSubset_15569(A: set, S: set)\n requires A <= S\n ensures |A| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_15570","instance":15570,"id":218913,"goal":"lemma SetUnionCard_15570(A: set, B: set)\n requires A * B == {}\n ensures |A + B| == |A| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_15571","instance":15571,"id":218914,"goal":"lemma SetUnionComm_15571(T: set, B: set)\n ensures T + B == B + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_15572","instance":15572,"id":218915,"goal":"lemma SetInterComm_15572(T: set, B: set)\n ensures T * B == B * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_15573","instance":15573,"id":218916,"goal":"lemma SetUnionAssoc_15573(U: set, S: set, B: set)\n ensures (U + S) + B == U + (S + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_15574","instance":15574,"id":218917,"goal":"lemma SetSubsetRefl_15574(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_15575","instance":15575,"id":218918,"goal":"lemma SetSubsetTrans_15575(U: set, A: set, S: set)\n requires U <= A && A <= S\n ensures U <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_15576","instance":15576,"id":218919,"goal":"lemma SetUnionEmpty_15576(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_15577","instance":15577,"id":218920,"goal":"lemma SetInterEmpty_15577(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_15578","instance":15578,"id":218921,"goal":"lemma SetInterSubset_15578(A: set, S: set)\n ensures A * S <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_15579","instance":15579,"id":218922,"goal":"lemma SetCardSubset_15579(A: set, T: set)\n requires A <= T\n ensures |A| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_15580","instance":15580,"id":218923,"goal":"lemma SetUnionCard_15580(A: set, S: set)\n requires A * S == {}\n ensures |A + S| == |A| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_15581","instance":15581,"id":218924,"goal":"lemma SetUnionComm_15581(B: set, U: set)\n ensures B + U == U + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_15582","instance":15582,"id":218925,"goal":"lemma SetInterComm_15582(U: set, T: set)\n ensures U * T == T * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_15583","instance":15583,"id":218926,"goal":"lemma SetUnionAssoc_15583(A: set, T: set, S: set)\n ensures (A + T) + S == A + (T + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_15584","instance":15584,"id":218927,"goal":"lemma SetSubsetRefl_15584(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_15585","instance":15585,"id":218928,"goal":"lemma SetSubsetTrans_15585(U: set, S: set, T: set)\n requires U <= S && S <= T\n ensures U <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_15586","instance":15586,"id":218929,"goal":"lemma SetUnionEmpty_15586(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_15587","instance":15587,"id":218930,"goal":"lemma SetInterEmpty_15587(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_15588","instance":15588,"id":218931,"goal":"lemma SetInterSubset_15588(U: set, B: set)\n ensures U * B <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_15589","instance":15589,"id":218932,"goal":"lemma SetCardSubset_15589(S: set, A: set)\n requires S <= A\n ensures |S| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_15590","instance":15590,"id":218933,"goal":"lemma SetUnionCard_15590(S: set, U: set)\n requires S * U == {}\n ensures |S + U| == |S| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_15591","instance":15591,"id":218934,"goal":"lemma SetUnionComm_15591(T: set, U: set)\n ensures T + U == U + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_15592","instance":15592,"id":218935,"goal":"lemma SetInterComm_15592(A: set, T: set)\n ensures A * T == T * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_15593","instance":15593,"id":218936,"goal":"lemma SetUnionAssoc_15593(A: set, B: set, T: set)\n ensures (A + B) + T == A + (B + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_15594","instance":15594,"id":218937,"goal":"lemma SetSubsetRefl_15594(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_15595","instance":15595,"id":218938,"goal":"lemma SetSubsetTrans_15595(B: set, A: set, T: set)\n requires B <= A && A <= T\n ensures B <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_15596","instance":15596,"id":218939,"goal":"lemma SetUnionEmpty_15596(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_15597","instance":15597,"id":218940,"goal":"lemma SetInterEmpty_15597(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_15598","instance":15598,"id":218941,"goal":"lemma SetInterSubset_15598(U: set, S: set)\n ensures U * S <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_15599","instance":15599,"id":218942,"goal":"lemma SetCardSubset_15599(S: set, T: set)\n requires S <= T\n ensures |S| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_15600","instance":15600,"id":218943,"goal":"lemma SetUnionCard_15600(B: set, A: set)\n requires B * A == {}\n ensures |B + A| == |B| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_15601","instance":15601,"id":218944,"goal":"lemma SetUnionComm_15601(A: set, U: set)\n ensures A + U == U + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_15602","instance":15602,"id":218945,"goal":"lemma SetInterComm_15602(A: set, T: set)\n ensures A * T == T * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_15603","instance":15603,"id":218946,"goal":"lemma SetUnionAssoc_15603(B: set, T: set, S: set)\n ensures (B + T) + S == B + (T + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_15604","instance":15604,"id":218947,"goal":"lemma SetSubsetRefl_15604(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_15605","instance":15605,"id":218948,"goal":"lemma SetSubsetTrans_15605(U: set, T: set, A: set)\n requires U <= T && T <= A\n ensures U <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_15606","instance":15606,"id":218949,"goal":"lemma SetUnionEmpty_15606(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_15607","instance":15607,"id":218950,"goal":"lemma SetInterEmpty_15607(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_15608","instance":15608,"id":218951,"goal":"lemma SetInterSubset_15608(U: set, S: set)\n ensures U * S <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_15609","instance":15609,"id":218952,"goal":"lemma SetCardSubset_15609(B: set, A: set)\n requires B <= A\n ensures |B| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_15610","instance":15610,"id":218953,"goal":"lemma SetUnionCard_15610(S: set, B: set)\n requires S * B == {}\n ensures |S + B| == |S| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_15611","instance":15611,"id":218954,"goal":"lemma SetUnionComm_15611(U: set, S: set)\n ensures U + S == S + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_15612","instance":15612,"id":218955,"goal":"lemma SetInterComm_15612(S: set, B: set)\n ensures S * B == B * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_15613","instance":15613,"id":218956,"goal":"lemma SetUnionAssoc_15613(T: set, U: set, S: set)\n ensures (T + U) + S == T + (U + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_15614","instance":15614,"id":218957,"goal":"lemma SetSubsetRefl_15614(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_15615","instance":15615,"id":218958,"goal":"lemma SetSubsetTrans_15615(T: set, B: set, A: set)\n requires T <= B && B <= A\n ensures T <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_15616","instance":15616,"id":218959,"goal":"lemma SetUnionEmpty_15616(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_15617","instance":15617,"id":218960,"goal":"lemma SetInterEmpty_15617(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_15618","instance":15618,"id":218961,"goal":"lemma SetInterSubset_15618(A: set, S: set)\n ensures A * S <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_15619","instance":15619,"id":218962,"goal":"lemma SetCardSubset_15619(T: set, U: set)\n requires T <= U\n ensures |T| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_15620","instance":15620,"id":218963,"goal":"lemma SetUnionCard_15620(A: set, B: set)\n requires A * B == {}\n ensures |A + B| == |A| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_15621","instance":15621,"id":218964,"goal":"lemma SetUnionComm_15621(S: set, U: set)\n ensures S + U == U + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_15622","instance":15622,"id":218965,"goal":"lemma SetInterComm_15622(U: set, A: set)\n ensures U * A == A * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_15623","instance":15623,"id":218966,"goal":"lemma SetUnionAssoc_15623(B: set, A: set, U: set)\n ensures (B + A) + U == B + (A + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_15624","instance":15624,"id":218967,"goal":"lemma SetSubsetRefl_15624(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_15625","instance":15625,"id":218968,"goal":"lemma SetSubsetTrans_15625(U: set, T: set, B: set)\n requires U <= T && T <= B\n ensures U <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_15626","instance":15626,"id":218969,"goal":"lemma SetUnionEmpty_15626(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_15627","instance":15627,"id":218970,"goal":"lemma SetInterEmpty_15627(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_15628","instance":15628,"id":218971,"goal":"lemma SetInterSubset_15628(T: set, S: set)\n ensures T * S <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_15629","instance":15629,"id":218972,"goal":"lemma SetCardSubset_15629(U: set, A: set)\n requires U <= A\n ensures |U| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_15630","instance":15630,"id":218973,"goal":"lemma SetUnionCard_15630(T: set, U: set)\n requires T * U == {}\n ensures |T + U| == |T| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_15631","instance":15631,"id":218974,"goal":"lemma SetUnionComm_15631(U: set, A: set)\n ensures U + A == A + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_15632","instance":15632,"id":218975,"goal":"lemma SetInterComm_15632(A: set, U: set)\n ensures A * U == U * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_15633","instance":15633,"id":218976,"goal":"lemma SetUnionAssoc_15633(T: set, B: set, S: set)\n ensures (T + B) + S == T + (B + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_15634","instance":15634,"id":218977,"goal":"lemma SetSubsetRefl_15634(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_15635","instance":15635,"id":218978,"goal":"lemma SetSubsetTrans_15635(T: set, A: set, B: set)\n requires T <= A && A <= B\n ensures T <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_15636","instance":15636,"id":218979,"goal":"lemma SetUnionEmpty_15636(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_15637","instance":15637,"id":218980,"goal":"lemma SetInterEmpty_15637(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_15638","instance":15638,"id":218981,"goal":"lemma SetInterSubset_15638(T: set, U: set)\n ensures T * U <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_15639","instance":15639,"id":218982,"goal":"lemma SetCardSubset_15639(U: set, T: set)\n requires U <= T\n ensures |U| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_15640","instance":15640,"id":218983,"goal":"lemma SetUnionCard_15640(S: set, B: set)\n requires S * B == {}\n ensures |S + B| == |S| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_15641","instance":15641,"id":218984,"goal":"lemma SetUnionComm_15641(U: set, B: set)\n ensures U + B == B + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_15642","instance":15642,"id":218985,"goal":"lemma SetInterComm_15642(A: set, T: set)\n ensures A * T == T * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_15643","instance":15643,"id":218986,"goal":"lemma SetUnionAssoc_15643(S: set, U: set, T: set)\n ensures (S + U) + T == S + (U + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_15644","instance":15644,"id":218987,"goal":"lemma SetSubsetRefl_15644(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_15645","instance":15645,"id":218988,"goal":"lemma SetSubsetTrans_15645(B: set, U: set, A: set)\n requires B <= U && U <= A\n ensures B <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_15646","instance":15646,"id":218989,"goal":"lemma SetUnionEmpty_15646(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_15647","instance":15647,"id":218990,"goal":"lemma SetInterEmpty_15647(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_15648","instance":15648,"id":218991,"goal":"lemma SetInterSubset_15648(U: set, B: set)\n ensures U * B <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_15649","instance":15649,"id":218992,"goal":"lemma SetCardSubset_15649(B: set, T: set)\n requires B <= T\n ensures |B| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_15650","instance":15650,"id":218993,"goal":"lemma SetUnionCard_15650(A: set, T: set)\n requires A * T == {}\n ensures |A + T| == |A| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_15651","instance":15651,"id":218994,"goal":"lemma SetUnionComm_15651(U: set, A: set)\n ensures U + A == A + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_15652","instance":15652,"id":218995,"goal":"lemma SetInterComm_15652(T: set, B: set)\n ensures T * B == B * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_15653","instance":15653,"id":218996,"goal":"lemma SetUnionAssoc_15653(T: set, B: set, U: set)\n ensures (T + B) + U == T + (B + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_15654","instance":15654,"id":218997,"goal":"lemma SetSubsetRefl_15654(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_15655","instance":15655,"id":218998,"goal":"lemma SetSubsetTrans_15655(U: set, S: set, T: set)\n requires U <= S && S <= T\n ensures U <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_15656","instance":15656,"id":218999,"goal":"lemma SetUnionEmpty_15656(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_15657","instance":15657,"id":219000,"goal":"lemma SetInterEmpty_15657(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_15658","instance":15658,"id":219001,"goal":"lemma SetInterSubset_15658(T: set, S: set)\n ensures T * S <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_15659","instance":15659,"id":219002,"goal":"lemma SetCardSubset_15659(U: set, T: set)\n requires U <= T\n ensures |U| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_15660","instance":15660,"id":219003,"goal":"lemma SetUnionCard_15660(A: set, T: set)\n requires A * T == {}\n ensures |A + T| == |A| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_15661","instance":15661,"id":219004,"goal":"lemma SetUnionComm_15661(U: set, S: set)\n ensures U + S == S + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_15662","instance":15662,"id":219005,"goal":"lemma SetInterComm_15662(T: set, B: set)\n ensures T * B == B * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_15663","instance":15663,"id":219006,"goal":"lemma SetUnionAssoc_15663(A: set, S: set, B: set)\n ensures (A + S) + B == A + (S + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_15664","instance":15664,"id":219007,"goal":"lemma SetSubsetRefl_15664(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_15665","instance":15665,"id":219008,"goal":"lemma SetSubsetTrans_15665(A: set, T: set, S: set)\n requires A <= T && T <= S\n ensures A <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_15666","instance":15666,"id":219009,"goal":"lemma SetUnionEmpty_15666(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_15667","instance":15667,"id":219010,"goal":"lemma SetInterEmpty_15667(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_15668","instance":15668,"id":219011,"goal":"lemma SetInterSubset_15668(T: set, U: set)\n ensures T * U <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_15669","instance":15669,"id":219012,"goal":"lemma SetCardSubset_15669(T: set, S: set)\n requires T <= S\n ensures |T| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_15670","instance":15670,"id":219013,"goal":"lemma SetUnionCard_15670(B: set, A: set)\n requires B * A == {}\n ensures |B + A| == |B| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_15671","instance":15671,"id":219014,"goal":"lemma SetUnionComm_15671(B: set, U: set)\n ensures B + U == U + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_15672","instance":15672,"id":219015,"goal":"lemma SetInterComm_15672(S: set, U: set)\n ensures S * U == U * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_15673","instance":15673,"id":219016,"goal":"lemma SetUnionAssoc_15673(T: set, A: set, U: set)\n ensures (T + A) + U == T + (A + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_15674","instance":15674,"id":219017,"goal":"lemma SetSubsetRefl_15674(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_15675","instance":15675,"id":219018,"goal":"lemma SetSubsetTrans_15675(U: set, S: set, B: set)\n requires U <= S && S <= B\n ensures U <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_15676","instance":15676,"id":219019,"goal":"lemma SetUnionEmpty_15676(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_15677","instance":15677,"id":219020,"goal":"lemma SetInterEmpty_15677(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_15678","instance":15678,"id":219021,"goal":"lemma SetInterSubset_15678(S: set, T: set)\n ensures S * T <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_15679","instance":15679,"id":219022,"goal":"lemma SetCardSubset_15679(T: set, A: set)\n requires T <= A\n ensures |T| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_15680","instance":15680,"id":219023,"goal":"lemma SetUnionCard_15680(U: set, T: set)\n requires U * T == {}\n ensures |U + T| == |U| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_15681","instance":15681,"id":219024,"goal":"lemma SetUnionComm_15681(U: set, B: set)\n ensures U + B == B + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_15682","instance":15682,"id":219025,"goal":"lemma SetInterComm_15682(S: set, U: set)\n ensures S * U == U * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_15683","instance":15683,"id":219026,"goal":"lemma SetUnionAssoc_15683(T: set, U: set, S: set)\n ensures (T + U) + S == T + (U + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_15684","instance":15684,"id":219027,"goal":"lemma SetSubsetRefl_15684(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_15685","instance":15685,"id":219028,"goal":"lemma SetSubsetTrans_15685(A: set, U: set, T: set)\n requires A <= U && U <= T\n ensures A <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_15686","instance":15686,"id":219029,"goal":"lemma SetUnionEmpty_15686(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_15687","instance":15687,"id":219030,"goal":"lemma SetInterEmpty_15687(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_15688","instance":15688,"id":219031,"goal":"lemma SetInterSubset_15688(T: set, A: set)\n ensures T * A <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_15689","instance":15689,"id":219032,"goal":"lemma SetCardSubset_15689(B: set, A: set)\n requires B <= A\n ensures |B| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_15690","instance":15690,"id":219033,"goal":"lemma SetUnionCard_15690(A: set, S: set)\n requires A * S == {}\n ensures |A + S| == |A| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_15691","instance":15691,"id":219034,"goal":"lemma SetUnionComm_15691(A: set, T: set)\n ensures A + T == T + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_15692","instance":15692,"id":219035,"goal":"lemma SetInterComm_15692(B: set, U: set)\n ensures B * U == U * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_15693","instance":15693,"id":219036,"goal":"lemma SetUnionAssoc_15693(T: set, B: set, U: set)\n ensures (T + B) + U == T + (B + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_15694","instance":15694,"id":219037,"goal":"lemma SetSubsetRefl_15694(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_15695","instance":15695,"id":219038,"goal":"lemma SetSubsetTrans_15695(S: set, U: set, A: set)\n requires S <= U && U <= A\n ensures S <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_15696","instance":15696,"id":219039,"goal":"lemma SetUnionEmpty_15696(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_15697","instance":15697,"id":219040,"goal":"lemma SetInterEmpty_15697(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_15698","instance":15698,"id":219041,"goal":"lemma SetInterSubset_15698(U: set, S: set)\n ensures U * S <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_15699","instance":15699,"id":219042,"goal":"lemma SetCardSubset_15699(B: set, S: set)\n requires B <= S\n ensures |B| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_15700","instance":15700,"id":219043,"goal":"lemma SetUnionCard_15700(S: set, A: set)\n requires S * A == {}\n ensures |S + A| == |S| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_15701","instance":15701,"id":219044,"goal":"lemma SetUnionComm_15701(T: set, B: set)\n ensures T + B == B + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_15702","instance":15702,"id":219045,"goal":"lemma SetInterComm_15702(B: set, T: set)\n ensures B * T == T * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_15703","instance":15703,"id":219046,"goal":"lemma SetUnionAssoc_15703(B: set, S: set, A: set)\n ensures (B + S) + A == B + (S + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_15704","instance":15704,"id":219047,"goal":"lemma SetSubsetRefl_15704(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_15705","instance":15705,"id":219048,"goal":"lemma SetSubsetTrans_15705(A: set, T: set, S: set)\n requires A <= T && T <= S\n ensures A <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_15706","instance":15706,"id":219049,"goal":"lemma SetUnionEmpty_15706(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_15707","instance":15707,"id":219050,"goal":"lemma SetInterEmpty_15707(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_15708","instance":15708,"id":219051,"goal":"lemma SetInterSubset_15708(U: set, S: set)\n ensures U * S <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_15709","instance":15709,"id":219052,"goal":"lemma SetCardSubset_15709(U: set, B: set)\n requires U <= B\n ensures |U| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_15710","instance":15710,"id":219053,"goal":"lemma SetUnionCard_15710(U: set, T: set)\n requires U * T == {}\n ensures |U + T| == |U| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_15711","instance":15711,"id":219054,"goal":"lemma SetUnionComm_15711(B: set, T: set)\n ensures B + T == T + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_15712","instance":15712,"id":219055,"goal":"lemma SetInterComm_15712(T: set, A: set)\n ensures T * A == A * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_15713","instance":15713,"id":219056,"goal":"lemma SetUnionAssoc_15713(S: set, U: set, B: set)\n ensures (S + U) + B == S + (U + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_15714","instance":15714,"id":219057,"goal":"lemma SetSubsetRefl_15714(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_15715","instance":15715,"id":219058,"goal":"lemma SetSubsetTrans_15715(B: set, T: set, S: set)\n requires B <= T && T <= S\n ensures B <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_15716","instance":15716,"id":219059,"goal":"lemma SetUnionEmpty_15716(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_15717","instance":15717,"id":219060,"goal":"lemma SetInterEmpty_15717(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_15718","instance":15718,"id":219061,"goal":"lemma SetInterSubset_15718(S: set, A: set)\n ensures S * A <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_15719","instance":15719,"id":219062,"goal":"lemma SetCardSubset_15719(B: set, A: set)\n requires B <= A\n ensures |B| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_15720","instance":15720,"id":219063,"goal":"lemma SetUnionCard_15720(A: set, T: set)\n requires A * T == {}\n ensures |A + T| == |A| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_15721","instance":15721,"id":219064,"goal":"lemma SetUnionComm_15721(S: set, U: set)\n ensures S + U == U + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_15722","instance":15722,"id":219065,"goal":"lemma SetInterComm_15722(T: set, A: set)\n ensures T * A == A * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_15723","instance":15723,"id":219066,"goal":"lemma SetUnionAssoc_15723(A: set, U: set, S: set)\n ensures (A + U) + S == A + (U + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_15724","instance":15724,"id":219067,"goal":"lemma SetSubsetRefl_15724(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_15725","instance":15725,"id":219068,"goal":"lemma SetSubsetTrans_15725(B: set, U: set, T: set)\n requires B <= U && U <= T\n ensures B <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_15726","instance":15726,"id":219069,"goal":"lemma SetUnionEmpty_15726(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_15727","instance":15727,"id":219070,"goal":"lemma SetInterEmpty_15727(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_15728","instance":15728,"id":219071,"goal":"lemma SetInterSubset_15728(S: set, U: set)\n ensures S * U <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_15729","instance":15729,"id":219072,"goal":"lemma SetCardSubset_15729(B: set, S: set)\n requires B <= S\n ensures |B| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_15730","instance":15730,"id":219073,"goal":"lemma SetUnionCard_15730(S: set, B: set)\n requires S * B == {}\n ensures |S + B| == |S| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_15731","instance":15731,"id":219074,"goal":"lemma SetUnionComm_15731(B: set, S: set)\n ensures B + S == S + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_15732","instance":15732,"id":219075,"goal":"lemma SetInterComm_15732(A: set, T: set)\n ensures A * T == T * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_15733","instance":15733,"id":219076,"goal":"lemma SetUnionAssoc_15733(T: set, B: set, A: set)\n ensures (T + B) + A == T + (B + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_15734","instance":15734,"id":219077,"goal":"lemma SetSubsetRefl_15734(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_15735","instance":15735,"id":219078,"goal":"lemma SetSubsetTrans_15735(U: set, T: set, A: set)\n requires U <= T && T <= A\n ensures U <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_15736","instance":15736,"id":219079,"goal":"lemma SetUnionEmpty_15736(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_15737","instance":15737,"id":219080,"goal":"lemma SetInterEmpty_15737(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_15738","instance":15738,"id":219081,"goal":"lemma SetInterSubset_15738(S: set, U: set)\n ensures S * U <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_15739","instance":15739,"id":219082,"goal":"lemma SetCardSubset_15739(U: set, A: set)\n requires U <= A\n ensures |U| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_15740","instance":15740,"id":219083,"goal":"lemma SetUnionCard_15740(S: set, T: set)\n requires S * T == {}\n ensures |S + T| == |S| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_15741","instance":15741,"id":219084,"goal":"lemma SetUnionComm_15741(B: set, S: set)\n ensures B + S == S + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_15742","instance":15742,"id":219085,"goal":"lemma SetInterComm_15742(A: set, U: set)\n ensures A * U == U * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_15743","instance":15743,"id":219086,"goal":"lemma SetUnionAssoc_15743(S: set, A: set, U: set)\n ensures (S + A) + U == S + (A + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_15744","instance":15744,"id":219087,"goal":"lemma SetSubsetRefl_15744(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_15745","instance":15745,"id":219088,"goal":"lemma SetSubsetTrans_15745(U: set, A: set, T: set)\n requires U <= A && A <= T\n ensures U <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_15746","instance":15746,"id":219089,"goal":"lemma SetUnionEmpty_15746(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_15747","instance":15747,"id":219090,"goal":"lemma SetInterEmpty_15747(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_15748","instance":15748,"id":219091,"goal":"lemma SetInterSubset_15748(A: set, S: set)\n ensures A * S <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_15749","instance":15749,"id":219092,"goal":"lemma SetCardSubset_15749(A: set, S: set)\n requires A <= S\n ensures |A| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_15750","instance":15750,"id":219093,"goal":"lemma SetUnionCard_15750(T: set, A: set)\n requires T * A == {}\n ensures |T + A| == |T| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_15751","instance":15751,"id":219094,"goal":"lemma SetUnionComm_15751(A: set, B: set)\n ensures A + B == B + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_15752","instance":15752,"id":219095,"goal":"lemma SetInterComm_15752(T: set, A: set)\n ensures T * A == A * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_15753","instance":15753,"id":219096,"goal":"lemma SetUnionAssoc_15753(S: set, B: set, U: set)\n ensures (S + B) + U == S + (B + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_15754","instance":15754,"id":219097,"goal":"lemma SetSubsetRefl_15754(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_15755","instance":15755,"id":219098,"goal":"lemma SetSubsetTrans_15755(S: set, U: set, T: set)\n requires S <= U && U <= T\n ensures S <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_15756","instance":15756,"id":219099,"goal":"lemma SetUnionEmpty_15756(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_15757","instance":15757,"id":219100,"goal":"lemma SetInterEmpty_15757(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_15758","instance":15758,"id":219101,"goal":"lemma SetInterSubset_15758(S: set, U: set)\n ensures S * U <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_15759","instance":15759,"id":219102,"goal":"lemma SetCardSubset_15759(U: set, A: set)\n requires U <= A\n ensures |U| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_15760","instance":15760,"id":219103,"goal":"lemma SetUnionCard_15760(A: set, S: set)\n requires A * S == {}\n ensures |A + S| == |A| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_15761","instance":15761,"id":219104,"goal":"lemma SetUnionComm_15761(T: set, B: set)\n ensures T + B == B + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_15762","instance":15762,"id":219105,"goal":"lemma SetInterComm_15762(S: set, T: set)\n ensures S * T == T * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_15763","instance":15763,"id":219106,"goal":"lemma SetUnionAssoc_15763(A: set, U: set, B: set)\n ensures (A + U) + B == A + (U + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_15764","instance":15764,"id":219107,"goal":"lemma SetSubsetRefl_15764(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_15765","instance":15765,"id":219108,"goal":"lemma SetSubsetTrans_15765(A: set, U: set, T: set)\n requires A <= U && U <= T\n ensures A <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_15766","instance":15766,"id":219109,"goal":"lemma SetUnionEmpty_15766(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_15767","instance":15767,"id":219110,"goal":"lemma SetInterEmpty_15767(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_15768","instance":15768,"id":219111,"goal":"lemma SetInterSubset_15768(B: set, A: set)\n ensures B * A <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_15769","instance":15769,"id":219112,"goal":"lemma SetCardSubset_15769(B: set, S: set)\n requires B <= S\n ensures |B| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_15770","instance":15770,"id":219113,"goal":"lemma SetUnionCard_15770(T: set, A: set)\n requires T * A == {}\n ensures |T + A| == |T| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_15771","instance":15771,"id":219114,"goal":"lemma SetUnionComm_15771(T: set, U: set)\n ensures T + U == U + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_15772","instance":15772,"id":219115,"goal":"lemma SetInterComm_15772(B: set, U: set)\n ensures B * U == U * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_15773","instance":15773,"id":219116,"goal":"lemma SetUnionAssoc_15773(A: set, S: set, U: set)\n ensures (A + S) + U == A + (S + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_15774","instance":15774,"id":219117,"goal":"lemma SetSubsetRefl_15774(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_15775","instance":15775,"id":219118,"goal":"lemma SetSubsetTrans_15775(T: set, A: set, B: set)\n requires T <= A && A <= B\n ensures T <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_15776","instance":15776,"id":219119,"goal":"lemma SetUnionEmpty_15776(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_15777","instance":15777,"id":219120,"goal":"lemma SetInterEmpty_15777(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_15778","instance":15778,"id":219121,"goal":"lemma SetInterSubset_15778(A: set, U: set)\n ensures A * U <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_15779","instance":15779,"id":219122,"goal":"lemma SetCardSubset_15779(B: set, T: set)\n requires B <= T\n ensures |B| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_15780","instance":15780,"id":219123,"goal":"lemma SetUnionCard_15780(B: set, T: set)\n requires B * T == {}\n ensures |B + T| == |B| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_15781","instance":15781,"id":219124,"goal":"lemma SetUnionComm_15781(U: set, B: set)\n ensures U + B == B + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_15782","instance":15782,"id":219125,"goal":"lemma SetInterComm_15782(T: set, S: set)\n ensures T * S == S * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_15783","instance":15783,"id":219126,"goal":"lemma SetUnionAssoc_15783(B: set, S: set, A: set)\n ensures (B + S) + A == B + (S + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_15784","instance":15784,"id":219127,"goal":"lemma SetSubsetRefl_15784(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_15785","instance":15785,"id":219128,"goal":"lemma SetSubsetTrans_15785(U: set, S: set, T: set)\n requires U <= S && S <= T\n ensures U <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_15786","instance":15786,"id":219129,"goal":"lemma SetUnionEmpty_15786(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_15787","instance":15787,"id":219130,"goal":"lemma SetInterEmpty_15787(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_15788","instance":15788,"id":219131,"goal":"lemma SetInterSubset_15788(S: set, T: set)\n ensures S * T <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_15789","instance":15789,"id":219132,"goal":"lemma SetCardSubset_15789(T: set, U: set)\n requires T <= U\n ensures |T| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_15790","instance":15790,"id":219133,"goal":"lemma SetUnionCard_15790(T: set, B: set)\n requires T * B == {}\n ensures |T + B| == |T| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_15791","instance":15791,"id":219134,"goal":"lemma SetUnionComm_15791(T: set, S: set)\n ensures T + S == S + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_15792","instance":15792,"id":219135,"goal":"lemma SetInterComm_15792(A: set, S: set)\n ensures A * S == S * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_15793","instance":15793,"id":219136,"goal":"lemma SetUnionAssoc_15793(T: set, U: set, B: set)\n ensures (T + U) + B == T + (U + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_15794","instance":15794,"id":219137,"goal":"lemma SetSubsetRefl_15794(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_15795","instance":15795,"id":219138,"goal":"lemma SetSubsetTrans_15795(A: set, B: set, T: set)\n requires A <= B && B <= T\n ensures A <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_15796","instance":15796,"id":219139,"goal":"lemma SetUnionEmpty_15796(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_15797","instance":15797,"id":219140,"goal":"lemma SetInterEmpty_15797(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_15798","instance":15798,"id":219141,"goal":"lemma SetInterSubset_15798(S: set, U: set)\n ensures S * U <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_15799","instance":15799,"id":219142,"goal":"lemma SetCardSubset_15799(A: set, B: set)\n requires A <= B\n ensures |A| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_15800","instance":15800,"id":219143,"goal":"lemma SetUnionCard_15800(U: set, A: set)\n requires U * A == {}\n ensures |U + A| == |U| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_15801","instance":15801,"id":219144,"goal":"lemma SetUnionComm_15801(B: set, S: set)\n ensures B + S == S + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_15802","instance":15802,"id":219145,"goal":"lemma SetInterComm_15802(T: set, S: set)\n ensures T * S == S * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_15803","instance":15803,"id":219146,"goal":"lemma SetUnionAssoc_15803(B: set, T: set, U: set)\n ensures (B + T) + U == B + (T + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_15804","instance":15804,"id":219147,"goal":"lemma SetSubsetRefl_15804(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_15805","instance":15805,"id":219148,"goal":"lemma SetSubsetTrans_15805(B: set, A: set, T: set)\n requires B <= A && A <= T\n ensures B <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_15806","instance":15806,"id":219149,"goal":"lemma SetUnionEmpty_15806(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_15807","instance":15807,"id":219150,"goal":"lemma SetInterEmpty_15807(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_15808","instance":15808,"id":219151,"goal":"lemma SetInterSubset_15808(S: set, T: set)\n ensures S * T <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_15809","instance":15809,"id":219152,"goal":"lemma SetCardSubset_15809(B: set, T: set)\n requires B <= T\n ensures |B| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_15810","instance":15810,"id":219153,"goal":"lemma SetUnionCard_15810(U: set, A: set)\n requires U * A == {}\n ensures |U + A| == |U| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_15811","instance":15811,"id":219154,"goal":"lemma SetUnionComm_15811(B: set, U: set)\n ensures B + U == U + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_15812","instance":15812,"id":219155,"goal":"lemma SetInterComm_15812(T: set, A: set)\n ensures T * A == A * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_15813","instance":15813,"id":219156,"goal":"lemma SetUnionAssoc_15813(A: set, U: set, S: set)\n ensures (A + U) + S == A + (U + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_15814","instance":15814,"id":219157,"goal":"lemma SetSubsetRefl_15814(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_15815","instance":15815,"id":219158,"goal":"lemma SetSubsetTrans_15815(S: set, U: set, B: set)\n requires S <= U && U <= B\n ensures S <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_15816","instance":15816,"id":219159,"goal":"lemma SetUnionEmpty_15816(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_15817","instance":15817,"id":219160,"goal":"lemma SetInterEmpty_15817(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_15818","instance":15818,"id":219161,"goal":"lemma SetInterSubset_15818(T: set, U: set)\n ensures T * U <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_15819","instance":15819,"id":219162,"goal":"lemma SetCardSubset_15819(A: set, B: set)\n requires A <= B\n ensures |A| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_15820","instance":15820,"id":219163,"goal":"lemma SetUnionCard_15820(S: set, A: set)\n requires S * A == {}\n ensures |S + A| == |S| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_15821","instance":15821,"id":219164,"goal":"lemma SetUnionComm_15821(B: set, T: set)\n ensures B + T == T + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_15822","instance":15822,"id":219165,"goal":"lemma SetInterComm_15822(A: set, S: set)\n ensures A * S == S * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_15823","instance":15823,"id":219166,"goal":"lemma SetUnionAssoc_15823(T: set, B: set, A: set)\n ensures (T + B) + A == T + (B + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_15824","instance":15824,"id":219167,"goal":"lemma SetSubsetRefl_15824(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_15825","instance":15825,"id":219168,"goal":"lemma SetSubsetTrans_15825(U: set, S: set, A: set)\n requires U <= S && S <= A\n ensures U <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_15826","instance":15826,"id":219169,"goal":"lemma SetUnionEmpty_15826(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_15827","instance":15827,"id":219170,"goal":"lemma SetInterEmpty_15827(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_15828","instance":15828,"id":219171,"goal":"lemma SetInterSubset_15828(A: set, T: set)\n ensures A * T <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_15829","instance":15829,"id":219172,"goal":"lemma SetCardSubset_15829(U: set, T: set)\n requires U <= T\n ensures |U| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_15830","instance":15830,"id":219173,"goal":"lemma SetUnionCard_15830(A: set, T: set)\n requires A * T == {}\n ensures |A + T| == |A| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_15831","instance":15831,"id":219174,"goal":"lemma SetUnionComm_15831(B: set, A: set)\n ensures B + A == A + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_15832","instance":15832,"id":219175,"goal":"lemma SetInterComm_15832(T: set, U: set)\n ensures T * U == U * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_15833","instance":15833,"id":219176,"goal":"lemma SetUnionAssoc_15833(S: set, B: set, T: set)\n ensures (S + B) + T == S + (B + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_15834","instance":15834,"id":219177,"goal":"lemma SetSubsetRefl_15834(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_15835","instance":15835,"id":219178,"goal":"lemma SetSubsetTrans_15835(T: set, U: set, S: set)\n requires T <= U && U <= S\n ensures T <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_15836","instance":15836,"id":219179,"goal":"lemma SetUnionEmpty_15836(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_15837","instance":15837,"id":219180,"goal":"lemma SetInterEmpty_15837(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_15838","instance":15838,"id":219181,"goal":"lemma SetInterSubset_15838(T: set, B: set)\n ensures T * B <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_15839","instance":15839,"id":219182,"goal":"lemma SetCardSubset_15839(A: set, B: set)\n requires A <= B\n ensures |A| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_15840","instance":15840,"id":219183,"goal":"lemma SetUnionCard_15840(T: set, S: set)\n requires T * S == {}\n ensures |T + S| == |T| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_15841","instance":15841,"id":219184,"goal":"lemma SetUnionComm_15841(A: set, B: set)\n ensures A + B == B + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_15842","instance":15842,"id":219185,"goal":"lemma SetInterComm_15842(U: set, B: set)\n ensures U * B == B * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_15843","instance":15843,"id":219186,"goal":"lemma SetUnionAssoc_15843(B: set, U: set, A: set)\n ensures (B + U) + A == B + (U + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_15844","instance":15844,"id":219187,"goal":"lemma SetSubsetRefl_15844(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_15845","instance":15845,"id":219188,"goal":"lemma SetSubsetTrans_15845(U: set, B: set, A: set)\n requires U <= B && B <= A\n ensures U <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_15846","instance":15846,"id":219189,"goal":"lemma SetUnionEmpty_15846(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_15847","instance":15847,"id":219190,"goal":"lemma SetInterEmpty_15847(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_15848","instance":15848,"id":219191,"goal":"lemma SetInterSubset_15848(S: set, T: set)\n ensures S * T <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_15849","instance":15849,"id":219192,"goal":"lemma SetCardSubset_15849(T: set, S: set)\n requires T <= S\n ensures |T| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_15850","instance":15850,"id":219193,"goal":"lemma SetUnionCard_15850(U: set, B: set)\n requires U * B == {}\n ensures |U + B| == |U| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_15851","instance":15851,"id":219194,"goal":"lemma SetUnionComm_15851(U: set, T: set)\n ensures U + T == T + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_15852","instance":15852,"id":219195,"goal":"lemma SetInterComm_15852(T: set, A: set)\n ensures T * A == A * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_15853","instance":15853,"id":219196,"goal":"lemma SetUnionAssoc_15853(B: set, S: set, U: set)\n ensures (B + S) + U == B + (S + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_15854","instance":15854,"id":219197,"goal":"lemma SetSubsetRefl_15854(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_15855","instance":15855,"id":219198,"goal":"lemma SetSubsetTrans_15855(T: set, B: set, U: set)\n requires T <= B && B <= U\n ensures T <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_15856","instance":15856,"id":219199,"goal":"lemma SetUnionEmpty_15856(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_15857","instance":15857,"id":219200,"goal":"lemma SetInterEmpty_15857(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_15858","instance":15858,"id":219201,"goal":"lemma SetInterSubset_15858(T: set, B: set)\n ensures T * B <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_15859","instance":15859,"id":219202,"goal":"lemma SetCardSubset_15859(A: set, B: set)\n requires A <= B\n ensures |A| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_15860","instance":15860,"id":219203,"goal":"lemma SetUnionCard_15860(S: set, B: set)\n requires S * B == {}\n ensures |S + B| == |S| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_15861","instance":15861,"id":219204,"goal":"lemma SetUnionComm_15861(A: set, U: set)\n ensures A + U == U + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_15862","instance":15862,"id":219205,"goal":"lemma SetInterComm_15862(U: set, B: set)\n ensures U * B == B * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_15863","instance":15863,"id":219206,"goal":"lemma SetUnionAssoc_15863(B: set, U: set, T: set)\n ensures (B + U) + T == B + (U + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_15864","instance":15864,"id":219207,"goal":"lemma SetSubsetRefl_15864(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_15865","instance":15865,"id":219208,"goal":"lemma SetSubsetTrans_15865(A: set, B: set, U: set)\n requires A <= B && B <= U\n ensures A <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_15866","instance":15866,"id":219209,"goal":"lemma SetUnionEmpty_15866(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_15867","instance":15867,"id":219210,"goal":"lemma SetInterEmpty_15867(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_15868","instance":15868,"id":219211,"goal":"lemma SetInterSubset_15868(B: set, U: set)\n ensures B * U <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_15869","instance":15869,"id":219212,"goal":"lemma SetCardSubset_15869(U: set, T: set)\n requires U <= T\n ensures |U| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_15870","instance":15870,"id":219213,"goal":"lemma SetUnionCard_15870(A: set, T: set)\n requires A * T == {}\n ensures |A + T| == |A| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_15871","instance":15871,"id":219214,"goal":"lemma SetUnionComm_15871(U: set, S: set)\n ensures U + S == S + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_15872","instance":15872,"id":219215,"goal":"lemma SetInterComm_15872(B: set, A: set)\n ensures B * A == A * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_15873","instance":15873,"id":219216,"goal":"lemma SetUnionAssoc_15873(B: set, S: set, A: set)\n ensures (B + S) + A == B + (S + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_15874","instance":15874,"id":219217,"goal":"lemma SetSubsetRefl_15874(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_15875","instance":15875,"id":219218,"goal":"lemma SetSubsetTrans_15875(A: set, S: set, U: set)\n requires A <= S && S <= U\n ensures A <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_15876","instance":15876,"id":219219,"goal":"lemma SetUnionEmpty_15876(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_15877","instance":15877,"id":219220,"goal":"lemma SetInterEmpty_15877(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_15878","instance":15878,"id":219221,"goal":"lemma SetInterSubset_15878(A: set, U: set)\n ensures A * U <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_15879","instance":15879,"id":219222,"goal":"lemma SetCardSubset_15879(U: set, B: set)\n requires U <= B\n ensures |U| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_15880","instance":15880,"id":219223,"goal":"lemma SetUnionCard_15880(U: set, S: set)\n requires U * S == {}\n ensures |U + S| == |U| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_15881","instance":15881,"id":219224,"goal":"lemma SetUnionComm_15881(A: set, U: set)\n ensures A + U == U + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_15882","instance":15882,"id":219225,"goal":"lemma SetInterComm_15882(U: set, S: set)\n ensures U * S == S * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_15883","instance":15883,"id":219226,"goal":"lemma SetUnionAssoc_15883(S: set, A: set, T: set)\n ensures (S + A) + T == S + (A + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_15884","instance":15884,"id":219227,"goal":"lemma SetSubsetRefl_15884(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_15885","instance":15885,"id":219228,"goal":"lemma SetSubsetTrans_15885(S: set, A: set, U: set)\n requires S <= A && A <= U\n ensures S <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_15886","instance":15886,"id":219229,"goal":"lemma SetUnionEmpty_15886(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_15887","instance":15887,"id":219230,"goal":"lemma SetInterEmpty_15887(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_15888","instance":15888,"id":219231,"goal":"lemma SetInterSubset_15888(A: set, T: set)\n ensures A * T <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_15889","instance":15889,"id":219232,"goal":"lemma SetCardSubset_15889(U: set, T: set)\n requires U <= T\n ensures |U| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_15890","instance":15890,"id":219233,"goal":"lemma SetUnionCard_15890(T: set, B: set)\n requires T * B == {}\n ensures |T + B| == |T| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_15891","instance":15891,"id":219234,"goal":"lemma SetUnionComm_15891(A: set, S: set)\n ensures A + S == S + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_15892","instance":15892,"id":219235,"goal":"lemma SetInterComm_15892(U: set, T: set)\n ensures U * T == T * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_15893","instance":15893,"id":219236,"goal":"lemma SetUnionAssoc_15893(U: set, S: set, B: set)\n ensures (U + S) + B == U + (S + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_15894","instance":15894,"id":219237,"goal":"lemma SetSubsetRefl_15894(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_15895","instance":15895,"id":219238,"goal":"lemma SetSubsetTrans_15895(T: set, S: set, A: set)\n requires T <= S && S <= A\n ensures T <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_15896","instance":15896,"id":219239,"goal":"lemma SetUnionEmpty_15896(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_15897","instance":15897,"id":219240,"goal":"lemma SetInterEmpty_15897(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_15898","instance":15898,"id":219241,"goal":"lemma SetInterSubset_15898(A: set, T: set)\n ensures A * T <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_15899","instance":15899,"id":219242,"goal":"lemma SetCardSubset_15899(A: set, B: set)\n requires A <= B\n ensures |A| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_15900","instance":15900,"id":219243,"goal":"lemma SetUnionCard_15900(S: set, A: set)\n requires S * A == {}\n ensures |S + A| == |S| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_15901","instance":15901,"id":219244,"goal":"lemma SetUnionComm_15901(U: set, A: set)\n ensures U + A == A + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_15902","instance":15902,"id":219245,"goal":"lemma SetInterComm_15902(A: set, S: set)\n ensures A * S == S * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_15903","instance":15903,"id":219246,"goal":"lemma SetUnionAssoc_15903(U: set, B: set, A: set)\n ensures (U + B) + A == U + (B + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_15904","instance":15904,"id":219247,"goal":"lemma SetSubsetRefl_15904(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_15905","instance":15905,"id":219248,"goal":"lemma SetSubsetTrans_15905(T: set, A: set, B: set)\n requires T <= A && A <= B\n ensures T <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_15906","instance":15906,"id":219249,"goal":"lemma SetUnionEmpty_15906(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_15907","instance":15907,"id":219250,"goal":"lemma SetInterEmpty_15907(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_15908","instance":15908,"id":219251,"goal":"lemma SetInterSubset_15908(S: set, U: set)\n ensures S * U <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_15909","instance":15909,"id":219252,"goal":"lemma SetCardSubset_15909(S: set, U: set)\n requires S <= U\n ensures |S| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_15910","instance":15910,"id":219253,"goal":"lemma SetUnionCard_15910(T: set, S: set)\n requires T * S == {}\n ensures |T + S| == |T| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_15911","instance":15911,"id":219254,"goal":"lemma SetUnionComm_15911(T: set, S: set)\n ensures T + S == S + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_15912","instance":15912,"id":219255,"goal":"lemma SetInterComm_15912(S: set, T: set)\n ensures S * T == T * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_15913","instance":15913,"id":219256,"goal":"lemma SetUnionAssoc_15913(B: set, U: set, A: set)\n ensures (B + U) + A == B + (U + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_15914","instance":15914,"id":219257,"goal":"lemma SetSubsetRefl_15914(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_15915","instance":15915,"id":219258,"goal":"lemma SetSubsetTrans_15915(T: set, B: set, A: set)\n requires T <= B && B <= A\n ensures T <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_15916","instance":15916,"id":219259,"goal":"lemma SetUnionEmpty_15916(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_15917","instance":15917,"id":219260,"goal":"lemma SetInterEmpty_15917(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_15918","instance":15918,"id":219261,"goal":"lemma SetInterSubset_15918(B: set, A: set)\n ensures B * A <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_15919","instance":15919,"id":219262,"goal":"lemma SetCardSubset_15919(S: set, B: set)\n requires S <= B\n ensures |S| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_15920","instance":15920,"id":219263,"goal":"lemma SetUnionCard_15920(S: set, T: set)\n requires S * T == {}\n ensures |S + T| == |S| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_15921","instance":15921,"id":219264,"goal":"lemma SetUnionComm_15921(T: set, U: set)\n ensures T + U == U + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_15922","instance":15922,"id":219265,"goal":"lemma SetInterComm_15922(B: set, S: set)\n ensures B * S == S * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_15923","instance":15923,"id":219266,"goal":"lemma SetUnionAssoc_15923(U: set, A: set, S: set)\n ensures (U + A) + S == U + (A + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_15924","instance":15924,"id":219267,"goal":"lemma SetSubsetRefl_15924(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_15925","instance":15925,"id":219268,"goal":"lemma SetSubsetTrans_15925(U: set, A: set, S: set)\n requires U <= A && A <= S\n ensures U <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_15926","instance":15926,"id":219269,"goal":"lemma SetUnionEmpty_15926(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_15927","instance":15927,"id":219270,"goal":"lemma SetInterEmpty_15927(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_15928","instance":15928,"id":219271,"goal":"lemma SetInterSubset_15928(B: set, S: set)\n ensures B * S <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_15929","instance":15929,"id":219272,"goal":"lemma SetCardSubset_15929(S: set, T: set)\n requires S <= T\n ensures |S| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_15930","instance":15930,"id":219273,"goal":"lemma SetUnionCard_15930(U: set, A: set)\n requires U * A == {}\n ensures |U + A| == |U| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_15931","instance":15931,"id":219274,"goal":"lemma SetUnionComm_15931(U: set, A: set)\n ensures U + A == A + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_15932","instance":15932,"id":219275,"goal":"lemma SetInterComm_15932(S: set, U: set)\n ensures S * U == U * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_15933","instance":15933,"id":219276,"goal":"lemma SetUnionAssoc_15933(U: set, T: set, A: set)\n ensures (U + T) + A == U + (T + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_15934","instance":15934,"id":219277,"goal":"lemma SetSubsetRefl_15934(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_15935","instance":15935,"id":219278,"goal":"lemma SetSubsetTrans_15935(S: set, A: set, U: set)\n requires S <= A && A <= U\n ensures S <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_15936","instance":15936,"id":219279,"goal":"lemma SetUnionEmpty_15936(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_15937","instance":15937,"id":219280,"goal":"lemma SetInterEmpty_15937(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_15938","instance":15938,"id":219281,"goal":"lemma SetInterSubset_15938(T: set, A: set)\n ensures T * A <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_15939","instance":15939,"id":219282,"goal":"lemma SetCardSubset_15939(U: set, S: set)\n requires U <= S\n ensures |U| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_15940","instance":15940,"id":219283,"goal":"lemma SetUnionCard_15940(A: set, S: set)\n requires A * S == {}\n ensures |A + S| == |A| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_15941","instance":15941,"id":219284,"goal":"lemma SetUnionComm_15941(A: set, S: set)\n ensures A + S == S + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_15942","instance":15942,"id":219285,"goal":"lemma SetInterComm_15942(B: set, U: set)\n ensures B * U == U * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_15943","instance":15943,"id":219286,"goal":"lemma SetUnionAssoc_15943(T: set, S: set, U: set)\n ensures (T + S) + U == T + (S + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_15944","instance":15944,"id":219287,"goal":"lemma SetSubsetRefl_15944(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_15945","instance":15945,"id":219288,"goal":"lemma SetSubsetTrans_15945(B: set, A: set, T: set)\n requires B <= A && A <= T\n ensures B <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_15946","instance":15946,"id":219289,"goal":"lemma SetUnionEmpty_15946(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_15947","instance":15947,"id":219290,"goal":"lemma SetInterEmpty_15947(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_15948","instance":15948,"id":219291,"goal":"lemma SetInterSubset_15948(B: set, S: set)\n ensures B * S <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_15949","instance":15949,"id":219292,"goal":"lemma SetCardSubset_15949(A: set, T: set)\n requires A <= T\n ensures |A| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_15950","instance":15950,"id":219293,"goal":"lemma SetUnionCard_15950(U: set, B: set)\n requires U * B == {}\n ensures |U + B| == |U| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_15951","instance":15951,"id":219294,"goal":"lemma SetUnionComm_15951(B: set, U: set)\n ensures B + U == U + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_15952","instance":15952,"id":219295,"goal":"lemma SetInterComm_15952(T: set, S: set)\n ensures T * S == S * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_15953","instance":15953,"id":219296,"goal":"lemma SetUnionAssoc_15953(B: set, A: set, S: set)\n ensures (B + A) + S == B + (A + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_15954","instance":15954,"id":219297,"goal":"lemma SetSubsetRefl_15954(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_15955","instance":15955,"id":219298,"goal":"lemma SetSubsetTrans_15955(A: set, T: set, S: set)\n requires A <= T && T <= S\n ensures A <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_15956","instance":15956,"id":219299,"goal":"lemma SetUnionEmpty_15956(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_15957","instance":15957,"id":219300,"goal":"lemma SetInterEmpty_15957(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_15958","instance":15958,"id":219301,"goal":"lemma SetInterSubset_15958(T: set, S: set)\n ensures T * S <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_15959","instance":15959,"id":219302,"goal":"lemma SetCardSubset_15959(B: set, T: set)\n requires B <= T\n ensures |B| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_15960","instance":15960,"id":219303,"goal":"lemma SetUnionCard_15960(T: set, U: set)\n requires T * U == {}\n ensures |T + U| == |T| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_15961","instance":15961,"id":219304,"goal":"lemma SetUnionComm_15961(S: set, U: set)\n ensures S + U == U + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_15962","instance":15962,"id":219305,"goal":"lemma SetInterComm_15962(U: set, B: set)\n ensures U * B == B * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_15963","instance":15963,"id":219306,"goal":"lemma SetUnionAssoc_15963(S: set, U: set, T: set)\n ensures (S + U) + T == S + (U + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_15964","instance":15964,"id":219307,"goal":"lemma SetSubsetRefl_15964(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_15965","instance":15965,"id":219308,"goal":"lemma SetSubsetTrans_15965(A: set, U: set, T: set)\n requires A <= U && U <= T\n ensures A <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_15966","instance":15966,"id":219309,"goal":"lemma SetUnionEmpty_15966(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_15967","instance":15967,"id":219310,"goal":"lemma SetInterEmpty_15967(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_15968","instance":15968,"id":219311,"goal":"lemma SetInterSubset_15968(B: set, S: set)\n ensures B * S <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_15969","instance":15969,"id":219312,"goal":"lemma SetCardSubset_15969(A: set, B: set)\n requires A <= B\n ensures |A| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_15970","instance":15970,"id":219313,"goal":"lemma SetUnionCard_15970(B: set, U: set)\n requires B * U == {}\n ensures |B + U| == |B| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_15971","instance":15971,"id":219314,"goal":"lemma SetUnionComm_15971(U: set, B: set)\n ensures U + B == B + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_15972","instance":15972,"id":219315,"goal":"lemma SetInterComm_15972(B: set, S: set)\n ensures B * S == S * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_15973","instance":15973,"id":219316,"goal":"lemma SetUnionAssoc_15973(A: set, U: set, T: set)\n ensures (A + U) + T == A + (U + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_15974","instance":15974,"id":219317,"goal":"lemma SetSubsetRefl_15974(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_15975","instance":15975,"id":219318,"goal":"lemma SetSubsetTrans_15975(U: set, S: set, B: set)\n requires U <= S && S <= B\n ensures U <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_15976","instance":15976,"id":219319,"goal":"lemma SetUnionEmpty_15976(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_15977","instance":15977,"id":219320,"goal":"lemma SetInterEmpty_15977(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_15978","instance":15978,"id":219321,"goal":"lemma SetInterSubset_15978(T: set, U: set)\n ensures T * U <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_15979","instance":15979,"id":219322,"goal":"lemma SetCardSubset_15979(A: set, B: set)\n requires A <= B\n ensures |A| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_15980","instance":15980,"id":219323,"goal":"lemma SetUnionCard_15980(A: set, U: set)\n requires A * U == {}\n ensures |A + U| == |A| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_15981","instance":15981,"id":219324,"goal":"lemma SetUnionComm_15981(S: set, B: set)\n ensures S + B == B + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_15982","instance":15982,"id":219325,"goal":"lemma SetInterComm_15982(U: set, A: set)\n ensures U * A == A * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_15983","instance":15983,"id":219326,"goal":"lemma SetUnionAssoc_15983(T: set, U: set, B: set)\n ensures (T + U) + B == T + (U + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_15984","instance":15984,"id":219327,"goal":"lemma SetSubsetRefl_15984(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_15985","instance":15985,"id":219328,"goal":"lemma SetSubsetTrans_15985(U: set, A: set, S: set)\n requires U <= A && A <= S\n ensures U <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_15986","instance":15986,"id":219329,"goal":"lemma SetUnionEmpty_15986(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_15987","instance":15987,"id":219330,"goal":"lemma SetInterEmpty_15987(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_15988","instance":15988,"id":219331,"goal":"lemma SetInterSubset_15988(B: set, A: set)\n ensures B * A <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_15989","instance":15989,"id":219332,"goal":"lemma SetCardSubset_15989(U: set, T: set)\n requires U <= T\n ensures |U| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_15990","instance":15990,"id":219333,"goal":"lemma SetUnionCard_15990(T: set, S: set)\n requires T * S == {}\n ensures |T + S| == |T| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_15991","instance":15991,"id":219334,"goal":"lemma SetUnionComm_15991(U: set, B: set)\n ensures U + B == B + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_15992","instance":15992,"id":219335,"goal":"lemma SetInterComm_15992(S: set, U: set)\n ensures S * U == U * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_15993","instance":15993,"id":219336,"goal":"lemma SetUnionAssoc_15993(T: set, A: set, U: set)\n ensures (T + A) + U == T + (A + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_15994","instance":15994,"id":219337,"goal":"lemma SetSubsetRefl_15994(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_15995","instance":15995,"id":219338,"goal":"lemma SetSubsetTrans_15995(S: set, T: set, A: set)\n requires S <= T && T <= A\n ensures S <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_15996","instance":15996,"id":219339,"goal":"lemma SetUnionEmpty_15996(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_15997","instance":15997,"id":219340,"goal":"lemma SetInterEmpty_15997(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_15998","instance":15998,"id":219341,"goal":"lemma SetInterSubset_15998(U: set, A: set)\n ensures U * A <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_15999","instance":15999,"id":219342,"goal":"lemma SetCardSubset_15999(S: set, B: set)\n requires S <= B\n ensures |S| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_16000","instance":16000,"id":219343,"goal":"lemma SetUnionCard_16000(A: set, T: set)\n requires A * T == {}\n ensures |A + T| == |A| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_16001","instance":16001,"id":219344,"goal":"lemma SetUnionComm_16001(S: set, A: set)\n ensures S + A == A + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_16002","instance":16002,"id":219345,"goal":"lemma SetInterComm_16002(U: set, S: set)\n ensures U * S == S * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_16003","instance":16003,"id":219346,"goal":"lemma SetUnionAssoc_16003(U: set, A: set, S: set)\n ensures (U + A) + S == U + (A + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_16004","instance":16004,"id":219347,"goal":"lemma SetSubsetRefl_16004(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_16005","instance":16005,"id":219348,"goal":"lemma SetSubsetTrans_16005(A: set, B: set, U: set)\n requires A <= B && B <= U\n ensures A <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_16006","instance":16006,"id":219349,"goal":"lemma SetUnionEmpty_16006(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_16007","instance":16007,"id":219350,"goal":"lemma SetInterEmpty_16007(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_16008","instance":16008,"id":219351,"goal":"lemma SetInterSubset_16008(T: set, A: set)\n ensures T * A <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_16009","instance":16009,"id":219352,"goal":"lemma SetCardSubset_16009(T: set, A: set)\n requires T <= A\n ensures |T| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_16010","instance":16010,"id":219353,"goal":"lemma SetUnionCard_16010(S: set, A: set)\n requires S * A == {}\n ensures |S + A| == |S| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_16011","instance":16011,"id":219354,"goal":"lemma SetUnionComm_16011(A: set, B: set)\n ensures A + B == B + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_16012","instance":16012,"id":219355,"goal":"lemma SetInterComm_16012(A: set, B: set)\n ensures A * B == B * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_16013","instance":16013,"id":219356,"goal":"lemma SetUnionAssoc_16013(S: set, T: set, U: set)\n ensures (S + T) + U == S + (T + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_16014","instance":16014,"id":219357,"goal":"lemma SetSubsetRefl_16014(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_16015","instance":16015,"id":219358,"goal":"lemma SetSubsetTrans_16015(T: set, A: set, U: set)\n requires T <= A && A <= U\n ensures T <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_16016","instance":16016,"id":219359,"goal":"lemma SetUnionEmpty_16016(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_16017","instance":16017,"id":219360,"goal":"lemma SetInterEmpty_16017(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_16018","instance":16018,"id":219361,"goal":"lemma SetInterSubset_16018(S: set, A: set)\n ensures S * A <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_16019","instance":16019,"id":219362,"goal":"lemma SetCardSubset_16019(T: set, U: set)\n requires T <= U\n ensures |T| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_16020","instance":16020,"id":219363,"goal":"lemma SetUnionCard_16020(A: set, S: set)\n requires A * S == {}\n ensures |A + S| == |A| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_16021","instance":16021,"id":219364,"goal":"lemma SetUnionComm_16021(A: set, U: set)\n ensures A + U == U + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_16022","instance":16022,"id":219365,"goal":"lemma SetInterComm_16022(S: set, B: set)\n ensures S * B == B * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_16023","instance":16023,"id":219366,"goal":"lemma SetUnionAssoc_16023(B: set, U: set, T: set)\n ensures (B + U) + T == B + (U + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_16024","instance":16024,"id":219367,"goal":"lemma SetSubsetRefl_16024(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_16025","instance":16025,"id":219368,"goal":"lemma SetSubsetTrans_16025(A: set, T: set, U: set)\n requires A <= T && T <= U\n ensures A <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_16026","instance":16026,"id":219369,"goal":"lemma SetUnionEmpty_16026(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_16027","instance":16027,"id":219370,"goal":"lemma SetInterEmpty_16027(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_16028","instance":16028,"id":219371,"goal":"lemma SetInterSubset_16028(T: set, A: set)\n ensures T * A <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_16029","instance":16029,"id":219372,"goal":"lemma SetCardSubset_16029(T: set, B: set)\n requires T <= B\n ensures |T| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_16030","instance":16030,"id":219373,"goal":"lemma SetUnionCard_16030(A: set, U: set)\n requires A * U == {}\n ensures |A + U| == |A| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_16031","instance":16031,"id":219374,"goal":"lemma SetUnionComm_16031(T: set, U: set)\n ensures T + U == U + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_16032","instance":16032,"id":219375,"goal":"lemma SetInterComm_16032(S: set, T: set)\n ensures S * T == T * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_16033","instance":16033,"id":219376,"goal":"lemma SetUnionAssoc_16033(U: set, A: set, T: set)\n ensures (U + A) + T == U + (A + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_16034","instance":16034,"id":219377,"goal":"lemma SetSubsetRefl_16034(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_16035","instance":16035,"id":219378,"goal":"lemma SetSubsetTrans_16035(U: set, T: set, S: set)\n requires U <= T && T <= S\n ensures U <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_16036","instance":16036,"id":219379,"goal":"lemma SetUnionEmpty_16036(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_16037","instance":16037,"id":219380,"goal":"lemma SetInterEmpty_16037(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_16038","instance":16038,"id":219381,"goal":"lemma SetInterSubset_16038(B: set, A: set)\n ensures B * A <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_16039","instance":16039,"id":219382,"goal":"lemma SetCardSubset_16039(B: set, A: set)\n requires B <= A\n ensures |B| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_16040","instance":16040,"id":219383,"goal":"lemma SetUnionCard_16040(B: set, U: set)\n requires B * U == {}\n ensures |B + U| == |B| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_16041","instance":16041,"id":219384,"goal":"lemma SetUnionComm_16041(A: set, T: set)\n ensures A + T == T + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_16042","instance":16042,"id":219385,"goal":"lemma SetInterComm_16042(S: set, A: set)\n ensures S * A == A * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_16043","instance":16043,"id":219386,"goal":"lemma SetUnionAssoc_16043(B: set, A: set, U: set)\n ensures (B + A) + U == B + (A + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_16044","instance":16044,"id":219387,"goal":"lemma SetSubsetRefl_16044(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_16045","instance":16045,"id":219388,"goal":"lemma SetSubsetTrans_16045(S: set, U: set, B: set)\n requires S <= U && U <= B\n ensures S <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_16046","instance":16046,"id":219389,"goal":"lemma SetUnionEmpty_16046(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_16047","instance":16047,"id":219390,"goal":"lemma SetInterEmpty_16047(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_16048","instance":16048,"id":219391,"goal":"lemma SetInterSubset_16048(T: set, A: set)\n ensures T * A <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_16049","instance":16049,"id":219392,"goal":"lemma SetCardSubset_16049(T: set, A: set)\n requires T <= A\n ensures |T| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_16050","instance":16050,"id":219393,"goal":"lemma SetUnionCard_16050(B: set, T: set)\n requires B * T == {}\n ensures |B + T| == |B| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_16051","instance":16051,"id":219394,"goal":"lemma SetUnionComm_16051(A: set, T: set)\n ensures A + T == T + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_16052","instance":16052,"id":219395,"goal":"lemma SetInterComm_16052(T: set, A: set)\n ensures T * A == A * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_16053","instance":16053,"id":219396,"goal":"lemma SetUnionAssoc_16053(T: set, U: set, S: set)\n ensures (T + U) + S == T + (U + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_16054","instance":16054,"id":219397,"goal":"lemma SetSubsetRefl_16054(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_16055","instance":16055,"id":219398,"goal":"lemma SetSubsetTrans_16055(B: set, T: set, A: set)\n requires B <= T && T <= A\n ensures B <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_16056","instance":16056,"id":219399,"goal":"lemma SetUnionEmpty_16056(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_16057","instance":16057,"id":219400,"goal":"lemma SetInterEmpty_16057(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_16058","instance":16058,"id":219401,"goal":"lemma SetInterSubset_16058(B: set, A: set)\n ensures B * A <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_16059","instance":16059,"id":219402,"goal":"lemma SetCardSubset_16059(B: set, A: set)\n requires B <= A\n ensures |B| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_16060","instance":16060,"id":219403,"goal":"lemma SetUnionCard_16060(U: set, T: set)\n requires U * T == {}\n ensures |U + T| == |U| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_16061","instance":16061,"id":219404,"goal":"lemma SetUnionComm_16061(S: set, A: set)\n ensures S + A == A + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_16062","instance":16062,"id":219405,"goal":"lemma SetInterComm_16062(T: set, B: set)\n ensures T * B == B * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_16063","instance":16063,"id":219406,"goal":"lemma SetUnionAssoc_16063(U: set, T: set, A: set)\n ensures (U + T) + A == U + (T + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_16064","instance":16064,"id":219407,"goal":"lemma SetSubsetRefl_16064(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_16065","instance":16065,"id":219408,"goal":"lemma SetSubsetTrans_16065(S: set, A: set, U: set)\n requires S <= A && A <= U\n ensures S <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_16066","instance":16066,"id":219409,"goal":"lemma SetUnionEmpty_16066(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_16067","instance":16067,"id":219410,"goal":"lemma SetInterEmpty_16067(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_16068","instance":16068,"id":219411,"goal":"lemma SetInterSubset_16068(A: set, S: set)\n ensures A * S <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_16069","instance":16069,"id":219412,"goal":"lemma SetCardSubset_16069(T: set, A: set)\n requires T <= A\n ensures |T| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_16070","instance":16070,"id":219413,"goal":"lemma SetUnionCard_16070(A: set, T: set)\n requires A * T == {}\n ensures |A + T| == |A| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_16071","instance":16071,"id":219414,"goal":"lemma SetUnionComm_16071(S: set, T: set)\n ensures S + T == T + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_16072","instance":16072,"id":219415,"goal":"lemma SetInterComm_16072(B: set, S: set)\n ensures B * S == S * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_16073","instance":16073,"id":219416,"goal":"lemma SetUnionAssoc_16073(S: set, B: set, A: set)\n ensures (S + B) + A == S + (B + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_16074","instance":16074,"id":219417,"goal":"lemma SetSubsetRefl_16074(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_16075","instance":16075,"id":219418,"goal":"lemma SetSubsetTrans_16075(T: set, B: set, S: set)\n requires T <= B && B <= S\n ensures T <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_16076","instance":16076,"id":219419,"goal":"lemma SetUnionEmpty_16076(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_16077","instance":16077,"id":219420,"goal":"lemma SetInterEmpty_16077(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_16078","instance":16078,"id":219421,"goal":"lemma SetInterSubset_16078(U: set, T: set)\n ensures U * T <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_16079","instance":16079,"id":219422,"goal":"lemma SetCardSubset_16079(U: set, A: set)\n requires U <= A\n ensures |U| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_16080","instance":16080,"id":219423,"goal":"lemma SetUnionCard_16080(B: set, T: set)\n requires B * T == {}\n ensures |B + T| == |B| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_16081","instance":16081,"id":219424,"goal":"lemma SetUnionComm_16081(A: set, U: set)\n ensures A + U == U + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_16082","instance":16082,"id":219425,"goal":"lemma SetInterComm_16082(A: set, T: set)\n ensures A * T == T * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_16083","instance":16083,"id":219426,"goal":"lemma SetUnionAssoc_16083(U: set, A: set, S: set)\n ensures (U + A) + S == U + (A + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_16084","instance":16084,"id":219427,"goal":"lemma SetSubsetRefl_16084(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_16085","instance":16085,"id":219428,"goal":"lemma SetSubsetTrans_16085(A: set, B: set, T: set)\n requires A <= B && B <= T\n ensures A <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_16086","instance":16086,"id":219429,"goal":"lemma SetUnionEmpty_16086(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_16087","instance":16087,"id":219430,"goal":"lemma SetInterEmpty_16087(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_16088","instance":16088,"id":219431,"goal":"lemma SetInterSubset_16088(B: set, S: set)\n ensures B * S <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_16089","instance":16089,"id":219432,"goal":"lemma SetCardSubset_16089(U: set, T: set)\n requires U <= T\n ensures |U| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_16090","instance":16090,"id":219433,"goal":"lemma SetUnionCard_16090(U: set, T: set)\n requires U * T == {}\n ensures |U + T| == |U| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_16091","instance":16091,"id":219434,"goal":"lemma SetUnionComm_16091(B: set, T: set)\n ensures B + T == T + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_16092","instance":16092,"id":219435,"goal":"lemma SetInterComm_16092(T: set, U: set)\n ensures T * U == U * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_16093","instance":16093,"id":219436,"goal":"lemma SetUnionAssoc_16093(U: set, A: set, B: set)\n ensures (U + A) + B == U + (A + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_16094","instance":16094,"id":219437,"goal":"lemma SetSubsetRefl_16094(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_16095","instance":16095,"id":219438,"goal":"lemma SetSubsetTrans_16095(S: set, B: set, U: set)\n requires S <= B && B <= U\n ensures S <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_16096","instance":16096,"id":219439,"goal":"lemma SetUnionEmpty_16096(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_16097","instance":16097,"id":219440,"goal":"lemma SetInterEmpty_16097(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_16098","instance":16098,"id":219441,"goal":"lemma SetInterSubset_16098(T: set, U: set)\n ensures T * U <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_16099","instance":16099,"id":219442,"goal":"lemma SetCardSubset_16099(U: set, B: set)\n requires U <= B\n ensures |U| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_16100","instance":16100,"id":219443,"goal":"lemma SetUnionCard_16100(S: set, B: set)\n requires S * B == {}\n ensures |S + B| == |S| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_16101","instance":16101,"id":219444,"goal":"lemma SetUnionComm_16101(S: set, A: set)\n ensures S + A == A + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_16102","instance":16102,"id":219445,"goal":"lemma SetInterComm_16102(A: set, B: set)\n ensures A * B == B * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_16103","instance":16103,"id":219446,"goal":"lemma SetUnionAssoc_16103(A: set, B: set, T: set)\n ensures (A + B) + T == A + (B + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_16104","instance":16104,"id":219447,"goal":"lemma SetSubsetRefl_16104(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_16105","instance":16105,"id":219448,"goal":"lemma SetSubsetTrans_16105(T: set, B: set, A: set)\n requires T <= B && B <= A\n ensures T <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_16106","instance":16106,"id":219449,"goal":"lemma SetUnionEmpty_16106(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_16107","instance":16107,"id":219450,"goal":"lemma SetInterEmpty_16107(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_16108","instance":16108,"id":219451,"goal":"lemma SetInterSubset_16108(S: set, U: set)\n ensures S * U <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_16109","instance":16109,"id":219452,"goal":"lemma SetCardSubset_16109(B: set, T: set)\n requires B <= T\n ensures |B| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_16110","instance":16110,"id":219453,"goal":"lemma SetUnionCard_16110(B: set, T: set)\n requires B * T == {}\n ensures |B + T| == |B| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_16111","instance":16111,"id":219454,"goal":"lemma SetUnionComm_16111(B: set, A: set)\n ensures B + A == A + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_16112","instance":16112,"id":219455,"goal":"lemma SetInterComm_16112(B: set, U: set)\n ensures B * U == U * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_16113","instance":16113,"id":219456,"goal":"lemma SetUnionAssoc_16113(T: set, S: set, U: set)\n ensures (T + S) + U == T + (S + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_16114","instance":16114,"id":219457,"goal":"lemma SetSubsetRefl_16114(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_16115","instance":16115,"id":219458,"goal":"lemma SetSubsetTrans_16115(B: set, T: set, U: set)\n requires B <= T && T <= U\n ensures B <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_16116","instance":16116,"id":219459,"goal":"lemma SetUnionEmpty_16116(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_16117","instance":16117,"id":219460,"goal":"lemma SetInterEmpty_16117(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_16118","instance":16118,"id":219461,"goal":"lemma SetInterSubset_16118(U: set, S: set)\n ensures U * S <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_16119","instance":16119,"id":219462,"goal":"lemma SetCardSubset_16119(A: set, S: set)\n requires A <= S\n ensures |A| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_16120","instance":16120,"id":219463,"goal":"lemma SetUnionCard_16120(A: set, T: set)\n requires A * T == {}\n ensures |A + T| == |A| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_16121","instance":16121,"id":219464,"goal":"lemma SetUnionComm_16121(A: set, S: set)\n ensures A + S == S + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_16122","instance":16122,"id":219465,"goal":"lemma SetInterComm_16122(A: set, U: set)\n ensures A * U == U * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_16123","instance":16123,"id":219466,"goal":"lemma SetUnionAssoc_16123(B: set, S: set, A: set)\n ensures (B + S) + A == B + (S + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_16124","instance":16124,"id":219467,"goal":"lemma SetSubsetRefl_16124(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_16125","instance":16125,"id":219468,"goal":"lemma SetSubsetTrans_16125(S: set, A: set, B: set)\n requires S <= A && A <= B\n ensures S <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_16126","instance":16126,"id":219469,"goal":"lemma SetUnionEmpty_16126(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_16127","instance":16127,"id":219470,"goal":"lemma SetInterEmpty_16127(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_16128","instance":16128,"id":219471,"goal":"lemma SetInterSubset_16128(S: set, A: set)\n ensures S * A <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_16129","instance":16129,"id":219472,"goal":"lemma SetCardSubset_16129(A: set, U: set)\n requires A <= U\n ensures |A| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_16130","instance":16130,"id":219473,"goal":"lemma SetUnionCard_16130(B: set, U: set)\n requires B * U == {}\n ensures |B + U| == |B| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_16131","instance":16131,"id":219474,"goal":"lemma SetUnionComm_16131(B: set, A: set)\n ensures B + A == A + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_16132","instance":16132,"id":219475,"goal":"lemma SetInterComm_16132(B: set, U: set)\n ensures B * U == U * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_16133","instance":16133,"id":219476,"goal":"lemma SetUnionAssoc_16133(S: set, T: set, U: set)\n ensures (S + T) + U == S + (T + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_16134","instance":16134,"id":219477,"goal":"lemma SetSubsetRefl_16134(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_16135","instance":16135,"id":219478,"goal":"lemma SetSubsetTrans_16135(B: set, S: set, U: set)\n requires B <= S && S <= U\n ensures B <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_16136","instance":16136,"id":219479,"goal":"lemma SetUnionEmpty_16136(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_16137","instance":16137,"id":219480,"goal":"lemma SetInterEmpty_16137(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_16138","instance":16138,"id":219481,"goal":"lemma SetInterSubset_16138(B: set, S: set)\n ensures B * S <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_16139","instance":16139,"id":219482,"goal":"lemma SetCardSubset_16139(T: set, U: set)\n requires T <= U\n ensures |T| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_16140","instance":16140,"id":219483,"goal":"lemma SetUnionCard_16140(T: set, B: set)\n requires T * B == {}\n ensures |T + B| == |T| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_16141","instance":16141,"id":219484,"goal":"lemma SetUnionComm_16141(S: set, T: set)\n ensures S + T == T + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_16142","instance":16142,"id":219485,"goal":"lemma SetInterComm_16142(A: set, B: set)\n ensures A * B == B * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_16143","instance":16143,"id":219486,"goal":"lemma SetUnionAssoc_16143(B: set, A: set, T: set)\n ensures (B + A) + T == B + (A + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_16144","instance":16144,"id":219487,"goal":"lemma SetSubsetRefl_16144(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_16145","instance":16145,"id":219488,"goal":"lemma SetSubsetTrans_16145(T: set, U: set, S: set)\n requires T <= U && U <= S\n ensures T <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_16146","instance":16146,"id":219489,"goal":"lemma SetUnionEmpty_16146(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_16147","instance":16147,"id":219490,"goal":"lemma SetInterEmpty_16147(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_16148","instance":16148,"id":219491,"goal":"lemma SetInterSubset_16148(T: set, B: set)\n ensures T * B <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_16149","instance":16149,"id":219492,"goal":"lemma SetCardSubset_16149(S: set, B: set)\n requires S <= B\n ensures |S| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_16150","instance":16150,"id":219493,"goal":"lemma SetUnionCard_16150(A: set, B: set)\n requires A * B == {}\n ensures |A + B| == |A| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_16151","instance":16151,"id":219494,"goal":"lemma SetUnionComm_16151(A: set, T: set)\n ensures A + T == T + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_16152","instance":16152,"id":219495,"goal":"lemma SetInterComm_16152(T: set, A: set)\n ensures T * A == A * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_16153","instance":16153,"id":219496,"goal":"lemma SetUnionAssoc_16153(A: set, T: set, B: set)\n ensures (A + T) + B == A + (T + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_16154","instance":16154,"id":219497,"goal":"lemma SetSubsetRefl_16154(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_16155","instance":16155,"id":219498,"goal":"lemma SetSubsetTrans_16155(A: set, B: set, T: set)\n requires A <= B && B <= T\n ensures A <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_16156","instance":16156,"id":219499,"goal":"lemma SetUnionEmpty_16156(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_16157","instance":16157,"id":219500,"goal":"lemma SetInterEmpty_16157(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_16158","instance":16158,"id":219501,"goal":"lemma SetInterSubset_16158(U: set, B: set)\n ensures U * B <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_16159","instance":16159,"id":219502,"goal":"lemma SetCardSubset_16159(A: set, B: set)\n requires A <= B\n ensures |A| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_16160","instance":16160,"id":219503,"goal":"lemma SetUnionCard_16160(U: set, B: set)\n requires U * B == {}\n ensures |U + B| == |U| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_16161","instance":16161,"id":219504,"goal":"lemma SetUnionComm_16161(A: set, S: set)\n ensures A + S == S + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_16162","instance":16162,"id":219505,"goal":"lemma SetInterComm_16162(S: set, B: set)\n ensures S * B == B * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_16163","instance":16163,"id":219506,"goal":"lemma SetUnionAssoc_16163(S: set, A: set, B: set)\n ensures (S + A) + B == S + (A + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_16164","instance":16164,"id":219507,"goal":"lemma SetSubsetRefl_16164(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_16165","instance":16165,"id":219508,"goal":"lemma SetSubsetTrans_16165(S: set, A: set, B: set)\n requires S <= A && A <= B\n ensures S <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_16166","instance":16166,"id":219509,"goal":"lemma SetUnionEmpty_16166(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_16167","instance":16167,"id":219510,"goal":"lemma SetInterEmpty_16167(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_16168","instance":16168,"id":219511,"goal":"lemma SetInterSubset_16168(S: set, A: set)\n ensures S * A <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_16169","instance":16169,"id":219512,"goal":"lemma SetCardSubset_16169(B: set, A: set)\n requires B <= A\n ensures |B| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_16170","instance":16170,"id":219513,"goal":"lemma SetUnionCard_16170(A: set, T: set)\n requires A * T == {}\n ensures |A + T| == |A| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_16171","instance":16171,"id":219514,"goal":"lemma SetUnionComm_16171(A: set, S: set)\n ensures A + S == S + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_16172","instance":16172,"id":219515,"goal":"lemma SetInterComm_16172(T: set, A: set)\n ensures T * A == A * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_16173","instance":16173,"id":219516,"goal":"lemma SetUnionAssoc_16173(A: set, U: set, B: set)\n ensures (A + U) + B == A + (U + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_16174","instance":16174,"id":219517,"goal":"lemma SetSubsetRefl_16174(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_16175","instance":16175,"id":219518,"goal":"lemma SetSubsetTrans_16175(U: set, T: set, A: set)\n requires U <= T && T <= A\n ensures U <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_16176","instance":16176,"id":219519,"goal":"lemma SetUnionEmpty_16176(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_16177","instance":16177,"id":219520,"goal":"lemma SetInterEmpty_16177(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_16178","instance":16178,"id":219521,"goal":"lemma SetInterSubset_16178(A: set, B: set)\n ensures A * B <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_16179","instance":16179,"id":219522,"goal":"lemma SetCardSubset_16179(T: set, U: set)\n requires T <= U\n ensures |T| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_16180","instance":16180,"id":219523,"goal":"lemma SetUnionCard_16180(S: set, B: set)\n requires S * B == {}\n ensures |S + B| == |S| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_16181","instance":16181,"id":219524,"goal":"lemma SetUnionComm_16181(T: set, B: set)\n ensures T + B == B + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_16182","instance":16182,"id":219525,"goal":"lemma SetInterComm_16182(U: set, A: set)\n ensures U * A == A * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_16183","instance":16183,"id":219526,"goal":"lemma SetUnionAssoc_16183(T: set, A: set, B: set)\n ensures (T + A) + B == T + (A + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_16184","instance":16184,"id":219527,"goal":"lemma SetSubsetRefl_16184(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_16185","instance":16185,"id":219528,"goal":"lemma SetSubsetTrans_16185(B: set, T: set, S: set)\n requires B <= T && T <= S\n ensures B <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_16186","instance":16186,"id":219529,"goal":"lemma SetUnionEmpty_16186(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_16187","instance":16187,"id":219530,"goal":"lemma SetInterEmpty_16187(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_16188","instance":16188,"id":219531,"goal":"lemma SetInterSubset_16188(T: set, B: set)\n ensures T * B <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_16189","instance":16189,"id":219532,"goal":"lemma SetCardSubset_16189(A: set, B: set)\n requires A <= B\n ensures |A| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_16190","instance":16190,"id":219533,"goal":"lemma SetUnionCard_16190(U: set, T: set)\n requires U * T == {}\n ensures |U + T| == |U| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_16191","instance":16191,"id":219534,"goal":"lemma SetUnionComm_16191(T: set, B: set)\n ensures T + B == B + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_16192","instance":16192,"id":219535,"goal":"lemma SetInterComm_16192(A: set, B: set)\n ensures A * B == B * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_16193","instance":16193,"id":219536,"goal":"lemma SetUnionAssoc_16193(S: set, T: set, A: set)\n ensures (S + T) + A == S + (T + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_16194","instance":16194,"id":219537,"goal":"lemma SetSubsetRefl_16194(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_16195","instance":16195,"id":219538,"goal":"lemma SetSubsetTrans_16195(A: set, T: set, S: set)\n requires A <= T && T <= S\n ensures A <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_16196","instance":16196,"id":219539,"goal":"lemma SetUnionEmpty_16196(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_16197","instance":16197,"id":219540,"goal":"lemma SetInterEmpty_16197(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_16198","instance":16198,"id":219541,"goal":"lemma SetInterSubset_16198(U: set, T: set)\n ensures U * T <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_16199","instance":16199,"id":219542,"goal":"lemma SetCardSubset_16199(B: set, A: set)\n requires B <= A\n ensures |B| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_16200","instance":16200,"id":219543,"goal":"lemma SetUnionCard_16200(A: set, U: set)\n requires A * U == {}\n ensures |A + U| == |A| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_16201","instance":16201,"id":219544,"goal":"lemma SetUnionComm_16201(S: set, U: set)\n ensures S + U == U + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_16202","instance":16202,"id":219545,"goal":"lemma SetInterComm_16202(U: set, S: set)\n ensures U * S == S * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_16203","instance":16203,"id":219546,"goal":"lemma SetUnionAssoc_16203(B: set, A: set, S: set)\n ensures (B + A) + S == B + (A + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_16204","instance":16204,"id":219547,"goal":"lemma SetSubsetRefl_16204(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_16205","instance":16205,"id":219548,"goal":"lemma SetSubsetTrans_16205(B: set, A: set, T: set)\n requires B <= A && A <= T\n ensures B <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_16206","instance":16206,"id":219549,"goal":"lemma SetUnionEmpty_16206(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_16207","instance":16207,"id":219550,"goal":"lemma SetInterEmpty_16207(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_16208","instance":16208,"id":219551,"goal":"lemma SetInterSubset_16208(A: set, S: set)\n ensures A * S <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_16209","instance":16209,"id":219552,"goal":"lemma SetCardSubset_16209(S: set, T: set)\n requires S <= T\n ensures |S| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_16210","instance":16210,"id":219553,"goal":"lemma SetUnionCard_16210(S: set, A: set)\n requires S * A == {}\n ensures |S + A| == |S| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_16211","instance":16211,"id":219554,"goal":"lemma SetUnionComm_16211(A: set, T: set)\n ensures A + T == T + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_16212","instance":16212,"id":219555,"goal":"lemma SetInterComm_16212(B: set, S: set)\n ensures B * S == S * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_16213","instance":16213,"id":219556,"goal":"lemma SetUnionAssoc_16213(A: set, T: set, B: set)\n ensures (A + T) + B == A + (T + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_16214","instance":16214,"id":219557,"goal":"lemma SetSubsetRefl_16214(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_16215","instance":16215,"id":219558,"goal":"lemma SetSubsetTrans_16215(B: set, S: set, U: set)\n requires B <= S && S <= U\n ensures B <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_16216","instance":16216,"id":219559,"goal":"lemma SetUnionEmpty_16216(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_16217","instance":16217,"id":219560,"goal":"lemma SetInterEmpty_16217(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_16218","instance":16218,"id":219561,"goal":"lemma SetInterSubset_16218(S: set, T: set)\n ensures S * T <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_16219","instance":16219,"id":219562,"goal":"lemma SetCardSubset_16219(A: set, S: set)\n requires A <= S\n ensures |A| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_16220","instance":16220,"id":219563,"goal":"lemma SetUnionCard_16220(U: set, T: set)\n requires U * T == {}\n ensures |U + T| == |U| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_16221","instance":16221,"id":219564,"goal":"lemma SetUnionComm_16221(A: set, U: set)\n ensures A + U == U + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_16222","instance":16222,"id":219565,"goal":"lemma SetInterComm_16222(S: set, T: set)\n ensures S * T == T * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_16223","instance":16223,"id":219566,"goal":"lemma SetUnionAssoc_16223(T: set, S: set, A: set)\n ensures (T + S) + A == T + (S + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_16224","instance":16224,"id":219567,"goal":"lemma SetSubsetRefl_16224(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_16225","instance":16225,"id":219568,"goal":"lemma SetSubsetTrans_16225(A: set, B: set, T: set)\n requires A <= B && B <= T\n ensures A <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_16226","instance":16226,"id":219569,"goal":"lemma SetUnionEmpty_16226(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_16227","instance":16227,"id":219570,"goal":"lemma SetInterEmpty_16227(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_16228","instance":16228,"id":219571,"goal":"lemma SetInterSubset_16228(B: set, A: set)\n ensures B * A <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_16229","instance":16229,"id":219572,"goal":"lemma SetCardSubset_16229(U: set, A: set)\n requires U <= A\n ensures |U| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_16230","instance":16230,"id":219573,"goal":"lemma SetUnionCard_16230(B: set, A: set)\n requires B * A == {}\n ensures |B + A| == |B| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_16231","instance":16231,"id":219574,"goal":"lemma SetUnionComm_16231(B: set, S: set)\n ensures B + S == S + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_16232","instance":16232,"id":219575,"goal":"lemma SetInterComm_16232(S: set, B: set)\n ensures S * B == B * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_16233","instance":16233,"id":219576,"goal":"lemma SetUnionAssoc_16233(S: set, T: set, U: set)\n ensures (S + T) + U == S + (T + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_16234","instance":16234,"id":219577,"goal":"lemma SetSubsetRefl_16234(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_16235","instance":16235,"id":219578,"goal":"lemma SetSubsetTrans_16235(A: set, S: set, B: set)\n requires A <= S && S <= B\n ensures A <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_16236","instance":16236,"id":219579,"goal":"lemma SetUnionEmpty_16236(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_16237","instance":16237,"id":219580,"goal":"lemma SetInterEmpty_16237(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_16238","instance":16238,"id":219581,"goal":"lemma SetInterSubset_16238(T: set, A: set)\n ensures T * A <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_16239","instance":16239,"id":219582,"goal":"lemma SetCardSubset_16239(U: set, T: set)\n requires U <= T\n ensures |U| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_16240","instance":16240,"id":219583,"goal":"lemma SetUnionCard_16240(A: set, T: set)\n requires A * T == {}\n ensures |A + T| == |A| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_16241","instance":16241,"id":219584,"goal":"lemma SetUnionComm_16241(A: set, T: set)\n ensures A + T == T + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_16242","instance":16242,"id":219585,"goal":"lemma SetInterComm_16242(T: set, A: set)\n ensures T * A == A * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_16243","instance":16243,"id":219586,"goal":"lemma SetUnionAssoc_16243(T: set, U: set, B: set)\n ensures (T + U) + B == T + (U + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_16244","instance":16244,"id":219587,"goal":"lemma SetSubsetRefl_16244(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_16245","instance":16245,"id":219588,"goal":"lemma SetSubsetTrans_16245(T: set, A: set, S: set)\n requires T <= A && A <= S\n ensures T <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_16246","instance":16246,"id":219589,"goal":"lemma SetUnionEmpty_16246(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_16247","instance":16247,"id":219590,"goal":"lemma SetInterEmpty_16247(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_16248","instance":16248,"id":219591,"goal":"lemma SetInterSubset_16248(T: set, A: set)\n ensures T * A <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_16249","instance":16249,"id":219592,"goal":"lemma SetCardSubset_16249(B: set, U: set)\n requires B <= U\n ensures |B| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_16250","instance":16250,"id":219593,"goal":"lemma SetUnionCard_16250(U: set, A: set)\n requires U * A == {}\n ensures |U + A| == |U| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_16251","instance":16251,"id":219594,"goal":"lemma SetUnionComm_16251(B: set, A: set)\n ensures B + A == A + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_16252","instance":16252,"id":219595,"goal":"lemma SetInterComm_16252(A: set, T: set)\n ensures A * T == T * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_16253","instance":16253,"id":219596,"goal":"lemma SetUnionAssoc_16253(U: set, T: set, B: set)\n ensures (U + T) + B == U + (T + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_16254","instance":16254,"id":219597,"goal":"lemma SetSubsetRefl_16254(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_16255","instance":16255,"id":219598,"goal":"lemma SetSubsetTrans_16255(B: set, S: set, A: set)\n requires B <= S && S <= A\n ensures B <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_16256","instance":16256,"id":219599,"goal":"lemma SetUnionEmpty_16256(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_16257","instance":16257,"id":219600,"goal":"lemma SetInterEmpty_16257(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_16258","instance":16258,"id":219601,"goal":"lemma SetInterSubset_16258(T: set, U: set)\n ensures T * U <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_16259","instance":16259,"id":219602,"goal":"lemma SetCardSubset_16259(A: set, T: set)\n requires A <= T\n ensures |A| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_16260","instance":16260,"id":219603,"goal":"lemma SetUnionCard_16260(A: set, B: set)\n requires A * B == {}\n ensures |A + B| == |A| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_16261","instance":16261,"id":219604,"goal":"lemma SetUnionComm_16261(U: set, B: set)\n ensures U + B == B + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_16262","instance":16262,"id":219605,"goal":"lemma SetInterComm_16262(S: set, B: set)\n ensures S * B == B * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_16263","instance":16263,"id":219606,"goal":"lemma SetUnionAssoc_16263(A: set, S: set, B: set)\n ensures (A + S) + B == A + (S + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_16264","instance":16264,"id":219607,"goal":"lemma SetSubsetRefl_16264(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_16265","instance":16265,"id":219608,"goal":"lemma SetSubsetTrans_16265(B: set, T: set, S: set)\n requires B <= T && T <= S\n ensures B <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_16266","instance":16266,"id":219609,"goal":"lemma SetUnionEmpty_16266(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_16267","instance":16267,"id":219610,"goal":"lemma SetInterEmpty_16267(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_16268","instance":16268,"id":219611,"goal":"lemma SetInterSubset_16268(S: set, B: set)\n ensures S * B <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_16269","instance":16269,"id":219612,"goal":"lemma SetCardSubset_16269(T: set, U: set)\n requires T <= U\n ensures |T| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_16270","instance":16270,"id":219613,"goal":"lemma SetUnionCard_16270(A: set, B: set)\n requires A * B == {}\n ensures |A + B| == |A| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_16271","instance":16271,"id":219614,"goal":"lemma SetUnionComm_16271(S: set, B: set)\n ensures S + B == B + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_16272","instance":16272,"id":219615,"goal":"lemma SetInterComm_16272(S: set, T: set)\n ensures S * T == T * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_16273","instance":16273,"id":219616,"goal":"lemma SetUnionAssoc_16273(A: set, T: set, U: set)\n ensures (A + T) + U == A + (T + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_16274","instance":16274,"id":219617,"goal":"lemma SetSubsetRefl_16274(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_16275","instance":16275,"id":219618,"goal":"lemma SetSubsetTrans_16275(T: set, B: set, S: set)\n requires T <= B && B <= S\n ensures T <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_16276","instance":16276,"id":219619,"goal":"lemma SetUnionEmpty_16276(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_16277","instance":16277,"id":219620,"goal":"lemma SetInterEmpty_16277(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_16278","instance":16278,"id":219621,"goal":"lemma SetInterSubset_16278(A: set, U: set)\n ensures A * U <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_16279","instance":16279,"id":219622,"goal":"lemma SetCardSubset_16279(B: set, S: set)\n requires B <= S\n ensures |B| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_16280","instance":16280,"id":219623,"goal":"lemma SetUnionCard_16280(T: set, A: set)\n requires T * A == {}\n ensures |T + A| == |T| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_16281","instance":16281,"id":219624,"goal":"lemma SetUnionComm_16281(T: set, U: set)\n ensures T + U == U + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_16282","instance":16282,"id":219625,"goal":"lemma SetInterComm_16282(U: set, S: set)\n ensures U * S == S * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_16283","instance":16283,"id":219626,"goal":"lemma SetUnionAssoc_16283(A: set, S: set, B: set)\n ensures (A + S) + B == A + (S + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_16284","instance":16284,"id":219627,"goal":"lemma SetSubsetRefl_16284(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_16285","instance":16285,"id":219628,"goal":"lemma SetSubsetTrans_16285(A: set, U: set, T: set)\n requires A <= U && U <= T\n ensures A <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_16286","instance":16286,"id":219629,"goal":"lemma SetUnionEmpty_16286(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_16287","instance":16287,"id":219630,"goal":"lemma SetInterEmpty_16287(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_16288","instance":16288,"id":219631,"goal":"lemma SetInterSubset_16288(T: set, A: set)\n ensures T * A <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_16289","instance":16289,"id":219632,"goal":"lemma SetCardSubset_16289(T: set, A: set)\n requires T <= A\n ensures |T| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_16290","instance":16290,"id":219633,"goal":"lemma SetUnionCard_16290(U: set, B: set)\n requires U * B == {}\n ensures |U + B| == |U| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_16291","instance":16291,"id":219634,"goal":"lemma SetUnionComm_16291(T: set, S: set)\n ensures T + S == S + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_16292","instance":16292,"id":219635,"goal":"lemma SetInterComm_16292(B: set, T: set)\n ensures B * T == T * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_16293","instance":16293,"id":219636,"goal":"lemma SetUnionAssoc_16293(T: set, A: set, S: set)\n ensures (T + A) + S == T + (A + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_16294","instance":16294,"id":219637,"goal":"lemma SetSubsetRefl_16294(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_16295","instance":16295,"id":219638,"goal":"lemma SetSubsetTrans_16295(U: set, B: set, S: set)\n requires U <= B && B <= S\n ensures U <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_16296","instance":16296,"id":219639,"goal":"lemma SetUnionEmpty_16296(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_16297","instance":16297,"id":219640,"goal":"lemma SetInterEmpty_16297(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_16298","instance":16298,"id":219641,"goal":"lemma SetInterSubset_16298(S: set, T: set)\n ensures S * T <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_16299","instance":16299,"id":219642,"goal":"lemma SetCardSubset_16299(B: set, A: set)\n requires B <= A\n ensures |B| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_16300","instance":16300,"id":219643,"goal":"lemma SetUnionCard_16300(B: set, S: set)\n requires B * S == {}\n ensures |B + S| == |B| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_16301","instance":16301,"id":219644,"goal":"lemma SetUnionComm_16301(B: set, U: set)\n ensures B + U == U + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_16302","instance":16302,"id":219645,"goal":"lemma SetInterComm_16302(U: set, B: set)\n ensures U * B == B * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_16303","instance":16303,"id":219646,"goal":"lemma SetUnionAssoc_16303(U: set, S: set, A: set)\n ensures (U + S) + A == U + (S + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_16304","instance":16304,"id":219647,"goal":"lemma SetSubsetRefl_16304(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_16305","instance":16305,"id":219648,"goal":"lemma SetSubsetTrans_16305(A: set, T: set, U: set)\n requires A <= T && T <= U\n ensures A <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_16306","instance":16306,"id":219649,"goal":"lemma SetUnionEmpty_16306(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_16307","instance":16307,"id":219650,"goal":"lemma SetInterEmpty_16307(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_16308","instance":16308,"id":219651,"goal":"lemma SetInterSubset_16308(S: set, T: set)\n ensures S * T <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_16309","instance":16309,"id":219652,"goal":"lemma SetCardSubset_16309(B: set, U: set)\n requires B <= U\n ensures |B| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_16310","instance":16310,"id":219653,"goal":"lemma SetUnionCard_16310(S: set, B: set)\n requires S * B == {}\n ensures |S + B| == |S| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_16311","instance":16311,"id":219654,"goal":"lemma SetUnionComm_16311(A: set, T: set)\n ensures A + T == T + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_16312","instance":16312,"id":219655,"goal":"lemma SetInterComm_16312(T: set, S: set)\n ensures T * S == S * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_16313","instance":16313,"id":219656,"goal":"lemma SetUnionAssoc_16313(S: set, T: set, B: set)\n ensures (S + T) + B == S + (T + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_16314","instance":16314,"id":219657,"goal":"lemma SetSubsetRefl_16314(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_16315","instance":16315,"id":219658,"goal":"lemma SetSubsetTrans_16315(U: set, S: set, A: set)\n requires U <= S && S <= A\n ensures U <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_16316","instance":16316,"id":219659,"goal":"lemma SetUnionEmpty_16316(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_16317","instance":16317,"id":219660,"goal":"lemma SetInterEmpty_16317(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_16318","instance":16318,"id":219661,"goal":"lemma SetInterSubset_16318(S: set, A: set)\n ensures S * A <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_16319","instance":16319,"id":219662,"goal":"lemma SetCardSubset_16319(B: set, U: set)\n requires B <= U\n ensures |B| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_16320","instance":16320,"id":219663,"goal":"lemma SetUnionCard_16320(A: set, S: set)\n requires A * S == {}\n ensures |A + S| == |A| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_16321","instance":16321,"id":219664,"goal":"lemma SetUnionComm_16321(A: set, B: set)\n ensures A + B == B + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_16322","instance":16322,"id":219665,"goal":"lemma SetInterComm_16322(T: set, S: set)\n ensures T * S == S * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_16323","instance":16323,"id":219666,"goal":"lemma SetUnionAssoc_16323(T: set, B: set, A: set)\n ensures (T + B) + A == T + (B + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_16324","instance":16324,"id":219667,"goal":"lemma SetSubsetRefl_16324(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_16325","instance":16325,"id":219668,"goal":"lemma SetSubsetTrans_16325(U: set, A: set, B: set)\n requires U <= A && A <= B\n ensures U <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_16326","instance":16326,"id":219669,"goal":"lemma SetUnionEmpty_16326(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_16327","instance":16327,"id":219670,"goal":"lemma SetInterEmpty_16327(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_16328","instance":16328,"id":219671,"goal":"lemma SetInterSubset_16328(T: set, A: set)\n ensures T * A <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_16329","instance":16329,"id":219672,"goal":"lemma SetCardSubset_16329(A: set, U: set)\n requires A <= U\n ensures |A| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_16330","instance":16330,"id":219673,"goal":"lemma SetUnionCard_16330(A: set, T: set)\n requires A * T == {}\n ensures |A + T| == |A| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_16331","instance":16331,"id":219674,"goal":"lemma SetUnionComm_16331(A: set, B: set)\n ensures A + B == B + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_16332","instance":16332,"id":219675,"goal":"lemma SetInterComm_16332(U: set, B: set)\n ensures U * B == B * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_16333","instance":16333,"id":219676,"goal":"lemma SetUnionAssoc_16333(A: set, B: set, U: set)\n ensures (A + B) + U == A + (B + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_16334","instance":16334,"id":219677,"goal":"lemma SetSubsetRefl_16334(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_16335","instance":16335,"id":219678,"goal":"lemma SetSubsetTrans_16335(B: set, A: set, T: set)\n requires B <= A && A <= T\n ensures B <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_16336","instance":16336,"id":219679,"goal":"lemma SetUnionEmpty_16336(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_16337","instance":16337,"id":219680,"goal":"lemma SetInterEmpty_16337(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_16338","instance":16338,"id":219681,"goal":"lemma SetInterSubset_16338(T: set, S: set)\n ensures T * S <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_16339","instance":16339,"id":219682,"goal":"lemma SetCardSubset_16339(S: set, B: set)\n requires S <= B\n ensures |S| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_16340","instance":16340,"id":219683,"goal":"lemma SetUnionCard_16340(S: set, A: set)\n requires S * A == {}\n ensures |S + A| == |S| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_16341","instance":16341,"id":219684,"goal":"lemma SetUnionComm_16341(B: set, A: set)\n ensures B + A == A + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_16342","instance":16342,"id":219685,"goal":"lemma SetInterComm_16342(U: set, A: set)\n ensures U * A == A * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_16343","instance":16343,"id":219686,"goal":"lemma SetUnionAssoc_16343(T: set, A: set, S: set)\n ensures (T + A) + S == T + (A + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_16344","instance":16344,"id":219687,"goal":"lemma SetSubsetRefl_16344(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_16345","instance":16345,"id":219688,"goal":"lemma SetSubsetTrans_16345(S: set, T: set, A: set)\n requires S <= T && T <= A\n ensures S <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_16346","instance":16346,"id":219689,"goal":"lemma SetUnionEmpty_16346(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_16347","instance":16347,"id":219690,"goal":"lemma SetInterEmpty_16347(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_16348","instance":16348,"id":219691,"goal":"lemma SetInterSubset_16348(T: set, S: set)\n ensures T * S <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_16349","instance":16349,"id":219692,"goal":"lemma SetCardSubset_16349(T: set, S: set)\n requires T <= S\n ensures |T| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_16350","instance":16350,"id":219693,"goal":"lemma SetUnionCard_16350(A: set, S: set)\n requires A * S == {}\n ensures |A + S| == |A| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_16351","instance":16351,"id":219694,"goal":"lemma SetUnionComm_16351(B: set, U: set)\n ensures B + U == U + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_16352","instance":16352,"id":219695,"goal":"lemma SetInterComm_16352(U: set, B: set)\n ensures U * B == B * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_16353","instance":16353,"id":219696,"goal":"lemma SetUnionAssoc_16353(A: set, S: set, B: set)\n ensures (A + S) + B == A + (S + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_16354","instance":16354,"id":219697,"goal":"lemma SetSubsetRefl_16354(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_16355","instance":16355,"id":219698,"goal":"lemma SetSubsetTrans_16355(B: set, S: set, U: set)\n requires B <= S && S <= U\n ensures B <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_16356","instance":16356,"id":219699,"goal":"lemma SetUnionEmpty_16356(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_16357","instance":16357,"id":219700,"goal":"lemma SetInterEmpty_16357(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_16358","instance":16358,"id":219701,"goal":"lemma SetInterSubset_16358(A: set, B: set)\n ensures A * B <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_16359","instance":16359,"id":219702,"goal":"lemma SetCardSubset_16359(B: set, A: set)\n requires B <= A\n ensures |B| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_16360","instance":16360,"id":219703,"goal":"lemma SetUnionCard_16360(A: set, T: set)\n requires A * T == {}\n ensures |A + T| == |A| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_16361","instance":16361,"id":219704,"goal":"lemma SetUnionComm_16361(B: set, A: set)\n ensures B + A == A + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_16362","instance":16362,"id":219705,"goal":"lemma SetInterComm_16362(B: set, T: set)\n ensures B * T == T * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_16363","instance":16363,"id":219706,"goal":"lemma SetUnionAssoc_16363(B: set, S: set, A: set)\n ensures (B + S) + A == B + (S + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_16364","instance":16364,"id":219707,"goal":"lemma SetSubsetRefl_16364(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_16365","instance":16365,"id":219708,"goal":"lemma SetSubsetTrans_16365(T: set, B: set, U: set)\n requires T <= B && B <= U\n ensures T <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_16366","instance":16366,"id":219709,"goal":"lemma SetUnionEmpty_16366(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_16367","instance":16367,"id":219710,"goal":"lemma SetInterEmpty_16367(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_16368","instance":16368,"id":219711,"goal":"lemma SetInterSubset_16368(A: set, B: set)\n ensures A * B <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_16369","instance":16369,"id":219712,"goal":"lemma SetCardSubset_16369(T: set, B: set)\n requires T <= B\n ensures |T| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_16370","instance":16370,"id":219713,"goal":"lemma SetUnionCard_16370(S: set, B: set)\n requires S * B == {}\n ensures |S + B| == |S| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_16371","instance":16371,"id":219714,"goal":"lemma SetUnionComm_16371(T: set, B: set)\n ensures T + B == B + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_16372","instance":16372,"id":219715,"goal":"lemma SetInterComm_16372(A: set, T: set)\n ensures A * T == T * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_16373","instance":16373,"id":219716,"goal":"lemma SetUnionAssoc_16373(S: set, B: set, T: set)\n ensures (S + B) + T == S + (B + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_16374","instance":16374,"id":219717,"goal":"lemma SetSubsetRefl_16374(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_16375","instance":16375,"id":219718,"goal":"lemma SetSubsetTrans_16375(A: set, S: set, B: set)\n requires A <= S && S <= B\n ensures A <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_16376","instance":16376,"id":219719,"goal":"lemma SetUnionEmpty_16376(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_16377","instance":16377,"id":219720,"goal":"lemma SetInterEmpty_16377(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_16378","instance":16378,"id":219721,"goal":"lemma SetInterSubset_16378(T: set, S: set)\n ensures T * S <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_16379","instance":16379,"id":219722,"goal":"lemma SetCardSubset_16379(S: set, A: set)\n requires S <= A\n ensures |S| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_16380","instance":16380,"id":219723,"goal":"lemma SetUnionCard_16380(U: set, B: set)\n requires U * B == {}\n ensures |U + B| == |U| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_16381","instance":16381,"id":219724,"goal":"lemma SetUnionComm_16381(T: set, S: set)\n ensures T + S == S + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_16382","instance":16382,"id":219725,"goal":"lemma SetInterComm_16382(S: set, U: set)\n ensures S * U == U * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_16383","instance":16383,"id":219726,"goal":"lemma SetUnionAssoc_16383(U: set, T: set, B: set)\n ensures (U + T) + B == U + (T + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_16384","instance":16384,"id":219727,"goal":"lemma SetSubsetRefl_16384(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_16385","instance":16385,"id":219728,"goal":"lemma SetSubsetTrans_16385(U: set, B: set, S: set)\n requires U <= B && B <= S\n ensures U <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_16386","instance":16386,"id":219729,"goal":"lemma SetUnionEmpty_16386(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_16387","instance":16387,"id":219730,"goal":"lemma SetInterEmpty_16387(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_16388","instance":16388,"id":219731,"goal":"lemma SetInterSubset_16388(B: set, U: set)\n ensures B * U <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_16389","instance":16389,"id":219732,"goal":"lemma SetCardSubset_16389(U: set, A: set)\n requires U <= A\n ensures |U| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_16390","instance":16390,"id":219733,"goal":"lemma SetUnionCard_16390(B: set, A: set)\n requires B * A == {}\n ensures |B + A| == |B| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_16391","instance":16391,"id":219734,"goal":"lemma SetUnionComm_16391(S: set, T: set)\n ensures S + T == T + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_16392","instance":16392,"id":219735,"goal":"lemma SetInterComm_16392(U: set, A: set)\n ensures U * A == A * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_16393","instance":16393,"id":219736,"goal":"lemma SetUnionAssoc_16393(U: set, B: set, T: set)\n ensures (U + B) + T == U + (B + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_16394","instance":16394,"id":219737,"goal":"lemma SetSubsetRefl_16394(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_16395","instance":16395,"id":219738,"goal":"lemma SetSubsetTrans_16395(T: set, U: set, S: set)\n requires T <= U && U <= S\n ensures T <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_16396","instance":16396,"id":219739,"goal":"lemma SetUnionEmpty_16396(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_16397","instance":16397,"id":219740,"goal":"lemma SetInterEmpty_16397(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_16398","instance":16398,"id":219741,"goal":"lemma SetInterSubset_16398(A: set, B: set)\n ensures A * B <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_16399","instance":16399,"id":219742,"goal":"lemma SetCardSubset_16399(A: set, U: set)\n requires A <= U\n ensures |A| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_16400","instance":16400,"id":219743,"goal":"lemma SetUnionCard_16400(T: set, U: set)\n requires T * U == {}\n ensures |T + U| == |T| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_16401","instance":16401,"id":219744,"goal":"lemma SetUnionComm_16401(T: set, S: set)\n ensures T + S == S + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_16402","instance":16402,"id":219745,"goal":"lemma SetInterComm_16402(A: set, B: set)\n ensures A * B == B * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_16403","instance":16403,"id":219746,"goal":"lemma SetUnionAssoc_16403(T: set, B: set, A: set)\n ensures (T + B) + A == T + (B + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_16404","instance":16404,"id":219747,"goal":"lemma SetSubsetRefl_16404(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_16405","instance":16405,"id":219748,"goal":"lemma SetSubsetTrans_16405(B: set, S: set, U: set)\n requires B <= S && S <= U\n ensures B <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_16406","instance":16406,"id":219749,"goal":"lemma SetUnionEmpty_16406(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_16407","instance":16407,"id":219750,"goal":"lemma SetInterEmpty_16407(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_16408","instance":16408,"id":219751,"goal":"lemma SetInterSubset_16408(A: set, T: set)\n ensures A * T <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_16409","instance":16409,"id":219752,"goal":"lemma SetCardSubset_16409(A: set, B: set)\n requires A <= B\n ensures |A| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_16410","instance":16410,"id":219753,"goal":"lemma SetUnionCard_16410(B: set, A: set)\n requires B * A == {}\n ensures |B + A| == |B| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_16411","instance":16411,"id":219754,"goal":"lemma SetUnionComm_16411(S: set, B: set)\n ensures S + B == B + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_16412","instance":16412,"id":219755,"goal":"lemma SetInterComm_16412(S: set, T: set)\n ensures S * T == T * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_16413","instance":16413,"id":219756,"goal":"lemma SetUnionAssoc_16413(A: set, U: set, T: set)\n ensures (A + U) + T == A + (U + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_16414","instance":16414,"id":219757,"goal":"lemma SetSubsetRefl_16414(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_16415","instance":16415,"id":219758,"goal":"lemma SetSubsetTrans_16415(A: set, S: set, U: set)\n requires A <= S && S <= U\n ensures A <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_16416","instance":16416,"id":219759,"goal":"lemma SetUnionEmpty_16416(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_16417","instance":16417,"id":219760,"goal":"lemma SetInterEmpty_16417(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_16418","instance":16418,"id":219761,"goal":"lemma SetInterSubset_16418(A: set, S: set)\n ensures A * S <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_16419","instance":16419,"id":219762,"goal":"lemma SetCardSubset_16419(U: set, A: set)\n requires U <= A\n ensures |U| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_16420","instance":16420,"id":219763,"goal":"lemma SetUnionCard_16420(S: set, T: set)\n requires S * T == {}\n ensures |S + T| == |S| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_16421","instance":16421,"id":219764,"goal":"lemma SetUnionComm_16421(T: set, S: set)\n ensures T + S == S + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_16422","instance":16422,"id":219765,"goal":"lemma SetInterComm_16422(U: set, B: set)\n ensures U * B == B * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_16423","instance":16423,"id":219766,"goal":"lemma SetUnionAssoc_16423(B: set, U: set, S: set)\n ensures (B + U) + S == B + (U + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_16424","instance":16424,"id":219767,"goal":"lemma SetSubsetRefl_16424(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_16425","instance":16425,"id":219768,"goal":"lemma SetSubsetTrans_16425(U: set, B: set, S: set)\n requires U <= B && B <= S\n ensures U <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_16426","instance":16426,"id":219769,"goal":"lemma SetUnionEmpty_16426(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_16427","instance":16427,"id":219770,"goal":"lemma SetInterEmpty_16427(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_16428","instance":16428,"id":219771,"goal":"lemma SetInterSubset_16428(B: set, A: set)\n ensures B * A <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_16429","instance":16429,"id":219772,"goal":"lemma SetCardSubset_16429(T: set, S: set)\n requires T <= S\n ensures |T| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_16430","instance":16430,"id":219773,"goal":"lemma SetUnionCard_16430(T: set, U: set)\n requires T * U == {}\n ensures |T + U| == |T| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_16431","instance":16431,"id":219774,"goal":"lemma SetUnionComm_16431(B: set, U: set)\n ensures B + U == U + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_16432","instance":16432,"id":219775,"goal":"lemma SetInterComm_16432(A: set, B: set)\n ensures A * B == B * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_16433","instance":16433,"id":219776,"goal":"lemma SetUnionAssoc_16433(A: set, U: set, T: set)\n ensures (A + U) + T == A + (U + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_16434","instance":16434,"id":219777,"goal":"lemma SetSubsetRefl_16434(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_16435","instance":16435,"id":219778,"goal":"lemma SetSubsetTrans_16435(U: set, B: set, A: set)\n requires U <= B && B <= A\n ensures U <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_16436","instance":16436,"id":219779,"goal":"lemma SetUnionEmpty_16436(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_16437","instance":16437,"id":219780,"goal":"lemma SetInterEmpty_16437(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_16438","instance":16438,"id":219781,"goal":"lemma SetInterSubset_16438(B: set, U: set)\n ensures B * U <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_16439","instance":16439,"id":219782,"goal":"lemma SetCardSubset_16439(T: set, A: set)\n requires T <= A\n ensures |T| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_16440","instance":16440,"id":219783,"goal":"lemma SetUnionCard_16440(S: set, A: set)\n requires S * A == {}\n ensures |S + A| == |S| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_16441","instance":16441,"id":219784,"goal":"lemma SetUnionComm_16441(B: set, T: set)\n ensures B + T == T + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_16442","instance":16442,"id":219785,"goal":"lemma SetInterComm_16442(T: set, B: set)\n ensures T * B == B * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_16443","instance":16443,"id":219786,"goal":"lemma SetUnionAssoc_16443(A: set, S: set, T: set)\n ensures (A + S) + T == A + (S + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_16444","instance":16444,"id":219787,"goal":"lemma SetSubsetRefl_16444(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_16445","instance":16445,"id":219788,"goal":"lemma SetSubsetTrans_16445(T: set, A: set, U: set)\n requires T <= A && A <= U\n ensures T <= U\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_16446","instance":16446,"id":219789,"goal":"lemma SetUnionEmpty_16446(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_16447","instance":16447,"id":219790,"goal":"lemma SetInterEmpty_16447(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_16448","instance":16448,"id":219791,"goal":"lemma SetInterSubset_16448(B: set, A: set)\n ensures B * A <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_16449","instance":16449,"id":219792,"goal":"lemma SetCardSubset_16449(A: set, U: set)\n requires A <= U\n ensures |A| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_16450","instance":16450,"id":219793,"goal":"lemma SetUnionCard_16450(U: set, T: set)\n requires U * T == {}\n ensures |U + T| == |U| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_16451","instance":16451,"id":219794,"goal":"lemma SetUnionComm_16451(A: set, U: set)\n ensures A + U == U + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_16452","instance":16452,"id":219795,"goal":"lemma SetInterComm_16452(A: set, U: set)\n ensures A * U == U * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_16453","instance":16453,"id":219796,"goal":"lemma SetUnionAssoc_16453(T: set, S: set, B: set)\n ensures (T + S) + B == T + (S + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_16454","instance":16454,"id":219797,"goal":"lemma SetSubsetRefl_16454(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_16455","instance":16455,"id":219798,"goal":"lemma SetSubsetTrans_16455(B: set, A: set, S: set)\n requires B <= A && A <= S\n ensures B <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_16456","instance":16456,"id":219799,"goal":"lemma SetUnionEmpty_16456(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_16457","instance":16457,"id":219800,"goal":"lemma SetInterEmpty_16457(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_16458","instance":16458,"id":219801,"goal":"lemma SetInterSubset_16458(A: set, S: set)\n ensures A * S <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_16459","instance":16459,"id":219802,"goal":"lemma SetCardSubset_16459(B: set, T: set)\n requires B <= T\n ensures |B| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_16460","instance":16460,"id":219803,"goal":"lemma SetUnionCard_16460(T: set, A: set)\n requires T * A == {}\n ensures |T + A| == |T| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_16461","instance":16461,"id":219804,"goal":"lemma SetUnionComm_16461(U: set, S: set)\n ensures U + S == S + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_16462","instance":16462,"id":219805,"goal":"lemma SetInterComm_16462(S: set, B: set)\n ensures S * B == B * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_16463","instance":16463,"id":219806,"goal":"lemma SetUnionAssoc_16463(U: set, T: set, A: set)\n ensures (U + T) + A == U + (T + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_16464","instance":16464,"id":219807,"goal":"lemma SetSubsetRefl_16464(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_16465","instance":16465,"id":219808,"goal":"lemma SetSubsetTrans_16465(T: set, S: set, A: set)\n requires T <= S && S <= A\n ensures T <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_16466","instance":16466,"id":219809,"goal":"lemma SetUnionEmpty_16466(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_16467","instance":16467,"id":219810,"goal":"lemma SetInterEmpty_16467(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_16468","instance":16468,"id":219811,"goal":"lemma SetInterSubset_16468(B: set, A: set)\n ensures B * A <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_16469","instance":16469,"id":219812,"goal":"lemma SetCardSubset_16469(B: set, S: set)\n requires B <= S\n ensures |B| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_16470","instance":16470,"id":219813,"goal":"lemma SetUnionCard_16470(T: set, U: set)\n requires T * U == {}\n ensures |T + U| == |T| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_16471","instance":16471,"id":219814,"goal":"lemma SetUnionComm_16471(B: set, S: set)\n ensures B + S == S + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_16472","instance":16472,"id":219815,"goal":"lemma SetInterComm_16472(T: set, A: set)\n ensures T * A == A * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_16473","instance":16473,"id":219816,"goal":"lemma SetUnionAssoc_16473(A: set, B: set, U: set)\n ensures (A + B) + U == A + (B + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_16474","instance":16474,"id":219817,"goal":"lemma SetSubsetRefl_16474(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_16475","instance":16475,"id":219818,"goal":"lemma SetSubsetTrans_16475(S: set, U: set, B: set)\n requires S <= U && U <= B\n ensures S <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_16476","instance":16476,"id":219819,"goal":"lemma SetUnionEmpty_16476(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_16477","instance":16477,"id":219820,"goal":"lemma SetInterEmpty_16477(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_16478","instance":16478,"id":219821,"goal":"lemma SetInterSubset_16478(T: set, A: set)\n ensures T * A <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_16479","instance":16479,"id":219822,"goal":"lemma SetCardSubset_16479(B: set, T: set)\n requires B <= T\n ensures |B| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_16480","instance":16480,"id":219823,"goal":"lemma SetUnionCard_16480(B: set, T: set)\n requires B * T == {}\n ensures |B + T| == |B| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_16481","instance":16481,"id":219824,"goal":"lemma SetUnionComm_16481(B: set, T: set)\n ensures B + T == T + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_16482","instance":16482,"id":219825,"goal":"lemma SetInterComm_16482(T: set, B: set)\n ensures T * B == B * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_16483","instance":16483,"id":219826,"goal":"lemma SetUnionAssoc_16483(U: set, B: set, T: set)\n ensures (U + B) + T == U + (B + T)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_16484","instance":16484,"id":219827,"goal":"lemma SetSubsetRefl_16484(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_16485","instance":16485,"id":219828,"goal":"lemma SetSubsetTrans_16485(U: set, T: set, S: set)\n requires U <= T && T <= S\n ensures U <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_16486","instance":16486,"id":219829,"goal":"lemma SetUnionEmpty_16486(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_16487","instance":16487,"id":219830,"goal":"lemma SetInterEmpty_16487(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_16488","instance":16488,"id":219831,"goal":"lemma SetInterSubset_16488(S: set, U: set)\n ensures S * U <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_16489","instance":16489,"id":219832,"goal":"lemma SetCardSubset_16489(B: set, T: set)\n requires B <= T\n ensures |B| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_16490","instance":16490,"id":219833,"goal":"lemma SetUnionCard_16490(U: set, A: set)\n requires U * A == {}\n ensures |U + A| == |U| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_16491","instance":16491,"id":219834,"goal":"lemma SetUnionComm_16491(T: set, U: set)\n ensures T + U == U + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_16492","instance":16492,"id":219835,"goal":"lemma SetInterComm_16492(U: set, A: set)\n ensures U * A == A * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_16493","instance":16493,"id":219836,"goal":"lemma SetUnionAssoc_16493(S: set, A: set, U: set)\n ensures (S + A) + U == S + (A + U)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_16494","instance":16494,"id":219837,"goal":"lemma SetSubsetRefl_16494(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_16495","instance":16495,"id":219838,"goal":"lemma SetSubsetTrans_16495(A: set, U: set, S: set)\n requires A <= U && U <= S\n ensures A <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_16496","instance":16496,"id":219839,"goal":"lemma SetUnionEmpty_16496(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_16497","instance":16497,"id":219840,"goal":"lemma SetInterEmpty_16497(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_16498","instance":16498,"id":219841,"goal":"lemma SetInterSubset_16498(U: set, T: set)\n ensures U * T <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_16499","instance":16499,"id":219842,"goal":"lemma SetCardSubset_16499(A: set, S: set)\n requires A <= S\n ensures |A| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_16500","instance":16500,"id":219843,"goal":"lemma SetUnionCard_16500(A: set, S: set)\n requires A * S == {}\n ensures |A + S| == |A| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_16501","instance":16501,"id":219844,"goal":"lemma SetUnionComm_16501(S: set, B: set)\n ensures S + B == B + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_16502","instance":16502,"id":219845,"goal":"lemma SetInterComm_16502(B: set, S: set)\n ensures B * S == S * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_16503","instance":16503,"id":219846,"goal":"lemma SetUnionAssoc_16503(B: set, U: set, S: set)\n ensures (B + U) + S == B + (U + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_16504","instance":16504,"id":219847,"goal":"lemma SetSubsetRefl_16504(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_16505","instance":16505,"id":219848,"goal":"lemma SetSubsetTrans_16505(A: set, S: set, B: set)\n requires A <= S && S <= B\n ensures A <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_16506","instance":16506,"id":219849,"goal":"lemma SetUnionEmpty_16506(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_16507","instance":16507,"id":219850,"goal":"lemma SetInterEmpty_16507(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_16508","instance":16508,"id":219851,"goal":"lemma SetInterSubset_16508(B: set, A: set)\n ensures B * A <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_16509","instance":16509,"id":219852,"goal":"lemma SetCardSubset_16509(T: set, A: set)\n requires T <= A\n ensures |T| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_16510","instance":16510,"id":219853,"goal":"lemma SetUnionCard_16510(S: set, U: set)\n requires S * U == {}\n ensures |S + U| == |S| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_16511","instance":16511,"id":219854,"goal":"lemma SetUnionComm_16511(B: set, A: set)\n ensures B + A == A + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_16512","instance":16512,"id":219855,"goal":"lemma SetInterComm_16512(T: set, A: set)\n ensures T * A == A * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_16513","instance":16513,"id":219856,"goal":"lemma SetUnionAssoc_16513(T: set, S: set, A: set)\n ensures (T + S) + A == T + (S + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_16514","instance":16514,"id":219857,"goal":"lemma SetSubsetRefl_16514(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_16515","instance":16515,"id":219858,"goal":"lemma SetSubsetTrans_16515(A: set, U: set, T: set)\n requires A <= U && U <= T\n ensures A <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_16516","instance":16516,"id":219859,"goal":"lemma SetUnionEmpty_16516(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_16517","instance":16517,"id":219860,"goal":"lemma SetInterEmpty_16517(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_16518","instance":16518,"id":219861,"goal":"lemma SetInterSubset_16518(U: set, A: set)\n ensures U * A <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_16519","instance":16519,"id":219862,"goal":"lemma SetCardSubset_16519(B: set, A: set)\n requires B <= A\n ensures |B| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_16520","instance":16520,"id":219863,"goal":"lemma SetUnionCard_16520(A: set, U: set)\n requires A * U == {}\n ensures |A + U| == |A| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_16521","instance":16521,"id":219864,"goal":"lemma SetUnionComm_16521(B: set, S: set)\n ensures B + S == S + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_16522","instance":16522,"id":219865,"goal":"lemma SetInterComm_16522(T: set, B: set)\n ensures T * B == B * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_16523","instance":16523,"id":219866,"goal":"lemma SetUnionAssoc_16523(A: set, U: set, S: set)\n ensures (A + U) + S == A + (U + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_16524","instance":16524,"id":219867,"goal":"lemma SetSubsetRefl_16524(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_16525","instance":16525,"id":219868,"goal":"lemma SetSubsetTrans_16525(B: set, U: set, S: set)\n requires B <= U && U <= S\n ensures B <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_16526","instance":16526,"id":219869,"goal":"lemma SetUnionEmpty_16526(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_16527","instance":16527,"id":219870,"goal":"lemma SetInterEmpty_16527(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_16528","instance":16528,"id":219871,"goal":"lemma SetInterSubset_16528(A: set, S: set)\n ensures A * S <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_16529","instance":16529,"id":219872,"goal":"lemma SetCardSubset_16529(A: set, B: set)\n requires A <= B\n ensures |A| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_16530","instance":16530,"id":219873,"goal":"lemma SetUnionCard_16530(S: set, B: set)\n requires S * B == {}\n ensures |S + B| == |S| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_16531","instance":16531,"id":219874,"goal":"lemma SetUnionComm_16531(S: set, B: set)\n ensures S + B == B + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_16532","instance":16532,"id":219875,"goal":"lemma SetInterComm_16532(A: set, U: set)\n ensures A * U == U * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_16533","instance":16533,"id":219876,"goal":"lemma SetUnionAssoc_16533(T: set, S: set, B: set)\n ensures (T + S) + B == T + (S + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_16534","instance":16534,"id":219877,"goal":"lemma SetSubsetRefl_16534(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_16535","instance":16535,"id":219878,"goal":"lemma SetSubsetTrans_16535(T: set, S: set, A: set)\n requires T <= S && S <= A\n ensures T <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_16536","instance":16536,"id":219879,"goal":"lemma SetUnionEmpty_16536(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_16537","instance":16537,"id":219880,"goal":"lemma SetInterEmpty_16537(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_16538","instance":16538,"id":219881,"goal":"lemma SetInterSubset_16538(S: set, U: set)\n ensures S * U <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_16539","instance":16539,"id":219882,"goal":"lemma SetCardSubset_16539(A: set, B: set)\n requires A <= B\n ensures |A| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_16540","instance":16540,"id":219883,"goal":"lemma SetUnionCard_16540(T: set, A: set)\n requires T * A == {}\n ensures |T + A| == |T| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_16541","instance":16541,"id":219884,"goal":"lemma SetUnionComm_16541(S: set, A: set)\n ensures S + A == A + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_16542","instance":16542,"id":219885,"goal":"lemma SetInterComm_16542(U: set, A: set)\n ensures U * A == A * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_16543","instance":16543,"id":219886,"goal":"lemma SetUnionAssoc_16543(A: set, T: set, S: set)\n ensures (A + T) + S == A + (T + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_16544","instance":16544,"id":219887,"goal":"lemma SetSubsetRefl_16544(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_16545","instance":16545,"id":219888,"goal":"lemma SetSubsetTrans_16545(U: set, S: set, B: set)\n requires U <= S && S <= B\n ensures U <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_16546","instance":16546,"id":219889,"goal":"lemma SetUnionEmpty_16546(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_16547","instance":16547,"id":219890,"goal":"lemma SetInterEmpty_16547(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_16548","instance":16548,"id":219891,"goal":"lemma SetInterSubset_16548(T: set, B: set)\n ensures T * B <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_16549","instance":16549,"id":219892,"goal":"lemma SetCardSubset_16549(T: set, S: set)\n requires T <= S\n ensures |T| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_16550","instance":16550,"id":219893,"goal":"lemma SetUnionCard_16550(U: set, T: set)\n requires U * T == {}\n ensures |U + T| == |U| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_16551","instance":16551,"id":219894,"goal":"lemma SetUnionComm_16551(T: set, S: set)\n ensures T + S == S + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_16552","instance":16552,"id":219895,"goal":"lemma SetInterComm_16552(A: set, B: set)\n ensures A * B == B * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_16553","instance":16553,"id":219896,"goal":"lemma SetUnionAssoc_16553(A: set, U: set, B: set)\n ensures (A + U) + B == A + (U + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_16554","instance":16554,"id":219897,"goal":"lemma SetSubsetRefl_16554(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_16555","instance":16555,"id":219898,"goal":"lemma SetSubsetTrans_16555(B: set, A: set, T: set)\n requires B <= A && A <= T\n ensures B <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_16556","instance":16556,"id":219899,"goal":"lemma SetUnionEmpty_16556(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_16557","instance":16557,"id":219900,"goal":"lemma SetInterEmpty_16557(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_16558","instance":16558,"id":219901,"goal":"lemma SetInterSubset_16558(U: set, T: set)\n ensures U * T <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_16559","instance":16559,"id":219902,"goal":"lemma SetCardSubset_16559(A: set, T: set)\n requires A <= T\n ensures |A| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_16560","instance":16560,"id":219903,"goal":"lemma SetUnionCard_16560(S: set, T: set)\n requires S * T == {}\n ensures |S + T| == |S| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_16561","instance":16561,"id":219904,"goal":"lemma SetUnionComm_16561(T: set, S: set)\n ensures T + S == S + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_16562","instance":16562,"id":219905,"goal":"lemma SetInterComm_16562(A: set, T: set)\n ensures A * T == T * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_16563","instance":16563,"id":219906,"goal":"lemma SetUnionAssoc_16563(U: set, T: set, S: set)\n ensures (U + T) + S == U + (T + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_16564","instance":16564,"id":219907,"goal":"lemma SetSubsetRefl_16564(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_16565","instance":16565,"id":219908,"goal":"lemma SetSubsetTrans_16565(T: set, A: set, S: set)\n requires T <= A && A <= S\n ensures T <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_16566","instance":16566,"id":219909,"goal":"lemma SetUnionEmpty_16566(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_16567","instance":16567,"id":219910,"goal":"lemma SetInterEmpty_16567(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_16568","instance":16568,"id":219911,"goal":"lemma SetInterSubset_16568(S: set, U: set)\n ensures S * U <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_16569","instance":16569,"id":219912,"goal":"lemma SetCardSubset_16569(B: set, U: set)\n requires B <= U\n ensures |B| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_16570","instance":16570,"id":219913,"goal":"lemma SetUnionCard_16570(S: set, B: set)\n requires S * B == {}\n ensures |S + B| == |S| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_16571","instance":16571,"id":219914,"goal":"lemma SetUnionComm_16571(B: set, T: set)\n ensures B + T == T + B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_16572","instance":16572,"id":219915,"goal":"lemma SetInterComm_16572(A: set, S: set)\n ensures A * S == S * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_16573","instance":16573,"id":219916,"goal":"lemma SetUnionAssoc_16573(A: set, B: set, S: set)\n ensures (A + B) + S == A + (B + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_16574","instance":16574,"id":219917,"goal":"lemma SetSubsetRefl_16574(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_16575","instance":16575,"id":219918,"goal":"lemma SetSubsetTrans_16575(B: set, T: set, A: set)\n requires B <= T && T <= A\n ensures B <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_16576","instance":16576,"id":219919,"goal":"lemma SetUnionEmpty_16576(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_16577","instance":16577,"id":219920,"goal":"lemma SetInterEmpty_16577(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_16578","instance":16578,"id":219921,"goal":"lemma SetInterSubset_16578(U: set, T: set)\n ensures U * T <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_16579","instance":16579,"id":219922,"goal":"lemma SetCardSubset_16579(T: set, A: set)\n requires T <= A\n ensures |T| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_16580","instance":16580,"id":219923,"goal":"lemma SetUnionCard_16580(S: set, A: set)\n requires S * A == {}\n ensures |S + A| == |S| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_16581","instance":16581,"id":219924,"goal":"lemma SetUnionComm_16581(U: set, T: set)\n ensures U + T == T + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_16582","instance":16582,"id":219925,"goal":"lemma SetInterComm_16582(S: set, U: set)\n ensures S * U == U * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_16583","instance":16583,"id":219926,"goal":"lemma SetUnionAssoc_16583(S: set, A: set, B: set)\n ensures (S + A) + B == S + (A + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_16584","instance":16584,"id":219927,"goal":"lemma SetSubsetRefl_16584(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_16585","instance":16585,"id":219928,"goal":"lemma SetSubsetTrans_16585(A: set, U: set, T: set)\n requires A <= U && U <= T\n ensures A <= T\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_16586","instance":16586,"id":219929,"goal":"lemma SetUnionEmpty_16586(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_16587","instance":16587,"id":219930,"goal":"lemma SetInterEmpty_16587(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_16588","instance":16588,"id":219931,"goal":"lemma SetInterSubset_16588(A: set, U: set)\n ensures A * U <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_16589","instance":16589,"id":219932,"goal":"lemma SetCardSubset_16589(U: set, A: set)\n requires U <= A\n ensures |U| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_16590","instance":16590,"id":219933,"goal":"lemma SetUnionCard_16590(B: set, T: set)\n requires B * T == {}\n ensures |B + T| == |B| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_16591","instance":16591,"id":219934,"goal":"lemma SetUnionComm_16591(A: set, U: set)\n ensures A + U == U + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_16592","instance":16592,"id":219935,"goal":"lemma SetInterComm_16592(S: set, B: set)\n ensures S * B == B * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_16593","instance":16593,"id":219936,"goal":"lemma SetUnionAssoc_16593(B: set, A: set, S: set)\n ensures (B + A) + S == B + (A + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_16594","instance":16594,"id":219937,"goal":"lemma SetSubsetRefl_16594(A: set)\n ensures A <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_16595","instance":16595,"id":219938,"goal":"lemma SetSubsetTrans_16595(U: set, A: set, B: set)\n requires U <= A && A <= B\n ensures U <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_16596","instance":16596,"id":219939,"goal":"lemma SetUnionEmpty_16596(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_16597","instance":16597,"id":219940,"goal":"lemma SetInterEmpty_16597(B: set)\n ensures B * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_16598","instance":16598,"id":219941,"goal":"lemma SetInterSubset_16598(T: set, B: set)\n ensures T * B <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_16599","instance":16599,"id":219942,"goal":"lemma SetCardSubset_16599(T: set, U: set)\n requires T <= U\n ensures |T| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_16600","instance":16600,"id":219943,"goal":"lemma SetUnionCard_16600(B: set, T: set)\n requires B * T == {}\n ensures |B + T| == |B| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_16601","instance":16601,"id":219944,"goal":"lemma SetUnionComm_16601(A: set, S: set)\n ensures A + S == S + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_16602","instance":16602,"id":219945,"goal":"lemma SetInterComm_16602(A: set, U: set)\n ensures A * U == U * A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_16603","instance":16603,"id":219946,"goal":"lemma SetUnionAssoc_16603(B: set, T: set, A: set)\n ensures (B + T) + A == B + (T + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_16604","instance":16604,"id":219947,"goal":"lemma SetSubsetRefl_16604(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_16605","instance":16605,"id":219948,"goal":"lemma SetSubsetTrans_16605(B: set, S: set, A: set)\n requires B <= S && S <= A\n ensures B <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_16606","instance":16606,"id":219949,"goal":"lemma SetUnionEmpty_16606(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_16607","instance":16607,"id":219950,"goal":"lemma SetInterEmpty_16607(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_16608","instance":16608,"id":219951,"goal":"lemma SetInterSubset_16608(U: set, S: set)\n ensures U * S <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_16609","instance":16609,"id":219952,"goal":"lemma SetCardSubset_16609(B: set, U: set)\n requires B <= U\n ensures |B| <= |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_16610","instance":16610,"id":219953,"goal":"lemma SetUnionCard_16610(U: set, A: set)\n requires U * A == {}\n ensures |U + A| == |U| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_16611","instance":16611,"id":219954,"goal":"lemma SetUnionComm_16611(T: set, U: set)\n ensures T + U == U + T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_16612","instance":16612,"id":219955,"goal":"lemma SetInterComm_16612(B: set, T: set)\n ensures B * T == T * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_16613","instance":16613,"id":219956,"goal":"lemma SetUnionAssoc_16613(T: set, S: set, B: set)\n ensures (T + S) + B == T + (S + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_16614","instance":16614,"id":219957,"goal":"lemma SetSubsetRefl_16614(B: set)\n ensures B <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_16615","instance":16615,"id":219958,"goal":"lemma SetSubsetTrans_16615(S: set, B: set, A: set)\n requires S <= B && B <= A\n ensures S <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_16616","instance":16616,"id":219959,"goal":"lemma SetUnionEmpty_16616(S: set)\n ensures S + {} == S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_16617","instance":16617,"id":219960,"goal":"lemma SetInterEmpty_16617(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_16618","instance":16618,"id":219961,"goal":"lemma SetInterSubset_16618(S: set, B: set)\n ensures S * B <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_16619","instance":16619,"id":219962,"goal":"lemma SetCardSubset_16619(U: set, S: set)\n requires U <= S\n ensures |U| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_16620","instance":16620,"id":219963,"goal":"lemma SetUnionCard_16620(T: set, U: set)\n requires T * U == {}\n ensures |T + U| == |T| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_16621","instance":16621,"id":219964,"goal":"lemma SetUnionComm_16621(S: set, B: set)\n ensures S + B == B + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_16622","instance":16622,"id":219965,"goal":"lemma SetInterComm_16622(T: set, U: set)\n ensures T * U == U * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_16623","instance":16623,"id":219966,"goal":"lemma SetUnionAssoc_16623(S: set, B: set, A: set)\n ensures (S + B) + A == S + (B + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_16624","instance":16624,"id":219967,"goal":"lemma SetSubsetRefl_16624(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_16625","instance":16625,"id":219968,"goal":"lemma SetSubsetTrans_16625(U: set, T: set, A: set)\n requires U <= T && T <= A\n ensures U <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_16626","instance":16626,"id":219969,"goal":"lemma SetUnionEmpty_16626(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_16627","instance":16627,"id":219970,"goal":"lemma SetInterEmpty_16627(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_16628","instance":16628,"id":219971,"goal":"lemma SetInterSubset_16628(T: set, B: set)\n ensures T * B <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_16629","instance":16629,"id":219972,"goal":"lemma SetCardSubset_16629(U: set, T: set)\n requires U <= T\n ensures |U| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_16630","instance":16630,"id":219973,"goal":"lemma SetUnionCard_16630(S: set, T: set)\n requires S * T == {}\n ensures |S + T| == |S| + |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_16631","instance":16631,"id":219974,"goal":"lemma SetUnionComm_16631(U: set, S: set)\n ensures U + S == S + U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_16632","instance":16632,"id":219975,"goal":"lemma SetInterComm_16632(B: set, T: set)\n ensures B * T == T * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_16633","instance":16633,"id":219976,"goal":"lemma SetUnionAssoc_16633(B: set, T: set, S: set)\n ensures (B + T) + S == B + (T + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_16634","instance":16634,"id":219977,"goal":"lemma SetSubsetRefl_16634(T: set)\n ensures T <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_16635","instance":16635,"id":219978,"goal":"lemma SetSubsetTrans_16635(U: set, B: set, S: set)\n requires U <= B && B <= S\n ensures U <= S\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_16636","instance":16636,"id":219979,"goal":"lemma SetUnionEmpty_16636(U: set)\n ensures U + {} == U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_16637","instance":16637,"id":219980,"goal":"lemma SetInterEmpty_16637(S: set)\n ensures S * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_16638","instance":16638,"id":219981,"goal":"lemma SetInterSubset_16638(T: set, S: set)\n ensures T * S <= T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_16639","instance":16639,"id":219982,"goal":"lemma SetCardSubset_16639(A: set, T: set)\n requires A <= T\n ensures |A| <= |T|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_16640","instance":16640,"id":219983,"goal":"lemma SetUnionCard_16640(U: set, B: set)\n requires U * B == {}\n ensures |U + B| == |U| + |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_16641","instance":16641,"id":219984,"goal":"lemma SetUnionComm_16641(S: set, U: set)\n ensures S + U == U + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_16642","instance":16642,"id":219985,"goal":"lemma SetInterComm_16642(T: set, B: set)\n ensures T * B == B * T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_16643","instance":16643,"id":219986,"goal":"lemma SetUnionAssoc_16643(A: set, S: set, B: set)\n ensures (A + S) + B == A + (S + B)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_16644","instance":16644,"id":219987,"goal":"lemma SetSubsetRefl_16644(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_16645","instance":16645,"id":219988,"goal":"lemma SetSubsetTrans_16645(B: set, U: set, A: set)\n requires B <= U && U <= A\n ensures B <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_16646","instance":16646,"id":219989,"goal":"lemma SetUnionEmpty_16646(T: set)\n ensures T + {} == T\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_16647","instance":16647,"id":219990,"goal":"lemma SetInterEmpty_16647(U: set)\n ensures U * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_16648","instance":16648,"id":219991,"goal":"lemma SetInterSubset_16648(B: set, A: set)\n ensures B * A <= B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_16649","instance":16649,"id":219992,"goal":"lemma SetCardSubset_16649(T: set, A: set)\n requires T <= A\n ensures |T| <= |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_16650","instance":16650,"id":219993,"goal":"lemma SetUnionCard_16650(A: set, U: set)\n requires A * U == {}\n ensures |A + U| == |A| + |U|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_16651","instance":16651,"id":219994,"goal":"lemma SetUnionComm_16651(A: set, T: set)\n ensures A + T == T + A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_16652","instance":16652,"id":219995,"goal":"lemma SetInterComm_16652(S: set, U: set)\n ensures S * U == U * S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_16653","instance":16653,"id":219996,"goal":"lemma SetUnionAssoc_16653(S: set, U: set, A: set)\n ensures (S + U) + A == S + (U + A)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_16654","instance":16654,"id":219997,"goal":"lemma SetSubsetRefl_16654(S: set)\n ensures S <= S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_16655","instance":16655,"id":219998,"goal":"lemma SetSubsetTrans_16655(A: set, S: set, B: set)\n requires A <= S && S <= B\n ensures A <= B\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_16656","instance":16656,"id":219999,"goal":"lemma SetUnionEmpty_16656(A: set)\n ensures A + {} == A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_16657","instance":16657,"id":220000,"goal":"lemma SetInterEmpty_16657(A: set)\n ensures A * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_16658","instance":16658,"id":220001,"goal":"lemma SetInterSubset_16658(A: set, S: set)\n ensures A * S <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_16659","instance":16659,"id":220002,"goal":"lemma SetCardSubset_16659(T: set, B: set)\n requires T <= B\n ensures |T| <= |B|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_16660","instance":16660,"id":220003,"goal":"lemma SetUnionCard_16660(T: set, S: set)\n requires T * S == {}\n ensures |T + S| == |T| + |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_16661","instance":16661,"id":220004,"goal":"lemma SetUnionComm_16661(S: set, A: set)\n ensures S + A == A + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_16662","instance":16662,"id":220005,"goal":"lemma SetInterComm_16662(U: set, B: set)\n ensures U * B == B * U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionAssoc","theorem":"SetUnionAssoc_16663","instance":16663,"id":220006,"goal":"lemma SetUnionAssoc_16663(U: set, B: set, S: set)\n ensures (U + B) + S == U + (B + S)\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetRefl","theorem":"SetSubsetRefl_16664","instance":16664,"id":220007,"goal":"lemma SetSubsetRefl_16664(U: set)\n ensures U <= U\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetSubsetTrans","theorem":"SetSubsetTrans_16665","instance":16665,"id":220008,"goal":"lemma SetSubsetTrans_16665(S: set, T: set, A: set)\n requires S <= T && T <= A\n ensures S <= A\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionEmpty","theorem":"SetUnionEmpty_16666","instance":16666,"id":220009,"goal":"lemma SetUnionEmpty_16666(B: set)\n ensures B + {} == B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterEmpty","theorem":"SetInterEmpty_16667","instance":16667,"id":220010,"goal":"lemma SetInterEmpty_16667(T: set)\n ensures T * {} == {}\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterSubset","theorem":"SetInterSubset_16668","instance":16668,"id":220011,"goal":"lemma SetInterSubset_16668(A: set, U: set)\n ensures A * U <= A\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetCardSubset","theorem":"SetCardSubset_16669","instance":16669,"id":220012,"goal":"lemma SetCardSubset_16669(U: set, S: set)\n requires U <= S\n ensures |U| <= |S|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionCard","theorem":"SetUnionCard_16670","instance":16670,"id":220013,"goal":"lemma SetUnionCard_16670(S: set, A: set)\n requires S * A == {}\n ensures |S + A| == |S| + |A|\n{}","type_family":"set","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetUnionComm","theorem":"SetUnionComm_16671","instance":16671,"id":220014,"goal":"lemma SetUnionComm_16671(S: set, A: set)\n ensures S + A == A + S\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/sets","variant":"SetInterComm","theorem":"SetInterComm_16672","instance":16672,"id":220015,"goal":"lemma SetInterComm_16672(B: set, A: set)\n ensures B * A == A * B\n{}","type_family":"set","tactics":["ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_1","instance":1,"id":220016,"goal":"method BinarySearch_1(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_2","instance":2,"id":220017,"goal":"method InsertSort_2(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_3","instance":3,"id":220018,"goal":"method MergeSort_3(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_4","instance":4,"id":220019,"goal":"method ArrayCopy_4(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_5","instance":5,"id":220020,"goal":"function ListReverse_5(s: seq): seq\n ensures |ListReverse_5(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_5(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_6","instance":6,"id":220021,"goal":"function Factorial_6(n: nat): nat\n ensures Factorial_6(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_6(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_7","instance":7,"id":220022,"goal":"function Fib_7(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_7(n-1) + Fib_7(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_8","instance":8,"id":220023,"goal":"function Gcd_8(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_8(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_9","instance":9,"id":220024,"goal":"function Power_9(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_9(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_10","instance":10,"id":220025,"goal":"function Sum_10(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_10(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_11","instance":11,"id":220026,"goal":"method BinarySearch_11(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_12","instance":12,"id":220027,"goal":"method InsertSort_12(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_13","instance":13,"id":220028,"goal":"method MergeSort_13(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_14","instance":14,"id":220029,"goal":"method ArrayCopy_14(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_15","instance":15,"id":220030,"goal":"function ListReverse_15(s: seq): seq\n ensures |ListReverse_15(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_15(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_16","instance":16,"id":220031,"goal":"function Factorial_16(n: nat): nat\n ensures Factorial_16(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_16(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_17","instance":17,"id":220032,"goal":"function Fib_17(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_17(n-1) + Fib_17(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_18","instance":18,"id":220033,"goal":"function Gcd_18(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_18(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_19","instance":19,"id":220034,"goal":"function Power_19(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_19(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_20","instance":20,"id":220035,"goal":"function Sum_20(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_20(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_21","instance":21,"id":220036,"goal":"method BinarySearch_21(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_22","instance":22,"id":220037,"goal":"method InsertSort_22(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_23","instance":23,"id":220038,"goal":"method MergeSort_23(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_24","instance":24,"id":220039,"goal":"method ArrayCopy_24(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_25","instance":25,"id":220040,"goal":"function ListReverse_25(s: seq): seq\n ensures |ListReverse_25(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_25(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_26","instance":26,"id":220041,"goal":"function Factorial_26(n: nat): nat\n ensures Factorial_26(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_26(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_27","instance":27,"id":220042,"goal":"function Fib_27(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_27(n-1) + Fib_27(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_28","instance":28,"id":220043,"goal":"function Gcd_28(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_28(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_29","instance":29,"id":220044,"goal":"function Power_29(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_29(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_30","instance":30,"id":220045,"goal":"function Sum_30(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_30(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_31","instance":31,"id":220046,"goal":"method BinarySearch_31(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_32","instance":32,"id":220047,"goal":"method InsertSort_32(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_33","instance":33,"id":220048,"goal":"method MergeSort_33(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_34","instance":34,"id":220049,"goal":"method ArrayCopy_34(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_35","instance":35,"id":220050,"goal":"function ListReverse_35(s: seq): seq\n ensures |ListReverse_35(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_35(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_36","instance":36,"id":220051,"goal":"function Factorial_36(n: nat): nat\n ensures Factorial_36(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_36(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_37","instance":37,"id":220052,"goal":"function Fib_37(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_37(n-1) + Fib_37(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_38","instance":38,"id":220053,"goal":"function Gcd_38(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_38(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_39","instance":39,"id":220054,"goal":"function Power_39(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_39(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_40","instance":40,"id":220055,"goal":"function Sum_40(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_40(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_41","instance":41,"id":220056,"goal":"method BinarySearch_41(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_42","instance":42,"id":220057,"goal":"method InsertSort_42(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_43","instance":43,"id":220058,"goal":"method MergeSort_43(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_44","instance":44,"id":220059,"goal":"method ArrayCopy_44(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_45","instance":45,"id":220060,"goal":"function ListReverse_45(s: seq): seq\n ensures |ListReverse_45(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_45(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_46","instance":46,"id":220061,"goal":"function Factorial_46(n: nat): nat\n ensures Factorial_46(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_46(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_47","instance":47,"id":220062,"goal":"function Fib_47(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_47(n-1) + Fib_47(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_48","instance":48,"id":220063,"goal":"function Gcd_48(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_48(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_49","instance":49,"id":220064,"goal":"function Power_49(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_49(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_50","instance":50,"id":220065,"goal":"function Sum_50(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_50(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_51","instance":51,"id":220066,"goal":"method BinarySearch_51(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_52","instance":52,"id":220067,"goal":"method InsertSort_52(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_53","instance":53,"id":220068,"goal":"method MergeSort_53(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_54","instance":54,"id":220069,"goal":"method ArrayCopy_54(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_55","instance":55,"id":220070,"goal":"function ListReverse_55(s: seq): seq\n ensures |ListReverse_55(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_55(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_56","instance":56,"id":220071,"goal":"function Factorial_56(n: nat): nat\n ensures Factorial_56(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_56(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_57","instance":57,"id":220072,"goal":"function Fib_57(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_57(n-1) + Fib_57(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_58","instance":58,"id":220073,"goal":"function Gcd_58(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_58(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_59","instance":59,"id":220074,"goal":"function Power_59(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_59(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_60","instance":60,"id":220075,"goal":"function Sum_60(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_60(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_61","instance":61,"id":220076,"goal":"method BinarySearch_61(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_62","instance":62,"id":220077,"goal":"method InsertSort_62(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_63","instance":63,"id":220078,"goal":"method MergeSort_63(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_64","instance":64,"id":220079,"goal":"method ArrayCopy_64(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_65","instance":65,"id":220080,"goal":"function ListReverse_65(s: seq): seq\n ensures |ListReverse_65(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_65(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_66","instance":66,"id":220081,"goal":"function Factorial_66(n: nat): nat\n ensures Factorial_66(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_66(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_67","instance":67,"id":220082,"goal":"function Fib_67(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_67(n-1) + Fib_67(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_68","instance":68,"id":220083,"goal":"function Gcd_68(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_68(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_69","instance":69,"id":220084,"goal":"function Power_69(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_69(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_70","instance":70,"id":220085,"goal":"function Sum_70(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_70(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_71","instance":71,"id":220086,"goal":"method BinarySearch_71(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_72","instance":72,"id":220087,"goal":"method InsertSort_72(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_73","instance":73,"id":220088,"goal":"method MergeSort_73(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_74","instance":74,"id":220089,"goal":"method ArrayCopy_74(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_75","instance":75,"id":220090,"goal":"function ListReverse_75(s: seq): seq\n ensures |ListReverse_75(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_75(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_76","instance":76,"id":220091,"goal":"function Factorial_76(n: nat): nat\n ensures Factorial_76(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_76(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_77","instance":77,"id":220092,"goal":"function Fib_77(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_77(n-1) + Fib_77(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_78","instance":78,"id":220093,"goal":"function Gcd_78(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_78(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_79","instance":79,"id":220094,"goal":"function Power_79(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_79(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_80","instance":80,"id":220095,"goal":"function Sum_80(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_80(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_81","instance":81,"id":220096,"goal":"method BinarySearch_81(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_82","instance":82,"id":220097,"goal":"method InsertSort_82(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_83","instance":83,"id":220098,"goal":"method MergeSort_83(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_84","instance":84,"id":220099,"goal":"method ArrayCopy_84(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_85","instance":85,"id":220100,"goal":"function ListReverse_85(s: seq): seq\n ensures |ListReverse_85(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_85(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_86","instance":86,"id":220101,"goal":"function Factorial_86(n: nat): nat\n ensures Factorial_86(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_86(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_87","instance":87,"id":220102,"goal":"function Fib_87(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_87(n-1) + Fib_87(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_88","instance":88,"id":220103,"goal":"function Gcd_88(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_88(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_89","instance":89,"id":220104,"goal":"function Power_89(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_89(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_90","instance":90,"id":220105,"goal":"function Sum_90(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_90(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_91","instance":91,"id":220106,"goal":"method BinarySearch_91(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_92","instance":92,"id":220107,"goal":"method InsertSort_92(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_93","instance":93,"id":220108,"goal":"method MergeSort_93(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_94","instance":94,"id":220109,"goal":"method ArrayCopy_94(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_95","instance":95,"id":220110,"goal":"function ListReverse_95(s: seq): seq\n ensures |ListReverse_95(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_95(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_96","instance":96,"id":220111,"goal":"function Factorial_96(n: nat): nat\n ensures Factorial_96(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_96(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_97","instance":97,"id":220112,"goal":"function Fib_97(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_97(n-1) + Fib_97(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_98","instance":98,"id":220113,"goal":"function Gcd_98(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_98(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_99","instance":99,"id":220114,"goal":"function Power_99(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_99(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_100","instance":100,"id":220115,"goal":"function Sum_100(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_100(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_101","instance":101,"id":220116,"goal":"method BinarySearch_101(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_102","instance":102,"id":220117,"goal":"method InsertSort_102(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_103","instance":103,"id":220118,"goal":"method MergeSort_103(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_104","instance":104,"id":220119,"goal":"method ArrayCopy_104(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_105","instance":105,"id":220120,"goal":"function ListReverse_105(s: seq): seq\n ensures |ListReverse_105(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_105(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_106","instance":106,"id":220121,"goal":"function Factorial_106(n: nat): nat\n ensures Factorial_106(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_106(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_107","instance":107,"id":220122,"goal":"function Fib_107(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_107(n-1) + Fib_107(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_108","instance":108,"id":220123,"goal":"function Gcd_108(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_108(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_109","instance":109,"id":220124,"goal":"function Power_109(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_109(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_110","instance":110,"id":220125,"goal":"function Sum_110(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_110(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_111","instance":111,"id":220126,"goal":"method BinarySearch_111(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_112","instance":112,"id":220127,"goal":"method InsertSort_112(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_113","instance":113,"id":220128,"goal":"method MergeSort_113(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_114","instance":114,"id":220129,"goal":"method ArrayCopy_114(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_115","instance":115,"id":220130,"goal":"function ListReverse_115(s: seq): seq\n ensures |ListReverse_115(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_115(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_116","instance":116,"id":220131,"goal":"function Factorial_116(n: nat): nat\n ensures Factorial_116(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_116(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_117","instance":117,"id":220132,"goal":"function Fib_117(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_117(n-1) + Fib_117(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_118","instance":118,"id":220133,"goal":"function Gcd_118(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_118(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_119","instance":119,"id":220134,"goal":"function Power_119(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_119(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_120","instance":120,"id":220135,"goal":"function Sum_120(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_120(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_121","instance":121,"id":220136,"goal":"method BinarySearch_121(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_122","instance":122,"id":220137,"goal":"method InsertSort_122(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_123","instance":123,"id":220138,"goal":"method MergeSort_123(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_124","instance":124,"id":220139,"goal":"method ArrayCopy_124(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_125","instance":125,"id":220140,"goal":"function ListReverse_125(s: seq): seq\n ensures |ListReverse_125(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_125(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_126","instance":126,"id":220141,"goal":"function Factorial_126(n: nat): nat\n ensures Factorial_126(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_126(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_127","instance":127,"id":220142,"goal":"function Fib_127(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_127(n-1) + Fib_127(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_128","instance":128,"id":220143,"goal":"function Gcd_128(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_128(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_129","instance":129,"id":220144,"goal":"function Power_129(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_129(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_130","instance":130,"id":220145,"goal":"function Sum_130(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_130(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_131","instance":131,"id":220146,"goal":"method BinarySearch_131(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_132","instance":132,"id":220147,"goal":"method InsertSort_132(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_133","instance":133,"id":220148,"goal":"method MergeSort_133(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_134","instance":134,"id":220149,"goal":"method ArrayCopy_134(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_135","instance":135,"id":220150,"goal":"function ListReverse_135(s: seq): seq\n ensures |ListReverse_135(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_135(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_136","instance":136,"id":220151,"goal":"function Factorial_136(n: nat): nat\n ensures Factorial_136(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_136(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_137","instance":137,"id":220152,"goal":"function Fib_137(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_137(n-1) + Fib_137(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_138","instance":138,"id":220153,"goal":"function Gcd_138(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_138(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_139","instance":139,"id":220154,"goal":"function Power_139(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_139(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_140","instance":140,"id":220155,"goal":"function Sum_140(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_140(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_141","instance":141,"id":220156,"goal":"method BinarySearch_141(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_142","instance":142,"id":220157,"goal":"method InsertSort_142(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_143","instance":143,"id":220158,"goal":"method MergeSort_143(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_144","instance":144,"id":220159,"goal":"method ArrayCopy_144(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_145","instance":145,"id":220160,"goal":"function ListReverse_145(s: seq): seq\n ensures |ListReverse_145(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_145(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_146","instance":146,"id":220161,"goal":"function Factorial_146(n: nat): nat\n ensures Factorial_146(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_146(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_147","instance":147,"id":220162,"goal":"function Fib_147(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_147(n-1) + Fib_147(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_148","instance":148,"id":220163,"goal":"function Gcd_148(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_148(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_149","instance":149,"id":220164,"goal":"function Power_149(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_149(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_150","instance":150,"id":220165,"goal":"function Sum_150(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_150(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_151","instance":151,"id":220166,"goal":"method BinarySearch_151(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_152","instance":152,"id":220167,"goal":"method InsertSort_152(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_153","instance":153,"id":220168,"goal":"method MergeSort_153(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_154","instance":154,"id":220169,"goal":"method ArrayCopy_154(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_155","instance":155,"id":220170,"goal":"function ListReverse_155(s: seq): seq\n ensures |ListReverse_155(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_155(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_156","instance":156,"id":220171,"goal":"function Factorial_156(n: nat): nat\n ensures Factorial_156(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_156(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_157","instance":157,"id":220172,"goal":"function Fib_157(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_157(n-1) + Fib_157(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_158","instance":158,"id":220173,"goal":"function Gcd_158(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_158(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_159","instance":159,"id":220174,"goal":"function Power_159(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_159(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_160","instance":160,"id":220175,"goal":"function Sum_160(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_160(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_161","instance":161,"id":220176,"goal":"method BinarySearch_161(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_162","instance":162,"id":220177,"goal":"method InsertSort_162(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_163","instance":163,"id":220178,"goal":"method MergeSort_163(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_164","instance":164,"id":220179,"goal":"method ArrayCopy_164(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_165","instance":165,"id":220180,"goal":"function ListReverse_165(s: seq): seq\n ensures |ListReverse_165(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_165(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_166","instance":166,"id":220181,"goal":"function Factorial_166(n: nat): nat\n ensures Factorial_166(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_166(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_167","instance":167,"id":220182,"goal":"function Fib_167(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_167(n-1) + Fib_167(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_168","instance":168,"id":220183,"goal":"function Gcd_168(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_168(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_169","instance":169,"id":220184,"goal":"function Power_169(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_169(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_170","instance":170,"id":220185,"goal":"function Sum_170(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_170(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_171","instance":171,"id":220186,"goal":"method BinarySearch_171(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_172","instance":172,"id":220187,"goal":"method InsertSort_172(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_173","instance":173,"id":220188,"goal":"method MergeSort_173(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_174","instance":174,"id":220189,"goal":"method ArrayCopy_174(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_175","instance":175,"id":220190,"goal":"function ListReverse_175(s: seq): seq\n ensures |ListReverse_175(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_175(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_176","instance":176,"id":220191,"goal":"function Factorial_176(n: nat): nat\n ensures Factorial_176(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_176(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_177","instance":177,"id":220192,"goal":"function Fib_177(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_177(n-1) + Fib_177(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_178","instance":178,"id":220193,"goal":"function Gcd_178(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_178(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_179","instance":179,"id":220194,"goal":"function Power_179(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_179(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_180","instance":180,"id":220195,"goal":"function Sum_180(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_180(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_181","instance":181,"id":220196,"goal":"method BinarySearch_181(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_182","instance":182,"id":220197,"goal":"method InsertSort_182(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_183","instance":183,"id":220198,"goal":"method MergeSort_183(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_184","instance":184,"id":220199,"goal":"method ArrayCopy_184(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_185","instance":185,"id":220200,"goal":"function ListReverse_185(s: seq): seq\n ensures |ListReverse_185(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_185(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_186","instance":186,"id":220201,"goal":"function Factorial_186(n: nat): nat\n ensures Factorial_186(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_186(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_187","instance":187,"id":220202,"goal":"function Fib_187(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_187(n-1) + Fib_187(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_188","instance":188,"id":220203,"goal":"function Gcd_188(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_188(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_189","instance":189,"id":220204,"goal":"function Power_189(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_189(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_190","instance":190,"id":220205,"goal":"function Sum_190(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_190(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_191","instance":191,"id":220206,"goal":"method BinarySearch_191(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_192","instance":192,"id":220207,"goal":"method InsertSort_192(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_193","instance":193,"id":220208,"goal":"method MergeSort_193(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_194","instance":194,"id":220209,"goal":"method ArrayCopy_194(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_195","instance":195,"id":220210,"goal":"function ListReverse_195(s: seq): seq\n ensures |ListReverse_195(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_195(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_196","instance":196,"id":220211,"goal":"function Factorial_196(n: nat): nat\n ensures Factorial_196(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_196(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_197","instance":197,"id":220212,"goal":"function Fib_197(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_197(n-1) + Fib_197(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_198","instance":198,"id":220213,"goal":"function Gcd_198(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_198(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_199","instance":199,"id":220214,"goal":"function Power_199(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_199(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_200","instance":200,"id":220215,"goal":"function Sum_200(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_200(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_201","instance":201,"id":220216,"goal":"method BinarySearch_201(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_202","instance":202,"id":220217,"goal":"method InsertSort_202(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_203","instance":203,"id":220218,"goal":"method MergeSort_203(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_204","instance":204,"id":220219,"goal":"method ArrayCopy_204(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_205","instance":205,"id":220220,"goal":"function ListReverse_205(s: seq): seq\n ensures |ListReverse_205(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_205(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_206","instance":206,"id":220221,"goal":"function Factorial_206(n: nat): nat\n ensures Factorial_206(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_206(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_207","instance":207,"id":220222,"goal":"function Fib_207(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_207(n-1) + Fib_207(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_208","instance":208,"id":220223,"goal":"function Gcd_208(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_208(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_209","instance":209,"id":220224,"goal":"function Power_209(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_209(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_210","instance":210,"id":220225,"goal":"function Sum_210(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_210(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_211","instance":211,"id":220226,"goal":"method BinarySearch_211(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_212","instance":212,"id":220227,"goal":"method InsertSort_212(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_213","instance":213,"id":220228,"goal":"method MergeSort_213(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_214","instance":214,"id":220229,"goal":"method ArrayCopy_214(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_215","instance":215,"id":220230,"goal":"function ListReverse_215(s: seq): seq\n ensures |ListReverse_215(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_215(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_216","instance":216,"id":220231,"goal":"function Factorial_216(n: nat): nat\n ensures Factorial_216(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_216(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_217","instance":217,"id":220232,"goal":"function Fib_217(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_217(n-1) + Fib_217(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_218","instance":218,"id":220233,"goal":"function Gcd_218(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_218(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_219","instance":219,"id":220234,"goal":"function Power_219(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_219(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_220","instance":220,"id":220235,"goal":"function Sum_220(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_220(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_221","instance":221,"id":220236,"goal":"method BinarySearch_221(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_222","instance":222,"id":220237,"goal":"method InsertSort_222(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_223","instance":223,"id":220238,"goal":"method MergeSort_223(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_224","instance":224,"id":220239,"goal":"method ArrayCopy_224(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_225","instance":225,"id":220240,"goal":"function ListReverse_225(s: seq): seq\n ensures |ListReverse_225(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_225(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_226","instance":226,"id":220241,"goal":"function Factorial_226(n: nat): nat\n ensures Factorial_226(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_226(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_227","instance":227,"id":220242,"goal":"function Fib_227(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_227(n-1) + Fib_227(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_228","instance":228,"id":220243,"goal":"function Gcd_228(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_228(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_229","instance":229,"id":220244,"goal":"function Power_229(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_229(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_230","instance":230,"id":220245,"goal":"function Sum_230(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_230(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_231","instance":231,"id":220246,"goal":"method BinarySearch_231(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_232","instance":232,"id":220247,"goal":"method InsertSort_232(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_233","instance":233,"id":220248,"goal":"method MergeSort_233(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_234","instance":234,"id":220249,"goal":"method ArrayCopy_234(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_235","instance":235,"id":220250,"goal":"function ListReverse_235(s: seq): seq\n ensures |ListReverse_235(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_235(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_236","instance":236,"id":220251,"goal":"function Factorial_236(n: nat): nat\n ensures Factorial_236(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_236(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_237","instance":237,"id":220252,"goal":"function Fib_237(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_237(n-1) + Fib_237(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_238","instance":238,"id":220253,"goal":"function Gcd_238(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_238(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_239","instance":239,"id":220254,"goal":"function Power_239(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_239(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_240","instance":240,"id":220255,"goal":"function Sum_240(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_240(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_241","instance":241,"id":220256,"goal":"method BinarySearch_241(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_242","instance":242,"id":220257,"goal":"method InsertSort_242(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_243","instance":243,"id":220258,"goal":"method MergeSort_243(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_244","instance":244,"id":220259,"goal":"method ArrayCopy_244(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_245","instance":245,"id":220260,"goal":"function ListReverse_245(s: seq): seq\n ensures |ListReverse_245(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_245(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_246","instance":246,"id":220261,"goal":"function Factorial_246(n: nat): nat\n ensures Factorial_246(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_246(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_247","instance":247,"id":220262,"goal":"function Fib_247(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_247(n-1) + Fib_247(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_248","instance":248,"id":220263,"goal":"function Gcd_248(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_248(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_249","instance":249,"id":220264,"goal":"function Power_249(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_249(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_250","instance":250,"id":220265,"goal":"function Sum_250(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_250(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_251","instance":251,"id":220266,"goal":"method BinarySearch_251(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_252","instance":252,"id":220267,"goal":"method InsertSort_252(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_253","instance":253,"id":220268,"goal":"method MergeSort_253(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_254","instance":254,"id":220269,"goal":"method ArrayCopy_254(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_255","instance":255,"id":220270,"goal":"function ListReverse_255(s: seq): seq\n ensures |ListReverse_255(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_255(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_256","instance":256,"id":220271,"goal":"function Factorial_256(n: nat): nat\n ensures Factorial_256(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_256(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_257","instance":257,"id":220272,"goal":"function Fib_257(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_257(n-1) + Fib_257(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_258","instance":258,"id":220273,"goal":"function Gcd_258(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_258(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_259","instance":259,"id":220274,"goal":"function Power_259(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_259(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_260","instance":260,"id":220275,"goal":"function Sum_260(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_260(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_261","instance":261,"id":220276,"goal":"method BinarySearch_261(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_262","instance":262,"id":220277,"goal":"method InsertSort_262(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_263","instance":263,"id":220278,"goal":"method MergeSort_263(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_264","instance":264,"id":220279,"goal":"method ArrayCopy_264(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_265","instance":265,"id":220280,"goal":"function ListReverse_265(s: seq): seq\n ensures |ListReverse_265(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_265(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_266","instance":266,"id":220281,"goal":"function Factorial_266(n: nat): nat\n ensures Factorial_266(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_266(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_267","instance":267,"id":220282,"goal":"function Fib_267(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_267(n-1) + Fib_267(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_268","instance":268,"id":220283,"goal":"function Gcd_268(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_268(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_269","instance":269,"id":220284,"goal":"function Power_269(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_269(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_270","instance":270,"id":220285,"goal":"function Sum_270(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_270(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_271","instance":271,"id":220286,"goal":"method BinarySearch_271(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_272","instance":272,"id":220287,"goal":"method InsertSort_272(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_273","instance":273,"id":220288,"goal":"method MergeSort_273(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_274","instance":274,"id":220289,"goal":"method ArrayCopy_274(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_275","instance":275,"id":220290,"goal":"function ListReverse_275(s: seq): seq\n ensures |ListReverse_275(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_275(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_276","instance":276,"id":220291,"goal":"function Factorial_276(n: nat): nat\n ensures Factorial_276(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_276(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_277","instance":277,"id":220292,"goal":"function Fib_277(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_277(n-1) + Fib_277(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_278","instance":278,"id":220293,"goal":"function Gcd_278(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_278(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_279","instance":279,"id":220294,"goal":"function Power_279(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_279(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_280","instance":280,"id":220295,"goal":"function Sum_280(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_280(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_281","instance":281,"id":220296,"goal":"method BinarySearch_281(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_282","instance":282,"id":220297,"goal":"method InsertSort_282(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_283","instance":283,"id":220298,"goal":"method MergeSort_283(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_284","instance":284,"id":220299,"goal":"method ArrayCopy_284(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_285","instance":285,"id":220300,"goal":"function ListReverse_285(s: seq): seq\n ensures |ListReverse_285(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_285(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_286","instance":286,"id":220301,"goal":"function Factorial_286(n: nat): nat\n ensures Factorial_286(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_286(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_287","instance":287,"id":220302,"goal":"function Fib_287(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_287(n-1) + Fib_287(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_288","instance":288,"id":220303,"goal":"function Gcd_288(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_288(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_289","instance":289,"id":220304,"goal":"function Power_289(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_289(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_290","instance":290,"id":220305,"goal":"function Sum_290(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_290(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_291","instance":291,"id":220306,"goal":"method BinarySearch_291(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_292","instance":292,"id":220307,"goal":"method InsertSort_292(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_293","instance":293,"id":220308,"goal":"method MergeSort_293(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_294","instance":294,"id":220309,"goal":"method ArrayCopy_294(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_295","instance":295,"id":220310,"goal":"function ListReverse_295(s: seq): seq\n ensures |ListReverse_295(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_295(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_296","instance":296,"id":220311,"goal":"function Factorial_296(n: nat): nat\n ensures Factorial_296(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_296(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_297","instance":297,"id":220312,"goal":"function Fib_297(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_297(n-1) + Fib_297(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_298","instance":298,"id":220313,"goal":"function Gcd_298(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_298(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_299","instance":299,"id":220314,"goal":"function Power_299(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_299(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_300","instance":300,"id":220315,"goal":"function Sum_300(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_300(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_301","instance":301,"id":220316,"goal":"method BinarySearch_301(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_302","instance":302,"id":220317,"goal":"method InsertSort_302(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_303","instance":303,"id":220318,"goal":"method MergeSort_303(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_304","instance":304,"id":220319,"goal":"method ArrayCopy_304(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_305","instance":305,"id":220320,"goal":"function ListReverse_305(s: seq): seq\n ensures |ListReverse_305(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_305(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_306","instance":306,"id":220321,"goal":"function Factorial_306(n: nat): nat\n ensures Factorial_306(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_306(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_307","instance":307,"id":220322,"goal":"function Fib_307(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_307(n-1) + Fib_307(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_308","instance":308,"id":220323,"goal":"function Gcd_308(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_308(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_309","instance":309,"id":220324,"goal":"function Power_309(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_309(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_310","instance":310,"id":220325,"goal":"function Sum_310(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_310(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_311","instance":311,"id":220326,"goal":"method BinarySearch_311(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_312","instance":312,"id":220327,"goal":"method InsertSort_312(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_313","instance":313,"id":220328,"goal":"method MergeSort_313(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_314","instance":314,"id":220329,"goal":"method ArrayCopy_314(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_315","instance":315,"id":220330,"goal":"function ListReverse_315(s: seq): seq\n ensures |ListReverse_315(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_315(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_316","instance":316,"id":220331,"goal":"function Factorial_316(n: nat): nat\n ensures Factorial_316(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_316(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_317","instance":317,"id":220332,"goal":"function Fib_317(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_317(n-1) + Fib_317(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_318","instance":318,"id":220333,"goal":"function Gcd_318(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_318(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_319","instance":319,"id":220334,"goal":"function Power_319(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_319(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_320","instance":320,"id":220335,"goal":"function Sum_320(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_320(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_321","instance":321,"id":220336,"goal":"method BinarySearch_321(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_322","instance":322,"id":220337,"goal":"method InsertSort_322(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_323","instance":323,"id":220338,"goal":"method MergeSort_323(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_324","instance":324,"id":220339,"goal":"method ArrayCopy_324(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_325","instance":325,"id":220340,"goal":"function ListReverse_325(s: seq): seq\n ensures |ListReverse_325(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_325(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_326","instance":326,"id":220341,"goal":"function Factorial_326(n: nat): nat\n ensures Factorial_326(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_326(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_327","instance":327,"id":220342,"goal":"function Fib_327(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_327(n-1) + Fib_327(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_328","instance":328,"id":220343,"goal":"function Gcd_328(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_328(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_329","instance":329,"id":220344,"goal":"function Power_329(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_329(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_330","instance":330,"id":220345,"goal":"function Sum_330(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_330(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_331","instance":331,"id":220346,"goal":"method BinarySearch_331(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_332","instance":332,"id":220347,"goal":"method InsertSort_332(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_333","instance":333,"id":220348,"goal":"method MergeSort_333(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_334","instance":334,"id":220349,"goal":"method ArrayCopy_334(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_335","instance":335,"id":220350,"goal":"function ListReverse_335(s: seq): seq\n ensures |ListReverse_335(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_335(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_336","instance":336,"id":220351,"goal":"function Factorial_336(n: nat): nat\n ensures Factorial_336(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_336(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_337","instance":337,"id":220352,"goal":"function Fib_337(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_337(n-1) + Fib_337(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_338","instance":338,"id":220353,"goal":"function Gcd_338(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_338(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_339","instance":339,"id":220354,"goal":"function Power_339(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_339(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_340","instance":340,"id":220355,"goal":"function Sum_340(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_340(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_341","instance":341,"id":220356,"goal":"method BinarySearch_341(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_342","instance":342,"id":220357,"goal":"method InsertSort_342(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_343","instance":343,"id":220358,"goal":"method MergeSort_343(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_344","instance":344,"id":220359,"goal":"method ArrayCopy_344(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_345","instance":345,"id":220360,"goal":"function ListReverse_345(s: seq): seq\n ensures |ListReverse_345(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_345(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_346","instance":346,"id":220361,"goal":"function Factorial_346(n: nat): nat\n ensures Factorial_346(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_346(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_347","instance":347,"id":220362,"goal":"function Fib_347(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_347(n-1) + Fib_347(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_348","instance":348,"id":220363,"goal":"function Gcd_348(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_348(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_349","instance":349,"id":220364,"goal":"function Power_349(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_349(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_350","instance":350,"id":220365,"goal":"function Sum_350(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_350(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_351","instance":351,"id":220366,"goal":"method BinarySearch_351(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_352","instance":352,"id":220367,"goal":"method InsertSort_352(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_353","instance":353,"id":220368,"goal":"method MergeSort_353(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_354","instance":354,"id":220369,"goal":"method ArrayCopy_354(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_355","instance":355,"id":220370,"goal":"function ListReverse_355(s: seq): seq\n ensures |ListReverse_355(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_355(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_356","instance":356,"id":220371,"goal":"function Factorial_356(n: nat): nat\n ensures Factorial_356(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_356(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_357","instance":357,"id":220372,"goal":"function Fib_357(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_357(n-1) + Fib_357(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_358","instance":358,"id":220373,"goal":"function Gcd_358(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_358(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_359","instance":359,"id":220374,"goal":"function Power_359(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_359(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_360","instance":360,"id":220375,"goal":"function Sum_360(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_360(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_361","instance":361,"id":220376,"goal":"method BinarySearch_361(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_362","instance":362,"id":220377,"goal":"method InsertSort_362(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_363","instance":363,"id":220378,"goal":"method MergeSort_363(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_364","instance":364,"id":220379,"goal":"method ArrayCopy_364(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_365","instance":365,"id":220380,"goal":"function ListReverse_365(s: seq): seq\n ensures |ListReverse_365(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_365(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_366","instance":366,"id":220381,"goal":"function Factorial_366(n: nat): nat\n ensures Factorial_366(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_366(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_367","instance":367,"id":220382,"goal":"function Fib_367(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_367(n-1) + Fib_367(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_368","instance":368,"id":220383,"goal":"function Gcd_368(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_368(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_369","instance":369,"id":220384,"goal":"function Power_369(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_369(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_370","instance":370,"id":220385,"goal":"function Sum_370(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_370(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_371","instance":371,"id":220386,"goal":"method BinarySearch_371(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_372","instance":372,"id":220387,"goal":"method InsertSort_372(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_373","instance":373,"id":220388,"goal":"method MergeSort_373(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_374","instance":374,"id":220389,"goal":"method ArrayCopy_374(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_375","instance":375,"id":220390,"goal":"function ListReverse_375(s: seq): seq\n ensures |ListReverse_375(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_375(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_376","instance":376,"id":220391,"goal":"function Factorial_376(n: nat): nat\n ensures Factorial_376(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_376(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_377","instance":377,"id":220392,"goal":"function Fib_377(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_377(n-1) + Fib_377(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_378","instance":378,"id":220393,"goal":"function Gcd_378(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_378(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_379","instance":379,"id":220394,"goal":"function Power_379(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_379(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_380","instance":380,"id":220395,"goal":"function Sum_380(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_380(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_381","instance":381,"id":220396,"goal":"method BinarySearch_381(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_382","instance":382,"id":220397,"goal":"method InsertSort_382(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_383","instance":383,"id":220398,"goal":"method MergeSort_383(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_384","instance":384,"id":220399,"goal":"method ArrayCopy_384(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_385","instance":385,"id":220400,"goal":"function ListReverse_385(s: seq): seq\n ensures |ListReverse_385(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_385(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_386","instance":386,"id":220401,"goal":"function Factorial_386(n: nat): nat\n ensures Factorial_386(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_386(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_387","instance":387,"id":220402,"goal":"function Fib_387(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_387(n-1) + Fib_387(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_388","instance":388,"id":220403,"goal":"function Gcd_388(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_388(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_389","instance":389,"id":220404,"goal":"function Power_389(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_389(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_390","instance":390,"id":220405,"goal":"function Sum_390(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_390(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_391","instance":391,"id":220406,"goal":"method BinarySearch_391(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_392","instance":392,"id":220407,"goal":"method InsertSort_392(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_393","instance":393,"id":220408,"goal":"method MergeSort_393(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_394","instance":394,"id":220409,"goal":"method ArrayCopy_394(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_395","instance":395,"id":220410,"goal":"function ListReverse_395(s: seq): seq\n ensures |ListReverse_395(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_395(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_396","instance":396,"id":220411,"goal":"function Factorial_396(n: nat): nat\n ensures Factorial_396(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_396(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_397","instance":397,"id":220412,"goal":"function Fib_397(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_397(n-1) + Fib_397(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_398","instance":398,"id":220413,"goal":"function Gcd_398(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_398(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_399","instance":399,"id":220414,"goal":"function Power_399(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_399(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_400","instance":400,"id":220415,"goal":"function Sum_400(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_400(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_401","instance":401,"id":220416,"goal":"method BinarySearch_401(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_402","instance":402,"id":220417,"goal":"method InsertSort_402(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_403","instance":403,"id":220418,"goal":"method MergeSort_403(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_404","instance":404,"id":220419,"goal":"method ArrayCopy_404(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_405","instance":405,"id":220420,"goal":"function ListReverse_405(s: seq): seq\n ensures |ListReverse_405(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_405(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_406","instance":406,"id":220421,"goal":"function Factorial_406(n: nat): nat\n ensures Factorial_406(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_406(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_407","instance":407,"id":220422,"goal":"function Fib_407(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_407(n-1) + Fib_407(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_408","instance":408,"id":220423,"goal":"function Gcd_408(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_408(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_409","instance":409,"id":220424,"goal":"function Power_409(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_409(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_410","instance":410,"id":220425,"goal":"function Sum_410(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_410(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_411","instance":411,"id":220426,"goal":"method BinarySearch_411(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_412","instance":412,"id":220427,"goal":"method InsertSort_412(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_413","instance":413,"id":220428,"goal":"method MergeSort_413(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_414","instance":414,"id":220429,"goal":"method ArrayCopy_414(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_415","instance":415,"id":220430,"goal":"function ListReverse_415(s: seq): seq\n ensures |ListReverse_415(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_415(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_416","instance":416,"id":220431,"goal":"function Factorial_416(n: nat): nat\n ensures Factorial_416(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_416(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_417","instance":417,"id":220432,"goal":"function Fib_417(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_417(n-1) + Fib_417(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_418","instance":418,"id":220433,"goal":"function Gcd_418(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_418(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_419","instance":419,"id":220434,"goal":"function Power_419(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_419(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_420","instance":420,"id":220435,"goal":"function Sum_420(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_420(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_421","instance":421,"id":220436,"goal":"method BinarySearch_421(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_422","instance":422,"id":220437,"goal":"method InsertSort_422(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_423","instance":423,"id":220438,"goal":"method MergeSort_423(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_424","instance":424,"id":220439,"goal":"method ArrayCopy_424(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_425","instance":425,"id":220440,"goal":"function ListReverse_425(s: seq): seq\n ensures |ListReverse_425(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_425(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_426","instance":426,"id":220441,"goal":"function Factorial_426(n: nat): nat\n ensures Factorial_426(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_426(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_427","instance":427,"id":220442,"goal":"function Fib_427(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_427(n-1) + Fib_427(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_428","instance":428,"id":220443,"goal":"function Gcd_428(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_428(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_429","instance":429,"id":220444,"goal":"function Power_429(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_429(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_430","instance":430,"id":220445,"goal":"function Sum_430(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_430(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_431","instance":431,"id":220446,"goal":"method BinarySearch_431(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_432","instance":432,"id":220447,"goal":"method InsertSort_432(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_433","instance":433,"id":220448,"goal":"method MergeSort_433(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_434","instance":434,"id":220449,"goal":"method ArrayCopy_434(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_435","instance":435,"id":220450,"goal":"function ListReverse_435(s: seq): seq\n ensures |ListReverse_435(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_435(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_436","instance":436,"id":220451,"goal":"function Factorial_436(n: nat): nat\n ensures Factorial_436(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_436(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_437","instance":437,"id":220452,"goal":"function Fib_437(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_437(n-1) + Fib_437(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_438","instance":438,"id":220453,"goal":"function Gcd_438(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_438(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_439","instance":439,"id":220454,"goal":"function Power_439(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_439(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_440","instance":440,"id":220455,"goal":"function Sum_440(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_440(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_441","instance":441,"id":220456,"goal":"method BinarySearch_441(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_442","instance":442,"id":220457,"goal":"method InsertSort_442(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_443","instance":443,"id":220458,"goal":"method MergeSort_443(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_444","instance":444,"id":220459,"goal":"method ArrayCopy_444(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_445","instance":445,"id":220460,"goal":"function ListReverse_445(s: seq): seq\n ensures |ListReverse_445(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_445(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_446","instance":446,"id":220461,"goal":"function Factorial_446(n: nat): nat\n ensures Factorial_446(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_446(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_447","instance":447,"id":220462,"goal":"function Fib_447(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_447(n-1) + Fib_447(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_448","instance":448,"id":220463,"goal":"function Gcd_448(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_448(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_449","instance":449,"id":220464,"goal":"function Power_449(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_449(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_450","instance":450,"id":220465,"goal":"function Sum_450(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_450(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_451","instance":451,"id":220466,"goal":"method BinarySearch_451(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_452","instance":452,"id":220467,"goal":"method InsertSort_452(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_453","instance":453,"id":220468,"goal":"method MergeSort_453(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_454","instance":454,"id":220469,"goal":"method ArrayCopy_454(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_455","instance":455,"id":220470,"goal":"function ListReverse_455(s: seq): seq\n ensures |ListReverse_455(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_455(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_456","instance":456,"id":220471,"goal":"function Factorial_456(n: nat): nat\n ensures Factorial_456(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_456(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_457","instance":457,"id":220472,"goal":"function Fib_457(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_457(n-1) + Fib_457(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_458","instance":458,"id":220473,"goal":"function Gcd_458(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_458(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_459","instance":459,"id":220474,"goal":"function Power_459(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_459(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_460","instance":460,"id":220475,"goal":"function Sum_460(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_460(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_461","instance":461,"id":220476,"goal":"method BinarySearch_461(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_462","instance":462,"id":220477,"goal":"method InsertSort_462(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_463","instance":463,"id":220478,"goal":"method MergeSort_463(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_464","instance":464,"id":220479,"goal":"method ArrayCopy_464(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_465","instance":465,"id":220480,"goal":"function ListReverse_465(s: seq): seq\n ensures |ListReverse_465(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_465(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_466","instance":466,"id":220481,"goal":"function Factorial_466(n: nat): nat\n ensures Factorial_466(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_466(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_467","instance":467,"id":220482,"goal":"function Fib_467(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_467(n-1) + Fib_467(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_468","instance":468,"id":220483,"goal":"function Gcd_468(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_468(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_469","instance":469,"id":220484,"goal":"function Power_469(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_469(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_470","instance":470,"id":220485,"goal":"function Sum_470(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_470(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_471","instance":471,"id":220486,"goal":"method BinarySearch_471(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_472","instance":472,"id":220487,"goal":"method InsertSort_472(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_473","instance":473,"id":220488,"goal":"method MergeSort_473(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_474","instance":474,"id":220489,"goal":"method ArrayCopy_474(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_475","instance":475,"id":220490,"goal":"function ListReverse_475(s: seq): seq\n ensures |ListReverse_475(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_475(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_476","instance":476,"id":220491,"goal":"function Factorial_476(n: nat): nat\n ensures Factorial_476(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_476(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_477","instance":477,"id":220492,"goal":"function Fib_477(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_477(n-1) + Fib_477(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_478","instance":478,"id":220493,"goal":"function Gcd_478(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_478(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_479","instance":479,"id":220494,"goal":"function Power_479(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_479(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_480","instance":480,"id":220495,"goal":"function Sum_480(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_480(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_481","instance":481,"id":220496,"goal":"method BinarySearch_481(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_482","instance":482,"id":220497,"goal":"method InsertSort_482(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_483","instance":483,"id":220498,"goal":"method MergeSort_483(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_484","instance":484,"id":220499,"goal":"method ArrayCopy_484(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_485","instance":485,"id":220500,"goal":"function ListReverse_485(s: seq): seq\n ensures |ListReverse_485(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_485(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_486","instance":486,"id":220501,"goal":"function Factorial_486(n: nat): nat\n ensures Factorial_486(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_486(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_487","instance":487,"id":220502,"goal":"function Fib_487(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_487(n-1) + Fib_487(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_488","instance":488,"id":220503,"goal":"function Gcd_488(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_488(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_489","instance":489,"id":220504,"goal":"function Power_489(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_489(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_490","instance":490,"id":220505,"goal":"function Sum_490(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_490(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_491","instance":491,"id":220506,"goal":"method BinarySearch_491(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_492","instance":492,"id":220507,"goal":"method InsertSort_492(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_493","instance":493,"id":220508,"goal":"method MergeSort_493(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_494","instance":494,"id":220509,"goal":"method ArrayCopy_494(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_495","instance":495,"id":220510,"goal":"function ListReverse_495(s: seq): seq\n ensures |ListReverse_495(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_495(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_496","instance":496,"id":220511,"goal":"function Factorial_496(n: nat): nat\n ensures Factorial_496(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_496(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_497","instance":497,"id":220512,"goal":"function Fib_497(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_497(n-1) + Fib_497(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_498","instance":498,"id":220513,"goal":"function Gcd_498(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_498(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_499","instance":499,"id":220514,"goal":"function Power_499(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_499(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_500","instance":500,"id":220515,"goal":"function Sum_500(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_500(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_501","instance":501,"id":220516,"goal":"method BinarySearch_501(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_502","instance":502,"id":220517,"goal":"method InsertSort_502(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_503","instance":503,"id":220518,"goal":"method MergeSort_503(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_504","instance":504,"id":220519,"goal":"method ArrayCopy_504(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_505","instance":505,"id":220520,"goal":"function ListReverse_505(s: seq): seq\n ensures |ListReverse_505(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_505(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_506","instance":506,"id":220521,"goal":"function Factorial_506(n: nat): nat\n ensures Factorial_506(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_506(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_507","instance":507,"id":220522,"goal":"function Fib_507(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_507(n-1) + Fib_507(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_508","instance":508,"id":220523,"goal":"function Gcd_508(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_508(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_509","instance":509,"id":220524,"goal":"function Power_509(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_509(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_510","instance":510,"id":220525,"goal":"function Sum_510(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_510(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_511","instance":511,"id":220526,"goal":"method BinarySearch_511(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_512","instance":512,"id":220527,"goal":"method InsertSort_512(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_513","instance":513,"id":220528,"goal":"method MergeSort_513(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_514","instance":514,"id":220529,"goal":"method ArrayCopy_514(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_515","instance":515,"id":220530,"goal":"function ListReverse_515(s: seq): seq\n ensures |ListReverse_515(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_515(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_516","instance":516,"id":220531,"goal":"function Factorial_516(n: nat): nat\n ensures Factorial_516(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_516(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_517","instance":517,"id":220532,"goal":"function Fib_517(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_517(n-1) + Fib_517(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_518","instance":518,"id":220533,"goal":"function Gcd_518(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_518(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_519","instance":519,"id":220534,"goal":"function Power_519(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_519(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_520","instance":520,"id":220535,"goal":"function Sum_520(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_520(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_521","instance":521,"id":220536,"goal":"method BinarySearch_521(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_522","instance":522,"id":220537,"goal":"method InsertSort_522(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_523","instance":523,"id":220538,"goal":"method MergeSort_523(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_524","instance":524,"id":220539,"goal":"method ArrayCopy_524(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_525","instance":525,"id":220540,"goal":"function ListReverse_525(s: seq): seq\n ensures |ListReverse_525(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_525(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_526","instance":526,"id":220541,"goal":"function Factorial_526(n: nat): nat\n ensures Factorial_526(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_526(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_527","instance":527,"id":220542,"goal":"function Fib_527(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_527(n-1) + Fib_527(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_528","instance":528,"id":220543,"goal":"function Gcd_528(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_528(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_529","instance":529,"id":220544,"goal":"function Power_529(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_529(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_530","instance":530,"id":220545,"goal":"function Sum_530(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_530(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_531","instance":531,"id":220546,"goal":"method BinarySearch_531(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_532","instance":532,"id":220547,"goal":"method InsertSort_532(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_533","instance":533,"id":220548,"goal":"method MergeSort_533(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_534","instance":534,"id":220549,"goal":"method ArrayCopy_534(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_535","instance":535,"id":220550,"goal":"function ListReverse_535(s: seq): seq\n ensures |ListReverse_535(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_535(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_536","instance":536,"id":220551,"goal":"function Factorial_536(n: nat): nat\n ensures Factorial_536(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_536(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_537","instance":537,"id":220552,"goal":"function Fib_537(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_537(n-1) + Fib_537(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_538","instance":538,"id":220553,"goal":"function Gcd_538(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_538(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_539","instance":539,"id":220554,"goal":"function Power_539(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_539(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_540","instance":540,"id":220555,"goal":"function Sum_540(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_540(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_541","instance":541,"id":220556,"goal":"method BinarySearch_541(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_542","instance":542,"id":220557,"goal":"method InsertSort_542(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_543","instance":543,"id":220558,"goal":"method MergeSort_543(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_544","instance":544,"id":220559,"goal":"method ArrayCopy_544(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_545","instance":545,"id":220560,"goal":"function ListReverse_545(s: seq): seq\n ensures |ListReverse_545(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_545(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_546","instance":546,"id":220561,"goal":"function Factorial_546(n: nat): nat\n ensures Factorial_546(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_546(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_547","instance":547,"id":220562,"goal":"function Fib_547(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_547(n-1) + Fib_547(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_548","instance":548,"id":220563,"goal":"function Gcd_548(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_548(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_549","instance":549,"id":220564,"goal":"function Power_549(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_549(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_550","instance":550,"id":220565,"goal":"function Sum_550(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_550(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_551","instance":551,"id":220566,"goal":"method BinarySearch_551(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_552","instance":552,"id":220567,"goal":"method InsertSort_552(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_553","instance":553,"id":220568,"goal":"method MergeSort_553(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_554","instance":554,"id":220569,"goal":"method ArrayCopy_554(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_555","instance":555,"id":220570,"goal":"function ListReverse_555(s: seq): seq\n ensures |ListReverse_555(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_555(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_556","instance":556,"id":220571,"goal":"function Factorial_556(n: nat): nat\n ensures Factorial_556(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_556(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_557","instance":557,"id":220572,"goal":"function Fib_557(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_557(n-1) + Fib_557(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_558","instance":558,"id":220573,"goal":"function Gcd_558(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_558(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_559","instance":559,"id":220574,"goal":"function Power_559(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_559(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_560","instance":560,"id":220575,"goal":"function Sum_560(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_560(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_561","instance":561,"id":220576,"goal":"method BinarySearch_561(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_562","instance":562,"id":220577,"goal":"method InsertSort_562(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_563","instance":563,"id":220578,"goal":"method MergeSort_563(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_564","instance":564,"id":220579,"goal":"method ArrayCopy_564(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_565","instance":565,"id":220580,"goal":"function ListReverse_565(s: seq): seq\n ensures |ListReverse_565(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_565(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_566","instance":566,"id":220581,"goal":"function Factorial_566(n: nat): nat\n ensures Factorial_566(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_566(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_567","instance":567,"id":220582,"goal":"function Fib_567(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_567(n-1) + Fib_567(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_568","instance":568,"id":220583,"goal":"function Gcd_568(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_568(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_569","instance":569,"id":220584,"goal":"function Power_569(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_569(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_570","instance":570,"id":220585,"goal":"function Sum_570(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_570(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_571","instance":571,"id":220586,"goal":"method BinarySearch_571(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_572","instance":572,"id":220587,"goal":"method InsertSort_572(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_573","instance":573,"id":220588,"goal":"method MergeSort_573(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_574","instance":574,"id":220589,"goal":"method ArrayCopy_574(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_575","instance":575,"id":220590,"goal":"function ListReverse_575(s: seq): seq\n ensures |ListReverse_575(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_575(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_576","instance":576,"id":220591,"goal":"function Factorial_576(n: nat): nat\n ensures Factorial_576(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_576(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_577","instance":577,"id":220592,"goal":"function Fib_577(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_577(n-1) + Fib_577(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_578","instance":578,"id":220593,"goal":"function Gcd_578(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_578(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_579","instance":579,"id":220594,"goal":"function Power_579(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_579(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_580","instance":580,"id":220595,"goal":"function Sum_580(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_580(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_581","instance":581,"id":220596,"goal":"method BinarySearch_581(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_582","instance":582,"id":220597,"goal":"method InsertSort_582(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_583","instance":583,"id":220598,"goal":"method MergeSort_583(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_584","instance":584,"id":220599,"goal":"method ArrayCopy_584(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_585","instance":585,"id":220600,"goal":"function ListReverse_585(s: seq): seq\n ensures |ListReverse_585(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_585(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_586","instance":586,"id":220601,"goal":"function Factorial_586(n: nat): nat\n ensures Factorial_586(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_586(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_587","instance":587,"id":220602,"goal":"function Fib_587(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_587(n-1) + Fib_587(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_588","instance":588,"id":220603,"goal":"function Gcd_588(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_588(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_589","instance":589,"id":220604,"goal":"function Power_589(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_589(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_590","instance":590,"id":220605,"goal":"function Sum_590(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_590(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_591","instance":591,"id":220606,"goal":"method BinarySearch_591(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_592","instance":592,"id":220607,"goal":"method InsertSort_592(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_593","instance":593,"id":220608,"goal":"method MergeSort_593(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_594","instance":594,"id":220609,"goal":"method ArrayCopy_594(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_595","instance":595,"id":220610,"goal":"function ListReverse_595(s: seq): seq\n ensures |ListReverse_595(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_595(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_596","instance":596,"id":220611,"goal":"function Factorial_596(n: nat): nat\n ensures Factorial_596(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_596(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_597","instance":597,"id":220612,"goal":"function Fib_597(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_597(n-1) + Fib_597(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_598","instance":598,"id":220613,"goal":"function Gcd_598(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_598(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_599","instance":599,"id":220614,"goal":"function Power_599(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_599(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_600","instance":600,"id":220615,"goal":"function Sum_600(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_600(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_601","instance":601,"id":220616,"goal":"method BinarySearch_601(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_602","instance":602,"id":220617,"goal":"method InsertSort_602(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_603","instance":603,"id":220618,"goal":"method MergeSort_603(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_604","instance":604,"id":220619,"goal":"method ArrayCopy_604(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_605","instance":605,"id":220620,"goal":"function ListReverse_605(s: seq): seq\n ensures |ListReverse_605(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_605(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_606","instance":606,"id":220621,"goal":"function Factorial_606(n: nat): nat\n ensures Factorial_606(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_606(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_607","instance":607,"id":220622,"goal":"function Fib_607(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_607(n-1) + Fib_607(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_608","instance":608,"id":220623,"goal":"function Gcd_608(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_608(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_609","instance":609,"id":220624,"goal":"function Power_609(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_609(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_610","instance":610,"id":220625,"goal":"function Sum_610(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_610(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_611","instance":611,"id":220626,"goal":"method BinarySearch_611(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_612","instance":612,"id":220627,"goal":"method InsertSort_612(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_613","instance":613,"id":220628,"goal":"method MergeSort_613(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_614","instance":614,"id":220629,"goal":"method ArrayCopy_614(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_615","instance":615,"id":220630,"goal":"function ListReverse_615(s: seq): seq\n ensures |ListReverse_615(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_615(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_616","instance":616,"id":220631,"goal":"function Factorial_616(n: nat): nat\n ensures Factorial_616(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_616(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_617","instance":617,"id":220632,"goal":"function Fib_617(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_617(n-1) + Fib_617(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_618","instance":618,"id":220633,"goal":"function Gcd_618(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_618(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_619","instance":619,"id":220634,"goal":"function Power_619(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_619(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_620","instance":620,"id":220635,"goal":"function Sum_620(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_620(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_621","instance":621,"id":220636,"goal":"method BinarySearch_621(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_622","instance":622,"id":220637,"goal":"method InsertSort_622(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_623","instance":623,"id":220638,"goal":"method MergeSort_623(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_624","instance":624,"id":220639,"goal":"method ArrayCopy_624(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_625","instance":625,"id":220640,"goal":"function ListReverse_625(s: seq): seq\n ensures |ListReverse_625(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_625(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_626","instance":626,"id":220641,"goal":"function Factorial_626(n: nat): nat\n ensures Factorial_626(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_626(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_627","instance":627,"id":220642,"goal":"function Fib_627(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_627(n-1) + Fib_627(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_628","instance":628,"id":220643,"goal":"function Gcd_628(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_628(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_629","instance":629,"id":220644,"goal":"function Power_629(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_629(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_630","instance":630,"id":220645,"goal":"function Sum_630(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_630(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_631","instance":631,"id":220646,"goal":"method BinarySearch_631(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_632","instance":632,"id":220647,"goal":"method InsertSort_632(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_633","instance":633,"id":220648,"goal":"method MergeSort_633(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_634","instance":634,"id":220649,"goal":"method ArrayCopy_634(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_635","instance":635,"id":220650,"goal":"function ListReverse_635(s: seq): seq\n ensures |ListReverse_635(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_635(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_636","instance":636,"id":220651,"goal":"function Factorial_636(n: nat): nat\n ensures Factorial_636(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_636(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_637","instance":637,"id":220652,"goal":"function Fib_637(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_637(n-1) + Fib_637(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_638","instance":638,"id":220653,"goal":"function Gcd_638(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_638(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_639","instance":639,"id":220654,"goal":"function Power_639(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_639(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_640","instance":640,"id":220655,"goal":"function Sum_640(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_640(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_641","instance":641,"id":220656,"goal":"method BinarySearch_641(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_642","instance":642,"id":220657,"goal":"method InsertSort_642(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_643","instance":643,"id":220658,"goal":"method MergeSort_643(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_644","instance":644,"id":220659,"goal":"method ArrayCopy_644(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_645","instance":645,"id":220660,"goal":"function ListReverse_645(s: seq): seq\n ensures |ListReverse_645(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_645(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_646","instance":646,"id":220661,"goal":"function Factorial_646(n: nat): nat\n ensures Factorial_646(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_646(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_647","instance":647,"id":220662,"goal":"function Fib_647(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_647(n-1) + Fib_647(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_648","instance":648,"id":220663,"goal":"function Gcd_648(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_648(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_649","instance":649,"id":220664,"goal":"function Power_649(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_649(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_650","instance":650,"id":220665,"goal":"function Sum_650(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_650(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_651","instance":651,"id":220666,"goal":"method BinarySearch_651(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_652","instance":652,"id":220667,"goal":"method InsertSort_652(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_653","instance":653,"id":220668,"goal":"method MergeSort_653(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_654","instance":654,"id":220669,"goal":"method ArrayCopy_654(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_655","instance":655,"id":220670,"goal":"function ListReverse_655(s: seq): seq\n ensures |ListReverse_655(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_655(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_656","instance":656,"id":220671,"goal":"function Factorial_656(n: nat): nat\n ensures Factorial_656(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_656(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_657","instance":657,"id":220672,"goal":"function Fib_657(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_657(n-1) + Fib_657(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_658","instance":658,"id":220673,"goal":"function Gcd_658(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_658(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_659","instance":659,"id":220674,"goal":"function Power_659(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_659(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_660","instance":660,"id":220675,"goal":"function Sum_660(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_660(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_661","instance":661,"id":220676,"goal":"method BinarySearch_661(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_662","instance":662,"id":220677,"goal":"method InsertSort_662(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_663","instance":663,"id":220678,"goal":"method MergeSort_663(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_664","instance":664,"id":220679,"goal":"method ArrayCopy_664(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_665","instance":665,"id":220680,"goal":"function ListReverse_665(s: seq): seq\n ensures |ListReverse_665(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_665(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_666","instance":666,"id":220681,"goal":"function Factorial_666(n: nat): nat\n ensures Factorial_666(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_666(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_667","instance":667,"id":220682,"goal":"function Fib_667(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_667(n-1) + Fib_667(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_668","instance":668,"id":220683,"goal":"function Gcd_668(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_668(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_669","instance":669,"id":220684,"goal":"function Power_669(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_669(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_670","instance":670,"id":220685,"goal":"function Sum_670(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_670(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_671","instance":671,"id":220686,"goal":"method BinarySearch_671(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_672","instance":672,"id":220687,"goal":"method InsertSort_672(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_673","instance":673,"id":220688,"goal":"method MergeSort_673(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_674","instance":674,"id":220689,"goal":"method ArrayCopy_674(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_675","instance":675,"id":220690,"goal":"function ListReverse_675(s: seq): seq\n ensures |ListReverse_675(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_675(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_676","instance":676,"id":220691,"goal":"function Factorial_676(n: nat): nat\n ensures Factorial_676(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_676(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_677","instance":677,"id":220692,"goal":"function Fib_677(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_677(n-1) + Fib_677(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_678","instance":678,"id":220693,"goal":"function Gcd_678(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_678(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_679","instance":679,"id":220694,"goal":"function Power_679(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_679(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_680","instance":680,"id":220695,"goal":"function Sum_680(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_680(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_681","instance":681,"id":220696,"goal":"method BinarySearch_681(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_682","instance":682,"id":220697,"goal":"method InsertSort_682(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_683","instance":683,"id":220698,"goal":"method MergeSort_683(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_684","instance":684,"id":220699,"goal":"method ArrayCopy_684(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_685","instance":685,"id":220700,"goal":"function ListReverse_685(s: seq): seq\n ensures |ListReverse_685(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_685(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_686","instance":686,"id":220701,"goal":"function Factorial_686(n: nat): nat\n ensures Factorial_686(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_686(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_687","instance":687,"id":220702,"goal":"function Fib_687(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_687(n-1) + Fib_687(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_688","instance":688,"id":220703,"goal":"function Gcd_688(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_688(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_689","instance":689,"id":220704,"goal":"function Power_689(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_689(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_690","instance":690,"id":220705,"goal":"function Sum_690(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_690(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_691","instance":691,"id":220706,"goal":"method BinarySearch_691(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_692","instance":692,"id":220707,"goal":"method InsertSort_692(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_693","instance":693,"id":220708,"goal":"method MergeSort_693(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_694","instance":694,"id":220709,"goal":"method ArrayCopy_694(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_695","instance":695,"id":220710,"goal":"function ListReverse_695(s: seq): seq\n ensures |ListReverse_695(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_695(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_696","instance":696,"id":220711,"goal":"function Factorial_696(n: nat): nat\n ensures Factorial_696(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_696(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_697","instance":697,"id":220712,"goal":"function Fib_697(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_697(n-1) + Fib_697(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_698","instance":698,"id":220713,"goal":"function Gcd_698(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_698(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_699","instance":699,"id":220714,"goal":"function Power_699(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_699(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_700","instance":700,"id":220715,"goal":"function Sum_700(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_700(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_701","instance":701,"id":220716,"goal":"method BinarySearch_701(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_702","instance":702,"id":220717,"goal":"method InsertSort_702(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_703","instance":703,"id":220718,"goal":"method MergeSort_703(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_704","instance":704,"id":220719,"goal":"method ArrayCopy_704(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_705","instance":705,"id":220720,"goal":"function ListReverse_705(s: seq): seq\n ensures |ListReverse_705(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_705(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_706","instance":706,"id":220721,"goal":"function Factorial_706(n: nat): nat\n ensures Factorial_706(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_706(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_707","instance":707,"id":220722,"goal":"function Fib_707(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_707(n-1) + Fib_707(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_708","instance":708,"id":220723,"goal":"function Gcd_708(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_708(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_709","instance":709,"id":220724,"goal":"function Power_709(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_709(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_710","instance":710,"id":220725,"goal":"function Sum_710(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_710(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_711","instance":711,"id":220726,"goal":"method BinarySearch_711(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_712","instance":712,"id":220727,"goal":"method InsertSort_712(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_713","instance":713,"id":220728,"goal":"method MergeSort_713(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_714","instance":714,"id":220729,"goal":"method ArrayCopy_714(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_715","instance":715,"id":220730,"goal":"function ListReverse_715(s: seq): seq\n ensures |ListReverse_715(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_715(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_716","instance":716,"id":220731,"goal":"function Factorial_716(n: nat): nat\n ensures Factorial_716(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_716(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_717","instance":717,"id":220732,"goal":"function Fib_717(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_717(n-1) + Fib_717(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_718","instance":718,"id":220733,"goal":"function Gcd_718(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_718(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_719","instance":719,"id":220734,"goal":"function Power_719(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_719(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_720","instance":720,"id":220735,"goal":"function Sum_720(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_720(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_721","instance":721,"id":220736,"goal":"method BinarySearch_721(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_722","instance":722,"id":220737,"goal":"method InsertSort_722(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_723","instance":723,"id":220738,"goal":"method MergeSort_723(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_724","instance":724,"id":220739,"goal":"method ArrayCopy_724(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_725","instance":725,"id":220740,"goal":"function ListReverse_725(s: seq): seq\n ensures |ListReverse_725(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_725(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_726","instance":726,"id":220741,"goal":"function Factorial_726(n: nat): nat\n ensures Factorial_726(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_726(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_727","instance":727,"id":220742,"goal":"function Fib_727(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_727(n-1) + Fib_727(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_728","instance":728,"id":220743,"goal":"function Gcd_728(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_728(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_729","instance":729,"id":220744,"goal":"function Power_729(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_729(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_730","instance":730,"id":220745,"goal":"function Sum_730(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_730(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_731","instance":731,"id":220746,"goal":"method BinarySearch_731(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_732","instance":732,"id":220747,"goal":"method InsertSort_732(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_733","instance":733,"id":220748,"goal":"method MergeSort_733(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_734","instance":734,"id":220749,"goal":"method ArrayCopy_734(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_735","instance":735,"id":220750,"goal":"function ListReverse_735(s: seq): seq\n ensures |ListReverse_735(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_735(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_736","instance":736,"id":220751,"goal":"function Factorial_736(n: nat): nat\n ensures Factorial_736(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_736(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_737","instance":737,"id":220752,"goal":"function Fib_737(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_737(n-1) + Fib_737(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_738","instance":738,"id":220753,"goal":"function Gcd_738(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_738(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_739","instance":739,"id":220754,"goal":"function Power_739(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_739(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_740","instance":740,"id":220755,"goal":"function Sum_740(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_740(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_741","instance":741,"id":220756,"goal":"method BinarySearch_741(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_742","instance":742,"id":220757,"goal":"method InsertSort_742(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_743","instance":743,"id":220758,"goal":"method MergeSort_743(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_744","instance":744,"id":220759,"goal":"method ArrayCopy_744(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_745","instance":745,"id":220760,"goal":"function ListReverse_745(s: seq): seq\n ensures |ListReverse_745(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_745(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_746","instance":746,"id":220761,"goal":"function Factorial_746(n: nat): nat\n ensures Factorial_746(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_746(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_747","instance":747,"id":220762,"goal":"function Fib_747(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_747(n-1) + Fib_747(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_748","instance":748,"id":220763,"goal":"function Gcd_748(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_748(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_749","instance":749,"id":220764,"goal":"function Power_749(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_749(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_750","instance":750,"id":220765,"goal":"function Sum_750(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_750(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_751","instance":751,"id":220766,"goal":"method BinarySearch_751(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_752","instance":752,"id":220767,"goal":"method InsertSort_752(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_753","instance":753,"id":220768,"goal":"method MergeSort_753(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_754","instance":754,"id":220769,"goal":"method ArrayCopy_754(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_755","instance":755,"id":220770,"goal":"function ListReverse_755(s: seq): seq\n ensures |ListReverse_755(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_755(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_756","instance":756,"id":220771,"goal":"function Factorial_756(n: nat): nat\n ensures Factorial_756(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_756(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_757","instance":757,"id":220772,"goal":"function Fib_757(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_757(n-1) + Fib_757(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_758","instance":758,"id":220773,"goal":"function Gcd_758(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_758(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_759","instance":759,"id":220774,"goal":"function Power_759(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_759(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_760","instance":760,"id":220775,"goal":"function Sum_760(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_760(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_761","instance":761,"id":220776,"goal":"method BinarySearch_761(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_762","instance":762,"id":220777,"goal":"method InsertSort_762(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_763","instance":763,"id":220778,"goal":"method MergeSort_763(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_764","instance":764,"id":220779,"goal":"method ArrayCopy_764(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_765","instance":765,"id":220780,"goal":"function ListReverse_765(s: seq): seq\n ensures |ListReverse_765(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_765(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_766","instance":766,"id":220781,"goal":"function Factorial_766(n: nat): nat\n ensures Factorial_766(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_766(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_767","instance":767,"id":220782,"goal":"function Fib_767(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_767(n-1) + Fib_767(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_768","instance":768,"id":220783,"goal":"function Gcd_768(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_768(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_769","instance":769,"id":220784,"goal":"function Power_769(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_769(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_770","instance":770,"id":220785,"goal":"function Sum_770(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_770(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_771","instance":771,"id":220786,"goal":"method BinarySearch_771(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_772","instance":772,"id":220787,"goal":"method InsertSort_772(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_773","instance":773,"id":220788,"goal":"method MergeSort_773(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_774","instance":774,"id":220789,"goal":"method ArrayCopy_774(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_775","instance":775,"id":220790,"goal":"function ListReverse_775(s: seq): seq\n ensures |ListReverse_775(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_775(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_776","instance":776,"id":220791,"goal":"function Factorial_776(n: nat): nat\n ensures Factorial_776(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_776(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_777","instance":777,"id":220792,"goal":"function Fib_777(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_777(n-1) + Fib_777(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_778","instance":778,"id":220793,"goal":"function Gcd_778(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_778(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_779","instance":779,"id":220794,"goal":"function Power_779(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_779(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_780","instance":780,"id":220795,"goal":"function Sum_780(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_780(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_781","instance":781,"id":220796,"goal":"method BinarySearch_781(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_782","instance":782,"id":220797,"goal":"method InsertSort_782(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_783","instance":783,"id":220798,"goal":"method MergeSort_783(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_784","instance":784,"id":220799,"goal":"method ArrayCopy_784(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_785","instance":785,"id":220800,"goal":"function ListReverse_785(s: seq): seq\n ensures |ListReverse_785(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_785(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_786","instance":786,"id":220801,"goal":"function Factorial_786(n: nat): nat\n ensures Factorial_786(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_786(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_787","instance":787,"id":220802,"goal":"function Fib_787(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_787(n-1) + Fib_787(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_788","instance":788,"id":220803,"goal":"function Gcd_788(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_788(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_789","instance":789,"id":220804,"goal":"function Power_789(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_789(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_790","instance":790,"id":220805,"goal":"function Sum_790(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_790(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_791","instance":791,"id":220806,"goal":"method BinarySearch_791(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_792","instance":792,"id":220807,"goal":"method InsertSort_792(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_793","instance":793,"id":220808,"goal":"method MergeSort_793(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_794","instance":794,"id":220809,"goal":"method ArrayCopy_794(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_795","instance":795,"id":220810,"goal":"function ListReverse_795(s: seq): seq\n ensures |ListReverse_795(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_795(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_796","instance":796,"id":220811,"goal":"function Factorial_796(n: nat): nat\n ensures Factorial_796(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_796(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_797","instance":797,"id":220812,"goal":"function Fib_797(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_797(n-1) + Fib_797(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_798","instance":798,"id":220813,"goal":"function Gcd_798(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_798(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_799","instance":799,"id":220814,"goal":"function Power_799(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_799(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_800","instance":800,"id":220815,"goal":"function Sum_800(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_800(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_801","instance":801,"id":220816,"goal":"method BinarySearch_801(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_802","instance":802,"id":220817,"goal":"method InsertSort_802(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_803","instance":803,"id":220818,"goal":"method MergeSort_803(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_804","instance":804,"id":220819,"goal":"method ArrayCopy_804(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_805","instance":805,"id":220820,"goal":"function ListReverse_805(s: seq): seq\n ensures |ListReverse_805(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_805(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_806","instance":806,"id":220821,"goal":"function Factorial_806(n: nat): nat\n ensures Factorial_806(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_806(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_807","instance":807,"id":220822,"goal":"function Fib_807(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_807(n-1) + Fib_807(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_808","instance":808,"id":220823,"goal":"function Gcd_808(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_808(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_809","instance":809,"id":220824,"goal":"function Power_809(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_809(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_810","instance":810,"id":220825,"goal":"function Sum_810(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_810(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_811","instance":811,"id":220826,"goal":"method BinarySearch_811(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_812","instance":812,"id":220827,"goal":"method InsertSort_812(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_813","instance":813,"id":220828,"goal":"method MergeSort_813(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_814","instance":814,"id":220829,"goal":"method ArrayCopy_814(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_815","instance":815,"id":220830,"goal":"function ListReverse_815(s: seq): seq\n ensures |ListReverse_815(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_815(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_816","instance":816,"id":220831,"goal":"function Factorial_816(n: nat): nat\n ensures Factorial_816(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_816(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_817","instance":817,"id":220832,"goal":"function Fib_817(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_817(n-1) + Fib_817(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_818","instance":818,"id":220833,"goal":"function Gcd_818(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_818(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_819","instance":819,"id":220834,"goal":"function Power_819(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_819(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_820","instance":820,"id":220835,"goal":"function Sum_820(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_820(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_821","instance":821,"id":220836,"goal":"method BinarySearch_821(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_822","instance":822,"id":220837,"goal":"method InsertSort_822(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_823","instance":823,"id":220838,"goal":"method MergeSort_823(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_824","instance":824,"id":220839,"goal":"method ArrayCopy_824(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_825","instance":825,"id":220840,"goal":"function ListReverse_825(s: seq): seq\n ensures |ListReverse_825(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_825(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_826","instance":826,"id":220841,"goal":"function Factorial_826(n: nat): nat\n ensures Factorial_826(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_826(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_827","instance":827,"id":220842,"goal":"function Fib_827(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_827(n-1) + Fib_827(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_828","instance":828,"id":220843,"goal":"function Gcd_828(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_828(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_829","instance":829,"id":220844,"goal":"function Power_829(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_829(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_830","instance":830,"id":220845,"goal":"function Sum_830(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_830(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_831","instance":831,"id":220846,"goal":"method BinarySearch_831(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_832","instance":832,"id":220847,"goal":"method InsertSort_832(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_833","instance":833,"id":220848,"goal":"method MergeSort_833(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_834","instance":834,"id":220849,"goal":"method ArrayCopy_834(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_835","instance":835,"id":220850,"goal":"function ListReverse_835(s: seq): seq\n ensures |ListReverse_835(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_835(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_836","instance":836,"id":220851,"goal":"function Factorial_836(n: nat): nat\n ensures Factorial_836(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_836(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_837","instance":837,"id":220852,"goal":"function Fib_837(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_837(n-1) + Fib_837(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_838","instance":838,"id":220853,"goal":"function Gcd_838(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_838(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_839","instance":839,"id":220854,"goal":"function Power_839(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_839(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_840","instance":840,"id":220855,"goal":"function Sum_840(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_840(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_841","instance":841,"id":220856,"goal":"method BinarySearch_841(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_842","instance":842,"id":220857,"goal":"method InsertSort_842(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_843","instance":843,"id":220858,"goal":"method MergeSort_843(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_844","instance":844,"id":220859,"goal":"method ArrayCopy_844(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_845","instance":845,"id":220860,"goal":"function ListReverse_845(s: seq): seq\n ensures |ListReverse_845(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_845(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_846","instance":846,"id":220861,"goal":"function Factorial_846(n: nat): nat\n ensures Factorial_846(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_846(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_847","instance":847,"id":220862,"goal":"function Fib_847(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_847(n-1) + Fib_847(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_848","instance":848,"id":220863,"goal":"function Gcd_848(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_848(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_849","instance":849,"id":220864,"goal":"function Power_849(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_849(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_850","instance":850,"id":220865,"goal":"function Sum_850(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_850(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_851","instance":851,"id":220866,"goal":"method BinarySearch_851(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_852","instance":852,"id":220867,"goal":"method InsertSort_852(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_853","instance":853,"id":220868,"goal":"method MergeSort_853(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_854","instance":854,"id":220869,"goal":"method ArrayCopy_854(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_855","instance":855,"id":220870,"goal":"function ListReverse_855(s: seq): seq\n ensures |ListReverse_855(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_855(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_856","instance":856,"id":220871,"goal":"function Factorial_856(n: nat): nat\n ensures Factorial_856(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_856(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_857","instance":857,"id":220872,"goal":"function Fib_857(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_857(n-1) + Fib_857(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_858","instance":858,"id":220873,"goal":"function Gcd_858(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_858(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_859","instance":859,"id":220874,"goal":"function Power_859(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_859(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_860","instance":860,"id":220875,"goal":"function Sum_860(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_860(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_861","instance":861,"id":220876,"goal":"method BinarySearch_861(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_862","instance":862,"id":220877,"goal":"method InsertSort_862(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_863","instance":863,"id":220878,"goal":"method MergeSort_863(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_864","instance":864,"id":220879,"goal":"method ArrayCopy_864(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_865","instance":865,"id":220880,"goal":"function ListReverse_865(s: seq): seq\n ensures |ListReverse_865(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_865(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_866","instance":866,"id":220881,"goal":"function Factorial_866(n: nat): nat\n ensures Factorial_866(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_866(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_867","instance":867,"id":220882,"goal":"function Fib_867(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_867(n-1) + Fib_867(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_868","instance":868,"id":220883,"goal":"function Gcd_868(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_868(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_869","instance":869,"id":220884,"goal":"function Power_869(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_869(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_870","instance":870,"id":220885,"goal":"function Sum_870(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_870(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_871","instance":871,"id":220886,"goal":"method BinarySearch_871(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_872","instance":872,"id":220887,"goal":"method InsertSort_872(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_873","instance":873,"id":220888,"goal":"method MergeSort_873(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_874","instance":874,"id":220889,"goal":"method ArrayCopy_874(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_875","instance":875,"id":220890,"goal":"function ListReverse_875(s: seq): seq\n ensures |ListReverse_875(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_875(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_876","instance":876,"id":220891,"goal":"function Factorial_876(n: nat): nat\n ensures Factorial_876(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_876(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_877","instance":877,"id":220892,"goal":"function Fib_877(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_877(n-1) + Fib_877(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_878","instance":878,"id":220893,"goal":"function Gcd_878(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_878(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_879","instance":879,"id":220894,"goal":"function Power_879(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_879(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_880","instance":880,"id":220895,"goal":"function Sum_880(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_880(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_881","instance":881,"id":220896,"goal":"method BinarySearch_881(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_882","instance":882,"id":220897,"goal":"method InsertSort_882(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_883","instance":883,"id":220898,"goal":"method MergeSort_883(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_884","instance":884,"id":220899,"goal":"method ArrayCopy_884(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_885","instance":885,"id":220900,"goal":"function ListReverse_885(s: seq): seq\n ensures |ListReverse_885(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_885(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_886","instance":886,"id":220901,"goal":"function Factorial_886(n: nat): nat\n ensures Factorial_886(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_886(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_887","instance":887,"id":220902,"goal":"function Fib_887(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_887(n-1) + Fib_887(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_888","instance":888,"id":220903,"goal":"function Gcd_888(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_888(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_889","instance":889,"id":220904,"goal":"function Power_889(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_889(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_890","instance":890,"id":220905,"goal":"function Sum_890(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_890(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_891","instance":891,"id":220906,"goal":"method BinarySearch_891(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_892","instance":892,"id":220907,"goal":"method InsertSort_892(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_893","instance":893,"id":220908,"goal":"method MergeSort_893(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_894","instance":894,"id":220909,"goal":"method ArrayCopy_894(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_895","instance":895,"id":220910,"goal":"function ListReverse_895(s: seq): seq\n ensures |ListReverse_895(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_895(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_896","instance":896,"id":220911,"goal":"function Factorial_896(n: nat): nat\n ensures Factorial_896(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_896(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_897","instance":897,"id":220912,"goal":"function Fib_897(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_897(n-1) + Fib_897(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_898","instance":898,"id":220913,"goal":"function Gcd_898(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_898(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_899","instance":899,"id":220914,"goal":"function Power_899(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_899(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_900","instance":900,"id":220915,"goal":"function Sum_900(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_900(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_901","instance":901,"id":220916,"goal":"method BinarySearch_901(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_902","instance":902,"id":220917,"goal":"method InsertSort_902(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_903","instance":903,"id":220918,"goal":"method MergeSort_903(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_904","instance":904,"id":220919,"goal":"method ArrayCopy_904(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_905","instance":905,"id":220920,"goal":"function ListReverse_905(s: seq): seq\n ensures |ListReverse_905(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_905(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_906","instance":906,"id":220921,"goal":"function Factorial_906(n: nat): nat\n ensures Factorial_906(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_906(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_907","instance":907,"id":220922,"goal":"function Fib_907(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_907(n-1) + Fib_907(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_908","instance":908,"id":220923,"goal":"function Gcd_908(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_908(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_909","instance":909,"id":220924,"goal":"function Power_909(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_909(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_910","instance":910,"id":220925,"goal":"function Sum_910(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_910(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_911","instance":911,"id":220926,"goal":"method BinarySearch_911(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_912","instance":912,"id":220927,"goal":"method InsertSort_912(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_913","instance":913,"id":220928,"goal":"method MergeSort_913(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_914","instance":914,"id":220929,"goal":"method ArrayCopy_914(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_915","instance":915,"id":220930,"goal":"function ListReverse_915(s: seq): seq\n ensures |ListReverse_915(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_915(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_916","instance":916,"id":220931,"goal":"function Factorial_916(n: nat): nat\n ensures Factorial_916(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_916(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_917","instance":917,"id":220932,"goal":"function Fib_917(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_917(n-1) + Fib_917(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_918","instance":918,"id":220933,"goal":"function Gcd_918(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_918(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_919","instance":919,"id":220934,"goal":"function Power_919(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_919(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_920","instance":920,"id":220935,"goal":"function Sum_920(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_920(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_921","instance":921,"id":220936,"goal":"method BinarySearch_921(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_922","instance":922,"id":220937,"goal":"method InsertSort_922(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_923","instance":923,"id":220938,"goal":"method MergeSort_923(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_924","instance":924,"id":220939,"goal":"method ArrayCopy_924(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_925","instance":925,"id":220940,"goal":"function ListReverse_925(s: seq): seq\n ensures |ListReverse_925(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_925(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_926","instance":926,"id":220941,"goal":"function Factorial_926(n: nat): nat\n ensures Factorial_926(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_926(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_927","instance":927,"id":220942,"goal":"function Fib_927(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_927(n-1) + Fib_927(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_928","instance":928,"id":220943,"goal":"function Gcd_928(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_928(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_929","instance":929,"id":220944,"goal":"function Power_929(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_929(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_930","instance":930,"id":220945,"goal":"function Sum_930(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_930(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_931","instance":931,"id":220946,"goal":"method BinarySearch_931(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_932","instance":932,"id":220947,"goal":"method InsertSort_932(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_933","instance":933,"id":220948,"goal":"method MergeSort_933(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_934","instance":934,"id":220949,"goal":"method ArrayCopy_934(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_935","instance":935,"id":220950,"goal":"function ListReverse_935(s: seq): seq\n ensures |ListReverse_935(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_935(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_936","instance":936,"id":220951,"goal":"function Factorial_936(n: nat): nat\n ensures Factorial_936(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_936(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_937","instance":937,"id":220952,"goal":"function Fib_937(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_937(n-1) + Fib_937(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_938","instance":938,"id":220953,"goal":"function Gcd_938(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_938(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_939","instance":939,"id":220954,"goal":"function Power_939(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_939(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_940","instance":940,"id":220955,"goal":"function Sum_940(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_940(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_941","instance":941,"id":220956,"goal":"method BinarySearch_941(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_942","instance":942,"id":220957,"goal":"method InsertSort_942(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_943","instance":943,"id":220958,"goal":"method MergeSort_943(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_944","instance":944,"id":220959,"goal":"method ArrayCopy_944(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_945","instance":945,"id":220960,"goal":"function ListReverse_945(s: seq): seq\n ensures |ListReverse_945(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_945(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_946","instance":946,"id":220961,"goal":"function Factorial_946(n: nat): nat\n ensures Factorial_946(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_946(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_947","instance":947,"id":220962,"goal":"function Fib_947(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_947(n-1) + Fib_947(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_948","instance":948,"id":220963,"goal":"function Gcd_948(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_948(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_949","instance":949,"id":220964,"goal":"function Power_949(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_949(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_950","instance":950,"id":220965,"goal":"function Sum_950(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_950(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_951","instance":951,"id":220966,"goal":"method BinarySearch_951(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_952","instance":952,"id":220967,"goal":"method InsertSort_952(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_953","instance":953,"id":220968,"goal":"method MergeSort_953(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_954","instance":954,"id":220969,"goal":"method ArrayCopy_954(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_955","instance":955,"id":220970,"goal":"function ListReverse_955(s: seq): seq\n ensures |ListReverse_955(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_955(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_956","instance":956,"id":220971,"goal":"function Factorial_956(n: nat): nat\n ensures Factorial_956(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_956(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_957","instance":957,"id":220972,"goal":"function Fib_957(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_957(n-1) + Fib_957(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_958","instance":958,"id":220973,"goal":"function Gcd_958(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_958(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_959","instance":959,"id":220974,"goal":"function Power_959(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_959(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_960","instance":960,"id":220975,"goal":"function Sum_960(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_960(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_961","instance":961,"id":220976,"goal":"method BinarySearch_961(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_962","instance":962,"id":220977,"goal":"method InsertSort_962(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_963","instance":963,"id":220978,"goal":"method MergeSort_963(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_964","instance":964,"id":220979,"goal":"method ArrayCopy_964(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_965","instance":965,"id":220980,"goal":"function ListReverse_965(s: seq): seq\n ensures |ListReverse_965(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_965(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_966","instance":966,"id":220981,"goal":"function Factorial_966(n: nat): nat\n ensures Factorial_966(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_966(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_967","instance":967,"id":220982,"goal":"function Fib_967(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_967(n-1) + Fib_967(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_968","instance":968,"id":220983,"goal":"function Gcd_968(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_968(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_969","instance":969,"id":220984,"goal":"function Power_969(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_969(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_970","instance":970,"id":220985,"goal":"function Sum_970(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_970(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_971","instance":971,"id":220986,"goal":"method BinarySearch_971(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_972","instance":972,"id":220987,"goal":"method InsertSort_972(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_973","instance":973,"id":220988,"goal":"method MergeSort_973(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_974","instance":974,"id":220989,"goal":"method ArrayCopy_974(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_975","instance":975,"id":220990,"goal":"function ListReverse_975(s: seq): seq\n ensures |ListReverse_975(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_975(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_976","instance":976,"id":220991,"goal":"function Factorial_976(n: nat): nat\n ensures Factorial_976(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_976(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_977","instance":977,"id":220992,"goal":"function Fib_977(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_977(n-1) + Fib_977(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_978","instance":978,"id":220993,"goal":"function Gcd_978(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_978(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_979","instance":979,"id":220994,"goal":"function Power_979(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_979(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_980","instance":980,"id":220995,"goal":"function Sum_980(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_980(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_981","instance":981,"id":220996,"goal":"method BinarySearch_981(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_982","instance":982,"id":220997,"goal":"method InsertSort_982(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_983","instance":983,"id":220998,"goal":"method MergeSort_983(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_984","instance":984,"id":220999,"goal":"method ArrayCopy_984(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_985","instance":985,"id":221000,"goal":"function ListReverse_985(s: seq): seq\n ensures |ListReverse_985(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_985(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_986","instance":986,"id":221001,"goal":"function Factorial_986(n: nat): nat\n ensures Factorial_986(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_986(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_987","instance":987,"id":221002,"goal":"function Fib_987(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_987(n-1) + Fib_987(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_988","instance":988,"id":221003,"goal":"function Gcd_988(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_988(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_989","instance":989,"id":221004,"goal":"function Power_989(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_989(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_990","instance":990,"id":221005,"goal":"function Sum_990(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_990(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_991","instance":991,"id":221006,"goal":"method BinarySearch_991(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_992","instance":992,"id":221007,"goal":"method InsertSort_992(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_993","instance":993,"id":221008,"goal":"method MergeSort_993(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_994","instance":994,"id":221009,"goal":"method ArrayCopy_994(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_995","instance":995,"id":221010,"goal":"function ListReverse_995(s: seq): seq\n ensures |ListReverse_995(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_995(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_996","instance":996,"id":221011,"goal":"function Factorial_996(n: nat): nat\n ensures Factorial_996(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_996(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_997","instance":997,"id":221012,"goal":"function Fib_997(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_997(n-1) + Fib_997(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_998","instance":998,"id":221013,"goal":"function Gcd_998(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_998(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_999","instance":999,"id":221014,"goal":"function Power_999(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_999(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_1000","instance":1000,"id":221015,"goal":"function Sum_1000(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_1000(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_1001","instance":1001,"id":221016,"goal":"method BinarySearch_1001(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_1002","instance":1002,"id":221017,"goal":"method InsertSort_1002(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_1003","instance":1003,"id":221018,"goal":"method MergeSort_1003(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_1004","instance":1004,"id":221019,"goal":"method ArrayCopy_1004(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_1005","instance":1005,"id":221020,"goal":"function ListReverse_1005(s: seq): seq\n ensures |ListReverse_1005(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_1005(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_1006","instance":1006,"id":221021,"goal":"function Factorial_1006(n: nat): nat\n ensures Factorial_1006(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_1006(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_1007","instance":1007,"id":221022,"goal":"function Fib_1007(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_1007(n-1) + Fib_1007(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_1008","instance":1008,"id":221023,"goal":"function Gcd_1008(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_1008(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_1009","instance":1009,"id":221024,"goal":"function Power_1009(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_1009(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_1010","instance":1010,"id":221025,"goal":"function Sum_1010(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_1010(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_1011","instance":1011,"id":221026,"goal":"method BinarySearch_1011(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_1012","instance":1012,"id":221027,"goal":"method InsertSort_1012(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_1013","instance":1013,"id":221028,"goal":"method MergeSort_1013(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_1014","instance":1014,"id":221029,"goal":"method ArrayCopy_1014(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_1015","instance":1015,"id":221030,"goal":"function ListReverse_1015(s: seq): seq\n ensures |ListReverse_1015(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_1015(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_1016","instance":1016,"id":221031,"goal":"function Factorial_1016(n: nat): nat\n ensures Factorial_1016(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_1016(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_1017","instance":1017,"id":221032,"goal":"function Fib_1017(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_1017(n-1) + Fib_1017(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_1018","instance":1018,"id":221033,"goal":"function Gcd_1018(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_1018(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_1019","instance":1019,"id":221034,"goal":"function Power_1019(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_1019(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_1020","instance":1020,"id":221035,"goal":"function Sum_1020(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_1020(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_1021","instance":1021,"id":221036,"goal":"method BinarySearch_1021(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_1022","instance":1022,"id":221037,"goal":"method InsertSort_1022(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_1023","instance":1023,"id":221038,"goal":"method MergeSort_1023(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_1024","instance":1024,"id":221039,"goal":"method ArrayCopy_1024(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_1025","instance":1025,"id":221040,"goal":"function ListReverse_1025(s: seq): seq\n ensures |ListReverse_1025(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_1025(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_1026","instance":1026,"id":221041,"goal":"function Factorial_1026(n: nat): nat\n ensures Factorial_1026(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_1026(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_1027","instance":1027,"id":221042,"goal":"function Fib_1027(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_1027(n-1) + Fib_1027(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_1028","instance":1028,"id":221043,"goal":"function Gcd_1028(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_1028(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_1029","instance":1029,"id":221044,"goal":"function Power_1029(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_1029(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_1030","instance":1030,"id":221045,"goal":"function Sum_1030(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_1030(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_1031","instance":1031,"id":221046,"goal":"method BinarySearch_1031(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_1032","instance":1032,"id":221047,"goal":"method InsertSort_1032(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_1033","instance":1033,"id":221048,"goal":"method MergeSort_1033(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_1034","instance":1034,"id":221049,"goal":"method ArrayCopy_1034(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_1035","instance":1035,"id":221050,"goal":"function ListReverse_1035(s: seq): seq\n ensures |ListReverse_1035(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_1035(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_1036","instance":1036,"id":221051,"goal":"function Factorial_1036(n: nat): nat\n ensures Factorial_1036(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_1036(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_1037","instance":1037,"id":221052,"goal":"function Fib_1037(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_1037(n-1) + Fib_1037(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_1038","instance":1038,"id":221053,"goal":"function Gcd_1038(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_1038(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_1039","instance":1039,"id":221054,"goal":"function Power_1039(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_1039(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_1040","instance":1040,"id":221055,"goal":"function Sum_1040(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_1040(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_1041","instance":1041,"id":221056,"goal":"method BinarySearch_1041(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_1042","instance":1042,"id":221057,"goal":"method InsertSort_1042(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_1043","instance":1043,"id":221058,"goal":"method MergeSort_1043(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_1044","instance":1044,"id":221059,"goal":"method ArrayCopy_1044(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_1045","instance":1045,"id":221060,"goal":"function ListReverse_1045(s: seq): seq\n ensures |ListReverse_1045(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_1045(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_1046","instance":1046,"id":221061,"goal":"function Factorial_1046(n: nat): nat\n ensures Factorial_1046(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_1046(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_1047","instance":1047,"id":221062,"goal":"function Fib_1047(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_1047(n-1) + Fib_1047(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_1048","instance":1048,"id":221063,"goal":"function Gcd_1048(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_1048(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_1049","instance":1049,"id":221064,"goal":"function Power_1049(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_1049(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_1050","instance":1050,"id":221065,"goal":"function Sum_1050(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_1050(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_1051","instance":1051,"id":221066,"goal":"method BinarySearch_1051(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_1052","instance":1052,"id":221067,"goal":"method InsertSort_1052(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_1053","instance":1053,"id":221068,"goal":"method MergeSort_1053(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_1054","instance":1054,"id":221069,"goal":"method ArrayCopy_1054(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_1055","instance":1055,"id":221070,"goal":"function ListReverse_1055(s: seq): seq\n ensures |ListReverse_1055(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_1055(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_1056","instance":1056,"id":221071,"goal":"function Factorial_1056(n: nat): nat\n ensures Factorial_1056(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_1056(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_1057","instance":1057,"id":221072,"goal":"function Fib_1057(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_1057(n-1) + Fib_1057(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_1058","instance":1058,"id":221073,"goal":"function Gcd_1058(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_1058(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_1059","instance":1059,"id":221074,"goal":"function Power_1059(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_1059(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_1060","instance":1060,"id":221075,"goal":"function Sum_1060(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_1060(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_1061","instance":1061,"id":221076,"goal":"method BinarySearch_1061(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_1062","instance":1062,"id":221077,"goal":"method InsertSort_1062(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_1063","instance":1063,"id":221078,"goal":"method MergeSort_1063(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_1064","instance":1064,"id":221079,"goal":"method ArrayCopy_1064(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_1065","instance":1065,"id":221080,"goal":"function ListReverse_1065(s: seq): seq\n ensures |ListReverse_1065(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_1065(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_1066","instance":1066,"id":221081,"goal":"function Factorial_1066(n: nat): nat\n ensures Factorial_1066(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_1066(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_1067","instance":1067,"id":221082,"goal":"function Fib_1067(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_1067(n-1) + Fib_1067(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_1068","instance":1068,"id":221083,"goal":"function Gcd_1068(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_1068(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_1069","instance":1069,"id":221084,"goal":"function Power_1069(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_1069(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_1070","instance":1070,"id":221085,"goal":"function Sum_1070(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_1070(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_1071","instance":1071,"id":221086,"goal":"method BinarySearch_1071(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_1072","instance":1072,"id":221087,"goal":"method InsertSort_1072(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_1073","instance":1073,"id":221088,"goal":"method MergeSort_1073(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_1074","instance":1074,"id":221089,"goal":"method ArrayCopy_1074(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_1075","instance":1075,"id":221090,"goal":"function ListReverse_1075(s: seq): seq\n ensures |ListReverse_1075(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_1075(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_1076","instance":1076,"id":221091,"goal":"function Factorial_1076(n: nat): nat\n ensures Factorial_1076(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_1076(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_1077","instance":1077,"id":221092,"goal":"function Fib_1077(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_1077(n-1) + Fib_1077(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_1078","instance":1078,"id":221093,"goal":"function Gcd_1078(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_1078(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_1079","instance":1079,"id":221094,"goal":"function Power_1079(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_1079(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_1080","instance":1080,"id":221095,"goal":"function Sum_1080(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_1080(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_1081","instance":1081,"id":221096,"goal":"method BinarySearch_1081(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_1082","instance":1082,"id":221097,"goal":"method InsertSort_1082(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_1083","instance":1083,"id":221098,"goal":"method MergeSort_1083(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_1084","instance":1084,"id":221099,"goal":"method ArrayCopy_1084(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_1085","instance":1085,"id":221100,"goal":"function ListReverse_1085(s: seq): seq\n ensures |ListReverse_1085(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_1085(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_1086","instance":1086,"id":221101,"goal":"function Factorial_1086(n: nat): nat\n ensures Factorial_1086(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_1086(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_1087","instance":1087,"id":221102,"goal":"function Fib_1087(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_1087(n-1) + Fib_1087(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_1088","instance":1088,"id":221103,"goal":"function Gcd_1088(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_1088(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_1089","instance":1089,"id":221104,"goal":"function Power_1089(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_1089(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_1090","instance":1090,"id":221105,"goal":"function Sum_1090(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_1090(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_1091","instance":1091,"id":221106,"goal":"method BinarySearch_1091(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_1092","instance":1092,"id":221107,"goal":"method InsertSort_1092(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_1093","instance":1093,"id":221108,"goal":"method MergeSort_1093(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_1094","instance":1094,"id":221109,"goal":"method ArrayCopy_1094(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_1095","instance":1095,"id":221110,"goal":"function ListReverse_1095(s: seq): seq\n ensures |ListReverse_1095(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_1095(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_1096","instance":1096,"id":221111,"goal":"function Factorial_1096(n: nat): nat\n ensures Factorial_1096(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_1096(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_1097","instance":1097,"id":221112,"goal":"function Fib_1097(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_1097(n-1) + Fib_1097(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_1098","instance":1098,"id":221113,"goal":"function Gcd_1098(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_1098(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_1099","instance":1099,"id":221114,"goal":"function Power_1099(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_1099(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_1100","instance":1100,"id":221115,"goal":"function Sum_1100(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_1100(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_1101","instance":1101,"id":221116,"goal":"method BinarySearch_1101(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_1102","instance":1102,"id":221117,"goal":"method InsertSort_1102(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_1103","instance":1103,"id":221118,"goal":"method MergeSort_1103(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_1104","instance":1104,"id":221119,"goal":"method ArrayCopy_1104(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_1105","instance":1105,"id":221120,"goal":"function ListReverse_1105(s: seq): seq\n ensures |ListReverse_1105(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_1105(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_1106","instance":1106,"id":221121,"goal":"function Factorial_1106(n: nat): nat\n ensures Factorial_1106(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_1106(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_1107","instance":1107,"id":221122,"goal":"function Fib_1107(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_1107(n-1) + Fib_1107(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_1108","instance":1108,"id":221123,"goal":"function Gcd_1108(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_1108(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_1109","instance":1109,"id":221124,"goal":"function Power_1109(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_1109(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_1110","instance":1110,"id":221125,"goal":"function Sum_1110(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_1110(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_1111","instance":1111,"id":221126,"goal":"method BinarySearch_1111(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_1112","instance":1112,"id":221127,"goal":"method InsertSort_1112(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_1113","instance":1113,"id":221128,"goal":"method MergeSort_1113(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_1114","instance":1114,"id":221129,"goal":"method ArrayCopy_1114(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_1115","instance":1115,"id":221130,"goal":"function ListReverse_1115(s: seq): seq\n ensures |ListReverse_1115(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_1115(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_1116","instance":1116,"id":221131,"goal":"function Factorial_1116(n: nat): nat\n ensures Factorial_1116(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_1116(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_1117","instance":1117,"id":221132,"goal":"function Fib_1117(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_1117(n-1) + Fib_1117(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_1118","instance":1118,"id":221133,"goal":"function Gcd_1118(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_1118(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_1119","instance":1119,"id":221134,"goal":"function Power_1119(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_1119(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_1120","instance":1120,"id":221135,"goal":"function Sum_1120(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_1120(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_1121","instance":1121,"id":221136,"goal":"method BinarySearch_1121(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_1122","instance":1122,"id":221137,"goal":"method InsertSort_1122(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_1123","instance":1123,"id":221138,"goal":"method MergeSort_1123(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_1124","instance":1124,"id":221139,"goal":"method ArrayCopy_1124(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_1125","instance":1125,"id":221140,"goal":"function ListReverse_1125(s: seq): seq\n ensures |ListReverse_1125(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_1125(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_1126","instance":1126,"id":221141,"goal":"function Factorial_1126(n: nat): nat\n ensures Factorial_1126(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_1126(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_1127","instance":1127,"id":221142,"goal":"function Fib_1127(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_1127(n-1) + Fib_1127(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_1128","instance":1128,"id":221143,"goal":"function Gcd_1128(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_1128(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_1129","instance":1129,"id":221144,"goal":"function Power_1129(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_1129(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_1130","instance":1130,"id":221145,"goal":"function Sum_1130(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_1130(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_1131","instance":1131,"id":221146,"goal":"method BinarySearch_1131(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_1132","instance":1132,"id":221147,"goal":"method InsertSort_1132(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_1133","instance":1133,"id":221148,"goal":"method MergeSort_1133(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_1134","instance":1134,"id":221149,"goal":"method ArrayCopy_1134(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_1135","instance":1135,"id":221150,"goal":"function ListReverse_1135(s: seq): seq\n ensures |ListReverse_1135(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_1135(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_1136","instance":1136,"id":221151,"goal":"function Factorial_1136(n: nat): nat\n ensures Factorial_1136(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_1136(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_1137","instance":1137,"id":221152,"goal":"function Fib_1137(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_1137(n-1) + Fib_1137(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_1138","instance":1138,"id":221153,"goal":"function Gcd_1138(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_1138(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_1139","instance":1139,"id":221154,"goal":"function Power_1139(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_1139(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_1140","instance":1140,"id":221155,"goal":"function Sum_1140(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_1140(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_1141","instance":1141,"id":221156,"goal":"method BinarySearch_1141(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_1142","instance":1142,"id":221157,"goal":"method InsertSort_1142(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_1143","instance":1143,"id":221158,"goal":"method MergeSort_1143(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_1144","instance":1144,"id":221159,"goal":"method ArrayCopy_1144(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_1145","instance":1145,"id":221160,"goal":"function ListReverse_1145(s: seq): seq\n ensures |ListReverse_1145(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_1145(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_1146","instance":1146,"id":221161,"goal":"function Factorial_1146(n: nat): nat\n ensures Factorial_1146(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_1146(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_1147","instance":1147,"id":221162,"goal":"function Fib_1147(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_1147(n-1) + Fib_1147(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_1148","instance":1148,"id":221163,"goal":"function Gcd_1148(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_1148(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_1149","instance":1149,"id":221164,"goal":"function Power_1149(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_1149(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_1150","instance":1150,"id":221165,"goal":"function Sum_1150(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_1150(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_1151","instance":1151,"id":221166,"goal":"method BinarySearch_1151(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_1152","instance":1152,"id":221167,"goal":"method InsertSort_1152(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_1153","instance":1153,"id":221168,"goal":"method MergeSort_1153(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_1154","instance":1154,"id":221169,"goal":"method ArrayCopy_1154(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_1155","instance":1155,"id":221170,"goal":"function ListReverse_1155(s: seq): seq\n ensures |ListReverse_1155(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_1155(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_1156","instance":1156,"id":221171,"goal":"function Factorial_1156(n: nat): nat\n ensures Factorial_1156(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_1156(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_1157","instance":1157,"id":221172,"goal":"function Fib_1157(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_1157(n-1) + Fib_1157(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_1158","instance":1158,"id":221173,"goal":"function Gcd_1158(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_1158(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_1159","instance":1159,"id":221174,"goal":"function Power_1159(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_1159(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_1160","instance":1160,"id":221175,"goal":"function Sum_1160(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_1160(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_1161","instance":1161,"id":221176,"goal":"method BinarySearch_1161(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_1162","instance":1162,"id":221177,"goal":"method InsertSort_1162(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_1163","instance":1163,"id":221178,"goal":"method MergeSort_1163(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_1164","instance":1164,"id":221179,"goal":"method ArrayCopy_1164(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_1165","instance":1165,"id":221180,"goal":"function ListReverse_1165(s: seq): seq\n ensures |ListReverse_1165(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_1165(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_1166","instance":1166,"id":221181,"goal":"function Factorial_1166(n: nat): nat\n ensures Factorial_1166(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_1166(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_1167","instance":1167,"id":221182,"goal":"function Fib_1167(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_1167(n-1) + Fib_1167(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_1168","instance":1168,"id":221183,"goal":"function Gcd_1168(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_1168(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_1169","instance":1169,"id":221184,"goal":"function Power_1169(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_1169(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_1170","instance":1170,"id":221185,"goal":"function Sum_1170(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_1170(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_1171","instance":1171,"id":221186,"goal":"method BinarySearch_1171(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_1172","instance":1172,"id":221187,"goal":"method InsertSort_1172(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_1173","instance":1173,"id":221188,"goal":"method MergeSort_1173(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_1174","instance":1174,"id":221189,"goal":"method ArrayCopy_1174(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_1175","instance":1175,"id":221190,"goal":"function ListReverse_1175(s: seq): seq\n ensures |ListReverse_1175(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_1175(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_1176","instance":1176,"id":221191,"goal":"function Factorial_1176(n: nat): nat\n ensures Factorial_1176(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_1176(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_1177","instance":1177,"id":221192,"goal":"function Fib_1177(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_1177(n-1) + Fib_1177(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_1178","instance":1178,"id":221193,"goal":"function Gcd_1178(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_1178(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_1179","instance":1179,"id":221194,"goal":"function Power_1179(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_1179(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_1180","instance":1180,"id":221195,"goal":"function Sum_1180(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_1180(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_1181","instance":1181,"id":221196,"goal":"method BinarySearch_1181(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_1182","instance":1182,"id":221197,"goal":"method InsertSort_1182(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_1183","instance":1183,"id":221198,"goal":"method MergeSort_1183(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_1184","instance":1184,"id":221199,"goal":"method ArrayCopy_1184(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_1185","instance":1185,"id":221200,"goal":"function ListReverse_1185(s: seq): seq\n ensures |ListReverse_1185(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_1185(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_1186","instance":1186,"id":221201,"goal":"function Factorial_1186(n: nat): nat\n ensures Factorial_1186(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_1186(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_1187","instance":1187,"id":221202,"goal":"function Fib_1187(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_1187(n-1) + Fib_1187(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_1188","instance":1188,"id":221203,"goal":"function Gcd_1188(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_1188(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_1189","instance":1189,"id":221204,"goal":"function Power_1189(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_1189(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_1190","instance":1190,"id":221205,"goal":"function Sum_1190(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_1190(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_1191","instance":1191,"id":221206,"goal":"method BinarySearch_1191(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_1192","instance":1192,"id":221207,"goal":"method InsertSort_1192(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_1193","instance":1193,"id":221208,"goal":"method MergeSort_1193(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_1194","instance":1194,"id":221209,"goal":"method ArrayCopy_1194(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_1195","instance":1195,"id":221210,"goal":"function ListReverse_1195(s: seq): seq\n ensures |ListReverse_1195(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_1195(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_1196","instance":1196,"id":221211,"goal":"function Factorial_1196(n: nat): nat\n ensures Factorial_1196(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_1196(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_1197","instance":1197,"id":221212,"goal":"function Fib_1197(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_1197(n-1) + Fib_1197(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_1198","instance":1198,"id":221213,"goal":"function Gcd_1198(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_1198(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_1199","instance":1199,"id":221214,"goal":"function Power_1199(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_1199(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_1200","instance":1200,"id":221215,"goal":"function Sum_1200(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_1200(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_1201","instance":1201,"id":221216,"goal":"method BinarySearch_1201(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_1202","instance":1202,"id":221217,"goal":"method InsertSort_1202(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_1203","instance":1203,"id":221218,"goal":"method MergeSort_1203(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_1204","instance":1204,"id":221219,"goal":"method ArrayCopy_1204(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_1205","instance":1205,"id":221220,"goal":"function ListReverse_1205(s: seq): seq\n ensures |ListReverse_1205(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_1205(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_1206","instance":1206,"id":221221,"goal":"function Factorial_1206(n: nat): nat\n ensures Factorial_1206(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_1206(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_1207","instance":1207,"id":221222,"goal":"function Fib_1207(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_1207(n-1) + Fib_1207(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_1208","instance":1208,"id":221223,"goal":"function Gcd_1208(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_1208(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_1209","instance":1209,"id":221224,"goal":"function Power_1209(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_1209(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_1210","instance":1210,"id":221225,"goal":"function Sum_1210(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_1210(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_1211","instance":1211,"id":221226,"goal":"method BinarySearch_1211(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_1212","instance":1212,"id":221227,"goal":"method InsertSort_1212(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_1213","instance":1213,"id":221228,"goal":"method MergeSort_1213(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_1214","instance":1214,"id":221229,"goal":"method ArrayCopy_1214(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_1215","instance":1215,"id":221230,"goal":"function ListReverse_1215(s: seq): seq\n ensures |ListReverse_1215(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_1215(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_1216","instance":1216,"id":221231,"goal":"function Factorial_1216(n: nat): nat\n ensures Factorial_1216(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_1216(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_1217","instance":1217,"id":221232,"goal":"function Fib_1217(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_1217(n-1) + Fib_1217(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_1218","instance":1218,"id":221233,"goal":"function Gcd_1218(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_1218(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_1219","instance":1219,"id":221234,"goal":"function Power_1219(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_1219(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_1220","instance":1220,"id":221235,"goal":"function Sum_1220(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_1220(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_1221","instance":1221,"id":221236,"goal":"method BinarySearch_1221(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_1222","instance":1222,"id":221237,"goal":"method InsertSort_1222(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_1223","instance":1223,"id":221238,"goal":"method MergeSort_1223(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_1224","instance":1224,"id":221239,"goal":"method ArrayCopy_1224(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_1225","instance":1225,"id":221240,"goal":"function ListReverse_1225(s: seq): seq\n ensures |ListReverse_1225(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_1225(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_1226","instance":1226,"id":221241,"goal":"function Factorial_1226(n: nat): nat\n ensures Factorial_1226(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_1226(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_1227","instance":1227,"id":221242,"goal":"function Fib_1227(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_1227(n-1) + Fib_1227(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_1228","instance":1228,"id":221243,"goal":"function Gcd_1228(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_1228(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_1229","instance":1229,"id":221244,"goal":"function Power_1229(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_1229(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_1230","instance":1230,"id":221245,"goal":"function Sum_1230(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_1230(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_1231","instance":1231,"id":221246,"goal":"method BinarySearch_1231(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_1232","instance":1232,"id":221247,"goal":"method InsertSort_1232(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_1233","instance":1233,"id":221248,"goal":"method MergeSort_1233(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_1234","instance":1234,"id":221249,"goal":"method ArrayCopy_1234(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_1235","instance":1235,"id":221250,"goal":"function ListReverse_1235(s: seq): seq\n ensures |ListReverse_1235(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_1235(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_1236","instance":1236,"id":221251,"goal":"function Factorial_1236(n: nat): nat\n ensures Factorial_1236(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_1236(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_1237","instance":1237,"id":221252,"goal":"function Fib_1237(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_1237(n-1) + Fib_1237(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_1238","instance":1238,"id":221253,"goal":"function Gcd_1238(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_1238(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_1239","instance":1239,"id":221254,"goal":"function Power_1239(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_1239(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_1240","instance":1240,"id":221255,"goal":"function Sum_1240(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_1240(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_1241","instance":1241,"id":221256,"goal":"method BinarySearch_1241(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_1242","instance":1242,"id":221257,"goal":"method InsertSort_1242(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_1243","instance":1243,"id":221258,"goal":"method MergeSort_1243(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_1244","instance":1244,"id":221259,"goal":"method ArrayCopy_1244(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_1245","instance":1245,"id":221260,"goal":"function ListReverse_1245(s: seq): seq\n ensures |ListReverse_1245(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_1245(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_1246","instance":1246,"id":221261,"goal":"function Factorial_1246(n: nat): nat\n ensures Factorial_1246(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_1246(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_1247","instance":1247,"id":221262,"goal":"function Fib_1247(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_1247(n-1) + Fib_1247(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_1248","instance":1248,"id":221263,"goal":"function Gcd_1248(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_1248(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_1249","instance":1249,"id":221264,"goal":"function Power_1249(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_1249(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_1250","instance":1250,"id":221265,"goal":"function Sum_1250(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_1250(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_1251","instance":1251,"id":221266,"goal":"method BinarySearch_1251(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_1252","instance":1252,"id":221267,"goal":"method InsertSort_1252(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_1253","instance":1253,"id":221268,"goal":"method MergeSort_1253(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_1254","instance":1254,"id":221269,"goal":"method ArrayCopy_1254(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_1255","instance":1255,"id":221270,"goal":"function ListReverse_1255(s: seq): seq\n ensures |ListReverse_1255(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_1255(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_1256","instance":1256,"id":221271,"goal":"function Factorial_1256(n: nat): nat\n ensures Factorial_1256(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_1256(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_1257","instance":1257,"id":221272,"goal":"function Fib_1257(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_1257(n-1) + Fib_1257(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_1258","instance":1258,"id":221273,"goal":"function Gcd_1258(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_1258(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_1259","instance":1259,"id":221274,"goal":"function Power_1259(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_1259(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_1260","instance":1260,"id":221275,"goal":"function Sum_1260(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_1260(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_1261","instance":1261,"id":221276,"goal":"method BinarySearch_1261(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_1262","instance":1262,"id":221277,"goal":"method InsertSort_1262(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_1263","instance":1263,"id":221278,"goal":"method MergeSort_1263(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_1264","instance":1264,"id":221279,"goal":"method ArrayCopy_1264(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_1265","instance":1265,"id":221280,"goal":"function ListReverse_1265(s: seq): seq\n ensures |ListReverse_1265(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_1265(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_1266","instance":1266,"id":221281,"goal":"function Factorial_1266(n: nat): nat\n ensures Factorial_1266(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_1266(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_1267","instance":1267,"id":221282,"goal":"function Fib_1267(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_1267(n-1) + Fib_1267(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_1268","instance":1268,"id":221283,"goal":"function Gcd_1268(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_1268(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_1269","instance":1269,"id":221284,"goal":"function Power_1269(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_1269(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_1270","instance":1270,"id":221285,"goal":"function Sum_1270(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_1270(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_1271","instance":1271,"id":221286,"goal":"method BinarySearch_1271(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_1272","instance":1272,"id":221287,"goal":"method InsertSort_1272(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_1273","instance":1273,"id":221288,"goal":"method MergeSort_1273(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_1274","instance":1274,"id":221289,"goal":"method ArrayCopy_1274(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_1275","instance":1275,"id":221290,"goal":"function ListReverse_1275(s: seq): seq\n ensures |ListReverse_1275(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_1275(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_1276","instance":1276,"id":221291,"goal":"function Factorial_1276(n: nat): nat\n ensures Factorial_1276(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_1276(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_1277","instance":1277,"id":221292,"goal":"function Fib_1277(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_1277(n-1) + Fib_1277(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_1278","instance":1278,"id":221293,"goal":"function Gcd_1278(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_1278(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_1279","instance":1279,"id":221294,"goal":"function Power_1279(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_1279(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_1280","instance":1280,"id":221295,"goal":"function Sum_1280(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_1280(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_1281","instance":1281,"id":221296,"goal":"method BinarySearch_1281(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_1282","instance":1282,"id":221297,"goal":"method InsertSort_1282(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_1283","instance":1283,"id":221298,"goal":"method MergeSort_1283(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_1284","instance":1284,"id":221299,"goal":"method ArrayCopy_1284(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_1285","instance":1285,"id":221300,"goal":"function ListReverse_1285(s: seq): seq\n ensures |ListReverse_1285(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_1285(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_1286","instance":1286,"id":221301,"goal":"function Factorial_1286(n: nat): nat\n ensures Factorial_1286(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_1286(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_1287","instance":1287,"id":221302,"goal":"function Fib_1287(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_1287(n-1) + Fib_1287(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_1288","instance":1288,"id":221303,"goal":"function Gcd_1288(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_1288(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_1289","instance":1289,"id":221304,"goal":"function Power_1289(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_1289(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_1290","instance":1290,"id":221305,"goal":"function Sum_1290(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_1290(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_1291","instance":1291,"id":221306,"goal":"method BinarySearch_1291(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_1292","instance":1292,"id":221307,"goal":"method InsertSort_1292(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_1293","instance":1293,"id":221308,"goal":"method MergeSort_1293(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_1294","instance":1294,"id":221309,"goal":"method ArrayCopy_1294(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_1295","instance":1295,"id":221310,"goal":"function ListReverse_1295(s: seq): seq\n ensures |ListReverse_1295(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_1295(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_1296","instance":1296,"id":221311,"goal":"function Factorial_1296(n: nat): nat\n ensures Factorial_1296(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_1296(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_1297","instance":1297,"id":221312,"goal":"function Fib_1297(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_1297(n-1) + Fib_1297(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_1298","instance":1298,"id":221313,"goal":"function Gcd_1298(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_1298(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_1299","instance":1299,"id":221314,"goal":"function Power_1299(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_1299(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_1300","instance":1300,"id":221315,"goal":"function Sum_1300(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_1300(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_1301","instance":1301,"id":221316,"goal":"method BinarySearch_1301(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_1302","instance":1302,"id":221317,"goal":"method InsertSort_1302(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_1303","instance":1303,"id":221318,"goal":"method MergeSort_1303(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_1304","instance":1304,"id":221319,"goal":"method ArrayCopy_1304(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_1305","instance":1305,"id":221320,"goal":"function ListReverse_1305(s: seq): seq\n ensures |ListReverse_1305(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_1305(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_1306","instance":1306,"id":221321,"goal":"function Factorial_1306(n: nat): nat\n ensures Factorial_1306(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_1306(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_1307","instance":1307,"id":221322,"goal":"function Fib_1307(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_1307(n-1) + Fib_1307(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_1308","instance":1308,"id":221323,"goal":"function Gcd_1308(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_1308(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_1309","instance":1309,"id":221324,"goal":"function Power_1309(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_1309(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_1310","instance":1310,"id":221325,"goal":"function Sum_1310(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_1310(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_1311","instance":1311,"id":221326,"goal":"method BinarySearch_1311(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_1312","instance":1312,"id":221327,"goal":"method InsertSort_1312(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_1313","instance":1313,"id":221328,"goal":"method MergeSort_1313(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_1314","instance":1314,"id":221329,"goal":"method ArrayCopy_1314(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_1315","instance":1315,"id":221330,"goal":"function ListReverse_1315(s: seq): seq\n ensures |ListReverse_1315(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_1315(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_1316","instance":1316,"id":221331,"goal":"function Factorial_1316(n: nat): nat\n ensures Factorial_1316(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_1316(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_1317","instance":1317,"id":221332,"goal":"function Fib_1317(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_1317(n-1) + Fib_1317(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_1318","instance":1318,"id":221333,"goal":"function Gcd_1318(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_1318(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_1319","instance":1319,"id":221334,"goal":"function Power_1319(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_1319(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_1320","instance":1320,"id":221335,"goal":"function Sum_1320(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_1320(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_1321","instance":1321,"id":221336,"goal":"method BinarySearch_1321(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_1322","instance":1322,"id":221337,"goal":"method InsertSort_1322(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_1323","instance":1323,"id":221338,"goal":"method MergeSort_1323(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_1324","instance":1324,"id":221339,"goal":"method ArrayCopy_1324(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_1325","instance":1325,"id":221340,"goal":"function ListReverse_1325(s: seq): seq\n ensures |ListReverse_1325(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_1325(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_1326","instance":1326,"id":221341,"goal":"function Factorial_1326(n: nat): nat\n ensures Factorial_1326(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_1326(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_1327","instance":1327,"id":221342,"goal":"function Fib_1327(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_1327(n-1) + Fib_1327(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_1328","instance":1328,"id":221343,"goal":"function Gcd_1328(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_1328(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_1329","instance":1329,"id":221344,"goal":"function Power_1329(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_1329(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_1330","instance":1330,"id":221345,"goal":"function Sum_1330(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_1330(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_1331","instance":1331,"id":221346,"goal":"method BinarySearch_1331(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_1332","instance":1332,"id":221347,"goal":"method InsertSort_1332(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_1333","instance":1333,"id":221348,"goal":"method MergeSort_1333(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_1334","instance":1334,"id":221349,"goal":"method ArrayCopy_1334(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_1335","instance":1335,"id":221350,"goal":"function ListReverse_1335(s: seq): seq\n ensures |ListReverse_1335(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_1335(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_1336","instance":1336,"id":221351,"goal":"function Factorial_1336(n: nat): nat\n ensures Factorial_1336(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_1336(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_1337","instance":1337,"id":221352,"goal":"function Fib_1337(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_1337(n-1) + Fib_1337(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_1338","instance":1338,"id":221353,"goal":"function Gcd_1338(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_1338(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_1339","instance":1339,"id":221354,"goal":"function Power_1339(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_1339(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_1340","instance":1340,"id":221355,"goal":"function Sum_1340(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_1340(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_1341","instance":1341,"id":221356,"goal":"method BinarySearch_1341(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_1342","instance":1342,"id":221357,"goal":"method InsertSort_1342(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_1343","instance":1343,"id":221358,"goal":"method MergeSort_1343(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_1344","instance":1344,"id":221359,"goal":"method ArrayCopy_1344(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_1345","instance":1345,"id":221360,"goal":"function ListReverse_1345(s: seq): seq\n ensures |ListReverse_1345(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_1345(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_1346","instance":1346,"id":221361,"goal":"function Factorial_1346(n: nat): nat\n ensures Factorial_1346(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_1346(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_1347","instance":1347,"id":221362,"goal":"function Fib_1347(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_1347(n-1) + Fib_1347(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_1348","instance":1348,"id":221363,"goal":"function Gcd_1348(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_1348(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_1349","instance":1349,"id":221364,"goal":"function Power_1349(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_1349(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_1350","instance":1350,"id":221365,"goal":"function Sum_1350(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_1350(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_1351","instance":1351,"id":221366,"goal":"method BinarySearch_1351(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_1352","instance":1352,"id":221367,"goal":"method InsertSort_1352(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_1353","instance":1353,"id":221368,"goal":"method MergeSort_1353(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_1354","instance":1354,"id":221369,"goal":"method ArrayCopy_1354(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_1355","instance":1355,"id":221370,"goal":"function ListReverse_1355(s: seq): seq\n ensures |ListReverse_1355(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_1355(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_1356","instance":1356,"id":221371,"goal":"function Factorial_1356(n: nat): nat\n ensures Factorial_1356(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_1356(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_1357","instance":1357,"id":221372,"goal":"function Fib_1357(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_1357(n-1) + Fib_1357(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_1358","instance":1358,"id":221373,"goal":"function Gcd_1358(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_1358(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_1359","instance":1359,"id":221374,"goal":"function Power_1359(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_1359(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_1360","instance":1360,"id":221375,"goal":"function Sum_1360(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_1360(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_1361","instance":1361,"id":221376,"goal":"method BinarySearch_1361(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_1362","instance":1362,"id":221377,"goal":"method InsertSort_1362(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_1363","instance":1363,"id":221378,"goal":"method MergeSort_1363(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_1364","instance":1364,"id":221379,"goal":"method ArrayCopy_1364(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_1365","instance":1365,"id":221380,"goal":"function ListReverse_1365(s: seq): seq\n ensures |ListReverse_1365(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_1365(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_1366","instance":1366,"id":221381,"goal":"function Factorial_1366(n: nat): nat\n ensures Factorial_1366(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_1366(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_1367","instance":1367,"id":221382,"goal":"function Fib_1367(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_1367(n-1) + Fib_1367(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_1368","instance":1368,"id":221383,"goal":"function Gcd_1368(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_1368(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_1369","instance":1369,"id":221384,"goal":"function Power_1369(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_1369(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_1370","instance":1370,"id":221385,"goal":"function Sum_1370(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_1370(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_1371","instance":1371,"id":221386,"goal":"method BinarySearch_1371(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_1372","instance":1372,"id":221387,"goal":"method InsertSort_1372(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_1373","instance":1373,"id":221388,"goal":"method MergeSort_1373(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_1374","instance":1374,"id":221389,"goal":"method ArrayCopy_1374(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_1375","instance":1375,"id":221390,"goal":"function ListReverse_1375(s: seq): seq\n ensures |ListReverse_1375(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_1375(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_1376","instance":1376,"id":221391,"goal":"function Factorial_1376(n: nat): nat\n ensures Factorial_1376(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_1376(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_1377","instance":1377,"id":221392,"goal":"function Fib_1377(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_1377(n-1) + Fib_1377(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_1378","instance":1378,"id":221393,"goal":"function Gcd_1378(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_1378(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_1379","instance":1379,"id":221394,"goal":"function Power_1379(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_1379(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_1380","instance":1380,"id":221395,"goal":"function Sum_1380(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_1380(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_1381","instance":1381,"id":221396,"goal":"method BinarySearch_1381(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_1382","instance":1382,"id":221397,"goal":"method InsertSort_1382(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_1383","instance":1383,"id":221398,"goal":"method MergeSort_1383(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_1384","instance":1384,"id":221399,"goal":"method ArrayCopy_1384(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_1385","instance":1385,"id":221400,"goal":"function ListReverse_1385(s: seq): seq\n ensures |ListReverse_1385(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_1385(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_1386","instance":1386,"id":221401,"goal":"function Factorial_1386(n: nat): nat\n ensures Factorial_1386(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_1386(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_1387","instance":1387,"id":221402,"goal":"function Fib_1387(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_1387(n-1) + Fib_1387(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_1388","instance":1388,"id":221403,"goal":"function Gcd_1388(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_1388(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_1389","instance":1389,"id":221404,"goal":"function Power_1389(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_1389(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_1390","instance":1390,"id":221405,"goal":"function Sum_1390(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_1390(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_1391","instance":1391,"id":221406,"goal":"method BinarySearch_1391(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_1392","instance":1392,"id":221407,"goal":"method InsertSort_1392(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_1393","instance":1393,"id":221408,"goal":"method MergeSort_1393(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_1394","instance":1394,"id":221409,"goal":"method ArrayCopy_1394(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_1395","instance":1395,"id":221410,"goal":"function ListReverse_1395(s: seq): seq\n ensures |ListReverse_1395(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_1395(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_1396","instance":1396,"id":221411,"goal":"function Factorial_1396(n: nat): nat\n ensures Factorial_1396(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_1396(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_1397","instance":1397,"id":221412,"goal":"function Fib_1397(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_1397(n-1) + Fib_1397(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_1398","instance":1398,"id":221413,"goal":"function Gcd_1398(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_1398(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_1399","instance":1399,"id":221414,"goal":"function Power_1399(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_1399(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_1400","instance":1400,"id":221415,"goal":"function Sum_1400(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_1400(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_1401","instance":1401,"id":221416,"goal":"method BinarySearch_1401(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_1402","instance":1402,"id":221417,"goal":"method InsertSort_1402(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_1403","instance":1403,"id":221418,"goal":"method MergeSort_1403(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_1404","instance":1404,"id":221419,"goal":"method ArrayCopy_1404(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_1405","instance":1405,"id":221420,"goal":"function ListReverse_1405(s: seq): seq\n ensures |ListReverse_1405(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_1405(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_1406","instance":1406,"id":221421,"goal":"function Factorial_1406(n: nat): nat\n ensures Factorial_1406(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_1406(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_1407","instance":1407,"id":221422,"goal":"function Fib_1407(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_1407(n-1) + Fib_1407(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_1408","instance":1408,"id":221423,"goal":"function Gcd_1408(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_1408(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_1409","instance":1409,"id":221424,"goal":"function Power_1409(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_1409(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_1410","instance":1410,"id":221425,"goal":"function Sum_1410(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_1410(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_1411","instance":1411,"id":221426,"goal":"method BinarySearch_1411(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_1412","instance":1412,"id":221427,"goal":"method InsertSort_1412(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_1413","instance":1413,"id":221428,"goal":"method MergeSort_1413(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_1414","instance":1414,"id":221429,"goal":"method ArrayCopy_1414(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_1415","instance":1415,"id":221430,"goal":"function ListReverse_1415(s: seq): seq\n ensures |ListReverse_1415(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_1415(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_1416","instance":1416,"id":221431,"goal":"function Factorial_1416(n: nat): nat\n ensures Factorial_1416(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_1416(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_1417","instance":1417,"id":221432,"goal":"function Fib_1417(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_1417(n-1) + Fib_1417(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_1418","instance":1418,"id":221433,"goal":"function Gcd_1418(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_1418(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_1419","instance":1419,"id":221434,"goal":"function Power_1419(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_1419(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_1420","instance":1420,"id":221435,"goal":"function Sum_1420(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_1420(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_1421","instance":1421,"id":221436,"goal":"method BinarySearch_1421(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_1422","instance":1422,"id":221437,"goal":"method InsertSort_1422(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_1423","instance":1423,"id":221438,"goal":"method MergeSort_1423(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_1424","instance":1424,"id":221439,"goal":"method ArrayCopy_1424(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_1425","instance":1425,"id":221440,"goal":"function ListReverse_1425(s: seq): seq\n ensures |ListReverse_1425(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_1425(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_1426","instance":1426,"id":221441,"goal":"function Factorial_1426(n: nat): nat\n ensures Factorial_1426(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_1426(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_1427","instance":1427,"id":221442,"goal":"function Fib_1427(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_1427(n-1) + Fib_1427(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_1428","instance":1428,"id":221443,"goal":"function Gcd_1428(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_1428(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_1429","instance":1429,"id":221444,"goal":"function Power_1429(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_1429(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_1430","instance":1430,"id":221445,"goal":"function Sum_1430(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_1430(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_1431","instance":1431,"id":221446,"goal":"method BinarySearch_1431(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_1432","instance":1432,"id":221447,"goal":"method InsertSort_1432(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_1433","instance":1433,"id":221448,"goal":"method MergeSort_1433(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_1434","instance":1434,"id":221449,"goal":"method ArrayCopy_1434(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_1435","instance":1435,"id":221450,"goal":"function ListReverse_1435(s: seq): seq\n ensures |ListReverse_1435(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_1435(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_1436","instance":1436,"id":221451,"goal":"function Factorial_1436(n: nat): nat\n ensures Factorial_1436(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_1436(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_1437","instance":1437,"id":221452,"goal":"function Fib_1437(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_1437(n-1) + Fib_1437(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_1438","instance":1438,"id":221453,"goal":"function Gcd_1438(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_1438(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_1439","instance":1439,"id":221454,"goal":"function Power_1439(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_1439(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_1440","instance":1440,"id":221455,"goal":"function Sum_1440(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_1440(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_1441","instance":1441,"id":221456,"goal":"method BinarySearch_1441(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_1442","instance":1442,"id":221457,"goal":"method InsertSort_1442(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_1443","instance":1443,"id":221458,"goal":"method MergeSort_1443(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_1444","instance":1444,"id":221459,"goal":"method ArrayCopy_1444(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_1445","instance":1445,"id":221460,"goal":"function ListReverse_1445(s: seq): seq\n ensures |ListReverse_1445(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_1445(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_1446","instance":1446,"id":221461,"goal":"function Factorial_1446(n: nat): nat\n ensures Factorial_1446(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_1446(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_1447","instance":1447,"id":221462,"goal":"function Fib_1447(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_1447(n-1) + Fib_1447(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_1448","instance":1448,"id":221463,"goal":"function Gcd_1448(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_1448(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_1449","instance":1449,"id":221464,"goal":"function Power_1449(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_1449(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_1450","instance":1450,"id":221465,"goal":"function Sum_1450(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_1450(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_1451","instance":1451,"id":221466,"goal":"method BinarySearch_1451(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_1452","instance":1452,"id":221467,"goal":"method InsertSort_1452(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_1453","instance":1453,"id":221468,"goal":"method MergeSort_1453(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_1454","instance":1454,"id":221469,"goal":"method ArrayCopy_1454(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_1455","instance":1455,"id":221470,"goal":"function ListReverse_1455(s: seq): seq\n ensures |ListReverse_1455(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_1455(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_1456","instance":1456,"id":221471,"goal":"function Factorial_1456(n: nat): nat\n ensures Factorial_1456(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_1456(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_1457","instance":1457,"id":221472,"goal":"function Fib_1457(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_1457(n-1) + Fib_1457(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_1458","instance":1458,"id":221473,"goal":"function Gcd_1458(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_1458(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_1459","instance":1459,"id":221474,"goal":"function Power_1459(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_1459(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_1460","instance":1460,"id":221475,"goal":"function Sum_1460(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_1460(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_1461","instance":1461,"id":221476,"goal":"method BinarySearch_1461(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_1462","instance":1462,"id":221477,"goal":"method InsertSort_1462(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_1463","instance":1463,"id":221478,"goal":"method MergeSort_1463(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_1464","instance":1464,"id":221479,"goal":"method ArrayCopy_1464(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_1465","instance":1465,"id":221480,"goal":"function ListReverse_1465(s: seq): seq\n ensures |ListReverse_1465(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_1465(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_1466","instance":1466,"id":221481,"goal":"function Factorial_1466(n: nat): nat\n ensures Factorial_1466(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_1466(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_1467","instance":1467,"id":221482,"goal":"function Fib_1467(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_1467(n-1) + Fib_1467(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_1468","instance":1468,"id":221483,"goal":"function Gcd_1468(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_1468(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_1469","instance":1469,"id":221484,"goal":"function Power_1469(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_1469(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_1470","instance":1470,"id":221485,"goal":"function Sum_1470(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_1470(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_1471","instance":1471,"id":221486,"goal":"method BinarySearch_1471(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_1472","instance":1472,"id":221487,"goal":"method InsertSort_1472(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_1473","instance":1473,"id":221488,"goal":"method MergeSort_1473(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_1474","instance":1474,"id":221489,"goal":"method ArrayCopy_1474(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_1475","instance":1475,"id":221490,"goal":"function ListReverse_1475(s: seq): seq\n ensures |ListReverse_1475(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_1475(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_1476","instance":1476,"id":221491,"goal":"function Factorial_1476(n: nat): nat\n ensures Factorial_1476(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_1476(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_1477","instance":1477,"id":221492,"goal":"function Fib_1477(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_1477(n-1) + Fib_1477(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_1478","instance":1478,"id":221493,"goal":"function Gcd_1478(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_1478(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_1479","instance":1479,"id":221494,"goal":"function Power_1479(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_1479(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_1480","instance":1480,"id":221495,"goal":"function Sum_1480(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_1480(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_1481","instance":1481,"id":221496,"goal":"method BinarySearch_1481(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_1482","instance":1482,"id":221497,"goal":"method InsertSort_1482(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_1483","instance":1483,"id":221498,"goal":"method MergeSort_1483(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_1484","instance":1484,"id":221499,"goal":"method ArrayCopy_1484(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_1485","instance":1485,"id":221500,"goal":"function ListReverse_1485(s: seq): seq\n ensures |ListReverse_1485(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_1485(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_1486","instance":1486,"id":221501,"goal":"function Factorial_1486(n: nat): nat\n ensures Factorial_1486(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_1486(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_1487","instance":1487,"id":221502,"goal":"function Fib_1487(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_1487(n-1) + Fib_1487(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_1488","instance":1488,"id":221503,"goal":"function Gcd_1488(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_1488(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_1489","instance":1489,"id":221504,"goal":"function Power_1489(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_1489(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_1490","instance":1490,"id":221505,"goal":"function Sum_1490(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_1490(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_1491","instance":1491,"id":221506,"goal":"method BinarySearch_1491(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_1492","instance":1492,"id":221507,"goal":"method InsertSort_1492(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_1493","instance":1493,"id":221508,"goal":"method MergeSort_1493(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_1494","instance":1494,"id":221509,"goal":"method ArrayCopy_1494(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_1495","instance":1495,"id":221510,"goal":"function ListReverse_1495(s: seq): seq\n ensures |ListReverse_1495(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_1495(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_1496","instance":1496,"id":221511,"goal":"function Factorial_1496(n: nat): nat\n ensures Factorial_1496(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_1496(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_1497","instance":1497,"id":221512,"goal":"function Fib_1497(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_1497(n-1) + Fib_1497(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_1498","instance":1498,"id":221513,"goal":"function Gcd_1498(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_1498(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_1499","instance":1499,"id":221514,"goal":"function Power_1499(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_1499(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_1500","instance":1500,"id":221515,"goal":"function Sum_1500(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_1500(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_1501","instance":1501,"id":221516,"goal":"method BinarySearch_1501(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_1502","instance":1502,"id":221517,"goal":"method InsertSort_1502(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_1503","instance":1503,"id":221518,"goal":"method MergeSort_1503(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_1504","instance":1504,"id":221519,"goal":"method ArrayCopy_1504(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_1505","instance":1505,"id":221520,"goal":"function ListReverse_1505(s: seq): seq\n ensures |ListReverse_1505(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_1505(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_1506","instance":1506,"id":221521,"goal":"function Factorial_1506(n: nat): nat\n ensures Factorial_1506(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_1506(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_1507","instance":1507,"id":221522,"goal":"function Fib_1507(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_1507(n-1) + Fib_1507(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_1508","instance":1508,"id":221523,"goal":"function Gcd_1508(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_1508(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_1509","instance":1509,"id":221524,"goal":"function Power_1509(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_1509(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_1510","instance":1510,"id":221525,"goal":"function Sum_1510(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_1510(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_1511","instance":1511,"id":221526,"goal":"method BinarySearch_1511(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_1512","instance":1512,"id":221527,"goal":"method InsertSort_1512(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_1513","instance":1513,"id":221528,"goal":"method MergeSort_1513(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_1514","instance":1514,"id":221529,"goal":"method ArrayCopy_1514(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_1515","instance":1515,"id":221530,"goal":"function ListReverse_1515(s: seq): seq\n ensures |ListReverse_1515(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_1515(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_1516","instance":1516,"id":221531,"goal":"function Factorial_1516(n: nat): nat\n ensures Factorial_1516(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_1516(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_1517","instance":1517,"id":221532,"goal":"function Fib_1517(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_1517(n-1) + Fib_1517(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_1518","instance":1518,"id":221533,"goal":"function Gcd_1518(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_1518(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_1519","instance":1519,"id":221534,"goal":"function Power_1519(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_1519(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_1520","instance":1520,"id":221535,"goal":"function Sum_1520(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_1520(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_1521","instance":1521,"id":221536,"goal":"method BinarySearch_1521(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_1522","instance":1522,"id":221537,"goal":"method InsertSort_1522(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_1523","instance":1523,"id":221538,"goal":"method MergeSort_1523(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_1524","instance":1524,"id":221539,"goal":"method ArrayCopy_1524(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_1525","instance":1525,"id":221540,"goal":"function ListReverse_1525(s: seq): seq\n ensures |ListReverse_1525(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_1525(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_1526","instance":1526,"id":221541,"goal":"function Factorial_1526(n: nat): nat\n ensures Factorial_1526(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_1526(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_1527","instance":1527,"id":221542,"goal":"function Fib_1527(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_1527(n-1) + Fib_1527(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_1528","instance":1528,"id":221543,"goal":"function Gcd_1528(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_1528(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_1529","instance":1529,"id":221544,"goal":"function Power_1529(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_1529(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_1530","instance":1530,"id":221545,"goal":"function Sum_1530(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_1530(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_1531","instance":1531,"id":221546,"goal":"method BinarySearch_1531(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_1532","instance":1532,"id":221547,"goal":"method InsertSort_1532(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_1533","instance":1533,"id":221548,"goal":"method MergeSort_1533(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_1534","instance":1534,"id":221549,"goal":"method ArrayCopy_1534(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_1535","instance":1535,"id":221550,"goal":"function ListReverse_1535(s: seq): seq\n ensures |ListReverse_1535(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_1535(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_1536","instance":1536,"id":221551,"goal":"function Factorial_1536(n: nat): nat\n ensures Factorial_1536(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_1536(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_1537","instance":1537,"id":221552,"goal":"function Fib_1537(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_1537(n-1) + Fib_1537(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_1538","instance":1538,"id":221553,"goal":"function Gcd_1538(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_1538(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_1539","instance":1539,"id":221554,"goal":"function Power_1539(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_1539(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_1540","instance":1540,"id":221555,"goal":"function Sum_1540(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_1540(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_1541","instance":1541,"id":221556,"goal":"method BinarySearch_1541(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_1542","instance":1542,"id":221557,"goal":"method InsertSort_1542(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_1543","instance":1543,"id":221558,"goal":"method MergeSort_1543(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_1544","instance":1544,"id":221559,"goal":"method ArrayCopy_1544(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_1545","instance":1545,"id":221560,"goal":"function ListReverse_1545(s: seq): seq\n ensures |ListReverse_1545(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_1545(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_1546","instance":1546,"id":221561,"goal":"function Factorial_1546(n: nat): nat\n ensures Factorial_1546(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_1546(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_1547","instance":1547,"id":221562,"goal":"function Fib_1547(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_1547(n-1) + Fib_1547(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_1548","instance":1548,"id":221563,"goal":"function Gcd_1548(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_1548(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_1549","instance":1549,"id":221564,"goal":"function Power_1549(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_1549(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_1550","instance":1550,"id":221565,"goal":"function Sum_1550(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_1550(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_1551","instance":1551,"id":221566,"goal":"method BinarySearch_1551(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_1552","instance":1552,"id":221567,"goal":"method InsertSort_1552(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_1553","instance":1553,"id":221568,"goal":"method MergeSort_1553(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_1554","instance":1554,"id":221569,"goal":"method ArrayCopy_1554(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_1555","instance":1555,"id":221570,"goal":"function ListReverse_1555(s: seq): seq\n ensures |ListReverse_1555(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_1555(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_1556","instance":1556,"id":221571,"goal":"function Factorial_1556(n: nat): nat\n ensures Factorial_1556(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_1556(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_1557","instance":1557,"id":221572,"goal":"function Fib_1557(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_1557(n-1) + Fib_1557(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_1558","instance":1558,"id":221573,"goal":"function Gcd_1558(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_1558(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_1559","instance":1559,"id":221574,"goal":"function Power_1559(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_1559(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_1560","instance":1560,"id":221575,"goal":"function Sum_1560(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_1560(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_1561","instance":1561,"id":221576,"goal":"method BinarySearch_1561(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_1562","instance":1562,"id":221577,"goal":"method InsertSort_1562(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_1563","instance":1563,"id":221578,"goal":"method MergeSort_1563(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_1564","instance":1564,"id":221579,"goal":"method ArrayCopy_1564(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_1565","instance":1565,"id":221580,"goal":"function ListReverse_1565(s: seq): seq\n ensures |ListReverse_1565(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_1565(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_1566","instance":1566,"id":221581,"goal":"function Factorial_1566(n: nat): nat\n ensures Factorial_1566(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_1566(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_1567","instance":1567,"id":221582,"goal":"function Fib_1567(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_1567(n-1) + Fib_1567(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_1568","instance":1568,"id":221583,"goal":"function Gcd_1568(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_1568(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_1569","instance":1569,"id":221584,"goal":"function Power_1569(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_1569(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_1570","instance":1570,"id":221585,"goal":"function Sum_1570(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_1570(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_1571","instance":1571,"id":221586,"goal":"method BinarySearch_1571(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_1572","instance":1572,"id":221587,"goal":"method InsertSort_1572(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_1573","instance":1573,"id":221588,"goal":"method MergeSort_1573(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_1574","instance":1574,"id":221589,"goal":"method ArrayCopy_1574(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_1575","instance":1575,"id":221590,"goal":"function ListReverse_1575(s: seq): seq\n ensures |ListReverse_1575(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_1575(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_1576","instance":1576,"id":221591,"goal":"function Factorial_1576(n: nat): nat\n ensures Factorial_1576(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_1576(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_1577","instance":1577,"id":221592,"goal":"function Fib_1577(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_1577(n-1) + Fib_1577(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_1578","instance":1578,"id":221593,"goal":"function Gcd_1578(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_1578(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_1579","instance":1579,"id":221594,"goal":"function Power_1579(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_1579(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_1580","instance":1580,"id":221595,"goal":"function Sum_1580(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_1580(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_1581","instance":1581,"id":221596,"goal":"method BinarySearch_1581(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_1582","instance":1582,"id":221597,"goal":"method InsertSort_1582(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_1583","instance":1583,"id":221598,"goal":"method MergeSort_1583(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_1584","instance":1584,"id":221599,"goal":"method ArrayCopy_1584(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_1585","instance":1585,"id":221600,"goal":"function ListReverse_1585(s: seq): seq\n ensures |ListReverse_1585(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_1585(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_1586","instance":1586,"id":221601,"goal":"function Factorial_1586(n: nat): nat\n ensures Factorial_1586(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_1586(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_1587","instance":1587,"id":221602,"goal":"function Fib_1587(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_1587(n-1) + Fib_1587(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_1588","instance":1588,"id":221603,"goal":"function Gcd_1588(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_1588(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_1589","instance":1589,"id":221604,"goal":"function Power_1589(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_1589(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_1590","instance":1590,"id":221605,"goal":"function Sum_1590(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_1590(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_1591","instance":1591,"id":221606,"goal":"method BinarySearch_1591(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_1592","instance":1592,"id":221607,"goal":"method InsertSort_1592(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_1593","instance":1593,"id":221608,"goal":"method MergeSort_1593(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_1594","instance":1594,"id":221609,"goal":"method ArrayCopy_1594(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_1595","instance":1595,"id":221610,"goal":"function ListReverse_1595(s: seq): seq\n ensures |ListReverse_1595(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_1595(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_1596","instance":1596,"id":221611,"goal":"function Factorial_1596(n: nat): nat\n ensures Factorial_1596(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_1596(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_1597","instance":1597,"id":221612,"goal":"function Fib_1597(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_1597(n-1) + Fib_1597(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_1598","instance":1598,"id":221613,"goal":"function Gcd_1598(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_1598(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_1599","instance":1599,"id":221614,"goal":"function Power_1599(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_1599(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_1600","instance":1600,"id":221615,"goal":"function Sum_1600(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_1600(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_1601","instance":1601,"id":221616,"goal":"method BinarySearch_1601(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_1602","instance":1602,"id":221617,"goal":"method InsertSort_1602(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_1603","instance":1603,"id":221618,"goal":"method MergeSort_1603(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_1604","instance":1604,"id":221619,"goal":"method ArrayCopy_1604(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_1605","instance":1605,"id":221620,"goal":"function ListReverse_1605(s: seq): seq\n ensures |ListReverse_1605(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_1605(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_1606","instance":1606,"id":221621,"goal":"function Factorial_1606(n: nat): nat\n ensures Factorial_1606(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_1606(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_1607","instance":1607,"id":221622,"goal":"function Fib_1607(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_1607(n-1) + Fib_1607(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_1608","instance":1608,"id":221623,"goal":"function Gcd_1608(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_1608(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_1609","instance":1609,"id":221624,"goal":"function Power_1609(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_1609(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_1610","instance":1610,"id":221625,"goal":"function Sum_1610(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_1610(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_1611","instance":1611,"id":221626,"goal":"method BinarySearch_1611(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_1612","instance":1612,"id":221627,"goal":"method InsertSort_1612(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_1613","instance":1613,"id":221628,"goal":"method MergeSort_1613(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_1614","instance":1614,"id":221629,"goal":"method ArrayCopy_1614(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_1615","instance":1615,"id":221630,"goal":"function ListReverse_1615(s: seq): seq\n ensures |ListReverse_1615(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_1615(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_1616","instance":1616,"id":221631,"goal":"function Factorial_1616(n: nat): nat\n ensures Factorial_1616(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_1616(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_1617","instance":1617,"id":221632,"goal":"function Fib_1617(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_1617(n-1) + Fib_1617(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_1618","instance":1618,"id":221633,"goal":"function Gcd_1618(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_1618(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_1619","instance":1619,"id":221634,"goal":"function Power_1619(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_1619(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_1620","instance":1620,"id":221635,"goal":"function Sum_1620(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_1620(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_1621","instance":1621,"id":221636,"goal":"method BinarySearch_1621(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_1622","instance":1622,"id":221637,"goal":"method InsertSort_1622(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_1623","instance":1623,"id":221638,"goal":"method MergeSort_1623(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_1624","instance":1624,"id":221639,"goal":"method ArrayCopy_1624(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_1625","instance":1625,"id":221640,"goal":"function ListReverse_1625(s: seq): seq\n ensures |ListReverse_1625(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_1625(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_1626","instance":1626,"id":221641,"goal":"function Factorial_1626(n: nat): nat\n ensures Factorial_1626(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_1626(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_1627","instance":1627,"id":221642,"goal":"function Fib_1627(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_1627(n-1) + Fib_1627(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_1628","instance":1628,"id":221643,"goal":"function Gcd_1628(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_1628(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_1629","instance":1629,"id":221644,"goal":"function Power_1629(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_1629(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_1630","instance":1630,"id":221645,"goal":"function Sum_1630(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_1630(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_1631","instance":1631,"id":221646,"goal":"method BinarySearch_1631(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_1632","instance":1632,"id":221647,"goal":"method InsertSort_1632(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_1633","instance":1633,"id":221648,"goal":"method MergeSort_1633(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_1634","instance":1634,"id":221649,"goal":"method ArrayCopy_1634(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_1635","instance":1635,"id":221650,"goal":"function ListReverse_1635(s: seq): seq\n ensures |ListReverse_1635(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_1635(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_1636","instance":1636,"id":221651,"goal":"function Factorial_1636(n: nat): nat\n ensures Factorial_1636(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_1636(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_1637","instance":1637,"id":221652,"goal":"function Fib_1637(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_1637(n-1) + Fib_1637(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_1638","instance":1638,"id":221653,"goal":"function Gcd_1638(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_1638(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_1639","instance":1639,"id":221654,"goal":"function Power_1639(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_1639(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_1640","instance":1640,"id":221655,"goal":"function Sum_1640(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_1640(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_1641","instance":1641,"id":221656,"goal":"method BinarySearch_1641(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_1642","instance":1642,"id":221657,"goal":"method InsertSort_1642(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_1643","instance":1643,"id":221658,"goal":"method MergeSort_1643(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_1644","instance":1644,"id":221659,"goal":"method ArrayCopy_1644(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_1645","instance":1645,"id":221660,"goal":"function ListReverse_1645(s: seq): seq\n ensures |ListReverse_1645(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_1645(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_1646","instance":1646,"id":221661,"goal":"function Factorial_1646(n: nat): nat\n ensures Factorial_1646(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_1646(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_1647","instance":1647,"id":221662,"goal":"function Fib_1647(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_1647(n-1) + Fib_1647(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_1648","instance":1648,"id":221663,"goal":"function Gcd_1648(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_1648(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_1649","instance":1649,"id":221664,"goal":"function Power_1649(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_1649(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_1650","instance":1650,"id":221665,"goal":"function Sum_1650(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_1650(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_1651","instance":1651,"id":221666,"goal":"method BinarySearch_1651(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_1652","instance":1652,"id":221667,"goal":"method InsertSort_1652(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_1653","instance":1653,"id":221668,"goal":"method MergeSort_1653(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_1654","instance":1654,"id":221669,"goal":"method ArrayCopy_1654(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_1655","instance":1655,"id":221670,"goal":"function ListReverse_1655(s: seq): seq\n ensures |ListReverse_1655(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_1655(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_1656","instance":1656,"id":221671,"goal":"function Factorial_1656(n: nat): nat\n ensures Factorial_1656(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_1656(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_1657","instance":1657,"id":221672,"goal":"function Fib_1657(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_1657(n-1) + Fib_1657(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_1658","instance":1658,"id":221673,"goal":"function Gcd_1658(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_1658(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_1659","instance":1659,"id":221674,"goal":"function Power_1659(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_1659(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_1660","instance":1660,"id":221675,"goal":"function Sum_1660(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_1660(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_1661","instance":1661,"id":221676,"goal":"method BinarySearch_1661(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_1662","instance":1662,"id":221677,"goal":"method InsertSort_1662(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_1663","instance":1663,"id":221678,"goal":"method MergeSort_1663(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_1664","instance":1664,"id":221679,"goal":"method ArrayCopy_1664(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_1665","instance":1665,"id":221680,"goal":"function ListReverse_1665(s: seq): seq\n ensures |ListReverse_1665(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_1665(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_1666","instance":1666,"id":221681,"goal":"function Factorial_1666(n: nat): nat\n ensures Factorial_1666(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_1666(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_1667","instance":1667,"id":221682,"goal":"function Fib_1667(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_1667(n-1) + Fib_1667(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_1668","instance":1668,"id":221683,"goal":"function Gcd_1668(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_1668(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_1669","instance":1669,"id":221684,"goal":"function Power_1669(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_1669(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_1670","instance":1670,"id":221685,"goal":"function Sum_1670(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_1670(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_1671","instance":1671,"id":221686,"goal":"method BinarySearch_1671(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_1672","instance":1672,"id":221687,"goal":"method InsertSort_1672(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_1673","instance":1673,"id":221688,"goal":"method MergeSort_1673(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_1674","instance":1674,"id":221689,"goal":"method ArrayCopy_1674(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_1675","instance":1675,"id":221690,"goal":"function ListReverse_1675(s: seq): seq\n ensures |ListReverse_1675(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_1675(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_1676","instance":1676,"id":221691,"goal":"function Factorial_1676(n: nat): nat\n ensures Factorial_1676(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_1676(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_1677","instance":1677,"id":221692,"goal":"function Fib_1677(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_1677(n-1) + Fib_1677(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_1678","instance":1678,"id":221693,"goal":"function Gcd_1678(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_1678(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_1679","instance":1679,"id":221694,"goal":"function Power_1679(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_1679(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_1680","instance":1680,"id":221695,"goal":"function Sum_1680(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_1680(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_1681","instance":1681,"id":221696,"goal":"method BinarySearch_1681(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_1682","instance":1682,"id":221697,"goal":"method InsertSort_1682(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_1683","instance":1683,"id":221698,"goal":"method MergeSort_1683(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_1684","instance":1684,"id":221699,"goal":"method ArrayCopy_1684(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_1685","instance":1685,"id":221700,"goal":"function ListReverse_1685(s: seq): seq\n ensures |ListReverse_1685(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_1685(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_1686","instance":1686,"id":221701,"goal":"function Factorial_1686(n: nat): nat\n ensures Factorial_1686(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_1686(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_1687","instance":1687,"id":221702,"goal":"function Fib_1687(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_1687(n-1) + Fib_1687(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_1688","instance":1688,"id":221703,"goal":"function Gcd_1688(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_1688(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_1689","instance":1689,"id":221704,"goal":"function Power_1689(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_1689(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_1690","instance":1690,"id":221705,"goal":"function Sum_1690(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_1690(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_1691","instance":1691,"id":221706,"goal":"method BinarySearch_1691(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_1692","instance":1692,"id":221707,"goal":"method InsertSort_1692(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_1693","instance":1693,"id":221708,"goal":"method MergeSort_1693(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_1694","instance":1694,"id":221709,"goal":"method ArrayCopy_1694(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_1695","instance":1695,"id":221710,"goal":"function ListReverse_1695(s: seq): seq\n ensures |ListReverse_1695(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_1695(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_1696","instance":1696,"id":221711,"goal":"function Factorial_1696(n: nat): nat\n ensures Factorial_1696(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_1696(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_1697","instance":1697,"id":221712,"goal":"function Fib_1697(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_1697(n-1) + Fib_1697(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_1698","instance":1698,"id":221713,"goal":"function Gcd_1698(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_1698(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_1699","instance":1699,"id":221714,"goal":"function Power_1699(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_1699(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_1700","instance":1700,"id":221715,"goal":"function Sum_1700(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_1700(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_1701","instance":1701,"id":221716,"goal":"method BinarySearch_1701(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_1702","instance":1702,"id":221717,"goal":"method InsertSort_1702(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_1703","instance":1703,"id":221718,"goal":"method MergeSort_1703(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_1704","instance":1704,"id":221719,"goal":"method ArrayCopy_1704(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_1705","instance":1705,"id":221720,"goal":"function ListReverse_1705(s: seq): seq\n ensures |ListReverse_1705(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_1705(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_1706","instance":1706,"id":221721,"goal":"function Factorial_1706(n: nat): nat\n ensures Factorial_1706(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_1706(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_1707","instance":1707,"id":221722,"goal":"function Fib_1707(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_1707(n-1) + Fib_1707(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_1708","instance":1708,"id":221723,"goal":"function Gcd_1708(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_1708(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_1709","instance":1709,"id":221724,"goal":"function Power_1709(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_1709(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_1710","instance":1710,"id":221725,"goal":"function Sum_1710(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_1710(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_1711","instance":1711,"id":221726,"goal":"method BinarySearch_1711(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_1712","instance":1712,"id":221727,"goal":"method InsertSort_1712(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_1713","instance":1713,"id":221728,"goal":"method MergeSort_1713(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_1714","instance":1714,"id":221729,"goal":"method ArrayCopy_1714(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_1715","instance":1715,"id":221730,"goal":"function ListReverse_1715(s: seq): seq\n ensures |ListReverse_1715(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_1715(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_1716","instance":1716,"id":221731,"goal":"function Factorial_1716(n: nat): nat\n ensures Factorial_1716(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_1716(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_1717","instance":1717,"id":221732,"goal":"function Fib_1717(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_1717(n-1) + Fib_1717(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_1718","instance":1718,"id":221733,"goal":"function Gcd_1718(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_1718(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_1719","instance":1719,"id":221734,"goal":"function Power_1719(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_1719(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_1720","instance":1720,"id":221735,"goal":"function Sum_1720(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_1720(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_1721","instance":1721,"id":221736,"goal":"method BinarySearch_1721(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_1722","instance":1722,"id":221737,"goal":"method InsertSort_1722(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_1723","instance":1723,"id":221738,"goal":"method MergeSort_1723(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_1724","instance":1724,"id":221739,"goal":"method ArrayCopy_1724(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_1725","instance":1725,"id":221740,"goal":"function ListReverse_1725(s: seq): seq\n ensures |ListReverse_1725(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_1725(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_1726","instance":1726,"id":221741,"goal":"function Factorial_1726(n: nat): nat\n ensures Factorial_1726(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_1726(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_1727","instance":1727,"id":221742,"goal":"function Fib_1727(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_1727(n-1) + Fib_1727(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_1728","instance":1728,"id":221743,"goal":"function Gcd_1728(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_1728(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_1729","instance":1729,"id":221744,"goal":"function Power_1729(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_1729(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_1730","instance":1730,"id":221745,"goal":"function Sum_1730(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_1730(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_1731","instance":1731,"id":221746,"goal":"method BinarySearch_1731(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_1732","instance":1732,"id":221747,"goal":"method InsertSort_1732(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_1733","instance":1733,"id":221748,"goal":"method MergeSort_1733(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_1734","instance":1734,"id":221749,"goal":"method ArrayCopy_1734(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_1735","instance":1735,"id":221750,"goal":"function ListReverse_1735(s: seq): seq\n ensures |ListReverse_1735(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_1735(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_1736","instance":1736,"id":221751,"goal":"function Factorial_1736(n: nat): nat\n ensures Factorial_1736(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_1736(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_1737","instance":1737,"id":221752,"goal":"function Fib_1737(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_1737(n-1) + Fib_1737(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_1738","instance":1738,"id":221753,"goal":"function Gcd_1738(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_1738(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_1739","instance":1739,"id":221754,"goal":"function Power_1739(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_1739(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_1740","instance":1740,"id":221755,"goal":"function Sum_1740(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_1740(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_1741","instance":1741,"id":221756,"goal":"method BinarySearch_1741(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_1742","instance":1742,"id":221757,"goal":"method InsertSort_1742(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_1743","instance":1743,"id":221758,"goal":"method MergeSort_1743(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_1744","instance":1744,"id":221759,"goal":"method ArrayCopy_1744(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_1745","instance":1745,"id":221760,"goal":"function ListReverse_1745(s: seq): seq\n ensures |ListReverse_1745(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_1745(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_1746","instance":1746,"id":221761,"goal":"function Factorial_1746(n: nat): nat\n ensures Factorial_1746(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_1746(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_1747","instance":1747,"id":221762,"goal":"function Fib_1747(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_1747(n-1) + Fib_1747(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_1748","instance":1748,"id":221763,"goal":"function Gcd_1748(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_1748(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_1749","instance":1749,"id":221764,"goal":"function Power_1749(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_1749(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_1750","instance":1750,"id":221765,"goal":"function Sum_1750(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_1750(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_1751","instance":1751,"id":221766,"goal":"method BinarySearch_1751(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_1752","instance":1752,"id":221767,"goal":"method InsertSort_1752(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_1753","instance":1753,"id":221768,"goal":"method MergeSort_1753(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_1754","instance":1754,"id":221769,"goal":"method ArrayCopy_1754(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_1755","instance":1755,"id":221770,"goal":"function ListReverse_1755(s: seq): seq\n ensures |ListReverse_1755(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_1755(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_1756","instance":1756,"id":221771,"goal":"function Factorial_1756(n: nat): nat\n ensures Factorial_1756(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_1756(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_1757","instance":1757,"id":221772,"goal":"function Fib_1757(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_1757(n-1) + Fib_1757(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_1758","instance":1758,"id":221773,"goal":"function Gcd_1758(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_1758(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_1759","instance":1759,"id":221774,"goal":"function Power_1759(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_1759(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_1760","instance":1760,"id":221775,"goal":"function Sum_1760(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_1760(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_1761","instance":1761,"id":221776,"goal":"method BinarySearch_1761(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_1762","instance":1762,"id":221777,"goal":"method InsertSort_1762(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_1763","instance":1763,"id":221778,"goal":"method MergeSort_1763(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_1764","instance":1764,"id":221779,"goal":"method ArrayCopy_1764(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_1765","instance":1765,"id":221780,"goal":"function ListReverse_1765(s: seq): seq\n ensures |ListReverse_1765(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_1765(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_1766","instance":1766,"id":221781,"goal":"function Factorial_1766(n: nat): nat\n ensures Factorial_1766(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_1766(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_1767","instance":1767,"id":221782,"goal":"function Fib_1767(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_1767(n-1) + Fib_1767(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_1768","instance":1768,"id":221783,"goal":"function Gcd_1768(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_1768(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_1769","instance":1769,"id":221784,"goal":"function Power_1769(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_1769(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_1770","instance":1770,"id":221785,"goal":"function Sum_1770(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_1770(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_1771","instance":1771,"id":221786,"goal":"method BinarySearch_1771(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_1772","instance":1772,"id":221787,"goal":"method InsertSort_1772(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_1773","instance":1773,"id":221788,"goal":"method MergeSort_1773(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_1774","instance":1774,"id":221789,"goal":"method ArrayCopy_1774(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_1775","instance":1775,"id":221790,"goal":"function ListReverse_1775(s: seq): seq\n ensures |ListReverse_1775(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_1775(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_1776","instance":1776,"id":221791,"goal":"function Factorial_1776(n: nat): nat\n ensures Factorial_1776(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_1776(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_1777","instance":1777,"id":221792,"goal":"function Fib_1777(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_1777(n-1) + Fib_1777(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_1778","instance":1778,"id":221793,"goal":"function Gcd_1778(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_1778(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_1779","instance":1779,"id":221794,"goal":"function Power_1779(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_1779(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_1780","instance":1780,"id":221795,"goal":"function Sum_1780(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_1780(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_1781","instance":1781,"id":221796,"goal":"method BinarySearch_1781(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_1782","instance":1782,"id":221797,"goal":"method InsertSort_1782(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_1783","instance":1783,"id":221798,"goal":"method MergeSort_1783(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_1784","instance":1784,"id":221799,"goal":"method ArrayCopy_1784(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_1785","instance":1785,"id":221800,"goal":"function ListReverse_1785(s: seq): seq\n ensures |ListReverse_1785(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_1785(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_1786","instance":1786,"id":221801,"goal":"function Factorial_1786(n: nat): nat\n ensures Factorial_1786(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_1786(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_1787","instance":1787,"id":221802,"goal":"function Fib_1787(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_1787(n-1) + Fib_1787(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_1788","instance":1788,"id":221803,"goal":"function Gcd_1788(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_1788(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_1789","instance":1789,"id":221804,"goal":"function Power_1789(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_1789(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_1790","instance":1790,"id":221805,"goal":"function Sum_1790(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_1790(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_1791","instance":1791,"id":221806,"goal":"method BinarySearch_1791(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_1792","instance":1792,"id":221807,"goal":"method InsertSort_1792(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_1793","instance":1793,"id":221808,"goal":"method MergeSort_1793(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_1794","instance":1794,"id":221809,"goal":"method ArrayCopy_1794(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_1795","instance":1795,"id":221810,"goal":"function ListReverse_1795(s: seq): seq\n ensures |ListReverse_1795(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_1795(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_1796","instance":1796,"id":221811,"goal":"function Factorial_1796(n: nat): nat\n ensures Factorial_1796(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_1796(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_1797","instance":1797,"id":221812,"goal":"function Fib_1797(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_1797(n-1) + Fib_1797(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_1798","instance":1798,"id":221813,"goal":"function Gcd_1798(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_1798(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_1799","instance":1799,"id":221814,"goal":"function Power_1799(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_1799(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_1800","instance":1800,"id":221815,"goal":"function Sum_1800(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_1800(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_1801","instance":1801,"id":221816,"goal":"method BinarySearch_1801(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_1802","instance":1802,"id":221817,"goal":"method InsertSort_1802(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_1803","instance":1803,"id":221818,"goal":"method MergeSort_1803(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_1804","instance":1804,"id":221819,"goal":"method ArrayCopy_1804(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_1805","instance":1805,"id":221820,"goal":"function ListReverse_1805(s: seq): seq\n ensures |ListReverse_1805(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_1805(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_1806","instance":1806,"id":221821,"goal":"function Factorial_1806(n: nat): nat\n ensures Factorial_1806(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_1806(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_1807","instance":1807,"id":221822,"goal":"function Fib_1807(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_1807(n-1) + Fib_1807(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_1808","instance":1808,"id":221823,"goal":"function Gcd_1808(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_1808(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_1809","instance":1809,"id":221824,"goal":"function Power_1809(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_1809(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_1810","instance":1810,"id":221825,"goal":"function Sum_1810(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_1810(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_1811","instance":1811,"id":221826,"goal":"method BinarySearch_1811(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_1812","instance":1812,"id":221827,"goal":"method InsertSort_1812(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_1813","instance":1813,"id":221828,"goal":"method MergeSort_1813(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_1814","instance":1814,"id":221829,"goal":"method ArrayCopy_1814(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_1815","instance":1815,"id":221830,"goal":"function ListReverse_1815(s: seq): seq\n ensures |ListReverse_1815(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_1815(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_1816","instance":1816,"id":221831,"goal":"function Factorial_1816(n: nat): nat\n ensures Factorial_1816(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_1816(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_1817","instance":1817,"id":221832,"goal":"function Fib_1817(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_1817(n-1) + Fib_1817(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_1818","instance":1818,"id":221833,"goal":"function Gcd_1818(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_1818(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_1819","instance":1819,"id":221834,"goal":"function Power_1819(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_1819(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_1820","instance":1820,"id":221835,"goal":"function Sum_1820(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_1820(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_1821","instance":1821,"id":221836,"goal":"method BinarySearch_1821(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_1822","instance":1822,"id":221837,"goal":"method InsertSort_1822(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_1823","instance":1823,"id":221838,"goal":"method MergeSort_1823(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_1824","instance":1824,"id":221839,"goal":"method ArrayCopy_1824(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_1825","instance":1825,"id":221840,"goal":"function ListReverse_1825(s: seq): seq\n ensures |ListReverse_1825(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_1825(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_1826","instance":1826,"id":221841,"goal":"function Factorial_1826(n: nat): nat\n ensures Factorial_1826(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_1826(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_1827","instance":1827,"id":221842,"goal":"function Fib_1827(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_1827(n-1) + Fib_1827(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_1828","instance":1828,"id":221843,"goal":"function Gcd_1828(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_1828(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_1829","instance":1829,"id":221844,"goal":"function Power_1829(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_1829(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_1830","instance":1830,"id":221845,"goal":"function Sum_1830(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_1830(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_1831","instance":1831,"id":221846,"goal":"method BinarySearch_1831(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_1832","instance":1832,"id":221847,"goal":"method InsertSort_1832(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_1833","instance":1833,"id":221848,"goal":"method MergeSort_1833(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_1834","instance":1834,"id":221849,"goal":"method ArrayCopy_1834(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_1835","instance":1835,"id":221850,"goal":"function ListReverse_1835(s: seq): seq\n ensures |ListReverse_1835(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_1835(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_1836","instance":1836,"id":221851,"goal":"function Factorial_1836(n: nat): nat\n ensures Factorial_1836(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_1836(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_1837","instance":1837,"id":221852,"goal":"function Fib_1837(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_1837(n-1) + Fib_1837(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_1838","instance":1838,"id":221853,"goal":"function Gcd_1838(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_1838(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_1839","instance":1839,"id":221854,"goal":"function Power_1839(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_1839(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_1840","instance":1840,"id":221855,"goal":"function Sum_1840(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_1840(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_1841","instance":1841,"id":221856,"goal":"method BinarySearch_1841(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_1842","instance":1842,"id":221857,"goal":"method InsertSort_1842(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_1843","instance":1843,"id":221858,"goal":"method MergeSort_1843(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_1844","instance":1844,"id":221859,"goal":"method ArrayCopy_1844(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_1845","instance":1845,"id":221860,"goal":"function ListReverse_1845(s: seq): seq\n ensures |ListReverse_1845(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_1845(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_1846","instance":1846,"id":221861,"goal":"function Factorial_1846(n: nat): nat\n ensures Factorial_1846(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_1846(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_1847","instance":1847,"id":221862,"goal":"function Fib_1847(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_1847(n-1) + Fib_1847(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_1848","instance":1848,"id":221863,"goal":"function Gcd_1848(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_1848(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_1849","instance":1849,"id":221864,"goal":"function Power_1849(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_1849(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_1850","instance":1850,"id":221865,"goal":"function Sum_1850(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_1850(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_1851","instance":1851,"id":221866,"goal":"method BinarySearch_1851(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_1852","instance":1852,"id":221867,"goal":"method InsertSort_1852(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_1853","instance":1853,"id":221868,"goal":"method MergeSort_1853(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_1854","instance":1854,"id":221869,"goal":"method ArrayCopy_1854(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_1855","instance":1855,"id":221870,"goal":"function ListReverse_1855(s: seq): seq\n ensures |ListReverse_1855(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_1855(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_1856","instance":1856,"id":221871,"goal":"function Factorial_1856(n: nat): nat\n ensures Factorial_1856(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_1856(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_1857","instance":1857,"id":221872,"goal":"function Fib_1857(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_1857(n-1) + Fib_1857(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_1858","instance":1858,"id":221873,"goal":"function Gcd_1858(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_1858(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_1859","instance":1859,"id":221874,"goal":"function Power_1859(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_1859(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_1860","instance":1860,"id":221875,"goal":"function Sum_1860(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_1860(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_1861","instance":1861,"id":221876,"goal":"method BinarySearch_1861(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_1862","instance":1862,"id":221877,"goal":"method InsertSort_1862(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_1863","instance":1863,"id":221878,"goal":"method MergeSort_1863(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_1864","instance":1864,"id":221879,"goal":"method ArrayCopy_1864(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_1865","instance":1865,"id":221880,"goal":"function ListReverse_1865(s: seq): seq\n ensures |ListReverse_1865(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_1865(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_1866","instance":1866,"id":221881,"goal":"function Factorial_1866(n: nat): nat\n ensures Factorial_1866(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_1866(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_1867","instance":1867,"id":221882,"goal":"function Fib_1867(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_1867(n-1) + Fib_1867(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_1868","instance":1868,"id":221883,"goal":"function Gcd_1868(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_1868(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_1869","instance":1869,"id":221884,"goal":"function Power_1869(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_1869(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_1870","instance":1870,"id":221885,"goal":"function Sum_1870(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_1870(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_1871","instance":1871,"id":221886,"goal":"method BinarySearch_1871(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_1872","instance":1872,"id":221887,"goal":"method InsertSort_1872(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_1873","instance":1873,"id":221888,"goal":"method MergeSort_1873(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_1874","instance":1874,"id":221889,"goal":"method ArrayCopy_1874(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_1875","instance":1875,"id":221890,"goal":"function ListReverse_1875(s: seq): seq\n ensures |ListReverse_1875(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_1875(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_1876","instance":1876,"id":221891,"goal":"function Factorial_1876(n: nat): nat\n ensures Factorial_1876(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_1876(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_1877","instance":1877,"id":221892,"goal":"function Fib_1877(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_1877(n-1) + Fib_1877(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_1878","instance":1878,"id":221893,"goal":"function Gcd_1878(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_1878(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_1879","instance":1879,"id":221894,"goal":"function Power_1879(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_1879(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_1880","instance":1880,"id":221895,"goal":"function Sum_1880(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_1880(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_1881","instance":1881,"id":221896,"goal":"method BinarySearch_1881(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_1882","instance":1882,"id":221897,"goal":"method InsertSort_1882(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_1883","instance":1883,"id":221898,"goal":"method MergeSort_1883(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_1884","instance":1884,"id":221899,"goal":"method ArrayCopy_1884(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_1885","instance":1885,"id":221900,"goal":"function ListReverse_1885(s: seq): seq\n ensures |ListReverse_1885(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_1885(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_1886","instance":1886,"id":221901,"goal":"function Factorial_1886(n: nat): nat\n ensures Factorial_1886(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_1886(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_1887","instance":1887,"id":221902,"goal":"function Fib_1887(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_1887(n-1) + Fib_1887(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_1888","instance":1888,"id":221903,"goal":"function Gcd_1888(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_1888(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_1889","instance":1889,"id":221904,"goal":"function Power_1889(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_1889(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_1890","instance":1890,"id":221905,"goal":"function Sum_1890(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_1890(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_1891","instance":1891,"id":221906,"goal":"method BinarySearch_1891(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_1892","instance":1892,"id":221907,"goal":"method InsertSort_1892(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_1893","instance":1893,"id":221908,"goal":"method MergeSort_1893(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_1894","instance":1894,"id":221909,"goal":"method ArrayCopy_1894(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_1895","instance":1895,"id":221910,"goal":"function ListReverse_1895(s: seq): seq\n ensures |ListReverse_1895(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_1895(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_1896","instance":1896,"id":221911,"goal":"function Factorial_1896(n: nat): nat\n ensures Factorial_1896(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_1896(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_1897","instance":1897,"id":221912,"goal":"function Fib_1897(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_1897(n-1) + Fib_1897(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_1898","instance":1898,"id":221913,"goal":"function Gcd_1898(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_1898(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_1899","instance":1899,"id":221914,"goal":"function Power_1899(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_1899(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_1900","instance":1900,"id":221915,"goal":"function Sum_1900(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_1900(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_1901","instance":1901,"id":221916,"goal":"method BinarySearch_1901(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_1902","instance":1902,"id":221917,"goal":"method InsertSort_1902(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_1903","instance":1903,"id":221918,"goal":"method MergeSort_1903(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_1904","instance":1904,"id":221919,"goal":"method ArrayCopy_1904(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_1905","instance":1905,"id":221920,"goal":"function ListReverse_1905(s: seq): seq\n ensures |ListReverse_1905(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_1905(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_1906","instance":1906,"id":221921,"goal":"function Factorial_1906(n: nat): nat\n ensures Factorial_1906(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_1906(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_1907","instance":1907,"id":221922,"goal":"function Fib_1907(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_1907(n-1) + Fib_1907(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_1908","instance":1908,"id":221923,"goal":"function Gcd_1908(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_1908(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_1909","instance":1909,"id":221924,"goal":"function Power_1909(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_1909(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_1910","instance":1910,"id":221925,"goal":"function Sum_1910(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_1910(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_1911","instance":1911,"id":221926,"goal":"method BinarySearch_1911(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_1912","instance":1912,"id":221927,"goal":"method InsertSort_1912(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_1913","instance":1913,"id":221928,"goal":"method MergeSort_1913(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_1914","instance":1914,"id":221929,"goal":"method ArrayCopy_1914(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_1915","instance":1915,"id":221930,"goal":"function ListReverse_1915(s: seq): seq\n ensures |ListReverse_1915(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_1915(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_1916","instance":1916,"id":221931,"goal":"function Factorial_1916(n: nat): nat\n ensures Factorial_1916(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_1916(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_1917","instance":1917,"id":221932,"goal":"function Fib_1917(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_1917(n-1) + Fib_1917(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_1918","instance":1918,"id":221933,"goal":"function Gcd_1918(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_1918(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_1919","instance":1919,"id":221934,"goal":"function Power_1919(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_1919(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_1920","instance":1920,"id":221935,"goal":"function Sum_1920(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_1920(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_1921","instance":1921,"id":221936,"goal":"method BinarySearch_1921(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_1922","instance":1922,"id":221937,"goal":"method InsertSort_1922(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_1923","instance":1923,"id":221938,"goal":"method MergeSort_1923(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_1924","instance":1924,"id":221939,"goal":"method ArrayCopy_1924(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_1925","instance":1925,"id":221940,"goal":"function ListReverse_1925(s: seq): seq\n ensures |ListReverse_1925(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_1925(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_1926","instance":1926,"id":221941,"goal":"function Factorial_1926(n: nat): nat\n ensures Factorial_1926(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_1926(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_1927","instance":1927,"id":221942,"goal":"function Fib_1927(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_1927(n-1) + Fib_1927(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_1928","instance":1928,"id":221943,"goal":"function Gcd_1928(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_1928(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_1929","instance":1929,"id":221944,"goal":"function Power_1929(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_1929(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_1930","instance":1930,"id":221945,"goal":"function Sum_1930(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_1930(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_1931","instance":1931,"id":221946,"goal":"method BinarySearch_1931(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_1932","instance":1932,"id":221947,"goal":"method InsertSort_1932(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_1933","instance":1933,"id":221948,"goal":"method MergeSort_1933(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_1934","instance":1934,"id":221949,"goal":"method ArrayCopy_1934(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_1935","instance":1935,"id":221950,"goal":"function ListReverse_1935(s: seq): seq\n ensures |ListReverse_1935(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_1935(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_1936","instance":1936,"id":221951,"goal":"function Factorial_1936(n: nat): nat\n ensures Factorial_1936(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_1936(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_1937","instance":1937,"id":221952,"goal":"function Fib_1937(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_1937(n-1) + Fib_1937(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_1938","instance":1938,"id":221953,"goal":"function Gcd_1938(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_1938(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_1939","instance":1939,"id":221954,"goal":"function Power_1939(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_1939(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_1940","instance":1940,"id":221955,"goal":"function Sum_1940(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_1940(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_1941","instance":1941,"id":221956,"goal":"method BinarySearch_1941(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_1942","instance":1942,"id":221957,"goal":"method InsertSort_1942(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_1943","instance":1943,"id":221958,"goal":"method MergeSort_1943(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_1944","instance":1944,"id":221959,"goal":"method ArrayCopy_1944(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_1945","instance":1945,"id":221960,"goal":"function ListReverse_1945(s: seq): seq\n ensures |ListReverse_1945(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_1945(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_1946","instance":1946,"id":221961,"goal":"function Factorial_1946(n: nat): nat\n ensures Factorial_1946(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_1946(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_1947","instance":1947,"id":221962,"goal":"function Fib_1947(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_1947(n-1) + Fib_1947(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_1948","instance":1948,"id":221963,"goal":"function Gcd_1948(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_1948(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_1949","instance":1949,"id":221964,"goal":"function Power_1949(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_1949(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_1950","instance":1950,"id":221965,"goal":"function Sum_1950(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_1950(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_1951","instance":1951,"id":221966,"goal":"method BinarySearch_1951(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_1952","instance":1952,"id":221967,"goal":"method InsertSort_1952(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_1953","instance":1953,"id":221968,"goal":"method MergeSort_1953(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_1954","instance":1954,"id":221969,"goal":"method ArrayCopy_1954(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_1955","instance":1955,"id":221970,"goal":"function ListReverse_1955(s: seq): seq\n ensures |ListReverse_1955(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_1955(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_1956","instance":1956,"id":221971,"goal":"function Factorial_1956(n: nat): nat\n ensures Factorial_1956(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_1956(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_1957","instance":1957,"id":221972,"goal":"function Fib_1957(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_1957(n-1) + Fib_1957(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_1958","instance":1958,"id":221973,"goal":"function Gcd_1958(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_1958(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_1959","instance":1959,"id":221974,"goal":"function Power_1959(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_1959(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_1960","instance":1960,"id":221975,"goal":"function Sum_1960(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_1960(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_1961","instance":1961,"id":221976,"goal":"method BinarySearch_1961(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_1962","instance":1962,"id":221977,"goal":"method InsertSort_1962(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_1963","instance":1963,"id":221978,"goal":"method MergeSort_1963(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_1964","instance":1964,"id":221979,"goal":"method ArrayCopy_1964(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_1965","instance":1965,"id":221980,"goal":"function ListReverse_1965(s: seq): seq\n ensures |ListReverse_1965(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_1965(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_1966","instance":1966,"id":221981,"goal":"function Factorial_1966(n: nat): nat\n ensures Factorial_1966(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_1966(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_1967","instance":1967,"id":221982,"goal":"function Fib_1967(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_1967(n-1) + Fib_1967(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_1968","instance":1968,"id":221983,"goal":"function Gcd_1968(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_1968(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_1969","instance":1969,"id":221984,"goal":"function Power_1969(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_1969(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_1970","instance":1970,"id":221985,"goal":"function Sum_1970(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_1970(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_1971","instance":1971,"id":221986,"goal":"method BinarySearch_1971(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_1972","instance":1972,"id":221987,"goal":"method InsertSort_1972(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_1973","instance":1973,"id":221988,"goal":"method MergeSort_1973(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_1974","instance":1974,"id":221989,"goal":"method ArrayCopy_1974(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_1975","instance":1975,"id":221990,"goal":"function ListReverse_1975(s: seq): seq\n ensures |ListReverse_1975(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_1975(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_1976","instance":1976,"id":221991,"goal":"function Factorial_1976(n: nat): nat\n ensures Factorial_1976(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_1976(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_1977","instance":1977,"id":221992,"goal":"function Fib_1977(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_1977(n-1) + Fib_1977(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_1978","instance":1978,"id":221993,"goal":"function Gcd_1978(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_1978(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_1979","instance":1979,"id":221994,"goal":"function Power_1979(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_1979(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_1980","instance":1980,"id":221995,"goal":"function Sum_1980(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_1980(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_1981","instance":1981,"id":221996,"goal":"method BinarySearch_1981(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_1982","instance":1982,"id":221997,"goal":"method InsertSort_1982(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_1983","instance":1983,"id":221998,"goal":"method MergeSort_1983(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_1984","instance":1984,"id":221999,"goal":"method ArrayCopy_1984(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_1985","instance":1985,"id":222000,"goal":"function ListReverse_1985(s: seq): seq\n ensures |ListReverse_1985(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_1985(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_1986","instance":1986,"id":222001,"goal":"function Factorial_1986(n: nat): nat\n ensures Factorial_1986(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_1986(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_1987","instance":1987,"id":222002,"goal":"function Fib_1987(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_1987(n-1) + Fib_1987(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_1988","instance":1988,"id":222003,"goal":"function Gcd_1988(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_1988(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_1989","instance":1989,"id":222004,"goal":"function Power_1989(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_1989(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_1990","instance":1990,"id":222005,"goal":"function Sum_1990(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_1990(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_1991","instance":1991,"id":222006,"goal":"method BinarySearch_1991(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_1992","instance":1992,"id":222007,"goal":"method InsertSort_1992(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_1993","instance":1993,"id":222008,"goal":"method MergeSort_1993(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_1994","instance":1994,"id":222009,"goal":"method ArrayCopy_1994(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_1995","instance":1995,"id":222010,"goal":"function ListReverse_1995(s: seq): seq\n ensures |ListReverse_1995(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_1995(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_1996","instance":1996,"id":222011,"goal":"function Factorial_1996(n: nat): nat\n ensures Factorial_1996(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_1996(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_1997","instance":1997,"id":222012,"goal":"function Fib_1997(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_1997(n-1) + Fib_1997(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_1998","instance":1998,"id":222013,"goal":"function Gcd_1998(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_1998(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_1999","instance":1999,"id":222014,"goal":"function Power_1999(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_1999(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_2000","instance":2000,"id":222015,"goal":"function Sum_2000(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_2000(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_2001","instance":2001,"id":222016,"goal":"method BinarySearch_2001(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_2002","instance":2002,"id":222017,"goal":"method InsertSort_2002(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_2003","instance":2003,"id":222018,"goal":"method MergeSort_2003(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_2004","instance":2004,"id":222019,"goal":"method ArrayCopy_2004(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_2005","instance":2005,"id":222020,"goal":"function ListReverse_2005(s: seq): seq\n ensures |ListReverse_2005(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_2005(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_2006","instance":2006,"id":222021,"goal":"function Factorial_2006(n: nat): nat\n ensures Factorial_2006(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_2006(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_2007","instance":2007,"id":222022,"goal":"function Fib_2007(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_2007(n-1) + Fib_2007(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_2008","instance":2008,"id":222023,"goal":"function Gcd_2008(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_2008(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_2009","instance":2009,"id":222024,"goal":"function Power_2009(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_2009(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_2010","instance":2010,"id":222025,"goal":"function Sum_2010(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_2010(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_2011","instance":2011,"id":222026,"goal":"method BinarySearch_2011(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_2012","instance":2012,"id":222027,"goal":"method InsertSort_2012(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_2013","instance":2013,"id":222028,"goal":"method MergeSort_2013(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_2014","instance":2014,"id":222029,"goal":"method ArrayCopy_2014(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_2015","instance":2015,"id":222030,"goal":"function ListReverse_2015(s: seq): seq\n ensures |ListReverse_2015(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_2015(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_2016","instance":2016,"id":222031,"goal":"function Factorial_2016(n: nat): nat\n ensures Factorial_2016(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_2016(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_2017","instance":2017,"id":222032,"goal":"function Fib_2017(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_2017(n-1) + Fib_2017(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_2018","instance":2018,"id":222033,"goal":"function Gcd_2018(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_2018(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_2019","instance":2019,"id":222034,"goal":"function Power_2019(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_2019(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_2020","instance":2020,"id":222035,"goal":"function Sum_2020(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_2020(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_2021","instance":2021,"id":222036,"goal":"method BinarySearch_2021(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_2022","instance":2022,"id":222037,"goal":"method InsertSort_2022(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_2023","instance":2023,"id":222038,"goal":"method MergeSort_2023(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_2024","instance":2024,"id":222039,"goal":"method ArrayCopy_2024(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_2025","instance":2025,"id":222040,"goal":"function ListReverse_2025(s: seq): seq\n ensures |ListReverse_2025(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_2025(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_2026","instance":2026,"id":222041,"goal":"function Factorial_2026(n: nat): nat\n ensures Factorial_2026(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_2026(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_2027","instance":2027,"id":222042,"goal":"function Fib_2027(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_2027(n-1) + Fib_2027(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_2028","instance":2028,"id":222043,"goal":"function Gcd_2028(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_2028(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_2029","instance":2029,"id":222044,"goal":"function Power_2029(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_2029(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_2030","instance":2030,"id":222045,"goal":"function Sum_2030(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_2030(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_2031","instance":2031,"id":222046,"goal":"method BinarySearch_2031(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_2032","instance":2032,"id":222047,"goal":"method InsertSort_2032(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_2033","instance":2033,"id":222048,"goal":"method MergeSort_2033(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_2034","instance":2034,"id":222049,"goal":"method ArrayCopy_2034(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_2035","instance":2035,"id":222050,"goal":"function ListReverse_2035(s: seq): seq\n ensures |ListReverse_2035(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_2035(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_2036","instance":2036,"id":222051,"goal":"function Factorial_2036(n: nat): nat\n ensures Factorial_2036(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_2036(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_2037","instance":2037,"id":222052,"goal":"function Fib_2037(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_2037(n-1) + Fib_2037(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_2038","instance":2038,"id":222053,"goal":"function Gcd_2038(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_2038(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_2039","instance":2039,"id":222054,"goal":"function Power_2039(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_2039(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_2040","instance":2040,"id":222055,"goal":"function Sum_2040(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_2040(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_2041","instance":2041,"id":222056,"goal":"method BinarySearch_2041(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_2042","instance":2042,"id":222057,"goal":"method InsertSort_2042(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_2043","instance":2043,"id":222058,"goal":"method MergeSort_2043(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_2044","instance":2044,"id":222059,"goal":"method ArrayCopy_2044(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_2045","instance":2045,"id":222060,"goal":"function ListReverse_2045(s: seq): seq\n ensures |ListReverse_2045(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_2045(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_2046","instance":2046,"id":222061,"goal":"function Factorial_2046(n: nat): nat\n ensures Factorial_2046(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_2046(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_2047","instance":2047,"id":222062,"goal":"function Fib_2047(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_2047(n-1) + Fib_2047(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_2048","instance":2048,"id":222063,"goal":"function Gcd_2048(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_2048(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_2049","instance":2049,"id":222064,"goal":"function Power_2049(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_2049(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_2050","instance":2050,"id":222065,"goal":"function Sum_2050(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_2050(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_2051","instance":2051,"id":222066,"goal":"method BinarySearch_2051(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_2052","instance":2052,"id":222067,"goal":"method InsertSort_2052(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_2053","instance":2053,"id":222068,"goal":"method MergeSort_2053(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_2054","instance":2054,"id":222069,"goal":"method ArrayCopy_2054(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_2055","instance":2055,"id":222070,"goal":"function ListReverse_2055(s: seq): seq\n ensures |ListReverse_2055(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_2055(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_2056","instance":2056,"id":222071,"goal":"function Factorial_2056(n: nat): nat\n ensures Factorial_2056(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_2056(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_2057","instance":2057,"id":222072,"goal":"function Fib_2057(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_2057(n-1) + Fib_2057(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_2058","instance":2058,"id":222073,"goal":"function Gcd_2058(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_2058(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_2059","instance":2059,"id":222074,"goal":"function Power_2059(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_2059(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_2060","instance":2060,"id":222075,"goal":"function Sum_2060(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_2060(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_2061","instance":2061,"id":222076,"goal":"method BinarySearch_2061(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_2062","instance":2062,"id":222077,"goal":"method InsertSort_2062(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_2063","instance":2063,"id":222078,"goal":"method MergeSort_2063(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_2064","instance":2064,"id":222079,"goal":"method ArrayCopy_2064(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_2065","instance":2065,"id":222080,"goal":"function ListReverse_2065(s: seq): seq\n ensures |ListReverse_2065(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_2065(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_2066","instance":2066,"id":222081,"goal":"function Factorial_2066(n: nat): nat\n ensures Factorial_2066(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_2066(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_2067","instance":2067,"id":222082,"goal":"function Fib_2067(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_2067(n-1) + Fib_2067(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_2068","instance":2068,"id":222083,"goal":"function Gcd_2068(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_2068(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_2069","instance":2069,"id":222084,"goal":"function Power_2069(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_2069(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_2070","instance":2070,"id":222085,"goal":"function Sum_2070(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_2070(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_2071","instance":2071,"id":222086,"goal":"method BinarySearch_2071(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_2072","instance":2072,"id":222087,"goal":"method InsertSort_2072(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_2073","instance":2073,"id":222088,"goal":"method MergeSort_2073(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_2074","instance":2074,"id":222089,"goal":"method ArrayCopy_2074(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_2075","instance":2075,"id":222090,"goal":"function ListReverse_2075(s: seq): seq\n ensures |ListReverse_2075(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_2075(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_2076","instance":2076,"id":222091,"goal":"function Factorial_2076(n: nat): nat\n ensures Factorial_2076(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_2076(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_2077","instance":2077,"id":222092,"goal":"function Fib_2077(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_2077(n-1) + Fib_2077(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_2078","instance":2078,"id":222093,"goal":"function Gcd_2078(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_2078(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_2079","instance":2079,"id":222094,"goal":"function Power_2079(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_2079(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_2080","instance":2080,"id":222095,"goal":"function Sum_2080(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_2080(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_2081","instance":2081,"id":222096,"goal":"method BinarySearch_2081(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_2082","instance":2082,"id":222097,"goal":"method InsertSort_2082(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_2083","instance":2083,"id":222098,"goal":"method MergeSort_2083(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_2084","instance":2084,"id":222099,"goal":"method ArrayCopy_2084(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_2085","instance":2085,"id":222100,"goal":"function ListReverse_2085(s: seq): seq\n ensures |ListReverse_2085(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_2085(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_2086","instance":2086,"id":222101,"goal":"function Factorial_2086(n: nat): nat\n ensures Factorial_2086(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_2086(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_2087","instance":2087,"id":222102,"goal":"function Fib_2087(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_2087(n-1) + Fib_2087(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_2088","instance":2088,"id":222103,"goal":"function Gcd_2088(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_2088(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_2089","instance":2089,"id":222104,"goal":"function Power_2089(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_2089(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_2090","instance":2090,"id":222105,"goal":"function Sum_2090(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_2090(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_2091","instance":2091,"id":222106,"goal":"method BinarySearch_2091(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_2092","instance":2092,"id":222107,"goal":"method InsertSort_2092(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_2093","instance":2093,"id":222108,"goal":"method MergeSort_2093(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_2094","instance":2094,"id":222109,"goal":"method ArrayCopy_2094(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_2095","instance":2095,"id":222110,"goal":"function ListReverse_2095(s: seq): seq\n ensures |ListReverse_2095(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_2095(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_2096","instance":2096,"id":222111,"goal":"function Factorial_2096(n: nat): nat\n ensures Factorial_2096(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_2096(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_2097","instance":2097,"id":222112,"goal":"function Fib_2097(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_2097(n-1) + Fib_2097(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_2098","instance":2098,"id":222113,"goal":"function Gcd_2098(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_2098(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_2099","instance":2099,"id":222114,"goal":"function Power_2099(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_2099(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_2100","instance":2100,"id":222115,"goal":"function Sum_2100(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_2100(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_2101","instance":2101,"id":222116,"goal":"method BinarySearch_2101(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_2102","instance":2102,"id":222117,"goal":"method InsertSort_2102(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_2103","instance":2103,"id":222118,"goal":"method MergeSort_2103(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_2104","instance":2104,"id":222119,"goal":"method ArrayCopy_2104(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_2105","instance":2105,"id":222120,"goal":"function ListReverse_2105(s: seq): seq\n ensures |ListReverse_2105(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_2105(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_2106","instance":2106,"id":222121,"goal":"function Factorial_2106(n: nat): nat\n ensures Factorial_2106(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_2106(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_2107","instance":2107,"id":222122,"goal":"function Fib_2107(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_2107(n-1) + Fib_2107(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_2108","instance":2108,"id":222123,"goal":"function Gcd_2108(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_2108(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_2109","instance":2109,"id":222124,"goal":"function Power_2109(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_2109(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_2110","instance":2110,"id":222125,"goal":"function Sum_2110(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_2110(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_2111","instance":2111,"id":222126,"goal":"method BinarySearch_2111(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_2112","instance":2112,"id":222127,"goal":"method InsertSort_2112(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_2113","instance":2113,"id":222128,"goal":"method MergeSort_2113(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_2114","instance":2114,"id":222129,"goal":"method ArrayCopy_2114(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_2115","instance":2115,"id":222130,"goal":"function ListReverse_2115(s: seq): seq\n ensures |ListReverse_2115(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_2115(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_2116","instance":2116,"id":222131,"goal":"function Factorial_2116(n: nat): nat\n ensures Factorial_2116(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_2116(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_2117","instance":2117,"id":222132,"goal":"function Fib_2117(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_2117(n-1) + Fib_2117(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_2118","instance":2118,"id":222133,"goal":"function Gcd_2118(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_2118(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_2119","instance":2119,"id":222134,"goal":"function Power_2119(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_2119(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_2120","instance":2120,"id":222135,"goal":"function Sum_2120(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_2120(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_2121","instance":2121,"id":222136,"goal":"method BinarySearch_2121(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_2122","instance":2122,"id":222137,"goal":"method InsertSort_2122(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_2123","instance":2123,"id":222138,"goal":"method MergeSort_2123(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_2124","instance":2124,"id":222139,"goal":"method ArrayCopy_2124(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_2125","instance":2125,"id":222140,"goal":"function ListReverse_2125(s: seq): seq\n ensures |ListReverse_2125(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_2125(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_2126","instance":2126,"id":222141,"goal":"function Factorial_2126(n: nat): nat\n ensures Factorial_2126(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_2126(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_2127","instance":2127,"id":222142,"goal":"function Fib_2127(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_2127(n-1) + Fib_2127(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_2128","instance":2128,"id":222143,"goal":"function Gcd_2128(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_2128(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_2129","instance":2129,"id":222144,"goal":"function Power_2129(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_2129(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_2130","instance":2130,"id":222145,"goal":"function Sum_2130(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_2130(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_2131","instance":2131,"id":222146,"goal":"method BinarySearch_2131(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_2132","instance":2132,"id":222147,"goal":"method InsertSort_2132(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_2133","instance":2133,"id":222148,"goal":"method MergeSort_2133(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_2134","instance":2134,"id":222149,"goal":"method ArrayCopy_2134(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_2135","instance":2135,"id":222150,"goal":"function ListReverse_2135(s: seq): seq\n ensures |ListReverse_2135(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_2135(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_2136","instance":2136,"id":222151,"goal":"function Factorial_2136(n: nat): nat\n ensures Factorial_2136(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_2136(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_2137","instance":2137,"id":222152,"goal":"function Fib_2137(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_2137(n-1) + Fib_2137(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_2138","instance":2138,"id":222153,"goal":"function Gcd_2138(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_2138(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_2139","instance":2139,"id":222154,"goal":"function Power_2139(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_2139(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_2140","instance":2140,"id":222155,"goal":"function Sum_2140(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_2140(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_2141","instance":2141,"id":222156,"goal":"method BinarySearch_2141(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_2142","instance":2142,"id":222157,"goal":"method InsertSort_2142(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_2143","instance":2143,"id":222158,"goal":"method MergeSort_2143(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_2144","instance":2144,"id":222159,"goal":"method ArrayCopy_2144(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_2145","instance":2145,"id":222160,"goal":"function ListReverse_2145(s: seq): seq\n ensures |ListReverse_2145(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_2145(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_2146","instance":2146,"id":222161,"goal":"function Factorial_2146(n: nat): nat\n ensures Factorial_2146(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_2146(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_2147","instance":2147,"id":222162,"goal":"function Fib_2147(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_2147(n-1) + Fib_2147(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_2148","instance":2148,"id":222163,"goal":"function Gcd_2148(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_2148(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_2149","instance":2149,"id":222164,"goal":"function Power_2149(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_2149(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_2150","instance":2150,"id":222165,"goal":"function Sum_2150(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_2150(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_2151","instance":2151,"id":222166,"goal":"method BinarySearch_2151(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_2152","instance":2152,"id":222167,"goal":"method InsertSort_2152(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_2153","instance":2153,"id":222168,"goal":"method MergeSort_2153(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_2154","instance":2154,"id":222169,"goal":"method ArrayCopy_2154(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_2155","instance":2155,"id":222170,"goal":"function ListReverse_2155(s: seq): seq\n ensures |ListReverse_2155(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_2155(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_2156","instance":2156,"id":222171,"goal":"function Factorial_2156(n: nat): nat\n ensures Factorial_2156(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_2156(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_2157","instance":2157,"id":222172,"goal":"function Fib_2157(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_2157(n-1) + Fib_2157(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_2158","instance":2158,"id":222173,"goal":"function Gcd_2158(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_2158(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_2159","instance":2159,"id":222174,"goal":"function Power_2159(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_2159(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_2160","instance":2160,"id":222175,"goal":"function Sum_2160(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_2160(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_2161","instance":2161,"id":222176,"goal":"method BinarySearch_2161(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_2162","instance":2162,"id":222177,"goal":"method InsertSort_2162(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_2163","instance":2163,"id":222178,"goal":"method MergeSort_2163(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_2164","instance":2164,"id":222179,"goal":"method ArrayCopy_2164(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_2165","instance":2165,"id":222180,"goal":"function ListReverse_2165(s: seq): seq\n ensures |ListReverse_2165(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_2165(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_2166","instance":2166,"id":222181,"goal":"function Factorial_2166(n: nat): nat\n ensures Factorial_2166(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_2166(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_2167","instance":2167,"id":222182,"goal":"function Fib_2167(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_2167(n-1) + Fib_2167(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_2168","instance":2168,"id":222183,"goal":"function Gcd_2168(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_2168(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_2169","instance":2169,"id":222184,"goal":"function Power_2169(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_2169(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_2170","instance":2170,"id":222185,"goal":"function Sum_2170(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_2170(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_2171","instance":2171,"id":222186,"goal":"method BinarySearch_2171(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_2172","instance":2172,"id":222187,"goal":"method InsertSort_2172(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_2173","instance":2173,"id":222188,"goal":"method MergeSort_2173(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_2174","instance":2174,"id":222189,"goal":"method ArrayCopy_2174(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_2175","instance":2175,"id":222190,"goal":"function ListReverse_2175(s: seq): seq\n ensures |ListReverse_2175(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_2175(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_2176","instance":2176,"id":222191,"goal":"function Factorial_2176(n: nat): nat\n ensures Factorial_2176(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_2176(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_2177","instance":2177,"id":222192,"goal":"function Fib_2177(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_2177(n-1) + Fib_2177(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_2178","instance":2178,"id":222193,"goal":"function Gcd_2178(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_2178(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_2179","instance":2179,"id":222194,"goal":"function Power_2179(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_2179(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_2180","instance":2180,"id":222195,"goal":"function Sum_2180(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_2180(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_2181","instance":2181,"id":222196,"goal":"method BinarySearch_2181(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_2182","instance":2182,"id":222197,"goal":"method InsertSort_2182(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_2183","instance":2183,"id":222198,"goal":"method MergeSort_2183(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_2184","instance":2184,"id":222199,"goal":"method ArrayCopy_2184(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_2185","instance":2185,"id":222200,"goal":"function ListReverse_2185(s: seq): seq\n ensures |ListReverse_2185(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_2185(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_2186","instance":2186,"id":222201,"goal":"function Factorial_2186(n: nat): nat\n ensures Factorial_2186(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_2186(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_2187","instance":2187,"id":222202,"goal":"function Fib_2187(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_2187(n-1) + Fib_2187(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_2188","instance":2188,"id":222203,"goal":"function Gcd_2188(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_2188(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_2189","instance":2189,"id":222204,"goal":"function Power_2189(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_2189(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_2190","instance":2190,"id":222205,"goal":"function Sum_2190(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_2190(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_2191","instance":2191,"id":222206,"goal":"method BinarySearch_2191(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_2192","instance":2192,"id":222207,"goal":"method InsertSort_2192(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_2193","instance":2193,"id":222208,"goal":"method MergeSort_2193(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_2194","instance":2194,"id":222209,"goal":"method ArrayCopy_2194(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_2195","instance":2195,"id":222210,"goal":"function ListReverse_2195(s: seq): seq\n ensures |ListReverse_2195(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_2195(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_2196","instance":2196,"id":222211,"goal":"function Factorial_2196(n: nat): nat\n ensures Factorial_2196(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_2196(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_2197","instance":2197,"id":222212,"goal":"function Fib_2197(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_2197(n-1) + Fib_2197(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_2198","instance":2198,"id":222213,"goal":"function Gcd_2198(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_2198(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_2199","instance":2199,"id":222214,"goal":"function Power_2199(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_2199(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_2200","instance":2200,"id":222215,"goal":"function Sum_2200(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_2200(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_2201","instance":2201,"id":222216,"goal":"method BinarySearch_2201(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_2202","instance":2202,"id":222217,"goal":"method InsertSort_2202(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_2203","instance":2203,"id":222218,"goal":"method MergeSort_2203(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_2204","instance":2204,"id":222219,"goal":"method ArrayCopy_2204(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_2205","instance":2205,"id":222220,"goal":"function ListReverse_2205(s: seq): seq\n ensures |ListReverse_2205(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_2205(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_2206","instance":2206,"id":222221,"goal":"function Factorial_2206(n: nat): nat\n ensures Factorial_2206(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_2206(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_2207","instance":2207,"id":222222,"goal":"function Fib_2207(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_2207(n-1) + Fib_2207(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_2208","instance":2208,"id":222223,"goal":"function Gcd_2208(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_2208(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_2209","instance":2209,"id":222224,"goal":"function Power_2209(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_2209(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_2210","instance":2210,"id":222225,"goal":"function Sum_2210(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_2210(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_2211","instance":2211,"id":222226,"goal":"method BinarySearch_2211(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_2212","instance":2212,"id":222227,"goal":"method InsertSort_2212(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_2213","instance":2213,"id":222228,"goal":"method MergeSort_2213(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_2214","instance":2214,"id":222229,"goal":"method ArrayCopy_2214(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_2215","instance":2215,"id":222230,"goal":"function ListReverse_2215(s: seq): seq\n ensures |ListReverse_2215(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_2215(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_2216","instance":2216,"id":222231,"goal":"function Factorial_2216(n: nat): nat\n ensures Factorial_2216(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_2216(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_2217","instance":2217,"id":222232,"goal":"function Fib_2217(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_2217(n-1) + Fib_2217(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_2218","instance":2218,"id":222233,"goal":"function Gcd_2218(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_2218(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_2219","instance":2219,"id":222234,"goal":"function Power_2219(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_2219(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_2220","instance":2220,"id":222235,"goal":"function Sum_2220(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_2220(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_2221","instance":2221,"id":222236,"goal":"method BinarySearch_2221(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_2222","instance":2222,"id":222237,"goal":"method InsertSort_2222(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_2223","instance":2223,"id":222238,"goal":"method MergeSort_2223(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_2224","instance":2224,"id":222239,"goal":"method ArrayCopy_2224(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_2225","instance":2225,"id":222240,"goal":"function ListReverse_2225(s: seq): seq\n ensures |ListReverse_2225(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_2225(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_2226","instance":2226,"id":222241,"goal":"function Factorial_2226(n: nat): nat\n ensures Factorial_2226(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_2226(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_2227","instance":2227,"id":222242,"goal":"function Fib_2227(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_2227(n-1) + Fib_2227(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_2228","instance":2228,"id":222243,"goal":"function Gcd_2228(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_2228(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_2229","instance":2229,"id":222244,"goal":"function Power_2229(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_2229(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_2230","instance":2230,"id":222245,"goal":"function Sum_2230(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_2230(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_2231","instance":2231,"id":222246,"goal":"method BinarySearch_2231(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_2232","instance":2232,"id":222247,"goal":"method InsertSort_2232(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_2233","instance":2233,"id":222248,"goal":"method MergeSort_2233(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_2234","instance":2234,"id":222249,"goal":"method ArrayCopy_2234(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_2235","instance":2235,"id":222250,"goal":"function ListReverse_2235(s: seq): seq\n ensures |ListReverse_2235(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_2235(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_2236","instance":2236,"id":222251,"goal":"function Factorial_2236(n: nat): nat\n ensures Factorial_2236(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_2236(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_2237","instance":2237,"id":222252,"goal":"function Fib_2237(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_2237(n-1) + Fib_2237(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_2238","instance":2238,"id":222253,"goal":"function Gcd_2238(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_2238(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_2239","instance":2239,"id":222254,"goal":"function Power_2239(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_2239(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_2240","instance":2240,"id":222255,"goal":"function Sum_2240(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_2240(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_2241","instance":2241,"id":222256,"goal":"method BinarySearch_2241(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_2242","instance":2242,"id":222257,"goal":"method InsertSort_2242(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_2243","instance":2243,"id":222258,"goal":"method MergeSort_2243(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_2244","instance":2244,"id":222259,"goal":"method ArrayCopy_2244(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_2245","instance":2245,"id":222260,"goal":"function ListReverse_2245(s: seq): seq\n ensures |ListReverse_2245(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_2245(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_2246","instance":2246,"id":222261,"goal":"function Factorial_2246(n: nat): nat\n ensures Factorial_2246(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_2246(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_2247","instance":2247,"id":222262,"goal":"function Fib_2247(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_2247(n-1) + Fib_2247(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_2248","instance":2248,"id":222263,"goal":"function Gcd_2248(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_2248(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_2249","instance":2249,"id":222264,"goal":"function Power_2249(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_2249(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_2250","instance":2250,"id":222265,"goal":"function Sum_2250(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_2250(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_2251","instance":2251,"id":222266,"goal":"method BinarySearch_2251(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_2252","instance":2252,"id":222267,"goal":"method InsertSort_2252(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_2253","instance":2253,"id":222268,"goal":"method MergeSort_2253(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_2254","instance":2254,"id":222269,"goal":"method ArrayCopy_2254(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_2255","instance":2255,"id":222270,"goal":"function ListReverse_2255(s: seq): seq\n ensures |ListReverse_2255(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_2255(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_2256","instance":2256,"id":222271,"goal":"function Factorial_2256(n: nat): nat\n ensures Factorial_2256(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_2256(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_2257","instance":2257,"id":222272,"goal":"function Fib_2257(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_2257(n-1) + Fib_2257(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_2258","instance":2258,"id":222273,"goal":"function Gcd_2258(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_2258(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_2259","instance":2259,"id":222274,"goal":"function Power_2259(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_2259(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_2260","instance":2260,"id":222275,"goal":"function Sum_2260(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_2260(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_2261","instance":2261,"id":222276,"goal":"method BinarySearch_2261(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_2262","instance":2262,"id":222277,"goal":"method InsertSort_2262(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_2263","instance":2263,"id":222278,"goal":"method MergeSort_2263(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_2264","instance":2264,"id":222279,"goal":"method ArrayCopy_2264(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_2265","instance":2265,"id":222280,"goal":"function ListReverse_2265(s: seq): seq\n ensures |ListReverse_2265(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_2265(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_2266","instance":2266,"id":222281,"goal":"function Factorial_2266(n: nat): nat\n ensures Factorial_2266(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_2266(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_2267","instance":2267,"id":222282,"goal":"function Fib_2267(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_2267(n-1) + Fib_2267(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_2268","instance":2268,"id":222283,"goal":"function Gcd_2268(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_2268(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_2269","instance":2269,"id":222284,"goal":"function Power_2269(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_2269(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_2270","instance":2270,"id":222285,"goal":"function Sum_2270(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_2270(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_2271","instance":2271,"id":222286,"goal":"method BinarySearch_2271(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_2272","instance":2272,"id":222287,"goal":"method InsertSort_2272(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_2273","instance":2273,"id":222288,"goal":"method MergeSort_2273(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_2274","instance":2274,"id":222289,"goal":"method ArrayCopy_2274(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_2275","instance":2275,"id":222290,"goal":"function ListReverse_2275(s: seq): seq\n ensures |ListReverse_2275(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_2275(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_2276","instance":2276,"id":222291,"goal":"function Factorial_2276(n: nat): nat\n ensures Factorial_2276(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_2276(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_2277","instance":2277,"id":222292,"goal":"function Fib_2277(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_2277(n-1) + Fib_2277(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_2278","instance":2278,"id":222293,"goal":"function Gcd_2278(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_2278(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_2279","instance":2279,"id":222294,"goal":"function Power_2279(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_2279(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_2280","instance":2280,"id":222295,"goal":"function Sum_2280(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_2280(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_2281","instance":2281,"id":222296,"goal":"method BinarySearch_2281(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_2282","instance":2282,"id":222297,"goal":"method InsertSort_2282(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_2283","instance":2283,"id":222298,"goal":"method MergeSort_2283(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_2284","instance":2284,"id":222299,"goal":"method ArrayCopy_2284(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_2285","instance":2285,"id":222300,"goal":"function ListReverse_2285(s: seq): seq\n ensures |ListReverse_2285(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_2285(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_2286","instance":2286,"id":222301,"goal":"function Factorial_2286(n: nat): nat\n ensures Factorial_2286(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_2286(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_2287","instance":2287,"id":222302,"goal":"function Fib_2287(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_2287(n-1) + Fib_2287(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_2288","instance":2288,"id":222303,"goal":"function Gcd_2288(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_2288(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_2289","instance":2289,"id":222304,"goal":"function Power_2289(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_2289(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_2290","instance":2290,"id":222305,"goal":"function Sum_2290(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_2290(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_2291","instance":2291,"id":222306,"goal":"method BinarySearch_2291(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_2292","instance":2292,"id":222307,"goal":"method InsertSort_2292(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_2293","instance":2293,"id":222308,"goal":"method MergeSort_2293(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_2294","instance":2294,"id":222309,"goal":"method ArrayCopy_2294(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_2295","instance":2295,"id":222310,"goal":"function ListReverse_2295(s: seq): seq\n ensures |ListReverse_2295(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_2295(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_2296","instance":2296,"id":222311,"goal":"function Factorial_2296(n: nat): nat\n ensures Factorial_2296(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_2296(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_2297","instance":2297,"id":222312,"goal":"function Fib_2297(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_2297(n-1) + Fib_2297(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_2298","instance":2298,"id":222313,"goal":"function Gcd_2298(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_2298(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_2299","instance":2299,"id":222314,"goal":"function Power_2299(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_2299(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_2300","instance":2300,"id":222315,"goal":"function Sum_2300(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_2300(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_2301","instance":2301,"id":222316,"goal":"method BinarySearch_2301(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_2302","instance":2302,"id":222317,"goal":"method InsertSort_2302(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_2303","instance":2303,"id":222318,"goal":"method MergeSort_2303(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_2304","instance":2304,"id":222319,"goal":"method ArrayCopy_2304(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_2305","instance":2305,"id":222320,"goal":"function ListReverse_2305(s: seq): seq\n ensures |ListReverse_2305(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_2305(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_2306","instance":2306,"id":222321,"goal":"function Factorial_2306(n: nat): nat\n ensures Factorial_2306(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_2306(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_2307","instance":2307,"id":222322,"goal":"function Fib_2307(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_2307(n-1) + Fib_2307(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_2308","instance":2308,"id":222323,"goal":"function Gcd_2308(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_2308(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_2309","instance":2309,"id":222324,"goal":"function Power_2309(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_2309(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_2310","instance":2310,"id":222325,"goal":"function Sum_2310(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_2310(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_2311","instance":2311,"id":222326,"goal":"method BinarySearch_2311(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_2312","instance":2312,"id":222327,"goal":"method InsertSort_2312(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_2313","instance":2313,"id":222328,"goal":"method MergeSort_2313(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_2314","instance":2314,"id":222329,"goal":"method ArrayCopy_2314(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_2315","instance":2315,"id":222330,"goal":"function ListReverse_2315(s: seq): seq\n ensures |ListReverse_2315(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_2315(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_2316","instance":2316,"id":222331,"goal":"function Factorial_2316(n: nat): nat\n ensures Factorial_2316(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_2316(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_2317","instance":2317,"id":222332,"goal":"function Fib_2317(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_2317(n-1) + Fib_2317(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_2318","instance":2318,"id":222333,"goal":"function Gcd_2318(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_2318(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_2319","instance":2319,"id":222334,"goal":"function Power_2319(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_2319(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_2320","instance":2320,"id":222335,"goal":"function Sum_2320(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_2320(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_2321","instance":2321,"id":222336,"goal":"method BinarySearch_2321(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_2322","instance":2322,"id":222337,"goal":"method InsertSort_2322(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_2323","instance":2323,"id":222338,"goal":"method MergeSort_2323(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_2324","instance":2324,"id":222339,"goal":"method ArrayCopy_2324(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_2325","instance":2325,"id":222340,"goal":"function ListReverse_2325(s: seq): seq\n ensures |ListReverse_2325(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_2325(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_2326","instance":2326,"id":222341,"goal":"function Factorial_2326(n: nat): nat\n ensures Factorial_2326(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_2326(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_2327","instance":2327,"id":222342,"goal":"function Fib_2327(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_2327(n-1) + Fib_2327(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_2328","instance":2328,"id":222343,"goal":"function Gcd_2328(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_2328(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_2329","instance":2329,"id":222344,"goal":"function Power_2329(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_2329(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_2330","instance":2330,"id":222345,"goal":"function Sum_2330(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_2330(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_2331","instance":2331,"id":222346,"goal":"method BinarySearch_2331(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_2332","instance":2332,"id":222347,"goal":"method InsertSort_2332(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_2333","instance":2333,"id":222348,"goal":"method MergeSort_2333(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_2334","instance":2334,"id":222349,"goal":"method ArrayCopy_2334(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_2335","instance":2335,"id":222350,"goal":"function ListReverse_2335(s: seq): seq\n ensures |ListReverse_2335(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_2335(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_2336","instance":2336,"id":222351,"goal":"function Factorial_2336(n: nat): nat\n ensures Factorial_2336(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_2336(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_2337","instance":2337,"id":222352,"goal":"function Fib_2337(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_2337(n-1) + Fib_2337(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_2338","instance":2338,"id":222353,"goal":"function Gcd_2338(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_2338(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_2339","instance":2339,"id":222354,"goal":"function Power_2339(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_2339(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_2340","instance":2340,"id":222355,"goal":"function Sum_2340(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_2340(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_2341","instance":2341,"id":222356,"goal":"method BinarySearch_2341(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_2342","instance":2342,"id":222357,"goal":"method InsertSort_2342(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_2343","instance":2343,"id":222358,"goal":"method MergeSort_2343(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_2344","instance":2344,"id":222359,"goal":"method ArrayCopy_2344(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_2345","instance":2345,"id":222360,"goal":"function ListReverse_2345(s: seq): seq\n ensures |ListReverse_2345(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_2345(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_2346","instance":2346,"id":222361,"goal":"function Factorial_2346(n: nat): nat\n ensures Factorial_2346(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_2346(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_2347","instance":2347,"id":222362,"goal":"function Fib_2347(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_2347(n-1) + Fib_2347(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_2348","instance":2348,"id":222363,"goal":"function Gcd_2348(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_2348(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_2349","instance":2349,"id":222364,"goal":"function Power_2349(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_2349(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_2350","instance":2350,"id":222365,"goal":"function Sum_2350(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_2350(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_2351","instance":2351,"id":222366,"goal":"method BinarySearch_2351(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_2352","instance":2352,"id":222367,"goal":"method InsertSort_2352(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_2353","instance":2353,"id":222368,"goal":"method MergeSort_2353(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_2354","instance":2354,"id":222369,"goal":"method ArrayCopy_2354(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_2355","instance":2355,"id":222370,"goal":"function ListReverse_2355(s: seq): seq\n ensures |ListReverse_2355(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_2355(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_2356","instance":2356,"id":222371,"goal":"function Factorial_2356(n: nat): nat\n ensures Factorial_2356(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_2356(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_2357","instance":2357,"id":222372,"goal":"function Fib_2357(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_2357(n-1) + Fib_2357(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_2358","instance":2358,"id":222373,"goal":"function Gcd_2358(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_2358(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_2359","instance":2359,"id":222374,"goal":"function Power_2359(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_2359(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_2360","instance":2360,"id":222375,"goal":"function Sum_2360(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_2360(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_2361","instance":2361,"id":222376,"goal":"method BinarySearch_2361(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_2362","instance":2362,"id":222377,"goal":"method InsertSort_2362(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_2363","instance":2363,"id":222378,"goal":"method MergeSort_2363(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_2364","instance":2364,"id":222379,"goal":"method ArrayCopy_2364(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_2365","instance":2365,"id":222380,"goal":"function ListReverse_2365(s: seq): seq\n ensures |ListReverse_2365(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_2365(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_2366","instance":2366,"id":222381,"goal":"function Factorial_2366(n: nat): nat\n ensures Factorial_2366(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_2366(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_2367","instance":2367,"id":222382,"goal":"function Fib_2367(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_2367(n-1) + Fib_2367(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_2368","instance":2368,"id":222383,"goal":"function Gcd_2368(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_2368(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_2369","instance":2369,"id":222384,"goal":"function Power_2369(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_2369(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_2370","instance":2370,"id":222385,"goal":"function Sum_2370(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_2370(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_2371","instance":2371,"id":222386,"goal":"method BinarySearch_2371(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_2372","instance":2372,"id":222387,"goal":"method InsertSort_2372(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_2373","instance":2373,"id":222388,"goal":"method MergeSort_2373(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_2374","instance":2374,"id":222389,"goal":"method ArrayCopy_2374(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_2375","instance":2375,"id":222390,"goal":"function ListReverse_2375(s: seq): seq\n ensures |ListReverse_2375(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_2375(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_2376","instance":2376,"id":222391,"goal":"function Factorial_2376(n: nat): nat\n ensures Factorial_2376(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_2376(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_2377","instance":2377,"id":222392,"goal":"function Fib_2377(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_2377(n-1) + Fib_2377(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_2378","instance":2378,"id":222393,"goal":"function Gcd_2378(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_2378(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_2379","instance":2379,"id":222394,"goal":"function Power_2379(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_2379(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_2380","instance":2380,"id":222395,"goal":"function Sum_2380(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_2380(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_2381","instance":2381,"id":222396,"goal":"method BinarySearch_2381(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_2382","instance":2382,"id":222397,"goal":"method InsertSort_2382(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_2383","instance":2383,"id":222398,"goal":"method MergeSort_2383(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_2384","instance":2384,"id":222399,"goal":"method ArrayCopy_2384(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_2385","instance":2385,"id":222400,"goal":"function ListReverse_2385(s: seq): seq\n ensures |ListReverse_2385(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_2385(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_2386","instance":2386,"id":222401,"goal":"function Factorial_2386(n: nat): nat\n ensures Factorial_2386(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_2386(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_2387","instance":2387,"id":222402,"goal":"function Fib_2387(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_2387(n-1) + Fib_2387(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_2388","instance":2388,"id":222403,"goal":"function Gcd_2388(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_2388(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_2389","instance":2389,"id":222404,"goal":"function Power_2389(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_2389(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_2390","instance":2390,"id":222405,"goal":"function Sum_2390(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_2390(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_2391","instance":2391,"id":222406,"goal":"method BinarySearch_2391(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_2392","instance":2392,"id":222407,"goal":"method InsertSort_2392(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_2393","instance":2393,"id":222408,"goal":"method MergeSort_2393(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_2394","instance":2394,"id":222409,"goal":"method ArrayCopy_2394(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_2395","instance":2395,"id":222410,"goal":"function ListReverse_2395(s: seq): seq\n ensures |ListReverse_2395(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_2395(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_2396","instance":2396,"id":222411,"goal":"function Factorial_2396(n: nat): nat\n ensures Factorial_2396(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_2396(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_2397","instance":2397,"id":222412,"goal":"function Fib_2397(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_2397(n-1) + Fib_2397(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_2398","instance":2398,"id":222413,"goal":"function Gcd_2398(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_2398(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_2399","instance":2399,"id":222414,"goal":"function Power_2399(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_2399(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_2400","instance":2400,"id":222415,"goal":"function Sum_2400(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_2400(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_2401","instance":2401,"id":222416,"goal":"method BinarySearch_2401(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_2402","instance":2402,"id":222417,"goal":"method InsertSort_2402(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_2403","instance":2403,"id":222418,"goal":"method MergeSort_2403(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_2404","instance":2404,"id":222419,"goal":"method ArrayCopy_2404(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_2405","instance":2405,"id":222420,"goal":"function ListReverse_2405(s: seq): seq\n ensures |ListReverse_2405(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_2405(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_2406","instance":2406,"id":222421,"goal":"function Factorial_2406(n: nat): nat\n ensures Factorial_2406(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_2406(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_2407","instance":2407,"id":222422,"goal":"function Fib_2407(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_2407(n-1) + Fib_2407(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_2408","instance":2408,"id":222423,"goal":"function Gcd_2408(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_2408(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_2409","instance":2409,"id":222424,"goal":"function Power_2409(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_2409(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_2410","instance":2410,"id":222425,"goal":"function Sum_2410(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_2410(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_2411","instance":2411,"id":222426,"goal":"method BinarySearch_2411(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_2412","instance":2412,"id":222427,"goal":"method InsertSort_2412(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_2413","instance":2413,"id":222428,"goal":"method MergeSort_2413(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_2414","instance":2414,"id":222429,"goal":"method ArrayCopy_2414(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_2415","instance":2415,"id":222430,"goal":"function ListReverse_2415(s: seq): seq\n ensures |ListReverse_2415(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_2415(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_2416","instance":2416,"id":222431,"goal":"function Factorial_2416(n: nat): nat\n ensures Factorial_2416(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_2416(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_2417","instance":2417,"id":222432,"goal":"function Fib_2417(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_2417(n-1) + Fib_2417(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_2418","instance":2418,"id":222433,"goal":"function Gcd_2418(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_2418(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_2419","instance":2419,"id":222434,"goal":"function Power_2419(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_2419(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_2420","instance":2420,"id":222435,"goal":"function Sum_2420(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_2420(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_2421","instance":2421,"id":222436,"goal":"method BinarySearch_2421(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_2422","instance":2422,"id":222437,"goal":"method InsertSort_2422(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_2423","instance":2423,"id":222438,"goal":"method MergeSort_2423(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_2424","instance":2424,"id":222439,"goal":"method ArrayCopy_2424(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_2425","instance":2425,"id":222440,"goal":"function ListReverse_2425(s: seq): seq\n ensures |ListReverse_2425(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_2425(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_2426","instance":2426,"id":222441,"goal":"function Factorial_2426(n: nat): nat\n ensures Factorial_2426(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_2426(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_2427","instance":2427,"id":222442,"goal":"function Fib_2427(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_2427(n-1) + Fib_2427(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_2428","instance":2428,"id":222443,"goal":"function Gcd_2428(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_2428(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_2429","instance":2429,"id":222444,"goal":"function Power_2429(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_2429(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_2430","instance":2430,"id":222445,"goal":"function Sum_2430(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_2430(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_2431","instance":2431,"id":222446,"goal":"method BinarySearch_2431(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_2432","instance":2432,"id":222447,"goal":"method InsertSort_2432(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_2433","instance":2433,"id":222448,"goal":"method MergeSort_2433(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_2434","instance":2434,"id":222449,"goal":"method ArrayCopy_2434(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_2435","instance":2435,"id":222450,"goal":"function ListReverse_2435(s: seq): seq\n ensures |ListReverse_2435(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_2435(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_2436","instance":2436,"id":222451,"goal":"function Factorial_2436(n: nat): nat\n ensures Factorial_2436(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_2436(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_2437","instance":2437,"id":222452,"goal":"function Fib_2437(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_2437(n-1) + Fib_2437(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_2438","instance":2438,"id":222453,"goal":"function Gcd_2438(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_2438(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_2439","instance":2439,"id":222454,"goal":"function Power_2439(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_2439(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_2440","instance":2440,"id":222455,"goal":"function Sum_2440(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_2440(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_2441","instance":2441,"id":222456,"goal":"method BinarySearch_2441(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_2442","instance":2442,"id":222457,"goal":"method InsertSort_2442(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_2443","instance":2443,"id":222458,"goal":"method MergeSort_2443(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_2444","instance":2444,"id":222459,"goal":"method ArrayCopy_2444(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_2445","instance":2445,"id":222460,"goal":"function ListReverse_2445(s: seq): seq\n ensures |ListReverse_2445(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_2445(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_2446","instance":2446,"id":222461,"goal":"function Factorial_2446(n: nat): nat\n ensures Factorial_2446(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_2446(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_2447","instance":2447,"id":222462,"goal":"function Fib_2447(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_2447(n-1) + Fib_2447(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_2448","instance":2448,"id":222463,"goal":"function Gcd_2448(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_2448(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_2449","instance":2449,"id":222464,"goal":"function Power_2449(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_2449(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_2450","instance":2450,"id":222465,"goal":"function Sum_2450(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_2450(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_2451","instance":2451,"id":222466,"goal":"method BinarySearch_2451(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_2452","instance":2452,"id":222467,"goal":"method InsertSort_2452(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_2453","instance":2453,"id":222468,"goal":"method MergeSort_2453(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_2454","instance":2454,"id":222469,"goal":"method ArrayCopy_2454(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_2455","instance":2455,"id":222470,"goal":"function ListReverse_2455(s: seq): seq\n ensures |ListReverse_2455(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_2455(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_2456","instance":2456,"id":222471,"goal":"function Factorial_2456(n: nat): nat\n ensures Factorial_2456(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_2456(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_2457","instance":2457,"id":222472,"goal":"function Fib_2457(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_2457(n-1) + Fib_2457(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_2458","instance":2458,"id":222473,"goal":"function Gcd_2458(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_2458(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_2459","instance":2459,"id":222474,"goal":"function Power_2459(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_2459(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_2460","instance":2460,"id":222475,"goal":"function Sum_2460(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_2460(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_2461","instance":2461,"id":222476,"goal":"method BinarySearch_2461(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_2462","instance":2462,"id":222477,"goal":"method InsertSort_2462(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_2463","instance":2463,"id":222478,"goal":"method MergeSort_2463(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_2464","instance":2464,"id":222479,"goal":"method ArrayCopy_2464(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_2465","instance":2465,"id":222480,"goal":"function ListReverse_2465(s: seq): seq\n ensures |ListReverse_2465(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_2465(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_2466","instance":2466,"id":222481,"goal":"function Factorial_2466(n: nat): nat\n ensures Factorial_2466(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_2466(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_2467","instance":2467,"id":222482,"goal":"function Fib_2467(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_2467(n-1) + Fib_2467(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_2468","instance":2468,"id":222483,"goal":"function Gcd_2468(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_2468(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_2469","instance":2469,"id":222484,"goal":"function Power_2469(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_2469(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_2470","instance":2470,"id":222485,"goal":"function Sum_2470(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_2470(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_2471","instance":2471,"id":222486,"goal":"method BinarySearch_2471(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_2472","instance":2472,"id":222487,"goal":"method InsertSort_2472(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_2473","instance":2473,"id":222488,"goal":"method MergeSort_2473(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_2474","instance":2474,"id":222489,"goal":"method ArrayCopy_2474(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_2475","instance":2475,"id":222490,"goal":"function ListReverse_2475(s: seq): seq\n ensures |ListReverse_2475(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_2475(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_2476","instance":2476,"id":222491,"goal":"function Factorial_2476(n: nat): nat\n ensures Factorial_2476(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_2476(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_2477","instance":2477,"id":222492,"goal":"function Fib_2477(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_2477(n-1) + Fib_2477(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_2478","instance":2478,"id":222493,"goal":"function Gcd_2478(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_2478(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_2479","instance":2479,"id":222494,"goal":"function Power_2479(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_2479(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_2480","instance":2480,"id":222495,"goal":"function Sum_2480(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_2480(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_2481","instance":2481,"id":222496,"goal":"method BinarySearch_2481(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_2482","instance":2482,"id":222497,"goal":"method InsertSort_2482(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_2483","instance":2483,"id":222498,"goal":"method MergeSort_2483(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_2484","instance":2484,"id":222499,"goal":"method ArrayCopy_2484(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_2485","instance":2485,"id":222500,"goal":"function ListReverse_2485(s: seq): seq\n ensures |ListReverse_2485(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_2485(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_2486","instance":2486,"id":222501,"goal":"function Factorial_2486(n: nat): nat\n ensures Factorial_2486(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_2486(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_2487","instance":2487,"id":222502,"goal":"function Fib_2487(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_2487(n-1) + Fib_2487(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_2488","instance":2488,"id":222503,"goal":"function Gcd_2488(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_2488(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_2489","instance":2489,"id":222504,"goal":"function Power_2489(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_2489(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_2490","instance":2490,"id":222505,"goal":"function Sum_2490(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_2490(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_2491","instance":2491,"id":222506,"goal":"method BinarySearch_2491(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_2492","instance":2492,"id":222507,"goal":"method InsertSort_2492(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_2493","instance":2493,"id":222508,"goal":"method MergeSort_2493(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_2494","instance":2494,"id":222509,"goal":"method ArrayCopy_2494(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_2495","instance":2495,"id":222510,"goal":"function ListReverse_2495(s: seq): seq\n ensures |ListReverse_2495(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_2495(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_2496","instance":2496,"id":222511,"goal":"function Factorial_2496(n: nat): nat\n ensures Factorial_2496(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_2496(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_2497","instance":2497,"id":222512,"goal":"function Fib_2497(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_2497(n-1) + Fib_2497(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_2498","instance":2498,"id":222513,"goal":"function Gcd_2498(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_2498(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_2499","instance":2499,"id":222514,"goal":"function Power_2499(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_2499(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_2500","instance":2500,"id":222515,"goal":"function Sum_2500(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_2500(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_2501","instance":2501,"id":222516,"goal":"method BinarySearch_2501(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_2502","instance":2502,"id":222517,"goal":"method InsertSort_2502(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_2503","instance":2503,"id":222518,"goal":"method MergeSort_2503(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_2504","instance":2504,"id":222519,"goal":"method ArrayCopy_2504(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_2505","instance":2505,"id":222520,"goal":"function ListReverse_2505(s: seq): seq\n ensures |ListReverse_2505(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_2505(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_2506","instance":2506,"id":222521,"goal":"function Factorial_2506(n: nat): nat\n ensures Factorial_2506(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_2506(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_2507","instance":2507,"id":222522,"goal":"function Fib_2507(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_2507(n-1) + Fib_2507(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_2508","instance":2508,"id":222523,"goal":"function Gcd_2508(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_2508(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_2509","instance":2509,"id":222524,"goal":"function Power_2509(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_2509(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_2510","instance":2510,"id":222525,"goal":"function Sum_2510(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_2510(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_2511","instance":2511,"id":222526,"goal":"method BinarySearch_2511(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_2512","instance":2512,"id":222527,"goal":"method InsertSort_2512(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_2513","instance":2513,"id":222528,"goal":"method MergeSort_2513(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_2514","instance":2514,"id":222529,"goal":"method ArrayCopy_2514(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_2515","instance":2515,"id":222530,"goal":"function ListReverse_2515(s: seq): seq\n ensures |ListReverse_2515(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_2515(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_2516","instance":2516,"id":222531,"goal":"function Factorial_2516(n: nat): nat\n ensures Factorial_2516(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_2516(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_2517","instance":2517,"id":222532,"goal":"function Fib_2517(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_2517(n-1) + Fib_2517(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_2518","instance":2518,"id":222533,"goal":"function Gcd_2518(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_2518(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_2519","instance":2519,"id":222534,"goal":"function Power_2519(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_2519(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_2520","instance":2520,"id":222535,"goal":"function Sum_2520(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_2520(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_2521","instance":2521,"id":222536,"goal":"method BinarySearch_2521(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_2522","instance":2522,"id":222537,"goal":"method InsertSort_2522(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_2523","instance":2523,"id":222538,"goal":"method MergeSort_2523(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_2524","instance":2524,"id":222539,"goal":"method ArrayCopy_2524(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_2525","instance":2525,"id":222540,"goal":"function ListReverse_2525(s: seq): seq\n ensures |ListReverse_2525(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_2525(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_2526","instance":2526,"id":222541,"goal":"function Factorial_2526(n: nat): nat\n ensures Factorial_2526(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_2526(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_2527","instance":2527,"id":222542,"goal":"function Fib_2527(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_2527(n-1) + Fib_2527(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_2528","instance":2528,"id":222543,"goal":"function Gcd_2528(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_2528(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_2529","instance":2529,"id":222544,"goal":"function Power_2529(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_2529(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_2530","instance":2530,"id":222545,"goal":"function Sum_2530(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_2530(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_2531","instance":2531,"id":222546,"goal":"method BinarySearch_2531(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_2532","instance":2532,"id":222547,"goal":"method InsertSort_2532(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_2533","instance":2533,"id":222548,"goal":"method MergeSort_2533(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_2534","instance":2534,"id":222549,"goal":"method ArrayCopy_2534(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_2535","instance":2535,"id":222550,"goal":"function ListReverse_2535(s: seq): seq\n ensures |ListReverse_2535(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_2535(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_2536","instance":2536,"id":222551,"goal":"function Factorial_2536(n: nat): nat\n ensures Factorial_2536(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_2536(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_2537","instance":2537,"id":222552,"goal":"function Fib_2537(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_2537(n-1) + Fib_2537(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_2538","instance":2538,"id":222553,"goal":"function Gcd_2538(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_2538(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_2539","instance":2539,"id":222554,"goal":"function Power_2539(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_2539(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_2540","instance":2540,"id":222555,"goal":"function Sum_2540(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_2540(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_2541","instance":2541,"id":222556,"goal":"method BinarySearch_2541(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_2542","instance":2542,"id":222557,"goal":"method InsertSort_2542(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_2543","instance":2543,"id":222558,"goal":"method MergeSort_2543(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_2544","instance":2544,"id":222559,"goal":"method ArrayCopy_2544(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_2545","instance":2545,"id":222560,"goal":"function ListReverse_2545(s: seq): seq\n ensures |ListReverse_2545(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_2545(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_2546","instance":2546,"id":222561,"goal":"function Factorial_2546(n: nat): nat\n ensures Factorial_2546(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_2546(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_2547","instance":2547,"id":222562,"goal":"function Fib_2547(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_2547(n-1) + Fib_2547(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_2548","instance":2548,"id":222563,"goal":"function Gcd_2548(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_2548(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_2549","instance":2549,"id":222564,"goal":"function Power_2549(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_2549(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_2550","instance":2550,"id":222565,"goal":"function Sum_2550(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_2550(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_2551","instance":2551,"id":222566,"goal":"method BinarySearch_2551(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_2552","instance":2552,"id":222567,"goal":"method InsertSort_2552(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_2553","instance":2553,"id":222568,"goal":"method MergeSort_2553(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_2554","instance":2554,"id":222569,"goal":"method ArrayCopy_2554(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_2555","instance":2555,"id":222570,"goal":"function ListReverse_2555(s: seq): seq\n ensures |ListReverse_2555(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_2555(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_2556","instance":2556,"id":222571,"goal":"function Factorial_2556(n: nat): nat\n ensures Factorial_2556(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_2556(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_2557","instance":2557,"id":222572,"goal":"function Fib_2557(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_2557(n-1) + Fib_2557(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_2558","instance":2558,"id":222573,"goal":"function Gcd_2558(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_2558(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_2559","instance":2559,"id":222574,"goal":"function Power_2559(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_2559(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_2560","instance":2560,"id":222575,"goal":"function Sum_2560(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_2560(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_2561","instance":2561,"id":222576,"goal":"method BinarySearch_2561(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_2562","instance":2562,"id":222577,"goal":"method InsertSort_2562(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_2563","instance":2563,"id":222578,"goal":"method MergeSort_2563(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_2564","instance":2564,"id":222579,"goal":"method ArrayCopy_2564(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_2565","instance":2565,"id":222580,"goal":"function ListReverse_2565(s: seq): seq\n ensures |ListReverse_2565(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_2565(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_2566","instance":2566,"id":222581,"goal":"function Factorial_2566(n: nat): nat\n ensures Factorial_2566(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_2566(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_2567","instance":2567,"id":222582,"goal":"function Fib_2567(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_2567(n-1) + Fib_2567(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_2568","instance":2568,"id":222583,"goal":"function Gcd_2568(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_2568(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_2569","instance":2569,"id":222584,"goal":"function Power_2569(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_2569(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_2570","instance":2570,"id":222585,"goal":"function Sum_2570(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_2570(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_2571","instance":2571,"id":222586,"goal":"method BinarySearch_2571(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_2572","instance":2572,"id":222587,"goal":"method InsertSort_2572(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_2573","instance":2573,"id":222588,"goal":"method MergeSort_2573(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_2574","instance":2574,"id":222589,"goal":"method ArrayCopy_2574(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_2575","instance":2575,"id":222590,"goal":"function ListReverse_2575(s: seq): seq\n ensures |ListReverse_2575(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_2575(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_2576","instance":2576,"id":222591,"goal":"function Factorial_2576(n: nat): nat\n ensures Factorial_2576(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_2576(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_2577","instance":2577,"id":222592,"goal":"function Fib_2577(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_2577(n-1) + Fib_2577(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_2578","instance":2578,"id":222593,"goal":"function Gcd_2578(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_2578(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_2579","instance":2579,"id":222594,"goal":"function Power_2579(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_2579(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_2580","instance":2580,"id":222595,"goal":"function Sum_2580(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_2580(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_2581","instance":2581,"id":222596,"goal":"method BinarySearch_2581(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_2582","instance":2582,"id":222597,"goal":"method InsertSort_2582(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_2583","instance":2583,"id":222598,"goal":"method MergeSort_2583(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_2584","instance":2584,"id":222599,"goal":"method ArrayCopy_2584(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_2585","instance":2585,"id":222600,"goal":"function ListReverse_2585(s: seq): seq\n ensures |ListReverse_2585(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_2585(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_2586","instance":2586,"id":222601,"goal":"function Factorial_2586(n: nat): nat\n ensures Factorial_2586(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_2586(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_2587","instance":2587,"id":222602,"goal":"function Fib_2587(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_2587(n-1) + Fib_2587(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_2588","instance":2588,"id":222603,"goal":"function Gcd_2588(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_2588(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_2589","instance":2589,"id":222604,"goal":"function Power_2589(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_2589(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_2590","instance":2590,"id":222605,"goal":"function Sum_2590(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_2590(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_2591","instance":2591,"id":222606,"goal":"method BinarySearch_2591(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_2592","instance":2592,"id":222607,"goal":"method InsertSort_2592(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_2593","instance":2593,"id":222608,"goal":"method MergeSort_2593(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_2594","instance":2594,"id":222609,"goal":"method ArrayCopy_2594(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_2595","instance":2595,"id":222610,"goal":"function ListReverse_2595(s: seq): seq\n ensures |ListReverse_2595(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_2595(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_2596","instance":2596,"id":222611,"goal":"function Factorial_2596(n: nat): nat\n ensures Factorial_2596(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_2596(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_2597","instance":2597,"id":222612,"goal":"function Fib_2597(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_2597(n-1) + Fib_2597(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_2598","instance":2598,"id":222613,"goal":"function Gcd_2598(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_2598(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_2599","instance":2599,"id":222614,"goal":"function Power_2599(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_2599(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_2600","instance":2600,"id":222615,"goal":"function Sum_2600(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_2600(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_2601","instance":2601,"id":222616,"goal":"method BinarySearch_2601(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_2602","instance":2602,"id":222617,"goal":"method InsertSort_2602(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_2603","instance":2603,"id":222618,"goal":"method MergeSort_2603(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_2604","instance":2604,"id":222619,"goal":"method ArrayCopy_2604(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_2605","instance":2605,"id":222620,"goal":"function ListReverse_2605(s: seq): seq\n ensures |ListReverse_2605(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_2605(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_2606","instance":2606,"id":222621,"goal":"function Factorial_2606(n: nat): nat\n ensures Factorial_2606(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_2606(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_2607","instance":2607,"id":222622,"goal":"function Fib_2607(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_2607(n-1) + Fib_2607(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_2608","instance":2608,"id":222623,"goal":"function Gcd_2608(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_2608(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_2609","instance":2609,"id":222624,"goal":"function Power_2609(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_2609(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_2610","instance":2610,"id":222625,"goal":"function Sum_2610(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_2610(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_2611","instance":2611,"id":222626,"goal":"method BinarySearch_2611(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_2612","instance":2612,"id":222627,"goal":"method InsertSort_2612(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_2613","instance":2613,"id":222628,"goal":"method MergeSort_2613(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_2614","instance":2614,"id":222629,"goal":"method ArrayCopy_2614(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_2615","instance":2615,"id":222630,"goal":"function ListReverse_2615(s: seq): seq\n ensures |ListReverse_2615(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_2615(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_2616","instance":2616,"id":222631,"goal":"function Factorial_2616(n: nat): nat\n ensures Factorial_2616(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_2616(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_2617","instance":2617,"id":222632,"goal":"function Fib_2617(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_2617(n-1) + Fib_2617(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_2618","instance":2618,"id":222633,"goal":"function Gcd_2618(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_2618(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_2619","instance":2619,"id":222634,"goal":"function Power_2619(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_2619(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_2620","instance":2620,"id":222635,"goal":"function Sum_2620(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_2620(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_2621","instance":2621,"id":222636,"goal":"method BinarySearch_2621(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_2622","instance":2622,"id":222637,"goal":"method InsertSort_2622(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_2623","instance":2623,"id":222638,"goal":"method MergeSort_2623(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_2624","instance":2624,"id":222639,"goal":"method ArrayCopy_2624(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_2625","instance":2625,"id":222640,"goal":"function ListReverse_2625(s: seq): seq\n ensures |ListReverse_2625(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_2625(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_2626","instance":2626,"id":222641,"goal":"function Factorial_2626(n: nat): nat\n ensures Factorial_2626(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_2626(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_2627","instance":2627,"id":222642,"goal":"function Fib_2627(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_2627(n-1) + Fib_2627(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_2628","instance":2628,"id":222643,"goal":"function Gcd_2628(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_2628(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_2629","instance":2629,"id":222644,"goal":"function Power_2629(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_2629(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_2630","instance":2630,"id":222645,"goal":"function Sum_2630(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_2630(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_2631","instance":2631,"id":222646,"goal":"method BinarySearch_2631(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_2632","instance":2632,"id":222647,"goal":"method InsertSort_2632(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_2633","instance":2633,"id":222648,"goal":"method MergeSort_2633(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_2634","instance":2634,"id":222649,"goal":"method ArrayCopy_2634(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_2635","instance":2635,"id":222650,"goal":"function ListReverse_2635(s: seq): seq\n ensures |ListReverse_2635(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_2635(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_2636","instance":2636,"id":222651,"goal":"function Factorial_2636(n: nat): nat\n ensures Factorial_2636(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_2636(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_2637","instance":2637,"id":222652,"goal":"function Fib_2637(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_2637(n-1) + Fib_2637(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_2638","instance":2638,"id":222653,"goal":"function Gcd_2638(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_2638(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_2639","instance":2639,"id":222654,"goal":"function Power_2639(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_2639(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_2640","instance":2640,"id":222655,"goal":"function Sum_2640(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_2640(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_2641","instance":2641,"id":222656,"goal":"method BinarySearch_2641(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_2642","instance":2642,"id":222657,"goal":"method InsertSort_2642(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_2643","instance":2643,"id":222658,"goal":"method MergeSort_2643(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_2644","instance":2644,"id":222659,"goal":"method ArrayCopy_2644(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_2645","instance":2645,"id":222660,"goal":"function ListReverse_2645(s: seq): seq\n ensures |ListReverse_2645(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_2645(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_2646","instance":2646,"id":222661,"goal":"function Factorial_2646(n: nat): nat\n ensures Factorial_2646(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_2646(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_2647","instance":2647,"id":222662,"goal":"function Fib_2647(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_2647(n-1) + Fib_2647(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_2648","instance":2648,"id":222663,"goal":"function Gcd_2648(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_2648(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_2649","instance":2649,"id":222664,"goal":"function Power_2649(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_2649(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_2650","instance":2650,"id":222665,"goal":"function Sum_2650(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_2650(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_2651","instance":2651,"id":222666,"goal":"method BinarySearch_2651(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_2652","instance":2652,"id":222667,"goal":"method InsertSort_2652(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_2653","instance":2653,"id":222668,"goal":"method MergeSort_2653(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_2654","instance":2654,"id":222669,"goal":"method ArrayCopy_2654(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_2655","instance":2655,"id":222670,"goal":"function ListReverse_2655(s: seq): seq\n ensures |ListReverse_2655(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_2655(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_2656","instance":2656,"id":222671,"goal":"function Factorial_2656(n: nat): nat\n ensures Factorial_2656(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_2656(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_2657","instance":2657,"id":222672,"goal":"function Fib_2657(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_2657(n-1) + Fib_2657(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_2658","instance":2658,"id":222673,"goal":"function Gcd_2658(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_2658(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_2659","instance":2659,"id":222674,"goal":"function Power_2659(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_2659(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_2660","instance":2660,"id":222675,"goal":"function Sum_2660(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_2660(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_2661","instance":2661,"id":222676,"goal":"method BinarySearch_2661(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_2662","instance":2662,"id":222677,"goal":"method InsertSort_2662(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_2663","instance":2663,"id":222678,"goal":"method MergeSort_2663(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_2664","instance":2664,"id":222679,"goal":"method ArrayCopy_2664(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_2665","instance":2665,"id":222680,"goal":"function ListReverse_2665(s: seq): seq\n ensures |ListReverse_2665(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_2665(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_2666","instance":2666,"id":222681,"goal":"function Factorial_2666(n: nat): nat\n ensures Factorial_2666(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_2666(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_2667","instance":2667,"id":222682,"goal":"function Fib_2667(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_2667(n-1) + Fib_2667(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_2668","instance":2668,"id":222683,"goal":"function Gcd_2668(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_2668(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_2669","instance":2669,"id":222684,"goal":"function Power_2669(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_2669(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_2670","instance":2670,"id":222685,"goal":"function Sum_2670(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_2670(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_2671","instance":2671,"id":222686,"goal":"method BinarySearch_2671(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_2672","instance":2672,"id":222687,"goal":"method InsertSort_2672(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_2673","instance":2673,"id":222688,"goal":"method MergeSort_2673(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_2674","instance":2674,"id":222689,"goal":"method ArrayCopy_2674(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_2675","instance":2675,"id":222690,"goal":"function ListReverse_2675(s: seq): seq\n ensures |ListReverse_2675(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_2675(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_2676","instance":2676,"id":222691,"goal":"function Factorial_2676(n: nat): nat\n ensures Factorial_2676(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_2676(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_2677","instance":2677,"id":222692,"goal":"function Fib_2677(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_2677(n-1) + Fib_2677(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_2678","instance":2678,"id":222693,"goal":"function Gcd_2678(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_2678(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_2679","instance":2679,"id":222694,"goal":"function Power_2679(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_2679(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_2680","instance":2680,"id":222695,"goal":"function Sum_2680(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_2680(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_2681","instance":2681,"id":222696,"goal":"method BinarySearch_2681(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_2682","instance":2682,"id":222697,"goal":"method InsertSort_2682(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_2683","instance":2683,"id":222698,"goal":"method MergeSort_2683(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_2684","instance":2684,"id":222699,"goal":"method ArrayCopy_2684(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_2685","instance":2685,"id":222700,"goal":"function ListReverse_2685(s: seq): seq\n ensures |ListReverse_2685(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_2685(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_2686","instance":2686,"id":222701,"goal":"function Factorial_2686(n: nat): nat\n ensures Factorial_2686(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_2686(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_2687","instance":2687,"id":222702,"goal":"function Fib_2687(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_2687(n-1) + Fib_2687(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_2688","instance":2688,"id":222703,"goal":"function Gcd_2688(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_2688(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_2689","instance":2689,"id":222704,"goal":"function Power_2689(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_2689(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_2690","instance":2690,"id":222705,"goal":"function Sum_2690(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_2690(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_2691","instance":2691,"id":222706,"goal":"method BinarySearch_2691(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_2692","instance":2692,"id":222707,"goal":"method InsertSort_2692(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_2693","instance":2693,"id":222708,"goal":"method MergeSort_2693(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_2694","instance":2694,"id":222709,"goal":"method ArrayCopy_2694(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_2695","instance":2695,"id":222710,"goal":"function ListReverse_2695(s: seq): seq\n ensures |ListReverse_2695(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_2695(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_2696","instance":2696,"id":222711,"goal":"function Factorial_2696(n: nat): nat\n ensures Factorial_2696(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_2696(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_2697","instance":2697,"id":222712,"goal":"function Fib_2697(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_2697(n-1) + Fib_2697(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_2698","instance":2698,"id":222713,"goal":"function Gcd_2698(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_2698(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_2699","instance":2699,"id":222714,"goal":"function Power_2699(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_2699(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_2700","instance":2700,"id":222715,"goal":"function Sum_2700(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_2700(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_2701","instance":2701,"id":222716,"goal":"method BinarySearch_2701(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_2702","instance":2702,"id":222717,"goal":"method InsertSort_2702(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_2703","instance":2703,"id":222718,"goal":"method MergeSort_2703(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_2704","instance":2704,"id":222719,"goal":"method ArrayCopy_2704(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_2705","instance":2705,"id":222720,"goal":"function ListReverse_2705(s: seq): seq\n ensures |ListReverse_2705(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_2705(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_2706","instance":2706,"id":222721,"goal":"function Factorial_2706(n: nat): nat\n ensures Factorial_2706(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_2706(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_2707","instance":2707,"id":222722,"goal":"function Fib_2707(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_2707(n-1) + Fib_2707(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_2708","instance":2708,"id":222723,"goal":"function Gcd_2708(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_2708(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_2709","instance":2709,"id":222724,"goal":"function Power_2709(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_2709(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_2710","instance":2710,"id":222725,"goal":"function Sum_2710(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_2710(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_2711","instance":2711,"id":222726,"goal":"method BinarySearch_2711(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_2712","instance":2712,"id":222727,"goal":"method InsertSort_2712(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_2713","instance":2713,"id":222728,"goal":"method MergeSort_2713(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_2714","instance":2714,"id":222729,"goal":"method ArrayCopy_2714(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_2715","instance":2715,"id":222730,"goal":"function ListReverse_2715(s: seq): seq\n ensures |ListReverse_2715(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_2715(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_2716","instance":2716,"id":222731,"goal":"function Factorial_2716(n: nat): nat\n ensures Factorial_2716(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_2716(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_2717","instance":2717,"id":222732,"goal":"function Fib_2717(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_2717(n-1) + Fib_2717(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_2718","instance":2718,"id":222733,"goal":"function Gcd_2718(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_2718(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_2719","instance":2719,"id":222734,"goal":"function Power_2719(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_2719(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_2720","instance":2720,"id":222735,"goal":"function Sum_2720(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_2720(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_2721","instance":2721,"id":222736,"goal":"method BinarySearch_2721(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_2722","instance":2722,"id":222737,"goal":"method InsertSort_2722(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_2723","instance":2723,"id":222738,"goal":"method MergeSort_2723(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_2724","instance":2724,"id":222739,"goal":"method ArrayCopy_2724(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_2725","instance":2725,"id":222740,"goal":"function ListReverse_2725(s: seq): seq\n ensures |ListReverse_2725(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_2725(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_2726","instance":2726,"id":222741,"goal":"function Factorial_2726(n: nat): nat\n ensures Factorial_2726(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_2726(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_2727","instance":2727,"id":222742,"goal":"function Fib_2727(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_2727(n-1) + Fib_2727(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_2728","instance":2728,"id":222743,"goal":"function Gcd_2728(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_2728(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_2729","instance":2729,"id":222744,"goal":"function Power_2729(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_2729(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_2730","instance":2730,"id":222745,"goal":"function Sum_2730(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_2730(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_2731","instance":2731,"id":222746,"goal":"method BinarySearch_2731(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_2732","instance":2732,"id":222747,"goal":"method InsertSort_2732(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_2733","instance":2733,"id":222748,"goal":"method MergeSort_2733(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_2734","instance":2734,"id":222749,"goal":"method ArrayCopy_2734(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_2735","instance":2735,"id":222750,"goal":"function ListReverse_2735(s: seq): seq\n ensures |ListReverse_2735(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_2735(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_2736","instance":2736,"id":222751,"goal":"function Factorial_2736(n: nat): nat\n ensures Factorial_2736(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_2736(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_2737","instance":2737,"id":222752,"goal":"function Fib_2737(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_2737(n-1) + Fib_2737(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_2738","instance":2738,"id":222753,"goal":"function Gcd_2738(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_2738(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_2739","instance":2739,"id":222754,"goal":"function Power_2739(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_2739(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_2740","instance":2740,"id":222755,"goal":"function Sum_2740(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_2740(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_2741","instance":2741,"id":222756,"goal":"method BinarySearch_2741(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_2742","instance":2742,"id":222757,"goal":"method InsertSort_2742(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_2743","instance":2743,"id":222758,"goal":"method MergeSort_2743(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_2744","instance":2744,"id":222759,"goal":"method ArrayCopy_2744(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_2745","instance":2745,"id":222760,"goal":"function ListReverse_2745(s: seq): seq\n ensures |ListReverse_2745(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_2745(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_2746","instance":2746,"id":222761,"goal":"function Factorial_2746(n: nat): nat\n ensures Factorial_2746(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_2746(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_2747","instance":2747,"id":222762,"goal":"function Fib_2747(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_2747(n-1) + Fib_2747(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_2748","instance":2748,"id":222763,"goal":"function Gcd_2748(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_2748(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_2749","instance":2749,"id":222764,"goal":"function Power_2749(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_2749(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_2750","instance":2750,"id":222765,"goal":"function Sum_2750(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_2750(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_2751","instance":2751,"id":222766,"goal":"method BinarySearch_2751(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_2752","instance":2752,"id":222767,"goal":"method InsertSort_2752(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_2753","instance":2753,"id":222768,"goal":"method MergeSort_2753(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_2754","instance":2754,"id":222769,"goal":"method ArrayCopy_2754(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_2755","instance":2755,"id":222770,"goal":"function ListReverse_2755(s: seq): seq\n ensures |ListReverse_2755(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_2755(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_2756","instance":2756,"id":222771,"goal":"function Factorial_2756(n: nat): nat\n ensures Factorial_2756(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_2756(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_2757","instance":2757,"id":222772,"goal":"function Fib_2757(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_2757(n-1) + Fib_2757(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_2758","instance":2758,"id":222773,"goal":"function Gcd_2758(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_2758(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_2759","instance":2759,"id":222774,"goal":"function Power_2759(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_2759(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_2760","instance":2760,"id":222775,"goal":"function Sum_2760(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_2760(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_2761","instance":2761,"id":222776,"goal":"method BinarySearch_2761(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_2762","instance":2762,"id":222777,"goal":"method InsertSort_2762(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_2763","instance":2763,"id":222778,"goal":"method MergeSort_2763(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_2764","instance":2764,"id":222779,"goal":"method ArrayCopy_2764(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_2765","instance":2765,"id":222780,"goal":"function ListReverse_2765(s: seq): seq\n ensures |ListReverse_2765(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_2765(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_2766","instance":2766,"id":222781,"goal":"function Factorial_2766(n: nat): nat\n ensures Factorial_2766(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_2766(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_2767","instance":2767,"id":222782,"goal":"function Fib_2767(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_2767(n-1) + Fib_2767(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_2768","instance":2768,"id":222783,"goal":"function Gcd_2768(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_2768(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_2769","instance":2769,"id":222784,"goal":"function Power_2769(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_2769(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_2770","instance":2770,"id":222785,"goal":"function Sum_2770(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_2770(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_2771","instance":2771,"id":222786,"goal":"method BinarySearch_2771(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_2772","instance":2772,"id":222787,"goal":"method InsertSort_2772(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_2773","instance":2773,"id":222788,"goal":"method MergeSort_2773(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_2774","instance":2774,"id":222789,"goal":"method ArrayCopy_2774(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_2775","instance":2775,"id":222790,"goal":"function ListReverse_2775(s: seq): seq\n ensures |ListReverse_2775(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_2775(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_2776","instance":2776,"id":222791,"goal":"function Factorial_2776(n: nat): nat\n ensures Factorial_2776(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_2776(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_2777","instance":2777,"id":222792,"goal":"function Fib_2777(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_2777(n-1) + Fib_2777(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_2778","instance":2778,"id":222793,"goal":"function Gcd_2778(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_2778(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_2779","instance":2779,"id":222794,"goal":"function Power_2779(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_2779(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_2780","instance":2780,"id":222795,"goal":"function Sum_2780(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_2780(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_2781","instance":2781,"id":222796,"goal":"method BinarySearch_2781(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_2782","instance":2782,"id":222797,"goal":"method InsertSort_2782(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_2783","instance":2783,"id":222798,"goal":"method MergeSort_2783(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_2784","instance":2784,"id":222799,"goal":"method ArrayCopy_2784(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_2785","instance":2785,"id":222800,"goal":"function ListReverse_2785(s: seq): seq\n ensures |ListReverse_2785(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_2785(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_2786","instance":2786,"id":222801,"goal":"function Factorial_2786(n: nat): nat\n ensures Factorial_2786(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_2786(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_2787","instance":2787,"id":222802,"goal":"function Fib_2787(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_2787(n-1) + Fib_2787(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_2788","instance":2788,"id":222803,"goal":"function Gcd_2788(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_2788(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_2789","instance":2789,"id":222804,"goal":"function Power_2789(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_2789(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_2790","instance":2790,"id":222805,"goal":"function Sum_2790(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_2790(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_2791","instance":2791,"id":222806,"goal":"method BinarySearch_2791(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_2792","instance":2792,"id":222807,"goal":"method InsertSort_2792(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_2793","instance":2793,"id":222808,"goal":"method MergeSort_2793(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_2794","instance":2794,"id":222809,"goal":"method ArrayCopy_2794(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_2795","instance":2795,"id":222810,"goal":"function ListReverse_2795(s: seq): seq\n ensures |ListReverse_2795(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_2795(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_2796","instance":2796,"id":222811,"goal":"function Factorial_2796(n: nat): nat\n ensures Factorial_2796(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_2796(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_2797","instance":2797,"id":222812,"goal":"function Fib_2797(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_2797(n-1) + Fib_2797(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_2798","instance":2798,"id":222813,"goal":"function Gcd_2798(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_2798(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_2799","instance":2799,"id":222814,"goal":"function Power_2799(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_2799(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_2800","instance":2800,"id":222815,"goal":"function Sum_2800(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_2800(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_2801","instance":2801,"id":222816,"goal":"method BinarySearch_2801(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_2802","instance":2802,"id":222817,"goal":"method InsertSort_2802(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_2803","instance":2803,"id":222818,"goal":"method MergeSort_2803(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_2804","instance":2804,"id":222819,"goal":"method ArrayCopy_2804(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_2805","instance":2805,"id":222820,"goal":"function ListReverse_2805(s: seq): seq\n ensures |ListReverse_2805(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_2805(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_2806","instance":2806,"id":222821,"goal":"function Factorial_2806(n: nat): nat\n ensures Factorial_2806(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_2806(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_2807","instance":2807,"id":222822,"goal":"function Fib_2807(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_2807(n-1) + Fib_2807(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_2808","instance":2808,"id":222823,"goal":"function Gcd_2808(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_2808(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_2809","instance":2809,"id":222824,"goal":"function Power_2809(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_2809(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_2810","instance":2810,"id":222825,"goal":"function Sum_2810(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_2810(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_2811","instance":2811,"id":222826,"goal":"method BinarySearch_2811(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_2812","instance":2812,"id":222827,"goal":"method InsertSort_2812(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_2813","instance":2813,"id":222828,"goal":"method MergeSort_2813(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_2814","instance":2814,"id":222829,"goal":"method ArrayCopy_2814(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_2815","instance":2815,"id":222830,"goal":"function ListReverse_2815(s: seq): seq\n ensures |ListReverse_2815(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_2815(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_2816","instance":2816,"id":222831,"goal":"function Factorial_2816(n: nat): nat\n ensures Factorial_2816(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_2816(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_2817","instance":2817,"id":222832,"goal":"function Fib_2817(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_2817(n-1) + Fib_2817(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_2818","instance":2818,"id":222833,"goal":"function Gcd_2818(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_2818(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_2819","instance":2819,"id":222834,"goal":"function Power_2819(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_2819(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_2820","instance":2820,"id":222835,"goal":"function Sum_2820(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_2820(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_2821","instance":2821,"id":222836,"goal":"method BinarySearch_2821(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_2822","instance":2822,"id":222837,"goal":"method InsertSort_2822(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_2823","instance":2823,"id":222838,"goal":"method MergeSort_2823(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_2824","instance":2824,"id":222839,"goal":"method ArrayCopy_2824(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_2825","instance":2825,"id":222840,"goal":"function ListReverse_2825(s: seq): seq\n ensures |ListReverse_2825(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_2825(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_2826","instance":2826,"id":222841,"goal":"function Factorial_2826(n: nat): nat\n ensures Factorial_2826(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_2826(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_2827","instance":2827,"id":222842,"goal":"function Fib_2827(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_2827(n-1) + Fib_2827(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_2828","instance":2828,"id":222843,"goal":"function Gcd_2828(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_2828(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_2829","instance":2829,"id":222844,"goal":"function Power_2829(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_2829(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_2830","instance":2830,"id":222845,"goal":"function Sum_2830(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_2830(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_2831","instance":2831,"id":222846,"goal":"method BinarySearch_2831(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_2832","instance":2832,"id":222847,"goal":"method InsertSort_2832(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_2833","instance":2833,"id":222848,"goal":"method MergeSort_2833(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_2834","instance":2834,"id":222849,"goal":"method ArrayCopy_2834(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_2835","instance":2835,"id":222850,"goal":"function ListReverse_2835(s: seq): seq\n ensures |ListReverse_2835(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_2835(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_2836","instance":2836,"id":222851,"goal":"function Factorial_2836(n: nat): nat\n ensures Factorial_2836(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_2836(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_2837","instance":2837,"id":222852,"goal":"function Fib_2837(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_2837(n-1) + Fib_2837(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_2838","instance":2838,"id":222853,"goal":"function Gcd_2838(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_2838(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_2839","instance":2839,"id":222854,"goal":"function Power_2839(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_2839(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_2840","instance":2840,"id":222855,"goal":"function Sum_2840(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_2840(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_2841","instance":2841,"id":222856,"goal":"method BinarySearch_2841(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_2842","instance":2842,"id":222857,"goal":"method InsertSort_2842(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_2843","instance":2843,"id":222858,"goal":"method MergeSort_2843(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_2844","instance":2844,"id":222859,"goal":"method ArrayCopy_2844(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_2845","instance":2845,"id":222860,"goal":"function ListReverse_2845(s: seq): seq\n ensures |ListReverse_2845(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_2845(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_2846","instance":2846,"id":222861,"goal":"function Factorial_2846(n: nat): nat\n ensures Factorial_2846(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_2846(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_2847","instance":2847,"id":222862,"goal":"function Fib_2847(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_2847(n-1) + Fib_2847(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_2848","instance":2848,"id":222863,"goal":"function Gcd_2848(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_2848(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_2849","instance":2849,"id":222864,"goal":"function Power_2849(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_2849(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_2850","instance":2850,"id":222865,"goal":"function Sum_2850(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_2850(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_2851","instance":2851,"id":222866,"goal":"method BinarySearch_2851(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_2852","instance":2852,"id":222867,"goal":"method InsertSort_2852(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_2853","instance":2853,"id":222868,"goal":"method MergeSort_2853(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_2854","instance":2854,"id":222869,"goal":"method ArrayCopy_2854(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_2855","instance":2855,"id":222870,"goal":"function ListReverse_2855(s: seq): seq\n ensures |ListReverse_2855(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_2855(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_2856","instance":2856,"id":222871,"goal":"function Factorial_2856(n: nat): nat\n ensures Factorial_2856(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_2856(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_2857","instance":2857,"id":222872,"goal":"function Fib_2857(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_2857(n-1) + Fib_2857(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_2858","instance":2858,"id":222873,"goal":"function Gcd_2858(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_2858(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_2859","instance":2859,"id":222874,"goal":"function Power_2859(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_2859(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_2860","instance":2860,"id":222875,"goal":"function Sum_2860(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_2860(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_2861","instance":2861,"id":222876,"goal":"method BinarySearch_2861(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_2862","instance":2862,"id":222877,"goal":"method InsertSort_2862(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_2863","instance":2863,"id":222878,"goal":"method MergeSort_2863(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_2864","instance":2864,"id":222879,"goal":"method ArrayCopy_2864(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_2865","instance":2865,"id":222880,"goal":"function ListReverse_2865(s: seq): seq\n ensures |ListReverse_2865(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_2865(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_2866","instance":2866,"id":222881,"goal":"function Factorial_2866(n: nat): nat\n ensures Factorial_2866(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_2866(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_2867","instance":2867,"id":222882,"goal":"function Fib_2867(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_2867(n-1) + Fib_2867(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_2868","instance":2868,"id":222883,"goal":"function Gcd_2868(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_2868(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_2869","instance":2869,"id":222884,"goal":"function Power_2869(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_2869(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_2870","instance":2870,"id":222885,"goal":"function Sum_2870(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_2870(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_2871","instance":2871,"id":222886,"goal":"method BinarySearch_2871(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_2872","instance":2872,"id":222887,"goal":"method InsertSort_2872(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_2873","instance":2873,"id":222888,"goal":"method MergeSort_2873(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_2874","instance":2874,"id":222889,"goal":"method ArrayCopy_2874(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_2875","instance":2875,"id":222890,"goal":"function ListReverse_2875(s: seq): seq\n ensures |ListReverse_2875(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_2875(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_2876","instance":2876,"id":222891,"goal":"function Factorial_2876(n: nat): nat\n ensures Factorial_2876(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_2876(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_2877","instance":2877,"id":222892,"goal":"function Fib_2877(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_2877(n-1) + Fib_2877(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_2878","instance":2878,"id":222893,"goal":"function Gcd_2878(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_2878(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_2879","instance":2879,"id":222894,"goal":"function Power_2879(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_2879(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_2880","instance":2880,"id":222895,"goal":"function Sum_2880(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_2880(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_2881","instance":2881,"id":222896,"goal":"method BinarySearch_2881(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_2882","instance":2882,"id":222897,"goal":"method InsertSort_2882(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_2883","instance":2883,"id":222898,"goal":"method MergeSort_2883(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_2884","instance":2884,"id":222899,"goal":"method ArrayCopy_2884(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_2885","instance":2885,"id":222900,"goal":"function ListReverse_2885(s: seq): seq\n ensures |ListReverse_2885(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_2885(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_2886","instance":2886,"id":222901,"goal":"function Factorial_2886(n: nat): nat\n ensures Factorial_2886(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_2886(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_2887","instance":2887,"id":222902,"goal":"function Fib_2887(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_2887(n-1) + Fib_2887(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_2888","instance":2888,"id":222903,"goal":"function Gcd_2888(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_2888(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_2889","instance":2889,"id":222904,"goal":"function Power_2889(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_2889(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_2890","instance":2890,"id":222905,"goal":"function Sum_2890(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_2890(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_2891","instance":2891,"id":222906,"goal":"method BinarySearch_2891(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_2892","instance":2892,"id":222907,"goal":"method InsertSort_2892(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_2893","instance":2893,"id":222908,"goal":"method MergeSort_2893(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_2894","instance":2894,"id":222909,"goal":"method ArrayCopy_2894(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_2895","instance":2895,"id":222910,"goal":"function ListReverse_2895(s: seq): seq\n ensures |ListReverse_2895(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_2895(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_2896","instance":2896,"id":222911,"goal":"function Factorial_2896(n: nat): nat\n ensures Factorial_2896(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_2896(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_2897","instance":2897,"id":222912,"goal":"function Fib_2897(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_2897(n-1) + Fib_2897(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_2898","instance":2898,"id":222913,"goal":"function Gcd_2898(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_2898(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_2899","instance":2899,"id":222914,"goal":"function Power_2899(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_2899(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_2900","instance":2900,"id":222915,"goal":"function Sum_2900(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_2900(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_2901","instance":2901,"id":222916,"goal":"method BinarySearch_2901(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_2902","instance":2902,"id":222917,"goal":"method InsertSort_2902(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_2903","instance":2903,"id":222918,"goal":"method MergeSort_2903(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_2904","instance":2904,"id":222919,"goal":"method ArrayCopy_2904(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_2905","instance":2905,"id":222920,"goal":"function ListReverse_2905(s: seq): seq\n ensures |ListReverse_2905(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_2905(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_2906","instance":2906,"id":222921,"goal":"function Factorial_2906(n: nat): nat\n ensures Factorial_2906(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_2906(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_2907","instance":2907,"id":222922,"goal":"function Fib_2907(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_2907(n-1) + Fib_2907(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_2908","instance":2908,"id":222923,"goal":"function Gcd_2908(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_2908(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_2909","instance":2909,"id":222924,"goal":"function Power_2909(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_2909(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_2910","instance":2910,"id":222925,"goal":"function Sum_2910(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_2910(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_2911","instance":2911,"id":222926,"goal":"method BinarySearch_2911(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_2912","instance":2912,"id":222927,"goal":"method InsertSort_2912(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_2913","instance":2913,"id":222928,"goal":"method MergeSort_2913(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_2914","instance":2914,"id":222929,"goal":"method ArrayCopy_2914(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_2915","instance":2915,"id":222930,"goal":"function ListReverse_2915(s: seq): seq\n ensures |ListReverse_2915(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_2915(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_2916","instance":2916,"id":222931,"goal":"function Factorial_2916(n: nat): nat\n ensures Factorial_2916(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_2916(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_2917","instance":2917,"id":222932,"goal":"function Fib_2917(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_2917(n-1) + Fib_2917(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_2918","instance":2918,"id":222933,"goal":"function Gcd_2918(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_2918(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_2919","instance":2919,"id":222934,"goal":"function Power_2919(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_2919(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_2920","instance":2920,"id":222935,"goal":"function Sum_2920(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_2920(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_2921","instance":2921,"id":222936,"goal":"method BinarySearch_2921(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_2922","instance":2922,"id":222937,"goal":"method InsertSort_2922(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_2923","instance":2923,"id":222938,"goal":"method MergeSort_2923(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_2924","instance":2924,"id":222939,"goal":"method ArrayCopy_2924(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_2925","instance":2925,"id":222940,"goal":"function ListReverse_2925(s: seq): seq\n ensures |ListReverse_2925(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_2925(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_2926","instance":2926,"id":222941,"goal":"function Factorial_2926(n: nat): nat\n ensures Factorial_2926(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_2926(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_2927","instance":2927,"id":222942,"goal":"function Fib_2927(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_2927(n-1) + Fib_2927(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_2928","instance":2928,"id":222943,"goal":"function Gcd_2928(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_2928(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_2929","instance":2929,"id":222944,"goal":"function Power_2929(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_2929(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_2930","instance":2930,"id":222945,"goal":"function Sum_2930(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_2930(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_2931","instance":2931,"id":222946,"goal":"method BinarySearch_2931(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_2932","instance":2932,"id":222947,"goal":"method InsertSort_2932(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_2933","instance":2933,"id":222948,"goal":"method MergeSort_2933(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_2934","instance":2934,"id":222949,"goal":"method ArrayCopy_2934(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_2935","instance":2935,"id":222950,"goal":"function ListReverse_2935(s: seq): seq\n ensures |ListReverse_2935(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_2935(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_2936","instance":2936,"id":222951,"goal":"function Factorial_2936(n: nat): nat\n ensures Factorial_2936(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_2936(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_2937","instance":2937,"id":222952,"goal":"function Fib_2937(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_2937(n-1) + Fib_2937(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_2938","instance":2938,"id":222953,"goal":"function Gcd_2938(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_2938(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_2939","instance":2939,"id":222954,"goal":"function Power_2939(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_2939(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_2940","instance":2940,"id":222955,"goal":"function Sum_2940(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_2940(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_2941","instance":2941,"id":222956,"goal":"method BinarySearch_2941(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_2942","instance":2942,"id":222957,"goal":"method InsertSort_2942(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_2943","instance":2943,"id":222958,"goal":"method MergeSort_2943(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_2944","instance":2944,"id":222959,"goal":"method ArrayCopy_2944(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_2945","instance":2945,"id":222960,"goal":"function ListReverse_2945(s: seq): seq\n ensures |ListReverse_2945(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_2945(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_2946","instance":2946,"id":222961,"goal":"function Factorial_2946(n: nat): nat\n ensures Factorial_2946(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_2946(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_2947","instance":2947,"id":222962,"goal":"function Fib_2947(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_2947(n-1) + Fib_2947(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_2948","instance":2948,"id":222963,"goal":"function Gcd_2948(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_2948(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_2949","instance":2949,"id":222964,"goal":"function Power_2949(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_2949(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_2950","instance":2950,"id":222965,"goal":"function Sum_2950(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_2950(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_2951","instance":2951,"id":222966,"goal":"method BinarySearch_2951(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_2952","instance":2952,"id":222967,"goal":"method InsertSort_2952(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_2953","instance":2953,"id":222968,"goal":"method MergeSort_2953(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_2954","instance":2954,"id":222969,"goal":"method ArrayCopy_2954(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_2955","instance":2955,"id":222970,"goal":"function ListReverse_2955(s: seq): seq\n ensures |ListReverse_2955(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_2955(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_2956","instance":2956,"id":222971,"goal":"function Factorial_2956(n: nat): nat\n ensures Factorial_2956(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_2956(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_2957","instance":2957,"id":222972,"goal":"function Fib_2957(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_2957(n-1) + Fib_2957(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_2958","instance":2958,"id":222973,"goal":"function Gcd_2958(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_2958(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_2959","instance":2959,"id":222974,"goal":"function Power_2959(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_2959(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_2960","instance":2960,"id":222975,"goal":"function Sum_2960(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_2960(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_2961","instance":2961,"id":222976,"goal":"method BinarySearch_2961(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_2962","instance":2962,"id":222977,"goal":"method InsertSort_2962(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_2963","instance":2963,"id":222978,"goal":"method MergeSort_2963(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_2964","instance":2964,"id":222979,"goal":"method ArrayCopy_2964(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_2965","instance":2965,"id":222980,"goal":"function ListReverse_2965(s: seq): seq\n ensures |ListReverse_2965(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_2965(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_2966","instance":2966,"id":222981,"goal":"function Factorial_2966(n: nat): nat\n ensures Factorial_2966(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_2966(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_2967","instance":2967,"id":222982,"goal":"function Fib_2967(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_2967(n-1) + Fib_2967(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_2968","instance":2968,"id":222983,"goal":"function Gcd_2968(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_2968(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_2969","instance":2969,"id":222984,"goal":"function Power_2969(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_2969(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_2970","instance":2970,"id":222985,"goal":"function Sum_2970(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_2970(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_2971","instance":2971,"id":222986,"goal":"method BinarySearch_2971(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_2972","instance":2972,"id":222987,"goal":"method InsertSort_2972(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_2973","instance":2973,"id":222988,"goal":"method MergeSort_2973(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_2974","instance":2974,"id":222989,"goal":"method ArrayCopy_2974(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_2975","instance":2975,"id":222990,"goal":"function ListReverse_2975(s: seq): seq\n ensures |ListReverse_2975(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_2975(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_2976","instance":2976,"id":222991,"goal":"function Factorial_2976(n: nat): nat\n ensures Factorial_2976(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_2976(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_2977","instance":2977,"id":222992,"goal":"function Fib_2977(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_2977(n-1) + Fib_2977(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_2978","instance":2978,"id":222993,"goal":"function Gcd_2978(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_2978(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_2979","instance":2979,"id":222994,"goal":"function Power_2979(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_2979(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_2980","instance":2980,"id":222995,"goal":"function Sum_2980(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_2980(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_2981","instance":2981,"id":222996,"goal":"method BinarySearch_2981(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_2982","instance":2982,"id":222997,"goal":"method InsertSort_2982(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_2983","instance":2983,"id":222998,"goal":"method MergeSort_2983(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_2984","instance":2984,"id":222999,"goal":"method ArrayCopy_2984(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_2985","instance":2985,"id":223000,"goal":"function ListReverse_2985(s: seq): seq\n ensures |ListReverse_2985(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_2985(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_2986","instance":2986,"id":223001,"goal":"function Factorial_2986(n: nat): nat\n ensures Factorial_2986(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_2986(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_2987","instance":2987,"id":223002,"goal":"function Fib_2987(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_2987(n-1) + Fib_2987(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_2988","instance":2988,"id":223003,"goal":"function Gcd_2988(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_2988(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_2989","instance":2989,"id":223004,"goal":"function Power_2989(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_2989(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_2990","instance":2990,"id":223005,"goal":"function Sum_2990(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_2990(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_2991","instance":2991,"id":223006,"goal":"method BinarySearch_2991(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_2992","instance":2992,"id":223007,"goal":"method InsertSort_2992(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_2993","instance":2993,"id":223008,"goal":"method MergeSort_2993(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_2994","instance":2994,"id":223009,"goal":"method ArrayCopy_2994(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_2995","instance":2995,"id":223010,"goal":"function ListReverse_2995(s: seq): seq\n ensures |ListReverse_2995(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_2995(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_2996","instance":2996,"id":223011,"goal":"function Factorial_2996(n: nat): nat\n ensures Factorial_2996(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_2996(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_2997","instance":2997,"id":223012,"goal":"function Fib_2997(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_2997(n-1) + Fib_2997(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_2998","instance":2998,"id":223013,"goal":"function Gcd_2998(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_2998(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_2999","instance":2999,"id":223014,"goal":"function Power_2999(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_2999(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_3000","instance":3000,"id":223015,"goal":"function Sum_3000(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_3000(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_3001","instance":3001,"id":223016,"goal":"method BinarySearch_3001(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_3002","instance":3002,"id":223017,"goal":"method InsertSort_3002(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_3003","instance":3003,"id":223018,"goal":"method MergeSort_3003(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_3004","instance":3004,"id":223019,"goal":"method ArrayCopy_3004(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_3005","instance":3005,"id":223020,"goal":"function ListReverse_3005(s: seq): seq\n ensures |ListReverse_3005(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_3005(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_3006","instance":3006,"id":223021,"goal":"function Factorial_3006(n: nat): nat\n ensures Factorial_3006(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_3006(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_3007","instance":3007,"id":223022,"goal":"function Fib_3007(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_3007(n-1) + Fib_3007(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_3008","instance":3008,"id":223023,"goal":"function Gcd_3008(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_3008(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_3009","instance":3009,"id":223024,"goal":"function Power_3009(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_3009(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_3010","instance":3010,"id":223025,"goal":"function Sum_3010(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_3010(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_3011","instance":3011,"id":223026,"goal":"method BinarySearch_3011(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_3012","instance":3012,"id":223027,"goal":"method InsertSort_3012(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_3013","instance":3013,"id":223028,"goal":"method MergeSort_3013(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_3014","instance":3014,"id":223029,"goal":"method ArrayCopy_3014(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_3015","instance":3015,"id":223030,"goal":"function ListReverse_3015(s: seq): seq\n ensures |ListReverse_3015(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_3015(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_3016","instance":3016,"id":223031,"goal":"function Factorial_3016(n: nat): nat\n ensures Factorial_3016(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_3016(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_3017","instance":3017,"id":223032,"goal":"function Fib_3017(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_3017(n-1) + Fib_3017(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_3018","instance":3018,"id":223033,"goal":"function Gcd_3018(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_3018(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_3019","instance":3019,"id":223034,"goal":"function Power_3019(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_3019(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_3020","instance":3020,"id":223035,"goal":"function Sum_3020(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_3020(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_3021","instance":3021,"id":223036,"goal":"method BinarySearch_3021(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_3022","instance":3022,"id":223037,"goal":"method InsertSort_3022(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_3023","instance":3023,"id":223038,"goal":"method MergeSort_3023(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_3024","instance":3024,"id":223039,"goal":"method ArrayCopy_3024(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_3025","instance":3025,"id":223040,"goal":"function ListReverse_3025(s: seq): seq\n ensures |ListReverse_3025(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_3025(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_3026","instance":3026,"id":223041,"goal":"function Factorial_3026(n: nat): nat\n ensures Factorial_3026(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_3026(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_3027","instance":3027,"id":223042,"goal":"function Fib_3027(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_3027(n-1) + Fib_3027(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_3028","instance":3028,"id":223043,"goal":"function Gcd_3028(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_3028(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_3029","instance":3029,"id":223044,"goal":"function Power_3029(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_3029(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_3030","instance":3030,"id":223045,"goal":"function Sum_3030(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_3030(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_3031","instance":3031,"id":223046,"goal":"method BinarySearch_3031(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_3032","instance":3032,"id":223047,"goal":"method InsertSort_3032(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_3033","instance":3033,"id":223048,"goal":"method MergeSort_3033(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_3034","instance":3034,"id":223049,"goal":"method ArrayCopy_3034(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_3035","instance":3035,"id":223050,"goal":"function ListReverse_3035(s: seq): seq\n ensures |ListReverse_3035(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_3035(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_3036","instance":3036,"id":223051,"goal":"function Factorial_3036(n: nat): nat\n ensures Factorial_3036(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_3036(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_3037","instance":3037,"id":223052,"goal":"function Fib_3037(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_3037(n-1) + Fib_3037(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_3038","instance":3038,"id":223053,"goal":"function Gcd_3038(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_3038(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_3039","instance":3039,"id":223054,"goal":"function Power_3039(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_3039(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_3040","instance":3040,"id":223055,"goal":"function Sum_3040(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_3040(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_3041","instance":3041,"id":223056,"goal":"method BinarySearch_3041(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_3042","instance":3042,"id":223057,"goal":"method InsertSort_3042(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_3043","instance":3043,"id":223058,"goal":"method MergeSort_3043(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_3044","instance":3044,"id":223059,"goal":"method ArrayCopy_3044(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_3045","instance":3045,"id":223060,"goal":"function ListReverse_3045(s: seq): seq\n ensures |ListReverse_3045(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_3045(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_3046","instance":3046,"id":223061,"goal":"function Factorial_3046(n: nat): nat\n ensures Factorial_3046(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_3046(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_3047","instance":3047,"id":223062,"goal":"function Fib_3047(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_3047(n-1) + Fib_3047(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_3048","instance":3048,"id":223063,"goal":"function Gcd_3048(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_3048(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_3049","instance":3049,"id":223064,"goal":"function Power_3049(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_3049(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_3050","instance":3050,"id":223065,"goal":"function Sum_3050(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_3050(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_3051","instance":3051,"id":223066,"goal":"method BinarySearch_3051(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_3052","instance":3052,"id":223067,"goal":"method InsertSort_3052(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_3053","instance":3053,"id":223068,"goal":"method MergeSort_3053(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_3054","instance":3054,"id":223069,"goal":"method ArrayCopy_3054(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_3055","instance":3055,"id":223070,"goal":"function ListReverse_3055(s: seq): seq\n ensures |ListReverse_3055(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_3055(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_3056","instance":3056,"id":223071,"goal":"function Factorial_3056(n: nat): nat\n ensures Factorial_3056(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_3056(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_3057","instance":3057,"id":223072,"goal":"function Fib_3057(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_3057(n-1) + Fib_3057(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_3058","instance":3058,"id":223073,"goal":"function Gcd_3058(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_3058(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_3059","instance":3059,"id":223074,"goal":"function Power_3059(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_3059(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_3060","instance":3060,"id":223075,"goal":"function Sum_3060(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_3060(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_3061","instance":3061,"id":223076,"goal":"method BinarySearch_3061(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_3062","instance":3062,"id":223077,"goal":"method InsertSort_3062(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_3063","instance":3063,"id":223078,"goal":"method MergeSort_3063(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_3064","instance":3064,"id":223079,"goal":"method ArrayCopy_3064(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_3065","instance":3065,"id":223080,"goal":"function ListReverse_3065(s: seq): seq\n ensures |ListReverse_3065(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_3065(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_3066","instance":3066,"id":223081,"goal":"function Factorial_3066(n: nat): nat\n ensures Factorial_3066(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_3066(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_3067","instance":3067,"id":223082,"goal":"function Fib_3067(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_3067(n-1) + Fib_3067(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_3068","instance":3068,"id":223083,"goal":"function Gcd_3068(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_3068(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_3069","instance":3069,"id":223084,"goal":"function Power_3069(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_3069(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_3070","instance":3070,"id":223085,"goal":"function Sum_3070(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_3070(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_3071","instance":3071,"id":223086,"goal":"method BinarySearch_3071(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_3072","instance":3072,"id":223087,"goal":"method InsertSort_3072(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_3073","instance":3073,"id":223088,"goal":"method MergeSort_3073(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_3074","instance":3074,"id":223089,"goal":"method ArrayCopy_3074(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_3075","instance":3075,"id":223090,"goal":"function ListReverse_3075(s: seq): seq\n ensures |ListReverse_3075(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_3075(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_3076","instance":3076,"id":223091,"goal":"function Factorial_3076(n: nat): nat\n ensures Factorial_3076(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_3076(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_3077","instance":3077,"id":223092,"goal":"function Fib_3077(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_3077(n-1) + Fib_3077(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_3078","instance":3078,"id":223093,"goal":"function Gcd_3078(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_3078(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_3079","instance":3079,"id":223094,"goal":"function Power_3079(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_3079(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_3080","instance":3080,"id":223095,"goal":"function Sum_3080(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_3080(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_3081","instance":3081,"id":223096,"goal":"method BinarySearch_3081(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_3082","instance":3082,"id":223097,"goal":"method InsertSort_3082(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_3083","instance":3083,"id":223098,"goal":"method MergeSort_3083(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_3084","instance":3084,"id":223099,"goal":"method ArrayCopy_3084(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_3085","instance":3085,"id":223100,"goal":"function ListReverse_3085(s: seq): seq\n ensures |ListReverse_3085(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_3085(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_3086","instance":3086,"id":223101,"goal":"function Factorial_3086(n: nat): nat\n ensures Factorial_3086(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_3086(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_3087","instance":3087,"id":223102,"goal":"function Fib_3087(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_3087(n-1) + Fib_3087(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_3088","instance":3088,"id":223103,"goal":"function Gcd_3088(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_3088(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_3089","instance":3089,"id":223104,"goal":"function Power_3089(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_3089(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_3090","instance":3090,"id":223105,"goal":"function Sum_3090(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_3090(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_3091","instance":3091,"id":223106,"goal":"method BinarySearch_3091(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_3092","instance":3092,"id":223107,"goal":"method InsertSort_3092(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_3093","instance":3093,"id":223108,"goal":"method MergeSort_3093(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_3094","instance":3094,"id":223109,"goal":"method ArrayCopy_3094(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_3095","instance":3095,"id":223110,"goal":"function ListReverse_3095(s: seq): seq\n ensures |ListReverse_3095(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_3095(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_3096","instance":3096,"id":223111,"goal":"function Factorial_3096(n: nat): nat\n ensures Factorial_3096(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_3096(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_3097","instance":3097,"id":223112,"goal":"function Fib_3097(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_3097(n-1) + Fib_3097(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_3098","instance":3098,"id":223113,"goal":"function Gcd_3098(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_3098(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_3099","instance":3099,"id":223114,"goal":"function Power_3099(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_3099(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_3100","instance":3100,"id":223115,"goal":"function Sum_3100(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_3100(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_3101","instance":3101,"id":223116,"goal":"method BinarySearch_3101(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_3102","instance":3102,"id":223117,"goal":"method InsertSort_3102(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_3103","instance":3103,"id":223118,"goal":"method MergeSort_3103(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_3104","instance":3104,"id":223119,"goal":"method ArrayCopy_3104(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_3105","instance":3105,"id":223120,"goal":"function ListReverse_3105(s: seq): seq\n ensures |ListReverse_3105(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_3105(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_3106","instance":3106,"id":223121,"goal":"function Factorial_3106(n: nat): nat\n ensures Factorial_3106(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_3106(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_3107","instance":3107,"id":223122,"goal":"function Fib_3107(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_3107(n-1) + Fib_3107(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_3108","instance":3108,"id":223123,"goal":"function Gcd_3108(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_3108(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_3109","instance":3109,"id":223124,"goal":"function Power_3109(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_3109(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_3110","instance":3110,"id":223125,"goal":"function Sum_3110(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_3110(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_3111","instance":3111,"id":223126,"goal":"method BinarySearch_3111(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_3112","instance":3112,"id":223127,"goal":"method InsertSort_3112(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_3113","instance":3113,"id":223128,"goal":"method MergeSort_3113(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_3114","instance":3114,"id":223129,"goal":"method ArrayCopy_3114(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_3115","instance":3115,"id":223130,"goal":"function ListReverse_3115(s: seq): seq\n ensures |ListReverse_3115(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_3115(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_3116","instance":3116,"id":223131,"goal":"function Factorial_3116(n: nat): nat\n ensures Factorial_3116(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_3116(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_3117","instance":3117,"id":223132,"goal":"function Fib_3117(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_3117(n-1) + Fib_3117(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_3118","instance":3118,"id":223133,"goal":"function Gcd_3118(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_3118(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_3119","instance":3119,"id":223134,"goal":"function Power_3119(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_3119(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_3120","instance":3120,"id":223135,"goal":"function Sum_3120(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_3120(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_3121","instance":3121,"id":223136,"goal":"method BinarySearch_3121(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_3122","instance":3122,"id":223137,"goal":"method InsertSort_3122(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_3123","instance":3123,"id":223138,"goal":"method MergeSort_3123(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_3124","instance":3124,"id":223139,"goal":"method ArrayCopy_3124(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_3125","instance":3125,"id":223140,"goal":"function ListReverse_3125(s: seq): seq\n ensures |ListReverse_3125(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_3125(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_3126","instance":3126,"id":223141,"goal":"function Factorial_3126(n: nat): nat\n ensures Factorial_3126(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_3126(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_3127","instance":3127,"id":223142,"goal":"function Fib_3127(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_3127(n-1) + Fib_3127(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_3128","instance":3128,"id":223143,"goal":"function Gcd_3128(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_3128(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_3129","instance":3129,"id":223144,"goal":"function Power_3129(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_3129(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_3130","instance":3130,"id":223145,"goal":"function Sum_3130(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_3130(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_3131","instance":3131,"id":223146,"goal":"method BinarySearch_3131(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_3132","instance":3132,"id":223147,"goal":"method InsertSort_3132(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_3133","instance":3133,"id":223148,"goal":"method MergeSort_3133(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_3134","instance":3134,"id":223149,"goal":"method ArrayCopy_3134(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_3135","instance":3135,"id":223150,"goal":"function ListReverse_3135(s: seq): seq\n ensures |ListReverse_3135(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_3135(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_3136","instance":3136,"id":223151,"goal":"function Factorial_3136(n: nat): nat\n ensures Factorial_3136(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_3136(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_3137","instance":3137,"id":223152,"goal":"function Fib_3137(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_3137(n-1) + Fib_3137(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_3138","instance":3138,"id":223153,"goal":"function Gcd_3138(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_3138(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_3139","instance":3139,"id":223154,"goal":"function Power_3139(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_3139(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_3140","instance":3140,"id":223155,"goal":"function Sum_3140(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_3140(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_3141","instance":3141,"id":223156,"goal":"method BinarySearch_3141(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_3142","instance":3142,"id":223157,"goal":"method InsertSort_3142(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_3143","instance":3143,"id":223158,"goal":"method MergeSort_3143(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_3144","instance":3144,"id":223159,"goal":"method ArrayCopy_3144(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_3145","instance":3145,"id":223160,"goal":"function ListReverse_3145(s: seq): seq\n ensures |ListReverse_3145(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_3145(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_3146","instance":3146,"id":223161,"goal":"function Factorial_3146(n: nat): nat\n ensures Factorial_3146(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_3146(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_3147","instance":3147,"id":223162,"goal":"function Fib_3147(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_3147(n-1) + Fib_3147(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_3148","instance":3148,"id":223163,"goal":"function Gcd_3148(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_3148(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_3149","instance":3149,"id":223164,"goal":"function Power_3149(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_3149(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_3150","instance":3150,"id":223165,"goal":"function Sum_3150(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_3150(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_3151","instance":3151,"id":223166,"goal":"method BinarySearch_3151(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_3152","instance":3152,"id":223167,"goal":"method InsertSort_3152(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_3153","instance":3153,"id":223168,"goal":"method MergeSort_3153(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_3154","instance":3154,"id":223169,"goal":"method ArrayCopy_3154(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_3155","instance":3155,"id":223170,"goal":"function ListReverse_3155(s: seq): seq\n ensures |ListReverse_3155(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_3155(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_3156","instance":3156,"id":223171,"goal":"function Factorial_3156(n: nat): nat\n ensures Factorial_3156(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_3156(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_3157","instance":3157,"id":223172,"goal":"function Fib_3157(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_3157(n-1) + Fib_3157(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_3158","instance":3158,"id":223173,"goal":"function Gcd_3158(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_3158(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_3159","instance":3159,"id":223174,"goal":"function Power_3159(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_3159(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_3160","instance":3160,"id":223175,"goal":"function Sum_3160(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_3160(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_3161","instance":3161,"id":223176,"goal":"method BinarySearch_3161(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_3162","instance":3162,"id":223177,"goal":"method InsertSort_3162(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_3163","instance":3163,"id":223178,"goal":"method MergeSort_3163(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_3164","instance":3164,"id":223179,"goal":"method ArrayCopy_3164(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_3165","instance":3165,"id":223180,"goal":"function ListReverse_3165(s: seq): seq\n ensures |ListReverse_3165(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_3165(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_3166","instance":3166,"id":223181,"goal":"function Factorial_3166(n: nat): nat\n ensures Factorial_3166(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_3166(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_3167","instance":3167,"id":223182,"goal":"function Fib_3167(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_3167(n-1) + Fib_3167(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_3168","instance":3168,"id":223183,"goal":"function Gcd_3168(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_3168(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_3169","instance":3169,"id":223184,"goal":"function Power_3169(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_3169(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_3170","instance":3170,"id":223185,"goal":"function Sum_3170(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_3170(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_3171","instance":3171,"id":223186,"goal":"method BinarySearch_3171(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_3172","instance":3172,"id":223187,"goal":"method InsertSort_3172(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_3173","instance":3173,"id":223188,"goal":"method MergeSort_3173(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_3174","instance":3174,"id":223189,"goal":"method ArrayCopy_3174(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_3175","instance":3175,"id":223190,"goal":"function ListReverse_3175(s: seq): seq\n ensures |ListReverse_3175(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_3175(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_3176","instance":3176,"id":223191,"goal":"function Factorial_3176(n: nat): nat\n ensures Factorial_3176(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_3176(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_3177","instance":3177,"id":223192,"goal":"function Fib_3177(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_3177(n-1) + Fib_3177(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_3178","instance":3178,"id":223193,"goal":"function Gcd_3178(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_3178(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_3179","instance":3179,"id":223194,"goal":"function Power_3179(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_3179(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_3180","instance":3180,"id":223195,"goal":"function Sum_3180(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_3180(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_3181","instance":3181,"id":223196,"goal":"method BinarySearch_3181(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_3182","instance":3182,"id":223197,"goal":"method InsertSort_3182(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_3183","instance":3183,"id":223198,"goal":"method MergeSort_3183(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_3184","instance":3184,"id":223199,"goal":"method ArrayCopy_3184(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_3185","instance":3185,"id":223200,"goal":"function ListReverse_3185(s: seq): seq\n ensures |ListReverse_3185(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_3185(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_3186","instance":3186,"id":223201,"goal":"function Factorial_3186(n: nat): nat\n ensures Factorial_3186(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_3186(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_3187","instance":3187,"id":223202,"goal":"function Fib_3187(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_3187(n-1) + Fib_3187(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_3188","instance":3188,"id":223203,"goal":"function Gcd_3188(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_3188(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_3189","instance":3189,"id":223204,"goal":"function Power_3189(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_3189(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_3190","instance":3190,"id":223205,"goal":"function Sum_3190(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_3190(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_3191","instance":3191,"id":223206,"goal":"method BinarySearch_3191(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_3192","instance":3192,"id":223207,"goal":"method InsertSort_3192(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_3193","instance":3193,"id":223208,"goal":"method MergeSort_3193(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_3194","instance":3194,"id":223209,"goal":"method ArrayCopy_3194(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_3195","instance":3195,"id":223210,"goal":"function ListReverse_3195(s: seq): seq\n ensures |ListReverse_3195(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_3195(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_3196","instance":3196,"id":223211,"goal":"function Factorial_3196(n: nat): nat\n ensures Factorial_3196(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_3196(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_3197","instance":3197,"id":223212,"goal":"function Fib_3197(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_3197(n-1) + Fib_3197(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_3198","instance":3198,"id":223213,"goal":"function Gcd_3198(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_3198(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_3199","instance":3199,"id":223214,"goal":"function Power_3199(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_3199(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_3200","instance":3200,"id":223215,"goal":"function Sum_3200(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_3200(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_3201","instance":3201,"id":223216,"goal":"method BinarySearch_3201(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_3202","instance":3202,"id":223217,"goal":"method InsertSort_3202(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_3203","instance":3203,"id":223218,"goal":"method MergeSort_3203(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_3204","instance":3204,"id":223219,"goal":"method ArrayCopy_3204(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_3205","instance":3205,"id":223220,"goal":"function ListReverse_3205(s: seq): seq\n ensures |ListReverse_3205(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_3205(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_3206","instance":3206,"id":223221,"goal":"function Factorial_3206(n: nat): nat\n ensures Factorial_3206(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_3206(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_3207","instance":3207,"id":223222,"goal":"function Fib_3207(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_3207(n-1) + Fib_3207(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_3208","instance":3208,"id":223223,"goal":"function Gcd_3208(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_3208(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_3209","instance":3209,"id":223224,"goal":"function Power_3209(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_3209(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_3210","instance":3210,"id":223225,"goal":"function Sum_3210(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_3210(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_3211","instance":3211,"id":223226,"goal":"method BinarySearch_3211(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_3212","instance":3212,"id":223227,"goal":"method InsertSort_3212(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_3213","instance":3213,"id":223228,"goal":"method MergeSort_3213(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_3214","instance":3214,"id":223229,"goal":"method ArrayCopy_3214(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_3215","instance":3215,"id":223230,"goal":"function ListReverse_3215(s: seq): seq\n ensures |ListReverse_3215(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_3215(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_3216","instance":3216,"id":223231,"goal":"function Factorial_3216(n: nat): nat\n ensures Factorial_3216(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_3216(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_3217","instance":3217,"id":223232,"goal":"function Fib_3217(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_3217(n-1) + Fib_3217(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_3218","instance":3218,"id":223233,"goal":"function Gcd_3218(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_3218(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_3219","instance":3219,"id":223234,"goal":"function Power_3219(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_3219(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_3220","instance":3220,"id":223235,"goal":"function Sum_3220(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_3220(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_3221","instance":3221,"id":223236,"goal":"method BinarySearch_3221(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_3222","instance":3222,"id":223237,"goal":"method InsertSort_3222(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_3223","instance":3223,"id":223238,"goal":"method MergeSort_3223(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_3224","instance":3224,"id":223239,"goal":"method ArrayCopy_3224(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_3225","instance":3225,"id":223240,"goal":"function ListReverse_3225(s: seq): seq\n ensures |ListReverse_3225(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_3225(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_3226","instance":3226,"id":223241,"goal":"function Factorial_3226(n: nat): nat\n ensures Factorial_3226(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_3226(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_3227","instance":3227,"id":223242,"goal":"function Fib_3227(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_3227(n-1) + Fib_3227(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_3228","instance":3228,"id":223243,"goal":"function Gcd_3228(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_3228(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_3229","instance":3229,"id":223244,"goal":"function Power_3229(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_3229(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_3230","instance":3230,"id":223245,"goal":"function Sum_3230(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_3230(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_3231","instance":3231,"id":223246,"goal":"method BinarySearch_3231(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_3232","instance":3232,"id":223247,"goal":"method InsertSort_3232(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_3233","instance":3233,"id":223248,"goal":"method MergeSort_3233(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_3234","instance":3234,"id":223249,"goal":"method ArrayCopy_3234(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_3235","instance":3235,"id":223250,"goal":"function ListReverse_3235(s: seq): seq\n ensures |ListReverse_3235(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_3235(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_3236","instance":3236,"id":223251,"goal":"function Factorial_3236(n: nat): nat\n ensures Factorial_3236(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_3236(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_3237","instance":3237,"id":223252,"goal":"function Fib_3237(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_3237(n-1) + Fib_3237(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_3238","instance":3238,"id":223253,"goal":"function Gcd_3238(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_3238(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_3239","instance":3239,"id":223254,"goal":"function Power_3239(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_3239(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_3240","instance":3240,"id":223255,"goal":"function Sum_3240(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_3240(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_3241","instance":3241,"id":223256,"goal":"method BinarySearch_3241(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_3242","instance":3242,"id":223257,"goal":"method InsertSort_3242(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_3243","instance":3243,"id":223258,"goal":"method MergeSort_3243(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_3244","instance":3244,"id":223259,"goal":"method ArrayCopy_3244(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_3245","instance":3245,"id":223260,"goal":"function ListReverse_3245(s: seq): seq\n ensures |ListReverse_3245(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_3245(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_3246","instance":3246,"id":223261,"goal":"function Factorial_3246(n: nat): nat\n ensures Factorial_3246(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_3246(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_3247","instance":3247,"id":223262,"goal":"function Fib_3247(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_3247(n-1) + Fib_3247(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_3248","instance":3248,"id":223263,"goal":"function Gcd_3248(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_3248(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_3249","instance":3249,"id":223264,"goal":"function Power_3249(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_3249(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_3250","instance":3250,"id":223265,"goal":"function Sum_3250(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_3250(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_3251","instance":3251,"id":223266,"goal":"method BinarySearch_3251(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_3252","instance":3252,"id":223267,"goal":"method InsertSort_3252(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_3253","instance":3253,"id":223268,"goal":"method MergeSort_3253(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_3254","instance":3254,"id":223269,"goal":"method ArrayCopy_3254(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_3255","instance":3255,"id":223270,"goal":"function ListReverse_3255(s: seq): seq\n ensures |ListReverse_3255(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_3255(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_3256","instance":3256,"id":223271,"goal":"function Factorial_3256(n: nat): nat\n ensures Factorial_3256(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_3256(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_3257","instance":3257,"id":223272,"goal":"function Fib_3257(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_3257(n-1) + Fib_3257(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_3258","instance":3258,"id":223273,"goal":"function Gcd_3258(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_3258(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_3259","instance":3259,"id":223274,"goal":"function Power_3259(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_3259(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_3260","instance":3260,"id":223275,"goal":"function Sum_3260(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_3260(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_3261","instance":3261,"id":223276,"goal":"method BinarySearch_3261(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_3262","instance":3262,"id":223277,"goal":"method InsertSort_3262(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_3263","instance":3263,"id":223278,"goal":"method MergeSort_3263(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_3264","instance":3264,"id":223279,"goal":"method ArrayCopy_3264(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_3265","instance":3265,"id":223280,"goal":"function ListReverse_3265(s: seq): seq\n ensures |ListReverse_3265(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_3265(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_3266","instance":3266,"id":223281,"goal":"function Factorial_3266(n: nat): nat\n ensures Factorial_3266(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_3266(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_3267","instance":3267,"id":223282,"goal":"function Fib_3267(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_3267(n-1) + Fib_3267(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_3268","instance":3268,"id":223283,"goal":"function Gcd_3268(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_3268(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_3269","instance":3269,"id":223284,"goal":"function Power_3269(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_3269(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_3270","instance":3270,"id":223285,"goal":"function Sum_3270(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_3270(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_3271","instance":3271,"id":223286,"goal":"method BinarySearch_3271(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_3272","instance":3272,"id":223287,"goal":"method InsertSort_3272(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_3273","instance":3273,"id":223288,"goal":"method MergeSort_3273(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_3274","instance":3274,"id":223289,"goal":"method ArrayCopy_3274(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_3275","instance":3275,"id":223290,"goal":"function ListReverse_3275(s: seq): seq\n ensures |ListReverse_3275(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_3275(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_3276","instance":3276,"id":223291,"goal":"function Factorial_3276(n: nat): nat\n ensures Factorial_3276(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_3276(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_3277","instance":3277,"id":223292,"goal":"function Fib_3277(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_3277(n-1) + Fib_3277(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_3278","instance":3278,"id":223293,"goal":"function Gcd_3278(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_3278(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_3279","instance":3279,"id":223294,"goal":"function Power_3279(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_3279(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_3280","instance":3280,"id":223295,"goal":"function Sum_3280(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_3280(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_3281","instance":3281,"id":223296,"goal":"method BinarySearch_3281(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_3282","instance":3282,"id":223297,"goal":"method InsertSort_3282(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_3283","instance":3283,"id":223298,"goal":"method MergeSort_3283(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_3284","instance":3284,"id":223299,"goal":"method ArrayCopy_3284(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_3285","instance":3285,"id":223300,"goal":"function ListReverse_3285(s: seq): seq\n ensures |ListReverse_3285(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_3285(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_3286","instance":3286,"id":223301,"goal":"function Factorial_3286(n: nat): nat\n ensures Factorial_3286(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_3286(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_3287","instance":3287,"id":223302,"goal":"function Fib_3287(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_3287(n-1) + Fib_3287(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_3288","instance":3288,"id":223303,"goal":"function Gcd_3288(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_3288(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_3289","instance":3289,"id":223304,"goal":"function Power_3289(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_3289(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_3290","instance":3290,"id":223305,"goal":"function Sum_3290(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_3290(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_3291","instance":3291,"id":223306,"goal":"method BinarySearch_3291(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_3292","instance":3292,"id":223307,"goal":"method InsertSort_3292(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_3293","instance":3293,"id":223308,"goal":"method MergeSort_3293(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_3294","instance":3294,"id":223309,"goal":"method ArrayCopy_3294(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_3295","instance":3295,"id":223310,"goal":"function ListReverse_3295(s: seq): seq\n ensures |ListReverse_3295(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_3295(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_3296","instance":3296,"id":223311,"goal":"function Factorial_3296(n: nat): nat\n ensures Factorial_3296(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_3296(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_3297","instance":3297,"id":223312,"goal":"function Fib_3297(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_3297(n-1) + Fib_3297(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_3298","instance":3298,"id":223313,"goal":"function Gcd_3298(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_3298(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_3299","instance":3299,"id":223314,"goal":"function Power_3299(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_3299(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_3300","instance":3300,"id":223315,"goal":"function Sum_3300(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_3300(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_3301","instance":3301,"id":223316,"goal":"method BinarySearch_3301(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_3302","instance":3302,"id":223317,"goal":"method InsertSort_3302(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_3303","instance":3303,"id":223318,"goal":"method MergeSort_3303(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_3304","instance":3304,"id":223319,"goal":"method ArrayCopy_3304(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_3305","instance":3305,"id":223320,"goal":"function ListReverse_3305(s: seq): seq\n ensures |ListReverse_3305(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_3305(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_3306","instance":3306,"id":223321,"goal":"function Factorial_3306(n: nat): nat\n ensures Factorial_3306(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_3306(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_3307","instance":3307,"id":223322,"goal":"function Fib_3307(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_3307(n-1) + Fib_3307(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_3308","instance":3308,"id":223323,"goal":"function Gcd_3308(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_3308(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_3309","instance":3309,"id":223324,"goal":"function Power_3309(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_3309(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_3310","instance":3310,"id":223325,"goal":"function Sum_3310(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_3310(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_3311","instance":3311,"id":223326,"goal":"method BinarySearch_3311(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_3312","instance":3312,"id":223327,"goal":"method InsertSort_3312(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_3313","instance":3313,"id":223328,"goal":"method MergeSort_3313(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_3314","instance":3314,"id":223329,"goal":"method ArrayCopy_3314(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_3315","instance":3315,"id":223330,"goal":"function ListReverse_3315(s: seq): seq\n ensures |ListReverse_3315(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_3315(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_3316","instance":3316,"id":223331,"goal":"function Factorial_3316(n: nat): nat\n ensures Factorial_3316(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_3316(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_3317","instance":3317,"id":223332,"goal":"function Fib_3317(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_3317(n-1) + Fib_3317(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_3318","instance":3318,"id":223333,"goal":"function Gcd_3318(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_3318(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_3319","instance":3319,"id":223334,"goal":"function Power_3319(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_3319(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_3320","instance":3320,"id":223335,"goal":"function Sum_3320(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_3320(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_3321","instance":3321,"id":223336,"goal":"method BinarySearch_3321(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_3322","instance":3322,"id":223337,"goal":"method InsertSort_3322(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_3323","instance":3323,"id":223338,"goal":"method MergeSort_3323(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_3324","instance":3324,"id":223339,"goal":"method ArrayCopy_3324(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_3325","instance":3325,"id":223340,"goal":"function ListReverse_3325(s: seq): seq\n ensures |ListReverse_3325(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_3325(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_3326","instance":3326,"id":223341,"goal":"function Factorial_3326(n: nat): nat\n ensures Factorial_3326(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_3326(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_3327","instance":3327,"id":223342,"goal":"function Fib_3327(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_3327(n-1) + Fib_3327(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_3328","instance":3328,"id":223343,"goal":"function Gcd_3328(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_3328(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_3329","instance":3329,"id":223344,"goal":"function Power_3329(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_3329(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_3330","instance":3330,"id":223345,"goal":"function Sum_3330(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_3330(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_3331","instance":3331,"id":223346,"goal":"method BinarySearch_3331(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_3332","instance":3332,"id":223347,"goal":"method InsertSort_3332(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_3333","instance":3333,"id":223348,"goal":"method MergeSort_3333(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_3334","instance":3334,"id":223349,"goal":"method ArrayCopy_3334(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_3335","instance":3335,"id":223350,"goal":"function ListReverse_3335(s: seq): seq\n ensures |ListReverse_3335(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_3335(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_3336","instance":3336,"id":223351,"goal":"function Factorial_3336(n: nat): nat\n ensures Factorial_3336(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_3336(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_3337","instance":3337,"id":223352,"goal":"function Fib_3337(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_3337(n-1) + Fib_3337(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_3338","instance":3338,"id":223353,"goal":"function Gcd_3338(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_3338(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_3339","instance":3339,"id":223354,"goal":"function Power_3339(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_3339(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_3340","instance":3340,"id":223355,"goal":"function Sum_3340(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_3340(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_3341","instance":3341,"id":223356,"goal":"method BinarySearch_3341(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_3342","instance":3342,"id":223357,"goal":"method InsertSort_3342(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_3343","instance":3343,"id":223358,"goal":"method MergeSort_3343(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_3344","instance":3344,"id":223359,"goal":"method ArrayCopy_3344(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_3345","instance":3345,"id":223360,"goal":"function ListReverse_3345(s: seq): seq\n ensures |ListReverse_3345(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_3345(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_3346","instance":3346,"id":223361,"goal":"function Factorial_3346(n: nat): nat\n ensures Factorial_3346(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_3346(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_3347","instance":3347,"id":223362,"goal":"function Fib_3347(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_3347(n-1) + Fib_3347(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_3348","instance":3348,"id":223363,"goal":"function Gcd_3348(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_3348(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_3349","instance":3349,"id":223364,"goal":"function Power_3349(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_3349(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_3350","instance":3350,"id":223365,"goal":"function Sum_3350(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_3350(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_3351","instance":3351,"id":223366,"goal":"method BinarySearch_3351(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_3352","instance":3352,"id":223367,"goal":"method InsertSort_3352(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_3353","instance":3353,"id":223368,"goal":"method MergeSort_3353(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_3354","instance":3354,"id":223369,"goal":"method ArrayCopy_3354(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_3355","instance":3355,"id":223370,"goal":"function ListReverse_3355(s: seq): seq\n ensures |ListReverse_3355(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_3355(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_3356","instance":3356,"id":223371,"goal":"function Factorial_3356(n: nat): nat\n ensures Factorial_3356(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_3356(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_3357","instance":3357,"id":223372,"goal":"function Fib_3357(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_3357(n-1) + Fib_3357(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_3358","instance":3358,"id":223373,"goal":"function Gcd_3358(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_3358(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_3359","instance":3359,"id":223374,"goal":"function Power_3359(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_3359(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_3360","instance":3360,"id":223375,"goal":"function Sum_3360(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_3360(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_3361","instance":3361,"id":223376,"goal":"method BinarySearch_3361(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_3362","instance":3362,"id":223377,"goal":"method InsertSort_3362(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_3363","instance":3363,"id":223378,"goal":"method MergeSort_3363(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_3364","instance":3364,"id":223379,"goal":"method ArrayCopy_3364(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_3365","instance":3365,"id":223380,"goal":"function ListReverse_3365(s: seq): seq\n ensures |ListReverse_3365(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_3365(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_3366","instance":3366,"id":223381,"goal":"function Factorial_3366(n: nat): nat\n ensures Factorial_3366(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_3366(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_3367","instance":3367,"id":223382,"goal":"function Fib_3367(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_3367(n-1) + Fib_3367(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_3368","instance":3368,"id":223383,"goal":"function Gcd_3368(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_3368(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_3369","instance":3369,"id":223384,"goal":"function Power_3369(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_3369(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_3370","instance":3370,"id":223385,"goal":"function Sum_3370(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_3370(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_3371","instance":3371,"id":223386,"goal":"method BinarySearch_3371(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_3372","instance":3372,"id":223387,"goal":"method InsertSort_3372(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_3373","instance":3373,"id":223388,"goal":"method MergeSort_3373(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_3374","instance":3374,"id":223389,"goal":"method ArrayCopy_3374(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_3375","instance":3375,"id":223390,"goal":"function ListReverse_3375(s: seq): seq\n ensures |ListReverse_3375(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_3375(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_3376","instance":3376,"id":223391,"goal":"function Factorial_3376(n: nat): nat\n ensures Factorial_3376(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_3376(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_3377","instance":3377,"id":223392,"goal":"function Fib_3377(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_3377(n-1) + Fib_3377(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_3378","instance":3378,"id":223393,"goal":"function Gcd_3378(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_3378(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_3379","instance":3379,"id":223394,"goal":"function Power_3379(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_3379(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_3380","instance":3380,"id":223395,"goal":"function Sum_3380(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_3380(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_3381","instance":3381,"id":223396,"goal":"method BinarySearch_3381(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_3382","instance":3382,"id":223397,"goal":"method InsertSort_3382(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_3383","instance":3383,"id":223398,"goal":"method MergeSort_3383(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_3384","instance":3384,"id":223399,"goal":"method ArrayCopy_3384(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_3385","instance":3385,"id":223400,"goal":"function ListReverse_3385(s: seq): seq\n ensures |ListReverse_3385(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_3385(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_3386","instance":3386,"id":223401,"goal":"function Factorial_3386(n: nat): nat\n ensures Factorial_3386(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_3386(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_3387","instance":3387,"id":223402,"goal":"function Fib_3387(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_3387(n-1) + Fib_3387(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_3388","instance":3388,"id":223403,"goal":"function Gcd_3388(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_3388(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_3389","instance":3389,"id":223404,"goal":"function Power_3389(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_3389(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_3390","instance":3390,"id":223405,"goal":"function Sum_3390(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_3390(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_3391","instance":3391,"id":223406,"goal":"method BinarySearch_3391(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_3392","instance":3392,"id":223407,"goal":"method InsertSort_3392(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_3393","instance":3393,"id":223408,"goal":"method MergeSort_3393(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_3394","instance":3394,"id":223409,"goal":"method ArrayCopy_3394(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_3395","instance":3395,"id":223410,"goal":"function ListReverse_3395(s: seq): seq\n ensures |ListReverse_3395(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_3395(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_3396","instance":3396,"id":223411,"goal":"function Factorial_3396(n: nat): nat\n ensures Factorial_3396(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_3396(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_3397","instance":3397,"id":223412,"goal":"function Fib_3397(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_3397(n-1) + Fib_3397(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_3398","instance":3398,"id":223413,"goal":"function Gcd_3398(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_3398(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_3399","instance":3399,"id":223414,"goal":"function Power_3399(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_3399(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_3400","instance":3400,"id":223415,"goal":"function Sum_3400(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_3400(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_3401","instance":3401,"id":223416,"goal":"method BinarySearch_3401(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_3402","instance":3402,"id":223417,"goal":"method InsertSort_3402(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_3403","instance":3403,"id":223418,"goal":"method MergeSort_3403(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_3404","instance":3404,"id":223419,"goal":"method ArrayCopy_3404(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_3405","instance":3405,"id":223420,"goal":"function ListReverse_3405(s: seq): seq\n ensures |ListReverse_3405(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_3405(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_3406","instance":3406,"id":223421,"goal":"function Factorial_3406(n: nat): nat\n ensures Factorial_3406(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_3406(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_3407","instance":3407,"id":223422,"goal":"function Fib_3407(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_3407(n-1) + Fib_3407(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_3408","instance":3408,"id":223423,"goal":"function Gcd_3408(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_3408(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_3409","instance":3409,"id":223424,"goal":"function Power_3409(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_3409(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_3410","instance":3410,"id":223425,"goal":"function Sum_3410(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_3410(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_3411","instance":3411,"id":223426,"goal":"method BinarySearch_3411(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_3412","instance":3412,"id":223427,"goal":"method InsertSort_3412(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_3413","instance":3413,"id":223428,"goal":"method MergeSort_3413(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_3414","instance":3414,"id":223429,"goal":"method ArrayCopy_3414(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_3415","instance":3415,"id":223430,"goal":"function ListReverse_3415(s: seq): seq\n ensures |ListReverse_3415(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_3415(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_3416","instance":3416,"id":223431,"goal":"function Factorial_3416(n: nat): nat\n ensures Factorial_3416(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_3416(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_3417","instance":3417,"id":223432,"goal":"function Fib_3417(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_3417(n-1) + Fib_3417(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_3418","instance":3418,"id":223433,"goal":"function Gcd_3418(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_3418(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_3419","instance":3419,"id":223434,"goal":"function Power_3419(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_3419(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_3420","instance":3420,"id":223435,"goal":"function Sum_3420(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_3420(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_3421","instance":3421,"id":223436,"goal":"method BinarySearch_3421(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_3422","instance":3422,"id":223437,"goal":"method InsertSort_3422(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_3423","instance":3423,"id":223438,"goal":"method MergeSort_3423(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_3424","instance":3424,"id":223439,"goal":"method ArrayCopy_3424(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_3425","instance":3425,"id":223440,"goal":"function ListReverse_3425(s: seq): seq\n ensures |ListReverse_3425(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_3425(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_3426","instance":3426,"id":223441,"goal":"function Factorial_3426(n: nat): nat\n ensures Factorial_3426(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_3426(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_3427","instance":3427,"id":223442,"goal":"function Fib_3427(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_3427(n-1) + Fib_3427(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_3428","instance":3428,"id":223443,"goal":"function Gcd_3428(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_3428(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_3429","instance":3429,"id":223444,"goal":"function Power_3429(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_3429(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_3430","instance":3430,"id":223445,"goal":"function Sum_3430(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_3430(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_3431","instance":3431,"id":223446,"goal":"method BinarySearch_3431(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_3432","instance":3432,"id":223447,"goal":"method InsertSort_3432(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_3433","instance":3433,"id":223448,"goal":"method MergeSort_3433(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_3434","instance":3434,"id":223449,"goal":"method ArrayCopy_3434(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_3435","instance":3435,"id":223450,"goal":"function ListReverse_3435(s: seq): seq\n ensures |ListReverse_3435(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_3435(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_3436","instance":3436,"id":223451,"goal":"function Factorial_3436(n: nat): nat\n ensures Factorial_3436(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_3436(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_3437","instance":3437,"id":223452,"goal":"function Fib_3437(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_3437(n-1) + Fib_3437(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_3438","instance":3438,"id":223453,"goal":"function Gcd_3438(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_3438(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_3439","instance":3439,"id":223454,"goal":"function Power_3439(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_3439(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_3440","instance":3440,"id":223455,"goal":"function Sum_3440(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_3440(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_3441","instance":3441,"id":223456,"goal":"method BinarySearch_3441(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_3442","instance":3442,"id":223457,"goal":"method InsertSort_3442(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_3443","instance":3443,"id":223458,"goal":"method MergeSort_3443(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_3444","instance":3444,"id":223459,"goal":"method ArrayCopy_3444(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_3445","instance":3445,"id":223460,"goal":"function ListReverse_3445(s: seq): seq\n ensures |ListReverse_3445(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_3445(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_3446","instance":3446,"id":223461,"goal":"function Factorial_3446(n: nat): nat\n ensures Factorial_3446(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_3446(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_3447","instance":3447,"id":223462,"goal":"function Fib_3447(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_3447(n-1) + Fib_3447(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_3448","instance":3448,"id":223463,"goal":"function Gcd_3448(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_3448(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_3449","instance":3449,"id":223464,"goal":"function Power_3449(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_3449(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_3450","instance":3450,"id":223465,"goal":"function Sum_3450(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_3450(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_3451","instance":3451,"id":223466,"goal":"method BinarySearch_3451(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_3452","instance":3452,"id":223467,"goal":"method InsertSort_3452(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_3453","instance":3453,"id":223468,"goal":"method MergeSort_3453(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_3454","instance":3454,"id":223469,"goal":"method ArrayCopy_3454(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_3455","instance":3455,"id":223470,"goal":"function ListReverse_3455(s: seq): seq\n ensures |ListReverse_3455(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_3455(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_3456","instance":3456,"id":223471,"goal":"function Factorial_3456(n: nat): nat\n ensures Factorial_3456(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_3456(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_3457","instance":3457,"id":223472,"goal":"function Fib_3457(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_3457(n-1) + Fib_3457(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_3458","instance":3458,"id":223473,"goal":"function Gcd_3458(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_3458(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_3459","instance":3459,"id":223474,"goal":"function Power_3459(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_3459(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_3460","instance":3460,"id":223475,"goal":"function Sum_3460(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_3460(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_3461","instance":3461,"id":223476,"goal":"method BinarySearch_3461(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_3462","instance":3462,"id":223477,"goal":"method InsertSort_3462(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_3463","instance":3463,"id":223478,"goal":"method MergeSort_3463(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_3464","instance":3464,"id":223479,"goal":"method ArrayCopy_3464(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_3465","instance":3465,"id":223480,"goal":"function ListReverse_3465(s: seq): seq\n ensures |ListReverse_3465(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_3465(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_3466","instance":3466,"id":223481,"goal":"function Factorial_3466(n: nat): nat\n ensures Factorial_3466(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_3466(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_3467","instance":3467,"id":223482,"goal":"function Fib_3467(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_3467(n-1) + Fib_3467(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_3468","instance":3468,"id":223483,"goal":"function Gcd_3468(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_3468(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_3469","instance":3469,"id":223484,"goal":"function Power_3469(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_3469(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_3470","instance":3470,"id":223485,"goal":"function Sum_3470(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_3470(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_3471","instance":3471,"id":223486,"goal":"method BinarySearch_3471(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_3472","instance":3472,"id":223487,"goal":"method InsertSort_3472(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_3473","instance":3473,"id":223488,"goal":"method MergeSort_3473(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_3474","instance":3474,"id":223489,"goal":"method ArrayCopy_3474(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_3475","instance":3475,"id":223490,"goal":"function ListReverse_3475(s: seq): seq\n ensures |ListReverse_3475(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_3475(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_3476","instance":3476,"id":223491,"goal":"function Factorial_3476(n: nat): nat\n ensures Factorial_3476(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_3476(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_3477","instance":3477,"id":223492,"goal":"function Fib_3477(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_3477(n-1) + Fib_3477(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_3478","instance":3478,"id":223493,"goal":"function Gcd_3478(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_3478(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_3479","instance":3479,"id":223494,"goal":"function Power_3479(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_3479(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_3480","instance":3480,"id":223495,"goal":"function Sum_3480(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_3480(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_3481","instance":3481,"id":223496,"goal":"method BinarySearch_3481(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_3482","instance":3482,"id":223497,"goal":"method InsertSort_3482(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_3483","instance":3483,"id":223498,"goal":"method MergeSort_3483(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_3484","instance":3484,"id":223499,"goal":"method ArrayCopy_3484(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_3485","instance":3485,"id":223500,"goal":"function ListReverse_3485(s: seq): seq\n ensures |ListReverse_3485(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_3485(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_3486","instance":3486,"id":223501,"goal":"function Factorial_3486(n: nat): nat\n ensures Factorial_3486(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_3486(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_3487","instance":3487,"id":223502,"goal":"function Fib_3487(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_3487(n-1) + Fib_3487(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_3488","instance":3488,"id":223503,"goal":"function Gcd_3488(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_3488(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_3489","instance":3489,"id":223504,"goal":"function Power_3489(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_3489(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_3490","instance":3490,"id":223505,"goal":"function Sum_3490(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_3490(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_3491","instance":3491,"id":223506,"goal":"method BinarySearch_3491(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_3492","instance":3492,"id":223507,"goal":"method InsertSort_3492(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_3493","instance":3493,"id":223508,"goal":"method MergeSort_3493(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_3494","instance":3494,"id":223509,"goal":"method ArrayCopy_3494(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_3495","instance":3495,"id":223510,"goal":"function ListReverse_3495(s: seq): seq\n ensures |ListReverse_3495(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_3495(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_3496","instance":3496,"id":223511,"goal":"function Factorial_3496(n: nat): nat\n ensures Factorial_3496(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_3496(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_3497","instance":3497,"id":223512,"goal":"function Fib_3497(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_3497(n-1) + Fib_3497(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_3498","instance":3498,"id":223513,"goal":"function Gcd_3498(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_3498(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_3499","instance":3499,"id":223514,"goal":"function Power_3499(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_3499(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_3500","instance":3500,"id":223515,"goal":"function Sum_3500(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_3500(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_3501","instance":3501,"id":223516,"goal":"method BinarySearch_3501(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_3502","instance":3502,"id":223517,"goal":"method InsertSort_3502(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_3503","instance":3503,"id":223518,"goal":"method MergeSort_3503(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_3504","instance":3504,"id":223519,"goal":"method ArrayCopy_3504(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_3505","instance":3505,"id":223520,"goal":"function ListReverse_3505(s: seq): seq\n ensures |ListReverse_3505(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_3505(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_3506","instance":3506,"id":223521,"goal":"function Factorial_3506(n: nat): nat\n ensures Factorial_3506(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_3506(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_3507","instance":3507,"id":223522,"goal":"function Fib_3507(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_3507(n-1) + Fib_3507(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_3508","instance":3508,"id":223523,"goal":"function Gcd_3508(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_3508(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_3509","instance":3509,"id":223524,"goal":"function Power_3509(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_3509(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_3510","instance":3510,"id":223525,"goal":"function Sum_3510(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_3510(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_3511","instance":3511,"id":223526,"goal":"method BinarySearch_3511(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_3512","instance":3512,"id":223527,"goal":"method InsertSort_3512(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_3513","instance":3513,"id":223528,"goal":"method MergeSort_3513(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_3514","instance":3514,"id":223529,"goal":"method ArrayCopy_3514(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_3515","instance":3515,"id":223530,"goal":"function ListReverse_3515(s: seq): seq\n ensures |ListReverse_3515(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_3515(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_3516","instance":3516,"id":223531,"goal":"function Factorial_3516(n: nat): nat\n ensures Factorial_3516(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_3516(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_3517","instance":3517,"id":223532,"goal":"function Fib_3517(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_3517(n-1) + Fib_3517(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_3518","instance":3518,"id":223533,"goal":"function Gcd_3518(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_3518(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_3519","instance":3519,"id":223534,"goal":"function Power_3519(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_3519(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_3520","instance":3520,"id":223535,"goal":"function Sum_3520(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_3520(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_3521","instance":3521,"id":223536,"goal":"method BinarySearch_3521(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_3522","instance":3522,"id":223537,"goal":"method InsertSort_3522(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_3523","instance":3523,"id":223538,"goal":"method MergeSort_3523(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_3524","instance":3524,"id":223539,"goal":"method ArrayCopy_3524(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_3525","instance":3525,"id":223540,"goal":"function ListReverse_3525(s: seq): seq\n ensures |ListReverse_3525(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_3525(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_3526","instance":3526,"id":223541,"goal":"function Factorial_3526(n: nat): nat\n ensures Factorial_3526(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_3526(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_3527","instance":3527,"id":223542,"goal":"function Fib_3527(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_3527(n-1) + Fib_3527(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_3528","instance":3528,"id":223543,"goal":"function Gcd_3528(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_3528(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_3529","instance":3529,"id":223544,"goal":"function Power_3529(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_3529(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_3530","instance":3530,"id":223545,"goal":"function Sum_3530(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_3530(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_3531","instance":3531,"id":223546,"goal":"method BinarySearch_3531(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_3532","instance":3532,"id":223547,"goal":"method InsertSort_3532(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_3533","instance":3533,"id":223548,"goal":"method MergeSort_3533(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_3534","instance":3534,"id":223549,"goal":"method ArrayCopy_3534(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_3535","instance":3535,"id":223550,"goal":"function ListReverse_3535(s: seq): seq\n ensures |ListReverse_3535(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_3535(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_3536","instance":3536,"id":223551,"goal":"function Factorial_3536(n: nat): nat\n ensures Factorial_3536(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_3536(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_3537","instance":3537,"id":223552,"goal":"function Fib_3537(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_3537(n-1) + Fib_3537(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_3538","instance":3538,"id":223553,"goal":"function Gcd_3538(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_3538(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_3539","instance":3539,"id":223554,"goal":"function Power_3539(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_3539(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_3540","instance":3540,"id":223555,"goal":"function Sum_3540(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_3540(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_3541","instance":3541,"id":223556,"goal":"method BinarySearch_3541(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_3542","instance":3542,"id":223557,"goal":"method InsertSort_3542(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_3543","instance":3543,"id":223558,"goal":"method MergeSort_3543(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_3544","instance":3544,"id":223559,"goal":"method ArrayCopy_3544(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_3545","instance":3545,"id":223560,"goal":"function ListReverse_3545(s: seq): seq\n ensures |ListReverse_3545(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_3545(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_3546","instance":3546,"id":223561,"goal":"function Factorial_3546(n: nat): nat\n ensures Factorial_3546(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_3546(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_3547","instance":3547,"id":223562,"goal":"function Fib_3547(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_3547(n-1) + Fib_3547(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_3548","instance":3548,"id":223563,"goal":"function Gcd_3548(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_3548(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_3549","instance":3549,"id":223564,"goal":"function Power_3549(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_3549(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_3550","instance":3550,"id":223565,"goal":"function Sum_3550(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_3550(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_3551","instance":3551,"id":223566,"goal":"method BinarySearch_3551(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_3552","instance":3552,"id":223567,"goal":"method InsertSort_3552(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_3553","instance":3553,"id":223568,"goal":"method MergeSort_3553(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_3554","instance":3554,"id":223569,"goal":"method ArrayCopy_3554(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_3555","instance":3555,"id":223570,"goal":"function ListReverse_3555(s: seq): seq\n ensures |ListReverse_3555(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_3555(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_3556","instance":3556,"id":223571,"goal":"function Factorial_3556(n: nat): nat\n ensures Factorial_3556(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_3556(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_3557","instance":3557,"id":223572,"goal":"function Fib_3557(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_3557(n-1) + Fib_3557(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_3558","instance":3558,"id":223573,"goal":"function Gcd_3558(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_3558(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_3559","instance":3559,"id":223574,"goal":"function Power_3559(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_3559(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_3560","instance":3560,"id":223575,"goal":"function Sum_3560(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_3560(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_3561","instance":3561,"id":223576,"goal":"method BinarySearch_3561(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_3562","instance":3562,"id":223577,"goal":"method InsertSort_3562(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_3563","instance":3563,"id":223578,"goal":"method MergeSort_3563(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_3564","instance":3564,"id":223579,"goal":"method ArrayCopy_3564(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_3565","instance":3565,"id":223580,"goal":"function ListReverse_3565(s: seq): seq\n ensures |ListReverse_3565(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_3565(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_3566","instance":3566,"id":223581,"goal":"function Factorial_3566(n: nat): nat\n ensures Factorial_3566(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_3566(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_3567","instance":3567,"id":223582,"goal":"function Fib_3567(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_3567(n-1) + Fib_3567(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_3568","instance":3568,"id":223583,"goal":"function Gcd_3568(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_3568(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_3569","instance":3569,"id":223584,"goal":"function Power_3569(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_3569(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_3570","instance":3570,"id":223585,"goal":"function Sum_3570(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_3570(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_3571","instance":3571,"id":223586,"goal":"method BinarySearch_3571(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_3572","instance":3572,"id":223587,"goal":"method InsertSort_3572(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_3573","instance":3573,"id":223588,"goal":"method MergeSort_3573(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_3574","instance":3574,"id":223589,"goal":"method ArrayCopy_3574(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_3575","instance":3575,"id":223590,"goal":"function ListReverse_3575(s: seq): seq\n ensures |ListReverse_3575(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_3575(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_3576","instance":3576,"id":223591,"goal":"function Factorial_3576(n: nat): nat\n ensures Factorial_3576(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_3576(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_3577","instance":3577,"id":223592,"goal":"function Fib_3577(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_3577(n-1) + Fib_3577(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_3578","instance":3578,"id":223593,"goal":"function Gcd_3578(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_3578(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_3579","instance":3579,"id":223594,"goal":"function Power_3579(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_3579(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_3580","instance":3580,"id":223595,"goal":"function Sum_3580(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_3580(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_3581","instance":3581,"id":223596,"goal":"method BinarySearch_3581(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_3582","instance":3582,"id":223597,"goal":"method InsertSort_3582(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_3583","instance":3583,"id":223598,"goal":"method MergeSort_3583(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_3584","instance":3584,"id":223599,"goal":"method ArrayCopy_3584(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_3585","instance":3585,"id":223600,"goal":"function ListReverse_3585(s: seq): seq\n ensures |ListReverse_3585(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_3585(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_3586","instance":3586,"id":223601,"goal":"function Factorial_3586(n: nat): nat\n ensures Factorial_3586(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_3586(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_3587","instance":3587,"id":223602,"goal":"function Fib_3587(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_3587(n-1) + Fib_3587(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_3588","instance":3588,"id":223603,"goal":"function Gcd_3588(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_3588(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_3589","instance":3589,"id":223604,"goal":"function Power_3589(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_3589(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_3590","instance":3590,"id":223605,"goal":"function Sum_3590(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_3590(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_3591","instance":3591,"id":223606,"goal":"method BinarySearch_3591(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_3592","instance":3592,"id":223607,"goal":"method InsertSort_3592(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_3593","instance":3593,"id":223608,"goal":"method MergeSort_3593(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_3594","instance":3594,"id":223609,"goal":"method ArrayCopy_3594(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_3595","instance":3595,"id":223610,"goal":"function ListReverse_3595(s: seq): seq\n ensures |ListReverse_3595(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_3595(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_3596","instance":3596,"id":223611,"goal":"function Factorial_3596(n: nat): nat\n ensures Factorial_3596(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_3596(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_3597","instance":3597,"id":223612,"goal":"function Fib_3597(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_3597(n-1) + Fib_3597(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_3598","instance":3598,"id":223613,"goal":"function Gcd_3598(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_3598(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_3599","instance":3599,"id":223614,"goal":"function Power_3599(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_3599(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_3600","instance":3600,"id":223615,"goal":"function Sum_3600(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_3600(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_3601","instance":3601,"id":223616,"goal":"method BinarySearch_3601(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_3602","instance":3602,"id":223617,"goal":"method InsertSort_3602(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_3603","instance":3603,"id":223618,"goal":"method MergeSort_3603(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_3604","instance":3604,"id":223619,"goal":"method ArrayCopy_3604(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_3605","instance":3605,"id":223620,"goal":"function ListReverse_3605(s: seq): seq\n ensures |ListReverse_3605(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_3605(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_3606","instance":3606,"id":223621,"goal":"function Factorial_3606(n: nat): nat\n ensures Factorial_3606(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_3606(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_3607","instance":3607,"id":223622,"goal":"function Fib_3607(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_3607(n-1) + Fib_3607(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_3608","instance":3608,"id":223623,"goal":"function Gcd_3608(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_3608(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_3609","instance":3609,"id":223624,"goal":"function Power_3609(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_3609(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_3610","instance":3610,"id":223625,"goal":"function Sum_3610(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_3610(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_3611","instance":3611,"id":223626,"goal":"method BinarySearch_3611(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_3612","instance":3612,"id":223627,"goal":"method InsertSort_3612(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_3613","instance":3613,"id":223628,"goal":"method MergeSort_3613(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_3614","instance":3614,"id":223629,"goal":"method ArrayCopy_3614(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_3615","instance":3615,"id":223630,"goal":"function ListReverse_3615(s: seq): seq\n ensures |ListReverse_3615(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_3615(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_3616","instance":3616,"id":223631,"goal":"function Factorial_3616(n: nat): nat\n ensures Factorial_3616(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_3616(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_3617","instance":3617,"id":223632,"goal":"function Fib_3617(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_3617(n-1) + Fib_3617(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_3618","instance":3618,"id":223633,"goal":"function Gcd_3618(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_3618(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_3619","instance":3619,"id":223634,"goal":"function Power_3619(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_3619(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_3620","instance":3620,"id":223635,"goal":"function Sum_3620(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_3620(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_3621","instance":3621,"id":223636,"goal":"method BinarySearch_3621(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_3622","instance":3622,"id":223637,"goal":"method InsertSort_3622(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_3623","instance":3623,"id":223638,"goal":"method MergeSort_3623(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_3624","instance":3624,"id":223639,"goal":"method ArrayCopy_3624(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_3625","instance":3625,"id":223640,"goal":"function ListReverse_3625(s: seq): seq\n ensures |ListReverse_3625(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_3625(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_3626","instance":3626,"id":223641,"goal":"function Factorial_3626(n: nat): nat\n ensures Factorial_3626(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_3626(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_3627","instance":3627,"id":223642,"goal":"function Fib_3627(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_3627(n-1) + Fib_3627(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_3628","instance":3628,"id":223643,"goal":"function Gcd_3628(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_3628(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_3629","instance":3629,"id":223644,"goal":"function Power_3629(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_3629(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_3630","instance":3630,"id":223645,"goal":"function Sum_3630(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_3630(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_3631","instance":3631,"id":223646,"goal":"method BinarySearch_3631(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_3632","instance":3632,"id":223647,"goal":"method InsertSort_3632(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_3633","instance":3633,"id":223648,"goal":"method MergeSort_3633(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_3634","instance":3634,"id":223649,"goal":"method ArrayCopy_3634(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_3635","instance":3635,"id":223650,"goal":"function ListReverse_3635(s: seq): seq\n ensures |ListReverse_3635(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_3635(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_3636","instance":3636,"id":223651,"goal":"function Factorial_3636(n: nat): nat\n ensures Factorial_3636(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_3636(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_3637","instance":3637,"id":223652,"goal":"function Fib_3637(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_3637(n-1) + Fib_3637(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_3638","instance":3638,"id":223653,"goal":"function Gcd_3638(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_3638(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_3639","instance":3639,"id":223654,"goal":"function Power_3639(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_3639(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_3640","instance":3640,"id":223655,"goal":"function Sum_3640(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_3640(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_3641","instance":3641,"id":223656,"goal":"method BinarySearch_3641(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_3642","instance":3642,"id":223657,"goal":"method InsertSort_3642(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_3643","instance":3643,"id":223658,"goal":"method MergeSort_3643(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_3644","instance":3644,"id":223659,"goal":"method ArrayCopy_3644(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_3645","instance":3645,"id":223660,"goal":"function ListReverse_3645(s: seq): seq\n ensures |ListReverse_3645(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_3645(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_3646","instance":3646,"id":223661,"goal":"function Factorial_3646(n: nat): nat\n ensures Factorial_3646(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_3646(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_3647","instance":3647,"id":223662,"goal":"function Fib_3647(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_3647(n-1) + Fib_3647(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_3648","instance":3648,"id":223663,"goal":"function Gcd_3648(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_3648(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_3649","instance":3649,"id":223664,"goal":"function Power_3649(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_3649(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_3650","instance":3650,"id":223665,"goal":"function Sum_3650(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_3650(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_3651","instance":3651,"id":223666,"goal":"method BinarySearch_3651(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_3652","instance":3652,"id":223667,"goal":"method InsertSort_3652(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_3653","instance":3653,"id":223668,"goal":"method MergeSort_3653(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_3654","instance":3654,"id":223669,"goal":"method ArrayCopy_3654(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_3655","instance":3655,"id":223670,"goal":"function ListReverse_3655(s: seq): seq\n ensures |ListReverse_3655(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_3655(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_3656","instance":3656,"id":223671,"goal":"function Factorial_3656(n: nat): nat\n ensures Factorial_3656(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_3656(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_3657","instance":3657,"id":223672,"goal":"function Fib_3657(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_3657(n-1) + Fib_3657(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_3658","instance":3658,"id":223673,"goal":"function Gcd_3658(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_3658(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_3659","instance":3659,"id":223674,"goal":"function Power_3659(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_3659(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_3660","instance":3660,"id":223675,"goal":"function Sum_3660(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_3660(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_3661","instance":3661,"id":223676,"goal":"method BinarySearch_3661(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_3662","instance":3662,"id":223677,"goal":"method InsertSort_3662(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_3663","instance":3663,"id":223678,"goal":"method MergeSort_3663(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_3664","instance":3664,"id":223679,"goal":"method ArrayCopy_3664(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_3665","instance":3665,"id":223680,"goal":"function ListReverse_3665(s: seq): seq\n ensures |ListReverse_3665(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_3665(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_3666","instance":3666,"id":223681,"goal":"function Factorial_3666(n: nat): nat\n ensures Factorial_3666(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_3666(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_3667","instance":3667,"id":223682,"goal":"function Fib_3667(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_3667(n-1) + Fib_3667(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_3668","instance":3668,"id":223683,"goal":"function Gcd_3668(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_3668(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_3669","instance":3669,"id":223684,"goal":"function Power_3669(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_3669(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_3670","instance":3670,"id":223685,"goal":"function Sum_3670(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_3670(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_3671","instance":3671,"id":223686,"goal":"method BinarySearch_3671(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_3672","instance":3672,"id":223687,"goal":"method InsertSort_3672(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_3673","instance":3673,"id":223688,"goal":"method MergeSort_3673(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_3674","instance":3674,"id":223689,"goal":"method ArrayCopy_3674(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_3675","instance":3675,"id":223690,"goal":"function ListReverse_3675(s: seq): seq\n ensures |ListReverse_3675(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_3675(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_3676","instance":3676,"id":223691,"goal":"function Factorial_3676(n: nat): nat\n ensures Factorial_3676(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_3676(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_3677","instance":3677,"id":223692,"goal":"function Fib_3677(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_3677(n-1) + Fib_3677(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_3678","instance":3678,"id":223693,"goal":"function Gcd_3678(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_3678(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_3679","instance":3679,"id":223694,"goal":"function Power_3679(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_3679(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_3680","instance":3680,"id":223695,"goal":"function Sum_3680(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_3680(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_3681","instance":3681,"id":223696,"goal":"method BinarySearch_3681(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_3682","instance":3682,"id":223697,"goal":"method InsertSort_3682(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_3683","instance":3683,"id":223698,"goal":"method MergeSort_3683(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_3684","instance":3684,"id":223699,"goal":"method ArrayCopy_3684(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_3685","instance":3685,"id":223700,"goal":"function ListReverse_3685(s: seq): seq\n ensures |ListReverse_3685(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_3685(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_3686","instance":3686,"id":223701,"goal":"function Factorial_3686(n: nat): nat\n ensures Factorial_3686(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_3686(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_3687","instance":3687,"id":223702,"goal":"function Fib_3687(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_3687(n-1) + Fib_3687(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_3688","instance":3688,"id":223703,"goal":"function Gcd_3688(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_3688(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_3689","instance":3689,"id":223704,"goal":"function Power_3689(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_3689(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_3690","instance":3690,"id":223705,"goal":"function Sum_3690(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_3690(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_3691","instance":3691,"id":223706,"goal":"method BinarySearch_3691(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_3692","instance":3692,"id":223707,"goal":"method InsertSort_3692(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_3693","instance":3693,"id":223708,"goal":"method MergeSort_3693(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_3694","instance":3694,"id":223709,"goal":"method ArrayCopy_3694(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_3695","instance":3695,"id":223710,"goal":"function ListReverse_3695(s: seq): seq\n ensures |ListReverse_3695(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_3695(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_3696","instance":3696,"id":223711,"goal":"function Factorial_3696(n: nat): nat\n ensures Factorial_3696(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_3696(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_3697","instance":3697,"id":223712,"goal":"function Fib_3697(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_3697(n-1) + Fib_3697(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_3698","instance":3698,"id":223713,"goal":"function Gcd_3698(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_3698(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_3699","instance":3699,"id":223714,"goal":"function Power_3699(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_3699(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_3700","instance":3700,"id":223715,"goal":"function Sum_3700(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_3700(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_3701","instance":3701,"id":223716,"goal":"method BinarySearch_3701(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_3702","instance":3702,"id":223717,"goal":"method InsertSort_3702(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_3703","instance":3703,"id":223718,"goal":"method MergeSort_3703(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_3704","instance":3704,"id":223719,"goal":"method ArrayCopy_3704(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_3705","instance":3705,"id":223720,"goal":"function ListReverse_3705(s: seq): seq\n ensures |ListReverse_3705(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_3705(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_3706","instance":3706,"id":223721,"goal":"function Factorial_3706(n: nat): nat\n ensures Factorial_3706(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_3706(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_3707","instance":3707,"id":223722,"goal":"function Fib_3707(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_3707(n-1) + Fib_3707(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_3708","instance":3708,"id":223723,"goal":"function Gcd_3708(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_3708(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_3709","instance":3709,"id":223724,"goal":"function Power_3709(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_3709(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_3710","instance":3710,"id":223725,"goal":"function Sum_3710(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_3710(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_3711","instance":3711,"id":223726,"goal":"method BinarySearch_3711(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_3712","instance":3712,"id":223727,"goal":"method InsertSort_3712(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_3713","instance":3713,"id":223728,"goal":"method MergeSort_3713(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_3714","instance":3714,"id":223729,"goal":"method ArrayCopy_3714(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_3715","instance":3715,"id":223730,"goal":"function ListReverse_3715(s: seq): seq\n ensures |ListReverse_3715(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_3715(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_3716","instance":3716,"id":223731,"goal":"function Factorial_3716(n: nat): nat\n ensures Factorial_3716(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_3716(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_3717","instance":3717,"id":223732,"goal":"function Fib_3717(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_3717(n-1) + Fib_3717(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_3718","instance":3718,"id":223733,"goal":"function Gcd_3718(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_3718(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_3719","instance":3719,"id":223734,"goal":"function Power_3719(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_3719(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_3720","instance":3720,"id":223735,"goal":"function Sum_3720(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_3720(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_3721","instance":3721,"id":223736,"goal":"method BinarySearch_3721(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_3722","instance":3722,"id":223737,"goal":"method InsertSort_3722(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_3723","instance":3723,"id":223738,"goal":"method MergeSort_3723(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_3724","instance":3724,"id":223739,"goal":"method ArrayCopy_3724(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_3725","instance":3725,"id":223740,"goal":"function ListReverse_3725(s: seq): seq\n ensures |ListReverse_3725(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_3725(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_3726","instance":3726,"id":223741,"goal":"function Factorial_3726(n: nat): nat\n ensures Factorial_3726(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_3726(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_3727","instance":3727,"id":223742,"goal":"function Fib_3727(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_3727(n-1) + Fib_3727(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_3728","instance":3728,"id":223743,"goal":"function Gcd_3728(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_3728(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_3729","instance":3729,"id":223744,"goal":"function Power_3729(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_3729(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_3730","instance":3730,"id":223745,"goal":"function Sum_3730(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_3730(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_3731","instance":3731,"id":223746,"goal":"method BinarySearch_3731(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_3732","instance":3732,"id":223747,"goal":"method InsertSort_3732(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_3733","instance":3733,"id":223748,"goal":"method MergeSort_3733(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_3734","instance":3734,"id":223749,"goal":"method ArrayCopy_3734(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_3735","instance":3735,"id":223750,"goal":"function ListReverse_3735(s: seq): seq\n ensures |ListReverse_3735(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_3735(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_3736","instance":3736,"id":223751,"goal":"function Factorial_3736(n: nat): nat\n ensures Factorial_3736(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_3736(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_3737","instance":3737,"id":223752,"goal":"function Fib_3737(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_3737(n-1) + Fib_3737(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_3738","instance":3738,"id":223753,"goal":"function Gcd_3738(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_3738(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_3739","instance":3739,"id":223754,"goal":"function Power_3739(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_3739(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_3740","instance":3740,"id":223755,"goal":"function Sum_3740(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_3740(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_3741","instance":3741,"id":223756,"goal":"method BinarySearch_3741(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_3742","instance":3742,"id":223757,"goal":"method InsertSort_3742(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_3743","instance":3743,"id":223758,"goal":"method MergeSort_3743(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_3744","instance":3744,"id":223759,"goal":"method ArrayCopy_3744(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_3745","instance":3745,"id":223760,"goal":"function ListReverse_3745(s: seq): seq\n ensures |ListReverse_3745(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_3745(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_3746","instance":3746,"id":223761,"goal":"function Factorial_3746(n: nat): nat\n ensures Factorial_3746(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_3746(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_3747","instance":3747,"id":223762,"goal":"function Fib_3747(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_3747(n-1) + Fib_3747(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_3748","instance":3748,"id":223763,"goal":"function Gcd_3748(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_3748(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_3749","instance":3749,"id":223764,"goal":"function Power_3749(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_3749(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_3750","instance":3750,"id":223765,"goal":"function Sum_3750(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_3750(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_3751","instance":3751,"id":223766,"goal":"method BinarySearch_3751(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_3752","instance":3752,"id":223767,"goal":"method InsertSort_3752(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_3753","instance":3753,"id":223768,"goal":"method MergeSort_3753(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_3754","instance":3754,"id":223769,"goal":"method ArrayCopy_3754(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_3755","instance":3755,"id":223770,"goal":"function ListReverse_3755(s: seq): seq\n ensures |ListReverse_3755(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_3755(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_3756","instance":3756,"id":223771,"goal":"function Factorial_3756(n: nat): nat\n ensures Factorial_3756(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_3756(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_3757","instance":3757,"id":223772,"goal":"function Fib_3757(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_3757(n-1) + Fib_3757(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_3758","instance":3758,"id":223773,"goal":"function Gcd_3758(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_3758(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_3759","instance":3759,"id":223774,"goal":"function Power_3759(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_3759(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_3760","instance":3760,"id":223775,"goal":"function Sum_3760(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_3760(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_3761","instance":3761,"id":223776,"goal":"method BinarySearch_3761(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_3762","instance":3762,"id":223777,"goal":"method InsertSort_3762(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_3763","instance":3763,"id":223778,"goal":"method MergeSort_3763(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_3764","instance":3764,"id":223779,"goal":"method ArrayCopy_3764(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_3765","instance":3765,"id":223780,"goal":"function ListReverse_3765(s: seq): seq\n ensures |ListReverse_3765(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_3765(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_3766","instance":3766,"id":223781,"goal":"function Factorial_3766(n: nat): nat\n ensures Factorial_3766(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_3766(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_3767","instance":3767,"id":223782,"goal":"function Fib_3767(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_3767(n-1) + Fib_3767(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_3768","instance":3768,"id":223783,"goal":"function Gcd_3768(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_3768(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_3769","instance":3769,"id":223784,"goal":"function Power_3769(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_3769(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_3770","instance":3770,"id":223785,"goal":"function Sum_3770(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_3770(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_3771","instance":3771,"id":223786,"goal":"method BinarySearch_3771(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_3772","instance":3772,"id":223787,"goal":"method InsertSort_3772(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_3773","instance":3773,"id":223788,"goal":"method MergeSort_3773(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_3774","instance":3774,"id":223789,"goal":"method ArrayCopy_3774(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_3775","instance":3775,"id":223790,"goal":"function ListReverse_3775(s: seq): seq\n ensures |ListReverse_3775(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_3775(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_3776","instance":3776,"id":223791,"goal":"function Factorial_3776(n: nat): nat\n ensures Factorial_3776(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_3776(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_3777","instance":3777,"id":223792,"goal":"function Fib_3777(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_3777(n-1) + Fib_3777(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_3778","instance":3778,"id":223793,"goal":"function Gcd_3778(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_3778(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_3779","instance":3779,"id":223794,"goal":"function Power_3779(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_3779(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_3780","instance":3780,"id":223795,"goal":"function Sum_3780(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_3780(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_3781","instance":3781,"id":223796,"goal":"method BinarySearch_3781(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_3782","instance":3782,"id":223797,"goal":"method InsertSort_3782(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_3783","instance":3783,"id":223798,"goal":"method MergeSort_3783(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_3784","instance":3784,"id":223799,"goal":"method ArrayCopy_3784(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_3785","instance":3785,"id":223800,"goal":"function ListReverse_3785(s: seq): seq\n ensures |ListReverse_3785(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_3785(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_3786","instance":3786,"id":223801,"goal":"function Factorial_3786(n: nat): nat\n ensures Factorial_3786(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_3786(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_3787","instance":3787,"id":223802,"goal":"function Fib_3787(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_3787(n-1) + Fib_3787(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_3788","instance":3788,"id":223803,"goal":"function Gcd_3788(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_3788(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_3789","instance":3789,"id":223804,"goal":"function Power_3789(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_3789(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_3790","instance":3790,"id":223805,"goal":"function Sum_3790(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_3790(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_3791","instance":3791,"id":223806,"goal":"method BinarySearch_3791(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_3792","instance":3792,"id":223807,"goal":"method InsertSort_3792(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_3793","instance":3793,"id":223808,"goal":"method MergeSort_3793(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_3794","instance":3794,"id":223809,"goal":"method ArrayCopy_3794(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_3795","instance":3795,"id":223810,"goal":"function ListReverse_3795(s: seq): seq\n ensures |ListReverse_3795(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_3795(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_3796","instance":3796,"id":223811,"goal":"function Factorial_3796(n: nat): nat\n ensures Factorial_3796(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_3796(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_3797","instance":3797,"id":223812,"goal":"function Fib_3797(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_3797(n-1) + Fib_3797(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_3798","instance":3798,"id":223813,"goal":"function Gcd_3798(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_3798(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_3799","instance":3799,"id":223814,"goal":"function Power_3799(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_3799(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_3800","instance":3800,"id":223815,"goal":"function Sum_3800(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_3800(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_3801","instance":3801,"id":223816,"goal":"method BinarySearch_3801(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_3802","instance":3802,"id":223817,"goal":"method InsertSort_3802(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_3803","instance":3803,"id":223818,"goal":"method MergeSort_3803(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_3804","instance":3804,"id":223819,"goal":"method ArrayCopy_3804(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_3805","instance":3805,"id":223820,"goal":"function ListReverse_3805(s: seq): seq\n ensures |ListReverse_3805(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_3805(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_3806","instance":3806,"id":223821,"goal":"function Factorial_3806(n: nat): nat\n ensures Factorial_3806(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_3806(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_3807","instance":3807,"id":223822,"goal":"function Fib_3807(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_3807(n-1) + Fib_3807(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_3808","instance":3808,"id":223823,"goal":"function Gcd_3808(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_3808(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_3809","instance":3809,"id":223824,"goal":"function Power_3809(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_3809(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_3810","instance":3810,"id":223825,"goal":"function Sum_3810(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_3810(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_3811","instance":3811,"id":223826,"goal":"method BinarySearch_3811(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_3812","instance":3812,"id":223827,"goal":"method InsertSort_3812(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_3813","instance":3813,"id":223828,"goal":"method MergeSort_3813(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_3814","instance":3814,"id":223829,"goal":"method ArrayCopy_3814(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_3815","instance":3815,"id":223830,"goal":"function ListReverse_3815(s: seq): seq\n ensures |ListReverse_3815(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_3815(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_3816","instance":3816,"id":223831,"goal":"function Factorial_3816(n: nat): nat\n ensures Factorial_3816(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_3816(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_3817","instance":3817,"id":223832,"goal":"function Fib_3817(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_3817(n-1) + Fib_3817(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_3818","instance":3818,"id":223833,"goal":"function Gcd_3818(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_3818(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_3819","instance":3819,"id":223834,"goal":"function Power_3819(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_3819(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_3820","instance":3820,"id":223835,"goal":"function Sum_3820(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_3820(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_3821","instance":3821,"id":223836,"goal":"method BinarySearch_3821(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_3822","instance":3822,"id":223837,"goal":"method InsertSort_3822(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_3823","instance":3823,"id":223838,"goal":"method MergeSort_3823(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_3824","instance":3824,"id":223839,"goal":"method ArrayCopy_3824(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_3825","instance":3825,"id":223840,"goal":"function ListReverse_3825(s: seq): seq\n ensures |ListReverse_3825(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_3825(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_3826","instance":3826,"id":223841,"goal":"function Factorial_3826(n: nat): nat\n ensures Factorial_3826(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_3826(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_3827","instance":3827,"id":223842,"goal":"function Fib_3827(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_3827(n-1) + Fib_3827(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_3828","instance":3828,"id":223843,"goal":"function Gcd_3828(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_3828(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_3829","instance":3829,"id":223844,"goal":"function Power_3829(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_3829(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_3830","instance":3830,"id":223845,"goal":"function Sum_3830(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_3830(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_3831","instance":3831,"id":223846,"goal":"method BinarySearch_3831(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_3832","instance":3832,"id":223847,"goal":"method InsertSort_3832(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_3833","instance":3833,"id":223848,"goal":"method MergeSort_3833(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_3834","instance":3834,"id":223849,"goal":"method ArrayCopy_3834(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_3835","instance":3835,"id":223850,"goal":"function ListReverse_3835(s: seq): seq\n ensures |ListReverse_3835(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_3835(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_3836","instance":3836,"id":223851,"goal":"function Factorial_3836(n: nat): nat\n ensures Factorial_3836(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_3836(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_3837","instance":3837,"id":223852,"goal":"function Fib_3837(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_3837(n-1) + Fib_3837(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_3838","instance":3838,"id":223853,"goal":"function Gcd_3838(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_3838(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_3839","instance":3839,"id":223854,"goal":"function Power_3839(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_3839(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_3840","instance":3840,"id":223855,"goal":"function Sum_3840(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_3840(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_3841","instance":3841,"id":223856,"goal":"method BinarySearch_3841(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_3842","instance":3842,"id":223857,"goal":"method InsertSort_3842(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_3843","instance":3843,"id":223858,"goal":"method MergeSort_3843(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_3844","instance":3844,"id":223859,"goal":"method ArrayCopy_3844(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_3845","instance":3845,"id":223860,"goal":"function ListReverse_3845(s: seq): seq\n ensures |ListReverse_3845(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_3845(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_3846","instance":3846,"id":223861,"goal":"function Factorial_3846(n: nat): nat\n ensures Factorial_3846(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_3846(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_3847","instance":3847,"id":223862,"goal":"function Fib_3847(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_3847(n-1) + Fib_3847(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_3848","instance":3848,"id":223863,"goal":"function Gcd_3848(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_3848(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_3849","instance":3849,"id":223864,"goal":"function Power_3849(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_3849(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_3850","instance":3850,"id":223865,"goal":"function Sum_3850(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_3850(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_3851","instance":3851,"id":223866,"goal":"method BinarySearch_3851(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_3852","instance":3852,"id":223867,"goal":"method InsertSort_3852(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_3853","instance":3853,"id":223868,"goal":"method MergeSort_3853(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_3854","instance":3854,"id":223869,"goal":"method ArrayCopy_3854(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_3855","instance":3855,"id":223870,"goal":"function ListReverse_3855(s: seq): seq\n ensures |ListReverse_3855(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_3855(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_3856","instance":3856,"id":223871,"goal":"function Factorial_3856(n: nat): nat\n ensures Factorial_3856(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_3856(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_3857","instance":3857,"id":223872,"goal":"function Fib_3857(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_3857(n-1) + Fib_3857(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_3858","instance":3858,"id":223873,"goal":"function Gcd_3858(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_3858(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_3859","instance":3859,"id":223874,"goal":"function Power_3859(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_3859(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_3860","instance":3860,"id":223875,"goal":"function Sum_3860(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_3860(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_3861","instance":3861,"id":223876,"goal":"method BinarySearch_3861(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_3862","instance":3862,"id":223877,"goal":"method InsertSort_3862(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_3863","instance":3863,"id":223878,"goal":"method MergeSort_3863(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_3864","instance":3864,"id":223879,"goal":"method ArrayCopy_3864(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_3865","instance":3865,"id":223880,"goal":"function ListReverse_3865(s: seq): seq\n ensures |ListReverse_3865(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_3865(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_3866","instance":3866,"id":223881,"goal":"function Factorial_3866(n: nat): nat\n ensures Factorial_3866(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_3866(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_3867","instance":3867,"id":223882,"goal":"function Fib_3867(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_3867(n-1) + Fib_3867(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_3868","instance":3868,"id":223883,"goal":"function Gcd_3868(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_3868(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_3869","instance":3869,"id":223884,"goal":"function Power_3869(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_3869(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_3870","instance":3870,"id":223885,"goal":"function Sum_3870(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_3870(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_3871","instance":3871,"id":223886,"goal":"method BinarySearch_3871(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_3872","instance":3872,"id":223887,"goal":"method InsertSort_3872(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_3873","instance":3873,"id":223888,"goal":"method MergeSort_3873(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_3874","instance":3874,"id":223889,"goal":"method ArrayCopy_3874(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_3875","instance":3875,"id":223890,"goal":"function ListReverse_3875(s: seq): seq\n ensures |ListReverse_3875(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_3875(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_3876","instance":3876,"id":223891,"goal":"function Factorial_3876(n: nat): nat\n ensures Factorial_3876(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_3876(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_3877","instance":3877,"id":223892,"goal":"function Fib_3877(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_3877(n-1) + Fib_3877(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_3878","instance":3878,"id":223893,"goal":"function Gcd_3878(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_3878(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_3879","instance":3879,"id":223894,"goal":"function Power_3879(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_3879(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_3880","instance":3880,"id":223895,"goal":"function Sum_3880(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_3880(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_3881","instance":3881,"id":223896,"goal":"method BinarySearch_3881(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_3882","instance":3882,"id":223897,"goal":"method InsertSort_3882(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_3883","instance":3883,"id":223898,"goal":"method MergeSort_3883(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_3884","instance":3884,"id":223899,"goal":"method ArrayCopy_3884(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_3885","instance":3885,"id":223900,"goal":"function ListReverse_3885(s: seq): seq\n ensures |ListReverse_3885(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_3885(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_3886","instance":3886,"id":223901,"goal":"function Factorial_3886(n: nat): nat\n ensures Factorial_3886(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_3886(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_3887","instance":3887,"id":223902,"goal":"function Fib_3887(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_3887(n-1) + Fib_3887(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_3888","instance":3888,"id":223903,"goal":"function Gcd_3888(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_3888(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_3889","instance":3889,"id":223904,"goal":"function Power_3889(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_3889(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_3890","instance":3890,"id":223905,"goal":"function Sum_3890(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_3890(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_3891","instance":3891,"id":223906,"goal":"method BinarySearch_3891(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_3892","instance":3892,"id":223907,"goal":"method InsertSort_3892(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_3893","instance":3893,"id":223908,"goal":"method MergeSort_3893(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_3894","instance":3894,"id":223909,"goal":"method ArrayCopy_3894(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_3895","instance":3895,"id":223910,"goal":"function ListReverse_3895(s: seq): seq\n ensures |ListReverse_3895(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_3895(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_3896","instance":3896,"id":223911,"goal":"function Factorial_3896(n: nat): nat\n ensures Factorial_3896(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_3896(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_3897","instance":3897,"id":223912,"goal":"function Fib_3897(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_3897(n-1) + Fib_3897(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_3898","instance":3898,"id":223913,"goal":"function Gcd_3898(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_3898(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_3899","instance":3899,"id":223914,"goal":"function Power_3899(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_3899(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_3900","instance":3900,"id":223915,"goal":"function Sum_3900(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_3900(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_3901","instance":3901,"id":223916,"goal":"method BinarySearch_3901(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_3902","instance":3902,"id":223917,"goal":"method InsertSort_3902(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_3903","instance":3903,"id":223918,"goal":"method MergeSort_3903(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_3904","instance":3904,"id":223919,"goal":"method ArrayCopy_3904(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_3905","instance":3905,"id":223920,"goal":"function ListReverse_3905(s: seq): seq\n ensures |ListReverse_3905(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_3905(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_3906","instance":3906,"id":223921,"goal":"function Factorial_3906(n: nat): nat\n ensures Factorial_3906(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_3906(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_3907","instance":3907,"id":223922,"goal":"function Fib_3907(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_3907(n-1) + Fib_3907(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_3908","instance":3908,"id":223923,"goal":"function Gcd_3908(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_3908(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_3909","instance":3909,"id":223924,"goal":"function Power_3909(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_3909(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_3910","instance":3910,"id":223925,"goal":"function Sum_3910(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_3910(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_3911","instance":3911,"id":223926,"goal":"method BinarySearch_3911(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_3912","instance":3912,"id":223927,"goal":"method InsertSort_3912(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_3913","instance":3913,"id":223928,"goal":"method MergeSort_3913(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_3914","instance":3914,"id":223929,"goal":"method ArrayCopy_3914(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_3915","instance":3915,"id":223930,"goal":"function ListReverse_3915(s: seq): seq\n ensures |ListReverse_3915(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_3915(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_3916","instance":3916,"id":223931,"goal":"function Factorial_3916(n: nat): nat\n ensures Factorial_3916(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_3916(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_3917","instance":3917,"id":223932,"goal":"function Fib_3917(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_3917(n-1) + Fib_3917(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_3918","instance":3918,"id":223933,"goal":"function Gcd_3918(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_3918(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_3919","instance":3919,"id":223934,"goal":"function Power_3919(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_3919(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_3920","instance":3920,"id":223935,"goal":"function Sum_3920(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_3920(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_3921","instance":3921,"id":223936,"goal":"method BinarySearch_3921(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_3922","instance":3922,"id":223937,"goal":"method InsertSort_3922(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_3923","instance":3923,"id":223938,"goal":"method MergeSort_3923(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_3924","instance":3924,"id":223939,"goal":"method ArrayCopy_3924(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_3925","instance":3925,"id":223940,"goal":"function ListReverse_3925(s: seq): seq\n ensures |ListReverse_3925(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_3925(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_3926","instance":3926,"id":223941,"goal":"function Factorial_3926(n: nat): nat\n ensures Factorial_3926(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_3926(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_3927","instance":3927,"id":223942,"goal":"function Fib_3927(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_3927(n-1) + Fib_3927(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_3928","instance":3928,"id":223943,"goal":"function Gcd_3928(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_3928(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_3929","instance":3929,"id":223944,"goal":"function Power_3929(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_3929(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_3930","instance":3930,"id":223945,"goal":"function Sum_3930(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_3930(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_3931","instance":3931,"id":223946,"goal":"method BinarySearch_3931(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_3932","instance":3932,"id":223947,"goal":"method InsertSort_3932(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_3933","instance":3933,"id":223948,"goal":"method MergeSort_3933(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_3934","instance":3934,"id":223949,"goal":"method ArrayCopy_3934(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_3935","instance":3935,"id":223950,"goal":"function ListReverse_3935(s: seq): seq\n ensures |ListReverse_3935(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_3935(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_3936","instance":3936,"id":223951,"goal":"function Factorial_3936(n: nat): nat\n ensures Factorial_3936(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_3936(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_3937","instance":3937,"id":223952,"goal":"function Fib_3937(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_3937(n-1) + Fib_3937(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_3938","instance":3938,"id":223953,"goal":"function Gcd_3938(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_3938(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_3939","instance":3939,"id":223954,"goal":"function Power_3939(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_3939(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_3940","instance":3940,"id":223955,"goal":"function Sum_3940(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_3940(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_3941","instance":3941,"id":223956,"goal":"method BinarySearch_3941(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_3942","instance":3942,"id":223957,"goal":"method InsertSort_3942(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_3943","instance":3943,"id":223958,"goal":"method MergeSort_3943(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_3944","instance":3944,"id":223959,"goal":"method ArrayCopy_3944(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_3945","instance":3945,"id":223960,"goal":"function ListReverse_3945(s: seq): seq\n ensures |ListReverse_3945(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_3945(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_3946","instance":3946,"id":223961,"goal":"function Factorial_3946(n: nat): nat\n ensures Factorial_3946(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_3946(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_3947","instance":3947,"id":223962,"goal":"function Fib_3947(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_3947(n-1) + Fib_3947(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_3948","instance":3948,"id":223963,"goal":"function Gcd_3948(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_3948(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_3949","instance":3949,"id":223964,"goal":"function Power_3949(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_3949(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_3950","instance":3950,"id":223965,"goal":"function Sum_3950(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_3950(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_3951","instance":3951,"id":223966,"goal":"method BinarySearch_3951(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_3952","instance":3952,"id":223967,"goal":"method InsertSort_3952(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_3953","instance":3953,"id":223968,"goal":"method MergeSort_3953(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_3954","instance":3954,"id":223969,"goal":"method ArrayCopy_3954(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_3955","instance":3955,"id":223970,"goal":"function ListReverse_3955(s: seq): seq\n ensures |ListReverse_3955(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_3955(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_3956","instance":3956,"id":223971,"goal":"function Factorial_3956(n: nat): nat\n ensures Factorial_3956(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_3956(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_3957","instance":3957,"id":223972,"goal":"function Fib_3957(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_3957(n-1) + Fib_3957(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_3958","instance":3958,"id":223973,"goal":"function Gcd_3958(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_3958(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_3959","instance":3959,"id":223974,"goal":"function Power_3959(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_3959(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_3960","instance":3960,"id":223975,"goal":"function Sum_3960(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_3960(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_3961","instance":3961,"id":223976,"goal":"method BinarySearch_3961(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_3962","instance":3962,"id":223977,"goal":"method InsertSort_3962(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_3963","instance":3963,"id":223978,"goal":"method MergeSort_3963(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_3964","instance":3964,"id":223979,"goal":"method ArrayCopy_3964(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_3965","instance":3965,"id":223980,"goal":"function ListReverse_3965(s: seq): seq\n ensures |ListReverse_3965(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_3965(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_3966","instance":3966,"id":223981,"goal":"function Factorial_3966(n: nat): nat\n ensures Factorial_3966(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_3966(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_3967","instance":3967,"id":223982,"goal":"function Fib_3967(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_3967(n-1) + Fib_3967(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_3968","instance":3968,"id":223983,"goal":"function Gcd_3968(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_3968(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_3969","instance":3969,"id":223984,"goal":"function Power_3969(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_3969(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_3970","instance":3970,"id":223985,"goal":"function Sum_3970(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_3970(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_3971","instance":3971,"id":223986,"goal":"method BinarySearch_3971(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_3972","instance":3972,"id":223987,"goal":"method InsertSort_3972(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_3973","instance":3973,"id":223988,"goal":"method MergeSort_3973(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_3974","instance":3974,"id":223989,"goal":"method ArrayCopy_3974(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_3975","instance":3975,"id":223990,"goal":"function ListReverse_3975(s: seq): seq\n ensures |ListReverse_3975(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_3975(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_3976","instance":3976,"id":223991,"goal":"function Factorial_3976(n: nat): nat\n ensures Factorial_3976(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_3976(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_3977","instance":3977,"id":223992,"goal":"function Fib_3977(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_3977(n-1) + Fib_3977(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_3978","instance":3978,"id":223993,"goal":"function Gcd_3978(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_3978(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_3979","instance":3979,"id":223994,"goal":"function Power_3979(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_3979(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_3980","instance":3980,"id":223995,"goal":"function Sum_3980(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_3980(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_3981","instance":3981,"id":223996,"goal":"method BinarySearch_3981(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_3982","instance":3982,"id":223997,"goal":"method InsertSort_3982(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_3983","instance":3983,"id":223998,"goal":"method MergeSort_3983(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_3984","instance":3984,"id":223999,"goal":"method ArrayCopy_3984(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_3985","instance":3985,"id":224000,"goal":"function ListReverse_3985(s: seq): seq\n ensures |ListReverse_3985(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_3985(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_3986","instance":3986,"id":224001,"goal":"function Factorial_3986(n: nat): nat\n ensures Factorial_3986(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_3986(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_3987","instance":3987,"id":224002,"goal":"function Fib_3987(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_3987(n-1) + Fib_3987(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_3988","instance":3988,"id":224003,"goal":"function Gcd_3988(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_3988(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_3989","instance":3989,"id":224004,"goal":"function Power_3989(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_3989(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_3990","instance":3990,"id":224005,"goal":"function Sum_3990(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_3990(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_3991","instance":3991,"id":224006,"goal":"method BinarySearch_3991(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_3992","instance":3992,"id":224007,"goal":"method InsertSort_3992(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_3993","instance":3993,"id":224008,"goal":"method MergeSort_3993(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_3994","instance":3994,"id":224009,"goal":"method ArrayCopy_3994(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_3995","instance":3995,"id":224010,"goal":"function ListReverse_3995(s: seq): seq\n ensures |ListReverse_3995(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_3995(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_3996","instance":3996,"id":224011,"goal":"function Factorial_3996(n: nat): nat\n ensures Factorial_3996(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_3996(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_3997","instance":3997,"id":224012,"goal":"function Fib_3997(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_3997(n-1) + Fib_3997(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_3998","instance":3998,"id":224013,"goal":"function Gcd_3998(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_3998(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_3999","instance":3999,"id":224014,"goal":"function Power_3999(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_3999(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_4000","instance":4000,"id":224015,"goal":"function Sum_4000(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_4000(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_4001","instance":4001,"id":224016,"goal":"method BinarySearch_4001(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_4002","instance":4002,"id":224017,"goal":"method InsertSort_4002(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_4003","instance":4003,"id":224018,"goal":"method MergeSort_4003(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_4004","instance":4004,"id":224019,"goal":"method ArrayCopy_4004(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_4005","instance":4005,"id":224020,"goal":"function ListReverse_4005(s: seq): seq\n ensures |ListReverse_4005(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_4005(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_4006","instance":4006,"id":224021,"goal":"function Factorial_4006(n: nat): nat\n ensures Factorial_4006(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_4006(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_4007","instance":4007,"id":224022,"goal":"function Fib_4007(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_4007(n-1) + Fib_4007(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_4008","instance":4008,"id":224023,"goal":"function Gcd_4008(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_4008(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_4009","instance":4009,"id":224024,"goal":"function Power_4009(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_4009(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_4010","instance":4010,"id":224025,"goal":"function Sum_4010(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_4010(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_4011","instance":4011,"id":224026,"goal":"method BinarySearch_4011(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_4012","instance":4012,"id":224027,"goal":"method InsertSort_4012(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_4013","instance":4013,"id":224028,"goal":"method MergeSort_4013(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_4014","instance":4014,"id":224029,"goal":"method ArrayCopy_4014(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_4015","instance":4015,"id":224030,"goal":"function ListReverse_4015(s: seq): seq\n ensures |ListReverse_4015(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_4015(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_4016","instance":4016,"id":224031,"goal":"function Factorial_4016(n: nat): nat\n ensures Factorial_4016(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_4016(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_4017","instance":4017,"id":224032,"goal":"function Fib_4017(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_4017(n-1) + Fib_4017(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_4018","instance":4018,"id":224033,"goal":"function Gcd_4018(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_4018(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_4019","instance":4019,"id":224034,"goal":"function Power_4019(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_4019(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_4020","instance":4020,"id":224035,"goal":"function Sum_4020(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_4020(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_4021","instance":4021,"id":224036,"goal":"method BinarySearch_4021(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_4022","instance":4022,"id":224037,"goal":"method InsertSort_4022(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_4023","instance":4023,"id":224038,"goal":"method MergeSort_4023(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_4024","instance":4024,"id":224039,"goal":"method ArrayCopy_4024(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_4025","instance":4025,"id":224040,"goal":"function ListReverse_4025(s: seq): seq\n ensures |ListReverse_4025(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_4025(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_4026","instance":4026,"id":224041,"goal":"function Factorial_4026(n: nat): nat\n ensures Factorial_4026(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_4026(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_4027","instance":4027,"id":224042,"goal":"function Fib_4027(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_4027(n-1) + Fib_4027(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_4028","instance":4028,"id":224043,"goal":"function Gcd_4028(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_4028(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_4029","instance":4029,"id":224044,"goal":"function Power_4029(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_4029(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_4030","instance":4030,"id":224045,"goal":"function Sum_4030(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_4030(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_4031","instance":4031,"id":224046,"goal":"method BinarySearch_4031(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_4032","instance":4032,"id":224047,"goal":"method InsertSort_4032(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_4033","instance":4033,"id":224048,"goal":"method MergeSort_4033(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_4034","instance":4034,"id":224049,"goal":"method ArrayCopy_4034(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_4035","instance":4035,"id":224050,"goal":"function ListReverse_4035(s: seq): seq\n ensures |ListReverse_4035(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_4035(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_4036","instance":4036,"id":224051,"goal":"function Factorial_4036(n: nat): nat\n ensures Factorial_4036(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_4036(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_4037","instance":4037,"id":224052,"goal":"function Fib_4037(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_4037(n-1) + Fib_4037(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_4038","instance":4038,"id":224053,"goal":"function Gcd_4038(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_4038(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_4039","instance":4039,"id":224054,"goal":"function Power_4039(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_4039(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_4040","instance":4040,"id":224055,"goal":"function Sum_4040(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_4040(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_4041","instance":4041,"id":224056,"goal":"method BinarySearch_4041(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_4042","instance":4042,"id":224057,"goal":"method InsertSort_4042(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_4043","instance":4043,"id":224058,"goal":"method MergeSort_4043(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_4044","instance":4044,"id":224059,"goal":"method ArrayCopy_4044(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_4045","instance":4045,"id":224060,"goal":"function ListReverse_4045(s: seq): seq\n ensures |ListReverse_4045(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_4045(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_4046","instance":4046,"id":224061,"goal":"function Factorial_4046(n: nat): nat\n ensures Factorial_4046(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_4046(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_4047","instance":4047,"id":224062,"goal":"function Fib_4047(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_4047(n-1) + Fib_4047(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_4048","instance":4048,"id":224063,"goal":"function Gcd_4048(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_4048(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_4049","instance":4049,"id":224064,"goal":"function Power_4049(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_4049(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_4050","instance":4050,"id":224065,"goal":"function Sum_4050(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_4050(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_4051","instance":4051,"id":224066,"goal":"method BinarySearch_4051(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_4052","instance":4052,"id":224067,"goal":"method InsertSort_4052(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_4053","instance":4053,"id":224068,"goal":"method MergeSort_4053(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_4054","instance":4054,"id":224069,"goal":"method ArrayCopy_4054(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_4055","instance":4055,"id":224070,"goal":"function ListReverse_4055(s: seq): seq\n ensures |ListReverse_4055(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_4055(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_4056","instance":4056,"id":224071,"goal":"function Factorial_4056(n: nat): nat\n ensures Factorial_4056(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_4056(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_4057","instance":4057,"id":224072,"goal":"function Fib_4057(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_4057(n-1) + Fib_4057(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_4058","instance":4058,"id":224073,"goal":"function Gcd_4058(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_4058(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_4059","instance":4059,"id":224074,"goal":"function Power_4059(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_4059(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_4060","instance":4060,"id":224075,"goal":"function Sum_4060(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_4060(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_4061","instance":4061,"id":224076,"goal":"method BinarySearch_4061(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_4062","instance":4062,"id":224077,"goal":"method InsertSort_4062(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_4063","instance":4063,"id":224078,"goal":"method MergeSort_4063(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_4064","instance":4064,"id":224079,"goal":"method ArrayCopy_4064(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_4065","instance":4065,"id":224080,"goal":"function ListReverse_4065(s: seq): seq\n ensures |ListReverse_4065(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_4065(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_4066","instance":4066,"id":224081,"goal":"function Factorial_4066(n: nat): nat\n ensures Factorial_4066(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_4066(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_4067","instance":4067,"id":224082,"goal":"function Fib_4067(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_4067(n-1) + Fib_4067(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_4068","instance":4068,"id":224083,"goal":"function Gcd_4068(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_4068(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_4069","instance":4069,"id":224084,"goal":"function Power_4069(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_4069(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_4070","instance":4070,"id":224085,"goal":"function Sum_4070(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_4070(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_4071","instance":4071,"id":224086,"goal":"method BinarySearch_4071(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_4072","instance":4072,"id":224087,"goal":"method InsertSort_4072(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_4073","instance":4073,"id":224088,"goal":"method MergeSort_4073(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_4074","instance":4074,"id":224089,"goal":"method ArrayCopy_4074(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_4075","instance":4075,"id":224090,"goal":"function ListReverse_4075(s: seq): seq\n ensures |ListReverse_4075(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_4075(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_4076","instance":4076,"id":224091,"goal":"function Factorial_4076(n: nat): nat\n ensures Factorial_4076(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_4076(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_4077","instance":4077,"id":224092,"goal":"function Fib_4077(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_4077(n-1) + Fib_4077(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_4078","instance":4078,"id":224093,"goal":"function Gcd_4078(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_4078(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_4079","instance":4079,"id":224094,"goal":"function Power_4079(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_4079(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_4080","instance":4080,"id":224095,"goal":"function Sum_4080(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_4080(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_4081","instance":4081,"id":224096,"goal":"method BinarySearch_4081(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_4082","instance":4082,"id":224097,"goal":"method InsertSort_4082(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_4083","instance":4083,"id":224098,"goal":"method MergeSort_4083(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_4084","instance":4084,"id":224099,"goal":"method ArrayCopy_4084(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_4085","instance":4085,"id":224100,"goal":"function ListReverse_4085(s: seq): seq\n ensures |ListReverse_4085(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_4085(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_4086","instance":4086,"id":224101,"goal":"function Factorial_4086(n: nat): nat\n ensures Factorial_4086(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_4086(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_4087","instance":4087,"id":224102,"goal":"function Fib_4087(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_4087(n-1) + Fib_4087(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_4088","instance":4088,"id":224103,"goal":"function Gcd_4088(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_4088(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_4089","instance":4089,"id":224104,"goal":"function Power_4089(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_4089(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_4090","instance":4090,"id":224105,"goal":"function Sum_4090(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_4090(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_4091","instance":4091,"id":224106,"goal":"method BinarySearch_4091(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_4092","instance":4092,"id":224107,"goal":"method InsertSort_4092(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_4093","instance":4093,"id":224108,"goal":"method MergeSort_4093(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_4094","instance":4094,"id":224109,"goal":"method ArrayCopy_4094(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_4095","instance":4095,"id":224110,"goal":"function ListReverse_4095(s: seq): seq\n ensures |ListReverse_4095(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_4095(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_4096","instance":4096,"id":224111,"goal":"function Factorial_4096(n: nat): nat\n ensures Factorial_4096(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_4096(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_4097","instance":4097,"id":224112,"goal":"function Fib_4097(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_4097(n-1) + Fib_4097(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_4098","instance":4098,"id":224113,"goal":"function Gcd_4098(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_4098(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_4099","instance":4099,"id":224114,"goal":"function Power_4099(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_4099(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_4100","instance":4100,"id":224115,"goal":"function Sum_4100(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_4100(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_4101","instance":4101,"id":224116,"goal":"method BinarySearch_4101(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_4102","instance":4102,"id":224117,"goal":"method InsertSort_4102(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_4103","instance":4103,"id":224118,"goal":"method MergeSort_4103(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_4104","instance":4104,"id":224119,"goal":"method ArrayCopy_4104(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_4105","instance":4105,"id":224120,"goal":"function ListReverse_4105(s: seq): seq\n ensures |ListReverse_4105(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_4105(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_4106","instance":4106,"id":224121,"goal":"function Factorial_4106(n: nat): nat\n ensures Factorial_4106(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_4106(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_4107","instance":4107,"id":224122,"goal":"function Fib_4107(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_4107(n-1) + Fib_4107(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_4108","instance":4108,"id":224123,"goal":"function Gcd_4108(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_4108(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_4109","instance":4109,"id":224124,"goal":"function Power_4109(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_4109(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_4110","instance":4110,"id":224125,"goal":"function Sum_4110(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_4110(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_4111","instance":4111,"id":224126,"goal":"method BinarySearch_4111(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_4112","instance":4112,"id":224127,"goal":"method InsertSort_4112(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_4113","instance":4113,"id":224128,"goal":"method MergeSort_4113(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_4114","instance":4114,"id":224129,"goal":"method ArrayCopy_4114(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_4115","instance":4115,"id":224130,"goal":"function ListReverse_4115(s: seq): seq\n ensures |ListReverse_4115(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_4115(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_4116","instance":4116,"id":224131,"goal":"function Factorial_4116(n: nat): nat\n ensures Factorial_4116(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_4116(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_4117","instance":4117,"id":224132,"goal":"function Fib_4117(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_4117(n-1) + Fib_4117(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_4118","instance":4118,"id":224133,"goal":"function Gcd_4118(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_4118(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_4119","instance":4119,"id":224134,"goal":"function Power_4119(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_4119(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_4120","instance":4120,"id":224135,"goal":"function Sum_4120(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_4120(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_4121","instance":4121,"id":224136,"goal":"method BinarySearch_4121(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_4122","instance":4122,"id":224137,"goal":"method InsertSort_4122(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_4123","instance":4123,"id":224138,"goal":"method MergeSort_4123(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_4124","instance":4124,"id":224139,"goal":"method ArrayCopy_4124(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_4125","instance":4125,"id":224140,"goal":"function ListReverse_4125(s: seq): seq\n ensures |ListReverse_4125(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_4125(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_4126","instance":4126,"id":224141,"goal":"function Factorial_4126(n: nat): nat\n ensures Factorial_4126(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_4126(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_4127","instance":4127,"id":224142,"goal":"function Fib_4127(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_4127(n-1) + Fib_4127(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_4128","instance":4128,"id":224143,"goal":"function Gcd_4128(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_4128(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_4129","instance":4129,"id":224144,"goal":"function Power_4129(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_4129(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_4130","instance":4130,"id":224145,"goal":"function Sum_4130(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_4130(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_4131","instance":4131,"id":224146,"goal":"method BinarySearch_4131(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_4132","instance":4132,"id":224147,"goal":"method InsertSort_4132(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_4133","instance":4133,"id":224148,"goal":"method MergeSort_4133(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_4134","instance":4134,"id":224149,"goal":"method ArrayCopy_4134(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_4135","instance":4135,"id":224150,"goal":"function ListReverse_4135(s: seq): seq\n ensures |ListReverse_4135(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_4135(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_4136","instance":4136,"id":224151,"goal":"function Factorial_4136(n: nat): nat\n ensures Factorial_4136(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_4136(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_4137","instance":4137,"id":224152,"goal":"function Fib_4137(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_4137(n-1) + Fib_4137(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_4138","instance":4138,"id":224153,"goal":"function Gcd_4138(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_4138(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_4139","instance":4139,"id":224154,"goal":"function Power_4139(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_4139(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_4140","instance":4140,"id":224155,"goal":"function Sum_4140(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_4140(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_4141","instance":4141,"id":224156,"goal":"method BinarySearch_4141(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_4142","instance":4142,"id":224157,"goal":"method InsertSort_4142(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_4143","instance":4143,"id":224158,"goal":"method MergeSort_4143(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_4144","instance":4144,"id":224159,"goal":"method ArrayCopy_4144(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_4145","instance":4145,"id":224160,"goal":"function ListReverse_4145(s: seq): seq\n ensures |ListReverse_4145(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_4145(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_4146","instance":4146,"id":224161,"goal":"function Factorial_4146(n: nat): nat\n ensures Factorial_4146(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_4146(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_4147","instance":4147,"id":224162,"goal":"function Fib_4147(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_4147(n-1) + Fib_4147(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_4148","instance":4148,"id":224163,"goal":"function Gcd_4148(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_4148(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_4149","instance":4149,"id":224164,"goal":"function Power_4149(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_4149(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_4150","instance":4150,"id":224165,"goal":"function Sum_4150(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_4150(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_4151","instance":4151,"id":224166,"goal":"method BinarySearch_4151(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_4152","instance":4152,"id":224167,"goal":"method InsertSort_4152(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_4153","instance":4153,"id":224168,"goal":"method MergeSort_4153(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_4154","instance":4154,"id":224169,"goal":"method ArrayCopy_4154(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_4155","instance":4155,"id":224170,"goal":"function ListReverse_4155(s: seq): seq\n ensures |ListReverse_4155(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_4155(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_4156","instance":4156,"id":224171,"goal":"function Factorial_4156(n: nat): nat\n ensures Factorial_4156(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_4156(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_4157","instance":4157,"id":224172,"goal":"function Fib_4157(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_4157(n-1) + Fib_4157(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_4158","instance":4158,"id":224173,"goal":"function Gcd_4158(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_4158(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_4159","instance":4159,"id":224174,"goal":"function Power_4159(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_4159(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_4160","instance":4160,"id":224175,"goal":"function Sum_4160(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_4160(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_4161","instance":4161,"id":224176,"goal":"method BinarySearch_4161(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_4162","instance":4162,"id":224177,"goal":"method InsertSort_4162(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_4163","instance":4163,"id":224178,"goal":"method MergeSort_4163(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_4164","instance":4164,"id":224179,"goal":"method ArrayCopy_4164(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_4165","instance":4165,"id":224180,"goal":"function ListReverse_4165(s: seq): seq\n ensures |ListReverse_4165(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_4165(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_4166","instance":4166,"id":224181,"goal":"function Factorial_4166(n: nat): nat\n ensures Factorial_4166(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_4166(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_4167","instance":4167,"id":224182,"goal":"function Fib_4167(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_4167(n-1) + Fib_4167(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_4168","instance":4168,"id":224183,"goal":"function Gcd_4168(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_4168(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_4169","instance":4169,"id":224184,"goal":"function Power_4169(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_4169(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_4170","instance":4170,"id":224185,"goal":"function Sum_4170(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_4170(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_4171","instance":4171,"id":224186,"goal":"method BinarySearch_4171(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_4172","instance":4172,"id":224187,"goal":"method InsertSort_4172(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_4173","instance":4173,"id":224188,"goal":"method MergeSort_4173(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_4174","instance":4174,"id":224189,"goal":"method ArrayCopy_4174(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_4175","instance":4175,"id":224190,"goal":"function ListReverse_4175(s: seq): seq\n ensures |ListReverse_4175(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_4175(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_4176","instance":4176,"id":224191,"goal":"function Factorial_4176(n: nat): nat\n ensures Factorial_4176(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_4176(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_4177","instance":4177,"id":224192,"goal":"function Fib_4177(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_4177(n-1) + Fib_4177(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_4178","instance":4178,"id":224193,"goal":"function Gcd_4178(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_4178(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_4179","instance":4179,"id":224194,"goal":"function Power_4179(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_4179(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_4180","instance":4180,"id":224195,"goal":"function Sum_4180(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_4180(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_4181","instance":4181,"id":224196,"goal":"method BinarySearch_4181(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_4182","instance":4182,"id":224197,"goal":"method InsertSort_4182(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_4183","instance":4183,"id":224198,"goal":"method MergeSort_4183(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_4184","instance":4184,"id":224199,"goal":"method ArrayCopy_4184(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_4185","instance":4185,"id":224200,"goal":"function ListReverse_4185(s: seq): seq\n ensures |ListReverse_4185(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_4185(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_4186","instance":4186,"id":224201,"goal":"function Factorial_4186(n: nat): nat\n ensures Factorial_4186(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_4186(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_4187","instance":4187,"id":224202,"goal":"function Fib_4187(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_4187(n-1) + Fib_4187(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_4188","instance":4188,"id":224203,"goal":"function Gcd_4188(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_4188(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_4189","instance":4189,"id":224204,"goal":"function Power_4189(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_4189(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_4190","instance":4190,"id":224205,"goal":"function Sum_4190(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_4190(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_4191","instance":4191,"id":224206,"goal":"method BinarySearch_4191(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_4192","instance":4192,"id":224207,"goal":"method InsertSort_4192(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_4193","instance":4193,"id":224208,"goal":"method MergeSort_4193(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_4194","instance":4194,"id":224209,"goal":"method ArrayCopy_4194(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_4195","instance":4195,"id":224210,"goal":"function ListReverse_4195(s: seq): seq\n ensures |ListReverse_4195(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_4195(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_4196","instance":4196,"id":224211,"goal":"function Factorial_4196(n: nat): nat\n ensures Factorial_4196(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_4196(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_4197","instance":4197,"id":224212,"goal":"function Fib_4197(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_4197(n-1) + Fib_4197(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_4198","instance":4198,"id":224213,"goal":"function Gcd_4198(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_4198(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_4199","instance":4199,"id":224214,"goal":"function Power_4199(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_4199(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_4200","instance":4200,"id":224215,"goal":"function Sum_4200(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_4200(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_4201","instance":4201,"id":224216,"goal":"method BinarySearch_4201(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_4202","instance":4202,"id":224217,"goal":"method InsertSort_4202(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_4203","instance":4203,"id":224218,"goal":"method MergeSort_4203(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_4204","instance":4204,"id":224219,"goal":"method ArrayCopy_4204(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_4205","instance":4205,"id":224220,"goal":"function ListReverse_4205(s: seq): seq\n ensures |ListReverse_4205(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_4205(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_4206","instance":4206,"id":224221,"goal":"function Factorial_4206(n: nat): nat\n ensures Factorial_4206(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_4206(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_4207","instance":4207,"id":224222,"goal":"function Fib_4207(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_4207(n-1) + Fib_4207(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_4208","instance":4208,"id":224223,"goal":"function Gcd_4208(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_4208(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_4209","instance":4209,"id":224224,"goal":"function Power_4209(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_4209(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_4210","instance":4210,"id":224225,"goal":"function Sum_4210(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_4210(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_4211","instance":4211,"id":224226,"goal":"method BinarySearch_4211(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_4212","instance":4212,"id":224227,"goal":"method InsertSort_4212(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_4213","instance":4213,"id":224228,"goal":"method MergeSort_4213(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_4214","instance":4214,"id":224229,"goal":"method ArrayCopy_4214(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_4215","instance":4215,"id":224230,"goal":"function ListReverse_4215(s: seq): seq\n ensures |ListReverse_4215(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_4215(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_4216","instance":4216,"id":224231,"goal":"function Factorial_4216(n: nat): nat\n ensures Factorial_4216(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_4216(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_4217","instance":4217,"id":224232,"goal":"function Fib_4217(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_4217(n-1) + Fib_4217(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_4218","instance":4218,"id":224233,"goal":"function Gcd_4218(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_4218(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_4219","instance":4219,"id":224234,"goal":"function Power_4219(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_4219(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_4220","instance":4220,"id":224235,"goal":"function Sum_4220(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_4220(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_4221","instance":4221,"id":224236,"goal":"method BinarySearch_4221(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_4222","instance":4222,"id":224237,"goal":"method InsertSort_4222(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_4223","instance":4223,"id":224238,"goal":"method MergeSort_4223(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_4224","instance":4224,"id":224239,"goal":"method ArrayCopy_4224(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_4225","instance":4225,"id":224240,"goal":"function ListReverse_4225(s: seq): seq\n ensures |ListReverse_4225(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_4225(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_4226","instance":4226,"id":224241,"goal":"function Factorial_4226(n: nat): nat\n ensures Factorial_4226(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_4226(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_4227","instance":4227,"id":224242,"goal":"function Fib_4227(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_4227(n-1) + Fib_4227(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_4228","instance":4228,"id":224243,"goal":"function Gcd_4228(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_4228(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_4229","instance":4229,"id":224244,"goal":"function Power_4229(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_4229(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_4230","instance":4230,"id":224245,"goal":"function Sum_4230(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_4230(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_4231","instance":4231,"id":224246,"goal":"method BinarySearch_4231(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_4232","instance":4232,"id":224247,"goal":"method InsertSort_4232(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_4233","instance":4233,"id":224248,"goal":"method MergeSort_4233(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_4234","instance":4234,"id":224249,"goal":"method ArrayCopy_4234(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_4235","instance":4235,"id":224250,"goal":"function ListReverse_4235(s: seq): seq\n ensures |ListReverse_4235(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_4235(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_4236","instance":4236,"id":224251,"goal":"function Factorial_4236(n: nat): nat\n ensures Factorial_4236(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_4236(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_4237","instance":4237,"id":224252,"goal":"function Fib_4237(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_4237(n-1) + Fib_4237(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_4238","instance":4238,"id":224253,"goal":"function Gcd_4238(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_4238(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_4239","instance":4239,"id":224254,"goal":"function Power_4239(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_4239(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_4240","instance":4240,"id":224255,"goal":"function Sum_4240(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_4240(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_4241","instance":4241,"id":224256,"goal":"method BinarySearch_4241(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_4242","instance":4242,"id":224257,"goal":"method InsertSort_4242(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_4243","instance":4243,"id":224258,"goal":"method MergeSort_4243(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_4244","instance":4244,"id":224259,"goal":"method ArrayCopy_4244(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_4245","instance":4245,"id":224260,"goal":"function ListReverse_4245(s: seq): seq\n ensures |ListReverse_4245(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_4245(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_4246","instance":4246,"id":224261,"goal":"function Factorial_4246(n: nat): nat\n ensures Factorial_4246(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_4246(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_4247","instance":4247,"id":224262,"goal":"function Fib_4247(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_4247(n-1) + Fib_4247(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_4248","instance":4248,"id":224263,"goal":"function Gcd_4248(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_4248(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_4249","instance":4249,"id":224264,"goal":"function Power_4249(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_4249(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_4250","instance":4250,"id":224265,"goal":"function Sum_4250(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_4250(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_4251","instance":4251,"id":224266,"goal":"method BinarySearch_4251(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_4252","instance":4252,"id":224267,"goal":"method InsertSort_4252(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_4253","instance":4253,"id":224268,"goal":"method MergeSort_4253(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_4254","instance":4254,"id":224269,"goal":"method ArrayCopy_4254(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_4255","instance":4255,"id":224270,"goal":"function ListReverse_4255(s: seq): seq\n ensures |ListReverse_4255(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_4255(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_4256","instance":4256,"id":224271,"goal":"function Factorial_4256(n: nat): nat\n ensures Factorial_4256(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_4256(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_4257","instance":4257,"id":224272,"goal":"function Fib_4257(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_4257(n-1) + Fib_4257(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_4258","instance":4258,"id":224273,"goal":"function Gcd_4258(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_4258(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_4259","instance":4259,"id":224274,"goal":"function Power_4259(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_4259(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_4260","instance":4260,"id":224275,"goal":"function Sum_4260(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_4260(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_4261","instance":4261,"id":224276,"goal":"method BinarySearch_4261(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_4262","instance":4262,"id":224277,"goal":"method InsertSort_4262(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_4263","instance":4263,"id":224278,"goal":"method MergeSort_4263(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_4264","instance":4264,"id":224279,"goal":"method ArrayCopy_4264(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_4265","instance":4265,"id":224280,"goal":"function ListReverse_4265(s: seq): seq\n ensures |ListReverse_4265(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_4265(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_4266","instance":4266,"id":224281,"goal":"function Factorial_4266(n: nat): nat\n ensures Factorial_4266(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_4266(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_4267","instance":4267,"id":224282,"goal":"function Fib_4267(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_4267(n-1) + Fib_4267(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_4268","instance":4268,"id":224283,"goal":"function Gcd_4268(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_4268(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_4269","instance":4269,"id":224284,"goal":"function Power_4269(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_4269(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_4270","instance":4270,"id":224285,"goal":"function Sum_4270(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_4270(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_4271","instance":4271,"id":224286,"goal":"method BinarySearch_4271(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_4272","instance":4272,"id":224287,"goal":"method InsertSort_4272(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_4273","instance":4273,"id":224288,"goal":"method MergeSort_4273(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_4274","instance":4274,"id":224289,"goal":"method ArrayCopy_4274(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_4275","instance":4275,"id":224290,"goal":"function ListReverse_4275(s: seq): seq\n ensures |ListReverse_4275(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_4275(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_4276","instance":4276,"id":224291,"goal":"function Factorial_4276(n: nat): nat\n ensures Factorial_4276(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_4276(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_4277","instance":4277,"id":224292,"goal":"function Fib_4277(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_4277(n-1) + Fib_4277(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_4278","instance":4278,"id":224293,"goal":"function Gcd_4278(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_4278(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_4279","instance":4279,"id":224294,"goal":"function Power_4279(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_4279(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_4280","instance":4280,"id":224295,"goal":"function Sum_4280(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_4280(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_4281","instance":4281,"id":224296,"goal":"method BinarySearch_4281(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_4282","instance":4282,"id":224297,"goal":"method InsertSort_4282(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_4283","instance":4283,"id":224298,"goal":"method MergeSort_4283(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_4284","instance":4284,"id":224299,"goal":"method ArrayCopy_4284(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_4285","instance":4285,"id":224300,"goal":"function ListReverse_4285(s: seq): seq\n ensures |ListReverse_4285(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_4285(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_4286","instance":4286,"id":224301,"goal":"function Factorial_4286(n: nat): nat\n ensures Factorial_4286(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_4286(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_4287","instance":4287,"id":224302,"goal":"function Fib_4287(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_4287(n-1) + Fib_4287(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_4288","instance":4288,"id":224303,"goal":"function Gcd_4288(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_4288(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_4289","instance":4289,"id":224304,"goal":"function Power_4289(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_4289(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_4290","instance":4290,"id":224305,"goal":"function Sum_4290(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_4290(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_4291","instance":4291,"id":224306,"goal":"method BinarySearch_4291(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_4292","instance":4292,"id":224307,"goal":"method InsertSort_4292(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_4293","instance":4293,"id":224308,"goal":"method MergeSort_4293(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_4294","instance":4294,"id":224309,"goal":"method ArrayCopy_4294(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_4295","instance":4295,"id":224310,"goal":"function ListReverse_4295(s: seq): seq\n ensures |ListReverse_4295(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_4295(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_4296","instance":4296,"id":224311,"goal":"function Factorial_4296(n: nat): nat\n ensures Factorial_4296(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_4296(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_4297","instance":4297,"id":224312,"goal":"function Fib_4297(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_4297(n-1) + Fib_4297(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_4298","instance":4298,"id":224313,"goal":"function Gcd_4298(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_4298(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_4299","instance":4299,"id":224314,"goal":"function Power_4299(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_4299(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_4300","instance":4300,"id":224315,"goal":"function Sum_4300(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_4300(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_4301","instance":4301,"id":224316,"goal":"method BinarySearch_4301(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_4302","instance":4302,"id":224317,"goal":"method InsertSort_4302(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_4303","instance":4303,"id":224318,"goal":"method MergeSort_4303(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_4304","instance":4304,"id":224319,"goal":"method ArrayCopy_4304(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_4305","instance":4305,"id":224320,"goal":"function ListReverse_4305(s: seq): seq\n ensures |ListReverse_4305(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_4305(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_4306","instance":4306,"id":224321,"goal":"function Factorial_4306(n: nat): nat\n ensures Factorial_4306(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_4306(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_4307","instance":4307,"id":224322,"goal":"function Fib_4307(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_4307(n-1) + Fib_4307(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_4308","instance":4308,"id":224323,"goal":"function Gcd_4308(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_4308(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_4309","instance":4309,"id":224324,"goal":"function Power_4309(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_4309(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_4310","instance":4310,"id":224325,"goal":"function Sum_4310(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_4310(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_4311","instance":4311,"id":224326,"goal":"method BinarySearch_4311(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_4312","instance":4312,"id":224327,"goal":"method InsertSort_4312(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_4313","instance":4313,"id":224328,"goal":"method MergeSort_4313(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_4314","instance":4314,"id":224329,"goal":"method ArrayCopy_4314(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_4315","instance":4315,"id":224330,"goal":"function ListReverse_4315(s: seq): seq\n ensures |ListReverse_4315(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_4315(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_4316","instance":4316,"id":224331,"goal":"function Factorial_4316(n: nat): nat\n ensures Factorial_4316(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_4316(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_4317","instance":4317,"id":224332,"goal":"function Fib_4317(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_4317(n-1) + Fib_4317(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_4318","instance":4318,"id":224333,"goal":"function Gcd_4318(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_4318(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_4319","instance":4319,"id":224334,"goal":"function Power_4319(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_4319(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_4320","instance":4320,"id":224335,"goal":"function Sum_4320(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_4320(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_4321","instance":4321,"id":224336,"goal":"method BinarySearch_4321(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_4322","instance":4322,"id":224337,"goal":"method InsertSort_4322(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_4323","instance":4323,"id":224338,"goal":"method MergeSort_4323(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_4324","instance":4324,"id":224339,"goal":"method ArrayCopy_4324(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_4325","instance":4325,"id":224340,"goal":"function ListReverse_4325(s: seq): seq\n ensures |ListReverse_4325(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_4325(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_4326","instance":4326,"id":224341,"goal":"function Factorial_4326(n: nat): nat\n ensures Factorial_4326(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_4326(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_4327","instance":4327,"id":224342,"goal":"function Fib_4327(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_4327(n-1) + Fib_4327(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_4328","instance":4328,"id":224343,"goal":"function Gcd_4328(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_4328(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_4329","instance":4329,"id":224344,"goal":"function Power_4329(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_4329(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_4330","instance":4330,"id":224345,"goal":"function Sum_4330(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_4330(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_4331","instance":4331,"id":224346,"goal":"method BinarySearch_4331(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_4332","instance":4332,"id":224347,"goal":"method InsertSort_4332(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_4333","instance":4333,"id":224348,"goal":"method MergeSort_4333(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_4334","instance":4334,"id":224349,"goal":"method ArrayCopy_4334(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_4335","instance":4335,"id":224350,"goal":"function ListReverse_4335(s: seq): seq\n ensures |ListReverse_4335(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_4335(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_4336","instance":4336,"id":224351,"goal":"function Factorial_4336(n: nat): nat\n ensures Factorial_4336(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_4336(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_4337","instance":4337,"id":224352,"goal":"function Fib_4337(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_4337(n-1) + Fib_4337(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_4338","instance":4338,"id":224353,"goal":"function Gcd_4338(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_4338(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_4339","instance":4339,"id":224354,"goal":"function Power_4339(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_4339(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_4340","instance":4340,"id":224355,"goal":"function Sum_4340(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_4340(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_4341","instance":4341,"id":224356,"goal":"method BinarySearch_4341(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_4342","instance":4342,"id":224357,"goal":"method InsertSort_4342(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_4343","instance":4343,"id":224358,"goal":"method MergeSort_4343(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_4344","instance":4344,"id":224359,"goal":"method ArrayCopy_4344(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_4345","instance":4345,"id":224360,"goal":"function ListReverse_4345(s: seq): seq\n ensures |ListReverse_4345(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_4345(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_4346","instance":4346,"id":224361,"goal":"function Factorial_4346(n: nat): nat\n ensures Factorial_4346(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_4346(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_4347","instance":4347,"id":224362,"goal":"function Fib_4347(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_4347(n-1) + Fib_4347(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_4348","instance":4348,"id":224363,"goal":"function Gcd_4348(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_4348(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_4349","instance":4349,"id":224364,"goal":"function Power_4349(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_4349(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_4350","instance":4350,"id":224365,"goal":"function Sum_4350(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_4350(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_4351","instance":4351,"id":224366,"goal":"method BinarySearch_4351(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_4352","instance":4352,"id":224367,"goal":"method InsertSort_4352(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_4353","instance":4353,"id":224368,"goal":"method MergeSort_4353(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_4354","instance":4354,"id":224369,"goal":"method ArrayCopy_4354(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_4355","instance":4355,"id":224370,"goal":"function ListReverse_4355(s: seq): seq\n ensures |ListReverse_4355(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_4355(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_4356","instance":4356,"id":224371,"goal":"function Factorial_4356(n: nat): nat\n ensures Factorial_4356(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_4356(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_4357","instance":4357,"id":224372,"goal":"function Fib_4357(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_4357(n-1) + Fib_4357(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_4358","instance":4358,"id":224373,"goal":"function Gcd_4358(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_4358(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_4359","instance":4359,"id":224374,"goal":"function Power_4359(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_4359(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_4360","instance":4360,"id":224375,"goal":"function Sum_4360(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_4360(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_4361","instance":4361,"id":224376,"goal":"method BinarySearch_4361(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_4362","instance":4362,"id":224377,"goal":"method InsertSort_4362(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_4363","instance":4363,"id":224378,"goal":"method MergeSort_4363(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_4364","instance":4364,"id":224379,"goal":"method ArrayCopy_4364(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_4365","instance":4365,"id":224380,"goal":"function ListReverse_4365(s: seq): seq\n ensures |ListReverse_4365(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_4365(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_4366","instance":4366,"id":224381,"goal":"function Factorial_4366(n: nat): nat\n ensures Factorial_4366(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_4366(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_4367","instance":4367,"id":224382,"goal":"function Fib_4367(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_4367(n-1) + Fib_4367(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_4368","instance":4368,"id":224383,"goal":"function Gcd_4368(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_4368(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_4369","instance":4369,"id":224384,"goal":"function Power_4369(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_4369(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_4370","instance":4370,"id":224385,"goal":"function Sum_4370(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_4370(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_4371","instance":4371,"id":224386,"goal":"method BinarySearch_4371(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_4372","instance":4372,"id":224387,"goal":"method InsertSort_4372(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_4373","instance":4373,"id":224388,"goal":"method MergeSort_4373(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_4374","instance":4374,"id":224389,"goal":"method ArrayCopy_4374(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_4375","instance":4375,"id":224390,"goal":"function ListReverse_4375(s: seq): seq\n ensures |ListReverse_4375(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_4375(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_4376","instance":4376,"id":224391,"goal":"function Factorial_4376(n: nat): nat\n ensures Factorial_4376(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_4376(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_4377","instance":4377,"id":224392,"goal":"function Fib_4377(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_4377(n-1) + Fib_4377(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_4378","instance":4378,"id":224393,"goal":"function Gcd_4378(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_4378(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_4379","instance":4379,"id":224394,"goal":"function Power_4379(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_4379(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_4380","instance":4380,"id":224395,"goal":"function Sum_4380(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_4380(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_4381","instance":4381,"id":224396,"goal":"method BinarySearch_4381(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_4382","instance":4382,"id":224397,"goal":"method InsertSort_4382(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_4383","instance":4383,"id":224398,"goal":"method MergeSort_4383(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_4384","instance":4384,"id":224399,"goal":"method ArrayCopy_4384(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_4385","instance":4385,"id":224400,"goal":"function ListReverse_4385(s: seq): seq\n ensures |ListReverse_4385(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_4385(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_4386","instance":4386,"id":224401,"goal":"function Factorial_4386(n: nat): nat\n ensures Factorial_4386(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_4386(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_4387","instance":4387,"id":224402,"goal":"function Fib_4387(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_4387(n-1) + Fib_4387(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_4388","instance":4388,"id":224403,"goal":"function Gcd_4388(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_4388(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_4389","instance":4389,"id":224404,"goal":"function Power_4389(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_4389(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_4390","instance":4390,"id":224405,"goal":"function Sum_4390(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_4390(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_4391","instance":4391,"id":224406,"goal":"method BinarySearch_4391(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_4392","instance":4392,"id":224407,"goal":"method InsertSort_4392(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_4393","instance":4393,"id":224408,"goal":"method MergeSort_4393(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_4394","instance":4394,"id":224409,"goal":"method ArrayCopy_4394(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_4395","instance":4395,"id":224410,"goal":"function ListReverse_4395(s: seq): seq\n ensures |ListReverse_4395(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_4395(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_4396","instance":4396,"id":224411,"goal":"function Factorial_4396(n: nat): nat\n ensures Factorial_4396(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_4396(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_4397","instance":4397,"id":224412,"goal":"function Fib_4397(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_4397(n-1) + Fib_4397(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_4398","instance":4398,"id":224413,"goal":"function Gcd_4398(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_4398(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_4399","instance":4399,"id":224414,"goal":"function Power_4399(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_4399(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_4400","instance":4400,"id":224415,"goal":"function Sum_4400(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_4400(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_4401","instance":4401,"id":224416,"goal":"method BinarySearch_4401(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_4402","instance":4402,"id":224417,"goal":"method InsertSort_4402(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_4403","instance":4403,"id":224418,"goal":"method MergeSort_4403(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_4404","instance":4404,"id":224419,"goal":"method ArrayCopy_4404(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_4405","instance":4405,"id":224420,"goal":"function ListReverse_4405(s: seq): seq\n ensures |ListReverse_4405(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_4405(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_4406","instance":4406,"id":224421,"goal":"function Factorial_4406(n: nat): nat\n ensures Factorial_4406(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_4406(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_4407","instance":4407,"id":224422,"goal":"function Fib_4407(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_4407(n-1) + Fib_4407(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_4408","instance":4408,"id":224423,"goal":"function Gcd_4408(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_4408(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_4409","instance":4409,"id":224424,"goal":"function Power_4409(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_4409(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_4410","instance":4410,"id":224425,"goal":"function Sum_4410(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_4410(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_4411","instance":4411,"id":224426,"goal":"method BinarySearch_4411(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_4412","instance":4412,"id":224427,"goal":"method InsertSort_4412(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_4413","instance":4413,"id":224428,"goal":"method MergeSort_4413(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_4414","instance":4414,"id":224429,"goal":"method ArrayCopy_4414(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_4415","instance":4415,"id":224430,"goal":"function ListReverse_4415(s: seq): seq\n ensures |ListReverse_4415(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_4415(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_4416","instance":4416,"id":224431,"goal":"function Factorial_4416(n: nat): nat\n ensures Factorial_4416(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_4416(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_4417","instance":4417,"id":224432,"goal":"function Fib_4417(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_4417(n-1) + Fib_4417(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_4418","instance":4418,"id":224433,"goal":"function Gcd_4418(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_4418(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_4419","instance":4419,"id":224434,"goal":"function Power_4419(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_4419(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_4420","instance":4420,"id":224435,"goal":"function Sum_4420(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_4420(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_4421","instance":4421,"id":224436,"goal":"method BinarySearch_4421(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_4422","instance":4422,"id":224437,"goal":"method InsertSort_4422(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_4423","instance":4423,"id":224438,"goal":"method MergeSort_4423(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_4424","instance":4424,"id":224439,"goal":"method ArrayCopy_4424(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_4425","instance":4425,"id":224440,"goal":"function ListReverse_4425(s: seq): seq\n ensures |ListReverse_4425(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_4425(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_4426","instance":4426,"id":224441,"goal":"function Factorial_4426(n: nat): nat\n ensures Factorial_4426(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_4426(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_4427","instance":4427,"id":224442,"goal":"function Fib_4427(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_4427(n-1) + Fib_4427(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_4428","instance":4428,"id":224443,"goal":"function Gcd_4428(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_4428(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_4429","instance":4429,"id":224444,"goal":"function Power_4429(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_4429(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_4430","instance":4430,"id":224445,"goal":"function Sum_4430(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_4430(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_4431","instance":4431,"id":224446,"goal":"method BinarySearch_4431(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_4432","instance":4432,"id":224447,"goal":"method InsertSort_4432(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_4433","instance":4433,"id":224448,"goal":"method MergeSort_4433(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_4434","instance":4434,"id":224449,"goal":"method ArrayCopy_4434(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_4435","instance":4435,"id":224450,"goal":"function ListReverse_4435(s: seq): seq\n ensures |ListReverse_4435(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_4435(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_4436","instance":4436,"id":224451,"goal":"function Factorial_4436(n: nat): nat\n ensures Factorial_4436(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_4436(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_4437","instance":4437,"id":224452,"goal":"function Fib_4437(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_4437(n-1) + Fib_4437(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_4438","instance":4438,"id":224453,"goal":"function Gcd_4438(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_4438(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_4439","instance":4439,"id":224454,"goal":"function Power_4439(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_4439(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_4440","instance":4440,"id":224455,"goal":"function Sum_4440(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_4440(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_4441","instance":4441,"id":224456,"goal":"method BinarySearch_4441(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_4442","instance":4442,"id":224457,"goal":"method InsertSort_4442(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_4443","instance":4443,"id":224458,"goal":"method MergeSort_4443(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_4444","instance":4444,"id":224459,"goal":"method ArrayCopy_4444(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_4445","instance":4445,"id":224460,"goal":"function ListReverse_4445(s: seq): seq\n ensures |ListReverse_4445(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_4445(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_4446","instance":4446,"id":224461,"goal":"function Factorial_4446(n: nat): nat\n ensures Factorial_4446(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_4446(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_4447","instance":4447,"id":224462,"goal":"function Fib_4447(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_4447(n-1) + Fib_4447(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_4448","instance":4448,"id":224463,"goal":"function Gcd_4448(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_4448(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_4449","instance":4449,"id":224464,"goal":"function Power_4449(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_4449(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_4450","instance":4450,"id":224465,"goal":"function Sum_4450(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_4450(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_4451","instance":4451,"id":224466,"goal":"method BinarySearch_4451(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_4452","instance":4452,"id":224467,"goal":"method InsertSort_4452(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_4453","instance":4453,"id":224468,"goal":"method MergeSort_4453(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_4454","instance":4454,"id":224469,"goal":"method ArrayCopy_4454(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_4455","instance":4455,"id":224470,"goal":"function ListReverse_4455(s: seq): seq\n ensures |ListReverse_4455(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_4455(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_4456","instance":4456,"id":224471,"goal":"function Factorial_4456(n: nat): nat\n ensures Factorial_4456(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_4456(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_4457","instance":4457,"id":224472,"goal":"function Fib_4457(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_4457(n-1) + Fib_4457(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_4458","instance":4458,"id":224473,"goal":"function Gcd_4458(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_4458(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_4459","instance":4459,"id":224474,"goal":"function Power_4459(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_4459(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_4460","instance":4460,"id":224475,"goal":"function Sum_4460(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_4460(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_4461","instance":4461,"id":224476,"goal":"method BinarySearch_4461(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_4462","instance":4462,"id":224477,"goal":"method InsertSort_4462(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_4463","instance":4463,"id":224478,"goal":"method MergeSort_4463(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_4464","instance":4464,"id":224479,"goal":"method ArrayCopy_4464(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_4465","instance":4465,"id":224480,"goal":"function ListReverse_4465(s: seq): seq\n ensures |ListReverse_4465(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_4465(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_4466","instance":4466,"id":224481,"goal":"function Factorial_4466(n: nat): nat\n ensures Factorial_4466(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_4466(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_4467","instance":4467,"id":224482,"goal":"function Fib_4467(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_4467(n-1) + Fib_4467(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_4468","instance":4468,"id":224483,"goal":"function Gcd_4468(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_4468(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_4469","instance":4469,"id":224484,"goal":"function Power_4469(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_4469(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_4470","instance":4470,"id":224485,"goal":"function Sum_4470(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_4470(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_4471","instance":4471,"id":224486,"goal":"method BinarySearch_4471(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_4472","instance":4472,"id":224487,"goal":"method InsertSort_4472(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_4473","instance":4473,"id":224488,"goal":"method MergeSort_4473(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_4474","instance":4474,"id":224489,"goal":"method ArrayCopy_4474(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_4475","instance":4475,"id":224490,"goal":"function ListReverse_4475(s: seq): seq\n ensures |ListReverse_4475(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_4475(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_4476","instance":4476,"id":224491,"goal":"function Factorial_4476(n: nat): nat\n ensures Factorial_4476(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_4476(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_4477","instance":4477,"id":224492,"goal":"function Fib_4477(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_4477(n-1) + Fib_4477(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_4478","instance":4478,"id":224493,"goal":"function Gcd_4478(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_4478(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_4479","instance":4479,"id":224494,"goal":"function Power_4479(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_4479(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_4480","instance":4480,"id":224495,"goal":"function Sum_4480(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_4480(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_4481","instance":4481,"id":224496,"goal":"method BinarySearch_4481(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_4482","instance":4482,"id":224497,"goal":"method InsertSort_4482(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_4483","instance":4483,"id":224498,"goal":"method MergeSort_4483(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_4484","instance":4484,"id":224499,"goal":"method ArrayCopy_4484(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_4485","instance":4485,"id":224500,"goal":"function ListReverse_4485(s: seq): seq\n ensures |ListReverse_4485(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_4485(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_4486","instance":4486,"id":224501,"goal":"function Factorial_4486(n: nat): nat\n ensures Factorial_4486(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_4486(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_4487","instance":4487,"id":224502,"goal":"function Fib_4487(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_4487(n-1) + Fib_4487(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_4488","instance":4488,"id":224503,"goal":"function Gcd_4488(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_4488(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_4489","instance":4489,"id":224504,"goal":"function Power_4489(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_4489(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_4490","instance":4490,"id":224505,"goal":"function Sum_4490(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_4490(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_4491","instance":4491,"id":224506,"goal":"method BinarySearch_4491(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_4492","instance":4492,"id":224507,"goal":"method InsertSort_4492(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_4493","instance":4493,"id":224508,"goal":"method MergeSort_4493(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_4494","instance":4494,"id":224509,"goal":"method ArrayCopy_4494(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_4495","instance":4495,"id":224510,"goal":"function ListReverse_4495(s: seq): seq\n ensures |ListReverse_4495(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_4495(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_4496","instance":4496,"id":224511,"goal":"function Factorial_4496(n: nat): nat\n ensures Factorial_4496(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_4496(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_4497","instance":4497,"id":224512,"goal":"function Fib_4497(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_4497(n-1) + Fib_4497(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_4498","instance":4498,"id":224513,"goal":"function Gcd_4498(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_4498(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_4499","instance":4499,"id":224514,"goal":"function Power_4499(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_4499(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_4500","instance":4500,"id":224515,"goal":"function Sum_4500(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_4500(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_4501","instance":4501,"id":224516,"goal":"method BinarySearch_4501(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_4502","instance":4502,"id":224517,"goal":"method InsertSort_4502(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_4503","instance":4503,"id":224518,"goal":"method MergeSort_4503(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_4504","instance":4504,"id":224519,"goal":"method ArrayCopy_4504(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_4505","instance":4505,"id":224520,"goal":"function ListReverse_4505(s: seq): seq\n ensures |ListReverse_4505(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_4505(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_4506","instance":4506,"id":224521,"goal":"function Factorial_4506(n: nat): nat\n ensures Factorial_4506(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_4506(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_4507","instance":4507,"id":224522,"goal":"function Fib_4507(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_4507(n-1) + Fib_4507(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_4508","instance":4508,"id":224523,"goal":"function Gcd_4508(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_4508(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_4509","instance":4509,"id":224524,"goal":"function Power_4509(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_4509(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_4510","instance":4510,"id":224525,"goal":"function Sum_4510(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_4510(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_4511","instance":4511,"id":224526,"goal":"method BinarySearch_4511(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_4512","instance":4512,"id":224527,"goal":"method InsertSort_4512(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_4513","instance":4513,"id":224528,"goal":"method MergeSort_4513(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_4514","instance":4514,"id":224529,"goal":"method ArrayCopy_4514(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_4515","instance":4515,"id":224530,"goal":"function ListReverse_4515(s: seq): seq\n ensures |ListReverse_4515(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_4515(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_4516","instance":4516,"id":224531,"goal":"function Factorial_4516(n: nat): nat\n ensures Factorial_4516(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_4516(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_4517","instance":4517,"id":224532,"goal":"function Fib_4517(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_4517(n-1) + Fib_4517(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_4518","instance":4518,"id":224533,"goal":"function Gcd_4518(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_4518(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_4519","instance":4519,"id":224534,"goal":"function Power_4519(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_4519(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_4520","instance":4520,"id":224535,"goal":"function Sum_4520(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_4520(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_4521","instance":4521,"id":224536,"goal":"method BinarySearch_4521(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_4522","instance":4522,"id":224537,"goal":"method InsertSort_4522(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_4523","instance":4523,"id":224538,"goal":"method MergeSort_4523(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_4524","instance":4524,"id":224539,"goal":"method ArrayCopy_4524(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_4525","instance":4525,"id":224540,"goal":"function ListReverse_4525(s: seq): seq\n ensures |ListReverse_4525(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_4525(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_4526","instance":4526,"id":224541,"goal":"function Factorial_4526(n: nat): nat\n ensures Factorial_4526(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_4526(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_4527","instance":4527,"id":224542,"goal":"function Fib_4527(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_4527(n-1) + Fib_4527(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_4528","instance":4528,"id":224543,"goal":"function Gcd_4528(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_4528(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_4529","instance":4529,"id":224544,"goal":"function Power_4529(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_4529(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_4530","instance":4530,"id":224545,"goal":"function Sum_4530(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_4530(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_4531","instance":4531,"id":224546,"goal":"method BinarySearch_4531(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_4532","instance":4532,"id":224547,"goal":"method InsertSort_4532(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_4533","instance":4533,"id":224548,"goal":"method MergeSort_4533(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_4534","instance":4534,"id":224549,"goal":"method ArrayCopy_4534(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_4535","instance":4535,"id":224550,"goal":"function ListReverse_4535(s: seq): seq\n ensures |ListReverse_4535(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_4535(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_4536","instance":4536,"id":224551,"goal":"function Factorial_4536(n: nat): nat\n ensures Factorial_4536(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_4536(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_4537","instance":4537,"id":224552,"goal":"function Fib_4537(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_4537(n-1) + Fib_4537(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_4538","instance":4538,"id":224553,"goal":"function Gcd_4538(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_4538(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_4539","instance":4539,"id":224554,"goal":"function Power_4539(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_4539(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_4540","instance":4540,"id":224555,"goal":"function Sum_4540(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_4540(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_4541","instance":4541,"id":224556,"goal":"method BinarySearch_4541(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_4542","instance":4542,"id":224557,"goal":"method InsertSort_4542(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_4543","instance":4543,"id":224558,"goal":"method MergeSort_4543(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_4544","instance":4544,"id":224559,"goal":"method ArrayCopy_4544(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_4545","instance":4545,"id":224560,"goal":"function ListReverse_4545(s: seq): seq\n ensures |ListReverse_4545(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_4545(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_4546","instance":4546,"id":224561,"goal":"function Factorial_4546(n: nat): nat\n ensures Factorial_4546(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_4546(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_4547","instance":4547,"id":224562,"goal":"function Fib_4547(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_4547(n-1) + Fib_4547(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_4548","instance":4548,"id":224563,"goal":"function Gcd_4548(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_4548(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_4549","instance":4549,"id":224564,"goal":"function Power_4549(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_4549(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_4550","instance":4550,"id":224565,"goal":"function Sum_4550(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_4550(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_4551","instance":4551,"id":224566,"goal":"method BinarySearch_4551(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_4552","instance":4552,"id":224567,"goal":"method InsertSort_4552(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_4553","instance":4553,"id":224568,"goal":"method MergeSort_4553(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_4554","instance":4554,"id":224569,"goal":"method ArrayCopy_4554(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_4555","instance":4555,"id":224570,"goal":"function ListReverse_4555(s: seq): seq\n ensures |ListReverse_4555(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_4555(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_4556","instance":4556,"id":224571,"goal":"function Factorial_4556(n: nat): nat\n ensures Factorial_4556(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_4556(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_4557","instance":4557,"id":224572,"goal":"function Fib_4557(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_4557(n-1) + Fib_4557(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_4558","instance":4558,"id":224573,"goal":"function Gcd_4558(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_4558(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_4559","instance":4559,"id":224574,"goal":"function Power_4559(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_4559(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_4560","instance":4560,"id":224575,"goal":"function Sum_4560(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_4560(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_4561","instance":4561,"id":224576,"goal":"method BinarySearch_4561(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_4562","instance":4562,"id":224577,"goal":"method InsertSort_4562(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_4563","instance":4563,"id":224578,"goal":"method MergeSort_4563(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_4564","instance":4564,"id":224579,"goal":"method ArrayCopy_4564(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_4565","instance":4565,"id":224580,"goal":"function ListReverse_4565(s: seq): seq\n ensures |ListReverse_4565(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_4565(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_4566","instance":4566,"id":224581,"goal":"function Factorial_4566(n: nat): nat\n ensures Factorial_4566(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_4566(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_4567","instance":4567,"id":224582,"goal":"function Fib_4567(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_4567(n-1) + Fib_4567(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_4568","instance":4568,"id":224583,"goal":"function Gcd_4568(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_4568(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_4569","instance":4569,"id":224584,"goal":"function Power_4569(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_4569(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_4570","instance":4570,"id":224585,"goal":"function Sum_4570(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_4570(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_4571","instance":4571,"id":224586,"goal":"method BinarySearch_4571(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_4572","instance":4572,"id":224587,"goal":"method InsertSort_4572(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_4573","instance":4573,"id":224588,"goal":"method MergeSort_4573(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_4574","instance":4574,"id":224589,"goal":"method ArrayCopy_4574(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_4575","instance":4575,"id":224590,"goal":"function ListReverse_4575(s: seq): seq\n ensures |ListReverse_4575(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_4575(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_4576","instance":4576,"id":224591,"goal":"function Factorial_4576(n: nat): nat\n ensures Factorial_4576(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_4576(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_4577","instance":4577,"id":224592,"goal":"function Fib_4577(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_4577(n-1) + Fib_4577(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_4578","instance":4578,"id":224593,"goal":"function Gcd_4578(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_4578(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_4579","instance":4579,"id":224594,"goal":"function Power_4579(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_4579(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_4580","instance":4580,"id":224595,"goal":"function Sum_4580(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_4580(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_4581","instance":4581,"id":224596,"goal":"method BinarySearch_4581(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_4582","instance":4582,"id":224597,"goal":"method InsertSort_4582(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_4583","instance":4583,"id":224598,"goal":"method MergeSort_4583(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_4584","instance":4584,"id":224599,"goal":"method ArrayCopy_4584(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_4585","instance":4585,"id":224600,"goal":"function ListReverse_4585(s: seq): seq\n ensures |ListReverse_4585(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_4585(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_4586","instance":4586,"id":224601,"goal":"function Factorial_4586(n: nat): nat\n ensures Factorial_4586(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_4586(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_4587","instance":4587,"id":224602,"goal":"function Fib_4587(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_4587(n-1) + Fib_4587(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_4588","instance":4588,"id":224603,"goal":"function Gcd_4588(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_4588(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_4589","instance":4589,"id":224604,"goal":"function Power_4589(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_4589(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_4590","instance":4590,"id":224605,"goal":"function Sum_4590(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_4590(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_4591","instance":4591,"id":224606,"goal":"method BinarySearch_4591(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_4592","instance":4592,"id":224607,"goal":"method InsertSort_4592(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_4593","instance":4593,"id":224608,"goal":"method MergeSort_4593(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_4594","instance":4594,"id":224609,"goal":"method ArrayCopy_4594(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_4595","instance":4595,"id":224610,"goal":"function ListReverse_4595(s: seq): seq\n ensures |ListReverse_4595(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_4595(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_4596","instance":4596,"id":224611,"goal":"function Factorial_4596(n: nat): nat\n ensures Factorial_4596(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_4596(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_4597","instance":4597,"id":224612,"goal":"function Fib_4597(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_4597(n-1) + Fib_4597(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_4598","instance":4598,"id":224613,"goal":"function Gcd_4598(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_4598(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_4599","instance":4599,"id":224614,"goal":"function Power_4599(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_4599(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_4600","instance":4600,"id":224615,"goal":"function Sum_4600(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_4600(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_4601","instance":4601,"id":224616,"goal":"method BinarySearch_4601(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_4602","instance":4602,"id":224617,"goal":"method InsertSort_4602(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_4603","instance":4603,"id":224618,"goal":"method MergeSort_4603(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_4604","instance":4604,"id":224619,"goal":"method ArrayCopy_4604(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_4605","instance":4605,"id":224620,"goal":"function ListReverse_4605(s: seq): seq\n ensures |ListReverse_4605(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_4605(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_4606","instance":4606,"id":224621,"goal":"function Factorial_4606(n: nat): nat\n ensures Factorial_4606(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_4606(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_4607","instance":4607,"id":224622,"goal":"function Fib_4607(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_4607(n-1) + Fib_4607(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_4608","instance":4608,"id":224623,"goal":"function Gcd_4608(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_4608(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_4609","instance":4609,"id":224624,"goal":"function Power_4609(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_4609(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_4610","instance":4610,"id":224625,"goal":"function Sum_4610(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_4610(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_4611","instance":4611,"id":224626,"goal":"method BinarySearch_4611(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_4612","instance":4612,"id":224627,"goal":"method InsertSort_4612(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_4613","instance":4613,"id":224628,"goal":"method MergeSort_4613(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_4614","instance":4614,"id":224629,"goal":"method ArrayCopy_4614(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_4615","instance":4615,"id":224630,"goal":"function ListReverse_4615(s: seq): seq\n ensures |ListReverse_4615(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_4615(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_4616","instance":4616,"id":224631,"goal":"function Factorial_4616(n: nat): nat\n ensures Factorial_4616(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_4616(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_4617","instance":4617,"id":224632,"goal":"function Fib_4617(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_4617(n-1) + Fib_4617(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_4618","instance":4618,"id":224633,"goal":"function Gcd_4618(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_4618(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_4619","instance":4619,"id":224634,"goal":"function Power_4619(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_4619(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_4620","instance":4620,"id":224635,"goal":"function Sum_4620(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_4620(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_4621","instance":4621,"id":224636,"goal":"method BinarySearch_4621(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_4622","instance":4622,"id":224637,"goal":"method InsertSort_4622(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_4623","instance":4623,"id":224638,"goal":"method MergeSort_4623(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_4624","instance":4624,"id":224639,"goal":"method ArrayCopy_4624(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_4625","instance":4625,"id":224640,"goal":"function ListReverse_4625(s: seq): seq\n ensures |ListReverse_4625(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_4625(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_4626","instance":4626,"id":224641,"goal":"function Factorial_4626(n: nat): nat\n ensures Factorial_4626(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_4626(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_4627","instance":4627,"id":224642,"goal":"function Fib_4627(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_4627(n-1) + Fib_4627(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_4628","instance":4628,"id":224643,"goal":"function Gcd_4628(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_4628(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_4629","instance":4629,"id":224644,"goal":"function Power_4629(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_4629(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_4630","instance":4630,"id":224645,"goal":"function Sum_4630(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_4630(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_4631","instance":4631,"id":224646,"goal":"method BinarySearch_4631(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_4632","instance":4632,"id":224647,"goal":"method InsertSort_4632(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_4633","instance":4633,"id":224648,"goal":"method MergeSort_4633(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_4634","instance":4634,"id":224649,"goal":"method ArrayCopy_4634(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_4635","instance":4635,"id":224650,"goal":"function ListReverse_4635(s: seq): seq\n ensures |ListReverse_4635(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_4635(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_4636","instance":4636,"id":224651,"goal":"function Factorial_4636(n: nat): nat\n ensures Factorial_4636(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_4636(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_4637","instance":4637,"id":224652,"goal":"function Fib_4637(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_4637(n-1) + Fib_4637(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_4638","instance":4638,"id":224653,"goal":"function Gcd_4638(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_4638(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_4639","instance":4639,"id":224654,"goal":"function Power_4639(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_4639(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_4640","instance":4640,"id":224655,"goal":"function Sum_4640(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_4640(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_4641","instance":4641,"id":224656,"goal":"method BinarySearch_4641(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_4642","instance":4642,"id":224657,"goal":"method InsertSort_4642(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_4643","instance":4643,"id":224658,"goal":"method MergeSort_4643(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_4644","instance":4644,"id":224659,"goal":"method ArrayCopy_4644(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_4645","instance":4645,"id":224660,"goal":"function ListReverse_4645(s: seq): seq\n ensures |ListReverse_4645(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_4645(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_4646","instance":4646,"id":224661,"goal":"function Factorial_4646(n: nat): nat\n ensures Factorial_4646(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_4646(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_4647","instance":4647,"id":224662,"goal":"function Fib_4647(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_4647(n-1) + Fib_4647(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_4648","instance":4648,"id":224663,"goal":"function Gcd_4648(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_4648(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_4649","instance":4649,"id":224664,"goal":"function Power_4649(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_4649(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_4650","instance":4650,"id":224665,"goal":"function Sum_4650(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_4650(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_4651","instance":4651,"id":224666,"goal":"method BinarySearch_4651(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_4652","instance":4652,"id":224667,"goal":"method InsertSort_4652(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_4653","instance":4653,"id":224668,"goal":"method MergeSort_4653(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_4654","instance":4654,"id":224669,"goal":"method ArrayCopy_4654(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_4655","instance":4655,"id":224670,"goal":"function ListReverse_4655(s: seq): seq\n ensures |ListReverse_4655(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_4655(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_4656","instance":4656,"id":224671,"goal":"function Factorial_4656(n: nat): nat\n ensures Factorial_4656(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_4656(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_4657","instance":4657,"id":224672,"goal":"function Fib_4657(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_4657(n-1) + Fib_4657(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_4658","instance":4658,"id":224673,"goal":"function Gcd_4658(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_4658(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_4659","instance":4659,"id":224674,"goal":"function Power_4659(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_4659(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_4660","instance":4660,"id":224675,"goal":"function Sum_4660(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_4660(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_4661","instance":4661,"id":224676,"goal":"method BinarySearch_4661(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_4662","instance":4662,"id":224677,"goal":"method InsertSort_4662(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_4663","instance":4663,"id":224678,"goal":"method MergeSort_4663(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_4664","instance":4664,"id":224679,"goal":"method ArrayCopy_4664(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_4665","instance":4665,"id":224680,"goal":"function ListReverse_4665(s: seq): seq\n ensures |ListReverse_4665(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_4665(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_4666","instance":4666,"id":224681,"goal":"function Factorial_4666(n: nat): nat\n ensures Factorial_4666(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_4666(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_4667","instance":4667,"id":224682,"goal":"function Fib_4667(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_4667(n-1) + Fib_4667(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_4668","instance":4668,"id":224683,"goal":"function Gcd_4668(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_4668(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_4669","instance":4669,"id":224684,"goal":"function Power_4669(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_4669(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_4670","instance":4670,"id":224685,"goal":"function Sum_4670(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_4670(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_4671","instance":4671,"id":224686,"goal":"method BinarySearch_4671(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_4672","instance":4672,"id":224687,"goal":"method InsertSort_4672(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_4673","instance":4673,"id":224688,"goal":"method MergeSort_4673(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_4674","instance":4674,"id":224689,"goal":"method ArrayCopy_4674(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_4675","instance":4675,"id":224690,"goal":"function ListReverse_4675(s: seq): seq\n ensures |ListReverse_4675(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_4675(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_4676","instance":4676,"id":224691,"goal":"function Factorial_4676(n: nat): nat\n ensures Factorial_4676(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_4676(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_4677","instance":4677,"id":224692,"goal":"function Fib_4677(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_4677(n-1) + Fib_4677(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_4678","instance":4678,"id":224693,"goal":"function Gcd_4678(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_4678(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_4679","instance":4679,"id":224694,"goal":"function Power_4679(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_4679(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_4680","instance":4680,"id":224695,"goal":"function Sum_4680(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_4680(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_4681","instance":4681,"id":224696,"goal":"method BinarySearch_4681(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_4682","instance":4682,"id":224697,"goal":"method InsertSort_4682(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_4683","instance":4683,"id":224698,"goal":"method MergeSort_4683(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_4684","instance":4684,"id":224699,"goal":"method ArrayCopy_4684(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_4685","instance":4685,"id":224700,"goal":"function ListReverse_4685(s: seq): seq\n ensures |ListReverse_4685(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_4685(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_4686","instance":4686,"id":224701,"goal":"function Factorial_4686(n: nat): nat\n ensures Factorial_4686(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_4686(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_4687","instance":4687,"id":224702,"goal":"function Fib_4687(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_4687(n-1) + Fib_4687(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_4688","instance":4688,"id":224703,"goal":"function Gcd_4688(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_4688(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_4689","instance":4689,"id":224704,"goal":"function Power_4689(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_4689(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_4690","instance":4690,"id":224705,"goal":"function Sum_4690(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_4690(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_4691","instance":4691,"id":224706,"goal":"method BinarySearch_4691(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_4692","instance":4692,"id":224707,"goal":"method InsertSort_4692(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_4693","instance":4693,"id":224708,"goal":"method MergeSort_4693(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_4694","instance":4694,"id":224709,"goal":"method ArrayCopy_4694(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_4695","instance":4695,"id":224710,"goal":"function ListReverse_4695(s: seq): seq\n ensures |ListReverse_4695(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_4695(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_4696","instance":4696,"id":224711,"goal":"function Factorial_4696(n: nat): nat\n ensures Factorial_4696(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_4696(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_4697","instance":4697,"id":224712,"goal":"function Fib_4697(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_4697(n-1) + Fib_4697(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_4698","instance":4698,"id":224713,"goal":"function Gcd_4698(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_4698(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_4699","instance":4699,"id":224714,"goal":"function Power_4699(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_4699(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_4700","instance":4700,"id":224715,"goal":"function Sum_4700(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_4700(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_4701","instance":4701,"id":224716,"goal":"method BinarySearch_4701(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_4702","instance":4702,"id":224717,"goal":"method InsertSort_4702(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_4703","instance":4703,"id":224718,"goal":"method MergeSort_4703(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_4704","instance":4704,"id":224719,"goal":"method ArrayCopy_4704(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_4705","instance":4705,"id":224720,"goal":"function ListReverse_4705(s: seq): seq\n ensures |ListReverse_4705(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_4705(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_4706","instance":4706,"id":224721,"goal":"function Factorial_4706(n: nat): nat\n ensures Factorial_4706(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_4706(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_4707","instance":4707,"id":224722,"goal":"function Fib_4707(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_4707(n-1) + Fib_4707(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_4708","instance":4708,"id":224723,"goal":"function Gcd_4708(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_4708(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_4709","instance":4709,"id":224724,"goal":"function Power_4709(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_4709(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_4710","instance":4710,"id":224725,"goal":"function Sum_4710(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_4710(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_4711","instance":4711,"id":224726,"goal":"method BinarySearch_4711(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_4712","instance":4712,"id":224727,"goal":"method InsertSort_4712(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_4713","instance":4713,"id":224728,"goal":"method MergeSort_4713(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_4714","instance":4714,"id":224729,"goal":"method ArrayCopy_4714(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_4715","instance":4715,"id":224730,"goal":"function ListReverse_4715(s: seq): seq\n ensures |ListReverse_4715(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_4715(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_4716","instance":4716,"id":224731,"goal":"function Factorial_4716(n: nat): nat\n ensures Factorial_4716(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_4716(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_4717","instance":4717,"id":224732,"goal":"function Fib_4717(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_4717(n-1) + Fib_4717(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_4718","instance":4718,"id":224733,"goal":"function Gcd_4718(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_4718(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_4719","instance":4719,"id":224734,"goal":"function Power_4719(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_4719(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_4720","instance":4720,"id":224735,"goal":"function Sum_4720(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_4720(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_4721","instance":4721,"id":224736,"goal":"method BinarySearch_4721(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_4722","instance":4722,"id":224737,"goal":"method InsertSort_4722(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_4723","instance":4723,"id":224738,"goal":"method MergeSort_4723(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_4724","instance":4724,"id":224739,"goal":"method ArrayCopy_4724(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_4725","instance":4725,"id":224740,"goal":"function ListReverse_4725(s: seq): seq\n ensures |ListReverse_4725(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_4725(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_4726","instance":4726,"id":224741,"goal":"function Factorial_4726(n: nat): nat\n ensures Factorial_4726(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_4726(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_4727","instance":4727,"id":224742,"goal":"function Fib_4727(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_4727(n-1) + Fib_4727(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_4728","instance":4728,"id":224743,"goal":"function Gcd_4728(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_4728(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_4729","instance":4729,"id":224744,"goal":"function Power_4729(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_4729(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_4730","instance":4730,"id":224745,"goal":"function Sum_4730(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_4730(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_4731","instance":4731,"id":224746,"goal":"method BinarySearch_4731(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_4732","instance":4732,"id":224747,"goal":"method InsertSort_4732(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_4733","instance":4733,"id":224748,"goal":"method MergeSort_4733(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_4734","instance":4734,"id":224749,"goal":"method ArrayCopy_4734(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_4735","instance":4735,"id":224750,"goal":"function ListReverse_4735(s: seq): seq\n ensures |ListReverse_4735(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_4735(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_4736","instance":4736,"id":224751,"goal":"function Factorial_4736(n: nat): nat\n ensures Factorial_4736(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_4736(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_4737","instance":4737,"id":224752,"goal":"function Fib_4737(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_4737(n-1) + Fib_4737(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_4738","instance":4738,"id":224753,"goal":"function Gcd_4738(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_4738(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_4739","instance":4739,"id":224754,"goal":"function Power_4739(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_4739(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_4740","instance":4740,"id":224755,"goal":"function Sum_4740(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_4740(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_4741","instance":4741,"id":224756,"goal":"method BinarySearch_4741(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_4742","instance":4742,"id":224757,"goal":"method InsertSort_4742(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_4743","instance":4743,"id":224758,"goal":"method MergeSort_4743(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_4744","instance":4744,"id":224759,"goal":"method ArrayCopy_4744(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_4745","instance":4745,"id":224760,"goal":"function ListReverse_4745(s: seq): seq\n ensures |ListReverse_4745(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_4745(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_4746","instance":4746,"id":224761,"goal":"function Factorial_4746(n: nat): nat\n ensures Factorial_4746(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_4746(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_4747","instance":4747,"id":224762,"goal":"function Fib_4747(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_4747(n-1) + Fib_4747(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_4748","instance":4748,"id":224763,"goal":"function Gcd_4748(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_4748(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_4749","instance":4749,"id":224764,"goal":"function Power_4749(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_4749(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_4750","instance":4750,"id":224765,"goal":"function Sum_4750(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_4750(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_4751","instance":4751,"id":224766,"goal":"method BinarySearch_4751(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_4752","instance":4752,"id":224767,"goal":"method InsertSort_4752(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_4753","instance":4753,"id":224768,"goal":"method MergeSort_4753(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_4754","instance":4754,"id":224769,"goal":"method ArrayCopy_4754(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_4755","instance":4755,"id":224770,"goal":"function ListReverse_4755(s: seq): seq\n ensures |ListReverse_4755(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_4755(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_4756","instance":4756,"id":224771,"goal":"function Factorial_4756(n: nat): nat\n ensures Factorial_4756(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_4756(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_4757","instance":4757,"id":224772,"goal":"function Fib_4757(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_4757(n-1) + Fib_4757(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_4758","instance":4758,"id":224773,"goal":"function Gcd_4758(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_4758(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_4759","instance":4759,"id":224774,"goal":"function Power_4759(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_4759(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_4760","instance":4760,"id":224775,"goal":"function Sum_4760(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_4760(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_4761","instance":4761,"id":224776,"goal":"method BinarySearch_4761(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_4762","instance":4762,"id":224777,"goal":"method InsertSort_4762(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_4763","instance":4763,"id":224778,"goal":"method MergeSort_4763(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_4764","instance":4764,"id":224779,"goal":"method ArrayCopy_4764(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_4765","instance":4765,"id":224780,"goal":"function ListReverse_4765(s: seq): seq\n ensures |ListReverse_4765(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_4765(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_4766","instance":4766,"id":224781,"goal":"function Factorial_4766(n: nat): nat\n ensures Factorial_4766(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_4766(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_4767","instance":4767,"id":224782,"goal":"function Fib_4767(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_4767(n-1) + Fib_4767(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_4768","instance":4768,"id":224783,"goal":"function Gcd_4768(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_4768(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_4769","instance":4769,"id":224784,"goal":"function Power_4769(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_4769(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_4770","instance":4770,"id":224785,"goal":"function Sum_4770(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_4770(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_4771","instance":4771,"id":224786,"goal":"method BinarySearch_4771(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_4772","instance":4772,"id":224787,"goal":"method InsertSort_4772(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_4773","instance":4773,"id":224788,"goal":"method MergeSort_4773(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_4774","instance":4774,"id":224789,"goal":"method ArrayCopy_4774(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_4775","instance":4775,"id":224790,"goal":"function ListReverse_4775(s: seq): seq\n ensures |ListReverse_4775(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_4775(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_4776","instance":4776,"id":224791,"goal":"function Factorial_4776(n: nat): nat\n ensures Factorial_4776(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_4776(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_4777","instance":4777,"id":224792,"goal":"function Fib_4777(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_4777(n-1) + Fib_4777(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_4778","instance":4778,"id":224793,"goal":"function Gcd_4778(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_4778(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_4779","instance":4779,"id":224794,"goal":"function Power_4779(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_4779(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_4780","instance":4780,"id":224795,"goal":"function Sum_4780(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_4780(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_4781","instance":4781,"id":224796,"goal":"method BinarySearch_4781(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_4782","instance":4782,"id":224797,"goal":"method InsertSort_4782(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_4783","instance":4783,"id":224798,"goal":"method MergeSort_4783(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_4784","instance":4784,"id":224799,"goal":"method ArrayCopy_4784(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_4785","instance":4785,"id":224800,"goal":"function ListReverse_4785(s: seq): seq\n ensures |ListReverse_4785(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_4785(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_4786","instance":4786,"id":224801,"goal":"function Factorial_4786(n: nat): nat\n ensures Factorial_4786(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_4786(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_4787","instance":4787,"id":224802,"goal":"function Fib_4787(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_4787(n-1) + Fib_4787(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_4788","instance":4788,"id":224803,"goal":"function Gcd_4788(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_4788(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_4789","instance":4789,"id":224804,"goal":"function Power_4789(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_4789(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_4790","instance":4790,"id":224805,"goal":"function Sum_4790(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_4790(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_4791","instance":4791,"id":224806,"goal":"method BinarySearch_4791(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_4792","instance":4792,"id":224807,"goal":"method InsertSort_4792(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_4793","instance":4793,"id":224808,"goal":"method MergeSort_4793(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_4794","instance":4794,"id":224809,"goal":"method ArrayCopy_4794(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_4795","instance":4795,"id":224810,"goal":"function ListReverse_4795(s: seq): seq\n ensures |ListReverse_4795(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_4795(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_4796","instance":4796,"id":224811,"goal":"function Factorial_4796(n: nat): nat\n ensures Factorial_4796(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_4796(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_4797","instance":4797,"id":224812,"goal":"function Fib_4797(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_4797(n-1) + Fib_4797(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_4798","instance":4798,"id":224813,"goal":"function Gcd_4798(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_4798(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_4799","instance":4799,"id":224814,"goal":"function Power_4799(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_4799(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_4800","instance":4800,"id":224815,"goal":"function Sum_4800(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_4800(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_4801","instance":4801,"id":224816,"goal":"method BinarySearch_4801(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_4802","instance":4802,"id":224817,"goal":"method InsertSort_4802(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_4803","instance":4803,"id":224818,"goal":"method MergeSort_4803(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_4804","instance":4804,"id":224819,"goal":"method ArrayCopy_4804(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_4805","instance":4805,"id":224820,"goal":"function ListReverse_4805(s: seq): seq\n ensures |ListReverse_4805(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_4805(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_4806","instance":4806,"id":224821,"goal":"function Factorial_4806(n: nat): nat\n ensures Factorial_4806(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_4806(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_4807","instance":4807,"id":224822,"goal":"function Fib_4807(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_4807(n-1) + Fib_4807(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_4808","instance":4808,"id":224823,"goal":"function Gcd_4808(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_4808(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_4809","instance":4809,"id":224824,"goal":"function Power_4809(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_4809(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_4810","instance":4810,"id":224825,"goal":"function Sum_4810(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_4810(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_4811","instance":4811,"id":224826,"goal":"method BinarySearch_4811(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_4812","instance":4812,"id":224827,"goal":"method InsertSort_4812(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_4813","instance":4813,"id":224828,"goal":"method MergeSort_4813(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_4814","instance":4814,"id":224829,"goal":"method ArrayCopy_4814(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_4815","instance":4815,"id":224830,"goal":"function ListReverse_4815(s: seq): seq\n ensures |ListReverse_4815(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_4815(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_4816","instance":4816,"id":224831,"goal":"function Factorial_4816(n: nat): nat\n ensures Factorial_4816(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_4816(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_4817","instance":4817,"id":224832,"goal":"function Fib_4817(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_4817(n-1) + Fib_4817(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_4818","instance":4818,"id":224833,"goal":"function Gcd_4818(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_4818(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_4819","instance":4819,"id":224834,"goal":"function Power_4819(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_4819(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_4820","instance":4820,"id":224835,"goal":"function Sum_4820(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_4820(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_4821","instance":4821,"id":224836,"goal":"method BinarySearch_4821(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_4822","instance":4822,"id":224837,"goal":"method InsertSort_4822(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_4823","instance":4823,"id":224838,"goal":"method MergeSort_4823(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_4824","instance":4824,"id":224839,"goal":"method ArrayCopy_4824(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_4825","instance":4825,"id":224840,"goal":"function ListReverse_4825(s: seq): seq\n ensures |ListReverse_4825(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_4825(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_4826","instance":4826,"id":224841,"goal":"function Factorial_4826(n: nat): nat\n ensures Factorial_4826(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_4826(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_4827","instance":4827,"id":224842,"goal":"function Fib_4827(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_4827(n-1) + Fib_4827(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_4828","instance":4828,"id":224843,"goal":"function Gcd_4828(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_4828(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_4829","instance":4829,"id":224844,"goal":"function Power_4829(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_4829(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_4830","instance":4830,"id":224845,"goal":"function Sum_4830(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_4830(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_4831","instance":4831,"id":224846,"goal":"method BinarySearch_4831(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_4832","instance":4832,"id":224847,"goal":"method InsertSort_4832(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_4833","instance":4833,"id":224848,"goal":"method MergeSort_4833(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_4834","instance":4834,"id":224849,"goal":"method ArrayCopy_4834(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_4835","instance":4835,"id":224850,"goal":"function ListReverse_4835(s: seq): seq\n ensures |ListReverse_4835(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_4835(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_4836","instance":4836,"id":224851,"goal":"function Factorial_4836(n: nat): nat\n ensures Factorial_4836(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_4836(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_4837","instance":4837,"id":224852,"goal":"function Fib_4837(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_4837(n-1) + Fib_4837(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_4838","instance":4838,"id":224853,"goal":"function Gcd_4838(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_4838(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_4839","instance":4839,"id":224854,"goal":"function Power_4839(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_4839(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_4840","instance":4840,"id":224855,"goal":"function Sum_4840(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_4840(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_4841","instance":4841,"id":224856,"goal":"method BinarySearch_4841(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_4842","instance":4842,"id":224857,"goal":"method InsertSort_4842(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_4843","instance":4843,"id":224858,"goal":"method MergeSort_4843(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_4844","instance":4844,"id":224859,"goal":"method ArrayCopy_4844(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_4845","instance":4845,"id":224860,"goal":"function ListReverse_4845(s: seq): seq\n ensures |ListReverse_4845(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_4845(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_4846","instance":4846,"id":224861,"goal":"function Factorial_4846(n: nat): nat\n ensures Factorial_4846(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_4846(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_4847","instance":4847,"id":224862,"goal":"function Fib_4847(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_4847(n-1) + Fib_4847(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_4848","instance":4848,"id":224863,"goal":"function Gcd_4848(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_4848(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_4849","instance":4849,"id":224864,"goal":"function Power_4849(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_4849(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_4850","instance":4850,"id":224865,"goal":"function Sum_4850(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_4850(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_4851","instance":4851,"id":224866,"goal":"method BinarySearch_4851(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_4852","instance":4852,"id":224867,"goal":"method InsertSort_4852(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_4853","instance":4853,"id":224868,"goal":"method MergeSort_4853(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_4854","instance":4854,"id":224869,"goal":"method ArrayCopy_4854(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_4855","instance":4855,"id":224870,"goal":"function ListReverse_4855(s: seq): seq\n ensures |ListReverse_4855(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_4855(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_4856","instance":4856,"id":224871,"goal":"function Factorial_4856(n: nat): nat\n ensures Factorial_4856(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_4856(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_4857","instance":4857,"id":224872,"goal":"function Fib_4857(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_4857(n-1) + Fib_4857(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_4858","instance":4858,"id":224873,"goal":"function Gcd_4858(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_4858(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_4859","instance":4859,"id":224874,"goal":"function Power_4859(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_4859(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_4860","instance":4860,"id":224875,"goal":"function Sum_4860(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_4860(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_4861","instance":4861,"id":224876,"goal":"method BinarySearch_4861(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_4862","instance":4862,"id":224877,"goal":"method InsertSort_4862(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_4863","instance":4863,"id":224878,"goal":"method MergeSort_4863(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_4864","instance":4864,"id":224879,"goal":"method ArrayCopy_4864(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_4865","instance":4865,"id":224880,"goal":"function ListReverse_4865(s: seq): seq\n ensures |ListReverse_4865(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_4865(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_4866","instance":4866,"id":224881,"goal":"function Factorial_4866(n: nat): nat\n ensures Factorial_4866(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_4866(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_4867","instance":4867,"id":224882,"goal":"function Fib_4867(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_4867(n-1) + Fib_4867(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_4868","instance":4868,"id":224883,"goal":"function Gcd_4868(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_4868(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_4869","instance":4869,"id":224884,"goal":"function Power_4869(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_4869(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_4870","instance":4870,"id":224885,"goal":"function Sum_4870(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_4870(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_4871","instance":4871,"id":224886,"goal":"method BinarySearch_4871(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_4872","instance":4872,"id":224887,"goal":"method InsertSort_4872(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_4873","instance":4873,"id":224888,"goal":"method MergeSort_4873(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_4874","instance":4874,"id":224889,"goal":"method ArrayCopy_4874(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_4875","instance":4875,"id":224890,"goal":"function ListReverse_4875(s: seq): seq\n ensures |ListReverse_4875(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_4875(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_4876","instance":4876,"id":224891,"goal":"function Factorial_4876(n: nat): nat\n ensures Factorial_4876(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_4876(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_4877","instance":4877,"id":224892,"goal":"function Fib_4877(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_4877(n-1) + Fib_4877(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_4878","instance":4878,"id":224893,"goal":"function Gcd_4878(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_4878(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_4879","instance":4879,"id":224894,"goal":"function Power_4879(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_4879(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_4880","instance":4880,"id":224895,"goal":"function Sum_4880(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_4880(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_4881","instance":4881,"id":224896,"goal":"method BinarySearch_4881(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_4882","instance":4882,"id":224897,"goal":"method InsertSort_4882(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_4883","instance":4883,"id":224898,"goal":"method MergeSort_4883(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_4884","instance":4884,"id":224899,"goal":"method ArrayCopy_4884(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_4885","instance":4885,"id":224900,"goal":"function ListReverse_4885(s: seq): seq\n ensures |ListReverse_4885(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_4885(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_4886","instance":4886,"id":224901,"goal":"function Factorial_4886(n: nat): nat\n ensures Factorial_4886(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_4886(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_4887","instance":4887,"id":224902,"goal":"function Fib_4887(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_4887(n-1) + Fib_4887(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_4888","instance":4888,"id":224903,"goal":"function Gcd_4888(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_4888(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_4889","instance":4889,"id":224904,"goal":"function Power_4889(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_4889(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_4890","instance":4890,"id":224905,"goal":"function Sum_4890(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_4890(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_4891","instance":4891,"id":224906,"goal":"method BinarySearch_4891(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_4892","instance":4892,"id":224907,"goal":"method InsertSort_4892(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_4893","instance":4893,"id":224908,"goal":"method MergeSort_4893(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_4894","instance":4894,"id":224909,"goal":"method ArrayCopy_4894(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_4895","instance":4895,"id":224910,"goal":"function ListReverse_4895(s: seq): seq\n ensures |ListReverse_4895(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_4895(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_4896","instance":4896,"id":224911,"goal":"function Factorial_4896(n: nat): nat\n ensures Factorial_4896(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_4896(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_4897","instance":4897,"id":224912,"goal":"function Fib_4897(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_4897(n-1) + Fib_4897(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_4898","instance":4898,"id":224913,"goal":"function Gcd_4898(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_4898(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_4899","instance":4899,"id":224914,"goal":"function Power_4899(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_4899(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_4900","instance":4900,"id":224915,"goal":"function Sum_4900(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_4900(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_4901","instance":4901,"id":224916,"goal":"method BinarySearch_4901(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_4902","instance":4902,"id":224917,"goal":"method InsertSort_4902(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_4903","instance":4903,"id":224918,"goal":"method MergeSort_4903(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_4904","instance":4904,"id":224919,"goal":"method ArrayCopy_4904(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_4905","instance":4905,"id":224920,"goal":"function ListReverse_4905(s: seq): seq\n ensures |ListReverse_4905(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_4905(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_4906","instance":4906,"id":224921,"goal":"function Factorial_4906(n: nat): nat\n ensures Factorial_4906(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_4906(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_4907","instance":4907,"id":224922,"goal":"function Fib_4907(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_4907(n-1) + Fib_4907(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_4908","instance":4908,"id":224923,"goal":"function Gcd_4908(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_4908(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_4909","instance":4909,"id":224924,"goal":"function Power_4909(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_4909(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_4910","instance":4910,"id":224925,"goal":"function Sum_4910(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_4910(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_4911","instance":4911,"id":224926,"goal":"method BinarySearch_4911(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_4912","instance":4912,"id":224927,"goal":"method InsertSort_4912(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_4913","instance":4913,"id":224928,"goal":"method MergeSort_4913(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_4914","instance":4914,"id":224929,"goal":"method ArrayCopy_4914(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_4915","instance":4915,"id":224930,"goal":"function ListReverse_4915(s: seq): seq\n ensures |ListReverse_4915(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_4915(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_4916","instance":4916,"id":224931,"goal":"function Factorial_4916(n: nat): nat\n ensures Factorial_4916(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_4916(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_4917","instance":4917,"id":224932,"goal":"function Fib_4917(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_4917(n-1) + Fib_4917(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_4918","instance":4918,"id":224933,"goal":"function Gcd_4918(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_4918(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_4919","instance":4919,"id":224934,"goal":"function Power_4919(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_4919(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_4920","instance":4920,"id":224935,"goal":"function Sum_4920(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_4920(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_4921","instance":4921,"id":224936,"goal":"method BinarySearch_4921(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_4922","instance":4922,"id":224937,"goal":"method InsertSort_4922(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_4923","instance":4923,"id":224938,"goal":"method MergeSort_4923(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_4924","instance":4924,"id":224939,"goal":"method ArrayCopy_4924(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_4925","instance":4925,"id":224940,"goal":"function ListReverse_4925(s: seq): seq\n ensures |ListReverse_4925(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_4925(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_4926","instance":4926,"id":224941,"goal":"function Factorial_4926(n: nat): nat\n ensures Factorial_4926(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_4926(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_4927","instance":4927,"id":224942,"goal":"function Fib_4927(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_4927(n-1) + Fib_4927(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_4928","instance":4928,"id":224943,"goal":"function Gcd_4928(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_4928(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_4929","instance":4929,"id":224944,"goal":"function Power_4929(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_4929(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_4930","instance":4930,"id":224945,"goal":"function Sum_4930(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_4930(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_4931","instance":4931,"id":224946,"goal":"method BinarySearch_4931(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_4932","instance":4932,"id":224947,"goal":"method InsertSort_4932(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_4933","instance":4933,"id":224948,"goal":"method MergeSort_4933(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_4934","instance":4934,"id":224949,"goal":"method ArrayCopy_4934(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_4935","instance":4935,"id":224950,"goal":"function ListReverse_4935(s: seq): seq\n ensures |ListReverse_4935(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_4935(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_4936","instance":4936,"id":224951,"goal":"function Factorial_4936(n: nat): nat\n ensures Factorial_4936(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_4936(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_4937","instance":4937,"id":224952,"goal":"function Fib_4937(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_4937(n-1) + Fib_4937(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_4938","instance":4938,"id":224953,"goal":"function Gcd_4938(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_4938(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_4939","instance":4939,"id":224954,"goal":"function Power_4939(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_4939(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_4940","instance":4940,"id":224955,"goal":"function Sum_4940(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_4940(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_4941","instance":4941,"id":224956,"goal":"method BinarySearch_4941(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_4942","instance":4942,"id":224957,"goal":"method InsertSort_4942(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_4943","instance":4943,"id":224958,"goal":"method MergeSort_4943(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_4944","instance":4944,"id":224959,"goal":"method ArrayCopy_4944(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_4945","instance":4945,"id":224960,"goal":"function ListReverse_4945(s: seq): seq\n ensures |ListReverse_4945(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_4945(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_4946","instance":4946,"id":224961,"goal":"function Factorial_4946(n: nat): nat\n ensures Factorial_4946(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_4946(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_4947","instance":4947,"id":224962,"goal":"function Fib_4947(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_4947(n-1) + Fib_4947(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_4948","instance":4948,"id":224963,"goal":"function Gcd_4948(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_4948(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_4949","instance":4949,"id":224964,"goal":"function Power_4949(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_4949(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_4950","instance":4950,"id":224965,"goal":"function Sum_4950(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_4950(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_4951","instance":4951,"id":224966,"goal":"method BinarySearch_4951(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_4952","instance":4952,"id":224967,"goal":"method InsertSort_4952(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_4953","instance":4953,"id":224968,"goal":"method MergeSort_4953(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_4954","instance":4954,"id":224969,"goal":"method ArrayCopy_4954(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_4955","instance":4955,"id":224970,"goal":"function ListReverse_4955(s: seq): seq\n ensures |ListReverse_4955(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_4955(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_4956","instance":4956,"id":224971,"goal":"function Factorial_4956(n: nat): nat\n ensures Factorial_4956(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_4956(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_4957","instance":4957,"id":224972,"goal":"function Fib_4957(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_4957(n-1) + Fib_4957(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_4958","instance":4958,"id":224973,"goal":"function Gcd_4958(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_4958(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_4959","instance":4959,"id":224974,"goal":"function Power_4959(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_4959(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_4960","instance":4960,"id":224975,"goal":"function Sum_4960(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_4960(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_4961","instance":4961,"id":224976,"goal":"method BinarySearch_4961(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_4962","instance":4962,"id":224977,"goal":"method InsertSort_4962(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_4963","instance":4963,"id":224978,"goal":"method MergeSort_4963(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_4964","instance":4964,"id":224979,"goal":"method ArrayCopy_4964(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_4965","instance":4965,"id":224980,"goal":"function ListReverse_4965(s: seq): seq\n ensures |ListReverse_4965(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_4965(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_4966","instance":4966,"id":224981,"goal":"function Factorial_4966(n: nat): nat\n ensures Factorial_4966(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_4966(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_4967","instance":4967,"id":224982,"goal":"function Fib_4967(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_4967(n-1) + Fib_4967(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_4968","instance":4968,"id":224983,"goal":"function Gcd_4968(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_4968(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_4969","instance":4969,"id":224984,"goal":"function Power_4969(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_4969(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_4970","instance":4970,"id":224985,"goal":"function Sum_4970(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_4970(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_4971","instance":4971,"id":224986,"goal":"method BinarySearch_4971(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_4972","instance":4972,"id":224987,"goal":"method InsertSort_4972(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_4973","instance":4973,"id":224988,"goal":"method MergeSort_4973(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_4974","instance":4974,"id":224989,"goal":"method ArrayCopy_4974(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_4975","instance":4975,"id":224990,"goal":"function ListReverse_4975(s: seq): seq\n ensures |ListReverse_4975(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_4975(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_4976","instance":4976,"id":224991,"goal":"function Factorial_4976(n: nat): nat\n ensures Factorial_4976(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_4976(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_4977","instance":4977,"id":224992,"goal":"function Fib_4977(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_4977(n-1) + Fib_4977(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_4978","instance":4978,"id":224993,"goal":"function Gcd_4978(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_4978(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_4979","instance":4979,"id":224994,"goal":"function Power_4979(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_4979(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_4980","instance":4980,"id":224995,"goal":"function Sum_4980(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_4980(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_4981","instance":4981,"id":224996,"goal":"method BinarySearch_4981(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_4982","instance":4982,"id":224997,"goal":"method InsertSort_4982(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_4983","instance":4983,"id":224998,"goal":"method MergeSort_4983(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_4984","instance":4984,"id":224999,"goal":"method ArrayCopy_4984(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_4985","instance":4985,"id":225000,"goal":"function ListReverse_4985(s: seq): seq\n ensures |ListReverse_4985(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_4985(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_4986","instance":4986,"id":225001,"goal":"function Factorial_4986(n: nat): nat\n ensures Factorial_4986(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_4986(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_4987","instance":4987,"id":225002,"goal":"function Fib_4987(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_4987(n-1) + Fib_4987(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_4988","instance":4988,"id":225003,"goal":"function Gcd_4988(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_4988(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_4989","instance":4989,"id":225004,"goal":"function Power_4989(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_4989(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_4990","instance":4990,"id":225005,"goal":"function Sum_4990(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_4990(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_4991","instance":4991,"id":225006,"goal":"method BinarySearch_4991(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_4992","instance":4992,"id":225007,"goal":"method InsertSort_4992(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_4993","instance":4993,"id":225008,"goal":"method MergeSort_4993(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_4994","instance":4994,"id":225009,"goal":"method ArrayCopy_4994(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_4995","instance":4995,"id":225010,"goal":"function ListReverse_4995(s: seq): seq\n ensures |ListReverse_4995(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_4995(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_4996","instance":4996,"id":225011,"goal":"function Factorial_4996(n: nat): nat\n ensures Factorial_4996(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_4996(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_4997","instance":4997,"id":225012,"goal":"function Fib_4997(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_4997(n-1) + Fib_4997(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_4998","instance":4998,"id":225013,"goal":"function Gcd_4998(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_4998(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_4999","instance":4999,"id":225014,"goal":"function Power_4999(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_4999(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_5000","instance":5000,"id":225015,"goal":"function Sum_5000(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_5000(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_5001","instance":5001,"id":225016,"goal":"method BinarySearch_5001(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_5002","instance":5002,"id":225017,"goal":"method InsertSort_5002(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_5003","instance":5003,"id":225018,"goal":"method MergeSort_5003(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_5004","instance":5004,"id":225019,"goal":"method ArrayCopy_5004(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_5005","instance":5005,"id":225020,"goal":"function ListReverse_5005(s: seq): seq\n ensures |ListReverse_5005(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_5005(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_5006","instance":5006,"id":225021,"goal":"function Factorial_5006(n: nat): nat\n ensures Factorial_5006(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_5006(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_5007","instance":5007,"id":225022,"goal":"function Fib_5007(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_5007(n-1) + Fib_5007(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_5008","instance":5008,"id":225023,"goal":"function Gcd_5008(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_5008(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_5009","instance":5009,"id":225024,"goal":"function Power_5009(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_5009(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_5010","instance":5010,"id":225025,"goal":"function Sum_5010(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_5010(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_5011","instance":5011,"id":225026,"goal":"method BinarySearch_5011(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_5012","instance":5012,"id":225027,"goal":"method InsertSort_5012(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_5013","instance":5013,"id":225028,"goal":"method MergeSort_5013(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_5014","instance":5014,"id":225029,"goal":"method ArrayCopy_5014(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_5015","instance":5015,"id":225030,"goal":"function ListReverse_5015(s: seq): seq\n ensures |ListReverse_5015(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_5015(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_5016","instance":5016,"id":225031,"goal":"function Factorial_5016(n: nat): nat\n ensures Factorial_5016(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_5016(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_5017","instance":5017,"id":225032,"goal":"function Fib_5017(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_5017(n-1) + Fib_5017(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_5018","instance":5018,"id":225033,"goal":"function Gcd_5018(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_5018(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_5019","instance":5019,"id":225034,"goal":"function Power_5019(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_5019(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_5020","instance":5020,"id":225035,"goal":"function Sum_5020(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_5020(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_5021","instance":5021,"id":225036,"goal":"method BinarySearch_5021(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_5022","instance":5022,"id":225037,"goal":"method InsertSort_5022(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_5023","instance":5023,"id":225038,"goal":"method MergeSort_5023(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_5024","instance":5024,"id":225039,"goal":"method ArrayCopy_5024(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_5025","instance":5025,"id":225040,"goal":"function ListReverse_5025(s: seq): seq\n ensures |ListReverse_5025(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_5025(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_5026","instance":5026,"id":225041,"goal":"function Factorial_5026(n: nat): nat\n ensures Factorial_5026(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_5026(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_5027","instance":5027,"id":225042,"goal":"function Fib_5027(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_5027(n-1) + Fib_5027(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_5028","instance":5028,"id":225043,"goal":"function Gcd_5028(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_5028(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_5029","instance":5029,"id":225044,"goal":"function Power_5029(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_5029(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_5030","instance":5030,"id":225045,"goal":"function Sum_5030(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_5030(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_5031","instance":5031,"id":225046,"goal":"method BinarySearch_5031(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_5032","instance":5032,"id":225047,"goal":"method InsertSort_5032(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_5033","instance":5033,"id":225048,"goal":"method MergeSort_5033(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_5034","instance":5034,"id":225049,"goal":"method ArrayCopy_5034(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_5035","instance":5035,"id":225050,"goal":"function ListReverse_5035(s: seq): seq\n ensures |ListReverse_5035(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_5035(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_5036","instance":5036,"id":225051,"goal":"function Factorial_5036(n: nat): nat\n ensures Factorial_5036(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_5036(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_5037","instance":5037,"id":225052,"goal":"function Fib_5037(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_5037(n-1) + Fib_5037(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_5038","instance":5038,"id":225053,"goal":"function Gcd_5038(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_5038(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_5039","instance":5039,"id":225054,"goal":"function Power_5039(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_5039(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_5040","instance":5040,"id":225055,"goal":"function Sum_5040(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_5040(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_5041","instance":5041,"id":225056,"goal":"method BinarySearch_5041(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_5042","instance":5042,"id":225057,"goal":"method InsertSort_5042(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_5043","instance":5043,"id":225058,"goal":"method MergeSort_5043(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_5044","instance":5044,"id":225059,"goal":"method ArrayCopy_5044(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_5045","instance":5045,"id":225060,"goal":"function ListReverse_5045(s: seq): seq\n ensures |ListReverse_5045(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_5045(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_5046","instance":5046,"id":225061,"goal":"function Factorial_5046(n: nat): nat\n ensures Factorial_5046(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_5046(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_5047","instance":5047,"id":225062,"goal":"function Fib_5047(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_5047(n-1) + Fib_5047(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_5048","instance":5048,"id":225063,"goal":"function Gcd_5048(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_5048(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_5049","instance":5049,"id":225064,"goal":"function Power_5049(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_5049(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_5050","instance":5050,"id":225065,"goal":"function Sum_5050(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_5050(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_5051","instance":5051,"id":225066,"goal":"method BinarySearch_5051(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_5052","instance":5052,"id":225067,"goal":"method InsertSort_5052(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_5053","instance":5053,"id":225068,"goal":"method MergeSort_5053(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_5054","instance":5054,"id":225069,"goal":"method ArrayCopy_5054(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_5055","instance":5055,"id":225070,"goal":"function ListReverse_5055(s: seq): seq\n ensures |ListReverse_5055(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_5055(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_5056","instance":5056,"id":225071,"goal":"function Factorial_5056(n: nat): nat\n ensures Factorial_5056(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_5056(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_5057","instance":5057,"id":225072,"goal":"function Fib_5057(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_5057(n-1) + Fib_5057(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_5058","instance":5058,"id":225073,"goal":"function Gcd_5058(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_5058(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_5059","instance":5059,"id":225074,"goal":"function Power_5059(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_5059(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_5060","instance":5060,"id":225075,"goal":"function Sum_5060(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_5060(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_5061","instance":5061,"id":225076,"goal":"method BinarySearch_5061(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_5062","instance":5062,"id":225077,"goal":"method InsertSort_5062(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_5063","instance":5063,"id":225078,"goal":"method MergeSort_5063(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_5064","instance":5064,"id":225079,"goal":"method ArrayCopy_5064(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_5065","instance":5065,"id":225080,"goal":"function ListReverse_5065(s: seq): seq\n ensures |ListReverse_5065(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_5065(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_5066","instance":5066,"id":225081,"goal":"function Factorial_5066(n: nat): nat\n ensures Factorial_5066(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_5066(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_5067","instance":5067,"id":225082,"goal":"function Fib_5067(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_5067(n-1) + Fib_5067(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_5068","instance":5068,"id":225083,"goal":"function Gcd_5068(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_5068(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_5069","instance":5069,"id":225084,"goal":"function Power_5069(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_5069(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_5070","instance":5070,"id":225085,"goal":"function Sum_5070(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_5070(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_5071","instance":5071,"id":225086,"goal":"method BinarySearch_5071(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_5072","instance":5072,"id":225087,"goal":"method InsertSort_5072(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_5073","instance":5073,"id":225088,"goal":"method MergeSort_5073(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_5074","instance":5074,"id":225089,"goal":"method ArrayCopy_5074(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_5075","instance":5075,"id":225090,"goal":"function ListReverse_5075(s: seq): seq\n ensures |ListReverse_5075(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_5075(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_5076","instance":5076,"id":225091,"goal":"function Factorial_5076(n: nat): nat\n ensures Factorial_5076(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_5076(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_5077","instance":5077,"id":225092,"goal":"function Fib_5077(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_5077(n-1) + Fib_5077(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_5078","instance":5078,"id":225093,"goal":"function Gcd_5078(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_5078(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_5079","instance":5079,"id":225094,"goal":"function Power_5079(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_5079(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_5080","instance":5080,"id":225095,"goal":"function Sum_5080(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_5080(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_5081","instance":5081,"id":225096,"goal":"method BinarySearch_5081(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_5082","instance":5082,"id":225097,"goal":"method InsertSort_5082(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_5083","instance":5083,"id":225098,"goal":"method MergeSort_5083(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_5084","instance":5084,"id":225099,"goal":"method ArrayCopy_5084(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_5085","instance":5085,"id":225100,"goal":"function ListReverse_5085(s: seq): seq\n ensures |ListReverse_5085(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_5085(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_5086","instance":5086,"id":225101,"goal":"function Factorial_5086(n: nat): nat\n ensures Factorial_5086(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_5086(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_5087","instance":5087,"id":225102,"goal":"function Fib_5087(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_5087(n-1) + Fib_5087(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_5088","instance":5088,"id":225103,"goal":"function Gcd_5088(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_5088(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_5089","instance":5089,"id":225104,"goal":"function Power_5089(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_5089(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_5090","instance":5090,"id":225105,"goal":"function Sum_5090(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_5090(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_5091","instance":5091,"id":225106,"goal":"method BinarySearch_5091(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_5092","instance":5092,"id":225107,"goal":"method InsertSort_5092(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_5093","instance":5093,"id":225108,"goal":"method MergeSort_5093(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_5094","instance":5094,"id":225109,"goal":"method ArrayCopy_5094(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_5095","instance":5095,"id":225110,"goal":"function ListReverse_5095(s: seq): seq\n ensures |ListReverse_5095(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_5095(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_5096","instance":5096,"id":225111,"goal":"function Factorial_5096(n: nat): nat\n ensures Factorial_5096(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_5096(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_5097","instance":5097,"id":225112,"goal":"function Fib_5097(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_5097(n-1) + Fib_5097(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_5098","instance":5098,"id":225113,"goal":"function Gcd_5098(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_5098(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_5099","instance":5099,"id":225114,"goal":"function Power_5099(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_5099(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_5100","instance":5100,"id":225115,"goal":"function Sum_5100(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_5100(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_5101","instance":5101,"id":225116,"goal":"method BinarySearch_5101(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_5102","instance":5102,"id":225117,"goal":"method InsertSort_5102(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_5103","instance":5103,"id":225118,"goal":"method MergeSort_5103(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_5104","instance":5104,"id":225119,"goal":"method ArrayCopy_5104(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_5105","instance":5105,"id":225120,"goal":"function ListReverse_5105(s: seq): seq\n ensures |ListReverse_5105(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_5105(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_5106","instance":5106,"id":225121,"goal":"function Factorial_5106(n: nat): nat\n ensures Factorial_5106(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_5106(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_5107","instance":5107,"id":225122,"goal":"function Fib_5107(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_5107(n-1) + Fib_5107(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_5108","instance":5108,"id":225123,"goal":"function Gcd_5108(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_5108(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_5109","instance":5109,"id":225124,"goal":"function Power_5109(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_5109(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_5110","instance":5110,"id":225125,"goal":"function Sum_5110(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_5110(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_5111","instance":5111,"id":225126,"goal":"method BinarySearch_5111(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_5112","instance":5112,"id":225127,"goal":"method InsertSort_5112(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_5113","instance":5113,"id":225128,"goal":"method MergeSort_5113(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_5114","instance":5114,"id":225129,"goal":"method ArrayCopy_5114(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_5115","instance":5115,"id":225130,"goal":"function ListReverse_5115(s: seq): seq\n ensures |ListReverse_5115(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_5115(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_5116","instance":5116,"id":225131,"goal":"function Factorial_5116(n: nat): nat\n ensures Factorial_5116(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_5116(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_5117","instance":5117,"id":225132,"goal":"function Fib_5117(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_5117(n-1) + Fib_5117(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_5118","instance":5118,"id":225133,"goal":"function Gcd_5118(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_5118(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_5119","instance":5119,"id":225134,"goal":"function Power_5119(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_5119(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_5120","instance":5120,"id":225135,"goal":"function Sum_5120(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_5120(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_5121","instance":5121,"id":225136,"goal":"method BinarySearch_5121(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_5122","instance":5122,"id":225137,"goal":"method InsertSort_5122(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_5123","instance":5123,"id":225138,"goal":"method MergeSort_5123(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_5124","instance":5124,"id":225139,"goal":"method ArrayCopy_5124(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_5125","instance":5125,"id":225140,"goal":"function ListReverse_5125(s: seq): seq\n ensures |ListReverse_5125(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_5125(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_5126","instance":5126,"id":225141,"goal":"function Factorial_5126(n: nat): nat\n ensures Factorial_5126(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_5126(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_5127","instance":5127,"id":225142,"goal":"function Fib_5127(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_5127(n-1) + Fib_5127(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_5128","instance":5128,"id":225143,"goal":"function Gcd_5128(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_5128(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_5129","instance":5129,"id":225144,"goal":"function Power_5129(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_5129(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_5130","instance":5130,"id":225145,"goal":"function Sum_5130(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_5130(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_5131","instance":5131,"id":225146,"goal":"method BinarySearch_5131(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_5132","instance":5132,"id":225147,"goal":"method InsertSort_5132(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_5133","instance":5133,"id":225148,"goal":"method MergeSort_5133(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_5134","instance":5134,"id":225149,"goal":"method ArrayCopy_5134(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_5135","instance":5135,"id":225150,"goal":"function ListReverse_5135(s: seq): seq\n ensures |ListReverse_5135(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_5135(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_5136","instance":5136,"id":225151,"goal":"function Factorial_5136(n: nat): nat\n ensures Factorial_5136(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_5136(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_5137","instance":5137,"id":225152,"goal":"function Fib_5137(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_5137(n-1) + Fib_5137(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_5138","instance":5138,"id":225153,"goal":"function Gcd_5138(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_5138(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_5139","instance":5139,"id":225154,"goal":"function Power_5139(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_5139(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_5140","instance":5140,"id":225155,"goal":"function Sum_5140(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_5140(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_5141","instance":5141,"id":225156,"goal":"method BinarySearch_5141(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_5142","instance":5142,"id":225157,"goal":"method InsertSort_5142(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_5143","instance":5143,"id":225158,"goal":"method MergeSort_5143(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_5144","instance":5144,"id":225159,"goal":"method ArrayCopy_5144(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_5145","instance":5145,"id":225160,"goal":"function ListReverse_5145(s: seq): seq\n ensures |ListReverse_5145(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_5145(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_5146","instance":5146,"id":225161,"goal":"function Factorial_5146(n: nat): nat\n ensures Factorial_5146(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_5146(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_5147","instance":5147,"id":225162,"goal":"function Fib_5147(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_5147(n-1) + Fib_5147(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_5148","instance":5148,"id":225163,"goal":"function Gcd_5148(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_5148(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_5149","instance":5149,"id":225164,"goal":"function Power_5149(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_5149(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_5150","instance":5150,"id":225165,"goal":"function Sum_5150(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_5150(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_5151","instance":5151,"id":225166,"goal":"method BinarySearch_5151(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_5152","instance":5152,"id":225167,"goal":"method InsertSort_5152(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_5153","instance":5153,"id":225168,"goal":"method MergeSort_5153(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_5154","instance":5154,"id":225169,"goal":"method ArrayCopy_5154(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_5155","instance":5155,"id":225170,"goal":"function ListReverse_5155(s: seq): seq\n ensures |ListReverse_5155(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_5155(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_5156","instance":5156,"id":225171,"goal":"function Factorial_5156(n: nat): nat\n ensures Factorial_5156(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_5156(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_5157","instance":5157,"id":225172,"goal":"function Fib_5157(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_5157(n-1) + Fib_5157(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_5158","instance":5158,"id":225173,"goal":"function Gcd_5158(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_5158(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_5159","instance":5159,"id":225174,"goal":"function Power_5159(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_5159(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_5160","instance":5160,"id":225175,"goal":"function Sum_5160(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_5160(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_5161","instance":5161,"id":225176,"goal":"method BinarySearch_5161(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_5162","instance":5162,"id":225177,"goal":"method InsertSort_5162(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_5163","instance":5163,"id":225178,"goal":"method MergeSort_5163(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_5164","instance":5164,"id":225179,"goal":"method ArrayCopy_5164(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_5165","instance":5165,"id":225180,"goal":"function ListReverse_5165(s: seq): seq\n ensures |ListReverse_5165(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_5165(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_5166","instance":5166,"id":225181,"goal":"function Factorial_5166(n: nat): nat\n ensures Factorial_5166(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_5166(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_5167","instance":5167,"id":225182,"goal":"function Fib_5167(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_5167(n-1) + Fib_5167(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_5168","instance":5168,"id":225183,"goal":"function Gcd_5168(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_5168(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_5169","instance":5169,"id":225184,"goal":"function Power_5169(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_5169(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_5170","instance":5170,"id":225185,"goal":"function Sum_5170(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_5170(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_5171","instance":5171,"id":225186,"goal":"method BinarySearch_5171(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_5172","instance":5172,"id":225187,"goal":"method InsertSort_5172(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_5173","instance":5173,"id":225188,"goal":"method MergeSort_5173(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_5174","instance":5174,"id":225189,"goal":"method ArrayCopy_5174(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_5175","instance":5175,"id":225190,"goal":"function ListReverse_5175(s: seq): seq\n ensures |ListReverse_5175(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_5175(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_5176","instance":5176,"id":225191,"goal":"function Factorial_5176(n: nat): nat\n ensures Factorial_5176(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_5176(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_5177","instance":5177,"id":225192,"goal":"function Fib_5177(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_5177(n-1) + Fib_5177(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_5178","instance":5178,"id":225193,"goal":"function Gcd_5178(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_5178(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_5179","instance":5179,"id":225194,"goal":"function Power_5179(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_5179(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_5180","instance":5180,"id":225195,"goal":"function Sum_5180(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_5180(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_5181","instance":5181,"id":225196,"goal":"method BinarySearch_5181(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_5182","instance":5182,"id":225197,"goal":"method InsertSort_5182(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_5183","instance":5183,"id":225198,"goal":"method MergeSort_5183(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_5184","instance":5184,"id":225199,"goal":"method ArrayCopy_5184(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_5185","instance":5185,"id":225200,"goal":"function ListReverse_5185(s: seq): seq\n ensures |ListReverse_5185(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_5185(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_5186","instance":5186,"id":225201,"goal":"function Factorial_5186(n: nat): nat\n ensures Factorial_5186(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_5186(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_5187","instance":5187,"id":225202,"goal":"function Fib_5187(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_5187(n-1) + Fib_5187(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_5188","instance":5188,"id":225203,"goal":"function Gcd_5188(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_5188(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_5189","instance":5189,"id":225204,"goal":"function Power_5189(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_5189(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_5190","instance":5190,"id":225205,"goal":"function Sum_5190(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_5190(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_5191","instance":5191,"id":225206,"goal":"method BinarySearch_5191(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_5192","instance":5192,"id":225207,"goal":"method InsertSort_5192(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_5193","instance":5193,"id":225208,"goal":"method MergeSort_5193(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_5194","instance":5194,"id":225209,"goal":"method ArrayCopy_5194(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_5195","instance":5195,"id":225210,"goal":"function ListReverse_5195(s: seq): seq\n ensures |ListReverse_5195(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_5195(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_5196","instance":5196,"id":225211,"goal":"function Factorial_5196(n: nat): nat\n ensures Factorial_5196(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_5196(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_5197","instance":5197,"id":225212,"goal":"function Fib_5197(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_5197(n-1) + Fib_5197(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_5198","instance":5198,"id":225213,"goal":"function Gcd_5198(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_5198(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_5199","instance":5199,"id":225214,"goal":"function Power_5199(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_5199(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_5200","instance":5200,"id":225215,"goal":"function Sum_5200(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_5200(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_5201","instance":5201,"id":225216,"goal":"method BinarySearch_5201(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_5202","instance":5202,"id":225217,"goal":"method InsertSort_5202(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_5203","instance":5203,"id":225218,"goal":"method MergeSort_5203(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_5204","instance":5204,"id":225219,"goal":"method ArrayCopy_5204(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_5205","instance":5205,"id":225220,"goal":"function ListReverse_5205(s: seq): seq\n ensures |ListReverse_5205(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_5205(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_5206","instance":5206,"id":225221,"goal":"function Factorial_5206(n: nat): nat\n ensures Factorial_5206(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_5206(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_5207","instance":5207,"id":225222,"goal":"function Fib_5207(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_5207(n-1) + Fib_5207(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_5208","instance":5208,"id":225223,"goal":"function Gcd_5208(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_5208(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_5209","instance":5209,"id":225224,"goal":"function Power_5209(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_5209(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_5210","instance":5210,"id":225225,"goal":"function Sum_5210(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_5210(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_5211","instance":5211,"id":225226,"goal":"method BinarySearch_5211(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_5212","instance":5212,"id":225227,"goal":"method InsertSort_5212(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_5213","instance":5213,"id":225228,"goal":"method MergeSort_5213(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_5214","instance":5214,"id":225229,"goal":"method ArrayCopy_5214(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_5215","instance":5215,"id":225230,"goal":"function ListReverse_5215(s: seq): seq\n ensures |ListReverse_5215(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_5215(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_5216","instance":5216,"id":225231,"goal":"function Factorial_5216(n: nat): nat\n ensures Factorial_5216(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_5216(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_5217","instance":5217,"id":225232,"goal":"function Fib_5217(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_5217(n-1) + Fib_5217(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_5218","instance":5218,"id":225233,"goal":"function Gcd_5218(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_5218(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_5219","instance":5219,"id":225234,"goal":"function Power_5219(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_5219(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_5220","instance":5220,"id":225235,"goal":"function Sum_5220(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_5220(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_5221","instance":5221,"id":225236,"goal":"method BinarySearch_5221(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_5222","instance":5222,"id":225237,"goal":"method InsertSort_5222(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_5223","instance":5223,"id":225238,"goal":"method MergeSort_5223(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_5224","instance":5224,"id":225239,"goal":"method ArrayCopy_5224(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_5225","instance":5225,"id":225240,"goal":"function ListReverse_5225(s: seq): seq\n ensures |ListReverse_5225(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_5225(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_5226","instance":5226,"id":225241,"goal":"function Factorial_5226(n: nat): nat\n ensures Factorial_5226(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_5226(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_5227","instance":5227,"id":225242,"goal":"function Fib_5227(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_5227(n-1) + Fib_5227(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_5228","instance":5228,"id":225243,"goal":"function Gcd_5228(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_5228(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_5229","instance":5229,"id":225244,"goal":"function Power_5229(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_5229(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_5230","instance":5230,"id":225245,"goal":"function Sum_5230(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_5230(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_5231","instance":5231,"id":225246,"goal":"method BinarySearch_5231(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_5232","instance":5232,"id":225247,"goal":"method InsertSort_5232(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_5233","instance":5233,"id":225248,"goal":"method MergeSort_5233(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_5234","instance":5234,"id":225249,"goal":"method ArrayCopy_5234(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_5235","instance":5235,"id":225250,"goal":"function ListReverse_5235(s: seq): seq\n ensures |ListReverse_5235(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_5235(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_5236","instance":5236,"id":225251,"goal":"function Factorial_5236(n: nat): nat\n ensures Factorial_5236(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_5236(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_5237","instance":5237,"id":225252,"goal":"function Fib_5237(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_5237(n-1) + Fib_5237(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_5238","instance":5238,"id":225253,"goal":"function Gcd_5238(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_5238(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_5239","instance":5239,"id":225254,"goal":"function Power_5239(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_5239(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_5240","instance":5240,"id":225255,"goal":"function Sum_5240(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_5240(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_5241","instance":5241,"id":225256,"goal":"method BinarySearch_5241(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_5242","instance":5242,"id":225257,"goal":"method InsertSort_5242(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_5243","instance":5243,"id":225258,"goal":"method MergeSort_5243(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_5244","instance":5244,"id":225259,"goal":"method ArrayCopy_5244(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_5245","instance":5245,"id":225260,"goal":"function ListReverse_5245(s: seq): seq\n ensures |ListReverse_5245(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_5245(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_5246","instance":5246,"id":225261,"goal":"function Factorial_5246(n: nat): nat\n ensures Factorial_5246(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_5246(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_5247","instance":5247,"id":225262,"goal":"function Fib_5247(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_5247(n-1) + Fib_5247(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_5248","instance":5248,"id":225263,"goal":"function Gcd_5248(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_5248(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_5249","instance":5249,"id":225264,"goal":"function Power_5249(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_5249(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_5250","instance":5250,"id":225265,"goal":"function Sum_5250(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_5250(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_5251","instance":5251,"id":225266,"goal":"method BinarySearch_5251(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_5252","instance":5252,"id":225267,"goal":"method InsertSort_5252(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_5253","instance":5253,"id":225268,"goal":"method MergeSort_5253(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_5254","instance":5254,"id":225269,"goal":"method ArrayCopy_5254(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_5255","instance":5255,"id":225270,"goal":"function ListReverse_5255(s: seq): seq\n ensures |ListReverse_5255(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_5255(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_5256","instance":5256,"id":225271,"goal":"function Factorial_5256(n: nat): nat\n ensures Factorial_5256(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_5256(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_5257","instance":5257,"id":225272,"goal":"function Fib_5257(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_5257(n-1) + Fib_5257(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_5258","instance":5258,"id":225273,"goal":"function Gcd_5258(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_5258(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_5259","instance":5259,"id":225274,"goal":"function Power_5259(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_5259(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_5260","instance":5260,"id":225275,"goal":"function Sum_5260(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_5260(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_5261","instance":5261,"id":225276,"goal":"method BinarySearch_5261(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_5262","instance":5262,"id":225277,"goal":"method InsertSort_5262(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_5263","instance":5263,"id":225278,"goal":"method MergeSort_5263(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_5264","instance":5264,"id":225279,"goal":"method ArrayCopy_5264(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_5265","instance":5265,"id":225280,"goal":"function ListReverse_5265(s: seq): seq\n ensures |ListReverse_5265(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_5265(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_5266","instance":5266,"id":225281,"goal":"function Factorial_5266(n: nat): nat\n ensures Factorial_5266(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_5266(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_5267","instance":5267,"id":225282,"goal":"function Fib_5267(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_5267(n-1) + Fib_5267(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_5268","instance":5268,"id":225283,"goal":"function Gcd_5268(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_5268(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_5269","instance":5269,"id":225284,"goal":"function Power_5269(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_5269(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_5270","instance":5270,"id":225285,"goal":"function Sum_5270(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_5270(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_5271","instance":5271,"id":225286,"goal":"method BinarySearch_5271(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_5272","instance":5272,"id":225287,"goal":"method InsertSort_5272(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_5273","instance":5273,"id":225288,"goal":"method MergeSort_5273(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_5274","instance":5274,"id":225289,"goal":"method ArrayCopy_5274(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_5275","instance":5275,"id":225290,"goal":"function ListReverse_5275(s: seq): seq\n ensures |ListReverse_5275(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_5275(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_5276","instance":5276,"id":225291,"goal":"function Factorial_5276(n: nat): nat\n ensures Factorial_5276(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_5276(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_5277","instance":5277,"id":225292,"goal":"function Fib_5277(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_5277(n-1) + Fib_5277(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_5278","instance":5278,"id":225293,"goal":"function Gcd_5278(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_5278(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_5279","instance":5279,"id":225294,"goal":"function Power_5279(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_5279(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_5280","instance":5280,"id":225295,"goal":"function Sum_5280(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_5280(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_5281","instance":5281,"id":225296,"goal":"method BinarySearch_5281(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_5282","instance":5282,"id":225297,"goal":"method InsertSort_5282(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_5283","instance":5283,"id":225298,"goal":"method MergeSort_5283(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_5284","instance":5284,"id":225299,"goal":"method ArrayCopy_5284(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_5285","instance":5285,"id":225300,"goal":"function ListReverse_5285(s: seq): seq\n ensures |ListReverse_5285(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_5285(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_5286","instance":5286,"id":225301,"goal":"function Factorial_5286(n: nat): nat\n ensures Factorial_5286(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_5286(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_5287","instance":5287,"id":225302,"goal":"function Fib_5287(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_5287(n-1) + Fib_5287(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_5288","instance":5288,"id":225303,"goal":"function Gcd_5288(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_5288(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_5289","instance":5289,"id":225304,"goal":"function Power_5289(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_5289(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_5290","instance":5290,"id":225305,"goal":"function Sum_5290(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_5290(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_5291","instance":5291,"id":225306,"goal":"method BinarySearch_5291(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_5292","instance":5292,"id":225307,"goal":"method InsertSort_5292(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_5293","instance":5293,"id":225308,"goal":"method MergeSort_5293(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_5294","instance":5294,"id":225309,"goal":"method ArrayCopy_5294(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_5295","instance":5295,"id":225310,"goal":"function ListReverse_5295(s: seq): seq\n ensures |ListReverse_5295(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_5295(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_5296","instance":5296,"id":225311,"goal":"function Factorial_5296(n: nat): nat\n ensures Factorial_5296(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_5296(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_5297","instance":5297,"id":225312,"goal":"function Fib_5297(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_5297(n-1) + Fib_5297(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_5298","instance":5298,"id":225313,"goal":"function Gcd_5298(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_5298(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_5299","instance":5299,"id":225314,"goal":"function Power_5299(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_5299(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_5300","instance":5300,"id":225315,"goal":"function Sum_5300(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_5300(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_5301","instance":5301,"id":225316,"goal":"method BinarySearch_5301(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_5302","instance":5302,"id":225317,"goal":"method InsertSort_5302(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_5303","instance":5303,"id":225318,"goal":"method MergeSort_5303(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_5304","instance":5304,"id":225319,"goal":"method ArrayCopy_5304(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_5305","instance":5305,"id":225320,"goal":"function ListReverse_5305(s: seq): seq\n ensures |ListReverse_5305(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_5305(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_5306","instance":5306,"id":225321,"goal":"function Factorial_5306(n: nat): nat\n ensures Factorial_5306(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_5306(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_5307","instance":5307,"id":225322,"goal":"function Fib_5307(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_5307(n-1) + Fib_5307(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_5308","instance":5308,"id":225323,"goal":"function Gcd_5308(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_5308(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_5309","instance":5309,"id":225324,"goal":"function Power_5309(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_5309(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_5310","instance":5310,"id":225325,"goal":"function Sum_5310(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_5310(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_5311","instance":5311,"id":225326,"goal":"method BinarySearch_5311(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_5312","instance":5312,"id":225327,"goal":"method InsertSort_5312(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_5313","instance":5313,"id":225328,"goal":"method MergeSort_5313(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_5314","instance":5314,"id":225329,"goal":"method ArrayCopy_5314(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_5315","instance":5315,"id":225330,"goal":"function ListReverse_5315(s: seq): seq\n ensures |ListReverse_5315(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_5315(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_5316","instance":5316,"id":225331,"goal":"function Factorial_5316(n: nat): nat\n ensures Factorial_5316(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_5316(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_5317","instance":5317,"id":225332,"goal":"function Fib_5317(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_5317(n-1) + Fib_5317(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_5318","instance":5318,"id":225333,"goal":"function Gcd_5318(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_5318(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_5319","instance":5319,"id":225334,"goal":"function Power_5319(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_5319(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_5320","instance":5320,"id":225335,"goal":"function Sum_5320(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_5320(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_5321","instance":5321,"id":225336,"goal":"method BinarySearch_5321(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_5322","instance":5322,"id":225337,"goal":"method InsertSort_5322(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_5323","instance":5323,"id":225338,"goal":"method MergeSort_5323(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_5324","instance":5324,"id":225339,"goal":"method ArrayCopy_5324(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_5325","instance":5325,"id":225340,"goal":"function ListReverse_5325(s: seq): seq\n ensures |ListReverse_5325(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_5325(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_5326","instance":5326,"id":225341,"goal":"function Factorial_5326(n: nat): nat\n ensures Factorial_5326(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_5326(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_5327","instance":5327,"id":225342,"goal":"function Fib_5327(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_5327(n-1) + Fib_5327(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_5328","instance":5328,"id":225343,"goal":"function Gcd_5328(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_5328(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_5329","instance":5329,"id":225344,"goal":"function Power_5329(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_5329(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_5330","instance":5330,"id":225345,"goal":"function Sum_5330(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_5330(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_5331","instance":5331,"id":225346,"goal":"method BinarySearch_5331(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_5332","instance":5332,"id":225347,"goal":"method InsertSort_5332(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_5333","instance":5333,"id":225348,"goal":"method MergeSort_5333(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_5334","instance":5334,"id":225349,"goal":"method ArrayCopy_5334(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_5335","instance":5335,"id":225350,"goal":"function ListReverse_5335(s: seq): seq\n ensures |ListReverse_5335(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_5335(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_5336","instance":5336,"id":225351,"goal":"function Factorial_5336(n: nat): nat\n ensures Factorial_5336(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_5336(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_5337","instance":5337,"id":225352,"goal":"function Fib_5337(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_5337(n-1) + Fib_5337(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_5338","instance":5338,"id":225353,"goal":"function Gcd_5338(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_5338(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_5339","instance":5339,"id":225354,"goal":"function Power_5339(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_5339(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_5340","instance":5340,"id":225355,"goal":"function Sum_5340(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_5340(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_5341","instance":5341,"id":225356,"goal":"method BinarySearch_5341(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_5342","instance":5342,"id":225357,"goal":"method InsertSort_5342(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_5343","instance":5343,"id":225358,"goal":"method MergeSort_5343(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_5344","instance":5344,"id":225359,"goal":"method ArrayCopy_5344(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_5345","instance":5345,"id":225360,"goal":"function ListReverse_5345(s: seq): seq\n ensures |ListReverse_5345(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_5345(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_5346","instance":5346,"id":225361,"goal":"function Factorial_5346(n: nat): nat\n ensures Factorial_5346(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_5346(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_5347","instance":5347,"id":225362,"goal":"function Fib_5347(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_5347(n-1) + Fib_5347(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_5348","instance":5348,"id":225363,"goal":"function Gcd_5348(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_5348(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_5349","instance":5349,"id":225364,"goal":"function Power_5349(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_5349(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_5350","instance":5350,"id":225365,"goal":"function Sum_5350(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_5350(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_5351","instance":5351,"id":225366,"goal":"method BinarySearch_5351(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_5352","instance":5352,"id":225367,"goal":"method InsertSort_5352(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_5353","instance":5353,"id":225368,"goal":"method MergeSort_5353(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_5354","instance":5354,"id":225369,"goal":"method ArrayCopy_5354(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_5355","instance":5355,"id":225370,"goal":"function ListReverse_5355(s: seq): seq\n ensures |ListReverse_5355(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_5355(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_5356","instance":5356,"id":225371,"goal":"function Factorial_5356(n: nat): nat\n ensures Factorial_5356(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_5356(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_5357","instance":5357,"id":225372,"goal":"function Fib_5357(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_5357(n-1) + Fib_5357(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_5358","instance":5358,"id":225373,"goal":"function Gcd_5358(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_5358(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_5359","instance":5359,"id":225374,"goal":"function Power_5359(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_5359(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_5360","instance":5360,"id":225375,"goal":"function Sum_5360(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_5360(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_5361","instance":5361,"id":225376,"goal":"method BinarySearch_5361(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_5362","instance":5362,"id":225377,"goal":"method InsertSort_5362(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_5363","instance":5363,"id":225378,"goal":"method MergeSort_5363(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_5364","instance":5364,"id":225379,"goal":"method ArrayCopy_5364(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_5365","instance":5365,"id":225380,"goal":"function ListReverse_5365(s: seq): seq\n ensures |ListReverse_5365(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_5365(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_5366","instance":5366,"id":225381,"goal":"function Factorial_5366(n: nat): nat\n ensures Factorial_5366(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_5366(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_5367","instance":5367,"id":225382,"goal":"function Fib_5367(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_5367(n-1) + Fib_5367(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_5368","instance":5368,"id":225383,"goal":"function Gcd_5368(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_5368(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_5369","instance":5369,"id":225384,"goal":"function Power_5369(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_5369(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_5370","instance":5370,"id":225385,"goal":"function Sum_5370(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_5370(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_5371","instance":5371,"id":225386,"goal":"method BinarySearch_5371(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_5372","instance":5372,"id":225387,"goal":"method InsertSort_5372(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_5373","instance":5373,"id":225388,"goal":"method MergeSort_5373(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_5374","instance":5374,"id":225389,"goal":"method ArrayCopy_5374(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_5375","instance":5375,"id":225390,"goal":"function ListReverse_5375(s: seq): seq\n ensures |ListReverse_5375(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_5375(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_5376","instance":5376,"id":225391,"goal":"function Factorial_5376(n: nat): nat\n ensures Factorial_5376(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_5376(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_5377","instance":5377,"id":225392,"goal":"function Fib_5377(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_5377(n-1) + Fib_5377(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_5378","instance":5378,"id":225393,"goal":"function Gcd_5378(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_5378(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_5379","instance":5379,"id":225394,"goal":"function Power_5379(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_5379(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_5380","instance":5380,"id":225395,"goal":"function Sum_5380(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_5380(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_5381","instance":5381,"id":225396,"goal":"method BinarySearch_5381(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_5382","instance":5382,"id":225397,"goal":"method InsertSort_5382(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_5383","instance":5383,"id":225398,"goal":"method MergeSort_5383(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_5384","instance":5384,"id":225399,"goal":"method ArrayCopy_5384(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_5385","instance":5385,"id":225400,"goal":"function ListReverse_5385(s: seq): seq\n ensures |ListReverse_5385(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_5385(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_5386","instance":5386,"id":225401,"goal":"function Factorial_5386(n: nat): nat\n ensures Factorial_5386(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_5386(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_5387","instance":5387,"id":225402,"goal":"function Fib_5387(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_5387(n-1) + Fib_5387(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_5388","instance":5388,"id":225403,"goal":"function Gcd_5388(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_5388(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_5389","instance":5389,"id":225404,"goal":"function Power_5389(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_5389(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_5390","instance":5390,"id":225405,"goal":"function Sum_5390(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_5390(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_5391","instance":5391,"id":225406,"goal":"method BinarySearch_5391(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_5392","instance":5392,"id":225407,"goal":"method InsertSort_5392(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_5393","instance":5393,"id":225408,"goal":"method MergeSort_5393(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_5394","instance":5394,"id":225409,"goal":"method ArrayCopy_5394(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_5395","instance":5395,"id":225410,"goal":"function ListReverse_5395(s: seq): seq\n ensures |ListReverse_5395(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_5395(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_5396","instance":5396,"id":225411,"goal":"function Factorial_5396(n: nat): nat\n ensures Factorial_5396(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_5396(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_5397","instance":5397,"id":225412,"goal":"function Fib_5397(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_5397(n-1) + Fib_5397(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_5398","instance":5398,"id":225413,"goal":"function Gcd_5398(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_5398(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_5399","instance":5399,"id":225414,"goal":"function Power_5399(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_5399(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_5400","instance":5400,"id":225415,"goal":"function Sum_5400(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_5400(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_5401","instance":5401,"id":225416,"goal":"method BinarySearch_5401(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_5402","instance":5402,"id":225417,"goal":"method InsertSort_5402(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_5403","instance":5403,"id":225418,"goal":"method MergeSort_5403(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_5404","instance":5404,"id":225419,"goal":"method ArrayCopy_5404(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_5405","instance":5405,"id":225420,"goal":"function ListReverse_5405(s: seq): seq\n ensures |ListReverse_5405(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_5405(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_5406","instance":5406,"id":225421,"goal":"function Factorial_5406(n: nat): nat\n ensures Factorial_5406(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_5406(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_5407","instance":5407,"id":225422,"goal":"function Fib_5407(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_5407(n-1) + Fib_5407(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_5408","instance":5408,"id":225423,"goal":"function Gcd_5408(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_5408(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_5409","instance":5409,"id":225424,"goal":"function Power_5409(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_5409(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_5410","instance":5410,"id":225425,"goal":"function Sum_5410(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_5410(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_5411","instance":5411,"id":225426,"goal":"method BinarySearch_5411(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_5412","instance":5412,"id":225427,"goal":"method InsertSort_5412(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_5413","instance":5413,"id":225428,"goal":"method MergeSort_5413(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_5414","instance":5414,"id":225429,"goal":"method ArrayCopy_5414(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_5415","instance":5415,"id":225430,"goal":"function ListReverse_5415(s: seq): seq\n ensures |ListReverse_5415(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_5415(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_5416","instance":5416,"id":225431,"goal":"function Factorial_5416(n: nat): nat\n ensures Factorial_5416(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_5416(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_5417","instance":5417,"id":225432,"goal":"function Fib_5417(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_5417(n-1) + Fib_5417(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_5418","instance":5418,"id":225433,"goal":"function Gcd_5418(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_5418(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_5419","instance":5419,"id":225434,"goal":"function Power_5419(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_5419(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_5420","instance":5420,"id":225435,"goal":"function Sum_5420(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_5420(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_5421","instance":5421,"id":225436,"goal":"method BinarySearch_5421(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_5422","instance":5422,"id":225437,"goal":"method InsertSort_5422(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_5423","instance":5423,"id":225438,"goal":"method MergeSort_5423(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_5424","instance":5424,"id":225439,"goal":"method ArrayCopy_5424(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_5425","instance":5425,"id":225440,"goal":"function ListReverse_5425(s: seq): seq\n ensures |ListReverse_5425(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_5425(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_5426","instance":5426,"id":225441,"goal":"function Factorial_5426(n: nat): nat\n ensures Factorial_5426(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_5426(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_5427","instance":5427,"id":225442,"goal":"function Fib_5427(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_5427(n-1) + Fib_5427(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_5428","instance":5428,"id":225443,"goal":"function Gcd_5428(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_5428(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_5429","instance":5429,"id":225444,"goal":"function Power_5429(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_5429(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_5430","instance":5430,"id":225445,"goal":"function Sum_5430(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_5430(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_5431","instance":5431,"id":225446,"goal":"method BinarySearch_5431(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_5432","instance":5432,"id":225447,"goal":"method InsertSort_5432(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_5433","instance":5433,"id":225448,"goal":"method MergeSort_5433(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_5434","instance":5434,"id":225449,"goal":"method ArrayCopy_5434(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_5435","instance":5435,"id":225450,"goal":"function ListReverse_5435(s: seq): seq\n ensures |ListReverse_5435(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_5435(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_5436","instance":5436,"id":225451,"goal":"function Factorial_5436(n: nat): nat\n ensures Factorial_5436(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_5436(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_5437","instance":5437,"id":225452,"goal":"function Fib_5437(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_5437(n-1) + Fib_5437(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_5438","instance":5438,"id":225453,"goal":"function Gcd_5438(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_5438(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_5439","instance":5439,"id":225454,"goal":"function Power_5439(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_5439(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_5440","instance":5440,"id":225455,"goal":"function Sum_5440(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_5440(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_5441","instance":5441,"id":225456,"goal":"method BinarySearch_5441(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_5442","instance":5442,"id":225457,"goal":"method InsertSort_5442(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_5443","instance":5443,"id":225458,"goal":"method MergeSort_5443(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_5444","instance":5444,"id":225459,"goal":"method ArrayCopy_5444(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_5445","instance":5445,"id":225460,"goal":"function ListReverse_5445(s: seq): seq\n ensures |ListReverse_5445(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_5445(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_5446","instance":5446,"id":225461,"goal":"function Factorial_5446(n: nat): nat\n ensures Factorial_5446(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_5446(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_5447","instance":5447,"id":225462,"goal":"function Fib_5447(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_5447(n-1) + Fib_5447(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_5448","instance":5448,"id":225463,"goal":"function Gcd_5448(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_5448(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_5449","instance":5449,"id":225464,"goal":"function Power_5449(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_5449(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_5450","instance":5450,"id":225465,"goal":"function Sum_5450(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_5450(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_5451","instance":5451,"id":225466,"goal":"method BinarySearch_5451(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_5452","instance":5452,"id":225467,"goal":"method InsertSort_5452(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_5453","instance":5453,"id":225468,"goal":"method MergeSort_5453(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_5454","instance":5454,"id":225469,"goal":"method ArrayCopy_5454(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_5455","instance":5455,"id":225470,"goal":"function ListReverse_5455(s: seq): seq\n ensures |ListReverse_5455(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_5455(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_5456","instance":5456,"id":225471,"goal":"function Factorial_5456(n: nat): nat\n ensures Factorial_5456(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_5456(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_5457","instance":5457,"id":225472,"goal":"function Fib_5457(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_5457(n-1) + Fib_5457(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_5458","instance":5458,"id":225473,"goal":"function Gcd_5458(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_5458(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_5459","instance":5459,"id":225474,"goal":"function Power_5459(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_5459(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_5460","instance":5460,"id":225475,"goal":"function Sum_5460(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_5460(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_5461","instance":5461,"id":225476,"goal":"method BinarySearch_5461(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_5462","instance":5462,"id":225477,"goal":"method InsertSort_5462(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_5463","instance":5463,"id":225478,"goal":"method MergeSort_5463(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_5464","instance":5464,"id":225479,"goal":"method ArrayCopy_5464(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_5465","instance":5465,"id":225480,"goal":"function ListReverse_5465(s: seq): seq\n ensures |ListReverse_5465(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_5465(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_5466","instance":5466,"id":225481,"goal":"function Factorial_5466(n: nat): nat\n ensures Factorial_5466(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_5466(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_5467","instance":5467,"id":225482,"goal":"function Fib_5467(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_5467(n-1) + Fib_5467(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_5468","instance":5468,"id":225483,"goal":"function Gcd_5468(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_5468(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_5469","instance":5469,"id":225484,"goal":"function Power_5469(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_5469(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_5470","instance":5470,"id":225485,"goal":"function Sum_5470(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_5470(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_5471","instance":5471,"id":225486,"goal":"method BinarySearch_5471(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_5472","instance":5472,"id":225487,"goal":"method InsertSort_5472(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_5473","instance":5473,"id":225488,"goal":"method MergeSort_5473(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_5474","instance":5474,"id":225489,"goal":"method ArrayCopy_5474(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_5475","instance":5475,"id":225490,"goal":"function ListReverse_5475(s: seq): seq\n ensures |ListReverse_5475(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_5475(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_5476","instance":5476,"id":225491,"goal":"function Factorial_5476(n: nat): nat\n ensures Factorial_5476(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_5476(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_5477","instance":5477,"id":225492,"goal":"function Fib_5477(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_5477(n-1) + Fib_5477(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_5478","instance":5478,"id":225493,"goal":"function Gcd_5478(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_5478(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_5479","instance":5479,"id":225494,"goal":"function Power_5479(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_5479(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_5480","instance":5480,"id":225495,"goal":"function Sum_5480(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_5480(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_5481","instance":5481,"id":225496,"goal":"method BinarySearch_5481(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_5482","instance":5482,"id":225497,"goal":"method InsertSort_5482(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_5483","instance":5483,"id":225498,"goal":"method MergeSort_5483(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_5484","instance":5484,"id":225499,"goal":"method ArrayCopy_5484(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_5485","instance":5485,"id":225500,"goal":"function ListReverse_5485(s: seq): seq\n ensures |ListReverse_5485(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_5485(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_5486","instance":5486,"id":225501,"goal":"function Factorial_5486(n: nat): nat\n ensures Factorial_5486(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_5486(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_5487","instance":5487,"id":225502,"goal":"function Fib_5487(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_5487(n-1) + Fib_5487(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_5488","instance":5488,"id":225503,"goal":"function Gcd_5488(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_5488(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_5489","instance":5489,"id":225504,"goal":"function Power_5489(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_5489(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_5490","instance":5490,"id":225505,"goal":"function Sum_5490(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_5490(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_5491","instance":5491,"id":225506,"goal":"method BinarySearch_5491(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_5492","instance":5492,"id":225507,"goal":"method InsertSort_5492(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_5493","instance":5493,"id":225508,"goal":"method MergeSort_5493(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_5494","instance":5494,"id":225509,"goal":"method ArrayCopy_5494(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_5495","instance":5495,"id":225510,"goal":"function ListReverse_5495(s: seq): seq\n ensures |ListReverse_5495(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_5495(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_5496","instance":5496,"id":225511,"goal":"function Factorial_5496(n: nat): nat\n ensures Factorial_5496(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_5496(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_5497","instance":5497,"id":225512,"goal":"function Fib_5497(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_5497(n-1) + Fib_5497(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_5498","instance":5498,"id":225513,"goal":"function Gcd_5498(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_5498(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_5499","instance":5499,"id":225514,"goal":"function Power_5499(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_5499(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_5500","instance":5500,"id":225515,"goal":"function Sum_5500(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_5500(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_5501","instance":5501,"id":225516,"goal":"method BinarySearch_5501(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_5502","instance":5502,"id":225517,"goal":"method InsertSort_5502(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_5503","instance":5503,"id":225518,"goal":"method MergeSort_5503(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_5504","instance":5504,"id":225519,"goal":"method ArrayCopy_5504(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_5505","instance":5505,"id":225520,"goal":"function ListReverse_5505(s: seq): seq\n ensures |ListReverse_5505(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_5505(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_5506","instance":5506,"id":225521,"goal":"function Factorial_5506(n: nat): nat\n ensures Factorial_5506(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_5506(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_5507","instance":5507,"id":225522,"goal":"function Fib_5507(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_5507(n-1) + Fib_5507(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_5508","instance":5508,"id":225523,"goal":"function Gcd_5508(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_5508(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_5509","instance":5509,"id":225524,"goal":"function Power_5509(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_5509(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_5510","instance":5510,"id":225525,"goal":"function Sum_5510(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_5510(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_5511","instance":5511,"id":225526,"goal":"method BinarySearch_5511(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_5512","instance":5512,"id":225527,"goal":"method InsertSort_5512(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_5513","instance":5513,"id":225528,"goal":"method MergeSort_5513(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_5514","instance":5514,"id":225529,"goal":"method ArrayCopy_5514(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_5515","instance":5515,"id":225530,"goal":"function ListReverse_5515(s: seq): seq\n ensures |ListReverse_5515(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_5515(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_5516","instance":5516,"id":225531,"goal":"function Factorial_5516(n: nat): nat\n ensures Factorial_5516(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_5516(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_5517","instance":5517,"id":225532,"goal":"function Fib_5517(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_5517(n-1) + Fib_5517(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_5518","instance":5518,"id":225533,"goal":"function Gcd_5518(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_5518(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_5519","instance":5519,"id":225534,"goal":"function Power_5519(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_5519(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_5520","instance":5520,"id":225535,"goal":"function Sum_5520(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_5520(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_5521","instance":5521,"id":225536,"goal":"method BinarySearch_5521(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_5522","instance":5522,"id":225537,"goal":"method InsertSort_5522(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_5523","instance":5523,"id":225538,"goal":"method MergeSort_5523(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_5524","instance":5524,"id":225539,"goal":"method ArrayCopy_5524(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_5525","instance":5525,"id":225540,"goal":"function ListReverse_5525(s: seq): seq\n ensures |ListReverse_5525(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_5525(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_5526","instance":5526,"id":225541,"goal":"function Factorial_5526(n: nat): nat\n ensures Factorial_5526(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_5526(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_5527","instance":5527,"id":225542,"goal":"function Fib_5527(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_5527(n-1) + Fib_5527(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_5528","instance":5528,"id":225543,"goal":"function Gcd_5528(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_5528(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_5529","instance":5529,"id":225544,"goal":"function Power_5529(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_5529(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_5530","instance":5530,"id":225545,"goal":"function Sum_5530(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_5530(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_5531","instance":5531,"id":225546,"goal":"method BinarySearch_5531(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_5532","instance":5532,"id":225547,"goal":"method InsertSort_5532(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_5533","instance":5533,"id":225548,"goal":"method MergeSort_5533(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_5534","instance":5534,"id":225549,"goal":"method ArrayCopy_5534(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_5535","instance":5535,"id":225550,"goal":"function ListReverse_5535(s: seq): seq\n ensures |ListReverse_5535(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_5535(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_5536","instance":5536,"id":225551,"goal":"function Factorial_5536(n: nat): nat\n ensures Factorial_5536(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_5536(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_5537","instance":5537,"id":225552,"goal":"function Fib_5537(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_5537(n-1) + Fib_5537(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_5538","instance":5538,"id":225553,"goal":"function Gcd_5538(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_5538(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_5539","instance":5539,"id":225554,"goal":"function Power_5539(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_5539(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_5540","instance":5540,"id":225555,"goal":"function Sum_5540(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_5540(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_5541","instance":5541,"id":225556,"goal":"method BinarySearch_5541(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_5542","instance":5542,"id":225557,"goal":"method InsertSort_5542(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_5543","instance":5543,"id":225558,"goal":"method MergeSort_5543(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_5544","instance":5544,"id":225559,"goal":"method ArrayCopy_5544(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_5545","instance":5545,"id":225560,"goal":"function ListReverse_5545(s: seq): seq\n ensures |ListReverse_5545(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_5545(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_5546","instance":5546,"id":225561,"goal":"function Factorial_5546(n: nat): nat\n ensures Factorial_5546(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_5546(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_5547","instance":5547,"id":225562,"goal":"function Fib_5547(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_5547(n-1) + Fib_5547(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_5548","instance":5548,"id":225563,"goal":"function Gcd_5548(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_5548(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_5549","instance":5549,"id":225564,"goal":"function Power_5549(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_5549(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_5550","instance":5550,"id":225565,"goal":"function Sum_5550(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_5550(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_5551","instance":5551,"id":225566,"goal":"method BinarySearch_5551(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_5552","instance":5552,"id":225567,"goal":"method InsertSort_5552(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_5553","instance":5553,"id":225568,"goal":"method MergeSort_5553(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_5554","instance":5554,"id":225569,"goal":"method ArrayCopy_5554(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_5555","instance":5555,"id":225570,"goal":"function ListReverse_5555(s: seq): seq\n ensures |ListReverse_5555(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_5555(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_5556","instance":5556,"id":225571,"goal":"function Factorial_5556(n: nat): nat\n ensures Factorial_5556(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_5556(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_5557","instance":5557,"id":225572,"goal":"function Fib_5557(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_5557(n-1) + Fib_5557(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_5558","instance":5558,"id":225573,"goal":"function Gcd_5558(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_5558(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_5559","instance":5559,"id":225574,"goal":"function Power_5559(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_5559(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_5560","instance":5560,"id":225575,"goal":"function Sum_5560(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_5560(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_5561","instance":5561,"id":225576,"goal":"method BinarySearch_5561(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_5562","instance":5562,"id":225577,"goal":"method InsertSort_5562(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_5563","instance":5563,"id":225578,"goal":"method MergeSort_5563(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_5564","instance":5564,"id":225579,"goal":"method ArrayCopy_5564(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_5565","instance":5565,"id":225580,"goal":"function ListReverse_5565(s: seq): seq\n ensures |ListReverse_5565(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_5565(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_5566","instance":5566,"id":225581,"goal":"function Factorial_5566(n: nat): nat\n ensures Factorial_5566(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_5566(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_5567","instance":5567,"id":225582,"goal":"function Fib_5567(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_5567(n-1) + Fib_5567(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_5568","instance":5568,"id":225583,"goal":"function Gcd_5568(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_5568(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_5569","instance":5569,"id":225584,"goal":"function Power_5569(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_5569(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_5570","instance":5570,"id":225585,"goal":"function Sum_5570(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_5570(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_5571","instance":5571,"id":225586,"goal":"method BinarySearch_5571(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_5572","instance":5572,"id":225587,"goal":"method InsertSort_5572(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_5573","instance":5573,"id":225588,"goal":"method MergeSort_5573(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_5574","instance":5574,"id":225589,"goal":"method ArrayCopy_5574(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_5575","instance":5575,"id":225590,"goal":"function ListReverse_5575(s: seq): seq\n ensures |ListReverse_5575(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_5575(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_5576","instance":5576,"id":225591,"goal":"function Factorial_5576(n: nat): nat\n ensures Factorial_5576(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_5576(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_5577","instance":5577,"id":225592,"goal":"function Fib_5577(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_5577(n-1) + Fib_5577(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_5578","instance":5578,"id":225593,"goal":"function Gcd_5578(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_5578(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_5579","instance":5579,"id":225594,"goal":"function Power_5579(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_5579(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_5580","instance":5580,"id":225595,"goal":"function Sum_5580(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_5580(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_5581","instance":5581,"id":225596,"goal":"method BinarySearch_5581(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_5582","instance":5582,"id":225597,"goal":"method InsertSort_5582(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_5583","instance":5583,"id":225598,"goal":"method MergeSort_5583(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_5584","instance":5584,"id":225599,"goal":"method ArrayCopy_5584(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_5585","instance":5585,"id":225600,"goal":"function ListReverse_5585(s: seq): seq\n ensures |ListReverse_5585(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_5585(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_5586","instance":5586,"id":225601,"goal":"function Factorial_5586(n: nat): nat\n ensures Factorial_5586(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_5586(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_5587","instance":5587,"id":225602,"goal":"function Fib_5587(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_5587(n-1) + Fib_5587(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_5588","instance":5588,"id":225603,"goal":"function Gcd_5588(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_5588(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_5589","instance":5589,"id":225604,"goal":"function Power_5589(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_5589(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_5590","instance":5590,"id":225605,"goal":"function Sum_5590(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_5590(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_5591","instance":5591,"id":225606,"goal":"method BinarySearch_5591(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_5592","instance":5592,"id":225607,"goal":"method InsertSort_5592(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_5593","instance":5593,"id":225608,"goal":"method MergeSort_5593(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_5594","instance":5594,"id":225609,"goal":"method ArrayCopy_5594(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_5595","instance":5595,"id":225610,"goal":"function ListReverse_5595(s: seq): seq\n ensures |ListReverse_5595(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_5595(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_5596","instance":5596,"id":225611,"goal":"function Factorial_5596(n: nat): nat\n ensures Factorial_5596(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_5596(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_5597","instance":5597,"id":225612,"goal":"function Fib_5597(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_5597(n-1) + Fib_5597(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_5598","instance":5598,"id":225613,"goal":"function Gcd_5598(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_5598(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_5599","instance":5599,"id":225614,"goal":"function Power_5599(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_5599(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_5600","instance":5600,"id":225615,"goal":"function Sum_5600(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_5600(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_5601","instance":5601,"id":225616,"goal":"method BinarySearch_5601(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_5602","instance":5602,"id":225617,"goal":"method InsertSort_5602(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_5603","instance":5603,"id":225618,"goal":"method MergeSort_5603(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_5604","instance":5604,"id":225619,"goal":"method ArrayCopy_5604(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_5605","instance":5605,"id":225620,"goal":"function ListReverse_5605(s: seq): seq\n ensures |ListReverse_5605(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_5605(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_5606","instance":5606,"id":225621,"goal":"function Factorial_5606(n: nat): nat\n ensures Factorial_5606(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_5606(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_5607","instance":5607,"id":225622,"goal":"function Fib_5607(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_5607(n-1) + Fib_5607(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_5608","instance":5608,"id":225623,"goal":"function Gcd_5608(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_5608(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_5609","instance":5609,"id":225624,"goal":"function Power_5609(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_5609(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_5610","instance":5610,"id":225625,"goal":"function Sum_5610(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_5610(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_5611","instance":5611,"id":225626,"goal":"method BinarySearch_5611(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_5612","instance":5612,"id":225627,"goal":"method InsertSort_5612(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_5613","instance":5613,"id":225628,"goal":"method MergeSort_5613(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_5614","instance":5614,"id":225629,"goal":"method ArrayCopy_5614(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_5615","instance":5615,"id":225630,"goal":"function ListReverse_5615(s: seq): seq\n ensures |ListReverse_5615(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_5615(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_5616","instance":5616,"id":225631,"goal":"function Factorial_5616(n: nat): nat\n ensures Factorial_5616(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_5616(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_5617","instance":5617,"id":225632,"goal":"function Fib_5617(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_5617(n-1) + Fib_5617(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_5618","instance":5618,"id":225633,"goal":"function Gcd_5618(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_5618(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_5619","instance":5619,"id":225634,"goal":"function Power_5619(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_5619(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_5620","instance":5620,"id":225635,"goal":"function Sum_5620(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_5620(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_5621","instance":5621,"id":225636,"goal":"method BinarySearch_5621(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_5622","instance":5622,"id":225637,"goal":"method InsertSort_5622(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_5623","instance":5623,"id":225638,"goal":"method MergeSort_5623(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_5624","instance":5624,"id":225639,"goal":"method ArrayCopy_5624(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_5625","instance":5625,"id":225640,"goal":"function ListReverse_5625(s: seq): seq\n ensures |ListReverse_5625(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_5625(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_5626","instance":5626,"id":225641,"goal":"function Factorial_5626(n: nat): nat\n ensures Factorial_5626(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_5626(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_5627","instance":5627,"id":225642,"goal":"function Fib_5627(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_5627(n-1) + Fib_5627(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_5628","instance":5628,"id":225643,"goal":"function Gcd_5628(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_5628(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_5629","instance":5629,"id":225644,"goal":"function Power_5629(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_5629(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_5630","instance":5630,"id":225645,"goal":"function Sum_5630(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_5630(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_5631","instance":5631,"id":225646,"goal":"method BinarySearch_5631(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_5632","instance":5632,"id":225647,"goal":"method InsertSort_5632(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_5633","instance":5633,"id":225648,"goal":"method MergeSort_5633(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_5634","instance":5634,"id":225649,"goal":"method ArrayCopy_5634(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_5635","instance":5635,"id":225650,"goal":"function ListReverse_5635(s: seq): seq\n ensures |ListReverse_5635(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_5635(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_5636","instance":5636,"id":225651,"goal":"function Factorial_5636(n: nat): nat\n ensures Factorial_5636(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_5636(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_5637","instance":5637,"id":225652,"goal":"function Fib_5637(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_5637(n-1) + Fib_5637(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_5638","instance":5638,"id":225653,"goal":"function Gcd_5638(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_5638(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_5639","instance":5639,"id":225654,"goal":"function Power_5639(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_5639(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_5640","instance":5640,"id":225655,"goal":"function Sum_5640(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_5640(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_5641","instance":5641,"id":225656,"goal":"method BinarySearch_5641(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_5642","instance":5642,"id":225657,"goal":"method InsertSort_5642(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_5643","instance":5643,"id":225658,"goal":"method MergeSort_5643(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_5644","instance":5644,"id":225659,"goal":"method ArrayCopy_5644(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_5645","instance":5645,"id":225660,"goal":"function ListReverse_5645(s: seq): seq\n ensures |ListReverse_5645(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_5645(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_5646","instance":5646,"id":225661,"goal":"function Factorial_5646(n: nat): nat\n ensures Factorial_5646(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_5646(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_5647","instance":5647,"id":225662,"goal":"function Fib_5647(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_5647(n-1) + Fib_5647(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_5648","instance":5648,"id":225663,"goal":"function Gcd_5648(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_5648(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_5649","instance":5649,"id":225664,"goal":"function Power_5649(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_5649(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_5650","instance":5650,"id":225665,"goal":"function Sum_5650(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_5650(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_5651","instance":5651,"id":225666,"goal":"method BinarySearch_5651(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_5652","instance":5652,"id":225667,"goal":"method InsertSort_5652(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_5653","instance":5653,"id":225668,"goal":"method MergeSort_5653(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_5654","instance":5654,"id":225669,"goal":"method ArrayCopy_5654(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_5655","instance":5655,"id":225670,"goal":"function ListReverse_5655(s: seq): seq\n ensures |ListReverse_5655(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_5655(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_5656","instance":5656,"id":225671,"goal":"function Factorial_5656(n: nat): nat\n ensures Factorial_5656(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_5656(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_5657","instance":5657,"id":225672,"goal":"function Fib_5657(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_5657(n-1) + Fib_5657(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_5658","instance":5658,"id":225673,"goal":"function Gcd_5658(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_5658(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_5659","instance":5659,"id":225674,"goal":"function Power_5659(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_5659(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_5660","instance":5660,"id":225675,"goal":"function Sum_5660(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_5660(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_5661","instance":5661,"id":225676,"goal":"method BinarySearch_5661(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_5662","instance":5662,"id":225677,"goal":"method InsertSort_5662(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_5663","instance":5663,"id":225678,"goal":"method MergeSort_5663(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_5664","instance":5664,"id":225679,"goal":"method ArrayCopy_5664(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_5665","instance":5665,"id":225680,"goal":"function ListReverse_5665(s: seq): seq\n ensures |ListReverse_5665(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_5665(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_5666","instance":5666,"id":225681,"goal":"function Factorial_5666(n: nat): nat\n ensures Factorial_5666(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_5666(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_5667","instance":5667,"id":225682,"goal":"function Fib_5667(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_5667(n-1) + Fib_5667(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_5668","instance":5668,"id":225683,"goal":"function Gcd_5668(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_5668(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_5669","instance":5669,"id":225684,"goal":"function Power_5669(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_5669(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_5670","instance":5670,"id":225685,"goal":"function Sum_5670(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_5670(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_5671","instance":5671,"id":225686,"goal":"method BinarySearch_5671(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_5672","instance":5672,"id":225687,"goal":"method InsertSort_5672(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_5673","instance":5673,"id":225688,"goal":"method MergeSort_5673(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_5674","instance":5674,"id":225689,"goal":"method ArrayCopy_5674(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_5675","instance":5675,"id":225690,"goal":"function ListReverse_5675(s: seq): seq\n ensures |ListReverse_5675(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_5675(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_5676","instance":5676,"id":225691,"goal":"function Factorial_5676(n: nat): nat\n ensures Factorial_5676(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_5676(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_5677","instance":5677,"id":225692,"goal":"function Fib_5677(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_5677(n-1) + Fib_5677(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_5678","instance":5678,"id":225693,"goal":"function Gcd_5678(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_5678(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_5679","instance":5679,"id":225694,"goal":"function Power_5679(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_5679(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_5680","instance":5680,"id":225695,"goal":"function Sum_5680(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_5680(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_5681","instance":5681,"id":225696,"goal":"method BinarySearch_5681(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_5682","instance":5682,"id":225697,"goal":"method InsertSort_5682(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_5683","instance":5683,"id":225698,"goal":"method MergeSort_5683(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_5684","instance":5684,"id":225699,"goal":"method ArrayCopy_5684(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_5685","instance":5685,"id":225700,"goal":"function ListReverse_5685(s: seq): seq\n ensures |ListReverse_5685(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_5685(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_5686","instance":5686,"id":225701,"goal":"function Factorial_5686(n: nat): nat\n ensures Factorial_5686(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_5686(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_5687","instance":5687,"id":225702,"goal":"function Fib_5687(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_5687(n-1) + Fib_5687(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_5688","instance":5688,"id":225703,"goal":"function Gcd_5688(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_5688(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_5689","instance":5689,"id":225704,"goal":"function Power_5689(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_5689(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_5690","instance":5690,"id":225705,"goal":"function Sum_5690(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_5690(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_5691","instance":5691,"id":225706,"goal":"method BinarySearch_5691(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_5692","instance":5692,"id":225707,"goal":"method InsertSort_5692(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_5693","instance":5693,"id":225708,"goal":"method MergeSort_5693(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_5694","instance":5694,"id":225709,"goal":"method ArrayCopy_5694(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_5695","instance":5695,"id":225710,"goal":"function ListReverse_5695(s: seq): seq\n ensures |ListReverse_5695(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_5695(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_5696","instance":5696,"id":225711,"goal":"function Factorial_5696(n: nat): nat\n ensures Factorial_5696(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_5696(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_5697","instance":5697,"id":225712,"goal":"function Fib_5697(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_5697(n-1) + Fib_5697(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_5698","instance":5698,"id":225713,"goal":"function Gcd_5698(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_5698(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_5699","instance":5699,"id":225714,"goal":"function Power_5699(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_5699(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_5700","instance":5700,"id":225715,"goal":"function Sum_5700(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_5700(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_5701","instance":5701,"id":225716,"goal":"method BinarySearch_5701(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_5702","instance":5702,"id":225717,"goal":"method InsertSort_5702(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_5703","instance":5703,"id":225718,"goal":"method MergeSort_5703(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_5704","instance":5704,"id":225719,"goal":"method ArrayCopy_5704(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_5705","instance":5705,"id":225720,"goal":"function ListReverse_5705(s: seq): seq\n ensures |ListReverse_5705(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_5705(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_5706","instance":5706,"id":225721,"goal":"function Factorial_5706(n: nat): nat\n ensures Factorial_5706(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_5706(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_5707","instance":5707,"id":225722,"goal":"function Fib_5707(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_5707(n-1) + Fib_5707(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_5708","instance":5708,"id":225723,"goal":"function Gcd_5708(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_5708(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_5709","instance":5709,"id":225724,"goal":"function Power_5709(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_5709(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_5710","instance":5710,"id":225725,"goal":"function Sum_5710(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_5710(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_5711","instance":5711,"id":225726,"goal":"method BinarySearch_5711(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_5712","instance":5712,"id":225727,"goal":"method InsertSort_5712(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_5713","instance":5713,"id":225728,"goal":"method MergeSort_5713(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_5714","instance":5714,"id":225729,"goal":"method ArrayCopy_5714(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_5715","instance":5715,"id":225730,"goal":"function ListReverse_5715(s: seq): seq\n ensures |ListReverse_5715(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_5715(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_5716","instance":5716,"id":225731,"goal":"function Factorial_5716(n: nat): nat\n ensures Factorial_5716(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_5716(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_5717","instance":5717,"id":225732,"goal":"function Fib_5717(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_5717(n-1) + Fib_5717(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_5718","instance":5718,"id":225733,"goal":"function Gcd_5718(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_5718(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_5719","instance":5719,"id":225734,"goal":"function Power_5719(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_5719(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_5720","instance":5720,"id":225735,"goal":"function Sum_5720(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_5720(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_5721","instance":5721,"id":225736,"goal":"method BinarySearch_5721(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_5722","instance":5722,"id":225737,"goal":"method InsertSort_5722(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_5723","instance":5723,"id":225738,"goal":"method MergeSort_5723(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_5724","instance":5724,"id":225739,"goal":"method ArrayCopy_5724(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_5725","instance":5725,"id":225740,"goal":"function ListReverse_5725(s: seq): seq\n ensures |ListReverse_5725(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_5725(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_5726","instance":5726,"id":225741,"goal":"function Factorial_5726(n: nat): nat\n ensures Factorial_5726(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_5726(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_5727","instance":5727,"id":225742,"goal":"function Fib_5727(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_5727(n-1) + Fib_5727(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_5728","instance":5728,"id":225743,"goal":"function Gcd_5728(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_5728(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_5729","instance":5729,"id":225744,"goal":"function Power_5729(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_5729(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_5730","instance":5730,"id":225745,"goal":"function Sum_5730(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_5730(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_5731","instance":5731,"id":225746,"goal":"method BinarySearch_5731(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_5732","instance":5732,"id":225747,"goal":"method InsertSort_5732(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_5733","instance":5733,"id":225748,"goal":"method MergeSort_5733(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_5734","instance":5734,"id":225749,"goal":"method ArrayCopy_5734(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_5735","instance":5735,"id":225750,"goal":"function ListReverse_5735(s: seq): seq\n ensures |ListReverse_5735(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_5735(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_5736","instance":5736,"id":225751,"goal":"function Factorial_5736(n: nat): nat\n ensures Factorial_5736(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_5736(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_5737","instance":5737,"id":225752,"goal":"function Fib_5737(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_5737(n-1) + Fib_5737(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_5738","instance":5738,"id":225753,"goal":"function Gcd_5738(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_5738(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_5739","instance":5739,"id":225754,"goal":"function Power_5739(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_5739(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_5740","instance":5740,"id":225755,"goal":"function Sum_5740(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_5740(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_5741","instance":5741,"id":225756,"goal":"method BinarySearch_5741(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_5742","instance":5742,"id":225757,"goal":"method InsertSort_5742(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_5743","instance":5743,"id":225758,"goal":"method MergeSort_5743(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_5744","instance":5744,"id":225759,"goal":"method ArrayCopy_5744(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_5745","instance":5745,"id":225760,"goal":"function ListReverse_5745(s: seq): seq\n ensures |ListReverse_5745(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_5745(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_5746","instance":5746,"id":225761,"goal":"function Factorial_5746(n: nat): nat\n ensures Factorial_5746(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_5746(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_5747","instance":5747,"id":225762,"goal":"function Fib_5747(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_5747(n-1) + Fib_5747(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_5748","instance":5748,"id":225763,"goal":"function Gcd_5748(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_5748(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_5749","instance":5749,"id":225764,"goal":"function Power_5749(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_5749(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_5750","instance":5750,"id":225765,"goal":"function Sum_5750(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_5750(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_5751","instance":5751,"id":225766,"goal":"method BinarySearch_5751(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_5752","instance":5752,"id":225767,"goal":"method InsertSort_5752(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_5753","instance":5753,"id":225768,"goal":"method MergeSort_5753(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_5754","instance":5754,"id":225769,"goal":"method ArrayCopy_5754(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_5755","instance":5755,"id":225770,"goal":"function ListReverse_5755(s: seq): seq\n ensures |ListReverse_5755(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_5755(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_5756","instance":5756,"id":225771,"goal":"function Factorial_5756(n: nat): nat\n ensures Factorial_5756(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_5756(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_5757","instance":5757,"id":225772,"goal":"function Fib_5757(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_5757(n-1) + Fib_5757(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_5758","instance":5758,"id":225773,"goal":"function Gcd_5758(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_5758(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_5759","instance":5759,"id":225774,"goal":"function Power_5759(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_5759(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_5760","instance":5760,"id":225775,"goal":"function Sum_5760(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_5760(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_5761","instance":5761,"id":225776,"goal":"method BinarySearch_5761(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_5762","instance":5762,"id":225777,"goal":"method InsertSort_5762(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_5763","instance":5763,"id":225778,"goal":"method MergeSort_5763(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_5764","instance":5764,"id":225779,"goal":"method ArrayCopy_5764(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_5765","instance":5765,"id":225780,"goal":"function ListReverse_5765(s: seq): seq\n ensures |ListReverse_5765(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_5765(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_5766","instance":5766,"id":225781,"goal":"function Factorial_5766(n: nat): nat\n ensures Factorial_5766(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_5766(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_5767","instance":5767,"id":225782,"goal":"function Fib_5767(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_5767(n-1) + Fib_5767(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_5768","instance":5768,"id":225783,"goal":"function Gcd_5768(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_5768(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_5769","instance":5769,"id":225784,"goal":"function Power_5769(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_5769(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_5770","instance":5770,"id":225785,"goal":"function Sum_5770(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_5770(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_5771","instance":5771,"id":225786,"goal":"method BinarySearch_5771(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_5772","instance":5772,"id":225787,"goal":"method InsertSort_5772(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_5773","instance":5773,"id":225788,"goal":"method MergeSort_5773(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_5774","instance":5774,"id":225789,"goal":"method ArrayCopy_5774(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_5775","instance":5775,"id":225790,"goal":"function ListReverse_5775(s: seq): seq\n ensures |ListReverse_5775(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_5775(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_5776","instance":5776,"id":225791,"goal":"function Factorial_5776(n: nat): nat\n ensures Factorial_5776(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_5776(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_5777","instance":5777,"id":225792,"goal":"function Fib_5777(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_5777(n-1) + Fib_5777(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_5778","instance":5778,"id":225793,"goal":"function Gcd_5778(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_5778(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_5779","instance":5779,"id":225794,"goal":"function Power_5779(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_5779(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_5780","instance":5780,"id":225795,"goal":"function Sum_5780(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_5780(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_5781","instance":5781,"id":225796,"goal":"method BinarySearch_5781(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_5782","instance":5782,"id":225797,"goal":"method InsertSort_5782(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_5783","instance":5783,"id":225798,"goal":"method MergeSort_5783(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_5784","instance":5784,"id":225799,"goal":"method ArrayCopy_5784(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_5785","instance":5785,"id":225800,"goal":"function ListReverse_5785(s: seq): seq\n ensures |ListReverse_5785(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_5785(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_5786","instance":5786,"id":225801,"goal":"function Factorial_5786(n: nat): nat\n ensures Factorial_5786(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_5786(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_5787","instance":5787,"id":225802,"goal":"function Fib_5787(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_5787(n-1) + Fib_5787(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_5788","instance":5788,"id":225803,"goal":"function Gcd_5788(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_5788(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_5789","instance":5789,"id":225804,"goal":"function Power_5789(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_5789(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_5790","instance":5790,"id":225805,"goal":"function Sum_5790(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_5790(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_5791","instance":5791,"id":225806,"goal":"method BinarySearch_5791(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_5792","instance":5792,"id":225807,"goal":"method InsertSort_5792(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_5793","instance":5793,"id":225808,"goal":"method MergeSort_5793(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_5794","instance":5794,"id":225809,"goal":"method ArrayCopy_5794(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_5795","instance":5795,"id":225810,"goal":"function ListReverse_5795(s: seq): seq\n ensures |ListReverse_5795(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_5795(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_5796","instance":5796,"id":225811,"goal":"function Factorial_5796(n: nat): nat\n ensures Factorial_5796(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_5796(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_5797","instance":5797,"id":225812,"goal":"function Fib_5797(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_5797(n-1) + Fib_5797(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_5798","instance":5798,"id":225813,"goal":"function Gcd_5798(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_5798(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_5799","instance":5799,"id":225814,"goal":"function Power_5799(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_5799(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_5800","instance":5800,"id":225815,"goal":"function Sum_5800(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_5800(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_5801","instance":5801,"id":225816,"goal":"method BinarySearch_5801(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_5802","instance":5802,"id":225817,"goal":"method InsertSort_5802(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_5803","instance":5803,"id":225818,"goal":"method MergeSort_5803(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_5804","instance":5804,"id":225819,"goal":"method ArrayCopy_5804(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_5805","instance":5805,"id":225820,"goal":"function ListReverse_5805(s: seq): seq\n ensures |ListReverse_5805(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_5805(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_5806","instance":5806,"id":225821,"goal":"function Factorial_5806(n: nat): nat\n ensures Factorial_5806(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_5806(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_5807","instance":5807,"id":225822,"goal":"function Fib_5807(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_5807(n-1) + Fib_5807(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_5808","instance":5808,"id":225823,"goal":"function Gcd_5808(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_5808(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_5809","instance":5809,"id":225824,"goal":"function Power_5809(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_5809(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_5810","instance":5810,"id":225825,"goal":"function Sum_5810(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_5810(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_5811","instance":5811,"id":225826,"goal":"method BinarySearch_5811(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_5812","instance":5812,"id":225827,"goal":"method InsertSort_5812(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_5813","instance":5813,"id":225828,"goal":"method MergeSort_5813(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_5814","instance":5814,"id":225829,"goal":"method ArrayCopy_5814(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_5815","instance":5815,"id":225830,"goal":"function ListReverse_5815(s: seq): seq\n ensures |ListReverse_5815(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_5815(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_5816","instance":5816,"id":225831,"goal":"function Factorial_5816(n: nat): nat\n ensures Factorial_5816(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_5816(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_5817","instance":5817,"id":225832,"goal":"function Fib_5817(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_5817(n-1) + Fib_5817(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_5818","instance":5818,"id":225833,"goal":"function Gcd_5818(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_5818(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_5819","instance":5819,"id":225834,"goal":"function Power_5819(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_5819(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_5820","instance":5820,"id":225835,"goal":"function Sum_5820(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_5820(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_5821","instance":5821,"id":225836,"goal":"method BinarySearch_5821(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_5822","instance":5822,"id":225837,"goal":"method InsertSort_5822(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_5823","instance":5823,"id":225838,"goal":"method MergeSort_5823(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_5824","instance":5824,"id":225839,"goal":"method ArrayCopy_5824(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_5825","instance":5825,"id":225840,"goal":"function ListReverse_5825(s: seq): seq\n ensures |ListReverse_5825(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_5825(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_5826","instance":5826,"id":225841,"goal":"function Factorial_5826(n: nat): nat\n ensures Factorial_5826(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_5826(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_5827","instance":5827,"id":225842,"goal":"function Fib_5827(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_5827(n-1) + Fib_5827(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_5828","instance":5828,"id":225843,"goal":"function Gcd_5828(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_5828(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_5829","instance":5829,"id":225844,"goal":"function Power_5829(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_5829(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_5830","instance":5830,"id":225845,"goal":"function Sum_5830(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_5830(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_5831","instance":5831,"id":225846,"goal":"method BinarySearch_5831(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_5832","instance":5832,"id":225847,"goal":"method InsertSort_5832(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_5833","instance":5833,"id":225848,"goal":"method MergeSort_5833(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_5834","instance":5834,"id":225849,"goal":"method ArrayCopy_5834(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_5835","instance":5835,"id":225850,"goal":"function ListReverse_5835(s: seq): seq\n ensures |ListReverse_5835(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_5835(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_5836","instance":5836,"id":225851,"goal":"function Factorial_5836(n: nat): nat\n ensures Factorial_5836(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_5836(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_5837","instance":5837,"id":225852,"goal":"function Fib_5837(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_5837(n-1) + Fib_5837(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_5838","instance":5838,"id":225853,"goal":"function Gcd_5838(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_5838(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_5839","instance":5839,"id":225854,"goal":"function Power_5839(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_5839(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_5840","instance":5840,"id":225855,"goal":"function Sum_5840(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_5840(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_5841","instance":5841,"id":225856,"goal":"method BinarySearch_5841(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_5842","instance":5842,"id":225857,"goal":"method InsertSort_5842(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_5843","instance":5843,"id":225858,"goal":"method MergeSort_5843(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_5844","instance":5844,"id":225859,"goal":"method ArrayCopy_5844(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_5845","instance":5845,"id":225860,"goal":"function ListReverse_5845(s: seq): seq\n ensures |ListReverse_5845(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_5845(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_5846","instance":5846,"id":225861,"goal":"function Factorial_5846(n: nat): nat\n ensures Factorial_5846(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_5846(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_5847","instance":5847,"id":225862,"goal":"function Fib_5847(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_5847(n-1) + Fib_5847(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_5848","instance":5848,"id":225863,"goal":"function Gcd_5848(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_5848(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_5849","instance":5849,"id":225864,"goal":"function Power_5849(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_5849(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_5850","instance":5850,"id":225865,"goal":"function Sum_5850(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_5850(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_5851","instance":5851,"id":225866,"goal":"method BinarySearch_5851(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_5852","instance":5852,"id":225867,"goal":"method InsertSort_5852(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_5853","instance":5853,"id":225868,"goal":"method MergeSort_5853(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_5854","instance":5854,"id":225869,"goal":"method ArrayCopy_5854(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_5855","instance":5855,"id":225870,"goal":"function ListReverse_5855(s: seq): seq\n ensures |ListReverse_5855(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_5855(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_5856","instance":5856,"id":225871,"goal":"function Factorial_5856(n: nat): nat\n ensures Factorial_5856(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_5856(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_5857","instance":5857,"id":225872,"goal":"function Fib_5857(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_5857(n-1) + Fib_5857(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_5858","instance":5858,"id":225873,"goal":"function Gcd_5858(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_5858(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_5859","instance":5859,"id":225874,"goal":"function Power_5859(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_5859(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_5860","instance":5860,"id":225875,"goal":"function Sum_5860(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_5860(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_5861","instance":5861,"id":225876,"goal":"method BinarySearch_5861(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_5862","instance":5862,"id":225877,"goal":"method InsertSort_5862(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_5863","instance":5863,"id":225878,"goal":"method MergeSort_5863(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_5864","instance":5864,"id":225879,"goal":"method ArrayCopy_5864(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_5865","instance":5865,"id":225880,"goal":"function ListReverse_5865(s: seq): seq\n ensures |ListReverse_5865(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_5865(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_5866","instance":5866,"id":225881,"goal":"function Factorial_5866(n: nat): nat\n ensures Factorial_5866(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_5866(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_5867","instance":5867,"id":225882,"goal":"function Fib_5867(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_5867(n-1) + Fib_5867(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_5868","instance":5868,"id":225883,"goal":"function Gcd_5868(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_5868(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_5869","instance":5869,"id":225884,"goal":"function Power_5869(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_5869(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_5870","instance":5870,"id":225885,"goal":"function Sum_5870(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_5870(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_5871","instance":5871,"id":225886,"goal":"method BinarySearch_5871(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_5872","instance":5872,"id":225887,"goal":"method InsertSort_5872(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_5873","instance":5873,"id":225888,"goal":"method MergeSort_5873(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_5874","instance":5874,"id":225889,"goal":"method ArrayCopy_5874(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_5875","instance":5875,"id":225890,"goal":"function ListReverse_5875(s: seq): seq\n ensures |ListReverse_5875(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_5875(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_5876","instance":5876,"id":225891,"goal":"function Factorial_5876(n: nat): nat\n ensures Factorial_5876(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_5876(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_5877","instance":5877,"id":225892,"goal":"function Fib_5877(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_5877(n-1) + Fib_5877(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_5878","instance":5878,"id":225893,"goal":"function Gcd_5878(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_5878(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_5879","instance":5879,"id":225894,"goal":"function Power_5879(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_5879(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_5880","instance":5880,"id":225895,"goal":"function Sum_5880(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_5880(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_5881","instance":5881,"id":225896,"goal":"method BinarySearch_5881(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_5882","instance":5882,"id":225897,"goal":"method InsertSort_5882(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_5883","instance":5883,"id":225898,"goal":"method MergeSort_5883(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_5884","instance":5884,"id":225899,"goal":"method ArrayCopy_5884(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_5885","instance":5885,"id":225900,"goal":"function ListReverse_5885(s: seq): seq\n ensures |ListReverse_5885(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_5885(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_5886","instance":5886,"id":225901,"goal":"function Factorial_5886(n: nat): nat\n ensures Factorial_5886(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_5886(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_5887","instance":5887,"id":225902,"goal":"function Fib_5887(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_5887(n-1) + Fib_5887(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_5888","instance":5888,"id":225903,"goal":"function Gcd_5888(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_5888(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_5889","instance":5889,"id":225904,"goal":"function Power_5889(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_5889(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_5890","instance":5890,"id":225905,"goal":"function Sum_5890(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_5890(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_5891","instance":5891,"id":225906,"goal":"method BinarySearch_5891(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_5892","instance":5892,"id":225907,"goal":"method InsertSort_5892(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_5893","instance":5893,"id":225908,"goal":"method MergeSort_5893(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_5894","instance":5894,"id":225909,"goal":"method ArrayCopy_5894(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_5895","instance":5895,"id":225910,"goal":"function ListReverse_5895(s: seq): seq\n ensures |ListReverse_5895(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_5895(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_5896","instance":5896,"id":225911,"goal":"function Factorial_5896(n: nat): nat\n ensures Factorial_5896(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_5896(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_5897","instance":5897,"id":225912,"goal":"function Fib_5897(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_5897(n-1) + Fib_5897(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_5898","instance":5898,"id":225913,"goal":"function Gcd_5898(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_5898(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_5899","instance":5899,"id":225914,"goal":"function Power_5899(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_5899(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_5900","instance":5900,"id":225915,"goal":"function Sum_5900(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_5900(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_5901","instance":5901,"id":225916,"goal":"method BinarySearch_5901(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_5902","instance":5902,"id":225917,"goal":"method InsertSort_5902(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_5903","instance":5903,"id":225918,"goal":"method MergeSort_5903(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_5904","instance":5904,"id":225919,"goal":"method ArrayCopy_5904(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_5905","instance":5905,"id":225920,"goal":"function ListReverse_5905(s: seq): seq\n ensures |ListReverse_5905(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_5905(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_5906","instance":5906,"id":225921,"goal":"function Factorial_5906(n: nat): nat\n ensures Factorial_5906(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_5906(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_5907","instance":5907,"id":225922,"goal":"function Fib_5907(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_5907(n-1) + Fib_5907(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_5908","instance":5908,"id":225923,"goal":"function Gcd_5908(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_5908(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_5909","instance":5909,"id":225924,"goal":"function Power_5909(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_5909(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_5910","instance":5910,"id":225925,"goal":"function Sum_5910(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_5910(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_5911","instance":5911,"id":225926,"goal":"method BinarySearch_5911(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_5912","instance":5912,"id":225927,"goal":"method InsertSort_5912(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_5913","instance":5913,"id":225928,"goal":"method MergeSort_5913(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_5914","instance":5914,"id":225929,"goal":"method ArrayCopy_5914(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_5915","instance":5915,"id":225930,"goal":"function ListReverse_5915(s: seq): seq\n ensures |ListReverse_5915(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_5915(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_5916","instance":5916,"id":225931,"goal":"function Factorial_5916(n: nat): nat\n ensures Factorial_5916(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_5916(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_5917","instance":5917,"id":225932,"goal":"function Fib_5917(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_5917(n-1) + Fib_5917(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_5918","instance":5918,"id":225933,"goal":"function Gcd_5918(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_5918(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_5919","instance":5919,"id":225934,"goal":"function Power_5919(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_5919(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_5920","instance":5920,"id":225935,"goal":"function Sum_5920(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_5920(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_5921","instance":5921,"id":225936,"goal":"method BinarySearch_5921(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_5922","instance":5922,"id":225937,"goal":"method InsertSort_5922(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_5923","instance":5923,"id":225938,"goal":"method MergeSort_5923(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_5924","instance":5924,"id":225939,"goal":"method ArrayCopy_5924(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_5925","instance":5925,"id":225940,"goal":"function ListReverse_5925(s: seq): seq\n ensures |ListReverse_5925(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_5925(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_5926","instance":5926,"id":225941,"goal":"function Factorial_5926(n: nat): nat\n ensures Factorial_5926(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_5926(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_5927","instance":5927,"id":225942,"goal":"function Fib_5927(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_5927(n-1) + Fib_5927(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_5928","instance":5928,"id":225943,"goal":"function Gcd_5928(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_5928(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_5929","instance":5929,"id":225944,"goal":"function Power_5929(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_5929(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_5930","instance":5930,"id":225945,"goal":"function Sum_5930(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_5930(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_5931","instance":5931,"id":225946,"goal":"method BinarySearch_5931(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_5932","instance":5932,"id":225947,"goal":"method InsertSort_5932(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_5933","instance":5933,"id":225948,"goal":"method MergeSort_5933(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_5934","instance":5934,"id":225949,"goal":"method ArrayCopy_5934(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_5935","instance":5935,"id":225950,"goal":"function ListReverse_5935(s: seq): seq\n ensures |ListReverse_5935(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_5935(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_5936","instance":5936,"id":225951,"goal":"function Factorial_5936(n: nat): nat\n ensures Factorial_5936(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_5936(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_5937","instance":5937,"id":225952,"goal":"function Fib_5937(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_5937(n-1) + Fib_5937(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_5938","instance":5938,"id":225953,"goal":"function Gcd_5938(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_5938(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_5939","instance":5939,"id":225954,"goal":"function Power_5939(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_5939(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_5940","instance":5940,"id":225955,"goal":"function Sum_5940(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_5940(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_5941","instance":5941,"id":225956,"goal":"method BinarySearch_5941(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_5942","instance":5942,"id":225957,"goal":"method InsertSort_5942(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_5943","instance":5943,"id":225958,"goal":"method MergeSort_5943(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_5944","instance":5944,"id":225959,"goal":"method ArrayCopy_5944(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_5945","instance":5945,"id":225960,"goal":"function ListReverse_5945(s: seq): seq\n ensures |ListReverse_5945(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_5945(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_5946","instance":5946,"id":225961,"goal":"function Factorial_5946(n: nat): nat\n ensures Factorial_5946(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_5946(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_5947","instance":5947,"id":225962,"goal":"function Fib_5947(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_5947(n-1) + Fib_5947(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_5948","instance":5948,"id":225963,"goal":"function Gcd_5948(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_5948(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_5949","instance":5949,"id":225964,"goal":"function Power_5949(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_5949(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_5950","instance":5950,"id":225965,"goal":"function Sum_5950(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_5950(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_5951","instance":5951,"id":225966,"goal":"method BinarySearch_5951(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_5952","instance":5952,"id":225967,"goal":"method InsertSort_5952(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_5953","instance":5953,"id":225968,"goal":"method MergeSort_5953(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_5954","instance":5954,"id":225969,"goal":"method ArrayCopy_5954(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_5955","instance":5955,"id":225970,"goal":"function ListReverse_5955(s: seq): seq\n ensures |ListReverse_5955(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_5955(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_5956","instance":5956,"id":225971,"goal":"function Factorial_5956(n: nat): nat\n ensures Factorial_5956(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_5956(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_5957","instance":5957,"id":225972,"goal":"function Fib_5957(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_5957(n-1) + Fib_5957(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_5958","instance":5958,"id":225973,"goal":"function Gcd_5958(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_5958(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_5959","instance":5959,"id":225974,"goal":"function Power_5959(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_5959(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_5960","instance":5960,"id":225975,"goal":"function Sum_5960(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_5960(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_5961","instance":5961,"id":225976,"goal":"method BinarySearch_5961(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_5962","instance":5962,"id":225977,"goal":"method InsertSort_5962(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_5963","instance":5963,"id":225978,"goal":"method MergeSort_5963(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_5964","instance":5964,"id":225979,"goal":"method ArrayCopy_5964(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_5965","instance":5965,"id":225980,"goal":"function ListReverse_5965(s: seq): seq\n ensures |ListReverse_5965(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_5965(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_5966","instance":5966,"id":225981,"goal":"function Factorial_5966(n: nat): nat\n ensures Factorial_5966(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_5966(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_5967","instance":5967,"id":225982,"goal":"function Fib_5967(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_5967(n-1) + Fib_5967(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_5968","instance":5968,"id":225983,"goal":"function Gcd_5968(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_5968(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_5969","instance":5969,"id":225984,"goal":"function Power_5969(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_5969(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_5970","instance":5970,"id":225985,"goal":"function Sum_5970(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_5970(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_5971","instance":5971,"id":225986,"goal":"method BinarySearch_5971(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_5972","instance":5972,"id":225987,"goal":"method InsertSort_5972(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_5973","instance":5973,"id":225988,"goal":"method MergeSort_5973(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_5974","instance":5974,"id":225989,"goal":"method ArrayCopy_5974(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_5975","instance":5975,"id":225990,"goal":"function ListReverse_5975(s: seq): seq\n ensures |ListReverse_5975(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_5975(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_5976","instance":5976,"id":225991,"goal":"function Factorial_5976(n: nat): nat\n ensures Factorial_5976(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_5976(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_5977","instance":5977,"id":225992,"goal":"function Fib_5977(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_5977(n-1) + Fib_5977(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_5978","instance":5978,"id":225993,"goal":"function Gcd_5978(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_5978(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_5979","instance":5979,"id":225994,"goal":"function Power_5979(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_5979(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_5980","instance":5980,"id":225995,"goal":"function Sum_5980(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_5980(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_5981","instance":5981,"id":225996,"goal":"method BinarySearch_5981(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_5982","instance":5982,"id":225997,"goal":"method InsertSort_5982(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_5983","instance":5983,"id":225998,"goal":"method MergeSort_5983(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_5984","instance":5984,"id":225999,"goal":"method ArrayCopy_5984(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_5985","instance":5985,"id":226000,"goal":"function ListReverse_5985(s: seq): seq\n ensures |ListReverse_5985(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_5985(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_5986","instance":5986,"id":226001,"goal":"function Factorial_5986(n: nat): nat\n ensures Factorial_5986(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_5986(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_5987","instance":5987,"id":226002,"goal":"function Fib_5987(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_5987(n-1) + Fib_5987(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_5988","instance":5988,"id":226003,"goal":"function Gcd_5988(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_5988(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_5989","instance":5989,"id":226004,"goal":"function Power_5989(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_5989(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_5990","instance":5990,"id":226005,"goal":"function Sum_5990(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_5990(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_5991","instance":5991,"id":226006,"goal":"method BinarySearch_5991(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_5992","instance":5992,"id":226007,"goal":"method InsertSort_5992(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_5993","instance":5993,"id":226008,"goal":"method MergeSort_5993(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_5994","instance":5994,"id":226009,"goal":"method ArrayCopy_5994(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_5995","instance":5995,"id":226010,"goal":"function ListReverse_5995(s: seq): seq\n ensures |ListReverse_5995(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_5995(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_5996","instance":5996,"id":226011,"goal":"function Factorial_5996(n: nat): nat\n ensures Factorial_5996(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_5996(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_5997","instance":5997,"id":226012,"goal":"function Fib_5997(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_5997(n-1) + Fib_5997(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_5998","instance":5998,"id":226013,"goal":"function Gcd_5998(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_5998(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_5999","instance":5999,"id":226014,"goal":"function Power_5999(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_5999(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_6000","instance":6000,"id":226015,"goal":"function Sum_6000(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_6000(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_6001","instance":6001,"id":226016,"goal":"method BinarySearch_6001(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_6002","instance":6002,"id":226017,"goal":"method InsertSort_6002(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_6003","instance":6003,"id":226018,"goal":"method MergeSort_6003(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_6004","instance":6004,"id":226019,"goal":"method ArrayCopy_6004(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_6005","instance":6005,"id":226020,"goal":"function ListReverse_6005(s: seq): seq\n ensures |ListReverse_6005(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_6005(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_6006","instance":6006,"id":226021,"goal":"function Factorial_6006(n: nat): nat\n ensures Factorial_6006(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_6006(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_6007","instance":6007,"id":226022,"goal":"function Fib_6007(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_6007(n-1) + Fib_6007(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_6008","instance":6008,"id":226023,"goal":"function Gcd_6008(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_6008(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_6009","instance":6009,"id":226024,"goal":"function Power_6009(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_6009(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_6010","instance":6010,"id":226025,"goal":"function Sum_6010(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_6010(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_6011","instance":6011,"id":226026,"goal":"method BinarySearch_6011(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_6012","instance":6012,"id":226027,"goal":"method InsertSort_6012(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_6013","instance":6013,"id":226028,"goal":"method MergeSort_6013(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_6014","instance":6014,"id":226029,"goal":"method ArrayCopy_6014(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_6015","instance":6015,"id":226030,"goal":"function ListReverse_6015(s: seq): seq\n ensures |ListReverse_6015(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_6015(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_6016","instance":6016,"id":226031,"goal":"function Factorial_6016(n: nat): nat\n ensures Factorial_6016(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_6016(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_6017","instance":6017,"id":226032,"goal":"function Fib_6017(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_6017(n-1) + Fib_6017(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_6018","instance":6018,"id":226033,"goal":"function Gcd_6018(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_6018(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_6019","instance":6019,"id":226034,"goal":"function Power_6019(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_6019(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_6020","instance":6020,"id":226035,"goal":"function Sum_6020(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_6020(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_6021","instance":6021,"id":226036,"goal":"method BinarySearch_6021(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_6022","instance":6022,"id":226037,"goal":"method InsertSort_6022(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_6023","instance":6023,"id":226038,"goal":"method MergeSort_6023(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_6024","instance":6024,"id":226039,"goal":"method ArrayCopy_6024(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_6025","instance":6025,"id":226040,"goal":"function ListReverse_6025(s: seq): seq\n ensures |ListReverse_6025(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_6025(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_6026","instance":6026,"id":226041,"goal":"function Factorial_6026(n: nat): nat\n ensures Factorial_6026(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_6026(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_6027","instance":6027,"id":226042,"goal":"function Fib_6027(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_6027(n-1) + Fib_6027(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_6028","instance":6028,"id":226043,"goal":"function Gcd_6028(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_6028(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_6029","instance":6029,"id":226044,"goal":"function Power_6029(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_6029(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_6030","instance":6030,"id":226045,"goal":"function Sum_6030(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_6030(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_6031","instance":6031,"id":226046,"goal":"method BinarySearch_6031(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_6032","instance":6032,"id":226047,"goal":"method InsertSort_6032(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_6033","instance":6033,"id":226048,"goal":"method MergeSort_6033(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_6034","instance":6034,"id":226049,"goal":"method ArrayCopy_6034(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_6035","instance":6035,"id":226050,"goal":"function ListReverse_6035(s: seq): seq\n ensures |ListReverse_6035(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_6035(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_6036","instance":6036,"id":226051,"goal":"function Factorial_6036(n: nat): nat\n ensures Factorial_6036(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_6036(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_6037","instance":6037,"id":226052,"goal":"function Fib_6037(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_6037(n-1) + Fib_6037(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_6038","instance":6038,"id":226053,"goal":"function Gcd_6038(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_6038(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_6039","instance":6039,"id":226054,"goal":"function Power_6039(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_6039(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_6040","instance":6040,"id":226055,"goal":"function Sum_6040(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_6040(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_6041","instance":6041,"id":226056,"goal":"method BinarySearch_6041(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_6042","instance":6042,"id":226057,"goal":"method InsertSort_6042(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_6043","instance":6043,"id":226058,"goal":"method MergeSort_6043(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_6044","instance":6044,"id":226059,"goal":"method ArrayCopy_6044(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_6045","instance":6045,"id":226060,"goal":"function ListReverse_6045(s: seq): seq\n ensures |ListReverse_6045(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_6045(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_6046","instance":6046,"id":226061,"goal":"function Factorial_6046(n: nat): nat\n ensures Factorial_6046(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_6046(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_6047","instance":6047,"id":226062,"goal":"function Fib_6047(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_6047(n-1) + Fib_6047(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_6048","instance":6048,"id":226063,"goal":"function Gcd_6048(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_6048(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_6049","instance":6049,"id":226064,"goal":"function Power_6049(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_6049(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_6050","instance":6050,"id":226065,"goal":"function Sum_6050(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_6050(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_6051","instance":6051,"id":226066,"goal":"method BinarySearch_6051(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_6052","instance":6052,"id":226067,"goal":"method InsertSort_6052(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_6053","instance":6053,"id":226068,"goal":"method MergeSort_6053(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_6054","instance":6054,"id":226069,"goal":"method ArrayCopy_6054(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_6055","instance":6055,"id":226070,"goal":"function ListReverse_6055(s: seq): seq\n ensures |ListReverse_6055(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_6055(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_6056","instance":6056,"id":226071,"goal":"function Factorial_6056(n: nat): nat\n ensures Factorial_6056(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_6056(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_6057","instance":6057,"id":226072,"goal":"function Fib_6057(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_6057(n-1) + Fib_6057(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_6058","instance":6058,"id":226073,"goal":"function Gcd_6058(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_6058(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_6059","instance":6059,"id":226074,"goal":"function Power_6059(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_6059(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_6060","instance":6060,"id":226075,"goal":"function Sum_6060(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_6060(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_6061","instance":6061,"id":226076,"goal":"method BinarySearch_6061(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_6062","instance":6062,"id":226077,"goal":"method InsertSort_6062(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_6063","instance":6063,"id":226078,"goal":"method MergeSort_6063(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_6064","instance":6064,"id":226079,"goal":"method ArrayCopy_6064(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_6065","instance":6065,"id":226080,"goal":"function ListReverse_6065(s: seq): seq\n ensures |ListReverse_6065(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_6065(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_6066","instance":6066,"id":226081,"goal":"function Factorial_6066(n: nat): nat\n ensures Factorial_6066(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_6066(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_6067","instance":6067,"id":226082,"goal":"function Fib_6067(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_6067(n-1) + Fib_6067(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_6068","instance":6068,"id":226083,"goal":"function Gcd_6068(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_6068(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_6069","instance":6069,"id":226084,"goal":"function Power_6069(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_6069(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_6070","instance":6070,"id":226085,"goal":"function Sum_6070(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_6070(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_6071","instance":6071,"id":226086,"goal":"method BinarySearch_6071(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_6072","instance":6072,"id":226087,"goal":"method InsertSort_6072(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_6073","instance":6073,"id":226088,"goal":"method MergeSort_6073(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_6074","instance":6074,"id":226089,"goal":"method ArrayCopy_6074(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_6075","instance":6075,"id":226090,"goal":"function ListReverse_6075(s: seq): seq\n ensures |ListReverse_6075(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_6075(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_6076","instance":6076,"id":226091,"goal":"function Factorial_6076(n: nat): nat\n ensures Factorial_6076(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_6076(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_6077","instance":6077,"id":226092,"goal":"function Fib_6077(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_6077(n-1) + Fib_6077(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_6078","instance":6078,"id":226093,"goal":"function Gcd_6078(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_6078(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_6079","instance":6079,"id":226094,"goal":"function Power_6079(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_6079(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_6080","instance":6080,"id":226095,"goal":"function Sum_6080(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_6080(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_6081","instance":6081,"id":226096,"goal":"method BinarySearch_6081(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_6082","instance":6082,"id":226097,"goal":"method InsertSort_6082(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_6083","instance":6083,"id":226098,"goal":"method MergeSort_6083(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_6084","instance":6084,"id":226099,"goal":"method ArrayCopy_6084(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_6085","instance":6085,"id":226100,"goal":"function ListReverse_6085(s: seq): seq\n ensures |ListReverse_6085(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_6085(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_6086","instance":6086,"id":226101,"goal":"function Factorial_6086(n: nat): nat\n ensures Factorial_6086(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_6086(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_6087","instance":6087,"id":226102,"goal":"function Fib_6087(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_6087(n-1) + Fib_6087(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_6088","instance":6088,"id":226103,"goal":"function Gcd_6088(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_6088(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_6089","instance":6089,"id":226104,"goal":"function Power_6089(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_6089(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_6090","instance":6090,"id":226105,"goal":"function Sum_6090(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_6090(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_6091","instance":6091,"id":226106,"goal":"method BinarySearch_6091(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_6092","instance":6092,"id":226107,"goal":"method InsertSort_6092(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_6093","instance":6093,"id":226108,"goal":"method MergeSort_6093(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_6094","instance":6094,"id":226109,"goal":"method ArrayCopy_6094(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_6095","instance":6095,"id":226110,"goal":"function ListReverse_6095(s: seq): seq\n ensures |ListReverse_6095(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_6095(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_6096","instance":6096,"id":226111,"goal":"function Factorial_6096(n: nat): nat\n ensures Factorial_6096(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_6096(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_6097","instance":6097,"id":226112,"goal":"function Fib_6097(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_6097(n-1) + Fib_6097(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_6098","instance":6098,"id":226113,"goal":"function Gcd_6098(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_6098(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_6099","instance":6099,"id":226114,"goal":"function Power_6099(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_6099(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_6100","instance":6100,"id":226115,"goal":"function Sum_6100(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_6100(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_6101","instance":6101,"id":226116,"goal":"method BinarySearch_6101(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_6102","instance":6102,"id":226117,"goal":"method InsertSort_6102(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_6103","instance":6103,"id":226118,"goal":"method MergeSort_6103(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_6104","instance":6104,"id":226119,"goal":"method ArrayCopy_6104(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_6105","instance":6105,"id":226120,"goal":"function ListReverse_6105(s: seq): seq\n ensures |ListReverse_6105(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_6105(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_6106","instance":6106,"id":226121,"goal":"function Factorial_6106(n: nat): nat\n ensures Factorial_6106(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_6106(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_6107","instance":6107,"id":226122,"goal":"function Fib_6107(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_6107(n-1) + Fib_6107(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_6108","instance":6108,"id":226123,"goal":"function Gcd_6108(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_6108(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_6109","instance":6109,"id":226124,"goal":"function Power_6109(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_6109(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_6110","instance":6110,"id":226125,"goal":"function Sum_6110(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_6110(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_6111","instance":6111,"id":226126,"goal":"method BinarySearch_6111(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_6112","instance":6112,"id":226127,"goal":"method InsertSort_6112(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_6113","instance":6113,"id":226128,"goal":"method MergeSort_6113(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_6114","instance":6114,"id":226129,"goal":"method ArrayCopy_6114(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_6115","instance":6115,"id":226130,"goal":"function ListReverse_6115(s: seq): seq\n ensures |ListReverse_6115(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_6115(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_6116","instance":6116,"id":226131,"goal":"function Factorial_6116(n: nat): nat\n ensures Factorial_6116(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_6116(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_6117","instance":6117,"id":226132,"goal":"function Fib_6117(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_6117(n-1) + Fib_6117(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_6118","instance":6118,"id":226133,"goal":"function Gcd_6118(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_6118(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_6119","instance":6119,"id":226134,"goal":"function Power_6119(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_6119(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_6120","instance":6120,"id":226135,"goal":"function Sum_6120(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_6120(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_6121","instance":6121,"id":226136,"goal":"method BinarySearch_6121(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_6122","instance":6122,"id":226137,"goal":"method InsertSort_6122(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_6123","instance":6123,"id":226138,"goal":"method MergeSort_6123(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_6124","instance":6124,"id":226139,"goal":"method ArrayCopy_6124(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_6125","instance":6125,"id":226140,"goal":"function ListReverse_6125(s: seq): seq\n ensures |ListReverse_6125(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_6125(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_6126","instance":6126,"id":226141,"goal":"function Factorial_6126(n: nat): nat\n ensures Factorial_6126(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_6126(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_6127","instance":6127,"id":226142,"goal":"function Fib_6127(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_6127(n-1) + Fib_6127(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_6128","instance":6128,"id":226143,"goal":"function Gcd_6128(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_6128(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_6129","instance":6129,"id":226144,"goal":"function Power_6129(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_6129(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_6130","instance":6130,"id":226145,"goal":"function Sum_6130(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_6130(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_6131","instance":6131,"id":226146,"goal":"method BinarySearch_6131(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_6132","instance":6132,"id":226147,"goal":"method InsertSort_6132(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_6133","instance":6133,"id":226148,"goal":"method MergeSort_6133(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_6134","instance":6134,"id":226149,"goal":"method ArrayCopy_6134(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_6135","instance":6135,"id":226150,"goal":"function ListReverse_6135(s: seq): seq\n ensures |ListReverse_6135(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_6135(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_6136","instance":6136,"id":226151,"goal":"function Factorial_6136(n: nat): nat\n ensures Factorial_6136(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_6136(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_6137","instance":6137,"id":226152,"goal":"function Fib_6137(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_6137(n-1) + Fib_6137(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_6138","instance":6138,"id":226153,"goal":"function Gcd_6138(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_6138(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_6139","instance":6139,"id":226154,"goal":"function Power_6139(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_6139(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_6140","instance":6140,"id":226155,"goal":"function Sum_6140(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_6140(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_6141","instance":6141,"id":226156,"goal":"method BinarySearch_6141(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_6142","instance":6142,"id":226157,"goal":"method InsertSort_6142(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_6143","instance":6143,"id":226158,"goal":"method MergeSort_6143(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_6144","instance":6144,"id":226159,"goal":"method ArrayCopy_6144(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_6145","instance":6145,"id":226160,"goal":"function ListReverse_6145(s: seq): seq\n ensures |ListReverse_6145(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_6145(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_6146","instance":6146,"id":226161,"goal":"function Factorial_6146(n: nat): nat\n ensures Factorial_6146(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_6146(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_6147","instance":6147,"id":226162,"goal":"function Fib_6147(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_6147(n-1) + Fib_6147(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_6148","instance":6148,"id":226163,"goal":"function Gcd_6148(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_6148(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_6149","instance":6149,"id":226164,"goal":"function Power_6149(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_6149(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_6150","instance":6150,"id":226165,"goal":"function Sum_6150(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_6150(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_6151","instance":6151,"id":226166,"goal":"method BinarySearch_6151(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_6152","instance":6152,"id":226167,"goal":"method InsertSort_6152(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_6153","instance":6153,"id":226168,"goal":"method MergeSort_6153(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_6154","instance":6154,"id":226169,"goal":"method ArrayCopy_6154(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_6155","instance":6155,"id":226170,"goal":"function ListReverse_6155(s: seq): seq\n ensures |ListReverse_6155(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_6155(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_6156","instance":6156,"id":226171,"goal":"function Factorial_6156(n: nat): nat\n ensures Factorial_6156(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_6156(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_6157","instance":6157,"id":226172,"goal":"function Fib_6157(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_6157(n-1) + Fib_6157(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_6158","instance":6158,"id":226173,"goal":"function Gcd_6158(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_6158(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_6159","instance":6159,"id":226174,"goal":"function Power_6159(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_6159(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_6160","instance":6160,"id":226175,"goal":"function Sum_6160(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_6160(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_6161","instance":6161,"id":226176,"goal":"method BinarySearch_6161(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_6162","instance":6162,"id":226177,"goal":"method InsertSort_6162(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_6163","instance":6163,"id":226178,"goal":"method MergeSort_6163(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_6164","instance":6164,"id":226179,"goal":"method ArrayCopy_6164(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_6165","instance":6165,"id":226180,"goal":"function ListReverse_6165(s: seq): seq\n ensures |ListReverse_6165(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_6165(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_6166","instance":6166,"id":226181,"goal":"function Factorial_6166(n: nat): nat\n ensures Factorial_6166(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_6166(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_6167","instance":6167,"id":226182,"goal":"function Fib_6167(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_6167(n-1) + Fib_6167(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_6168","instance":6168,"id":226183,"goal":"function Gcd_6168(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_6168(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_6169","instance":6169,"id":226184,"goal":"function Power_6169(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_6169(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_6170","instance":6170,"id":226185,"goal":"function Sum_6170(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_6170(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_6171","instance":6171,"id":226186,"goal":"method BinarySearch_6171(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_6172","instance":6172,"id":226187,"goal":"method InsertSort_6172(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_6173","instance":6173,"id":226188,"goal":"method MergeSort_6173(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_6174","instance":6174,"id":226189,"goal":"method ArrayCopy_6174(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_6175","instance":6175,"id":226190,"goal":"function ListReverse_6175(s: seq): seq\n ensures |ListReverse_6175(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_6175(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_6176","instance":6176,"id":226191,"goal":"function Factorial_6176(n: nat): nat\n ensures Factorial_6176(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_6176(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_6177","instance":6177,"id":226192,"goal":"function Fib_6177(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_6177(n-1) + Fib_6177(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_6178","instance":6178,"id":226193,"goal":"function Gcd_6178(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_6178(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_6179","instance":6179,"id":226194,"goal":"function Power_6179(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_6179(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_6180","instance":6180,"id":226195,"goal":"function Sum_6180(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_6180(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_6181","instance":6181,"id":226196,"goal":"method BinarySearch_6181(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_6182","instance":6182,"id":226197,"goal":"method InsertSort_6182(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_6183","instance":6183,"id":226198,"goal":"method MergeSort_6183(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_6184","instance":6184,"id":226199,"goal":"method ArrayCopy_6184(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_6185","instance":6185,"id":226200,"goal":"function ListReverse_6185(s: seq): seq\n ensures |ListReverse_6185(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_6185(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_6186","instance":6186,"id":226201,"goal":"function Factorial_6186(n: nat): nat\n ensures Factorial_6186(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_6186(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_6187","instance":6187,"id":226202,"goal":"function Fib_6187(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_6187(n-1) + Fib_6187(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_6188","instance":6188,"id":226203,"goal":"function Gcd_6188(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_6188(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_6189","instance":6189,"id":226204,"goal":"function Power_6189(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_6189(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_6190","instance":6190,"id":226205,"goal":"function Sum_6190(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_6190(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_6191","instance":6191,"id":226206,"goal":"method BinarySearch_6191(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_6192","instance":6192,"id":226207,"goal":"method InsertSort_6192(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_6193","instance":6193,"id":226208,"goal":"method MergeSort_6193(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_6194","instance":6194,"id":226209,"goal":"method ArrayCopy_6194(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_6195","instance":6195,"id":226210,"goal":"function ListReverse_6195(s: seq): seq\n ensures |ListReverse_6195(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_6195(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_6196","instance":6196,"id":226211,"goal":"function Factorial_6196(n: nat): nat\n ensures Factorial_6196(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_6196(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_6197","instance":6197,"id":226212,"goal":"function Fib_6197(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_6197(n-1) + Fib_6197(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_6198","instance":6198,"id":226213,"goal":"function Gcd_6198(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_6198(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_6199","instance":6199,"id":226214,"goal":"function Power_6199(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_6199(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_6200","instance":6200,"id":226215,"goal":"function Sum_6200(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_6200(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_6201","instance":6201,"id":226216,"goal":"method BinarySearch_6201(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_6202","instance":6202,"id":226217,"goal":"method InsertSort_6202(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_6203","instance":6203,"id":226218,"goal":"method MergeSort_6203(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_6204","instance":6204,"id":226219,"goal":"method ArrayCopy_6204(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_6205","instance":6205,"id":226220,"goal":"function ListReverse_6205(s: seq): seq\n ensures |ListReverse_6205(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_6205(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_6206","instance":6206,"id":226221,"goal":"function Factorial_6206(n: nat): nat\n ensures Factorial_6206(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_6206(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_6207","instance":6207,"id":226222,"goal":"function Fib_6207(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_6207(n-1) + Fib_6207(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_6208","instance":6208,"id":226223,"goal":"function Gcd_6208(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_6208(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_6209","instance":6209,"id":226224,"goal":"function Power_6209(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_6209(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_6210","instance":6210,"id":226225,"goal":"function Sum_6210(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_6210(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_6211","instance":6211,"id":226226,"goal":"method BinarySearch_6211(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_6212","instance":6212,"id":226227,"goal":"method InsertSort_6212(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_6213","instance":6213,"id":226228,"goal":"method MergeSort_6213(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_6214","instance":6214,"id":226229,"goal":"method ArrayCopy_6214(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_6215","instance":6215,"id":226230,"goal":"function ListReverse_6215(s: seq): seq\n ensures |ListReverse_6215(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_6215(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_6216","instance":6216,"id":226231,"goal":"function Factorial_6216(n: nat): nat\n ensures Factorial_6216(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_6216(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_6217","instance":6217,"id":226232,"goal":"function Fib_6217(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_6217(n-1) + Fib_6217(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_6218","instance":6218,"id":226233,"goal":"function Gcd_6218(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_6218(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_6219","instance":6219,"id":226234,"goal":"function Power_6219(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_6219(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_6220","instance":6220,"id":226235,"goal":"function Sum_6220(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_6220(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_6221","instance":6221,"id":226236,"goal":"method BinarySearch_6221(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_6222","instance":6222,"id":226237,"goal":"method InsertSort_6222(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_6223","instance":6223,"id":226238,"goal":"method MergeSort_6223(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_6224","instance":6224,"id":226239,"goal":"method ArrayCopy_6224(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_6225","instance":6225,"id":226240,"goal":"function ListReverse_6225(s: seq): seq\n ensures |ListReverse_6225(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_6225(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_6226","instance":6226,"id":226241,"goal":"function Factorial_6226(n: nat): nat\n ensures Factorial_6226(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_6226(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_6227","instance":6227,"id":226242,"goal":"function Fib_6227(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_6227(n-1) + Fib_6227(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_6228","instance":6228,"id":226243,"goal":"function Gcd_6228(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_6228(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_6229","instance":6229,"id":226244,"goal":"function Power_6229(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_6229(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_6230","instance":6230,"id":226245,"goal":"function Sum_6230(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_6230(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_6231","instance":6231,"id":226246,"goal":"method BinarySearch_6231(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_6232","instance":6232,"id":226247,"goal":"method InsertSort_6232(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_6233","instance":6233,"id":226248,"goal":"method MergeSort_6233(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_6234","instance":6234,"id":226249,"goal":"method ArrayCopy_6234(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_6235","instance":6235,"id":226250,"goal":"function ListReverse_6235(s: seq): seq\n ensures |ListReverse_6235(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_6235(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_6236","instance":6236,"id":226251,"goal":"function Factorial_6236(n: nat): nat\n ensures Factorial_6236(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_6236(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_6237","instance":6237,"id":226252,"goal":"function Fib_6237(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_6237(n-1) + Fib_6237(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_6238","instance":6238,"id":226253,"goal":"function Gcd_6238(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_6238(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_6239","instance":6239,"id":226254,"goal":"function Power_6239(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_6239(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_6240","instance":6240,"id":226255,"goal":"function Sum_6240(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_6240(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_6241","instance":6241,"id":226256,"goal":"method BinarySearch_6241(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_6242","instance":6242,"id":226257,"goal":"method InsertSort_6242(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_6243","instance":6243,"id":226258,"goal":"method MergeSort_6243(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_6244","instance":6244,"id":226259,"goal":"method ArrayCopy_6244(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_6245","instance":6245,"id":226260,"goal":"function ListReverse_6245(s: seq): seq\n ensures |ListReverse_6245(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_6245(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_6246","instance":6246,"id":226261,"goal":"function Factorial_6246(n: nat): nat\n ensures Factorial_6246(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_6246(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_6247","instance":6247,"id":226262,"goal":"function Fib_6247(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_6247(n-1) + Fib_6247(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_6248","instance":6248,"id":226263,"goal":"function Gcd_6248(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_6248(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_6249","instance":6249,"id":226264,"goal":"function Power_6249(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_6249(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_6250","instance":6250,"id":226265,"goal":"function Sum_6250(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_6250(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_6251","instance":6251,"id":226266,"goal":"method BinarySearch_6251(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_6252","instance":6252,"id":226267,"goal":"method InsertSort_6252(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_6253","instance":6253,"id":226268,"goal":"method MergeSort_6253(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_6254","instance":6254,"id":226269,"goal":"method ArrayCopy_6254(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_6255","instance":6255,"id":226270,"goal":"function ListReverse_6255(s: seq): seq\n ensures |ListReverse_6255(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_6255(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_6256","instance":6256,"id":226271,"goal":"function Factorial_6256(n: nat): nat\n ensures Factorial_6256(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_6256(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_6257","instance":6257,"id":226272,"goal":"function Fib_6257(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_6257(n-1) + Fib_6257(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_6258","instance":6258,"id":226273,"goal":"function Gcd_6258(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_6258(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_6259","instance":6259,"id":226274,"goal":"function Power_6259(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_6259(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_6260","instance":6260,"id":226275,"goal":"function Sum_6260(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_6260(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_6261","instance":6261,"id":226276,"goal":"method BinarySearch_6261(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_6262","instance":6262,"id":226277,"goal":"method InsertSort_6262(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_6263","instance":6263,"id":226278,"goal":"method MergeSort_6263(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_6264","instance":6264,"id":226279,"goal":"method ArrayCopy_6264(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_6265","instance":6265,"id":226280,"goal":"function ListReverse_6265(s: seq): seq\n ensures |ListReverse_6265(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_6265(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_6266","instance":6266,"id":226281,"goal":"function Factorial_6266(n: nat): nat\n ensures Factorial_6266(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_6266(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_6267","instance":6267,"id":226282,"goal":"function Fib_6267(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_6267(n-1) + Fib_6267(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_6268","instance":6268,"id":226283,"goal":"function Gcd_6268(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_6268(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_6269","instance":6269,"id":226284,"goal":"function Power_6269(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_6269(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_6270","instance":6270,"id":226285,"goal":"function Sum_6270(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_6270(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_6271","instance":6271,"id":226286,"goal":"method BinarySearch_6271(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_6272","instance":6272,"id":226287,"goal":"method InsertSort_6272(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_6273","instance":6273,"id":226288,"goal":"method MergeSort_6273(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_6274","instance":6274,"id":226289,"goal":"method ArrayCopy_6274(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_6275","instance":6275,"id":226290,"goal":"function ListReverse_6275(s: seq): seq\n ensures |ListReverse_6275(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_6275(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_6276","instance":6276,"id":226291,"goal":"function Factorial_6276(n: nat): nat\n ensures Factorial_6276(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_6276(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_6277","instance":6277,"id":226292,"goal":"function Fib_6277(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_6277(n-1) + Fib_6277(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_6278","instance":6278,"id":226293,"goal":"function Gcd_6278(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_6278(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_6279","instance":6279,"id":226294,"goal":"function Power_6279(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_6279(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_6280","instance":6280,"id":226295,"goal":"function Sum_6280(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_6280(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_6281","instance":6281,"id":226296,"goal":"method BinarySearch_6281(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_6282","instance":6282,"id":226297,"goal":"method InsertSort_6282(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_6283","instance":6283,"id":226298,"goal":"method MergeSort_6283(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_6284","instance":6284,"id":226299,"goal":"method ArrayCopy_6284(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_6285","instance":6285,"id":226300,"goal":"function ListReverse_6285(s: seq): seq\n ensures |ListReverse_6285(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_6285(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_6286","instance":6286,"id":226301,"goal":"function Factorial_6286(n: nat): nat\n ensures Factorial_6286(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_6286(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_6287","instance":6287,"id":226302,"goal":"function Fib_6287(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_6287(n-1) + Fib_6287(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_6288","instance":6288,"id":226303,"goal":"function Gcd_6288(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_6288(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_6289","instance":6289,"id":226304,"goal":"function Power_6289(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_6289(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_6290","instance":6290,"id":226305,"goal":"function Sum_6290(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_6290(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_6291","instance":6291,"id":226306,"goal":"method BinarySearch_6291(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_6292","instance":6292,"id":226307,"goal":"method InsertSort_6292(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_6293","instance":6293,"id":226308,"goal":"method MergeSort_6293(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_6294","instance":6294,"id":226309,"goal":"method ArrayCopy_6294(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_6295","instance":6295,"id":226310,"goal":"function ListReverse_6295(s: seq): seq\n ensures |ListReverse_6295(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_6295(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_6296","instance":6296,"id":226311,"goal":"function Factorial_6296(n: nat): nat\n ensures Factorial_6296(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_6296(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_6297","instance":6297,"id":226312,"goal":"function Fib_6297(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_6297(n-1) + Fib_6297(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_6298","instance":6298,"id":226313,"goal":"function Gcd_6298(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_6298(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_6299","instance":6299,"id":226314,"goal":"function Power_6299(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_6299(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_6300","instance":6300,"id":226315,"goal":"function Sum_6300(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_6300(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_6301","instance":6301,"id":226316,"goal":"method BinarySearch_6301(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_6302","instance":6302,"id":226317,"goal":"method InsertSort_6302(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_6303","instance":6303,"id":226318,"goal":"method MergeSort_6303(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_6304","instance":6304,"id":226319,"goal":"method ArrayCopy_6304(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_6305","instance":6305,"id":226320,"goal":"function ListReverse_6305(s: seq): seq\n ensures |ListReverse_6305(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_6305(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_6306","instance":6306,"id":226321,"goal":"function Factorial_6306(n: nat): nat\n ensures Factorial_6306(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_6306(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_6307","instance":6307,"id":226322,"goal":"function Fib_6307(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_6307(n-1) + Fib_6307(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_6308","instance":6308,"id":226323,"goal":"function Gcd_6308(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_6308(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_6309","instance":6309,"id":226324,"goal":"function Power_6309(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_6309(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_6310","instance":6310,"id":226325,"goal":"function Sum_6310(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_6310(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_6311","instance":6311,"id":226326,"goal":"method BinarySearch_6311(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_6312","instance":6312,"id":226327,"goal":"method InsertSort_6312(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_6313","instance":6313,"id":226328,"goal":"method MergeSort_6313(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_6314","instance":6314,"id":226329,"goal":"method ArrayCopy_6314(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_6315","instance":6315,"id":226330,"goal":"function ListReverse_6315(s: seq): seq\n ensures |ListReverse_6315(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_6315(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_6316","instance":6316,"id":226331,"goal":"function Factorial_6316(n: nat): nat\n ensures Factorial_6316(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_6316(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_6317","instance":6317,"id":226332,"goal":"function Fib_6317(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_6317(n-1) + Fib_6317(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_6318","instance":6318,"id":226333,"goal":"function Gcd_6318(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_6318(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_6319","instance":6319,"id":226334,"goal":"function Power_6319(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_6319(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_6320","instance":6320,"id":226335,"goal":"function Sum_6320(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_6320(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_6321","instance":6321,"id":226336,"goal":"method BinarySearch_6321(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_6322","instance":6322,"id":226337,"goal":"method InsertSort_6322(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_6323","instance":6323,"id":226338,"goal":"method MergeSort_6323(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_6324","instance":6324,"id":226339,"goal":"method ArrayCopy_6324(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_6325","instance":6325,"id":226340,"goal":"function ListReverse_6325(s: seq): seq\n ensures |ListReverse_6325(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_6325(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_6326","instance":6326,"id":226341,"goal":"function Factorial_6326(n: nat): nat\n ensures Factorial_6326(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_6326(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_6327","instance":6327,"id":226342,"goal":"function Fib_6327(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_6327(n-1) + Fib_6327(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_6328","instance":6328,"id":226343,"goal":"function Gcd_6328(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_6328(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_6329","instance":6329,"id":226344,"goal":"function Power_6329(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_6329(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_6330","instance":6330,"id":226345,"goal":"function Sum_6330(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_6330(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_6331","instance":6331,"id":226346,"goal":"method BinarySearch_6331(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_6332","instance":6332,"id":226347,"goal":"method InsertSort_6332(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_6333","instance":6333,"id":226348,"goal":"method MergeSort_6333(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_6334","instance":6334,"id":226349,"goal":"method ArrayCopy_6334(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_6335","instance":6335,"id":226350,"goal":"function ListReverse_6335(s: seq): seq\n ensures |ListReverse_6335(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_6335(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_6336","instance":6336,"id":226351,"goal":"function Factorial_6336(n: nat): nat\n ensures Factorial_6336(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_6336(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_6337","instance":6337,"id":226352,"goal":"function Fib_6337(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_6337(n-1) + Fib_6337(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_6338","instance":6338,"id":226353,"goal":"function Gcd_6338(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_6338(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_6339","instance":6339,"id":226354,"goal":"function Power_6339(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_6339(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_6340","instance":6340,"id":226355,"goal":"function Sum_6340(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_6340(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_6341","instance":6341,"id":226356,"goal":"method BinarySearch_6341(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_6342","instance":6342,"id":226357,"goal":"method InsertSort_6342(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_6343","instance":6343,"id":226358,"goal":"method MergeSort_6343(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_6344","instance":6344,"id":226359,"goal":"method ArrayCopy_6344(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_6345","instance":6345,"id":226360,"goal":"function ListReverse_6345(s: seq): seq\n ensures |ListReverse_6345(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_6345(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_6346","instance":6346,"id":226361,"goal":"function Factorial_6346(n: nat): nat\n ensures Factorial_6346(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_6346(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_6347","instance":6347,"id":226362,"goal":"function Fib_6347(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_6347(n-1) + Fib_6347(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_6348","instance":6348,"id":226363,"goal":"function Gcd_6348(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_6348(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_6349","instance":6349,"id":226364,"goal":"function Power_6349(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_6349(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_6350","instance":6350,"id":226365,"goal":"function Sum_6350(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_6350(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_6351","instance":6351,"id":226366,"goal":"method BinarySearch_6351(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_6352","instance":6352,"id":226367,"goal":"method InsertSort_6352(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_6353","instance":6353,"id":226368,"goal":"method MergeSort_6353(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_6354","instance":6354,"id":226369,"goal":"method ArrayCopy_6354(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_6355","instance":6355,"id":226370,"goal":"function ListReverse_6355(s: seq): seq\n ensures |ListReverse_6355(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_6355(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_6356","instance":6356,"id":226371,"goal":"function Factorial_6356(n: nat): nat\n ensures Factorial_6356(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_6356(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_6357","instance":6357,"id":226372,"goal":"function Fib_6357(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_6357(n-1) + Fib_6357(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_6358","instance":6358,"id":226373,"goal":"function Gcd_6358(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_6358(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_6359","instance":6359,"id":226374,"goal":"function Power_6359(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_6359(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_6360","instance":6360,"id":226375,"goal":"function Sum_6360(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_6360(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_6361","instance":6361,"id":226376,"goal":"method BinarySearch_6361(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_6362","instance":6362,"id":226377,"goal":"method InsertSort_6362(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_6363","instance":6363,"id":226378,"goal":"method MergeSort_6363(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_6364","instance":6364,"id":226379,"goal":"method ArrayCopy_6364(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_6365","instance":6365,"id":226380,"goal":"function ListReverse_6365(s: seq): seq\n ensures |ListReverse_6365(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_6365(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_6366","instance":6366,"id":226381,"goal":"function Factorial_6366(n: nat): nat\n ensures Factorial_6366(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_6366(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_6367","instance":6367,"id":226382,"goal":"function Fib_6367(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_6367(n-1) + Fib_6367(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_6368","instance":6368,"id":226383,"goal":"function Gcd_6368(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_6368(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_6369","instance":6369,"id":226384,"goal":"function Power_6369(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_6369(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_6370","instance":6370,"id":226385,"goal":"function Sum_6370(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_6370(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_6371","instance":6371,"id":226386,"goal":"method BinarySearch_6371(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_6372","instance":6372,"id":226387,"goal":"method InsertSort_6372(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_6373","instance":6373,"id":226388,"goal":"method MergeSort_6373(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_6374","instance":6374,"id":226389,"goal":"method ArrayCopy_6374(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_6375","instance":6375,"id":226390,"goal":"function ListReverse_6375(s: seq): seq\n ensures |ListReverse_6375(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_6375(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_6376","instance":6376,"id":226391,"goal":"function Factorial_6376(n: nat): nat\n ensures Factorial_6376(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_6376(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_6377","instance":6377,"id":226392,"goal":"function Fib_6377(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_6377(n-1) + Fib_6377(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_6378","instance":6378,"id":226393,"goal":"function Gcd_6378(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_6378(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_6379","instance":6379,"id":226394,"goal":"function Power_6379(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_6379(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_6380","instance":6380,"id":226395,"goal":"function Sum_6380(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_6380(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_6381","instance":6381,"id":226396,"goal":"method BinarySearch_6381(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_6382","instance":6382,"id":226397,"goal":"method InsertSort_6382(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_6383","instance":6383,"id":226398,"goal":"method MergeSort_6383(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_6384","instance":6384,"id":226399,"goal":"method ArrayCopy_6384(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_6385","instance":6385,"id":226400,"goal":"function ListReverse_6385(s: seq): seq\n ensures |ListReverse_6385(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_6385(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_6386","instance":6386,"id":226401,"goal":"function Factorial_6386(n: nat): nat\n ensures Factorial_6386(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_6386(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_6387","instance":6387,"id":226402,"goal":"function Fib_6387(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_6387(n-1) + Fib_6387(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_6388","instance":6388,"id":226403,"goal":"function Gcd_6388(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_6388(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_6389","instance":6389,"id":226404,"goal":"function Power_6389(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_6389(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_6390","instance":6390,"id":226405,"goal":"function Sum_6390(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_6390(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_6391","instance":6391,"id":226406,"goal":"method BinarySearch_6391(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_6392","instance":6392,"id":226407,"goal":"method InsertSort_6392(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_6393","instance":6393,"id":226408,"goal":"method MergeSort_6393(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_6394","instance":6394,"id":226409,"goal":"method ArrayCopy_6394(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_6395","instance":6395,"id":226410,"goal":"function ListReverse_6395(s: seq): seq\n ensures |ListReverse_6395(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_6395(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_6396","instance":6396,"id":226411,"goal":"function Factorial_6396(n: nat): nat\n ensures Factorial_6396(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_6396(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_6397","instance":6397,"id":226412,"goal":"function Fib_6397(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_6397(n-1) + Fib_6397(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_6398","instance":6398,"id":226413,"goal":"function Gcd_6398(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_6398(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_6399","instance":6399,"id":226414,"goal":"function Power_6399(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_6399(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_6400","instance":6400,"id":226415,"goal":"function Sum_6400(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_6400(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_6401","instance":6401,"id":226416,"goal":"method BinarySearch_6401(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_6402","instance":6402,"id":226417,"goal":"method InsertSort_6402(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_6403","instance":6403,"id":226418,"goal":"method MergeSort_6403(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_6404","instance":6404,"id":226419,"goal":"method ArrayCopy_6404(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_6405","instance":6405,"id":226420,"goal":"function ListReverse_6405(s: seq): seq\n ensures |ListReverse_6405(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_6405(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_6406","instance":6406,"id":226421,"goal":"function Factorial_6406(n: nat): nat\n ensures Factorial_6406(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_6406(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_6407","instance":6407,"id":226422,"goal":"function Fib_6407(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_6407(n-1) + Fib_6407(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_6408","instance":6408,"id":226423,"goal":"function Gcd_6408(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_6408(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_6409","instance":6409,"id":226424,"goal":"function Power_6409(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_6409(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_6410","instance":6410,"id":226425,"goal":"function Sum_6410(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_6410(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_6411","instance":6411,"id":226426,"goal":"method BinarySearch_6411(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_6412","instance":6412,"id":226427,"goal":"method InsertSort_6412(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_6413","instance":6413,"id":226428,"goal":"method MergeSort_6413(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_6414","instance":6414,"id":226429,"goal":"method ArrayCopy_6414(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_6415","instance":6415,"id":226430,"goal":"function ListReverse_6415(s: seq): seq\n ensures |ListReverse_6415(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_6415(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_6416","instance":6416,"id":226431,"goal":"function Factorial_6416(n: nat): nat\n ensures Factorial_6416(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_6416(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_6417","instance":6417,"id":226432,"goal":"function Fib_6417(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_6417(n-1) + Fib_6417(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_6418","instance":6418,"id":226433,"goal":"function Gcd_6418(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_6418(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_6419","instance":6419,"id":226434,"goal":"function Power_6419(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_6419(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_6420","instance":6420,"id":226435,"goal":"function Sum_6420(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_6420(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_6421","instance":6421,"id":226436,"goal":"method BinarySearch_6421(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_6422","instance":6422,"id":226437,"goal":"method InsertSort_6422(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_6423","instance":6423,"id":226438,"goal":"method MergeSort_6423(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_6424","instance":6424,"id":226439,"goal":"method ArrayCopy_6424(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_6425","instance":6425,"id":226440,"goal":"function ListReverse_6425(s: seq): seq\n ensures |ListReverse_6425(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_6425(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_6426","instance":6426,"id":226441,"goal":"function Factorial_6426(n: nat): nat\n ensures Factorial_6426(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_6426(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_6427","instance":6427,"id":226442,"goal":"function Fib_6427(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_6427(n-1) + Fib_6427(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_6428","instance":6428,"id":226443,"goal":"function Gcd_6428(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_6428(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_6429","instance":6429,"id":226444,"goal":"function Power_6429(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_6429(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_6430","instance":6430,"id":226445,"goal":"function Sum_6430(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_6430(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_6431","instance":6431,"id":226446,"goal":"method BinarySearch_6431(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_6432","instance":6432,"id":226447,"goal":"method InsertSort_6432(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_6433","instance":6433,"id":226448,"goal":"method MergeSort_6433(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_6434","instance":6434,"id":226449,"goal":"method ArrayCopy_6434(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_6435","instance":6435,"id":226450,"goal":"function ListReverse_6435(s: seq): seq\n ensures |ListReverse_6435(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_6435(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_6436","instance":6436,"id":226451,"goal":"function Factorial_6436(n: nat): nat\n ensures Factorial_6436(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_6436(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_6437","instance":6437,"id":226452,"goal":"function Fib_6437(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_6437(n-1) + Fib_6437(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_6438","instance":6438,"id":226453,"goal":"function Gcd_6438(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_6438(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_6439","instance":6439,"id":226454,"goal":"function Power_6439(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_6439(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_6440","instance":6440,"id":226455,"goal":"function Sum_6440(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_6440(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_6441","instance":6441,"id":226456,"goal":"method BinarySearch_6441(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_6442","instance":6442,"id":226457,"goal":"method InsertSort_6442(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_6443","instance":6443,"id":226458,"goal":"method MergeSort_6443(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_6444","instance":6444,"id":226459,"goal":"method ArrayCopy_6444(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_6445","instance":6445,"id":226460,"goal":"function ListReverse_6445(s: seq): seq\n ensures |ListReverse_6445(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_6445(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_6446","instance":6446,"id":226461,"goal":"function Factorial_6446(n: nat): nat\n ensures Factorial_6446(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_6446(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_6447","instance":6447,"id":226462,"goal":"function Fib_6447(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_6447(n-1) + Fib_6447(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_6448","instance":6448,"id":226463,"goal":"function Gcd_6448(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_6448(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_6449","instance":6449,"id":226464,"goal":"function Power_6449(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_6449(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_6450","instance":6450,"id":226465,"goal":"function Sum_6450(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_6450(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_6451","instance":6451,"id":226466,"goal":"method BinarySearch_6451(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_6452","instance":6452,"id":226467,"goal":"method InsertSort_6452(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_6453","instance":6453,"id":226468,"goal":"method MergeSort_6453(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_6454","instance":6454,"id":226469,"goal":"method ArrayCopy_6454(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_6455","instance":6455,"id":226470,"goal":"function ListReverse_6455(s: seq): seq\n ensures |ListReverse_6455(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_6455(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_6456","instance":6456,"id":226471,"goal":"function Factorial_6456(n: nat): nat\n ensures Factorial_6456(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_6456(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_6457","instance":6457,"id":226472,"goal":"function Fib_6457(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_6457(n-1) + Fib_6457(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_6458","instance":6458,"id":226473,"goal":"function Gcd_6458(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_6458(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_6459","instance":6459,"id":226474,"goal":"function Power_6459(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_6459(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_6460","instance":6460,"id":226475,"goal":"function Sum_6460(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_6460(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_6461","instance":6461,"id":226476,"goal":"method BinarySearch_6461(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_6462","instance":6462,"id":226477,"goal":"method InsertSort_6462(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_6463","instance":6463,"id":226478,"goal":"method MergeSort_6463(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_6464","instance":6464,"id":226479,"goal":"method ArrayCopy_6464(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_6465","instance":6465,"id":226480,"goal":"function ListReverse_6465(s: seq): seq\n ensures |ListReverse_6465(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_6465(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_6466","instance":6466,"id":226481,"goal":"function Factorial_6466(n: nat): nat\n ensures Factorial_6466(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_6466(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_6467","instance":6467,"id":226482,"goal":"function Fib_6467(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_6467(n-1) + Fib_6467(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_6468","instance":6468,"id":226483,"goal":"function Gcd_6468(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_6468(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_6469","instance":6469,"id":226484,"goal":"function Power_6469(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_6469(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_6470","instance":6470,"id":226485,"goal":"function Sum_6470(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_6470(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_6471","instance":6471,"id":226486,"goal":"method BinarySearch_6471(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_6472","instance":6472,"id":226487,"goal":"method InsertSort_6472(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_6473","instance":6473,"id":226488,"goal":"method MergeSort_6473(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_6474","instance":6474,"id":226489,"goal":"method ArrayCopy_6474(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_6475","instance":6475,"id":226490,"goal":"function ListReverse_6475(s: seq): seq\n ensures |ListReverse_6475(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_6475(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_6476","instance":6476,"id":226491,"goal":"function Factorial_6476(n: nat): nat\n ensures Factorial_6476(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_6476(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_6477","instance":6477,"id":226492,"goal":"function Fib_6477(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_6477(n-1) + Fib_6477(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_6478","instance":6478,"id":226493,"goal":"function Gcd_6478(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_6478(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_6479","instance":6479,"id":226494,"goal":"function Power_6479(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_6479(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_6480","instance":6480,"id":226495,"goal":"function Sum_6480(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_6480(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_6481","instance":6481,"id":226496,"goal":"method BinarySearch_6481(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_6482","instance":6482,"id":226497,"goal":"method InsertSort_6482(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_6483","instance":6483,"id":226498,"goal":"method MergeSort_6483(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_6484","instance":6484,"id":226499,"goal":"method ArrayCopy_6484(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_6485","instance":6485,"id":226500,"goal":"function ListReverse_6485(s: seq): seq\n ensures |ListReverse_6485(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_6485(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_6486","instance":6486,"id":226501,"goal":"function Factorial_6486(n: nat): nat\n ensures Factorial_6486(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_6486(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_6487","instance":6487,"id":226502,"goal":"function Fib_6487(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_6487(n-1) + Fib_6487(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_6488","instance":6488,"id":226503,"goal":"function Gcd_6488(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_6488(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_6489","instance":6489,"id":226504,"goal":"function Power_6489(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_6489(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_6490","instance":6490,"id":226505,"goal":"function Sum_6490(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_6490(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_6491","instance":6491,"id":226506,"goal":"method BinarySearch_6491(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_6492","instance":6492,"id":226507,"goal":"method InsertSort_6492(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_6493","instance":6493,"id":226508,"goal":"method MergeSort_6493(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_6494","instance":6494,"id":226509,"goal":"method ArrayCopy_6494(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_6495","instance":6495,"id":226510,"goal":"function ListReverse_6495(s: seq): seq\n ensures |ListReverse_6495(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_6495(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_6496","instance":6496,"id":226511,"goal":"function Factorial_6496(n: nat): nat\n ensures Factorial_6496(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_6496(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_6497","instance":6497,"id":226512,"goal":"function Fib_6497(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_6497(n-1) + Fib_6497(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_6498","instance":6498,"id":226513,"goal":"function Gcd_6498(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_6498(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_6499","instance":6499,"id":226514,"goal":"function Power_6499(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_6499(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_6500","instance":6500,"id":226515,"goal":"function Sum_6500(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_6500(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_6501","instance":6501,"id":226516,"goal":"method BinarySearch_6501(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_6502","instance":6502,"id":226517,"goal":"method InsertSort_6502(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_6503","instance":6503,"id":226518,"goal":"method MergeSort_6503(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_6504","instance":6504,"id":226519,"goal":"method ArrayCopy_6504(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_6505","instance":6505,"id":226520,"goal":"function ListReverse_6505(s: seq): seq\n ensures |ListReverse_6505(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_6505(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_6506","instance":6506,"id":226521,"goal":"function Factorial_6506(n: nat): nat\n ensures Factorial_6506(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_6506(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_6507","instance":6507,"id":226522,"goal":"function Fib_6507(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_6507(n-1) + Fib_6507(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_6508","instance":6508,"id":226523,"goal":"function Gcd_6508(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_6508(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_6509","instance":6509,"id":226524,"goal":"function Power_6509(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_6509(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_6510","instance":6510,"id":226525,"goal":"function Sum_6510(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_6510(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_6511","instance":6511,"id":226526,"goal":"method BinarySearch_6511(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_6512","instance":6512,"id":226527,"goal":"method InsertSort_6512(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_6513","instance":6513,"id":226528,"goal":"method MergeSort_6513(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_6514","instance":6514,"id":226529,"goal":"method ArrayCopy_6514(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_6515","instance":6515,"id":226530,"goal":"function ListReverse_6515(s: seq): seq\n ensures |ListReverse_6515(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_6515(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_6516","instance":6516,"id":226531,"goal":"function Factorial_6516(n: nat): nat\n ensures Factorial_6516(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_6516(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_6517","instance":6517,"id":226532,"goal":"function Fib_6517(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_6517(n-1) + Fib_6517(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_6518","instance":6518,"id":226533,"goal":"function Gcd_6518(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_6518(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_6519","instance":6519,"id":226534,"goal":"function Power_6519(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_6519(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_6520","instance":6520,"id":226535,"goal":"function Sum_6520(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_6520(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_6521","instance":6521,"id":226536,"goal":"method BinarySearch_6521(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_6522","instance":6522,"id":226537,"goal":"method InsertSort_6522(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_6523","instance":6523,"id":226538,"goal":"method MergeSort_6523(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_6524","instance":6524,"id":226539,"goal":"method ArrayCopy_6524(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_6525","instance":6525,"id":226540,"goal":"function ListReverse_6525(s: seq): seq\n ensures |ListReverse_6525(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_6525(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_6526","instance":6526,"id":226541,"goal":"function Factorial_6526(n: nat): nat\n ensures Factorial_6526(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_6526(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_6527","instance":6527,"id":226542,"goal":"function Fib_6527(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_6527(n-1) + Fib_6527(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_6528","instance":6528,"id":226543,"goal":"function Gcd_6528(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_6528(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_6529","instance":6529,"id":226544,"goal":"function Power_6529(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_6529(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_6530","instance":6530,"id":226545,"goal":"function Sum_6530(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_6530(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_6531","instance":6531,"id":226546,"goal":"method BinarySearch_6531(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_6532","instance":6532,"id":226547,"goal":"method InsertSort_6532(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_6533","instance":6533,"id":226548,"goal":"method MergeSort_6533(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_6534","instance":6534,"id":226549,"goal":"method ArrayCopy_6534(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_6535","instance":6535,"id":226550,"goal":"function ListReverse_6535(s: seq): seq\n ensures |ListReverse_6535(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_6535(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_6536","instance":6536,"id":226551,"goal":"function Factorial_6536(n: nat): nat\n ensures Factorial_6536(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_6536(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_6537","instance":6537,"id":226552,"goal":"function Fib_6537(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_6537(n-1) + Fib_6537(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_6538","instance":6538,"id":226553,"goal":"function Gcd_6538(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_6538(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_6539","instance":6539,"id":226554,"goal":"function Power_6539(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_6539(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_6540","instance":6540,"id":226555,"goal":"function Sum_6540(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_6540(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_6541","instance":6541,"id":226556,"goal":"method BinarySearch_6541(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_6542","instance":6542,"id":226557,"goal":"method InsertSort_6542(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_6543","instance":6543,"id":226558,"goal":"method MergeSort_6543(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_6544","instance":6544,"id":226559,"goal":"method ArrayCopy_6544(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_6545","instance":6545,"id":226560,"goal":"function ListReverse_6545(s: seq): seq\n ensures |ListReverse_6545(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_6545(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_6546","instance":6546,"id":226561,"goal":"function Factorial_6546(n: nat): nat\n ensures Factorial_6546(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_6546(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_6547","instance":6547,"id":226562,"goal":"function Fib_6547(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_6547(n-1) + Fib_6547(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_6548","instance":6548,"id":226563,"goal":"function Gcd_6548(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_6548(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_6549","instance":6549,"id":226564,"goal":"function Power_6549(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_6549(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_6550","instance":6550,"id":226565,"goal":"function Sum_6550(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_6550(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_6551","instance":6551,"id":226566,"goal":"method BinarySearch_6551(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_6552","instance":6552,"id":226567,"goal":"method InsertSort_6552(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_6553","instance":6553,"id":226568,"goal":"method MergeSort_6553(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_6554","instance":6554,"id":226569,"goal":"method ArrayCopy_6554(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_6555","instance":6555,"id":226570,"goal":"function ListReverse_6555(s: seq): seq\n ensures |ListReverse_6555(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_6555(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_6556","instance":6556,"id":226571,"goal":"function Factorial_6556(n: nat): nat\n ensures Factorial_6556(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_6556(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_6557","instance":6557,"id":226572,"goal":"function Fib_6557(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_6557(n-1) + Fib_6557(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_6558","instance":6558,"id":226573,"goal":"function Gcd_6558(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_6558(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_6559","instance":6559,"id":226574,"goal":"function Power_6559(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_6559(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_6560","instance":6560,"id":226575,"goal":"function Sum_6560(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_6560(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_6561","instance":6561,"id":226576,"goal":"method BinarySearch_6561(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_6562","instance":6562,"id":226577,"goal":"method InsertSort_6562(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_6563","instance":6563,"id":226578,"goal":"method MergeSort_6563(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_6564","instance":6564,"id":226579,"goal":"method ArrayCopy_6564(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_6565","instance":6565,"id":226580,"goal":"function ListReverse_6565(s: seq): seq\n ensures |ListReverse_6565(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_6565(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_6566","instance":6566,"id":226581,"goal":"function Factorial_6566(n: nat): nat\n ensures Factorial_6566(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_6566(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_6567","instance":6567,"id":226582,"goal":"function Fib_6567(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_6567(n-1) + Fib_6567(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_6568","instance":6568,"id":226583,"goal":"function Gcd_6568(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_6568(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_6569","instance":6569,"id":226584,"goal":"function Power_6569(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_6569(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_6570","instance":6570,"id":226585,"goal":"function Sum_6570(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_6570(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_6571","instance":6571,"id":226586,"goal":"method BinarySearch_6571(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_6572","instance":6572,"id":226587,"goal":"method InsertSort_6572(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_6573","instance":6573,"id":226588,"goal":"method MergeSort_6573(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_6574","instance":6574,"id":226589,"goal":"method ArrayCopy_6574(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_6575","instance":6575,"id":226590,"goal":"function ListReverse_6575(s: seq): seq\n ensures |ListReverse_6575(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_6575(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_6576","instance":6576,"id":226591,"goal":"function Factorial_6576(n: nat): nat\n ensures Factorial_6576(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_6576(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_6577","instance":6577,"id":226592,"goal":"function Fib_6577(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_6577(n-1) + Fib_6577(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_6578","instance":6578,"id":226593,"goal":"function Gcd_6578(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_6578(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_6579","instance":6579,"id":226594,"goal":"function Power_6579(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_6579(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_6580","instance":6580,"id":226595,"goal":"function Sum_6580(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_6580(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_6581","instance":6581,"id":226596,"goal":"method BinarySearch_6581(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_6582","instance":6582,"id":226597,"goal":"method InsertSort_6582(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_6583","instance":6583,"id":226598,"goal":"method MergeSort_6583(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_6584","instance":6584,"id":226599,"goal":"method ArrayCopy_6584(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_6585","instance":6585,"id":226600,"goal":"function ListReverse_6585(s: seq): seq\n ensures |ListReverse_6585(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_6585(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_6586","instance":6586,"id":226601,"goal":"function Factorial_6586(n: nat): nat\n ensures Factorial_6586(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_6586(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_6587","instance":6587,"id":226602,"goal":"function Fib_6587(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_6587(n-1) + Fib_6587(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_6588","instance":6588,"id":226603,"goal":"function Gcd_6588(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_6588(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_6589","instance":6589,"id":226604,"goal":"function Power_6589(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_6589(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_6590","instance":6590,"id":226605,"goal":"function Sum_6590(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_6590(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_6591","instance":6591,"id":226606,"goal":"method BinarySearch_6591(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_6592","instance":6592,"id":226607,"goal":"method InsertSort_6592(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_6593","instance":6593,"id":226608,"goal":"method MergeSort_6593(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_6594","instance":6594,"id":226609,"goal":"method ArrayCopy_6594(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_6595","instance":6595,"id":226610,"goal":"function ListReverse_6595(s: seq): seq\n ensures |ListReverse_6595(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_6595(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_6596","instance":6596,"id":226611,"goal":"function Factorial_6596(n: nat): nat\n ensures Factorial_6596(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_6596(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_6597","instance":6597,"id":226612,"goal":"function Fib_6597(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_6597(n-1) + Fib_6597(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_6598","instance":6598,"id":226613,"goal":"function Gcd_6598(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_6598(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_6599","instance":6599,"id":226614,"goal":"function Power_6599(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_6599(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_6600","instance":6600,"id":226615,"goal":"function Sum_6600(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_6600(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_6601","instance":6601,"id":226616,"goal":"method BinarySearch_6601(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_6602","instance":6602,"id":226617,"goal":"method InsertSort_6602(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_6603","instance":6603,"id":226618,"goal":"method MergeSort_6603(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_6604","instance":6604,"id":226619,"goal":"method ArrayCopy_6604(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_6605","instance":6605,"id":226620,"goal":"function ListReverse_6605(s: seq): seq\n ensures |ListReverse_6605(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_6605(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_6606","instance":6606,"id":226621,"goal":"function Factorial_6606(n: nat): nat\n ensures Factorial_6606(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_6606(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_6607","instance":6607,"id":226622,"goal":"function Fib_6607(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_6607(n-1) + Fib_6607(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_6608","instance":6608,"id":226623,"goal":"function Gcd_6608(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_6608(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_6609","instance":6609,"id":226624,"goal":"function Power_6609(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_6609(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_6610","instance":6610,"id":226625,"goal":"function Sum_6610(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_6610(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_6611","instance":6611,"id":226626,"goal":"method BinarySearch_6611(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_6612","instance":6612,"id":226627,"goal":"method InsertSort_6612(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_6613","instance":6613,"id":226628,"goal":"method MergeSort_6613(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_6614","instance":6614,"id":226629,"goal":"method ArrayCopy_6614(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_6615","instance":6615,"id":226630,"goal":"function ListReverse_6615(s: seq): seq\n ensures |ListReverse_6615(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_6615(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_6616","instance":6616,"id":226631,"goal":"function Factorial_6616(n: nat): nat\n ensures Factorial_6616(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_6616(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_6617","instance":6617,"id":226632,"goal":"function Fib_6617(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_6617(n-1) + Fib_6617(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_6618","instance":6618,"id":226633,"goal":"function Gcd_6618(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_6618(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_6619","instance":6619,"id":226634,"goal":"function Power_6619(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_6619(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_6620","instance":6620,"id":226635,"goal":"function Sum_6620(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_6620(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_6621","instance":6621,"id":226636,"goal":"method BinarySearch_6621(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_6622","instance":6622,"id":226637,"goal":"method InsertSort_6622(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_6623","instance":6623,"id":226638,"goal":"method MergeSort_6623(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_6624","instance":6624,"id":226639,"goal":"method ArrayCopy_6624(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_6625","instance":6625,"id":226640,"goal":"function ListReverse_6625(s: seq): seq\n ensures |ListReverse_6625(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_6625(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_6626","instance":6626,"id":226641,"goal":"function Factorial_6626(n: nat): nat\n ensures Factorial_6626(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_6626(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_6627","instance":6627,"id":226642,"goal":"function Fib_6627(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_6627(n-1) + Fib_6627(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_6628","instance":6628,"id":226643,"goal":"function Gcd_6628(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_6628(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_6629","instance":6629,"id":226644,"goal":"function Power_6629(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_6629(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_6630","instance":6630,"id":226645,"goal":"function Sum_6630(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_6630(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_6631","instance":6631,"id":226646,"goal":"method BinarySearch_6631(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_6632","instance":6632,"id":226647,"goal":"method InsertSort_6632(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_6633","instance":6633,"id":226648,"goal":"method MergeSort_6633(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_6634","instance":6634,"id":226649,"goal":"method ArrayCopy_6634(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_6635","instance":6635,"id":226650,"goal":"function ListReverse_6635(s: seq): seq\n ensures |ListReverse_6635(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_6635(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_6636","instance":6636,"id":226651,"goal":"function Factorial_6636(n: nat): nat\n ensures Factorial_6636(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_6636(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_6637","instance":6637,"id":226652,"goal":"function Fib_6637(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_6637(n-1) + Fib_6637(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_6638","instance":6638,"id":226653,"goal":"function Gcd_6638(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_6638(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_6639","instance":6639,"id":226654,"goal":"function Power_6639(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_6639(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_6640","instance":6640,"id":226655,"goal":"function Sum_6640(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_6640(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_6641","instance":6641,"id":226656,"goal":"method BinarySearch_6641(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_6642","instance":6642,"id":226657,"goal":"method InsertSort_6642(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_6643","instance":6643,"id":226658,"goal":"method MergeSort_6643(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_6644","instance":6644,"id":226659,"goal":"method ArrayCopy_6644(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_6645","instance":6645,"id":226660,"goal":"function ListReverse_6645(s: seq): seq\n ensures |ListReverse_6645(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_6645(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_6646","instance":6646,"id":226661,"goal":"function Factorial_6646(n: nat): nat\n ensures Factorial_6646(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_6646(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_6647","instance":6647,"id":226662,"goal":"function Fib_6647(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_6647(n-1) + Fib_6647(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_6648","instance":6648,"id":226663,"goal":"function Gcd_6648(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_6648(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_6649","instance":6649,"id":226664,"goal":"function Power_6649(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_6649(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_6650","instance":6650,"id":226665,"goal":"function Sum_6650(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_6650(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_6651","instance":6651,"id":226666,"goal":"method BinarySearch_6651(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_6652","instance":6652,"id":226667,"goal":"method InsertSort_6652(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_6653","instance":6653,"id":226668,"goal":"method MergeSort_6653(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_6654","instance":6654,"id":226669,"goal":"method ArrayCopy_6654(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_6655","instance":6655,"id":226670,"goal":"function ListReverse_6655(s: seq): seq\n ensures |ListReverse_6655(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_6655(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_6656","instance":6656,"id":226671,"goal":"function Factorial_6656(n: nat): nat\n ensures Factorial_6656(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_6656(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_6657","instance":6657,"id":226672,"goal":"function Fib_6657(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_6657(n-1) + Fib_6657(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_6658","instance":6658,"id":226673,"goal":"function Gcd_6658(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_6658(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_6659","instance":6659,"id":226674,"goal":"function Power_6659(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_6659(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_6660","instance":6660,"id":226675,"goal":"function Sum_6660(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_6660(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_6661","instance":6661,"id":226676,"goal":"method BinarySearch_6661(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_6662","instance":6662,"id":226677,"goal":"method InsertSort_6662(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_6663","instance":6663,"id":226678,"goal":"method MergeSort_6663(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_6664","instance":6664,"id":226679,"goal":"method ArrayCopy_6664(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_6665","instance":6665,"id":226680,"goal":"function ListReverse_6665(s: seq): seq\n ensures |ListReverse_6665(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_6665(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_6666","instance":6666,"id":226681,"goal":"function Factorial_6666(n: nat): nat\n ensures Factorial_6666(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_6666(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_6667","instance":6667,"id":226682,"goal":"function Fib_6667(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_6667(n-1) + Fib_6667(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_6668","instance":6668,"id":226683,"goal":"function Gcd_6668(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_6668(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_6669","instance":6669,"id":226684,"goal":"function Power_6669(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_6669(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_6670","instance":6670,"id":226685,"goal":"function Sum_6670(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_6670(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_6671","instance":6671,"id":226686,"goal":"method BinarySearch_6671(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_6672","instance":6672,"id":226687,"goal":"method InsertSort_6672(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_6673","instance":6673,"id":226688,"goal":"method MergeSort_6673(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_6674","instance":6674,"id":226689,"goal":"method ArrayCopy_6674(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_6675","instance":6675,"id":226690,"goal":"function ListReverse_6675(s: seq): seq\n ensures |ListReverse_6675(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_6675(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_6676","instance":6676,"id":226691,"goal":"function Factorial_6676(n: nat): nat\n ensures Factorial_6676(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_6676(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_6677","instance":6677,"id":226692,"goal":"function Fib_6677(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_6677(n-1) + Fib_6677(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_6678","instance":6678,"id":226693,"goal":"function Gcd_6678(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_6678(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_6679","instance":6679,"id":226694,"goal":"function Power_6679(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_6679(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_6680","instance":6680,"id":226695,"goal":"function Sum_6680(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_6680(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_6681","instance":6681,"id":226696,"goal":"method BinarySearch_6681(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_6682","instance":6682,"id":226697,"goal":"method InsertSort_6682(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_6683","instance":6683,"id":226698,"goal":"method MergeSort_6683(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_6684","instance":6684,"id":226699,"goal":"method ArrayCopy_6684(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_6685","instance":6685,"id":226700,"goal":"function ListReverse_6685(s: seq): seq\n ensures |ListReverse_6685(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_6685(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_6686","instance":6686,"id":226701,"goal":"function Factorial_6686(n: nat): nat\n ensures Factorial_6686(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_6686(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_6687","instance":6687,"id":226702,"goal":"function Fib_6687(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_6687(n-1) + Fib_6687(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_6688","instance":6688,"id":226703,"goal":"function Gcd_6688(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_6688(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_6689","instance":6689,"id":226704,"goal":"function Power_6689(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_6689(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_6690","instance":6690,"id":226705,"goal":"function Sum_6690(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_6690(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_6691","instance":6691,"id":226706,"goal":"method BinarySearch_6691(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_6692","instance":6692,"id":226707,"goal":"method InsertSort_6692(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_6693","instance":6693,"id":226708,"goal":"method MergeSort_6693(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_6694","instance":6694,"id":226709,"goal":"method ArrayCopy_6694(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_6695","instance":6695,"id":226710,"goal":"function ListReverse_6695(s: seq): seq\n ensures |ListReverse_6695(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_6695(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_6696","instance":6696,"id":226711,"goal":"function Factorial_6696(n: nat): nat\n ensures Factorial_6696(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_6696(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_6697","instance":6697,"id":226712,"goal":"function Fib_6697(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_6697(n-1) + Fib_6697(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_6698","instance":6698,"id":226713,"goal":"function Gcd_6698(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_6698(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_6699","instance":6699,"id":226714,"goal":"function Power_6699(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_6699(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_6700","instance":6700,"id":226715,"goal":"function Sum_6700(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_6700(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_6701","instance":6701,"id":226716,"goal":"method BinarySearch_6701(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_6702","instance":6702,"id":226717,"goal":"method InsertSort_6702(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_6703","instance":6703,"id":226718,"goal":"method MergeSort_6703(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_6704","instance":6704,"id":226719,"goal":"method ArrayCopy_6704(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_6705","instance":6705,"id":226720,"goal":"function ListReverse_6705(s: seq): seq\n ensures |ListReverse_6705(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_6705(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_6706","instance":6706,"id":226721,"goal":"function Factorial_6706(n: nat): nat\n ensures Factorial_6706(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_6706(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_6707","instance":6707,"id":226722,"goal":"function Fib_6707(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_6707(n-1) + Fib_6707(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_6708","instance":6708,"id":226723,"goal":"function Gcd_6708(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_6708(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_6709","instance":6709,"id":226724,"goal":"function Power_6709(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_6709(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_6710","instance":6710,"id":226725,"goal":"function Sum_6710(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_6710(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_6711","instance":6711,"id":226726,"goal":"method BinarySearch_6711(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_6712","instance":6712,"id":226727,"goal":"method InsertSort_6712(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_6713","instance":6713,"id":226728,"goal":"method MergeSort_6713(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_6714","instance":6714,"id":226729,"goal":"method ArrayCopy_6714(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_6715","instance":6715,"id":226730,"goal":"function ListReverse_6715(s: seq): seq\n ensures |ListReverse_6715(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_6715(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_6716","instance":6716,"id":226731,"goal":"function Factorial_6716(n: nat): nat\n ensures Factorial_6716(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_6716(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_6717","instance":6717,"id":226732,"goal":"function Fib_6717(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_6717(n-1) + Fib_6717(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_6718","instance":6718,"id":226733,"goal":"function Gcd_6718(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_6718(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_6719","instance":6719,"id":226734,"goal":"function Power_6719(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_6719(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_6720","instance":6720,"id":226735,"goal":"function Sum_6720(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_6720(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_6721","instance":6721,"id":226736,"goal":"method BinarySearch_6721(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_6722","instance":6722,"id":226737,"goal":"method InsertSort_6722(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_6723","instance":6723,"id":226738,"goal":"method MergeSort_6723(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_6724","instance":6724,"id":226739,"goal":"method ArrayCopy_6724(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_6725","instance":6725,"id":226740,"goal":"function ListReverse_6725(s: seq): seq\n ensures |ListReverse_6725(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_6725(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_6726","instance":6726,"id":226741,"goal":"function Factorial_6726(n: nat): nat\n ensures Factorial_6726(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_6726(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_6727","instance":6727,"id":226742,"goal":"function Fib_6727(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_6727(n-1) + Fib_6727(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_6728","instance":6728,"id":226743,"goal":"function Gcd_6728(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_6728(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_6729","instance":6729,"id":226744,"goal":"function Power_6729(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_6729(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_6730","instance":6730,"id":226745,"goal":"function Sum_6730(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_6730(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_6731","instance":6731,"id":226746,"goal":"method BinarySearch_6731(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_6732","instance":6732,"id":226747,"goal":"method InsertSort_6732(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_6733","instance":6733,"id":226748,"goal":"method MergeSort_6733(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_6734","instance":6734,"id":226749,"goal":"method ArrayCopy_6734(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_6735","instance":6735,"id":226750,"goal":"function ListReverse_6735(s: seq): seq\n ensures |ListReverse_6735(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_6735(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_6736","instance":6736,"id":226751,"goal":"function Factorial_6736(n: nat): nat\n ensures Factorial_6736(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_6736(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_6737","instance":6737,"id":226752,"goal":"function Fib_6737(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_6737(n-1) + Fib_6737(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_6738","instance":6738,"id":226753,"goal":"function Gcd_6738(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_6738(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_6739","instance":6739,"id":226754,"goal":"function Power_6739(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_6739(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_6740","instance":6740,"id":226755,"goal":"function Sum_6740(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_6740(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_6741","instance":6741,"id":226756,"goal":"method BinarySearch_6741(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_6742","instance":6742,"id":226757,"goal":"method InsertSort_6742(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_6743","instance":6743,"id":226758,"goal":"method MergeSort_6743(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_6744","instance":6744,"id":226759,"goal":"method ArrayCopy_6744(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_6745","instance":6745,"id":226760,"goal":"function ListReverse_6745(s: seq): seq\n ensures |ListReverse_6745(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_6745(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_6746","instance":6746,"id":226761,"goal":"function Factorial_6746(n: nat): nat\n ensures Factorial_6746(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_6746(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_6747","instance":6747,"id":226762,"goal":"function Fib_6747(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_6747(n-1) + Fib_6747(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_6748","instance":6748,"id":226763,"goal":"function Gcd_6748(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_6748(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_6749","instance":6749,"id":226764,"goal":"function Power_6749(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_6749(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_6750","instance":6750,"id":226765,"goal":"function Sum_6750(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_6750(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_6751","instance":6751,"id":226766,"goal":"method BinarySearch_6751(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_6752","instance":6752,"id":226767,"goal":"method InsertSort_6752(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_6753","instance":6753,"id":226768,"goal":"method MergeSort_6753(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_6754","instance":6754,"id":226769,"goal":"method ArrayCopy_6754(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_6755","instance":6755,"id":226770,"goal":"function ListReverse_6755(s: seq): seq\n ensures |ListReverse_6755(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_6755(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_6756","instance":6756,"id":226771,"goal":"function Factorial_6756(n: nat): nat\n ensures Factorial_6756(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_6756(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_6757","instance":6757,"id":226772,"goal":"function Fib_6757(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_6757(n-1) + Fib_6757(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_6758","instance":6758,"id":226773,"goal":"function Gcd_6758(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_6758(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_6759","instance":6759,"id":226774,"goal":"function Power_6759(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_6759(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_6760","instance":6760,"id":226775,"goal":"function Sum_6760(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_6760(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_6761","instance":6761,"id":226776,"goal":"method BinarySearch_6761(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_6762","instance":6762,"id":226777,"goal":"method InsertSort_6762(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_6763","instance":6763,"id":226778,"goal":"method MergeSort_6763(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_6764","instance":6764,"id":226779,"goal":"method ArrayCopy_6764(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_6765","instance":6765,"id":226780,"goal":"function ListReverse_6765(s: seq): seq\n ensures |ListReverse_6765(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_6765(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_6766","instance":6766,"id":226781,"goal":"function Factorial_6766(n: nat): nat\n ensures Factorial_6766(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_6766(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_6767","instance":6767,"id":226782,"goal":"function Fib_6767(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_6767(n-1) + Fib_6767(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_6768","instance":6768,"id":226783,"goal":"function Gcd_6768(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_6768(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_6769","instance":6769,"id":226784,"goal":"function Power_6769(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_6769(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_6770","instance":6770,"id":226785,"goal":"function Sum_6770(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_6770(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_6771","instance":6771,"id":226786,"goal":"method BinarySearch_6771(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_6772","instance":6772,"id":226787,"goal":"method InsertSort_6772(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_6773","instance":6773,"id":226788,"goal":"method MergeSort_6773(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_6774","instance":6774,"id":226789,"goal":"method ArrayCopy_6774(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_6775","instance":6775,"id":226790,"goal":"function ListReverse_6775(s: seq): seq\n ensures |ListReverse_6775(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_6775(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_6776","instance":6776,"id":226791,"goal":"function Factorial_6776(n: nat): nat\n ensures Factorial_6776(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_6776(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_6777","instance":6777,"id":226792,"goal":"function Fib_6777(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_6777(n-1) + Fib_6777(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_6778","instance":6778,"id":226793,"goal":"function Gcd_6778(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_6778(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_6779","instance":6779,"id":226794,"goal":"function Power_6779(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_6779(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_6780","instance":6780,"id":226795,"goal":"function Sum_6780(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_6780(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_6781","instance":6781,"id":226796,"goal":"method BinarySearch_6781(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_6782","instance":6782,"id":226797,"goal":"method InsertSort_6782(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_6783","instance":6783,"id":226798,"goal":"method MergeSort_6783(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_6784","instance":6784,"id":226799,"goal":"method ArrayCopy_6784(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_6785","instance":6785,"id":226800,"goal":"function ListReverse_6785(s: seq): seq\n ensures |ListReverse_6785(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_6785(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_6786","instance":6786,"id":226801,"goal":"function Factorial_6786(n: nat): nat\n ensures Factorial_6786(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_6786(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_6787","instance":6787,"id":226802,"goal":"function Fib_6787(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_6787(n-1) + Fib_6787(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_6788","instance":6788,"id":226803,"goal":"function Gcd_6788(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_6788(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_6789","instance":6789,"id":226804,"goal":"function Power_6789(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_6789(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_6790","instance":6790,"id":226805,"goal":"function Sum_6790(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_6790(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_6791","instance":6791,"id":226806,"goal":"method BinarySearch_6791(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_6792","instance":6792,"id":226807,"goal":"method InsertSort_6792(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_6793","instance":6793,"id":226808,"goal":"method MergeSort_6793(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_6794","instance":6794,"id":226809,"goal":"method ArrayCopy_6794(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_6795","instance":6795,"id":226810,"goal":"function ListReverse_6795(s: seq): seq\n ensures |ListReverse_6795(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_6795(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_6796","instance":6796,"id":226811,"goal":"function Factorial_6796(n: nat): nat\n ensures Factorial_6796(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_6796(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_6797","instance":6797,"id":226812,"goal":"function Fib_6797(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_6797(n-1) + Fib_6797(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_6798","instance":6798,"id":226813,"goal":"function Gcd_6798(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_6798(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_6799","instance":6799,"id":226814,"goal":"function Power_6799(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_6799(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_6800","instance":6800,"id":226815,"goal":"function Sum_6800(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_6800(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_6801","instance":6801,"id":226816,"goal":"method BinarySearch_6801(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_6802","instance":6802,"id":226817,"goal":"method InsertSort_6802(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_6803","instance":6803,"id":226818,"goal":"method MergeSort_6803(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_6804","instance":6804,"id":226819,"goal":"method ArrayCopy_6804(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_6805","instance":6805,"id":226820,"goal":"function ListReverse_6805(s: seq): seq\n ensures |ListReverse_6805(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_6805(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_6806","instance":6806,"id":226821,"goal":"function Factorial_6806(n: nat): nat\n ensures Factorial_6806(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_6806(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_6807","instance":6807,"id":226822,"goal":"function Fib_6807(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_6807(n-1) + Fib_6807(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_6808","instance":6808,"id":226823,"goal":"function Gcd_6808(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_6808(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_6809","instance":6809,"id":226824,"goal":"function Power_6809(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_6809(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_6810","instance":6810,"id":226825,"goal":"function Sum_6810(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_6810(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_6811","instance":6811,"id":226826,"goal":"method BinarySearch_6811(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_6812","instance":6812,"id":226827,"goal":"method InsertSort_6812(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_6813","instance":6813,"id":226828,"goal":"method MergeSort_6813(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_6814","instance":6814,"id":226829,"goal":"method ArrayCopy_6814(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_6815","instance":6815,"id":226830,"goal":"function ListReverse_6815(s: seq): seq\n ensures |ListReverse_6815(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_6815(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_6816","instance":6816,"id":226831,"goal":"function Factorial_6816(n: nat): nat\n ensures Factorial_6816(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_6816(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_6817","instance":6817,"id":226832,"goal":"function Fib_6817(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_6817(n-1) + Fib_6817(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_6818","instance":6818,"id":226833,"goal":"function Gcd_6818(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_6818(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_6819","instance":6819,"id":226834,"goal":"function Power_6819(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_6819(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_6820","instance":6820,"id":226835,"goal":"function Sum_6820(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_6820(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_6821","instance":6821,"id":226836,"goal":"method BinarySearch_6821(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_6822","instance":6822,"id":226837,"goal":"method InsertSort_6822(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_6823","instance":6823,"id":226838,"goal":"method MergeSort_6823(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_6824","instance":6824,"id":226839,"goal":"method ArrayCopy_6824(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_6825","instance":6825,"id":226840,"goal":"function ListReverse_6825(s: seq): seq\n ensures |ListReverse_6825(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_6825(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_6826","instance":6826,"id":226841,"goal":"function Factorial_6826(n: nat): nat\n ensures Factorial_6826(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_6826(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_6827","instance":6827,"id":226842,"goal":"function Fib_6827(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_6827(n-1) + Fib_6827(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_6828","instance":6828,"id":226843,"goal":"function Gcd_6828(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_6828(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_6829","instance":6829,"id":226844,"goal":"function Power_6829(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_6829(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_6830","instance":6830,"id":226845,"goal":"function Sum_6830(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_6830(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_6831","instance":6831,"id":226846,"goal":"method BinarySearch_6831(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_6832","instance":6832,"id":226847,"goal":"method InsertSort_6832(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_6833","instance":6833,"id":226848,"goal":"method MergeSort_6833(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_6834","instance":6834,"id":226849,"goal":"method ArrayCopy_6834(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_6835","instance":6835,"id":226850,"goal":"function ListReverse_6835(s: seq): seq\n ensures |ListReverse_6835(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_6835(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_6836","instance":6836,"id":226851,"goal":"function Factorial_6836(n: nat): nat\n ensures Factorial_6836(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_6836(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_6837","instance":6837,"id":226852,"goal":"function Fib_6837(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_6837(n-1) + Fib_6837(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_6838","instance":6838,"id":226853,"goal":"function Gcd_6838(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_6838(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_6839","instance":6839,"id":226854,"goal":"function Power_6839(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_6839(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_6840","instance":6840,"id":226855,"goal":"function Sum_6840(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_6840(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_6841","instance":6841,"id":226856,"goal":"method BinarySearch_6841(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_6842","instance":6842,"id":226857,"goal":"method InsertSort_6842(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_6843","instance":6843,"id":226858,"goal":"method MergeSort_6843(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_6844","instance":6844,"id":226859,"goal":"method ArrayCopy_6844(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_6845","instance":6845,"id":226860,"goal":"function ListReverse_6845(s: seq): seq\n ensures |ListReverse_6845(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_6845(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_6846","instance":6846,"id":226861,"goal":"function Factorial_6846(n: nat): nat\n ensures Factorial_6846(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_6846(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_6847","instance":6847,"id":226862,"goal":"function Fib_6847(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_6847(n-1) + Fib_6847(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_6848","instance":6848,"id":226863,"goal":"function Gcd_6848(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_6848(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_6849","instance":6849,"id":226864,"goal":"function Power_6849(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_6849(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_6850","instance":6850,"id":226865,"goal":"function Sum_6850(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_6850(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_6851","instance":6851,"id":226866,"goal":"method BinarySearch_6851(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_6852","instance":6852,"id":226867,"goal":"method InsertSort_6852(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_6853","instance":6853,"id":226868,"goal":"method MergeSort_6853(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_6854","instance":6854,"id":226869,"goal":"method ArrayCopy_6854(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_6855","instance":6855,"id":226870,"goal":"function ListReverse_6855(s: seq): seq\n ensures |ListReverse_6855(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_6855(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_6856","instance":6856,"id":226871,"goal":"function Factorial_6856(n: nat): nat\n ensures Factorial_6856(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_6856(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_6857","instance":6857,"id":226872,"goal":"function Fib_6857(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_6857(n-1) + Fib_6857(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_6858","instance":6858,"id":226873,"goal":"function Gcd_6858(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_6858(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_6859","instance":6859,"id":226874,"goal":"function Power_6859(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_6859(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_6860","instance":6860,"id":226875,"goal":"function Sum_6860(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_6860(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_6861","instance":6861,"id":226876,"goal":"method BinarySearch_6861(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_6862","instance":6862,"id":226877,"goal":"method InsertSort_6862(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_6863","instance":6863,"id":226878,"goal":"method MergeSort_6863(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_6864","instance":6864,"id":226879,"goal":"method ArrayCopy_6864(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_6865","instance":6865,"id":226880,"goal":"function ListReverse_6865(s: seq): seq\n ensures |ListReverse_6865(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_6865(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_6866","instance":6866,"id":226881,"goal":"function Factorial_6866(n: nat): nat\n ensures Factorial_6866(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_6866(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_6867","instance":6867,"id":226882,"goal":"function Fib_6867(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_6867(n-1) + Fib_6867(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_6868","instance":6868,"id":226883,"goal":"function Gcd_6868(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_6868(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_6869","instance":6869,"id":226884,"goal":"function Power_6869(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_6869(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_6870","instance":6870,"id":226885,"goal":"function Sum_6870(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_6870(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_6871","instance":6871,"id":226886,"goal":"method BinarySearch_6871(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_6872","instance":6872,"id":226887,"goal":"method InsertSort_6872(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_6873","instance":6873,"id":226888,"goal":"method MergeSort_6873(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_6874","instance":6874,"id":226889,"goal":"method ArrayCopy_6874(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_6875","instance":6875,"id":226890,"goal":"function ListReverse_6875(s: seq): seq\n ensures |ListReverse_6875(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_6875(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_6876","instance":6876,"id":226891,"goal":"function Factorial_6876(n: nat): nat\n ensures Factorial_6876(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_6876(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_6877","instance":6877,"id":226892,"goal":"function Fib_6877(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_6877(n-1) + Fib_6877(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_6878","instance":6878,"id":226893,"goal":"function Gcd_6878(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_6878(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_6879","instance":6879,"id":226894,"goal":"function Power_6879(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_6879(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_6880","instance":6880,"id":226895,"goal":"function Sum_6880(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_6880(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_6881","instance":6881,"id":226896,"goal":"method BinarySearch_6881(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_6882","instance":6882,"id":226897,"goal":"method InsertSort_6882(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_6883","instance":6883,"id":226898,"goal":"method MergeSort_6883(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_6884","instance":6884,"id":226899,"goal":"method ArrayCopy_6884(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_6885","instance":6885,"id":226900,"goal":"function ListReverse_6885(s: seq): seq\n ensures |ListReverse_6885(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_6885(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_6886","instance":6886,"id":226901,"goal":"function Factorial_6886(n: nat): nat\n ensures Factorial_6886(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_6886(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_6887","instance":6887,"id":226902,"goal":"function Fib_6887(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_6887(n-1) + Fib_6887(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_6888","instance":6888,"id":226903,"goal":"function Gcd_6888(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_6888(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_6889","instance":6889,"id":226904,"goal":"function Power_6889(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_6889(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_6890","instance":6890,"id":226905,"goal":"function Sum_6890(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_6890(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_6891","instance":6891,"id":226906,"goal":"method BinarySearch_6891(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_6892","instance":6892,"id":226907,"goal":"method InsertSort_6892(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_6893","instance":6893,"id":226908,"goal":"method MergeSort_6893(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_6894","instance":6894,"id":226909,"goal":"method ArrayCopy_6894(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_6895","instance":6895,"id":226910,"goal":"function ListReverse_6895(s: seq): seq\n ensures |ListReverse_6895(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_6895(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_6896","instance":6896,"id":226911,"goal":"function Factorial_6896(n: nat): nat\n ensures Factorial_6896(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_6896(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_6897","instance":6897,"id":226912,"goal":"function Fib_6897(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_6897(n-1) + Fib_6897(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_6898","instance":6898,"id":226913,"goal":"function Gcd_6898(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_6898(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_6899","instance":6899,"id":226914,"goal":"function Power_6899(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_6899(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_6900","instance":6900,"id":226915,"goal":"function Sum_6900(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_6900(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_6901","instance":6901,"id":226916,"goal":"method BinarySearch_6901(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_6902","instance":6902,"id":226917,"goal":"method InsertSort_6902(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_6903","instance":6903,"id":226918,"goal":"method MergeSort_6903(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_6904","instance":6904,"id":226919,"goal":"method ArrayCopy_6904(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_6905","instance":6905,"id":226920,"goal":"function ListReverse_6905(s: seq): seq\n ensures |ListReverse_6905(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_6905(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_6906","instance":6906,"id":226921,"goal":"function Factorial_6906(n: nat): nat\n ensures Factorial_6906(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_6906(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_6907","instance":6907,"id":226922,"goal":"function Fib_6907(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_6907(n-1) + Fib_6907(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_6908","instance":6908,"id":226923,"goal":"function Gcd_6908(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_6908(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_6909","instance":6909,"id":226924,"goal":"function Power_6909(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_6909(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_6910","instance":6910,"id":226925,"goal":"function Sum_6910(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_6910(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_6911","instance":6911,"id":226926,"goal":"method BinarySearch_6911(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_6912","instance":6912,"id":226927,"goal":"method InsertSort_6912(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_6913","instance":6913,"id":226928,"goal":"method MergeSort_6913(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_6914","instance":6914,"id":226929,"goal":"method ArrayCopy_6914(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_6915","instance":6915,"id":226930,"goal":"function ListReverse_6915(s: seq): seq\n ensures |ListReverse_6915(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_6915(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_6916","instance":6916,"id":226931,"goal":"function Factorial_6916(n: nat): nat\n ensures Factorial_6916(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_6916(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_6917","instance":6917,"id":226932,"goal":"function Fib_6917(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_6917(n-1) + Fib_6917(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_6918","instance":6918,"id":226933,"goal":"function Gcd_6918(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_6918(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_6919","instance":6919,"id":226934,"goal":"function Power_6919(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_6919(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_6920","instance":6920,"id":226935,"goal":"function Sum_6920(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_6920(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_6921","instance":6921,"id":226936,"goal":"method BinarySearch_6921(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_6922","instance":6922,"id":226937,"goal":"method InsertSort_6922(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_6923","instance":6923,"id":226938,"goal":"method MergeSort_6923(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_6924","instance":6924,"id":226939,"goal":"method ArrayCopy_6924(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_6925","instance":6925,"id":226940,"goal":"function ListReverse_6925(s: seq): seq\n ensures |ListReverse_6925(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_6925(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_6926","instance":6926,"id":226941,"goal":"function Factorial_6926(n: nat): nat\n ensures Factorial_6926(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_6926(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_6927","instance":6927,"id":226942,"goal":"function Fib_6927(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_6927(n-1) + Fib_6927(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_6928","instance":6928,"id":226943,"goal":"function Gcd_6928(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_6928(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_6929","instance":6929,"id":226944,"goal":"function Power_6929(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_6929(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_6930","instance":6930,"id":226945,"goal":"function Sum_6930(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_6930(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_6931","instance":6931,"id":226946,"goal":"method BinarySearch_6931(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_6932","instance":6932,"id":226947,"goal":"method InsertSort_6932(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_6933","instance":6933,"id":226948,"goal":"method MergeSort_6933(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_6934","instance":6934,"id":226949,"goal":"method ArrayCopy_6934(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_6935","instance":6935,"id":226950,"goal":"function ListReverse_6935(s: seq): seq\n ensures |ListReverse_6935(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_6935(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_6936","instance":6936,"id":226951,"goal":"function Factorial_6936(n: nat): nat\n ensures Factorial_6936(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_6936(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_6937","instance":6937,"id":226952,"goal":"function Fib_6937(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_6937(n-1) + Fib_6937(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_6938","instance":6938,"id":226953,"goal":"function Gcd_6938(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_6938(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_6939","instance":6939,"id":226954,"goal":"function Power_6939(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_6939(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_6940","instance":6940,"id":226955,"goal":"function Sum_6940(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_6940(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_6941","instance":6941,"id":226956,"goal":"method BinarySearch_6941(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_6942","instance":6942,"id":226957,"goal":"method InsertSort_6942(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_6943","instance":6943,"id":226958,"goal":"method MergeSort_6943(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_6944","instance":6944,"id":226959,"goal":"method ArrayCopy_6944(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_6945","instance":6945,"id":226960,"goal":"function ListReverse_6945(s: seq): seq\n ensures |ListReverse_6945(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_6945(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_6946","instance":6946,"id":226961,"goal":"function Factorial_6946(n: nat): nat\n ensures Factorial_6946(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_6946(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_6947","instance":6947,"id":226962,"goal":"function Fib_6947(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_6947(n-1) + Fib_6947(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_6948","instance":6948,"id":226963,"goal":"function Gcd_6948(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_6948(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_6949","instance":6949,"id":226964,"goal":"function Power_6949(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_6949(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_6950","instance":6950,"id":226965,"goal":"function Sum_6950(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_6950(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_6951","instance":6951,"id":226966,"goal":"method BinarySearch_6951(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_6952","instance":6952,"id":226967,"goal":"method InsertSort_6952(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_6953","instance":6953,"id":226968,"goal":"method MergeSort_6953(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_6954","instance":6954,"id":226969,"goal":"method ArrayCopy_6954(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_6955","instance":6955,"id":226970,"goal":"function ListReverse_6955(s: seq): seq\n ensures |ListReverse_6955(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_6955(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_6956","instance":6956,"id":226971,"goal":"function Factorial_6956(n: nat): nat\n ensures Factorial_6956(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_6956(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_6957","instance":6957,"id":226972,"goal":"function Fib_6957(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_6957(n-1) + Fib_6957(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_6958","instance":6958,"id":226973,"goal":"function Gcd_6958(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_6958(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_6959","instance":6959,"id":226974,"goal":"function Power_6959(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_6959(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_6960","instance":6960,"id":226975,"goal":"function Sum_6960(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_6960(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_6961","instance":6961,"id":226976,"goal":"method BinarySearch_6961(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_6962","instance":6962,"id":226977,"goal":"method InsertSort_6962(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_6963","instance":6963,"id":226978,"goal":"method MergeSort_6963(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_6964","instance":6964,"id":226979,"goal":"method ArrayCopy_6964(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_6965","instance":6965,"id":226980,"goal":"function ListReverse_6965(s: seq): seq\n ensures |ListReverse_6965(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_6965(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_6966","instance":6966,"id":226981,"goal":"function Factorial_6966(n: nat): nat\n ensures Factorial_6966(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_6966(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_6967","instance":6967,"id":226982,"goal":"function Fib_6967(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_6967(n-1) + Fib_6967(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_6968","instance":6968,"id":226983,"goal":"function Gcd_6968(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_6968(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_6969","instance":6969,"id":226984,"goal":"function Power_6969(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_6969(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_6970","instance":6970,"id":226985,"goal":"function Sum_6970(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_6970(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_6971","instance":6971,"id":226986,"goal":"method BinarySearch_6971(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_6972","instance":6972,"id":226987,"goal":"method InsertSort_6972(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_6973","instance":6973,"id":226988,"goal":"method MergeSort_6973(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_6974","instance":6974,"id":226989,"goal":"method ArrayCopy_6974(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_6975","instance":6975,"id":226990,"goal":"function ListReverse_6975(s: seq): seq\n ensures |ListReverse_6975(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_6975(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_6976","instance":6976,"id":226991,"goal":"function Factorial_6976(n: nat): nat\n ensures Factorial_6976(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_6976(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_6977","instance":6977,"id":226992,"goal":"function Fib_6977(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_6977(n-1) + Fib_6977(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_6978","instance":6978,"id":226993,"goal":"function Gcd_6978(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_6978(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_6979","instance":6979,"id":226994,"goal":"function Power_6979(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_6979(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_6980","instance":6980,"id":226995,"goal":"function Sum_6980(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_6980(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_6981","instance":6981,"id":226996,"goal":"method BinarySearch_6981(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_6982","instance":6982,"id":226997,"goal":"method InsertSort_6982(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_6983","instance":6983,"id":226998,"goal":"method MergeSort_6983(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_6984","instance":6984,"id":226999,"goal":"method ArrayCopy_6984(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_6985","instance":6985,"id":227000,"goal":"function ListReverse_6985(s: seq): seq\n ensures |ListReverse_6985(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_6985(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_6986","instance":6986,"id":227001,"goal":"function Factorial_6986(n: nat): nat\n ensures Factorial_6986(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_6986(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_6987","instance":6987,"id":227002,"goal":"function Fib_6987(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_6987(n-1) + Fib_6987(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_6988","instance":6988,"id":227003,"goal":"function Gcd_6988(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_6988(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_6989","instance":6989,"id":227004,"goal":"function Power_6989(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_6989(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_6990","instance":6990,"id":227005,"goal":"function Sum_6990(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_6990(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_6991","instance":6991,"id":227006,"goal":"method BinarySearch_6991(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_6992","instance":6992,"id":227007,"goal":"method InsertSort_6992(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_6993","instance":6993,"id":227008,"goal":"method MergeSort_6993(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_6994","instance":6994,"id":227009,"goal":"method ArrayCopy_6994(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_6995","instance":6995,"id":227010,"goal":"function ListReverse_6995(s: seq): seq\n ensures |ListReverse_6995(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_6995(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_6996","instance":6996,"id":227011,"goal":"function Factorial_6996(n: nat): nat\n ensures Factorial_6996(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_6996(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_6997","instance":6997,"id":227012,"goal":"function Fib_6997(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_6997(n-1) + Fib_6997(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_6998","instance":6998,"id":227013,"goal":"function Gcd_6998(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_6998(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_6999","instance":6999,"id":227014,"goal":"function Power_6999(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_6999(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_7000","instance":7000,"id":227015,"goal":"function Sum_7000(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_7000(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_7001","instance":7001,"id":227016,"goal":"method BinarySearch_7001(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_7002","instance":7002,"id":227017,"goal":"method InsertSort_7002(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_7003","instance":7003,"id":227018,"goal":"method MergeSort_7003(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_7004","instance":7004,"id":227019,"goal":"method ArrayCopy_7004(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_7005","instance":7005,"id":227020,"goal":"function ListReverse_7005(s: seq): seq\n ensures |ListReverse_7005(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_7005(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_7006","instance":7006,"id":227021,"goal":"function Factorial_7006(n: nat): nat\n ensures Factorial_7006(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_7006(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_7007","instance":7007,"id":227022,"goal":"function Fib_7007(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_7007(n-1) + Fib_7007(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_7008","instance":7008,"id":227023,"goal":"function Gcd_7008(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_7008(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_7009","instance":7009,"id":227024,"goal":"function Power_7009(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_7009(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_7010","instance":7010,"id":227025,"goal":"function Sum_7010(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_7010(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_7011","instance":7011,"id":227026,"goal":"method BinarySearch_7011(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_7012","instance":7012,"id":227027,"goal":"method InsertSort_7012(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_7013","instance":7013,"id":227028,"goal":"method MergeSort_7013(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_7014","instance":7014,"id":227029,"goal":"method ArrayCopy_7014(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_7015","instance":7015,"id":227030,"goal":"function ListReverse_7015(s: seq): seq\n ensures |ListReverse_7015(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_7015(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_7016","instance":7016,"id":227031,"goal":"function Factorial_7016(n: nat): nat\n ensures Factorial_7016(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_7016(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_7017","instance":7017,"id":227032,"goal":"function Fib_7017(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_7017(n-1) + Fib_7017(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_7018","instance":7018,"id":227033,"goal":"function Gcd_7018(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_7018(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_7019","instance":7019,"id":227034,"goal":"function Power_7019(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_7019(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_7020","instance":7020,"id":227035,"goal":"function Sum_7020(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_7020(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_7021","instance":7021,"id":227036,"goal":"method BinarySearch_7021(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_7022","instance":7022,"id":227037,"goal":"method InsertSort_7022(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_7023","instance":7023,"id":227038,"goal":"method MergeSort_7023(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_7024","instance":7024,"id":227039,"goal":"method ArrayCopy_7024(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_7025","instance":7025,"id":227040,"goal":"function ListReverse_7025(s: seq): seq\n ensures |ListReverse_7025(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_7025(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_7026","instance":7026,"id":227041,"goal":"function Factorial_7026(n: nat): nat\n ensures Factorial_7026(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_7026(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_7027","instance":7027,"id":227042,"goal":"function Fib_7027(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_7027(n-1) + Fib_7027(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_7028","instance":7028,"id":227043,"goal":"function Gcd_7028(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_7028(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_7029","instance":7029,"id":227044,"goal":"function Power_7029(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_7029(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_7030","instance":7030,"id":227045,"goal":"function Sum_7030(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_7030(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_7031","instance":7031,"id":227046,"goal":"method BinarySearch_7031(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_7032","instance":7032,"id":227047,"goal":"method InsertSort_7032(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_7033","instance":7033,"id":227048,"goal":"method MergeSort_7033(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_7034","instance":7034,"id":227049,"goal":"method ArrayCopy_7034(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_7035","instance":7035,"id":227050,"goal":"function ListReverse_7035(s: seq): seq\n ensures |ListReverse_7035(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_7035(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_7036","instance":7036,"id":227051,"goal":"function Factorial_7036(n: nat): nat\n ensures Factorial_7036(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_7036(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_7037","instance":7037,"id":227052,"goal":"function Fib_7037(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_7037(n-1) + Fib_7037(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_7038","instance":7038,"id":227053,"goal":"function Gcd_7038(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_7038(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_7039","instance":7039,"id":227054,"goal":"function Power_7039(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_7039(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_7040","instance":7040,"id":227055,"goal":"function Sum_7040(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_7040(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_7041","instance":7041,"id":227056,"goal":"method BinarySearch_7041(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_7042","instance":7042,"id":227057,"goal":"method InsertSort_7042(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_7043","instance":7043,"id":227058,"goal":"method MergeSort_7043(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_7044","instance":7044,"id":227059,"goal":"method ArrayCopy_7044(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_7045","instance":7045,"id":227060,"goal":"function ListReverse_7045(s: seq): seq\n ensures |ListReverse_7045(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_7045(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_7046","instance":7046,"id":227061,"goal":"function Factorial_7046(n: nat): nat\n ensures Factorial_7046(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_7046(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_7047","instance":7047,"id":227062,"goal":"function Fib_7047(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_7047(n-1) + Fib_7047(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_7048","instance":7048,"id":227063,"goal":"function Gcd_7048(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_7048(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_7049","instance":7049,"id":227064,"goal":"function Power_7049(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_7049(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_7050","instance":7050,"id":227065,"goal":"function Sum_7050(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_7050(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_7051","instance":7051,"id":227066,"goal":"method BinarySearch_7051(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_7052","instance":7052,"id":227067,"goal":"method InsertSort_7052(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_7053","instance":7053,"id":227068,"goal":"method MergeSort_7053(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_7054","instance":7054,"id":227069,"goal":"method ArrayCopy_7054(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_7055","instance":7055,"id":227070,"goal":"function ListReverse_7055(s: seq): seq\n ensures |ListReverse_7055(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_7055(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_7056","instance":7056,"id":227071,"goal":"function Factorial_7056(n: nat): nat\n ensures Factorial_7056(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_7056(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_7057","instance":7057,"id":227072,"goal":"function Fib_7057(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_7057(n-1) + Fib_7057(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_7058","instance":7058,"id":227073,"goal":"function Gcd_7058(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_7058(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_7059","instance":7059,"id":227074,"goal":"function Power_7059(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_7059(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_7060","instance":7060,"id":227075,"goal":"function Sum_7060(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_7060(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_7061","instance":7061,"id":227076,"goal":"method BinarySearch_7061(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_7062","instance":7062,"id":227077,"goal":"method InsertSort_7062(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_7063","instance":7063,"id":227078,"goal":"method MergeSort_7063(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_7064","instance":7064,"id":227079,"goal":"method ArrayCopy_7064(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_7065","instance":7065,"id":227080,"goal":"function ListReverse_7065(s: seq): seq\n ensures |ListReverse_7065(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_7065(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_7066","instance":7066,"id":227081,"goal":"function Factorial_7066(n: nat): nat\n ensures Factorial_7066(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_7066(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_7067","instance":7067,"id":227082,"goal":"function Fib_7067(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_7067(n-1) + Fib_7067(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_7068","instance":7068,"id":227083,"goal":"function Gcd_7068(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_7068(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_7069","instance":7069,"id":227084,"goal":"function Power_7069(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_7069(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_7070","instance":7070,"id":227085,"goal":"function Sum_7070(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_7070(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_7071","instance":7071,"id":227086,"goal":"method BinarySearch_7071(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_7072","instance":7072,"id":227087,"goal":"method InsertSort_7072(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_7073","instance":7073,"id":227088,"goal":"method MergeSort_7073(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_7074","instance":7074,"id":227089,"goal":"method ArrayCopy_7074(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_7075","instance":7075,"id":227090,"goal":"function ListReverse_7075(s: seq): seq\n ensures |ListReverse_7075(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_7075(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_7076","instance":7076,"id":227091,"goal":"function Factorial_7076(n: nat): nat\n ensures Factorial_7076(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_7076(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_7077","instance":7077,"id":227092,"goal":"function Fib_7077(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_7077(n-1) + Fib_7077(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_7078","instance":7078,"id":227093,"goal":"function Gcd_7078(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_7078(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_7079","instance":7079,"id":227094,"goal":"function Power_7079(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_7079(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_7080","instance":7080,"id":227095,"goal":"function Sum_7080(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_7080(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_7081","instance":7081,"id":227096,"goal":"method BinarySearch_7081(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_7082","instance":7082,"id":227097,"goal":"method InsertSort_7082(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_7083","instance":7083,"id":227098,"goal":"method MergeSort_7083(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_7084","instance":7084,"id":227099,"goal":"method ArrayCopy_7084(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_7085","instance":7085,"id":227100,"goal":"function ListReverse_7085(s: seq): seq\n ensures |ListReverse_7085(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_7085(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_7086","instance":7086,"id":227101,"goal":"function Factorial_7086(n: nat): nat\n ensures Factorial_7086(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_7086(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_7087","instance":7087,"id":227102,"goal":"function Fib_7087(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_7087(n-1) + Fib_7087(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_7088","instance":7088,"id":227103,"goal":"function Gcd_7088(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_7088(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_7089","instance":7089,"id":227104,"goal":"function Power_7089(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_7089(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_7090","instance":7090,"id":227105,"goal":"function Sum_7090(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_7090(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_7091","instance":7091,"id":227106,"goal":"method BinarySearch_7091(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_7092","instance":7092,"id":227107,"goal":"method InsertSort_7092(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_7093","instance":7093,"id":227108,"goal":"method MergeSort_7093(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_7094","instance":7094,"id":227109,"goal":"method ArrayCopy_7094(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_7095","instance":7095,"id":227110,"goal":"function ListReverse_7095(s: seq): seq\n ensures |ListReverse_7095(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_7095(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_7096","instance":7096,"id":227111,"goal":"function Factorial_7096(n: nat): nat\n ensures Factorial_7096(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_7096(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_7097","instance":7097,"id":227112,"goal":"function Fib_7097(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_7097(n-1) + Fib_7097(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_7098","instance":7098,"id":227113,"goal":"function Gcd_7098(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_7098(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_7099","instance":7099,"id":227114,"goal":"function Power_7099(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_7099(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_7100","instance":7100,"id":227115,"goal":"function Sum_7100(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_7100(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_7101","instance":7101,"id":227116,"goal":"method BinarySearch_7101(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_7102","instance":7102,"id":227117,"goal":"method InsertSort_7102(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_7103","instance":7103,"id":227118,"goal":"method MergeSort_7103(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_7104","instance":7104,"id":227119,"goal":"method ArrayCopy_7104(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_7105","instance":7105,"id":227120,"goal":"function ListReverse_7105(s: seq): seq\n ensures |ListReverse_7105(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_7105(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_7106","instance":7106,"id":227121,"goal":"function Factorial_7106(n: nat): nat\n ensures Factorial_7106(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_7106(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_7107","instance":7107,"id":227122,"goal":"function Fib_7107(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_7107(n-1) + Fib_7107(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_7108","instance":7108,"id":227123,"goal":"function Gcd_7108(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_7108(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_7109","instance":7109,"id":227124,"goal":"function Power_7109(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_7109(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_7110","instance":7110,"id":227125,"goal":"function Sum_7110(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_7110(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_7111","instance":7111,"id":227126,"goal":"method BinarySearch_7111(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_7112","instance":7112,"id":227127,"goal":"method InsertSort_7112(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_7113","instance":7113,"id":227128,"goal":"method MergeSort_7113(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_7114","instance":7114,"id":227129,"goal":"method ArrayCopy_7114(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_7115","instance":7115,"id":227130,"goal":"function ListReverse_7115(s: seq): seq\n ensures |ListReverse_7115(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_7115(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_7116","instance":7116,"id":227131,"goal":"function Factorial_7116(n: nat): nat\n ensures Factorial_7116(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_7116(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_7117","instance":7117,"id":227132,"goal":"function Fib_7117(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_7117(n-1) + Fib_7117(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_7118","instance":7118,"id":227133,"goal":"function Gcd_7118(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_7118(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_7119","instance":7119,"id":227134,"goal":"function Power_7119(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_7119(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_7120","instance":7120,"id":227135,"goal":"function Sum_7120(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_7120(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_7121","instance":7121,"id":227136,"goal":"method BinarySearch_7121(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_7122","instance":7122,"id":227137,"goal":"method InsertSort_7122(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_7123","instance":7123,"id":227138,"goal":"method MergeSort_7123(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_7124","instance":7124,"id":227139,"goal":"method ArrayCopy_7124(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_7125","instance":7125,"id":227140,"goal":"function ListReverse_7125(s: seq): seq\n ensures |ListReverse_7125(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_7125(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_7126","instance":7126,"id":227141,"goal":"function Factorial_7126(n: nat): nat\n ensures Factorial_7126(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_7126(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_7127","instance":7127,"id":227142,"goal":"function Fib_7127(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_7127(n-1) + Fib_7127(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_7128","instance":7128,"id":227143,"goal":"function Gcd_7128(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_7128(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_7129","instance":7129,"id":227144,"goal":"function Power_7129(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_7129(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_7130","instance":7130,"id":227145,"goal":"function Sum_7130(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_7130(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_7131","instance":7131,"id":227146,"goal":"method BinarySearch_7131(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_7132","instance":7132,"id":227147,"goal":"method InsertSort_7132(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_7133","instance":7133,"id":227148,"goal":"method MergeSort_7133(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_7134","instance":7134,"id":227149,"goal":"method ArrayCopy_7134(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_7135","instance":7135,"id":227150,"goal":"function ListReverse_7135(s: seq): seq\n ensures |ListReverse_7135(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_7135(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_7136","instance":7136,"id":227151,"goal":"function Factorial_7136(n: nat): nat\n ensures Factorial_7136(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_7136(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_7137","instance":7137,"id":227152,"goal":"function Fib_7137(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_7137(n-1) + Fib_7137(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_7138","instance":7138,"id":227153,"goal":"function Gcd_7138(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_7138(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_7139","instance":7139,"id":227154,"goal":"function Power_7139(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_7139(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_7140","instance":7140,"id":227155,"goal":"function Sum_7140(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_7140(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_7141","instance":7141,"id":227156,"goal":"method BinarySearch_7141(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_7142","instance":7142,"id":227157,"goal":"method InsertSort_7142(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_7143","instance":7143,"id":227158,"goal":"method MergeSort_7143(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_7144","instance":7144,"id":227159,"goal":"method ArrayCopy_7144(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_7145","instance":7145,"id":227160,"goal":"function ListReverse_7145(s: seq): seq\n ensures |ListReverse_7145(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_7145(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_7146","instance":7146,"id":227161,"goal":"function Factorial_7146(n: nat): nat\n ensures Factorial_7146(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_7146(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_7147","instance":7147,"id":227162,"goal":"function Fib_7147(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_7147(n-1) + Fib_7147(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_7148","instance":7148,"id":227163,"goal":"function Gcd_7148(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_7148(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_7149","instance":7149,"id":227164,"goal":"function Power_7149(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_7149(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_7150","instance":7150,"id":227165,"goal":"function Sum_7150(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_7150(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_7151","instance":7151,"id":227166,"goal":"method BinarySearch_7151(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_7152","instance":7152,"id":227167,"goal":"method InsertSort_7152(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_7153","instance":7153,"id":227168,"goal":"method MergeSort_7153(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_7154","instance":7154,"id":227169,"goal":"method ArrayCopy_7154(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_7155","instance":7155,"id":227170,"goal":"function ListReverse_7155(s: seq): seq\n ensures |ListReverse_7155(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_7155(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_7156","instance":7156,"id":227171,"goal":"function Factorial_7156(n: nat): nat\n ensures Factorial_7156(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_7156(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_7157","instance":7157,"id":227172,"goal":"function Fib_7157(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_7157(n-1) + Fib_7157(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_7158","instance":7158,"id":227173,"goal":"function Gcd_7158(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_7158(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_7159","instance":7159,"id":227174,"goal":"function Power_7159(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_7159(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_7160","instance":7160,"id":227175,"goal":"function Sum_7160(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_7160(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_7161","instance":7161,"id":227176,"goal":"method BinarySearch_7161(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_7162","instance":7162,"id":227177,"goal":"method InsertSort_7162(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_7163","instance":7163,"id":227178,"goal":"method MergeSort_7163(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_7164","instance":7164,"id":227179,"goal":"method ArrayCopy_7164(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_7165","instance":7165,"id":227180,"goal":"function ListReverse_7165(s: seq): seq\n ensures |ListReverse_7165(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_7165(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_7166","instance":7166,"id":227181,"goal":"function Factorial_7166(n: nat): nat\n ensures Factorial_7166(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_7166(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_7167","instance":7167,"id":227182,"goal":"function Fib_7167(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_7167(n-1) + Fib_7167(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_7168","instance":7168,"id":227183,"goal":"function Gcd_7168(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_7168(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_7169","instance":7169,"id":227184,"goal":"function Power_7169(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_7169(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_7170","instance":7170,"id":227185,"goal":"function Sum_7170(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_7170(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_7171","instance":7171,"id":227186,"goal":"method BinarySearch_7171(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_7172","instance":7172,"id":227187,"goal":"method InsertSort_7172(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_7173","instance":7173,"id":227188,"goal":"method MergeSort_7173(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_7174","instance":7174,"id":227189,"goal":"method ArrayCopy_7174(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_7175","instance":7175,"id":227190,"goal":"function ListReverse_7175(s: seq): seq\n ensures |ListReverse_7175(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_7175(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_7176","instance":7176,"id":227191,"goal":"function Factorial_7176(n: nat): nat\n ensures Factorial_7176(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_7176(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_7177","instance":7177,"id":227192,"goal":"function Fib_7177(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_7177(n-1) + Fib_7177(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_7178","instance":7178,"id":227193,"goal":"function Gcd_7178(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_7178(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_7179","instance":7179,"id":227194,"goal":"function Power_7179(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_7179(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_7180","instance":7180,"id":227195,"goal":"function Sum_7180(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_7180(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_7181","instance":7181,"id":227196,"goal":"method BinarySearch_7181(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_7182","instance":7182,"id":227197,"goal":"method InsertSort_7182(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_7183","instance":7183,"id":227198,"goal":"method MergeSort_7183(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_7184","instance":7184,"id":227199,"goal":"method ArrayCopy_7184(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_7185","instance":7185,"id":227200,"goal":"function ListReverse_7185(s: seq): seq\n ensures |ListReverse_7185(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_7185(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_7186","instance":7186,"id":227201,"goal":"function Factorial_7186(n: nat): nat\n ensures Factorial_7186(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_7186(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_7187","instance":7187,"id":227202,"goal":"function Fib_7187(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_7187(n-1) + Fib_7187(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_7188","instance":7188,"id":227203,"goal":"function Gcd_7188(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_7188(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_7189","instance":7189,"id":227204,"goal":"function Power_7189(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_7189(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_7190","instance":7190,"id":227205,"goal":"function Sum_7190(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_7190(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_7191","instance":7191,"id":227206,"goal":"method BinarySearch_7191(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_7192","instance":7192,"id":227207,"goal":"method InsertSort_7192(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_7193","instance":7193,"id":227208,"goal":"method MergeSort_7193(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_7194","instance":7194,"id":227209,"goal":"method ArrayCopy_7194(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_7195","instance":7195,"id":227210,"goal":"function ListReverse_7195(s: seq): seq\n ensures |ListReverse_7195(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_7195(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_7196","instance":7196,"id":227211,"goal":"function Factorial_7196(n: nat): nat\n ensures Factorial_7196(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_7196(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_7197","instance":7197,"id":227212,"goal":"function Fib_7197(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_7197(n-1) + Fib_7197(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_7198","instance":7198,"id":227213,"goal":"function Gcd_7198(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_7198(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_7199","instance":7199,"id":227214,"goal":"function Power_7199(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_7199(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_7200","instance":7200,"id":227215,"goal":"function Sum_7200(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_7200(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_7201","instance":7201,"id":227216,"goal":"method BinarySearch_7201(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_7202","instance":7202,"id":227217,"goal":"method InsertSort_7202(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_7203","instance":7203,"id":227218,"goal":"method MergeSort_7203(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_7204","instance":7204,"id":227219,"goal":"method ArrayCopy_7204(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_7205","instance":7205,"id":227220,"goal":"function ListReverse_7205(s: seq): seq\n ensures |ListReverse_7205(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_7205(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_7206","instance":7206,"id":227221,"goal":"function Factorial_7206(n: nat): nat\n ensures Factorial_7206(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_7206(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_7207","instance":7207,"id":227222,"goal":"function Fib_7207(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_7207(n-1) + Fib_7207(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_7208","instance":7208,"id":227223,"goal":"function Gcd_7208(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_7208(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_7209","instance":7209,"id":227224,"goal":"function Power_7209(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_7209(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_7210","instance":7210,"id":227225,"goal":"function Sum_7210(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_7210(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_7211","instance":7211,"id":227226,"goal":"method BinarySearch_7211(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_7212","instance":7212,"id":227227,"goal":"method InsertSort_7212(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_7213","instance":7213,"id":227228,"goal":"method MergeSort_7213(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_7214","instance":7214,"id":227229,"goal":"method ArrayCopy_7214(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_7215","instance":7215,"id":227230,"goal":"function ListReverse_7215(s: seq): seq\n ensures |ListReverse_7215(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_7215(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_7216","instance":7216,"id":227231,"goal":"function Factorial_7216(n: nat): nat\n ensures Factorial_7216(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_7216(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_7217","instance":7217,"id":227232,"goal":"function Fib_7217(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_7217(n-1) + Fib_7217(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_7218","instance":7218,"id":227233,"goal":"function Gcd_7218(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_7218(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_7219","instance":7219,"id":227234,"goal":"function Power_7219(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_7219(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_7220","instance":7220,"id":227235,"goal":"function Sum_7220(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_7220(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_7221","instance":7221,"id":227236,"goal":"method BinarySearch_7221(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_7222","instance":7222,"id":227237,"goal":"method InsertSort_7222(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_7223","instance":7223,"id":227238,"goal":"method MergeSort_7223(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_7224","instance":7224,"id":227239,"goal":"method ArrayCopy_7224(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_7225","instance":7225,"id":227240,"goal":"function ListReverse_7225(s: seq): seq\n ensures |ListReverse_7225(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_7225(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_7226","instance":7226,"id":227241,"goal":"function Factorial_7226(n: nat): nat\n ensures Factorial_7226(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_7226(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_7227","instance":7227,"id":227242,"goal":"function Fib_7227(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_7227(n-1) + Fib_7227(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_7228","instance":7228,"id":227243,"goal":"function Gcd_7228(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_7228(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_7229","instance":7229,"id":227244,"goal":"function Power_7229(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_7229(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_7230","instance":7230,"id":227245,"goal":"function Sum_7230(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_7230(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_7231","instance":7231,"id":227246,"goal":"method BinarySearch_7231(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_7232","instance":7232,"id":227247,"goal":"method InsertSort_7232(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_7233","instance":7233,"id":227248,"goal":"method MergeSort_7233(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_7234","instance":7234,"id":227249,"goal":"method ArrayCopy_7234(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_7235","instance":7235,"id":227250,"goal":"function ListReverse_7235(s: seq): seq\n ensures |ListReverse_7235(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_7235(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_7236","instance":7236,"id":227251,"goal":"function Factorial_7236(n: nat): nat\n ensures Factorial_7236(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_7236(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_7237","instance":7237,"id":227252,"goal":"function Fib_7237(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_7237(n-1) + Fib_7237(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_7238","instance":7238,"id":227253,"goal":"function Gcd_7238(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_7238(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_7239","instance":7239,"id":227254,"goal":"function Power_7239(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_7239(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_7240","instance":7240,"id":227255,"goal":"function Sum_7240(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_7240(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_7241","instance":7241,"id":227256,"goal":"method BinarySearch_7241(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_7242","instance":7242,"id":227257,"goal":"method InsertSort_7242(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_7243","instance":7243,"id":227258,"goal":"method MergeSort_7243(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_7244","instance":7244,"id":227259,"goal":"method ArrayCopy_7244(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_7245","instance":7245,"id":227260,"goal":"function ListReverse_7245(s: seq): seq\n ensures |ListReverse_7245(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_7245(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_7246","instance":7246,"id":227261,"goal":"function Factorial_7246(n: nat): nat\n ensures Factorial_7246(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_7246(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_7247","instance":7247,"id":227262,"goal":"function Fib_7247(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_7247(n-1) + Fib_7247(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_7248","instance":7248,"id":227263,"goal":"function Gcd_7248(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_7248(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_7249","instance":7249,"id":227264,"goal":"function Power_7249(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_7249(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_7250","instance":7250,"id":227265,"goal":"function Sum_7250(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_7250(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_7251","instance":7251,"id":227266,"goal":"method BinarySearch_7251(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_7252","instance":7252,"id":227267,"goal":"method InsertSort_7252(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_7253","instance":7253,"id":227268,"goal":"method MergeSort_7253(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_7254","instance":7254,"id":227269,"goal":"method ArrayCopy_7254(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_7255","instance":7255,"id":227270,"goal":"function ListReverse_7255(s: seq): seq\n ensures |ListReverse_7255(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_7255(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_7256","instance":7256,"id":227271,"goal":"function Factorial_7256(n: nat): nat\n ensures Factorial_7256(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_7256(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_7257","instance":7257,"id":227272,"goal":"function Fib_7257(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_7257(n-1) + Fib_7257(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_7258","instance":7258,"id":227273,"goal":"function Gcd_7258(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_7258(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_7259","instance":7259,"id":227274,"goal":"function Power_7259(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_7259(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_7260","instance":7260,"id":227275,"goal":"function Sum_7260(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_7260(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_7261","instance":7261,"id":227276,"goal":"method BinarySearch_7261(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_7262","instance":7262,"id":227277,"goal":"method InsertSort_7262(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_7263","instance":7263,"id":227278,"goal":"method MergeSort_7263(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_7264","instance":7264,"id":227279,"goal":"method ArrayCopy_7264(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_7265","instance":7265,"id":227280,"goal":"function ListReverse_7265(s: seq): seq\n ensures |ListReverse_7265(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_7265(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_7266","instance":7266,"id":227281,"goal":"function Factorial_7266(n: nat): nat\n ensures Factorial_7266(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_7266(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_7267","instance":7267,"id":227282,"goal":"function Fib_7267(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_7267(n-1) + Fib_7267(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_7268","instance":7268,"id":227283,"goal":"function Gcd_7268(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_7268(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_7269","instance":7269,"id":227284,"goal":"function Power_7269(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_7269(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_7270","instance":7270,"id":227285,"goal":"function Sum_7270(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_7270(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_7271","instance":7271,"id":227286,"goal":"method BinarySearch_7271(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_7272","instance":7272,"id":227287,"goal":"method InsertSort_7272(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_7273","instance":7273,"id":227288,"goal":"method MergeSort_7273(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_7274","instance":7274,"id":227289,"goal":"method ArrayCopy_7274(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_7275","instance":7275,"id":227290,"goal":"function ListReverse_7275(s: seq): seq\n ensures |ListReverse_7275(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_7275(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_7276","instance":7276,"id":227291,"goal":"function Factorial_7276(n: nat): nat\n ensures Factorial_7276(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_7276(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_7277","instance":7277,"id":227292,"goal":"function Fib_7277(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_7277(n-1) + Fib_7277(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_7278","instance":7278,"id":227293,"goal":"function Gcd_7278(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_7278(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_7279","instance":7279,"id":227294,"goal":"function Power_7279(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_7279(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_7280","instance":7280,"id":227295,"goal":"function Sum_7280(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_7280(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_7281","instance":7281,"id":227296,"goal":"method BinarySearch_7281(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_7282","instance":7282,"id":227297,"goal":"method InsertSort_7282(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_7283","instance":7283,"id":227298,"goal":"method MergeSort_7283(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_7284","instance":7284,"id":227299,"goal":"method ArrayCopy_7284(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_7285","instance":7285,"id":227300,"goal":"function ListReverse_7285(s: seq): seq\n ensures |ListReverse_7285(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_7285(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_7286","instance":7286,"id":227301,"goal":"function Factorial_7286(n: nat): nat\n ensures Factorial_7286(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_7286(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_7287","instance":7287,"id":227302,"goal":"function Fib_7287(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_7287(n-1) + Fib_7287(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_7288","instance":7288,"id":227303,"goal":"function Gcd_7288(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_7288(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_7289","instance":7289,"id":227304,"goal":"function Power_7289(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_7289(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_7290","instance":7290,"id":227305,"goal":"function Sum_7290(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_7290(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_7291","instance":7291,"id":227306,"goal":"method BinarySearch_7291(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_7292","instance":7292,"id":227307,"goal":"method InsertSort_7292(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_7293","instance":7293,"id":227308,"goal":"method MergeSort_7293(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_7294","instance":7294,"id":227309,"goal":"method ArrayCopy_7294(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_7295","instance":7295,"id":227310,"goal":"function ListReverse_7295(s: seq): seq\n ensures |ListReverse_7295(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_7295(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_7296","instance":7296,"id":227311,"goal":"function Factorial_7296(n: nat): nat\n ensures Factorial_7296(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_7296(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_7297","instance":7297,"id":227312,"goal":"function Fib_7297(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_7297(n-1) + Fib_7297(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_7298","instance":7298,"id":227313,"goal":"function Gcd_7298(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_7298(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_7299","instance":7299,"id":227314,"goal":"function Power_7299(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_7299(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_7300","instance":7300,"id":227315,"goal":"function Sum_7300(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_7300(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_7301","instance":7301,"id":227316,"goal":"method BinarySearch_7301(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_7302","instance":7302,"id":227317,"goal":"method InsertSort_7302(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_7303","instance":7303,"id":227318,"goal":"method MergeSort_7303(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_7304","instance":7304,"id":227319,"goal":"method ArrayCopy_7304(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_7305","instance":7305,"id":227320,"goal":"function ListReverse_7305(s: seq): seq\n ensures |ListReverse_7305(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_7305(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_7306","instance":7306,"id":227321,"goal":"function Factorial_7306(n: nat): nat\n ensures Factorial_7306(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_7306(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_7307","instance":7307,"id":227322,"goal":"function Fib_7307(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_7307(n-1) + Fib_7307(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_7308","instance":7308,"id":227323,"goal":"function Gcd_7308(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_7308(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_7309","instance":7309,"id":227324,"goal":"function Power_7309(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_7309(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_7310","instance":7310,"id":227325,"goal":"function Sum_7310(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_7310(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_7311","instance":7311,"id":227326,"goal":"method BinarySearch_7311(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_7312","instance":7312,"id":227327,"goal":"method InsertSort_7312(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_7313","instance":7313,"id":227328,"goal":"method MergeSort_7313(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_7314","instance":7314,"id":227329,"goal":"method ArrayCopy_7314(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_7315","instance":7315,"id":227330,"goal":"function ListReverse_7315(s: seq): seq\n ensures |ListReverse_7315(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_7315(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_7316","instance":7316,"id":227331,"goal":"function Factorial_7316(n: nat): nat\n ensures Factorial_7316(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_7316(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_7317","instance":7317,"id":227332,"goal":"function Fib_7317(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_7317(n-1) + Fib_7317(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_7318","instance":7318,"id":227333,"goal":"function Gcd_7318(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_7318(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_7319","instance":7319,"id":227334,"goal":"function Power_7319(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_7319(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_7320","instance":7320,"id":227335,"goal":"function Sum_7320(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_7320(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_7321","instance":7321,"id":227336,"goal":"method BinarySearch_7321(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_7322","instance":7322,"id":227337,"goal":"method InsertSort_7322(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_7323","instance":7323,"id":227338,"goal":"method MergeSort_7323(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_7324","instance":7324,"id":227339,"goal":"method ArrayCopy_7324(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_7325","instance":7325,"id":227340,"goal":"function ListReverse_7325(s: seq): seq\n ensures |ListReverse_7325(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_7325(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_7326","instance":7326,"id":227341,"goal":"function Factorial_7326(n: nat): nat\n ensures Factorial_7326(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_7326(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_7327","instance":7327,"id":227342,"goal":"function Fib_7327(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_7327(n-1) + Fib_7327(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_7328","instance":7328,"id":227343,"goal":"function Gcd_7328(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_7328(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_7329","instance":7329,"id":227344,"goal":"function Power_7329(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_7329(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_7330","instance":7330,"id":227345,"goal":"function Sum_7330(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_7330(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_7331","instance":7331,"id":227346,"goal":"method BinarySearch_7331(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_7332","instance":7332,"id":227347,"goal":"method InsertSort_7332(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_7333","instance":7333,"id":227348,"goal":"method MergeSort_7333(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_7334","instance":7334,"id":227349,"goal":"method ArrayCopy_7334(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_7335","instance":7335,"id":227350,"goal":"function ListReverse_7335(s: seq): seq\n ensures |ListReverse_7335(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_7335(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_7336","instance":7336,"id":227351,"goal":"function Factorial_7336(n: nat): nat\n ensures Factorial_7336(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_7336(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_7337","instance":7337,"id":227352,"goal":"function Fib_7337(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_7337(n-1) + Fib_7337(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_7338","instance":7338,"id":227353,"goal":"function Gcd_7338(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_7338(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_7339","instance":7339,"id":227354,"goal":"function Power_7339(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_7339(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_7340","instance":7340,"id":227355,"goal":"function Sum_7340(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_7340(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_7341","instance":7341,"id":227356,"goal":"method BinarySearch_7341(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_7342","instance":7342,"id":227357,"goal":"method InsertSort_7342(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_7343","instance":7343,"id":227358,"goal":"method MergeSort_7343(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_7344","instance":7344,"id":227359,"goal":"method ArrayCopy_7344(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_7345","instance":7345,"id":227360,"goal":"function ListReverse_7345(s: seq): seq\n ensures |ListReverse_7345(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_7345(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_7346","instance":7346,"id":227361,"goal":"function Factorial_7346(n: nat): nat\n ensures Factorial_7346(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_7346(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_7347","instance":7347,"id":227362,"goal":"function Fib_7347(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_7347(n-1) + Fib_7347(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_7348","instance":7348,"id":227363,"goal":"function Gcd_7348(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_7348(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_7349","instance":7349,"id":227364,"goal":"function Power_7349(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_7349(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_7350","instance":7350,"id":227365,"goal":"function Sum_7350(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_7350(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_7351","instance":7351,"id":227366,"goal":"method BinarySearch_7351(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_7352","instance":7352,"id":227367,"goal":"method InsertSort_7352(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_7353","instance":7353,"id":227368,"goal":"method MergeSort_7353(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_7354","instance":7354,"id":227369,"goal":"method ArrayCopy_7354(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_7355","instance":7355,"id":227370,"goal":"function ListReverse_7355(s: seq): seq\n ensures |ListReverse_7355(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_7355(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_7356","instance":7356,"id":227371,"goal":"function Factorial_7356(n: nat): nat\n ensures Factorial_7356(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_7356(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_7357","instance":7357,"id":227372,"goal":"function Fib_7357(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_7357(n-1) + Fib_7357(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_7358","instance":7358,"id":227373,"goal":"function Gcd_7358(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_7358(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_7359","instance":7359,"id":227374,"goal":"function Power_7359(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_7359(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_7360","instance":7360,"id":227375,"goal":"function Sum_7360(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_7360(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_7361","instance":7361,"id":227376,"goal":"method BinarySearch_7361(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_7362","instance":7362,"id":227377,"goal":"method InsertSort_7362(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_7363","instance":7363,"id":227378,"goal":"method MergeSort_7363(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_7364","instance":7364,"id":227379,"goal":"method ArrayCopy_7364(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_7365","instance":7365,"id":227380,"goal":"function ListReverse_7365(s: seq): seq\n ensures |ListReverse_7365(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_7365(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_7366","instance":7366,"id":227381,"goal":"function Factorial_7366(n: nat): nat\n ensures Factorial_7366(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_7366(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_7367","instance":7367,"id":227382,"goal":"function Fib_7367(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_7367(n-1) + Fib_7367(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_7368","instance":7368,"id":227383,"goal":"function Gcd_7368(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_7368(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_7369","instance":7369,"id":227384,"goal":"function Power_7369(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_7369(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_7370","instance":7370,"id":227385,"goal":"function Sum_7370(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_7370(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_7371","instance":7371,"id":227386,"goal":"method BinarySearch_7371(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_7372","instance":7372,"id":227387,"goal":"method InsertSort_7372(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_7373","instance":7373,"id":227388,"goal":"method MergeSort_7373(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_7374","instance":7374,"id":227389,"goal":"method ArrayCopy_7374(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_7375","instance":7375,"id":227390,"goal":"function ListReverse_7375(s: seq): seq\n ensures |ListReverse_7375(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_7375(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_7376","instance":7376,"id":227391,"goal":"function Factorial_7376(n: nat): nat\n ensures Factorial_7376(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_7376(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_7377","instance":7377,"id":227392,"goal":"function Fib_7377(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_7377(n-1) + Fib_7377(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_7378","instance":7378,"id":227393,"goal":"function Gcd_7378(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_7378(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_7379","instance":7379,"id":227394,"goal":"function Power_7379(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_7379(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_7380","instance":7380,"id":227395,"goal":"function Sum_7380(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_7380(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_7381","instance":7381,"id":227396,"goal":"method BinarySearch_7381(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_7382","instance":7382,"id":227397,"goal":"method InsertSort_7382(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_7383","instance":7383,"id":227398,"goal":"method MergeSort_7383(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_7384","instance":7384,"id":227399,"goal":"method ArrayCopy_7384(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_7385","instance":7385,"id":227400,"goal":"function ListReverse_7385(s: seq): seq\n ensures |ListReverse_7385(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_7385(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_7386","instance":7386,"id":227401,"goal":"function Factorial_7386(n: nat): nat\n ensures Factorial_7386(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_7386(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_7387","instance":7387,"id":227402,"goal":"function Fib_7387(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_7387(n-1) + Fib_7387(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_7388","instance":7388,"id":227403,"goal":"function Gcd_7388(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_7388(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_7389","instance":7389,"id":227404,"goal":"function Power_7389(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_7389(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_7390","instance":7390,"id":227405,"goal":"function Sum_7390(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_7390(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_7391","instance":7391,"id":227406,"goal":"method BinarySearch_7391(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_7392","instance":7392,"id":227407,"goal":"method InsertSort_7392(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_7393","instance":7393,"id":227408,"goal":"method MergeSort_7393(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_7394","instance":7394,"id":227409,"goal":"method ArrayCopy_7394(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_7395","instance":7395,"id":227410,"goal":"function ListReverse_7395(s: seq): seq\n ensures |ListReverse_7395(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_7395(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_7396","instance":7396,"id":227411,"goal":"function Factorial_7396(n: nat): nat\n ensures Factorial_7396(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_7396(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_7397","instance":7397,"id":227412,"goal":"function Fib_7397(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_7397(n-1) + Fib_7397(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_7398","instance":7398,"id":227413,"goal":"function Gcd_7398(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_7398(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_7399","instance":7399,"id":227414,"goal":"function Power_7399(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_7399(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_7400","instance":7400,"id":227415,"goal":"function Sum_7400(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_7400(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_7401","instance":7401,"id":227416,"goal":"method BinarySearch_7401(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_7402","instance":7402,"id":227417,"goal":"method InsertSort_7402(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_7403","instance":7403,"id":227418,"goal":"method MergeSort_7403(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_7404","instance":7404,"id":227419,"goal":"method ArrayCopy_7404(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_7405","instance":7405,"id":227420,"goal":"function ListReverse_7405(s: seq): seq\n ensures |ListReverse_7405(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_7405(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_7406","instance":7406,"id":227421,"goal":"function Factorial_7406(n: nat): nat\n ensures Factorial_7406(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_7406(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_7407","instance":7407,"id":227422,"goal":"function Fib_7407(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_7407(n-1) + Fib_7407(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_7408","instance":7408,"id":227423,"goal":"function Gcd_7408(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_7408(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_7409","instance":7409,"id":227424,"goal":"function Power_7409(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_7409(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_7410","instance":7410,"id":227425,"goal":"function Sum_7410(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_7410(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_7411","instance":7411,"id":227426,"goal":"method BinarySearch_7411(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_7412","instance":7412,"id":227427,"goal":"method InsertSort_7412(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_7413","instance":7413,"id":227428,"goal":"method MergeSort_7413(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_7414","instance":7414,"id":227429,"goal":"method ArrayCopy_7414(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_7415","instance":7415,"id":227430,"goal":"function ListReverse_7415(s: seq): seq\n ensures |ListReverse_7415(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_7415(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_7416","instance":7416,"id":227431,"goal":"function Factorial_7416(n: nat): nat\n ensures Factorial_7416(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_7416(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_7417","instance":7417,"id":227432,"goal":"function Fib_7417(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_7417(n-1) + Fib_7417(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_7418","instance":7418,"id":227433,"goal":"function Gcd_7418(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_7418(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_7419","instance":7419,"id":227434,"goal":"function Power_7419(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_7419(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_7420","instance":7420,"id":227435,"goal":"function Sum_7420(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_7420(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_7421","instance":7421,"id":227436,"goal":"method BinarySearch_7421(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_7422","instance":7422,"id":227437,"goal":"method InsertSort_7422(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_7423","instance":7423,"id":227438,"goal":"method MergeSort_7423(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_7424","instance":7424,"id":227439,"goal":"method ArrayCopy_7424(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_7425","instance":7425,"id":227440,"goal":"function ListReverse_7425(s: seq): seq\n ensures |ListReverse_7425(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_7425(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_7426","instance":7426,"id":227441,"goal":"function Factorial_7426(n: nat): nat\n ensures Factorial_7426(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_7426(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_7427","instance":7427,"id":227442,"goal":"function Fib_7427(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_7427(n-1) + Fib_7427(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_7428","instance":7428,"id":227443,"goal":"function Gcd_7428(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_7428(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_7429","instance":7429,"id":227444,"goal":"function Power_7429(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_7429(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_7430","instance":7430,"id":227445,"goal":"function Sum_7430(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_7430(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_7431","instance":7431,"id":227446,"goal":"method BinarySearch_7431(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_7432","instance":7432,"id":227447,"goal":"method InsertSort_7432(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_7433","instance":7433,"id":227448,"goal":"method MergeSort_7433(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_7434","instance":7434,"id":227449,"goal":"method ArrayCopy_7434(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_7435","instance":7435,"id":227450,"goal":"function ListReverse_7435(s: seq): seq\n ensures |ListReverse_7435(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_7435(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_7436","instance":7436,"id":227451,"goal":"function Factorial_7436(n: nat): nat\n ensures Factorial_7436(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_7436(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_7437","instance":7437,"id":227452,"goal":"function Fib_7437(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_7437(n-1) + Fib_7437(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_7438","instance":7438,"id":227453,"goal":"function Gcd_7438(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_7438(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_7439","instance":7439,"id":227454,"goal":"function Power_7439(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_7439(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_7440","instance":7440,"id":227455,"goal":"function Sum_7440(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_7440(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_7441","instance":7441,"id":227456,"goal":"method BinarySearch_7441(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_7442","instance":7442,"id":227457,"goal":"method InsertSort_7442(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_7443","instance":7443,"id":227458,"goal":"method MergeSort_7443(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_7444","instance":7444,"id":227459,"goal":"method ArrayCopy_7444(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_7445","instance":7445,"id":227460,"goal":"function ListReverse_7445(s: seq): seq\n ensures |ListReverse_7445(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_7445(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_7446","instance":7446,"id":227461,"goal":"function Factorial_7446(n: nat): nat\n ensures Factorial_7446(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_7446(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_7447","instance":7447,"id":227462,"goal":"function Fib_7447(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_7447(n-1) + Fib_7447(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_7448","instance":7448,"id":227463,"goal":"function Gcd_7448(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_7448(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_7449","instance":7449,"id":227464,"goal":"function Power_7449(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_7449(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_7450","instance":7450,"id":227465,"goal":"function Sum_7450(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_7450(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_7451","instance":7451,"id":227466,"goal":"method BinarySearch_7451(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_7452","instance":7452,"id":227467,"goal":"method InsertSort_7452(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_7453","instance":7453,"id":227468,"goal":"method MergeSort_7453(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_7454","instance":7454,"id":227469,"goal":"method ArrayCopy_7454(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_7455","instance":7455,"id":227470,"goal":"function ListReverse_7455(s: seq): seq\n ensures |ListReverse_7455(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_7455(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_7456","instance":7456,"id":227471,"goal":"function Factorial_7456(n: nat): nat\n ensures Factorial_7456(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_7456(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_7457","instance":7457,"id":227472,"goal":"function Fib_7457(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_7457(n-1) + Fib_7457(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_7458","instance":7458,"id":227473,"goal":"function Gcd_7458(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_7458(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_7459","instance":7459,"id":227474,"goal":"function Power_7459(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_7459(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_7460","instance":7460,"id":227475,"goal":"function Sum_7460(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_7460(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_7461","instance":7461,"id":227476,"goal":"method BinarySearch_7461(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_7462","instance":7462,"id":227477,"goal":"method InsertSort_7462(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_7463","instance":7463,"id":227478,"goal":"method MergeSort_7463(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_7464","instance":7464,"id":227479,"goal":"method ArrayCopy_7464(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_7465","instance":7465,"id":227480,"goal":"function ListReverse_7465(s: seq): seq\n ensures |ListReverse_7465(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_7465(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_7466","instance":7466,"id":227481,"goal":"function Factorial_7466(n: nat): nat\n ensures Factorial_7466(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_7466(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_7467","instance":7467,"id":227482,"goal":"function Fib_7467(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_7467(n-1) + Fib_7467(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_7468","instance":7468,"id":227483,"goal":"function Gcd_7468(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_7468(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_7469","instance":7469,"id":227484,"goal":"function Power_7469(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_7469(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_7470","instance":7470,"id":227485,"goal":"function Sum_7470(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_7470(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_7471","instance":7471,"id":227486,"goal":"method BinarySearch_7471(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_7472","instance":7472,"id":227487,"goal":"method InsertSort_7472(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_7473","instance":7473,"id":227488,"goal":"method MergeSort_7473(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_7474","instance":7474,"id":227489,"goal":"method ArrayCopy_7474(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_7475","instance":7475,"id":227490,"goal":"function ListReverse_7475(s: seq): seq\n ensures |ListReverse_7475(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_7475(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_7476","instance":7476,"id":227491,"goal":"function Factorial_7476(n: nat): nat\n ensures Factorial_7476(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_7476(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_7477","instance":7477,"id":227492,"goal":"function Fib_7477(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_7477(n-1) + Fib_7477(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_7478","instance":7478,"id":227493,"goal":"function Gcd_7478(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_7478(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_7479","instance":7479,"id":227494,"goal":"function Power_7479(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_7479(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_7480","instance":7480,"id":227495,"goal":"function Sum_7480(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_7480(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_7481","instance":7481,"id":227496,"goal":"method BinarySearch_7481(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_7482","instance":7482,"id":227497,"goal":"method InsertSort_7482(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_7483","instance":7483,"id":227498,"goal":"method MergeSort_7483(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_7484","instance":7484,"id":227499,"goal":"method ArrayCopy_7484(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_7485","instance":7485,"id":227500,"goal":"function ListReverse_7485(s: seq): seq\n ensures |ListReverse_7485(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_7485(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_7486","instance":7486,"id":227501,"goal":"function Factorial_7486(n: nat): nat\n ensures Factorial_7486(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_7486(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_7487","instance":7487,"id":227502,"goal":"function Fib_7487(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_7487(n-1) + Fib_7487(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_7488","instance":7488,"id":227503,"goal":"function Gcd_7488(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_7488(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_7489","instance":7489,"id":227504,"goal":"function Power_7489(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_7489(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_7490","instance":7490,"id":227505,"goal":"function Sum_7490(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_7490(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_7491","instance":7491,"id":227506,"goal":"method BinarySearch_7491(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_7492","instance":7492,"id":227507,"goal":"method InsertSort_7492(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_7493","instance":7493,"id":227508,"goal":"method MergeSort_7493(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_7494","instance":7494,"id":227509,"goal":"method ArrayCopy_7494(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_7495","instance":7495,"id":227510,"goal":"function ListReverse_7495(s: seq): seq\n ensures |ListReverse_7495(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_7495(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_7496","instance":7496,"id":227511,"goal":"function Factorial_7496(n: nat): nat\n ensures Factorial_7496(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_7496(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_7497","instance":7497,"id":227512,"goal":"function Fib_7497(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_7497(n-1) + Fib_7497(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_7498","instance":7498,"id":227513,"goal":"function Gcd_7498(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_7498(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_7499","instance":7499,"id":227514,"goal":"function Power_7499(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_7499(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_7500","instance":7500,"id":227515,"goal":"function Sum_7500(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_7500(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_7501","instance":7501,"id":227516,"goal":"method BinarySearch_7501(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_7502","instance":7502,"id":227517,"goal":"method InsertSort_7502(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_7503","instance":7503,"id":227518,"goal":"method MergeSort_7503(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_7504","instance":7504,"id":227519,"goal":"method ArrayCopy_7504(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_7505","instance":7505,"id":227520,"goal":"function ListReverse_7505(s: seq): seq\n ensures |ListReverse_7505(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_7505(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_7506","instance":7506,"id":227521,"goal":"function Factorial_7506(n: nat): nat\n ensures Factorial_7506(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_7506(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_7507","instance":7507,"id":227522,"goal":"function Fib_7507(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_7507(n-1) + Fib_7507(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_7508","instance":7508,"id":227523,"goal":"function Gcd_7508(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_7508(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_7509","instance":7509,"id":227524,"goal":"function Power_7509(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_7509(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_7510","instance":7510,"id":227525,"goal":"function Sum_7510(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_7510(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_7511","instance":7511,"id":227526,"goal":"method BinarySearch_7511(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_7512","instance":7512,"id":227527,"goal":"method InsertSort_7512(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_7513","instance":7513,"id":227528,"goal":"method MergeSort_7513(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_7514","instance":7514,"id":227529,"goal":"method ArrayCopy_7514(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_7515","instance":7515,"id":227530,"goal":"function ListReverse_7515(s: seq): seq\n ensures |ListReverse_7515(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_7515(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_7516","instance":7516,"id":227531,"goal":"function Factorial_7516(n: nat): nat\n ensures Factorial_7516(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_7516(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_7517","instance":7517,"id":227532,"goal":"function Fib_7517(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_7517(n-1) + Fib_7517(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_7518","instance":7518,"id":227533,"goal":"function Gcd_7518(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_7518(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_7519","instance":7519,"id":227534,"goal":"function Power_7519(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_7519(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_7520","instance":7520,"id":227535,"goal":"function Sum_7520(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_7520(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_7521","instance":7521,"id":227536,"goal":"method BinarySearch_7521(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_7522","instance":7522,"id":227537,"goal":"method InsertSort_7522(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_7523","instance":7523,"id":227538,"goal":"method MergeSort_7523(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_7524","instance":7524,"id":227539,"goal":"method ArrayCopy_7524(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_7525","instance":7525,"id":227540,"goal":"function ListReverse_7525(s: seq): seq\n ensures |ListReverse_7525(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_7525(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_7526","instance":7526,"id":227541,"goal":"function Factorial_7526(n: nat): nat\n ensures Factorial_7526(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_7526(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_7527","instance":7527,"id":227542,"goal":"function Fib_7527(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_7527(n-1) + Fib_7527(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_7528","instance":7528,"id":227543,"goal":"function Gcd_7528(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_7528(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_7529","instance":7529,"id":227544,"goal":"function Power_7529(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_7529(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_7530","instance":7530,"id":227545,"goal":"function Sum_7530(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_7530(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_7531","instance":7531,"id":227546,"goal":"method BinarySearch_7531(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_7532","instance":7532,"id":227547,"goal":"method InsertSort_7532(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_7533","instance":7533,"id":227548,"goal":"method MergeSort_7533(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_7534","instance":7534,"id":227549,"goal":"method ArrayCopy_7534(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_7535","instance":7535,"id":227550,"goal":"function ListReverse_7535(s: seq): seq\n ensures |ListReverse_7535(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_7535(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_7536","instance":7536,"id":227551,"goal":"function Factorial_7536(n: nat): nat\n ensures Factorial_7536(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_7536(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_7537","instance":7537,"id":227552,"goal":"function Fib_7537(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_7537(n-1) + Fib_7537(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_7538","instance":7538,"id":227553,"goal":"function Gcd_7538(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_7538(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_7539","instance":7539,"id":227554,"goal":"function Power_7539(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_7539(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_7540","instance":7540,"id":227555,"goal":"function Sum_7540(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_7540(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_7541","instance":7541,"id":227556,"goal":"method BinarySearch_7541(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_7542","instance":7542,"id":227557,"goal":"method InsertSort_7542(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_7543","instance":7543,"id":227558,"goal":"method MergeSort_7543(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_7544","instance":7544,"id":227559,"goal":"method ArrayCopy_7544(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_7545","instance":7545,"id":227560,"goal":"function ListReverse_7545(s: seq): seq\n ensures |ListReverse_7545(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_7545(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_7546","instance":7546,"id":227561,"goal":"function Factorial_7546(n: nat): nat\n ensures Factorial_7546(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_7546(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_7547","instance":7547,"id":227562,"goal":"function Fib_7547(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_7547(n-1) + Fib_7547(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_7548","instance":7548,"id":227563,"goal":"function Gcd_7548(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_7548(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_7549","instance":7549,"id":227564,"goal":"function Power_7549(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_7549(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_7550","instance":7550,"id":227565,"goal":"function Sum_7550(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_7550(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_7551","instance":7551,"id":227566,"goal":"method BinarySearch_7551(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_7552","instance":7552,"id":227567,"goal":"method InsertSort_7552(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_7553","instance":7553,"id":227568,"goal":"method MergeSort_7553(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_7554","instance":7554,"id":227569,"goal":"method ArrayCopy_7554(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_7555","instance":7555,"id":227570,"goal":"function ListReverse_7555(s: seq): seq\n ensures |ListReverse_7555(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_7555(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_7556","instance":7556,"id":227571,"goal":"function Factorial_7556(n: nat): nat\n ensures Factorial_7556(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_7556(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_7557","instance":7557,"id":227572,"goal":"function Fib_7557(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_7557(n-1) + Fib_7557(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_7558","instance":7558,"id":227573,"goal":"function Gcd_7558(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_7558(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_7559","instance":7559,"id":227574,"goal":"function Power_7559(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_7559(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_7560","instance":7560,"id":227575,"goal":"function Sum_7560(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_7560(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_7561","instance":7561,"id":227576,"goal":"method BinarySearch_7561(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_7562","instance":7562,"id":227577,"goal":"method InsertSort_7562(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_7563","instance":7563,"id":227578,"goal":"method MergeSort_7563(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_7564","instance":7564,"id":227579,"goal":"method ArrayCopy_7564(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_7565","instance":7565,"id":227580,"goal":"function ListReverse_7565(s: seq): seq\n ensures |ListReverse_7565(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_7565(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_7566","instance":7566,"id":227581,"goal":"function Factorial_7566(n: nat): nat\n ensures Factorial_7566(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_7566(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_7567","instance":7567,"id":227582,"goal":"function Fib_7567(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_7567(n-1) + Fib_7567(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_7568","instance":7568,"id":227583,"goal":"function Gcd_7568(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_7568(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_7569","instance":7569,"id":227584,"goal":"function Power_7569(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_7569(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_7570","instance":7570,"id":227585,"goal":"function Sum_7570(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_7570(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_7571","instance":7571,"id":227586,"goal":"method BinarySearch_7571(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_7572","instance":7572,"id":227587,"goal":"method InsertSort_7572(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_7573","instance":7573,"id":227588,"goal":"method MergeSort_7573(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_7574","instance":7574,"id":227589,"goal":"method ArrayCopy_7574(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_7575","instance":7575,"id":227590,"goal":"function ListReverse_7575(s: seq): seq\n ensures |ListReverse_7575(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_7575(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_7576","instance":7576,"id":227591,"goal":"function Factorial_7576(n: nat): nat\n ensures Factorial_7576(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_7576(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_7577","instance":7577,"id":227592,"goal":"function Fib_7577(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_7577(n-1) + Fib_7577(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_7578","instance":7578,"id":227593,"goal":"function Gcd_7578(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_7578(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_7579","instance":7579,"id":227594,"goal":"function Power_7579(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_7579(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_7580","instance":7580,"id":227595,"goal":"function Sum_7580(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_7580(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_7581","instance":7581,"id":227596,"goal":"method BinarySearch_7581(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_7582","instance":7582,"id":227597,"goal":"method InsertSort_7582(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_7583","instance":7583,"id":227598,"goal":"method MergeSort_7583(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_7584","instance":7584,"id":227599,"goal":"method ArrayCopy_7584(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_7585","instance":7585,"id":227600,"goal":"function ListReverse_7585(s: seq): seq\n ensures |ListReverse_7585(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_7585(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_7586","instance":7586,"id":227601,"goal":"function Factorial_7586(n: nat): nat\n ensures Factorial_7586(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_7586(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_7587","instance":7587,"id":227602,"goal":"function Fib_7587(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_7587(n-1) + Fib_7587(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_7588","instance":7588,"id":227603,"goal":"function Gcd_7588(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_7588(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_7589","instance":7589,"id":227604,"goal":"function Power_7589(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_7589(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_7590","instance":7590,"id":227605,"goal":"function Sum_7590(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_7590(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_7591","instance":7591,"id":227606,"goal":"method BinarySearch_7591(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_7592","instance":7592,"id":227607,"goal":"method InsertSort_7592(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_7593","instance":7593,"id":227608,"goal":"method MergeSort_7593(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_7594","instance":7594,"id":227609,"goal":"method ArrayCopy_7594(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_7595","instance":7595,"id":227610,"goal":"function ListReverse_7595(s: seq): seq\n ensures |ListReverse_7595(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_7595(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_7596","instance":7596,"id":227611,"goal":"function Factorial_7596(n: nat): nat\n ensures Factorial_7596(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_7596(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_7597","instance":7597,"id":227612,"goal":"function Fib_7597(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_7597(n-1) + Fib_7597(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_7598","instance":7598,"id":227613,"goal":"function Gcd_7598(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_7598(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_7599","instance":7599,"id":227614,"goal":"function Power_7599(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_7599(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_7600","instance":7600,"id":227615,"goal":"function Sum_7600(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_7600(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_7601","instance":7601,"id":227616,"goal":"method BinarySearch_7601(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_7602","instance":7602,"id":227617,"goal":"method InsertSort_7602(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_7603","instance":7603,"id":227618,"goal":"method MergeSort_7603(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_7604","instance":7604,"id":227619,"goal":"method ArrayCopy_7604(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_7605","instance":7605,"id":227620,"goal":"function ListReverse_7605(s: seq): seq\n ensures |ListReverse_7605(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_7605(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_7606","instance":7606,"id":227621,"goal":"function Factorial_7606(n: nat): nat\n ensures Factorial_7606(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_7606(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_7607","instance":7607,"id":227622,"goal":"function Fib_7607(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_7607(n-1) + Fib_7607(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_7608","instance":7608,"id":227623,"goal":"function Gcd_7608(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_7608(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_7609","instance":7609,"id":227624,"goal":"function Power_7609(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_7609(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_7610","instance":7610,"id":227625,"goal":"function Sum_7610(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_7610(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_7611","instance":7611,"id":227626,"goal":"method BinarySearch_7611(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_7612","instance":7612,"id":227627,"goal":"method InsertSort_7612(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_7613","instance":7613,"id":227628,"goal":"method MergeSort_7613(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_7614","instance":7614,"id":227629,"goal":"method ArrayCopy_7614(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_7615","instance":7615,"id":227630,"goal":"function ListReverse_7615(s: seq): seq\n ensures |ListReverse_7615(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_7615(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_7616","instance":7616,"id":227631,"goal":"function Factorial_7616(n: nat): nat\n ensures Factorial_7616(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_7616(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_7617","instance":7617,"id":227632,"goal":"function Fib_7617(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_7617(n-1) + Fib_7617(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_7618","instance":7618,"id":227633,"goal":"function Gcd_7618(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_7618(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_7619","instance":7619,"id":227634,"goal":"function Power_7619(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_7619(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_7620","instance":7620,"id":227635,"goal":"function Sum_7620(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_7620(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_7621","instance":7621,"id":227636,"goal":"method BinarySearch_7621(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_7622","instance":7622,"id":227637,"goal":"method InsertSort_7622(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_7623","instance":7623,"id":227638,"goal":"method MergeSort_7623(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_7624","instance":7624,"id":227639,"goal":"method ArrayCopy_7624(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_7625","instance":7625,"id":227640,"goal":"function ListReverse_7625(s: seq): seq\n ensures |ListReverse_7625(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_7625(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_7626","instance":7626,"id":227641,"goal":"function Factorial_7626(n: nat): nat\n ensures Factorial_7626(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_7626(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_7627","instance":7627,"id":227642,"goal":"function Fib_7627(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_7627(n-1) + Fib_7627(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_7628","instance":7628,"id":227643,"goal":"function Gcd_7628(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_7628(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_7629","instance":7629,"id":227644,"goal":"function Power_7629(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_7629(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_7630","instance":7630,"id":227645,"goal":"function Sum_7630(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_7630(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_7631","instance":7631,"id":227646,"goal":"method BinarySearch_7631(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_7632","instance":7632,"id":227647,"goal":"method InsertSort_7632(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_7633","instance":7633,"id":227648,"goal":"method MergeSort_7633(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_7634","instance":7634,"id":227649,"goal":"method ArrayCopy_7634(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_7635","instance":7635,"id":227650,"goal":"function ListReverse_7635(s: seq): seq\n ensures |ListReverse_7635(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_7635(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_7636","instance":7636,"id":227651,"goal":"function Factorial_7636(n: nat): nat\n ensures Factorial_7636(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_7636(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_7637","instance":7637,"id":227652,"goal":"function Fib_7637(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_7637(n-1) + Fib_7637(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_7638","instance":7638,"id":227653,"goal":"function Gcd_7638(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_7638(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_7639","instance":7639,"id":227654,"goal":"function Power_7639(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_7639(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_7640","instance":7640,"id":227655,"goal":"function Sum_7640(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_7640(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_7641","instance":7641,"id":227656,"goal":"method BinarySearch_7641(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_7642","instance":7642,"id":227657,"goal":"method InsertSort_7642(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_7643","instance":7643,"id":227658,"goal":"method MergeSort_7643(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_7644","instance":7644,"id":227659,"goal":"method ArrayCopy_7644(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_7645","instance":7645,"id":227660,"goal":"function ListReverse_7645(s: seq): seq\n ensures |ListReverse_7645(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_7645(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_7646","instance":7646,"id":227661,"goal":"function Factorial_7646(n: nat): nat\n ensures Factorial_7646(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_7646(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_7647","instance":7647,"id":227662,"goal":"function Fib_7647(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_7647(n-1) + Fib_7647(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_7648","instance":7648,"id":227663,"goal":"function Gcd_7648(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_7648(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_7649","instance":7649,"id":227664,"goal":"function Power_7649(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_7649(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_7650","instance":7650,"id":227665,"goal":"function Sum_7650(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_7650(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_7651","instance":7651,"id":227666,"goal":"method BinarySearch_7651(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_7652","instance":7652,"id":227667,"goal":"method InsertSort_7652(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_7653","instance":7653,"id":227668,"goal":"method MergeSort_7653(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_7654","instance":7654,"id":227669,"goal":"method ArrayCopy_7654(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_7655","instance":7655,"id":227670,"goal":"function ListReverse_7655(s: seq): seq\n ensures |ListReverse_7655(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_7655(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_7656","instance":7656,"id":227671,"goal":"function Factorial_7656(n: nat): nat\n ensures Factorial_7656(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_7656(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_7657","instance":7657,"id":227672,"goal":"function Fib_7657(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_7657(n-1) + Fib_7657(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_7658","instance":7658,"id":227673,"goal":"function Gcd_7658(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_7658(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_7659","instance":7659,"id":227674,"goal":"function Power_7659(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_7659(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_7660","instance":7660,"id":227675,"goal":"function Sum_7660(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_7660(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_7661","instance":7661,"id":227676,"goal":"method BinarySearch_7661(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_7662","instance":7662,"id":227677,"goal":"method InsertSort_7662(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_7663","instance":7663,"id":227678,"goal":"method MergeSort_7663(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_7664","instance":7664,"id":227679,"goal":"method ArrayCopy_7664(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_7665","instance":7665,"id":227680,"goal":"function ListReverse_7665(s: seq): seq\n ensures |ListReverse_7665(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_7665(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_7666","instance":7666,"id":227681,"goal":"function Factorial_7666(n: nat): nat\n ensures Factorial_7666(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_7666(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_7667","instance":7667,"id":227682,"goal":"function Fib_7667(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_7667(n-1) + Fib_7667(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_7668","instance":7668,"id":227683,"goal":"function Gcd_7668(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_7668(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_7669","instance":7669,"id":227684,"goal":"function Power_7669(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_7669(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_7670","instance":7670,"id":227685,"goal":"function Sum_7670(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_7670(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_7671","instance":7671,"id":227686,"goal":"method BinarySearch_7671(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_7672","instance":7672,"id":227687,"goal":"method InsertSort_7672(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_7673","instance":7673,"id":227688,"goal":"method MergeSort_7673(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_7674","instance":7674,"id":227689,"goal":"method ArrayCopy_7674(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_7675","instance":7675,"id":227690,"goal":"function ListReverse_7675(s: seq): seq\n ensures |ListReverse_7675(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_7675(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_7676","instance":7676,"id":227691,"goal":"function Factorial_7676(n: nat): nat\n ensures Factorial_7676(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_7676(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_7677","instance":7677,"id":227692,"goal":"function Fib_7677(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_7677(n-1) + Fib_7677(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_7678","instance":7678,"id":227693,"goal":"function Gcd_7678(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_7678(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_7679","instance":7679,"id":227694,"goal":"function Power_7679(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_7679(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_7680","instance":7680,"id":227695,"goal":"function Sum_7680(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_7680(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_7681","instance":7681,"id":227696,"goal":"method BinarySearch_7681(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_7682","instance":7682,"id":227697,"goal":"method InsertSort_7682(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_7683","instance":7683,"id":227698,"goal":"method MergeSort_7683(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_7684","instance":7684,"id":227699,"goal":"method ArrayCopy_7684(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_7685","instance":7685,"id":227700,"goal":"function ListReverse_7685(s: seq): seq\n ensures |ListReverse_7685(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_7685(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_7686","instance":7686,"id":227701,"goal":"function Factorial_7686(n: nat): nat\n ensures Factorial_7686(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_7686(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_7687","instance":7687,"id":227702,"goal":"function Fib_7687(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_7687(n-1) + Fib_7687(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_7688","instance":7688,"id":227703,"goal":"function Gcd_7688(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_7688(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_7689","instance":7689,"id":227704,"goal":"function Power_7689(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_7689(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_7690","instance":7690,"id":227705,"goal":"function Sum_7690(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_7690(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_7691","instance":7691,"id":227706,"goal":"method BinarySearch_7691(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_7692","instance":7692,"id":227707,"goal":"method InsertSort_7692(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_7693","instance":7693,"id":227708,"goal":"method MergeSort_7693(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_7694","instance":7694,"id":227709,"goal":"method ArrayCopy_7694(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_7695","instance":7695,"id":227710,"goal":"function ListReverse_7695(s: seq): seq\n ensures |ListReverse_7695(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_7695(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_7696","instance":7696,"id":227711,"goal":"function Factorial_7696(n: nat): nat\n ensures Factorial_7696(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_7696(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_7697","instance":7697,"id":227712,"goal":"function Fib_7697(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_7697(n-1) + Fib_7697(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_7698","instance":7698,"id":227713,"goal":"function Gcd_7698(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_7698(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_7699","instance":7699,"id":227714,"goal":"function Power_7699(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_7699(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_7700","instance":7700,"id":227715,"goal":"function Sum_7700(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_7700(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_7701","instance":7701,"id":227716,"goal":"method BinarySearch_7701(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_7702","instance":7702,"id":227717,"goal":"method InsertSort_7702(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_7703","instance":7703,"id":227718,"goal":"method MergeSort_7703(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_7704","instance":7704,"id":227719,"goal":"method ArrayCopy_7704(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_7705","instance":7705,"id":227720,"goal":"function ListReverse_7705(s: seq): seq\n ensures |ListReverse_7705(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_7705(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_7706","instance":7706,"id":227721,"goal":"function Factorial_7706(n: nat): nat\n ensures Factorial_7706(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_7706(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_7707","instance":7707,"id":227722,"goal":"function Fib_7707(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_7707(n-1) + Fib_7707(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_7708","instance":7708,"id":227723,"goal":"function Gcd_7708(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_7708(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_7709","instance":7709,"id":227724,"goal":"function Power_7709(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_7709(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_7710","instance":7710,"id":227725,"goal":"function Sum_7710(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_7710(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_7711","instance":7711,"id":227726,"goal":"method BinarySearch_7711(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_7712","instance":7712,"id":227727,"goal":"method InsertSort_7712(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_7713","instance":7713,"id":227728,"goal":"method MergeSort_7713(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_7714","instance":7714,"id":227729,"goal":"method ArrayCopy_7714(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_7715","instance":7715,"id":227730,"goal":"function ListReverse_7715(s: seq): seq\n ensures |ListReverse_7715(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_7715(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_7716","instance":7716,"id":227731,"goal":"function Factorial_7716(n: nat): nat\n ensures Factorial_7716(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_7716(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_7717","instance":7717,"id":227732,"goal":"function Fib_7717(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_7717(n-1) + Fib_7717(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_7718","instance":7718,"id":227733,"goal":"function Gcd_7718(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_7718(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_7719","instance":7719,"id":227734,"goal":"function Power_7719(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_7719(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_7720","instance":7720,"id":227735,"goal":"function Sum_7720(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_7720(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_7721","instance":7721,"id":227736,"goal":"method BinarySearch_7721(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_7722","instance":7722,"id":227737,"goal":"method InsertSort_7722(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_7723","instance":7723,"id":227738,"goal":"method MergeSort_7723(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_7724","instance":7724,"id":227739,"goal":"method ArrayCopy_7724(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_7725","instance":7725,"id":227740,"goal":"function ListReverse_7725(s: seq): seq\n ensures |ListReverse_7725(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_7725(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_7726","instance":7726,"id":227741,"goal":"function Factorial_7726(n: nat): nat\n ensures Factorial_7726(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_7726(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_7727","instance":7727,"id":227742,"goal":"function Fib_7727(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_7727(n-1) + Fib_7727(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_7728","instance":7728,"id":227743,"goal":"function Gcd_7728(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_7728(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_7729","instance":7729,"id":227744,"goal":"function Power_7729(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_7729(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_7730","instance":7730,"id":227745,"goal":"function Sum_7730(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_7730(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_7731","instance":7731,"id":227746,"goal":"method BinarySearch_7731(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_7732","instance":7732,"id":227747,"goal":"method InsertSort_7732(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_7733","instance":7733,"id":227748,"goal":"method MergeSort_7733(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_7734","instance":7734,"id":227749,"goal":"method ArrayCopy_7734(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_7735","instance":7735,"id":227750,"goal":"function ListReverse_7735(s: seq): seq\n ensures |ListReverse_7735(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_7735(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_7736","instance":7736,"id":227751,"goal":"function Factorial_7736(n: nat): nat\n ensures Factorial_7736(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_7736(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_7737","instance":7737,"id":227752,"goal":"function Fib_7737(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_7737(n-1) + Fib_7737(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_7738","instance":7738,"id":227753,"goal":"function Gcd_7738(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_7738(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_7739","instance":7739,"id":227754,"goal":"function Power_7739(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_7739(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_7740","instance":7740,"id":227755,"goal":"function Sum_7740(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_7740(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_7741","instance":7741,"id":227756,"goal":"method BinarySearch_7741(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_7742","instance":7742,"id":227757,"goal":"method InsertSort_7742(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_7743","instance":7743,"id":227758,"goal":"method MergeSort_7743(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_7744","instance":7744,"id":227759,"goal":"method ArrayCopy_7744(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_7745","instance":7745,"id":227760,"goal":"function ListReverse_7745(s: seq): seq\n ensures |ListReverse_7745(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_7745(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_7746","instance":7746,"id":227761,"goal":"function Factorial_7746(n: nat): nat\n ensures Factorial_7746(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_7746(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_7747","instance":7747,"id":227762,"goal":"function Fib_7747(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_7747(n-1) + Fib_7747(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_7748","instance":7748,"id":227763,"goal":"function Gcd_7748(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_7748(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_7749","instance":7749,"id":227764,"goal":"function Power_7749(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_7749(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_7750","instance":7750,"id":227765,"goal":"function Sum_7750(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_7750(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_7751","instance":7751,"id":227766,"goal":"method BinarySearch_7751(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_7752","instance":7752,"id":227767,"goal":"method InsertSort_7752(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_7753","instance":7753,"id":227768,"goal":"method MergeSort_7753(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_7754","instance":7754,"id":227769,"goal":"method ArrayCopy_7754(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_7755","instance":7755,"id":227770,"goal":"function ListReverse_7755(s: seq): seq\n ensures |ListReverse_7755(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_7755(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_7756","instance":7756,"id":227771,"goal":"function Factorial_7756(n: nat): nat\n ensures Factorial_7756(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_7756(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_7757","instance":7757,"id":227772,"goal":"function Fib_7757(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_7757(n-1) + Fib_7757(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_7758","instance":7758,"id":227773,"goal":"function Gcd_7758(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_7758(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_7759","instance":7759,"id":227774,"goal":"function Power_7759(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_7759(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_7760","instance":7760,"id":227775,"goal":"function Sum_7760(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_7760(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_7761","instance":7761,"id":227776,"goal":"method BinarySearch_7761(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_7762","instance":7762,"id":227777,"goal":"method InsertSort_7762(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_7763","instance":7763,"id":227778,"goal":"method MergeSort_7763(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_7764","instance":7764,"id":227779,"goal":"method ArrayCopy_7764(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_7765","instance":7765,"id":227780,"goal":"function ListReverse_7765(s: seq): seq\n ensures |ListReverse_7765(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_7765(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_7766","instance":7766,"id":227781,"goal":"function Factorial_7766(n: nat): nat\n ensures Factorial_7766(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_7766(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_7767","instance":7767,"id":227782,"goal":"function Fib_7767(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_7767(n-1) + Fib_7767(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_7768","instance":7768,"id":227783,"goal":"function Gcd_7768(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_7768(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_7769","instance":7769,"id":227784,"goal":"function Power_7769(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_7769(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_7770","instance":7770,"id":227785,"goal":"function Sum_7770(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_7770(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_7771","instance":7771,"id":227786,"goal":"method BinarySearch_7771(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_7772","instance":7772,"id":227787,"goal":"method InsertSort_7772(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_7773","instance":7773,"id":227788,"goal":"method MergeSort_7773(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_7774","instance":7774,"id":227789,"goal":"method ArrayCopy_7774(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_7775","instance":7775,"id":227790,"goal":"function ListReverse_7775(s: seq): seq\n ensures |ListReverse_7775(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_7775(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_7776","instance":7776,"id":227791,"goal":"function Factorial_7776(n: nat): nat\n ensures Factorial_7776(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_7776(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_7777","instance":7777,"id":227792,"goal":"function Fib_7777(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_7777(n-1) + Fib_7777(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_7778","instance":7778,"id":227793,"goal":"function Gcd_7778(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_7778(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_7779","instance":7779,"id":227794,"goal":"function Power_7779(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_7779(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_7780","instance":7780,"id":227795,"goal":"function Sum_7780(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_7780(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_7781","instance":7781,"id":227796,"goal":"method BinarySearch_7781(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_7782","instance":7782,"id":227797,"goal":"method InsertSort_7782(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_7783","instance":7783,"id":227798,"goal":"method MergeSort_7783(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_7784","instance":7784,"id":227799,"goal":"method ArrayCopy_7784(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_7785","instance":7785,"id":227800,"goal":"function ListReverse_7785(s: seq): seq\n ensures |ListReverse_7785(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_7785(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_7786","instance":7786,"id":227801,"goal":"function Factorial_7786(n: nat): nat\n ensures Factorial_7786(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_7786(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_7787","instance":7787,"id":227802,"goal":"function Fib_7787(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_7787(n-1) + Fib_7787(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_7788","instance":7788,"id":227803,"goal":"function Gcd_7788(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_7788(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_7789","instance":7789,"id":227804,"goal":"function Power_7789(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_7789(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_7790","instance":7790,"id":227805,"goal":"function Sum_7790(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_7790(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_7791","instance":7791,"id":227806,"goal":"method BinarySearch_7791(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_7792","instance":7792,"id":227807,"goal":"method InsertSort_7792(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_7793","instance":7793,"id":227808,"goal":"method MergeSort_7793(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_7794","instance":7794,"id":227809,"goal":"method ArrayCopy_7794(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_7795","instance":7795,"id":227810,"goal":"function ListReverse_7795(s: seq): seq\n ensures |ListReverse_7795(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_7795(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_7796","instance":7796,"id":227811,"goal":"function Factorial_7796(n: nat): nat\n ensures Factorial_7796(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_7796(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_7797","instance":7797,"id":227812,"goal":"function Fib_7797(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_7797(n-1) + Fib_7797(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_7798","instance":7798,"id":227813,"goal":"function Gcd_7798(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_7798(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_7799","instance":7799,"id":227814,"goal":"function Power_7799(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_7799(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_7800","instance":7800,"id":227815,"goal":"function Sum_7800(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_7800(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_7801","instance":7801,"id":227816,"goal":"method BinarySearch_7801(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_7802","instance":7802,"id":227817,"goal":"method InsertSort_7802(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_7803","instance":7803,"id":227818,"goal":"method MergeSort_7803(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_7804","instance":7804,"id":227819,"goal":"method ArrayCopy_7804(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_7805","instance":7805,"id":227820,"goal":"function ListReverse_7805(s: seq): seq\n ensures |ListReverse_7805(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_7805(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_7806","instance":7806,"id":227821,"goal":"function Factorial_7806(n: nat): nat\n ensures Factorial_7806(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_7806(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_7807","instance":7807,"id":227822,"goal":"function Fib_7807(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_7807(n-1) + Fib_7807(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_7808","instance":7808,"id":227823,"goal":"function Gcd_7808(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_7808(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_7809","instance":7809,"id":227824,"goal":"function Power_7809(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_7809(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_7810","instance":7810,"id":227825,"goal":"function Sum_7810(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_7810(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_7811","instance":7811,"id":227826,"goal":"method BinarySearch_7811(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_7812","instance":7812,"id":227827,"goal":"method InsertSort_7812(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_7813","instance":7813,"id":227828,"goal":"method MergeSort_7813(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_7814","instance":7814,"id":227829,"goal":"method ArrayCopy_7814(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_7815","instance":7815,"id":227830,"goal":"function ListReverse_7815(s: seq): seq\n ensures |ListReverse_7815(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_7815(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_7816","instance":7816,"id":227831,"goal":"function Factorial_7816(n: nat): nat\n ensures Factorial_7816(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_7816(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_7817","instance":7817,"id":227832,"goal":"function Fib_7817(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_7817(n-1) + Fib_7817(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_7818","instance":7818,"id":227833,"goal":"function Gcd_7818(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_7818(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_7819","instance":7819,"id":227834,"goal":"function Power_7819(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_7819(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_7820","instance":7820,"id":227835,"goal":"function Sum_7820(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_7820(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_7821","instance":7821,"id":227836,"goal":"method BinarySearch_7821(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_7822","instance":7822,"id":227837,"goal":"method InsertSort_7822(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_7823","instance":7823,"id":227838,"goal":"method MergeSort_7823(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_7824","instance":7824,"id":227839,"goal":"method ArrayCopy_7824(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_7825","instance":7825,"id":227840,"goal":"function ListReverse_7825(s: seq): seq\n ensures |ListReverse_7825(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_7825(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_7826","instance":7826,"id":227841,"goal":"function Factorial_7826(n: nat): nat\n ensures Factorial_7826(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_7826(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_7827","instance":7827,"id":227842,"goal":"function Fib_7827(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_7827(n-1) + Fib_7827(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_7828","instance":7828,"id":227843,"goal":"function Gcd_7828(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_7828(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_7829","instance":7829,"id":227844,"goal":"function Power_7829(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_7829(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_7830","instance":7830,"id":227845,"goal":"function Sum_7830(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_7830(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_7831","instance":7831,"id":227846,"goal":"method BinarySearch_7831(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_7832","instance":7832,"id":227847,"goal":"method InsertSort_7832(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_7833","instance":7833,"id":227848,"goal":"method MergeSort_7833(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_7834","instance":7834,"id":227849,"goal":"method ArrayCopy_7834(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_7835","instance":7835,"id":227850,"goal":"function ListReverse_7835(s: seq): seq\n ensures |ListReverse_7835(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_7835(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_7836","instance":7836,"id":227851,"goal":"function Factorial_7836(n: nat): nat\n ensures Factorial_7836(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_7836(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_7837","instance":7837,"id":227852,"goal":"function Fib_7837(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_7837(n-1) + Fib_7837(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_7838","instance":7838,"id":227853,"goal":"function Gcd_7838(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_7838(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_7839","instance":7839,"id":227854,"goal":"function Power_7839(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_7839(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_7840","instance":7840,"id":227855,"goal":"function Sum_7840(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_7840(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_7841","instance":7841,"id":227856,"goal":"method BinarySearch_7841(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_7842","instance":7842,"id":227857,"goal":"method InsertSort_7842(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_7843","instance":7843,"id":227858,"goal":"method MergeSort_7843(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_7844","instance":7844,"id":227859,"goal":"method ArrayCopy_7844(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_7845","instance":7845,"id":227860,"goal":"function ListReverse_7845(s: seq): seq\n ensures |ListReverse_7845(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_7845(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_7846","instance":7846,"id":227861,"goal":"function Factorial_7846(n: nat): nat\n ensures Factorial_7846(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_7846(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_7847","instance":7847,"id":227862,"goal":"function Fib_7847(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_7847(n-1) + Fib_7847(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_7848","instance":7848,"id":227863,"goal":"function Gcd_7848(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_7848(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_7849","instance":7849,"id":227864,"goal":"function Power_7849(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_7849(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_7850","instance":7850,"id":227865,"goal":"function Sum_7850(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_7850(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_7851","instance":7851,"id":227866,"goal":"method BinarySearch_7851(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_7852","instance":7852,"id":227867,"goal":"method InsertSort_7852(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_7853","instance":7853,"id":227868,"goal":"method MergeSort_7853(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_7854","instance":7854,"id":227869,"goal":"method ArrayCopy_7854(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_7855","instance":7855,"id":227870,"goal":"function ListReverse_7855(s: seq): seq\n ensures |ListReverse_7855(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_7855(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_7856","instance":7856,"id":227871,"goal":"function Factorial_7856(n: nat): nat\n ensures Factorial_7856(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_7856(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_7857","instance":7857,"id":227872,"goal":"function Fib_7857(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_7857(n-1) + Fib_7857(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_7858","instance":7858,"id":227873,"goal":"function Gcd_7858(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_7858(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_7859","instance":7859,"id":227874,"goal":"function Power_7859(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_7859(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_7860","instance":7860,"id":227875,"goal":"function Sum_7860(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_7860(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_7861","instance":7861,"id":227876,"goal":"method BinarySearch_7861(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_7862","instance":7862,"id":227877,"goal":"method InsertSort_7862(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_7863","instance":7863,"id":227878,"goal":"method MergeSort_7863(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_7864","instance":7864,"id":227879,"goal":"method ArrayCopy_7864(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_7865","instance":7865,"id":227880,"goal":"function ListReverse_7865(s: seq): seq\n ensures |ListReverse_7865(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_7865(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_7866","instance":7866,"id":227881,"goal":"function Factorial_7866(n: nat): nat\n ensures Factorial_7866(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_7866(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_7867","instance":7867,"id":227882,"goal":"function Fib_7867(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_7867(n-1) + Fib_7867(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_7868","instance":7868,"id":227883,"goal":"function Gcd_7868(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_7868(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_7869","instance":7869,"id":227884,"goal":"function Power_7869(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_7869(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_7870","instance":7870,"id":227885,"goal":"function Sum_7870(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_7870(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_7871","instance":7871,"id":227886,"goal":"method BinarySearch_7871(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_7872","instance":7872,"id":227887,"goal":"method InsertSort_7872(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_7873","instance":7873,"id":227888,"goal":"method MergeSort_7873(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_7874","instance":7874,"id":227889,"goal":"method ArrayCopy_7874(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_7875","instance":7875,"id":227890,"goal":"function ListReverse_7875(s: seq): seq\n ensures |ListReverse_7875(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_7875(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_7876","instance":7876,"id":227891,"goal":"function Factorial_7876(n: nat): nat\n ensures Factorial_7876(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_7876(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_7877","instance":7877,"id":227892,"goal":"function Fib_7877(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_7877(n-1) + Fib_7877(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_7878","instance":7878,"id":227893,"goal":"function Gcd_7878(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_7878(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_7879","instance":7879,"id":227894,"goal":"function Power_7879(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_7879(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_7880","instance":7880,"id":227895,"goal":"function Sum_7880(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_7880(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_7881","instance":7881,"id":227896,"goal":"method BinarySearch_7881(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_7882","instance":7882,"id":227897,"goal":"method InsertSort_7882(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_7883","instance":7883,"id":227898,"goal":"method MergeSort_7883(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_7884","instance":7884,"id":227899,"goal":"method ArrayCopy_7884(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_7885","instance":7885,"id":227900,"goal":"function ListReverse_7885(s: seq): seq\n ensures |ListReverse_7885(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_7885(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_7886","instance":7886,"id":227901,"goal":"function Factorial_7886(n: nat): nat\n ensures Factorial_7886(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_7886(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_7887","instance":7887,"id":227902,"goal":"function Fib_7887(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_7887(n-1) + Fib_7887(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_7888","instance":7888,"id":227903,"goal":"function Gcd_7888(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_7888(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_7889","instance":7889,"id":227904,"goal":"function Power_7889(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_7889(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_7890","instance":7890,"id":227905,"goal":"function Sum_7890(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_7890(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_7891","instance":7891,"id":227906,"goal":"method BinarySearch_7891(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_7892","instance":7892,"id":227907,"goal":"method InsertSort_7892(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_7893","instance":7893,"id":227908,"goal":"method MergeSort_7893(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_7894","instance":7894,"id":227909,"goal":"method ArrayCopy_7894(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_7895","instance":7895,"id":227910,"goal":"function ListReverse_7895(s: seq): seq\n ensures |ListReverse_7895(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_7895(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_7896","instance":7896,"id":227911,"goal":"function Factorial_7896(n: nat): nat\n ensures Factorial_7896(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_7896(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_7897","instance":7897,"id":227912,"goal":"function Fib_7897(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_7897(n-1) + Fib_7897(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_7898","instance":7898,"id":227913,"goal":"function Gcd_7898(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_7898(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_7899","instance":7899,"id":227914,"goal":"function Power_7899(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_7899(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_7900","instance":7900,"id":227915,"goal":"function Sum_7900(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_7900(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_7901","instance":7901,"id":227916,"goal":"method BinarySearch_7901(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_7902","instance":7902,"id":227917,"goal":"method InsertSort_7902(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_7903","instance":7903,"id":227918,"goal":"method MergeSort_7903(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_7904","instance":7904,"id":227919,"goal":"method ArrayCopy_7904(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_7905","instance":7905,"id":227920,"goal":"function ListReverse_7905(s: seq): seq\n ensures |ListReverse_7905(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_7905(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_7906","instance":7906,"id":227921,"goal":"function Factorial_7906(n: nat): nat\n ensures Factorial_7906(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_7906(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_7907","instance":7907,"id":227922,"goal":"function Fib_7907(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_7907(n-1) + Fib_7907(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_7908","instance":7908,"id":227923,"goal":"function Gcd_7908(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_7908(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_7909","instance":7909,"id":227924,"goal":"function Power_7909(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_7909(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_7910","instance":7910,"id":227925,"goal":"function Sum_7910(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_7910(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_7911","instance":7911,"id":227926,"goal":"method BinarySearch_7911(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_7912","instance":7912,"id":227927,"goal":"method InsertSort_7912(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_7913","instance":7913,"id":227928,"goal":"method MergeSort_7913(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_7914","instance":7914,"id":227929,"goal":"method ArrayCopy_7914(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_7915","instance":7915,"id":227930,"goal":"function ListReverse_7915(s: seq): seq\n ensures |ListReverse_7915(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_7915(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_7916","instance":7916,"id":227931,"goal":"function Factorial_7916(n: nat): nat\n ensures Factorial_7916(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_7916(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_7917","instance":7917,"id":227932,"goal":"function Fib_7917(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_7917(n-1) + Fib_7917(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_7918","instance":7918,"id":227933,"goal":"function Gcd_7918(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_7918(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_7919","instance":7919,"id":227934,"goal":"function Power_7919(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_7919(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_7920","instance":7920,"id":227935,"goal":"function Sum_7920(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_7920(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_7921","instance":7921,"id":227936,"goal":"method BinarySearch_7921(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_7922","instance":7922,"id":227937,"goal":"method InsertSort_7922(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_7923","instance":7923,"id":227938,"goal":"method MergeSort_7923(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_7924","instance":7924,"id":227939,"goal":"method ArrayCopy_7924(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_7925","instance":7925,"id":227940,"goal":"function ListReverse_7925(s: seq): seq\n ensures |ListReverse_7925(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_7925(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_7926","instance":7926,"id":227941,"goal":"function Factorial_7926(n: nat): nat\n ensures Factorial_7926(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_7926(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_7927","instance":7927,"id":227942,"goal":"function Fib_7927(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_7927(n-1) + Fib_7927(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_7928","instance":7928,"id":227943,"goal":"function Gcd_7928(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_7928(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_7929","instance":7929,"id":227944,"goal":"function Power_7929(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_7929(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_7930","instance":7930,"id":227945,"goal":"function Sum_7930(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_7930(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_7931","instance":7931,"id":227946,"goal":"method BinarySearch_7931(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_7932","instance":7932,"id":227947,"goal":"method InsertSort_7932(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_7933","instance":7933,"id":227948,"goal":"method MergeSort_7933(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_7934","instance":7934,"id":227949,"goal":"method ArrayCopy_7934(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_7935","instance":7935,"id":227950,"goal":"function ListReverse_7935(s: seq): seq\n ensures |ListReverse_7935(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_7935(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_7936","instance":7936,"id":227951,"goal":"function Factorial_7936(n: nat): nat\n ensures Factorial_7936(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_7936(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_7937","instance":7937,"id":227952,"goal":"function Fib_7937(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_7937(n-1) + Fib_7937(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_7938","instance":7938,"id":227953,"goal":"function Gcd_7938(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_7938(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_7939","instance":7939,"id":227954,"goal":"function Power_7939(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_7939(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_7940","instance":7940,"id":227955,"goal":"function Sum_7940(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_7940(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_7941","instance":7941,"id":227956,"goal":"method BinarySearch_7941(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_7942","instance":7942,"id":227957,"goal":"method InsertSort_7942(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_7943","instance":7943,"id":227958,"goal":"method MergeSort_7943(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_7944","instance":7944,"id":227959,"goal":"method ArrayCopy_7944(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_7945","instance":7945,"id":227960,"goal":"function ListReverse_7945(s: seq): seq\n ensures |ListReverse_7945(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_7945(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_7946","instance":7946,"id":227961,"goal":"function Factorial_7946(n: nat): nat\n ensures Factorial_7946(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_7946(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_7947","instance":7947,"id":227962,"goal":"function Fib_7947(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_7947(n-1) + Fib_7947(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_7948","instance":7948,"id":227963,"goal":"function Gcd_7948(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_7948(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_7949","instance":7949,"id":227964,"goal":"function Power_7949(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_7949(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_7950","instance":7950,"id":227965,"goal":"function Sum_7950(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_7950(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_7951","instance":7951,"id":227966,"goal":"method BinarySearch_7951(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_7952","instance":7952,"id":227967,"goal":"method InsertSort_7952(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_7953","instance":7953,"id":227968,"goal":"method MergeSort_7953(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_7954","instance":7954,"id":227969,"goal":"method ArrayCopy_7954(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_7955","instance":7955,"id":227970,"goal":"function ListReverse_7955(s: seq): seq\n ensures |ListReverse_7955(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_7955(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_7956","instance":7956,"id":227971,"goal":"function Factorial_7956(n: nat): nat\n ensures Factorial_7956(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_7956(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_7957","instance":7957,"id":227972,"goal":"function Fib_7957(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_7957(n-1) + Fib_7957(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_7958","instance":7958,"id":227973,"goal":"function Gcd_7958(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_7958(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_7959","instance":7959,"id":227974,"goal":"function Power_7959(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_7959(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_7960","instance":7960,"id":227975,"goal":"function Sum_7960(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_7960(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_7961","instance":7961,"id":227976,"goal":"method BinarySearch_7961(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_7962","instance":7962,"id":227977,"goal":"method InsertSort_7962(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_7963","instance":7963,"id":227978,"goal":"method MergeSort_7963(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_7964","instance":7964,"id":227979,"goal":"method ArrayCopy_7964(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_7965","instance":7965,"id":227980,"goal":"function ListReverse_7965(s: seq): seq\n ensures |ListReverse_7965(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_7965(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_7966","instance":7966,"id":227981,"goal":"function Factorial_7966(n: nat): nat\n ensures Factorial_7966(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_7966(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_7967","instance":7967,"id":227982,"goal":"function Fib_7967(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_7967(n-1) + Fib_7967(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_7968","instance":7968,"id":227983,"goal":"function Gcd_7968(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_7968(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_7969","instance":7969,"id":227984,"goal":"function Power_7969(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_7969(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_7970","instance":7970,"id":227985,"goal":"function Sum_7970(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_7970(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_7971","instance":7971,"id":227986,"goal":"method BinarySearch_7971(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_7972","instance":7972,"id":227987,"goal":"method InsertSort_7972(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_7973","instance":7973,"id":227988,"goal":"method MergeSort_7973(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_7974","instance":7974,"id":227989,"goal":"method ArrayCopy_7974(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_7975","instance":7975,"id":227990,"goal":"function ListReverse_7975(s: seq): seq\n ensures |ListReverse_7975(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_7975(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_7976","instance":7976,"id":227991,"goal":"function Factorial_7976(n: nat): nat\n ensures Factorial_7976(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_7976(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_7977","instance":7977,"id":227992,"goal":"function Fib_7977(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_7977(n-1) + Fib_7977(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_7978","instance":7978,"id":227993,"goal":"function Gcd_7978(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_7978(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_7979","instance":7979,"id":227994,"goal":"function Power_7979(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_7979(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_7980","instance":7980,"id":227995,"goal":"function Sum_7980(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_7980(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_7981","instance":7981,"id":227996,"goal":"method BinarySearch_7981(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_7982","instance":7982,"id":227997,"goal":"method InsertSort_7982(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_7983","instance":7983,"id":227998,"goal":"method MergeSort_7983(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_7984","instance":7984,"id":227999,"goal":"method ArrayCopy_7984(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_7985","instance":7985,"id":228000,"goal":"function ListReverse_7985(s: seq): seq\n ensures |ListReverse_7985(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_7985(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_7986","instance":7986,"id":228001,"goal":"function Factorial_7986(n: nat): nat\n ensures Factorial_7986(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_7986(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_7987","instance":7987,"id":228002,"goal":"function Fib_7987(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_7987(n-1) + Fib_7987(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_7988","instance":7988,"id":228003,"goal":"function Gcd_7988(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_7988(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_7989","instance":7989,"id":228004,"goal":"function Power_7989(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_7989(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_7990","instance":7990,"id":228005,"goal":"function Sum_7990(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_7990(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_7991","instance":7991,"id":228006,"goal":"method BinarySearch_7991(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_7992","instance":7992,"id":228007,"goal":"method InsertSort_7992(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_7993","instance":7993,"id":228008,"goal":"method MergeSort_7993(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_7994","instance":7994,"id":228009,"goal":"method ArrayCopy_7994(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_7995","instance":7995,"id":228010,"goal":"function ListReverse_7995(s: seq): seq\n ensures |ListReverse_7995(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_7995(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_7996","instance":7996,"id":228011,"goal":"function Factorial_7996(n: nat): nat\n ensures Factorial_7996(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_7996(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_7997","instance":7997,"id":228012,"goal":"function Fib_7997(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_7997(n-1) + Fib_7997(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_7998","instance":7998,"id":228013,"goal":"function Gcd_7998(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_7998(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_7999","instance":7999,"id":228014,"goal":"function Power_7999(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_7999(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_8000","instance":8000,"id":228015,"goal":"function Sum_8000(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_8000(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_8001","instance":8001,"id":228016,"goal":"method BinarySearch_8001(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_8002","instance":8002,"id":228017,"goal":"method InsertSort_8002(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_8003","instance":8003,"id":228018,"goal":"method MergeSort_8003(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_8004","instance":8004,"id":228019,"goal":"method ArrayCopy_8004(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_8005","instance":8005,"id":228020,"goal":"function ListReverse_8005(s: seq): seq\n ensures |ListReverse_8005(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_8005(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_8006","instance":8006,"id":228021,"goal":"function Factorial_8006(n: nat): nat\n ensures Factorial_8006(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_8006(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_8007","instance":8007,"id":228022,"goal":"function Fib_8007(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_8007(n-1) + Fib_8007(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_8008","instance":8008,"id":228023,"goal":"function Gcd_8008(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_8008(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_8009","instance":8009,"id":228024,"goal":"function Power_8009(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_8009(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_8010","instance":8010,"id":228025,"goal":"function Sum_8010(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_8010(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_8011","instance":8011,"id":228026,"goal":"method BinarySearch_8011(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_8012","instance":8012,"id":228027,"goal":"method InsertSort_8012(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_8013","instance":8013,"id":228028,"goal":"method MergeSort_8013(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_8014","instance":8014,"id":228029,"goal":"method ArrayCopy_8014(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_8015","instance":8015,"id":228030,"goal":"function ListReverse_8015(s: seq): seq\n ensures |ListReverse_8015(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_8015(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_8016","instance":8016,"id":228031,"goal":"function Factorial_8016(n: nat): nat\n ensures Factorial_8016(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_8016(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_8017","instance":8017,"id":228032,"goal":"function Fib_8017(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_8017(n-1) + Fib_8017(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_8018","instance":8018,"id":228033,"goal":"function Gcd_8018(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_8018(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_8019","instance":8019,"id":228034,"goal":"function Power_8019(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_8019(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_8020","instance":8020,"id":228035,"goal":"function Sum_8020(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_8020(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_8021","instance":8021,"id":228036,"goal":"method BinarySearch_8021(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_8022","instance":8022,"id":228037,"goal":"method InsertSort_8022(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_8023","instance":8023,"id":228038,"goal":"method MergeSort_8023(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_8024","instance":8024,"id":228039,"goal":"method ArrayCopy_8024(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_8025","instance":8025,"id":228040,"goal":"function ListReverse_8025(s: seq): seq\n ensures |ListReverse_8025(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_8025(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_8026","instance":8026,"id":228041,"goal":"function Factorial_8026(n: nat): nat\n ensures Factorial_8026(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_8026(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_8027","instance":8027,"id":228042,"goal":"function Fib_8027(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_8027(n-1) + Fib_8027(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_8028","instance":8028,"id":228043,"goal":"function Gcd_8028(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_8028(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_8029","instance":8029,"id":228044,"goal":"function Power_8029(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_8029(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_8030","instance":8030,"id":228045,"goal":"function Sum_8030(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_8030(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_8031","instance":8031,"id":228046,"goal":"method BinarySearch_8031(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_8032","instance":8032,"id":228047,"goal":"method InsertSort_8032(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_8033","instance":8033,"id":228048,"goal":"method MergeSort_8033(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_8034","instance":8034,"id":228049,"goal":"method ArrayCopy_8034(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_8035","instance":8035,"id":228050,"goal":"function ListReverse_8035(s: seq): seq\n ensures |ListReverse_8035(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_8035(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_8036","instance":8036,"id":228051,"goal":"function Factorial_8036(n: nat): nat\n ensures Factorial_8036(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_8036(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_8037","instance":8037,"id":228052,"goal":"function Fib_8037(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_8037(n-1) + Fib_8037(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_8038","instance":8038,"id":228053,"goal":"function Gcd_8038(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_8038(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_8039","instance":8039,"id":228054,"goal":"function Power_8039(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_8039(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_8040","instance":8040,"id":228055,"goal":"function Sum_8040(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_8040(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_8041","instance":8041,"id":228056,"goal":"method BinarySearch_8041(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_8042","instance":8042,"id":228057,"goal":"method InsertSort_8042(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_8043","instance":8043,"id":228058,"goal":"method MergeSort_8043(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_8044","instance":8044,"id":228059,"goal":"method ArrayCopy_8044(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_8045","instance":8045,"id":228060,"goal":"function ListReverse_8045(s: seq): seq\n ensures |ListReverse_8045(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_8045(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_8046","instance":8046,"id":228061,"goal":"function Factorial_8046(n: nat): nat\n ensures Factorial_8046(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_8046(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_8047","instance":8047,"id":228062,"goal":"function Fib_8047(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_8047(n-1) + Fib_8047(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_8048","instance":8048,"id":228063,"goal":"function Gcd_8048(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_8048(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_8049","instance":8049,"id":228064,"goal":"function Power_8049(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_8049(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_8050","instance":8050,"id":228065,"goal":"function Sum_8050(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_8050(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_8051","instance":8051,"id":228066,"goal":"method BinarySearch_8051(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_8052","instance":8052,"id":228067,"goal":"method InsertSort_8052(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_8053","instance":8053,"id":228068,"goal":"method MergeSort_8053(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_8054","instance":8054,"id":228069,"goal":"method ArrayCopy_8054(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_8055","instance":8055,"id":228070,"goal":"function ListReverse_8055(s: seq): seq\n ensures |ListReverse_8055(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_8055(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_8056","instance":8056,"id":228071,"goal":"function Factorial_8056(n: nat): nat\n ensures Factorial_8056(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_8056(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_8057","instance":8057,"id":228072,"goal":"function Fib_8057(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_8057(n-1) + Fib_8057(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_8058","instance":8058,"id":228073,"goal":"function Gcd_8058(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_8058(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_8059","instance":8059,"id":228074,"goal":"function Power_8059(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_8059(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_8060","instance":8060,"id":228075,"goal":"function Sum_8060(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_8060(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_8061","instance":8061,"id":228076,"goal":"method BinarySearch_8061(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_8062","instance":8062,"id":228077,"goal":"method InsertSort_8062(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_8063","instance":8063,"id":228078,"goal":"method MergeSort_8063(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_8064","instance":8064,"id":228079,"goal":"method ArrayCopy_8064(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_8065","instance":8065,"id":228080,"goal":"function ListReverse_8065(s: seq): seq\n ensures |ListReverse_8065(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_8065(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_8066","instance":8066,"id":228081,"goal":"function Factorial_8066(n: nat): nat\n ensures Factorial_8066(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_8066(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_8067","instance":8067,"id":228082,"goal":"function Fib_8067(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_8067(n-1) + Fib_8067(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_8068","instance":8068,"id":228083,"goal":"function Gcd_8068(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_8068(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_8069","instance":8069,"id":228084,"goal":"function Power_8069(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_8069(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_8070","instance":8070,"id":228085,"goal":"function Sum_8070(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_8070(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_8071","instance":8071,"id":228086,"goal":"method BinarySearch_8071(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_8072","instance":8072,"id":228087,"goal":"method InsertSort_8072(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_8073","instance":8073,"id":228088,"goal":"method MergeSort_8073(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_8074","instance":8074,"id":228089,"goal":"method ArrayCopy_8074(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_8075","instance":8075,"id":228090,"goal":"function ListReverse_8075(s: seq): seq\n ensures |ListReverse_8075(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_8075(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_8076","instance":8076,"id":228091,"goal":"function Factorial_8076(n: nat): nat\n ensures Factorial_8076(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_8076(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_8077","instance":8077,"id":228092,"goal":"function Fib_8077(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_8077(n-1) + Fib_8077(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_8078","instance":8078,"id":228093,"goal":"function Gcd_8078(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_8078(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_8079","instance":8079,"id":228094,"goal":"function Power_8079(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_8079(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_8080","instance":8080,"id":228095,"goal":"function Sum_8080(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_8080(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_8081","instance":8081,"id":228096,"goal":"method BinarySearch_8081(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_8082","instance":8082,"id":228097,"goal":"method InsertSort_8082(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_8083","instance":8083,"id":228098,"goal":"method MergeSort_8083(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_8084","instance":8084,"id":228099,"goal":"method ArrayCopy_8084(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_8085","instance":8085,"id":228100,"goal":"function ListReverse_8085(s: seq): seq\n ensures |ListReverse_8085(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_8085(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_8086","instance":8086,"id":228101,"goal":"function Factorial_8086(n: nat): nat\n ensures Factorial_8086(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_8086(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_8087","instance":8087,"id":228102,"goal":"function Fib_8087(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_8087(n-1) + Fib_8087(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_8088","instance":8088,"id":228103,"goal":"function Gcd_8088(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_8088(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_8089","instance":8089,"id":228104,"goal":"function Power_8089(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_8089(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_8090","instance":8090,"id":228105,"goal":"function Sum_8090(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_8090(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_8091","instance":8091,"id":228106,"goal":"method BinarySearch_8091(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_8092","instance":8092,"id":228107,"goal":"method InsertSort_8092(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_8093","instance":8093,"id":228108,"goal":"method MergeSort_8093(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_8094","instance":8094,"id":228109,"goal":"method ArrayCopy_8094(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_8095","instance":8095,"id":228110,"goal":"function ListReverse_8095(s: seq): seq\n ensures |ListReverse_8095(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_8095(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_8096","instance":8096,"id":228111,"goal":"function Factorial_8096(n: nat): nat\n ensures Factorial_8096(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_8096(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_8097","instance":8097,"id":228112,"goal":"function Fib_8097(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_8097(n-1) + Fib_8097(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_8098","instance":8098,"id":228113,"goal":"function Gcd_8098(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_8098(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_8099","instance":8099,"id":228114,"goal":"function Power_8099(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_8099(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_8100","instance":8100,"id":228115,"goal":"function Sum_8100(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_8100(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_8101","instance":8101,"id":228116,"goal":"method BinarySearch_8101(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_8102","instance":8102,"id":228117,"goal":"method InsertSort_8102(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_8103","instance":8103,"id":228118,"goal":"method MergeSort_8103(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_8104","instance":8104,"id":228119,"goal":"method ArrayCopy_8104(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_8105","instance":8105,"id":228120,"goal":"function ListReverse_8105(s: seq): seq\n ensures |ListReverse_8105(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_8105(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_8106","instance":8106,"id":228121,"goal":"function Factorial_8106(n: nat): nat\n ensures Factorial_8106(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_8106(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_8107","instance":8107,"id":228122,"goal":"function Fib_8107(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_8107(n-1) + Fib_8107(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_8108","instance":8108,"id":228123,"goal":"function Gcd_8108(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_8108(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_8109","instance":8109,"id":228124,"goal":"function Power_8109(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_8109(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_8110","instance":8110,"id":228125,"goal":"function Sum_8110(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_8110(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_8111","instance":8111,"id":228126,"goal":"method BinarySearch_8111(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_8112","instance":8112,"id":228127,"goal":"method InsertSort_8112(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_8113","instance":8113,"id":228128,"goal":"method MergeSort_8113(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_8114","instance":8114,"id":228129,"goal":"method ArrayCopy_8114(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_8115","instance":8115,"id":228130,"goal":"function ListReverse_8115(s: seq): seq\n ensures |ListReverse_8115(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_8115(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_8116","instance":8116,"id":228131,"goal":"function Factorial_8116(n: nat): nat\n ensures Factorial_8116(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_8116(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_8117","instance":8117,"id":228132,"goal":"function Fib_8117(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_8117(n-1) + Fib_8117(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_8118","instance":8118,"id":228133,"goal":"function Gcd_8118(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_8118(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_8119","instance":8119,"id":228134,"goal":"function Power_8119(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_8119(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_8120","instance":8120,"id":228135,"goal":"function Sum_8120(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_8120(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_8121","instance":8121,"id":228136,"goal":"method BinarySearch_8121(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_8122","instance":8122,"id":228137,"goal":"method InsertSort_8122(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_8123","instance":8123,"id":228138,"goal":"method MergeSort_8123(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_8124","instance":8124,"id":228139,"goal":"method ArrayCopy_8124(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_8125","instance":8125,"id":228140,"goal":"function ListReverse_8125(s: seq): seq\n ensures |ListReverse_8125(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_8125(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_8126","instance":8126,"id":228141,"goal":"function Factorial_8126(n: nat): nat\n ensures Factorial_8126(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_8126(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_8127","instance":8127,"id":228142,"goal":"function Fib_8127(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_8127(n-1) + Fib_8127(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_8128","instance":8128,"id":228143,"goal":"function Gcd_8128(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_8128(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_8129","instance":8129,"id":228144,"goal":"function Power_8129(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_8129(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_8130","instance":8130,"id":228145,"goal":"function Sum_8130(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_8130(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_8131","instance":8131,"id":228146,"goal":"method BinarySearch_8131(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_8132","instance":8132,"id":228147,"goal":"method InsertSort_8132(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_8133","instance":8133,"id":228148,"goal":"method MergeSort_8133(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_8134","instance":8134,"id":228149,"goal":"method ArrayCopy_8134(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_8135","instance":8135,"id":228150,"goal":"function ListReverse_8135(s: seq): seq\n ensures |ListReverse_8135(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_8135(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_8136","instance":8136,"id":228151,"goal":"function Factorial_8136(n: nat): nat\n ensures Factorial_8136(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_8136(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_8137","instance":8137,"id":228152,"goal":"function Fib_8137(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_8137(n-1) + Fib_8137(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_8138","instance":8138,"id":228153,"goal":"function Gcd_8138(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_8138(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_8139","instance":8139,"id":228154,"goal":"function Power_8139(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_8139(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_8140","instance":8140,"id":228155,"goal":"function Sum_8140(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_8140(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_8141","instance":8141,"id":228156,"goal":"method BinarySearch_8141(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_8142","instance":8142,"id":228157,"goal":"method InsertSort_8142(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_8143","instance":8143,"id":228158,"goal":"method MergeSort_8143(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_8144","instance":8144,"id":228159,"goal":"method ArrayCopy_8144(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_8145","instance":8145,"id":228160,"goal":"function ListReverse_8145(s: seq): seq\n ensures |ListReverse_8145(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_8145(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_8146","instance":8146,"id":228161,"goal":"function Factorial_8146(n: nat): nat\n ensures Factorial_8146(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_8146(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_8147","instance":8147,"id":228162,"goal":"function Fib_8147(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_8147(n-1) + Fib_8147(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_8148","instance":8148,"id":228163,"goal":"function Gcd_8148(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_8148(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_8149","instance":8149,"id":228164,"goal":"function Power_8149(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_8149(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_8150","instance":8150,"id":228165,"goal":"function Sum_8150(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_8150(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_8151","instance":8151,"id":228166,"goal":"method BinarySearch_8151(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_8152","instance":8152,"id":228167,"goal":"method InsertSort_8152(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_8153","instance":8153,"id":228168,"goal":"method MergeSort_8153(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_8154","instance":8154,"id":228169,"goal":"method ArrayCopy_8154(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_8155","instance":8155,"id":228170,"goal":"function ListReverse_8155(s: seq): seq\n ensures |ListReverse_8155(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_8155(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_8156","instance":8156,"id":228171,"goal":"function Factorial_8156(n: nat): nat\n ensures Factorial_8156(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_8156(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_8157","instance":8157,"id":228172,"goal":"function Fib_8157(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_8157(n-1) + Fib_8157(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_8158","instance":8158,"id":228173,"goal":"function Gcd_8158(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_8158(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_8159","instance":8159,"id":228174,"goal":"function Power_8159(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_8159(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_8160","instance":8160,"id":228175,"goal":"function Sum_8160(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_8160(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_8161","instance":8161,"id":228176,"goal":"method BinarySearch_8161(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_8162","instance":8162,"id":228177,"goal":"method InsertSort_8162(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_8163","instance":8163,"id":228178,"goal":"method MergeSort_8163(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_8164","instance":8164,"id":228179,"goal":"method ArrayCopy_8164(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_8165","instance":8165,"id":228180,"goal":"function ListReverse_8165(s: seq): seq\n ensures |ListReverse_8165(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_8165(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_8166","instance":8166,"id":228181,"goal":"function Factorial_8166(n: nat): nat\n ensures Factorial_8166(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_8166(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_8167","instance":8167,"id":228182,"goal":"function Fib_8167(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_8167(n-1) + Fib_8167(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_8168","instance":8168,"id":228183,"goal":"function Gcd_8168(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_8168(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_8169","instance":8169,"id":228184,"goal":"function Power_8169(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_8169(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_8170","instance":8170,"id":228185,"goal":"function Sum_8170(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_8170(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_8171","instance":8171,"id":228186,"goal":"method BinarySearch_8171(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_8172","instance":8172,"id":228187,"goal":"method InsertSort_8172(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_8173","instance":8173,"id":228188,"goal":"method MergeSort_8173(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_8174","instance":8174,"id":228189,"goal":"method ArrayCopy_8174(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_8175","instance":8175,"id":228190,"goal":"function ListReverse_8175(s: seq): seq\n ensures |ListReverse_8175(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_8175(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_8176","instance":8176,"id":228191,"goal":"function Factorial_8176(n: nat): nat\n ensures Factorial_8176(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_8176(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_8177","instance":8177,"id":228192,"goal":"function Fib_8177(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_8177(n-1) + Fib_8177(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_8178","instance":8178,"id":228193,"goal":"function Gcd_8178(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_8178(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_8179","instance":8179,"id":228194,"goal":"function Power_8179(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_8179(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_8180","instance":8180,"id":228195,"goal":"function Sum_8180(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_8180(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_8181","instance":8181,"id":228196,"goal":"method BinarySearch_8181(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_8182","instance":8182,"id":228197,"goal":"method InsertSort_8182(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_8183","instance":8183,"id":228198,"goal":"method MergeSort_8183(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_8184","instance":8184,"id":228199,"goal":"method ArrayCopy_8184(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_8185","instance":8185,"id":228200,"goal":"function ListReverse_8185(s: seq): seq\n ensures |ListReverse_8185(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_8185(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_8186","instance":8186,"id":228201,"goal":"function Factorial_8186(n: nat): nat\n ensures Factorial_8186(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_8186(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_8187","instance":8187,"id":228202,"goal":"function Fib_8187(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_8187(n-1) + Fib_8187(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_8188","instance":8188,"id":228203,"goal":"function Gcd_8188(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_8188(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_8189","instance":8189,"id":228204,"goal":"function Power_8189(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_8189(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_8190","instance":8190,"id":228205,"goal":"function Sum_8190(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_8190(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_8191","instance":8191,"id":228206,"goal":"method BinarySearch_8191(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_8192","instance":8192,"id":228207,"goal":"method InsertSort_8192(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_8193","instance":8193,"id":228208,"goal":"method MergeSort_8193(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_8194","instance":8194,"id":228209,"goal":"method ArrayCopy_8194(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_8195","instance":8195,"id":228210,"goal":"function ListReverse_8195(s: seq): seq\n ensures |ListReverse_8195(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_8195(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_8196","instance":8196,"id":228211,"goal":"function Factorial_8196(n: nat): nat\n ensures Factorial_8196(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_8196(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_8197","instance":8197,"id":228212,"goal":"function Fib_8197(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_8197(n-1) + Fib_8197(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_8198","instance":8198,"id":228213,"goal":"function Gcd_8198(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_8198(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_8199","instance":8199,"id":228214,"goal":"function Power_8199(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_8199(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_8200","instance":8200,"id":228215,"goal":"function Sum_8200(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_8200(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_8201","instance":8201,"id":228216,"goal":"method BinarySearch_8201(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_8202","instance":8202,"id":228217,"goal":"method InsertSort_8202(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_8203","instance":8203,"id":228218,"goal":"method MergeSort_8203(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_8204","instance":8204,"id":228219,"goal":"method ArrayCopy_8204(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_8205","instance":8205,"id":228220,"goal":"function ListReverse_8205(s: seq): seq\n ensures |ListReverse_8205(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_8205(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_8206","instance":8206,"id":228221,"goal":"function Factorial_8206(n: nat): nat\n ensures Factorial_8206(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_8206(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_8207","instance":8207,"id":228222,"goal":"function Fib_8207(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_8207(n-1) + Fib_8207(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_8208","instance":8208,"id":228223,"goal":"function Gcd_8208(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_8208(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_8209","instance":8209,"id":228224,"goal":"function Power_8209(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_8209(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_8210","instance":8210,"id":228225,"goal":"function Sum_8210(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_8210(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_8211","instance":8211,"id":228226,"goal":"method BinarySearch_8211(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_8212","instance":8212,"id":228227,"goal":"method InsertSort_8212(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_8213","instance":8213,"id":228228,"goal":"method MergeSort_8213(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_8214","instance":8214,"id":228229,"goal":"method ArrayCopy_8214(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_8215","instance":8215,"id":228230,"goal":"function ListReverse_8215(s: seq): seq\n ensures |ListReverse_8215(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_8215(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_8216","instance":8216,"id":228231,"goal":"function Factorial_8216(n: nat): nat\n ensures Factorial_8216(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_8216(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_8217","instance":8217,"id":228232,"goal":"function Fib_8217(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_8217(n-1) + Fib_8217(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_8218","instance":8218,"id":228233,"goal":"function Gcd_8218(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_8218(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_8219","instance":8219,"id":228234,"goal":"function Power_8219(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_8219(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_8220","instance":8220,"id":228235,"goal":"function Sum_8220(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_8220(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_8221","instance":8221,"id":228236,"goal":"method BinarySearch_8221(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_8222","instance":8222,"id":228237,"goal":"method InsertSort_8222(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_8223","instance":8223,"id":228238,"goal":"method MergeSort_8223(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_8224","instance":8224,"id":228239,"goal":"method ArrayCopy_8224(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_8225","instance":8225,"id":228240,"goal":"function ListReverse_8225(s: seq): seq\n ensures |ListReverse_8225(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_8225(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_8226","instance":8226,"id":228241,"goal":"function Factorial_8226(n: nat): nat\n ensures Factorial_8226(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_8226(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_8227","instance":8227,"id":228242,"goal":"function Fib_8227(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_8227(n-1) + Fib_8227(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_8228","instance":8228,"id":228243,"goal":"function Gcd_8228(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_8228(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_8229","instance":8229,"id":228244,"goal":"function Power_8229(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_8229(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_8230","instance":8230,"id":228245,"goal":"function Sum_8230(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_8230(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_8231","instance":8231,"id":228246,"goal":"method BinarySearch_8231(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_8232","instance":8232,"id":228247,"goal":"method InsertSort_8232(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_8233","instance":8233,"id":228248,"goal":"method MergeSort_8233(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_8234","instance":8234,"id":228249,"goal":"method ArrayCopy_8234(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_8235","instance":8235,"id":228250,"goal":"function ListReverse_8235(s: seq): seq\n ensures |ListReverse_8235(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_8235(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_8236","instance":8236,"id":228251,"goal":"function Factorial_8236(n: nat): nat\n ensures Factorial_8236(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_8236(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_8237","instance":8237,"id":228252,"goal":"function Fib_8237(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_8237(n-1) + Fib_8237(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_8238","instance":8238,"id":228253,"goal":"function Gcd_8238(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_8238(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_8239","instance":8239,"id":228254,"goal":"function Power_8239(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_8239(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_8240","instance":8240,"id":228255,"goal":"function Sum_8240(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_8240(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_8241","instance":8241,"id":228256,"goal":"method BinarySearch_8241(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_8242","instance":8242,"id":228257,"goal":"method InsertSort_8242(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_8243","instance":8243,"id":228258,"goal":"method MergeSort_8243(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_8244","instance":8244,"id":228259,"goal":"method ArrayCopy_8244(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_8245","instance":8245,"id":228260,"goal":"function ListReverse_8245(s: seq): seq\n ensures |ListReverse_8245(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_8245(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_8246","instance":8246,"id":228261,"goal":"function Factorial_8246(n: nat): nat\n ensures Factorial_8246(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_8246(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_8247","instance":8247,"id":228262,"goal":"function Fib_8247(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_8247(n-1) + Fib_8247(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_8248","instance":8248,"id":228263,"goal":"function Gcd_8248(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_8248(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_8249","instance":8249,"id":228264,"goal":"function Power_8249(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_8249(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_8250","instance":8250,"id":228265,"goal":"function Sum_8250(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_8250(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_8251","instance":8251,"id":228266,"goal":"method BinarySearch_8251(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_8252","instance":8252,"id":228267,"goal":"method InsertSort_8252(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_8253","instance":8253,"id":228268,"goal":"method MergeSort_8253(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_8254","instance":8254,"id":228269,"goal":"method ArrayCopy_8254(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_8255","instance":8255,"id":228270,"goal":"function ListReverse_8255(s: seq): seq\n ensures |ListReverse_8255(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_8255(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_8256","instance":8256,"id":228271,"goal":"function Factorial_8256(n: nat): nat\n ensures Factorial_8256(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_8256(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_8257","instance":8257,"id":228272,"goal":"function Fib_8257(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_8257(n-1) + Fib_8257(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_8258","instance":8258,"id":228273,"goal":"function Gcd_8258(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_8258(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_8259","instance":8259,"id":228274,"goal":"function Power_8259(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_8259(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_8260","instance":8260,"id":228275,"goal":"function Sum_8260(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_8260(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_8261","instance":8261,"id":228276,"goal":"method BinarySearch_8261(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_8262","instance":8262,"id":228277,"goal":"method InsertSort_8262(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_8263","instance":8263,"id":228278,"goal":"method MergeSort_8263(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_8264","instance":8264,"id":228279,"goal":"method ArrayCopy_8264(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_8265","instance":8265,"id":228280,"goal":"function ListReverse_8265(s: seq): seq\n ensures |ListReverse_8265(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_8265(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_8266","instance":8266,"id":228281,"goal":"function Factorial_8266(n: nat): nat\n ensures Factorial_8266(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_8266(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_8267","instance":8267,"id":228282,"goal":"function Fib_8267(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_8267(n-1) + Fib_8267(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_8268","instance":8268,"id":228283,"goal":"function Gcd_8268(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_8268(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_8269","instance":8269,"id":228284,"goal":"function Power_8269(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_8269(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_8270","instance":8270,"id":228285,"goal":"function Sum_8270(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_8270(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_8271","instance":8271,"id":228286,"goal":"method BinarySearch_8271(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_8272","instance":8272,"id":228287,"goal":"method InsertSort_8272(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_8273","instance":8273,"id":228288,"goal":"method MergeSort_8273(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_8274","instance":8274,"id":228289,"goal":"method ArrayCopy_8274(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_8275","instance":8275,"id":228290,"goal":"function ListReverse_8275(s: seq): seq\n ensures |ListReverse_8275(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_8275(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_8276","instance":8276,"id":228291,"goal":"function Factorial_8276(n: nat): nat\n ensures Factorial_8276(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_8276(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_8277","instance":8277,"id":228292,"goal":"function Fib_8277(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_8277(n-1) + Fib_8277(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_8278","instance":8278,"id":228293,"goal":"function Gcd_8278(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_8278(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_8279","instance":8279,"id":228294,"goal":"function Power_8279(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_8279(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_8280","instance":8280,"id":228295,"goal":"function Sum_8280(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_8280(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_8281","instance":8281,"id":228296,"goal":"method BinarySearch_8281(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_8282","instance":8282,"id":228297,"goal":"method InsertSort_8282(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_8283","instance":8283,"id":228298,"goal":"method MergeSort_8283(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_8284","instance":8284,"id":228299,"goal":"method ArrayCopy_8284(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_8285","instance":8285,"id":228300,"goal":"function ListReverse_8285(s: seq): seq\n ensures |ListReverse_8285(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_8285(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_8286","instance":8286,"id":228301,"goal":"function Factorial_8286(n: nat): nat\n ensures Factorial_8286(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_8286(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_8287","instance":8287,"id":228302,"goal":"function Fib_8287(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_8287(n-1) + Fib_8287(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_8288","instance":8288,"id":228303,"goal":"function Gcd_8288(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_8288(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_8289","instance":8289,"id":228304,"goal":"function Power_8289(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_8289(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_8290","instance":8290,"id":228305,"goal":"function Sum_8290(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_8290(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_8291","instance":8291,"id":228306,"goal":"method BinarySearch_8291(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_8292","instance":8292,"id":228307,"goal":"method InsertSort_8292(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_8293","instance":8293,"id":228308,"goal":"method MergeSort_8293(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_8294","instance":8294,"id":228309,"goal":"method ArrayCopy_8294(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_8295","instance":8295,"id":228310,"goal":"function ListReverse_8295(s: seq): seq\n ensures |ListReverse_8295(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_8295(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_8296","instance":8296,"id":228311,"goal":"function Factorial_8296(n: nat): nat\n ensures Factorial_8296(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_8296(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_8297","instance":8297,"id":228312,"goal":"function Fib_8297(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_8297(n-1) + Fib_8297(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_8298","instance":8298,"id":228313,"goal":"function Gcd_8298(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_8298(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_8299","instance":8299,"id":228314,"goal":"function Power_8299(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_8299(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_8300","instance":8300,"id":228315,"goal":"function Sum_8300(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_8300(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_8301","instance":8301,"id":228316,"goal":"method BinarySearch_8301(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_8302","instance":8302,"id":228317,"goal":"method InsertSort_8302(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_8303","instance":8303,"id":228318,"goal":"method MergeSort_8303(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_8304","instance":8304,"id":228319,"goal":"method ArrayCopy_8304(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_8305","instance":8305,"id":228320,"goal":"function ListReverse_8305(s: seq): seq\n ensures |ListReverse_8305(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_8305(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_8306","instance":8306,"id":228321,"goal":"function Factorial_8306(n: nat): nat\n ensures Factorial_8306(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_8306(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_8307","instance":8307,"id":228322,"goal":"function Fib_8307(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_8307(n-1) + Fib_8307(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_8308","instance":8308,"id":228323,"goal":"function Gcd_8308(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_8308(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_8309","instance":8309,"id":228324,"goal":"function Power_8309(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_8309(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_8310","instance":8310,"id":228325,"goal":"function Sum_8310(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_8310(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_8311","instance":8311,"id":228326,"goal":"method BinarySearch_8311(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_8312","instance":8312,"id":228327,"goal":"method InsertSort_8312(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_8313","instance":8313,"id":228328,"goal":"method MergeSort_8313(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_8314","instance":8314,"id":228329,"goal":"method ArrayCopy_8314(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_8315","instance":8315,"id":228330,"goal":"function ListReverse_8315(s: seq): seq\n ensures |ListReverse_8315(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_8315(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_8316","instance":8316,"id":228331,"goal":"function Factorial_8316(n: nat): nat\n ensures Factorial_8316(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_8316(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_8317","instance":8317,"id":228332,"goal":"function Fib_8317(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_8317(n-1) + Fib_8317(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_8318","instance":8318,"id":228333,"goal":"function Gcd_8318(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_8318(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_8319","instance":8319,"id":228334,"goal":"function Power_8319(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_8319(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_8320","instance":8320,"id":228335,"goal":"function Sum_8320(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_8320(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_8321","instance":8321,"id":228336,"goal":"method BinarySearch_8321(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_8322","instance":8322,"id":228337,"goal":"method InsertSort_8322(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_8323","instance":8323,"id":228338,"goal":"method MergeSort_8323(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_8324","instance":8324,"id":228339,"goal":"method ArrayCopy_8324(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_8325","instance":8325,"id":228340,"goal":"function ListReverse_8325(s: seq): seq\n ensures |ListReverse_8325(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_8325(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_8326","instance":8326,"id":228341,"goal":"function Factorial_8326(n: nat): nat\n ensures Factorial_8326(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_8326(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_8327","instance":8327,"id":228342,"goal":"function Fib_8327(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_8327(n-1) + Fib_8327(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_8328","instance":8328,"id":228343,"goal":"function Gcd_8328(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_8328(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_8329","instance":8329,"id":228344,"goal":"function Power_8329(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_8329(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_8330","instance":8330,"id":228345,"goal":"function Sum_8330(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_8330(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_8331","instance":8331,"id":228346,"goal":"method BinarySearch_8331(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_8332","instance":8332,"id":228347,"goal":"method InsertSort_8332(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_8333","instance":8333,"id":228348,"goal":"method MergeSort_8333(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_8334","instance":8334,"id":228349,"goal":"method ArrayCopy_8334(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_8335","instance":8335,"id":228350,"goal":"function ListReverse_8335(s: seq): seq\n ensures |ListReverse_8335(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_8335(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_8336","instance":8336,"id":228351,"goal":"function Factorial_8336(n: nat): nat\n ensures Factorial_8336(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_8336(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_8337","instance":8337,"id":228352,"goal":"function Fib_8337(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_8337(n-1) + Fib_8337(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_8338","instance":8338,"id":228353,"goal":"function Gcd_8338(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_8338(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_8339","instance":8339,"id":228354,"goal":"function Power_8339(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_8339(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_8340","instance":8340,"id":228355,"goal":"function Sum_8340(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_8340(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_8341","instance":8341,"id":228356,"goal":"method BinarySearch_8341(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_8342","instance":8342,"id":228357,"goal":"method InsertSort_8342(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_8343","instance":8343,"id":228358,"goal":"method MergeSort_8343(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_8344","instance":8344,"id":228359,"goal":"method ArrayCopy_8344(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_8345","instance":8345,"id":228360,"goal":"function ListReverse_8345(s: seq): seq\n ensures |ListReverse_8345(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_8345(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_8346","instance":8346,"id":228361,"goal":"function Factorial_8346(n: nat): nat\n ensures Factorial_8346(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_8346(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_8347","instance":8347,"id":228362,"goal":"function Fib_8347(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_8347(n-1) + Fib_8347(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_8348","instance":8348,"id":228363,"goal":"function Gcd_8348(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_8348(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_8349","instance":8349,"id":228364,"goal":"function Power_8349(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_8349(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_8350","instance":8350,"id":228365,"goal":"function Sum_8350(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_8350(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_8351","instance":8351,"id":228366,"goal":"method BinarySearch_8351(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_8352","instance":8352,"id":228367,"goal":"method InsertSort_8352(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_8353","instance":8353,"id":228368,"goal":"method MergeSort_8353(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_8354","instance":8354,"id":228369,"goal":"method ArrayCopy_8354(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_8355","instance":8355,"id":228370,"goal":"function ListReverse_8355(s: seq): seq\n ensures |ListReverse_8355(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_8355(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_8356","instance":8356,"id":228371,"goal":"function Factorial_8356(n: nat): nat\n ensures Factorial_8356(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_8356(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_8357","instance":8357,"id":228372,"goal":"function Fib_8357(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_8357(n-1) + Fib_8357(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_8358","instance":8358,"id":228373,"goal":"function Gcd_8358(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_8358(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_8359","instance":8359,"id":228374,"goal":"function Power_8359(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_8359(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_8360","instance":8360,"id":228375,"goal":"function Sum_8360(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_8360(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_8361","instance":8361,"id":228376,"goal":"method BinarySearch_8361(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_8362","instance":8362,"id":228377,"goal":"method InsertSort_8362(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_8363","instance":8363,"id":228378,"goal":"method MergeSort_8363(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_8364","instance":8364,"id":228379,"goal":"method ArrayCopy_8364(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_8365","instance":8365,"id":228380,"goal":"function ListReverse_8365(s: seq): seq\n ensures |ListReverse_8365(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_8365(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_8366","instance":8366,"id":228381,"goal":"function Factorial_8366(n: nat): nat\n ensures Factorial_8366(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_8366(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_8367","instance":8367,"id":228382,"goal":"function Fib_8367(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_8367(n-1) + Fib_8367(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_8368","instance":8368,"id":228383,"goal":"function Gcd_8368(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_8368(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_8369","instance":8369,"id":228384,"goal":"function Power_8369(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_8369(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_8370","instance":8370,"id":228385,"goal":"function Sum_8370(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_8370(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_8371","instance":8371,"id":228386,"goal":"method BinarySearch_8371(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_8372","instance":8372,"id":228387,"goal":"method InsertSort_8372(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_8373","instance":8373,"id":228388,"goal":"method MergeSort_8373(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_8374","instance":8374,"id":228389,"goal":"method ArrayCopy_8374(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_8375","instance":8375,"id":228390,"goal":"function ListReverse_8375(s: seq): seq\n ensures |ListReverse_8375(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_8375(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_8376","instance":8376,"id":228391,"goal":"function Factorial_8376(n: nat): nat\n ensures Factorial_8376(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_8376(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_8377","instance":8377,"id":228392,"goal":"function Fib_8377(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_8377(n-1) + Fib_8377(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_8378","instance":8378,"id":228393,"goal":"function Gcd_8378(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_8378(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_8379","instance":8379,"id":228394,"goal":"function Power_8379(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_8379(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_8380","instance":8380,"id":228395,"goal":"function Sum_8380(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_8380(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_8381","instance":8381,"id":228396,"goal":"method BinarySearch_8381(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_8382","instance":8382,"id":228397,"goal":"method InsertSort_8382(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_8383","instance":8383,"id":228398,"goal":"method MergeSort_8383(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_8384","instance":8384,"id":228399,"goal":"method ArrayCopy_8384(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_8385","instance":8385,"id":228400,"goal":"function ListReverse_8385(s: seq): seq\n ensures |ListReverse_8385(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_8385(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_8386","instance":8386,"id":228401,"goal":"function Factorial_8386(n: nat): nat\n ensures Factorial_8386(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_8386(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_8387","instance":8387,"id":228402,"goal":"function Fib_8387(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_8387(n-1) + Fib_8387(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_8388","instance":8388,"id":228403,"goal":"function Gcd_8388(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_8388(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_8389","instance":8389,"id":228404,"goal":"function Power_8389(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_8389(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_8390","instance":8390,"id":228405,"goal":"function Sum_8390(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_8390(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_8391","instance":8391,"id":228406,"goal":"method BinarySearch_8391(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_8392","instance":8392,"id":228407,"goal":"method InsertSort_8392(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_8393","instance":8393,"id":228408,"goal":"method MergeSort_8393(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_8394","instance":8394,"id":228409,"goal":"method ArrayCopy_8394(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_8395","instance":8395,"id":228410,"goal":"function ListReverse_8395(s: seq): seq\n ensures |ListReverse_8395(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_8395(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_8396","instance":8396,"id":228411,"goal":"function Factorial_8396(n: nat): nat\n ensures Factorial_8396(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_8396(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_8397","instance":8397,"id":228412,"goal":"function Fib_8397(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_8397(n-1) + Fib_8397(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_8398","instance":8398,"id":228413,"goal":"function Gcd_8398(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_8398(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_8399","instance":8399,"id":228414,"goal":"function Power_8399(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_8399(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_8400","instance":8400,"id":228415,"goal":"function Sum_8400(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_8400(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_8401","instance":8401,"id":228416,"goal":"method BinarySearch_8401(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_8402","instance":8402,"id":228417,"goal":"method InsertSort_8402(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_8403","instance":8403,"id":228418,"goal":"method MergeSort_8403(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_8404","instance":8404,"id":228419,"goal":"method ArrayCopy_8404(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_8405","instance":8405,"id":228420,"goal":"function ListReverse_8405(s: seq): seq\n ensures |ListReverse_8405(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_8405(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_8406","instance":8406,"id":228421,"goal":"function Factorial_8406(n: nat): nat\n ensures Factorial_8406(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_8406(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_8407","instance":8407,"id":228422,"goal":"function Fib_8407(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_8407(n-1) + Fib_8407(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_8408","instance":8408,"id":228423,"goal":"function Gcd_8408(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_8408(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_8409","instance":8409,"id":228424,"goal":"function Power_8409(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_8409(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_8410","instance":8410,"id":228425,"goal":"function Sum_8410(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_8410(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_8411","instance":8411,"id":228426,"goal":"method BinarySearch_8411(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_8412","instance":8412,"id":228427,"goal":"method InsertSort_8412(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_8413","instance":8413,"id":228428,"goal":"method MergeSort_8413(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_8414","instance":8414,"id":228429,"goal":"method ArrayCopy_8414(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_8415","instance":8415,"id":228430,"goal":"function ListReverse_8415(s: seq): seq\n ensures |ListReverse_8415(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_8415(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_8416","instance":8416,"id":228431,"goal":"function Factorial_8416(n: nat): nat\n ensures Factorial_8416(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_8416(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_8417","instance":8417,"id":228432,"goal":"function Fib_8417(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_8417(n-1) + Fib_8417(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_8418","instance":8418,"id":228433,"goal":"function Gcd_8418(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_8418(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_8419","instance":8419,"id":228434,"goal":"function Power_8419(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_8419(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_8420","instance":8420,"id":228435,"goal":"function Sum_8420(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_8420(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_8421","instance":8421,"id":228436,"goal":"method BinarySearch_8421(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_8422","instance":8422,"id":228437,"goal":"method InsertSort_8422(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_8423","instance":8423,"id":228438,"goal":"method MergeSort_8423(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_8424","instance":8424,"id":228439,"goal":"method ArrayCopy_8424(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_8425","instance":8425,"id":228440,"goal":"function ListReverse_8425(s: seq): seq\n ensures |ListReverse_8425(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_8425(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_8426","instance":8426,"id":228441,"goal":"function Factorial_8426(n: nat): nat\n ensures Factorial_8426(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_8426(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_8427","instance":8427,"id":228442,"goal":"function Fib_8427(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_8427(n-1) + Fib_8427(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_8428","instance":8428,"id":228443,"goal":"function Gcd_8428(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_8428(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_8429","instance":8429,"id":228444,"goal":"function Power_8429(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_8429(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_8430","instance":8430,"id":228445,"goal":"function Sum_8430(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_8430(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_8431","instance":8431,"id":228446,"goal":"method BinarySearch_8431(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_8432","instance":8432,"id":228447,"goal":"method InsertSort_8432(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_8433","instance":8433,"id":228448,"goal":"method MergeSort_8433(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_8434","instance":8434,"id":228449,"goal":"method ArrayCopy_8434(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_8435","instance":8435,"id":228450,"goal":"function ListReverse_8435(s: seq): seq\n ensures |ListReverse_8435(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_8435(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_8436","instance":8436,"id":228451,"goal":"function Factorial_8436(n: nat): nat\n ensures Factorial_8436(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_8436(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_8437","instance":8437,"id":228452,"goal":"function Fib_8437(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_8437(n-1) + Fib_8437(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_8438","instance":8438,"id":228453,"goal":"function Gcd_8438(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_8438(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_8439","instance":8439,"id":228454,"goal":"function Power_8439(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_8439(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_8440","instance":8440,"id":228455,"goal":"function Sum_8440(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_8440(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_8441","instance":8441,"id":228456,"goal":"method BinarySearch_8441(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_8442","instance":8442,"id":228457,"goal":"method InsertSort_8442(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_8443","instance":8443,"id":228458,"goal":"method MergeSort_8443(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_8444","instance":8444,"id":228459,"goal":"method ArrayCopy_8444(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_8445","instance":8445,"id":228460,"goal":"function ListReverse_8445(s: seq): seq\n ensures |ListReverse_8445(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_8445(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_8446","instance":8446,"id":228461,"goal":"function Factorial_8446(n: nat): nat\n ensures Factorial_8446(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_8446(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_8447","instance":8447,"id":228462,"goal":"function Fib_8447(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_8447(n-1) + Fib_8447(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_8448","instance":8448,"id":228463,"goal":"function Gcd_8448(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_8448(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_8449","instance":8449,"id":228464,"goal":"function Power_8449(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_8449(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_8450","instance":8450,"id":228465,"goal":"function Sum_8450(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_8450(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_8451","instance":8451,"id":228466,"goal":"method BinarySearch_8451(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_8452","instance":8452,"id":228467,"goal":"method InsertSort_8452(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_8453","instance":8453,"id":228468,"goal":"method MergeSort_8453(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_8454","instance":8454,"id":228469,"goal":"method ArrayCopy_8454(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_8455","instance":8455,"id":228470,"goal":"function ListReverse_8455(s: seq): seq\n ensures |ListReverse_8455(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_8455(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_8456","instance":8456,"id":228471,"goal":"function Factorial_8456(n: nat): nat\n ensures Factorial_8456(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_8456(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_8457","instance":8457,"id":228472,"goal":"function Fib_8457(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_8457(n-1) + Fib_8457(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_8458","instance":8458,"id":228473,"goal":"function Gcd_8458(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_8458(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_8459","instance":8459,"id":228474,"goal":"function Power_8459(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_8459(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_8460","instance":8460,"id":228475,"goal":"function Sum_8460(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_8460(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_8461","instance":8461,"id":228476,"goal":"method BinarySearch_8461(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_8462","instance":8462,"id":228477,"goal":"method InsertSort_8462(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_8463","instance":8463,"id":228478,"goal":"method MergeSort_8463(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_8464","instance":8464,"id":228479,"goal":"method ArrayCopy_8464(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_8465","instance":8465,"id":228480,"goal":"function ListReverse_8465(s: seq): seq\n ensures |ListReverse_8465(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_8465(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_8466","instance":8466,"id":228481,"goal":"function Factorial_8466(n: nat): nat\n ensures Factorial_8466(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_8466(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_8467","instance":8467,"id":228482,"goal":"function Fib_8467(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_8467(n-1) + Fib_8467(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_8468","instance":8468,"id":228483,"goal":"function Gcd_8468(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_8468(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_8469","instance":8469,"id":228484,"goal":"function Power_8469(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_8469(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_8470","instance":8470,"id":228485,"goal":"function Sum_8470(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_8470(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_8471","instance":8471,"id":228486,"goal":"method BinarySearch_8471(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_8472","instance":8472,"id":228487,"goal":"method InsertSort_8472(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_8473","instance":8473,"id":228488,"goal":"method MergeSort_8473(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_8474","instance":8474,"id":228489,"goal":"method ArrayCopy_8474(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_8475","instance":8475,"id":228490,"goal":"function ListReverse_8475(s: seq): seq\n ensures |ListReverse_8475(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_8475(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_8476","instance":8476,"id":228491,"goal":"function Factorial_8476(n: nat): nat\n ensures Factorial_8476(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_8476(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_8477","instance":8477,"id":228492,"goal":"function Fib_8477(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_8477(n-1) + Fib_8477(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_8478","instance":8478,"id":228493,"goal":"function Gcd_8478(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_8478(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_8479","instance":8479,"id":228494,"goal":"function Power_8479(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_8479(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_8480","instance":8480,"id":228495,"goal":"function Sum_8480(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_8480(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_8481","instance":8481,"id":228496,"goal":"method BinarySearch_8481(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_8482","instance":8482,"id":228497,"goal":"method InsertSort_8482(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_8483","instance":8483,"id":228498,"goal":"method MergeSort_8483(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_8484","instance":8484,"id":228499,"goal":"method ArrayCopy_8484(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_8485","instance":8485,"id":228500,"goal":"function ListReverse_8485(s: seq): seq\n ensures |ListReverse_8485(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_8485(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_8486","instance":8486,"id":228501,"goal":"function Factorial_8486(n: nat): nat\n ensures Factorial_8486(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_8486(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_8487","instance":8487,"id":228502,"goal":"function Fib_8487(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_8487(n-1) + Fib_8487(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_8488","instance":8488,"id":228503,"goal":"function Gcd_8488(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_8488(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_8489","instance":8489,"id":228504,"goal":"function Power_8489(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_8489(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_8490","instance":8490,"id":228505,"goal":"function Sum_8490(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_8490(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_8491","instance":8491,"id":228506,"goal":"method BinarySearch_8491(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_8492","instance":8492,"id":228507,"goal":"method InsertSort_8492(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_8493","instance":8493,"id":228508,"goal":"method MergeSort_8493(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_8494","instance":8494,"id":228509,"goal":"method ArrayCopy_8494(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_8495","instance":8495,"id":228510,"goal":"function ListReverse_8495(s: seq): seq\n ensures |ListReverse_8495(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_8495(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_8496","instance":8496,"id":228511,"goal":"function Factorial_8496(n: nat): nat\n ensures Factorial_8496(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_8496(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_8497","instance":8497,"id":228512,"goal":"function Fib_8497(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_8497(n-1) + Fib_8497(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_8498","instance":8498,"id":228513,"goal":"function Gcd_8498(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_8498(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_8499","instance":8499,"id":228514,"goal":"function Power_8499(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_8499(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_8500","instance":8500,"id":228515,"goal":"function Sum_8500(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_8500(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_8501","instance":8501,"id":228516,"goal":"method BinarySearch_8501(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_8502","instance":8502,"id":228517,"goal":"method InsertSort_8502(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_8503","instance":8503,"id":228518,"goal":"method MergeSort_8503(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_8504","instance":8504,"id":228519,"goal":"method ArrayCopy_8504(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_8505","instance":8505,"id":228520,"goal":"function ListReverse_8505(s: seq): seq\n ensures |ListReverse_8505(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_8505(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_8506","instance":8506,"id":228521,"goal":"function Factorial_8506(n: nat): nat\n ensures Factorial_8506(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_8506(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_8507","instance":8507,"id":228522,"goal":"function Fib_8507(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_8507(n-1) + Fib_8507(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_8508","instance":8508,"id":228523,"goal":"function Gcd_8508(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_8508(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_8509","instance":8509,"id":228524,"goal":"function Power_8509(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_8509(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_8510","instance":8510,"id":228525,"goal":"function Sum_8510(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_8510(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_8511","instance":8511,"id":228526,"goal":"method BinarySearch_8511(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_8512","instance":8512,"id":228527,"goal":"method InsertSort_8512(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_8513","instance":8513,"id":228528,"goal":"method MergeSort_8513(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_8514","instance":8514,"id":228529,"goal":"method ArrayCopy_8514(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_8515","instance":8515,"id":228530,"goal":"function ListReverse_8515(s: seq): seq\n ensures |ListReverse_8515(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_8515(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_8516","instance":8516,"id":228531,"goal":"function Factorial_8516(n: nat): nat\n ensures Factorial_8516(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_8516(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_8517","instance":8517,"id":228532,"goal":"function Fib_8517(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_8517(n-1) + Fib_8517(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_8518","instance":8518,"id":228533,"goal":"function Gcd_8518(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_8518(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_8519","instance":8519,"id":228534,"goal":"function Power_8519(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_8519(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_8520","instance":8520,"id":228535,"goal":"function Sum_8520(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_8520(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_8521","instance":8521,"id":228536,"goal":"method BinarySearch_8521(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_8522","instance":8522,"id":228537,"goal":"method InsertSort_8522(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_8523","instance":8523,"id":228538,"goal":"method MergeSort_8523(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_8524","instance":8524,"id":228539,"goal":"method ArrayCopy_8524(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_8525","instance":8525,"id":228540,"goal":"function ListReverse_8525(s: seq): seq\n ensures |ListReverse_8525(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_8525(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_8526","instance":8526,"id":228541,"goal":"function Factorial_8526(n: nat): nat\n ensures Factorial_8526(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_8526(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_8527","instance":8527,"id":228542,"goal":"function Fib_8527(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_8527(n-1) + Fib_8527(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_8528","instance":8528,"id":228543,"goal":"function Gcd_8528(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_8528(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_8529","instance":8529,"id":228544,"goal":"function Power_8529(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_8529(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_8530","instance":8530,"id":228545,"goal":"function Sum_8530(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_8530(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_8531","instance":8531,"id":228546,"goal":"method BinarySearch_8531(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_8532","instance":8532,"id":228547,"goal":"method InsertSort_8532(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_8533","instance":8533,"id":228548,"goal":"method MergeSort_8533(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_8534","instance":8534,"id":228549,"goal":"method ArrayCopy_8534(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_8535","instance":8535,"id":228550,"goal":"function ListReverse_8535(s: seq): seq\n ensures |ListReverse_8535(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_8535(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_8536","instance":8536,"id":228551,"goal":"function Factorial_8536(n: nat): nat\n ensures Factorial_8536(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_8536(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_8537","instance":8537,"id":228552,"goal":"function Fib_8537(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_8537(n-1) + Fib_8537(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_8538","instance":8538,"id":228553,"goal":"function Gcd_8538(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_8538(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_8539","instance":8539,"id":228554,"goal":"function Power_8539(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_8539(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_8540","instance":8540,"id":228555,"goal":"function Sum_8540(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_8540(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_8541","instance":8541,"id":228556,"goal":"method BinarySearch_8541(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_8542","instance":8542,"id":228557,"goal":"method InsertSort_8542(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_8543","instance":8543,"id":228558,"goal":"method MergeSort_8543(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_8544","instance":8544,"id":228559,"goal":"method ArrayCopy_8544(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_8545","instance":8545,"id":228560,"goal":"function ListReverse_8545(s: seq): seq\n ensures |ListReverse_8545(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_8545(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_8546","instance":8546,"id":228561,"goal":"function Factorial_8546(n: nat): nat\n ensures Factorial_8546(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_8546(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_8547","instance":8547,"id":228562,"goal":"function Fib_8547(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_8547(n-1) + Fib_8547(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_8548","instance":8548,"id":228563,"goal":"function Gcd_8548(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_8548(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_8549","instance":8549,"id":228564,"goal":"function Power_8549(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_8549(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_8550","instance":8550,"id":228565,"goal":"function Sum_8550(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_8550(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_8551","instance":8551,"id":228566,"goal":"method BinarySearch_8551(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_8552","instance":8552,"id":228567,"goal":"method InsertSort_8552(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_8553","instance":8553,"id":228568,"goal":"method MergeSort_8553(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_8554","instance":8554,"id":228569,"goal":"method ArrayCopy_8554(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_8555","instance":8555,"id":228570,"goal":"function ListReverse_8555(s: seq): seq\n ensures |ListReverse_8555(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_8555(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_8556","instance":8556,"id":228571,"goal":"function Factorial_8556(n: nat): nat\n ensures Factorial_8556(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_8556(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_8557","instance":8557,"id":228572,"goal":"function Fib_8557(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_8557(n-1) + Fib_8557(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_8558","instance":8558,"id":228573,"goal":"function Gcd_8558(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_8558(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_8559","instance":8559,"id":228574,"goal":"function Power_8559(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_8559(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_8560","instance":8560,"id":228575,"goal":"function Sum_8560(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_8560(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_8561","instance":8561,"id":228576,"goal":"method BinarySearch_8561(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_8562","instance":8562,"id":228577,"goal":"method InsertSort_8562(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_8563","instance":8563,"id":228578,"goal":"method MergeSort_8563(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_8564","instance":8564,"id":228579,"goal":"method ArrayCopy_8564(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_8565","instance":8565,"id":228580,"goal":"function ListReverse_8565(s: seq): seq\n ensures |ListReverse_8565(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_8565(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_8566","instance":8566,"id":228581,"goal":"function Factorial_8566(n: nat): nat\n ensures Factorial_8566(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_8566(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_8567","instance":8567,"id":228582,"goal":"function Fib_8567(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_8567(n-1) + Fib_8567(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_8568","instance":8568,"id":228583,"goal":"function Gcd_8568(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_8568(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_8569","instance":8569,"id":228584,"goal":"function Power_8569(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_8569(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_8570","instance":8570,"id":228585,"goal":"function Sum_8570(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_8570(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_8571","instance":8571,"id":228586,"goal":"method BinarySearch_8571(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_8572","instance":8572,"id":228587,"goal":"method InsertSort_8572(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_8573","instance":8573,"id":228588,"goal":"method MergeSort_8573(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_8574","instance":8574,"id":228589,"goal":"method ArrayCopy_8574(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_8575","instance":8575,"id":228590,"goal":"function ListReverse_8575(s: seq): seq\n ensures |ListReverse_8575(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_8575(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_8576","instance":8576,"id":228591,"goal":"function Factorial_8576(n: nat): nat\n ensures Factorial_8576(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_8576(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_8577","instance":8577,"id":228592,"goal":"function Fib_8577(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_8577(n-1) + Fib_8577(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_8578","instance":8578,"id":228593,"goal":"function Gcd_8578(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_8578(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_8579","instance":8579,"id":228594,"goal":"function Power_8579(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_8579(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_8580","instance":8580,"id":228595,"goal":"function Sum_8580(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_8580(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_8581","instance":8581,"id":228596,"goal":"method BinarySearch_8581(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_8582","instance":8582,"id":228597,"goal":"method InsertSort_8582(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_8583","instance":8583,"id":228598,"goal":"method MergeSort_8583(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_8584","instance":8584,"id":228599,"goal":"method ArrayCopy_8584(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_8585","instance":8585,"id":228600,"goal":"function ListReverse_8585(s: seq): seq\n ensures |ListReverse_8585(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_8585(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_8586","instance":8586,"id":228601,"goal":"function Factorial_8586(n: nat): nat\n ensures Factorial_8586(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_8586(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_8587","instance":8587,"id":228602,"goal":"function Fib_8587(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_8587(n-1) + Fib_8587(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_8588","instance":8588,"id":228603,"goal":"function Gcd_8588(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_8588(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_8589","instance":8589,"id":228604,"goal":"function Power_8589(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_8589(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_8590","instance":8590,"id":228605,"goal":"function Sum_8590(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_8590(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_8591","instance":8591,"id":228606,"goal":"method BinarySearch_8591(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_8592","instance":8592,"id":228607,"goal":"method InsertSort_8592(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_8593","instance":8593,"id":228608,"goal":"method MergeSort_8593(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_8594","instance":8594,"id":228609,"goal":"method ArrayCopy_8594(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_8595","instance":8595,"id":228610,"goal":"function ListReverse_8595(s: seq): seq\n ensures |ListReverse_8595(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_8595(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_8596","instance":8596,"id":228611,"goal":"function Factorial_8596(n: nat): nat\n ensures Factorial_8596(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_8596(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_8597","instance":8597,"id":228612,"goal":"function Fib_8597(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_8597(n-1) + Fib_8597(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_8598","instance":8598,"id":228613,"goal":"function Gcd_8598(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_8598(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_8599","instance":8599,"id":228614,"goal":"function Power_8599(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_8599(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_8600","instance":8600,"id":228615,"goal":"function Sum_8600(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_8600(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_8601","instance":8601,"id":228616,"goal":"method BinarySearch_8601(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_8602","instance":8602,"id":228617,"goal":"method InsertSort_8602(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_8603","instance":8603,"id":228618,"goal":"method MergeSort_8603(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_8604","instance":8604,"id":228619,"goal":"method ArrayCopy_8604(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_8605","instance":8605,"id":228620,"goal":"function ListReverse_8605(s: seq): seq\n ensures |ListReverse_8605(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_8605(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_8606","instance":8606,"id":228621,"goal":"function Factorial_8606(n: nat): nat\n ensures Factorial_8606(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_8606(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_8607","instance":8607,"id":228622,"goal":"function Fib_8607(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_8607(n-1) + Fib_8607(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_8608","instance":8608,"id":228623,"goal":"function Gcd_8608(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_8608(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_8609","instance":8609,"id":228624,"goal":"function Power_8609(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_8609(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_8610","instance":8610,"id":228625,"goal":"function Sum_8610(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_8610(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_8611","instance":8611,"id":228626,"goal":"method BinarySearch_8611(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_8612","instance":8612,"id":228627,"goal":"method InsertSort_8612(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_8613","instance":8613,"id":228628,"goal":"method MergeSort_8613(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_8614","instance":8614,"id":228629,"goal":"method ArrayCopy_8614(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_8615","instance":8615,"id":228630,"goal":"function ListReverse_8615(s: seq): seq\n ensures |ListReverse_8615(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_8615(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_8616","instance":8616,"id":228631,"goal":"function Factorial_8616(n: nat): nat\n ensures Factorial_8616(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_8616(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_8617","instance":8617,"id":228632,"goal":"function Fib_8617(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_8617(n-1) + Fib_8617(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_8618","instance":8618,"id":228633,"goal":"function Gcd_8618(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_8618(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_8619","instance":8619,"id":228634,"goal":"function Power_8619(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_8619(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_8620","instance":8620,"id":228635,"goal":"function Sum_8620(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_8620(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_8621","instance":8621,"id":228636,"goal":"method BinarySearch_8621(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_8622","instance":8622,"id":228637,"goal":"method InsertSort_8622(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_8623","instance":8623,"id":228638,"goal":"method MergeSort_8623(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_8624","instance":8624,"id":228639,"goal":"method ArrayCopy_8624(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_8625","instance":8625,"id":228640,"goal":"function ListReverse_8625(s: seq): seq\n ensures |ListReverse_8625(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_8625(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_8626","instance":8626,"id":228641,"goal":"function Factorial_8626(n: nat): nat\n ensures Factorial_8626(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_8626(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_8627","instance":8627,"id":228642,"goal":"function Fib_8627(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_8627(n-1) + Fib_8627(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_8628","instance":8628,"id":228643,"goal":"function Gcd_8628(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_8628(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_8629","instance":8629,"id":228644,"goal":"function Power_8629(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_8629(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_8630","instance":8630,"id":228645,"goal":"function Sum_8630(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_8630(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_8631","instance":8631,"id":228646,"goal":"method BinarySearch_8631(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_8632","instance":8632,"id":228647,"goal":"method InsertSort_8632(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_8633","instance":8633,"id":228648,"goal":"method MergeSort_8633(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_8634","instance":8634,"id":228649,"goal":"method ArrayCopy_8634(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_8635","instance":8635,"id":228650,"goal":"function ListReverse_8635(s: seq): seq\n ensures |ListReverse_8635(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_8635(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_8636","instance":8636,"id":228651,"goal":"function Factorial_8636(n: nat): nat\n ensures Factorial_8636(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_8636(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_8637","instance":8637,"id":228652,"goal":"function Fib_8637(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_8637(n-1) + Fib_8637(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_8638","instance":8638,"id":228653,"goal":"function Gcd_8638(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_8638(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_8639","instance":8639,"id":228654,"goal":"function Power_8639(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_8639(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_8640","instance":8640,"id":228655,"goal":"function Sum_8640(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_8640(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_8641","instance":8641,"id":228656,"goal":"method BinarySearch_8641(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_8642","instance":8642,"id":228657,"goal":"method InsertSort_8642(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_8643","instance":8643,"id":228658,"goal":"method MergeSort_8643(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_8644","instance":8644,"id":228659,"goal":"method ArrayCopy_8644(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_8645","instance":8645,"id":228660,"goal":"function ListReverse_8645(s: seq): seq\n ensures |ListReverse_8645(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_8645(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_8646","instance":8646,"id":228661,"goal":"function Factorial_8646(n: nat): nat\n ensures Factorial_8646(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_8646(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_8647","instance":8647,"id":228662,"goal":"function Fib_8647(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_8647(n-1) + Fib_8647(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_8648","instance":8648,"id":228663,"goal":"function Gcd_8648(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_8648(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_8649","instance":8649,"id":228664,"goal":"function Power_8649(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_8649(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_8650","instance":8650,"id":228665,"goal":"function Sum_8650(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_8650(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_8651","instance":8651,"id":228666,"goal":"method BinarySearch_8651(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_8652","instance":8652,"id":228667,"goal":"method InsertSort_8652(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_8653","instance":8653,"id":228668,"goal":"method MergeSort_8653(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_8654","instance":8654,"id":228669,"goal":"method ArrayCopy_8654(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_8655","instance":8655,"id":228670,"goal":"function ListReverse_8655(s: seq): seq\n ensures |ListReverse_8655(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_8655(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_8656","instance":8656,"id":228671,"goal":"function Factorial_8656(n: nat): nat\n ensures Factorial_8656(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_8656(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_8657","instance":8657,"id":228672,"goal":"function Fib_8657(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_8657(n-1) + Fib_8657(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_8658","instance":8658,"id":228673,"goal":"function Gcd_8658(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_8658(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_8659","instance":8659,"id":228674,"goal":"function Power_8659(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_8659(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_8660","instance":8660,"id":228675,"goal":"function Sum_8660(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_8660(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_8661","instance":8661,"id":228676,"goal":"method BinarySearch_8661(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_8662","instance":8662,"id":228677,"goal":"method InsertSort_8662(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_8663","instance":8663,"id":228678,"goal":"method MergeSort_8663(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_8664","instance":8664,"id":228679,"goal":"method ArrayCopy_8664(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_8665","instance":8665,"id":228680,"goal":"function ListReverse_8665(s: seq): seq\n ensures |ListReverse_8665(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_8665(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_8666","instance":8666,"id":228681,"goal":"function Factorial_8666(n: nat): nat\n ensures Factorial_8666(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_8666(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_8667","instance":8667,"id":228682,"goal":"function Fib_8667(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_8667(n-1) + Fib_8667(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_8668","instance":8668,"id":228683,"goal":"function Gcd_8668(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_8668(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_8669","instance":8669,"id":228684,"goal":"function Power_8669(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_8669(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_8670","instance":8670,"id":228685,"goal":"function Sum_8670(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_8670(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_8671","instance":8671,"id":228686,"goal":"method BinarySearch_8671(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_8672","instance":8672,"id":228687,"goal":"method InsertSort_8672(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_8673","instance":8673,"id":228688,"goal":"method MergeSort_8673(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_8674","instance":8674,"id":228689,"goal":"method ArrayCopy_8674(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_8675","instance":8675,"id":228690,"goal":"function ListReverse_8675(s: seq): seq\n ensures |ListReverse_8675(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_8675(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_8676","instance":8676,"id":228691,"goal":"function Factorial_8676(n: nat): nat\n ensures Factorial_8676(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_8676(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_8677","instance":8677,"id":228692,"goal":"function Fib_8677(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_8677(n-1) + Fib_8677(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_8678","instance":8678,"id":228693,"goal":"function Gcd_8678(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_8678(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_8679","instance":8679,"id":228694,"goal":"function Power_8679(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_8679(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_8680","instance":8680,"id":228695,"goal":"function Sum_8680(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_8680(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_8681","instance":8681,"id":228696,"goal":"method BinarySearch_8681(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_8682","instance":8682,"id":228697,"goal":"method InsertSort_8682(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_8683","instance":8683,"id":228698,"goal":"method MergeSort_8683(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_8684","instance":8684,"id":228699,"goal":"method ArrayCopy_8684(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_8685","instance":8685,"id":228700,"goal":"function ListReverse_8685(s: seq): seq\n ensures |ListReverse_8685(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_8685(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_8686","instance":8686,"id":228701,"goal":"function Factorial_8686(n: nat): nat\n ensures Factorial_8686(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_8686(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_8687","instance":8687,"id":228702,"goal":"function Fib_8687(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_8687(n-1) + Fib_8687(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_8688","instance":8688,"id":228703,"goal":"function Gcd_8688(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_8688(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_8689","instance":8689,"id":228704,"goal":"function Power_8689(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_8689(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_8690","instance":8690,"id":228705,"goal":"function Sum_8690(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_8690(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_8691","instance":8691,"id":228706,"goal":"method BinarySearch_8691(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_8692","instance":8692,"id":228707,"goal":"method InsertSort_8692(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_8693","instance":8693,"id":228708,"goal":"method MergeSort_8693(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_8694","instance":8694,"id":228709,"goal":"method ArrayCopy_8694(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_8695","instance":8695,"id":228710,"goal":"function ListReverse_8695(s: seq): seq\n ensures |ListReverse_8695(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_8695(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_8696","instance":8696,"id":228711,"goal":"function Factorial_8696(n: nat): nat\n ensures Factorial_8696(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_8696(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_8697","instance":8697,"id":228712,"goal":"function Fib_8697(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_8697(n-1) + Fib_8697(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_8698","instance":8698,"id":228713,"goal":"function Gcd_8698(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_8698(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_8699","instance":8699,"id":228714,"goal":"function Power_8699(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_8699(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_8700","instance":8700,"id":228715,"goal":"function Sum_8700(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_8700(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_8701","instance":8701,"id":228716,"goal":"method BinarySearch_8701(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_8702","instance":8702,"id":228717,"goal":"method InsertSort_8702(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_8703","instance":8703,"id":228718,"goal":"method MergeSort_8703(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_8704","instance":8704,"id":228719,"goal":"method ArrayCopy_8704(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_8705","instance":8705,"id":228720,"goal":"function ListReverse_8705(s: seq): seq\n ensures |ListReverse_8705(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_8705(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_8706","instance":8706,"id":228721,"goal":"function Factorial_8706(n: nat): nat\n ensures Factorial_8706(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_8706(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_8707","instance":8707,"id":228722,"goal":"function Fib_8707(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_8707(n-1) + Fib_8707(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_8708","instance":8708,"id":228723,"goal":"function Gcd_8708(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_8708(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_8709","instance":8709,"id":228724,"goal":"function Power_8709(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_8709(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_8710","instance":8710,"id":228725,"goal":"function Sum_8710(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_8710(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_8711","instance":8711,"id":228726,"goal":"method BinarySearch_8711(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_8712","instance":8712,"id":228727,"goal":"method InsertSort_8712(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_8713","instance":8713,"id":228728,"goal":"method MergeSort_8713(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_8714","instance":8714,"id":228729,"goal":"method ArrayCopy_8714(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_8715","instance":8715,"id":228730,"goal":"function ListReverse_8715(s: seq): seq\n ensures |ListReverse_8715(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_8715(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_8716","instance":8716,"id":228731,"goal":"function Factorial_8716(n: nat): nat\n ensures Factorial_8716(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_8716(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_8717","instance":8717,"id":228732,"goal":"function Fib_8717(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_8717(n-1) + Fib_8717(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_8718","instance":8718,"id":228733,"goal":"function Gcd_8718(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_8718(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_8719","instance":8719,"id":228734,"goal":"function Power_8719(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_8719(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_8720","instance":8720,"id":228735,"goal":"function Sum_8720(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_8720(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_8721","instance":8721,"id":228736,"goal":"method BinarySearch_8721(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_8722","instance":8722,"id":228737,"goal":"method InsertSort_8722(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_8723","instance":8723,"id":228738,"goal":"method MergeSort_8723(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_8724","instance":8724,"id":228739,"goal":"method ArrayCopy_8724(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_8725","instance":8725,"id":228740,"goal":"function ListReverse_8725(s: seq): seq\n ensures |ListReverse_8725(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_8725(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_8726","instance":8726,"id":228741,"goal":"function Factorial_8726(n: nat): nat\n ensures Factorial_8726(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_8726(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_8727","instance":8727,"id":228742,"goal":"function Fib_8727(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_8727(n-1) + Fib_8727(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_8728","instance":8728,"id":228743,"goal":"function Gcd_8728(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_8728(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_8729","instance":8729,"id":228744,"goal":"function Power_8729(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_8729(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_8730","instance":8730,"id":228745,"goal":"function Sum_8730(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_8730(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_8731","instance":8731,"id":228746,"goal":"method BinarySearch_8731(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_8732","instance":8732,"id":228747,"goal":"method InsertSort_8732(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_8733","instance":8733,"id":228748,"goal":"method MergeSort_8733(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_8734","instance":8734,"id":228749,"goal":"method ArrayCopy_8734(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_8735","instance":8735,"id":228750,"goal":"function ListReverse_8735(s: seq): seq\n ensures |ListReverse_8735(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_8735(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_8736","instance":8736,"id":228751,"goal":"function Factorial_8736(n: nat): nat\n ensures Factorial_8736(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_8736(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_8737","instance":8737,"id":228752,"goal":"function Fib_8737(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_8737(n-1) + Fib_8737(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_8738","instance":8738,"id":228753,"goal":"function Gcd_8738(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_8738(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_8739","instance":8739,"id":228754,"goal":"function Power_8739(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_8739(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_8740","instance":8740,"id":228755,"goal":"function Sum_8740(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_8740(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_8741","instance":8741,"id":228756,"goal":"method BinarySearch_8741(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_8742","instance":8742,"id":228757,"goal":"method InsertSort_8742(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_8743","instance":8743,"id":228758,"goal":"method MergeSort_8743(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_8744","instance":8744,"id":228759,"goal":"method ArrayCopy_8744(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_8745","instance":8745,"id":228760,"goal":"function ListReverse_8745(s: seq): seq\n ensures |ListReverse_8745(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_8745(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_8746","instance":8746,"id":228761,"goal":"function Factorial_8746(n: nat): nat\n ensures Factorial_8746(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_8746(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_8747","instance":8747,"id":228762,"goal":"function Fib_8747(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_8747(n-1) + Fib_8747(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_8748","instance":8748,"id":228763,"goal":"function Gcd_8748(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_8748(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_8749","instance":8749,"id":228764,"goal":"function Power_8749(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_8749(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_8750","instance":8750,"id":228765,"goal":"function Sum_8750(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_8750(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_8751","instance":8751,"id":228766,"goal":"method BinarySearch_8751(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_8752","instance":8752,"id":228767,"goal":"method InsertSort_8752(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_8753","instance":8753,"id":228768,"goal":"method MergeSort_8753(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_8754","instance":8754,"id":228769,"goal":"method ArrayCopy_8754(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_8755","instance":8755,"id":228770,"goal":"function ListReverse_8755(s: seq): seq\n ensures |ListReverse_8755(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_8755(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_8756","instance":8756,"id":228771,"goal":"function Factorial_8756(n: nat): nat\n ensures Factorial_8756(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_8756(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_8757","instance":8757,"id":228772,"goal":"function Fib_8757(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_8757(n-1) + Fib_8757(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_8758","instance":8758,"id":228773,"goal":"function Gcd_8758(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_8758(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_8759","instance":8759,"id":228774,"goal":"function Power_8759(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_8759(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_8760","instance":8760,"id":228775,"goal":"function Sum_8760(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_8760(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_8761","instance":8761,"id":228776,"goal":"method BinarySearch_8761(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_8762","instance":8762,"id":228777,"goal":"method InsertSort_8762(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_8763","instance":8763,"id":228778,"goal":"method MergeSort_8763(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_8764","instance":8764,"id":228779,"goal":"method ArrayCopy_8764(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_8765","instance":8765,"id":228780,"goal":"function ListReverse_8765(s: seq): seq\n ensures |ListReverse_8765(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_8765(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_8766","instance":8766,"id":228781,"goal":"function Factorial_8766(n: nat): nat\n ensures Factorial_8766(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_8766(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_8767","instance":8767,"id":228782,"goal":"function Fib_8767(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_8767(n-1) + Fib_8767(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_8768","instance":8768,"id":228783,"goal":"function Gcd_8768(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_8768(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_8769","instance":8769,"id":228784,"goal":"function Power_8769(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_8769(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_8770","instance":8770,"id":228785,"goal":"function Sum_8770(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_8770(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_8771","instance":8771,"id":228786,"goal":"method BinarySearch_8771(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_8772","instance":8772,"id":228787,"goal":"method InsertSort_8772(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_8773","instance":8773,"id":228788,"goal":"method MergeSort_8773(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_8774","instance":8774,"id":228789,"goal":"method ArrayCopy_8774(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_8775","instance":8775,"id":228790,"goal":"function ListReverse_8775(s: seq): seq\n ensures |ListReverse_8775(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_8775(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_8776","instance":8776,"id":228791,"goal":"function Factorial_8776(n: nat): nat\n ensures Factorial_8776(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_8776(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_8777","instance":8777,"id":228792,"goal":"function Fib_8777(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_8777(n-1) + Fib_8777(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_8778","instance":8778,"id":228793,"goal":"function Gcd_8778(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_8778(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_8779","instance":8779,"id":228794,"goal":"function Power_8779(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_8779(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_8780","instance":8780,"id":228795,"goal":"function Sum_8780(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_8780(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_8781","instance":8781,"id":228796,"goal":"method BinarySearch_8781(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_8782","instance":8782,"id":228797,"goal":"method InsertSort_8782(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_8783","instance":8783,"id":228798,"goal":"method MergeSort_8783(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_8784","instance":8784,"id":228799,"goal":"method ArrayCopy_8784(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_8785","instance":8785,"id":228800,"goal":"function ListReverse_8785(s: seq): seq\n ensures |ListReverse_8785(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_8785(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_8786","instance":8786,"id":228801,"goal":"function Factorial_8786(n: nat): nat\n ensures Factorial_8786(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_8786(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_8787","instance":8787,"id":228802,"goal":"function Fib_8787(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_8787(n-1) + Fib_8787(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_8788","instance":8788,"id":228803,"goal":"function Gcd_8788(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_8788(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_8789","instance":8789,"id":228804,"goal":"function Power_8789(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_8789(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_8790","instance":8790,"id":228805,"goal":"function Sum_8790(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_8790(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_8791","instance":8791,"id":228806,"goal":"method BinarySearch_8791(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_8792","instance":8792,"id":228807,"goal":"method InsertSort_8792(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_8793","instance":8793,"id":228808,"goal":"method MergeSort_8793(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_8794","instance":8794,"id":228809,"goal":"method ArrayCopy_8794(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_8795","instance":8795,"id":228810,"goal":"function ListReverse_8795(s: seq): seq\n ensures |ListReverse_8795(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_8795(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_8796","instance":8796,"id":228811,"goal":"function Factorial_8796(n: nat): nat\n ensures Factorial_8796(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_8796(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_8797","instance":8797,"id":228812,"goal":"function Fib_8797(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_8797(n-1) + Fib_8797(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_8798","instance":8798,"id":228813,"goal":"function Gcd_8798(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_8798(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_8799","instance":8799,"id":228814,"goal":"function Power_8799(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_8799(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_8800","instance":8800,"id":228815,"goal":"function Sum_8800(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_8800(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_8801","instance":8801,"id":228816,"goal":"method BinarySearch_8801(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_8802","instance":8802,"id":228817,"goal":"method InsertSort_8802(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_8803","instance":8803,"id":228818,"goal":"method MergeSort_8803(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_8804","instance":8804,"id":228819,"goal":"method ArrayCopy_8804(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_8805","instance":8805,"id":228820,"goal":"function ListReverse_8805(s: seq): seq\n ensures |ListReverse_8805(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_8805(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_8806","instance":8806,"id":228821,"goal":"function Factorial_8806(n: nat): nat\n ensures Factorial_8806(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_8806(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_8807","instance":8807,"id":228822,"goal":"function Fib_8807(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_8807(n-1) + Fib_8807(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_8808","instance":8808,"id":228823,"goal":"function Gcd_8808(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_8808(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_8809","instance":8809,"id":228824,"goal":"function Power_8809(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_8809(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_8810","instance":8810,"id":228825,"goal":"function Sum_8810(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_8810(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_8811","instance":8811,"id":228826,"goal":"method BinarySearch_8811(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_8812","instance":8812,"id":228827,"goal":"method InsertSort_8812(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_8813","instance":8813,"id":228828,"goal":"method MergeSort_8813(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_8814","instance":8814,"id":228829,"goal":"method ArrayCopy_8814(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_8815","instance":8815,"id":228830,"goal":"function ListReverse_8815(s: seq): seq\n ensures |ListReverse_8815(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_8815(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_8816","instance":8816,"id":228831,"goal":"function Factorial_8816(n: nat): nat\n ensures Factorial_8816(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_8816(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_8817","instance":8817,"id":228832,"goal":"function Fib_8817(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_8817(n-1) + Fib_8817(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_8818","instance":8818,"id":228833,"goal":"function Gcd_8818(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_8818(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_8819","instance":8819,"id":228834,"goal":"function Power_8819(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_8819(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_8820","instance":8820,"id":228835,"goal":"function Sum_8820(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_8820(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_8821","instance":8821,"id":228836,"goal":"method BinarySearch_8821(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_8822","instance":8822,"id":228837,"goal":"method InsertSort_8822(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_8823","instance":8823,"id":228838,"goal":"method MergeSort_8823(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_8824","instance":8824,"id":228839,"goal":"method ArrayCopy_8824(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_8825","instance":8825,"id":228840,"goal":"function ListReverse_8825(s: seq): seq\n ensures |ListReverse_8825(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_8825(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_8826","instance":8826,"id":228841,"goal":"function Factorial_8826(n: nat): nat\n ensures Factorial_8826(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_8826(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_8827","instance":8827,"id":228842,"goal":"function Fib_8827(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_8827(n-1) + Fib_8827(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_8828","instance":8828,"id":228843,"goal":"function Gcd_8828(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_8828(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_8829","instance":8829,"id":228844,"goal":"function Power_8829(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_8829(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_8830","instance":8830,"id":228845,"goal":"function Sum_8830(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_8830(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_8831","instance":8831,"id":228846,"goal":"method BinarySearch_8831(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_8832","instance":8832,"id":228847,"goal":"method InsertSort_8832(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_8833","instance":8833,"id":228848,"goal":"method MergeSort_8833(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_8834","instance":8834,"id":228849,"goal":"method ArrayCopy_8834(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_8835","instance":8835,"id":228850,"goal":"function ListReverse_8835(s: seq): seq\n ensures |ListReverse_8835(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_8835(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_8836","instance":8836,"id":228851,"goal":"function Factorial_8836(n: nat): nat\n ensures Factorial_8836(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_8836(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_8837","instance":8837,"id":228852,"goal":"function Fib_8837(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_8837(n-1) + Fib_8837(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_8838","instance":8838,"id":228853,"goal":"function Gcd_8838(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_8838(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_8839","instance":8839,"id":228854,"goal":"function Power_8839(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_8839(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_8840","instance":8840,"id":228855,"goal":"function Sum_8840(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_8840(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_8841","instance":8841,"id":228856,"goal":"method BinarySearch_8841(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_8842","instance":8842,"id":228857,"goal":"method InsertSort_8842(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_8843","instance":8843,"id":228858,"goal":"method MergeSort_8843(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_8844","instance":8844,"id":228859,"goal":"method ArrayCopy_8844(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_8845","instance":8845,"id":228860,"goal":"function ListReverse_8845(s: seq): seq\n ensures |ListReverse_8845(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_8845(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_8846","instance":8846,"id":228861,"goal":"function Factorial_8846(n: nat): nat\n ensures Factorial_8846(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_8846(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_8847","instance":8847,"id":228862,"goal":"function Fib_8847(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_8847(n-1) + Fib_8847(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_8848","instance":8848,"id":228863,"goal":"function Gcd_8848(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_8848(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_8849","instance":8849,"id":228864,"goal":"function Power_8849(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_8849(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_8850","instance":8850,"id":228865,"goal":"function Sum_8850(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_8850(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_8851","instance":8851,"id":228866,"goal":"method BinarySearch_8851(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_8852","instance":8852,"id":228867,"goal":"method InsertSort_8852(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_8853","instance":8853,"id":228868,"goal":"method MergeSort_8853(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_8854","instance":8854,"id":228869,"goal":"method ArrayCopy_8854(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_8855","instance":8855,"id":228870,"goal":"function ListReverse_8855(s: seq): seq\n ensures |ListReverse_8855(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_8855(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_8856","instance":8856,"id":228871,"goal":"function Factorial_8856(n: nat): nat\n ensures Factorial_8856(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_8856(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_8857","instance":8857,"id":228872,"goal":"function Fib_8857(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_8857(n-1) + Fib_8857(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_8858","instance":8858,"id":228873,"goal":"function Gcd_8858(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_8858(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_8859","instance":8859,"id":228874,"goal":"function Power_8859(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_8859(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_8860","instance":8860,"id":228875,"goal":"function Sum_8860(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_8860(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_8861","instance":8861,"id":228876,"goal":"method BinarySearch_8861(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_8862","instance":8862,"id":228877,"goal":"method InsertSort_8862(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_8863","instance":8863,"id":228878,"goal":"method MergeSort_8863(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_8864","instance":8864,"id":228879,"goal":"method ArrayCopy_8864(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_8865","instance":8865,"id":228880,"goal":"function ListReverse_8865(s: seq): seq\n ensures |ListReverse_8865(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_8865(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_8866","instance":8866,"id":228881,"goal":"function Factorial_8866(n: nat): nat\n ensures Factorial_8866(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_8866(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_8867","instance":8867,"id":228882,"goal":"function Fib_8867(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_8867(n-1) + Fib_8867(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_8868","instance":8868,"id":228883,"goal":"function Gcd_8868(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_8868(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_8869","instance":8869,"id":228884,"goal":"function Power_8869(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_8869(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_8870","instance":8870,"id":228885,"goal":"function Sum_8870(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_8870(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_8871","instance":8871,"id":228886,"goal":"method BinarySearch_8871(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_8872","instance":8872,"id":228887,"goal":"method InsertSort_8872(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_8873","instance":8873,"id":228888,"goal":"method MergeSort_8873(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_8874","instance":8874,"id":228889,"goal":"method ArrayCopy_8874(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_8875","instance":8875,"id":228890,"goal":"function ListReverse_8875(s: seq): seq\n ensures |ListReverse_8875(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_8875(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_8876","instance":8876,"id":228891,"goal":"function Factorial_8876(n: nat): nat\n ensures Factorial_8876(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_8876(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_8877","instance":8877,"id":228892,"goal":"function Fib_8877(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_8877(n-1) + Fib_8877(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_8878","instance":8878,"id":228893,"goal":"function Gcd_8878(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_8878(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_8879","instance":8879,"id":228894,"goal":"function Power_8879(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_8879(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_8880","instance":8880,"id":228895,"goal":"function Sum_8880(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_8880(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_8881","instance":8881,"id":228896,"goal":"method BinarySearch_8881(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_8882","instance":8882,"id":228897,"goal":"method InsertSort_8882(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_8883","instance":8883,"id":228898,"goal":"method MergeSort_8883(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_8884","instance":8884,"id":228899,"goal":"method ArrayCopy_8884(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_8885","instance":8885,"id":228900,"goal":"function ListReverse_8885(s: seq): seq\n ensures |ListReverse_8885(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_8885(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_8886","instance":8886,"id":228901,"goal":"function Factorial_8886(n: nat): nat\n ensures Factorial_8886(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_8886(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_8887","instance":8887,"id":228902,"goal":"function Fib_8887(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_8887(n-1) + Fib_8887(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_8888","instance":8888,"id":228903,"goal":"function Gcd_8888(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_8888(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_8889","instance":8889,"id":228904,"goal":"function Power_8889(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_8889(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_8890","instance":8890,"id":228905,"goal":"function Sum_8890(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_8890(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_8891","instance":8891,"id":228906,"goal":"method BinarySearch_8891(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_8892","instance":8892,"id":228907,"goal":"method InsertSort_8892(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_8893","instance":8893,"id":228908,"goal":"method MergeSort_8893(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_8894","instance":8894,"id":228909,"goal":"method ArrayCopy_8894(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_8895","instance":8895,"id":228910,"goal":"function ListReverse_8895(s: seq): seq\n ensures |ListReverse_8895(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_8895(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_8896","instance":8896,"id":228911,"goal":"function Factorial_8896(n: nat): nat\n ensures Factorial_8896(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_8896(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_8897","instance":8897,"id":228912,"goal":"function Fib_8897(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_8897(n-1) + Fib_8897(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_8898","instance":8898,"id":228913,"goal":"function Gcd_8898(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_8898(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_8899","instance":8899,"id":228914,"goal":"function Power_8899(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_8899(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_8900","instance":8900,"id":228915,"goal":"function Sum_8900(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_8900(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_8901","instance":8901,"id":228916,"goal":"method BinarySearch_8901(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_8902","instance":8902,"id":228917,"goal":"method InsertSort_8902(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_8903","instance":8903,"id":228918,"goal":"method MergeSort_8903(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_8904","instance":8904,"id":228919,"goal":"method ArrayCopy_8904(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_8905","instance":8905,"id":228920,"goal":"function ListReverse_8905(s: seq): seq\n ensures |ListReverse_8905(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_8905(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_8906","instance":8906,"id":228921,"goal":"function Factorial_8906(n: nat): nat\n ensures Factorial_8906(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_8906(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_8907","instance":8907,"id":228922,"goal":"function Fib_8907(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_8907(n-1) + Fib_8907(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_8908","instance":8908,"id":228923,"goal":"function Gcd_8908(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_8908(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_8909","instance":8909,"id":228924,"goal":"function Power_8909(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_8909(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_8910","instance":8910,"id":228925,"goal":"function Sum_8910(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_8910(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_8911","instance":8911,"id":228926,"goal":"method BinarySearch_8911(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_8912","instance":8912,"id":228927,"goal":"method InsertSort_8912(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_8913","instance":8913,"id":228928,"goal":"method MergeSort_8913(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_8914","instance":8914,"id":228929,"goal":"method ArrayCopy_8914(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_8915","instance":8915,"id":228930,"goal":"function ListReverse_8915(s: seq): seq\n ensures |ListReverse_8915(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_8915(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_8916","instance":8916,"id":228931,"goal":"function Factorial_8916(n: nat): nat\n ensures Factorial_8916(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_8916(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_8917","instance":8917,"id":228932,"goal":"function Fib_8917(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_8917(n-1) + Fib_8917(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_8918","instance":8918,"id":228933,"goal":"function Gcd_8918(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_8918(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_8919","instance":8919,"id":228934,"goal":"function Power_8919(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_8919(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_8920","instance":8920,"id":228935,"goal":"function Sum_8920(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_8920(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_8921","instance":8921,"id":228936,"goal":"method BinarySearch_8921(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_8922","instance":8922,"id":228937,"goal":"method InsertSort_8922(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_8923","instance":8923,"id":228938,"goal":"method MergeSort_8923(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_8924","instance":8924,"id":228939,"goal":"method ArrayCopy_8924(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_8925","instance":8925,"id":228940,"goal":"function ListReverse_8925(s: seq): seq\n ensures |ListReverse_8925(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_8925(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_8926","instance":8926,"id":228941,"goal":"function Factorial_8926(n: nat): nat\n ensures Factorial_8926(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_8926(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_8927","instance":8927,"id":228942,"goal":"function Fib_8927(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_8927(n-1) + Fib_8927(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_8928","instance":8928,"id":228943,"goal":"function Gcd_8928(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_8928(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_8929","instance":8929,"id":228944,"goal":"function Power_8929(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_8929(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_8930","instance":8930,"id":228945,"goal":"function Sum_8930(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_8930(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_8931","instance":8931,"id":228946,"goal":"method BinarySearch_8931(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_8932","instance":8932,"id":228947,"goal":"method InsertSort_8932(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_8933","instance":8933,"id":228948,"goal":"method MergeSort_8933(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_8934","instance":8934,"id":228949,"goal":"method ArrayCopy_8934(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_8935","instance":8935,"id":228950,"goal":"function ListReverse_8935(s: seq): seq\n ensures |ListReverse_8935(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_8935(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_8936","instance":8936,"id":228951,"goal":"function Factorial_8936(n: nat): nat\n ensures Factorial_8936(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_8936(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_8937","instance":8937,"id":228952,"goal":"function Fib_8937(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_8937(n-1) + Fib_8937(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_8938","instance":8938,"id":228953,"goal":"function Gcd_8938(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_8938(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_8939","instance":8939,"id":228954,"goal":"function Power_8939(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_8939(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_8940","instance":8940,"id":228955,"goal":"function Sum_8940(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_8940(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_8941","instance":8941,"id":228956,"goal":"method BinarySearch_8941(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_8942","instance":8942,"id":228957,"goal":"method InsertSort_8942(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_8943","instance":8943,"id":228958,"goal":"method MergeSort_8943(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_8944","instance":8944,"id":228959,"goal":"method ArrayCopy_8944(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_8945","instance":8945,"id":228960,"goal":"function ListReverse_8945(s: seq): seq\n ensures |ListReverse_8945(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_8945(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_8946","instance":8946,"id":228961,"goal":"function Factorial_8946(n: nat): nat\n ensures Factorial_8946(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_8946(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_8947","instance":8947,"id":228962,"goal":"function Fib_8947(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_8947(n-1) + Fib_8947(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_8948","instance":8948,"id":228963,"goal":"function Gcd_8948(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_8948(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_8949","instance":8949,"id":228964,"goal":"function Power_8949(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_8949(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_8950","instance":8950,"id":228965,"goal":"function Sum_8950(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_8950(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_8951","instance":8951,"id":228966,"goal":"method BinarySearch_8951(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_8952","instance":8952,"id":228967,"goal":"method InsertSort_8952(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_8953","instance":8953,"id":228968,"goal":"method MergeSort_8953(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_8954","instance":8954,"id":228969,"goal":"method ArrayCopy_8954(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_8955","instance":8955,"id":228970,"goal":"function ListReverse_8955(s: seq): seq\n ensures |ListReverse_8955(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_8955(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_8956","instance":8956,"id":228971,"goal":"function Factorial_8956(n: nat): nat\n ensures Factorial_8956(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_8956(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_8957","instance":8957,"id":228972,"goal":"function Fib_8957(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_8957(n-1) + Fib_8957(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_8958","instance":8958,"id":228973,"goal":"function Gcd_8958(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_8958(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_8959","instance":8959,"id":228974,"goal":"function Power_8959(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_8959(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_8960","instance":8960,"id":228975,"goal":"function Sum_8960(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_8960(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_8961","instance":8961,"id":228976,"goal":"method BinarySearch_8961(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_8962","instance":8962,"id":228977,"goal":"method InsertSort_8962(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_8963","instance":8963,"id":228978,"goal":"method MergeSort_8963(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_8964","instance":8964,"id":228979,"goal":"method ArrayCopy_8964(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_8965","instance":8965,"id":228980,"goal":"function ListReverse_8965(s: seq): seq\n ensures |ListReverse_8965(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_8965(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_8966","instance":8966,"id":228981,"goal":"function Factorial_8966(n: nat): nat\n ensures Factorial_8966(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_8966(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_8967","instance":8967,"id":228982,"goal":"function Fib_8967(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_8967(n-1) + Fib_8967(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_8968","instance":8968,"id":228983,"goal":"function Gcd_8968(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_8968(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_8969","instance":8969,"id":228984,"goal":"function Power_8969(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_8969(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_8970","instance":8970,"id":228985,"goal":"function Sum_8970(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_8970(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_8971","instance":8971,"id":228986,"goal":"method BinarySearch_8971(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_8972","instance":8972,"id":228987,"goal":"method InsertSort_8972(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_8973","instance":8973,"id":228988,"goal":"method MergeSort_8973(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_8974","instance":8974,"id":228989,"goal":"method ArrayCopy_8974(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_8975","instance":8975,"id":228990,"goal":"function ListReverse_8975(s: seq): seq\n ensures |ListReverse_8975(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_8975(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_8976","instance":8976,"id":228991,"goal":"function Factorial_8976(n: nat): nat\n ensures Factorial_8976(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_8976(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_8977","instance":8977,"id":228992,"goal":"function Fib_8977(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_8977(n-1) + Fib_8977(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_8978","instance":8978,"id":228993,"goal":"function Gcd_8978(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_8978(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_8979","instance":8979,"id":228994,"goal":"function Power_8979(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_8979(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_8980","instance":8980,"id":228995,"goal":"function Sum_8980(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_8980(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_8981","instance":8981,"id":228996,"goal":"method BinarySearch_8981(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_8982","instance":8982,"id":228997,"goal":"method InsertSort_8982(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_8983","instance":8983,"id":228998,"goal":"method MergeSort_8983(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_8984","instance":8984,"id":228999,"goal":"method ArrayCopy_8984(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_8985","instance":8985,"id":229000,"goal":"function ListReverse_8985(s: seq): seq\n ensures |ListReverse_8985(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_8985(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_8986","instance":8986,"id":229001,"goal":"function Factorial_8986(n: nat): nat\n ensures Factorial_8986(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_8986(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_8987","instance":8987,"id":229002,"goal":"function Fib_8987(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_8987(n-1) + Fib_8987(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_8988","instance":8988,"id":229003,"goal":"function Gcd_8988(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_8988(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_8989","instance":8989,"id":229004,"goal":"function Power_8989(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_8989(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_8990","instance":8990,"id":229005,"goal":"function Sum_8990(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_8990(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_8991","instance":8991,"id":229006,"goal":"method BinarySearch_8991(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_8992","instance":8992,"id":229007,"goal":"method InsertSort_8992(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_8993","instance":8993,"id":229008,"goal":"method MergeSort_8993(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_8994","instance":8994,"id":229009,"goal":"method ArrayCopy_8994(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_8995","instance":8995,"id":229010,"goal":"function ListReverse_8995(s: seq): seq\n ensures |ListReverse_8995(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_8995(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_8996","instance":8996,"id":229011,"goal":"function Factorial_8996(n: nat): nat\n ensures Factorial_8996(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_8996(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_8997","instance":8997,"id":229012,"goal":"function Fib_8997(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_8997(n-1) + Fib_8997(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_8998","instance":8998,"id":229013,"goal":"function Gcd_8998(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_8998(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_8999","instance":8999,"id":229014,"goal":"function Power_8999(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_8999(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_9000","instance":9000,"id":229015,"goal":"function Sum_9000(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_9000(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_9001","instance":9001,"id":229016,"goal":"method BinarySearch_9001(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_9002","instance":9002,"id":229017,"goal":"method InsertSort_9002(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_9003","instance":9003,"id":229018,"goal":"method MergeSort_9003(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_9004","instance":9004,"id":229019,"goal":"method ArrayCopy_9004(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_9005","instance":9005,"id":229020,"goal":"function ListReverse_9005(s: seq): seq\n ensures |ListReverse_9005(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_9005(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_9006","instance":9006,"id":229021,"goal":"function Factorial_9006(n: nat): nat\n ensures Factorial_9006(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_9006(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_9007","instance":9007,"id":229022,"goal":"function Fib_9007(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_9007(n-1) + Fib_9007(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_9008","instance":9008,"id":229023,"goal":"function Gcd_9008(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_9008(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_9009","instance":9009,"id":229024,"goal":"function Power_9009(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_9009(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_9010","instance":9010,"id":229025,"goal":"function Sum_9010(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_9010(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_9011","instance":9011,"id":229026,"goal":"method BinarySearch_9011(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_9012","instance":9012,"id":229027,"goal":"method InsertSort_9012(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_9013","instance":9013,"id":229028,"goal":"method MergeSort_9013(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_9014","instance":9014,"id":229029,"goal":"method ArrayCopy_9014(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_9015","instance":9015,"id":229030,"goal":"function ListReverse_9015(s: seq): seq\n ensures |ListReverse_9015(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_9015(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_9016","instance":9016,"id":229031,"goal":"function Factorial_9016(n: nat): nat\n ensures Factorial_9016(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_9016(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_9017","instance":9017,"id":229032,"goal":"function Fib_9017(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_9017(n-1) + Fib_9017(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_9018","instance":9018,"id":229033,"goal":"function Gcd_9018(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_9018(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_9019","instance":9019,"id":229034,"goal":"function Power_9019(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_9019(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_9020","instance":9020,"id":229035,"goal":"function Sum_9020(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_9020(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_9021","instance":9021,"id":229036,"goal":"method BinarySearch_9021(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_9022","instance":9022,"id":229037,"goal":"method InsertSort_9022(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_9023","instance":9023,"id":229038,"goal":"method MergeSort_9023(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_9024","instance":9024,"id":229039,"goal":"method ArrayCopy_9024(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_9025","instance":9025,"id":229040,"goal":"function ListReverse_9025(s: seq): seq\n ensures |ListReverse_9025(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_9025(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_9026","instance":9026,"id":229041,"goal":"function Factorial_9026(n: nat): nat\n ensures Factorial_9026(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_9026(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_9027","instance":9027,"id":229042,"goal":"function Fib_9027(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_9027(n-1) + Fib_9027(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_9028","instance":9028,"id":229043,"goal":"function Gcd_9028(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_9028(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_9029","instance":9029,"id":229044,"goal":"function Power_9029(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_9029(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_9030","instance":9030,"id":229045,"goal":"function Sum_9030(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_9030(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_9031","instance":9031,"id":229046,"goal":"method BinarySearch_9031(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_9032","instance":9032,"id":229047,"goal":"method InsertSort_9032(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_9033","instance":9033,"id":229048,"goal":"method MergeSort_9033(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_9034","instance":9034,"id":229049,"goal":"method ArrayCopy_9034(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_9035","instance":9035,"id":229050,"goal":"function ListReverse_9035(s: seq): seq\n ensures |ListReverse_9035(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_9035(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_9036","instance":9036,"id":229051,"goal":"function Factorial_9036(n: nat): nat\n ensures Factorial_9036(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_9036(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_9037","instance":9037,"id":229052,"goal":"function Fib_9037(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_9037(n-1) + Fib_9037(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_9038","instance":9038,"id":229053,"goal":"function Gcd_9038(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_9038(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_9039","instance":9039,"id":229054,"goal":"function Power_9039(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_9039(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_9040","instance":9040,"id":229055,"goal":"function Sum_9040(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_9040(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_9041","instance":9041,"id":229056,"goal":"method BinarySearch_9041(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_9042","instance":9042,"id":229057,"goal":"method InsertSort_9042(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_9043","instance":9043,"id":229058,"goal":"method MergeSort_9043(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_9044","instance":9044,"id":229059,"goal":"method ArrayCopy_9044(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_9045","instance":9045,"id":229060,"goal":"function ListReverse_9045(s: seq): seq\n ensures |ListReverse_9045(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_9045(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_9046","instance":9046,"id":229061,"goal":"function Factorial_9046(n: nat): nat\n ensures Factorial_9046(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_9046(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_9047","instance":9047,"id":229062,"goal":"function Fib_9047(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_9047(n-1) + Fib_9047(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_9048","instance":9048,"id":229063,"goal":"function Gcd_9048(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_9048(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_9049","instance":9049,"id":229064,"goal":"function Power_9049(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_9049(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_9050","instance":9050,"id":229065,"goal":"function Sum_9050(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_9050(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_9051","instance":9051,"id":229066,"goal":"method BinarySearch_9051(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_9052","instance":9052,"id":229067,"goal":"method InsertSort_9052(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_9053","instance":9053,"id":229068,"goal":"method MergeSort_9053(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_9054","instance":9054,"id":229069,"goal":"method ArrayCopy_9054(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_9055","instance":9055,"id":229070,"goal":"function ListReverse_9055(s: seq): seq\n ensures |ListReverse_9055(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_9055(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_9056","instance":9056,"id":229071,"goal":"function Factorial_9056(n: nat): nat\n ensures Factorial_9056(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_9056(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_9057","instance":9057,"id":229072,"goal":"function Fib_9057(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_9057(n-1) + Fib_9057(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_9058","instance":9058,"id":229073,"goal":"function Gcd_9058(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_9058(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_9059","instance":9059,"id":229074,"goal":"function Power_9059(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_9059(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_9060","instance":9060,"id":229075,"goal":"function Sum_9060(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_9060(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_9061","instance":9061,"id":229076,"goal":"method BinarySearch_9061(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_9062","instance":9062,"id":229077,"goal":"method InsertSort_9062(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_9063","instance":9063,"id":229078,"goal":"method MergeSort_9063(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_9064","instance":9064,"id":229079,"goal":"method ArrayCopy_9064(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_9065","instance":9065,"id":229080,"goal":"function ListReverse_9065(s: seq): seq\n ensures |ListReverse_9065(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_9065(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_9066","instance":9066,"id":229081,"goal":"function Factorial_9066(n: nat): nat\n ensures Factorial_9066(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_9066(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_9067","instance":9067,"id":229082,"goal":"function Fib_9067(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_9067(n-1) + Fib_9067(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_9068","instance":9068,"id":229083,"goal":"function Gcd_9068(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_9068(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_9069","instance":9069,"id":229084,"goal":"function Power_9069(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_9069(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_9070","instance":9070,"id":229085,"goal":"function Sum_9070(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_9070(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_9071","instance":9071,"id":229086,"goal":"method BinarySearch_9071(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_9072","instance":9072,"id":229087,"goal":"method InsertSort_9072(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_9073","instance":9073,"id":229088,"goal":"method MergeSort_9073(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_9074","instance":9074,"id":229089,"goal":"method ArrayCopy_9074(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_9075","instance":9075,"id":229090,"goal":"function ListReverse_9075(s: seq): seq\n ensures |ListReverse_9075(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_9075(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_9076","instance":9076,"id":229091,"goal":"function Factorial_9076(n: nat): nat\n ensures Factorial_9076(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_9076(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_9077","instance":9077,"id":229092,"goal":"function Fib_9077(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_9077(n-1) + Fib_9077(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_9078","instance":9078,"id":229093,"goal":"function Gcd_9078(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_9078(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_9079","instance":9079,"id":229094,"goal":"function Power_9079(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_9079(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_9080","instance":9080,"id":229095,"goal":"function Sum_9080(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_9080(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_9081","instance":9081,"id":229096,"goal":"method BinarySearch_9081(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_9082","instance":9082,"id":229097,"goal":"method InsertSort_9082(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_9083","instance":9083,"id":229098,"goal":"method MergeSort_9083(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_9084","instance":9084,"id":229099,"goal":"method ArrayCopy_9084(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_9085","instance":9085,"id":229100,"goal":"function ListReverse_9085(s: seq): seq\n ensures |ListReverse_9085(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_9085(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_9086","instance":9086,"id":229101,"goal":"function Factorial_9086(n: nat): nat\n ensures Factorial_9086(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_9086(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_9087","instance":9087,"id":229102,"goal":"function Fib_9087(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_9087(n-1) + Fib_9087(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_9088","instance":9088,"id":229103,"goal":"function Gcd_9088(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_9088(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_9089","instance":9089,"id":229104,"goal":"function Power_9089(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_9089(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_9090","instance":9090,"id":229105,"goal":"function Sum_9090(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_9090(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_9091","instance":9091,"id":229106,"goal":"method BinarySearch_9091(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_9092","instance":9092,"id":229107,"goal":"method InsertSort_9092(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_9093","instance":9093,"id":229108,"goal":"method MergeSort_9093(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_9094","instance":9094,"id":229109,"goal":"method ArrayCopy_9094(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_9095","instance":9095,"id":229110,"goal":"function ListReverse_9095(s: seq): seq\n ensures |ListReverse_9095(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_9095(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_9096","instance":9096,"id":229111,"goal":"function Factorial_9096(n: nat): nat\n ensures Factorial_9096(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_9096(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_9097","instance":9097,"id":229112,"goal":"function Fib_9097(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_9097(n-1) + Fib_9097(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_9098","instance":9098,"id":229113,"goal":"function Gcd_9098(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_9098(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_9099","instance":9099,"id":229114,"goal":"function Power_9099(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_9099(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_9100","instance":9100,"id":229115,"goal":"function Sum_9100(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_9100(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_9101","instance":9101,"id":229116,"goal":"method BinarySearch_9101(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_9102","instance":9102,"id":229117,"goal":"method InsertSort_9102(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_9103","instance":9103,"id":229118,"goal":"method MergeSort_9103(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_9104","instance":9104,"id":229119,"goal":"method ArrayCopy_9104(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_9105","instance":9105,"id":229120,"goal":"function ListReverse_9105(s: seq): seq\n ensures |ListReverse_9105(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_9105(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_9106","instance":9106,"id":229121,"goal":"function Factorial_9106(n: nat): nat\n ensures Factorial_9106(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_9106(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_9107","instance":9107,"id":229122,"goal":"function Fib_9107(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_9107(n-1) + Fib_9107(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_9108","instance":9108,"id":229123,"goal":"function Gcd_9108(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_9108(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_9109","instance":9109,"id":229124,"goal":"function Power_9109(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_9109(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_9110","instance":9110,"id":229125,"goal":"function Sum_9110(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_9110(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_9111","instance":9111,"id":229126,"goal":"method BinarySearch_9111(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_9112","instance":9112,"id":229127,"goal":"method InsertSort_9112(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_9113","instance":9113,"id":229128,"goal":"method MergeSort_9113(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_9114","instance":9114,"id":229129,"goal":"method ArrayCopy_9114(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_9115","instance":9115,"id":229130,"goal":"function ListReverse_9115(s: seq): seq\n ensures |ListReverse_9115(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_9115(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_9116","instance":9116,"id":229131,"goal":"function Factorial_9116(n: nat): nat\n ensures Factorial_9116(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_9116(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_9117","instance":9117,"id":229132,"goal":"function Fib_9117(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_9117(n-1) + Fib_9117(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_9118","instance":9118,"id":229133,"goal":"function Gcd_9118(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_9118(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_9119","instance":9119,"id":229134,"goal":"function Power_9119(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_9119(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_9120","instance":9120,"id":229135,"goal":"function Sum_9120(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_9120(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_9121","instance":9121,"id":229136,"goal":"method BinarySearch_9121(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_9122","instance":9122,"id":229137,"goal":"method InsertSort_9122(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_9123","instance":9123,"id":229138,"goal":"method MergeSort_9123(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_9124","instance":9124,"id":229139,"goal":"method ArrayCopy_9124(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_9125","instance":9125,"id":229140,"goal":"function ListReverse_9125(s: seq): seq\n ensures |ListReverse_9125(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_9125(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_9126","instance":9126,"id":229141,"goal":"function Factorial_9126(n: nat): nat\n ensures Factorial_9126(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_9126(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_9127","instance":9127,"id":229142,"goal":"function Fib_9127(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_9127(n-1) + Fib_9127(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_9128","instance":9128,"id":229143,"goal":"function Gcd_9128(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_9128(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_9129","instance":9129,"id":229144,"goal":"function Power_9129(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_9129(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_9130","instance":9130,"id":229145,"goal":"function Sum_9130(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_9130(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_9131","instance":9131,"id":229146,"goal":"method BinarySearch_9131(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_9132","instance":9132,"id":229147,"goal":"method InsertSort_9132(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_9133","instance":9133,"id":229148,"goal":"method MergeSort_9133(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_9134","instance":9134,"id":229149,"goal":"method ArrayCopy_9134(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_9135","instance":9135,"id":229150,"goal":"function ListReverse_9135(s: seq): seq\n ensures |ListReverse_9135(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_9135(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_9136","instance":9136,"id":229151,"goal":"function Factorial_9136(n: nat): nat\n ensures Factorial_9136(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_9136(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_9137","instance":9137,"id":229152,"goal":"function Fib_9137(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_9137(n-1) + Fib_9137(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_9138","instance":9138,"id":229153,"goal":"function Gcd_9138(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_9138(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_9139","instance":9139,"id":229154,"goal":"function Power_9139(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_9139(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_9140","instance":9140,"id":229155,"goal":"function Sum_9140(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_9140(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_9141","instance":9141,"id":229156,"goal":"method BinarySearch_9141(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_9142","instance":9142,"id":229157,"goal":"method InsertSort_9142(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_9143","instance":9143,"id":229158,"goal":"method MergeSort_9143(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_9144","instance":9144,"id":229159,"goal":"method ArrayCopy_9144(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_9145","instance":9145,"id":229160,"goal":"function ListReverse_9145(s: seq): seq\n ensures |ListReverse_9145(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_9145(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_9146","instance":9146,"id":229161,"goal":"function Factorial_9146(n: nat): nat\n ensures Factorial_9146(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_9146(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_9147","instance":9147,"id":229162,"goal":"function Fib_9147(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_9147(n-1) + Fib_9147(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_9148","instance":9148,"id":229163,"goal":"function Gcd_9148(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_9148(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_9149","instance":9149,"id":229164,"goal":"function Power_9149(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_9149(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_9150","instance":9150,"id":229165,"goal":"function Sum_9150(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_9150(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_9151","instance":9151,"id":229166,"goal":"method BinarySearch_9151(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_9152","instance":9152,"id":229167,"goal":"method InsertSort_9152(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_9153","instance":9153,"id":229168,"goal":"method MergeSort_9153(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_9154","instance":9154,"id":229169,"goal":"method ArrayCopy_9154(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_9155","instance":9155,"id":229170,"goal":"function ListReverse_9155(s: seq): seq\n ensures |ListReverse_9155(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_9155(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_9156","instance":9156,"id":229171,"goal":"function Factorial_9156(n: nat): nat\n ensures Factorial_9156(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_9156(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_9157","instance":9157,"id":229172,"goal":"function Fib_9157(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_9157(n-1) + Fib_9157(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_9158","instance":9158,"id":229173,"goal":"function Gcd_9158(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_9158(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_9159","instance":9159,"id":229174,"goal":"function Power_9159(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_9159(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_9160","instance":9160,"id":229175,"goal":"function Sum_9160(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_9160(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_9161","instance":9161,"id":229176,"goal":"method BinarySearch_9161(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_9162","instance":9162,"id":229177,"goal":"method InsertSort_9162(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_9163","instance":9163,"id":229178,"goal":"method MergeSort_9163(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_9164","instance":9164,"id":229179,"goal":"method ArrayCopy_9164(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_9165","instance":9165,"id":229180,"goal":"function ListReverse_9165(s: seq): seq\n ensures |ListReverse_9165(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_9165(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_9166","instance":9166,"id":229181,"goal":"function Factorial_9166(n: nat): nat\n ensures Factorial_9166(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_9166(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_9167","instance":9167,"id":229182,"goal":"function Fib_9167(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_9167(n-1) + Fib_9167(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_9168","instance":9168,"id":229183,"goal":"function Gcd_9168(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_9168(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_9169","instance":9169,"id":229184,"goal":"function Power_9169(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_9169(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_9170","instance":9170,"id":229185,"goal":"function Sum_9170(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_9170(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_9171","instance":9171,"id":229186,"goal":"method BinarySearch_9171(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_9172","instance":9172,"id":229187,"goal":"method InsertSort_9172(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_9173","instance":9173,"id":229188,"goal":"method MergeSort_9173(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_9174","instance":9174,"id":229189,"goal":"method ArrayCopy_9174(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_9175","instance":9175,"id":229190,"goal":"function ListReverse_9175(s: seq): seq\n ensures |ListReverse_9175(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_9175(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_9176","instance":9176,"id":229191,"goal":"function Factorial_9176(n: nat): nat\n ensures Factorial_9176(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_9176(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_9177","instance":9177,"id":229192,"goal":"function Fib_9177(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_9177(n-1) + Fib_9177(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_9178","instance":9178,"id":229193,"goal":"function Gcd_9178(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_9178(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_9179","instance":9179,"id":229194,"goal":"function Power_9179(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_9179(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_9180","instance":9180,"id":229195,"goal":"function Sum_9180(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_9180(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_9181","instance":9181,"id":229196,"goal":"method BinarySearch_9181(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_9182","instance":9182,"id":229197,"goal":"method InsertSort_9182(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_9183","instance":9183,"id":229198,"goal":"method MergeSort_9183(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_9184","instance":9184,"id":229199,"goal":"method ArrayCopy_9184(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_9185","instance":9185,"id":229200,"goal":"function ListReverse_9185(s: seq): seq\n ensures |ListReverse_9185(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_9185(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_9186","instance":9186,"id":229201,"goal":"function Factorial_9186(n: nat): nat\n ensures Factorial_9186(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_9186(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_9187","instance":9187,"id":229202,"goal":"function Fib_9187(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_9187(n-1) + Fib_9187(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_9188","instance":9188,"id":229203,"goal":"function Gcd_9188(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_9188(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_9189","instance":9189,"id":229204,"goal":"function Power_9189(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_9189(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_9190","instance":9190,"id":229205,"goal":"function Sum_9190(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_9190(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_9191","instance":9191,"id":229206,"goal":"method BinarySearch_9191(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_9192","instance":9192,"id":229207,"goal":"method InsertSort_9192(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_9193","instance":9193,"id":229208,"goal":"method MergeSort_9193(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_9194","instance":9194,"id":229209,"goal":"method ArrayCopy_9194(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_9195","instance":9195,"id":229210,"goal":"function ListReverse_9195(s: seq): seq\n ensures |ListReverse_9195(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_9195(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_9196","instance":9196,"id":229211,"goal":"function Factorial_9196(n: nat): nat\n ensures Factorial_9196(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_9196(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_9197","instance":9197,"id":229212,"goal":"function Fib_9197(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_9197(n-1) + Fib_9197(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_9198","instance":9198,"id":229213,"goal":"function Gcd_9198(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_9198(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_9199","instance":9199,"id":229214,"goal":"function Power_9199(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_9199(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_9200","instance":9200,"id":229215,"goal":"function Sum_9200(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_9200(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_9201","instance":9201,"id":229216,"goal":"method BinarySearch_9201(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_9202","instance":9202,"id":229217,"goal":"method InsertSort_9202(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_9203","instance":9203,"id":229218,"goal":"method MergeSort_9203(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_9204","instance":9204,"id":229219,"goal":"method ArrayCopy_9204(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_9205","instance":9205,"id":229220,"goal":"function ListReverse_9205(s: seq): seq\n ensures |ListReverse_9205(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_9205(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_9206","instance":9206,"id":229221,"goal":"function Factorial_9206(n: nat): nat\n ensures Factorial_9206(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_9206(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_9207","instance":9207,"id":229222,"goal":"function Fib_9207(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_9207(n-1) + Fib_9207(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_9208","instance":9208,"id":229223,"goal":"function Gcd_9208(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_9208(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_9209","instance":9209,"id":229224,"goal":"function Power_9209(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_9209(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_9210","instance":9210,"id":229225,"goal":"function Sum_9210(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_9210(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_9211","instance":9211,"id":229226,"goal":"method BinarySearch_9211(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_9212","instance":9212,"id":229227,"goal":"method InsertSort_9212(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_9213","instance":9213,"id":229228,"goal":"method MergeSort_9213(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_9214","instance":9214,"id":229229,"goal":"method ArrayCopy_9214(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_9215","instance":9215,"id":229230,"goal":"function ListReverse_9215(s: seq): seq\n ensures |ListReverse_9215(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_9215(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_9216","instance":9216,"id":229231,"goal":"function Factorial_9216(n: nat): nat\n ensures Factorial_9216(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_9216(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_9217","instance":9217,"id":229232,"goal":"function Fib_9217(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_9217(n-1) + Fib_9217(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_9218","instance":9218,"id":229233,"goal":"function Gcd_9218(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_9218(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_9219","instance":9219,"id":229234,"goal":"function Power_9219(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_9219(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_9220","instance":9220,"id":229235,"goal":"function Sum_9220(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_9220(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_9221","instance":9221,"id":229236,"goal":"method BinarySearch_9221(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_9222","instance":9222,"id":229237,"goal":"method InsertSort_9222(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_9223","instance":9223,"id":229238,"goal":"method MergeSort_9223(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_9224","instance":9224,"id":229239,"goal":"method ArrayCopy_9224(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_9225","instance":9225,"id":229240,"goal":"function ListReverse_9225(s: seq): seq\n ensures |ListReverse_9225(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_9225(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_9226","instance":9226,"id":229241,"goal":"function Factorial_9226(n: nat): nat\n ensures Factorial_9226(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_9226(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_9227","instance":9227,"id":229242,"goal":"function Fib_9227(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_9227(n-1) + Fib_9227(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_9228","instance":9228,"id":229243,"goal":"function Gcd_9228(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_9228(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_9229","instance":9229,"id":229244,"goal":"function Power_9229(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_9229(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_9230","instance":9230,"id":229245,"goal":"function Sum_9230(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_9230(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_9231","instance":9231,"id":229246,"goal":"method BinarySearch_9231(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_9232","instance":9232,"id":229247,"goal":"method InsertSort_9232(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_9233","instance":9233,"id":229248,"goal":"method MergeSort_9233(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_9234","instance":9234,"id":229249,"goal":"method ArrayCopy_9234(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_9235","instance":9235,"id":229250,"goal":"function ListReverse_9235(s: seq): seq\n ensures |ListReverse_9235(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_9235(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_9236","instance":9236,"id":229251,"goal":"function Factorial_9236(n: nat): nat\n ensures Factorial_9236(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_9236(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_9237","instance":9237,"id":229252,"goal":"function Fib_9237(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_9237(n-1) + Fib_9237(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_9238","instance":9238,"id":229253,"goal":"function Gcd_9238(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_9238(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_9239","instance":9239,"id":229254,"goal":"function Power_9239(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_9239(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_9240","instance":9240,"id":229255,"goal":"function Sum_9240(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_9240(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_9241","instance":9241,"id":229256,"goal":"method BinarySearch_9241(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_9242","instance":9242,"id":229257,"goal":"method InsertSort_9242(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_9243","instance":9243,"id":229258,"goal":"method MergeSort_9243(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_9244","instance":9244,"id":229259,"goal":"method ArrayCopy_9244(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_9245","instance":9245,"id":229260,"goal":"function ListReverse_9245(s: seq): seq\n ensures |ListReverse_9245(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_9245(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_9246","instance":9246,"id":229261,"goal":"function Factorial_9246(n: nat): nat\n ensures Factorial_9246(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_9246(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_9247","instance":9247,"id":229262,"goal":"function Fib_9247(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_9247(n-1) + Fib_9247(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_9248","instance":9248,"id":229263,"goal":"function Gcd_9248(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_9248(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_9249","instance":9249,"id":229264,"goal":"function Power_9249(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_9249(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_9250","instance":9250,"id":229265,"goal":"function Sum_9250(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_9250(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_9251","instance":9251,"id":229266,"goal":"method BinarySearch_9251(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_9252","instance":9252,"id":229267,"goal":"method InsertSort_9252(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_9253","instance":9253,"id":229268,"goal":"method MergeSort_9253(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_9254","instance":9254,"id":229269,"goal":"method ArrayCopy_9254(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_9255","instance":9255,"id":229270,"goal":"function ListReverse_9255(s: seq): seq\n ensures |ListReverse_9255(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_9255(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_9256","instance":9256,"id":229271,"goal":"function Factorial_9256(n: nat): nat\n ensures Factorial_9256(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_9256(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_9257","instance":9257,"id":229272,"goal":"function Fib_9257(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_9257(n-1) + Fib_9257(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_9258","instance":9258,"id":229273,"goal":"function Gcd_9258(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_9258(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_9259","instance":9259,"id":229274,"goal":"function Power_9259(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_9259(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_9260","instance":9260,"id":229275,"goal":"function Sum_9260(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_9260(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_9261","instance":9261,"id":229276,"goal":"method BinarySearch_9261(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_9262","instance":9262,"id":229277,"goal":"method InsertSort_9262(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_9263","instance":9263,"id":229278,"goal":"method MergeSort_9263(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_9264","instance":9264,"id":229279,"goal":"method ArrayCopy_9264(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_9265","instance":9265,"id":229280,"goal":"function ListReverse_9265(s: seq): seq\n ensures |ListReverse_9265(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_9265(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_9266","instance":9266,"id":229281,"goal":"function Factorial_9266(n: nat): nat\n ensures Factorial_9266(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_9266(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_9267","instance":9267,"id":229282,"goal":"function Fib_9267(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_9267(n-1) + Fib_9267(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_9268","instance":9268,"id":229283,"goal":"function Gcd_9268(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_9268(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_9269","instance":9269,"id":229284,"goal":"function Power_9269(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_9269(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_9270","instance":9270,"id":229285,"goal":"function Sum_9270(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_9270(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_9271","instance":9271,"id":229286,"goal":"method BinarySearch_9271(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_9272","instance":9272,"id":229287,"goal":"method InsertSort_9272(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_9273","instance":9273,"id":229288,"goal":"method MergeSort_9273(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_9274","instance":9274,"id":229289,"goal":"method ArrayCopy_9274(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_9275","instance":9275,"id":229290,"goal":"function ListReverse_9275(s: seq): seq\n ensures |ListReverse_9275(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_9275(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_9276","instance":9276,"id":229291,"goal":"function Factorial_9276(n: nat): nat\n ensures Factorial_9276(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_9276(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_9277","instance":9277,"id":229292,"goal":"function Fib_9277(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_9277(n-1) + Fib_9277(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_9278","instance":9278,"id":229293,"goal":"function Gcd_9278(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_9278(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_9279","instance":9279,"id":229294,"goal":"function Power_9279(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_9279(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_9280","instance":9280,"id":229295,"goal":"function Sum_9280(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_9280(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_9281","instance":9281,"id":229296,"goal":"method BinarySearch_9281(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_9282","instance":9282,"id":229297,"goal":"method InsertSort_9282(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_9283","instance":9283,"id":229298,"goal":"method MergeSort_9283(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_9284","instance":9284,"id":229299,"goal":"method ArrayCopy_9284(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_9285","instance":9285,"id":229300,"goal":"function ListReverse_9285(s: seq): seq\n ensures |ListReverse_9285(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_9285(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_9286","instance":9286,"id":229301,"goal":"function Factorial_9286(n: nat): nat\n ensures Factorial_9286(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_9286(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_9287","instance":9287,"id":229302,"goal":"function Fib_9287(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_9287(n-1) + Fib_9287(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_9288","instance":9288,"id":229303,"goal":"function Gcd_9288(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_9288(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_9289","instance":9289,"id":229304,"goal":"function Power_9289(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_9289(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_9290","instance":9290,"id":229305,"goal":"function Sum_9290(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_9290(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_9291","instance":9291,"id":229306,"goal":"method BinarySearch_9291(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_9292","instance":9292,"id":229307,"goal":"method InsertSort_9292(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_9293","instance":9293,"id":229308,"goal":"method MergeSort_9293(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_9294","instance":9294,"id":229309,"goal":"method ArrayCopy_9294(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_9295","instance":9295,"id":229310,"goal":"function ListReverse_9295(s: seq): seq\n ensures |ListReverse_9295(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_9295(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_9296","instance":9296,"id":229311,"goal":"function Factorial_9296(n: nat): nat\n ensures Factorial_9296(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_9296(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_9297","instance":9297,"id":229312,"goal":"function Fib_9297(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_9297(n-1) + Fib_9297(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_9298","instance":9298,"id":229313,"goal":"function Gcd_9298(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_9298(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_9299","instance":9299,"id":229314,"goal":"function Power_9299(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_9299(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_9300","instance":9300,"id":229315,"goal":"function Sum_9300(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_9300(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_9301","instance":9301,"id":229316,"goal":"method BinarySearch_9301(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_9302","instance":9302,"id":229317,"goal":"method InsertSort_9302(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_9303","instance":9303,"id":229318,"goal":"method MergeSort_9303(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_9304","instance":9304,"id":229319,"goal":"method ArrayCopy_9304(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_9305","instance":9305,"id":229320,"goal":"function ListReverse_9305(s: seq): seq\n ensures |ListReverse_9305(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_9305(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_9306","instance":9306,"id":229321,"goal":"function Factorial_9306(n: nat): nat\n ensures Factorial_9306(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_9306(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_9307","instance":9307,"id":229322,"goal":"function Fib_9307(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_9307(n-1) + Fib_9307(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_9308","instance":9308,"id":229323,"goal":"function Gcd_9308(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_9308(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_9309","instance":9309,"id":229324,"goal":"function Power_9309(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_9309(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_9310","instance":9310,"id":229325,"goal":"function Sum_9310(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_9310(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_9311","instance":9311,"id":229326,"goal":"method BinarySearch_9311(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_9312","instance":9312,"id":229327,"goal":"method InsertSort_9312(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_9313","instance":9313,"id":229328,"goal":"method MergeSort_9313(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_9314","instance":9314,"id":229329,"goal":"method ArrayCopy_9314(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_9315","instance":9315,"id":229330,"goal":"function ListReverse_9315(s: seq): seq\n ensures |ListReverse_9315(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_9315(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_9316","instance":9316,"id":229331,"goal":"function Factorial_9316(n: nat): nat\n ensures Factorial_9316(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_9316(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_9317","instance":9317,"id":229332,"goal":"function Fib_9317(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_9317(n-1) + Fib_9317(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_9318","instance":9318,"id":229333,"goal":"function Gcd_9318(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_9318(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_9319","instance":9319,"id":229334,"goal":"function Power_9319(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_9319(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_9320","instance":9320,"id":229335,"goal":"function Sum_9320(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_9320(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_9321","instance":9321,"id":229336,"goal":"method BinarySearch_9321(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_9322","instance":9322,"id":229337,"goal":"method InsertSort_9322(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_9323","instance":9323,"id":229338,"goal":"method MergeSort_9323(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_9324","instance":9324,"id":229339,"goal":"method ArrayCopy_9324(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_9325","instance":9325,"id":229340,"goal":"function ListReverse_9325(s: seq): seq\n ensures |ListReverse_9325(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_9325(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_9326","instance":9326,"id":229341,"goal":"function Factorial_9326(n: nat): nat\n ensures Factorial_9326(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_9326(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_9327","instance":9327,"id":229342,"goal":"function Fib_9327(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_9327(n-1) + Fib_9327(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_9328","instance":9328,"id":229343,"goal":"function Gcd_9328(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_9328(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_9329","instance":9329,"id":229344,"goal":"function Power_9329(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_9329(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_9330","instance":9330,"id":229345,"goal":"function Sum_9330(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_9330(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_9331","instance":9331,"id":229346,"goal":"method BinarySearch_9331(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_9332","instance":9332,"id":229347,"goal":"method InsertSort_9332(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_9333","instance":9333,"id":229348,"goal":"method MergeSort_9333(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_9334","instance":9334,"id":229349,"goal":"method ArrayCopy_9334(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_9335","instance":9335,"id":229350,"goal":"function ListReverse_9335(s: seq): seq\n ensures |ListReverse_9335(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_9335(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_9336","instance":9336,"id":229351,"goal":"function Factorial_9336(n: nat): nat\n ensures Factorial_9336(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_9336(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_9337","instance":9337,"id":229352,"goal":"function Fib_9337(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_9337(n-1) + Fib_9337(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_9338","instance":9338,"id":229353,"goal":"function Gcd_9338(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_9338(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_9339","instance":9339,"id":229354,"goal":"function Power_9339(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_9339(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_9340","instance":9340,"id":229355,"goal":"function Sum_9340(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_9340(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_9341","instance":9341,"id":229356,"goal":"method BinarySearch_9341(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_9342","instance":9342,"id":229357,"goal":"method InsertSort_9342(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_9343","instance":9343,"id":229358,"goal":"method MergeSort_9343(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_9344","instance":9344,"id":229359,"goal":"method ArrayCopy_9344(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_9345","instance":9345,"id":229360,"goal":"function ListReverse_9345(s: seq): seq\n ensures |ListReverse_9345(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_9345(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_9346","instance":9346,"id":229361,"goal":"function Factorial_9346(n: nat): nat\n ensures Factorial_9346(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_9346(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_9347","instance":9347,"id":229362,"goal":"function Fib_9347(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_9347(n-1) + Fib_9347(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_9348","instance":9348,"id":229363,"goal":"function Gcd_9348(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_9348(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_9349","instance":9349,"id":229364,"goal":"function Power_9349(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_9349(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_9350","instance":9350,"id":229365,"goal":"function Sum_9350(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_9350(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_9351","instance":9351,"id":229366,"goal":"method BinarySearch_9351(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_9352","instance":9352,"id":229367,"goal":"method InsertSort_9352(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_9353","instance":9353,"id":229368,"goal":"method MergeSort_9353(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_9354","instance":9354,"id":229369,"goal":"method ArrayCopy_9354(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_9355","instance":9355,"id":229370,"goal":"function ListReverse_9355(s: seq): seq\n ensures |ListReverse_9355(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_9355(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_9356","instance":9356,"id":229371,"goal":"function Factorial_9356(n: nat): nat\n ensures Factorial_9356(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_9356(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_9357","instance":9357,"id":229372,"goal":"function Fib_9357(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_9357(n-1) + Fib_9357(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_9358","instance":9358,"id":229373,"goal":"function Gcd_9358(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_9358(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_9359","instance":9359,"id":229374,"goal":"function Power_9359(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_9359(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_9360","instance":9360,"id":229375,"goal":"function Sum_9360(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_9360(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_9361","instance":9361,"id":229376,"goal":"method BinarySearch_9361(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_9362","instance":9362,"id":229377,"goal":"method InsertSort_9362(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_9363","instance":9363,"id":229378,"goal":"method MergeSort_9363(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_9364","instance":9364,"id":229379,"goal":"method ArrayCopy_9364(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_9365","instance":9365,"id":229380,"goal":"function ListReverse_9365(s: seq): seq\n ensures |ListReverse_9365(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_9365(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_9366","instance":9366,"id":229381,"goal":"function Factorial_9366(n: nat): nat\n ensures Factorial_9366(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_9366(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_9367","instance":9367,"id":229382,"goal":"function Fib_9367(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_9367(n-1) + Fib_9367(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_9368","instance":9368,"id":229383,"goal":"function Gcd_9368(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_9368(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_9369","instance":9369,"id":229384,"goal":"function Power_9369(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_9369(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_9370","instance":9370,"id":229385,"goal":"function Sum_9370(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_9370(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_9371","instance":9371,"id":229386,"goal":"method BinarySearch_9371(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_9372","instance":9372,"id":229387,"goal":"method InsertSort_9372(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_9373","instance":9373,"id":229388,"goal":"method MergeSort_9373(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_9374","instance":9374,"id":229389,"goal":"method ArrayCopy_9374(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_9375","instance":9375,"id":229390,"goal":"function ListReverse_9375(s: seq): seq\n ensures |ListReverse_9375(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_9375(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_9376","instance":9376,"id":229391,"goal":"function Factorial_9376(n: nat): nat\n ensures Factorial_9376(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_9376(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_9377","instance":9377,"id":229392,"goal":"function Fib_9377(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_9377(n-1) + Fib_9377(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_9378","instance":9378,"id":229393,"goal":"function Gcd_9378(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_9378(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_9379","instance":9379,"id":229394,"goal":"function Power_9379(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_9379(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_9380","instance":9380,"id":229395,"goal":"function Sum_9380(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_9380(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_9381","instance":9381,"id":229396,"goal":"method BinarySearch_9381(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_9382","instance":9382,"id":229397,"goal":"method InsertSort_9382(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_9383","instance":9383,"id":229398,"goal":"method MergeSort_9383(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_9384","instance":9384,"id":229399,"goal":"method ArrayCopy_9384(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_9385","instance":9385,"id":229400,"goal":"function ListReverse_9385(s: seq): seq\n ensures |ListReverse_9385(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_9385(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_9386","instance":9386,"id":229401,"goal":"function Factorial_9386(n: nat): nat\n ensures Factorial_9386(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_9386(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_9387","instance":9387,"id":229402,"goal":"function Fib_9387(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_9387(n-1) + Fib_9387(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_9388","instance":9388,"id":229403,"goal":"function Gcd_9388(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_9388(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_9389","instance":9389,"id":229404,"goal":"function Power_9389(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_9389(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_9390","instance":9390,"id":229405,"goal":"function Sum_9390(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_9390(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_9391","instance":9391,"id":229406,"goal":"method BinarySearch_9391(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_9392","instance":9392,"id":229407,"goal":"method InsertSort_9392(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_9393","instance":9393,"id":229408,"goal":"method MergeSort_9393(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_9394","instance":9394,"id":229409,"goal":"method ArrayCopy_9394(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_9395","instance":9395,"id":229410,"goal":"function ListReverse_9395(s: seq): seq\n ensures |ListReverse_9395(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_9395(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_9396","instance":9396,"id":229411,"goal":"function Factorial_9396(n: nat): nat\n ensures Factorial_9396(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_9396(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_9397","instance":9397,"id":229412,"goal":"function Fib_9397(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_9397(n-1) + Fib_9397(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_9398","instance":9398,"id":229413,"goal":"function Gcd_9398(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_9398(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_9399","instance":9399,"id":229414,"goal":"function Power_9399(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_9399(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_9400","instance":9400,"id":229415,"goal":"function Sum_9400(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_9400(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_9401","instance":9401,"id":229416,"goal":"method BinarySearch_9401(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_9402","instance":9402,"id":229417,"goal":"method InsertSort_9402(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_9403","instance":9403,"id":229418,"goal":"method MergeSort_9403(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_9404","instance":9404,"id":229419,"goal":"method ArrayCopy_9404(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_9405","instance":9405,"id":229420,"goal":"function ListReverse_9405(s: seq): seq\n ensures |ListReverse_9405(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_9405(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_9406","instance":9406,"id":229421,"goal":"function Factorial_9406(n: nat): nat\n ensures Factorial_9406(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_9406(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_9407","instance":9407,"id":229422,"goal":"function Fib_9407(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_9407(n-1) + Fib_9407(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_9408","instance":9408,"id":229423,"goal":"function Gcd_9408(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_9408(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_9409","instance":9409,"id":229424,"goal":"function Power_9409(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_9409(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_9410","instance":9410,"id":229425,"goal":"function Sum_9410(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_9410(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_9411","instance":9411,"id":229426,"goal":"method BinarySearch_9411(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_9412","instance":9412,"id":229427,"goal":"method InsertSort_9412(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_9413","instance":9413,"id":229428,"goal":"method MergeSort_9413(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_9414","instance":9414,"id":229429,"goal":"method ArrayCopy_9414(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_9415","instance":9415,"id":229430,"goal":"function ListReverse_9415(s: seq): seq\n ensures |ListReverse_9415(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_9415(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_9416","instance":9416,"id":229431,"goal":"function Factorial_9416(n: nat): nat\n ensures Factorial_9416(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_9416(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_9417","instance":9417,"id":229432,"goal":"function Fib_9417(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_9417(n-1) + Fib_9417(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_9418","instance":9418,"id":229433,"goal":"function Gcd_9418(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_9418(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_9419","instance":9419,"id":229434,"goal":"function Power_9419(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_9419(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_9420","instance":9420,"id":229435,"goal":"function Sum_9420(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_9420(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_9421","instance":9421,"id":229436,"goal":"method BinarySearch_9421(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_9422","instance":9422,"id":229437,"goal":"method InsertSort_9422(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_9423","instance":9423,"id":229438,"goal":"method MergeSort_9423(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_9424","instance":9424,"id":229439,"goal":"method ArrayCopy_9424(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_9425","instance":9425,"id":229440,"goal":"function ListReverse_9425(s: seq): seq\n ensures |ListReverse_9425(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_9425(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_9426","instance":9426,"id":229441,"goal":"function Factorial_9426(n: nat): nat\n ensures Factorial_9426(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_9426(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_9427","instance":9427,"id":229442,"goal":"function Fib_9427(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_9427(n-1) + Fib_9427(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_9428","instance":9428,"id":229443,"goal":"function Gcd_9428(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_9428(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_9429","instance":9429,"id":229444,"goal":"function Power_9429(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_9429(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_9430","instance":9430,"id":229445,"goal":"function Sum_9430(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_9430(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_9431","instance":9431,"id":229446,"goal":"method BinarySearch_9431(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_9432","instance":9432,"id":229447,"goal":"method InsertSort_9432(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_9433","instance":9433,"id":229448,"goal":"method MergeSort_9433(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_9434","instance":9434,"id":229449,"goal":"method ArrayCopy_9434(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_9435","instance":9435,"id":229450,"goal":"function ListReverse_9435(s: seq): seq\n ensures |ListReverse_9435(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_9435(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_9436","instance":9436,"id":229451,"goal":"function Factorial_9436(n: nat): nat\n ensures Factorial_9436(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_9436(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_9437","instance":9437,"id":229452,"goal":"function Fib_9437(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_9437(n-1) + Fib_9437(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_9438","instance":9438,"id":229453,"goal":"function Gcd_9438(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_9438(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_9439","instance":9439,"id":229454,"goal":"function Power_9439(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_9439(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_9440","instance":9440,"id":229455,"goal":"function Sum_9440(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_9440(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_9441","instance":9441,"id":229456,"goal":"method BinarySearch_9441(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_9442","instance":9442,"id":229457,"goal":"method InsertSort_9442(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_9443","instance":9443,"id":229458,"goal":"method MergeSort_9443(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_9444","instance":9444,"id":229459,"goal":"method ArrayCopy_9444(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_9445","instance":9445,"id":229460,"goal":"function ListReverse_9445(s: seq): seq\n ensures |ListReverse_9445(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_9445(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_9446","instance":9446,"id":229461,"goal":"function Factorial_9446(n: nat): nat\n ensures Factorial_9446(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_9446(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_9447","instance":9447,"id":229462,"goal":"function Fib_9447(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_9447(n-1) + Fib_9447(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_9448","instance":9448,"id":229463,"goal":"function Gcd_9448(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_9448(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_9449","instance":9449,"id":229464,"goal":"function Power_9449(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_9449(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_9450","instance":9450,"id":229465,"goal":"function Sum_9450(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_9450(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_9451","instance":9451,"id":229466,"goal":"method BinarySearch_9451(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_9452","instance":9452,"id":229467,"goal":"method InsertSort_9452(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_9453","instance":9453,"id":229468,"goal":"method MergeSort_9453(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_9454","instance":9454,"id":229469,"goal":"method ArrayCopy_9454(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_9455","instance":9455,"id":229470,"goal":"function ListReverse_9455(s: seq): seq\n ensures |ListReverse_9455(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_9455(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_9456","instance":9456,"id":229471,"goal":"function Factorial_9456(n: nat): nat\n ensures Factorial_9456(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_9456(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_9457","instance":9457,"id":229472,"goal":"function Fib_9457(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_9457(n-1) + Fib_9457(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_9458","instance":9458,"id":229473,"goal":"function Gcd_9458(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_9458(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_9459","instance":9459,"id":229474,"goal":"function Power_9459(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_9459(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_9460","instance":9460,"id":229475,"goal":"function Sum_9460(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_9460(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_9461","instance":9461,"id":229476,"goal":"method BinarySearch_9461(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_9462","instance":9462,"id":229477,"goal":"method InsertSort_9462(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_9463","instance":9463,"id":229478,"goal":"method MergeSort_9463(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_9464","instance":9464,"id":229479,"goal":"method ArrayCopy_9464(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_9465","instance":9465,"id":229480,"goal":"function ListReverse_9465(s: seq): seq\n ensures |ListReverse_9465(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_9465(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_9466","instance":9466,"id":229481,"goal":"function Factorial_9466(n: nat): nat\n ensures Factorial_9466(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_9466(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_9467","instance":9467,"id":229482,"goal":"function Fib_9467(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_9467(n-1) + Fib_9467(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_9468","instance":9468,"id":229483,"goal":"function Gcd_9468(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_9468(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_9469","instance":9469,"id":229484,"goal":"function Power_9469(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_9469(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_9470","instance":9470,"id":229485,"goal":"function Sum_9470(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_9470(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_9471","instance":9471,"id":229486,"goal":"method BinarySearch_9471(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_9472","instance":9472,"id":229487,"goal":"method InsertSort_9472(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_9473","instance":9473,"id":229488,"goal":"method MergeSort_9473(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_9474","instance":9474,"id":229489,"goal":"method ArrayCopy_9474(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_9475","instance":9475,"id":229490,"goal":"function ListReverse_9475(s: seq): seq\n ensures |ListReverse_9475(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_9475(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_9476","instance":9476,"id":229491,"goal":"function Factorial_9476(n: nat): nat\n ensures Factorial_9476(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_9476(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_9477","instance":9477,"id":229492,"goal":"function Fib_9477(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_9477(n-1) + Fib_9477(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_9478","instance":9478,"id":229493,"goal":"function Gcd_9478(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_9478(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_9479","instance":9479,"id":229494,"goal":"function Power_9479(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_9479(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_9480","instance":9480,"id":229495,"goal":"function Sum_9480(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_9480(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_9481","instance":9481,"id":229496,"goal":"method BinarySearch_9481(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_9482","instance":9482,"id":229497,"goal":"method InsertSort_9482(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_9483","instance":9483,"id":229498,"goal":"method MergeSort_9483(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_9484","instance":9484,"id":229499,"goal":"method ArrayCopy_9484(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_9485","instance":9485,"id":229500,"goal":"function ListReverse_9485(s: seq): seq\n ensures |ListReverse_9485(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_9485(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_9486","instance":9486,"id":229501,"goal":"function Factorial_9486(n: nat): nat\n ensures Factorial_9486(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_9486(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_9487","instance":9487,"id":229502,"goal":"function Fib_9487(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_9487(n-1) + Fib_9487(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_9488","instance":9488,"id":229503,"goal":"function Gcd_9488(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_9488(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_9489","instance":9489,"id":229504,"goal":"function Power_9489(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_9489(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_9490","instance":9490,"id":229505,"goal":"function Sum_9490(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_9490(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_9491","instance":9491,"id":229506,"goal":"method BinarySearch_9491(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_9492","instance":9492,"id":229507,"goal":"method InsertSort_9492(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_9493","instance":9493,"id":229508,"goal":"method MergeSort_9493(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_9494","instance":9494,"id":229509,"goal":"method ArrayCopy_9494(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_9495","instance":9495,"id":229510,"goal":"function ListReverse_9495(s: seq): seq\n ensures |ListReverse_9495(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_9495(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_9496","instance":9496,"id":229511,"goal":"function Factorial_9496(n: nat): nat\n ensures Factorial_9496(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_9496(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_9497","instance":9497,"id":229512,"goal":"function Fib_9497(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_9497(n-1) + Fib_9497(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_9498","instance":9498,"id":229513,"goal":"function Gcd_9498(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_9498(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_9499","instance":9499,"id":229514,"goal":"function Power_9499(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_9499(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_9500","instance":9500,"id":229515,"goal":"function Sum_9500(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_9500(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_9501","instance":9501,"id":229516,"goal":"method BinarySearch_9501(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_9502","instance":9502,"id":229517,"goal":"method InsertSort_9502(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_9503","instance":9503,"id":229518,"goal":"method MergeSort_9503(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_9504","instance":9504,"id":229519,"goal":"method ArrayCopy_9504(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_9505","instance":9505,"id":229520,"goal":"function ListReverse_9505(s: seq): seq\n ensures |ListReverse_9505(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_9505(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_9506","instance":9506,"id":229521,"goal":"function Factorial_9506(n: nat): nat\n ensures Factorial_9506(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_9506(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_9507","instance":9507,"id":229522,"goal":"function Fib_9507(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_9507(n-1) + Fib_9507(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_9508","instance":9508,"id":229523,"goal":"function Gcd_9508(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_9508(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_9509","instance":9509,"id":229524,"goal":"function Power_9509(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_9509(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_9510","instance":9510,"id":229525,"goal":"function Sum_9510(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_9510(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_9511","instance":9511,"id":229526,"goal":"method BinarySearch_9511(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_9512","instance":9512,"id":229527,"goal":"method InsertSort_9512(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_9513","instance":9513,"id":229528,"goal":"method MergeSort_9513(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_9514","instance":9514,"id":229529,"goal":"method ArrayCopy_9514(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_9515","instance":9515,"id":229530,"goal":"function ListReverse_9515(s: seq): seq\n ensures |ListReverse_9515(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_9515(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_9516","instance":9516,"id":229531,"goal":"function Factorial_9516(n: nat): nat\n ensures Factorial_9516(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_9516(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_9517","instance":9517,"id":229532,"goal":"function Fib_9517(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_9517(n-1) + Fib_9517(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_9518","instance":9518,"id":229533,"goal":"function Gcd_9518(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_9518(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_9519","instance":9519,"id":229534,"goal":"function Power_9519(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_9519(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_9520","instance":9520,"id":229535,"goal":"function Sum_9520(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_9520(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_9521","instance":9521,"id":229536,"goal":"method BinarySearch_9521(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_9522","instance":9522,"id":229537,"goal":"method InsertSort_9522(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_9523","instance":9523,"id":229538,"goal":"method MergeSort_9523(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_9524","instance":9524,"id":229539,"goal":"method ArrayCopy_9524(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_9525","instance":9525,"id":229540,"goal":"function ListReverse_9525(s: seq): seq\n ensures |ListReverse_9525(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_9525(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_9526","instance":9526,"id":229541,"goal":"function Factorial_9526(n: nat): nat\n ensures Factorial_9526(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_9526(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_9527","instance":9527,"id":229542,"goal":"function Fib_9527(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_9527(n-1) + Fib_9527(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_9528","instance":9528,"id":229543,"goal":"function Gcd_9528(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_9528(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_9529","instance":9529,"id":229544,"goal":"function Power_9529(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_9529(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_9530","instance":9530,"id":229545,"goal":"function Sum_9530(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_9530(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_9531","instance":9531,"id":229546,"goal":"method BinarySearch_9531(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_9532","instance":9532,"id":229547,"goal":"method InsertSort_9532(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_9533","instance":9533,"id":229548,"goal":"method MergeSort_9533(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_9534","instance":9534,"id":229549,"goal":"method ArrayCopy_9534(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_9535","instance":9535,"id":229550,"goal":"function ListReverse_9535(s: seq): seq\n ensures |ListReverse_9535(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_9535(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_9536","instance":9536,"id":229551,"goal":"function Factorial_9536(n: nat): nat\n ensures Factorial_9536(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_9536(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_9537","instance":9537,"id":229552,"goal":"function Fib_9537(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_9537(n-1) + Fib_9537(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_9538","instance":9538,"id":229553,"goal":"function Gcd_9538(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_9538(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_9539","instance":9539,"id":229554,"goal":"function Power_9539(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_9539(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_9540","instance":9540,"id":229555,"goal":"function Sum_9540(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_9540(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_9541","instance":9541,"id":229556,"goal":"method BinarySearch_9541(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_9542","instance":9542,"id":229557,"goal":"method InsertSort_9542(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_9543","instance":9543,"id":229558,"goal":"method MergeSort_9543(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_9544","instance":9544,"id":229559,"goal":"method ArrayCopy_9544(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_9545","instance":9545,"id":229560,"goal":"function ListReverse_9545(s: seq): seq\n ensures |ListReverse_9545(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_9545(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_9546","instance":9546,"id":229561,"goal":"function Factorial_9546(n: nat): nat\n ensures Factorial_9546(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_9546(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_9547","instance":9547,"id":229562,"goal":"function Fib_9547(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_9547(n-1) + Fib_9547(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_9548","instance":9548,"id":229563,"goal":"function Gcd_9548(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_9548(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_9549","instance":9549,"id":229564,"goal":"function Power_9549(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_9549(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_9550","instance":9550,"id":229565,"goal":"function Sum_9550(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_9550(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_9551","instance":9551,"id":229566,"goal":"method BinarySearch_9551(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_9552","instance":9552,"id":229567,"goal":"method InsertSort_9552(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_9553","instance":9553,"id":229568,"goal":"method MergeSort_9553(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_9554","instance":9554,"id":229569,"goal":"method ArrayCopy_9554(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_9555","instance":9555,"id":229570,"goal":"function ListReverse_9555(s: seq): seq\n ensures |ListReverse_9555(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_9555(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_9556","instance":9556,"id":229571,"goal":"function Factorial_9556(n: nat): nat\n ensures Factorial_9556(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_9556(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_9557","instance":9557,"id":229572,"goal":"function Fib_9557(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_9557(n-1) + Fib_9557(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_9558","instance":9558,"id":229573,"goal":"function Gcd_9558(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_9558(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_9559","instance":9559,"id":229574,"goal":"function Power_9559(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_9559(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_9560","instance":9560,"id":229575,"goal":"function Sum_9560(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_9560(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_9561","instance":9561,"id":229576,"goal":"method BinarySearch_9561(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_9562","instance":9562,"id":229577,"goal":"method InsertSort_9562(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_9563","instance":9563,"id":229578,"goal":"method MergeSort_9563(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_9564","instance":9564,"id":229579,"goal":"method ArrayCopy_9564(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_9565","instance":9565,"id":229580,"goal":"function ListReverse_9565(s: seq): seq\n ensures |ListReverse_9565(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_9565(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_9566","instance":9566,"id":229581,"goal":"function Factorial_9566(n: nat): nat\n ensures Factorial_9566(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_9566(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_9567","instance":9567,"id":229582,"goal":"function Fib_9567(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_9567(n-1) + Fib_9567(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_9568","instance":9568,"id":229583,"goal":"function Gcd_9568(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_9568(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_9569","instance":9569,"id":229584,"goal":"function Power_9569(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_9569(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_9570","instance":9570,"id":229585,"goal":"function Sum_9570(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_9570(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_9571","instance":9571,"id":229586,"goal":"method BinarySearch_9571(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_9572","instance":9572,"id":229587,"goal":"method InsertSort_9572(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_9573","instance":9573,"id":229588,"goal":"method MergeSort_9573(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_9574","instance":9574,"id":229589,"goal":"method ArrayCopy_9574(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_9575","instance":9575,"id":229590,"goal":"function ListReverse_9575(s: seq): seq\n ensures |ListReverse_9575(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_9575(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_9576","instance":9576,"id":229591,"goal":"function Factorial_9576(n: nat): nat\n ensures Factorial_9576(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_9576(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_9577","instance":9577,"id":229592,"goal":"function Fib_9577(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_9577(n-1) + Fib_9577(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_9578","instance":9578,"id":229593,"goal":"function Gcd_9578(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_9578(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_9579","instance":9579,"id":229594,"goal":"function Power_9579(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_9579(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_9580","instance":9580,"id":229595,"goal":"function Sum_9580(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_9580(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_9581","instance":9581,"id":229596,"goal":"method BinarySearch_9581(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_9582","instance":9582,"id":229597,"goal":"method InsertSort_9582(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_9583","instance":9583,"id":229598,"goal":"method MergeSort_9583(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_9584","instance":9584,"id":229599,"goal":"method ArrayCopy_9584(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_9585","instance":9585,"id":229600,"goal":"function ListReverse_9585(s: seq): seq\n ensures |ListReverse_9585(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_9585(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_9586","instance":9586,"id":229601,"goal":"function Factorial_9586(n: nat): nat\n ensures Factorial_9586(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_9586(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_9587","instance":9587,"id":229602,"goal":"function Fib_9587(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_9587(n-1) + Fib_9587(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_9588","instance":9588,"id":229603,"goal":"function Gcd_9588(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_9588(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_9589","instance":9589,"id":229604,"goal":"function Power_9589(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_9589(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_9590","instance":9590,"id":229605,"goal":"function Sum_9590(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_9590(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_9591","instance":9591,"id":229606,"goal":"method BinarySearch_9591(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_9592","instance":9592,"id":229607,"goal":"method InsertSort_9592(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_9593","instance":9593,"id":229608,"goal":"method MergeSort_9593(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_9594","instance":9594,"id":229609,"goal":"method ArrayCopy_9594(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_9595","instance":9595,"id":229610,"goal":"function ListReverse_9595(s: seq): seq\n ensures |ListReverse_9595(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_9595(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_9596","instance":9596,"id":229611,"goal":"function Factorial_9596(n: nat): nat\n ensures Factorial_9596(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_9596(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_9597","instance":9597,"id":229612,"goal":"function Fib_9597(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_9597(n-1) + Fib_9597(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_9598","instance":9598,"id":229613,"goal":"function Gcd_9598(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_9598(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_9599","instance":9599,"id":229614,"goal":"function Power_9599(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_9599(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_9600","instance":9600,"id":229615,"goal":"function Sum_9600(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_9600(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_9601","instance":9601,"id":229616,"goal":"method BinarySearch_9601(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_9602","instance":9602,"id":229617,"goal":"method InsertSort_9602(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_9603","instance":9603,"id":229618,"goal":"method MergeSort_9603(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_9604","instance":9604,"id":229619,"goal":"method ArrayCopy_9604(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_9605","instance":9605,"id":229620,"goal":"function ListReverse_9605(s: seq): seq\n ensures |ListReverse_9605(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_9605(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_9606","instance":9606,"id":229621,"goal":"function Factorial_9606(n: nat): nat\n ensures Factorial_9606(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_9606(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_9607","instance":9607,"id":229622,"goal":"function Fib_9607(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_9607(n-1) + Fib_9607(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_9608","instance":9608,"id":229623,"goal":"function Gcd_9608(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_9608(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_9609","instance":9609,"id":229624,"goal":"function Power_9609(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_9609(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_9610","instance":9610,"id":229625,"goal":"function Sum_9610(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_9610(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_9611","instance":9611,"id":229626,"goal":"method BinarySearch_9611(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_9612","instance":9612,"id":229627,"goal":"method InsertSort_9612(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_9613","instance":9613,"id":229628,"goal":"method MergeSort_9613(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_9614","instance":9614,"id":229629,"goal":"method ArrayCopy_9614(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_9615","instance":9615,"id":229630,"goal":"function ListReverse_9615(s: seq): seq\n ensures |ListReverse_9615(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_9615(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_9616","instance":9616,"id":229631,"goal":"function Factorial_9616(n: nat): nat\n ensures Factorial_9616(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_9616(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_9617","instance":9617,"id":229632,"goal":"function Fib_9617(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_9617(n-1) + Fib_9617(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_9618","instance":9618,"id":229633,"goal":"function Gcd_9618(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_9618(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_9619","instance":9619,"id":229634,"goal":"function Power_9619(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_9619(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_9620","instance":9620,"id":229635,"goal":"function Sum_9620(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_9620(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_9621","instance":9621,"id":229636,"goal":"method BinarySearch_9621(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_9622","instance":9622,"id":229637,"goal":"method InsertSort_9622(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_9623","instance":9623,"id":229638,"goal":"method MergeSort_9623(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_9624","instance":9624,"id":229639,"goal":"method ArrayCopy_9624(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_9625","instance":9625,"id":229640,"goal":"function ListReverse_9625(s: seq): seq\n ensures |ListReverse_9625(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_9625(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_9626","instance":9626,"id":229641,"goal":"function Factorial_9626(n: nat): nat\n ensures Factorial_9626(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_9626(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_9627","instance":9627,"id":229642,"goal":"function Fib_9627(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_9627(n-1) + Fib_9627(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_9628","instance":9628,"id":229643,"goal":"function Gcd_9628(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_9628(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_9629","instance":9629,"id":229644,"goal":"function Power_9629(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_9629(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_9630","instance":9630,"id":229645,"goal":"function Sum_9630(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_9630(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_9631","instance":9631,"id":229646,"goal":"method BinarySearch_9631(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_9632","instance":9632,"id":229647,"goal":"method InsertSort_9632(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_9633","instance":9633,"id":229648,"goal":"method MergeSort_9633(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_9634","instance":9634,"id":229649,"goal":"method ArrayCopy_9634(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_9635","instance":9635,"id":229650,"goal":"function ListReverse_9635(s: seq): seq\n ensures |ListReverse_9635(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_9635(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_9636","instance":9636,"id":229651,"goal":"function Factorial_9636(n: nat): nat\n ensures Factorial_9636(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_9636(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_9637","instance":9637,"id":229652,"goal":"function Fib_9637(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_9637(n-1) + Fib_9637(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_9638","instance":9638,"id":229653,"goal":"function Gcd_9638(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_9638(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_9639","instance":9639,"id":229654,"goal":"function Power_9639(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_9639(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_9640","instance":9640,"id":229655,"goal":"function Sum_9640(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_9640(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_9641","instance":9641,"id":229656,"goal":"method BinarySearch_9641(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_9642","instance":9642,"id":229657,"goal":"method InsertSort_9642(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_9643","instance":9643,"id":229658,"goal":"method MergeSort_9643(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_9644","instance":9644,"id":229659,"goal":"method ArrayCopy_9644(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_9645","instance":9645,"id":229660,"goal":"function ListReverse_9645(s: seq): seq\n ensures |ListReverse_9645(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_9645(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_9646","instance":9646,"id":229661,"goal":"function Factorial_9646(n: nat): nat\n ensures Factorial_9646(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_9646(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_9647","instance":9647,"id":229662,"goal":"function Fib_9647(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_9647(n-1) + Fib_9647(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_9648","instance":9648,"id":229663,"goal":"function Gcd_9648(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_9648(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_9649","instance":9649,"id":229664,"goal":"function Power_9649(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_9649(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_9650","instance":9650,"id":229665,"goal":"function Sum_9650(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_9650(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_9651","instance":9651,"id":229666,"goal":"method BinarySearch_9651(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_9652","instance":9652,"id":229667,"goal":"method InsertSort_9652(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_9653","instance":9653,"id":229668,"goal":"method MergeSort_9653(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_9654","instance":9654,"id":229669,"goal":"method ArrayCopy_9654(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_9655","instance":9655,"id":229670,"goal":"function ListReverse_9655(s: seq): seq\n ensures |ListReverse_9655(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_9655(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_9656","instance":9656,"id":229671,"goal":"function Factorial_9656(n: nat): nat\n ensures Factorial_9656(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_9656(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_9657","instance":9657,"id":229672,"goal":"function Fib_9657(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_9657(n-1) + Fib_9657(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_9658","instance":9658,"id":229673,"goal":"function Gcd_9658(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_9658(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_9659","instance":9659,"id":229674,"goal":"function Power_9659(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_9659(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_9660","instance":9660,"id":229675,"goal":"function Sum_9660(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_9660(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_9661","instance":9661,"id":229676,"goal":"method BinarySearch_9661(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_9662","instance":9662,"id":229677,"goal":"method InsertSort_9662(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_9663","instance":9663,"id":229678,"goal":"method MergeSort_9663(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_9664","instance":9664,"id":229679,"goal":"method ArrayCopy_9664(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_9665","instance":9665,"id":229680,"goal":"function ListReverse_9665(s: seq): seq\n ensures |ListReverse_9665(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_9665(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_9666","instance":9666,"id":229681,"goal":"function Factorial_9666(n: nat): nat\n ensures Factorial_9666(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_9666(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_9667","instance":9667,"id":229682,"goal":"function Fib_9667(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_9667(n-1) + Fib_9667(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_9668","instance":9668,"id":229683,"goal":"function Gcd_9668(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_9668(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_9669","instance":9669,"id":229684,"goal":"function Power_9669(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_9669(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_9670","instance":9670,"id":229685,"goal":"function Sum_9670(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_9670(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_9671","instance":9671,"id":229686,"goal":"method BinarySearch_9671(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_9672","instance":9672,"id":229687,"goal":"method InsertSort_9672(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_9673","instance":9673,"id":229688,"goal":"method MergeSort_9673(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_9674","instance":9674,"id":229689,"goal":"method ArrayCopy_9674(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_9675","instance":9675,"id":229690,"goal":"function ListReverse_9675(s: seq): seq\n ensures |ListReverse_9675(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_9675(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_9676","instance":9676,"id":229691,"goal":"function Factorial_9676(n: nat): nat\n ensures Factorial_9676(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_9676(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_9677","instance":9677,"id":229692,"goal":"function Fib_9677(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_9677(n-1) + Fib_9677(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_9678","instance":9678,"id":229693,"goal":"function Gcd_9678(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_9678(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_9679","instance":9679,"id":229694,"goal":"function Power_9679(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_9679(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_9680","instance":9680,"id":229695,"goal":"function Sum_9680(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_9680(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_9681","instance":9681,"id":229696,"goal":"method BinarySearch_9681(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_9682","instance":9682,"id":229697,"goal":"method InsertSort_9682(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_9683","instance":9683,"id":229698,"goal":"method MergeSort_9683(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_9684","instance":9684,"id":229699,"goal":"method ArrayCopy_9684(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_9685","instance":9685,"id":229700,"goal":"function ListReverse_9685(s: seq): seq\n ensures |ListReverse_9685(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_9685(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_9686","instance":9686,"id":229701,"goal":"function Factorial_9686(n: nat): nat\n ensures Factorial_9686(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_9686(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_9687","instance":9687,"id":229702,"goal":"function Fib_9687(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_9687(n-1) + Fib_9687(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_9688","instance":9688,"id":229703,"goal":"function Gcd_9688(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_9688(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_9689","instance":9689,"id":229704,"goal":"function Power_9689(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_9689(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_9690","instance":9690,"id":229705,"goal":"function Sum_9690(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_9690(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_9691","instance":9691,"id":229706,"goal":"method BinarySearch_9691(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_9692","instance":9692,"id":229707,"goal":"method InsertSort_9692(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_9693","instance":9693,"id":229708,"goal":"method MergeSort_9693(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_9694","instance":9694,"id":229709,"goal":"method ArrayCopy_9694(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_9695","instance":9695,"id":229710,"goal":"function ListReverse_9695(s: seq): seq\n ensures |ListReverse_9695(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_9695(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_9696","instance":9696,"id":229711,"goal":"function Factorial_9696(n: nat): nat\n ensures Factorial_9696(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_9696(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_9697","instance":9697,"id":229712,"goal":"function Fib_9697(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_9697(n-1) + Fib_9697(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_9698","instance":9698,"id":229713,"goal":"function Gcd_9698(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_9698(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_9699","instance":9699,"id":229714,"goal":"function Power_9699(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_9699(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_9700","instance":9700,"id":229715,"goal":"function Sum_9700(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_9700(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_9701","instance":9701,"id":229716,"goal":"method BinarySearch_9701(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_9702","instance":9702,"id":229717,"goal":"method InsertSort_9702(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_9703","instance":9703,"id":229718,"goal":"method MergeSort_9703(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_9704","instance":9704,"id":229719,"goal":"method ArrayCopy_9704(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_9705","instance":9705,"id":229720,"goal":"function ListReverse_9705(s: seq): seq\n ensures |ListReverse_9705(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_9705(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_9706","instance":9706,"id":229721,"goal":"function Factorial_9706(n: nat): nat\n ensures Factorial_9706(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_9706(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_9707","instance":9707,"id":229722,"goal":"function Fib_9707(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_9707(n-1) + Fib_9707(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_9708","instance":9708,"id":229723,"goal":"function Gcd_9708(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_9708(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_9709","instance":9709,"id":229724,"goal":"function Power_9709(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_9709(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_9710","instance":9710,"id":229725,"goal":"function Sum_9710(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_9710(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_9711","instance":9711,"id":229726,"goal":"method BinarySearch_9711(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_9712","instance":9712,"id":229727,"goal":"method InsertSort_9712(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_9713","instance":9713,"id":229728,"goal":"method MergeSort_9713(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_9714","instance":9714,"id":229729,"goal":"method ArrayCopy_9714(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_9715","instance":9715,"id":229730,"goal":"function ListReverse_9715(s: seq): seq\n ensures |ListReverse_9715(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_9715(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_9716","instance":9716,"id":229731,"goal":"function Factorial_9716(n: nat): nat\n ensures Factorial_9716(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_9716(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_9717","instance":9717,"id":229732,"goal":"function Fib_9717(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_9717(n-1) + Fib_9717(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_9718","instance":9718,"id":229733,"goal":"function Gcd_9718(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_9718(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_9719","instance":9719,"id":229734,"goal":"function Power_9719(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_9719(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_9720","instance":9720,"id":229735,"goal":"function Sum_9720(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_9720(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_9721","instance":9721,"id":229736,"goal":"method BinarySearch_9721(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_9722","instance":9722,"id":229737,"goal":"method InsertSort_9722(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_9723","instance":9723,"id":229738,"goal":"method MergeSort_9723(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_9724","instance":9724,"id":229739,"goal":"method ArrayCopy_9724(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_9725","instance":9725,"id":229740,"goal":"function ListReverse_9725(s: seq): seq\n ensures |ListReverse_9725(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_9725(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_9726","instance":9726,"id":229741,"goal":"function Factorial_9726(n: nat): nat\n ensures Factorial_9726(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_9726(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_9727","instance":9727,"id":229742,"goal":"function Fib_9727(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_9727(n-1) + Fib_9727(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_9728","instance":9728,"id":229743,"goal":"function Gcd_9728(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_9728(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_9729","instance":9729,"id":229744,"goal":"function Power_9729(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_9729(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_9730","instance":9730,"id":229745,"goal":"function Sum_9730(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_9730(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_9731","instance":9731,"id":229746,"goal":"method BinarySearch_9731(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_9732","instance":9732,"id":229747,"goal":"method InsertSort_9732(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_9733","instance":9733,"id":229748,"goal":"method MergeSort_9733(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_9734","instance":9734,"id":229749,"goal":"method ArrayCopy_9734(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_9735","instance":9735,"id":229750,"goal":"function ListReverse_9735(s: seq): seq\n ensures |ListReverse_9735(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_9735(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_9736","instance":9736,"id":229751,"goal":"function Factorial_9736(n: nat): nat\n ensures Factorial_9736(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_9736(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_9737","instance":9737,"id":229752,"goal":"function Fib_9737(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_9737(n-1) + Fib_9737(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_9738","instance":9738,"id":229753,"goal":"function Gcd_9738(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_9738(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_9739","instance":9739,"id":229754,"goal":"function Power_9739(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_9739(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_9740","instance":9740,"id":229755,"goal":"function Sum_9740(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_9740(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_9741","instance":9741,"id":229756,"goal":"method BinarySearch_9741(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_9742","instance":9742,"id":229757,"goal":"method InsertSort_9742(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_9743","instance":9743,"id":229758,"goal":"method MergeSort_9743(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_9744","instance":9744,"id":229759,"goal":"method ArrayCopy_9744(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_9745","instance":9745,"id":229760,"goal":"function ListReverse_9745(s: seq): seq\n ensures |ListReverse_9745(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_9745(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_9746","instance":9746,"id":229761,"goal":"function Factorial_9746(n: nat): nat\n ensures Factorial_9746(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_9746(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_9747","instance":9747,"id":229762,"goal":"function Fib_9747(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_9747(n-1) + Fib_9747(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_9748","instance":9748,"id":229763,"goal":"function Gcd_9748(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_9748(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_9749","instance":9749,"id":229764,"goal":"function Power_9749(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_9749(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_9750","instance":9750,"id":229765,"goal":"function Sum_9750(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_9750(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_9751","instance":9751,"id":229766,"goal":"method BinarySearch_9751(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_9752","instance":9752,"id":229767,"goal":"method InsertSort_9752(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_9753","instance":9753,"id":229768,"goal":"method MergeSort_9753(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_9754","instance":9754,"id":229769,"goal":"method ArrayCopy_9754(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_9755","instance":9755,"id":229770,"goal":"function ListReverse_9755(s: seq): seq\n ensures |ListReverse_9755(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_9755(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_9756","instance":9756,"id":229771,"goal":"function Factorial_9756(n: nat): nat\n ensures Factorial_9756(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_9756(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_9757","instance":9757,"id":229772,"goal":"function Fib_9757(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_9757(n-1) + Fib_9757(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_9758","instance":9758,"id":229773,"goal":"function Gcd_9758(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_9758(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_9759","instance":9759,"id":229774,"goal":"function Power_9759(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_9759(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_9760","instance":9760,"id":229775,"goal":"function Sum_9760(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_9760(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_9761","instance":9761,"id":229776,"goal":"method BinarySearch_9761(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_9762","instance":9762,"id":229777,"goal":"method InsertSort_9762(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_9763","instance":9763,"id":229778,"goal":"method MergeSort_9763(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_9764","instance":9764,"id":229779,"goal":"method ArrayCopy_9764(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_9765","instance":9765,"id":229780,"goal":"function ListReverse_9765(s: seq): seq\n ensures |ListReverse_9765(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_9765(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_9766","instance":9766,"id":229781,"goal":"function Factorial_9766(n: nat): nat\n ensures Factorial_9766(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_9766(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_9767","instance":9767,"id":229782,"goal":"function Fib_9767(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_9767(n-1) + Fib_9767(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_9768","instance":9768,"id":229783,"goal":"function Gcd_9768(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_9768(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_9769","instance":9769,"id":229784,"goal":"function Power_9769(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_9769(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_9770","instance":9770,"id":229785,"goal":"function Sum_9770(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_9770(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_9771","instance":9771,"id":229786,"goal":"method BinarySearch_9771(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_9772","instance":9772,"id":229787,"goal":"method InsertSort_9772(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_9773","instance":9773,"id":229788,"goal":"method MergeSort_9773(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_9774","instance":9774,"id":229789,"goal":"method ArrayCopy_9774(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_9775","instance":9775,"id":229790,"goal":"function ListReverse_9775(s: seq): seq\n ensures |ListReverse_9775(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_9775(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_9776","instance":9776,"id":229791,"goal":"function Factorial_9776(n: nat): nat\n ensures Factorial_9776(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_9776(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_9777","instance":9777,"id":229792,"goal":"function Fib_9777(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_9777(n-1) + Fib_9777(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_9778","instance":9778,"id":229793,"goal":"function Gcd_9778(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_9778(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_9779","instance":9779,"id":229794,"goal":"function Power_9779(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_9779(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_9780","instance":9780,"id":229795,"goal":"function Sum_9780(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_9780(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_9781","instance":9781,"id":229796,"goal":"method BinarySearch_9781(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_9782","instance":9782,"id":229797,"goal":"method InsertSort_9782(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_9783","instance":9783,"id":229798,"goal":"method MergeSort_9783(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_9784","instance":9784,"id":229799,"goal":"method ArrayCopy_9784(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_9785","instance":9785,"id":229800,"goal":"function ListReverse_9785(s: seq): seq\n ensures |ListReverse_9785(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_9785(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_9786","instance":9786,"id":229801,"goal":"function Factorial_9786(n: nat): nat\n ensures Factorial_9786(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_9786(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_9787","instance":9787,"id":229802,"goal":"function Fib_9787(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_9787(n-1) + Fib_9787(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_9788","instance":9788,"id":229803,"goal":"function Gcd_9788(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_9788(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_9789","instance":9789,"id":229804,"goal":"function Power_9789(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_9789(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_9790","instance":9790,"id":229805,"goal":"function Sum_9790(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_9790(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_9791","instance":9791,"id":229806,"goal":"method BinarySearch_9791(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_9792","instance":9792,"id":229807,"goal":"method InsertSort_9792(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_9793","instance":9793,"id":229808,"goal":"method MergeSort_9793(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_9794","instance":9794,"id":229809,"goal":"method ArrayCopy_9794(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_9795","instance":9795,"id":229810,"goal":"function ListReverse_9795(s: seq): seq\n ensures |ListReverse_9795(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_9795(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_9796","instance":9796,"id":229811,"goal":"function Factorial_9796(n: nat): nat\n ensures Factorial_9796(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_9796(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_9797","instance":9797,"id":229812,"goal":"function Fib_9797(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_9797(n-1) + Fib_9797(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_9798","instance":9798,"id":229813,"goal":"function Gcd_9798(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_9798(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_9799","instance":9799,"id":229814,"goal":"function Power_9799(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_9799(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_9800","instance":9800,"id":229815,"goal":"function Sum_9800(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_9800(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_9801","instance":9801,"id":229816,"goal":"method BinarySearch_9801(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_9802","instance":9802,"id":229817,"goal":"method InsertSort_9802(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_9803","instance":9803,"id":229818,"goal":"method MergeSort_9803(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_9804","instance":9804,"id":229819,"goal":"method ArrayCopy_9804(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_9805","instance":9805,"id":229820,"goal":"function ListReverse_9805(s: seq): seq\n ensures |ListReverse_9805(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_9805(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_9806","instance":9806,"id":229821,"goal":"function Factorial_9806(n: nat): nat\n ensures Factorial_9806(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_9806(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_9807","instance":9807,"id":229822,"goal":"function Fib_9807(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_9807(n-1) + Fib_9807(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_9808","instance":9808,"id":229823,"goal":"function Gcd_9808(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_9808(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_9809","instance":9809,"id":229824,"goal":"function Power_9809(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_9809(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_9810","instance":9810,"id":229825,"goal":"function Sum_9810(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_9810(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_9811","instance":9811,"id":229826,"goal":"method BinarySearch_9811(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_9812","instance":9812,"id":229827,"goal":"method InsertSort_9812(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_9813","instance":9813,"id":229828,"goal":"method MergeSort_9813(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_9814","instance":9814,"id":229829,"goal":"method ArrayCopy_9814(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_9815","instance":9815,"id":229830,"goal":"function ListReverse_9815(s: seq): seq\n ensures |ListReverse_9815(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_9815(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_9816","instance":9816,"id":229831,"goal":"function Factorial_9816(n: nat): nat\n ensures Factorial_9816(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_9816(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_9817","instance":9817,"id":229832,"goal":"function Fib_9817(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_9817(n-1) + Fib_9817(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_9818","instance":9818,"id":229833,"goal":"function Gcd_9818(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_9818(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_9819","instance":9819,"id":229834,"goal":"function Power_9819(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_9819(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_9820","instance":9820,"id":229835,"goal":"function Sum_9820(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_9820(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_9821","instance":9821,"id":229836,"goal":"method BinarySearch_9821(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_9822","instance":9822,"id":229837,"goal":"method InsertSort_9822(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_9823","instance":9823,"id":229838,"goal":"method MergeSort_9823(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_9824","instance":9824,"id":229839,"goal":"method ArrayCopy_9824(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_9825","instance":9825,"id":229840,"goal":"function ListReverse_9825(s: seq): seq\n ensures |ListReverse_9825(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_9825(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_9826","instance":9826,"id":229841,"goal":"function Factorial_9826(n: nat): nat\n ensures Factorial_9826(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_9826(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_9827","instance":9827,"id":229842,"goal":"function Fib_9827(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_9827(n-1) + Fib_9827(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_9828","instance":9828,"id":229843,"goal":"function Gcd_9828(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_9828(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_9829","instance":9829,"id":229844,"goal":"function Power_9829(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_9829(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_9830","instance":9830,"id":229845,"goal":"function Sum_9830(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_9830(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_9831","instance":9831,"id":229846,"goal":"method BinarySearch_9831(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_9832","instance":9832,"id":229847,"goal":"method InsertSort_9832(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_9833","instance":9833,"id":229848,"goal":"method MergeSort_9833(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_9834","instance":9834,"id":229849,"goal":"method ArrayCopy_9834(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_9835","instance":9835,"id":229850,"goal":"function ListReverse_9835(s: seq): seq\n ensures |ListReverse_9835(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_9835(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_9836","instance":9836,"id":229851,"goal":"function Factorial_9836(n: nat): nat\n ensures Factorial_9836(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_9836(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_9837","instance":9837,"id":229852,"goal":"function Fib_9837(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_9837(n-1) + Fib_9837(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_9838","instance":9838,"id":229853,"goal":"function Gcd_9838(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_9838(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_9839","instance":9839,"id":229854,"goal":"function Power_9839(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_9839(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_9840","instance":9840,"id":229855,"goal":"function Sum_9840(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_9840(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_9841","instance":9841,"id":229856,"goal":"method BinarySearch_9841(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_9842","instance":9842,"id":229857,"goal":"method InsertSort_9842(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_9843","instance":9843,"id":229858,"goal":"method MergeSort_9843(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_9844","instance":9844,"id":229859,"goal":"method ArrayCopy_9844(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_9845","instance":9845,"id":229860,"goal":"function ListReverse_9845(s: seq): seq\n ensures |ListReverse_9845(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_9845(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_9846","instance":9846,"id":229861,"goal":"function Factorial_9846(n: nat): nat\n ensures Factorial_9846(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_9846(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_9847","instance":9847,"id":229862,"goal":"function Fib_9847(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_9847(n-1) + Fib_9847(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_9848","instance":9848,"id":229863,"goal":"function Gcd_9848(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_9848(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_9849","instance":9849,"id":229864,"goal":"function Power_9849(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_9849(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_9850","instance":9850,"id":229865,"goal":"function Sum_9850(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_9850(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_9851","instance":9851,"id":229866,"goal":"method BinarySearch_9851(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_9852","instance":9852,"id":229867,"goal":"method InsertSort_9852(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_9853","instance":9853,"id":229868,"goal":"method MergeSort_9853(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_9854","instance":9854,"id":229869,"goal":"method ArrayCopy_9854(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_9855","instance":9855,"id":229870,"goal":"function ListReverse_9855(s: seq): seq\n ensures |ListReverse_9855(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_9855(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_9856","instance":9856,"id":229871,"goal":"function Factorial_9856(n: nat): nat\n ensures Factorial_9856(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_9856(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_9857","instance":9857,"id":229872,"goal":"function Fib_9857(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_9857(n-1) + Fib_9857(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_9858","instance":9858,"id":229873,"goal":"function Gcd_9858(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_9858(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_9859","instance":9859,"id":229874,"goal":"function Power_9859(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_9859(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_9860","instance":9860,"id":229875,"goal":"function Sum_9860(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_9860(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_9861","instance":9861,"id":229876,"goal":"method BinarySearch_9861(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_9862","instance":9862,"id":229877,"goal":"method InsertSort_9862(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_9863","instance":9863,"id":229878,"goal":"method MergeSort_9863(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_9864","instance":9864,"id":229879,"goal":"method ArrayCopy_9864(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_9865","instance":9865,"id":229880,"goal":"function ListReverse_9865(s: seq): seq\n ensures |ListReverse_9865(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_9865(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_9866","instance":9866,"id":229881,"goal":"function Factorial_9866(n: nat): nat\n ensures Factorial_9866(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_9866(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_9867","instance":9867,"id":229882,"goal":"function Fib_9867(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_9867(n-1) + Fib_9867(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_9868","instance":9868,"id":229883,"goal":"function Gcd_9868(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_9868(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_9869","instance":9869,"id":229884,"goal":"function Power_9869(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_9869(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_9870","instance":9870,"id":229885,"goal":"function Sum_9870(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_9870(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_9871","instance":9871,"id":229886,"goal":"method BinarySearch_9871(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_9872","instance":9872,"id":229887,"goal":"method InsertSort_9872(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_9873","instance":9873,"id":229888,"goal":"method MergeSort_9873(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_9874","instance":9874,"id":229889,"goal":"method ArrayCopy_9874(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_9875","instance":9875,"id":229890,"goal":"function ListReverse_9875(s: seq): seq\n ensures |ListReverse_9875(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_9875(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_9876","instance":9876,"id":229891,"goal":"function Factorial_9876(n: nat): nat\n ensures Factorial_9876(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_9876(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_9877","instance":9877,"id":229892,"goal":"function Fib_9877(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_9877(n-1) + Fib_9877(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_9878","instance":9878,"id":229893,"goal":"function Gcd_9878(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_9878(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_9879","instance":9879,"id":229894,"goal":"function Power_9879(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_9879(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_9880","instance":9880,"id":229895,"goal":"function Sum_9880(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_9880(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_9881","instance":9881,"id":229896,"goal":"method BinarySearch_9881(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_9882","instance":9882,"id":229897,"goal":"method InsertSort_9882(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_9883","instance":9883,"id":229898,"goal":"method MergeSort_9883(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_9884","instance":9884,"id":229899,"goal":"method ArrayCopy_9884(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_9885","instance":9885,"id":229900,"goal":"function ListReverse_9885(s: seq): seq\n ensures |ListReverse_9885(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_9885(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_9886","instance":9886,"id":229901,"goal":"function Factorial_9886(n: nat): nat\n ensures Factorial_9886(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_9886(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_9887","instance":9887,"id":229902,"goal":"function Fib_9887(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_9887(n-1) + Fib_9887(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_9888","instance":9888,"id":229903,"goal":"function Gcd_9888(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_9888(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_9889","instance":9889,"id":229904,"goal":"function Power_9889(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_9889(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_9890","instance":9890,"id":229905,"goal":"function Sum_9890(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_9890(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_9891","instance":9891,"id":229906,"goal":"method BinarySearch_9891(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_9892","instance":9892,"id":229907,"goal":"method InsertSort_9892(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_9893","instance":9893,"id":229908,"goal":"method MergeSort_9893(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_9894","instance":9894,"id":229909,"goal":"method ArrayCopy_9894(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_9895","instance":9895,"id":229910,"goal":"function ListReverse_9895(s: seq): seq\n ensures |ListReverse_9895(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_9895(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_9896","instance":9896,"id":229911,"goal":"function Factorial_9896(n: nat): nat\n ensures Factorial_9896(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_9896(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_9897","instance":9897,"id":229912,"goal":"function Fib_9897(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_9897(n-1) + Fib_9897(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_9898","instance":9898,"id":229913,"goal":"function Gcd_9898(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_9898(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_9899","instance":9899,"id":229914,"goal":"function Power_9899(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_9899(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_9900","instance":9900,"id":229915,"goal":"function Sum_9900(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_9900(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_9901","instance":9901,"id":229916,"goal":"method BinarySearch_9901(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_9902","instance":9902,"id":229917,"goal":"method InsertSort_9902(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_9903","instance":9903,"id":229918,"goal":"method MergeSort_9903(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_9904","instance":9904,"id":229919,"goal":"method ArrayCopy_9904(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_9905","instance":9905,"id":229920,"goal":"function ListReverse_9905(s: seq): seq\n ensures |ListReverse_9905(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_9905(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_9906","instance":9906,"id":229921,"goal":"function Factorial_9906(n: nat): nat\n ensures Factorial_9906(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_9906(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_9907","instance":9907,"id":229922,"goal":"function Fib_9907(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_9907(n-1) + Fib_9907(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_9908","instance":9908,"id":229923,"goal":"function Gcd_9908(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_9908(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_9909","instance":9909,"id":229924,"goal":"function Power_9909(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_9909(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_9910","instance":9910,"id":229925,"goal":"function Sum_9910(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_9910(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_9911","instance":9911,"id":229926,"goal":"method BinarySearch_9911(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_9912","instance":9912,"id":229927,"goal":"method InsertSort_9912(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_9913","instance":9913,"id":229928,"goal":"method MergeSort_9913(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_9914","instance":9914,"id":229929,"goal":"method ArrayCopy_9914(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_9915","instance":9915,"id":229930,"goal":"function ListReverse_9915(s: seq): seq\n ensures |ListReverse_9915(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_9915(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_9916","instance":9916,"id":229931,"goal":"function Factorial_9916(n: nat): nat\n ensures Factorial_9916(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_9916(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_9917","instance":9917,"id":229932,"goal":"function Fib_9917(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_9917(n-1) + Fib_9917(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_9918","instance":9918,"id":229933,"goal":"function Gcd_9918(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_9918(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_9919","instance":9919,"id":229934,"goal":"function Power_9919(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_9919(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_9920","instance":9920,"id":229935,"goal":"function Sum_9920(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_9920(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_9921","instance":9921,"id":229936,"goal":"method BinarySearch_9921(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_9922","instance":9922,"id":229937,"goal":"method InsertSort_9922(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_9923","instance":9923,"id":229938,"goal":"method MergeSort_9923(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_9924","instance":9924,"id":229939,"goal":"method ArrayCopy_9924(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_9925","instance":9925,"id":229940,"goal":"function ListReverse_9925(s: seq): seq\n ensures |ListReverse_9925(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_9925(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_9926","instance":9926,"id":229941,"goal":"function Factorial_9926(n: nat): nat\n ensures Factorial_9926(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_9926(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_9927","instance":9927,"id":229942,"goal":"function Fib_9927(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_9927(n-1) + Fib_9927(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_9928","instance":9928,"id":229943,"goal":"function Gcd_9928(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_9928(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_9929","instance":9929,"id":229944,"goal":"function Power_9929(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_9929(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_9930","instance":9930,"id":229945,"goal":"function Sum_9930(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_9930(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_9931","instance":9931,"id":229946,"goal":"method BinarySearch_9931(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_9932","instance":9932,"id":229947,"goal":"method InsertSort_9932(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_9933","instance":9933,"id":229948,"goal":"method MergeSort_9933(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_9934","instance":9934,"id":229949,"goal":"method ArrayCopy_9934(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_9935","instance":9935,"id":229950,"goal":"function ListReverse_9935(s: seq): seq\n ensures |ListReverse_9935(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_9935(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_9936","instance":9936,"id":229951,"goal":"function Factorial_9936(n: nat): nat\n ensures Factorial_9936(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_9936(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_9937","instance":9937,"id":229952,"goal":"function Fib_9937(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_9937(n-1) + Fib_9937(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_9938","instance":9938,"id":229953,"goal":"function Gcd_9938(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_9938(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_9939","instance":9939,"id":229954,"goal":"function Power_9939(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_9939(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_9940","instance":9940,"id":229955,"goal":"function Sum_9940(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_9940(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_9941","instance":9941,"id":229956,"goal":"method BinarySearch_9941(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_9942","instance":9942,"id":229957,"goal":"method InsertSort_9942(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_9943","instance":9943,"id":229958,"goal":"method MergeSort_9943(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_9944","instance":9944,"id":229959,"goal":"method ArrayCopy_9944(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_9945","instance":9945,"id":229960,"goal":"function ListReverse_9945(s: seq): seq\n ensures |ListReverse_9945(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_9945(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_9946","instance":9946,"id":229961,"goal":"function Factorial_9946(n: nat): nat\n ensures Factorial_9946(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_9946(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_9947","instance":9947,"id":229962,"goal":"function Fib_9947(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_9947(n-1) + Fib_9947(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_9948","instance":9948,"id":229963,"goal":"function Gcd_9948(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_9948(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_9949","instance":9949,"id":229964,"goal":"function Power_9949(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_9949(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_9950","instance":9950,"id":229965,"goal":"function Sum_9950(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_9950(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_9951","instance":9951,"id":229966,"goal":"method BinarySearch_9951(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_9952","instance":9952,"id":229967,"goal":"method InsertSort_9952(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_9953","instance":9953,"id":229968,"goal":"method MergeSort_9953(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_9954","instance":9954,"id":229969,"goal":"method ArrayCopy_9954(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_9955","instance":9955,"id":229970,"goal":"function ListReverse_9955(s: seq): seq\n ensures |ListReverse_9955(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_9955(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_9956","instance":9956,"id":229971,"goal":"function Factorial_9956(n: nat): nat\n ensures Factorial_9956(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_9956(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_9957","instance":9957,"id":229972,"goal":"function Fib_9957(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_9957(n-1) + Fib_9957(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_9958","instance":9958,"id":229973,"goal":"function Gcd_9958(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_9958(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_9959","instance":9959,"id":229974,"goal":"function Power_9959(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_9959(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_9960","instance":9960,"id":229975,"goal":"function Sum_9960(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_9960(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_9961","instance":9961,"id":229976,"goal":"method BinarySearch_9961(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_9962","instance":9962,"id":229977,"goal":"method InsertSort_9962(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_9963","instance":9963,"id":229978,"goal":"method MergeSort_9963(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_9964","instance":9964,"id":229979,"goal":"method ArrayCopy_9964(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_9965","instance":9965,"id":229980,"goal":"function ListReverse_9965(s: seq): seq\n ensures |ListReverse_9965(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_9965(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_9966","instance":9966,"id":229981,"goal":"function Factorial_9966(n: nat): nat\n ensures Factorial_9966(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_9966(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_9967","instance":9967,"id":229982,"goal":"function Fib_9967(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_9967(n-1) + Fib_9967(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_9968","instance":9968,"id":229983,"goal":"function Gcd_9968(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_9968(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_9969","instance":9969,"id":229984,"goal":"function Power_9969(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_9969(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_9970","instance":9970,"id":229985,"goal":"function Sum_9970(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_9970(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_9971","instance":9971,"id":229986,"goal":"method BinarySearch_9971(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_9972","instance":9972,"id":229987,"goal":"method InsertSort_9972(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_9973","instance":9973,"id":229988,"goal":"method MergeSort_9973(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_9974","instance":9974,"id":229989,"goal":"method ArrayCopy_9974(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_9975","instance":9975,"id":229990,"goal":"function ListReverse_9975(s: seq): seq\n ensures |ListReverse_9975(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_9975(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_9976","instance":9976,"id":229991,"goal":"function Factorial_9976(n: nat): nat\n ensures Factorial_9976(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_9976(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_9977","instance":9977,"id":229992,"goal":"function Fib_9977(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_9977(n-1) + Fib_9977(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_9978","instance":9978,"id":229993,"goal":"function Gcd_9978(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_9978(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_9979","instance":9979,"id":229994,"goal":"function Power_9979(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_9979(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_9980","instance":9980,"id":229995,"goal":"function Sum_9980(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_9980(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_9981","instance":9981,"id":229996,"goal":"method BinarySearch_9981(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_9982","instance":9982,"id":229997,"goal":"method InsertSort_9982(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_9983","instance":9983,"id":229998,"goal":"method MergeSort_9983(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_9984","instance":9984,"id":229999,"goal":"method ArrayCopy_9984(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_9985","instance":9985,"id":230000,"goal":"function ListReverse_9985(s: seq): seq\n ensures |ListReverse_9985(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_9985(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_9986","instance":9986,"id":230001,"goal":"function Factorial_9986(n: nat): nat\n ensures Factorial_9986(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_9986(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_9987","instance":9987,"id":230002,"goal":"function Fib_9987(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_9987(n-1) + Fib_9987(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_9988","instance":9988,"id":230003,"goal":"function Gcd_9988(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_9988(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_9989","instance":9989,"id":230004,"goal":"function Power_9989(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_9989(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_9990","instance":9990,"id":230005,"goal":"function Sum_9990(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_9990(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_9991","instance":9991,"id":230006,"goal":"method BinarySearch_9991(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_9992","instance":9992,"id":230007,"goal":"method InsertSort_9992(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_9993","instance":9993,"id":230008,"goal":"method MergeSort_9993(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_9994","instance":9994,"id":230009,"goal":"method ArrayCopy_9994(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_9995","instance":9995,"id":230010,"goal":"function ListReverse_9995(s: seq): seq\n ensures |ListReverse_9995(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_9995(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_9996","instance":9996,"id":230011,"goal":"function Factorial_9996(n: nat): nat\n ensures Factorial_9996(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_9996(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_9997","instance":9997,"id":230012,"goal":"function Fib_9997(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_9997(n-1) + Fib_9997(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_9998","instance":9998,"id":230013,"goal":"function Gcd_9998(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_9998(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_9999","instance":9999,"id":230014,"goal":"function Power_9999(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_9999(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_10000","instance":10000,"id":230015,"goal":"function Sum_10000(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_10000(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_10001","instance":10001,"id":230016,"goal":"method BinarySearch_10001(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_10002","instance":10002,"id":230017,"goal":"method InsertSort_10002(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_10003","instance":10003,"id":230018,"goal":"method MergeSort_10003(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_10004","instance":10004,"id":230019,"goal":"method ArrayCopy_10004(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_10005","instance":10005,"id":230020,"goal":"function ListReverse_10005(s: seq): seq\n ensures |ListReverse_10005(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_10005(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_10006","instance":10006,"id":230021,"goal":"function Factorial_10006(n: nat): nat\n ensures Factorial_10006(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_10006(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_10007","instance":10007,"id":230022,"goal":"function Fib_10007(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_10007(n-1) + Fib_10007(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_10008","instance":10008,"id":230023,"goal":"function Gcd_10008(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_10008(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_10009","instance":10009,"id":230024,"goal":"function Power_10009(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_10009(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_10010","instance":10010,"id":230025,"goal":"function Sum_10010(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_10010(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_10011","instance":10011,"id":230026,"goal":"method BinarySearch_10011(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_10012","instance":10012,"id":230027,"goal":"method InsertSort_10012(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_10013","instance":10013,"id":230028,"goal":"method MergeSort_10013(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_10014","instance":10014,"id":230029,"goal":"method ArrayCopy_10014(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_10015","instance":10015,"id":230030,"goal":"function ListReverse_10015(s: seq): seq\n ensures |ListReverse_10015(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_10015(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_10016","instance":10016,"id":230031,"goal":"function Factorial_10016(n: nat): nat\n ensures Factorial_10016(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_10016(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_10017","instance":10017,"id":230032,"goal":"function Fib_10017(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_10017(n-1) + Fib_10017(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_10018","instance":10018,"id":230033,"goal":"function Gcd_10018(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_10018(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_10019","instance":10019,"id":230034,"goal":"function Power_10019(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_10019(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_10020","instance":10020,"id":230035,"goal":"function Sum_10020(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_10020(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_10021","instance":10021,"id":230036,"goal":"method BinarySearch_10021(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_10022","instance":10022,"id":230037,"goal":"method InsertSort_10022(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_10023","instance":10023,"id":230038,"goal":"method MergeSort_10023(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_10024","instance":10024,"id":230039,"goal":"method ArrayCopy_10024(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_10025","instance":10025,"id":230040,"goal":"function ListReverse_10025(s: seq): seq\n ensures |ListReverse_10025(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_10025(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_10026","instance":10026,"id":230041,"goal":"function Factorial_10026(n: nat): nat\n ensures Factorial_10026(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_10026(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_10027","instance":10027,"id":230042,"goal":"function Fib_10027(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_10027(n-1) + Fib_10027(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_10028","instance":10028,"id":230043,"goal":"function Gcd_10028(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_10028(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_10029","instance":10029,"id":230044,"goal":"function Power_10029(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_10029(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_10030","instance":10030,"id":230045,"goal":"function Sum_10030(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_10030(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_10031","instance":10031,"id":230046,"goal":"method BinarySearch_10031(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_10032","instance":10032,"id":230047,"goal":"method InsertSort_10032(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_10033","instance":10033,"id":230048,"goal":"method MergeSort_10033(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_10034","instance":10034,"id":230049,"goal":"method ArrayCopy_10034(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_10035","instance":10035,"id":230050,"goal":"function ListReverse_10035(s: seq): seq\n ensures |ListReverse_10035(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_10035(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_10036","instance":10036,"id":230051,"goal":"function Factorial_10036(n: nat): nat\n ensures Factorial_10036(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_10036(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_10037","instance":10037,"id":230052,"goal":"function Fib_10037(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_10037(n-1) + Fib_10037(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_10038","instance":10038,"id":230053,"goal":"function Gcd_10038(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_10038(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_10039","instance":10039,"id":230054,"goal":"function Power_10039(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_10039(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_10040","instance":10040,"id":230055,"goal":"function Sum_10040(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_10040(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_10041","instance":10041,"id":230056,"goal":"method BinarySearch_10041(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_10042","instance":10042,"id":230057,"goal":"method InsertSort_10042(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_10043","instance":10043,"id":230058,"goal":"method MergeSort_10043(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_10044","instance":10044,"id":230059,"goal":"method ArrayCopy_10044(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_10045","instance":10045,"id":230060,"goal":"function ListReverse_10045(s: seq): seq\n ensures |ListReverse_10045(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_10045(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_10046","instance":10046,"id":230061,"goal":"function Factorial_10046(n: nat): nat\n ensures Factorial_10046(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_10046(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_10047","instance":10047,"id":230062,"goal":"function Fib_10047(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_10047(n-1) + Fib_10047(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_10048","instance":10048,"id":230063,"goal":"function Gcd_10048(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_10048(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_10049","instance":10049,"id":230064,"goal":"function Power_10049(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_10049(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_10050","instance":10050,"id":230065,"goal":"function Sum_10050(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_10050(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_10051","instance":10051,"id":230066,"goal":"method BinarySearch_10051(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_10052","instance":10052,"id":230067,"goal":"method InsertSort_10052(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_10053","instance":10053,"id":230068,"goal":"method MergeSort_10053(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_10054","instance":10054,"id":230069,"goal":"method ArrayCopy_10054(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_10055","instance":10055,"id":230070,"goal":"function ListReverse_10055(s: seq): seq\n ensures |ListReverse_10055(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_10055(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_10056","instance":10056,"id":230071,"goal":"function Factorial_10056(n: nat): nat\n ensures Factorial_10056(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_10056(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_10057","instance":10057,"id":230072,"goal":"function Fib_10057(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_10057(n-1) + Fib_10057(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_10058","instance":10058,"id":230073,"goal":"function Gcd_10058(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_10058(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_10059","instance":10059,"id":230074,"goal":"function Power_10059(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_10059(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_10060","instance":10060,"id":230075,"goal":"function Sum_10060(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_10060(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_10061","instance":10061,"id":230076,"goal":"method BinarySearch_10061(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_10062","instance":10062,"id":230077,"goal":"method InsertSort_10062(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_10063","instance":10063,"id":230078,"goal":"method MergeSort_10063(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_10064","instance":10064,"id":230079,"goal":"method ArrayCopy_10064(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_10065","instance":10065,"id":230080,"goal":"function ListReverse_10065(s: seq): seq\n ensures |ListReverse_10065(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_10065(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_10066","instance":10066,"id":230081,"goal":"function Factorial_10066(n: nat): nat\n ensures Factorial_10066(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_10066(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_10067","instance":10067,"id":230082,"goal":"function Fib_10067(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_10067(n-1) + Fib_10067(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_10068","instance":10068,"id":230083,"goal":"function Gcd_10068(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_10068(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_10069","instance":10069,"id":230084,"goal":"function Power_10069(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_10069(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_10070","instance":10070,"id":230085,"goal":"function Sum_10070(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_10070(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_10071","instance":10071,"id":230086,"goal":"method BinarySearch_10071(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_10072","instance":10072,"id":230087,"goal":"method InsertSort_10072(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_10073","instance":10073,"id":230088,"goal":"method MergeSort_10073(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_10074","instance":10074,"id":230089,"goal":"method ArrayCopy_10074(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_10075","instance":10075,"id":230090,"goal":"function ListReverse_10075(s: seq): seq\n ensures |ListReverse_10075(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_10075(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_10076","instance":10076,"id":230091,"goal":"function Factorial_10076(n: nat): nat\n ensures Factorial_10076(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_10076(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_10077","instance":10077,"id":230092,"goal":"function Fib_10077(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_10077(n-1) + Fib_10077(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_10078","instance":10078,"id":230093,"goal":"function Gcd_10078(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_10078(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_10079","instance":10079,"id":230094,"goal":"function Power_10079(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_10079(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_10080","instance":10080,"id":230095,"goal":"function Sum_10080(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_10080(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_10081","instance":10081,"id":230096,"goal":"method BinarySearch_10081(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_10082","instance":10082,"id":230097,"goal":"method InsertSort_10082(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_10083","instance":10083,"id":230098,"goal":"method MergeSort_10083(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_10084","instance":10084,"id":230099,"goal":"method ArrayCopy_10084(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_10085","instance":10085,"id":230100,"goal":"function ListReverse_10085(s: seq): seq\n ensures |ListReverse_10085(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_10085(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_10086","instance":10086,"id":230101,"goal":"function Factorial_10086(n: nat): nat\n ensures Factorial_10086(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_10086(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_10087","instance":10087,"id":230102,"goal":"function Fib_10087(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_10087(n-1) + Fib_10087(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_10088","instance":10088,"id":230103,"goal":"function Gcd_10088(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_10088(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_10089","instance":10089,"id":230104,"goal":"function Power_10089(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_10089(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_10090","instance":10090,"id":230105,"goal":"function Sum_10090(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_10090(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_10091","instance":10091,"id":230106,"goal":"method BinarySearch_10091(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_10092","instance":10092,"id":230107,"goal":"method InsertSort_10092(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_10093","instance":10093,"id":230108,"goal":"method MergeSort_10093(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_10094","instance":10094,"id":230109,"goal":"method ArrayCopy_10094(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_10095","instance":10095,"id":230110,"goal":"function ListReverse_10095(s: seq): seq\n ensures |ListReverse_10095(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_10095(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_10096","instance":10096,"id":230111,"goal":"function Factorial_10096(n: nat): nat\n ensures Factorial_10096(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_10096(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_10097","instance":10097,"id":230112,"goal":"function Fib_10097(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_10097(n-1) + Fib_10097(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_10098","instance":10098,"id":230113,"goal":"function Gcd_10098(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_10098(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_10099","instance":10099,"id":230114,"goal":"function Power_10099(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_10099(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_10100","instance":10100,"id":230115,"goal":"function Sum_10100(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_10100(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_10101","instance":10101,"id":230116,"goal":"method BinarySearch_10101(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_10102","instance":10102,"id":230117,"goal":"method InsertSort_10102(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_10103","instance":10103,"id":230118,"goal":"method MergeSort_10103(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_10104","instance":10104,"id":230119,"goal":"method ArrayCopy_10104(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_10105","instance":10105,"id":230120,"goal":"function ListReverse_10105(s: seq): seq\n ensures |ListReverse_10105(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_10105(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_10106","instance":10106,"id":230121,"goal":"function Factorial_10106(n: nat): nat\n ensures Factorial_10106(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_10106(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_10107","instance":10107,"id":230122,"goal":"function Fib_10107(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_10107(n-1) + Fib_10107(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_10108","instance":10108,"id":230123,"goal":"function Gcd_10108(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_10108(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_10109","instance":10109,"id":230124,"goal":"function Power_10109(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_10109(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_10110","instance":10110,"id":230125,"goal":"function Sum_10110(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_10110(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_10111","instance":10111,"id":230126,"goal":"method BinarySearch_10111(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_10112","instance":10112,"id":230127,"goal":"method InsertSort_10112(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_10113","instance":10113,"id":230128,"goal":"method MergeSort_10113(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_10114","instance":10114,"id":230129,"goal":"method ArrayCopy_10114(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_10115","instance":10115,"id":230130,"goal":"function ListReverse_10115(s: seq): seq\n ensures |ListReverse_10115(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_10115(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_10116","instance":10116,"id":230131,"goal":"function Factorial_10116(n: nat): nat\n ensures Factorial_10116(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_10116(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_10117","instance":10117,"id":230132,"goal":"function Fib_10117(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_10117(n-1) + Fib_10117(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_10118","instance":10118,"id":230133,"goal":"function Gcd_10118(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_10118(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_10119","instance":10119,"id":230134,"goal":"function Power_10119(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_10119(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_10120","instance":10120,"id":230135,"goal":"function Sum_10120(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_10120(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_10121","instance":10121,"id":230136,"goal":"method BinarySearch_10121(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_10122","instance":10122,"id":230137,"goal":"method InsertSort_10122(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_10123","instance":10123,"id":230138,"goal":"method MergeSort_10123(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_10124","instance":10124,"id":230139,"goal":"method ArrayCopy_10124(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_10125","instance":10125,"id":230140,"goal":"function ListReverse_10125(s: seq): seq\n ensures |ListReverse_10125(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_10125(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_10126","instance":10126,"id":230141,"goal":"function Factorial_10126(n: nat): nat\n ensures Factorial_10126(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_10126(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_10127","instance":10127,"id":230142,"goal":"function Fib_10127(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_10127(n-1) + Fib_10127(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_10128","instance":10128,"id":230143,"goal":"function Gcd_10128(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_10128(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_10129","instance":10129,"id":230144,"goal":"function Power_10129(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_10129(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_10130","instance":10130,"id":230145,"goal":"function Sum_10130(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_10130(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_10131","instance":10131,"id":230146,"goal":"method BinarySearch_10131(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_10132","instance":10132,"id":230147,"goal":"method InsertSort_10132(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_10133","instance":10133,"id":230148,"goal":"method MergeSort_10133(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_10134","instance":10134,"id":230149,"goal":"method ArrayCopy_10134(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_10135","instance":10135,"id":230150,"goal":"function ListReverse_10135(s: seq): seq\n ensures |ListReverse_10135(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_10135(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_10136","instance":10136,"id":230151,"goal":"function Factorial_10136(n: nat): nat\n ensures Factorial_10136(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_10136(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_10137","instance":10137,"id":230152,"goal":"function Fib_10137(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_10137(n-1) + Fib_10137(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_10138","instance":10138,"id":230153,"goal":"function Gcd_10138(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_10138(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_10139","instance":10139,"id":230154,"goal":"function Power_10139(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_10139(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_10140","instance":10140,"id":230155,"goal":"function Sum_10140(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_10140(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_10141","instance":10141,"id":230156,"goal":"method BinarySearch_10141(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_10142","instance":10142,"id":230157,"goal":"method InsertSort_10142(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_10143","instance":10143,"id":230158,"goal":"method MergeSort_10143(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_10144","instance":10144,"id":230159,"goal":"method ArrayCopy_10144(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_10145","instance":10145,"id":230160,"goal":"function ListReverse_10145(s: seq): seq\n ensures |ListReverse_10145(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_10145(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_10146","instance":10146,"id":230161,"goal":"function Factorial_10146(n: nat): nat\n ensures Factorial_10146(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_10146(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_10147","instance":10147,"id":230162,"goal":"function Fib_10147(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_10147(n-1) + Fib_10147(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_10148","instance":10148,"id":230163,"goal":"function Gcd_10148(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_10148(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_10149","instance":10149,"id":230164,"goal":"function Power_10149(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_10149(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_10150","instance":10150,"id":230165,"goal":"function Sum_10150(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_10150(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_10151","instance":10151,"id":230166,"goal":"method BinarySearch_10151(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_10152","instance":10152,"id":230167,"goal":"method InsertSort_10152(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_10153","instance":10153,"id":230168,"goal":"method MergeSort_10153(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_10154","instance":10154,"id":230169,"goal":"method ArrayCopy_10154(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_10155","instance":10155,"id":230170,"goal":"function ListReverse_10155(s: seq): seq\n ensures |ListReverse_10155(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_10155(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_10156","instance":10156,"id":230171,"goal":"function Factorial_10156(n: nat): nat\n ensures Factorial_10156(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_10156(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_10157","instance":10157,"id":230172,"goal":"function Fib_10157(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_10157(n-1) + Fib_10157(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_10158","instance":10158,"id":230173,"goal":"function Gcd_10158(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_10158(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_10159","instance":10159,"id":230174,"goal":"function Power_10159(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_10159(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_10160","instance":10160,"id":230175,"goal":"function Sum_10160(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_10160(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_10161","instance":10161,"id":230176,"goal":"method BinarySearch_10161(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_10162","instance":10162,"id":230177,"goal":"method InsertSort_10162(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_10163","instance":10163,"id":230178,"goal":"method MergeSort_10163(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_10164","instance":10164,"id":230179,"goal":"method ArrayCopy_10164(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_10165","instance":10165,"id":230180,"goal":"function ListReverse_10165(s: seq): seq\n ensures |ListReverse_10165(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_10165(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_10166","instance":10166,"id":230181,"goal":"function Factorial_10166(n: nat): nat\n ensures Factorial_10166(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_10166(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_10167","instance":10167,"id":230182,"goal":"function Fib_10167(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_10167(n-1) + Fib_10167(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_10168","instance":10168,"id":230183,"goal":"function Gcd_10168(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_10168(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_10169","instance":10169,"id":230184,"goal":"function Power_10169(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_10169(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_10170","instance":10170,"id":230185,"goal":"function Sum_10170(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_10170(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_10171","instance":10171,"id":230186,"goal":"method BinarySearch_10171(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_10172","instance":10172,"id":230187,"goal":"method InsertSort_10172(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_10173","instance":10173,"id":230188,"goal":"method MergeSort_10173(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_10174","instance":10174,"id":230189,"goal":"method ArrayCopy_10174(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_10175","instance":10175,"id":230190,"goal":"function ListReverse_10175(s: seq): seq\n ensures |ListReverse_10175(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_10175(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_10176","instance":10176,"id":230191,"goal":"function Factorial_10176(n: nat): nat\n ensures Factorial_10176(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_10176(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_10177","instance":10177,"id":230192,"goal":"function Fib_10177(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_10177(n-1) + Fib_10177(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_10178","instance":10178,"id":230193,"goal":"function Gcd_10178(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_10178(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_10179","instance":10179,"id":230194,"goal":"function Power_10179(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_10179(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_10180","instance":10180,"id":230195,"goal":"function Sum_10180(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_10180(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_10181","instance":10181,"id":230196,"goal":"method BinarySearch_10181(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_10182","instance":10182,"id":230197,"goal":"method InsertSort_10182(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_10183","instance":10183,"id":230198,"goal":"method MergeSort_10183(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_10184","instance":10184,"id":230199,"goal":"method ArrayCopy_10184(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_10185","instance":10185,"id":230200,"goal":"function ListReverse_10185(s: seq): seq\n ensures |ListReverse_10185(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_10185(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_10186","instance":10186,"id":230201,"goal":"function Factorial_10186(n: nat): nat\n ensures Factorial_10186(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_10186(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_10187","instance":10187,"id":230202,"goal":"function Fib_10187(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_10187(n-1) + Fib_10187(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_10188","instance":10188,"id":230203,"goal":"function Gcd_10188(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_10188(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_10189","instance":10189,"id":230204,"goal":"function Power_10189(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_10189(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_10190","instance":10190,"id":230205,"goal":"function Sum_10190(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_10190(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_10191","instance":10191,"id":230206,"goal":"method BinarySearch_10191(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_10192","instance":10192,"id":230207,"goal":"method InsertSort_10192(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_10193","instance":10193,"id":230208,"goal":"method MergeSort_10193(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_10194","instance":10194,"id":230209,"goal":"method ArrayCopy_10194(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_10195","instance":10195,"id":230210,"goal":"function ListReverse_10195(s: seq): seq\n ensures |ListReverse_10195(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_10195(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_10196","instance":10196,"id":230211,"goal":"function Factorial_10196(n: nat): nat\n ensures Factorial_10196(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_10196(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_10197","instance":10197,"id":230212,"goal":"function Fib_10197(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_10197(n-1) + Fib_10197(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_10198","instance":10198,"id":230213,"goal":"function Gcd_10198(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_10198(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_10199","instance":10199,"id":230214,"goal":"function Power_10199(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_10199(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_10200","instance":10200,"id":230215,"goal":"function Sum_10200(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_10200(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_10201","instance":10201,"id":230216,"goal":"method BinarySearch_10201(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_10202","instance":10202,"id":230217,"goal":"method InsertSort_10202(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_10203","instance":10203,"id":230218,"goal":"method MergeSort_10203(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_10204","instance":10204,"id":230219,"goal":"method ArrayCopy_10204(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_10205","instance":10205,"id":230220,"goal":"function ListReverse_10205(s: seq): seq\n ensures |ListReverse_10205(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_10205(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_10206","instance":10206,"id":230221,"goal":"function Factorial_10206(n: nat): nat\n ensures Factorial_10206(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_10206(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_10207","instance":10207,"id":230222,"goal":"function Fib_10207(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_10207(n-1) + Fib_10207(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_10208","instance":10208,"id":230223,"goal":"function Gcd_10208(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_10208(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_10209","instance":10209,"id":230224,"goal":"function Power_10209(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_10209(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_10210","instance":10210,"id":230225,"goal":"function Sum_10210(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_10210(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_10211","instance":10211,"id":230226,"goal":"method BinarySearch_10211(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_10212","instance":10212,"id":230227,"goal":"method InsertSort_10212(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_10213","instance":10213,"id":230228,"goal":"method MergeSort_10213(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_10214","instance":10214,"id":230229,"goal":"method ArrayCopy_10214(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_10215","instance":10215,"id":230230,"goal":"function ListReverse_10215(s: seq): seq\n ensures |ListReverse_10215(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_10215(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_10216","instance":10216,"id":230231,"goal":"function Factorial_10216(n: nat): nat\n ensures Factorial_10216(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_10216(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_10217","instance":10217,"id":230232,"goal":"function Fib_10217(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_10217(n-1) + Fib_10217(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_10218","instance":10218,"id":230233,"goal":"function Gcd_10218(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_10218(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_10219","instance":10219,"id":230234,"goal":"function Power_10219(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_10219(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_10220","instance":10220,"id":230235,"goal":"function Sum_10220(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_10220(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_10221","instance":10221,"id":230236,"goal":"method BinarySearch_10221(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_10222","instance":10222,"id":230237,"goal":"method InsertSort_10222(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_10223","instance":10223,"id":230238,"goal":"method MergeSort_10223(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_10224","instance":10224,"id":230239,"goal":"method ArrayCopy_10224(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_10225","instance":10225,"id":230240,"goal":"function ListReverse_10225(s: seq): seq\n ensures |ListReverse_10225(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_10225(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_10226","instance":10226,"id":230241,"goal":"function Factorial_10226(n: nat): nat\n ensures Factorial_10226(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_10226(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_10227","instance":10227,"id":230242,"goal":"function Fib_10227(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_10227(n-1) + Fib_10227(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_10228","instance":10228,"id":230243,"goal":"function Gcd_10228(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_10228(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_10229","instance":10229,"id":230244,"goal":"function Power_10229(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_10229(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_10230","instance":10230,"id":230245,"goal":"function Sum_10230(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_10230(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_10231","instance":10231,"id":230246,"goal":"method BinarySearch_10231(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_10232","instance":10232,"id":230247,"goal":"method InsertSort_10232(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_10233","instance":10233,"id":230248,"goal":"method MergeSort_10233(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_10234","instance":10234,"id":230249,"goal":"method ArrayCopy_10234(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_10235","instance":10235,"id":230250,"goal":"function ListReverse_10235(s: seq): seq\n ensures |ListReverse_10235(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_10235(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_10236","instance":10236,"id":230251,"goal":"function Factorial_10236(n: nat): nat\n ensures Factorial_10236(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_10236(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_10237","instance":10237,"id":230252,"goal":"function Fib_10237(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_10237(n-1) + Fib_10237(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_10238","instance":10238,"id":230253,"goal":"function Gcd_10238(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_10238(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_10239","instance":10239,"id":230254,"goal":"function Power_10239(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_10239(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_10240","instance":10240,"id":230255,"goal":"function Sum_10240(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_10240(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_10241","instance":10241,"id":230256,"goal":"method BinarySearch_10241(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_10242","instance":10242,"id":230257,"goal":"method InsertSort_10242(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_10243","instance":10243,"id":230258,"goal":"method MergeSort_10243(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_10244","instance":10244,"id":230259,"goal":"method ArrayCopy_10244(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_10245","instance":10245,"id":230260,"goal":"function ListReverse_10245(s: seq): seq\n ensures |ListReverse_10245(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_10245(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_10246","instance":10246,"id":230261,"goal":"function Factorial_10246(n: nat): nat\n ensures Factorial_10246(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_10246(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_10247","instance":10247,"id":230262,"goal":"function Fib_10247(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_10247(n-1) + Fib_10247(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_10248","instance":10248,"id":230263,"goal":"function Gcd_10248(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_10248(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_10249","instance":10249,"id":230264,"goal":"function Power_10249(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_10249(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_10250","instance":10250,"id":230265,"goal":"function Sum_10250(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_10250(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_10251","instance":10251,"id":230266,"goal":"method BinarySearch_10251(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_10252","instance":10252,"id":230267,"goal":"method InsertSort_10252(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_10253","instance":10253,"id":230268,"goal":"method MergeSort_10253(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_10254","instance":10254,"id":230269,"goal":"method ArrayCopy_10254(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_10255","instance":10255,"id":230270,"goal":"function ListReverse_10255(s: seq): seq\n ensures |ListReverse_10255(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_10255(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_10256","instance":10256,"id":230271,"goal":"function Factorial_10256(n: nat): nat\n ensures Factorial_10256(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_10256(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_10257","instance":10257,"id":230272,"goal":"function Fib_10257(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_10257(n-1) + Fib_10257(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_10258","instance":10258,"id":230273,"goal":"function Gcd_10258(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_10258(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_10259","instance":10259,"id":230274,"goal":"function Power_10259(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_10259(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_10260","instance":10260,"id":230275,"goal":"function Sum_10260(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_10260(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_10261","instance":10261,"id":230276,"goal":"method BinarySearch_10261(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_10262","instance":10262,"id":230277,"goal":"method InsertSort_10262(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_10263","instance":10263,"id":230278,"goal":"method MergeSort_10263(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_10264","instance":10264,"id":230279,"goal":"method ArrayCopy_10264(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_10265","instance":10265,"id":230280,"goal":"function ListReverse_10265(s: seq): seq\n ensures |ListReverse_10265(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_10265(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_10266","instance":10266,"id":230281,"goal":"function Factorial_10266(n: nat): nat\n ensures Factorial_10266(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_10266(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_10267","instance":10267,"id":230282,"goal":"function Fib_10267(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_10267(n-1) + Fib_10267(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_10268","instance":10268,"id":230283,"goal":"function Gcd_10268(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_10268(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_10269","instance":10269,"id":230284,"goal":"function Power_10269(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_10269(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_10270","instance":10270,"id":230285,"goal":"function Sum_10270(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_10270(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_10271","instance":10271,"id":230286,"goal":"method BinarySearch_10271(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_10272","instance":10272,"id":230287,"goal":"method InsertSort_10272(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_10273","instance":10273,"id":230288,"goal":"method MergeSort_10273(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_10274","instance":10274,"id":230289,"goal":"method ArrayCopy_10274(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_10275","instance":10275,"id":230290,"goal":"function ListReverse_10275(s: seq): seq\n ensures |ListReverse_10275(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_10275(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_10276","instance":10276,"id":230291,"goal":"function Factorial_10276(n: nat): nat\n ensures Factorial_10276(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_10276(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_10277","instance":10277,"id":230292,"goal":"function Fib_10277(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_10277(n-1) + Fib_10277(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_10278","instance":10278,"id":230293,"goal":"function Gcd_10278(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_10278(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_10279","instance":10279,"id":230294,"goal":"function Power_10279(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_10279(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_10280","instance":10280,"id":230295,"goal":"function Sum_10280(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_10280(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_10281","instance":10281,"id":230296,"goal":"method BinarySearch_10281(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_10282","instance":10282,"id":230297,"goal":"method InsertSort_10282(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_10283","instance":10283,"id":230298,"goal":"method MergeSort_10283(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_10284","instance":10284,"id":230299,"goal":"method ArrayCopy_10284(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_10285","instance":10285,"id":230300,"goal":"function ListReverse_10285(s: seq): seq\n ensures |ListReverse_10285(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_10285(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_10286","instance":10286,"id":230301,"goal":"function Factorial_10286(n: nat): nat\n ensures Factorial_10286(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_10286(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_10287","instance":10287,"id":230302,"goal":"function Fib_10287(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_10287(n-1) + Fib_10287(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_10288","instance":10288,"id":230303,"goal":"function Gcd_10288(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_10288(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_10289","instance":10289,"id":230304,"goal":"function Power_10289(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_10289(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_10290","instance":10290,"id":230305,"goal":"function Sum_10290(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_10290(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_10291","instance":10291,"id":230306,"goal":"method BinarySearch_10291(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_10292","instance":10292,"id":230307,"goal":"method InsertSort_10292(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_10293","instance":10293,"id":230308,"goal":"method MergeSort_10293(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_10294","instance":10294,"id":230309,"goal":"method ArrayCopy_10294(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_10295","instance":10295,"id":230310,"goal":"function ListReverse_10295(s: seq): seq\n ensures |ListReverse_10295(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_10295(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_10296","instance":10296,"id":230311,"goal":"function Factorial_10296(n: nat): nat\n ensures Factorial_10296(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_10296(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_10297","instance":10297,"id":230312,"goal":"function Fib_10297(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_10297(n-1) + Fib_10297(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_10298","instance":10298,"id":230313,"goal":"function Gcd_10298(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_10298(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_10299","instance":10299,"id":230314,"goal":"function Power_10299(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_10299(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_10300","instance":10300,"id":230315,"goal":"function Sum_10300(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_10300(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_10301","instance":10301,"id":230316,"goal":"method BinarySearch_10301(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_10302","instance":10302,"id":230317,"goal":"method InsertSort_10302(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_10303","instance":10303,"id":230318,"goal":"method MergeSort_10303(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_10304","instance":10304,"id":230319,"goal":"method ArrayCopy_10304(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_10305","instance":10305,"id":230320,"goal":"function ListReverse_10305(s: seq): seq\n ensures |ListReverse_10305(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_10305(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_10306","instance":10306,"id":230321,"goal":"function Factorial_10306(n: nat): nat\n ensures Factorial_10306(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_10306(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_10307","instance":10307,"id":230322,"goal":"function Fib_10307(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_10307(n-1) + Fib_10307(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_10308","instance":10308,"id":230323,"goal":"function Gcd_10308(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_10308(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_10309","instance":10309,"id":230324,"goal":"function Power_10309(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_10309(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_10310","instance":10310,"id":230325,"goal":"function Sum_10310(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_10310(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_10311","instance":10311,"id":230326,"goal":"method BinarySearch_10311(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_10312","instance":10312,"id":230327,"goal":"method InsertSort_10312(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_10313","instance":10313,"id":230328,"goal":"method MergeSort_10313(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_10314","instance":10314,"id":230329,"goal":"method ArrayCopy_10314(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_10315","instance":10315,"id":230330,"goal":"function ListReverse_10315(s: seq): seq\n ensures |ListReverse_10315(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_10315(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_10316","instance":10316,"id":230331,"goal":"function Factorial_10316(n: nat): nat\n ensures Factorial_10316(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_10316(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_10317","instance":10317,"id":230332,"goal":"function Fib_10317(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_10317(n-1) + Fib_10317(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_10318","instance":10318,"id":230333,"goal":"function Gcd_10318(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_10318(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_10319","instance":10319,"id":230334,"goal":"function Power_10319(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_10319(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_10320","instance":10320,"id":230335,"goal":"function Sum_10320(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_10320(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_10321","instance":10321,"id":230336,"goal":"method BinarySearch_10321(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_10322","instance":10322,"id":230337,"goal":"method InsertSort_10322(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_10323","instance":10323,"id":230338,"goal":"method MergeSort_10323(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_10324","instance":10324,"id":230339,"goal":"method ArrayCopy_10324(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_10325","instance":10325,"id":230340,"goal":"function ListReverse_10325(s: seq): seq\n ensures |ListReverse_10325(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_10325(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_10326","instance":10326,"id":230341,"goal":"function Factorial_10326(n: nat): nat\n ensures Factorial_10326(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_10326(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_10327","instance":10327,"id":230342,"goal":"function Fib_10327(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_10327(n-1) + Fib_10327(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_10328","instance":10328,"id":230343,"goal":"function Gcd_10328(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_10328(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_10329","instance":10329,"id":230344,"goal":"function Power_10329(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_10329(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_10330","instance":10330,"id":230345,"goal":"function Sum_10330(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_10330(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_10331","instance":10331,"id":230346,"goal":"method BinarySearch_10331(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_10332","instance":10332,"id":230347,"goal":"method InsertSort_10332(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_10333","instance":10333,"id":230348,"goal":"method MergeSort_10333(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_10334","instance":10334,"id":230349,"goal":"method ArrayCopy_10334(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_10335","instance":10335,"id":230350,"goal":"function ListReverse_10335(s: seq): seq\n ensures |ListReverse_10335(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_10335(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_10336","instance":10336,"id":230351,"goal":"function Factorial_10336(n: nat): nat\n ensures Factorial_10336(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_10336(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_10337","instance":10337,"id":230352,"goal":"function Fib_10337(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_10337(n-1) + Fib_10337(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_10338","instance":10338,"id":230353,"goal":"function Gcd_10338(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_10338(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_10339","instance":10339,"id":230354,"goal":"function Power_10339(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_10339(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_10340","instance":10340,"id":230355,"goal":"function Sum_10340(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_10340(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_10341","instance":10341,"id":230356,"goal":"method BinarySearch_10341(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_10342","instance":10342,"id":230357,"goal":"method InsertSort_10342(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_10343","instance":10343,"id":230358,"goal":"method MergeSort_10343(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_10344","instance":10344,"id":230359,"goal":"method ArrayCopy_10344(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_10345","instance":10345,"id":230360,"goal":"function ListReverse_10345(s: seq): seq\n ensures |ListReverse_10345(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_10345(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_10346","instance":10346,"id":230361,"goal":"function Factorial_10346(n: nat): nat\n ensures Factorial_10346(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_10346(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_10347","instance":10347,"id":230362,"goal":"function Fib_10347(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_10347(n-1) + Fib_10347(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_10348","instance":10348,"id":230363,"goal":"function Gcd_10348(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_10348(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_10349","instance":10349,"id":230364,"goal":"function Power_10349(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_10349(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_10350","instance":10350,"id":230365,"goal":"function Sum_10350(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_10350(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_10351","instance":10351,"id":230366,"goal":"method BinarySearch_10351(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_10352","instance":10352,"id":230367,"goal":"method InsertSort_10352(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_10353","instance":10353,"id":230368,"goal":"method MergeSort_10353(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_10354","instance":10354,"id":230369,"goal":"method ArrayCopy_10354(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_10355","instance":10355,"id":230370,"goal":"function ListReverse_10355(s: seq): seq\n ensures |ListReverse_10355(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_10355(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_10356","instance":10356,"id":230371,"goal":"function Factorial_10356(n: nat): nat\n ensures Factorial_10356(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_10356(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_10357","instance":10357,"id":230372,"goal":"function Fib_10357(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_10357(n-1) + Fib_10357(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_10358","instance":10358,"id":230373,"goal":"function Gcd_10358(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_10358(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_10359","instance":10359,"id":230374,"goal":"function Power_10359(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_10359(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_10360","instance":10360,"id":230375,"goal":"function Sum_10360(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_10360(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_10361","instance":10361,"id":230376,"goal":"method BinarySearch_10361(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_10362","instance":10362,"id":230377,"goal":"method InsertSort_10362(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_10363","instance":10363,"id":230378,"goal":"method MergeSort_10363(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_10364","instance":10364,"id":230379,"goal":"method ArrayCopy_10364(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_10365","instance":10365,"id":230380,"goal":"function ListReverse_10365(s: seq): seq\n ensures |ListReverse_10365(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_10365(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_10366","instance":10366,"id":230381,"goal":"function Factorial_10366(n: nat): nat\n ensures Factorial_10366(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_10366(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_10367","instance":10367,"id":230382,"goal":"function Fib_10367(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_10367(n-1) + Fib_10367(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_10368","instance":10368,"id":230383,"goal":"function Gcd_10368(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_10368(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_10369","instance":10369,"id":230384,"goal":"function Power_10369(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_10369(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_10370","instance":10370,"id":230385,"goal":"function Sum_10370(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_10370(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_10371","instance":10371,"id":230386,"goal":"method BinarySearch_10371(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_10372","instance":10372,"id":230387,"goal":"method InsertSort_10372(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_10373","instance":10373,"id":230388,"goal":"method MergeSort_10373(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_10374","instance":10374,"id":230389,"goal":"method ArrayCopy_10374(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_10375","instance":10375,"id":230390,"goal":"function ListReverse_10375(s: seq): seq\n ensures |ListReverse_10375(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_10375(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_10376","instance":10376,"id":230391,"goal":"function Factorial_10376(n: nat): nat\n ensures Factorial_10376(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_10376(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_10377","instance":10377,"id":230392,"goal":"function Fib_10377(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_10377(n-1) + Fib_10377(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_10378","instance":10378,"id":230393,"goal":"function Gcd_10378(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_10378(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_10379","instance":10379,"id":230394,"goal":"function Power_10379(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_10379(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_10380","instance":10380,"id":230395,"goal":"function Sum_10380(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_10380(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_10381","instance":10381,"id":230396,"goal":"method BinarySearch_10381(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_10382","instance":10382,"id":230397,"goal":"method InsertSort_10382(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_10383","instance":10383,"id":230398,"goal":"method MergeSort_10383(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_10384","instance":10384,"id":230399,"goal":"method ArrayCopy_10384(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_10385","instance":10385,"id":230400,"goal":"function ListReverse_10385(s: seq): seq\n ensures |ListReverse_10385(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_10385(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_10386","instance":10386,"id":230401,"goal":"function Factorial_10386(n: nat): nat\n ensures Factorial_10386(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_10386(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_10387","instance":10387,"id":230402,"goal":"function Fib_10387(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_10387(n-1) + Fib_10387(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_10388","instance":10388,"id":230403,"goal":"function Gcd_10388(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_10388(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_10389","instance":10389,"id":230404,"goal":"function Power_10389(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_10389(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_10390","instance":10390,"id":230405,"goal":"function Sum_10390(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_10390(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_10391","instance":10391,"id":230406,"goal":"method BinarySearch_10391(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_10392","instance":10392,"id":230407,"goal":"method InsertSort_10392(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_10393","instance":10393,"id":230408,"goal":"method MergeSort_10393(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_10394","instance":10394,"id":230409,"goal":"method ArrayCopy_10394(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_10395","instance":10395,"id":230410,"goal":"function ListReverse_10395(s: seq): seq\n ensures |ListReverse_10395(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_10395(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_10396","instance":10396,"id":230411,"goal":"function Factorial_10396(n: nat): nat\n ensures Factorial_10396(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_10396(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_10397","instance":10397,"id":230412,"goal":"function Fib_10397(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_10397(n-1) + Fib_10397(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_10398","instance":10398,"id":230413,"goal":"function Gcd_10398(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_10398(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_10399","instance":10399,"id":230414,"goal":"function Power_10399(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_10399(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_10400","instance":10400,"id":230415,"goal":"function Sum_10400(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_10400(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_10401","instance":10401,"id":230416,"goal":"method BinarySearch_10401(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_10402","instance":10402,"id":230417,"goal":"method InsertSort_10402(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_10403","instance":10403,"id":230418,"goal":"method MergeSort_10403(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_10404","instance":10404,"id":230419,"goal":"method ArrayCopy_10404(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_10405","instance":10405,"id":230420,"goal":"function ListReverse_10405(s: seq): seq\n ensures |ListReverse_10405(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_10405(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_10406","instance":10406,"id":230421,"goal":"function Factorial_10406(n: nat): nat\n ensures Factorial_10406(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_10406(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_10407","instance":10407,"id":230422,"goal":"function Fib_10407(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_10407(n-1) + Fib_10407(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_10408","instance":10408,"id":230423,"goal":"function Gcd_10408(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_10408(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_10409","instance":10409,"id":230424,"goal":"function Power_10409(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_10409(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_10410","instance":10410,"id":230425,"goal":"function Sum_10410(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_10410(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_10411","instance":10411,"id":230426,"goal":"method BinarySearch_10411(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_10412","instance":10412,"id":230427,"goal":"method InsertSort_10412(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_10413","instance":10413,"id":230428,"goal":"method MergeSort_10413(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_10414","instance":10414,"id":230429,"goal":"method ArrayCopy_10414(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_10415","instance":10415,"id":230430,"goal":"function ListReverse_10415(s: seq): seq\n ensures |ListReverse_10415(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_10415(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_10416","instance":10416,"id":230431,"goal":"function Factorial_10416(n: nat): nat\n ensures Factorial_10416(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_10416(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_10417","instance":10417,"id":230432,"goal":"function Fib_10417(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_10417(n-1) + Fib_10417(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_10418","instance":10418,"id":230433,"goal":"function Gcd_10418(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_10418(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_10419","instance":10419,"id":230434,"goal":"function Power_10419(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_10419(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_10420","instance":10420,"id":230435,"goal":"function Sum_10420(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_10420(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_10421","instance":10421,"id":230436,"goal":"method BinarySearch_10421(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_10422","instance":10422,"id":230437,"goal":"method InsertSort_10422(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_10423","instance":10423,"id":230438,"goal":"method MergeSort_10423(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_10424","instance":10424,"id":230439,"goal":"method ArrayCopy_10424(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_10425","instance":10425,"id":230440,"goal":"function ListReverse_10425(s: seq): seq\n ensures |ListReverse_10425(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_10425(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_10426","instance":10426,"id":230441,"goal":"function Factorial_10426(n: nat): nat\n ensures Factorial_10426(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_10426(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_10427","instance":10427,"id":230442,"goal":"function Fib_10427(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_10427(n-1) + Fib_10427(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_10428","instance":10428,"id":230443,"goal":"function Gcd_10428(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_10428(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_10429","instance":10429,"id":230444,"goal":"function Power_10429(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_10429(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_10430","instance":10430,"id":230445,"goal":"function Sum_10430(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_10430(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_10431","instance":10431,"id":230446,"goal":"method BinarySearch_10431(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_10432","instance":10432,"id":230447,"goal":"method InsertSort_10432(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_10433","instance":10433,"id":230448,"goal":"method MergeSort_10433(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_10434","instance":10434,"id":230449,"goal":"method ArrayCopy_10434(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_10435","instance":10435,"id":230450,"goal":"function ListReverse_10435(s: seq): seq\n ensures |ListReverse_10435(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_10435(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_10436","instance":10436,"id":230451,"goal":"function Factorial_10436(n: nat): nat\n ensures Factorial_10436(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_10436(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_10437","instance":10437,"id":230452,"goal":"function Fib_10437(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_10437(n-1) + Fib_10437(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_10438","instance":10438,"id":230453,"goal":"function Gcd_10438(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_10438(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_10439","instance":10439,"id":230454,"goal":"function Power_10439(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_10439(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_10440","instance":10440,"id":230455,"goal":"function Sum_10440(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_10440(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_10441","instance":10441,"id":230456,"goal":"method BinarySearch_10441(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_10442","instance":10442,"id":230457,"goal":"method InsertSort_10442(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_10443","instance":10443,"id":230458,"goal":"method MergeSort_10443(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_10444","instance":10444,"id":230459,"goal":"method ArrayCopy_10444(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_10445","instance":10445,"id":230460,"goal":"function ListReverse_10445(s: seq): seq\n ensures |ListReverse_10445(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_10445(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_10446","instance":10446,"id":230461,"goal":"function Factorial_10446(n: nat): nat\n ensures Factorial_10446(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_10446(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_10447","instance":10447,"id":230462,"goal":"function Fib_10447(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_10447(n-1) + Fib_10447(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_10448","instance":10448,"id":230463,"goal":"function Gcd_10448(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_10448(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_10449","instance":10449,"id":230464,"goal":"function Power_10449(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_10449(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_10450","instance":10450,"id":230465,"goal":"function Sum_10450(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_10450(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_10451","instance":10451,"id":230466,"goal":"method BinarySearch_10451(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_10452","instance":10452,"id":230467,"goal":"method InsertSort_10452(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_10453","instance":10453,"id":230468,"goal":"method MergeSort_10453(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_10454","instance":10454,"id":230469,"goal":"method ArrayCopy_10454(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_10455","instance":10455,"id":230470,"goal":"function ListReverse_10455(s: seq): seq\n ensures |ListReverse_10455(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_10455(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_10456","instance":10456,"id":230471,"goal":"function Factorial_10456(n: nat): nat\n ensures Factorial_10456(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_10456(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_10457","instance":10457,"id":230472,"goal":"function Fib_10457(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_10457(n-1) + Fib_10457(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_10458","instance":10458,"id":230473,"goal":"function Gcd_10458(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_10458(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_10459","instance":10459,"id":230474,"goal":"function Power_10459(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_10459(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_10460","instance":10460,"id":230475,"goal":"function Sum_10460(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_10460(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_10461","instance":10461,"id":230476,"goal":"method BinarySearch_10461(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_10462","instance":10462,"id":230477,"goal":"method InsertSort_10462(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_10463","instance":10463,"id":230478,"goal":"method MergeSort_10463(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_10464","instance":10464,"id":230479,"goal":"method ArrayCopy_10464(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_10465","instance":10465,"id":230480,"goal":"function ListReverse_10465(s: seq): seq\n ensures |ListReverse_10465(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_10465(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_10466","instance":10466,"id":230481,"goal":"function Factorial_10466(n: nat): nat\n ensures Factorial_10466(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_10466(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_10467","instance":10467,"id":230482,"goal":"function Fib_10467(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_10467(n-1) + Fib_10467(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_10468","instance":10468,"id":230483,"goal":"function Gcd_10468(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_10468(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_10469","instance":10469,"id":230484,"goal":"function Power_10469(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_10469(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_10470","instance":10470,"id":230485,"goal":"function Sum_10470(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_10470(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_10471","instance":10471,"id":230486,"goal":"method BinarySearch_10471(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_10472","instance":10472,"id":230487,"goal":"method InsertSort_10472(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_10473","instance":10473,"id":230488,"goal":"method MergeSort_10473(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_10474","instance":10474,"id":230489,"goal":"method ArrayCopy_10474(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_10475","instance":10475,"id":230490,"goal":"function ListReverse_10475(s: seq): seq\n ensures |ListReverse_10475(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_10475(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_10476","instance":10476,"id":230491,"goal":"function Factorial_10476(n: nat): nat\n ensures Factorial_10476(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_10476(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_10477","instance":10477,"id":230492,"goal":"function Fib_10477(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_10477(n-1) + Fib_10477(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_10478","instance":10478,"id":230493,"goal":"function Gcd_10478(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_10478(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_10479","instance":10479,"id":230494,"goal":"function Power_10479(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_10479(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_10480","instance":10480,"id":230495,"goal":"function Sum_10480(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_10480(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_10481","instance":10481,"id":230496,"goal":"method BinarySearch_10481(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_10482","instance":10482,"id":230497,"goal":"method InsertSort_10482(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_10483","instance":10483,"id":230498,"goal":"method MergeSort_10483(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_10484","instance":10484,"id":230499,"goal":"method ArrayCopy_10484(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_10485","instance":10485,"id":230500,"goal":"function ListReverse_10485(s: seq): seq\n ensures |ListReverse_10485(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_10485(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_10486","instance":10486,"id":230501,"goal":"function Factorial_10486(n: nat): nat\n ensures Factorial_10486(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_10486(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_10487","instance":10487,"id":230502,"goal":"function Fib_10487(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_10487(n-1) + Fib_10487(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_10488","instance":10488,"id":230503,"goal":"function Gcd_10488(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_10488(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_10489","instance":10489,"id":230504,"goal":"function Power_10489(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_10489(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_10490","instance":10490,"id":230505,"goal":"function Sum_10490(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_10490(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_10491","instance":10491,"id":230506,"goal":"method BinarySearch_10491(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_10492","instance":10492,"id":230507,"goal":"method InsertSort_10492(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_10493","instance":10493,"id":230508,"goal":"method MergeSort_10493(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_10494","instance":10494,"id":230509,"goal":"method ArrayCopy_10494(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_10495","instance":10495,"id":230510,"goal":"function ListReverse_10495(s: seq): seq\n ensures |ListReverse_10495(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_10495(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_10496","instance":10496,"id":230511,"goal":"function Factorial_10496(n: nat): nat\n ensures Factorial_10496(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_10496(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_10497","instance":10497,"id":230512,"goal":"function Fib_10497(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_10497(n-1) + Fib_10497(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_10498","instance":10498,"id":230513,"goal":"function Gcd_10498(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_10498(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_10499","instance":10499,"id":230514,"goal":"function Power_10499(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_10499(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_10500","instance":10500,"id":230515,"goal":"function Sum_10500(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_10500(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_10501","instance":10501,"id":230516,"goal":"method BinarySearch_10501(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_10502","instance":10502,"id":230517,"goal":"method InsertSort_10502(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_10503","instance":10503,"id":230518,"goal":"method MergeSort_10503(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_10504","instance":10504,"id":230519,"goal":"method ArrayCopy_10504(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_10505","instance":10505,"id":230520,"goal":"function ListReverse_10505(s: seq): seq\n ensures |ListReverse_10505(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_10505(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_10506","instance":10506,"id":230521,"goal":"function Factorial_10506(n: nat): nat\n ensures Factorial_10506(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_10506(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_10507","instance":10507,"id":230522,"goal":"function Fib_10507(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_10507(n-1) + Fib_10507(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_10508","instance":10508,"id":230523,"goal":"function Gcd_10508(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_10508(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_10509","instance":10509,"id":230524,"goal":"function Power_10509(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_10509(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_10510","instance":10510,"id":230525,"goal":"function Sum_10510(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_10510(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_10511","instance":10511,"id":230526,"goal":"method BinarySearch_10511(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_10512","instance":10512,"id":230527,"goal":"method InsertSort_10512(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_10513","instance":10513,"id":230528,"goal":"method MergeSort_10513(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_10514","instance":10514,"id":230529,"goal":"method ArrayCopy_10514(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_10515","instance":10515,"id":230530,"goal":"function ListReverse_10515(s: seq): seq\n ensures |ListReverse_10515(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_10515(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_10516","instance":10516,"id":230531,"goal":"function Factorial_10516(n: nat): nat\n ensures Factorial_10516(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_10516(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_10517","instance":10517,"id":230532,"goal":"function Fib_10517(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_10517(n-1) + Fib_10517(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_10518","instance":10518,"id":230533,"goal":"function Gcd_10518(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_10518(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_10519","instance":10519,"id":230534,"goal":"function Power_10519(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_10519(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_10520","instance":10520,"id":230535,"goal":"function Sum_10520(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_10520(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_10521","instance":10521,"id":230536,"goal":"method BinarySearch_10521(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_10522","instance":10522,"id":230537,"goal":"method InsertSort_10522(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_10523","instance":10523,"id":230538,"goal":"method MergeSort_10523(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_10524","instance":10524,"id":230539,"goal":"method ArrayCopy_10524(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_10525","instance":10525,"id":230540,"goal":"function ListReverse_10525(s: seq): seq\n ensures |ListReverse_10525(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_10525(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_10526","instance":10526,"id":230541,"goal":"function Factorial_10526(n: nat): nat\n ensures Factorial_10526(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_10526(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_10527","instance":10527,"id":230542,"goal":"function Fib_10527(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_10527(n-1) + Fib_10527(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_10528","instance":10528,"id":230543,"goal":"function Gcd_10528(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_10528(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_10529","instance":10529,"id":230544,"goal":"function Power_10529(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_10529(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_10530","instance":10530,"id":230545,"goal":"function Sum_10530(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_10530(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_10531","instance":10531,"id":230546,"goal":"method BinarySearch_10531(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_10532","instance":10532,"id":230547,"goal":"method InsertSort_10532(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_10533","instance":10533,"id":230548,"goal":"method MergeSort_10533(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_10534","instance":10534,"id":230549,"goal":"method ArrayCopy_10534(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_10535","instance":10535,"id":230550,"goal":"function ListReverse_10535(s: seq): seq\n ensures |ListReverse_10535(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_10535(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_10536","instance":10536,"id":230551,"goal":"function Factorial_10536(n: nat): nat\n ensures Factorial_10536(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_10536(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_10537","instance":10537,"id":230552,"goal":"function Fib_10537(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_10537(n-1) + Fib_10537(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_10538","instance":10538,"id":230553,"goal":"function Gcd_10538(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_10538(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_10539","instance":10539,"id":230554,"goal":"function Power_10539(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_10539(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_10540","instance":10540,"id":230555,"goal":"function Sum_10540(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_10540(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_10541","instance":10541,"id":230556,"goal":"method BinarySearch_10541(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_10542","instance":10542,"id":230557,"goal":"method InsertSort_10542(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_10543","instance":10543,"id":230558,"goal":"method MergeSort_10543(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_10544","instance":10544,"id":230559,"goal":"method ArrayCopy_10544(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_10545","instance":10545,"id":230560,"goal":"function ListReverse_10545(s: seq): seq\n ensures |ListReverse_10545(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_10545(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_10546","instance":10546,"id":230561,"goal":"function Factorial_10546(n: nat): nat\n ensures Factorial_10546(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_10546(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_10547","instance":10547,"id":230562,"goal":"function Fib_10547(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_10547(n-1) + Fib_10547(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_10548","instance":10548,"id":230563,"goal":"function Gcd_10548(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_10548(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_10549","instance":10549,"id":230564,"goal":"function Power_10549(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_10549(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_10550","instance":10550,"id":230565,"goal":"function Sum_10550(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_10550(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_10551","instance":10551,"id":230566,"goal":"method BinarySearch_10551(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_10552","instance":10552,"id":230567,"goal":"method InsertSort_10552(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_10553","instance":10553,"id":230568,"goal":"method MergeSort_10553(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_10554","instance":10554,"id":230569,"goal":"method ArrayCopy_10554(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_10555","instance":10555,"id":230570,"goal":"function ListReverse_10555(s: seq): seq\n ensures |ListReverse_10555(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_10555(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_10556","instance":10556,"id":230571,"goal":"function Factorial_10556(n: nat): nat\n ensures Factorial_10556(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_10556(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_10557","instance":10557,"id":230572,"goal":"function Fib_10557(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_10557(n-1) + Fib_10557(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_10558","instance":10558,"id":230573,"goal":"function Gcd_10558(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_10558(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_10559","instance":10559,"id":230574,"goal":"function Power_10559(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_10559(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_10560","instance":10560,"id":230575,"goal":"function Sum_10560(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_10560(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_10561","instance":10561,"id":230576,"goal":"method BinarySearch_10561(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_10562","instance":10562,"id":230577,"goal":"method InsertSort_10562(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_10563","instance":10563,"id":230578,"goal":"method MergeSort_10563(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_10564","instance":10564,"id":230579,"goal":"method ArrayCopy_10564(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_10565","instance":10565,"id":230580,"goal":"function ListReverse_10565(s: seq): seq\n ensures |ListReverse_10565(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_10565(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_10566","instance":10566,"id":230581,"goal":"function Factorial_10566(n: nat): nat\n ensures Factorial_10566(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_10566(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_10567","instance":10567,"id":230582,"goal":"function Fib_10567(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_10567(n-1) + Fib_10567(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_10568","instance":10568,"id":230583,"goal":"function Gcd_10568(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_10568(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_10569","instance":10569,"id":230584,"goal":"function Power_10569(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_10569(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_10570","instance":10570,"id":230585,"goal":"function Sum_10570(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_10570(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_10571","instance":10571,"id":230586,"goal":"method BinarySearch_10571(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_10572","instance":10572,"id":230587,"goal":"method InsertSort_10572(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_10573","instance":10573,"id":230588,"goal":"method MergeSort_10573(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_10574","instance":10574,"id":230589,"goal":"method ArrayCopy_10574(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_10575","instance":10575,"id":230590,"goal":"function ListReverse_10575(s: seq): seq\n ensures |ListReverse_10575(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_10575(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_10576","instance":10576,"id":230591,"goal":"function Factorial_10576(n: nat): nat\n ensures Factorial_10576(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_10576(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_10577","instance":10577,"id":230592,"goal":"function Fib_10577(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_10577(n-1) + Fib_10577(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_10578","instance":10578,"id":230593,"goal":"function Gcd_10578(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_10578(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_10579","instance":10579,"id":230594,"goal":"function Power_10579(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_10579(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_10580","instance":10580,"id":230595,"goal":"function Sum_10580(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_10580(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_10581","instance":10581,"id":230596,"goal":"method BinarySearch_10581(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_10582","instance":10582,"id":230597,"goal":"method InsertSort_10582(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_10583","instance":10583,"id":230598,"goal":"method MergeSort_10583(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_10584","instance":10584,"id":230599,"goal":"method ArrayCopy_10584(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_10585","instance":10585,"id":230600,"goal":"function ListReverse_10585(s: seq): seq\n ensures |ListReverse_10585(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_10585(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_10586","instance":10586,"id":230601,"goal":"function Factorial_10586(n: nat): nat\n ensures Factorial_10586(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_10586(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_10587","instance":10587,"id":230602,"goal":"function Fib_10587(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_10587(n-1) + Fib_10587(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_10588","instance":10588,"id":230603,"goal":"function Gcd_10588(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_10588(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_10589","instance":10589,"id":230604,"goal":"function Power_10589(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_10589(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_10590","instance":10590,"id":230605,"goal":"function Sum_10590(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_10590(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_10591","instance":10591,"id":230606,"goal":"method BinarySearch_10591(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_10592","instance":10592,"id":230607,"goal":"method InsertSort_10592(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_10593","instance":10593,"id":230608,"goal":"method MergeSort_10593(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_10594","instance":10594,"id":230609,"goal":"method ArrayCopy_10594(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_10595","instance":10595,"id":230610,"goal":"function ListReverse_10595(s: seq): seq\n ensures |ListReverse_10595(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_10595(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_10596","instance":10596,"id":230611,"goal":"function Factorial_10596(n: nat): nat\n ensures Factorial_10596(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_10596(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_10597","instance":10597,"id":230612,"goal":"function Fib_10597(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_10597(n-1) + Fib_10597(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_10598","instance":10598,"id":230613,"goal":"function Gcd_10598(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_10598(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_10599","instance":10599,"id":230614,"goal":"function Power_10599(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_10599(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_10600","instance":10600,"id":230615,"goal":"function Sum_10600(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_10600(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_10601","instance":10601,"id":230616,"goal":"method BinarySearch_10601(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_10602","instance":10602,"id":230617,"goal":"method InsertSort_10602(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_10603","instance":10603,"id":230618,"goal":"method MergeSort_10603(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_10604","instance":10604,"id":230619,"goal":"method ArrayCopy_10604(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_10605","instance":10605,"id":230620,"goal":"function ListReverse_10605(s: seq): seq\n ensures |ListReverse_10605(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_10605(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_10606","instance":10606,"id":230621,"goal":"function Factorial_10606(n: nat): nat\n ensures Factorial_10606(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_10606(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_10607","instance":10607,"id":230622,"goal":"function Fib_10607(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_10607(n-1) + Fib_10607(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_10608","instance":10608,"id":230623,"goal":"function Gcd_10608(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_10608(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_10609","instance":10609,"id":230624,"goal":"function Power_10609(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_10609(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_10610","instance":10610,"id":230625,"goal":"function Sum_10610(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_10610(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_10611","instance":10611,"id":230626,"goal":"method BinarySearch_10611(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_10612","instance":10612,"id":230627,"goal":"method InsertSort_10612(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_10613","instance":10613,"id":230628,"goal":"method MergeSort_10613(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_10614","instance":10614,"id":230629,"goal":"method ArrayCopy_10614(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_10615","instance":10615,"id":230630,"goal":"function ListReverse_10615(s: seq): seq\n ensures |ListReverse_10615(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_10615(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_10616","instance":10616,"id":230631,"goal":"function Factorial_10616(n: nat): nat\n ensures Factorial_10616(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_10616(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_10617","instance":10617,"id":230632,"goal":"function Fib_10617(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_10617(n-1) + Fib_10617(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_10618","instance":10618,"id":230633,"goal":"function Gcd_10618(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_10618(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_10619","instance":10619,"id":230634,"goal":"function Power_10619(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_10619(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_10620","instance":10620,"id":230635,"goal":"function Sum_10620(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_10620(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_10621","instance":10621,"id":230636,"goal":"method BinarySearch_10621(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_10622","instance":10622,"id":230637,"goal":"method InsertSort_10622(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_10623","instance":10623,"id":230638,"goal":"method MergeSort_10623(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_10624","instance":10624,"id":230639,"goal":"method ArrayCopy_10624(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_10625","instance":10625,"id":230640,"goal":"function ListReverse_10625(s: seq): seq\n ensures |ListReverse_10625(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_10625(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_10626","instance":10626,"id":230641,"goal":"function Factorial_10626(n: nat): nat\n ensures Factorial_10626(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_10626(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_10627","instance":10627,"id":230642,"goal":"function Fib_10627(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_10627(n-1) + Fib_10627(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_10628","instance":10628,"id":230643,"goal":"function Gcd_10628(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_10628(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_10629","instance":10629,"id":230644,"goal":"function Power_10629(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_10629(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_10630","instance":10630,"id":230645,"goal":"function Sum_10630(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_10630(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_10631","instance":10631,"id":230646,"goal":"method BinarySearch_10631(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_10632","instance":10632,"id":230647,"goal":"method InsertSort_10632(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_10633","instance":10633,"id":230648,"goal":"method MergeSort_10633(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_10634","instance":10634,"id":230649,"goal":"method ArrayCopy_10634(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_10635","instance":10635,"id":230650,"goal":"function ListReverse_10635(s: seq): seq\n ensures |ListReverse_10635(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_10635(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_10636","instance":10636,"id":230651,"goal":"function Factorial_10636(n: nat): nat\n ensures Factorial_10636(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_10636(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_10637","instance":10637,"id":230652,"goal":"function Fib_10637(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_10637(n-1) + Fib_10637(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_10638","instance":10638,"id":230653,"goal":"function Gcd_10638(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_10638(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_10639","instance":10639,"id":230654,"goal":"function Power_10639(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_10639(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_10640","instance":10640,"id":230655,"goal":"function Sum_10640(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_10640(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_10641","instance":10641,"id":230656,"goal":"method BinarySearch_10641(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_10642","instance":10642,"id":230657,"goal":"method InsertSort_10642(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_10643","instance":10643,"id":230658,"goal":"method MergeSort_10643(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_10644","instance":10644,"id":230659,"goal":"method ArrayCopy_10644(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_10645","instance":10645,"id":230660,"goal":"function ListReverse_10645(s: seq): seq\n ensures |ListReverse_10645(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_10645(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_10646","instance":10646,"id":230661,"goal":"function Factorial_10646(n: nat): nat\n ensures Factorial_10646(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_10646(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_10647","instance":10647,"id":230662,"goal":"function Fib_10647(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_10647(n-1) + Fib_10647(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_10648","instance":10648,"id":230663,"goal":"function Gcd_10648(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_10648(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_10649","instance":10649,"id":230664,"goal":"function Power_10649(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_10649(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_10650","instance":10650,"id":230665,"goal":"function Sum_10650(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_10650(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_10651","instance":10651,"id":230666,"goal":"method BinarySearch_10651(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_10652","instance":10652,"id":230667,"goal":"method InsertSort_10652(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_10653","instance":10653,"id":230668,"goal":"method MergeSort_10653(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_10654","instance":10654,"id":230669,"goal":"method ArrayCopy_10654(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_10655","instance":10655,"id":230670,"goal":"function ListReverse_10655(s: seq): seq\n ensures |ListReverse_10655(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_10655(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_10656","instance":10656,"id":230671,"goal":"function Factorial_10656(n: nat): nat\n ensures Factorial_10656(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_10656(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_10657","instance":10657,"id":230672,"goal":"function Fib_10657(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_10657(n-1) + Fib_10657(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_10658","instance":10658,"id":230673,"goal":"function Gcd_10658(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_10658(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_10659","instance":10659,"id":230674,"goal":"function Power_10659(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_10659(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_10660","instance":10660,"id":230675,"goal":"function Sum_10660(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_10660(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_10661","instance":10661,"id":230676,"goal":"method BinarySearch_10661(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_10662","instance":10662,"id":230677,"goal":"method InsertSort_10662(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_10663","instance":10663,"id":230678,"goal":"method MergeSort_10663(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_10664","instance":10664,"id":230679,"goal":"method ArrayCopy_10664(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_10665","instance":10665,"id":230680,"goal":"function ListReverse_10665(s: seq): seq\n ensures |ListReverse_10665(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_10665(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_10666","instance":10666,"id":230681,"goal":"function Factorial_10666(n: nat): nat\n ensures Factorial_10666(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_10666(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_10667","instance":10667,"id":230682,"goal":"function Fib_10667(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_10667(n-1) + Fib_10667(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_10668","instance":10668,"id":230683,"goal":"function Gcd_10668(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_10668(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_10669","instance":10669,"id":230684,"goal":"function Power_10669(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_10669(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_10670","instance":10670,"id":230685,"goal":"function Sum_10670(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_10670(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_10671","instance":10671,"id":230686,"goal":"method BinarySearch_10671(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_10672","instance":10672,"id":230687,"goal":"method InsertSort_10672(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_10673","instance":10673,"id":230688,"goal":"method MergeSort_10673(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_10674","instance":10674,"id":230689,"goal":"method ArrayCopy_10674(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_10675","instance":10675,"id":230690,"goal":"function ListReverse_10675(s: seq): seq\n ensures |ListReverse_10675(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_10675(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_10676","instance":10676,"id":230691,"goal":"function Factorial_10676(n: nat): nat\n ensures Factorial_10676(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_10676(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_10677","instance":10677,"id":230692,"goal":"function Fib_10677(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_10677(n-1) + Fib_10677(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_10678","instance":10678,"id":230693,"goal":"function Gcd_10678(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_10678(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_10679","instance":10679,"id":230694,"goal":"function Power_10679(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_10679(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_10680","instance":10680,"id":230695,"goal":"function Sum_10680(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_10680(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_10681","instance":10681,"id":230696,"goal":"method BinarySearch_10681(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_10682","instance":10682,"id":230697,"goal":"method InsertSort_10682(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_10683","instance":10683,"id":230698,"goal":"method MergeSort_10683(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_10684","instance":10684,"id":230699,"goal":"method ArrayCopy_10684(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_10685","instance":10685,"id":230700,"goal":"function ListReverse_10685(s: seq): seq\n ensures |ListReverse_10685(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_10685(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_10686","instance":10686,"id":230701,"goal":"function Factorial_10686(n: nat): nat\n ensures Factorial_10686(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_10686(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_10687","instance":10687,"id":230702,"goal":"function Fib_10687(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_10687(n-1) + Fib_10687(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_10688","instance":10688,"id":230703,"goal":"function Gcd_10688(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_10688(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_10689","instance":10689,"id":230704,"goal":"function Power_10689(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_10689(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_10690","instance":10690,"id":230705,"goal":"function Sum_10690(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_10690(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_10691","instance":10691,"id":230706,"goal":"method BinarySearch_10691(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_10692","instance":10692,"id":230707,"goal":"method InsertSort_10692(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_10693","instance":10693,"id":230708,"goal":"method MergeSort_10693(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_10694","instance":10694,"id":230709,"goal":"method ArrayCopy_10694(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_10695","instance":10695,"id":230710,"goal":"function ListReverse_10695(s: seq): seq\n ensures |ListReverse_10695(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_10695(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_10696","instance":10696,"id":230711,"goal":"function Factorial_10696(n: nat): nat\n ensures Factorial_10696(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_10696(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_10697","instance":10697,"id":230712,"goal":"function Fib_10697(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_10697(n-1) + Fib_10697(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_10698","instance":10698,"id":230713,"goal":"function Gcd_10698(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_10698(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_10699","instance":10699,"id":230714,"goal":"function Power_10699(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_10699(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_10700","instance":10700,"id":230715,"goal":"function Sum_10700(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_10700(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_10701","instance":10701,"id":230716,"goal":"method BinarySearch_10701(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_10702","instance":10702,"id":230717,"goal":"method InsertSort_10702(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_10703","instance":10703,"id":230718,"goal":"method MergeSort_10703(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_10704","instance":10704,"id":230719,"goal":"method ArrayCopy_10704(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_10705","instance":10705,"id":230720,"goal":"function ListReverse_10705(s: seq): seq\n ensures |ListReverse_10705(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_10705(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_10706","instance":10706,"id":230721,"goal":"function Factorial_10706(n: nat): nat\n ensures Factorial_10706(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_10706(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_10707","instance":10707,"id":230722,"goal":"function Fib_10707(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_10707(n-1) + Fib_10707(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_10708","instance":10708,"id":230723,"goal":"function Gcd_10708(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_10708(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_10709","instance":10709,"id":230724,"goal":"function Power_10709(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_10709(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_10710","instance":10710,"id":230725,"goal":"function Sum_10710(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_10710(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_10711","instance":10711,"id":230726,"goal":"method BinarySearch_10711(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_10712","instance":10712,"id":230727,"goal":"method InsertSort_10712(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_10713","instance":10713,"id":230728,"goal":"method MergeSort_10713(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_10714","instance":10714,"id":230729,"goal":"method ArrayCopy_10714(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_10715","instance":10715,"id":230730,"goal":"function ListReverse_10715(s: seq): seq\n ensures |ListReverse_10715(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_10715(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_10716","instance":10716,"id":230731,"goal":"function Factorial_10716(n: nat): nat\n ensures Factorial_10716(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_10716(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_10717","instance":10717,"id":230732,"goal":"function Fib_10717(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_10717(n-1) + Fib_10717(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_10718","instance":10718,"id":230733,"goal":"function Gcd_10718(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_10718(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_10719","instance":10719,"id":230734,"goal":"function Power_10719(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_10719(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_10720","instance":10720,"id":230735,"goal":"function Sum_10720(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_10720(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_10721","instance":10721,"id":230736,"goal":"method BinarySearch_10721(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_10722","instance":10722,"id":230737,"goal":"method InsertSort_10722(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_10723","instance":10723,"id":230738,"goal":"method MergeSort_10723(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_10724","instance":10724,"id":230739,"goal":"method ArrayCopy_10724(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_10725","instance":10725,"id":230740,"goal":"function ListReverse_10725(s: seq): seq\n ensures |ListReverse_10725(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_10725(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_10726","instance":10726,"id":230741,"goal":"function Factorial_10726(n: nat): nat\n ensures Factorial_10726(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_10726(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_10727","instance":10727,"id":230742,"goal":"function Fib_10727(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_10727(n-1) + Fib_10727(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_10728","instance":10728,"id":230743,"goal":"function Gcd_10728(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_10728(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_10729","instance":10729,"id":230744,"goal":"function Power_10729(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_10729(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_10730","instance":10730,"id":230745,"goal":"function Sum_10730(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_10730(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_10731","instance":10731,"id":230746,"goal":"method BinarySearch_10731(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_10732","instance":10732,"id":230747,"goal":"method InsertSort_10732(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_10733","instance":10733,"id":230748,"goal":"method MergeSort_10733(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_10734","instance":10734,"id":230749,"goal":"method ArrayCopy_10734(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_10735","instance":10735,"id":230750,"goal":"function ListReverse_10735(s: seq): seq\n ensures |ListReverse_10735(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_10735(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_10736","instance":10736,"id":230751,"goal":"function Factorial_10736(n: nat): nat\n ensures Factorial_10736(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_10736(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_10737","instance":10737,"id":230752,"goal":"function Fib_10737(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_10737(n-1) + Fib_10737(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_10738","instance":10738,"id":230753,"goal":"function Gcd_10738(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_10738(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_10739","instance":10739,"id":230754,"goal":"function Power_10739(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_10739(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_10740","instance":10740,"id":230755,"goal":"function Sum_10740(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_10740(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_10741","instance":10741,"id":230756,"goal":"method BinarySearch_10741(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_10742","instance":10742,"id":230757,"goal":"method InsertSort_10742(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_10743","instance":10743,"id":230758,"goal":"method MergeSort_10743(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_10744","instance":10744,"id":230759,"goal":"method ArrayCopy_10744(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_10745","instance":10745,"id":230760,"goal":"function ListReverse_10745(s: seq): seq\n ensures |ListReverse_10745(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_10745(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_10746","instance":10746,"id":230761,"goal":"function Factorial_10746(n: nat): nat\n ensures Factorial_10746(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_10746(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_10747","instance":10747,"id":230762,"goal":"function Fib_10747(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_10747(n-1) + Fib_10747(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_10748","instance":10748,"id":230763,"goal":"function Gcd_10748(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_10748(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_10749","instance":10749,"id":230764,"goal":"function Power_10749(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_10749(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_10750","instance":10750,"id":230765,"goal":"function Sum_10750(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_10750(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_10751","instance":10751,"id":230766,"goal":"method BinarySearch_10751(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_10752","instance":10752,"id":230767,"goal":"method InsertSort_10752(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_10753","instance":10753,"id":230768,"goal":"method MergeSort_10753(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_10754","instance":10754,"id":230769,"goal":"method ArrayCopy_10754(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_10755","instance":10755,"id":230770,"goal":"function ListReverse_10755(s: seq): seq\n ensures |ListReverse_10755(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_10755(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_10756","instance":10756,"id":230771,"goal":"function Factorial_10756(n: nat): nat\n ensures Factorial_10756(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_10756(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_10757","instance":10757,"id":230772,"goal":"function Fib_10757(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_10757(n-1) + Fib_10757(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_10758","instance":10758,"id":230773,"goal":"function Gcd_10758(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_10758(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_10759","instance":10759,"id":230774,"goal":"function Power_10759(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_10759(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_10760","instance":10760,"id":230775,"goal":"function Sum_10760(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_10760(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_10761","instance":10761,"id":230776,"goal":"method BinarySearch_10761(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_10762","instance":10762,"id":230777,"goal":"method InsertSort_10762(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_10763","instance":10763,"id":230778,"goal":"method MergeSort_10763(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_10764","instance":10764,"id":230779,"goal":"method ArrayCopy_10764(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_10765","instance":10765,"id":230780,"goal":"function ListReverse_10765(s: seq): seq\n ensures |ListReverse_10765(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_10765(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_10766","instance":10766,"id":230781,"goal":"function Factorial_10766(n: nat): nat\n ensures Factorial_10766(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_10766(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_10767","instance":10767,"id":230782,"goal":"function Fib_10767(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_10767(n-1) + Fib_10767(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_10768","instance":10768,"id":230783,"goal":"function Gcd_10768(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_10768(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_10769","instance":10769,"id":230784,"goal":"function Power_10769(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_10769(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_10770","instance":10770,"id":230785,"goal":"function Sum_10770(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_10770(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_10771","instance":10771,"id":230786,"goal":"method BinarySearch_10771(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_10772","instance":10772,"id":230787,"goal":"method InsertSort_10772(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_10773","instance":10773,"id":230788,"goal":"method MergeSort_10773(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_10774","instance":10774,"id":230789,"goal":"method ArrayCopy_10774(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_10775","instance":10775,"id":230790,"goal":"function ListReverse_10775(s: seq): seq\n ensures |ListReverse_10775(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_10775(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_10776","instance":10776,"id":230791,"goal":"function Factorial_10776(n: nat): nat\n ensures Factorial_10776(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_10776(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_10777","instance":10777,"id":230792,"goal":"function Fib_10777(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_10777(n-1) + Fib_10777(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_10778","instance":10778,"id":230793,"goal":"function Gcd_10778(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_10778(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_10779","instance":10779,"id":230794,"goal":"function Power_10779(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_10779(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_10780","instance":10780,"id":230795,"goal":"function Sum_10780(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_10780(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_10781","instance":10781,"id":230796,"goal":"method BinarySearch_10781(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_10782","instance":10782,"id":230797,"goal":"method InsertSort_10782(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_10783","instance":10783,"id":230798,"goal":"method MergeSort_10783(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_10784","instance":10784,"id":230799,"goal":"method ArrayCopy_10784(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_10785","instance":10785,"id":230800,"goal":"function ListReverse_10785(s: seq): seq\n ensures |ListReverse_10785(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_10785(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_10786","instance":10786,"id":230801,"goal":"function Factorial_10786(n: nat): nat\n ensures Factorial_10786(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_10786(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_10787","instance":10787,"id":230802,"goal":"function Fib_10787(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_10787(n-1) + Fib_10787(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_10788","instance":10788,"id":230803,"goal":"function Gcd_10788(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_10788(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_10789","instance":10789,"id":230804,"goal":"function Power_10789(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_10789(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_10790","instance":10790,"id":230805,"goal":"function Sum_10790(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_10790(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_10791","instance":10791,"id":230806,"goal":"method BinarySearch_10791(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_10792","instance":10792,"id":230807,"goal":"method InsertSort_10792(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_10793","instance":10793,"id":230808,"goal":"method MergeSort_10793(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_10794","instance":10794,"id":230809,"goal":"method ArrayCopy_10794(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_10795","instance":10795,"id":230810,"goal":"function ListReverse_10795(s: seq): seq\n ensures |ListReverse_10795(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_10795(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_10796","instance":10796,"id":230811,"goal":"function Factorial_10796(n: nat): nat\n ensures Factorial_10796(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_10796(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_10797","instance":10797,"id":230812,"goal":"function Fib_10797(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_10797(n-1) + Fib_10797(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_10798","instance":10798,"id":230813,"goal":"function Gcd_10798(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_10798(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_10799","instance":10799,"id":230814,"goal":"function Power_10799(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_10799(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_10800","instance":10800,"id":230815,"goal":"function Sum_10800(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_10800(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_10801","instance":10801,"id":230816,"goal":"method BinarySearch_10801(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_10802","instance":10802,"id":230817,"goal":"method InsertSort_10802(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_10803","instance":10803,"id":230818,"goal":"method MergeSort_10803(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_10804","instance":10804,"id":230819,"goal":"method ArrayCopy_10804(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_10805","instance":10805,"id":230820,"goal":"function ListReverse_10805(s: seq): seq\n ensures |ListReverse_10805(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_10805(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_10806","instance":10806,"id":230821,"goal":"function Factorial_10806(n: nat): nat\n ensures Factorial_10806(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_10806(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_10807","instance":10807,"id":230822,"goal":"function Fib_10807(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_10807(n-1) + Fib_10807(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_10808","instance":10808,"id":230823,"goal":"function Gcd_10808(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_10808(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_10809","instance":10809,"id":230824,"goal":"function Power_10809(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_10809(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_10810","instance":10810,"id":230825,"goal":"function Sum_10810(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_10810(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_10811","instance":10811,"id":230826,"goal":"method BinarySearch_10811(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_10812","instance":10812,"id":230827,"goal":"method InsertSort_10812(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_10813","instance":10813,"id":230828,"goal":"method MergeSort_10813(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_10814","instance":10814,"id":230829,"goal":"method ArrayCopy_10814(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_10815","instance":10815,"id":230830,"goal":"function ListReverse_10815(s: seq): seq\n ensures |ListReverse_10815(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_10815(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_10816","instance":10816,"id":230831,"goal":"function Factorial_10816(n: nat): nat\n ensures Factorial_10816(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_10816(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_10817","instance":10817,"id":230832,"goal":"function Fib_10817(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_10817(n-1) + Fib_10817(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_10818","instance":10818,"id":230833,"goal":"function Gcd_10818(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_10818(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_10819","instance":10819,"id":230834,"goal":"function Power_10819(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_10819(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_10820","instance":10820,"id":230835,"goal":"function Sum_10820(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_10820(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_10821","instance":10821,"id":230836,"goal":"method BinarySearch_10821(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_10822","instance":10822,"id":230837,"goal":"method InsertSort_10822(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_10823","instance":10823,"id":230838,"goal":"method MergeSort_10823(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_10824","instance":10824,"id":230839,"goal":"method ArrayCopy_10824(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_10825","instance":10825,"id":230840,"goal":"function ListReverse_10825(s: seq): seq\n ensures |ListReverse_10825(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_10825(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_10826","instance":10826,"id":230841,"goal":"function Factorial_10826(n: nat): nat\n ensures Factorial_10826(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_10826(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_10827","instance":10827,"id":230842,"goal":"function Fib_10827(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_10827(n-1) + Fib_10827(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_10828","instance":10828,"id":230843,"goal":"function Gcd_10828(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_10828(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_10829","instance":10829,"id":230844,"goal":"function Power_10829(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_10829(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_10830","instance":10830,"id":230845,"goal":"function Sum_10830(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_10830(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_10831","instance":10831,"id":230846,"goal":"method BinarySearch_10831(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_10832","instance":10832,"id":230847,"goal":"method InsertSort_10832(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_10833","instance":10833,"id":230848,"goal":"method MergeSort_10833(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_10834","instance":10834,"id":230849,"goal":"method ArrayCopy_10834(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_10835","instance":10835,"id":230850,"goal":"function ListReverse_10835(s: seq): seq\n ensures |ListReverse_10835(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_10835(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_10836","instance":10836,"id":230851,"goal":"function Factorial_10836(n: nat): nat\n ensures Factorial_10836(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_10836(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_10837","instance":10837,"id":230852,"goal":"function Fib_10837(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_10837(n-1) + Fib_10837(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_10838","instance":10838,"id":230853,"goal":"function Gcd_10838(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_10838(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_10839","instance":10839,"id":230854,"goal":"function Power_10839(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_10839(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_10840","instance":10840,"id":230855,"goal":"function Sum_10840(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_10840(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_10841","instance":10841,"id":230856,"goal":"method BinarySearch_10841(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_10842","instance":10842,"id":230857,"goal":"method InsertSort_10842(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_10843","instance":10843,"id":230858,"goal":"method MergeSort_10843(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_10844","instance":10844,"id":230859,"goal":"method ArrayCopy_10844(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_10845","instance":10845,"id":230860,"goal":"function ListReverse_10845(s: seq): seq\n ensures |ListReverse_10845(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_10845(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_10846","instance":10846,"id":230861,"goal":"function Factorial_10846(n: nat): nat\n ensures Factorial_10846(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_10846(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_10847","instance":10847,"id":230862,"goal":"function Fib_10847(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_10847(n-1) + Fib_10847(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_10848","instance":10848,"id":230863,"goal":"function Gcd_10848(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_10848(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_10849","instance":10849,"id":230864,"goal":"function Power_10849(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_10849(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_10850","instance":10850,"id":230865,"goal":"function Sum_10850(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_10850(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_10851","instance":10851,"id":230866,"goal":"method BinarySearch_10851(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_10852","instance":10852,"id":230867,"goal":"method InsertSort_10852(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_10853","instance":10853,"id":230868,"goal":"method MergeSort_10853(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_10854","instance":10854,"id":230869,"goal":"method ArrayCopy_10854(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_10855","instance":10855,"id":230870,"goal":"function ListReverse_10855(s: seq): seq\n ensures |ListReverse_10855(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_10855(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_10856","instance":10856,"id":230871,"goal":"function Factorial_10856(n: nat): nat\n ensures Factorial_10856(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_10856(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_10857","instance":10857,"id":230872,"goal":"function Fib_10857(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_10857(n-1) + Fib_10857(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_10858","instance":10858,"id":230873,"goal":"function Gcd_10858(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_10858(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_10859","instance":10859,"id":230874,"goal":"function Power_10859(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_10859(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_10860","instance":10860,"id":230875,"goal":"function Sum_10860(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_10860(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_10861","instance":10861,"id":230876,"goal":"method BinarySearch_10861(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_10862","instance":10862,"id":230877,"goal":"method InsertSort_10862(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_10863","instance":10863,"id":230878,"goal":"method MergeSort_10863(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_10864","instance":10864,"id":230879,"goal":"method ArrayCopy_10864(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_10865","instance":10865,"id":230880,"goal":"function ListReverse_10865(s: seq): seq\n ensures |ListReverse_10865(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_10865(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_10866","instance":10866,"id":230881,"goal":"function Factorial_10866(n: nat): nat\n ensures Factorial_10866(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_10866(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_10867","instance":10867,"id":230882,"goal":"function Fib_10867(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_10867(n-1) + Fib_10867(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_10868","instance":10868,"id":230883,"goal":"function Gcd_10868(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_10868(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_10869","instance":10869,"id":230884,"goal":"function Power_10869(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_10869(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_10870","instance":10870,"id":230885,"goal":"function Sum_10870(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_10870(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_10871","instance":10871,"id":230886,"goal":"method BinarySearch_10871(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_10872","instance":10872,"id":230887,"goal":"method InsertSort_10872(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_10873","instance":10873,"id":230888,"goal":"method MergeSort_10873(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_10874","instance":10874,"id":230889,"goal":"method ArrayCopy_10874(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_10875","instance":10875,"id":230890,"goal":"function ListReverse_10875(s: seq): seq\n ensures |ListReverse_10875(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_10875(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_10876","instance":10876,"id":230891,"goal":"function Factorial_10876(n: nat): nat\n ensures Factorial_10876(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_10876(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_10877","instance":10877,"id":230892,"goal":"function Fib_10877(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_10877(n-1) + Fib_10877(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_10878","instance":10878,"id":230893,"goal":"function Gcd_10878(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_10878(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_10879","instance":10879,"id":230894,"goal":"function Power_10879(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_10879(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_10880","instance":10880,"id":230895,"goal":"function Sum_10880(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_10880(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_10881","instance":10881,"id":230896,"goal":"method BinarySearch_10881(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_10882","instance":10882,"id":230897,"goal":"method InsertSort_10882(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_10883","instance":10883,"id":230898,"goal":"method MergeSort_10883(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_10884","instance":10884,"id":230899,"goal":"method ArrayCopy_10884(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_10885","instance":10885,"id":230900,"goal":"function ListReverse_10885(s: seq): seq\n ensures |ListReverse_10885(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_10885(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_10886","instance":10886,"id":230901,"goal":"function Factorial_10886(n: nat): nat\n ensures Factorial_10886(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_10886(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_10887","instance":10887,"id":230902,"goal":"function Fib_10887(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_10887(n-1) + Fib_10887(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_10888","instance":10888,"id":230903,"goal":"function Gcd_10888(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_10888(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_10889","instance":10889,"id":230904,"goal":"function Power_10889(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_10889(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_10890","instance":10890,"id":230905,"goal":"function Sum_10890(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_10890(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_10891","instance":10891,"id":230906,"goal":"method BinarySearch_10891(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_10892","instance":10892,"id":230907,"goal":"method InsertSort_10892(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_10893","instance":10893,"id":230908,"goal":"method MergeSort_10893(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_10894","instance":10894,"id":230909,"goal":"method ArrayCopy_10894(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_10895","instance":10895,"id":230910,"goal":"function ListReverse_10895(s: seq): seq\n ensures |ListReverse_10895(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_10895(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_10896","instance":10896,"id":230911,"goal":"function Factorial_10896(n: nat): nat\n ensures Factorial_10896(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_10896(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_10897","instance":10897,"id":230912,"goal":"function Fib_10897(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_10897(n-1) + Fib_10897(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_10898","instance":10898,"id":230913,"goal":"function Gcd_10898(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_10898(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_10899","instance":10899,"id":230914,"goal":"function Power_10899(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_10899(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_10900","instance":10900,"id":230915,"goal":"function Sum_10900(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_10900(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_10901","instance":10901,"id":230916,"goal":"method BinarySearch_10901(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_10902","instance":10902,"id":230917,"goal":"method InsertSort_10902(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_10903","instance":10903,"id":230918,"goal":"method MergeSort_10903(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_10904","instance":10904,"id":230919,"goal":"method ArrayCopy_10904(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_10905","instance":10905,"id":230920,"goal":"function ListReverse_10905(s: seq): seq\n ensures |ListReverse_10905(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_10905(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_10906","instance":10906,"id":230921,"goal":"function Factorial_10906(n: nat): nat\n ensures Factorial_10906(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_10906(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_10907","instance":10907,"id":230922,"goal":"function Fib_10907(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_10907(n-1) + Fib_10907(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_10908","instance":10908,"id":230923,"goal":"function Gcd_10908(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_10908(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_10909","instance":10909,"id":230924,"goal":"function Power_10909(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_10909(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_10910","instance":10910,"id":230925,"goal":"function Sum_10910(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_10910(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_10911","instance":10911,"id":230926,"goal":"method BinarySearch_10911(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_10912","instance":10912,"id":230927,"goal":"method InsertSort_10912(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_10913","instance":10913,"id":230928,"goal":"method MergeSort_10913(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_10914","instance":10914,"id":230929,"goal":"method ArrayCopy_10914(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_10915","instance":10915,"id":230930,"goal":"function ListReverse_10915(s: seq): seq\n ensures |ListReverse_10915(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_10915(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_10916","instance":10916,"id":230931,"goal":"function Factorial_10916(n: nat): nat\n ensures Factorial_10916(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_10916(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_10917","instance":10917,"id":230932,"goal":"function Fib_10917(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_10917(n-1) + Fib_10917(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_10918","instance":10918,"id":230933,"goal":"function Gcd_10918(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_10918(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_10919","instance":10919,"id":230934,"goal":"function Power_10919(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_10919(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_10920","instance":10920,"id":230935,"goal":"function Sum_10920(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_10920(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_10921","instance":10921,"id":230936,"goal":"method BinarySearch_10921(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_10922","instance":10922,"id":230937,"goal":"method InsertSort_10922(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_10923","instance":10923,"id":230938,"goal":"method MergeSort_10923(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_10924","instance":10924,"id":230939,"goal":"method ArrayCopy_10924(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_10925","instance":10925,"id":230940,"goal":"function ListReverse_10925(s: seq): seq\n ensures |ListReverse_10925(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_10925(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_10926","instance":10926,"id":230941,"goal":"function Factorial_10926(n: nat): nat\n ensures Factorial_10926(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_10926(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_10927","instance":10927,"id":230942,"goal":"function Fib_10927(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_10927(n-1) + Fib_10927(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_10928","instance":10928,"id":230943,"goal":"function Gcd_10928(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_10928(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_10929","instance":10929,"id":230944,"goal":"function Power_10929(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_10929(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_10930","instance":10930,"id":230945,"goal":"function Sum_10930(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_10930(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_10931","instance":10931,"id":230946,"goal":"method BinarySearch_10931(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_10932","instance":10932,"id":230947,"goal":"method InsertSort_10932(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_10933","instance":10933,"id":230948,"goal":"method MergeSort_10933(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_10934","instance":10934,"id":230949,"goal":"method ArrayCopy_10934(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_10935","instance":10935,"id":230950,"goal":"function ListReverse_10935(s: seq): seq\n ensures |ListReverse_10935(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_10935(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_10936","instance":10936,"id":230951,"goal":"function Factorial_10936(n: nat): nat\n ensures Factorial_10936(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_10936(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_10937","instance":10937,"id":230952,"goal":"function Fib_10937(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_10937(n-1) + Fib_10937(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_10938","instance":10938,"id":230953,"goal":"function Gcd_10938(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_10938(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_10939","instance":10939,"id":230954,"goal":"function Power_10939(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_10939(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_10940","instance":10940,"id":230955,"goal":"function Sum_10940(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_10940(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_10941","instance":10941,"id":230956,"goal":"method BinarySearch_10941(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_10942","instance":10942,"id":230957,"goal":"method InsertSort_10942(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_10943","instance":10943,"id":230958,"goal":"method MergeSort_10943(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_10944","instance":10944,"id":230959,"goal":"method ArrayCopy_10944(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_10945","instance":10945,"id":230960,"goal":"function ListReverse_10945(s: seq): seq\n ensures |ListReverse_10945(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_10945(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_10946","instance":10946,"id":230961,"goal":"function Factorial_10946(n: nat): nat\n ensures Factorial_10946(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_10946(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_10947","instance":10947,"id":230962,"goal":"function Fib_10947(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_10947(n-1) + Fib_10947(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_10948","instance":10948,"id":230963,"goal":"function Gcd_10948(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_10948(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_10949","instance":10949,"id":230964,"goal":"function Power_10949(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_10949(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_10950","instance":10950,"id":230965,"goal":"function Sum_10950(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_10950(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_10951","instance":10951,"id":230966,"goal":"method BinarySearch_10951(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_10952","instance":10952,"id":230967,"goal":"method InsertSort_10952(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_10953","instance":10953,"id":230968,"goal":"method MergeSort_10953(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_10954","instance":10954,"id":230969,"goal":"method ArrayCopy_10954(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_10955","instance":10955,"id":230970,"goal":"function ListReverse_10955(s: seq): seq\n ensures |ListReverse_10955(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_10955(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_10956","instance":10956,"id":230971,"goal":"function Factorial_10956(n: nat): nat\n ensures Factorial_10956(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_10956(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_10957","instance":10957,"id":230972,"goal":"function Fib_10957(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_10957(n-1) + Fib_10957(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_10958","instance":10958,"id":230973,"goal":"function Gcd_10958(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_10958(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_10959","instance":10959,"id":230974,"goal":"function Power_10959(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_10959(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_10960","instance":10960,"id":230975,"goal":"function Sum_10960(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_10960(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_10961","instance":10961,"id":230976,"goal":"method BinarySearch_10961(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_10962","instance":10962,"id":230977,"goal":"method InsertSort_10962(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_10963","instance":10963,"id":230978,"goal":"method MergeSort_10963(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_10964","instance":10964,"id":230979,"goal":"method ArrayCopy_10964(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_10965","instance":10965,"id":230980,"goal":"function ListReverse_10965(s: seq): seq\n ensures |ListReverse_10965(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_10965(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_10966","instance":10966,"id":230981,"goal":"function Factorial_10966(n: nat): nat\n ensures Factorial_10966(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_10966(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_10967","instance":10967,"id":230982,"goal":"function Fib_10967(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_10967(n-1) + Fib_10967(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_10968","instance":10968,"id":230983,"goal":"function Gcd_10968(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_10968(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_10969","instance":10969,"id":230984,"goal":"function Power_10969(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_10969(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_10970","instance":10970,"id":230985,"goal":"function Sum_10970(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_10970(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_10971","instance":10971,"id":230986,"goal":"method BinarySearch_10971(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_10972","instance":10972,"id":230987,"goal":"method InsertSort_10972(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_10973","instance":10973,"id":230988,"goal":"method MergeSort_10973(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_10974","instance":10974,"id":230989,"goal":"method ArrayCopy_10974(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_10975","instance":10975,"id":230990,"goal":"function ListReverse_10975(s: seq): seq\n ensures |ListReverse_10975(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_10975(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_10976","instance":10976,"id":230991,"goal":"function Factorial_10976(n: nat): nat\n ensures Factorial_10976(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_10976(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_10977","instance":10977,"id":230992,"goal":"function Fib_10977(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_10977(n-1) + Fib_10977(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_10978","instance":10978,"id":230993,"goal":"function Gcd_10978(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_10978(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_10979","instance":10979,"id":230994,"goal":"function Power_10979(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_10979(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_10980","instance":10980,"id":230995,"goal":"function Sum_10980(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_10980(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_10981","instance":10981,"id":230996,"goal":"method BinarySearch_10981(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_10982","instance":10982,"id":230997,"goal":"method InsertSort_10982(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_10983","instance":10983,"id":230998,"goal":"method MergeSort_10983(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_10984","instance":10984,"id":230999,"goal":"method ArrayCopy_10984(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_10985","instance":10985,"id":231000,"goal":"function ListReverse_10985(s: seq): seq\n ensures |ListReverse_10985(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_10985(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_10986","instance":10986,"id":231001,"goal":"function Factorial_10986(n: nat): nat\n ensures Factorial_10986(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_10986(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_10987","instance":10987,"id":231002,"goal":"function Fib_10987(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_10987(n-1) + Fib_10987(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_10988","instance":10988,"id":231003,"goal":"function Gcd_10988(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_10988(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_10989","instance":10989,"id":231004,"goal":"function Power_10989(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_10989(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_10990","instance":10990,"id":231005,"goal":"function Sum_10990(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_10990(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_10991","instance":10991,"id":231006,"goal":"method BinarySearch_10991(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_10992","instance":10992,"id":231007,"goal":"method InsertSort_10992(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_10993","instance":10993,"id":231008,"goal":"method MergeSort_10993(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_10994","instance":10994,"id":231009,"goal":"method ArrayCopy_10994(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_10995","instance":10995,"id":231010,"goal":"function ListReverse_10995(s: seq): seq\n ensures |ListReverse_10995(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_10995(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_10996","instance":10996,"id":231011,"goal":"function Factorial_10996(n: nat): nat\n ensures Factorial_10996(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_10996(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_10997","instance":10997,"id":231012,"goal":"function Fib_10997(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_10997(n-1) + Fib_10997(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_10998","instance":10998,"id":231013,"goal":"function Gcd_10998(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_10998(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_10999","instance":10999,"id":231014,"goal":"function Power_10999(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_10999(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_11000","instance":11000,"id":231015,"goal":"function Sum_11000(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_11000(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_11001","instance":11001,"id":231016,"goal":"method BinarySearch_11001(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_11002","instance":11002,"id":231017,"goal":"method InsertSort_11002(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_11003","instance":11003,"id":231018,"goal":"method MergeSort_11003(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_11004","instance":11004,"id":231019,"goal":"method ArrayCopy_11004(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_11005","instance":11005,"id":231020,"goal":"function ListReverse_11005(s: seq): seq\n ensures |ListReverse_11005(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_11005(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_11006","instance":11006,"id":231021,"goal":"function Factorial_11006(n: nat): nat\n ensures Factorial_11006(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_11006(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_11007","instance":11007,"id":231022,"goal":"function Fib_11007(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_11007(n-1) + Fib_11007(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_11008","instance":11008,"id":231023,"goal":"function Gcd_11008(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_11008(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_11009","instance":11009,"id":231024,"goal":"function Power_11009(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_11009(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_11010","instance":11010,"id":231025,"goal":"function Sum_11010(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_11010(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_11011","instance":11011,"id":231026,"goal":"method BinarySearch_11011(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_11012","instance":11012,"id":231027,"goal":"method InsertSort_11012(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_11013","instance":11013,"id":231028,"goal":"method MergeSort_11013(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_11014","instance":11014,"id":231029,"goal":"method ArrayCopy_11014(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_11015","instance":11015,"id":231030,"goal":"function ListReverse_11015(s: seq): seq\n ensures |ListReverse_11015(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_11015(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_11016","instance":11016,"id":231031,"goal":"function Factorial_11016(n: nat): nat\n ensures Factorial_11016(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_11016(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_11017","instance":11017,"id":231032,"goal":"function Fib_11017(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_11017(n-1) + Fib_11017(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_11018","instance":11018,"id":231033,"goal":"function Gcd_11018(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_11018(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_11019","instance":11019,"id":231034,"goal":"function Power_11019(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_11019(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_11020","instance":11020,"id":231035,"goal":"function Sum_11020(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_11020(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_11021","instance":11021,"id":231036,"goal":"method BinarySearch_11021(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_11022","instance":11022,"id":231037,"goal":"method InsertSort_11022(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_11023","instance":11023,"id":231038,"goal":"method MergeSort_11023(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_11024","instance":11024,"id":231039,"goal":"method ArrayCopy_11024(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_11025","instance":11025,"id":231040,"goal":"function ListReverse_11025(s: seq): seq\n ensures |ListReverse_11025(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_11025(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_11026","instance":11026,"id":231041,"goal":"function Factorial_11026(n: nat): nat\n ensures Factorial_11026(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_11026(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_11027","instance":11027,"id":231042,"goal":"function Fib_11027(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_11027(n-1) + Fib_11027(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_11028","instance":11028,"id":231043,"goal":"function Gcd_11028(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_11028(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_11029","instance":11029,"id":231044,"goal":"function Power_11029(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_11029(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_11030","instance":11030,"id":231045,"goal":"function Sum_11030(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_11030(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_11031","instance":11031,"id":231046,"goal":"method BinarySearch_11031(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_11032","instance":11032,"id":231047,"goal":"method InsertSort_11032(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_11033","instance":11033,"id":231048,"goal":"method MergeSort_11033(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_11034","instance":11034,"id":231049,"goal":"method ArrayCopy_11034(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_11035","instance":11035,"id":231050,"goal":"function ListReverse_11035(s: seq): seq\n ensures |ListReverse_11035(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_11035(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_11036","instance":11036,"id":231051,"goal":"function Factorial_11036(n: nat): nat\n ensures Factorial_11036(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_11036(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_11037","instance":11037,"id":231052,"goal":"function Fib_11037(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_11037(n-1) + Fib_11037(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_11038","instance":11038,"id":231053,"goal":"function Gcd_11038(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_11038(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_11039","instance":11039,"id":231054,"goal":"function Power_11039(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_11039(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_11040","instance":11040,"id":231055,"goal":"function Sum_11040(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_11040(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_11041","instance":11041,"id":231056,"goal":"method BinarySearch_11041(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_11042","instance":11042,"id":231057,"goal":"method InsertSort_11042(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_11043","instance":11043,"id":231058,"goal":"method MergeSort_11043(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_11044","instance":11044,"id":231059,"goal":"method ArrayCopy_11044(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_11045","instance":11045,"id":231060,"goal":"function ListReverse_11045(s: seq): seq\n ensures |ListReverse_11045(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_11045(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_11046","instance":11046,"id":231061,"goal":"function Factorial_11046(n: nat): nat\n ensures Factorial_11046(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_11046(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_11047","instance":11047,"id":231062,"goal":"function Fib_11047(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_11047(n-1) + Fib_11047(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_11048","instance":11048,"id":231063,"goal":"function Gcd_11048(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_11048(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_11049","instance":11049,"id":231064,"goal":"function Power_11049(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_11049(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_11050","instance":11050,"id":231065,"goal":"function Sum_11050(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_11050(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_11051","instance":11051,"id":231066,"goal":"method BinarySearch_11051(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_11052","instance":11052,"id":231067,"goal":"method InsertSort_11052(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_11053","instance":11053,"id":231068,"goal":"method MergeSort_11053(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_11054","instance":11054,"id":231069,"goal":"method ArrayCopy_11054(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_11055","instance":11055,"id":231070,"goal":"function ListReverse_11055(s: seq): seq\n ensures |ListReverse_11055(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_11055(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_11056","instance":11056,"id":231071,"goal":"function Factorial_11056(n: nat): nat\n ensures Factorial_11056(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_11056(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_11057","instance":11057,"id":231072,"goal":"function Fib_11057(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_11057(n-1) + Fib_11057(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_11058","instance":11058,"id":231073,"goal":"function Gcd_11058(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_11058(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_11059","instance":11059,"id":231074,"goal":"function Power_11059(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_11059(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_11060","instance":11060,"id":231075,"goal":"function Sum_11060(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_11060(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_11061","instance":11061,"id":231076,"goal":"method BinarySearch_11061(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_11062","instance":11062,"id":231077,"goal":"method InsertSort_11062(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_11063","instance":11063,"id":231078,"goal":"method MergeSort_11063(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_11064","instance":11064,"id":231079,"goal":"method ArrayCopy_11064(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_11065","instance":11065,"id":231080,"goal":"function ListReverse_11065(s: seq): seq\n ensures |ListReverse_11065(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_11065(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_11066","instance":11066,"id":231081,"goal":"function Factorial_11066(n: nat): nat\n ensures Factorial_11066(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_11066(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_11067","instance":11067,"id":231082,"goal":"function Fib_11067(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_11067(n-1) + Fib_11067(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_11068","instance":11068,"id":231083,"goal":"function Gcd_11068(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_11068(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_11069","instance":11069,"id":231084,"goal":"function Power_11069(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_11069(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_11070","instance":11070,"id":231085,"goal":"function Sum_11070(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_11070(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_11071","instance":11071,"id":231086,"goal":"method BinarySearch_11071(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_11072","instance":11072,"id":231087,"goal":"method InsertSort_11072(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_11073","instance":11073,"id":231088,"goal":"method MergeSort_11073(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_11074","instance":11074,"id":231089,"goal":"method ArrayCopy_11074(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_11075","instance":11075,"id":231090,"goal":"function ListReverse_11075(s: seq): seq\n ensures |ListReverse_11075(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_11075(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_11076","instance":11076,"id":231091,"goal":"function Factorial_11076(n: nat): nat\n ensures Factorial_11076(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_11076(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_11077","instance":11077,"id":231092,"goal":"function Fib_11077(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_11077(n-1) + Fib_11077(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_11078","instance":11078,"id":231093,"goal":"function Gcd_11078(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_11078(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_11079","instance":11079,"id":231094,"goal":"function Power_11079(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_11079(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_11080","instance":11080,"id":231095,"goal":"function Sum_11080(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_11080(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_11081","instance":11081,"id":231096,"goal":"method BinarySearch_11081(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_11082","instance":11082,"id":231097,"goal":"method InsertSort_11082(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_11083","instance":11083,"id":231098,"goal":"method MergeSort_11083(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_11084","instance":11084,"id":231099,"goal":"method ArrayCopy_11084(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_11085","instance":11085,"id":231100,"goal":"function ListReverse_11085(s: seq): seq\n ensures |ListReverse_11085(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_11085(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_11086","instance":11086,"id":231101,"goal":"function Factorial_11086(n: nat): nat\n ensures Factorial_11086(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_11086(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_11087","instance":11087,"id":231102,"goal":"function Fib_11087(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_11087(n-1) + Fib_11087(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_11088","instance":11088,"id":231103,"goal":"function Gcd_11088(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_11088(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_11089","instance":11089,"id":231104,"goal":"function Power_11089(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_11089(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_11090","instance":11090,"id":231105,"goal":"function Sum_11090(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_11090(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_11091","instance":11091,"id":231106,"goal":"method BinarySearch_11091(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_11092","instance":11092,"id":231107,"goal":"method InsertSort_11092(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_11093","instance":11093,"id":231108,"goal":"method MergeSort_11093(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_11094","instance":11094,"id":231109,"goal":"method ArrayCopy_11094(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_11095","instance":11095,"id":231110,"goal":"function ListReverse_11095(s: seq): seq\n ensures |ListReverse_11095(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_11095(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_11096","instance":11096,"id":231111,"goal":"function Factorial_11096(n: nat): nat\n ensures Factorial_11096(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_11096(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_11097","instance":11097,"id":231112,"goal":"function Fib_11097(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_11097(n-1) + Fib_11097(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_11098","instance":11098,"id":231113,"goal":"function Gcd_11098(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_11098(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_11099","instance":11099,"id":231114,"goal":"function Power_11099(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_11099(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_11100","instance":11100,"id":231115,"goal":"function Sum_11100(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_11100(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_11101","instance":11101,"id":231116,"goal":"method BinarySearch_11101(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_11102","instance":11102,"id":231117,"goal":"method InsertSort_11102(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_11103","instance":11103,"id":231118,"goal":"method MergeSort_11103(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_11104","instance":11104,"id":231119,"goal":"method ArrayCopy_11104(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_11105","instance":11105,"id":231120,"goal":"function ListReverse_11105(s: seq): seq\n ensures |ListReverse_11105(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_11105(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_11106","instance":11106,"id":231121,"goal":"function Factorial_11106(n: nat): nat\n ensures Factorial_11106(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_11106(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_11107","instance":11107,"id":231122,"goal":"function Fib_11107(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_11107(n-1) + Fib_11107(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_11108","instance":11108,"id":231123,"goal":"function Gcd_11108(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_11108(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_11109","instance":11109,"id":231124,"goal":"function Power_11109(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_11109(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_11110","instance":11110,"id":231125,"goal":"function Sum_11110(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_11110(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_11111","instance":11111,"id":231126,"goal":"method BinarySearch_11111(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_11112","instance":11112,"id":231127,"goal":"method InsertSort_11112(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_11113","instance":11113,"id":231128,"goal":"method MergeSort_11113(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_11114","instance":11114,"id":231129,"goal":"method ArrayCopy_11114(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_11115","instance":11115,"id":231130,"goal":"function ListReverse_11115(s: seq): seq\n ensures |ListReverse_11115(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_11115(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_11116","instance":11116,"id":231131,"goal":"function Factorial_11116(n: nat): nat\n ensures Factorial_11116(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_11116(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_11117","instance":11117,"id":231132,"goal":"function Fib_11117(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_11117(n-1) + Fib_11117(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_11118","instance":11118,"id":231133,"goal":"function Gcd_11118(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_11118(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_11119","instance":11119,"id":231134,"goal":"function Power_11119(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_11119(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_11120","instance":11120,"id":231135,"goal":"function Sum_11120(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_11120(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_11121","instance":11121,"id":231136,"goal":"method BinarySearch_11121(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_11122","instance":11122,"id":231137,"goal":"method InsertSort_11122(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_11123","instance":11123,"id":231138,"goal":"method MergeSort_11123(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_11124","instance":11124,"id":231139,"goal":"method ArrayCopy_11124(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_11125","instance":11125,"id":231140,"goal":"function ListReverse_11125(s: seq): seq\n ensures |ListReverse_11125(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_11125(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_11126","instance":11126,"id":231141,"goal":"function Factorial_11126(n: nat): nat\n ensures Factorial_11126(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_11126(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_11127","instance":11127,"id":231142,"goal":"function Fib_11127(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_11127(n-1) + Fib_11127(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_11128","instance":11128,"id":231143,"goal":"function Gcd_11128(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_11128(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_11129","instance":11129,"id":231144,"goal":"function Power_11129(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_11129(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_11130","instance":11130,"id":231145,"goal":"function Sum_11130(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_11130(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_11131","instance":11131,"id":231146,"goal":"method BinarySearch_11131(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_11132","instance":11132,"id":231147,"goal":"method InsertSort_11132(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_11133","instance":11133,"id":231148,"goal":"method MergeSort_11133(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_11134","instance":11134,"id":231149,"goal":"method ArrayCopy_11134(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_11135","instance":11135,"id":231150,"goal":"function ListReverse_11135(s: seq): seq\n ensures |ListReverse_11135(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_11135(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_11136","instance":11136,"id":231151,"goal":"function Factorial_11136(n: nat): nat\n ensures Factorial_11136(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_11136(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_11137","instance":11137,"id":231152,"goal":"function Fib_11137(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_11137(n-1) + Fib_11137(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_11138","instance":11138,"id":231153,"goal":"function Gcd_11138(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_11138(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_11139","instance":11139,"id":231154,"goal":"function Power_11139(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_11139(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_11140","instance":11140,"id":231155,"goal":"function Sum_11140(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_11140(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_11141","instance":11141,"id":231156,"goal":"method BinarySearch_11141(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_11142","instance":11142,"id":231157,"goal":"method InsertSort_11142(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_11143","instance":11143,"id":231158,"goal":"method MergeSort_11143(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_11144","instance":11144,"id":231159,"goal":"method ArrayCopy_11144(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_11145","instance":11145,"id":231160,"goal":"function ListReverse_11145(s: seq): seq\n ensures |ListReverse_11145(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_11145(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_11146","instance":11146,"id":231161,"goal":"function Factorial_11146(n: nat): nat\n ensures Factorial_11146(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_11146(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_11147","instance":11147,"id":231162,"goal":"function Fib_11147(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_11147(n-1) + Fib_11147(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_11148","instance":11148,"id":231163,"goal":"function Gcd_11148(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_11148(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_11149","instance":11149,"id":231164,"goal":"function Power_11149(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_11149(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_11150","instance":11150,"id":231165,"goal":"function Sum_11150(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_11150(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_11151","instance":11151,"id":231166,"goal":"method BinarySearch_11151(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_11152","instance":11152,"id":231167,"goal":"method InsertSort_11152(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_11153","instance":11153,"id":231168,"goal":"method MergeSort_11153(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_11154","instance":11154,"id":231169,"goal":"method ArrayCopy_11154(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_11155","instance":11155,"id":231170,"goal":"function ListReverse_11155(s: seq): seq\n ensures |ListReverse_11155(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_11155(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_11156","instance":11156,"id":231171,"goal":"function Factorial_11156(n: nat): nat\n ensures Factorial_11156(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_11156(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_11157","instance":11157,"id":231172,"goal":"function Fib_11157(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_11157(n-1) + Fib_11157(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_11158","instance":11158,"id":231173,"goal":"function Gcd_11158(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_11158(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_11159","instance":11159,"id":231174,"goal":"function Power_11159(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_11159(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_11160","instance":11160,"id":231175,"goal":"function Sum_11160(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_11160(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_11161","instance":11161,"id":231176,"goal":"method BinarySearch_11161(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_11162","instance":11162,"id":231177,"goal":"method InsertSort_11162(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_11163","instance":11163,"id":231178,"goal":"method MergeSort_11163(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_11164","instance":11164,"id":231179,"goal":"method ArrayCopy_11164(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_11165","instance":11165,"id":231180,"goal":"function ListReverse_11165(s: seq): seq\n ensures |ListReverse_11165(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_11165(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_11166","instance":11166,"id":231181,"goal":"function Factorial_11166(n: nat): nat\n ensures Factorial_11166(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_11166(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_11167","instance":11167,"id":231182,"goal":"function Fib_11167(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_11167(n-1) + Fib_11167(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_11168","instance":11168,"id":231183,"goal":"function Gcd_11168(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_11168(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_11169","instance":11169,"id":231184,"goal":"function Power_11169(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_11169(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_11170","instance":11170,"id":231185,"goal":"function Sum_11170(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_11170(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_11171","instance":11171,"id":231186,"goal":"method BinarySearch_11171(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_11172","instance":11172,"id":231187,"goal":"method InsertSort_11172(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_11173","instance":11173,"id":231188,"goal":"method MergeSort_11173(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_11174","instance":11174,"id":231189,"goal":"method ArrayCopy_11174(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_11175","instance":11175,"id":231190,"goal":"function ListReverse_11175(s: seq): seq\n ensures |ListReverse_11175(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_11175(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_11176","instance":11176,"id":231191,"goal":"function Factorial_11176(n: nat): nat\n ensures Factorial_11176(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_11176(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_11177","instance":11177,"id":231192,"goal":"function Fib_11177(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_11177(n-1) + Fib_11177(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_11178","instance":11178,"id":231193,"goal":"function Gcd_11178(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_11178(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_11179","instance":11179,"id":231194,"goal":"function Power_11179(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_11179(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_11180","instance":11180,"id":231195,"goal":"function Sum_11180(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_11180(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_11181","instance":11181,"id":231196,"goal":"method BinarySearch_11181(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_11182","instance":11182,"id":231197,"goal":"method InsertSort_11182(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_11183","instance":11183,"id":231198,"goal":"method MergeSort_11183(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_11184","instance":11184,"id":231199,"goal":"method ArrayCopy_11184(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_11185","instance":11185,"id":231200,"goal":"function ListReverse_11185(s: seq): seq\n ensures |ListReverse_11185(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_11185(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_11186","instance":11186,"id":231201,"goal":"function Factorial_11186(n: nat): nat\n ensures Factorial_11186(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_11186(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_11187","instance":11187,"id":231202,"goal":"function Fib_11187(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_11187(n-1) + Fib_11187(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_11188","instance":11188,"id":231203,"goal":"function Gcd_11188(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_11188(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_11189","instance":11189,"id":231204,"goal":"function Power_11189(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_11189(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_11190","instance":11190,"id":231205,"goal":"function Sum_11190(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_11190(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_11191","instance":11191,"id":231206,"goal":"method BinarySearch_11191(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_11192","instance":11192,"id":231207,"goal":"method InsertSort_11192(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_11193","instance":11193,"id":231208,"goal":"method MergeSort_11193(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_11194","instance":11194,"id":231209,"goal":"method ArrayCopy_11194(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_11195","instance":11195,"id":231210,"goal":"function ListReverse_11195(s: seq): seq\n ensures |ListReverse_11195(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_11195(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_11196","instance":11196,"id":231211,"goal":"function Factorial_11196(n: nat): nat\n ensures Factorial_11196(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_11196(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_11197","instance":11197,"id":231212,"goal":"function Fib_11197(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_11197(n-1) + Fib_11197(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_11198","instance":11198,"id":231213,"goal":"function Gcd_11198(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_11198(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_11199","instance":11199,"id":231214,"goal":"function Power_11199(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_11199(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_11200","instance":11200,"id":231215,"goal":"function Sum_11200(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_11200(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_11201","instance":11201,"id":231216,"goal":"method BinarySearch_11201(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_11202","instance":11202,"id":231217,"goal":"method InsertSort_11202(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_11203","instance":11203,"id":231218,"goal":"method MergeSort_11203(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_11204","instance":11204,"id":231219,"goal":"method ArrayCopy_11204(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_11205","instance":11205,"id":231220,"goal":"function ListReverse_11205(s: seq): seq\n ensures |ListReverse_11205(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_11205(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_11206","instance":11206,"id":231221,"goal":"function Factorial_11206(n: nat): nat\n ensures Factorial_11206(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_11206(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_11207","instance":11207,"id":231222,"goal":"function Fib_11207(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_11207(n-1) + Fib_11207(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_11208","instance":11208,"id":231223,"goal":"function Gcd_11208(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_11208(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_11209","instance":11209,"id":231224,"goal":"function Power_11209(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_11209(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_11210","instance":11210,"id":231225,"goal":"function Sum_11210(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_11210(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_11211","instance":11211,"id":231226,"goal":"method BinarySearch_11211(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_11212","instance":11212,"id":231227,"goal":"method InsertSort_11212(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_11213","instance":11213,"id":231228,"goal":"method MergeSort_11213(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_11214","instance":11214,"id":231229,"goal":"method ArrayCopy_11214(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_11215","instance":11215,"id":231230,"goal":"function ListReverse_11215(s: seq): seq\n ensures |ListReverse_11215(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_11215(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_11216","instance":11216,"id":231231,"goal":"function Factorial_11216(n: nat): nat\n ensures Factorial_11216(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_11216(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_11217","instance":11217,"id":231232,"goal":"function Fib_11217(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_11217(n-1) + Fib_11217(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_11218","instance":11218,"id":231233,"goal":"function Gcd_11218(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_11218(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_11219","instance":11219,"id":231234,"goal":"function Power_11219(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_11219(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_11220","instance":11220,"id":231235,"goal":"function Sum_11220(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_11220(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_11221","instance":11221,"id":231236,"goal":"method BinarySearch_11221(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_11222","instance":11222,"id":231237,"goal":"method InsertSort_11222(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_11223","instance":11223,"id":231238,"goal":"method MergeSort_11223(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_11224","instance":11224,"id":231239,"goal":"method ArrayCopy_11224(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_11225","instance":11225,"id":231240,"goal":"function ListReverse_11225(s: seq): seq\n ensures |ListReverse_11225(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_11225(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_11226","instance":11226,"id":231241,"goal":"function Factorial_11226(n: nat): nat\n ensures Factorial_11226(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_11226(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_11227","instance":11227,"id":231242,"goal":"function Fib_11227(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_11227(n-1) + Fib_11227(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_11228","instance":11228,"id":231243,"goal":"function Gcd_11228(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_11228(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_11229","instance":11229,"id":231244,"goal":"function Power_11229(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_11229(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_11230","instance":11230,"id":231245,"goal":"function Sum_11230(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_11230(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_11231","instance":11231,"id":231246,"goal":"method BinarySearch_11231(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_11232","instance":11232,"id":231247,"goal":"method InsertSort_11232(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_11233","instance":11233,"id":231248,"goal":"method MergeSort_11233(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_11234","instance":11234,"id":231249,"goal":"method ArrayCopy_11234(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_11235","instance":11235,"id":231250,"goal":"function ListReverse_11235(s: seq): seq\n ensures |ListReverse_11235(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_11235(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_11236","instance":11236,"id":231251,"goal":"function Factorial_11236(n: nat): nat\n ensures Factorial_11236(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_11236(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_11237","instance":11237,"id":231252,"goal":"function Fib_11237(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_11237(n-1) + Fib_11237(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_11238","instance":11238,"id":231253,"goal":"function Gcd_11238(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_11238(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_11239","instance":11239,"id":231254,"goal":"function Power_11239(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_11239(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_11240","instance":11240,"id":231255,"goal":"function Sum_11240(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_11240(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_11241","instance":11241,"id":231256,"goal":"method BinarySearch_11241(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_11242","instance":11242,"id":231257,"goal":"method InsertSort_11242(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_11243","instance":11243,"id":231258,"goal":"method MergeSort_11243(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_11244","instance":11244,"id":231259,"goal":"method ArrayCopy_11244(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_11245","instance":11245,"id":231260,"goal":"function ListReverse_11245(s: seq): seq\n ensures |ListReverse_11245(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_11245(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_11246","instance":11246,"id":231261,"goal":"function Factorial_11246(n: nat): nat\n ensures Factorial_11246(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_11246(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_11247","instance":11247,"id":231262,"goal":"function Fib_11247(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_11247(n-1) + Fib_11247(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_11248","instance":11248,"id":231263,"goal":"function Gcd_11248(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_11248(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_11249","instance":11249,"id":231264,"goal":"function Power_11249(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_11249(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_11250","instance":11250,"id":231265,"goal":"function Sum_11250(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_11250(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_11251","instance":11251,"id":231266,"goal":"method BinarySearch_11251(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_11252","instance":11252,"id":231267,"goal":"method InsertSort_11252(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_11253","instance":11253,"id":231268,"goal":"method MergeSort_11253(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_11254","instance":11254,"id":231269,"goal":"method ArrayCopy_11254(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_11255","instance":11255,"id":231270,"goal":"function ListReverse_11255(s: seq): seq\n ensures |ListReverse_11255(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_11255(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_11256","instance":11256,"id":231271,"goal":"function Factorial_11256(n: nat): nat\n ensures Factorial_11256(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_11256(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_11257","instance":11257,"id":231272,"goal":"function Fib_11257(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_11257(n-1) + Fib_11257(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_11258","instance":11258,"id":231273,"goal":"function Gcd_11258(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_11258(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_11259","instance":11259,"id":231274,"goal":"function Power_11259(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_11259(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_11260","instance":11260,"id":231275,"goal":"function Sum_11260(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_11260(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_11261","instance":11261,"id":231276,"goal":"method BinarySearch_11261(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_11262","instance":11262,"id":231277,"goal":"method InsertSort_11262(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_11263","instance":11263,"id":231278,"goal":"method MergeSort_11263(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_11264","instance":11264,"id":231279,"goal":"method ArrayCopy_11264(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_11265","instance":11265,"id":231280,"goal":"function ListReverse_11265(s: seq): seq\n ensures |ListReverse_11265(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_11265(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_11266","instance":11266,"id":231281,"goal":"function Factorial_11266(n: nat): nat\n ensures Factorial_11266(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_11266(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_11267","instance":11267,"id":231282,"goal":"function Fib_11267(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_11267(n-1) + Fib_11267(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_11268","instance":11268,"id":231283,"goal":"function Gcd_11268(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_11268(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_11269","instance":11269,"id":231284,"goal":"function Power_11269(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_11269(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_11270","instance":11270,"id":231285,"goal":"function Sum_11270(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_11270(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_11271","instance":11271,"id":231286,"goal":"method BinarySearch_11271(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_11272","instance":11272,"id":231287,"goal":"method InsertSort_11272(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_11273","instance":11273,"id":231288,"goal":"method MergeSort_11273(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_11274","instance":11274,"id":231289,"goal":"method ArrayCopy_11274(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_11275","instance":11275,"id":231290,"goal":"function ListReverse_11275(s: seq): seq\n ensures |ListReverse_11275(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_11275(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_11276","instance":11276,"id":231291,"goal":"function Factorial_11276(n: nat): nat\n ensures Factorial_11276(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_11276(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_11277","instance":11277,"id":231292,"goal":"function Fib_11277(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_11277(n-1) + Fib_11277(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_11278","instance":11278,"id":231293,"goal":"function Gcd_11278(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_11278(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_11279","instance":11279,"id":231294,"goal":"function Power_11279(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_11279(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_11280","instance":11280,"id":231295,"goal":"function Sum_11280(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_11280(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_11281","instance":11281,"id":231296,"goal":"method BinarySearch_11281(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_11282","instance":11282,"id":231297,"goal":"method InsertSort_11282(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_11283","instance":11283,"id":231298,"goal":"method MergeSort_11283(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_11284","instance":11284,"id":231299,"goal":"method ArrayCopy_11284(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_11285","instance":11285,"id":231300,"goal":"function ListReverse_11285(s: seq): seq\n ensures |ListReverse_11285(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_11285(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_11286","instance":11286,"id":231301,"goal":"function Factorial_11286(n: nat): nat\n ensures Factorial_11286(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_11286(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_11287","instance":11287,"id":231302,"goal":"function Fib_11287(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_11287(n-1) + Fib_11287(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_11288","instance":11288,"id":231303,"goal":"function Gcd_11288(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_11288(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_11289","instance":11289,"id":231304,"goal":"function Power_11289(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_11289(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_11290","instance":11290,"id":231305,"goal":"function Sum_11290(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_11290(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_11291","instance":11291,"id":231306,"goal":"method BinarySearch_11291(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_11292","instance":11292,"id":231307,"goal":"method InsertSort_11292(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_11293","instance":11293,"id":231308,"goal":"method MergeSort_11293(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_11294","instance":11294,"id":231309,"goal":"method ArrayCopy_11294(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_11295","instance":11295,"id":231310,"goal":"function ListReverse_11295(s: seq): seq\n ensures |ListReverse_11295(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_11295(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_11296","instance":11296,"id":231311,"goal":"function Factorial_11296(n: nat): nat\n ensures Factorial_11296(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_11296(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_11297","instance":11297,"id":231312,"goal":"function Fib_11297(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_11297(n-1) + Fib_11297(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_11298","instance":11298,"id":231313,"goal":"function Gcd_11298(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_11298(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_11299","instance":11299,"id":231314,"goal":"function Power_11299(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_11299(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_11300","instance":11300,"id":231315,"goal":"function Sum_11300(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_11300(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_11301","instance":11301,"id":231316,"goal":"method BinarySearch_11301(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_11302","instance":11302,"id":231317,"goal":"method InsertSort_11302(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_11303","instance":11303,"id":231318,"goal":"method MergeSort_11303(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_11304","instance":11304,"id":231319,"goal":"method ArrayCopy_11304(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_11305","instance":11305,"id":231320,"goal":"function ListReverse_11305(s: seq): seq\n ensures |ListReverse_11305(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_11305(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_11306","instance":11306,"id":231321,"goal":"function Factorial_11306(n: nat): nat\n ensures Factorial_11306(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_11306(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_11307","instance":11307,"id":231322,"goal":"function Fib_11307(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_11307(n-1) + Fib_11307(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_11308","instance":11308,"id":231323,"goal":"function Gcd_11308(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_11308(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_11309","instance":11309,"id":231324,"goal":"function Power_11309(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_11309(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_11310","instance":11310,"id":231325,"goal":"function Sum_11310(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_11310(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_11311","instance":11311,"id":231326,"goal":"method BinarySearch_11311(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_11312","instance":11312,"id":231327,"goal":"method InsertSort_11312(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_11313","instance":11313,"id":231328,"goal":"method MergeSort_11313(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_11314","instance":11314,"id":231329,"goal":"method ArrayCopy_11314(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_11315","instance":11315,"id":231330,"goal":"function ListReverse_11315(s: seq): seq\n ensures |ListReverse_11315(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_11315(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_11316","instance":11316,"id":231331,"goal":"function Factorial_11316(n: nat): nat\n ensures Factorial_11316(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_11316(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_11317","instance":11317,"id":231332,"goal":"function Fib_11317(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_11317(n-1) + Fib_11317(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_11318","instance":11318,"id":231333,"goal":"function Gcd_11318(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_11318(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_11319","instance":11319,"id":231334,"goal":"function Power_11319(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_11319(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_11320","instance":11320,"id":231335,"goal":"function Sum_11320(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_11320(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_11321","instance":11321,"id":231336,"goal":"method BinarySearch_11321(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_11322","instance":11322,"id":231337,"goal":"method InsertSort_11322(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_11323","instance":11323,"id":231338,"goal":"method MergeSort_11323(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_11324","instance":11324,"id":231339,"goal":"method ArrayCopy_11324(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_11325","instance":11325,"id":231340,"goal":"function ListReverse_11325(s: seq): seq\n ensures |ListReverse_11325(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_11325(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_11326","instance":11326,"id":231341,"goal":"function Factorial_11326(n: nat): nat\n ensures Factorial_11326(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_11326(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_11327","instance":11327,"id":231342,"goal":"function Fib_11327(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_11327(n-1) + Fib_11327(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_11328","instance":11328,"id":231343,"goal":"function Gcd_11328(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_11328(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_11329","instance":11329,"id":231344,"goal":"function Power_11329(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_11329(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_11330","instance":11330,"id":231345,"goal":"function Sum_11330(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_11330(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_11331","instance":11331,"id":231346,"goal":"method BinarySearch_11331(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_11332","instance":11332,"id":231347,"goal":"method InsertSort_11332(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_11333","instance":11333,"id":231348,"goal":"method MergeSort_11333(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_11334","instance":11334,"id":231349,"goal":"method ArrayCopy_11334(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_11335","instance":11335,"id":231350,"goal":"function ListReverse_11335(s: seq): seq\n ensures |ListReverse_11335(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_11335(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_11336","instance":11336,"id":231351,"goal":"function Factorial_11336(n: nat): nat\n ensures Factorial_11336(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_11336(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_11337","instance":11337,"id":231352,"goal":"function Fib_11337(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_11337(n-1) + Fib_11337(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_11338","instance":11338,"id":231353,"goal":"function Gcd_11338(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_11338(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_11339","instance":11339,"id":231354,"goal":"function Power_11339(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_11339(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_11340","instance":11340,"id":231355,"goal":"function Sum_11340(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_11340(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_11341","instance":11341,"id":231356,"goal":"method BinarySearch_11341(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_11342","instance":11342,"id":231357,"goal":"method InsertSort_11342(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_11343","instance":11343,"id":231358,"goal":"method MergeSort_11343(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_11344","instance":11344,"id":231359,"goal":"method ArrayCopy_11344(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_11345","instance":11345,"id":231360,"goal":"function ListReverse_11345(s: seq): seq\n ensures |ListReverse_11345(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_11345(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_11346","instance":11346,"id":231361,"goal":"function Factorial_11346(n: nat): nat\n ensures Factorial_11346(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_11346(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_11347","instance":11347,"id":231362,"goal":"function Fib_11347(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_11347(n-1) + Fib_11347(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_11348","instance":11348,"id":231363,"goal":"function Gcd_11348(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_11348(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_11349","instance":11349,"id":231364,"goal":"function Power_11349(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_11349(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_11350","instance":11350,"id":231365,"goal":"function Sum_11350(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_11350(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_11351","instance":11351,"id":231366,"goal":"method BinarySearch_11351(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_11352","instance":11352,"id":231367,"goal":"method InsertSort_11352(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_11353","instance":11353,"id":231368,"goal":"method MergeSort_11353(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_11354","instance":11354,"id":231369,"goal":"method ArrayCopy_11354(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_11355","instance":11355,"id":231370,"goal":"function ListReverse_11355(s: seq): seq\n ensures |ListReverse_11355(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_11355(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_11356","instance":11356,"id":231371,"goal":"function Factorial_11356(n: nat): nat\n ensures Factorial_11356(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_11356(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_11357","instance":11357,"id":231372,"goal":"function Fib_11357(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_11357(n-1) + Fib_11357(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_11358","instance":11358,"id":231373,"goal":"function Gcd_11358(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_11358(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_11359","instance":11359,"id":231374,"goal":"function Power_11359(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_11359(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_11360","instance":11360,"id":231375,"goal":"function Sum_11360(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_11360(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_11361","instance":11361,"id":231376,"goal":"method BinarySearch_11361(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_11362","instance":11362,"id":231377,"goal":"method InsertSort_11362(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_11363","instance":11363,"id":231378,"goal":"method MergeSort_11363(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_11364","instance":11364,"id":231379,"goal":"method ArrayCopy_11364(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_11365","instance":11365,"id":231380,"goal":"function ListReverse_11365(s: seq): seq\n ensures |ListReverse_11365(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_11365(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_11366","instance":11366,"id":231381,"goal":"function Factorial_11366(n: nat): nat\n ensures Factorial_11366(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_11366(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_11367","instance":11367,"id":231382,"goal":"function Fib_11367(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_11367(n-1) + Fib_11367(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_11368","instance":11368,"id":231383,"goal":"function Gcd_11368(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_11368(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_11369","instance":11369,"id":231384,"goal":"function Power_11369(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_11369(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_11370","instance":11370,"id":231385,"goal":"function Sum_11370(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_11370(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_11371","instance":11371,"id":231386,"goal":"method BinarySearch_11371(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_11372","instance":11372,"id":231387,"goal":"method InsertSort_11372(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_11373","instance":11373,"id":231388,"goal":"method MergeSort_11373(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_11374","instance":11374,"id":231389,"goal":"method ArrayCopy_11374(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_11375","instance":11375,"id":231390,"goal":"function ListReverse_11375(s: seq): seq\n ensures |ListReverse_11375(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_11375(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_11376","instance":11376,"id":231391,"goal":"function Factorial_11376(n: nat): nat\n ensures Factorial_11376(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_11376(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_11377","instance":11377,"id":231392,"goal":"function Fib_11377(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_11377(n-1) + Fib_11377(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_11378","instance":11378,"id":231393,"goal":"function Gcd_11378(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_11378(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_11379","instance":11379,"id":231394,"goal":"function Power_11379(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_11379(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_11380","instance":11380,"id":231395,"goal":"function Sum_11380(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_11380(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_11381","instance":11381,"id":231396,"goal":"method BinarySearch_11381(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_11382","instance":11382,"id":231397,"goal":"method InsertSort_11382(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_11383","instance":11383,"id":231398,"goal":"method MergeSort_11383(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_11384","instance":11384,"id":231399,"goal":"method ArrayCopy_11384(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_11385","instance":11385,"id":231400,"goal":"function ListReverse_11385(s: seq): seq\n ensures |ListReverse_11385(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_11385(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_11386","instance":11386,"id":231401,"goal":"function Factorial_11386(n: nat): nat\n ensures Factorial_11386(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_11386(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_11387","instance":11387,"id":231402,"goal":"function Fib_11387(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_11387(n-1) + Fib_11387(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_11388","instance":11388,"id":231403,"goal":"function Gcd_11388(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_11388(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_11389","instance":11389,"id":231404,"goal":"function Power_11389(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_11389(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_11390","instance":11390,"id":231405,"goal":"function Sum_11390(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_11390(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_11391","instance":11391,"id":231406,"goal":"method BinarySearch_11391(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_11392","instance":11392,"id":231407,"goal":"method InsertSort_11392(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_11393","instance":11393,"id":231408,"goal":"method MergeSort_11393(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_11394","instance":11394,"id":231409,"goal":"method ArrayCopy_11394(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_11395","instance":11395,"id":231410,"goal":"function ListReverse_11395(s: seq): seq\n ensures |ListReverse_11395(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_11395(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_11396","instance":11396,"id":231411,"goal":"function Factorial_11396(n: nat): nat\n ensures Factorial_11396(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_11396(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_11397","instance":11397,"id":231412,"goal":"function Fib_11397(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_11397(n-1) + Fib_11397(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_11398","instance":11398,"id":231413,"goal":"function Gcd_11398(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_11398(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_11399","instance":11399,"id":231414,"goal":"function Power_11399(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_11399(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_11400","instance":11400,"id":231415,"goal":"function Sum_11400(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_11400(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_11401","instance":11401,"id":231416,"goal":"method BinarySearch_11401(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_11402","instance":11402,"id":231417,"goal":"method InsertSort_11402(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_11403","instance":11403,"id":231418,"goal":"method MergeSort_11403(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_11404","instance":11404,"id":231419,"goal":"method ArrayCopy_11404(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_11405","instance":11405,"id":231420,"goal":"function ListReverse_11405(s: seq): seq\n ensures |ListReverse_11405(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_11405(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_11406","instance":11406,"id":231421,"goal":"function Factorial_11406(n: nat): nat\n ensures Factorial_11406(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_11406(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_11407","instance":11407,"id":231422,"goal":"function Fib_11407(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_11407(n-1) + Fib_11407(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_11408","instance":11408,"id":231423,"goal":"function Gcd_11408(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_11408(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_11409","instance":11409,"id":231424,"goal":"function Power_11409(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_11409(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_11410","instance":11410,"id":231425,"goal":"function Sum_11410(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_11410(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_11411","instance":11411,"id":231426,"goal":"method BinarySearch_11411(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_11412","instance":11412,"id":231427,"goal":"method InsertSort_11412(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_11413","instance":11413,"id":231428,"goal":"method MergeSort_11413(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_11414","instance":11414,"id":231429,"goal":"method ArrayCopy_11414(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_11415","instance":11415,"id":231430,"goal":"function ListReverse_11415(s: seq): seq\n ensures |ListReverse_11415(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_11415(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_11416","instance":11416,"id":231431,"goal":"function Factorial_11416(n: nat): nat\n ensures Factorial_11416(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_11416(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_11417","instance":11417,"id":231432,"goal":"function Fib_11417(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_11417(n-1) + Fib_11417(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_11418","instance":11418,"id":231433,"goal":"function Gcd_11418(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_11418(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_11419","instance":11419,"id":231434,"goal":"function Power_11419(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_11419(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_11420","instance":11420,"id":231435,"goal":"function Sum_11420(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_11420(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_11421","instance":11421,"id":231436,"goal":"method BinarySearch_11421(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_11422","instance":11422,"id":231437,"goal":"method InsertSort_11422(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_11423","instance":11423,"id":231438,"goal":"method MergeSort_11423(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_11424","instance":11424,"id":231439,"goal":"method ArrayCopy_11424(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_11425","instance":11425,"id":231440,"goal":"function ListReverse_11425(s: seq): seq\n ensures |ListReverse_11425(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_11425(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_11426","instance":11426,"id":231441,"goal":"function Factorial_11426(n: nat): nat\n ensures Factorial_11426(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_11426(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_11427","instance":11427,"id":231442,"goal":"function Fib_11427(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_11427(n-1) + Fib_11427(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_11428","instance":11428,"id":231443,"goal":"function Gcd_11428(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_11428(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_11429","instance":11429,"id":231444,"goal":"function Power_11429(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_11429(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_11430","instance":11430,"id":231445,"goal":"function Sum_11430(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_11430(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_11431","instance":11431,"id":231446,"goal":"method BinarySearch_11431(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_11432","instance":11432,"id":231447,"goal":"method InsertSort_11432(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_11433","instance":11433,"id":231448,"goal":"method MergeSort_11433(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_11434","instance":11434,"id":231449,"goal":"method ArrayCopy_11434(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_11435","instance":11435,"id":231450,"goal":"function ListReverse_11435(s: seq): seq\n ensures |ListReverse_11435(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_11435(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_11436","instance":11436,"id":231451,"goal":"function Factorial_11436(n: nat): nat\n ensures Factorial_11436(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_11436(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_11437","instance":11437,"id":231452,"goal":"function Fib_11437(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_11437(n-1) + Fib_11437(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_11438","instance":11438,"id":231453,"goal":"function Gcd_11438(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_11438(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_11439","instance":11439,"id":231454,"goal":"function Power_11439(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_11439(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_11440","instance":11440,"id":231455,"goal":"function Sum_11440(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_11440(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_11441","instance":11441,"id":231456,"goal":"method BinarySearch_11441(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_11442","instance":11442,"id":231457,"goal":"method InsertSort_11442(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_11443","instance":11443,"id":231458,"goal":"method MergeSort_11443(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_11444","instance":11444,"id":231459,"goal":"method ArrayCopy_11444(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_11445","instance":11445,"id":231460,"goal":"function ListReverse_11445(s: seq): seq\n ensures |ListReverse_11445(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_11445(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_11446","instance":11446,"id":231461,"goal":"function Factorial_11446(n: nat): nat\n ensures Factorial_11446(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_11446(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_11447","instance":11447,"id":231462,"goal":"function Fib_11447(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_11447(n-1) + Fib_11447(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_11448","instance":11448,"id":231463,"goal":"function Gcd_11448(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_11448(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_11449","instance":11449,"id":231464,"goal":"function Power_11449(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_11449(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_11450","instance":11450,"id":231465,"goal":"function Sum_11450(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_11450(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_11451","instance":11451,"id":231466,"goal":"method BinarySearch_11451(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_11452","instance":11452,"id":231467,"goal":"method InsertSort_11452(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_11453","instance":11453,"id":231468,"goal":"method MergeSort_11453(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_11454","instance":11454,"id":231469,"goal":"method ArrayCopy_11454(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_11455","instance":11455,"id":231470,"goal":"function ListReverse_11455(s: seq): seq\n ensures |ListReverse_11455(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_11455(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_11456","instance":11456,"id":231471,"goal":"function Factorial_11456(n: nat): nat\n ensures Factorial_11456(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_11456(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_11457","instance":11457,"id":231472,"goal":"function Fib_11457(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_11457(n-1) + Fib_11457(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_11458","instance":11458,"id":231473,"goal":"function Gcd_11458(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_11458(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_11459","instance":11459,"id":231474,"goal":"function Power_11459(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_11459(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_11460","instance":11460,"id":231475,"goal":"function Sum_11460(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_11460(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_11461","instance":11461,"id":231476,"goal":"method BinarySearch_11461(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_11462","instance":11462,"id":231477,"goal":"method InsertSort_11462(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_11463","instance":11463,"id":231478,"goal":"method MergeSort_11463(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_11464","instance":11464,"id":231479,"goal":"method ArrayCopy_11464(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_11465","instance":11465,"id":231480,"goal":"function ListReverse_11465(s: seq): seq\n ensures |ListReverse_11465(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_11465(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_11466","instance":11466,"id":231481,"goal":"function Factorial_11466(n: nat): nat\n ensures Factorial_11466(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_11466(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_11467","instance":11467,"id":231482,"goal":"function Fib_11467(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_11467(n-1) + Fib_11467(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_11468","instance":11468,"id":231483,"goal":"function Gcd_11468(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_11468(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_11469","instance":11469,"id":231484,"goal":"function Power_11469(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_11469(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_11470","instance":11470,"id":231485,"goal":"function Sum_11470(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_11470(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_11471","instance":11471,"id":231486,"goal":"method BinarySearch_11471(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_11472","instance":11472,"id":231487,"goal":"method InsertSort_11472(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_11473","instance":11473,"id":231488,"goal":"method MergeSort_11473(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_11474","instance":11474,"id":231489,"goal":"method ArrayCopy_11474(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_11475","instance":11475,"id":231490,"goal":"function ListReverse_11475(s: seq): seq\n ensures |ListReverse_11475(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_11475(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_11476","instance":11476,"id":231491,"goal":"function Factorial_11476(n: nat): nat\n ensures Factorial_11476(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_11476(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_11477","instance":11477,"id":231492,"goal":"function Fib_11477(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_11477(n-1) + Fib_11477(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_11478","instance":11478,"id":231493,"goal":"function Gcd_11478(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_11478(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_11479","instance":11479,"id":231494,"goal":"function Power_11479(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_11479(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_11480","instance":11480,"id":231495,"goal":"function Sum_11480(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_11480(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_11481","instance":11481,"id":231496,"goal":"method BinarySearch_11481(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_11482","instance":11482,"id":231497,"goal":"method InsertSort_11482(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_11483","instance":11483,"id":231498,"goal":"method MergeSort_11483(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_11484","instance":11484,"id":231499,"goal":"method ArrayCopy_11484(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_11485","instance":11485,"id":231500,"goal":"function ListReverse_11485(s: seq): seq\n ensures |ListReverse_11485(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_11485(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_11486","instance":11486,"id":231501,"goal":"function Factorial_11486(n: nat): nat\n ensures Factorial_11486(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_11486(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_11487","instance":11487,"id":231502,"goal":"function Fib_11487(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_11487(n-1) + Fib_11487(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_11488","instance":11488,"id":231503,"goal":"function Gcd_11488(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_11488(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_11489","instance":11489,"id":231504,"goal":"function Power_11489(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_11489(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_11490","instance":11490,"id":231505,"goal":"function Sum_11490(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_11490(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_11491","instance":11491,"id":231506,"goal":"method BinarySearch_11491(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_11492","instance":11492,"id":231507,"goal":"method InsertSort_11492(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_11493","instance":11493,"id":231508,"goal":"method MergeSort_11493(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_11494","instance":11494,"id":231509,"goal":"method ArrayCopy_11494(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_11495","instance":11495,"id":231510,"goal":"function ListReverse_11495(s: seq): seq\n ensures |ListReverse_11495(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_11495(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_11496","instance":11496,"id":231511,"goal":"function Factorial_11496(n: nat): nat\n ensures Factorial_11496(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_11496(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_11497","instance":11497,"id":231512,"goal":"function Fib_11497(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_11497(n-1) + Fib_11497(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_11498","instance":11498,"id":231513,"goal":"function Gcd_11498(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_11498(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_11499","instance":11499,"id":231514,"goal":"function Power_11499(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_11499(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_11500","instance":11500,"id":231515,"goal":"function Sum_11500(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_11500(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_11501","instance":11501,"id":231516,"goal":"method BinarySearch_11501(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_11502","instance":11502,"id":231517,"goal":"method InsertSort_11502(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_11503","instance":11503,"id":231518,"goal":"method MergeSort_11503(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_11504","instance":11504,"id":231519,"goal":"method ArrayCopy_11504(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_11505","instance":11505,"id":231520,"goal":"function ListReverse_11505(s: seq): seq\n ensures |ListReverse_11505(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_11505(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_11506","instance":11506,"id":231521,"goal":"function Factorial_11506(n: nat): nat\n ensures Factorial_11506(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_11506(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_11507","instance":11507,"id":231522,"goal":"function Fib_11507(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_11507(n-1) + Fib_11507(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_11508","instance":11508,"id":231523,"goal":"function Gcd_11508(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_11508(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_11509","instance":11509,"id":231524,"goal":"function Power_11509(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_11509(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_11510","instance":11510,"id":231525,"goal":"function Sum_11510(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_11510(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_11511","instance":11511,"id":231526,"goal":"method BinarySearch_11511(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_11512","instance":11512,"id":231527,"goal":"method InsertSort_11512(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_11513","instance":11513,"id":231528,"goal":"method MergeSort_11513(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_11514","instance":11514,"id":231529,"goal":"method ArrayCopy_11514(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_11515","instance":11515,"id":231530,"goal":"function ListReverse_11515(s: seq): seq\n ensures |ListReverse_11515(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_11515(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_11516","instance":11516,"id":231531,"goal":"function Factorial_11516(n: nat): nat\n ensures Factorial_11516(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_11516(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_11517","instance":11517,"id":231532,"goal":"function Fib_11517(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_11517(n-1) + Fib_11517(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_11518","instance":11518,"id":231533,"goal":"function Gcd_11518(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_11518(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_11519","instance":11519,"id":231534,"goal":"function Power_11519(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_11519(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_11520","instance":11520,"id":231535,"goal":"function Sum_11520(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_11520(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_11521","instance":11521,"id":231536,"goal":"method BinarySearch_11521(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_11522","instance":11522,"id":231537,"goal":"method InsertSort_11522(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_11523","instance":11523,"id":231538,"goal":"method MergeSort_11523(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_11524","instance":11524,"id":231539,"goal":"method ArrayCopy_11524(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_11525","instance":11525,"id":231540,"goal":"function ListReverse_11525(s: seq): seq\n ensures |ListReverse_11525(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_11525(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_11526","instance":11526,"id":231541,"goal":"function Factorial_11526(n: nat): nat\n ensures Factorial_11526(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_11526(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_11527","instance":11527,"id":231542,"goal":"function Fib_11527(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_11527(n-1) + Fib_11527(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_11528","instance":11528,"id":231543,"goal":"function Gcd_11528(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_11528(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_11529","instance":11529,"id":231544,"goal":"function Power_11529(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_11529(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_11530","instance":11530,"id":231545,"goal":"function Sum_11530(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_11530(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_11531","instance":11531,"id":231546,"goal":"method BinarySearch_11531(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_11532","instance":11532,"id":231547,"goal":"method InsertSort_11532(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_11533","instance":11533,"id":231548,"goal":"method MergeSort_11533(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_11534","instance":11534,"id":231549,"goal":"method ArrayCopy_11534(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_11535","instance":11535,"id":231550,"goal":"function ListReverse_11535(s: seq): seq\n ensures |ListReverse_11535(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_11535(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_11536","instance":11536,"id":231551,"goal":"function Factorial_11536(n: nat): nat\n ensures Factorial_11536(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_11536(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_11537","instance":11537,"id":231552,"goal":"function Fib_11537(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_11537(n-1) + Fib_11537(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_11538","instance":11538,"id":231553,"goal":"function Gcd_11538(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_11538(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_11539","instance":11539,"id":231554,"goal":"function Power_11539(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_11539(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_11540","instance":11540,"id":231555,"goal":"function Sum_11540(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_11540(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_11541","instance":11541,"id":231556,"goal":"method BinarySearch_11541(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_11542","instance":11542,"id":231557,"goal":"method InsertSort_11542(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_11543","instance":11543,"id":231558,"goal":"method MergeSort_11543(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_11544","instance":11544,"id":231559,"goal":"method ArrayCopy_11544(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_11545","instance":11545,"id":231560,"goal":"function ListReverse_11545(s: seq): seq\n ensures |ListReverse_11545(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_11545(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_11546","instance":11546,"id":231561,"goal":"function Factorial_11546(n: nat): nat\n ensures Factorial_11546(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_11546(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_11547","instance":11547,"id":231562,"goal":"function Fib_11547(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_11547(n-1) + Fib_11547(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_11548","instance":11548,"id":231563,"goal":"function Gcd_11548(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_11548(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_11549","instance":11549,"id":231564,"goal":"function Power_11549(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_11549(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_11550","instance":11550,"id":231565,"goal":"function Sum_11550(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_11550(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_11551","instance":11551,"id":231566,"goal":"method BinarySearch_11551(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_11552","instance":11552,"id":231567,"goal":"method InsertSort_11552(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_11553","instance":11553,"id":231568,"goal":"method MergeSort_11553(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_11554","instance":11554,"id":231569,"goal":"method ArrayCopy_11554(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_11555","instance":11555,"id":231570,"goal":"function ListReverse_11555(s: seq): seq\n ensures |ListReverse_11555(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_11555(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_11556","instance":11556,"id":231571,"goal":"function Factorial_11556(n: nat): nat\n ensures Factorial_11556(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_11556(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_11557","instance":11557,"id":231572,"goal":"function Fib_11557(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_11557(n-1) + Fib_11557(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_11558","instance":11558,"id":231573,"goal":"function Gcd_11558(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_11558(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_11559","instance":11559,"id":231574,"goal":"function Power_11559(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_11559(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_11560","instance":11560,"id":231575,"goal":"function Sum_11560(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_11560(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_11561","instance":11561,"id":231576,"goal":"method BinarySearch_11561(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_11562","instance":11562,"id":231577,"goal":"method InsertSort_11562(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_11563","instance":11563,"id":231578,"goal":"method MergeSort_11563(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_11564","instance":11564,"id":231579,"goal":"method ArrayCopy_11564(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_11565","instance":11565,"id":231580,"goal":"function ListReverse_11565(s: seq): seq\n ensures |ListReverse_11565(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_11565(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_11566","instance":11566,"id":231581,"goal":"function Factorial_11566(n: nat): nat\n ensures Factorial_11566(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_11566(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_11567","instance":11567,"id":231582,"goal":"function Fib_11567(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_11567(n-1) + Fib_11567(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_11568","instance":11568,"id":231583,"goal":"function Gcd_11568(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_11568(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_11569","instance":11569,"id":231584,"goal":"function Power_11569(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_11569(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_11570","instance":11570,"id":231585,"goal":"function Sum_11570(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_11570(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_11571","instance":11571,"id":231586,"goal":"method BinarySearch_11571(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_11572","instance":11572,"id":231587,"goal":"method InsertSort_11572(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_11573","instance":11573,"id":231588,"goal":"method MergeSort_11573(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_11574","instance":11574,"id":231589,"goal":"method ArrayCopy_11574(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_11575","instance":11575,"id":231590,"goal":"function ListReverse_11575(s: seq): seq\n ensures |ListReverse_11575(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_11575(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_11576","instance":11576,"id":231591,"goal":"function Factorial_11576(n: nat): nat\n ensures Factorial_11576(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_11576(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_11577","instance":11577,"id":231592,"goal":"function Fib_11577(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_11577(n-1) + Fib_11577(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_11578","instance":11578,"id":231593,"goal":"function Gcd_11578(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_11578(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_11579","instance":11579,"id":231594,"goal":"function Power_11579(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_11579(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_11580","instance":11580,"id":231595,"goal":"function Sum_11580(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_11580(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_11581","instance":11581,"id":231596,"goal":"method BinarySearch_11581(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_11582","instance":11582,"id":231597,"goal":"method InsertSort_11582(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_11583","instance":11583,"id":231598,"goal":"method MergeSort_11583(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_11584","instance":11584,"id":231599,"goal":"method ArrayCopy_11584(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_11585","instance":11585,"id":231600,"goal":"function ListReverse_11585(s: seq): seq\n ensures |ListReverse_11585(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_11585(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_11586","instance":11586,"id":231601,"goal":"function Factorial_11586(n: nat): nat\n ensures Factorial_11586(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_11586(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_11587","instance":11587,"id":231602,"goal":"function Fib_11587(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_11587(n-1) + Fib_11587(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_11588","instance":11588,"id":231603,"goal":"function Gcd_11588(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_11588(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_11589","instance":11589,"id":231604,"goal":"function Power_11589(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_11589(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_11590","instance":11590,"id":231605,"goal":"function Sum_11590(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_11590(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_11591","instance":11591,"id":231606,"goal":"method BinarySearch_11591(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_11592","instance":11592,"id":231607,"goal":"method InsertSort_11592(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_11593","instance":11593,"id":231608,"goal":"method MergeSort_11593(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_11594","instance":11594,"id":231609,"goal":"method ArrayCopy_11594(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_11595","instance":11595,"id":231610,"goal":"function ListReverse_11595(s: seq): seq\n ensures |ListReverse_11595(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_11595(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_11596","instance":11596,"id":231611,"goal":"function Factorial_11596(n: nat): nat\n ensures Factorial_11596(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_11596(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_11597","instance":11597,"id":231612,"goal":"function Fib_11597(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_11597(n-1) + Fib_11597(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_11598","instance":11598,"id":231613,"goal":"function Gcd_11598(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_11598(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_11599","instance":11599,"id":231614,"goal":"function Power_11599(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_11599(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_11600","instance":11600,"id":231615,"goal":"function Sum_11600(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_11600(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_11601","instance":11601,"id":231616,"goal":"method BinarySearch_11601(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_11602","instance":11602,"id":231617,"goal":"method InsertSort_11602(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_11603","instance":11603,"id":231618,"goal":"method MergeSort_11603(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_11604","instance":11604,"id":231619,"goal":"method ArrayCopy_11604(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_11605","instance":11605,"id":231620,"goal":"function ListReverse_11605(s: seq): seq\n ensures |ListReverse_11605(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_11605(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_11606","instance":11606,"id":231621,"goal":"function Factorial_11606(n: nat): nat\n ensures Factorial_11606(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_11606(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_11607","instance":11607,"id":231622,"goal":"function Fib_11607(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_11607(n-1) + Fib_11607(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_11608","instance":11608,"id":231623,"goal":"function Gcd_11608(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_11608(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_11609","instance":11609,"id":231624,"goal":"function Power_11609(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_11609(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_11610","instance":11610,"id":231625,"goal":"function Sum_11610(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_11610(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_11611","instance":11611,"id":231626,"goal":"method BinarySearch_11611(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_11612","instance":11612,"id":231627,"goal":"method InsertSort_11612(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_11613","instance":11613,"id":231628,"goal":"method MergeSort_11613(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_11614","instance":11614,"id":231629,"goal":"method ArrayCopy_11614(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_11615","instance":11615,"id":231630,"goal":"function ListReverse_11615(s: seq): seq\n ensures |ListReverse_11615(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_11615(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_11616","instance":11616,"id":231631,"goal":"function Factorial_11616(n: nat): nat\n ensures Factorial_11616(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_11616(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_11617","instance":11617,"id":231632,"goal":"function Fib_11617(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_11617(n-1) + Fib_11617(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_11618","instance":11618,"id":231633,"goal":"function Gcd_11618(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_11618(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_11619","instance":11619,"id":231634,"goal":"function Power_11619(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_11619(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_11620","instance":11620,"id":231635,"goal":"function Sum_11620(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_11620(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_11621","instance":11621,"id":231636,"goal":"method BinarySearch_11621(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_11622","instance":11622,"id":231637,"goal":"method InsertSort_11622(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_11623","instance":11623,"id":231638,"goal":"method MergeSort_11623(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_11624","instance":11624,"id":231639,"goal":"method ArrayCopy_11624(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_11625","instance":11625,"id":231640,"goal":"function ListReverse_11625(s: seq): seq\n ensures |ListReverse_11625(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_11625(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_11626","instance":11626,"id":231641,"goal":"function Factorial_11626(n: nat): nat\n ensures Factorial_11626(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_11626(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_11627","instance":11627,"id":231642,"goal":"function Fib_11627(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_11627(n-1) + Fib_11627(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_11628","instance":11628,"id":231643,"goal":"function Gcd_11628(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_11628(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_11629","instance":11629,"id":231644,"goal":"function Power_11629(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_11629(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_11630","instance":11630,"id":231645,"goal":"function Sum_11630(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_11630(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_11631","instance":11631,"id":231646,"goal":"method BinarySearch_11631(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_11632","instance":11632,"id":231647,"goal":"method InsertSort_11632(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_11633","instance":11633,"id":231648,"goal":"method MergeSort_11633(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_11634","instance":11634,"id":231649,"goal":"method ArrayCopy_11634(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_11635","instance":11635,"id":231650,"goal":"function ListReverse_11635(s: seq): seq\n ensures |ListReverse_11635(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_11635(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_11636","instance":11636,"id":231651,"goal":"function Factorial_11636(n: nat): nat\n ensures Factorial_11636(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_11636(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_11637","instance":11637,"id":231652,"goal":"function Fib_11637(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_11637(n-1) + Fib_11637(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_11638","instance":11638,"id":231653,"goal":"function Gcd_11638(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_11638(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_11639","instance":11639,"id":231654,"goal":"function Power_11639(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_11639(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_11640","instance":11640,"id":231655,"goal":"function Sum_11640(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_11640(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_11641","instance":11641,"id":231656,"goal":"method BinarySearch_11641(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_11642","instance":11642,"id":231657,"goal":"method InsertSort_11642(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_11643","instance":11643,"id":231658,"goal":"method MergeSort_11643(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_11644","instance":11644,"id":231659,"goal":"method ArrayCopy_11644(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_11645","instance":11645,"id":231660,"goal":"function ListReverse_11645(s: seq): seq\n ensures |ListReverse_11645(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_11645(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_11646","instance":11646,"id":231661,"goal":"function Factorial_11646(n: nat): nat\n ensures Factorial_11646(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_11646(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_11647","instance":11647,"id":231662,"goal":"function Fib_11647(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_11647(n-1) + Fib_11647(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_11648","instance":11648,"id":231663,"goal":"function Gcd_11648(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_11648(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_11649","instance":11649,"id":231664,"goal":"function Power_11649(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_11649(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_11650","instance":11650,"id":231665,"goal":"function Sum_11650(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_11650(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_11651","instance":11651,"id":231666,"goal":"method BinarySearch_11651(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_11652","instance":11652,"id":231667,"goal":"method InsertSort_11652(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_11653","instance":11653,"id":231668,"goal":"method MergeSort_11653(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_11654","instance":11654,"id":231669,"goal":"method ArrayCopy_11654(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_11655","instance":11655,"id":231670,"goal":"function ListReverse_11655(s: seq): seq\n ensures |ListReverse_11655(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_11655(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_11656","instance":11656,"id":231671,"goal":"function Factorial_11656(n: nat): nat\n ensures Factorial_11656(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_11656(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_11657","instance":11657,"id":231672,"goal":"function Fib_11657(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_11657(n-1) + Fib_11657(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_11658","instance":11658,"id":231673,"goal":"function Gcd_11658(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_11658(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_11659","instance":11659,"id":231674,"goal":"function Power_11659(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_11659(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_11660","instance":11660,"id":231675,"goal":"function Sum_11660(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_11660(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_11661","instance":11661,"id":231676,"goal":"method BinarySearch_11661(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_11662","instance":11662,"id":231677,"goal":"method InsertSort_11662(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_11663","instance":11663,"id":231678,"goal":"method MergeSort_11663(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_11664","instance":11664,"id":231679,"goal":"method ArrayCopy_11664(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_11665","instance":11665,"id":231680,"goal":"function ListReverse_11665(s: seq): seq\n ensures |ListReverse_11665(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_11665(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_11666","instance":11666,"id":231681,"goal":"function Factorial_11666(n: nat): nat\n ensures Factorial_11666(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_11666(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_11667","instance":11667,"id":231682,"goal":"function Fib_11667(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_11667(n-1) + Fib_11667(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_11668","instance":11668,"id":231683,"goal":"function Gcd_11668(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_11668(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_11669","instance":11669,"id":231684,"goal":"function Power_11669(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_11669(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_11670","instance":11670,"id":231685,"goal":"function Sum_11670(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_11670(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_11671","instance":11671,"id":231686,"goal":"method BinarySearch_11671(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_11672","instance":11672,"id":231687,"goal":"method InsertSort_11672(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_11673","instance":11673,"id":231688,"goal":"method MergeSort_11673(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_11674","instance":11674,"id":231689,"goal":"method ArrayCopy_11674(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_11675","instance":11675,"id":231690,"goal":"function ListReverse_11675(s: seq): seq\n ensures |ListReverse_11675(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_11675(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_11676","instance":11676,"id":231691,"goal":"function Factorial_11676(n: nat): nat\n ensures Factorial_11676(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_11676(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_11677","instance":11677,"id":231692,"goal":"function Fib_11677(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_11677(n-1) + Fib_11677(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_11678","instance":11678,"id":231693,"goal":"function Gcd_11678(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_11678(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_11679","instance":11679,"id":231694,"goal":"function Power_11679(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_11679(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_11680","instance":11680,"id":231695,"goal":"function Sum_11680(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_11680(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_11681","instance":11681,"id":231696,"goal":"method BinarySearch_11681(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_11682","instance":11682,"id":231697,"goal":"method InsertSort_11682(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_11683","instance":11683,"id":231698,"goal":"method MergeSort_11683(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_11684","instance":11684,"id":231699,"goal":"method ArrayCopy_11684(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_11685","instance":11685,"id":231700,"goal":"function ListReverse_11685(s: seq): seq\n ensures |ListReverse_11685(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_11685(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_11686","instance":11686,"id":231701,"goal":"function Factorial_11686(n: nat): nat\n ensures Factorial_11686(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_11686(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_11687","instance":11687,"id":231702,"goal":"function Fib_11687(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_11687(n-1) + Fib_11687(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_11688","instance":11688,"id":231703,"goal":"function Gcd_11688(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_11688(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_11689","instance":11689,"id":231704,"goal":"function Power_11689(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_11689(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_11690","instance":11690,"id":231705,"goal":"function Sum_11690(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_11690(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_11691","instance":11691,"id":231706,"goal":"method BinarySearch_11691(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_11692","instance":11692,"id":231707,"goal":"method InsertSort_11692(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_11693","instance":11693,"id":231708,"goal":"method MergeSort_11693(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_11694","instance":11694,"id":231709,"goal":"method ArrayCopy_11694(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_11695","instance":11695,"id":231710,"goal":"function ListReverse_11695(s: seq): seq\n ensures |ListReverse_11695(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_11695(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_11696","instance":11696,"id":231711,"goal":"function Factorial_11696(n: nat): nat\n ensures Factorial_11696(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_11696(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_11697","instance":11697,"id":231712,"goal":"function Fib_11697(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_11697(n-1) + Fib_11697(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_11698","instance":11698,"id":231713,"goal":"function Gcd_11698(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_11698(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_11699","instance":11699,"id":231714,"goal":"function Power_11699(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_11699(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_11700","instance":11700,"id":231715,"goal":"function Sum_11700(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_11700(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_11701","instance":11701,"id":231716,"goal":"method BinarySearch_11701(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_11702","instance":11702,"id":231717,"goal":"method InsertSort_11702(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_11703","instance":11703,"id":231718,"goal":"method MergeSort_11703(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_11704","instance":11704,"id":231719,"goal":"method ArrayCopy_11704(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_11705","instance":11705,"id":231720,"goal":"function ListReverse_11705(s: seq): seq\n ensures |ListReverse_11705(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_11705(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_11706","instance":11706,"id":231721,"goal":"function Factorial_11706(n: nat): nat\n ensures Factorial_11706(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_11706(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_11707","instance":11707,"id":231722,"goal":"function Fib_11707(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_11707(n-1) + Fib_11707(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_11708","instance":11708,"id":231723,"goal":"function Gcd_11708(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_11708(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_11709","instance":11709,"id":231724,"goal":"function Power_11709(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_11709(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_11710","instance":11710,"id":231725,"goal":"function Sum_11710(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_11710(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_11711","instance":11711,"id":231726,"goal":"method BinarySearch_11711(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_11712","instance":11712,"id":231727,"goal":"method InsertSort_11712(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_11713","instance":11713,"id":231728,"goal":"method MergeSort_11713(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_11714","instance":11714,"id":231729,"goal":"method ArrayCopy_11714(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_11715","instance":11715,"id":231730,"goal":"function ListReverse_11715(s: seq): seq\n ensures |ListReverse_11715(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_11715(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_11716","instance":11716,"id":231731,"goal":"function Factorial_11716(n: nat): nat\n ensures Factorial_11716(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_11716(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_11717","instance":11717,"id":231732,"goal":"function Fib_11717(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_11717(n-1) + Fib_11717(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_11718","instance":11718,"id":231733,"goal":"function Gcd_11718(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_11718(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_11719","instance":11719,"id":231734,"goal":"function Power_11719(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_11719(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_11720","instance":11720,"id":231735,"goal":"function Sum_11720(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_11720(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_11721","instance":11721,"id":231736,"goal":"method BinarySearch_11721(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_11722","instance":11722,"id":231737,"goal":"method InsertSort_11722(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_11723","instance":11723,"id":231738,"goal":"method MergeSort_11723(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_11724","instance":11724,"id":231739,"goal":"method ArrayCopy_11724(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_11725","instance":11725,"id":231740,"goal":"function ListReverse_11725(s: seq): seq\n ensures |ListReverse_11725(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_11725(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_11726","instance":11726,"id":231741,"goal":"function Factorial_11726(n: nat): nat\n ensures Factorial_11726(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_11726(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_11727","instance":11727,"id":231742,"goal":"function Fib_11727(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_11727(n-1) + Fib_11727(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_11728","instance":11728,"id":231743,"goal":"function Gcd_11728(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_11728(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_11729","instance":11729,"id":231744,"goal":"function Power_11729(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_11729(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_11730","instance":11730,"id":231745,"goal":"function Sum_11730(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_11730(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_11731","instance":11731,"id":231746,"goal":"method BinarySearch_11731(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_11732","instance":11732,"id":231747,"goal":"method InsertSort_11732(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_11733","instance":11733,"id":231748,"goal":"method MergeSort_11733(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_11734","instance":11734,"id":231749,"goal":"method ArrayCopy_11734(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_11735","instance":11735,"id":231750,"goal":"function ListReverse_11735(s: seq): seq\n ensures |ListReverse_11735(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_11735(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_11736","instance":11736,"id":231751,"goal":"function Factorial_11736(n: nat): nat\n ensures Factorial_11736(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_11736(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_11737","instance":11737,"id":231752,"goal":"function Fib_11737(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_11737(n-1) + Fib_11737(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_11738","instance":11738,"id":231753,"goal":"function Gcd_11738(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_11738(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_11739","instance":11739,"id":231754,"goal":"function Power_11739(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_11739(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_11740","instance":11740,"id":231755,"goal":"function Sum_11740(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_11740(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_11741","instance":11741,"id":231756,"goal":"method BinarySearch_11741(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_11742","instance":11742,"id":231757,"goal":"method InsertSort_11742(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_11743","instance":11743,"id":231758,"goal":"method MergeSort_11743(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_11744","instance":11744,"id":231759,"goal":"method ArrayCopy_11744(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_11745","instance":11745,"id":231760,"goal":"function ListReverse_11745(s: seq): seq\n ensures |ListReverse_11745(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_11745(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_11746","instance":11746,"id":231761,"goal":"function Factorial_11746(n: nat): nat\n ensures Factorial_11746(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_11746(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_11747","instance":11747,"id":231762,"goal":"function Fib_11747(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_11747(n-1) + Fib_11747(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_11748","instance":11748,"id":231763,"goal":"function Gcd_11748(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_11748(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_11749","instance":11749,"id":231764,"goal":"function Power_11749(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_11749(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_11750","instance":11750,"id":231765,"goal":"function Sum_11750(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_11750(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_11751","instance":11751,"id":231766,"goal":"method BinarySearch_11751(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_11752","instance":11752,"id":231767,"goal":"method InsertSort_11752(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_11753","instance":11753,"id":231768,"goal":"method MergeSort_11753(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_11754","instance":11754,"id":231769,"goal":"method ArrayCopy_11754(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_11755","instance":11755,"id":231770,"goal":"function ListReverse_11755(s: seq): seq\n ensures |ListReverse_11755(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_11755(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_11756","instance":11756,"id":231771,"goal":"function Factorial_11756(n: nat): nat\n ensures Factorial_11756(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_11756(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_11757","instance":11757,"id":231772,"goal":"function Fib_11757(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_11757(n-1) + Fib_11757(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_11758","instance":11758,"id":231773,"goal":"function Gcd_11758(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_11758(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_11759","instance":11759,"id":231774,"goal":"function Power_11759(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_11759(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_11760","instance":11760,"id":231775,"goal":"function Sum_11760(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_11760(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_11761","instance":11761,"id":231776,"goal":"method BinarySearch_11761(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_11762","instance":11762,"id":231777,"goal":"method InsertSort_11762(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_11763","instance":11763,"id":231778,"goal":"method MergeSort_11763(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_11764","instance":11764,"id":231779,"goal":"method ArrayCopy_11764(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_11765","instance":11765,"id":231780,"goal":"function ListReverse_11765(s: seq): seq\n ensures |ListReverse_11765(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_11765(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_11766","instance":11766,"id":231781,"goal":"function Factorial_11766(n: nat): nat\n ensures Factorial_11766(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_11766(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_11767","instance":11767,"id":231782,"goal":"function Fib_11767(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_11767(n-1) + Fib_11767(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_11768","instance":11768,"id":231783,"goal":"function Gcd_11768(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_11768(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_11769","instance":11769,"id":231784,"goal":"function Power_11769(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_11769(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_11770","instance":11770,"id":231785,"goal":"function Sum_11770(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_11770(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_11771","instance":11771,"id":231786,"goal":"method BinarySearch_11771(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_11772","instance":11772,"id":231787,"goal":"method InsertSort_11772(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_11773","instance":11773,"id":231788,"goal":"method MergeSort_11773(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_11774","instance":11774,"id":231789,"goal":"method ArrayCopy_11774(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_11775","instance":11775,"id":231790,"goal":"function ListReverse_11775(s: seq): seq\n ensures |ListReverse_11775(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_11775(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_11776","instance":11776,"id":231791,"goal":"function Factorial_11776(n: nat): nat\n ensures Factorial_11776(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_11776(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_11777","instance":11777,"id":231792,"goal":"function Fib_11777(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_11777(n-1) + Fib_11777(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_11778","instance":11778,"id":231793,"goal":"function Gcd_11778(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_11778(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_11779","instance":11779,"id":231794,"goal":"function Power_11779(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_11779(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_11780","instance":11780,"id":231795,"goal":"function Sum_11780(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_11780(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_11781","instance":11781,"id":231796,"goal":"method BinarySearch_11781(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_11782","instance":11782,"id":231797,"goal":"method InsertSort_11782(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_11783","instance":11783,"id":231798,"goal":"method MergeSort_11783(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_11784","instance":11784,"id":231799,"goal":"method ArrayCopy_11784(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_11785","instance":11785,"id":231800,"goal":"function ListReverse_11785(s: seq): seq\n ensures |ListReverse_11785(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_11785(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_11786","instance":11786,"id":231801,"goal":"function Factorial_11786(n: nat): nat\n ensures Factorial_11786(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_11786(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_11787","instance":11787,"id":231802,"goal":"function Fib_11787(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_11787(n-1) + Fib_11787(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_11788","instance":11788,"id":231803,"goal":"function Gcd_11788(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_11788(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_11789","instance":11789,"id":231804,"goal":"function Power_11789(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_11789(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_11790","instance":11790,"id":231805,"goal":"function Sum_11790(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_11790(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_11791","instance":11791,"id":231806,"goal":"method BinarySearch_11791(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_11792","instance":11792,"id":231807,"goal":"method InsertSort_11792(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_11793","instance":11793,"id":231808,"goal":"method MergeSort_11793(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_11794","instance":11794,"id":231809,"goal":"method ArrayCopy_11794(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_11795","instance":11795,"id":231810,"goal":"function ListReverse_11795(s: seq): seq\n ensures |ListReverse_11795(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_11795(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_11796","instance":11796,"id":231811,"goal":"function Factorial_11796(n: nat): nat\n ensures Factorial_11796(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_11796(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_11797","instance":11797,"id":231812,"goal":"function Fib_11797(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_11797(n-1) + Fib_11797(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_11798","instance":11798,"id":231813,"goal":"function Gcd_11798(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_11798(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_11799","instance":11799,"id":231814,"goal":"function Power_11799(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_11799(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_11800","instance":11800,"id":231815,"goal":"function Sum_11800(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_11800(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_11801","instance":11801,"id":231816,"goal":"method BinarySearch_11801(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_11802","instance":11802,"id":231817,"goal":"method InsertSort_11802(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_11803","instance":11803,"id":231818,"goal":"method MergeSort_11803(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_11804","instance":11804,"id":231819,"goal":"method ArrayCopy_11804(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_11805","instance":11805,"id":231820,"goal":"function ListReverse_11805(s: seq): seq\n ensures |ListReverse_11805(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_11805(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_11806","instance":11806,"id":231821,"goal":"function Factorial_11806(n: nat): nat\n ensures Factorial_11806(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_11806(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_11807","instance":11807,"id":231822,"goal":"function Fib_11807(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_11807(n-1) + Fib_11807(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_11808","instance":11808,"id":231823,"goal":"function Gcd_11808(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_11808(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_11809","instance":11809,"id":231824,"goal":"function Power_11809(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_11809(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_11810","instance":11810,"id":231825,"goal":"function Sum_11810(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_11810(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_11811","instance":11811,"id":231826,"goal":"method BinarySearch_11811(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_11812","instance":11812,"id":231827,"goal":"method InsertSort_11812(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_11813","instance":11813,"id":231828,"goal":"method MergeSort_11813(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_11814","instance":11814,"id":231829,"goal":"method ArrayCopy_11814(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_11815","instance":11815,"id":231830,"goal":"function ListReverse_11815(s: seq): seq\n ensures |ListReverse_11815(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_11815(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_11816","instance":11816,"id":231831,"goal":"function Factorial_11816(n: nat): nat\n ensures Factorial_11816(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_11816(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_11817","instance":11817,"id":231832,"goal":"function Fib_11817(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_11817(n-1) + Fib_11817(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_11818","instance":11818,"id":231833,"goal":"function Gcd_11818(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_11818(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_11819","instance":11819,"id":231834,"goal":"function Power_11819(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_11819(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_11820","instance":11820,"id":231835,"goal":"function Sum_11820(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_11820(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_11821","instance":11821,"id":231836,"goal":"method BinarySearch_11821(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_11822","instance":11822,"id":231837,"goal":"method InsertSort_11822(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_11823","instance":11823,"id":231838,"goal":"method MergeSort_11823(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_11824","instance":11824,"id":231839,"goal":"method ArrayCopy_11824(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_11825","instance":11825,"id":231840,"goal":"function ListReverse_11825(s: seq): seq\n ensures |ListReverse_11825(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_11825(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_11826","instance":11826,"id":231841,"goal":"function Factorial_11826(n: nat): nat\n ensures Factorial_11826(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_11826(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_11827","instance":11827,"id":231842,"goal":"function Fib_11827(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_11827(n-1) + Fib_11827(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_11828","instance":11828,"id":231843,"goal":"function Gcd_11828(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_11828(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_11829","instance":11829,"id":231844,"goal":"function Power_11829(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_11829(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_11830","instance":11830,"id":231845,"goal":"function Sum_11830(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_11830(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_11831","instance":11831,"id":231846,"goal":"method BinarySearch_11831(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_11832","instance":11832,"id":231847,"goal":"method InsertSort_11832(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_11833","instance":11833,"id":231848,"goal":"method MergeSort_11833(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_11834","instance":11834,"id":231849,"goal":"method ArrayCopy_11834(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_11835","instance":11835,"id":231850,"goal":"function ListReverse_11835(s: seq): seq\n ensures |ListReverse_11835(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_11835(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_11836","instance":11836,"id":231851,"goal":"function Factorial_11836(n: nat): nat\n ensures Factorial_11836(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_11836(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_11837","instance":11837,"id":231852,"goal":"function Fib_11837(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_11837(n-1) + Fib_11837(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_11838","instance":11838,"id":231853,"goal":"function Gcd_11838(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_11838(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_11839","instance":11839,"id":231854,"goal":"function Power_11839(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_11839(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_11840","instance":11840,"id":231855,"goal":"function Sum_11840(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_11840(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_11841","instance":11841,"id":231856,"goal":"method BinarySearch_11841(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_11842","instance":11842,"id":231857,"goal":"method InsertSort_11842(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_11843","instance":11843,"id":231858,"goal":"method MergeSort_11843(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_11844","instance":11844,"id":231859,"goal":"method ArrayCopy_11844(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_11845","instance":11845,"id":231860,"goal":"function ListReverse_11845(s: seq): seq\n ensures |ListReverse_11845(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_11845(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_11846","instance":11846,"id":231861,"goal":"function Factorial_11846(n: nat): nat\n ensures Factorial_11846(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_11846(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_11847","instance":11847,"id":231862,"goal":"function Fib_11847(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_11847(n-1) + Fib_11847(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_11848","instance":11848,"id":231863,"goal":"function Gcd_11848(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_11848(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_11849","instance":11849,"id":231864,"goal":"function Power_11849(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_11849(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_11850","instance":11850,"id":231865,"goal":"function Sum_11850(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_11850(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_11851","instance":11851,"id":231866,"goal":"method BinarySearch_11851(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_11852","instance":11852,"id":231867,"goal":"method InsertSort_11852(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_11853","instance":11853,"id":231868,"goal":"method MergeSort_11853(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_11854","instance":11854,"id":231869,"goal":"method ArrayCopy_11854(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_11855","instance":11855,"id":231870,"goal":"function ListReverse_11855(s: seq): seq\n ensures |ListReverse_11855(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_11855(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_11856","instance":11856,"id":231871,"goal":"function Factorial_11856(n: nat): nat\n ensures Factorial_11856(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_11856(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_11857","instance":11857,"id":231872,"goal":"function Fib_11857(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_11857(n-1) + Fib_11857(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_11858","instance":11858,"id":231873,"goal":"function Gcd_11858(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_11858(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_11859","instance":11859,"id":231874,"goal":"function Power_11859(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_11859(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_11860","instance":11860,"id":231875,"goal":"function Sum_11860(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_11860(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_11861","instance":11861,"id":231876,"goal":"method BinarySearch_11861(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_11862","instance":11862,"id":231877,"goal":"method InsertSort_11862(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_11863","instance":11863,"id":231878,"goal":"method MergeSort_11863(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_11864","instance":11864,"id":231879,"goal":"method ArrayCopy_11864(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_11865","instance":11865,"id":231880,"goal":"function ListReverse_11865(s: seq): seq\n ensures |ListReverse_11865(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_11865(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_11866","instance":11866,"id":231881,"goal":"function Factorial_11866(n: nat): nat\n ensures Factorial_11866(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_11866(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_11867","instance":11867,"id":231882,"goal":"function Fib_11867(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_11867(n-1) + Fib_11867(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_11868","instance":11868,"id":231883,"goal":"function Gcd_11868(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_11868(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_11869","instance":11869,"id":231884,"goal":"function Power_11869(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_11869(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_11870","instance":11870,"id":231885,"goal":"function Sum_11870(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_11870(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_11871","instance":11871,"id":231886,"goal":"method BinarySearch_11871(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_11872","instance":11872,"id":231887,"goal":"method InsertSort_11872(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_11873","instance":11873,"id":231888,"goal":"method MergeSort_11873(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_11874","instance":11874,"id":231889,"goal":"method ArrayCopy_11874(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_11875","instance":11875,"id":231890,"goal":"function ListReverse_11875(s: seq): seq\n ensures |ListReverse_11875(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_11875(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_11876","instance":11876,"id":231891,"goal":"function Factorial_11876(n: nat): nat\n ensures Factorial_11876(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_11876(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_11877","instance":11877,"id":231892,"goal":"function Fib_11877(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_11877(n-1) + Fib_11877(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_11878","instance":11878,"id":231893,"goal":"function Gcd_11878(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_11878(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_11879","instance":11879,"id":231894,"goal":"function Power_11879(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_11879(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_11880","instance":11880,"id":231895,"goal":"function Sum_11880(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_11880(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_11881","instance":11881,"id":231896,"goal":"method BinarySearch_11881(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_11882","instance":11882,"id":231897,"goal":"method InsertSort_11882(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_11883","instance":11883,"id":231898,"goal":"method MergeSort_11883(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_11884","instance":11884,"id":231899,"goal":"method ArrayCopy_11884(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_11885","instance":11885,"id":231900,"goal":"function ListReverse_11885(s: seq): seq\n ensures |ListReverse_11885(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_11885(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_11886","instance":11886,"id":231901,"goal":"function Factorial_11886(n: nat): nat\n ensures Factorial_11886(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_11886(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_11887","instance":11887,"id":231902,"goal":"function Fib_11887(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_11887(n-1) + Fib_11887(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_11888","instance":11888,"id":231903,"goal":"function Gcd_11888(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_11888(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_11889","instance":11889,"id":231904,"goal":"function Power_11889(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_11889(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_11890","instance":11890,"id":231905,"goal":"function Sum_11890(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_11890(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_11891","instance":11891,"id":231906,"goal":"method BinarySearch_11891(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_11892","instance":11892,"id":231907,"goal":"method InsertSort_11892(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_11893","instance":11893,"id":231908,"goal":"method MergeSort_11893(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_11894","instance":11894,"id":231909,"goal":"method ArrayCopy_11894(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_11895","instance":11895,"id":231910,"goal":"function ListReverse_11895(s: seq): seq\n ensures |ListReverse_11895(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_11895(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_11896","instance":11896,"id":231911,"goal":"function Factorial_11896(n: nat): nat\n ensures Factorial_11896(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_11896(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_11897","instance":11897,"id":231912,"goal":"function Fib_11897(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_11897(n-1) + Fib_11897(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_11898","instance":11898,"id":231913,"goal":"function Gcd_11898(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_11898(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_11899","instance":11899,"id":231914,"goal":"function Power_11899(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_11899(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_11900","instance":11900,"id":231915,"goal":"function Sum_11900(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_11900(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_11901","instance":11901,"id":231916,"goal":"method BinarySearch_11901(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_11902","instance":11902,"id":231917,"goal":"method InsertSort_11902(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_11903","instance":11903,"id":231918,"goal":"method MergeSort_11903(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_11904","instance":11904,"id":231919,"goal":"method ArrayCopy_11904(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_11905","instance":11905,"id":231920,"goal":"function ListReverse_11905(s: seq): seq\n ensures |ListReverse_11905(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_11905(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_11906","instance":11906,"id":231921,"goal":"function Factorial_11906(n: nat): nat\n ensures Factorial_11906(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_11906(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_11907","instance":11907,"id":231922,"goal":"function Fib_11907(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_11907(n-1) + Fib_11907(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_11908","instance":11908,"id":231923,"goal":"function Gcd_11908(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_11908(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_11909","instance":11909,"id":231924,"goal":"function Power_11909(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_11909(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_11910","instance":11910,"id":231925,"goal":"function Sum_11910(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_11910(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_11911","instance":11911,"id":231926,"goal":"method BinarySearch_11911(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_11912","instance":11912,"id":231927,"goal":"method InsertSort_11912(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_11913","instance":11913,"id":231928,"goal":"method MergeSort_11913(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_11914","instance":11914,"id":231929,"goal":"method ArrayCopy_11914(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_11915","instance":11915,"id":231930,"goal":"function ListReverse_11915(s: seq): seq\n ensures |ListReverse_11915(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_11915(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_11916","instance":11916,"id":231931,"goal":"function Factorial_11916(n: nat): nat\n ensures Factorial_11916(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_11916(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_11917","instance":11917,"id":231932,"goal":"function Fib_11917(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_11917(n-1) + Fib_11917(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_11918","instance":11918,"id":231933,"goal":"function Gcd_11918(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_11918(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_11919","instance":11919,"id":231934,"goal":"function Power_11919(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_11919(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_11920","instance":11920,"id":231935,"goal":"function Sum_11920(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_11920(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_11921","instance":11921,"id":231936,"goal":"method BinarySearch_11921(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_11922","instance":11922,"id":231937,"goal":"method InsertSort_11922(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_11923","instance":11923,"id":231938,"goal":"method MergeSort_11923(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_11924","instance":11924,"id":231939,"goal":"method ArrayCopy_11924(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_11925","instance":11925,"id":231940,"goal":"function ListReverse_11925(s: seq): seq\n ensures |ListReverse_11925(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_11925(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_11926","instance":11926,"id":231941,"goal":"function Factorial_11926(n: nat): nat\n ensures Factorial_11926(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_11926(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_11927","instance":11927,"id":231942,"goal":"function Fib_11927(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_11927(n-1) + Fib_11927(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_11928","instance":11928,"id":231943,"goal":"function Gcd_11928(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_11928(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_11929","instance":11929,"id":231944,"goal":"function Power_11929(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_11929(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_11930","instance":11930,"id":231945,"goal":"function Sum_11930(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_11930(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_11931","instance":11931,"id":231946,"goal":"method BinarySearch_11931(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_11932","instance":11932,"id":231947,"goal":"method InsertSort_11932(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_11933","instance":11933,"id":231948,"goal":"method MergeSort_11933(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_11934","instance":11934,"id":231949,"goal":"method ArrayCopy_11934(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_11935","instance":11935,"id":231950,"goal":"function ListReverse_11935(s: seq): seq\n ensures |ListReverse_11935(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_11935(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_11936","instance":11936,"id":231951,"goal":"function Factorial_11936(n: nat): nat\n ensures Factorial_11936(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_11936(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_11937","instance":11937,"id":231952,"goal":"function Fib_11937(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_11937(n-1) + Fib_11937(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_11938","instance":11938,"id":231953,"goal":"function Gcd_11938(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_11938(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_11939","instance":11939,"id":231954,"goal":"function Power_11939(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_11939(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_11940","instance":11940,"id":231955,"goal":"function Sum_11940(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_11940(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_11941","instance":11941,"id":231956,"goal":"method BinarySearch_11941(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_11942","instance":11942,"id":231957,"goal":"method InsertSort_11942(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_11943","instance":11943,"id":231958,"goal":"method MergeSort_11943(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_11944","instance":11944,"id":231959,"goal":"method ArrayCopy_11944(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_11945","instance":11945,"id":231960,"goal":"function ListReverse_11945(s: seq): seq\n ensures |ListReverse_11945(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_11945(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_11946","instance":11946,"id":231961,"goal":"function Factorial_11946(n: nat): nat\n ensures Factorial_11946(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_11946(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_11947","instance":11947,"id":231962,"goal":"function Fib_11947(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_11947(n-1) + Fib_11947(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_11948","instance":11948,"id":231963,"goal":"function Gcd_11948(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_11948(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_11949","instance":11949,"id":231964,"goal":"function Power_11949(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_11949(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_11950","instance":11950,"id":231965,"goal":"function Sum_11950(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_11950(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_11951","instance":11951,"id":231966,"goal":"method BinarySearch_11951(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_11952","instance":11952,"id":231967,"goal":"method InsertSort_11952(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_11953","instance":11953,"id":231968,"goal":"method MergeSort_11953(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_11954","instance":11954,"id":231969,"goal":"method ArrayCopy_11954(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_11955","instance":11955,"id":231970,"goal":"function ListReverse_11955(s: seq): seq\n ensures |ListReverse_11955(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_11955(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_11956","instance":11956,"id":231971,"goal":"function Factorial_11956(n: nat): nat\n ensures Factorial_11956(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_11956(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_11957","instance":11957,"id":231972,"goal":"function Fib_11957(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_11957(n-1) + Fib_11957(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_11958","instance":11958,"id":231973,"goal":"function Gcd_11958(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_11958(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_11959","instance":11959,"id":231974,"goal":"function Power_11959(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_11959(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_11960","instance":11960,"id":231975,"goal":"function Sum_11960(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_11960(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_11961","instance":11961,"id":231976,"goal":"method BinarySearch_11961(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_11962","instance":11962,"id":231977,"goal":"method InsertSort_11962(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_11963","instance":11963,"id":231978,"goal":"method MergeSort_11963(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_11964","instance":11964,"id":231979,"goal":"method ArrayCopy_11964(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_11965","instance":11965,"id":231980,"goal":"function ListReverse_11965(s: seq): seq\n ensures |ListReverse_11965(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_11965(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_11966","instance":11966,"id":231981,"goal":"function Factorial_11966(n: nat): nat\n ensures Factorial_11966(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_11966(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_11967","instance":11967,"id":231982,"goal":"function Fib_11967(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_11967(n-1) + Fib_11967(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_11968","instance":11968,"id":231983,"goal":"function Gcd_11968(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_11968(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_11969","instance":11969,"id":231984,"goal":"function Power_11969(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_11969(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_11970","instance":11970,"id":231985,"goal":"function Sum_11970(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_11970(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_11971","instance":11971,"id":231986,"goal":"method BinarySearch_11971(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_11972","instance":11972,"id":231987,"goal":"method InsertSort_11972(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_11973","instance":11973,"id":231988,"goal":"method MergeSort_11973(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_11974","instance":11974,"id":231989,"goal":"method ArrayCopy_11974(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_11975","instance":11975,"id":231990,"goal":"function ListReverse_11975(s: seq): seq\n ensures |ListReverse_11975(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_11975(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_11976","instance":11976,"id":231991,"goal":"function Factorial_11976(n: nat): nat\n ensures Factorial_11976(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_11976(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_11977","instance":11977,"id":231992,"goal":"function Fib_11977(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_11977(n-1) + Fib_11977(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_11978","instance":11978,"id":231993,"goal":"function Gcd_11978(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_11978(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_11979","instance":11979,"id":231994,"goal":"function Power_11979(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_11979(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_11980","instance":11980,"id":231995,"goal":"function Sum_11980(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_11980(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_11981","instance":11981,"id":231996,"goal":"method BinarySearch_11981(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_11982","instance":11982,"id":231997,"goal":"method InsertSort_11982(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_11983","instance":11983,"id":231998,"goal":"method MergeSort_11983(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_11984","instance":11984,"id":231999,"goal":"method ArrayCopy_11984(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_11985","instance":11985,"id":232000,"goal":"function ListReverse_11985(s: seq): seq\n ensures |ListReverse_11985(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_11985(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_11986","instance":11986,"id":232001,"goal":"function Factorial_11986(n: nat): nat\n ensures Factorial_11986(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_11986(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_11987","instance":11987,"id":232002,"goal":"function Fib_11987(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_11987(n-1) + Fib_11987(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_11988","instance":11988,"id":232003,"goal":"function Gcd_11988(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_11988(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_11989","instance":11989,"id":232004,"goal":"function Power_11989(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_11989(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_11990","instance":11990,"id":232005,"goal":"function Sum_11990(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_11990(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_11991","instance":11991,"id":232006,"goal":"method BinarySearch_11991(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_11992","instance":11992,"id":232007,"goal":"method InsertSort_11992(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_11993","instance":11993,"id":232008,"goal":"method MergeSort_11993(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_11994","instance":11994,"id":232009,"goal":"method ArrayCopy_11994(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_11995","instance":11995,"id":232010,"goal":"function ListReverse_11995(s: seq): seq\n ensures |ListReverse_11995(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_11995(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_11996","instance":11996,"id":232011,"goal":"function Factorial_11996(n: nat): nat\n ensures Factorial_11996(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_11996(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_11997","instance":11997,"id":232012,"goal":"function Fib_11997(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_11997(n-1) + Fib_11997(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_11998","instance":11998,"id":232013,"goal":"function Gcd_11998(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_11998(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_11999","instance":11999,"id":232014,"goal":"function Power_11999(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_11999(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_12000","instance":12000,"id":232015,"goal":"function Sum_12000(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_12000(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_12001","instance":12001,"id":232016,"goal":"method BinarySearch_12001(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_12002","instance":12002,"id":232017,"goal":"method InsertSort_12002(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_12003","instance":12003,"id":232018,"goal":"method MergeSort_12003(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_12004","instance":12004,"id":232019,"goal":"method ArrayCopy_12004(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_12005","instance":12005,"id":232020,"goal":"function ListReverse_12005(s: seq): seq\n ensures |ListReverse_12005(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_12005(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_12006","instance":12006,"id":232021,"goal":"function Factorial_12006(n: nat): nat\n ensures Factorial_12006(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_12006(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_12007","instance":12007,"id":232022,"goal":"function Fib_12007(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_12007(n-1) + Fib_12007(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_12008","instance":12008,"id":232023,"goal":"function Gcd_12008(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_12008(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_12009","instance":12009,"id":232024,"goal":"function Power_12009(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_12009(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_12010","instance":12010,"id":232025,"goal":"function Sum_12010(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_12010(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_12011","instance":12011,"id":232026,"goal":"method BinarySearch_12011(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_12012","instance":12012,"id":232027,"goal":"method InsertSort_12012(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_12013","instance":12013,"id":232028,"goal":"method MergeSort_12013(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_12014","instance":12014,"id":232029,"goal":"method ArrayCopy_12014(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_12015","instance":12015,"id":232030,"goal":"function ListReverse_12015(s: seq): seq\n ensures |ListReverse_12015(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_12015(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_12016","instance":12016,"id":232031,"goal":"function Factorial_12016(n: nat): nat\n ensures Factorial_12016(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_12016(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_12017","instance":12017,"id":232032,"goal":"function Fib_12017(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_12017(n-1) + Fib_12017(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_12018","instance":12018,"id":232033,"goal":"function Gcd_12018(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_12018(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_12019","instance":12019,"id":232034,"goal":"function Power_12019(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_12019(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_12020","instance":12020,"id":232035,"goal":"function Sum_12020(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_12020(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_12021","instance":12021,"id":232036,"goal":"method BinarySearch_12021(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_12022","instance":12022,"id":232037,"goal":"method InsertSort_12022(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_12023","instance":12023,"id":232038,"goal":"method MergeSort_12023(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_12024","instance":12024,"id":232039,"goal":"method ArrayCopy_12024(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_12025","instance":12025,"id":232040,"goal":"function ListReverse_12025(s: seq): seq\n ensures |ListReverse_12025(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_12025(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_12026","instance":12026,"id":232041,"goal":"function Factorial_12026(n: nat): nat\n ensures Factorial_12026(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_12026(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_12027","instance":12027,"id":232042,"goal":"function Fib_12027(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_12027(n-1) + Fib_12027(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_12028","instance":12028,"id":232043,"goal":"function Gcd_12028(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_12028(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_12029","instance":12029,"id":232044,"goal":"function Power_12029(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_12029(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_12030","instance":12030,"id":232045,"goal":"function Sum_12030(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_12030(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_12031","instance":12031,"id":232046,"goal":"method BinarySearch_12031(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_12032","instance":12032,"id":232047,"goal":"method InsertSort_12032(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_12033","instance":12033,"id":232048,"goal":"method MergeSort_12033(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_12034","instance":12034,"id":232049,"goal":"method ArrayCopy_12034(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_12035","instance":12035,"id":232050,"goal":"function ListReverse_12035(s: seq): seq\n ensures |ListReverse_12035(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_12035(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_12036","instance":12036,"id":232051,"goal":"function Factorial_12036(n: nat): nat\n ensures Factorial_12036(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_12036(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_12037","instance":12037,"id":232052,"goal":"function Fib_12037(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_12037(n-1) + Fib_12037(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_12038","instance":12038,"id":232053,"goal":"function Gcd_12038(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_12038(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_12039","instance":12039,"id":232054,"goal":"function Power_12039(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_12039(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_12040","instance":12040,"id":232055,"goal":"function Sum_12040(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_12040(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_12041","instance":12041,"id":232056,"goal":"method BinarySearch_12041(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_12042","instance":12042,"id":232057,"goal":"method InsertSort_12042(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_12043","instance":12043,"id":232058,"goal":"method MergeSort_12043(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_12044","instance":12044,"id":232059,"goal":"method ArrayCopy_12044(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_12045","instance":12045,"id":232060,"goal":"function ListReverse_12045(s: seq): seq\n ensures |ListReverse_12045(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_12045(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_12046","instance":12046,"id":232061,"goal":"function Factorial_12046(n: nat): nat\n ensures Factorial_12046(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_12046(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_12047","instance":12047,"id":232062,"goal":"function Fib_12047(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_12047(n-1) + Fib_12047(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_12048","instance":12048,"id":232063,"goal":"function Gcd_12048(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_12048(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_12049","instance":12049,"id":232064,"goal":"function Power_12049(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_12049(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_12050","instance":12050,"id":232065,"goal":"function Sum_12050(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_12050(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_12051","instance":12051,"id":232066,"goal":"method BinarySearch_12051(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_12052","instance":12052,"id":232067,"goal":"method InsertSort_12052(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_12053","instance":12053,"id":232068,"goal":"method MergeSort_12053(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_12054","instance":12054,"id":232069,"goal":"method ArrayCopy_12054(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_12055","instance":12055,"id":232070,"goal":"function ListReverse_12055(s: seq): seq\n ensures |ListReverse_12055(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_12055(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_12056","instance":12056,"id":232071,"goal":"function Factorial_12056(n: nat): nat\n ensures Factorial_12056(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_12056(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_12057","instance":12057,"id":232072,"goal":"function Fib_12057(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_12057(n-1) + Fib_12057(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_12058","instance":12058,"id":232073,"goal":"function Gcd_12058(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_12058(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_12059","instance":12059,"id":232074,"goal":"function Power_12059(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_12059(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_12060","instance":12060,"id":232075,"goal":"function Sum_12060(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_12060(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_12061","instance":12061,"id":232076,"goal":"method BinarySearch_12061(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_12062","instance":12062,"id":232077,"goal":"method InsertSort_12062(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_12063","instance":12063,"id":232078,"goal":"method MergeSort_12063(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_12064","instance":12064,"id":232079,"goal":"method ArrayCopy_12064(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_12065","instance":12065,"id":232080,"goal":"function ListReverse_12065(s: seq): seq\n ensures |ListReverse_12065(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_12065(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_12066","instance":12066,"id":232081,"goal":"function Factorial_12066(n: nat): nat\n ensures Factorial_12066(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_12066(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_12067","instance":12067,"id":232082,"goal":"function Fib_12067(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_12067(n-1) + Fib_12067(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_12068","instance":12068,"id":232083,"goal":"function Gcd_12068(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_12068(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_12069","instance":12069,"id":232084,"goal":"function Power_12069(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_12069(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_12070","instance":12070,"id":232085,"goal":"function Sum_12070(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_12070(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_12071","instance":12071,"id":232086,"goal":"method BinarySearch_12071(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_12072","instance":12072,"id":232087,"goal":"method InsertSort_12072(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_12073","instance":12073,"id":232088,"goal":"method MergeSort_12073(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_12074","instance":12074,"id":232089,"goal":"method ArrayCopy_12074(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_12075","instance":12075,"id":232090,"goal":"function ListReverse_12075(s: seq): seq\n ensures |ListReverse_12075(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_12075(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_12076","instance":12076,"id":232091,"goal":"function Factorial_12076(n: nat): nat\n ensures Factorial_12076(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_12076(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_12077","instance":12077,"id":232092,"goal":"function Fib_12077(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_12077(n-1) + Fib_12077(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_12078","instance":12078,"id":232093,"goal":"function Gcd_12078(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_12078(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_12079","instance":12079,"id":232094,"goal":"function Power_12079(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_12079(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_12080","instance":12080,"id":232095,"goal":"function Sum_12080(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_12080(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_12081","instance":12081,"id":232096,"goal":"method BinarySearch_12081(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_12082","instance":12082,"id":232097,"goal":"method InsertSort_12082(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_12083","instance":12083,"id":232098,"goal":"method MergeSort_12083(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_12084","instance":12084,"id":232099,"goal":"method ArrayCopy_12084(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_12085","instance":12085,"id":232100,"goal":"function ListReverse_12085(s: seq): seq\n ensures |ListReverse_12085(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_12085(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_12086","instance":12086,"id":232101,"goal":"function Factorial_12086(n: nat): nat\n ensures Factorial_12086(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_12086(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_12087","instance":12087,"id":232102,"goal":"function Fib_12087(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_12087(n-1) + Fib_12087(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_12088","instance":12088,"id":232103,"goal":"function Gcd_12088(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_12088(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_12089","instance":12089,"id":232104,"goal":"function Power_12089(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_12089(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_12090","instance":12090,"id":232105,"goal":"function Sum_12090(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_12090(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_12091","instance":12091,"id":232106,"goal":"method BinarySearch_12091(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_12092","instance":12092,"id":232107,"goal":"method InsertSort_12092(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_12093","instance":12093,"id":232108,"goal":"method MergeSort_12093(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_12094","instance":12094,"id":232109,"goal":"method ArrayCopy_12094(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_12095","instance":12095,"id":232110,"goal":"function ListReverse_12095(s: seq): seq\n ensures |ListReverse_12095(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_12095(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_12096","instance":12096,"id":232111,"goal":"function Factorial_12096(n: nat): nat\n ensures Factorial_12096(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_12096(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_12097","instance":12097,"id":232112,"goal":"function Fib_12097(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_12097(n-1) + Fib_12097(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_12098","instance":12098,"id":232113,"goal":"function Gcd_12098(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_12098(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_12099","instance":12099,"id":232114,"goal":"function Power_12099(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_12099(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_12100","instance":12100,"id":232115,"goal":"function Sum_12100(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_12100(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_12101","instance":12101,"id":232116,"goal":"method BinarySearch_12101(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_12102","instance":12102,"id":232117,"goal":"method InsertSort_12102(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_12103","instance":12103,"id":232118,"goal":"method MergeSort_12103(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_12104","instance":12104,"id":232119,"goal":"method ArrayCopy_12104(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_12105","instance":12105,"id":232120,"goal":"function ListReverse_12105(s: seq): seq\n ensures |ListReverse_12105(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_12105(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_12106","instance":12106,"id":232121,"goal":"function Factorial_12106(n: nat): nat\n ensures Factorial_12106(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_12106(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_12107","instance":12107,"id":232122,"goal":"function Fib_12107(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_12107(n-1) + Fib_12107(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_12108","instance":12108,"id":232123,"goal":"function Gcd_12108(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_12108(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_12109","instance":12109,"id":232124,"goal":"function Power_12109(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_12109(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_12110","instance":12110,"id":232125,"goal":"function Sum_12110(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_12110(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_12111","instance":12111,"id":232126,"goal":"method BinarySearch_12111(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_12112","instance":12112,"id":232127,"goal":"method InsertSort_12112(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_12113","instance":12113,"id":232128,"goal":"method MergeSort_12113(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_12114","instance":12114,"id":232129,"goal":"method ArrayCopy_12114(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_12115","instance":12115,"id":232130,"goal":"function ListReverse_12115(s: seq): seq\n ensures |ListReverse_12115(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_12115(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_12116","instance":12116,"id":232131,"goal":"function Factorial_12116(n: nat): nat\n ensures Factorial_12116(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_12116(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_12117","instance":12117,"id":232132,"goal":"function Fib_12117(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_12117(n-1) + Fib_12117(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_12118","instance":12118,"id":232133,"goal":"function Gcd_12118(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_12118(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_12119","instance":12119,"id":232134,"goal":"function Power_12119(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_12119(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_12120","instance":12120,"id":232135,"goal":"function Sum_12120(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_12120(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_12121","instance":12121,"id":232136,"goal":"method BinarySearch_12121(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_12122","instance":12122,"id":232137,"goal":"method InsertSort_12122(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_12123","instance":12123,"id":232138,"goal":"method MergeSort_12123(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_12124","instance":12124,"id":232139,"goal":"method ArrayCopy_12124(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_12125","instance":12125,"id":232140,"goal":"function ListReverse_12125(s: seq): seq\n ensures |ListReverse_12125(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_12125(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_12126","instance":12126,"id":232141,"goal":"function Factorial_12126(n: nat): nat\n ensures Factorial_12126(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_12126(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_12127","instance":12127,"id":232142,"goal":"function Fib_12127(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_12127(n-1) + Fib_12127(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_12128","instance":12128,"id":232143,"goal":"function Gcd_12128(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_12128(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_12129","instance":12129,"id":232144,"goal":"function Power_12129(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_12129(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_12130","instance":12130,"id":232145,"goal":"function Sum_12130(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_12130(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_12131","instance":12131,"id":232146,"goal":"method BinarySearch_12131(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_12132","instance":12132,"id":232147,"goal":"method InsertSort_12132(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_12133","instance":12133,"id":232148,"goal":"method MergeSort_12133(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_12134","instance":12134,"id":232149,"goal":"method ArrayCopy_12134(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_12135","instance":12135,"id":232150,"goal":"function ListReverse_12135(s: seq): seq\n ensures |ListReverse_12135(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_12135(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_12136","instance":12136,"id":232151,"goal":"function Factorial_12136(n: nat): nat\n ensures Factorial_12136(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_12136(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_12137","instance":12137,"id":232152,"goal":"function Fib_12137(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_12137(n-1) + Fib_12137(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_12138","instance":12138,"id":232153,"goal":"function Gcd_12138(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_12138(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_12139","instance":12139,"id":232154,"goal":"function Power_12139(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_12139(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_12140","instance":12140,"id":232155,"goal":"function Sum_12140(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_12140(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_12141","instance":12141,"id":232156,"goal":"method BinarySearch_12141(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_12142","instance":12142,"id":232157,"goal":"method InsertSort_12142(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_12143","instance":12143,"id":232158,"goal":"method MergeSort_12143(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_12144","instance":12144,"id":232159,"goal":"method ArrayCopy_12144(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_12145","instance":12145,"id":232160,"goal":"function ListReverse_12145(s: seq): seq\n ensures |ListReverse_12145(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_12145(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_12146","instance":12146,"id":232161,"goal":"function Factorial_12146(n: nat): nat\n ensures Factorial_12146(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_12146(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_12147","instance":12147,"id":232162,"goal":"function Fib_12147(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_12147(n-1) + Fib_12147(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_12148","instance":12148,"id":232163,"goal":"function Gcd_12148(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_12148(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_12149","instance":12149,"id":232164,"goal":"function Power_12149(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_12149(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_12150","instance":12150,"id":232165,"goal":"function Sum_12150(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_12150(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_12151","instance":12151,"id":232166,"goal":"method BinarySearch_12151(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_12152","instance":12152,"id":232167,"goal":"method InsertSort_12152(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_12153","instance":12153,"id":232168,"goal":"method MergeSort_12153(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_12154","instance":12154,"id":232169,"goal":"method ArrayCopy_12154(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_12155","instance":12155,"id":232170,"goal":"function ListReverse_12155(s: seq): seq\n ensures |ListReverse_12155(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_12155(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_12156","instance":12156,"id":232171,"goal":"function Factorial_12156(n: nat): nat\n ensures Factorial_12156(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_12156(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_12157","instance":12157,"id":232172,"goal":"function Fib_12157(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_12157(n-1) + Fib_12157(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_12158","instance":12158,"id":232173,"goal":"function Gcd_12158(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_12158(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_12159","instance":12159,"id":232174,"goal":"function Power_12159(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_12159(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_12160","instance":12160,"id":232175,"goal":"function Sum_12160(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_12160(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_12161","instance":12161,"id":232176,"goal":"method BinarySearch_12161(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_12162","instance":12162,"id":232177,"goal":"method InsertSort_12162(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_12163","instance":12163,"id":232178,"goal":"method MergeSort_12163(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_12164","instance":12164,"id":232179,"goal":"method ArrayCopy_12164(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_12165","instance":12165,"id":232180,"goal":"function ListReverse_12165(s: seq): seq\n ensures |ListReverse_12165(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_12165(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_12166","instance":12166,"id":232181,"goal":"function Factorial_12166(n: nat): nat\n ensures Factorial_12166(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_12166(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_12167","instance":12167,"id":232182,"goal":"function Fib_12167(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_12167(n-1) + Fib_12167(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_12168","instance":12168,"id":232183,"goal":"function Gcd_12168(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_12168(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_12169","instance":12169,"id":232184,"goal":"function Power_12169(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_12169(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_12170","instance":12170,"id":232185,"goal":"function Sum_12170(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_12170(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_12171","instance":12171,"id":232186,"goal":"method BinarySearch_12171(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_12172","instance":12172,"id":232187,"goal":"method InsertSort_12172(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_12173","instance":12173,"id":232188,"goal":"method MergeSort_12173(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_12174","instance":12174,"id":232189,"goal":"method ArrayCopy_12174(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_12175","instance":12175,"id":232190,"goal":"function ListReverse_12175(s: seq): seq\n ensures |ListReverse_12175(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_12175(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_12176","instance":12176,"id":232191,"goal":"function Factorial_12176(n: nat): nat\n ensures Factorial_12176(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_12176(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_12177","instance":12177,"id":232192,"goal":"function Fib_12177(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_12177(n-1) + Fib_12177(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_12178","instance":12178,"id":232193,"goal":"function Gcd_12178(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_12178(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_12179","instance":12179,"id":232194,"goal":"function Power_12179(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_12179(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_12180","instance":12180,"id":232195,"goal":"function Sum_12180(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_12180(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_12181","instance":12181,"id":232196,"goal":"method BinarySearch_12181(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_12182","instance":12182,"id":232197,"goal":"method InsertSort_12182(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_12183","instance":12183,"id":232198,"goal":"method MergeSort_12183(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_12184","instance":12184,"id":232199,"goal":"method ArrayCopy_12184(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_12185","instance":12185,"id":232200,"goal":"function ListReverse_12185(s: seq): seq\n ensures |ListReverse_12185(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_12185(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_12186","instance":12186,"id":232201,"goal":"function Factorial_12186(n: nat): nat\n ensures Factorial_12186(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_12186(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_12187","instance":12187,"id":232202,"goal":"function Fib_12187(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_12187(n-1) + Fib_12187(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_12188","instance":12188,"id":232203,"goal":"function Gcd_12188(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_12188(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_12189","instance":12189,"id":232204,"goal":"function Power_12189(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_12189(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_12190","instance":12190,"id":232205,"goal":"function Sum_12190(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_12190(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_12191","instance":12191,"id":232206,"goal":"method BinarySearch_12191(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_12192","instance":12192,"id":232207,"goal":"method InsertSort_12192(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_12193","instance":12193,"id":232208,"goal":"method MergeSort_12193(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_12194","instance":12194,"id":232209,"goal":"method ArrayCopy_12194(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_12195","instance":12195,"id":232210,"goal":"function ListReverse_12195(s: seq): seq\n ensures |ListReverse_12195(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_12195(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_12196","instance":12196,"id":232211,"goal":"function Factorial_12196(n: nat): nat\n ensures Factorial_12196(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_12196(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_12197","instance":12197,"id":232212,"goal":"function Fib_12197(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_12197(n-1) + Fib_12197(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_12198","instance":12198,"id":232213,"goal":"function Gcd_12198(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_12198(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_12199","instance":12199,"id":232214,"goal":"function Power_12199(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_12199(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_12200","instance":12200,"id":232215,"goal":"function Sum_12200(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_12200(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_12201","instance":12201,"id":232216,"goal":"method BinarySearch_12201(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_12202","instance":12202,"id":232217,"goal":"method InsertSort_12202(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_12203","instance":12203,"id":232218,"goal":"method MergeSort_12203(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_12204","instance":12204,"id":232219,"goal":"method ArrayCopy_12204(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_12205","instance":12205,"id":232220,"goal":"function ListReverse_12205(s: seq): seq\n ensures |ListReverse_12205(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_12205(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_12206","instance":12206,"id":232221,"goal":"function Factorial_12206(n: nat): nat\n ensures Factorial_12206(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_12206(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_12207","instance":12207,"id":232222,"goal":"function Fib_12207(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_12207(n-1) + Fib_12207(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_12208","instance":12208,"id":232223,"goal":"function Gcd_12208(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_12208(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_12209","instance":12209,"id":232224,"goal":"function Power_12209(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_12209(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_12210","instance":12210,"id":232225,"goal":"function Sum_12210(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_12210(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_12211","instance":12211,"id":232226,"goal":"method BinarySearch_12211(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_12212","instance":12212,"id":232227,"goal":"method InsertSort_12212(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_12213","instance":12213,"id":232228,"goal":"method MergeSort_12213(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_12214","instance":12214,"id":232229,"goal":"method ArrayCopy_12214(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_12215","instance":12215,"id":232230,"goal":"function ListReverse_12215(s: seq): seq\n ensures |ListReverse_12215(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_12215(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_12216","instance":12216,"id":232231,"goal":"function Factorial_12216(n: nat): nat\n ensures Factorial_12216(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_12216(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_12217","instance":12217,"id":232232,"goal":"function Fib_12217(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_12217(n-1) + Fib_12217(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_12218","instance":12218,"id":232233,"goal":"function Gcd_12218(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_12218(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_12219","instance":12219,"id":232234,"goal":"function Power_12219(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_12219(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_12220","instance":12220,"id":232235,"goal":"function Sum_12220(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_12220(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_12221","instance":12221,"id":232236,"goal":"method BinarySearch_12221(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_12222","instance":12222,"id":232237,"goal":"method InsertSort_12222(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_12223","instance":12223,"id":232238,"goal":"method MergeSort_12223(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_12224","instance":12224,"id":232239,"goal":"method ArrayCopy_12224(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_12225","instance":12225,"id":232240,"goal":"function ListReverse_12225(s: seq): seq\n ensures |ListReverse_12225(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_12225(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_12226","instance":12226,"id":232241,"goal":"function Factorial_12226(n: nat): nat\n ensures Factorial_12226(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_12226(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_12227","instance":12227,"id":232242,"goal":"function Fib_12227(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_12227(n-1) + Fib_12227(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_12228","instance":12228,"id":232243,"goal":"function Gcd_12228(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_12228(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_12229","instance":12229,"id":232244,"goal":"function Power_12229(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_12229(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_12230","instance":12230,"id":232245,"goal":"function Sum_12230(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_12230(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_12231","instance":12231,"id":232246,"goal":"method BinarySearch_12231(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_12232","instance":12232,"id":232247,"goal":"method InsertSort_12232(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_12233","instance":12233,"id":232248,"goal":"method MergeSort_12233(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_12234","instance":12234,"id":232249,"goal":"method ArrayCopy_12234(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_12235","instance":12235,"id":232250,"goal":"function ListReverse_12235(s: seq): seq\n ensures |ListReverse_12235(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_12235(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_12236","instance":12236,"id":232251,"goal":"function Factorial_12236(n: nat): nat\n ensures Factorial_12236(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_12236(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_12237","instance":12237,"id":232252,"goal":"function Fib_12237(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_12237(n-1) + Fib_12237(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_12238","instance":12238,"id":232253,"goal":"function Gcd_12238(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_12238(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_12239","instance":12239,"id":232254,"goal":"function Power_12239(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_12239(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_12240","instance":12240,"id":232255,"goal":"function Sum_12240(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_12240(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_12241","instance":12241,"id":232256,"goal":"method BinarySearch_12241(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_12242","instance":12242,"id":232257,"goal":"method InsertSort_12242(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_12243","instance":12243,"id":232258,"goal":"method MergeSort_12243(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_12244","instance":12244,"id":232259,"goal":"method ArrayCopy_12244(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_12245","instance":12245,"id":232260,"goal":"function ListReverse_12245(s: seq): seq\n ensures |ListReverse_12245(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_12245(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_12246","instance":12246,"id":232261,"goal":"function Factorial_12246(n: nat): nat\n ensures Factorial_12246(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_12246(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_12247","instance":12247,"id":232262,"goal":"function Fib_12247(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_12247(n-1) + Fib_12247(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_12248","instance":12248,"id":232263,"goal":"function Gcd_12248(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_12248(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_12249","instance":12249,"id":232264,"goal":"function Power_12249(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_12249(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_12250","instance":12250,"id":232265,"goal":"function Sum_12250(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_12250(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_12251","instance":12251,"id":232266,"goal":"method BinarySearch_12251(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_12252","instance":12252,"id":232267,"goal":"method InsertSort_12252(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_12253","instance":12253,"id":232268,"goal":"method MergeSort_12253(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_12254","instance":12254,"id":232269,"goal":"method ArrayCopy_12254(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_12255","instance":12255,"id":232270,"goal":"function ListReverse_12255(s: seq): seq\n ensures |ListReverse_12255(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_12255(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_12256","instance":12256,"id":232271,"goal":"function Factorial_12256(n: nat): nat\n ensures Factorial_12256(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_12256(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_12257","instance":12257,"id":232272,"goal":"function Fib_12257(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_12257(n-1) + Fib_12257(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_12258","instance":12258,"id":232273,"goal":"function Gcd_12258(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_12258(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_12259","instance":12259,"id":232274,"goal":"function Power_12259(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_12259(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_12260","instance":12260,"id":232275,"goal":"function Sum_12260(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_12260(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_12261","instance":12261,"id":232276,"goal":"method BinarySearch_12261(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_12262","instance":12262,"id":232277,"goal":"method InsertSort_12262(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_12263","instance":12263,"id":232278,"goal":"method MergeSort_12263(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_12264","instance":12264,"id":232279,"goal":"method ArrayCopy_12264(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_12265","instance":12265,"id":232280,"goal":"function ListReverse_12265(s: seq): seq\n ensures |ListReverse_12265(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_12265(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_12266","instance":12266,"id":232281,"goal":"function Factorial_12266(n: nat): nat\n ensures Factorial_12266(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_12266(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_12267","instance":12267,"id":232282,"goal":"function Fib_12267(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_12267(n-1) + Fib_12267(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_12268","instance":12268,"id":232283,"goal":"function Gcd_12268(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_12268(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_12269","instance":12269,"id":232284,"goal":"function Power_12269(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_12269(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_12270","instance":12270,"id":232285,"goal":"function Sum_12270(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_12270(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_12271","instance":12271,"id":232286,"goal":"method BinarySearch_12271(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_12272","instance":12272,"id":232287,"goal":"method InsertSort_12272(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_12273","instance":12273,"id":232288,"goal":"method MergeSort_12273(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_12274","instance":12274,"id":232289,"goal":"method ArrayCopy_12274(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_12275","instance":12275,"id":232290,"goal":"function ListReverse_12275(s: seq): seq\n ensures |ListReverse_12275(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_12275(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_12276","instance":12276,"id":232291,"goal":"function Factorial_12276(n: nat): nat\n ensures Factorial_12276(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_12276(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_12277","instance":12277,"id":232292,"goal":"function Fib_12277(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_12277(n-1) + Fib_12277(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_12278","instance":12278,"id":232293,"goal":"function Gcd_12278(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_12278(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_12279","instance":12279,"id":232294,"goal":"function Power_12279(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_12279(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_12280","instance":12280,"id":232295,"goal":"function Sum_12280(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_12280(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_12281","instance":12281,"id":232296,"goal":"method BinarySearch_12281(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_12282","instance":12282,"id":232297,"goal":"method InsertSort_12282(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_12283","instance":12283,"id":232298,"goal":"method MergeSort_12283(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_12284","instance":12284,"id":232299,"goal":"method ArrayCopy_12284(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_12285","instance":12285,"id":232300,"goal":"function ListReverse_12285(s: seq): seq\n ensures |ListReverse_12285(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_12285(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_12286","instance":12286,"id":232301,"goal":"function Factorial_12286(n: nat): nat\n ensures Factorial_12286(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_12286(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_12287","instance":12287,"id":232302,"goal":"function Fib_12287(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_12287(n-1) + Fib_12287(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_12288","instance":12288,"id":232303,"goal":"function Gcd_12288(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_12288(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_12289","instance":12289,"id":232304,"goal":"function Power_12289(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_12289(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_12290","instance":12290,"id":232305,"goal":"function Sum_12290(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_12290(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_12291","instance":12291,"id":232306,"goal":"method BinarySearch_12291(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_12292","instance":12292,"id":232307,"goal":"method InsertSort_12292(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_12293","instance":12293,"id":232308,"goal":"method MergeSort_12293(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_12294","instance":12294,"id":232309,"goal":"method ArrayCopy_12294(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_12295","instance":12295,"id":232310,"goal":"function ListReverse_12295(s: seq): seq\n ensures |ListReverse_12295(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_12295(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_12296","instance":12296,"id":232311,"goal":"function Factorial_12296(n: nat): nat\n ensures Factorial_12296(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_12296(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_12297","instance":12297,"id":232312,"goal":"function Fib_12297(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_12297(n-1) + Fib_12297(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_12298","instance":12298,"id":232313,"goal":"function Gcd_12298(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_12298(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_12299","instance":12299,"id":232314,"goal":"function Power_12299(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_12299(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_12300","instance":12300,"id":232315,"goal":"function Sum_12300(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_12300(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_12301","instance":12301,"id":232316,"goal":"method BinarySearch_12301(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_12302","instance":12302,"id":232317,"goal":"method InsertSort_12302(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_12303","instance":12303,"id":232318,"goal":"method MergeSort_12303(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_12304","instance":12304,"id":232319,"goal":"method ArrayCopy_12304(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_12305","instance":12305,"id":232320,"goal":"function ListReverse_12305(s: seq): seq\n ensures |ListReverse_12305(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_12305(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_12306","instance":12306,"id":232321,"goal":"function Factorial_12306(n: nat): nat\n ensures Factorial_12306(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_12306(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_12307","instance":12307,"id":232322,"goal":"function Fib_12307(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_12307(n-1) + Fib_12307(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_12308","instance":12308,"id":232323,"goal":"function Gcd_12308(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_12308(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_12309","instance":12309,"id":232324,"goal":"function Power_12309(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_12309(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_12310","instance":12310,"id":232325,"goal":"function Sum_12310(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_12310(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_12311","instance":12311,"id":232326,"goal":"method BinarySearch_12311(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_12312","instance":12312,"id":232327,"goal":"method InsertSort_12312(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_12313","instance":12313,"id":232328,"goal":"method MergeSort_12313(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_12314","instance":12314,"id":232329,"goal":"method ArrayCopy_12314(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_12315","instance":12315,"id":232330,"goal":"function ListReverse_12315(s: seq): seq\n ensures |ListReverse_12315(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_12315(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_12316","instance":12316,"id":232331,"goal":"function Factorial_12316(n: nat): nat\n ensures Factorial_12316(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_12316(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_12317","instance":12317,"id":232332,"goal":"function Fib_12317(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_12317(n-1) + Fib_12317(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_12318","instance":12318,"id":232333,"goal":"function Gcd_12318(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_12318(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_12319","instance":12319,"id":232334,"goal":"function Power_12319(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_12319(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_12320","instance":12320,"id":232335,"goal":"function Sum_12320(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_12320(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_12321","instance":12321,"id":232336,"goal":"method BinarySearch_12321(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_12322","instance":12322,"id":232337,"goal":"method InsertSort_12322(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_12323","instance":12323,"id":232338,"goal":"method MergeSort_12323(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_12324","instance":12324,"id":232339,"goal":"method ArrayCopy_12324(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_12325","instance":12325,"id":232340,"goal":"function ListReverse_12325(s: seq): seq\n ensures |ListReverse_12325(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_12325(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_12326","instance":12326,"id":232341,"goal":"function Factorial_12326(n: nat): nat\n ensures Factorial_12326(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_12326(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_12327","instance":12327,"id":232342,"goal":"function Fib_12327(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_12327(n-1) + Fib_12327(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_12328","instance":12328,"id":232343,"goal":"function Gcd_12328(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_12328(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_12329","instance":12329,"id":232344,"goal":"function Power_12329(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_12329(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_12330","instance":12330,"id":232345,"goal":"function Sum_12330(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_12330(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_12331","instance":12331,"id":232346,"goal":"method BinarySearch_12331(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_12332","instance":12332,"id":232347,"goal":"method InsertSort_12332(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_12333","instance":12333,"id":232348,"goal":"method MergeSort_12333(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_12334","instance":12334,"id":232349,"goal":"method ArrayCopy_12334(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_12335","instance":12335,"id":232350,"goal":"function ListReverse_12335(s: seq): seq\n ensures |ListReverse_12335(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_12335(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_12336","instance":12336,"id":232351,"goal":"function Factorial_12336(n: nat): nat\n ensures Factorial_12336(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_12336(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_12337","instance":12337,"id":232352,"goal":"function Fib_12337(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_12337(n-1) + Fib_12337(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_12338","instance":12338,"id":232353,"goal":"function Gcd_12338(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_12338(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_12339","instance":12339,"id":232354,"goal":"function Power_12339(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_12339(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_12340","instance":12340,"id":232355,"goal":"function Sum_12340(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_12340(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_12341","instance":12341,"id":232356,"goal":"method BinarySearch_12341(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_12342","instance":12342,"id":232357,"goal":"method InsertSort_12342(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_12343","instance":12343,"id":232358,"goal":"method MergeSort_12343(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_12344","instance":12344,"id":232359,"goal":"method ArrayCopy_12344(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_12345","instance":12345,"id":232360,"goal":"function ListReverse_12345(s: seq): seq\n ensures |ListReverse_12345(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_12345(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_12346","instance":12346,"id":232361,"goal":"function Factorial_12346(n: nat): nat\n ensures Factorial_12346(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_12346(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_12347","instance":12347,"id":232362,"goal":"function Fib_12347(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_12347(n-1) + Fib_12347(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_12348","instance":12348,"id":232363,"goal":"function Gcd_12348(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_12348(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_12349","instance":12349,"id":232364,"goal":"function Power_12349(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_12349(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_12350","instance":12350,"id":232365,"goal":"function Sum_12350(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_12350(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_12351","instance":12351,"id":232366,"goal":"method BinarySearch_12351(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_12352","instance":12352,"id":232367,"goal":"method InsertSort_12352(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_12353","instance":12353,"id":232368,"goal":"method MergeSort_12353(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_12354","instance":12354,"id":232369,"goal":"method ArrayCopy_12354(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_12355","instance":12355,"id":232370,"goal":"function ListReverse_12355(s: seq): seq\n ensures |ListReverse_12355(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_12355(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_12356","instance":12356,"id":232371,"goal":"function Factorial_12356(n: nat): nat\n ensures Factorial_12356(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_12356(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_12357","instance":12357,"id":232372,"goal":"function Fib_12357(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_12357(n-1) + Fib_12357(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_12358","instance":12358,"id":232373,"goal":"function Gcd_12358(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_12358(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_12359","instance":12359,"id":232374,"goal":"function Power_12359(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_12359(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_12360","instance":12360,"id":232375,"goal":"function Sum_12360(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_12360(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_12361","instance":12361,"id":232376,"goal":"method BinarySearch_12361(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_12362","instance":12362,"id":232377,"goal":"method InsertSort_12362(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_12363","instance":12363,"id":232378,"goal":"method MergeSort_12363(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_12364","instance":12364,"id":232379,"goal":"method ArrayCopy_12364(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_12365","instance":12365,"id":232380,"goal":"function ListReverse_12365(s: seq): seq\n ensures |ListReverse_12365(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_12365(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_12366","instance":12366,"id":232381,"goal":"function Factorial_12366(n: nat): nat\n ensures Factorial_12366(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_12366(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_12367","instance":12367,"id":232382,"goal":"function Fib_12367(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_12367(n-1) + Fib_12367(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_12368","instance":12368,"id":232383,"goal":"function Gcd_12368(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_12368(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_12369","instance":12369,"id":232384,"goal":"function Power_12369(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_12369(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_12370","instance":12370,"id":232385,"goal":"function Sum_12370(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_12370(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_12371","instance":12371,"id":232386,"goal":"method BinarySearch_12371(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_12372","instance":12372,"id":232387,"goal":"method InsertSort_12372(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_12373","instance":12373,"id":232388,"goal":"method MergeSort_12373(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_12374","instance":12374,"id":232389,"goal":"method ArrayCopy_12374(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_12375","instance":12375,"id":232390,"goal":"function ListReverse_12375(s: seq): seq\n ensures |ListReverse_12375(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_12375(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_12376","instance":12376,"id":232391,"goal":"function Factorial_12376(n: nat): nat\n ensures Factorial_12376(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_12376(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_12377","instance":12377,"id":232392,"goal":"function Fib_12377(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_12377(n-1) + Fib_12377(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_12378","instance":12378,"id":232393,"goal":"function Gcd_12378(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_12378(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_12379","instance":12379,"id":232394,"goal":"function Power_12379(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_12379(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_12380","instance":12380,"id":232395,"goal":"function Sum_12380(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_12380(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_12381","instance":12381,"id":232396,"goal":"method BinarySearch_12381(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_12382","instance":12382,"id":232397,"goal":"method InsertSort_12382(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_12383","instance":12383,"id":232398,"goal":"method MergeSort_12383(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_12384","instance":12384,"id":232399,"goal":"method ArrayCopy_12384(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_12385","instance":12385,"id":232400,"goal":"function ListReverse_12385(s: seq): seq\n ensures |ListReverse_12385(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_12385(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_12386","instance":12386,"id":232401,"goal":"function Factorial_12386(n: nat): nat\n ensures Factorial_12386(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_12386(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_12387","instance":12387,"id":232402,"goal":"function Fib_12387(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_12387(n-1) + Fib_12387(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_12388","instance":12388,"id":232403,"goal":"function Gcd_12388(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_12388(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_12389","instance":12389,"id":232404,"goal":"function Power_12389(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_12389(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_12390","instance":12390,"id":232405,"goal":"function Sum_12390(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_12390(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_12391","instance":12391,"id":232406,"goal":"method BinarySearch_12391(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_12392","instance":12392,"id":232407,"goal":"method InsertSort_12392(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_12393","instance":12393,"id":232408,"goal":"method MergeSort_12393(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_12394","instance":12394,"id":232409,"goal":"method ArrayCopy_12394(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_12395","instance":12395,"id":232410,"goal":"function ListReverse_12395(s: seq): seq\n ensures |ListReverse_12395(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_12395(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_12396","instance":12396,"id":232411,"goal":"function Factorial_12396(n: nat): nat\n ensures Factorial_12396(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_12396(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_12397","instance":12397,"id":232412,"goal":"function Fib_12397(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_12397(n-1) + Fib_12397(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_12398","instance":12398,"id":232413,"goal":"function Gcd_12398(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_12398(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_12399","instance":12399,"id":232414,"goal":"function Power_12399(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_12399(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_12400","instance":12400,"id":232415,"goal":"function Sum_12400(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_12400(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_12401","instance":12401,"id":232416,"goal":"method BinarySearch_12401(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_12402","instance":12402,"id":232417,"goal":"method InsertSort_12402(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_12403","instance":12403,"id":232418,"goal":"method MergeSort_12403(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_12404","instance":12404,"id":232419,"goal":"method ArrayCopy_12404(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_12405","instance":12405,"id":232420,"goal":"function ListReverse_12405(s: seq): seq\n ensures |ListReverse_12405(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_12405(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_12406","instance":12406,"id":232421,"goal":"function Factorial_12406(n: nat): nat\n ensures Factorial_12406(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_12406(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_12407","instance":12407,"id":232422,"goal":"function Fib_12407(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_12407(n-1) + Fib_12407(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_12408","instance":12408,"id":232423,"goal":"function Gcd_12408(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_12408(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_12409","instance":12409,"id":232424,"goal":"function Power_12409(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_12409(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_12410","instance":12410,"id":232425,"goal":"function Sum_12410(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_12410(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_12411","instance":12411,"id":232426,"goal":"method BinarySearch_12411(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_12412","instance":12412,"id":232427,"goal":"method InsertSort_12412(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_12413","instance":12413,"id":232428,"goal":"method MergeSort_12413(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_12414","instance":12414,"id":232429,"goal":"method ArrayCopy_12414(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_12415","instance":12415,"id":232430,"goal":"function ListReverse_12415(s: seq): seq\n ensures |ListReverse_12415(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_12415(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_12416","instance":12416,"id":232431,"goal":"function Factorial_12416(n: nat): nat\n ensures Factorial_12416(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_12416(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_12417","instance":12417,"id":232432,"goal":"function Fib_12417(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_12417(n-1) + Fib_12417(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_12418","instance":12418,"id":232433,"goal":"function Gcd_12418(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_12418(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_12419","instance":12419,"id":232434,"goal":"function Power_12419(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_12419(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_12420","instance":12420,"id":232435,"goal":"function Sum_12420(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_12420(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_12421","instance":12421,"id":232436,"goal":"method BinarySearch_12421(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_12422","instance":12422,"id":232437,"goal":"method InsertSort_12422(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_12423","instance":12423,"id":232438,"goal":"method MergeSort_12423(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_12424","instance":12424,"id":232439,"goal":"method ArrayCopy_12424(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_12425","instance":12425,"id":232440,"goal":"function ListReverse_12425(s: seq): seq\n ensures |ListReverse_12425(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_12425(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_12426","instance":12426,"id":232441,"goal":"function Factorial_12426(n: nat): nat\n ensures Factorial_12426(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_12426(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_12427","instance":12427,"id":232442,"goal":"function Fib_12427(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_12427(n-1) + Fib_12427(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_12428","instance":12428,"id":232443,"goal":"function Gcd_12428(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_12428(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_12429","instance":12429,"id":232444,"goal":"function Power_12429(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_12429(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_12430","instance":12430,"id":232445,"goal":"function Sum_12430(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_12430(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_12431","instance":12431,"id":232446,"goal":"method BinarySearch_12431(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_12432","instance":12432,"id":232447,"goal":"method InsertSort_12432(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_12433","instance":12433,"id":232448,"goal":"method MergeSort_12433(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_12434","instance":12434,"id":232449,"goal":"method ArrayCopy_12434(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_12435","instance":12435,"id":232450,"goal":"function ListReverse_12435(s: seq): seq\n ensures |ListReverse_12435(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_12435(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_12436","instance":12436,"id":232451,"goal":"function Factorial_12436(n: nat): nat\n ensures Factorial_12436(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_12436(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_12437","instance":12437,"id":232452,"goal":"function Fib_12437(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_12437(n-1) + Fib_12437(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_12438","instance":12438,"id":232453,"goal":"function Gcd_12438(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_12438(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_12439","instance":12439,"id":232454,"goal":"function Power_12439(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_12439(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_12440","instance":12440,"id":232455,"goal":"function Sum_12440(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_12440(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_12441","instance":12441,"id":232456,"goal":"method BinarySearch_12441(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_12442","instance":12442,"id":232457,"goal":"method InsertSort_12442(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_12443","instance":12443,"id":232458,"goal":"method MergeSort_12443(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_12444","instance":12444,"id":232459,"goal":"method ArrayCopy_12444(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_12445","instance":12445,"id":232460,"goal":"function ListReverse_12445(s: seq): seq\n ensures |ListReverse_12445(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_12445(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_12446","instance":12446,"id":232461,"goal":"function Factorial_12446(n: nat): nat\n ensures Factorial_12446(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_12446(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_12447","instance":12447,"id":232462,"goal":"function Fib_12447(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_12447(n-1) + Fib_12447(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_12448","instance":12448,"id":232463,"goal":"function Gcd_12448(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_12448(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_12449","instance":12449,"id":232464,"goal":"function Power_12449(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_12449(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_12450","instance":12450,"id":232465,"goal":"function Sum_12450(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_12450(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_12451","instance":12451,"id":232466,"goal":"method BinarySearch_12451(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_12452","instance":12452,"id":232467,"goal":"method InsertSort_12452(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_12453","instance":12453,"id":232468,"goal":"method MergeSort_12453(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_12454","instance":12454,"id":232469,"goal":"method ArrayCopy_12454(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_12455","instance":12455,"id":232470,"goal":"function ListReverse_12455(s: seq): seq\n ensures |ListReverse_12455(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_12455(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_12456","instance":12456,"id":232471,"goal":"function Factorial_12456(n: nat): nat\n ensures Factorial_12456(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_12456(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_12457","instance":12457,"id":232472,"goal":"function Fib_12457(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_12457(n-1) + Fib_12457(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_12458","instance":12458,"id":232473,"goal":"function Gcd_12458(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_12458(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_12459","instance":12459,"id":232474,"goal":"function Power_12459(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_12459(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_12460","instance":12460,"id":232475,"goal":"function Sum_12460(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_12460(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_12461","instance":12461,"id":232476,"goal":"method BinarySearch_12461(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_12462","instance":12462,"id":232477,"goal":"method InsertSort_12462(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_12463","instance":12463,"id":232478,"goal":"method MergeSort_12463(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_12464","instance":12464,"id":232479,"goal":"method ArrayCopy_12464(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_12465","instance":12465,"id":232480,"goal":"function ListReverse_12465(s: seq): seq\n ensures |ListReverse_12465(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_12465(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_12466","instance":12466,"id":232481,"goal":"function Factorial_12466(n: nat): nat\n ensures Factorial_12466(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_12466(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_12467","instance":12467,"id":232482,"goal":"function Fib_12467(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_12467(n-1) + Fib_12467(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_12468","instance":12468,"id":232483,"goal":"function Gcd_12468(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_12468(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_12469","instance":12469,"id":232484,"goal":"function Power_12469(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_12469(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_12470","instance":12470,"id":232485,"goal":"function Sum_12470(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_12470(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_12471","instance":12471,"id":232486,"goal":"method BinarySearch_12471(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_12472","instance":12472,"id":232487,"goal":"method InsertSort_12472(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_12473","instance":12473,"id":232488,"goal":"method MergeSort_12473(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_12474","instance":12474,"id":232489,"goal":"method ArrayCopy_12474(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_12475","instance":12475,"id":232490,"goal":"function ListReverse_12475(s: seq): seq\n ensures |ListReverse_12475(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_12475(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_12476","instance":12476,"id":232491,"goal":"function Factorial_12476(n: nat): nat\n ensures Factorial_12476(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_12476(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_12477","instance":12477,"id":232492,"goal":"function Fib_12477(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_12477(n-1) + Fib_12477(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_12478","instance":12478,"id":232493,"goal":"function Gcd_12478(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_12478(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_12479","instance":12479,"id":232494,"goal":"function Power_12479(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_12479(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_12480","instance":12480,"id":232495,"goal":"function Sum_12480(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_12480(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_12481","instance":12481,"id":232496,"goal":"method BinarySearch_12481(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_12482","instance":12482,"id":232497,"goal":"method InsertSort_12482(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_12483","instance":12483,"id":232498,"goal":"method MergeSort_12483(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_12484","instance":12484,"id":232499,"goal":"method ArrayCopy_12484(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_12485","instance":12485,"id":232500,"goal":"function ListReverse_12485(s: seq): seq\n ensures |ListReverse_12485(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_12485(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_12486","instance":12486,"id":232501,"goal":"function Factorial_12486(n: nat): nat\n ensures Factorial_12486(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_12486(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_12487","instance":12487,"id":232502,"goal":"function Fib_12487(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_12487(n-1) + Fib_12487(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_12488","instance":12488,"id":232503,"goal":"function Gcd_12488(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_12488(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_12489","instance":12489,"id":232504,"goal":"function Power_12489(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_12489(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_12490","instance":12490,"id":232505,"goal":"function Sum_12490(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_12490(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_12491","instance":12491,"id":232506,"goal":"method BinarySearch_12491(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_12492","instance":12492,"id":232507,"goal":"method InsertSort_12492(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_12493","instance":12493,"id":232508,"goal":"method MergeSort_12493(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_12494","instance":12494,"id":232509,"goal":"method ArrayCopy_12494(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_12495","instance":12495,"id":232510,"goal":"function ListReverse_12495(s: seq): seq\n ensures |ListReverse_12495(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_12495(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_12496","instance":12496,"id":232511,"goal":"function Factorial_12496(n: nat): nat\n ensures Factorial_12496(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_12496(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_12497","instance":12497,"id":232512,"goal":"function Fib_12497(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_12497(n-1) + Fib_12497(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_12498","instance":12498,"id":232513,"goal":"function Gcd_12498(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_12498(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_12499","instance":12499,"id":232514,"goal":"function Power_12499(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_12499(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_12500","instance":12500,"id":232515,"goal":"function Sum_12500(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_12500(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_12501","instance":12501,"id":232516,"goal":"method BinarySearch_12501(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_12502","instance":12502,"id":232517,"goal":"method InsertSort_12502(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_12503","instance":12503,"id":232518,"goal":"method MergeSort_12503(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_12504","instance":12504,"id":232519,"goal":"method ArrayCopy_12504(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_12505","instance":12505,"id":232520,"goal":"function ListReverse_12505(s: seq): seq\n ensures |ListReverse_12505(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_12505(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_12506","instance":12506,"id":232521,"goal":"function Factorial_12506(n: nat): nat\n ensures Factorial_12506(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_12506(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_12507","instance":12507,"id":232522,"goal":"function Fib_12507(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_12507(n-1) + Fib_12507(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_12508","instance":12508,"id":232523,"goal":"function Gcd_12508(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_12508(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_12509","instance":12509,"id":232524,"goal":"function Power_12509(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_12509(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_12510","instance":12510,"id":232525,"goal":"function Sum_12510(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_12510(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_12511","instance":12511,"id":232526,"goal":"method BinarySearch_12511(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_12512","instance":12512,"id":232527,"goal":"method InsertSort_12512(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_12513","instance":12513,"id":232528,"goal":"method MergeSort_12513(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_12514","instance":12514,"id":232529,"goal":"method ArrayCopy_12514(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_12515","instance":12515,"id":232530,"goal":"function ListReverse_12515(s: seq): seq\n ensures |ListReverse_12515(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_12515(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_12516","instance":12516,"id":232531,"goal":"function Factorial_12516(n: nat): nat\n ensures Factorial_12516(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_12516(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_12517","instance":12517,"id":232532,"goal":"function Fib_12517(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_12517(n-1) + Fib_12517(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_12518","instance":12518,"id":232533,"goal":"function Gcd_12518(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_12518(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_12519","instance":12519,"id":232534,"goal":"function Power_12519(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_12519(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_12520","instance":12520,"id":232535,"goal":"function Sum_12520(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_12520(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_12521","instance":12521,"id":232536,"goal":"method BinarySearch_12521(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_12522","instance":12522,"id":232537,"goal":"method InsertSort_12522(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_12523","instance":12523,"id":232538,"goal":"method MergeSort_12523(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_12524","instance":12524,"id":232539,"goal":"method ArrayCopy_12524(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_12525","instance":12525,"id":232540,"goal":"function ListReverse_12525(s: seq): seq\n ensures |ListReverse_12525(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_12525(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_12526","instance":12526,"id":232541,"goal":"function Factorial_12526(n: nat): nat\n ensures Factorial_12526(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_12526(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_12527","instance":12527,"id":232542,"goal":"function Fib_12527(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_12527(n-1) + Fib_12527(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_12528","instance":12528,"id":232543,"goal":"function Gcd_12528(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_12528(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_12529","instance":12529,"id":232544,"goal":"function Power_12529(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_12529(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_12530","instance":12530,"id":232545,"goal":"function Sum_12530(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_12530(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_12531","instance":12531,"id":232546,"goal":"method BinarySearch_12531(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_12532","instance":12532,"id":232547,"goal":"method InsertSort_12532(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_12533","instance":12533,"id":232548,"goal":"method MergeSort_12533(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_12534","instance":12534,"id":232549,"goal":"method ArrayCopy_12534(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_12535","instance":12535,"id":232550,"goal":"function ListReverse_12535(s: seq): seq\n ensures |ListReverse_12535(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_12535(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_12536","instance":12536,"id":232551,"goal":"function Factorial_12536(n: nat): nat\n ensures Factorial_12536(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_12536(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_12537","instance":12537,"id":232552,"goal":"function Fib_12537(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_12537(n-1) + Fib_12537(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_12538","instance":12538,"id":232553,"goal":"function Gcd_12538(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_12538(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_12539","instance":12539,"id":232554,"goal":"function Power_12539(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_12539(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_12540","instance":12540,"id":232555,"goal":"function Sum_12540(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_12540(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_12541","instance":12541,"id":232556,"goal":"method BinarySearch_12541(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_12542","instance":12542,"id":232557,"goal":"method InsertSort_12542(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_12543","instance":12543,"id":232558,"goal":"method MergeSort_12543(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_12544","instance":12544,"id":232559,"goal":"method ArrayCopy_12544(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_12545","instance":12545,"id":232560,"goal":"function ListReverse_12545(s: seq): seq\n ensures |ListReverse_12545(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_12545(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_12546","instance":12546,"id":232561,"goal":"function Factorial_12546(n: nat): nat\n ensures Factorial_12546(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_12546(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_12547","instance":12547,"id":232562,"goal":"function Fib_12547(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_12547(n-1) + Fib_12547(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_12548","instance":12548,"id":232563,"goal":"function Gcd_12548(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_12548(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_12549","instance":12549,"id":232564,"goal":"function Power_12549(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_12549(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_12550","instance":12550,"id":232565,"goal":"function Sum_12550(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_12550(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_12551","instance":12551,"id":232566,"goal":"method BinarySearch_12551(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_12552","instance":12552,"id":232567,"goal":"method InsertSort_12552(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_12553","instance":12553,"id":232568,"goal":"method MergeSort_12553(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_12554","instance":12554,"id":232569,"goal":"method ArrayCopy_12554(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_12555","instance":12555,"id":232570,"goal":"function ListReverse_12555(s: seq): seq\n ensures |ListReverse_12555(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_12555(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_12556","instance":12556,"id":232571,"goal":"function Factorial_12556(n: nat): nat\n ensures Factorial_12556(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_12556(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_12557","instance":12557,"id":232572,"goal":"function Fib_12557(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_12557(n-1) + Fib_12557(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_12558","instance":12558,"id":232573,"goal":"function Gcd_12558(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_12558(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_12559","instance":12559,"id":232574,"goal":"function Power_12559(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_12559(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_12560","instance":12560,"id":232575,"goal":"function Sum_12560(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_12560(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_12561","instance":12561,"id":232576,"goal":"method BinarySearch_12561(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_12562","instance":12562,"id":232577,"goal":"method InsertSort_12562(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_12563","instance":12563,"id":232578,"goal":"method MergeSort_12563(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_12564","instance":12564,"id":232579,"goal":"method ArrayCopy_12564(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_12565","instance":12565,"id":232580,"goal":"function ListReverse_12565(s: seq): seq\n ensures |ListReverse_12565(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_12565(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_12566","instance":12566,"id":232581,"goal":"function Factorial_12566(n: nat): nat\n ensures Factorial_12566(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_12566(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_12567","instance":12567,"id":232582,"goal":"function Fib_12567(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_12567(n-1) + Fib_12567(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_12568","instance":12568,"id":232583,"goal":"function Gcd_12568(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_12568(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_12569","instance":12569,"id":232584,"goal":"function Power_12569(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_12569(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_12570","instance":12570,"id":232585,"goal":"function Sum_12570(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_12570(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_12571","instance":12571,"id":232586,"goal":"method BinarySearch_12571(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_12572","instance":12572,"id":232587,"goal":"method InsertSort_12572(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_12573","instance":12573,"id":232588,"goal":"method MergeSort_12573(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_12574","instance":12574,"id":232589,"goal":"method ArrayCopy_12574(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_12575","instance":12575,"id":232590,"goal":"function ListReverse_12575(s: seq): seq\n ensures |ListReverse_12575(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_12575(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_12576","instance":12576,"id":232591,"goal":"function Factorial_12576(n: nat): nat\n ensures Factorial_12576(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_12576(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_12577","instance":12577,"id":232592,"goal":"function Fib_12577(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_12577(n-1) + Fib_12577(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_12578","instance":12578,"id":232593,"goal":"function Gcd_12578(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_12578(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_12579","instance":12579,"id":232594,"goal":"function Power_12579(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_12579(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_12580","instance":12580,"id":232595,"goal":"function Sum_12580(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_12580(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_12581","instance":12581,"id":232596,"goal":"method BinarySearch_12581(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_12582","instance":12582,"id":232597,"goal":"method InsertSort_12582(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_12583","instance":12583,"id":232598,"goal":"method MergeSort_12583(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_12584","instance":12584,"id":232599,"goal":"method ArrayCopy_12584(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_12585","instance":12585,"id":232600,"goal":"function ListReverse_12585(s: seq): seq\n ensures |ListReverse_12585(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_12585(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_12586","instance":12586,"id":232601,"goal":"function Factorial_12586(n: nat): nat\n ensures Factorial_12586(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_12586(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_12587","instance":12587,"id":232602,"goal":"function Fib_12587(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_12587(n-1) + Fib_12587(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_12588","instance":12588,"id":232603,"goal":"function Gcd_12588(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_12588(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_12589","instance":12589,"id":232604,"goal":"function Power_12589(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_12589(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_12590","instance":12590,"id":232605,"goal":"function Sum_12590(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_12590(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_12591","instance":12591,"id":232606,"goal":"method BinarySearch_12591(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_12592","instance":12592,"id":232607,"goal":"method InsertSort_12592(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_12593","instance":12593,"id":232608,"goal":"method MergeSort_12593(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_12594","instance":12594,"id":232609,"goal":"method ArrayCopy_12594(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_12595","instance":12595,"id":232610,"goal":"function ListReverse_12595(s: seq): seq\n ensures |ListReverse_12595(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_12595(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_12596","instance":12596,"id":232611,"goal":"function Factorial_12596(n: nat): nat\n ensures Factorial_12596(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_12596(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_12597","instance":12597,"id":232612,"goal":"function Fib_12597(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_12597(n-1) + Fib_12597(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_12598","instance":12598,"id":232613,"goal":"function Gcd_12598(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_12598(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_12599","instance":12599,"id":232614,"goal":"function Power_12599(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_12599(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_12600","instance":12600,"id":232615,"goal":"function Sum_12600(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_12600(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_12601","instance":12601,"id":232616,"goal":"method BinarySearch_12601(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_12602","instance":12602,"id":232617,"goal":"method InsertSort_12602(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_12603","instance":12603,"id":232618,"goal":"method MergeSort_12603(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_12604","instance":12604,"id":232619,"goal":"method ArrayCopy_12604(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_12605","instance":12605,"id":232620,"goal":"function ListReverse_12605(s: seq): seq\n ensures |ListReverse_12605(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_12605(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_12606","instance":12606,"id":232621,"goal":"function Factorial_12606(n: nat): nat\n ensures Factorial_12606(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_12606(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_12607","instance":12607,"id":232622,"goal":"function Fib_12607(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_12607(n-1) + Fib_12607(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_12608","instance":12608,"id":232623,"goal":"function Gcd_12608(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_12608(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_12609","instance":12609,"id":232624,"goal":"function Power_12609(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_12609(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_12610","instance":12610,"id":232625,"goal":"function Sum_12610(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_12610(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_12611","instance":12611,"id":232626,"goal":"method BinarySearch_12611(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_12612","instance":12612,"id":232627,"goal":"method InsertSort_12612(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_12613","instance":12613,"id":232628,"goal":"method MergeSort_12613(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_12614","instance":12614,"id":232629,"goal":"method ArrayCopy_12614(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_12615","instance":12615,"id":232630,"goal":"function ListReverse_12615(s: seq): seq\n ensures |ListReverse_12615(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_12615(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_12616","instance":12616,"id":232631,"goal":"function Factorial_12616(n: nat): nat\n ensures Factorial_12616(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_12616(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_12617","instance":12617,"id":232632,"goal":"function Fib_12617(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_12617(n-1) + Fib_12617(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_12618","instance":12618,"id":232633,"goal":"function Gcd_12618(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_12618(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_12619","instance":12619,"id":232634,"goal":"function Power_12619(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_12619(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_12620","instance":12620,"id":232635,"goal":"function Sum_12620(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_12620(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_12621","instance":12621,"id":232636,"goal":"method BinarySearch_12621(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_12622","instance":12622,"id":232637,"goal":"method InsertSort_12622(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_12623","instance":12623,"id":232638,"goal":"method MergeSort_12623(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_12624","instance":12624,"id":232639,"goal":"method ArrayCopy_12624(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_12625","instance":12625,"id":232640,"goal":"function ListReverse_12625(s: seq): seq\n ensures |ListReverse_12625(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_12625(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_12626","instance":12626,"id":232641,"goal":"function Factorial_12626(n: nat): nat\n ensures Factorial_12626(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_12626(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_12627","instance":12627,"id":232642,"goal":"function Fib_12627(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_12627(n-1) + Fib_12627(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_12628","instance":12628,"id":232643,"goal":"function Gcd_12628(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_12628(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_12629","instance":12629,"id":232644,"goal":"function Power_12629(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_12629(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_12630","instance":12630,"id":232645,"goal":"function Sum_12630(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_12630(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_12631","instance":12631,"id":232646,"goal":"method BinarySearch_12631(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_12632","instance":12632,"id":232647,"goal":"method InsertSort_12632(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_12633","instance":12633,"id":232648,"goal":"method MergeSort_12633(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_12634","instance":12634,"id":232649,"goal":"method ArrayCopy_12634(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_12635","instance":12635,"id":232650,"goal":"function ListReverse_12635(s: seq): seq\n ensures |ListReverse_12635(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_12635(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_12636","instance":12636,"id":232651,"goal":"function Factorial_12636(n: nat): nat\n ensures Factorial_12636(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_12636(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_12637","instance":12637,"id":232652,"goal":"function Fib_12637(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_12637(n-1) + Fib_12637(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_12638","instance":12638,"id":232653,"goal":"function Gcd_12638(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_12638(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_12639","instance":12639,"id":232654,"goal":"function Power_12639(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_12639(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_12640","instance":12640,"id":232655,"goal":"function Sum_12640(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_12640(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_12641","instance":12641,"id":232656,"goal":"method BinarySearch_12641(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_12642","instance":12642,"id":232657,"goal":"method InsertSort_12642(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_12643","instance":12643,"id":232658,"goal":"method MergeSort_12643(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_12644","instance":12644,"id":232659,"goal":"method ArrayCopy_12644(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_12645","instance":12645,"id":232660,"goal":"function ListReverse_12645(s: seq): seq\n ensures |ListReverse_12645(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_12645(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_12646","instance":12646,"id":232661,"goal":"function Factorial_12646(n: nat): nat\n ensures Factorial_12646(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_12646(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_12647","instance":12647,"id":232662,"goal":"function Fib_12647(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_12647(n-1) + Fib_12647(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_12648","instance":12648,"id":232663,"goal":"function Gcd_12648(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_12648(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_12649","instance":12649,"id":232664,"goal":"function Power_12649(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_12649(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_12650","instance":12650,"id":232665,"goal":"function Sum_12650(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_12650(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_12651","instance":12651,"id":232666,"goal":"method BinarySearch_12651(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_12652","instance":12652,"id":232667,"goal":"method InsertSort_12652(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_12653","instance":12653,"id":232668,"goal":"method MergeSort_12653(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_12654","instance":12654,"id":232669,"goal":"method ArrayCopy_12654(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_12655","instance":12655,"id":232670,"goal":"function ListReverse_12655(s: seq): seq\n ensures |ListReverse_12655(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_12655(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_12656","instance":12656,"id":232671,"goal":"function Factorial_12656(n: nat): nat\n ensures Factorial_12656(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_12656(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_12657","instance":12657,"id":232672,"goal":"function Fib_12657(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_12657(n-1) + Fib_12657(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_12658","instance":12658,"id":232673,"goal":"function Gcd_12658(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_12658(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_12659","instance":12659,"id":232674,"goal":"function Power_12659(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_12659(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_12660","instance":12660,"id":232675,"goal":"function Sum_12660(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_12660(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_12661","instance":12661,"id":232676,"goal":"method BinarySearch_12661(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_12662","instance":12662,"id":232677,"goal":"method InsertSort_12662(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_12663","instance":12663,"id":232678,"goal":"method MergeSort_12663(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_12664","instance":12664,"id":232679,"goal":"method ArrayCopy_12664(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_12665","instance":12665,"id":232680,"goal":"function ListReverse_12665(s: seq): seq\n ensures |ListReverse_12665(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_12665(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_12666","instance":12666,"id":232681,"goal":"function Factorial_12666(n: nat): nat\n ensures Factorial_12666(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_12666(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_12667","instance":12667,"id":232682,"goal":"function Fib_12667(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_12667(n-1) + Fib_12667(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_12668","instance":12668,"id":232683,"goal":"function Gcd_12668(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_12668(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_12669","instance":12669,"id":232684,"goal":"function Power_12669(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_12669(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_12670","instance":12670,"id":232685,"goal":"function Sum_12670(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_12670(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_12671","instance":12671,"id":232686,"goal":"method BinarySearch_12671(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_12672","instance":12672,"id":232687,"goal":"method InsertSort_12672(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_12673","instance":12673,"id":232688,"goal":"method MergeSort_12673(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_12674","instance":12674,"id":232689,"goal":"method ArrayCopy_12674(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_12675","instance":12675,"id":232690,"goal":"function ListReverse_12675(s: seq): seq\n ensures |ListReverse_12675(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_12675(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_12676","instance":12676,"id":232691,"goal":"function Factorial_12676(n: nat): nat\n ensures Factorial_12676(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_12676(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_12677","instance":12677,"id":232692,"goal":"function Fib_12677(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_12677(n-1) + Fib_12677(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_12678","instance":12678,"id":232693,"goal":"function Gcd_12678(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_12678(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_12679","instance":12679,"id":232694,"goal":"function Power_12679(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_12679(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_12680","instance":12680,"id":232695,"goal":"function Sum_12680(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_12680(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_12681","instance":12681,"id":232696,"goal":"method BinarySearch_12681(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_12682","instance":12682,"id":232697,"goal":"method InsertSort_12682(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_12683","instance":12683,"id":232698,"goal":"method MergeSort_12683(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_12684","instance":12684,"id":232699,"goal":"method ArrayCopy_12684(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_12685","instance":12685,"id":232700,"goal":"function ListReverse_12685(s: seq): seq\n ensures |ListReverse_12685(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_12685(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_12686","instance":12686,"id":232701,"goal":"function Factorial_12686(n: nat): nat\n ensures Factorial_12686(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_12686(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_12687","instance":12687,"id":232702,"goal":"function Fib_12687(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_12687(n-1) + Fib_12687(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_12688","instance":12688,"id":232703,"goal":"function Gcd_12688(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_12688(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_12689","instance":12689,"id":232704,"goal":"function Power_12689(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_12689(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_12690","instance":12690,"id":232705,"goal":"function Sum_12690(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_12690(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_12691","instance":12691,"id":232706,"goal":"method BinarySearch_12691(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_12692","instance":12692,"id":232707,"goal":"method InsertSort_12692(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_12693","instance":12693,"id":232708,"goal":"method MergeSort_12693(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_12694","instance":12694,"id":232709,"goal":"method ArrayCopy_12694(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_12695","instance":12695,"id":232710,"goal":"function ListReverse_12695(s: seq): seq\n ensures |ListReverse_12695(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_12695(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_12696","instance":12696,"id":232711,"goal":"function Factorial_12696(n: nat): nat\n ensures Factorial_12696(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_12696(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_12697","instance":12697,"id":232712,"goal":"function Fib_12697(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_12697(n-1) + Fib_12697(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_12698","instance":12698,"id":232713,"goal":"function Gcd_12698(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_12698(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_12699","instance":12699,"id":232714,"goal":"function Power_12699(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_12699(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_12700","instance":12700,"id":232715,"goal":"function Sum_12700(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_12700(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_12701","instance":12701,"id":232716,"goal":"method BinarySearch_12701(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_12702","instance":12702,"id":232717,"goal":"method InsertSort_12702(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_12703","instance":12703,"id":232718,"goal":"method MergeSort_12703(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_12704","instance":12704,"id":232719,"goal":"method ArrayCopy_12704(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_12705","instance":12705,"id":232720,"goal":"function ListReverse_12705(s: seq): seq\n ensures |ListReverse_12705(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_12705(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_12706","instance":12706,"id":232721,"goal":"function Factorial_12706(n: nat): nat\n ensures Factorial_12706(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_12706(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_12707","instance":12707,"id":232722,"goal":"function Fib_12707(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_12707(n-1) + Fib_12707(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_12708","instance":12708,"id":232723,"goal":"function Gcd_12708(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_12708(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_12709","instance":12709,"id":232724,"goal":"function Power_12709(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_12709(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_12710","instance":12710,"id":232725,"goal":"function Sum_12710(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_12710(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_12711","instance":12711,"id":232726,"goal":"method BinarySearch_12711(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_12712","instance":12712,"id":232727,"goal":"method InsertSort_12712(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_12713","instance":12713,"id":232728,"goal":"method MergeSort_12713(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_12714","instance":12714,"id":232729,"goal":"method ArrayCopy_12714(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_12715","instance":12715,"id":232730,"goal":"function ListReverse_12715(s: seq): seq\n ensures |ListReverse_12715(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_12715(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_12716","instance":12716,"id":232731,"goal":"function Factorial_12716(n: nat): nat\n ensures Factorial_12716(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_12716(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_12717","instance":12717,"id":232732,"goal":"function Fib_12717(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_12717(n-1) + Fib_12717(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_12718","instance":12718,"id":232733,"goal":"function Gcd_12718(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_12718(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_12719","instance":12719,"id":232734,"goal":"function Power_12719(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_12719(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_12720","instance":12720,"id":232735,"goal":"function Sum_12720(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_12720(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_12721","instance":12721,"id":232736,"goal":"method BinarySearch_12721(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_12722","instance":12722,"id":232737,"goal":"method InsertSort_12722(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_12723","instance":12723,"id":232738,"goal":"method MergeSort_12723(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_12724","instance":12724,"id":232739,"goal":"method ArrayCopy_12724(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_12725","instance":12725,"id":232740,"goal":"function ListReverse_12725(s: seq): seq\n ensures |ListReverse_12725(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_12725(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_12726","instance":12726,"id":232741,"goal":"function Factorial_12726(n: nat): nat\n ensures Factorial_12726(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_12726(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_12727","instance":12727,"id":232742,"goal":"function Fib_12727(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_12727(n-1) + Fib_12727(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_12728","instance":12728,"id":232743,"goal":"function Gcd_12728(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_12728(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_12729","instance":12729,"id":232744,"goal":"function Power_12729(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_12729(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_12730","instance":12730,"id":232745,"goal":"function Sum_12730(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_12730(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_12731","instance":12731,"id":232746,"goal":"method BinarySearch_12731(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_12732","instance":12732,"id":232747,"goal":"method InsertSort_12732(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_12733","instance":12733,"id":232748,"goal":"method MergeSort_12733(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_12734","instance":12734,"id":232749,"goal":"method ArrayCopy_12734(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_12735","instance":12735,"id":232750,"goal":"function ListReverse_12735(s: seq): seq\n ensures |ListReverse_12735(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_12735(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_12736","instance":12736,"id":232751,"goal":"function Factorial_12736(n: nat): nat\n ensures Factorial_12736(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_12736(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_12737","instance":12737,"id":232752,"goal":"function Fib_12737(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_12737(n-1) + Fib_12737(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_12738","instance":12738,"id":232753,"goal":"function Gcd_12738(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_12738(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_12739","instance":12739,"id":232754,"goal":"function Power_12739(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_12739(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_12740","instance":12740,"id":232755,"goal":"function Sum_12740(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_12740(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_12741","instance":12741,"id":232756,"goal":"method BinarySearch_12741(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_12742","instance":12742,"id":232757,"goal":"method InsertSort_12742(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_12743","instance":12743,"id":232758,"goal":"method MergeSort_12743(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_12744","instance":12744,"id":232759,"goal":"method ArrayCopy_12744(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_12745","instance":12745,"id":232760,"goal":"function ListReverse_12745(s: seq): seq\n ensures |ListReverse_12745(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_12745(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_12746","instance":12746,"id":232761,"goal":"function Factorial_12746(n: nat): nat\n ensures Factorial_12746(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_12746(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_12747","instance":12747,"id":232762,"goal":"function Fib_12747(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_12747(n-1) + Fib_12747(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_12748","instance":12748,"id":232763,"goal":"function Gcd_12748(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_12748(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_12749","instance":12749,"id":232764,"goal":"function Power_12749(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_12749(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_12750","instance":12750,"id":232765,"goal":"function Sum_12750(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_12750(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_12751","instance":12751,"id":232766,"goal":"method BinarySearch_12751(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_12752","instance":12752,"id":232767,"goal":"method InsertSort_12752(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_12753","instance":12753,"id":232768,"goal":"method MergeSort_12753(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_12754","instance":12754,"id":232769,"goal":"method ArrayCopy_12754(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_12755","instance":12755,"id":232770,"goal":"function ListReverse_12755(s: seq): seq\n ensures |ListReverse_12755(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_12755(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_12756","instance":12756,"id":232771,"goal":"function Factorial_12756(n: nat): nat\n ensures Factorial_12756(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_12756(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_12757","instance":12757,"id":232772,"goal":"function Fib_12757(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_12757(n-1) + Fib_12757(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_12758","instance":12758,"id":232773,"goal":"function Gcd_12758(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_12758(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_12759","instance":12759,"id":232774,"goal":"function Power_12759(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_12759(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_12760","instance":12760,"id":232775,"goal":"function Sum_12760(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_12760(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_12761","instance":12761,"id":232776,"goal":"method BinarySearch_12761(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_12762","instance":12762,"id":232777,"goal":"method InsertSort_12762(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_12763","instance":12763,"id":232778,"goal":"method MergeSort_12763(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_12764","instance":12764,"id":232779,"goal":"method ArrayCopy_12764(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_12765","instance":12765,"id":232780,"goal":"function ListReverse_12765(s: seq): seq\n ensures |ListReverse_12765(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_12765(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_12766","instance":12766,"id":232781,"goal":"function Factorial_12766(n: nat): nat\n ensures Factorial_12766(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_12766(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_12767","instance":12767,"id":232782,"goal":"function Fib_12767(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_12767(n-1) + Fib_12767(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_12768","instance":12768,"id":232783,"goal":"function Gcd_12768(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_12768(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_12769","instance":12769,"id":232784,"goal":"function Power_12769(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_12769(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_12770","instance":12770,"id":232785,"goal":"function Sum_12770(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_12770(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_12771","instance":12771,"id":232786,"goal":"method BinarySearch_12771(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_12772","instance":12772,"id":232787,"goal":"method InsertSort_12772(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_12773","instance":12773,"id":232788,"goal":"method MergeSort_12773(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_12774","instance":12774,"id":232789,"goal":"method ArrayCopy_12774(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_12775","instance":12775,"id":232790,"goal":"function ListReverse_12775(s: seq): seq\n ensures |ListReverse_12775(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_12775(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_12776","instance":12776,"id":232791,"goal":"function Factorial_12776(n: nat): nat\n ensures Factorial_12776(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_12776(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_12777","instance":12777,"id":232792,"goal":"function Fib_12777(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_12777(n-1) + Fib_12777(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_12778","instance":12778,"id":232793,"goal":"function Gcd_12778(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_12778(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_12779","instance":12779,"id":232794,"goal":"function Power_12779(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_12779(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_12780","instance":12780,"id":232795,"goal":"function Sum_12780(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_12780(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_12781","instance":12781,"id":232796,"goal":"method BinarySearch_12781(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_12782","instance":12782,"id":232797,"goal":"method InsertSort_12782(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_12783","instance":12783,"id":232798,"goal":"method MergeSort_12783(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_12784","instance":12784,"id":232799,"goal":"method ArrayCopy_12784(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_12785","instance":12785,"id":232800,"goal":"function ListReverse_12785(s: seq): seq\n ensures |ListReverse_12785(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_12785(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_12786","instance":12786,"id":232801,"goal":"function Factorial_12786(n: nat): nat\n ensures Factorial_12786(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_12786(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_12787","instance":12787,"id":232802,"goal":"function Fib_12787(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_12787(n-1) + Fib_12787(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_12788","instance":12788,"id":232803,"goal":"function Gcd_12788(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_12788(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_12789","instance":12789,"id":232804,"goal":"function Power_12789(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_12789(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_12790","instance":12790,"id":232805,"goal":"function Sum_12790(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_12790(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_12791","instance":12791,"id":232806,"goal":"method BinarySearch_12791(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_12792","instance":12792,"id":232807,"goal":"method InsertSort_12792(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_12793","instance":12793,"id":232808,"goal":"method MergeSort_12793(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_12794","instance":12794,"id":232809,"goal":"method ArrayCopy_12794(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_12795","instance":12795,"id":232810,"goal":"function ListReverse_12795(s: seq): seq\n ensures |ListReverse_12795(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_12795(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_12796","instance":12796,"id":232811,"goal":"function Factorial_12796(n: nat): nat\n ensures Factorial_12796(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_12796(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_12797","instance":12797,"id":232812,"goal":"function Fib_12797(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_12797(n-1) + Fib_12797(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_12798","instance":12798,"id":232813,"goal":"function Gcd_12798(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_12798(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_12799","instance":12799,"id":232814,"goal":"function Power_12799(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_12799(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_12800","instance":12800,"id":232815,"goal":"function Sum_12800(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_12800(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_12801","instance":12801,"id":232816,"goal":"method BinarySearch_12801(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_12802","instance":12802,"id":232817,"goal":"method InsertSort_12802(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_12803","instance":12803,"id":232818,"goal":"method MergeSort_12803(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_12804","instance":12804,"id":232819,"goal":"method ArrayCopy_12804(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_12805","instance":12805,"id":232820,"goal":"function ListReverse_12805(s: seq): seq\n ensures |ListReverse_12805(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_12805(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_12806","instance":12806,"id":232821,"goal":"function Factorial_12806(n: nat): nat\n ensures Factorial_12806(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_12806(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_12807","instance":12807,"id":232822,"goal":"function Fib_12807(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_12807(n-1) + Fib_12807(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_12808","instance":12808,"id":232823,"goal":"function Gcd_12808(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_12808(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_12809","instance":12809,"id":232824,"goal":"function Power_12809(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_12809(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_12810","instance":12810,"id":232825,"goal":"function Sum_12810(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_12810(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_12811","instance":12811,"id":232826,"goal":"method BinarySearch_12811(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_12812","instance":12812,"id":232827,"goal":"method InsertSort_12812(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_12813","instance":12813,"id":232828,"goal":"method MergeSort_12813(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_12814","instance":12814,"id":232829,"goal":"method ArrayCopy_12814(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_12815","instance":12815,"id":232830,"goal":"function ListReverse_12815(s: seq): seq\n ensures |ListReverse_12815(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_12815(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_12816","instance":12816,"id":232831,"goal":"function Factorial_12816(n: nat): nat\n ensures Factorial_12816(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_12816(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_12817","instance":12817,"id":232832,"goal":"function Fib_12817(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_12817(n-1) + Fib_12817(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_12818","instance":12818,"id":232833,"goal":"function Gcd_12818(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_12818(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_12819","instance":12819,"id":232834,"goal":"function Power_12819(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_12819(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_12820","instance":12820,"id":232835,"goal":"function Sum_12820(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_12820(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_12821","instance":12821,"id":232836,"goal":"method BinarySearch_12821(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_12822","instance":12822,"id":232837,"goal":"method InsertSort_12822(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_12823","instance":12823,"id":232838,"goal":"method MergeSort_12823(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_12824","instance":12824,"id":232839,"goal":"method ArrayCopy_12824(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_12825","instance":12825,"id":232840,"goal":"function ListReverse_12825(s: seq): seq\n ensures |ListReverse_12825(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_12825(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_12826","instance":12826,"id":232841,"goal":"function Factorial_12826(n: nat): nat\n ensures Factorial_12826(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_12826(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_12827","instance":12827,"id":232842,"goal":"function Fib_12827(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_12827(n-1) + Fib_12827(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_12828","instance":12828,"id":232843,"goal":"function Gcd_12828(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_12828(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_12829","instance":12829,"id":232844,"goal":"function Power_12829(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_12829(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_12830","instance":12830,"id":232845,"goal":"function Sum_12830(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_12830(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_12831","instance":12831,"id":232846,"goal":"method BinarySearch_12831(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_12832","instance":12832,"id":232847,"goal":"method InsertSort_12832(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_12833","instance":12833,"id":232848,"goal":"method MergeSort_12833(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_12834","instance":12834,"id":232849,"goal":"method ArrayCopy_12834(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_12835","instance":12835,"id":232850,"goal":"function ListReverse_12835(s: seq): seq\n ensures |ListReverse_12835(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_12835(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_12836","instance":12836,"id":232851,"goal":"function Factorial_12836(n: nat): nat\n ensures Factorial_12836(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_12836(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_12837","instance":12837,"id":232852,"goal":"function Fib_12837(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_12837(n-1) + Fib_12837(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_12838","instance":12838,"id":232853,"goal":"function Gcd_12838(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_12838(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_12839","instance":12839,"id":232854,"goal":"function Power_12839(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_12839(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_12840","instance":12840,"id":232855,"goal":"function Sum_12840(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_12840(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_12841","instance":12841,"id":232856,"goal":"method BinarySearch_12841(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_12842","instance":12842,"id":232857,"goal":"method InsertSort_12842(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_12843","instance":12843,"id":232858,"goal":"method MergeSort_12843(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_12844","instance":12844,"id":232859,"goal":"method ArrayCopy_12844(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_12845","instance":12845,"id":232860,"goal":"function ListReverse_12845(s: seq): seq\n ensures |ListReverse_12845(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_12845(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_12846","instance":12846,"id":232861,"goal":"function Factorial_12846(n: nat): nat\n ensures Factorial_12846(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_12846(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_12847","instance":12847,"id":232862,"goal":"function Fib_12847(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_12847(n-1) + Fib_12847(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_12848","instance":12848,"id":232863,"goal":"function Gcd_12848(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_12848(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_12849","instance":12849,"id":232864,"goal":"function Power_12849(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_12849(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_12850","instance":12850,"id":232865,"goal":"function Sum_12850(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_12850(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_12851","instance":12851,"id":232866,"goal":"method BinarySearch_12851(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_12852","instance":12852,"id":232867,"goal":"method InsertSort_12852(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_12853","instance":12853,"id":232868,"goal":"method MergeSort_12853(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_12854","instance":12854,"id":232869,"goal":"method ArrayCopy_12854(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_12855","instance":12855,"id":232870,"goal":"function ListReverse_12855(s: seq): seq\n ensures |ListReverse_12855(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_12855(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_12856","instance":12856,"id":232871,"goal":"function Factorial_12856(n: nat): nat\n ensures Factorial_12856(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_12856(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_12857","instance":12857,"id":232872,"goal":"function Fib_12857(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_12857(n-1) + Fib_12857(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_12858","instance":12858,"id":232873,"goal":"function Gcd_12858(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_12858(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_12859","instance":12859,"id":232874,"goal":"function Power_12859(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_12859(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_12860","instance":12860,"id":232875,"goal":"function Sum_12860(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_12860(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_12861","instance":12861,"id":232876,"goal":"method BinarySearch_12861(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_12862","instance":12862,"id":232877,"goal":"method InsertSort_12862(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_12863","instance":12863,"id":232878,"goal":"method MergeSort_12863(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_12864","instance":12864,"id":232879,"goal":"method ArrayCopy_12864(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_12865","instance":12865,"id":232880,"goal":"function ListReverse_12865(s: seq): seq\n ensures |ListReverse_12865(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_12865(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_12866","instance":12866,"id":232881,"goal":"function Factorial_12866(n: nat): nat\n ensures Factorial_12866(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_12866(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_12867","instance":12867,"id":232882,"goal":"function Fib_12867(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_12867(n-1) + Fib_12867(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_12868","instance":12868,"id":232883,"goal":"function Gcd_12868(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_12868(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_12869","instance":12869,"id":232884,"goal":"function Power_12869(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_12869(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_12870","instance":12870,"id":232885,"goal":"function Sum_12870(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_12870(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_12871","instance":12871,"id":232886,"goal":"method BinarySearch_12871(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_12872","instance":12872,"id":232887,"goal":"method InsertSort_12872(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_12873","instance":12873,"id":232888,"goal":"method MergeSort_12873(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_12874","instance":12874,"id":232889,"goal":"method ArrayCopy_12874(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_12875","instance":12875,"id":232890,"goal":"function ListReverse_12875(s: seq): seq\n ensures |ListReverse_12875(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_12875(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_12876","instance":12876,"id":232891,"goal":"function Factorial_12876(n: nat): nat\n ensures Factorial_12876(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_12876(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_12877","instance":12877,"id":232892,"goal":"function Fib_12877(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_12877(n-1) + Fib_12877(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_12878","instance":12878,"id":232893,"goal":"function Gcd_12878(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_12878(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_12879","instance":12879,"id":232894,"goal":"function Power_12879(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_12879(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_12880","instance":12880,"id":232895,"goal":"function Sum_12880(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_12880(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_12881","instance":12881,"id":232896,"goal":"method BinarySearch_12881(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_12882","instance":12882,"id":232897,"goal":"method InsertSort_12882(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_12883","instance":12883,"id":232898,"goal":"method MergeSort_12883(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_12884","instance":12884,"id":232899,"goal":"method ArrayCopy_12884(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_12885","instance":12885,"id":232900,"goal":"function ListReverse_12885(s: seq): seq\n ensures |ListReverse_12885(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_12885(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_12886","instance":12886,"id":232901,"goal":"function Factorial_12886(n: nat): nat\n ensures Factorial_12886(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_12886(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_12887","instance":12887,"id":232902,"goal":"function Fib_12887(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_12887(n-1) + Fib_12887(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_12888","instance":12888,"id":232903,"goal":"function Gcd_12888(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_12888(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_12889","instance":12889,"id":232904,"goal":"function Power_12889(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_12889(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_12890","instance":12890,"id":232905,"goal":"function Sum_12890(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_12890(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_12891","instance":12891,"id":232906,"goal":"method BinarySearch_12891(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_12892","instance":12892,"id":232907,"goal":"method InsertSort_12892(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_12893","instance":12893,"id":232908,"goal":"method MergeSort_12893(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_12894","instance":12894,"id":232909,"goal":"method ArrayCopy_12894(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_12895","instance":12895,"id":232910,"goal":"function ListReverse_12895(s: seq): seq\n ensures |ListReverse_12895(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_12895(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_12896","instance":12896,"id":232911,"goal":"function Factorial_12896(n: nat): nat\n ensures Factorial_12896(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_12896(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_12897","instance":12897,"id":232912,"goal":"function Fib_12897(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_12897(n-1) + Fib_12897(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_12898","instance":12898,"id":232913,"goal":"function Gcd_12898(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_12898(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_12899","instance":12899,"id":232914,"goal":"function Power_12899(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_12899(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_12900","instance":12900,"id":232915,"goal":"function Sum_12900(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_12900(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_12901","instance":12901,"id":232916,"goal":"method BinarySearch_12901(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_12902","instance":12902,"id":232917,"goal":"method InsertSort_12902(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_12903","instance":12903,"id":232918,"goal":"method MergeSort_12903(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_12904","instance":12904,"id":232919,"goal":"method ArrayCopy_12904(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_12905","instance":12905,"id":232920,"goal":"function ListReverse_12905(s: seq): seq\n ensures |ListReverse_12905(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_12905(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_12906","instance":12906,"id":232921,"goal":"function Factorial_12906(n: nat): nat\n ensures Factorial_12906(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_12906(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_12907","instance":12907,"id":232922,"goal":"function Fib_12907(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_12907(n-1) + Fib_12907(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_12908","instance":12908,"id":232923,"goal":"function Gcd_12908(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_12908(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_12909","instance":12909,"id":232924,"goal":"function Power_12909(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_12909(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_12910","instance":12910,"id":232925,"goal":"function Sum_12910(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_12910(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_12911","instance":12911,"id":232926,"goal":"method BinarySearch_12911(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_12912","instance":12912,"id":232927,"goal":"method InsertSort_12912(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_12913","instance":12913,"id":232928,"goal":"method MergeSort_12913(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_12914","instance":12914,"id":232929,"goal":"method ArrayCopy_12914(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_12915","instance":12915,"id":232930,"goal":"function ListReverse_12915(s: seq): seq\n ensures |ListReverse_12915(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_12915(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_12916","instance":12916,"id":232931,"goal":"function Factorial_12916(n: nat): nat\n ensures Factorial_12916(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_12916(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_12917","instance":12917,"id":232932,"goal":"function Fib_12917(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_12917(n-1) + Fib_12917(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_12918","instance":12918,"id":232933,"goal":"function Gcd_12918(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_12918(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_12919","instance":12919,"id":232934,"goal":"function Power_12919(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_12919(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_12920","instance":12920,"id":232935,"goal":"function Sum_12920(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_12920(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_12921","instance":12921,"id":232936,"goal":"method BinarySearch_12921(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_12922","instance":12922,"id":232937,"goal":"method InsertSort_12922(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_12923","instance":12923,"id":232938,"goal":"method MergeSort_12923(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_12924","instance":12924,"id":232939,"goal":"method ArrayCopy_12924(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_12925","instance":12925,"id":232940,"goal":"function ListReverse_12925(s: seq): seq\n ensures |ListReverse_12925(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_12925(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_12926","instance":12926,"id":232941,"goal":"function Factorial_12926(n: nat): nat\n ensures Factorial_12926(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_12926(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_12927","instance":12927,"id":232942,"goal":"function Fib_12927(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_12927(n-1) + Fib_12927(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_12928","instance":12928,"id":232943,"goal":"function Gcd_12928(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_12928(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_12929","instance":12929,"id":232944,"goal":"function Power_12929(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_12929(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_12930","instance":12930,"id":232945,"goal":"function Sum_12930(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_12930(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_12931","instance":12931,"id":232946,"goal":"method BinarySearch_12931(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_12932","instance":12932,"id":232947,"goal":"method InsertSort_12932(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_12933","instance":12933,"id":232948,"goal":"method MergeSort_12933(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_12934","instance":12934,"id":232949,"goal":"method ArrayCopy_12934(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_12935","instance":12935,"id":232950,"goal":"function ListReverse_12935(s: seq): seq\n ensures |ListReverse_12935(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_12935(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_12936","instance":12936,"id":232951,"goal":"function Factorial_12936(n: nat): nat\n ensures Factorial_12936(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_12936(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_12937","instance":12937,"id":232952,"goal":"function Fib_12937(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_12937(n-1) + Fib_12937(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_12938","instance":12938,"id":232953,"goal":"function Gcd_12938(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_12938(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_12939","instance":12939,"id":232954,"goal":"function Power_12939(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_12939(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_12940","instance":12940,"id":232955,"goal":"function Sum_12940(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_12940(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_12941","instance":12941,"id":232956,"goal":"method BinarySearch_12941(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_12942","instance":12942,"id":232957,"goal":"method InsertSort_12942(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_12943","instance":12943,"id":232958,"goal":"method MergeSort_12943(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_12944","instance":12944,"id":232959,"goal":"method ArrayCopy_12944(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_12945","instance":12945,"id":232960,"goal":"function ListReverse_12945(s: seq): seq\n ensures |ListReverse_12945(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_12945(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_12946","instance":12946,"id":232961,"goal":"function Factorial_12946(n: nat): nat\n ensures Factorial_12946(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_12946(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_12947","instance":12947,"id":232962,"goal":"function Fib_12947(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_12947(n-1) + Fib_12947(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_12948","instance":12948,"id":232963,"goal":"function Gcd_12948(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_12948(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_12949","instance":12949,"id":232964,"goal":"function Power_12949(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_12949(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_12950","instance":12950,"id":232965,"goal":"function Sum_12950(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_12950(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_12951","instance":12951,"id":232966,"goal":"method BinarySearch_12951(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_12952","instance":12952,"id":232967,"goal":"method InsertSort_12952(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_12953","instance":12953,"id":232968,"goal":"method MergeSort_12953(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_12954","instance":12954,"id":232969,"goal":"method ArrayCopy_12954(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_12955","instance":12955,"id":232970,"goal":"function ListReverse_12955(s: seq): seq\n ensures |ListReverse_12955(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_12955(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_12956","instance":12956,"id":232971,"goal":"function Factorial_12956(n: nat): nat\n ensures Factorial_12956(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_12956(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_12957","instance":12957,"id":232972,"goal":"function Fib_12957(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_12957(n-1) + Fib_12957(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_12958","instance":12958,"id":232973,"goal":"function Gcd_12958(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_12958(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_12959","instance":12959,"id":232974,"goal":"function Power_12959(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_12959(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_12960","instance":12960,"id":232975,"goal":"function Sum_12960(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_12960(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_12961","instance":12961,"id":232976,"goal":"method BinarySearch_12961(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_12962","instance":12962,"id":232977,"goal":"method InsertSort_12962(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_12963","instance":12963,"id":232978,"goal":"method MergeSort_12963(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_12964","instance":12964,"id":232979,"goal":"method ArrayCopy_12964(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_12965","instance":12965,"id":232980,"goal":"function ListReverse_12965(s: seq): seq\n ensures |ListReverse_12965(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_12965(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_12966","instance":12966,"id":232981,"goal":"function Factorial_12966(n: nat): nat\n ensures Factorial_12966(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_12966(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_12967","instance":12967,"id":232982,"goal":"function Fib_12967(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_12967(n-1) + Fib_12967(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_12968","instance":12968,"id":232983,"goal":"function Gcd_12968(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_12968(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_12969","instance":12969,"id":232984,"goal":"function Power_12969(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_12969(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_12970","instance":12970,"id":232985,"goal":"function Sum_12970(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_12970(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_12971","instance":12971,"id":232986,"goal":"method BinarySearch_12971(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_12972","instance":12972,"id":232987,"goal":"method InsertSort_12972(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_12973","instance":12973,"id":232988,"goal":"method MergeSort_12973(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_12974","instance":12974,"id":232989,"goal":"method ArrayCopy_12974(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_12975","instance":12975,"id":232990,"goal":"function ListReverse_12975(s: seq): seq\n ensures |ListReverse_12975(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_12975(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_12976","instance":12976,"id":232991,"goal":"function Factorial_12976(n: nat): nat\n ensures Factorial_12976(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_12976(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_12977","instance":12977,"id":232992,"goal":"function Fib_12977(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_12977(n-1) + Fib_12977(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_12978","instance":12978,"id":232993,"goal":"function Gcd_12978(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_12978(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_12979","instance":12979,"id":232994,"goal":"function Power_12979(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_12979(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_12980","instance":12980,"id":232995,"goal":"function Sum_12980(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_12980(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_12981","instance":12981,"id":232996,"goal":"method BinarySearch_12981(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_12982","instance":12982,"id":232997,"goal":"method InsertSort_12982(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_12983","instance":12983,"id":232998,"goal":"method MergeSort_12983(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_12984","instance":12984,"id":232999,"goal":"method ArrayCopy_12984(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_12985","instance":12985,"id":233000,"goal":"function ListReverse_12985(s: seq): seq\n ensures |ListReverse_12985(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_12985(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_12986","instance":12986,"id":233001,"goal":"function Factorial_12986(n: nat): nat\n ensures Factorial_12986(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_12986(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_12987","instance":12987,"id":233002,"goal":"function Fib_12987(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_12987(n-1) + Fib_12987(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_12988","instance":12988,"id":233003,"goal":"function Gcd_12988(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_12988(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_12989","instance":12989,"id":233004,"goal":"function Power_12989(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_12989(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_12990","instance":12990,"id":233005,"goal":"function Sum_12990(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_12990(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_12991","instance":12991,"id":233006,"goal":"method BinarySearch_12991(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_12992","instance":12992,"id":233007,"goal":"method InsertSort_12992(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_12993","instance":12993,"id":233008,"goal":"method MergeSort_12993(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_12994","instance":12994,"id":233009,"goal":"method ArrayCopy_12994(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_12995","instance":12995,"id":233010,"goal":"function ListReverse_12995(s: seq): seq\n ensures |ListReverse_12995(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_12995(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_12996","instance":12996,"id":233011,"goal":"function Factorial_12996(n: nat): nat\n ensures Factorial_12996(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_12996(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_12997","instance":12997,"id":233012,"goal":"function Fib_12997(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_12997(n-1) + Fib_12997(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_12998","instance":12998,"id":233013,"goal":"function Gcd_12998(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_12998(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_12999","instance":12999,"id":233014,"goal":"function Power_12999(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_12999(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_13000","instance":13000,"id":233015,"goal":"function Sum_13000(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_13000(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_13001","instance":13001,"id":233016,"goal":"method BinarySearch_13001(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_13002","instance":13002,"id":233017,"goal":"method InsertSort_13002(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_13003","instance":13003,"id":233018,"goal":"method MergeSort_13003(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_13004","instance":13004,"id":233019,"goal":"method ArrayCopy_13004(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_13005","instance":13005,"id":233020,"goal":"function ListReverse_13005(s: seq): seq\n ensures |ListReverse_13005(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_13005(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_13006","instance":13006,"id":233021,"goal":"function Factorial_13006(n: nat): nat\n ensures Factorial_13006(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_13006(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_13007","instance":13007,"id":233022,"goal":"function Fib_13007(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_13007(n-1) + Fib_13007(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_13008","instance":13008,"id":233023,"goal":"function Gcd_13008(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_13008(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_13009","instance":13009,"id":233024,"goal":"function Power_13009(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_13009(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_13010","instance":13010,"id":233025,"goal":"function Sum_13010(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_13010(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_13011","instance":13011,"id":233026,"goal":"method BinarySearch_13011(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_13012","instance":13012,"id":233027,"goal":"method InsertSort_13012(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_13013","instance":13013,"id":233028,"goal":"method MergeSort_13013(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_13014","instance":13014,"id":233029,"goal":"method ArrayCopy_13014(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_13015","instance":13015,"id":233030,"goal":"function ListReverse_13015(s: seq): seq\n ensures |ListReverse_13015(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_13015(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_13016","instance":13016,"id":233031,"goal":"function Factorial_13016(n: nat): nat\n ensures Factorial_13016(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_13016(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_13017","instance":13017,"id":233032,"goal":"function Fib_13017(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_13017(n-1) + Fib_13017(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_13018","instance":13018,"id":233033,"goal":"function Gcd_13018(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_13018(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_13019","instance":13019,"id":233034,"goal":"function Power_13019(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_13019(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_13020","instance":13020,"id":233035,"goal":"function Sum_13020(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_13020(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_13021","instance":13021,"id":233036,"goal":"method BinarySearch_13021(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_13022","instance":13022,"id":233037,"goal":"method InsertSort_13022(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_13023","instance":13023,"id":233038,"goal":"method MergeSort_13023(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_13024","instance":13024,"id":233039,"goal":"method ArrayCopy_13024(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_13025","instance":13025,"id":233040,"goal":"function ListReverse_13025(s: seq): seq\n ensures |ListReverse_13025(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_13025(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_13026","instance":13026,"id":233041,"goal":"function Factorial_13026(n: nat): nat\n ensures Factorial_13026(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_13026(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_13027","instance":13027,"id":233042,"goal":"function Fib_13027(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_13027(n-1) + Fib_13027(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_13028","instance":13028,"id":233043,"goal":"function Gcd_13028(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_13028(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_13029","instance":13029,"id":233044,"goal":"function Power_13029(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_13029(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_13030","instance":13030,"id":233045,"goal":"function Sum_13030(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_13030(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_13031","instance":13031,"id":233046,"goal":"method BinarySearch_13031(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_13032","instance":13032,"id":233047,"goal":"method InsertSort_13032(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_13033","instance":13033,"id":233048,"goal":"method MergeSort_13033(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_13034","instance":13034,"id":233049,"goal":"method ArrayCopy_13034(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_13035","instance":13035,"id":233050,"goal":"function ListReverse_13035(s: seq): seq\n ensures |ListReverse_13035(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_13035(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_13036","instance":13036,"id":233051,"goal":"function Factorial_13036(n: nat): nat\n ensures Factorial_13036(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_13036(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_13037","instance":13037,"id":233052,"goal":"function Fib_13037(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_13037(n-1) + Fib_13037(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_13038","instance":13038,"id":233053,"goal":"function Gcd_13038(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_13038(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_13039","instance":13039,"id":233054,"goal":"function Power_13039(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_13039(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_13040","instance":13040,"id":233055,"goal":"function Sum_13040(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_13040(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_13041","instance":13041,"id":233056,"goal":"method BinarySearch_13041(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_13042","instance":13042,"id":233057,"goal":"method InsertSort_13042(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_13043","instance":13043,"id":233058,"goal":"method MergeSort_13043(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_13044","instance":13044,"id":233059,"goal":"method ArrayCopy_13044(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_13045","instance":13045,"id":233060,"goal":"function ListReverse_13045(s: seq): seq\n ensures |ListReverse_13045(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_13045(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_13046","instance":13046,"id":233061,"goal":"function Factorial_13046(n: nat): nat\n ensures Factorial_13046(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_13046(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_13047","instance":13047,"id":233062,"goal":"function Fib_13047(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_13047(n-1) + Fib_13047(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_13048","instance":13048,"id":233063,"goal":"function Gcd_13048(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_13048(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_13049","instance":13049,"id":233064,"goal":"function Power_13049(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_13049(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_13050","instance":13050,"id":233065,"goal":"function Sum_13050(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_13050(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_13051","instance":13051,"id":233066,"goal":"method BinarySearch_13051(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_13052","instance":13052,"id":233067,"goal":"method InsertSort_13052(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_13053","instance":13053,"id":233068,"goal":"method MergeSort_13053(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_13054","instance":13054,"id":233069,"goal":"method ArrayCopy_13054(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_13055","instance":13055,"id":233070,"goal":"function ListReverse_13055(s: seq): seq\n ensures |ListReverse_13055(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_13055(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_13056","instance":13056,"id":233071,"goal":"function Factorial_13056(n: nat): nat\n ensures Factorial_13056(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_13056(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_13057","instance":13057,"id":233072,"goal":"function Fib_13057(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_13057(n-1) + Fib_13057(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_13058","instance":13058,"id":233073,"goal":"function Gcd_13058(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_13058(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_13059","instance":13059,"id":233074,"goal":"function Power_13059(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_13059(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_13060","instance":13060,"id":233075,"goal":"function Sum_13060(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_13060(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_13061","instance":13061,"id":233076,"goal":"method BinarySearch_13061(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_13062","instance":13062,"id":233077,"goal":"method InsertSort_13062(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_13063","instance":13063,"id":233078,"goal":"method MergeSort_13063(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_13064","instance":13064,"id":233079,"goal":"method ArrayCopy_13064(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_13065","instance":13065,"id":233080,"goal":"function ListReverse_13065(s: seq): seq\n ensures |ListReverse_13065(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_13065(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_13066","instance":13066,"id":233081,"goal":"function Factorial_13066(n: nat): nat\n ensures Factorial_13066(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_13066(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_13067","instance":13067,"id":233082,"goal":"function Fib_13067(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_13067(n-1) + Fib_13067(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_13068","instance":13068,"id":233083,"goal":"function Gcd_13068(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_13068(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_13069","instance":13069,"id":233084,"goal":"function Power_13069(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_13069(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_13070","instance":13070,"id":233085,"goal":"function Sum_13070(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_13070(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_13071","instance":13071,"id":233086,"goal":"method BinarySearch_13071(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_13072","instance":13072,"id":233087,"goal":"method InsertSort_13072(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_13073","instance":13073,"id":233088,"goal":"method MergeSort_13073(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_13074","instance":13074,"id":233089,"goal":"method ArrayCopy_13074(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_13075","instance":13075,"id":233090,"goal":"function ListReverse_13075(s: seq): seq\n ensures |ListReverse_13075(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_13075(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_13076","instance":13076,"id":233091,"goal":"function Factorial_13076(n: nat): nat\n ensures Factorial_13076(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_13076(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_13077","instance":13077,"id":233092,"goal":"function Fib_13077(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_13077(n-1) + Fib_13077(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_13078","instance":13078,"id":233093,"goal":"function Gcd_13078(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_13078(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_13079","instance":13079,"id":233094,"goal":"function Power_13079(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_13079(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_13080","instance":13080,"id":233095,"goal":"function Sum_13080(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_13080(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_13081","instance":13081,"id":233096,"goal":"method BinarySearch_13081(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_13082","instance":13082,"id":233097,"goal":"method InsertSort_13082(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_13083","instance":13083,"id":233098,"goal":"method MergeSort_13083(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_13084","instance":13084,"id":233099,"goal":"method ArrayCopy_13084(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_13085","instance":13085,"id":233100,"goal":"function ListReverse_13085(s: seq): seq\n ensures |ListReverse_13085(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_13085(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_13086","instance":13086,"id":233101,"goal":"function Factorial_13086(n: nat): nat\n ensures Factorial_13086(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_13086(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_13087","instance":13087,"id":233102,"goal":"function Fib_13087(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_13087(n-1) + Fib_13087(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_13088","instance":13088,"id":233103,"goal":"function Gcd_13088(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_13088(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_13089","instance":13089,"id":233104,"goal":"function Power_13089(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_13089(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_13090","instance":13090,"id":233105,"goal":"function Sum_13090(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_13090(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_13091","instance":13091,"id":233106,"goal":"method BinarySearch_13091(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_13092","instance":13092,"id":233107,"goal":"method InsertSort_13092(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_13093","instance":13093,"id":233108,"goal":"method MergeSort_13093(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_13094","instance":13094,"id":233109,"goal":"method ArrayCopy_13094(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_13095","instance":13095,"id":233110,"goal":"function ListReverse_13095(s: seq): seq\n ensures |ListReverse_13095(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_13095(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_13096","instance":13096,"id":233111,"goal":"function Factorial_13096(n: nat): nat\n ensures Factorial_13096(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_13096(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_13097","instance":13097,"id":233112,"goal":"function Fib_13097(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_13097(n-1) + Fib_13097(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_13098","instance":13098,"id":233113,"goal":"function Gcd_13098(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_13098(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_13099","instance":13099,"id":233114,"goal":"function Power_13099(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_13099(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_13100","instance":13100,"id":233115,"goal":"function Sum_13100(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_13100(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_13101","instance":13101,"id":233116,"goal":"method BinarySearch_13101(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_13102","instance":13102,"id":233117,"goal":"method InsertSort_13102(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_13103","instance":13103,"id":233118,"goal":"method MergeSort_13103(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_13104","instance":13104,"id":233119,"goal":"method ArrayCopy_13104(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_13105","instance":13105,"id":233120,"goal":"function ListReverse_13105(s: seq): seq\n ensures |ListReverse_13105(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_13105(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_13106","instance":13106,"id":233121,"goal":"function Factorial_13106(n: nat): nat\n ensures Factorial_13106(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_13106(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_13107","instance":13107,"id":233122,"goal":"function Fib_13107(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_13107(n-1) + Fib_13107(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_13108","instance":13108,"id":233123,"goal":"function Gcd_13108(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_13108(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_13109","instance":13109,"id":233124,"goal":"function Power_13109(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_13109(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_13110","instance":13110,"id":233125,"goal":"function Sum_13110(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_13110(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_13111","instance":13111,"id":233126,"goal":"method BinarySearch_13111(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_13112","instance":13112,"id":233127,"goal":"method InsertSort_13112(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_13113","instance":13113,"id":233128,"goal":"method MergeSort_13113(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_13114","instance":13114,"id":233129,"goal":"method ArrayCopy_13114(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_13115","instance":13115,"id":233130,"goal":"function ListReverse_13115(s: seq): seq\n ensures |ListReverse_13115(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_13115(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_13116","instance":13116,"id":233131,"goal":"function Factorial_13116(n: nat): nat\n ensures Factorial_13116(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_13116(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_13117","instance":13117,"id":233132,"goal":"function Fib_13117(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_13117(n-1) + Fib_13117(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_13118","instance":13118,"id":233133,"goal":"function Gcd_13118(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_13118(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_13119","instance":13119,"id":233134,"goal":"function Power_13119(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_13119(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_13120","instance":13120,"id":233135,"goal":"function Sum_13120(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_13120(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_13121","instance":13121,"id":233136,"goal":"method BinarySearch_13121(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_13122","instance":13122,"id":233137,"goal":"method InsertSort_13122(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_13123","instance":13123,"id":233138,"goal":"method MergeSort_13123(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_13124","instance":13124,"id":233139,"goal":"method ArrayCopy_13124(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_13125","instance":13125,"id":233140,"goal":"function ListReverse_13125(s: seq): seq\n ensures |ListReverse_13125(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_13125(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_13126","instance":13126,"id":233141,"goal":"function Factorial_13126(n: nat): nat\n ensures Factorial_13126(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_13126(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_13127","instance":13127,"id":233142,"goal":"function Fib_13127(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_13127(n-1) + Fib_13127(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_13128","instance":13128,"id":233143,"goal":"function Gcd_13128(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_13128(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_13129","instance":13129,"id":233144,"goal":"function Power_13129(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_13129(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_13130","instance":13130,"id":233145,"goal":"function Sum_13130(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_13130(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_13131","instance":13131,"id":233146,"goal":"method BinarySearch_13131(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_13132","instance":13132,"id":233147,"goal":"method InsertSort_13132(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_13133","instance":13133,"id":233148,"goal":"method MergeSort_13133(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_13134","instance":13134,"id":233149,"goal":"method ArrayCopy_13134(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_13135","instance":13135,"id":233150,"goal":"function ListReverse_13135(s: seq): seq\n ensures |ListReverse_13135(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_13135(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_13136","instance":13136,"id":233151,"goal":"function Factorial_13136(n: nat): nat\n ensures Factorial_13136(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_13136(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_13137","instance":13137,"id":233152,"goal":"function Fib_13137(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_13137(n-1) + Fib_13137(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_13138","instance":13138,"id":233153,"goal":"function Gcd_13138(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_13138(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_13139","instance":13139,"id":233154,"goal":"function Power_13139(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_13139(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_13140","instance":13140,"id":233155,"goal":"function Sum_13140(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_13140(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_13141","instance":13141,"id":233156,"goal":"method BinarySearch_13141(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_13142","instance":13142,"id":233157,"goal":"method InsertSort_13142(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_13143","instance":13143,"id":233158,"goal":"method MergeSort_13143(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_13144","instance":13144,"id":233159,"goal":"method ArrayCopy_13144(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_13145","instance":13145,"id":233160,"goal":"function ListReverse_13145(s: seq): seq\n ensures |ListReverse_13145(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_13145(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_13146","instance":13146,"id":233161,"goal":"function Factorial_13146(n: nat): nat\n ensures Factorial_13146(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_13146(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_13147","instance":13147,"id":233162,"goal":"function Fib_13147(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_13147(n-1) + Fib_13147(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_13148","instance":13148,"id":233163,"goal":"function Gcd_13148(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_13148(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_13149","instance":13149,"id":233164,"goal":"function Power_13149(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_13149(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_13150","instance":13150,"id":233165,"goal":"function Sum_13150(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_13150(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_13151","instance":13151,"id":233166,"goal":"method BinarySearch_13151(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_13152","instance":13152,"id":233167,"goal":"method InsertSort_13152(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_13153","instance":13153,"id":233168,"goal":"method MergeSort_13153(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_13154","instance":13154,"id":233169,"goal":"method ArrayCopy_13154(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_13155","instance":13155,"id":233170,"goal":"function ListReverse_13155(s: seq): seq\n ensures |ListReverse_13155(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_13155(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_13156","instance":13156,"id":233171,"goal":"function Factorial_13156(n: nat): nat\n ensures Factorial_13156(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_13156(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_13157","instance":13157,"id":233172,"goal":"function Fib_13157(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_13157(n-1) + Fib_13157(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_13158","instance":13158,"id":233173,"goal":"function Gcd_13158(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_13158(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_13159","instance":13159,"id":233174,"goal":"function Power_13159(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_13159(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_13160","instance":13160,"id":233175,"goal":"function Sum_13160(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_13160(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_13161","instance":13161,"id":233176,"goal":"method BinarySearch_13161(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_13162","instance":13162,"id":233177,"goal":"method InsertSort_13162(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_13163","instance":13163,"id":233178,"goal":"method MergeSort_13163(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_13164","instance":13164,"id":233179,"goal":"method ArrayCopy_13164(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_13165","instance":13165,"id":233180,"goal":"function ListReverse_13165(s: seq): seq\n ensures |ListReverse_13165(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_13165(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_13166","instance":13166,"id":233181,"goal":"function Factorial_13166(n: nat): nat\n ensures Factorial_13166(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_13166(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_13167","instance":13167,"id":233182,"goal":"function Fib_13167(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_13167(n-1) + Fib_13167(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_13168","instance":13168,"id":233183,"goal":"function Gcd_13168(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_13168(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_13169","instance":13169,"id":233184,"goal":"function Power_13169(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_13169(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_13170","instance":13170,"id":233185,"goal":"function Sum_13170(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_13170(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_13171","instance":13171,"id":233186,"goal":"method BinarySearch_13171(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_13172","instance":13172,"id":233187,"goal":"method InsertSort_13172(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_13173","instance":13173,"id":233188,"goal":"method MergeSort_13173(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_13174","instance":13174,"id":233189,"goal":"method ArrayCopy_13174(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_13175","instance":13175,"id":233190,"goal":"function ListReverse_13175(s: seq): seq\n ensures |ListReverse_13175(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_13175(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_13176","instance":13176,"id":233191,"goal":"function Factorial_13176(n: nat): nat\n ensures Factorial_13176(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_13176(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_13177","instance":13177,"id":233192,"goal":"function Fib_13177(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_13177(n-1) + Fib_13177(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_13178","instance":13178,"id":233193,"goal":"function Gcd_13178(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_13178(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_13179","instance":13179,"id":233194,"goal":"function Power_13179(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_13179(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_13180","instance":13180,"id":233195,"goal":"function Sum_13180(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_13180(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_13181","instance":13181,"id":233196,"goal":"method BinarySearch_13181(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_13182","instance":13182,"id":233197,"goal":"method InsertSort_13182(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_13183","instance":13183,"id":233198,"goal":"method MergeSort_13183(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_13184","instance":13184,"id":233199,"goal":"method ArrayCopy_13184(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_13185","instance":13185,"id":233200,"goal":"function ListReverse_13185(s: seq): seq\n ensures |ListReverse_13185(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_13185(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_13186","instance":13186,"id":233201,"goal":"function Factorial_13186(n: nat): nat\n ensures Factorial_13186(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_13186(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_13187","instance":13187,"id":233202,"goal":"function Fib_13187(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_13187(n-1) + Fib_13187(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_13188","instance":13188,"id":233203,"goal":"function Gcd_13188(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_13188(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_13189","instance":13189,"id":233204,"goal":"function Power_13189(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_13189(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_13190","instance":13190,"id":233205,"goal":"function Sum_13190(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_13190(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_13191","instance":13191,"id":233206,"goal":"method BinarySearch_13191(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_13192","instance":13192,"id":233207,"goal":"method InsertSort_13192(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_13193","instance":13193,"id":233208,"goal":"method MergeSort_13193(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_13194","instance":13194,"id":233209,"goal":"method ArrayCopy_13194(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_13195","instance":13195,"id":233210,"goal":"function ListReverse_13195(s: seq): seq\n ensures |ListReverse_13195(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_13195(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_13196","instance":13196,"id":233211,"goal":"function Factorial_13196(n: nat): nat\n ensures Factorial_13196(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_13196(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_13197","instance":13197,"id":233212,"goal":"function Fib_13197(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_13197(n-1) + Fib_13197(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_13198","instance":13198,"id":233213,"goal":"function Gcd_13198(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_13198(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_13199","instance":13199,"id":233214,"goal":"function Power_13199(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_13199(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_13200","instance":13200,"id":233215,"goal":"function Sum_13200(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_13200(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_13201","instance":13201,"id":233216,"goal":"method BinarySearch_13201(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_13202","instance":13202,"id":233217,"goal":"method InsertSort_13202(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_13203","instance":13203,"id":233218,"goal":"method MergeSort_13203(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_13204","instance":13204,"id":233219,"goal":"method ArrayCopy_13204(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_13205","instance":13205,"id":233220,"goal":"function ListReverse_13205(s: seq): seq\n ensures |ListReverse_13205(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_13205(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_13206","instance":13206,"id":233221,"goal":"function Factorial_13206(n: nat): nat\n ensures Factorial_13206(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_13206(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_13207","instance":13207,"id":233222,"goal":"function Fib_13207(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_13207(n-1) + Fib_13207(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_13208","instance":13208,"id":233223,"goal":"function Gcd_13208(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_13208(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_13209","instance":13209,"id":233224,"goal":"function Power_13209(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_13209(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_13210","instance":13210,"id":233225,"goal":"function Sum_13210(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_13210(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_13211","instance":13211,"id":233226,"goal":"method BinarySearch_13211(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_13212","instance":13212,"id":233227,"goal":"method InsertSort_13212(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_13213","instance":13213,"id":233228,"goal":"method MergeSort_13213(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_13214","instance":13214,"id":233229,"goal":"method ArrayCopy_13214(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_13215","instance":13215,"id":233230,"goal":"function ListReverse_13215(s: seq): seq\n ensures |ListReverse_13215(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_13215(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_13216","instance":13216,"id":233231,"goal":"function Factorial_13216(n: nat): nat\n ensures Factorial_13216(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_13216(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_13217","instance":13217,"id":233232,"goal":"function Fib_13217(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_13217(n-1) + Fib_13217(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_13218","instance":13218,"id":233233,"goal":"function Gcd_13218(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_13218(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_13219","instance":13219,"id":233234,"goal":"function Power_13219(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_13219(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_13220","instance":13220,"id":233235,"goal":"function Sum_13220(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_13220(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_13221","instance":13221,"id":233236,"goal":"method BinarySearch_13221(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_13222","instance":13222,"id":233237,"goal":"method InsertSort_13222(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_13223","instance":13223,"id":233238,"goal":"method MergeSort_13223(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_13224","instance":13224,"id":233239,"goal":"method ArrayCopy_13224(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_13225","instance":13225,"id":233240,"goal":"function ListReverse_13225(s: seq): seq\n ensures |ListReverse_13225(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_13225(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_13226","instance":13226,"id":233241,"goal":"function Factorial_13226(n: nat): nat\n ensures Factorial_13226(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_13226(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_13227","instance":13227,"id":233242,"goal":"function Fib_13227(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_13227(n-1) + Fib_13227(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_13228","instance":13228,"id":233243,"goal":"function Gcd_13228(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_13228(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_13229","instance":13229,"id":233244,"goal":"function Power_13229(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_13229(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_13230","instance":13230,"id":233245,"goal":"function Sum_13230(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_13230(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_13231","instance":13231,"id":233246,"goal":"method BinarySearch_13231(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_13232","instance":13232,"id":233247,"goal":"method InsertSort_13232(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_13233","instance":13233,"id":233248,"goal":"method MergeSort_13233(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_13234","instance":13234,"id":233249,"goal":"method ArrayCopy_13234(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_13235","instance":13235,"id":233250,"goal":"function ListReverse_13235(s: seq): seq\n ensures |ListReverse_13235(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_13235(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_13236","instance":13236,"id":233251,"goal":"function Factorial_13236(n: nat): nat\n ensures Factorial_13236(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_13236(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_13237","instance":13237,"id":233252,"goal":"function Fib_13237(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_13237(n-1) + Fib_13237(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_13238","instance":13238,"id":233253,"goal":"function Gcd_13238(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_13238(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_13239","instance":13239,"id":233254,"goal":"function Power_13239(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_13239(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_13240","instance":13240,"id":233255,"goal":"function Sum_13240(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_13240(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_13241","instance":13241,"id":233256,"goal":"method BinarySearch_13241(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_13242","instance":13242,"id":233257,"goal":"method InsertSort_13242(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_13243","instance":13243,"id":233258,"goal":"method MergeSort_13243(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_13244","instance":13244,"id":233259,"goal":"method ArrayCopy_13244(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_13245","instance":13245,"id":233260,"goal":"function ListReverse_13245(s: seq): seq\n ensures |ListReverse_13245(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_13245(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_13246","instance":13246,"id":233261,"goal":"function Factorial_13246(n: nat): nat\n ensures Factorial_13246(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_13246(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_13247","instance":13247,"id":233262,"goal":"function Fib_13247(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_13247(n-1) + Fib_13247(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_13248","instance":13248,"id":233263,"goal":"function Gcd_13248(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_13248(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_13249","instance":13249,"id":233264,"goal":"function Power_13249(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_13249(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_13250","instance":13250,"id":233265,"goal":"function Sum_13250(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_13250(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_13251","instance":13251,"id":233266,"goal":"method BinarySearch_13251(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_13252","instance":13252,"id":233267,"goal":"method InsertSort_13252(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_13253","instance":13253,"id":233268,"goal":"method MergeSort_13253(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_13254","instance":13254,"id":233269,"goal":"method ArrayCopy_13254(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_13255","instance":13255,"id":233270,"goal":"function ListReverse_13255(s: seq): seq\n ensures |ListReverse_13255(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_13255(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_13256","instance":13256,"id":233271,"goal":"function Factorial_13256(n: nat): nat\n ensures Factorial_13256(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_13256(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_13257","instance":13257,"id":233272,"goal":"function Fib_13257(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_13257(n-1) + Fib_13257(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_13258","instance":13258,"id":233273,"goal":"function Gcd_13258(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_13258(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_13259","instance":13259,"id":233274,"goal":"function Power_13259(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_13259(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_13260","instance":13260,"id":233275,"goal":"function Sum_13260(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_13260(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_13261","instance":13261,"id":233276,"goal":"method BinarySearch_13261(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_13262","instance":13262,"id":233277,"goal":"method InsertSort_13262(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_13263","instance":13263,"id":233278,"goal":"method MergeSort_13263(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_13264","instance":13264,"id":233279,"goal":"method ArrayCopy_13264(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_13265","instance":13265,"id":233280,"goal":"function ListReverse_13265(s: seq): seq\n ensures |ListReverse_13265(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_13265(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_13266","instance":13266,"id":233281,"goal":"function Factorial_13266(n: nat): nat\n ensures Factorial_13266(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_13266(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_13267","instance":13267,"id":233282,"goal":"function Fib_13267(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_13267(n-1) + Fib_13267(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_13268","instance":13268,"id":233283,"goal":"function Gcd_13268(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_13268(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_13269","instance":13269,"id":233284,"goal":"function Power_13269(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_13269(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_13270","instance":13270,"id":233285,"goal":"function Sum_13270(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_13270(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_13271","instance":13271,"id":233286,"goal":"method BinarySearch_13271(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_13272","instance":13272,"id":233287,"goal":"method InsertSort_13272(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_13273","instance":13273,"id":233288,"goal":"method MergeSort_13273(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_13274","instance":13274,"id":233289,"goal":"method ArrayCopy_13274(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_13275","instance":13275,"id":233290,"goal":"function ListReverse_13275(s: seq): seq\n ensures |ListReverse_13275(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_13275(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_13276","instance":13276,"id":233291,"goal":"function Factorial_13276(n: nat): nat\n ensures Factorial_13276(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_13276(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_13277","instance":13277,"id":233292,"goal":"function Fib_13277(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_13277(n-1) + Fib_13277(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_13278","instance":13278,"id":233293,"goal":"function Gcd_13278(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_13278(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_13279","instance":13279,"id":233294,"goal":"function Power_13279(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_13279(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_13280","instance":13280,"id":233295,"goal":"function Sum_13280(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_13280(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_13281","instance":13281,"id":233296,"goal":"method BinarySearch_13281(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_13282","instance":13282,"id":233297,"goal":"method InsertSort_13282(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_13283","instance":13283,"id":233298,"goal":"method MergeSort_13283(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_13284","instance":13284,"id":233299,"goal":"method ArrayCopy_13284(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_13285","instance":13285,"id":233300,"goal":"function ListReverse_13285(s: seq): seq\n ensures |ListReverse_13285(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_13285(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_13286","instance":13286,"id":233301,"goal":"function Factorial_13286(n: nat): nat\n ensures Factorial_13286(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_13286(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_13287","instance":13287,"id":233302,"goal":"function Fib_13287(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_13287(n-1) + Fib_13287(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_13288","instance":13288,"id":233303,"goal":"function Gcd_13288(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_13288(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_13289","instance":13289,"id":233304,"goal":"function Power_13289(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_13289(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_13290","instance":13290,"id":233305,"goal":"function Sum_13290(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_13290(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_13291","instance":13291,"id":233306,"goal":"method BinarySearch_13291(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_13292","instance":13292,"id":233307,"goal":"method InsertSort_13292(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_13293","instance":13293,"id":233308,"goal":"method MergeSort_13293(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_13294","instance":13294,"id":233309,"goal":"method ArrayCopy_13294(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_13295","instance":13295,"id":233310,"goal":"function ListReverse_13295(s: seq): seq\n ensures |ListReverse_13295(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_13295(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_13296","instance":13296,"id":233311,"goal":"function Factorial_13296(n: nat): nat\n ensures Factorial_13296(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_13296(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_13297","instance":13297,"id":233312,"goal":"function Fib_13297(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_13297(n-1) + Fib_13297(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_13298","instance":13298,"id":233313,"goal":"function Gcd_13298(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_13298(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_13299","instance":13299,"id":233314,"goal":"function Power_13299(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_13299(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_13300","instance":13300,"id":233315,"goal":"function Sum_13300(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_13300(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_13301","instance":13301,"id":233316,"goal":"method BinarySearch_13301(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_13302","instance":13302,"id":233317,"goal":"method InsertSort_13302(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_13303","instance":13303,"id":233318,"goal":"method MergeSort_13303(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_13304","instance":13304,"id":233319,"goal":"method ArrayCopy_13304(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_13305","instance":13305,"id":233320,"goal":"function ListReverse_13305(s: seq): seq\n ensures |ListReverse_13305(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_13305(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_13306","instance":13306,"id":233321,"goal":"function Factorial_13306(n: nat): nat\n ensures Factorial_13306(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_13306(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_13307","instance":13307,"id":233322,"goal":"function Fib_13307(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_13307(n-1) + Fib_13307(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_13308","instance":13308,"id":233323,"goal":"function Gcd_13308(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_13308(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_13309","instance":13309,"id":233324,"goal":"function Power_13309(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_13309(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_13310","instance":13310,"id":233325,"goal":"function Sum_13310(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_13310(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_13311","instance":13311,"id":233326,"goal":"method BinarySearch_13311(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_13312","instance":13312,"id":233327,"goal":"method InsertSort_13312(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_13313","instance":13313,"id":233328,"goal":"method MergeSort_13313(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_13314","instance":13314,"id":233329,"goal":"method ArrayCopy_13314(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_13315","instance":13315,"id":233330,"goal":"function ListReverse_13315(s: seq): seq\n ensures |ListReverse_13315(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_13315(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_13316","instance":13316,"id":233331,"goal":"function Factorial_13316(n: nat): nat\n ensures Factorial_13316(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_13316(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_13317","instance":13317,"id":233332,"goal":"function Fib_13317(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_13317(n-1) + Fib_13317(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_13318","instance":13318,"id":233333,"goal":"function Gcd_13318(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_13318(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_13319","instance":13319,"id":233334,"goal":"function Power_13319(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_13319(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_13320","instance":13320,"id":233335,"goal":"function Sum_13320(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_13320(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_13321","instance":13321,"id":233336,"goal":"method BinarySearch_13321(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_13322","instance":13322,"id":233337,"goal":"method InsertSort_13322(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_13323","instance":13323,"id":233338,"goal":"method MergeSort_13323(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_13324","instance":13324,"id":233339,"goal":"method ArrayCopy_13324(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_13325","instance":13325,"id":233340,"goal":"function ListReverse_13325(s: seq): seq\n ensures |ListReverse_13325(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_13325(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_13326","instance":13326,"id":233341,"goal":"function Factorial_13326(n: nat): nat\n ensures Factorial_13326(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_13326(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_13327","instance":13327,"id":233342,"goal":"function Fib_13327(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_13327(n-1) + Fib_13327(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_13328","instance":13328,"id":233343,"goal":"function Gcd_13328(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_13328(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_13329","instance":13329,"id":233344,"goal":"function Power_13329(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_13329(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_13330","instance":13330,"id":233345,"goal":"function Sum_13330(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_13330(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_13331","instance":13331,"id":233346,"goal":"method BinarySearch_13331(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_13332","instance":13332,"id":233347,"goal":"method InsertSort_13332(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_13333","instance":13333,"id":233348,"goal":"method MergeSort_13333(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_13334","instance":13334,"id":233349,"goal":"method ArrayCopy_13334(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_13335","instance":13335,"id":233350,"goal":"function ListReverse_13335(s: seq): seq\n ensures |ListReverse_13335(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_13335(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_13336","instance":13336,"id":233351,"goal":"function Factorial_13336(n: nat): nat\n ensures Factorial_13336(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_13336(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_13337","instance":13337,"id":233352,"goal":"function Fib_13337(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_13337(n-1) + Fib_13337(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_13338","instance":13338,"id":233353,"goal":"function Gcd_13338(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_13338(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_13339","instance":13339,"id":233354,"goal":"function Power_13339(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_13339(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_13340","instance":13340,"id":233355,"goal":"function Sum_13340(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_13340(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_13341","instance":13341,"id":233356,"goal":"method BinarySearch_13341(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_13342","instance":13342,"id":233357,"goal":"method InsertSort_13342(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_13343","instance":13343,"id":233358,"goal":"method MergeSort_13343(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_13344","instance":13344,"id":233359,"goal":"method ArrayCopy_13344(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_13345","instance":13345,"id":233360,"goal":"function ListReverse_13345(s: seq): seq\n ensures |ListReverse_13345(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_13345(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_13346","instance":13346,"id":233361,"goal":"function Factorial_13346(n: nat): nat\n ensures Factorial_13346(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_13346(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_13347","instance":13347,"id":233362,"goal":"function Fib_13347(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_13347(n-1) + Fib_13347(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_13348","instance":13348,"id":233363,"goal":"function Gcd_13348(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_13348(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_13349","instance":13349,"id":233364,"goal":"function Power_13349(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_13349(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_13350","instance":13350,"id":233365,"goal":"function Sum_13350(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_13350(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_13351","instance":13351,"id":233366,"goal":"method BinarySearch_13351(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_13352","instance":13352,"id":233367,"goal":"method InsertSort_13352(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_13353","instance":13353,"id":233368,"goal":"method MergeSort_13353(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_13354","instance":13354,"id":233369,"goal":"method ArrayCopy_13354(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_13355","instance":13355,"id":233370,"goal":"function ListReverse_13355(s: seq): seq\n ensures |ListReverse_13355(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_13355(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_13356","instance":13356,"id":233371,"goal":"function Factorial_13356(n: nat): nat\n ensures Factorial_13356(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_13356(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_13357","instance":13357,"id":233372,"goal":"function Fib_13357(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_13357(n-1) + Fib_13357(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_13358","instance":13358,"id":233373,"goal":"function Gcd_13358(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_13358(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_13359","instance":13359,"id":233374,"goal":"function Power_13359(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_13359(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_13360","instance":13360,"id":233375,"goal":"function Sum_13360(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_13360(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_13361","instance":13361,"id":233376,"goal":"method BinarySearch_13361(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_13362","instance":13362,"id":233377,"goal":"method InsertSort_13362(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_13363","instance":13363,"id":233378,"goal":"method MergeSort_13363(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_13364","instance":13364,"id":233379,"goal":"method ArrayCopy_13364(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_13365","instance":13365,"id":233380,"goal":"function ListReverse_13365(s: seq): seq\n ensures |ListReverse_13365(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_13365(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_13366","instance":13366,"id":233381,"goal":"function Factorial_13366(n: nat): nat\n ensures Factorial_13366(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_13366(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_13367","instance":13367,"id":233382,"goal":"function Fib_13367(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_13367(n-1) + Fib_13367(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_13368","instance":13368,"id":233383,"goal":"function Gcd_13368(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_13368(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_13369","instance":13369,"id":233384,"goal":"function Power_13369(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_13369(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_13370","instance":13370,"id":233385,"goal":"function Sum_13370(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_13370(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_13371","instance":13371,"id":233386,"goal":"method BinarySearch_13371(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_13372","instance":13372,"id":233387,"goal":"method InsertSort_13372(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_13373","instance":13373,"id":233388,"goal":"method MergeSort_13373(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_13374","instance":13374,"id":233389,"goal":"method ArrayCopy_13374(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_13375","instance":13375,"id":233390,"goal":"function ListReverse_13375(s: seq): seq\n ensures |ListReverse_13375(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_13375(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_13376","instance":13376,"id":233391,"goal":"function Factorial_13376(n: nat): nat\n ensures Factorial_13376(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_13376(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_13377","instance":13377,"id":233392,"goal":"function Fib_13377(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_13377(n-1) + Fib_13377(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_13378","instance":13378,"id":233393,"goal":"function Gcd_13378(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_13378(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_13379","instance":13379,"id":233394,"goal":"function Power_13379(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_13379(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_13380","instance":13380,"id":233395,"goal":"function Sum_13380(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_13380(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_13381","instance":13381,"id":233396,"goal":"method BinarySearch_13381(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_13382","instance":13382,"id":233397,"goal":"method InsertSort_13382(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_13383","instance":13383,"id":233398,"goal":"method MergeSort_13383(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_13384","instance":13384,"id":233399,"goal":"method ArrayCopy_13384(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_13385","instance":13385,"id":233400,"goal":"function ListReverse_13385(s: seq): seq\n ensures |ListReverse_13385(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_13385(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_13386","instance":13386,"id":233401,"goal":"function Factorial_13386(n: nat): nat\n ensures Factorial_13386(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_13386(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_13387","instance":13387,"id":233402,"goal":"function Fib_13387(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_13387(n-1) + Fib_13387(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_13388","instance":13388,"id":233403,"goal":"function Gcd_13388(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_13388(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_13389","instance":13389,"id":233404,"goal":"function Power_13389(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_13389(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_13390","instance":13390,"id":233405,"goal":"function Sum_13390(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_13390(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_13391","instance":13391,"id":233406,"goal":"method BinarySearch_13391(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_13392","instance":13392,"id":233407,"goal":"method InsertSort_13392(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_13393","instance":13393,"id":233408,"goal":"method MergeSort_13393(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_13394","instance":13394,"id":233409,"goal":"method ArrayCopy_13394(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_13395","instance":13395,"id":233410,"goal":"function ListReverse_13395(s: seq): seq\n ensures |ListReverse_13395(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_13395(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_13396","instance":13396,"id":233411,"goal":"function Factorial_13396(n: nat): nat\n ensures Factorial_13396(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_13396(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_13397","instance":13397,"id":233412,"goal":"function Fib_13397(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_13397(n-1) + Fib_13397(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_13398","instance":13398,"id":233413,"goal":"function Gcd_13398(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_13398(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_13399","instance":13399,"id":233414,"goal":"function Power_13399(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_13399(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_13400","instance":13400,"id":233415,"goal":"function Sum_13400(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_13400(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_13401","instance":13401,"id":233416,"goal":"method BinarySearch_13401(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_13402","instance":13402,"id":233417,"goal":"method InsertSort_13402(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_13403","instance":13403,"id":233418,"goal":"method MergeSort_13403(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_13404","instance":13404,"id":233419,"goal":"method ArrayCopy_13404(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_13405","instance":13405,"id":233420,"goal":"function ListReverse_13405(s: seq): seq\n ensures |ListReverse_13405(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_13405(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_13406","instance":13406,"id":233421,"goal":"function Factorial_13406(n: nat): nat\n ensures Factorial_13406(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_13406(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_13407","instance":13407,"id":233422,"goal":"function Fib_13407(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_13407(n-1) + Fib_13407(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_13408","instance":13408,"id":233423,"goal":"function Gcd_13408(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_13408(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_13409","instance":13409,"id":233424,"goal":"function Power_13409(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_13409(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_13410","instance":13410,"id":233425,"goal":"function Sum_13410(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_13410(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_13411","instance":13411,"id":233426,"goal":"method BinarySearch_13411(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_13412","instance":13412,"id":233427,"goal":"method InsertSort_13412(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_13413","instance":13413,"id":233428,"goal":"method MergeSort_13413(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_13414","instance":13414,"id":233429,"goal":"method ArrayCopy_13414(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_13415","instance":13415,"id":233430,"goal":"function ListReverse_13415(s: seq): seq\n ensures |ListReverse_13415(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_13415(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_13416","instance":13416,"id":233431,"goal":"function Factorial_13416(n: nat): nat\n ensures Factorial_13416(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_13416(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_13417","instance":13417,"id":233432,"goal":"function Fib_13417(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_13417(n-1) + Fib_13417(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_13418","instance":13418,"id":233433,"goal":"function Gcd_13418(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_13418(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_13419","instance":13419,"id":233434,"goal":"function Power_13419(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_13419(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_13420","instance":13420,"id":233435,"goal":"function Sum_13420(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_13420(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_13421","instance":13421,"id":233436,"goal":"method BinarySearch_13421(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_13422","instance":13422,"id":233437,"goal":"method InsertSort_13422(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_13423","instance":13423,"id":233438,"goal":"method MergeSort_13423(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_13424","instance":13424,"id":233439,"goal":"method ArrayCopy_13424(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_13425","instance":13425,"id":233440,"goal":"function ListReverse_13425(s: seq): seq\n ensures |ListReverse_13425(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_13425(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_13426","instance":13426,"id":233441,"goal":"function Factorial_13426(n: nat): nat\n ensures Factorial_13426(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_13426(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_13427","instance":13427,"id":233442,"goal":"function Fib_13427(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_13427(n-1) + Fib_13427(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_13428","instance":13428,"id":233443,"goal":"function Gcd_13428(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_13428(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_13429","instance":13429,"id":233444,"goal":"function Power_13429(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_13429(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_13430","instance":13430,"id":233445,"goal":"function Sum_13430(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_13430(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_13431","instance":13431,"id":233446,"goal":"method BinarySearch_13431(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_13432","instance":13432,"id":233447,"goal":"method InsertSort_13432(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_13433","instance":13433,"id":233448,"goal":"method MergeSort_13433(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_13434","instance":13434,"id":233449,"goal":"method ArrayCopy_13434(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_13435","instance":13435,"id":233450,"goal":"function ListReverse_13435(s: seq): seq\n ensures |ListReverse_13435(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_13435(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_13436","instance":13436,"id":233451,"goal":"function Factorial_13436(n: nat): nat\n ensures Factorial_13436(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_13436(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_13437","instance":13437,"id":233452,"goal":"function Fib_13437(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_13437(n-1) + Fib_13437(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_13438","instance":13438,"id":233453,"goal":"function Gcd_13438(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_13438(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_13439","instance":13439,"id":233454,"goal":"function Power_13439(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_13439(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_13440","instance":13440,"id":233455,"goal":"function Sum_13440(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_13440(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_13441","instance":13441,"id":233456,"goal":"method BinarySearch_13441(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_13442","instance":13442,"id":233457,"goal":"method InsertSort_13442(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_13443","instance":13443,"id":233458,"goal":"method MergeSort_13443(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_13444","instance":13444,"id":233459,"goal":"method ArrayCopy_13444(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_13445","instance":13445,"id":233460,"goal":"function ListReverse_13445(s: seq): seq\n ensures |ListReverse_13445(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_13445(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_13446","instance":13446,"id":233461,"goal":"function Factorial_13446(n: nat): nat\n ensures Factorial_13446(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_13446(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_13447","instance":13447,"id":233462,"goal":"function Fib_13447(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_13447(n-1) + Fib_13447(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_13448","instance":13448,"id":233463,"goal":"function Gcd_13448(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_13448(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_13449","instance":13449,"id":233464,"goal":"function Power_13449(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_13449(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_13450","instance":13450,"id":233465,"goal":"function Sum_13450(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_13450(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_13451","instance":13451,"id":233466,"goal":"method BinarySearch_13451(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_13452","instance":13452,"id":233467,"goal":"method InsertSort_13452(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_13453","instance":13453,"id":233468,"goal":"method MergeSort_13453(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_13454","instance":13454,"id":233469,"goal":"method ArrayCopy_13454(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_13455","instance":13455,"id":233470,"goal":"function ListReverse_13455(s: seq): seq\n ensures |ListReverse_13455(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_13455(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_13456","instance":13456,"id":233471,"goal":"function Factorial_13456(n: nat): nat\n ensures Factorial_13456(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_13456(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_13457","instance":13457,"id":233472,"goal":"function Fib_13457(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_13457(n-1) + Fib_13457(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_13458","instance":13458,"id":233473,"goal":"function Gcd_13458(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_13458(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_13459","instance":13459,"id":233474,"goal":"function Power_13459(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_13459(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_13460","instance":13460,"id":233475,"goal":"function Sum_13460(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_13460(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_13461","instance":13461,"id":233476,"goal":"method BinarySearch_13461(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_13462","instance":13462,"id":233477,"goal":"method InsertSort_13462(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_13463","instance":13463,"id":233478,"goal":"method MergeSort_13463(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_13464","instance":13464,"id":233479,"goal":"method ArrayCopy_13464(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_13465","instance":13465,"id":233480,"goal":"function ListReverse_13465(s: seq): seq\n ensures |ListReverse_13465(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_13465(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_13466","instance":13466,"id":233481,"goal":"function Factorial_13466(n: nat): nat\n ensures Factorial_13466(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_13466(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_13467","instance":13467,"id":233482,"goal":"function Fib_13467(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_13467(n-1) + Fib_13467(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_13468","instance":13468,"id":233483,"goal":"function Gcd_13468(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_13468(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_13469","instance":13469,"id":233484,"goal":"function Power_13469(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_13469(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_13470","instance":13470,"id":233485,"goal":"function Sum_13470(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_13470(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_13471","instance":13471,"id":233486,"goal":"method BinarySearch_13471(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_13472","instance":13472,"id":233487,"goal":"method InsertSort_13472(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_13473","instance":13473,"id":233488,"goal":"method MergeSort_13473(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_13474","instance":13474,"id":233489,"goal":"method ArrayCopy_13474(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_13475","instance":13475,"id":233490,"goal":"function ListReverse_13475(s: seq): seq\n ensures |ListReverse_13475(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_13475(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_13476","instance":13476,"id":233491,"goal":"function Factorial_13476(n: nat): nat\n ensures Factorial_13476(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_13476(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_13477","instance":13477,"id":233492,"goal":"function Fib_13477(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_13477(n-1) + Fib_13477(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_13478","instance":13478,"id":233493,"goal":"function Gcd_13478(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_13478(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_13479","instance":13479,"id":233494,"goal":"function Power_13479(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_13479(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_13480","instance":13480,"id":233495,"goal":"function Sum_13480(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_13480(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_13481","instance":13481,"id":233496,"goal":"method BinarySearch_13481(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_13482","instance":13482,"id":233497,"goal":"method InsertSort_13482(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_13483","instance":13483,"id":233498,"goal":"method MergeSort_13483(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_13484","instance":13484,"id":233499,"goal":"method ArrayCopy_13484(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_13485","instance":13485,"id":233500,"goal":"function ListReverse_13485(s: seq): seq\n ensures |ListReverse_13485(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_13485(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_13486","instance":13486,"id":233501,"goal":"function Factorial_13486(n: nat): nat\n ensures Factorial_13486(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_13486(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_13487","instance":13487,"id":233502,"goal":"function Fib_13487(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_13487(n-1) + Fib_13487(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_13488","instance":13488,"id":233503,"goal":"function Gcd_13488(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_13488(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_13489","instance":13489,"id":233504,"goal":"function Power_13489(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_13489(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_13490","instance":13490,"id":233505,"goal":"function Sum_13490(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_13490(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_13491","instance":13491,"id":233506,"goal":"method BinarySearch_13491(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_13492","instance":13492,"id":233507,"goal":"method InsertSort_13492(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_13493","instance":13493,"id":233508,"goal":"method MergeSort_13493(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_13494","instance":13494,"id":233509,"goal":"method ArrayCopy_13494(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_13495","instance":13495,"id":233510,"goal":"function ListReverse_13495(s: seq): seq\n ensures |ListReverse_13495(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_13495(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_13496","instance":13496,"id":233511,"goal":"function Factorial_13496(n: nat): nat\n ensures Factorial_13496(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_13496(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_13497","instance":13497,"id":233512,"goal":"function Fib_13497(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_13497(n-1) + Fib_13497(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_13498","instance":13498,"id":233513,"goal":"function Gcd_13498(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_13498(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_13499","instance":13499,"id":233514,"goal":"function Power_13499(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_13499(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_13500","instance":13500,"id":233515,"goal":"function Sum_13500(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_13500(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_13501","instance":13501,"id":233516,"goal":"method BinarySearch_13501(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_13502","instance":13502,"id":233517,"goal":"method InsertSort_13502(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_13503","instance":13503,"id":233518,"goal":"method MergeSort_13503(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_13504","instance":13504,"id":233519,"goal":"method ArrayCopy_13504(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_13505","instance":13505,"id":233520,"goal":"function ListReverse_13505(s: seq): seq\n ensures |ListReverse_13505(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_13505(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_13506","instance":13506,"id":233521,"goal":"function Factorial_13506(n: nat): nat\n ensures Factorial_13506(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_13506(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_13507","instance":13507,"id":233522,"goal":"function Fib_13507(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_13507(n-1) + Fib_13507(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_13508","instance":13508,"id":233523,"goal":"function Gcd_13508(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_13508(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_13509","instance":13509,"id":233524,"goal":"function Power_13509(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_13509(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_13510","instance":13510,"id":233525,"goal":"function Sum_13510(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_13510(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_13511","instance":13511,"id":233526,"goal":"method BinarySearch_13511(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_13512","instance":13512,"id":233527,"goal":"method InsertSort_13512(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_13513","instance":13513,"id":233528,"goal":"method MergeSort_13513(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_13514","instance":13514,"id":233529,"goal":"method ArrayCopy_13514(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_13515","instance":13515,"id":233530,"goal":"function ListReverse_13515(s: seq): seq\n ensures |ListReverse_13515(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_13515(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_13516","instance":13516,"id":233531,"goal":"function Factorial_13516(n: nat): nat\n ensures Factorial_13516(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_13516(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_13517","instance":13517,"id":233532,"goal":"function Fib_13517(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_13517(n-1) + Fib_13517(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_13518","instance":13518,"id":233533,"goal":"function Gcd_13518(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_13518(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_13519","instance":13519,"id":233534,"goal":"function Power_13519(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_13519(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_13520","instance":13520,"id":233535,"goal":"function Sum_13520(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_13520(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_13521","instance":13521,"id":233536,"goal":"method BinarySearch_13521(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_13522","instance":13522,"id":233537,"goal":"method InsertSort_13522(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_13523","instance":13523,"id":233538,"goal":"method MergeSort_13523(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_13524","instance":13524,"id":233539,"goal":"method ArrayCopy_13524(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_13525","instance":13525,"id":233540,"goal":"function ListReverse_13525(s: seq): seq\n ensures |ListReverse_13525(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_13525(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_13526","instance":13526,"id":233541,"goal":"function Factorial_13526(n: nat): nat\n ensures Factorial_13526(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_13526(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_13527","instance":13527,"id":233542,"goal":"function Fib_13527(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_13527(n-1) + Fib_13527(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_13528","instance":13528,"id":233543,"goal":"function Gcd_13528(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_13528(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_13529","instance":13529,"id":233544,"goal":"function Power_13529(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_13529(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_13530","instance":13530,"id":233545,"goal":"function Sum_13530(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_13530(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_13531","instance":13531,"id":233546,"goal":"method BinarySearch_13531(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_13532","instance":13532,"id":233547,"goal":"method InsertSort_13532(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_13533","instance":13533,"id":233548,"goal":"method MergeSort_13533(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_13534","instance":13534,"id":233549,"goal":"method ArrayCopy_13534(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_13535","instance":13535,"id":233550,"goal":"function ListReverse_13535(s: seq): seq\n ensures |ListReverse_13535(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_13535(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_13536","instance":13536,"id":233551,"goal":"function Factorial_13536(n: nat): nat\n ensures Factorial_13536(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_13536(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_13537","instance":13537,"id":233552,"goal":"function Fib_13537(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_13537(n-1) + Fib_13537(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_13538","instance":13538,"id":233553,"goal":"function Gcd_13538(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_13538(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_13539","instance":13539,"id":233554,"goal":"function Power_13539(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_13539(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_13540","instance":13540,"id":233555,"goal":"function Sum_13540(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_13540(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_13541","instance":13541,"id":233556,"goal":"method BinarySearch_13541(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_13542","instance":13542,"id":233557,"goal":"method InsertSort_13542(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_13543","instance":13543,"id":233558,"goal":"method MergeSort_13543(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_13544","instance":13544,"id":233559,"goal":"method ArrayCopy_13544(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_13545","instance":13545,"id":233560,"goal":"function ListReverse_13545(s: seq): seq\n ensures |ListReverse_13545(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_13545(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_13546","instance":13546,"id":233561,"goal":"function Factorial_13546(n: nat): nat\n ensures Factorial_13546(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_13546(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_13547","instance":13547,"id":233562,"goal":"function Fib_13547(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_13547(n-1) + Fib_13547(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_13548","instance":13548,"id":233563,"goal":"function Gcd_13548(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_13548(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_13549","instance":13549,"id":233564,"goal":"function Power_13549(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_13549(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_13550","instance":13550,"id":233565,"goal":"function Sum_13550(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_13550(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_13551","instance":13551,"id":233566,"goal":"method BinarySearch_13551(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_13552","instance":13552,"id":233567,"goal":"method InsertSort_13552(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_13553","instance":13553,"id":233568,"goal":"method MergeSort_13553(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_13554","instance":13554,"id":233569,"goal":"method ArrayCopy_13554(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_13555","instance":13555,"id":233570,"goal":"function ListReverse_13555(s: seq): seq\n ensures |ListReverse_13555(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_13555(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_13556","instance":13556,"id":233571,"goal":"function Factorial_13556(n: nat): nat\n ensures Factorial_13556(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_13556(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_13557","instance":13557,"id":233572,"goal":"function Fib_13557(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_13557(n-1) + Fib_13557(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_13558","instance":13558,"id":233573,"goal":"function Gcd_13558(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_13558(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_13559","instance":13559,"id":233574,"goal":"function Power_13559(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_13559(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_13560","instance":13560,"id":233575,"goal":"function Sum_13560(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_13560(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_13561","instance":13561,"id":233576,"goal":"method BinarySearch_13561(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_13562","instance":13562,"id":233577,"goal":"method InsertSort_13562(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_13563","instance":13563,"id":233578,"goal":"method MergeSort_13563(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_13564","instance":13564,"id":233579,"goal":"method ArrayCopy_13564(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_13565","instance":13565,"id":233580,"goal":"function ListReverse_13565(s: seq): seq\n ensures |ListReverse_13565(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_13565(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_13566","instance":13566,"id":233581,"goal":"function Factorial_13566(n: nat): nat\n ensures Factorial_13566(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_13566(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_13567","instance":13567,"id":233582,"goal":"function Fib_13567(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_13567(n-1) + Fib_13567(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_13568","instance":13568,"id":233583,"goal":"function Gcd_13568(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_13568(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_13569","instance":13569,"id":233584,"goal":"function Power_13569(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_13569(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_13570","instance":13570,"id":233585,"goal":"function Sum_13570(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_13570(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_13571","instance":13571,"id":233586,"goal":"method BinarySearch_13571(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_13572","instance":13572,"id":233587,"goal":"method InsertSort_13572(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_13573","instance":13573,"id":233588,"goal":"method MergeSort_13573(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_13574","instance":13574,"id":233589,"goal":"method ArrayCopy_13574(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_13575","instance":13575,"id":233590,"goal":"function ListReverse_13575(s: seq): seq\n ensures |ListReverse_13575(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_13575(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_13576","instance":13576,"id":233591,"goal":"function Factorial_13576(n: nat): nat\n ensures Factorial_13576(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_13576(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_13577","instance":13577,"id":233592,"goal":"function Fib_13577(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_13577(n-1) + Fib_13577(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_13578","instance":13578,"id":233593,"goal":"function Gcd_13578(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_13578(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_13579","instance":13579,"id":233594,"goal":"function Power_13579(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_13579(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_13580","instance":13580,"id":233595,"goal":"function Sum_13580(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_13580(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_13581","instance":13581,"id":233596,"goal":"method BinarySearch_13581(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_13582","instance":13582,"id":233597,"goal":"method InsertSort_13582(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_13583","instance":13583,"id":233598,"goal":"method MergeSort_13583(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_13584","instance":13584,"id":233599,"goal":"method ArrayCopy_13584(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_13585","instance":13585,"id":233600,"goal":"function ListReverse_13585(s: seq): seq\n ensures |ListReverse_13585(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_13585(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_13586","instance":13586,"id":233601,"goal":"function Factorial_13586(n: nat): nat\n ensures Factorial_13586(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_13586(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_13587","instance":13587,"id":233602,"goal":"function Fib_13587(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_13587(n-1) + Fib_13587(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_13588","instance":13588,"id":233603,"goal":"function Gcd_13588(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_13588(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_13589","instance":13589,"id":233604,"goal":"function Power_13589(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_13589(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_13590","instance":13590,"id":233605,"goal":"function Sum_13590(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_13590(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_13591","instance":13591,"id":233606,"goal":"method BinarySearch_13591(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_13592","instance":13592,"id":233607,"goal":"method InsertSort_13592(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_13593","instance":13593,"id":233608,"goal":"method MergeSort_13593(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_13594","instance":13594,"id":233609,"goal":"method ArrayCopy_13594(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_13595","instance":13595,"id":233610,"goal":"function ListReverse_13595(s: seq): seq\n ensures |ListReverse_13595(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_13595(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_13596","instance":13596,"id":233611,"goal":"function Factorial_13596(n: nat): nat\n ensures Factorial_13596(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_13596(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_13597","instance":13597,"id":233612,"goal":"function Fib_13597(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_13597(n-1) + Fib_13597(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_13598","instance":13598,"id":233613,"goal":"function Gcd_13598(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_13598(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_13599","instance":13599,"id":233614,"goal":"function Power_13599(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_13599(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_13600","instance":13600,"id":233615,"goal":"function Sum_13600(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_13600(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_13601","instance":13601,"id":233616,"goal":"method BinarySearch_13601(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_13602","instance":13602,"id":233617,"goal":"method InsertSort_13602(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_13603","instance":13603,"id":233618,"goal":"method MergeSort_13603(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_13604","instance":13604,"id":233619,"goal":"method ArrayCopy_13604(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_13605","instance":13605,"id":233620,"goal":"function ListReverse_13605(s: seq): seq\n ensures |ListReverse_13605(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_13605(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_13606","instance":13606,"id":233621,"goal":"function Factorial_13606(n: nat): nat\n ensures Factorial_13606(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_13606(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_13607","instance":13607,"id":233622,"goal":"function Fib_13607(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_13607(n-1) + Fib_13607(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_13608","instance":13608,"id":233623,"goal":"function Gcd_13608(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_13608(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_13609","instance":13609,"id":233624,"goal":"function Power_13609(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_13609(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_13610","instance":13610,"id":233625,"goal":"function Sum_13610(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_13610(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_13611","instance":13611,"id":233626,"goal":"method BinarySearch_13611(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_13612","instance":13612,"id":233627,"goal":"method InsertSort_13612(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_13613","instance":13613,"id":233628,"goal":"method MergeSort_13613(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_13614","instance":13614,"id":233629,"goal":"method ArrayCopy_13614(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_13615","instance":13615,"id":233630,"goal":"function ListReverse_13615(s: seq): seq\n ensures |ListReverse_13615(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_13615(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_13616","instance":13616,"id":233631,"goal":"function Factorial_13616(n: nat): nat\n ensures Factorial_13616(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_13616(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_13617","instance":13617,"id":233632,"goal":"function Fib_13617(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_13617(n-1) + Fib_13617(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_13618","instance":13618,"id":233633,"goal":"function Gcd_13618(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_13618(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_13619","instance":13619,"id":233634,"goal":"function Power_13619(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_13619(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_13620","instance":13620,"id":233635,"goal":"function Sum_13620(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_13620(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_13621","instance":13621,"id":233636,"goal":"method BinarySearch_13621(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_13622","instance":13622,"id":233637,"goal":"method InsertSort_13622(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_13623","instance":13623,"id":233638,"goal":"method MergeSort_13623(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_13624","instance":13624,"id":233639,"goal":"method ArrayCopy_13624(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_13625","instance":13625,"id":233640,"goal":"function ListReverse_13625(s: seq): seq\n ensures |ListReverse_13625(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_13625(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_13626","instance":13626,"id":233641,"goal":"function Factorial_13626(n: nat): nat\n ensures Factorial_13626(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_13626(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_13627","instance":13627,"id":233642,"goal":"function Fib_13627(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_13627(n-1) + Fib_13627(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_13628","instance":13628,"id":233643,"goal":"function Gcd_13628(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_13628(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_13629","instance":13629,"id":233644,"goal":"function Power_13629(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_13629(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_13630","instance":13630,"id":233645,"goal":"function Sum_13630(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_13630(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_13631","instance":13631,"id":233646,"goal":"method BinarySearch_13631(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_13632","instance":13632,"id":233647,"goal":"method InsertSort_13632(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_13633","instance":13633,"id":233648,"goal":"method MergeSort_13633(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_13634","instance":13634,"id":233649,"goal":"method ArrayCopy_13634(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_13635","instance":13635,"id":233650,"goal":"function ListReverse_13635(s: seq): seq\n ensures |ListReverse_13635(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_13635(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_13636","instance":13636,"id":233651,"goal":"function Factorial_13636(n: nat): nat\n ensures Factorial_13636(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_13636(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_13637","instance":13637,"id":233652,"goal":"function Fib_13637(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_13637(n-1) + Fib_13637(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_13638","instance":13638,"id":233653,"goal":"function Gcd_13638(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_13638(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_13639","instance":13639,"id":233654,"goal":"function Power_13639(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_13639(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_13640","instance":13640,"id":233655,"goal":"function Sum_13640(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_13640(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_13641","instance":13641,"id":233656,"goal":"method BinarySearch_13641(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_13642","instance":13642,"id":233657,"goal":"method InsertSort_13642(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_13643","instance":13643,"id":233658,"goal":"method MergeSort_13643(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_13644","instance":13644,"id":233659,"goal":"method ArrayCopy_13644(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_13645","instance":13645,"id":233660,"goal":"function ListReverse_13645(s: seq): seq\n ensures |ListReverse_13645(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_13645(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_13646","instance":13646,"id":233661,"goal":"function Factorial_13646(n: nat): nat\n ensures Factorial_13646(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_13646(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_13647","instance":13647,"id":233662,"goal":"function Fib_13647(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_13647(n-1) + Fib_13647(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_13648","instance":13648,"id":233663,"goal":"function Gcd_13648(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_13648(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_13649","instance":13649,"id":233664,"goal":"function Power_13649(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_13649(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_13650","instance":13650,"id":233665,"goal":"function Sum_13650(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_13650(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_13651","instance":13651,"id":233666,"goal":"method BinarySearch_13651(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_13652","instance":13652,"id":233667,"goal":"method InsertSort_13652(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_13653","instance":13653,"id":233668,"goal":"method MergeSort_13653(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_13654","instance":13654,"id":233669,"goal":"method ArrayCopy_13654(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_13655","instance":13655,"id":233670,"goal":"function ListReverse_13655(s: seq): seq\n ensures |ListReverse_13655(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_13655(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_13656","instance":13656,"id":233671,"goal":"function Factorial_13656(n: nat): nat\n ensures Factorial_13656(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_13656(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_13657","instance":13657,"id":233672,"goal":"function Fib_13657(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_13657(n-1) + Fib_13657(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_13658","instance":13658,"id":233673,"goal":"function Gcd_13658(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_13658(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_13659","instance":13659,"id":233674,"goal":"function Power_13659(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_13659(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_13660","instance":13660,"id":233675,"goal":"function Sum_13660(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_13660(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_13661","instance":13661,"id":233676,"goal":"method BinarySearch_13661(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_13662","instance":13662,"id":233677,"goal":"method InsertSort_13662(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_13663","instance":13663,"id":233678,"goal":"method MergeSort_13663(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_13664","instance":13664,"id":233679,"goal":"method ArrayCopy_13664(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_13665","instance":13665,"id":233680,"goal":"function ListReverse_13665(s: seq): seq\n ensures |ListReverse_13665(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_13665(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_13666","instance":13666,"id":233681,"goal":"function Factorial_13666(n: nat): nat\n ensures Factorial_13666(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_13666(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_13667","instance":13667,"id":233682,"goal":"function Fib_13667(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_13667(n-1) + Fib_13667(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_13668","instance":13668,"id":233683,"goal":"function Gcd_13668(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_13668(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_13669","instance":13669,"id":233684,"goal":"function Power_13669(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_13669(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_13670","instance":13670,"id":233685,"goal":"function Sum_13670(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_13670(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_13671","instance":13671,"id":233686,"goal":"method BinarySearch_13671(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_13672","instance":13672,"id":233687,"goal":"method InsertSort_13672(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_13673","instance":13673,"id":233688,"goal":"method MergeSort_13673(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_13674","instance":13674,"id":233689,"goal":"method ArrayCopy_13674(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_13675","instance":13675,"id":233690,"goal":"function ListReverse_13675(s: seq): seq\n ensures |ListReverse_13675(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_13675(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_13676","instance":13676,"id":233691,"goal":"function Factorial_13676(n: nat): nat\n ensures Factorial_13676(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_13676(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_13677","instance":13677,"id":233692,"goal":"function Fib_13677(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_13677(n-1) + Fib_13677(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_13678","instance":13678,"id":233693,"goal":"function Gcd_13678(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_13678(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_13679","instance":13679,"id":233694,"goal":"function Power_13679(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_13679(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_13680","instance":13680,"id":233695,"goal":"function Sum_13680(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_13680(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_13681","instance":13681,"id":233696,"goal":"method BinarySearch_13681(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_13682","instance":13682,"id":233697,"goal":"method InsertSort_13682(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_13683","instance":13683,"id":233698,"goal":"method MergeSort_13683(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_13684","instance":13684,"id":233699,"goal":"method ArrayCopy_13684(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_13685","instance":13685,"id":233700,"goal":"function ListReverse_13685(s: seq): seq\n ensures |ListReverse_13685(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_13685(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_13686","instance":13686,"id":233701,"goal":"function Factorial_13686(n: nat): nat\n ensures Factorial_13686(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_13686(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_13687","instance":13687,"id":233702,"goal":"function Fib_13687(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_13687(n-1) + Fib_13687(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_13688","instance":13688,"id":233703,"goal":"function Gcd_13688(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_13688(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_13689","instance":13689,"id":233704,"goal":"function Power_13689(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_13689(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_13690","instance":13690,"id":233705,"goal":"function Sum_13690(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_13690(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_13691","instance":13691,"id":233706,"goal":"method BinarySearch_13691(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_13692","instance":13692,"id":233707,"goal":"method InsertSort_13692(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_13693","instance":13693,"id":233708,"goal":"method MergeSort_13693(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_13694","instance":13694,"id":233709,"goal":"method ArrayCopy_13694(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_13695","instance":13695,"id":233710,"goal":"function ListReverse_13695(s: seq): seq\n ensures |ListReverse_13695(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_13695(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_13696","instance":13696,"id":233711,"goal":"function Factorial_13696(n: nat): nat\n ensures Factorial_13696(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_13696(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_13697","instance":13697,"id":233712,"goal":"function Fib_13697(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_13697(n-1) + Fib_13697(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_13698","instance":13698,"id":233713,"goal":"function Gcd_13698(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_13698(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_13699","instance":13699,"id":233714,"goal":"function Power_13699(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_13699(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_13700","instance":13700,"id":233715,"goal":"function Sum_13700(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_13700(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_13701","instance":13701,"id":233716,"goal":"method BinarySearch_13701(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_13702","instance":13702,"id":233717,"goal":"method InsertSort_13702(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_13703","instance":13703,"id":233718,"goal":"method MergeSort_13703(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_13704","instance":13704,"id":233719,"goal":"method ArrayCopy_13704(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_13705","instance":13705,"id":233720,"goal":"function ListReverse_13705(s: seq): seq\n ensures |ListReverse_13705(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_13705(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_13706","instance":13706,"id":233721,"goal":"function Factorial_13706(n: nat): nat\n ensures Factorial_13706(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_13706(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_13707","instance":13707,"id":233722,"goal":"function Fib_13707(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_13707(n-1) + Fib_13707(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_13708","instance":13708,"id":233723,"goal":"function Gcd_13708(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_13708(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_13709","instance":13709,"id":233724,"goal":"function Power_13709(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_13709(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_13710","instance":13710,"id":233725,"goal":"function Sum_13710(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_13710(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_13711","instance":13711,"id":233726,"goal":"method BinarySearch_13711(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_13712","instance":13712,"id":233727,"goal":"method InsertSort_13712(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_13713","instance":13713,"id":233728,"goal":"method MergeSort_13713(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_13714","instance":13714,"id":233729,"goal":"method ArrayCopy_13714(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_13715","instance":13715,"id":233730,"goal":"function ListReverse_13715(s: seq): seq\n ensures |ListReverse_13715(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_13715(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_13716","instance":13716,"id":233731,"goal":"function Factorial_13716(n: nat): nat\n ensures Factorial_13716(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_13716(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_13717","instance":13717,"id":233732,"goal":"function Fib_13717(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_13717(n-1) + Fib_13717(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_13718","instance":13718,"id":233733,"goal":"function Gcd_13718(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_13718(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_13719","instance":13719,"id":233734,"goal":"function Power_13719(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_13719(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_13720","instance":13720,"id":233735,"goal":"function Sum_13720(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_13720(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_13721","instance":13721,"id":233736,"goal":"method BinarySearch_13721(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_13722","instance":13722,"id":233737,"goal":"method InsertSort_13722(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_13723","instance":13723,"id":233738,"goal":"method MergeSort_13723(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_13724","instance":13724,"id":233739,"goal":"method ArrayCopy_13724(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_13725","instance":13725,"id":233740,"goal":"function ListReverse_13725(s: seq): seq\n ensures |ListReverse_13725(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_13725(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_13726","instance":13726,"id":233741,"goal":"function Factorial_13726(n: nat): nat\n ensures Factorial_13726(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_13726(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_13727","instance":13727,"id":233742,"goal":"function Fib_13727(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_13727(n-1) + Fib_13727(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_13728","instance":13728,"id":233743,"goal":"function Gcd_13728(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_13728(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_13729","instance":13729,"id":233744,"goal":"function Power_13729(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_13729(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_13730","instance":13730,"id":233745,"goal":"function Sum_13730(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_13730(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_13731","instance":13731,"id":233746,"goal":"method BinarySearch_13731(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_13732","instance":13732,"id":233747,"goal":"method InsertSort_13732(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_13733","instance":13733,"id":233748,"goal":"method MergeSort_13733(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_13734","instance":13734,"id":233749,"goal":"method ArrayCopy_13734(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_13735","instance":13735,"id":233750,"goal":"function ListReverse_13735(s: seq): seq\n ensures |ListReverse_13735(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_13735(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_13736","instance":13736,"id":233751,"goal":"function Factorial_13736(n: nat): nat\n ensures Factorial_13736(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_13736(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_13737","instance":13737,"id":233752,"goal":"function Fib_13737(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_13737(n-1) + Fib_13737(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_13738","instance":13738,"id":233753,"goal":"function Gcd_13738(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_13738(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_13739","instance":13739,"id":233754,"goal":"function Power_13739(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_13739(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_13740","instance":13740,"id":233755,"goal":"function Sum_13740(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_13740(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_13741","instance":13741,"id":233756,"goal":"method BinarySearch_13741(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_13742","instance":13742,"id":233757,"goal":"method InsertSort_13742(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_13743","instance":13743,"id":233758,"goal":"method MergeSort_13743(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_13744","instance":13744,"id":233759,"goal":"method ArrayCopy_13744(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_13745","instance":13745,"id":233760,"goal":"function ListReverse_13745(s: seq): seq\n ensures |ListReverse_13745(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_13745(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_13746","instance":13746,"id":233761,"goal":"function Factorial_13746(n: nat): nat\n ensures Factorial_13746(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_13746(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_13747","instance":13747,"id":233762,"goal":"function Fib_13747(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_13747(n-1) + Fib_13747(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_13748","instance":13748,"id":233763,"goal":"function Gcd_13748(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_13748(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_13749","instance":13749,"id":233764,"goal":"function Power_13749(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_13749(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_13750","instance":13750,"id":233765,"goal":"function Sum_13750(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_13750(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_13751","instance":13751,"id":233766,"goal":"method BinarySearch_13751(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_13752","instance":13752,"id":233767,"goal":"method InsertSort_13752(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_13753","instance":13753,"id":233768,"goal":"method MergeSort_13753(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_13754","instance":13754,"id":233769,"goal":"method ArrayCopy_13754(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_13755","instance":13755,"id":233770,"goal":"function ListReverse_13755(s: seq): seq\n ensures |ListReverse_13755(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_13755(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_13756","instance":13756,"id":233771,"goal":"function Factorial_13756(n: nat): nat\n ensures Factorial_13756(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_13756(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_13757","instance":13757,"id":233772,"goal":"function Fib_13757(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_13757(n-1) + Fib_13757(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_13758","instance":13758,"id":233773,"goal":"function Gcd_13758(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_13758(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_13759","instance":13759,"id":233774,"goal":"function Power_13759(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_13759(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_13760","instance":13760,"id":233775,"goal":"function Sum_13760(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_13760(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_13761","instance":13761,"id":233776,"goal":"method BinarySearch_13761(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_13762","instance":13762,"id":233777,"goal":"method InsertSort_13762(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_13763","instance":13763,"id":233778,"goal":"method MergeSort_13763(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_13764","instance":13764,"id":233779,"goal":"method ArrayCopy_13764(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_13765","instance":13765,"id":233780,"goal":"function ListReverse_13765(s: seq): seq\n ensures |ListReverse_13765(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_13765(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_13766","instance":13766,"id":233781,"goal":"function Factorial_13766(n: nat): nat\n ensures Factorial_13766(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_13766(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_13767","instance":13767,"id":233782,"goal":"function Fib_13767(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_13767(n-1) + Fib_13767(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_13768","instance":13768,"id":233783,"goal":"function Gcd_13768(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_13768(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_13769","instance":13769,"id":233784,"goal":"function Power_13769(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_13769(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_13770","instance":13770,"id":233785,"goal":"function Sum_13770(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_13770(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_13771","instance":13771,"id":233786,"goal":"method BinarySearch_13771(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_13772","instance":13772,"id":233787,"goal":"method InsertSort_13772(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_13773","instance":13773,"id":233788,"goal":"method MergeSort_13773(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_13774","instance":13774,"id":233789,"goal":"method ArrayCopy_13774(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_13775","instance":13775,"id":233790,"goal":"function ListReverse_13775(s: seq): seq\n ensures |ListReverse_13775(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_13775(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_13776","instance":13776,"id":233791,"goal":"function Factorial_13776(n: nat): nat\n ensures Factorial_13776(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_13776(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_13777","instance":13777,"id":233792,"goal":"function Fib_13777(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_13777(n-1) + Fib_13777(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_13778","instance":13778,"id":233793,"goal":"function Gcd_13778(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_13778(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_13779","instance":13779,"id":233794,"goal":"function Power_13779(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_13779(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_13780","instance":13780,"id":233795,"goal":"function Sum_13780(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_13780(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_13781","instance":13781,"id":233796,"goal":"method BinarySearch_13781(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_13782","instance":13782,"id":233797,"goal":"method InsertSort_13782(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_13783","instance":13783,"id":233798,"goal":"method MergeSort_13783(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_13784","instance":13784,"id":233799,"goal":"method ArrayCopy_13784(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_13785","instance":13785,"id":233800,"goal":"function ListReverse_13785(s: seq): seq\n ensures |ListReverse_13785(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_13785(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_13786","instance":13786,"id":233801,"goal":"function Factorial_13786(n: nat): nat\n ensures Factorial_13786(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_13786(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_13787","instance":13787,"id":233802,"goal":"function Fib_13787(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_13787(n-1) + Fib_13787(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_13788","instance":13788,"id":233803,"goal":"function Gcd_13788(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_13788(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_13789","instance":13789,"id":233804,"goal":"function Power_13789(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_13789(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_13790","instance":13790,"id":233805,"goal":"function Sum_13790(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_13790(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_13791","instance":13791,"id":233806,"goal":"method BinarySearch_13791(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_13792","instance":13792,"id":233807,"goal":"method InsertSort_13792(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_13793","instance":13793,"id":233808,"goal":"method MergeSort_13793(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_13794","instance":13794,"id":233809,"goal":"method ArrayCopy_13794(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_13795","instance":13795,"id":233810,"goal":"function ListReverse_13795(s: seq): seq\n ensures |ListReverse_13795(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_13795(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_13796","instance":13796,"id":233811,"goal":"function Factorial_13796(n: nat): nat\n ensures Factorial_13796(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_13796(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_13797","instance":13797,"id":233812,"goal":"function Fib_13797(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_13797(n-1) + Fib_13797(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_13798","instance":13798,"id":233813,"goal":"function Gcd_13798(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_13798(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_13799","instance":13799,"id":233814,"goal":"function Power_13799(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_13799(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_13800","instance":13800,"id":233815,"goal":"function Sum_13800(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_13800(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_13801","instance":13801,"id":233816,"goal":"method BinarySearch_13801(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_13802","instance":13802,"id":233817,"goal":"method InsertSort_13802(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_13803","instance":13803,"id":233818,"goal":"method MergeSort_13803(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_13804","instance":13804,"id":233819,"goal":"method ArrayCopy_13804(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_13805","instance":13805,"id":233820,"goal":"function ListReverse_13805(s: seq): seq\n ensures |ListReverse_13805(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_13805(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_13806","instance":13806,"id":233821,"goal":"function Factorial_13806(n: nat): nat\n ensures Factorial_13806(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_13806(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_13807","instance":13807,"id":233822,"goal":"function Fib_13807(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_13807(n-1) + Fib_13807(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_13808","instance":13808,"id":233823,"goal":"function Gcd_13808(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_13808(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_13809","instance":13809,"id":233824,"goal":"function Power_13809(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_13809(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_13810","instance":13810,"id":233825,"goal":"function Sum_13810(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_13810(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_13811","instance":13811,"id":233826,"goal":"method BinarySearch_13811(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_13812","instance":13812,"id":233827,"goal":"method InsertSort_13812(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_13813","instance":13813,"id":233828,"goal":"method MergeSort_13813(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_13814","instance":13814,"id":233829,"goal":"method ArrayCopy_13814(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_13815","instance":13815,"id":233830,"goal":"function ListReverse_13815(s: seq): seq\n ensures |ListReverse_13815(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_13815(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_13816","instance":13816,"id":233831,"goal":"function Factorial_13816(n: nat): nat\n ensures Factorial_13816(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_13816(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_13817","instance":13817,"id":233832,"goal":"function Fib_13817(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_13817(n-1) + Fib_13817(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_13818","instance":13818,"id":233833,"goal":"function Gcd_13818(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_13818(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_13819","instance":13819,"id":233834,"goal":"function Power_13819(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_13819(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_13820","instance":13820,"id":233835,"goal":"function Sum_13820(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_13820(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_13821","instance":13821,"id":233836,"goal":"method BinarySearch_13821(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_13822","instance":13822,"id":233837,"goal":"method InsertSort_13822(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_13823","instance":13823,"id":233838,"goal":"method MergeSort_13823(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_13824","instance":13824,"id":233839,"goal":"method ArrayCopy_13824(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_13825","instance":13825,"id":233840,"goal":"function ListReverse_13825(s: seq): seq\n ensures |ListReverse_13825(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_13825(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_13826","instance":13826,"id":233841,"goal":"function Factorial_13826(n: nat): nat\n ensures Factorial_13826(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_13826(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_13827","instance":13827,"id":233842,"goal":"function Fib_13827(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_13827(n-1) + Fib_13827(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_13828","instance":13828,"id":233843,"goal":"function Gcd_13828(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_13828(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_13829","instance":13829,"id":233844,"goal":"function Power_13829(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_13829(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_13830","instance":13830,"id":233845,"goal":"function Sum_13830(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_13830(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_13831","instance":13831,"id":233846,"goal":"method BinarySearch_13831(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_13832","instance":13832,"id":233847,"goal":"method InsertSort_13832(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_13833","instance":13833,"id":233848,"goal":"method MergeSort_13833(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_13834","instance":13834,"id":233849,"goal":"method ArrayCopy_13834(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_13835","instance":13835,"id":233850,"goal":"function ListReverse_13835(s: seq): seq\n ensures |ListReverse_13835(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_13835(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_13836","instance":13836,"id":233851,"goal":"function Factorial_13836(n: nat): nat\n ensures Factorial_13836(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_13836(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_13837","instance":13837,"id":233852,"goal":"function Fib_13837(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_13837(n-1) + Fib_13837(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_13838","instance":13838,"id":233853,"goal":"function Gcd_13838(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_13838(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_13839","instance":13839,"id":233854,"goal":"function Power_13839(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_13839(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_13840","instance":13840,"id":233855,"goal":"function Sum_13840(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_13840(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_13841","instance":13841,"id":233856,"goal":"method BinarySearch_13841(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_13842","instance":13842,"id":233857,"goal":"method InsertSort_13842(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_13843","instance":13843,"id":233858,"goal":"method MergeSort_13843(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_13844","instance":13844,"id":233859,"goal":"method ArrayCopy_13844(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_13845","instance":13845,"id":233860,"goal":"function ListReverse_13845(s: seq): seq\n ensures |ListReverse_13845(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_13845(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_13846","instance":13846,"id":233861,"goal":"function Factorial_13846(n: nat): nat\n ensures Factorial_13846(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_13846(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_13847","instance":13847,"id":233862,"goal":"function Fib_13847(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_13847(n-1) + Fib_13847(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_13848","instance":13848,"id":233863,"goal":"function Gcd_13848(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_13848(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_13849","instance":13849,"id":233864,"goal":"function Power_13849(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_13849(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_13850","instance":13850,"id":233865,"goal":"function Sum_13850(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_13850(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_13851","instance":13851,"id":233866,"goal":"method BinarySearch_13851(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_13852","instance":13852,"id":233867,"goal":"method InsertSort_13852(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_13853","instance":13853,"id":233868,"goal":"method MergeSort_13853(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_13854","instance":13854,"id":233869,"goal":"method ArrayCopy_13854(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_13855","instance":13855,"id":233870,"goal":"function ListReverse_13855(s: seq): seq\n ensures |ListReverse_13855(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_13855(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_13856","instance":13856,"id":233871,"goal":"function Factorial_13856(n: nat): nat\n ensures Factorial_13856(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_13856(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_13857","instance":13857,"id":233872,"goal":"function Fib_13857(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_13857(n-1) + Fib_13857(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_13858","instance":13858,"id":233873,"goal":"function Gcd_13858(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_13858(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_13859","instance":13859,"id":233874,"goal":"function Power_13859(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_13859(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_13860","instance":13860,"id":233875,"goal":"function Sum_13860(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_13860(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_13861","instance":13861,"id":233876,"goal":"method BinarySearch_13861(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_13862","instance":13862,"id":233877,"goal":"method InsertSort_13862(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_13863","instance":13863,"id":233878,"goal":"method MergeSort_13863(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_13864","instance":13864,"id":233879,"goal":"method ArrayCopy_13864(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_13865","instance":13865,"id":233880,"goal":"function ListReverse_13865(s: seq): seq\n ensures |ListReverse_13865(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_13865(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_13866","instance":13866,"id":233881,"goal":"function Factorial_13866(n: nat): nat\n ensures Factorial_13866(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_13866(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_13867","instance":13867,"id":233882,"goal":"function Fib_13867(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_13867(n-1) + Fib_13867(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_13868","instance":13868,"id":233883,"goal":"function Gcd_13868(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_13868(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_13869","instance":13869,"id":233884,"goal":"function Power_13869(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_13869(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_13870","instance":13870,"id":233885,"goal":"function Sum_13870(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_13870(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_13871","instance":13871,"id":233886,"goal":"method BinarySearch_13871(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_13872","instance":13872,"id":233887,"goal":"method InsertSort_13872(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_13873","instance":13873,"id":233888,"goal":"method MergeSort_13873(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_13874","instance":13874,"id":233889,"goal":"method ArrayCopy_13874(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_13875","instance":13875,"id":233890,"goal":"function ListReverse_13875(s: seq): seq\n ensures |ListReverse_13875(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_13875(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_13876","instance":13876,"id":233891,"goal":"function Factorial_13876(n: nat): nat\n ensures Factorial_13876(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_13876(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_13877","instance":13877,"id":233892,"goal":"function Fib_13877(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_13877(n-1) + Fib_13877(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_13878","instance":13878,"id":233893,"goal":"function Gcd_13878(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_13878(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_13879","instance":13879,"id":233894,"goal":"function Power_13879(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_13879(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_13880","instance":13880,"id":233895,"goal":"function Sum_13880(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_13880(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_13881","instance":13881,"id":233896,"goal":"method BinarySearch_13881(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_13882","instance":13882,"id":233897,"goal":"method InsertSort_13882(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_13883","instance":13883,"id":233898,"goal":"method MergeSort_13883(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_13884","instance":13884,"id":233899,"goal":"method ArrayCopy_13884(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_13885","instance":13885,"id":233900,"goal":"function ListReverse_13885(s: seq): seq\n ensures |ListReverse_13885(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_13885(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_13886","instance":13886,"id":233901,"goal":"function Factorial_13886(n: nat): nat\n ensures Factorial_13886(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_13886(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_13887","instance":13887,"id":233902,"goal":"function Fib_13887(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_13887(n-1) + Fib_13887(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_13888","instance":13888,"id":233903,"goal":"function Gcd_13888(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_13888(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_13889","instance":13889,"id":233904,"goal":"function Power_13889(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_13889(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_13890","instance":13890,"id":233905,"goal":"function Sum_13890(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_13890(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_13891","instance":13891,"id":233906,"goal":"method BinarySearch_13891(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_13892","instance":13892,"id":233907,"goal":"method InsertSort_13892(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_13893","instance":13893,"id":233908,"goal":"method MergeSort_13893(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_13894","instance":13894,"id":233909,"goal":"method ArrayCopy_13894(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_13895","instance":13895,"id":233910,"goal":"function ListReverse_13895(s: seq): seq\n ensures |ListReverse_13895(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_13895(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_13896","instance":13896,"id":233911,"goal":"function Factorial_13896(n: nat): nat\n ensures Factorial_13896(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_13896(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_13897","instance":13897,"id":233912,"goal":"function Fib_13897(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_13897(n-1) + Fib_13897(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_13898","instance":13898,"id":233913,"goal":"function Gcd_13898(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_13898(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_13899","instance":13899,"id":233914,"goal":"function Power_13899(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_13899(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_13900","instance":13900,"id":233915,"goal":"function Sum_13900(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_13900(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_13901","instance":13901,"id":233916,"goal":"method BinarySearch_13901(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_13902","instance":13902,"id":233917,"goal":"method InsertSort_13902(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_13903","instance":13903,"id":233918,"goal":"method MergeSort_13903(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_13904","instance":13904,"id":233919,"goal":"method ArrayCopy_13904(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_13905","instance":13905,"id":233920,"goal":"function ListReverse_13905(s: seq): seq\n ensures |ListReverse_13905(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_13905(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_13906","instance":13906,"id":233921,"goal":"function Factorial_13906(n: nat): nat\n ensures Factorial_13906(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_13906(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_13907","instance":13907,"id":233922,"goal":"function Fib_13907(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_13907(n-1) + Fib_13907(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_13908","instance":13908,"id":233923,"goal":"function Gcd_13908(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_13908(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_13909","instance":13909,"id":233924,"goal":"function Power_13909(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_13909(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_13910","instance":13910,"id":233925,"goal":"function Sum_13910(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_13910(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_13911","instance":13911,"id":233926,"goal":"method BinarySearch_13911(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_13912","instance":13912,"id":233927,"goal":"method InsertSort_13912(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_13913","instance":13913,"id":233928,"goal":"method MergeSort_13913(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_13914","instance":13914,"id":233929,"goal":"method ArrayCopy_13914(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_13915","instance":13915,"id":233930,"goal":"function ListReverse_13915(s: seq): seq\n ensures |ListReverse_13915(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_13915(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_13916","instance":13916,"id":233931,"goal":"function Factorial_13916(n: nat): nat\n ensures Factorial_13916(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_13916(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_13917","instance":13917,"id":233932,"goal":"function Fib_13917(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_13917(n-1) + Fib_13917(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_13918","instance":13918,"id":233933,"goal":"function Gcd_13918(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_13918(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_13919","instance":13919,"id":233934,"goal":"function Power_13919(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_13919(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_13920","instance":13920,"id":233935,"goal":"function Sum_13920(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_13920(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_13921","instance":13921,"id":233936,"goal":"method BinarySearch_13921(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_13922","instance":13922,"id":233937,"goal":"method InsertSort_13922(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_13923","instance":13923,"id":233938,"goal":"method MergeSort_13923(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_13924","instance":13924,"id":233939,"goal":"method ArrayCopy_13924(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_13925","instance":13925,"id":233940,"goal":"function ListReverse_13925(s: seq): seq\n ensures |ListReverse_13925(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_13925(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_13926","instance":13926,"id":233941,"goal":"function Factorial_13926(n: nat): nat\n ensures Factorial_13926(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_13926(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_13927","instance":13927,"id":233942,"goal":"function Fib_13927(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_13927(n-1) + Fib_13927(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_13928","instance":13928,"id":233943,"goal":"function Gcd_13928(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_13928(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_13929","instance":13929,"id":233944,"goal":"function Power_13929(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_13929(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_13930","instance":13930,"id":233945,"goal":"function Sum_13930(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_13930(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_13931","instance":13931,"id":233946,"goal":"method BinarySearch_13931(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_13932","instance":13932,"id":233947,"goal":"method InsertSort_13932(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_13933","instance":13933,"id":233948,"goal":"method MergeSort_13933(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_13934","instance":13934,"id":233949,"goal":"method ArrayCopy_13934(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_13935","instance":13935,"id":233950,"goal":"function ListReverse_13935(s: seq): seq\n ensures |ListReverse_13935(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_13935(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_13936","instance":13936,"id":233951,"goal":"function Factorial_13936(n: nat): nat\n ensures Factorial_13936(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_13936(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_13937","instance":13937,"id":233952,"goal":"function Fib_13937(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_13937(n-1) + Fib_13937(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_13938","instance":13938,"id":233953,"goal":"function Gcd_13938(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_13938(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_13939","instance":13939,"id":233954,"goal":"function Power_13939(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_13939(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_13940","instance":13940,"id":233955,"goal":"function Sum_13940(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_13940(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_13941","instance":13941,"id":233956,"goal":"method BinarySearch_13941(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_13942","instance":13942,"id":233957,"goal":"method InsertSort_13942(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_13943","instance":13943,"id":233958,"goal":"method MergeSort_13943(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_13944","instance":13944,"id":233959,"goal":"method ArrayCopy_13944(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_13945","instance":13945,"id":233960,"goal":"function ListReverse_13945(s: seq): seq\n ensures |ListReverse_13945(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_13945(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_13946","instance":13946,"id":233961,"goal":"function Factorial_13946(n: nat): nat\n ensures Factorial_13946(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_13946(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_13947","instance":13947,"id":233962,"goal":"function Fib_13947(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_13947(n-1) + Fib_13947(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_13948","instance":13948,"id":233963,"goal":"function Gcd_13948(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_13948(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_13949","instance":13949,"id":233964,"goal":"function Power_13949(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_13949(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_13950","instance":13950,"id":233965,"goal":"function Sum_13950(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_13950(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_13951","instance":13951,"id":233966,"goal":"method BinarySearch_13951(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_13952","instance":13952,"id":233967,"goal":"method InsertSort_13952(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_13953","instance":13953,"id":233968,"goal":"method MergeSort_13953(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_13954","instance":13954,"id":233969,"goal":"method ArrayCopy_13954(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_13955","instance":13955,"id":233970,"goal":"function ListReverse_13955(s: seq): seq\n ensures |ListReverse_13955(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_13955(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_13956","instance":13956,"id":233971,"goal":"function Factorial_13956(n: nat): nat\n ensures Factorial_13956(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_13956(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_13957","instance":13957,"id":233972,"goal":"function Fib_13957(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_13957(n-1) + Fib_13957(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_13958","instance":13958,"id":233973,"goal":"function Gcd_13958(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_13958(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_13959","instance":13959,"id":233974,"goal":"function Power_13959(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_13959(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_13960","instance":13960,"id":233975,"goal":"function Sum_13960(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_13960(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_13961","instance":13961,"id":233976,"goal":"method BinarySearch_13961(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_13962","instance":13962,"id":233977,"goal":"method InsertSort_13962(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_13963","instance":13963,"id":233978,"goal":"method MergeSort_13963(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_13964","instance":13964,"id":233979,"goal":"method ArrayCopy_13964(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_13965","instance":13965,"id":233980,"goal":"function ListReverse_13965(s: seq): seq\n ensures |ListReverse_13965(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_13965(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_13966","instance":13966,"id":233981,"goal":"function Factorial_13966(n: nat): nat\n ensures Factorial_13966(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_13966(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_13967","instance":13967,"id":233982,"goal":"function Fib_13967(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_13967(n-1) + Fib_13967(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_13968","instance":13968,"id":233983,"goal":"function Gcd_13968(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_13968(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_13969","instance":13969,"id":233984,"goal":"function Power_13969(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_13969(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_13970","instance":13970,"id":233985,"goal":"function Sum_13970(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_13970(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_13971","instance":13971,"id":233986,"goal":"method BinarySearch_13971(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_13972","instance":13972,"id":233987,"goal":"method InsertSort_13972(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_13973","instance":13973,"id":233988,"goal":"method MergeSort_13973(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_13974","instance":13974,"id":233989,"goal":"method ArrayCopy_13974(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_13975","instance":13975,"id":233990,"goal":"function ListReverse_13975(s: seq): seq\n ensures |ListReverse_13975(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_13975(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_13976","instance":13976,"id":233991,"goal":"function Factorial_13976(n: nat): nat\n ensures Factorial_13976(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_13976(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_13977","instance":13977,"id":233992,"goal":"function Fib_13977(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_13977(n-1) + Fib_13977(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_13978","instance":13978,"id":233993,"goal":"function Gcd_13978(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_13978(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_13979","instance":13979,"id":233994,"goal":"function Power_13979(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_13979(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_13980","instance":13980,"id":233995,"goal":"function Sum_13980(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_13980(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_13981","instance":13981,"id":233996,"goal":"method BinarySearch_13981(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_13982","instance":13982,"id":233997,"goal":"method InsertSort_13982(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_13983","instance":13983,"id":233998,"goal":"method MergeSort_13983(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_13984","instance":13984,"id":233999,"goal":"method ArrayCopy_13984(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_13985","instance":13985,"id":234000,"goal":"function ListReverse_13985(s: seq): seq\n ensures |ListReverse_13985(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_13985(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_13986","instance":13986,"id":234001,"goal":"function Factorial_13986(n: nat): nat\n ensures Factorial_13986(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_13986(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_13987","instance":13987,"id":234002,"goal":"function Fib_13987(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_13987(n-1) + Fib_13987(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_13988","instance":13988,"id":234003,"goal":"function Gcd_13988(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_13988(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_13989","instance":13989,"id":234004,"goal":"function Power_13989(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_13989(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_13990","instance":13990,"id":234005,"goal":"function Sum_13990(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_13990(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_13991","instance":13991,"id":234006,"goal":"method BinarySearch_13991(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_13992","instance":13992,"id":234007,"goal":"method InsertSort_13992(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_13993","instance":13993,"id":234008,"goal":"method MergeSort_13993(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_13994","instance":13994,"id":234009,"goal":"method ArrayCopy_13994(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_13995","instance":13995,"id":234010,"goal":"function ListReverse_13995(s: seq): seq\n ensures |ListReverse_13995(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_13995(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_13996","instance":13996,"id":234011,"goal":"function Factorial_13996(n: nat): nat\n ensures Factorial_13996(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_13996(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_13997","instance":13997,"id":234012,"goal":"function Fib_13997(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_13997(n-1) + Fib_13997(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_13998","instance":13998,"id":234013,"goal":"function Gcd_13998(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_13998(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_13999","instance":13999,"id":234014,"goal":"function Power_13999(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_13999(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_14000","instance":14000,"id":234015,"goal":"function Sum_14000(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_14000(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_14001","instance":14001,"id":234016,"goal":"method BinarySearch_14001(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_14002","instance":14002,"id":234017,"goal":"method InsertSort_14002(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_14003","instance":14003,"id":234018,"goal":"method MergeSort_14003(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_14004","instance":14004,"id":234019,"goal":"method ArrayCopy_14004(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_14005","instance":14005,"id":234020,"goal":"function ListReverse_14005(s: seq): seq\n ensures |ListReverse_14005(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_14005(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_14006","instance":14006,"id":234021,"goal":"function Factorial_14006(n: nat): nat\n ensures Factorial_14006(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_14006(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_14007","instance":14007,"id":234022,"goal":"function Fib_14007(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_14007(n-1) + Fib_14007(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_14008","instance":14008,"id":234023,"goal":"function Gcd_14008(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_14008(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_14009","instance":14009,"id":234024,"goal":"function Power_14009(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_14009(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_14010","instance":14010,"id":234025,"goal":"function Sum_14010(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_14010(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_14011","instance":14011,"id":234026,"goal":"method BinarySearch_14011(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_14012","instance":14012,"id":234027,"goal":"method InsertSort_14012(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_14013","instance":14013,"id":234028,"goal":"method MergeSort_14013(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_14014","instance":14014,"id":234029,"goal":"method ArrayCopy_14014(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_14015","instance":14015,"id":234030,"goal":"function ListReverse_14015(s: seq): seq\n ensures |ListReverse_14015(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_14015(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_14016","instance":14016,"id":234031,"goal":"function Factorial_14016(n: nat): nat\n ensures Factorial_14016(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_14016(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_14017","instance":14017,"id":234032,"goal":"function Fib_14017(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_14017(n-1) + Fib_14017(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_14018","instance":14018,"id":234033,"goal":"function Gcd_14018(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_14018(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_14019","instance":14019,"id":234034,"goal":"function Power_14019(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_14019(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_14020","instance":14020,"id":234035,"goal":"function Sum_14020(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_14020(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_14021","instance":14021,"id":234036,"goal":"method BinarySearch_14021(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_14022","instance":14022,"id":234037,"goal":"method InsertSort_14022(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_14023","instance":14023,"id":234038,"goal":"method MergeSort_14023(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_14024","instance":14024,"id":234039,"goal":"method ArrayCopy_14024(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_14025","instance":14025,"id":234040,"goal":"function ListReverse_14025(s: seq): seq\n ensures |ListReverse_14025(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_14025(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_14026","instance":14026,"id":234041,"goal":"function Factorial_14026(n: nat): nat\n ensures Factorial_14026(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_14026(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_14027","instance":14027,"id":234042,"goal":"function Fib_14027(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_14027(n-1) + Fib_14027(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_14028","instance":14028,"id":234043,"goal":"function Gcd_14028(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_14028(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_14029","instance":14029,"id":234044,"goal":"function Power_14029(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_14029(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_14030","instance":14030,"id":234045,"goal":"function Sum_14030(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_14030(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_14031","instance":14031,"id":234046,"goal":"method BinarySearch_14031(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_14032","instance":14032,"id":234047,"goal":"method InsertSort_14032(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_14033","instance":14033,"id":234048,"goal":"method MergeSort_14033(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_14034","instance":14034,"id":234049,"goal":"method ArrayCopy_14034(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_14035","instance":14035,"id":234050,"goal":"function ListReverse_14035(s: seq): seq\n ensures |ListReverse_14035(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_14035(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_14036","instance":14036,"id":234051,"goal":"function Factorial_14036(n: nat): nat\n ensures Factorial_14036(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_14036(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_14037","instance":14037,"id":234052,"goal":"function Fib_14037(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_14037(n-1) + Fib_14037(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_14038","instance":14038,"id":234053,"goal":"function Gcd_14038(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_14038(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_14039","instance":14039,"id":234054,"goal":"function Power_14039(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_14039(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_14040","instance":14040,"id":234055,"goal":"function Sum_14040(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_14040(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_14041","instance":14041,"id":234056,"goal":"method BinarySearch_14041(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_14042","instance":14042,"id":234057,"goal":"method InsertSort_14042(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_14043","instance":14043,"id":234058,"goal":"method MergeSort_14043(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_14044","instance":14044,"id":234059,"goal":"method ArrayCopy_14044(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_14045","instance":14045,"id":234060,"goal":"function ListReverse_14045(s: seq): seq\n ensures |ListReverse_14045(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_14045(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_14046","instance":14046,"id":234061,"goal":"function Factorial_14046(n: nat): nat\n ensures Factorial_14046(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_14046(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_14047","instance":14047,"id":234062,"goal":"function Fib_14047(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_14047(n-1) + Fib_14047(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_14048","instance":14048,"id":234063,"goal":"function Gcd_14048(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_14048(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_14049","instance":14049,"id":234064,"goal":"function Power_14049(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_14049(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_14050","instance":14050,"id":234065,"goal":"function Sum_14050(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_14050(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_14051","instance":14051,"id":234066,"goal":"method BinarySearch_14051(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_14052","instance":14052,"id":234067,"goal":"method InsertSort_14052(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_14053","instance":14053,"id":234068,"goal":"method MergeSort_14053(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_14054","instance":14054,"id":234069,"goal":"method ArrayCopy_14054(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_14055","instance":14055,"id":234070,"goal":"function ListReverse_14055(s: seq): seq\n ensures |ListReverse_14055(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_14055(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_14056","instance":14056,"id":234071,"goal":"function Factorial_14056(n: nat): nat\n ensures Factorial_14056(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_14056(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_14057","instance":14057,"id":234072,"goal":"function Fib_14057(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_14057(n-1) + Fib_14057(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_14058","instance":14058,"id":234073,"goal":"function Gcd_14058(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_14058(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_14059","instance":14059,"id":234074,"goal":"function Power_14059(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_14059(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_14060","instance":14060,"id":234075,"goal":"function Sum_14060(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_14060(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_14061","instance":14061,"id":234076,"goal":"method BinarySearch_14061(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_14062","instance":14062,"id":234077,"goal":"method InsertSort_14062(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_14063","instance":14063,"id":234078,"goal":"method MergeSort_14063(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_14064","instance":14064,"id":234079,"goal":"method ArrayCopy_14064(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_14065","instance":14065,"id":234080,"goal":"function ListReverse_14065(s: seq): seq\n ensures |ListReverse_14065(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_14065(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_14066","instance":14066,"id":234081,"goal":"function Factorial_14066(n: nat): nat\n ensures Factorial_14066(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_14066(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_14067","instance":14067,"id":234082,"goal":"function Fib_14067(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_14067(n-1) + Fib_14067(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_14068","instance":14068,"id":234083,"goal":"function Gcd_14068(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_14068(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_14069","instance":14069,"id":234084,"goal":"function Power_14069(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_14069(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_14070","instance":14070,"id":234085,"goal":"function Sum_14070(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_14070(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_14071","instance":14071,"id":234086,"goal":"method BinarySearch_14071(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_14072","instance":14072,"id":234087,"goal":"method InsertSort_14072(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_14073","instance":14073,"id":234088,"goal":"method MergeSort_14073(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_14074","instance":14074,"id":234089,"goal":"method ArrayCopy_14074(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_14075","instance":14075,"id":234090,"goal":"function ListReverse_14075(s: seq): seq\n ensures |ListReverse_14075(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_14075(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_14076","instance":14076,"id":234091,"goal":"function Factorial_14076(n: nat): nat\n ensures Factorial_14076(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_14076(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_14077","instance":14077,"id":234092,"goal":"function Fib_14077(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_14077(n-1) + Fib_14077(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_14078","instance":14078,"id":234093,"goal":"function Gcd_14078(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_14078(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_14079","instance":14079,"id":234094,"goal":"function Power_14079(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_14079(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_14080","instance":14080,"id":234095,"goal":"function Sum_14080(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_14080(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_14081","instance":14081,"id":234096,"goal":"method BinarySearch_14081(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_14082","instance":14082,"id":234097,"goal":"method InsertSort_14082(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_14083","instance":14083,"id":234098,"goal":"method MergeSort_14083(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_14084","instance":14084,"id":234099,"goal":"method ArrayCopy_14084(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_14085","instance":14085,"id":234100,"goal":"function ListReverse_14085(s: seq): seq\n ensures |ListReverse_14085(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_14085(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_14086","instance":14086,"id":234101,"goal":"function Factorial_14086(n: nat): nat\n ensures Factorial_14086(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_14086(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_14087","instance":14087,"id":234102,"goal":"function Fib_14087(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_14087(n-1) + Fib_14087(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_14088","instance":14088,"id":234103,"goal":"function Gcd_14088(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_14088(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_14089","instance":14089,"id":234104,"goal":"function Power_14089(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_14089(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_14090","instance":14090,"id":234105,"goal":"function Sum_14090(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_14090(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_14091","instance":14091,"id":234106,"goal":"method BinarySearch_14091(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_14092","instance":14092,"id":234107,"goal":"method InsertSort_14092(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_14093","instance":14093,"id":234108,"goal":"method MergeSort_14093(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_14094","instance":14094,"id":234109,"goal":"method ArrayCopy_14094(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_14095","instance":14095,"id":234110,"goal":"function ListReverse_14095(s: seq): seq\n ensures |ListReverse_14095(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_14095(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_14096","instance":14096,"id":234111,"goal":"function Factorial_14096(n: nat): nat\n ensures Factorial_14096(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_14096(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_14097","instance":14097,"id":234112,"goal":"function Fib_14097(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_14097(n-1) + Fib_14097(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_14098","instance":14098,"id":234113,"goal":"function Gcd_14098(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_14098(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_14099","instance":14099,"id":234114,"goal":"function Power_14099(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_14099(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_14100","instance":14100,"id":234115,"goal":"function Sum_14100(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_14100(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_14101","instance":14101,"id":234116,"goal":"method BinarySearch_14101(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_14102","instance":14102,"id":234117,"goal":"method InsertSort_14102(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_14103","instance":14103,"id":234118,"goal":"method MergeSort_14103(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_14104","instance":14104,"id":234119,"goal":"method ArrayCopy_14104(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_14105","instance":14105,"id":234120,"goal":"function ListReverse_14105(s: seq): seq\n ensures |ListReverse_14105(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_14105(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_14106","instance":14106,"id":234121,"goal":"function Factorial_14106(n: nat): nat\n ensures Factorial_14106(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_14106(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_14107","instance":14107,"id":234122,"goal":"function Fib_14107(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_14107(n-1) + Fib_14107(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_14108","instance":14108,"id":234123,"goal":"function Gcd_14108(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_14108(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_14109","instance":14109,"id":234124,"goal":"function Power_14109(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_14109(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_14110","instance":14110,"id":234125,"goal":"function Sum_14110(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_14110(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_14111","instance":14111,"id":234126,"goal":"method BinarySearch_14111(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_14112","instance":14112,"id":234127,"goal":"method InsertSort_14112(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_14113","instance":14113,"id":234128,"goal":"method MergeSort_14113(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_14114","instance":14114,"id":234129,"goal":"method ArrayCopy_14114(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_14115","instance":14115,"id":234130,"goal":"function ListReverse_14115(s: seq): seq\n ensures |ListReverse_14115(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_14115(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_14116","instance":14116,"id":234131,"goal":"function Factorial_14116(n: nat): nat\n ensures Factorial_14116(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_14116(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_14117","instance":14117,"id":234132,"goal":"function Fib_14117(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_14117(n-1) + Fib_14117(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_14118","instance":14118,"id":234133,"goal":"function Gcd_14118(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_14118(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_14119","instance":14119,"id":234134,"goal":"function Power_14119(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_14119(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_14120","instance":14120,"id":234135,"goal":"function Sum_14120(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_14120(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_14121","instance":14121,"id":234136,"goal":"method BinarySearch_14121(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_14122","instance":14122,"id":234137,"goal":"method InsertSort_14122(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_14123","instance":14123,"id":234138,"goal":"method MergeSort_14123(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_14124","instance":14124,"id":234139,"goal":"method ArrayCopy_14124(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_14125","instance":14125,"id":234140,"goal":"function ListReverse_14125(s: seq): seq\n ensures |ListReverse_14125(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_14125(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_14126","instance":14126,"id":234141,"goal":"function Factorial_14126(n: nat): nat\n ensures Factorial_14126(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_14126(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_14127","instance":14127,"id":234142,"goal":"function Fib_14127(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_14127(n-1) + Fib_14127(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_14128","instance":14128,"id":234143,"goal":"function Gcd_14128(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_14128(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_14129","instance":14129,"id":234144,"goal":"function Power_14129(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_14129(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_14130","instance":14130,"id":234145,"goal":"function Sum_14130(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_14130(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_14131","instance":14131,"id":234146,"goal":"method BinarySearch_14131(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_14132","instance":14132,"id":234147,"goal":"method InsertSort_14132(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_14133","instance":14133,"id":234148,"goal":"method MergeSort_14133(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_14134","instance":14134,"id":234149,"goal":"method ArrayCopy_14134(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_14135","instance":14135,"id":234150,"goal":"function ListReverse_14135(s: seq): seq\n ensures |ListReverse_14135(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_14135(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_14136","instance":14136,"id":234151,"goal":"function Factorial_14136(n: nat): nat\n ensures Factorial_14136(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_14136(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_14137","instance":14137,"id":234152,"goal":"function Fib_14137(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_14137(n-1) + Fib_14137(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_14138","instance":14138,"id":234153,"goal":"function Gcd_14138(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_14138(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_14139","instance":14139,"id":234154,"goal":"function Power_14139(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_14139(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_14140","instance":14140,"id":234155,"goal":"function Sum_14140(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_14140(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_14141","instance":14141,"id":234156,"goal":"method BinarySearch_14141(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_14142","instance":14142,"id":234157,"goal":"method InsertSort_14142(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_14143","instance":14143,"id":234158,"goal":"method MergeSort_14143(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_14144","instance":14144,"id":234159,"goal":"method ArrayCopy_14144(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_14145","instance":14145,"id":234160,"goal":"function ListReverse_14145(s: seq): seq\n ensures |ListReverse_14145(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_14145(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_14146","instance":14146,"id":234161,"goal":"function Factorial_14146(n: nat): nat\n ensures Factorial_14146(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_14146(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_14147","instance":14147,"id":234162,"goal":"function Fib_14147(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_14147(n-1) + Fib_14147(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_14148","instance":14148,"id":234163,"goal":"function Gcd_14148(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_14148(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_14149","instance":14149,"id":234164,"goal":"function Power_14149(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_14149(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_14150","instance":14150,"id":234165,"goal":"function Sum_14150(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_14150(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_14151","instance":14151,"id":234166,"goal":"method BinarySearch_14151(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_14152","instance":14152,"id":234167,"goal":"method InsertSort_14152(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_14153","instance":14153,"id":234168,"goal":"method MergeSort_14153(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_14154","instance":14154,"id":234169,"goal":"method ArrayCopy_14154(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_14155","instance":14155,"id":234170,"goal":"function ListReverse_14155(s: seq): seq\n ensures |ListReverse_14155(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_14155(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_14156","instance":14156,"id":234171,"goal":"function Factorial_14156(n: nat): nat\n ensures Factorial_14156(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_14156(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_14157","instance":14157,"id":234172,"goal":"function Fib_14157(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_14157(n-1) + Fib_14157(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_14158","instance":14158,"id":234173,"goal":"function Gcd_14158(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_14158(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_14159","instance":14159,"id":234174,"goal":"function Power_14159(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_14159(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_14160","instance":14160,"id":234175,"goal":"function Sum_14160(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_14160(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_14161","instance":14161,"id":234176,"goal":"method BinarySearch_14161(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_14162","instance":14162,"id":234177,"goal":"method InsertSort_14162(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_14163","instance":14163,"id":234178,"goal":"method MergeSort_14163(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_14164","instance":14164,"id":234179,"goal":"method ArrayCopy_14164(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_14165","instance":14165,"id":234180,"goal":"function ListReverse_14165(s: seq): seq\n ensures |ListReverse_14165(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_14165(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_14166","instance":14166,"id":234181,"goal":"function Factorial_14166(n: nat): nat\n ensures Factorial_14166(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_14166(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_14167","instance":14167,"id":234182,"goal":"function Fib_14167(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_14167(n-1) + Fib_14167(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_14168","instance":14168,"id":234183,"goal":"function Gcd_14168(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_14168(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_14169","instance":14169,"id":234184,"goal":"function Power_14169(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_14169(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_14170","instance":14170,"id":234185,"goal":"function Sum_14170(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_14170(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_14171","instance":14171,"id":234186,"goal":"method BinarySearch_14171(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_14172","instance":14172,"id":234187,"goal":"method InsertSort_14172(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_14173","instance":14173,"id":234188,"goal":"method MergeSort_14173(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_14174","instance":14174,"id":234189,"goal":"method ArrayCopy_14174(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_14175","instance":14175,"id":234190,"goal":"function ListReverse_14175(s: seq): seq\n ensures |ListReverse_14175(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_14175(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_14176","instance":14176,"id":234191,"goal":"function Factorial_14176(n: nat): nat\n ensures Factorial_14176(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_14176(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_14177","instance":14177,"id":234192,"goal":"function Fib_14177(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_14177(n-1) + Fib_14177(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_14178","instance":14178,"id":234193,"goal":"function Gcd_14178(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_14178(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_14179","instance":14179,"id":234194,"goal":"function Power_14179(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_14179(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_14180","instance":14180,"id":234195,"goal":"function Sum_14180(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_14180(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_14181","instance":14181,"id":234196,"goal":"method BinarySearch_14181(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_14182","instance":14182,"id":234197,"goal":"method InsertSort_14182(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_14183","instance":14183,"id":234198,"goal":"method MergeSort_14183(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_14184","instance":14184,"id":234199,"goal":"method ArrayCopy_14184(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_14185","instance":14185,"id":234200,"goal":"function ListReverse_14185(s: seq): seq\n ensures |ListReverse_14185(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_14185(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_14186","instance":14186,"id":234201,"goal":"function Factorial_14186(n: nat): nat\n ensures Factorial_14186(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_14186(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_14187","instance":14187,"id":234202,"goal":"function Fib_14187(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_14187(n-1) + Fib_14187(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_14188","instance":14188,"id":234203,"goal":"function Gcd_14188(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_14188(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_14189","instance":14189,"id":234204,"goal":"function Power_14189(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_14189(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_14190","instance":14190,"id":234205,"goal":"function Sum_14190(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_14190(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_14191","instance":14191,"id":234206,"goal":"method BinarySearch_14191(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_14192","instance":14192,"id":234207,"goal":"method InsertSort_14192(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_14193","instance":14193,"id":234208,"goal":"method MergeSort_14193(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_14194","instance":14194,"id":234209,"goal":"method ArrayCopy_14194(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_14195","instance":14195,"id":234210,"goal":"function ListReverse_14195(s: seq): seq\n ensures |ListReverse_14195(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_14195(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_14196","instance":14196,"id":234211,"goal":"function Factorial_14196(n: nat): nat\n ensures Factorial_14196(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_14196(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_14197","instance":14197,"id":234212,"goal":"function Fib_14197(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_14197(n-1) + Fib_14197(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_14198","instance":14198,"id":234213,"goal":"function Gcd_14198(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_14198(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_14199","instance":14199,"id":234214,"goal":"function Power_14199(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_14199(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_14200","instance":14200,"id":234215,"goal":"function Sum_14200(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_14200(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_14201","instance":14201,"id":234216,"goal":"method BinarySearch_14201(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_14202","instance":14202,"id":234217,"goal":"method InsertSort_14202(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_14203","instance":14203,"id":234218,"goal":"method MergeSort_14203(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_14204","instance":14204,"id":234219,"goal":"method ArrayCopy_14204(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_14205","instance":14205,"id":234220,"goal":"function ListReverse_14205(s: seq): seq\n ensures |ListReverse_14205(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_14205(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_14206","instance":14206,"id":234221,"goal":"function Factorial_14206(n: nat): nat\n ensures Factorial_14206(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_14206(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_14207","instance":14207,"id":234222,"goal":"function Fib_14207(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_14207(n-1) + Fib_14207(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_14208","instance":14208,"id":234223,"goal":"function Gcd_14208(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_14208(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_14209","instance":14209,"id":234224,"goal":"function Power_14209(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_14209(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_14210","instance":14210,"id":234225,"goal":"function Sum_14210(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_14210(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_14211","instance":14211,"id":234226,"goal":"method BinarySearch_14211(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_14212","instance":14212,"id":234227,"goal":"method InsertSort_14212(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_14213","instance":14213,"id":234228,"goal":"method MergeSort_14213(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_14214","instance":14214,"id":234229,"goal":"method ArrayCopy_14214(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_14215","instance":14215,"id":234230,"goal":"function ListReverse_14215(s: seq): seq\n ensures |ListReverse_14215(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_14215(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_14216","instance":14216,"id":234231,"goal":"function Factorial_14216(n: nat): nat\n ensures Factorial_14216(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_14216(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_14217","instance":14217,"id":234232,"goal":"function Fib_14217(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_14217(n-1) + Fib_14217(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_14218","instance":14218,"id":234233,"goal":"function Gcd_14218(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_14218(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_14219","instance":14219,"id":234234,"goal":"function Power_14219(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_14219(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_14220","instance":14220,"id":234235,"goal":"function Sum_14220(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_14220(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_14221","instance":14221,"id":234236,"goal":"method BinarySearch_14221(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_14222","instance":14222,"id":234237,"goal":"method InsertSort_14222(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_14223","instance":14223,"id":234238,"goal":"method MergeSort_14223(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_14224","instance":14224,"id":234239,"goal":"method ArrayCopy_14224(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_14225","instance":14225,"id":234240,"goal":"function ListReverse_14225(s: seq): seq\n ensures |ListReverse_14225(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_14225(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_14226","instance":14226,"id":234241,"goal":"function Factorial_14226(n: nat): nat\n ensures Factorial_14226(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_14226(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_14227","instance":14227,"id":234242,"goal":"function Fib_14227(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_14227(n-1) + Fib_14227(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_14228","instance":14228,"id":234243,"goal":"function Gcd_14228(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_14228(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_14229","instance":14229,"id":234244,"goal":"function Power_14229(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_14229(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_14230","instance":14230,"id":234245,"goal":"function Sum_14230(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_14230(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_14231","instance":14231,"id":234246,"goal":"method BinarySearch_14231(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_14232","instance":14232,"id":234247,"goal":"method InsertSort_14232(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_14233","instance":14233,"id":234248,"goal":"method MergeSort_14233(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_14234","instance":14234,"id":234249,"goal":"method ArrayCopy_14234(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_14235","instance":14235,"id":234250,"goal":"function ListReverse_14235(s: seq): seq\n ensures |ListReverse_14235(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_14235(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_14236","instance":14236,"id":234251,"goal":"function Factorial_14236(n: nat): nat\n ensures Factorial_14236(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_14236(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_14237","instance":14237,"id":234252,"goal":"function Fib_14237(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_14237(n-1) + Fib_14237(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_14238","instance":14238,"id":234253,"goal":"function Gcd_14238(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_14238(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_14239","instance":14239,"id":234254,"goal":"function Power_14239(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_14239(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_14240","instance":14240,"id":234255,"goal":"function Sum_14240(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_14240(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_14241","instance":14241,"id":234256,"goal":"method BinarySearch_14241(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_14242","instance":14242,"id":234257,"goal":"method InsertSort_14242(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_14243","instance":14243,"id":234258,"goal":"method MergeSort_14243(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_14244","instance":14244,"id":234259,"goal":"method ArrayCopy_14244(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_14245","instance":14245,"id":234260,"goal":"function ListReverse_14245(s: seq): seq\n ensures |ListReverse_14245(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_14245(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_14246","instance":14246,"id":234261,"goal":"function Factorial_14246(n: nat): nat\n ensures Factorial_14246(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_14246(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_14247","instance":14247,"id":234262,"goal":"function Fib_14247(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_14247(n-1) + Fib_14247(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_14248","instance":14248,"id":234263,"goal":"function Gcd_14248(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_14248(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_14249","instance":14249,"id":234264,"goal":"function Power_14249(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_14249(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_14250","instance":14250,"id":234265,"goal":"function Sum_14250(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_14250(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_14251","instance":14251,"id":234266,"goal":"method BinarySearch_14251(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_14252","instance":14252,"id":234267,"goal":"method InsertSort_14252(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_14253","instance":14253,"id":234268,"goal":"method MergeSort_14253(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_14254","instance":14254,"id":234269,"goal":"method ArrayCopy_14254(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_14255","instance":14255,"id":234270,"goal":"function ListReverse_14255(s: seq): seq\n ensures |ListReverse_14255(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_14255(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_14256","instance":14256,"id":234271,"goal":"function Factorial_14256(n: nat): nat\n ensures Factorial_14256(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_14256(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_14257","instance":14257,"id":234272,"goal":"function Fib_14257(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_14257(n-1) + Fib_14257(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_14258","instance":14258,"id":234273,"goal":"function Gcd_14258(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_14258(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_14259","instance":14259,"id":234274,"goal":"function Power_14259(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_14259(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_14260","instance":14260,"id":234275,"goal":"function Sum_14260(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_14260(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_14261","instance":14261,"id":234276,"goal":"method BinarySearch_14261(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_14262","instance":14262,"id":234277,"goal":"method InsertSort_14262(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_14263","instance":14263,"id":234278,"goal":"method MergeSort_14263(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_14264","instance":14264,"id":234279,"goal":"method ArrayCopy_14264(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_14265","instance":14265,"id":234280,"goal":"function ListReverse_14265(s: seq): seq\n ensures |ListReverse_14265(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_14265(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_14266","instance":14266,"id":234281,"goal":"function Factorial_14266(n: nat): nat\n ensures Factorial_14266(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_14266(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_14267","instance":14267,"id":234282,"goal":"function Fib_14267(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_14267(n-1) + Fib_14267(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_14268","instance":14268,"id":234283,"goal":"function Gcd_14268(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_14268(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_14269","instance":14269,"id":234284,"goal":"function Power_14269(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_14269(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_14270","instance":14270,"id":234285,"goal":"function Sum_14270(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_14270(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_14271","instance":14271,"id":234286,"goal":"method BinarySearch_14271(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_14272","instance":14272,"id":234287,"goal":"method InsertSort_14272(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_14273","instance":14273,"id":234288,"goal":"method MergeSort_14273(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_14274","instance":14274,"id":234289,"goal":"method ArrayCopy_14274(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_14275","instance":14275,"id":234290,"goal":"function ListReverse_14275(s: seq): seq\n ensures |ListReverse_14275(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_14275(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_14276","instance":14276,"id":234291,"goal":"function Factorial_14276(n: nat): nat\n ensures Factorial_14276(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_14276(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_14277","instance":14277,"id":234292,"goal":"function Fib_14277(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_14277(n-1) + Fib_14277(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_14278","instance":14278,"id":234293,"goal":"function Gcd_14278(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_14278(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_14279","instance":14279,"id":234294,"goal":"function Power_14279(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_14279(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_14280","instance":14280,"id":234295,"goal":"function Sum_14280(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_14280(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_14281","instance":14281,"id":234296,"goal":"method BinarySearch_14281(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_14282","instance":14282,"id":234297,"goal":"method InsertSort_14282(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_14283","instance":14283,"id":234298,"goal":"method MergeSort_14283(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_14284","instance":14284,"id":234299,"goal":"method ArrayCopy_14284(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_14285","instance":14285,"id":234300,"goal":"function ListReverse_14285(s: seq): seq\n ensures |ListReverse_14285(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_14285(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_14286","instance":14286,"id":234301,"goal":"function Factorial_14286(n: nat): nat\n ensures Factorial_14286(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_14286(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_14287","instance":14287,"id":234302,"goal":"function Fib_14287(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_14287(n-1) + Fib_14287(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_14288","instance":14288,"id":234303,"goal":"function Gcd_14288(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_14288(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_14289","instance":14289,"id":234304,"goal":"function Power_14289(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_14289(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_14290","instance":14290,"id":234305,"goal":"function Sum_14290(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_14290(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_14291","instance":14291,"id":234306,"goal":"method BinarySearch_14291(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_14292","instance":14292,"id":234307,"goal":"method InsertSort_14292(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_14293","instance":14293,"id":234308,"goal":"method MergeSort_14293(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_14294","instance":14294,"id":234309,"goal":"method ArrayCopy_14294(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_14295","instance":14295,"id":234310,"goal":"function ListReverse_14295(s: seq): seq\n ensures |ListReverse_14295(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_14295(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_14296","instance":14296,"id":234311,"goal":"function Factorial_14296(n: nat): nat\n ensures Factorial_14296(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_14296(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_14297","instance":14297,"id":234312,"goal":"function Fib_14297(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_14297(n-1) + Fib_14297(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_14298","instance":14298,"id":234313,"goal":"function Gcd_14298(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_14298(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_14299","instance":14299,"id":234314,"goal":"function Power_14299(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_14299(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_14300","instance":14300,"id":234315,"goal":"function Sum_14300(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_14300(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_14301","instance":14301,"id":234316,"goal":"method BinarySearch_14301(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_14302","instance":14302,"id":234317,"goal":"method InsertSort_14302(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_14303","instance":14303,"id":234318,"goal":"method MergeSort_14303(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_14304","instance":14304,"id":234319,"goal":"method ArrayCopy_14304(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_14305","instance":14305,"id":234320,"goal":"function ListReverse_14305(s: seq): seq\n ensures |ListReverse_14305(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_14305(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_14306","instance":14306,"id":234321,"goal":"function Factorial_14306(n: nat): nat\n ensures Factorial_14306(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_14306(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_14307","instance":14307,"id":234322,"goal":"function Fib_14307(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_14307(n-1) + Fib_14307(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_14308","instance":14308,"id":234323,"goal":"function Gcd_14308(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_14308(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_14309","instance":14309,"id":234324,"goal":"function Power_14309(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_14309(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_14310","instance":14310,"id":234325,"goal":"function Sum_14310(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_14310(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_14311","instance":14311,"id":234326,"goal":"method BinarySearch_14311(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_14312","instance":14312,"id":234327,"goal":"method InsertSort_14312(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_14313","instance":14313,"id":234328,"goal":"method MergeSort_14313(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_14314","instance":14314,"id":234329,"goal":"method ArrayCopy_14314(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_14315","instance":14315,"id":234330,"goal":"function ListReverse_14315(s: seq): seq\n ensures |ListReverse_14315(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_14315(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_14316","instance":14316,"id":234331,"goal":"function Factorial_14316(n: nat): nat\n ensures Factorial_14316(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_14316(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_14317","instance":14317,"id":234332,"goal":"function Fib_14317(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_14317(n-1) + Fib_14317(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_14318","instance":14318,"id":234333,"goal":"function Gcd_14318(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_14318(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_14319","instance":14319,"id":234334,"goal":"function Power_14319(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_14319(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_14320","instance":14320,"id":234335,"goal":"function Sum_14320(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_14320(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_14321","instance":14321,"id":234336,"goal":"method BinarySearch_14321(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_14322","instance":14322,"id":234337,"goal":"method InsertSort_14322(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_14323","instance":14323,"id":234338,"goal":"method MergeSort_14323(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_14324","instance":14324,"id":234339,"goal":"method ArrayCopy_14324(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_14325","instance":14325,"id":234340,"goal":"function ListReverse_14325(s: seq): seq\n ensures |ListReverse_14325(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_14325(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_14326","instance":14326,"id":234341,"goal":"function Factorial_14326(n: nat): nat\n ensures Factorial_14326(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_14326(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_14327","instance":14327,"id":234342,"goal":"function Fib_14327(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_14327(n-1) + Fib_14327(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_14328","instance":14328,"id":234343,"goal":"function Gcd_14328(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_14328(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_14329","instance":14329,"id":234344,"goal":"function Power_14329(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_14329(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_14330","instance":14330,"id":234345,"goal":"function Sum_14330(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_14330(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_14331","instance":14331,"id":234346,"goal":"method BinarySearch_14331(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_14332","instance":14332,"id":234347,"goal":"method InsertSort_14332(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_14333","instance":14333,"id":234348,"goal":"method MergeSort_14333(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_14334","instance":14334,"id":234349,"goal":"method ArrayCopy_14334(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_14335","instance":14335,"id":234350,"goal":"function ListReverse_14335(s: seq): seq\n ensures |ListReverse_14335(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_14335(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_14336","instance":14336,"id":234351,"goal":"function Factorial_14336(n: nat): nat\n ensures Factorial_14336(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_14336(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_14337","instance":14337,"id":234352,"goal":"function Fib_14337(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_14337(n-1) + Fib_14337(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_14338","instance":14338,"id":234353,"goal":"function Gcd_14338(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_14338(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_14339","instance":14339,"id":234354,"goal":"function Power_14339(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_14339(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_14340","instance":14340,"id":234355,"goal":"function Sum_14340(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_14340(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_14341","instance":14341,"id":234356,"goal":"method BinarySearch_14341(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_14342","instance":14342,"id":234357,"goal":"method InsertSort_14342(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_14343","instance":14343,"id":234358,"goal":"method MergeSort_14343(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_14344","instance":14344,"id":234359,"goal":"method ArrayCopy_14344(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_14345","instance":14345,"id":234360,"goal":"function ListReverse_14345(s: seq): seq\n ensures |ListReverse_14345(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_14345(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_14346","instance":14346,"id":234361,"goal":"function Factorial_14346(n: nat): nat\n ensures Factorial_14346(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_14346(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_14347","instance":14347,"id":234362,"goal":"function Fib_14347(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_14347(n-1) + Fib_14347(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_14348","instance":14348,"id":234363,"goal":"function Gcd_14348(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_14348(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_14349","instance":14349,"id":234364,"goal":"function Power_14349(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_14349(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_14350","instance":14350,"id":234365,"goal":"function Sum_14350(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_14350(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_14351","instance":14351,"id":234366,"goal":"method BinarySearch_14351(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_14352","instance":14352,"id":234367,"goal":"method InsertSort_14352(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_14353","instance":14353,"id":234368,"goal":"method MergeSort_14353(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_14354","instance":14354,"id":234369,"goal":"method ArrayCopy_14354(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_14355","instance":14355,"id":234370,"goal":"function ListReverse_14355(s: seq): seq\n ensures |ListReverse_14355(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_14355(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_14356","instance":14356,"id":234371,"goal":"function Factorial_14356(n: nat): nat\n ensures Factorial_14356(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_14356(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_14357","instance":14357,"id":234372,"goal":"function Fib_14357(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_14357(n-1) + Fib_14357(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_14358","instance":14358,"id":234373,"goal":"function Gcd_14358(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_14358(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_14359","instance":14359,"id":234374,"goal":"function Power_14359(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_14359(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_14360","instance":14360,"id":234375,"goal":"function Sum_14360(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_14360(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_14361","instance":14361,"id":234376,"goal":"method BinarySearch_14361(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_14362","instance":14362,"id":234377,"goal":"method InsertSort_14362(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_14363","instance":14363,"id":234378,"goal":"method MergeSort_14363(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_14364","instance":14364,"id":234379,"goal":"method ArrayCopy_14364(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_14365","instance":14365,"id":234380,"goal":"function ListReverse_14365(s: seq): seq\n ensures |ListReverse_14365(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_14365(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_14366","instance":14366,"id":234381,"goal":"function Factorial_14366(n: nat): nat\n ensures Factorial_14366(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_14366(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_14367","instance":14367,"id":234382,"goal":"function Fib_14367(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_14367(n-1) + Fib_14367(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_14368","instance":14368,"id":234383,"goal":"function Gcd_14368(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_14368(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_14369","instance":14369,"id":234384,"goal":"function Power_14369(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_14369(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_14370","instance":14370,"id":234385,"goal":"function Sum_14370(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_14370(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_14371","instance":14371,"id":234386,"goal":"method BinarySearch_14371(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_14372","instance":14372,"id":234387,"goal":"method InsertSort_14372(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_14373","instance":14373,"id":234388,"goal":"method MergeSort_14373(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_14374","instance":14374,"id":234389,"goal":"method ArrayCopy_14374(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_14375","instance":14375,"id":234390,"goal":"function ListReverse_14375(s: seq): seq\n ensures |ListReverse_14375(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_14375(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_14376","instance":14376,"id":234391,"goal":"function Factorial_14376(n: nat): nat\n ensures Factorial_14376(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_14376(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_14377","instance":14377,"id":234392,"goal":"function Fib_14377(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_14377(n-1) + Fib_14377(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_14378","instance":14378,"id":234393,"goal":"function Gcd_14378(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_14378(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_14379","instance":14379,"id":234394,"goal":"function Power_14379(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_14379(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_14380","instance":14380,"id":234395,"goal":"function Sum_14380(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_14380(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_14381","instance":14381,"id":234396,"goal":"method BinarySearch_14381(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_14382","instance":14382,"id":234397,"goal":"method InsertSort_14382(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_14383","instance":14383,"id":234398,"goal":"method MergeSort_14383(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_14384","instance":14384,"id":234399,"goal":"method ArrayCopy_14384(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_14385","instance":14385,"id":234400,"goal":"function ListReverse_14385(s: seq): seq\n ensures |ListReverse_14385(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_14385(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_14386","instance":14386,"id":234401,"goal":"function Factorial_14386(n: nat): nat\n ensures Factorial_14386(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_14386(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_14387","instance":14387,"id":234402,"goal":"function Fib_14387(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_14387(n-1) + Fib_14387(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_14388","instance":14388,"id":234403,"goal":"function Gcd_14388(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_14388(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_14389","instance":14389,"id":234404,"goal":"function Power_14389(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_14389(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_14390","instance":14390,"id":234405,"goal":"function Sum_14390(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_14390(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_14391","instance":14391,"id":234406,"goal":"method BinarySearch_14391(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_14392","instance":14392,"id":234407,"goal":"method InsertSort_14392(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_14393","instance":14393,"id":234408,"goal":"method MergeSort_14393(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_14394","instance":14394,"id":234409,"goal":"method ArrayCopy_14394(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_14395","instance":14395,"id":234410,"goal":"function ListReverse_14395(s: seq): seq\n ensures |ListReverse_14395(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_14395(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_14396","instance":14396,"id":234411,"goal":"function Factorial_14396(n: nat): nat\n ensures Factorial_14396(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_14396(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_14397","instance":14397,"id":234412,"goal":"function Fib_14397(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_14397(n-1) + Fib_14397(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_14398","instance":14398,"id":234413,"goal":"function Gcd_14398(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_14398(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_14399","instance":14399,"id":234414,"goal":"function Power_14399(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_14399(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_14400","instance":14400,"id":234415,"goal":"function Sum_14400(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_14400(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_14401","instance":14401,"id":234416,"goal":"method BinarySearch_14401(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_14402","instance":14402,"id":234417,"goal":"method InsertSort_14402(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_14403","instance":14403,"id":234418,"goal":"method MergeSort_14403(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_14404","instance":14404,"id":234419,"goal":"method ArrayCopy_14404(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_14405","instance":14405,"id":234420,"goal":"function ListReverse_14405(s: seq): seq\n ensures |ListReverse_14405(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_14405(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_14406","instance":14406,"id":234421,"goal":"function Factorial_14406(n: nat): nat\n ensures Factorial_14406(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_14406(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_14407","instance":14407,"id":234422,"goal":"function Fib_14407(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_14407(n-1) + Fib_14407(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_14408","instance":14408,"id":234423,"goal":"function Gcd_14408(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_14408(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_14409","instance":14409,"id":234424,"goal":"function Power_14409(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_14409(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_14410","instance":14410,"id":234425,"goal":"function Sum_14410(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_14410(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_14411","instance":14411,"id":234426,"goal":"method BinarySearch_14411(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_14412","instance":14412,"id":234427,"goal":"method InsertSort_14412(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_14413","instance":14413,"id":234428,"goal":"method MergeSort_14413(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_14414","instance":14414,"id":234429,"goal":"method ArrayCopy_14414(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_14415","instance":14415,"id":234430,"goal":"function ListReverse_14415(s: seq): seq\n ensures |ListReverse_14415(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_14415(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_14416","instance":14416,"id":234431,"goal":"function Factorial_14416(n: nat): nat\n ensures Factorial_14416(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_14416(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_14417","instance":14417,"id":234432,"goal":"function Fib_14417(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_14417(n-1) + Fib_14417(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_14418","instance":14418,"id":234433,"goal":"function Gcd_14418(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_14418(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_14419","instance":14419,"id":234434,"goal":"function Power_14419(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_14419(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_14420","instance":14420,"id":234435,"goal":"function Sum_14420(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_14420(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_14421","instance":14421,"id":234436,"goal":"method BinarySearch_14421(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_14422","instance":14422,"id":234437,"goal":"method InsertSort_14422(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_14423","instance":14423,"id":234438,"goal":"method MergeSort_14423(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_14424","instance":14424,"id":234439,"goal":"method ArrayCopy_14424(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_14425","instance":14425,"id":234440,"goal":"function ListReverse_14425(s: seq): seq\n ensures |ListReverse_14425(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_14425(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_14426","instance":14426,"id":234441,"goal":"function Factorial_14426(n: nat): nat\n ensures Factorial_14426(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_14426(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_14427","instance":14427,"id":234442,"goal":"function Fib_14427(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_14427(n-1) + Fib_14427(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_14428","instance":14428,"id":234443,"goal":"function Gcd_14428(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_14428(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_14429","instance":14429,"id":234444,"goal":"function Power_14429(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_14429(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_14430","instance":14430,"id":234445,"goal":"function Sum_14430(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_14430(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_14431","instance":14431,"id":234446,"goal":"method BinarySearch_14431(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_14432","instance":14432,"id":234447,"goal":"method InsertSort_14432(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_14433","instance":14433,"id":234448,"goal":"method MergeSort_14433(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_14434","instance":14434,"id":234449,"goal":"method ArrayCopy_14434(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_14435","instance":14435,"id":234450,"goal":"function ListReverse_14435(s: seq): seq\n ensures |ListReverse_14435(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_14435(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_14436","instance":14436,"id":234451,"goal":"function Factorial_14436(n: nat): nat\n ensures Factorial_14436(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_14436(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_14437","instance":14437,"id":234452,"goal":"function Fib_14437(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_14437(n-1) + Fib_14437(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_14438","instance":14438,"id":234453,"goal":"function Gcd_14438(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_14438(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_14439","instance":14439,"id":234454,"goal":"function Power_14439(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_14439(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_14440","instance":14440,"id":234455,"goal":"function Sum_14440(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_14440(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_14441","instance":14441,"id":234456,"goal":"method BinarySearch_14441(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_14442","instance":14442,"id":234457,"goal":"method InsertSort_14442(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_14443","instance":14443,"id":234458,"goal":"method MergeSort_14443(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_14444","instance":14444,"id":234459,"goal":"method ArrayCopy_14444(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_14445","instance":14445,"id":234460,"goal":"function ListReverse_14445(s: seq): seq\n ensures |ListReverse_14445(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_14445(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_14446","instance":14446,"id":234461,"goal":"function Factorial_14446(n: nat): nat\n ensures Factorial_14446(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_14446(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_14447","instance":14447,"id":234462,"goal":"function Fib_14447(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_14447(n-1) + Fib_14447(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_14448","instance":14448,"id":234463,"goal":"function Gcd_14448(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_14448(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_14449","instance":14449,"id":234464,"goal":"function Power_14449(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_14449(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_14450","instance":14450,"id":234465,"goal":"function Sum_14450(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_14450(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_14451","instance":14451,"id":234466,"goal":"method BinarySearch_14451(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_14452","instance":14452,"id":234467,"goal":"method InsertSort_14452(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_14453","instance":14453,"id":234468,"goal":"method MergeSort_14453(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_14454","instance":14454,"id":234469,"goal":"method ArrayCopy_14454(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_14455","instance":14455,"id":234470,"goal":"function ListReverse_14455(s: seq): seq\n ensures |ListReverse_14455(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_14455(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_14456","instance":14456,"id":234471,"goal":"function Factorial_14456(n: nat): nat\n ensures Factorial_14456(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_14456(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_14457","instance":14457,"id":234472,"goal":"function Fib_14457(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_14457(n-1) + Fib_14457(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_14458","instance":14458,"id":234473,"goal":"function Gcd_14458(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_14458(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_14459","instance":14459,"id":234474,"goal":"function Power_14459(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_14459(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_14460","instance":14460,"id":234475,"goal":"function Sum_14460(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_14460(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_14461","instance":14461,"id":234476,"goal":"method BinarySearch_14461(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_14462","instance":14462,"id":234477,"goal":"method InsertSort_14462(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_14463","instance":14463,"id":234478,"goal":"method MergeSort_14463(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_14464","instance":14464,"id":234479,"goal":"method ArrayCopy_14464(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_14465","instance":14465,"id":234480,"goal":"function ListReverse_14465(s: seq): seq\n ensures |ListReverse_14465(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_14465(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_14466","instance":14466,"id":234481,"goal":"function Factorial_14466(n: nat): nat\n ensures Factorial_14466(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_14466(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_14467","instance":14467,"id":234482,"goal":"function Fib_14467(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_14467(n-1) + Fib_14467(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_14468","instance":14468,"id":234483,"goal":"function Gcd_14468(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_14468(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_14469","instance":14469,"id":234484,"goal":"function Power_14469(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_14469(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_14470","instance":14470,"id":234485,"goal":"function Sum_14470(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_14470(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_14471","instance":14471,"id":234486,"goal":"method BinarySearch_14471(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_14472","instance":14472,"id":234487,"goal":"method InsertSort_14472(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_14473","instance":14473,"id":234488,"goal":"method MergeSort_14473(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_14474","instance":14474,"id":234489,"goal":"method ArrayCopy_14474(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_14475","instance":14475,"id":234490,"goal":"function ListReverse_14475(s: seq): seq\n ensures |ListReverse_14475(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_14475(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_14476","instance":14476,"id":234491,"goal":"function Factorial_14476(n: nat): nat\n ensures Factorial_14476(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_14476(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_14477","instance":14477,"id":234492,"goal":"function Fib_14477(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_14477(n-1) + Fib_14477(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_14478","instance":14478,"id":234493,"goal":"function Gcd_14478(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_14478(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_14479","instance":14479,"id":234494,"goal":"function Power_14479(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_14479(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_14480","instance":14480,"id":234495,"goal":"function Sum_14480(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_14480(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_14481","instance":14481,"id":234496,"goal":"method BinarySearch_14481(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_14482","instance":14482,"id":234497,"goal":"method InsertSort_14482(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_14483","instance":14483,"id":234498,"goal":"method MergeSort_14483(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_14484","instance":14484,"id":234499,"goal":"method ArrayCopy_14484(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_14485","instance":14485,"id":234500,"goal":"function ListReverse_14485(s: seq): seq\n ensures |ListReverse_14485(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_14485(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_14486","instance":14486,"id":234501,"goal":"function Factorial_14486(n: nat): nat\n ensures Factorial_14486(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_14486(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_14487","instance":14487,"id":234502,"goal":"function Fib_14487(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_14487(n-1) + Fib_14487(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_14488","instance":14488,"id":234503,"goal":"function Gcd_14488(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_14488(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_14489","instance":14489,"id":234504,"goal":"function Power_14489(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_14489(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_14490","instance":14490,"id":234505,"goal":"function Sum_14490(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_14490(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_14491","instance":14491,"id":234506,"goal":"method BinarySearch_14491(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_14492","instance":14492,"id":234507,"goal":"method InsertSort_14492(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_14493","instance":14493,"id":234508,"goal":"method MergeSort_14493(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_14494","instance":14494,"id":234509,"goal":"method ArrayCopy_14494(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_14495","instance":14495,"id":234510,"goal":"function ListReverse_14495(s: seq): seq\n ensures |ListReverse_14495(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_14495(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_14496","instance":14496,"id":234511,"goal":"function Factorial_14496(n: nat): nat\n ensures Factorial_14496(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_14496(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_14497","instance":14497,"id":234512,"goal":"function Fib_14497(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_14497(n-1) + Fib_14497(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_14498","instance":14498,"id":234513,"goal":"function Gcd_14498(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_14498(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_14499","instance":14499,"id":234514,"goal":"function Power_14499(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_14499(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_14500","instance":14500,"id":234515,"goal":"function Sum_14500(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_14500(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_14501","instance":14501,"id":234516,"goal":"method BinarySearch_14501(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_14502","instance":14502,"id":234517,"goal":"method InsertSort_14502(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_14503","instance":14503,"id":234518,"goal":"method MergeSort_14503(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_14504","instance":14504,"id":234519,"goal":"method ArrayCopy_14504(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_14505","instance":14505,"id":234520,"goal":"function ListReverse_14505(s: seq): seq\n ensures |ListReverse_14505(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_14505(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_14506","instance":14506,"id":234521,"goal":"function Factorial_14506(n: nat): nat\n ensures Factorial_14506(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_14506(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_14507","instance":14507,"id":234522,"goal":"function Fib_14507(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_14507(n-1) + Fib_14507(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_14508","instance":14508,"id":234523,"goal":"function Gcd_14508(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_14508(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_14509","instance":14509,"id":234524,"goal":"function Power_14509(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_14509(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_14510","instance":14510,"id":234525,"goal":"function Sum_14510(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_14510(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_14511","instance":14511,"id":234526,"goal":"method BinarySearch_14511(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_14512","instance":14512,"id":234527,"goal":"method InsertSort_14512(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_14513","instance":14513,"id":234528,"goal":"method MergeSort_14513(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_14514","instance":14514,"id":234529,"goal":"method ArrayCopy_14514(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_14515","instance":14515,"id":234530,"goal":"function ListReverse_14515(s: seq): seq\n ensures |ListReverse_14515(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_14515(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_14516","instance":14516,"id":234531,"goal":"function Factorial_14516(n: nat): nat\n ensures Factorial_14516(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_14516(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_14517","instance":14517,"id":234532,"goal":"function Fib_14517(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_14517(n-1) + Fib_14517(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_14518","instance":14518,"id":234533,"goal":"function Gcd_14518(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_14518(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_14519","instance":14519,"id":234534,"goal":"function Power_14519(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_14519(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_14520","instance":14520,"id":234535,"goal":"function Sum_14520(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_14520(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_14521","instance":14521,"id":234536,"goal":"method BinarySearch_14521(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_14522","instance":14522,"id":234537,"goal":"method InsertSort_14522(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_14523","instance":14523,"id":234538,"goal":"method MergeSort_14523(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_14524","instance":14524,"id":234539,"goal":"method ArrayCopy_14524(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_14525","instance":14525,"id":234540,"goal":"function ListReverse_14525(s: seq): seq\n ensures |ListReverse_14525(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_14525(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_14526","instance":14526,"id":234541,"goal":"function Factorial_14526(n: nat): nat\n ensures Factorial_14526(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_14526(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_14527","instance":14527,"id":234542,"goal":"function Fib_14527(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_14527(n-1) + Fib_14527(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_14528","instance":14528,"id":234543,"goal":"function Gcd_14528(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_14528(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_14529","instance":14529,"id":234544,"goal":"function Power_14529(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_14529(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_14530","instance":14530,"id":234545,"goal":"function Sum_14530(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_14530(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_14531","instance":14531,"id":234546,"goal":"method BinarySearch_14531(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_14532","instance":14532,"id":234547,"goal":"method InsertSort_14532(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_14533","instance":14533,"id":234548,"goal":"method MergeSort_14533(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_14534","instance":14534,"id":234549,"goal":"method ArrayCopy_14534(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_14535","instance":14535,"id":234550,"goal":"function ListReverse_14535(s: seq): seq\n ensures |ListReverse_14535(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_14535(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_14536","instance":14536,"id":234551,"goal":"function Factorial_14536(n: nat): nat\n ensures Factorial_14536(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_14536(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_14537","instance":14537,"id":234552,"goal":"function Fib_14537(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_14537(n-1) + Fib_14537(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_14538","instance":14538,"id":234553,"goal":"function Gcd_14538(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_14538(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_14539","instance":14539,"id":234554,"goal":"function Power_14539(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_14539(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_14540","instance":14540,"id":234555,"goal":"function Sum_14540(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_14540(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_14541","instance":14541,"id":234556,"goal":"method BinarySearch_14541(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_14542","instance":14542,"id":234557,"goal":"method InsertSort_14542(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_14543","instance":14543,"id":234558,"goal":"method MergeSort_14543(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_14544","instance":14544,"id":234559,"goal":"method ArrayCopy_14544(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_14545","instance":14545,"id":234560,"goal":"function ListReverse_14545(s: seq): seq\n ensures |ListReverse_14545(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_14545(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_14546","instance":14546,"id":234561,"goal":"function Factorial_14546(n: nat): nat\n ensures Factorial_14546(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_14546(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_14547","instance":14547,"id":234562,"goal":"function Fib_14547(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_14547(n-1) + Fib_14547(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_14548","instance":14548,"id":234563,"goal":"function Gcd_14548(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_14548(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_14549","instance":14549,"id":234564,"goal":"function Power_14549(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_14549(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_14550","instance":14550,"id":234565,"goal":"function Sum_14550(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_14550(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_14551","instance":14551,"id":234566,"goal":"method BinarySearch_14551(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_14552","instance":14552,"id":234567,"goal":"method InsertSort_14552(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_14553","instance":14553,"id":234568,"goal":"method MergeSort_14553(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_14554","instance":14554,"id":234569,"goal":"method ArrayCopy_14554(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_14555","instance":14555,"id":234570,"goal":"function ListReverse_14555(s: seq): seq\n ensures |ListReverse_14555(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_14555(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_14556","instance":14556,"id":234571,"goal":"function Factorial_14556(n: nat): nat\n ensures Factorial_14556(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_14556(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_14557","instance":14557,"id":234572,"goal":"function Fib_14557(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_14557(n-1) + Fib_14557(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_14558","instance":14558,"id":234573,"goal":"function Gcd_14558(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_14558(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_14559","instance":14559,"id":234574,"goal":"function Power_14559(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_14559(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_14560","instance":14560,"id":234575,"goal":"function Sum_14560(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_14560(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_14561","instance":14561,"id":234576,"goal":"method BinarySearch_14561(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_14562","instance":14562,"id":234577,"goal":"method InsertSort_14562(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_14563","instance":14563,"id":234578,"goal":"method MergeSort_14563(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_14564","instance":14564,"id":234579,"goal":"method ArrayCopy_14564(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_14565","instance":14565,"id":234580,"goal":"function ListReverse_14565(s: seq): seq\n ensures |ListReverse_14565(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_14565(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_14566","instance":14566,"id":234581,"goal":"function Factorial_14566(n: nat): nat\n ensures Factorial_14566(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_14566(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_14567","instance":14567,"id":234582,"goal":"function Fib_14567(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_14567(n-1) + Fib_14567(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_14568","instance":14568,"id":234583,"goal":"function Gcd_14568(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_14568(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_14569","instance":14569,"id":234584,"goal":"function Power_14569(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_14569(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_14570","instance":14570,"id":234585,"goal":"function Sum_14570(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_14570(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_14571","instance":14571,"id":234586,"goal":"method BinarySearch_14571(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_14572","instance":14572,"id":234587,"goal":"method InsertSort_14572(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_14573","instance":14573,"id":234588,"goal":"method MergeSort_14573(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_14574","instance":14574,"id":234589,"goal":"method ArrayCopy_14574(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_14575","instance":14575,"id":234590,"goal":"function ListReverse_14575(s: seq): seq\n ensures |ListReverse_14575(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_14575(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_14576","instance":14576,"id":234591,"goal":"function Factorial_14576(n: nat): nat\n ensures Factorial_14576(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_14576(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_14577","instance":14577,"id":234592,"goal":"function Fib_14577(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_14577(n-1) + Fib_14577(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_14578","instance":14578,"id":234593,"goal":"function Gcd_14578(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_14578(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_14579","instance":14579,"id":234594,"goal":"function Power_14579(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_14579(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_14580","instance":14580,"id":234595,"goal":"function Sum_14580(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_14580(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_14581","instance":14581,"id":234596,"goal":"method BinarySearch_14581(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_14582","instance":14582,"id":234597,"goal":"method InsertSort_14582(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_14583","instance":14583,"id":234598,"goal":"method MergeSort_14583(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_14584","instance":14584,"id":234599,"goal":"method ArrayCopy_14584(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_14585","instance":14585,"id":234600,"goal":"function ListReverse_14585(s: seq): seq\n ensures |ListReverse_14585(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_14585(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_14586","instance":14586,"id":234601,"goal":"function Factorial_14586(n: nat): nat\n ensures Factorial_14586(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_14586(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_14587","instance":14587,"id":234602,"goal":"function Fib_14587(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_14587(n-1) + Fib_14587(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_14588","instance":14588,"id":234603,"goal":"function Gcd_14588(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_14588(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_14589","instance":14589,"id":234604,"goal":"function Power_14589(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_14589(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_14590","instance":14590,"id":234605,"goal":"function Sum_14590(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_14590(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_14591","instance":14591,"id":234606,"goal":"method BinarySearch_14591(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_14592","instance":14592,"id":234607,"goal":"method InsertSort_14592(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_14593","instance":14593,"id":234608,"goal":"method MergeSort_14593(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_14594","instance":14594,"id":234609,"goal":"method ArrayCopy_14594(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_14595","instance":14595,"id":234610,"goal":"function ListReverse_14595(s: seq): seq\n ensures |ListReverse_14595(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_14595(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_14596","instance":14596,"id":234611,"goal":"function Factorial_14596(n: nat): nat\n ensures Factorial_14596(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_14596(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_14597","instance":14597,"id":234612,"goal":"function Fib_14597(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_14597(n-1) + Fib_14597(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_14598","instance":14598,"id":234613,"goal":"function Gcd_14598(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_14598(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_14599","instance":14599,"id":234614,"goal":"function Power_14599(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_14599(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_14600","instance":14600,"id":234615,"goal":"function Sum_14600(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_14600(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_14601","instance":14601,"id":234616,"goal":"method BinarySearch_14601(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_14602","instance":14602,"id":234617,"goal":"method InsertSort_14602(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_14603","instance":14603,"id":234618,"goal":"method MergeSort_14603(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_14604","instance":14604,"id":234619,"goal":"method ArrayCopy_14604(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_14605","instance":14605,"id":234620,"goal":"function ListReverse_14605(s: seq): seq\n ensures |ListReverse_14605(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_14605(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_14606","instance":14606,"id":234621,"goal":"function Factorial_14606(n: nat): nat\n ensures Factorial_14606(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_14606(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_14607","instance":14607,"id":234622,"goal":"function Fib_14607(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_14607(n-1) + Fib_14607(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_14608","instance":14608,"id":234623,"goal":"function Gcd_14608(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_14608(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_14609","instance":14609,"id":234624,"goal":"function Power_14609(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_14609(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_14610","instance":14610,"id":234625,"goal":"function Sum_14610(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_14610(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_14611","instance":14611,"id":234626,"goal":"method BinarySearch_14611(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_14612","instance":14612,"id":234627,"goal":"method InsertSort_14612(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_14613","instance":14613,"id":234628,"goal":"method MergeSort_14613(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_14614","instance":14614,"id":234629,"goal":"method ArrayCopy_14614(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_14615","instance":14615,"id":234630,"goal":"function ListReverse_14615(s: seq): seq\n ensures |ListReverse_14615(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_14615(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_14616","instance":14616,"id":234631,"goal":"function Factorial_14616(n: nat): nat\n ensures Factorial_14616(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_14616(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_14617","instance":14617,"id":234632,"goal":"function Fib_14617(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_14617(n-1) + Fib_14617(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_14618","instance":14618,"id":234633,"goal":"function Gcd_14618(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_14618(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_14619","instance":14619,"id":234634,"goal":"function Power_14619(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_14619(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_14620","instance":14620,"id":234635,"goal":"function Sum_14620(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_14620(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_14621","instance":14621,"id":234636,"goal":"method BinarySearch_14621(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_14622","instance":14622,"id":234637,"goal":"method InsertSort_14622(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_14623","instance":14623,"id":234638,"goal":"method MergeSort_14623(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_14624","instance":14624,"id":234639,"goal":"method ArrayCopy_14624(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_14625","instance":14625,"id":234640,"goal":"function ListReverse_14625(s: seq): seq\n ensures |ListReverse_14625(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_14625(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_14626","instance":14626,"id":234641,"goal":"function Factorial_14626(n: nat): nat\n ensures Factorial_14626(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_14626(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_14627","instance":14627,"id":234642,"goal":"function Fib_14627(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_14627(n-1) + Fib_14627(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_14628","instance":14628,"id":234643,"goal":"function Gcd_14628(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_14628(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_14629","instance":14629,"id":234644,"goal":"function Power_14629(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_14629(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_14630","instance":14630,"id":234645,"goal":"function Sum_14630(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_14630(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_14631","instance":14631,"id":234646,"goal":"method BinarySearch_14631(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_14632","instance":14632,"id":234647,"goal":"method InsertSort_14632(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_14633","instance":14633,"id":234648,"goal":"method MergeSort_14633(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_14634","instance":14634,"id":234649,"goal":"method ArrayCopy_14634(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_14635","instance":14635,"id":234650,"goal":"function ListReverse_14635(s: seq): seq\n ensures |ListReverse_14635(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_14635(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_14636","instance":14636,"id":234651,"goal":"function Factorial_14636(n: nat): nat\n ensures Factorial_14636(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_14636(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_14637","instance":14637,"id":234652,"goal":"function Fib_14637(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_14637(n-1) + Fib_14637(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_14638","instance":14638,"id":234653,"goal":"function Gcd_14638(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_14638(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_14639","instance":14639,"id":234654,"goal":"function Power_14639(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_14639(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_14640","instance":14640,"id":234655,"goal":"function Sum_14640(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_14640(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_14641","instance":14641,"id":234656,"goal":"method BinarySearch_14641(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_14642","instance":14642,"id":234657,"goal":"method InsertSort_14642(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_14643","instance":14643,"id":234658,"goal":"method MergeSort_14643(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_14644","instance":14644,"id":234659,"goal":"method ArrayCopy_14644(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_14645","instance":14645,"id":234660,"goal":"function ListReverse_14645(s: seq): seq\n ensures |ListReverse_14645(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_14645(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_14646","instance":14646,"id":234661,"goal":"function Factorial_14646(n: nat): nat\n ensures Factorial_14646(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_14646(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_14647","instance":14647,"id":234662,"goal":"function Fib_14647(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_14647(n-1) + Fib_14647(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_14648","instance":14648,"id":234663,"goal":"function Gcd_14648(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_14648(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_14649","instance":14649,"id":234664,"goal":"function Power_14649(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_14649(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_14650","instance":14650,"id":234665,"goal":"function Sum_14650(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_14650(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_14651","instance":14651,"id":234666,"goal":"method BinarySearch_14651(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_14652","instance":14652,"id":234667,"goal":"method InsertSort_14652(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_14653","instance":14653,"id":234668,"goal":"method MergeSort_14653(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_14654","instance":14654,"id":234669,"goal":"method ArrayCopy_14654(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_14655","instance":14655,"id":234670,"goal":"function ListReverse_14655(s: seq): seq\n ensures |ListReverse_14655(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_14655(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_14656","instance":14656,"id":234671,"goal":"function Factorial_14656(n: nat): nat\n ensures Factorial_14656(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_14656(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_14657","instance":14657,"id":234672,"goal":"function Fib_14657(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_14657(n-1) + Fib_14657(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_14658","instance":14658,"id":234673,"goal":"function Gcd_14658(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_14658(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_14659","instance":14659,"id":234674,"goal":"function Power_14659(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_14659(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_14660","instance":14660,"id":234675,"goal":"function Sum_14660(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_14660(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_14661","instance":14661,"id":234676,"goal":"method BinarySearch_14661(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_14662","instance":14662,"id":234677,"goal":"method InsertSort_14662(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_14663","instance":14663,"id":234678,"goal":"method MergeSort_14663(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_14664","instance":14664,"id":234679,"goal":"method ArrayCopy_14664(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_14665","instance":14665,"id":234680,"goal":"function ListReverse_14665(s: seq): seq\n ensures |ListReverse_14665(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_14665(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_14666","instance":14666,"id":234681,"goal":"function Factorial_14666(n: nat): nat\n ensures Factorial_14666(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_14666(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_14667","instance":14667,"id":234682,"goal":"function Fib_14667(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_14667(n-1) + Fib_14667(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_14668","instance":14668,"id":234683,"goal":"function Gcd_14668(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_14668(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_14669","instance":14669,"id":234684,"goal":"function Power_14669(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_14669(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_14670","instance":14670,"id":234685,"goal":"function Sum_14670(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_14670(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_14671","instance":14671,"id":234686,"goal":"method BinarySearch_14671(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_14672","instance":14672,"id":234687,"goal":"method InsertSort_14672(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_14673","instance":14673,"id":234688,"goal":"method MergeSort_14673(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_14674","instance":14674,"id":234689,"goal":"method ArrayCopy_14674(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_14675","instance":14675,"id":234690,"goal":"function ListReverse_14675(s: seq): seq\n ensures |ListReverse_14675(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_14675(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_14676","instance":14676,"id":234691,"goal":"function Factorial_14676(n: nat): nat\n ensures Factorial_14676(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_14676(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_14677","instance":14677,"id":234692,"goal":"function Fib_14677(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_14677(n-1) + Fib_14677(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_14678","instance":14678,"id":234693,"goal":"function Gcd_14678(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_14678(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_14679","instance":14679,"id":234694,"goal":"function Power_14679(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_14679(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_14680","instance":14680,"id":234695,"goal":"function Sum_14680(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_14680(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_14681","instance":14681,"id":234696,"goal":"method BinarySearch_14681(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_14682","instance":14682,"id":234697,"goal":"method InsertSort_14682(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_14683","instance":14683,"id":234698,"goal":"method MergeSort_14683(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_14684","instance":14684,"id":234699,"goal":"method ArrayCopy_14684(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_14685","instance":14685,"id":234700,"goal":"function ListReverse_14685(s: seq): seq\n ensures |ListReverse_14685(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_14685(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_14686","instance":14686,"id":234701,"goal":"function Factorial_14686(n: nat): nat\n ensures Factorial_14686(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_14686(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_14687","instance":14687,"id":234702,"goal":"function Fib_14687(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_14687(n-1) + Fib_14687(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_14688","instance":14688,"id":234703,"goal":"function Gcd_14688(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_14688(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_14689","instance":14689,"id":234704,"goal":"function Power_14689(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_14689(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_14690","instance":14690,"id":234705,"goal":"function Sum_14690(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_14690(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_14691","instance":14691,"id":234706,"goal":"method BinarySearch_14691(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_14692","instance":14692,"id":234707,"goal":"method InsertSort_14692(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_14693","instance":14693,"id":234708,"goal":"method MergeSort_14693(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_14694","instance":14694,"id":234709,"goal":"method ArrayCopy_14694(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_14695","instance":14695,"id":234710,"goal":"function ListReverse_14695(s: seq): seq\n ensures |ListReverse_14695(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_14695(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_14696","instance":14696,"id":234711,"goal":"function Factorial_14696(n: nat): nat\n ensures Factorial_14696(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_14696(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_14697","instance":14697,"id":234712,"goal":"function Fib_14697(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_14697(n-1) + Fib_14697(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_14698","instance":14698,"id":234713,"goal":"function Gcd_14698(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_14698(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_14699","instance":14699,"id":234714,"goal":"function Power_14699(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_14699(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_14700","instance":14700,"id":234715,"goal":"function Sum_14700(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_14700(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_14701","instance":14701,"id":234716,"goal":"method BinarySearch_14701(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_14702","instance":14702,"id":234717,"goal":"method InsertSort_14702(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_14703","instance":14703,"id":234718,"goal":"method MergeSort_14703(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_14704","instance":14704,"id":234719,"goal":"method ArrayCopy_14704(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_14705","instance":14705,"id":234720,"goal":"function ListReverse_14705(s: seq): seq\n ensures |ListReverse_14705(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_14705(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_14706","instance":14706,"id":234721,"goal":"function Factorial_14706(n: nat): nat\n ensures Factorial_14706(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_14706(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_14707","instance":14707,"id":234722,"goal":"function Fib_14707(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_14707(n-1) + Fib_14707(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_14708","instance":14708,"id":234723,"goal":"function Gcd_14708(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_14708(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_14709","instance":14709,"id":234724,"goal":"function Power_14709(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_14709(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_14710","instance":14710,"id":234725,"goal":"function Sum_14710(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_14710(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_14711","instance":14711,"id":234726,"goal":"method BinarySearch_14711(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_14712","instance":14712,"id":234727,"goal":"method InsertSort_14712(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_14713","instance":14713,"id":234728,"goal":"method MergeSort_14713(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_14714","instance":14714,"id":234729,"goal":"method ArrayCopy_14714(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_14715","instance":14715,"id":234730,"goal":"function ListReverse_14715(s: seq): seq\n ensures |ListReverse_14715(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_14715(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_14716","instance":14716,"id":234731,"goal":"function Factorial_14716(n: nat): nat\n ensures Factorial_14716(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_14716(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_14717","instance":14717,"id":234732,"goal":"function Fib_14717(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_14717(n-1) + Fib_14717(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_14718","instance":14718,"id":234733,"goal":"function Gcd_14718(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_14718(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_14719","instance":14719,"id":234734,"goal":"function Power_14719(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_14719(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_14720","instance":14720,"id":234735,"goal":"function Sum_14720(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_14720(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_14721","instance":14721,"id":234736,"goal":"method BinarySearch_14721(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_14722","instance":14722,"id":234737,"goal":"method InsertSort_14722(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_14723","instance":14723,"id":234738,"goal":"method MergeSort_14723(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_14724","instance":14724,"id":234739,"goal":"method ArrayCopy_14724(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_14725","instance":14725,"id":234740,"goal":"function ListReverse_14725(s: seq): seq\n ensures |ListReverse_14725(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_14725(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_14726","instance":14726,"id":234741,"goal":"function Factorial_14726(n: nat): nat\n ensures Factorial_14726(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_14726(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_14727","instance":14727,"id":234742,"goal":"function Fib_14727(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_14727(n-1) + Fib_14727(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_14728","instance":14728,"id":234743,"goal":"function Gcd_14728(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_14728(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_14729","instance":14729,"id":234744,"goal":"function Power_14729(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_14729(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_14730","instance":14730,"id":234745,"goal":"function Sum_14730(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_14730(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_14731","instance":14731,"id":234746,"goal":"method BinarySearch_14731(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_14732","instance":14732,"id":234747,"goal":"method InsertSort_14732(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_14733","instance":14733,"id":234748,"goal":"method MergeSort_14733(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_14734","instance":14734,"id":234749,"goal":"method ArrayCopy_14734(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_14735","instance":14735,"id":234750,"goal":"function ListReverse_14735(s: seq): seq\n ensures |ListReverse_14735(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_14735(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_14736","instance":14736,"id":234751,"goal":"function Factorial_14736(n: nat): nat\n ensures Factorial_14736(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_14736(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_14737","instance":14737,"id":234752,"goal":"function Fib_14737(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_14737(n-1) + Fib_14737(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_14738","instance":14738,"id":234753,"goal":"function Gcd_14738(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_14738(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_14739","instance":14739,"id":234754,"goal":"function Power_14739(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_14739(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_14740","instance":14740,"id":234755,"goal":"function Sum_14740(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_14740(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_14741","instance":14741,"id":234756,"goal":"method BinarySearch_14741(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_14742","instance":14742,"id":234757,"goal":"method InsertSort_14742(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_14743","instance":14743,"id":234758,"goal":"method MergeSort_14743(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_14744","instance":14744,"id":234759,"goal":"method ArrayCopy_14744(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_14745","instance":14745,"id":234760,"goal":"function ListReverse_14745(s: seq): seq\n ensures |ListReverse_14745(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_14745(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_14746","instance":14746,"id":234761,"goal":"function Factorial_14746(n: nat): nat\n ensures Factorial_14746(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_14746(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_14747","instance":14747,"id":234762,"goal":"function Fib_14747(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_14747(n-1) + Fib_14747(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_14748","instance":14748,"id":234763,"goal":"function Gcd_14748(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_14748(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_14749","instance":14749,"id":234764,"goal":"function Power_14749(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_14749(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_14750","instance":14750,"id":234765,"goal":"function Sum_14750(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_14750(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_14751","instance":14751,"id":234766,"goal":"method BinarySearch_14751(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_14752","instance":14752,"id":234767,"goal":"method InsertSort_14752(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_14753","instance":14753,"id":234768,"goal":"method MergeSort_14753(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_14754","instance":14754,"id":234769,"goal":"method ArrayCopy_14754(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_14755","instance":14755,"id":234770,"goal":"function ListReverse_14755(s: seq): seq\n ensures |ListReverse_14755(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_14755(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_14756","instance":14756,"id":234771,"goal":"function Factorial_14756(n: nat): nat\n ensures Factorial_14756(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_14756(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_14757","instance":14757,"id":234772,"goal":"function Fib_14757(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_14757(n-1) + Fib_14757(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_14758","instance":14758,"id":234773,"goal":"function Gcd_14758(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_14758(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_14759","instance":14759,"id":234774,"goal":"function Power_14759(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_14759(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_14760","instance":14760,"id":234775,"goal":"function Sum_14760(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_14760(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_14761","instance":14761,"id":234776,"goal":"method BinarySearch_14761(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_14762","instance":14762,"id":234777,"goal":"method InsertSort_14762(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_14763","instance":14763,"id":234778,"goal":"method MergeSort_14763(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_14764","instance":14764,"id":234779,"goal":"method ArrayCopy_14764(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_14765","instance":14765,"id":234780,"goal":"function ListReverse_14765(s: seq): seq\n ensures |ListReverse_14765(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_14765(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_14766","instance":14766,"id":234781,"goal":"function Factorial_14766(n: nat): nat\n ensures Factorial_14766(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_14766(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_14767","instance":14767,"id":234782,"goal":"function Fib_14767(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_14767(n-1) + Fib_14767(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_14768","instance":14768,"id":234783,"goal":"function Gcd_14768(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_14768(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_14769","instance":14769,"id":234784,"goal":"function Power_14769(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_14769(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_14770","instance":14770,"id":234785,"goal":"function Sum_14770(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_14770(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_14771","instance":14771,"id":234786,"goal":"method BinarySearch_14771(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_14772","instance":14772,"id":234787,"goal":"method InsertSort_14772(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_14773","instance":14773,"id":234788,"goal":"method MergeSort_14773(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_14774","instance":14774,"id":234789,"goal":"method ArrayCopy_14774(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_14775","instance":14775,"id":234790,"goal":"function ListReverse_14775(s: seq): seq\n ensures |ListReverse_14775(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_14775(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_14776","instance":14776,"id":234791,"goal":"function Factorial_14776(n: nat): nat\n ensures Factorial_14776(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_14776(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_14777","instance":14777,"id":234792,"goal":"function Fib_14777(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_14777(n-1) + Fib_14777(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_14778","instance":14778,"id":234793,"goal":"function Gcd_14778(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_14778(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_14779","instance":14779,"id":234794,"goal":"function Power_14779(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_14779(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_14780","instance":14780,"id":234795,"goal":"function Sum_14780(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_14780(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_14781","instance":14781,"id":234796,"goal":"method BinarySearch_14781(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_14782","instance":14782,"id":234797,"goal":"method InsertSort_14782(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_14783","instance":14783,"id":234798,"goal":"method MergeSort_14783(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_14784","instance":14784,"id":234799,"goal":"method ArrayCopy_14784(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_14785","instance":14785,"id":234800,"goal":"function ListReverse_14785(s: seq): seq\n ensures |ListReverse_14785(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_14785(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_14786","instance":14786,"id":234801,"goal":"function Factorial_14786(n: nat): nat\n ensures Factorial_14786(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_14786(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_14787","instance":14787,"id":234802,"goal":"function Fib_14787(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_14787(n-1) + Fib_14787(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_14788","instance":14788,"id":234803,"goal":"function Gcd_14788(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_14788(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_14789","instance":14789,"id":234804,"goal":"function Power_14789(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_14789(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_14790","instance":14790,"id":234805,"goal":"function Sum_14790(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_14790(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_14791","instance":14791,"id":234806,"goal":"method BinarySearch_14791(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_14792","instance":14792,"id":234807,"goal":"method InsertSort_14792(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_14793","instance":14793,"id":234808,"goal":"method MergeSort_14793(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_14794","instance":14794,"id":234809,"goal":"method ArrayCopy_14794(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_14795","instance":14795,"id":234810,"goal":"function ListReverse_14795(s: seq): seq\n ensures |ListReverse_14795(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_14795(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_14796","instance":14796,"id":234811,"goal":"function Factorial_14796(n: nat): nat\n ensures Factorial_14796(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_14796(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_14797","instance":14797,"id":234812,"goal":"function Fib_14797(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_14797(n-1) + Fib_14797(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_14798","instance":14798,"id":234813,"goal":"function Gcd_14798(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_14798(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_14799","instance":14799,"id":234814,"goal":"function Power_14799(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_14799(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_14800","instance":14800,"id":234815,"goal":"function Sum_14800(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_14800(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_14801","instance":14801,"id":234816,"goal":"method BinarySearch_14801(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_14802","instance":14802,"id":234817,"goal":"method InsertSort_14802(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_14803","instance":14803,"id":234818,"goal":"method MergeSort_14803(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_14804","instance":14804,"id":234819,"goal":"method ArrayCopy_14804(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_14805","instance":14805,"id":234820,"goal":"function ListReverse_14805(s: seq): seq\n ensures |ListReverse_14805(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_14805(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_14806","instance":14806,"id":234821,"goal":"function Factorial_14806(n: nat): nat\n ensures Factorial_14806(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_14806(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_14807","instance":14807,"id":234822,"goal":"function Fib_14807(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_14807(n-1) + Fib_14807(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_14808","instance":14808,"id":234823,"goal":"function Gcd_14808(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_14808(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_14809","instance":14809,"id":234824,"goal":"function Power_14809(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_14809(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_14810","instance":14810,"id":234825,"goal":"function Sum_14810(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_14810(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_14811","instance":14811,"id":234826,"goal":"method BinarySearch_14811(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_14812","instance":14812,"id":234827,"goal":"method InsertSort_14812(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_14813","instance":14813,"id":234828,"goal":"method MergeSort_14813(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_14814","instance":14814,"id":234829,"goal":"method ArrayCopy_14814(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_14815","instance":14815,"id":234830,"goal":"function ListReverse_14815(s: seq): seq\n ensures |ListReverse_14815(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_14815(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_14816","instance":14816,"id":234831,"goal":"function Factorial_14816(n: nat): nat\n ensures Factorial_14816(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_14816(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_14817","instance":14817,"id":234832,"goal":"function Fib_14817(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_14817(n-1) + Fib_14817(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_14818","instance":14818,"id":234833,"goal":"function Gcd_14818(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_14818(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_14819","instance":14819,"id":234834,"goal":"function Power_14819(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_14819(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_14820","instance":14820,"id":234835,"goal":"function Sum_14820(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_14820(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_14821","instance":14821,"id":234836,"goal":"method BinarySearch_14821(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_14822","instance":14822,"id":234837,"goal":"method InsertSort_14822(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_14823","instance":14823,"id":234838,"goal":"method MergeSort_14823(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_14824","instance":14824,"id":234839,"goal":"method ArrayCopy_14824(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_14825","instance":14825,"id":234840,"goal":"function ListReverse_14825(s: seq): seq\n ensures |ListReverse_14825(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_14825(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_14826","instance":14826,"id":234841,"goal":"function Factorial_14826(n: nat): nat\n ensures Factorial_14826(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_14826(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_14827","instance":14827,"id":234842,"goal":"function Fib_14827(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_14827(n-1) + Fib_14827(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_14828","instance":14828,"id":234843,"goal":"function Gcd_14828(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_14828(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_14829","instance":14829,"id":234844,"goal":"function Power_14829(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_14829(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_14830","instance":14830,"id":234845,"goal":"function Sum_14830(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_14830(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_14831","instance":14831,"id":234846,"goal":"method BinarySearch_14831(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_14832","instance":14832,"id":234847,"goal":"method InsertSort_14832(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_14833","instance":14833,"id":234848,"goal":"method MergeSort_14833(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_14834","instance":14834,"id":234849,"goal":"method ArrayCopy_14834(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_14835","instance":14835,"id":234850,"goal":"function ListReverse_14835(s: seq): seq\n ensures |ListReverse_14835(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_14835(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_14836","instance":14836,"id":234851,"goal":"function Factorial_14836(n: nat): nat\n ensures Factorial_14836(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_14836(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_14837","instance":14837,"id":234852,"goal":"function Fib_14837(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_14837(n-1) + Fib_14837(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_14838","instance":14838,"id":234853,"goal":"function Gcd_14838(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_14838(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_14839","instance":14839,"id":234854,"goal":"function Power_14839(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_14839(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_14840","instance":14840,"id":234855,"goal":"function Sum_14840(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_14840(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_14841","instance":14841,"id":234856,"goal":"method BinarySearch_14841(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_14842","instance":14842,"id":234857,"goal":"method InsertSort_14842(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_14843","instance":14843,"id":234858,"goal":"method MergeSort_14843(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_14844","instance":14844,"id":234859,"goal":"method ArrayCopy_14844(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_14845","instance":14845,"id":234860,"goal":"function ListReverse_14845(s: seq): seq\n ensures |ListReverse_14845(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_14845(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_14846","instance":14846,"id":234861,"goal":"function Factorial_14846(n: nat): nat\n ensures Factorial_14846(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_14846(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_14847","instance":14847,"id":234862,"goal":"function Fib_14847(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_14847(n-1) + Fib_14847(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_14848","instance":14848,"id":234863,"goal":"function Gcd_14848(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_14848(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_14849","instance":14849,"id":234864,"goal":"function Power_14849(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_14849(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_14850","instance":14850,"id":234865,"goal":"function Sum_14850(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_14850(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_14851","instance":14851,"id":234866,"goal":"method BinarySearch_14851(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_14852","instance":14852,"id":234867,"goal":"method InsertSort_14852(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_14853","instance":14853,"id":234868,"goal":"method MergeSort_14853(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_14854","instance":14854,"id":234869,"goal":"method ArrayCopy_14854(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_14855","instance":14855,"id":234870,"goal":"function ListReverse_14855(s: seq): seq\n ensures |ListReverse_14855(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_14855(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_14856","instance":14856,"id":234871,"goal":"function Factorial_14856(n: nat): nat\n ensures Factorial_14856(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_14856(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_14857","instance":14857,"id":234872,"goal":"function Fib_14857(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_14857(n-1) + Fib_14857(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_14858","instance":14858,"id":234873,"goal":"function Gcd_14858(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_14858(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_14859","instance":14859,"id":234874,"goal":"function Power_14859(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_14859(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_14860","instance":14860,"id":234875,"goal":"function Sum_14860(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_14860(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_14861","instance":14861,"id":234876,"goal":"method BinarySearch_14861(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_14862","instance":14862,"id":234877,"goal":"method InsertSort_14862(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_14863","instance":14863,"id":234878,"goal":"method MergeSort_14863(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_14864","instance":14864,"id":234879,"goal":"method ArrayCopy_14864(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_14865","instance":14865,"id":234880,"goal":"function ListReverse_14865(s: seq): seq\n ensures |ListReverse_14865(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_14865(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_14866","instance":14866,"id":234881,"goal":"function Factorial_14866(n: nat): nat\n ensures Factorial_14866(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_14866(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_14867","instance":14867,"id":234882,"goal":"function Fib_14867(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_14867(n-1) + Fib_14867(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_14868","instance":14868,"id":234883,"goal":"function Gcd_14868(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_14868(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_14869","instance":14869,"id":234884,"goal":"function Power_14869(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_14869(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_14870","instance":14870,"id":234885,"goal":"function Sum_14870(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_14870(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_14871","instance":14871,"id":234886,"goal":"method BinarySearch_14871(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_14872","instance":14872,"id":234887,"goal":"method InsertSort_14872(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_14873","instance":14873,"id":234888,"goal":"method MergeSort_14873(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_14874","instance":14874,"id":234889,"goal":"method ArrayCopy_14874(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_14875","instance":14875,"id":234890,"goal":"function ListReverse_14875(s: seq): seq\n ensures |ListReverse_14875(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_14875(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_14876","instance":14876,"id":234891,"goal":"function Factorial_14876(n: nat): nat\n ensures Factorial_14876(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_14876(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_14877","instance":14877,"id":234892,"goal":"function Fib_14877(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_14877(n-1) + Fib_14877(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_14878","instance":14878,"id":234893,"goal":"function Gcd_14878(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_14878(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_14879","instance":14879,"id":234894,"goal":"function Power_14879(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_14879(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_14880","instance":14880,"id":234895,"goal":"function Sum_14880(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_14880(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_14881","instance":14881,"id":234896,"goal":"method BinarySearch_14881(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_14882","instance":14882,"id":234897,"goal":"method InsertSort_14882(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_14883","instance":14883,"id":234898,"goal":"method MergeSort_14883(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_14884","instance":14884,"id":234899,"goal":"method ArrayCopy_14884(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_14885","instance":14885,"id":234900,"goal":"function ListReverse_14885(s: seq): seq\n ensures |ListReverse_14885(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_14885(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_14886","instance":14886,"id":234901,"goal":"function Factorial_14886(n: nat): nat\n ensures Factorial_14886(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_14886(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_14887","instance":14887,"id":234902,"goal":"function Fib_14887(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_14887(n-1) + Fib_14887(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_14888","instance":14888,"id":234903,"goal":"function Gcd_14888(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_14888(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_14889","instance":14889,"id":234904,"goal":"function Power_14889(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_14889(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_14890","instance":14890,"id":234905,"goal":"function Sum_14890(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_14890(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_14891","instance":14891,"id":234906,"goal":"method BinarySearch_14891(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_14892","instance":14892,"id":234907,"goal":"method InsertSort_14892(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_14893","instance":14893,"id":234908,"goal":"method MergeSort_14893(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_14894","instance":14894,"id":234909,"goal":"method ArrayCopy_14894(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_14895","instance":14895,"id":234910,"goal":"function ListReverse_14895(s: seq): seq\n ensures |ListReverse_14895(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_14895(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_14896","instance":14896,"id":234911,"goal":"function Factorial_14896(n: nat): nat\n ensures Factorial_14896(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_14896(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_14897","instance":14897,"id":234912,"goal":"function Fib_14897(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_14897(n-1) + Fib_14897(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_14898","instance":14898,"id":234913,"goal":"function Gcd_14898(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_14898(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_14899","instance":14899,"id":234914,"goal":"function Power_14899(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_14899(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_14900","instance":14900,"id":234915,"goal":"function Sum_14900(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_14900(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_14901","instance":14901,"id":234916,"goal":"method BinarySearch_14901(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_14902","instance":14902,"id":234917,"goal":"method InsertSort_14902(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_14903","instance":14903,"id":234918,"goal":"method MergeSort_14903(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_14904","instance":14904,"id":234919,"goal":"method ArrayCopy_14904(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_14905","instance":14905,"id":234920,"goal":"function ListReverse_14905(s: seq): seq\n ensures |ListReverse_14905(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_14905(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_14906","instance":14906,"id":234921,"goal":"function Factorial_14906(n: nat): nat\n ensures Factorial_14906(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_14906(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_14907","instance":14907,"id":234922,"goal":"function Fib_14907(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_14907(n-1) + Fib_14907(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_14908","instance":14908,"id":234923,"goal":"function Gcd_14908(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_14908(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_14909","instance":14909,"id":234924,"goal":"function Power_14909(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_14909(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_14910","instance":14910,"id":234925,"goal":"function Sum_14910(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_14910(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_14911","instance":14911,"id":234926,"goal":"method BinarySearch_14911(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_14912","instance":14912,"id":234927,"goal":"method InsertSort_14912(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_14913","instance":14913,"id":234928,"goal":"method MergeSort_14913(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_14914","instance":14914,"id":234929,"goal":"method ArrayCopy_14914(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_14915","instance":14915,"id":234930,"goal":"function ListReverse_14915(s: seq): seq\n ensures |ListReverse_14915(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_14915(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_14916","instance":14916,"id":234931,"goal":"function Factorial_14916(n: nat): nat\n ensures Factorial_14916(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_14916(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_14917","instance":14917,"id":234932,"goal":"function Fib_14917(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_14917(n-1) + Fib_14917(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_14918","instance":14918,"id":234933,"goal":"function Gcd_14918(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_14918(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_14919","instance":14919,"id":234934,"goal":"function Power_14919(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_14919(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_14920","instance":14920,"id":234935,"goal":"function Sum_14920(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_14920(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_14921","instance":14921,"id":234936,"goal":"method BinarySearch_14921(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_14922","instance":14922,"id":234937,"goal":"method InsertSort_14922(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_14923","instance":14923,"id":234938,"goal":"method MergeSort_14923(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_14924","instance":14924,"id":234939,"goal":"method ArrayCopy_14924(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_14925","instance":14925,"id":234940,"goal":"function ListReverse_14925(s: seq): seq\n ensures |ListReverse_14925(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_14925(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_14926","instance":14926,"id":234941,"goal":"function Factorial_14926(n: nat): nat\n ensures Factorial_14926(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_14926(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_14927","instance":14927,"id":234942,"goal":"function Fib_14927(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_14927(n-1) + Fib_14927(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_14928","instance":14928,"id":234943,"goal":"function Gcd_14928(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_14928(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_14929","instance":14929,"id":234944,"goal":"function Power_14929(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_14929(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_14930","instance":14930,"id":234945,"goal":"function Sum_14930(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_14930(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_14931","instance":14931,"id":234946,"goal":"method BinarySearch_14931(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_14932","instance":14932,"id":234947,"goal":"method InsertSort_14932(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_14933","instance":14933,"id":234948,"goal":"method MergeSort_14933(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_14934","instance":14934,"id":234949,"goal":"method ArrayCopy_14934(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_14935","instance":14935,"id":234950,"goal":"function ListReverse_14935(s: seq): seq\n ensures |ListReverse_14935(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_14935(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_14936","instance":14936,"id":234951,"goal":"function Factorial_14936(n: nat): nat\n ensures Factorial_14936(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_14936(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_14937","instance":14937,"id":234952,"goal":"function Fib_14937(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_14937(n-1) + Fib_14937(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_14938","instance":14938,"id":234953,"goal":"function Gcd_14938(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_14938(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_14939","instance":14939,"id":234954,"goal":"function Power_14939(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_14939(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_14940","instance":14940,"id":234955,"goal":"function Sum_14940(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_14940(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_14941","instance":14941,"id":234956,"goal":"method BinarySearch_14941(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_14942","instance":14942,"id":234957,"goal":"method InsertSort_14942(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_14943","instance":14943,"id":234958,"goal":"method MergeSort_14943(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_14944","instance":14944,"id":234959,"goal":"method ArrayCopy_14944(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_14945","instance":14945,"id":234960,"goal":"function ListReverse_14945(s: seq): seq\n ensures |ListReverse_14945(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_14945(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_14946","instance":14946,"id":234961,"goal":"function Factorial_14946(n: nat): nat\n ensures Factorial_14946(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_14946(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_14947","instance":14947,"id":234962,"goal":"function Fib_14947(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_14947(n-1) + Fib_14947(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_14948","instance":14948,"id":234963,"goal":"function Gcd_14948(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_14948(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_14949","instance":14949,"id":234964,"goal":"function Power_14949(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_14949(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_14950","instance":14950,"id":234965,"goal":"function Sum_14950(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_14950(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_14951","instance":14951,"id":234966,"goal":"method BinarySearch_14951(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_14952","instance":14952,"id":234967,"goal":"method InsertSort_14952(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_14953","instance":14953,"id":234968,"goal":"method MergeSort_14953(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_14954","instance":14954,"id":234969,"goal":"method ArrayCopy_14954(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_14955","instance":14955,"id":234970,"goal":"function ListReverse_14955(s: seq): seq\n ensures |ListReverse_14955(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_14955(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_14956","instance":14956,"id":234971,"goal":"function Factorial_14956(n: nat): nat\n ensures Factorial_14956(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_14956(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_14957","instance":14957,"id":234972,"goal":"function Fib_14957(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_14957(n-1) + Fib_14957(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_14958","instance":14958,"id":234973,"goal":"function Gcd_14958(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_14958(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_14959","instance":14959,"id":234974,"goal":"function Power_14959(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_14959(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_14960","instance":14960,"id":234975,"goal":"function Sum_14960(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_14960(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_14961","instance":14961,"id":234976,"goal":"method BinarySearch_14961(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_14962","instance":14962,"id":234977,"goal":"method InsertSort_14962(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_14963","instance":14963,"id":234978,"goal":"method MergeSort_14963(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_14964","instance":14964,"id":234979,"goal":"method ArrayCopy_14964(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_14965","instance":14965,"id":234980,"goal":"function ListReverse_14965(s: seq): seq\n ensures |ListReverse_14965(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_14965(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_14966","instance":14966,"id":234981,"goal":"function Factorial_14966(n: nat): nat\n ensures Factorial_14966(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_14966(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_14967","instance":14967,"id":234982,"goal":"function Fib_14967(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_14967(n-1) + Fib_14967(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_14968","instance":14968,"id":234983,"goal":"function Gcd_14968(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_14968(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_14969","instance":14969,"id":234984,"goal":"function Power_14969(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_14969(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_14970","instance":14970,"id":234985,"goal":"function Sum_14970(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_14970(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_14971","instance":14971,"id":234986,"goal":"method BinarySearch_14971(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_14972","instance":14972,"id":234987,"goal":"method InsertSort_14972(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_14973","instance":14973,"id":234988,"goal":"method MergeSort_14973(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_14974","instance":14974,"id":234989,"goal":"method ArrayCopy_14974(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_14975","instance":14975,"id":234990,"goal":"function ListReverse_14975(s: seq): seq\n ensures |ListReverse_14975(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_14975(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_14976","instance":14976,"id":234991,"goal":"function Factorial_14976(n: nat): nat\n ensures Factorial_14976(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_14976(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_14977","instance":14977,"id":234992,"goal":"function Fib_14977(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_14977(n-1) + Fib_14977(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_14978","instance":14978,"id":234993,"goal":"function Gcd_14978(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_14978(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_14979","instance":14979,"id":234994,"goal":"function Power_14979(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_14979(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_14980","instance":14980,"id":234995,"goal":"function Sum_14980(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_14980(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_14981","instance":14981,"id":234996,"goal":"method BinarySearch_14981(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_14982","instance":14982,"id":234997,"goal":"method InsertSort_14982(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_14983","instance":14983,"id":234998,"goal":"method MergeSort_14983(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_14984","instance":14984,"id":234999,"goal":"method ArrayCopy_14984(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_14985","instance":14985,"id":235000,"goal":"function ListReverse_14985(s: seq): seq\n ensures |ListReverse_14985(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_14985(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_14986","instance":14986,"id":235001,"goal":"function Factorial_14986(n: nat): nat\n ensures Factorial_14986(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_14986(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_14987","instance":14987,"id":235002,"goal":"function Fib_14987(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_14987(n-1) + Fib_14987(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_14988","instance":14988,"id":235003,"goal":"function Gcd_14988(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_14988(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_14989","instance":14989,"id":235004,"goal":"function Power_14989(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_14989(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_14990","instance":14990,"id":235005,"goal":"function Sum_14990(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_14990(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_14991","instance":14991,"id":235006,"goal":"method BinarySearch_14991(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_14992","instance":14992,"id":235007,"goal":"method InsertSort_14992(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_14993","instance":14993,"id":235008,"goal":"method MergeSort_14993(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_14994","instance":14994,"id":235009,"goal":"method ArrayCopy_14994(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_14995","instance":14995,"id":235010,"goal":"function ListReverse_14995(s: seq): seq\n ensures |ListReverse_14995(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_14995(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_14996","instance":14996,"id":235011,"goal":"function Factorial_14996(n: nat): nat\n ensures Factorial_14996(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_14996(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_14997","instance":14997,"id":235012,"goal":"function Fib_14997(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_14997(n-1) + Fib_14997(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_14998","instance":14998,"id":235013,"goal":"function Gcd_14998(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_14998(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_14999","instance":14999,"id":235014,"goal":"function Power_14999(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_14999(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_15000","instance":15000,"id":235015,"goal":"function Sum_15000(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_15000(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_15001","instance":15001,"id":235016,"goal":"method BinarySearch_15001(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_15002","instance":15002,"id":235017,"goal":"method InsertSort_15002(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_15003","instance":15003,"id":235018,"goal":"method MergeSort_15003(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_15004","instance":15004,"id":235019,"goal":"method ArrayCopy_15004(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_15005","instance":15005,"id":235020,"goal":"function ListReverse_15005(s: seq): seq\n ensures |ListReverse_15005(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_15005(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_15006","instance":15006,"id":235021,"goal":"function Factorial_15006(n: nat): nat\n ensures Factorial_15006(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_15006(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_15007","instance":15007,"id":235022,"goal":"function Fib_15007(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_15007(n-1) + Fib_15007(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_15008","instance":15008,"id":235023,"goal":"function Gcd_15008(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_15008(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_15009","instance":15009,"id":235024,"goal":"function Power_15009(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_15009(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_15010","instance":15010,"id":235025,"goal":"function Sum_15010(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_15010(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_15011","instance":15011,"id":235026,"goal":"method BinarySearch_15011(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_15012","instance":15012,"id":235027,"goal":"method InsertSort_15012(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_15013","instance":15013,"id":235028,"goal":"method MergeSort_15013(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_15014","instance":15014,"id":235029,"goal":"method ArrayCopy_15014(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_15015","instance":15015,"id":235030,"goal":"function ListReverse_15015(s: seq): seq\n ensures |ListReverse_15015(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_15015(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_15016","instance":15016,"id":235031,"goal":"function Factorial_15016(n: nat): nat\n ensures Factorial_15016(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_15016(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_15017","instance":15017,"id":235032,"goal":"function Fib_15017(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_15017(n-1) + Fib_15017(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_15018","instance":15018,"id":235033,"goal":"function Gcd_15018(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_15018(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_15019","instance":15019,"id":235034,"goal":"function Power_15019(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_15019(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_15020","instance":15020,"id":235035,"goal":"function Sum_15020(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_15020(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_15021","instance":15021,"id":235036,"goal":"method BinarySearch_15021(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_15022","instance":15022,"id":235037,"goal":"method InsertSort_15022(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_15023","instance":15023,"id":235038,"goal":"method MergeSort_15023(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_15024","instance":15024,"id":235039,"goal":"method ArrayCopy_15024(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_15025","instance":15025,"id":235040,"goal":"function ListReverse_15025(s: seq): seq\n ensures |ListReverse_15025(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_15025(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_15026","instance":15026,"id":235041,"goal":"function Factorial_15026(n: nat): nat\n ensures Factorial_15026(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_15026(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_15027","instance":15027,"id":235042,"goal":"function Fib_15027(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_15027(n-1) + Fib_15027(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_15028","instance":15028,"id":235043,"goal":"function Gcd_15028(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_15028(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_15029","instance":15029,"id":235044,"goal":"function Power_15029(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_15029(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_15030","instance":15030,"id":235045,"goal":"function Sum_15030(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_15030(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_15031","instance":15031,"id":235046,"goal":"method BinarySearch_15031(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_15032","instance":15032,"id":235047,"goal":"method InsertSort_15032(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_15033","instance":15033,"id":235048,"goal":"method MergeSort_15033(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_15034","instance":15034,"id":235049,"goal":"method ArrayCopy_15034(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_15035","instance":15035,"id":235050,"goal":"function ListReverse_15035(s: seq): seq\n ensures |ListReverse_15035(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_15035(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_15036","instance":15036,"id":235051,"goal":"function Factorial_15036(n: nat): nat\n ensures Factorial_15036(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_15036(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_15037","instance":15037,"id":235052,"goal":"function Fib_15037(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_15037(n-1) + Fib_15037(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_15038","instance":15038,"id":235053,"goal":"function Gcd_15038(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_15038(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_15039","instance":15039,"id":235054,"goal":"function Power_15039(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_15039(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_15040","instance":15040,"id":235055,"goal":"function Sum_15040(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_15040(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_15041","instance":15041,"id":235056,"goal":"method BinarySearch_15041(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_15042","instance":15042,"id":235057,"goal":"method InsertSort_15042(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_15043","instance":15043,"id":235058,"goal":"method MergeSort_15043(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_15044","instance":15044,"id":235059,"goal":"method ArrayCopy_15044(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_15045","instance":15045,"id":235060,"goal":"function ListReverse_15045(s: seq): seq\n ensures |ListReverse_15045(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_15045(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_15046","instance":15046,"id":235061,"goal":"function Factorial_15046(n: nat): nat\n ensures Factorial_15046(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_15046(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_15047","instance":15047,"id":235062,"goal":"function Fib_15047(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_15047(n-1) + Fib_15047(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_15048","instance":15048,"id":235063,"goal":"function Gcd_15048(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_15048(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_15049","instance":15049,"id":235064,"goal":"function Power_15049(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_15049(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_15050","instance":15050,"id":235065,"goal":"function Sum_15050(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_15050(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_15051","instance":15051,"id":235066,"goal":"method BinarySearch_15051(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_15052","instance":15052,"id":235067,"goal":"method InsertSort_15052(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_15053","instance":15053,"id":235068,"goal":"method MergeSort_15053(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_15054","instance":15054,"id":235069,"goal":"method ArrayCopy_15054(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_15055","instance":15055,"id":235070,"goal":"function ListReverse_15055(s: seq): seq\n ensures |ListReverse_15055(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_15055(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_15056","instance":15056,"id":235071,"goal":"function Factorial_15056(n: nat): nat\n ensures Factorial_15056(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_15056(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_15057","instance":15057,"id":235072,"goal":"function Fib_15057(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_15057(n-1) + Fib_15057(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_15058","instance":15058,"id":235073,"goal":"function Gcd_15058(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_15058(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_15059","instance":15059,"id":235074,"goal":"function Power_15059(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_15059(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_15060","instance":15060,"id":235075,"goal":"function Sum_15060(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_15060(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_15061","instance":15061,"id":235076,"goal":"method BinarySearch_15061(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_15062","instance":15062,"id":235077,"goal":"method InsertSort_15062(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_15063","instance":15063,"id":235078,"goal":"method MergeSort_15063(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_15064","instance":15064,"id":235079,"goal":"method ArrayCopy_15064(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_15065","instance":15065,"id":235080,"goal":"function ListReverse_15065(s: seq): seq\n ensures |ListReverse_15065(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_15065(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_15066","instance":15066,"id":235081,"goal":"function Factorial_15066(n: nat): nat\n ensures Factorial_15066(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_15066(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_15067","instance":15067,"id":235082,"goal":"function Fib_15067(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_15067(n-1) + Fib_15067(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_15068","instance":15068,"id":235083,"goal":"function Gcd_15068(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_15068(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_15069","instance":15069,"id":235084,"goal":"function Power_15069(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_15069(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_15070","instance":15070,"id":235085,"goal":"function Sum_15070(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_15070(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_15071","instance":15071,"id":235086,"goal":"method BinarySearch_15071(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_15072","instance":15072,"id":235087,"goal":"method InsertSort_15072(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_15073","instance":15073,"id":235088,"goal":"method MergeSort_15073(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_15074","instance":15074,"id":235089,"goal":"method ArrayCopy_15074(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_15075","instance":15075,"id":235090,"goal":"function ListReverse_15075(s: seq): seq\n ensures |ListReverse_15075(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_15075(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_15076","instance":15076,"id":235091,"goal":"function Factorial_15076(n: nat): nat\n ensures Factorial_15076(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_15076(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_15077","instance":15077,"id":235092,"goal":"function Fib_15077(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_15077(n-1) + Fib_15077(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_15078","instance":15078,"id":235093,"goal":"function Gcd_15078(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_15078(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_15079","instance":15079,"id":235094,"goal":"function Power_15079(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_15079(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_15080","instance":15080,"id":235095,"goal":"function Sum_15080(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_15080(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_15081","instance":15081,"id":235096,"goal":"method BinarySearch_15081(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_15082","instance":15082,"id":235097,"goal":"method InsertSort_15082(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_15083","instance":15083,"id":235098,"goal":"method MergeSort_15083(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_15084","instance":15084,"id":235099,"goal":"method ArrayCopy_15084(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_15085","instance":15085,"id":235100,"goal":"function ListReverse_15085(s: seq): seq\n ensures |ListReverse_15085(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_15085(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_15086","instance":15086,"id":235101,"goal":"function Factorial_15086(n: nat): nat\n ensures Factorial_15086(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_15086(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_15087","instance":15087,"id":235102,"goal":"function Fib_15087(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_15087(n-1) + Fib_15087(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_15088","instance":15088,"id":235103,"goal":"function Gcd_15088(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_15088(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_15089","instance":15089,"id":235104,"goal":"function Power_15089(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_15089(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_15090","instance":15090,"id":235105,"goal":"function Sum_15090(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_15090(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_15091","instance":15091,"id":235106,"goal":"method BinarySearch_15091(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_15092","instance":15092,"id":235107,"goal":"method InsertSort_15092(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_15093","instance":15093,"id":235108,"goal":"method MergeSort_15093(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_15094","instance":15094,"id":235109,"goal":"method ArrayCopy_15094(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_15095","instance":15095,"id":235110,"goal":"function ListReverse_15095(s: seq): seq\n ensures |ListReverse_15095(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_15095(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_15096","instance":15096,"id":235111,"goal":"function Factorial_15096(n: nat): nat\n ensures Factorial_15096(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_15096(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_15097","instance":15097,"id":235112,"goal":"function Fib_15097(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_15097(n-1) + Fib_15097(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_15098","instance":15098,"id":235113,"goal":"function Gcd_15098(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_15098(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_15099","instance":15099,"id":235114,"goal":"function Power_15099(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_15099(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_15100","instance":15100,"id":235115,"goal":"function Sum_15100(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_15100(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_15101","instance":15101,"id":235116,"goal":"method BinarySearch_15101(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_15102","instance":15102,"id":235117,"goal":"method InsertSort_15102(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_15103","instance":15103,"id":235118,"goal":"method MergeSort_15103(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_15104","instance":15104,"id":235119,"goal":"method ArrayCopy_15104(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_15105","instance":15105,"id":235120,"goal":"function ListReverse_15105(s: seq): seq\n ensures |ListReverse_15105(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_15105(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_15106","instance":15106,"id":235121,"goal":"function Factorial_15106(n: nat): nat\n ensures Factorial_15106(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_15106(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_15107","instance":15107,"id":235122,"goal":"function Fib_15107(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_15107(n-1) + Fib_15107(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_15108","instance":15108,"id":235123,"goal":"function Gcd_15108(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_15108(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_15109","instance":15109,"id":235124,"goal":"function Power_15109(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_15109(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_15110","instance":15110,"id":235125,"goal":"function Sum_15110(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_15110(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_15111","instance":15111,"id":235126,"goal":"method BinarySearch_15111(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_15112","instance":15112,"id":235127,"goal":"method InsertSort_15112(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_15113","instance":15113,"id":235128,"goal":"method MergeSort_15113(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_15114","instance":15114,"id":235129,"goal":"method ArrayCopy_15114(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_15115","instance":15115,"id":235130,"goal":"function ListReverse_15115(s: seq): seq\n ensures |ListReverse_15115(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_15115(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_15116","instance":15116,"id":235131,"goal":"function Factorial_15116(n: nat): nat\n ensures Factorial_15116(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_15116(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_15117","instance":15117,"id":235132,"goal":"function Fib_15117(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_15117(n-1) + Fib_15117(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_15118","instance":15118,"id":235133,"goal":"function Gcd_15118(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_15118(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_15119","instance":15119,"id":235134,"goal":"function Power_15119(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_15119(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_15120","instance":15120,"id":235135,"goal":"function Sum_15120(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_15120(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_15121","instance":15121,"id":235136,"goal":"method BinarySearch_15121(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_15122","instance":15122,"id":235137,"goal":"method InsertSort_15122(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_15123","instance":15123,"id":235138,"goal":"method MergeSort_15123(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_15124","instance":15124,"id":235139,"goal":"method ArrayCopy_15124(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_15125","instance":15125,"id":235140,"goal":"function ListReverse_15125(s: seq): seq\n ensures |ListReverse_15125(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_15125(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_15126","instance":15126,"id":235141,"goal":"function Factorial_15126(n: nat): nat\n ensures Factorial_15126(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_15126(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_15127","instance":15127,"id":235142,"goal":"function Fib_15127(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_15127(n-1) + Fib_15127(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_15128","instance":15128,"id":235143,"goal":"function Gcd_15128(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_15128(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_15129","instance":15129,"id":235144,"goal":"function Power_15129(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_15129(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_15130","instance":15130,"id":235145,"goal":"function Sum_15130(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_15130(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_15131","instance":15131,"id":235146,"goal":"method BinarySearch_15131(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_15132","instance":15132,"id":235147,"goal":"method InsertSort_15132(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_15133","instance":15133,"id":235148,"goal":"method MergeSort_15133(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_15134","instance":15134,"id":235149,"goal":"method ArrayCopy_15134(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_15135","instance":15135,"id":235150,"goal":"function ListReverse_15135(s: seq): seq\n ensures |ListReverse_15135(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_15135(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_15136","instance":15136,"id":235151,"goal":"function Factorial_15136(n: nat): nat\n ensures Factorial_15136(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_15136(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_15137","instance":15137,"id":235152,"goal":"function Fib_15137(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_15137(n-1) + Fib_15137(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_15138","instance":15138,"id":235153,"goal":"function Gcd_15138(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_15138(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_15139","instance":15139,"id":235154,"goal":"function Power_15139(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_15139(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_15140","instance":15140,"id":235155,"goal":"function Sum_15140(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_15140(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_15141","instance":15141,"id":235156,"goal":"method BinarySearch_15141(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_15142","instance":15142,"id":235157,"goal":"method InsertSort_15142(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_15143","instance":15143,"id":235158,"goal":"method MergeSort_15143(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_15144","instance":15144,"id":235159,"goal":"method ArrayCopy_15144(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_15145","instance":15145,"id":235160,"goal":"function ListReverse_15145(s: seq): seq\n ensures |ListReverse_15145(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_15145(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_15146","instance":15146,"id":235161,"goal":"function Factorial_15146(n: nat): nat\n ensures Factorial_15146(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_15146(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_15147","instance":15147,"id":235162,"goal":"function Fib_15147(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_15147(n-1) + Fib_15147(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_15148","instance":15148,"id":235163,"goal":"function Gcd_15148(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_15148(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_15149","instance":15149,"id":235164,"goal":"function Power_15149(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_15149(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_15150","instance":15150,"id":235165,"goal":"function Sum_15150(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_15150(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_15151","instance":15151,"id":235166,"goal":"method BinarySearch_15151(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_15152","instance":15152,"id":235167,"goal":"method InsertSort_15152(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_15153","instance":15153,"id":235168,"goal":"method MergeSort_15153(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_15154","instance":15154,"id":235169,"goal":"method ArrayCopy_15154(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_15155","instance":15155,"id":235170,"goal":"function ListReverse_15155(s: seq): seq\n ensures |ListReverse_15155(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_15155(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_15156","instance":15156,"id":235171,"goal":"function Factorial_15156(n: nat): nat\n ensures Factorial_15156(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_15156(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_15157","instance":15157,"id":235172,"goal":"function Fib_15157(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_15157(n-1) + Fib_15157(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_15158","instance":15158,"id":235173,"goal":"function Gcd_15158(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_15158(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_15159","instance":15159,"id":235174,"goal":"function Power_15159(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_15159(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_15160","instance":15160,"id":235175,"goal":"function Sum_15160(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_15160(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_15161","instance":15161,"id":235176,"goal":"method BinarySearch_15161(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_15162","instance":15162,"id":235177,"goal":"method InsertSort_15162(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_15163","instance":15163,"id":235178,"goal":"method MergeSort_15163(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_15164","instance":15164,"id":235179,"goal":"method ArrayCopy_15164(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_15165","instance":15165,"id":235180,"goal":"function ListReverse_15165(s: seq): seq\n ensures |ListReverse_15165(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_15165(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_15166","instance":15166,"id":235181,"goal":"function Factorial_15166(n: nat): nat\n ensures Factorial_15166(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_15166(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_15167","instance":15167,"id":235182,"goal":"function Fib_15167(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_15167(n-1) + Fib_15167(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_15168","instance":15168,"id":235183,"goal":"function Gcd_15168(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_15168(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_15169","instance":15169,"id":235184,"goal":"function Power_15169(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_15169(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_15170","instance":15170,"id":235185,"goal":"function Sum_15170(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_15170(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_15171","instance":15171,"id":235186,"goal":"method BinarySearch_15171(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_15172","instance":15172,"id":235187,"goal":"method InsertSort_15172(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_15173","instance":15173,"id":235188,"goal":"method MergeSort_15173(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_15174","instance":15174,"id":235189,"goal":"method ArrayCopy_15174(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_15175","instance":15175,"id":235190,"goal":"function ListReverse_15175(s: seq): seq\n ensures |ListReverse_15175(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_15175(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_15176","instance":15176,"id":235191,"goal":"function Factorial_15176(n: nat): nat\n ensures Factorial_15176(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_15176(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_15177","instance":15177,"id":235192,"goal":"function Fib_15177(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_15177(n-1) + Fib_15177(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_15178","instance":15178,"id":235193,"goal":"function Gcd_15178(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_15178(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_15179","instance":15179,"id":235194,"goal":"function Power_15179(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_15179(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_15180","instance":15180,"id":235195,"goal":"function Sum_15180(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_15180(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_15181","instance":15181,"id":235196,"goal":"method BinarySearch_15181(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_15182","instance":15182,"id":235197,"goal":"method InsertSort_15182(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_15183","instance":15183,"id":235198,"goal":"method MergeSort_15183(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_15184","instance":15184,"id":235199,"goal":"method ArrayCopy_15184(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_15185","instance":15185,"id":235200,"goal":"function ListReverse_15185(s: seq): seq\n ensures |ListReverse_15185(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_15185(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_15186","instance":15186,"id":235201,"goal":"function Factorial_15186(n: nat): nat\n ensures Factorial_15186(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_15186(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_15187","instance":15187,"id":235202,"goal":"function Fib_15187(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_15187(n-1) + Fib_15187(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_15188","instance":15188,"id":235203,"goal":"function Gcd_15188(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_15188(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_15189","instance":15189,"id":235204,"goal":"function Power_15189(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_15189(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_15190","instance":15190,"id":235205,"goal":"function Sum_15190(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_15190(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_15191","instance":15191,"id":235206,"goal":"method BinarySearch_15191(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_15192","instance":15192,"id":235207,"goal":"method InsertSort_15192(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_15193","instance":15193,"id":235208,"goal":"method MergeSort_15193(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_15194","instance":15194,"id":235209,"goal":"method ArrayCopy_15194(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_15195","instance":15195,"id":235210,"goal":"function ListReverse_15195(s: seq): seq\n ensures |ListReverse_15195(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_15195(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_15196","instance":15196,"id":235211,"goal":"function Factorial_15196(n: nat): nat\n ensures Factorial_15196(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_15196(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_15197","instance":15197,"id":235212,"goal":"function Fib_15197(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_15197(n-1) + Fib_15197(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_15198","instance":15198,"id":235213,"goal":"function Gcd_15198(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_15198(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_15199","instance":15199,"id":235214,"goal":"function Power_15199(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_15199(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_15200","instance":15200,"id":235215,"goal":"function Sum_15200(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_15200(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_15201","instance":15201,"id":235216,"goal":"method BinarySearch_15201(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_15202","instance":15202,"id":235217,"goal":"method InsertSort_15202(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_15203","instance":15203,"id":235218,"goal":"method MergeSort_15203(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_15204","instance":15204,"id":235219,"goal":"method ArrayCopy_15204(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_15205","instance":15205,"id":235220,"goal":"function ListReverse_15205(s: seq): seq\n ensures |ListReverse_15205(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_15205(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_15206","instance":15206,"id":235221,"goal":"function Factorial_15206(n: nat): nat\n ensures Factorial_15206(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_15206(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_15207","instance":15207,"id":235222,"goal":"function Fib_15207(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_15207(n-1) + Fib_15207(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_15208","instance":15208,"id":235223,"goal":"function Gcd_15208(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_15208(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_15209","instance":15209,"id":235224,"goal":"function Power_15209(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_15209(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_15210","instance":15210,"id":235225,"goal":"function Sum_15210(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_15210(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_15211","instance":15211,"id":235226,"goal":"method BinarySearch_15211(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_15212","instance":15212,"id":235227,"goal":"method InsertSort_15212(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_15213","instance":15213,"id":235228,"goal":"method MergeSort_15213(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_15214","instance":15214,"id":235229,"goal":"method ArrayCopy_15214(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_15215","instance":15215,"id":235230,"goal":"function ListReverse_15215(s: seq): seq\n ensures |ListReverse_15215(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_15215(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_15216","instance":15216,"id":235231,"goal":"function Factorial_15216(n: nat): nat\n ensures Factorial_15216(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_15216(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_15217","instance":15217,"id":235232,"goal":"function Fib_15217(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_15217(n-1) + Fib_15217(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_15218","instance":15218,"id":235233,"goal":"function Gcd_15218(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_15218(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_15219","instance":15219,"id":235234,"goal":"function Power_15219(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_15219(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_15220","instance":15220,"id":235235,"goal":"function Sum_15220(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_15220(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_15221","instance":15221,"id":235236,"goal":"method BinarySearch_15221(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_15222","instance":15222,"id":235237,"goal":"method InsertSort_15222(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_15223","instance":15223,"id":235238,"goal":"method MergeSort_15223(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_15224","instance":15224,"id":235239,"goal":"method ArrayCopy_15224(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_15225","instance":15225,"id":235240,"goal":"function ListReverse_15225(s: seq): seq\n ensures |ListReverse_15225(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_15225(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_15226","instance":15226,"id":235241,"goal":"function Factorial_15226(n: nat): nat\n ensures Factorial_15226(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_15226(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_15227","instance":15227,"id":235242,"goal":"function Fib_15227(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_15227(n-1) + Fib_15227(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_15228","instance":15228,"id":235243,"goal":"function Gcd_15228(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_15228(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_15229","instance":15229,"id":235244,"goal":"function Power_15229(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_15229(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_15230","instance":15230,"id":235245,"goal":"function Sum_15230(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_15230(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_15231","instance":15231,"id":235246,"goal":"method BinarySearch_15231(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_15232","instance":15232,"id":235247,"goal":"method InsertSort_15232(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_15233","instance":15233,"id":235248,"goal":"method MergeSort_15233(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_15234","instance":15234,"id":235249,"goal":"method ArrayCopy_15234(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_15235","instance":15235,"id":235250,"goal":"function ListReverse_15235(s: seq): seq\n ensures |ListReverse_15235(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_15235(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_15236","instance":15236,"id":235251,"goal":"function Factorial_15236(n: nat): nat\n ensures Factorial_15236(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_15236(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_15237","instance":15237,"id":235252,"goal":"function Fib_15237(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_15237(n-1) + Fib_15237(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_15238","instance":15238,"id":235253,"goal":"function Gcd_15238(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_15238(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_15239","instance":15239,"id":235254,"goal":"function Power_15239(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_15239(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_15240","instance":15240,"id":235255,"goal":"function Sum_15240(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_15240(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_15241","instance":15241,"id":235256,"goal":"method BinarySearch_15241(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_15242","instance":15242,"id":235257,"goal":"method InsertSort_15242(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_15243","instance":15243,"id":235258,"goal":"method MergeSort_15243(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_15244","instance":15244,"id":235259,"goal":"method ArrayCopy_15244(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_15245","instance":15245,"id":235260,"goal":"function ListReverse_15245(s: seq): seq\n ensures |ListReverse_15245(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_15245(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_15246","instance":15246,"id":235261,"goal":"function Factorial_15246(n: nat): nat\n ensures Factorial_15246(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_15246(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_15247","instance":15247,"id":235262,"goal":"function Fib_15247(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_15247(n-1) + Fib_15247(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_15248","instance":15248,"id":235263,"goal":"function Gcd_15248(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_15248(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_15249","instance":15249,"id":235264,"goal":"function Power_15249(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_15249(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_15250","instance":15250,"id":235265,"goal":"function Sum_15250(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_15250(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_15251","instance":15251,"id":235266,"goal":"method BinarySearch_15251(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_15252","instance":15252,"id":235267,"goal":"method InsertSort_15252(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_15253","instance":15253,"id":235268,"goal":"method MergeSort_15253(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_15254","instance":15254,"id":235269,"goal":"method ArrayCopy_15254(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_15255","instance":15255,"id":235270,"goal":"function ListReverse_15255(s: seq): seq\n ensures |ListReverse_15255(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_15255(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_15256","instance":15256,"id":235271,"goal":"function Factorial_15256(n: nat): nat\n ensures Factorial_15256(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_15256(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_15257","instance":15257,"id":235272,"goal":"function Fib_15257(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_15257(n-1) + Fib_15257(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_15258","instance":15258,"id":235273,"goal":"function Gcd_15258(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_15258(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_15259","instance":15259,"id":235274,"goal":"function Power_15259(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_15259(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_15260","instance":15260,"id":235275,"goal":"function Sum_15260(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_15260(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_15261","instance":15261,"id":235276,"goal":"method BinarySearch_15261(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_15262","instance":15262,"id":235277,"goal":"method InsertSort_15262(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_15263","instance":15263,"id":235278,"goal":"method MergeSort_15263(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_15264","instance":15264,"id":235279,"goal":"method ArrayCopy_15264(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_15265","instance":15265,"id":235280,"goal":"function ListReverse_15265(s: seq): seq\n ensures |ListReverse_15265(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_15265(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_15266","instance":15266,"id":235281,"goal":"function Factorial_15266(n: nat): nat\n ensures Factorial_15266(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_15266(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_15267","instance":15267,"id":235282,"goal":"function Fib_15267(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_15267(n-1) + Fib_15267(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_15268","instance":15268,"id":235283,"goal":"function Gcd_15268(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_15268(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_15269","instance":15269,"id":235284,"goal":"function Power_15269(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_15269(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_15270","instance":15270,"id":235285,"goal":"function Sum_15270(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_15270(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_15271","instance":15271,"id":235286,"goal":"method BinarySearch_15271(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_15272","instance":15272,"id":235287,"goal":"method InsertSort_15272(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_15273","instance":15273,"id":235288,"goal":"method MergeSort_15273(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_15274","instance":15274,"id":235289,"goal":"method ArrayCopy_15274(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_15275","instance":15275,"id":235290,"goal":"function ListReverse_15275(s: seq): seq\n ensures |ListReverse_15275(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_15275(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_15276","instance":15276,"id":235291,"goal":"function Factorial_15276(n: nat): nat\n ensures Factorial_15276(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_15276(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_15277","instance":15277,"id":235292,"goal":"function Fib_15277(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_15277(n-1) + Fib_15277(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_15278","instance":15278,"id":235293,"goal":"function Gcd_15278(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_15278(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_15279","instance":15279,"id":235294,"goal":"function Power_15279(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_15279(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_15280","instance":15280,"id":235295,"goal":"function Sum_15280(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_15280(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_15281","instance":15281,"id":235296,"goal":"method BinarySearch_15281(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_15282","instance":15282,"id":235297,"goal":"method InsertSort_15282(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_15283","instance":15283,"id":235298,"goal":"method MergeSort_15283(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_15284","instance":15284,"id":235299,"goal":"method ArrayCopy_15284(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_15285","instance":15285,"id":235300,"goal":"function ListReverse_15285(s: seq): seq\n ensures |ListReverse_15285(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_15285(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_15286","instance":15286,"id":235301,"goal":"function Factorial_15286(n: nat): nat\n ensures Factorial_15286(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_15286(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_15287","instance":15287,"id":235302,"goal":"function Fib_15287(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_15287(n-1) + Fib_15287(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_15288","instance":15288,"id":235303,"goal":"function Gcd_15288(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_15288(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_15289","instance":15289,"id":235304,"goal":"function Power_15289(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_15289(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_15290","instance":15290,"id":235305,"goal":"function Sum_15290(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_15290(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_15291","instance":15291,"id":235306,"goal":"method BinarySearch_15291(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_15292","instance":15292,"id":235307,"goal":"method InsertSort_15292(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_15293","instance":15293,"id":235308,"goal":"method MergeSort_15293(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_15294","instance":15294,"id":235309,"goal":"method ArrayCopy_15294(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_15295","instance":15295,"id":235310,"goal":"function ListReverse_15295(s: seq): seq\n ensures |ListReverse_15295(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_15295(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_15296","instance":15296,"id":235311,"goal":"function Factorial_15296(n: nat): nat\n ensures Factorial_15296(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_15296(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_15297","instance":15297,"id":235312,"goal":"function Fib_15297(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_15297(n-1) + Fib_15297(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_15298","instance":15298,"id":235313,"goal":"function Gcd_15298(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_15298(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_15299","instance":15299,"id":235314,"goal":"function Power_15299(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_15299(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_15300","instance":15300,"id":235315,"goal":"function Sum_15300(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_15300(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_15301","instance":15301,"id":235316,"goal":"method BinarySearch_15301(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_15302","instance":15302,"id":235317,"goal":"method InsertSort_15302(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_15303","instance":15303,"id":235318,"goal":"method MergeSort_15303(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_15304","instance":15304,"id":235319,"goal":"method ArrayCopy_15304(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_15305","instance":15305,"id":235320,"goal":"function ListReverse_15305(s: seq): seq\n ensures |ListReverse_15305(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_15305(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_15306","instance":15306,"id":235321,"goal":"function Factorial_15306(n: nat): nat\n ensures Factorial_15306(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_15306(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_15307","instance":15307,"id":235322,"goal":"function Fib_15307(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_15307(n-1) + Fib_15307(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_15308","instance":15308,"id":235323,"goal":"function Gcd_15308(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_15308(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_15309","instance":15309,"id":235324,"goal":"function Power_15309(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_15309(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_15310","instance":15310,"id":235325,"goal":"function Sum_15310(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_15310(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_15311","instance":15311,"id":235326,"goal":"method BinarySearch_15311(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_15312","instance":15312,"id":235327,"goal":"method InsertSort_15312(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_15313","instance":15313,"id":235328,"goal":"method MergeSort_15313(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_15314","instance":15314,"id":235329,"goal":"method ArrayCopy_15314(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_15315","instance":15315,"id":235330,"goal":"function ListReverse_15315(s: seq): seq\n ensures |ListReverse_15315(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_15315(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_15316","instance":15316,"id":235331,"goal":"function Factorial_15316(n: nat): nat\n ensures Factorial_15316(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_15316(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_15317","instance":15317,"id":235332,"goal":"function Fib_15317(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_15317(n-1) + Fib_15317(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_15318","instance":15318,"id":235333,"goal":"function Gcd_15318(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_15318(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_15319","instance":15319,"id":235334,"goal":"function Power_15319(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_15319(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_15320","instance":15320,"id":235335,"goal":"function Sum_15320(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_15320(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_15321","instance":15321,"id":235336,"goal":"method BinarySearch_15321(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_15322","instance":15322,"id":235337,"goal":"method InsertSort_15322(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_15323","instance":15323,"id":235338,"goal":"method MergeSort_15323(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_15324","instance":15324,"id":235339,"goal":"method ArrayCopy_15324(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_15325","instance":15325,"id":235340,"goal":"function ListReverse_15325(s: seq): seq\n ensures |ListReverse_15325(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_15325(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_15326","instance":15326,"id":235341,"goal":"function Factorial_15326(n: nat): nat\n ensures Factorial_15326(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_15326(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_15327","instance":15327,"id":235342,"goal":"function Fib_15327(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_15327(n-1) + Fib_15327(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_15328","instance":15328,"id":235343,"goal":"function Gcd_15328(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_15328(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_15329","instance":15329,"id":235344,"goal":"function Power_15329(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_15329(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_15330","instance":15330,"id":235345,"goal":"function Sum_15330(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_15330(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_15331","instance":15331,"id":235346,"goal":"method BinarySearch_15331(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_15332","instance":15332,"id":235347,"goal":"method InsertSort_15332(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_15333","instance":15333,"id":235348,"goal":"method MergeSort_15333(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_15334","instance":15334,"id":235349,"goal":"method ArrayCopy_15334(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_15335","instance":15335,"id":235350,"goal":"function ListReverse_15335(s: seq): seq\n ensures |ListReverse_15335(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_15335(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_15336","instance":15336,"id":235351,"goal":"function Factorial_15336(n: nat): nat\n ensures Factorial_15336(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_15336(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_15337","instance":15337,"id":235352,"goal":"function Fib_15337(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_15337(n-1) + Fib_15337(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_15338","instance":15338,"id":235353,"goal":"function Gcd_15338(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_15338(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_15339","instance":15339,"id":235354,"goal":"function Power_15339(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_15339(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_15340","instance":15340,"id":235355,"goal":"function Sum_15340(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_15340(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_15341","instance":15341,"id":235356,"goal":"method BinarySearch_15341(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_15342","instance":15342,"id":235357,"goal":"method InsertSort_15342(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_15343","instance":15343,"id":235358,"goal":"method MergeSort_15343(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_15344","instance":15344,"id":235359,"goal":"method ArrayCopy_15344(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_15345","instance":15345,"id":235360,"goal":"function ListReverse_15345(s: seq): seq\n ensures |ListReverse_15345(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_15345(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_15346","instance":15346,"id":235361,"goal":"function Factorial_15346(n: nat): nat\n ensures Factorial_15346(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_15346(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_15347","instance":15347,"id":235362,"goal":"function Fib_15347(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_15347(n-1) + Fib_15347(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_15348","instance":15348,"id":235363,"goal":"function Gcd_15348(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_15348(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_15349","instance":15349,"id":235364,"goal":"function Power_15349(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_15349(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_15350","instance":15350,"id":235365,"goal":"function Sum_15350(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_15350(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_15351","instance":15351,"id":235366,"goal":"method BinarySearch_15351(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_15352","instance":15352,"id":235367,"goal":"method InsertSort_15352(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_15353","instance":15353,"id":235368,"goal":"method MergeSort_15353(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_15354","instance":15354,"id":235369,"goal":"method ArrayCopy_15354(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_15355","instance":15355,"id":235370,"goal":"function ListReverse_15355(s: seq): seq\n ensures |ListReverse_15355(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_15355(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_15356","instance":15356,"id":235371,"goal":"function Factorial_15356(n: nat): nat\n ensures Factorial_15356(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_15356(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_15357","instance":15357,"id":235372,"goal":"function Fib_15357(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_15357(n-1) + Fib_15357(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_15358","instance":15358,"id":235373,"goal":"function Gcd_15358(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_15358(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_15359","instance":15359,"id":235374,"goal":"function Power_15359(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_15359(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_15360","instance":15360,"id":235375,"goal":"function Sum_15360(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_15360(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_15361","instance":15361,"id":235376,"goal":"method BinarySearch_15361(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_15362","instance":15362,"id":235377,"goal":"method InsertSort_15362(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_15363","instance":15363,"id":235378,"goal":"method MergeSort_15363(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_15364","instance":15364,"id":235379,"goal":"method ArrayCopy_15364(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_15365","instance":15365,"id":235380,"goal":"function ListReverse_15365(s: seq): seq\n ensures |ListReverse_15365(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_15365(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_15366","instance":15366,"id":235381,"goal":"function Factorial_15366(n: nat): nat\n ensures Factorial_15366(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_15366(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_15367","instance":15367,"id":235382,"goal":"function Fib_15367(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_15367(n-1) + Fib_15367(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_15368","instance":15368,"id":235383,"goal":"function Gcd_15368(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_15368(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_15369","instance":15369,"id":235384,"goal":"function Power_15369(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_15369(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_15370","instance":15370,"id":235385,"goal":"function Sum_15370(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_15370(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_15371","instance":15371,"id":235386,"goal":"method BinarySearch_15371(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_15372","instance":15372,"id":235387,"goal":"method InsertSort_15372(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_15373","instance":15373,"id":235388,"goal":"method MergeSort_15373(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_15374","instance":15374,"id":235389,"goal":"method ArrayCopy_15374(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_15375","instance":15375,"id":235390,"goal":"function ListReverse_15375(s: seq): seq\n ensures |ListReverse_15375(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_15375(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_15376","instance":15376,"id":235391,"goal":"function Factorial_15376(n: nat): nat\n ensures Factorial_15376(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_15376(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_15377","instance":15377,"id":235392,"goal":"function Fib_15377(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_15377(n-1) + Fib_15377(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_15378","instance":15378,"id":235393,"goal":"function Gcd_15378(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_15378(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_15379","instance":15379,"id":235394,"goal":"function Power_15379(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_15379(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_15380","instance":15380,"id":235395,"goal":"function Sum_15380(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_15380(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_15381","instance":15381,"id":235396,"goal":"method BinarySearch_15381(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_15382","instance":15382,"id":235397,"goal":"method InsertSort_15382(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_15383","instance":15383,"id":235398,"goal":"method MergeSort_15383(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_15384","instance":15384,"id":235399,"goal":"method ArrayCopy_15384(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_15385","instance":15385,"id":235400,"goal":"function ListReverse_15385(s: seq): seq\n ensures |ListReverse_15385(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_15385(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_15386","instance":15386,"id":235401,"goal":"function Factorial_15386(n: nat): nat\n ensures Factorial_15386(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_15386(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_15387","instance":15387,"id":235402,"goal":"function Fib_15387(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_15387(n-1) + Fib_15387(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_15388","instance":15388,"id":235403,"goal":"function Gcd_15388(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_15388(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_15389","instance":15389,"id":235404,"goal":"function Power_15389(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_15389(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_15390","instance":15390,"id":235405,"goal":"function Sum_15390(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_15390(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_15391","instance":15391,"id":235406,"goal":"method BinarySearch_15391(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_15392","instance":15392,"id":235407,"goal":"method InsertSort_15392(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_15393","instance":15393,"id":235408,"goal":"method MergeSort_15393(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_15394","instance":15394,"id":235409,"goal":"method ArrayCopy_15394(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_15395","instance":15395,"id":235410,"goal":"function ListReverse_15395(s: seq): seq\n ensures |ListReverse_15395(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_15395(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_15396","instance":15396,"id":235411,"goal":"function Factorial_15396(n: nat): nat\n ensures Factorial_15396(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_15396(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_15397","instance":15397,"id":235412,"goal":"function Fib_15397(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_15397(n-1) + Fib_15397(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_15398","instance":15398,"id":235413,"goal":"function Gcd_15398(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_15398(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_15399","instance":15399,"id":235414,"goal":"function Power_15399(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_15399(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_15400","instance":15400,"id":235415,"goal":"function Sum_15400(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_15400(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_15401","instance":15401,"id":235416,"goal":"method BinarySearch_15401(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_15402","instance":15402,"id":235417,"goal":"method InsertSort_15402(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_15403","instance":15403,"id":235418,"goal":"method MergeSort_15403(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_15404","instance":15404,"id":235419,"goal":"method ArrayCopy_15404(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_15405","instance":15405,"id":235420,"goal":"function ListReverse_15405(s: seq): seq\n ensures |ListReverse_15405(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_15405(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_15406","instance":15406,"id":235421,"goal":"function Factorial_15406(n: nat): nat\n ensures Factorial_15406(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_15406(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_15407","instance":15407,"id":235422,"goal":"function Fib_15407(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_15407(n-1) + Fib_15407(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_15408","instance":15408,"id":235423,"goal":"function Gcd_15408(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_15408(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_15409","instance":15409,"id":235424,"goal":"function Power_15409(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_15409(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_15410","instance":15410,"id":235425,"goal":"function Sum_15410(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_15410(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_15411","instance":15411,"id":235426,"goal":"method BinarySearch_15411(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_15412","instance":15412,"id":235427,"goal":"method InsertSort_15412(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_15413","instance":15413,"id":235428,"goal":"method MergeSort_15413(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_15414","instance":15414,"id":235429,"goal":"method ArrayCopy_15414(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_15415","instance":15415,"id":235430,"goal":"function ListReverse_15415(s: seq): seq\n ensures |ListReverse_15415(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_15415(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_15416","instance":15416,"id":235431,"goal":"function Factorial_15416(n: nat): nat\n ensures Factorial_15416(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_15416(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_15417","instance":15417,"id":235432,"goal":"function Fib_15417(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_15417(n-1) + Fib_15417(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_15418","instance":15418,"id":235433,"goal":"function Gcd_15418(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_15418(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_15419","instance":15419,"id":235434,"goal":"function Power_15419(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_15419(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_15420","instance":15420,"id":235435,"goal":"function Sum_15420(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_15420(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_15421","instance":15421,"id":235436,"goal":"method BinarySearch_15421(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_15422","instance":15422,"id":235437,"goal":"method InsertSort_15422(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_15423","instance":15423,"id":235438,"goal":"method MergeSort_15423(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_15424","instance":15424,"id":235439,"goal":"method ArrayCopy_15424(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_15425","instance":15425,"id":235440,"goal":"function ListReverse_15425(s: seq): seq\n ensures |ListReverse_15425(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_15425(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_15426","instance":15426,"id":235441,"goal":"function Factorial_15426(n: nat): nat\n ensures Factorial_15426(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_15426(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_15427","instance":15427,"id":235442,"goal":"function Fib_15427(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_15427(n-1) + Fib_15427(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_15428","instance":15428,"id":235443,"goal":"function Gcd_15428(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_15428(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_15429","instance":15429,"id":235444,"goal":"function Power_15429(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_15429(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_15430","instance":15430,"id":235445,"goal":"function Sum_15430(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_15430(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_15431","instance":15431,"id":235446,"goal":"method BinarySearch_15431(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_15432","instance":15432,"id":235447,"goal":"method InsertSort_15432(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_15433","instance":15433,"id":235448,"goal":"method MergeSort_15433(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_15434","instance":15434,"id":235449,"goal":"method ArrayCopy_15434(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_15435","instance":15435,"id":235450,"goal":"function ListReverse_15435(s: seq): seq\n ensures |ListReverse_15435(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_15435(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_15436","instance":15436,"id":235451,"goal":"function Factorial_15436(n: nat): nat\n ensures Factorial_15436(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_15436(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_15437","instance":15437,"id":235452,"goal":"function Fib_15437(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_15437(n-1) + Fib_15437(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_15438","instance":15438,"id":235453,"goal":"function Gcd_15438(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_15438(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_15439","instance":15439,"id":235454,"goal":"function Power_15439(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_15439(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_15440","instance":15440,"id":235455,"goal":"function Sum_15440(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_15440(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_15441","instance":15441,"id":235456,"goal":"method BinarySearch_15441(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_15442","instance":15442,"id":235457,"goal":"method InsertSort_15442(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_15443","instance":15443,"id":235458,"goal":"method MergeSort_15443(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_15444","instance":15444,"id":235459,"goal":"method ArrayCopy_15444(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_15445","instance":15445,"id":235460,"goal":"function ListReverse_15445(s: seq): seq\n ensures |ListReverse_15445(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_15445(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_15446","instance":15446,"id":235461,"goal":"function Factorial_15446(n: nat): nat\n ensures Factorial_15446(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_15446(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_15447","instance":15447,"id":235462,"goal":"function Fib_15447(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_15447(n-1) + Fib_15447(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_15448","instance":15448,"id":235463,"goal":"function Gcd_15448(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_15448(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_15449","instance":15449,"id":235464,"goal":"function Power_15449(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_15449(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_15450","instance":15450,"id":235465,"goal":"function Sum_15450(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_15450(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_15451","instance":15451,"id":235466,"goal":"method BinarySearch_15451(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_15452","instance":15452,"id":235467,"goal":"method InsertSort_15452(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_15453","instance":15453,"id":235468,"goal":"method MergeSort_15453(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_15454","instance":15454,"id":235469,"goal":"method ArrayCopy_15454(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_15455","instance":15455,"id":235470,"goal":"function ListReverse_15455(s: seq): seq\n ensures |ListReverse_15455(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_15455(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_15456","instance":15456,"id":235471,"goal":"function Factorial_15456(n: nat): nat\n ensures Factorial_15456(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_15456(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_15457","instance":15457,"id":235472,"goal":"function Fib_15457(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_15457(n-1) + Fib_15457(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_15458","instance":15458,"id":235473,"goal":"function Gcd_15458(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_15458(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_15459","instance":15459,"id":235474,"goal":"function Power_15459(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_15459(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_15460","instance":15460,"id":235475,"goal":"function Sum_15460(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_15460(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_15461","instance":15461,"id":235476,"goal":"method BinarySearch_15461(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_15462","instance":15462,"id":235477,"goal":"method InsertSort_15462(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_15463","instance":15463,"id":235478,"goal":"method MergeSort_15463(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_15464","instance":15464,"id":235479,"goal":"method ArrayCopy_15464(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_15465","instance":15465,"id":235480,"goal":"function ListReverse_15465(s: seq): seq\n ensures |ListReverse_15465(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_15465(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_15466","instance":15466,"id":235481,"goal":"function Factorial_15466(n: nat): nat\n ensures Factorial_15466(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_15466(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_15467","instance":15467,"id":235482,"goal":"function Fib_15467(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_15467(n-1) + Fib_15467(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_15468","instance":15468,"id":235483,"goal":"function Gcd_15468(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_15468(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_15469","instance":15469,"id":235484,"goal":"function Power_15469(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_15469(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_15470","instance":15470,"id":235485,"goal":"function Sum_15470(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_15470(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_15471","instance":15471,"id":235486,"goal":"method BinarySearch_15471(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_15472","instance":15472,"id":235487,"goal":"method InsertSort_15472(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_15473","instance":15473,"id":235488,"goal":"method MergeSort_15473(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_15474","instance":15474,"id":235489,"goal":"method ArrayCopy_15474(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_15475","instance":15475,"id":235490,"goal":"function ListReverse_15475(s: seq): seq\n ensures |ListReverse_15475(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_15475(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_15476","instance":15476,"id":235491,"goal":"function Factorial_15476(n: nat): nat\n ensures Factorial_15476(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_15476(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_15477","instance":15477,"id":235492,"goal":"function Fib_15477(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_15477(n-1) + Fib_15477(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_15478","instance":15478,"id":235493,"goal":"function Gcd_15478(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_15478(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_15479","instance":15479,"id":235494,"goal":"function Power_15479(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_15479(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_15480","instance":15480,"id":235495,"goal":"function Sum_15480(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_15480(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_15481","instance":15481,"id":235496,"goal":"method BinarySearch_15481(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_15482","instance":15482,"id":235497,"goal":"method InsertSort_15482(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_15483","instance":15483,"id":235498,"goal":"method MergeSort_15483(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_15484","instance":15484,"id":235499,"goal":"method ArrayCopy_15484(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_15485","instance":15485,"id":235500,"goal":"function ListReverse_15485(s: seq): seq\n ensures |ListReverse_15485(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_15485(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_15486","instance":15486,"id":235501,"goal":"function Factorial_15486(n: nat): nat\n ensures Factorial_15486(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_15486(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_15487","instance":15487,"id":235502,"goal":"function Fib_15487(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_15487(n-1) + Fib_15487(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_15488","instance":15488,"id":235503,"goal":"function Gcd_15488(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_15488(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_15489","instance":15489,"id":235504,"goal":"function Power_15489(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_15489(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_15490","instance":15490,"id":235505,"goal":"function Sum_15490(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_15490(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_15491","instance":15491,"id":235506,"goal":"method BinarySearch_15491(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_15492","instance":15492,"id":235507,"goal":"method InsertSort_15492(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_15493","instance":15493,"id":235508,"goal":"method MergeSort_15493(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_15494","instance":15494,"id":235509,"goal":"method ArrayCopy_15494(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_15495","instance":15495,"id":235510,"goal":"function ListReverse_15495(s: seq): seq\n ensures |ListReverse_15495(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_15495(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_15496","instance":15496,"id":235511,"goal":"function Factorial_15496(n: nat): nat\n ensures Factorial_15496(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_15496(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_15497","instance":15497,"id":235512,"goal":"function Fib_15497(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_15497(n-1) + Fib_15497(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_15498","instance":15498,"id":235513,"goal":"function Gcd_15498(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_15498(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_15499","instance":15499,"id":235514,"goal":"function Power_15499(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_15499(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_15500","instance":15500,"id":235515,"goal":"function Sum_15500(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_15500(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_15501","instance":15501,"id":235516,"goal":"method BinarySearch_15501(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_15502","instance":15502,"id":235517,"goal":"method InsertSort_15502(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_15503","instance":15503,"id":235518,"goal":"method MergeSort_15503(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_15504","instance":15504,"id":235519,"goal":"method ArrayCopy_15504(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_15505","instance":15505,"id":235520,"goal":"function ListReverse_15505(s: seq): seq\n ensures |ListReverse_15505(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_15505(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_15506","instance":15506,"id":235521,"goal":"function Factorial_15506(n: nat): nat\n ensures Factorial_15506(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_15506(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_15507","instance":15507,"id":235522,"goal":"function Fib_15507(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_15507(n-1) + Fib_15507(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_15508","instance":15508,"id":235523,"goal":"function Gcd_15508(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_15508(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_15509","instance":15509,"id":235524,"goal":"function Power_15509(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_15509(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_15510","instance":15510,"id":235525,"goal":"function Sum_15510(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_15510(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_15511","instance":15511,"id":235526,"goal":"method BinarySearch_15511(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_15512","instance":15512,"id":235527,"goal":"method InsertSort_15512(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_15513","instance":15513,"id":235528,"goal":"method MergeSort_15513(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_15514","instance":15514,"id":235529,"goal":"method ArrayCopy_15514(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_15515","instance":15515,"id":235530,"goal":"function ListReverse_15515(s: seq): seq\n ensures |ListReverse_15515(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_15515(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_15516","instance":15516,"id":235531,"goal":"function Factorial_15516(n: nat): nat\n ensures Factorial_15516(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_15516(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_15517","instance":15517,"id":235532,"goal":"function Fib_15517(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_15517(n-1) + Fib_15517(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_15518","instance":15518,"id":235533,"goal":"function Gcd_15518(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_15518(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_15519","instance":15519,"id":235534,"goal":"function Power_15519(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_15519(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_15520","instance":15520,"id":235535,"goal":"function Sum_15520(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_15520(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_15521","instance":15521,"id":235536,"goal":"method BinarySearch_15521(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_15522","instance":15522,"id":235537,"goal":"method InsertSort_15522(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_15523","instance":15523,"id":235538,"goal":"method MergeSort_15523(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_15524","instance":15524,"id":235539,"goal":"method ArrayCopy_15524(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_15525","instance":15525,"id":235540,"goal":"function ListReverse_15525(s: seq): seq\n ensures |ListReverse_15525(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_15525(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_15526","instance":15526,"id":235541,"goal":"function Factorial_15526(n: nat): nat\n ensures Factorial_15526(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_15526(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_15527","instance":15527,"id":235542,"goal":"function Fib_15527(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_15527(n-1) + Fib_15527(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_15528","instance":15528,"id":235543,"goal":"function Gcd_15528(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_15528(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_15529","instance":15529,"id":235544,"goal":"function Power_15529(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_15529(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_15530","instance":15530,"id":235545,"goal":"function Sum_15530(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_15530(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_15531","instance":15531,"id":235546,"goal":"method BinarySearch_15531(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_15532","instance":15532,"id":235547,"goal":"method InsertSort_15532(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_15533","instance":15533,"id":235548,"goal":"method MergeSort_15533(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_15534","instance":15534,"id":235549,"goal":"method ArrayCopy_15534(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_15535","instance":15535,"id":235550,"goal":"function ListReverse_15535(s: seq): seq\n ensures |ListReverse_15535(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_15535(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_15536","instance":15536,"id":235551,"goal":"function Factorial_15536(n: nat): nat\n ensures Factorial_15536(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_15536(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_15537","instance":15537,"id":235552,"goal":"function Fib_15537(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_15537(n-1) + Fib_15537(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_15538","instance":15538,"id":235553,"goal":"function Gcd_15538(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_15538(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_15539","instance":15539,"id":235554,"goal":"function Power_15539(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_15539(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_15540","instance":15540,"id":235555,"goal":"function Sum_15540(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_15540(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_15541","instance":15541,"id":235556,"goal":"method BinarySearch_15541(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_15542","instance":15542,"id":235557,"goal":"method InsertSort_15542(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_15543","instance":15543,"id":235558,"goal":"method MergeSort_15543(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_15544","instance":15544,"id":235559,"goal":"method ArrayCopy_15544(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_15545","instance":15545,"id":235560,"goal":"function ListReverse_15545(s: seq): seq\n ensures |ListReverse_15545(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_15545(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_15546","instance":15546,"id":235561,"goal":"function Factorial_15546(n: nat): nat\n ensures Factorial_15546(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_15546(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_15547","instance":15547,"id":235562,"goal":"function Fib_15547(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_15547(n-1) + Fib_15547(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_15548","instance":15548,"id":235563,"goal":"function Gcd_15548(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_15548(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_15549","instance":15549,"id":235564,"goal":"function Power_15549(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_15549(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_15550","instance":15550,"id":235565,"goal":"function Sum_15550(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_15550(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_15551","instance":15551,"id":235566,"goal":"method BinarySearch_15551(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_15552","instance":15552,"id":235567,"goal":"method InsertSort_15552(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_15553","instance":15553,"id":235568,"goal":"method MergeSort_15553(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_15554","instance":15554,"id":235569,"goal":"method ArrayCopy_15554(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_15555","instance":15555,"id":235570,"goal":"function ListReverse_15555(s: seq): seq\n ensures |ListReverse_15555(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_15555(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_15556","instance":15556,"id":235571,"goal":"function Factorial_15556(n: nat): nat\n ensures Factorial_15556(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_15556(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_15557","instance":15557,"id":235572,"goal":"function Fib_15557(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_15557(n-1) + Fib_15557(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_15558","instance":15558,"id":235573,"goal":"function Gcd_15558(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_15558(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_15559","instance":15559,"id":235574,"goal":"function Power_15559(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_15559(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_15560","instance":15560,"id":235575,"goal":"function Sum_15560(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_15560(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_15561","instance":15561,"id":235576,"goal":"method BinarySearch_15561(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_15562","instance":15562,"id":235577,"goal":"method InsertSort_15562(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_15563","instance":15563,"id":235578,"goal":"method MergeSort_15563(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_15564","instance":15564,"id":235579,"goal":"method ArrayCopy_15564(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_15565","instance":15565,"id":235580,"goal":"function ListReverse_15565(s: seq): seq\n ensures |ListReverse_15565(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_15565(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_15566","instance":15566,"id":235581,"goal":"function Factorial_15566(n: nat): nat\n ensures Factorial_15566(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_15566(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_15567","instance":15567,"id":235582,"goal":"function Fib_15567(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_15567(n-1) + Fib_15567(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_15568","instance":15568,"id":235583,"goal":"function Gcd_15568(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_15568(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_15569","instance":15569,"id":235584,"goal":"function Power_15569(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_15569(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_15570","instance":15570,"id":235585,"goal":"function Sum_15570(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_15570(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_15571","instance":15571,"id":235586,"goal":"method BinarySearch_15571(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_15572","instance":15572,"id":235587,"goal":"method InsertSort_15572(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_15573","instance":15573,"id":235588,"goal":"method MergeSort_15573(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_15574","instance":15574,"id":235589,"goal":"method ArrayCopy_15574(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_15575","instance":15575,"id":235590,"goal":"function ListReverse_15575(s: seq): seq\n ensures |ListReverse_15575(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_15575(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_15576","instance":15576,"id":235591,"goal":"function Factorial_15576(n: nat): nat\n ensures Factorial_15576(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_15576(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_15577","instance":15577,"id":235592,"goal":"function Fib_15577(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_15577(n-1) + Fib_15577(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_15578","instance":15578,"id":235593,"goal":"function Gcd_15578(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_15578(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_15579","instance":15579,"id":235594,"goal":"function Power_15579(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_15579(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_15580","instance":15580,"id":235595,"goal":"function Sum_15580(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_15580(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_15581","instance":15581,"id":235596,"goal":"method BinarySearch_15581(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_15582","instance":15582,"id":235597,"goal":"method InsertSort_15582(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_15583","instance":15583,"id":235598,"goal":"method MergeSort_15583(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_15584","instance":15584,"id":235599,"goal":"method ArrayCopy_15584(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_15585","instance":15585,"id":235600,"goal":"function ListReverse_15585(s: seq): seq\n ensures |ListReverse_15585(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_15585(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_15586","instance":15586,"id":235601,"goal":"function Factorial_15586(n: nat): nat\n ensures Factorial_15586(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_15586(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_15587","instance":15587,"id":235602,"goal":"function Fib_15587(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_15587(n-1) + Fib_15587(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_15588","instance":15588,"id":235603,"goal":"function Gcd_15588(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_15588(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_15589","instance":15589,"id":235604,"goal":"function Power_15589(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_15589(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_15590","instance":15590,"id":235605,"goal":"function Sum_15590(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_15590(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_15591","instance":15591,"id":235606,"goal":"method BinarySearch_15591(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_15592","instance":15592,"id":235607,"goal":"method InsertSort_15592(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_15593","instance":15593,"id":235608,"goal":"method MergeSort_15593(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_15594","instance":15594,"id":235609,"goal":"method ArrayCopy_15594(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_15595","instance":15595,"id":235610,"goal":"function ListReverse_15595(s: seq): seq\n ensures |ListReverse_15595(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_15595(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_15596","instance":15596,"id":235611,"goal":"function Factorial_15596(n: nat): nat\n ensures Factorial_15596(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_15596(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_15597","instance":15597,"id":235612,"goal":"function Fib_15597(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_15597(n-1) + Fib_15597(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_15598","instance":15598,"id":235613,"goal":"function Gcd_15598(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_15598(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_15599","instance":15599,"id":235614,"goal":"function Power_15599(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_15599(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_15600","instance":15600,"id":235615,"goal":"function Sum_15600(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_15600(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_15601","instance":15601,"id":235616,"goal":"method BinarySearch_15601(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_15602","instance":15602,"id":235617,"goal":"method InsertSort_15602(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_15603","instance":15603,"id":235618,"goal":"method MergeSort_15603(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_15604","instance":15604,"id":235619,"goal":"method ArrayCopy_15604(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_15605","instance":15605,"id":235620,"goal":"function ListReverse_15605(s: seq): seq\n ensures |ListReverse_15605(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_15605(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_15606","instance":15606,"id":235621,"goal":"function Factorial_15606(n: nat): nat\n ensures Factorial_15606(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_15606(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_15607","instance":15607,"id":235622,"goal":"function Fib_15607(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_15607(n-1) + Fib_15607(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_15608","instance":15608,"id":235623,"goal":"function Gcd_15608(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_15608(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_15609","instance":15609,"id":235624,"goal":"function Power_15609(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_15609(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_15610","instance":15610,"id":235625,"goal":"function Sum_15610(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_15610(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_15611","instance":15611,"id":235626,"goal":"method BinarySearch_15611(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_15612","instance":15612,"id":235627,"goal":"method InsertSort_15612(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_15613","instance":15613,"id":235628,"goal":"method MergeSort_15613(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_15614","instance":15614,"id":235629,"goal":"method ArrayCopy_15614(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_15615","instance":15615,"id":235630,"goal":"function ListReverse_15615(s: seq): seq\n ensures |ListReverse_15615(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_15615(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_15616","instance":15616,"id":235631,"goal":"function Factorial_15616(n: nat): nat\n ensures Factorial_15616(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_15616(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_15617","instance":15617,"id":235632,"goal":"function Fib_15617(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_15617(n-1) + Fib_15617(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_15618","instance":15618,"id":235633,"goal":"function Gcd_15618(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_15618(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_15619","instance":15619,"id":235634,"goal":"function Power_15619(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_15619(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_15620","instance":15620,"id":235635,"goal":"function Sum_15620(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_15620(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_15621","instance":15621,"id":235636,"goal":"method BinarySearch_15621(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_15622","instance":15622,"id":235637,"goal":"method InsertSort_15622(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_15623","instance":15623,"id":235638,"goal":"method MergeSort_15623(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_15624","instance":15624,"id":235639,"goal":"method ArrayCopy_15624(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_15625","instance":15625,"id":235640,"goal":"function ListReverse_15625(s: seq): seq\n ensures |ListReverse_15625(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_15625(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_15626","instance":15626,"id":235641,"goal":"function Factorial_15626(n: nat): nat\n ensures Factorial_15626(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_15626(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_15627","instance":15627,"id":235642,"goal":"function Fib_15627(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_15627(n-1) + Fib_15627(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_15628","instance":15628,"id":235643,"goal":"function Gcd_15628(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_15628(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_15629","instance":15629,"id":235644,"goal":"function Power_15629(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_15629(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_15630","instance":15630,"id":235645,"goal":"function Sum_15630(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_15630(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_15631","instance":15631,"id":235646,"goal":"method BinarySearch_15631(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_15632","instance":15632,"id":235647,"goal":"method InsertSort_15632(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_15633","instance":15633,"id":235648,"goal":"method MergeSort_15633(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_15634","instance":15634,"id":235649,"goal":"method ArrayCopy_15634(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_15635","instance":15635,"id":235650,"goal":"function ListReverse_15635(s: seq): seq\n ensures |ListReverse_15635(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_15635(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_15636","instance":15636,"id":235651,"goal":"function Factorial_15636(n: nat): nat\n ensures Factorial_15636(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_15636(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_15637","instance":15637,"id":235652,"goal":"function Fib_15637(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_15637(n-1) + Fib_15637(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_15638","instance":15638,"id":235653,"goal":"function Gcd_15638(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_15638(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_15639","instance":15639,"id":235654,"goal":"function Power_15639(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_15639(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_15640","instance":15640,"id":235655,"goal":"function Sum_15640(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_15640(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_15641","instance":15641,"id":235656,"goal":"method BinarySearch_15641(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_15642","instance":15642,"id":235657,"goal":"method InsertSort_15642(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_15643","instance":15643,"id":235658,"goal":"method MergeSort_15643(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_15644","instance":15644,"id":235659,"goal":"method ArrayCopy_15644(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_15645","instance":15645,"id":235660,"goal":"function ListReverse_15645(s: seq): seq\n ensures |ListReverse_15645(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_15645(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_15646","instance":15646,"id":235661,"goal":"function Factorial_15646(n: nat): nat\n ensures Factorial_15646(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_15646(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_15647","instance":15647,"id":235662,"goal":"function Fib_15647(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_15647(n-1) + Fib_15647(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_15648","instance":15648,"id":235663,"goal":"function Gcd_15648(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_15648(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_15649","instance":15649,"id":235664,"goal":"function Power_15649(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_15649(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_15650","instance":15650,"id":235665,"goal":"function Sum_15650(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_15650(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_15651","instance":15651,"id":235666,"goal":"method BinarySearch_15651(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_15652","instance":15652,"id":235667,"goal":"method InsertSort_15652(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_15653","instance":15653,"id":235668,"goal":"method MergeSort_15653(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_15654","instance":15654,"id":235669,"goal":"method ArrayCopy_15654(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_15655","instance":15655,"id":235670,"goal":"function ListReverse_15655(s: seq): seq\n ensures |ListReverse_15655(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_15655(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_15656","instance":15656,"id":235671,"goal":"function Factorial_15656(n: nat): nat\n ensures Factorial_15656(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_15656(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_15657","instance":15657,"id":235672,"goal":"function Fib_15657(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_15657(n-1) + Fib_15657(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_15658","instance":15658,"id":235673,"goal":"function Gcd_15658(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_15658(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_15659","instance":15659,"id":235674,"goal":"function Power_15659(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_15659(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_15660","instance":15660,"id":235675,"goal":"function Sum_15660(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_15660(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_15661","instance":15661,"id":235676,"goal":"method BinarySearch_15661(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_15662","instance":15662,"id":235677,"goal":"method InsertSort_15662(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_15663","instance":15663,"id":235678,"goal":"method MergeSort_15663(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_15664","instance":15664,"id":235679,"goal":"method ArrayCopy_15664(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_15665","instance":15665,"id":235680,"goal":"function ListReverse_15665(s: seq): seq\n ensures |ListReverse_15665(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_15665(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_15666","instance":15666,"id":235681,"goal":"function Factorial_15666(n: nat): nat\n ensures Factorial_15666(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_15666(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_15667","instance":15667,"id":235682,"goal":"function Fib_15667(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_15667(n-1) + Fib_15667(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_15668","instance":15668,"id":235683,"goal":"function Gcd_15668(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_15668(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_15669","instance":15669,"id":235684,"goal":"function Power_15669(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_15669(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_15670","instance":15670,"id":235685,"goal":"function Sum_15670(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_15670(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_15671","instance":15671,"id":235686,"goal":"method BinarySearch_15671(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_15672","instance":15672,"id":235687,"goal":"method InsertSort_15672(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_15673","instance":15673,"id":235688,"goal":"method MergeSort_15673(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_15674","instance":15674,"id":235689,"goal":"method ArrayCopy_15674(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_15675","instance":15675,"id":235690,"goal":"function ListReverse_15675(s: seq): seq\n ensures |ListReverse_15675(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_15675(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_15676","instance":15676,"id":235691,"goal":"function Factorial_15676(n: nat): nat\n ensures Factorial_15676(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_15676(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_15677","instance":15677,"id":235692,"goal":"function Fib_15677(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_15677(n-1) + Fib_15677(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_15678","instance":15678,"id":235693,"goal":"function Gcd_15678(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_15678(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_15679","instance":15679,"id":235694,"goal":"function Power_15679(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_15679(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_15680","instance":15680,"id":235695,"goal":"function Sum_15680(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_15680(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_15681","instance":15681,"id":235696,"goal":"method BinarySearch_15681(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_15682","instance":15682,"id":235697,"goal":"method InsertSort_15682(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_15683","instance":15683,"id":235698,"goal":"method MergeSort_15683(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_15684","instance":15684,"id":235699,"goal":"method ArrayCopy_15684(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_15685","instance":15685,"id":235700,"goal":"function ListReverse_15685(s: seq): seq\n ensures |ListReverse_15685(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_15685(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_15686","instance":15686,"id":235701,"goal":"function Factorial_15686(n: nat): nat\n ensures Factorial_15686(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_15686(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_15687","instance":15687,"id":235702,"goal":"function Fib_15687(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_15687(n-1) + Fib_15687(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_15688","instance":15688,"id":235703,"goal":"function Gcd_15688(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_15688(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_15689","instance":15689,"id":235704,"goal":"function Power_15689(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_15689(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_15690","instance":15690,"id":235705,"goal":"function Sum_15690(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_15690(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_15691","instance":15691,"id":235706,"goal":"method BinarySearch_15691(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_15692","instance":15692,"id":235707,"goal":"method InsertSort_15692(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_15693","instance":15693,"id":235708,"goal":"method MergeSort_15693(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_15694","instance":15694,"id":235709,"goal":"method ArrayCopy_15694(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_15695","instance":15695,"id":235710,"goal":"function ListReverse_15695(s: seq): seq\n ensures |ListReverse_15695(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_15695(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_15696","instance":15696,"id":235711,"goal":"function Factorial_15696(n: nat): nat\n ensures Factorial_15696(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_15696(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_15697","instance":15697,"id":235712,"goal":"function Fib_15697(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_15697(n-1) + Fib_15697(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_15698","instance":15698,"id":235713,"goal":"function Gcd_15698(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_15698(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_15699","instance":15699,"id":235714,"goal":"function Power_15699(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_15699(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_15700","instance":15700,"id":235715,"goal":"function Sum_15700(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_15700(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_15701","instance":15701,"id":235716,"goal":"method BinarySearch_15701(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_15702","instance":15702,"id":235717,"goal":"method InsertSort_15702(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_15703","instance":15703,"id":235718,"goal":"method MergeSort_15703(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_15704","instance":15704,"id":235719,"goal":"method ArrayCopy_15704(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_15705","instance":15705,"id":235720,"goal":"function ListReverse_15705(s: seq): seq\n ensures |ListReverse_15705(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_15705(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_15706","instance":15706,"id":235721,"goal":"function Factorial_15706(n: nat): nat\n ensures Factorial_15706(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_15706(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_15707","instance":15707,"id":235722,"goal":"function Fib_15707(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_15707(n-1) + Fib_15707(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_15708","instance":15708,"id":235723,"goal":"function Gcd_15708(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_15708(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_15709","instance":15709,"id":235724,"goal":"function Power_15709(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_15709(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_15710","instance":15710,"id":235725,"goal":"function Sum_15710(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_15710(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_15711","instance":15711,"id":235726,"goal":"method BinarySearch_15711(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_15712","instance":15712,"id":235727,"goal":"method InsertSort_15712(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_15713","instance":15713,"id":235728,"goal":"method MergeSort_15713(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_15714","instance":15714,"id":235729,"goal":"method ArrayCopy_15714(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_15715","instance":15715,"id":235730,"goal":"function ListReverse_15715(s: seq): seq\n ensures |ListReverse_15715(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_15715(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_15716","instance":15716,"id":235731,"goal":"function Factorial_15716(n: nat): nat\n ensures Factorial_15716(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_15716(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_15717","instance":15717,"id":235732,"goal":"function Fib_15717(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_15717(n-1) + Fib_15717(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_15718","instance":15718,"id":235733,"goal":"function Gcd_15718(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_15718(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_15719","instance":15719,"id":235734,"goal":"function Power_15719(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_15719(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_15720","instance":15720,"id":235735,"goal":"function Sum_15720(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_15720(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_15721","instance":15721,"id":235736,"goal":"method BinarySearch_15721(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_15722","instance":15722,"id":235737,"goal":"method InsertSort_15722(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_15723","instance":15723,"id":235738,"goal":"method MergeSort_15723(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_15724","instance":15724,"id":235739,"goal":"method ArrayCopy_15724(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_15725","instance":15725,"id":235740,"goal":"function ListReverse_15725(s: seq): seq\n ensures |ListReverse_15725(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_15725(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_15726","instance":15726,"id":235741,"goal":"function Factorial_15726(n: nat): nat\n ensures Factorial_15726(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_15726(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_15727","instance":15727,"id":235742,"goal":"function Fib_15727(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_15727(n-1) + Fib_15727(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_15728","instance":15728,"id":235743,"goal":"function Gcd_15728(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_15728(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_15729","instance":15729,"id":235744,"goal":"function Power_15729(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_15729(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_15730","instance":15730,"id":235745,"goal":"function Sum_15730(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_15730(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_15731","instance":15731,"id":235746,"goal":"method BinarySearch_15731(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_15732","instance":15732,"id":235747,"goal":"method InsertSort_15732(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_15733","instance":15733,"id":235748,"goal":"method MergeSort_15733(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_15734","instance":15734,"id":235749,"goal":"method ArrayCopy_15734(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_15735","instance":15735,"id":235750,"goal":"function ListReverse_15735(s: seq): seq\n ensures |ListReverse_15735(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_15735(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_15736","instance":15736,"id":235751,"goal":"function Factorial_15736(n: nat): nat\n ensures Factorial_15736(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_15736(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_15737","instance":15737,"id":235752,"goal":"function Fib_15737(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_15737(n-1) + Fib_15737(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_15738","instance":15738,"id":235753,"goal":"function Gcd_15738(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_15738(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_15739","instance":15739,"id":235754,"goal":"function Power_15739(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_15739(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_15740","instance":15740,"id":235755,"goal":"function Sum_15740(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_15740(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_15741","instance":15741,"id":235756,"goal":"method BinarySearch_15741(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_15742","instance":15742,"id":235757,"goal":"method InsertSort_15742(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_15743","instance":15743,"id":235758,"goal":"method MergeSort_15743(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_15744","instance":15744,"id":235759,"goal":"method ArrayCopy_15744(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_15745","instance":15745,"id":235760,"goal":"function ListReverse_15745(s: seq): seq\n ensures |ListReverse_15745(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_15745(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_15746","instance":15746,"id":235761,"goal":"function Factorial_15746(n: nat): nat\n ensures Factorial_15746(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_15746(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_15747","instance":15747,"id":235762,"goal":"function Fib_15747(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_15747(n-1) + Fib_15747(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_15748","instance":15748,"id":235763,"goal":"function Gcd_15748(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_15748(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_15749","instance":15749,"id":235764,"goal":"function Power_15749(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_15749(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_15750","instance":15750,"id":235765,"goal":"function Sum_15750(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_15750(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_15751","instance":15751,"id":235766,"goal":"method BinarySearch_15751(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_15752","instance":15752,"id":235767,"goal":"method InsertSort_15752(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_15753","instance":15753,"id":235768,"goal":"method MergeSort_15753(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_15754","instance":15754,"id":235769,"goal":"method ArrayCopy_15754(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_15755","instance":15755,"id":235770,"goal":"function ListReverse_15755(s: seq): seq\n ensures |ListReverse_15755(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_15755(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_15756","instance":15756,"id":235771,"goal":"function Factorial_15756(n: nat): nat\n ensures Factorial_15756(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_15756(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_15757","instance":15757,"id":235772,"goal":"function Fib_15757(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_15757(n-1) + Fib_15757(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_15758","instance":15758,"id":235773,"goal":"function Gcd_15758(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_15758(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_15759","instance":15759,"id":235774,"goal":"function Power_15759(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_15759(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_15760","instance":15760,"id":235775,"goal":"function Sum_15760(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_15760(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_15761","instance":15761,"id":235776,"goal":"method BinarySearch_15761(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_15762","instance":15762,"id":235777,"goal":"method InsertSort_15762(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_15763","instance":15763,"id":235778,"goal":"method MergeSort_15763(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_15764","instance":15764,"id":235779,"goal":"method ArrayCopy_15764(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_15765","instance":15765,"id":235780,"goal":"function ListReverse_15765(s: seq): seq\n ensures |ListReverse_15765(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_15765(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_15766","instance":15766,"id":235781,"goal":"function Factorial_15766(n: nat): nat\n ensures Factorial_15766(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_15766(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_15767","instance":15767,"id":235782,"goal":"function Fib_15767(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_15767(n-1) + Fib_15767(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_15768","instance":15768,"id":235783,"goal":"function Gcd_15768(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_15768(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_15769","instance":15769,"id":235784,"goal":"function Power_15769(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_15769(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_15770","instance":15770,"id":235785,"goal":"function Sum_15770(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_15770(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_15771","instance":15771,"id":235786,"goal":"method BinarySearch_15771(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_15772","instance":15772,"id":235787,"goal":"method InsertSort_15772(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_15773","instance":15773,"id":235788,"goal":"method MergeSort_15773(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_15774","instance":15774,"id":235789,"goal":"method ArrayCopy_15774(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_15775","instance":15775,"id":235790,"goal":"function ListReverse_15775(s: seq): seq\n ensures |ListReverse_15775(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_15775(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_15776","instance":15776,"id":235791,"goal":"function Factorial_15776(n: nat): nat\n ensures Factorial_15776(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_15776(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_15777","instance":15777,"id":235792,"goal":"function Fib_15777(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_15777(n-1) + Fib_15777(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_15778","instance":15778,"id":235793,"goal":"function Gcd_15778(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_15778(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_15779","instance":15779,"id":235794,"goal":"function Power_15779(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_15779(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_15780","instance":15780,"id":235795,"goal":"function Sum_15780(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_15780(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_15781","instance":15781,"id":235796,"goal":"method BinarySearch_15781(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_15782","instance":15782,"id":235797,"goal":"method InsertSort_15782(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_15783","instance":15783,"id":235798,"goal":"method MergeSort_15783(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_15784","instance":15784,"id":235799,"goal":"method ArrayCopy_15784(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_15785","instance":15785,"id":235800,"goal":"function ListReverse_15785(s: seq): seq\n ensures |ListReverse_15785(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_15785(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_15786","instance":15786,"id":235801,"goal":"function Factorial_15786(n: nat): nat\n ensures Factorial_15786(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_15786(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_15787","instance":15787,"id":235802,"goal":"function Fib_15787(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_15787(n-1) + Fib_15787(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_15788","instance":15788,"id":235803,"goal":"function Gcd_15788(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_15788(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_15789","instance":15789,"id":235804,"goal":"function Power_15789(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_15789(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_15790","instance":15790,"id":235805,"goal":"function Sum_15790(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_15790(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_15791","instance":15791,"id":235806,"goal":"method BinarySearch_15791(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_15792","instance":15792,"id":235807,"goal":"method InsertSort_15792(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_15793","instance":15793,"id":235808,"goal":"method MergeSort_15793(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_15794","instance":15794,"id":235809,"goal":"method ArrayCopy_15794(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_15795","instance":15795,"id":235810,"goal":"function ListReverse_15795(s: seq): seq\n ensures |ListReverse_15795(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_15795(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_15796","instance":15796,"id":235811,"goal":"function Factorial_15796(n: nat): nat\n ensures Factorial_15796(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_15796(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_15797","instance":15797,"id":235812,"goal":"function Fib_15797(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_15797(n-1) + Fib_15797(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_15798","instance":15798,"id":235813,"goal":"function Gcd_15798(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_15798(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_15799","instance":15799,"id":235814,"goal":"function Power_15799(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_15799(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_15800","instance":15800,"id":235815,"goal":"function Sum_15800(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_15800(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_15801","instance":15801,"id":235816,"goal":"method BinarySearch_15801(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_15802","instance":15802,"id":235817,"goal":"method InsertSort_15802(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_15803","instance":15803,"id":235818,"goal":"method MergeSort_15803(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_15804","instance":15804,"id":235819,"goal":"method ArrayCopy_15804(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_15805","instance":15805,"id":235820,"goal":"function ListReverse_15805(s: seq): seq\n ensures |ListReverse_15805(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_15805(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_15806","instance":15806,"id":235821,"goal":"function Factorial_15806(n: nat): nat\n ensures Factorial_15806(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_15806(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_15807","instance":15807,"id":235822,"goal":"function Fib_15807(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_15807(n-1) + Fib_15807(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_15808","instance":15808,"id":235823,"goal":"function Gcd_15808(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_15808(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_15809","instance":15809,"id":235824,"goal":"function Power_15809(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_15809(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_15810","instance":15810,"id":235825,"goal":"function Sum_15810(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_15810(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_15811","instance":15811,"id":235826,"goal":"method BinarySearch_15811(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_15812","instance":15812,"id":235827,"goal":"method InsertSort_15812(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_15813","instance":15813,"id":235828,"goal":"method MergeSort_15813(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_15814","instance":15814,"id":235829,"goal":"method ArrayCopy_15814(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_15815","instance":15815,"id":235830,"goal":"function ListReverse_15815(s: seq): seq\n ensures |ListReverse_15815(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_15815(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_15816","instance":15816,"id":235831,"goal":"function Factorial_15816(n: nat): nat\n ensures Factorial_15816(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_15816(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_15817","instance":15817,"id":235832,"goal":"function Fib_15817(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_15817(n-1) + Fib_15817(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_15818","instance":15818,"id":235833,"goal":"function Gcd_15818(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_15818(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_15819","instance":15819,"id":235834,"goal":"function Power_15819(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_15819(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_15820","instance":15820,"id":235835,"goal":"function Sum_15820(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_15820(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_15821","instance":15821,"id":235836,"goal":"method BinarySearch_15821(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_15822","instance":15822,"id":235837,"goal":"method InsertSort_15822(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_15823","instance":15823,"id":235838,"goal":"method MergeSort_15823(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_15824","instance":15824,"id":235839,"goal":"method ArrayCopy_15824(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_15825","instance":15825,"id":235840,"goal":"function ListReverse_15825(s: seq): seq\n ensures |ListReverse_15825(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_15825(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_15826","instance":15826,"id":235841,"goal":"function Factorial_15826(n: nat): nat\n ensures Factorial_15826(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_15826(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_15827","instance":15827,"id":235842,"goal":"function Fib_15827(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_15827(n-1) + Fib_15827(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_15828","instance":15828,"id":235843,"goal":"function Gcd_15828(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_15828(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_15829","instance":15829,"id":235844,"goal":"function Power_15829(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_15829(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_15830","instance":15830,"id":235845,"goal":"function Sum_15830(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_15830(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_15831","instance":15831,"id":235846,"goal":"method BinarySearch_15831(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_15832","instance":15832,"id":235847,"goal":"method InsertSort_15832(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_15833","instance":15833,"id":235848,"goal":"method MergeSort_15833(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_15834","instance":15834,"id":235849,"goal":"method ArrayCopy_15834(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_15835","instance":15835,"id":235850,"goal":"function ListReverse_15835(s: seq): seq\n ensures |ListReverse_15835(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_15835(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_15836","instance":15836,"id":235851,"goal":"function Factorial_15836(n: nat): nat\n ensures Factorial_15836(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_15836(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_15837","instance":15837,"id":235852,"goal":"function Fib_15837(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_15837(n-1) + Fib_15837(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_15838","instance":15838,"id":235853,"goal":"function Gcd_15838(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_15838(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_15839","instance":15839,"id":235854,"goal":"function Power_15839(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_15839(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_15840","instance":15840,"id":235855,"goal":"function Sum_15840(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_15840(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_15841","instance":15841,"id":235856,"goal":"method BinarySearch_15841(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_15842","instance":15842,"id":235857,"goal":"method InsertSort_15842(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_15843","instance":15843,"id":235858,"goal":"method MergeSort_15843(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_15844","instance":15844,"id":235859,"goal":"method ArrayCopy_15844(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_15845","instance":15845,"id":235860,"goal":"function ListReverse_15845(s: seq): seq\n ensures |ListReverse_15845(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_15845(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_15846","instance":15846,"id":235861,"goal":"function Factorial_15846(n: nat): nat\n ensures Factorial_15846(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_15846(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_15847","instance":15847,"id":235862,"goal":"function Fib_15847(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_15847(n-1) + Fib_15847(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_15848","instance":15848,"id":235863,"goal":"function Gcd_15848(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_15848(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_15849","instance":15849,"id":235864,"goal":"function Power_15849(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_15849(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_15850","instance":15850,"id":235865,"goal":"function Sum_15850(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_15850(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_15851","instance":15851,"id":235866,"goal":"method BinarySearch_15851(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_15852","instance":15852,"id":235867,"goal":"method InsertSort_15852(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_15853","instance":15853,"id":235868,"goal":"method MergeSort_15853(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_15854","instance":15854,"id":235869,"goal":"method ArrayCopy_15854(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_15855","instance":15855,"id":235870,"goal":"function ListReverse_15855(s: seq): seq\n ensures |ListReverse_15855(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_15855(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_15856","instance":15856,"id":235871,"goal":"function Factorial_15856(n: nat): nat\n ensures Factorial_15856(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_15856(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_15857","instance":15857,"id":235872,"goal":"function Fib_15857(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_15857(n-1) + Fib_15857(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_15858","instance":15858,"id":235873,"goal":"function Gcd_15858(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_15858(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_15859","instance":15859,"id":235874,"goal":"function Power_15859(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_15859(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_15860","instance":15860,"id":235875,"goal":"function Sum_15860(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_15860(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_15861","instance":15861,"id":235876,"goal":"method BinarySearch_15861(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_15862","instance":15862,"id":235877,"goal":"method InsertSort_15862(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_15863","instance":15863,"id":235878,"goal":"method MergeSort_15863(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_15864","instance":15864,"id":235879,"goal":"method ArrayCopy_15864(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_15865","instance":15865,"id":235880,"goal":"function ListReverse_15865(s: seq): seq\n ensures |ListReverse_15865(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_15865(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_15866","instance":15866,"id":235881,"goal":"function Factorial_15866(n: nat): nat\n ensures Factorial_15866(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_15866(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_15867","instance":15867,"id":235882,"goal":"function Fib_15867(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_15867(n-1) + Fib_15867(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_15868","instance":15868,"id":235883,"goal":"function Gcd_15868(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_15868(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_15869","instance":15869,"id":235884,"goal":"function Power_15869(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_15869(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_15870","instance":15870,"id":235885,"goal":"function Sum_15870(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_15870(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_15871","instance":15871,"id":235886,"goal":"method BinarySearch_15871(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_15872","instance":15872,"id":235887,"goal":"method InsertSort_15872(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_15873","instance":15873,"id":235888,"goal":"method MergeSort_15873(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_15874","instance":15874,"id":235889,"goal":"method ArrayCopy_15874(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_15875","instance":15875,"id":235890,"goal":"function ListReverse_15875(s: seq): seq\n ensures |ListReverse_15875(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_15875(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_15876","instance":15876,"id":235891,"goal":"function Factorial_15876(n: nat): nat\n ensures Factorial_15876(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_15876(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_15877","instance":15877,"id":235892,"goal":"function Fib_15877(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_15877(n-1) + Fib_15877(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_15878","instance":15878,"id":235893,"goal":"function Gcd_15878(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_15878(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_15879","instance":15879,"id":235894,"goal":"function Power_15879(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_15879(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_15880","instance":15880,"id":235895,"goal":"function Sum_15880(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_15880(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_15881","instance":15881,"id":235896,"goal":"method BinarySearch_15881(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_15882","instance":15882,"id":235897,"goal":"method InsertSort_15882(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_15883","instance":15883,"id":235898,"goal":"method MergeSort_15883(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_15884","instance":15884,"id":235899,"goal":"method ArrayCopy_15884(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_15885","instance":15885,"id":235900,"goal":"function ListReverse_15885(s: seq): seq\n ensures |ListReverse_15885(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_15885(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_15886","instance":15886,"id":235901,"goal":"function Factorial_15886(n: nat): nat\n ensures Factorial_15886(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_15886(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_15887","instance":15887,"id":235902,"goal":"function Fib_15887(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_15887(n-1) + Fib_15887(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_15888","instance":15888,"id":235903,"goal":"function Gcd_15888(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_15888(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_15889","instance":15889,"id":235904,"goal":"function Power_15889(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_15889(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_15890","instance":15890,"id":235905,"goal":"function Sum_15890(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_15890(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_15891","instance":15891,"id":235906,"goal":"method BinarySearch_15891(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_15892","instance":15892,"id":235907,"goal":"method InsertSort_15892(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_15893","instance":15893,"id":235908,"goal":"method MergeSort_15893(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_15894","instance":15894,"id":235909,"goal":"method ArrayCopy_15894(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_15895","instance":15895,"id":235910,"goal":"function ListReverse_15895(s: seq): seq\n ensures |ListReverse_15895(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_15895(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_15896","instance":15896,"id":235911,"goal":"function Factorial_15896(n: nat): nat\n ensures Factorial_15896(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_15896(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_15897","instance":15897,"id":235912,"goal":"function Fib_15897(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_15897(n-1) + Fib_15897(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_15898","instance":15898,"id":235913,"goal":"function Gcd_15898(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_15898(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_15899","instance":15899,"id":235914,"goal":"function Power_15899(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_15899(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_15900","instance":15900,"id":235915,"goal":"function Sum_15900(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_15900(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_15901","instance":15901,"id":235916,"goal":"method BinarySearch_15901(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_15902","instance":15902,"id":235917,"goal":"method InsertSort_15902(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_15903","instance":15903,"id":235918,"goal":"method MergeSort_15903(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_15904","instance":15904,"id":235919,"goal":"method ArrayCopy_15904(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_15905","instance":15905,"id":235920,"goal":"function ListReverse_15905(s: seq): seq\n ensures |ListReverse_15905(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_15905(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_15906","instance":15906,"id":235921,"goal":"function Factorial_15906(n: nat): nat\n ensures Factorial_15906(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_15906(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_15907","instance":15907,"id":235922,"goal":"function Fib_15907(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_15907(n-1) + Fib_15907(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_15908","instance":15908,"id":235923,"goal":"function Gcd_15908(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_15908(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_15909","instance":15909,"id":235924,"goal":"function Power_15909(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_15909(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_15910","instance":15910,"id":235925,"goal":"function Sum_15910(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_15910(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_15911","instance":15911,"id":235926,"goal":"method BinarySearch_15911(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_15912","instance":15912,"id":235927,"goal":"method InsertSort_15912(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_15913","instance":15913,"id":235928,"goal":"method MergeSort_15913(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_15914","instance":15914,"id":235929,"goal":"method ArrayCopy_15914(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_15915","instance":15915,"id":235930,"goal":"function ListReverse_15915(s: seq): seq\n ensures |ListReverse_15915(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_15915(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_15916","instance":15916,"id":235931,"goal":"function Factorial_15916(n: nat): nat\n ensures Factorial_15916(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_15916(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_15917","instance":15917,"id":235932,"goal":"function Fib_15917(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_15917(n-1) + Fib_15917(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_15918","instance":15918,"id":235933,"goal":"function Gcd_15918(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_15918(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_15919","instance":15919,"id":235934,"goal":"function Power_15919(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_15919(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_15920","instance":15920,"id":235935,"goal":"function Sum_15920(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_15920(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_15921","instance":15921,"id":235936,"goal":"method BinarySearch_15921(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_15922","instance":15922,"id":235937,"goal":"method InsertSort_15922(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_15923","instance":15923,"id":235938,"goal":"method MergeSort_15923(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_15924","instance":15924,"id":235939,"goal":"method ArrayCopy_15924(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_15925","instance":15925,"id":235940,"goal":"function ListReverse_15925(s: seq): seq\n ensures |ListReverse_15925(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_15925(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_15926","instance":15926,"id":235941,"goal":"function Factorial_15926(n: nat): nat\n ensures Factorial_15926(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_15926(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_15927","instance":15927,"id":235942,"goal":"function Fib_15927(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_15927(n-1) + Fib_15927(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_15928","instance":15928,"id":235943,"goal":"function Gcd_15928(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_15928(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_15929","instance":15929,"id":235944,"goal":"function Power_15929(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_15929(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_15930","instance":15930,"id":235945,"goal":"function Sum_15930(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_15930(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_15931","instance":15931,"id":235946,"goal":"method BinarySearch_15931(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_15932","instance":15932,"id":235947,"goal":"method InsertSort_15932(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_15933","instance":15933,"id":235948,"goal":"method MergeSort_15933(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_15934","instance":15934,"id":235949,"goal":"method ArrayCopy_15934(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_15935","instance":15935,"id":235950,"goal":"function ListReverse_15935(s: seq): seq\n ensures |ListReverse_15935(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_15935(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_15936","instance":15936,"id":235951,"goal":"function Factorial_15936(n: nat): nat\n ensures Factorial_15936(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_15936(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_15937","instance":15937,"id":235952,"goal":"function Fib_15937(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_15937(n-1) + Fib_15937(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_15938","instance":15938,"id":235953,"goal":"function Gcd_15938(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_15938(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_15939","instance":15939,"id":235954,"goal":"function Power_15939(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_15939(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_15940","instance":15940,"id":235955,"goal":"function Sum_15940(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_15940(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_15941","instance":15941,"id":235956,"goal":"method BinarySearch_15941(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_15942","instance":15942,"id":235957,"goal":"method InsertSort_15942(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_15943","instance":15943,"id":235958,"goal":"method MergeSort_15943(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_15944","instance":15944,"id":235959,"goal":"method ArrayCopy_15944(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_15945","instance":15945,"id":235960,"goal":"function ListReverse_15945(s: seq): seq\n ensures |ListReverse_15945(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_15945(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_15946","instance":15946,"id":235961,"goal":"function Factorial_15946(n: nat): nat\n ensures Factorial_15946(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_15946(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_15947","instance":15947,"id":235962,"goal":"function Fib_15947(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_15947(n-1) + Fib_15947(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_15948","instance":15948,"id":235963,"goal":"function Gcd_15948(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_15948(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_15949","instance":15949,"id":235964,"goal":"function Power_15949(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_15949(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_15950","instance":15950,"id":235965,"goal":"function Sum_15950(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_15950(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_15951","instance":15951,"id":235966,"goal":"method BinarySearch_15951(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_15952","instance":15952,"id":235967,"goal":"method InsertSort_15952(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_15953","instance":15953,"id":235968,"goal":"method MergeSort_15953(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_15954","instance":15954,"id":235969,"goal":"method ArrayCopy_15954(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_15955","instance":15955,"id":235970,"goal":"function ListReverse_15955(s: seq): seq\n ensures |ListReverse_15955(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_15955(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_15956","instance":15956,"id":235971,"goal":"function Factorial_15956(n: nat): nat\n ensures Factorial_15956(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_15956(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_15957","instance":15957,"id":235972,"goal":"function Fib_15957(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_15957(n-1) + Fib_15957(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_15958","instance":15958,"id":235973,"goal":"function Gcd_15958(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_15958(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_15959","instance":15959,"id":235974,"goal":"function Power_15959(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_15959(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_15960","instance":15960,"id":235975,"goal":"function Sum_15960(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_15960(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_15961","instance":15961,"id":235976,"goal":"method BinarySearch_15961(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_15962","instance":15962,"id":235977,"goal":"method InsertSort_15962(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_15963","instance":15963,"id":235978,"goal":"method MergeSort_15963(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_15964","instance":15964,"id":235979,"goal":"method ArrayCopy_15964(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_15965","instance":15965,"id":235980,"goal":"function ListReverse_15965(s: seq): seq\n ensures |ListReverse_15965(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_15965(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_15966","instance":15966,"id":235981,"goal":"function Factorial_15966(n: nat): nat\n ensures Factorial_15966(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_15966(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_15967","instance":15967,"id":235982,"goal":"function Fib_15967(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_15967(n-1) + Fib_15967(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_15968","instance":15968,"id":235983,"goal":"function Gcd_15968(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_15968(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_15969","instance":15969,"id":235984,"goal":"function Power_15969(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_15969(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_15970","instance":15970,"id":235985,"goal":"function Sum_15970(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_15970(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_15971","instance":15971,"id":235986,"goal":"method BinarySearch_15971(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_15972","instance":15972,"id":235987,"goal":"method InsertSort_15972(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_15973","instance":15973,"id":235988,"goal":"method MergeSort_15973(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_15974","instance":15974,"id":235989,"goal":"method ArrayCopy_15974(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_15975","instance":15975,"id":235990,"goal":"function ListReverse_15975(s: seq): seq\n ensures |ListReverse_15975(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_15975(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_15976","instance":15976,"id":235991,"goal":"function Factorial_15976(n: nat): nat\n ensures Factorial_15976(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_15976(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_15977","instance":15977,"id":235992,"goal":"function Fib_15977(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_15977(n-1) + Fib_15977(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_15978","instance":15978,"id":235993,"goal":"function Gcd_15978(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_15978(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_15979","instance":15979,"id":235994,"goal":"function Power_15979(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_15979(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_15980","instance":15980,"id":235995,"goal":"function Sum_15980(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_15980(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_15981","instance":15981,"id":235996,"goal":"method BinarySearch_15981(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_15982","instance":15982,"id":235997,"goal":"method InsertSort_15982(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_15983","instance":15983,"id":235998,"goal":"method MergeSort_15983(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_15984","instance":15984,"id":235999,"goal":"method ArrayCopy_15984(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_15985","instance":15985,"id":236000,"goal":"function ListReverse_15985(s: seq): seq\n ensures |ListReverse_15985(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_15985(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_15986","instance":15986,"id":236001,"goal":"function Factorial_15986(n: nat): nat\n ensures Factorial_15986(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_15986(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_15987","instance":15987,"id":236002,"goal":"function Fib_15987(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_15987(n-1) + Fib_15987(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_15988","instance":15988,"id":236003,"goal":"function Gcd_15988(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_15988(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_15989","instance":15989,"id":236004,"goal":"function Power_15989(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_15989(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_15990","instance":15990,"id":236005,"goal":"function Sum_15990(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_15990(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_15991","instance":15991,"id":236006,"goal":"method BinarySearch_15991(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_15992","instance":15992,"id":236007,"goal":"method InsertSort_15992(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_15993","instance":15993,"id":236008,"goal":"method MergeSort_15993(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_15994","instance":15994,"id":236009,"goal":"method ArrayCopy_15994(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_15995","instance":15995,"id":236010,"goal":"function ListReverse_15995(s: seq): seq\n ensures |ListReverse_15995(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_15995(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_15996","instance":15996,"id":236011,"goal":"function Factorial_15996(n: nat): nat\n ensures Factorial_15996(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_15996(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_15997","instance":15997,"id":236012,"goal":"function Fib_15997(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_15997(n-1) + Fib_15997(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_15998","instance":15998,"id":236013,"goal":"function Gcd_15998(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_15998(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_15999","instance":15999,"id":236014,"goal":"function Power_15999(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_15999(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_16000","instance":16000,"id":236015,"goal":"function Sum_16000(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_16000(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_16001","instance":16001,"id":236016,"goal":"method BinarySearch_16001(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_16002","instance":16002,"id":236017,"goal":"method InsertSort_16002(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_16003","instance":16003,"id":236018,"goal":"method MergeSort_16003(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_16004","instance":16004,"id":236019,"goal":"method ArrayCopy_16004(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_16005","instance":16005,"id":236020,"goal":"function ListReverse_16005(s: seq): seq\n ensures |ListReverse_16005(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_16005(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_16006","instance":16006,"id":236021,"goal":"function Factorial_16006(n: nat): nat\n ensures Factorial_16006(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_16006(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_16007","instance":16007,"id":236022,"goal":"function Fib_16007(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_16007(n-1) + Fib_16007(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_16008","instance":16008,"id":236023,"goal":"function Gcd_16008(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_16008(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_16009","instance":16009,"id":236024,"goal":"function Power_16009(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_16009(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_16010","instance":16010,"id":236025,"goal":"function Sum_16010(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_16010(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_16011","instance":16011,"id":236026,"goal":"method BinarySearch_16011(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_16012","instance":16012,"id":236027,"goal":"method InsertSort_16012(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_16013","instance":16013,"id":236028,"goal":"method MergeSort_16013(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_16014","instance":16014,"id":236029,"goal":"method ArrayCopy_16014(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_16015","instance":16015,"id":236030,"goal":"function ListReverse_16015(s: seq): seq\n ensures |ListReverse_16015(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_16015(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_16016","instance":16016,"id":236031,"goal":"function Factorial_16016(n: nat): nat\n ensures Factorial_16016(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_16016(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_16017","instance":16017,"id":236032,"goal":"function Fib_16017(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_16017(n-1) + Fib_16017(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_16018","instance":16018,"id":236033,"goal":"function Gcd_16018(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_16018(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_16019","instance":16019,"id":236034,"goal":"function Power_16019(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_16019(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_16020","instance":16020,"id":236035,"goal":"function Sum_16020(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_16020(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_16021","instance":16021,"id":236036,"goal":"method BinarySearch_16021(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_16022","instance":16022,"id":236037,"goal":"method InsertSort_16022(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_16023","instance":16023,"id":236038,"goal":"method MergeSort_16023(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_16024","instance":16024,"id":236039,"goal":"method ArrayCopy_16024(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_16025","instance":16025,"id":236040,"goal":"function ListReverse_16025(s: seq): seq\n ensures |ListReverse_16025(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_16025(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_16026","instance":16026,"id":236041,"goal":"function Factorial_16026(n: nat): nat\n ensures Factorial_16026(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_16026(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_16027","instance":16027,"id":236042,"goal":"function Fib_16027(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_16027(n-1) + Fib_16027(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_16028","instance":16028,"id":236043,"goal":"function Gcd_16028(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_16028(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_16029","instance":16029,"id":236044,"goal":"function Power_16029(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_16029(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_16030","instance":16030,"id":236045,"goal":"function Sum_16030(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_16030(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_16031","instance":16031,"id":236046,"goal":"method BinarySearch_16031(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_16032","instance":16032,"id":236047,"goal":"method InsertSort_16032(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_16033","instance":16033,"id":236048,"goal":"method MergeSort_16033(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_16034","instance":16034,"id":236049,"goal":"method ArrayCopy_16034(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_16035","instance":16035,"id":236050,"goal":"function ListReverse_16035(s: seq): seq\n ensures |ListReverse_16035(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_16035(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_16036","instance":16036,"id":236051,"goal":"function Factorial_16036(n: nat): nat\n ensures Factorial_16036(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_16036(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_16037","instance":16037,"id":236052,"goal":"function Fib_16037(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_16037(n-1) + Fib_16037(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_16038","instance":16038,"id":236053,"goal":"function Gcd_16038(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_16038(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_16039","instance":16039,"id":236054,"goal":"function Power_16039(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_16039(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_16040","instance":16040,"id":236055,"goal":"function Sum_16040(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_16040(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_16041","instance":16041,"id":236056,"goal":"method BinarySearch_16041(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_16042","instance":16042,"id":236057,"goal":"method InsertSort_16042(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_16043","instance":16043,"id":236058,"goal":"method MergeSort_16043(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_16044","instance":16044,"id":236059,"goal":"method ArrayCopy_16044(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_16045","instance":16045,"id":236060,"goal":"function ListReverse_16045(s: seq): seq\n ensures |ListReverse_16045(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_16045(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_16046","instance":16046,"id":236061,"goal":"function Factorial_16046(n: nat): nat\n ensures Factorial_16046(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_16046(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_16047","instance":16047,"id":236062,"goal":"function Fib_16047(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_16047(n-1) + Fib_16047(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_16048","instance":16048,"id":236063,"goal":"function Gcd_16048(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_16048(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_16049","instance":16049,"id":236064,"goal":"function Power_16049(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_16049(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_16050","instance":16050,"id":236065,"goal":"function Sum_16050(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_16050(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_16051","instance":16051,"id":236066,"goal":"method BinarySearch_16051(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_16052","instance":16052,"id":236067,"goal":"method InsertSort_16052(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_16053","instance":16053,"id":236068,"goal":"method MergeSort_16053(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_16054","instance":16054,"id":236069,"goal":"method ArrayCopy_16054(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_16055","instance":16055,"id":236070,"goal":"function ListReverse_16055(s: seq): seq\n ensures |ListReverse_16055(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_16055(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_16056","instance":16056,"id":236071,"goal":"function Factorial_16056(n: nat): nat\n ensures Factorial_16056(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_16056(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_16057","instance":16057,"id":236072,"goal":"function Fib_16057(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_16057(n-1) + Fib_16057(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_16058","instance":16058,"id":236073,"goal":"function Gcd_16058(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_16058(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_16059","instance":16059,"id":236074,"goal":"function Power_16059(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_16059(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_16060","instance":16060,"id":236075,"goal":"function Sum_16060(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_16060(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_16061","instance":16061,"id":236076,"goal":"method BinarySearch_16061(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_16062","instance":16062,"id":236077,"goal":"method InsertSort_16062(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_16063","instance":16063,"id":236078,"goal":"method MergeSort_16063(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_16064","instance":16064,"id":236079,"goal":"method ArrayCopy_16064(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_16065","instance":16065,"id":236080,"goal":"function ListReverse_16065(s: seq): seq\n ensures |ListReverse_16065(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_16065(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_16066","instance":16066,"id":236081,"goal":"function Factorial_16066(n: nat): nat\n ensures Factorial_16066(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_16066(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_16067","instance":16067,"id":236082,"goal":"function Fib_16067(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_16067(n-1) + Fib_16067(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_16068","instance":16068,"id":236083,"goal":"function Gcd_16068(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_16068(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_16069","instance":16069,"id":236084,"goal":"function Power_16069(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_16069(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_16070","instance":16070,"id":236085,"goal":"function Sum_16070(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_16070(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_16071","instance":16071,"id":236086,"goal":"method BinarySearch_16071(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_16072","instance":16072,"id":236087,"goal":"method InsertSort_16072(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_16073","instance":16073,"id":236088,"goal":"method MergeSort_16073(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_16074","instance":16074,"id":236089,"goal":"method ArrayCopy_16074(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_16075","instance":16075,"id":236090,"goal":"function ListReverse_16075(s: seq): seq\n ensures |ListReverse_16075(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_16075(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_16076","instance":16076,"id":236091,"goal":"function Factorial_16076(n: nat): nat\n ensures Factorial_16076(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_16076(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_16077","instance":16077,"id":236092,"goal":"function Fib_16077(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_16077(n-1) + Fib_16077(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_16078","instance":16078,"id":236093,"goal":"function Gcd_16078(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_16078(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_16079","instance":16079,"id":236094,"goal":"function Power_16079(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_16079(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_16080","instance":16080,"id":236095,"goal":"function Sum_16080(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_16080(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_16081","instance":16081,"id":236096,"goal":"method BinarySearch_16081(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_16082","instance":16082,"id":236097,"goal":"method InsertSort_16082(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_16083","instance":16083,"id":236098,"goal":"method MergeSort_16083(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_16084","instance":16084,"id":236099,"goal":"method ArrayCopy_16084(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_16085","instance":16085,"id":236100,"goal":"function ListReverse_16085(s: seq): seq\n ensures |ListReverse_16085(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_16085(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_16086","instance":16086,"id":236101,"goal":"function Factorial_16086(n: nat): nat\n ensures Factorial_16086(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_16086(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_16087","instance":16087,"id":236102,"goal":"function Fib_16087(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_16087(n-1) + Fib_16087(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_16088","instance":16088,"id":236103,"goal":"function Gcd_16088(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_16088(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_16089","instance":16089,"id":236104,"goal":"function Power_16089(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_16089(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_16090","instance":16090,"id":236105,"goal":"function Sum_16090(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_16090(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_16091","instance":16091,"id":236106,"goal":"method BinarySearch_16091(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_16092","instance":16092,"id":236107,"goal":"method InsertSort_16092(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_16093","instance":16093,"id":236108,"goal":"method MergeSort_16093(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_16094","instance":16094,"id":236109,"goal":"method ArrayCopy_16094(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_16095","instance":16095,"id":236110,"goal":"function ListReverse_16095(s: seq): seq\n ensures |ListReverse_16095(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_16095(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_16096","instance":16096,"id":236111,"goal":"function Factorial_16096(n: nat): nat\n ensures Factorial_16096(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_16096(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_16097","instance":16097,"id":236112,"goal":"function Fib_16097(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_16097(n-1) + Fib_16097(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_16098","instance":16098,"id":236113,"goal":"function Gcd_16098(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_16098(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_16099","instance":16099,"id":236114,"goal":"function Power_16099(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_16099(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_16100","instance":16100,"id":236115,"goal":"function Sum_16100(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_16100(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_16101","instance":16101,"id":236116,"goal":"method BinarySearch_16101(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_16102","instance":16102,"id":236117,"goal":"method InsertSort_16102(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_16103","instance":16103,"id":236118,"goal":"method MergeSort_16103(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_16104","instance":16104,"id":236119,"goal":"method ArrayCopy_16104(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_16105","instance":16105,"id":236120,"goal":"function ListReverse_16105(s: seq): seq\n ensures |ListReverse_16105(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_16105(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_16106","instance":16106,"id":236121,"goal":"function Factorial_16106(n: nat): nat\n ensures Factorial_16106(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_16106(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_16107","instance":16107,"id":236122,"goal":"function Fib_16107(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_16107(n-1) + Fib_16107(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_16108","instance":16108,"id":236123,"goal":"function Gcd_16108(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_16108(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_16109","instance":16109,"id":236124,"goal":"function Power_16109(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_16109(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_16110","instance":16110,"id":236125,"goal":"function Sum_16110(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_16110(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_16111","instance":16111,"id":236126,"goal":"method BinarySearch_16111(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_16112","instance":16112,"id":236127,"goal":"method InsertSort_16112(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_16113","instance":16113,"id":236128,"goal":"method MergeSort_16113(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_16114","instance":16114,"id":236129,"goal":"method ArrayCopy_16114(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_16115","instance":16115,"id":236130,"goal":"function ListReverse_16115(s: seq): seq\n ensures |ListReverse_16115(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_16115(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_16116","instance":16116,"id":236131,"goal":"function Factorial_16116(n: nat): nat\n ensures Factorial_16116(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_16116(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_16117","instance":16117,"id":236132,"goal":"function Fib_16117(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_16117(n-1) + Fib_16117(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_16118","instance":16118,"id":236133,"goal":"function Gcd_16118(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_16118(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_16119","instance":16119,"id":236134,"goal":"function Power_16119(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_16119(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_16120","instance":16120,"id":236135,"goal":"function Sum_16120(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_16120(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_16121","instance":16121,"id":236136,"goal":"method BinarySearch_16121(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_16122","instance":16122,"id":236137,"goal":"method InsertSort_16122(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_16123","instance":16123,"id":236138,"goal":"method MergeSort_16123(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_16124","instance":16124,"id":236139,"goal":"method ArrayCopy_16124(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_16125","instance":16125,"id":236140,"goal":"function ListReverse_16125(s: seq): seq\n ensures |ListReverse_16125(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_16125(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_16126","instance":16126,"id":236141,"goal":"function Factorial_16126(n: nat): nat\n ensures Factorial_16126(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_16126(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_16127","instance":16127,"id":236142,"goal":"function Fib_16127(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_16127(n-1) + Fib_16127(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_16128","instance":16128,"id":236143,"goal":"function Gcd_16128(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_16128(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_16129","instance":16129,"id":236144,"goal":"function Power_16129(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_16129(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_16130","instance":16130,"id":236145,"goal":"function Sum_16130(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_16130(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_16131","instance":16131,"id":236146,"goal":"method BinarySearch_16131(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_16132","instance":16132,"id":236147,"goal":"method InsertSort_16132(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_16133","instance":16133,"id":236148,"goal":"method MergeSort_16133(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_16134","instance":16134,"id":236149,"goal":"method ArrayCopy_16134(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_16135","instance":16135,"id":236150,"goal":"function ListReverse_16135(s: seq): seq\n ensures |ListReverse_16135(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_16135(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_16136","instance":16136,"id":236151,"goal":"function Factorial_16136(n: nat): nat\n ensures Factorial_16136(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_16136(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_16137","instance":16137,"id":236152,"goal":"function Fib_16137(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_16137(n-1) + Fib_16137(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_16138","instance":16138,"id":236153,"goal":"function Gcd_16138(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_16138(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_16139","instance":16139,"id":236154,"goal":"function Power_16139(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_16139(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_16140","instance":16140,"id":236155,"goal":"function Sum_16140(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_16140(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_16141","instance":16141,"id":236156,"goal":"method BinarySearch_16141(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_16142","instance":16142,"id":236157,"goal":"method InsertSort_16142(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_16143","instance":16143,"id":236158,"goal":"method MergeSort_16143(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_16144","instance":16144,"id":236159,"goal":"method ArrayCopy_16144(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_16145","instance":16145,"id":236160,"goal":"function ListReverse_16145(s: seq): seq\n ensures |ListReverse_16145(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_16145(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_16146","instance":16146,"id":236161,"goal":"function Factorial_16146(n: nat): nat\n ensures Factorial_16146(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_16146(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_16147","instance":16147,"id":236162,"goal":"function Fib_16147(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_16147(n-1) + Fib_16147(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_16148","instance":16148,"id":236163,"goal":"function Gcd_16148(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_16148(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_16149","instance":16149,"id":236164,"goal":"function Power_16149(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_16149(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_16150","instance":16150,"id":236165,"goal":"function Sum_16150(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_16150(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_16151","instance":16151,"id":236166,"goal":"method BinarySearch_16151(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_16152","instance":16152,"id":236167,"goal":"method InsertSort_16152(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_16153","instance":16153,"id":236168,"goal":"method MergeSort_16153(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_16154","instance":16154,"id":236169,"goal":"method ArrayCopy_16154(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_16155","instance":16155,"id":236170,"goal":"function ListReverse_16155(s: seq): seq\n ensures |ListReverse_16155(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_16155(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_16156","instance":16156,"id":236171,"goal":"function Factorial_16156(n: nat): nat\n ensures Factorial_16156(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_16156(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_16157","instance":16157,"id":236172,"goal":"function Fib_16157(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_16157(n-1) + Fib_16157(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_16158","instance":16158,"id":236173,"goal":"function Gcd_16158(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_16158(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_16159","instance":16159,"id":236174,"goal":"function Power_16159(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_16159(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_16160","instance":16160,"id":236175,"goal":"function Sum_16160(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_16160(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_16161","instance":16161,"id":236176,"goal":"method BinarySearch_16161(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_16162","instance":16162,"id":236177,"goal":"method InsertSort_16162(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_16163","instance":16163,"id":236178,"goal":"method MergeSort_16163(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_16164","instance":16164,"id":236179,"goal":"method ArrayCopy_16164(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_16165","instance":16165,"id":236180,"goal":"function ListReverse_16165(s: seq): seq\n ensures |ListReverse_16165(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_16165(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_16166","instance":16166,"id":236181,"goal":"function Factorial_16166(n: nat): nat\n ensures Factorial_16166(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_16166(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_16167","instance":16167,"id":236182,"goal":"function Fib_16167(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_16167(n-1) + Fib_16167(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_16168","instance":16168,"id":236183,"goal":"function Gcd_16168(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_16168(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_16169","instance":16169,"id":236184,"goal":"function Power_16169(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_16169(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_16170","instance":16170,"id":236185,"goal":"function Sum_16170(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_16170(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_16171","instance":16171,"id":236186,"goal":"method BinarySearch_16171(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_16172","instance":16172,"id":236187,"goal":"method InsertSort_16172(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_16173","instance":16173,"id":236188,"goal":"method MergeSort_16173(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_16174","instance":16174,"id":236189,"goal":"method ArrayCopy_16174(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_16175","instance":16175,"id":236190,"goal":"function ListReverse_16175(s: seq): seq\n ensures |ListReverse_16175(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_16175(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_16176","instance":16176,"id":236191,"goal":"function Factorial_16176(n: nat): nat\n ensures Factorial_16176(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_16176(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_16177","instance":16177,"id":236192,"goal":"function Fib_16177(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_16177(n-1) + Fib_16177(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_16178","instance":16178,"id":236193,"goal":"function Gcd_16178(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_16178(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_16179","instance":16179,"id":236194,"goal":"function Power_16179(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_16179(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_16180","instance":16180,"id":236195,"goal":"function Sum_16180(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_16180(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_16181","instance":16181,"id":236196,"goal":"method BinarySearch_16181(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_16182","instance":16182,"id":236197,"goal":"method InsertSort_16182(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_16183","instance":16183,"id":236198,"goal":"method MergeSort_16183(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_16184","instance":16184,"id":236199,"goal":"method ArrayCopy_16184(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_16185","instance":16185,"id":236200,"goal":"function ListReverse_16185(s: seq): seq\n ensures |ListReverse_16185(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_16185(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_16186","instance":16186,"id":236201,"goal":"function Factorial_16186(n: nat): nat\n ensures Factorial_16186(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_16186(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_16187","instance":16187,"id":236202,"goal":"function Fib_16187(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_16187(n-1) + Fib_16187(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_16188","instance":16188,"id":236203,"goal":"function Gcd_16188(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_16188(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_16189","instance":16189,"id":236204,"goal":"function Power_16189(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_16189(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_16190","instance":16190,"id":236205,"goal":"function Sum_16190(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_16190(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_16191","instance":16191,"id":236206,"goal":"method BinarySearch_16191(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_16192","instance":16192,"id":236207,"goal":"method InsertSort_16192(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_16193","instance":16193,"id":236208,"goal":"method MergeSort_16193(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_16194","instance":16194,"id":236209,"goal":"method ArrayCopy_16194(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_16195","instance":16195,"id":236210,"goal":"function ListReverse_16195(s: seq): seq\n ensures |ListReverse_16195(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_16195(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_16196","instance":16196,"id":236211,"goal":"function Factorial_16196(n: nat): nat\n ensures Factorial_16196(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_16196(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_16197","instance":16197,"id":236212,"goal":"function Fib_16197(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_16197(n-1) + Fib_16197(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_16198","instance":16198,"id":236213,"goal":"function Gcd_16198(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_16198(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_16199","instance":16199,"id":236214,"goal":"function Power_16199(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_16199(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_16200","instance":16200,"id":236215,"goal":"function Sum_16200(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_16200(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_16201","instance":16201,"id":236216,"goal":"method BinarySearch_16201(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_16202","instance":16202,"id":236217,"goal":"method InsertSort_16202(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_16203","instance":16203,"id":236218,"goal":"method MergeSort_16203(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_16204","instance":16204,"id":236219,"goal":"method ArrayCopy_16204(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_16205","instance":16205,"id":236220,"goal":"function ListReverse_16205(s: seq): seq\n ensures |ListReverse_16205(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_16205(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_16206","instance":16206,"id":236221,"goal":"function Factorial_16206(n: nat): nat\n ensures Factorial_16206(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_16206(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_16207","instance":16207,"id":236222,"goal":"function Fib_16207(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_16207(n-1) + Fib_16207(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_16208","instance":16208,"id":236223,"goal":"function Gcd_16208(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_16208(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_16209","instance":16209,"id":236224,"goal":"function Power_16209(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_16209(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_16210","instance":16210,"id":236225,"goal":"function Sum_16210(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_16210(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_16211","instance":16211,"id":236226,"goal":"method BinarySearch_16211(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_16212","instance":16212,"id":236227,"goal":"method InsertSort_16212(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_16213","instance":16213,"id":236228,"goal":"method MergeSort_16213(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_16214","instance":16214,"id":236229,"goal":"method ArrayCopy_16214(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_16215","instance":16215,"id":236230,"goal":"function ListReverse_16215(s: seq): seq\n ensures |ListReverse_16215(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_16215(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_16216","instance":16216,"id":236231,"goal":"function Factorial_16216(n: nat): nat\n ensures Factorial_16216(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_16216(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_16217","instance":16217,"id":236232,"goal":"function Fib_16217(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_16217(n-1) + Fib_16217(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_16218","instance":16218,"id":236233,"goal":"function Gcd_16218(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_16218(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_16219","instance":16219,"id":236234,"goal":"function Power_16219(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_16219(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_16220","instance":16220,"id":236235,"goal":"function Sum_16220(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_16220(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_16221","instance":16221,"id":236236,"goal":"method BinarySearch_16221(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_16222","instance":16222,"id":236237,"goal":"method InsertSort_16222(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_16223","instance":16223,"id":236238,"goal":"method MergeSort_16223(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_16224","instance":16224,"id":236239,"goal":"method ArrayCopy_16224(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_16225","instance":16225,"id":236240,"goal":"function ListReverse_16225(s: seq): seq\n ensures |ListReverse_16225(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_16225(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_16226","instance":16226,"id":236241,"goal":"function Factorial_16226(n: nat): nat\n ensures Factorial_16226(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_16226(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_16227","instance":16227,"id":236242,"goal":"function Fib_16227(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_16227(n-1) + Fib_16227(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_16228","instance":16228,"id":236243,"goal":"function Gcd_16228(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_16228(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_16229","instance":16229,"id":236244,"goal":"function Power_16229(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_16229(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_16230","instance":16230,"id":236245,"goal":"function Sum_16230(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_16230(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_16231","instance":16231,"id":236246,"goal":"method BinarySearch_16231(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_16232","instance":16232,"id":236247,"goal":"method InsertSort_16232(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_16233","instance":16233,"id":236248,"goal":"method MergeSort_16233(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_16234","instance":16234,"id":236249,"goal":"method ArrayCopy_16234(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_16235","instance":16235,"id":236250,"goal":"function ListReverse_16235(s: seq): seq\n ensures |ListReverse_16235(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_16235(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_16236","instance":16236,"id":236251,"goal":"function Factorial_16236(n: nat): nat\n ensures Factorial_16236(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_16236(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_16237","instance":16237,"id":236252,"goal":"function Fib_16237(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_16237(n-1) + Fib_16237(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_16238","instance":16238,"id":236253,"goal":"function Gcd_16238(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_16238(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_16239","instance":16239,"id":236254,"goal":"function Power_16239(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_16239(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_16240","instance":16240,"id":236255,"goal":"function Sum_16240(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_16240(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_16241","instance":16241,"id":236256,"goal":"method BinarySearch_16241(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_16242","instance":16242,"id":236257,"goal":"method InsertSort_16242(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_16243","instance":16243,"id":236258,"goal":"method MergeSort_16243(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_16244","instance":16244,"id":236259,"goal":"method ArrayCopy_16244(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_16245","instance":16245,"id":236260,"goal":"function ListReverse_16245(s: seq): seq\n ensures |ListReverse_16245(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_16245(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_16246","instance":16246,"id":236261,"goal":"function Factorial_16246(n: nat): nat\n ensures Factorial_16246(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_16246(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_16247","instance":16247,"id":236262,"goal":"function Fib_16247(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_16247(n-1) + Fib_16247(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_16248","instance":16248,"id":236263,"goal":"function Gcd_16248(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_16248(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_16249","instance":16249,"id":236264,"goal":"function Power_16249(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_16249(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_16250","instance":16250,"id":236265,"goal":"function Sum_16250(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_16250(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_16251","instance":16251,"id":236266,"goal":"method BinarySearch_16251(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_16252","instance":16252,"id":236267,"goal":"method InsertSort_16252(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_16253","instance":16253,"id":236268,"goal":"method MergeSort_16253(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_16254","instance":16254,"id":236269,"goal":"method ArrayCopy_16254(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_16255","instance":16255,"id":236270,"goal":"function ListReverse_16255(s: seq): seq\n ensures |ListReverse_16255(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_16255(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_16256","instance":16256,"id":236271,"goal":"function Factorial_16256(n: nat): nat\n ensures Factorial_16256(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_16256(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_16257","instance":16257,"id":236272,"goal":"function Fib_16257(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_16257(n-1) + Fib_16257(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_16258","instance":16258,"id":236273,"goal":"function Gcd_16258(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_16258(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_16259","instance":16259,"id":236274,"goal":"function Power_16259(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_16259(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_16260","instance":16260,"id":236275,"goal":"function Sum_16260(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_16260(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_16261","instance":16261,"id":236276,"goal":"method BinarySearch_16261(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_16262","instance":16262,"id":236277,"goal":"method InsertSort_16262(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_16263","instance":16263,"id":236278,"goal":"method MergeSort_16263(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_16264","instance":16264,"id":236279,"goal":"method ArrayCopy_16264(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_16265","instance":16265,"id":236280,"goal":"function ListReverse_16265(s: seq): seq\n ensures |ListReverse_16265(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_16265(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_16266","instance":16266,"id":236281,"goal":"function Factorial_16266(n: nat): nat\n ensures Factorial_16266(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_16266(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_16267","instance":16267,"id":236282,"goal":"function Fib_16267(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_16267(n-1) + Fib_16267(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_16268","instance":16268,"id":236283,"goal":"function Gcd_16268(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_16268(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_16269","instance":16269,"id":236284,"goal":"function Power_16269(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_16269(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_16270","instance":16270,"id":236285,"goal":"function Sum_16270(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_16270(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_16271","instance":16271,"id":236286,"goal":"method BinarySearch_16271(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_16272","instance":16272,"id":236287,"goal":"method InsertSort_16272(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_16273","instance":16273,"id":236288,"goal":"method MergeSort_16273(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_16274","instance":16274,"id":236289,"goal":"method ArrayCopy_16274(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_16275","instance":16275,"id":236290,"goal":"function ListReverse_16275(s: seq): seq\n ensures |ListReverse_16275(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_16275(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_16276","instance":16276,"id":236291,"goal":"function Factorial_16276(n: nat): nat\n ensures Factorial_16276(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_16276(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_16277","instance":16277,"id":236292,"goal":"function Fib_16277(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_16277(n-1) + Fib_16277(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_16278","instance":16278,"id":236293,"goal":"function Gcd_16278(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_16278(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_16279","instance":16279,"id":236294,"goal":"function Power_16279(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_16279(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_16280","instance":16280,"id":236295,"goal":"function Sum_16280(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_16280(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_16281","instance":16281,"id":236296,"goal":"method BinarySearch_16281(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_16282","instance":16282,"id":236297,"goal":"method InsertSort_16282(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_16283","instance":16283,"id":236298,"goal":"method MergeSort_16283(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_16284","instance":16284,"id":236299,"goal":"method ArrayCopy_16284(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_16285","instance":16285,"id":236300,"goal":"function ListReverse_16285(s: seq): seq\n ensures |ListReverse_16285(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_16285(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_16286","instance":16286,"id":236301,"goal":"function Factorial_16286(n: nat): nat\n ensures Factorial_16286(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_16286(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_16287","instance":16287,"id":236302,"goal":"function Fib_16287(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_16287(n-1) + Fib_16287(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_16288","instance":16288,"id":236303,"goal":"function Gcd_16288(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_16288(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_16289","instance":16289,"id":236304,"goal":"function Power_16289(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_16289(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_16290","instance":16290,"id":236305,"goal":"function Sum_16290(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_16290(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_16291","instance":16291,"id":236306,"goal":"method BinarySearch_16291(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_16292","instance":16292,"id":236307,"goal":"method InsertSort_16292(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_16293","instance":16293,"id":236308,"goal":"method MergeSort_16293(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_16294","instance":16294,"id":236309,"goal":"method ArrayCopy_16294(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_16295","instance":16295,"id":236310,"goal":"function ListReverse_16295(s: seq): seq\n ensures |ListReverse_16295(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_16295(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_16296","instance":16296,"id":236311,"goal":"function Factorial_16296(n: nat): nat\n ensures Factorial_16296(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_16296(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_16297","instance":16297,"id":236312,"goal":"function Fib_16297(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_16297(n-1) + Fib_16297(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_16298","instance":16298,"id":236313,"goal":"function Gcd_16298(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_16298(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_16299","instance":16299,"id":236314,"goal":"function Power_16299(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_16299(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_16300","instance":16300,"id":236315,"goal":"function Sum_16300(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_16300(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_16301","instance":16301,"id":236316,"goal":"method BinarySearch_16301(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_16302","instance":16302,"id":236317,"goal":"method InsertSort_16302(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_16303","instance":16303,"id":236318,"goal":"method MergeSort_16303(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_16304","instance":16304,"id":236319,"goal":"method ArrayCopy_16304(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_16305","instance":16305,"id":236320,"goal":"function ListReverse_16305(s: seq): seq\n ensures |ListReverse_16305(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_16305(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_16306","instance":16306,"id":236321,"goal":"function Factorial_16306(n: nat): nat\n ensures Factorial_16306(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_16306(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_16307","instance":16307,"id":236322,"goal":"function Fib_16307(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_16307(n-1) + Fib_16307(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_16308","instance":16308,"id":236323,"goal":"function Gcd_16308(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_16308(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_16309","instance":16309,"id":236324,"goal":"function Power_16309(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_16309(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_16310","instance":16310,"id":236325,"goal":"function Sum_16310(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_16310(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_16311","instance":16311,"id":236326,"goal":"method BinarySearch_16311(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_16312","instance":16312,"id":236327,"goal":"method InsertSort_16312(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_16313","instance":16313,"id":236328,"goal":"method MergeSort_16313(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_16314","instance":16314,"id":236329,"goal":"method ArrayCopy_16314(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_16315","instance":16315,"id":236330,"goal":"function ListReverse_16315(s: seq): seq\n ensures |ListReverse_16315(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_16315(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_16316","instance":16316,"id":236331,"goal":"function Factorial_16316(n: nat): nat\n ensures Factorial_16316(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_16316(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_16317","instance":16317,"id":236332,"goal":"function Fib_16317(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_16317(n-1) + Fib_16317(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_16318","instance":16318,"id":236333,"goal":"function Gcd_16318(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_16318(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_16319","instance":16319,"id":236334,"goal":"function Power_16319(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_16319(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_16320","instance":16320,"id":236335,"goal":"function Sum_16320(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_16320(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_16321","instance":16321,"id":236336,"goal":"method BinarySearch_16321(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_16322","instance":16322,"id":236337,"goal":"method InsertSort_16322(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_16323","instance":16323,"id":236338,"goal":"method MergeSort_16323(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_16324","instance":16324,"id":236339,"goal":"method ArrayCopy_16324(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_16325","instance":16325,"id":236340,"goal":"function ListReverse_16325(s: seq): seq\n ensures |ListReverse_16325(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_16325(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_16326","instance":16326,"id":236341,"goal":"function Factorial_16326(n: nat): nat\n ensures Factorial_16326(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_16326(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_16327","instance":16327,"id":236342,"goal":"function Fib_16327(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_16327(n-1) + Fib_16327(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_16328","instance":16328,"id":236343,"goal":"function Gcd_16328(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_16328(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_16329","instance":16329,"id":236344,"goal":"function Power_16329(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_16329(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_16330","instance":16330,"id":236345,"goal":"function Sum_16330(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_16330(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_16331","instance":16331,"id":236346,"goal":"method BinarySearch_16331(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_16332","instance":16332,"id":236347,"goal":"method InsertSort_16332(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_16333","instance":16333,"id":236348,"goal":"method MergeSort_16333(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_16334","instance":16334,"id":236349,"goal":"method ArrayCopy_16334(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_16335","instance":16335,"id":236350,"goal":"function ListReverse_16335(s: seq): seq\n ensures |ListReverse_16335(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_16335(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_16336","instance":16336,"id":236351,"goal":"function Factorial_16336(n: nat): nat\n ensures Factorial_16336(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_16336(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_16337","instance":16337,"id":236352,"goal":"function Fib_16337(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_16337(n-1) + Fib_16337(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_16338","instance":16338,"id":236353,"goal":"function Gcd_16338(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_16338(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_16339","instance":16339,"id":236354,"goal":"function Power_16339(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_16339(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_16340","instance":16340,"id":236355,"goal":"function Sum_16340(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_16340(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_16341","instance":16341,"id":236356,"goal":"method BinarySearch_16341(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_16342","instance":16342,"id":236357,"goal":"method InsertSort_16342(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_16343","instance":16343,"id":236358,"goal":"method MergeSort_16343(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_16344","instance":16344,"id":236359,"goal":"method ArrayCopy_16344(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_16345","instance":16345,"id":236360,"goal":"function ListReverse_16345(s: seq): seq\n ensures |ListReverse_16345(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_16345(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_16346","instance":16346,"id":236361,"goal":"function Factorial_16346(n: nat): nat\n ensures Factorial_16346(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_16346(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_16347","instance":16347,"id":236362,"goal":"function Fib_16347(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_16347(n-1) + Fib_16347(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_16348","instance":16348,"id":236363,"goal":"function Gcd_16348(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_16348(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_16349","instance":16349,"id":236364,"goal":"function Power_16349(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_16349(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_16350","instance":16350,"id":236365,"goal":"function Sum_16350(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_16350(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_16351","instance":16351,"id":236366,"goal":"method BinarySearch_16351(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_16352","instance":16352,"id":236367,"goal":"method InsertSort_16352(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_16353","instance":16353,"id":236368,"goal":"method MergeSort_16353(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_16354","instance":16354,"id":236369,"goal":"method ArrayCopy_16354(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_16355","instance":16355,"id":236370,"goal":"function ListReverse_16355(s: seq): seq\n ensures |ListReverse_16355(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_16355(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_16356","instance":16356,"id":236371,"goal":"function Factorial_16356(n: nat): nat\n ensures Factorial_16356(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_16356(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_16357","instance":16357,"id":236372,"goal":"function Fib_16357(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_16357(n-1) + Fib_16357(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_16358","instance":16358,"id":236373,"goal":"function Gcd_16358(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_16358(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_16359","instance":16359,"id":236374,"goal":"function Power_16359(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_16359(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_16360","instance":16360,"id":236375,"goal":"function Sum_16360(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_16360(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_16361","instance":16361,"id":236376,"goal":"method BinarySearch_16361(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_16362","instance":16362,"id":236377,"goal":"method InsertSort_16362(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_16363","instance":16363,"id":236378,"goal":"method MergeSort_16363(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_16364","instance":16364,"id":236379,"goal":"method ArrayCopy_16364(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_16365","instance":16365,"id":236380,"goal":"function ListReverse_16365(s: seq): seq\n ensures |ListReverse_16365(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_16365(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_16366","instance":16366,"id":236381,"goal":"function Factorial_16366(n: nat): nat\n ensures Factorial_16366(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_16366(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_16367","instance":16367,"id":236382,"goal":"function Fib_16367(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_16367(n-1) + Fib_16367(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_16368","instance":16368,"id":236383,"goal":"function Gcd_16368(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_16368(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_16369","instance":16369,"id":236384,"goal":"function Power_16369(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_16369(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_16370","instance":16370,"id":236385,"goal":"function Sum_16370(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_16370(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_16371","instance":16371,"id":236386,"goal":"method BinarySearch_16371(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_16372","instance":16372,"id":236387,"goal":"method InsertSort_16372(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_16373","instance":16373,"id":236388,"goal":"method MergeSort_16373(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_16374","instance":16374,"id":236389,"goal":"method ArrayCopy_16374(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_16375","instance":16375,"id":236390,"goal":"function ListReverse_16375(s: seq): seq\n ensures |ListReverse_16375(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_16375(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_16376","instance":16376,"id":236391,"goal":"function Factorial_16376(n: nat): nat\n ensures Factorial_16376(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_16376(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_16377","instance":16377,"id":236392,"goal":"function Fib_16377(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_16377(n-1) + Fib_16377(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_16378","instance":16378,"id":236393,"goal":"function Gcd_16378(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_16378(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_16379","instance":16379,"id":236394,"goal":"function Power_16379(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_16379(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_16380","instance":16380,"id":236395,"goal":"function Sum_16380(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_16380(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_16381","instance":16381,"id":236396,"goal":"method BinarySearch_16381(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_16382","instance":16382,"id":236397,"goal":"method InsertSort_16382(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_16383","instance":16383,"id":236398,"goal":"method MergeSort_16383(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_16384","instance":16384,"id":236399,"goal":"method ArrayCopy_16384(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_16385","instance":16385,"id":236400,"goal":"function ListReverse_16385(s: seq): seq\n ensures |ListReverse_16385(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_16385(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_16386","instance":16386,"id":236401,"goal":"function Factorial_16386(n: nat): nat\n ensures Factorial_16386(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_16386(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_16387","instance":16387,"id":236402,"goal":"function Fib_16387(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_16387(n-1) + Fib_16387(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_16388","instance":16388,"id":236403,"goal":"function Gcd_16388(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_16388(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_16389","instance":16389,"id":236404,"goal":"function Power_16389(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_16389(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_16390","instance":16390,"id":236405,"goal":"function Sum_16390(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_16390(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_16391","instance":16391,"id":236406,"goal":"method BinarySearch_16391(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_16392","instance":16392,"id":236407,"goal":"method InsertSort_16392(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_16393","instance":16393,"id":236408,"goal":"method MergeSort_16393(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_16394","instance":16394,"id":236409,"goal":"method ArrayCopy_16394(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_16395","instance":16395,"id":236410,"goal":"function ListReverse_16395(s: seq): seq\n ensures |ListReverse_16395(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_16395(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_16396","instance":16396,"id":236411,"goal":"function Factorial_16396(n: nat): nat\n ensures Factorial_16396(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_16396(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_16397","instance":16397,"id":236412,"goal":"function Fib_16397(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_16397(n-1) + Fib_16397(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_16398","instance":16398,"id":236413,"goal":"function Gcd_16398(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_16398(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_16399","instance":16399,"id":236414,"goal":"function Power_16399(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_16399(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_16400","instance":16400,"id":236415,"goal":"function Sum_16400(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_16400(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_16401","instance":16401,"id":236416,"goal":"method BinarySearch_16401(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_16402","instance":16402,"id":236417,"goal":"method InsertSort_16402(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_16403","instance":16403,"id":236418,"goal":"method MergeSort_16403(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_16404","instance":16404,"id":236419,"goal":"method ArrayCopy_16404(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_16405","instance":16405,"id":236420,"goal":"function ListReverse_16405(s: seq): seq\n ensures |ListReverse_16405(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_16405(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_16406","instance":16406,"id":236421,"goal":"function Factorial_16406(n: nat): nat\n ensures Factorial_16406(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_16406(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_16407","instance":16407,"id":236422,"goal":"function Fib_16407(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_16407(n-1) + Fib_16407(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_16408","instance":16408,"id":236423,"goal":"function Gcd_16408(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_16408(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_16409","instance":16409,"id":236424,"goal":"function Power_16409(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_16409(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_16410","instance":16410,"id":236425,"goal":"function Sum_16410(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_16410(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_16411","instance":16411,"id":236426,"goal":"method BinarySearch_16411(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_16412","instance":16412,"id":236427,"goal":"method InsertSort_16412(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_16413","instance":16413,"id":236428,"goal":"method MergeSort_16413(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_16414","instance":16414,"id":236429,"goal":"method ArrayCopy_16414(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_16415","instance":16415,"id":236430,"goal":"function ListReverse_16415(s: seq): seq\n ensures |ListReverse_16415(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_16415(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_16416","instance":16416,"id":236431,"goal":"function Factorial_16416(n: nat): nat\n ensures Factorial_16416(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_16416(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_16417","instance":16417,"id":236432,"goal":"function Fib_16417(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_16417(n-1) + Fib_16417(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_16418","instance":16418,"id":236433,"goal":"function Gcd_16418(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_16418(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_16419","instance":16419,"id":236434,"goal":"function Power_16419(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_16419(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_16420","instance":16420,"id":236435,"goal":"function Sum_16420(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_16420(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_16421","instance":16421,"id":236436,"goal":"method BinarySearch_16421(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_16422","instance":16422,"id":236437,"goal":"method InsertSort_16422(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_16423","instance":16423,"id":236438,"goal":"method MergeSort_16423(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_16424","instance":16424,"id":236439,"goal":"method ArrayCopy_16424(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_16425","instance":16425,"id":236440,"goal":"function ListReverse_16425(s: seq): seq\n ensures |ListReverse_16425(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_16425(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_16426","instance":16426,"id":236441,"goal":"function Factorial_16426(n: nat): nat\n ensures Factorial_16426(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_16426(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_16427","instance":16427,"id":236442,"goal":"function Fib_16427(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_16427(n-1) + Fib_16427(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_16428","instance":16428,"id":236443,"goal":"function Gcd_16428(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_16428(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_16429","instance":16429,"id":236444,"goal":"function Power_16429(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_16429(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_16430","instance":16430,"id":236445,"goal":"function Sum_16430(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_16430(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_16431","instance":16431,"id":236446,"goal":"method BinarySearch_16431(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_16432","instance":16432,"id":236447,"goal":"method InsertSort_16432(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_16433","instance":16433,"id":236448,"goal":"method MergeSort_16433(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_16434","instance":16434,"id":236449,"goal":"method ArrayCopy_16434(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_16435","instance":16435,"id":236450,"goal":"function ListReverse_16435(s: seq): seq\n ensures |ListReverse_16435(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_16435(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_16436","instance":16436,"id":236451,"goal":"function Factorial_16436(n: nat): nat\n ensures Factorial_16436(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_16436(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_16437","instance":16437,"id":236452,"goal":"function Fib_16437(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_16437(n-1) + Fib_16437(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_16438","instance":16438,"id":236453,"goal":"function Gcd_16438(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_16438(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_16439","instance":16439,"id":236454,"goal":"function Power_16439(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_16439(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_16440","instance":16440,"id":236455,"goal":"function Sum_16440(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_16440(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_16441","instance":16441,"id":236456,"goal":"method BinarySearch_16441(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_16442","instance":16442,"id":236457,"goal":"method InsertSort_16442(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_16443","instance":16443,"id":236458,"goal":"method MergeSort_16443(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_16444","instance":16444,"id":236459,"goal":"method ArrayCopy_16444(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_16445","instance":16445,"id":236460,"goal":"function ListReverse_16445(s: seq): seq\n ensures |ListReverse_16445(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_16445(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_16446","instance":16446,"id":236461,"goal":"function Factorial_16446(n: nat): nat\n ensures Factorial_16446(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_16446(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_16447","instance":16447,"id":236462,"goal":"function Fib_16447(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_16447(n-1) + Fib_16447(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_16448","instance":16448,"id":236463,"goal":"function Gcd_16448(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_16448(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_16449","instance":16449,"id":236464,"goal":"function Power_16449(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_16449(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_16450","instance":16450,"id":236465,"goal":"function Sum_16450(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_16450(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_16451","instance":16451,"id":236466,"goal":"method BinarySearch_16451(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_16452","instance":16452,"id":236467,"goal":"method InsertSort_16452(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_16453","instance":16453,"id":236468,"goal":"method MergeSort_16453(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_16454","instance":16454,"id":236469,"goal":"method ArrayCopy_16454(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_16455","instance":16455,"id":236470,"goal":"function ListReverse_16455(s: seq): seq\n ensures |ListReverse_16455(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_16455(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_16456","instance":16456,"id":236471,"goal":"function Factorial_16456(n: nat): nat\n ensures Factorial_16456(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_16456(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_16457","instance":16457,"id":236472,"goal":"function Fib_16457(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_16457(n-1) + Fib_16457(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_16458","instance":16458,"id":236473,"goal":"function Gcd_16458(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_16458(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_16459","instance":16459,"id":236474,"goal":"function Power_16459(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_16459(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_16460","instance":16460,"id":236475,"goal":"function Sum_16460(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_16460(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_16461","instance":16461,"id":236476,"goal":"method BinarySearch_16461(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_16462","instance":16462,"id":236477,"goal":"method InsertSort_16462(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_16463","instance":16463,"id":236478,"goal":"method MergeSort_16463(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_16464","instance":16464,"id":236479,"goal":"method ArrayCopy_16464(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_16465","instance":16465,"id":236480,"goal":"function ListReverse_16465(s: seq): seq\n ensures |ListReverse_16465(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_16465(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_16466","instance":16466,"id":236481,"goal":"function Factorial_16466(n: nat): nat\n ensures Factorial_16466(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_16466(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_16467","instance":16467,"id":236482,"goal":"function Fib_16467(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_16467(n-1) + Fib_16467(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_16468","instance":16468,"id":236483,"goal":"function Gcd_16468(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_16468(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_16469","instance":16469,"id":236484,"goal":"function Power_16469(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_16469(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_16470","instance":16470,"id":236485,"goal":"function Sum_16470(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_16470(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_16471","instance":16471,"id":236486,"goal":"method BinarySearch_16471(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_16472","instance":16472,"id":236487,"goal":"method InsertSort_16472(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_16473","instance":16473,"id":236488,"goal":"method MergeSort_16473(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_16474","instance":16474,"id":236489,"goal":"method ArrayCopy_16474(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_16475","instance":16475,"id":236490,"goal":"function ListReverse_16475(s: seq): seq\n ensures |ListReverse_16475(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_16475(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_16476","instance":16476,"id":236491,"goal":"function Factorial_16476(n: nat): nat\n ensures Factorial_16476(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_16476(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_16477","instance":16477,"id":236492,"goal":"function Fib_16477(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_16477(n-1) + Fib_16477(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_16478","instance":16478,"id":236493,"goal":"function Gcd_16478(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_16478(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_16479","instance":16479,"id":236494,"goal":"function Power_16479(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_16479(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_16480","instance":16480,"id":236495,"goal":"function Sum_16480(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_16480(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_16481","instance":16481,"id":236496,"goal":"method BinarySearch_16481(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_16482","instance":16482,"id":236497,"goal":"method InsertSort_16482(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_16483","instance":16483,"id":236498,"goal":"method MergeSort_16483(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_16484","instance":16484,"id":236499,"goal":"method ArrayCopy_16484(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_16485","instance":16485,"id":236500,"goal":"function ListReverse_16485(s: seq): seq\n ensures |ListReverse_16485(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_16485(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_16486","instance":16486,"id":236501,"goal":"function Factorial_16486(n: nat): nat\n ensures Factorial_16486(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_16486(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_16487","instance":16487,"id":236502,"goal":"function Fib_16487(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_16487(n-1) + Fib_16487(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_16488","instance":16488,"id":236503,"goal":"function Gcd_16488(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_16488(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_16489","instance":16489,"id":236504,"goal":"function Power_16489(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_16489(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_16490","instance":16490,"id":236505,"goal":"function Sum_16490(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_16490(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_16491","instance":16491,"id":236506,"goal":"method BinarySearch_16491(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_16492","instance":16492,"id":236507,"goal":"method InsertSort_16492(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_16493","instance":16493,"id":236508,"goal":"method MergeSort_16493(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_16494","instance":16494,"id":236509,"goal":"method ArrayCopy_16494(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_16495","instance":16495,"id":236510,"goal":"function ListReverse_16495(s: seq): seq\n ensures |ListReverse_16495(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_16495(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_16496","instance":16496,"id":236511,"goal":"function Factorial_16496(n: nat): nat\n ensures Factorial_16496(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_16496(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_16497","instance":16497,"id":236512,"goal":"function Fib_16497(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_16497(n-1) + Fib_16497(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_16498","instance":16498,"id":236513,"goal":"function Gcd_16498(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_16498(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_16499","instance":16499,"id":236514,"goal":"function Power_16499(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_16499(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_16500","instance":16500,"id":236515,"goal":"function Sum_16500(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_16500(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_16501","instance":16501,"id":236516,"goal":"method BinarySearch_16501(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_16502","instance":16502,"id":236517,"goal":"method InsertSort_16502(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_16503","instance":16503,"id":236518,"goal":"method MergeSort_16503(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_16504","instance":16504,"id":236519,"goal":"method ArrayCopy_16504(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_16505","instance":16505,"id":236520,"goal":"function ListReverse_16505(s: seq): seq\n ensures |ListReverse_16505(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_16505(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_16506","instance":16506,"id":236521,"goal":"function Factorial_16506(n: nat): nat\n ensures Factorial_16506(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_16506(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_16507","instance":16507,"id":236522,"goal":"function Fib_16507(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_16507(n-1) + Fib_16507(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_16508","instance":16508,"id":236523,"goal":"function Gcd_16508(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_16508(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_16509","instance":16509,"id":236524,"goal":"function Power_16509(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_16509(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_16510","instance":16510,"id":236525,"goal":"function Sum_16510(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_16510(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_16511","instance":16511,"id":236526,"goal":"method BinarySearch_16511(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_16512","instance":16512,"id":236527,"goal":"method InsertSort_16512(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_16513","instance":16513,"id":236528,"goal":"method MergeSort_16513(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_16514","instance":16514,"id":236529,"goal":"method ArrayCopy_16514(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_16515","instance":16515,"id":236530,"goal":"function ListReverse_16515(s: seq): seq\n ensures |ListReverse_16515(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_16515(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_16516","instance":16516,"id":236531,"goal":"function Factorial_16516(n: nat): nat\n ensures Factorial_16516(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_16516(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_16517","instance":16517,"id":236532,"goal":"function Fib_16517(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_16517(n-1) + Fib_16517(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_16518","instance":16518,"id":236533,"goal":"function Gcd_16518(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_16518(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_16519","instance":16519,"id":236534,"goal":"function Power_16519(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_16519(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_16520","instance":16520,"id":236535,"goal":"function Sum_16520(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_16520(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_16521","instance":16521,"id":236536,"goal":"method BinarySearch_16521(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_16522","instance":16522,"id":236537,"goal":"method InsertSort_16522(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_16523","instance":16523,"id":236538,"goal":"method MergeSort_16523(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_16524","instance":16524,"id":236539,"goal":"method ArrayCopy_16524(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_16525","instance":16525,"id":236540,"goal":"function ListReverse_16525(s: seq): seq\n ensures |ListReverse_16525(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_16525(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_16526","instance":16526,"id":236541,"goal":"function Factorial_16526(n: nat): nat\n ensures Factorial_16526(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_16526(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_16527","instance":16527,"id":236542,"goal":"function Fib_16527(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_16527(n-1) + Fib_16527(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_16528","instance":16528,"id":236543,"goal":"function Gcd_16528(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_16528(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_16529","instance":16529,"id":236544,"goal":"function Power_16529(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_16529(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_16530","instance":16530,"id":236545,"goal":"function Sum_16530(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_16530(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_16531","instance":16531,"id":236546,"goal":"method BinarySearch_16531(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_16532","instance":16532,"id":236547,"goal":"method InsertSort_16532(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_16533","instance":16533,"id":236548,"goal":"method MergeSort_16533(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_16534","instance":16534,"id":236549,"goal":"method ArrayCopy_16534(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_16535","instance":16535,"id":236550,"goal":"function ListReverse_16535(s: seq): seq\n ensures |ListReverse_16535(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_16535(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_16536","instance":16536,"id":236551,"goal":"function Factorial_16536(n: nat): nat\n ensures Factorial_16536(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_16536(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_16537","instance":16537,"id":236552,"goal":"function Fib_16537(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_16537(n-1) + Fib_16537(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_16538","instance":16538,"id":236553,"goal":"function Gcd_16538(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_16538(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_16539","instance":16539,"id":236554,"goal":"function Power_16539(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_16539(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_16540","instance":16540,"id":236555,"goal":"function Sum_16540(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_16540(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_16541","instance":16541,"id":236556,"goal":"method BinarySearch_16541(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_16542","instance":16542,"id":236557,"goal":"method InsertSort_16542(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_16543","instance":16543,"id":236558,"goal":"method MergeSort_16543(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_16544","instance":16544,"id":236559,"goal":"method ArrayCopy_16544(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_16545","instance":16545,"id":236560,"goal":"function ListReverse_16545(s: seq): seq\n ensures |ListReverse_16545(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_16545(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_16546","instance":16546,"id":236561,"goal":"function Factorial_16546(n: nat): nat\n ensures Factorial_16546(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_16546(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_16547","instance":16547,"id":236562,"goal":"function Fib_16547(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_16547(n-1) + Fib_16547(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_16548","instance":16548,"id":236563,"goal":"function Gcd_16548(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_16548(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_16549","instance":16549,"id":236564,"goal":"function Power_16549(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_16549(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_16550","instance":16550,"id":236565,"goal":"function Sum_16550(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_16550(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_16551","instance":16551,"id":236566,"goal":"method BinarySearch_16551(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_16552","instance":16552,"id":236567,"goal":"method InsertSort_16552(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_16553","instance":16553,"id":236568,"goal":"method MergeSort_16553(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_16554","instance":16554,"id":236569,"goal":"method ArrayCopy_16554(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_16555","instance":16555,"id":236570,"goal":"function ListReverse_16555(s: seq): seq\n ensures |ListReverse_16555(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_16555(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_16556","instance":16556,"id":236571,"goal":"function Factorial_16556(n: nat): nat\n ensures Factorial_16556(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_16556(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_16557","instance":16557,"id":236572,"goal":"function Fib_16557(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_16557(n-1) + Fib_16557(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_16558","instance":16558,"id":236573,"goal":"function Gcd_16558(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_16558(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_16559","instance":16559,"id":236574,"goal":"function Power_16559(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_16559(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_16560","instance":16560,"id":236575,"goal":"function Sum_16560(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_16560(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_16561","instance":16561,"id":236576,"goal":"method BinarySearch_16561(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_16562","instance":16562,"id":236577,"goal":"method InsertSort_16562(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_16563","instance":16563,"id":236578,"goal":"method MergeSort_16563(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_16564","instance":16564,"id":236579,"goal":"method ArrayCopy_16564(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_16565","instance":16565,"id":236580,"goal":"function ListReverse_16565(s: seq): seq\n ensures |ListReverse_16565(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_16565(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_16566","instance":16566,"id":236581,"goal":"function Factorial_16566(n: nat): nat\n ensures Factorial_16566(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_16566(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_16567","instance":16567,"id":236582,"goal":"function Fib_16567(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_16567(n-1) + Fib_16567(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_16568","instance":16568,"id":236583,"goal":"function Gcd_16568(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_16568(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_16569","instance":16569,"id":236584,"goal":"function Power_16569(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_16569(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_16570","instance":16570,"id":236585,"goal":"function Sum_16570(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_16570(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_16571","instance":16571,"id":236586,"goal":"method BinarySearch_16571(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_16572","instance":16572,"id":236587,"goal":"method InsertSort_16572(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_16573","instance":16573,"id":236588,"goal":"method MergeSort_16573(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_16574","instance":16574,"id":236589,"goal":"method ArrayCopy_16574(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_16575","instance":16575,"id":236590,"goal":"function ListReverse_16575(s: seq): seq\n ensures |ListReverse_16575(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_16575(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_16576","instance":16576,"id":236591,"goal":"function Factorial_16576(n: nat): nat\n ensures Factorial_16576(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_16576(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_16577","instance":16577,"id":236592,"goal":"function Fib_16577(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_16577(n-1) + Fib_16577(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_16578","instance":16578,"id":236593,"goal":"function Gcd_16578(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_16578(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_16579","instance":16579,"id":236594,"goal":"function Power_16579(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_16579(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_16580","instance":16580,"id":236595,"goal":"function Sum_16580(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_16580(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_16581","instance":16581,"id":236596,"goal":"method BinarySearch_16581(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_16582","instance":16582,"id":236597,"goal":"method InsertSort_16582(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_16583","instance":16583,"id":236598,"goal":"method MergeSort_16583(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_16584","instance":16584,"id":236599,"goal":"method ArrayCopy_16584(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_16585","instance":16585,"id":236600,"goal":"function ListReverse_16585(s: seq): seq\n ensures |ListReverse_16585(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_16585(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_16586","instance":16586,"id":236601,"goal":"function Factorial_16586(n: nat): nat\n ensures Factorial_16586(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_16586(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_16587","instance":16587,"id":236602,"goal":"function Fib_16587(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_16587(n-1) + Fib_16587(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_16588","instance":16588,"id":236603,"goal":"function Gcd_16588(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_16588(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_16589","instance":16589,"id":236604,"goal":"function Power_16589(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_16589(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_16590","instance":16590,"id":236605,"goal":"function Sum_16590(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_16590(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_16591","instance":16591,"id":236606,"goal":"method BinarySearch_16591(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_16592","instance":16592,"id":236607,"goal":"method InsertSort_16592(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_16593","instance":16593,"id":236608,"goal":"method MergeSort_16593(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_16594","instance":16594,"id":236609,"goal":"method ArrayCopy_16594(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_16595","instance":16595,"id":236610,"goal":"function ListReverse_16595(s: seq): seq\n ensures |ListReverse_16595(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_16595(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_16596","instance":16596,"id":236611,"goal":"function Factorial_16596(n: nat): nat\n ensures Factorial_16596(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_16596(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_16597","instance":16597,"id":236612,"goal":"function Fib_16597(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_16597(n-1) + Fib_16597(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_16598","instance":16598,"id":236613,"goal":"function Gcd_16598(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_16598(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_16599","instance":16599,"id":236614,"goal":"function Power_16599(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_16599(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_16600","instance":16600,"id":236615,"goal":"function Sum_16600(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_16600(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_16601","instance":16601,"id":236616,"goal":"method BinarySearch_16601(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_16602","instance":16602,"id":236617,"goal":"method InsertSort_16602(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_16603","instance":16603,"id":236618,"goal":"method MergeSort_16603(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_16604","instance":16604,"id":236619,"goal":"method ArrayCopy_16604(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_16605","instance":16605,"id":236620,"goal":"function ListReverse_16605(s: seq): seq\n ensures |ListReverse_16605(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_16605(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_16606","instance":16606,"id":236621,"goal":"function Factorial_16606(n: nat): nat\n ensures Factorial_16606(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_16606(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_16607","instance":16607,"id":236622,"goal":"function Fib_16607(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_16607(n-1) + Fib_16607(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_16608","instance":16608,"id":236623,"goal":"function Gcd_16608(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_16608(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_16609","instance":16609,"id":236624,"goal":"function Power_16609(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_16609(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_16610","instance":16610,"id":236625,"goal":"function Sum_16610(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_16610(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_16611","instance":16611,"id":236626,"goal":"method BinarySearch_16611(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_16612","instance":16612,"id":236627,"goal":"method InsertSort_16612(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_16613","instance":16613,"id":236628,"goal":"method MergeSort_16613(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_16614","instance":16614,"id":236629,"goal":"method ArrayCopy_16614(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_16615","instance":16615,"id":236630,"goal":"function ListReverse_16615(s: seq): seq\n ensures |ListReverse_16615(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_16615(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_16616","instance":16616,"id":236631,"goal":"function Factorial_16616(n: nat): nat\n ensures Factorial_16616(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_16616(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_16617","instance":16617,"id":236632,"goal":"function Fib_16617(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_16617(n-1) + Fib_16617(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_16618","instance":16618,"id":236633,"goal":"function Gcd_16618(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_16618(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_16619","instance":16619,"id":236634,"goal":"function Power_16619(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_16619(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_16620","instance":16620,"id":236635,"goal":"function Sum_16620(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_16620(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_16621","instance":16621,"id":236636,"goal":"method BinarySearch_16621(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_16622","instance":16622,"id":236637,"goal":"method InsertSort_16622(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_16623","instance":16623,"id":236638,"goal":"method MergeSort_16623(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_16624","instance":16624,"id":236639,"goal":"method ArrayCopy_16624(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_16625","instance":16625,"id":236640,"goal":"function ListReverse_16625(s: seq): seq\n ensures |ListReverse_16625(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_16625(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_16626","instance":16626,"id":236641,"goal":"function Factorial_16626(n: nat): nat\n ensures Factorial_16626(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_16626(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_16627","instance":16627,"id":236642,"goal":"function Fib_16627(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_16627(n-1) + Fib_16627(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_16628","instance":16628,"id":236643,"goal":"function Gcd_16628(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_16628(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_16629","instance":16629,"id":236644,"goal":"function Power_16629(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_16629(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_16630","instance":16630,"id":236645,"goal":"function Sum_16630(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_16630(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_16631","instance":16631,"id":236646,"goal":"method BinarySearch_16631(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_16632","instance":16632,"id":236647,"goal":"method InsertSort_16632(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_16633","instance":16633,"id":236648,"goal":"method MergeSort_16633(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_16634","instance":16634,"id":236649,"goal":"method ArrayCopy_16634(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_16635","instance":16635,"id":236650,"goal":"function ListReverse_16635(s: seq): seq\n ensures |ListReverse_16635(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_16635(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_16636","instance":16636,"id":236651,"goal":"function Factorial_16636(n: nat): nat\n ensures Factorial_16636(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_16636(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_16637","instance":16637,"id":236652,"goal":"function Fib_16637(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_16637(n-1) + Fib_16637(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_16638","instance":16638,"id":236653,"goal":"function Gcd_16638(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_16638(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_16639","instance":16639,"id":236654,"goal":"function Power_16639(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_16639(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_16640","instance":16640,"id":236655,"goal":"function Sum_16640(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_16640(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_16641","instance":16641,"id":236656,"goal":"method BinarySearch_16641(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_16642","instance":16642,"id":236657,"goal":"method InsertSort_16642(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_16643","instance":16643,"id":236658,"goal":"method MergeSort_16643(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_16644","instance":16644,"id":236659,"goal":"method ArrayCopy_16644(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_16645","instance":16645,"id":236660,"goal":"function ListReverse_16645(s: seq): seq\n ensures |ListReverse_16645(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_16645(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_16646","instance":16646,"id":236661,"goal":"function Factorial_16646(n: nat): nat\n ensures Factorial_16646(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_16646(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_16647","instance":16647,"id":236662,"goal":"function Fib_16647(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_16647(n-1) + Fib_16647(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_16648","instance":16648,"id":236663,"goal":"function Gcd_16648(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_16648(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_16649","instance":16649,"id":236664,"goal":"function Power_16649(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_16649(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_16650","instance":16650,"id":236665,"goal":"function Sum_16650(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_16650(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_16651","instance":16651,"id":236666,"goal":"method BinarySearch_16651(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_16652","instance":16652,"id":236667,"goal":"method InsertSort_16652(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_16653","instance":16653,"id":236668,"goal":"method MergeSort_16653(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_16654","instance":16654,"id":236669,"goal":"method ArrayCopy_16654(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_16655","instance":16655,"id":236670,"goal":"function ListReverse_16655(s: seq): seq\n ensures |ListReverse_16655(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_16655(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_16656","instance":16656,"id":236671,"goal":"function Factorial_16656(n: nat): nat\n ensures Factorial_16656(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_16656(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_16657","instance":16657,"id":236672,"goal":"function Fib_16657(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_16657(n-1) + Fib_16657(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_16658","instance":16658,"id":236673,"goal":"function Gcd_16658(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_16658(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_16659","instance":16659,"id":236674,"goal":"function Power_16659(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_16659(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_16660","instance":16660,"id":236675,"goal":"function Sum_16660(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_16660(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_16661","instance":16661,"id":236676,"goal":"method BinarySearch_16661(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_16662","instance":16662,"id":236677,"goal":"method InsertSort_16662(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"MergeSort","theorem":"MergeSort_16663","instance":16663,"id":236678,"goal":"method MergeSort_16663(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n modifies a\n ensures Sorted(a, lo, hi)\n decreases hi - lo\n{}","tactics":["requires","modifies","ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ArrayCopy","theorem":"ArrayCopy_16664","instance":16664,"id":236679,"goal":"method ArrayCopy_16664(src: array, dst: array)\n requires src.Length == dst.Length\n modifies dst\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n{}","tactics":["requires","modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"ListReverse","theorem":"ListReverse_16665","instance":16665,"id":236680,"goal":"function ListReverse_16665(s: seq): seq\n ensures |ListReverse_16665(s)| == |s|\n decreases |s|\n{ if |s| == 0 then [] else ListReverse_16665(s[1..]) + [s[0]] }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Factorial","theorem":"Factorial_16666","instance":16666,"id":236681,"goal":"function Factorial_16666(n: nat): nat\n ensures Factorial_16666(n) >= 1\n decreases n\n{ if n == 0 then 1 else n * Factorial_16666(n - 1) }","tactics":["ensures","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Fib","theorem":"Fib_16667","instance":16667,"id":236682,"goal":"function Fib_16667(n: nat): nat\n decreases n\n{ if n < 2 then n else Fib_16667(n-1) + Fib_16667(n-2) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Gcd","theorem":"Gcd_16668","instance":16668,"id":236683,"goal":"function Gcd_16668(a: nat, b: nat): nat\n requires a > 0 || b > 0\n decreases a + b\n{ if b == 0 then a else Gcd_16668(b, a % b) }","tactics":["requires","decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Power","theorem":"Power_16669","instance":16669,"id":236684,"goal":"function Power_16669(base: int, n: nat): int\n decreases n\n{ if n == 0 then 1 else base * Power_16669(base, n-1) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"Sum","theorem":"Sum_16670","instance":16670,"id":236685,"goal":"function Sum_16670(s: seq): int\n decreases |s|\n{ if |s| == 0 then 0 else s[0] + Sum_16670(s[1..]) }","tactics":["decreases"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"BinarySearch","theorem":"BinarySearch_16671","instance":16671,"id":236686,"goal":"method BinarySearch_16671(a: array, key: int) returns (index: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= index < a.Length ==> a[index] == key\n ensures index < 0 ==> forall i :: 0 <= i < a.Length ==> a[i] != key\n{}","tactics":["requires","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/methods","variant":"InsertSort","theorem":"InsertSort_16672","instance":16672,"id":236687,"goal":"method InsertSort_16672(a: array)\n modifies a\n ensures Sorted(a, 0, a.Length)\n ensures multiset(a[..]) == multiset(old(a[..]))\n{}","tactics":["modifies","ensures"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_1","instance":1,"id":236688,"goal":"predicate Sorted_1(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_2","instance":2,"id":236689,"goal":"predicate AllPositive_2(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_3","instance":3,"id":236690,"goal":"predicate DistinctSeq_3(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_4","instance":4,"id":236691,"goal":"predicate IsSubseq_4(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_5","instance":5,"id":236692,"goal":"predicate IsPermutation_5(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_6","instance":6,"id":236693,"goal":"predicate IsEven_6(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_7","instance":7,"id":236694,"goal":"predicate InRange_7(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_8","instance":8,"id":236695,"goal":"predicate SubsetOf_8(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_9","instance":9,"id":236696,"goal":"predicate AllMem_9(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_10","instance":10,"id":236697,"goal":"predicate DisjointSets_10(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_11","instance":11,"id":236698,"goal":"predicate Sorted_11(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_12","instance":12,"id":236699,"goal":"predicate AllPositive_12(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_13","instance":13,"id":236700,"goal":"predicate DistinctSeq_13(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_14","instance":14,"id":236701,"goal":"predicate IsSubseq_14(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_15","instance":15,"id":236702,"goal":"predicate IsPermutation_15(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_16","instance":16,"id":236703,"goal":"predicate IsEven_16(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_17","instance":17,"id":236704,"goal":"predicate InRange_17(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_18","instance":18,"id":236705,"goal":"predicate SubsetOf_18(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_19","instance":19,"id":236706,"goal":"predicate AllMem_19(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_20","instance":20,"id":236707,"goal":"predicate DisjointSets_20(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_21","instance":21,"id":236708,"goal":"predicate Sorted_21(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_22","instance":22,"id":236709,"goal":"predicate AllPositive_22(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_23","instance":23,"id":236710,"goal":"predicate DistinctSeq_23(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_24","instance":24,"id":236711,"goal":"predicate IsSubseq_24(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_25","instance":25,"id":236712,"goal":"predicate IsPermutation_25(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_26","instance":26,"id":236713,"goal":"predicate IsEven_26(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_27","instance":27,"id":236714,"goal":"predicate InRange_27(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_28","instance":28,"id":236715,"goal":"predicate SubsetOf_28(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_29","instance":29,"id":236716,"goal":"predicate AllMem_29(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_30","instance":30,"id":236717,"goal":"predicate DisjointSets_30(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_31","instance":31,"id":236718,"goal":"predicate Sorted_31(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_32","instance":32,"id":236719,"goal":"predicate AllPositive_32(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_33","instance":33,"id":236720,"goal":"predicate DistinctSeq_33(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_34","instance":34,"id":236721,"goal":"predicate IsSubseq_34(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_35","instance":35,"id":236722,"goal":"predicate IsPermutation_35(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_36","instance":36,"id":236723,"goal":"predicate IsEven_36(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_37","instance":37,"id":236724,"goal":"predicate InRange_37(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_38","instance":38,"id":236725,"goal":"predicate SubsetOf_38(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_39","instance":39,"id":236726,"goal":"predicate AllMem_39(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_40","instance":40,"id":236727,"goal":"predicate DisjointSets_40(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_41","instance":41,"id":236728,"goal":"predicate Sorted_41(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_42","instance":42,"id":236729,"goal":"predicate AllPositive_42(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_43","instance":43,"id":236730,"goal":"predicate DistinctSeq_43(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_44","instance":44,"id":236731,"goal":"predicate IsSubseq_44(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_45","instance":45,"id":236732,"goal":"predicate IsPermutation_45(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_46","instance":46,"id":236733,"goal":"predicate IsEven_46(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_47","instance":47,"id":236734,"goal":"predicate InRange_47(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_48","instance":48,"id":236735,"goal":"predicate SubsetOf_48(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_49","instance":49,"id":236736,"goal":"predicate AllMem_49(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_50","instance":50,"id":236737,"goal":"predicate DisjointSets_50(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_51","instance":51,"id":236738,"goal":"predicate Sorted_51(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_52","instance":52,"id":236739,"goal":"predicate AllPositive_52(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_53","instance":53,"id":236740,"goal":"predicate DistinctSeq_53(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_54","instance":54,"id":236741,"goal":"predicate IsSubseq_54(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_55","instance":55,"id":236742,"goal":"predicate IsPermutation_55(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_56","instance":56,"id":236743,"goal":"predicate IsEven_56(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_57","instance":57,"id":236744,"goal":"predicate InRange_57(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_58","instance":58,"id":236745,"goal":"predicate SubsetOf_58(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_59","instance":59,"id":236746,"goal":"predicate AllMem_59(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_60","instance":60,"id":236747,"goal":"predicate DisjointSets_60(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_61","instance":61,"id":236748,"goal":"predicate Sorted_61(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_62","instance":62,"id":236749,"goal":"predicate AllPositive_62(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_63","instance":63,"id":236750,"goal":"predicate DistinctSeq_63(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_64","instance":64,"id":236751,"goal":"predicate IsSubseq_64(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_65","instance":65,"id":236752,"goal":"predicate IsPermutation_65(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_66","instance":66,"id":236753,"goal":"predicate IsEven_66(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_67","instance":67,"id":236754,"goal":"predicate InRange_67(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_68","instance":68,"id":236755,"goal":"predicate SubsetOf_68(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_69","instance":69,"id":236756,"goal":"predicate AllMem_69(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_70","instance":70,"id":236757,"goal":"predicate DisjointSets_70(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_71","instance":71,"id":236758,"goal":"predicate Sorted_71(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_72","instance":72,"id":236759,"goal":"predicate AllPositive_72(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_73","instance":73,"id":236760,"goal":"predicate DistinctSeq_73(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_74","instance":74,"id":236761,"goal":"predicate IsSubseq_74(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_75","instance":75,"id":236762,"goal":"predicate IsPermutation_75(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_76","instance":76,"id":236763,"goal":"predicate IsEven_76(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_77","instance":77,"id":236764,"goal":"predicate InRange_77(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_78","instance":78,"id":236765,"goal":"predicate SubsetOf_78(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_79","instance":79,"id":236766,"goal":"predicate AllMem_79(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_80","instance":80,"id":236767,"goal":"predicate DisjointSets_80(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_81","instance":81,"id":236768,"goal":"predicate Sorted_81(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_82","instance":82,"id":236769,"goal":"predicate AllPositive_82(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_83","instance":83,"id":236770,"goal":"predicate DistinctSeq_83(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_84","instance":84,"id":236771,"goal":"predicate IsSubseq_84(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_85","instance":85,"id":236772,"goal":"predicate IsPermutation_85(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_86","instance":86,"id":236773,"goal":"predicate IsEven_86(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_87","instance":87,"id":236774,"goal":"predicate InRange_87(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_88","instance":88,"id":236775,"goal":"predicate SubsetOf_88(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_89","instance":89,"id":236776,"goal":"predicate AllMem_89(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_90","instance":90,"id":236777,"goal":"predicate DisjointSets_90(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_91","instance":91,"id":236778,"goal":"predicate Sorted_91(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_92","instance":92,"id":236779,"goal":"predicate AllPositive_92(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_93","instance":93,"id":236780,"goal":"predicate DistinctSeq_93(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_94","instance":94,"id":236781,"goal":"predicate IsSubseq_94(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_95","instance":95,"id":236782,"goal":"predicate IsPermutation_95(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_96","instance":96,"id":236783,"goal":"predicate IsEven_96(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_97","instance":97,"id":236784,"goal":"predicate InRange_97(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_98","instance":98,"id":236785,"goal":"predicate SubsetOf_98(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_99","instance":99,"id":236786,"goal":"predicate AllMem_99(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_100","instance":100,"id":236787,"goal":"predicate DisjointSets_100(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_101","instance":101,"id":236788,"goal":"predicate Sorted_101(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_102","instance":102,"id":236789,"goal":"predicate AllPositive_102(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_103","instance":103,"id":236790,"goal":"predicate DistinctSeq_103(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_104","instance":104,"id":236791,"goal":"predicate IsSubseq_104(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_105","instance":105,"id":236792,"goal":"predicate IsPermutation_105(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_106","instance":106,"id":236793,"goal":"predicate IsEven_106(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_107","instance":107,"id":236794,"goal":"predicate InRange_107(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_108","instance":108,"id":236795,"goal":"predicate SubsetOf_108(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_109","instance":109,"id":236796,"goal":"predicate AllMem_109(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_110","instance":110,"id":236797,"goal":"predicate DisjointSets_110(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_111","instance":111,"id":236798,"goal":"predicate Sorted_111(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_112","instance":112,"id":236799,"goal":"predicate AllPositive_112(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_113","instance":113,"id":236800,"goal":"predicate DistinctSeq_113(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_114","instance":114,"id":236801,"goal":"predicate IsSubseq_114(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_115","instance":115,"id":236802,"goal":"predicate IsPermutation_115(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_116","instance":116,"id":236803,"goal":"predicate IsEven_116(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_117","instance":117,"id":236804,"goal":"predicate InRange_117(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_118","instance":118,"id":236805,"goal":"predicate SubsetOf_118(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_119","instance":119,"id":236806,"goal":"predicate AllMem_119(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_120","instance":120,"id":236807,"goal":"predicate DisjointSets_120(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_121","instance":121,"id":236808,"goal":"predicate Sorted_121(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_122","instance":122,"id":236809,"goal":"predicate AllPositive_122(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_123","instance":123,"id":236810,"goal":"predicate DistinctSeq_123(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_124","instance":124,"id":236811,"goal":"predicate IsSubseq_124(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_125","instance":125,"id":236812,"goal":"predicate IsPermutation_125(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_126","instance":126,"id":236813,"goal":"predicate IsEven_126(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_127","instance":127,"id":236814,"goal":"predicate InRange_127(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_128","instance":128,"id":236815,"goal":"predicate SubsetOf_128(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_129","instance":129,"id":236816,"goal":"predicate AllMem_129(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_130","instance":130,"id":236817,"goal":"predicate DisjointSets_130(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_131","instance":131,"id":236818,"goal":"predicate Sorted_131(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_132","instance":132,"id":236819,"goal":"predicate AllPositive_132(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_133","instance":133,"id":236820,"goal":"predicate DistinctSeq_133(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_134","instance":134,"id":236821,"goal":"predicate IsSubseq_134(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_135","instance":135,"id":236822,"goal":"predicate IsPermutation_135(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_136","instance":136,"id":236823,"goal":"predicate IsEven_136(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_137","instance":137,"id":236824,"goal":"predicate InRange_137(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_138","instance":138,"id":236825,"goal":"predicate SubsetOf_138(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_139","instance":139,"id":236826,"goal":"predicate AllMem_139(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_140","instance":140,"id":236827,"goal":"predicate DisjointSets_140(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_141","instance":141,"id":236828,"goal":"predicate Sorted_141(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_142","instance":142,"id":236829,"goal":"predicate AllPositive_142(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_143","instance":143,"id":236830,"goal":"predicate DistinctSeq_143(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_144","instance":144,"id":236831,"goal":"predicate IsSubseq_144(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_145","instance":145,"id":236832,"goal":"predicate IsPermutation_145(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_146","instance":146,"id":236833,"goal":"predicate IsEven_146(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_147","instance":147,"id":236834,"goal":"predicate InRange_147(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_148","instance":148,"id":236835,"goal":"predicate SubsetOf_148(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_149","instance":149,"id":236836,"goal":"predicate AllMem_149(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_150","instance":150,"id":236837,"goal":"predicate DisjointSets_150(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_151","instance":151,"id":236838,"goal":"predicate Sorted_151(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_152","instance":152,"id":236839,"goal":"predicate AllPositive_152(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_153","instance":153,"id":236840,"goal":"predicate DistinctSeq_153(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_154","instance":154,"id":236841,"goal":"predicate IsSubseq_154(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_155","instance":155,"id":236842,"goal":"predicate IsPermutation_155(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_156","instance":156,"id":236843,"goal":"predicate IsEven_156(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_157","instance":157,"id":236844,"goal":"predicate InRange_157(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_158","instance":158,"id":236845,"goal":"predicate SubsetOf_158(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_159","instance":159,"id":236846,"goal":"predicate AllMem_159(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_160","instance":160,"id":236847,"goal":"predicate DisjointSets_160(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_161","instance":161,"id":236848,"goal":"predicate Sorted_161(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_162","instance":162,"id":236849,"goal":"predicate AllPositive_162(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_163","instance":163,"id":236850,"goal":"predicate DistinctSeq_163(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_164","instance":164,"id":236851,"goal":"predicate IsSubseq_164(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_165","instance":165,"id":236852,"goal":"predicate IsPermutation_165(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_166","instance":166,"id":236853,"goal":"predicate IsEven_166(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_167","instance":167,"id":236854,"goal":"predicate InRange_167(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_168","instance":168,"id":236855,"goal":"predicate SubsetOf_168(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_169","instance":169,"id":236856,"goal":"predicate AllMem_169(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_170","instance":170,"id":236857,"goal":"predicate DisjointSets_170(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_171","instance":171,"id":236858,"goal":"predicate Sorted_171(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_172","instance":172,"id":236859,"goal":"predicate AllPositive_172(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_173","instance":173,"id":236860,"goal":"predicate DistinctSeq_173(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_174","instance":174,"id":236861,"goal":"predicate IsSubseq_174(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_175","instance":175,"id":236862,"goal":"predicate IsPermutation_175(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_176","instance":176,"id":236863,"goal":"predicate IsEven_176(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_177","instance":177,"id":236864,"goal":"predicate InRange_177(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_178","instance":178,"id":236865,"goal":"predicate SubsetOf_178(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_179","instance":179,"id":236866,"goal":"predicate AllMem_179(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_180","instance":180,"id":236867,"goal":"predicate DisjointSets_180(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_181","instance":181,"id":236868,"goal":"predicate Sorted_181(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_182","instance":182,"id":236869,"goal":"predicate AllPositive_182(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_183","instance":183,"id":236870,"goal":"predicate DistinctSeq_183(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_184","instance":184,"id":236871,"goal":"predicate IsSubseq_184(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_185","instance":185,"id":236872,"goal":"predicate IsPermutation_185(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_186","instance":186,"id":236873,"goal":"predicate IsEven_186(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_187","instance":187,"id":236874,"goal":"predicate InRange_187(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_188","instance":188,"id":236875,"goal":"predicate SubsetOf_188(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_189","instance":189,"id":236876,"goal":"predicate AllMem_189(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_190","instance":190,"id":236877,"goal":"predicate DisjointSets_190(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_191","instance":191,"id":236878,"goal":"predicate Sorted_191(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_192","instance":192,"id":236879,"goal":"predicate AllPositive_192(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_193","instance":193,"id":236880,"goal":"predicate DistinctSeq_193(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_194","instance":194,"id":236881,"goal":"predicate IsSubseq_194(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_195","instance":195,"id":236882,"goal":"predicate IsPermutation_195(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_196","instance":196,"id":236883,"goal":"predicate IsEven_196(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_197","instance":197,"id":236884,"goal":"predicate InRange_197(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_198","instance":198,"id":236885,"goal":"predicate SubsetOf_198(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_199","instance":199,"id":236886,"goal":"predicate AllMem_199(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_200","instance":200,"id":236887,"goal":"predicate DisjointSets_200(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_201","instance":201,"id":236888,"goal":"predicate Sorted_201(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_202","instance":202,"id":236889,"goal":"predicate AllPositive_202(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_203","instance":203,"id":236890,"goal":"predicate DistinctSeq_203(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_204","instance":204,"id":236891,"goal":"predicate IsSubseq_204(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_205","instance":205,"id":236892,"goal":"predicate IsPermutation_205(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_206","instance":206,"id":236893,"goal":"predicate IsEven_206(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_207","instance":207,"id":236894,"goal":"predicate InRange_207(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_208","instance":208,"id":236895,"goal":"predicate SubsetOf_208(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_209","instance":209,"id":236896,"goal":"predicate AllMem_209(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_210","instance":210,"id":236897,"goal":"predicate DisjointSets_210(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_211","instance":211,"id":236898,"goal":"predicate Sorted_211(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_212","instance":212,"id":236899,"goal":"predicate AllPositive_212(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_213","instance":213,"id":236900,"goal":"predicate DistinctSeq_213(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_214","instance":214,"id":236901,"goal":"predicate IsSubseq_214(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_215","instance":215,"id":236902,"goal":"predicate IsPermutation_215(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_216","instance":216,"id":236903,"goal":"predicate IsEven_216(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_217","instance":217,"id":236904,"goal":"predicate InRange_217(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_218","instance":218,"id":236905,"goal":"predicate SubsetOf_218(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_219","instance":219,"id":236906,"goal":"predicate AllMem_219(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_220","instance":220,"id":236907,"goal":"predicate DisjointSets_220(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_221","instance":221,"id":236908,"goal":"predicate Sorted_221(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_222","instance":222,"id":236909,"goal":"predicate AllPositive_222(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_223","instance":223,"id":236910,"goal":"predicate DistinctSeq_223(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_224","instance":224,"id":236911,"goal":"predicate IsSubseq_224(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_225","instance":225,"id":236912,"goal":"predicate IsPermutation_225(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_226","instance":226,"id":236913,"goal":"predicate IsEven_226(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_227","instance":227,"id":236914,"goal":"predicate InRange_227(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_228","instance":228,"id":236915,"goal":"predicate SubsetOf_228(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_229","instance":229,"id":236916,"goal":"predicate AllMem_229(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_230","instance":230,"id":236917,"goal":"predicate DisjointSets_230(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_231","instance":231,"id":236918,"goal":"predicate Sorted_231(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_232","instance":232,"id":236919,"goal":"predicate AllPositive_232(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_233","instance":233,"id":236920,"goal":"predicate DistinctSeq_233(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_234","instance":234,"id":236921,"goal":"predicate IsSubseq_234(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_235","instance":235,"id":236922,"goal":"predicate IsPermutation_235(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_236","instance":236,"id":236923,"goal":"predicate IsEven_236(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_237","instance":237,"id":236924,"goal":"predicate InRange_237(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_238","instance":238,"id":236925,"goal":"predicate SubsetOf_238(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_239","instance":239,"id":236926,"goal":"predicate AllMem_239(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_240","instance":240,"id":236927,"goal":"predicate DisjointSets_240(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_241","instance":241,"id":236928,"goal":"predicate Sorted_241(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_242","instance":242,"id":236929,"goal":"predicate AllPositive_242(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_243","instance":243,"id":236930,"goal":"predicate DistinctSeq_243(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_244","instance":244,"id":236931,"goal":"predicate IsSubseq_244(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_245","instance":245,"id":236932,"goal":"predicate IsPermutation_245(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_246","instance":246,"id":236933,"goal":"predicate IsEven_246(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_247","instance":247,"id":236934,"goal":"predicate InRange_247(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_248","instance":248,"id":236935,"goal":"predicate SubsetOf_248(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_249","instance":249,"id":236936,"goal":"predicate AllMem_249(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_250","instance":250,"id":236937,"goal":"predicate DisjointSets_250(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_251","instance":251,"id":236938,"goal":"predicate Sorted_251(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_252","instance":252,"id":236939,"goal":"predicate AllPositive_252(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_253","instance":253,"id":236940,"goal":"predicate DistinctSeq_253(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_254","instance":254,"id":236941,"goal":"predicate IsSubseq_254(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_255","instance":255,"id":236942,"goal":"predicate IsPermutation_255(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_256","instance":256,"id":236943,"goal":"predicate IsEven_256(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_257","instance":257,"id":236944,"goal":"predicate InRange_257(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_258","instance":258,"id":236945,"goal":"predicate SubsetOf_258(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_259","instance":259,"id":236946,"goal":"predicate AllMem_259(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_260","instance":260,"id":236947,"goal":"predicate DisjointSets_260(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_261","instance":261,"id":236948,"goal":"predicate Sorted_261(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_262","instance":262,"id":236949,"goal":"predicate AllPositive_262(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_263","instance":263,"id":236950,"goal":"predicate DistinctSeq_263(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_264","instance":264,"id":236951,"goal":"predicate IsSubseq_264(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_265","instance":265,"id":236952,"goal":"predicate IsPermutation_265(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_266","instance":266,"id":236953,"goal":"predicate IsEven_266(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_267","instance":267,"id":236954,"goal":"predicate InRange_267(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_268","instance":268,"id":236955,"goal":"predicate SubsetOf_268(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_269","instance":269,"id":236956,"goal":"predicate AllMem_269(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_270","instance":270,"id":236957,"goal":"predicate DisjointSets_270(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_271","instance":271,"id":236958,"goal":"predicate Sorted_271(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_272","instance":272,"id":236959,"goal":"predicate AllPositive_272(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_273","instance":273,"id":236960,"goal":"predicate DistinctSeq_273(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_274","instance":274,"id":236961,"goal":"predicate IsSubseq_274(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_275","instance":275,"id":236962,"goal":"predicate IsPermutation_275(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_276","instance":276,"id":236963,"goal":"predicate IsEven_276(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_277","instance":277,"id":236964,"goal":"predicate InRange_277(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_278","instance":278,"id":236965,"goal":"predicate SubsetOf_278(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_279","instance":279,"id":236966,"goal":"predicate AllMem_279(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_280","instance":280,"id":236967,"goal":"predicate DisjointSets_280(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_281","instance":281,"id":236968,"goal":"predicate Sorted_281(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_282","instance":282,"id":236969,"goal":"predicate AllPositive_282(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_283","instance":283,"id":236970,"goal":"predicate DistinctSeq_283(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_284","instance":284,"id":236971,"goal":"predicate IsSubseq_284(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_285","instance":285,"id":236972,"goal":"predicate IsPermutation_285(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_286","instance":286,"id":236973,"goal":"predicate IsEven_286(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_287","instance":287,"id":236974,"goal":"predicate InRange_287(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_288","instance":288,"id":236975,"goal":"predicate SubsetOf_288(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_289","instance":289,"id":236976,"goal":"predicate AllMem_289(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_290","instance":290,"id":236977,"goal":"predicate DisjointSets_290(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_291","instance":291,"id":236978,"goal":"predicate Sorted_291(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_292","instance":292,"id":236979,"goal":"predicate AllPositive_292(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_293","instance":293,"id":236980,"goal":"predicate DistinctSeq_293(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_294","instance":294,"id":236981,"goal":"predicate IsSubseq_294(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_295","instance":295,"id":236982,"goal":"predicate IsPermutation_295(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_296","instance":296,"id":236983,"goal":"predicate IsEven_296(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_297","instance":297,"id":236984,"goal":"predicate InRange_297(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_298","instance":298,"id":236985,"goal":"predicate SubsetOf_298(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_299","instance":299,"id":236986,"goal":"predicate AllMem_299(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_300","instance":300,"id":236987,"goal":"predicate DisjointSets_300(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_301","instance":301,"id":236988,"goal":"predicate Sorted_301(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_302","instance":302,"id":236989,"goal":"predicate AllPositive_302(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_303","instance":303,"id":236990,"goal":"predicate DistinctSeq_303(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_304","instance":304,"id":236991,"goal":"predicate IsSubseq_304(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_305","instance":305,"id":236992,"goal":"predicate IsPermutation_305(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_306","instance":306,"id":236993,"goal":"predicate IsEven_306(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_307","instance":307,"id":236994,"goal":"predicate InRange_307(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_308","instance":308,"id":236995,"goal":"predicate SubsetOf_308(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_309","instance":309,"id":236996,"goal":"predicate AllMem_309(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_310","instance":310,"id":236997,"goal":"predicate DisjointSets_310(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_311","instance":311,"id":236998,"goal":"predicate Sorted_311(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_312","instance":312,"id":236999,"goal":"predicate AllPositive_312(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_313","instance":313,"id":237000,"goal":"predicate DistinctSeq_313(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_314","instance":314,"id":237001,"goal":"predicate IsSubseq_314(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_315","instance":315,"id":237002,"goal":"predicate IsPermutation_315(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_316","instance":316,"id":237003,"goal":"predicate IsEven_316(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_317","instance":317,"id":237004,"goal":"predicate InRange_317(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_318","instance":318,"id":237005,"goal":"predicate SubsetOf_318(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_319","instance":319,"id":237006,"goal":"predicate AllMem_319(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_320","instance":320,"id":237007,"goal":"predicate DisjointSets_320(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_321","instance":321,"id":237008,"goal":"predicate Sorted_321(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_322","instance":322,"id":237009,"goal":"predicate AllPositive_322(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_323","instance":323,"id":237010,"goal":"predicate DistinctSeq_323(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_324","instance":324,"id":237011,"goal":"predicate IsSubseq_324(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_325","instance":325,"id":237012,"goal":"predicate IsPermutation_325(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_326","instance":326,"id":237013,"goal":"predicate IsEven_326(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_327","instance":327,"id":237014,"goal":"predicate InRange_327(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_328","instance":328,"id":237015,"goal":"predicate SubsetOf_328(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_329","instance":329,"id":237016,"goal":"predicate AllMem_329(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_330","instance":330,"id":237017,"goal":"predicate DisjointSets_330(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_331","instance":331,"id":237018,"goal":"predicate Sorted_331(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_332","instance":332,"id":237019,"goal":"predicate AllPositive_332(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_333","instance":333,"id":237020,"goal":"predicate DistinctSeq_333(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_334","instance":334,"id":237021,"goal":"predicate IsSubseq_334(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_335","instance":335,"id":237022,"goal":"predicate IsPermutation_335(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_336","instance":336,"id":237023,"goal":"predicate IsEven_336(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_337","instance":337,"id":237024,"goal":"predicate InRange_337(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_338","instance":338,"id":237025,"goal":"predicate SubsetOf_338(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_339","instance":339,"id":237026,"goal":"predicate AllMem_339(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_340","instance":340,"id":237027,"goal":"predicate DisjointSets_340(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_341","instance":341,"id":237028,"goal":"predicate Sorted_341(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_342","instance":342,"id":237029,"goal":"predicate AllPositive_342(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_343","instance":343,"id":237030,"goal":"predicate DistinctSeq_343(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_344","instance":344,"id":237031,"goal":"predicate IsSubseq_344(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_345","instance":345,"id":237032,"goal":"predicate IsPermutation_345(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_346","instance":346,"id":237033,"goal":"predicate IsEven_346(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_347","instance":347,"id":237034,"goal":"predicate InRange_347(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_348","instance":348,"id":237035,"goal":"predicate SubsetOf_348(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_349","instance":349,"id":237036,"goal":"predicate AllMem_349(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_350","instance":350,"id":237037,"goal":"predicate DisjointSets_350(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_351","instance":351,"id":237038,"goal":"predicate Sorted_351(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_352","instance":352,"id":237039,"goal":"predicate AllPositive_352(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_353","instance":353,"id":237040,"goal":"predicate DistinctSeq_353(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_354","instance":354,"id":237041,"goal":"predicate IsSubseq_354(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_355","instance":355,"id":237042,"goal":"predicate IsPermutation_355(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_356","instance":356,"id":237043,"goal":"predicate IsEven_356(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_357","instance":357,"id":237044,"goal":"predicate InRange_357(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_358","instance":358,"id":237045,"goal":"predicate SubsetOf_358(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_359","instance":359,"id":237046,"goal":"predicate AllMem_359(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_360","instance":360,"id":237047,"goal":"predicate DisjointSets_360(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_361","instance":361,"id":237048,"goal":"predicate Sorted_361(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_362","instance":362,"id":237049,"goal":"predicate AllPositive_362(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_363","instance":363,"id":237050,"goal":"predicate DistinctSeq_363(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_364","instance":364,"id":237051,"goal":"predicate IsSubseq_364(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_365","instance":365,"id":237052,"goal":"predicate IsPermutation_365(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_366","instance":366,"id":237053,"goal":"predicate IsEven_366(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_367","instance":367,"id":237054,"goal":"predicate InRange_367(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_368","instance":368,"id":237055,"goal":"predicate SubsetOf_368(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_369","instance":369,"id":237056,"goal":"predicate AllMem_369(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_370","instance":370,"id":237057,"goal":"predicate DisjointSets_370(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_371","instance":371,"id":237058,"goal":"predicate Sorted_371(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_372","instance":372,"id":237059,"goal":"predicate AllPositive_372(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_373","instance":373,"id":237060,"goal":"predicate DistinctSeq_373(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_374","instance":374,"id":237061,"goal":"predicate IsSubseq_374(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_375","instance":375,"id":237062,"goal":"predicate IsPermutation_375(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_376","instance":376,"id":237063,"goal":"predicate IsEven_376(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_377","instance":377,"id":237064,"goal":"predicate InRange_377(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_378","instance":378,"id":237065,"goal":"predicate SubsetOf_378(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_379","instance":379,"id":237066,"goal":"predicate AllMem_379(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_380","instance":380,"id":237067,"goal":"predicate DisjointSets_380(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_381","instance":381,"id":237068,"goal":"predicate Sorted_381(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_382","instance":382,"id":237069,"goal":"predicate AllPositive_382(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_383","instance":383,"id":237070,"goal":"predicate DistinctSeq_383(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_384","instance":384,"id":237071,"goal":"predicate IsSubseq_384(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_385","instance":385,"id":237072,"goal":"predicate IsPermutation_385(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_386","instance":386,"id":237073,"goal":"predicate IsEven_386(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_387","instance":387,"id":237074,"goal":"predicate InRange_387(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_388","instance":388,"id":237075,"goal":"predicate SubsetOf_388(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_389","instance":389,"id":237076,"goal":"predicate AllMem_389(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_390","instance":390,"id":237077,"goal":"predicate DisjointSets_390(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_391","instance":391,"id":237078,"goal":"predicate Sorted_391(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_392","instance":392,"id":237079,"goal":"predicate AllPositive_392(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_393","instance":393,"id":237080,"goal":"predicate DistinctSeq_393(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_394","instance":394,"id":237081,"goal":"predicate IsSubseq_394(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_395","instance":395,"id":237082,"goal":"predicate IsPermutation_395(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_396","instance":396,"id":237083,"goal":"predicate IsEven_396(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_397","instance":397,"id":237084,"goal":"predicate InRange_397(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_398","instance":398,"id":237085,"goal":"predicate SubsetOf_398(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_399","instance":399,"id":237086,"goal":"predicate AllMem_399(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_400","instance":400,"id":237087,"goal":"predicate DisjointSets_400(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_401","instance":401,"id":237088,"goal":"predicate Sorted_401(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_402","instance":402,"id":237089,"goal":"predicate AllPositive_402(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_403","instance":403,"id":237090,"goal":"predicate DistinctSeq_403(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_404","instance":404,"id":237091,"goal":"predicate IsSubseq_404(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_405","instance":405,"id":237092,"goal":"predicate IsPermutation_405(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_406","instance":406,"id":237093,"goal":"predicate IsEven_406(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_407","instance":407,"id":237094,"goal":"predicate InRange_407(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_408","instance":408,"id":237095,"goal":"predicate SubsetOf_408(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_409","instance":409,"id":237096,"goal":"predicate AllMem_409(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_410","instance":410,"id":237097,"goal":"predicate DisjointSets_410(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_411","instance":411,"id":237098,"goal":"predicate Sorted_411(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_412","instance":412,"id":237099,"goal":"predicate AllPositive_412(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_413","instance":413,"id":237100,"goal":"predicate DistinctSeq_413(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_414","instance":414,"id":237101,"goal":"predicate IsSubseq_414(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_415","instance":415,"id":237102,"goal":"predicate IsPermutation_415(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_416","instance":416,"id":237103,"goal":"predicate IsEven_416(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_417","instance":417,"id":237104,"goal":"predicate InRange_417(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_418","instance":418,"id":237105,"goal":"predicate SubsetOf_418(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_419","instance":419,"id":237106,"goal":"predicate AllMem_419(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_420","instance":420,"id":237107,"goal":"predicate DisjointSets_420(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_421","instance":421,"id":237108,"goal":"predicate Sorted_421(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_422","instance":422,"id":237109,"goal":"predicate AllPositive_422(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_423","instance":423,"id":237110,"goal":"predicate DistinctSeq_423(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_424","instance":424,"id":237111,"goal":"predicate IsSubseq_424(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_425","instance":425,"id":237112,"goal":"predicate IsPermutation_425(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_426","instance":426,"id":237113,"goal":"predicate IsEven_426(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_427","instance":427,"id":237114,"goal":"predicate InRange_427(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_428","instance":428,"id":237115,"goal":"predicate SubsetOf_428(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_429","instance":429,"id":237116,"goal":"predicate AllMem_429(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_430","instance":430,"id":237117,"goal":"predicate DisjointSets_430(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_431","instance":431,"id":237118,"goal":"predicate Sorted_431(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_432","instance":432,"id":237119,"goal":"predicate AllPositive_432(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_433","instance":433,"id":237120,"goal":"predicate DistinctSeq_433(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_434","instance":434,"id":237121,"goal":"predicate IsSubseq_434(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_435","instance":435,"id":237122,"goal":"predicate IsPermutation_435(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_436","instance":436,"id":237123,"goal":"predicate IsEven_436(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_437","instance":437,"id":237124,"goal":"predicate InRange_437(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_438","instance":438,"id":237125,"goal":"predicate SubsetOf_438(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_439","instance":439,"id":237126,"goal":"predicate AllMem_439(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_440","instance":440,"id":237127,"goal":"predicate DisjointSets_440(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_441","instance":441,"id":237128,"goal":"predicate Sorted_441(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_442","instance":442,"id":237129,"goal":"predicate AllPositive_442(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_443","instance":443,"id":237130,"goal":"predicate DistinctSeq_443(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_444","instance":444,"id":237131,"goal":"predicate IsSubseq_444(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_445","instance":445,"id":237132,"goal":"predicate IsPermutation_445(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_446","instance":446,"id":237133,"goal":"predicate IsEven_446(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_447","instance":447,"id":237134,"goal":"predicate InRange_447(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_448","instance":448,"id":237135,"goal":"predicate SubsetOf_448(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_449","instance":449,"id":237136,"goal":"predicate AllMem_449(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_450","instance":450,"id":237137,"goal":"predicate DisjointSets_450(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_451","instance":451,"id":237138,"goal":"predicate Sorted_451(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_452","instance":452,"id":237139,"goal":"predicate AllPositive_452(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_453","instance":453,"id":237140,"goal":"predicate DistinctSeq_453(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_454","instance":454,"id":237141,"goal":"predicate IsSubseq_454(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_455","instance":455,"id":237142,"goal":"predicate IsPermutation_455(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_456","instance":456,"id":237143,"goal":"predicate IsEven_456(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_457","instance":457,"id":237144,"goal":"predicate InRange_457(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_458","instance":458,"id":237145,"goal":"predicate SubsetOf_458(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_459","instance":459,"id":237146,"goal":"predicate AllMem_459(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_460","instance":460,"id":237147,"goal":"predicate DisjointSets_460(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_461","instance":461,"id":237148,"goal":"predicate Sorted_461(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_462","instance":462,"id":237149,"goal":"predicate AllPositive_462(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_463","instance":463,"id":237150,"goal":"predicate DistinctSeq_463(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_464","instance":464,"id":237151,"goal":"predicate IsSubseq_464(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_465","instance":465,"id":237152,"goal":"predicate IsPermutation_465(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_466","instance":466,"id":237153,"goal":"predicate IsEven_466(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_467","instance":467,"id":237154,"goal":"predicate InRange_467(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_468","instance":468,"id":237155,"goal":"predicate SubsetOf_468(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_469","instance":469,"id":237156,"goal":"predicate AllMem_469(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_470","instance":470,"id":237157,"goal":"predicate DisjointSets_470(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_471","instance":471,"id":237158,"goal":"predicate Sorted_471(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_472","instance":472,"id":237159,"goal":"predicate AllPositive_472(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_473","instance":473,"id":237160,"goal":"predicate DistinctSeq_473(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_474","instance":474,"id":237161,"goal":"predicate IsSubseq_474(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_475","instance":475,"id":237162,"goal":"predicate IsPermutation_475(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_476","instance":476,"id":237163,"goal":"predicate IsEven_476(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_477","instance":477,"id":237164,"goal":"predicate InRange_477(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_478","instance":478,"id":237165,"goal":"predicate SubsetOf_478(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_479","instance":479,"id":237166,"goal":"predicate AllMem_479(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_480","instance":480,"id":237167,"goal":"predicate DisjointSets_480(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_481","instance":481,"id":237168,"goal":"predicate Sorted_481(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_482","instance":482,"id":237169,"goal":"predicate AllPositive_482(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_483","instance":483,"id":237170,"goal":"predicate DistinctSeq_483(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_484","instance":484,"id":237171,"goal":"predicate IsSubseq_484(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_485","instance":485,"id":237172,"goal":"predicate IsPermutation_485(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_486","instance":486,"id":237173,"goal":"predicate IsEven_486(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_487","instance":487,"id":237174,"goal":"predicate InRange_487(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_488","instance":488,"id":237175,"goal":"predicate SubsetOf_488(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_489","instance":489,"id":237176,"goal":"predicate AllMem_489(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_490","instance":490,"id":237177,"goal":"predicate DisjointSets_490(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_491","instance":491,"id":237178,"goal":"predicate Sorted_491(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_492","instance":492,"id":237179,"goal":"predicate AllPositive_492(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_493","instance":493,"id":237180,"goal":"predicate DistinctSeq_493(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_494","instance":494,"id":237181,"goal":"predicate IsSubseq_494(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_495","instance":495,"id":237182,"goal":"predicate IsPermutation_495(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_496","instance":496,"id":237183,"goal":"predicate IsEven_496(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_497","instance":497,"id":237184,"goal":"predicate InRange_497(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_498","instance":498,"id":237185,"goal":"predicate SubsetOf_498(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_499","instance":499,"id":237186,"goal":"predicate AllMem_499(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_500","instance":500,"id":237187,"goal":"predicate DisjointSets_500(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_501","instance":501,"id":237188,"goal":"predicate Sorted_501(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_502","instance":502,"id":237189,"goal":"predicate AllPositive_502(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_503","instance":503,"id":237190,"goal":"predicate DistinctSeq_503(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_504","instance":504,"id":237191,"goal":"predicate IsSubseq_504(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_505","instance":505,"id":237192,"goal":"predicate IsPermutation_505(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_506","instance":506,"id":237193,"goal":"predicate IsEven_506(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_507","instance":507,"id":237194,"goal":"predicate InRange_507(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_508","instance":508,"id":237195,"goal":"predicate SubsetOf_508(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_509","instance":509,"id":237196,"goal":"predicate AllMem_509(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_510","instance":510,"id":237197,"goal":"predicate DisjointSets_510(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_511","instance":511,"id":237198,"goal":"predicate Sorted_511(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_512","instance":512,"id":237199,"goal":"predicate AllPositive_512(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_513","instance":513,"id":237200,"goal":"predicate DistinctSeq_513(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_514","instance":514,"id":237201,"goal":"predicate IsSubseq_514(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_515","instance":515,"id":237202,"goal":"predicate IsPermutation_515(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_516","instance":516,"id":237203,"goal":"predicate IsEven_516(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_517","instance":517,"id":237204,"goal":"predicate InRange_517(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_518","instance":518,"id":237205,"goal":"predicate SubsetOf_518(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_519","instance":519,"id":237206,"goal":"predicate AllMem_519(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_520","instance":520,"id":237207,"goal":"predicate DisjointSets_520(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_521","instance":521,"id":237208,"goal":"predicate Sorted_521(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_522","instance":522,"id":237209,"goal":"predicate AllPositive_522(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_523","instance":523,"id":237210,"goal":"predicate DistinctSeq_523(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_524","instance":524,"id":237211,"goal":"predicate IsSubseq_524(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_525","instance":525,"id":237212,"goal":"predicate IsPermutation_525(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_526","instance":526,"id":237213,"goal":"predicate IsEven_526(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_527","instance":527,"id":237214,"goal":"predicate InRange_527(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_528","instance":528,"id":237215,"goal":"predicate SubsetOf_528(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_529","instance":529,"id":237216,"goal":"predicate AllMem_529(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_530","instance":530,"id":237217,"goal":"predicate DisjointSets_530(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_531","instance":531,"id":237218,"goal":"predicate Sorted_531(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_532","instance":532,"id":237219,"goal":"predicate AllPositive_532(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_533","instance":533,"id":237220,"goal":"predicate DistinctSeq_533(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_534","instance":534,"id":237221,"goal":"predicate IsSubseq_534(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_535","instance":535,"id":237222,"goal":"predicate IsPermutation_535(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_536","instance":536,"id":237223,"goal":"predicate IsEven_536(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_537","instance":537,"id":237224,"goal":"predicate InRange_537(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_538","instance":538,"id":237225,"goal":"predicate SubsetOf_538(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_539","instance":539,"id":237226,"goal":"predicate AllMem_539(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_540","instance":540,"id":237227,"goal":"predicate DisjointSets_540(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_541","instance":541,"id":237228,"goal":"predicate Sorted_541(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_542","instance":542,"id":237229,"goal":"predicate AllPositive_542(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_543","instance":543,"id":237230,"goal":"predicate DistinctSeq_543(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_544","instance":544,"id":237231,"goal":"predicate IsSubseq_544(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_545","instance":545,"id":237232,"goal":"predicate IsPermutation_545(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_546","instance":546,"id":237233,"goal":"predicate IsEven_546(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_547","instance":547,"id":237234,"goal":"predicate InRange_547(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_548","instance":548,"id":237235,"goal":"predicate SubsetOf_548(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_549","instance":549,"id":237236,"goal":"predicate AllMem_549(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_550","instance":550,"id":237237,"goal":"predicate DisjointSets_550(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_551","instance":551,"id":237238,"goal":"predicate Sorted_551(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_552","instance":552,"id":237239,"goal":"predicate AllPositive_552(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_553","instance":553,"id":237240,"goal":"predicate DistinctSeq_553(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_554","instance":554,"id":237241,"goal":"predicate IsSubseq_554(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_555","instance":555,"id":237242,"goal":"predicate IsPermutation_555(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_556","instance":556,"id":237243,"goal":"predicate IsEven_556(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_557","instance":557,"id":237244,"goal":"predicate InRange_557(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_558","instance":558,"id":237245,"goal":"predicate SubsetOf_558(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_559","instance":559,"id":237246,"goal":"predicate AllMem_559(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_560","instance":560,"id":237247,"goal":"predicate DisjointSets_560(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_561","instance":561,"id":237248,"goal":"predicate Sorted_561(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_562","instance":562,"id":237249,"goal":"predicate AllPositive_562(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_563","instance":563,"id":237250,"goal":"predicate DistinctSeq_563(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_564","instance":564,"id":237251,"goal":"predicate IsSubseq_564(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_565","instance":565,"id":237252,"goal":"predicate IsPermutation_565(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_566","instance":566,"id":237253,"goal":"predicate IsEven_566(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_567","instance":567,"id":237254,"goal":"predicate InRange_567(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_568","instance":568,"id":237255,"goal":"predicate SubsetOf_568(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_569","instance":569,"id":237256,"goal":"predicate AllMem_569(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_570","instance":570,"id":237257,"goal":"predicate DisjointSets_570(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_571","instance":571,"id":237258,"goal":"predicate Sorted_571(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_572","instance":572,"id":237259,"goal":"predicate AllPositive_572(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_573","instance":573,"id":237260,"goal":"predicate DistinctSeq_573(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_574","instance":574,"id":237261,"goal":"predicate IsSubseq_574(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_575","instance":575,"id":237262,"goal":"predicate IsPermutation_575(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_576","instance":576,"id":237263,"goal":"predicate IsEven_576(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_577","instance":577,"id":237264,"goal":"predicate InRange_577(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_578","instance":578,"id":237265,"goal":"predicate SubsetOf_578(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_579","instance":579,"id":237266,"goal":"predicate AllMem_579(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_580","instance":580,"id":237267,"goal":"predicate DisjointSets_580(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_581","instance":581,"id":237268,"goal":"predicate Sorted_581(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_582","instance":582,"id":237269,"goal":"predicate AllPositive_582(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_583","instance":583,"id":237270,"goal":"predicate DistinctSeq_583(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_584","instance":584,"id":237271,"goal":"predicate IsSubseq_584(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_585","instance":585,"id":237272,"goal":"predicate IsPermutation_585(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_586","instance":586,"id":237273,"goal":"predicate IsEven_586(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_587","instance":587,"id":237274,"goal":"predicate InRange_587(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_588","instance":588,"id":237275,"goal":"predicate SubsetOf_588(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_589","instance":589,"id":237276,"goal":"predicate AllMem_589(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_590","instance":590,"id":237277,"goal":"predicate DisjointSets_590(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_591","instance":591,"id":237278,"goal":"predicate Sorted_591(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_592","instance":592,"id":237279,"goal":"predicate AllPositive_592(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_593","instance":593,"id":237280,"goal":"predicate DistinctSeq_593(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_594","instance":594,"id":237281,"goal":"predicate IsSubseq_594(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_595","instance":595,"id":237282,"goal":"predicate IsPermutation_595(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_596","instance":596,"id":237283,"goal":"predicate IsEven_596(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_597","instance":597,"id":237284,"goal":"predicate InRange_597(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_598","instance":598,"id":237285,"goal":"predicate SubsetOf_598(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_599","instance":599,"id":237286,"goal":"predicate AllMem_599(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_600","instance":600,"id":237287,"goal":"predicate DisjointSets_600(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_601","instance":601,"id":237288,"goal":"predicate Sorted_601(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_602","instance":602,"id":237289,"goal":"predicate AllPositive_602(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_603","instance":603,"id":237290,"goal":"predicate DistinctSeq_603(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_604","instance":604,"id":237291,"goal":"predicate IsSubseq_604(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_605","instance":605,"id":237292,"goal":"predicate IsPermutation_605(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_606","instance":606,"id":237293,"goal":"predicate IsEven_606(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_607","instance":607,"id":237294,"goal":"predicate InRange_607(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_608","instance":608,"id":237295,"goal":"predicate SubsetOf_608(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_609","instance":609,"id":237296,"goal":"predicate AllMem_609(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_610","instance":610,"id":237297,"goal":"predicate DisjointSets_610(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_611","instance":611,"id":237298,"goal":"predicate Sorted_611(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_612","instance":612,"id":237299,"goal":"predicate AllPositive_612(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_613","instance":613,"id":237300,"goal":"predicate DistinctSeq_613(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_614","instance":614,"id":237301,"goal":"predicate IsSubseq_614(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_615","instance":615,"id":237302,"goal":"predicate IsPermutation_615(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_616","instance":616,"id":237303,"goal":"predicate IsEven_616(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_617","instance":617,"id":237304,"goal":"predicate InRange_617(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_618","instance":618,"id":237305,"goal":"predicate SubsetOf_618(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_619","instance":619,"id":237306,"goal":"predicate AllMem_619(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_620","instance":620,"id":237307,"goal":"predicate DisjointSets_620(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_621","instance":621,"id":237308,"goal":"predicate Sorted_621(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_622","instance":622,"id":237309,"goal":"predicate AllPositive_622(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_623","instance":623,"id":237310,"goal":"predicate DistinctSeq_623(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_624","instance":624,"id":237311,"goal":"predicate IsSubseq_624(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_625","instance":625,"id":237312,"goal":"predicate IsPermutation_625(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_626","instance":626,"id":237313,"goal":"predicate IsEven_626(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_627","instance":627,"id":237314,"goal":"predicate InRange_627(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_628","instance":628,"id":237315,"goal":"predicate SubsetOf_628(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_629","instance":629,"id":237316,"goal":"predicate AllMem_629(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_630","instance":630,"id":237317,"goal":"predicate DisjointSets_630(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_631","instance":631,"id":237318,"goal":"predicate Sorted_631(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_632","instance":632,"id":237319,"goal":"predicate AllPositive_632(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_633","instance":633,"id":237320,"goal":"predicate DistinctSeq_633(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_634","instance":634,"id":237321,"goal":"predicate IsSubseq_634(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_635","instance":635,"id":237322,"goal":"predicate IsPermutation_635(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_636","instance":636,"id":237323,"goal":"predicate IsEven_636(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_637","instance":637,"id":237324,"goal":"predicate InRange_637(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_638","instance":638,"id":237325,"goal":"predicate SubsetOf_638(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_639","instance":639,"id":237326,"goal":"predicate AllMem_639(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_640","instance":640,"id":237327,"goal":"predicate DisjointSets_640(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_641","instance":641,"id":237328,"goal":"predicate Sorted_641(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_642","instance":642,"id":237329,"goal":"predicate AllPositive_642(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_643","instance":643,"id":237330,"goal":"predicate DistinctSeq_643(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_644","instance":644,"id":237331,"goal":"predicate IsSubseq_644(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_645","instance":645,"id":237332,"goal":"predicate IsPermutation_645(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_646","instance":646,"id":237333,"goal":"predicate IsEven_646(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_647","instance":647,"id":237334,"goal":"predicate InRange_647(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_648","instance":648,"id":237335,"goal":"predicate SubsetOf_648(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_649","instance":649,"id":237336,"goal":"predicate AllMem_649(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_650","instance":650,"id":237337,"goal":"predicate DisjointSets_650(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_651","instance":651,"id":237338,"goal":"predicate Sorted_651(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_652","instance":652,"id":237339,"goal":"predicate AllPositive_652(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_653","instance":653,"id":237340,"goal":"predicate DistinctSeq_653(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_654","instance":654,"id":237341,"goal":"predicate IsSubseq_654(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_655","instance":655,"id":237342,"goal":"predicate IsPermutation_655(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_656","instance":656,"id":237343,"goal":"predicate IsEven_656(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_657","instance":657,"id":237344,"goal":"predicate InRange_657(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_658","instance":658,"id":237345,"goal":"predicate SubsetOf_658(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_659","instance":659,"id":237346,"goal":"predicate AllMem_659(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_660","instance":660,"id":237347,"goal":"predicate DisjointSets_660(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_661","instance":661,"id":237348,"goal":"predicate Sorted_661(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_662","instance":662,"id":237349,"goal":"predicate AllPositive_662(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_663","instance":663,"id":237350,"goal":"predicate DistinctSeq_663(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_664","instance":664,"id":237351,"goal":"predicate IsSubseq_664(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_665","instance":665,"id":237352,"goal":"predicate IsPermutation_665(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_666","instance":666,"id":237353,"goal":"predicate IsEven_666(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_667","instance":667,"id":237354,"goal":"predicate InRange_667(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_668","instance":668,"id":237355,"goal":"predicate SubsetOf_668(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_669","instance":669,"id":237356,"goal":"predicate AllMem_669(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_670","instance":670,"id":237357,"goal":"predicate DisjointSets_670(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_671","instance":671,"id":237358,"goal":"predicate Sorted_671(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_672","instance":672,"id":237359,"goal":"predicate AllPositive_672(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_673","instance":673,"id":237360,"goal":"predicate DistinctSeq_673(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_674","instance":674,"id":237361,"goal":"predicate IsSubseq_674(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_675","instance":675,"id":237362,"goal":"predicate IsPermutation_675(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_676","instance":676,"id":237363,"goal":"predicate IsEven_676(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_677","instance":677,"id":237364,"goal":"predicate InRange_677(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_678","instance":678,"id":237365,"goal":"predicate SubsetOf_678(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_679","instance":679,"id":237366,"goal":"predicate AllMem_679(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_680","instance":680,"id":237367,"goal":"predicate DisjointSets_680(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_681","instance":681,"id":237368,"goal":"predicate Sorted_681(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_682","instance":682,"id":237369,"goal":"predicate AllPositive_682(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_683","instance":683,"id":237370,"goal":"predicate DistinctSeq_683(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_684","instance":684,"id":237371,"goal":"predicate IsSubseq_684(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_685","instance":685,"id":237372,"goal":"predicate IsPermutation_685(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_686","instance":686,"id":237373,"goal":"predicate IsEven_686(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_687","instance":687,"id":237374,"goal":"predicate InRange_687(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_688","instance":688,"id":237375,"goal":"predicate SubsetOf_688(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_689","instance":689,"id":237376,"goal":"predicate AllMem_689(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_690","instance":690,"id":237377,"goal":"predicate DisjointSets_690(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_691","instance":691,"id":237378,"goal":"predicate Sorted_691(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_692","instance":692,"id":237379,"goal":"predicate AllPositive_692(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_693","instance":693,"id":237380,"goal":"predicate DistinctSeq_693(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_694","instance":694,"id":237381,"goal":"predicate IsSubseq_694(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_695","instance":695,"id":237382,"goal":"predicate IsPermutation_695(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_696","instance":696,"id":237383,"goal":"predicate IsEven_696(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_697","instance":697,"id":237384,"goal":"predicate InRange_697(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_698","instance":698,"id":237385,"goal":"predicate SubsetOf_698(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_699","instance":699,"id":237386,"goal":"predicate AllMem_699(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_700","instance":700,"id":237387,"goal":"predicate DisjointSets_700(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_701","instance":701,"id":237388,"goal":"predicate Sorted_701(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_702","instance":702,"id":237389,"goal":"predicate AllPositive_702(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_703","instance":703,"id":237390,"goal":"predicate DistinctSeq_703(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_704","instance":704,"id":237391,"goal":"predicate IsSubseq_704(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_705","instance":705,"id":237392,"goal":"predicate IsPermutation_705(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_706","instance":706,"id":237393,"goal":"predicate IsEven_706(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_707","instance":707,"id":237394,"goal":"predicate InRange_707(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_708","instance":708,"id":237395,"goal":"predicate SubsetOf_708(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_709","instance":709,"id":237396,"goal":"predicate AllMem_709(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_710","instance":710,"id":237397,"goal":"predicate DisjointSets_710(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_711","instance":711,"id":237398,"goal":"predicate Sorted_711(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_712","instance":712,"id":237399,"goal":"predicate AllPositive_712(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_713","instance":713,"id":237400,"goal":"predicate DistinctSeq_713(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_714","instance":714,"id":237401,"goal":"predicate IsSubseq_714(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_715","instance":715,"id":237402,"goal":"predicate IsPermutation_715(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_716","instance":716,"id":237403,"goal":"predicate IsEven_716(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_717","instance":717,"id":237404,"goal":"predicate InRange_717(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_718","instance":718,"id":237405,"goal":"predicate SubsetOf_718(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_719","instance":719,"id":237406,"goal":"predicate AllMem_719(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_720","instance":720,"id":237407,"goal":"predicate DisjointSets_720(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_721","instance":721,"id":237408,"goal":"predicate Sorted_721(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_722","instance":722,"id":237409,"goal":"predicate AllPositive_722(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_723","instance":723,"id":237410,"goal":"predicate DistinctSeq_723(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_724","instance":724,"id":237411,"goal":"predicate IsSubseq_724(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_725","instance":725,"id":237412,"goal":"predicate IsPermutation_725(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_726","instance":726,"id":237413,"goal":"predicate IsEven_726(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_727","instance":727,"id":237414,"goal":"predicate InRange_727(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_728","instance":728,"id":237415,"goal":"predicate SubsetOf_728(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_729","instance":729,"id":237416,"goal":"predicate AllMem_729(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_730","instance":730,"id":237417,"goal":"predicate DisjointSets_730(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_731","instance":731,"id":237418,"goal":"predicate Sorted_731(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_732","instance":732,"id":237419,"goal":"predicate AllPositive_732(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_733","instance":733,"id":237420,"goal":"predicate DistinctSeq_733(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_734","instance":734,"id":237421,"goal":"predicate IsSubseq_734(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_735","instance":735,"id":237422,"goal":"predicate IsPermutation_735(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_736","instance":736,"id":237423,"goal":"predicate IsEven_736(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_737","instance":737,"id":237424,"goal":"predicate InRange_737(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_738","instance":738,"id":237425,"goal":"predicate SubsetOf_738(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_739","instance":739,"id":237426,"goal":"predicate AllMem_739(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_740","instance":740,"id":237427,"goal":"predicate DisjointSets_740(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_741","instance":741,"id":237428,"goal":"predicate Sorted_741(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_742","instance":742,"id":237429,"goal":"predicate AllPositive_742(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_743","instance":743,"id":237430,"goal":"predicate DistinctSeq_743(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_744","instance":744,"id":237431,"goal":"predicate IsSubseq_744(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_745","instance":745,"id":237432,"goal":"predicate IsPermutation_745(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_746","instance":746,"id":237433,"goal":"predicate IsEven_746(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_747","instance":747,"id":237434,"goal":"predicate InRange_747(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_748","instance":748,"id":237435,"goal":"predicate SubsetOf_748(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_749","instance":749,"id":237436,"goal":"predicate AllMem_749(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_750","instance":750,"id":237437,"goal":"predicate DisjointSets_750(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_751","instance":751,"id":237438,"goal":"predicate Sorted_751(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_752","instance":752,"id":237439,"goal":"predicate AllPositive_752(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_753","instance":753,"id":237440,"goal":"predicate DistinctSeq_753(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_754","instance":754,"id":237441,"goal":"predicate IsSubseq_754(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_755","instance":755,"id":237442,"goal":"predicate IsPermutation_755(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_756","instance":756,"id":237443,"goal":"predicate IsEven_756(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_757","instance":757,"id":237444,"goal":"predicate InRange_757(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_758","instance":758,"id":237445,"goal":"predicate SubsetOf_758(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_759","instance":759,"id":237446,"goal":"predicate AllMem_759(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_760","instance":760,"id":237447,"goal":"predicate DisjointSets_760(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_761","instance":761,"id":237448,"goal":"predicate Sorted_761(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_762","instance":762,"id":237449,"goal":"predicate AllPositive_762(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_763","instance":763,"id":237450,"goal":"predicate DistinctSeq_763(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_764","instance":764,"id":237451,"goal":"predicate IsSubseq_764(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_765","instance":765,"id":237452,"goal":"predicate IsPermutation_765(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_766","instance":766,"id":237453,"goal":"predicate IsEven_766(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_767","instance":767,"id":237454,"goal":"predicate InRange_767(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_768","instance":768,"id":237455,"goal":"predicate SubsetOf_768(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_769","instance":769,"id":237456,"goal":"predicate AllMem_769(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_770","instance":770,"id":237457,"goal":"predicate DisjointSets_770(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_771","instance":771,"id":237458,"goal":"predicate Sorted_771(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_772","instance":772,"id":237459,"goal":"predicate AllPositive_772(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_773","instance":773,"id":237460,"goal":"predicate DistinctSeq_773(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_774","instance":774,"id":237461,"goal":"predicate IsSubseq_774(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_775","instance":775,"id":237462,"goal":"predicate IsPermutation_775(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_776","instance":776,"id":237463,"goal":"predicate IsEven_776(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_777","instance":777,"id":237464,"goal":"predicate InRange_777(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_778","instance":778,"id":237465,"goal":"predicate SubsetOf_778(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_779","instance":779,"id":237466,"goal":"predicate AllMem_779(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_780","instance":780,"id":237467,"goal":"predicate DisjointSets_780(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_781","instance":781,"id":237468,"goal":"predicate Sorted_781(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_782","instance":782,"id":237469,"goal":"predicate AllPositive_782(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_783","instance":783,"id":237470,"goal":"predicate DistinctSeq_783(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_784","instance":784,"id":237471,"goal":"predicate IsSubseq_784(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_785","instance":785,"id":237472,"goal":"predicate IsPermutation_785(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_786","instance":786,"id":237473,"goal":"predicate IsEven_786(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_787","instance":787,"id":237474,"goal":"predicate InRange_787(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_788","instance":788,"id":237475,"goal":"predicate SubsetOf_788(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_789","instance":789,"id":237476,"goal":"predicate AllMem_789(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_790","instance":790,"id":237477,"goal":"predicate DisjointSets_790(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_791","instance":791,"id":237478,"goal":"predicate Sorted_791(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_792","instance":792,"id":237479,"goal":"predicate AllPositive_792(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_793","instance":793,"id":237480,"goal":"predicate DistinctSeq_793(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_794","instance":794,"id":237481,"goal":"predicate IsSubseq_794(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_795","instance":795,"id":237482,"goal":"predicate IsPermutation_795(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_796","instance":796,"id":237483,"goal":"predicate IsEven_796(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_797","instance":797,"id":237484,"goal":"predicate InRange_797(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_798","instance":798,"id":237485,"goal":"predicate SubsetOf_798(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_799","instance":799,"id":237486,"goal":"predicate AllMem_799(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_800","instance":800,"id":237487,"goal":"predicate DisjointSets_800(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_801","instance":801,"id":237488,"goal":"predicate Sorted_801(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_802","instance":802,"id":237489,"goal":"predicate AllPositive_802(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_803","instance":803,"id":237490,"goal":"predicate DistinctSeq_803(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_804","instance":804,"id":237491,"goal":"predicate IsSubseq_804(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_805","instance":805,"id":237492,"goal":"predicate IsPermutation_805(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_806","instance":806,"id":237493,"goal":"predicate IsEven_806(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_807","instance":807,"id":237494,"goal":"predicate InRange_807(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_808","instance":808,"id":237495,"goal":"predicate SubsetOf_808(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_809","instance":809,"id":237496,"goal":"predicate AllMem_809(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_810","instance":810,"id":237497,"goal":"predicate DisjointSets_810(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_811","instance":811,"id":237498,"goal":"predicate Sorted_811(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_812","instance":812,"id":237499,"goal":"predicate AllPositive_812(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_813","instance":813,"id":237500,"goal":"predicate DistinctSeq_813(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_814","instance":814,"id":237501,"goal":"predicate IsSubseq_814(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_815","instance":815,"id":237502,"goal":"predicate IsPermutation_815(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_816","instance":816,"id":237503,"goal":"predicate IsEven_816(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_817","instance":817,"id":237504,"goal":"predicate InRange_817(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_818","instance":818,"id":237505,"goal":"predicate SubsetOf_818(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_819","instance":819,"id":237506,"goal":"predicate AllMem_819(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_820","instance":820,"id":237507,"goal":"predicate DisjointSets_820(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_821","instance":821,"id":237508,"goal":"predicate Sorted_821(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_822","instance":822,"id":237509,"goal":"predicate AllPositive_822(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_823","instance":823,"id":237510,"goal":"predicate DistinctSeq_823(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_824","instance":824,"id":237511,"goal":"predicate IsSubseq_824(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_825","instance":825,"id":237512,"goal":"predicate IsPermutation_825(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_826","instance":826,"id":237513,"goal":"predicate IsEven_826(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_827","instance":827,"id":237514,"goal":"predicate InRange_827(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_828","instance":828,"id":237515,"goal":"predicate SubsetOf_828(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_829","instance":829,"id":237516,"goal":"predicate AllMem_829(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_830","instance":830,"id":237517,"goal":"predicate DisjointSets_830(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_831","instance":831,"id":237518,"goal":"predicate Sorted_831(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_832","instance":832,"id":237519,"goal":"predicate AllPositive_832(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_833","instance":833,"id":237520,"goal":"predicate DistinctSeq_833(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_834","instance":834,"id":237521,"goal":"predicate IsSubseq_834(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_835","instance":835,"id":237522,"goal":"predicate IsPermutation_835(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_836","instance":836,"id":237523,"goal":"predicate IsEven_836(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_837","instance":837,"id":237524,"goal":"predicate InRange_837(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_838","instance":838,"id":237525,"goal":"predicate SubsetOf_838(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_839","instance":839,"id":237526,"goal":"predicate AllMem_839(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_840","instance":840,"id":237527,"goal":"predicate DisjointSets_840(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_841","instance":841,"id":237528,"goal":"predicate Sorted_841(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_842","instance":842,"id":237529,"goal":"predicate AllPositive_842(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_843","instance":843,"id":237530,"goal":"predicate DistinctSeq_843(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_844","instance":844,"id":237531,"goal":"predicate IsSubseq_844(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_845","instance":845,"id":237532,"goal":"predicate IsPermutation_845(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_846","instance":846,"id":237533,"goal":"predicate IsEven_846(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_847","instance":847,"id":237534,"goal":"predicate InRange_847(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_848","instance":848,"id":237535,"goal":"predicate SubsetOf_848(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_849","instance":849,"id":237536,"goal":"predicate AllMem_849(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_850","instance":850,"id":237537,"goal":"predicate DisjointSets_850(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_851","instance":851,"id":237538,"goal":"predicate Sorted_851(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_852","instance":852,"id":237539,"goal":"predicate AllPositive_852(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_853","instance":853,"id":237540,"goal":"predicate DistinctSeq_853(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_854","instance":854,"id":237541,"goal":"predicate IsSubseq_854(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_855","instance":855,"id":237542,"goal":"predicate IsPermutation_855(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_856","instance":856,"id":237543,"goal":"predicate IsEven_856(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_857","instance":857,"id":237544,"goal":"predicate InRange_857(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_858","instance":858,"id":237545,"goal":"predicate SubsetOf_858(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_859","instance":859,"id":237546,"goal":"predicate AllMem_859(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_860","instance":860,"id":237547,"goal":"predicate DisjointSets_860(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_861","instance":861,"id":237548,"goal":"predicate Sorted_861(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_862","instance":862,"id":237549,"goal":"predicate AllPositive_862(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_863","instance":863,"id":237550,"goal":"predicate DistinctSeq_863(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_864","instance":864,"id":237551,"goal":"predicate IsSubseq_864(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_865","instance":865,"id":237552,"goal":"predicate IsPermutation_865(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_866","instance":866,"id":237553,"goal":"predicate IsEven_866(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_867","instance":867,"id":237554,"goal":"predicate InRange_867(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_868","instance":868,"id":237555,"goal":"predicate SubsetOf_868(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_869","instance":869,"id":237556,"goal":"predicate AllMem_869(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_870","instance":870,"id":237557,"goal":"predicate DisjointSets_870(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_871","instance":871,"id":237558,"goal":"predicate Sorted_871(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_872","instance":872,"id":237559,"goal":"predicate AllPositive_872(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_873","instance":873,"id":237560,"goal":"predicate DistinctSeq_873(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_874","instance":874,"id":237561,"goal":"predicate IsSubseq_874(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_875","instance":875,"id":237562,"goal":"predicate IsPermutation_875(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_876","instance":876,"id":237563,"goal":"predicate IsEven_876(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_877","instance":877,"id":237564,"goal":"predicate InRange_877(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_878","instance":878,"id":237565,"goal":"predicate SubsetOf_878(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_879","instance":879,"id":237566,"goal":"predicate AllMem_879(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_880","instance":880,"id":237567,"goal":"predicate DisjointSets_880(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_881","instance":881,"id":237568,"goal":"predicate Sorted_881(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_882","instance":882,"id":237569,"goal":"predicate AllPositive_882(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_883","instance":883,"id":237570,"goal":"predicate DistinctSeq_883(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_884","instance":884,"id":237571,"goal":"predicate IsSubseq_884(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_885","instance":885,"id":237572,"goal":"predicate IsPermutation_885(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_886","instance":886,"id":237573,"goal":"predicate IsEven_886(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_887","instance":887,"id":237574,"goal":"predicate InRange_887(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_888","instance":888,"id":237575,"goal":"predicate SubsetOf_888(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_889","instance":889,"id":237576,"goal":"predicate AllMem_889(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_890","instance":890,"id":237577,"goal":"predicate DisjointSets_890(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_891","instance":891,"id":237578,"goal":"predicate Sorted_891(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_892","instance":892,"id":237579,"goal":"predicate AllPositive_892(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_893","instance":893,"id":237580,"goal":"predicate DistinctSeq_893(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_894","instance":894,"id":237581,"goal":"predicate IsSubseq_894(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_895","instance":895,"id":237582,"goal":"predicate IsPermutation_895(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_896","instance":896,"id":237583,"goal":"predicate IsEven_896(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_897","instance":897,"id":237584,"goal":"predicate InRange_897(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_898","instance":898,"id":237585,"goal":"predicate SubsetOf_898(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_899","instance":899,"id":237586,"goal":"predicate AllMem_899(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_900","instance":900,"id":237587,"goal":"predicate DisjointSets_900(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_901","instance":901,"id":237588,"goal":"predicate Sorted_901(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_902","instance":902,"id":237589,"goal":"predicate AllPositive_902(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_903","instance":903,"id":237590,"goal":"predicate DistinctSeq_903(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_904","instance":904,"id":237591,"goal":"predicate IsSubseq_904(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_905","instance":905,"id":237592,"goal":"predicate IsPermutation_905(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_906","instance":906,"id":237593,"goal":"predicate IsEven_906(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_907","instance":907,"id":237594,"goal":"predicate InRange_907(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_908","instance":908,"id":237595,"goal":"predicate SubsetOf_908(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_909","instance":909,"id":237596,"goal":"predicate AllMem_909(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_910","instance":910,"id":237597,"goal":"predicate DisjointSets_910(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_911","instance":911,"id":237598,"goal":"predicate Sorted_911(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_912","instance":912,"id":237599,"goal":"predicate AllPositive_912(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_913","instance":913,"id":237600,"goal":"predicate DistinctSeq_913(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_914","instance":914,"id":237601,"goal":"predicate IsSubseq_914(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_915","instance":915,"id":237602,"goal":"predicate IsPermutation_915(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_916","instance":916,"id":237603,"goal":"predicate IsEven_916(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_917","instance":917,"id":237604,"goal":"predicate InRange_917(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_918","instance":918,"id":237605,"goal":"predicate SubsetOf_918(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_919","instance":919,"id":237606,"goal":"predicate AllMem_919(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_920","instance":920,"id":237607,"goal":"predicate DisjointSets_920(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_921","instance":921,"id":237608,"goal":"predicate Sorted_921(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_922","instance":922,"id":237609,"goal":"predicate AllPositive_922(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_923","instance":923,"id":237610,"goal":"predicate DistinctSeq_923(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_924","instance":924,"id":237611,"goal":"predicate IsSubseq_924(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_925","instance":925,"id":237612,"goal":"predicate IsPermutation_925(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_926","instance":926,"id":237613,"goal":"predicate IsEven_926(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_927","instance":927,"id":237614,"goal":"predicate InRange_927(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_928","instance":928,"id":237615,"goal":"predicate SubsetOf_928(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_929","instance":929,"id":237616,"goal":"predicate AllMem_929(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_930","instance":930,"id":237617,"goal":"predicate DisjointSets_930(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_931","instance":931,"id":237618,"goal":"predicate Sorted_931(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_932","instance":932,"id":237619,"goal":"predicate AllPositive_932(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_933","instance":933,"id":237620,"goal":"predicate DistinctSeq_933(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_934","instance":934,"id":237621,"goal":"predicate IsSubseq_934(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_935","instance":935,"id":237622,"goal":"predicate IsPermutation_935(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_936","instance":936,"id":237623,"goal":"predicate IsEven_936(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_937","instance":937,"id":237624,"goal":"predicate InRange_937(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_938","instance":938,"id":237625,"goal":"predicate SubsetOf_938(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_939","instance":939,"id":237626,"goal":"predicate AllMem_939(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_940","instance":940,"id":237627,"goal":"predicate DisjointSets_940(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_941","instance":941,"id":237628,"goal":"predicate Sorted_941(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_942","instance":942,"id":237629,"goal":"predicate AllPositive_942(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_943","instance":943,"id":237630,"goal":"predicate DistinctSeq_943(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_944","instance":944,"id":237631,"goal":"predicate IsSubseq_944(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_945","instance":945,"id":237632,"goal":"predicate IsPermutation_945(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_946","instance":946,"id":237633,"goal":"predicate IsEven_946(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_947","instance":947,"id":237634,"goal":"predicate InRange_947(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_948","instance":948,"id":237635,"goal":"predicate SubsetOf_948(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_949","instance":949,"id":237636,"goal":"predicate AllMem_949(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_950","instance":950,"id":237637,"goal":"predicate DisjointSets_950(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_951","instance":951,"id":237638,"goal":"predicate Sorted_951(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_952","instance":952,"id":237639,"goal":"predicate AllPositive_952(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_953","instance":953,"id":237640,"goal":"predicate DistinctSeq_953(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_954","instance":954,"id":237641,"goal":"predicate IsSubseq_954(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_955","instance":955,"id":237642,"goal":"predicate IsPermutation_955(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_956","instance":956,"id":237643,"goal":"predicate IsEven_956(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_957","instance":957,"id":237644,"goal":"predicate InRange_957(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_958","instance":958,"id":237645,"goal":"predicate SubsetOf_958(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_959","instance":959,"id":237646,"goal":"predicate AllMem_959(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_960","instance":960,"id":237647,"goal":"predicate DisjointSets_960(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_961","instance":961,"id":237648,"goal":"predicate Sorted_961(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_962","instance":962,"id":237649,"goal":"predicate AllPositive_962(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_963","instance":963,"id":237650,"goal":"predicate DistinctSeq_963(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_964","instance":964,"id":237651,"goal":"predicate IsSubseq_964(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_965","instance":965,"id":237652,"goal":"predicate IsPermutation_965(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_966","instance":966,"id":237653,"goal":"predicate IsEven_966(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_967","instance":967,"id":237654,"goal":"predicate InRange_967(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_968","instance":968,"id":237655,"goal":"predicate SubsetOf_968(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_969","instance":969,"id":237656,"goal":"predicate AllMem_969(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_970","instance":970,"id":237657,"goal":"predicate DisjointSets_970(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_971","instance":971,"id":237658,"goal":"predicate Sorted_971(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_972","instance":972,"id":237659,"goal":"predicate AllPositive_972(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_973","instance":973,"id":237660,"goal":"predicate DistinctSeq_973(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_974","instance":974,"id":237661,"goal":"predicate IsSubseq_974(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_975","instance":975,"id":237662,"goal":"predicate IsPermutation_975(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_976","instance":976,"id":237663,"goal":"predicate IsEven_976(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_977","instance":977,"id":237664,"goal":"predicate InRange_977(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_978","instance":978,"id":237665,"goal":"predicate SubsetOf_978(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_979","instance":979,"id":237666,"goal":"predicate AllMem_979(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_980","instance":980,"id":237667,"goal":"predicate DisjointSets_980(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_981","instance":981,"id":237668,"goal":"predicate Sorted_981(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_982","instance":982,"id":237669,"goal":"predicate AllPositive_982(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_983","instance":983,"id":237670,"goal":"predicate DistinctSeq_983(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_984","instance":984,"id":237671,"goal":"predicate IsSubseq_984(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_985","instance":985,"id":237672,"goal":"predicate IsPermutation_985(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_986","instance":986,"id":237673,"goal":"predicate IsEven_986(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_987","instance":987,"id":237674,"goal":"predicate InRange_987(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_988","instance":988,"id":237675,"goal":"predicate SubsetOf_988(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_989","instance":989,"id":237676,"goal":"predicate AllMem_989(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_990","instance":990,"id":237677,"goal":"predicate DisjointSets_990(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_991","instance":991,"id":237678,"goal":"predicate Sorted_991(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_992","instance":992,"id":237679,"goal":"predicate AllPositive_992(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_993","instance":993,"id":237680,"goal":"predicate DistinctSeq_993(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_994","instance":994,"id":237681,"goal":"predicate IsSubseq_994(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_995","instance":995,"id":237682,"goal":"predicate IsPermutation_995(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_996","instance":996,"id":237683,"goal":"predicate IsEven_996(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_997","instance":997,"id":237684,"goal":"predicate InRange_997(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_998","instance":998,"id":237685,"goal":"predicate SubsetOf_998(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_999","instance":999,"id":237686,"goal":"predicate AllMem_999(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_1000","instance":1000,"id":237687,"goal":"predicate DisjointSets_1000(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_1001","instance":1001,"id":237688,"goal":"predicate Sorted_1001(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_1002","instance":1002,"id":237689,"goal":"predicate AllPositive_1002(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_1003","instance":1003,"id":237690,"goal":"predicate DistinctSeq_1003(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_1004","instance":1004,"id":237691,"goal":"predicate IsSubseq_1004(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_1005","instance":1005,"id":237692,"goal":"predicate IsPermutation_1005(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_1006","instance":1006,"id":237693,"goal":"predicate IsEven_1006(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_1007","instance":1007,"id":237694,"goal":"predicate InRange_1007(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_1008","instance":1008,"id":237695,"goal":"predicate SubsetOf_1008(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_1009","instance":1009,"id":237696,"goal":"predicate AllMem_1009(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_1010","instance":1010,"id":237697,"goal":"predicate DisjointSets_1010(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_1011","instance":1011,"id":237698,"goal":"predicate Sorted_1011(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_1012","instance":1012,"id":237699,"goal":"predicate AllPositive_1012(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_1013","instance":1013,"id":237700,"goal":"predicate DistinctSeq_1013(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_1014","instance":1014,"id":237701,"goal":"predicate IsSubseq_1014(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_1015","instance":1015,"id":237702,"goal":"predicate IsPermutation_1015(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_1016","instance":1016,"id":237703,"goal":"predicate IsEven_1016(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_1017","instance":1017,"id":237704,"goal":"predicate InRange_1017(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_1018","instance":1018,"id":237705,"goal":"predicate SubsetOf_1018(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_1019","instance":1019,"id":237706,"goal":"predicate AllMem_1019(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_1020","instance":1020,"id":237707,"goal":"predicate DisjointSets_1020(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_1021","instance":1021,"id":237708,"goal":"predicate Sorted_1021(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_1022","instance":1022,"id":237709,"goal":"predicate AllPositive_1022(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_1023","instance":1023,"id":237710,"goal":"predicate DistinctSeq_1023(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_1024","instance":1024,"id":237711,"goal":"predicate IsSubseq_1024(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_1025","instance":1025,"id":237712,"goal":"predicate IsPermutation_1025(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_1026","instance":1026,"id":237713,"goal":"predicate IsEven_1026(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_1027","instance":1027,"id":237714,"goal":"predicate InRange_1027(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_1028","instance":1028,"id":237715,"goal":"predicate SubsetOf_1028(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_1029","instance":1029,"id":237716,"goal":"predicate AllMem_1029(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_1030","instance":1030,"id":237717,"goal":"predicate DisjointSets_1030(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_1031","instance":1031,"id":237718,"goal":"predicate Sorted_1031(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_1032","instance":1032,"id":237719,"goal":"predicate AllPositive_1032(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_1033","instance":1033,"id":237720,"goal":"predicate DistinctSeq_1033(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_1034","instance":1034,"id":237721,"goal":"predicate IsSubseq_1034(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_1035","instance":1035,"id":237722,"goal":"predicate IsPermutation_1035(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_1036","instance":1036,"id":237723,"goal":"predicate IsEven_1036(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_1037","instance":1037,"id":237724,"goal":"predicate InRange_1037(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_1038","instance":1038,"id":237725,"goal":"predicate SubsetOf_1038(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_1039","instance":1039,"id":237726,"goal":"predicate AllMem_1039(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_1040","instance":1040,"id":237727,"goal":"predicate DisjointSets_1040(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_1041","instance":1041,"id":237728,"goal":"predicate Sorted_1041(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_1042","instance":1042,"id":237729,"goal":"predicate AllPositive_1042(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_1043","instance":1043,"id":237730,"goal":"predicate DistinctSeq_1043(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_1044","instance":1044,"id":237731,"goal":"predicate IsSubseq_1044(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_1045","instance":1045,"id":237732,"goal":"predicate IsPermutation_1045(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_1046","instance":1046,"id":237733,"goal":"predicate IsEven_1046(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_1047","instance":1047,"id":237734,"goal":"predicate InRange_1047(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_1048","instance":1048,"id":237735,"goal":"predicate SubsetOf_1048(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_1049","instance":1049,"id":237736,"goal":"predicate AllMem_1049(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_1050","instance":1050,"id":237737,"goal":"predicate DisjointSets_1050(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_1051","instance":1051,"id":237738,"goal":"predicate Sorted_1051(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_1052","instance":1052,"id":237739,"goal":"predicate AllPositive_1052(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_1053","instance":1053,"id":237740,"goal":"predicate DistinctSeq_1053(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_1054","instance":1054,"id":237741,"goal":"predicate IsSubseq_1054(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_1055","instance":1055,"id":237742,"goal":"predicate IsPermutation_1055(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_1056","instance":1056,"id":237743,"goal":"predicate IsEven_1056(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_1057","instance":1057,"id":237744,"goal":"predicate InRange_1057(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_1058","instance":1058,"id":237745,"goal":"predicate SubsetOf_1058(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_1059","instance":1059,"id":237746,"goal":"predicate AllMem_1059(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_1060","instance":1060,"id":237747,"goal":"predicate DisjointSets_1060(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_1061","instance":1061,"id":237748,"goal":"predicate Sorted_1061(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_1062","instance":1062,"id":237749,"goal":"predicate AllPositive_1062(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_1063","instance":1063,"id":237750,"goal":"predicate DistinctSeq_1063(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_1064","instance":1064,"id":237751,"goal":"predicate IsSubseq_1064(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_1065","instance":1065,"id":237752,"goal":"predicate IsPermutation_1065(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_1066","instance":1066,"id":237753,"goal":"predicate IsEven_1066(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_1067","instance":1067,"id":237754,"goal":"predicate InRange_1067(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_1068","instance":1068,"id":237755,"goal":"predicate SubsetOf_1068(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_1069","instance":1069,"id":237756,"goal":"predicate AllMem_1069(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_1070","instance":1070,"id":237757,"goal":"predicate DisjointSets_1070(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_1071","instance":1071,"id":237758,"goal":"predicate Sorted_1071(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_1072","instance":1072,"id":237759,"goal":"predicate AllPositive_1072(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_1073","instance":1073,"id":237760,"goal":"predicate DistinctSeq_1073(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_1074","instance":1074,"id":237761,"goal":"predicate IsSubseq_1074(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_1075","instance":1075,"id":237762,"goal":"predicate IsPermutation_1075(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_1076","instance":1076,"id":237763,"goal":"predicate IsEven_1076(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_1077","instance":1077,"id":237764,"goal":"predicate InRange_1077(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_1078","instance":1078,"id":237765,"goal":"predicate SubsetOf_1078(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_1079","instance":1079,"id":237766,"goal":"predicate AllMem_1079(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_1080","instance":1080,"id":237767,"goal":"predicate DisjointSets_1080(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_1081","instance":1081,"id":237768,"goal":"predicate Sorted_1081(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_1082","instance":1082,"id":237769,"goal":"predicate AllPositive_1082(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_1083","instance":1083,"id":237770,"goal":"predicate DistinctSeq_1083(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_1084","instance":1084,"id":237771,"goal":"predicate IsSubseq_1084(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_1085","instance":1085,"id":237772,"goal":"predicate IsPermutation_1085(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_1086","instance":1086,"id":237773,"goal":"predicate IsEven_1086(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_1087","instance":1087,"id":237774,"goal":"predicate InRange_1087(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_1088","instance":1088,"id":237775,"goal":"predicate SubsetOf_1088(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_1089","instance":1089,"id":237776,"goal":"predicate AllMem_1089(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_1090","instance":1090,"id":237777,"goal":"predicate DisjointSets_1090(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_1091","instance":1091,"id":237778,"goal":"predicate Sorted_1091(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_1092","instance":1092,"id":237779,"goal":"predicate AllPositive_1092(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_1093","instance":1093,"id":237780,"goal":"predicate DistinctSeq_1093(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_1094","instance":1094,"id":237781,"goal":"predicate IsSubseq_1094(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_1095","instance":1095,"id":237782,"goal":"predicate IsPermutation_1095(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_1096","instance":1096,"id":237783,"goal":"predicate IsEven_1096(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_1097","instance":1097,"id":237784,"goal":"predicate InRange_1097(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_1098","instance":1098,"id":237785,"goal":"predicate SubsetOf_1098(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_1099","instance":1099,"id":237786,"goal":"predicate AllMem_1099(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_1100","instance":1100,"id":237787,"goal":"predicate DisjointSets_1100(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_1101","instance":1101,"id":237788,"goal":"predicate Sorted_1101(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_1102","instance":1102,"id":237789,"goal":"predicate AllPositive_1102(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_1103","instance":1103,"id":237790,"goal":"predicate DistinctSeq_1103(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_1104","instance":1104,"id":237791,"goal":"predicate IsSubseq_1104(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_1105","instance":1105,"id":237792,"goal":"predicate IsPermutation_1105(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_1106","instance":1106,"id":237793,"goal":"predicate IsEven_1106(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_1107","instance":1107,"id":237794,"goal":"predicate InRange_1107(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_1108","instance":1108,"id":237795,"goal":"predicate SubsetOf_1108(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_1109","instance":1109,"id":237796,"goal":"predicate AllMem_1109(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_1110","instance":1110,"id":237797,"goal":"predicate DisjointSets_1110(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_1111","instance":1111,"id":237798,"goal":"predicate Sorted_1111(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_1112","instance":1112,"id":237799,"goal":"predicate AllPositive_1112(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_1113","instance":1113,"id":237800,"goal":"predicate DistinctSeq_1113(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_1114","instance":1114,"id":237801,"goal":"predicate IsSubseq_1114(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_1115","instance":1115,"id":237802,"goal":"predicate IsPermutation_1115(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_1116","instance":1116,"id":237803,"goal":"predicate IsEven_1116(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_1117","instance":1117,"id":237804,"goal":"predicate InRange_1117(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_1118","instance":1118,"id":237805,"goal":"predicate SubsetOf_1118(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_1119","instance":1119,"id":237806,"goal":"predicate AllMem_1119(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_1120","instance":1120,"id":237807,"goal":"predicate DisjointSets_1120(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_1121","instance":1121,"id":237808,"goal":"predicate Sorted_1121(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_1122","instance":1122,"id":237809,"goal":"predicate AllPositive_1122(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_1123","instance":1123,"id":237810,"goal":"predicate DistinctSeq_1123(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_1124","instance":1124,"id":237811,"goal":"predicate IsSubseq_1124(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_1125","instance":1125,"id":237812,"goal":"predicate IsPermutation_1125(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_1126","instance":1126,"id":237813,"goal":"predicate IsEven_1126(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_1127","instance":1127,"id":237814,"goal":"predicate InRange_1127(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_1128","instance":1128,"id":237815,"goal":"predicate SubsetOf_1128(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_1129","instance":1129,"id":237816,"goal":"predicate AllMem_1129(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_1130","instance":1130,"id":237817,"goal":"predicate DisjointSets_1130(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_1131","instance":1131,"id":237818,"goal":"predicate Sorted_1131(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_1132","instance":1132,"id":237819,"goal":"predicate AllPositive_1132(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_1133","instance":1133,"id":237820,"goal":"predicate DistinctSeq_1133(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_1134","instance":1134,"id":237821,"goal":"predicate IsSubseq_1134(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_1135","instance":1135,"id":237822,"goal":"predicate IsPermutation_1135(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_1136","instance":1136,"id":237823,"goal":"predicate IsEven_1136(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_1137","instance":1137,"id":237824,"goal":"predicate InRange_1137(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_1138","instance":1138,"id":237825,"goal":"predicate SubsetOf_1138(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_1139","instance":1139,"id":237826,"goal":"predicate AllMem_1139(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_1140","instance":1140,"id":237827,"goal":"predicate DisjointSets_1140(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_1141","instance":1141,"id":237828,"goal":"predicate Sorted_1141(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_1142","instance":1142,"id":237829,"goal":"predicate AllPositive_1142(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_1143","instance":1143,"id":237830,"goal":"predicate DistinctSeq_1143(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_1144","instance":1144,"id":237831,"goal":"predicate IsSubseq_1144(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_1145","instance":1145,"id":237832,"goal":"predicate IsPermutation_1145(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_1146","instance":1146,"id":237833,"goal":"predicate IsEven_1146(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_1147","instance":1147,"id":237834,"goal":"predicate InRange_1147(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_1148","instance":1148,"id":237835,"goal":"predicate SubsetOf_1148(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_1149","instance":1149,"id":237836,"goal":"predicate AllMem_1149(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_1150","instance":1150,"id":237837,"goal":"predicate DisjointSets_1150(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_1151","instance":1151,"id":237838,"goal":"predicate Sorted_1151(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_1152","instance":1152,"id":237839,"goal":"predicate AllPositive_1152(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_1153","instance":1153,"id":237840,"goal":"predicate DistinctSeq_1153(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_1154","instance":1154,"id":237841,"goal":"predicate IsSubseq_1154(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_1155","instance":1155,"id":237842,"goal":"predicate IsPermutation_1155(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_1156","instance":1156,"id":237843,"goal":"predicate IsEven_1156(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_1157","instance":1157,"id":237844,"goal":"predicate InRange_1157(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_1158","instance":1158,"id":237845,"goal":"predicate SubsetOf_1158(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_1159","instance":1159,"id":237846,"goal":"predicate AllMem_1159(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_1160","instance":1160,"id":237847,"goal":"predicate DisjointSets_1160(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_1161","instance":1161,"id":237848,"goal":"predicate Sorted_1161(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_1162","instance":1162,"id":237849,"goal":"predicate AllPositive_1162(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_1163","instance":1163,"id":237850,"goal":"predicate DistinctSeq_1163(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_1164","instance":1164,"id":237851,"goal":"predicate IsSubseq_1164(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_1165","instance":1165,"id":237852,"goal":"predicate IsPermutation_1165(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_1166","instance":1166,"id":237853,"goal":"predicate IsEven_1166(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_1167","instance":1167,"id":237854,"goal":"predicate InRange_1167(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_1168","instance":1168,"id":237855,"goal":"predicate SubsetOf_1168(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_1169","instance":1169,"id":237856,"goal":"predicate AllMem_1169(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_1170","instance":1170,"id":237857,"goal":"predicate DisjointSets_1170(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_1171","instance":1171,"id":237858,"goal":"predicate Sorted_1171(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_1172","instance":1172,"id":237859,"goal":"predicate AllPositive_1172(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_1173","instance":1173,"id":237860,"goal":"predicate DistinctSeq_1173(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_1174","instance":1174,"id":237861,"goal":"predicate IsSubseq_1174(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_1175","instance":1175,"id":237862,"goal":"predicate IsPermutation_1175(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_1176","instance":1176,"id":237863,"goal":"predicate IsEven_1176(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_1177","instance":1177,"id":237864,"goal":"predicate InRange_1177(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_1178","instance":1178,"id":237865,"goal":"predicate SubsetOf_1178(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_1179","instance":1179,"id":237866,"goal":"predicate AllMem_1179(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_1180","instance":1180,"id":237867,"goal":"predicate DisjointSets_1180(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_1181","instance":1181,"id":237868,"goal":"predicate Sorted_1181(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_1182","instance":1182,"id":237869,"goal":"predicate AllPositive_1182(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_1183","instance":1183,"id":237870,"goal":"predicate DistinctSeq_1183(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_1184","instance":1184,"id":237871,"goal":"predicate IsSubseq_1184(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_1185","instance":1185,"id":237872,"goal":"predicate IsPermutation_1185(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_1186","instance":1186,"id":237873,"goal":"predicate IsEven_1186(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_1187","instance":1187,"id":237874,"goal":"predicate InRange_1187(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_1188","instance":1188,"id":237875,"goal":"predicate SubsetOf_1188(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_1189","instance":1189,"id":237876,"goal":"predicate AllMem_1189(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_1190","instance":1190,"id":237877,"goal":"predicate DisjointSets_1190(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_1191","instance":1191,"id":237878,"goal":"predicate Sorted_1191(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_1192","instance":1192,"id":237879,"goal":"predicate AllPositive_1192(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_1193","instance":1193,"id":237880,"goal":"predicate DistinctSeq_1193(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_1194","instance":1194,"id":237881,"goal":"predicate IsSubseq_1194(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_1195","instance":1195,"id":237882,"goal":"predicate IsPermutation_1195(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_1196","instance":1196,"id":237883,"goal":"predicate IsEven_1196(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_1197","instance":1197,"id":237884,"goal":"predicate InRange_1197(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_1198","instance":1198,"id":237885,"goal":"predicate SubsetOf_1198(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_1199","instance":1199,"id":237886,"goal":"predicate AllMem_1199(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_1200","instance":1200,"id":237887,"goal":"predicate DisjointSets_1200(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_1201","instance":1201,"id":237888,"goal":"predicate Sorted_1201(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_1202","instance":1202,"id":237889,"goal":"predicate AllPositive_1202(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_1203","instance":1203,"id":237890,"goal":"predicate DistinctSeq_1203(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_1204","instance":1204,"id":237891,"goal":"predicate IsSubseq_1204(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_1205","instance":1205,"id":237892,"goal":"predicate IsPermutation_1205(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_1206","instance":1206,"id":237893,"goal":"predicate IsEven_1206(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_1207","instance":1207,"id":237894,"goal":"predicate InRange_1207(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_1208","instance":1208,"id":237895,"goal":"predicate SubsetOf_1208(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_1209","instance":1209,"id":237896,"goal":"predicate AllMem_1209(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_1210","instance":1210,"id":237897,"goal":"predicate DisjointSets_1210(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_1211","instance":1211,"id":237898,"goal":"predicate Sorted_1211(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_1212","instance":1212,"id":237899,"goal":"predicate AllPositive_1212(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_1213","instance":1213,"id":237900,"goal":"predicate DistinctSeq_1213(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_1214","instance":1214,"id":237901,"goal":"predicate IsSubseq_1214(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_1215","instance":1215,"id":237902,"goal":"predicate IsPermutation_1215(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_1216","instance":1216,"id":237903,"goal":"predicate IsEven_1216(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_1217","instance":1217,"id":237904,"goal":"predicate InRange_1217(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_1218","instance":1218,"id":237905,"goal":"predicate SubsetOf_1218(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_1219","instance":1219,"id":237906,"goal":"predicate AllMem_1219(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_1220","instance":1220,"id":237907,"goal":"predicate DisjointSets_1220(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_1221","instance":1221,"id":237908,"goal":"predicate Sorted_1221(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_1222","instance":1222,"id":237909,"goal":"predicate AllPositive_1222(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_1223","instance":1223,"id":237910,"goal":"predicate DistinctSeq_1223(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_1224","instance":1224,"id":237911,"goal":"predicate IsSubseq_1224(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_1225","instance":1225,"id":237912,"goal":"predicate IsPermutation_1225(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_1226","instance":1226,"id":237913,"goal":"predicate IsEven_1226(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_1227","instance":1227,"id":237914,"goal":"predicate InRange_1227(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_1228","instance":1228,"id":237915,"goal":"predicate SubsetOf_1228(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_1229","instance":1229,"id":237916,"goal":"predicate AllMem_1229(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_1230","instance":1230,"id":237917,"goal":"predicate DisjointSets_1230(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_1231","instance":1231,"id":237918,"goal":"predicate Sorted_1231(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_1232","instance":1232,"id":237919,"goal":"predicate AllPositive_1232(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_1233","instance":1233,"id":237920,"goal":"predicate DistinctSeq_1233(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_1234","instance":1234,"id":237921,"goal":"predicate IsSubseq_1234(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_1235","instance":1235,"id":237922,"goal":"predicate IsPermutation_1235(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_1236","instance":1236,"id":237923,"goal":"predicate IsEven_1236(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_1237","instance":1237,"id":237924,"goal":"predicate InRange_1237(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_1238","instance":1238,"id":237925,"goal":"predicate SubsetOf_1238(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_1239","instance":1239,"id":237926,"goal":"predicate AllMem_1239(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_1240","instance":1240,"id":237927,"goal":"predicate DisjointSets_1240(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_1241","instance":1241,"id":237928,"goal":"predicate Sorted_1241(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_1242","instance":1242,"id":237929,"goal":"predicate AllPositive_1242(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_1243","instance":1243,"id":237930,"goal":"predicate DistinctSeq_1243(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_1244","instance":1244,"id":237931,"goal":"predicate IsSubseq_1244(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_1245","instance":1245,"id":237932,"goal":"predicate IsPermutation_1245(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_1246","instance":1246,"id":237933,"goal":"predicate IsEven_1246(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_1247","instance":1247,"id":237934,"goal":"predicate InRange_1247(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_1248","instance":1248,"id":237935,"goal":"predicate SubsetOf_1248(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_1249","instance":1249,"id":237936,"goal":"predicate AllMem_1249(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_1250","instance":1250,"id":237937,"goal":"predicate DisjointSets_1250(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_1251","instance":1251,"id":237938,"goal":"predicate Sorted_1251(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_1252","instance":1252,"id":237939,"goal":"predicate AllPositive_1252(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_1253","instance":1253,"id":237940,"goal":"predicate DistinctSeq_1253(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_1254","instance":1254,"id":237941,"goal":"predicate IsSubseq_1254(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_1255","instance":1255,"id":237942,"goal":"predicate IsPermutation_1255(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_1256","instance":1256,"id":237943,"goal":"predicate IsEven_1256(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_1257","instance":1257,"id":237944,"goal":"predicate InRange_1257(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_1258","instance":1258,"id":237945,"goal":"predicate SubsetOf_1258(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_1259","instance":1259,"id":237946,"goal":"predicate AllMem_1259(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_1260","instance":1260,"id":237947,"goal":"predicate DisjointSets_1260(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_1261","instance":1261,"id":237948,"goal":"predicate Sorted_1261(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_1262","instance":1262,"id":237949,"goal":"predicate AllPositive_1262(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_1263","instance":1263,"id":237950,"goal":"predicate DistinctSeq_1263(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_1264","instance":1264,"id":237951,"goal":"predicate IsSubseq_1264(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_1265","instance":1265,"id":237952,"goal":"predicate IsPermutation_1265(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_1266","instance":1266,"id":237953,"goal":"predicate IsEven_1266(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_1267","instance":1267,"id":237954,"goal":"predicate InRange_1267(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_1268","instance":1268,"id":237955,"goal":"predicate SubsetOf_1268(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_1269","instance":1269,"id":237956,"goal":"predicate AllMem_1269(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_1270","instance":1270,"id":237957,"goal":"predicate DisjointSets_1270(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_1271","instance":1271,"id":237958,"goal":"predicate Sorted_1271(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_1272","instance":1272,"id":237959,"goal":"predicate AllPositive_1272(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_1273","instance":1273,"id":237960,"goal":"predicate DistinctSeq_1273(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_1274","instance":1274,"id":237961,"goal":"predicate IsSubseq_1274(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_1275","instance":1275,"id":237962,"goal":"predicate IsPermutation_1275(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_1276","instance":1276,"id":237963,"goal":"predicate IsEven_1276(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_1277","instance":1277,"id":237964,"goal":"predicate InRange_1277(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_1278","instance":1278,"id":237965,"goal":"predicate SubsetOf_1278(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_1279","instance":1279,"id":237966,"goal":"predicate AllMem_1279(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_1280","instance":1280,"id":237967,"goal":"predicate DisjointSets_1280(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_1281","instance":1281,"id":237968,"goal":"predicate Sorted_1281(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_1282","instance":1282,"id":237969,"goal":"predicate AllPositive_1282(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_1283","instance":1283,"id":237970,"goal":"predicate DistinctSeq_1283(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_1284","instance":1284,"id":237971,"goal":"predicate IsSubseq_1284(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_1285","instance":1285,"id":237972,"goal":"predicate IsPermutation_1285(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_1286","instance":1286,"id":237973,"goal":"predicate IsEven_1286(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_1287","instance":1287,"id":237974,"goal":"predicate InRange_1287(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_1288","instance":1288,"id":237975,"goal":"predicate SubsetOf_1288(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_1289","instance":1289,"id":237976,"goal":"predicate AllMem_1289(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_1290","instance":1290,"id":237977,"goal":"predicate DisjointSets_1290(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_1291","instance":1291,"id":237978,"goal":"predicate Sorted_1291(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_1292","instance":1292,"id":237979,"goal":"predicate AllPositive_1292(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_1293","instance":1293,"id":237980,"goal":"predicate DistinctSeq_1293(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_1294","instance":1294,"id":237981,"goal":"predicate IsSubseq_1294(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_1295","instance":1295,"id":237982,"goal":"predicate IsPermutation_1295(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_1296","instance":1296,"id":237983,"goal":"predicate IsEven_1296(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_1297","instance":1297,"id":237984,"goal":"predicate InRange_1297(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_1298","instance":1298,"id":237985,"goal":"predicate SubsetOf_1298(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_1299","instance":1299,"id":237986,"goal":"predicate AllMem_1299(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_1300","instance":1300,"id":237987,"goal":"predicate DisjointSets_1300(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_1301","instance":1301,"id":237988,"goal":"predicate Sorted_1301(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_1302","instance":1302,"id":237989,"goal":"predicate AllPositive_1302(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_1303","instance":1303,"id":237990,"goal":"predicate DistinctSeq_1303(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_1304","instance":1304,"id":237991,"goal":"predicate IsSubseq_1304(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_1305","instance":1305,"id":237992,"goal":"predicate IsPermutation_1305(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_1306","instance":1306,"id":237993,"goal":"predicate IsEven_1306(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_1307","instance":1307,"id":237994,"goal":"predicate InRange_1307(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_1308","instance":1308,"id":237995,"goal":"predicate SubsetOf_1308(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_1309","instance":1309,"id":237996,"goal":"predicate AllMem_1309(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_1310","instance":1310,"id":237997,"goal":"predicate DisjointSets_1310(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_1311","instance":1311,"id":237998,"goal":"predicate Sorted_1311(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_1312","instance":1312,"id":237999,"goal":"predicate AllPositive_1312(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_1313","instance":1313,"id":238000,"goal":"predicate DistinctSeq_1313(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_1314","instance":1314,"id":238001,"goal":"predicate IsSubseq_1314(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_1315","instance":1315,"id":238002,"goal":"predicate IsPermutation_1315(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_1316","instance":1316,"id":238003,"goal":"predicate IsEven_1316(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_1317","instance":1317,"id":238004,"goal":"predicate InRange_1317(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_1318","instance":1318,"id":238005,"goal":"predicate SubsetOf_1318(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_1319","instance":1319,"id":238006,"goal":"predicate AllMem_1319(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_1320","instance":1320,"id":238007,"goal":"predicate DisjointSets_1320(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_1321","instance":1321,"id":238008,"goal":"predicate Sorted_1321(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_1322","instance":1322,"id":238009,"goal":"predicate AllPositive_1322(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_1323","instance":1323,"id":238010,"goal":"predicate DistinctSeq_1323(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_1324","instance":1324,"id":238011,"goal":"predicate IsSubseq_1324(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_1325","instance":1325,"id":238012,"goal":"predicate IsPermutation_1325(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_1326","instance":1326,"id":238013,"goal":"predicate IsEven_1326(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_1327","instance":1327,"id":238014,"goal":"predicate InRange_1327(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_1328","instance":1328,"id":238015,"goal":"predicate SubsetOf_1328(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_1329","instance":1329,"id":238016,"goal":"predicate AllMem_1329(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_1330","instance":1330,"id":238017,"goal":"predicate DisjointSets_1330(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_1331","instance":1331,"id":238018,"goal":"predicate Sorted_1331(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_1332","instance":1332,"id":238019,"goal":"predicate AllPositive_1332(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_1333","instance":1333,"id":238020,"goal":"predicate DistinctSeq_1333(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_1334","instance":1334,"id":238021,"goal":"predicate IsSubseq_1334(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_1335","instance":1335,"id":238022,"goal":"predicate IsPermutation_1335(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_1336","instance":1336,"id":238023,"goal":"predicate IsEven_1336(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_1337","instance":1337,"id":238024,"goal":"predicate InRange_1337(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_1338","instance":1338,"id":238025,"goal":"predicate SubsetOf_1338(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_1339","instance":1339,"id":238026,"goal":"predicate AllMem_1339(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_1340","instance":1340,"id":238027,"goal":"predicate DisjointSets_1340(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_1341","instance":1341,"id":238028,"goal":"predicate Sorted_1341(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_1342","instance":1342,"id":238029,"goal":"predicate AllPositive_1342(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_1343","instance":1343,"id":238030,"goal":"predicate DistinctSeq_1343(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_1344","instance":1344,"id":238031,"goal":"predicate IsSubseq_1344(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_1345","instance":1345,"id":238032,"goal":"predicate IsPermutation_1345(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_1346","instance":1346,"id":238033,"goal":"predicate IsEven_1346(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_1347","instance":1347,"id":238034,"goal":"predicate InRange_1347(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_1348","instance":1348,"id":238035,"goal":"predicate SubsetOf_1348(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_1349","instance":1349,"id":238036,"goal":"predicate AllMem_1349(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_1350","instance":1350,"id":238037,"goal":"predicate DisjointSets_1350(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_1351","instance":1351,"id":238038,"goal":"predicate Sorted_1351(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_1352","instance":1352,"id":238039,"goal":"predicate AllPositive_1352(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_1353","instance":1353,"id":238040,"goal":"predicate DistinctSeq_1353(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_1354","instance":1354,"id":238041,"goal":"predicate IsSubseq_1354(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_1355","instance":1355,"id":238042,"goal":"predicate IsPermutation_1355(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_1356","instance":1356,"id":238043,"goal":"predicate IsEven_1356(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_1357","instance":1357,"id":238044,"goal":"predicate InRange_1357(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_1358","instance":1358,"id":238045,"goal":"predicate SubsetOf_1358(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_1359","instance":1359,"id":238046,"goal":"predicate AllMem_1359(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_1360","instance":1360,"id":238047,"goal":"predicate DisjointSets_1360(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_1361","instance":1361,"id":238048,"goal":"predicate Sorted_1361(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_1362","instance":1362,"id":238049,"goal":"predicate AllPositive_1362(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_1363","instance":1363,"id":238050,"goal":"predicate DistinctSeq_1363(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_1364","instance":1364,"id":238051,"goal":"predicate IsSubseq_1364(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_1365","instance":1365,"id":238052,"goal":"predicate IsPermutation_1365(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_1366","instance":1366,"id":238053,"goal":"predicate IsEven_1366(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_1367","instance":1367,"id":238054,"goal":"predicate InRange_1367(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_1368","instance":1368,"id":238055,"goal":"predicate SubsetOf_1368(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_1369","instance":1369,"id":238056,"goal":"predicate AllMem_1369(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_1370","instance":1370,"id":238057,"goal":"predicate DisjointSets_1370(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_1371","instance":1371,"id":238058,"goal":"predicate Sorted_1371(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_1372","instance":1372,"id":238059,"goal":"predicate AllPositive_1372(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_1373","instance":1373,"id":238060,"goal":"predicate DistinctSeq_1373(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_1374","instance":1374,"id":238061,"goal":"predicate IsSubseq_1374(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_1375","instance":1375,"id":238062,"goal":"predicate IsPermutation_1375(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_1376","instance":1376,"id":238063,"goal":"predicate IsEven_1376(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_1377","instance":1377,"id":238064,"goal":"predicate InRange_1377(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_1378","instance":1378,"id":238065,"goal":"predicate SubsetOf_1378(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_1379","instance":1379,"id":238066,"goal":"predicate AllMem_1379(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_1380","instance":1380,"id":238067,"goal":"predicate DisjointSets_1380(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_1381","instance":1381,"id":238068,"goal":"predicate Sorted_1381(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_1382","instance":1382,"id":238069,"goal":"predicate AllPositive_1382(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_1383","instance":1383,"id":238070,"goal":"predicate DistinctSeq_1383(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_1384","instance":1384,"id":238071,"goal":"predicate IsSubseq_1384(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_1385","instance":1385,"id":238072,"goal":"predicate IsPermutation_1385(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_1386","instance":1386,"id":238073,"goal":"predicate IsEven_1386(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_1387","instance":1387,"id":238074,"goal":"predicate InRange_1387(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_1388","instance":1388,"id":238075,"goal":"predicate SubsetOf_1388(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_1389","instance":1389,"id":238076,"goal":"predicate AllMem_1389(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_1390","instance":1390,"id":238077,"goal":"predicate DisjointSets_1390(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_1391","instance":1391,"id":238078,"goal":"predicate Sorted_1391(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_1392","instance":1392,"id":238079,"goal":"predicate AllPositive_1392(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_1393","instance":1393,"id":238080,"goal":"predicate DistinctSeq_1393(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_1394","instance":1394,"id":238081,"goal":"predicate IsSubseq_1394(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_1395","instance":1395,"id":238082,"goal":"predicate IsPermutation_1395(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_1396","instance":1396,"id":238083,"goal":"predicate IsEven_1396(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_1397","instance":1397,"id":238084,"goal":"predicate InRange_1397(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_1398","instance":1398,"id":238085,"goal":"predicate SubsetOf_1398(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_1399","instance":1399,"id":238086,"goal":"predicate AllMem_1399(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_1400","instance":1400,"id":238087,"goal":"predicate DisjointSets_1400(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_1401","instance":1401,"id":238088,"goal":"predicate Sorted_1401(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_1402","instance":1402,"id":238089,"goal":"predicate AllPositive_1402(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_1403","instance":1403,"id":238090,"goal":"predicate DistinctSeq_1403(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_1404","instance":1404,"id":238091,"goal":"predicate IsSubseq_1404(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_1405","instance":1405,"id":238092,"goal":"predicate IsPermutation_1405(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_1406","instance":1406,"id":238093,"goal":"predicate IsEven_1406(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_1407","instance":1407,"id":238094,"goal":"predicate InRange_1407(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_1408","instance":1408,"id":238095,"goal":"predicate SubsetOf_1408(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_1409","instance":1409,"id":238096,"goal":"predicate AllMem_1409(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_1410","instance":1410,"id":238097,"goal":"predicate DisjointSets_1410(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_1411","instance":1411,"id":238098,"goal":"predicate Sorted_1411(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_1412","instance":1412,"id":238099,"goal":"predicate AllPositive_1412(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_1413","instance":1413,"id":238100,"goal":"predicate DistinctSeq_1413(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_1414","instance":1414,"id":238101,"goal":"predicate IsSubseq_1414(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_1415","instance":1415,"id":238102,"goal":"predicate IsPermutation_1415(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_1416","instance":1416,"id":238103,"goal":"predicate IsEven_1416(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_1417","instance":1417,"id":238104,"goal":"predicate InRange_1417(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_1418","instance":1418,"id":238105,"goal":"predicate SubsetOf_1418(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_1419","instance":1419,"id":238106,"goal":"predicate AllMem_1419(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_1420","instance":1420,"id":238107,"goal":"predicate DisjointSets_1420(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_1421","instance":1421,"id":238108,"goal":"predicate Sorted_1421(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_1422","instance":1422,"id":238109,"goal":"predicate AllPositive_1422(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_1423","instance":1423,"id":238110,"goal":"predicate DistinctSeq_1423(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_1424","instance":1424,"id":238111,"goal":"predicate IsSubseq_1424(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_1425","instance":1425,"id":238112,"goal":"predicate IsPermutation_1425(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_1426","instance":1426,"id":238113,"goal":"predicate IsEven_1426(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_1427","instance":1427,"id":238114,"goal":"predicate InRange_1427(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_1428","instance":1428,"id":238115,"goal":"predicate SubsetOf_1428(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_1429","instance":1429,"id":238116,"goal":"predicate AllMem_1429(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_1430","instance":1430,"id":238117,"goal":"predicate DisjointSets_1430(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_1431","instance":1431,"id":238118,"goal":"predicate Sorted_1431(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_1432","instance":1432,"id":238119,"goal":"predicate AllPositive_1432(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_1433","instance":1433,"id":238120,"goal":"predicate DistinctSeq_1433(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_1434","instance":1434,"id":238121,"goal":"predicate IsSubseq_1434(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_1435","instance":1435,"id":238122,"goal":"predicate IsPermutation_1435(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_1436","instance":1436,"id":238123,"goal":"predicate IsEven_1436(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_1437","instance":1437,"id":238124,"goal":"predicate InRange_1437(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_1438","instance":1438,"id":238125,"goal":"predicate SubsetOf_1438(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_1439","instance":1439,"id":238126,"goal":"predicate AllMem_1439(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_1440","instance":1440,"id":238127,"goal":"predicate DisjointSets_1440(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_1441","instance":1441,"id":238128,"goal":"predicate Sorted_1441(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_1442","instance":1442,"id":238129,"goal":"predicate AllPositive_1442(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_1443","instance":1443,"id":238130,"goal":"predicate DistinctSeq_1443(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_1444","instance":1444,"id":238131,"goal":"predicate IsSubseq_1444(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_1445","instance":1445,"id":238132,"goal":"predicate IsPermutation_1445(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_1446","instance":1446,"id":238133,"goal":"predicate IsEven_1446(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_1447","instance":1447,"id":238134,"goal":"predicate InRange_1447(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_1448","instance":1448,"id":238135,"goal":"predicate SubsetOf_1448(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_1449","instance":1449,"id":238136,"goal":"predicate AllMem_1449(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_1450","instance":1450,"id":238137,"goal":"predicate DisjointSets_1450(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_1451","instance":1451,"id":238138,"goal":"predicate Sorted_1451(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_1452","instance":1452,"id":238139,"goal":"predicate AllPositive_1452(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_1453","instance":1453,"id":238140,"goal":"predicate DistinctSeq_1453(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_1454","instance":1454,"id":238141,"goal":"predicate IsSubseq_1454(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_1455","instance":1455,"id":238142,"goal":"predicate IsPermutation_1455(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_1456","instance":1456,"id":238143,"goal":"predicate IsEven_1456(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_1457","instance":1457,"id":238144,"goal":"predicate InRange_1457(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_1458","instance":1458,"id":238145,"goal":"predicate SubsetOf_1458(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_1459","instance":1459,"id":238146,"goal":"predicate AllMem_1459(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_1460","instance":1460,"id":238147,"goal":"predicate DisjointSets_1460(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_1461","instance":1461,"id":238148,"goal":"predicate Sorted_1461(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_1462","instance":1462,"id":238149,"goal":"predicate AllPositive_1462(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_1463","instance":1463,"id":238150,"goal":"predicate DistinctSeq_1463(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_1464","instance":1464,"id":238151,"goal":"predicate IsSubseq_1464(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_1465","instance":1465,"id":238152,"goal":"predicate IsPermutation_1465(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_1466","instance":1466,"id":238153,"goal":"predicate IsEven_1466(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_1467","instance":1467,"id":238154,"goal":"predicate InRange_1467(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_1468","instance":1468,"id":238155,"goal":"predicate SubsetOf_1468(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_1469","instance":1469,"id":238156,"goal":"predicate AllMem_1469(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_1470","instance":1470,"id":238157,"goal":"predicate DisjointSets_1470(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_1471","instance":1471,"id":238158,"goal":"predicate Sorted_1471(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_1472","instance":1472,"id":238159,"goal":"predicate AllPositive_1472(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_1473","instance":1473,"id":238160,"goal":"predicate DistinctSeq_1473(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_1474","instance":1474,"id":238161,"goal":"predicate IsSubseq_1474(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_1475","instance":1475,"id":238162,"goal":"predicate IsPermutation_1475(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_1476","instance":1476,"id":238163,"goal":"predicate IsEven_1476(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_1477","instance":1477,"id":238164,"goal":"predicate InRange_1477(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_1478","instance":1478,"id":238165,"goal":"predicate SubsetOf_1478(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_1479","instance":1479,"id":238166,"goal":"predicate AllMem_1479(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_1480","instance":1480,"id":238167,"goal":"predicate DisjointSets_1480(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_1481","instance":1481,"id":238168,"goal":"predicate Sorted_1481(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_1482","instance":1482,"id":238169,"goal":"predicate AllPositive_1482(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_1483","instance":1483,"id":238170,"goal":"predicate DistinctSeq_1483(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_1484","instance":1484,"id":238171,"goal":"predicate IsSubseq_1484(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_1485","instance":1485,"id":238172,"goal":"predicate IsPermutation_1485(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_1486","instance":1486,"id":238173,"goal":"predicate IsEven_1486(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_1487","instance":1487,"id":238174,"goal":"predicate InRange_1487(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_1488","instance":1488,"id":238175,"goal":"predicate SubsetOf_1488(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_1489","instance":1489,"id":238176,"goal":"predicate AllMem_1489(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_1490","instance":1490,"id":238177,"goal":"predicate DisjointSets_1490(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_1491","instance":1491,"id":238178,"goal":"predicate Sorted_1491(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_1492","instance":1492,"id":238179,"goal":"predicate AllPositive_1492(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_1493","instance":1493,"id":238180,"goal":"predicate DistinctSeq_1493(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_1494","instance":1494,"id":238181,"goal":"predicate IsSubseq_1494(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_1495","instance":1495,"id":238182,"goal":"predicate IsPermutation_1495(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_1496","instance":1496,"id":238183,"goal":"predicate IsEven_1496(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_1497","instance":1497,"id":238184,"goal":"predicate InRange_1497(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_1498","instance":1498,"id":238185,"goal":"predicate SubsetOf_1498(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_1499","instance":1499,"id":238186,"goal":"predicate AllMem_1499(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_1500","instance":1500,"id":238187,"goal":"predicate DisjointSets_1500(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_1501","instance":1501,"id":238188,"goal":"predicate Sorted_1501(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_1502","instance":1502,"id":238189,"goal":"predicate AllPositive_1502(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_1503","instance":1503,"id":238190,"goal":"predicate DistinctSeq_1503(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_1504","instance":1504,"id":238191,"goal":"predicate IsSubseq_1504(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_1505","instance":1505,"id":238192,"goal":"predicate IsPermutation_1505(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_1506","instance":1506,"id":238193,"goal":"predicate IsEven_1506(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_1507","instance":1507,"id":238194,"goal":"predicate InRange_1507(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_1508","instance":1508,"id":238195,"goal":"predicate SubsetOf_1508(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_1509","instance":1509,"id":238196,"goal":"predicate AllMem_1509(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_1510","instance":1510,"id":238197,"goal":"predicate DisjointSets_1510(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_1511","instance":1511,"id":238198,"goal":"predicate Sorted_1511(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_1512","instance":1512,"id":238199,"goal":"predicate AllPositive_1512(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_1513","instance":1513,"id":238200,"goal":"predicate DistinctSeq_1513(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_1514","instance":1514,"id":238201,"goal":"predicate IsSubseq_1514(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_1515","instance":1515,"id":238202,"goal":"predicate IsPermutation_1515(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_1516","instance":1516,"id":238203,"goal":"predicate IsEven_1516(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_1517","instance":1517,"id":238204,"goal":"predicate InRange_1517(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_1518","instance":1518,"id":238205,"goal":"predicate SubsetOf_1518(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_1519","instance":1519,"id":238206,"goal":"predicate AllMem_1519(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_1520","instance":1520,"id":238207,"goal":"predicate DisjointSets_1520(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_1521","instance":1521,"id":238208,"goal":"predicate Sorted_1521(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_1522","instance":1522,"id":238209,"goal":"predicate AllPositive_1522(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_1523","instance":1523,"id":238210,"goal":"predicate DistinctSeq_1523(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_1524","instance":1524,"id":238211,"goal":"predicate IsSubseq_1524(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_1525","instance":1525,"id":238212,"goal":"predicate IsPermutation_1525(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_1526","instance":1526,"id":238213,"goal":"predicate IsEven_1526(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_1527","instance":1527,"id":238214,"goal":"predicate InRange_1527(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_1528","instance":1528,"id":238215,"goal":"predicate SubsetOf_1528(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_1529","instance":1529,"id":238216,"goal":"predicate AllMem_1529(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_1530","instance":1530,"id":238217,"goal":"predicate DisjointSets_1530(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_1531","instance":1531,"id":238218,"goal":"predicate Sorted_1531(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_1532","instance":1532,"id":238219,"goal":"predicate AllPositive_1532(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_1533","instance":1533,"id":238220,"goal":"predicate DistinctSeq_1533(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_1534","instance":1534,"id":238221,"goal":"predicate IsSubseq_1534(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_1535","instance":1535,"id":238222,"goal":"predicate IsPermutation_1535(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_1536","instance":1536,"id":238223,"goal":"predicate IsEven_1536(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_1537","instance":1537,"id":238224,"goal":"predicate InRange_1537(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_1538","instance":1538,"id":238225,"goal":"predicate SubsetOf_1538(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_1539","instance":1539,"id":238226,"goal":"predicate AllMem_1539(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_1540","instance":1540,"id":238227,"goal":"predicate DisjointSets_1540(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_1541","instance":1541,"id":238228,"goal":"predicate Sorted_1541(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_1542","instance":1542,"id":238229,"goal":"predicate AllPositive_1542(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_1543","instance":1543,"id":238230,"goal":"predicate DistinctSeq_1543(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_1544","instance":1544,"id":238231,"goal":"predicate IsSubseq_1544(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_1545","instance":1545,"id":238232,"goal":"predicate IsPermutation_1545(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_1546","instance":1546,"id":238233,"goal":"predicate IsEven_1546(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_1547","instance":1547,"id":238234,"goal":"predicate InRange_1547(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_1548","instance":1548,"id":238235,"goal":"predicate SubsetOf_1548(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_1549","instance":1549,"id":238236,"goal":"predicate AllMem_1549(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_1550","instance":1550,"id":238237,"goal":"predicate DisjointSets_1550(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_1551","instance":1551,"id":238238,"goal":"predicate Sorted_1551(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_1552","instance":1552,"id":238239,"goal":"predicate AllPositive_1552(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_1553","instance":1553,"id":238240,"goal":"predicate DistinctSeq_1553(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_1554","instance":1554,"id":238241,"goal":"predicate IsSubseq_1554(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_1555","instance":1555,"id":238242,"goal":"predicate IsPermutation_1555(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_1556","instance":1556,"id":238243,"goal":"predicate IsEven_1556(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_1557","instance":1557,"id":238244,"goal":"predicate InRange_1557(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_1558","instance":1558,"id":238245,"goal":"predicate SubsetOf_1558(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_1559","instance":1559,"id":238246,"goal":"predicate AllMem_1559(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_1560","instance":1560,"id":238247,"goal":"predicate DisjointSets_1560(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_1561","instance":1561,"id":238248,"goal":"predicate Sorted_1561(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_1562","instance":1562,"id":238249,"goal":"predicate AllPositive_1562(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_1563","instance":1563,"id":238250,"goal":"predicate DistinctSeq_1563(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_1564","instance":1564,"id":238251,"goal":"predicate IsSubseq_1564(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_1565","instance":1565,"id":238252,"goal":"predicate IsPermutation_1565(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_1566","instance":1566,"id":238253,"goal":"predicate IsEven_1566(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_1567","instance":1567,"id":238254,"goal":"predicate InRange_1567(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_1568","instance":1568,"id":238255,"goal":"predicate SubsetOf_1568(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_1569","instance":1569,"id":238256,"goal":"predicate AllMem_1569(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_1570","instance":1570,"id":238257,"goal":"predicate DisjointSets_1570(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_1571","instance":1571,"id":238258,"goal":"predicate Sorted_1571(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_1572","instance":1572,"id":238259,"goal":"predicate AllPositive_1572(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_1573","instance":1573,"id":238260,"goal":"predicate DistinctSeq_1573(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_1574","instance":1574,"id":238261,"goal":"predicate IsSubseq_1574(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_1575","instance":1575,"id":238262,"goal":"predicate IsPermutation_1575(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_1576","instance":1576,"id":238263,"goal":"predicate IsEven_1576(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_1577","instance":1577,"id":238264,"goal":"predicate InRange_1577(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_1578","instance":1578,"id":238265,"goal":"predicate SubsetOf_1578(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_1579","instance":1579,"id":238266,"goal":"predicate AllMem_1579(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_1580","instance":1580,"id":238267,"goal":"predicate DisjointSets_1580(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_1581","instance":1581,"id":238268,"goal":"predicate Sorted_1581(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_1582","instance":1582,"id":238269,"goal":"predicate AllPositive_1582(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_1583","instance":1583,"id":238270,"goal":"predicate DistinctSeq_1583(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_1584","instance":1584,"id":238271,"goal":"predicate IsSubseq_1584(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_1585","instance":1585,"id":238272,"goal":"predicate IsPermutation_1585(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_1586","instance":1586,"id":238273,"goal":"predicate IsEven_1586(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_1587","instance":1587,"id":238274,"goal":"predicate InRange_1587(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_1588","instance":1588,"id":238275,"goal":"predicate SubsetOf_1588(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_1589","instance":1589,"id":238276,"goal":"predicate AllMem_1589(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_1590","instance":1590,"id":238277,"goal":"predicate DisjointSets_1590(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_1591","instance":1591,"id":238278,"goal":"predicate Sorted_1591(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_1592","instance":1592,"id":238279,"goal":"predicate AllPositive_1592(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_1593","instance":1593,"id":238280,"goal":"predicate DistinctSeq_1593(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_1594","instance":1594,"id":238281,"goal":"predicate IsSubseq_1594(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_1595","instance":1595,"id":238282,"goal":"predicate IsPermutation_1595(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_1596","instance":1596,"id":238283,"goal":"predicate IsEven_1596(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_1597","instance":1597,"id":238284,"goal":"predicate InRange_1597(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_1598","instance":1598,"id":238285,"goal":"predicate SubsetOf_1598(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_1599","instance":1599,"id":238286,"goal":"predicate AllMem_1599(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_1600","instance":1600,"id":238287,"goal":"predicate DisjointSets_1600(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_1601","instance":1601,"id":238288,"goal":"predicate Sorted_1601(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_1602","instance":1602,"id":238289,"goal":"predicate AllPositive_1602(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_1603","instance":1603,"id":238290,"goal":"predicate DistinctSeq_1603(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_1604","instance":1604,"id":238291,"goal":"predicate IsSubseq_1604(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_1605","instance":1605,"id":238292,"goal":"predicate IsPermutation_1605(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_1606","instance":1606,"id":238293,"goal":"predicate IsEven_1606(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_1607","instance":1607,"id":238294,"goal":"predicate InRange_1607(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_1608","instance":1608,"id":238295,"goal":"predicate SubsetOf_1608(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_1609","instance":1609,"id":238296,"goal":"predicate AllMem_1609(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_1610","instance":1610,"id":238297,"goal":"predicate DisjointSets_1610(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_1611","instance":1611,"id":238298,"goal":"predicate Sorted_1611(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_1612","instance":1612,"id":238299,"goal":"predicate AllPositive_1612(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_1613","instance":1613,"id":238300,"goal":"predicate DistinctSeq_1613(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_1614","instance":1614,"id":238301,"goal":"predicate IsSubseq_1614(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_1615","instance":1615,"id":238302,"goal":"predicate IsPermutation_1615(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_1616","instance":1616,"id":238303,"goal":"predicate IsEven_1616(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_1617","instance":1617,"id":238304,"goal":"predicate InRange_1617(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_1618","instance":1618,"id":238305,"goal":"predicate SubsetOf_1618(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_1619","instance":1619,"id":238306,"goal":"predicate AllMem_1619(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_1620","instance":1620,"id":238307,"goal":"predicate DisjointSets_1620(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_1621","instance":1621,"id":238308,"goal":"predicate Sorted_1621(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_1622","instance":1622,"id":238309,"goal":"predicate AllPositive_1622(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_1623","instance":1623,"id":238310,"goal":"predicate DistinctSeq_1623(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_1624","instance":1624,"id":238311,"goal":"predicate IsSubseq_1624(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_1625","instance":1625,"id":238312,"goal":"predicate IsPermutation_1625(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_1626","instance":1626,"id":238313,"goal":"predicate IsEven_1626(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_1627","instance":1627,"id":238314,"goal":"predicate InRange_1627(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_1628","instance":1628,"id":238315,"goal":"predicate SubsetOf_1628(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_1629","instance":1629,"id":238316,"goal":"predicate AllMem_1629(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_1630","instance":1630,"id":238317,"goal":"predicate DisjointSets_1630(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_1631","instance":1631,"id":238318,"goal":"predicate Sorted_1631(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_1632","instance":1632,"id":238319,"goal":"predicate AllPositive_1632(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_1633","instance":1633,"id":238320,"goal":"predicate DistinctSeq_1633(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_1634","instance":1634,"id":238321,"goal":"predicate IsSubseq_1634(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_1635","instance":1635,"id":238322,"goal":"predicate IsPermutation_1635(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_1636","instance":1636,"id":238323,"goal":"predicate IsEven_1636(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_1637","instance":1637,"id":238324,"goal":"predicate InRange_1637(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_1638","instance":1638,"id":238325,"goal":"predicate SubsetOf_1638(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_1639","instance":1639,"id":238326,"goal":"predicate AllMem_1639(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_1640","instance":1640,"id":238327,"goal":"predicate DisjointSets_1640(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_1641","instance":1641,"id":238328,"goal":"predicate Sorted_1641(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_1642","instance":1642,"id":238329,"goal":"predicate AllPositive_1642(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_1643","instance":1643,"id":238330,"goal":"predicate DistinctSeq_1643(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_1644","instance":1644,"id":238331,"goal":"predicate IsSubseq_1644(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_1645","instance":1645,"id":238332,"goal":"predicate IsPermutation_1645(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_1646","instance":1646,"id":238333,"goal":"predicate IsEven_1646(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_1647","instance":1647,"id":238334,"goal":"predicate InRange_1647(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_1648","instance":1648,"id":238335,"goal":"predicate SubsetOf_1648(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_1649","instance":1649,"id":238336,"goal":"predicate AllMem_1649(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_1650","instance":1650,"id":238337,"goal":"predicate DisjointSets_1650(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_1651","instance":1651,"id":238338,"goal":"predicate Sorted_1651(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_1652","instance":1652,"id":238339,"goal":"predicate AllPositive_1652(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_1653","instance":1653,"id":238340,"goal":"predicate DistinctSeq_1653(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_1654","instance":1654,"id":238341,"goal":"predicate IsSubseq_1654(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_1655","instance":1655,"id":238342,"goal":"predicate IsPermutation_1655(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_1656","instance":1656,"id":238343,"goal":"predicate IsEven_1656(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_1657","instance":1657,"id":238344,"goal":"predicate InRange_1657(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_1658","instance":1658,"id":238345,"goal":"predicate SubsetOf_1658(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_1659","instance":1659,"id":238346,"goal":"predicate AllMem_1659(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_1660","instance":1660,"id":238347,"goal":"predicate DisjointSets_1660(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_1661","instance":1661,"id":238348,"goal":"predicate Sorted_1661(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_1662","instance":1662,"id":238349,"goal":"predicate AllPositive_1662(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_1663","instance":1663,"id":238350,"goal":"predicate DistinctSeq_1663(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_1664","instance":1664,"id":238351,"goal":"predicate IsSubseq_1664(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_1665","instance":1665,"id":238352,"goal":"predicate IsPermutation_1665(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_1666","instance":1666,"id":238353,"goal":"predicate IsEven_1666(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_1667","instance":1667,"id":238354,"goal":"predicate InRange_1667(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_1668","instance":1668,"id":238355,"goal":"predicate SubsetOf_1668(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_1669","instance":1669,"id":238356,"goal":"predicate AllMem_1669(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_1670","instance":1670,"id":238357,"goal":"predicate DisjointSets_1670(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_1671","instance":1671,"id":238358,"goal":"predicate Sorted_1671(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_1672","instance":1672,"id":238359,"goal":"predicate AllPositive_1672(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_1673","instance":1673,"id":238360,"goal":"predicate DistinctSeq_1673(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_1674","instance":1674,"id":238361,"goal":"predicate IsSubseq_1674(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_1675","instance":1675,"id":238362,"goal":"predicate IsPermutation_1675(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_1676","instance":1676,"id":238363,"goal":"predicate IsEven_1676(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_1677","instance":1677,"id":238364,"goal":"predicate InRange_1677(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_1678","instance":1678,"id":238365,"goal":"predicate SubsetOf_1678(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_1679","instance":1679,"id":238366,"goal":"predicate AllMem_1679(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_1680","instance":1680,"id":238367,"goal":"predicate DisjointSets_1680(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_1681","instance":1681,"id":238368,"goal":"predicate Sorted_1681(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_1682","instance":1682,"id":238369,"goal":"predicate AllPositive_1682(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_1683","instance":1683,"id":238370,"goal":"predicate DistinctSeq_1683(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_1684","instance":1684,"id":238371,"goal":"predicate IsSubseq_1684(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_1685","instance":1685,"id":238372,"goal":"predicate IsPermutation_1685(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_1686","instance":1686,"id":238373,"goal":"predicate IsEven_1686(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_1687","instance":1687,"id":238374,"goal":"predicate InRange_1687(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_1688","instance":1688,"id":238375,"goal":"predicate SubsetOf_1688(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_1689","instance":1689,"id":238376,"goal":"predicate AllMem_1689(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_1690","instance":1690,"id":238377,"goal":"predicate DisjointSets_1690(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_1691","instance":1691,"id":238378,"goal":"predicate Sorted_1691(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_1692","instance":1692,"id":238379,"goal":"predicate AllPositive_1692(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_1693","instance":1693,"id":238380,"goal":"predicate DistinctSeq_1693(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_1694","instance":1694,"id":238381,"goal":"predicate IsSubseq_1694(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_1695","instance":1695,"id":238382,"goal":"predicate IsPermutation_1695(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_1696","instance":1696,"id":238383,"goal":"predicate IsEven_1696(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_1697","instance":1697,"id":238384,"goal":"predicate InRange_1697(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_1698","instance":1698,"id":238385,"goal":"predicate SubsetOf_1698(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_1699","instance":1699,"id":238386,"goal":"predicate AllMem_1699(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_1700","instance":1700,"id":238387,"goal":"predicate DisjointSets_1700(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_1701","instance":1701,"id":238388,"goal":"predicate Sorted_1701(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_1702","instance":1702,"id":238389,"goal":"predicate AllPositive_1702(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_1703","instance":1703,"id":238390,"goal":"predicate DistinctSeq_1703(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_1704","instance":1704,"id":238391,"goal":"predicate IsSubseq_1704(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_1705","instance":1705,"id":238392,"goal":"predicate IsPermutation_1705(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_1706","instance":1706,"id":238393,"goal":"predicate IsEven_1706(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_1707","instance":1707,"id":238394,"goal":"predicate InRange_1707(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_1708","instance":1708,"id":238395,"goal":"predicate SubsetOf_1708(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_1709","instance":1709,"id":238396,"goal":"predicate AllMem_1709(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_1710","instance":1710,"id":238397,"goal":"predicate DisjointSets_1710(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_1711","instance":1711,"id":238398,"goal":"predicate Sorted_1711(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_1712","instance":1712,"id":238399,"goal":"predicate AllPositive_1712(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_1713","instance":1713,"id":238400,"goal":"predicate DistinctSeq_1713(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_1714","instance":1714,"id":238401,"goal":"predicate IsSubseq_1714(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_1715","instance":1715,"id":238402,"goal":"predicate IsPermutation_1715(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_1716","instance":1716,"id":238403,"goal":"predicate IsEven_1716(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_1717","instance":1717,"id":238404,"goal":"predicate InRange_1717(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_1718","instance":1718,"id":238405,"goal":"predicate SubsetOf_1718(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_1719","instance":1719,"id":238406,"goal":"predicate AllMem_1719(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_1720","instance":1720,"id":238407,"goal":"predicate DisjointSets_1720(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_1721","instance":1721,"id":238408,"goal":"predicate Sorted_1721(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_1722","instance":1722,"id":238409,"goal":"predicate AllPositive_1722(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_1723","instance":1723,"id":238410,"goal":"predicate DistinctSeq_1723(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_1724","instance":1724,"id":238411,"goal":"predicate IsSubseq_1724(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_1725","instance":1725,"id":238412,"goal":"predicate IsPermutation_1725(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_1726","instance":1726,"id":238413,"goal":"predicate IsEven_1726(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_1727","instance":1727,"id":238414,"goal":"predicate InRange_1727(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_1728","instance":1728,"id":238415,"goal":"predicate SubsetOf_1728(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_1729","instance":1729,"id":238416,"goal":"predicate AllMem_1729(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_1730","instance":1730,"id":238417,"goal":"predicate DisjointSets_1730(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_1731","instance":1731,"id":238418,"goal":"predicate Sorted_1731(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_1732","instance":1732,"id":238419,"goal":"predicate AllPositive_1732(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_1733","instance":1733,"id":238420,"goal":"predicate DistinctSeq_1733(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_1734","instance":1734,"id":238421,"goal":"predicate IsSubseq_1734(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_1735","instance":1735,"id":238422,"goal":"predicate IsPermutation_1735(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_1736","instance":1736,"id":238423,"goal":"predicate IsEven_1736(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_1737","instance":1737,"id":238424,"goal":"predicate InRange_1737(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_1738","instance":1738,"id":238425,"goal":"predicate SubsetOf_1738(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_1739","instance":1739,"id":238426,"goal":"predicate AllMem_1739(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_1740","instance":1740,"id":238427,"goal":"predicate DisjointSets_1740(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_1741","instance":1741,"id":238428,"goal":"predicate Sorted_1741(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_1742","instance":1742,"id":238429,"goal":"predicate AllPositive_1742(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_1743","instance":1743,"id":238430,"goal":"predicate DistinctSeq_1743(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_1744","instance":1744,"id":238431,"goal":"predicate IsSubseq_1744(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_1745","instance":1745,"id":238432,"goal":"predicate IsPermutation_1745(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_1746","instance":1746,"id":238433,"goal":"predicate IsEven_1746(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_1747","instance":1747,"id":238434,"goal":"predicate InRange_1747(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_1748","instance":1748,"id":238435,"goal":"predicate SubsetOf_1748(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_1749","instance":1749,"id":238436,"goal":"predicate AllMem_1749(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_1750","instance":1750,"id":238437,"goal":"predicate DisjointSets_1750(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_1751","instance":1751,"id":238438,"goal":"predicate Sorted_1751(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_1752","instance":1752,"id":238439,"goal":"predicate AllPositive_1752(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_1753","instance":1753,"id":238440,"goal":"predicate DistinctSeq_1753(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_1754","instance":1754,"id":238441,"goal":"predicate IsSubseq_1754(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_1755","instance":1755,"id":238442,"goal":"predicate IsPermutation_1755(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_1756","instance":1756,"id":238443,"goal":"predicate IsEven_1756(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_1757","instance":1757,"id":238444,"goal":"predicate InRange_1757(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_1758","instance":1758,"id":238445,"goal":"predicate SubsetOf_1758(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_1759","instance":1759,"id":238446,"goal":"predicate AllMem_1759(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_1760","instance":1760,"id":238447,"goal":"predicate DisjointSets_1760(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_1761","instance":1761,"id":238448,"goal":"predicate Sorted_1761(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_1762","instance":1762,"id":238449,"goal":"predicate AllPositive_1762(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_1763","instance":1763,"id":238450,"goal":"predicate DistinctSeq_1763(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_1764","instance":1764,"id":238451,"goal":"predicate IsSubseq_1764(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_1765","instance":1765,"id":238452,"goal":"predicate IsPermutation_1765(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_1766","instance":1766,"id":238453,"goal":"predicate IsEven_1766(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_1767","instance":1767,"id":238454,"goal":"predicate InRange_1767(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_1768","instance":1768,"id":238455,"goal":"predicate SubsetOf_1768(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_1769","instance":1769,"id":238456,"goal":"predicate AllMem_1769(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_1770","instance":1770,"id":238457,"goal":"predicate DisjointSets_1770(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_1771","instance":1771,"id":238458,"goal":"predicate Sorted_1771(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_1772","instance":1772,"id":238459,"goal":"predicate AllPositive_1772(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_1773","instance":1773,"id":238460,"goal":"predicate DistinctSeq_1773(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_1774","instance":1774,"id":238461,"goal":"predicate IsSubseq_1774(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_1775","instance":1775,"id":238462,"goal":"predicate IsPermutation_1775(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_1776","instance":1776,"id":238463,"goal":"predicate IsEven_1776(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_1777","instance":1777,"id":238464,"goal":"predicate InRange_1777(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_1778","instance":1778,"id":238465,"goal":"predicate SubsetOf_1778(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_1779","instance":1779,"id":238466,"goal":"predicate AllMem_1779(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_1780","instance":1780,"id":238467,"goal":"predicate DisjointSets_1780(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_1781","instance":1781,"id":238468,"goal":"predicate Sorted_1781(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_1782","instance":1782,"id":238469,"goal":"predicate AllPositive_1782(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_1783","instance":1783,"id":238470,"goal":"predicate DistinctSeq_1783(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_1784","instance":1784,"id":238471,"goal":"predicate IsSubseq_1784(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_1785","instance":1785,"id":238472,"goal":"predicate IsPermutation_1785(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_1786","instance":1786,"id":238473,"goal":"predicate IsEven_1786(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_1787","instance":1787,"id":238474,"goal":"predicate InRange_1787(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_1788","instance":1788,"id":238475,"goal":"predicate SubsetOf_1788(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_1789","instance":1789,"id":238476,"goal":"predicate AllMem_1789(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_1790","instance":1790,"id":238477,"goal":"predicate DisjointSets_1790(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_1791","instance":1791,"id":238478,"goal":"predicate Sorted_1791(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_1792","instance":1792,"id":238479,"goal":"predicate AllPositive_1792(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_1793","instance":1793,"id":238480,"goal":"predicate DistinctSeq_1793(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_1794","instance":1794,"id":238481,"goal":"predicate IsSubseq_1794(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_1795","instance":1795,"id":238482,"goal":"predicate IsPermutation_1795(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_1796","instance":1796,"id":238483,"goal":"predicate IsEven_1796(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_1797","instance":1797,"id":238484,"goal":"predicate InRange_1797(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_1798","instance":1798,"id":238485,"goal":"predicate SubsetOf_1798(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_1799","instance":1799,"id":238486,"goal":"predicate AllMem_1799(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_1800","instance":1800,"id":238487,"goal":"predicate DisjointSets_1800(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_1801","instance":1801,"id":238488,"goal":"predicate Sorted_1801(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_1802","instance":1802,"id":238489,"goal":"predicate AllPositive_1802(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_1803","instance":1803,"id":238490,"goal":"predicate DistinctSeq_1803(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_1804","instance":1804,"id":238491,"goal":"predicate IsSubseq_1804(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_1805","instance":1805,"id":238492,"goal":"predicate IsPermutation_1805(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_1806","instance":1806,"id":238493,"goal":"predicate IsEven_1806(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_1807","instance":1807,"id":238494,"goal":"predicate InRange_1807(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_1808","instance":1808,"id":238495,"goal":"predicate SubsetOf_1808(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_1809","instance":1809,"id":238496,"goal":"predicate AllMem_1809(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_1810","instance":1810,"id":238497,"goal":"predicate DisjointSets_1810(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_1811","instance":1811,"id":238498,"goal":"predicate Sorted_1811(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_1812","instance":1812,"id":238499,"goal":"predicate AllPositive_1812(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_1813","instance":1813,"id":238500,"goal":"predicate DistinctSeq_1813(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_1814","instance":1814,"id":238501,"goal":"predicate IsSubseq_1814(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_1815","instance":1815,"id":238502,"goal":"predicate IsPermutation_1815(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_1816","instance":1816,"id":238503,"goal":"predicate IsEven_1816(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_1817","instance":1817,"id":238504,"goal":"predicate InRange_1817(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_1818","instance":1818,"id":238505,"goal":"predicate SubsetOf_1818(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_1819","instance":1819,"id":238506,"goal":"predicate AllMem_1819(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_1820","instance":1820,"id":238507,"goal":"predicate DisjointSets_1820(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_1821","instance":1821,"id":238508,"goal":"predicate Sorted_1821(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_1822","instance":1822,"id":238509,"goal":"predicate AllPositive_1822(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_1823","instance":1823,"id":238510,"goal":"predicate DistinctSeq_1823(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_1824","instance":1824,"id":238511,"goal":"predicate IsSubseq_1824(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_1825","instance":1825,"id":238512,"goal":"predicate IsPermutation_1825(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_1826","instance":1826,"id":238513,"goal":"predicate IsEven_1826(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_1827","instance":1827,"id":238514,"goal":"predicate InRange_1827(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_1828","instance":1828,"id":238515,"goal":"predicate SubsetOf_1828(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_1829","instance":1829,"id":238516,"goal":"predicate AllMem_1829(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_1830","instance":1830,"id":238517,"goal":"predicate DisjointSets_1830(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_1831","instance":1831,"id":238518,"goal":"predicate Sorted_1831(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_1832","instance":1832,"id":238519,"goal":"predicate AllPositive_1832(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_1833","instance":1833,"id":238520,"goal":"predicate DistinctSeq_1833(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_1834","instance":1834,"id":238521,"goal":"predicate IsSubseq_1834(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_1835","instance":1835,"id":238522,"goal":"predicate IsPermutation_1835(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_1836","instance":1836,"id":238523,"goal":"predicate IsEven_1836(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_1837","instance":1837,"id":238524,"goal":"predicate InRange_1837(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_1838","instance":1838,"id":238525,"goal":"predicate SubsetOf_1838(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_1839","instance":1839,"id":238526,"goal":"predicate AllMem_1839(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_1840","instance":1840,"id":238527,"goal":"predicate DisjointSets_1840(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_1841","instance":1841,"id":238528,"goal":"predicate Sorted_1841(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_1842","instance":1842,"id":238529,"goal":"predicate AllPositive_1842(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_1843","instance":1843,"id":238530,"goal":"predicate DistinctSeq_1843(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_1844","instance":1844,"id":238531,"goal":"predicate IsSubseq_1844(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_1845","instance":1845,"id":238532,"goal":"predicate IsPermutation_1845(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_1846","instance":1846,"id":238533,"goal":"predicate IsEven_1846(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_1847","instance":1847,"id":238534,"goal":"predicate InRange_1847(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_1848","instance":1848,"id":238535,"goal":"predicate SubsetOf_1848(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_1849","instance":1849,"id":238536,"goal":"predicate AllMem_1849(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_1850","instance":1850,"id":238537,"goal":"predicate DisjointSets_1850(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_1851","instance":1851,"id":238538,"goal":"predicate Sorted_1851(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_1852","instance":1852,"id":238539,"goal":"predicate AllPositive_1852(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_1853","instance":1853,"id":238540,"goal":"predicate DistinctSeq_1853(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_1854","instance":1854,"id":238541,"goal":"predicate IsSubseq_1854(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_1855","instance":1855,"id":238542,"goal":"predicate IsPermutation_1855(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_1856","instance":1856,"id":238543,"goal":"predicate IsEven_1856(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_1857","instance":1857,"id":238544,"goal":"predicate InRange_1857(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_1858","instance":1858,"id":238545,"goal":"predicate SubsetOf_1858(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_1859","instance":1859,"id":238546,"goal":"predicate AllMem_1859(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_1860","instance":1860,"id":238547,"goal":"predicate DisjointSets_1860(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_1861","instance":1861,"id":238548,"goal":"predicate Sorted_1861(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_1862","instance":1862,"id":238549,"goal":"predicate AllPositive_1862(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_1863","instance":1863,"id":238550,"goal":"predicate DistinctSeq_1863(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_1864","instance":1864,"id":238551,"goal":"predicate IsSubseq_1864(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_1865","instance":1865,"id":238552,"goal":"predicate IsPermutation_1865(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_1866","instance":1866,"id":238553,"goal":"predicate IsEven_1866(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_1867","instance":1867,"id":238554,"goal":"predicate InRange_1867(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_1868","instance":1868,"id":238555,"goal":"predicate SubsetOf_1868(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_1869","instance":1869,"id":238556,"goal":"predicate AllMem_1869(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_1870","instance":1870,"id":238557,"goal":"predicate DisjointSets_1870(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_1871","instance":1871,"id":238558,"goal":"predicate Sorted_1871(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_1872","instance":1872,"id":238559,"goal":"predicate AllPositive_1872(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_1873","instance":1873,"id":238560,"goal":"predicate DistinctSeq_1873(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_1874","instance":1874,"id":238561,"goal":"predicate IsSubseq_1874(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_1875","instance":1875,"id":238562,"goal":"predicate IsPermutation_1875(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_1876","instance":1876,"id":238563,"goal":"predicate IsEven_1876(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_1877","instance":1877,"id":238564,"goal":"predicate InRange_1877(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_1878","instance":1878,"id":238565,"goal":"predicate SubsetOf_1878(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_1879","instance":1879,"id":238566,"goal":"predicate AllMem_1879(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_1880","instance":1880,"id":238567,"goal":"predicate DisjointSets_1880(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_1881","instance":1881,"id":238568,"goal":"predicate Sorted_1881(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_1882","instance":1882,"id":238569,"goal":"predicate AllPositive_1882(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_1883","instance":1883,"id":238570,"goal":"predicate DistinctSeq_1883(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_1884","instance":1884,"id":238571,"goal":"predicate IsSubseq_1884(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_1885","instance":1885,"id":238572,"goal":"predicate IsPermutation_1885(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_1886","instance":1886,"id":238573,"goal":"predicate IsEven_1886(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_1887","instance":1887,"id":238574,"goal":"predicate InRange_1887(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_1888","instance":1888,"id":238575,"goal":"predicate SubsetOf_1888(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_1889","instance":1889,"id":238576,"goal":"predicate AllMem_1889(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_1890","instance":1890,"id":238577,"goal":"predicate DisjointSets_1890(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_1891","instance":1891,"id":238578,"goal":"predicate Sorted_1891(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_1892","instance":1892,"id":238579,"goal":"predicate AllPositive_1892(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_1893","instance":1893,"id":238580,"goal":"predicate DistinctSeq_1893(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_1894","instance":1894,"id":238581,"goal":"predicate IsSubseq_1894(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_1895","instance":1895,"id":238582,"goal":"predicate IsPermutation_1895(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_1896","instance":1896,"id":238583,"goal":"predicate IsEven_1896(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_1897","instance":1897,"id":238584,"goal":"predicate InRange_1897(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_1898","instance":1898,"id":238585,"goal":"predicate SubsetOf_1898(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_1899","instance":1899,"id":238586,"goal":"predicate AllMem_1899(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_1900","instance":1900,"id":238587,"goal":"predicate DisjointSets_1900(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_1901","instance":1901,"id":238588,"goal":"predicate Sorted_1901(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_1902","instance":1902,"id":238589,"goal":"predicate AllPositive_1902(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_1903","instance":1903,"id":238590,"goal":"predicate DistinctSeq_1903(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_1904","instance":1904,"id":238591,"goal":"predicate IsSubseq_1904(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_1905","instance":1905,"id":238592,"goal":"predicate IsPermutation_1905(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_1906","instance":1906,"id":238593,"goal":"predicate IsEven_1906(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_1907","instance":1907,"id":238594,"goal":"predicate InRange_1907(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_1908","instance":1908,"id":238595,"goal":"predicate SubsetOf_1908(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_1909","instance":1909,"id":238596,"goal":"predicate AllMem_1909(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_1910","instance":1910,"id":238597,"goal":"predicate DisjointSets_1910(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_1911","instance":1911,"id":238598,"goal":"predicate Sorted_1911(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_1912","instance":1912,"id":238599,"goal":"predicate AllPositive_1912(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_1913","instance":1913,"id":238600,"goal":"predicate DistinctSeq_1913(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_1914","instance":1914,"id":238601,"goal":"predicate IsSubseq_1914(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_1915","instance":1915,"id":238602,"goal":"predicate IsPermutation_1915(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_1916","instance":1916,"id":238603,"goal":"predicate IsEven_1916(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_1917","instance":1917,"id":238604,"goal":"predicate InRange_1917(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_1918","instance":1918,"id":238605,"goal":"predicate SubsetOf_1918(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_1919","instance":1919,"id":238606,"goal":"predicate AllMem_1919(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_1920","instance":1920,"id":238607,"goal":"predicate DisjointSets_1920(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_1921","instance":1921,"id":238608,"goal":"predicate Sorted_1921(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_1922","instance":1922,"id":238609,"goal":"predicate AllPositive_1922(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_1923","instance":1923,"id":238610,"goal":"predicate DistinctSeq_1923(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_1924","instance":1924,"id":238611,"goal":"predicate IsSubseq_1924(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_1925","instance":1925,"id":238612,"goal":"predicate IsPermutation_1925(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_1926","instance":1926,"id":238613,"goal":"predicate IsEven_1926(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_1927","instance":1927,"id":238614,"goal":"predicate InRange_1927(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_1928","instance":1928,"id":238615,"goal":"predicate SubsetOf_1928(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_1929","instance":1929,"id":238616,"goal":"predicate AllMem_1929(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_1930","instance":1930,"id":238617,"goal":"predicate DisjointSets_1930(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_1931","instance":1931,"id":238618,"goal":"predicate Sorted_1931(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_1932","instance":1932,"id":238619,"goal":"predicate AllPositive_1932(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_1933","instance":1933,"id":238620,"goal":"predicate DistinctSeq_1933(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_1934","instance":1934,"id":238621,"goal":"predicate IsSubseq_1934(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_1935","instance":1935,"id":238622,"goal":"predicate IsPermutation_1935(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_1936","instance":1936,"id":238623,"goal":"predicate IsEven_1936(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_1937","instance":1937,"id":238624,"goal":"predicate InRange_1937(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_1938","instance":1938,"id":238625,"goal":"predicate SubsetOf_1938(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_1939","instance":1939,"id":238626,"goal":"predicate AllMem_1939(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_1940","instance":1940,"id":238627,"goal":"predicate DisjointSets_1940(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_1941","instance":1941,"id":238628,"goal":"predicate Sorted_1941(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_1942","instance":1942,"id":238629,"goal":"predicate AllPositive_1942(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_1943","instance":1943,"id":238630,"goal":"predicate DistinctSeq_1943(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_1944","instance":1944,"id":238631,"goal":"predicate IsSubseq_1944(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_1945","instance":1945,"id":238632,"goal":"predicate IsPermutation_1945(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_1946","instance":1946,"id":238633,"goal":"predicate IsEven_1946(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_1947","instance":1947,"id":238634,"goal":"predicate InRange_1947(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_1948","instance":1948,"id":238635,"goal":"predicate SubsetOf_1948(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_1949","instance":1949,"id":238636,"goal":"predicate AllMem_1949(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_1950","instance":1950,"id":238637,"goal":"predicate DisjointSets_1950(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_1951","instance":1951,"id":238638,"goal":"predicate Sorted_1951(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_1952","instance":1952,"id":238639,"goal":"predicate AllPositive_1952(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_1953","instance":1953,"id":238640,"goal":"predicate DistinctSeq_1953(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_1954","instance":1954,"id":238641,"goal":"predicate IsSubseq_1954(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_1955","instance":1955,"id":238642,"goal":"predicate IsPermutation_1955(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_1956","instance":1956,"id":238643,"goal":"predicate IsEven_1956(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_1957","instance":1957,"id":238644,"goal":"predicate InRange_1957(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_1958","instance":1958,"id":238645,"goal":"predicate SubsetOf_1958(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_1959","instance":1959,"id":238646,"goal":"predicate AllMem_1959(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_1960","instance":1960,"id":238647,"goal":"predicate DisjointSets_1960(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_1961","instance":1961,"id":238648,"goal":"predicate Sorted_1961(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_1962","instance":1962,"id":238649,"goal":"predicate AllPositive_1962(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_1963","instance":1963,"id":238650,"goal":"predicate DistinctSeq_1963(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_1964","instance":1964,"id":238651,"goal":"predicate IsSubseq_1964(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_1965","instance":1965,"id":238652,"goal":"predicate IsPermutation_1965(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_1966","instance":1966,"id":238653,"goal":"predicate IsEven_1966(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_1967","instance":1967,"id":238654,"goal":"predicate InRange_1967(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_1968","instance":1968,"id":238655,"goal":"predicate SubsetOf_1968(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_1969","instance":1969,"id":238656,"goal":"predicate AllMem_1969(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_1970","instance":1970,"id":238657,"goal":"predicate DisjointSets_1970(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_1971","instance":1971,"id":238658,"goal":"predicate Sorted_1971(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_1972","instance":1972,"id":238659,"goal":"predicate AllPositive_1972(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_1973","instance":1973,"id":238660,"goal":"predicate DistinctSeq_1973(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_1974","instance":1974,"id":238661,"goal":"predicate IsSubseq_1974(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_1975","instance":1975,"id":238662,"goal":"predicate IsPermutation_1975(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_1976","instance":1976,"id":238663,"goal":"predicate IsEven_1976(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_1977","instance":1977,"id":238664,"goal":"predicate InRange_1977(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_1978","instance":1978,"id":238665,"goal":"predicate SubsetOf_1978(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_1979","instance":1979,"id":238666,"goal":"predicate AllMem_1979(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_1980","instance":1980,"id":238667,"goal":"predicate DisjointSets_1980(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_1981","instance":1981,"id":238668,"goal":"predicate Sorted_1981(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_1982","instance":1982,"id":238669,"goal":"predicate AllPositive_1982(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_1983","instance":1983,"id":238670,"goal":"predicate DistinctSeq_1983(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_1984","instance":1984,"id":238671,"goal":"predicate IsSubseq_1984(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_1985","instance":1985,"id":238672,"goal":"predicate IsPermutation_1985(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_1986","instance":1986,"id":238673,"goal":"predicate IsEven_1986(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_1987","instance":1987,"id":238674,"goal":"predicate InRange_1987(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_1988","instance":1988,"id":238675,"goal":"predicate SubsetOf_1988(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_1989","instance":1989,"id":238676,"goal":"predicate AllMem_1989(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_1990","instance":1990,"id":238677,"goal":"predicate DisjointSets_1990(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_1991","instance":1991,"id":238678,"goal":"predicate Sorted_1991(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_1992","instance":1992,"id":238679,"goal":"predicate AllPositive_1992(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_1993","instance":1993,"id":238680,"goal":"predicate DistinctSeq_1993(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_1994","instance":1994,"id":238681,"goal":"predicate IsSubseq_1994(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_1995","instance":1995,"id":238682,"goal":"predicate IsPermutation_1995(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_1996","instance":1996,"id":238683,"goal":"predicate IsEven_1996(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_1997","instance":1997,"id":238684,"goal":"predicate InRange_1997(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_1998","instance":1998,"id":238685,"goal":"predicate SubsetOf_1998(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_1999","instance":1999,"id":238686,"goal":"predicate AllMem_1999(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_2000","instance":2000,"id":238687,"goal":"predicate DisjointSets_2000(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_2001","instance":2001,"id":238688,"goal":"predicate Sorted_2001(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_2002","instance":2002,"id":238689,"goal":"predicate AllPositive_2002(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_2003","instance":2003,"id":238690,"goal":"predicate DistinctSeq_2003(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_2004","instance":2004,"id":238691,"goal":"predicate IsSubseq_2004(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_2005","instance":2005,"id":238692,"goal":"predicate IsPermutation_2005(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_2006","instance":2006,"id":238693,"goal":"predicate IsEven_2006(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_2007","instance":2007,"id":238694,"goal":"predicate InRange_2007(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_2008","instance":2008,"id":238695,"goal":"predicate SubsetOf_2008(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_2009","instance":2009,"id":238696,"goal":"predicate AllMem_2009(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_2010","instance":2010,"id":238697,"goal":"predicate DisjointSets_2010(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_2011","instance":2011,"id":238698,"goal":"predicate Sorted_2011(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_2012","instance":2012,"id":238699,"goal":"predicate AllPositive_2012(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_2013","instance":2013,"id":238700,"goal":"predicate DistinctSeq_2013(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_2014","instance":2014,"id":238701,"goal":"predicate IsSubseq_2014(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_2015","instance":2015,"id":238702,"goal":"predicate IsPermutation_2015(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_2016","instance":2016,"id":238703,"goal":"predicate IsEven_2016(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_2017","instance":2017,"id":238704,"goal":"predicate InRange_2017(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_2018","instance":2018,"id":238705,"goal":"predicate SubsetOf_2018(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_2019","instance":2019,"id":238706,"goal":"predicate AllMem_2019(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_2020","instance":2020,"id":238707,"goal":"predicate DisjointSets_2020(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_2021","instance":2021,"id":238708,"goal":"predicate Sorted_2021(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_2022","instance":2022,"id":238709,"goal":"predicate AllPositive_2022(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_2023","instance":2023,"id":238710,"goal":"predicate DistinctSeq_2023(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_2024","instance":2024,"id":238711,"goal":"predicate IsSubseq_2024(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_2025","instance":2025,"id":238712,"goal":"predicate IsPermutation_2025(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_2026","instance":2026,"id":238713,"goal":"predicate IsEven_2026(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_2027","instance":2027,"id":238714,"goal":"predicate InRange_2027(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_2028","instance":2028,"id":238715,"goal":"predicate SubsetOf_2028(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_2029","instance":2029,"id":238716,"goal":"predicate AllMem_2029(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_2030","instance":2030,"id":238717,"goal":"predicate DisjointSets_2030(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_2031","instance":2031,"id":238718,"goal":"predicate Sorted_2031(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_2032","instance":2032,"id":238719,"goal":"predicate AllPositive_2032(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_2033","instance":2033,"id":238720,"goal":"predicate DistinctSeq_2033(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_2034","instance":2034,"id":238721,"goal":"predicate IsSubseq_2034(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_2035","instance":2035,"id":238722,"goal":"predicate IsPermutation_2035(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_2036","instance":2036,"id":238723,"goal":"predicate IsEven_2036(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_2037","instance":2037,"id":238724,"goal":"predicate InRange_2037(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_2038","instance":2038,"id":238725,"goal":"predicate SubsetOf_2038(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_2039","instance":2039,"id":238726,"goal":"predicate AllMem_2039(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_2040","instance":2040,"id":238727,"goal":"predicate DisjointSets_2040(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_2041","instance":2041,"id":238728,"goal":"predicate Sorted_2041(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_2042","instance":2042,"id":238729,"goal":"predicate AllPositive_2042(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_2043","instance":2043,"id":238730,"goal":"predicate DistinctSeq_2043(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_2044","instance":2044,"id":238731,"goal":"predicate IsSubseq_2044(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_2045","instance":2045,"id":238732,"goal":"predicate IsPermutation_2045(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_2046","instance":2046,"id":238733,"goal":"predicate IsEven_2046(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_2047","instance":2047,"id":238734,"goal":"predicate InRange_2047(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_2048","instance":2048,"id":238735,"goal":"predicate SubsetOf_2048(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_2049","instance":2049,"id":238736,"goal":"predicate AllMem_2049(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_2050","instance":2050,"id":238737,"goal":"predicate DisjointSets_2050(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_2051","instance":2051,"id":238738,"goal":"predicate Sorted_2051(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_2052","instance":2052,"id":238739,"goal":"predicate AllPositive_2052(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_2053","instance":2053,"id":238740,"goal":"predicate DistinctSeq_2053(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_2054","instance":2054,"id":238741,"goal":"predicate IsSubseq_2054(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_2055","instance":2055,"id":238742,"goal":"predicate IsPermutation_2055(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_2056","instance":2056,"id":238743,"goal":"predicate IsEven_2056(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_2057","instance":2057,"id":238744,"goal":"predicate InRange_2057(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_2058","instance":2058,"id":238745,"goal":"predicate SubsetOf_2058(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_2059","instance":2059,"id":238746,"goal":"predicate AllMem_2059(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_2060","instance":2060,"id":238747,"goal":"predicate DisjointSets_2060(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_2061","instance":2061,"id":238748,"goal":"predicate Sorted_2061(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_2062","instance":2062,"id":238749,"goal":"predicate AllPositive_2062(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_2063","instance":2063,"id":238750,"goal":"predicate DistinctSeq_2063(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_2064","instance":2064,"id":238751,"goal":"predicate IsSubseq_2064(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_2065","instance":2065,"id":238752,"goal":"predicate IsPermutation_2065(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_2066","instance":2066,"id":238753,"goal":"predicate IsEven_2066(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_2067","instance":2067,"id":238754,"goal":"predicate InRange_2067(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_2068","instance":2068,"id":238755,"goal":"predicate SubsetOf_2068(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_2069","instance":2069,"id":238756,"goal":"predicate AllMem_2069(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_2070","instance":2070,"id":238757,"goal":"predicate DisjointSets_2070(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_2071","instance":2071,"id":238758,"goal":"predicate Sorted_2071(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_2072","instance":2072,"id":238759,"goal":"predicate AllPositive_2072(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_2073","instance":2073,"id":238760,"goal":"predicate DistinctSeq_2073(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_2074","instance":2074,"id":238761,"goal":"predicate IsSubseq_2074(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_2075","instance":2075,"id":238762,"goal":"predicate IsPermutation_2075(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_2076","instance":2076,"id":238763,"goal":"predicate IsEven_2076(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_2077","instance":2077,"id":238764,"goal":"predicate InRange_2077(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_2078","instance":2078,"id":238765,"goal":"predicate SubsetOf_2078(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_2079","instance":2079,"id":238766,"goal":"predicate AllMem_2079(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_2080","instance":2080,"id":238767,"goal":"predicate DisjointSets_2080(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_2081","instance":2081,"id":238768,"goal":"predicate Sorted_2081(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_2082","instance":2082,"id":238769,"goal":"predicate AllPositive_2082(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_2083","instance":2083,"id":238770,"goal":"predicate DistinctSeq_2083(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_2084","instance":2084,"id":238771,"goal":"predicate IsSubseq_2084(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_2085","instance":2085,"id":238772,"goal":"predicate IsPermutation_2085(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_2086","instance":2086,"id":238773,"goal":"predicate IsEven_2086(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_2087","instance":2087,"id":238774,"goal":"predicate InRange_2087(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_2088","instance":2088,"id":238775,"goal":"predicate SubsetOf_2088(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_2089","instance":2089,"id":238776,"goal":"predicate AllMem_2089(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_2090","instance":2090,"id":238777,"goal":"predicate DisjointSets_2090(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_2091","instance":2091,"id":238778,"goal":"predicate Sorted_2091(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_2092","instance":2092,"id":238779,"goal":"predicate AllPositive_2092(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_2093","instance":2093,"id":238780,"goal":"predicate DistinctSeq_2093(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_2094","instance":2094,"id":238781,"goal":"predicate IsSubseq_2094(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_2095","instance":2095,"id":238782,"goal":"predicate IsPermutation_2095(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_2096","instance":2096,"id":238783,"goal":"predicate IsEven_2096(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_2097","instance":2097,"id":238784,"goal":"predicate InRange_2097(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_2098","instance":2098,"id":238785,"goal":"predicate SubsetOf_2098(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_2099","instance":2099,"id":238786,"goal":"predicate AllMem_2099(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_2100","instance":2100,"id":238787,"goal":"predicate DisjointSets_2100(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_2101","instance":2101,"id":238788,"goal":"predicate Sorted_2101(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_2102","instance":2102,"id":238789,"goal":"predicate AllPositive_2102(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_2103","instance":2103,"id":238790,"goal":"predicate DistinctSeq_2103(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_2104","instance":2104,"id":238791,"goal":"predicate IsSubseq_2104(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_2105","instance":2105,"id":238792,"goal":"predicate IsPermutation_2105(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_2106","instance":2106,"id":238793,"goal":"predicate IsEven_2106(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_2107","instance":2107,"id":238794,"goal":"predicate InRange_2107(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_2108","instance":2108,"id":238795,"goal":"predicate SubsetOf_2108(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_2109","instance":2109,"id":238796,"goal":"predicate AllMem_2109(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_2110","instance":2110,"id":238797,"goal":"predicate DisjointSets_2110(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_2111","instance":2111,"id":238798,"goal":"predicate Sorted_2111(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_2112","instance":2112,"id":238799,"goal":"predicate AllPositive_2112(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_2113","instance":2113,"id":238800,"goal":"predicate DistinctSeq_2113(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_2114","instance":2114,"id":238801,"goal":"predicate IsSubseq_2114(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_2115","instance":2115,"id":238802,"goal":"predicate IsPermutation_2115(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_2116","instance":2116,"id":238803,"goal":"predicate IsEven_2116(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_2117","instance":2117,"id":238804,"goal":"predicate InRange_2117(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_2118","instance":2118,"id":238805,"goal":"predicate SubsetOf_2118(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_2119","instance":2119,"id":238806,"goal":"predicate AllMem_2119(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_2120","instance":2120,"id":238807,"goal":"predicate DisjointSets_2120(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_2121","instance":2121,"id":238808,"goal":"predicate Sorted_2121(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_2122","instance":2122,"id":238809,"goal":"predicate AllPositive_2122(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_2123","instance":2123,"id":238810,"goal":"predicate DistinctSeq_2123(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_2124","instance":2124,"id":238811,"goal":"predicate IsSubseq_2124(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_2125","instance":2125,"id":238812,"goal":"predicate IsPermutation_2125(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_2126","instance":2126,"id":238813,"goal":"predicate IsEven_2126(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_2127","instance":2127,"id":238814,"goal":"predicate InRange_2127(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_2128","instance":2128,"id":238815,"goal":"predicate SubsetOf_2128(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_2129","instance":2129,"id":238816,"goal":"predicate AllMem_2129(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_2130","instance":2130,"id":238817,"goal":"predicate DisjointSets_2130(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_2131","instance":2131,"id":238818,"goal":"predicate Sorted_2131(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_2132","instance":2132,"id":238819,"goal":"predicate AllPositive_2132(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_2133","instance":2133,"id":238820,"goal":"predicate DistinctSeq_2133(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_2134","instance":2134,"id":238821,"goal":"predicate IsSubseq_2134(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_2135","instance":2135,"id":238822,"goal":"predicate IsPermutation_2135(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_2136","instance":2136,"id":238823,"goal":"predicate IsEven_2136(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_2137","instance":2137,"id":238824,"goal":"predicate InRange_2137(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_2138","instance":2138,"id":238825,"goal":"predicate SubsetOf_2138(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_2139","instance":2139,"id":238826,"goal":"predicate AllMem_2139(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_2140","instance":2140,"id":238827,"goal":"predicate DisjointSets_2140(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_2141","instance":2141,"id":238828,"goal":"predicate Sorted_2141(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_2142","instance":2142,"id":238829,"goal":"predicate AllPositive_2142(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_2143","instance":2143,"id":238830,"goal":"predicate DistinctSeq_2143(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_2144","instance":2144,"id":238831,"goal":"predicate IsSubseq_2144(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_2145","instance":2145,"id":238832,"goal":"predicate IsPermutation_2145(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_2146","instance":2146,"id":238833,"goal":"predicate IsEven_2146(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_2147","instance":2147,"id":238834,"goal":"predicate InRange_2147(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_2148","instance":2148,"id":238835,"goal":"predicate SubsetOf_2148(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_2149","instance":2149,"id":238836,"goal":"predicate AllMem_2149(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_2150","instance":2150,"id":238837,"goal":"predicate DisjointSets_2150(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_2151","instance":2151,"id":238838,"goal":"predicate Sorted_2151(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_2152","instance":2152,"id":238839,"goal":"predicate AllPositive_2152(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_2153","instance":2153,"id":238840,"goal":"predicate DistinctSeq_2153(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_2154","instance":2154,"id":238841,"goal":"predicate IsSubseq_2154(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_2155","instance":2155,"id":238842,"goal":"predicate IsPermutation_2155(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_2156","instance":2156,"id":238843,"goal":"predicate IsEven_2156(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_2157","instance":2157,"id":238844,"goal":"predicate InRange_2157(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_2158","instance":2158,"id":238845,"goal":"predicate SubsetOf_2158(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_2159","instance":2159,"id":238846,"goal":"predicate AllMem_2159(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_2160","instance":2160,"id":238847,"goal":"predicate DisjointSets_2160(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_2161","instance":2161,"id":238848,"goal":"predicate Sorted_2161(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_2162","instance":2162,"id":238849,"goal":"predicate AllPositive_2162(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_2163","instance":2163,"id":238850,"goal":"predicate DistinctSeq_2163(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_2164","instance":2164,"id":238851,"goal":"predicate IsSubseq_2164(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_2165","instance":2165,"id":238852,"goal":"predicate IsPermutation_2165(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_2166","instance":2166,"id":238853,"goal":"predicate IsEven_2166(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_2167","instance":2167,"id":238854,"goal":"predicate InRange_2167(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_2168","instance":2168,"id":238855,"goal":"predicate SubsetOf_2168(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_2169","instance":2169,"id":238856,"goal":"predicate AllMem_2169(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_2170","instance":2170,"id":238857,"goal":"predicate DisjointSets_2170(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_2171","instance":2171,"id":238858,"goal":"predicate Sorted_2171(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_2172","instance":2172,"id":238859,"goal":"predicate AllPositive_2172(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_2173","instance":2173,"id":238860,"goal":"predicate DistinctSeq_2173(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_2174","instance":2174,"id":238861,"goal":"predicate IsSubseq_2174(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_2175","instance":2175,"id":238862,"goal":"predicate IsPermutation_2175(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_2176","instance":2176,"id":238863,"goal":"predicate IsEven_2176(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_2177","instance":2177,"id":238864,"goal":"predicate InRange_2177(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_2178","instance":2178,"id":238865,"goal":"predicate SubsetOf_2178(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_2179","instance":2179,"id":238866,"goal":"predicate AllMem_2179(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_2180","instance":2180,"id":238867,"goal":"predicate DisjointSets_2180(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_2181","instance":2181,"id":238868,"goal":"predicate Sorted_2181(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_2182","instance":2182,"id":238869,"goal":"predicate AllPositive_2182(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_2183","instance":2183,"id":238870,"goal":"predicate DistinctSeq_2183(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_2184","instance":2184,"id":238871,"goal":"predicate IsSubseq_2184(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_2185","instance":2185,"id":238872,"goal":"predicate IsPermutation_2185(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_2186","instance":2186,"id":238873,"goal":"predicate IsEven_2186(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_2187","instance":2187,"id":238874,"goal":"predicate InRange_2187(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_2188","instance":2188,"id":238875,"goal":"predicate SubsetOf_2188(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_2189","instance":2189,"id":238876,"goal":"predicate AllMem_2189(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_2190","instance":2190,"id":238877,"goal":"predicate DisjointSets_2190(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_2191","instance":2191,"id":238878,"goal":"predicate Sorted_2191(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_2192","instance":2192,"id":238879,"goal":"predicate AllPositive_2192(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_2193","instance":2193,"id":238880,"goal":"predicate DistinctSeq_2193(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_2194","instance":2194,"id":238881,"goal":"predicate IsSubseq_2194(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_2195","instance":2195,"id":238882,"goal":"predicate IsPermutation_2195(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_2196","instance":2196,"id":238883,"goal":"predicate IsEven_2196(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_2197","instance":2197,"id":238884,"goal":"predicate InRange_2197(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_2198","instance":2198,"id":238885,"goal":"predicate SubsetOf_2198(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_2199","instance":2199,"id":238886,"goal":"predicate AllMem_2199(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_2200","instance":2200,"id":238887,"goal":"predicate DisjointSets_2200(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_2201","instance":2201,"id":238888,"goal":"predicate Sorted_2201(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_2202","instance":2202,"id":238889,"goal":"predicate AllPositive_2202(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_2203","instance":2203,"id":238890,"goal":"predicate DistinctSeq_2203(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_2204","instance":2204,"id":238891,"goal":"predicate IsSubseq_2204(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_2205","instance":2205,"id":238892,"goal":"predicate IsPermutation_2205(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_2206","instance":2206,"id":238893,"goal":"predicate IsEven_2206(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_2207","instance":2207,"id":238894,"goal":"predicate InRange_2207(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_2208","instance":2208,"id":238895,"goal":"predicate SubsetOf_2208(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_2209","instance":2209,"id":238896,"goal":"predicate AllMem_2209(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_2210","instance":2210,"id":238897,"goal":"predicate DisjointSets_2210(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_2211","instance":2211,"id":238898,"goal":"predicate Sorted_2211(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_2212","instance":2212,"id":238899,"goal":"predicate AllPositive_2212(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_2213","instance":2213,"id":238900,"goal":"predicate DistinctSeq_2213(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_2214","instance":2214,"id":238901,"goal":"predicate IsSubseq_2214(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_2215","instance":2215,"id":238902,"goal":"predicate IsPermutation_2215(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_2216","instance":2216,"id":238903,"goal":"predicate IsEven_2216(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_2217","instance":2217,"id":238904,"goal":"predicate InRange_2217(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_2218","instance":2218,"id":238905,"goal":"predicate SubsetOf_2218(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_2219","instance":2219,"id":238906,"goal":"predicate AllMem_2219(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_2220","instance":2220,"id":238907,"goal":"predicate DisjointSets_2220(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_2221","instance":2221,"id":238908,"goal":"predicate Sorted_2221(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_2222","instance":2222,"id":238909,"goal":"predicate AllPositive_2222(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_2223","instance":2223,"id":238910,"goal":"predicate DistinctSeq_2223(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_2224","instance":2224,"id":238911,"goal":"predicate IsSubseq_2224(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_2225","instance":2225,"id":238912,"goal":"predicate IsPermutation_2225(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_2226","instance":2226,"id":238913,"goal":"predicate IsEven_2226(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_2227","instance":2227,"id":238914,"goal":"predicate InRange_2227(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_2228","instance":2228,"id":238915,"goal":"predicate SubsetOf_2228(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_2229","instance":2229,"id":238916,"goal":"predicate AllMem_2229(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_2230","instance":2230,"id":238917,"goal":"predicate DisjointSets_2230(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_2231","instance":2231,"id":238918,"goal":"predicate Sorted_2231(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_2232","instance":2232,"id":238919,"goal":"predicate AllPositive_2232(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_2233","instance":2233,"id":238920,"goal":"predicate DistinctSeq_2233(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_2234","instance":2234,"id":238921,"goal":"predicate IsSubseq_2234(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_2235","instance":2235,"id":238922,"goal":"predicate IsPermutation_2235(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_2236","instance":2236,"id":238923,"goal":"predicate IsEven_2236(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_2237","instance":2237,"id":238924,"goal":"predicate InRange_2237(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_2238","instance":2238,"id":238925,"goal":"predicate SubsetOf_2238(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_2239","instance":2239,"id":238926,"goal":"predicate AllMem_2239(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_2240","instance":2240,"id":238927,"goal":"predicate DisjointSets_2240(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_2241","instance":2241,"id":238928,"goal":"predicate Sorted_2241(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_2242","instance":2242,"id":238929,"goal":"predicate AllPositive_2242(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_2243","instance":2243,"id":238930,"goal":"predicate DistinctSeq_2243(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_2244","instance":2244,"id":238931,"goal":"predicate IsSubseq_2244(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_2245","instance":2245,"id":238932,"goal":"predicate IsPermutation_2245(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_2246","instance":2246,"id":238933,"goal":"predicate IsEven_2246(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_2247","instance":2247,"id":238934,"goal":"predicate InRange_2247(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_2248","instance":2248,"id":238935,"goal":"predicate SubsetOf_2248(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_2249","instance":2249,"id":238936,"goal":"predicate AllMem_2249(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_2250","instance":2250,"id":238937,"goal":"predicate DisjointSets_2250(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_2251","instance":2251,"id":238938,"goal":"predicate Sorted_2251(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_2252","instance":2252,"id":238939,"goal":"predicate AllPositive_2252(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_2253","instance":2253,"id":238940,"goal":"predicate DistinctSeq_2253(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_2254","instance":2254,"id":238941,"goal":"predicate IsSubseq_2254(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_2255","instance":2255,"id":238942,"goal":"predicate IsPermutation_2255(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_2256","instance":2256,"id":238943,"goal":"predicate IsEven_2256(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_2257","instance":2257,"id":238944,"goal":"predicate InRange_2257(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_2258","instance":2258,"id":238945,"goal":"predicate SubsetOf_2258(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_2259","instance":2259,"id":238946,"goal":"predicate AllMem_2259(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_2260","instance":2260,"id":238947,"goal":"predicate DisjointSets_2260(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_2261","instance":2261,"id":238948,"goal":"predicate Sorted_2261(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_2262","instance":2262,"id":238949,"goal":"predicate AllPositive_2262(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_2263","instance":2263,"id":238950,"goal":"predicate DistinctSeq_2263(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_2264","instance":2264,"id":238951,"goal":"predicate IsSubseq_2264(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_2265","instance":2265,"id":238952,"goal":"predicate IsPermutation_2265(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_2266","instance":2266,"id":238953,"goal":"predicate IsEven_2266(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_2267","instance":2267,"id":238954,"goal":"predicate InRange_2267(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_2268","instance":2268,"id":238955,"goal":"predicate SubsetOf_2268(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_2269","instance":2269,"id":238956,"goal":"predicate AllMem_2269(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_2270","instance":2270,"id":238957,"goal":"predicate DisjointSets_2270(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_2271","instance":2271,"id":238958,"goal":"predicate Sorted_2271(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_2272","instance":2272,"id":238959,"goal":"predicate AllPositive_2272(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_2273","instance":2273,"id":238960,"goal":"predicate DistinctSeq_2273(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_2274","instance":2274,"id":238961,"goal":"predicate IsSubseq_2274(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_2275","instance":2275,"id":238962,"goal":"predicate IsPermutation_2275(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_2276","instance":2276,"id":238963,"goal":"predicate IsEven_2276(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_2277","instance":2277,"id":238964,"goal":"predicate InRange_2277(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_2278","instance":2278,"id":238965,"goal":"predicate SubsetOf_2278(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_2279","instance":2279,"id":238966,"goal":"predicate AllMem_2279(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_2280","instance":2280,"id":238967,"goal":"predicate DisjointSets_2280(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_2281","instance":2281,"id":238968,"goal":"predicate Sorted_2281(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_2282","instance":2282,"id":238969,"goal":"predicate AllPositive_2282(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_2283","instance":2283,"id":238970,"goal":"predicate DistinctSeq_2283(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_2284","instance":2284,"id":238971,"goal":"predicate IsSubseq_2284(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_2285","instance":2285,"id":238972,"goal":"predicate IsPermutation_2285(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_2286","instance":2286,"id":238973,"goal":"predicate IsEven_2286(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_2287","instance":2287,"id":238974,"goal":"predicate InRange_2287(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_2288","instance":2288,"id":238975,"goal":"predicate SubsetOf_2288(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_2289","instance":2289,"id":238976,"goal":"predicate AllMem_2289(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_2290","instance":2290,"id":238977,"goal":"predicate DisjointSets_2290(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_2291","instance":2291,"id":238978,"goal":"predicate Sorted_2291(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_2292","instance":2292,"id":238979,"goal":"predicate AllPositive_2292(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_2293","instance":2293,"id":238980,"goal":"predicate DistinctSeq_2293(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_2294","instance":2294,"id":238981,"goal":"predicate IsSubseq_2294(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_2295","instance":2295,"id":238982,"goal":"predicate IsPermutation_2295(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_2296","instance":2296,"id":238983,"goal":"predicate IsEven_2296(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_2297","instance":2297,"id":238984,"goal":"predicate InRange_2297(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_2298","instance":2298,"id":238985,"goal":"predicate SubsetOf_2298(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_2299","instance":2299,"id":238986,"goal":"predicate AllMem_2299(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_2300","instance":2300,"id":238987,"goal":"predicate DisjointSets_2300(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_2301","instance":2301,"id":238988,"goal":"predicate Sorted_2301(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_2302","instance":2302,"id":238989,"goal":"predicate AllPositive_2302(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_2303","instance":2303,"id":238990,"goal":"predicate DistinctSeq_2303(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_2304","instance":2304,"id":238991,"goal":"predicate IsSubseq_2304(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_2305","instance":2305,"id":238992,"goal":"predicate IsPermutation_2305(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_2306","instance":2306,"id":238993,"goal":"predicate IsEven_2306(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_2307","instance":2307,"id":238994,"goal":"predicate InRange_2307(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_2308","instance":2308,"id":238995,"goal":"predicate SubsetOf_2308(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_2309","instance":2309,"id":238996,"goal":"predicate AllMem_2309(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_2310","instance":2310,"id":238997,"goal":"predicate DisjointSets_2310(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_2311","instance":2311,"id":238998,"goal":"predicate Sorted_2311(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_2312","instance":2312,"id":238999,"goal":"predicate AllPositive_2312(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_2313","instance":2313,"id":239000,"goal":"predicate DistinctSeq_2313(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_2314","instance":2314,"id":239001,"goal":"predicate IsSubseq_2314(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_2315","instance":2315,"id":239002,"goal":"predicate IsPermutation_2315(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_2316","instance":2316,"id":239003,"goal":"predicate IsEven_2316(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_2317","instance":2317,"id":239004,"goal":"predicate InRange_2317(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_2318","instance":2318,"id":239005,"goal":"predicate SubsetOf_2318(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_2319","instance":2319,"id":239006,"goal":"predicate AllMem_2319(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_2320","instance":2320,"id":239007,"goal":"predicate DisjointSets_2320(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_2321","instance":2321,"id":239008,"goal":"predicate Sorted_2321(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_2322","instance":2322,"id":239009,"goal":"predicate AllPositive_2322(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_2323","instance":2323,"id":239010,"goal":"predicate DistinctSeq_2323(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_2324","instance":2324,"id":239011,"goal":"predicate IsSubseq_2324(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_2325","instance":2325,"id":239012,"goal":"predicate IsPermutation_2325(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_2326","instance":2326,"id":239013,"goal":"predicate IsEven_2326(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_2327","instance":2327,"id":239014,"goal":"predicate InRange_2327(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_2328","instance":2328,"id":239015,"goal":"predicate SubsetOf_2328(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_2329","instance":2329,"id":239016,"goal":"predicate AllMem_2329(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_2330","instance":2330,"id":239017,"goal":"predicate DisjointSets_2330(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_2331","instance":2331,"id":239018,"goal":"predicate Sorted_2331(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_2332","instance":2332,"id":239019,"goal":"predicate AllPositive_2332(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_2333","instance":2333,"id":239020,"goal":"predicate DistinctSeq_2333(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_2334","instance":2334,"id":239021,"goal":"predicate IsSubseq_2334(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_2335","instance":2335,"id":239022,"goal":"predicate IsPermutation_2335(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_2336","instance":2336,"id":239023,"goal":"predicate IsEven_2336(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_2337","instance":2337,"id":239024,"goal":"predicate InRange_2337(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_2338","instance":2338,"id":239025,"goal":"predicate SubsetOf_2338(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_2339","instance":2339,"id":239026,"goal":"predicate AllMem_2339(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_2340","instance":2340,"id":239027,"goal":"predicate DisjointSets_2340(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_2341","instance":2341,"id":239028,"goal":"predicate Sorted_2341(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_2342","instance":2342,"id":239029,"goal":"predicate AllPositive_2342(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_2343","instance":2343,"id":239030,"goal":"predicate DistinctSeq_2343(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_2344","instance":2344,"id":239031,"goal":"predicate IsSubseq_2344(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_2345","instance":2345,"id":239032,"goal":"predicate IsPermutation_2345(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_2346","instance":2346,"id":239033,"goal":"predicate IsEven_2346(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_2347","instance":2347,"id":239034,"goal":"predicate InRange_2347(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_2348","instance":2348,"id":239035,"goal":"predicate SubsetOf_2348(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_2349","instance":2349,"id":239036,"goal":"predicate AllMem_2349(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_2350","instance":2350,"id":239037,"goal":"predicate DisjointSets_2350(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_2351","instance":2351,"id":239038,"goal":"predicate Sorted_2351(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_2352","instance":2352,"id":239039,"goal":"predicate AllPositive_2352(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_2353","instance":2353,"id":239040,"goal":"predicate DistinctSeq_2353(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_2354","instance":2354,"id":239041,"goal":"predicate IsSubseq_2354(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_2355","instance":2355,"id":239042,"goal":"predicate IsPermutation_2355(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_2356","instance":2356,"id":239043,"goal":"predicate IsEven_2356(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_2357","instance":2357,"id":239044,"goal":"predicate InRange_2357(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_2358","instance":2358,"id":239045,"goal":"predicate SubsetOf_2358(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_2359","instance":2359,"id":239046,"goal":"predicate AllMem_2359(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_2360","instance":2360,"id":239047,"goal":"predicate DisjointSets_2360(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_2361","instance":2361,"id":239048,"goal":"predicate Sorted_2361(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_2362","instance":2362,"id":239049,"goal":"predicate AllPositive_2362(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_2363","instance":2363,"id":239050,"goal":"predicate DistinctSeq_2363(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_2364","instance":2364,"id":239051,"goal":"predicate IsSubseq_2364(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_2365","instance":2365,"id":239052,"goal":"predicate IsPermutation_2365(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_2366","instance":2366,"id":239053,"goal":"predicate IsEven_2366(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_2367","instance":2367,"id":239054,"goal":"predicate InRange_2367(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_2368","instance":2368,"id":239055,"goal":"predicate SubsetOf_2368(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_2369","instance":2369,"id":239056,"goal":"predicate AllMem_2369(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_2370","instance":2370,"id":239057,"goal":"predicate DisjointSets_2370(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_2371","instance":2371,"id":239058,"goal":"predicate Sorted_2371(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_2372","instance":2372,"id":239059,"goal":"predicate AllPositive_2372(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_2373","instance":2373,"id":239060,"goal":"predicate DistinctSeq_2373(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_2374","instance":2374,"id":239061,"goal":"predicate IsSubseq_2374(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_2375","instance":2375,"id":239062,"goal":"predicate IsPermutation_2375(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_2376","instance":2376,"id":239063,"goal":"predicate IsEven_2376(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_2377","instance":2377,"id":239064,"goal":"predicate InRange_2377(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_2378","instance":2378,"id":239065,"goal":"predicate SubsetOf_2378(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_2379","instance":2379,"id":239066,"goal":"predicate AllMem_2379(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_2380","instance":2380,"id":239067,"goal":"predicate DisjointSets_2380(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_2381","instance":2381,"id":239068,"goal":"predicate Sorted_2381(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_2382","instance":2382,"id":239069,"goal":"predicate AllPositive_2382(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_2383","instance":2383,"id":239070,"goal":"predicate DistinctSeq_2383(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_2384","instance":2384,"id":239071,"goal":"predicate IsSubseq_2384(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_2385","instance":2385,"id":239072,"goal":"predicate IsPermutation_2385(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_2386","instance":2386,"id":239073,"goal":"predicate IsEven_2386(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_2387","instance":2387,"id":239074,"goal":"predicate InRange_2387(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_2388","instance":2388,"id":239075,"goal":"predicate SubsetOf_2388(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_2389","instance":2389,"id":239076,"goal":"predicate AllMem_2389(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_2390","instance":2390,"id":239077,"goal":"predicate DisjointSets_2390(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_2391","instance":2391,"id":239078,"goal":"predicate Sorted_2391(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_2392","instance":2392,"id":239079,"goal":"predicate AllPositive_2392(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_2393","instance":2393,"id":239080,"goal":"predicate DistinctSeq_2393(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_2394","instance":2394,"id":239081,"goal":"predicate IsSubseq_2394(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_2395","instance":2395,"id":239082,"goal":"predicate IsPermutation_2395(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_2396","instance":2396,"id":239083,"goal":"predicate IsEven_2396(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_2397","instance":2397,"id":239084,"goal":"predicate InRange_2397(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_2398","instance":2398,"id":239085,"goal":"predicate SubsetOf_2398(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_2399","instance":2399,"id":239086,"goal":"predicate AllMem_2399(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_2400","instance":2400,"id":239087,"goal":"predicate DisjointSets_2400(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_2401","instance":2401,"id":239088,"goal":"predicate Sorted_2401(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_2402","instance":2402,"id":239089,"goal":"predicate AllPositive_2402(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_2403","instance":2403,"id":239090,"goal":"predicate DistinctSeq_2403(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_2404","instance":2404,"id":239091,"goal":"predicate IsSubseq_2404(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_2405","instance":2405,"id":239092,"goal":"predicate IsPermutation_2405(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_2406","instance":2406,"id":239093,"goal":"predicate IsEven_2406(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_2407","instance":2407,"id":239094,"goal":"predicate InRange_2407(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_2408","instance":2408,"id":239095,"goal":"predicate SubsetOf_2408(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_2409","instance":2409,"id":239096,"goal":"predicate AllMem_2409(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_2410","instance":2410,"id":239097,"goal":"predicate DisjointSets_2410(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_2411","instance":2411,"id":239098,"goal":"predicate Sorted_2411(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_2412","instance":2412,"id":239099,"goal":"predicate AllPositive_2412(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_2413","instance":2413,"id":239100,"goal":"predicate DistinctSeq_2413(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_2414","instance":2414,"id":239101,"goal":"predicate IsSubseq_2414(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_2415","instance":2415,"id":239102,"goal":"predicate IsPermutation_2415(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_2416","instance":2416,"id":239103,"goal":"predicate IsEven_2416(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_2417","instance":2417,"id":239104,"goal":"predicate InRange_2417(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_2418","instance":2418,"id":239105,"goal":"predicate SubsetOf_2418(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_2419","instance":2419,"id":239106,"goal":"predicate AllMem_2419(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_2420","instance":2420,"id":239107,"goal":"predicate DisjointSets_2420(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_2421","instance":2421,"id":239108,"goal":"predicate Sorted_2421(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_2422","instance":2422,"id":239109,"goal":"predicate AllPositive_2422(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_2423","instance":2423,"id":239110,"goal":"predicate DistinctSeq_2423(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_2424","instance":2424,"id":239111,"goal":"predicate IsSubseq_2424(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_2425","instance":2425,"id":239112,"goal":"predicate IsPermutation_2425(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_2426","instance":2426,"id":239113,"goal":"predicate IsEven_2426(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_2427","instance":2427,"id":239114,"goal":"predicate InRange_2427(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_2428","instance":2428,"id":239115,"goal":"predicate SubsetOf_2428(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_2429","instance":2429,"id":239116,"goal":"predicate AllMem_2429(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_2430","instance":2430,"id":239117,"goal":"predicate DisjointSets_2430(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_2431","instance":2431,"id":239118,"goal":"predicate Sorted_2431(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_2432","instance":2432,"id":239119,"goal":"predicate AllPositive_2432(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_2433","instance":2433,"id":239120,"goal":"predicate DistinctSeq_2433(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_2434","instance":2434,"id":239121,"goal":"predicate IsSubseq_2434(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_2435","instance":2435,"id":239122,"goal":"predicate IsPermutation_2435(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_2436","instance":2436,"id":239123,"goal":"predicate IsEven_2436(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_2437","instance":2437,"id":239124,"goal":"predicate InRange_2437(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_2438","instance":2438,"id":239125,"goal":"predicate SubsetOf_2438(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_2439","instance":2439,"id":239126,"goal":"predicate AllMem_2439(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_2440","instance":2440,"id":239127,"goal":"predicate DisjointSets_2440(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_2441","instance":2441,"id":239128,"goal":"predicate Sorted_2441(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_2442","instance":2442,"id":239129,"goal":"predicate AllPositive_2442(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_2443","instance":2443,"id":239130,"goal":"predicate DistinctSeq_2443(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_2444","instance":2444,"id":239131,"goal":"predicate IsSubseq_2444(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_2445","instance":2445,"id":239132,"goal":"predicate IsPermutation_2445(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_2446","instance":2446,"id":239133,"goal":"predicate IsEven_2446(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_2447","instance":2447,"id":239134,"goal":"predicate InRange_2447(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_2448","instance":2448,"id":239135,"goal":"predicate SubsetOf_2448(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_2449","instance":2449,"id":239136,"goal":"predicate AllMem_2449(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_2450","instance":2450,"id":239137,"goal":"predicate DisjointSets_2450(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_2451","instance":2451,"id":239138,"goal":"predicate Sorted_2451(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_2452","instance":2452,"id":239139,"goal":"predicate AllPositive_2452(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_2453","instance":2453,"id":239140,"goal":"predicate DistinctSeq_2453(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_2454","instance":2454,"id":239141,"goal":"predicate IsSubseq_2454(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_2455","instance":2455,"id":239142,"goal":"predicate IsPermutation_2455(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_2456","instance":2456,"id":239143,"goal":"predicate IsEven_2456(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_2457","instance":2457,"id":239144,"goal":"predicate InRange_2457(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_2458","instance":2458,"id":239145,"goal":"predicate SubsetOf_2458(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_2459","instance":2459,"id":239146,"goal":"predicate AllMem_2459(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_2460","instance":2460,"id":239147,"goal":"predicate DisjointSets_2460(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_2461","instance":2461,"id":239148,"goal":"predicate Sorted_2461(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_2462","instance":2462,"id":239149,"goal":"predicate AllPositive_2462(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_2463","instance":2463,"id":239150,"goal":"predicate DistinctSeq_2463(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_2464","instance":2464,"id":239151,"goal":"predicate IsSubseq_2464(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_2465","instance":2465,"id":239152,"goal":"predicate IsPermutation_2465(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_2466","instance":2466,"id":239153,"goal":"predicate IsEven_2466(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_2467","instance":2467,"id":239154,"goal":"predicate InRange_2467(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_2468","instance":2468,"id":239155,"goal":"predicate SubsetOf_2468(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_2469","instance":2469,"id":239156,"goal":"predicate AllMem_2469(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_2470","instance":2470,"id":239157,"goal":"predicate DisjointSets_2470(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_2471","instance":2471,"id":239158,"goal":"predicate Sorted_2471(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_2472","instance":2472,"id":239159,"goal":"predicate AllPositive_2472(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_2473","instance":2473,"id":239160,"goal":"predicate DistinctSeq_2473(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_2474","instance":2474,"id":239161,"goal":"predicate IsSubseq_2474(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_2475","instance":2475,"id":239162,"goal":"predicate IsPermutation_2475(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_2476","instance":2476,"id":239163,"goal":"predicate IsEven_2476(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_2477","instance":2477,"id":239164,"goal":"predicate InRange_2477(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_2478","instance":2478,"id":239165,"goal":"predicate SubsetOf_2478(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_2479","instance":2479,"id":239166,"goal":"predicate AllMem_2479(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_2480","instance":2480,"id":239167,"goal":"predicate DisjointSets_2480(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_2481","instance":2481,"id":239168,"goal":"predicate Sorted_2481(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_2482","instance":2482,"id":239169,"goal":"predicate AllPositive_2482(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_2483","instance":2483,"id":239170,"goal":"predicate DistinctSeq_2483(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_2484","instance":2484,"id":239171,"goal":"predicate IsSubseq_2484(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_2485","instance":2485,"id":239172,"goal":"predicate IsPermutation_2485(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_2486","instance":2486,"id":239173,"goal":"predicate IsEven_2486(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_2487","instance":2487,"id":239174,"goal":"predicate InRange_2487(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_2488","instance":2488,"id":239175,"goal":"predicate SubsetOf_2488(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_2489","instance":2489,"id":239176,"goal":"predicate AllMem_2489(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_2490","instance":2490,"id":239177,"goal":"predicate DisjointSets_2490(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_2491","instance":2491,"id":239178,"goal":"predicate Sorted_2491(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_2492","instance":2492,"id":239179,"goal":"predicate AllPositive_2492(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_2493","instance":2493,"id":239180,"goal":"predicate DistinctSeq_2493(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_2494","instance":2494,"id":239181,"goal":"predicate IsSubseq_2494(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_2495","instance":2495,"id":239182,"goal":"predicate IsPermutation_2495(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_2496","instance":2496,"id":239183,"goal":"predicate IsEven_2496(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_2497","instance":2497,"id":239184,"goal":"predicate InRange_2497(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_2498","instance":2498,"id":239185,"goal":"predicate SubsetOf_2498(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_2499","instance":2499,"id":239186,"goal":"predicate AllMem_2499(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_2500","instance":2500,"id":239187,"goal":"predicate DisjointSets_2500(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_2501","instance":2501,"id":239188,"goal":"predicate Sorted_2501(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_2502","instance":2502,"id":239189,"goal":"predicate AllPositive_2502(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_2503","instance":2503,"id":239190,"goal":"predicate DistinctSeq_2503(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_2504","instance":2504,"id":239191,"goal":"predicate IsSubseq_2504(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_2505","instance":2505,"id":239192,"goal":"predicate IsPermutation_2505(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_2506","instance":2506,"id":239193,"goal":"predicate IsEven_2506(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_2507","instance":2507,"id":239194,"goal":"predicate InRange_2507(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_2508","instance":2508,"id":239195,"goal":"predicate SubsetOf_2508(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_2509","instance":2509,"id":239196,"goal":"predicate AllMem_2509(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_2510","instance":2510,"id":239197,"goal":"predicate DisjointSets_2510(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_2511","instance":2511,"id":239198,"goal":"predicate Sorted_2511(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_2512","instance":2512,"id":239199,"goal":"predicate AllPositive_2512(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_2513","instance":2513,"id":239200,"goal":"predicate DistinctSeq_2513(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_2514","instance":2514,"id":239201,"goal":"predicate IsSubseq_2514(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_2515","instance":2515,"id":239202,"goal":"predicate IsPermutation_2515(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_2516","instance":2516,"id":239203,"goal":"predicate IsEven_2516(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_2517","instance":2517,"id":239204,"goal":"predicate InRange_2517(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_2518","instance":2518,"id":239205,"goal":"predicate SubsetOf_2518(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_2519","instance":2519,"id":239206,"goal":"predicate AllMem_2519(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_2520","instance":2520,"id":239207,"goal":"predicate DisjointSets_2520(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_2521","instance":2521,"id":239208,"goal":"predicate Sorted_2521(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_2522","instance":2522,"id":239209,"goal":"predicate AllPositive_2522(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_2523","instance":2523,"id":239210,"goal":"predicate DistinctSeq_2523(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_2524","instance":2524,"id":239211,"goal":"predicate IsSubseq_2524(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_2525","instance":2525,"id":239212,"goal":"predicate IsPermutation_2525(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_2526","instance":2526,"id":239213,"goal":"predicate IsEven_2526(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_2527","instance":2527,"id":239214,"goal":"predicate InRange_2527(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_2528","instance":2528,"id":239215,"goal":"predicate SubsetOf_2528(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_2529","instance":2529,"id":239216,"goal":"predicate AllMem_2529(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_2530","instance":2530,"id":239217,"goal":"predicate DisjointSets_2530(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_2531","instance":2531,"id":239218,"goal":"predicate Sorted_2531(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_2532","instance":2532,"id":239219,"goal":"predicate AllPositive_2532(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_2533","instance":2533,"id":239220,"goal":"predicate DistinctSeq_2533(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_2534","instance":2534,"id":239221,"goal":"predicate IsSubseq_2534(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_2535","instance":2535,"id":239222,"goal":"predicate IsPermutation_2535(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_2536","instance":2536,"id":239223,"goal":"predicate IsEven_2536(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_2537","instance":2537,"id":239224,"goal":"predicate InRange_2537(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_2538","instance":2538,"id":239225,"goal":"predicate SubsetOf_2538(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_2539","instance":2539,"id":239226,"goal":"predicate AllMem_2539(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_2540","instance":2540,"id":239227,"goal":"predicate DisjointSets_2540(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_2541","instance":2541,"id":239228,"goal":"predicate Sorted_2541(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_2542","instance":2542,"id":239229,"goal":"predicate AllPositive_2542(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_2543","instance":2543,"id":239230,"goal":"predicate DistinctSeq_2543(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_2544","instance":2544,"id":239231,"goal":"predicate IsSubseq_2544(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_2545","instance":2545,"id":239232,"goal":"predicate IsPermutation_2545(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_2546","instance":2546,"id":239233,"goal":"predicate IsEven_2546(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_2547","instance":2547,"id":239234,"goal":"predicate InRange_2547(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_2548","instance":2548,"id":239235,"goal":"predicate SubsetOf_2548(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_2549","instance":2549,"id":239236,"goal":"predicate AllMem_2549(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_2550","instance":2550,"id":239237,"goal":"predicate DisjointSets_2550(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_2551","instance":2551,"id":239238,"goal":"predicate Sorted_2551(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_2552","instance":2552,"id":239239,"goal":"predicate AllPositive_2552(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_2553","instance":2553,"id":239240,"goal":"predicate DistinctSeq_2553(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_2554","instance":2554,"id":239241,"goal":"predicate IsSubseq_2554(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_2555","instance":2555,"id":239242,"goal":"predicate IsPermutation_2555(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_2556","instance":2556,"id":239243,"goal":"predicate IsEven_2556(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_2557","instance":2557,"id":239244,"goal":"predicate InRange_2557(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_2558","instance":2558,"id":239245,"goal":"predicate SubsetOf_2558(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_2559","instance":2559,"id":239246,"goal":"predicate AllMem_2559(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_2560","instance":2560,"id":239247,"goal":"predicate DisjointSets_2560(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_2561","instance":2561,"id":239248,"goal":"predicate Sorted_2561(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_2562","instance":2562,"id":239249,"goal":"predicate AllPositive_2562(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_2563","instance":2563,"id":239250,"goal":"predicate DistinctSeq_2563(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_2564","instance":2564,"id":239251,"goal":"predicate IsSubseq_2564(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_2565","instance":2565,"id":239252,"goal":"predicate IsPermutation_2565(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_2566","instance":2566,"id":239253,"goal":"predicate IsEven_2566(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_2567","instance":2567,"id":239254,"goal":"predicate InRange_2567(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_2568","instance":2568,"id":239255,"goal":"predicate SubsetOf_2568(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_2569","instance":2569,"id":239256,"goal":"predicate AllMem_2569(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_2570","instance":2570,"id":239257,"goal":"predicate DisjointSets_2570(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_2571","instance":2571,"id":239258,"goal":"predicate Sorted_2571(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_2572","instance":2572,"id":239259,"goal":"predicate AllPositive_2572(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_2573","instance":2573,"id":239260,"goal":"predicate DistinctSeq_2573(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_2574","instance":2574,"id":239261,"goal":"predicate IsSubseq_2574(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_2575","instance":2575,"id":239262,"goal":"predicate IsPermutation_2575(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_2576","instance":2576,"id":239263,"goal":"predicate IsEven_2576(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_2577","instance":2577,"id":239264,"goal":"predicate InRange_2577(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_2578","instance":2578,"id":239265,"goal":"predicate SubsetOf_2578(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_2579","instance":2579,"id":239266,"goal":"predicate AllMem_2579(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_2580","instance":2580,"id":239267,"goal":"predicate DisjointSets_2580(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_2581","instance":2581,"id":239268,"goal":"predicate Sorted_2581(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_2582","instance":2582,"id":239269,"goal":"predicate AllPositive_2582(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_2583","instance":2583,"id":239270,"goal":"predicate DistinctSeq_2583(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_2584","instance":2584,"id":239271,"goal":"predicate IsSubseq_2584(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_2585","instance":2585,"id":239272,"goal":"predicate IsPermutation_2585(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_2586","instance":2586,"id":239273,"goal":"predicate IsEven_2586(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_2587","instance":2587,"id":239274,"goal":"predicate InRange_2587(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_2588","instance":2588,"id":239275,"goal":"predicate SubsetOf_2588(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_2589","instance":2589,"id":239276,"goal":"predicate AllMem_2589(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_2590","instance":2590,"id":239277,"goal":"predicate DisjointSets_2590(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_2591","instance":2591,"id":239278,"goal":"predicate Sorted_2591(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_2592","instance":2592,"id":239279,"goal":"predicate AllPositive_2592(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_2593","instance":2593,"id":239280,"goal":"predicate DistinctSeq_2593(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_2594","instance":2594,"id":239281,"goal":"predicate IsSubseq_2594(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_2595","instance":2595,"id":239282,"goal":"predicate IsPermutation_2595(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_2596","instance":2596,"id":239283,"goal":"predicate IsEven_2596(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_2597","instance":2597,"id":239284,"goal":"predicate InRange_2597(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_2598","instance":2598,"id":239285,"goal":"predicate SubsetOf_2598(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_2599","instance":2599,"id":239286,"goal":"predicate AllMem_2599(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_2600","instance":2600,"id":239287,"goal":"predicate DisjointSets_2600(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_2601","instance":2601,"id":239288,"goal":"predicate Sorted_2601(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_2602","instance":2602,"id":239289,"goal":"predicate AllPositive_2602(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_2603","instance":2603,"id":239290,"goal":"predicate DistinctSeq_2603(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_2604","instance":2604,"id":239291,"goal":"predicate IsSubseq_2604(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_2605","instance":2605,"id":239292,"goal":"predicate IsPermutation_2605(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_2606","instance":2606,"id":239293,"goal":"predicate IsEven_2606(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_2607","instance":2607,"id":239294,"goal":"predicate InRange_2607(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_2608","instance":2608,"id":239295,"goal":"predicate SubsetOf_2608(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_2609","instance":2609,"id":239296,"goal":"predicate AllMem_2609(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_2610","instance":2610,"id":239297,"goal":"predicate DisjointSets_2610(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_2611","instance":2611,"id":239298,"goal":"predicate Sorted_2611(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_2612","instance":2612,"id":239299,"goal":"predicate AllPositive_2612(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_2613","instance":2613,"id":239300,"goal":"predicate DistinctSeq_2613(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_2614","instance":2614,"id":239301,"goal":"predicate IsSubseq_2614(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_2615","instance":2615,"id":239302,"goal":"predicate IsPermutation_2615(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_2616","instance":2616,"id":239303,"goal":"predicate IsEven_2616(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_2617","instance":2617,"id":239304,"goal":"predicate InRange_2617(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_2618","instance":2618,"id":239305,"goal":"predicate SubsetOf_2618(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_2619","instance":2619,"id":239306,"goal":"predicate AllMem_2619(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_2620","instance":2620,"id":239307,"goal":"predicate DisjointSets_2620(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_2621","instance":2621,"id":239308,"goal":"predicate Sorted_2621(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_2622","instance":2622,"id":239309,"goal":"predicate AllPositive_2622(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_2623","instance":2623,"id":239310,"goal":"predicate DistinctSeq_2623(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_2624","instance":2624,"id":239311,"goal":"predicate IsSubseq_2624(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_2625","instance":2625,"id":239312,"goal":"predicate IsPermutation_2625(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_2626","instance":2626,"id":239313,"goal":"predicate IsEven_2626(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_2627","instance":2627,"id":239314,"goal":"predicate InRange_2627(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_2628","instance":2628,"id":239315,"goal":"predicate SubsetOf_2628(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_2629","instance":2629,"id":239316,"goal":"predicate AllMem_2629(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_2630","instance":2630,"id":239317,"goal":"predicate DisjointSets_2630(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_2631","instance":2631,"id":239318,"goal":"predicate Sorted_2631(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_2632","instance":2632,"id":239319,"goal":"predicate AllPositive_2632(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_2633","instance":2633,"id":239320,"goal":"predicate DistinctSeq_2633(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_2634","instance":2634,"id":239321,"goal":"predicate IsSubseq_2634(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_2635","instance":2635,"id":239322,"goal":"predicate IsPermutation_2635(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_2636","instance":2636,"id":239323,"goal":"predicate IsEven_2636(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_2637","instance":2637,"id":239324,"goal":"predicate InRange_2637(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_2638","instance":2638,"id":239325,"goal":"predicate SubsetOf_2638(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_2639","instance":2639,"id":239326,"goal":"predicate AllMem_2639(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_2640","instance":2640,"id":239327,"goal":"predicate DisjointSets_2640(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_2641","instance":2641,"id":239328,"goal":"predicate Sorted_2641(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_2642","instance":2642,"id":239329,"goal":"predicate AllPositive_2642(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_2643","instance":2643,"id":239330,"goal":"predicate DistinctSeq_2643(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_2644","instance":2644,"id":239331,"goal":"predicate IsSubseq_2644(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_2645","instance":2645,"id":239332,"goal":"predicate IsPermutation_2645(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_2646","instance":2646,"id":239333,"goal":"predicate IsEven_2646(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_2647","instance":2647,"id":239334,"goal":"predicate InRange_2647(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_2648","instance":2648,"id":239335,"goal":"predicate SubsetOf_2648(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_2649","instance":2649,"id":239336,"goal":"predicate AllMem_2649(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_2650","instance":2650,"id":239337,"goal":"predicate DisjointSets_2650(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_2651","instance":2651,"id":239338,"goal":"predicate Sorted_2651(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_2652","instance":2652,"id":239339,"goal":"predicate AllPositive_2652(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_2653","instance":2653,"id":239340,"goal":"predicate DistinctSeq_2653(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_2654","instance":2654,"id":239341,"goal":"predicate IsSubseq_2654(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_2655","instance":2655,"id":239342,"goal":"predicate IsPermutation_2655(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_2656","instance":2656,"id":239343,"goal":"predicate IsEven_2656(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_2657","instance":2657,"id":239344,"goal":"predicate InRange_2657(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_2658","instance":2658,"id":239345,"goal":"predicate SubsetOf_2658(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_2659","instance":2659,"id":239346,"goal":"predicate AllMem_2659(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_2660","instance":2660,"id":239347,"goal":"predicate DisjointSets_2660(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_2661","instance":2661,"id":239348,"goal":"predicate Sorted_2661(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_2662","instance":2662,"id":239349,"goal":"predicate AllPositive_2662(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_2663","instance":2663,"id":239350,"goal":"predicate DistinctSeq_2663(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_2664","instance":2664,"id":239351,"goal":"predicate IsSubseq_2664(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_2665","instance":2665,"id":239352,"goal":"predicate IsPermutation_2665(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_2666","instance":2666,"id":239353,"goal":"predicate IsEven_2666(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_2667","instance":2667,"id":239354,"goal":"predicate InRange_2667(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_2668","instance":2668,"id":239355,"goal":"predicate SubsetOf_2668(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_2669","instance":2669,"id":239356,"goal":"predicate AllMem_2669(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_2670","instance":2670,"id":239357,"goal":"predicate DisjointSets_2670(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_2671","instance":2671,"id":239358,"goal":"predicate Sorted_2671(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_2672","instance":2672,"id":239359,"goal":"predicate AllPositive_2672(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_2673","instance":2673,"id":239360,"goal":"predicate DistinctSeq_2673(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_2674","instance":2674,"id":239361,"goal":"predicate IsSubseq_2674(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_2675","instance":2675,"id":239362,"goal":"predicate IsPermutation_2675(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_2676","instance":2676,"id":239363,"goal":"predicate IsEven_2676(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_2677","instance":2677,"id":239364,"goal":"predicate InRange_2677(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_2678","instance":2678,"id":239365,"goal":"predicate SubsetOf_2678(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_2679","instance":2679,"id":239366,"goal":"predicate AllMem_2679(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_2680","instance":2680,"id":239367,"goal":"predicate DisjointSets_2680(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_2681","instance":2681,"id":239368,"goal":"predicate Sorted_2681(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_2682","instance":2682,"id":239369,"goal":"predicate AllPositive_2682(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_2683","instance":2683,"id":239370,"goal":"predicate DistinctSeq_2683(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_2684","instance":2684,"id":239371,"goal":"predicate IsSubseq_2684(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_2685","instance":2685,"id":239372,"goal":"predicate IsPermutation_2685(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_2686","instance":2686,"id":239373,"goal":"predicate IsEven_2686(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_2687","instance":2687,"id":239374,"goal":"predicate InRange_2687(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_2688","instance":2688,"id":239375,"goal":"predicate SubsetOf_2688(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_2689","instance":2689,"id":239376,"goal":"predicate AllMem_2689(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_2690","instance":2690,"id":239377,"goal":"predicate DisjointSets_2690(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_2691","instance":2691,"id":239378,"goal":"predicate Sorted_2691(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_2692","instance":2692,"id":239379,"goal":"predicate AllPositive_2692(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_2693","instance":2693,"id":239380,"goal":"predicate DistinctSeq_2693(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_2694","instance":2694,"id":239381,"goal":"predicate IsSubseq_2694(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_2695","instance":2695,"id":239382,"goal":"predicate IsPermutation_2695(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_2696","instance":2696,"id":239383,"goal":"predicate IsEven_2696(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_2697","instance":2697,"id":239384,"goal":"predicate InRange_2697(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_2698","instance":2698,"id":239385,"goal":"predicate SubsetOf_2698(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_2699","instance":2699,"id":239386,"goal":"predicate AllMem_2699(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_2700","instance":2700,"id":239387,"goal":"predicate DisjointSets_2700(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_2701","instance":2701,"id":239388,"goal":"predicate Sorted_2701(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_2702","instance":2702,"id":239389,"goal":"predicate AllPositive_2702(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_2703","instance":2703,"id":239390,"goal":"predicate DistinctSeq_2703(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_2704","instance":2704,"id":239391,"goal":"predicate IsSubseq_2704(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_2705","instance":2705,"id":239392,"goal":"predicate IsPermutation_2705(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_2706","instance":2706,"id":239393,"goal":"predicate IsEven_2706(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_2707","instance":2707,"id":239394,"goal":"predicate InRange_2707(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_2708","instance":2708,"id":239395,"goal":"predicate SubsetOf_2708(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_2709","instance":2709,"id":239396,"goal":"predicate AllMem_2709(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_2710","instance":2710,"id":239397,"goal":"predicate DisjointSets_2710(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_2711","instance":2711,"id":239398,"goal":"predicate Sorted_2711(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_2712","instance":2712,"id":239399,"goal":"predicate AllPositive_2712(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_2713","instance":2713,"id":239400,"goal":"predicate DistinctSeq_2713(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_2714","instance":2714,"id":239401,"goal":"predicate IsSubseq_2714(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_2715","instance":2715,"id":239402,"goal":"predicate IsPermutation_2715(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_2716","instance":2716,"id":239403,"goal":"predicate IsEven_2716(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_2717","instance":2717,"id":239404,"goal":"predicate InRange_2717(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_2718","instance":2718,"id":239405,"goal":"predicate SubsetOf_2718(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_2719","instance":2719,"id":239406,"goal":"predicate AllMem_2719(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_2720","instance":2720,"id":239407,"goal":"predicate DisjointSets_2720(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_2721","instance":2721,"id":239408,"goal":"predicate Sorted_2721(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_2722","instance":2722,"id":239409,"goal":"predicate AllPositive_2722(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_2723","instance":2723,"id":239410,"goal":"predicate DistinctSeq_2723(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_2724","instance":2724,"id":239411,"goal":"predicate IsSubseq_2724(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_2725","instance":2725,"id":239412,"goal":"predicate IsPermutation_2725(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_2726","instance":2726,"id":239413,"goal":"predicate IsEven_2726(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_2727","instance":2727,"id":239414,"goal":"predicate InRange_2727(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_2728","instance":2728,"id":239415,"goal":"predicate SubsetOf_2728(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_2729","instance":2729,"id":239416,"goal":"predicate AllMem_2729(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_2730","instance":2730,"id":239417,"goal":"predicate DisjointSets_2730(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_2731","instance":2731,"id":239418,"goal":"predicate Sorted_2731(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_2732","instance":2732,"id":239419,"goal":"predicate AllPositive_2732(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_2733","instance":2733,"id":239420,"goal":"predicate DistinctSeq_2733(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_2734","instance":2734,"id":239421,"goal":"predicate IsSubseq_2734(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_2735","instance":2735,"id":239422,"goal":"predicate IsPermutation_2735(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_2736","instance":2736,"id":239423,"goal":"predicate IsEven_2736(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_2737","instance":2737,"id":239424,"goal":"predicate InRange_2737(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_2738","instance":2738,"id":239425,"goal":"predicate SubsetOf_2738(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_2739","instance":2739,"id":239426,"goal":"predicate AllMem_2739(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_2740","instance":2740,"id":239427,"goal":"predicate DisjointSets_2740(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_2741","instance":2741,"id":239428,"goal":"predicate Sorted_2741(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_2742","instance":2742,"id":239429,"goal":"predicate AllPositive_2742(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_2743","instance":2743,"id":239430,"goal":"predicate DistinctSeq_2743(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_2744","instance":2744,"id":239431,"goal":"predicate IsSubseq_2744(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_2745","instance":2745,"id":239432,"goal":"predicate IsPermutation_2745(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_2746","instance":2746,"id":239433,"goal":"predicate IsEven_2746(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_2747","instance":2747,"id":239434,"goal":"predicate InRange_2747(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_2748","instance":2748,"id":239435,"goal":"predicate SubsetOf_2748(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_2749","instance":2749,"id":239436,"goal":"predicate AllMem_2749(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_2750","instance":2750,"id":239437,"goal":"predicate DisjointSets_2750(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_2751","instance":2751,"id":239438,"goal":"predicate Sorted_2751(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_2752","instance":2752,"id":239439,"goal":"predicate AllPositive_2752(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_2753","instance":2753,"id":239440,"goal":"predicate DistinctSeq_2753(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_2754","instance":2754,"id":239441,"goal":"predicate IsSubseq_2754(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_2755","instance":2755,"id":239442,"goal":"predicate IsPermutation_2755(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_2756","instance":2756,"id":239443,"goal":"predicate IsEven_2756(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_2757","instance":2757,"id":239444,"goal":"predicate InRange_2757(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_2758","instance":2758,"id":239445,"goal":"predicate SubsetOf_2758(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_2759","instance":2759,"id":239446,"goal":"predicate AllMem_2759(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_2760","instance":2760,"id":239447,"goal":"predicate DisjointSets_2760(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_2761","instance":2761,"id":239448,"goal":"predicate Sorted_2761(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_2762","instance":2762,"id":239449,"goal":"predicate AllPositive_2762(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_2763","instance":2763,"id":239450,"goal":"predicate DistinctSeq_2763(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_2764","instance":2764,"id":239451,"goal":"predicate IsSubseq_2764(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_2765","instance":2765,"id":239452,"goal":"predicate IsPermutation_2765(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_2766","instance":2766,"id":239453,"goal":"predicate IsEven_2766(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_2767","instance":2767,"id":239454,"goal":"predicate InRange_2767(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_2768","instance":2768,"id":239455,"goal":"predicate SubsetOf_2768(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_2769","instance":2769,"id":239456,"goal":"predicate AllMem_2769(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_2770","instance":2770,"id":239457,"goal":"predicate DisjointSets_2770(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_2771","instance":2771,"id":239458,"goal":"predicate Sorted_2771(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_2772","instance":2772,"id":239459,"goal":"predicate AllPositive_2772(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_2773","instance":2773,"id":239460,"goal":"predicate DistinctSeq_2773(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_2774","instance":2774,"id":239461,"goal":"predicate IsSubseq_2774(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_2775","instance":2775,"id":239462,"goal":"predicate IsPermutation_2775(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_2776","instance":2776,"id":239463,"goal":"predicate IsEven_2776(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_2777","instance":2777,"id":239464,"goal":"predicate InRange_2777(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_2778","instance":2778,"id":239465,"goal":"predicate SubsetOf_2778(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_2779","instance":2779,"id":239466,"goal":"predicate AllMem_2779(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_2780","instance":2780,"id":239467,"goal":"predicate DisjointSets_2780(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_2781","instance":2781,"id":239468,"goal":"predicate Sorted_2781(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_2782","instance":2782,"id":239469,"goal":"predicate AllPositive_2782(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_2783","instance":2783,"id":239470,"goal":"predicate DistinctSeq_2783(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_2784","instance":2784,"id":239471,"goal":"predicate IsSubseq_2784(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_2785","instance":2785,"id":239472,"goal":"predicate IsPermutation_2785(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_2786","instance":2786,"id":239473,"goal":"predicate IsEven_2786(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_2787","instance":2787,"id":239474,"goal":"predicate InRange_2787(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_2788","instance":2788,"id":239475,"goal":"predicate SubsetOf_2788(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_2789","instance":2789,"id":239476,"goal":"predicate AllMem_2789(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_2790","instance":2790,"id":239477,"goal":"predicate DisjointSets_2790(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_2791","instance":2791,"id":239478,"goal":"predicate Sorted_2791(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_2792","instance":2792,"id":239479,"goal":"predicate AllPositive_2792(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_2793","instance":2793,"id":239480,"goal":"predicate DistinctSeq_2793(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_2794","instance":2794,"id":239481,"goal":"predicate IsSubseq_2794(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_2795","instance":2795,"id":239482,"goal":"predicate IsPermutation_2795(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_2796","instance":2796,"id":239483,"goal":"predicate IsEven_2796(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_2797","instance":2797,"id":239484,"goal":"predicate InRange_2797(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_2798","instance":2798,"id":239485,"goal":"predicate SubsetOf_2798(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_2799","instance":2799,"id":239486,"goal":"predicate AllMem_2799(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_2800","instance":2800,"id":239487,"goal":"predicate DisjointSets_2800(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_2801","instance":2801,"id":239488,"goal":"predicate Sorted_2801(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_2802","instance":2802,"id":239489,"goal":"predicate AllPositive_2802(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_2803","instance":2803,"id":239490,"goal":"predicate DistinctSeq_2803(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_2804","instance":2804,"id":239491,"goal":"predicate IsSubseq_2804(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_2805","instance":2805,"id":239492,"goal":"predicate IsPermutation_2805(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_2806","instance":2806,"id":239493,"goal":"predicate IsEven_2806(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_2807","instance":2807,"id":239494,"goal":"predicate InRange_2807(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_2808","instance":2808,"id":239495,"goal":"predicate SubsetOf_2808(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_2809","instance":2809,"id":239496,"goal":"predicate AllMem_2809(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_2810","instance":2810,"id":239497,"goal":"predicate DisjointSets_2810(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_2811","instance":2811,"id":239498,"goal":"predicate Sorted_2811(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_2812","instance":2812,"id":239499,"goal":"predicate AllPositive_2812(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_2813","instance":2813,"id":239500,"goal":"predicate DistinctSeq_2813(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_2814","instance":2814,"id":239501,"goal":"predicate IsSubseq_2814(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_2815","instance":2815,"id":239502,"goal":"predicate IsPermutation_2815(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_2816","instance":2816,"id":239503,"goal":"predicate IsEven_2816(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_2817","instance":2817,"id":239504,"goal":"predicate InRange_2817(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_2818","instance":2818,"id":239505,"goal":"predicate SubsetOf_2818(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_2819","instance":2819,"id":239506,"goal":"predicate AllMem_2819(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_2820","instance":2820,"id":239507,"goal":"predicate DisjointSets_2820(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_2821","instance":2821,"id":239508,"goal":"predicate Sorted_2821(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_2822","instance":2822,"id":239509,"goal":"predicate AllPositive_2822(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_2823","instance":2823,"id":239510,"goal":"predicate DistinctSeq_2823(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_2824","instance":2824,"id":239511,"goal":"predicate IsSubseq_2824(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_2825","instance":2825,"id":239512,"goal":"predicate IsPermutation_2825(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_2826","instance":2826,"id":239513,"goal":"predicate IsEven_2826(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_2827","instance":2827,"id":239514,"goal":"predicate InRange_2827(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_2828","instance":2828,"id":239515,"goal":"predicate SubsetOf_2828(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_2829","instance":2829,"id":239516,"goal":"predicate AllMem_2829(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_2830","instance":2830,"id":239517,"goal":"predicate DisjointSets_2830(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_2831","instance":2831,"id":239518,"goal":"predicate Sorted_2831(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_2832","instance":2832,"id":239519,"goal":"predicate AllPositive_2832(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_2833","instance":2833,"id":239520,"goal":"predicate DistinctSeq_2833(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_2834","instance":2834,"id":239521,"goal":"predicate IsSubseq_2834(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_2835","instance":2835,"id":239522,"goal":"predicate IsPermutation_2835(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_2836","instance":2836,"id":239523,"goal":"predicate IsEven_2836(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_2837","instance":2837,"id":239524,"goal":"predicate InRange_2837(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_2838","instance":2838,"id":239525,"goal":"predicate SubsetOf_2838(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_2839","instance":2839,"id":239526,"goal":"predicate AllMem_2839(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_2840","instance":2840,"id":239527,"goal":"predicate DisjointSets_2840(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_2841","instance":2841,"id":239528,"goal":"predicate Sorted_2841(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_2842","instance":2842,"id":239529,"goal":"predicate AllPositive_2842(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_2843","instance":2843,"id":239530,"goal":"predicate DistinctSeq_2843(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_2844","instance":2844,"id":239531,"goal":"predicate IsSubseq_2844(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_2845","instance":2845,"id":239532,"goal":"predicate IsPermutation_2845(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_2846","instance":2846,"id":239533,"goal":"predicate IsEven_2846(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_2847","instance":2847,"id":239534,"goal":"predicate InRange_2847(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_2848","instance":2848,"id":239535,"goal":"predicate SubsetOf_2848(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_2849","instance":2849,"id":239536,"goal":"predicate AllMem_2849(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_2850","instance":2850,"id":239537,"goal":"predicate DisjointSets_2850(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_2851","instance":2851,"id":239538,"goal":"predicate Sorted_2851(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_2852","instance":2852,"id":239539,"goal":"predicate AllPositive_2852(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_2853","instance":2853,"id":239540,"goal":"predicate DistinctSeq_2853(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_2854","instance":2854,"id":239541,"goal":"predicate IsSubseq_2854(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_2855","instance":2855,"id":239542,"goal":"predicate IsPermutation_2855(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_2856","instance":2856,"id":239543,"goal":"predicate IsEven_2856(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_2857","instance":2857,"id":239544,"goal":"predicate InRange_2857(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_2858","instance":2858,"id":239545,"goal":"predicate SubsetOf_2858(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_2859","instance":2859,"id":239546,"goal":"predicate AllMem_2859(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_2860","instance":2860,"id":239547,"goal":"predicate DisjointSets_2860(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_2861","instance":2861,"id":239548,"goal":"predicate Sorted_2861(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_2862","instance":2862,"id":239549,"goal":"predicate AllPositive_2862(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_2863","instance":2863,"id":239550,"goal":"predicate DistinctSeq_2863(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_2864","instance":2864,"id":239551,"goal":"predicate IsSubseq_2864(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_2865","instance":2865,"id":239552,"goal":"predicate IsPermutation_2865(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_2866","instance":2866,"id":239553,"goal":"predicate IsEven_2866(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_2867","instance":2867,"id":239554,"goal":"predicate InRange_2867(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_2868","instance":2868,"id":239555,"goal":"predicate SubsetOf_2868(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_2869","instance":2869,"id":239556,"goal":"predicate AllMem_2869(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_2870","instance":2870,"id":239557,"goal":"predicate DisjointSets_2870(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_2871","instance":2871,"id":239558,"goal":"predicate Sorted_2871(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_2872","instance":2872,"id":239559,"goal":"predicate AllPositive_2872(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_2873","instance":2873,"id":239560,"goal":"predicate DistinctSeq_2873(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_2874","instance":2874,"id":239561,"goal":"predicate IsSubseq_2874(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_2875","instance":2875,"id":239562,"goal":"predicate IsPermutation_2875(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_2876","instance":2876,"id":239563,"goal":"predicate IsEven_2876(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_2877","instance":2877,"id":239564,"goal":"predicate InRange_2877(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_2878","instance":2878,"id":239565,"goal":"predicate SubsetOf_2878(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_2879","instance":2879,"id":239566,"goal":"predicate AllMem_2879(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_2880","instance":2880,"id":239567,"goal":"predicate DisjointSets_2880(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_2881","instance":2881,"id":239568,"goal":"predicate Sorted_2881(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_2882","instance":2882,"id":239569,"goal":"predicate AllPositive_2882(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_2883","instance":2883,"id":239570,"goal":"predicate DistinctSeq_2883(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_2884","instance":2884,"id":239571,"goal":"predicate IsSubseq_2884(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_2885","instance":2885,"id":239572,"goal":"predicate IsPermutation_2885(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_2886","instance":2886,"id":239573,"goal":"predicate IsEven_2886(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_2887","instance":2887,"id":239574,"goal":"predicate InRange_2887(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_2888","instance":2888,"id":239575,"goal":"predicate SubsetOf_2888(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_2889","instance":2889,"id":239576,"goal":"predicate AllMem_2889(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_2890","instance":2890,"id":239577,"goal":"predicate DisjointSets_2890(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_2891","instance":2891,"id":239578,"goal":"predicate Sorted_2891(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_2892","instance":2892,"id":239579,"goal":"predicate AllPositive_2892(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_2893","instance":2893,"id":239580,"goal":"predicate DistinctSeq_2893(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_2894","instance":2894,"id":239581,"goal":"predicate IsSubseq_2894(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_2895","instance":2895,"id":239582,"goal":"predicate IsPermutation_2895(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_2896","instance":2896,"id":239583,"goal":"predicate IsEven_2896(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_2897","instance":2897,"id":239584,"goal":"predicate InRange_2897(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_2898","instance":2898,"id":239585,"goal":"predicate SubsetOf_2898(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_2899","instance":2899,"id":239586,"goal":"predicate AllMem_2899(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_2900","instance":2900,"id":239587,"goal":"predicate DisjointSets_2900(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_2901","instance":2901,"id":239588,"goal":"predicate Sorted_2901(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_2902","instance":2902,"id":239589,"goal":"predicate AllPositive_2902(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_2903","instance":2903,"id":239590,"goal":"predicate DistinctSeq_2903(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_2904","instance":2904,"id":239591,"goal":"predicate IsSubseq_2904(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_2905","instance":2905,"id":239592,"goal":"predicate IsPermutation_2905(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_2906","instance":2906,"id":239593,"goal":"predicate IsEven_2906(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_2907","instance":2907,"id":239594,"goal":"predicate InRange_2907(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_2908","instance":2908,"id":239595,"goal":"predicate SubsetOf_2908(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_2909","instance":2909,"id":239596,"goal":"predicate AllMem_2909(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_2910","instance":2910,"id":239597,"goal":"predicate DisjointSets_2910(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_2911","instance":2911,"id":239598,"goal":"predicate Sorted_2911(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_2912","instance":2912,"id":239599,"goal":"predicate AllPositive_2912(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_2913","instance":2913,"id":239600,"goal":"predicate DistinctSeq_2913(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_2914","instance":2914,"id":239601,"goal":"predicate IsSubseq_2914(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_2915","instance":2915,"id":239602,"goal":"predicate IsPermutation_2915(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_2916","instance":2916,"id":239603,"goal":"predicate IsEven_2916(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_2917","instance":2917,"id":239604,"goal":"predicate InRange_2917(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_2918","instance":2918,"id":239605,"goal":"predicate SubsetOf_2918(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_2919","instance":2919,"id":239606,"goal":"predicate AllMem_2919(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_2920","instance":2920,"id":239607,"goal":"predicate DisjointSets_2920(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_2921","instance":2921,"id":239608,"goal":"predicate Sorted_2921(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_2922","instance":2922,"id":239609,"goal":"predicate AllPositive_2922(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_2923","instance":2923,"id":239610,"goal":"predicate DistinctSeq_2923(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_2924","instance":2924,"id":239611,"goal":"predicate IsSubseq_2924(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_2925","instance":2925,"id":239612,"goal":"predicate IsPermutation_2925(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_2926","instance":2926,"id":239613,"goal":"predicate IsEven_2926(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_2927","instance":2927,"id":239614,"goal":"predicate InRange_2927(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_2928","instance":2928,"id":239615,"goal":"predicate SubsetOf_2928(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_2929","instance":2929,"id":239616,"goal":"predicate AllMem_2929(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_2930","instance":2930,"id":239617,"goal":"predicate DisjointSets_2930(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_2931","instance":2931,"id":239618,"goal":"predicate Sorted_2931(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_2932","instance":2932,"id":239619,"goal":"predicate AllPositive_2932(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_2933","instance":2933,"id":239620,"goal":"predicate DistinctSeq_2933(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_2934","instance":2934,"id":239621,"goal":"predicate IsSubseq_2934(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_2935","instance":2935,"id":239622,"goal":"predicate IsPermutation_2935(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_2936","instance":2936,"id":239623,"goal":"predicate IsEven_2936(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_2937","instance":2937,"id":239624,"goal":"predicate InRange_2937(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_2938","instance":2938,"id":239625,"goal":"predicate SubsetOf_2938(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_2939","instance":2939,"id":239626,"goal":"predicate AllMem_2939(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_2940","instance":2940,"id":239627,"goal":"predicate DisjointSets_2940(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_2941","instance":2941,"id":239628,"goal":"predicate Sorted_2941(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_2942","instance":2942,"id":239629,"goal":"predicate AllPositive_2942(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_2943","instance":2943,"id":239630,"goal":"predicate DistinctSeq_2943(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_2944","instance":2944,"id":239631,"goal":"predicate IsSubseq_2944(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_2945","instance":2945,"id":239632,"goal":"predicate IsPermutation_2945(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_2946","instance":2946,"id":239633,"goal":"predicate IsEven_2946(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_2947","instance":2947,"id":239634,"goal":"predicate InRange_2947(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_2948","instance":2948,"id":239635,"goal":"predicate SubsetOf_2948(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_2949","instance":2949,"id":239636,"goal":"predicate AllMem_2949(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_2950","instance":2950,"id":239637,"goal":"predicate DisjointSets_2950(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_2951","instance":2951,"id":239638,"goal":"predicate Sorted_2951(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_2952","instance":2952,"id":239639,"goal":"predicate AllPositive_2952(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_2953","instance":2953,"id":239640,"goal":"predicate DistinctSeq_2953(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_2954","instance":2954,"id":239641,"goal":"predicate IsSubseq_2954(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_2955","instance":2955,"id":239642,"goal":"predicate IsPermutation_2955(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_2956","instance":2956,"id":239643,"goal":"predicate IsEven_2956(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_2957","instance":2957,"id":239644,"goal":"predicate InRange_2957(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_2958","instance":2958,"id":239645,"goal":"predicate SubsetOf_2958(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_2959","instance":2959,"id":239646,"goal":"predicate AllMem_2959(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_2960","instance":2960,"id":239647,"goal":"predicate DisjointSets_2960(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_2961","instance":2961,"id":239648,"goal":"predicate Sorted_2961(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_2962","instance":2962,"id":239649,"goal":"predicate AllPositive_2962(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_2963","instance":2963,"id":239650,"goal":"predicate DistinctSeq_2963(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_2964","instance":2964,"id":239651,"goal":"predicate IsSubseq_2964(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_2965","instance":2965,"id":239652,"goal":"predicate IsPermutation_2965(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_2966","instance":2966,"id":239653,"goal":"predicate IsEven_2966(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_2967","instance":2967,"id":239654,"goal":"predicate InRange_2967(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_2968","instance":2968,"id":239655,"goal":"predicate SubsetOf_2968(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_2969","instance":2969,"id":239656,"goal":"predicate AllMem_2969(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_2970","instance":2970,"id":239657,"goal":"predicate DisjointSets_2970(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_2971","instance":2971,"id":239658,"goal":"predicate Sorted_2971(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_2972","instance":2972,"id":239659,"goal":"predicate AllPositive_2972(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_2973","instance":2973,"id":239660,"goal":"predicate DistinctSeq_2973(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_2974","instance":2974,"id":239661,"goal":"predicate IsSubseq_2974(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_2975","instance":2975,"id":239662,"goal":"predicate IsPermutation_2975(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_2976","instance":2976,"id":239663,"goal":"predicate IsEven_2976(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_2977","instance":2977,"id":239664,"goal":"predicate InRange_2977(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_2978","instance":2978,"id":239665,"goal":"predicate SubsetOf_2978(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_2979","instance":2979,"id":239666,"goal":"predicate AllMem_2979(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_2980","instance":2980,"id":239667,"goal":"predicate DisjointSets_2980(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_2981","instance":2981,"id":239668,"goal":"predicate Sorted_2981(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_2982","instance":2982,"id":239669,"goal":"predicate AllPositive_2982(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_2983","instance":2983,"id":239670,"goal":"predicate DistinctSeq_2983(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_2984","instance":2984,"id":239671,"goal":"predicate IsSubseq_2984(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_2985","instance":2985,"id":239672,"goal":"predicate IsPermutation_2985(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_2986","instance":2986,"id":239673,"goal":"predicate IsEven_2986(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_2987","instance":2987,"id":239674,"goal":"predicate InRange_2987(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_2988","instance":2988,"id":239675,"goal":"predicate SubsetOf_2988(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_2989","instance":2989,"id":239676,"goal":"predicate AllMem_2989(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_2990","instance":2990,"id":239677,"goal":"predicate DisjointSets_2990(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_2991","instance":2991,"id":239678,"goal":"predicate Sorted_2991(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_2992","instance":2992,"id":239679,"goal":"predicate AllPositive_2992(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_2993","instance":2993,"id":239680,"goal":"predicate DistinctSeq_2993(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_2994","instance":2994,"id":239681,"goal":"predicate IsSubseq_2994(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_2995","instance":2995,"id":239682,"goal":"predicate IsPermutation_2995(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_2996","instance":2996,"id":239683,"goal":"predicate IsEven_2996(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_2997","instance":2997,"id":239684,"goal":"predicate InRange_2997(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_2998","instance":2998,"id":239685,"goal":"predicate SubsetOf_2998(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_2999","instance":2999,"id":239686,"goal":"predicate AllMem_2999(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_3000","instance":3000,"id":239687,"goal":"predicate DisjointSets_3000(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_3001","instance":3001,"id":239688,"goal":"predicate Sorted_3001(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_3002","instance":3002,"id":239689,"goal":"predicate AllPositive_3002(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_3003","instance":3003,"id":239690,"goal":"predicate DistinctSeq_3003(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_3004","instance":3004,"id":239691,"goal":"predicate IsSubseq_3004(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_3005","instance":3005,"id":239692,"goal":"predicate IsPermutation_3005(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_3006","instance":3006,"id":239693,"goal":"predicate IsEven_3006(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_3007","instance":3007,"id":239694,"goal":"predicate InRange_3007(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_3008","instance":3008,"id":239695,"goal":"predicate SubsetOf_3008(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_3009","instance":3009,"id":239696,"goal":"predicate AllMem_3009(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_3010","instance":3010,"id":239697,"goal":"predicate DisjointSets_3010(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_3011","instance":3011,"id":239698,"goal":"predicate Sorted_3011(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_3012","instance":3012,"id":239699,"goal":"predicate AllPositive_3012(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_3013","instance":3013,"id":239700,"goal":"predicate DistinctSeq_3013(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_3014","instance":3014,"id":239701,"goal":"predicate IsSubseq_3014(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_3015","instance":3015,"id":239702,"goal":"predicate IsPermutation_3015(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_3016","instance":3016,"id":239703,"goal":"predicate IsEven_3016(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_3017","instance":3017,"id":239704,"goal":"predicate InRange_3017(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_3018","instance":3018,"id":239705,"goal":"predicate SubsetOf_3018(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_3019","instance":3019,"id":239706,"goal":"predicate AllMem_3019(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_3020","instance":3020,"id":239707,"goal":"predicate DisjointSets_3020(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_3021","instance":3021,"id":239708,"goal":"predicate Sorted_3021(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_3022","instance":3022,"id":239709,"goal":"predicate AllPositive_3022(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_3023","instance":3023,"id":239710,"goal":"predicate DistinctSeq_3023(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_3024","instance":3024,"id":239711,"goal":"predicate IsSubseq_3024(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_3025","instance":3025,"id":239712,"goal":"predicate IsPermutation_3025(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_3026","instance":3026,"id":239713,"goal":"predicate IsEven_3026(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_3027","instance":3027,"id":239714,"goal":"predicate InRange_3027(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_3028","instance":3028,"id":239715,"goal":"predicate SubsetOf_3028(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_3029","instance":3029,"id":239716,"goal":"predicate AllMem_3029(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_3030","instance":3030,"id":239717,"goal":"predicate DisjointSets_3030(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_3031","instance":3031,"id":239718,"goal":"predicate Sorted_3031(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_3032","instance":3032,"id":239719,"goal":"predicate AllPositive_3032(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_3033","instance":3033,"id":239720,"goal":"predicate DistinctSeq_3033(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_3034","instance":3034,"id":239721,"goal":"predicate IsSubseq_3034(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_3035","instance":3035,"id":239722,"goal":"predicate IsPermutation_3035(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_3036","instance":3036,"id":239723,"goal":"predicate IsEven_3036(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_3037","instance":3037,"id":239724,"goal":"predicate InRange_3037(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_3038","instance":3038,"id":239725,"goal":"predicate SubsetOf_3038(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_3039","instance":3039,"id":239726,"goal":"predicate AllMem_3039(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_3040","instance":3040,"id":239727,"goal":"predicate DisjointSets_3040(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_3041","instance":3041,"id":239728,"goal":"predicate Sorted_3041(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_3042","instance":3042,"id":239729,"goal":"predicate AllPositive_3042(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_3043","instance":3043,"id":239730,"goal":"predicate DistinctSeq_3043(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_3044","instance":3044,"id":239731,"goal":"predicate IsSubseq_3044(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_3045","instance":3045,"id":239732,"goal":"predicate IsPermutation_3045(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_3046","instance":3046,"id":239733,"goal":"predicate IsEven_3046(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_3047","instance":3047,"id":239734,"goal":"predicate InRange_3047(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_3048","instance":3048,"id":239735,"goal":"predicate SubsetOf_3048(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_3049","instance":3049,"id":239736,"goal":"predicate AllMem_3049(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_3050","instance":3050,"id":239737,"goal":"predicate DisjointSets_3050(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_3051","instance":3051,"id":239738,"goal":"predicate Sorted_3051(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_3052","instance":3052,"id":239739,"goal":"predicate AllPositive_3052(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_3053","instance":3053,"id":239740,"goal":"predicate DistinctSeq_3053(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_3054","instance":3054,"id":239741,"goal":"predicate IsSubseq_3054(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_3055","instance":3055,"id":239742,"goal":"predicate IsPermutation_3055(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_3056","instance":3056,"id":239743,"goal":"predicate IsEven_3056(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_3057","instance":3057,"id":239744,"goal":"predicate InRange_3057(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_3058","instance":3058,"id":239745,"goal":"predicate SubsetOf_3058(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_3059","instance":3059,"id":239746,"goal":"predicate AllMem_3059(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_3060","instance":3060,"id":239747,"goal":"predicate DisjointSets_3060(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_3061","instance":3061,"id":239748,"goal":"predicate Sorted_3061(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_3062","instance":3062,"id":239749,"goal":"predicate AllPositive_3062(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_3063","instance":3063,"id":239750,"goal":"predicate DistinctSeq_3063(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_3064","instance":3064,"id":239751,"goal":"predicate IsSubseq_3064(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_3065","instance":3065,"id":239752,"goal":"predicate IsPermutation_3065(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_3066","instance":3066,"id":239753,"goal":"predicate IsEven_3066(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_3067","instance":3067,"id":239754,"goal":"predicate InRange_3067(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_3068","instance":3068,"id":239755,"goal":"predicate SubsetOf_3068(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_3069","instance":3069,"id":239756,"goal":"predicate AllMem_3069(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_3070","instance":3070,"id":239757,"goal":"predicate DisjointSets_3070(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_3071","instance":3071,"id":239758,"goal":"predicate Sorted_3071(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_3072","instance":3072,"id":239759,"goal":"predicate AllPositive_3072(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_3073","instance":3073,"id":239760,"goal":"predicate DistinctSeq_3073(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_3074","instance":3074,"id":239761,"goal":"predicate IsSubseq_3074(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_3075","instance":3075,"id":239762,"goal":"predicate IsPermutation_3075(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_3076","instance":3076,"id":239763,"goal":"predicate IsEven_3076(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_3077","instance":3077,"id":239764,"goal":"predicate InRange_3077(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_3078","instance":3078,"id":239765,"goal":"predicate SubsetOf_3078(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_3079","instance":3079,"id":239766,"goal":"predicate AllMem_3079(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_3080","instance":3080,"id":239767,"goal":"predicate DisjointSets_3080(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_3081","instance":3081,"id":239768,"goal":"predicate Sorted_3081(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_3082","instance":3082,"id":239769,"goal":"predicate AllPositive_3082(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_3083","instance":3083,"id":239770,"goal":"predicate DistinctSeq_3083(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_3084","instance":3084,"id":239771,"goal":"predicate IsSubseq_3084(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_3085","instance":3085,"id":239772,"goal":"predicate IsPermutation_3085(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_3086","instance":3086,"id":239773,"goal":"predicate IsEven_3086(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_3087","instance":3087,"id":239774,"goal":"predicate InRange_3087(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_3088","instance":3088,"id":239775,"goal":"predicate SubsetOf_3088(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_3089","instance":3089,"id":239776,"goal":"predicate AllMem_3089(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_3090","instance":3090,"id":239777,"goal":"predicate DisjointSets_3090(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_3091","instance":3091,"id":239778,"goal":"predicate Sorted_3091(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_3092","instance":3092,"id":239779,"goal":"predicate AllPositive_3092(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_3093","instance":3093,"id":239780,"goal":"predicate DistinctSeq_3093(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_3094","instance":3094,"id":239781,"goal":"predicate IsSubseq_3094(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_3095","instance":3095,"id":239782,"goal":"predicate IsPermutation_3095(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_3096","instance":3096,"id":239783,"goal":"predicate IsEven_3096(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_3097","instance":3097,"id":239784,"goal":"predicate InRange_3097(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_3098","instance":3098,"id":239785,"goal":"predicate SubsetOf_3098(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_3099","instance":3099,"id":239786,"goal":"predicate AllMem_3099(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_3100","instance":3100,"id":239787,"goal":"predicate DisjointSets_3100(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_3101","instance":3101,"id":239788,"goal":"predicate Sorted_3101(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_3102","instance":3102,"id":239789,"goal":"predicate AllPositive_3102(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_3103","instance":3103,"id":239790,"goal":"predicate DistinctSeq_3103(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_3104","instance":3104,"id":239791,"goal":"predicate IsSubseq_3104(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_3105","instance":3105,"id":239792,"goal":"predicate IsPermutation_3105(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_3106","instance":3106,"id":239793,"goal":"predicate IsEven_3106(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_3107","instance":3107,"id":239794,"goal":"predicate InRange_3107(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_3108","instance":3108,"id":239795,"goal":"predicate SubsetOf_3108(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_3109","instance":3109,"id":239796,"goal":"predicate AllMem_3109(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_3110","instance":3110,"id":239797,"goal":"predicate DisjointSets_3110(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_3111","instance":3111,"id":239798,"goal":"predicate Sorted_3111(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_3112","instance":3112,"id":239799,"goal":"predicate AllPositive_3112(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_3113","instance":3113,"id":239800,"goal":"predicate DistinctSeq_3113(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_3114","instance":3114,"id":239801,"goal":"predicate IsSubseq_3114(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_3115","instance":3115,"id":239802,"goal":"predicate IsPermutation_3115(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_3116","instance":3116,"id":239803,"goal":"predicate IsEven_3116(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_3117","instance":3117,"id":239804,"goal":"predicate InRange_3117(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_3118","instance":3118,"id":239805,"goal":"predicate SubsetOf_3118(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_3119","instance":3119,"id":239806,"goal":"predicate AllMem_3119(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_3120","instance":3120,"id":239807,"goal":"predicate DisjointSets_3120(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_3121","instance":3121,"id":239808,"goal":"predicate Sorted_3121(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_3122","instance":3122,"id":239809,"goal":"predicate AllPositive_3122(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_3123","instance":3123,"id":239810,"goal":"predicate DistinctSeq_3123(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_3124","instance":3124,"id":239811,"goal":"predicate IsSubseq_3124(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_3125","instance":3125,"id":239812,"goal":"predicate IsPermutation_3125(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_3126","instance":3126,"id":239813,"goal":"predicate IsEven_3126(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_3127","instance":3127,"id":239814,"goal":"predicate InRange_3127(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_3128","instance":3128,"id":239815,"goal":"predicate SubsetOf_3128(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_3129","instance":3129,"id":239816,"goal":"predicate AllMem_3129(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_3130","instance":3130,"id":239817,"goal":"predicate DisjointSets_3130(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_3131","instance":3131,"id":239818,"goal":"predicate Sorted_3131(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_3132","instance":3132,"id":239819,"goal":"predicate AllPositive_3132(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_3133","instance":3133,"id":239820,"goal":"predicate DistinctSeq_3133(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_3134","instance":3134,"id":239821,"goal":"predicate IsSubseq_3134(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_3135","instance":3135,"id":239822,"goal":"predicate IsPermutation_3135(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_3136","instance":3136,"id":239823,"goal":"predicate IsEven_3136(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_3137","instance":3137,"id":239824,"goal":"predicate InRange_3137(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_3138","instance":3138,"id":239825,"goal":"predicate SubsetOf_3138(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_3139","instance":3139,"id":239826,"goal":"predicate AllMem_3139(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_3140","instance":3140,"id":239827,"goal":"predicate DisjointSets_3140(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_3141","instance":3141,"id":239828,"goal":"predicate Sorted_3141(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_3142","instance":3142,"id":239829,"goal":"predicate AllPositive_3142(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_3143","instance":3143,"id":239830,"goal":"predicate DistinctSeq_3143(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_3144","instance":3144,"id":239831,"goal":"predicate IsSubseq_3144(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_3145","instance":3145,"id":239832,"goal":"predicate IsPermutation_3145(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_3146","instance":3146,"id":239833,"goal":"predicate IsEven_3146(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_3147","instance":3147,"id":239834,"goal":"predicate InRange_3147(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_3148","instance":3148,"id":239835,"goal":"predicate SubsetOf_3148(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_3149","instance":3149,"id":239836,"goal":"predicate AllMem_3149(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_3150","instance":3150,"id":239837,"goal":"predicate DisjointSets_3150(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_3151","instance":3151,"id":239838,"goal":"predicate Sorted_3151(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_3152","instance":3152,"id":239839,"goal":"predicate AllPositive_3152(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_3153","instance":3153,"id":239840,"goal":"predicate DistinctSeq_3153(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_3154","instance":3154,"id":239841,"goal":"predicate IsSubseq_3154(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_3155","instance":3155,"id":239842,"goal":"predicate IsPermutation_3155(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_3156","instance":3156,"id":239843,"goal":"predicate IsEven_3156(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_3157","instance":3157,"id":239844,"goal":"predicate InRange_3157(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_3158","instance":3158,"id":239845,"goal":"predicate SubsetOf_3158(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_3159","instance":3159,"id":239846,"goal":"predicate AllMem_3159(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_3160","instance":3160,"id":239847,"goal":"predicate DisjointSets_3160(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_3161","instance":3161,"id":239848,"goal":"predicate Sorted_3161(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_3162","instance":3162,"id":239849,"goal":"predicate AllPositive_3162(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_3163","instance":3163,"id":239850,"goal":"predicate DistinctSeq_3163(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_3164","instance":3164,"id":239851,"goal":"predicate IsSubseq_3164(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_3165","instance":3165,"id":239852,"goal":"predicate IsPermutation_3165(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_3166","instance":3166,"id":239853,"goal":"predicate IsEven_3166(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_3167","instance":3167,"id":239854,"goal":"predicate InRange_3167(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_3168","instance":3168,"id":239855,"goal":"predicate SubsetOf_3168(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_3169","instance":3169,"id":239856,"goal":"predicate AllMem_3169(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_3170","instance":3170,"id":239857,"goal":"predicate DisjointSets_3170(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_3171","instance":3171,"id":239858,"goal":"predicate Sorted_3171(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_3172","instance":3172,"id":239859,"goal":"predicate AllPositive_3172(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_3173","instance":3173,"id":239860,"goal":"predicate DistinctSeq_3173(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_3174","instance":3174,"id":239861,"goal":"predicate IsSubseq_3174(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_3175","instance":3175,"id":239862,"goal":"predicate IsPermutation_3175(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_3176","instance":3176,"id":239863,"goal":"predicate IsEven_3176(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_3177","instance":3177,"id":239864,"goal":"predicate InRange_3177(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_3178","instance":3178,"id":239865,"goal":"predicate SubsetOf_3178(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_3179","instance":3179,"id":239866,"goal":"predicate AllMem_3179(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_3180","instance":3180,"id":239867,"goal":"predicate DisjointSets_3180(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_3181","instance":3181,"id":239868,"goal":"predicate Sorted_3181(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_3182","instance":3182,"id":239869,"goal":"predicate AllPositive_3182(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_3183","instance":3183,"id":239870,"goal":"predicate DistinctSeq_3183(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_3184","instance":3184,"id":239871,"goal":"predicate IsSubseq_3184(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_3185","instance":3185,"id":239872,"goal":"predicate IsPermutation_3185(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_3186","instance":3186,"id":239873,"goal":"predicate IsEven_3186(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_3187","instance":3187,"id":239874,"goal":"predicate InRange_3187(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_3188","instance":3188,"id":239875,"goal":"predicate SubsetOf_3188(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_3189","instance":3189,"id":239876,"goal":"predicate AllMem_3189(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_3190","instance":3190,"id":239877,"goal":"predicate DisjointSets_3190(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_3191","instance":3191,"id":239878,"goal":"predicate Sorted_3191(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_3192","instance":3192,"id":239879,"goal":"predicate AllPositive_3192(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_3193","instance":3193,"id":239880,"goal":"predicate DistinctSeq_3193(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_3194","instance":3194,"id":239881,"goal":"predicate IsSubseq_3194(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_3195","instance":3195,"id":239882,"goal":"predicate IsPermutation_3195(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_3196","instance":3196,"id":239883,"goal":"predicate IsEven_3196(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_3197","instance":3197,"id":239884,"goal":"predicate InRange_3197(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_3198","instance":3198,"id":239885,"goal":"predicate SubsetOf_3198(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_3199","instance":3199,"id":239886,"goal":"predicate AllMem_3199(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_3200","instance":3200,"id":239887,"goal":"predicate DisjointSets_3200(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_3201","instance":3201,"id":239888,"goal":"predicate Sorted_3201(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_3202","instance":3202,"id":239889,"goal":"predicate AllPositive_3202(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_3203","instance":3203,"id":239890,"goal":"predicate DistinctSeq_3203(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_3204","instance":3204,"id":239891,"goal":"predicate IsSubseq_3204(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_3205","instance":3205,"id":239892,"goal":"predicate IsPermutation_3205(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_3206","instance":3206,"id":239893,"goal":"predicate IsEven_3206(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_3207","instance":3207,"id":239894,"goal":"predicate InRange_3207(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_3208","instance":3208,"id":239895,"goal":"predicate SubsetOf_3208(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_3209","instance":3209,"id":239896,"goal":"predicate AllMem_3209(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_3210","instance":3210,"id":239897,"goal":"predicate DisjointSets_3210(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_3211","instance":3211,"id":239898,"goal":"predicate Sorted_3211(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_3212","instance":3212,"id":239899,"goal":"predicate AllPositive_3212(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_3213","instance":3213,"id":239900,"goal":"predicate DistinctSeq_3213(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_3214","instance":3214,"id":239901,"goal":"predicate IsSubseq_3214(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_3215","instance":3215,"id":239902,"goal":"predicate IsPermutation_3215(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_3216","instance":3216,"id":239903,"goal":"predicate IsEven_3216(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_3217","instance":3217,"id":239904,"goal":"predicate InRange_3217(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_3218","instance":3218,"id":239905,"goal":"predicate SubsetOf_3218(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_3219","instance":3219,"id":239906,"goal":"predicate AllMem_3219(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_3220","instance":3220,"id":239907,"goal":"predicate DisjointSets_3220(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_3221","instance":3221,"id":239908,"goal":"predicate Sorted_3221(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_3222","instance":3222,"id":239909,"goal":"predicate AllPositive_3222(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_3223","instance":3223,"id":239910,"goal":"predicate DistinctSeq_3223(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_3224","instance":3224,"id":239911,"goal":"predicate IsSubseq_3224(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_3225","instance":3225,"id":239912,"goal":"predicate IsPermutation_3225(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_3226","instance":3226,"id":239913,"goal":"predicate IsEven_3226(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_3227","instance":3227,"id":239914,"goal":"predicate InRange_3227(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_3228","instance":3228,"id":239915,"goal":"predicate SubsetOf_3228(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_3229","instance":3229,"id":239916,"goal":"predicate AllMem_3229(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_3230","instance":3230,"id":239917,"goal":"predicate DisjointSets_3230(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_3231","instance":3231,"id":239918,"goal":"predicate Sorted_3231(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_3232","instance":3232,"id":239919,"goal":"predicate AllPositive_3232(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_3233","instance":3233,"id":239920,"goal":"predicate DistinctSeq_3233(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_3234","instance":3234,"id":239921,"goal":"predicate IsSubseq_3234(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_3235","instance":3235,"id":239922,"goal":"predicate IsPermutation_3235(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_3236","instance":3236,"id":239923,"goal":"predicate IsEven_3236(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_3237","instance":3237,"id":239924,"goal":"predicate InRange_3237(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_3238","instance":3238,"id":239925,"goal":"predicate SubsetOf_3238(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_3239","instance":3239,"id":239926,"goal":"predicate AllMem_3239(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_3240","instance":3240,"id":239927,"goal":"predicate DisjointSets_3240(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_3241","instance":3241,"id":239928,"goal":"predicate Sorted_3241(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_3242","instance":3242,"id":239929,"goal":"predicate AllPositive_3242(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_3243","instance":3243,"id":239930,"goal":"predicate DistinctSeq_3243(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_3244","instance":3244,"id":239931,"goal":"predicate IsSubseq_3244(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_3245","instance":3245,"id":239932,"goal":"predicate IsPermutation_3245(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_3246","instance":3246,"id":239933,"goal":"predicate IsEven_3246(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_3247","instance":3247,"id":239934,"goal":"predicate InRange_3247(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_3248","instance":3248,"id":239935,"goal":"predicate SubsetOf_3248(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_3249","instance":3249,"id":239936,"goal":"predicate AllMem_3249(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_3250","instance":3250,"id":239937,"goal":"predicate DisjointSets_3250(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_3251","instance":3251,"id":239938,"goal":"predicate Sorted_3251(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_3252","instance":3252,"id":239939,"goal":"predicate AllPositive_3252(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_3253","instance":3253,"id":239940,"goal":"predicate DistinctSeq_3253(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_3254","instance":3254,"id":239941,"goal":"predicate IsSubseq_3254(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_3255","instance":3255,"id":239942,"goal":"predicate IsPermutation_3255(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_3256","instance":3256,"id":239943,"goal":"predicate IsEven_3256(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_3257","instance":3257,"id":239944,"goal":"predicate InRange_3257(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_3258","instance":3258,"id":239945,"goal":"predicate SubsetOf_3258(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_3259","instance":3259,"id":239946,"goal":"predicate AllMem_3259(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_3260","instance":3260,"id":239947,"goal":"predicate DisjointSets_3260(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_3261","instance":3261,"id":239948,"goal":"predicate Sorted_3261(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_3262","instance":3262,"id":239949,"goal":"predicate AllPositive_3262(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_3263","instance":3263,"id":239950,"goal":"predicate DistinctSeq_3263(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_3264","instance":3264,"id":239951,"goal":"predicate IsSubseq_3264(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_3265","instance":3265,"id":239952,"goal":"predicate IsPermutation_3265(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_3266","instance":3266,"id":239953,"goal":"predicate IsEven_3266(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_3267","instance":3267,"id":239954,"goal":"predicate InRange_3267(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_3268","instance":3268,"id":239955,"goal":"predicate SubsetOf_3268(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_3269","instance":3269,"id":239956,"goal":"predicate AllMem_3269(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_3270","instance":3270,"id":239957,"goal":"predicate DisjointSets_3270(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_3271","instance":3271,"id":239958,"goal":"predicate Sorted_3271(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_3272","instance":3272,"id":239959,"goal":"predicate AllPositive_3272(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_3273","instance":3273,"id":239960,"goal":"predicate DistinctSeq_3273(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_3274","instance":3274,"id":239961,"goal":"predicate IsSubseq_3274(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_3275","instance":3275,"id":239962,"goal":"predicate IsPermutation_3275(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_3276","instance":3276,"id":239963,"goal":"predicate IsEven_3276(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_3277","instance":3277,"id":239964,"goal":"predicate InRange_3277(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_3278","instance":3278,"id":239965,"goal":"predicate SubsetOf_3278(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_3279","instance":3279,"id":239966,"goal":"predicate AllMem_3279(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_3280","instance":3280,"id":239967,"goal":"predicate DisjointSets_3280(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_3281","instance":3281,"id":239968,"goal":"predicate Sorted_3281(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_3282","instance":3282,"id":239969,"goal":"predicate AllPositive_3282(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_3283","instance":3283,"id":239970,"goal":"predicate DistinctSeq_3283(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_3284","instance":3284,"id":239971,"goal":"predicate IsSubseq_3284(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_3285","instance":3285,"id":239972,"goal":"predicate IsPermutation_3285(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_3286","instance":3286,"id":239973,"goal":"predicate IsEven_3286(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_3287","instance":3287,"id":239974,"goal":"predicate InRange_3287(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_3288","instance":3288,"id":239975,"goal":"predicate SubsetOf_3288(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_3289","instance":3289,"id":239976,"goal":"predicate AllMem_3289(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_3290","instance":3290,"id":239977,"goal":"predicate DisjointSets_3290(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_3291","instance":3291,"id":239978,"goal":"predicate Sorted_3291(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_3292","instance":3292,"id":239979,"goal":"predicate AllPositive_3292(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_3293","instance":3293,"id":239980,"goal":"predicate DistinctSeq_3293(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_3294","instance":3294,"id":239981,"goal":"predicate IsSubseq_3294(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_3295","instance":3295,"id":239982,"goal":"predicate IsPermutation_3295(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_3296","instance":3296,"id":239983,"goal":"predicate IsEven_3296(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_3297","instance":3297,"id":239984,"goal":"predicate InRange_3297(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_3298","instance":3298,"id":239985,"goal":"predicate SubsetOf_3298(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_3299","instance":3299,"id":239986,"goal":"predicate AllMem_3299(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_3300","instance":3300,"id":239987,"goal":"predicate DisjointSets_3300(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_3301","instance":3301,"id":239988,"goal":"predicate Sorted_3301(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_3302","instance":3302,"id":239989,"goal":"predicate AllPositive_3302(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_3303","instance":3303,"id":239990,"goal":"predicate DistinctSeq_3303(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_3304","instance":3304,"id":239991,"goal":"predicate IsSubseq_3304(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_3305","instance":3305,"id":239992,"goal":"predicate IsPermutation_3305(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_3306","instance":3306,"id":239993,"goal":"predicate IsEven_3306(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_3307","instance":3307,"id":239994,"goal":"predicate InRange_3307(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_3308","instance":3308,"id":239995,"goal":"predicate SubsetOf_3308(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_3309","instance":3309,"id":239996,"goal":"predicate AllMem_3309(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_3310","instance":3310,"id":239997,"goal":"predicate DisjointSets_3310(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_3311","instance":3311,"id":239998,"goal":"predicate Sorted_3311(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_3312","instance":3312,"id":239999,"goal":"predicate AllPositive_3312(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_3313","instance":3313,"id":240000,"goal":"predicate DistinctSeq_3313(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_3314","instance":3314,"id":240001,"goal":"predicate IsSubseq_3314(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_3315","instance":3315,"id":240002,"goal":"predicate IsPermutation_3315(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_3316","instance":3316,"id":240003,"goal":"predicate IsEven_3316(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_3317","instance":3317,"id":240004,"goal":"predicate InRange_3317(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_3318","instance":3318,"id":240005,"goal":"predicate SubsetOf_3318(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_3319","instance":3319,"id":240006,"goal":"predicate AllMem_3319(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_3320","instance":3320,"id":240007,"goal":"predicate DisjointSets_3320(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_3321","instance":3321,"id":240008,"goal":"predicate Sorted_3321(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_3322","instance":3322,"id":240009,"goal":"predicate AllPositive_3322(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_3323","instance":3323,"id":240010,"goal":"predicate DistinctSeq_3323(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_3324","instance":3324,"id":240011,"goal":"predicate IsSubseq_3324(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_3325","instance":3325,"id":240012,"goal":"predicate IsPermutation_3325(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_3326","instance":3326,"id":240013,"goal":"predicate IsEven_3326(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_3327","instance":3327,"id":240014,"goal":"predicate InRange_3327(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_3328","instance":3328,"id":240015,"goal":"predicate SubsetOf_3328(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_3329","instance":3329,"id":240016,"goal":"predicate AllMem_3329(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_3330","instance":3330,"id":240017,"goal":"predicate DisjointSets_3330(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_3331","instance":3331,"id":240018,"goal":"predicate Sorted_3331(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_3332","instance":3332,"id":240019,"goal":"predicate AllPositive_3332(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_3333","instance":3333,"id":240020,"goal":"predicate DistinctSeq_3333(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_3334","instance":3334,"id":240021,"goal":"predicate IsSubseq_3334(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_3335","instance":3335,"id":240022,"goal":"predicate IsPermutation_3335(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_3336","instance":3336,"id":240023,"goal":"predicate IsEven_3336(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_3337","instance":3337,"id":240024,"goal":"predicate InRange_3337(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_3338","instance":3338,"id":240025,"goal":"predicate SubsetOf_3338(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_3339","instance":3339,"id":240026,"goal":"predicate AllMem_3339(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_3340","instance":3340,"id":240027,"goal":"predicate DisjointSets_3340(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_3341","instance":3341,"id":240028,"goal":"predicate Sorted_3341(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_3342","instance":3342,"id":240029,"goal":"predicate AllPositive_3342(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_3343","instance":3343,"id":240030,"goal":"predicate DistinctSeq_3343(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_3344","instance":3344,"id":240031,"goal":"predicate IsSubseq_3344(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_3345","instance":3345,"id":240032,"goal":"predicate IsPermutation_3345(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_3346","instance":3346,"id":240033,"goal":"predicate IsEven_3346(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_3347","instance":3347,"id":240034,"goal":"predicate InRange_3347(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_3348","instance":3348,"id":240035,"goal":"predicate SubsetOf_3348(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_3349","instance":3349,"id":240036,"goal":"predicate AllMem_3349(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_3350","instance":3350,"id":240037,"goal":"predicate DisjointSets_3350(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_3351","instance":3351,"id":240038,"goal":"predicate Sorted_3351(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_3352","instance":3352,"id":240039,"goal":"predicate AllPositive_3352(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_3353","instance":3353,"id":240040,"goal":"predicate DistinctSeq_3353(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_3354","instance":3354,"id":240041,"goal":"predicate IsSubseq_3354(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_3355","instance":3355,"id":240042,"goal":"predicate IsPermutation_3355(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_3356","instance":3356,"id":240043,"goal":"predicate IsEven_3356(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_3357","instance":3357,"id":240044,"goal":"predicate InRange_3357(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_3358","instance":3358,"id":240045,"goal":"predicate SubsetOf_3358(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_3359","instance":3359,"id":240046,"goal":"predicate AllMem_3359(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_3360","instance":3360,"id":240047,"goal":"predicate DisjointSets_3360(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_3361","instance":3361,"id":240048,"goal":"predicate Sorted_3361(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_3362","instance":3362,"id":240049,"goal":"predicate AllPositive_3362(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_3363","instance":3363,"id":240050,"goal":"predicate DistinctSeq_3363(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_3364","instance":3364,"id":240051,"goal":"predicate IsSubseq_3364(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_3365","instance":3365,"id":240052,"goal":"predicate IsPermutation_3365(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_3366","instance":3366,"id":240053,"goal":"predicate IsEven_3366(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_3367","instance":3367,"id":240054,"goal":"predicate InRange_3367(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_3368","instance":3368,"id":240055,"goal":"predicate SubsetOf_3368(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_3369","instance":3369,"id":240056,"goal":"predicate AllMem_3369(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_3370","instance":3370,"id":240057,"goal":"predicate DisjointSets_3370(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_3371","instance":3371,"id":240058,"goal":"predicate Sorted_3371(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_3372","instance":3372,"id":240059,"goal":"predicate AllPositive_3372(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_3373","instance":3373,"id":240060,"goal":"predicate DistinctSeq_3373(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_3374","instance":3374,"id":240061,"goal":"predicate IsSubseq_3374(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_3375","instance":3375,"id":240062,"goal":"predicate IsPermutation_3375(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_3376","instance":3376,"id":240063,"goal":"predicate IsEven_3376(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_3377","instance":3377,"id":240064,"goal":"predicate InRange_3377(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_3378","instance":3378,"id":240065,"goal":"predicate SubsetOf_3378(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_3379","instance":3379,"id":240066,"goal":"predicate AllMem_3379(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_3380","instance":3380,"id":240067,"goal":"predicate DisjointSets_3380(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_3381","instance":3381,"id":240068,"goal":"predicate Sorted_3381(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_3382","instance":3382,"id":240069,"goal":"predicate AllPositive_3382(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_3383","instance":3383,"id":240070,"goal":"predicate DistinctSeq_3383(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_3384","instance":3384,"id":240071,"goal":"predicate IsSubseq_3384(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_3385","instance":3385,"id":240072,"goal":"predicate IsPermutation_3385(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_3386","instance":3386,"id":240073,"goal":"predicate IsEven_3386(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_3387","instance":3387,"id":240074,"goal":"predicate InRange_3387(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_3388","instance":3388,"id":240075,"goal":"predicate SubsetOf_3388(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_3389","instance":3389,"id":240076,"goal":"predicate AllMem_3389(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_3390","instance":3390,"id":240077,"goal":"predicate DisjointSets_3390(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_3391","instance":3391,"id":240078,"goal":"predicate Sorted_3391(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_3392","instance":3392,"id":240079,"goal":"predicate AllPositive_3392(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_3393","instance":3393,"id":240080,"goal":"predicate DistinctSeq_3393(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_3394","instance":3394,"id":240081,"goal":"predicate IsSubseq_3394(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_3395","instance":3395,"id":240082,"goal":"predicate IsPermutation_3395(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_3396","instance":3396,"id":240083,"goal":"predicate IsEven_3396(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_3397","instance":3397,"id":240084,"goal":"predicate InRange_3397(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_3398","instance":3398,"id":240085,"goal":"predicate SubsetOf_3398(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_3399","instance":3399,"id":240086,"goal":"predicate AllMem_3399(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_3400","instance":3400,"id":240087,"goal":"predicate DisjointSets_3400(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_3401","instance":3401,"id":240088,"goal":"predicate Sorted_3401(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_3402","instance":3402,"id":240089,"goal":"predicate AllPositive_3402(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_3403","instance":3403,"id":240090,"goal":"predicate DistinctSeq_3403(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_3404","instance":3404,"id":240091,"goal":"predicate IsSubseq_3404(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_3405","instance":3405,"id":240092,"goal":"predicate IsPermutation_3405(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_3406","instance":3406,"id":240093,"goal":"predicate IsEven_3406(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_3407","instance":3407,"id":240094,"goal":"predicate InRange_3407(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_3408","instance":3408,"id":240095,"goal":"predicate SubsetOf_3408(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_3409","instance":3409,"id":240096,"goal":"predicate AllMem_3409(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_3410","instance":3410,"id":240097,"goal":"predicate DisjointSets_3410(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_3411","instance":3411,"id":240098,"goal":"predicate Sorted_3411(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_3412","instance":3412,"id":240099,"goal":"predicate AllPositive_3412(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_3413","instance":3413,"id":240100,"goal":"predicate DistinctSeq_3413(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_3414","instance":3414,"id":240101,"goal":"predicate IsSubseq_3414(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_3415","instance":3415,"id":240102,"goal":"predicate IsPermutation_3415(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_3416","instance":3416,"id":240103,"goal":"predicate IsEven_3416(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_3417","instance":3417,"id":240104,"goal":"predicate InRange_3417(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_3418","instance":3418,"id":240105,"goal":"predicate SubsetOf_3418(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_3419","instance":3419,"id":240106,"goal":"predicate AllMem_3419(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_3420","instance":3420,"id":240107,"goal":"predicate DisjointSets_3420(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_3421","instance":3421,"id":240108,"goal":"predicate Sorted_3421(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_3422","instance":3422,"id":240109,"goal":"predicate AllPositive_3422(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_3423","instance":3423,"id":240110,"goal":"predicate DistinctSeq_3423(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_3424","instance":3424,"id":240111,"goal":"predicate IsSubseq_3424(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_3425","instance":3425,"id":240112,"goal":"predicate IsPermutation_3425(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_3426","instance":3426,"id":240113,"goal":"predicate IsEven_3426(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_3427","instance":3427,"id":240114,"goal":"predicate InRange_3427(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_3428","instance":3428,"id":240115,"goal":"predicate SubsetOf_3428(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_3429","instance":3429,"id":240116,"goal":"predicate AllMem_3429(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_3430","instance":3430,"id":240117,"goal":"predicate DisjointSets_3430(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_3431","instance":3431,"id":240118,"goal":"predicate Sorted_3431(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_3432","instance":3432,"id":240119,"goal":"predicate AllPositive_3432(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_3433","instance":3433,"id":240120,"goal":"predicate DistinctSeq_3433(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_3434","instance":3434,"id":240121,"goal":"predicate IsSubseq_3434(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_3435","instance":3435,"id":240122,"goal":"predicate IsPermutation_3435(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_3436","instance":3436,"id":240123,"goal":"predicate IsEven_3436(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_3437","instance":3437,"id":240124,"goal":"predicate InRange_3437(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_3438","instance":3438,"id":240125,"goal":"predicate SubsetOf_3438(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_3439","instance":3439,"id":240126,"goal":"predicate AllMem_3439(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_3440","instance":3440,"id":240127,"goal":"predicate DisjointSets_3440(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_3441","instance":3441,"id":240128,"goal":"predicate Sorted_3441(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_3442","instance":3442,"id":240129,"goal":"predicate AllPositive_3442(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_3443","instance":3443,"id":240130,"goal":"predicate DistinctSeq_3443(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_3444","instance":3444,"id":240131,"goal":"predicate IsSubseq_3444(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_3445","instance":3445,"id":240132,"goal":"predicate IsPermutation_3445(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_3446","instance":3446,"id":240133,"goal":"predicate IsEven_3446(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_3447","instance":3447,"id":240134,"goal":"predicate InRange_3447(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_3448","instance":3448,"id":240135,"goal":"predicate SubsetOf_3448(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_3449","instance":3449,"id":240136,"goal":"predicate AllMem_3449(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_3450","instance":3450,"id":240137,"goal":"predicate DisjointSets_3450(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_3451","instance":3451,"id":240138,"goal":"predicate Sorted_3451(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_3452","instance":3452,"id":240139,"goal":"predicate AllPositive_3452(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_3453","instance":3453,"id":240140,"goal":"predicate DistinctSeq_3453(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_3454","instance":3454,"id":240141,"goal":"predicate IsSubseq_3454(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_3455","instance":3455,"id":240142,"goal":"predicate IsPermutation_3455(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_3456","instance":3456,"id":240143,"goal":"predicate IsEven_3456(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_3457","instance":3457,"id":240144,"goal":"predicate InRange_3457(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_3458","instance":3458,"id":240145,"goal":"predicate SubsetOf_3458(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_3459","instance":3459,"id":240146,"goal":"predicate AllMem_3459(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_3460","instance":3460,"id":240147,"goal":"predicate DisjointSets_3460(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_3461","instance":3461,"id":240148,"goal":"predicate Sorted_3461(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_3462","instance":3462,"id":240149,"goal":"predicate AllPositive_3462(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_3463","instance":3463,"id":240150,"goal":"predicate DistinctSeq_3463(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_3464","instance":3464,"id":240151,"goal":"predicate IsSubseq_3464(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_3465","instance":3465,"id":240152,"goal":"predicate IsPermutation_3465(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_3466","instance":3466,"id":240153,"goal":"predicate IsEven_3466(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_3467","instance":3467,"id":240154,"goal":"predicate InRange_3467(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_3468","instance":3468,"id":240155,"goal":"predicate SubsetOf_3468(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_3469","instance":3469,"id":240156,"goal":"predicate AllMem_3469(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_3470","instance":3470,"id":240157,"goal":"predicate DisjointSets_3470(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_3471","instance":3471,"id":240158,"goal":"predicate Sorted_3471(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_3472","instance":3472,"id":240159,"goal":"predicate AllPositive_3472(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_3473","instance":3473,"id":240160,"goal":"predicate DistinctSeq_3473(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_3474","instance":3474,"id":240161,"goal":"predicate IsSubseq_3474(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_3475","instance":3475,"id":240162,"goal":"predicate IsPermutation_3475(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_3476","instance":3476,"id":240163,"goal":"predicate IsEven_3476(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_3477","instance":3477,"id":240164,"goal":"predicate InRange_3477(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_3478","instance":3478,"id":240165,"goal":"predicate SubsetOf_3478(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_3479","instance":3479,"id":240166,"goal":"predicate AllMem_3479(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_3480","instance":3480,"id":240167,"goal":"predicate DisjointSets_3480(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_3481","instance":3481,"id":240168,"goal":"predicate Sorted_3481(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_3482","instance":3482,"id":240169,"goal":"predicate AllPositive_3482(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_3483","instance":3483,"id":240170,"goal":"predicate DistinctSeq_3483(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_3484","instance":3484,"id":240171,"goal":"predicate IsSubseq_3484(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_3485","instance":3485,"id":240172,"goal":"predicate IsPermutation_3485(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_3486","instance":3486,"id":240173,"goal":"predicate IsEven_3486(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_3487","instance":3487,"id":240174,"goal":"predicate InRange_3487(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_3488","instance":3488,"id":240175,"goal":"predicate SubsetOf_3488(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_3489","instance":3489,"id":240176,"goal":"predicate AllMem_3489(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_3490","instance":3490,"id":240177,"goal":"predicate DisjointSets_3490(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_3491","instance":3491,"id":240178,"goal":"predicate Sorted_3491(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_3492","instance":3492,"id":240179,"goal":"predicate AllPositive_3492(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_3493","instance":3493,"id":240180,"goal":"predicate DistinctSeq_3493(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_3494","instance":3494,"id":240181,"goal":"predicate IsSubseq_3494(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_3495","instance":3495,"id":240182,"goal":"predicate IsPermutation_3495(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_3496","instance":3496,"id":240183,"goal":"predicate IsEven_3496(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_3497","instance":3497,"id":240184,"goal":"predicate InRange_3497(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_3498","instance":3498,"id":240185,"goal":"predicate SubsetOf_3498(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_3499","instance":3499,"id":240186,"goal":"predicate AllMem_3499(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_3500","instance":3500,"id":240187,"goal":"predicate DisjointSets_3500(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_3501","instance":3501,"id":240188,"goal":"predicate Sorted_3501(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_3502","instance":3502,"id":240189,"goal":"predicate AllPositive_3502(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_3503","instance":3503,"id":240190,"goal":"predicate DistinctSeq_3503(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_3504","instance":3504,"id":240191,"goal":"predicate IsSubseq_3504(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_3505","instance":3505,"id":240192,"goal":"predicate IsPermutation_3505(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_3506","instance":3506,"id":240193,"goal":"predicate IsEven_3506(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_3507","instance":3507,"id":240194,"goal":"predicate InRange_3507(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_3508","instance":3508,"id":240195,"goal":"predicate SubsetOf_3508(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_3509","instance":3509,"id":240196,"goal":"predicate AllMem_3509(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_3510","instance":3510,"id":240197,"goal":"predicate DisjointSets_3510(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_3511","instance":3511,"id":240198,"goal":"predicate Sorted_3511(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_3512","instance":3512,"id":240199,"goal":"predicate AllPositive_3512(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_3513","instance":3513,"id":240200,"goal":"predicate DistinctSeq_3513(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_3514","instance":3514,"id":240201,"goal":"predicate IsSubseq_3514(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_3515","instance":3515,"id":240202,"goal":"predicate IsPermutation_3515(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_3516","instance":3516,"id":240203,"goal":"predicate IsEven_3516(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_3517","instance":3517,"id":240204,"goal":"predicate InRange_3517(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_3518","instance":3518,"id":240205,"goal":"predicate SubsetOf_3518(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_3519","instance":3519,"id":240206,"goal":"predicate AllMem_3519(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_3520","instance":3520,"id":240207,"goal":"predicate DisjointSets_3520(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_3521","instance":3521,"id":240208,"goal":"predicate Sorted_3521(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_3522","instance":3522,"id":240209,"goal":"predicate AllPositive_3522(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_3523","instance":3523,"id":240210,"goal":"predicate DistinctSeq_3523(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_3524","instance":3524,"id":240211,"goal":"predicate IsSubseq_3524(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_3525","instance":3525,"id":240212,"goal":"predicate IsPermutation_3525(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_3526","instance":3526,"id":240213,"goal":"predicate IsEven_3526(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_3527","instance":3527,"id":240214,"goal":"predicate InRange_3527(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_3528","instance":3528,"id":240215,"goal":"predicate SubsetOf_3528(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_3529","instance":3529,"id":240216,"goal":"predicate AllMem_3529(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_3530","instance":3530,"id":240217,"goal":"predicate DisjointSets_3530(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_3531","instance":3531,"id":240218,"goal":"predicate Sorted_3531(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_3532","instance":3532,"id":240219,"goal":"predicate AllPositive_3532(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_3533","instance":3533,"id":240220,"goal":"predicate DistinctSeq_3533(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_3534","instance":3534,"id":240221,"goal":"predicate IsSubseq_3534(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_3535","instance":3535,"id":240222,"goal":"predicate IsPermutation_3535(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_3536","instance":3536,"id":240223,"goal":"predicate IsEven_3536(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_3537","instance":3537,"id":240224,"goal":"predicate InRange_3537(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_3538","instance":3538,"id":240225,"goal":"predicate SubsetOf_3538(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_3539","instance":3539,"id":240226,"goal":"predicate AllMem_3539(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_3540","instance":3540,"id":240227,"goal":"predicate DisjointSets_3540(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_3541","instance":3541,"id":240228,"goal":"predicate Sorted_3541(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_3542","instance":3542,"id":240229,"goal":"predicate AllPositive_3542(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_3543","instance":3543,"id":240230,"goal":"predicate DistinctSeq_3543(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_3544","instance":3544,"id":240231,"goal":"predicate IsSubseq_3544(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_3545","instance":3545,"id":240232,"goal":"predicate IsPermutation_3545(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_3546","instance":3546,"id":240233,"goal":"predicate IsEven_3546(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_3547","instance":3547,"id":240234,"goal":"predicate InRange_3547(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_3548","instance":3548,"id":240235,"goal":"predicate SubsetOf_3548(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_3549","instance":3549,"id":240236,"goal":"predicate AllMem_3549(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_3550","instance":3550,"id":240237,"goal":"predicate DisjointSets_3550(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_3551","instance":3551,"id":240238,"goal":"predicate Sorted_3551(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_3552","instance":3552,"id":240239,"goal":"predicate AllPositive_3552(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_3553","instance":3553,"id":240240,"goal":"predicate DistinctSeq_3553(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_3554","instance":3554,"id":240241,"goal":"predicate IsSubseq_3554(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_3555","instance":3555,"id":240242,"goal":"predicate IsPermutation_3555(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_3556","instance":3556,"id":240243,"goal":"predicate IsEven_3556(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_3557","instance":3557,"id":240244,"goal":"predicate InRange_3557(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_3558","instance":3558,"id":240245,"goal":"predicate SubsetOf_3558(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_3559","instance":3559,"id":240246,"goal":"predicate AllMem_3559(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_3560","instance":3560,"id":240247,"goal":"predicate DisjointSets_3560(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_3561","instance":3561,"id":240248,"goal":"predicate Sorted_3561(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_3562","instance":3562,"id":240249,"goal":"predicate AllPositive_3562(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_3563","instance":3563,"id":240250,"goal":"predicate DistinctSeq_3563(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_3564","instance":3564,"id":240251,"goal":"predicate IsSubseq_3564(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_3565","instance":3565,"id":240252,"goal":"predicate IsPermutation_3565(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_3566","instance":3566,"id":240253,"goal":"predicate IsEven_3566(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_3567","instance":3567,"id":240254,"goal":"predicate InRange_3567(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_3568","instance":3568,"id":240255,"goal":"predicate SubsetOf_3568(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_3569","instance":3569,"id":240256,"goal":"predicate AllMem_3569(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_3570","instance":3570,"id":240257,"goal":"predicate DisjointSets_3570(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_3571","instance":3571,"id":240258,"goal":"predicate Sorted_3571(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_3572","instance":3572,"id":240259,"goal":"predicate AllPositive_3572(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_3573","instance":3573,"id":240260,"goal":"predicate DistinctSeq_3573(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_3574","instance":3574,"id":240261,"goal":"predicate IsSubseq_3574(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_3575","instance":3575,"id":240262,"goal":"predicate IsPermutation_3575(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_3576","instance":3576,"id":240263,"goal":"predicate IsEven_3576(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_3577","instance":3577,"id":240264,"goal":"predicate InRange_3577(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_3578","instance":3578,"id":240265,"goal":"predicate SubsetOf_3578(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_3579","instance":3579,"id":240266,"goal":"predicate AllMem_3579(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_3580","instance":3580,"id":240267,"goal":"predicate DisjointSets_3580(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_3581","instance":3581,"id":240268,"goal":"predicate Sorted_3581(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_3582","instance":3582,"id":240269,"goal":"predicate AllPositive_3582(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_3583","instance":3583,"id":240270,"goal":"predicate DistinctSeq_3583(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_3584","instance":3584,"id":240271,"goal":"predicate IsSubseq_3584(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_3585","instance":3585,"id":240272,"goal":"predicate IsPermutation_3585(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_3586","instance":3586,"id":240273,"goal":"predicate IsEven_3586(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_3587","instance":3587,"id":240274,"goal":"predicate InRange_3587(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_3588","instance":3588,"id":240275,"goal":"predicate SubsetOf_3588(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_3589","instance":3589,"id":240276,"goal":"predicate AllMem_3589(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_3590","instance":3590,"id":240277,"goal":"predicate DisjointSets_3590(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_3591","instance":3591,"id":240278,"goal":"predicate Sorted_3591(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_3592","instance":3592,"id":240279,"goal":"predicate AllPositive_3592(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_3593","instance":3593,"id":240280,"goal":"predicate DistinctSeq_3593(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_3594","instance":3594,"id":240281,"goal":"predicate IsSubseq_3594(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_3595","instance":3595,"id":240282,"goal":"predicate IsPermutation_3595(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_3596","instance":3596,"id":240283,"goal":"predicate IsEven_3596(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_3597","instance":3597,"id":240284,"goal":"predicate InRange_3597(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_3598","instance":3598,"id":240285,"goal":"predicate SubsetOf_3598(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_3599","instance":3599,"id":240286,"goal":"predicate AllMem_3599(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_3600","instance":3600,"id":240287,"goal":"predicate DisjointSets_3600(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_3601","instance":3601,"id":240288,"goal":"predicate Sorted_3601(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_3602","instance":3602,"id":240289,"goal":"predicate AllPositive_3602(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_3603","instance":3603,"id":240290,"goal":"predicate DistinctSeq_3603(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_3604","instance":3604,"id":240291,"goal":"predicate IsSubseq_3604(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_3605","instance":3605,"id":240292,"goal":"predicate IsPermutation_3605(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_3606","instance":3606,"id":240293,"goal":"predicate IsEven_3606(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_3607","instance":3607,"id":240294,"goal":"predicate InRange_3607(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_3608","instance":3608,"id":240295,"goal":"predicate SubsetOf_3608(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_3609","instance":3609,"id":240296,"goal":"predicate AllMem_3609(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_3610","instance":3610,"id":240297,"goal":"predicate DisjointSets_3610(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_3611","instance":3611,"id":240298,"goal":"predicate Sorted_3611(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_3612","instance":3612,"id":240299,"goal":"predicate AllPositive_3612(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_3613","instance":3613,"id":240300,"goal":"predicate DistinctSeq_3613(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_3614","instance":3614,"id":240301,"goal":"predicate IsSubseq_3614(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_3615","instance":3615,"id":240302,"goal":"predicate IsPermutation_3615(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_3616","instance":3616,"id":240303,"goal":"predicate IsEven_3616(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_3617","instance":3617,"id":240304,"goal":"predicate InRange_3617(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_3618","instance":3618,"id":240305,"goal":"predicate SubsetOf_3618(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_3619","instance":3619,"id":240306,"goal":"predicate AllMem_3619(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_3620","instance":3620,"id":240307,"goal":"predicate DisjointSets_3620(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_3621","instance":3621,"id":240308,"goal":"predicate Sorted_3621(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_3622","instance":3622,"id":240309,"goal":"predicate AllPositive_3622(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_3623","instance":3623,"id":240310,"goal":"predicate DistinctSeq_3623(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_3624","instance":3624,"id":240311,"goal":"predicate IsSubseq_3624(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_3625","instance":3625,"id":240312,"goal":"predicate IsPermutation_3625(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_3626","instance":3626,"id":240313,"goal":"predicate IsEven_3626(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_3627","instance":3627,"id":240314,"goal":"predicate InRange_3627(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_3628","instance":3628,"id":240315,"goal":"predicate SubsetOf_3628(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_3629","instance":3629,"id":240316,"goal":"predicate AllMem_3629(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_3630","instance":3630,"id":240317,"goal":"predicate DisjointSets_3630(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_3631","instance":3631,"id":240318,"goal":"predicate Sorted_3631(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_3632","instance":3632,"id":240319,"goal":"predicate AllPositive_3632(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_3633","instance":3633,"id":240320,"goal":"predicate DistinctSeq_3633(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_3634","instance":3634,"id":240321,"goal":"predicate IsSubseq_3634(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_3635","instance":3635,"id":240322,"goal":"predicate IsPermutation_3635(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_3636","instance":3636,"id":240323,"goal":"predicate IsEven_3636(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_3637","instance":3637,"id":240324,"goal":"predicate InRange_3637(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_3638","instance":3638,"id":240325,"goal":"predicate SubsetOf_3638(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_3639","instance":3639,"id":240326,"goal":"predicate AllMem_3639(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_3640","instance":3640,"id":240327,"goal":"predicate DisjointSets_3640(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_3641","instance":3641,"id":240328,"goal":"predicate Sorted_3641(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_3642","instance":3642,"id":240329,"goal":"predicate AllPositive_3642(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_3643","instance":3643,"id":240330,"goal":"predicate DistinctSeq_3643(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_3644","instance":3644,"id":240331,"goal":"predicate IsSubseq_3644(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_3645","instance":3645,"id":240332,"goal":"predicate IsPermutation_3645(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_3646","instance":3646,"id":240333,"goal":"predicate IsEven_3646(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_3647","instance":3647,"id":240334,"goal":"predicate InRange_3647(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_3648","instance":3648,"id":240335,"goal":"predicate SubsetOf_3648(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_3649","instance":3649,"id":240336,"goal":"predicate AllMem_3649(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_3650","instance":3650,"id":240337,"goal":"predicate DisjointSets_3650(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_3651","instance":3651,"id":240338,"goal":"predicate Sorted_3651(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_3652","instance":3652,"id":240339,"goal":"predicate AllPositive_3652(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_3653","instance":3653,"id":240340,"goal":"predicate DistinctSeq_3653(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_3654","instance":3654,"id":240341,"goal":"predicate IsSubseq_3654(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_3655","instance":3655,"id":240342,"goal":"predicate IsPermutation_3655(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_3656","instance":3656,"id":240343,"goal":"predicate IsEven_3656(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_3657","instance":3657,"id":240344,"goal":"predicate InRange_3657(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_3658","instance":3658,"id":240345,"goal":"predicate SubsetOf_3658(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_3659","instance":3659,"id":240346,"goal":"predicate AllMem_3659(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_3660","instance":3660,"id":240347,"goal":"predicate DisjointSets_3660(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_3661","instance":3661,"id":240348,"goal":"predicate Sorted_3661(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_3662","instance":3662,"id":240349,"goal":"predicate AllPositive_3662(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_3663","instance":3663,"id":240350,"goal":"predicate DistinctSeq_3663(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_3664","instance":3664,"id":240351,"goal":"predicate IsSubseq_3664(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_3665","instance":3665,"id":240352,"goal":"predicate IsPermutation_3665(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_3666","instance":3666,"id":240353,"goal":"predicate IsEven_3666(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_3667","instance":3667,"id":240354,"goal":"predicate InRange_3667(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_3668","instance":3668,"id":240355,"goal":"predicate SubsetOf_3668(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_3669","instance":3669,"id":240356,"goal":"predicate AllMem_3669(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_3670","instance":3670,"id":240357,"goal":"predicate DisjointSets_3670(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_3671","instance":3671,"id":240358,"goal":"predicate Sorted_3671(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_3672","instance":3672,"id":240359,"goal":"predicate AllPositive_3672(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_3673","instance":3673,"id":240360,"goal":"predicate DistinctSeq_3673(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_3674","instance":3674,"id":240361,"goal":"predicate IsSubseq_3674(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_3675","instance":3675,"id":240362,"goal":"predicate IsPermutation_3675(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_3676","instance":3676,"id":240363,"goal":"predicate IsEven_3676(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_3677","instance":3677,"id":240364,"goal":"predicate InRange_3677(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_3678","instance":3678,"id":240365,"goal":"predicate SubsetOf_3678(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_3679","instance":3679,"id":240366,"goal":"predicate AllMem_3679(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_3680","instance":3680,"id":240367,"goal":"predicate DisjointSets_3680(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_3681","instance":3681,"id":240368,"goal":"predicate Sorted_3681(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_3682","instance":3682,"id":240369,"goal":"predicate AllPositive_3682(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_3683","instance":3683,"id":240370,"goal":"predicate DistinctSeq_3683(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_3684","instance":3684,"id":240371,"goal":"predicate IsSubseq_3684(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_3685","instance":3685,"id":240372,"goal":"predicate IsPermutation_3685(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_3686","instance":3686,"id":240373,"goal":"predicate IsEven_3686(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_3687","instance":3687,"id":240374,"goal":"predicate InRange_3687(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_3688","instance":3688,"id":240375,"goal":"predicate SubsetOf_3688(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_3689","instance":3689,"id":240376,"goal":"predicate AllMem_3689(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_3690","instance":3690,"id":240377,"goal":"predicate DisjointSets_3690(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_3691","instance":3691,"id":240378,"goal":"predicate Sorted_3691(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_3692","instance":3692,"id":240379,"goal":"predicate AllPositive_3692(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_3693","instance":3693,"id":240380,"goal":"predicate DistinctSeq_3693(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_3694","instance":3694,"id":240381,"goal":"predicate IsSubseq_3694(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_3695","instance":3695,"id":240382,"goal":"predicate IsPermutation_3695(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_3696","instance":3696,"id":240383,"goal":"predicate IsEven_3696(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_3697","instance":3697,"id":240384,"goal":"predicate InRange_3697(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_3698","instance":3698,"id":240385,"goal":"predicate SubsetOf_3698(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_3699","instance":3699,"id":240386,"goal":"predicate AllMem_3699(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_3700","instance":3700,"id":240387,"goal":"predicate DisjointSets_3700(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_3701","instance":3701,"id":240388,"goal":"predicate Sorted_3701(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_3702","instance":3702,"id":240389,"goal":"predicate AllPositive_3702(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_3703","instance":3703,"id":240390,"goal":"predicate DistinctSeq_3703(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_3704","instance":3704,"id":240391,"goal":"predicate IsSubseq_3704(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_3705","instance":3705,"id":240392,"goal":"predicate IsPermutation_3705(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_3706","instance":3706,"id":240393,"goal":"predicate IsEven_3706(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_3707","instance":3707,"id":240394,"goal":"predicate InRange_3707(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_3708","instance":3708,"id":240395,"goal":"predicate SubsetOf_3708(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_3709","instance":3709,"id":240396,"goal":"predicate AllMem_3709(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_3710","instance":3710,"id":240397,"goal":"predicate DisjointSets_3710(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_3711","instance":3711,"id":240398,"goal":"predicate Sorted_3711(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_3712","instance":3712,"id":240399,"goal":"predicate AllPositive_3712(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_3713","instance":3713,"id":240400,"goal":"predicate DistinctSeq_3713(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_3714","instance":3714,"id":240401,"goal":"predicate IsSubseq_3714(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_3715","instance":3715,"id":240402,"goal":"predicate IsPermutation_3715(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_3716","instance":3716,"id":240403,"goal":"predicate IsEven_3716(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_3717","instance":3717,"id":240404,"goal":"predicate InRange_3717(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_3718","instance":3718,"id":240405,"goal":"predicate SubsetOf_3718(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_3719","instance":3719,"id":240406,"goal":"predicate AllMem_3719(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_3720","instance":3720,"id":240407,"goal":"predicate DisjointSets_3720(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_3721","instance":3721,"id":240408,"goal":"predicate Sorted_3721(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_3722","instance":3722,"id":240409,"goal":"predicate AllPositive_3722(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_3723","instance":3723,"id":240410,"goal":"predicate DistinctSeq_3723(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_3724","instance":3724,"id":240411,"goal":"predicate IsSubseq_3724(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_3725","instance":3725,"id":240412,"goal":"predicate IsPermutation_3725(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_3726","instance":3726,"id":240413,"goal":"predicate IsEven_3726(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_3727","instance":3727,"id":240414,"goal":"predicate InRange_3727(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_3728","instance":3728,"id":240415,"goal":"predicate SubsetOf_3728(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_3729","instance":3729,"id":240416,"goal":"predicate AllMem_3729(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_3730","instance":3730,"id":240417,"goal":"predicate DisjointSets_3730(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_3731","instance":3731,"id":240418,"goal":"predicate Sorted_3731(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_3732","instance":3732,"id":240419,"goal":"predicate AllPositive_3732(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_3733","instance":3733,"id":240420,"goal":"predicate DistinctSeq_3733(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_3734","instance":3734,"id":240421,"goal":"predicate IsSubseq_3734(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_3735","instance":3735,"id":240422,"goal":"predicate IsPermutation_3735(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_3736","instance":3736,"id":240423,"goal":"predicate IsEven_3736(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_3737","instance":3737,"id":240424,"goal":"predicate InRange_3737(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_3738","instance":3738,"id":240425,"goal":"predicate SubsetOf_3738(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_3739","instance":3739,"id":240426,"goal":"predicate AllMem_3739(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_3740","instance":3740,"id":240427,"goal":"predicate DisjointSets_3740(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_3741","instance":3741,"id":240428,"goal":"predicate Sorted_3741(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_3742","instance":3742,"id":240429,"goal":"predicate AllPositive_3742(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_3743","instance":3743,"id":240430,"goal":"predicate DistinctSeq_3743(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_3744","instance":3744,"id":240431,"goal":"predicate IsSubseq_3744(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_3745","instance":3745,"id":240432,"goal":"predicate IsPermutation_3745(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_3746","instance":3746,"id":240433,"goal":"predicate IsEven_3746(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_3747","instance":3747,"id":240434,"goal":"predicate InRange_3747(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_3748","instance":3748,"id":240435,"goal":"predicate SubsetOf_3748(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_3749","instance":3749,"id":240436,"goal":"predicate AllMem_3749(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_3750","instance":3750,"id":240437,"goal":"predicate DisjointSets_3750(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_3751","instance":3751,"id":240438,"goal":"predicate Sorted_3751(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_3752","instance":3752,"id":240439,"goal":"predicate AllPositive_3752(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_3753","instance":3753,"id":240440,"goal":"predicate DistinctSeq_3753(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_3754","instance":3754,"id":240441,"goal":"predicate IsSubseq_3754(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_3755","instance":3755,"id":240442,"goal":"predicate IsPermutation_3755(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_3756","instance":3756,"id":240443,"goal":"predicate IsEven_3756(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_3757","instance":3757,"id":240444,"goal":"predicate InRange_3757(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_3758","instance":3758,"id":240445,"goal":"predicate SubsetOf_3758(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_3759","instance":3759,"id":240446,"goal":"predicate AllMem_3759(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_3760","instance":3760,"id":240447,"goal":"predicate DisjointSets_3760(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_3761","instance":3761,"id":240448,"goal":"predicate Sorted_3761(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_3762","instance":3762,"id":240449,"goal":"predicate AllPositive_3762(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_3763","instance":3763,"id":240450,"goal":"predicate DistinctSeq_3763(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_3764","instance":3764,"id":240451,"goal":"predicate IsSubseq_3764(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_3765","instance":3765,"id":240452,"goal":"predicate IsPermutation_3765(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_3766","instance":3766,"id":240453,"goal":"predicate IsEven_3766(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_3767","instance":3767,"id":240454,"goal":"predicate InRange_3767(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_3768","instance":3768,"id":240455,"goal":"predicate SubsetOf_3768(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_3769","instance":3769,"id":240456,"goal":"predicate AllMem_3769(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_3770","instance":3770,"id":240457,"goal":"predicate DisjointSets_3770(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_3771","instance":3771,"id":240458,"goal":"predicate Sorted_3771(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_3772","instance":3772,"id":240459,"goal":"predicate AllPositive_3772(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_3773","instance":3773,"id":240460,"goal":"predicate DistinctSeq_3773(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_3774","instance":3774,"id":240461,"goal":"predicate IsSubseq_3774(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_3775","instance":3775,"id":240462,"goal":"predicate IsPermutation_3775(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_3776","instance":3776,"id":240463,"goal":"predicate IsEven_3776(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_3777","instance":3777,"id":240464,"goal":"predicate InRange_3777(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_3778","instance":3778,"id":240465,"goal":"predicate SubsetOf_3778(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_3779","instance":3779,"id":240466,"goal":"predicate AllMem_3779(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_3780","instance":3780,"id":240467,"goal":"predicate DisjointSets_3780(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_3781","instance":3781,"id":240468,"goal":"predicate Sorted_3781(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_3782","instance":3782,"id":240469,"goal":"predicate AllPositive_3782(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_3783","instance":3783,"id":240470,"goal":"predicate DistinctSeq_3783(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_3784","instance":3784,"id":240471,"goal":"predicate IsSubseq_3784(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_3785","instance":3785,"id":240472,"goal":"predicate IsPermutation_3785(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_3786","instance":3786,"id":240473,"goal":"predicate IsEven_3786(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_3787","instance":3787,"id":240474,"goal":"predicate InRange_3787(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_3788","instance":3788,"id":240475,"goal":"predicate SubsetOf_3788(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_3789","instance":3789,"id":240476,"goal":"predicate AllMem_3789(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_3790","instance":3790,"id":240477,"goal":"predicate DisjointSets_3790(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_3791","instance":3791,"id":240478,"goal":"predicate Sorted_3791(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_3792","instance":3792,"id":240479,"goal":"predicate AllPositive_3792(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_3793","instance":3793,"id":240480,"goal":"predicate DistinctSeq_3793(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_3794","instance":3794,"id":240481,"goal":"predicate IsSubseq_3794(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_3795","instance":3795,"id":240482,"goal":"predicate IsPermutation_3795(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_3796","instance":3796,"id":240483,"goal":"predicate IsEven_3796(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_3797","instance":3797,"id":240484,"goal":"predicate InRange_3797(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_3798","instance":3798,"id":240485,"goal":"predicate SubsetOf_3798(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_3799","instance":3799,"id":240486,"goal":"predicate AllMem_3799(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_3800","instance":3800,"id":240487,"goal":"predicate DisjointSets_3800(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_3801","instance":3801,"id":240488,"goal":"predicate Sorted_3801(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_3802","instance":3802,"id":240489,"goal":"predicate AllPositive_3802(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_3803","instance":3803,"id":240490,"goal":"predicate DistinctSeq_3803(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_3804","instance":3804,"id":240491,"goal":"predicate IsSubseq_3804(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_3805","instance":3805,"id":240492,"goal":"predicate IsPermutation_3805(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_3806","instance":3806,"id":240493,"goal":"predicate IsEven_3806(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_3807","instance":3807,"id":240494,"goal":"predicate InRange_3807(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_3808","instance":3808,"id":240495,"goal":"predicate SubsetOf_3808(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_3809","instance":3809,"id":240496,"goal":"predicate AllMem_3809(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_3810","instance":3810,"id":240497,"goal":"predicate DisjointSets_3810(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_3811","instance":3811,"id":240498,"goal":"predicate Sorted_3811(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_3812","instance":3812,"id":240499,"goal":"predicate AllPositive_3812(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_3813","instance":3813,"id":240500,"goal":"predicate DistinctSeq_3813(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_3814","instance":3814,"id":240501,"goal":"predicate IsSubseq_3814(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_3815","instance":3815,"id":240502,"goal":"predicate IsPermutation_3815(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_3816","instance":3816,"id":240503,"goal":"predicate IsEven_3816(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_3817","instance":3817,"id":240504,"goal":"predicate InRange_3817(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_3818","instance":3818,"id":240505,"goal":"predicate SubsetOf_3818(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_3819","instance":3819,"id":240506,"goal":"predicate AllMem_3819(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_3820","instance":3820,"id":240507,"goal":"predicate DisjointSets_3820(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_3821","instance":3821,"id":240508,"goal":"predicate Sorted_3821(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_3822","instance":3822,"id":240509,"goal":"predicate AllPositive_3822(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_3823","instance":3823,"id":240510,"goal":"predicate DistinctSeq_3823(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_3824","instance":3824,"id":240511,"goal":"predicate IsSubseq_3824(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_3825","instance":3825,"id":240512,"goal":"predicate IsPermutation_3825(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_3826","instance":3826,"id":240513,"goal":"predicate IsEven_3826(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_3827","instance":3827,"id":240514,"goal":"predicate InRange_3827(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_3828","instance":3828,"id":240515,"goal":"predicate SubsetOf_3828(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_3829","instance":3829,"id":240516,"goal":"predicate AllMem_3829(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_3830","instance":3830,"id":240517,"goal":"predicate DisjointSets_3830(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_3831","instance":3831,"id":240518,"goal":"predicate Sorted_3831(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_3832","instance":3832,"id":240519,"goal":"predicate AllPositive_3832(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_3833","instance":3833,"id":240520,"goal":"predicate DistinctSeq_3833(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_3834","instance":3834,"id":240521,"goal":"predicate IsSubseq_3834(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_3835","instance":3835,"id":240522,"goal":"predicate IsPermutation_3835(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_3836","instance":3836,"id":240523,"goal":"predicate IsEven_3836(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_3837","instance":3837,"id":240524,"goal":"predicate InRange_3837(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_3838","instance":3838,"id":240525,"goal":"predicate SubsetOf_3838(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_3839","instance":3839,"id":240526,"goal":"predicate AllMem_3839(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_3840","instance":3840,"id":240527,"goal":"predicate DisjointSets_3840(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_3841","instance":3841,"id":240528,"goal":"predicate Sorted_3841(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_3842","instance":3842,"id":240529,"goal":"predicate AllPositive_3842(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_3843","instance":3843,"id":240530,"goal":"predicate DistinctSeq_3843(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_3844","instance":3844,"id":240531,"goal":"predicate IsSubseq_3844(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_3845","instance":3845,"id":240532,"goal":"predicate IsPermutation_3845(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_3846","instance":3846,"id":240533,"goal":"predicate IsEven_3846(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_3847","instance":3847,"id":240534,"goal":"predicate InRange_3847(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_3848","instance":3848,"id":240535,"goal":"predicate SubsetOf_3848(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_3849","instance":3849,"id":240536,"goal":"predicate AllMem_3849(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_3850","instance":3850,"id":240537,"goal":"predicate DisjointSets_3850(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_3851","instance":3851,"id":240538,"goal":"predicate Sorted_3851(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_3852","instance":3852,"id":240539,"goal":"predicate AllPositive_3852(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_3853","instance":3853,"id":240540,"goal":"predicate DistinctSeq_3853(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_3854","instance":3854,"id":240541,"goal":"predicate IsSubseq_3854(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_3855","instance":3855,"id":240542,"goal":"predicate IsPermutation_3855(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_3856","instance":3856,"id":240543,"goal":"predicate IsEven_3856(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_3857","instance":3857,"id":240544,"goal":"predicate InRange_3857(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_3858","instance":3858,"id":240545,"goal":"predicate SubsetOf_3858(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_3859","instance":3859,"id":240546,"goal":"predicate AllMem_3859(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_3860","instance":3860,"id":240547,"goal":"predicate DisjointSets_3860(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_3861","instance":3861,"id":240548,"goal":"predicate Sorted_3861(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_3862","instance":3862,"id":240549,"goal":"predicate AllPositive_3862(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_3863","instance":3863,"id":240550,"goal":"predicate DistinctSeq_3863(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_3864","instance":3864,"id":240551,"goal":"predicate IsSubseq_3864(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_3865","instance":3865,"id":240552,"goal":"predicate IsPermutation_3865(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_3866","instance":3866,"id":240553,"goal":"predicate IsEven_3866(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_3867","instance":3867,"id":240554,"goal":"predicate InRange_3867(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_3868","instance":3868,"id":240555,"goal":"predicate SubsetOf_3868(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_3869","instance":3869,"id":240556,"goal":"predicate AllMem_3869(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_3870","instance":3870,"id":240557,"goal":"predicate DisjointSets_3870(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_3871","instance":3871,"id":240558,"goal":"predicate Sorted_3871(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_3872","instance":3872,"id":240559,"goal":"predicate AllPositive_3872(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_3873","instance":3873,"id":240560,"goal":"predicate DistinctSeq_3873(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_3874","instance":3874,"id":240561,"goal":"predicate IsSubseq_3874(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_3875","instance":3875,"id":240562,"goal":"predicate IsPermutation_3875(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_3876","instance":3876,"id":240563,"goal":"predicate IsEven_3876(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_3877","instance":3877,"id":240564,"goal":"predicate InRange_3877(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_3878","instance":3878,"id":240565,"goal":"predicate SubsetOf_3878(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_3879","instance":3879,"id":240566,"goal":"predicate AllMem_3879(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_3880","instance":3880,"id":240567,"goal":"predicate DisjointSets_3880(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_3881","instance":3881,"id":240568,"goal":"predicate Sorted_3881(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_3882","instance":3882,"id":240569,"goal":"predicate AllPositive_3882(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_3883","instance":3883,"id":240570,"goal":"predicate DistinctSeq_3883(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_3884","instance":3884,"id":240571,"goal":"predicate IsSubseq_3884(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_3885","instance":3885,"id":240572,"goal":"predicate IsPermutation_3885(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_3886","instance":3886,"id":240573,"goal":"predicate IsEven_3886(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_3887","instance":3887,"id":240574,"goal":"predicate InRange_3887(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_3888","instance":3888,"id":240575,"goal":"predicate SubsetOf_3888(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_3889","instance":3889,"id":240576,"goal":"predicate AllMem_3889(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_3890","instance":3890,"id":240577,"goal":"predicate DisjointSets_3890(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_3891","instance":3891,"id":240578,"goal":"predicate Sorted_3891(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_3892","instance":3892,"id":240579,"goal":"predicate AllPositive_3892(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_3893","instance":3893,"id":240580,"goal":"predicate DistinctSeq_3893(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_3894","instance":3894,"id":240581,"goal":"predicate IsSubseq_3894(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_3895","instance":3895,"id":240582,"goal":"predicate IsPermutation_3895(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_3896","instance":3896,"id":240583,"goal":"predicate IsEven_3896(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_3897","instance":3897,"id":240584,"goal":"predicate InRange_3897(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_3898","instance":3898,"id":240585,"goal":"predicate SubsetOf_3898(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_3899","instance":3899,"id":240586,"goal":"predicate AllMem_3899(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_3900","instance":3900,"id":240587,"goal":"predicate DisjointSets_3900(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_3901","instance":3901,"id":240588,"goal":"predicate Sorted_3901(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_3902","instance":3902,"id":240589,"goal":"predicate AllPositive_3902(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_3903","instance":3903,"id":240590,"goal":"predicate DistinctSeq_3903(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_3904","instance":3904,"id":240591,"goal":"predicate IsSubseq_3904(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_3905","instance":3905,"id":240592,"goal":"predicate IsPermutation_3905(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_3906","instance":3906,"id":240593,"goal":"predicate IsEven_3906(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_3907","instance":3907,"id":240594,"goal":"predicate InRange_3907(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_3908","instance":3908,"id":240595,"goal":"predicate SubsetOf_3908(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_3909","instance":3909,"id":240596,"goal":"predicate AllMem_3909(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_3910","instance":3910,"id":240597,"goal":"predicate DisjointSets_3910(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_3911","instance":3911,"id":240598,"goal":"predicate Sorted_3911(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_3912","instance":3912,"id":240599,"goal":"predicate AllPositive_3912(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_3913","instance":3913,"id":240600,"goal":"predicate DistinctSeq_3913(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_3914","instance":3914,"id":240601,"goal":"predicate IsSubseq_3914(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_3915","instance":3915,"id":240602,"goal":"predicate IsPermutation_3915(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_3916","instance":3916,"id":240603,"goal":"predicate IsEven_3916(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_3917","instance":3917,"id":240604,"goal":"predicate InRange_3917(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_3918","instance":3918,"id":240605,"goal":"predicate SubsetOf_3918(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_3919","instance":3919,"id":240606,"goal":"predicate AllMem_3919(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_3920","instance":3920,"id":240607,"goal":"predicate DisjointSets_3920(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_3921","instance":3921,"id":240608,"goal":"predicate Sorted_3921(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_3922","instance":3922,"id":240609,"goal":"predicate AllPositive_3922(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_3923","instance":3923,"id":240610,"goal":"predicate DistinctSeq_3923(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_3924","instance":3924,"id":240611,"goal":"predicate IsSubseq_3924(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_3925","instance":3925,"id":240612,"goal":"predicate IsPermutation_3925(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_3926","instance":3926,"id":240613,"goal":"predicate IsEven_3926(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_3927","instance":3927,"id":240614,"goal":"predicate InRange_3927(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_3928","instance":3928,"id":240615,"goal":"predicate SubsetOf_3928(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_3929","instance":3929,"id":240616,"goal":"predicate AllMem_3929(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_3930","instance":3930,"id":240617,"goal":"predicate DisjointSets_3930(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_3931","instance":3931,"id":240618,"goal":"predicate Sorted_3931(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_3932","instance":3932,"id":240619,"goal":"predicate AllPositive_3932(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_3933","instance":3933,"id":240620,"goal":"predicate DistinctSeq_3933(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_3934","instance":3934,"id":240621,"goal":"predicate IsSubseq_3934(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_3935","instance":3935,"id":240622,"goal":"predicate IsPermutation_3935(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_3936","instance":3936,"id":240623,"goal":"predicate IsEven_3936(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_3937","instance":3937,"id":240624,"goal":"predicate InRange_3937(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_3938","instance":3938,"id":240625,"goal":"predicate SubsetOf_3938(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_3939","instance":3939,"id":240626,"goal":"predicate AllMem_3939(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_3940","instance":3940,"id":240627,"goal":"predicate DisjointSets_3940(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_3941","instance":3941,"id":240628,"goal":"predicate Sorted_3941(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_3942","instance":3942,"id":240629,"goal":"predicate AllPositive_3942(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_3943","instance":3943,"id":240630,"goal":"predicate DistinctSeq_3943(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_3944","instance":3944,"id":240631,"goal":"predicate IsSubseq_3944(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_3945","instance":3945,"id":240632,"goal":"predicate IsPermutation_3945(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_3946","instance":3946,"id":240633,"goal":"predicate IsEven_3946(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_3947","instance":3947,"id":240634,"goal":"predicate InRange_3947(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_3948","instance":3948,"id":240635,"goal":"predicate SubsetOf_3948(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_3949","instance":3949,"id":240636,"goal":"predicate AllMem_3949(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_3950","instance":3950,"id":240637,"goal":"predicate DisjointSets_3950(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_3951","instance":3951,"id":240638,"goal":"predicate Sorted_3951(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_3952","instance":3952,"id":240639,"goal":"predicate AllPositive_3952(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_3953","instance":3953,"id":240640,"goal":"predicate DistinctSeq_3953(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_3954","instance":3954,"id":240641,"goal":"predicate IsSubseq_3954(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_3955","instance":3955,"id":240642,"goal":"predicate IsPermutation_3955(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_3956","instance":3956,"id":240643,"goal":"predicate IsEven_3956(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_3957","instance":3957,"id":240644,"goal":"predicate InRange_3957(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_3958","instance":3958,"id":240645,"goal":"predicate SubsetOf_3958(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_3959","instance":3959,"id":240646,"goal":"predicate AllMem_3959(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_3960","instance":3960,"id":240647,"goal":"predicate DisjointSets_3960(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_3961","instance":3961,"id":240648,"goal":"predicate Sorted_3961(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_3962","instance":3962,"id":240649,"goal":"predicate AllPositive_3962(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_3963","instance":3963,"id":240650,"goal":"predicate DistinctSeq_3963(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_3964","instance":3964,"id":240651,"goal":"predicate IsSubseq_3964(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_3965","instance":3965,"id":240652,"goal":"predicate IsPermutation_3965(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_3966","instance":3966,"id":240653,"goal":"predicate IsEven_3966(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_3967","instance":3967,"id":240654,"goal":"predicate InRange_3967(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_3968","instance":3968,"id":240655,"goal":"predicate SubsetOf_3968(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_3969","instance":3969,"id":240656,"goal":"predicate AllMem_3969(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_3970","instance":3970,"id":240657,"goal":"predicate DisjointSets_3970(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_3971","instance":3971,"id":240658,"goal":"predicate Sorted_3971(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_3972","instance":3972,"id":240659,"goal":"predicate AllPositive_3972(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_3973","instance":3973,"id":240660,"goal":"predicate DistinctSeq_3973(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_3974","instance":3974,"id":240661,"goal":"predicate IsSubseq_3974(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_3975","instance":3975,"id":240662,"goal":"predicate IsPermutation_3975(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_3976","instance":3976,"id":240663,"goal":"predicate IsEven_3976(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_3977","instance":3977,"id":240664,"goal":"predicate InRange_3977(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_3978","instance":3978,"id":240665,"goal":"predicate SubsetOf_3978(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_3979","instance":3979,"id":240666,"goal":"predicate AllMem_3979(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_3980","instance":3980,"id":240667,"goal":"predicate DisjointSets_3980(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_3981","instance":3981,"id":240668,"goal":"predicate Sorted_3981(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_3982","instance":3982,"id":240669,"goal":"predicate AllPositive_3982(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_3983","instance":3983,"id":240670,"goal":"predicate DistinctSeq_3983(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_3984","instance":3984,"id":240671,"goal":"predicate IsSubseq_3984(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_3985","instance":3985,"id":240672,"goal":"predicate IsPermutation_3985(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_3986","instance":3986,"id":240673,"goal":"predicate IsEven_3986(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_3987","instance":3987,"id":240674,"goal":"predicate InRange_3987(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_3988","instance":3988,"id":240675,"goal":"predicate SubsetOf_3988(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_3989","instance":3989,"id":240676,"goal":"predicate AllMem_3989(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_3990","instance":3990,"id":240677,"goal":"predicate DisjointSets_3990(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_3991","instance":3991,"id":240678,"goal":"predicate Sorted_3991(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_3992","instance":3992,"id":240679,"goal":"predicate AllPositive_3992(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_3993","instance":3993,"id":240680,"goal":"predicate DistinctSeq_3993(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_3994","instance":3994,"id":240681,"goal":"predicate IsSubseq_3994(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_3995","instance":3995,"id":240682,"goal":"predicate IsPermutation_3995(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_3996","instance":3996,"id":240683,"goal":"predicate IsEven_3996(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_3997","instance":3997,"id":240684,"goal":"predicate InRange_3997(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_3998","instance":3998,"id":240685,"goal":"predicate SubsetOf_3998(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_3999","instance":3999,"id":240686,"goal":"predicate AllMem_3999(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_4000","instance":4000,"id":240687,"goal":"predicate DisjointSets_4000(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_4001","instance":4001,"id":240688,"goal":"predicate Sorted_4001(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_4002","instance":4002,"id":240689,"goal":"predicate AllPositive_4002(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_4003","instance":4003,"id":240690,"goal":"predicate DistinctSeq_4003(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_4004","instance":4004,"id":240691,"goal":"predicate IsSubseq_4004(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_4005","instance":4005,"id":240692,"goal":"predicate IsPermutation_4005(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_4006","instance":4006,"id":240693,"goal":"predicate IsEven_4006(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_4007","instance":4007,"id":240694,"goal":"predicate InRange_4007(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_4008","instance":4008,"id":240695,"goal":"predicate SubsetOf_4008(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_4009","instance":4009,"id":240696,"goal":"predicate AllMem_4009(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_4010","instance":4010,"id":240697,"goal":"predicate DisjointSets_4010(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_4011","instance":4011,"id":240698,"goal":"predicate Sorted_4011(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_4012","instance":4012,"id":240699,"goal":"predicate AllPositive_4012(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_4013","instance":4013,"id":240700,"goal":"predicate DistinctSeq_4013(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_4014","instance":4014,"id":240701,"goal":"predicate IsSubseq_4014(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_4015","instance":4015,"id":240702,"goal":"predicate IsPermutation_4015(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_4016","instance":4016,"id":240703,"goal":"predicate IsEven_4016(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_4017","instance":4017,"id":240704,"goal":"predicate InRange_4017(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_4018","instance":4018,"id":240705,"goal":"predicate SubsetOf_4018(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_4019","instance":4019,"id":240706,"goal":"predicate AllMem_4019(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_4020","instance":4020,"id":240707,"goal":"predicate DisjointSets_4020(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_4021","instance":4021,"id":240708,"goal":"predicate Sorted_4021(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_4022","instance":4022,"id":240709,"goal":"predicate AllPositive_4022(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_4023","instance":4023,"id":240710,"goal":"predicate DistinctSeq_4023(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_4024","instance":4024,"id":240711,"goal":"predicate IsSubseq_4024(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_4025","instance":4025,"id":240712,"goal":"predicate IsPermutation_4025(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_4026","instance":4026,"id":240713,"goal":"predicate IsEven_4026(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_4027","instance":4027,"id":240714,"goal":"predicate InRange_4027(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_4028","instance":4028,"id":240715,"goal":"predicate SubsetOf_4028(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_4029","instance":4029,"id":240716,"goal":"predicate AllMem_4029(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_4030","instance":4030,"id":240717,"goal":"predicate DisjointSets_4030(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_4031","instance":4031,"id":240718,"goal":"predicate Sorted_4031(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_4032","instance":4032,"id":240719,"goal":"predicate AllPositive_4032(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_4033","instance":4033,"id":240720,"goal":"predicate DistinctSeq_4033(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_4034","instance":4034,"id":240721,"goal":"predicate IsSubseq_4034(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_4035","instance":4035,"id":240722,"goal":"predicate IsPermutation_4035(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_4036","instance":4036,"id":240723,"goal":"predicate IsEven_4036(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_4037","instance":4037,"id":240724,"goal":"predicate InRange_4037(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_4038","instance":4038,"id":240725,"goal":"predicate SubsetOf_4038(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_4039","instance":4039,"id":240726,"goal":"predicate AllMem_4039(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_4040","instance":4040,"id":240727,"goal":"predicate DisjointSets_4040(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_4041","instance":4041,"id":240728,"goal":"predicate Sorted_4041(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_4042","instance":4042,"id":240729,"goal":"predicate AllPositive_4042(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_4043","instance":4043,"id":240730,"goal":"predicate DistinctSeq_4043(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_4044","instance":4044,"id":240731,"goal":"predicate IsSubseq_4044(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_4045","instance":4045,"id":240732,"goal":"predicate IsPermutation_4045(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_4046","instance":4046,"id":240733,"goal":"predicate IsEven_4046(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_4047","instance":4047,"id":240734,"goal":"predicate InRange_4047(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_4048","instance":4048,"id":240735,"goal":"predicate SubsetOf_4048(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_4049","instance":4049,"id":240736,"goal":"predicate AllMem_4049(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_4050","instance":4050,"id":240737,"goal":"predicate DisjointSets_4050(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_4051","instance":4051,"id":240738,"goal":"predicate Sorted_4051(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_4052","instance":4052,"id":240739,"goal":"predicate AllPositive_4052(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_4053","instance":4053,"id":240740,"goal":"predicate DistinctSeq_4053(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_4054","instance":4054,"id":240741,"goal":"predicate IsSubseq_4054(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_4055","instance":4055,"id":240742,"goal":"predicate IsPermutation_4055(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_4056","instance":4056,"id":240743,"goal":"predicate IsEven_4056(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_4057","instance":4057,"id":240744,"goal":"predicate InRange_4057(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_4058","instance":4058,"id":240745,"goal":"predicate SubsetOf_4058(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_4059","instance":4059,"id":240746,"goal":"predicate AllMem_4059(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_4060","instance":4060,"id":240747,"goal":"predicate DisjointSets_4060(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_4061","instance":4061,"id":240748,"goal":"predicate Sorted_4061(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_4062","instance":4062,"id":240749,"goal":"predicate AllPositive_4062(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_4063","instance":4063,"id":240750,"goal":"predicate DistinctSeq_4063(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_4064","instance":4064,"id":240751,"goal":"predicate IsSubseq_4064(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_4065","instance":4065,"id":240752,"goal":"predicate IsPermutation_4065(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_4066","instance":4066,"id":240753,"goal":"predicate IsEven_4066(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_4067","instance":4067,"id":240754,"goal":"predicate InRange_4067(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_4068","instance":4068,"id":240755,"goal":"predicate SubsetOf_4068(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_4069","instance":4069,"id":240756,"goal":"predicate AllMem_4069(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_4070","instance":4070,"id":240757,"goal":"predicate DisjointSets_4070(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_4071","instance":4071,"id":240758,"goal":"predicate Sorted_4071(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_4072","instance":4072,"id":240759,"goal":"predicate AllPositive_4072(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_4073","instance":4073,"id":240760,"goal":"predicate DistinctSeq_4073(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_4074","instance":4074,"id":240761,"goal":"predicate IsSubseq_4074(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_4075","instance":4075,"id":240762,"goal":"predicate IsPermutation_4075(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_4076","instance":4076,"id":240763,"goal":"predicate IsEven_4076(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_4077","instance":4077,"id":240764,"goal":"predicate InRange_4077(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_4078","instance":4078,"id":240765,"goal":"predicate SubsetOf_4078(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_4079","instance":4079,"id":240766,"goal":"predicate AllMem_4079(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_4080","instance":4080,"id":240767,"goal":"predicate DisjointSets_4080(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_4081","instance":4081,"id":240768,"goal":"predicate Sorted_4081(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_4082","instance":4082,"id":240769,"goal":"predicate AllPositive_4082(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_4083","instance":4083,"id":240770,"goal":"predicate DistinctSeq_4083(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_4084","instance":4084,"id":240771,"goal":"predicate IsSubseq_4084(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_4085","instance":4085,"id":240772,"goal":"predicate IsPermutation_4085(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_4086","instance":4086,"id":240773,"goal":"predicate IsEven_4086(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_4087","instance":4087,"id":240774,"goal":"predicate InRange_4087(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_4088","instance":4088,"id":240775,"goal":"predicate SubsetOf_4088(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_4089","instance":4089,"id":240776,"goal":"predicate AllMem_4089(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_4090","instance":4090,"id":240777,"goal":"predicate DisjointSets_4090(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_4091","instance":4091,"id":240778,"goal":"predicate Sorted_4091(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_4092","instance":4092,"id":240779,"goal":"predicate AllPositive_4092(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_4093","instance":4093,"id":240780,"goal":"predicate DistinctSeq_4093(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_4094","instance":4094,"id":240781,"goal":"predicate IsSubseq_4094(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_4095","instance":4095,"id":240782,"goal":"predicate IsPermutation_4095(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_4096","instance":4096,"id":240783,"goal":"predicate IsEven_4096(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_4097","instance":4097,"id":240784,"goal":"predicate InRange_4097(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_4098","instance":4098,"id":240785,"goal":"predicate SubsetOf_4098(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_4099","instance":4099,"id":240786,"goal":"predicate AllMem_4099(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_4100","instance":4100,"id":240787,"goal":"predicate DisjointSets_4100(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_4101","instance":4101,"id":240788,"goal":"predicate Sorted_4101(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_4102","instance":4102,"id":240789,"goal":"predicate AllPositive_4102(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_4103","instance":4103,"id":240790,"goal":"predicate DistinctSeq_4103(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_4104","instance":4104,"id":240791,"goal":"predicate IsSubseq_4104(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_4105","instance":4105,"id":240792,"goal":"predicate IsPermutation_4105(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_4106","instance":4106,"id":240793,"goal":"predicate IsEven_4106(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_4107","instance":4107,"id":240794,"goal":"predicate InRange_4107(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_4108","instance":4108,"id":240795,"goal":"predicate SubsetOf_4108(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_4109","instance":4109,"id":240796,"goal":"predicate AllMem_4109(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_4110","instance":4110,"id":240797,"goal":"predicate DisjointSets_4110(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_4111","instance":4111,"id":240798,"goal":"predicate Sorted_4111(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_4112","instance":4112,"id":240799,"goal":"predicate AllPositive_4112(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_4113","instance":4113,"id":240800,"goal":"predicate DistinctSeq_4113(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_4114","instance":4114,"id":240801,"goal":"predicate IsSubseq_4114(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_4115","instance":4115,"id":240802,"goal":"predicate IsPermutation_4115(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_4116","instance":4116,"id":240803,"goal":"predicate IsEven_4116(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_4117","instance":4117,"id":240804,"goal":"predicate InRange_4117(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_4118","instance":4118,"id":240805,"goal":"predicate SubsetOf_4118(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_4119","instance":4119,"id":240806,"goal":"predicate AllMem_4119(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_4120","instance":4120,"id":240807,"goal":"predicate DisjointSets_4120(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_4121","instance":4121,"id":240808,"goal":"predicate Sorted_4121(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_4122","instance":4122,"id":240809,"goal":"predicate AllPositive_4122(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_4123","instance":4123,"id":240810,"goal":"predicate DistinctSeq_4123(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_4124","instance":4124,"id":240811,"goal":"predicate IsSubseq_4124(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_4125","instance":4125,"id":240812,"goal":"predicate IsPermutation_4125(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_4126","instance":4126,"id":240813,"goal":"predicate IsEven_4126(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_4127","instance":4127,"id":240814,"goal":"predicate InRange_4127(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_4128","instance":4128,"id":240815,"goal":"predicate SubsetOf_4128(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_4129","instance":4129,"id":240816,"goal":"predicate AllMem_4129(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_4130","instance":4130,"id":240817,"goal":"predicate DisjointSets_4130(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_4131","instance":4131,"id":240818,"goal":"predicate Sorted_4131(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_4132","instance":4132,"id":240819,"goal":"predicate AllPositive_4132(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_4133","instance":4133,"id":240820,"goal":"predicate DistinctSeq_4133(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_4134","instance":4134,"id":240821,"goal":"predicate IsSubseq_4134(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_4135","instance":4135,"id":240822,"goal":"predicate IsPermutation_4135(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_4136","instance":4136,"id":240823,"goal":"predicate IsEven_4136(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_4137","instance":4137,"id":240824,"goal":"predicate InRange_4137(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_4138","instance":4138,"id":240825,"goal":"predicate SubsetOf_4138(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_4139","instance":4139,"id":240826,"goal":"predicate AllMem_4139(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_4140","instance":4140,"id":240827,"goal":"predicate DisjointSets_4140(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_4141","instance":4141,"id":240828,"goal":"predicate Sorted_4141(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_4142","instance":4142,"id":240829,"goal":"predicate AllPositive_4142(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_4143","instance":4143,"id":240830,"goal":"predicate DistinctSeq_4143(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_4144","instance":4144,"id":240831,"goal":"predicate IsSubseq_4144(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_4145","instance":4145,"id":240832,"goal":"predicate IsPermutation_4145(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_4146","instance":4146,"id":240833,"goal":"predicate IsEven_4146(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_4147","instance":4147,"id":240834,"goal":"predicate InRange_4147(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_4148","instance":4148,"id":240835,"goal":"predicate SubsetOf_4148(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_4149","instance":4149,"id":240836,"goal":"predicate AllMem_4149(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_4150","instance":4150,"id":240837,"goal":"predicate DisjointSets_4150(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_4151","instance":4151,"id":240838,"goal":"predicate Sorted_4151(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_4152","instance":4152,"id":240839,"goal":"predicate AllPositive_4152(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_4153","instance":4153,"id":240840,"goal":"predicate DistinctSeq_4153(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_4154","instance":4154,"id":240841,"goal":"predicate IsSubseq_4154(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_4155","instance":4155,"id":240842,"goal":"predicate IsPermutation_4155(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_4156","instance":4156,"id":240843,"goal":"predicate IsEven_4156(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_4157","instance":4157,"id":240844,"goal":"predicate InRange_4157(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_4158","instance":4158,"id":240845,"goal":"predicate SubsetOf_4158(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_4159","instance":4159,"id":240846,"goal":"predicate AllMem_4159(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_4160","instance":4160,"id":240847,"goal":"predicate DisjointSets_4160(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_4161","instance":4161,"id":240848,"goal":"predicate Sorted_4161(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_4162","instance":4162,"id":240849,"goal":"predicate AllPositive_4162(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_4163","instance":4163,"id":240850,"goal":"predicate DistinctSeq_4163(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_4164","instance":4164,"id":240851,"goal":"predicate IsSubseq_4164(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_4165","instance":4165,"id":240852,"goal":"predicate IsPermutation_4165(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_4166","instance":4166,"id":240853,"goal":"predicate IsEven_4166(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_4167","instance":4167,"id":240854,"goal":"predicate InRange_4167(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_4168","instance":4168,"id":240855,"goal":"predicate SubsetOf_4168(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_4169","instance":4169,"id":240856,"goal":"predicate AllMem_4169(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_4170","instance":4170,"id":240857,"goal":"predicate DisjointSets_4170(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_4171","instance":4171,"id":240858,"goal":"predicate Sorted_4171(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_4172","instance":4172,"id":240859,"goal":"predicate AllPositive_4172(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_4173","instance":4173,"id":240860,"goal":"predicate DistinctSeq_4173(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_4174","instance":4174,"id":240861,"goal":"predicate IsSubseq_4174(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_4175","instance":4175,"id":240862,"goal":"predicate IsPermutation_4175(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_4176","instance":4176,"id":240863,"goal":"predicate IsEven_4176(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_4177","instance":4177,"id":240864,"goal":"predicate InRange_4177(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_4178","instance":4178,"id":240865,"goal":"predicate SubsetOf_4178(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_4179","instance":4179,"id":240866,"goal":"predicate AllMem_4179(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_4180","instance":4180,"id":240867,"goal":"predicate DisjointSets_4180(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_4181","instance":4181,"id":240868,"goal":"predicate Sorted_4181(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_4182","instance":4182,"id":240869,"goal":"predicate AllPositive_4182(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_4183","instance":4183,"id":240870,"goal":"predicate DistinctSeq_4183(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_4184","instance":4184,"id":240871,"goal":"predicate IsSubseq_4184(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_4185","instance":4185,"id":240872,"goal":"predicate IsPermutation_4185(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_4186","instance":4186,"id":240873,"goal":"predicate IsEven_4186(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_4187","instance":4187,"id":240874,"goal":"predicate InRange_4187(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_4188","instance":4188,"id":240875,"goal":"predicate SubsetOf_4188(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_4189","instance":4189,"id":240876,"goal":"predicate AllMem_4189(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_4190","instance":4190,"id":240877,"goal":"predicate DisjointSets_4190(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_4191","instance":4191,"id":240878,"goal":"predicate Sorted_4191(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_4192","instance":4192,"id":240879,"goal":"predicate AllPositive_4192(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_4193","instance":4193,"id":240880,"goal":"predicate DistinctSeq_4193(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_4194","instance":4194,"id":240881,"goal":"predicate IsSubseq_4194(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_4195","instance":4195,"id":240882,"goal":"predicate IsPermutation_4195(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_4196","instance":4196,"id":240883,"goal":"predicate IsEven_4196(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_4197","instance":4197,"id":240884,"goal":"predicate InRange_4197(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_4198","instance":4198,"id":240885,"goal":"predicate SubsetOf_4198(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_4199","instance":4199,"id":240886,"goal":"predicate AllMem_4199(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_4200","instance":4200,"id":240887,"goal":"predicate DisjointSets_4200(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_4201","instance":4201,"id":240888,"goal":"predicate Sorted_4201(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_4202","instance":4202,"id":240889,"goal":"predicate AllPositive_4202(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_4203","instance":4203,"id":240890,"goal":"predicate DistinctSeq_4203(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_4204","instance":4204,"id":240891,"goal":"predicate IsSubseq_4204(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_4205","instance":4205,"id":240892,"goal":"predicate IsPermutation_4205(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_4206","instance":4206,"id":240893,"goal":"predicate IsEven_4206(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_4207","instance":4207,"id":240894,"goal":"predicate InRange_4207(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_4208","instance":4208,"id":240895,"goal":"predicate SubsetOf_4208(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_4209","instance":4209,"id":240896,"goal":"predicate AllMem_4209(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_4210","instance":4210,"id":240897,"goal":"predicate DisjointSets_4210(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_4211","instance":4211,"id":240898,"goal":"predicate Sorted_4211(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_4212","instance":4212,"id":240899,"goal":"predicate AllPositive_4212(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_4213","instance":4213,"id":240900,"goal":"predicate DistinctSeq_4213(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_4214","instance":4214,"id":240901,"goal":"predicate IsSubseq_4214(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_4215","instance":4215,"id":240902,"goal":"predicate IsPermutation_4215(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_4216","instance":4216,"id":240903,"goal":"predicate IsEven_4216(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_4217","instance":4217,"id":240904,"goal":"predicate InRange_4217(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_4218","instance":4218,"id":240905,"goal":"predicate SubsetOf_4218(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_4219","instance":4219,"id":240906,"goal":"predicate AllMem_4219(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_4220","instance":4220,"id":240907,"goal":"predicate DisjointSets_4220(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_4221","instance":4221,"id":240908,"goal":"predicate Sorted_4221(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_4222","instance":4222,"id":240909,"goal":"predicate AllPositive_4222(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_4223","instance":4223,"id":240910,"goal":"predicate DistinctSeq_4223(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_4224","instance":4224,"id":240911,"goal":"predicate IsSubseq_4224(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_4225","instance":4225,"id":240912,"goal":"predicate IsPermutation_4225(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_4226","instance":4226,"id":240913,"goal":"predicate IsEven_4226(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_4227","instance":4227,"id":240914,"goal":"predicate InRange_4227(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_4228","instance":4228,"id":240915,"goal":"predicate SubsetOf_4228(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_4229","instance":4229,"id":240916,"goal":"predicate AllMem_4229(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_4230","instance":4230,"id":240917,"goal":"predicate DisjointSets_4230(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_4231","instance":4231,"id":240918,"goal":"predicate Sorted_4231(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_4232","instance":4232,"id":240919,"goal":"predicate AllPositive_4232(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_4233","instance":4233,"id":240920,"goal":"predicate DistinctSeq_4233(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_4234","instance":4234,"id":240921,"goal":"predicate IsSubseq_4234(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_4235","instance":4235,"id":240922,"goal":"predicate IsPermutation_4235(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_4236","instance":4236,"id":240923,"goal":"predicate IsEven_4236(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_4237","instance":4237,"id":240924,"goal":"predicate InRange_4237(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_4238","instance":4238,"id":240925,"goal":"predicate SubsetOf_4238(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_4239","instance":4239,"id":240926,"goal":"predicate AllMem_4239(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_4240","instance":4240,"id":240927,"goal":"predicate DisjointSets_4240(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_4241","instance":4241,"id":240928,"goal":"predicate Sorted_4241(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_4242","instance":4242,"id":240929,"goal":"predicate AllPositive_4242(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_4243","instance":4243,"id":240930,"goal":"predicate DistinctSeq_4243(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_4244","instance":4244,"id":240931,"goal":"predicate IsSubseq_4244(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_4245","instance":4245,"id":240932,"goal":"predicate IsPermutation_4245(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_4246","instance":4246,"id":240933,"goal":"predicate IsEven_4246(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_4247","instance":4247,"id":240934,"goal":"predicate InRange_4247(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_4248","instance":4248,"id":240935,"goal":"predicate SubsetOf_4248(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_4249","instance":4249,"id":240936,"goal":"predicate AllMem_4249(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_4250","instance":4250,"id":240937,"goal":"predicate DisjointSets_4250(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_4251","instance":4251,"id":240938,"goal":"predicate Sorted_4251(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_4252","instance":4252,"id":240939,"goal":"predicate AllPositive_4252(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_4253","instance":4253,"id":240940,"goal":"predicate DistinctSeq_4253(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_4254","instance":4254,"id":240941,"goal":"predicate IsSubseq_4254(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_4255","instance":4255,"id":240942,"goal":"predicate IsPermutation_4255(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_4256","instance":4256,"id":240943,"goal":"predicate IsEven_4256(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_4257","instance":4257,"id":240944,"goal":"predicate InRange_4257(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_4258","instance":4258,"id":240945,"goal":"predicate SubsetOf_4258(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_4259","instance":4259,"id":240946,"goal":"predicate AllMem_4259(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_4260","instance":4260,"id":240947,"goal":"predicate DisjointSets_4260(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_4261","instance":4261,"id":240948,"goal":"predicate Sorted_4261(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_4262","instance":4262,"id":240949,"goal":"predicate AllPositive_4262(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_4263","instance":4263,"id":240950,"goal":"predicate DistinctSeq_4263(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_4264","instance":4264,"id":240951,"goal":"predicate IsSubseq_4264(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_4265","instance":4265,"id":240952,"goal":"predicate IsPermutation_4265(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_4266","instance":4266,"id":240953,"goal":"predicate IsEven_4266(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_4267","instance":4267,"id":240954,"goal":"predicate InRange_4267(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_4268","instance":4268,"id":240955,"goal":"predicate SubsetOf_4268(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_4269","instance":4269,"id":240956,"goal":"predicate AllMem_4269(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_4270","instance":4270,"id":240957,"goal":"predicate DisjointSets_4270(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_4271","instance":4271,"id":240958,"goal":"predicate Sorted_4271(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_4272","instance":4272,"id":240959,"goal":"predicate AllPositive_4272(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_4273","instance":4273,"id":240960,"goal":"predicate DistinctSeq_4273(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_4274","instance":4274,"id":240961,"goal":"predicate IsSubseq_4274(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_4275","instance":4275,"id":240962,"goal":"predicate IsPermutation_4275(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_4276","instance":4276,"id":240963,"goal":"predicate IsEven_4276(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_4277","instance":4277,"id":240964,"goal":"predicate InRange_4277(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_4278","instance":4278,"id":240965,"goal":"predicate SubsetOf_4278(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_4279","instance":4279,"id":240966,"goal":"predicate AllMem_4279(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_4280","instance":4280,"id":240967,"goal":"predicate DisjointSets_4280(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_4281","instance":4281,"id":240968,"goal":"predicate Sorted_4281(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_4282","instance":4282,"id":240969,"goal":"predicate AllPositive_4282(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_4283","instance":4283,"id":240970,"goal":"predicate DistinctSeq_4283(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_4284","instance":4284,"id":240971,"goal":"predicate IsSubseq_4284(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_4285","instance":4285,"id":240972,"goal":"predicate IsPermutation_4285(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_4286","instance":4286,"id":240973,"goal":"predicate IsEven_4286(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_4287","instance":4287,"id":240974,"goal":"predicate InRange_4287(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_4288","instance":4288,"id":240975,"goal":"predicate SubsetOf_4288(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_4289","instance":4289,"id":240976,"goal":"predicate AllMem_4289(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_4290","instance":4290,"id":240977,"goal":"predicate DisjointSets_4290(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_4291","instance":4291,"id":240978,"goal":"predicate Sorted_4291(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_4292","instance":4292,"id":240979,"goal":"predicate AllPositive_4292(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_4293","instance":4293,"id":240980,"goal":"predicate DistinctSeq_4293(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_4294","instance":4294,"id":240981,"goal":"predicate IsSubseq_4294(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_4295","instance":4295,"id":240982,"goal":"predicate IsPermutation_4295(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_4296","instance":4296,"id":240983,"goal":"predicate IsEven_4296(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_4297","instance":4297,"id":240984,"goal":"predicate InRange_4297(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_4298","instance":4298,"id":240985,"goal":"predicate SubsetOf_4298(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_4299","instance":4299,"id":240986,"goal":"predicate AllMem_4299(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_4300","instance":4300,"id":240987,"goal":"predicate DisjointSets_4300(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_4301","instance":4301,"id":240988,"goal":"predicate Sorted_4301(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_4302","instance":4302,"id":240989,"goal":"predicate AllPositive_4302(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_4303","instance":4303,"id":240990,"goal":"predicate DistinctSeq_4303(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_4304","instance":4304,"id":240991,"goal":"predicate IsSubseq_4304(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_4305","instance":4305,"id":240992,"goal":"predicate IsPermutation_4305(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_4306","instance":4306,"id":240993,"goal":"predicate IsEven_4306(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_4307","instance":4307,"id":240994,"goal":"predicate InRange_4307(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_4308","instance":4308,"id":240995,"goal":"predicate SubsetOf_4308(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_4309","instance":4309,"id":240996,"goal":"predicate AllMem_4309(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_4310","instance":4310,"id":240997,"goal":"predicate DisjointSets_4310(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_4311","instance":4311,"id":240998,"goal":"predicate Sorted_4311(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_4312","instance":4312,"id":240999,"goal":"predicate AllPositive_4312(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_4313","instance":4313,"id":241000,"goal":"predicate DistinctSeq_4313(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_4314","instance":4314,"id":241001,"goal":"predicate IsSubseq_4314(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_4315","instance":4315,"id":241002,"goal":"predicate IsPermutation_4315(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_4316","instance":4316,"id":241003,"goal":"predicate IsEven_4316(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_4317","instance":4317,"id":241004,"goal":"predicate InRange_4317(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_4318","instance":4318,"id":241005,"goal":"predicate SubsetOf_4318(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_4319","instance":4319,"id":241006,"goal":"predicate AllMem_4319(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_4320","instance":4320,"id":241007,"goal":"predicate DisjointSets_4320(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_4321","instance":4321,"id":241008,"goal":"predicate Sorted_4321(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_4322","instance":4322,"id":241009,"goal":"predicate AllPositive_4322(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_4323","instance":4323,"id":241010,"goal":"predicate DistinctSeq_4323(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_4324","instance":4324,"id":241011,"goal":"predicate IsSubseq_4324(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_4325","instance":4325,"id":241012,"goal":"predicate IsPermutation_4325(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_4326","instance":4326,"id":241013,"goal":"predicate IsEven_4326(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_4327","instance":4327,"id":241014,"goal":"predicate InRange_4327(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_4328","instance":4328,"id":241015,"goal":"predicate SubsetOf_4328(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_4329","instance":4329,"id":241016,"goal":"predicate AllMem_4329(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_4330","instance":4330,"id":241017,"goal":"predicate DisjointSets_4330(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_4331","instance":4331,"id":241018,"goal":"predicate Sorted_4331(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_4332","instance":4332,"id":241019,"goal":"predicate AllPositive_4332(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_4333","instance":4333,"id":241020,"goal":"predicate DistinctSeq_4333(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_4334","instance":4334,"id":241021,"goal":"predicate IsSubseq_4334(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_4335","instance":4335,"id":241022,"goal":"predicate IsPermutation_4335(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_4336","instance":4336,"id":241023,"goal":"predicate IsEven_4336(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_4337","instance":4337,"id":241024,"goal":"predicate InRange_4337(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_4338","instance":4338,"id":241025,"goal":"predicate SubsetOf_4338(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_4339","instance":4339,"id":241026,"goal":"predicate AllMem_4339(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_4340","instance":4340,"id":241027,"goal":"predicate DisjointSets_4340(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_4341","instance":4341,"id":241028,"goal":"predicate Sorted_4341(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_4342","instance":4342,"id":241029,"goal":"predicate AllPositive_4342(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_4343","instance":4343,"id":241030,"goal":"predicate DistinctSeq_4343(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_4344","instance":4344,"id":241031,"goal":"predicate IsSubseq_4344(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_4345","instance":4345,"id":241032,"goal":"predicate IsPermutation_4345(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_4346","instance":4346,"id":241033,"goal":"predicate IsEven_4346(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_4347","instance":4347,"id":241034,"goal":"predicate InRange_4347(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_4348","instance":4348,"id":241035,"goal":"predicate SubsetOf_4348(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_4349","instance":4349,"id":241036,"goal":"predicate AllMem_4349(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_4350","instance":4350,"id":241037,"goal":"predicate DisjointSets_4350(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_4351","instance":4351,"id":241038,"goal":"predicate Sorted_4351(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_4352","instance":4352,"id":241039,"goal":"predicate AllPositive_4352(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_4353","instance":4353,"id":241040,"goal":"predicate DistinctSeq_4353(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_4354","instance":4354,"id":241041,"goal":"predicate IsSubseq_4354(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_4355","instance":4355,"id":241042,"goal":"predicate IsPermutation_4355(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_4356","instance":4356,"id":241043,"goal":"predicate IsEven_4356(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_4357","instance":4357,"id":241044,"goal":"predicate InRange_4357(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_4358","instance":4358,"id":241045,"goal":"predicate SubsetOf_4358(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_4359","instance":4359,"id":241046,"goal":"predicate AllMem_4359(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_4360","instance":4360,"id":241047,"goal":"predicate DisjointSets_4360(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_4361","instance":4361,"id":241048,"goal":"predicate Sorted_4361(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_4362","instance":4362,"id":241049,"goal":"predicate AllPositive_4362(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_4363","instance":4363,"id":241050,"goal":"predicate DistinctSeq_4363(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_4364","instance":4364,"id":241051,"goal":"predicate IsSubseq_4364(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_4365","instance":4365,"id":241052,"goal":"predicate IsPermutation_4365(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_4366","instance":4366,"id":241053,"goal":"predicate IsEven_4366(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_4367","instance":4367,"id":241054,"goal":"predicate InRange_4367(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_4368","instance":4368,"id":241055,"goal":"predicate SubsetOf_4368(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_4369","instance":4369,"id":241056,"goal":"predicate AllMem_4369(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_4370","instance":4370,"id":241057,"goal":"predicate DisjointSets_4370(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_4371","instance":4371,"id":241058,"goal":"predicate Sorted_4371(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_4372","instance":4372,"id":241059,"goal":"predicate AllPositive_4372(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_4373","instance":4373,"id":241060,"goal":"predicate DistinctSeq_4373(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_4374","instance":4374,"id":241061,"goal":"predicate IsSubseq_4374(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_4375","instance":4375,"id":241062,"goal":"predicate IsPermutation_4375(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_4376","instance":4376,"id":241063,"goal":"predicate IsEven_4376(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_4377","instance":4377,"id":241064,"goal":"predicate InRange_4377(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_4378","instance":4378,"id":241065,"goal":"predicate SubsetOf_4378(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_4379","instance":4379,"id":241066,"goal":"predicate AllMem_4379(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_4380","instance":4380,"id":241067,"goal":"predicate DisjointSets_4380(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_4381","instance":4381,"id":241068,"goal":"predicate Sorted_4381(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_4382","instance":4382,"id":241069,"goal":"predicate AllPositive_4382(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_4383","instance":4383,"id":241070,"goal":"predicate DistinctSeq_4383(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_4384","instance":4384,"id":241071,"goal":"predicate IsSubseq_4384(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_4385","instance":4385,"id":241072,"goal":"predicate IsPermutation_4385(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_4386","instance":4386,"id":241073,"goal":"predicate IsEven_4386(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_4387","instance":4387,"id":241074,"goal":"predicate InRange_4387(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_4388","instance":4388,"id":241075,"goal":"predicate SubsetOf_4388(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_4389","instance":4389,"id":241076,"goal":"predicate AllMem_4389(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_4390","instance":4390,"id":241077,"goal":"predicate DisjointSets_4390(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_4391","instance":4391,"id":241078,"goal":"predicate Sorted_4391(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_4392","instance":4392,"id":241079,"goal":"predicate AllPositive_4392(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_4393","instance":4393,"id":241080,"goal":"predicate DistinctSeq_4393(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_4394","instance":4394,"id":241081,"goal":"predicate IsSubseq_4394(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_4395","instance":4395,"id":241082,"goal":"predicate IsPermutation_4395(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_4396","instance":4396,"id":241083,"goal":"predicate IsEven_4396(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_4397","instance":4397,"id":241084,"goal":"predicate InRange_4397(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_4398","instance":4398,"id":241085,"goal":"predicate SubsetOf_4398(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_4399","instance":4399,"id":241086,"goal":"predicate AllMem_4399(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_4400","instance":4400,"id":241087,"goal":"predicate DisjointSets_4400(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_4401","instance":4401,"id":241088,"goal":"predicate Sorted_4401(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_4402","instance":4402,"id":241089,"goal":"predicate AllPositive_4402(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_4403","instance":4403,"id":241090,"goal":"predicate DistinctSeq_4403(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_4404","instance":4404,"id":241091,"goal":"predicate IsSubseq_4404(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_4405","instance":4405,"id":241092,"goal":"predicate IsPermutation_4405(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_4406","instance":4406,"id":241093,"goal":"predicate IsEven_4406(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_4407","instance":4407,"id":241094,"goal":"predicate InRange_4407(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_4408","instance":4408,"id":241095,"goal":"predicate SubsetOf_4408(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_4409","instance":4409,"id":241096,"goal":"predicate AllMem_4409(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_4410","instance":4410,"id":241097,"goal":"predicate DisjointSets_4410(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_4411","instance":4411,"id":241098,"goal":"predicate Sorted_4411(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_4412","instance":4412,"id":241099,"goal":"predicate AllPositive_4412(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_4413","instance":4413,"id":241100,"goal":"predicate DistinctSeq_4413(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_4414","instance":4414,"id":241101,"goal":"predicate IsSubseq_4414(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_4415","instance":4415,"id":241102,"goal":"predicate IsPermutation_4415(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_4416","instance":4416,"id":241103,"goal":"predicate IsEven_4416(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_4417","instance":4417,"id":241104,"goal":"predicate InRange_4417(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_4418","instance":4418,"id":241105,"goal":"predicate SubsetOf_4418(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_4419","instance":4419,"id":241106,"goal":"predicate AllMem_4419(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_4420","instance":4420,"id":241107,"goal":"predicate DisjointSets_4420(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_4421","instance":4421,"id":241108,"goal":"predicate Sorted_4421(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_4422","instance":4422,"id":241109,"goal":"predicate AllPositive_4422(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_4423","instance":4423,"id":241110,"goal":"predicate DistinctSeq_4423(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_4424","instance":4424,"id":241111,"goal":"predicate IsSubseq_4424(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_4425","instance":4425,"id":241112,"goal":"predicate IsPermutation_4425(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_4426","instance":4426,"id":241113,"goal":"predicate IsEven_4426(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_4427","instance":4427,"id":241114,"goal":"predicate InRange_4427(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_4428","instance":4428,"id":241115,"goal":"predicate SubsetOf_4428(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_4429","instance":4429,"id":241116,"goal":"predicate AllMem_4429(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_4430","instance":4430,"id":241117,"goal":"predicate DisjointSets_4430(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_4431","instance":4431,"id":241118,"goal":"predicate Sorted_4431(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_4432","instance":4432,"id":241119,"goal":"predicate AllPositive_4432(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_4433","instance":4433,"id":241120,"goal":"predicate DistinctSeq_4433(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_4434","instance":4434,"id":241121,"goal":"predicate IsSubseq_4434(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_4435","instance":4435,"id":241122,"goal":"predicate IsPermutation_4435(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_4436","instance":4436,"id":241123,"goal":"predicate IsEven_4436(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_4437","instance":4437,"id":241124,"goal":"predicate InRange_4437(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_4438","instance":4438,"id":241125,"goal":"predicate SubsetOf_4438(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_4439","instance":4439,"id":241126,"goal":"predicate AllMem_4439(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_4440","instance":4440,"id":241127,"goal":"predicate DisjointSets_4440(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_4441","instance":4441,"id":241128,"goal":"predicate Sorted_4441(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_4442","instance":4442,"id":241129,"goal":"predicate AllPositive_4442(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_4443","instance":4443,"id":241130,"goal":"predicate DistinctSeq_4443(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_4444","instance":4444,"id":241131,"goal":"predicate IsSubseq_4444(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_4445","instance":4445,"id":241132,"goal":"predicate IsPermutation_4445(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_4446","instance":4446,"id":241133,"goal":"predicate IsEven_4446(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_4447","instance":4447,"id":241134,"goal":"predicate InRange_4447(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_4448","instance":4448,"id":241135,"goal":"predicate SubsetOf_4448(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_4449","instance":4449,"id":241136,"goal":"predicate AllMem_4449(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_4450","instance":4450,"id":241137,"goal":"predicate DisjointSets_4450(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_4451","instance":4451,"id":241138,"goal":"predicate Sorted_4451(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_4452","instance":4452,"id":241139,"goal":"predicate AllPositive_4452(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_4453","instance":4453,"id":241140,"goal":"predicate DistinctSeq_4453(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_4454","instance":4454,"id":241141,"goal":"predicate IsSubseq_4454(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_4455","instance":4455,"id":241142,"goal":"predicate IsPermutation_4455(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_4456","instance":4456,"id":241143,"goal":"predicate IsEven_4456(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_4457","instance":4457,"id":241144,"goal":"predicate InRange_4457(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_4458","instance":4458,"id":241145,"goal":"predicate SubsetOf_4458(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_4459","instance":4459,"id":241146,"goal":"predicate AllMem_4459(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_4460","instance":4460,"id":241147,"goal":"predicate DisjointSets_4460(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_4461","instance":4461,"id":241148,"goal":"predicate Sorted_4461(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_4462","instance":4462,"id":241149,"goal":"predicate AllPositive_4462(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_4463","instance":4463,"id":241150,"goal":"predicate DistinctSeq_4463(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_4464","instance":4464,"id":241151,"goal":"predicate IsSubseq_4464(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_4465","instance":4465,"id":241152,"goal":"predicate IsPermutation_4465(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_4466","instance":4466,"id":241153,"goal":"predicate IsEven_4466(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_4467","instance":4467,"id":241154,"goal":"predicate InRange_4467(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_4468","instance":4468,"id":241155,"goal":"predicate SubsetOf_4468(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_4469","instance":4469,"id":241156,"goal":"predicate AllMem_4469(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_4470","instance":4470,"id":241157,"goal":"predicate DisjointSets_4470(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_4471","instance":4471,"id":241158,"goal":"predicate Sorted_4471(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_4472","instance":4472,"id":241159,"goal":"predicate AllPositive_4472(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_4473","instance":4473,"id":241160,"goal":"predicate DistinctSeq_4473(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_4474","instance":4474,"id":241161,"goal":"predicate IsSubseq_4474(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_4475","instance":4475,"id":241162,"goal":"predicate IsPermutation_4475(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_4476","instance":4476,"id":241163,"goal":"predicate IsEven_4476(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_4477","instance":4477,"id":241164,"goal":"predicate InRange_4477(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_4478","instance":4478,"id":241165,"goal":"predicate SubsetOf_4478(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_4479","instance":4479,"id":241166,"goal":"predicate AllMem_4479(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_4480","instance":4480,"id":241167,"goal":"predicate DisjointSets_4480(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_4481","instance":4481,"id":241168,"goal":"predicate Sorted_4481(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_4482","instance":4482,"id":241169,"goal":"predicate AllPositive_4482(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_4483","instance":4483,"id":241170,"goal":"predicate DistinctSeq_4483(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_4484","instance":4484,"id":241171,"goal":"predicate IsSubseq_4484(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_4485","instance":4485,"id":241172,"goal":"predicate IsPermutation_4485(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_4486","instance":4486,"id":241173,"goal":"predicate IsEven_4486(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_4487","instance":4487,"id":241174,"goal":"predicate InRange_4487(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_4488","instance":4488,"id":241175,"goal":"predicate SubsetOf_4488(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_4489","instance":4489,"id":241176,"goal":"predicate AllMem_4489(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_4490","instance":4490,"id":241177,"goal":"predicate DisjointSets_4490(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_4491","instance":4491,"id":241178,"goal":"predicate Sorted_4491(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_4492","instance":4492,"id":241179,"goal":"predicate AllPositive_4492(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_4493","instance":4493,"id":241180,"goal":"predicate DistinctSeq_4493(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_4494","instance":4494,"id":241181,"goal":"predicate IsSubseq_4494(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_4495","instance":4495,"id":241182,"goal":"predicate IsPermutation_4495(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_4496","instance":4496,"id":241183,"goal":"predicate IsEven_4496(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_4497","instance":4497,"id":241184,"goal":"predicate InRange_4497(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_4498","instance":4498,"id":241185,"goal":"predicate SubsetOf_4498(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_4499","instance":4499,"id":241186,"goal":"predicate AllMem_4499(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_4500","instance":4500,"id":241187,"goal":"predicate DisjointSets_4500(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_4501","instance":4501,"id":241188,"goal":"predicate Sorted_4501(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_4502","instance":4502,"id":241189,"goal":"predicate AllPositive_4502(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_4503","instance":4503,"id":241190,"goal":"predicate DistinctSeq_4503(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_4504","instance":4504,"id":241191,"goal":"predicate IsSubseq_4504(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_4505","instance":4505,"id":241192,"goal":"predicate IsPermutation_4505(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_4506","instance":4506,"id":241193,"goal":"predicate IsEven_4506(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_4507","instance":4507,"id":241194,"goal":"predicate InRange_4507(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_4508","instance":4508,"id":241195,"goal":"predicate SubsetOf_4508(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_4509","instance":4509,"id":241196,"goal":"predicate AllMem_4509(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_4510","instance":4510,"id":241197,"goal":"predicate DisjointSets_4510(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_4511","instance":4511,"id":241198,"goal":"predicate Sorted_4511(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_4512","instance":4512,"id":241199,"goal":"predicate AllPositive_4512(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_4513","instance":4513,"id":241200,"goal":"predicate DistinctSeq_4513(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_4514","instance":4514,"id":241201,"goal":"predicate IsSubseq_4514(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_4515","instance":4515,"id":241202,"goal":"predicate IsPermutation_4515(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_4516","instance":4516,"id":241203,"goal":"predicate IsEven_4516(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_4517","instance":4517,"id":241204,"goal":"predicate InRange_4517(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_4518","instance":4518,"id":241205,"goal":"predicate SubsetOf_4518(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_4519","instance":4519,"id":241206,"goal":"predicate AllMem_4519(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_4520","instance":4520,"id":241207,"goal":"predicate DisjointSets_4520(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_4521","instance":4521,"id":241208,"goal":"predicate Sorted_4521(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_4522","instance":4522,"id":241209,"goal":"predicate AllPositive_4522(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_4523","instance":4523,"id":241210,"goal":"predicate DistinctSeq_4523(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_4524","instance":4524,"id":241211,"goal":"predicate IsSubseq_4524(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_4525","instance":4525,"id":241212,"goal":"predicate IsPermutation_4525(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_4526","instance":4526,"id":241213,"goal":"predicate IsEven_4526(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_4527","instance":4527,"id":241214,"goal":"predicate InRange_4527(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_4528","instance":4528,"id":241215,"goal":"predicate SubsetOf_4528(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_4529","instance":4529,"id":241216,"goal":"predicate AllMem_4529(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_4530","instance":4530,"id":241217,"goal":"predicate DisjointSets_4530(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_4531","instance":4531,"id":241218,"goal":"predicate Sorted_4531(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_4532","instance":4532,"id":241219,"goal":"predicate AllPositive_4532(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_4533","instance":4533,"id":241220,"goal":"predicate DistinctSeq_4533(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_4534","instance":4534,"id":241221,"goal":"predicate IsSubseq_4534(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_4535","instance":4535,"id":241222,"goal":"predicate IsPermutation_4535(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_4536","instance":4536,"id":241223,"goal":"predicate IsEven_4536(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_4537","instance":4537,"id":241224,"goal":"predicate InRange_4537(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_4538","instance":4538,"id":241225,"goal":"predicate SubsetOf_4538(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_4539","instance":4539,"id":241226,"goal":"predicate AllMem_4539(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_4540","instance":4540,"id":241227,"goal":"predicate DisjointSets_4540(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_4541","instance":4541,"id":241228,"goal":"predicate Sorted_4541(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_4542","instance":4542,"id":241229,"goal":"predicate AllPositive_4542(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_4543","instance":4543,"id":241230,"goal":"predicate DistinctSeq_4543(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_4544","instance":4544,"id":241231,"goal":"predicate IsSubseq_4544(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_4545","instance":4545,"id":241232,"goal":"predicate IsPermutation_4545(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_4546","instance":4546,"id":241233,"goal":"predicate IsEven_4546(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_4547","instance":4547,"id":241234,"goal":"predicate InRange_4547(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_4548","instance":4548,"id":241235,"goal":"predicate SubsetOf_4548(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_4549","instance":4549,"id":241236,"goal":"predicate AllMem_4549(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_4550","instance":4550,"id":241237,"goal":"predicate DisjointSets_4550(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_4551","instance":4551,"id":241238,"goal":"predicate Sorted_4551(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_4552","instance":4552,"id":241239,"goal":"predicate AllPositive_4552(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_4553","instance":4553,"id":241240,"goal":"predicate DistinctSeq_4553(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_4554","instance":4554,"id":241241,"goal":"predicate IsSubseq_4554(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_4555","instance":4555,"id":241242,"goal":"predicate IsPermutation_4555(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_4556","instance":4556,"id":241243,"goal":"predicate IsEven_4556(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_4557","instance":4557,"id":241244,"goal":"predicate InRange_4557(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_4558","instance":4558,"id":241245,"goal":"predicate SubsetOf_4558(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_4559","instance":4559,"id":241246,"goal":"predicate AllMem_4559(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_4560","instance":4560,"id":241247,"goal":"predicate DisjointSets_4560(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_4561","instance":4561,"id":241248,"goal":"predicate Sorted_4561(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_4562","instance":4562,"id":241249,"goal":"predicate AllPositive_4562(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_4563","instance":4563,"id":241250,"goal":"predicate DistinctSeq_4563(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_4564","instance":4564,"id":241251,"goal":"predicate IsSubseq_4564(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_4565","instance":4565,"id":241252,"goal":"predicate IsPermutation_4565(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_4566","instance":4566,"id":241253,"goal":"predicate IsEven_4566(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_4567","instance":4567,"id":241254,"goal":"predicate InRange_4567(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_4568","instance":4568,"id":241255,"goal":"predicate SubsetOf_4568(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_4569","instance":4569,"id":241256,"goal":"predicate AllMem_4569(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_4570","instance":4570,"id":241257,"goal":"predicate DisjointSets_4570(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_4571","instance":4571,"id":241258,"goal":"predicate Sorted_4571(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_4572","instance":4572,"id":241259,"goal":"predicate AllPositive_4572(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_4573","instance":4573,"id":241260,"goal":"predicate DistinctSeq_4573(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_4574","instance":4574,"id":241261,"goal":"predicate IsSubseq_4574(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_4575","instance":4575,"id":241262,"goal":"predicate IsPermutation_4575(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_4576","instance":4576,"id":241263,"goal":"predicate IsEven_4576(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_4577","instance":4577,"id":241264,"goal":"predicate InRange_4577(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_4578","instance":4578,"id":241265,"goal":"predicate SubsetOf_4578(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_4579","instance":4579,"id":241266,"goal":"predicate AllMem_4579(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_4580","instance":4580,"id":241267,"goal":"predicate DisjointSets_4580(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_4581","instance":4581,"id":241268,"goal":"predicate Sorted_4581(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_4582","instance":4582,"id":241269,"goal":"predicate AllPositive_4582(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_4583","instance":4583,"id":241270,"goal":"predicate DistinctSeq_4583(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_4584","instance":4584,"id":241271,"goal":"predicate IsSubseq_4584(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_4585","instance":4585,"id":241272,"goal":"predicate IsPermutation_4585(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_4586","instance":4586,"id":241273,"goal":"predicate IsEven_4586(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_4587","instance":4587,"id":241274,"goal":"predicate InRange_4587(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_4588","instance":4588,"id":241275,"goal":"predicate SubsetOf_4588(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_4589","instance":4589,"id":241276,"goal":"predicate AllMem_4589(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_4590","instance":4590,"id":241277,"goal":"predicate DisjointSets_4590(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_4591","instance":4591,"id":241278,"goal":"predicate Sorted_4591(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_4592","instance":4592,"id":241279,"goal":"predicate AllPositive_4592(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_4593","instance":4593,"id":241280,"goal":"predicate DistinctSeq_4593(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_4594","instance":4594,"id":241281,"goal":"predicate IsSubseq_4594(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_4595","instance":4595,"id":241282,"goal":"predicate IsPermutation_4595(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_4596","instance":4596,"id":241283,"goal":"predicate IsEven_4596(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_4597","instance":4597,"id":241284,"goal":"predicate InRange_4597(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_4598","instance":4598,"id":241285,"goal":"predicate SubsetOf_4598(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_4599","instance":4599,"id":241286,"goal":"predicate AllMem_4599(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_4600","instance":4600,"id":241287,"goal":"predicate DisjointSets_4600(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_4601","instance":4601,"id":241288,"goal":"predicate Sorted_4601(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_4602","instance":4602,"id":241289,"goal":"predicate AllPositive_4602(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_4603","instance":4603,"id":241290,"goal":"predicate DistinctSeq_4603(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_4604","instance":4604,"id":241291,"goal":"predicate IsSubseq_4604(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_4605","instance":4605,"id":241292,"goal":"predicate IsPermutation_4605(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_4606","instance":4606,"id":241293,"goal":"predicate IsEven_4606(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_4607","instance":4607,"id":241294,"goal":"predicate InRange_4607(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_4608","instance":4608,"id":241295,"goal":"predicate SubsetOf_4608(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_4609","instance":4609,"id":241296,"goal":"predicate AllMem_4609(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_4610","instance":4610,"id":241297,"goal":"predicate DisjointSets_4610(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_4611","instance":4611,"id":241298,"goal":"predicate Sorted_4611(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_4612","instance":4612,"id":241299,"goal":"predicate AllPositive_4612(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_4613","instance":4613,"id":241300,"goal":"predicate DistinctSeq_4613(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_4614","instance":4614,"id":241301,"goal":"predicate IsSubseq_4614(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_4615","instance":4615,"id":241302,"goal":"predicate IsPermutation_4615(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_4616","instance":4616,"id":241303,"goal":"predicate IsEven_4616(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_4617","instance":4617,"id":241304,"goal":"predicate InRange_4617(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_4618","instance":4618,"id":241305,"goal":"predicate SubsetOf_4618(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_4619","instance":4619,"id":241306,"goal":"predicate AllMem_4619(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_4620","instance":4620,"id":241307,"goal":"predicate DisjointSets_4620(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_4621","instance":4621,"id":241308,"goal":"predicate Sorted_4621(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_4622","instance":4622,"id":241309,"goal":"predicate AllPositive_4622(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_4623","instance":4623,"id":241310,"goal":"predicate DistinctSeq_4623(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_4624","instance":4624,"id":241311,"goal":"predicate IsSubseq_4624(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_4625","instance":4625,"id":241312,"goal":"predicate IsPermutation_4625(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_4626","instance":4626,"id":241313,"goal":"predicate IsEven_4626(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_4627","instance":4627,"id":241314,"goal":"predicate InRange_4627(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_4628","instance":4628,"id":241315,"goal":"predicate SubsetOf_4628(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_4629","instance":4629,"id":241316,"goal":"predicate AllMem_4629(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_4630","instance":4630,"id":241317,"goal":"predicate DisjointSets_4630(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_4631","instance":4631,"id":241318,"goal":"predicate Sorted_4631(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_4632","instance":4632,"id":241319,"goal":"predicate AllPositive_4632(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_4633","instance":4633,"id":241320,"goal":"predicate DistinctSeq_4633(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_4634","instance":4634,"id":241321,"goal":"predicate IsSubseq_4634(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_4635","instance":4635,"id":241322,"goal":"predicate IsPermutation_4635(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_4636","instance":4636,"id":241323,"goal":"predicate IsEven_4636(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_4637","instance":4637,"id":241324,"goal":"predicate InRange_4637(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_4638","instance":4638,"id":241325,"goal":"predicate SubsetOf_4638(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_4639","instance":4639,"id":241326,"goal":"predicate AllMem_4639(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_4640","instance":4640,"id":241327,"goal":"predicate DisjointSets_4640(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_4641","instance":4641,"id":241328,"goal":"predicate Sorted_4641(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_4642","instance":4642,"id":241329,"goal":"predicate AllPositive_4642(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_4643","instance":4643,"id":241330,"goal":"predicate DistinctSeq_4643(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_4644","instance":4644,"id":241331,"goal":"predicate IsSubseq_4644(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_4645","instance":4645,"id":241332,"goal":"predicate IsPermutation_4645(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_4646","instance":4646,"id":241333,"goal":"predicate IsEven_4646(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_4647","instance":4647,"id":241334,"goal":"predicate InRange_4647(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_4648","instance":4648,"id":241335,"goal":"predicate SubsetOf_4648(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_4649","instance":4649,"id":241336,"goal":"predicate AllMem_4649(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_4650","instance":4650,"id":241337,"goal":"predicate DisjointSets_4650(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_4651","instance":4651,"id":241338,"goal":"predicate Sorted_4651(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_4652","instance":4652,"id":241339,"goal":"predicate AllPositive_4652(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_4653","instance":4653,"id":241340,"goal":"predicate DistinctSeq_4653(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_4654","instance":4654,"id":241341,"goal":"predicate IsSubseq_4654(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_4655","instance":4655,"id":241342,"goal":"predicate IsPermutation_4655(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_4656","instance":4656,"id":241343,"goal":"predicate IsEven_4656(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_4657","instance":4657,"id":241344,"goal":"predicate InRange_4657(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_4658","instance":4658,"id":241345,"goal":"predicate SubsetOf_4658(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_4659","instance":4659,"id":241346,"goal":"predicate AllMem_4659(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_4660","instance":4660,"id":241347,"goal":"predicate DisjointSets_4660(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_4661","instance":4661,"id":241348,"goal":"predicate Sorted_4661(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_4662","instance":4662,"id":241349,"goal":"predicate AllPositive_4662(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_4663","instance":4663,"id":241350,"goal":"predicate DistinctSeq_4663(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_4664","instance":4664,"id":241351,"goal":"predicate IsSubseq_4664(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_4665","instance":4665,"id":241352,"goal":"predicate IsPermutation_4665(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_4666","instance":4666,"id":241353,"goal":"predicate IsEven_4666(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_4667","instance":4667,"id":241354,"goal":"predicate InRange_4667(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_4668","instance":4668,"id":241355,"goal":"predicate SubsetOf_4668(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_4669","instance":4669,"id":241356,"goal":"predicate AllMem_4669(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_4670","instance":4670,"id":241357,"goal":"predicate DisjointSets_4670(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_4671","instance":4671,"id":241358,"goal":"predicate Sorted_4671(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_4672","instance":4672,"id":241359,"goal":"predicate AllPositive_4672(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_4673","instance":4673,"id":241360,"goal":"predicate DistinctSeq_4673(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_4674","instance":4674,"id":241361,"goal":"predicate IsSubseq_4674(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_4675","instance":4675,"id":241362,"goal":"predicate IsPermutation_4675(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_4676","instance":4676,"id":241363,"goal":"predicate IsEven_4676(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_4677","instance":4677,"id":241364,"goal":"predicate InRange_4677(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_4678","instance":4678,"id":241365,"goal":"predicate SubsetOf_4678(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_4679","instance":4679,"id":241366,"goal":"predicate AllMem_4679(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_4680","instance":4680,"id":241367,"goal":"predicate DisjointSets_4680(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_4681","instance":4681,"id":241368,"goal":"predicate Sorted_4681(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_4682","instance":4682,"id":241369,"goal":"predicate AllPositive_4682(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_4683","instance":4683,"id":241370,"goal":"predicate DistinctSeq_4683(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_4684","instance":4684,"id":241371,"goal":"predicate IsSubseq_4684(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_4685","instance":4685,"id":241372,"goal":"predicate IsPermutation_4685(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_4686","instance":4686,"id":241373,"goal":"predicate IsEven_4686(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_4687","instance":4687,"id":241374,"goal":"predicate InRange_4687(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_4688","instance":4688,"id":241375,"goal":"predicate SubsetOf_4688(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_4689","instance":4689,"id":241376,"goal":"predicate AllMem_4689(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_4690","instance":4690,"id":241377,"goal":"predicate DisjointSets_4690(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_4691","instance":4691,"id":241378,"goal":"predicate Sorted_4691(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_4692","instance":4692,"id":241379,"goal":"predicate AllPositive_4692(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_4693","instance":4693,"id":241380,"goal":"predicate DistinctSeq_4693(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_4694","instance":4694,"id":241381,"goal":"predicate IsSubseq_4694(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_4695","instance":4695,"id":241382,"goal":"predicate IsPermutation_4695(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_4696","instance":4696,"id":241383,"goal":"predicate IsEven_4696(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_4697","instance":4697,"id":241384,"goal":"predicate InRange_4697(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_4698","instance":4698,"id":241385,"goal":"predicate SubsetOf_4698(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_4699","instance":4699,"id":241386,"goal":"predicate AllMem_4699(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_4700","instance":4700,"id":241387,"goal":"predicate DisjointSets_4700(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_4701","instance":4701,"id":241388,"goal":"predicate Sorted_4701(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_4702","instance":4702,"id":241389,"goal":"predicate AllPositive_4702(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_4703","instance":4703,"id":241390,"goal":"predicate DistinctSeq_4703(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_4704","instance":4704,"id":241391,"goal":"predicate IsSubseq_4704(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_4705","instance":4705,"id":241392,"goal":"predicate IsPermutation_4705(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_4706","instance":4706,"id":241393,"goal":"predicate IsEven_4706(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_4707","instance":4707,"id":241394,"goal":"predicate InRange_4707(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_4708","instance":4708,"id":241395,"goal":"predicate SubsetOf_4708(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_4709","instance":4709,"id":241396,"goal":"predicate AllMem_4709(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_4710","instance":4710,"id":241397,"goal":"predicate DisjointSets_4710(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_4711","instance":4711,"id":241398,"goal":"predicate Sorted_4711(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_4712","instance":4712,"id":241399,"goal":"predicate AllPositive_4712(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_4713","instance":4713,"id":241400,"goal":"predicate DistinctSeq_4713(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_4714","instance":4714,"id":241401,"goal":"predicate IsSubseq_4714(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_4715","instance":4715,"id":241402,"goal":"predicate IsPermutation_4715(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_4716","instance":4716,"id":241403,"goal":"predicate IsEven_4716(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_4717","instance":4717,"id":241404,"goal":"predicate InRange_4717(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_4718","instance":4718,"id":241405,"goal":"predicate SubsetOf_4718(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_4719","instance":4719,"id":241406,"goal":"predicate AllMem_4719(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_4720","instance":4720,"id":241407,"goal":"predicate DisjointSets_4720(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_4721","instance":4721,"id":241408,"goal":"predicate Sorted_4721(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_4722","instance":4722,"id":241409,"goal":"predicate AllPositive_4722(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_4723","instance":4723,"id":241410,"goal":"predicate DistinctSeq_4723(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_4724","instance":4724,"id":241411,"goal":"predicate IsSubseq_4724(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_4725","instance":4725,"id":241412,"goal":"predicate IsPermutation_4725(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_4726","instance":4726,"id":241413,"goal":"predicate IsEven_4726(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_4727","instance":4727,"id":241414,"goal":"predicate InRange_4727(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_4728","instance":4728,"id":241415,"goal":"predicate SubsetOf_4728(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_4729","instance":4729,"id":241416,"goal":"predicate AllMem_4729(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_4730","instance":4730,"id":241417,"goal":"predicate DisjointSets_4730(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_4731","instance":4731,"id":241418,"goal":"predicate Sorted_4731(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_4732","instance":4732,"id":241419,"goal":"predicate AllPositive_4732(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_4733","instance":4733,"id":241420,"goal":"predicate DistinctSeq_4733(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_4734","instance":4734,"id":241421,"goal":"predicate IsSubseq_4734(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_4735","instance":4735,"id":241422,"goal":"predicate IsPermutation_4735(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_4736","instance":4736,"id":241423,"goal":"predicate IsEven_4736(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_4737","instance":4737,"id":241424,"goal":"predicate InRange_4737(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_4738","instance":4738,"id":241425,"goal":"predicate SubsetOf_4738(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_4739","instance":4739,"id":241426,"goal":"predicate AllMem_4739(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_4740","instance":4740,"id":241427,"goal":"predicate DisjointSets_4740(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_4741","instance":4741,"id":241428,"goal":"predicate Sorted_4741(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_4742","instance":4742,"id":241429,"goal":"predicate AllPositive_4742(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_4743","instance":4743,"id":241430,"goal":"predicate DistinctSeq_4743(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_4744","instance":4744,"id":241431,"goal":"predicate IsSubseq_4744(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_4745","instance":4745,"id":241432,"goal":"predicate IsPermutation_4745(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_4746","instance":4746,"id":241433,"goal":"predicate IsEven_4746(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_4747","instance":4747,"id":241434,"goal":"predicate InRange_4747(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_4748","instance":4748,"id":241435,"goal":"predicate SubsetOf_4748(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_4749","instance":4749,"id":241436,"goal":"predicate AllMem_4749(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_4750","instance":4750,"id":241437,"goal":"predicate DisjointSets_4750(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_4751","instance":4751,"id":241438,"goal":"predicate Sorted_4751(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_4752","instance":4752,"id":241439,"goal":"predicate AllPositive_4752(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_4753","instance":4753,"id":241440,"goal":"predicate DistinctSeq_4753(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_4754","instance":4754,"id":241441,"goal":"predicate IsSubseq_4754(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_4755","instance":4755,"id":241442,"goal":"predicate IsPermutation_4755(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_4756","instance":4756,"id":241443,"goal":"predicate IsEven_4756(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_4757","instance":4757,"id":241444,"goal":"predicate InRange_4757(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_4758","instance":4758,"id":241445,"goal":"predicate SubsetOf_4758(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_4759","instance":4759,"id":241446,"goal":"predicate AllMem_4759(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_4760","instance":4760,"id":241447,"goal":"predicate DisjointSets_4760(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_4761","instance":4761,"id":241448,"goal":"predicate Sorted_4761(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_4762","instance":4762,"id":241449,"goal":"predicate AllPositive_4762(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_4763","instance":4763,"id":241450,"goal":"predicate DistinctSeq_4763(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_4764","instance":4764,"id":241451,"goal":"predicate IsSubseq_4764(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_4765","instance":4765,"id":241452,"goal":"predicate IsPermutation_4765(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_4766","instance":4766,"id":241453,"goal":"predicate IsEven_4766(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_4767","instance":4767,"id":241454,"goal":"predicate InRange_4767(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_4768","instance":4768,"id":241455,"goal":"predicate SubsetOf_4768(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_4769","instance":4769,"id":241456,"goal":"predicate AllMem_4769(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_4770","instance":4770,"id":241457,"goal":"predicate DisjointSets_4770(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_4771","instance":4771,"id":241458,"goal":"predicate Sorted_4771(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_4772","instance":4772,"id":241459,"goal":"predicate AllPositive_4772(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_4773","instance":4773,"id":241460,"goal":"predicate DistinctSeq_4773(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_4774","instance":4774,"id":241461,"goal":"predicate IsSubseq_4774(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_4775","instance":4775,"id":241462,"goal":"predicate IsPermutation_4775(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_4776","instance":4776,"id":241463,"goal":"predicate IsEven_4776(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_4777","instance":4777,"id":241464,"goal":"predicate InRange_4777(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_4778","instance":4778,"id":241465,"goal":"predicate SubsetOf_4778(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_4779","instance":4779,"id":241466,"goal":"predicate AllMem_4779(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_4780","instance":4780,"id":241467,"goal":"predicate DisjointSets_4780(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_4781","instance":4781,"id":241468,"goal":"predicate Sorted_4781(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_4782","instance":4782,"id":241469,"goal":"predicate AllPositive_4782(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_4783","instance":4783,"id":241470,"goal":"predicate DistinctSeq_4783(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_4784","instance":4784,"id":241471,"goal":"predicate IsSubseq_4784(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_4785","instance":4785,"id":241472,"goal":"predicate IsPermutation_4785(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_4786","instance":4786,"id":241473,"goal":"predicate IsEven_4786(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_4787","instance":4787,"id":241474,"goal":"predicate InRange_4787(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_4788","instance":4788,"id":241475,"goal":"predicate SubsetOf_4788(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_4789","instance":4789,"id":241476,"goal":"predicate AllMem_4789(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_4790","instance":4790,"id":241477,"goal":"predicate DisjointSets_4790(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_4791","instance":4791,"id":241478,"goal":"predicate Sorted_4791(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_4792","instance":4792,"id":241479,"goal":"predicate AllPositive_4792(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_4793","instance":4793,"id":241480,"goal":"predicate DistinctSeq_4793(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_4794","instance":4794,"id":241481,"goal":"predicate IsSubseq_4794(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_4795","instance":4795,"id":241482,"goal":"predicate IsPermutation_4795(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_4796","instance":4796,"id":241483,"goal":"predicate IsEven_4796(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_4797","instance":4797,"id":241484,"goal":"predicate InRange_4797(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_4798","instance":4798,"id":241485,"goal":"predicate SubsetOf_4798(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_4799","instance":4799,"id":241486,"goal":"predicate AllMem_4799(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_4800","instance":4800,"id":241487,"goal":"predicate DisjointSets_4800(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_4801","instance":4801,"id":241488,"goal":"predicate Sorted_4801(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_4802","instance":4802,"id":241489,"goal":"predicate AllPositive_4802(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_4803","instance":4803,"id":241490,"goal":"predicate DistinctSeq_4803(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_4804","instance":4804,"id":241491,"goal":"predicate IsSubseq_4804(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_4805","instance":4805,"id":241492,"goal":"predicate IsPermutation_4805(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_4806","instance":4806,"id":241493,"goal":"predicate IsEven_4806(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_4807","instance":4807,"id":241494,"goal":"predicate InRange_4807(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_4808","instance":4808,"id":241495,"goal":"predicate SubsetOf_4808(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_4809","instance":4809,"id":241496,"goal":"predicate AllMem_4809(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_4810","instance":4810,"id":241497,"goal":"predicate DisjointSets_4810(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_4811","instance":4811,"id":241498,"goal":"predicate Sorted_4811(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_4812","instance":4812,"id":241499,"goal":"predicate AllPositive_4812(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_4813","instance":4813,"id":241500,"goal":"predicate DistinctSeq_4813(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_4814","instance":4814,"id":241501,"goal":"predicate IsSubseq_4814(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_4815","instance":4815,"id":241502,"goal":"predicate IsPermutation_4815(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_4816","instance":4816,"id":241503,"goal":"predicate IsEven_4816(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_4817","instance":4817,"id":241504,"goal":"predicate InRange_4817(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_4818","instance":4818,"id":241505,"goal":"predicate SubsetOf_4818(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_4819","instance":4819,"id":241506,"goal":"predicate AllMem_4819(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_4820","instance":4820,"id":241507,"goal":"predicate DisjointSets_4820(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_4821","instance":4821,"id":241508,"goal":"predicate Sorted_4821(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_4822","instance":4822,"id":241509,"goal":"predicate AllPositive_4822(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_4823","instance":4823,"id":241510,"goal":"predicate DistinctSeq_4823(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_4824","instance":4824,"id":241511,"goal":"predicate IsSubseq_4824(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_4825","instance":4825,"id":241512,"goal":"predicate IsPermutation_4825(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_4826","instance":4826,"id":241513,"goal":"predicate IsEven_4826(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_4827","instance":4827,"id":241514,"goal":"predicate InRange_4827(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_4828","instance":4828,"id":241515,"goal":"predicate SubsetOf_4828(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_4829","instance":4829,"id":241516,"goal":"predicate AllMem_4829(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_4830","instance":4830,"id":241517,"goal":"predicate DisjointSets_4830(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_4831","instance":4831,"id":241518,"goal":"predicate Sorted_4831(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_4832","instance":4832,"id":241519,"goal":"predicate AllPositive_4832(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_4833","instance":4833,"id":241520,"goal":"predicate DistinctSeq_4833(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_4834","instance":4834,"id":241521,"goal":"predicate IsSubseq_4834(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_4835","instance":4835,"id":241522,"goal":"predicate IsPermutation_4835(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_4836","instance":4836,"id":241523,"goal":"predicate IsEven_4836(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_4837","instance":4837,"id":241524,"goal":"predicate InRange_4837(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_4838","instance":4838,"id":241525,"goal":"predicate SubsetOf_4838(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_4839","instance":4839,"id":241526,"goal":"predicate AllMem_4839(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_4840","instance":4840,"id":241527,"goal":"predicate DisjointSets_4840(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_4841","instance":4841,"id":241528,"goal":"predicate Sorted_4841(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_4842","instance":4842,"id":241529,"goal":"predicate AllPositive_4842(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_4843","instance":4843,"id":241530,"goal":"predicate DistinctSeq_4843(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_4844","instance":4844,"id":241531,"goal":"predicate IsSubseq_4844(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_4845","instance":4845,"id":241532,"goal":"predicate IsPermutation_4845(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_4846","instance":4846,"id":241533,"goal":"predicate IsEven_4846(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_4847","instance":4847,"id":241534,"goal":"predicate InRange_4847(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_4848","instance":4848,"id":241535,"goal":"predicate SubsetOf_4848(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_4849","instance":4849,"id":241536,"goal":"predicate AllMem_4849(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_4850","instance":4850,"id":241537,"goal":"predicate DisjointSets_4850(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_4851","instance":4851,"id":241538,"goal":"predicate Sorted_4851(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_4852","instance":4852,"id":241539,"goal":"predicate AllPositive_4852(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_4853","instance":4853,"id":241540,"goal":"predicate DistinctSeq_4853(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_4854","instance":4854,"id":241541,"goal":"predicate IsSubseq_4854(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_4855","instance":4855,"id":241542,"goal":"predicate IsPermutation_4855(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_4856","instance":4856,"id":241543,"goal":"predicate IsEven_4856(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_4857","instance":4857,"id":241544,"goal":"predicate InRange_4857(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_4858","instance":4858,"id":241545,"goal":"predicate SubsetOf_4858(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_4859","instance":4859,"id":241546,"goal":"predicate AllMem_4859(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_4860","instance":4860,"id":241547,"goal":"predicate DisjointSets_4860(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_4861","instance":4861,"id":241548,"goal":"predicate Sorted_4861(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_4862","instance":4862,"id":241549,"goal":"predicate AllPositive_4862(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_4863","instance":4863,"id":241550,"goal":"predicate DistinctSeq_4863(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_4864","instance":4864,"id":241551,"goal":"predicate IsSubseq_4864(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_4865","instance":4865,"id":241552,"goal":"predicate IsPermutation_4865(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_4866","instance":4866,"id":241553,"goal":"predicate IsEven_4866(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_4867","instance":4867,"id":241554,"goal":"predicate InRange_4867(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_4868","instance":4868,"id":241555,"goal":"predicate SubsetOf_4868(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_4869","instance":4869,"id":241556,"goal":"predicate AllMem_4869(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_4870","instance":4870,"id":241557,"goal":"predicate DisjointSets_4870(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_4871","instance":4871,"id":241558,"goal":"predicate Sorted_4871(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_4872","instance":4872,"id":241559,"goal":"predicate AllPositive_4872(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_4873","instance":4873,"id":241560,"goal":"predicate DistinctSeq_4873(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_4874","instance":4874,"id":241561,"goal":"predicate IsSubseq_4874(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_4875","instance":4875,"id":241562,"goal":"predicate IsPermutation_4875(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_4876","instance":4876,"id":241563,"goal":"predicate IsEven_4876(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_4877","instance":4877,"id":241564,"goal":"predicate InRange_4877(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_4878","instance":4878,"id":241565,"goal":"predicate SubsetOf_4878(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_4879","instance":4879,"id":241566,"goal":"predicate AllMem_4879(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_4880","instance":4880,"id":241567,"goal":"predicate DisjointSets_4880(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_4881","instance":4881,"id":241568,"goal":"predicate Sorted_4881(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_4882","instance":4882,"id":241569,"goal":"predicate AllPositive_4882(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_4883","instance":4883,"id":241570,"goal":"predicate DistinctSeq_4883(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_4884","instance":4884,"id":241571,"goal":"predicate IsSubseq_4884(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_4885","instance":4885,"id":241572,"goal":"predicate IsPermutation_4885(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_4886","instance":4886,"id":241573,"goal":"predicate IsEven_4886(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_4887","instance":4887,"id":241574,"goal":"predicate InRange_4887(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_4888","instance":4888,"id":241575,"goal":"predicate SubsetOf_4888(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_4889","instance":4889,"id":241576,"goal":"predicate AllMem_4889(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_4890","instance":4890,"id":241577,"goal":"predicate DisjointSets_4890(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_4891","instance":4891,"id":241578,"goal":"predicate Sorted_4891(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_4892","instance":4892,"id":241579,"goal":"predicate AllPositive_4892(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_4893","instance":4893,"id":241580,"goal":"predicate DistinctSeq_4893(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_4894","instance":4894,"id":241581,"goal":"predicate IsSubseq_4894(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_4895","instance":4895,"id":241582,"goal":"predicate IsPermutation_4895(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_4896","instance":4896,"id":241583,"goal":"predicate IsEven_4896(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_4897","instance":4897,"id":241584,"goal":"predicate InRange_4897(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_4898","instance":4898,"id":241585,"goal":"predicate SubsetOf_4898(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_4899","instance":4899,"id":241586,"goal":"predicate AllMem_4899(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_4900","instance":4900,"id":241587,"goal":"predicate DisjointSets_4900(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_4901","instance":4901,"id":241588,"goal":"predicate Sorted_4901(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_4902","instance":4902,"id":241589,"goal":"predicate AllPositive_4902(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_4903","instance":4903,"id":241590,"goal":"predicate DistinctSeq_4903(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_4904","instance":4904,"id":241591,"goal":"predicate IsSubseq_4904(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_4905","instance":4905,"id":241592,"goal":"predicate IsPermutation_4905(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_4906","instance":4906,"id":241593,"goal":"predicate IsEven_4906(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_4907","instance":4907,"id":241594,"goal":"predicate InRange_4907(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_4908","instance":4908,"id":241595,"goal":"predicate SubsetOf_4908(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_4909","instance":4909,"id":241596,"goal":"predicate AllMem_4909(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_4910","instance":4910,"id":241597,"goal":"predicate DisjointSets_4910(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_4911","instance":4911,"id":241598,"goal":"predicate Sorted_4911(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_4912","instance":4912,"id":241599,"goal":"predicate AllPositive_4912(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_4913","instance":4913,"id":241600,"goal":"predicate DistinctSeq_4913(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_4914","instance":4914,"id":241601,"goal":"predicate IsSubseq_4914(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_4915","instance":4915,"id":241602,"goal":"predicate IsPermutation_4915(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_4916","instance":4916,"id":241603,"goal":"predicate IsEven_4916(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_4917","instance":4917,"id":241604,"goal":"predicate InRange_4917(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_4918","instance":4918,"id":241605,"goal":"predicate SubsetOf_4918(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_4919","instance":4919,"id":241606,"goal":"predicate AllMem_4919(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_4920","instance":4920,"id":241607,"goal":"predicate DisjointSets_4920(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_4921","instance":4921,"id":241608,"goal":"predicate Sorted_4921(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_4922","instance":4922,"id":241609,"goal":"predicate AllPositive_4922(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_4923","instance":4923,"id":241610,"goal":"predicate DistinctSeq_4923(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_4924","instance":4924,"id":241611,"goal":"predicate IsSubseq_4924(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_4925","instance":4925,"id":241612,"goal":"predicate IsPermutation_4925(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_4926","instance":4926,"id":241613,"goal":"predicate IsEven_4926(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_4927","instance":4927,"id":241614,"goal":"predicate InRange_4927(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_4928","instance":4928,"id":241615,"goal":"predicate SubsetOf_4928(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_4929","instance":4929,"id":241616,"goal":"predicate AllMem_4929(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_4930","instance":4930,"id":241617,"goal":"predicate DisjointSets_4930(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_4931","instance":4931,"id":241618,"goal":"predicate Sorted_4931(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_4932","instance":4932,"id":241619,"goal":"predicate AllPositive_4932(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_4933","instance":4933,"id":241620,"goal":"predicate DistinctSeq_4933(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_4934","instance":4934,"id":241621,"goal":"predicate IsSubseq_4934(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_4935","instance":4935,"id":241622,"goal":"predicate IsPermutation_4935(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_4936","instance":4936,"id":241623,"goal":"predicate IsEven_4936(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_4937","instance":4937,"id":241624,"goal":"predicate InRange_4937(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_4938","instance":4938,"id":241625,"goal":"predicate SubsetOf_4938(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_4939","instance":4939,"id":241626,"goal":"predicate AllMem_4939(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_4940","instance":4940,"id":241627,"goal":"predicate DisjointSets_4940(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_4941","instance":4941,"id":241628,"goal":"predicate Sorted_4941(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_4942","instance":4942,"id":241629,"goal":"predicate AllPositive_4942(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_4943","instance":4943,"id":241630,"goal":"predicate DistinctSeq_4943(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_4944","instance":4944,"id":241631,"goal":"predicate IsSubseq_4944(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_4945","instance":4945,"id":241632,"goal":"predicate IsPermutation_4945(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_4946","instance":4946,"id":241633,"goal":"predicate IsEven_4946(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_4947","instance":4947,"id":241634,"goal":"predicate InRange_4947(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_4948","instance":4948,"id":241635,"goal":"predicate SubsetOf_4948(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_4949","instance":4949,"id":241636,"goal":"predicate AllMem_4949(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_4950","instance":4950,"id":241637,"goal":"predicate DisjointSets_4950(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_4951","instance":4951,"id":241638,"goal":"predicate Sorted_4951(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_4952","instance":4952,"id":241639,"goal":"predicate AllPositive_4952(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_4953","instance":4953,"id":241640,"goal":"predicate DistinctSeq_4953(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_4954","instance":4954,"id":241641,"goal":"predicate IsSubseq_4954(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_4955","instance":4955,"id":241642,"goal":"predicate IsPermutation_4955(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_4956","instance":4956,"id":241643,"goal":"predicate IsEven_4956(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_4957","instance":4957,"id":241644,"goal":"predicate InRange_4957(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_4958","instance":4958,"id":241645,"goal":"predicate SubsetOf_4958(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_4959","instance":4959,"id":241646,"goal":"predicate AllMem_4959(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_4960","instance":4960,"id":241647,"goal":"predicate DisjointSets_4960(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_4961","instance":4961,"id":241648,"goal":"predicate Sorted_4961(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_4962","instance":4962,"id":241649,"goal":"predicate AllPositive_4962(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_4963","instance":4963,"id":241650,"goal":"predicate DistinctSeq_4963(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_4964","instance":4964,"id":241651,"goal":"predicate IsSubseq_4964(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_4965","instance":4965,"id":241652,"goal":"predicate IsPermutation_4965(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_4966","instance":4966,"id":241653,"goal":"predicate IsEven_4966(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_4967","instance":4967,"id":241654,"goal":"predicate InRange_4967(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_4968","instance":4968,"id":241655,"goal":"predicate SubsetOf_4968(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_4969","instance":4969,"id":241656,"goal":"predicate AllMem_4969(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_4970","instance":4970,"id":241657,"goal":"predicate DisjointSets_4970(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_4971","instance":4971,"id":241658,"goal":"predicate Sorted_4971(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_4972","instance":4972,"id":241659,"goal":"predicate AllPositive_4972(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_4973","instance":4973,"id":241660,"goal":"predicate DistinctSeq_4973(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_4974","instance":4974,"id":241661,"goal":"predicate IsSubseq_4974(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_4975","instance":4975,"id":241662,"goal":"predicate IsPermutation_4975(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_4976","instance":4976,"id":241663,"goal":"predicate IsEven_4976(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_4977","instance":4977,"id":241664,"goal":"predicate InRange_4977(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_4978","instance":4978,"id":241665,"goal":"predicate SubsetOf_4978(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_4979","instance":4979,"id":241666,"goal":"predicate AllMem_4979(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_4980","instance":4980,"id":241667,"goal":"predicate DisjointSets_4980(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_4981","instance":4981,"id":241668,"goal":"predicate Sorted_4981(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_4982","instance":4982,"id":241669,"goal":"predicate AllPositive_4982(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_4983","instance":4983,"id":241670,"goal":"predicate DistinctSeq_4983(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_4984","instance":4984,"id":241671,"goal":"predicate IsSubseq_4984(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_4985","instance":4985,"id":241672,"goal":"predicate IsPermutation_4985(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_4986","instance":4986,"id":241673,"goal":"predicate IsEven_4986(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_4987","instance":4987,"id":241674,"goal":"predicate InRange_4987(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_4988","instance":4988,"id":241675,"goal":"predicate SubsetOf_4988(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_4989","instance":4989,"id":241676,"goal":"predicate AllMem_4989(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_4990","instance":4990,"id":241677,"goal":"predicate DisjointSets_4990(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_4991","instance":4991,"id":241678,"goal":"predicate Sorted_4991(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_4992","instance":4992,"id":241679,"goal":"predicate AllPositive_4992(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_4993","instance":4993,"id":241680,"goal":"predicate DistinctSeq_4993(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_4994","instance":4994,"id":241681,"goal":"predicate IsSubseq_4994(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_4995","instance":4995,"id":241682,"goal":"predicate IsPermutation_4995(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_4996","instance":4996,"id":241683,"goal":"predicate IsEven_4996(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_4997","instance":4997,"id":241684,"goal":"predicate InRange_4997(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_4998","instance":4998,"id":241685,"goal":"predicate SubsetOf_4998(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_4999","instance":4999,"id":241686,"goal":"predicate AllMem_4999(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_5000","instance":5000,"id":241687,"goal":"predicate DisjointSets_5000(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_5001","instance":5001,"id":241688,"goal":"predicate Sorted_5001(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_5002","instance":5002,"id":241689,"goal":"predicate AllPositive_5002(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_5003","instance":5003,"id":241690,"goal":"predicate DistinctSeq_5003(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_5004","instance":5004,"id":241691,"goal":"predicate IsSubseq_5004(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_5005","instance":5005,"id":241692,"goal":"predicate IsPermutation_5005(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_5006","instance":5006,"id":241693,"goal":"predicate IsEven_5006(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_5007","instance":5007,"id":241694,"goal":"predicate InRange_5007(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_5008","instance":5008,"id":241695,"goal":"predicate SubsetOf_5008(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_5009","instance":5009,"id":241696,"goal":"predicate AllMem_5009(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_5010","instance":5010,"id":241697,"goal":"predicate DisjointSets_5010(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_5011","instance":5011,"id":241698,"goal":"predicate Sorted_5011(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_5012","instance":5012,"id":241699,"goal":"predicate AllPositive_5012(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_5013","instance":5013,"id":241700,"goal":"predicate DistinctSeq_5013(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_5014","instance":5014,"id":241701,"goal":"predicate IsSubseq_5014(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_5015","instance":5015,"id":241702,"goal":"predicate IsPermutation_5015(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_5016","instance":5016,"id":241703,"goal":"predicate IsEven_5016(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_5017","instance":5017,"id":241704,"goal":"predicate InRange_5017(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_5018","instance":5018,"id":241705,"goal":"predicate SubsetOf_5018(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_5019","instance":5019,"id":241706,"goal":"predicate AllMem_5019(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_5020","instance":5020,"id":241707,"goal":"predicate DisjointSets_5020(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_5021","instance":5021,"id":241708,"goal":"predicate Sorted_5021(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_5022","instance":5022,"id":241709,"goal":"predicate AllPositive_5022(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_5023","instance":5023,"id":241710,"goal":"predicate DistinctSeq_5023(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_5024","instance":5024,"id":241711,"goal":"predicate IsSubseq_5024(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_5025","instance":5025,"id":241712,"goal":"predicate IsPermutation_5025(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_5026","instance":5026,"id":241713,"goal":"predicate IsEven_5026(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_5027","instance":5027,"id":241714,"goal":"predicate InRange_5027(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_5028","instance":5028,"id":241715,"goal":"predicate SubsetOf_5028(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_5029","instance":5029,"id":241716,"goal":"predicate AllMem_5029(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_5030","instance":5030,"id":241717,"goal":"predicate DisjointSets_5030(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_5031","instance":5031,"id":241718,"goal":"predicate Sorted_5031(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_5032","instance":5032,"id":241719,"goal":"predicate AllPositive_5032(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_5033","instance":5033,"id":241720,"goal":"predicate DistinctSeq_5033(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_5034","instance":5034,"id":241721,"goal":"predicate IsSubseq_5034(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_5035","instance":5035,"id":241722,"goal":"predicate IsPermutation_5035(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_5036","instance":5036,"id":241723,"goal":"predicate IsEven_5036(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_5037","instance":5037,"id":241724,"goal":"predicate InRange_5037(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_5038","instance":5038,"id":241725,"goal":"predicate SubsetOf_5038(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_5039","instance":5039,"id":241726,"goal":"predicate AllMem_5039(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_5040","instance":5040,"id":241727,"goal":"predicate DisjointSets_5040(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_5041","instance":5041,"id":241728,"goal":"predicate Sorted_5041(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_5042","instance":5042,"id":241729,"goal":"predicate AllPositive_5042(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_5043","instance":5043,"id":241730,"goal":"predicate DistinctSeq_5043(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_5044","instance":5044,"id":241731,"goal":"predicate IsSubseq_5044(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_5045","instance":5045,"id":241732,"goal":"predicate IsPermutation_5045(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_5046","instance":5046,"id":241733,"goal":"predicate IsEven_5046(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_5047","instance":5047,"id":241734,"goal":"predicate InRange_5047(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_5048","instance":5048,"id":241735,"goal":"predicate SubsetOf_5048(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_5049","instance":5049,"id":241736,"goal":"predicate AllMem_5049(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_5050","instance":5050,"id":241737,"goal":"predicate DisjointSets_5050(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_5051","instance":5051,"id":241738,"goal":"predicate Sorted_5051(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_5052","instance":5052,"id":241739,"goal":"predicate AllPositive_5052(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_5053","instance":5053,"id":241740,"goal":"predicate DistinctSeq_5053(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_5054","instance":5054,"id":241741,"goal":"predicate IsSubseq_5054(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_5055","instance":5055,"id":241742,"goal":"predicate IsPermutation_5055(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_5056","instance":5056,"id":241743,"goal":"predicate IsEven_5056(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_5057","instance":5057,"id":241744,"goal":"predicate InRange_5057(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_5058","instance":5058,"id":241745,"goal":"predicate SubsetOf_5058(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_5059","instance":5059,"id":241746,"goal":"predicate AllMem_5059(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_5060","instance":5060,"id":241747,"goal":"predicate DisjointSets_5060(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_5061","instance":5061,"id":241748,"goal":"predicate Sorted_5061(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_5062","instance":5062,"id":241749,"goal":"predicate AllPositive_5062(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_5063","instance":5063,"id":241750,"goal":"predicate DistinctSeq_5063(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_5064","instance":5064,"id":241751,"goal":"predicate IsSubseq_5064(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_5065","instance":5065,"id":241752,"goal":"predicate IsPermutation_5065(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_5066","instance":5066,"id":241753,"goal":"predicate IsEven_5066(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_5067","instance":5067,"id":241754,"goal":"predicate InRange_5067(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_5068","instance":5068,"id":241755,"goal":"predicate SubsetOf_5068(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_5069","instance":5069,"id":241756,"goal":"predicate AllMem_5069(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_5070","instance":5070,"id":241757,"goal":"predicate DisjointSets_5070(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_5071","instance":5071,"id":241758,"goal":"predicate Sorted_5071(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_5072","instance":5072,"id":241759,"goal":"predicate AllPositive_5072(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_5073","instance":5073,"id":241760,"goal":"predicate DistinctSeq_5073(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_5074","instance":5074,"id":241761,"goal":"predicate IsSubseq_5074(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_5075","instance":5075,"id":241762,"goal":"predicate IsPermutation_5075(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_5076","instance":5076,"id":241763,"goal":"predicate IsEven_5076(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_5077","instance":5077,"id":241764,"goal":"predicate InRange_5077(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_5078","instance":5078,"id":241765,"goal":"predicate SubsetOf_5078(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_5079","instance":5079,"id":241766,"goal":"predicate AllMem_5079(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_5080","instance":5080,"id":241767,"goal":"predicate DisjointSets_5080(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_5081","instance":5081,"id":241768,"goal":"predicate Sorted_5081(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_5082","instance":5082,"id":241769,"goal":"predicate AllPositive_5082(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_5083","instance":5083,"id":241770,"goal":"predicate DistinctSeq_5083(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_5084","instance":5084,"id":241771,"goal":"predicate IsSubseq_5084(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_5085","instance":5085,"id":241772,"goal":"predicate IsPermutation_5085(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_5086","instance":5086,"id":241773,"goal":"predicate IsEven_5086(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_5087","instance":5087,"id":241774,"goal":"predicate InRange_5087(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_5088","instance":5088,"id":241775,"goal":"predicate SubsetOf_5088(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_5089","instance":5089,"id":241776,"goal":"predicate AllMem_5089(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_5090","instance":5090,"id":241777,"goal":"predicate DisjointSets_5090(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_5091","instance":5091,"id":241778,"goal":"predicate Sorted_5091(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_5092","instance":5092,"id":241779,"goal":"predicate AllPositive_5092(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_5093","instance":5093,"id":241780,"goal":"predicate DistinctSeq_5093(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_5094","instance":5094,"id":241781,"goal":"predicate IsSubseq_5094(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_5095","instance":5095,"id":241782,"goal":"predicate IsPermutation_5095(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_5096","instance":5096,"id":241783,"goal":"predicate IsEven_5096(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_5097","instance":5097,"id":241784,"goal":"predicate InRange_5097(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_5098","instance":5098,"id":241785,"goal":"predicate SubsetOf_5098(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_5099","instance":5099,"id":241786,"goal":"predicate AllMem_5099(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_5100","instance":5100,"id":241787,"goal":"predicate DisjointSets_5100(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_5101","instance":5101,"id":241788,"goal":"predicate Sorted_5101(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_5102","instance":5102,"id":241789,"goal":"predicate AllPositive_5102(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_5103","instance":5103,"id":241790,"goal":"predicate DistinctSeq_5103(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_5104","instance":5104,"id":241791,"goal":"predicate IsSubseq_5104(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_5105","instance":5105,"id":241792,"goal":"predicate IsPermutation_5105(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_5106","instance":5106,"id":241793,"goal":"predicate IsEven_5106(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_5107","instance":5107,"id":241794,"goal":"predicate InRange_5107(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_5108","instance":5108,"id":241795,"goal":"predicate SubsetOf_5108(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_5109","instance":5109,"id":241796,"goal":"predicate AllMem_5109(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_5110","instance":5110,"id":241797,"goal":"predicate DisjointSets_5110(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_5111","instance":5111,"id":241798,"goal":"predicate Sorted_5111(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_5112","instance":5112,"id":241799,"goal":"predicate AllPositive_5112(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_5113","instance":5113,"id":241800,"goal":"predicate DistinctSeq_5113(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_5114","instance":5114,"id":241801,"goal":"predicate IsSubseq_5114(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_5115","instance":5115,"id":241802,"goal":"predicate IsPermutation_5115(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_5116","instance":5116,"id":241803,"goal":"predicate IsEven_5116(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_5117","instance":5117,"id":241804,"goal":"predicate InRange_5117(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_5118","instance":5118,"id":241805,"goal":"predicate SubsetOf_5118(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_5119","instance":5119,"id":241806,"goal":"predicate AllMem_5119(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_5120","instance":5120,"id":241807,"goal":"predicate DisjointSets_5120(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_5121","instance":5121,"id":241808,"goal":"predicate Sorted_5121(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_5122","instance":5122,"id":241809,"goal":"predicate AllPositive_5122(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_5123","instance":5123,"id":241810,"goal":"predicate DistinctSeq_5123(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_5124","instance":5124,"id":241811,"goal":"predicate IsSubseq_5124(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_5125","instance":5125,"id":241812,"goal":"predicate IsPermutation_5125(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_5126","instance":5126,"id":241813,"goal":"predicate IsEven_5126(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_5127","instance":5127,"id":241814,"goal":"predicate InRange_5127(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_5128","instance":5128,"id":241815,"goal":"predicate SubsetOf_5128(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_5129","instance":5129,"id":241816,"goal":"predicate AllMem_5129(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_5130","instance":5130,"id":241817,"goal":"predicate DisjointSets_5130(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_5131","instance":5131,"id":241818,"goal":"predicate Sorted_5131(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_5132","instance":5132,"id":241819,"goal":"predicate AllPositive_5132(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_5133","instance":5133,"id":241820,"goal":"predicate DistinctSeq_5133(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_5134","instance":5134,"id":241821,"goal":"predicate IsSubseq_5134(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_5135","instance":5135,"id":241822,"goal":"predicate IsPermutation_5135(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_5136","instance":5136,"id":241823,"goal":"predicate IsEven_5136(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_5137","instance":5137,"id":241824,"goal":"predicate InRange_5137(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_5138","instance":5138,"id":241825,"goal":"predicate SubsetOf_5138(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_5139","instance":5139,"id":241826,"goal":"predicate AllMem_5139(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_5140","instance":5140,"id":241827,"goal":"predicate DisjointSets_5140(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_5141","instance":5141,"id":241828,"goal":"predicate Sorted_5141(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_5142","instance":5142,"id":241829,"goal":"predicate AllPositive_5142(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_5143","instance":5143,"id":241830,"goal":"predicate DistinctSeq_5143(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_5144","instance":5144,"id":241831,"goal":"predicate IsSubseq_5144(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_5145","instance":5145,"id":241832,"goal":"predicate IsPermutation_5145(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_5146","instance":5146,"id":241833,"goal":"predicate IsEven_5146(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_5147","instance":5147,"id":241834,"goal":"predicate InRange_5147(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_5148","instance":5148,"id":241835,"goal":"predicate SubsetOf_5148(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_5149","instance":5149,"id":241836,"goal":"predicate AllMem_5149(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_5150","instance":5150,"id":241837,"goal":"predicate DisjointSets_5150(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_5151","instance":5151,"id":241838,"goal":"predicate Sorted_5151(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_5152","instance":5152,"id":241839,"goal":"predicate AllPositive_5152(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_5153","instance":5153,"id":241840,"goal":"predicate DistinctSeq_5153(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_5154","instance":5154,"id":241841,"goal":"predicate IsSubseq_5154(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_5155","instance":5155,"id":241842,"goal":"predicate IsPermutation_5155(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_5156","instance":5156,"id":241843,"goal":"predicate IsEven_5156(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_5157","instance":5157,"id":241844,"goal":"predicate InRange_5157(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_5158","instance":5158,"id":241845,"goal":"predicate SubsetOf_5158(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_5159","instance":5159,"id":241846,"goal":"predicate AllMem_5159(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_5160","instance":5160,"id":241847,"goal":"predicate DisjointSets_5160(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_5161","instance":5161,"id":241848,"goal":"predicate Sorted_5161(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_5162","instance":5162,"id":241849,"goal":"predicate AllPositive_5162(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_5163","instance":5163,"id":241850,"goal":"predicate DistinctSeq_5163(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_5164","instance":5164,"id":241851,"goal":"predicate IsSubseq_5164(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_5165","instance":5165,"id":241852,"goal":"predicate IsPermutation_5165(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_5166","instance":5166,"id":241853,"goal":"predicate IsEven_5166(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_5167","instance":5167,"id":241854,"goal":"predicate InRange_5167(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_5168","instance":5168,"id":241855,"goal":"predicate SubsetOf_5168(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_5169","instance":5169,"id":241856,"goal":"predicate AllMem_5169(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_5170","instance":5170,"id":241857,"goal":"predicate DisjointSets_5170(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_5171","instance":5171,"id":241858,"goal":"predicate Sorted_5171(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_5172","instance":5172,"id":241859,"goal":"predicate AllPositive_5172(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_5173","instance":5173,"id":241860,"goal":"predicate DistinctSeq_5173(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_5174","instance":5174,"id":241861,"goal":"predicate IsSubseq_5174(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_5175","instance":5175,"id":241862,"goal":"predicate IsPermutation_5175(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_5176","instance":5176,"id":241863,"goal":"predicate IsEven_5176(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_5177","instance":5177,"id":241864,"goal":"predicate InRange_5177(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_5178","instance":5178,"id":241865,"goal":"predicate SubsetOf_5178(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_5179","instance":5179,"id":241866,"goal":"predicate AllMem_5179(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_5180","instance":5180,"id":241867,"goal":"predicate DisjointSets_5180(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_5181","instance":5181,"id":241868,"goal":"predicate Sorted_5181(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_5182","instance":5182,"id":241869,"goal":"predicate AllPositive_5182(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_5183","instance":5183,"id":241870,"goal":"predicate DistinctSeq_5183(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_5184","instance":5184,"id":241871,"goal":"predicate IsSubseq_5184(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_5185","instance":5185,"id":241872,"goal":"predicate IsPermutation_5185(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_5186","instance":5186,"id":241873,"goal":"predicate IsEven_5186(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_5187","instance":5187,"id":241874,"goal":"predicate InRange_5187(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_5188","instance":5188,"id":241875,"goal":"predicate SubsetOf_5188(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_5189","instance":5189,"id":241876,"goal":"predicate AllMem_5189(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_5190","instance":5190,"id":241877,"goal":"predicate DisjointSets_5190(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_5191","instance":5191,"id":241878,"goal":"predicate Sorted_5191(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_5192","instance":5192,"id":241879,"goal":"predicate AllPositive_5192(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_5193","instance":5193,"id":241880,"goal":"predicate DistinctSeq_5193(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_5194","instance":5194,"id":241881,"goal":"predicate IsSubseq_5194(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_5195","instance":5195,"id":241882,"goal":"predicate IsPermutation_5195(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_5196","instance":5196,"id":241883,"goal":"predicate IsEven_5196(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_5197","instance":5197,"id":241884,"goal":"predicate InRange_5197(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_5198","instance":5198,"id":241885,"goal":"predicate SubsetOf_5198(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_5199","instance":5199,"id":241886,"goal":"predicate AllMem_5199(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_5200","instance":5200,"id":241887,"goal":"predicate DisjointSets_5200(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_5201","instance":5201,"id":241888,"goal":"predicate Sorted_5201(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_5202","instance":5202,"id":241889,"goal":"predicate AllPositive_5202(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_5203","instance":5203,"id":241890,"goal":"predicate DistinctSeq_5203(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_5204","instance":5204,"id":241891,"goal":"predicate IsSubseq_5204(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_5205","instance":5205,"id":241892,"goal":"predicate IsPermutation_5205(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_5206","instance":5206,"id":241893,"goal":"predicate IsEven_5206(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_5207","instance":5207,"id":241894,"goal":"predicate InRange_5207(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_5208","instance":5208,"id":241895,"goal":"predicate SubsetOf_5208(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_5209","instance":5209,"id":241896,"goal":"predicate AllMem_5209(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_5210","instance":5210,"id":241897,"goal":"predicate DisjointSets_5210(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_5211","instance":5211,"id":241898,"goal":"predicate Sorted_5211(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_5212","instance":5212,"id":241899,"goal":"predicate AllPositive_5212(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_5213","instance":5213,"id":241900,"goal":"predicate DistinctSeq_5213(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_5214","instance":5214,"id":241901,"goal":"predicate IsSubseq_5214(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_5215","instance":5215,"id":241902,"goal":"predicate IsPermutation_5215(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_5216","instance":5216,"id":241903,"goal":"predicate IsEven_5216(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_5217","instance":5217,"id":241904,"goal":"predicate InRange_5217(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_5218","instance":5218,"id":241905,"goal":"predicate SubsetOf_5218(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_5219","instance":5219,"id":241906,"goal":"predicate AllMem_5219(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_5220","instance":5220,"id":241907,"goal":"predicate DisjointSets_5220(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_5221","instance":5221,"id":241908,"goal":"predicate Sorted_5221(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_5222","instance":5222,"id":241909,"goal":"predicate AllPositive_5222(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_5223","instance":5223,"id":241910,"goal":"predicate DistinctSeq_5223(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_5224","instance":5224,"id":241911,"goal":"predicate IsSubseq_5224(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_5225","instance":5225,"id":241912,"goal":"predicate IsPermutation_5225(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_5226","instance":5226,"id":241913,"goal":"predicate IsEven_5226(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_5227","instance":5227,"id":241914,"goal":"predicate InRange_5227(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_5228","instance":5228,"id":241915,"goal":"predicate SubsetOf_5228(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_5229","instance":5229,"id":241916,"goal":"predicate AllMem_5229(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_5230","instance":5230,"id":241917,"goal":"predicate DisjointSets_5230(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_5231","instance":5231,"id":241918,"goal":"predicate Sorted_5231(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_5232","instance":5232,"id":241919,"goal":"predicate AllPositive_5232(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_5233","instance":5233,"id":241920,"goal":"predicate DistinctSeq_5233(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_5234","instance":5234,"id":241921,"goal":"predicate IsSubseq_5234(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_5235","instance":5235,"id":241922,"goal":"predicate IsPermutation_5235(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_5236","instance":5236,"id":241923,"goal":"predicate IsEven_5236(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_5237","instance":5237,"id":241924,"goal":"predicate InRange_5237(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_5238","instance":5238,"id":241925,"goal":"predicate SubsetOf_5238(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_5239","instance":5239,"id":241926,"goal":"predicate AllMem_5239(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_5240","instance":5240,"id":241927,"goal":"predicate DisjointSets_5240(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_5241","instance":5241,"id":241928,"goal":"predicate Sorted_5241(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_5242","instance":5242,"id":241929,"goal":"predicate AllPositive_5242(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_5243","instance":5243,"id":241930,"goal":"predicate DistinctSeq_5243(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_5244","instance":5244,"id":241931,"goal":"predicate IsSubseq_5244(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_5245","instance":5245,"id":241932,"goal":"predicate IsPermutation_5245(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_5246","instance":5246,"id":241933,"goal":"predicate IsEven_5246(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_5247","instance":5247,"id":241934,"goal":"predicate InRange_5247(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_5248","instance":5248,"id":241935,"goal":"predicate SubsetOf_5248(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_5249","instance":5249,"id":241936,"goal":"predicate AllMem_5249(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_5250","instance":5250,"id":241937,"goal":"predicate DisjointSets_5250(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_5251","instance":5251,"id":241938,"goal":"predicate Sorted_5251(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_5252","instance":5252,"id":241939,"goal":"predicate AllPositive_5252(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_5253","instance":5253,"id":241940,"goal":"predicate DistinctSeq_5253(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_5254","instance":5254,"id":241941,"goal":"predicate IsSubseq_5254(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_5255","instance":5255,"id":241942,"goal":"predicate IsPermutation_5255(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_5256","instance":5256,"id":241943,"goal":"predicate IsEven_5256(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_5257","instance":5257,"id":241944,"goal":"predicate InRange_5257(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_5258","instance":5258,"id":241945,"goal":"predicate SubsetOf_5258(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_5259","instance":5259,"id":241946,"goal":"predicate AllMem_5259(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_5260","instance":5260,"id":241947,"goal":"predicate DisjointSets_5260(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_5261","instance":5261,"id":241948,"goal":"predicate Sorted_5261(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_5262","instance":5262,"id":241949,"goal":"predicate AllPositive_5262(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_5263","instance":5263,"id":241950,"goal":"predicate DistinctSeq_5263(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_5264","instance":5264,"id":241951,"goal":"predicate IsSubseq_5264(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_5265","instance":5265,"id":241952,"goal":"predicate IsPermutation_5265(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_5266","instance":5266,"id":241953,"goal":"predicate IsEven_5266(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_5267","instance":5267,"id":241954,"goal":"predicate InRange_5267(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_5268","instance":5268,"id":241955,"goal":"predicate SubsetOf_5268(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_5269","instance":5269,"id":241956,"goal":"predicate AllMem_5269(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_5270","instance":5270,"id":241957,"goal":"predicate DisjointSets_5270(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_5271","instance":5271,"id":241958,"goal":"predicate Sorted_5271(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_5272","instance":5272,"id":241959,"goal":"predicate AllPositive_5272(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_5273","instance":5273,"id":241960,"goal":"predicate DistinctSeq_5273(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_5274","instance":5274,"id":241961,"goal":"predicate IsSubseq_5274(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_5275","instance":5275,"id":241962,"goal":"predicate IsPermutation_5275(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_5276","instance":5276,"id":241963,"goal":"predicate IsEven_5276(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_5277","instance":5277,"id":241964,"goal":"predicate InRange_5277(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_5278","instance":5278,"id":241965,"goal":"predicate SubsetOf_5278(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_5279","instance":5279,"id":241966,"goal":"predicate AllMem_5279(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_5280","instance":5280,"id":241967,"goal":"predicate DisjointSets_5280(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_5281","instance":5281,"id":241968,"goal":"predicate Sorted_5281(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_5282","instance":5282,"id":241969,"goal":"predicate AllPositive_5282(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_5283","instance":5283,"id":241970,"goal":"predicate DistinctSeq_5283(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_5284","instance":5284,"id":241971,"goal":"predicate IsSubseq_5284(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_5285","instance":5285,"id":241972,"goal":"predicate IsPermutation_5285(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_5286","instance":5286,"id":241973,"goal":"predicate IsEven_5286(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_5287","instance":5287,"id":241974,"goal":"predicate InRange_5287(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_5288","instance":5288,"id":241975,"goal":"predicate SubsetOf_5288(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_5289","instance":5289,"id":241976,"goal":"predicate AllMem_5289(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_5290","instance":5290,"id":241977,"goal":"predicate DisjointSets_5290(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_5291","instance":5291,"id":241978,"goal":"predicate Sorted_5291(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_5292","instance":5292,"id":241979,"goal":"predicate AllPositive_5292(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_5293","instance":5293,"id":241980,"goal":"predicate DistinctSeq_5293(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_5294","instance":5294,"id":241981,"goal":"predicate IsSubseq_5294(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_5295","instance":5295,"id":241982,"goal":"predicate IsPermutation_5295(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_5296","instance":5296,"id":241983,"goal":"predicate IsEven_5296(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_5297","instance":5297,"id":241984,"goal":"predicate InRange_5297(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_5298","instance":5298,"id":241985,"goal":"predicate SubsetOf_5298(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_5299","instance":5299,"id":241986,"goal":"predicate AllMem_5299(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_5300","instance":5300,"id":241987,"goal":"predicate DisjointSets_5300(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_5301","instance":5301,"id":241988,"goal":"predicate Sorted_5301(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_5302","instance":5302,"id":241989,"goal":"predicate AllPositive_5302(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_5303","instance":5303,"id":241990,"goal":"predicate DistinctSeq_5303(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_5304","instance":5304,"id":241991,"goal":"predicate IsSubseq_5304(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_5305","instance":5305,"id":241992,"goal":"predicate IsPermutation_5305(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_5306","instance":5306,"id":241993,"goal":"predicate IsEven_5306(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_5307","instance":5307,"id":241994,"goal":"predicate InRange_5307(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_5308","instance":5308,"id":241995,"goal":"predicate SubsetOf_5308(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_5309","instance":5309,"id":241996,"goal":"predicate AllMem_5309(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_5310","instance":5310,"id":241997,"goal":"predicate DisjointSets_5310(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_5311","instance":5311,"id":241998,"goal":"predicate Sorted_5311(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_5312","instance":5312,"id":241999,"goal":"predicate AllPositive_5312(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_5313","instance":5313,"id":242000,"goal":"predicate DistinctSeq_5313(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_5314","instance":5314,"id":242001,"goal":"predicate IsSubseq_5314(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_5315","instance":5315,"id":242002,"goal":"predicate IsPermutation_5315(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_5316","instance":5316,"id":242003,"goal":"predicate IsEven_5316(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_5317","instance":5317,"id":242004,"goal":"predicate InRange_5317(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_5318","instance":5318,"id":242005,"goal":"predicate SubsetOf_5318(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_5319","instance":5319,"id":242006,"goal":"predicate AllMem_5319(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_5320","instance":5320,"id":242007,"goal":"predicate DisjointSets_5320(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_5321","instance":5321,"id":242008,"goal":"predicate Sorted_5321(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_5322","instance":5322,"id":242009,"goal":"predicate AllPositive_5322(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_5323","instance":5323,"id":242010,"goal":"predicate DistinctSeq_5323(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_5324","instance":5324,"id":242011,"goal":"predicate IsSubseq_5324(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_5325","instance":5325,"id":242012,"goal":"predicate IsPermutation_5325(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_5326","instance":5326,"id":242013,"goal":"predicate IsEven_5326(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_5327","instance":5327,"id":242014,"goal":"predicate InRange_5327(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_5328","instance":5328,"id":242015,"goal":"predicate SubsetOf_5328(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_5329","instance":5329,"id":242016,"goal":"predicate AllMem_5329(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_5330","instance":5330,"id":242017,"goal":"predicate DisjointSets_5330(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_5331","instance":5331,"id":242018,"goal":"predicate Sorted_5331(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_5332","instance":5332,"id":242019,"goal":"predicate AllPositive_5332(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_5333","instance":5333,"id":242020,"goal":"predicate DistinctSeq_5333(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_5334","instance":5334,"id":242021,"goal":"predicate IsSubseq_5334(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_5335","instance":5335,"id":242022,"goal":"predicate IsPermutation_5335(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_5336","instance":5336,"id":242023,"goal":"predicate IsEven_5336(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_5337","instance":5337,"id":242024,"goal":"predicate InRange_5337(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_5338","instance":5338,"id":242025,"goal":"predicate SubsetOf_5338(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_5339","instance":5339,"id":242026,"goal":"predicate AllMem_5339(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_5340","instance":5340,"id":242027,"goal":"predicate DisjointSets_5340(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_5341","instance":5341,"id":242028,"goal":"predicate Sorted_5341(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_5342","instance":5342,"id":242029,"goal":"predicate AllPositive_5342(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_5343","instance":5343,"id":242030,"goal":"predicate DistinctSeq_5343(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_5344","instance":5344,"id":242031,"goal":"predicate IsSubseq_5344(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_5345","instance":5345,"id":242032,"goal":"predicate IsPermutation_5345(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_5346","instance":5346,"id":242033,"goal":"predicate IsEven_5346(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_5347","instance":5347,"id":242034,"goal":"predicate InRange_5347(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_5348","instance":5348,"id":242035,"goal":"predicate SubsetOf_5348(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_5349","instance":5349,"id":242036,"goal":"predicate AllMem_5349(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_5350","instance":5350,"id":242037,"goal":"predicate DisjointSets_5350(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_5351","instance":5351,"id":242038,"goal":"predicate Sorted_5351(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_5352","instance":5352,"id":242039,"goal":"predicate AllPositive_5352(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_5353","instance":5353,"id":242040,"goal":"predicate DistinctSeq_5353(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_5354","instance":5354,"id":242041,"goal":"predicate IsSubseq_5354(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_5355","instance":5355,"id":242042,"goal":"predicate IsPermutation_5355(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_5356","instance":5356,"id":242043,"goal":"predicate IsEven_5356(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_5357","instance":5357,"id":242044,"goal":"predicate InRange_5357(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_5358","instance":5358,"id":242045,"goal":"predicate SubsetOf_5358(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_5359","instance":5359,"id":242046,"goal":"predicate AllMem_5359(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_5360","instance":5360,"id":242047,"goal":"predicate DisjointSets_5360(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_5361","instance":5361,"id":242048,"goal":"predicate Sorted_5361(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_5362","instance":5362,"id":242049,"goal":"predicate AllPositive_5362(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_5363","instance":5363,"id":242050,"goal":"predicate DistinctSeq_5363(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_5364","instance":5364,"id":242051,"goal":"predicate IsSubseq_5364(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_5365","instance":5365,"id":242052,"goal":"predicate IsPermutation_5365(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_5366","instance":5366,"id":242053,"goal":"predicate IsEven_5366(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_5367","instance":5367,"id":242054,"goal":"predicate InRange_5367(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_5368","instance":5368,"id":242055,"goal":"predicate SubsetOf_5368(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_5369","instance":5369,"id":242056,"goal":"predicate AllMem_5369(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_5370","instance":5370,"id":242057,"goal":"predicate DisjointSets_5370(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_5371","instance":5371,"id":242058,"goal":"predicate Sorted_5371(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_5372","instance":5372,"id":242059,"goal":"predicate AllPositive_5372(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_5373","instance":5373,"id":242060,"goal":"predicate DistinctSeq_5373(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_5374","instance":5374,"id":242061,"goal":"predicate IsSubseq_5374(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_5375","instance":5375,"id":242062,"goal":"predicate IsPermutation_5375(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_5376","instance":5376,"id":242063,"goal":"predicate IsEven_5376(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_5377","instance":5377,"id":242064,"goal":"predicate InRange_5377(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_5378","instance":5378,"id":242065,"goal":"predicate SubsetOf_5378(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_5379","instance":5379,"id":242066,"goal":"predicate AllMem_5379(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_5380","instance":5380,"id":242067,"goal":"predicate DisjointSets_5380(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_5381","instance":5381,"id":242068,"goal":"predicate Sorted_5381(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_5382","instance":5382,"id":242069,"goal":"predicate AllPositive_5382(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_5383","instance":5383,"id":242070,"goal":"predicate DistinctSeq_5383(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_5384","instance":5384,"id":242071,"goal":"predicate IsSubseq_5384(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_5385","instance":5385,"id":242072,"goal":"predicate IsPermutation_5385(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_5386","instance":5386,"id":242073,"goal":"predicate IsEven_5386(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_5387","instance":5387,"id":242074,"goal":"predicate InRange_5387(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_5388","instance":5388,"id":242075,"goal":"predicate SubsetOf_5388(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_5389","instance":5389,"id":242076,"goal":"predicate AllMem_5389(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_5390","instance":5390,"id":242077,"goal":"predicate DisjointSets_5390(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_5391","instance":5391,"id":242078,"goal":"predicate Sorted_5391(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_5392","instance":5392,"id":242079,"goal":"predicate AllPositive_5392(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_5393","instance":5393,"id":242080,"goal":"predicate DistinctSeq_5393(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_5394","instance":5394,"id":242081,"goal":"predicate IsSubseq_5394(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_5395","instance":5395,"id":242082,"goal":"predicate IsPermutation_5395(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_5396","instance":5396,"id":242083,"goal":"predicate IsEven_5396(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_5397","instance":5397,"id":242084,"goal":"predicate InRange_5397(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_5398","instance":5398,"id":242085,"goal":"predicate SubsetOf_5398(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_5399","instance":5399,"id":242086,"goal":"predicate AllMem_5399(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_5400","instance":5400,"id":242087,"goal":"predicate DisjointSets_5400(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_5401","instance":5401,"id":242088,"goal":"predicate Sorted_5401(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_5402","instance":5402,"id":242089,"goal":"predicate AllPositive_5402(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_5403","instance":5403,"id":242090,"goal":"predicate DistinctSeq_5403(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_5404","instance":5404,"id":242091,"goal":"predicate IsSubseq_5404(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_5405","instance":5405,"id":242092,"goal":"predicate IsPermutation_5405(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_5406","instance":5406,"id":242093,"goal":"predicate IsEven_5406(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_5407","instance":5407,"id":242094,"goal":"predicate InRange_5407(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_5408","instance":5408,"id":242095,"goal":"predicate SubsetOf_5408(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_5409","instance":5409,"id":242096,"goal":"predicate AllMem_5409(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_5410","instance":5410,"id":242097,"goal":"predicate DisjointSets_5410(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_5411","instance":5411,"id":242098,"goal":"predicate Sorted_5411(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_5412","instance":5412,"id":242099,"goal":"predicate AllPositive_5412(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_5413","instance":5413,"id":242100,"goal":"predicate DistinctSeq_5413(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_5414","instance":5414,"id":242101,"goal":"predicate IsSubseq_5414(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_5415","instance":5415,"id":242102,"goal":"predicate IsPermutation_5415(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_5416","instance":5416,"id":242103,"goal":"predicate IsEven_5416(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_5417","instance":5417,"id":242104,"goal":"predicate InRange_5417(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_5418","instance":5418,"id":242105,"goal":"predicate SubsetOf_5418(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_5419","instance":5419,"id":242106,"goal":"predicate AllMem_5419(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_5420","instance":5420,"id":242107,"goal":"predicate DisjointSets_5420(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_5421","instance":5421,"id":242108,"goal":"predicate Sorted_5421(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_5422","instance":5422,"id":242109,"goal":"predicate AllPositive_5422(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_5423","instance":5423,"id":242110,"goal":"predicate DistinctSeq_5423(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_5424","instance":5424,"id":242111,"goal":"predicate IsSubseq_5424(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_5425","instance":5425,"id":242112,"goal":"predicate IsPermutation_5425(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_5426","instance":5426,"id":242113,"goal":"predicate IsEven_5426(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_5427","instance":5427,"id":242114,"goal":"predicate InRange_5427(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_5428","instance":5428,"id":242115,"goal":"predicate SubsetOf_5428(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_5429","instance":5429,"id":242116,"goal":"predicate AllMem_5429(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_5430","instance":5430,"id":242117,"goal":"predicate DisjointSets_5430(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_5431","instance":5431,"id":242118,"goal":"predicate Sorted_5431(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_5432","instance":5432,"id":242119,"goal":"predicate AllPositive_5432(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_5433","instance":5433,"id":242120,"goal":"predicate DistinctSeq_5433(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_5434","instance":5434,"id":242121,"goal":"predicate IsSubseq_5434(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_5435","instance":5435,"id":242122,"goal":"predicate IsPermutation_5435(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_5436","instance":5436,"id":242123,"goal":"predicate IsEven_5436(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_5437","instance":5437,"id":242124,"goal":"predicate InRange_5437(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_5438","instance":5438,"id":242125,"goal":"predicate SubsetOf_5438(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_5439","instance":5439,"id":242126,"goal":"predicate AllMem_5439(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_5440","instance":5440,"id":242127,"goal":"predicate DisjointSets_5440(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_5441","instance":5441,"id":242128,"goal":"predicate Sorted_5441(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_5442","instance":5442,"id":242129,"goal":"predicate AllPositive_5442(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_5443","instance":5443,"id":242130,"goal":"predicate DistinctSeq_5443(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_5444","instance":5444,"id":242131,"goal":"predicate IsSubseq_5444(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_5445","instance":5445,"id":242132,"goal":"predicate IsPermutation_5445(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_5446","instance":5446,"id":242133,"goal":"predicate IsEven_5446(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_5447","instance":5447,"id":242134,"goal":"predicate InRange_5447(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_5448","instance":5448,"id":242135,"goal":"predicate SubsetOf_5448(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_5449","instance":5449,"id":242136,"goal":"predicate AllMem_5449(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_5450","instance":5450,"id":242137,"goal":"predicate DisjointSets_5450(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_5451","instance":5451,"id":242138,"goal":"predicate Sorted_5451(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_5452","instance":5452,"id":242139,"goal":"predicate AllPositive_5452(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_5453","instance":5453,"id":242140,"goal":"predicate DistinctSeq_5453(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_5454","instance":5454,"id":242141,"goal":"predicate IsSubseq_5454(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_5455","instance":5455,"id":242142,"goal":"predicate IsPermutation_5455(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_5456","instance":5456,"id":242143,"goal":"predicate IsEven_5456(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_5457","instance":5457,"id":242144,"goal":"predicate InRange_5457(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_5458","instance":5458,"id":242145,"goal":"predicate SubsetOf_5458(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_5459","instance":5459,"id":242146,"goal":"predicate AllMem_5459(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_5460","instance":5460,"id":242147,"goal":"predicate DisjointSets_5460(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_5461","instance":5461,"id":242148,"goal":"predicate Sorted_5461(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_5462","instance":5462,"id":242149,"goal":"predicate AllPositive_5462(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_5463","instance":5463,"id":242150,"goal":"predicate DistinctSeq_5463(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_5464","instance":5464,"id":242151,"goal":"predicate IsSubseq_5464(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_5465","instance":5465,"id":242152,"goal":"predicate IsPermutation_5465(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_5466","instance":5466,"id":242153,"goal":"predicate IsEven_5466(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_5467","instance":5467,"id":242154,"goal":"predicate InRange_5467(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_5468","instance":5468,"id":242155,"goal":"predicate SubsetOf_5468(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_5469","instance":5469,"id":242156,"goal":"predicate AllMem_5469(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_5470","instance":5470,"id":242157,"goal":"predicate DisjointSets_5470(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_5471","instance":5471,"id":242158,"goal":"predicate Sorted_5471(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_5472","instance":5472,"id":242159,"goal":"predicate AllPositive_5472(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_5473","instance":5473,"id":242160,"goal":"predicate DistinctSeq_5473(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_5474","instance":5474,"id":242161,"goal":"predicate IsSubseq_5474(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_5475","instance":5475,"id":242162,"goal":"predicate IsPermutation_5475(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_5476","instance":5476,"id":242163,"goal":"predicate IsEven_5476(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_5477","instance":5477,"id":242164,"goal":"predicate InRange_5477(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_5478","instance":5478,"id":242165,"goal":"predicate SubsetOf_5478(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_5479","instance":5479,"id":242166,"goal":"predicate AllMem_5479(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_5480","instance":5480,"id":242167,"goal":"predicate DisjointSets_5480(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_5481","instance":5481,"id":242168,"goal":"predicate Sorted_5481(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_5482","instance":5482,"id":242169,"goal":"predicate AllPositive_5482(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_5483","instance":5483,"id":242170,"goal":"predicate DistinctSeq_5483(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_5484","instance":5484,"id":242171,"goal":"predicate IsSubseq_5484(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_5485","instance":5485,"id":242172,"goal":"predicate IsPermutation_5485(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_5486","instance":5486,"id":242173,"goal":"predicate IsEven_5486(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_5487","instance":5487,"id":242174,"goal":"predicate InRange_5487(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_5488","instance":5488,"id":242175,"goal":"predicate SubsetOf_5488(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_5489","instance":5489,"id":242176,"goal":"predicate AllMem_5489(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_5490","instance":5490,"id":242177,"goal":"predicate DisjointSets_5490(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_5491","instance":5491,"id":242178,"goal":"predicate Sorted_5491(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_5492","instance":5492,"id":242179,"goal":"predicate AllPositive_5492(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_5493","instance":5493,"id":242180,"goal":"predicate DistinctSeq_5493(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_5494","instance":5494,"id":242181,"goal":"predicate IsSubseq_5494(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_5495","instance":5495,"id":242182,"goal":"predicate IsPermutation_5495(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_5496","instance":5496,"id":242183,"goal":"predicate IsEven_5496(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_5497","instance":5497,"id":242184,"goal":"predicate InRange_5497(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_5498","instance":5498,"id":242185,"goal":"predicate SubsetOf_5498(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_5499","instance":5499,"id":242186,"goal":"predicate AllMem_5499(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_5500","instance":5500,"id":242187,"goal":"predicate DisjointSets_5500(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_5501","instance":5501,"id":242188,"goal":"predicate Sorted_5501(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_5502","instance":5502,"id":242189,"goal":"predicate AllPositive_5502(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_5503","instance":5503,"id":242190,"goal":"predicate DistinctSeq_5503(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_5504","instance":5504,"id":242191,"goal":"predicate IsSubseq_5504(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_5505","instance":5505,"id":242192,"goal":"predicate IsPermutation_5505(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_5506","instance":5506,"id":242193,"goal":"predicate IsEven_5506(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_5507","instance":5507,"id":242194,"goal":"predicate InRange_5507(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_5508","instance":5508,"id":242195,"goal":"predicate SubsetOf_5508(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_5509","instance":5509,"id":242196,"goal":"predicate AllMem_5509(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_5510","instance":5510,"id":242197,"goal":"predicate DisjointSets_5510(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_5511","instance":5511,"id":242198,"goal":"predicate Sorted_5511(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_5512","instance":5512,"id":242199,"goal":"predicate AllPositive_5512(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_5513","instance":5513,"id":242200,"goal":"predicate DistinctSeq_5513(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_5514","instance":5514,"id":242201,"goal":"predicate IsSubseq_5514(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_5515","instance":5515,"id":242202,"goal":"predicate IsPermutation_5515(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_5516","instance":5516,"id":242203,"goal":"predicate IsEven_5516(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_5517","instance":5517,"id":242204,"goal":"predicate InRange_5517(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_5518","instance":5518,"id":242205,"goal":"predicate SubsetOf_5518(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_5519","instance":5519,"id":242206,"goal":"predicate AllMem_5519(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_5520","instance":5520,"id":242207,"goal":"predicate DisjointSets_5520(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_5521","instance":5521,"id":242208,"goal":"predicate Sorted_5521(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_5522","instance":5522,"id":242209,"goal":"predicate AllPositive_5522(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_5523","instance":5523,"id":242210,"goal":"predicate DistinctSeq_5523(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_5524","instance":5524,"id":242211,"goal":"predicate IsSubseq_5524(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_5525","instance":5525,"id":242212,"goal":"predicate IsPermutation_5525(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_5526","instance":5526,"id":242213,"goal":"predicate IsEven_5526(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_5527","instance":5527,"id":242214,"goal":"predicate InRange_5527(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_5528","instance":5528,"id":242215,"goal":"predicate SubsetOf_5528(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_5529","instance":5529,"id":242216,"goal":"predicate AllMem_5529(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_5530","instance":5530,"id":242217,"goal":"predicate DisjointSets_5530(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_5531","instance":5531,"id":242218,"goal":"predicate Sorted_5531(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_5532","instance":5532,"id":242219,"goal":"predicate AllPositive_5532(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_5533","instance":5533,"id":242220,"goal":"predicate DistinctSeq_5533(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_5534","instance":5534,"id":242221,"goal":"predicate IsSubseq_5534(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_5535","instance":5535,"id":242222,"goal":"predicate IsPermutation_5535(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_5536","instance":5536,"id":242223,"goal":"predicate IsEven_5536(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_5537","instance":5537,"id":242224,"goal":"predicate InRange_5537(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_5538","instance":5538,"id":242225,"goal":"predicate SubsetOf_5538(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_5539","instance":5539,"id":242226,"goal":"predicate AllMem_5539(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_5540","instance":5540,"id":242227,"goal":"predicate DisjointSets_5540(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_5541","instance":5541,"id":242228,"goal":"predicate Sorted_5541(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_5542","instance":5542,"id":242229,"goal":"predicate AllPositive_5542(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_5543","instance":5543,"id":242230,"goal":"predicate DistinctSeq_5543(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_5544","instance":5544,"id":242231,"goal":"predicate IsSubseq_5544(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_5545","instance":5545,"id":242232,"goal":"predicate IsPermutation_5545(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_5546","instance":5546,"id":242233,"goal":"predicate IsEven_5546(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_5547","instance":5547,"id":242234,"goal":"predicate InRange_5547(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_5548","instance":5548,"id":242235,"goal":"predicate SubsetOf_5548(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_5549","instance":5549,"id":242236,"goal":"predicate AllMem_5549(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_5550","instance":5550,"id":242237,"goal":"predicate DisjointSets_5550(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_5551","instance":5551,"id":242238,"goal":"predicate Sorted_5551(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_5552","instance":5552,"id":242239,"goal":"predicate AllPositive_5552(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_5553","instance":5553,"id":242240,"goal":"predicate DistinctSeq_5553(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_5554","instance":5554,"id":242241,"goal":"predicate IsSubseq_5554(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_5555","instance":5555,"id":242242,"goal":"predicate IsPermutation_5555(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_5556","instance":5556,"id":242243,"goal":"predicate IsEven_5556(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_5557","instance":5557,"id":242244,"goal":"predicate InRange_5557(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_5558","instance":5558,"id":242245,"goal":"predicate SubsetOf_5558(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_5559","instance":5559,"id":242246,"goal":"predicate AllMem_5559(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_5560","instance":5560,"id":242247,"goal":"predicate DisjointSets_5560(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_5561","instance":5561,"id":242248,"goal":"predicate Sorted_5561(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_5562","instance":5562,"id":242249,"goal":"predicate AllPositive_5562(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_5563","instance":5563,"id":242250,"goal":"predicate DistinctSeq_5563(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_5564","instance":5564,"id":242251,"goal":"predicate IsSubseq_5564(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_5565","instance":5565,"id":242252,"goal":"predicate IsPermutation_5565(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_5566","instance":5566,"id":242253,"goal":"predicate IsEven_5566(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_5567","instance":5567,"id":242254,"goal":"predicate InRange_5567(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_5568","instance":5568,"id":242255,"goal":"predicate SubsetOf_5568(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_5569","instance":5569,"id":242256,"goal":"predicate AllMem_5569(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_5570","instance":5570,"id":242257,"goal":"predicate DisjointSets_5570(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_5571","instance":5571,"id":242258,"goal":"predicate Sorted_5571(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_5572","instance":5572,"id":242259,"goal":"predicate AllPositive_5572(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_5573","instance":5573,"id":242260,"goal":"predicate DistinctSeq_5573(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_5574","instance":5574,"id":242261,"goal":"predicate IsSubseq_5574(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_5575","instance":5575,"id":242262,"goal":"predicate IsPermutation_5575(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_5576","instance":5576,"id":242263,"goal":"predicate IsEven_5576(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_5577","instance":5577,"id":242264,"goal":"predicate InRange_5577(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_5578","instance":5578,"id":242265,"goal":"predicate SubsetOf_5578(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_5579","instance":5579,"id":242266,"goal":"predicate AllMem_5579(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_5580","instance":5580,"id":242267,"goal":"predicate DisjointSets_5580(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_5581","instance":5581,"id":242268,"goal":"predicate Sorted_5581(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_5582","instance":5582,"id":242269,"goal":"predicate AllPositive_5582(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_5583","instance":5583,"id":242270,"goal":"predicate DistinctSeq_5583(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_5584","instance":5584,"id":242271,"goal":"predicate IsSubseq_5584(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_5585","instance":5585,"id":242272,"goal":"predicate IsPermutation_5585(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_5586","instance":5586,"id":242273,"goal":"predicate IsEven_5586(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_5587","instance":5587,"id":242274,"goal":"predicate InRange_5587(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_5588","instance":5588,"id":242275,"goal":"predicate SubsetOf_5588(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_5589","instance":5589,"id":242276,"goal":"predicate AllMem_5589(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_5590","instance":5590,"id":242277,"goal":"predicate DisjointSets_5590(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_5591","instance":5591,"id":242278,"goal":"predicate Sorted_5591(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_5592","instance":5592,"id":242279,"goal":"predicate AllPositive_5592(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_5593","instance":5593,"id":242280,"goal":"predicate DistinctSeq_5593(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_5594","instance":5594,"id":242281,"goal":"predicate IsSubseq_5594(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_5595","instance":5595,"id":242282,"goal":"predicate IsPermutation_5595(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_5596","instance":5596,"id":242283,"goal":"predicate IsEven_5596(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_5597","instance":5597,"id":242284,"goal":"predicate InRange_5597(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_5598","instance":5598,"id":242285,"goal":"predicate SubsetOf_5598(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_5599","instance":5599,"id":242286,"goal":"predicate AllMem_5599(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_5600","instance":5600,"id":242287,"goal":"predicate DisjointSets_5600(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_5601","instance":5601,"id":242288,"goal":"predicate Sorted_5601(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_5602","instance":5602,"id":242289,"goal":"predicate AllPositive_5602(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_5603","instance":5603,"id":242290,"goal":"predicate DistinctSeq_5603(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_5604","instance":5604,"id":242291,"goal":"predicate IsSubseq_5604(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_5605","instance":5605,"id":242292,"goal":"predicate IsPermutation_5605(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_5606","instance":5606,"id":242293,"goal":"predicate IsEven_5606(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_5607","instance":5607,"id":242294,"goal":"predicate InRange_5607(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_5608","instance":5608,"id":242295,"goal":"predicate SubsetOf_5608(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_5609","instance":5609,"id":242296,"goal":"predicate AllMem_5609(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_5610","instance":5610,"id":242297,"goal":"predicate DisjointSets_5610(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_5611","instance":5611,"id":242298,"goal":"predicate Sorted_5611(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_5612","instance":5612,"id":242299,"goal":"predicate AllPositive_5612(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_5613","instance":5613,"id":242300,"goal":"predicate DistinctSeq_5613(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_5614","instance":5614,"id":242301,"goal":"predicate IsSubseq_5614(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_5615","instance":5615,"id":242302,"goal":"predicate IsPermutation_5615(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_5616","instance":5616,"id":242303,"goal":"predicate IsEven_5616(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_5617","instance":5617,"id":242304,"goal":"predicate InRange_5617(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_5618","instance":5618,"id":242305,"goal":"predicate SubsetOf_5618(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_5619","instance":5619,"id":242306,"goal":"predicate AllMem_5619(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_5620","instance":5620,"id":242307,"goal":"predicate DisjointSets_5620(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_5621","instance":5621,"id":242308,"goal":"predicate Sorted_5621(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_5622","instance":5622,"id":242309,"goal":"predicate AllPositive_5622(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_5623","instance":5623,"id":242310,"goal":"predicate DistinctSeq_5623(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_5624","instance":5624,"id":242311,"goal":"predicate IsSubseq_5624(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_5625","instance":5625,"id":242312,"goal":"predicate IsPermutation_5625(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_5626","instance":5626,"id":242313,"goal":"predicate IsEven_5626(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_5627","instance":5627,"id":242314,"goal":"predicate InRange_5627(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_5628","instance":5628,"id":242315,"goal":"predicate SubsetOf_5628(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_5629","instance":5629,"id":242316,"goal":"predicate AllMem_5629(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_5630","instance":5630,"id":242317,"goal":"predicate DisjointSets_5630(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_5631","instance":5631,"id":242318,"goal":"predicate Sorted_5631(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_5632","instance":5632,"id":242319,"goal":"predicate AllPositive_5632(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_5633","instance":5633,"id":242320,"goal":"predicate DistinctSeq_5633(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_5634","instance":5634,"id":242321,"goal":"predicate IsSubseq_5634(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_5635","instance":5635,"id":242322,"goal":"predicate IsPermutation_5635(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_5636","instance":5636,"id":242323,"goal":"predicate IsEven_5636(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_5637","instance":5637,"id":242324,"goal":"predicate InRange_5637(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_5638","instance":5638,"id":242325,"goal":"predicate SubsetOf_5638(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_5639","instance":5639,"id":242326,"goal":"predicate AllMem_5639(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_5640","instance":5640,"id":242327,"goal":"predicate DisjointSets_5640(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_5641","instance":5641,"id":242328,"goal":"predicate Sorted_5641(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_5642","instance":5642,"id":242329,"goal":"predicate AllPositive_5642(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_5643","instance":5643,"id":242330,"goal":"predicate DistinctSeq_5643(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_5644","instance":5644,"id":242331,"goal":"predicate IsSubseq_5644(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_5645","instance":5645,"id":242332,"goal":"predicate IsPermutation_5645(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_5646","instance":5646,"id":242333,"goal":"predicate IsEven_5646(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_5647","instance":5647,"id":242334,"goal":"predicate InRange_5647(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_5648","instance":5648,"id":242335,"goal":"predicate SubsetOf_5648(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_5649","instance":5649,"id":242336,"goal":"predicate AllMem_5649(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_5650","instance":5650,"id":242337,"goal":"predicate DisjointSets_5650(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_5651","instance":5651,"id":242338,"goal":"predicate Sorted_5651(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_5652","instance":5652,"id":242339,"goal":"predicate AllPositive_5652(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_5653","instance":5653,"id":242340,"goal":"predicate DistinctSeq_5653(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_5654","instance":5654,"id":242341,"goal":"predicate IsSubseq_5654(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_5655","instance":5655,"id":242342,"goal":"predicate IsPermutation_5655(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_5656","instance":5656,"id":242343,"goal":"predicate IsEven_5656(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_5657","instance":5657,"id":242344,"goal":"predicate InRange_5657(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_5658","instance":5658,"id":242345,"goal":"predicate SubsetOf_5658(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_5659","instance":5659,"id":242346,"goal":"predicate AllMem_5659(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_5660","instance":5660,"id":242347,"goal":"predicate DisjointSets_5660(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_5661","instance":5661,"id":242348,"goal":"predicate Sorted_5661(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_5662","instance":5662,"id":242349,"goal":"predicate AllPositive_5662(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_5663","instance":5663,"id":242350,"goal":"predicate DistinctSeq_5663(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_5664","instance":5664,"id":242351,"goal":"predicate IsSubseq_5664(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_5665","instance":5665,"id":242352,"goal":"predicate IsPermutation_5665(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_5666","instance":5666,"id":242353,"goal":"predicate IsEven_5666(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_5667","instance":5667,"id":242354,"goal":"predicate InRange_5667(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_5668","instance":5668,"id":242355,"goal":"predicate SubsetOf_5668(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_5669","instance":5669,"id":242356,"goal":"predicate AllMem_5669(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_5670","instance":5670,"id":242357,"goal":"predicate DisjointSets_5670(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_5671","instance":5671,"id":242358,"goal":"predicate Sorted_5671(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_5672","instance":5672,"id":242359,"goal":"predicate AllPositive_5672(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_5673","instance":5673,"id":242360,"goal":"predicate DistinctSeq_5673(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_5674","instance":5674,"id":242361,"goal":"predicate IsSubseq_5674(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_5675","instance":5675,"id":242362,"goal":"predicate IsPermutation_5675(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_5676","instance":5676,"id":242363,"goal":"predicate IsEven_5676(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_5677","instance":5677,"id":242364,"goal":"predicate InRange_5677(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_5678","instance":5678,"id":242365,"goal":"predicate SubsetOf_5678(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_5679","instance":5679,"id":242366,"goal":"predicate AllMem_5679(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_5680","instance":5680,"id":242367,"goal":"predicate DisjointSets_5680(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_5681","instance":5681,"id":242368,"goal":"predicate Sorted_5681(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_5682","instance":5682,"id":242369,"goal":"predicate AllPositive_5682(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_5683","instance":5683,"id":242370,"goal":"predicate DistinctSeq_5683(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_5684","instance":5684,"id":242371,"goal":"predicate IsSubseq_5684(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_5685","instance":5685,"id":242372,"goal":"predicate IsPermutation_5685(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_5686","instance":5686,"id":242373,"goal":"predicate IsEven_5686(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_5687","instance":5687,"id":242374,"goal":"predicate InRange_5687(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_5688","instance":5688,"id":242375,"goal":"predicate SubsetOf_5688(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_5689","instance":5689,"id":242376,"goal":"predicate AllMem_5689(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_5690","instance":5690,"id":242377,"goal":"predicate DisjointSets_5690(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_5691","instance":5691,"id":242378,"goal":"predicate Sorted_5691(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_5692","instance":5692,"id":242379,"goal":"predicate AllPositive_5692(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_5693","instance":5693,"id":242380,"goal":"predicate DistinctSeq_5693(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_5694","instance":5694,"id":242381,"goal":"predicate IsSubseq_5694(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_5695","instance":5695,"id":242382,"goal":"predicate IsPermutation_5695(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_5696","instance":5696,"id":242383,"goal":"predicate IsEven_5696(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_5697","instance":5697,"id":242384,"goal":"predicate InRange_5697(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_5698","instance":5698,"id":242385,"goal":"predicate SubsetOf_5698(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_5699","instance":5699,"id":242386,"goal":"predicate AllMem_5699(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_5700","instance":5700,"id":242387,"goal":"predicate DisjointSets_5700(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_5701","instance":5701,"id":242388,"goal":"predicate Sorted_5701(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_5702","instance":5702,"id":242389,"goal":"predicate AllPositive_5702(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_5703","instance":5703,"id":242390,"goal":"predicate DistinctSeq_5703(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_5704","instance":5704,"id":242391,"goal":"predicate IsSubseq_5704(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_5705","instance":5705,"id":242392,"goal":"predicate IsPermutation_5705(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_5706","instance":5706,"id":242393,"goal":"predicate IsEven_5706(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_5707","instance":5707,"id":242394,"goal":"predicate InRange_5707(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_5708","instance":5708,"id":242395,"goal":"predicate SubsetOf_5708(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_5709","instance":5709,"id":242396,"goal":"predicate AllMem_5709(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_5710","instance":5710,"id":242397,"goal":"predicate DisjointSets_5710(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_5711","instance":5711,"id":242398,"goal":"predicate Sorted_5711(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_5712","instance":5712,"id":242399,"goal":"predicate AllPositive_5712(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_5713","instance":5713,"id":242400,"goal":"predicate DistinctSeq_5713(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_5714","instance":5714,"id":242401,"goal":"predicate IsSubseq_5714(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_5715","instance":5715,"id":242402,"goal":"predicate IsPermutation_5715(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_5716","instance":5716,"id":242403,"goal":"predicate IsEven_5716(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_5717","instance":5717,"id":242404,"goal":"predicate InRange_5717(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_5718","instance":5718,"id":242405,"goal":"predicate SubsetOf_5718(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_5719","instance":5719,"id":242406,"goal":"predicate AllMem_5719(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_5720","instance":5720,"id":242407,"goal":"predicate DisjointSets_5720(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_5721","instance":5721,"id":242408,"goal":"predicate Sorted_5721(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_5722","instance":5722,"id":242409,"goal":"predicate AllPositive_5722(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_5723","instance":5723,"id":242410,"goal":"predicate DistinctSeq_5723(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_5724","instance":5724,"id":242411,"goal":"predicate IsSubseq_5724(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_5725","instance":5725,"id":242412,"goal":"predicate IsPermutation_5725(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_5726","instance":5726,"id":242413,"goal":"predicate IsEven_5726(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_5727","instance":5727,"id":242414,"goal":"predicate InRange_5727(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_5728","instance":5728,"id":242415,"goal":"predicate SubsetOf_5728(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_5729","instance":5729,"id":242416,"goal":"predicate AllMem_5729(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_5730","instance":5730,"id":242417,"goal":"predicate DisjointSets_5730(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_5731","instance":5731,"id":242418,"goal":"predicate Sorted_5731(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_5732","instance":5732,"id":242419,"goal":"predicate AllPositive_5732(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_5733","instance":5733,"id":242420,"goal":"predicate DistinctSeq_5733(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_5734","instance":5734,"id":242421,"goal":"predicate IsSubseq_5734(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_5735","instance":5735,"id":242422,"goal":"predicate IsPermutation_5735(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_5736","instance":5736,"id":242423,"goal":"predicate IsEven_5736(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_5737","instance":5737,"id":242424,"goal":"predicate InRange_5737(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_5738","instance":5738,"id":242425,"goal":"predicate SubsetOf_5738(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_5739","instance":5739,"id":242426,"goal":"predicate AllMem_5739(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_5740","instance":5740,"id":242427,"goal":"predicate DisjointSets_5740(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_5741","instance":5741,"id":242428,"goal":"predicate Sorted_5741(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_5742","instance":5742,"id":242429,"goal":"predicate AllPositive_5742(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_5743","instance":5743,"id":242430,"goal":"predicate DistinctSeq_5743(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_5744","instance":5744,"id":242431,"goal":"predicate IsSubseq_5744(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_5745","instance":5745,"id":242432,"goal":"predicate IsPermutation_5745(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_5746","instance":5746,"id":242433,"goal":"predicate IsEven_5746(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_5747","instance":5747,"id":242434,"goal":"predicate InRange_5747(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_5748","instance":5748,"id":242435,"goal":"predicate SubsetOf_5748(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_5749","instance":5749,"id":242436,"goal":"predicate AllMem_5749(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_5750","instance":5750,"id":242437,"goal":"predicate DisjointSets_5750(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_5751","instance":5751,"id":242438,"goal":"predicate Sorted_5751(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_5752","instance":5752,"id":242439,"goal":"predicate AllPositive_5752(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_5753","instance":5753,"id":242440,"goal":"predicate DistinctSeq_5753(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_5754","instance":5754,"id":242441,"goal":"predicate IsSubseq_5754(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_5755","instance":5755,"id":242442,"goal":"predicate IsPermutation_5755(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_5756","instance":5756,"id":242443,"goal":"predicate IsEven_5756(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_5757","instance":5757,"id":242444,"goal":"predicate InRange_5757(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_5758","instance":5758,"id":242445,"goal":"predicate SubsetOf_5758(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_5759","instance":5759,"id":242446,"goal":"predicate AllMem_5759(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_5760","instance":5760,"id":242447,"goal":"predicate DisjointSets_5760(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_5761","instance":5761,"id":242448,"goal":"predicate Sorted_5761(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_5762","instance":5762,"id":242449,"goal":"predicate AllPositive_5762(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_5763","instance":5763,"id":242450,"goal":"predicate DistinctSeq_5763(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_5764","instance":5764,"id":242451,"goal":"predicate IsSubseq_5764(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_5765","instance":5765,"id":242452,"goal":"predicate IsPermutation_5765(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_5766","instance":5766,"id":242453,"goal":"predicate IsEven_5766(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_5767","instance":5767,"id":242454,"goal":"predicate InRange_5767(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_5768","instance":5768,"id":242455,"goal":"predicate SubsetOf_5768(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_5769","instance":5769,"id":242456,"goal":"predicate AllMem_5769(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_5770","instance":5770,"id":242457,"goal":"predicate DisjointSets_5770(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_5771","instance":5771,"id":242458,"goal":"predicate Sorted_5771(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_5772","instance":5772,"id":242459,"goal":"predicate AllPositive_5772(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_5773","instance":5773,"id":242460,"goal":"predicate DistinctSeq_5773(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_5774","instance":5774,"id":242461,"goal":"predicate IsSubseq_5774(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_5775","instance":5775,"id":242462,"goal":"predicate IsPermutation_5775(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_5776","instance":5776,"id":242463,"goal":"predicate IsEven_5776(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_5777","instance":5777,"id":242464,"goal":"predicate InRange_5777(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_5778","instance":5778,"id":242465,"goal":"predicate SubsetOf_5778(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_5779","instance":5779,"id":242466,"goal":"predicate AllMem_5779(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_5780","instance":5780,"id":242467,"goal":"predicate DisjointSets_5780(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_5781","instance":5781,"id":242468,"goal":"predicate Sorted_5781(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_5782","instance":5782,"id":242469,"goal":"predicate AllPositive_5782(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_5783","instance":5783,"id":242470,"goal":"predicate DistinctSeq_5783(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_5784","instance":5784,"id":242471,"goal":"predicate IsSubseq_5784(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_5785","instance":5785,"id":242472,"goal":"predicate IsPermutation_5785(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_5786","instance":5786,"id":242473,"goal":"predicate IsEven_5786(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_5787","instance":5787,"id":242474,"goal":"predicate InRange_5787(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_5788","instance":5788,"id":242475,"goal":"predicate SubsetOf_5788(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_5789","instance":5789,"id":242476,"goal":"predicate AllMem_5789(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_5790","instance":5790,"id":242477,"goal":"predicate DisjointSets_5790(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_5791","instance":5791,"id":242478,"goal":"predicate Sorted_5791(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_5792","instance":5792,"id":242479,"goal":"predicate AllPositive_5792(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_5793","instance":5793,"id":242480,"goal":"predicate DistinctSeq_5793(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_5794","instance":5794,"id":242481,"goal":"predicate IsSubseq_5794(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_5795","instance":5795,"id":242482,"goal":"predicate IsPermutation_5795(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_5796","instance":5796,"id":242483,"goal":"predicate IsEven_5796(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_5797","instance":5797,"id":242484,"goal":"predicate InRange_5797(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_5798","instance":5798,"id":242485,"goal":"predicate SubsetOf_5798(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_5799","instance":5799,"id":242486,"goal":"predicate AllMem_5799(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_5800","instance":5800,"id":242487,"goal":"predicate DisjointSets_5800(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_5801","instance":5801,"id":242488,"goal":"predicate Sorted_5801(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_5802","instance":5802,"id":242489,"goal":"predicate AllPositive_5802(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_5803","instance":5803,"id":242490,"goal":"predicate DistinctSeq_5803(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_5804","instance":5804,"id":242491,"goal":"predicate IsSubseq_5804(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_5805","instance":5805,"id":242492,"goal":"predicate IsPermutation_5805(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_5806","instance":5806,"id":242493,"goal":"predicate IsEven_5806(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_5807","instance":5807,"id":242494,"goal":"predicate InRange_5807(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_5808","instance":5808,"id":242495,"goal":"predicate SubsetOf_5808(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_5809","instance":5809,"id":242496,"goal":"predicate AllMem_5809(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_5810","instance":5810,"id":242497,"goal":"predicate DisjointSets_5810(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_5811","instance":5811,"id":242498,"goal":"predicate Sorted_5811(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_5812","instance":5812,"id":242499,"goal":"predicate AllPositive_5812(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_5813","instance":5813,"id":242500,"goal":"predicate DistinctSeq_5813(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_5814","instance":5814,"id":242501,"goal":"predicate IsSubseq_5814(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_5815","instance":5815,"id":242502,"goal":"predicate IsPermutation_5815(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_5816","instance":5816,"id":242503,"goal":"predicate IsEven_5816(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_5817","instance":5817,"id":242504,"goal":"predicate InRange_5817(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_5818","instance":5818,"id":242505,"goal":"predicate SubsetOf_5818(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_5819","instance":5819,"id":242506,"goal":"predicate AllMem_5819(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_5820","instance":5820,"id":242507,"goal":"predicate DisjointSets_5820(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_5821","instance":5821,"id":242508,"goal":"predicate Sorted_5821(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_5822","instance":5822,"id":242509,"goal":"predicate AllPositive_5822(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_5823","instance":5823,"id":242510,"goal":"predicate DistinctSeq_5823(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_5824","instance":5824,"id":242511,"goal":"predicate IsSubseq_5824(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_5825","instance":5825,"id":242512,"goal":"predicate IsPermutation_5825(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_5826","instance":5826,"id":242513,"goal":"predicate IsEven_5826(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_5827","instance":5827,"id":242514,"goal":"predicate InRange_5827(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_5828","instance":5828,"id":242515,"goal":"predicate SubsetOf_5828(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_5829","instance":5829,"id":242516,"goal":"predicate AllMem_5829(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_5830","instance":5830,"id":242517,"goal":"predicate DisjointSets_5830(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_5831","instance":5831,"id":242518,"goal":"predicate Sorted_5831(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_5832","instance":5832,"id":242519,"goal":"predicate AllPositive_5832(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_5833","instance":5833,"id":242520,"goal":"predicate DistinctSeq_5833(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_5834","instance":5834,"id":242521,"goal":"predicate IsSubseq_5834(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_5835","instance":5835,"id":242522,"goal":"predicate IsPermutation_5835(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_5836","instance":5836,"id":242523,"goal":"predicate IsEven_5836(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_5837","instance":5837,"id":242524,"goal":"predicate InRange_5837(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_5838","instance":5838,"id":242525,"goal":"predicate SubsetOf_5838(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_5839","instance":5839,"id":242526,"goal":"predicate AllMem_5839(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_5840","instance":5840,"id":242527,"goal":"predicate DisjointSets_5840(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_5841","instance":5841,"id":242528,"goal":"predicate Sorted_5841(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_5842","instance":5842,"id":242529,"goal":"predicate AllPositive_5842(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_5843","instance":5843,"id":242530,"goal":"predicate DistinctSeq_5843(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_5844","instance":5844,"id":242531,"goal":"predicate IsSubseq_5844(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_5845","instance":5845,"id":242532,"goal":"predicate IsPermutation_5845(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_5846","instance":5846,"id":242533,"goal":"predicate IsEven_5846(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_5847","instance":5847,"id":242534,"goal":"predicate InRange_5847(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_5848","instance":5848,"id":242535,"goal":"predicate SubsetOf_5848(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_5849","instance":5849,"id":242536,"goal":"predicate AllMem_5849(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_5850","instance":5850,"id":242537,"goal":"predicate DisjointSets_5850(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_5851","instance":5851,"id":242538,"goal":"predicate Sorted_5851(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_5852","instance":5852,"id":242539,"goal":"predicate AllPositive_5852(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_5853","instance":5853,"id":242540,"goal":"predicate DistinctSeq_5853(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_5854","instance":5854,"id":242541,"goal":"predicate IsSubseq_5854(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_5855","instance":5855,"id":242542,"goal":"predicate IsPermutation_5855(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_5856","instance":5856,"id":242543,"goal":"predicate IsEven_5856(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_5857","instance":5857,"id":242544,"goal":"predicate InRange_5857(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_5858","instance":5858,"id":242545,"goal":"predicate SubsetOf_5858(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_5859","instance":5859,"id":242546,"goal":"predicate AllMem_5859(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_5860","instance":5860,"id":242547,"goal":"predicate DisjointSets_5860(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_5861","instance":5861,"id":242548,"goal":"predicate Sorted_5861(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_5862","instance":5862,"id":242549,"goal":"predicate AllPositive_5862(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_5863","instance":5863,"id":242550,"goal":"predicate DistinctSeq_5863(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_5864","instance":5864,"id":242551,"goal":"predicate IsSubseq_5864(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_5865","instance":5865,"id":242552,"goal":"predicate IsPermutation_5865(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_5866","instance":5866,"id":242553,"goal":"predicate IsEven_5866(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_5867","instance":5867,"id":242554,"goal":"predicate InRange_5867(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_5868","instance":5868,"id":242555,"goal":"predicate SubsetOf_5868(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_5869","instance":5869,"id":242556,"goal":"predicate AllMem_5869(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_5870","instance":5870,"id":242557,"goal":"predicate DisjointSets_5870(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_5871","instance":5871,"id":242558,"goal":"predicate Sorted_5871(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_5872","instance":5872,"id":242559,"goal":"predicate AllPositive_5872(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_5873","instance":5873,"id":242560,"goal":"predicate DistinctSeq_5873(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_5874","instance":5874,"id":242561,"goal":"predicate IsSubseq_5874(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_5875","instance":5875,"id":242562,"goal":"predicate IsPermutation_5875(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_5876","instance":5876,"id":242563,"goal":"predicate IsEven_5876(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_5877","instance":5877,"id":242564,"goal":"predicate InRange_5877(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_5878","instance":5878,"id":242565,"goal":"predicate SubsetOf_5878(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_5879","instance":5879,"id":242566,"goal":"predicate AllMem_5879(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_5880","instance":5880,"id":242567,"goal":"predicate DisjointSets_5880(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_5881","instance":5881,"id":242568,"goal":"predicate Sorted_5881(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_5882","instance":5882,"id":242569,"goal":"predicate AllPositive_5882(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_5883","instance":5883,"id":242570,"goal":"predicate DistinctSeq_5883(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_5884","instance":5884,"id":242571,"goal":"predicate IsSubseq_5884(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_5885","instance":5885,"id":242572,"goal":"predicate IsPermutation_5885(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_5886","instance":5886,"id":242573,"goal":"predicate IsEven_5886(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_5887","instance":5887,"id":242574,"goal":"predicate InRange_5887(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_5888","instance":5888,"id":242575,"goal":"predicate SubsetOf_5888(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_5889","instance":5889,"id":242576,"goal":"predicate AllMem_5889(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_5890","instance":5890,"id":242577,"goal":"predicate DisjointSets_5890(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_5891","instance":5891,"id":242578,"goal":"predicate Sorted_5891(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_5892","instance":5892,"id":242579,"goal":"predicate AllPositive_5892(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_5893","instance":5893,"id":242580,"goal":"predicate DistinctSeq_5893(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_5894","instance":5894,"id":242581,"goal":"predicate IsSubseq_5894(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_5895","instance":5895,"id":242582,"goal":"predicate IsPermutation_5895(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_5896","instance":5896,"id":242583,"goal":"predicate IsEven_5896(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_5897","instance":5897,"id":242584,"goal":"predicate InRange_5897(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_5898","instance":5898,"id":242585,"goal":"predicate SubsetOf_5898(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_5899","instance":5899,"id":242586,"goal":"predicate AllMem_5899(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_5900","instance":5900,"id":242587,"goal":"predicate DisjointSets_5900(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_5901","instance":5901,"id":242588,"goal":"predicate Sorted_5901(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_5902","instance":5902,"id":242589,"goal":"predicate AllPositive_5902(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_5903","instance":5903,"id":242590,"goal":"predicate DistinctSeq_5903(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_5904","instance":5904,"id":242591,"goal":"predicate IsSubseq_5904(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_5905","instance":5905,"id":242592,"goal":"predicate IsPermutation_5905(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_5906","instance":5906,"id":242593,"goal":"predicate IsEven_5906(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_5907","instance":5907,"id":242594,"goal":"predicate InRange_5907(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_5908","instance":5908,"id":242595,"goal":"predicate SubsetOf_5908(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_5909","instance":5909,"id":242596,"goal":"predicate AllMem_5909(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_5910","instance":5910,"id":242597,"goal":"predicate DisjointSets_5910(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_5911","instance":5911,"id":242598,"goal":"predicate Sorted_5911(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_5912","instance":5912,"id":242599,"goal":"predicate AllPositive_5912(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_5913","instance":5913,"id":242600,"goal":"predicate DistinctSeq_5913(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_5914","instance":5914,"id":242601,"goal":"predicate IsSubseq_5914(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_5915","instance":5915,"id":242602,"goal":"predicate IsPermutation_5915(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_5916","instance":5916,"id":242603,"goal":"predicate IsEven_5916(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_5917","instance":5917,"id":242604,"goal":"predicate InRange_5917(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_5918","instance":5918,"id":242605,"goal":"predicate SubsetOf_5918(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_5919","instance":5919,"id":242606,"goal":"predicate AllMem_5919(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_5920","instance":5920,"id":242607,"goal":"predicate DisjointSets_5920(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_5921","instance":5921,"id":242608,"goal":"predicate Sorted_5921(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_5922","instance":5922,"id":242609,"goal":"predicate AllPositive_5922(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_5923","instance":5923,"id":242610,"goal":"predicate DistinctSeq_5923(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_5924","instance":5924,"id":242611,"goal":"predicate IsSubseq_5924(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_5925","instance":5925,"id":242612,"goal":"predicate IsPermutation_5925(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_5926","instance":5926,"id":242613,"goal":"predicate IsEven_5926(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_5927","instance":5927,"id":242614,"goal":"predicate InRange_5927(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_5928","instance":5928,"id":242615,"goal":"predicate SubsetOf_5928(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_5929","instance":5929,"id":242616,"goal":"predicate AllMem_5929(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_5930","instance":5930,"id":242617,"goal":"predicate DisjointSets_5930(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_5931","instance":5931,"id":242618,"goal":"predicate Sorted_5931(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_5932","instance":5932,"id":242619,"goal":"predicate AllPositive_5932(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_5933","instance":5933,"id":242620,"goal":"predicate DistinctSeq_5933(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_5934","instance":5934,"id":242621,"goal":"predicate IsSubseq_5934(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_5935","instance":5935,"id":242622,"goal":"predicate IsPermutation_5935(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_5936","instance":5936,"id":242623,"goal":"predicate IsEven_5936(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_5937","instance":5937,"id":242624,"goal":"predicate InRange_5937(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_5938","instance":5938,"id":242625,"goal":"predicate SubsetOf_5938(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_5939","instance":5939,"id":242626,"goal":"predicate AllMem_5939(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_5940","instance":5940,"id":242627,"goal":"predicate DisjointSets_5940(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_5941","instance":5941,"id":242628,"goal":"predicate Sorted_5941(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_5942","instance":5942,"id":242629,"goal":"predicate AllPositive_5942(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_5943","instance":5943,"id":242630,"goal":"predicate DistinctSeq_5943(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_5944","instance":5944,"id":242631,"goal":"predicate IsSubseq_5944(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_5945","instance":5945,"id":242632,"goal":"predicate IsPermutation_5945(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_5946","instance":5946,"id":242633,"goal":"predicate IsEven_5946(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_5947","instance":5947,"id":242634,"goal":"predicate InRange_5947(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_5948","instance":5948,"id":242635,"goal":"predicate SubsetOf_5948(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_5949","instance":5949,"id":242636,"goal":"predicate AllMem_5949(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_5950","instance":5950,"id":242637,"goal":"predicate DisjointSets_5950(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_5951","instance":5951,"id":242638,"goal":"predicate Sorted_5951(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_5952","instance":5952,"id":242639,"goal":"predicate AllPositive_5952(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_5953","instance":5953,"id":242640,"goal":"predicate DistinctSeq_5953(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_5954","instance":5954,"id":242641,"goal":"predicate IsSubseq_5954(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_5955","instance":5955,"id":242642,"goal":"predicate IsPermutation_5955(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_5956","instance":5956,"id":242643,"goal":"predicate IsEven_5956(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_5957","instance":5957,"id":242644,"goal":"predicate InRange_5957(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_5958","instance":5958,"id":242645,"goal":"predicate SubsetOf_5958(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_5959","instance":5959,"id":242646,"goal":"predicate AllMem_5959(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_5960","instance":5960,"id":242647,"goal":"predicate DisjointSets_5960(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_5961","instance":5961,"id":242648,"goal":"predicate Sorted_5961(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_5962","instance":5962,"id":242649,"goal":"predicate AllPositive_5962(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_5963","instance":5963,"id":242650,"goal":"predicate DistinctSeq_5963(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_5964","instance":5964,"id":242651,"goal":"predicate IsSubseq_5964(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_5965","instance":5965,"id":242652,"goal":"predicate IsPermutation_5965(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_5966","instance":5966,"id":242653,"goal":"predicate IsEven_5966(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_5967","instance":5967,"id":242654,"goal":"predicate InRange_5967(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_5968","instance":5968,"id":242655,"goal":"predicate SubsetOf_5968(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_5969","instance":5969,"id":242656,"goal":"predicate AllMem_5969(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_5970","instance":5970,"id":242657,"goal":"predicate DisjointSets_5970(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_5971","instance":5971,"id":242658,"goal":"predicate Sorted_5971(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_5972","instance":5972,"id":242659,"goal":"predicate AllPositive_5972(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_5973","instance":5973,"id":242660,"goal":"predicate DistinctSeq_5973(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_5974","instance":5974,"id":242661,"goal":"predicate IsSubseq_5974(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_5975","instance":5975,"id":242662,"goal":"predicate IsPermutation_5975(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_5976","instance":5976,"id":242663,"goal":"predicate IsEven_5976(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_5977","instance":5977,"id":242664,"goal":"predicate InRange_5977(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_5978","instance":5978,"id":242665,"goal":"predicate SubsetOf_5978(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_5979","instance":5979,"id":242666,"goal":"predicate AllMem_5979(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_5980","instance":5980,"id":242667,"goal":"predicate DisjointSets_5980(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_5981","instance":5981,"id":242668,"goal":"predicate Sorted_5981(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_5982","instance":5982,"id":242669,"goal":"predicate AllPositive_5982(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_5983","instance":5983,"id":242670,"goal":"predicate DistinctSeq_5983(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_5984","instance":5984,"id":242671,"goal":"predicate IsSubseq_5984(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_5985","instance":5985,"id":242672,"goal":"predicate IsPermutation_5985(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_5986","instance":5986,"id":242673,"goal":"predicate IsEven_5986(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_5987","instance":5987,"id":242674,"goal":"predicate InRange_5987(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_5988","instance":5988,"id":242675,"goal":"predicate SubsetOf_5988(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_5989","instance":5989,"id":242676,"goal":"predicate AllMem_5989(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_5990","instance":5990,"id":242677,"goal":"predicate DisjointSets_5990(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_5991","instance":5991,"id":242678,"goal":"predicate Sorted_5991(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_5992","instance":5992,"id":242679,"goal":"predicate AllPositive_5992(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_5993","instance":5993,"id":242680,"goal":"predicate DistinctSeq_5993(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_5994","instance":5994,"id":242681,"goal":"predicate IsSubseq_5994(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_5995","instance":5995,"id":242682,"goal":"predicate IsPermutation_5995(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_5996","instance":5996,"id":242683,"goal":"predicate IsEven_5996(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_5997","instance":5997,"id":242684,"goal":"predicate InRange_5997(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_5998","instance":5998,"id":242685,"goal":"predicate SubsetOf_5998(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_5999","instance":5999,"id":242686,"goal":"predicate AllMem_5999(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_6000","instance":6000,"id":242687,"goal":"predicate DisjointSets_6000(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_6001","instance":6001,"id":242688,"goal":"predicate Sorted_6001(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_6002","instance":6002,"id":242689,"goal":"predicate AllPositive_6002(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_6003","instance":6003,"id":242690,"goal":"predicate DistinctSeq_6003(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_6004","instance":6004,"id":242691,"goal":"predicate IsSubseq_6004(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_6005","instance":6005,"id":242692,"goal":"predicate IsPermutation_6005(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_6006","instance":6006,"id":242693,"goal":"predicate IsEven_6006(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_6007","instance":6007,"id":242694,"goal":"predicate InRange_6007(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_6008","instance":6008,"id":242695,"goal":"predicate SubsetOf_6008(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_6009","instance":6009,"id":242696,"goal":"predicate AllMem_6009(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_6010","instance":6010,"id":242697,"goal":"predicate DisjointSets_6010(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_6011","instance":6011,"id":242698,"goal":"predicate Sorted_6011(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_6012","instance":6012,"id":242699,"goal":"predicate AllPositive_6012(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_6013","instance":6013,"id":242700,"goal":"predicate DistinctSeq_6013(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_6014","instance":6014,"id":242701,"goal":"predicate IsSubseq_6014(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_6015","instance":6015,"id":242702,"goal":"predicate IsPermutation_6015(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_6016","instance":6016,"id":242703,"goal":"predicate IsEven_6016(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_6017","instance":6017,"id":242704,"goal":"predicate InRange_6017(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_6018","instance":6018,"id":242705,"goal":"predicate SubsetOf_6018(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_6019","instance":6019,"id":242706,"goal":"predicate AllMem_6019(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_6020","instance":6020,"id":242707,"goal":"predicate DisjointSets_6020(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_6021","instance":6021,"id":242708,"goal":"predicate Sorted_6021(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_6022","instance":6022,"id":242709,"goal":"predicate AllPositive_6022(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_6023","instance":6023,"id":242710,"goal":"predicate DistinctSeq_6023(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_6024","instance":6024,"id":242711,"goal":"predicate IsSubseq_6024(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_6025","instance":6025,"id":242712,"goal":"predicate IsPermutation_6025(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_6026","instance":6026,"id":242713,"goal":"predicate IsEven_6026(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_6027","instance":6027,"id":242714,"goal":"predicate InRange_6027(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_6028","instance":6028,"id":242715,"goal":"predicate SubsetOf_6028(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_6029","instance":6029,"id":242716,"goal":"predicate AllMem_6029(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_6030","instance":6030,"id":242717,"goal":"predicate DisjointSets_6030(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_6031","instance":6031,"id":242718,"goal":"predicate Sorted_6031(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_6032","instance":6032,"id":242719,"goal":"predicate AllPositive_6032(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_6033","instance":6033,"id":242720,"goal":"predicate DistinctSeq_6033(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_6034","instance":6034,"id":242721,"goal":"predicate IsSubseq_6034(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_6035","instance":6035,"id":242722,"goal":"predicate IsPermutation_6035(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_6036","instance":6036,"id":242723,"goal":"predicate IsEven_6036(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_6037","instance":6037,"id":242724,"goal":"predicate InRange_6037(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_6038","instance":6038,"id":242725,"goal":"predicate SubsetOf_6038(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_6039","instance":6039,"id":242726,"goal":"predicate AllMem_6039(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_6040","instance":6040,"id":242727,"goal":"predicate DisjointSets_6040(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_6041","instance":6041,"id":242728,"goal":"predicate Sorted_6041(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_6042","instance":6042,"id":242729,"goal":"predicate AllPositive_6042(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_6043","instance":6043,"id":242730,"goal":"predicate DistinctSeq_6043(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_6044","instance":6044,"id":242731,"goal":"predicate IsSubseq_6044(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_6045","instance":6045,"id":242732,"goal":"predicate IsPermutation_6045(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_6046","instance":6046,"id":242733,"goal":"predicate IsEven_6046(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_6047","instance":6047,"id":242734,"goal":"predicate InRange_6047(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_6048","instance":6048,"id":242735,"goal":"predicate SubsetOf_6048(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_6049","instance":6049,"id":242736,"goal":"predicate AllMem_6049(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_6050","instance":6050,"id":242737,"goal":"predicate DisjointSets_6050(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_6051","instance":6051,"id":242738,"goal":"predicate Sorted_6051(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_6052","instance":6052,"id":242739,"goal":"predicate AllPositive_6052(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_6053","instance":6053,"id":242740,"goal":"predicate DistinctSeq_6053(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_6054","instance":6054,"id":242741,"goal":"predicate IsSubseq_6054(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_6055","instance":6055,"id":242742,"goal":"predicate IsPermutation_6055(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_6056","instance":6056,"id":242743,"goal":"predicate IsEven_6056(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_6057","instance":6057,"id":242744,"goal":"predicate InRange_6057(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_6058","instance":6058,"id":242745,"goal":"predicate SubsetOf_6058(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_6059","instance":6059,"id":242746,"goal":"predicate AllMem_6059(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_6060","instance":6060,"id":242747,"goal":"predicate DisjointSets_6060(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_6061","instance":6061,"id":242748,"goal":"predicate Sorted_6061(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_6062","instance":6062,"id":242749,"goal":"predicate AllPositive_6062(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_6063","instance":6063,"id":242750,"goal":"predicate DistinctSeq_6063(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_6064","instance":6064,"id":242751,"goal":"predicate IsSubseq_6064(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_6065","instance":6065,"id":242752,"goal":"predicate IsPermutation_6065(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_6066","instance":6066,"id":242753,"goal":"predicate IsEven_6066(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_6067","instance":6067,"id":242754,"goal":"predicate InRange_6067(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_6068","instance":6068,"id":242755,"goal":"predicate SubsetOf_6068(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_6069","instance":6069,"id":242756,"goal":"predicate AllMem_6069(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_6070","instance":6070,"id":242757,"goal":"predicate DisjointSets_6070(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_6071","instance":6071,"id":242758,"goal":"predicate Sorted_6071(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_6072","instance":6072,"id":242759,"goal":"predicate AllPositive_6072(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_6073","instance":6073,"id":242760,"goal":"predicate DistinctSeq_6073(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_6074","instance":6074,"id":242761,"goal":"predicate IsSubseq_6074(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_6075","instance":6075,"id":242762,"goal":"predicate IsPermutation_6075(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_6076","instance":6076,"id":242763,"goal":"predicate IsEven_6076(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_6077","instance":6077,"id":242764,"goal":"predicate InRange_6077(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_6078","instance":6078,"id":242765,"goal":"predicate SubsetOf_6078(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_6079","instance":6079,"id":242766,"goal":"predicate AllMem_6079(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_6080","instance":6080,"id":242767,"goal":"predicate DisjointSets_6080(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_6081","instance":6081,"id":242768,"goal":"predicate Sorted_6081(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_6082","instance":6082,"id":242769,"goal":"predicate AllPositive_6082(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_6083","instance":6083,"id":242770,"goal":"predicate DistinctSeq_6083(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_6084","instance":6084,"id":242771,"goal":"predicate IsSubseq_6084(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_6085","instance":6085,"id":242772,"goal":"predicate IsPermutation_6085(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_6086","instance":6086,"id":242773,"goal":"predicate IsEven_6086(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_6087","instance":6087,"id":242774,"goal":"predicate InRange_6087(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_6088","instance":6088,"id":242775,"goal":"predicate SubsetOf_6088(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_6089","instance":6089,"id":242776,"goal":"predicate AllMem_6089(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_6090","instance":6090,"id":242777,"goal":"predicate DisjointSets_6090(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_6091","instance":6091,"id":242778,"goal":"predicate Sorted_6091(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_6092","instance":6092,"id":242779,"goal":"predicate AllPositive_6092(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_6093","instance":6093,"id":242780,"goal":"predicate DistinctSeq_6093(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_6094","instance":6094,"id":242781,"goal":"predicate IsSubseq_6094(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_6095","instance":6095,"id":242782,"goal":"predicate IsPermutation_6095(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_6096","instance":6096,"id":242783,"goal":"predicate IsEven_6096(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_6097","instance":6097,"id":242784,"goal":"predicate InRange_6097(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_6098","instance":6098,"id":242785,"goal":"predicate SubsetOf_6098(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_6099","instance":6099,"id":242786,"goal":"predicate AllMem_6099(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_6100","instance":6100,"id":242787,"goal":"predicate DisjointSets_6100(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_6101","instance":6101,"id":242788,"goal":"predicate Sorted_6101(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_6102","instance":6102,"id":242789,"goal":"predicate AllPositive_6102(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_6103","instance":6103,"id":242790,"goal":"predicate DistinctSeq_6103(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_6104","instance":6104,"id":242791,"goal":"predicate IsSubseq_6104(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_6105","instance":6105,"id":242792,"goal":"predicate IsPermutation_6105(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_6106","instance":6106,"id":242793,"goal":"predicate IsEven_6106(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_6107","instance":6107,"id":242794,"goal":"predicate InRange_6107(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_6108","instance":6108,"id":242795,"goal":"predicate SubsetOf_6108(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_6109","instance":6109,"id":242796,"goal":"predicate AllMem_6109(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_6110","instance":6110,"id":242797,"goal":"predicate DisjointSets_6110(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_6111","instance":6111,"id":242798,"goal":"predicate Sorted_6111(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_6112","instance":6112,"id":242799,"goal":"predicate AllPositive_6112(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_6113","instance":6113,"id":242800,"goal":"predicate DistinctSeq_6113(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_6114","instance":6114,"id":242801,"goal":"predicate IsSubseq_6114(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_6115","instance":6115,"id":242802,"goal":"predicate IsPermutation_6115(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_6116","instance":6116,"id":242803,"goal":"predicate IsEven_6116(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_6117","instance":6117,"id":242804,"goal":"predicate InRange_6117(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_6118","instance":6118,"id":242805,"goal":"predicate SubsetOf_6118(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_6119","instance":6119,"id":242806,"goal":"predicate AllMem_6119(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_6120","instance":6120,"id":242807,"goal":"predicate DisjointSets_6120(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_6121","instance":6121,"id":242808,"goal":"predicate Sorted_6121(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_6122","instance":6122,"id":242809,"goal":"predicate AllPositive_6122(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_6123","instance":6123,"id":242810,"goal":"predicate DistinctSeq_6123(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_6124","instance":6124,"id":242811,"goal":"predicate IsSubseq_6124(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_6125","instance":6125,"id":242812,"goal":"predicate IsPermutation_6125(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_6126","instance":6126,"id":242813,"goal":"predicate IsEven_6126(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_6127","instance":6127,"id":242814,"goal":"predicate InRange_6127(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_6128","instance":6128,"id":242815,"goal":"predicate SubsetOf_6128(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_6129","instance":6129,"id":242816,"goal":"predicate AllMem_6129(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_6130","instance":6130,"id":242817,"goal":"predicate DisjointSets_6130(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_6131","instance":6131,"id":242818,"goal":"predicate Sorted_6131(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_6132","instance":6132,"id":242819,"goal":"predicate AllPositive_6132(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_6133","instance":6133,"id":242820,"goal":"predicate DistinctSeq_6133(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_6134","instance":6134,"id":242821,"goal":"predicate IsSubseq_6134(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_6135","instance":6135,"id":242822,"goal":"predicate IsPermutation_6135(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_6136","instance":6136,"id":242823,"goal":"predicate IsEven_6136(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_6137","instance":6137,"id":242824,"goal":"predicate InRange_6137(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_6138","instance":6138,"id":242825,"goal":"predicate SubsetOf_6138(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_6139","instance":6139,"id":242826,"goal":"predicate AllMem_6139(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_6140","instance":6140,"id":242827,"goal":"predicate DisjointSets_6140(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_6141","instance":6141,"id":242828,"goal":"predicate Sorted_6141(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_6142","instance":6142,"id":242829,"goal":"predicate AllPositive_6142(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_6143","instance":6143,"id":242830,"goal":"predicate DistinctSeq_6143(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_6144","instance":6144,"id":242831,"goal":"predicate IsSubseq_6144(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_6145","instance":6145,"id":242832,"goal":"predicate IsPermutation_6145(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_6146","instance":6146,"id":242833,"goal":"predicate IsEven_6146(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_6147","instance":6147,"id":242834,"goal":"predicate InRange_6147(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_6148","instance":6148,"id":242835,"goal":"predicate SubsetOf_6148(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_6149","instance":6149,"id":242836,"goal":"predicate AllMem_6149(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_6150","instance":6150,"id":242837,"goal":"predicate DisjointSets_6150(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_6151","instance":6151,"id":242838,"goal":"predicate Sorted_6151(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_6152","instance":6152,"id":242839,"goal":"predicate AllPositive_6152(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_6153","instance":6153,"id":242840,"goal":"predicate DistinctSeq_6153(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_6154","instance":6154,"id":242841,"goal":"predicate IsSubseq_6154(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_6155","instance":6155,"id":242842,"goal":"predicate IsPermutation_6155(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_6156","instance":6156,"id":242843,"goal":"predicate IsEven_6156(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_6157","instance":6157,"id":242844,"goal":"predicate InRange_6157(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_6158","instance":6158,"id":242845,"goal":"predicate SubsetOf_6158(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_6159","instance":6159,"id":242846,"goal":"predicate AllMem_6159(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_6160","instance":6160,"id":242847,"goal":"predicate DisjointSets_6160(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_6161","instance":6161,"id":242848,"goal":"predicate Sorted_6161(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_6162","instance":6162,"id":242849,"goal":"predicate AllPositive_6162(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_6163","instance":6163,"id":242850,"goal":"predicate DistinctSeq_6163(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_6164","instance":6164,"id":242851,"goal":"predicate IsSubseq_6164(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_6165","instance":6165,"id":242852,"goal":"predicate IsPermutation_6165(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_6166","instance":6166,"id":242853,"goal":"predicate IsEven_6166(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_6167","instance":6167,"id":242854,"goal":"predicate InRange_6167(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_6168","instance":6168,"id":242855,"goal":"predicate SubsetOf_6168(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_6169","instance":6169,"id":242856,"goal":"predicate AllMem_6169(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_6170","instance":6170,"id":242857,"goal":"predicate DisjointSets_6170(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_6171","instance":6171,"id":242858,"goal":"predicate Sorted_6171(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_6172","instance":6172,"id":242859,"goal":"predicate AllPositive_6172(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_6173","instance":6173,"id":242860,"goal":"predicate DistinctSeq_6173(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_6174","instance":6174,"id":242861,"goal":"predicate IsSubseq_6174(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_6175","instance":6175,"id":242862,"goal":"predicate IsPermutation_6175(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_6176","instance":6176,"id":242863,"goal":"predicate IsEven_6176(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_6177","instance":6177,"id":242864,"goal":"predicate InRange_6177(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_6178","instance":6178,"id":242865,"goal":"predicate SubsetOf_6178(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_6179","instance":6179,"id":242866,"goal":"predicate AllMem_6179(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_6180","instance":6180,"id":242867,"goal":"predicate DisjointSets_6180(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_6181","instance":6181,"id":242868,"goal":"predicate Sorted_6181(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_6182","instance":6182,"id":242869,"goal":"predicate AllPositive_6182(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_6183","instance":6183,"id":242870,"goal":"predicate DistinctSeq_6183(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_6184","instance":6184,"id":242871,"goal":"predicate IsSubseq_6184(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_6185","instance":6185,"id":242872,"goal":"predicate IsPermutation_6185(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_6186","instance":6186,"id":242873,"goal":"predicate IsEven_6186(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_6187","instance":6187,"id":242874,"goal":"predicate InRange_6187(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_6188","instance":6188,"id":242875,"goal":"predicate SubsetOf_6188(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_6189","instance":6189,"id":242876,"goal":"predicate AllMem_6189(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_6190","instance":6190,"id":242877,"goal":"predicate DisjointSets_6190(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_6191","instance":6191,"id":242878,"goal":"predicate Sorted_6191(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_6192","instance":6192,"id":242879,"goal":"predicate AllPositive_6192(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_6193","instance":6193,"id":242880,"goal":"predicate DistinctSeq_6193(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_6194","instance":6194,"id":242881,"goal":"predicate IsSubseq_6194(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_6195","instance":6195,"id":242882,"goal":"predicate IsPermutation_6195(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_6196","instance":6196,"id":242883,"goal":"predicate IsEven_6196(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_6197","instance":6197,"id":242884,"goal":"predicate InRange_6197(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_6198","instance":6198,"id":242885,"goal":"predicate SubsetOf_6198(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_6199","instance":6199,"id":242886,"goal":"predicate AllMem_6199(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_6200","instance":6200,"id":242887,"goal":"predicate DisjointSets_6200(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_6201","instance":6201,"id":242888,"goal":"predicate Sorted_6201(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_6202","instance":6202,"id":242889,"goal":"predicate AllPositive_6202(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_6203","instance":6203,"id":242890,"goal":"predicate DistinctSeq_6203(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_6204","instance":6204,"id":242891,"goal":"predicate IsSubseq_6204(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_6205","instance":6205,"id":242892,"goal":"predicate IsPermutation_6205(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_6206","instance":6206,"id":242893,"goal":"predicate IsEven_6206(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_6207","instance":6207,"id":242894,"goal":"predicate InRange_6207(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_6208","instance":6208,"id":242895,"goal":"predicate SubsetOf_6208(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_6209","instance":6209,"id":242896,"goal":"predicate AllMem_6209(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_6210","instance":6210,"id":242897,"goal":"predicate DisjointSets_6210(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_6211","instance":6211,"id":242898,"goal":"predicate Sorted_6211(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_6212","instance":6212,"id":242899,"goal":"predicate AllPositive_6212(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_6213","instance":6213,"id":242900,"goal":"predicate DistinctSeq_6213(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_6214","instance":6214,"id":242901,"goal":"predicate IsSubseq_6214(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_6215","instance":6215,"id":242902,"goal":"predicate IsPermutation_6215(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_6216","instance":6216,"id":242903,"goal":"predicate IsEven_6216(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_6217","instance":6217,"id":242904,"goal":"predicate InRange_6217(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_6218","instance":6218,"id":242905,"goal":"predicate SubsetOf_6218(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_6219","instance":6219,"id":242906,"goal":"predicate AllMem_6219(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_6220","instance":6220,"id":242907,"goal":"predicate DisjointSets_6220(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_6221","instance":6221,"id":242908,"goal":"predicate Sorted_6221(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_6222","instance":6222,"id":242909,"goal":"predicate AllPositive_6222(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_6223","instance":6223,"id":242910,"goal":"predicate DistinctSeq_6223(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_6224","instance":6224,"id":242911,"goal":"predicate IsSubseq_6224(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_6225","instance":6225,"id":242912,"goal":"predicate IsPermutation_6225(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_6226","instance":6226,"id":242913,"goal":"predicate IsEven_6226(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_6227","instance":6227,"id":242914,"goal":"predicate InRange_6227(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_6228","instance":6228,"id":242915,"goal":"predicate SubsetOf_6228(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_6229","instance":6229,"id":242916,"goal":"predicate AllMem_6229(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_6230","instance":6230,"id":242917,"goal":"predicate DisjointSets_6230(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_6231","instance":6231,"id":242918,"goal":"predicate Sorted_6231(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_6232","instance":6232,"id":242919,"goal":"predicate AllPositive_6232(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_6233","instance":6233,"id":242920,"goal":"predicate DistinctSeq_6233(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_6234","instance":6234,"id":242921,"goal":"predicate IsSubseq_6234(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_6235","instance":6235,"id":242922,"goal":"predicate IsPermutation_6235(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_6236","instance":6236,"id":242923,"goal":"predicate IsEven_6236(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_6237","instance":6237,"id":242924,"goal":"predicate InRange_6237(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_6238","instance":6238,"id":242925,"goal":"predicate SubsetOf_6238(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_6239","instance":6239,"id":242926,"goal":"predicate AllMem_6239(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_6240","instance":6240,"id":242927,"goal":"predicate DisjointSets_6240(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_6241","instance":6241,"id":242928,"goal":"predicate Sorted_6241(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_6242","instance":6242,"id":242929,"goal":"predicate AllPositive_6242(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_6243","instance":6243,"id":242930,"goal":"predicate DistinctSeq_6243(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_6244","instance":6244,"id":242931,"goal":"predicate IsSubseq_6244(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_6245","instance":6245,"id":242932,"goal":"predicate IsPermutation_6245(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_6246","instance":6246,"id":242933,"goal":"predicate IsEven_6246(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_6247","instance":6247,"id":242934,"goal":"predicate InRange_6247(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_6248","instance":6248,"id":242935,"goal":"predicate SubsetOf_6248(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_6249","instance":6249,"id":242936,"goal":"predicate AllMem_6249(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_6250","instance":6250,"id":242937,"goal":"predicate DisjointSets_6250(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_6251","instance":6251,"id":242938,"goal":"predicate Sorted_6251(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_6252","instance":6252,"id":242939,"goal":"predicate AllPositive_6252(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_6253","instance":6253,"id":242940,"goal":"predicate DistinctSeq_6253(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_6254","instance":6254,"id":242941,"goal":"predicate IsSubseq_6254(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_6255","instance":6255,"id":242942,"goal":"predicate IsPermutation_6255(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_6256","instance":6256,"id":242943,"goal":"predicate IsEven_6256(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_6257","instance":6257,"id":242944,"goal":"predicate InRange_6257(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_6258","instance":6258,"id":242945,"goal":"predicate SubsetOf_6258(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_6259","instance":6259,"id":242946,"goal":"predicate AllMem_6259(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_6260","instance":6260,"id":242947,"goal":"predicate DisjointSets_6260(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_6261","instance":6261,"id":242948,"goal":"predicate Sorted_6261(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_6262","instance":6262,"id":242949,"goal":"predicate AllPositive_6262(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_6263","instance":6263,"id":242950,"goal":"predicate DistinctSeq_6263(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_6264","instance":6264,"id":242951,"goal":"predicate IsSubseq_6264(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_6265","instance":6265,"id":242952,"goal":"predicate IsPermutation_6265(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_6266","instance":6266,"id":242953,"goal":"predicate IsEven_6266(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_6267","instance":6267,"id":242954,"goal":"predicate InRange_6267(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_6268","instance":6268,"id":242955,"goal":"predicate SubsetOf_6268(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_6269","instance":6269,"id":242956,"goal":"predicate AllMem_6269(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_6270","instance":6270,"id":242957,"goal":"predicate DisjointSets_6270(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_6271","instance":6271,"id":242958,"goal":"predicate Sorted_6271(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_6272","instance":6272,"id":242959,"goal":"predicate AllPositive_6272(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_6273","instance":6273,"id":242960,"goal":"predicate DistinctSeq_6273(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_6274","instance":6274,"id":242961,"goal":"predicate IsSubseq_6274(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_6275","instance":6275,"id":242962,"goal":"predicate IsPermutation_6275(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_6276","instance":6276,"id":242963,"goal":"predicate IsEven_6276(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_6277","instance":6277,"id":242964,"goal":"predicate InRange_6277(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_6278","instance":6278,"id":242965,"goal":"predicate SubsetOf_6278(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_6279","instance":6279,"id":242966,"goal":"predicate AllMem_6279(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_6280","instance":6280,"id":242967,"goal":"predicate DisjointSets_6280(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_6281","instance":6281,"id":242968,"goal":"predicate Sorted_6281(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_6282","instance":6282,"id":242969,"goal":"predicate AllPositive_6282(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_6283","instance":6283,"id":242970,"goal":"predicate DistinctSeq_6283(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_6284","instance":6284,"id":242971,"goal":"predicate IsSubseq_6284(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_6285","instance":6285,"id":242972,"goal":"predicate IsPermutation_6285(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_6286","instance":6286,"id":242973,"goal":"predicate IsEven_6286(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_6287","instance":6287,"id":242974,"goal":"predicate InRange_6287(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_6288","instance":6288,"id":242975,"goal":"predicate SubsetOf_6288(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_6289","instance":6289,"id":242976,"goal":"predicate AllMem_6289(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_6290","instance":6290,"id":242977,"goal":"predicate DisjointSets_6290(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_6291","instance":6291,"id":242978,"goal":"predicate Sorted_6291(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_6292","instance":6292,"id":242979,"goal":"predicate AllPositive_6292(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_6293","instance":6293,"id":242980,"goal":"predicate DistinctSeq_6293(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_6294","instance":6294,"id":242981,"goal":"predicate IsSubseq_6294(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_6295","instance":6295,"id":242982,"goal":"predicate IsPermutation_6295(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_6296","instance":6296,"id":242983,"goal":"predicate IsEven_6296(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_6297","instance":6297,"id":242984,"goal":"predicate InRange_6297(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_6298","instance":6298,"id":242985,"goal":"predicate SubsetOf_6298(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_6299","instance":6299,"id":242986,"goal":"predicate AllMem_6299(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_6300","instance":6300,"id":242987,"goal":"predicate DisjointSets_6300(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_6301","instance":6301,"id":242988,"goal":"predicate Sorted_6301(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_6302","instance":6302,"id":242989,"goal":"predicate AllPositive_6302(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_6303","instance":6303,"id":242990,"goal":"predicate DistinctSeq_6303(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_6304","instance":6304,"id":242991,"goal":"predicate IsSubseq_6304(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_6305","instance":6305,"id":242992,"goal":"predicate IsPermutation_6305(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_6306","instance":6306,"id":242993,"goal":"predicate IsEven_6306(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_6307","instance":6307,"id":242994,"goal":"predicate InRange_6307(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_6308","instance":6308,"id":242995,"goal":"predicate SubsetOf_6308(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_6309","instance":6309,"id":242996,"goal":"predicate AllMem_6309(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_6310","instance":6310,"id":242997,"goal":"predicate DisjointSets_6310(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_6311","instance":6311,"id":242998,"goal":"predicate Sorted_6311(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_6312","instance":6312,"id":242999,"goal":"predicate AllPositive_6312(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_6313","instance":6313,"id":243000,"goal":"predicate DistinctSeq_6313(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_6314","instance":6314,"id":243001,"goal":"predicate IsSubseq_6314(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_6315","instance":6315,"id":243002,"goal":"predicate IsPermutation_6315(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_6316","instance":6316,"id":243003,"goal":"predicate IsEven_6316(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_6317","instance":6317,"id":243004,"goal":"predicate InRange_6317(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_6318","instance":6318,"id":243005,"goal":"predicate SubsetOf_6318(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_6319","instance":6319,"id":243006,"goal":"predicate AllMem_6319(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_6320","instance":6320,"id":243007,"goal":"predicate DisjointSets_6320(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_6321","instance":6321,"id":243008,"goal":"predicate Sorted_6321(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_6322","instance":6322,"id":243009,"goal":"predicate AllPositive_6322(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_6323","instance":6323,"id":243010,"goal":"predicate DistinctSeq_6323(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_6324","instance":6324,"id":243011,"goal":"predicate IsSubseq_6324(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_6325","instance":6325,"id":243012,"goal":"predicate IsPermutation_6325(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_6326","instance":6326,"id":243013,"goal":"predicate IsEven_6326(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_6327","instance":6327,"id":243014,"goal":"predicate InRange_6327(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_6328","instance":6328,"id":243015,"goal":"predicate SubsetOf_6328(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_6329","instance":6329,"id":243016,"goal":"predicate AllMem_6329(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_6330","instance":6330,"id":243017,"goal":"predicate DisjointSets_6330(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_6331","instance":6331,"id":243018,"goal":"predicate Sorted_6331(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_6332","instance":6332,"id":243019,"goal":"predicate AllPositive_6332(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_6333","instance":6333,"id":243020,"goal":"predicate DistinctSeq_6333(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_6334","instance":6334,"id":243021,"goal":"predicate IsSubseq_6334(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_6335","instance":6335,"id":243022,"goal":"predicate IsPermutation_6335(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_6336","instance":6336,"id":243023,"goal":"predicate IsEven_6336(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_6337","instance":6337,"id":243024,"goal":"predicate InRange_6337(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_6338","instance":6338,"id":243025,"goal":"predicate SubsetOf_6338(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_6339","instance":6339,"id":243026,"goal":"predicate AllMem_6339(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_6340","instance":6340,"id":243027,"goal":"predicate DisjointSets_6340(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_6341","instance":6341,"id":243028,"goal":"predicate Sorted_6341(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_6342","instance":6342,"id":243029,"goal":"predicate AllPositive_6342(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_6343","instance":6343,"id":243030,"goal":"predicate DistinctSeq_6343(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_6344","instance":6344,"id":243031,"goal":"predicate IsSubseq_6344(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_6345","instance":6345,"id":243032,"goal":"predicate IsPermutation_6345(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_6346","instance":6346,"id":243033,"goal":"predicate IsEven_6346(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_6347","instance":6347,"id":243034,"goal":"predicate InRange_6347(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_6348","instance":6348,"id":243035,"goal":"predicate SubsetOf_6348(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_6349","instance":6349,"id":243036,"goal":"predicate AllMem_6349(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_6350","instance":6350,"id":243037,"goal":"predicate DisjointSets_6350(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_6351","instance":6351,"id":243038,"goal":"predicate Sorted_6351(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_6352","instance":6352,"id":243039,"goal":"predicate AllPositive_6352(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_6353","instance":6353,"id":243040,"goal":"predicate DistinctSeq_6353(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_6354","instance":6354,"id":243041,"goal":"predicate IsSubseq_6354(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_6355","instance":6355,"id":243042,"goal":"predicate IsPermutation_6355(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_6356","instance":6356,"id":243043,"goal":"predicate IsEven_6356(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_6357","instance":6357,"id":243044,"goal":"predicate InRange_6357(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_6358","instance":6358,"id":243045,"goal":"predicate SubsetOf_6358(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_6359","instance":6359,"id":243046,"goal":"predicate AllMem_6359(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_6360","instance":6360,"id":243047,"goal":"predicate DisjointSets_6360(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_6361","instance":6361,"id":243048,"goal":"predicate Sorted_6361(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_6362","instance":6362,"id":243049,"goal":"predicate AllPositive_6362(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_6363","instance":6363,"id":243050,"goal":"predicate DistinctSeq_6363(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_6364","instance":6364,"id":243051,"goal":"predicate IsSubseq_6364(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_6365","instance":6365,"id":243052,"goal":"predicate IsPermutation_6365(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_6366","instance":6366,"id":243053,"goal":"predicate IsEven_6366(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_6367","instance":6367,"id":243054,"goal":"predicate InRange_6367(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_6368","instance":6368,"id":243055,"goal":"predicate SubsetOf_6368(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_6369","instance":6369,"id":243056,"goal":"predicate AllMem_6369(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_6370","instance":6370,"id":243057,"goal":"predicate DisjointSets_6370(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_6371","instance":6371,"id":243058,"goal":"predicate Sorted_6371(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_6372","instance":6372,"id":243059,"goal":"predicate AllPositive_6372(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_6373","instance":6373,"id":243060,"goal":"predicate DistinctSeq_6373(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_6374","instance":6374,"id":243061,"goal":"predicate IsSubseq_6374(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_6375","instance":6375,"id":243062,"goal":"predicate IsPermutation_6375(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_6376","instance":6376,"id":243063,"goal":"predicate IsEven_6376(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_6377","instance":6377,"id":243064,"goal":"predicate InRange_6377(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_6378","instance":6378,"id":243065,"goal":"predicate SubsetOf_6378(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_6379","instance":6379,"id":243066,"goal":"predicate AllMem_6379(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_6380","instance":6380,"id":243067,"goal":"predicate DisjointSets_6380(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_6381","instance":6381,"id":243068,"goal":"predicate Sorted_6381(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_6382","instance":6382,"id":243069,"goal":"predicate AllPositive_6382(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_6383","instance":6383,"id":243070,"goal":"predicate DistinctSeq_6383(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_6384","instance":6384,"id":243071,"goal":"predicate IsSubseq_6384(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_6385","instance":6385,"id":243072,"goal":"predicate IsPermutation_6385(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_6386","instance":6386,"id":243073,"goal":"predicate IsEven_6386(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_6387","instance":6387,"id":243074,"goal":"predicate InRange_6387(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_6388","instance":6388,"id":243075,"goal":"predicate SubsetOf_6388(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_6389","instance":6389,"id":243076,"goal":"predicate AllMem_6389(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_6390","instance":6390,"id":243077,"goal":"predicate DisjointSets_6390(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_6391","instance":6391,"id":243078,"goal":"predicate Sorted_6391(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_6392","instance":6392,"id":243079,"goal":"predicate AllPositive_6392(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_6393","instance":6393,"id":243080,"goal":"predicate DistinctSeq_6393(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_6394","instance":6394,"id":243081,"goal":"predicate IsSubseq_6394(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_6395","instance":6395,"id":243082,"goal":"predicate IsPermutation_6395(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_6396","instance":6396,"id":243083,"goal":"predicate IsEven_6396(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_6397","instance":6397,"id":243084,"goal":"predicate InRange_6397(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_6398","instance":6398,"id":243085,"goal":"predicate SubsetOf_6398(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_6399","instance":6399,"id":243086,"goal":"predicate AllMem_6399(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_6400","instance":6400,"id":243087,"goal":"predicate DisjointSets_6400(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_6401","instance":6401,"id":243088,"goal":"predicate Sorted_6401(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_6402","instance":6402,"id":243089,"goal":"predicate AllPositive_6402(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_6403","instance":6403,"id":243090,"goal":"predicate DistinctSeq_6403(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_6404","instance":6404,"id":243091,"goal":"predicate IsSubseq_6404(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_6405","instance":6405,"id":243092,"goal":"predicate IsPermutation_6405(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_6406","instance":6406,"id":243093,"goal":"predicate IsEven_6406(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_6407","instance":6407,"id":243094,"goal":"predicate InRange_6407(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_6408","instance":6408,"id":243095,"goal":"predicate SubsetOf_6408(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_6409","instance":6409,"id":243096,"goal":"predicate AllMem_6409(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_6410","instance":6410,"id":243097,"goal":"predicate DisjointSets_6410(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_6411","instance":6411,"id":243098,"goal":"predicate Sorted_6411(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_6412","instance":6412,"id":243099,"goal":"predicate AllPositive_6412(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_6413","instance":6413,"id":243100,"goal":"predicate DistinctSeq_6413(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_6414","instance":6414,"id":243101,"goal":"predicate IsSubseq_6414(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_6415","instance":6415,"id":243102,"goal":"predicate IsPermutation_6415(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_6416","instance":6416,"id":243103,"goal":"predicate IsEven_6416(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_6417","instance":6417,"id":243104,"goal":"predicate InRange_6417(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_6418","instance":6418,"id":243105,"goal":"predicate SubsetOf_6418(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_6419","instance":6419,"id":243106,"goal":"predicate AllMem_6419(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_6420","instance":6420,"id":243107,"goal":"predicate DisjointSets_6420(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_6421","instance":6421,"id":243108,"goal":"predicate Sorted_6421(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_6422","instance":6422,"id":243109,"goal":"predicate AllPositive_6422(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_6423","instance":6423,"id":243110,"goal":"predicate DistinctSeq_6423(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_6424","instance":6424,"id":243111,"goal":"predicate IsSubseq_6424(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_6425","instance":6425,"id":243112,"goal":"predicate IsPermutation_6425(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_6426","instance":6426,"id":243113,"goal":"predicate IsEven_6426(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_6427","instance":6427,"id":243114,"goal":"predicate InRange_6427(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_6428","instance":6428,"id":243115,"goal":"predicate SubsetOf_6428(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_6429","instance":6429,"id":243116,"goal":"predicate AllMem_6429(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_6430","instance":6430,"id":243117,"goal":"predicate DisjointSets_6430(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_6431","instance":6431,"id":243118,"goal":"predicate Sorted_6431(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_6432","instance":6432,"id":243119,"goal":"predicate AllPositive_6432(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_6433","instance":6433,"id":243120,"goal":"predicate DistinctSeq_6433(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_6434","instance":6434,"id":243121,"goal":"predicate IsSubseq_6434(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_6435","instance":6435,"id":243122,"goal":"predicate IsPermutation_6435(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_6436","instance":6436,"id":243123,"goal":"predicate IsEven_6436(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_6437","instance":6437,"id":243124,"goal":"predicate InRange_6437(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_6438","instance":6438,"id":243125,"goal":"predicate SubsetOf_6438(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_6439","instance":6439,"id":243126,"goal":"predicate AllMem_6439(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_6440","instance":6440,"id":243127,"goal":"predicate DisjointSets_6440(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_6441","instance":6441,"id":243128,"goal":"predicate Sorted_6441(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_6442","instance":6442,"id":243129,"goal":"predicate AllPositive_6442(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_6443","instance":6443,"id":243130,"goal":"predicate DistinctSeq_6443(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_6444","instance":6444,"id":243131,"goal":"predicate IsSubseq_6444(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_6445","instance":6445,"id":243132,"goal":"predicate IsPermutation_6445(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_6446","instance":6446,"id":243133,"goal":"predicate IsEven_6446(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_6447","instance":6447,"id":243134,"goal":"predicate InRange_6447(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_6448","instance":6448,"id":243135,"goal":"predicate SubsetOf_6448(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_6449","instance":6449,"id":243136,"goal":"predicate AllMem_6449(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_6450","instance":6450,"id":243137,"goal":"predicate DisjointSets_6450(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_6451","instance":6451,"id":243138,"goal":"predicate Sorted_6451(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_6452","instance":6452,"id":243139,"goal":"predicate AllPositive_6452(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_6453","instance":6453,"id":243140,"goal":"predicate DistinctSeq_6453(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_6454","instance":6454,"id":243141,"goal":"predicate IsSubseq_6454(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_6455","instance":6455,"id":243142,"goal":"predicate IsPermutation_6455(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_6456","instance":6456,"id":243143,"goal":"predicate IsEven_6456(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_6457","instance":6457,"id":243144,"goal":"predicate InRange_6457(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_6458","instance":6458,"id":243145,"goal":"predicate SubsetOf_6458(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_6459","instance":6459,"id":243146,"goal":"predicate AllMem_6459(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_6460","instance":6460,"id":243147,"goal":"predicate DisjointSets_6460(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_6461","instance":6461,"id":243148,"goal":"predicate Sorted_6461(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_6462","instance":6462,"id":243149,"goal":"predicate AllPositive_6462(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_6463","instance":6463,"id":243150,"goal":"predicate DistinctSeq_6463(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_6464","instance":6464,"id":243151,"goal":"predicate IsSubseq_6464(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_6465","instance":6465,"id":243152,"goal":"predicate IsPermutation_6465(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_6466","instance":6466,"id":243153,"goal":"predicate IsEven_6466(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_6467","instance":6467,"id":243154,"goal":"predicate InRange_6467(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_6468","instance":6468,"id":243155,"goal":"predicate SubsetOf_6468(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_6469","instance":6469,"id":243156,"goal":"predicate AllMem_6469(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_6470","instance":6470,"id":243157,"goal":"predicate DisjointSets_6470(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_6471","instance":6471,"id":243158,"goal":"predicate Sorted_6471(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_6472","instance":6472,"id":243159,"goal":"predicate AllPositive_6472(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_6473","instance":6473,"id":243160,"goal":"predicate DistinctSeq_6473(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_6474","instance":6474,"id":243161,"goal":"predicate IsSubseq_6474(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_6475","instance":6475,"id":243162,"goal":"predicate IsPermutation_6475(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_6476","instance":6476,"id":243163,"goal":"predicate IsEven_6476(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_6477","instance":6477,"id":243164,"goal":"predicate InRange_6477(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_6478","instance":6478,"id":243165,"goal":"predicate SubsetOf_6478(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_6479","instance":6479,"id":243166,"goal":"predicate AllMem_6479(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_6480","instance":6480,"id":243167,"goal":"predicate DisjointSets_6480(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_6481","instance":6481,"id":243168,"goal":"predicate Sorted_6481(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_6482","instance":6482,"id":243169,"goal":"predicate AllPositive_6482(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_6483","instance":6483,"id":243170,"goal":"predicate DistinctSeq_6483(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_6484","instance":6484,"id":243171,"goal":"predicate IsSubseq_6484(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_6485","instance":6485,"id":243172,"goal":"predicate IsPermutation_6485(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_6486","instance":6486,"id":243173,"goal":"predicate IsEven_6486(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_6487","instance":6487,"id":243174,"goal":"predicate InRange_6487(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_6488","instance":6488,"id":243175,"goal":"predicate SubsetOf_6488(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_6489","instance":6489,"id":243176,"goal":"predicate AllMem_6489(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_6490","instance":6490,"id":243177,"goal":"predicate DisjointSets_6490(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_6491","instance":6491,"id":243178,"goal":"predicate Sorted_6491(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_6492","instance":6492,"id":243179,"goal":"predicate AllPositive_6492(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_6493","instance":6493,"id":243180,"goal":"predicate DistinctSeq_6493(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_6494","instance":6494,"id":243181,"goal":"predicate IsSubseq_6494(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_6495","instance":6495,"id":243182,"goal":"predicate IsPermutation_6495(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_6496","instance":6496,"id":243183,"goal":"predicate IsEven_6496(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_6497","instance":6497,"id":243184,"goal":"predicate InRange_6497(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_6498","instance":6498,"id":243185,"goal":"predicate SubsetOf_6498(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_6499","instance":6499,"id":243186,"goal":"predicate AllMem_6499(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_6500","instance":6500,"id":243187,"goal":"predicate DisjointSets_6500(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_6501","instance":6501,"id":243188,"goal":"predicate Sorted_6501(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_6502","instance":6502,"id":243189,"goal":"predicate AllPositive_6502(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_6503","instance":6503,"id":243190,"goal":"predicate DistinctSeq_6503(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_6504","instance":6504,"id":243191,"goal":"predicate IsSubseq_6504(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_6505","instance":6505,"id":243192,"goal":"predicate IsPermutation_6505(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_6506","instance":6506,"id":243193,"goal":"predicate IsEven_6506(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_6507","instance":6507,"id":243194,"goal":"predicate InRange_6507(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_6508","instance":6508,"id":243195,"goal":"predicate SubsetOf_6508(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_6509","instance":6509,"id":243196,"goal":"predicate AllMem_6509(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_6510","instance":6510,"id":243197,"goal":"predicate DisjointSets_6510(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_6511","instance":6511,"id":243198,"goal":"predicate Sorted_6511(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_6512","instance":6512,"id":243199,"goal":"predicate AllPositive_6512(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_6513","instance":6513,"id":243200,"goal":"predicate DistinctSeq_6513(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_6514","instance":6514,"id":243201,"goal":"predicate IsSubseq_6514(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_6515","instance":6515,"id":243202,"goal":"predicate IsPermutation_6515(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_6516","instance":6516,"id":243203,"goal":"predicate IsEven_6516(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_6517","instance":6517,"id":243204,"goal":"predicate InRange_6517(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_6518","instance":6518,"id":243205,"goal":"predicate SubsetOf_6518(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_6519","instance":6519,"id":243206,"goal":"predicate AllMem_6519(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_6520","instance":6520,"id":243207,"goal":"predicate DisjointSets_6520(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_6521","instance":6521,"id":243208,"goal":"predicate Sorted_6521(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_6522","instance":6522,"id":243209,"goal":"predicate AllPositive_6522(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_6523","instance":6523,"id":243210,"goal":"predicate DistinctSeq_6523(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_6524","instance":6524,"id":243211,"goal":"predicate IsSubseq_6524(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_6525","instance":6525,"id":243212,"goal":"predicate IsPermutation_6525(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_6526","instance":6526,"id":243213,"goal":"predicate IsEven_6526(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_6527","instance":6527,"id":243214,"goal":"predicate InRange_6527(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_6528","instance":6528,"id":243215,"goal":"predicate SubsetOf_6528(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_6529","instance":6529,"id":243216,"goal":"predicate AllMem_6529(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_6530","instance":6530,"id":243217,"goal":"predicate DisjointSets_6530(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_6531","instance":6531,"id":243218,"goal":"predicate Sorted_6531(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_6532","instance":6532,"id":243219,"goal":"predicate AllPositive_6532(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_6533","instance":6533,"id":243220,"goal":"predicate DistinctSeq_6533(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_6534","instance":6534,"id":243221,"goal":"predicate IsSubseq_6534(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_6535","instance":6535,"id":243222,"goal":"predicate IsPermutation_6535(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_6536","instance":6536,"id":243223,"goal":"predicate IsEven_6536(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_6537","instance":6537,"id":243224,"goal":"predicate InRange_6537(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_6538","instance":6538,"id":243225,"goal":"predicate SubsetOf_6538(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_6539","instance":6539,"id":243226,"goal":"predicate AllMem_6539(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_6540","instance":6540,"id":243227,"goal":"predicate DisjointSets_6540(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_6541","instance":6541,"id":243228,"goal":"predicate Sorted_6541(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_6542","instance":6542,"id":243229,"goal":"predicate AllPositive_6542(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_6543","instance":6543,"id":243230,"goal":"predicate DistinctSeq_6543(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_6544","instance":6544,"id":243231,"goal":"predicate IsSubseq_6544(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_6545","instance":6545,"id":243232,"goal":"predicate IsPermutation_6545(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_6546","instance":6546,"id":243233,"goal":"predicate IsEven_6546(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_6547","instance":6547,"id":243234,"goal":"predicate InRange_6547(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_6548","instance":6548,"id":243235,"goal":"predicate SubsetOf_6548(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_6549","instance":6549,"id":243236,"goal":"predicate AllMem_6549(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_6550","instance":6550,"id":243237,"goal":"predicate DisjointSets_6550(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_6551","instance":6551,"id":243238,"goal":"predicate Sorted_6551(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_6552","instance":6552,"id":243239,"goal":"predicate AllPositive_6552(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_6553","instance":6553,"id":243240,"goal":"predicate DistinctSeq_6553(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_6554","instance":6554,"id":243241,"goal":"predicate IsSubseq_6554(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_6555","instance":6555,"id":243242,"goal":"predicate IsPermutation_6555(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_6556","instance":6556,"id":243243,"goal":"predicate IsEven_6556(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_6557","instance":6557,"id":243244,"goal":"predicate InRange_6557(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_6558","instance":6558,"id":243245,"goal":"predicate SubsetOf_6558(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_6559","instance":6559,"id":243246,"goal":"predicate AllMem_6559(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_6560","instance":6560,"id":243247,"goal":"predicate DisjointSets_6560(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_6561","instance":6561,"id":243248,"goal":"predicate Sorted_6561(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_6562","instance":6562,"id":243249,"goal":"predicate AllPositive_6562(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_6563","instance":6563,"id":243250,"goal":"predicate DistinctSeq_6563(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_6564","instance":6564,"id":243251,"goal":"predicate IsSubseq_6564(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_6565","instance":6565,"id":243252,"goal":"predicate IsPermutation_6565(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_6566","instance":6566,"id":243253,"goal":"predicate IsEven_6566(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_6567","instance":6567,"id":243254,"goal":"predicate InRange_6567(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_6568","instance":6568,"id":243255,"goal":"predicate SubsetOf_6568(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_6569","instance":6569,"id":243256,"goal":"predicate AllMem_6569(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_6570","instance":6570,"id":243257,"goal":"predicate DisjointSets_6570(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_6571","instance":6571,"id":243258,"goal":"predicate Sorted_6571(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_6572","instance":6572,"id":243259,"goal":"predicate AllPositive_6572(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_6573","instance":6573,"id":243260,"goal":"predicate DistinctSeq_6573(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_6574","instance":6574,"id":243261,"goal":"predicate IsSubseq_6574(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_6575","instance":6575,"id":243262,"goal":"predicate IsPermutation_6575(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_6576","instance":6576,"id":243263,"goal":"predicate IsEven_6576(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_6577","instance":6577,"id":243264,"goal":"predicate InRange_6577(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_6578","instance":6578,"id":243265,"goal":"predicate SubsetOf_6578(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_6579","instance":6579,"id":243266,"goal":"predicate AllMem_6579(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_6580","instance":6580,"id":243267,"goal":"predicate DisjointSets_6580(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_6581","instance":6581,"id":243268,"goal":"predicate Sorted_6581(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_6582","instance":6582,"id":243269,"goal":"predicate AllPositive_6582(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_6583","instance":6583,"id":243270,"goal":"predicate DistinctSeq_6583(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_6584","instance":6584,"id":243271,"goal":"predicate IsSubseq_6584(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_6585","instance":6585,"id":243272,"goal":"predicate IsPermutation_6585(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_6586","instance":6586,"id":243273,"goal":"predicate IsEven_6586(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_6587","instance":6587,"id":243274,"goal":"predicate InRange_6587(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_6588","instance":6588,"id":243275,"goal":"predicate SubsetOf_6588(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_6589","instance":6589,"id":243276,"goal":"predicate AllMem_6589(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_6590","instance":6590,"id":243277,"goal":"predicate DisjointSets_6590(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_6591","instance":6591,"id":243278,"goal":"predicate Sorted_6591(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_6592","instance":6592,"id":243279,"goal":"predicate AllPositive_6592(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_6593","instance":6593,"id":243280,"goal":"predicate DistinctSeq_6593(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_6594","instance":6594,"id":243281,"goal":"predicate IsSubseq_6594(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_6595","instance":6595,"id":243282,"goal":"predicate IsPermutation_6595(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_6596","instance":6596,"id":243283,"goal":"predicate IsEven_6596(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_6597","instance":6597,"id":243284,"goal":"predicate InRange_6597(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_6598","instance":6598,"id":243285,"goal":"predicate SubsetOf_6598(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_6599","instance":6599,"id":243286,"goal":"predicate AllMem_6599(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_6600","instance":6600,"id":243287,"goal":"predicate DisjointSets_6600(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_6601","instance":6601,"id":243288,"goal":"predicate Sorted_6601(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_6602","instance":6602,"id":243289,"goal":"predicate AllPositive_6602(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_6603","instance":6603,"id":243290,"goal":"predicate DistinctSeq_6603(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_6604","instance":6604,"id":243291,"goal":"predicate IsSubseq_6604(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_6605","instance":6605,"id":243292,"goal":"predicate IsPermutation_6605(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_6606","instance":6606,"id":243293,"goal":"predicate IsEven_6606(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_6607","instance":6607,"id":243294,"goal":"predicate InRange_6607(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_6608","instance":6608,"id":243295,"goal":"predicate SubsetOf_6608(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_6609","instance":6609,"id":243296,"goal":"predicate AllMem_6609(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_6610","instance":6610,"id":243297,"goal":"predicate DisjointSets_6610(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_6611","instance":6611,"id":243298,"goal":"predicate Sorted_6611(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_6612","instance":6612,"id":243299,"goal":"predicate AllPositive_6612(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_6613","instance":6613,"id":243300,"goal":"predicate DistinctSeq_6613(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_6614","instance":6614,"id":243301,"goal":"predicate IsSubseq_6614(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_6615","instance":6615,"id":243302,"goal":"predicate IsPermutation_6615(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_6616","instance":6616,"id":243303,"goal":"predicate IsEven_6616(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_6617","instance":6617,"id":243304,"goal":"predicate InRange_6617(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_6618","instance":6618,"id":243305,"goal":"predicate SubsetOf_6618(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_6619","instance":6619,"id":243306,"goal":"predicate AllMem_6619(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_6620","instance":6620,"id":243307,"goal":"predicate DisjointSets_6620(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_6621","instance":6621,"id":243308,"goal":"predicate Sorted_6621(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_6622","instance":6622,"id":243309,"goal":"predicate AllPositive_6622(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_6623","instance":6623,"id":243310,"goal":"predicate DistinctSeq_6623(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_6624","instance":6624,"id":243311,"goal":"predicate IsSubseq_6624(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_6625","instance":6625,"id":243312,"goal":"predicate IsPermutation_6625(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_6626","instance":6626,"id":243313,"goal":"predicate IsEven_6626(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_6627","instance":6627,"id":243314,"goal":"predicate InRange_6627(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_6628","instance":6628,"id":243315,"goal":"predicate SubsetOf_6628(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_6629","instance":6629,"id":243316,"goal":"predicate AllMem_6629(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_6630","instance":6630,"id":243317,"goal":"predicate DisjointSets_6630(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_6631","instance":6631,"id":243318,"goal":"predicate Sorted_6631(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_6632","instance":6632,"id":243319,"goal":"predicate AllPositive_6632(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_6633","instance":6633,"id":243320,"goal":"predicate DistinctSeq_6633(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_6634","instance":6634,"id":243321,"goal":"predicate IsSubseq_6634(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_6635","instance":6635,"id":243322,"goal":"predicate IsPermutation_6635(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_6636","instance":6636,"id":243323,"goal":"predicate IsEven_6636(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_6637","instance":6637,"id":243324,"goal":"predicate InRange_6637(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_6638","instance":6638,"id":243325,"goal":"predicate SubsetOf_6638(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_6639","instance":6639,"id":243326,"goal":"predicate AllMem_6639(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_6640","instance":6640,"id":243327,"goal":"predicate DisjointSets_6640(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_6641","instance":6641,"id":243328,"goal":"predicate Sorted_6641(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_6642","instance":6642,"id":243329,"goal":"predicate AllPositive_6642(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_6643","instance":6643,"id":243330,"goal":"predicate DistinctSeq_6643(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_6644","instance":6644,"id":243331,"goal":"predicate IsSubseq_6644(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_6645","instance":6645,"id":243332,"goal":"predicate IsPermutation_6645(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_6646","instance":6646,"id":243333,"goal":"predicate IsEven_6646(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_6647","instance":6647,"id":243334,"goal":"predicate InRange_6647(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_6648","instance":6648,"id":243335,"goal":"predicate SubsetOf_6648(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_6649","instance":6649,"id":243336,"goal":"predicate AllMem_6649(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_6650","instance":6650,"id":243337,"goal":"predicate DisjointSets_6650(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_6651","instance":6651,"id":243338,"goal":"predicate Sorted_6651(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_6652","instance":6652,"id":243339,"goal":"predicate AllPositive_6652(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_6653","instance":6653,"id":243340,"goal":"predicate DistinctSeq_6653(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_6654","instance":6654,"id":243341,"goal":"predicate IsSubseq_6654(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_6655","instance":6655,"id":243342,"goal":"predicate IsPermutation_6655(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_6656","instance":6656,"id":243343,"goal":"predicate IsEven_6656(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_6657","instance":6657,"id":243344,"goal":"predicate InRange_6657(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_6658","instance":6658,"id":243345,"goal":"predicate SubsetOf_6658(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_6659","instance":6659,"id":243346,"goal":"predicate AllMem_6659(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_6660","instance":6660,"id":243347,"goal":"predicate DisjointSets_6660(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_6661","instance":6661,"id":243348,"goal":"predicate Sorted_6661(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_6662","instance":6662,"id":243349,"goal":"predicate AllPositive_6662(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_6663","instance":6663,"id":243350,"goal":"predicate DistinctSeq_6663(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_6664","instance":6664,"id":243351,"goal":"predicate IsSubseq_6664(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_6665","instance":6665,"id":243352,"goal":"predicate IsPermutation_6665(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_6666","instance":6666,"id":243353,"goal":"predicate IsEven_6666(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_6667","instance":6667,"id":243354,"goal":"predicate InRange_6667(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_6668","instance":6668,"id":243355,"goal":"predicate SubsetOf_6668(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_6669","instance":6669,"id":243356,"goal":"predicate AllMem_6669(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_6670","instance":6670,"id":243357,"goal":"predicate DisjointSets_6670(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_6671","instance":6671,"id":243358,"goal":"predicate Sorted_6671(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_6672","instance":6672,"id":243359,"goal":"predicate AllPositive_6672(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_6673","instance":6673,"id":243360,"goal":"predicate DistinctSeq_6673(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_6674","instance":6674,"id":243361,"goal":"predicate IsSubseq_6674(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_6675","instance":6675,"id":243362,"goal":"predicate IsPermutation_6675(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_6676","instance":6676,"id":243363,"goal":"predicate IsEven_6676(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_6677","instance":6677,"id":243364,"goal":"predicate InRange_6677(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_6678","instance":6678,"id":243365,"goal":"predicate SubsetOf_6678(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_6679","instance":6679,"id":243366,"goal":"predicate AllMem_6679(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_6680","instance":6680,"id":243367,"goal":"predicate DisjointSets_6680(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_6681","instance":6681,"id":243368,"goal":"predicate Sorted_6681(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_6682","instance":6682,"id":243369,"goal":"predicate AllPositive_6682(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_6683","instance":6683,"id":243370,"goal":"predicate DistinctSeq_6683(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_6684","instance":6684,"id":243371,"goal":"predicate IsSubseq_6684(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_6685","instance":6685,"id":243372,"goal":"predicate IsPermutation_6685(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_6686","instance":6686,"id":243373,"goal":"predicate IsEven_6686(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_6687","instance":6687,"id":243374,"goal":"predicate InRange_6687(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_6688","instance":6688,"id":243375,"goal":"predicate SubsetOf_6688(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_6689","instance":6689,"id":243376,"goal":"predicate AllMem_6689(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_6690","instance":6690,"id":243377,"goal":"predicate DisjointSets_6690(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_6691","instance":6691,"id":243378,"goal":"predicate Sorted_6691(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_6692","instance":6692,"id":243379,"goal":"predicate AllPositive_6692(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_6693","instance":6693,"id":243380,"goal":"predicate DistinctSeq_6693(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_6694","instance":6694,"id":243381,"goal":"predicate IsSubseq_6694(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_6695","instance":6695,"id":243382,"goal":"predicate IsPermutation_6695(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_6696","instance":6696,"id":243383,"goal":"predicate IsEven_6696(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_6697","instance":6697,"id":243384,"goal":"predicate InRange_6697(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_6698","instance":6698,"id":243385,"goal":"predicate SubsetOf_6698(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_6699","instance":6699,"id":243386,"goal":"predicate AllMem_6699(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_6700","instance":6700,"id":243387,"goal":"predicate DisjointSets_6700(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_6701","instance":6701,"id":243388,"goal":"predicate Sorted_6701(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_6702","instance":6702,"id":243389,"goal":"predicate AllPositive_6702(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_6703","instance":6703,"id":243390,"goal":"predicate DistinctSeq_6703(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_6704","instance":6704,"id":243391,"goal":"predicate IsSubseq_6704(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_6705","instance":6705,"id":243392,"goal":"predicate IsPermutation_6705(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_6706","instance":6706,"id":243393,"goal":"predicate IsEven_6706(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_6707","instance":6707,"id":243394,"goal":"predicate InRange_6707(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_6708","instance":6708,"id":243395,"goal":"predicate SubsetOf_6708(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_6709","instance":6709,"id":243396,"goal":"predicate AllMem_6709(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_6710","instance":6710,"id":243397,"goal":"predicate DisjointSets_6710(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_6711","instance":6711,"id":243398,"goal":"predicate Sorted_6711(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_6712","instance":6712,"id":243399,"goal":"predicate AllPositive_6712(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_6713","instance":6713,"id":243400,"goal":"predicate DistinctSeq_6713(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_6714","instance":6714,"id":243401,"goal":"predicate IsSubseq_6714(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_6715","instance":6715,"id":243402,"goal":"predicate IsPermutation_6715(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_6716","instance":6716,"id":243403,"goal":"predicate IsEven_6716(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_6717","instance":6717,"id":243404,"goal":"predicate InRange_6717(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_6718","instance":6718,"id":243405,"goal":"predicate SubsetOf_6718(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_6719","instance":6719,"id":243406,"goal":"predicate AllMem_6719(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_6720","instance":6720,"id":243407,"goal":"predicate DisjointSets_6720(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_6721","instance":6721,"id":243408,"goal":"predicate Sorted_6721(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_6722","instance":6722,"id":243409,"goal":"predicate AllPositive_6722(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_6723","instance":6723,"id":243410,"goal":"predicate DistinctSeq_6723(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_6724","instance":6724,"id":243411,"goal":"predicate IsSubseq_6724(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_6725","instance":6725,"id":243412,"goal":"predicate IsPermutation_6725(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_6726","instance":6726,"id":243413,"goal":"predicate IsEven_6726(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_6727","instance":6727,"id":243414,"goal":"predicate InRange_6727(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_6728","instance":6728,"id":243415,"goal":"predicate SubsetOf_6728(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_6729","instance":6729,"id":243416,"goal":"predicate AllMem_6729(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_6730","instance":6730,"id":243417,"goal":"predicate DisjointSets_6730(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_6731","instance":6731,"id":243418,"goal":"predicate Sorted_6731(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_6732","instance":6732,"id":243419,"goal":"predicate AllPositive_6732(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_6733","instance":6733,"id":243420,"goal":"predicate DistinctSeq_6733(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_6734","instance":6734,"id":243421,"goal":"predicate IsSubseq_6734(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_6735","instance":6735,"id":243422,"goal":"predicate IsPermutation_6735(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_6736","instance":6736,"id":243423,"goal":"predicate IsEven_6736(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_6737","instance":6737,"id":243424,"goal":"predicate InRange_6737(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_6738","instance":6738,"id":243425,"goal":"predicate SubsetOf_6738(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_6739","instance":6739,"id":243426,"goal":"predicate AllMem_6739(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_6740","instance":6740,"id":243427,"goal":"predicate DisjointSets_6740(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_6741","instance":6741,"id":243428,"goal":"predicate Sorted_6741(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_6742","instance":6742,"id":243429,"goal":"predicate AllPositive_6742(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_6743","instance":6743,"id":243430,"goal":"predicate DistinctSeq_6743(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_6744","instance":6744,"id":243431,"goal":"predicate IsSubseq_6744(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_6745","instance":6745,"id":243432,"goal":"predicate IsPermutation_6745(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_6746","instance":6746,"id":243433,"goal":"predicate IsEven_6746(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_6747","instance":6747,"id":243434,"goal":"predicate InRange_6747(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_6748","instance":6748,"id":243435,"goal":"predicate SubsetOf_6748(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_6749","instance":6749,"id":243436,"goal":"predicate AllMem_6749(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_6750","instance":6750,"id":243437,"goal":"predicate DisjointSets_6750(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_6751","instance":6751,"id":243438,"goal":"predicate Sorted_6751(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_6752","instance":6752,"id":243439,"goal":"predicate AllPositive_6752(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_6753","instance":6753,"id":243440,"goal":"predicate DistinctSeq_6753(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_6754","instance":6754,"id":243441,"goal":"predicate IsSubseq_6754(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_6755","instance":6755,"id":243442,"goal":"predicate IsPermutation_6755(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_6756","instance":6756,"id":243443,"goal":"predicate IsEven_6756(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_6757","instance":6757,"id":243444,"goal":"predicate InRange_6757(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_6758","instance":6758,"id":243445,"goal":"predicate SubsetOf_6758(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_6759","instance":6759,"id":243446,"goal":"predicate AllMem_6759(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_6760","instance":6760,"id":243447,"goal":"predicate DisjointSets_6760(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_6761","instance":6761,"id":243448,"goal":"predicate Sorted_6761(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_6762","instance":6762,"id":243449,"goal":"predicate AllPositive_6762(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_6763","instance":6763,"id":243450,"goal":"predicate DistinctSeq_6763(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_6764","instance":6764,"id":243451,"goal":"predicate IsSubseq_6764(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_6765","instance":6765,"id":243452,"goal":"predicate IsPermutation_6765(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_6766","instance":6766,"id":243453,"goal":"predicate IsEven_6766(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_6767","instance":6767,"id":243454,"goal":"predicate InRange_6767(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_6768","instance":6768,"id":243455,"goal":"predicate SubsetOf_6768(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_6769","instance":6769,"id":243456,"goal":"predicate AllMem_6769(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_6770","instance":6770,"id":243457,"goal":"predicate DisjointSets_6770(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_6771","instance":6771,"id":243458,"goal":"predicate Sorted_6771(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_6772","instance":6772,"id":243459,"goal":"predicate AllPositive_6772(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_6773","instance":6773,"id":243460,"goal":"predicate DistinctSeq_6773(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_6774","instance":6774,"id":243461,"goal":"predicate IsSubseq_6774(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_6775","instance":6775,"id":243462,"goal":"predicate IsPermutation_6775(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_6776","instance":6776,"id":243463,"goal":"predicate IsEven_6776(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_6777","instance":6777,"id":243464,"goal":"predicate InRange_6777(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_6778","instance":6778,"id":243465,"goal":"predicate SubsetOf_6778(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_6779","instance":6779,"id":243466,"goal":"predicate AllMem_6779(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_6780","instance":6780,"id":243467,"goal":"predicate DisjointSets_6780(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_6781","instance":6781,"id":243468,"goal":"predicate Sorted_6781(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_6782","instance":6782,"id":243469,"goal":"predicate AllPositive_6782(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_6783","instance":6783,"id":243470,"goal":"predicate DistinctSeq_6783(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_6784","instance":6784,"id":243471,"goal":"predicate IsSubseq_6784(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_6785","instance":6785,"id":243472,"goal":"predicate IsPermutation_6785(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_6786","instance":6786,"id":243473,"goal":"predicate IsEven_6786(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_6787","instance":6787,"id":243474,"goal":"predicate InRange_6787(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_6788","instance":6788,"id":243475,"goal":"predicate SubsetOf_6788(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_6789","instance":6789,"id":243476,"goal":"predicate AllMem_6789(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_6790","instance":6790,"id":243477,"goal":"predicate DisjointSets_6790(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_6791","instance":6791,"id":243478,"goal":"predicate Sorted_6791(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_6792","instance":6792,"id":243479,"goal":"predicate AllPositive_6792(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_6793","instance":6793,"id":243480,"goal":"predicate DistinctSeq_6793(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_6794","instance":6794,"id":243481,"goal":"predicate IsSubseq_6794(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_6795","instance":6795,"id":243482,"goal":"predicate IsPermutation_6795(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_6796","instance":6796,"id":243483,"goal":"predicate IsEven_6796(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_6797","instance":6797,"id":243484,"goal":"predicate InRange_6797(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_6798","instance":6798,"id":243485,"goal":"predicate SubsetOf_6798(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_6799","instance":6799,"id":243486,"goal":"predicate AllMem_6799(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_6800","instance":6800,"id":243487,"goal":"predicate DisjointSets_6800(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_6801","instance":6801,"id":243488,"goal":"predicate Sorted_6801(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_6802","instance":6802,"id":243489,"goal":"predicate AllPositive_6802(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_6803","instance":6803,"id":243490,"goal":"predicate DistinctSeq_6803(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_6804","instance":6804,"id":243491,"goal":"predicate IsSubseq_6804(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_6805","instance":6805,"id":243492,"goal":"predicate IsPermutation_6805(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_6806","instance":6806,"id":243493,"goal":"predicate IsEven_6806(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_6807","instance":6807,"id":243494,"goal":"predicate InRange_6807(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_6808","instance":6808,"id":243495,"goal":"predicate SubsetOf_6808(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_6809","instance":6809,"id":243496,"goal":"predicate AllMem_6809(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_6810","instance":6810,"id":243497,"goal":"predicate DisjointSets_6810(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_6811","instance":6811,"id":243498,"goal":"predicate Sorted_6811(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_6812","instance":6812,"id":243499,"goal":"predicate AllPositive_6812(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_6813","instance":6813,"id":243500,"goal":"predicate DistinctSeq_6813(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_6814","instance":6814,"id":243501,"goal":"predicate IsSubseq_6814(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_6815","instance":6815,"id":243502,"goal":"predicate IsPermutation_6815(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_6816","instance":6816,"id":243503,"goal":"predicate IsEven_6816(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_6817","instance":6817,"id":243504,"goal":"predicate InRange_6817(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_6818","instance":6818,"id":243505,"goal":"predicate SubsetOf_6818(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_6819","instance":6819,"id":243506,"goal":"predicate AllMem_6819(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_6820","instance":6820,"id":243507,"goal":"predicate DisjointSets_6820(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_6821","instance":6821,"id":243508,"goal":"predicate Sorted_6821(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_6822","instance":6822,"id":243509,"goal":"predicate AllPositive_6822(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_6823","instance":6823,"id":243510,"goal":"predicate DistinctSeq_6823(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_6824","instance":6824,"id":243511,"goal":"predicate IsSubseq_6824(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_6825","instance":6825,"id":243512,"goal":"predicate IsPermutation_6825(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_6826","instance":6826,"id":243513,"goal":"predicate IsEven_6826(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_6827","instance":6827,"id":243514,"goal":"predicate InRange_6827(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_6828","instance":6828,"id":243515,"goal":"predicate SubsetOf_6828(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_6829","instance":6829,"id":243516,"goal":"predicate AllMem_6829(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_6830","instance":6830,"id":243517,"goal":"predicate DisjointSets_6830(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_6831","instance":6831,"id":243518,"goal":"predicate Sorted_6831(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_6832","instance":6832,"id":243519,"goal":"predicate AllPositive_6832(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_6833","instance":6833,"id":243520,"goal":"predicate DistinctSeq_6833(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_6834","instance":6834,"id":243521,"goal":"predicate IsSubseq_6834(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_6835","instance":6835,"id":243522,"goal":"predicate IsPermutation_6835(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_6836","instance":6836,"id":243523,"goal":"predicate IsEven_6836(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_6837","instance":6837,"id":243524,"goal":"predicate InRange_6837(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_6838","instance":6838,"id":243525,"goal":"predicate SubsetOf_6838(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_6839","instance":6839,"id":243526,"goal":"predicate AllMem_6839(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_6840","instance":6840,"id":243527,"goal":"predicate DisjointSets_6840(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_6841","instance":6841,"id":243528,"goal":"predicate Sorted_6841(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_6842","instance":6842,"id":243529,"goal":"predicate AllPositive_6842(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_6843","instance":6843,"id":243530,"goal":"predicate DistinctSeq_6843(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_6844","instance":6844,"id":243531,"goal":"predicate IsSubseq_6844(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_6845","instance":6845,"id":243532,"goal":"predicate IsPermutation_6845(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_6846","instance":6846,"id":243533,"goal":"predicate IsEven_6846(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_6847","instance":6847,"id":243534,"goal":"predicate InRange_6847(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_6848","instance":6848,"id":243535,"goal":"predicate SubsetOf_6848(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_6849","instance":6849,"id":243536,"goal":"predicate AllMem_6849(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_6850","instance":6850,"id":243537,"goal":"predicate DisjointSets_6850(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_6851","instance":6851,"id":243538,"goal":"predicate Sorted_6851(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_6852","instance":6852,"id":243539,"goal":"predicate AllPositive_6852(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_6853","instance":6853,"id":243540,"goal":"predicate DistinctSeq_6853(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_6854","instance":6854,"id":243541,"goal":"predicate IsSubseq_6854(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_6855","instance":6855,"id":243542,"goal":"predicate IsPermutation_6855(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_6856","instance":6856,"id":243543,"goal":"predicate IsEven_6856(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_6857","instance":6857,"id":243544,"goal":"predicate InRange_6857(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_6858","instance":6858,"id":243545,"goal":"predicate SubsetOf_6858(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_6859","instance":6859,"id":243546,"goal":"predicate AllMem_6859(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_6860","instance":6860,"id":243547,"goal":"predicate DisjointSets_6860(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_6861","instance":6861,"id":243548,"goal":"predicate Sorted_6861(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_6862","instance":6862,"id":243549,"goal":"predicate AllPositive_6862(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_6863","instance":6863,"id":243550,"goal":"predicate DistinctSeq_6863(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_6864","instance":6864,"id":243551,"goal":"predicate IsSubseq_6864(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_6865","instance":6865,"id":243552,"goal":"predicate IsPermutation_6865(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_6866","instance":6866,"id":243553,"goal":"predicate IsEven_6866(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_6867","instance":6867,"id":243554,"goal":"predicate InRange_6867(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_6868","instance":6868,"id":243555,"goal":"predicate SubsetOf_6868(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_6869","instance":6869,"id":243556,"goal":"predicate AllMem_6869(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_6870","instance":6870,"id":243557,"goal":"predicate DisjointSets_6870(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_6871","instance":6871,"id":243558,"goal":"predicate Sorted_6871(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_6872","instance":6872,"id":243559,"goal":"predicate AllPositive_6872(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_6873","instance":6873,"id":243560,"goal":"predicate DistinctSeq_6873(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_6874","instance":6874,"id":243561,"goal":"predicate IsSubseq_6874(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_6875","instance":6875,"id":243562,"goal":"predicate IsPermutation_6875(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_6876","instance":6876,"id":243563,"goal":"predicate IsEven_6876(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_6877","instance":6877,"id":243564,"goal":"predicate InRange_6877(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_6878","instance":6878,"id":243565,"goal":"predicate SubsetOf_6878(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_6879","instance":6879,"id":243566,"goal":"predicate AllMem_6879(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_6880","instance":6880,"id":243567,"goal":"predicate DisjointSets_6880(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_6881","instance":6881,"id":243568,"goal":"predicate Sorted_6881(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_6882","instance":6882,"id":243569,"goal":"predicate AllPositive_6882(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_6883","instance":6883,"id":243570,"goal":"predicate DistinctSeq_6883(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_6884","instance":6884,"id":243571,"goal":"predicate IsSubseq_6884(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_6885","instance":6885,"id":243572,"goal":"predicate IsPermutation_6885(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_6886","instance":6886,"id":243573,"goal":"predicate IsEven_6886(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_6887","instance":6887,"id":243574,"goal":"predicate InRange_6887(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_6888","instance":6888,"id":243575,"goal":"predicate SubsetOf_6888(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_6889","instance":6889,"id":243576,"goal":"predicate AllMem_6889(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_6890","instance":6890,"id":243577,"goal":"predicate DisjointSets_6890(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_6891","instance":6891,"id":243578,"goal":"predicate Sorted_6891(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_6892","instance":6892,"id":243579,"goal":"predicate AllPositive_6892(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_6893","instance":6893,"id":243580,"goal":"predicate DistinctSeq_6893(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_6894","instance":6894,"id":243581,"goal":"predicate IsSubseq_6894(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_6895","instance":6895,"id":243582,"goal":"predicate IsPermutation_6895(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_6896","instance":6896,"id":243583,"goal":"predicate IsEven_6896(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_6897","instance":6897,"id":243584,"goal":"predicate InRange_6897(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_6898","instance":6898,"id":243585,"goal":"predicate SubsetOf_6898(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_6899","instance":6899,"id":243586,"goal":"predicate AllMem_6899(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_6900","instance":6900,"id":243587,"goal":"predicate DisjointSets_6900(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_6901","instance":6901,"id":243588,"goal":"predicate Sorted_6901(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_6902","instance":6902,"id":243589,"goal":"predicate AllPositive_6902(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_6903","instance":6903,"id":243590,"goal":"predicate DistinctSeq_6903(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_6904","instance":6904,"id":243591,"goal":"predicate IsSubseq_6904(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_6905","instance":6905,"id":243592,"goal":"predicate IsPermutation_6905(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_6906","instance":6906,"id":243593,"goal":"predicate IsEven_6906(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_6907","instance":6907,"id":243594,"goal":"predicate InRange_6907(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_6908","instance":6908,"id":243595,"goal":"predicate SubsetOf_6908(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_6909","instance":6909,"id":243596,"goal":"predicate AllMem_6909(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_6910","instance":6910,"id":243597,"goal":"predicate DisjointSets_6910(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_6911","instance":6911,"id":243598,"goal":"predicate Sorted_6911(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_6912","instance":6912,"id":243599,"goal":"predicate AllPositive_6912(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_6913","instance":6913,"id":243600,"goal":"predicate DistinctSeq_6913(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_6914","instance":6914,"id":243601,"goal":"predicate IsSubseq_6914(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_6915","instance":6915,"id":243602,"goal":"predicate IsPermutation_6915(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_6916","instance":6916,"id":243603,"goal":"predicate IsEven_6916(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_6917","instance":6917,"id":243604,"goal":"predicate InRange_6917(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_6918","instance":6918,"id":243605,"goal":"predicate SubsetOf_6918(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_6919","instance":6919,"id":243606,"goal":"predicate AllMem_6919(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_6920","instance":6920,"id":243607,"goal":"predicate DisjointSets_6920(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_6921","instance":6921,"id":243608,"goal":"predicate Sorted_6921(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_6922","instance":6922,"id":243609,"goal":"predicate AllPositive_6922(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_6923","instance":6923,"id":243610,"goal":"predicate DistinctSeq_6923(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_6924","instance":6924,"id":243611,"goal":"predicate IsSubseq_6924(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_6925","instance":6925,"id":243612,"goal":"predicate IsPermutation_6925(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_6926","instance":6926,"id":243613,"goal":"predicate IsEven_6926(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_6927","instance":6927,"id":243614,"goal":"predicate InRange_6927(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_6928","instance":6928,"id":243615,"goal":"predicate SubsetOf_6928(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_6929","instance":6929,"id":243616,"goal":"predicate AllMem_6929(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_6930","instance":6930,"id":243617,"goal":"predicate DisjointSets_6930(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_6931","instance":6931,"id":243618,"goal":"predicate Sorted_6931(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_6932","instance":6932,"id":243619,"goal":"predicate AllPositive_6932(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_6933","instance":6933,"id":243620,"goal":"predicate DistinctSeq_6933(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_6934","instance":6934,"id":243621,"goal":"predicate IsSubseq_6934(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_6935","instance":6935,"id":243622,"goal":"predicate IsPermutation_6935(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_6936","instance":6936,"id":243623,"goal":"predicate IsEven_6936(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_6937","instance":6937,"id":243624,"goal":"predicate InRange_6937(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_6938","instance":6938,"id":243625,"goal":"predicate SubsetOf_6938(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_6939","instance":6939,"id":243626,"goal":"predicate AllMem_6939(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_6940","instance":6940,"id":243627,"goal":"predicate DisjointSets_6940(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_6941","instance":6941,"id":243628,"goal":"predicate Sorted_6941(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_6942","instance":6942,"id":243629,"goal":"predicate AllPositive_6942(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_6943","instance":6943,"id":243630,"goal":"predicate DistinctSeq_6943(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_6944","instance":6944,"id":243631,"goal":"predicate IsSubseq_6944(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_6945","instance":6945,"id":243632,"goal":"predicate IsPermutation_6945(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_6946","instance":6946,"id":243633,"goal":"predicate IsEven_6946(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_6947","instance":6947,"id":243634,"goal":"predicate InRange_6947(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_6948","instance":6948,"id":243635,"goal":"predicate SubsetOf_6948(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_6949","instance":6949,"id":243636,"goal":"predicate AllMem_6949(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_6950","instance":6950,"id":243637,"goal":"predicate DisjointSets_6950(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_6951","instance":6951,"id":243638,"goal":"predicate Sorted_6951(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_6952","instance":6952,"id":243639,"goal":"predicate AllPositive_6952(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_6953","instance":6953,"id":243640,"goal":"predicate DistinctSeq_6953(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_6954","instance":6954,"id":243641,"goal":"predicate IsSubseq_6954(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_6955","instance":6955,"id":243642,"goal":"predicate IsPermutation_6955(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_6956","instance":6956,"id":243643,"goal":"predicate IsEven_6956(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_6957","instance":6957,"id":243644,"goal":"predicate InRange_6957(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_6958","instance":6958,"id":243645,"goal":"predicate SubsetOf_6958(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_6959","instance":6959,"id":243646,"goal":"predicate AllMem_6959(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_6960","instance":6960,"id":243647,"goal":"predicate DisjointSets_6960(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_6961","instance":6961,"id":243648,"goal":"predicate Sorted_6961(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_6962","instance":6962,"id":243649,"goal":"predicate AllPositive_6962(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_6963","instance":6963,"id":243650,"goal":"predicate DistinctSeq_6963(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_6964","instance":6964,"id":243651,"goal":"predicate IsSubseq_6964(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_6965","instance":6965,"id":243652,"goal":"predicate IsPermutation_6965(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_6966","instance":6966,"id":243653,"goal":"predicate IsEven_6966(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_6967","instance":6967,"id":243654,"goal":"predicate InRange_6967(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_6968","instance":6968,"id":243655,"goal":"predicate SubsetOf_6968(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_6969","instance":6969,"id":243656,"goal":"predicate AllMem_6969(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_6970","instance":6970,"id":243657,"goal":"predicate DisjointSets_6970(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_6971","instance":6971,"id":243658,"goal":"predicate Sorted_6971(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_6972","instance":6972,"id":243659,"goal":"predicate AllPositive_6972(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_6973","instance":6973,"id":243660,"goal":"predicate DistinctSeq_6973(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_6974","instance":6974,"id":243661,"goal":"predicate IsSubseq_6974(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_6975","instance":6975,"id":243662,"goal":"predicate IsPermutation_6975(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_6976","instance":6976,"id":243663,"goal":"predicate IsEven_6976(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_6977","instance":6977,"id":243664,"goal":"predicate InRange_6977(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_6978","instance":6978,"id":243665,"goal":"predicate SubsetOf_6978(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_6979","instance":6979,"id":243666,"goal":"predicate AllMem_6979(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_6980","instance":6980,"id":243667,"goal":"predicate DisjointSets_6980(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_6981","instance":6981,"id":243668,"goal":"predicate Sorted_6981(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_6982","instance":6982,"id":243669,"goal":"predicate AllPositive_6982(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_6983","instance":6983,"id":243670,"goal":"predicate DistinctSeq_6983(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_6984","instance":6984,"id":243671,"goal":"predicate IsSubseq_6984(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_6985","instance":6985,"id":243672,"goal":"predicate IsPermutation_6985(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_6986","instance":6986,"id":243673,"goal":"predicate IsEven_6986(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_6987","instance":6987,"id":243674,"goal":"predicate InRange_6987(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_6988","instance":6988,"id":243675,"goal":"predicate SubsetOf_6988(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_6989","instance":6989,"id":243676,"goal":"predicate AllMem_6989(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_6990","instance":6990,"id":243677,"goal":"predicate DisjointSets_6990(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_6991","instance":6991,"id":243678,"goal":"predicate Sorted_6991(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_6992","instance":6992,"id":243679,"goal":"predicate AllPositive_6992(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_6993","instance":6993,"id":243680,"goal":"predicate DistinctSeq_6993(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_6994","instance":6994,"id":243681,"goal":"predicate IsSubseq_6994(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_6995","instance":6995,"id":243682,"goal":"predicate IsPermutation_6995(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_6996","instance":6996,"id":243683,"goal":"predicate IsEven_6996(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_6997","instance":6997,"id":243684,"goal":"predicate InRange_6997(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_6998","instance":6998,"id":243685,"goal":"predicate SubsetOf_6998(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_6999","instance":6999,"id":243686,"goal":"predicate AllMem_6999(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_7000","instance":7000,"id":243687,"goal":"predicate DisjointSets_7000(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_7001","instance":7001,"id":243688,"goal":"predicate Sorted_7001(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_7002","instance":7002,"id":243689,"goal":"predicate AllPositive_7002(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_7003","instance":7003,"id":243690,"goal":"predicate DistinctSeq_7003(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_7004","instance":7004,"id":243691,"goal":"predicate IsSubseq_7004(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_7005","instance":7005,"id":243692,"goal":"predicate IsPermutation_7005(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_7006","instance":7006,"id":243693,"goal":"predicate IsEven_7006(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_7007","instance":7007,"id":243694,"goal":"predicate InRange_7007(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_7008","instance":7008,"id":243695,"goal":"predicate SubsetOf_7008(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_7009","instance":7009,"id":243696,"goal":"predicate AllMem_7009(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_7010","instance":7010,"id":243697,"goal":"predicate DisjointSets_7010(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_7011","instance":7011,"id":243698,"goal":"predicate Sorted_7011(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_7012","instance":7012,"id":243699,"goal":"predicate AllPositive_7012(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_7013","instance":7013,"id":243700,"goal":"predicate DistinctSeq_7013(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_7014","instance":7014,"id":243701,"goal":"predicate IsSubseq_7014(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_7015","instance":7015,"id":243702,"goal":"predicate IsPermutation_7015(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_7016","instance":7016,"id":243703,"goal":"predicate IsEven_7016(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_7017","instance":7017,"id":243704,"goal":"predicate InRange_7017(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_7018","instance":7018,"id":243705,"goal":"predicate SubsetOf_7018(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_7019","instance":7019,"id":243706,"goal":"predicate AllMem_7019(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_7020","instance":7020,"id":243707,"goal":"predicate DisjointSets_7020(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_7021","instance":7021,"id":243708,"goal":"predicate Sorted_7021(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_7022","instance":7022,"id":243709,"goal":"predicate AllPositive_7022(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_7023","instance":7023,"id":243710,"goal":"predicate DistinctSeq_7023(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_7024","instance":7024,"id":243711,"goal":"predicate IsSubseq_7024(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_7025","instance":7025,"id":243712,"goal":"predicate IsPermutation_7025(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_7026","instance":7026,"id":243713,"goal":"predicate IsEven_7026(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_7027","instance":7027,"id":243714,"goal":"predicate InRange_7027(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_7028","instance":7028,"id":243715,"goal":"predicate SubsetOf_7028(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_7029","instance":7029,"id":243716,"goal":"predicate AllMem_7029(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_7030","instance":7030,"id":243717,"goal":"predicate DisjointSets_7030(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_7031","instance":7031,"id":243718,"goal":"predicate Sorted_7031(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_7032","instance":7032,"id":243719,"goal":"predicate AllPositive_7032(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_7033","instance":7033,"id":243720,"goal":"predicate DistinctSeq_7033(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_7034","instance":7034,"id":243721,"goal":"predicate IsSubseq_7034(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_7035","instance":7035,"id":243722,"goal":"predicate IsPermutation_7035(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_7036","instance":7036,"id":243723,"goal":"predicate IsEven_7036(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_7037","instance":7037,"id":243724,"goal":"predicate InRange_7037(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_7038","instance":7038,"id":243725,"goal":"predicate SubsetOf_7038(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_7039","instance":7039,"id":243726,"goal":"predicate AllMem_7039(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_7040","instance":7040,"id":243727,"goal":"predicate DisjointSets_7040(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_7041","instance":7041,"id":243728,"goal":"predicate Sorted_7041(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_7042","instance":7042,"id":243729,"goal":"predicate AllPositive_7042(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_7043","instance":7043,"id":243730,"goal":"predicate DistinctSeq_7043(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_7044","instance":7044,"id":243731,"goal":"predicate IsSubseq_7044(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_7045","instance":7045,"id":243732,"goal":"predicate IsPermutation_7045(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_7046","instance":7046,"id":243733,"goal":"predicate IsEven_7046(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_7047","instance":7047,"id":243734,"goal":"predicate InRange_7047(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_7048","instance":7048,"id":243735,"goal":"predicate SubsetOf_7048(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_7049","instance":7049,"id":243736,"goal":"predicate AllMem_7049(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_7050","instance":7050,"id":243737,"goal":"predicate DisjointSets_7050(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_7051","instance":7051,"id":243738,"goal":"predicate Sorted_7051(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_7052","instance":7052,"id":243739,"goal":"predicate AllPositive_7052(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_7053","instance":7053,"id":243740,"goal":"predicate DistinctSeq_7053(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_7054","instance":7054,"id":243741,"goal":"predicate IsSubseq_7054(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_7055","instance":7055,"id":243742,"goal":"predicate IsPermutation_7055(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_7056","instance":7056,"id":243743,"goal":"predicate IsEven_7056(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_7057","instance":7057,"id":243744,"goal":"predicate InRange_7057(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_7058","instance":7058,"id":243745,"goal":"predicate SubsetOf_7058(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_7059","instance":7059,"id":243746,"goal":"predicate AllMem_7059(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_7060","instance":7060,"id":243747,"goal":"predicate DisjointSets_7060(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_7061","instance":7061,"id":243748,"goal":"predicate Sorted_7061(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_7062","instance":7062,"id":243749,"goal":"predicate AllPositive_7062(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_7063","instance":7063,"id":243750,"goal":"predicate DistinctSeq_7063(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_7064","instance":7064,"id":243751,"goal":"predicate IsSubseq_7064(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_7065","instance":7065,"id":243752,"goal":"predicate IsPermutation_7065(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_7066","instance":7066,"id":243753,"goal":"predicate IsEven_7066(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_7067","instance":7067,"id":243754,"goal":"predicate InRange_7067(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_7068","instance":7068,"id":243755,"goal":"predicate SubsetOf_7068(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_7069","instance":7069,"id":243756,"goal":"predicate AllMem_7069(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_7070","instance":7070,"id":243757,"goal":"predicate DisjointSets_7070(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_7071","instance":7071,"id":243758,"goal":"predicate Sorted_7071(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_7072","instance":7072,"id":243759,"goal":"predicate AllPositive_7072(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_7073","instance":7073,"id":243760,"goal":"predicate DistinctSeq_7073(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_7074","instance":7074,"id":243761,"goal":"predicate IsSubseq_7074(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_7075","instance":7075,"id":243762,"goal":"predicate IsPermutation_7075(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_7076","instance":7076,"id":243763,"goal":"predicate IsEven_7076(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_7077","instance":7077,"id":243764,"goal":"predicate InRange_7077(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_7078","instance":7078,"id":243765,"goal":"predicate SubsetOf_7078(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_7079","instance":7079,"id":243766,"goal":"predicate AllMem_7079(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_7080","instance":7080,"id":243767,"goal":"predicate DisjointSets_7080(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_7081","instance":7081,"id":243768,"goal":"predicate Sorted_7081(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_7082","instance":7082,"id":243769,"goal":"predicate AllPositive_7082(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_7083","instance":7083,"id":243770,"goal":"predicate DistinctSeq_7083(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_7084","instance":7084,"id":243771,"goal":"predicate IsSubseq_7084(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_7085","instance":7085,"id":243772,"goal":"predicate IsPermutation_7085(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_7086","instance":7086,"id":243773,"goal":"predicate IsEven_7086(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_7087","instance":7087,"id":243774,"goal":"predicate InRange_7087(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_7088","instance":7088,"id":243775,"goal":"predicate SubsetOf_7088(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_7089","instance":7089,"id":243776,"goal":"predicate AllMem_7089(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_7090","instance":7090,"id":243777,"goal":"predicate DisjointSets_7090(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_7091","instance":7091,"id":243778,"goal":"predicate Sorted_7091(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_7092","instance":7092,"id":243779,"goal":"predicate AllPositive_7092(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_7093","instance":7093,"id":243780,"goal":"predicate DistinctSeq_7093(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_7094","instance":7094,"id":243781,"goal":"predicate IsSubseq_7094(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_7095","instance":7095,"id":243782,"goal":"predicate IsPermutation_7095(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_7096","instance":7096,"id":243783,"goal":"predicate IsEven_7096(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_7097","instance":7097,"id":243784,"goal":"predicate InRange_7097(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_7098","instance":7098,"id":243785,"goal":"predicate SubsetOf_7098(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_7099","instance":7099,"id":243786,"goal":"predicate AllMem_7099(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_7100","instance":7100,"id":243787,"goal":"predicate DisjointSets_7100(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_7101","instance":7101,"id":243788,"goal":"predicate Sorted_7101(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_7102","instance":7102,"id":243789,"goal":"predicate AllPositive_7102(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_7103","instance":7103,"id":243790,"goal":"predicate DistinctSeq_7103(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_7104","instance":7104,"id":243791,"goal":"predicate IsSubseq_7104(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_7105","instance":7105,"id":243792,"goal":"predicate IsPermutation_7105(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_7106","instance":7106,"id":243793,"goal":"predicate IsEven_7106(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_7107","instance":7107,"id":243794,"goal":"predicate InRange_7107(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_7108","instance":7108,"id":243795,"goal":"predicate SubsetOf_7108(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_7109","instance":7109,"id":243796,"goal":"predicate AllMem_7109(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_7110","instance":7110,"id":243797,"goal":"predicate DisjointSets_7110(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_7111","instance":7111,"id":243798,"goal":"predicate Sorted_7111(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_7112","instance":7112,"id":243799,"goal":"predicate AllPositive_7112(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_7113","instance":7113,"id":243800,"goal":"predicate DistinctSeq_7113(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_7114","instance":7114,"id":243801,"goal":"predicate IsSubseq_7114(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_7115","instance":7115,"id":243802,"goal":"predicate IsPermutation_7115(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_7116","instance":7116,"id":243803,"goal":"predicate IsEven_7116(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_7117","instance":7117,"id":243804,"goal":"predicate InRange_7117(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_7118","instance":7118,"id":243805,"goal":"predicate SubsetOf_7118(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_7119","instance":7119,"id":243806,"goal":"predicate AllMem_7119(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_7120","instance":7120,"id":243807,"goal":"predicate DisjointSets_7120(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_7121","instance":7121,"id":243808,"goal":"predicate Sorted_7121(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_7122","instance":7122,"id":243809,"goal":"predicate AllPositive_7122(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_7123","instance":7123,"id":243810,"goal":"predicate DistinctSeq_7123(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_7124","instance":7124,"id":243811,"goal":"predicate IsSubseq_7124(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_7125","instance":7125,"id":243812,"goal":"predicate IsPermutation_7125(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_7126","instance":7126,"id":243813,"goal":"predicate IsEven_7126(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_7127","instance":7127,"id":243814,"goal":"predicate InRange_7127(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_7128","instance":7128,"id":243815,"goal":"predicate SubsetOf_7128(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_7129","instance":7129,"id":243816,"goal":"predicate AllMem_7129(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_7130","instance":7130,"id":243817,"goal":"predicate DisjointSets_7130(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_7131","instance":7131,"id":243818,"goal":"predicate Sorted_7131(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_7132","instance":7132,"id":243819,"goal":"predicate AllPositive_7132(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_7133","instance":7133,"id":243820,"goal":"predicate DistinctSeq_7133(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_7134","instance":7134,"id":243821,"goal":"predicate IsSubseq_7134(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_7135","instance":7135,"id":243822,"goal":"predicate IsPermutation_7135(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_7136","instance":7136,"id":243823,"goal":"predicate IsEven_7136(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_7137","instance":7137,"id":243824,"goal":"predicate InRange_7137(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_7138","instance":7138,"id":243825,"goal":"predicate SubsetOf_7138(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_7139","instance":7139,"id":243826,"goal":"predicate AllMem_7139(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_7140","instance":7140,"id":243827,"goal":"predicate DisjointSets_7140(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_7141","instance":7141,"id":243828,"goal":"predicate Sorted_7141(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_7142","instance":7142,"id":243829,"goal":"predicate AllPositive_7142(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_7143","instance":7143,"id":243830,"goal":"predicate DistinctSeq_7143(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_7144","instance":7144,"id":243831,"goal":"predicate IsSubseq_7144(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_7145","instance":7145,"id":243832,"goal":"predicate IsPermutation_7145(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_7146","instance":7146,"id":243833,"goal":"predicate IsEven_7146(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_7147","instance":7147,"id":243834,"goal":"predicate InRange_7147(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_7148","instance":7148,"id":243835,"goal":"predicate SubsetOf_7148(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_7149","instance":7149,"id":243836,"goal":"predicate AllMem_7149(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_7150","instance":7150,"id":243837,"goal":"predicate DisjointSets_7150(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_7151","instance":7151,"id":243838,"goal":"predicate Sorted_7151(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_7152","instance":7152,"id":243839,"goal":"predicate AllPositive_7152(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_7153","instance":7153,"id":243840,"goal":"predicate DistinctSeq_7153(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_7154","instance":7154,"id":243841,"goal":"predicate IsSubseq_7154(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_7155","instance":7155,"id":243842,"goal":"predicate IsPermutation_7155(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_7156","instance":7156,"id":243843,"goal":"predicate IsEven_7156(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_7157","instance":7157,"id":243844,"goal":"predicate InRange_7157(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_7158","instance":7158,"id":243845,"goal":"predicate SubsetOf_7158(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_7159","instance":7159,"id":243846,"goal":"predicate AllMem_7159(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_7160","instance":7160,"id":243847,"goal":"predicate DisjointSets_7160(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_7161","instance":7161,"id":243848,"goal":"predicate Sorted_7161(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_7162","instance":7162,"id":243849,"goal":"predicate AllPositive_7162(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_7163","instance":7163,"id":243850,"goal":"predicate DistinctSeq_7163(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_7164","instance":7164,"id":243851,"goal":"predicate IsSubseq_7164(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_7165","instance":7165,"id":243852,"goal":"predicate IsPermutation_7165(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_7166","instance":7166,"id":243853,"goal":"predicate IsEven_7166(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_7167","instance":7167,"id":243854,"goal":"predicate InRange_7167(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_7168","instance":7168,"id":243855,"goal":"predicate SubsetOf_7168(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_7169","instance":7169,"id":243856,"goal":"predicate AllMem_7169(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_7170","instance":7170,"id":243857,"goal":"predicate DisjointSets_7170(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_7171","instance":7171,"id":243858,"goal":"predicate Sorted_7171(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_7172","instance":7172,"id":243859,"goal":"predicate AllPositive_7172(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_7173","instance":7173,"id":243860,"goal":"predicate DistinctSeq_7173(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_7174","instance":7174,"id":243861,"goal":"predicate IsSubseq_7174(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_7175","instance":7175,"id":243862,"goal":"predicate IsPermutation_7175(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_7176","instance":7176,"id":243863,"goal":"predicate IsEven_7176(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_7177","instance":7177,"id":243864,"goal":"predicate InRange_7177(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_7178","instance":7178,"id":243865,"goal":"predicate SubsetOf_7178(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_7179","instance":7179,"id":243866,"goal":"predicate AllMem_7179(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_7180","instance":7180,"id":243867,"goal":"predicate DisjointSets_7180(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_7181","instance":7181,"id":243868,"goal":"predicate Sorted_7181(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_7182","instance":7182,"id":243869,"goal":"predicate AllPositive_7182(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_7183","instance":7183,"id":243870,"goal":"predicate DistinctSeq_7183(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_7184","instance":7184,"id":243871,"goal":"predicate IsSubseq_7184(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_7185","instance":7185,"id":243872,"goal":"predicate IsPermutation_7185(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_7186","instance":7186,"id":243873,"goal":"predicate IsEven_7186(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_7187","instance":7187,"id":243874,"goal":"predicate InRange_7187(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_7188","instance":7188,"id":243875,"goal":"predicate SubsetOf_7188(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_7189","instance":7189,"id":243876,"goal":"predicate AllMem_7189(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_7190","instance":7190,"id":243877,"goal":"predicate DisjointSets_7190(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_7191","instance":7191,"id":243878,"goal":"predicate Sorted_7191(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_7192","instance":7192,"id":243879,"goal":"predicate AllPositive_7192(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_7193","instance":7193,"id":243880,"goal":"predicate DistinctSeq_7193(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_7194","instance":7194,"id":243881,"goal":"predicate IsSubseq_7194(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_7195","instance":7195,"id":243882,"goal":"predicate IsPermutation_7195(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_7196","instance":7196,"id":243883,"goal":"predicate IsEven_7196(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_7197","instance":7197,"id":243884,"goal":"predicate InRange_7197(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_7198","instance":7198,"id":243885,"goal":"predicate SubsetOf_7198(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_7199","instance":7199,"id":243886,"goal":"predicate AllMem_7199(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_7200","instance":7200,"id":243887,"goal":"predicate DisjointSets_7200(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_7201","instance":7201,"id":243888,"goal":"predicate Sorted_7201(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_7202","instance":7202,"id":243889,"goal":"predicate AllPositive_7202(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_7203","instance":7203,"id":243890,"goal":"predicate DistinctSeq_7203(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_7204","instance":7204,"id":243891,"goal":"predicate IsSubseq_7204(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_7205","instance":7205,"id":243892,"goal":"predicate IsPermutation_7205(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_7206","instance":7206,"id":243893,"goal":"predicate IsEven_7206(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_7207","instance":7207,"id":243894,"goal":"predicate InRange_7207(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_7208","instance":7208,"id":243895,"goal":"predicate SubsetOf_7208(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_7209","instance":7209,"id":243896,"goal":"predicate AllMem_7209(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_7210","instance":7210,"id":243897,"goal":"predicate DisjointSets_7210(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_7211","instance":7211,"id":243898,"goal":"predicate Sorted_7211(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_7212","instance":7212,"id":243899,"goal":"predicate AllPositive_7212(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_7213","instance":7213,"id":243900,"goal":"predicate DistinctSeq_7213(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_7214","instance":7214,"id":243901,"goal":"predicate IsSubseq_7214(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_7215","instance":7215,"id":243902,"goal":"predicate IsPermutation_7215(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_7216","instance":7216,"id":243903,"goal":"predicate IsEven_7216(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_7217","instance":7217,"id":243904,"goal":"predicate InRange_7217(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_7218","instance":7218,"id":243905,"goal":"predicate SubsetOf_7218(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_7219","instance":7219,"id":243906,"goal":"predicate AllMem_7219(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_7220","instance":7220,"id":243907,"goal":"predicate DisjointSets_7220(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_7221","instance":7221,"id":243908,"goal":"predicate Sorted_7221(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_7222","instance":7222,"id":243909,"goal":"predicate AllPositive_7222(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_7223","instance":7223,"id":243910,"goal":"predicate DistinctSeq_7223(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_7224","instance":7224,"id":243911,"goal":"predicate IsSubseq_7224(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_7225","instance":7225,"id":243912,"goal":"predicate IsPermutation_7225(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_7226","instance":7226,"id":243913,"goal":"predicate IsEven_7226(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_7227","instance":7227,"id":243914,"goal":"predicate InRange_7227(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_7228","instance":7228,"id":243915,"goal":"predicate SubsetOf_7228(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_7229","instance":7229,"id":243916,"goal":"predicate AllMem_7229(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_7230","instance":7230,"id":243917,"goal":"predicate DisjointSets_7230(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_7231","instance":7231,"id":243918,"goal":"predicate Sorted_7231(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_7232","instance":7232,"id":243919,"goal":"predicate AllPositive_7232(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_7233","instance":7233,"id":243920,"goal":"predicate DistinctSeq_7233(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_7234","instance":7234,"id":243921,"goal":"predicate IsSubseq_7234(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_7235","instance":7235,"id":243922,"goal":"predicate IsPermutation_7235(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_7236","instance":7236,"id":243923,"goal":"predicate IsEven_7236(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_7237","instance":7237,"id":243924,"goal":"predicate InRange_7237(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_7238","instance":7238,"id":243925,"goal":"predicate SubsetOf_7238(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_7239","instance":7239,"id":243926,"goal":"predicate AllMem_7239(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_7240","instance":7240,"id":243927,"goal":"predicate DisjointSets_7240(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_7241","instance":7241,"id":243928,"goal":"predicate Sorted_7241(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_7242","instance":7242,"id":243929,"goal":"predicate AllPositive_7242(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_7243","instance":7243,"id":243930,"goal":"predicate DistinctSeq_7243(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_7244","instance":7244,"id":243931,"goal":"predicate IsSubseq_7244(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_7245","instance":7245,"id":243932,"goal":"predicate IsPermutation_7245(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_7246","instance":7246,"id":243933,"goal":"predicate IsEven_7246(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_7247","instance":7247,"id":243934,"goal":"predicate InRange_7247(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_7248","instance":7248,"id":243935,"goal":"predicate SubsetOf_7248(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_7249","instance":7249,"id":243936,"goal":"predicate AllMem_7249(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_7250","instance":7250,"id":243937,"goal":"predicate DisjointSets_7250(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_7251","instance":7251,"id":243938,"goal":"predicate Sorted_7251(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_7252","instance":7252,"id":243939,"goal":"predicate AllPositive_7252(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_7253","instance":7253,"id":243940,"goal":"predicate DistinctSeq_7253(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_7254","instance":7254,"id":243941,"goal":"predicate IsSubseq_7254(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_7255","instance":7255,"id":243942,"goal":"predicate IsPermutation_7255(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_7256","instance":7256,"id":243943,"goal":"predicate IsEven_7256(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_7257","instance":7257,"id":243944,"goal":"predicate InRange_7257(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_7258","instance":7258,"id":243945,"goal":"predicate SubsetOf_7258(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_7259","instance":7259,"id":243946,"goal":"predicate AllMem_7259(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_7260","instance":7260,"id":243947,"goal":"predicate DisjointSets_7260(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_7261","instance":7261,"id":243948,"goal":"predicate Sorted_7261(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_7262","instance":7262,"id":243949,"goal":"predicate AllPositive_7262(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_7263","instance":7263,"id":243950,"goal":"predicate DistinctSeq_7263(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_7264","instance":7264,"id":243951,"goal":"predicate IsSubseq_7264(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_7265","instance":7265,"id":243952,"goal":"predicate IsPermutation_7265(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_7266","instance":7266,"id":243953,"goal":"predicate IsEven_7266(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_7267","instance":7267,"id":243954,"goal":"predicate InRange_7267(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_7268","instance":7268,"id":243955,"goal":"predicate SubsetOf_7268(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_7269","instance":7269,"id":243956,"goal":"predicate AllMem_7269(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_7270","instance":7270,"id":243957,"goal":"predicate DisjointSets_7270(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_7271","instance":7271,"id":243958,"goal":"predicate Sorted_7271(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_7272","instance":7272,"id":243959,"goal":"predicate AllPositive_7272(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_7273","instance":7273,"id":243960,"goal":"predicate DistinctSeq_7273(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_7274","instance":7274,"id":243961,"goal":"predicate IsSubseq_7274(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_7275","instance":7275,"id":243962,"goal":"predicate IsPermutation_7275(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_7276","instance":7276,"id":243963,"goal":"predicate IsEven_7276(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_7277","instance":7277,"id":243964,"goal":"predicate InRange_7277(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_7278","instance":7278,"id":243965,"goal":"predicate SubsetOf_7278(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_7279","instance":7279,"id":243966,"goal":"predicate AllMem_7279(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_7280","instance":7280,"id":243967,"goal":"predicate DisjointSets_7280(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_7281","instance":7281,"id":243968,"goal":"predicate Sorted_7281(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_7282","instance":7282,"id":243969,"goal":"predicate AllPositive_7282(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_7283","instance":7283,"id":243970,"goal":"predicate DistinctSeq_7283(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_7284","instance":7284,"id":243971,"goal":"predicate IsSubseq_7284(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_7285","instance":7285,"id":243972,"goal":"predicate IsPermutation_7285(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_7286","instance":7286,"id":243973,"goal":"predicate IsEven_7286(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_7287","instance":7287,"id":243974,"goal":"predicate InRange_7287(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_7288","instance":7288,"id":243975,"goal":"predicate SubsetOf_7288(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_7289","instance":7289,"id":243976,"goal":"predicate AllMem_7289(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_7290","instance":7290,"id":243977,"goal":"predicate DisjointSets_7290(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_7291","instance":7291,"id":243978,"goal":"predicate Sorted_7291(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_7292","instance":7292,"id":243979,"goal":"predicate AllPositive_7292(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_7293","instance":7293,"id":243980,"goal":"predicate DistinctSeq_7293(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_7294","instance":7294,"id":243981,"goal":"predicate IsSubseq_7294(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_7295","instance":7295,"id":243982,"goal":"predicate IsPermutation_7295(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_7296","instance":7296,"id":243983,"goal":"predicate IsEven_7296(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_7297","instance":7297,"id":243984,"goal":"predicate InRange_7297(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_7298","instance":7298,"id":243985,"goal":"predicate SubsetOf_7298(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_7299","instance":7299,"id":243986,"goal":"predicate AllMem_7299(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_7300","instance":7300,"id":243987,"goal":"predicate DisjointSets_7300(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_7301","instance":7301,"id":243988,"goal":"predicate Sorted_7301(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_7302","instance":7302,"id":243989,"goal":"predicate AllPositive_7302(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_7303","instance":7303,"id":243990,"goal":"predicate DistinctSeq_7303(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_7304","instance":7304,"id":243991,"goal":"predicate IsSubseq_7304(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_7305","instance":7305,"id":243992,"goal":"predicate IsPermutation_7305(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_7306","instance":7306,"id":243993,"goal":"predicate IsEven_7306(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_7307","instance":7307,"id":243994,"goal":"predicate InRange_7307(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_7308","instance":7308,"id":243995,"goal":"predicate SubsetOf_7308(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_7309","instance":7309,"id":243996,"goal":"predicate AllMem_7309(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_7310","instance":7310,"id":243997,"goal":"predicate DisjointSets_7310(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_7311","instance":7311,"id":243998,"goal":"predicate Sorted_7311(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_7312","instance":7312,"id":243999,"goal":"predicate AllPositive_7312(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_7313","instance":7313,"id":244000,"goal":"predicate DistinctSeq_7313(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_7314","instance":7314,"id":244001,"goal":"predicate IsSubseq_7314(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_7315","instance":7315,"id":244002,"goal":"predicate IsPermutation_7315(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_7316","instance":7316,"id":244003,"goal":"predicate IsEven_7316(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_7317","instance":7317,"id":244004,"goal":"predicate InRange_7317(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_7318","instance":7318,"id":244005,"goal":"predicate SubsetOf_7318(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_7319","instance":7319,"id":244006,"goal":"predicate AllMem_7319(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_7320","instance":7320,"id":244007,"goal":"predicate DisjointSets_7320(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_7321","instance":7321,"id":244008,"goal":"predicate Sorted_7321(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_7322","instance":7322,"id":244009,"goal":"predicate AllPositive_7322(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_7323","instance":7323,"id":244010,"goal":"predicate DistinctSeq_7323(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_7324","instance":7324,"id":244011,"goal":"predicate IsSubseq_7324(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_7325","instance":7325,"id":244012,"goal":"predicate IsPermutation_7325(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_7326","instance":7326,"id":244013,"goal":"predicate IsEven_7326(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_7327","instance":7327,"id":244014,"goal":"predicate InRange_7327(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_7328","instance":7328,"id":244015,"goal":"predicate SubsetOf_7328(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_7329","instance":7329,"id":244016,"goal":"predicate AllMem_7329(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_7330","instance":7330,"id":244017,"goal":"predicate DisjointSets_7330(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_7331","instance":7331,"id":244018,"goal":"predicate Sorted_7331(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_7332","instance":7332,"id":244019,"goal":"predicate AllPositive_7332(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_7333","instance":7333,"id":244020,"goal":"predicate DistinctSeq_7333(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_7334","instance":7334,"id":244021,"goal":"predicate IsSubseq_7334(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_7335","instance":7335,"id":244022,"goal":"predicate IsPermutation_7335(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_7336","instance":7336,"id":244023,"goal":"predicate IsEven_7336(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_7337","instance":7337,"id":244024,"goal":"predicate InRange_7337(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_7338","instance":7338,"id":244025,"goal":"predicate SubsetOf_7338(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_7339","instance":7339,"id":244026,"goal":"predicate AllMem_7339(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_7340","instance":7340,"id":244027,"goal":"predicate DisjointSets_7340(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_7341","instance":7341,"id":244028,"goal":"predicate Sorted_7341(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_7342","instance":7342,"id":244029,"goal":"predicate AllPositive_7342(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_7343","instance":7343,"id":244030,"goal":"predicate DistinctSeq_7343(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_7344","instance":7344,"id":244031,"goal":"predicate IsSubseq_7344(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_7345","instance":7345,"id":244032,"goal":"predicate IsPermutation_7345(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_7346","instance":7346,"id":244033,"goal":"predicate IsEven_7346(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_7347","instance":7347,"id":244034,"goal":"predicate InRange_7347(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_7348","instance":7348,"id":244035,"goal":"predicate SubsetOf_7348(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_7349","instance":7349,"id":244036,"goal":"predicate AllMem_7349(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_7350","instance":7350,"id":244037,"goal":"predicate DisjointSets_7350(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_7351","instance":7351,"id":244038,"goal":"predicate Sorted_7351(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_7352","instance":7352,"id":244039,"goal":"predicate AllPositive_7352(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_7353","instance":7353,"id":244040,"goal":"predicate DistinctSeq_7353(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_7354","instance":7354,"id":244041,"goal":"predicate IsSubseq_7354(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_7355","instance":7355,"id":244042,"goal":"predicate IsPermutation_7355(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_7356","instance":7356,"id":244043,"goal":"predicate IsEven_7356(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_7357","instance":7357,"id":244044,"goal":"predicate InRange_7357(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_7358","instance":7358,"id":244045,"goal":"predicate SubsetOf_7358(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_7359","instance":7359,"id":244046,"goal":"predicate AllMem_7359(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_7360","instance":7360,"id":244047,"goal":"predicate DisjointSets_7360(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_7361","instance":7361,"id":244048,"goal":"predicate Sorted_7361(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_7362","instance":7362,"id":244049,"goal":"predicate AllPositive_7362(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_7363","instance":7363,"id":244050,"goal":"predicate DistinctSeq_7363(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_7364","instance":7364,"id":244051,"goal":"predicate IsSubseq_7364(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_7365","instance":7365,"id":244052,"goal":"predicate IsPermutation_7365(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_7366","instance":7366,"id":244053,"goal":"predicate IsEven_7366(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_7367","instance":7367,"id":244054,"goal":"predicate InRange_7367(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_7368","instance":7368,"id":244055,"goal":"predicate SubsetOf_7368(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_7369","instance":7369,"id":244056,"goal":"predicate AllMem_7369(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_7370","instance":7370,"id":244057,"goal":"predicate DisjointSets_7370(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_7371","instance":7371,"id":244058,"goal":"predicate Sorted_7371(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_7372","instance":7372,"id":244059,"goal":"predicate AllPositive_7372(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_7373","instance":7373,"id":244060,"goal":"predicate DistinctSeq_7373(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_7374","instance":7374,"id":244061,"goal":"predicate IsSubseq_7374(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_7375","instance":7375,"id":244062,"goal":"predicate IsPermutation_7375(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_7376","instance":7376,"id":244063,"goal":"predicate IsEven_7376(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_7377","instance":7377,"id":244064,"goal":"predicate InRange_7377(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_7378","instance":7378,"id":244065,"goal":"predicate SubsetOf_7378(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_7379","instance":7379,"id":244066,"goal":"predicate AllMem_7379(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_7380","instance":7380,"id":244067,"goal":"predicate DisjointSets_7380(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_7381","instance":7381,"id":244068,"goal":"predicate Sorted_7381(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_7382","instance":7382,"id":244069,"goal":"predicate AllPositive_7382(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_7383","instance":7383,"id":244070,"goal":"predicate DistinctSeq_7383(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_7384","instance":7384,"id":244071,"goal":"predicate IsSubseq_7384(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_7385","instance":7385,"id":244072,"goal":"predicate IsPermutation_7385(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_7386","instance":7386,"id":244073,"goal":"predicate IsEven_7386(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_7387","instance":7387,"id":244074,"goal":"predicate InRange_7387(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_7388","instance":7388,"id":244075,"goal":"predicate SubsetOf_7388(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_7389","instance":7389,"id":244076,"goal":"predicate AllMem_7389(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_7390","instance":7390,"id":244077,"goal":"predicate DisjointSets_7390(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_7391","instance":7391,"id":244078,"goal":"predicate Sorted_7391(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_7392","instance":7392,"id":244079,"goal":"predicate AllPositive_7392(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_7393","instance":7393,"id":244080,"goal":"predicate DistinctSeq_7393(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_7394","instance":7394,"id":244081,"goal":"predicate IsSubseq_7394(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_7395","instance":7395,"id":244082,"goal":"predicate IsPermutation_7395(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_7396","instance":7396,"id":244083,"goal":"predicate IsEven_7396(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_7397","instance":7397,"id":244084,"goal":"predicate InRange_7397(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_7398","instance":7398,"id":244085,"goal":"predicate SubsetOf_7398(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_7399","instance":7399,"id":244086,"goal":"predicate AllMem_7399(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_7400","instance":7400,"id":244087,"goal":"predicate DisjointSets_7400(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_7401","instance":7401,"id":244088,"goal":"predicate Sorted_7401(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_7402","instance":7402,"id":244089,"goal":"predicate AllPositive_7402(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_7403","instance":7403,"id":244090,"goal":"predicate DistinctSeq_7403(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_7404","instance":7404,"id":244091,"goal":"predicate IsSubseq_7404(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_7405","instance":7405,"id":244092,"goal":"predicate IsPermutation_7405(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_7406","instance":7406,"id":244093,"goal":"predicate IsEven_7406(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_7407","instance":7407,"id":244094,"goal":"predicate InRange_7407(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_7408","instance":7408,"id":244095,"goal":"predicate SubsetOf_7408(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_7409","instance":7409,"id":244096,"goal":"predicate AllMem_7409(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_7410","instance":7410,"id":244097,"goal":"predicate DisjointSets_7410(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_7411","instance":7411,"id":244098,"goal":"predicate Sorted_7411(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_7412","instance":7412,"id":244099,"goal":"predicate AllPositive_7412(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_7413","instance":7413,"id":244100,"goal":"predicate DistinctSeq_7413(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_7414","instance":7414,"id":244101,"goal":"predicate IsSubseq_7414(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_7415","instance":7415,"id":244102,"goal":"predicate IsPermutation_7415(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_7416","instance":7416,"id":244103,"goal":"predicate IsEven_7416(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_7417","instance":7417,"id":244104,"goal":"predicate InRange_7417(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_7418","instance":7418,"id":244105,"goal":"predicate SubsetOf_7418(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_7419","instance":7419,"id":244106,"goal":"predicate AllMem_7419(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_7420","instance":7420,"id":244107,"goal":"predicate DisjointSets_7420(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_7421","instance":7421,"id":244108,"goal":"predicate Sorted_7421(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_7422","instance":7422,"id":244109,"goal":"predicate AllPositive_7422(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_7423","instance":7423,"id":244110,"goal":"predicate DistinctSeq_7423(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_7424","instance":7424,"id":244111,"goal":"predicate IsSubseq_7424(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_7425","instance":7425,"id":244112,"goal":"predicate IsPermutation_7425(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_7426","instance":7426,"id":244113,"goal":"predicate IsEven_7426(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_7427","instance":7427,"id":244114,"goal":"predicate InRange_7427(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_7428","instance":7428,"id":244115,"goal":"predicate SubsetOf_7428(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_7429","instance":7429,"id":244116,"goal":"predicate AllMem_7429(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_7430","instance":7430,"id":244117,"goal":"predicate DisjointSets_7430(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_7431","instance":7431,"id":244118,"goal":"predicate Sorted_7431(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_7432","instance":7432,"id":244119,"goal":"predicate AllPositive_7432(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_7433","instance":7433,"id":244120,"goal":"predicate DistinctSeq_7433(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_7434","instance":7434,"id":244121,"goal":"predicate IsSubseq_7434(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_7435","instance":7435,"id":244122,"goal":"predicate IsPermutation_7435(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_7436","instance":7436,"id":244123,"goal":"predicate IsEven_7436(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_7437","instance":7437,"id":244124,"goal":"predicate InRange_7437(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_7438","instance":7438,"id":244125,"goal":"predicate SubsetOf_7438(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_7439","instance":7439,"id":244126,"goal":"predicate AllMem_7439(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_7440","instance":7440,"id":244127,"goal":"predicate DisjointSets_7440(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_7441","instance":7441,"id":244128,"goal":"predicate Sorted_7441(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_7442","instance":7442,"id":244129,"goal":"predicate AllPositive_7442(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_7443","instance":7443,"id":244130,"goal":"predicate DistinctSeq_7443(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_7444","instance":7444,"id":244131,"goal":"predicate IsSubseq_7444(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_7445","instance":7445,"id":244132,"goal":"predicate IsPermutation_7445(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_7446","instance":7446,"id":244133,"goal":"predicate IsEven_7446(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_7447","instance":7447,"id":244134,"goal":"predicate InRange_7447(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_7448","instance":7448,"id":244135,"goal":"predicate SubsetOf_7448(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_7449","instance":7449,"id":244136,"goal":"predicate AllMem_7449(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_7450","instance":7450,"id":244137,"goal":"predicate DisjointSets_7450(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_7451","instance":7451,"id":244138,"goal":"predicate Sorted_7451(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_7452","instance":7452,"id":244139,"goal":"predicate AllPositive_7452(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_7453","instance":7453,"id":244140,"goal":"predicate DistinctSeq_7453(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_7454","instance":7454,"id":244141,"goal":"predicate IsSubseq_7454(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_7455","instance":7455,"id":244142,"goal":"predicate IsPermutation_7455(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_7456","instance":7456,"id":244143,"goal":"predicate IsEven_7456(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_7457","instance":7457,"id":244144,"goal":"predicate InRange_7457(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_7458","instance":7458,"id":244145,"goal":"predicate SubsetOf_7458(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_7459","instance":7459,"id":244146,"goal":"predicate AllMem_7459(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_7460","instance":7460,"id":244147,"goal":"predicate DisjointSets_7460(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_7461","instance":7461,"id":244148,"goal":"predicate Sorted_7461(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_7462","instance":7462,"id":244149,"goal":"predicate AllPositive_7462(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_7463","instance":7463,"id":244150,"goal":"predicate DistinctSeq_7463(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_7464","instance":7464,"id":244151,"goal":"predicate IsSubseq_7464(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_7465","instance":7465,"id":244152,"goal":"predicate IsPermutation_7465(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_7466","instance":7466,"id":244153,"goal":"predicate IsEven_7466(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_7467","instance":7467,"id":244154,"goal":"predicate InRange_7467(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_7468","instance":7468,"id":244155,"goal":"predicate SubsetOf_7468(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_7469","instance":7469,"id":244156,"goal":"predicate AllMem_7469(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_7470","instance":7470,"id":244157,"goal":"predicate DisjointSets_7470(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_7471","instance":7471,"id":244158,"goal":"predicate Sorted_7471(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_7472","instance":7472,"id":244159,"goal":"predicate AllPositive_7472(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_7473","instance":7473,"id":244160,"goal":"predicate DistinctSeq_7473(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_7474","instance":7474,"id":244161,"goal":"predicate IsSubseq_7474(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_7475","instance":7475,"id":244162,"goal":"predicate IsPermutation_7475(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_7476","instance":7476,"id":244163,"goal":"predicate IsEven_7476(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_7477","instance":7477,"id":244164,"goal":"predicate InRange_7477(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_7478","instance":7478,"id":244165,"goal":"predicate SubsetOf_7478(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_7479","instance":7479,"id":244166,"goal":"predicate AllMem_7479(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_7480","instance":7480,"id":244167,"goal":"predicate DisjointSets_7480(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_7481","instance":7481,"id":244168,"goal":"predicate Sorted_7481(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_7482","instance":7482,"id":244169,"goal":"predicate AllPositive_7482(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_7483","instance":7483,"id":244170,"goal":"predicate DistinctSeq_7483(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_7484","instance":7484,"id":244171,"goal":"predicate IsSubseq_7484(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_7485","instance":7485,"id":244172,"goal":"predicate IsPermutation_7485(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_7486","instance":7486,"id":244173,"goal":"predicate IsEven_7486(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_7487","instance":7487,"id":244174,"goal":"predicate InRange_7487(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_7488","instance":7488,"id":244175,"goal":"predicate SubsetOf_7488(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_7489","instance":7489,"id":244176,"goal":"predicate AllMem_7489(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_7490","instance":7490,"id":244177,"goal":"predicate DisjointSets_7490(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_7491","instance":7491,"id":244178,"goal":"predicate Sorted_7491(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_7492","instance":7492,"id":244179,"goal":"predicate AllPositive_7492(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_7493","instance":7493,"id":244180,"goal":"predicate DistinctSeq_7493(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_7494","instance":7494,"id":244181,"goal":"predicate IsSubseq_7494(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_7495","instance":7495,"id":244182,"goal":"predicate IsPermutation_7495(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_7496","instance":7496,"id":244183,"goal":"predicate IsEven_7496(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_7497","instance":7497,"id":244184,"goal":"predicate InRange_7497(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_7498","instance":7498,"id":244185,"goal":"predicate SubsetOf_7498(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_7499","instance":7499,"id":244186,"goal":"predicate AllMem_7499(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_7500","instance":7500,"id":244187,"goal":"predicate DisjointSets_7500(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_7501","instance":7501,"id":244188,"goal":"predicate Sorted_7501(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_7502","instance":7502,"id":244189,"goal":"predicate AllPositive_7502(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_7503","instance":7503,"id":244190,"goal":"predicate DistinctSeq_7503(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_7504","instance":7504,"id":244191,"goal":"predicate IsSubseq_7504(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_7505","instance":7505,"id":244192,"goal":"predicate IsPermutation_7505(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_7506","instance":7506,"id":244193,"goal":"predicate IsEven_7506(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_7507","instance":7507,"id":244194,"goal":"predicate InRange_7507(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_7508","instance":7508,"id":244195,"goal":"predicate SubsetOf_7508(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_7509","instance":7509,"id":244196,"goal":"predicate AllMem_7509(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_7510","instance":7510,"id":244197,"goal":"predicate DisjointSets_7510(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_7511","instance":7511,"id":244198,"goal":"predicate Sorted_7511(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_7512","instance":7512,"id":244199,"goal":"predicate AllPositive_7512(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_7513","instance":7513,"id":244200,"goal":"predicate DistinctSeq_7513(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_7514","instance":7514,"id":244201,"goal":"predicate IsSubseq_7514(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_7515","instance":7515,"id":244202,"goal":"predicate IsPermutation_7515(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_7516","instance":7516,"id":244203,"goal":"predicate IsEven_7516(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_7517","instance":7517,"id":244204,"goal":"predicate InRange_7517(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_7518","instance":7518,"id":244205,"goal":"predicate SubsetOf_7518(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_7519","instance":7519,"id":244206,"goal":"predicate AllMem_7519(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_7520","instance":7520,"id":244207,"goal":"predicate DisjointSets_7520(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_7521","instance":7521,"id":244208,"goal":"predicate Sorted_7521(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_7522","instance":7522,"id":244209,"goal":"predicate AllPositive_7522(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_7523","instance":7523,"id":244210,"goal":"predicate DistinctSeq_7523(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_7524","instance":7524,"id":244211,"goal":"predicate IsSubseq_7524(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_7525","instance":7525,"id":244212,"goal":"predicate IsPermutation_7525(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_7526","instance":7526,"id":244213,"goal":"predicate IsEven_7526(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_7527","instance":7527,"id":244214,"goal":"predicate InRange_7527(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_7528","instance":7528,"id":244215,"goal":"predicate SubsetOf_7528(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_7529","instance":7529,"id":244216,"goal":"predicate AllMem_7529(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_7530","instance":7530,"id":244217,"goal":"predicate DisjointSets_7530(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_7531","instance":7531,"id":244218,"goal":"predicate Sorted_7531(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_7532","instance":7532,"id":244219,"goal":"predicate AllPositive_7532(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_7533","instance":7533,"id":244220,"goal":"predicate DistinctSeq_7533(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_7534","instance":7534,"id":244221,"goal":"predicate IsSubseq_7534(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_7535","instance":7535,"id":244222,"goal":"predicate IsPermutation_7535(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_7536","instance":7536,"id":244223,"goal":"predicate IsEven_7536(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_7537","instance":7537,"id":244224,"goal":"predicate InRange_7537(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_7538","instance":7538,"id":244225,"goal":"predicate SubsetOf_7538(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_7539","instance":7539,"id":244226,"goal":"predicate AllMem_7539(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_7540","instance":7540,"id":244227,"goal":"predicate DisjointSets_7540(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_7541","instance":7541,"id":244228,"goal":"predicate Sorted_7541(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_7542","instance":7542,"id":244229,"goal":"predicate AllPositive_7542(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_7543","instance":7543,"id":244230,"goal":"predicate DistinctSeq_7543(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_7544","instance":7544,"id":244231,"goal":"predicate IsSubseq_7544(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_7545","instance":7545,"id":244232,"goal":"predicate IsPermutation_7545(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_7546","instance":7546,"id":244233,"goal":"predicate IsEven_7546(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_7547","instance":7547,"id":244234,"goal":"predicate InRange_7547(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_7548","instance":7548,"id":244235,"goal":"predicate SubsetOf_7548(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_7549","instance":7549,"id":244236,"goal":"predicate AllMem_7549(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_7550","instance":7550,"id":244237,"goal":"predicate DisjointSets_7550(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_7551","instance":7551,"id":244238,"goal":"predicate Sorted_7551(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_7552","instance":7552,"id":244239,"goal":"predicate AllPositive_7552(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_7553","instance":7553,"id":244240,"goal":"predicate DistinctSeq_7553(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_7554","instance":7554,"id":244241,"goal":"predicate IsSubseq_7554(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_7555","instance":7555,"id":244242,"goal":"predicate IsPermutation_7555(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_7556","instance":7556,"id":244243,"goal":"predicate IsEven_7556(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_7557","instance":7557,"id":244244,"goal":"predicate InRange_7557(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_7558","instance":7558,"id":244245,"goal":"predicate SubsetOf_7558(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_7559","instance":7559,"id":244246,"goal":"predicate AllMem_7559(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_7560","instance":7560,"id":244247,"goal":"predicate DisjointSets_7560(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_7561","instance":7561,"id":244248,"goal":"predicate Sorted_7561(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_7562","instance":7562,"id":244249,"goal":"predicate AllPositive_7562(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_7563","instance":7563,"id":244250,"goal":"predicate DistinctSeq_7563(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_7564","instance":7564,"id":244251,"goal":"predicate IsSubseq_7564(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_7565","instance":7565,"id":244252,"goal":"predicate IsPermutation_7565(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_7566","instance":7566,"id":244253,"goal":"predicate IsEven_7566(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_7567","instance":7567,"id":244254,"goal":"predicate InRange_7567(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_7568","instance":7568,"id":244255,"goal":"predicate SubsetOf_7568(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_7569","instance":7569,"id":244256,"goal":"predicate AllMem_7569(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_7570","instance":7570,"id":244257,"goal":"predicate DisjointSets_7570(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_7571","instance":7571,"id":244258,"goal":"predicate Sorted_7571(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_7572","instance":7572,"id":244259,"goal":"predicate AllPositive_7572(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_7573","instance":7573,"id":244260,"goal":"predicate DistinctSeq_7573(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_7574","instance":7574,"id":244261,"goal":"predicate IsSubseq_7574(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_7575","instance":7575,"id":244262,"goal":"predicate IsPermutation_7575(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_7576","instance":7576,"id":244263,"goal":"predicate IsEven_7576(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_7577","instance":7577,"id":244264,"goal":"predicate InRange_7577(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_7578","instance":7578,"id":244265,"goal":"predicate SubsetOf_7578(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_7579","instance":7579,"id":244266,"goal":"predicate AllMem_7579(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_7580","instance":7580,"id":244267,"goal":"predicate DisjointSets_7580(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_7581","instance":7581,"id":244268,"goal":"predicate Sorted_7581(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_7582","instance":7582,"id":244269,"goal":"predicate AllPositive_7582(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_7583","instance":7583,"id":244270,"goal":"predicate DistinctSeq_7583(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_7584","instance":7584,"id":244271,"goal":"predicate IsSubseq_7584(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_7585","instance":7585,"id":244272,"goal":"predicate IsPermutation_7585(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_7586","instance":7586,"id":244273,"goal":"predicate IsEven_7586(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_7587","instance":7587,"id":244274,"goal":"predicate InRange_7587(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_7588","instance":7588,"id":244275,"goal":"predicate SubsetOf_7588(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_7589","instance":7589,"id":244276,"goal":"predicate AllMem_7589(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_7590","instance":7590,"id":244277,"goal":"predicate DisjointSets_7590(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_7591","instance":7591,"id":244278,"goal":"predicate Sorted_7591(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_7592","instance":7592,"id":244279,"goal":"predicate AllPositive_7592(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_7593","instance":7593,"id":244280,"goal":"predicate DistinctSeq_7593(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_7594","instance":7594,"id":244281,"goal":"predicate IsSubseq_7594(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_7595","instance":7595,"id":244282,"goal":"predicate IsPermutation_7595(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_7596","instance":7596,"id":244283,"goal":"predicate IsEven_7596(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_7597","instance":7597,"id":244284,"goal":"predicate InRange_7597(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_7598","instance":7598,"id":244285,"goal":"predicate SubsetOf_7598(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_7599","instance":7599,"id":244286,"goal":"predicate AllMem_7599(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_7600","instance":7600,"id":244287,"goal":"predicate DisjointSets_7600(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_7601","instance":7601,"id":244288,"goal":"predicate Sorted_7601(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_7602","instance":7602,"id":244289,"goal":"predicate AllPositive_7602(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_7603","instance":7603,"id":244290,"goal":"predicate DistinctSeq_7603(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_7604","instance":7604,"id":244291,"goal":"predicate IsSubseq_7604(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_7605","instance":7605,"id":244292,"goal":"predicate IsPermutation_7605(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_7606","instance":7606,"id":244293,"goal":"predicate IsEven_7606(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_7607","instance":7607,"id":244294,"goal":"predicate InRange_7607(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_7608","instance":7608,"id":244295,"goal":"predicate SubsetOf_7608(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_7609","instance":7609,"id":244296,"goal":"predicate AllMem_7609(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_7610","instance":7610,"id":244297,"goal":"predicate DisjointSets_7610(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_7611","instance":7611,"id":244298,"goal":"predicate Sorted_7611(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_7612","instance":7612,"id":244299,"goal":"predicate AllPositive_7612(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_7613","instance":7613,"id":244300,"goal":"predicate DistinctSeq_7613(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_7614","instance":7614,"id":244301,"goal":"predicate IsSubseq_7614(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_7615","instance":7615,"id":244302,"goal":"predicate IsPermutation_7615(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_7616","instance":7616,"id":244303,"goal":"predicate IsEven_7616(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_7617","instance":7617,"id":244304,"goal":"predicate InRange_7617(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_7618","instance":7618,"id":244305,"goal":"predicate SubsetOf_7618(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_7619","instance":7619,"id":244306,"goal":"predicate AllMem_7619(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_7620","instance":7620,"id":244307,"goal":"predicate DisjointSets_7620(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_7621","instance":7621,"id":244308,"goal":"predicate Sorted_7621(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_7622","instance":7622,"id":244309,"goal":"predicate AllPositive_7622(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_7623","instance":7623,"id":244310,"goal":"predicate DistinctSeq_7623(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_7624","instance":7624,"id":244311,"goal":"predicate IsSubseq_7624(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_7625","instance":7625,"id":244312,"goal":"predicate IsPermutation_7625(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_7626","instance":7626,"id":244313,"goal":"predicate IsEven_7626(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_7627","instance":7627,"id":244314,"goal":"predicate InRange_7627(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_7628","instance":7628,"id":244315,"goal":"predicate SubsetOf_7628(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_7629","instance":7629,"id":244316,"goal":"predicate AllMem_7629(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_7630","instance":7630,"id":244317,"goal":"predicate DisjointSets_7630(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_7631","instance":7631,"id":244318,"goal":"predicate Sorted_7631(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_7632","instance":7632,"id":244319,"goal":"predicate AllPositive_7632(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_7633","instance":7633,"id":244320,"goal":"predicate DistinctSeq_7633(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_7634","instance":7634,"id":244321,"goal":"predicate IsSubseq_7634(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_7635","instance":7635,"id":244322,"goal":"predicate IsPermutation_7635(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_7636","instance":7636,"id":244323,"goal":"predicate IsEven_7636(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_7637","instance":7637,"id":244324,"goal":"predicate InRange_7637(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_7638","instance":7638,"id":244325,"goal":"predicate SubsetOf_7638(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_7639","instance":7639,"id":244326,"goal":"predicate AllMem_7639(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_7640","instance":7640,"id":244327,"goal":"predicate DisjointSets_7640(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_7641","instance":7641,"id":244328,"goal":"predicate Sorted_7641(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_7642","instance":7642,"id":244329,"goal":"predicate AllPositive_7642(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_7643","instance":7643,"id":244330,"goal":"predicate DistinctSeq_7643(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_7644","instance":7644,"id":244331,"goal":"predicate IsSubseq_7644(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_7645","instance":7645,"id":244332,"goal":"predicate IsPermutation_7645(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_7646","instance":7646,"id":244333,"goal":"predicate IsEven_7646(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_7647","instance":7647,"id":244334,"goal":"predicate InRange_7647(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_7648","instance":7648,"id":244335,"goal":"predicate SubsetOf_7648(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_7649","instance":7649,"id":244336,"goal":"predicate AllMem_7649(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_7650","instance":7650,"id":244337,"goal":"predicate DisjointSets_7650(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_7651","instance":7651,"id":244338,"goal":"predicate Sorted_7651(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_7652","instance":7652,"id":244339,"goal":"predicate AllPositive_7652(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_7653","instance":7653,"id":244340,"goal":"predicate DistinctSeq_7653(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_7654","instance":7654,"id":244341,"goal":"predicate IsSubseq_7654(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_7655","instance":7655,"id":244342,"goal":"predicate IsPermutation_7655(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_7656","instance":7656,"id":244343,"goal":"predicate IsEven_7656(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_7657","instance":7657,"id":244344,"goal":"predicate InRange_7657(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_7658","instance":7658,"id":244345,"goal":"predicate SubsetOf_7658(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_7659","instance":7659,"id":244346,"goal":"predicate AllMem_7659(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_7660","instance":7660,"id":244347,"goal":"predicate DisjointSets_7660(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_7661","instance":7661,"id":244348,"goal":"predicate Sorted_7661(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_7662","instance":7662,"id":244349,"goal":"predicate AllPositive_7662(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_7663","instance":7663,"id":244350,"goal":"predicate DistinctSeq_7663(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_7664","instance":7664,"id":244351,"goal":"predicate IsSubseq_7664(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_7665","instance":7665,"id":244352,"goal":"predicate IsPermutation_7665(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_7666","instance":7666,"id":244353,"goal":"predicate IsEven_7666(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_7667","instance":7667,"id":244354,"goal":"predicate InRange_7667(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_7668","instance":7668,"id":244355,"goal":"predicate SubsetOf_7668(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_7669","instance":7669,"id":244356,"goal":"predicate AllMem_7669(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_7670","instance":7670,"id":244357,"goal":"predicate DisjointSets_7670(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_7671","instance":7671,"id":244358,"goal":"predicate Sorted_7671(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_7672","instance":7672,"id":244359,"goal":"predicate AllPositive_7672(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_7673","instance":7673,"id":244360,"goal":"predicate DistinctSeq_7673(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_7674","instance":7674,"id":244361,"goal":"predicate IsSubseq_7674(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_7675","instance":7675,"id":244362,"goal":"predicate IsPermutation_7675(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_7676","instance":7676,"id":244363,"goal":"predicate IsEven_7676(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_7677","instance":7677,"id":244364,"goal":"predicate InRange_7677(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_7678","instance":7678,"id":244365,"goal":"predicate SubsetOf_7678(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_7679","instance":7679,"id":244366,"goal":"predicate AllMem_7679(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_7680","instance":7680,"id":244367,"goal":"predicate DisjointSets_7680(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_7681","instance":7681,"id":244368,"goal":"predicate Sorted_7681(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_7682","instance":7682,"id":244369,"goal":"predicate AllPositive_7682(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_7683","instance":7683,"id":244370,"goal":"predicate DistinctSeq_7683(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_7684","instance":7684,"id":244371,"goal":"predicate IsSubseq_7684(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_7685","instance":7685,"id":244372,"goal":"predicate IsPermutation_7685(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_7686","instance":7686,"id":244373,"goal":"predicate IsEven_7686(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_7687","instance":7687,"id":244374,"goal":"predicate InRange_7687(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_7688","instance":7688,"id":244375,"goal":"predicate SubsetOf_7688(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_7689","instance":7689,"id":244376,"goal":"predicate AllMem_7689(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_7690","instance":7690,"id":244377,"goal":"predicate DisjointSets_7690(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_7691","instance":7691,"id":244378,"goal":"predicate Sorted_7691(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_7692","instance":7692,"id":244379,"goal":"predicate AllPositive_7692(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_7693","instance":7693,"id":244380,"goal":"predicate DistinctSeq_7693(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_7694","instance":7694,"id":244381,"goal":"predicate IsSubseq_7694(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_7695","instance":7695,"id":244382,"goal":"predicate IsPermutation_7695(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_7696","instance":7696,"id":244383,"goal":"predicate IsEven_7696(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_7697","instance":7697,"id":244384,"goal":"predicate InRange_7697(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_7698","instance":7698,"id":244385,"goal":"predicate SubsetOf_7698(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_7699","instance":7699,"id":244386,"goal":"predicate AllMem_7699(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_7700","instance":7700,"id":244387,"goal":"predicate DisjointSets_7700(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_7701","instance":7701,"id":244388,"goal":"predicate Sorted_7701(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_7702","instance":7702,"id":244389,"goal":"predicate AllPositive_7702(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_7703","instance":7703,"id":244390,"goal":"predicate DistinctSeq_7703(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_7704","instance":7704,"id":244391,"goal":"predicate IsSubseq_7704(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_7705","instance":7705,"id":244392,"goal":"predicate IsPermutation_7705(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_7706","instance":7706,"id":244393,"goal":"predicate IsEven_7706(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_7707","instance":7707,"id":244394,"goal":"predicate InRange_7707(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_7708","instance":7708,"id":244395,"goal":"predicate SubsetOf_7708(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_7709","instance":7709,"id":244396,"goal":"predicate AllMem_7709(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_7710","instance":7710,"id":244397,"goal":"predicate DisjointSets_7710(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_7711","instance":7711,"id":244398,"goal":"predicate Sorted_7711(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_7712","instance":7712,"id":244399,"goal":"predicate AllPositive_7712(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_7713","instance":7713,"id":244400,"goal":"predicate DistinctSeq_7713(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_7714","instance":7714,"id":244401,"goal":"predicate IsSubseq_7714(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_7715","instance":7715,"id":244402,"goal":"predicate IsPermutation_7715(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_7716","instance":7716,"id":244403,"goal":"predicate IsEven_7716(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_7717","instance":7717,"id":244404,"goal":"predicate InRange_7717(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_7718","instance":7718,"id":244405,"goal":"predicate SubsetOf_7718(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_7719","instance":7719,"id":244406,"goal":"predicate AllMem_7719(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_7720","instance":7720,"id":244407,"goal":"predicate DisjointSets_7720(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_7721","instance":7721,"id":244408,"goal":"predicate Sorted_7721(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_7722","instance":7722,"id":244409,"goal":"predicate AllPositive_7722(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_7723","instance":7723,"id":244410,"goal":"predicate DistinctSeq_7723(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_7724","instance":7724,"id":244411,"goal":"predicate IsSubseq_7724(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_7725","instance":7725,"id":244412,"goal":"predicate IsPermutation_7725(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_7726","instance":7726,"id":244413,"goal":"predicate IsEven_7726(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_7727","instance":7727,"id":244414,"goal":"predicate InRange_7727(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_7728","instance":7728,"id":244415,"goal":"predicate SubsetOf_7728(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_7729","instance":7729,"id":244416,"goal":"predicate AllMem_7729(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_7730","instance":7730,"id":244417,"goal":"predicate DisjointSets_7730(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_7731","instance":7731,"id":244418,"goal":"predicate Sorted_7731(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_7732","instance":7732,"id":244419,"goal":"predicate AllPositive_7732(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_7733","instance":7733,"id":244420,"goal":"predicate DistinctSeq_7733(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_7734","instance":7734,"id":244421,"goal":"predicate IsSubseq_7734(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_7735","instance":7735,"id":244422,"goal":"predicate IsPermutation_7735(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_7736","instance":7736,"id":244423,"goal":"predicate IsEven_7736(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_7737","instance":7737,"id":244424,"goal":"predicate InRange_7737(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_7738","instance":7738,"id":244425,"goal":"predicate SubsetOf_7738(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_7739","instance":7739,"id":244426,"goal":"predicate AllMem_7739(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_7740","instance":7740,"id":244427,"goal":"predicate DisjointSets_7740(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_7741","instance":7741,"id":244428,"goal":"predicate Sorted_7741(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_7742","instance":7742,"id":244429,"goal":"predicate AllPositive_7742(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_7743","instance":7743,"id":244430,"goal":"predicate DistinctSeq_7743(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_7744","instance":7744,"id":244431,"goal":"predicate IsSubseq_7744(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_7745","instance":7745,"id":244432,"goal":"predicate IsPermutation_7745(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_7746","instance":7746,"id":244433,"goal":"predicate IsEven_7746(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_7747","instance":7747,"id":244434,"goal":"predicate InRange_7747(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_7748","instance":7748,"id":244435,"goal":"predicate SubsetOf_7748(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_7749","instance":7749,"id":244436,"goal":"predicate AllMem_7749(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_7750","instance":7750,"id":244437,"goal":"predicate DisjointSets_7750(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_7751","instance":7751,"id":244438,"goal":"predicate Sorted_7751(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_7752","instance":7752,"id":244439,"goal":"predicate AllPositive_7752(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_7753","instance":7753,"id":244440,"goal":"predicate DistinctSeq_7753(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_7754","instance":7754,"id":244441,"goal":"predicate IsSubseq_7754(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_7755","instance":7755,"id":244442,"goal":"predicate IsPermutation_7755(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_7756","instance":7756,"id":244443,"goal":"predicate IsEven_7756(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_7757","instance":7757,"id":244444,"goal":"predicate InRange_7757(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_7758","instance":7758,"id":244445,"goal":"predicate SubsetOf_7758(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_7759","instance":7759,"id":244446,"goal":"predicate AllMem_7759(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_7760","instance":7760,"id":244447,"goal":"predicate DisjointSets_7760(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_7761","instance":7761,"id":244448,"goal":"predicate Sorted_7761(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_7762","instance":7762,"id":244449,"goal":"predicate AllPositive_7762(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_7763","instance":7763,"id":244450,"goal":"predicate DistinctSeq_7763(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_7764","instance":7764,"id":244451,"goal":"predicate IsSubseq_7764(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_7765","instance":7765,"id":244452,"goal":"predicate IsPermutation_7765(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_7766","instance":7766,"id":244453,"goal":"predicate IsEven_7766(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_7767","instance":7767,"id":244454,"goal":"predicate InRange_7767(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_7768","instance":7768,"id":244455,"goal":"predicate SubsetOf_7768(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_7769","instance":7769,"id":244456,"goal":"predicate AllMem_7769(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_7770","instance":7770,"id":244457,"goal":"predicate DisjointSets_7770(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_7771","instance":7771,"id":244458,"goal":"predicate Sorted_7771(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_7772","instance":7772,"id":244459,"goal":"predicate AllPositive_7772(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_7773","instance":7773,"id":244460,"goal":"predicate DistinctSeq_7773(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_7774","instance":7774,"id":244461,"goal":"predicate IsSubseq_7774(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_7775","instance":7775,"id":244462,"goal":"predicate IsPermutation_7775(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_7776","instance":7776,"id":244463,"goal":"predicate IsEven_7776(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_7777","instance":7777,"id":244464,"goal":"predicate InRange_7777(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_7778","instance":7778,"id":244465,"goal":"predicate SubsetOf_7778(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_7779","instance":7779,"id":244466,"goal":"predicate AllMem_7779(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_7780","instance":7780,"id":244467,"goal":"predicate DisjointSets_7780(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_7781","instance":7781,"id":244468,"goal":"predicate Sorted_7781(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_7782","instance":7782,"id":244469,"goal":"predicate AllPositive_7782(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_7783","instance":7783,"id":244470,"goal":"predicate DistinctSeq_7783(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_7784","instance":7784,"id":244471,"goal":"predicate IsSubseq_7784(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_7785","instance":7785,"id":244472,"goal":"predicate IsPermutation_7785(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_7786","instance":7786,"id":244473,"goal":"predicate IsEven_7786(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_7787","instance":7787,"id":244474,"goal":"predicate InRange_7787(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_7788","instance":7788,"id":244475,"goal":"predicate SubsetOf_7788(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_7789","instance":7789,"id":244476,"goal":"predicate AllMem_7789(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_7790","instance":7790,"id":244477,"goal":"predicate DisjointSets_7790(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_7791","instance":7791,"id":244478,"goal":"predicate Sorted_7791(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_7792","instance":7792,"id":244479,"goal":"predicate AllPositive_7792(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_7793","instance":7793,"id":244480,"goal":"predicate DistinctSeq_7793(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_7794","instance":7794,"id":244481,"goal":"predicate IsSubseq_7794(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_7795","instance":7795,"id":244482,"goal":"predicate IsPermutation_7795(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_7796","instance":7796,"id":244483,"goal":"predicate IsEven_7796(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_7797","instance":7797,"id":244484,"goal":"predicate InRange_7797(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_7798","instance":7798,"id":244485,"goal":"predicate SubsetOf_7798(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_7799","instance":7799,"id":244486,"goal":"predicate AllMem_7799(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_7800","instance":7800,"id":244487,"goal":"predicate DisjointSets_7800(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_7801","instance":7801,"id":244488,"goal":"predicate Sorted_7801(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_7802","instance":7802,"id":244489,"goal":"predicate AllPositive_7802(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_7803","instance":7803,"id":244490,"goal":"predicate DistinctSeq_7803(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_7804","instance":7804,"id":244491,"goal":"predicate IsSubseq_7804(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_7805","instance":7805,"id":244492,"goal":"predicate IsPermutation_7805(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_7806","instance":7806,"id":244493,"goal":"predicate IsEven_7806(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_7807","instance":7807,"id":244494,"goal":"predicate InRange_7807(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_7808","instance":7808,"id":244495,"goal":"predicate SubsetOf_7808(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_7809","instance":7809,"id":244496,"goal":"predicate AllMem_7809(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_7810","instance":7810,"id":244497,"goal":"predicate DisjointSets_7810(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_7811","instance":7811,"id":244498,"goal":"predicate Sorted_7811(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_7812","instance":7812,"id":244499,"goal":"predicate AllPositive_7812(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_7813","instance":7813,"id":244500,"goal":"predicate DistinctSeq_7813(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_7814","instance":7814,"id":244501,"goal":"predicate IsSubseq_7814(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_7815","instance":7815,"id":244502,"goal":"predicate IsPermutation_7815(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_7816","instance":7816,"id":244503,"goal":"predicate IsEven_7816(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_7817","instance":7817,"id":244504,"goal":"predicate InRange_7817(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_7818","instance":7818,"id":244505,"goal":"predicate SubsetOf_7818(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_7819","instance":7819,"id":244506,"goal":"predicate AllMem_7819(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_7820","instance":7820,"id":244507,"goal":"predicate DisjointSets_7820(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_7821","instance":7821,"id":244508,"goal":"predicate Sorted_7821(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_7822","instance":7822,"id":244509,"goal":"predicate AllPositive_7822(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_7823","instance":7823,"id":244510,"goal":"predicate DistinctSeq_7823(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_7824","instance":7824,"id":244511,"goal":"predicate IsSubseq_7824(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_7825","instance":7825,"id":244512,"goal":"predicate IsPermutation_7825(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_7826","instance":7826,"id":244513,"goal":"predicate IsEven_7826(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_7827","instance":7827,"id":244514,"goal":"predicate InRange_7827(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_7828","instance":7828,"id":244515,"goal":"predicate SubsetOf_7828(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_7829","instance":7829,"id":244516,"goal":"predicate AllMem_7829(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_7830","instance":7830,"id":244517,"goal":"predicate DisjointSets_7830(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_7831","instance":7831,"id":244518,"goal":"predicate Sorted_7831(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_7832","instance":7832,"id":244519,"goal":"predicate AllPositive_7832(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_7833","instance":7833,"id":244520,"goal":"predicate DistinctSeq_7833(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_7834","instance":7834,"id":244521,"goal":"predicate IsSubseq_7834(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_7835","instance":7835,"id":244522,"goal":"predicate IsPermutation_7835(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_7836","instance":7836,"id":244523,"goal":"predicate IsEven_7836(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_7837","instance":7837,"id":244524,"goal":"predicate InRange_7837(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_7838","instance":7838,"id":244525,"goal":"predicate SubsetOf_7838(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_7839","instance":7839,"id":244526,"goal":"predicate AllMem_7839(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_7840","instance":7840,"id":244527,"goal":"predicate DisjointSets_7840(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_7841","instance":7841,"id":244528,"goal":"predicate Sorted_7841(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_7842","instance":7842,"id":244529,"goal":"predicate AllPositive_7842(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_7843","instance":7843,"id":244530,"goal":"predicate DistinctSeq_7843(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_7844","instance":7844,"id":244531,"goal":"predicate IsSubseq_7844(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_7845","instance":7845,"id":244532,"goal":"predicate IsPermutation_7845(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_7846","instance":7846,"id":244533,"goal":"predicate IsEven_7846(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_7847","instance":7847,"id":244534,"goal":"predicate InRange_7847(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_7848","instance":7848,"id":244535,"goal":"predicate SubsetOf_7848(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_7849","instance":7849,"id":244536,"goal":"predicate AllMem_7849(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_7850","instance":7850,"id":244537,"goal":"predicate DisjointSets_7850(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_7851","instance":7851,"id":244538,"goal":"predicate Sorted_7851(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_7852","instance":7852,"id":244539,"goal":"predicate AllPositive_7852(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_7853","instance":7853,"id":244540,"goal":"predicate DistinctSeq_7853(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_7854","instance":7854,"id":244541,"goal":"predicate IsSubseq_7854(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_7855","instance":7855,"id":244542,"goal":"predicate IsPermutation_7855(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_7856","instance":7856,"id":244543,"goal":"predicate IsEven_7856(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_7857","instance":7857,"id":244544,"goal":"predicate InRange_7857(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_7858","instance":7858,"id":244545,"goal":"predicate SubsetOf_7858(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_7859","instance":7859,"id":244546,"goal":"predicate AllMem_7859(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_7860","instance":7860,"id":244547,"goal":"predicate DisjointSets_7860(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_7861","instance":7861,"id":244548,"goal":"predicate Sorted_7861(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_7862","instance":7862,"id":244549,"goal":"predicate AllPositive_7862(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_7863","instance":7863,"id":244550,"goal":"predicate DistinctSeq_7863(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_7864","instance":7864,"id":244551,"goal":"predicate IsSubseq_7864(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_7865","instance":7865,"id":244552,"goal":"predicate IsPermutation_7865(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_7866","instance":7866,"id":244553,"goal":"predicate IsEven_7866(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_7867","instance":7867,"id":244554,"goal":"predicate InRange_7867(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_7868","instance":7868,"id":244555,"goal":"predicate SubsetOf_7868(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_7869","instance":7869,"id":244556,"goal":"predicate AllMem_7869(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_7870","instance":7870,"id":244557,"goal":"predicate DisjointSets_7870(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_7871","instance":7871,"id":244558,"goal":"predicate Sorted_7871(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_7872","instance":7872,"id":244559,"goal":"predicate AllPositive_7872(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_7873","instance":7873,"id":244560,"goal":"predicate DistinctSeq_7873(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_7874","instance":7874,"id":244561,"goal":"predicate IsSubseq_7874(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_7875","instance":7875,"id":244562,"goal":"predicate IsPermutation_7875(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_7876","instance":7876,"id":244563,"goal":"predicate IsEven_7876(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_7877","instance":7877,"id":244564,"goal":"predicate InRange_7877(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_7878","instance":7878,"id":244565,"goal":"predicate SubsetOf_7878(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_7879","instance":7879,"id":244566,"goal":"predicate AllMem_7879(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_7880","instance":7880,"id":244567,"goal":"predicate DisjointSets_7880(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_7881","instance":7881,"id":244568,"goal":"predicate Sorted_7881(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_7882","instance":7882,"id":244569,"goal":"predicate AllPositive_7882(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_7883","instance":7883,"id":244570,"goal":"predicate DistinctSeq_7883(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_7884","instance":7884,"id":244571,"goal":"predicate IsSubseq_7884(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_7885","instance":7885,"id":244572,"goal":"predicate IsPermutation_7885(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_7886","instance":7886,"id":244573,"goal":"predicate IsEven_7886(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_7887","instance":7887,"id":244574,"goal":"predicate InRange_7887(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_7888","instance":7888,"id":244575,"goal":"predicate SubsetOf_7888(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_7889","instance":7889,"id":244576,"goal":"predicate AllMem_7889(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_7890","instance":7890,"id":244577,"goal":"predicate DisjointSets_7890(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_7891","instance":7891,"id":244578,"goal":"predicate Sorted_7891(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_7892","instance":7892,"id":244579,"goal":"predicate AllPositive_7892(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_7893","instance":7893,"id":244580,"goal":"predicate DistinctSeq_7893(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_7894","instance":7894,"id":244581,"goal":"predicate IsSubseq_7894(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_7895","instance":7895,"id":244582,"goal":"predicate IsPermutation_7895(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_7896","instance":7896,"id":244583,"goal":"predicate IsEven_7896(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_7897","instance":7897,"id":244584,"goal":"predicate InRange_7897(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_7898","instance":7898,"id":244585,"goal":"predicate SubsetOf_7898(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_7899","instance":7899,"id":244586,"goal":"predicate AllMem_7899(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_7900","instance":7900,"id":244587,"goal":"predicate DisjointSets_7900(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_7901","instance":7901,"id":244588,"goal":"predicate Sorted_7901(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_7902","instance":7902,"id":244589,"goal":"predicate AllPositive_7902(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_7903","instance":7903,"id":244590,"goal":"predicate DistinctSeq_7903(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_7904","instance":7904,"id":244591,"goal":"predicate IsSubseq_7904(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_7905","instance":7905,"id":244592,"goal":"predicate IsPermutation_7905(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_7906","instance":7906,"id":244593,"goal":"predicate IsEven_7906(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_7907","instance":7907,"id":244594,"goal":"predicate InRange_7907(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_7908","instance":7908,"id":244595,"goal":"predicate SubsetOf_7908(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_7909","instance":7909,"id":244596,"goal":"predicate AllMem_7909(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_7910","instance":7910,"id":244597,"goal":"predicate DisjointSets_7910(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_7911","instance":7911,"id":244598,"goal":"predicate Sorted_7911(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_7912","instance":7912,"id":244599,"goal":"predicate AllPositive_7912(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_7913","instance":7913,"id":244600,"goal":"predicate DistinctSeq_7913(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_7914","instance":7914,"id":244601,"goal":"predicate IsSubseq_7914(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_7915","instance":7915,"id":244602,"goal":"predicate IsPermutation_7915(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_7916","instance":7916,"id":244603,"goal":"predicate IsEven_7916(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_7917","instance":7917,"id":244604,"goal":"predicate InRange_7917(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_7918","instance":7918,"id":244605,"goal":"predicate SubsetOf_7918(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_7919","instance":7919,"id":244606,"goal":"predicate AllMem_7919(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_7920","instance":7920,"id":244607,"goal":"predicate DisjointSets_7920(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_7921","instance":7921,"id":244608,"goal":"predicate Sorted_7921(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_7922","instance":7922,"id":244609,"goal":"predicate AllPositive_7922(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_7923","instance":7923,"id":244610,"goal":"predicate DistinctSeq_7923(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_7924","instance":7924,"id":244611,"goal":"predicate IsSubseq_7924(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_7925","instance":7925,"id":244612,"goal":"predicate IsPermutation_7925(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_7926","instance":7926,"id":244613,"goal":"predicate IsEven_7926(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_7927","instance":7927,"id":244614,"goal":"predicate InRange_7927(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_7928","instance":7928,"id":244615,"goal":"predicate SubsetOf_7928(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_7929","instance":7929,"id":244616,"goal":"predicate AllMem_7929(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_7930","instance":7930,"id":244617,"goal":"predicate DisjointSets_7930(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_7931","instance":7931,"id":244618,"goal":"predicate Sorted_7931(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_7932","instance":7932,"id":244619,"goal":"predicate AllPositive_7932(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_7933","instance":7933,"id":244620,"goal":"predicate DistinctSeq_7933(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_7934","instance":7934,"id":244621,"goal":"predicate IsSubseq_7934(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_7935","instance":7935,"id":244622,"goal":"predicate IsPermutation_7935(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_7936","instance":7936,"id":244623,"goal":"predicate IsEven_7936(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_7937","instance":7937,"id":244624,"goal":"predicate InRange_7937(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_7938","instance":7938,"id":244625,"goal":"predicate SubsetOf_7938(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_7939","instance":7939,"id":244626,"goal":"predicate AllMem_7939(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_7940","instance":7940,"id":244627,"goal":"predicate DisjointSets_7940(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_7941","instance":7941,"id":244628,"goal":"predicate Sorted_7941(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_7942","instance":7942,"id":244629,"goal":"predicate AllPositive_7942(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_7943","instance":7943,"id":244630,"goal":"predicate DistinctSeq_7943(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_7944","instance":7944,"id":244631,"goal":"predicate IsSubseq_7944(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_7945","instance":7945,"id":244632,"goal":"predicate IsPermutation_7945(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_7946","instance":7946,"id":244633,"goal":"predicate IsEven_7946(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_7947","instance":7947,"id":244634,"goal":"predicate InRange_7947(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_7948","instance":7948,"id":244635,"goal":"predicate SubsetOf_7948(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_7949","instance":7949,"id":244636,"goal":"predicate AllMem_7949(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_7950","instance":7950,"id":244637,"goal":"predicate DisjointSets_7950(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_7951","instance":7951,"id":244638,"goal":"predicate Sorted_7951(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_7952","instance":7952,"id":244639,"goal":"predicate AllPositive_7952(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_7953","instance":7953,"id":244640,"goal":"predicate DistinctSeq_7953(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_7954","instance":7954,"id":244641,"goal":"predicate IsSubseq_7954(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_7955","instance":7955,"id":244642,"goal":"predicate IsPermutation_7955(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_7956","instance":7956,"id":244643,"goal":"predicate IsEven_7956(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_7957","instance":7957,"id":244644,"goal":"predicate InRange_7957(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_7958","instance":7958,"id":244645,"goal":"predicate SubsetOf_7958(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_7959","instance":7959,"id":244646,"goal":"predicate AllMem_7959(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_7960","instance":7960,"id":244647,"goal":"predicate DisjointSets_7960(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_7961","instance":7961,"id":244648,"goal":"predicate Sorted_7961(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_7962","instance":7962,"id":244649,"goal":"predicate AllPositive_7962(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_7963","instance":7963,"id":244650,"goal":"predicate DistinctSeq_7963(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_7964","instance":7964,"id":244651,"goal":"predicate IsSubseq_7964(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_7965","instance":7965,"id":244652,"goal":"predicate IsPermutation_7965(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_7966","instance":7966,"id":244653,"goal":"predicate IsEven_7966(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_7967","instance":7967,"id":244654,"goal":"predicate InRange_7967(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_7968","instance":7968,"id":244655,"goal":"predicate SubsetOf_7968(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_7969","instance":7969,"id":244656,"goal":"predicate AllMem_7969(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_7970","instance":7970,"id":244657,"goal":"predicate DisjointSets_7970(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_7971","instance":7971,"id":244658,"goal":"predicate Sorted_7971(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_7972","instance":7972,"id":244659,"goal":"predicate AllPositive_7972(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_7973","instance":7973,"id":244660,"goal":"predicate DistinctSeq_7973(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_7974","instance":7974,"id":244661,"goal":"predicate IsSubseq_7974(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_7975","instance":7975,"id":244662,"goal":"predicate IsPermutation_7975(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_7976","instance":7976,"id":244663,"goal":"predicate IsEven_7976(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_7977","instance":7977,"id":244664,"goal":"predicate InRange_7977(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_7978","instance":7978,"id":244665,"goal":"predicate SubsetOf_7978(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_7979","instance":7979,"id":244666,"goal":"predicate AllMem_7979(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_7980","instance":7980,"id":244667,"goal":"predicate DisjointSets_7980(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_7981","instance":7981,"id":244668,"goal":"predicate Sorted_7981(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_7982","instance":7982,"id":244669,"goal":"predicate AllPositive_7982(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_7983","instance":7983,"id":244670,"goal":"predicate DistinctSeq_7983(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_7984","instance":7984,"id":244671,"goal":"predicate IsSubseq_7984(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_7985","instance":7985,"id":244672,"goal":"predicate IsPermutation_7985(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_7986","instance":7986,"id":244673,"goal":"predicate IsEven_7986(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_7987","instance":7987,"id":244674,"goal":"predicate InRange_7987(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_7988","instance":7988,"id":244675,"goal":"predicate SubsetOf_7988(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_7989","instance":7989,"id":244676,"goal":"predicate AllMem_7989(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_7990","instance":7990,"id":244677,"goal":"predicate DisjointSets_7990(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_7991","instance":7991,"id":244678,"goal":"predicate Sorted_7991(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_7992","instance":7992,"id":244679,"goal":"predicate AllPositive_7992(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_7993","instance":7993,"id":244680,"goal":"predicate DistinctSeq_7993(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_7994","instance":7994,"id":244681,"goal":"predicate IsSubseq_7994(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_7995","instance":7995,"id":244682,"goal":"predicate IsPermutation_7995(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_7996","instance":7996,"id":244683,"goal":"predicate IsEven_7996(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_7997","instance":7997,"id":244684,"goal":"predicate InRange_7997(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_7998","instance":7998,"id":244685,"goal":"predicate SubsetOf_7998(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_7999","instance":7999,"id":244686,"goal":"predicate AllMem_7999(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_8000","instance":8000,"id":244687,"goal":"predicate DisjointSets_8000(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_8001","instance":8001,"id":244688,"goal":"predicate Sorted_8001(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_8002","instance":8002,"id":244689,"goal":"predicate AllPositive_8002(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_8003","instance":8003,"id":244690,"goal":"predicate DistinctSeq_8003(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_8004","instance":8004,"id":244691,"goal":"predicate IsSubseq_8004(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_8005","instance":8005,"id":244692,"goal":"predicate IsPermutation_8005(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_8006","instance":8006,"id":244693,"goal":"predicate IsEven_8006(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_8007","instance":8007,"id":244694,"goal":"predicate InRange_8007(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_8008","instance":8008,"id":244695,"goal":"predicate SubsetOf_8008(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_8009","instance":8009,"id":244696,"goal":"predicate AllMem_8009(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_8010","instance":8010,"id":244697,"goal":"predicate DisjointSets_8010(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_8011","instance":8011,"id":244698,"goal":"predicate Sorted_8011(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_8012","instance":8012,"id":244699,"goal":"predicate AllPositive_8012(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_8013","instance":8013,"id":244700,"goal":"predicate DistinctSeq_8013(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_8014","instance":8014,"id":244701,"goal":"predicate IsSubseq_8014(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_8015","instance":8015,"id":244702,"goal":"predicate IsPermutation_8015(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_8016","instance":8016,"id":244703,"goal":"predicate IsEven_8016(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_8017","instance":8017,"id":244704,"goal":"predicate InRange_8017(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_8018","instance":8018,"id":244705,"goal":"predicate SubsetOf_8018(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_8019","instance":8019,"id":244706,"goal":"predicate AllMem_8019(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_8020","instance":8020,"id":244707,"goal":"predicate DisjointSets_8020(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_8021","instance":8021,"id":244708,"goal":"predicate Sorted_8021(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_8022","instance":8022,"id":244709,"goal":"predicate AllPositive_8022(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_8023","instance":8023,"id":244710,"goal":"predicate DistinctSeq_8023(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_8024","instance":8024,"id":244711,"goal":"predicate IsSubseq_8024(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_8025","instance":8025,"id":244712,"goal":"predicate IsPermutation_8025(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_8026","instance":8026,"id":244713,"goal":"predicate IsEven_8026(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_8027","instance":8027,"id":244714,"goal":"predicate InRange_8027(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_8028","instance":8028,"id":244715,"goal":"predicate SubsetOf_8028(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_8029","instance":8029,"id":244716,"goal":"predicate AllMem_8029(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_8030","instance":8030,"id":244717,"goal":"predicate DisjointSets_8030(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_8031","instance":8031,"id":244718,"goal":"predicate Sorted_8031(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_8032","instance":8032,"id":244719,"goal":"predicate AllPositive_8032(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_8033","instance":8033,"id":244720,"goal":"predicate DistinctSeq_8033(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_8034","instance":8034,"id":244721,"goal":"predicate IsSubseq_8034(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_8035","instance":8035,"id":244722,"goal":"predicate IsPermutation_8035(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_8036","instance":8036,"id":244723,"goal":"predicate IsEven_8036(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_8037","instance":8037,"id":244724,"goal":"predicate InRange_8037(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_8038","instance":8038,"id":244725,"goal":"predicate SubsetOf_8038(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_8039","instance":8039,"id":244726,"goal":"predicate AllMem_8039(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_8040","instance":8040,"id":244727,"goal":"predicate DisjointSets_8040(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_8041","instance":8041,"id":244728,"goal":"predicate Sorted_8041(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_8042","instance":8042,"id":244729,"goal":"predicate AllPositive_8042(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_8043","instance":8043,"id":244730,"goal":"predicate DistinctSeq_8043(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_8044","instance":8044,"id":244731,"goal":"predicate IsSubseq_8044(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_8045","instance":8045,"id":244732,"goal":"predicate IsPermutation_8045(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_8046","instance":8046,"id":244733,"goal":"predicate IsEven_8046(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_8047","instance":8047,"id":244734,"goal":"predicate InRange_8047(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_8048","instance":8048,"id":244735,"goal":"predicate SubsetOf_8048(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_8049","instance":8049,"id":244736,"goal":"predicate AllMem_8049(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_8050","instance":8050,"id":244737,"goal":"predicate DisjointSets_8050(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_8051","instance":8051,"id":244738,"goal":"predicate Sorted_8051(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_8052","instance":8052,"id":244739,"goal":"predicate AllPositive_8052(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_8053","instance":8053,"id":244740,"goal":"predicate DistinctSeq_8053(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_8054","instance":8054,"id":244741,"goal":"predicate IsSubseq_8054(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_8055","instance":8055,"id":244742,"goal":"predicate IsPermutation_8055(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_8056","instance":8056,"id":244743,"goal":"predicate IsEven_8056(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_8057","instance":8057,"id":244744,"goal":"predicate InRange_8057(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_8058","instance":8058,"id":244745,"goal":"predicate SubsetOf_8058(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_8059","instance":8059,"id":244746,"goal":"predicate AllMem_8059(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_8060","instance":8060,"id":244747,"goal":"predicate DisjointSets_8060(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_8061","instance":8061,"id":244748,"goal":"predicate Sorted_8061(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_8062","instance":8062,"id":244749,"goal":"predicate AllPositive_8062(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_8063","instance":8063,"id":244750,"goal":"predicate DistinctSeq_8063(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_8064","instance":8064,"id":244751,"goal":"predicate IsSubseq_8064(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_8065","instance":8065,"id":244752,"goal":"predicate IsPermutation_8065(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_8066","instance":8066,"id":244753,"goal":"predicate IsEven_8066(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_8067","instance":8067,"id":244754,"goal":"predicate InRange_8067(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_8068","instance":8068,"id":244755,"goal":"predicate SubsetOf_8068(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_8069","instance":8069,"id":244756,"goal":"predicate AllMem_8069(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_8070","instance":8070,"id":244757,"goal":"predicate DisjointSets_8070(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_8071","instance":8071,"id":244758,"goal":"predicate Sorted_8071(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_8072","instance":8072,"id":244759,"goal":"predicate AllPositive_8072(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_8073","instance":8073,"id":244760,"goal":"predicate DistinctSeq_8073(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_8074","instance":8074,"id":244761,"goal":"predicate IsSubseq_8074(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_8075","instance":8075,"id":244762,"goal":"predicate IsPermutation_8075(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_8076","instance":8076,"id":244763,"goal":"predicate IsEven_8076(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_8077","instance":8077,"id":244764,"goal":"predicate InRange_8077(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_8078","instance":8078,"id":244765,"goal":"predicate SubsetOf_8078(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_8079","instance":8079,"id":244766,"goal":"predicate AllMem_8079(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_8080","instance":8080,"id":244767,"goal":"predicate DisjointSets_8080(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_8081","instance":8081,"id":244768,"goal":"predicate Sorted_8081(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_8082","instance":8082,"id":244769,"goal":"predicate AllPositive_8082(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_8083","instance":8083,"id":244770,"goal":"predicate DistinctSeq_8083(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_8084","instance":8084,"id":244771,"goal":"predicate IsSubseq_8084(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_8085","instance":8085,"id":244772,"goal":"predicate IsPermutation_8085(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_8086","instance":8086,"id":244773,"goal":"predicate IsEven_8086(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_8087","instance":8087,"id":244774,"goal":"predicate InRange_8087(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_8088","instance":8088,"id":244775,"goal":"predicate SubsetOf_8088(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_8089","instance":8089,"id":244776,"goal":"predicate AllMem_8089(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_8090","instance":8090,"id":244777,"goal":"predicate DisjointSets_8090(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_8091","instance":8091,"id":244778,"goal":"predicate Sorted_8091(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_8092","instance":8092,"id":244779,"goal":"predicate AllPositive_8092(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_8093","instance":8093,"id":244780,"goal":"predicate DistinctSeq_8093(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_8094","instance":8094,"id":244781,"goal":"predicate IsSubseq_8094(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_8095","instance":8095,"id":244782,"goal":"predicate IsPermutation_8095(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_8096","instance":8096,"id":244783,"goal":"predicate IsEven_8096(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_8097","instance":8097,"id":244784,"goal":"predicate InRange_8097(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_8098","instance":8098,"id":244785,"goal":"predicate SubsetOf_8098(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_8099","instance":8099,"id":244786,"goal":"predicate AllMem_8099(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_8100","instance":8100,"id":244787,"goal":"predicate DisjointSets_8100(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_8101","instance":8101,"id":244788,"goal":"predicate Sorted_8101(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_8102","instance":8102,"id":244789,"goal":"predicate AllPositive_8102(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_8103","instance":8103,"id":244790,"goal":"predicate DistinctSeq_8103(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_8104","instance":8104,"id":244791,"goal":"predicate IsSubseq_8104(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_8105","instance":8105,"id":244792,"goal":"predicate IsPermutation_8105(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_8106","instance":8106,"id":244793,"goal":"predicate IsEven_8106(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_8107","instance":8107,"id":244794,"goal":"predicate InRange_8107(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_8108","instance":8108,"id":244795,"goal":"predicate SubsetOf_8108(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_8109","instance":8109,"id":244796,"goal":"predicate AllMem_8109(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_8110","instance":8110,"id":244797,"goal":"predicate DisjointSets_8110(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_8111","instance":8111,"id":244798,"goal":"predicate Sorted_8111(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_8112","instance":8112,"id":244799,"goal":"predicate AllPositive_8112(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_8113","instance":8113,"id":244800,"goal":"predicate DistinctSeq_8113(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_8114","instance":8114,"id":244801,"goal":"predicate IsSubseq_8114(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_8115","instance":8115,"id":244802,"goal":"predicate IsPermutation_8115(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_8116","instance":8116,"id":244803,"goal":"predicate IsEven_8116(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_8117","instance":8117,"id":244804,"goal":"predicate InRange_8117(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_8118","instance":8118,"id":244805,"goal":"predicate SubsetOf_8118(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_8119","instance":8119,"id":244806,"goal":"predicate AllMem_8119(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_8120","instance":8120,"id":244807,"goal":"predicate DisjointSets_8120(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_8121","instance":8121,"id":244808,"goal":"predicate Sorted_8121(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_8122","instance":8122,"id":244809,"goal":"predicate AllPositive_8122(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_8123","instance":8123,"id":244810,"goal":"predicate DistinctSeq_8123(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_8124","instance":8124,"id":244811,"goal":"predicate IsSubseq_8124(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_8125","instance":8125,"id":244812,"goal":"predicate IsPermutation_8125(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_8126","instance":8126,"id":244813,"goal":"predicate IsEven_8126(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_8127","instance":8127,"id":244814,"goal":"predicate InRange_8127(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_8128","instance":8128,"id":244815,"goal":"predicate SubsetOf_8128(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_8129","instance":8129,"id":244816,"goal":"predicate AllMem_8129(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_8130","instance":8130,"id":244817,"goal":"predicate DisjointSets_8130(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_8131","instance":8131,"id":244818,"goal":"predicate Sorted_8131(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_8132","instance":8132,"id":244819,"goal":"predicate AllPositive_8132(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_8133","instance":8133,"id":244820,"goal":"predicate DistinctSeq_8133(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_8134","instance":8134,"id":244821,"goal":"predicate IsSubseq_8134(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_8135","instance":8135,"id":244822,"goal":"predicate IsPermutation_8135(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_8136","instance":8136,"id":244823,"goal":"predicate IsEven_8136(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_8137","instance":8137,"id":244824,"goal":"predicate InRange_8137(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_8138","instance":8138,"id":244825,"goal":"predicate SubsetOf_8138(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_8139","instance":8139,"id":244826,"goal":"predicate AllMem_8139(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_8140","instance":8140,"id":244827,"goal":"predicate DisjointSets_8140(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_8141","instance":8141,"id":244828,"goal":"predicate Sorted_8141(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_8142","instance":8142,"id":244829,"goal":"predicate AllPositive_8142(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_8143","instance":8143,"id":244830,"goal":"predicate DistinctSeq_8143(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_8144","instance":8144,"id":244831,"goal":"predicate IsSubseq_8144(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_8145","instance":8145,"id":244832,"goal":"predicate IsPermutation_8145(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_8146","instance":8146,"id":244833,"goal":"predicate IsEven_8146(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_8147","instance":8147,"id":244834,"goal":"predicate InRange_8147(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_8148","instance":8148,"id":244835,"goal":"predicate SubsetOf_8148(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_8149","instance":8149,"id":244836,"goal":"predicate AllMem_8149(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_8150","instance":8150,"id":244837,"goal":"predicate DisjointSets_8150(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_8151","instance":8151,"id":244838,"goal":"predicate Sorted_8151(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_8152","instance":8152,"id":244839,"goal":"predicate AllPositive_8152(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_8153","instance":8153,"id":244840,"goal":"predicate DistinctSeq_8153(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_8154","instance":8154,"id":244841,"goal":"predicate IsSubseq_8154(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_8155","instance":8155,"id":244842,"goal":"predicate IsPermutation_8155(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_8156","instance":8156,"id":244843,"goal":"predicate IsEven_8156(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_8157","instance":8157,"id":244844,"goal":"predicate InRange_8157(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_8158","instance":8158,"id":244845,"goal":"predicate SubsetOf_8158(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_8159","instance":8159,"id":244846,"goal":"predicate AllMem_8159(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_8160","instance":8160,"id":244847,"goal":"predicate DisjointSets_8160(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_8161","instance":8161,"id":244848,"goal":"predicate Sorted_8161(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_8162","instance":8162,"id":244849,"goal":"predicate AllPositive_8162(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_8163","instance":8163,"id":244850,"goal":"predicate DistinctSeq_8163(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_8164","instance":8164,"id":244851,"goal":"predicate IsSubseq_8164(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_8165","instance":8165,"id":244852,"goal":"predicate IsPermutation_8165(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_8166","instance":8166,"id":244853,"goal":"predicate IsEven_8166(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_8167","instance":8167,"id":244854,"goal":"predicate InRange_8167(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_8168","instance":8168,"id":244855,"goal":"predicate SubsetOf_8168(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_8169","instance":8169,"id":244856,"goal":"predicate AllMem_8169(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_8170","instance":8170,"id":244857,"goal":"predicate DisjointSets_8170(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_8171","instance":8171,"id":244858,"goal":"predicate Sorted_8171(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_8172","instance":8172,"id":244859,"goal":"predicate AllPositive_8172(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_8173","instance":8173,"id":244860,"goal":"predicate DistinctSeq_8173(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_8174","instance":8174,"id":244861,"goal":"predicate IsSubseq_8174(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_8175","instance":8175,"id":244862,"goal":"predicate IsPermutation_8175(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_8176","instance":8176,"id":244863,"goal":"predicate IsEven_8176(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_8177","instance":8177,"id":244864,"goal":"predicate InRange_8177(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_8178","instance":8178,"id":244865,"goal":"predicate SubsetOf_8178(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_8179","instance":8179,"id":244866,"goal":"predicate AllMem_8179(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_8180","instance":8180,"id":244867,"goal":"predicate DisjointSets_8180(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_8181","instance":8181,"id":244868,"goal":"predicate Sorted_8181(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_8182","instance":8182,"id":244869,"goal":"predicate AllPositive_8182(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_8183","instance":8183,"id":244870,"goal":"predicate DistinctSeq_8183(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_8184","instance":8184,"id":244871,"goal":"predicate IsSubseq_8184(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_8185","instance":8185,"id":244872,"goal":"predicate IsPermutation_8185(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_8186","instance":8186,"id":244873,"goal":"predicate IsEven_8186(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_8187","instance":8187,"id":244874,"goal":"predicate InRange_8187(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_8188","instance":8188,"id":244875,"goal":"predicate SubsetOf_8188(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_8189","instance":8189,"id":244876,"goal":"predicate AllMem_8189(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_8190","instance":8190,"id":244877,"goal":"predicate DisjointSets_8190(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_8191","instance":8191,"id":244878,"goal":"predicate Sorted_8191(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_8192","instance":8192,"id":244879,"goal":"predicate AllPositive_8192(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_8193","instance":8193,"id":244880,"goal":"predicate DistinctSeq_8193(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_8194","instance":8194,"id":244881,"goal":"predicate IsSubseq_8194(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_8195","instance":8195,"id":244882,"goal":"predicate IsPermutation_8195(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_8196","instance":8196,"id":244883,"goal":"predicate IsEven_8196(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_8197","instance":8197,"id":244884,"goal":"predicate InRange_8197(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_8198","instance":8198,"id":244885,"goal":"predicate SubsetOf_8198(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_8199","instance":8199,"id":244886,"goal":"predicate AllMem_8199(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_8200","instance":8200,"id":244887,"goal":"predicate DisjointSets_8200(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_8201","instance":8201,"id":244888,"goal":"predicate Sorted_8201(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_8202","instance":8202,"id":244889,"goal":"predicate AllPositive_8202(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_8203","instance":8203,"id":244890,"goal":"predicate DistinctSeq_8203(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_8204","instance":8204,"id":244891,"goal":"predicate IsSubseq_8204(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_8205","instance":8205,"id":244892,"goal":"predicate IsPermutation_8205(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_8206","instance":8206,"id":244893,"goal":"predicate IsEven_8206(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_8207","instance":8207,"id":244894,"goal":"predicate InRange_8207(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_8208","instance":8208,"id":244895,"goal":"predicate SubsetOf_8208(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_8209","instance":8209,"id":244896,"goal":"predicate AllMem_8209(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_8210","instance":8210,"id":244897,"goal":"predicate DisjointSets_8210(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_8211","instance":8211,"id":244898,"goal":"predicate Sorted_8211(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_8212","instance":8212,"id":244899,"goal":"predicate AllPositive_8212(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_8213","instance":8213,"id":244900,"goal":"predicate DistinctSeq_8213(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_8214","instance":8214,"id":244901,"goal":"predicate IsSubseq_8214(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_8215","instance":8215,"id":244902,"goal":"predicate IsPermutation_8215(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_8216","instance":8216,"id":244903,"goal":"predicate IsEven_8216(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_8217","instance":8217,"id":244904,"goal":"predicate InRange_8217(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_8218","instance":8218,"id":244905,"goal":"predicate SubsetOf_8218(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_8219","instance":8219,"id":244906,"goal":"predicate AllMem_8219(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_8220","instance":8220,"id":244907,"goal":"predicate DisjointSets_8220(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_8221","instance":8221,"id":244908,"goal":"predicate Sorted_8221(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_8222","instance":8222,"id":244909,"goal":"predicate AllPositive_8222(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_8223","instance":8223,"id":244910,"goal":"predicate DistinctSeq_8223(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_8224","instance":8224,"id":244911,"goal":"predicate IsSubseq_8224(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_8225","instance":8225,"id":244912,"goal":"predicate IsPermutation_8225(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_8226","instance":8226,"id":244913,"goal":"predicate IsEven_8226(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_8227","instance":8227,"id":244914,"goal":"predicate InRange_8227(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_8228","instance":8228,"id":244915,"goal":"predicate SubsetOf_8228(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_8229","instance":8229,"id":244916,"goal":"predicate AllMem_8229(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_8230","instance":8230,"id":244917,"goal":"predicate DisjointSets_8230(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_8231","instance":8231,"id":244918,"goal":"predicate Sorted_8231(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_8232","instance":8232,"id":244919,"goal":"predicate AllPositive_8232(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_8233","instance":8233,"id":244920,"goal":"predicate DistinctSeq_8233(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_8234","instance":8234,"id":244921,"goal":"predicate IsSubseq_8234(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_8235","instance":8235,"id":244922,"goal":"predicate IsPermutation_8235(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_8236","instance":8236,"id":244923,"goal":"predicate IsEven_8236(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_8237","instance":8237,"id":244924,"goal":"predicate InRange_8237(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_8238","instance":8238,"id":244925,"goal":"predicate SubsetOf_8238(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_8239","instance":8239,"id":244926,"goal":"predicate AllMem_8239(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_8240","instance":8240,"id":244927,"goal":"predicate DisjointSets_8240(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_8241","instance":8241,"id":244928,"goal":"predicate Sorted_8241(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_8242","instance":8242,"id":244929,"goal":"predicate AllPositive_8242(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_8243","instance":8243,"id":244930,"goal":"predicate DistinctSeq_8243(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_8244","instance":8244,"id":244931,"goal":"predicate IsSubseq_8244(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_8245","instance":8245,"id":244932,"goal":"predicate IsPermutation_8245(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_8246","instance":8246,"id":244933,"goal":"predicate IsEven_8246(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_8247","instance":8247,"id":244934,"goal":"predicate InRange_8247(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_8248","instance":8248,"id":244935,"goal":"predicate SubsetOf_8248(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_8249","instance":8249,"id":244936,"goal":"predicate AllMem_8249(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_8250","instance":8250,"id":244937,"goal":"predicate DisjointSets_8250(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_8251","instance":8251,"id":244938,"goal":"predicate Sorted_8251(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_8252","instance":8252,"id":244939,"goal":"predicate AllPositive_8252(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_8253","instance":8253,"id":244940,"goal":"predicate DistinctSeq_8253(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_8254","instance":8254,"id":244941,"goal":"predicate IsSubseq_8254(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_8255","instance":8255,"id":244942,"goal":"predicate IsPermutation_8255(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_8256","instance":8256,"id":244943,"goal":"predicate IsEven_8256(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_8257","instance":8257,"id":244944,"goal":"predicate InRange_8257(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_8258","instance":8258,"id":244945,"goal":"predicate SubsetOf_8258(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_8259","instance":8259,"id":244946,"goal":"predicate AllMem_8259(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_8260","instance":8260,"id":244947,"goal":"predicate DisjointSets_8260(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_8261","instance":8261,"id":244948,"goal":"predicate Sorted_8261(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_8262","instance":8262,"id":244949,"goal":"predicate AllPositive_8262(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_8263","instance":8263,"id":244950,"goal":"predicate DistinctSeq_8263(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_8264","instance":8264,"id":244951,"goal":"predicate IsSubseq_8264(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_8265","instance":8265,"id":244952,"goal":"predicate IsPermutation_8265(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_8266","instance":8266,"id":244953,"goal":"predicate IsEven_8266(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_8267","instance":8267,"id":244954,"goal":"predicate InRange_8267(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_8268","instance":8268,"id":244955,"goal":"predicate SubsetOf_8268(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_8269","instance":8269,"id":244956,"goal":"predicate AllMem_8269(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_8270","instance":8270,"id":244957,"goal":"predicate DisjointSets_8270(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_8271","instance":8271,"id":244958,"goal":"predicate Sorted_8271(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_8272","instance":8272,"id":244959,"goal":"predicate AllPositive_8272(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_8273","instance":8273,"id":244960,"goal":"predicate DistinctSeq_8273(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_8274","instance":8274,"id":244961,"goal":"predicate IsSubseq_8274(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_8275","instance":8275,"id":244962,"goal":"predicate IsPermutation_8275(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_8276","instance":8276,"id":244963,"goal":"predicate IsEven_8276(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_8277","instance":8277,"id":244964,"goal":"predicate InRange_8277(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_8278","instance":8278,"id":244965,"goal":"predicate SubsetOf_8278(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_8279","instance":8279,"id":244966,"goal":"predicate AllMem_8279(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_8280","instance":8280,"id":244967,"goal":"predicate DisjointSets_8280(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_8281","instance":8281,"id":244968,"goal":"predicate Sorted_8281(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_8282","instance":8282,"id":244969,"goal":"predicate AllPositive_8282(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_8283","instance":8283,"id":244970,"goal":"predicate DistinctSeq_8283(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_8284","instance":8284,"id":244971,"goal":"predicate IsSubseq_8284(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_8285","instance":8285,"id":244972,"goal":"predicate IsPermutation_8285(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_8286","instance":8286,"id":244973,"goal":"predicate IsEven_8286(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_8287","instance":8287,"id":244974,"goal":"predicate InRange_8287(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_8288","instance":8288,"id":244975,"goal":"predicate SubsetOf_8288(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_8289","instance":8289,"id":244976,"goal":"predicate AllMem_8289(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_8290","instance":8290,"id":244977,"goal":"predicate DisjointSets_8290(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_8291","instance":8291,"id":244978,"goal":"predicate Sorted_8291(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_8292","instance":8292,"id":244979,"goal":"predicate AllPositive_8292(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_8293","instance":8293,"id":244980,"goal":"predicate DistinctSeq_8293(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_8294","instance":8294,"id":244981,"goal":"predicate IsSubseq_8294(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_8295","instance":8295,"id":244982,"goal":"predicate IsPermutation_8295(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_8296","instance":8296,"id":244983,"goal":"predicate IsEven_8296(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_8297","instance":8297,"id":244984,"goal":"predicate InRange_8297(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_8298","instance":8298,"id":244985,"goal":"predicate SubsetOf_8298(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_8299","instance":8299,"id":244986,"goal":"predicate AllMem_8299(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_8300","instance":8300,"id":244987,"goal":"predicate DisjointSets_8300(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_8301","instance":8301,"id":244988,"goal":"predicate Sorted_8301(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_8302","instance":8302,"id":244989,"goal":"predicate AllPositive_8302(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_8303","instance":8303,"id":244990,"goal":"predicate DistinctSeq_8303(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_8304","instance":8304,"id":244991,"goal":"predicate IsSubseq_8304(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_8305","instance":8305,"id":244992,"goal":"predicate IsPermutation_8305(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_8306","instance":8306,"id":244993,"goal":"predicate IsEven_8306(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_8307","instance":8307,"id":244994,"goal":"predicate InRange_8307(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_8308","instance":8308,"id":244995,"goal":"predicate SubsetOf_8308(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_8309","instance":8309,"id":244996,"goal":"predicate AllMem_8309(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_8310","instance":8310,"id":244997,"goal":"predicate DisjointSets_8310(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_8311","instance":8311,"id":244998,"goal":"predicate Sorted_8311(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_8312","instance":8312,"id":244999,"goal":"predicate AllPositive_8312(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_8313","instance":8313,"id":245000,"goal":"predicate DistinctSeq_8313(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_8314","instance":8314,"id":245001,"goal":"predicate IsSubseq_8314(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_8315","instance":8315,"id":245002,"goal":"predicate IsPermutation_8315(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_8316","instance":8316,"id":245003,"goal":"predicate IsEven_8316(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_8317","instance":8317,"id":245004,"goal":"predicate InRange_8317(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_8318","instance":8318,"id":245005,"goal":"predicate SubsetOf_8318(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_8319","instance":8319,"id":245006,"goal":"predicate AllMem_8319(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_8320","instance":8320,"id":245007,"goal":"predicate DisjointSets_8320(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_8321","instance":8321,"id":245008,"goal":"predicate Sorted_8321(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_8322","instance":8322,"id":245009,"goal":"predicate AllPositive_8322(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_8323","instance":8323,"id":245010,"goal":"predicate DistinctSeq_8323(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_8324","instance":8324,"id":245011,"goal":"predicate IsSubseq_8324(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_8325","instance":8325,"id":245012,"goal":"predicate IsPermutation_8325(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_8326","instance":8326,"id":245013,"goal":"predicate IsEven_8326(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_8327","instance":8327,"id":245014,"goal":"predicate InRange_8327(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_8328","instance":8328,"id":245015,"goal":"predicate SubsetOf_8328(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_8329","instance":8329,"id":245016,"goal":"predicate AllMem_8329(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_8330","instance":8330,"id":245017,"goal":"predicate DisjointSets_8330(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_8331","instance":8331,"id":245018,"goal":"predicate Sorted_8331(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_8332","instance":8332,"id":245019,"goal":"predicate AllPositive_8332(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_8333","instance":8333,"id":245020,"goal":"predicate DistinctSeq_8333(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_8334","instance":8334,"id":245021,"goal":"predicate IsSubseq_8334(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_8335","instance":8335,"id":245022,"goal":"predicate IsPermutation_8335(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_8336","instance":8336,"id":245023,"goal":"predicate IsEven_8336(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_8337","instance":8337,"id":245024,"goal":"predicate InRange_8337(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_8338","instance":8338,"id":245025,"goal":"predicate SubsetOf_8338(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_8339","instance":8339,"id":245026,"goal":"predicate AllMem_8339(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_8340","instance":8340,"id":245027,"goal":"predicate DisjointSets_8340(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_8341","instance":8341,"id":245028,"goal":"predicate Sorted_8341(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_8342","instance":8342,"id":245029,"goal":"predicate AllPositive_8342(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_8343","instance":8343,"id":245030,"goal":"predicate DistinctSeq_8343(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_8344","instance":8344,"id":245031,"goal":"predicate IsSubseq_8344(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_8345","instance":8345,"id":245032,"goal":"predicate IsPermutation_8345(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_8346","instance":8346,"id":245033,"goal":"predicate IsEven_8346(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_8347","instance":8347,"id":245034,"goal":"predicate InRange_8347(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_8348","instance":8348,"id":245035,"goal":"predicate SubsetOf_8348(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_8349","instance":8349,"id":245036,"goal":"predicate AllMem_8349(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_8350","instance":8350,"id":245037,"goal":"predicate DisjointSets_8350(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_8351","instance":8351,"id":245038,"goal":"predicate Sorted_8351(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_8352","instance":8352,"id":245039,"goal":"predicate AllPositive_8352(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_8353","instance":8353,"id":245040,"goal":"predicate DistinctSeq_8353(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_8354","instance":8354,"id":245041,"goal":"predicate IsSubseq_8354(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_8355","instance":8355,"id":245042,"goal":"predicate IsPermutation_8355(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_8356","instance":8356,"id":245043,"goal":"predicate IsEven_8356(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_8357","instance":8357,"id":245044,"goal":"predicate InRange_8357(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_8358","instance":8358,"id":245045,"goal":"predicate SubsetOf_8358(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_8359","instance":8359,"id":245046,"goal":"predicate AllMem_8359(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_8360","instance":8360,"id":245047,"goal":"predicate DisjointSets_8360(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_8361","instance":8361,"id":245048,"goal":"predicate Sorted_8361(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_8362","instance":8362,"id":245049,"goal":"predicate AllPositive_8362(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_8363","instance":8363,"id":245050,"goal":"predicate DistinctSeq_8363(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_8364","instance":8364,"id":245051,"goal":"predicate IsSubseq_8364(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_8365","instance":8365,"id":245052,"goal":"predicate IsPermutation_8365(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_8366","instance":8366,"id":245053,"goal":"predicate IsEven_8366(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_8367","instance":8367,"id":245054,"goal":"predicate InRange_8367(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_8368","instance":8368,"id":245055,"goal":"predicate SubsetOf_8368(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_8369","instance":8369,"id":245056,"goal":"predicate AllMem_8369(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_8370","instance":8370,"id":245057,"goal":"predicate DisjointSets_8370(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_8371","instance":8371,"id":245058,"goal":"predicate Sorted_8371(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_8372","instance":8372,"id":245059,"goal":"predicate AllPositive_8372(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_8373","instance":8373,"id":245060,"goal":"predicate DistinctSeq_8373(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_8374","instance":8374,"id":245061,"goal":"predicate IsSubseq_8374(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_8375","instance":8375,"id":245062,"goal":"predicate IsPermutation_8375(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_8376","instance":8376,"id":245063,"goal":"predicate IsEven_8376(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_8377","instance":8377,"id":245064,"goal":"predicate InRange_8377(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_8378","instance":8378,"id":245065,"goal":"predicate SubsetOf_8378(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_8379","instance":8379,"id":245066,"goal":"predicate AllMem_8379(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_8380","instance":8380,"id":245067,"goal":"predicate DisjointSets_8380(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_8381","instance":8381,"id":245068,"goal":"predicate Sorted_8381(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_8382","instance":8382,"id":245069,"goal":"predicate AllPositive_8382(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_8383","instance":8383,"id":245070,"goal":"predicate DistinctSeq_8383(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_8384","instance":8384,"id":245071,"goal":"predicate IsSubseq_8384(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_8385","instance":8385,"id":245072,"goal":"predicate IsPermutation_8385(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_8386","instance":8386,"id":245073,"goal":"predicate IsEven_8386(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_8387","instance":8387,"id":245074,"goal":"predicate InRange_8387(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_8388","instance":8388,"id":245075,"goal":"predicate SubsetOf_8388(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_8389","instance":8389,"id":245076,"goal":"predicate AllMem_8389(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_8390","instance":8390,"id":245077,"goal":"predicate DisjointSets_8390(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_8391","instance":8391,"id":245078,"goal":"predicate Sorted_8391(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_8392","instance":8392,"id":245079,"goal":"predicate AllPositive_8392(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_8393","instance":8393,"id":245080,"goal":"predicate DistinctSeq_8393(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_8394","instance":8394,"id":245081,"goal":"predicate IsSubseq_8394(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_8395","instance":8395,"id":245082,"goal":"predicate IsPermutation_8395(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_8396","instance":8396,"id":245083,"goal":"predicate IsEven_8396(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_8397","instance":8397,"id":245084,"goal":"predicate InRange_8397(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_8398","instance":8398,"id":245085,"goal":"predicate SubsetOf_8398(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_8399","instance":8399,"id":245086,"goal":"predicate AllMem_8399(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_8400","instance":8400,"id":245087,"goal":"predicate DisjointSets_8400(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_8401","instance":8401,"id":245088,"goal":"predicate Sorted_8401(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_8402","instance":8402,"id":245089,"goal":"predicate AllPositive_8402(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_8403","instance":8403,"id":245090,"goal":"predicate DistinctSeq_8403(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_8404","instance":8404,"id":245091,"goal":"predicate IsSubseq_8404(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_8405","instance":8405,"id":245092,"goal":"predicate IsPermutation_8405(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_8406","instance":8406,"id":245093,"goal":"predicate IsEven_8406(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_8407","instance":8407,"id":245094,"goal":"predicate InRange_8407(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_8408","instance":8408,"id":245095,"goal":"predicate SubsetOf_8408(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_8409","instance":8409,"id":245096,"goal":"predicate AllMem_8409(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_8410","instance":8410,"id":245097,"goal":"predicate DisjointSets_8410(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_8411","instance":8411,"id":245098,"goal":"predicate Sorted_8411(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_8412","instance":8412,"id":245099,"goal":"predicate AllPositive_8412(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_8413","instance":8413,"id":245100,"goal":"predicate DistinctSeq_8413(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_8414","instance":8414,"id":245101,"goal":"predicate IsSubseq_8414(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_8415","instance":8415,"id":245102,"goal":"predicate IsPermutation_8415(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_8416","instance":8416,"id":245103,"goal":"predicate IsEven_8416(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_8417","instance":8417,"id":245104,"goal":"predicate InRange_8417(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_8418","instance":8418,"id":245105,"goal":"predicate SubsetOf_8418(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_8419","instance":8419,"id":245106,"goal":"predicate AllMem_8419(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_8420","instance":8420,"id":245107,"goal":"predicate DisjointSets_8420(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_8421","instance":8421,"id":245108,"goal":"predicate Sorted_8421(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_8422","instance":8422,"id":245109,"goal":"predicate AllPositive_8422(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_8423","instance":8423,"id":245110,"goal":"predicate DistinctSeq_8423(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_8424","instance":8424,"id":245111,"goal":"predicate IsSubseq_8424(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_8425","instance":8425,"id":245112,"goal":"predicate IsPermutation_8425(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_8426","instance":8426,"id":245113,"goal":"predicate IsEven_8426(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_8427","instance":8427,"id":245114,"goal":"predicate InRange_8427(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_8428","instance":8428,"id":245115,"goal":"predicate SubsetOf_8428(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_8429","instance":8429,"id":245116,"goal":"predicate AllMem_8429(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_8430","instance":8430,"id":245117,"goal":"predicate DisjointSets_8430(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_8431","instance":8431,"id":245118,"goal":"predicate Sorted_8431(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_8432","instance":8432,"id":245119,"goal":"predicate AllPositive_8432(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_8433","instance":8433,"id":245120,"goal":"predicate DistinctSeq_8433(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_8434","instance":8434,"id":245121,"goal":"predicate IsSubseq_8434(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_8435","instance":8435,"id":245122,"goal":"predicate IsPermutation_8435(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_8436","instance":8436,"id":245123,"goal":"predicate IsEven_8436(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_8437","instance":8437,"id":245124,"goal":"predicate InRange_8437(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_8438","instance":8438,"id":245125,"goal":"predicate SubsetOf_8438(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_8439","instance":8439,"id":245126,"goal":"predicate AllMem_8439(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_8440","instance":8440,"id":245127,"goal":"predicate DisjointSets_8440(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_8441","instance":8441,"id":245128,"goal":"predicate Sorted_8441(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_8442","instance":8442,"id":245129,"goal":"predicate AllPositive_8442(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_8443","instance":8443,"id":245130,"goal":"predicate DistinctSeq_8443(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_8444","instance":8444,"id":245131,"goal":"predicate IsSubseq_8444(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_8445","instance":8445,"id":245132,"goal":"predicate IsPermutation_8445(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_8446","instance":8446,"id":245133,"goal":"predicate IsEven_8446(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_8447","instance":8447,"id":245134,"goal":"predicate InRange_8447(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_8448","instance":8448,"id":245135,"goal":"predicate SubsetOf_8448(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_8449","instance":8449,"id":245136,"goal":"predicate AllMem_8449(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_8450","instance":8450,"id":245137,"goal":"predicate DisjointSets_8450(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_8451","instance":8451,"id":245138,"goal":"predicate Sorted_8451(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_8452","instance":8452,"id":245139,"goal":"predicate AllPositive_8452(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_8453","instance":8453,"id":245140,"goal":"predicate DistinctSeq_8453(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_8454","instance":8454,"id":245141,"goal":"predicate IsSubseq_8454(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_8455","instance":8455,"id":245142,"goal":"predicate IsPermutation_8455(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_8456","instance":8456,"id":245143,"goal":"predicate IsEven_8456(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_8457","instance":8457,"id":245144,"goal":"predicate InRange_8457(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_8458","instance":8458,"id":245145,"goal":"predicate SubsetOf_8458(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_8459","instance":8459,"id":245146,"goal":"predicate AllMem_8459(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_8460","instance":8460,"id":245147,"goal":"predicate DisjointSets_8460(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_8461","instance":8461,"id":245148,"goal":"predicate Sorted_8461(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_8462","instance":8462,"id":245149,"goal":"predicate AllPositive_8462(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_8463","instance":8463,"id":245150,"goal":"predicate DistinctSeq_8463(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_8464","instance":8464,"id":245151,"goal":"predicate IsSubseq_8464(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_8465","instance":8465,"id":245152,"goal":"predicate IsPermutation_8465(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_8466","instance":8466,"id":245153,"goal":"predicate IsEven_8466(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_8467","instance":8467,"id":245154,"goal":"predicate InRange_8467(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_8468","instance":8468,"id":245155,"goal":"predicate SubsetOf_8468(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_8469","instance":8469,"id":245156,"goal":"predicate AllMem_8469(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_8470","instance":8470,"id":245157,"goal":"predicate DisjointSets_8470(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_8471","instance":8471,"id":245158,"goal":"predicate Sorted_8471(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_8472","instance":8472,"id":245159,"goal":"predicate AllPositive_8472(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_8473","instance":8473,"id":245160,"goal":"predicate DistinctSeq_8473(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_8474","instance":8474,"id":245161,"goal":"predicate IsSubseq_8474(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_8475","instance":8475,"id":245162,"goal":"predicate IsPermutation_8475(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_8476","instance":8476,"id":245163,"goal":"predicate IsEven_8476(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_8477","instance":8477,"id":245164,"goal":"predicate InRange_8477(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_8478","instance":8478,"id":245165,"goal":"predicate SubsetOf_8478(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_8479","instance":8479,"id":245166,"goal":"predicate AllMem_8479(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_8480","instance":8480,"id":245167,"goal":"predicate DisjointSets_8480(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_8481","instance":8481,"id":245168,"goal":"predicate Sorted_8481(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_8482","instance":8482,"id":245169,"goal":"predicate AllPositive_8482(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_8483","instance":8483,"id":245170,"goal":"predicate DistinctSeq_8483(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_8484","instance":8484,"id":245171,"goal":"predicate IsSubseq_8484(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_8485","instance":8485,"id":245172,"goal":"predicate IsPermutation_8485(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_8486","instance":8486,"id":245173,"goal":"predicate IsEven_8486(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_8487","instance":8487,"id":245174,"goal":"predicate InRange_8487(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_8488","instance":8488,"id":245175,"goal":"predicate SubsetOf_8488(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_8489","instance":8489,"id":245176,"goal":"predicate AllMem_8489(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_8490","instance":8490,"id":245177,"goal":"predicate DisjointSets_8490(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_8491","instance":8491,"id":245178,"goal":"predicate Sorted_8491(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_8492","instance":8492,"id":245179,"goal":"predicate AllPositive_8492(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_8493","instance":8493,"id":245180,"goal":"predicate DistinctSeq_8493(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_8494","instance":8494,"id":245181,"goal":"predicate IsSubseq_8494(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_8495","instance":8495,"id":245182,"goal":"predicate IsPermutation_8495(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_8496","instance":8496,"id":245183,"goal":"predicate IsEven_8496(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_8497","instance":8497,"id":245184,"goal":"predicate InRange_8497(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_8498","instance":8498,"id":245185,"goal":"predicate SubsetOf_8498(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_8499","instance":8499,"id":245186,"goal":"predicate AllMem_8499(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_8500","instance":8500,"id":245187,"goal":"predicate DisjointSets_8500(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_8501","instance":8501,"id":245188,"goal":"predicate Sorted_8501(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_8502","instance":8502,"id":245189,"goal":"predicate AllPositive_8502(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_8503","instance":8503,"id":245190,"goal":"predicate DistinctSeq_8503(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_8504","instance":8504,"id":245191,"goal":"predicate IsSubseq_8504(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_8505","instance":8505,"id":245192,"goal":"predicate IsPermutation_8505(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_8506","instance":8506,"id":245193,"goal":"predicate IsEven_8506(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_8507","instance":8507,"id":245194,"goal":"predicate InRange_8507(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_8508","instance":8508,"id":245195,"goal":"predicate SubsetOf_8508(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_8509","instance":8509,"id":245196,"goal":"predicate AllMem_8509(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_8510","instance":8510,"id":245197,"goal":"predicate DisjointSets_8510(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_8511","instance":8511,"id":245198,"goal":"predicate Sorted_8511(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_8512","instance":8512,"id":245199,"goal":"predicate AllPositive_8512(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_8513","instance":8513,"id":245200,"goal":"predicate DistinctSeq_8513(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_8514","instance":8514,"id":245201,"goal":"predicate IsSubseq_8514(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_8515","instance":8515,"id":245202,"goal":"predicate IsPermutation_8515(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_8516","instance":8516,"id":245203,"goal":"predicate IsEven_8516(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_8517","instance":8517,"id":245204,"goal":"predicate InRange_8517(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_8518","instance":8518,"id":245205,"goal":"predicate SubsetOf_8518(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_8519","instance":8519,"id":245206,"goal":"predicate AllMem_8519(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_8520","instance":8520,"id":245207,"goal":"predicate DisjointSets_8520(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_8521","instance":8521,"id":245208,"goal":"predicate Sorted_8521(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_8522","instance":8522,"id":245209,"goal":"predicate AllPositive_8522(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_8523","instance":8523,"id":245210,"goal":"predicate DistinctSeq_8523(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_8524","instance":8524,"id":245211,"goal":"predicate IsSubseq_8524(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_8525","instance":8525,"id":245212,"goal":"predicate IsPermutation_8525(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_8526","instance":8526,"id":245213,"goal":"predicate IsEven_8526(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_8527","instance":8527,"id":245214,"goal":"predicate InRange_8527(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_8528","instance":8528,"id":245215,"goal":"predicate SubsetOf_8528(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_8529","instance":8529,"id":245216,"goal":"predicate AllMem_8529(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_8530","instance":8530,"id":245217,"goal":"predicate DisjointSets_8530(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_8531","instance":8531,"id":245218,"goal":"predicate Sorted_8531(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_8532","instance":8532,"id":245219,"goal":"predicate AllPositive_8532(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_8533","instance":8533,"id":245220,"goal":"predicate DistinctSeq_8533(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_8534","instance":8534,"id":245221,"goal":"predicate IsSubseq_8534(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_8535","instance":8535,"id":245222,"goal":"predicate IsPermutation_8535(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_8536","instance":8536,"id":245223,"goal":"predicate IsEven_8536(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_8537","instance":8537,"id":245224,"goal":"predicate InRange_8537(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_8538","instance":8538,"id":245225,"goal":"predicate SubsetOf_8538(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_8539","instance":8539,"id":245226,"goal":"predicate AllMem_8539(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_8540","instance":8540,"id":245227,"goal":"predicate DisjointSets_8540(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_8541","instance":8541,"id":245228,"goal":"predicate Sorted_8541(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_8542","instance":8542,"id":245229,"goal":"predicate AllPositive_8542(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_8543","instance":8543,"id":245230,"goal":"predicate DistinctSeq_8543(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_8544","instance":8544,"id":245231,"goal":"predicate IsSubseq_8544(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_8545","instance":8545,"id":245232,"goal":"predicate IsPermutation_8545(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_8546","instance":8546,"id":245233,"goal":"predicate IsEven_8546(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_8547","instance":8547,"id":245234,"goal":"predicate InRange_8547(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_8548","instance":8548,"id":245235,"goal":"predicate SubsetOf_8548(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_8549","instance":8549,"id":245236,"goal":"predicate AllMem_8549(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_8550","instance":8550,"id":245237,"goal":"predicate DisjointSets_8550(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_8551","instance":8551,"id":245238,"goal":"predicate Sorted_8551(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_8552","instance":8552,"id":245239,"goal":"predicate AllPositive_8552(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_8553","instance":8553,"id":245240,"goal":"predicate DistinctSeq_8553(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_8554","instance":8554,"id":245241,"goal":"predicate IsSubseq_8554(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_8555","instance":8555,"id":245242,"goal":"predicate IsPermutation_8555(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_8556","instance":8556,"id":245243,"goal":"predicate IsEven_8556(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_8557","instance":8557,"id":245244,"goal":"predicate InRange_8557(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_8558","instance":8558,"id":245245,"goal":"predicate SubsetOf_8558(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_8559","instance":8559,"id":245246,"goal":"predicate AllMem_8559(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_8560","instance":8560,"id":245247,"goal":"predicate DisjointSets_8560(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_8561","instance":8561,"id":245248,"goal":"predicate Sorted_8561(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_8562","instance":8562,"id":245249,"goal":"predicate AllPositive_8562(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_8563","instance":8563,"id":245250,"goal":"predicate DistinctSeq_8563(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_8564","instance":8564,"id":245251,"goal":"predicate IsSubseq_8564(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_8565","instance":8565,"id":245252,"goal":"predicate IsPermutation_8565(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_8566","instance":8566,"id":245253,"goal":"predicate IsEven_8566(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_8567","instance":8567,"id":245254,"goal":"predicate InRange_8567(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_8568","instance":8568,"id":245255,"goal":"predicate SubsetOf_8568(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_8569","instance":8569,"id":245256,"goal":"predicate AllMem_8569(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_8570","instance":8570,"id":245257,"goal":"predicate DisjointSets_8570(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_8571","instance":8571,"id":245258,"goal":"predicate Sorted_8571(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_8572","instance":8572,"id":245259,"goal":"predicate AllPositive_8572(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_8573","instance":8573,"id":245260,"goal":"predicate DistinctSeq_8573(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_8574","instance":8574,"id":245261,"goal":"predicate IsSubseq_8574(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_8575","instance":8575,"id":245262,"goal":"predicate IsPermutation_8575(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_8576","instance":8576,"id":245263,"goal":"predicate IsEven_8576(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_8577","instance":8577,"id":245264,"goal":"predicate InRange_8577(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_8578","instance":8578,"id":245265,"goal":"predicate SubsetOf_8578(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_8579","instance":8579,"id":245266,"goal":"predicate AllMem_8579(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_8580","instance":8580,"id":245267,"goal":"predicate DisjointSets_8580(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_8581","instance":8581,"id":245268,"goal":"predicate Sorted_8581(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_8582","instance":8582,"id":245269,"goal":"predicate AllPositive_8582(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_8583","instance":8583,"id":245270,"goal":"predicate DistinctSeq_8583(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_8584","instance":8584,"id":245271,"goal":"predicate IsSubseq_8584(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_8585","instance":8585,"id":245272,"goal":"predicate IsPermutation_8585(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_8586","instance":8586,"id":245273,"goal":"predicate IsEven_8586(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_8587","instance":8587,"id":245274,"goal":"predicate InRange_8587(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_8588","instance":8588,"id":245275,"goal":"predicate SubsetOf_8588(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_8589","instance":8589,"id":245276,"goal":"predicate AllMem_8589(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_8590","instance":8590,"id":245277,"goal":"predicate DisjointSets_8590(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_8591","instance":8591,"id":245278,"goal":"predicate Sorted_8591(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_8592","instance":8592,"id":245279,"goal":"predicate AllPositive_8592(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_8593","instance":8593,"id":245280,"goal":"predicate DistinctSeq_8593(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_8594","instance":8594,"id":245281,"goal":"predicate IsSubseq_8594(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_8595","instance":8595,"id":245282,"goal":"predicate IsPermutation_8595(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_8596","instance":8596,"id":245283,"goal":"predicate IsEven_8596(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_8597","instance":8597,"id":245284,"goal":"predicate InRange_8597(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_8598","instance":8598,"id":245285,"goal":"predicate SubsetOf_8598(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_8599","instance":8599,"id":245286,"goal":"predicate AllMem_8599(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_8600","instance":8600,"id":245287,"goal":"predicate DisjointSets_8600(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_8601","instance":8601,"id":245288,"goal":"predicate Sorted_8601(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_8602","instance":8602,"id":245289,"goal":"predicate AllPositive_8602(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_8603","instance":8603,"id":245290,"goal":"predicate DistinctSeq_8603(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_8604","instance":8604,"id":245291,"goal":"predicate IsSubseq_8604(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_8605","instance":8605,"id":245292,"goal":"predicate IsPermutation_8605(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_8606","instance":8606,"id":245293,"goal":"predicate IsEven_8606(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_8607","instance":8607,"id":245294,"goal":"predicate InRange_8607(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_8608","instance":8608,"id":245295,"goal":"predicate SubsetOf_8608(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_8609","instance":8609,"id":245296,"goal":"predicate AllMem_8609(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_8610","instance":8610,"id":245297,"goal":"predicate DisjointSets_8610(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_8611","instance":8611,"id":245298,"goal":"predicate Sorted_8611(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_8612","instance":8612,"id":245299,"goal":"predicate AllPositive_8612(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_8613","instance":8613,"id":245300,"goal":"predicate DistinctSeq_8613(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_8614","instance":8614,"id":245301,"goal":"predicate IsSubseq_8614(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_8615","instance":8615,"id":245302,"goal":"predicate IsPermutation_8615(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_8616","instance":8616,"id":245303,"goal":"predicate IsEven_8616(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_8617","instance":8617,"id":245304,"goal":"predicate InRange_8617(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_8618","instance":8618,"id":245305,"goal":"predicate SubsetOf_8618(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_8619","instance":8619,"id":245306,"goal":"predicate AllMem_8619(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_8620","instance":8620,"id":245307,"goal":"predicate DisjointSets_8620(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_8621","instance":8621,"id":245308,"goal":"predicate Sorted_8621(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_8622","instance":8622,"id":245309,"goal":"predicate AllPositive_8622(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_8623","instance":8623,"id":245310,"goal":"predicate DistinctSeq_8623(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_8624","instance":8624,"id":245311,"goal":"predicate IsSubseq_8624(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_8625","instance":8625,"id":245312,"goal":"predicate IsPermutation_8625(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_8626","instance":8626,"id":245313,"goal":"predicate IsEven_8626(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_8627","instance":8627,"id":245314,"goal":"predicate InRange_8627(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_8628","instance":8628,"id":245315,"goal":"predicate SubsetOf_8628(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_8629","instance":8629,"id":245316,"goal":"predicate AllMem_8629(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_8630","instance":8630,"id":245317,"goal":"predicate DisjointSets_8630(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_8631","instance":8631,"id":245318,"goal":"predicate Sorted_8631(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_8632","instance":8632,"id":245319,"goal":"predicate AllPositive_8632(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_8633","instance":8633,"id":245320,"goal":"predicate DistinctSeq_8633(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_8634","instance":8634,"id":245321,"goal":"predicate IsSubseq_8634(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_8635","instance":8635,"id":245322,"goal":"predicate IsPermutation_8635(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_8636","instance":8636,"id":245323,"goal":"predicate IsEven_8636(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_8637","instance":8637,"id":245324,"goal":"predicate InRange_8637(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_8638","instance":8638,"id":245325,"goal":"predicate SubsetOf_8638(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_8639","instance":8639,"id":245326,"goal":"predicate AllMem_8639(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_8640","instance":8640,"id":245327,"goal":"predicate DisjointSets_8640(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_8641","instance":8641,"id":245328,"goal":"predicate Sorted_8641(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_8642","instance":8642,"id":245329,"goal":"predicate AllPositive_8642(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_8643","instance":8643,"id":245330,"goal":"predicate DistinctSeq_8643(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_8644","instance":8644,"id":245331,"goal":"predicate IsSubseq_8644(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_8645","instance":8645,"id":245332,"goal":"predicate IsPermutation_8645(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_8646","instance":8646,"id":245333,"goal":"predicate IsEven_8646(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_8647","instance":8647,"id":245334,"goal":"predicate InRange_8647(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_8648","instance":8648,"id":245335,"goal":"predicate SubsetOf_8648(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_8649","instance":8649,"id":245336,"goal":"predicate AllMem_8649(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_8650","instance":8650,"id":245337,"goal":"predicate DisjointSets_8650(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_8651","instance":8651,"id":245338,"goal":"predicate Sorted_8651(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_8652","instance":8652,"id":245339,"goal":"predicate AllPositive_8652(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_8653","instance":8653,"id":245340,"goal":"predicate DistinctSeq_8653(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_8654","instance":8654,"id":245341,"goal":"predicate IsSubseq_8654(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_8655","instance":8655,"id":245342,"goal":"predicate IsPermutation_8655(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_8656","instance":8656,"id":245343,"goal":"predicate IsEven_8656(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_8657","instance":8657,"id":245344,"goal":"predicate InRange_8657(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_8658","instance":8658,"id":245345,"goal":"predicate SubsetOf_8658(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_8659","instance":8659,"id":245346,"goal":"predicate AllMem_8659(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_8660","instance":8660,"id":245347,"goal":"predicate DisjointSets_8660(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_8661","instance":8661,"id":245348,"goal":"predicate Sorted_8661(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_8662","instance":8662,"id":245349,"goal":"predicate AllPositive_8662(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_8663","instance":8663,"id":245350,"goal":"predicate DistinctSeq_8663(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_8664","instance":8664,"id":245351,"goal":"predicate IsSubseq_8664(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_8665","instance":8665,"id":245352,"goal":"predicate IsPermutation_8665(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_8666","instance":8666,"id":245353,"goal":"predicate IsEven_8666(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_8667","instance":8667,"id":245354,"goal":"predicate InRange_8667(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_8668","instance":8668,"id":245355,"goal":"predicate SubsetOf_8668(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_8669","instance":8669,"id":245356,"goal":"predicate AllMem_8669(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_8670","instance":8670,"id":245357,"goal":"predicate DisjointSets_8670(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_8671","instance":8671,"id":245358,"goal":"predicate Sorted_8671(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_8672","instance":8672,"id":245359,"goal":"predicate AllPositive_8672(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_8673","instance":8673,"id":245360,"goal":"predicate DistinctSeq_8673(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_8674","instance":8674,"id":245361,"goal":"predicate IsSubseq_8674(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_8675","instance":8675,"id":245362,"goal":"predicate IsPermutation_8675(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_8676","instance":8676,"id":245363,"goal":"predicate IsEven_8676(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_8677","instance":8677,"id":245364,"goal":"predicate InRange_8677(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_8678","instance":8678,"id":245365,"goal":"predicate SubsetOf_8678(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_8679","instance":8679,"id":245366,"goal":"predicate AllMem_8679(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_8680","instance":8680,"id":245367,"goal":"predicate DisjointSets_8680(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_8681","instance":8681,"id":245368,"goal":"predicate Sorted_8681(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_8682","instance":8682,"id":245369,"goal":"predicate AllPositive_8682(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_8683","instance":8683,"id":245370,"goal":"predicate DistinctSeq_8683(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_8684","instance":8684,"id":245371,"goal":"predicate IsSubseq_8684(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_8685","instance":8685,"id":245372,"goal":"predicate IsPermutation_8685(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_8686","instance":8686,"id":245373,"goal":"predicate IsEven_8686(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_8687","instance":8687,"id":245374,"goal":"predicate InRange_8687(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_8688","instance":8688,"id":245375,"goal":"predicate SubsetOf_8688(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_8689","instance":8689,"id":245376,"goal":"predicate AllMem_8689(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_8690","instance":8690,"id":245377,"goal":"predicate DisjointSets_8690(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_8691","instance":8691,"id":245378,"goal":"predicate Sorted_8691(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_8692","instance":8692,"id":245379,"goal":"predicate AllPositive_8692(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_8693","instance":8693,"id":245380,"goal":"predicate DistinctSeq_8693(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_8694","instance":8694,"id":245381,"goal":"predicate IsSubseq_8694(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_8695","instance":8695,"id":245382,"goal":"predicate IsPermutation_8695(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_8696","instance":8696,"id":245383,"goal":"predicate IsEven_8696(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_8697","instance":8697,"id":245384,"goal":"predicate InRange_8697(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_8698","instance":8698,"id":245385,"goal":"predicate SubsetOf_8698(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_8699","instance":8699,"id":245386,"goal":"predicate AllMem_8699(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_8700","instance":8700,"id":245387,"goal":"predicate DisjointSets_8700(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_8701","instance":8701,"id":245388,"goal":"predicate Sorted_8701(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_8702","instance":8702,"id":245389,"goal":"predicate AllPositive_8702(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_8703","instance":8703,"id":245390,"goal":"predicate DistinctSeq_8703(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_8704","instance":8704,"id":245391,"goal":"predicate IsSubseq_8704(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_8705","instance":8705,"id":245392,"goal":"predicate IsPermutation_8705(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_8706","instance":8706,"id":245393,"goal":"predicate IsEven_8706(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_8707","instance":8707,"id":245394,"goal":"predicate InRange_8707(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_8708","instance":8708,"id":245395,"goal":"predicate SubsetOf_8708(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_8709","instance":8709,"id":245396,"goal":"predicate AllMem_8709(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_8710","instance":8710,"id":245397,"goal":"predicate DisjointSets_8710(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_8711","instance":8711,"id":245398,"goal":"predicate Sorted_8711(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_8712","instance":8712,"id":245399,"goal":"predicate AllPositive_8712(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_8713","instance":8713,"id":245400,"goal":"predicate DistinctSeq_8713(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_8714","instance":8714,"id":245401,"goal":"predicate IsSubseq_8714(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_8715","instance":8715,"id":245402,"goal":"predicate IsPermutation_8715(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_8716","instance":8716,"id":245403,"goal":"predicate IsEven_8716(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_8717","instance":8717,"id":245404,"goal":"predicate InRange_8717(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_8718","instance":8718,"id":245405,"goal":"predicate SubsetOf_8718(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_8719","instance":8719,"id":245406,"goal":"predicate AllMem_8719(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_8720","instance":8720,"id":245407,"goal":"predicate DisjointSets_8720(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_8721","instance":8721,"id":245408,"goal":"predicate Sorted_8721(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_8722","instance":8722,"id":245409,"goal":"predicate AllPositive_8722(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_8723","instance":8723,"id":245410,"goal":"predicate DistinctSeq_8723(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_8724","instance":8724,"id":245411,"goal":"predicate IsSubseq_8724(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_8725","instance":8725,"id":245412,"goal":"predicate IsPermutation_8725(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_8726","instance":8726,"id":245413,"goal":"predicate IsEven_8726(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_8727","instance":8727,"id":245414,"goal":"predicate InRange_8727(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_8728","instance":8728,"id":245415,"goal":"predicate SubsetOf_8728(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_8729","instance":8729,"id":245416,"goal":"predicate AllMem_8729(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_8730","instance":8730,"id":245417,"goal":"predicate DisjointSets_8730(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_8731","instance":8731,"id":245418,"goal":"predicate Sorted_8731(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_8732","instance":8732,"id":245419,"goal":"predicate AllPositive_8732(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_8733","instance":8733,"id":245420,"goal":"predicate DistinctSeq_8733(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_8734","instance":8734,"id":245421,"goal":"predicate IsSubseq_8734(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_8735","instance":8735,"id":245422,"goal":"predicate IsPermutation_8735(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_8736","instance":8736,"id":245423,"goal":"predicate IsEven_8736(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_8737","instance":8737,"id":245424,"goal":"predicate InRange_8737(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_8738","instance":8738,"id":245425,"goal":"predicate SubsetOf_8738(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_8739","instance":8739,"id":245426,"goal":"predicate AllMem_8739(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_8740","instance":8740,"id":245427,"goal":"predicate DisjointSets_8740(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_8741","instance":8741,"id":245428,"goal":"predicate Sorted_8741(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_8742","instance":8742,"id":245429,"goal":"predicate AllPositive_8742(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_8743","instance":8743,"id":245430,"goal":"predicate DistinctSeq_8743(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_8744","instance":8744,"id":245431,"goal":"predicate IsSubseq_8744(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_8745","instance":8745,"id":245432,"goal":"predicate IsPermutation_8745(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_8746","instance":8746,"id":245433,"goal":"predicate IsEven_8746(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_8747","instance":8747,"id":245434,"goal":"predicate InRange_8747(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_8748","instance":8748,"id":245435,"goal":"predicate SubsetOf_8748(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_8749","instance":8749,"id":245436,"goal":"predicate AllMem_8749(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_8750","instance":8750,"id":245437,"goal":"predicate DisjointSets_8750(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_8751","instance":8751,"id":245438,"goal":"predicate Sorted_8751(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_8752","instance":8752,"id":245439,"goal":"predicate AllPositive_8752(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_8753","instance":8753,"id":245440,"goal":"predicate DistinctSeq_8753(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_8754","instance":8754,"id":245441,"goal":"predicate IsSubseq_8754(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_8755","instance":8755,"id":245442,"goal":"predicate IsPermutation_8755(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_8756","instance":8756,"id":245443,"goal":"predicate IsEven_8756(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_8757","instance":8757,"id":245444,"goal":"predicate InRange_8757(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_8758","instance":8758,"id":245445,"goal":"predicate SubsetOf_8758(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_8759","instance":8759,"id":245446,"goal":"predicate AllMem_8759(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_8760","instance":8760,"id":245447,"goal":"predicate DisjointSets_8760(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_8761","instance":8761,"id":245448,"goal":"predicate Sorted_8761(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_8762","instance":8762,"id":245449,"goal":"predicate AllPositive_8762(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_8763","instance":8763,"id":245450,"goal":"predicate DistinctSeq_8763(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_8764","instance":8764,"id":245451,"goal":"predicate IsSubseq_8764(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_8765","instance":8765,"id":245452,"goal":"predicate IsPermutation_8765(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_8766","instance":8766,"id":245453,"goal":"predicate IsEven_8766(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_8767","instance":8767,"id":245454,"goal":"predicate InRange_8767(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_8768","instance":8768,"id":245455,"goal":"predicate SubsetOf_8768(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_8769","instance":8769,"id":245456,"goal":"predicate AllMem_8769(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_8770","instance":8770,"id":245457,"goal":"predicate DisjointSets_8770(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_8771","instance":8771,"id":245458,"goal":"predicate Sorted_8771(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_8772","instance":8772,"id":245459,"goal":"predicate AllPositive_8772(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_8773","instance":8773,"id":245460,"goal":"predicate DistinctSeq_8773(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_8774","instance":8774,"id":245461,"goal":"predicate IsSubseq_8774(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_8775","instance":8775,"id":245462,"goal":"predicate IsPermutation_8775(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_8776","instance":8776,"id":245463,"goal":"predicate IsEven_8776(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_8777","instance":8777,"id":245464,"goal":"predicate InRange_8777(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_8778","instance":8778,"id":245465,"goal":"predicate SubsetOf_8778(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_8779","instance":8779,"id":245466,"goal":"predicate AllMem_8779(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_8780","instance":8780,"id":245467,"goal":"predicate DisjointSets_8780(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_8781","instance":8781,"id":245468,"goal":"predicate Sorted_8781(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_8782","instance":8782,"id":245469,"goal":"predicate AllPositive_8782(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_8783","instance":8783,"id":245470,"goal":"predicate DistinctSeq_8783(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_8784","instance":8784,"id":245471,"goal":"predicate IsSubseq_8784(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_8785","instance":8785,"id":245472,"goal":"predicate IsPermutation_8785(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_8786","instance":8786,"id":245473,"goal":"predicate IsEven_8786(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_8787","instance":8787,"id":245474,"goal":"predicate InRange_8787(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_8788","instance":8788,"id":245475,"goal":"predicate SubsetOf_8788(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_8789","instance":8789,"id":245476,"goal":"predicate AllMem_8789(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_8790","instance":8790,"id":245477,"goal":"predicate DisjointSets_8790(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_8791","instance":8791,"id":245478,"goal":"predicate Sorted_8791(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_8792","instance":8792,"id":245479,"goal":"predicate AllPositive_8792(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_8793","instance":8793,"id":245480,"goal":"predicate DistinctSeq_8793(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_8794","instance":8794,"id":245481,"goal":"predicate IsSubseq_8794(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_8795","instance":8795,"id":245482,"goal":"predicate IsPermutation_8795(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_8796","instance":8796,"id":245483,"goal":"predicate IsEven_8796(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_8797","instance":8797,"id":245484,"goal":"predicate InRange_8797(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_8798","instance":8798,"id":245485,"goal":"predicate SubsetOf_8798(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_8799","instance":8799,"id":245486,"goal":"predicate AllMem_8799(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_8800","instance":8800,"id":245487,"goal":"predicate DisjointSets_8800(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_8801","instance":8801,"id":245488,"goal":"predicate Sorted_8801(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_8802","instance":8802,"id":245489,"goal":"predicate AllPositive_8802(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_8803","instance":8803,"id":245490,"goal":"predicate DistinctSeq_8803(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_8804","instance":8804,"id":245491,"goal":"predicate IsSubseq_8804(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_8805","instance":8805,"id":245492,"goal":"predicate IsPermutation_8805(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_8806","instance":8806,"id":245493,"goal":"predicate IsEven_8806(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_8807","instance":8807,"id":245494,"goal":"predicate InRange_8807(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_8808","instance":8808,"id":245495,"goal":"predicate SubsetOf_8808(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_8809","instance":8809,"id":245496,"goal":"predicate AllMem_8809(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_8810","instance":8810,"id":245497,"goal":"predicate DisjointSets_8810(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_8811","instance":8811,"id":245498,"goal":"predicate Sorted_8811(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_8812","instance":8812,"id":245499,"goal":"predicate AllPositive_8812(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_8813","instance":8813,"id":245500,"goal":"predicate DistinctSeq_8813(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_8814","instance":8814,"id":245501,"goal":"predicate IsSubseq_8814(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_8815","instance":8815,"id":245502,"goal":"predicate IsPermutation_8815(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_8816","instance":8816,"id":245503,"goal":"predicate IsEven_8816(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_8817","instance":8817,"id":245504,"goal":"predicate InRange_8817(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_8818","instance":8818,"id":245505,"goal":"predicate SubsetOf_8818(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_8819","instance":8819,"id":245506,"goal":"predicate AllMem_8819(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_8820","instance":8820,"id":245507,"goal":"predicate DisjointSets_8820(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_8821","instance":8821,"id":245508,"goal":"predicate Sorted_8821(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_8822","instance":8822,"id":245509,"goal":"predicate AllPositive_8822(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_8823","instance":8823,"id":245510,"goal":"predicate DistinctSeq_8823(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_8824","instance":8824,"id":245511,"goal":"predicate IsSubseq_8824(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_8825","instance":8825,"id":245512,"goal":"predicate IsPermutation_8825(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_8826","instance":8826,"id":245513,"goal":"predicate IsEven_8826(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_8827","instance":8827,"id":245514,"goal":"predicate InRange_8827(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_8828","instance":8828,"id":245515,"goal":"predicate SubsetOf_8828(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_8829","instance":8829,"id":245516,"goal":"predicate AllMem_8829(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_8830","instance":8830,"id":245517,"goal":"predicate DisjointSets_8830(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_8831","instance":8831,"id":245518,"goal":"predicate Sorted_8831(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_8832","instance":8832,"id":245519,"goal":"predicate AllPositive_8832(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_8833","instance":8833,"id":245520,"goal":"predicate DistinctSeq_8833(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_8834","instance":8834,"id":245521,"goal":"predicate IsSubseq_8834(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_8835","instance":8835,"id":245522,"goal":"predicate IsPermutation_8835(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_8836","instance":8836,"id":245523,"goal":"predicate IsEven_8836(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_8837","instance":8837,"id":245524,"goal":"predicate InRange_8837(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_8838","instance":8838,"id":245525,"goal":"predicate SubsetOf_8838(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_8839","instance":8839,"id":245526,"goal":"predicate AllMem_8839(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_8840","instance":8840,"id":245527,"goal":"predicate DisjointSets_8840(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_8841","instance":8841,"id":245528,"goal":"predicate Sorted_8841(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_8842","instance":8842,"id":245529,"goal":"predicate AllPositive_8842(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_8843","instance":8843,"id":245530,"goal":"predicate DistinctSeq_8843(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_8844","instance":8844,"id":245531,"goal":"predicate IsSubseq_8844(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_8845","instance":8845,"id":245532,"goal":"predicate IsPermutation_8845(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_8846","instance":8846,"id":245533,"goal":"predicate IsEven_8846(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_8847","instance":8847,"id":245534,"goal":"predicate InRange_8847(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_8848","instance":8848,"id":245535,"goal":"predicate SubsetOf_8848(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_8849","instance":8849,"id":245536,"goal":"predicate AllMem_8849(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_8850","instance":8850,"id":245537,"goal":"predicate DisjointSets_8850(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_8851","instance":8851,"id":245538,"goal":"predicate Sorted_8851(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_8852","instance":8852,"id":245539,"goal":"predicate AllPositive_8852(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_8853","instance":8853,"id":245540,"goal":"predicate DistinctSeq_8853(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_8854","instance":8854,"id":245541,"goal":"predicate IsSubseq_8854(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_8855","instance":8855,"id":245542,"goal":"predicate IsPermutation_8855(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_8856","instance":8856,"id":245543,"goal":"predicate IsEven_8856(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_8857","instance":8857,"id":245544,"goal":"predicate InRange_8857(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_8858","instance":8858,"id":245545,"goal":"predicate SubsetOf_8858(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_8859","instance":8859,"id":245546,"goal":"predicate AllMem_8859(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_8860","instance":8860,"id":245547,"goal":"predicate DisjointSets_8860(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_8861","instance":8861,"id":245548,"goal":"predicate Sorted_8861(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_8862","instance":8862,"id":245549,"goal":"predicate AllPositive_8862(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_8863","instance":8863,"id":245550,"goal":"predicate DistinctSeq_8863(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_8864","instance":8864,"id":245551,"goal":"predicate IsSubseq_8864(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_8865","instance":8865,"id":245552,"goal":"predicate IsPermutation_8865(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_8866","instance":8866,"id":245553,"goal":"predicate IsEven_8866(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_8867","instance":8867,"id":245554,"goal":"predicate InRange_8867(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_8868","instance":8868,"id":245555,"goal":"predicate SubsetOf_8868(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_8869","instance":8869,"id":245556,"goal":"predicate AllMem_8869(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_8870","instance":8870,"id":245557,"goal":"predicate DisjointSets_8870(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_8871","instance":8871,"id":245558,"goal":"predicate Sorted_8871(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_8872","instance":8872,"id":245559,"goal":"predicate AllPositive_8872(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_8873","instance":8873,"id":245560,"goal":"predicate DistinctSeq_8873(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_8874","instance":8874,"id":245561,"goal":"predicate IsSubseq_8874(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_8875","instance":8875,"id":245562,"goal":"predicate IsPermutation_8875(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_8876","instance":8876,"id":245563,"goal":"predicate IsEven_8876(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_8877","instance":8877,"id":245564,"goal":"predicate InRange_8877(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_8878","instance":8878,"id":245565,"goal":"predicate SubsetOf_8878(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_8879","instance":8879,"id":245566,"goal":"predicate AllMem_8879(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_8880","instance":8880,"id":245567,"goal":"predicate DisjointSets_8880(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_8881","instance":8881,"id":245568,"goal":"predicate Sorted_8881(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_8882","instance":8882,"id":245569,"goal":"predicate AllPositive_8882(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_8883","instance":8883,"id":245570,"goal":"predicate DistinctSeq_8883(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_8884","instance":8884,"id":245571,"goal":"predicate IsSubseq_8884(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_8885","instance":8885,"id":245572,"goal":"predicate IsPermutation_8885(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_8886","instance":8886,"id":245573,"goal":"predicate IsEven_8886(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_8887","instance":8887,"id":245574,"goal":"predicate InRange_8887(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_8888","instance":8888,"id":245575,"goal":"predicate SubsetOf_8888(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_8889","instance":8889,"id":245576,"goal":"predicate AllMem_8889(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_8890","instance":8890,"id":245577,"goal":"predicate DisjointSets_8890(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_8891","instance":8891,"id":245578,"goal":"predicate Sorted_8891(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_8892","instance":8892,"id":245579,"goal":"predicate AllPositive_8892(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_8893","instance":8893,"id":245580,"goal":"predicate DistinctSeq_8893(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_8894","instance":8894,"id":245581,"goal":"predicate IsSubseq_8894(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_8895","instance":8895,"id":245582,"goal":"predicate IsPermutation_8895(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_8896","instance":8896,"id":245583,"goal":"predicate IsEven_8896(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_8897","instance":8897,"id":245584,"goal":"predicate InRange_8897(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_8898","instance":8898,"id":245585,"goal":"predicate SubsetOf_8898(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_8899","instance":8899,"id":245586,"goal":"predicate AllMem_8899(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_8900","instance":8900,"id":245587,"goal":"predicate DisjointSets_8900(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_8901","instance":8901,"id":245588,"goal":"predicate Sorted_8901(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_8902","instance":8902,"id":245589,"goal":"predicate AllPositive_8902(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_8903","instance":8903,"id":245590,"goal":"predicate DistinctSeq_8903(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_8904","instance":8904,"id":245591,"goal":"predicate IsSubseq_8904(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_8905","instance":8905,"id":245592,"goal":"predicate IsPermutation_8905(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_8906","instance":8906,"id":245593,"goal":"predicate IsEven_8906(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_8907","instance":8907,"id":245594,"goal":"predicate InRange_8907(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_8908","instance":8908,"id":245595,"goal":"predicate SubsetOf_8908(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_8909","instance":8909,"id":245596,"goal":"predicate AllMem_8909(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_8910","instance":8910,"id":245597,"goal":"predicate DisjointSets_8910(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_8911","instance":8911,"id":245598,"goal":"predicate Sorted_8911(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_8912","instance":8912,"id":245599,"goal":"predicate AllPositive_8912(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_8913","instance":8913,"id":245600,"goal":"predicate DistinctSeq_8913(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_8914","instance":8914,"id":245601,"goal":"predicate IsSubseq_8914(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_8915","instance":8915,"id":245602,"goal":"predicate IsPermutation_8915(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_8916","instance":8916,"id":245603,"goal":"predicate IsEven_8916(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_8917","instance":8917,"id":245604,"goal":"predicate InRange_8917(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_8918","instance":8918,"id":245605,"goal":"predicate SubsetOf_8918(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_8919","instance":8919,"id":245606,"goal":"predicate AllMem_8919(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_8920","instance":8920,"id":245607,"goal":"predicate DisjointSets_8920(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_8921","instance":8921,"id":245608,"goal":"predicate Sorted_8921(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_8922","instance":8922,"id":245609,"goal":"predicate AllPositive_8922(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_8923","instance":8923,"id":245610,"goal":"predicate DistinctSeq_8923(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_8924","instance":8924,"id":245611,"goal":"predicate IsSubseq_8924(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_8925","instance":8925,"id":245612,"goal":"predicate IsPermutation_8925(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_8926","instance":8926,"id":245613,"goal":"predicate IsEven_8926(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_8927","instance":8927,"id":245614,"goal":"predicate InRange_8927(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_8928","instance":8928,"id":245615,"goal":"predicate SubsetOf_8928(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_8929","instance":8929,"id":245616,"goal":"predicate AllMem_8929(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_8930","instance":8930,"id":245617,"goal":"predicate DisjointSets_8930(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_8931","instance":8931,"id":245618,"goal":"predicate Sorted_8931(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_8932","instance":8932,"id":245619,"goal":"predicate AllPositive_8932(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_8933","instance":8933,"id":245620,"goal":"predicate DistinctSeq_8933(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_8934","instance":8934,"id":245621,"goal":"predicate IsSubseq_8934(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_8935","instance":8935,"id":245622,"goal":"predicate IsPermutation_8935(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_8936","instance":8936,"id":245623,"goal":"predicate IsEven_8936(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_8937","instance":8937,"id":245624,"goal":"predicate InRange_8937(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_8938","instance":8938,"id":245625,"goal":"predicate SubsetOf_8938(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_8939","instance":8939,"id":245626,"goal":"predicate AllMem_8939(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_8940","instance":8940,"id":245627,"goal":"predicate DisjointSets_8940(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_8941","instance":8941,"id":245628,"goal":"predicate Sorted_8941(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_8942","instance":8942,"id":245629,"goal":"predicate AllPositive_8942(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_8943","instance":8943,"id":245630,"goal":"predicate DistinctSeq_8943(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_8944","instance":8944,"id":245631,"goal":"predicate IsSubseq_8944(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_8945","instance":8945,"id":245632,"goal":"predicate IsPermutation_8945(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_8946","instance":8946,"id":245633,"goal":"predicate IsEven_8946(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_8947","instance":8947,"id":245634,"goal":"predicate InRange_8947(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_8948","instance":8948,"id":245635,"goal":"predicate SubsetOf_8948(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_8949","instance":8949,"id":245636,"goal":"predicate AllMem_8949(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_8950","instance":8950,"id":245637,"goal":"predicate DisjointSets_8950(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_8951","instance":8951,"id":245638,"goal":"predicate Sorted_8951(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_8952","instance":8952,"id":245639,"goal":"predicate AllPositive_8952(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_8953","instance":8953,"id":245640,"goal":"predicate DistinctSeq_8953(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_8954","instance":8954,"id":245641,"goal":"predicate IsSubseq_8954(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_8955","instance":8955,"id":245642,"goal":"predicate IsPermutation_8955(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_8956","instance":8956,"id":245643,"goal":"predicate IsEven_8956(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_8957","instance":8957,"id":245644,"goal":"predicate InRange_8957(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_8958","instance":8958,"id":245645,"goal":"predicate SubsetOf_8958(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_8959","instance":8959,"id":245646,"goal":"predicate AllMem_8959(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_8960","instance":8960,"id":245647,"goal":"predicate DisjointSets_8960(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_8961","instance":8961,"id":245648,"goal":"predicate Sorted_8961(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_8962","instance":8962,"id":245649,"goal":"predicate AllPositive_8962(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_8963","instance":8963,"id":245650,"goal":"predicate DistinctSeq_8963(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_8964","instance":8964,"id":245651,"goal":"predicate IsSubseq_8964(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_8965","instance":8965,"id":245652,"goal":"predicate IsPermutation_8965(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_8966","instance":8966,"id":245653,"goal":"predicate IsEven_8966(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_8967","instance":8967,"id":245654,"goal":"predicate InRange_8967(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_8968","instance":8968,"id":245655,"goal":"predicate SubsetOf_8968(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_8969","instance":8969,"id":245656,"goal":"predicate AllMem_8969(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_8970","instance":8970,"id":245657,"goal":"predicate DisjointSets_8970(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_8971","instance":8971,"id":245658,"goal":"predicate Sorted_8971(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_8972","instance":8972,"id":245659,"goal":"predicate AllPositive_8972(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_8973","instance":8973,"id":245660,"goal":"predicate DistinctSeq_8973(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_8974","instance":8974,"id":245661,"goal":"predicate IsSubseq_8974(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_8975","instance":8975,"id":245662,"goal":"predicate IsPermutation_8975(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_8976","instance":8976,"id":245663,"goal":"predicate IsEven_8976(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_8977","instance":8977,"id":245664,"goal":"predicate InRange_8977(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_8978","instance":8978,"id":245665,"goal":"predicate SubsetOf_8978(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_8979","instance":8979,"id":245666,"goal":"predicate AllMem_8979(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_8980","instance":8980,"id":245667,"goal":"predicate DisjointSets_8980(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_8981","instance":8981,"id":245668,"goal":"predicate Sorted_8981(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_8982","instance":8982,"id":245669,"goal":"predicate AllPositive_8982(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_8983","instance":8983,"id":245670,"goal":"predicate DistinctSeq_8983(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_8984","instance":8984,"id":245671,"goal":"predicate IsSubseq_8984(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_8985","instance":8985,"id":245672,"goal":"predicate IsPermutation_8985(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_8986","instance":8986,"id":245673,"goal":"predicate IsEven_8986(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_8987","instance":8987,"id":245674,"goal":"predicate InRange_8987(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_8988","instance":8988,"id":245675,"goal":"predicate SubsetOf_8988(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_8989","instance":8989,"id":245676,"goal":"predicate AllMem_8989(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_8990","instance":8990,"id":245677,"goal":"predicate DisjointSets_8990(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_8991","instance":8991,"id":245678,"goal":"predicate Sorted_8991(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_8992","instance":8992,"id":245679,"goal":"predicate AllPositive_8992(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_8993","instance":8993,"id":245680,"goal":"predicate DistinctSeq_8993(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_8994","instance":8994,"id":245681,"goal":"predicate IsSubseq_8994(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_8995","instance":8995,"id":245682,"goal":"predicate IsPermutation_8995(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_8996","instance":8996,"id":245683,"goal":"predicate IsEven_8996(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_8997","instance":8997,"id":245684,"goal":"predicate InRange_8997(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_8998","instance":8998,"id":245685,"goal":"predicate SubsetOf_8998(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_8999","instance":8999,"id":245686,"goal":"predicate AllMem_8999(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_9000","instance":9000,"id":245687,"goal":"predicate DisjointSets_9000(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_9001","instance":9001,"id":245688,"goal":"predicate Sorted_9001(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_9002","instance":9002,"id":245689,"goal":"predicate AllPositive_9002(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_9003","instance":9003,"id":245690,"goal":"predicate DistinctSeq_9003(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_9004","instance":9004,"id":245691,"goal":"predicate IsSubseq_9004(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_9005","instance":9005,"id":245692,"goal":"predicate IsPermutation_9005(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_9006","instance":9006,"id":245693,"goal":"predicate IsEven_9006(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_9007","instance":9007,"id":245694,"goal":"predicate InRange_9007(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_9008","instance":9008,"id":245695,"goal":"predicate SubsetOf_9008(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_9009","instance":9009,"id":245696,"goal":"predicate AllMem_9009(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_9010","instance":9010,"id":245697,"goal":"predicate DisjointSets_9010(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_9011","instance":9011,"id":245698,"goal":"predicate Sorted_9011(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_9012","instance":9012,"id":245699,"goal":"predicate AllPositive_9012(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_9013","instance":9013,"id":245700,"goal":"predicate DistinctSeq_9013(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_9014","instance":9014,"id":245701,"goal":"predicate IsSubseq_9014(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_9015","instance":9015,"id":245702,"goal":"predicate IsPermutation_9015(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_9016","instance":9016,"id":245703,"goal":"predicate IsEven_9016(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_9017","instance":9017,"id":245704,"goal":"predicate InRange_9017(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_9018","instance":9018,"id":245705,"goal":"predicate SubsetOf_9018(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_9019","instance":9019,"id":245706,"goal":"predicate AllMem_9019(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_9020","instance":9020,"id":245707,"goal":"predicate DisjointSets_9020(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_9021","instance":9021,"id":245708,"goal":"predicate Sorted_9021(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_9022","instance":9022,"id":245709,"goal":"predicate AllPositive_9022(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_9023","instance":9023,"id":245710,"goal":"predicate DistinctSeq_9023(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_9024","instance":9024,"id":245711,"goal":"predicate IsSubseq_9024(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_9025","instance":9025,"id":245712,"goal":"predicate IsPermutation_9025(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_9026","instance":9026,"id":245713,"goal":"predicate IsEven_9026(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_9027","instance":9027,"id":245714,"goal":"predicate InRange_9027(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_9028","instance":9028,"id":245715,"goal":"predicate SubsetOf_9028(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_9029","instance":9029,"id":245716,"goal":"predicate AllMem_9029(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_9030","instance":9030,"id":245717,"goal":"predicate DisjointSets_9030(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_9031","instance":9031,"id":245718,"goal":"predicate Sorted_9031(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_9032","instance":9032,"id":245719,"goal":"predicate AllPositive_9032(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_9033","instance":9033,"id":245720,"goal":"predicate DistinctSeq_9033(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_9034","instance":9034,"id":245721,"goal":"predicate IsSubseq_9034(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_9035","instance":9035,"id":245722,"goal":"predicate IsPermutation_9035(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_9036","instance":9036,"id":245723,"goal":"predicate IsEven_9036(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_9037","instance":9037,"id":245724,"goal":"predicate InRange_9037(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_9038","instance":9038,"id":245725,"goal":"predicate SubsetOf_9038(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_9039","instance":9039,"id":245726,"goal":"predicate AllMem_9039(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_9040","instance":9040,"id":245727,"goal":"predicate DisjointSets_9040(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_9041","instance":9041,"id":245728,"goal":"predicate Sorted_9041(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_9042","instance":9042,"id":245729,"goal":"predicate AllPositive_9042(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_9043","instance":9043,"id":245730,"goal":"predicate DistinctSeq_9043(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_9044","instance":9044,"id":245731,"goal":"predicate IsSubseq_9044(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_9045","instance":9045,"id":245732,"goal":"predicate IsPermutation_9045(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_9046","instance":9046,"id":245733,"goal":"predicate IsEven_9046(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_9047","instance":9047,"id":245734,"goal":"predicate InRange_9047(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_9048","instance":9048,"id":245735,"goal":"predicate SubsetOf_9048(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_9049","instance":9049,"id":245736,"goal":"predicate AllMem_9049(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_9050","instance":9050,"id":245737,"goal":"predicate DisjointSets_9050(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_9051","instance":9051,"id":245738,"goal":"predicate Sorted_9051(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_9052","instance":9052,"id":245739,"goal":"predicate AllPositive_9052(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_9053","instance":9053,"id":245740,"goal":"predicate DistinctSeq_9053(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_9054","instance":9054,"id":245741,"goal":"predicate IsSubseq_9054(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_9055","instance":9055,"id":245742,"goal":"predicate IsPermutation_9055(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_9056","instance":9056,"id":245743,"goal":"predicate IsEven_9056(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_9057","instance":9057,"id":245744,"goal":"predicate InRange_9057(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_9058","instance":9058,"id":245745,"goal":"predicate SubsetOf_9058(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_9059","instance":9059,"id":245746,"goal":"predicate AllMem_9059(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_9060","instance":9060,"id":245747,"goal":"predicate DisjointSets_9060(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_9061","instance":9061,"id":245748,"goal":"predicate Sorted_9061(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_9062","instance":9062,"id":245749,"goal":"predicate AllPositive_9062(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_9063","instance":9063,"id":245750,"goal":"predicate DistinctSeq_9063(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_9064","instance":9064,"id":245751,"goal":"predicate IsSubseq_9064(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_9065","instance":9065,"id":245752,"goal":"predicate IsPermutation_9065(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_9066","instance":9066,"id":245753,"goal":"predicate IsEven_9066(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_9067","instance":9067,"id":245754,"goal":"predicate InRange_9067(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_9068","instance":9068,"id":245755,"goal":"predicate SubsetOf_9068(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_9069","instance":9069,"id":245756,"goal":"predicate AllMem_9069(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_9070","instance":9070,"id":245757,"goal":"predicate DisjointSets_9070(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_9071","instance":9071,"id":245758,"goal":"predicate Sorted_9071(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_9072","instance":9072,"id":245759,"goal":"predicate AllPositive_9072(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_9073","instance":9073,"id":245760,"goal":"predicate DistinctSeq_9073(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_9074","instance":9074,"id":245761,"goal":"predicate IsSubseq_9074(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_9075","instance":9075,"id":245762,"goal":"predicate IsPermutation_9075(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_9076","instance":9076,"id":245763,"goal":"predicate IsEven_9076(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_9077","instance":9077,"id":245764,"goal":"predicate InRange_9077(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_9078","instance":9078,"id":245765,"goal":"predicate SubsetOf_9078(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_9079","instance":9079,"id":245766,"goal":"predicate AllMem_9079(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_9080","instance":9080,"id":245767,"goal":"predicate DisjointSets_9080(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_9081","instance":9081,"id":245768,"goal":"predicate Sorted_9081(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_9082","instance":9082,"id":245769,"goal":"predicate AllPositive_9082(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_9083","instance":9083,"id":245770,"goal":"predicate DistinctSeq_9083(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_9084","instance":9084,"id":245771,"goal":"predicate IsSubseq_9084(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_9085","instance":9085,"id":245772,"goal":"predicate IsPermutation_9085(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_9086","instance":9086,"id":245773,"goal":"predicate IsEven_9086(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_9087","instance":9087,"id":245774,"goal":"predicate InRange_9087(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_9088","instance":9088,"id":245775,"goal":"predicate SubsetOf_9088(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_9089","instance":9089,"id":245776,"goal":"predicate AllMem_9089(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_9090","instance":9090,"id":245777,"goal":"predicate DisjointSets_9090(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_9091","instance":9091,"id":245778,"goal":"predicate Sorted_9091(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_9092","instance":9092,"id":245779,"goal":"predicate AllPositive_9092(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_9093","instance":9093,"id":245780,"goal":"predicate DistinctSeq_9093(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_9094","instance":9094,"id":245781,"goal":"predicate IsSubseq_9094(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_9095","instance":9095,"id":245782,"goal":"predicate IsPermutation_9095(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_9096","instance":9096,"id":245783,"goal":"predicate IsEven_9096(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_9097","instance":9097,"id":245784,"goal":"predicate InRange_9097(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_9098","instance":9098,"id":245785,"goal":"predicate SubsetOf_9098(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_9099","instance":9099,"id":245786,"goal":"predicate AllMem_9099(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_9100","instance":9100,"id":245787,"goal":"predicate DisjointSets_9100(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_9101","instance":9101,"id":245788,"goal":"predicate Sorted_9101(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_9102","instance":9102,"id":245789,"goal":"predicate AllPositive_9102(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_9103","instance":9103,"id":245790,"goal":"predicate DistinctSeq_9103(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_9104","instance":9104,"id":245791,"goal":"predicate IsSubseq_9104(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_9105","instance":9105,"id":245792,"goal":"predicate IsPermutation_9105(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_9106","instance":9106,"id":245793,"goal":"predicate IsEven_9106(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_9107","instance":9107,"id":245794,"goal":"predicate InRange_9107(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_9108","instance":9108,"id":245795,"goal":"predicate SubsetOf_9108(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_9109","instance":9109,"id":245796,"goal":"predicate AllMem_9109(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_9110","instance":9110,"id":245797,"goal":"predicate DisjointSets_9110(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_9111","instance":9111,"id":245798,"goal":"predicate Sorted_9111(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_9112","instance":9112,"id":245799,"goal":"predicate AllPositive_9112(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_9113","instance":9113,"id":245800,"goal":"predicate DistinctSeq_9113(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_9114","instance":9114,"id":245801,"goal":"predicate IsSubseq_9114(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_9115","instance":9115,"id":245802,"goal":"predicate IsPermutation_9115(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_9116","instance":9116,"id":245803,"goal":"predicate IsEven_9116(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_9117","instance":9117,"id":245804,"goal":"predicate InRange_9117(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_9118","instance":9118,"id":245805,"goal":"predicate SubsetOf_9118(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_9119","instance":9119,"id":245806,"goal":"predicate AllMem_9119(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_9120","instance":9120,"id":245807,"goal":"predicate DisjointSets_9120(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_9121","instance":9121,"id":245808,"goal":"predicate Sorted_9121(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_9122","instance":9122,"id":245809,"goal":"predicate AllPositive_9122(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_9123","instance":9123,"id":245810,"goal":"predicate DistinctSeq_9123(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_9124","instance":9124,"id":245811,"goal":"predicate IsSubseq_9124(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_9125","instance":9125,"id":245812,"goal":"predicate IsPermutation_9125(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_9126","instance":9126,"id":245813,"goal":"predicate IsEven_9126(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_9127","instance":9127,"id":245814,"goal":"predicate InRange_9127(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_9128","instance":9128,"id":245815,"goal":"predicate SubsetOf_9128(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_9129","instance":9129,"id":245816,"goal":"predicate AllMem_9129(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_9130","instance":9130,"id":245817,"goal":"predicate DisjointSets_9130(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_9131","instance":9131,"id":245818,"goal":"predicate Sorted_9131(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_9132","instance":9132,"id":245819,"goal":"predicate AllPositive_9132(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_9133","instance":9133,"id":245820,"goal":"predicate DistinctSeq_9133(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_9134","instance":9134,"id":245821,"goal":"predicate IsSubseq_9134(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_9135","instance":9135,"id":245822,"goal":"predicate IsPermutation_9135(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_9136","instance":9136,"id":245823,"goal":"predicate IsEven_9136(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_9137","instance":9137,"id":245824,"goal":"predicate InRange_9137(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_9138","instance":9138,"id":245825,"goal":"predicate SubsetOf_9138(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_9139","instance":9139,"id":245826,"goal":"predicate AllMem_9139(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_9140","instance":9140,"id":245827,"goal":"predicate DisjointSets_9140(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_9141","instance":9141,"id":245828,"goal":"predicate Sorted_9141(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_9142","instance":9142,"id":245829,"goal":"predicate AllPositive_9142(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_9143","instance":9143,"id":245830,"goal":"predicate DistinctSeq_9143(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_9144","instance":9144,"id":245831,"goal":"predicate IsSubseq_9144(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_9145","instance":9145,"id":245832,"goal":"predicate IsPermutation_9145(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_9146","instance":9146,"id":245833,"goal":"predicate IsEven_9146(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_9147","instance":9147,"id":245834,"goal":"predicate InRange_9147(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_9148","instance":9148,"id":245835,"goal":"predicate SubsetOf_9148(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_9149","instance":9149,"id":245836,"goal":"predicate AllMem_9149(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_9150","instance":9150,"id":245837,"goal":"predicate DisjointSets_9150(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_9151","instance":9151,"id":245838,"goal":"predicate Sorted_9151(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_9152","instance":9152,"id":245839,"goal":"predicate AllPositive_9152(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_9153","instance":9153,"id":245840,"goal":"predicate DistinctSeq_9153(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_9154","instance":9154,"id":245841,"goal":"predicate IsSubseq_9154(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_9155","instance":9155,"id":245842,"goal":"predicate IsPermutation_9155(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_9156","instance":9156,"id":245843,"goal":"predicate IsEven_9156(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_9157","instance":9157,"id":245844,"goal":"predicate InRange_9157(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_9158","instance":9158,"id":245845,"goal":"predicate SubsetOf_9158(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_9159","instance":9159,"id":245846,"goal":"predicate AllMem_9159(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_9160","instance":9160,"id":245847,"goal":"predicate DisjointSets_9160(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_9161","instance":9161,"id":245848,"goal":"predicate Sorted_9161(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_9162","instance":9162,"id":245849,"goal":"predicate AllPositive_9162(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_9163","instance":9163,"id":245850,"goal":"predicate DistinctSeq_9163(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_9164","instance":9164,"id":245851,"goal":"predicate IsSubseq_9164(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_9165","instance":9165,"id":245852,"goal":"predicate IsPermutation_9165(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_9166","instance":9166,"id":245853,"goal":"predicate IsEven_9166(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_9167","instance":9167,"id":245854,"goal":"predicate InRange_9167(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_9168","instance":9168,"id":245855,"goal":"predicate SubsetOf_9168(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_9169","instance":9169,"id":245856,"goal":"predicate AllMem_9169(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_9170","instance":9170,"id":245857,"goal":"predicate DisjointSets_9170(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_9171","instance":9171,"id":245858,"goal":"predicate Sorted_9171(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_9172","instance":9172,"id":245859,"goal":"predicate AllPositive_9172(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_9173","instance":9173,"id":245860,"goal":"predicate DistinctSeq_9173(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_9174","instance":9174,"id":245861,"goal":"predicate IsSubseq_9174(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_9175","instance":9175,"id":245862,"goal":"predicate IsPermutation_9175(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_9176","instance":9176,"id":245863,"goal":"predicate IsEven_9176(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_9177","instance":9177,"id":245864,"goal":"predicate InRange_9177(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_9178","instance":9178,"id":245865,"goal":"predicate SubsetOf_9178(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_9179","instance":9179,"id":245866,"goal":"predicate AllMem_9179(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_9180","instance":9180,"id":245867,"goal":"predicate DisjointSets_9180(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_9181","instance":9181,"id":245868,"goal":"predicate Sorted_9181(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_9182","instance":9182,"id":245869,"goal":"predicate AllPositive_9182(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_9183","instance":9183,"id":245870,"goal":"predicate DistinctSeq_9183(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_9184","instance":9184,"id":245871,"goal":"predicate IsSubseq_9184(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_9185","instance":9185,"id":245872,"goal":"predicate IsPermutation_9185(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_9186","instance":9186,"id":245873,"goal":"predicate IsEven_9186(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_9187","instance":9187,"id":245874,"goal":"predicate InRange_9187(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_9188","instance":9188,"id":245875,"goal":"predicate SubsetOf_9188(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_9189","instance":9189,"id":245876,"goal":"predicate AllMem_9189(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_9190","instance":9190,"id":245877,"goal":"predicate DisjointSets_9190(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_9191","instance":9191,"id":245878,"goal":"predicate Sorted_9191(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_9192","instance":9192,"id":245879,"goal":"predicate AllPositive_9192(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_9193","instance":9193,"id":245880,"goal":"predicate DistinctSeq_9193(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_9194","instance":9194,"id":245881,"goal":"predicate IsSubseq_9194(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_9195","instance":9195,"id":245882,"goal":"predicate IsPermutation_9195(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_9196","instance":9196,"id":245883,"goal":"predicate IsEven_9196(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_9197","instance":9197,"id":245884,"goal":"predicate InRange_9197(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_9198","instance":9198,"id":245885,"goal":"predicate SubsetOf_9198(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_9199","instance":9199,"id":245886,"goal":"predicate AllMem_9199(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_9200","instance":9200,"id":245887,"goal":"predicate DisjointSets_9200(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_9201","instance":9201,"id":245888,"goal":"predicate Sorted_9201(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_9202","instance":9202,"id":245889,"goal":"predicate AllPositive_9202(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_9203","instance":9203,"id":245890,"goal":"predicate DistinctSeq_9203(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_9204","instance":9204,"id":245891,"goal":"predicate IsSubseq_9204(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_9205","instance":9205,"id":245892,"goal":"predicate IsPermutation_9205(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_9206","instance":9206,"id":245893,"goal":"predicate IsEven_9206(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_9207","instance":9207,"id":245894,"goal":"predicate InRange_9207(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_9208","instance":9208,"id":245895,"goal":"predicate SubsetOf_9208(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_9209","instance":9209,"id":245896,"goal":"predicate AllMem_9209(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_9210","instance":9210,"id":245897,"goal":"predicate DisjointSets_9210(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_9211","instance":9211,"id":245898,"goal":"predicate Sorted_9211(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_9212","instance":9212,"id":245899,"goal":"predicate AllPositive_9212(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_9213","instance":9213,"id":245900,"goal":"predicate DistinctSeq_9213(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_9214","instance":9214,"id":245901,"goal":"predicate IsSubseq_9214(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_9215","instance":9215,"id":245902,"goal":"predicate IsPermutation_9215(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_9216","instance":9216,"id":245903,"goal":"predicate IsEven_9216(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_9217","instance":9217,"id":245904,"goal":"predicate InRange_9217(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_9218","instance":9218,"id":245905,"goal":"predicate SubsetOf_9218(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_9219","instance":9219,"id":245906,"goal":"predicate AllMem_9219(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_9220","instance":9220,"id":245907,"goal":"predicate DisjointSets_9220(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_9221","instance":9221,"id":245908,"goal":"predicate Sorted_9221(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_9222","instance":9222,"id":245909,"goal":"predicate AllPositive_9222(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_9223","instance":9223,"id":245910,"goal":"predicate DistinctSeq_9223(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_9224","instance":9224,"id":245911,"goal":"predicate IsSubseq_9224(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_9225","instance":9225,"id":245912,"goal":"predicate IsPermutation_9225(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_9226","instance":9226,"id":245913,"goal":"predicate IsEven_9226(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_9227","instance":9227,"id":245914,"goal":"predicate InRange_9227(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_9228","instance":9228,"id":245915,"goal":"predicate SubsetOf_9228(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_9229","instance":9229,"id":245916,"goal":"predicate AllMem_9229(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_9230","instance":9230,"id":245917,"goal":"predicate DisjointSets_9230(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_9231","instance":9231,"id":245918,"goal":"predicate Sorted_9231(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_9232","instance":9232,"id":245919,"goal":"predicate AllPositive_9232(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_9233","instance":9233,"id":245920,"goal":"predicate DistinctSeq_9233(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_9234","instance":9234,"id":245921,"goal":"predicate IsSubseq_9234(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_9235","instance":9235,"id":245922,"goal":"predicate IsPermutation_9235(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_9236","instance":9236,"id":245923,"goal":"predicate IsEven_9236(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_9237","instance":9237,"id":245924,"goal":"predicate InRange_9237(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_9238","instance":9238,"id":245925,"goal":"predicate SubsetOf_9238(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_9239","instance":9239,"id":245926,"goal":"predicate AllMem_9239(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_9240","instance":9240,"id":245927,"goal":"predicate DisjointSets_9240(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_9241","instance":9241,"id":245928,"goal":"predicate Sorted_9241(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_9242","instance":9242,"id":245929,"goal":"predicate AllPositive_9242(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_9243","instance":9243,"id":245930,"goal":"predicate DistinctSeq_9243(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_9244","instance":9244,"id":245931,"goal":"predicate IsSubseq_9244(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_9245","instance":9245,"id":245932,"goal":"predicate IsPermutation_9245(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_9246","instance":9246,"id":245933,"goal":"predicate IsEven_9246(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_9247","instance":9247,"id":245934,"goal":"predicate InRange_9247(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_9248","instance":9248,"id":245935,"goal":"predicate SubsetOf_9248(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_9249","instance":9249,"id":245936,"goal":"predicate AllMem_9249(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_9250","instance":9250,"id":245937,"goal":"predicate DisjointSets_9250(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_9251","instance":9251,"id":245938,"goal":"predicate Sorted_9251(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_9252","instance":9252,"id":245939,"goal":"predicate AllPositive_9252(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_9253","instance":9253,"id":245940,"goal":"predicate DistinctSeq_9253(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_9254","instance":9254,"id":245941,"goal":"predicate IsSubseq_9254(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_9255","instance":9255,"id":245942,"goal":"predicate IsPermutation_9255(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_9256","instance":9256,"id":245943,"goal":"predicate IsEven_9256(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_9257","instance":9257,"id":245944,"goal":"predicate InRange_9257(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_9258","instance":9258,"id":245945,"goal":"predicate SubsetOf_9258(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_9259","instance":9259,"id":245946,"goal":"predicate AllMem_9259(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_9260","instance":9260,"id":245947,"goal":"predicate DisjointSets_9260(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_9261","instance":9261,"id":245948,"goal":"predicate Sorted_9261(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_9262","instance":9262,"id":245949,"goal":"predicate AllPositive_9262(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_9263","instance":9263,"id":245950,"goal":"predicate DistinctSeq_9263(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_9264","instance":9264,"id":245951,"goal":"predicate IsSubseq_9264(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_9265","instance":9265,"id":245952,"goal":"predicate IsPermutation_9265(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_9266","instance":9266,"id":245953,"goal":"predicate IsEven_9266(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_9267","instance":9267,"id":245954,"goal":"predicate InRange_9267(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_9268","instance":9268,"id":245955,"goal":"predicate SubsetOf_9268(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_9269","instance":9269,"id":245956,"goal":"predicate AllMem_9269(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_9270","instance":9270,"id":245957,"goal":"predicate DisjointSets_9270(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_9271","instance":9271,"id":245958,"goal":"predicate Sorted_9271(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_9272","instance":9272,"id":245959,"goal":"predicate AllPositive_9272(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_9273","instance":9273,"id":245960,"goal":"predicate DistinctSeq_9273(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_9274","instance":9274,"id":245961,"goal":"predicate IsSubseq_9274(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_9275","instance":9275,"id":245962,"goal":"predicate IsPermutation_9275(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_9276","instance":9276,"id":245963,"goal":"predicate IsEven_9276(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_9277","instance":9277,"id":245964,"goal":"predicate InRange_9277(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_9278","instance":9278,"id":245965,"goal":"predicate SubsetOf_9278(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_9279","instance":9279,"id":245966,"goal":"predicate AllMem_9279(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_9280","instance":9280,"id":245967,"goal":"predicate DisjointSets_9280(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_9281","instance":9281,"id":245968,"goal":"predicate Sorted_9281(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_9282","instance":9282,"id":245969,"goal":"predicate AllPositive_9282(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_9283","instance":9283,"id":245970,"goal":"predicate DistinctSeq_9283(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_9284","instance":9284,"id":245971,"goal":"predicate IsSubseq_9284(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_9285","instance":9285,"id":245972,"goal":"predicate IsPermutation_9285(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_9286","instance":9286,"id":245973,"goal":"predicate IsEven_9286(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_9287","instance":9287,"id":245974,"goal":"predicate InRange_9287(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_9288","instance":9288,"id":245975,"goal":"predicate SubsetOf_9288(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_9289","instance":9289,"id":245976,"goal":"predicate AllMem_9289(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_9290","instance":9290,"id":245977,"goal":"predicate DisjointSets_9290(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_9291","instance":9291,"id":245978,"goal":"predicate Sorted_9291(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_9292","instance":9292,"id":245979,"goal":"predicate AllPositive_9292(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_9293","instance":9293,"id":245980,"goal":"predicate DistinctSeq_9293(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_9294","instance":9294,"id":245981,"goal":"predicate IsSubseq_9294(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_9295","instance":9295,"id":245982,"goal":"predicate IsPermutation_9295(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_9296","instance":9296,"id":245983,"goal":"predicate IsEven_9296(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_9297","instance":9297,"id":245984,"goal":"predicate InRange_9297(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_9298","instance":9298,"id":245985,"goal":"predicate SubsetOf_9298(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_9299","instance":9299,"id":245986,"goal":"predicate AllMem_9299(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_9300","instance":9300,"id":245987,"goal":"predicate DisjointSets_9300(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_9301","instance":9301,"id":245988,"goal":"predicate Sorted_9301(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_9302","instance":9302,"id":245989,"goal":"predicate AllPositive_9302(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_9303","instance":9303,"id":245990,"goal":"predicate DistinctSeq_9303(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_9304","instance":9304,"id":245991,"goal":"predicate IsSubseq_9304(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_9305","instance":9305,"id":245992,"goal":"predicate IsPermutation_9305(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_9306","instance":9306,"id":245993,"goal":"predicate IsEven_9306(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_9307","instance":9307,"id":245994,"goal":"predicate InRange_9307(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_9308","instance":9308,"id":245995,"goal":"predicate SubsetOf_9308(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_9309","instance":9309,"id":245996,"goal":"predicate AllMem_9309(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_9310","instance":9310,"id":245997,"goal":"predicate DisjointSets_9310(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_9311","instance":9311,"id":245998,"goal":"predicate Sorted_9311(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_9312","instance":9312,"id":245999,"goal":"predicate AllPositive_9312(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_9313","instance":9313,"id":246000,"goal":"predicate DistinctSeq_9313(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_9314","instance":9314,"id":246001,"goal":"predicate IsSubseq_9314(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_9315","instance":9315,"id":246002,"goal":"predicate IsPermutation_9315(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_9316","instance":9316,"id":246003,"goal":"predicate IsEven_9316(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_9317","instance":9317,"id":246004,"goal":"predicate InRange_9317(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_9318","instance":9318,"id":246005,"goal":"predicate SubsetOf_9318(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_9319","instance":9319,"id":246006,"goal":"predicate AllMem_9319(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_9320","instance":9320,"id":246007,"goal":"predicate DisjointSets_9320(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_9321","instance":9321,"id":246008,"goal":"predicate Sorted_9321(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_9322","instance":9322,"id":246009,"goal":"predicate AllPositive_9322(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_9323","instance":9323,"id":246010,"goal":"predicate DistinctSeq_9323(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_9324","instance":9324,"id":246011,"goal":"predicate IsSubseq_9324(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_9325","instance":9325,"id":246012,"goal":"predicate IsPermutation_9325(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_9326","instance":9326,"id":246013,"goal":"predicate IsEven_9326(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_9327","instance":9327,"id":246014,"goal":"predicate InRange_9327(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_9328","instance":9328,"id":246015,"goal":"predicate SubsetOf_9328(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_9329","instance":9329,"id":246016,"goal":"predicate AllMem_9329(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_9330","instance":9330,"id":246017,"goal":"predicate DisjointSets_9330(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_9331","instance":9331,"id":246018,"goal":"predicate Sorted_9331(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_9332","instance":9332,"id":246019,"goal":"predicate AllPositive_9332(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_9333","instance":9333,"id":246020,"goal":"predicate DistinctSeq_9333(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_9334","instance":9334,"id":246021,"goal":"predicate IsSubseq_9334(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_9335","instance":9335,"id":246022,"goal":"predicate IsPermutation_9335(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_9336","instance":9336,"id":246023,"goal":"predicate IsEven_9336(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_9337","instance":9337,"id":246024,"goal":"predicate InRange_9337(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_9338","instance":9338,"id":246025,"goal":"predicate SubsetOf_9338(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_9339","instance":9339,"id":246026,"goal":"predicate AllMem_9339(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_9340","instance":9340,"id":246027,"goal":"predicate DisjointSets_9340(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_9341","instance":9341,"id":246028,"goal":"predicate Sorted_9341(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_9342","instance":9342,"id":246029,"goal":"predicate AllPositive_9342(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_9343","instance":9343,"id":246030,"goal":"predicate DistinctSeq_9343(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_9344","instance":9344,"id":246031,"goal":"predicate IsSubseq_9344(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_9345","instance":9345,"id":246032,"goal":"predicate IsPermutation_9345(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_9346","instance":9346,"id":246033,"goal":"predicate IsEven_9346(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_9347","instance":9347,"id":246034,"goal":"predicate InRange_9347(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_9348","instance":9348,"id":246035,"goal":"predicate SubsetOf_9348(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_9349","instance":9349,"id":246036,"goal":"predicate AllMem_9349(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_9350","instance":9350,"id":246037,"goal":"predicate DisjointSets_9350(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_9351","instance":9351,"id":246038,"goal":"predicate Sorted_9351(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_9352","instance":9352,"id":246039,"goal":"predicate AllPositive_9352(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_9353","instance":9353,"id":246040,"goal":"predicate DistinctSeq_9353(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_9354","instance":9354,"id":246041,"goal":"predicate IsSubseq_9354(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_9355","instance":9355,"id":246042,"goal":"predicate IsPermutation_9355(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_9356","instance":9356,"id":246043,"goal":"predicate IsEven_9356(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_9357","instance":9357,"id":246044,"goal":"predicate InRange_9357(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_9358","instance":9358,"id":246045,"goal":"predicate SubsetOf_9358(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_9359","instance":9359,"id":246046,"goal":"predicate AllMem_9359(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_9360","instance":9360,"id":246047,"goal":"predicate DisjointSets_9360(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_9361","instance":9361,"id":246048,"goal":"predicate Sorted_9361(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_9362","instance":9362,"id":246049,"goal":"predicate AllPositive_9362(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_9363","instance":9363,"id":246050,"goal":"predicate DistinctSeq_9363(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_9364","instance":9364,"id":246051,"goal":"predicate IsSubseq_9364(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_9365","instance":9365,"id":246052,"goal":"predicate IsPermutation_9365(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_9366","instance":9366,"id":246053,"goal":"predicate IsEven_9366(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_9367","instance":9367,"id":246054,"goal":"predicate InRange_9367(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_9368","instance":9368,"id":246055,"goal":"predicate SubsetOf_9368(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_9369","instance":9369,"id":246056,"goal":"predicate AllMem_9369(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_9370","instance":9370,"id":246057,"goal":"predicate DisjointSets_9370(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_9371","instance":9371,"id":246058,"goal":"predicate Sorted_9371(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_9372","instance":9372,"id":246059,"goal":"predicate AllPositive_9372(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_9373","instance":9373,"id":246060,"goal":"predicate DistinctSeq_9373(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_9374","instance":9374,"id":246061,"goal":"predicate IsSubseq_9374(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_9375","instance":9375,"id":246062,"goal":"predicate IsPermutation_9375(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_9376","instance":9376,"id":246063,"goal":"predicate IsEven_9376(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_9377","instance":9377,"id":246064,"goal":"predicate InRange_9377(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_9378","instance":9378,"id":246065,"goal":"predicate SubsetOf_9378(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_9379","instance":9379,"id":246066,"goal":"predicate AllMem_9379(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_9380","instance":9380,"id":246067,"goal":"predicate DisjointSets_9380(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_9381","instance":9381,"id":246068,"goal":"predicate Sorted_9381(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_9382","instance":9382,"id":246069,"goal":"predicate AllPositive_9382(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_9383","instance":9383,"id":246070,"goal":"predicate DistinctSeq_9383(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_9384","instance":9384,"id":246071,"goal":"predicate IsSubseq_9384(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_9385","instance":9385,"id":246072,"goal":"predicate IsPermutation_9385(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_9386","instance":9386,"id":246073,"goal":"predicate IsEven_9386(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_9387","instance":9387,"id":246074,"goal":"predicate InRange_9387(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_9388","instance":9388,"id":246075,"goal":"predicate SubsetOf_9388(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_9389","instance":9389,"id":246076,"goal":"predicate AllMem_9389(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_9390","instance":9390,"id":246077,"goal":"predicate DisjointSets_9390(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_9391","instance":9391,"id":246078,"goal":"predicate Sorted_9391(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_9392","instance":9392,"id":246079,"goal":"predicate AllPositive_9392(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_9393","instance":9393,"id":246080,"goal":"predicate DistinctSeq_9393(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_9394","instance":9394,"id":246081,"goal":"predicate IsSubseq_9394(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_9395","instance":9395,"id":246082,"goal":"predicate IsPermutation_9395(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_9396","instance":9396,"id":246083,"goal":"predicate IsEven_9396(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_9397","instance":9397,"id":246084,"goal":"predicate InRange_9397(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_9398","instance":9398,"id":246085,"goal":"predicate SubsetOf_9398(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_9399","instance":9399,"id":246086,"goal":"predicate AllMem_9399(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_9400","instance":9400,"id":246087,"goal":"predicate DisjointSets_9400(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_9401","instance":9401,"id":246088,"goal":"predicate Sorted_9401(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_9402","instance":9402,"id":246089,"goal":"predicate AllPositive_9402(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_9403","instance":9403,"id":246090,"goal":"predicate DistinctSeq_9403(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_9404","instance":9404,"id":246091,"goal":"predicate IsSubseq_9404(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_9405","instance":9405,"id":246092,"goal":"predicate IsPermutation_9405(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_9406","instance":9406,"id":246093,"goal":"predicate IsEven_9406(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_9407","instance":9407,"id":246094,"goal":"predicate InRange_9407(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_9408","instance":9408,"id":246095,"goal":"predicate SubsetOf_9408(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_9409","instance":9409,"id":246096,"goal":"predicate AllMem_9409(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_9410","instance":9410,"id":246097,"goal":"predicate DisjointSets_9410(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_9411","instance":9411,"id":246098,"goal":"predicate Sorted_9411(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_9412","instance":9412,"id":246099,"goal":"predicate AllPositive_9412(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_9413","instance":9413,"id":246100,"goal":"predicate DistinctSeq_9413(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_9414","instance":9414,"id":246101,"goal":"predicate IsSubseq_9414(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_9415","instance":9415,"id":246102,"goal":"predicate IsPermutation_9415(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_9416","instance":9416,"id":246103,"goal":"predicate IsEven_9416(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_9417","instance":9417,"id":246104,"goal":"predicate InRange_9417(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_9418","instance":9418,"id":246105,"goal":"predicate SubsetOf_9418(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_9419","instance":9419,"id":246106,"goal":"predicate AllMem_9419(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_9420","instance":9420,"id":246107,"goal":"predicate DisjointSets_9420(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_9421","instance":9421,"id":246108,"goal":"predicate Sorted_9421(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_9422","instance":9422,"id":246109,"goal":"predicate AllPositive_9422(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_9423","instance":9423,"id":246110,"goal":"predicate DistinctSeq_9423(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_9424","instance":9424,"id":246111,"goal":"predicate IsSubseq_9424(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_9425","instance":9425,"id":246112,"goal":"predicate IsPermutation_9425(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_9426","instance":9426,"id":246113,"goal":"predicate IsEven_9426(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_9427","instance":9427,"id":246114,"goal":"predicate InRange_9427(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_9428","instance":9428,"id":246115,"goal":"predicate SubsetOf_9428(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_9429","instance":9429,"id":246116,"goal":"predicate AllMem_9429(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_9430","instance":9430,"id":246117,"goal":"predicate DisjointSets_9430(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_9431","instance":9431,"id":246118,"goal":"predicate Sorted_9431(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_9432","instance":9432,"id":246119,"goal":"predicate AllPositive_9432(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_9433","instance":9433,"id":246120,"goal":"predicate DistinctSeq_9433(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_9434","instance":9434,"id":246121,"goal":"predicate IsSubseq_9434(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_9435","instance":9435,"id":246122,"goal":"predicate IsPermutation_9435(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_9436","instance":9436,"id":246123,"goal":"predicate IsEven_9436(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_9437","instance":9437,"id":246124,"goal":"predicate InRange_9437(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_9438","instance":9438,"id":246125,"goal":"predicate SubsetOf_9438(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_9439","instance":9439,"id":246126,"goal":"predicate AllMem_9439(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_9440","instance":9440,"id":246127,"goal":"predicate DisjointSets_9440(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_9441","instance":9441,"id":246128,"goal":"predicate Sorted_9441(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_9442","instance":9442,"id":246129,"goal":"predicate AllPositive_9442(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_9443","instance":9443,"id":246130,"goal":"predicate DistinctSeq_9443(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_9444","instance":9444,"id":246131,"goal":"predicate IsSubseq_9444(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_9445","instance":9445,"id":246132,"goal":"predicate IsPermutation_9445(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_9446","instance":9446,"id":246133,"goal":"predicate IsEven_9446(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_9447","instance":9447,"id":246134,"goal":"predicate InRange_9447(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_9448","instance":9448,"id":246135,"goal":"predicate SubsetOf_9448(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_9449","instance":9449,"id":246136,"goal":"predicate AllMem_9449(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_9450","instance":9450,"id":246137,"goal":"predicate DisjointSets_9450(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_9451","instance":9451,"id":246138,"goal":"predicate Sorted_9451(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_9452","instance":9452,"id":246139,"goal":"predicate AllPositive_9452(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_9453","instance":9453,"id":246140,"goal":"predicate DistinctSeq_9453(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_9454","instance":9454,"id":246141,"goal":"predicate IsSubseq_9454(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_9455","instance":9455,"id":246142,"goal":"predicate IsPermutation_9455(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_9456","instance":9456,"id":246143,"goal":"predicate IsEven_9456(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_9457","instance":9457,"id":246144,"goal":"predicate InRange_9457(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_9458","instance":9458,"id":246145,"goal":"predicate SubsetOf_9458(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_9459","instance":9459,"id":246146,"goal":"predicate AllMem_9459(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_9460","instance":9460,"id":246147,"goal":"predicate DisjointSets_9460(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_9461","instance":9461,"id":246148,"goal":"predicate Sorted_9461(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_9462","instance":9462,"id":246149,"goal":"predicate AllPositive_9462(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_9463","instance":9463,"id":246150,"goal":"predicate DistinctSeq_9463(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_9464","instance":9464,"id":246151,"goal":"predicate IsSubseq_9464(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_9465","instance":9465,"id":246152,"goal":"predicate IsPermutation_9465(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_9466","instance":9466,"id":246153,"goal":"predicate IsEven_9466(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_9467","instance":9467,"id":246154,"goal":"predicate InRange_9467(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_9468","instance":9468,"id":246155,"goal":"predicate SubsetOf_9468(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_9469","instance":9469,"id":246156,"goal":"predicate AllMem_9469(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_9470","instance":9470,"id":246157,"goal":"predicate DisjointSets_9470(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_9471","instance":9471,"id":246158,"goal":"predicate Sorted_9471(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_9472","instance":9472,"id":246159,"goal":"predicate AllPositive_9472(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_9473","instance":9473,"id":246160,"goal":"predicate DistinctSeq_9473(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_9474","instance":9474,"id":246161,"goal":"predicate IsSubseq_9474(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_9475","instance":9475,"id":246162,"goal":"predicate IsPermutation_9475(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_9476","instance":9476,"id":246163,"goal":"predicate IsEven_9476(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_9477","instance":9477,"id":246164,"goal":"predicate InRange_9477(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_9478","instance":9478,"id":246165,"goal":"predicate SubsetOf_9478(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_9479","instance":9479,"id":246166,"goal":"predicate AllMem_9479(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_9480","instance":9480,"id":246167,"goal":"predicate DisjointSets_9480(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_9481","instance":9481,"id":246168,"goal":"predicate Sorted_9481(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_9482","instance":9482,"id":246169,"goal":"predicate AllPositive_9482(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_9483","instance":9483,"id":246170,"goal":"predicate DistinctSeq_9483(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_9484","instance":9484,"id":246171,"goal":"predicate IsSubseq_9484(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_9485","instance":9485,"id":246172,"goal":"predicate IsPermutation_9485(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_9486","instance":9486,"id":246173,"goal":"predicate IsEven_9486(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_9487","instance":9487,"id":246174,"goal":"predicate InRange_9487(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_9488","instance":9488,"id":246175,"goal":"predicate SubsetOf_9488(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_9489","instance":9489,"id":246176,"goal":"predicate AllMem_9489(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_9490","instance":9490,"id":246177,"goal":"predicate DisjointSets_9490(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_9491","instance":9491,"id":246178,"goal":"predicate Sorted_9491(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_9492","instance":9492,"id":246179,"goal":"predicate AllPositive_9492(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_9493","instance":9493,"id":246180,"goal":"predicate DistinctSeq_9493(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_9494","instance":9494,"id":246181,"goal":"predicate IsSubseq_9494(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_9495","instance":9495,"id":246182,"goal":"predicate IsPermutation_9495(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_9496","instance":9496,"id":246183,"goal":"predicate IsEven_9496(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_9497","instance":9497,"id":246184,"goal":"predicate InRange_9497(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_9498","instance":9498,"id":246185,"goal":"predicate SubsetOf_9498(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_9499","instance":9499,"id":246186,"goal":"predicate AllMem_9499(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_9500","instance":9500,"id":246187,"goal":"predicate DisjointSets_9500(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_9501","instance":9501,"id":246188,"goal":"predicate Sorted_9501(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_9502","instance":9502,"id":246189,"goal":"predicate AllPositive_9502(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_9503","instance":9503,"id":246190,"goal":"predicate DistinctSeq_9503(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_9504","instance":9504,"id":246191,"goal":"predicate IsSubseq_9504(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_9505","instance":9505,"id":246192,"goal":"predicate IsPermutation_9505(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_9506","instance":9506,"id":246193,"goal":"predicate IsEven_9506(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_9507","instance":9507,"id":246194,"goal":"predicate InRange_9507(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_9508","instance":9508,"id":246195,"goal":"predicate SubsetOf_9508(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_9509","instance":9509,"id":246196,"goal":"predicate AllMem_9509(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_9510","instance":9510,"id":246197,"goal":"predicate DisjointSets_9510(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_9511","instance":9511,"id":246198,"goal":"predicate Sorted_9511(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_9512","instance":9512,"id":246199,"goal":"predicate AllPositive_9512(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_9513","instance":9513,"id":246200,"goal":"predicate DistinctSeq_9513(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_9514","instance":9514,"id":246201,"goal":"predicate IsSubseq_9514(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_9515","instance":9515,"id":246202,"goal":"predicate IsPermutation_9515(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_9516","instance":9516,"id":246203,"goal":"predicate IsEven_9516(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_9517","instance":9517,"id":246204,"goal":"predicate InRange_9517(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_9518","instance":9518,"id":246205,"goal":"predicate SubsetOf_9518(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_9519","instance":9519,"id":246206,"goal":"predicate AllMem_9519(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_9520","instance":9520,"id":246207,"goal":"predicate DisjointSets_9520(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_9521","instance":9521,"id":246208,"goal":"predicate Sorted_9521(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_9522","instance":9522,"id":246209,"goal":"predicate AllPositive_9522(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_9523","instance":9523,"id":246210,"goal":"predicate DistinctSeq_9523(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_9524","instance":9524,"id":246211,"goal":"predicate IsSubseq_9524(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_9525","instance":9525,"id":246212,"goal":"predicate IsPermutation_9525(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_9526","instance":9526,"id":246213,"goal":"predicate IsEven_9526(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_9527","instance":9527,"id":246214,"goal":"predicate InRange_9527(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_9528","instance":9528,"id":246215,"goal":"predicate SubsetOf_9528(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_9529","instance":9529,"id":246216,"goal":"predicate AllMem_9529(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_9530","instance":9530,"id":246217,"goal":"predicate DisjointSets_9530(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_9531","instance":9531,"id":246218,"goal":"predicate Sorted_9531(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_9532","instance":9532,"id":246219,"goal":"predicate AllPositive_9532(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_9533","instance":9533,"id":246220,"goal":"predicate DistinctSeq_9533(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_9534","instance":9534,"id":246221,"goal":"predicate IsSubseq_9534(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_9535","instance":9535,"id":246222,"goal":"predicate IsPermutation_9535(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_9536","instance":9536,"id":246223,"goal":"predicate IsEven_9536(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_9537","instance":9537,"id":246224,"goal":"predicate InRange_9537(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_9538","instance":9538,"id":246225,"goal":"predicate SubsetOf_9538(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_9539","instance":9539,"id":246226,"goal":"predicate AllMem_9539(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_9540","instance":9540,"id":246227,"goal":"predicate DisjointSets_9540(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_9541","instance":9541,"id":246228,"goal":"predicate Sorted_9541(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_9542","instance":9542,"id":246229,"goal":"predicate AllPositive_9542(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_9543","instance":9543,"id":246230,"goal":"predicate DistinctSeq_9543(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_9544","instance":9544,"id":246231,"goal":"predicate IsSubseq_9544(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_9545","instance":9545,"id":246232,"goal":"predicate IsPermutation_9545(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_9546","instance":9546,"id":246233,"goal":"predicate IsEven_9546(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_9547","instance":9547,"id":246234,"goal":"predicate InRange_9547(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_9548","instance":9548,"id":246235,"goal":"predicate SubsetOf_9548(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_9549","instance":9549,"id":246236,"goal":"predicate AllMem_9549(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_9550","instance":9550,"id":246237,"goal":"predicate DisjointSets_9550(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_9551","instance":9551,"id":246238,"goal":"predicate Sorted_9551(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_9552","instance":9552,"id":246239,"goal":"predicate AllPositive_9552(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_9553","instance":9553,"id":246240,"goal":"predicate DistinctSeq_9553(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_9554","instance":9554,"id":246241,"goal":"predicate IsSubseq_9554(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_9555","instance":9555,"id":246242,"goal":"predicate IsPermutation_9555(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_9556","instance":9556,"id":246243,"goal":"predicate IsEven_9556(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_9557","instance":9557,"id":246244,"goal":"predicate InRange_9557(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_9558","instance":9558,"id":246245,"goal":"predicate SubsetOf_9558(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_9559","instance":9559,"id":246246,"goal":"predicate AllMem_9559(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_9560","instance":9560,"id":246247,"goal":"predicate DisjointSets_9560(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_9561","instance":9561,"id":246248,"goal":"predicate Sorted_9561(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_9562","instance":9562,"id":246249,"goal":"predicate AllPositive_9562(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_9563","instance":9563,"id":246250,"goal":"predicate DistinctSeq_9563(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_9564","instance":9564,"id":246251,"goal":"predicate IsSubseq_9564(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_9565","instance":9565,"id":246252,"goal":"predicate IsPermutation_9565(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_9566","instance":9566,"id":246253,"goal":"predicate IsEven_9566(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_9567","instance":9567,"id":246254,"goal":"predicate InRange_9567(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_9568","instance":9568,"id":246255,"goal":"predicate SubsetOf_9568(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_9569","instance":9569,"id":246256,"goal":"predicate AllMem_9569(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_9570","instance":9570,"id":246257,"goal":"predicate DisjointSets_9570(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_9571","instance":9571,"id":246258,"goal":"predicate Sorted_9571(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_9572","instance":9572,"id":246259,"goal":"predicate AllPositive_9572(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_9573","instance":9573,"id":246260,"goal":"predicate DistinctSeq_9573(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_9574","instance":9574,"id":246261,"goal":"predicate IsSubseq_9574(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_9575","instance":9575,"id":246262,"goal":"predicate IsPermutation_9575(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_9576","instance":9576,"id":246263,"goal":"predicate IsEven_9576(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_9577","instance":9577,"id":246264,"goal":"predicate InRange_9577(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_9578","instance":9578,"id":246265,"goal":"predicate SubsetOf_9578(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_9579","instance":9579,"id":246266,"goal":"predicate AllMem_9579(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_9580","instance":9580,"id":246267,"goal":"predicate DisjointSets_9580(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_9581","instance":9581,"id":246268,"goal":"predicate Sorted_9581(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_9582","instance":9582,"id":246269,"goal":"predicate AllPositive_9582(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_9583","instance":9583,"id":246270,"goal":"predicate DistinctSeq_9583(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_9584","instance":9584,"id":246271,"goal":"predicate IsSubseq_9584(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_9585","instance":9585,"id":246272,"goal":"predicate IsPermutation_9585(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_9586","instance":9586,"id":246273,"goal":"predicate IsEven_9586(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_9587","instance":9587,"id":246274,"goal":"predicate InRange_9587(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_9588","instance":9588,"id":246275,"goal":"predicate SubsetOf_9588(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_9589","instance":9589,"id":246276,"goal":"predicate AllMem_9589(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_9590","instance":9590,"id":246277,"goal":"predicate DisjointSets_9590(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_9591","instance":9591,"id":246278,"goal":"predicate Sorted_9591(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_9592","instance":9592,"id":246279,"goal":"predicate AllPositive_9592(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_9593","instance":9593,"id":246280,"goal":"predicate DistinctSeq_9593(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_9594","instance":9594,"id":246281,"goal":"predicate IsSubseq_9594(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_9595","instance":9595,"id":246282,"goal":"predicate IsPermutation_9595(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_9596","instance":9596,"id":246283,"goal":"predicate IsEven_9596(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_9597","instance":9597,"id":246284,"goal":"predicate InRange_9597(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_9598","instance":9598,"id":246285,"goal":"predicate SubsetOf_9598(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_9599","instance":9599,"id":246286,"goal":"predicate AllMem_9599(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_9600","instance":9600,"id":246287,"goal":"predicate DisjointSets_9600(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_9601","instance":9601,"id":246288,"goal":"predicate Sorted_9601(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_9602","instance":9602,"id":246289,"goal":"predicate AllPositive_9602(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_9603","instance":9603,"id":246290,"goal":"predicate DistinctSeq_9603(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_9604","instance":9604,"id":246291,"goal":"predicate IsSubseq_9604(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_9605","instance":9605,"id":246292,"goal":"predicate IsPermutation_9605(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_9606","instance":9606,"id":246293,"goal":"predicate IsEven_9606(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_9607","instance":9607,"id":246294,"goal":"predicate InRange_9607(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_9608","instance":9608,"id":246295,"goal":"predicate SubsetOf_9608(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_9609","instance":9609,"id":246296,"goal":"predicate AllMem_9609(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_9610","instance":9610,"id":246297,"goal":"predicate DisjointSets_9610(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_9611","instance":9611,"id":246298,"goal":"predicate Sorted_9611(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_9612","instance":9612,"id":246299,"goal":"predicate AllPositive_9612(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_9613","instance":9613,"id":246300,"goal":"predicate DistinctSeq_9613(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_9614","instance":9614,"id":246301,"goal":"predicate IsSubseq_9614(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_9615","instance":9615,"id":246302,"goal":"predicate IsPermutation_9615(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_9616","instance":9616,"id":246303,"goal":"predicate IsEven_9616(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_9617","instance":9617,"id":246304,"goal":"predicate InRange_9617(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_9618","instance":9618,"id":246305,"goal":"predicate SubsetOf_9618(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_9619","instance":9619,"id":246306,"goal":"predicate AllMem_9619(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_9620","instance":9620,"id":246307,"goal":"predicate DisjointSets_9620(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_9621","instance":9621,"id":246308,"goal":"predicate Sorted_9621(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_9622","instance":9622,"id":246309,"goal":"predicate AllPositive_9622(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_9623","instance":9623,"id":246310,"goal":"predicate DistinctSeq_9623(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_9624","instance":9624,"id":246311,"goal":"predicate IsSubseq_9624(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_9625","instance":9625,"id":246312,"goal":"predicate IsPermutation_9625(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_9626","instance":9626,"id":246313,"goal":"predicate IsEven_9626(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_9627","instance":9627,"id":246314,"goal":"predicate InRange_9627(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_9628","instance":9628,"id":246315,"goal":"predicate SubsetOf_9628(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_9629","instance":9629,"id":246316,"goal":"predicate AllMem_9629(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_9630","instance":9630,"id":246317,"goal":"predicate DisjointSets_9630(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_9631","instance":9631,"id":246318,"goal":"predicate Sorted_9631(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_9632","instance":9632,"id":246319,"goal":"predicate AllPositive_9632(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_9633","instance":9633,"id":246320,"goal":"predicate DistinctSeq_9633(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_9634","instance":9634,"id":246321,"goal":"predicate IsSubseq_9634(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_9635","instance":9635,"id":246322,"goal":"predicate IsPermutation_9635(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_9636","instance":9636,"id":246323,"goal":"predicate IsEven_9636(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_9637","instance":9637,"id":246324,"goal":"predicate InRange_9637(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_9638","instance":9638,"id":246325,"goal":"predicate SubsetOf_9638(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_9639","instance":9639,"id":246326,"goal":"predicate AllMem_9639(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_9640","instance":9640,"id":246327,"goal":"predicate DisjointSets_9640(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_9641","instance":9641,"id":246328,"goal":"predicate Sorted_9641(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_9642","instance":9642,"id":246329,"goal":"predicate AllPositive_9642(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_9643","instance":9643,"id":246330,"goal":"predicate DistinctSeq_9643(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_9644","instance":9644,"id":246331,"goal":"predicate IsSubseq_9644(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_9645","instance":9645,"id":246332,"goal":"predicate IsPermutation_9645(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_9646","instance":9646,"id":246333,"goal":"predicate IsEven_9646(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_9647","instance":9647,"id":246334,"goal":"predicate InRange_9647(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_9648","instance":9648,"id":246335,"goal":"predicate SubsetOf_9648(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_9649","instance":9649,"id":246336,"goal":"predicate AllMem_9649(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_9650","instance":9650,"id":246337,"goal":"predicate DisjointSets_9650(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_9651","instance":9651,"id":246338,"goal":"predicate Sorted_9651(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_9652","instance":9652,"id":246339,"goal":"predicate AllPositive_9652(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_9653","instance":9653,"id":246340,"goal":"predicate DistinctSeq_9653(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_9654","instance":9654,"id":246341,"goal":"predicate IsSubseq_9654(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_9655","instance":9655,"id":246342,"goal":"predicate IsPermutation_9655(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_9656","instance":9656,"id":246343,"goal":"predicate IsEven_9656(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_9657","instance":9657,"id":246344,"goal":"predicate InRange_9657(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_9658","instance":9658,"id":246345,"goal":"predicate SubsetOf_9658(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_9659","instance":9659,"id":246346,"goal":"predicate AllMem_9659(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_9660","instance":9660,"id":246347,"goal":"predicate DisjointSets_9660(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_9661","instance":9661,"id":246348,"goal":"predicate Sorted_9661(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_9662","instance":9662,"id":246349,"goal":"predicate AllPositive_9662(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_9663","instance":9663,"id":246350,"goal":"predicate DistinctSeq_9663(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_9664","instance":9664,"id":246351,"goal":"predicate IsSubseq_9664(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_9665","instance":9665,"id":246352,"goal":"predicate IsPermutation_9665(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_9666","instance":9666,"id":246353,"goal":"predicate IsEven_9666(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_9667","instance":9667,"id":246354,"goal":"predicate InRange_9667(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_9668","instance":9668,"id":246355,"goal":"predicate SubsetOf_9668(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_9669","instance":9669,"id":246356,"goal":"predicate AllMem_9669(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_9670","instance":9670,"id":246357,"goal":"predicate DisjointSets_9670(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_9671","instance":9671,"id":246358,"goal":"predicate Sorted_9671(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_9672","instance":9672,"id":246359,"goal":"predicate AllPositive_9672(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_9673","instance":9673,"id":246360,"goal":"predicate DistinctSeq_9673(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_9674","instance":9674,"id":246361,"goal":"predicate IsSubseq_9674(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_9675","instance":9675,"id":246362,"goal":"predicate IsPermutation_9675(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_9676","instance":9676,"id":246363,"goal":"predicate IsEven_9676(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_9677","instance":9677,"id":246364,"goal":"predicate InRange_9677(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_9678","instance":9678,"id":246365,"goal":"predicate SubsetOf_9678(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_9679","instance":9679,"id":246366,"goal":"predicate AllMem_9679(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_9680","instance":9680,"id":246367,"goal":"predicate DisjointSets_9680(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_9681","instance":9681,"id":246368,"goal":"predicate Sorted_9681(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_9682","instance":9682,"id":246369,"goal":"predicate AllPositive_9682(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_9683","instance":9683,"id":246370,"goal":"predicate DistinctSeq_9683(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_9684","instance":9684,"id":246371,"goal":"predicate IsSubseq_9684(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_9685","instance":9685,"id":246372,"goal":"predicate IsPermutation_9685(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_9686","instance":9686,"id":246373,"goal":"predicate IsEven_9686(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_9687","instance":9687,"id":246374,"goal":"predicate InRange_9687(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_9688","instance":9688,"id":246375,"goal":"predicate SubsetOf_9688(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_9689","instance":9689,"id":246376,"goal":"predicate AllMem_9689(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_9690","instance":9690,"id":246377,"goal":"predicate DisjointSets_9690(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_9691","instance":9691,"id":246378,"goal":"predicate Sorted_9691(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_9692","instance":9692,"id":246379,"goal":"predicate AllPositive_9692(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_9693","instance":9693,"id":246380,"goal":"predicate DistinctSeq_9693(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_9694","instance":9694,"id":246381,"goal":"predicate IsSubseq_9694(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_9695","instance":9695,"id":246382,"goal":"predicate IsPermutation_9695(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_9696","instance":9696,"id":246383,"goal":"predicate IsEven_9696(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_9697","instance":9697,"id":246384,"goal":"predicate InRange_9697(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_9698","instance":9698,"id":246385,"goal":"predicate SubsetOf_9698(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_9699","instance":9699,"id":246386,"goal":"predicate AllMem_9699(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_9700","instance":9700,"id":246387,"goal":"predicate DisjointSets_9700(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_9701","instance":9701,"id":246388,"goal":"predicate Sorted_9701(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_9702","instance":9702,"id":246389,"goal":"predicate AllPositive_9702(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_9703","instance":9703,"id":246390,"goal":"predicate DistinctSeq_9703(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_9704","instance":9704,"id":246391,"goal":"predicate IsSubseq_9704(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_9705","instance":9705,"id":246392,"goal":"predicate IsPermutation_9705(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_9706","instance":9706,"id":246393,"goal":"predicate IsEven_9706(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_9707","instance":9707,"id":246394,"goal":"predicate InRange_9707(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_9708","instance":9708,"id":246395,"goal":"predicate SubsetOf_9708(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_9709","instance":9709,"id":246396,"goal":"predicate AllMem_9709(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_9710","instance":9710,"id":246397,"goal":"predicate DisjointSets_9710(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_9711","instance":9711,"id":246398,"goal":"predicate Sorted_9711(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_9712","instance":9712,"id":246399,"goal":"predicate AllPositive_9712(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_9713","instance":9713,"id":246400,"goal":"predicate DistinctSeq_9713(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_9714","instance":9714,"id":246401,"goal":"predicate IsSubseq_9714(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_9715","instance":9715,"id":246402,"goal":"predicate IsPermutation_9715(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_9716","instance":9716,"id":246403,"goal":"predicate IsEven_9716(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_9717","instance":9717,"id":246404,"goal":"predicate InRange_9717(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_9718","instance":9718,"id":246405,"goal":"predicate SubsetOf_9718(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_9719","instance":9719,"id":246406,"goal":"predicate AllMem_9719(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_9720","instance":9720,"id":246407,"goal":"predicate DisjointSets_9720(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_9721","instance":9721,"id":246408,"goal":"predicate Sorted_9721(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_9722","instance":9722,"id":246409,"goal":"predicate AllPositive_9722(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_9723","instance":9723,"id":246410,"goal":"predicate DistinctSeq_9723(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_9724","instance":9724,"id":246411,"goal":"predicate IsSubseq_9724(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_9725","instance":9725,"id":246412,"goal":"predicate IsPermutation_9725(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_9726","instance":9726,"id":246413,"goal":"predicate IsEven_9726(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_9727","instance":9727,"id":246414,"goal":"predicate InRange_9727(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_9728","instance":9728,"id":246415,"goal":"predicate SubsetOf_9728(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_9729","instance":9729,"id":246416,"goal":"predicate AllMem_9729(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_9730","instance":9730,"id":246417,"goal":"predicate DisjointSets_9730(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_9731","instance":9731,"id":246418,"goal":"predicate Sorted_9731(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_9732","instance":9732,"id":246419,"goal":"predicate AllPositive_9732(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_9733","instance":9733,"id":246420,"goal":"predicate DistinctSeq_9733(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_9734","instance":9734,"id":246421,"goal":"predicate IsSubseq_9734(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_9735","instance":9735,"id":246422,"goal":"predicate IsPermutation_9735(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_9736","instance":9736,"id":246423,"goal":"predicate IsEven_9736(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_9737","instance":9737,"id":246424,"goal":"predicate InRange_9737(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_9738","instance":9738,"id":246425,"goal":"predicate SubsetOf_9738(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_9739","instance":9739,"id":246426,"goal":"predicate AllMem_9739(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_9740","instance":9740,"id":246427,"goal":"predicate DisjointSets_9740(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_9741","instance":9741,"id":246428,"goal":"predicate Sorted_9741(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_9742","instance":9742,"id":246429,"goal":"predicate AllPositive_9742(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_9743","instance":9743,"id":246430,"goal":"predicate DistinctSeq_9743(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_9744","instance":9744,"id":246431,"goal":"predicate IsSubseq_9744(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_9745","instance":9745,"id":246432,"goal":"predicate IsPermutation_9745(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_9746","instance":9746,"id":246433,"goal":"predicate IsEven_9746(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_9747","instance":9747,"id":246434,"goal":"predicate InRange_9747(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_9748","instance":9748,"id":246435,"goal":"predicate SubsetOf_9748(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_9749","instance":9749,"id":246436,"goal":"predicate AllMem_9749(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_9750","instance":9750,"id":246437,"goal":"predicate DisjointSets_9750(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_9751","instance":9751,"id":246438,"goal":"predicate Sorted_9751(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_9752","instance":9752,"id":246439,"goal":"predicate AllPositive_9752(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_9753","instance":9753,"id":246440,"goal":"predicate DistinctSeq_9753(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_9754","instance":9754,"id":246441,"goal":"predicate IsSubseq_9754(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_9755","instance":9755,"id":246442,"goal":"predicate IsPermutation_9755(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_9756","instance":9756,"id":246443,"goal":"predicate IsEven_9756(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_9757","instance":9757,"id":246444,"goal":"predicate InRange_9757(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_9758","instance":9758,"id":246445,"goal":"predicate SubsetOf_9758(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_9759","instance":9759,"id":246446,"goal":"predicate AllMem_9759(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_9760","instance":9760,"id":246447,"goal":"predicate DisjointSets_9760(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_9761","instance":9761,"id":246448,"goal":"predicate Sorted_9761(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_9762","instance":9762,"id":246449,"goal":"predicate AllPositive_9762(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_9763","instance":9763,"id":246450,"goal":"predicate DistinctSeq_9763(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_9764","instance":9764,"id":246451,"goal":"predicate IsSubseq_9764(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_9765","instance":9765,"id":246452,"goal":"predicate IsPermutation_9765(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_9766","instance":9766,"id":246453,"goal":"predicate IsEven_9766(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_9767","instance":9767,"id":246454,"goal":"predicate InRange_9767(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_9768","instance":9768,"id":246455,"goal":"predicate SubsetOf_9768(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_9769","instance":9769,"id":246456,"goal":"predicate AllMem_9769(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_9770","instance":9770,"id":246457,"goal":"predicate DisjointSets_9770(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_9771","instance":9771,"id":246458,"goal":"predicate Sorted_9771(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_9772","instance":9772,"id":246459,"goal":"predicate AllPositive_9772(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_9773","instance":9773,"id":246460,"goal":"predicate DistinctSeq_9773(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_9774","instance":9774,"id":246461,"goal":"predicate IsSubseq_9774(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_9775","instance":9775,"id":246462,"goal":"predicate IsPermutation_9775(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_9776","instance":9776,"id":246463,"goal":"predicate IsEven_9776(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_9777","instance":9777,"id":246464,"goal":"predicate InRange_9777(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_9778","instance":9778,"id":246465,"goal":"predicate SubsetOf_9778(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_9779","instance":9779,"id":246466,"goal":"predicate AllMem_9779(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_9780","instance":9780,"id":246467,"goal":"predicate DisjointSets_9780(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_9781","instance":9781,"id":246468,"goal":"predicate Sorted_9781(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_9782","instance":9782,"id":246469,"goal":"predicate AllPositive_9782(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_9783","instance":9783,"id":246470,"goal":"predicate DistinctSeq_9783(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_9784","instance":9784,"id":246471,"goal":"predicate IsSubseq_9784(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_9785","instance":9785,"id":246472,"goal":"predicate IsPermutation_9785(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_9786","instance":9786,"id":246473,"goal":"predicate IsEven_9786(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_9787","instance":9787,"id":246474,"goal":"predicate InRange_9787(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_9788","instance":9788,"id":246475,"goal":"predicate SubsetOf_9788(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_9789","instance":9789,"id":246476,"goal":"predicate AllMem_9789(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_9790","instance":9790,"id":246477,"goal":"predicate DisjointSets_9790(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_9791","instance":9791,"id":246478,"goal":"predicate Sorted_9791(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_9792","instance":9792,"id":246479,"goal":"predicate AllPositive_9792(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_9793","instance":9793,"id":246480,"goal":"predicate DistinctSeq_9793(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_9794","instance":9794,"id":246481,"goal":"predicate IsSubseq_9794(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_9795","instance":9795,"id":246482,"goal":"predicate IsPermutation_9795(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_9796","instance":9796,"id":246483,"goal":"predicate IsEven_9796(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_9797","instance":9797,"id":246484,"goal":"predicate InRange_9797(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_9798","instance":9798,"id":246485,"goal":"predicate SubsetOf_9798(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_9799","instance":9799,"id":246486,"goal":"predicate AllMem_9799(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_9800","instance":9800,"id":246487,"goal":"predicate DisjointSets_9800(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_9801","instance":9801,"id":246488,"goal":"predicate Sorted_9801(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_9802","instance":9802,"id":246489,"goal":"predicate AllPositive_9802(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_9803","instance":9803,"id":246490,"goal":"predicate DistinctSeq_9803(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_9804","instance":9804,"id":246491,"goal":"predicate IsSubseq_9804(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_9805","instance":9805,"id":246492,"goal":"predicate IsPermutation_9805(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_9806","instance":9806,"id":246493,"goal":"predicate IsEven_9806(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_9807","instance":9807,"id":246494,"goal":"predicate InRange_9807(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_9808","instance":9808,"id":246495,"goal":"predicate SubsetOf_9808(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_9809","instance":9809,"id":246496,"goal":"predicate AllMem_9809(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_9810","instance":9810,"id":246497,"goal":"predicate DisjointSets_9810(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_9811","instance":9811,"id":246498,"goal":"predicate Sorted_9811(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_9812","instance":9812,"id":246499,"goal":"predicate AllPositive_9812(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_9813","instance":9813,"id":246500,"goal":"predicate DistinctSeq_9813(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_9814","instance":9814,"id":246501,"goal":"predicate IsSubseq_9814(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_9815","instance":9815,"id":246502,"goal":"predicate IsPermutation_9815(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_9816","instance":9816,"id":246503,"goal":"predicate IsEven_9816(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_9817","instance":9817,"id":246504,"goal":"predicate InRange_9817(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_9818","instance":9818,"id":246505,"goal":"predicate SubsetOf_9818(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_9819","instance":9819,"id":246506,"goal":"predicate AllMem_9819(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_9820","instance":9820,"id":246507,"goal":"predicate DisjointSets_9820(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_9821","instance":9821,"id":246508,"goal":"predicate Sorted_9821(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_9822","instance":9822,"id":246509,"goal":"predicate AllPositive_9822(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_9823","instance":9823,"id":246510,"goal":"predicate DistinctSeq_9823(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_9824","instance":9824,"id":246511,"goal":"predicate IsSubseq_9824(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_9825","instance":9825,"id":246512,"goal":"predicate IsPermutation_9825(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_9826","instance":9826,"id":246513,"goal":"predicate IsEven_9826(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_9827","instance":9827,"id":246514,"goal":"predicate InRange_9827(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_9828","instance":9828,"id":246515,"goal":"predicate SubsetOf_9828(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_9829","instance":9829,"id":246516,"goal":"predicate AllMem_9829(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_9830","instance":9830,"id":246517,"goal":"predicate DisjointSets_9830(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_9831","instance":9831,"id":246518,"goal":"predicate Sorted_9831(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_9832","instance":9832,"id":246519,"goal":"predicate AllPositive_9832(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_9833","instance":9833,"id":246520,"goal":"predicate DistinctSeq_9833(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_9834","instance":9834,"id":246521,"goal":"predicate IsSubseq_9834(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_9835","instance":9835,"id":246522,"goal":"predicate IsPermutation_9835(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_9836","instance":9836,"id":246523,"goal":"predicate IsEven_9836(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_9837","instance":9837,"id":246524,"goal":"predicate InRange_9837(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_9838","instance":9838,"id":246525,"goal":"predicate SubsetOf_9838(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_9839","instance":9839,"id":246526,"goal":"predicate AllMem_9839(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_9840","instance":9840,"id":246527,"goal":"predicate DisjointSets_9840(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_9841","instance":9841,"id":246528,"goal":"predicate Sorted_9841(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_9842","instance":9842,"id":246529,"goal":"predicate AllPositive_9842(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_9843","instance":9843,"id":246530,"goal":"predicate DistinctSeq_9843(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_9844","instance":9844,"id":246531,"goal":"predicate IsSubseq_9844(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_9845","instance":9845,"id":246532,"goal":"predicate IsPermutation_9845(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_9846","instance":9846,"id":246533,"goal":"predicate IsEven_9846(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_9847","instance":9847,"id":246534,"goal":"predicate InRange_9847(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_9848","instance":9848,"id":246535,"goal":"predicate SubsetOf_9848(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_9849","instance":9849,"id":246536,"goal":"predicate AllMem_9849(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_9850","instance":9850,"id":246537,"goal":"predicate DisjointSets_9850(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_9851","instance":9851,"id":246538,"goal":"predicate Sorted_9851(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_9852","instance":9852,"id":246539,"goal":"predicate AllPositive_9852(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_9853","instance":9853,"id":246540,"goal":"predicate DistinctSeq_9853(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_9854","instance":9854,"id":246541,"goal":"predicate IsSubseq_9854(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_9855","instance":9855,"id":246542,"goal":"predicate IsPermutation_9855(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_9856","instance":9856,"id":246543,"goal":"predicate IsEven_9856(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_9857","instance":9857,"id":246544,"goal":"predicate InRange_9857(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_9858","instance":9858,"id":246545,"goal":"predicate SubsetOf_9858(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_9859","instance":9859,"id":246546,"goal":"predicate AllMem_9859(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_9860","instance":9860,"id":246547,"goal":"predicate DisjointSets_9860(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_9861","instance":9861,"id":246548,"goal":"predicate Sorted_9861(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_9862","instance":9862,"id":246549,"goal":"predicate AllPositive_9862(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_9863","instance":9863,"id":246550,"goal":"predicate DistinctSeq_9863(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_9864","instance":9864,"id":246551,"goal":"predicate IsSubseq_9864(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_9865","instance":9865,"id":246552,"goal":"predicate IsPermutation_9865(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_9866","instance":9866,"id":246553,"goal":"predicate IsEven_9866(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_9867","instance":9867,"id":246554,"goal":"predicate InRange_9867(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_9868","instance":9868,"id":246555,"goal":"predicate SubsetOf_9868(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_9869","instance":9869,"id":246556,"goal":"predicate AllMem_9869(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_9870","instance":9870,"id":246557,"goal":"predicate DisjointSets_9870(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_9871","instance":9871,"id":246558,"goal":"predicate Sorted_9871(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_9872","instance":9872,"id":246559,"goal":"predicate AllPositive_9872(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_9873","instance":9873,"id":246560,"goal":"predicate DistinctSeq_9873(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_9874","instance":9874,"id":246561,"goal":"predicate IsSubseq_9874(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_9875","instance":9875,"id":246562,"goal":"predicate IsPermutation_9875(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_9876","instance":9876,"id":246563,"goal":"predicate IsEven_9876(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_9877","instance":9877,"id":246564,"goal":"predicate InRange_9877(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_9878","instance":9878,"id":246565,"goal":"predicate SubsetOf_9878(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_9879","instance":9879,"id":246566,"goal":"predicate AllMem_9879(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_9880","instance":9880,"id":246567,"goal":"predicate DisjointSets_9880(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_9881","instance":9881,"id":246568,"goal":"predicate Sorted_9881(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_9882","instance":9882,"id":246569,"goal":"predicate AllPositive_9882(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_9883","instance":9883,"id":246570,"goal":"predicate DistinctSeq_9883(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_9884","instance":9884,"id":246571,"goal":"predicate IsSubseq_9884(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_9885","instance":9885,"id":246572,"goal":"predicate IsPermutation_9885(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_9886","instance":9886,"id":246573,"goal":"predicate IsEven_9886(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_9887","instance":9887,"id":246574,"goal":"predicate InRange_9887(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_9888","instance":9888,"id":246575,"goal":"predicate SubsetOf_9888(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_9889","instance":9889,"id":246576,"goal":"predicate AllMem_9889(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_9890","instance":9890,"id":246577,"goal":"predicate DisjointSets_9890(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_9891","instance":9891,"id":246578,"goal":"predicate Sorted_9891(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_9892","instance":9892,"id":246579,"goal":"predicate AllPositive_9892(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_9893","instance":9893,"id":246580,"goal":"predicate DistinctSeq_9893(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_9894","instance":9894,"id":246581,"goal":"predicate IsSubseq_9894(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_9895","instance":9895,"id":246582,"goal":"predicate IsPermutation_9895(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_9896","instance":9896,"id":246583,"goal":"predicate IsEven_9896(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_9897","instance":9897,"id":246584,"goal":"predicate InRange_9897(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_9898","instance":9898,"id":246585,"goal":"predicate SubsetOf_9898(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_9899","instance":9899,"id":246586,"goal":"predicate AllMem_9899(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_9900","instance":9900,"id":246587,"goal":"predicate DisjointSets_9900(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_9901","instance":9901,"id":246588,"goal":"predicate Sorted_9901(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_9902","instance":9902,"id":246589,"goal":"predicate AllPositive_9902(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_9903","instance":9903,"id":246590,"goal":"predicate DistinctSeq_9903(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_9904","instance":9904,"id":246591,"goal":"predicate IsSubseq_9904(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_9905","instance":9905,"id":246592,"goal":"predicate IsPermutation_9905(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_9906","instance":9906,"id":246593,"goal":"predicate IsEven_9906(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_9907","instance":9907,"id":246594,"goal":"predicate InRange_9907(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_9908","instance":9908,"id":246595,"goal":"predicate SubsetOf_9908(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_9909","instance":9909,"id":246596,"goal":"predicate AllMem_9909(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_9910","instance":9910,"id":246597,"goal":"predicate DisjointSets_9910(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_9911","instance":9911,"id":246598,"goal":"predicate Sorted_9911(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_9912","instance":9912,"id":246599,"goal":"predicate AllPositive_9912(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_9913","instance":9913,"id":246600,"goal":"predicate DistinctSeq_9913(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_9914","instance":9914,"id":246601,"goal":"predicate IsSubseq_9914(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_9915","instance":9915,"id":246602,"goal":"predicate IsPermutation_9915(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_9916","instance":9916,"id":246603,"goal":"predicate IsEven_9916(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_9917","instance":9917,"id":246604,"goal":"predicate InRange_9917(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_9918","instance":9918,"id":246605,"goal":"predicate SubsetOf_9918(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_9919","instance":9919,"id":246606,"goal":"predicate AllMem_9919(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_9920","instance":9920,"id":246607,"goal":"predicate DisjointSets_9920(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_9921","instance":9921,"id":246608,"goal":"predicate Sorted_9921(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_9922","instance":9922,"id":246609,"goal":"predicate AllPositive_9922(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_9923","instance":9923,"id":246610,"goal":"predicate DistinctSeq_9923(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_9924","instance":9924,"id":246611,"goal":"predicate IsSubseq_9924(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_9925","instance":9925,"id":246612,"goal":"predicate IsPermutation_9925(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_9926","instance":9926,"id":246613,"goal":"predicate IsEven_9926(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_9927","instance":9927,"id":246614,"goal":"predicate InRange_9927(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_9928","instance":9928,"id":246615,"goal":"predicate SubsetOf_9928(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_9929","instance":9929,"id":246616,"goal":"predicate AllMem_9929(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_9930","instance":9930,"id":246617,"goal":"predicate DisjointSets_9930(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_9931","instance":9931,"id":246618,"goal":"predicate Sorted_9931(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_9932","instance":9932,"id":246619,"goal":"predicate AllPositive_9932(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_9933","instance":9933,"id":246620,"goal":"predicate DistinctSeq_9933(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_9934","instance":9934,"id":246621,"goal":"predicate IsSubseq_9934(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_9935","instance":9935,"id":246622,"goal":"predicate IsPermutation_9935(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_9936","instance":9936,"id":246623,"goal":"predicate IsEven_9936(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_9937","instance":9937,"id":246624,"goal":"predicate InRange_9937(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_9938","instance":9938,"id":246625,"goal":"predicate SubsetOf_9938(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_9939","instance":9939,"id":246626,"goal":"predicate AllMem_9939(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_9940","instance":9940,"id":246627,"goal":"predicate DisjointSets_9940(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_9941","instance":9941,"id":246628,"goal":"predicate Sorted_9941(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_9942","instance":9942,"id":246629,"goal":"predicate AllPositive_9942(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_9943","instance":9943,"id":246630,"goal":"predicate DistinctSeq_9943(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_9944","instance":9944,"id":246631,"goal":"predicate IsSubseq_9944(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_9945","instance":9945,"id":246632,"goal":"predicate IsPermutation_9945(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_9946","instance":9946,"id":246633,"goal":"predicate IsEven_9946(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_9947","instance":9947,"id":246634,"goal":"predicate InRange_9947(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_9948","instance":9948,"id":246635,"goal":"predicate SubsetOf_9948(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_9949","instance":9949,"id":246636,"goal":"predicate AllMem_9949(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_9950","instance":9950,"id":246637,"goal":"predicate DisjointSets_9950(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_9951","instance":9951,"id":246638,"goal":"predicate Sorted_9951(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_9952","instance":9952,"id":246639,"goal":"predicate AllPositive_9952(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_9953","instance":9953,"id":246640,"goal":"predicate DistinctSeq_9953(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_9954","instance":9954,"id":246641,"goal":"predicate IsSubseq_9954(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_9955","instance":9955,"id":246642,"goal":"predicate IsPermutation_9955(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_9956","instance":9956,"id":246643,"goal":"predicate IsEven_9956(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_9957","instance":9957,"id":246644,"goal":"predicate InRange_9957(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_9958","instance":9958,"id":246645,"goal":"predicate SubsetOf_9958(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_9959","instance":9959,"id":246646,"goal":"predicate AllMem_9959(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_9960","instance":9960,"id":246647,"goal":"predicate DisjointSets_9960(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_9961","instance":9961,"id":246648,"goal":"predicate Sorted_9961(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_9962","instance":9962,"id":246649,"goal":"predicate AllPositive_9962(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_9963","instance":9963,"id":246650,"goal":"predicate DistinctSeq_9963(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_9964","instance":9964,"id":246651,"goal":"predicate IsSubseq_9964(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_9965","instance":9965,"id":246652,"goal":"predicate IsPermutation_9965(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_9966","instance":9966,"id":246653,"goal":"predicate IsEven_9966(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_9967","instance":9967,"id":246654,"goal":"predicate InRange_9967(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_9968","instance":9968,"id":246655,"goal":"predicate SubsetOf_9968(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_9969","instance":9969,"id":246656,"goal":"predicate AllMem_9969(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_9970","instance":9970,"id":246657,"goal":"predicate DisjointSets_9970(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_9971","instance":9971,"id":246658,"goal":"predicate Sorted_9971(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_9972","instance":9972,"id":246659,"goal":"predicate AllPositive_9972(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_9973","instance":9973,"id":246660,"goal":"predicate DistinctSeq_9973(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_9974","instance":9974,"id":246661,"goal":"predicate IsSubseq_9974(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_9975","instance":9975,"id":246662,"goal":"predicate IsPermutation_9975(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_9976","instance":9976,"id":246663,"goal":"predicate IsEven_9976(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_9977","instance":9977,"id":246664,"goal":"predicate InRange_9977(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_9978","instance":9978,"id":246665,"goal":"predicate SubsetOf_9978(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_9979","instance":9979,"id":246666,"goal":"predicate AllMem_9979(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_9980","instance":9980,"id":246667,"goal":"predicate DisjointSets_9980(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_9981","instance":9981,"id":246668,"goal":"predicate Sorted_9981(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_9982","instance":9982,"id":246669,"goal":"predicate AllPositive_9982(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_9983","instance":9983,"id":246670,"goal":"predicate DistinctSeq_9983(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_9984","instance":9984,"id":246671,"goal":"predicate IsSubseq_9984(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_9985","instance":9985,"id":246672,"goal":"predicate IsPermutation_9985(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_9986","instance":9986,"id":246673,"goal":"predicate IsEven_9986(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_9987","instance":9987,"id":246674,"goal":"predicate InRange_9987(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_9988","instance":9988,"id":246675,"goal":"predicate SubsetOf_9988(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_9989","instance":9989,"id":246676,"goal":"predicate AllMem_9989(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_9990","instance":9990,"id":246677,"goal":"predicate DisjointSets_9990(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_9991","instance":9991,"id":246678,"goal":"predicate Sorted_9991(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_9992","instance":9992,"id":246679,"goal":"predicate AllPositive_9992(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_9993","instance":9993,"id":246680,"goal":"predicate DistinctSeq_9993(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_9994","instance":9994,"id":246681,"goal":"predicate IsSubseq_9994(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_9995","instance":9995,"id":246682,"goal":"predicate IsPermutation_9995(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_9996","instance":9996,"id":246683,"goal":"predicate IsEven_9996(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_9997","instance":9997,"id":246684,"goal":"predicate InRange_9997(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_9998","instance":9998,"id":246685,"goal":"predicate SubsetOf_9998(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_9999","instance":9999,"id":246686,"goal":"predicate AllMem_9999(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_10000","instance":10000,"id":246687,"goal":"predicate DisjointSets_10000(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_10001","instance":10001,"id":246688,"goal":"predicate Sorted_10001(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_10002","instance":10002,"id":246689,"goal":"predicate AllPositive_10002(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_10003","instance":10003,"id":246690,"goal":"predicate DistinctSeq_10003(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_10004","instance":10004,"id":246691,"goal":"predicate IsSubseq_10004(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_10005","instance":10005,"id":246692,"goal":"predicate IsPermutation_10005(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_10006","instance":10006,"id":246693,"goal":"predicate IsEven_10006(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_10007","instance":10007,"id":246694,"goal":"predicate InRange_10007(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_10008","instance":10008,"id":246695,"goal":"predicate SubsetOf_10008(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_10009","instance":10009,"id":246696,"goal":"predicate AllMem_10009(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_10010","instance":10010,"id":246697,"goal":"predicate DisjointSets_10010(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_10011","instance":10011,"id":246698,"goal":"predicate Sorted_10011(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_10012","instance":10012,"id":246699,"goal":"predicate AllPositive_10012(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_10013","instance":10013,"id":246700,"goal":"predicate DistinctSeq_10013(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_10014","instance":10014,"id":246701,"goal":"predicate IsSubseq_10014(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_10015","instance":10015,"id":246702,"goal":"predicate IsPermutation_10015(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_10016","instance":10016,"id":246703,"goal":"predicate IsEven_10016(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_10017","instance":10017,"id":246704,"goal":"predicate InRange_10017(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_10018","instance":10018,"id":246705,"goal":"predicate SubsetOf_10018(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_10019","instance":10019,"id":246706,"goal":"predicate AllMem_10019(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_10020","instance":10020,"id":246707,"goal":"predicate DisjointSets_10020(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_10021","instance":10021,"id":246708,"goal":"predicate Sorted_10021(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_10022","instance":10022,"id":246709,"goal":"predicate AllPositive_10022(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_10023","instance":10023,"id":246710,"goal":"predicate DistinctSeq_10023(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_10024","instance":10024,"id":246711,"goal":"predicate IsSubseq_10024(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_10025","instance":10025,"id":246712,"goal":"predicate IsPermutation_10025(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_10026","instance":10026,"id":246713,"goal":"predicate IsEven_10026(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_10027","instance":10027,"id":246714,"goal":"predicate InRange_10027(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_10028","instance":10028,"id":246715,"goal":"predicate SubsetOf_10028(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_10029","instance":10029,"id":246716,"goal":"predicate AllMem_10029(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_10030","instance":10030,"id":246717,"goal":"predicate DisjointSets_10030(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_10031","instance":10031,"id":246718,"goal":"predicate Sorted_10031(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_10032","instance":10032,"id":246719,"goal":"predicate AllPositive_10032(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_10033","instance":10033,"id":246720,"goal":"predicate DistinctSeq_10033(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_10034","instance":10034,"id":246721,"goal":"predicate IsSubseq_10034(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_10035","instance":10035,"id":246722,"goal":"predicate IsPermutation_10035(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_10036","instance":10036,"id":246723,"goal":"predicate IsEven_10036(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_10037","instance":10037,"id":246724,"goal":"predicate InRange_10037(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_10038","instance":10038,"id":246725,"goal":"predicate SubsetOf_10038(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_10039","instance":10039,"id":246726,"goal":"predicate AllMem_10039(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_10040","instance":10040,"id":246727,"goal":"predicate DisjointSets_10040(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_10041","instance":10041,"id":246728,"goal":"predicate Sorted_10041(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_10042","instance":10042,"id":246729,"goal":"predicate AllPositive_10042(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_10043","instance":10043,"id":246730,"goal":"predicate DistinctSeq_10043(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_10044","instance":10044,"id":246731,"goal":"predicate IsSubseq_10044(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_10045","instance":10045,"id":246732,"goal":"predicate IsPermutation_10045(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_10046","instance":10046,"id":246733,"goal":"predicate IsEven_10046(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_10047","instance":10047,"id":246734,"goal":"predicate InRange_10047(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_10048","instance":10048,"id":246735,"goal":"predicate SubsetOf_10048(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_10049","instance":10049,"id":246736,"goal":"predicate AllMem_10049(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_10050","instance":10050,"id":246737,"goal":"predicate DisjointSets_10050(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_10051","instance":10051,"id":246738,"goal":"predicate Sorted_10051(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_10052","instance":10052,"id":246739,"goal":"predicate AllPositive_10052(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_10053","instance":10053,"id":246740,"goal":"predicate DistinctSeq_10053(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_10054","instance":10054,"id":246741,"goal":"predicate IsSubseq_10054(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_10055","instance":10055,"id":246742,"goal":"predicate IsPermutation_10055(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_10056","instance":10056,"id":246743,"goal":"predicate IsEven_10056(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_10057","instance":10057,"id":246744,"goal":"predicate InRange_10057(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_10058","instance":10058,"id":246745,"goal":"predicate SubsetOf_10058(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_10059","instance":10059,"id":246746,"goal":"predicate AllMem_10059(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_10060","instance":10060,"id":246747,"goal":"predicate DisjointSets_10060(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_10061","instance":10061,"id":246748,"goal":"predicate Sorted_10061(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_10062","instance":10062,"id":246749,"goal":"predicate AllPositive_10062(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_10063","instance":10063,"id":246750,"goal":"predicate DistinctSeq_10063(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_10064","instance":10064,"id":246751,"goal":"predicate IsSubseq_10064(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_10065","instance":10065,"id":246752,"goal":"predicate IsPermutation_10065(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_10066","instance":10066,"id":246753,"goal":"predicate IsEven_10066(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_10067","instance":10067,"id":246754,"goal":"predicate InRange_10067(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_10068","instance":10068,"id":246755,"goal":"predicate SubsetOf_10068(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_10069","instance":10069,"id":246756,"goal":"predicate AllMem_10069(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_10070","instance":10070,"id":246757,"goal":"predicate DisjointSets_10070(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_10071","instance":10071,"id":246758,"goal":"predicate Sorted_10071(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_10072","instance":10072,"id":246759,"goal":"predicate AllPositive_10072(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_10073","instance":10073,"id":246760,"goal":"predicate DistinctSeq_10073(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_10074","instance":10074,"id":246761,"goal":"predicate IsSubseq_10074(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_10075","instance":10075,"id":246762,"goal":"predicate IsPermutation_10075(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_10076","instance":10076,"id":246763,"goal":"predicate IsEven_10076(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_10077","instance":10077,"id":246764,"goal":"predicate InRange_10077(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_10078","instance":10078,"id":246765,"goal":"predicate SubsetOf_10078(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_10079","instance":10079,"id":246766,"goal":"predicate AllMem_10079(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_10080","instance":10080,"id":246767,"goal":"predicate DisjointSets_10080(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_10081","instance":10081,"id":246768,"goal":"predicate Sorted_10081(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_10082","instance":10082,"id":246769,"goal":"predicate AllPositive_10082(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_10083","instance":10083,"id":246770,"goal":"predicate DistinctSeq_10083(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_10084","instance":10084,"id":246771,"goal":"predicate IsSubseq_10084(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_10085","instance":10085,"id":246772,"goal":"predicate IsPermutation_10085(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_10086","instance":10086,"id":246773,"goal":"predicate IsEven_10086(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_10087","instance":10087,"id":246774,"goal":"predicate InRange_10087(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_10088","instance":10088,"id":246775,"goal":"predicate SubsetOf_10088(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_10089","instance":10089,"id":246776,"goal":"predicate AllMem_10089(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_10090","instance":10090,"id":246777,"goal":"predicate DisjointSets_10090(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_10091","instance":10091,"id":246778,"goal":"predicate Sorted_10091(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_10092","instance":10092,"id":246779,"goal":"predicate AllPositive_10092(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_10093","instance":10093,"id":246780,"goal":"predicate DistinctSeq_10093(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_10094","instance":10094,"id":246781,"goal":"predicate IsSubseq_10094(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_10095","instance":10095,"id":246782,"goal":"predicate IsPermutation_10095(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_10096","instance":10096,"id":246783,"goal":"predicate IsEven_10096(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_10097","instance":10097,"id":246784,"goal":"predicate InRange_10097(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_10098","instance":10098,"id":246785,"goal":"predicate SubsetOf_10098(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_10099","instance":10099,"id":246786,"goal":"predicate AllMem_10099(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_10100","instance":10100,"id":246787,"goal":"predicate DisjointSets_10100(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_10101","instance":10101,"id":246788,"goal":"predicate Sorted_10101(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_10102","instance":10102,"id":246789,"goal":"predicate AllPositive_10102(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_10103","instance":10103,"id":246790,"goal":"predicate DistinctSeq_10103(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_10104","instance":10104,"id":246791,"goal":"predicate IsSubseq_10104(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_10105","instance":10105,"id":246792,"goal":"predicate IsPermutation_10105(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_10106","instance":10106,"id":246793,"goal":"predicate IsEven_10106(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_10107","instance":10107,"id":246794,"goal":"predicate InRange_10107(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_10108","instance":10108,"id":246795,"goal":"predicate SubsetOf_10108(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_10109","instance":10109,"id":246796,"goal":"predicate AllMem_10109(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_10110","instance":10110,"id":246797,"goal":"predicate DisjointSets_10110(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_10111","instance":10111,"id":246798,"goal":"predicate Sorted_10111(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_10112","instance":10112,"id":246799,"goal":"predicate AllPositive_10112(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_10113","instance":10113,"id":246800,"goal":"predicate DistinctSeq_10113(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_10114","instance":10114,"id":246801,"goal":"predicate IsSubseq_10114(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_10115","instance":10115,"id":246802,"goal":"predicate IsPermutation_10115(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_10116","instance":10116,"id":246803,"goal":"predicate IsEven_10116(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_10117","instance":10117,"id":246804,"goal":"predicate InRange_10117(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_10118","instance":10118,"id":246805,"goal":"predicate SubsetOf_10118(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_10119","instance":10119,"id":246806,"goal":"predicate AllMem_10119(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_10120","instance":10120,"id":246807,"goal":"predicate DisjointSets_10120(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_10121","instance":10121,"id":246808,"goal":"predicate Sorted_10121(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_10122","instance":10122,"id":246809,"goal":"predicate AllPositive_10122(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_10123","instance":10123,"id":246810,"goal":"predicate DistinctSeq_10123(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_10124","instance":10124,"id":246811,"goal":"predicate IsSubseq_10124(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_10125","instance":10125,"id":246812,"goal":"predicate IsPermutation_10125(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_10126","instance":10126,"id":246813,"goal":"predicate IsEven_10126(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_10127","instance":10127,"id":246814,"goal":"predicate InRange_10127(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_10128","instance":10128,"id":246815,"goal":"predicate SubsetOf_10128(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_10129","instance":10129,"id":246816,"goal":"predicate AllMem_10129(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_10130","instance":10130,"id":246817,"goal":"predicate DisjointSets_10130(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_10131","instance":10131,"id":246818,"goal":"predicate Sorted_10131(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_10132","instance":10132,"id":246819,"goal":"predicate AllPositive_10132(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_10133","instance":10133,"id":246820,"goal":"predicate DistinctSeq_10133(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_10134","instance":10134,"id":246821,"goal":"predicate IsSubseq_10134(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_10135","instance":10135,"id":246822,"goal":"predicate IsPermutation_10135(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_10136","instance":10136,"id":246823,"goal":"predicate IsEven_10136(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_10137","instance":10137,"id":246824,"goal":"predicate InRange_10137(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_10138","instance":10138,"id":246825,"goal":"predicate SubsetOf_10138(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_10139","instance":10139,"id":246826,"goal":"predicate AllMem_10139(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_10140","instance":10140,"id":246827,"goal":"predicate DisjointSets_10140(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_10141","instance":10141,"id":246828,"goal":"predicate Sorted_10141(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_10142","instance":10142,"id":246829,"goal":"predicate AllPositive_10142(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_10143","instance":10143,"id":246830,"goal":"predicate DistinctSeq_10143(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_10144","instance":10144,"id":246831,"goal":"predicate IsSubseq_10144(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_10145","instance":10145,"id":246832,"goal":"predicate IsPermutation_10145(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_10146","instance":10146,"id":246833,"goal":"predicate IsEven_10146(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_10147","instance":10147,"id":246834,"goal":"predicate InRange_10147(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_10148","instance":10148,"id":246835,"goal":"predicate SubsetOf_10148(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_10149","instance":10149,"id":246836,"goal":"predicate AllMem_10149(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_10150","instance":10150,"id":246837,"goal":"predicate DisjointSets_10150(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_10151","instance":10151,"id":246838,"goal":"predicate Sorted_10151(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_10152","instance":10152,"id":246839,"goal":"predicate AllPositive_10152(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_10153","instance":10153,"id":246840,"goal":"predicate DistinctSeq_10153(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_10154","instance":10154,"id":246841,"goal":"predicate IsSubseq_10154(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_10155","instance":10155,"id":246842,"goal":"predicate IsPermutation_10155(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_10156","instance":10156,"id":246843,"goal":"predicate IsEven_10156(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_10157","instance":10157,"id":246844,"goal":"predicate InRange_10157(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_10158","instance":10158,"id":246845,"goal":"predicate SubsetOf_10158(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_10159","instance":10159,"id":246846,"goal":"predicate AllMem_10159(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_10160","instance":10160,"id":246847,"goal":"predicate DisjointSets_10160(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_10161","instance":10161,"id":246848,"goal":"predicate Sorted_10161(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_10162","instance":10162,"id":246849,"goal":"predicate AllPositive_10162(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_10163","instance":10163,"id":246850,"goal":"predicate DistinctSeq_10163(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_10164","instance":10164,"id":246851,"goal":"predicate IsSubseq_10164(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_10165","instance":10165,"id":246852,"goal":"predicate IsPermutation_10165(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_10166","instance":10166,"id":246853,"goal":"predicate IsEven_10166(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_10167","instance":10167,"id":246854,"goal":"predicate InRange_10167(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_10168","instance":10168,"id":246855,"goal":"predicate SubsetOf_10168(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_10169","instance":10169,"id":246856,"goal":"predicate AllMem_10169(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_10170","instance":10170,"id":246857,"goal":"predicate DisjointSets_10170(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_10171","instance":10171,"id":246858,"goal":"predicate Sorted_10171(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_10172","instance":10172,"id":246859,"goal":"predicate AllPositive_10172(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_10173","instance":10173,"id":246860,"goal":"predicate DistinctSeq_10173(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_10174","instance":10174,"id":246861,"goal":"predicate IsSubseq_10174(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_10175","instance":10175,"id":246862,"goal":"predicate IsPermutation_10175(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_10176","instance":10176,"id":246863,"goal":"predicate IsEven_10176(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_10177","instance":10177,"id":246864,"goal":"predicate InRange_10177(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_10178","instance":10178,"id":246865,"goal":"predicate SubsetOf_10178(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_10179","instance":10179,"id":246866,"goal":"predicate AllMem_10179(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_10180","instance":10180,"id":246867,"goal":"predicate DisjointSets_10180(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_10181","instance":10181,"id":246868,"goal":"predicate Sorted_10181(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_10182","instance":10182,"id":246869,"goal":"predicate AllPositive_10182(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_10183","instance":10183,"id":246870,"goal":"predicate DistinctSeq_10183(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_10184","instance":10184,"id":246871,"goal":"predicate IsSubseq_10184(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_10185","instance":10185,"id":246872,"goal":"predicate IsPermutation_10185(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_10186","instance":10186,"id":246873,"goal":"predicate IsEven_10186(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_10187","instance":10187,"id":246874,"goal":"predicate InRange_10187(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_10188","instance":10188,"id":246875,"goal":"predicate SubsetOf_10188(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_10189","instance":10189,"id":246876,"goal":"predicate AllMem_10189(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_10190","instance":10190,"id":246877,"goal":"predicate DisjointSets_10190(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_10191","instance":10191,"id":246878,"goal":"predicate Sorted_10191(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_10192","instance":10192,"id":246879,"goal":"predicate AllPositive_10192(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_10193","instance":10193,"id":246880,"goal":"predicate DistinctSeq_10193(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_10194","instance":10194,"id":246881,"goal":"predicate IsSubseq_10194(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_10195","instance":10195,"id":246882,"goal":"predicate IsPermutation_10195(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_10196","instance":10196,"id":246883,"goal":"predicate IsEven_10196(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_10197","instance":10197,"id":246884,"goal":"predicate InRange_10197(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_10198","instance":10198,"id":246885,"goal":"predicate SubsetOf_10198(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_10199","instance":10199,"id":246886,"goal":"predicate AllMem_10199(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_10200","instance":10200,"id":246887,"goal":"predicate DisjointSets_10200(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_10201","instance":10201,"id":246888,"goal":"predicate Sorted_10201(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_10202","instance":10202,"id":246889,"goal":"predicate AllPositive_10202(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_10203","instance":10203,"id":246890,"goal":"predicate DistinctSeq_10203(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_10204","instance":10204,"id":246891,"goal":"predicate IsSubseq_10204(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_10205","instance":10205,"id":246892,"goal":"predicate IsPermutation_10205(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_10206","instance":10206,"id":246893,"goal":"predicate IsEven_10206(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_10207","instance":10207,"id":246894,"goal":"predicate InRange_10207(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_10208","instance":10208,"id":246895,"goal":"predicate SubsetOf_10208(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_10209","instance":10209,"id":246896,"goal":"predicate AllMem_10209(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_10210","instance":10210,"id":246897,"goal":"predicate DisjointSets_10210(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_10211","instance":10211,"id":246898,"goal":"predicate Sorted_10211(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_10212","instance":10212,"id":246899,"goal":"predicate AllPositive_10212(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_10213","instance":10213,"id":246900,"goal":"predicate DistinctSeq_10213(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_10214","instance":10214,"id":246901,"goal":"predicate IsSubseq_10214(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_10215","instance":10215,"id":246902,"goal":"predicate IsPermutation_10215(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_10216","instance":10216,"id":246903,"goal":"predicate IsEven_10216(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_10217","instance":10217,"id":246904,"goal":"predicate InRange_10217(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_10218","instance":10218,"id":246905,"goal":"predicate SubsetOf_10218(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_10219","instance":10219,"id":246906,"goal":"predicate AllMem_10219(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_10220","instance":10220,"id":246907,"goal":"predicate DisjointSets_10220(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_10221","instance":10221,"id":246908,"goal":"predicate Sorted_10221(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_10222","instance":10222,"id":246909,"goal":"predicate AllPositive_10222(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_10223","instance":10223,"id":246910,"goal":"predicate DistinctSeq_10223(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_10224","instance":10224,"id":246911,"goal":"predicate IsSubseq_10224(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_10225","instance":10225,"id":246912,"goal":"predicate IsPermutation_10225(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_10226","instance":10226,"id":246913,"goal":"predicate IsEven_10226(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_10227","instance":10227,"id":246914,"goal":"predicate InRange_10227(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_10228","instance":10228,"id":246915,"goal":"predicate SubsetOf_10228(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_10229","instance":10229,"id":246916,"goal":"predicate AllMem_10229(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_10230","instance":10230,"id":246917,"goal":"predicate DisjointSets_10230(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_10231","instance":10231,"id":246918,"goal":"predicate Sorted_10231(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_10232","instance":10232,"id":246919,"goal":"predicate AllPositive_10232(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_10233","instance":10233,"id":246920,"goal":"predicate DistinctSeq_10233(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_10234","instance":10234,"id":246921,"goal":"predicate IsSubseq_10234(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_10235","instance":10235,"id":246922,"goal":"predicate IsPermutation_10235(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_10236","instance":10236,"id":246923,"goal":"predicate IsEven_10236(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_10237","instance":10237,"id":246924,"goal":"predicate InRange_10237(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_10238","instance":10238,"id":246925,"goal":"predicate SubsetOf_10238(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_10239","instance":10239,"id":246926,"goal":"predicate AllMem_10239(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_10240","instance":10240,"id":246927,"goal":"predicate DisjointSets_10240(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_10241","instance":10241,"id":246928,"goal":"predicate Sorted_10241(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_10242","instance":10242,"id":246929,"goal":"predicate AllPositive_10242(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_10243","instance":10243,"id":246930,"goal":"predicate DistinctSeq_10243(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_10244","instance":10244,"id":246931,"goal":"predicate IsSubseq_10244(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_10245","instance":10245,"id":246932,"goal":"predicate IsPermutation_10245(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_10246","instance":10246,"id":246933,"goal":"predicate IsEven_10246(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_10247","instance":10247,"id":246934,"goal":"predicate InRange_10247(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_10248","instance":10248,"id":246935,"goal":"predicate SubsetOf_10248(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_10249","instance":10249,"id":246936,"goal":"predicate AllMem_10249(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_10250","instance":10250,"id":246937,"goal":"predicate DisjointSets_10250(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_10251","instance":10251,"id":246938,"goal":"predicate Sorted_10251(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_10252","instance":10252,"id":246939,"goal":"predicate AllPositive_10252(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_10253","instance":10253,"id":246940,"goal":"predicate DistinctSeq_10253(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_10254","instance":10254,"id":246941,"goal":"predicate IsSubseq_10254(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_10255","instance":10255,"id":246942,"goal":"predicate IsPermutation_10255(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_10256","instance":10256,"id":246943,"goal":"predicate IsEven_10256(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_10257","instance":10257,"id":246944,"goal":"predicate InRange_10257(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_10258","instance":10258,"id":246945,"goal":"predicate SubsetOf_10258(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_10259","instance":10259,"id":246946,"goal":"predicate AllMem_10259(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_10260","instance":10260,"id":246947,"goal":"predicate DisjointSets_10260(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_10261","instance":10261,"id":246948,"goal":"predicate Sorted_10261(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_10262","instance":10262,"id":246949,"goal":"predicate AllPositive_10262(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_10263","instance":10263,"id":246950,"goal":"predicate DistinctSeq_10263(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_10264","instance":10264,"id":246951,"goal":"predicate IsSubseq_10264(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_10265","instance":10265,"id":246952,"goal":"predicate IsPermutation_10265(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_10266","instance":10266,"id":246953,"goal":"predicate IsEven_10266(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_10267","instance":10267,"id":246954,"goal":"predicate InRange_10267(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_10268","instance":10268,"id":246955,"goal":"predicate SubsetOf_10268(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_10269","instance":10269,"id":246956,"goal":"predicate AllMem_10269(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_10270","instance":10270,"id":246957,"goal":"predicate DisjointSets_10270(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_10271","instance":10271,"id":246958,"goal":"predicate Sorted_10271(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_10272","instance":10272,"id":246959,"goal":"predicate AllPositive_10272(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_10273","instance":10273,"id":246960,"goal":"predicate DistinctSeq_10273(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_10274","instance":10274,"id":246961,"goal":"predicate IsSubseq_10274(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_10275","instance":10275,"id":246962,"goal":"predicate IsPermutation_10275(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_10276","instance":10276,"id":246963,"goal":"predicate IsEven_10276(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_10277","instance":10277,"id":246964,"goal":"predicate InRange_10277(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_10278","instance":10278,"id":246965,"goal":"predicate SubsetOf_10278(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_10279","instance":10279,"id":246966,"goal":"predicate AllMem_10279(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_10280","instance":10280,"id":246967,"goal":"predicate DisjointSets_10280(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_10281","instance":10281,"id":246968,"goal":"predicate Sorted_10281(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_10282","instance":10282,"id":246969,"goal":"predicate AllPositive_10282(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_10283","instance":10283,"id":246970,"goal":"predicate DistinctSeq_10283(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_10284","instance":10284,"id":246971,"goal":"predicate IsSubseq_10284(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_10285","instance":10285,"id":246972,"goal":"predicate IsPermutation_10285(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_10286","instance":10286,"id":246973,"goal":"predicate IsEven_10286(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_10287","instance":10287,"id":246974,"goal":"predicate InRange_10287(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_10288","instance":10288,"id":246975,"goal":"predicate SubsetOf_10288(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_10289","instance":10289,"id":246976,"goal":"predicate AllMem_10289(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_10290","instance":10290,"id":246977,"goal":"predicate DisjointSets_10290(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_10291","instance":10291,"id":246978,"goal":"predicate Sorted_10291(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_10292","instance":10292,"id":246979,"goal":"predicate AllPositive_10292(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_10293","instance":10293,"id":246980,"goal":"predicate DistinctSeq_10293(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_10294","instance":10294,"id":246981,"goal":"predicate IsSubseq_10294(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_10295","instance":10295,"id":246982,"goal":"predicate IsPermutation_10295(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_10296","instance":10296,"id":246983,"goal":"predicate IsEven_10296(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_10297","instance":10297,"id":246984,"goal":"predicate InRange_10297(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_10298","instance":10298,"id":246985,"goal":"predicate SubsetOf_10298(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_10299","instance":10299,"id":246986,"goal":"predicate AllMem_10299(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_10300","instance":10300,"id":246987,"goal":"predicate DisjointSets_10300(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_10301","instance":10301,"id":246988,"goal":"predicate Sorted_10301(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_10302","instance":10302,"id":246989,"goal":"predicate AllPositive_10302(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_10303","instance":10303,"id":246990,"goal":"predicate DistinctSeq_10303(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_10304","instance":10304,"id":246991,"goal":"predicate IsSubseq_10304(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_10305","instance":10305,"id":246992,"goal":"predicate IsPermutation_10305(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_10306","instance":10306,"id":246993,"goal":"predicate IsEven_10306(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_10307","instance":10307,"id":246994,"goal":"predicate InRange_10307(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_10308","instance":10308,"id":246995,"goal":"predicate SubsetOf_10308(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_10309","instance":10309,"id":246996,"goal":"predicate AllMem_10309(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_10310","instance":10310,"id":246997,"goal":"predicate DisjointSets_10310(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_10311","instance":10311,"id":246998,"goal":"predicate Sorted_10311(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_10312","instance":10312,"id":246999,"goal":"predicate AllPositive_10312(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_10313","instance":10313,"id":247000,"goal":"predicate DistinctSeq_10313(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_10314","instance":10314,"id":247001,"goal":"predicate IsSubseq_10314(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_10315","instance":10315,"id":247002,"goal":"predicate IsPermutation_10315(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_10316","instance":10316,"id":247003,"goal":"predicate IsEven_10316(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_10317","instance":10317,"id":247004,"goal":"predicate InRange_10317(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_10318","instance":10318,"id":247005,"goal":"predicate SubsetOf_10318(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_10319","instance":10319,"id":247006,"goal":"predicate AllMem_10319(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_10320","instance":10320,"id":247007,"goal":"predicate DisjointSets_10320(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_10321","instance":10321,"id":247008,"goal":"predicate Sorted_10321(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_10322","instance":10322,"id":247009,"goal":"predicate AllPositive_10322(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_10323","instance":10323,"id":247010,"goal":"predicate DistinctSeq_10323(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_10324","instance":10324,"id":247011,"goal":"predicate IsSubseq_10324(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_10325","instance":10325,"id":247012,"goal":"predicate IsPermutation_10325(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_10326","instance":10326,"id":247013,"goal":"predicate IsEven_10326(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_10327","instance":10327,"id":247014,"goal":"predicate InRange_10327(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_10328","instance":10328,"id":247015,"goal":"predicate SubsetOf_10328(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_10329","instance":10329,"id":247016,"goal":"predicate AllMem_10329(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_10330","instance":10330,"id":247017,"goal":"predicate DisjointSets_10330(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_10331","instance":10331,"id":247018,"goal":"predicate Sorted_10331(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_10332","instance":10332,"id":247019,"goal":"predicate AllPositive_10332(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_10333","instance":10333,"id":247020,"goal":"predicate DistinctSeq_10333(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_10334","instance":10334,"id":247021,"goal":"predicate IsSubseq_10334(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_10335","instance":10335,"id":247022,"goal":"predicate IsPermutation_10335(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_10336","instance":10336,"id":247023,"goal":"predicate IsEven_10336(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_10337","instance":10337,"id":247024,"goal":"predicate InRange_10337(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_10338","instance":10338,"id":247025,"goal":"predicate SubsetOf_10338(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_10339","instance":10339,"id":247026,"goal":"predicate AllMem_10339(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_10340","instance":10340,"id":247027,"goal":"predicate DisjointSets_10340(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_10341","instance":10341,"id":247028,"goal":"predicate Sorted_10341(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_10342","instance":10342,"id":247029,"goal":"predicate AllPositive_10342(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_10343","instance":10343,"id":247030,"goal":"predicate DistinctSeq_10343(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_10344","instance":10344,"id":247031,"goal":"predicate IsSubseq_10344(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_10345","instance":10345,"id":247032,"goal":"predicate IsPermutation_10345(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_10346","instance":10346,"id":247033,"goal":"predicate IsEven_10346(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_10347","instance":10347,"id":247034,"goal":"predicate InRange_10347(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_10348","instance":10348,"id":247035,"goal":"predicate SubsetOf_10348(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_10349","instance":10349,"id":247036,"goal":"predicate AllMem_10349(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_10350","instance":10350,"id":247037,"goal":"predicate DisjointSets_10350(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_10351","instance":10351,"id":247038,"goal":"predicate Sorted_10351(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_10352","instance":10352,"id":247039,"goal":"predicate AllPositive_10352(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_10353","instance":10353,"id":247040,"goal":"predicate DistinctSeq_10353(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_10354","instance":10354,"id":247041,"goal":"predicate IsSubseq_10354(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_10355","instance":10355,"id":247042,"goal":"predicate IsPermutation_10355(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_10356","instance":10356,"id":247043,"goal":"predicate IsEven_10356(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_10357","instance":10357,"id":247044,"goal":"predicate InRange_10357(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_10358","instance":10358,"id":247045,"goal":"predicate SubsetOf_10358(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_10359","instance":10359,"id":247046,"goal":"predicate AllMem_10359(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_10360","instance":10360,"id":247047,"goal":"predicate DisjointSets_10360(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_10361","instance":10361,"id":247048,"goal":"predicate Sorted_10361(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_10362","instance":10362,"id":247049,"goal":"predicate AllPositive_10362(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_10363","instance":10363,"id":247050,"goal":"predicate DistinctSeq_10363(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_10364","instance":10364,"id":247051,"goal":"predicate IsSubseq_10364(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_10365","instance":10365,"id":247052,"goal":"predicate IsPermutation_10365(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_10366","instance":10366,"id":247053,"goal":"predicate IsEven_10366(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_10367","instance":10367,"id":247054,"goal":"predicate InRange_10367(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_10368","instance":10368,"id":247055,"goal":"predicate SubsetOf_10368(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_10369","instance":10369,"id":247056,"goal":"predicate AllMem_10369(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_10370","instance":10370,"id":247057,"goal":"predicate DisjointSets_10370(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_10371","instance":10371,"id":247058,"goal":"predicate Sorted_10371(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_10372","instance":10372,"id":247059,"goal":"predicate AllPositive_10372(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_10373","instance":10373,"id":247060,"goal":"predicate DistinctSeq_10373(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_10374","instance":10374,"id":247061,"goal":"predicate IsSubseq_10374(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_10375","instance":10375,"id":247062,"goal":"predicate IsPermutation_10375(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_10376","instance":10376,"id":247063,"goal":"predicate IsEven_10376(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_10377","instance":10377,"id":247064,"goal":"predicate InRange_10377(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_10378","instance":10378,"id":247065,"goal":"predicate SubsetOf_10378(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_10379","instance":10379,"id":247066,"goal":"predicate AllMem_10379(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_10380","instance":10380,"id":247067,"goal":"predicate DisjointSets_10380(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_10381","instance":10381,"id":247068,"goal":"predicate Sorted_10381(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_10382","instance":10382,"id":247069,"goal":"predicate AllPositive_10382(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_10383","instance":10383,"id":247070,"goal":"predicate DistinctSeq_10383(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_10384","instance":10384,"id":247071,"goal":"predicate IsSubseq_10384(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_10385","instance":10385,"id":247072,"goal":"predicate IsPermutation_10385(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_10386","instance":10386,"id":247073,"goal":"predicate IsEven_10386(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_10387","instance":10387,"id":247074,"goal":"predicate InRange_10387(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_10388","instance":10388,"id":247075,"goal":"predicate SubsetOf_10388(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_10389","instance":10389,"id":247076,"goal":"predicate AllMem_10389(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_10390","instance":10390,"id":247077,"goal":"predicate DisjointSets_10390(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_10391","instance":10391,"id":247078,"goal":"predicate Sorted_10391(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_10392","instance":10392,"id":247079,"goal":"predicate AllPositive_10392(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_10393","instance":10393,"id":247080,"goal":"predicate DistinctSeq_10393(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_10394","instance":10394,"id":247081,"goal":"predicate IsSubseq_10394(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_10395","instance":10395,"id":247082,"goal":"predicate IsPermutation_10395(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_10396","instance":10396,"id":247083,"goal":"predicate IsEven_10396(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_10397","instance":10397,"id":247084,"goal":"predicate InRange_10397(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_10398","instance":10398,"id":247085,"goal":"predicate SubsetOf_10398(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_10399","instance":10399,"id":247086,"goal":"predicate AllMem_10399(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_10400","instance":10400,"id":247087,"goal":"predicate DisjointSets_10400(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_10401","instance":10401,"id":247088,"goal":"predicate Sorted_10401(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_10402","instance":10402,"id":247089,"goal":"predicate AllPositive_10402(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_10403","instance":10403,"id":247090,"goal":"predicate DistinctSeq_10403(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_10404","instance":10404,"id":247091,"goal":"predicate IsSubseq_10404(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_10405","instance":10405,"id":247092,"goal":"predicate IsPermutation_10405(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_10406","instance":10406,"id":247093,"goal":"predicate IsEven_10406(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_10407","instance":10407,"id":247094,"goal":"predicate InRange_10407(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_10408","instance":10408,"id":247095,"goal":"predicate SubsetOf_10408(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_10409","instance":10409,"id":247096,"goal":"predicate AllMem_10409(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_10410","instance":10410,"id":247097,"goal":"predicate DisjointSets_10410(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_10411","instance":10411,"id":247098,"goal":"predicate Sorted_10411(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_10412","instance":10412,"id":247099,"goal":"predicate AllPositive_10412(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_10413","instance":10413,"id":247100,"goal":"predicate DistinctSeq_10413(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_10414","instance":10414,"id":247101,"goal":"predicate IsSubseq_10414(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_10415","instance":10415,"id":247102,"goal":"predicate IsPermutation_10415(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_10416","instance":10416,"id":247103,"goal":"predicate IsEven_10416(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_10417","instance":10417,"id":247104,"goal":"predicate InRange_10417(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_10418","instance":10418,"id":247105,"goal":"predicate SubsetOf_10418(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_10419","instance":10419,"id":247106,"goal":"predicate AllMem_10419(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_10420","instance":10420,"id":247107,"goal":"predicate DisjointSets_10420(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_10421","instance":10421,"id":247108,"goal":"predicate Sorted_10421(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_10422","instance":10422,"id":247109,"goal":"predicate AllPositive_10422(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_10423","instance":10423,"id":247110,"goal":"predicate DistinctSeq_10423(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_10424","instance":10424,"id":247111,"goal":"predicate IsSubseq_10424(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_10425","instance":10425,"id":247112,"goal":"predicate IsPermutation_10425(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_10426","instance":10426,"id":247113,"goal":"predicate IsEven_10426(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_10427","instance":10427,"id":247114,"goal":"predicate InRange_10427(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_10428","instance":10428,"id":247115,"goal":"predicate SubsetOf_10428(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_10429","instance":10429,"id":247116,"goal":"predicate AllMem_10429(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_10430","instance":10430,"id":247117,"goal":"predicate DisjointSets_10430(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_10431","instance":10431,"id":247118,"goal":"predicate Sorted_10431(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_10432","instance":10432,"id":247119,"goal":"predicate AllPositive_10432(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_10433","instance":10433,"id":247120,"goal":"predicate DistinctSeq_10433(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_10434","instance":10434,"id":247121,"goal":"predicate IsSubseq_10434(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_10435","instance":10435,"id":247122,"goal":"predicate IsPermutation_10435(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_10436","instance":10436,"id":247123,"goal":"predicate IsEven_10436(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_10437","instance":10437,"id":247124,"goal":"predicate InRange_10437(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_10438","instance":10438,"id":247125,"goal":"predicate SubsetOf_10438(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_10439","instance":10439,"id":247126,"goal":"predicate AllMem_10439(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_10440","instance":10440,"id":247127,"goal":"predicate DisjointSets_10440(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_10441","instance":10441,"id":247128,"goal":"predicate Sorted_10441(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_10442","instance":10442,"id":247129,"goal":"predicate AllPositive_10442(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_10443","instance":10443,"id":247130,"goal":"predicate DistinctSeq_10443(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_10444","instance":10444,"id":247131,"goal":"predicate IsSubseq_10444(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_10445","instance":10445,"id":247132,"goal":"predicate IsPermutation_10445(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_10446","instance":10446,"id":247133,"goal":"predicate IsEven_10446(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_10447","instance":10447,"id":247134,"goal":"predicate InRange_10447(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_10448","instance":10448,"id":247135,"goal":"predicate SubsetOf_10448(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_10449","instance":10449,"id":247136,"goal":"predicate AllMem_10449(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_10450","instance":10450,"id":247137,"goal":"predicate DisjointSets_10450(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_10451","instance":10451,"id":247138,"goal":"predicate Sorted_10451(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_10452","instance":10452,"id":247139,"goal":"predicate AllPositive_10452(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_10453","instance":10453,"id":247140,"goal":"predicate DistinctSeq_10453(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_10454","instance":10454,"id":247141,"goal":"predicate IsSubseq_10454(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_10455","instance":10455,"id":247142,"goal":"predicate IsPermutation_10455(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_10456","instance":10456,"id":247143,"goal":"predicate IsEven_10456(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_10457","instance":10457,"id":247144,"goal":"predicate InRange_10457(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_10458","instance":10458,"id":247145,"goal":"predicate SubsetOf_10458(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_10459","instance":10459,"id":247146,"goal":"predicate AllMem_10459(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_10460","instance":10460,"id":247147,"goal":"predicate DisjointSets_10460(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_10461","instance":10461,"id":247148,"goal":"predicate Sorted_10461(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_10462","instance":10462,"id":247149,"goal":"predicate AllPositive_10462(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_10463","instance":10463,"id":247150,"goal":"predicate DistinctSeq_10463(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_10464","instance":10464,"id":247151,"goal":"predicate IsSubseq_10464(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_10465","instance":10465,"id":247152,"goal":"predicate IsPermutation_10465(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_10466","instance":10466,"id":247153,"goal":"predicate IsEven_10466(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_10467","instance":10467,"id":247154,"goal":"predicate InRange_10467(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_10468","instance":10468,"id":247155,"goal":"predicate SubsetOf_10468(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_10469","instance":10469,"id":247156,"goal":"predicate AllMem_10469(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_10470","instance":10470,"id":247157,"goal":"predicate DisjointSets_10470(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_10471","instance":10471,"id":247158,"goal":"predicate Sorted_10471(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_10472","instance":10472,"id":247159,"goal":"predicate AllPositive_10472(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_10473","instance":10473,"id":247160,"goal":"predicate DistinctSeq_10473(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_10474","instance":10474,"id":247161,"goal":"predicate IsSubseq_10474(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_10475","instance":10475,"id":247162,"goal":"predicate IsPermutation_10475(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_10476","instance":10476,"id":247163,"goal":"predicate IsEven_10476(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_10477","instance":10477,"id":247164,"goal":"predicate InRange_10477(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_10478","instance":10478,"id":247165,"goal":"predicate SubsetOf_10478(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_10479","instance":10479,"id":247166,"goal":"predicate AllMem_10479(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_10480","instance":10480,"id":247167,"goal":"predicate DisjointSets_10480(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_10481","instance":10481,"id":247168,"goal":"predicate Sorted_10481(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_10482","instance":10482,"id":247169,"goal":"predicate AllPositive_10482(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_10483","instance":10483,"id":247170,"goal":"predicate DistinctSeq_10483(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_10484","instance":10484,"id":247171,"goal":"predicate IsSubseq_10484(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_10485","instance":10485,"id":247172,"goal":"predicate IsPermutation_10485(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_10486","instance":10486,"id":247173,"goal":"predicate IsEven_10486(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_10487","instance":10487,"id":247174,"goal":"predicate InRange_10487(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_10488","instance":10488,"id":247175,"goal":"predicate SubsetOf_10488(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_10489","instance":10489,"id":247176,"goal":"predicate AllMem_10489(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_10490","instance":10490,"id":247177,"goal":"predicate DisjointSets_10490(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_10491","instance":10491,"id":247178,"goal":"predicate Sorted_10491(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_10492","instance":10492,"id":247179,"goal":"predicate AllPositive_10492(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_10493","instance":10493,"id":247180,"goal":"predicate DistinctSeq_10493(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_10494","instance":10494,"id":247181,"goal":"predicate IsSubseq_10494(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_10495","instance":10495,"id":247182,"goal":"predicate IsPermutation_10495(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_10496","instance":10496,"id":247183,"goal":"predicate IsEven_10496(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_10497","instance":10497,"id":247184,"goal":"predicate InRange_10497(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_10498","instance":10498,"id":247185,"goal":"predicate SubsetOf_10498(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_10499","instance":10499,"id":247186,"goal":"predicate AllMem_10499(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_10500","instance":10500,"id":247187,"goal":"predicate DisjointSets_10500(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_10501","instance":10501,"id":247188,"goal":"predicate Sorted_10501(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_10502","instance":10502,"id":247189,"goal":"predicate AllPositive_10502(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_10503","instance":10503,"id":247190,"goal":"predicate DistinctSeq_10503(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_10504","instance":10504,"id":247191,"goal":"predicate IsSubseq_10504(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_10505","instance":10505,"id":247192,"goal":"predicate IsPermutation_10505(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_10506","instance":10506,"id":247193,"goal":"predicate IsEven_10506(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_10507","instance":10507,"id":247194,"goal":"predicate InRange_10507(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_10508","instance":10508,"id":247195,"goal":"predicate SubsetOf_10508(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_10509","instance":10509,"id":247196,"goal":"predicate AllMem_10509(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_10510","instance":10510,"id":247197,"goal":"predicate DisjointSets_10510(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_10511","instance":10511,"id":247198,"goal":"predicate Sorted_10511(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_10512","instance":10512,"id":247199,"goal":"predicate AllPositive_10512(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_10513","instance":10513,"id":247200,"goal":"predicate DistinctSeq_10513(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_10514","instance":10514,"id":247201,"goal":"predicate IsSubseq_10514(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_10515","instance":10515,"id":247202,"goal":"predicate IsPermutation_10515(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_10516","instance":10516,"id":247203,"goal":"predicate IsEven_10516(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_10517","instance":10517,"id":247204,"goal":"predicate InRange_10517(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_10518","instance":10518,"id":247205,"goal":"predicate SubsetOf_10518(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_10519","instance":10519,"id":247206,"goal":"predicate AllMem_10519(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_10520","instance":10520,"id":247207,"goal":"predicate DisjointSets_10520(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_10521","instance":10521,"id":247208,"goal":"predicate Sorted_10521(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_10522","instance":10522,"id":247209,"goal":"predicate AllPositive_10522(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_10523","instance":10523,"id":247210,"goal":"predicate DistinctSeq_10523(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_10524","instance":10524,"id":247211,"goal":"predicate IsSubseq_10524(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_10525","instance":10525,"id":247212,"goal":"predicate IsPermutation_10525(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_10526","instance":10526,"id":247213,"goal":"predicate IsEven_10526(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_10527","instance":10527,"id":247214,"goal":"predicate InRange_10527(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_10528","instance":10528,"id":247215,"goal":"predicate SubsetOf_10528(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_10529","instance":10529,"id":247216,"goal":"predicate AllMem_10529(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_10530","instance":10530,"id":247217,"goal":"predicate DisjointSets_10530(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_10531","instance":10531,"id":247218,"goal":"predicate Sorted_10531(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_10532","instance":10532,"id":247219,"goal":"predicate AllPositive_10532(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_10533","instance":10533,"id":247220,"goal":"predicate DistinctSeq_10533(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_10534","instance":10534,"id":247221,"goal":"predicate IsSubseq_10534(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_10535","instance":10535,"id":247222,"goal":"predicate IsPermutation_10535(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_10536","instance":10536,"id":247223,"goal":"predicate IsEven_10536(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_10537","instance":10537,"id":247224,"goal":"predicate InRange_10537(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_10538","instance":10538,"id":247225,"goal":"predicate SubsetOf_10538(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_10539","instance":10539,"id":247226,"goal":"predicate AllMem_10539(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_10540","instance":10540,"id":247227,"goal":"predicate DisjointSets_10540(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_10541","instance":10541,"id":247228,"goal":"predicate Sorted_10541(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_10542","instance":10542,"id":247229,"goal":"predicate AllPositive_10542(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_10543","instance":10543,"id":247230,"goal":"predicate DistinctSeq_10543(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_10544","instance":10544,"id":247231,"goal":"predicate IsSubseq_10544(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_10545","instance":10545,"id":247232,"goal":"predicate IsPermutation_10545(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_10546","instance":10546,"id":247233,"goal":"predicate IsEven_10546(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_10547","instance":10547,"id":247234,"goal":"predicate InRange_10547(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_10548","instance":10548,"id":247235,"goal":"predicate SubsetOf_10548(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_10549","instance":10549,"id":247236,"goal":"predicate AllMem_10549(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_10550","instance":10550,"id":247237,"goal":"predicate DisjointSets_10550(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_10551","instance":10551,"id":247238,"goal":"predicate Sorted_10551(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_10552","instance":10552,"id":247239,"goal":"predicate AllPositive_10552(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_10553","instance":10553,"id":247240,"goal":"predicate DistinctSeq_10553(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_10554","instance":10554,"id":247241,"goal":"predicate IsSubseq_10554(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_10555","instance":10555,"id":247242,"goal":"predicate IsPermutation_10555(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_10556","instance":10556,"id":247243,"goal":"predicate IsEven_10556(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_10557","instance":10557,"id":247244,"goal":"predicate InRange_10557(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_10558","instance":10558,"id":247245,"goal":"predicate SubsetOf_10558(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_10559","instance":10559,"id":247246,"goal":"predicate AllMem_10559(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_10560","instance":10560,"id":247247,"goal":"predicate DisjointSets_10560(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_10561","instance":10561,"id":247248,"goal":"predicate Sorted_10561(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_10562","instance":10562,"id":247249,"goal":"predicate AllPositive_10562(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_10563","instance":10563,"id":247250,"goal":"predicate DistinctSeq_10563(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_10564","instance":10564,"id":247251,"goal":"predicate IsSubseq_10564(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_10565","instance":10565,"id":247252,"goal":"predicate IsPermutation_10565(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_10566","instance":10566,"id":247253,"goal":"predicate IsEven_10566(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_10567","instance":10567,"id":247254,"goal":"predicate InRange_10567(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_10568","instance":10568,"id":247255,"goal":"predicate SubsetOf_10568(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_10569","instance":10569,"id":247256,"goal":"predicate AllMem_10569(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_10570","instance":10570,"id":247257,"goal":"predicate DisjointSets_10570(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_10571","instance":10571,"id":247258,"goal":"predicate Sorted_10571(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_10572","instance":10572,"id":247259,"goal":"predicate AllPositive_10572(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_10573","instance":10573,"id":247260,"goal":"predicate DistinctSeq_10573(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_10574","instance":10574,"id":247261,"goal":"predicate IsSubseq_10574(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_10575","instance":10575,"id":247262,"goal":"predicate IsPermutation_10575(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_10576","instance":10576,"id":247263,"goal":"predicate IsEven_10576(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_10577","instance":10577,"id":247264,"goal":"predicate InRange_10577(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_10578","instance":10578,"id":247265,"goal":"predicate SubsetOf_10578(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_10579","instance":10579,"id":247266,"goal":"predicate AllMem_10579(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_10580","instance":10580,"id":247267,"goal":"predicate DisjointSets_10580(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_10581","instance":10581,"id":247268,"goal":"predicate Sorted_10581(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_10582","instance":10582,"id":247269,"goal":"predicate AllPositive_10582(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_10583","instance":10583,"id":247270,"goal":"predicate DistinctSeq_10583(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_10584","instance":10584,"id":247271,"goal":"predicate IsSubseq_10584(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_10585","instance":10585,"id":247272,"goal":"predicate IsPermutation_10585(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_10586","instance":10586,"id":247273,"goal":"predicate IsEven_10586(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_10587","instance":10587,"id":247274,"goal":"predicate InRange_10587(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_10588","instance":10588,"id":247275,"goal":"predicate SubsetOf_10588(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_10589","instance":10589,"id":247276,"goal":"predicate AllMem_10589(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_10590","instance":10590,"id":247277,"goal":"predicate DisjointSets_10590(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_10591","instance":10591,"id":247278,"goal":"predicate Sorted_10591(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_10592","instance":10592,"id":247279,"goal":"predicate AllPositive_10592(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_10593","instance":10593,"id":247280,"goal":"predicate DistinctSeq_10593(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_10594","instance":10594,"id":247281,"goal":"predicate IsSubseq_10594(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_10595","instance":10595,"id":247282,"goal":"predicate IsPermutation_10595(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_10596","instance":10596,"id":247283,"goal":"predicate IsEven_10596(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_10597","instance":10597,"id":247284,"goal":"predicate InRange_10597(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_10598","instance":10598,"id":247285,"goal":"predicate SubsetOf_10598(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_10599","instance":10599,"id":247286,"goal":"predicate AllMem_10599(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_10600","instance":10600,"id":247287,"goal":"predicate DisjointSets_10600(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_10601","instance":10601,"id":247288,"goal":"predicate Sorted_10601(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_10602","instance":10602,"id":247289,"goal":"predicate AllPositive_10602(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_10603","instance":10603,"id":247290,"goal":"predicate DistinctSeq_10603(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_10604","instance":10604,"id":247291,"goal":"predicate IsSubseq_10604(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_10605","instance":10605,"id":247292,"goal":"predicate IsPermutation_10605(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_10606","instance":10606,"id":247293,"goal":"predicate IsEven_10606(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_10607","instance":10607,"id":247294,"goal":"predicate InRange_10607(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_10608","instance":10608,"id":247295,"goal":"predicate SubsetOf_10608(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_10609","instance":10609,"id":247296,"goal":"predicate AllMem_10609(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_10610","instance":10610,"id":247297,"goal":"predicate DisjointSets_10610(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_10611","instance":10611,"id":247298,"goal":"predicate Sorted_10611(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_10612","instance":10612,"id":247299,"goal":"predicate AllPositive_10612(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_10613","instance":10613,"id":247300,"goal":"predicate DistinctSeq_10613(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_10614","instance":10614,"id":247301,"goal":"predicate IsSubseq_10614(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_10615","instance":10615,"id":247302,"goal":"predicate IsPermutation_10615(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_10616","instance":10616,"id":247303,"goal":"predicate IsEven_10616(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_10617","instance":10617,"id":247304,"goal":"predicate InRange_10617(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_10618","instance":10618,"id":247305,"goal":"predicate SubsetOf_10618(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_10619","instance":10619,"id":247306,"goal":"predicate AllMem_10619(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_10620","instance":10620,"id":247307,"goal":"predicate DisjointSets_10620(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_10621","instance":10621,"id":247308,"goal":"predicate Sorted_10621(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_10622","instance":10622,"id":247309,"goal":"predicate AllPositive_10622(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_10623","instance":10623,"id":247310,"goal":"predicate DistinctSeq_10623(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_10624","instance":10624,"id":247311,"goal":"predicate IsSubseq_10624(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_10625","instance":10625,"id":247312,"goal":"predicate IsPermutation_10625(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_10626","instance":10626,"id":247313,"goal":"predicate IsEven_10626(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_10627","instance":10627,"id":247314,"goal":"predicate InRange_10627(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_10628","instance":10628,"id":247315,"goal":"predicate SubsetOf_10628(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_10629","instance":10629,"id":247316,"goal":"predicate AllMem_10629(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_10630","instance":10630,"id":247317,"goal":"predicate DisjointSets_10630(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_10631","instance":10631,"id":247318,"goal":"predicate Sorted_10631(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_10632","instance":10632,"id":247319,"goal":"predicate AllPositive_10632(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_10633","instance":10633,"id":247320,"goal":"predicate DistinctSeq_10633(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_10634","instance":10634,"id":247321,"goal":"predicate IsSubseq_10634(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_10635","instance":10635,"id":247322,"goal":"predicate IsPermutation_10635(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_10636","instance":10636,"id":247323,"goal":"predicate IsEven_10636(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_10637","instance":10637,"id":247324,"goal":"predicate InRange_10637(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_10638","instance":10638,"id":247325,"goal":"predicate SubsetOf_10638(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_10639","instance":10639,"id":247326,"goal":"predicate AllMem_10639(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_10640","instance":10640,"id":247327,"goal":"predicate DisjointSets_10640(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_10641","instance":10641,"id":247328,"goal":"predicate Sorted_10641(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_10642","instance":10642,"id":247329,"goal":"predicate AllPositive_10642(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_10643","instance":10643,"id":247330,"goal":"predicate DistinctSeq_10643(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_10644","instance":10644,"id":247331,"goal":"predicate IsSubseq_10644(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_10645","instance":10645,"id":247332,"goal":"predicate IsPermutation_10645(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_10646","instance":10646,"id":247333,"goal":"predicate IsEven_10646(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_10647","instance":10647,"id":247334,"goal":"predicate InRange_10647(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_10648","instance":10648,"id":247335,"goal":"predicate SubsetOf_10648(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_10649","instance":10649,"id":247336,"goal":"predicate AllMem_10649(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_10650","instance":10650,"id":247337,"goal":"predicate DisjointSets_10650(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_10651","instance":10651,"id":247338,"goal":"predicate Sorted_10651(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_10652","instance":10652,"id":247339,"goal":"predicate AllPositive_10652(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_10653","instance":10653,"id":247340,"goal":"predicate DistinctSeq_10653(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_10654","instance":10654,"id":247341,"goal":"predicate IsSubseq_10654(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_10655","instance":10655,"id":247342,"goal":"predicate IsPermutation_10655(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_10656","instance":10656,"id":247343,"goal":"predicate IsEven_10656(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_10657","instance":10657,"id":247344,"goal":"predicate InRange_10657(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_10658","instance":10658,"id":247345,"goal":"predicate SubsetOf_10658(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_10659","instance":10659,"id":247346,"goal":"predicate AllMem_10659(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_10660","instance":10660,"id":247347,"goal":"predicate DisjointSets_10660(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_10661","instance":10661,"id":247348,"goal":"predicate Sorted_10661(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_10662","instance":10662,"id":247349,"goal":"predicate AllPositive_10662(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_10663","instance":10663,"id":247350,"goal":"predicate DistinctSeq_10663(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_10664","instance":10664,"id":247351,"goal":"predicate IsSubseq_10664(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_10665","instance":10665,"id":247352,"goal":"predicate IsPermutation_10665(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_10666","instance":10666,"id":247353,"goal":"predicate IsEven_10666(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_10667","instance":10667,"id":247354,"goal":"predicate InRange_10667(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_10668","instance":10668,"id":247355,"goal":"predicate SubsetOf_10668(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_10669","instance":10669,"id":247356,"goal":"predicate AllMem_10669(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_10670","instance":10670,"id":247357,"goal":"predicate DisjointSets_10670(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_10671","instance":10671,"id":247358,"goal":"predicate Sorted_10671(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_10672","instance":10672,"id":247359,"goal":"predicate AllPositive_10672(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_10673","instance":10673,"id":247360,"goal":"predicate DistinctSeq_10673(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_10674","instance":10674,"id":247361,"goal":"predicate IsSubseq_10674(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_10675","instance":10675,"id":247362,"goal":"predicate IsPermutation_10675(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_10676","instance":10676,"id":247363,"goal":"predicate IsEven_10676(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_10677","instance":10677,"id":247364,"goal":"predicate InRange_10677(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_10678","instance":10678,"id":247365,"goal":"predicate SubsetOf_10678(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_10679","instance":10679,"id":247366,"goal":"predicate AllMem_10679(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_10680","instance":10680,"id":247367,"goal":"predicate DisjointSets_10680(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_10681","instance":10681,"id":247368,"goal":"predicate Sorted_10681(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_10682","instance":10682,"id":247369,"goal":"predicate AllPositive_10682(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_10683","instance":10683,"id":247370,"goal":"predicate DistinctSeq_10683(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_10684","instance":10684,"id":247371,"goal":"predicate IsSubseq_10684(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_10685","instance":10685,"id":247372,"goal":"predicate IsPermutation_10685(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_10686","instance":10686,"id":247373,"goal":"predicate IsEven_10686(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_10687","instance":10687,"id":247374,"goal":"predicate InRange_10687(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_10688","instance":10688,"id":247375,"goal":"predicate SubsetOf_10688(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_10689","instance":10689,"id":247376,"goal":"predicate AllMem_10689(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_10690","instance":10690,"id":247377,"goal":"predicate DisjointSets_10690(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_10691","instance":10691,"id":247378,"goal":"predicate Sorted_10691(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_10692","instance":10692,"id":247379,"goal":"predicate AllPositive_10692(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_10693","instance":10693,"id":247380,"goal":"predicate DistinctSeq_10693(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_10694","instance":10694,"id":247381,"goal":"predicate IsSubseq_10694(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_10695","instance":10695,"id":247382,"goal":"predicate IsPermutation_10695(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_10696","instance":10696,"id":247383,"goal":"predicate IsEven_10696(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_10697","instance":10697,"id":247384,"goal":"predicate InRange_10697(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_10698","instance":10698,"id":247385,"goal":"predicate SubsetOf_10698(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_10699","instance":10699,"id":247386,"goal":"predicate AllMem_10699(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_10700","instance":10700,"id":247387,"goal":"predicate DisjointSets_10700(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_10701","instance":10701,"id":247388,"goal":"predicate Sorted_10701(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_10702","instance":10702,"id":247389,"goal":"predicate AllPositive_10702(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_10703","instance":10703,"id":247390,"goal":"predicate DistinctSeq_10703(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_10704","instance":10704,"id":247391,"goal":"predicate IsSubseq_10704(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_10705","instance":10705,"id":247392,"goal":"predicate IsPermutation_10705(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_10706","instance":10706,"id":247393,"goal":"predicate IsEven_10706(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_10707","instance":10707,"id":247394,"goal":"predicate InRange_10707(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_10708","instance":10708,"id":247395,"goal":"predicate SubsetOf_10708(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_10709","instance":10709,"id":247396,"goal":"predicate AllMem_10709(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_10710","instance":10710,"id":247397,"goal":"predicate DisjointSets_10710(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_10711","instance":10711,"id":247398,"goal":"predicate Sorted_10711(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_10712","instance":10712,"id":247399,"goal":"predicate AllPositive_10712(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_10713","instance":10713,"id":247400,"goal":"predicate DistinctSeq_10713(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_10714","instance":10714,"id":247401,"goal":"predicate IsSubseq_10714(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_10715","instance":10715,"id":247402,"goal":"predicate IsPermutation_10715(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_10716","instance":10716,"id":247403,"goal":"predicate IsEven_10716(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_10717","instance":10717,"id":247404,"goal":"predicate InRange_10717(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_10718","instance":10718,"id":247405,"goal":"predicate SubsetOf_10718(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_10719","instance":10719,"id":247406,"goal":"predicate AllMem_10719(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_10720","instance":10720,"id":247407,"goal":"predicate DisjointSets_10720(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_10721","instance":10721,"id":247408,"goal":"predicate Sorted_10721(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_10722","instance":10722,"id":247409,"goal":"predicate AllPositive_10722(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_10723","instance":10723,"id":247410,"goal":"predicate DistinctSeq_10723(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_10724","instance":10724,"id":247411,"goal":"predicate IsSubseq_10724(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_10725","instance":10725,"id":247412,"goal":"predicate IsPermutation_10725(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_10726","instance":10726,"id":247413,"goal":"predicate IsEven_10726(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_10727","instance":10727,"id":247414,"goal":"predicate InRange_10727(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_10728","instance":10728,"id":247415,"goal":"predicate SubsetOf_10728(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_10729","instance":10729,"id":247416,"goal":"predicate AllMem_10729(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_10730","instance":10730,"id":247417,"goal":"predicate DisjointSets_10730(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_10731","instance":10731,"id":247418,"goal":"predicate Sorted_10731(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_10732","instance":10732,"id":247419,"goal":"predicate AllPositive_10732(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_10733","instance":10733,"id":247420,"goal":"predicate DistinctSeq_10733(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_10734","instance":10734,"id":247421,"goal":"predicate IsSubseq_10734(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_10735","instance":10735,"id":247422,"goal":"predicate IsPermutation_10735(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_10736","instance":10736,"id":247423,"goal":"predicate IsEven_10736(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_10737","instance":10737,"id":247424,"goal":"predicate InRange_10737(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_10738","instance":10738,"id":247425,"goal":"predicate SubsetOf_10738(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_10739","instance":10739,"id":247426,"goal":"predicate AllMem_10739(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_10740","instance":10740,"id":247427,"goal":"predicate DisjointSets_10740(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_10741","instance":10741,"id":247428,"goal":"predicate Sorted_10741(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_10742","instance":10742,"id":247429,"goal":"predicate AllPositive_10742(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_10743","instance":10743,"id":247430,"goal":"predicate DistinctSeq_10743(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_10744","instance":10744,"id":247431,"goal":"predicate IsSubseq_10744(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_10745","instance":10745,"id":247432,"goal":"predicate IsPermutation_10745(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_10746","instance":10746,"id":247433,"goal":"predicate IsEven_10746(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_10747","instance":10747,"id":247434,"goal":"predicate InRange_10747(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_10748","instance":10748,"id":247435,"goal":"predicate SubsetOf_10748(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_10749","instance":10749,"id":247436,"goal":"predicate AllMem_10749(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_10750","instance":10750,"id":247437,"goal":"predicate DisjointSets_10750(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_10751","instance":10751,"id":247438,"goal":"predicate Sorted_10751(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_10752","instance":10752,"id":247439,"goal":"predicate AllPositive_10752(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_10753","instance":10753,"id":247440,"goal":"predicate DistinctSeq_10753(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_10754","instance":10754,"id":247441,"goal":"predicate IsSubseq_10754(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_10755","instance":10755,"id":247442,"goal":"predicate IsPermutation_10755(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_10756","instance":10756,"id":247443,"goal":"predicate IsEven_10756(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_10757","instance":10757,"id":247444,"goal":"predicate InRange_10757(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_10758","instance":10758,"id":247445,"goal":"predicate SubsetOf_10758(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_10759","instance":10759,"id":247446,"goal":"predicate AllMem_10759(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_10760","instance":10760,"id":247447,"goal":"predicate DisjointSets_10760(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_10761","instance":10761,"id":247448,"goal":"predicate Sorted_10761(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_10762","instance":10762,"id":247449,"goal":"predicate AllPositive_10762(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_10763","instance":10763,"id":247450,"goal":"predicate DistinctSeq_10763(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_10764","instance":10764,"id":247451,"goal":"predicate IsSubseq_10764(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_10765","instance":10765,"id":247452,"goal":"predicate IsPermutation_10765(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_10766","instance":10766,"id":247453,"goal":"predicate IsEven_10766(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_10767","instance":10767,"id":247454,"goal":"predicate InRange_10767(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_10768","instance":10768,"id":247455,"goal":"predicate SubsetOf_10768(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_10769","instance":10769,"id":247456,"goal":"predicate AllMem_10769(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_10770","instance":10770,"id":247457,"goal":"predicate DisjointSets_10770(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_10771","instance":10771,"id":247458,"goal":"predicate Sorted_10771(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_10772","instance":10772,"id":247459,"goal":"predicate AllPositive_10772(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_10773","instance":10773,"id":247460,"goal":"predicate DistinctSeq_10773(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_10774","instance":10774,"id":247461,"goal":"predicate IsSubseq_10774(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_10775","instance":10775,"id":247462,"goal":"predicate IsPermutation_10775(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_10776","instance":10776,"id":247463,"goal":"predicate IsEven_10776(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_10777","instance":10777,"id":247464,"goal":"predicate InRange_10777(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_10778","instance":10778,"id":247465,"goal":"predicate SubsetOf_10778(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_10779","instance":10779,"id":247466,"goal":"predicate AllMem_10779(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_10780","instance":10780,"id":247467,"goal":"predicate DisjointSets_10780(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_10781","instance":10781,"id":247468,"goal":"predicate Sorted_10781(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_10782","instance":10782,"id":247469,"goal":"predicate AllPositive_10782(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_10783","instance":10783,"id":247470,"goal":"predicate DistinctSeq_10783(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_10784","instance":10784,"id":247471,"goal":"predicate IsSubseq_10784(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_10785","instance":10785,"id":247472,"goal":"predicate IsPermutation_10785(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_10786","instance":10786,"id":247473,"goal":"predicate IsEven_10786(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_10787","instance":10787,"id":247474,"goal":"predicate InRange_10787(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_10788","instance":10788,"id":247475,"goal":"predicate SubsetOf_10788(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_10789","instance":10789,"id":247476,"goal":"predicate AllMem_10789(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_10790","instance":10790,"id":247477,"goal":"predicate DisjointSets_10790(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_10791","instance":10791,"id":247478,"goal":"predicate Sorted_10791(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_10792","instance":10792,"id":247479,"goal":"predicate AllPositive_10792(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_10793","instance":10793,"id":247480,"goal":"predicate DistinctSeq_10793(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_10794","instance":10794,"id":247481,"goal":"predicate IsSubseq_10794(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_10795","instance":10795,"id":247482,"goal":"predicate IsPermutation_10795(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_10796","instance":10796,"id":247483,"goal":"predicate IsEven_10796(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_10797","instance":10797,"id":247484,"goal":"predicate InRange_10797(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_10798","instance":10798,"id":247485,"goal":"predicate SubsetOf_10798(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_10799","instance":10799,"id":247486,"goal":"predicate AllMem_10799(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_10800","instance":10800,"id":247487,"goal":"predicate DisjointSets_10800(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_10801","instance":10801,"id":247488,"goal":"predicate Sorted_10801(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_10802","instance":10802,"id":247489,"goal":"predicate AllPositive_10802(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_10803","instance":10803,"id":247490,"goal":"predicate DistinctSeq_10803(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_10804","instance":10804,"id":247491,"goal":"predicate IsSubseq_10804(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_10805","instance":10805,"id":247492,"goal":"predicate IsPermutation_10805(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_10806","instance":10806,"id":247493,"goal":"predicate IsEven_10806(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_10807","instance":10807,"id":247494,"goal":"predicate InRange_10807(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_10808","instance":10808,"id":247495,"goal":"predicate SubsetOf_10808(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_10809","instance":10809,"id":247496,"goal":"predicate AllMem_10809(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_10810","instance":10810,"id":247497,"goal":"predicate DisjointSets_10810(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_10811","instance":10811,"id":247498,"goal":"predicate Sorted_10811(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_10812","instance":10812,"id":247499,"goal":"predicate AllPositive_10812(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_10813","instance":10813,"id":247500,"goal":"predicate DistinctSeq_10813(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_10814","instance":10814,"id":247501,"goal":"predicate IsSubseq_10814(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_10815","instance":10815,"id":247502,"goal":"predicate IsPermutation_10815(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_10816","instance":10816,"id":247503,"goal":"predicate IsEven_10816(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_10817","instance":10817,"id":247504,"goal":"predicate InRange_10817(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_10818","instance":10818,"id":247505,"goal":"predicate SubsetOf_10818(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_10819","instance":10819,"id":247506,"goal":"predicate AllMem_10819(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_10820","instance":10820,"id":247507,"goal":"predicate DisjointSets_10820(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_10821","instance":10821,"id":247508,"goal":"predicate Sorted_10821(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_10822","instance":10822,"id":247509,"goal":"predicate AllPositive_10822(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_10823","instance":10823,"id":247510,"goal":"predicate DistinctSeq_10823(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_10824","instance":10824,"id":247511,"goal":"predicate IsSubseq_10824(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_10825","instance":10825,"id":247512,"goal":"predicate IsPermutation_10825(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_10826","instance":10826,"id":247513,"goal":"predicate IsEven_10826(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_10827","instance":10827,"id":247514,"goal":"predicate InRange_10827(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_10828","instance":10828,"id":247515,"goal":"predicate SubsetOf_10828(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_10829","instance":10829,"id":247516,"goal":"predicate AllMem_10829(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_10830","instance":10830,"id":247517,"goal":"predicate DisjointSets_10830(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_10831","instance":10831,"id":247518,"goal":"predicate Sorted_10831(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_10832","instance":10832,"id":247519,"goal":"predicate AllPositive_10832(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_10833","instance":10833,"id":247520,"goal":"predicate DistinctSeq_10833(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_10834","instance":10834,"id":247521,"goal":"predicate IsSubseq_10834(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_10835","instance":10835,"id":247522,"goal":"predicate IsPermutation_10835(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_10836","instance":10836,"id":247523,"goal":"predicate IsEven_10836(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_10837","instance":10837,"id":247524,"goal":"predicate InRange_10837(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_10838","instance":10838,"id":247525,"goal":"predicate SubsetOf_10838(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_10839","instance":10839,"id":247526,"goal":"predicate AllMem_10839(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_10840","instance":10840,"id":247527,"goal":"predicate DisjointSets_10840(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_10841","instance":10841,"id":247528,"goal":"predicate Sorted_10841(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_10842","instance":10842,"id":247529,"goal":"predicate AllPositive_10842(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_10843","instance":10843,"id":247530,"goal":"predicate DistinctSeq_10843(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_10844","instance":10844,"id":247531,"goal":"predicate IsSubseq_10844(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_10845","instance":10845,"id":247532,"goal":"predicate IsPermutation_10845(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_10846","instance":10846,"id":247533,"goal":"predicate IsEven_10846(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_10847","instance":10847,"id":247534,"goal":"predicate InRange_10847(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_10848","instance":10848,"id":247535,"goal":"predicate SubsetOf_10848(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_10849","instance":10849,"id":247536,"goal":"predicate AllMem_10849(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_10850","instance":10850,"id":247537,"goal":"predicate DisjointSets_10850(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_10851","instance":10851,"id":247538,"goal":"predicate Sorted_10851(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_10852","instance":10852,"id":247539,"goal":"predicate AllPositive_10852(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_10853","instance":10853,"id":247540,"goal":"predicate DistinctSeq_10853(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_10854","instance":10854,"id":247541,"goal":"predicate IsSubseq_10854(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_10855","instance":10855,"id":247542,"goal":"predicate IsPermutation_10855(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_10856","instance":10856,"id":247543,"goal":"predicate IsEven_10856(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_10857","instance":10857,"id":247544,"goal":"predicate InRange_10857(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_10858","instance":10858,"id":247545,"goal":"predicate SubsetOf_10858(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_10859","instance":10859,"id":247546,"goal":"predicate AllMem_10859(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_10860","instance":10860,"id":247547,"goal":"predicate DisjointSets_10860(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_10861","instance":10861,"id":247548,"goal":"predicate Sorted_10861(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_10862","instance":10862,"id":247549,"goal":"predicate AllPositive_10862(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_10863","instance":10863,"id":247550,"goal":"predicate DistinctSeq_10863(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_10864","instance":10864,"id":247551,"goal":"predicate IsSubseq_10864(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_10865","instance":10865,"id":247552,"goal":"predicate IsPermutation_10865(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_10866","instance":10866,"id":247553,"goal":"predicate IsEven_10866(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_10867","instance":10867,"id":247554,"goal":"predicate InRange_10867(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_10868","instance":10868,"id":247555,"goal":"predicate SubsetOf_10868(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_10869","instance":10869,"id":247556,"goal":"predicate AllMem_10869(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_10870","instance":10870,"id":247557,"goal":"predicate DisjointSets_10870(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_10871","instance":10871,"id":247558,"goal":"predicate Sorted_10871(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_10872","instance":10872,"id":247559,"goal":"predicate AllPositive_10872(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_10873","instance":10873,"id":247560,"goal":"predicate DistinctSeq_10873(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_10874","instance":10874,"id":247561,"goal":"predicate IsSubseq_10874(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_10875","instance":10875,"id":247562,"goal":"predicate IsPermutation_10875(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_10876","instance":10876,"id":247563,"goal":"predicate IsEven_10876(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_10877","instance":10877,"id":247564,"goal":"predicate InRange_10877(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_10878","instance":10878,"id":247565,"goal":"predicate SubsetOf_10878(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_10879","instance":10879,"id":247566,"goal":"predicate AllMem_10879(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_10880","instance":10880,"id":247567,"goal":"predicate DisjointSets_10880(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_10881","instance":10881,"id":247568,"goal":"predicate Sorted_10881(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_10882","instance":10882,"id":247569,"goal":"predicate AllPositive_10882(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_10883","instance":10883,"id":247570,"goal":"predicate DistinctSeq_10883(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_10884","instance":10884,"id":247571,"goal":"predicate IsSubseq_10884(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_10885","instance":10885,"id":247572,"goal":"predicate IsPermutation_10885(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_10886","instance":10886,"id":247573,"goal":"predicate IsEven_10886(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_10887","instance":10887,"id":247574,"goal":"predicate InRange_10887(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_10888","instance":10888,"id":247575,"goal":"predicate SubsetOf_10888(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_10889","instance":10889,"id":247576,"goal":"predicate AllMem_10889(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_10890","instance":10890,"id":247577,"goal":"predicate DisjointSets_10890(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_10891","instance":10891,"id":247578,"goal":"predicate Sorted_10891(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_10892","instance":10892,"id":247579,"goal":"predicate AllPositive_10892(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_10893","instance":10893,"id":247580,"goal":"predicate DistinctSeq_10893(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_10894","instance":10894,"id":247581,"goal":"predicate IsSubseq_10894(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_10895","instance":10895,"id":247582,"goal":"predicate IsPermutation_10895(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_10896","instance":10896,"id":247583,"goal":"predicate IsEven_10896(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_10897","instance":10897,"id":247584,"goal":"predicate InRange_10897(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_10898","instance":10898,"id":247585,"goal":"predicate SubsetOf_10898(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_10899","instance":10899,"id":247586,"goal":"predicate AllMem_10899(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_10900","instance":10900,"id":247587,"goal":"predicate DisjointSets_10900(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_10901","instance":10901,"id":247588,"goal":"predicate Sorted_10901(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_10902","instance":10902,"id":247589,"goal":"predicate AllPositive_10902(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_10903","instance":10903,"id":247590,"goal":"predicate DistinctSeq_10903(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_10904","instance":10904,"id":247591,"goal":"predicate IsSubseq_10904(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_10905","instance":10905,"id":247592,"goal":"predicate IsPermutation_10905(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_10906","instance":10906,"id":247593,"goal":"predicate IsEven_10906(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_10907","instance":10907,"id":247594,"goal":"predicate InRange_10907(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_10908","instance":10908,"id":247595,"goal":"predicate SubsetOf_10908(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_10909","instance":10909,"id":247596,"goal":"predicate AllMem_10909(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_10910","instance":10910,"id":247597,"goal":"predicate DisjointSets_10910(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_10911","instance":10911,"id":247598,"goal":"predicate Sorted_10911(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_10912","instance":10912,"id":247599,"goal":"predicate AllPositive_10912(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_10913","instance":10913,"id":247600,"goal":"predicate DistinctSeq_10913(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_10914","instance":10914,"id":247601,"goal":"predicate IsSubseq_10914(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_10915","instance":10915,"id":247602,"goal":"predicate IsPermutation_10915(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_10916","instance":10916,"id":247603,"goal":"predicate IsEven_10916(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_10917","instance":10917,"id":247604,"goal":"predicate InRange_10917(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_10918","instance":10918,"id":247605,"goal":"predicate SubsetOf_10918(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_10919","instance":10919,"id":247606,"goal":"predicate AllMem_10919(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_10920","instance":10920,"id":247607,"goal":"predicate DisjointSets_10920(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_10921","instance":10921,"id":247608,"goal":"predicate Sorted_10921(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_10922","instance":10922,"id":247609,"goal":"predicate AllPositive_10922(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_10923","instance":10923,"id":247610,"goal":"predicate DistinctSeq_10923(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_10924","instance":10924,"id":247611,"goal":"predicate IsSubseq_10924(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_10925","instance":10925,"id":247612,"goal":"predicate IsPermutation_10925(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_10926","instance":10926,"id":247613,"goal":"predicate IsEven_10926(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_10927","instance":10927,"id":247614,"goal":"predicate InRange_10927(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_10928","instance":10928,"id":247615,"goal":"predicate SubsetOf_10928(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_10929","instance":10929,"id":247616,"goal":"predicate AllMem_10929(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_10930","instance":10930,"id":247617,"goal":"predicate DisjointSets_10930(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_10931","instance":10931,"id":247618,"goal":"predicate Sorted_10931(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_10932","instance":10932,"id":247619,"goal":"predicate AllPositive_10932(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_10933","instance":10933,"id":247620,"goal":"predicate DistinctSeq_10933(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_10934","instance":10934,"id":247621,"goal":"predicate IsSubseq_10934(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_10935","instance":10935,"id":247622,"goal":"predicate IsPermutation_10935(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_10936","instance":10936,"id":247623,"goal":"predicate IsEven_10936(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_10937","instance":10937,"id":247624,"goal":"predicate InRange_10937(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_10938","instance":10938,"id":247625,"goal":"predicate SubsetOf_10938(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_10939","instance":10939,"id":247626,"goal":"predicate AllMem_10939(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_10940","instance":10940,"id":247627,"goal":"predicate DisjointSets_10940(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_10941","instance":10941,"id":247628,"goal":"predicate Sorted_10941(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_10942","instance":10942,"id":247629,"goal":"predicate AllPositive_10942(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_10943","instance":10943,"id":247630,"goal":"predicate DistinctSeq_10943(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_10944","instance":10944,"id":247631,"goal":"predicate IsSubseq_10944(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_10945","instance":10945,"id":247632,"goal":"predicate IsPermutation_10945(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_10946","instance":10946,"id":247633,"goal":"predicate IsEven_10946(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_10947","instance":10947,"id":247634,"goal":"predicate InRange_10947(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_10948","instance":10948,"id":247635,"goal":"predicate SubsetOf_10948(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_10949","instance":10949,"id":247636,"goal":"predicate AllMem_10949(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_10950","instance":10950,"id":247637,"goal":"predicate DisjointSets_10950(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_10951","instance":10951,"id":247638,"goal":"predicate Sorted_10951(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_10952","instance":10952,"id":247639,"goal":"predicate AllPositive_10952(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_10953","instance":10953,"id":247640,"goal":"predicate DistinctSeq_10953(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_10954","instance":10954,"id":247641,"goal":"predicate IsSubseq_10954(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_10955","instance":10955,"id":247642,"goal":"predicate IsPermutation_10955(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_10956","instance":10956,"id":247643,"goal":"predicate IsEven_10956(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_10957","instance":10957,"id":247644,"goal":"predicate InRange_10957(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_10958","instance":10958,"id":247645,"goal":"predicate SubsetOf_10958(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_10959","instance":10959,"id":247646,"goal":"predicate AllMem_10959(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_10960","instance":10960,"id":247647,"goal":"predicate DisjointSets_10960(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_10961","instance":10961,"id":247648,"goal":"predicate Sorted_10961(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_10962","instance":10962,"id":247649,"goal":"predicate AllPositive_10962(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_10963","instance":10963,"id":247650,"goal":"predicate DistinctSeq_10963(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_10964","instance":10964,"id":247651,"goal":"predicate IsSubseq_10964(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_10965","instance":10965,"id":247652,"goal":"predicate IsPermutation_10965(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_10966","instance":10966,"id":247653,"goal":"predicate IsEven_10966(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_10967","instance":10967,"id":247654,"goal":"predicate InRange_10967(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_10968","instance":10968,"id":247655,"goal":"predicate SubsetOf_10968(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_10969","instance":10969,"id":247656,"goal":"predicate AllMem_10969(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_10970","instance":10970,"id":247657,"goal":"predicate DisjointSets_10970(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_10971","instance":10971,"id":247658,"goal":"predicate Sorted_10971(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_10972","instance":10972,"id":247659,"goal":"predicate AllPositive_10972(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_10973","instance":10973,"id":247660,"goal":"predicate DistinctSeq_10973(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_10974","instance":10974,"id":247661,"goal":"predicate IsSubseq_10974(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_10975","instance":10975,"id":247662,"goal":"predicate IsPermutation_10975(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_10976","instance":10976,"id":247663,"goal":"predicate IsEven_10976(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_10977","instance":10977,"id":247664,"goal":"predicate InRange_10977(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_10978","instance":10978,"id":247665,"goal":"predicate SubsetOf_10978(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_10979","instance":10979,"id":247666,"goal":"predicate AllMem_10979(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_10980","instance":10980,"id":247667,"goal":"predicate DisjointSets_10980(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_10981","instance":10981,"id":247668,"goal":"predicate Sorted_10981(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_10982","instance":10982,"id":247669,"goal":"predicate AllPositive_10982(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_10983","instance":10983,"id":247670,"goal":"predicate DistinctSeq_10983(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_10984","instance":10984,"id":247671,"goal":"predicate IsSubseq_10984(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_10985","instance":10985,"id":247672,"goal":"predicate IsPermutation_10985(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_10986","instance":10986,"id":247673,"goal":"predicate IsEven_10986(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_10987","instance":10987,"id":247674,"goal":"predicate InRange_10987(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_10988","instance":10988,"id":247675,"goal":"predicate SubsetOf_10988(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_10989","instance":10989,"id":247676,"goal":"predicate AllMem_10989(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_10990","instance":10990,"id":247677,"goal":"predicate DisjointSets_10990(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_10991","instance":10991,"id":247678,"goal":"predicate Sorted_10991(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_10992","instance":10992,"id":247679,"goal":"predicate AllPositive_10992(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_10993","instance":10993,"id":247680,"goal":"predicate DistinctSeq_10993(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_10994","instance":10994,"id":247681,"goal":"predicate IsSubseq_10994(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_10995","instance":10995,"id":247682,"goal":"predicate IsPermutation_10995(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_10996","instance":10996,"id":247683,"goal":"predicate IsEven_10996(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_10997","instance":10997,"id":247684,"goal":"predicate InRange_10997(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_10998","instance":10998,"id":247685,"goal":"predicate SubsetOf_10998(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_10999","instance":10999,"id":247686,"goal":"predicate AllMem_10999(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_11000","instance":11000,"id":247687,"goal":"predicate DisjointSets_11000(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_11001","instance":11001,"id":247688,"goal":"predicate Sorted_11001(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_11002","instance":11002,"id":247689,"goal":"predicate AllPositive_11002(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_11003","instance":11003,"id":247690,"goal":"predicate DistinctSeq_11003(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_11004","instance":11004,"id":247691,"goal":"predicate IsSubseq_11004(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_11005","instance":11005,"id":247692,"goal":"predicate IsPermutation_11005(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_11006","instance":11006,"id":247693,"goal":"predicate IsEven_11006(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_11007","instance":11007,"id":247694,"goal":"predicate InRange_11007(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_11008","instance":11008,"id":247695,"goal":"predicate SubsetOf_11008(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_11009","instance":11009,"id":247696,"goal":"predicate AllMem_11009(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_11010","instance":11010,"id":247697,"goal":"predicate DisjointSets_11010(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_11011","instance":11011,"id":247698,"goal":"predicate Sorted_11011(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_11012","instance":11012,"id":247699,"goal":"predicate AllPositive_11012(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_11013","instance":11013,"id":247700,"goal":"predicate DistinctSeq_11013(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_11014","instance":11014,"id":247701,"goal":"predicate IsSubseq_11014(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_11015","instance":11015,"id":247702,"goal":"predicate IsPermutation_11015(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_11016","instance":11016,"id":247703,"goal":"predicate IsEven_11016(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_11017","instance":11017,"id":247704,"goal":"predicate InRange_11017(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_11018","instance":11018,"id":247705,"goal":"predicate SubsetOf_11018(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_11019","instance":11019,"id":247706,"goal":"predicate AllMem_11019(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_11020","instance":11020,"id":247707,"goal":"predicate DisjointSets_11020(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_11021","instance":11021,"id":247708,"goal":"predicate Sorted_11021(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_11022","instance":11022,"id":247709,"goal":"predicate AllPositive_11022(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_11023","instance":11023,"id":247710,"goal":"predicate DistinctSeq_11023(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_11024","instance":11024,"id":247711,"goal":"predicate IsSubseq_11024(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_11025","instance":11025,"id":247712,"goal":"predicate IsPermutation_11025(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_11026","instance":11026,"id":247713,"goal":"predicate IsEven_11026(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_11027","instance":11027,"id":247714,"goal":"predicate InRange_11027(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_11028","instance":11028,"id":247715,"goal":"predicate SubsetOf_11028(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_11029","instance":11029,"id":247716,"goal":"predicate AllMem_11029(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_11030","instance":11030,"id":247717,"goal":"predicate DisjointSets_11030(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_11031","instance":11031,"id":247718,"goal":"predicate Sorted_11031(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_11032","instance":11032,"id":247719,"goal":"predicate AllPositive_11032(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_11033","instance":11033,"id":247720,"goal":"predicate DistinctSeq_11033(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_11034","instance":11034,"id":247721,"goal":"predicate IsSubseq_11034(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_11035","instance":11035,"id":247722,"goal":"predicate IsPermutation_11035(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_11036","instance":11036,"id":247723,"goal":"predicate IsEven_11036(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_11037","instance":11037,"id":247724,"goal":"predicate InRange_11037(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_11038","instance":11038,"id":247725,"goal":"predicate SubsetOf_11038(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_11039","instance":11039,"id":247726,"goal":"predicate AllMem_11039(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_11040","instance":11040,"id":247727,"goal":"predicate DisjointSets_11040(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_11041","instance":11041,"id":247728,"goal":"predicate Sorted_11041(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_11042","instance":11042,"id":247729,"goal":"predicate AllPositive_11042(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_11043","instance":11043,"id":247730,"goal":"predicate DistinctSeq_11043(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_11044","instance":11044,"id":247731,"goal":"predicate IsSubseq_11044(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_11045","instance":11045,"id":247732,"goal":"predicate IsPermutation_11045(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_11046","instance":11046,"id":247733,"goal":"predicate IsEven_11046(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_11047","instance":11047,"id":247734,"goal":"predicate InRange_11047(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_11048","instance":11048,"id":247735,"goal":"predicate SubsetOf_11048(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_11049","instance":11049,"id":247736,"goal":"predicate AllMem_11049(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_11050","instance":11050,"id":247737,"goal":"predicate DisjointSets_11050(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_11051","instance":11051,"id":247738,"goal":"predicate Sorted_11051(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_11052","instance":11052,"id":247739,"goal":"predicate AllPositive_11052(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_11053","instance":11053,"id":247740,"goal":"predicate DistinctSeq_11053(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_11054","instance":11054,"id":247741,"goal":"predicate IsSubseq_11054(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_11055","instance":11055,"id":247742,"goal":"predicate IsPermutation_11055(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_11056","instance":11056,"id":247743,"goal":"predicate IsEven_11056(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_11057","instance":11057,"id":247744,"goal":"predicate InRange_11057(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_11058","instance":11058,"id":247745,"goal":"predicate SubsetOf_11058(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_11059","instance":11059,"id":247746,"goal":"predicate AllMem_11059(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_11060","instance":11060,"id":247747,"goal":"predicate DisjointSets_11060(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_11061","instance":11061,"id":247748,"goal":"predicate Sorted_11061(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_11062","instance":11062,"id":247749,"goal":"predicate AllPositive_11062(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_11063","instance":11063,"id":247750,"goal":"predicate DistinctSeq_11063(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_11064","instance":11064,"id":247751,"goal":"predicate IsSubseq_11064(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_11065","instance":11065,"id":247752,"goal":"predicate IsPermutation_11065(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_11066","instance":11066,"id":247753,"goal":"predicate IsEven_11066(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_11067","instance":11067,"id":247754,"goal":"predicate InRange_11067(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_11068","instance":11068,"id":247755,"goal":"predicate SubsetOf_11068(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_11069","instance":11069,"id":247756,"goal":"predicate AllMem_11069(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_11070","instance":11070,"id":247757,"goal":"predicate DisjointSets_11070(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_11071","instance":11071,"id":247758,"goal":"predicate Sorted_11071(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_11072","instance":11072,"id":247759,"goal":"predicate AllPositive_11072(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_11073","instance":11073,"id":247760,"goal":"predicate DistinctSeq_11073(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_11074","instance":11074,"id":247761,"goal":"predicate IsSubseq_11074(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_11075","instance":11075,"id":247762,"goal":"predicate IsPermutation_11075(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_11076","instance":11076,"id":247763,"goal":"predicate IsEven_11076(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_11077","instance":11077,"id":247764,"goal":"predicate InRange_11077(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_11078","instance":11078,"id":247765,"goal":"predicate SubsetOf_11078(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_11079","instance":11079,"id":247766,"goal":"predicate AllMem_11079(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_11080","instance":11080,"id":247767,"goal":"predicate DisjointSets_11080(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_11081","instance":11081,"id":247768,"goal":"predicate Sorted_11081(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_11082","instance":11082,"id":247769,"goal":"predicate AllPositive_11082(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_11083","instance":11083,"id":247770,"goal":"predicate DistinctSeq_11083(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_11084","instance":11084,"id":247771,"goal":"predicate IsSubseq_11084(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_11085","instance":11085,"id":247772,"goal":"predicate IsPermutation_11085(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_11086","instance":11086,"id":247773,"goal":"predicate IsEven_11086(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_11087","instance":11087,"id":247774,"goal":"predicate InRange_11087(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_11088","instance":11088,"id":247775,"goal":"predicate SubsetOf_11088(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_11089","instance":11089,"id":247776,"goal":"predicate AllMem_11089(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_11090","instance":11090,"id":247777,"goal":"predicate DisjointSets_11090(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_11091","instance":11091,"id":247778,"goal":"predicate Sorted_11091(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_11092","instance":11092,"id":247779,"goal":"predicate AllPositive_11092(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_11093","instance":11093,"id":247780,"goal":"predicate DistinctSeq_11093(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_11094","instance":11094,"id":247781,"goal":"predicate IsSubseq_11094(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_11095","instance":11095,"id":247782,"goal":"predicate IsPermutation_11095(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_11096","instance":11096,"id":247783,"goal":"predicate IsEven_11096(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_11097","instance":11097,"id":247784,"goal":"predicate InRange_11097(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_11098","instance":11098,"id":247785,"goal":"predicate SubsetOf_11098(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_11099","instance":11099,"id":247786,"goal":"predicate AllMem_11099(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_11100","instance":11100,"id":247787,"goal":"predicate DisjointSets_11100(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_11101","instance":11101,"id":247788,"goal":"predicate Sorted_11101(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_11102","instance":11102,"id":247789,"goal":"predicate AllPositive_11102(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_11103","instance":11103,"id":247790,"goal":"predicate DistinctSeq_11103(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_11104","instance":11104,"id":247791,"goal":"predicate IsSubseq_11104(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_11105","instance":11105,"id":247792,"goal":"predicate IsPermutation_11105(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_11106","instance":11106,"id":247793,"goal":"predicate IsEven_11106(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_11107","instance":11107,"id":247794,"goal":"predicate InRange_11107(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_11108","instance":11108,"id":247795,"goal":"predicate SubsetOf_11108(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_11109","instance":11109,"id":247796,"goal":"predicate AllMem_11109(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_11110","instance":11110,"id":247797,"goal":"predicate DisjointSets_11110(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_11111","instance":11111,"id":247798,"goal":"predicate Sorted_11111(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_11112","instance":11112,"id":247799,"goal":"predicate AllPositive_11112(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_11113","instance":11113,"id":247800,"goal":"predicate DistinctSeq_11113(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_11114","instance":11114,"id":247801,"goal":"predicate IsSubseq_11114(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_11115","instance":11115,"id":247802,"goal":"predicate IsPermutation_11115(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_11116","instance":11116,"id":247803,"goal":"predicate IsEven_11116(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_11117","instance":11117,"id":247804,"goal":"predicate InRange_11117(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_11118","instance":11118,"id":247805,"goal":"predicate SubsetOf_11118(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_11119","instance":11119,"id":247806,"goal":"predicate AllMem_11119(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_11120","instance":11120,"id":247807,"goal":"predicate DisjointSets_11120(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_11121","instance":11121,"id":247808,"goal":"predicate Sorted_11121(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_11122","instance":11122,"id":247809,"goal":"predicate AllPositive_11122(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_11123","instance":11123,"id":247810,"goal":"predicate DistinctSeq_11123(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_11124","instance":11124,"id":247811,"goal":"predicate IsSubseq_11124(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_11125","instance":11125,"id":247812,"goal":"predicate IsPermutation_11125(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_11126","instance":11126,"id":247813,"goal":"predicate IsEven_11126(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_11127","instance":11127,"id":247814,"goal":"predicate InRange_11127(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_11128","instance":11128,"id":247815,"goal":"predicate SubsetOf_11128(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_11129","instance":11129,"id":247816,"goal":"predicate AllMem_11129(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_11130","instance":11130,"id":247817,"goal":"predicate DisjointSets_11130(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_11131","instance":11131,"id":247818,"goal":"predicate Sorted_11131(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_11132","instance":11132,"id":247819,"goal":"predicate AllPositive_11132(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_11133","instance":11133,"id":247820,"goal":"predicate DistinctSeq_11133(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_11134","instance":11134,"id":247821,"goal":"predicate IsSubseq_11134(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_11135","instance":11135,"id":247822,"goal":"predicate IsPermutation_11135(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_11136","instance":11136,"id":247823,"goal":"predicate IsEven_11136(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_11137","instance":11137,"id":247824,"goal":"predicate InRange_11137(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_11138","instance":11138,"id":247825,"goal":"predicate SubsetOf_11138(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_11139","instance":11139,"id":247826,"goal":"predicate AllMem_11139(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_11140","instance":11140,"id":247827,"goal":"predicate DisjointSets_11140(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_11141","instance":11141,"id":247828,"goal":"predicate Sorted_11141(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_11142","instance":11142,"id":247829,"goal":"predicate AllPositive_11142(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_11143","instance":11143,"id":247830,"goal":"predicate DistinctSeq_11143(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_11144","instance":11144,"id":247831,"goal":"predicate IsSubseq_11144(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_11145","instance":11145,"id":247832,"goal":"predicate IsPermutation_11145(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_11146","instance":11146,"id":247833,"goal":"predicate IsEven_11146(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_11147","instance":11147,"id":247834,"goal":"predicate InRange_11147(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_11148","instance":11148,"id":247835,"goal":"predicate SubsetOf_11148(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_11149","instance":11149,"id":247836,"goal":"predicate AllMem_11149(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_11150","instance":11150,"id":247837,"goal":"predicate DisjointSets_11150(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_11151","instance":11151,"id":247838,"goal":"predicate Sorted_11151(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_11152","instance":11152,"id":247839,"goal":"predicate AllPositive_11152(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_11153","instance":11153,"id":247840,"goal":"predicate DistinctSeq_11153(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_11154","instance":11154,"id":247841,"goal":"predicate IsSubseq_11154(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_11155","instance":11155,"id":247842,"goal":"predicate IsPermutation_11155(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_11156","instance":11156,"id":247843,"goal":"predicate IsEven_11156(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_11157","instance":11157,"id":247844,"goal":"predicate InRange_11157(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_11158","instance":11158,"id":247845,"goal":"predicate SubsetOf_11158(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_11159","instance":11159,"id":247846,"goal":"predicate AllMem_11159(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_11160","instance":11160,"id":247847,"goal":"predicate DisjointSets_11160(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_11161","instance":11161,"id":247848,"goal":"predicate Sorted_11161(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_11162","instance":11162,"id":247849,"goal":"predicate AllPositive_11162(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_11163","instance":11163,"id":247850,"goal":"predicate DistinctSeq_11163(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_11164","instance":11164,"id":247851,"goal":"predicate IsSubseq_11164(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_11165","instance":11165,"id":247852,"goal":"predicate IsPermutation_11165(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_11166","instance":11166,"id":247853,"goal":"predicate IsEven_11166(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_11167","instance":11167,"id":247854,"goal":"predicate InRange_11167(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_11168","instance":11168,"id":247855,"goal":"predicate SubsetOf_11168(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_11169","instance":11169,"id":247856,"goal":"predicate AllMem_11169(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_11170","instance":11170,"id":247857,"goal":"predicate DisjointSets_11170(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_11171","instance":11171,"id":247858,"goal":"predicate Sorted_11171(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_11172","instance":11172,"id":247859,"goal":"predicate AllPositive_11172(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_11173","instance":11173,"id":247860,"goal":"predicate DistinctSeq_11173(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_11174","instance":11174,"id":247861,"goal":"predicate IsSubseq_11174(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_11175","instance":11175,"id":247862,"goal":"predicate IsPermutation_11175(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_11176","instance":11176,"id":247863,"goal":"predicate IsEven_11176(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_11177","instance":11177,"id":247864,"goal":"predicate InRange_11177(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_11178","instance":11178,"id":247865,"goal":"predicate SubsetOf_11178(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_11179","instance":11179,"id":247866,"goal":"predicate AllMem_11179(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_11180","instance":11180,"id":247867,"goal":"predicate DisjointSets_11180(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_11181","instance":11181,"id":247868,"goal":"predicate Sorted_11181(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_11182","instance":11182,"id":247869,"goal":"predicate AllPositive_11182(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_11183","instance":11183,"id":247870,"goal":"predicate DistinctSeq_11183(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_11184","instance":11184,"id":247871,"goal":"predicate IsSubseq_11184(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_11185","instance":11185,"id":247872,"goal":"predicate IsPermutation_11185(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_11186","instance":11186,"id":247873,"goal":"predicate IsEven_11186(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_11187","instance":11187,"id":247874,"goal":"predicate InRange_11187(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_11188","instance":11188,"id":247875,"goal":"predicate SubsetOf_11188(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_11189","instance":11189,"id":247876,"goal":"predicate AllMem_11189(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_11190","instance":11190,"id":247877,"goal":"predicate DisjointSets_11190(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_11191","instance":11191,"id":247878,"goal":"predicate Sorted_11191(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_11192","instance":11192,"id":247879,"goal":"predicate AllPositive_11192(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_11193","instance":11193,"id":247880,"goal":"predicate DistinctSeq_11193(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_11194","instance":11194,"id":247881,"goal":"predicate IsSubseq_11194(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_11195","instance":11195,"id":247882,"goal":"predicate IsPermutation_11195(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_11196","instance":11196,"id":247883,"goal":"predicate IsEven_11196(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_11197","instance":11197,"id":247884,"goal":"predicate InRange_11197(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_11198","instance":11198,"id":247885,"goal":"predicate SubsetOf_11198(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_11199","instance":11199,"id":247886,"goal":"predicate AllMem_11199(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_11200","instance":11200,"id":247887,"goal":"predicate DisjointSets_11200(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_11201","instance":11201,"id":247888,"goal":"predicate Sorted_11201(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_11202","instance":11202,"id":247889,"goal":"predicate AllPositive_11202(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_11203","instance":11203,"id":247890,"goal":"predicate DistinctSeq_11203(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_11204","instance":11204,"id":247891,"goal":"predicate IsSubseq_11204(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_11205","instance":11205,"id":247892,"goal":"predicate IsPermutation_11205(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_11206","instance":11206,"id":247893,"goal":"predicate IsEven_11206(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_11207","instance":11207,"id":247894,"goal":"predicate InRange_11207(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_11208","instance":11208,"id":247895,"goal":"predicate SubsetOf_11208(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_11209","instance":11209,"id":247896,"goal":"predicate AllMem_11209(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_11210","instance":11210,"id":247897,"goal":"predicate DisjointSets_11210(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_11211","instance":11211,"id":247898,"goal":"predicate Sorted_11211(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_11212","instance":11212,"id":247899,"goal":"predicate AllPositive_11212(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_11213","instance":11213,"id":247900,"goal":"predicate DistinctSeq_11213(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_11214","instance":11214,"id":247901,"goal":"predicate IsSubseq_11214(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_11215","instance":11215,"id":247902,"goal":"predicate IsPermutation_11215(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_11216","instance":11216,"id":247903,"goal":"predicate IsEven_11216(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_11217","instance":11217,"id":247904,"goal":"predicate InRange_11217(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_11218","instance":11218,"id":247905,"goal":"predicate SubsetOf_11218(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_11219","instance":11219,"id":247906,"goal":"predicate AllMem_11219(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_11220","instance":11220,"id":247907,"goal":"predicate DisjointSets_11220(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_11221","instance":11221,"id":247908,"goal":"predicate Sorted_11221(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_11222","instance":11222,"id":247909,"goal":"predicate AllPositive_11222(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_11223","instance":11223,"id":247910,"goal":"predicate DistinctSeq_11223(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_11224","instance":11224,"id":247911,"goal":"predicate IsSubseq_11224(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_11225","instance":11225,"id":247912,"goal":"predicate IsPermutation_11225(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_11226","instance":11226,"id":247913,"goal":"predicate IsEven_11226(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_11227","instance":11227,"id":247914,"goal":"predicate InRange_11227(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_11228","instance":11228,"id":247915,"goal":"predicate SubsetOf_11228(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_11229","instance":11229,"id":247916,"goal":"predicate AllMem_11229(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_11230","instance":11230,"id":247917,"goal":"predicate DisjointSets_11230(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_11231","instance":11231,"id":247918,"goal":"predicate Sorted_11231(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_11232","instance":11232,"id":247919,"goal":"predicate AllPositive_11232(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_11233","instance":11233,"id":247920,"goal":"predicate DistinctSeq_11233(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_11234","instance":11234,"id":247921,"goal":"predicate IsSubseq_11234(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_11235","instance":11235,"id":247922,"goal":"predicate IsPermutation_11235(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_11236","instance":11236,"id":247923,"goal":"predicate IsEven_11236(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_11237","instance":11237,"id":247924,"goal":"predicate InRange_11237(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_11238","instance":11238,"id":247925,"goal":"predicate SubsetOf_11238(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_11239","instance":11239,"id":247926,"goal":"predicate AllMem_11239(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_11240","instance":11240,"id":247927,"goal":"predicate DisjointSets_11240(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_11241","instance":11241,"id":247928,"goal":"predicate Sorted_11241(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_11242","instance":11242,"id":247929,"goal":"predicate AllPositive_11242(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_11243","instance":11243,"id":247930,"goal":"predicate DistinctSeq_11243(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_11244","instance":11244,"id":247931,"goal":"predicate IsSubseq_11244(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_11245","instance":11245,"id":247932,"goal":"predicate IsPermutation_11245(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_11246","instance":11246,"id":247933,"goal":"predicate IsEven_11246(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_11247","instance":11247,"id":247934,"goal":"predicate InRange_11247(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_11248","instance":11248,"id":247935,"goal":"predicate SubsetOf_11248(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_11249","instance":11249,"id":247936,"goal":"predicate AllMem_11249(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_11250","instance":11250,"id":247937,"goal":"predicate DisjointSets_11250(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_11251","instance":11251,"id":247938,"goal":"predicate Sorted_11251(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_11252","instance":11252,"id":247939,"goal":"predicate AllPositive_11252(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_11253","instance":11253,"id":247940,"goal":"predicate DistinctSeq_11253(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_11254","instance":11254,"id":247941,"goal":"predicate IsSubseq_11254(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_11255","instance":11255,"id":247942,"goal":"predicate IsPermutation_11255(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_11256","instance":11256,"id":247943,"goal":"predicate IsEven_11256(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_11257","instance":11257,"id":247944,"goal":"predicate InRange_11257(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_11258","instance":11258,"id":247945,"goal":"predicate SubsetOf_11258(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_11259","instance":11259,"id":247946,"goal":"predicate AllMem_11259(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_11260","instance":11260,"id":247947,"goal":"predicate DisjointSets_11260(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_11261","instance":11261,"id":247948,"goal":"predicate Sorted_11261(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_11262","instance":11262,"id":247949,"goal":"predicate AllPositive_11262(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_11263","instance":11263,"id":247950,"goal":"predicate DistinctSeq_11263(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_11264","instance":11264,"id":247951,"goal":"predicate IsSubseq_11264(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_11265","instance":11265,"id":247952,"goal":"predicate IsPermutation_11265(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_11266","instance":11266,"id":247953,"goal":"predicate IsEven_11266(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_11267","instance":11267,"id":247954,"goal":"predicate InRange_11267(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_11268","instance":11268,"id":247955,"goal":"predicate SubsetOf_11268(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_11269","instance":11269,"id":247956,"goal":"predicate AllMem_11269(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_11270","instance":11270,"id":247957,"goal":"predicate DisjointSets_11270(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_11271","instance":11271,"id":247958,"goal":"predicate Sorted_11271(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_11272","instance":11272,"id":247959,"goal":"predicate AllPositive_11272(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_11273","instance":11273,"id":247960,"goal":"predicate DistinctSeq_11273(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_11274","instance":11274,"id":247961,"goal":"predicate IsSubseq_11274(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_11275","instance":11275,"id":247962,"goal":"predicate IsPermutation_11275(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_11276","instance":11276,"id":247963,"goal":"predicate IsEven_11276(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_11277","instance":11277,"id":247964,"goal":"predicate InRange_11277(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_11278","instance":11278,"id":247965,"goal":"predicate SubsetOf_11278(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_11279","instance":11279,"id":247966,"goal":"predicate AllMem_11279(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_11280","instance":11280,"id":247967,"goal":"predicate DisjointSets_11280(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_11281","instance":11281,"id":247968,"goal":"predicate Sorted_11281(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_11282","instance":11282,"id":247969,"goal":"predicate AllPositive_11282(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_11283","instance":11283,"id":247970,"goal":"predicate DistinctSeq_11283(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_11284","instance":11284,"id":247971,"goal":"predicate IsSubseq_11284(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_11285","instance":11285,"id":247972,"goal":"predicate IsPermutation_11285(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_11286","instance":11286,"id":247973,"goal":"predicate IsEven_11286(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_11287","instance":11287,"id":247974,"goal":"predicate InRange_11287(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_11288","instance":11288,"id":247975,"goal":"predicate SubsetOf_11288(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_11289","instance":11289,"id":247976,"goal":"predicate AllMem_11289(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_11290","instance":11290,"id":247977,"goal":"predicate DisjointSets_11290(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_11291","instance":11291,"id":247978,"goal":"predicate Sorted_11291(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_11292","instance":11292,"id":247979,"goal":"predicate AllPositive_11292(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_11293","instance":11293,"id":247980,"goal":"predicate DistinctSeq_11293(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_11294","instance":11294,"id":247981,"goal":"predicate IsSubseq_11294(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_11295","instance":11295,"id":247982,"goal":"predicate IsPermutation_11295(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_11296","instance":11296,"id":247983,"goal":"predicate IsEven_11296(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_11297","instance":11297,"id":247984,"goal":"predicate InRange_11297(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_11298","instance":11298,"id":247985,"goal":"predicate SubsetOf_11298(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_11299","instance":11299,"id":247986,"goal":"predicate AllMem_11299(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_11300","instance":11300,"id":247987,"goal":"predicate DisjointSets_11300(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_11301","instance":11301,"id":247988,"goal":"predicate Sorted_11301(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_11302","instance":11302,"id":247989,"goal":"predicate AllPositive_11302(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_11303","instance":11303,"id":247990,"goal":"predicate DistinctSeq_11303(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_11304","instance":11304,"id":247991,"goal":"predicate IsSubseq_11304(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_11305","instance":11305,"id":247992,"goal":"predicate IsPermutation_11305(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_11306","instance":11306,"id":247993,"goal":"predicate IsEven_11306(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_11307","instance":11307,"id":247994,"goal":"predicate InRange_11307(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_11308","instance":11308,"id":247995,"goal":"predicate SubsetOf_11308(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_11309","instance":11309,"id":247996,"goal":"predicate AllMem_11309(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_11310","instance":11310,"id":247997,"goal":"predicate DisjointSets_11310(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_11311","instance":11311,"id":247998,"goal":"predicate Sorted_11311(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_11312","instance":11312,"id":247999,"goal":"predicate AllPositive_11312(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_11313","instance":11313,"id":248000,"goal":"predicate DistinctSeq_11313(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_11314","instance":11314,"id":248001,"goal":"predicate IsSubseq_11314(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_11315","instance":11315,"id":248002,"goal":"predicate IsPermutation_11315(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_11316","instance":11316,"id":248003,"goal":"predicate IsEven_11316(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_11317","instance":11317,"id":248004,"goal":"predicate InRange_11317(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_11318","instance":11318,"id":248005,"goal":"predicate SubsetOf_11318(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_11319","instance":11319,"id":248006,"goal":"predicate AllMem_11319(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_11320","instance":11320,"id":248007,"goal":"predicate DisjointSets_11320(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_11321","instance":11321,"id":248008,"goal":"predicate Sorted_11321(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_11322","instance":11322,"id":248009,"goal":"predicate AllPositive_11322(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_11323","instance":11323,"id":248010,"goal":"predicate DistinctSeq_11323(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_11324","instance":11324,"id":248011,"goal":"predicate IsSubseq_11324(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_11325","instance":11325,"id":248012,"goal":"predicate IsPermutation_11325(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_11326","instance":11326,"id":248013,"goal":"predicate IsEven_11326(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_11327","instance":11327,"id":248014,"goal":"predicate InRange_11327(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_11328","instance":11328,"id":248015,"goal":"predicate SubsetOf_11328(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_11329","instance":11329,"id":248016,"goal":"predicate AllMem_11329(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_11330","instance":11330,"id":248017,"goal":"predicate DisjointSets_11330(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_11331","instance":11331,"id":248018,"goal":"predicate Sorted_11331(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_11332","instance":11332,"id":248019,"goal":"predicate AllPositive_11332(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_11333","instance":11333,"id":248020,"goal":"predicate DistinctSeq_11333(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_11334","instance":11334,"id":248021,"goal":"predicate IsSubseq_11334(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_11335","instance":11335,"id":248022,"goal":"predicate IsPermutation_11335(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_11336","instance":11336,"id":248023,"goal":"predicate IsEven_11336(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_11337","instance":11337,"id":248024,"goal":"predicate InRange_11337(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_11338","instance":11338,"id":248025,"goal":"predicate SubsetOf_11338(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_11339","instance":11339,"id":248026,"goal":"predicate AllMem_11339(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_11340","instance":11340,"id":248027,"goal":"predicate DisjointSets_11340(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_11341","instance":11341,"id":248028,"goal":"predicate Sorted_11341(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_11342","instance":11342,"id":248029,"goal":"predicate AllPositive_11342(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_11343","instance":11343,"id":248030,"goal":"predicate DistinctSeq_11343(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_11344","instance":11344,"id":248031,"goal":"predicate IsSubseq_11344(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_11345","instance":11345,"id":248032,"goal":"predicate IsPermutation_11345(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_11346","instance":11346,"id":248033,"goal":"predicate IsEven_11346(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_11347","instance":11347,"id":248034,"goal":"predicate InRange_11347(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_11348","instance":11348,"id":248035,"goal":"predicate SubsetOf_11348(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_11349","instance":11349,"id":248036,"goal":"predicate AllMem_11349(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_11350","instance":11350,"id":248037,"goal":"predicate DisjointSets_11350(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_11351","instance":11351,"id":248038,"goal":"predicate Sorted_11351(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_11352","instance":11352,"id":248039,"goal":"predicate AllPositive_11352(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_11353","instance":11353,"id":248040,"goal":"predicate DistinctSeq_11353(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_11354","instance":11354,"id":248041,"goal":"predicate IsSubseq_11354(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_11355","instance":11355,"id":248042,"goal":"predicate IsPermutation_11355(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_11356","instance":11356,"id":248043,"goal":"predicate IsEven_11356(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_11357","instance":11357,"id":248044,"goal":"predicate InRange_11357(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_11358","instance":11358,"id":248045,"goal":"predicate SubsetOf_11358(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_11359","instance":11359,"id":248046,"goal":"predicate AllMem_11359(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_11360","instance":11360,"id":248047,"goal":"predicate DisjointSets_11360(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_11361","instance":11361,"id":248048,"goal":"predicate Sorted_11361(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_11362","instance":11362,"id":248049,"goal":"predicate AllPositive_11362(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_11363","instance":11363,"id":248050,"goal":"predicate DistinctSeq_11363(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_11364","instance":11364,"id":248051,"goal":"predicate IsSubseq_11364(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_11365","instance":11365,"id":248052,"goal":"predicate IsPermutation_11365(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_11366","instance":11366,"id":248053,"goal":"predicate IsEven_11366(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_11367","instance":11367,"id":248054,"goal":"predicate InRange_11367(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_11368","instance":11368,"id":248055,"goal":"predicate SubsetOf_11368(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_11369","instance":11369,"id":248056,"goal":"predicate AllMem_11369(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_11370","instance":11370,"id":248057,"goal":"predicate DisjointSets_11370(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_11371","instance":11371,"id":248058,"goal":"predicate Sorted_11371(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_11372","instance":11372,"id":248059,"goal":"predicate AllPositive_11372(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_11373","instance":11373,"id":248060,"goal":"predicate DistinctSeq_11373(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_11374","instance":11374,"id":248061,"goal":"predicate IsSubseq_11374(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_11375","instance":11375,"id":248062,"goal":"predicate IsPermutation_11375(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_11376","instance":11376,"id":248063,"goal":"predicate IsEven_11376(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_11377","instance":11377,"id":248064,"goal":"predicate InRange_11377(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_11378","instance":11378,"id":248065,"goal":"predicate SubsetOf_11378(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_11379","instance":11379,"id":248066,"goal":"predicate AllMem_11379(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_11380","instance":11380,"id":248067,"goal":"predicate DisjointSets_11380(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_11381","instance":11381,"id":248068,"goal":"predicate Sorted_11381(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_11382","instance":11382,"id":248069,"goal":"predicate AllPositive_11382(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_11383","instance":11383,"id":248070,"goal":"predicate DistinctSeq_11383(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_11384","instance":11384,"id":248071,"goal":"predicate IsSubseq_11384(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_11385","instance":11385,"id":248072,"goal":"predicate IsPermutation_11385(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_11386","instance":11386,"id":248073,"goal":"predicate IsEven_11386(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_11387","instance":11387,"id":248074,"goal":"predicate InRange_11387(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_11388","instance":11388,"id":248075,"goal":"predicate SubsetOf_11388(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_11389","instance":11389,"id":248076,"goal":"predicate AllMem_11389(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_11390","instance":11390,"id":248077,"goal":"predicate DisjointSets_11390(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_11391","instance":11391,"id":248078,"goal":"predicate Sorted_11391(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_11392","instance":11392,"id":248079,"goal":"predicate AllPositive_11392(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_11393","instance":11393,"id":248080,"goal":"predicate DistinctSeq_11393(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_11394","instance":11394,"id":248081,"goal":"predicate IsSubseq_11394(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_11395","instance":11395,"id":248082,"goal":"predicate IsPermutation_11395(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_11396","instance":11396,"id":248083,"goal":"predicate IsEven_11396(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_11397","instance":11397,"id":248084,"goal":"predicate InRange_11397(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_11398","instance":11398,"id":248085,"goal":"predicate SubsetOf_11398(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_11399","instance":11399,"id":248086,"goal":"predicate AllMem_11399(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_11400","instance":11400,"id":248087,"goal":"predicate DisjointSets_11400(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_11401","instance":11401,"id":248088,"goal":"predicate Sorted_11401(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_11402","instance":11402,"id":248089,"goal":"predicate AllPositive_11402(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_11403","instance":11403,"id":248090,"goal":"predicate DistinctSeq_11403(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_11404","instance":11404,"id":248091,"goal":"predicate IsSubseq_11404(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_11405","instance":11405,"id":248092,"goal":"predicate IsPermutation_11405(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_11406","instance":11406,"id":248093,"goal":"predicate IsEven_11406(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_11407","instance":11407,"id":248094,"goal":"predicate InRange_11407(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_11408","instance":11408,"id":248095,"goal":"predicate SubsetOf_11408(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_11409","instance":11409,"id":248096,"goal":"predicate AllMem_11409(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_11410","instance":11410,"id":248097,"goal":"predicate DisjointSets_11410(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_11411","instance":11411,"id":248098,"goal":"predicate Sorted_11411(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_11412","instance":11412,"id":248099,"goal":"predicate AllPositive_11412(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_11413","instance":11413,"id":248100,"goal":"predicate DistinctSeq_11413(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_11414","instance":11414,"id":248101,"goal":"predicate IsSubseq_11414(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_11415","instance":11415,"id":248102,"goal":"predicate IsPermutation_11415(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_11416","instance":11416,"id":248103,"goal":"predicate IsEven_11416(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_11417","instance":11417,"id":248104,"goal":"predicate InRange_11417(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_11418","instance":11418,"id":248105,"goal":"predicate SubsetOf_11418(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_11419","instance":11419,"id":248106,"goal":"predicate AllMem_11419(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_11420","instance":11420,"id":248107,"goal":"predicate DisjointSets_11420(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_11421","instance":11421,"id":248108,"goal":"predicate Sorted_11421(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_11422","instance":11422,"id":248109,"goal":"predicate AllPositive_11422(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_11423","instance":11423,"id":248110,"goal":"predicate DistinctSeq_11423(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_11424","instance":11424,"id":248111,"goal":"predicate IsSubseq_11424(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_11425","instance":11425,"id":248112,"goal":"predicate IsPermutation_11425(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_11426","instance":11426,"id":248113,"goal":"predicate IsEven_11426(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_11427","instance":11427,"id":248114,"goal":"predicate InRange_11427(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_11428","instance":11428,"id":248115,"goal":"predicate SubsetOf_11428(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_11429","instance":11429,"id":248116,"goal":"predicate AllMem_11429(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_11430","instance":11430,"id":248117,"goal":"predicate DisjointSets_11430(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_11431","instance":11431,"id":248118,"goal":"predicate Sorted_11431(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_11432","instance":11432,"id":248119,"goal":"predicate AllPositive_11432(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_11433","instance":11433,"id":248120,"goal":"predicate DistinctSeq_11433(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_11434","instance":11434,"id":248121,"goal":"predicate IsSubseq_11434(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_11435","instance":11435,"id":248122,"goal":"predicate IsPermutation_11435(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_11436","instance":11436,"id":248123,"goal":"predicate IsEven_11436(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_11437","instance":11437,"id":248124,"goal":"predicate InRange_11437(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_11438","instance":11438,"id":248125,"goal":"predicate SubsetOf_11438(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_11439","instance":11439,"id":248126,"goal":"predicate AllMem_11439(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_11440","instance":11440,"id":248127,"goal":"predicate DisjointSets_11440(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_11441","instance":11441,"id":248128,"goal":"predicate Sorted_11441(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_11442","instance":11442,"id":248129,"goal":"predicate AllPositive_11442(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_11443","instance":11443,"id":248130,"goal":"predicate DistinctSeq_11443(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_11444","instance":11444,"id":248131,"goal":"predicate IsSubseq_11444(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_11445","instance":11445,"id":248132,"goal":"predicate IsPermutation_11445(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_11446","instance":11446,"id":248133,"goal":"predicate IsEven_11446(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_11447","instance":11447,"id":248134,"goal":"predicate InRange_11447(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_11448","instance":11448,"id":248135,"goal":"predicate SubsetOf_11448(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_11449","instance":11449,"id":248136,"goal":"predicate AllMem_11449(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_11450","instance":11450,"id":248137,"goal":"predicate DisjointSets_11450(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_11451","instance":11451,"id":248138,"goal":"predicate Sorted_11451(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_11452","instance":11452,"id":248139,"goal":"predicate AllPositive_11452(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_11453","instance":11453,"id":248140,"goal":"predicate DistinctSeq_11453(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_11454","instance":11454,"id":248141,"goal":"predicate IsSubseq_11454(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_11455","instance":11455,"id":248142,"goal":"predicate IsPermutation_11455(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_11456","instance":11456,"id":248143,"goal":"predicate IsEven_11456(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_11457","instance":11457,"id":248144,"goal":"predicate InRange_11457(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_11458","instance":11458,"id":248145,"goal":"predicate SubsetOf_11458(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_11459","instance":11459,"id":248146,"goal":"predicate AllMem_11459(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_11460","instance":11460,"id":248147,"goal":"predicate DisjointSets_11460(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_11461","instance":11461,"id":248148,"goal":"predicate Sorted_11461(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_11462","instance":11462,"id":248149,"goal":"predicate AllPositive_11462(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_11463","instance":11463,"id":248150,"goal":"predicate DistinctSeq_11463(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_11464","instance":11464,"id":248151,"goal":"predicate IsSubseq_11464(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_11465","instance":11465,"id":248152,"goal":"predicate IsPermutation_11465(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_11466","instance":11466,"id":248153,"goal":"predicate IsEven_11466(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_11467","instance":11467,"id":248154,"goal":"predicate InRange_11467(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_11468","instance":11468,"id":248155,"goal":"predicate SubsetOf_11468(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_11469","instance":11469,"id":248156,"goal":"predicate AllMem_11469(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_11470","instance":11470,"id":248157,"goal":"predicate DisjointSets_11470(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_11471","instance":11471,"id":248158,"goal":"predicate Sorted_11471(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_11472","instance":11472,"id":248159,"goal":"predicate AllPositive_11472(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_11473","instance":11473,"id":248160,"goal":"predicate DistinctSeq_11473(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_11474","instance":11474,"id":248161,"goal":"predicate IsSubseq_11474(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_11475","instance":11475,"id":248162,"goal":"predicate IsPermutation_11475(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_11476","instance":11476,"id":248163,"goal":"predicate IsEven_11476(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_11477","instance":11477,"id":248164,"goal":"predicate InRange_11477(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_11478","instance":11478,"id":248165,"goal":"predicate SubsetOf_11478(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_11479","instance":11479,"id":248166,"goal":"predicate AllMem_11479(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_11480","instance":11480,"id":248167,"goal":"predicate DisjointSets_11480(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_11481","instance":11481,"id":248168,"goal":"predicate Sorted_11481(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_11482","instance":11482,"id":248169,"goal":"predicate AllPositive_11482(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_11483","instance":11483,"id":248170,"goal":"predicate DistinctSeq_11483(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_11484","instance":11484,"id":248171,"goal":"predicate IsSubseq_11484(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_11485","instance":11485,"id":248172,"goal":"predicate IsPermutation_11485(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_11486","instance":11486,"id":248173,"goal":"predicate IsEven_11486(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_11487","instance":11487,"id":248174,"goal":"predicate InRange_11487(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_11488","instance":11488,"id":248175,"goal":"predicate SubsetOf_11488(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_11489","instance":11489,"id":248176,"goal":"predicate AllMem_11489(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_11490","instance":11490,"id":248177,"goal":"predicate DisjointSets_11490(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_11491","instance":11491,"id":248178,"goal":"predicate Sorted_11491(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_11492","instance":11492,"id":248179,"goal":"predicate AllPositive_11492(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_11493","instance":11493,"id":248180,"goal":"predicate DistinctSeq_11493(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_11494","instance":11494,"id":248181,"goal":"predicate IsSubseq_11494(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_11495","instance":11495,"id":248182,"goal":"predicate IsPermutation_11495(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_11496","instance":11496,"id":248183,"goal":"predicate IsEven_11496(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_11497","instance":11497,"id":248184,"goal":"predicate InRange_11497(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_11498","instance":11498,"id":248185,"goal":"predicate SubsetOf_11498(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_11499","instance":11499,"id":248186,"goal":"predicate AllMem_11499(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_11500","instance":11500,"id":248187,"goal":"predicate DisjointSets_11500(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_11501","instance":11501,"id":248188,"goal":"predicate Sorted_11501(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_11502","instance":11502,"id":248189,"goal":"predicate AllPositive_11502(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_11503","instance":11503,"id":248190,"goal":"predicate DistinctSeq_11503(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_11504","instance":11504,"id":248191,"goal":"predicate IsSubseq_11504(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_11505","instance":11505,"id":248192,"goal":"predicate IsPermutation_11505(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_11506","instance":11506,"id":248193,"goal":"predicate IsEven_11506(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_11507","instance":11507,"id":248194,"goal":"predicate InRange_11507(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_11508","instance":11508,"id":248195,"goal":"predicate SubsetOf_11508(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_11509","instance":11509,"id":248196,"goal":"predicate AllMem_11509(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_11510","instance":11510,"id":248197,"goal":"predicate DisjointSets_11510(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_11511","instance":11511,"id":248198,"goal":"predicate Sorted_11511(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_11512","instance":11512,"id":248199,"goal":"predicate AllPositive_11512(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_11513","instance":11513,"id":248200,"goal":"predicate DistinctSeq_11513(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_11514","instance":11514,"id":248201,"goal":"predicate IsSubseq_11514(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_11515","instance":11515,"id":248202,"goal":"predicate IsPermutation_11515(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_11516","instance":11516,"id":248203,"goal":"predicate IsEven_11516(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_11517","instance":11517,"id":248204,"goal":"predicate InRange_11517(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_11518","instance":11518,"id":248205,"goal":"predicate SubsetOf_11518(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_11519","instance":11519,"id":248206,"goal":"predicate AllMem_11519(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_11520","instance":11520,"id":248207,"goal":"predicate DisjointSets_11520(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_11521","instance":11521,"id":248208,"goal":"predicate Sorted_11521(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_11522","instance":11522,"id":248209,"goal":"predicate AllPositive_11522(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_11523","instance":11523,"id":248210,"goal":"predicate DistinctSeq_11523(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_11524","instance":11524,"id":248211,"goal":"predicate IsSubseq_11524(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_11525","instance":11525,"id":248212,"goal":"predicate IsPermutation_11525(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_11526","instance":11526,"id":248213,"goal":"predicate IsEven_11526(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_11527","instance":11527,"id":248214,"goal":"predicate InRange_11527(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_11528","instance":11528,"id":248215,"goal":"predicate SubsetOf_11528(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_11529","instance":11529,"id":248216,"goal":"predicate AllMem_11529(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_11530","instance":11530,"id":248217,"goal":"predicate DisjointSets_11530(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_11531","instance":11531,"id":248218,"goal":"predicate Sorted_11531(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_11532","instance":11532,"id":248219,"goal":"predicate AllPositive_11532(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_11533","instance":11533,"id":248220,"goal":"predicate DistinctSeq_11533(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_11534","instance":11534,"id":248221,"goal":"predicate IsSubseq_11534(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_11535","instance":11535,"id":248222,"goal":"predicate IsPermutation_11535(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_11536","instance":11536,"id":248223,"goal":"predicate IsEven_11536(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_11537","instance":11537,"id":248224,"goal":"predicate InRange_11537(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_11538","instance":11538,"id":248225,"goal":"predicate SubsetOf_11538(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_11539","instance":11539,"id":248226,"goal":"predicate AllMem_11539(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_11540","instance":11540,"id":248227,"goal":"predicate DisjointSets_11540(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_11541","instance":11541,"id":248228,"goal":"predicate Sorted_11541(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_11542","instance":11542,"id":248229,"goal":"predicate AllPositive_11542(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_11543","instance":11543,"id":248230,"goal":"predicate DistinctSeq_11543(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_11544","instance":11544,"id":248231,"goal":"predicate IsSubseq_11544(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_11545","instance":11545,"id":248232,"goal":"predicate IsPermutation_11545(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_11546","instance":11546,"id":248233,"goal":"predicate IsEven_11546(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_11547","instance":11547,"id":248234,"goal":"predicate InRange_11547(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_11548","instance":11548,"id":248235,"goal":"predicate SubsetOf_11548(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_11549","instance":11549,"id":248236,"goal":"predicate AllMem_11549(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_11550","instance":11550,"id":248237,"goal":"predicate DisjointSets_11550(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_11551","instance":11551,"id":248238,"goal":"predicate Sorted_11551(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_11552","instance":11552,"id":248239,"goal":"predicate AllPositive_11552(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_11553","instance":11553,"id":248240,"goal":"predicate DistinctSeq_11553(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_11554","instance":11554,"id":248241,"goal":"predicate IsSubseq_11554(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_11555","instance":11555,"id":248242,"goal":"predicate IsPermutation_11555(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_11556","instance":11556,"id":248243,"goal":"predicate IsEven_11556(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_11557","instance":11557,"id":248244,"goal":"predicate InRange_11557(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_11558","instance":11558,"id":248245,"goal":"predicate SubsetOf_11558(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_11559","instance":11559,"id":248246,"goal":"predicate AllMem_11559(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_11560","instance":11560,"id":248247,"goal":"predicate DisjointSets_11560(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_11561","instance":11561,"id":248248,"goal":"predicate Sorted_11561(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_11562","instance":11562,"id":248249,"goal":"predicate AllPositive_11562(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_11563","instance":11563,"id":248250,"goal":"predicate DistinctSeq_11563(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_11564","instance":11564,"id":248251,"goal":"predicate IsSubseq_11564(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_11565","instance":11565,"id":248252,"goal":"predicate IsPermutation_11565(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_11566","instance":11566,"id":248253,"goal":"predicate IsEven_11566(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_11567","instance":11567,"id":248254,"goal":"predicate InRange_11567(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_11568","instance":11568,"id":248255,"goal":"predicate SubsetOf_11568(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_11569","instance":11569,"id":248256,"goal":"predicate AllMem_11569(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_11570","instance":11570,"id":248257,"goal":"predicate DisjointSets_11570(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_11571","instance":11571,"id":248258,"goal":"predicate Sorted_11571(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_11572","instance":11572,"id":248259,"goal":"predicate AllPositive_11572(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_11573","instance":11573,"id":248260,"goal":"predicate DistinctSeq_11573(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_11574","instance":11574,"id":248261,"goal":"predicate IsSubseq_11574(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_11575","instance":11575,"id":248262,"goal":"predicate IsPermutation_11575(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_11576","instance":11576,"id":248263,"goal":"predicate IsEven_11576(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_11577","instance":11577,"id":248264,"goal":"predicate InRange_11577(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_11578","instance":11578,"id":248265,"goal":"predicate SubsetOf_11578(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_11579","instance":11579,"id":248266,"goal":"predicate AllMem_11579(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_11580","instance":11580,"id":248267,"goal":"predicate DisjointSets_11580(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_11581","instance":11581,"id":248268,"goal":"predicate Sorted_11581(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_11582","instance":11582,"id":248269,"goal":"predicate AllPositive_11582(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_11583","instance":11583,"id":248270,"goal":"predicate DistinctSeq_11583(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_11584","instance":11584,"id":248271,"goal":"predicate IsSubseq_11584(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_11585","instance":11585,"id":248272,"goal":"predicate IsPermutation_11585(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_11586","instance":11586,"id":248273,"goal":"predicate IsEven_11586(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_11587","instance":11587,"id":248274,"goal":"predicate InRange_11587(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_11588","instance":11588,"id":248275,"goal":"predicate SubsetOf_11588(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_11589","instance":11589,"id":248276,"goal":"predicate AllMem_11589(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_11590","instance":11590,"id":248277,"goal":"predicate DisjointSets_11590(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_11591","instance":11591,"id":248278,"goal":"predicate Sorted_11591(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_11592","instance":11592,"id":248279,"goal":"predicate AllPositive_11592(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_11593","instance":11593,"id":248280,"goal":"predicate DistinctSeq_11593(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_11594","instance":11594,"id":248281,"goal":"predicate IsSubseq_11594(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_11595","instance":11595,"id":248282,"goal":"predicate IsPermutation_11595(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_11596","instance":11596,"id":248283,"goal":"predicate IsEven_11596(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_11597","instance":11597,"id":248284,"goal":"predicate InRange_11597(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_11598","instance":11598,"id":248285,"goal":"predicate SubsetOf_11598(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_11599","instance":11599,"id":248286,"goal":"predicate AllMem_11599(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_11600","instance":11600,"id":248287,"goal":"predicate DisjointSets_11600(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_11601","instance":11601,"id":248288,"goal":"predicate Sorted_11601(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_11602","instance":11602,"id":248289,"goal":"predicate AllPositive_11602(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_11603","instance":11603,"id":248290,"goal":"predicate DistinctSeq_11603(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_11604","instance":11604,"id":248291,"goal":"predicate IsSubseq_11604(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_11605","instance":11605,"id":248292,"goal":"predicate IsPermutation_11605(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_11606","instance":11606,"id":248293,"goal":"predicate IsEven_11606(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_11607","instance":11607,"id":248294,"goal":"predicate InRange_11607(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_11608","instance":11608,"id":248295,"goal":"predicate SubsetOf_11608(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_11609","instance":11609,"id":248296,"goal":"predicate AllMem_11609(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_11610","instance":11610,"id":248297,"goal":"predicate DisjointSets_11610(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_11611","instance":11611,"id":248298,"goal":"predicate Sorted_11611(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_11612","instance":11612,"id":248299,"goal":"predicate AllPositive_11612(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_11613","instance":11613,"id":248300,"goal":"predicate DistinctSeq_11613(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_11614","instance":11614,"id":248301,"goal":"predicate IsSubseq_11614(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_11615","instance":11615,"id":248302,"goal":"predicate IsPermutation_11615(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_11616","instance":11616,"id":248303,"goal":"predicate IsEven_11616(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_11617","instance":11617,"id":248304,"goal":"predicate InRange_11617(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_11618","instance":11618,"id":248305,"goal":"predicate SubsetOf_11618(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_11619","instance":11619,"id":248306,"goal":"predicate AllMem_11619(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_11620","instance":11620,"id":248307,"goal":"predicate DisjointSets_11620(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_11621","instance":11621,"id":248308,"goal":"predicate Sorted_11621(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_11622","instance":11622,"id":248309,"goal":"predicate AllPositive_11622(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_11623","instance":11623,"id":248310,"goal":"predicate DistinctSeq_11623(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_11624","instance":11624,"id":248311,"goal":"predicate IsSubseq_11624(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_11625","instance":11625,"id":248312,"goal":"predicate IsPermutation_11625(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_11626","instance":11626,"id":248313,"goal":"predicate IsEven_11626(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_11627","instance":11627,"id":248314,"goal":"predicate InRange_11627(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_11628","instance":11628,"id":248315,"goal":"predicate SubsetOf_11628(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_11629","instance":11629,"id":248316,"goal":"predicate AllMem_11629(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_11630","instance":11630,"id":248317,"goal":"predicate DisjointSets_11630(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_11631","instance":11631,"id":248318,"goal":"predicate Sorted_11631(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_11632","instance":11632,"id":248319,"goal":"predicate AllPositive_11632(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_11633","instance":11633,"id":248320,"goal":"predicate DistinctSeq_11633(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_11634","instance":11634,"id":248321,"goal":"predicate IsSubseq_11634(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_11635","instance":11635,"id":248322,"goal":"predicate IsPermutation_11635(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_11636","instance":11636,"id":248323,"goal":"predicate IsEven_11636(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_11637","instance":11637,"id":248324,"goal":"predicate InRange_11637(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_11638","instance":11638,"id":248325,"goal":"predicate SubsetOf_11638(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_11639","instance":11639,"id":248326,"goal":"predicate AllMem_11639(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_11640","instance":11640,"id":248327,"goal":"predicate DisjointSets_11640(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_11641","instance":11641,"id":248328,"goal":"predicate Sorted_11641(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_11642","instance":11642,"id":248329,"goal":"predicate AllPositive_11642(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_11643","instance":11643,"id":248330,"goal":"predicate DistinctSeq_11643(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_11644","instance":11644,"id":248331,"goal":"predicate IsSubseq_11644(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_11645","instance":11645,"id":248332,"goal":"predicate IsPermutation_11645(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_11646","instance":11646,"id":248333,"goal":"predicate IsEven_11646(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_11647","instance":11647,"id":248334,"goal":"predicate InRange_11647(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_11648","instance":11648,"id":248335,"goal":"predicate SubsetOf_11648(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_11649","instance":11649,"id":248336,"goal":"predicate AllMem_11649(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_11650","instance":11650,"id":248337,"goal":"predicate DisjointSets_11650(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_11651","instance":11651,"id":248338,"goal":"predicate Sorted_11651(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_11652","instance":11652,"id":248339,"goal":"predicate AllPositive_11652(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_11653","instance":11653,"id":248340,"goal":"predicate DistinctSeq_11653(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_11654","instance":11654,"id":248341,"goal":"predicate IsSubseq_11654(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_11655","instance":11655,"id":248342,"goal":"predicate IsPermutation_11655(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_11656","instance":11656,"id":248343,"goal":"predicate IsEven_11656(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_11657","instance":11657,"id":248344,"goal":"predicate InRange_11657(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_11658","instance":11658,"id":248345,"goal":"predicate SubsetOf_11658(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_11659","instance":11659,"id":248346,"goal":"predicate AllMem_11659(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_11660","instance":11660,"id":248347,"goal":"predicate DisjointSets_11660(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_11661","instance":11661,"id":248348,"goal":"predicate Sorted_11661(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_11662","instance":11662,"id":248349,"goal":"predicate AllPositive_11662(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_11663","instance":11663,"id":248350,"goal":"predicate DistinctSeq_11663(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_11664","instance":11664,"id":248351,"goal":"predicate IsSubseq_11664(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_11665","instance":11665,"id":248352,"goal":"predicate IsPermutation_11665(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_11666","instance":11666,"id":248353,"goal":"predicate IsEven_11666(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_11667","instance":11667,"id":248354,"goal":"predicate InRange_11667(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_11668","instance":11668,"id":248355,"goal":"predicate SubsetOf_11668(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_11669","instance":11669,"id":248356,"goal":"predicate AllMem_11669(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_11670","instance":11670,"id":248357,"goal":"predicate DisjointSets_11670(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_11671","instance":11671,"id":248358,"goal":"predicate Sorted_11671(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_11672","instance":11672,"id":248359,"goal":"predicate AllPositive_11672(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_11673","instance":11673,"id":248360,"goal":"predicate DistinctSeq_11673(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_11674","instance":11674,"id":248361,"goal":"predicate IsSubseq_11674(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_11675","instance":11675,"id":248362,"goal":"predicate IsPermutation_11675(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_11676","instance":11676,"id":248363,"goal":"predicate IsEven_11676(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_11677","instance":11677,"id":248364,"goal":"predicate InRange_11677(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_11678","instance":11678,"id":248365,"goal":"predicate SubsetOf_11678(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_11679","instance":11679,"id":248366,"goal":"predicate AllMem_11679(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_11680","instance":11680,"id":248367,"goal":"predicate DisjointSets_11680(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_11681","instance":11681,"id":248368,"goal":"predicate Sorted_11681(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_11682","instance":11682,"id":248369,"goal":"predicate AllPositive_11682(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_11683","instance":11683,"id":248370,"goal":"predicate DistinctSeq_11683(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_11684","instance":11684,"id":248371,"goal":"predicate IsSubseq_11684(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_11685","instance":11685,"id":248372,"goal":"predicate IsPermutation_11685(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_11686","instance":11686,"id":248373,"goal":"predicate IsEven_11686(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_11687","instance":11687,"id":248374,"goal":"predicate InRange_11687(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_11688","instance":11688,"id":248375,"goal":"predicate SubsetOf_11688(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_11689","instance":11689,"id":248376,"goal":"predicate AllMem_11689(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_11690","instance":11690,"id":248377,"goal":"predicate DisjointSets_11690(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_11691","instance":11691,"id":248378,"goal":"predicate Sorted_11691(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_11692","instance":11692,"id":248379,"goal":"predicate AllPositive_11692(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_11693","instance":11693,"id":248380,"goal":"predicate DistinctSeq_11693(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_11694","instance":11694,"id":248381,"goal":"predicate IsSubseq_11694(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_11695","instance":11695,"id":248382,"goal":"predicate IsPermutation_11695(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_11696","instance":11696,"id":248383,"goal":"predicate IsEven_11696(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_11697","instance":11697,"id":248384,"goal":"predicate InRange_11697(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_11698","instance":11698,"id":248385,"goal":"predicate SubsetOf_11698(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_11699","instance":11699,"id":248386,"goal":"predicate AllMem_11699(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_11700","instance":11700,"id":248387,"goal":"predicate DisjointSets_11700(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_11701","instance":11701,"id":248388,"goal":"predicate Sorted_11701(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_11702","instance":11702,"id":248389,"goal":"predicate AllPositive_11702(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_11703","instance":11703,"id":248390,"goal":"predicate DistinctSeq_11703(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_11704","instance":11704,"id":248391,"goal":"predicate IsSubseq_11704(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_11705","instance":11705,"id":248392,"goal":"predicate IsPermutation_11705(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_11706","instance":11706,"id":248393,"goal":"predicate IsEven_11706(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_11707","instance":11707,"id":248394,"goal":"predicate InRange_11707(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_11708","instance":11708,"id":248395,"goal":"predicate SubsetOf_11708(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_11709","instance":11709,"id":248396,"goal":"predicate AllMem_11709(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_11710","instance":11710,"id":248397,"goal":"predicate DisjointSets_11710(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_11711","instance":11711,"id":248398,"goal":"predicate Sorted_11711(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_11712","instance":11712,"id":248399,"goal":"predicate AllPositive_11712(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_11713","instance":11713,"id":248400,"goal":"predicate DistinctSeq_11713(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_11714","instance":11714,"id":248401,"goal":"predicate IsSubseq_11714(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_11715","instance":11715,"id":248402,"goal":"predicate IsPermutation_11715(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_11716","instance":11716,"id":248403,"goal":"predicate IsEven_11716(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_11717","instance":11717,"id":248404,"goal":"predicate InRange_11717(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_11718","instance":11718,"id":248405,"goal":"predicate SubsetOf_11718(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_11719","instance":11719,"id":248406,"goal":"predicate AllMem_11719(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_11720","instance":11720,"id":248407,"goal":"predicate DisjointSets_11720(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_11721","instance":11721,"id":248408,"goal":"predicate Sorted_11721(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_11722","instance":11722,"id":248409,"goal":"predicate AllPositive_11722(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_11723","instance":11723,"id":248410,"goal":"predicate DistinctSeq_11723(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_11724","instance":11724,"id":248411,"goal":"predicate IsSubseq_11724(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_11725","instance":11725,"id":248412,"goal":"predicate IsPermutation_11725(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_11726","instance":11726,"id":248413,"goal":"predicate IsEven_11726(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_11727","instance":11727,"id":248414,"goal":"predicate InRange_11727(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_11728","instance":11728,"id":248415,"goal":"predicate SubsetOf_11728(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_11729","instance":11729,"id":248416,"goal":"predicate AllMem_11729(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_11730","instance":11730,"id":248417,"goal":"predicate DisjointSets_11730(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_11731","instance":11731,"id":248418,"goal":"predicate Sorted_11731(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_11732","instance":11732,"id":248419,"goal":"predicate AllPositive_11732(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_11733","instance":11733,"id":248420,"goal":"predicate DistinctSeq_11733(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_11734","instance":11734,"id":248421,"goal":"predicate IsSubseq_11734(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_11735","instance":11735,"id":248422,"goal":"predicate IsPermutation_11735(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_11736","instance":11736,"id":248423,"goal":"predicate IsEven_11736(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_11737","instance":11737,"id":248424,"goal":"predicate InRange_11737(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_11738","instance":11738,"id":248425,"goal":"predicate SubsetOf_11738(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_11739","instance":11739,"id":248426,"goal":"predicate AllMem_11739(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_11740","instance":11740,"id":248427,"goal":"predicate DisjointSets_11740(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_11741","instance":11741,"id":248428,"goal":"predicate Sorted_11741(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_11742","instance":11742,"id":248429,"goal":"predicate AllPositive_11742(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_11743","instance":11743,"id":248430,"goal":"predicate DistinctSeq_11743(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_11744","instance":11744,"id":248431,"goal":"predicate IsSubseq_11744(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_11745","instance":11745,"id":248432,"goal":"predicate IsPermutation_11745(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_11746","instance":11746,"id":248433,"goal":"predicate IsEven_11746(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_11747","instance":11747,"id":248434,"goal":"predicate InRange_11747(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_11748","instance":11748,"id":248435,"goal":"predicate SubsetOf_11748(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_11749","instance":11749,"id":248436,"goal":"predicate AllMem_11749(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_11750","instance":11750,"id":248437,"goal":"predicate DisjointSets_11750(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_11751","instance":11751,"id":248438,"goal":"predicate Sorted_11751(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_11752","instance":11752,"id":248439,"goal":"predicate AllPositive_11752(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_11753","instance":11753,"id":248440,"goal":"predicate DistinctSeq_11753(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_11754","instance":11754,"id":248441,"goal":"predicate IsSubseq_11754(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_11755","instance":11755,"id":248442,"goal":"predicate IsPermutation_11755(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_11756","instance":11756,"id":248443,"goal":"predicate IsEven_11756(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_11757","instance":11757,"id":248444,"goal":"predicate InRange_11757(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_11758","instance":11758,"id":248445,"goal":"predicate SubsetOf_11758(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_11759","instance":11759,"id":248446,"goal":"predicate AllMem_11759(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_11760","instance":11760,"id":248447,"goal":"predicate DisjointSets_11760(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_11761","instance":11761,"id":248448,"goal":"predicate Sorted_11761(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_11762","instance":11762,"id":248449,"goal":"predicate AllPositive_11762(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_11763","instance":11763,"id":248450,"goal":"predicate DistinctSeq_11763(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_11764","instance":11764,"id":248451,"goal":"predicate IsSubseq_11764(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_11765","instance":11765,"id":248452,"goal":"predicate IsPermutation_11765(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_11766","instance":11766,"id":248453,"goal":"predicate IsEven_11766(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_11767","instance":11767,"id":248454,"goal":"predicate InRange_11767(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_11768","instance":11768,"id":248455,"goal":"predicate SubsetOf_11768(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_11769","instance":11769,"id":248456,"goal":"predicate AllMem_11769(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_11770","instance":11770,"id":248457,"goal":"predicate DisjointSets_11770(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_11771","instance":11771,"id":248458,"goal":"predicate Sorted_11771(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_11772","instance":11772,"id":248459,"goal":"predicate AllPositive_11772(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_11773","instance":11773,"id":248460,"goal":"predicate DistinctSeq_11773(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_11774","instance":11774,"id":248461,"goal":"predicate IsSubseq_11774(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_11775","instance":11775,"id":248462,"goal":"predicate IsPermutation_11775(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_11776","instance":11776,"id":248463,"goal":"predicate IsEven_11776(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_11777","instance":11777,"id":248464,"goal":"predicate InRange_11777(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_11778","instance":11778,"id":248465,"goal":"predicate SubsetOf_11778(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_11779","instance":11779,"id":248466,"goal":"predicate AllMem_11779(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_11780","instance":11780,"id":248467,"goal":"predicate DisjointSets_11780(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_11781","instance":11781,"id":248468,"goal":"predicate Sorted_11781(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_11782","instance":11782,"id":248469,"goal":"predicate AllPositive_11782(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_11783","instance":11783,"id":248470,"goal":"predicate DistinctSeq_11783(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_11784","instance":11784,"id":248471,"goal":"predicate IsSubseq_11784(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_11785","instance":11785,"id":248472,"goal":"predicate IsPermutation_11785(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_11786","instance":11786,"id":248473,"goal":"predicate IsEven_11786(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_11787","instance":11787,"id":248474,"goal":"predicate InRange_11787(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_11788","instance":11788,"id":248475,"goal":"predicate SubsetOf_11788(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_11789","instance":11789,"id":248476,"goal":"predicate AllMem_11789(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_11790","instance":11790,"id":248477,"goal":"predicate DisjointSets_11790(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_11791","instance":11791,"id":248478,"goal":"predicate Sorted_11791(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_11792","instance":11792,"id":248479,"goal":"predicate AllPositive_11792(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_11793","instance":11793,"id":248480,"goal":"predicate DistinctSeq_11793(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_11794","instance":11794,"id":248481,"goal":"predicate IsSubseq_11794(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_11795","instance":11795,"id":248482,"goal":"predicate IsPermutation_11795(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_11796","instance":11796,"id":248483,"goal":"predicate IsEven_11796(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_11797","instance":11797,"id":248484,"goal":"predicate InRange_11797(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_11798","instance":11798,"id":248485,"goal":"predicate SubsetOf_11798(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_11799","instance":11799,"id":248486,"goal":"predicate AllMem_11799(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_11800","instance":11800,"id":248487,"goal":"predicate DisjointSets_11800(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_11801","instance":11801,"id":248488,"goal":"predicate Sorted_11801(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_11802","instance":11802,"id":248489,"goal":"predicate AllPositive_11802(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_11803","instance":11803,"id":248490,"goal":"predicate DistinctSeq_11803(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_11804","instance":11804,"id":248491,"goal":"predicate IsSubseq_11804(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_11805","instance":11805,"id":248492,"goal":"predicate IsPermutation_11805(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_11806","instance":11806,"id":248493,"goal":"predicate IsEven_11806(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_11807","instance":11807,"id":248494,"goal":"predicate InRange_11807(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_11808","instance":11808,"id":248495,"goal":"predicate SubsetOf_11808(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_11809","instance":11809,"id":248496,"goal":"predicate AllMem_11809(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_11810","instance":11810,"id":248497,"goal":"predicate DisjointSets_11810(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_11811","instance":11811,"id":248498,"goal":"predicate Sorted_11811(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_11812","instance":11812,"id":248499,"goal":"predicate AllPositive_11812(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_11813","instance":11813,"id":248500,"goal":"predicate DistinctSeq_11813(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_11814","instance":11814,"id":248501,"goal":"predicate IsSubseq_11814(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_11815","instance":11815,"id":248502,"goal":"predicate IsPermutation_11815(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_11816","instance":11816,"id":248503,"goal":"predicate IsEven_11816(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_11817","instance":11817,"id":248504,"goal":"predicate InRange_11817(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_11818","instance":11818,"id":248505,"goal":"predicate SubsetOf_11818(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_11819","instance":11819,"id":248506,"goal":"predicate AllMem_11819(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_11820","instance":11820,"id":248507,"goal":"predicate DisjointSets_11820(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_11821","instance":11821,"id":248508,"goal":"predicate Sorted_11821(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_11822","instance":11822,"id":248509,"goal":"predicate AllPositive_11822(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_11823","instance":11823,"id":248510,"goal":"predicate DistinctSeq_11823(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_11824","instance":11824,"id":248511,"goal":"predicate IsSubseq_11824(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_11825","instance":11825,"id":248512,"goal":"predicate IsPermutation_11825(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_11826","instance":11826,"id":248513,"goal":"predicate IsEven_11826(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_11827","instance":11827,"id":248514,"goal":"predicate InRange_11827(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_11828","instance":11828,"id":248515,"goal":"predicate SubsetOf_11828(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_11829","instance":11829,"id":248516,"goal":"predicate AllMem_11829(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_11830","instance":11830,"id":248517,"goal":"predicate DisjointSets_11830(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_11831","instance":11831,"id":248518,"goal":"predicate Sorted_11831(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_11832","instance":11832,"id":248519,"goal":"predicate AllPositive_11832(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_11833","instance":11833,"id":248520,"goal":"predicate DistinctSeq_11833(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_11834","instance":11834,"id":248521,"goal":"predicate IsSubseq_11834(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_11835","instance":11835,"id":248522,"goal":"predicate IsPermutation_11835(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_11836","instance":11836,"id":248523,"goal":"predicate IsEven_11836(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_11837","instance":11837,"id":248524,"goal":"predicate InRange_11837(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_11838","instance":11838,"id":248525,"goal":"predicate SubsetOf_11838(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_11839","instance":11839,"id":248526,"goal":"predicate AllMem_11839(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_11840","instance":11840,"id":248527,"goal":"predicate DisjointSets_11840(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_11841","instance":11841,"id":248528,"goal":"predicate Sorted_11841(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_11842","instance":11842,"id":248529,"goal":"predicate AllPositive_11842(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_11843","instance":11843,"id":248530,"goal":"predicate DistinctSeq_11843(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_11844","instance":11844,"id":248531,"goal":"predicate IsSubseq_11844(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_11845","instance":11845,"id":248532,"goal":"predicate IsPermutation_11845(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_11846","instance":11846,"id":248533,"goal":"predicate IsEven_11846(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_11847","instance":11847,"id":248534,"goal":"predicate InRange_11847(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_11848","instance":11848,"id":248535,"goal":"predicate SubsetOf_11848(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_11849","instance":11849,"id":248536,"goal":"predicate AllMem_11849(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_11850","instance":11850,"id":248537,"goal":"predicate DisjointSets_11850(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_11851","instance":11851,"id":248538,"goal":"predicate Sorted_11851(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_11852","instance":11852,"id":248539,"goal":"predicate AllPositive_11852(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_11853","instance":11853,"id":248540,"goal":"predicate DistinctSeq_11853(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_11854","instance":11854,"id":248541,"goal":"predicate IsSubseq_11854(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_11855","instance":11855,"id":248542,"goal":"predicate IsPermutation_11855(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_11856","instance":11856,"id":248543,"goal":"predicate IsEven_11856(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_11857","instance":11857,"id":248544,"goal":"predicate InRange_11857(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_11858","instance":11858,"id":248545,"goal":"predicate SubsetOf_11858(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_11859","instance":11859,"id":248546,"goal":"predicate AllMem_11859(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_11860","instance":11860,"id":248547,"goal":"predicate DisjointSets_11860(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_11861","instance":11861,"id":248548,"goal":"predicate Sorted_11861(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_11862","instance":11862,"id":248549,"goal":"predicate AllPositive_11862(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_11863","instance":11863,"id":248550,"goal":"predicate DistinctSeq_11863(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_11864","instance":11864,"id":248551,"goal":"predicate IsSubseq_11864(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_11865","instance":11865,"id":248552,"goal":"predicate IsPermutation_11865(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_11866","instance":11866,"id":248553,"goal":"predicate IsEven_11866(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_11867","instance":11867,"id":248554,"goal":"predicate InRange_11867(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_11868","instance":11868,"id":248555,"goal":"predicate SubsetOf_11868(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_11869","instance":11869,"id":248556,"goal":"predicate AllMem_11869(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_11870","instance":11870,"id":248557,"goal":"predicate DisjointSets_11870(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_11871","instance":11871,"id":248558,"goal":"predicate Sorted_11871(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_11872","instance":11872,"id":248559,"goal":"predicate AllPositive_11872(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_11873","instance":11873,"id":248560,"goal":"predicate DistinctSeq_11873(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_11874","instance":11874,"id":248561,"goal":"predicate IsSubseq_11874(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_11875","instance":11875,"id":248562,"goal":"predicate IsPermutation_11875(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_11876","instance":11876,"id":248563,"goal":"predicate IsEven_11876(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_11877","instance":11877,"id":248564,"goal":"predicate InRange_11877(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_11878","instance":11878,"id":248565,"goal":"predicate SubsetOf_11878(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_11879","instance":11879,"id":248566,"goal":"predicate AllMem_11879(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_11880","instance":11880,"id":248567,"goal":"predicate DisjointSets_11880(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_11881","instance":11881,"id":248568,"goal":"predicate Sorted_11881(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_11882","instance":11882,"id":248569,"goal":"predicate AllPositive_11882(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_11883","instance":11883,"id":248570,"goal":"predicate DistinctSeq_11883(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_11884","instance":11884,"id":248571,"goal":"predicate IsSubseq_11884(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_11885","instance":11885,"id":248572,"goal":"predicate IsPermutation_11885(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_11886","instance":11886,"id":248573,"goal":"predicate IsEven_11886(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_11887","instance":11887,"id":248574,"goal":"predicate InRange_11887(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_11888","instance":11888,"id":248575,"goal":"predicate SubsetOf_11888(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_11889","instance":11889,"id":248576,"goal":"predicate AllMem_11889(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_11890","instance":11890,"id":248577,"goal":"predicate DisjointSets_11890(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_11891","instance":11891,"id":248578,"goal":"predicate Sorted_11891(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_11892","instance":11892,"id":248579,"goal":"predicate AllPositive_11892(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_11893","instance":11893,"id":248580,"goal":"predicate DistinctSeq_11893(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_11894","instance":11894,"id":248581,"goal":"predicate IsSubseq_11894(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_11895","instance":11895,"id":248582,"goal":"predicate IsPermutation_11895(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_11896","instance":11896,"id":248583,"goal":"predicate IsEven_11896(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_11897","instance":11897,"id":248584,"goal":"predicate InRange_11897(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_11898","instance":11898,"id":248585,"goal":"predicate SubsetOf_11898(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_11899","instance":11899,"id":248586,"goal":"predicate AllMem_11899(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_11900","instance":11900,"id":248587,"goal":"predicate DisjointSets_11900(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_11901","instance":11901,"id":248588,"goal":"predicate Sorted_11901(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_11902","instance":11902,"id":248589,"goal":"predicate AllPositive_11902(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_11903","instance":11903,"id":248590,"goal":"predicate DistinctSeq_11903(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_11904","instance":11904,"id":248591,"goal":"predicate IsSubseq_11904(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_11905","instance":11905,"id":248592,"goal":"predicate IsPermutation_11905(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_11906","instance":11906,"id":248593,"goal":"predicate IsEven_11906(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_11907","instance":11907,"id":248594,"goal":"predicate InRange_11907(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_11908","instance":11908,"id":248595,"goal":"predicate SubsetOf_11908(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_11909","instance":11909,"id":248596,"goal":"predicate AllMem_11909(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_11910","instance":11910,"id":248597,"goal":"predicate DisjointSets_11910(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_11911","instance":11911,"id":248598,"goal":"predicate Sorted_11911(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_11912","instance":11912,"id":248599,"goal":"predicate AllPositive_11912(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_11913","instance":11913,"id":248600,"goal":"predicate DistinctSeq_11913(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_11914","instance":11914,"id":248601,"goal":"predicate IsSubseq_11914(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_11915","instance":11915,"id":248602,"goal":"predicate IsPermutation_11915(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_11916","instance":11916,"id":248603,"goal":"predicate IsEven_11916(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_11917","instance":11917,"id":248604,"goal":"predicate InRange_11917(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_11918","instance":11918,"id":248605,"goal":"predicate SubsetOf_11918(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_11919","instance":11919,"id":248606,"goal":"predicate AllMem_11919(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_11920","instance":11920,"id":248607,"goal":"predicate DisjointSets_11920(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_11921","instance":11921,"id":248608,"goal":"predicate Sorted_11921(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_11922","instance":11922,"id":248609,"goal":"predicate AllPositive_11922(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_11923","instance":11923,"id":248610,"goal":"predicate DistinctSeq_11923(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_11924","instance":11924,"id":248611,"goal":"predicate IsSubseq_11924(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_11925","instance":11925,"id":248612,"goal":"predicate IsPermutation_11925(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_11926","instance":11926,"id":248613,"goal":"predicate IsEven_11926(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_11927","instance":11927,"id":248614,"goal":"predicate InRange_11927(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_11928","instance":11928,"id":248615,"goal":"predicate SubsetOf_11928(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_11929","instance":11929,"id":248616,"goal":"predicate AllMem_11929(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_11930","instance":11930,"id":248617,"goal":"predicate DisjointSets_11930(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_11931","instance":11931,"id":248618,"goal":"predicate Sorted_11931(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_11932","instance":11932,"id":248619,"goal":"predicate AllPositive_11932(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_11933","instance":11933,"id":248620,"goal":"predicate DistinctSeq_11933(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_11934","instance":11934,"id":248621,"goal":"predicate IsSubseq_11934(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_11935","instance":11935,"id":248622,"goal":"predicate IsPermutation_11935(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_11936","instance":11936,"id":248623,"goal":"predicate IsEven_11936(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_11937","instance":11937,"id":248624,"goal":"predicate InRange_11937(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_11938","instance":11938,"id":248625,"goal":"predicate SubsetOf_11938(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_11939","instance":11939,"id":248626,"goal":"predicate AllMem_11939(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_11940","instance":11940,"id":248627,"goal":"predicate DisjointSets_11940(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_11941","instance":11941,"id":248628,"goal":"predicate Sorted_11941(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_11942","instance":11942,"id":248629,"goal":"predicate AllPositive_11942(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_11943","instance":11943,"id":248630,"goal":"predicate DistinctSeq_11943(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_11944","instance":11944,"id":248631,"goal":"predicate IsSubseq_11944(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_11945","instance":11945,"id":248632,"goal":"predicate IsPermutation_11945(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_11946","instance":11946,"id":248633,"goal":"predicate IsEven_11946(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_11947","instance":11947,"id":248634,"goal":"predicate InRange_11947(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_11948","instance":11948,"id":248635,"goal":"predicate SubsetOf_11948(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_11949","instance":11949,"id":248636,"goal":"predicate AllMem_11949(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_11950","instance":11950,"id":248637,"goal":"predicate DisjointSets_11950(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_11951","instance":11951,"id":248638,"goal":"predicate Sorted_11951(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_11952","instance":11952,"id":248639,"goal":"predicate AllPositive_11952(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_11953","instance":11953,"id":248640,"goal":"predicate DistinctSeq_11953(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_11954","instance":11954,"id":248641,"goal":"predicate IsSubseq_11954(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_11955","instance":11955,"id":248642,"goal":"predicate IsPermutation_11955(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_11956","instance":11956,"id":248643,"goal":"predicate IsEven_11956(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_11957","instance":11957,"id":248644,"goal":"predicate InRange_11957(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_11958","instance":11958,"id":248645,"goal":"predicate SubsetOf_11958(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_11959","instance":11959,"id":248646,"goal":"predicate AllMem_11959(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_11960","instance":11960,"id":248647,"goal":"predicate DisjointSets_11960(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_11961","instance":11961,"id":248648,"goal":"predicate Sorted_11961(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_11962","instance":11962,"id":248649,"goal":"predicate AllPositive_11962(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_11963","instance":11963,"id":248650,"goal":"predicate DistinctSeq_11963(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_11964","instance":11964,"id":248651,"goal":"predicate IsSubseq_11964(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_11965","instance":11965,"id":248652,"goal":"predicate IsPermutation_11965(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_11966","instance":11966,"id":248653,"goal":"predicate IsEven_11966(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_11967","instance":11967,"id":248654,"goal":"predicate InRange_11967(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_11968","instance":11968,"id":248655,"goal":"predicate SubsetOf_11968(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_11969","instance":11969,"id":248656,"goal":"predicate AllMem_11969(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_11970","instance":11970,"id":248657,"goal":"predicate DisjointSets_11970(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_11971","instance":11971,"id":248658,"goal":"predicate Sorted_11971(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_11972","instance":11972,"id":248659,"goal":"predicate AllPositive_11972(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_11973","instance":11973,"id":248660,"goal":"predicate DistinctSeq_11973(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_11974","instance":11974,"id":248661,"goal":"predicate IsSubseq_11974(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_11975","instance":11975,"id":248662,"goal":"predicate IsPermutation_11975(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_11976","instance":11976,"id":248663,"goal":"predicate IsEven_11976(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_11977","instance":11977,"id":248664,"goal":"predicate InRange_11977(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_11978","instance":11978,"id":248665,"goal":"predicate SubsetOf_11978(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_11979","instance":11979,"id":248666,"goal":"predicate AllMem_11979(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_11980","instance":11980,"id":248667,"goal":"predicate DisjointSets_11980(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_11981","instance":11981,"id":248668,"goal":"predicate Sorted_11981(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_11982","instance":11982,"id":248669,"goal":"predicate AllPositive_11982(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_11983","instance":11983,"id":248670,"goal":"predicate DistinctSeq_11983(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_11984","instance":11984,"id":248671,"goal":"predicate IsSubseq_11984(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_11985","instance":11985,"id":248672,"goal":"predicate IsPermutation_11985(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_11986","instance":11986,"id":248673,"goal":"predicate IsEven_11986(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_11987","instance":11987,"id":248674,"goal":"predicate InRange_11987(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_11988","instance":11988,"id":248675,"goal":"predicate SubsetOf_11988(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_11989","instance":11989,"id":248676,"goal":"predicate AllMem_11989(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_11990","instance":11990,"id":248677,"goal":"predicate DisjointSets_11990(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_11991","instance":11991,"id":248678,"goal":"predicate Sorted_11991(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_11992","instance":11992,"id":248679,"goal":"predicate AllPositive_11992(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_11993","instance":11993,"id":248680,"goal":"predicate DistinctSeq_11993(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_11994","instance":11994,"id":248681,"goal":"predicate IsSubseq_11994(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_11995","instance":11995,"id":248682,"goal":"predicate IsPermutation_11995(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_11996","instance":11996,"id":248683,"goal":"predicate IsEven_11996(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_11997","instance":11997,"id":248684,"goal":"predicate InRange_11997(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_11998","instance":11998,"id":248685,"goal":"predicate SubsetOf_11998(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_11999","instance":11999,"id":248686,"goal":"predicate AllMem_11999(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_12000","instance":12000,"id":248687,"goal":"predicate DisjointSets_12000(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_12001","instance":12001,"id":248688,"goal":"predicate Sorted_12001(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_12002","instance":12002,"id":248689,"goal":"predicate AllPositive_12002(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_12003","instance":12003,"id":248690,"goal":"predicate DistinctSeq_12003(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_12004","instance":12004,"id":248691,"goal":"predicate IsSubseq_12004(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_12005","instance":12005,"id":248692,"goal":"predicate IsPermutation_12005(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_12006","instance":12006,"id":248693,"goal":"predicate IsEven_12006(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_12007","instance":12007,"id":248694,"goal":"predicate InRange_12007(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_12008","instance":12008,"id":248695,"goal":"predicate SubsetOf_12008(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_12009","instance":12009,"id":248696,"goal":"predicate AllMem_12009(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_12010","instance":12010,"id":248697,"goal":"predicate DisjointSets_12010(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_12011","instance":12011,"id":248698,"goal":"predicate Sorted_12011(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_12012","instance":12012,"id":248699,"goal":"predicate AllPositive_12012(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_12013","instance":12013,"id":248700,"goal":"predicate DistinctSeq_12013(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_12014","instance":12014,"id":248701,"goal":"predicate IsSubseq_12014(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_12015","instance":12015,"id":248702,"goal":"predicate IsPermutation_12015(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_12016","instance":12016,"id":248703,"goal":"predicate IsEven_12016(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_12017","instance":12017,"id":248704,"goal":"predicate InRange_12017(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_12018","instance":12018,"id":248705,"goal":"predicate SubsetOf_12018(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_12019","instance":12019,"id":248706,"goal":"predicate AllMem_12019(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_12020","instance":12020,"id":248707,"goal":"predicate DisjointSets_12020(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_12021","instance":12021,"id":248708,"goal":"predicate Sorted_12021(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_12022","instance":12022,"id":248709,"goal":"predicate AllPositive_12022(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_12023","instance":12023,"id":248710,"goal":"predicate DistinctSeq_12023(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_12024","instance":12024,"id":248711,"goal":"predicate IsSubseq_12024(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_12025","instance":12025,"id":248712,"goal":"predicate IsPermutation_12025(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_12026","instance":12026,"id":248713,"goal":"predicate IsEven_12026(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_12027","instance":12027,"id":248714,"goal":"predicate InRange_12027(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_12028","instance":12028,"id":248715,"goal":"predicate SubsetOf_12028(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_12029","instance":12029,"id":248716,"goal":"predicate AllMem_12029(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_12030","instance":12030,"id":248717,"goal":"predicate DisjointSets_12030(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_12031","instance":12031,"id":248718,"goal":"predicate Sorted_12031(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_12032","instance":12032,"id":248719,"goal":"predicate AllPositive_12032(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_12033","instance":12033,"id":248720,"goal":"predicate DistinctSeq_12033(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_12034","instance":12034,"id":248721,"goal":"predicate IsSubseq_12034(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_12035","instance":12035,"id":248722,"goal":"predicate IsPermutation_12035(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_12036","instance":12036,"id":248723,"goal":"predicate IsEven_12036(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_12037","instance":12037,"id":248724,"goal":"predicate InRange_12037(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_12038","instance":12038,"id":248725,"goal":"predicate SubsetOf_12038(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_12039","instance":12039,"id":248726,"goal":"predicate AllMem_12039(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_12040","instance":12040,"id":248727,"goal":"predicate DisjointSets_12040(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_12041","instance":12041,"id":248728,"goal":"predicate Sorted_12041(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_12042","instance":12042,"id":248729,"goal":"predicate AllPositive_12042(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_12043","instance":12043,"id":248730,"goal":"predicate DistinctSeq_12043(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_12044","instance":12044,"id":248731,"goal":"predicate IsSubseq_12044(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_12045","instance":12045,"id":248732,"goal":"predicate IsPermutation_12045(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_12046","instance":12046,"id":248733,"goal":"predicate IsEven_12046(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_12047","instance":12047,"id":248734,"goal":"predicate InRange_12047(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_12048","instance":12048,"id":248735,"goal":"predicate SubsetOf_12048(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_12049","instance":12049,"id":248736,"goal":"predicate AllMem_12049(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_12050","instance":12050,"id":248737,"goal":"predicate DisjointSets_12050(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_12051","instance":12051,"id":248738,"goal":"predicate Sorted_12051(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_12052","instance":12052,"id":248739,"goal":"predicate AllPositive_12052(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_12053","instance":12053,"id":248740,"goal":"predicate DistinctSeq_12053(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_12054","instance":12054,"id":248741,"goal":"predicate IsSubseq_12054(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_12055","instance":12055,"id":248742,"goal":"predicate IsPermutation_12055(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_12056","instance":12056,"id":248743,"goal":"predicate IsEven_12056(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_12057","instance":12057,"id":248744,"goal":"predicate InRange_12057(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_12058","instance":12058,"id":248745,"goal":"predicate SubsetOf_12058(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_12059","instance":12059,"id":248746,"goal":"predicate AllMem_12059(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_12060","instance":12060,"id":248747,"goal":"predicate DisjointSets_12060(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_12061","instance":12061,"id":248748,"goal":"predicate Sorted_12061(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_12062","instance":12062,"id":248749,"goal":"predicate AllPositive_12062(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_12063","instance":12063,"id":248750,"goal":"predicate DistinctSeq_12063(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_12064","instance":12064,"id":248751,"goal":"predicate IsSubseq_12064(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_12065","instance":12065,"id":248752,"goal":"predicate IsPermutation_12065(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_12066","instance":12066,"id":248753,"goal":"predicate IsEven_12066(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_12067","instance":12067,"id":248754,"goal":"predicate InRange_12067(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_12068","instance":12068,"id":248755,"goal":"predicate SubsetOf_12068(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_12069","instance":12069,"id":248756,"goal":"predicate AllMem_12069(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_12070","instance":12070,"id":248757,"goal":"predicate DisjointSets_12070(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_12071","instance":12071,"id":248758,"goal":"predicate Sorted_12071(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_12072","instance":12072,"id":248759,"goal":"predicate AllPositive_12072(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_12073","instance":12073,"id":248760,"goal":"predicate DistinctSeq_12073(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_12074","instance":12074,"id":248761,"goal":"predicate IsSubseq_12074(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_12075","instance":12075,"id":248762,"goal":"predicate IsPermutation_12075(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_12076","instance":12076,"id":248763,"goal":"predicate IsEven_12076(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_12077","instance":12077,"id":248764,"goal":"predicate InRange_12077(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_12078","instance":12078,"id":248765,"goal":"predicate SubsetOf_12078(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_12079","instance":12079,"id":248766,"goal":"predicate AllMem_12079(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_12080","instance":12080,"id":248767,"goal":"predicate DisjointSets_12080(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_12081","instance":12081,"id":248768,"goal":"predicate Sorted_12081(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_12082","instance":12082,"id":248769,"goal":"predicate AllPositive_12082(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_12083","instance":12083,"id":248770,"goal":"predicate DistinctSeq_12083(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_12084","instance":12084,"id":248771,"goal":"predicate IsSubseq_12084(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_12085","instance":12085,"id":248772,"goal":"predicate IsPermutation_12085(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_12086","instance":12086,"id":248773,"goal":"predicate IsEven_12086(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_12087","instance":12087,"id":248774,"goal":"predicate InRange_12087(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_12088","instance":12088,"id":248775,"goal":"predicate SubsetOf_12088(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_12089","instance":12089,"id":248776,"goal":"predicate AllMem_12089(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_12090","instance":12090,"id":248777,"goal":"predicate DisjointSets_12090(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_12091","instance":12091,"id":248778,"goal":"predicate Sorted_12091(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_12092","instance":12092,"id":248779,"goal":"predicate AllPositive_12092(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_12093","instance":12093,"id":248780,"goal":"predicate DistinctSeq_12093(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_12094","instance":12094,"id":248781,"goal":"predicate IsSubseq_12094(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_12095","instance":12095,"id":248782,"goal":"predicate IsPermutation_12095(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_12096","instance":12096,"id":248783,"goal":"predicate IsEven_12096(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_12097","instance":12097,"id":248784,"goal":"predicate InRange_12097(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_12098","instance":12098,"id":248785,"goal":"predicate SubsetOf_12098(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_12099","instance":12099,"id":248786,"goal":"predicate AllMem_12099(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_12100","instance":12100,"id":248787,"goal":"predicate DisjointSets_12100(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_12101","instance":12101,"id":248788,"goal":"predicate Sorted_12101(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_12102","instance":12102,"id":248789,"goal":"predicate AllPositive_12102(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_12103","instance":12103,"id":248790,"goal":"predicate DistinctSeq_12103(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_12104","instance":12104,"id":248791,"goal":"predicate IsSubseq_12104(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_12105","instance":12105,"id":248792,"goal":"predicate IsPermutation_12105(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_12106","instance":12106,"id":248793,"goal":"predicate IsEven_12106(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_12107","instance":12107,"id":248794,"goal":"predicate InRange_12107(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_12108","instance":12108,"id":248795,"goal":"predicate SubsetOf_12108(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_12109","instance":12109,"id":248796,"goal":"predicate AllMem_12109(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_12110","instance":12110,"id":248797,"goal":"predicate DisjointSets_12110(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_12111","instance":12111,"id":248798,"goal":"predicate Sorted_12111(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_12112","instance":12112,"id":248799,"goal":"predicate AllPositive_12112(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_12113","instance":12113,"id":248800,"goal":"predicate DistinctSeq_12113(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_12114","instance":12114,"id":248801,"goal":"predicate IsSubseq_12114(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_12115","instance":12115,"id":248802,"goal":"predicate IsPermutation_12115(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_12116","instance":12116,"id":248803,"goal":"predicate IsEven_12116(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_12117","instance":12117,"id":248804,"goal":"predicate InRange_12117(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_12118","instance":12118,"id":248805,"goal":"predicate SubsetOf_12118(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_12119","instance":12119,"id":248806,"goal":"predicate AllMem_12119(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_12120","instance":12120,"id":248807,"goal":"predicate DisjointSets_12120(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_12121","instance":12121,"id":248808,"goal":"predicate Sorted_12121(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_12122","instance":12122,"id":248809,"goal":"predicate AllPositive_12122(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_12123","instance":12123,"id":248810,"goal":"predicate DistinctSeq_12123(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_12124","instance":12124,"id":248811,"goal":"predicate IsSubseq_12124(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_12125","instance":12125,"id":248812,"goal":"predicate IsPermutation_12125(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_12126","instance":12126,"id":248813,"goal":"predicate IsEven_12126(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_12127","instance":12127,"id":248814,"goal":"predicate InRange_12127(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_12128","instance":12128,"id":248815,"goal":"predicate SubsetOf_12128(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_12129","instance":12129,"id":248816,"goal":"predicate AllMem_12129(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_12130","instance":12130,"id":248817,"goal":"predicate DisjointSets_12130(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_12131","instance":12131,"id":248818,"goal":"predicate Sorted_12131(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_12132","instance":12132,"id":248819,"goal":"predicate AllPositive_12132(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_12133","instance":12133,"id":248820,"goal":"predicate DistinctSeq_12133(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_12134","instance":12134,"id":248821,"goal":"predicate IsSubseq_12134(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_12135","instance":12135,"id":248822,"goal":"predicate IsPermutation_12135(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_12136","instance":12136,"id":248823,"goal":"predicate IsEven_12136(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_12137","instance":12137,"id":248824,"goal":"predicate InRange_12137(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_12138","instance":12138,"id":248825,"goal":"predicate SubsetOf_12138(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_12139","instance":12139,"id":248826,"goal":"predicate AllMem_12139(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_12140","instance":12140,"id":248827,"goal":"predicate DisjointSets_12140(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_12141","instance":12141,"id":248828,"goal":"predicate Sorted_12141(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_12142","instance":12142,"id":248829,"goal":"predicate AllPositive_12142(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_12143","instance":12143,"id":248830,"goal":"predicate DistinctSeq_12143(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_12144","instance":12144,"id":248831,"goal":"predicate IsSubseq_12144(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_12145","instance":12145,"id":248832,"goal":"predicate IsPermutation_12145(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_12146","instance":12146,"id":248833,"goal":"predicate IsEven_12146(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_12147","instance":12147,"id":248834,"goal":"predicate InRange_12147(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_12148","instance":12148,"id":248835,"goal":"predicate SubsetOf_12148(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_12149","instance":12149,"id":248836,"goal":"predicate AllMem_12149(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_12150","instance":12150,"id":248837,"goal":"predicate DisjointSets_12150(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_12151","instance":12151,"id":248838,"goal":"predicate Sorted_12151(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_12152","instance":12152,"id":248839,"goal":"predicate AllPositive_12152(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_12153","instance":12153,"id":248840,"goal":"predicate DistinctSeq_12153(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_12154","instance":12154,"id":248841,"goal":"predicate IsSubseq_12154(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_12155","instance":12155,"id":248842,"goal":"predicate IsPermutation_12155(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_12156","instance":12156,"id":248843,"goal":"predicate IsEven_12156(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_12157","instance":12157,"id":248844,"goal":"predicate InRange_12157(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_12158","instance":12158,"id":248845,"goal":"predicate SubsetOf_12158(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_12159","instance":12159,"id":248846,"goal":"predicate AllMem_12159(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_12160","instance":12160,"id":248847,"goal":"predicate DisjointSets_12160(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_12161","instance":12161,"id":248848,"goal":"predicate Sorted_12161(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_12162","instance":12162,"id":248849,"goal":"predicate AllPositive_12162(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_12163","instance":12163,"id":248850,"goal":"predicate DistinctSeq_12163(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_12164","instance":12164,"id":248851,"goal":"predicate IsSubseq_12164(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_12165","instance":12165,"id":248852,"goal":"predicate IsPermutation_12165(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_12166","instance":12166,"id":248853,"goal":"predicate IsEven_12166(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_12167","instance":12167,"id":248854,"goal":"predicate InRange_12167(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_12168","instance":12168,"id":248855,"goal":"predicate SubsetOf_12168(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_12169","instance":12169,"id":248856,"goal":"predicate AllMem_12169(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_12170","instance":12170,"id":248857,"goal":"predicate DisjointSets_12170(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_12171","instance":12171,"id":248858,"goal":"predicate Sorted_12171(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_12172","instance":12172,"id":248859,"goal":"predicate AllPositive_12172(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_12173","instance":12173,"id":248860,"goal":"predicate DistinctSeq_12173(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_12174","instance":12174,"id":248861,"goal":"predicate IsSubseq_12174(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_12175","instance":12175,"id":248862,"goal":"predicate IsPermutation_12175(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_12176","instance":12176,"id":248863,"goal":"predicate IsEven_12176(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_12177","instance":12177,"id":248864,"goal":"predicate InRange_12177(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_12178","instance":12178,"id":248865,"goal":"predicate SubsetOf_12178(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_12179","instance":12179,"id":248866,"goal":"predicate AllMem_12179(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_12180","instance":12180,"id":248867,"goal":"predicate DisjointSets_12180(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_12181","instance":12181,"id":248868,"goal":"predicate Sorted_12181(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_12182","instance":12182,"id":248869,"goal":"predicate AllPositive_12182(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_12183","instance":12183,"id":248870,"goal":"predicate DistinctSeq_12183(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_12184","instance":12184,"id":248871,"goal":"predicate IsSubseq_12184(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_12185","instance":12185,"id":248872,"goal":"predicate IsPermutation_12185(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_12186","instance":12186,"id":248873,"goal":"predicate IsEven_12186(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_12187","instance":12187,"id":248874,"goal":"predicate InRange_12187(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_12188","instance":12188,"id":248875,"goal":"predicate SubsetOf_12188(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_12189","instance":12189,"id":248876,"goal":"predicate AllMem_12189(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_12190","instance":12190,"id":248877,"goal":"predicate DisjointSets_12190(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_12191","instance":12191,"id":248878,"goal":"predicate Sorted_12191(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_12192","instance":12192,"id":248879,"goal":"predicate AllPositive_12192(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_12193","instance":12193,"id":248880,"goal":"predicate DistinctSeq_12193(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_12194","instance":12194,"id":248881,"goal":"predicate IsSubseq_12194(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_12195","instance":12195,"id":248882,"goal":"predicate IsPermutation_12195(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_12196","instance":12196,"id":248883,"goal":"predicate IsEven_12196(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_12197","instance":12197,"id":248884,"goal":"predicate InRange_12197(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_12198","instance":12198,"id":248885,"goal":"predicate SubsetOf_12198(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_12199","instance":12199,"id":248886,"goal":"predicate AllMem_12199(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_12200","instance":12200,"id":248887,"goal":"predicate DisjointSets_12200(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_12201","instance":12201,"id":248888,"goal":"predicate Sorted_12201(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_12202","instance":12202,"id":248889,"goal":"predicate AllPositive_12202(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_12203","instance":12203,"id":248890,"goal":"predicate DistinctSeq_12203(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_12204","instance":12204,"id":248891,"goal":"predicate IsSubseq_12204(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_12205","instance":12205,"id":248892,"goal":"predicate IsPermutation_12205(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_12206","instance":12206,"id":248893,"goal":"predicate IsEven_12206(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_12207","instance":12207,"id":248894,"goal":"predicate InRange_12207(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_12208","instance":12208,"id":248895,"goal":"predicate SubsetOf_12208(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_12209","instance":12209,"id":248896,"goal":"predicate AllMem_12209(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_12210","instance":12210,"id":248897,"goal":"predicate DisjointSets_12210(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_12211","instance":12211,"id":248898,"goal":"predicate Sorted_12211(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_12212","instance":12212,"id":248899,"goal":"predicate AllPositive_12212(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_12213","instance":12213,"id":248900,"goal":"predicate DistinctSeq_12213(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_12214","instance":12214,"id":248901,"goal":"predicate IsSubseq_12214(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_12215","instance":12215,"id":248902,"goal":"predicate IsPermutation_12215(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_12216","instance":12216,"id":248903,"goal":"predicate IsEven_12216(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_12217","instance":12217,"id":248904,"goal":"predicate InRange_12217(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_12218","instance":12218,"id":248905,"goal":"predicate SubsetOf_12218(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_12219","instance":12219,"id":248906,"goal":"predicate AllMem_12219(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_12220","instance":12220,"id":248907,"goal":"predicate DisjointSets_12220(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_12221","instance":12221,"id":248908,"goal":"predicate Sorted_12221(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_12222","instance":12222,"id":248909,"goal":"predicate AllPositive_12222(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_12223","instance":12223,"id":248910,"goal":"predicate DistinctSeq_12223(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_12224","instance":12224,"id":248911,"goal":"predicate IsSubseq_12224(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_12225","instance":12225,"id":248912,"goal":"predicate IsPermutation_12225(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_12226","instance":12226,"id":248913,"goal":"predicate IsEven_12226(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_12227","instance":12227,"id":248914,"goal":"predicate InRange_12227(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_12228","instance":12228,"id":248915,"goal":"predicate SubsetOf_12228(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_12229","instance":12229,"id":248916,"goal":"predicate AllMem_12229(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_12230","instance":12230,"id":248917,"goal":"predicate DisjointSets_12230(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_12231","instance":12231,"id":248918,"goal":"predicate Sorted_12231(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_12232","instance":12232,"id":248919,"goal":"predicate AllPositive_12232(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_12233","instance":12233,"id":248920,"goal":"predicate DistinctSeq_12233(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_12234","instance":12234,"id":248921,"goal":"predicate IsSubseq_12234(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_12235","instance":12235,"id":248922,"goal":"predicate IsPermutation_12235(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_12236","instance":12236,"id":248923,"goal":"predicate IsEven_12236(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_12237","instance":12237,"id":248924,"goal":"predicate InRange_12237(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_12238","instance":12238,"id":248925,"goal":"predicate SubsetOf_12238(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_12239","instance":12239,"id":248926,"goal":"predicate AllMem_12239(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_12240","instance":12240,"id":248927,"goal":"predicate DisjointSets_12240(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_12241","instance":12241,"id":248928,"goal":"predicate Sorted_12241(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_12242","instance":12242,"id":248929,"goal":"predicate AllPositive_12242(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_12243","instance":12243,"id":248930,"goal":"predicate DistinctSeq_12243(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_12244","instance":12244,"id":248931,"goal":"predicate IsSubseq_12244(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_12245","instance":12245,"id":248932,"goal":"predicate IsPermutation_12245(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_12246","instance":12246,"id":248933,"goal":"predicate IsEven_12246(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_12247","instance":12247,"id":248934,"goal":"predicate InRange_12247(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_12248","instance":12248,"id":248935,"goal":"predicate SubsetOf_12248(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_12249","instance":12249,"id":248936,"goal":"predicate AllMem_12249(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_12250","instance":12250,"id":248937,"goal":"predicate DisjointSets_12250(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_12251","instance":12251,"id":248938,"goal":"predicate Sorted_12251(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_12252","instance":12252,"id":248939,"goal":"predicate AllPositive_12252(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_12253","instance":12253,"id":248940,"goal":"predicate DistinctSeq_12253(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_12254","instance":12254,"id":248941,"goal":"predicate IsSubseq_12254(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_12255","instance":12255,"id":248942,"goal":"predicate IsPermutation_12255(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_12256","instance":12256,"id":248943,"goal":"predicate IsEven_12256(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_12257","instance":12257,"id":248944,"goal":"predicate InRange_12257(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_12258","instance":12258,"id":248945,"goal":"predicate SubsetOf_12258(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_12259","instance":12259,"id":248946,"goal":"predicate AllMem_12259(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_12260","instance":12260,"id":248947,"goal":"predicate DisjointSets_12260(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_12261","instance":12261,"id":248948,"goal":"predicate Sorted_12261(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_12262","instance":12262,"id":248949,"goal":"predicate AllPositive_12262(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_12263","instance":12263,"id":248950,"goal":"predicate DistinctSeq_12263(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_12264","instance":12264,"id":248951,"goal":"predicate IsSubseq_12264(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_12265","instance":12265,"id":248952,"goal":"predicate IsPermutation_12265(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_12266","instance":12266,"id":248953,"goal":"predicate IsEven_12266(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_12267","instance":12267,"id":248954,"goal":"predicate InRange_12267(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_12268","instance":12268,"id":248955,"goal":"predicate SubsetOf_12268(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_12269","instance":12269,"id":248956,"goal":"predicate AllMem_12269(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_12270","instance":12270,"id":248957,"goal":"predicate DisjointSets_12270(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_12271","instance":12271,"id":248958,"goal":"predicate Sorted_12271(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_12272","instance":12272,"id":248959,"goal":"predicate AllPositive_12272(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_12273","instance":12273,"id":248960,"goal":"predicate DistinctSeq_12273(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_12274","instance":12274,"id":248961,"goal":"predicate IsSubseq_12274(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_12275","instance":12275,"id":248962,"goal":"predicate IsPermutation_12275(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_12276","instance":12276,"id":248963,"goal":"predicate IsEven_12276(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_12277","instance":12277,"id":248964,"goal":"predicate InRange_12277(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_12278","instance":12278,"id":248965,"goal":"predicate SubsetOf_12278(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_12279","instance":12279,"id":248966,"goal":"predicate AllMem_12279(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_12280","instance":12280,"id":248967,"goal":"predicate DisjointSets_12280(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_12281","instance":12281,"id":248968,"goal":"predicate Sorted_12281(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_12282","instance":12282,"id":248969,"goal":"predicate AllPositive_12282(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_12283","instance":12283,"id":248970,"goal":"predicate DistinctSeq_12283(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_12284","instance":12284,"id":248971,"goal":"predicate IsSubseq_12284(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_12285","instance":12285,"id":248972,"goal":"predicate IsPermutation_12285(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_12286","instance":12286,"id":248973,"goal":"predicate IsEven_12286(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_12287","instance":12287,"id":248974,"goal":"predicate InRange_12287(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_12288","instance":12288,"id":248975,"goal":"predicate SubsetOf_12288(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_12289","instance":12289,"id":248976,"goal":"predicate AllMem_12289(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_12290","instance":12290,"id":248977,"goal":"predicate DisjointSets_12290(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_12291","instance":12291,"id":248978,"goal":"predicate Sorted_12291(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_12292","instance":12292,"id":248979,"goal":"predicate AllPositive_12292(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_12293","instance":12293,"id":248980,"goal":"predicate DistinctSeq_12293(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_12294","instance":12294,"id":248981,"goal":"predicate IsSubseq_12294(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_12295","instance":12295,"id":248982,"goal":"predicate IsPermutation_12295(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_12296","instance":12296,"id":248983,"goal":"predicate IsEven_12296(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_12297","instance":12297,"id":248984,"goal":"predicate InRange_12297(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_12298","instance":12298,"id":248985,"goal":"predicate SubsetOf_12298(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_12299","instance":12299,"id":248986,"goal":"predicate AllMem_12299(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_12300","instance":12300,"id":248987,"goal":"predicate DisjointSets_12300(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_12301","instance":12301,"id":248988,"goal":"predicate Sorted_12301(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_12302","instance":12302,"id":248989,"goal":"predicate AllPositive_12302(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_12303","instance":12303,"id":248990,"goal":"predicate DistinctSeq_12303(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_12304","instance":12304,"id":248991,"goal":"predicate IsSubseq_12304(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_12305","instance":12305,"id":248992,"goal":"predicate IsPermutation_12305(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_12306","instance":12306,"id":248993,"goal":"predicate IsEven_12306(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_12307","instance":12307,"id":248994,"goal":"predicate InRange_12307(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_12308","instance":12308,"id":248995,"goal":"predicate SubsetOf_12308(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_12309","instance":12309,"id":248996,"goal":"predicate AllMem_12309(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_12310","instance":12310,"id":248997,"goal":"predicate DisjointSets_12310(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_12311","instance":12311,"id":248998,"goal":"predicate Sorted_12311(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_12312","instance":12312,"id":248999,"goal":"predicate AllPositive_12312(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_12313","instance":12313,"id":249000,"goal":"predicate DistinctSeq_12313(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_12314","instance":12314,"id":249001,"goal":"predicate IsSubseq_12314(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_12315","instance":12315,"id":249002,"goal":"predicate IsPermutation_12315(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_12316","instance":12316,"id":249003,"goal":"predicate IsEven_12316(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_12317","instance":12317,"id":249004,"goal":"predicate InRange_12317(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_12318","instance":12318,"id":249005,"goal":"predicate SubsetOf_12318(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_12319","instance":12319,"id":249006,"goal":"predicate AllMem_12319(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_12320","instance":12320,"id":249007,"goal":"predicate DisjointSets_12320(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_12321","instance":12321,"id":249008,"goal":"predicate Sorted_12321(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_12322","instance":12322,"id":249009,"goal":"predicate AllPositive_12322(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_12323","instance":12323,"id":249010,"goal":"predicate DistinctSeq_12323(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_12324","instance":12324,"id":249011,"goal":"predicate IsSubseq_12324(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_12325","instance":12325,"id":249012,"goal":"predicate IsPermutation_12325(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_12326","instance":12326,"id":249013,"goal":"predicate IsEven_12326(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_12327","instance":12327,"id":249014,"goal":"predicate InRange_12327(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_12328","instance":12328,"id":249015,"goal":"predicate SubsetOf_12328(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_12329","instance":12329,"id":249016,"goal":"predicate AllMem_12329(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_12330","instance":12330,"id":249017,"goal":"predicate DisjointSets_12330(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_12331","instance":12331,"id":249018,"goal":"predicate Sorted_12331(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_12332","instance":12332,"id":249019,"goal":"predicate AllPositive_12332(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_12333","instance":12333,"id":249020,"goal":"predicate DistinctSeq_12333(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_12334","instance":12334,"id":249021,"goal":"predicate IsSubseq_12334(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_12335","instance":12335,"id":249022,"goal":"predicate IsPermutation_12335(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_12336","instance":12336,"id":249023,"goal":"predicate IsEven_12336(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_12337","instance":12337,"id":249024,"goal":"predicate InRange_12337(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_12338","instance":12338,"id":249025,"goal":"predicate SubsetOf_12338(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_12339","instance":12339,"id":249026,"goal":"predicate AllMem_12339(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_12340","instance":12340,"id":249027,"goal":"predicate DisjointSets_12340(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_12341","instance":12341,"id":249028,"goal":"predicate Sorted_12341(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_12342","instance":12342,"id":249029,"goal":"predicate AllPositive_12342(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_12343","instance":12343,"id":249030,"goal":"predicate DistinctSeq_12343(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_12344","instance":12344,"id":249031,"goal":"predicate IsSubseq_12344(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_12345","instance":12345,"id":249032,"goal":"predicate IsPermutation_12345(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_12346","instance":12346,"id":249033,"goal":"predicate IsEven_12346(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_12347","instance":12347,"id":249034,"goal":"predicate InRange_12347(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_12348","instance":12348,"id":249035,"goal":"predicate SubsetOf_12348(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_12349","instance":12349,"id":249036,"goal":"predicate AllMem_12349(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_12350","instance":12350,"id":249037,"goal":"predicate DisjointSets_12350(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_12351","instance":12351,"id":249038,"goal":"predicate Sorted_12351(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_12352","instance":12352,"id":249039,"goal":"predicate AllPositive_12352(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_12353","instance":12353,"id":249040,"goal":"predicate DistinctSeq_12353(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_12354","instance":12354,"id":249041,"goal":"predicate IsSubseq_12354(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_12355","instance":12355,"id":249042,"goal":"predicate IsPermutation_12355(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_12356","instance":12356,"id":249043,"goal":"predicate IsEven_12356(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_12357","instance":12357,"id":249044,"goal":"predicate InRange_12357(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_12358","instance":12358,"id":249045,"goal":"predicate SubsetOf_12358(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_12359","instance":12359,"id":249046,"goal":"predicate AllMem_12359(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_12360","instance":12360,"id":249047,"goal":"predicate DisjointSets_12360(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_12361","instance":12361,"id":249048,"goal":"predicate Sorted_12361(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_12362","instance":12362,"id":249049,"goal":"predicate AllPositive_12362(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_12363","instance":12363,"id":249050,"goal":"predicate DistinctSeq_12363(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_12364","instance":12364,"id":249051,"goal":"predicate IsSubseq_12364(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_12365","instance":12365,"id":249052,"goal":"predicate IsPermutation_12365(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_12366","instance":12366,"id":249053,"goal":"predicate IsEven_12366(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_12367","instance":12367,"id":249054,"goal":"predicate InRange_12367(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_12368","instance":12368,"id":249055,"goal":"predicate SubsetOf_12368(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_12369","instance":12369,"id":249056,"goal":"predicate AllMem_12369(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_12370","instance":12370,"id":249057,"goal":"predicate DisjointSets_12370(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_12371","instance":12371,"id":249058,"goal":"predicate Sorted_12371(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_12372","instance":12372,"id":249059,"goal":"predicate AllPositive_12372(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_12373","instance":12373,"id":249060,"goal":"predicate DistinctSeq_12373(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_12374","instance":12374,"id":249061,"goal":"predicate IsSubseq_12374(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_12375","instance":12375,"id":249062,"goal":"predicate IsPermutation_12375(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_12376","instance":12376,"id":249063,"goal":"predicate IsEven_12376(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_12377","instance":12377,"id":249064,"goal":"predicate InRange_12377(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_12378","instance":12378,"id":249065,"goal":"predicate SubsetOf_12378(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_12379","instance":12379,"id":249066,"goal":"predicate AllMem_12379(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_12380","instance":12380,"id":249067,"goal":"predicate DisjointSets_12380(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_12381","instance":12381,"id":249068,"goal":"predicate Sorted_12381(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_12382","instance":12382,"id":249069,"goal":"predicate AllPositive_12382(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_12383","instance":12383,"id":249070,"goal":"predicate DistinctSeq_12383(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_12384","instance":12384,"id":249071,"goal":"predicate IsSubseq_12384(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_12385","instance":12385,"id":249072,"goal":"predicate IsPermutation_12385(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_12386","instance":12386,"id":249073,"goal":"predicate IsEven_12386(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_12387","instance":12387,"id":249074,"goal":"predicate InRange_12387(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_12388","instance":12388,"id":249075,"goal":"predicate SubsetOf_12388(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_12389","instance":12389,"id":249076,"goal":"predicate AllMem_12389(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_12390","instance":12390,"id":249077,"goal":"predicate DisjointSets_12390(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_12391","instance":12391,"id":249078,"goal":"predicate Sorted_12391(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_12392","instance":12392,"id":249079,"goal":"predicate AllPositive_12392(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_12393","instance":12393,"id":249080,"goal":"predicate DistinctSeq_12393(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_12394","instance":12394,"id":249081,"goal":"predicate IsSubseq_12394(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_12395","instance":12395,"id":249082,"goal":"predicate IsPermutation_12395(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_12396","instance":12396,"id":249083,"goal":"predicate IsEven_12396(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_12397","instance":12397,"id":249084,"goal":"predicate InRange_12397(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_12398","instance":12398,"id":249085,"goal":"predicate SubsetOf_12398(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_12399","instance":12399,"id":249086,"goal":"predicate AllMem_12399(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_12400","instance":12400,"id":249087,"goal":"predicate DisjointSets_12400(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_12401","instance":12401,"id":249088,"goal":"predicate Sorted_12401(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_12402","instance":12402,"id":249089,"goal":"predicate AllPositive_12402(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_12403","instance":12403,"id":249090,"goal":"predicate DistinctSeq_12403(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_12404","instance":12404,"id":249091,"goal":"predicate IsSubseq_12404(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_12405","instance":12405,"id":249092,"goal":"predicate IsPermutation_12405(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_12406","instance":12406,"id":249093,"goal":"predicate IsEven_12406(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_12407","instance":12407,"id":249094,"goal":"predicate InRange_12407(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_12408","instance":12408,"id":249095,"goal":"predicate SubsetOf_12408(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_12409","instance":12409,"id":249096,"goal":"predicate AllMem_12409(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_12410","instance":12410,"id":249097,"goal":"predicate DisjointSets_12410(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_12411","instance":12411,"id":249098,"goal":"predicate Sorted_12411(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_12412","instance":12412,"id":249099,"goal":"predicate AllPositive_12412(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_12413","instance":12413,"id":249100,"goal":"predicate DistinctSeq_12413(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_12414","instance":12414,"id":249101,"goal":"predicate IsSubseq_12414(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_12415","instance":12415,"id":249102,"goal":"predicate IsPermutation_12415(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_12416","instance":12416,"id":249103,"goal":"predicate IsEven_12416(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_12417","instance":12417,"id":249104,"goal":"predicate InRange_12417(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_12418","instance":12418,"id":249105,"goal":"predicate SubsetOf_12418(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_12419","instance":12419,"id":249106,"goal":"predicate AllMem_12419(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_12420","instance":12420,"id":249107,"goal":"predicate DisjointSets_12420(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_12421","instance":12421,"id":249108,"goal":"predicate Sorted_12421(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_12422","instance":12422,"id":249109,"goal":"predicate AllPositive_12422(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_12423","instance":12423,"id":249110,"goal":"predicate DistinctSeq_12423(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_12424","instance":12424,"id":249111,"goal":"predicate IsSubseq_12424(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_12425","instance":12425,"id":249112,"goal":"predicate IsPermutation_12425(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_12426","instance":12426,"id":249113,"goal":"predicate IsEven_12426(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_12427","instance":12427,"id":249114,"goal":"predicate InRange_12427(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_12428","instance":12428,"id":249115,"goal":"predicate SubsetOf_12428(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_12429","instance":12429,"id":249116,"goal":"predicate AllMem_12429(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_12430","instance":12430,"id":249117,"goal":"predicate DisjointSets_12430(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_12431","instance":12431,"id":249118,"goal":"predicate Sorted_12431(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_12432","instance":12432,"id":249119,"goal":"predicate AllPositive_12432(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_12433","instance":12433,"id":249120,"goal":"predicate DistinctSeq_12433(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_12434","instance":12434,"id":249121,"goal":"predicate IsSubseq_12434(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_12435","instance":12435,"id":249122,"goal":"predicate IsPermutation_12435(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_12436","instance":12436,"id":249123,"goal":"predicate IsEven_12436(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_12437","instance":12437,"id":249124,"goal":"predicate InRange_12437(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_12438","instance":12438,"id":249125,"goal":"predicate SubsetOf_12438(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_12439","instance":12439,"id":249126,"goal":"predicate AllMem_12439(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_12440","instance":12440,"id":249127,"goal":"predicate DisjointSets_12440(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_12441","instance":12441,"id":249128,"goal":"predicate Sorted_12441(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_12442","instance":12442,"id":249129,"goal":"predicate AllPositive_12442(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_12443","instance":12443,"id":249130,"goal":"predicate DistinctSeq_12443(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_12444","instance":12444,"id":249131,"goal":"predicate IsSubseq_12444(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_12445","instance":12445,"id":249132,"goal":"predicate IsPermutation_12445(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_12446","instance":12446,"id":249133,"goal":"predicate IsEven_12446(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_12447","instance":12447,"id":249134,"goal":"predicate InRange_12447(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_12448","instance":12448,"id":249135,"goal":"predicate SubsetOf_12448(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_12449","instance":12449,"id":249136,"goal":"predicate AllMem_12449(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_12450","instance":12450,"id":249137,"goal":"predicate DisjointSets_12450(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_12451","instance":12451,"id":249138,"goal":"predicate Sorted_12451(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_12452","instance":12452,"id":249139,"goal":"predicate AllPositive_12452(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_12453","instance":12453,"id":249140,"goal":"predicate DistinctSeq_12453(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_12454","instance":12454,"id":249141,"goal":"predicate IsSubseq_12454(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_12455","instance":12455,"id":249142,"goal":"predicate IsPermutation_12455(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_12456","instance":12456,"id":249143,"goal":"predicate IsEven_12456(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_12457","instance":12457,"id":249144,"goal":"predicate InRange_12457(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_12458","instance":12458,"id":249145,"goal":"predicate SubsetOf_12458(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_12459","instance":12459,"id":249146,"goal":"predicate AllMem_12459(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_12460","instance":12460,"id":249147,"goal":"predicate DisjointSets_12460(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_12461","instance":12461,"id":249148,"goal":"predicate Sorted_12461(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_12462","instance":12462,"id":249149,"goal":"predicate AllPositive_12462(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_12463","instance":12463,"id":249150,"goal":"predicate DistinctSeq_12463(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_12464","instance":12464,"id":249151,"goal":"predicate IsSubseq_12464(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_12465","instance":12465,"id":249152,"goal":"predicate IsPermutation_12465(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_12466","instance":12466,"id":249153,"goal":"predicate IsEven_12466(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_12467","instance":12467,"id":249154,"goal":"predicate InRange_12467(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_12468","instance":12468,"id":249155,"goal":"predicate SubsetOf_12468(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_12469","instance":12469,"id":249156,"goal":"predicate AllMem_12469(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_12470","instance":12470,"id":249157,"goal":"predicate DisjointSets_12470(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_12471","instance":12471,"id":249158,"goal":"predicate Sorted_12471(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_12472","instance":12472,"id":249159,"goal":"predicate AllPositive_12472(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_12473","instance":12473,"id":249160,"goal":"predicate DistinctSeq_12473(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_12474","instance":12474,"id":249161,"goal":"predicate IsSubseq_12474(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_12475","instance":12475,"id":249162,"goal":"predicate IsPermutation_12475(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_12476","instance":12476,"id":249163,"goal":"predicate IsEven_12476(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_12477","instance":12477,"id":249164,"goal":"predicate InRange_12477(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_12478","instance":12478,"id":249165,"goal":"predicate SubsetOf_12478(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_12479","instance":12479,"id":249166,"goal":"predicate AllMem_12479(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_12480","instance":12480,"id":249167,"goal":"predicate DisjointSets_12480(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_12481","instance":12481,"id":249168,"goal":"predicate Sorted_12481(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_12482","instance":12482,"id":249169,"goal":"predicate AllPositive_12482(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_12483","instance":12483,"id":249170,"goal":"predicate DistinctSeq_12483(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_12484","instance":12484,"id":249171,"goal":"predicate IsSubseq_12484(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_12485","instance":12485,"id":249172,"goal":"predicate IsPermutation_12485(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_12486","instance":12486,"id":249173,"goal":"predicate IsEven_12486(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_12487","instance":12487,"id":249174,"goal":"predicate InRange_12487(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_12488","instance":12488,"id":249175,"goal":"predicate SubsetOf_12488(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_12489","instance":12489,"id":249176,"goal":"predicate AllMem_12489(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_12490","instance":12490,"id":249177,"goal":"predicate DisjointSets_12490(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_12491","instance":12491,"id":249178,"goal":"predicate Sorted_12491(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_12492","instance":12492,"id":249179,"goal":"predicate AllPositive_12492(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_12493","instance":12493,"id":249180,"goal":"predicate DistinctSeq_12493(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_12494","instance":12494,"id":249181,"goal":"predicate IsSubseq_12494(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_12495","instance":12495,"id":249182,"goal":"predicate IsPermutation_12495(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_12496","instance":12496,"id":249183,"goal":"predicate IsEven_12496(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_12497","instance":12497,"id":249184,"goal":"predicate InRange_12497(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_12498","instance":12498,"id":249185,"goal":"predicate SubsetOf_12498(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_12499","instance":12499,"id":249186,"goal":"predicate AllMem_12499(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_12500","instance":12500,"id":249187,"goal":"predicate DisjointSets_12500(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_12501","instance":12501,"id":249188,"goal":"predicate Sorted_12501(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_12502","instance":12502,"id":249189,"goal":"predicate AllPositive_12502(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_12503","instance":12503,"id":249190,"goal":"predicate DistinctSeq_12503(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_12504","instance":12504,"id":249191,"goal":"predicate IsSubseq_12504(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_12505","instance":12505,"id":249192,"goal":"predicate IsPermutation_12505(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_12506","instance":12506,"id":249193,"goal":"predicate IsEven_12506(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_12507","instance":12507,"id":249194,"goal":"predicate InRange_12507(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_12508","instance":12508,"id":249195,"goal":"predicate SubsetOf_12508(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_12509","instance":12509,"id":249196,"goal":"predicate AllMem_12509(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_12510","instance":12510,"id":249197,"goal":"predicate DisjointSets_12510(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_12511","instance":12511,"id":249198,"goal":"predicate Sorted_12511(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_12512","instance":12512,"id":249199,"goal":"predicate AllPositive_12512(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_12513","instance":12513,"id":249200,"goal":"predicate DistinctSeq_12513(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_12514","instance":12514,"id":249201,"goal":"predicate IsSubseq_12514(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_12515","instance":12515,"id":249202,"goal":"predicate IsPermutation_12515(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_12516","instance":12516,"id":249203,"goal":"predicate IsEven_12516(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_12517","instance":12517,"id":249204,"goal":"predicate InRange_12517(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_12518","instance":12518,"id":249205,"goal":"predicate SubsetOf_12518(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_12519","instance":12519,"id":249206,"goal":"predicate AllMem_12519(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_12520","instance":12520,"id":249207,"goal":"predicate DisjointSets_12520(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_12521","instance":12521,"id":249208,"goal":"predicate Sorted_12521(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_12522","instance":12522,"id":249209,"goal":"predicate AllPositive_12522(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_12523","instance":12523,"id":249210,"goal":"predicate DistinctSeq_12523(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_12524","instance":12524,"id":249211,"goal":"predicate IsSubseq_12524(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_12525","instance":12525,"id":249212,"goal":"predicate IsPermutation_12525(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_12526","instance":12526,"id":249213,"goal":"predicate IsEven_12526(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_12527","instance":12527,"id":249214,"goal":"predicate InRange_12527(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_12528","instance":12528,"id":249215,"goal":"predicate SubsetOf_12528(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_12529","instance":12529,"id":249216,"goal":"predicate AllMem_12529(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_12530","instance":12530,"id":249217,"goal":"predicate DisjointSets_12530(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_12531","instance":12531,"id":249218,"goal":"predicate Sorted_12531(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_12532","instance":12532,"id":249219,"goal":"predicate AllPositive_12532(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_12533","instance":12533,"id":249220,"goal":"predicate DistinctSeq_12533(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_12534","instance":12534,"id":249221,"goal":"predicate IsSubseq_12534(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_12535","instance":12535,"id":249222,"goal":"predicate IsPermutation_12535(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_12536","instance":12536,"id":249223,"goal":"predicate IsEven_12536(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_12537","instance":12537,"id":249224,"goal":"predicate InRange_12537(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_12538","instance":12538,"id":249225,"goal":"predicate SubsetOf_12538(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_12539","instance":12539,"id":249226,"goal":"predicate AllMem_12539(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_12540","instance":12540,"id":249227,"goal":"predicate DisjointSets_12540(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_12541","instance":12541,"id":249228,"goal":"predicate Sorted_12541(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_12542","instance":12542,"id":249229,"goal":"predicate AllPositive_12542(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_12543","instance":12543,"id":249230,"goal":"predicate DistinctSeq_12543(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_12544","instance":12544,"id":249231,"goal":"predicate IsSubseq_12544(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_12545","instance":12545,"id":249232,"goal":"predicate IsPermutation_12545(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_12546","instance":12546,"id":249233,"goal":"predicate IsEven_12546(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_12547","instance":12547,"id":249234,"goal":"predicate InRange_12547(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_12548","instance":12548,"id":249235,"goal":"predicate SubsetOf_12548(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_12549","instance":12549,"id":249236,"goal":"predicate AllMem_12549(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_12550","instance":12550,"id":249237,"goal":"predicate DisjointSets_12550(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_12551","instance":12551,"id":249238,"goal":"predicate Sorted_12551(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_12552","instance":12552,"id":249239,"goal":"predicate AllPositive_12552(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_12553","instance":12553,"id":249240,"goal":"predicate DistinctSeq_12553(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_12554","instance":12554,"id":249241,"goal":"predicate IsSubseq_12554(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_12555","instance":12555,"id":249242,"goal":"predicate IsPermutation_12555(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_12556","instance":12556,"id":249243,"goal":"predicate IsEven_12556(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_12557","instance":12557,"id":249244,"goal":"predicate InRange_12557(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_12558","instance":12558,"id":249245,"goal":"predicate SubsetOf_12558(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_12559","instance":12559,"id":249246,"goal":"predicate AllMem_12559(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_12560","instance":12560,"id":249247,"goal":"predicate DisjointSets_12560(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_12561","instance":12561,"id":249248,"goal":"predicate Sorted_12561(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_12562","instance":12562,"id":249249,"goal":"predicate AllPositive_12562(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_12563","instance":12563,"id":249250,"goal":"predicate DistinctSeq_12563(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_12564","instance":12564,"id":249251,"goal":"predicate IsSubseq_12564(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_12565","instance":12565,"id":249252,"goal":"predicate IsPermutation_12565(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_12566","instance":12566,"id":249253,"goal":"predicate IsEven_12566(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_12567","instance":12567,"id":249254,"goal":"predicate InRange_12567(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_12568","instance":12568,"id":249255,"goal":"predicate SubsetOf_12568(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_12569","instance":12569,"id":249256,"goal":"predicate AllMem_12569(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_12570","instance":12570,"id":249257,"goal":"predicate DisjointSets_12570(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_12571","instance":12571,"id":249258,"goal":"predicate Sorted_12571(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_12572","instance":12572,"id":249259,"goal":"predicate AllPositive_12572(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_12573","instance":12573,"id":249260,"goal":"predicate DistinctSeq_12573(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_12574","instance":12574,"id":249261,"goal":"predicate IsSubseq_12574(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_12575","instance":12575,"id":249262,"goal":"predicate IsPermutation_12575(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_12576","instance":12576,"id":249263,"goal":"predicate IsEven_12576(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_12577","instance":12577,"id":249264,"goal":"predicate InRange_12577(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_12578","instance":12578,"id":249265,"goal":"predicate SubsetOf_12578(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_12579","instance":12579,"id":249266,"goal":"predicate AllMem_12579(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_12580","instance":12580,"id":249267,"goal":"predicate DisjointSets_12580(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_12581","instance":12581,"id":249268,"goal":"predicate Sorted_12581(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_12582","instance":12582,"id":249269,"goal":"predicate AllPositive_12582(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_12583","instance":12583,"id":249270,"goal":"predicate DistinctSeq_12583(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_12584","instance":12584,"id":249271,"goal":"predicate IsSubseq_12584(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_12585","instance":12585,"id":249272,"goal":"predicate IsPermutation_12585(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_12586","instance":12586,"id":249273,"goal":"predicate IsEven_12586(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_12587","instance":12587,"id":249274,"goal":"predicate InRange_12587(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_12588","instance":12588,"id":249275,"goal":"predicate SubsetOf_12588(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_12589","instance":12589,"id":249276,"goal":"predicate AllMem_12589(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_12590","instance":12590,"id":249277,"goal":"predicate DisjointSets_12590(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_12591","instance":12591,"id":249278,"goal":"predicate Sorted_12591(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_12592","instance":12592,"id":249279,"goal":"predicate AllPositive_12592(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_12593","instance":12593,"id":249280,"goal":"predicate DistinctSeq_12593(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_12594","instance":12594,"id":249281,"goal":"predicate IsSubseq_12594(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_12595","instance":12595,"id":249282,"goal":"predicate IsPermutation_12595(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_12596","instance":12596,"id":249283,"goal":"predicate IsEven_12596(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_12597","instance":12597,"id":249284,"goal":"predicate InRange_12597(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_12598","instance":12598,"id":249285,"goal":"predicate SubsetOf_12598(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_12599","instance":12599,"id":249286,"goal":"predicate AllMem_12599(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_12600","instance":12600,"id":249287,"goal":"predicate DisjointSets_12600(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_12601","instance":12601,"id":249288,"goal":"predicate Sorted_12601(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_12602","instance":12602,"id":249289,"goal":"predicate AllPositive_12602(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_12603","instance":12603,"id":249290,"goal":"predicate DistinctSeq_12603(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_12604","instance":12604,"id":249291,"goal":"predicate IsSubseq_12604(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_12605","instance":12605,"id":249292,"goal":"predicate IsPermutation_12605(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_12606","instance":12606,"id":249293,"goal":"predicate IsEven_12606(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_12607","instance":12607,"id":249294,"goal":"predicate InRange_12607(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_12608","instance":12608,"id":249295,"goal":"predicate SubsetOf_12608(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_12609","instance":12609,"id":249296,"goal":"predicate AllMem_12609(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_12610","instance":12610,"id":249297,"goal":"predicate DisjointSets_12610(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_12611","instance":12611,"id":249298,"goal":"predicate Sorted_12611(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_12612","instance":12612,"id":249299,"goal":"predicate AllPositive_12612(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_12613","instance":12613,"id":249300,"goal":"predicate DistinctSeq_12613(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_12614","instance":12614,"id":249301,"goal":"predicate IsSubseq_12614(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_12615","instance":12615,"id":249302,"goal":"predicate IsPermutation_12615(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_12616","instance":12616,"id":249303,"goal":"predicate IsEven_12616(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_12617","instance":12617,"id":249304,"goal":"predicate InRange_12617(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_12618","instance":12618,"id":249305,"goal":"predicate SubsetOf_12618(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_12619","instance":12619,"id":249306,"goal":"predicate AllMem_12619(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_12620","instance":12620,"id":249307,"goal":"predicate DisjointSets_12620(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_12621","instance":12621,"id":249308,"goal":"predicate Sorted_12621(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_12622","instance":12622,"id":249309,"goal":"predicate AllPositive_12622(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_12623","instance":12623,"id":249310,"goal":"predicate DistinctSeq_12623(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_12624","instance":12624,"id":249311,"goal":"predicate IsSubseq_12624(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_12625","instance":12625,"id":249312,"goal":"predicate IsPermutation_12625(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_12626","instance":12626,"id":249313,"goal":"predicate IsEven_12626(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_12627","instance":12627,"id":249314,"goal":"predicate InRange_12627(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_12628","instance":12628,"id":249315,"goal":"predicate SubsetOf_12628(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_12629","instance":12629,"id":249316,"goal":"predicate AllMem_12629(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_12630","instance":12630,"id":249317,"goal":"predicate DisjointSets_12630(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_12631","instance":12631,"id":249318,"goal":"predicate Sorted_12631(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_12632","instance":12632,"id":249319,"goal":"predicate AllPositive_12632(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_12633","instance":12633,"id":249320,"goal":"predicate DistinctSeq_12633(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_12634","instance":12634,"id":249321,"goal":"predicate IsSubseq_12634(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_12635","instance":12635,"id":249322,"goal":"predicate IsPermutation_12635(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_12636","instance":12636,"id":249323,"goal":"predicate IsEven_12636(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_12637","instance":12637,"id":249324,"goal":"predicate InRange_12637(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_12638","instance":12638,"id":249325,"goal":"predicate SubsetOf_12638(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_12639","instance":12639,"id":249326,"goal":"predicate AllMem_12639(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_12640","instance":12640,"id":249327,"goal":"predicate DisjointSets_12640(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_12641","instance":12641,"id":249328,"goal":"predicate Sorted_12641(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_12642","instance":12642,"id":249329,"goal":"predicate AllPositive_12642(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_12643","instance":12643,"id":249330,"goal":"predicate DistinctSeq_12643(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_12644","instance":12644,"id":249331,"goal":"predicate IsSubseq_12644(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_12645","instance":12645,"id":249332,"goal":"predicate IsPermutation_12645(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_12646","instance":12646,"id":249333,"goal":"predicate IsEven_12646(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_12647","instance":12647,"id":249334,"goal":"predicate InRange_12647(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_12648","instance":12648,"id":249335,"goal":"predicate SubsetOf_12648(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_12649","instance":12649,"id":249336,"goal":"predicate AllMem_12649(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_12650","instance":12650,"id":249337,"goal":"predicate DisjointSets_12650(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_12651","instance":12651,"id":249338,"goal":"predicate Sorted_12651(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_12652","instance":12652,"id":249339,"goal":"predicate AllPositive_12652(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_12653","instance":12653,"id":249340,"goal":"predicate DistinctSeq_12653(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_12654","instance":12654,"id":249341,"goal":"predicate IsSubseq_12654(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_12655","instance":12655,"id":249342,"goal":"predicate IsPermutation_12655(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_12656","instance":12656,"id":249343,"goal":"predicate IsEven_12656(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_12657","instance":12657,"id":249344,"goal":"predicate InRange_12657(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_12658","instance":12658,"id":249345,"goal":"predicate SubsetOf_12658(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_12659","instance":12659,"id":249346,"goal":"predicate AllMem_12659(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_12660","instance":12660,"id":249347,"goal":"predicate DisjointSets_12660(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_12661","instance":12661,"id":249348,"goal":"predicate Sorted_12661(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_12662","instance":12662,"id":249349,"goal":"predicate AllPositive_12662(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_12663","instance":12663,"id":249350,"goal":"predicate DistinctSeq_12663(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_12664","instance":12664,"id":249351,"goal":"predicate IsSubseq_12664(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_12665","instance":12665,"id":249352,"goal":"predicate IsPermutation_12665(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_12666","instance":12666,"id":249353,"goal":"predicate IsEven_12666(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_12667","instance":12667,"id":249354,"goal":"predicate InRange_12667(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_12668","instance":12668,"id":249355,"goal":"predicate SubsetOf_12668(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_12669","instance":12669,"id":249356,"goal":"predicate AllMem_12669(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_12670","instance":12670,"id":249357,"goal":"predicate DisjointSets_12670(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_12671","instance":12671,"id":249358,"goal":"predicate Sorted_12671(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_12672","instance":12672,"id":249359,"goal":"predicate AllPositive_12672(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_12673","instance":12673,"id":249360,"goal":"predicate DistinctSeq_12673(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_12674","instance":12674,"id":249361,"goal":"predicate IsSubseq_12674(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_12675","instance":12675,"id":249362,"goal":"predicate IsPermutation_12675(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_12676","instance":12676,"id":249363,"goal":"predicate IsEven_12676(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_12677","instance":12677,"id":249364,"goal":"predicate InRange_12677(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_12678","instance":12678,"id":249365,"goal":"predicate SubsetOf_12678(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_12679","instance":12679,"id":249366,"goal":"predicate AllMem_12679(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_12680","instance":12680,"id":249367,"goal":"predicate DisjointSets_12680(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_12681","instance":12681,"id":249368,"goal":"predicate Sorted_12681(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_12682","instance":12682,"id":249369,"goal":"predicate AllPositive_12682(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_12683","instance":12683,"id":249370,"goal":"predicate DistinctSeq_12683(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_12684","instance":12684,"id":249371,"goal":"predicate IsSubseq_12684(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_12685","instance":12685,"id":249372,"goal":"predicate IsPermutation_12685(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_12686","instance":12686,"id":249373,"goal":"predicate IsEven_12686(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_12687","instance":12687,"id":249374,"goal":"predicate InRange_12687(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_12688","instance":12688,"id":249375,"goal":"predicate SubsetOf_12688(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_12689","instance":12689,"id":249376,"goal":"predicate AllMem_12689(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_12690","instance":12690,"id":249377,"goal":"predicate DisjointSets_12690(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_12691","instance":12691,"id":249378,"goal":"predicate Sorted_12691(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_12692","instance":12692,"id":249379,"goal":"predicate AllPositive_12692(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_12693","instance":12693,"id":249380,"goal":"predicate DistinctSeq_12693(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_12694","instance":12694,"id":249381,"goal":"predicate IsSubseq_12694(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_12695","instance":12695,"id":249382,"goal":"predicate IsPermutation_12695(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_12696","instance":12696,"id":249383,"goal":"predicate IsEven_12696(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_12697","instance":12697,"id":249384,"goal":"predicate InRange_12697(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_12698","instance":12698,"id":249385,"goal":"predicate SubsetOf_12698(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_12699","instance":12699,"id":249386,"goal":"predicate AllMem_12699(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_12700","instance":12700,"id":249387,"goal":"predicate DisjointSets_12700(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_12701","instance":12701,"id":249388,"goal":"predicate Sorted_12701(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_12702","instance":12702,"id":249389,"goal":"predicate AllPositive_12702(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_12703","instance":12703,"id":249390,"goal":"predicate DistinctSeq_12703(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_12704","instance":12704,"id":249391,"goal":"predicate IsSubseq_12704(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_12705","instance":12705,"id":249392,"goal":"predicate IsPermutation_12705(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_12706","instance":12706,"id":249393,"goal":"predicate IsEven_12706(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_12707","instance":12707,"id":249394,"goal":"predicate InRange_12707(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_12708","instance":12708,"id":249395,"goal":"predicate SubsetOf_12708(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_12709","instance":12709,"id":249396,"goal":"predicate AllMem_12709(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_12710","instance":12710,"id":249397,"goal":"predicate DisjointSets_12710(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_12711","instance":12711,"id":249398,"goal":"predicate Sorted_12711(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_12712","instance":12712,"id":249399,"goal":"predicate AllPositive_12712(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_12713","instance":12713,"id":249400,"goal":"predicate DistinctSeq_12713(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_12714","instance":12714,"id":249401,"goal":"predicate IsSubseq_12714(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_12715","instance":12715,"id":249402,"goal":"predicate IsPermutation_12715(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_12716","instance":12716,"id":249403,"goal":"predicate IsEven_12716(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_12717","instance":12717,"id":249404,"goal":"predicate InRange_12717(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_12718","instance":12718,"id":249405,"goal":"predicate SubsetOf_12718(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_12719","instance":12719,"id":249406,"goal":"predicate AllMem_12719(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_12720","instance":12720,"id":249407,"goal":"predicate DisjointSets_12720(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_12721","instance":12721,"id":249408,"goal":"predicate Sorted_12721(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_12722","instance":12722,"id":249409,"goal":"predicate AllPositive_12722(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_12723","instance":12723,"id":249410,"goal":"predicate DistinctSeq_12723(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_12724","instance":12724,"id":249411,"goal":"predicate IsSubseq_12724(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_12725","instance":12725,"id":249412,"goal":"predicate IsPermutation_12725(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_12726","instance":12726,"id":249413,"goal":"predicate IsEven_12726(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_12727","instance":12727,"id":249414,"goal":"predicate InRange_12727(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_12728","instance":12728,"id":249415,"goal":"predicate SubsetOf_12728(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_12729","instance":12729,"id":249416,"goal":"predicate AllMem_12729(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_12730","instance":12730,"id":249417,"goal":"predicate DisjointSets_12730(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_12731","instance":12731,"id":249418,"goal":"predicate Sorted_12731(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_12732","instance":12732,"id":249419,"goal":"predicate AllPositive_12732(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_12733","instance":12733,"id":249420,"goal":"predicate DistinctSeq_12733(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_12734","instance":12734,"id":249421,"goal":"predicate IsSubseq_12734(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_12735","instance":12735,"id":249422,"goal":"predicate IsPermutation_12735(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_12736","instance":12736,"id":249423,"goal":"predicate IsEven_12736(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_12737","instance":12737,"id":249424,"goal":"predicate InRange_12737(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_12738","instance":12738,"id":249425,"goal":"predicate SubsetOf_12738(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_12739","instance":12739,"id":249426,"goal":"predicate AllMem_12739(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_12740","instance":12740,"id":249427,"goal":"predicate DisjointSets_12740(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_12741","instance":12741,"id":249428,"goal":"predicate Sorted_12741(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_12742","instance":12742,"id":249429,"goal":"predicate AllPositive_12742(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_12743","instance":12743,"id":249430,"goal":"predicate DistinctSeq_12743(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_12744","instance":12744,"id":249431,"goal":"predicate IsSubseq_12744(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_12745","instance":12745,"id":249432,"goal":"predicate IsPermutation_12745(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_12746","instance":12746,"id":249433,"goal":"predicate IsEven_12746(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_12747","instance":12747,"id":249434,"goal":"predicate InRange_12747(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_12748","instance":12748,"id":249435,"goal":"predicate SubsetOf_12748(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_12749","instance":12749,"id":249436,"goal":"predicate AllMem_12749(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_12750","instance":12750,"id":249437,"goal":"predicate DisjointSets_12750(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_12751","instance":12751,"id":249438,"goal":"predicate Sorted_12751(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_12752","instance":12752,"id":249439,"goal":"predicate AllPositive_12752(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_12753","instance":12753,"id":249440,"goal":"predicate DistinctSeq_12753(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_12754","instance":12754,"id":249441,"goal":"predicate IsSubseq_12754(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_12755","instance":12755,"id":249442,"goal":"predicate IsPermutation_12755(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_12756","instance":12756,"id":249443,"goal":"predicate IsEven_12756(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_12757","instance":12757,"id":249444,"goal":"predicate InRange_12757(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_12758","instance":12758,"id":249445,"goal":"predicate SubsetOf_12758(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_12759","instance":12759,"id":249446,"goal":"predicate AllMem_12759(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_12760","instance":12760,"id":249447,"goal":"predicate DisjointSets_12760(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_12761","instance":12761,"id":249448,"goal":"predicate Sorted_12761(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_12762","instance":12762,"id":249449,"goal":"predicate AllPositive_12762(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_12763","instance":12763,"id":249450,"goal":"predicate DistinctSeq_12763(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_12764","instance":12764,"id":249451,"goal":"predicate IsSubseq_12764(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_12765","instance":12765,"id":249452,"goal":"predicate IsPermutation_12765(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_12766","instance":12766,"id":249453,"goal":"predicate IsEven_12766(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_12767","instance":12767,"id":249454,"goal":"predicate InRange_12767(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_12768","instance":12768,"id":249455,"goal":"predicate SubsetOf_12768(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_12769","instance":12769,"id":249456,"goal":"predicate AllMem_12769(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_12770","instance":12770,"id":249457,"goal":"predicate DisjointSets_12770(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_12771","instance":12771,"id":249458,"goal":"predicate Sorted_12771(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_12772","instance":12772,"id":249459,"goal":"predicate AllPositive_12772(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_12773","instance":12773,"id":249460,"goal":"predicate DistinctSeq_12773(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_12774","instance":12774,"id":249461,"goal":"predicate IsSubseq_12774(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_12775","instance":12775,"id":249462,"goal":"predicate IsPermutation_12775(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_12776","instance":12776,"id":249463,"goal":"predicate IsEven_12776(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_12777","instance":12777,"id":249464,"goal":"predicate InRange_12777(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_12778","instance":12778,"id":249465,"goal":"predicate SubsetOf_12778(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_12779","instance":12779,"id":249466,"goal":"predicate AllMem_12779(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_12780","instance":12780,"id":249467,"goal":"predicate DisjointSets_12780(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_12781","instance":12781,"id":249468,"goal":"predicate Sorted_12781(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_12782","instance":12782,"id":249469,"goal":"predicate AllPositive_12782(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_12783","instance":12783,"id":249470,"goal":"predicate DistinctSeq_12783(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_12784","instance":12784,"id":249471,"goal":"predicate IsSubseq_12784(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_12785","instance":12785,"id":249472,"goal":"predicate IsPermutation_12785(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_12786","instance":12786,"id":249473,"goal":"predicate IsEven_12786(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_12787","instance":12787,"id":249474,"goal":"predicate InRange_12787(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_12788","instance":12788,"id":249475,"goal":"predicate SubsetOf_12788(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_12789","instance":12789,"id":249476,"goal":"predicate AllMem_12789(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_12790","instance":12790,"id":249477,"goal":"predicate DisjointSets_12790(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_12791","instance":12791,"id":249478,"goal":"predicate Sorted_12791(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_12792","instance":12792,"id":249479,"goal":"predicate AllPositive_12792(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_12793","instance":12793,"id":249480,"goal":"predicate DistinctSeq_12793(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_12794","instance":12794,"id":249481,"goal":"predicate IsSubseq_12794(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_12795","instance":12795,"id":249482,"goal":"predicate IsPermutation_12795(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_12796","instance":12796,"id":249483,"goal":"predicate IsEven_12796(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_12797","instance":12797,"id":249484,"goal":"predicate InRange_12797(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_12798","instance":12798,"id":249485,"goal":"predicate SubsetOf_12798(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_12799","instance":12799,"id":249486,"goal":"predicate AllMem_12799(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_12800","instance":12800,"id":249487,"goal":"predicate DisjointSets_12800(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_12801","instance":12801,"id":249488,"goal":"predicate Sorted_12801(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_12802","instance":12802,"id":249489,"goal":"predicate AllPositive_12802(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_12803","instance":12803,"id":249490,"goal":"predicate DistinctSeq_12803(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_12804","instance":12804,"id":249491,"goal":"predicate IsSubseq_12804(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_12805","instance":12805,"id":249492,"goal":"predicate IsPermutation_12805(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_12806","instance":12806,"id":249493,"goal":"predicate IsEven_12806(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_12807","instance":12807,"id":249494,"goal":"predicate InRange_12807(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_12808","instance":12808,"id":249495,"goal":"predicate SubsetOf_12808(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_12809","instance":12809,"id":249496,"goal":"predicate AllMem_12809(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_12810","instance":12810,"id":249497,"goal":"predicate DisjointSets_12810(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_12811","instance":12811,"id":249498,"goal":"predicate Sorted_12811(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_12812","instance":12812,"id":249499,"goal":"predicate AllPositive_12812(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_12813","instance":12813,"id":249500,"goal":"predicate DistinctSeq_12813(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_12814","instance":12814,"id":249501,"goal":"predicate IsSubseq_12814(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_12815","instance":12815,"id":249502,"goal":"predicate IsPermutation_12815(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_12816","instance":12816,"id":249503,"goal":"predicate IsEven_12816(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_12817","instance":12817,"id":249504,"goal":"predicate InRange_12817(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_12818","instance":12818,"id":249505,"goal":"predicate SubsetOf_12818(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_12819","instance":12819,"id":249506,"goal":"predicate AllMem_12819(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_12820","instance":12820,"id":249507,"goal":"predicate DisjointSets_12820(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_12821","instance":12821,"id":249508,"goal":"predicate Sorted_12821(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_12822","instance":12822,"id":249509,"goal":"predicate AllPositive_12822(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_12823","instance":12823,"id":249510,"goal":"predicate DistinctSeq_12823(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_12824","instance":12824,"id":249511,"goal":"predicate IsSubseq_12824(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_12825","instance":12825,"id":249512,"goal":"predicate IsPermutation_12825(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_12826","instance":12826,"id":249513,"goal":"predicate IsEven_12826(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_12827","instance":12827,"id":249514,"goal":"predicate InRange_12827(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_12828","instance":12828,"id":249515,"goal":"predicate SubsetOf_12828(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_12829","instance":12829,"id":249516,"goal":"predicate AllMem_12829(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_12830","instance":12830,"id":249517,"goal":"predicate DisjointSets_12830(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_12831","instance":12831,"id":249518,"goal":"predicate Sorted_12831(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_12832","instance":12832,"id":249519,"goal":"predicate AllPositive_12832(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_12833","instance":12833,"id":249520,"goal":"predicate DistinctSeq_12833(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_12834","instance":12834,"id":249521,"goal":"predicate IsSubseq_12834(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_12835","instance":12835,"id":249522,"goal":"predicate IsPermutation_12835(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_12836","instance":12836,"id":249523,"goal":"predicate IsEven_12836(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_12837","instance":12837,"id":249524,"goal":"predicate InRange_12837(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_12838","instance":12838,"id":249525,"goal":"predicate SubsetOf_12838(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_12839","instance":12839,"id":249526,"goal":"predicate AllMem_12839(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_12840","instance":12840,"id":249527,"goal":"predicate DisjointSets_12840(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_12841","instance":12841,"id":249528,"goal":"predicate Sorted_12841(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_12842","instance":12842,"id":249529,"goal":"predicate AllPositive_12842(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_12843","instance":12843,"id":249530,"goal":"predicate DistinctSeq_12843(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_12844","instance":12844,"id":249531,"goal":"predicate IsSubseq_12844(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_12845","instance":12845,"id":249532,"goal":"predicate IsPermutation_12845(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_12846","instance":12846,"id":249533,"goal":"predicate IsEven_12846(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_12847","instance":12847,"id":249534,"goal":"predicate InRange_12847(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_12848","instance":12848,"id":249535,"goal":"predicate SubsetOf_12848(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_12849","instance":12849,"id":249536,"goal":"predicate AllMem_12849(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_12850","instance":12850,"id":249537,"goal":"predicate DisjointSets_12850(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_12851","instance":12851,"id":249538,"goal":"predicate Sorted_12851(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_12852","instance":12852,"id":249539,"goal":"predicate AllPositive_12852(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_12853","instance":12853,"id":249540,"goal":"predicate DistinctSeq_12853(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_12854","instance":12854,"id":249541,"goal":"predicate IsSubseq_12854(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_12855","instance":12855,"id":249542,"goal":"predicate IsPermutation_12855(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_12856","instance":12856,"id":249543,"goal":"predicate IsEven_12856(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_12857","instance":12857,"id":249544,"goal":"predicate InRange_12857(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_12858","instance":12858,"id":249545,"goal":"predicate SubsetOf_12858(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_12859","instance":12859,"id":249546,"goal":"predicate AllMem_12859(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_12860","instance":12860,"id":249547,"goal":"predicate DisjointSets_12860(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_12861","instance":12861,"id":249548,"goal":"predicate Sorted_12861(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_12862","instance":12862,"id":249549,"goal":"predicate AllPositive_12862(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_12863","instance":12863,"id":249550,"goal":"predicate DistinctSeq_12863(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_12864","instance":12864,"id":249551,"goal":"predicate IsSubseq_12864(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_12865","instance":12865,"id":249552,"goal":"predicate IsPermutation_12865(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_12866","instance":12866,"id":249553,"goal":"predicate IsEven_12866(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_12867","instance":12867,"id":249554,"goal":"predicate InRange_12867(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_12868","instance":12868,"id":249555,"goal":"predicate SubsetOf_12868(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_12869","instance":12869,"id":249556,"goal":"predicate AllMem_12869(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_12870","instance":12870,"id":249557,"goal":"predicate DisjointSets_12870(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_12871","instance":12871,"id":249558,"goal":"predicate Sorted_12871(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_12872","instance":12872,"id":249559,"goal":"predicate AllPositive_12872(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_12873","instance":12873,"id":249560,"goal":"predicate DistinctSeq_12873(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_12874","instance":12874,"id":249561,"goal":"predicate IsSubseq_12874(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_12875","instance":12875,"id":249562,"goal":"predicate IsPermutation_12875(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_12876","instance":12876,"id":249563,"goal":"predicate IsEven_12876(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_12877","instance":12877,"id":249564,"goal":"predicate InRange_12877(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_12878","instance":12878,"id":249565,"goal":"predicate SubsetOf_12878(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_12879","instance":12879,"id":249566,"goal":"predicate AllMem_12879(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_12880","instance":12880,"id":249567,"goal":"predicate DisjointSets_12880(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_12881","instance":12881,"id":249568,"goal":"predicate Sorted_12881(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_12882","instance":12882,"id":249569,"goal":"predicate AllPositive_12882(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_12883","instance":12883,"id":249570,"goal":"predicate DistinctSeq_12883(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_12884","instance":12884,"id":249571,"goal":"predicate IsSubseq_12884(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_12885","instance":12885,"id":249572,"goal":"predicate IsPermutation_12885(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_12886","instance":12886,"id":249573,"goal":"predicate IsEven_12886(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_12887","instance":12887,"id":249574,"goal":"predicate InRange_12887(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_12888","instance":12888,"id":249575,"goal":"predicate SubsetOf_12888(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_12889","instance":12889,"id":249576,"goal":"predicate AllMem_12889(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_12890","instance":12890,"id":249577,"goal":"predicate DisjointSets_12890(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_12891","instance":12891,"id":249578,"goal":"predicate Sorted_12891(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_12892","instance":12892,"id":249579,"goal":"predicate AllPositive_12892(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_12893","instance":12893,"id":249580,"goal":"predicate DistinctSeq_12893(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_12894","instance":12894,"id":249581,"goal":"predicate IsSubseq_12894(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_12895","instance":12895,"id":249582,"goal":"predicate IsPermutation_12895(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_12896","instance":12896,"id":249583,"goal":"predicate IsEven_12896(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_12897","instance":12897,"id":249584,"goal":"predicate InRange_12897(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_12898","instance":12898,"id":249585,"goal":"predicate SubsetOf_12898(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_12899","instance":12899,"id":249586,"goal":"predicate AllMem_12899(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_12900","instance":12900,"id":249587,"goal":"predicate DisjointSets_12900(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_12901","instance":12901,"id":249588,"goal":"predicate Sorted_12901(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_12902","instance":12902,"id":249589,"goal":"predicate AllPositive_12902(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_12903","instance":12903,"id":249590,"goal":"predicate DistinctSeq_12903(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_12904","instance":12904,"id":249591,"goal":"predicate IsSubseq_12904(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_12905","instance":12905,"id":249592,"goal":"predicate IsPermutation_12905(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_12906","instance":12906,"id":249593,"goal":"predicate IsEven_12906(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_12907","instance":12907,"id":249594,"goal":"predicate InRange_12907(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_12908","instance":12908,"id":249595,"goal":"predicate SubsetOf_12908(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_12909","instance":12909,"id":249596,"goal":"predicate AllMem_12909(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_12910","instance":12910,"id":249597,"goal":"predicate DisjointSets_12910(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_12911","instance":12911,"id":249598,"goal":"predicate Sorted_12911(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_12912","instance":12912,"id":249599,"goal":"predicate AllPositive_12912(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_12913","instance":12913,"id":249600,"goal":"predicate DistinctSeq_12913(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_12914","instance":12914,"id":249601,"goal":"predicate IsSubseq_12914(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_12915","instance":12915,"id":249602,"goal":"predicate IsPermutation_12915(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_12916","instance":12916,"id":249603,"goal":"predicate IsEven_12916(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_12917","instance":12917,"id":249604,"goal":"predicate InRange_12917(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_12918","instance":12918,"id":249605,"goal":"predicate SubsetOf_12918(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_12919","instance":12919,"id":249606,"goal":"predicate AllMem_12919(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_12920","instance":12920,"id":249607,"goal":"predicate DisjointSets_12920(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_12921","instance":12921,"id":249608,"goal":"predicate Sorted_12921(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_12922","instance":12922,"id":249609,"goal":"predicate AllPositive_12922(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_12923","instance":12923,"id":249610,"goal":"predicate DistinctSeq_12923(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_12924","instance":12924,"id":249611,"goal":"predicate IsSubseq_12924(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_12925","instance":12925,"id":249612,"goal":"predicate IsPermutation_12925(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_12926","instance":12926,"id":249613,"goal":"predicate IsEven_12926(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_12927","instance":12927,"id":249614,"goal":"predicate InRange_12927(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_12928","instance":12928,"id":249615,"goal":"predicate SubsetOf_12928(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_12929","instance":12929,"id":249616,"goal":"predicate AllMem_12929(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_12930","instance":12930,"id":249617,"goal":"predicate DisjointSets_12930(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_12931","instance":12931,"id":249618,"goal":"predicate Sorted_12931(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_12932","instance":12932,"id":249619,"goal":"predicate AllPositive_12932(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_12933","instance":12933,"id":249620,"goal":"predicate DistinctSeq_12933(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_12934","instance":12934,"id":249621,"goal":"predicate IsSubseq_12934(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_12935","instance":12935,"id":249622,"goal":"predicate IsPermutation_12935(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_12936","instance":12936,"id":249623,"goal":"predicate IsEven_12936(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_12937","instance":12937,"id":249624,"goal":"predicate InRange_12937(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_12938","instance":12938,"id":249625,"goal":"predicate SubsetOf_12938(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_12939","instance":12939,"id":249626,"goal":"predicate AllMem_12939(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_12940","instance":12940,"id":249627,"goal":"predicate DisjointSets_12940(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_12941","instance":12941,"id":249628,"goal":"predicate Sorted_12941(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_12942","instance":12942,"id":249629,"goal":"predicate AllPositive_12942(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_12943","instance":12943,"id":249630,"goal":"predicate DistinctSeq_12943(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_12944","instance":12944,"id":249631,"goal":"predicate IsSubseq_12944(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_12945","instance":12945,"id":249632,"goal":"predicate IsPermutation_12945(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_12946","instance":12946,"id":249633,"goal":"predicate IsEven_12946(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_12947","instance":12947,"id":249634,"goal":"predicate InRange_12947(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_12948","instance":12948,"id":249635,"goal":"predicate SubsetOf_12948(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_12949","instance":12949,"id":249636,"goal":"predicate AllMem_12949(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_12950","instance":12950,"id":249637,"goal":"predicate DisjointSets_12950(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_12951","instance":12951,"id":249638,"goal":"predicate Sorted_12951(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_12952","instance":12952,"id":249639,"goal":"predicate AllPositive_12952(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_12953","instance":12953,"id":249640,"goal":"predicate DistinctSeq_12953(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_12954","instance":12954,"id":249641,"goal":"predicate IsSubseq_12954(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_12955","instance":12955,"id":249642,"goal":"predicate IsPermutation_12955(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_12956","instance":12956,"id":249643,"goal":"predicate IsEven_12956(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_12957","instance":12957,"id":249644,"goal":"predicate InRange_12957(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_12958","instance":12958,"id":249645,"goal":"predicate SubsetOf_12958(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_12959","instance":12959,"id":249646,"goal":"predicate AllMem_12959(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_12960","instance":12960,"id":249647,"goal":"predicate DisjointSets_12960(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_12961","instance":12961,"id":249648,"goal":"predicate Sorted_12961(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_12962","instance":12962,"id":249649,"goal":"predicate AllPositive_12962(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_12963","instance":12963,"id":249650,"goal":"predicate DistinctSeq_12963(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_12964","instance":12964,"id":249651,"goal":"predicate IsSubseq_12964(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_12965","instance":12965,"id":249652,"goal":"predicate IsPermutation_12965(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_12966","instance":12966,"id":249653,"goal":"predicate IsEven_12966(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_12967","instance":12967,"id":249654,"goal":"predicate InRange_12967(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_12968","instance":12968,"id":249655,"goal":"predicate SubsetOf_12968(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_12969","instance":12969,"id":249656,"goal":"predicate AllMem_12969(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_12970","instance":12970,"id":249657,"goal":"predicate DisjointSets_12970(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_12971","instance":12971,"id":249658,"goal":"predicate Sorted_12971(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_12972","instance":12972,"id":249659,"goal":"predicate AllPositive_12972(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_12973","instance":12973,"id":249660,"goal":"predicate DistinctSeq_12973(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_12974","instance":12974,"id":249661,"goal":"predicate IsSubseq_12974(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_12975","instance":12975,"id":249662,"goal":"predicate IsPermutation_12975(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_12976","instance":12976,"id":249663,"goal":"predicate IsEven_12976(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_12977","instance":12977,"id":249664,"goal":"predicate InRange_12977(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_12978","instance":12978,"id":249665,"goal":"predicate SubsetOf_12978(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_12979","instance":12979,"id":249666,"goal":"predicate AllMem_12979(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_12980","instance":12980,"id":249667,"goal":"predicate DisjointSets_12980(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_12981","instance":12981,"id":249668,"goal":"predicate Sorted_12981(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_12982","instance":12982,"id":249669,"goal":"predicate AllPositive_12982(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_12983","instance":12983,"id":249670,"goal":"predicate DistinctSeq_12983(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_12984","instance":12984,"id":249671,"goal":"predicate IsSubseq_12984(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_12985","instance":12985,"id":249672,"goal":"predicate IsPermutation_12985(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_12986","instance":12986,"id":249673,"goal":"predicate IsEven_12986(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_12987","instance":12987,"id":249674,"goal":"predicate InRange_12987(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_12988","instance":12988,"id":249675,"goal":"predicate SubsetOf_12988(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_12989","instance":12989,"id":249676,"goal":"predicate AllMem_12989(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_12990","instance":12990,"id":249677,"goal":"predicate DisjointSets_12990(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_12991","instance":12991,"id":249678,"goal":"predicate Sorted_12991(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_12992","instance":12992,"id":249679,"goal":"predicate AllPositive_12992(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_12993","instance":12993,"id":249680,"goal":"predicate DistinctSeq_12993(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_12994","instance":12994,"id":249681,"goal":"predicate IsSubseq_12994(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_12995","instance":12995,"id":249682,"goal":"predicate IsPermutation_12995(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_12996","instance":12996,"id":249683,"goal":"predicate IsEven_12996(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_12997","instance":12997,"id":249684,"goal":"predicate InRange_12997(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_12998","instance":12998,"id":249685,"goal":"predicate SubsetOf_12998(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_12999","instance":12999,"id":249686,"goal":"predicate AllMem_12999(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_13000","instance":13000,"id":249687,"goal":"predicate DisjointSets_13000(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_13001","instance":13001,"id":249688,"goal":"predicate Sorted_13001(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_13002","instance":13002,"id":249689,"goal":"predicate AllPositive_13002(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_13003","instance":13003,"id":249690,"goal":"predicate DistinctSeq_13003(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_13004","instance":13004,"id":249691,"goal":"predicate IsSubseq_13004(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_13005","instance":13005,"id":249692,"goal":"predicate IsPermutation_13005(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_13006","instance":13006,"id":249693,"goal":"predicate IsEven_13006(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_13007","instance":13007,"id":249694,"goal":"predicate InRange_13007(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_13008","instance":13008,"id":249695,"goal":"predicate SubsetOf_13008(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_13009","instance":13009,"id":249696,"goal":"predicate AllMem_13009(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_13010","instance":13010,"id":249697,"goal":"predicate DisjointSets_13010(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_13011","instance":13011,"id":249698,"goal":"predicate Sorted_13011(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_13012","instance":13012,"id":249699,"goal":"predicate AllPositive_13012(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_13013","instance":13013,"id":249700,"goal":"predicate DistinctSeq_13013(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_13014","instance":13014,"id":249701,"goal":"predicate IsSubseq_13014(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_13015","instance":13015,"id":249702,"goal":"predicate IsPermutation_13015(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_13016","instance":13016,"id":249703,"goal":"predicate IsEven_13016(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_13017","instance":13017,"id":249704,"goal":"predicate InRange_13017(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_13018","instance":13018,"id":249705,"goal":"predicate SubsetOf_13018(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_13019","instance":13019,"id":249706,"goal":"predicate AllMem_13019(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_13020","instance":13020,"id":249707,"goal":"predicate DisjointSets_13020(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_13021","instance":13021,"id":249708,"goal":"predicate Sorted_13021(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_13022","instance":13022,"id":249709,"goal":"predicate AllPositive_13022(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_13023","instance":13023,"id":249710,"goal":"predicate DistinctSeq_13023(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_13024","instance":13024,"id":249711,"goal":"predicate IsSubseq_13024(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_13025","instance":13025,"id":249712,"goal":"predicate IsPermutation_13025(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_13026","instance":13026,"id":249713,"goal":"predicate IsEven_13026(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_13027","instance":13027,"id":249714,"goal":"predicate InRange_13027(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_13028","instance":13028,"id":249715,"goal":"predicate SubsetOf_13028(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_13029","instance":13029,"id":249716,"goal":"predicate AllMem_13029(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_13030","instance":13030,"id":249717,"goal":"predicate DisjointSets_13030(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_13031","instance":13031,"id":249718,"goal":"predicate Sorted_13031(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_13032","instance":13032,"id":249719,"goal":"predicate AllPositive_13032(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_13033","instance":13033,"id":249720,"goal":"predicate DistinctSeq_13033(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_13034","instance":13034,"id":249721,"goal":"predicate IsSubseq_13034(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_13035","instance":13035,"id":249722,"goal":"predicate IsPermutation_13035(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_13036","instance":13036,"id":249723,"goal":"predicate IsEven_13036(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_13037","instance":13037,"id":249724,"goal":"predicate InRange_13037(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_13038","instance":13038,"id":249725,"goal":"predicate SubsetOf_13038(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_13039","instance":13039,"id":249726,"goal":"predicate AllMem_13039(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_13040","instance":13040,"id":249727,"goal":"predicate DisjointSets_13040(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_13041","instance":13041,"id":249728,"goal":"predicate Sorted_13041(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_13042","instance":13042,"id":249729,"goal":"predicate AllPositive_13042(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_13043","instance":13043,"id":249730,"goal":"predicate DistinctSeq_13043(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_13044","instance":13044,"id":249731,"goal":"predicate IsSubseq_13044(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_13045","instance":13045,"id":249732,"goal":"predicate IsPermutation_13045(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_13046","instance":13046,"id":249733,"goal":"predicate IsEven_13046(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_13047","instance":13047,"id":249734,"goal":"predicate InRange_13047(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_13048","instance":13048,"id":249735,"goal":"predicate SubsetOf_13048(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_13049","instance":13049,"id":249736,"goal":"predicate AllMem_13049(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_13050","instance":13050,"id":249737,"goal":"predicate DisjointSets_13050(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_13051","instance":13051,"id":249738,"goal":"predicate Sorted_13051(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_13052","instance":13052,"id":249739,"goal":"predicate AllPositive_13052(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_13053","instance":13053,"id":249740,"goal":"predicate DistinctSeq_13053(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_13054","instance":13054,"id":249741,"goal":"predicate IsSubseq_13054(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_13055","instance":13055,"id":249742,"goal":"predicate IsPermutation_13055(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_13056","instance":13056,"id":249743,"goal":"predicate IsEven_13056(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_13057","instance":13057,"id":249744,"goal":"predicate InRange_13057(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_13058","instance":13058,"id":249745,"goal":"predicate SubsetOf_13058(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_13059","instance":13059,"id":249746,"goal":"predicate AllMem_13059(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_13060","instance":13060,"id":249747,"goal":"predicate DisjointSets_13060(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_13061","instance":13061,"id":249748,"goal":"predicate Sorted_13061(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_13062","instance":13062,"id":249749,"goal":"predicate AllPositive_13062(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_13063","instance":13063,"id":249750,"goal":"predicate DistinctSeq_13063(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_13064","instance":13064,"id":249751,"goal":"predicate IsSubseq_13064(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_13065","instance":13065,"id":249752,"goal":"predicate IsPermutation_13065(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_13066","instance":13066,"id":249753,"goal":"predicate IsEven_13066(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_13067","instance":13067,"id":249754,"goal":"predicate InRange_13067(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_13068","instance":13068,"id":249755,"goal":"predicate SubsetOf_13068(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_13069","instance":13069,"id":249756,"goal":"predicate AllMem_13069(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_13070","instance":13070,"id":249757,"goal":"predicate DisjointSets_13070(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_13071","instance":13071,"id":249758,"goal":"predicate Sorted_13071(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_13072","instance":13072,"id":249759,"goal":"predicate AllPositive_13072(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_13073","instance":13073,"id":249760,"goal":"predicate DistinctSeq_13073(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_13074","instance":13074,"id":249761,"goal":"predicate IsSubseq_13074(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_13075","instance":13075,"id":249762,"goal":"predicate IsPermutation_13075(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_13076","instance":13076,"id":249763,"goal":"predicate IsEven_13076(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_13077","instance":13077,"id":249764,"goal":"predicate InRange_13077(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_13078","instance":13078,"id":249765,"goal":"predicate SubsetOf_13078(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_13079","instance":13079,"id":249766,"goal":"predicate AllMem_13079(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_13080","instance":13080,"id":249767,"goal":"predicate DisjointSets_13080(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_13081","instance":13081,"id":249768,"goal":"predicate Sorted_13081(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_13082","instance":13082,"id":249769,"goal":"predicate AllPositive_13082(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_13083","instance":13083,"id":249770,"goal":"predicate DistinctSeq_13083(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_13084","instance":13084,"id":249771,"goal":"predicate IsSubseq_13084(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_13085","instance":13085,"id":249772,"goal":"predicate IsPermutation_13085(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_13086","instance":13086,"id":249773,"goal":"predicate IsEven_13086(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_13087","instance":13087,"id":249774,"goal":"predicate InRange_13087(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_13088","instance":13088,"id":249775,"goal":"predicate SubsetOf_13088(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_13089","instance":13089,"id":249776,"goal":"predicate AllMem_13089(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_13090","instance":13090,"id":249777,"goal":"predicate DisjointSets_13090(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_13091","instance":13091,"id":249778,"goal":"predicate Sorted_13091(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_13092","instance":13092,"id":249779,"goal":"predicate AllPositive_13092(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_13093","instance":13093,"id":249780,"goal":"predicate DistinctSeq_13093(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_13094","instance":13094,"id":249781,"goal":"predicate IsSubseq_13094(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_13095","instance":13095,"id":249782,"goal":"predicate IsPermutation_13095(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_13096","instance":13096,"id":249783,"goal":"predicate IsEven_13096(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_13097","instance":13097,"id":249784,"goal":"predicate InRange_13097(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_13098","instance":13098,"id":249785,"goal":"predicate SubsetOf_13098(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_13099","instance":13099,"id":249786,"goal":"predicate AllMem_13099(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_13100","instance":13100,"id":249787,"goal":"predicate DisjointSets_13100(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_13101","instance":13101,"id":249788,"goal":"predicate Sorted_13101(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_13102","instance":13102,"id":249789,"goal":"predicate AllPositive_13102(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_13103","instance":13103,"id":249790,"goal":"predicate DistinctSeq_13103(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_13104","instance":13104,"id":249791,"goal":"predicate IsSubseq_13104(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_13105","instance":13105,"id":249792,"goal":"predicate IsPermutation_13105(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_13106","instance":13106,"id":249793,"goal":"predicate IsEven_13106(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_13107","instance":13107,"id":249794,"goal":"predicate InRange_13107(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_13108","instance":13108,"id":249795,"goal":"predicate SubsetOf_13108(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_13109","instance":13109,"id":249796,"goal":"predicate AllMem_13109(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_13110","instance":13110,"id":249797,"goal":"predicate DisjointSets_13110(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_13111","instance":13111,"id":249798,"goal":"predicate Sorted_13111(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_13112","instance":13112,"id":249799,"goal":"predicate AllPositive_13112(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_13113","instance":13113,"id":249800,"goal":"predicate DistinctSeq_13113(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_13114","instance":13114,"id":249801,"goal":"predicate IsSubseq_13114(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_13115","instance":13115,"id":249802,"goal":"predicate IsPermutation_13115(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_13116","instance":13116,"id":249803,"goal":"predicate IsEven_13116(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_13117","instance":13117,"id":249804,"goal":"predicate InRange_13117(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_13118","instance":13118,"id":249805,"goal":"predicate SubsetOf_13118(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_13119","instance":13119,"id":249806,"goal":"predicate AllMem_13119(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_13120","instance":13120,"id":249807,"goal":"predicate DisjointSets_13120(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_13121","instance":13121,"id":249808,"goal":"predicate Sorted_13121(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_13122","instance":13122,"id":249809,"goal":"predicate AllPositive_13122(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_13123","instance":13123,"id":249810,"goal":"predicate DistinctSeq_13123(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_13124","instance":13124,"id":249811,"goal":"predicate IsSubseq_13124(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_13125","instance":13125,"id":249812,"goal":"predicate IsPermutation_13125(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_13126","instance":13126,"id":249813,"goal":"predicate IsEven_13126(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_13127","instance":13127,"id":249814,"goal":"predicate InRange_13127(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_13128","instance":13128,"id":249815,"goal":"predicate SubsetOf_13128(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_13129","instance":13129,"id":249816,"goal":"predicate AllMem_13129(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_13130","instance":13130,"id":249817,"goal":"predicate DisjointSets_13130(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_13131","instance":13131,"id":249818,"goal":"predicate Sorted_13131(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_13132","instance":13132,"id":249819,"goal":"predicate AllPositive_13132(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_13133","instance":13133,"id":249820,"goal":"predicate DistinctSeq_13133(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_13134","instance":13134,"id":249821,"goal":"predicate IsSubseq_13134(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_13135","instance":13135,"id":249822,"goal":"predicate IsPermutation_13135(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_13136","instance":13136,"id":249823,"goal":"predicate IsEven_13136(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_13137","instance":13137,"id":249824,"goal":"predicate InRange_13137(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_13138","instance":13138,"id":249825,"goal":"predicate SubsetOf_13138(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_13139","instance":13139,"id":249826,"goal":"predicate AllMem_13139(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_13140","instance":13140,"id":249827,"goal":"predicate DisjointSets_13140(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_13141","instance":13141,"id":249828,"goal":"predicate Sorted_13141(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_13142","instance":13142,"id":249829,"goal":"predicate AllPositive_13142(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_13143","instance":13143,"id":249830,"goal":"predicate DistinctSeq_13143(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_13144","instance":13144,"id":249831,"goal":"predicate IsSubseq_13144(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_13145","instance":13145,"id":249832,"goal":"predicate IsPermutation_13145(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_13146","instance":13146,"id":249833,"goal":"predicate IsEven_13146(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_13147","instance":13147,"id":249834,"goal":"predicate InRange_13147(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_13148","instance":13148,"id":249835,"goal":"predicate SubsetOf_13148(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_13149","instance":13149,"id":249836,"goal":"predicate AllMem_13149(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_13150","instance":13150,"id":249837,"goal":"predicate DisjointSets_13150(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_13151","instance":13151,"id":249838,"goal":"predicate Sorted_13151(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_13152","instance":13152,"id":249839,"goal":"predicate AllPositive_13152(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_13153","instance":13153,"id":249840,"goal":"predicate DistinctSeq_13153(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_13154","instance":13154,"id":249841,"goal":"predicate IsSubseq_13154(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_13155","instance":13155,"id":249842,"goal":"predicate IsPermutation_13155(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_13156","instance":13156,"id":249843,"goal":"predicate IsEven_13156(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_13157","instance":13157,"id":249844,"goal":"predicate InRange_13157(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_13158","instance":13158,"id":249845,"goal":"predicate SubsetOf_13158(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_13159","instance":13159,"id":249846,"goal":"predicate AllMem_13159(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_13160","instance":13160,"id":249847,"goal":"predicate DisjointSets_13160(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_13161","instance":13161,"id":249848,"goal":"predicate Sorted_13161(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_13162","instance":13162,"id":249849,"goal":"predicate AllPositive_13162(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_13163","instance":13163,"id":249850,"goal":"predicate DistinctSeq_13163(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_13164","instance":13164,"id":249851,"goal":"predicate IsSubseq_13164(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_13165","instance":13165,"id":249852,"goal":"predicate IsPermutation_13165(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_13166","instance":13166,"id":249853,"goal":"predicate IsEven_13166(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_13167","instance":13167,"id":249854,"goal":"predicate InRange_13167(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_13168","instance":13168,"id":249855,"goal":"predicate SubsetOf_13168(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_13169","instance":13169,"id":249856,"goal":"predicate AllMem_13169(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_13170","instance":13170,"id":249857,"goal":"predicate DisjointSets_13170(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_13171","instance":13171,"id":249858,"goal":"predicate Sorted_13171(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_13172","instance":13172,"id":249859,"goal":"predicate AllPositive_13172(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_13173","instance":13173,"id":249860,"goal":"predicate DistinctSeq_13173(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_13174","instance":13174,"id":249861,"goal":"predicate IsSubseq_13174(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_13175","instance":13175,"id":249862,"goal":"predicate IsPermutation_13175(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_13176","instance":13176,"id":249863,"goal":"predicate IsEven_13176(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_13177","instance":13177,"id":249864,"goal":"predicate InRange_13177(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_13178","instance":13178,"id":249865,"goal":"predicate SubsetOf_13178(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_13179","instance":13179,"id":249866,"goal":"predicate AllMem_13179(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_13180","instance":13180,"id":249867,"goal":"predicate DisjointSets_13180(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_13181","instance":13181,"id":249868,"goal":"predicate Sorted_13181(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_13182","instance":13182,"id":249869,"goal":"predicate AllPositive_13182(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_13183","instance":13183,"id":249870,"goal":"predicate DistinctSeq_13183(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_13184","instance":13184,"id":249871,"goal":"predicate IsSubseq_13184(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_13185","instance":13185,"id":249872,"goal":"predicate IsPermutation_13185(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_13186","instance":13186,"id":249873,"goal":"predicate IsEven_13186(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_13187","instance":13187,"id":249874,"goal":"predicate InRange_13187(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_13188","instance":13188,"id":249875,"goal":"predicate SubsetOf_13188(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_13189","instance":13189,"id":249876,"goal":"predicate AllMem_13189(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_13190","instance":13190,"id":249877,"goal":"predicate DisjointSets_13190(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_13191","instance":13191,"id":249878,"goal":"predicate Sorted_13191(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_13192","instance":13192,"id":249879,"goal":"predicate AllPositive_13192(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_13193","instance":13193,"id":249880,"goal":"predicate DistinctSeq_13193(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_13194","instance":13194,"id":249881,"goal":"predicate IsSubseq_13194(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_13195","instance":13195,"id":249882,"goal":"predicate IsPermutation_13195(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_13196","instance":13196,"id":249883,"goal":"predicate IsEven_13196(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_13197","instance":13197,"id":249884,"goal":"predicate InRange_13197(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_13198","instance":13198,"id":249885,"goal":"predicate SubsetOf_13198(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_13199","instance":13199,"id":249886,"goal":"predicate AllMem_13199(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_13200","instance":13200,"id":249887,"goal":"predicate DisjointSets_13200(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_13201","instance":13201,"id":249888,"goal":"predicate Sorted_13201(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_13202","instance":13202,"id":249889,"goal":"predicate AllPositive_13202(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_13203","instance":13203,"id":249890,"goal":"predicate DistinctSeq_13203(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_13204","instance":13204,"id":249891,"goal":"predicate IsSubseq_13204(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_13205","instance":13205,"id":249892,"goal":"predicate IsPermutation_13205(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_13206","instance":13206,"id":249893,"goal":"predicate IsEven_13206(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_13207","instance":13207,"id":249894,"goal":"predicate InRange_13207(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_13208","instance":13208,"id":249895,"goal":"predicate SubsetOf_13208(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_13209","instance":13209,"id":249896,"goal":"predicate AllMem_13209(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_13210","instance":13210,"id":249897,"goal":"predicate DisjointSets_13210(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_13211","instance":13211,"id":249898,"goal":"predicate Sorted_13211(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_13212","instance":13212,"id":249899,"goal":"predicate AllPositive_13212(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_13213","instance":13213,"id":249900,"goal":"predicate DistinctSeq_13213(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_13214","instance":13214,"id":249901,"goal":"predicate IsSubseq_13214(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_13215","instance":13215,"id":249902,"goal":"predicate IsPermutation_13215(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_13216","instance":13216,"id":249903,"goal":"predicate IsEven_13216(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_13217","instance":13217,"id":249904,"goal":"predicate InRange_13217(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_13218","instance":13218,"id":249905,"goal":"predicate SubsetOf_13218(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_13219","instance":13219,"id":249906,"goal":"predicate AllMem_13219(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_13220","instance":13220,"id":249907,"goal":"predicate DisjointSets_13220(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_13221","instance":13221,"id":249908,"goal":"predicate Sorted_13221(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_13222","instance":13222,"id":249909,"goal":"predicate AllPositive_13222(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_13223","instance":13223,"id":249910,"goal":"predicate DistinctSeq_13223(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_13224","instance":13224,"id":249911,"goal":"predicate IsSubseq_13224(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_13225","instance":13225,"id":249912,"goal":"predicate IsPermutation_13225(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_13226","instance":13226,"id":249913,"goal":"predicate IsEven_13226(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_13227","instance":13227,"id":249914,"goal":"predicate InRange_13227(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_13228","instance":13228,"id":249915,"goal":"predicate SubsetOf_13228(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_13229","instance":13229,"id":249916,"goal":"predicate AllMem_13229(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_13230","instance":13230,"id":249917,"goal":"predicate DisjointSets_13230(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_13231","instance":13231,"id":249918,"goal":"predicate Sorted_13231(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_13232","instance":13232,"id":249919,"goal":"predicate AllPositive_13232(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_13233","instance":13233,"id":249920,"goal":"predicate DistinctSeq_13233(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_13234","instance":13234,"id":249921,"goal":"predicate IsSubseq_13234(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_13235","instance":13235,"id":249922,"goal":"predicate IsPermutation_13235(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_13236","instance":13236,"id":249923,"goal":"predicate IsEven_13236(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_13237","instance":13237,"id":249924,"goal":"predicate InRange_13237(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_13238","instance":13238,"id":249925,"goal":"predicate SubsetOf_13238(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_13239","instance":13239,"id":249926,"goal":"predicate AllMem_13239(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_13240","instance":13240,"id":249927,"goal":"predicate DisjointSets_13240(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_13241","instance":13241,"id":249928,"goal":"predicate Sorted_13241(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_13242","instance":13242,"id":249929,"goal":"predicate AllPositive_13242(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_13243","instance":13243,"id":249930,"goal":"predicate DistinctSeq_13243(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_13244","instance":13244,"id":249931,"goal":"predicate IsSubseq_13244(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_13245","instance":13245,"id":249932,"goal":"predicate IsPermutation_13245(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_13246","instance":13246,"id":249933,"goal":"predicate IsEven_13246(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_13247","instance":13247,"id":249934,"goal":"predicate InRange_13247(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_13248","instance":13248,"id":249935,"goal":"predicate SubsetOf_13248(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_13249","instance":13249,"id":249936,"goal":"predicate AllMem_13249(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_13250","instance":13250,"id":249937,"goal":"predicate DisjointSets_13250(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_13251","instance":13251,"id":249938,"goal":"predicate Sorted_13251(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_13252","instance":13252,"id":249939,"goal":"predicate AllPositive_13252(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_13253","instance":13253,"id":249940,"goal":"predicate DistinctSeq_13253(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_13254","instance":13254,"id":249941,"goal":"predicate IsSubseq_13254(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_13255","instance":13255,"id":249942,"goal":"predicate IsPermutation_13255(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_13256","instance":13256,"id":249943,"goal":"predicate IsEven_13256(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_13257","instance":13257,"id":249944,"goal":"predicate InRange_13257(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_13258","instance":13258,"id":249945,"goal":"predicate SubsetOf_13258(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_13259","instance":13259,"id":249946,"goal":"predicate AllMem_13259(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_13260","instance":13260,"id":249947,"goal":"predicate DisjointSets_13260(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_13261","instance":13261,"id":249948,"goal":"predicate Sorted_13261(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_13262","instance":13262,"id":249949,"goal":"predicate AllPositive_13262(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_13263","instance":13263,"id":249950,"goal":"predicate DistinctSeq_13263(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_13264","instance":13264,"id":249951,"goal":"predicate IsSubseq_13264(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_13265","instance":13265,"id":249952,"goal":"predicate IsPermutation_13265(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_13266","instance":13266,"id":249953,"goal":"predicate IsEven_13266(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_13267","instance":13267,"id":249954,"goal":"predicate InRange_13267(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_13268","instance":13268,"id":249955,"goal":"predicate SubsetOf_13268(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_13269","instance":13269,"id":249956,"goal":"predicate AllMem_13269(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_13270","instance":13270,"id":249957,"goal":"predicate DisjointSets_13270(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_13271","instance":13271,"id":249958,"goal":"predicate Sorted_13271(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_13272","instance":13272,"id":249959,"goal":"predicate AllPositive_13272(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_13273","instance":13273,"id":249960,"goal":"predicate DistinctSeq_13273(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_13274","instance":13274,"id":249961,"goal":"predicate IsSubseq_13274(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_13275","instance":13275,"id":249962,"goal":"predicate IsPermutation_13275(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_13276","instance":13276,"id":249963,"goal":"predicate IsEven_13276(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_13277","instance":13277,"id":249964,"goal":"predicate InRange_13277(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_13278","instance":13278,"id":249965,"goal":"predicate SubsetOf_13278(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_13279","instance":13279,"id":249966,"goal":"predicate AllMem_13279(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_13280","instance":13280,"id":249967,"goal":"predicate DisjointSets_13280(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_13281","instance":13281,"id":249968,"goal":"predicate Sorted_13281(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_13282","instance":13282,"id":249969,"goal":"predicate AllPositive_13282(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_13283","instance":13283,"id":249970,"goal":"predicate DistinctSeq_13283(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_13284","instance":13284,"id":249971,"goal":"predicate IsSubseq_13284(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_13285","instance":13285,"id":249972,"goal":"predicate IsPermutation_13285(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_13286","instance":13286,"id":249973,"goal":"predicate IsEven_13286(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_13287","instance":13287,"id":249974,"goal":"predicate InRange_13287(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_13288","instance":13288,"id":249975,"goal":"predicate SubsetOf_13288(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_13289","instance":13289,"id":249976,"goal":"predicate AllMem_13289(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_13290","instance":13290,"id":249977,"goal":"predicate DisjointSets_13290(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_13291","instance":13291,"id":249978,"goal":"predicate Sorted_13291(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_13292","instance":13292,"id":249979,"goal":"predicate AllPositive_13292(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_13293","instance":13293,"id":249980,"goal":"predicate DistinctSeq_13293(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_13294","instance":13294,"id":249981,"goal":"predicate IsSubseq_13294(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_13295","instance":13295,"id":249982,"goal":"predicate IsPermutation_13295(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_13296","instance":13296,"id":249983,"goal":"predicate IsEven_13296(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_13297","instance":13297,"id":249984,"goal":"predicate InRange_13297(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_13298","instance":13298,"id":249985,"goal":"predicate SubsetOf_13298(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_13299","instance":13299,"id":249986,"goal":"predicate AllMem_13299(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_13300","instance":13300,"id":249987,"goal":"predicate DisjointSets_13300(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_13301","instance":13301,"id":249988,"goal":"predicate Sorted_13301(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_13302","instance":13302,"id":249989,"goal":"predicate AllPositive_13302(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_13303","instance":13303,"id":249990,"goal":"predicate DistinctSeq_13303(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_13304","instance":13304,"id":249991,"goal":"predicate IsSubseq_13304(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_13305","instance":13305,"id":249992,"goal":"predicate IsPermutation_13305(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_13306","instance":13306,"id":249993,"goal":"predicate IsEven_13306(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_13307","instance":13307,"id":249994,"goal":"predicate InRange_13307(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_13308","instance":13308,"id":249995,"goal":"predicate SubsetOf_13308(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_13309","instance":13309,"id":249996,"goal":"predicate AllMem_13309(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_13310","instance":13310,"id":249997,"goal":"predicate DisjointSets_13310(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_13311","instance":13311,"id":249998,"goal":"predicate Sorted_13311(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_13312","instance":13312,"id":249999,"goal":"predicate AllPositive_13312(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_13313","instance":13313,"id":250000,"goal":"predicate DistinctSeq_13313(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_13314","instance":13314,"id":250001,"goal":"predicate IsSubseq_13314(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_13315","instance":13315,"id":250002,"goal":"predicate IsPermutation_13315(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_13316","instance":13316,"id":250003,"goal":"predicate IsEven_13316(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_13317","instance":13317,"id":250004,"goal":"predicate InRange_13317(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_13318","instance":13318,"id":250005,"goal":"predicate SubsetOf_13318(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_13319","instance":13319,"id":250006,"goal":"predicate AllMem_13319(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_13320","instance":13320,"id":250007,"goal":"predicate DisjointSets_13320(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_13321","instance":13321,"id":250008,"goal":"predicate Sorted_13321(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_13322","instance":13322,"id":250009,"goal":"predicate AllPositive_13322(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_13323","instance":13323,"id":250010,"goal":"predicate DistinctSeq_13323(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_13324","instance":13324,"id":250011,"goal":"predicate IsSubseq_13324(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_13325","instance":13325,"id":250012,"goal":"predicate IsPermutation_13325(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_13326","instance":13326,"id":250013,"goal":"predicate IsEven_13326(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_13327","instance":13327,"id":250014,"goal":"predicate InRange_13327(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_13328","instance":13328,"id":250015,"goal":"predicate SubsetOf_13328(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_13329","instance":13329,"id":250016,"goal":"predicate AllMem_13329(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_13330","instance":13330,"id":250017,"goal":"predicate DisjointSets_13330(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_13331","instance":13331,"id":250018,"goal":"predicate Sorted_13331(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_13332","instance":13332,"id":250019,"goal":"predicate AllPositive_13332(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_13333","instance":13333,"id":250020,"goal":"predicate DistinctSeq_13333(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_13334","instance":13334,"id":250021,"goal":"predicate IsSubseq_13334(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_13335","instance":13335,"id":250022,"goal":"predicate IsPermutation_13335(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_13336","instance":13336,"id":250023,"goal":"predicate IsEven_13336(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_13337","instance":13337,"id":250024,"goal":"predicate InRange_13337(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_13338","instance":13338,"id":250025,"goal":"predicate SubsetOf_13338(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_13339","instance":13339,"id":250026,"goal":"predicate AllMem_13339(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_13340","instance":13340,"id":250027,"goal":"predicate DisjointSets_13340(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_13341","instance":13341,"id":250028,"goal":"predicate Sorted_13341(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_13342","instance":13342,"id":250029,"goal":"predicate AllPositive_13342(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_13343","instance":13343,"id":250030,"goal":"predicate DistinctSeq_13343(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_13344","instance":13344,"id":250031,"goal":"predicate IsSubseq_13344(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_13345","instance":13345,"id":250032,"goal":"predicate IsPermutation_13345(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_13346","instance":13346,"id":250033,"goal":"predicate IsEven_13346(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_13347","instance":13347,"id":250034,"goal":"predicate InRange_13347(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_13348","instance":13348,"id":250035,"goal":"predicate SubsetOf_13348(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_13349","instance":13349,"id":250036,"goal":"predicate AllMem_13349(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_13350","instance":13350,"id":250037,"goal":"predicate DisjointSets_13350(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_13351","instance":13351,"id":250038,"goal":"predicate Sorted_13351(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_13352","instance":13352,"id":250039,"goal":"predicate AllPositive_13352(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_13353","instance":13353,"id":250040,"goal":"predicate DistinctSeq_13353(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_13354","instance":13354,"id":250041,"goal":"predicate IsSubseq_13354(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_13355","instance":13355,"id":250042,"goal":"predicate IsPermutation_13355(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_13356","instance":13356,"id":250043,"goal":"predicate IsEven_13356(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_13357","instance":13357,"id":250044,"goal":"predicate InRange_13357(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_13358","instance":13358,"id":250045,"goal":"predicate SubsetOf_13358(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_13359","instance":13359,"id":250046,"goal":"predicate AllMem_13359(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_13360","instance":13360,"id":250047,"goal":"predicate DisjointSets_13360(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_13361","instance":13361,"id":250048,"goal":"predicate Sorted_13361(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_13362","instance":13362,"id":250049,"goal":"predicate AllPositive_13362(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_13363","instance":13363,"id":250050,"goal":"predicate DistinctSeq_13363(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_13364","instance":13364,"id":250051,"goal":"predicate IsSubseq_13364(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_13365","instance":13365,"id":250052,"goal":"predicate IsPermutation_13365(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_13366","instance":13366,"id":250053,"goal":"predicate IsEven_13366(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_13367","instance":13367,"id":250054,"goal":"predicate InRange_13367(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_13368","instance":13368,"id":250055,"goal":"predicate SubsetOf_13368(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_13369","instance":13369,"id":250056,"goal":"predicate AllMem_13369(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_13370","instance":13370,"id":250057,"goal":"predicate DisjointSets_13370(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_13371","instance":13371,"id":250058,"goal":"predicate Sorted_13371(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_13372","instance":13372,"id":250059,"goal":"predicate AllPositive_13372(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_13373","instance":13373,"id":250060,"goal":"predicate DistinctSeq_13373(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_13374","instance":13374,"id":250061,"goal":"predicate IsSubseq_13374(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_13375","instance":13375,"id":250062,"goal":"predicate IsPermutation_13375(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_13376","instance":13376,"id":250063,"goal":"predicate IsEven_13376(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_13377","instance":13377,"id":250064,"goal":"predicate InRange_13377(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_13378","instance":13378,"id":250065,"goal":"predicate SubsetOf_13378(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_13379","instance":13379,"id":250066,"goal":"predicate AllMem_13379(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_13380","instance":13380,"id":250067,"goal":"predicate DisjointSets_13380(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_13381","instance":13381,"id":250068,"goal":"predicate Sorted_13381(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_13382","instance":13382,"id":250069,"goal":"predicate AllPositive_13382(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_13383","instance":13383,"id":250070,"goal":"predicate DistinctSeq_13383(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_13384","instance":13384,"id":250071,"goal":"predicate IsSubseq_13384(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_13385","instance":13385,"id":250072,"goal":"predicate IsPermutation_13385(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_13386","instance":13386,"id":250073,"goal":"predicate IsEven_13386(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_13387","instance":13387,"id":250074,"goal":"predicate InRange_13387(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_13388","instance":13388,"id":250075,"goal":"predicate SubsetOf_13388(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_13389","instance":13389,"id":250076,"goal":"predicate AllMem_13389(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_13390","instance":13390,"id":250077,"goal":"predicate DisjointSets_13390(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_13391","instance":13391,"id":250078,"goal":"predicate Sorted_13391(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_13392","instance":13392,"id":250079,"goal":"predicate AllPositive_13392(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_13393","instance":13393,"id":250080,"goal":"predicate DistinctSeq_13393(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_13394","instance":13394,"id":250081,"goal":"predicate IsSubseq_13394(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_13395","instance":13395,"id":250082,"goal":"predicate IsPermutation_13395(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_13396","instance":13396,"id":250083,"goal":"predicate IsEven_13396(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_13397","instance":13397,"id":250084,"goal":"predicate InRange_13397(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_13398","instance":13398,"id":250085,"goal":"predicate SubsetOf_13398(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_13399","instance":13399,"id":250086,"goal":"predicate AllMem_13399(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_13400","instance":13400,"id":250087,"goal":"predicate DisjointSets_13400(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_13401","instance":13401,"id":250088,"goal":"predicate Sorted_13401(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_13402","instance":13402,"id":250089,"goal":"predicate AllPositive_13402(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_13403","instance":13403,"id":250090,"goal":"predicate DistinctSeq_13403(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_13404","instance":13404,"id":250091,"goal":"predicate IsSubseq_13404(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_13405","instance":13405,"id":250092,"goal":"predicate IsPermutation_13405(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_13406","instance":13406,"id":250093,"goal":"predicate IsEven_13406(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_13407","instance":13407,"id":250094,"goal":"predicate InRange_13407(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_13408","instance":13408,"id":250095,"goal":"predicate SubsetOf_13408(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_13409","instance":13409,"id":250096,"goal":"predicate AllMem_13409(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_13410","instance":13410,"id":250097,"goal":"predicate DisjointSets_13410(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_13411","instance":13411,"id":250098,"goal":"predicate Sorted_13411(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_13412","instance":13412,"id":250099,"goal":"predicate AllPositive_13412(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_13413","instance":13413,"id":250100,"goal":"predicate DistinctSeq_13413(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_13414","instance":13414,"id":250101,"goal":"predicate IsSubseq_13414(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_13415","instance":13415,"id":250102,"goal":"predicate IsPermutation_13415(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_13416","instance":13416,"id":250103,"goal":"predicate IsEven_13416(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_13417","instance":13417,"id":250104,"goal":"predicate InRange_13417(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_13418","instance":13418,"id":250105,"goal":"predicate SubsetOf_13418(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_13419","instance":13419,"id":250106,"goal":"predicate AllMem_13419(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_13420","instance":13420,"id":250107,"goal":"predicate DisjointSets_13420(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_13421","instance":13421,"id":250108,"goal":"predicate Sorted_13421(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_13422","instance":13422,"id":250109,"goal":"predicate AllPositive_13422(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_13423","instance":13423,"id":250110,"goal":"predicate DistinctSeq_13423(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_13424","instance":13424,"id":250111,"goal":"predicate IsSubseq_13424(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_13425","instance":13425,"id":250112,"goal":"predicate IsPermutation_13425(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_13426","instance":13426,"id":250113,"goal":"predicate IsEven_13426(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_13427","instance":13427,"id":250114,"goal":"predicate InRange_13427(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_13428","instance":13428,"id":250115,"goal":"predicate SubsetOf_13428(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_13429","instance":13429,"id":250116,"goal":"predicate AllMem_13429(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_13430","instance":13430,"id":250117,"goal":"predicate DisjointSets_13430(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_13431","instance":13431,"id":250118,"goal":"predicate Sorted_13431(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_13432","instance":13432,"id":250119,"goal":"predicate AllPositive_13432(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_13433","instance":13433,"id":250120,"goal":"predicate DistinctSeq_13433(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_13434","instance":13434,"id":250121,"goal":"predicate IsSubseq_13434(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_13435","instance":13435,"id":250122,"goal":"predicate IsPermutation_13435(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_13436","instance":13436,"id":250123,"goal":"predicate IsEven_13436(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_13437","instance":13437,"id":250124,"goal":"predicate InRange_13437(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_13438","instance":13438,"id":250125,"goal":"predicate SubsetOf_13438(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_13439","instance":13439,"id":250126,"goal":"predicate AllMem_13439(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_13440","instance":13440,"id":250127,"goal":"predicate DisjointSets_13440(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_13441","instance":13441,"id":250128,"goal":"predicate Sorted_13441(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_13442","instance":13442,"id":250129,"goal":"predicate AllPositive_13442(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_13443","instance":13443,"id":250130,"goal":"predicate DistinctSeq_13443(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_13444","instance":13444,"id":250131,"goal":"predicate IsSubseq_13444(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_13445","instance":13445,"id":250132,"goal":"predicate IsPermutation_13445(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_13446","instance":13446,"id":250133,"goal":"predicate IsEven_13446(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_13447","instance":13447,"id":250134,"goal":"predicate InRange_13447(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_13448","instance":13448,"id":250135,"goal":"predicate SubsetOf_13448(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_13449","instance":13449,"id":250136,"goal":"predicate AllMem_13449(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_13450","instance":13450,"id":250137,"goal":"predicate DisjointSets_13450(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_13451","instance":13451,"id":250138,"goal":"predicate Sorted_13451(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_13452","instance":13452,"id":250139,"goal":"predicate AllPositive_13452(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_13453","instance":13453,"id":250140,"goal":"predicate DistinctSeq_13453(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_13454","instance":13454,"id":250141,"goal":"predicate IsSubseq_13454(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_13455","instance":13455,"id":250142,"goal":"predicate IsPermutation_13455(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_13456","instance":13456,"id":250143,"goal":"predicate IsEven_13456(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_13457","instance":13457,"id":250144,"goal":"predicate InRange_13457(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_13458","instance":13458,"id":250145,"goal":"predicate SubsetOf_13458(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_13459","instance":13459,"id":250146,"goal":"predicate AllMem_13459(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_13460","instance":13460,"id":250147,"goal":"predicate DisjointSets_13460(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_13461","instance":13461,"id":250148,"goal":"predicate Sorted_13461(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_13462","instance":13462,"id":250149,"goal":"predicate AllPositive_13462(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_13463","instance":13463,"id":250150,"goal":"predicate DistinctSeq_13463(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_13464","instance":13464,"id":250151,"goal":"predicate IsSubseq_13464(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_13465","instance":13465,"id":250152,"goal":"predicate IsPermutation_13465(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_13466","instance":13466,"id":250153,"goal":"predicate IsEven_13466(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_13467","instance":13467,"id":250154,"goal":"predicate InRange_13467(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_13468","instance":13468,"id":250155,"goal":"predicate SubsetOf_13468(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_13469","instance":13469,"id":250156,"goal":"predicate AllMem_13469(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_13470","instance":13470,"id":250157,"goal":"predicate DisjointSets_13470(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_13471","instance":13471,"id":250158,"goal":"predicate Sorted_13471(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_13472","instance":13472,"id":250159,"goal":"predicate AllPositive_13472(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_13473","instance":13473,"id":250160,"goal":"predicate DistinctSeq_13473(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_13474","instance":13474,"id":250161,"goal":"predicate IsSubseq_13474(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_13475","instance":13475,"id":250162,"goal":"predicate IsPermutation_13475(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_13476","instance":13476,"id":250163,"goal":"predicate IsEven_13476(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_13477","instance":13477,"id":250164,"goal":"predicate InRange_13477(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_13478","instance":13478,"id":250165,"goal":"predicate SubsetOf_13478(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_13479","instance":13479,"id":250166,"goal":"predicate AllMem_13479(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_13480","instance":13480,"id":250167,"goal":"predicate DisjointSets_13480(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_13481","instance":13481,"id":250168,"goal":"predicate Sorted_13481(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_13482","instance":13482,"id":250169,"goal":"predicate AllPositive_13482(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_13483","instance":13483,"id":250170,"goal":"predicate DistinctSeq_13483(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_13484","instance":13484,"id":250171,"goal":"predicate IsSubseq_13484(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_13485","instance":13485,"id":250172,"goal":"predicate IsPermutation_13485(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_13486","instance":13486,"id":250173,"goal":"predicate IsEven_13486(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_13487","instance":13487,"id":250174,"goal":"predicate InRange_13487(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_13488","instance":13488,"id":250175,"goal":"predicate SubsetOf_13488(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_13489","instance":13489,"id":250176,"goal":"predicate AllMem_13489(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_13490","instance":13490,"id":250177,"goal":"predicate DisjointSets_13490(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_13491","instance":13491,"id":250178,"goal":"predicate Sorted_13491(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_13492","instance":13492,"id":250179,"goal":"predicate AllPositive_13492(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_13493","instance":13493,"id":250180,"goal":"predicate DistinctSeq_13493(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_13494","instance":13494,"id":250181,"goal":"predicate IsSubseq_13494(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_13495","instance":13495,"id":250182,"goal":"predicate IsPermutation_13495(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_13496","instance":13496,"id":250183,"goal":"predicate IsEven_13496(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_13497","instance":13497,"id":250184,"goal":"predicate InRange_13497(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_13498","instance":13498,"id":250185,"goal":"predicate SubsetOf_13498(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_13499","instance":13499,"id":250186,"goal":"predicate AllMem_13499(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_13500","instance":13500,"id":250187,"goal":"predicate DisjointSets_13500(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_13501","instance":13501,"id":250188,"goal":"predicate Sorted_13501(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_13502","instance":13502,"id":250189,"goal":"predicate AllPositive_13502(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_13503","instance":13503,"id":250190,"goal":"predicate DistinctSeq_13503(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_13504","instance":13504,"id":250191,"goal":"predicate IsSubseq_13504(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_13505","instance":13505,"id":250192,"goal":"predicate IsPermutation_13505(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_13506","instance":13506,"id":250193,"goal":"predicate IsEven_13506(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_13507","instance":13507,"id":250194,"goal":"predicate InRange_13507(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_13508","instance":13508,"id":250195,"goal":"predicate SubsetOf_13508(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_13509","instance":13509,"id":250196,"goal":"predicate AllMem_13509(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_13510","instance":13510,"id":250197,"goal":"predicate DisjointSets_13510(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_13511","instance":13511,"id":250198,"goal":"predicate Sorted_13511(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_13512","instance":13512,"id":250199,"goal":"predicate AllPositive_13512(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_13513","instance":13513,"id":250200,"goal":"predicate DistinctSeq_13513(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_13514","instance":13514,"id":250201,"goal":"predicate IsSubseq_13514(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_13515","instance":13515,"id":250202,"goal":"predicate IsPermutation_13515(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_13516","instance":13516,"id":250203,"goal":"predicate IsEven_13516(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_13517","instance":13517,"id":250204,"goal":"predicate InRange_13517(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_13518","instance":13518,"id":250205,"goal":"predicate SubsetOf_13518(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_13519","instance":13519,"id":250206,"goal":"predicate AllMem_13519(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_13520","instance":13520,"id":250207,"goal":"predicate DisjointSets_13520(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_13521","instance":13521,"id":250208,"goal":"predicate Sorted_13521(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_13522","instance":13522,"id":250209,"goal":"predicate AllPositive_13522(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_13523","instance":13523,"id":250210,"goal":"predicate DistinctSeq_13523(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_13524","instance":13524,"id":250211,"goal":"predicate IsSubseq_13524(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_13525","instance":13525,"id":250212,"goal":"predicate IsPermutation_13525(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_13526","instance":13526,"id":250213,"goal":"predicate IsEven_13526(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_13527","instance":13527,"id":250214,"goal":"predicate InRange_13527(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_13528","instance":13528,"id":250215,"goal":"predicate SubsetOf_13528(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_13529","instance":13529,"id":250216,"goal":"predicate AllMem_13529(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_13530","instance":13530,"id":250217,"goal":"predicate DisjointSets_13530(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_13531","instance":13531,"id":250218,"goal":"predicate Sorted_13531(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_13532","instance":13532,"id":250219,"goal":"predicate AllPositive_13532(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_13533","instance":13533,"id":250220,"goal":"predicate DistinctSeq_13533(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_13534","instance":13534,"id":250221,"goal":"predicate IsSubseq_13534(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_13535","instance":13535,"id":250222,"goal":"predicate IsPermutation_13535(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_13536","instance":13536,"id":250223,"goal":"predicate IsEven_13536(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_13537","instance":13537,"id":250224,"goal":"predicate InRange_13537(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_13538","instance":13538,"id":250225,"goal":"predicate SubsetOf_13538(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_13539","instance":13539,"id":250226,"goal":"predicate AllMem_13539(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_13540","instance":13540,"id":250227,"goal":"predicate DisjointSets_13540(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_13541","instance":13541,"id":250228,"goal":"predicate Sorted_13541(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_13542","instance":13542,"id":250229,"goal":"predicate AllPositive_13542(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_13543","instance":13543,"id":250230,"goal":"predicate DistinctSeq_13543(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_13544","instance":13544,"id":250231,"goal":"predicate IsSubseq_13544(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_13545","instance":13545,"id":250232,"goal":"predicate IsPermutation_13545(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_13546","instance":13546,"id":250233,"goal":"predicate IsEven_13546(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_13547","instance":13547,"id":250234,"goal":"predicate InRange_13547(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_13548","instance":13548,"id":250235,"goal":"predicate SubsetOf_13548(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_13549","instance":13549,"id":250236,"goal":"predicate AllMem_13549(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_13550","instance":13550,"id":250237,"goal":"predicate DisjointSets_13550(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_13551","instance":13551,"id":250238,"goal":"predicate Sorted_13551(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_13552","instance":13552,"id":250239,"goal":"predicate AllPositive_13552(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_13553","instance":13553,"id":250240,"goal":"predicate DistinctSeq_13553(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_13554","instance":13554,"id":250241,"goal":"predicate IsSubseq_13554(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_13555","instance":13555,"id":250242,"goal":"predicate IsPermutation_13555(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_13556","instance":13556,"id":250243,"goal":"predicate IsEven_13556(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_13557","instance":13557,"id":250244,"goal":"predicate InRange_13557(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_13558","instance":13558,"id":250245,"goal":"predicate SubsetOf_13558(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_13559","instance":13559,"id":250246,"goal":"predicate AllMem_13559(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_13560","instance":13560,"id":250247,"goal":"predicate DisjointSets_13560(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_13561","instance":13561,"id":250248,"goal":"predicate Sorted_13561(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_13562","instance":13562,"id":250249,"goal":"predicate AllPositive_13562(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_13563","instance":13563,"id":250250,"goal":"predicate DistinctSeq_13563(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_13564","instance":13564,"id":250251,"goal":"predicate IsSubseq_13564(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_13565","instance":13565,"id":250252,"goal":"predicate IsPermutation_13565(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_13566","instance":13566,"id":250253,"goal":"predicate IsEven_13566(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_13567","instance":13567,"id":250254,"goal":"predicate InRange_13567(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_13568","instance":13568,"id":250255,"goal":"predicate SubsetOf_13568(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_13569","instance":13569,"id":250256,"goal":"predicate AllMem_13569(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_13570","instance":13570,"id":250257,"goal":"predicate DisjointSets_13570(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_13571","instance":13571,"id":250258,"goal":"predicate Sorted_13571(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_13572","instance":13572,"id":250259,"goal":"predicate AllPositive_13572(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_13573","instance":13573,"id":250260,"goal":"predicate DistinctSeq_13573(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_13574","instance":13574,"id":250261,"goal":"predicate IsSubseq_13574(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_13575","instance":13575,"id":250262,"goal":"predicate IsPermutation_13575(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_13576","instance":13576,"id":250263,"goal":"predicate IsEven_13576(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_13577","instance":13577,"id":250264,"goal":"predicate InRange_13577(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_13578","instance":13578,"id":250265,"goal":"predicate SubsetOf_13578(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_13579","instance":13579,"id":250266,"goal":"predicate AllMem_13579(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_13580","instance":13580,"id":250267,"goal":"predicate DisjointSets_13580(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_13581","instance":13581,"id":250268,"goal":"predicate Sorted_13581(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_13582","instance":13582,"id":250269,"goal":"predicate AllPositive_13582(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_13583","instance":13583,"id":250270,"goal":"predicate DistinctSeq_13583(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_13584","instance":13584,"id":250271,"goal":"predicate IsSubseq_13584(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_13585","instance":13585,"id":250272,"goal":"predicate IsPermutation_13585(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_13586","instance":13586,"id":250273,"goal":"predicate IsEven_13586(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_13587","instance":13587,"id":250274,"goal":"predicate InRange_13587(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_13588","instance":13588,"id":250275,"goal":"predicate SubsetOf_13588(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_13589","instance":13589,"id":250276,"goal":"predicate AllMem_13589(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_13590","instance":13590,"id":250277,"goal":"predicate DisjointSets_13590(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_13591","instance":13591,"id":250278,"goal":"predicate Sorted_13591(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_13592","instance":13592,"id":250279,"goal":"predicate AllPositive_13592(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_13593","instance":13593,"id":250280,"goal":"predicate DistinctSeq_13593(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_13594","instance":13594,"id":250281,"goal":"predicate IsSubseq_13594(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_13595","instance":13595,"id":250282,"goal":"predicate IsPermutation_13595(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_13596","instance":13596,"id":250283,"goal":"predicate IsEven_13596(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_13597","instance":13597,"id":250284,"goal":"predicate InRange_13597(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_13598","instance":13598,"id":250285,"goal":"predicate SubsetOf_13598(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_13599","instance":13599,"id":250286,"goal":"predicate AllMem_13599(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_13600","instance":13600,"id":250287,"goal":"predicate DisjointSets_13600(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_13601","instance":13601,"id":250288,"goal":"predicate Sorted_13601(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_13602","instance":13602,"id":250289,"goal":"predicate AllPositive_13602(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_13603","instance":13603,"id":250290,"goal":"predicate DistinctSeq_13603(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_13604","instance":13604,"id":250291,"goal":"predicate IsSubseq_13604(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_13605","instance":13605,"id":250292,"goal":"predicate IsPermutation_13605(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_13606","instance":13606,"id":250293,"goal":"predicate IsEven_13606(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_13607","instance":13607,"id":250294,"goal":"predicate InRange_13607(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_13608","instance":13608,"id":250295,"goal":"predicate SubsetOf_13608(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_13609","instance":13609,"id":250296,"goal":"predicate AllMem_13609(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_13610","instance":13610,"id":250297,"goal":"predicate DisjointSets_13610(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_13611","instance":13611,"id":250298,"goal":"predicate Sorted_13611(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_13612","instance":13612,"id":250299,"goal":"predicate AllPositive_13612(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_13613","instance":13613,"id":250300,"goal":"predicate DistinctSeq_13613(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_13614","instance":13614,"id":250301,"goal":"predicate IsSubseq_13614(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_13615","instance":13615,"id":250302,"goal":"predicate IsPermutation_13615(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_13616","instance":13616,"id":250303,"goal":"predicate IsEven_13616(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_13617","instance":13617,"id":250304,"goal":"predicate InRange_13617(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_13618","instance":13618,"id":250305,"goal":"predicate SubsetOf_13618(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_13619","instance":13619,"id":250306,"goal":"predicate AllMem_13619(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_13620","instance":13620,"id":250307,"goal":"predicate DisjointSets_13620(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_13621","instance":13621,"id":250308,"goal":"predicate Sorted_13621(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_13622","instance":13622,"id":250309,"goal":"predicate AllPositive_13622(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_13623","instance":13623,"id":250310,"goal":"predicate DistinctSeq_13623(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_13624","instance":13624,"id":250311,"goal":"predicate IsSubseq_13624(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_13625","instance":13625,"id":250312,"goal":"predicate IsPermutation_13625(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_13626","instance":13626,"id":250313,"goal":"predicate IsEven_13626(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_13627","instance":13627,"id":250314,"goal":"predicate InRange_13627(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_13628","instance":13628,"id":250315,"goal":"predicate SubsetOf_13628(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_13629","instance":13629,"id":250316,"goal":"predicate AllMem_13629(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_13630","instance":13630,"id":250317,"goal":"predicate DisjointSets_13630(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_13631","instance":13631,"id":250318,"goal":"predicate Sorted_13631(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_13632","instance":13632,"id":250319,"goal":"predicate AllPositive_13632(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_13633","instance":13633,"id":250320,"goal":"predicate DistinctSeq_13633(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_13634","instance":13634,"id":250321,"goal":"predicate IsSubseq_13634(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_13635","instance":13635,"id":250322,"goal":"predicate IsPermutation_13635(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_13636","instance":13636,"id":250323,"goal":"predicate IsEven_13636(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_13637","instance":13637,"id":250324,"goal":"predicate InRange_13637(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_13638","instance":13638,"id":250325,"goal":"predicate SubsetOf_13638(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_13639","instance":13639,"id":250326,"goal":"predicate AllMem_13639(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_13640","instance":13640,"id":250327,"goal":"predicate DisjointSets_13640(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_13641","instance":13641,"id":250328,"goal":"predicate Sorted_13641(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_13642","instance":13642,"id":250329,"goal":"predicate AllPositive_13642(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_13643","instance":13643,"id":250330,"goal":"predicate DistinctSeq_13643(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_13644","instance":13644,"id":250331,"goal":"predicate IsSubseq_13644(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_13645","instance":13645,"id":250332,"goal":"predicate IsPermutation_13645(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_13646","instance":13646,"id":250333,"goal":"predicate IsEven_13646(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_13647","instance":13647,"id":250334,"goal":"predicate InRange_13647(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_13648","instance":13648,"id":250335,"goal":"predicate SubsetOf_13648(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_13649","instance":13649,"id":250336,"goal":"predicate AllMem_13649(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_13650","instance":13650,"id":250337,"goal":"predicate DisjointSets_13650(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_13651","instance":13651,"id":250338,"goal":"predicate Sorted_13651(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_13652","instance":13652,"id":250339,"goal":"predicate AllPositive_13652(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_13653","instance":13653,"id":250340,"goal":"predicate DistinctSeq_13653(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_13654","instance":13654,"id":250341,"goal":"predicate IsSubseq_13654(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_13655","instance":13655,"id":250342,"goal":"predicate IsPermutation_13655(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_13656","instance":13656,"id":250343,"goal":"predicate IsEven_13656(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_13657","instance":13657,"id":250344,"goal":"predicate InRange_13657(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_13658","instance":13658,"id":250345,"goal":"predicate SubsetOf_13658(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_13659","instance":13659,"id":250346,"goal":"predicate AllMem_13659(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_13660","instance":13660,"id":250347,"goal":"predicate DisjointSets_13660(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_13661","instance":13661,"id":250348,"goal":"predicate Sorted_13661(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_13662","instance":13662,"id":250349,"goal":"predicate AllPositive_13662(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_13663","instance":13663,"id":250350,"goal":"predicate DistinctSeq_13663(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_13664","instance":13664,"id":250351,"goal":"predicate IsSubseq_13664(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_13665","instance":13665,"id":250352,"goal":"predicate IsPermutation_13665(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_13666","instance":13666,"id":250353,"goal":"predicate IsEven_13666(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_13667","instance":13667,"id":250354,"goal":"predicate InRange_13667(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_13668","instance":13668,"id":250355,"goal":"predicate SubsetOf_13668(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_13669","instance":13669,"id":250356,"goal":"predicate AllMem_13669(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_13670","instance":13670,"id":250357,"goal":"predicate DisjointSets_13670(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_13671","instance":13671,"id":250358,"goal":"predicate Sorted_13671(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_13672","instance":13672,"id":250359,"goal":"predicate AllPositive_13672(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_13673","instance":13673,"id":250360,"goal":"predicate DistinctSeq_13673(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_13674","instance":13674,"id":250361,"goal":"predicate IsSubseq_13674(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_13675","instance":13675,"id":250362,"goal":"predicate IsPermutation_13675(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_13676","instance":13676,"id":250363,"goal":"predicate IsEven_13676(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_13677","instance":13677,"id":250364,"goal":"predicate InRange_13677(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_13678","instance":13678,"id":250365,"goal":"predicate SubsetOf_13678(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_13679","instance":13679,"id":250366,"goal":"predicate AllMem_13679(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_13680","instance":13680,"id":250367,"goal":"predicate DisjointSets_13680(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_13681","instance":13681,"id":250368,"goal":"predicate Sorted_13681(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_13682","instance":13682,"id":250369,"goal":"predicate AllPositive_13682(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_13683","instance":13683,"id":250370,"goal":"predicate DistinctSeq_13683(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_13684","instance":13684,"id":250371,"goal":"predicate IsSubseq_13684(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_13685","instance":13685,"id":250372,"goal":"predicate IsPermutation_13685(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_13686","instance":13686,"id":250373,"goal":"predicate IsEven_13686(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_13687","instance":13687,"id":250374,"goal":"predicate InRange_13687(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_13688","instance":13688,"id":250375,"goal":"predicate SubsetOf_13688(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_13689","instance":13689,"id":250376,"goal":"predicate AllMem_13689(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_13690","instance":13690,"id":250377,"goal":"predicate DisjointSets_13690(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_13691","instance":13691,"id":250378,"goal":"predicate Sorted_13691(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_13692","instance":13692,"id":250379,"goal":"predicate AllPositive_13692(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_13693","instance":13693,"id":250380,"goal":"predicate DistinctSeq_13693(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_13694","instance":13694,"id":250381,"goal":"predicate IsSubseq_13694(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_13695","instance":13695,"id":250382,"goal":"predicate IsPermutation_13695(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_13696","instance":13696,"id":250383,"goal":"predicate IsEven_13696(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_13697","instance":13697,"id":250384,"goal":"predicate InRange_13697(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_13698","instance":13698,"id":250385,"goal":"predicate SubsetOf_13698(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_13699","instance":13699,"id":250386,"goal":"predicate AllMem_13699(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_13700","instance":13700,"id":250387,"goal":"predicate DisjointSets_13700(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_13701","instance":13701,"id":250388,"goal":"predicate Sorted_13701(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_13702","instance":13702,"id":250389,"goal":"predicate AllPositive_13702(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_13703","instance":13703,"id":250390,"goal":"predicate DistinctSeq_13703(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_13704","instance":13704,"id":250391,"goal":"predicate IsSubseq_13704(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_13705","instance":13705,"id":250392,"goal":"predicate IsPermutation_13705(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_13706","instance":13706,"id":250393,"goal":"predicate IsEven_13706(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_13707","instance":13707,"id":250394,"goal":"predicate InRange_13707(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_13708","instance":13708,"id":250395,"goal":"predicate SubsetOf_13708(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_13709","instance":13709,"id":250396,"goal":"predicate AllMem_13709(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_13710","instance":13710,"id":250397,"goal":"predicate DisjointSets_13710(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_13711","instance":13711,"id":250398,"goal":"predicate Sorted_13711(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_13712","instance":13712,"id":250399,"goal":"predicate AllPositive_13712(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_13713","instance":13713,"id":250400,"goal":"predicate DistinctSeq_13713(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_13714","instance":13714,"id":250401,"goal":"predicate IsSubseq_13714(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_13715","instance":13715,"id":250402,"goal":"predicate IsPermutation_13715(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_13716","instance":13716,"id":250403,"goal":"predicate IsEven_13716(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_13717","instance":13717,"id":250404,"goal":"predicate InRange_13717(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_13718","instance":13718,"id":250405,"goal":"predicate SubsetOf_13718(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_13719","instance":13719,"id":250406,"goal":"predicate AllMem_13719(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_13720","instance":13720,"id":250407,"goal":"predicate DisjointSets_13720(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_13721","instance":13721,"id":250408,"goal":"predicate Sorted_13721(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_13722","instance":13722,"id":250409,"goal":"predicate AllPositive_13722(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_13723","instance":13723,"id":250410,"goal":"predicate DistinctSeq_13723(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_13724","instance":13724,"id":250411,"goal":"predicate IsSubseq_13724(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_13725","instance":13725,"id":250412,"goal":"predicate IsPermutation_13725(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_13726","instance":13726,"id":250413,"goal":"predicate IsEven_13726(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_13727","instance":13727,"id":250414,"goal":"predicate InRange_13727(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_13728","instance":13728,"id":250415,"goal":"predicate SubsetOf_13728(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_13729","instance":13729,"id":250416,"goal":"predicate AllMem_13729(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_13730","instance":13730,"id":250417,"goal":"predicate DisjointSets_13730(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_13731","instance":13731,"id":250418,"goal":"predicate Sorted_13731(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_13732","instance":13732,"id":250419,"goal":"predicate AllPositive_13732(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_13733","instance":13733,"id":250420,"goal":"predicate DistinctSeq_13733(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_13734","instance":13734,"id":250421,"goal":"predicate IsSubseq_13734(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_13735","instance":13735,"id":250422,"goal":"predicate IsPermutation_13735(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_13736","instance":13736,"id":250423,"goal":"predicate IsEven_13736(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_13737","instance":13737,"id":250424,"goal":"predicate InRange_13737(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_13738","instance":13738,"id":250425,"goal":"predicate SubsetOf_13738(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_13739","instance":13739,"id":250426,"goal":"predicate AllMem_13739(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_13740","instance":13740,"id":250427,"goal":"predicate DisjointSets_13740(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_13741","instance":13741,"id":250428,"goal":"predicate Sorted_13741(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_13742","instance":13742,"id":250429,"goal":"predicate AllPositive_13742(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_13743","instance":13743,"id":250430,"goal":"predicate DistinctSeq_13743(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_13744","instance":13744,"id":250431,"goal":"predicate IsSubseq_13744(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_13745","instance":13745,"id":250432,"goal":"predicate IsPermutation_13745(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_13746","instance":13746,"id":250433,"goal":"predicate IsEven_13746(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_13747","instance":13747,"id":250434,"goal":"predicate InRange_13747(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_13748","instance":13748,"id":250435,"goal":"predicate SubsetOf_13748(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_13749","instance":13749,"id":250436,"goal":"predicate AllMem_13749(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_13750","instance":13750,"id":250437,"goal":"predicate DisjointSets_13750(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_13751","instance":13751,"id":250438,"goal":"predicate Sorted_13751(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_13752","instance":13752,"id":250439,"goal":"predicate AllPositive_13752(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_13753","instance":13753,"id":250440,"goal":"predicate DistinctSeq_13753(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_13754","instance":13754,"id":250441,"goal":"predicate IsSubseq_13754(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_13755","instance":13755,"id":250442,"goal":"predicate IsPermutation_13755(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_13756","instance":13756,"id":250443,"goal":"predicate IsEven_13756(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_13757","instance":13757,"id":250444,"goal":"predicate InRange_13757(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_13758","instance":13758,"id":250445,"goal":"predicate SubsetOf_13758(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_13759","instance":13759,"id":250446,"goal":"predicate AllMem_13759(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_13760","instance":13760,"id":250447,"goal":"predicate DisjointSets_13760(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_13761","instance":13761,"id":250448,"goal":"predicate Sorted_13761(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_13762","instance":13762,"id":250449,"goal":"predicate AllPositive_13762(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_13763","instance":13763,"id":250450,"goal":"predicate DistinctSeq_13763(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_13764","instance":13764,"id":250451,"goal":"predicate IsSubseq_13764(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_13765","instance":13765,"id":250452,"goal":"predicate IsPermutation_13765(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_13766","instance":13766,"id":250453,"goal":"predicate IsEven_13766(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_13767","instance":13767,"id":250454,"goal":"predicate InRange_13767(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_13768","instance":13768,"id":250455,"goal":"predicate SubsetOf_13768(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_13769","instance":13769,"id":250456,"goal":"predicate AllMem_13769(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_13770","instance":13770,"id":250457,"goal":"predicate DisjointSets_13770(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_13771","instance":13771,"id":250458,"goal":"predicate Sorted_13771(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_13772","instance":13772,"id":250459,"goal":"predicate AllPositive_13772(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_13773","instance":13773,"id":250460,"goal":"predicate DistinctSeq_13773(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_13774","instance":13774,"id":250461,"goal":"predicate IsSubseq_13774(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_13775","instance":13775,"id":250462,"goal":"predicate IsPermutation_13775(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_13776","instance":13776,"id":250463,"goal":"predicate IsEven_13776(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_13777","instance":13777,"id":250464,"goal":"predicate InRange_13777(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_13778","instance":13778,"id":250465,"goal":"predicate SubsetOf_13778(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_13779","instance":13779,"id":250466,"goal":"predicate AllMem_13779(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_13780","instance":13780,"id":250467,"goal":"predicate DisjointSets_13780(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_13781","instance":13781,"id":250468,"goal":"predicate Sorted_13781(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_13782","instance":13782,"id":250469,"goal":"predicate AllPositive_13782(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_13783","instance":13783,"id":250470,"goal":"predicate DistinctSeq_13783(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_13784","instance":13784,"id":250471,"goal":"predicate IsSubseq_13784(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_13785","instance":13785,"id":250472,"goal":"predicate IsPermutation_13785(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_13786","instance":13786,"id":250473,"goal":"predicate IsEven_13786(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_13787","instance":13787,"id":250474,"goal":"predicate InRange_13787(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_13788","instance":13788,"id":250475,"goal":"predicate SubsetOf_13788(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_13789","instance":13789,"id":250476,"goal":"predicate AllMem_13789(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_13790","instance":13790,"id":250477,"goal":"predicate DisjointSets_13790(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_13791","instance":13791,"id":250478,"goal":"predicate Sorted_13791(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_13792","instance":13792,"id":250479,"goal":"predicate AllPositive_13792(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_13793","instance":13793,"id":250480,"goal":"predicate DistinctSeq_13793(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_13794","instance":13794,"id":250481,"goal":"predicate IsSubseq_13794(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_13795","instance":13795,"id":250482,"goal":"predicate IsPermutation_13795(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_13796","instance":13796,"id":250483,"goal":"predicate IsEven_13796(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_13797","instance":13797,"id":250484,"goal":"predicate InRange_13797(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_13798","instance":13798,"id":250485,"goal":"predicate SubsetOf_13798(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_13799","instance":13799,"id":250486,"goal":"predicate AllMem_13799(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_13800","instance":13800,"id":250487,"goal":"predicate DisjointSets_13800(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_13801","instance":13801,"id":250488,"goal":"predicate Sorted_13801(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_13802","instance":13802,"id":250489,"goal":"predicate AllPositive_13802(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_13803","instance":13803,"id":250490,"goal":"predicate DistinctSeq_13803(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_13804","instance":13804,"id":250491,"goal":"predicate IsSubseq_13804(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_13805","instance":13805,"id":250492,"goal":"predicate IsPermutation_13805(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_13806","instance":13806,"id":250493,"goal":"predicate IsEven_13806(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_13807","instance":13807,"id":250494,"goal":"predicate InRange_13807(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_13808","instance":13808,"id":250495,"goal":"predicate SubsetOf_13808(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_13809","instance":13809,"id":250496,"goal":"predicate AllMem_13809(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_13810","instance":13810,"id":250497,"goal":"predicate DisjointSets_13810(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_13811","instance":13811,"id":250498,"goal":"predicate Sorted_13811(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_13812","instance":13812,"id":250499,"goal":"predicate AllPositive_13812(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_13813","instance":13813,"id":250500,"goal":"predicate DistinctSeq_13813(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_13814","instance":13814,"id":250501,"goal":"predicate IsSubseq_13814(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_13815","instance":13815,"id":250502,"goal":"predicate IsPermutation_13815(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_13816","instance":13816,"id":250503,"goal":"predicate IsEven_13816(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_13817","instance":13817,"id":250504,"goal":"predicate InRange_13817(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_13818","instance":13818,"id":250505,"goal":"predicate SubsetOf_13818(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_13819","instance":13819,"id":250506,"goal":"predicate AllMem_13819(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_13820","instance":13820,"id":250507,"goal":"predicate DisjointSets_13820(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_13821","instance":13821,"id":250508,"goal":"predicate Sorted_13821(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_13822","instance":13822,"id":250509,"goal":"predicate AllPositive_13822(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_13823","instance":13823,"id":250510,"goal":"predicate DistinctSeq_13823(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_13824","instance":13824,"id":250511,"goal":"predicate IsSubseq_13824(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_13825","instance":13825,"id":250512,"goal":"predicate IsPermutation_13825(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_13826","instance":13826,"id":250513,"goal":"predicate IsEven_13826(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_13827","instance":13827,"id":250514,"goal":"predicate InRange_13827(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_13828","instance":13828,"id":250515,"goal":"predicate SubsetOf_13828(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_13829","instance":13829,"id":250516,"goal":"predicate AllMem_13829(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_13830","instance":13830,"id":250517,"goal":"predicate DisjointSets_13830(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_13831","instance":13831,"id":250518,"goal":"predicate Sorted_13831(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_13832","instance":13832,"id":250519,"goal":"predicate AllPositive_13832(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_13833","instance":13833,"id":250520,"goal":"predicate DistinctSeq_13833(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_13834","instance":13834,"id":250521,"goal":"predicate IsSubseq_13834(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_13835","instance":13835,"id":250522,"goal":"predicate IsPermutation_13835(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_13836","instance":13836,"id":250523,"goal":"predicate IsEven_13836(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_13837","instance":13837,"id":250524,"goal":"predicate InRange_13837(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_13838","instance":13838,"id":250525,"goal":"predicate SubsetOf_13838(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_13839","instance":13839,"id":250526,"goal":"predicate AllMem_13839(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_13840","instance":13840,"id":250527,"goal":"predicate DisjointSets_13840(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_13841","instance":13841,"id":250528,"goal":"predicate Sorted_13841(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_13842","instance":13842,"id":250529,"goal":"predicate AllPositive_13842(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_13843","instance":13843,"id":250530,"goal":"predicate DistinctSeq_13843(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_13844","instance":13844,"id":250531,"goal":"predicate IsSubseq_13844(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_13845","instance":13845,"id":250532,"goal":"predicate IsPermutation_13845(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_13846","instance":13846,"id":250533,"goal":"predicate IsEven_13846(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_13847","instance":13847,"id":250534,"goal":"predicate InRange_13847(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_13848","instance":13848,"id":250535,"goal":"predicate SubsetOf_13848(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_13849","instance":13849,"id":250536,"goal":"predicate AllMem_13849(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_13850","instance":13850,"id":250537,"goal":"predicate DisjointSets_13850(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_13851","instance":13851,"id":250538,"goal":"predicate Sorted_13851(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_13852","instance":13852,"id":250539,"goal":"predicate AllPositive_13852(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_13853","instance":13853,"id":250540,"goal":"predicate DistinctSeq_13853(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_13854","instance":13854,"id":250541,"goal":"predicate IsSubseq_13854(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_13855","instance":13855,"id":250542,"goal":"predicate IsPermutation_13855(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_13856","instance":13856,"id":250543,"goal":"predicate IsEven_13856(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_13857","instance":13857,"id":250544,"goal":"predicate InRange_13857(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_13858","instance":13858,"id":250545,"goal":"predicate SubsetOf_13858(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_13859","instance":13859,"id":250546,"goal":"predicate AllMem_13859(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_13860","instance":13860,"id":250547,"goal":"predicate DisjointSets_13860(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_13861","instance":13861,"id":250548,"goal":"predicate Sorted_13861(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_13862","instance":13862,"id":250549,"goal":"predicate AllPositive_13862(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_13863","instance":13863,"id":250550,"goal":"predicate DistinctSeq_13863(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_13864","instance":13864,"id":250551,"goal":"predicate IsSubseq_13864(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_13865","instance":13865,"id":250552,"goal":"predicate IsPermutation_13865(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_13866","instance":13866,"id":250553,"goal":"predicate IsEven_13866(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_13867","instance":13867,"id":250554,"goal":"predicate InRange_13867(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_13868","instance":13868,"id":250555,"goal":"predicate SubsetOf_13868(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_13869","instance":13869,"id":250556,"goal":"predicate AllMem_13869(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_13870","instance":13870,"id":250557,"goal":"predicate DisjointSets_13870(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_13871","instance":13871,"id":250558,"goal":"predicate Sorted_13871(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_13872","instance":13872,"id":250559,"goal":"predicate AllPositive_13872(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_13873","instance":13873,"id":250560,"goal":"predicate DistinctSeq_13873(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_13874","instance":13874,"id":250561,"goal":"predicate IsSubseq_13874(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_13875","instance":13875,"id":250562,"goal":"predicate IsPermutation_13875(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_13876","instance":13876,"id":250563,"goal":"predicate IsEven_13876(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_13877","instance":13877,"id":250564,"goal":"predicate InRange_13877(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_13878","instance":13878,"id":250565,"goal":"predicate SubsetOf_13878(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_13879","instance":13879,"id":250566,"goal":"predicate AllMem_13879(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_13880","instance":13880,"id":250567,"goal":"predicate DisjointSets_13880(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_13881","instance":13881,"id":250568,"goal":"predicate Sorted_13881(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_13882","instance":13882,"id":250569,"goal":"predicate AllPositive_13882(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_13883","instance":13883,"id":250570,"goal":"predicate DistinctSeq_13883(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_13884","instance":13884,"id":250571,"goal":"predicate IsSubseq_13884(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_13885","instance":13885,"id":250572,"goal":"predicate IsPermutation_13885(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_13886","instance":13886,"id":250573,"goal":"predicate IsEven_13886(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_13887","instance":13887,"id":250574,"goal":"predicate InRange_13887(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_13888","instance":13888,"id":250575,"goal":"predicate SubsetOf_13888(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_13889","instance":13889,"id":250576,"goal":"predicate AllMem_13889(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_13890","instance":13890,"id":250577,"goal":"predicate DisjointSets_13890(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_13891","instance":13891,"id":250578,"goal":"predicate Sorted_13891(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_13892","instance":13892,"id":250579,"goal":"predicate AllPositive_13892(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_13893","instance":13893,"id":250580,"goal":"predicate DistinctSeq_13893(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_13894","instance":13894,"id":250581,"goal":"predicate IsSubseq_13894(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_13895","instance":13895,"id":250582,"goal":"predicate IsPermutation_13895(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_13896","instance":13896,"id":250583,"goal":"predicate IsEven_13896(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_13897","instance":13897,"id":250584,"goal":"predicate InRange_13897(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_13898","instance":13898,"id":250585,"goal":"predicate SubsetOf_13898(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_13899","instance":13899,"id":250586,"goal":"predicate AllMem_13899(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_13900","instance":13900,"id":250587,"goal":"predicate DisjointSets_13900(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_13901","instance":13901,"id":250588,"goal":"predicate Sorted_13901(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_13902","instance":13902,"id":250589,"goal":"predicate AllPositive_13902(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_13903","instance":13903,"id":250590,"goal":"predicate DistinctSeq_13903(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_13904","instance":13904,"id":250591,"goal":"predicate IsSubseq_13904(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_13905","instance":13905,"id":250592,"goal":"predicate IsPermutation_13905(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_13906","instance":13906,"id":250593,"goal":"predicate IsEven_13906(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_13907","instance":13907,"id":250594,"goal":"predicate InRange_13907(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_13908","instance":13908,"id":250595,"goal":"predicate SubsetOf_13908(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_13909","instance":13909,"id":250596,"goal":"predicate AllMem_13909(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_13910","instance":13910,"id":250597,"goal":"predicate DisjointSets_13910(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_13911","instance":13911,"id":250598,"goal":"predicate Sorted_13911(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_13912","instance":13912,"id":250599,"goal":"predicate AllPositive_13912(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_13913","instance":13913,"id":250600,"goal":"predicate DistinctSeq_13913(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_13914","instance":13914,"id":250601,"goal":"predicate IsSubseq_13914(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_13915","instance":13915,"id":250602,"goal":"predicate IsPermutation_13915(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_13916","instance":13916,"id":250603,"goal":"predicate IsEven_13916(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_13917","instance":13917,"id":250604,"goal":"predicate InRange_13917(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_13918","instance":13918,"id":250605,"goal":"predicate SubsetOf_13918(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_13919","instance":13919,"id":250606,"goal":"predicate AllMem_13919(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_13920","instance":13920,"id":250607,"goal":"predicate DisjointSets_13920(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_13921","instance":13921,"id":250608,"goal":"predicate Sorted_13921(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_13922","instance":13922,"id":250609,"goal":"predicate AllPositive_13922(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_13923","instance":13923,"id":250610,"goal":"predicate DistinctSeq_13923(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_13924","instance":13924,"id":250611,"goal":"predicate IsSubseq_13924(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_13925","instance":13925,"id":250612,"goal":"predicate IsPermutation_13925(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_13926","instance":13926,"id":250613,"goal":"predicate IsEven_13926(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_13927","instance":13927,"id":250614,"goal":"predicate InRange_13927(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_13928","instance":13928,"id":250615,"goal":"predicate SubsetOf_13928(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_13929","instance":13929,"id":250616,"goal":"predicate AllMem_13929(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_13930","instance":13930,"id":250617,"goal":"predicate DisjointSets_13930(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_13931","instance":13931,"id":250618,"goal":"predicate Sorted_13931(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_13932","instance":13932,"id":250619,"goal":"predicate AllPositive_13932(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_13933","instance":13933,"id":250620,"goal":"predicate DistinctSeq_13933(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_13934","instance":13934,"id":250621,"goal":"predicate IsSubseq_13934(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_13935","instance":13935,"id":250622,"goal":"predicate IsPermutation_13935(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_13936","instance":13936,"id":250623,"goal":"predicate IsEven_13936(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_13937","instance":13937,"id":250624,"goal":"predicate InRange_13937(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_13938","instance":13938,"id":250625,"goal":"predicate SubsetOf_13938(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_13939","instance":13939,"id":250626,"goal":"predicate AllMem_13939(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_13940","instance":13940,"id":250627,"goal":"predicate DisjointSets_13940(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_13941","instance":13941,"id":250628,"goal":"predicate Sorted_13941(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_13942","instance":13942,"id":250629,"goal":"predicate AllPositive_13942(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_13943","instance":13943,"id":250630,"goal":"predicate DistinctSeq_13943(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_13944","instance":13944,"id":250631,"goal":"predicate IsSubseq_13944(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_13945","instance":13945,"id":250632,"goal":"predicate IsPermutation_13945(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_13946","instance":13946,"id":250633,"goal":"predicate IsEven_13946(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_13947","instance":13947,"id":250634,"goal":"predicate InRange_13947(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_13948","instance":13948,"id":250635,"goal":"predicate SubsetOf_13948(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_13949","instance":13949,"id":250636,"goal":"predicate AllMem_13949(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_13950","instance":13950,"id":250637,"goal":"predicate DisjointSets_13950(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_13951","instance":13951,"id":250638,"goal":"predicate Sorted_13951(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_13952","instance":13952,"id":250639,"goal":"predicate AllPositive_13952(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_13953","instance":13953,"id":250640,"goal":"predicate DistinctSeq_13953(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_13954","instance":13954,"id":250641,"goal":"predicate IsSubseq_13954(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_13955","instance":13955,"id":250642,"goal":"predicate IsPermutation_13955(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_13956","instance":13956,"id":250643,"goal":"predicate IsEven_13956(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_13957","instance":13957,"id":250644,"goal":"predicate InRange_13957(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_13958","instance":13958,"id":250645,"goal":"predicate SubsetOf_13958(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_13959","instance":13959,"id":250646,"goal":"predicate AllMem_13959(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_13960","instance":13960,"id":250647,"goal":"predicate DisjointSets_13960(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_13961","instance":13961,"id":250648,"goal":"predicate Sorted_13961(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_13962","instance":13962,"id":250649,"goal":"predicate AllPositive_13962(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_13963","instance":13963,"id":250650,"goal":"predicate DistinctSeq_13963(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_13964","instance":13964,"id":250651,"goal":"predicate IsSubseq_13964(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_13965","instance":13965,"id":250652,"goal":"predicate IsPermutation_13965(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_13966","instance":13966,"id":250653,"goal":"predicate IsEven_13966(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_13967","instance":13967,"id":250654,"goal":"predicate InRange_13967(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_13968","instance":13968,"id":250655,"goal":"predicate SubsetOf_13968(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_13969","instance":13969,"id":250656,"goal":"predicate AllMem_13969(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_13970","instance":13970,"id":250657,"goal":"predicate DisjointSets_13970(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_13971","instance":13971,"id":250658,"goal":"predicate Sorted_13971(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_13972","instance":13972,"id":250659,"goal":"predicate AllPositive_13972(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_13973","instance":13973,"id":250660,"goal":"predicate DistinctSeq_13973(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_13974","instance":13974,"id":250661,"goal":"predicate IsSubseq_13974(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_13975","instance":13975,"id":250662,"goal":"predicate IsPermutation_13975(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_13976","instance":13976,"id":250663,"goal":"predicate IsEven_13976(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_13977","instance":13977,"id":250664,"goal":"predicate InRange_13977(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_13978","instance":13978,"id":250665,"goal":"predicate SubsetOf_13978(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_13979","instance":13979,"id":250666,"goal":"predicate AllMem_13979(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_13980","instance":13980,"id":250667,"goal":"predicate DisjointSets_13980(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_13981","instance":13981,"id":250668,"goal":"predicate Sorted_13981(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_13982","instance":13982,"id":250669,"goal":"predicate AllPositive_13982(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_13983","instance":13983,"id":250670,"goal":"predicate DistinctSeq_13983(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_13984","instance":13984,"id":250671,"goal":"predicate IsSubseq_13984(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_13985","instance":13985,"id":250672,"goal":"predicate IsPermutation_13985(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_13986","instance":13986,"id":250673,"goal":"predicate IsEven_13986(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_13987","instance":13987,"id":250674,"goal":"predicate InRange_13987(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_13988","instance":13988,"id":250675,"goal":"predicate SubsetOf_13988(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_13989","instance":13989,"id":250676,"goal":"predicate AllMem_13989(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_13990","instance":13990,"id":250677,"goal":"predicate DisjointSets_13990(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_13991","instance":13991,"id":250678,"goal":"predicate Sorted_13991(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_13992","instance":13992,"id":250679,"goal":"predicate AllPositive_13992(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_13993","instance":13993,"id":250680,"goal":"predicate DistinctSeq_13993(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_13994","instance":13994,"id":250681,"goal":"predicate IsSubseq_13994(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_13995","instance":13995,"id":250682,"goal":"predicate IsPermutation_13995(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_13996","instance":13996,"id":250683,"goal":"predicate IsEven_13996(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_13997","instance":13997,"id":250684,"goal":"predicate InRange_13997(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_13998","instance":13998,"id":250685,"goal":"predicate SubsetOf_13998(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_13999","instance":13999,"id":250686,"goal":"predicate AllMem_13999(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_14000","instance":14000,"id":250687,"goal":"predicate DisjointSets_14000(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_14001","instance":14001,"id":250688,"goal":"predicate Sorted_14001(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_14002","instance":14002,"id":250689,"goal":"predicate AllPositive_14002(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_14003","instance":14003,"id":250690,"goal":"predicate DistinctSeq_14003(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_14004","instance":14004,"id":250691,"goal":"predicate IsSubseq_14004(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_14005","instance":14005,"id":250692,"goal":"predicate IsPermutation_14005(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_14006","instance":14006,"id":250693,"goal":"predicate IsEven_14006(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_14007","instance":14007,"id":250694,"goal":"predicate InRange_14007(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_14008","instance":14008,"id":250695,"goal":"predicate SubsetOf_14008(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_14009","instance":14009,"id":250696,"goal":"predicate AllMem_14009(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_14010","instance":14010,"id":250697,"goal":"predicate DisjointSets_14010(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_14011","instance":14011,"id":250698,"goal":"predicate Sorted_14011(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_14012","instance":14012,"id":250699,"goal":"predicate AllPositive_14012(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_14013","instance":14013,"id":250700,"goal":"predicate DistinctSeq_14013(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_14014","instance":14014,"id":250701,"goal":"predicate IsSubseq_14014(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_14015","instance":14015,"id":250702,"goal":"predicate IsPermutation_14015(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_14016","instance":14016,"id":250703,"goal":"predicate IsEven_14016(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_14017","instance":14017,"id":250704,"goal":"predicate InRange_14017(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_14018","instance":14018,"id":250705,"goal":"predicate SubsetOf_14018(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_14019","instance":14019,"id":250706,"goal":"predicate AllMem_14019(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_14020","instance":14020,"id":250707,"goal":"predicate DisjointSets_14020(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_14021","instance":14021,"id":250708,"goal":"predicate Sorted_14021(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_14022","instance":14022,"id":250709,"goal":"predicate AllPositive_14022(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_14023","instance":14023,"id":250710,"goal":"predicate DistinctSeq_14023(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_14024","instance":14024,"id":250711,"goal":"predicate IsSubseq_14024(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_14025","instance":14025,"id":250712,"goal":"predicate IsPermutation_14025(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_14026","instance":14026,"id":250713,"goal":"predicate IsEven_14026(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_14027","instance":14027,"id":250714,"goal":"predicate InRange_14027(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_14028","instance":14028,"id":250715,"goal":"predicate SubsetOf_14028(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_14029","instance":14029,"id":250716,"goal":"predicate AllMem_14029(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_14030","instance":14030,"id":250717,"goal":"predicate DisjointSets_14030(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_14031","instance":14031,"id":250718,"goal":"predicate Sorted_14031(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_14032","instance":14032,"id":250719,"goal":"predicate AllPositive_14032(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_14033","instance":14033,"id":250720,"goal":"predicate DistinctSeq_14033(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_14034","instance":14034,"id":250721,"goal":"predicate IsSubseq_14034(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_14035","instance":14035,"id":250722,"goal":"predicate IsPermutation_14035(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_14036","instance":14036,"id":250723,"goal":"predicate IsEven_14036(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_14037","instance":14037,"id":250724,"goal":"predicate InRange_14037(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_14038","instance":14038,"id":250725,"goal":"predicate SubsetOf_14038(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_14039","instance":14039,"id":250726,"goal":"predicate AllMem_14039(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_14040","instance":14040,"id":250727,"goal":"predicate DisjointSets_14040(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_14041","instance":14041,"id":250728,"goal":"predicate Sorted_14041(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_14042","instance":14042,"id":250729,"goal":"predicate AllPositive_14042(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_14043","instance":14043,"id":250730,"goal":"predicate DistinctSeq_14043(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_14044","instance":14044,"id":250731,"goal":"predicate IsSubseq_14044(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_14045","instance":14045,"id":250732,"goal":"predicate IsPermutation_14045(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_14046","instance":14046,"id":250733,"goal":"predicate IsEven_14046(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_14047","instance":14047,"id":250734,"goal":"predicate InRange_14047(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_14048","instance":14048,"id":250735,"goal":"predicate SubsetOf_14048(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_14049","instance":14049,"id":250736,"goal":"predicate AllMem_14049(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_14050","instance":14050,"id":250737,"goal":"predicate DisjointSets_14050(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_14051","instance":14051,"id":250738,"goal":"predicate Sorted_14051(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_14052","instance":14052,"id":250739,"goal":"predicate AllPositive_14052(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_14053","instance":14053,"id":250740,"goal":"predicate DistinctSeq_14053(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_14054","instance":14054,"id":250741,"goal":"predicate IsSubseq_14054(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_14055","instance":14055,"id":250742,"goal":"predicate IsPermutation_14055(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_14056","instance":14056,"id":250743,"goal":"predicate IsEven_14056(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_14057","instance":14057,"id":250744,"goal":"predicate InRange_14057(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_14058","instance":14058,"id":250745,"goal":"predicate SubsetOf_14058(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_14059","instance":14059,"id":250746,"goal":"predicate AllMem_14059(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_14060","instance":14060,"id":250747,"goal":"predicate DisjointSets_14060(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_14061","instance":14061,"id":250748,"goal":"predicate Sorted_14061(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_14062","instance":14062,"id":250749,"goal":"predicate AllPositive_14062(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_14063","instance":14063,"id":250750,"goal":"predicate DistinctSeq_14063(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_14064","instance":14064,"id":250751,"goal":"predicate IsSubseq_14064(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_14065","instance":14065,"id":250752,"goal":"predicate IsPermutation_14065(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_14066","instance":14066,"id":250753,"goal":"predicate IsEven_14066(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_14067","instance":14067,"id":250754,"goal":"predicate InRange_14067(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_14068","instance":14068,"id":250755,"goal":"predicate SubsetOf_14068(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_14069","instance":14069,"id":250756,"goal":"predicate AllMem_14069(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_14070","instance":14070,"id":250757,"goal":"predicate DisjointSets_14070(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_14071","instance":14071,"id":250758,"goal":"predicate Sorted_14071(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_14072","instance":14072,"id":250759,"goal":"predicate AllPositive_14072(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_14073","instance":14073,"id":250760,"goal":"predicate DistinctSeq_14073(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_14074","instance":14074,"id":250761,"goal":"predicate IsSubseq_14074(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_14075","instance":14075,"id":250762,"goal":"predicate IsPermutation_14075(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_14076","instance":14076,"id":250763,"goal":"predicate IsEven_14076(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_14077","instance":14077,"id":250764,"goal":"predicate InRange_14077(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_14078","instance":14078,"id":250765,"goal":"predicate SubsetOf_14078(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_14079","instance":14079,"id":250766,"goal":"predicate AllMem_14079(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_14080","instance":14080,"id":250767,"goal":"predicate DisjointSets_14080(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_14081","instance":14081,"id":250768,"goal":"predicate Sorted_14081(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_14082","instance":14082,"id":250769,"goal":"predicate AllPositive_14082(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_14083","instance":14083,"id":250770,"goal":"predicate DistinctSeq_14083(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_14084","instance":14084,"id":250771,"goal":"predicate IsSubseq_14084(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_14085","instance":14085,"id":250772,"goal":"predicate IsPermutation_14085(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_14086","instance":14086,"id":250773,"goal":"predicate IsEven_14086(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_14087","instance":14087,"id":250774,"goal":"predicate InRange_14087(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_14088","instance":14088,"id":250775,"goal":"predicate SubsetOf_14088(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_14089","instance":14089,"id":250776,"goal":"predicate AllMem_14089(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_14090","instance":14090,"id":250777,"goal":"predicate DisjointSets_14090(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_14091","instance":14091,"id":250778,"goal":"predicate Sorted_14091(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_14092","instance":14092,"id":250779,"goal":"predicate AllPositive_14092(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_14093","instance":14093,"id":250780,"goal":"predicate DistinctSeq_14093(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_14094","instance":14094,"id":250781,"goal":"predicate IsSubseq_14094(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_14095","instance":14095,"id":250782,"goal":"predicate IsPermutation_14095(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_14096","instance":14096,"id":250783,"goal":"predicate IsEven_14096(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_14097","instance":14097,"id":250784,"goal":"predicate InRange_14097(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_14098","instance":14098,"id":250785,"goal":"predicate SubsetOf_14098(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_14099","instance":14099,"id":250786,"goal":"predicate AllMem_14099(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_14100","instance":14100,"id":250787,"goal":"predicate DisjointSets_14100(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_14101","instance":14101,"id":250788,"goal":"predicate Sorted_14101(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_14102","instance":14102,"id":250789,"goal":"predicate AllPositive_14102(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_14103","instance":14103,"id":250790,"goal":"predicate DistinctSeq_14103(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_14104","instance":14104,"id":250791,"goal":"predicate IsSubseq_14104(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_14105","instance":14105,"id":250792,"goal":"predicate IsPermutation_14105(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_14106","instance":14106,"id":250793,"goal":"predicate IsEven_14106(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_14107","instance":14107,"id":250794,"goal":"predicate InRange_14107(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_14108","instance":14108,"id":250795,"goal":"predicate SubsetOf_14108(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_14109","instance":14109,"id":250796,"goal":"predicate AllMem_14109(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_14110","instance":14110,"id":250797,"goal":"predicate DisjointSets_14110(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_14111","instance":14111,"id":250798,"goal":"predicate Sorted_14111(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_14112","instance":14112,"id":250799,"goal":"predicate AllPositive_14112(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_14113","instance":14113,"id":250800,"goal":"predicate DistinctSeq_14113(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_14114","instance":14114,"id":250801,"goal":"predicate IsSubseq_14114(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_14115","instance":14115,"id":250802,"goal":"predicate IsPermutation_14115(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_14116","instance":14116,"id":250803,"goal":"predicate IsEven_14116(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_14117","instance":14117,"id":250804,"goal":"predicate InRange_14117(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_14118","instance":14118,"id":250805,"goal":"predicate SubsetOf_14118(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_14119","instance":14119,"id":250806,"goal":"predicate AllMem_14119(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_14120","instance":14120,"id":250807,"goal":"predicate DisjointSets_14120(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_14121","instance":14121,"id":250808,"goal":"predicate Sorted_14121(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_14122","instance":14122,"id":250809,"goal":"predicate AllPositive_14122(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_14123","instance":14123,"id":250810,"goal":"predicate DistinctSeq_14123(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_14124","instance":14124,"id":250811,"goal":"predicate IsSubseq_14124(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_14125","instance":14125,"id":250812,"goal":"predicate IsPermutation_14125(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_14126","instance":14126,"id":250813,"goal":"predicate IsEven_14126(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_14127","instance":14127,"id":250814,"goal":"predicate InRange_14127(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_14128","instance":14128,"id":250815,"goal":"predicate SubsetOf_14128(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_14129","instance":14129,"id":250816,"goal":"predicate AllMem_14129(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_14130","instance":14130,"id":250817,"goal":"predicate DisjointSets_14130(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_14131","instance":14131,"id":250818,"goal":"predicate Sorted_14131(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_14132","instance":14132,"id":250819,"goal":"predicate AllPositive_14132(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_14133","instance":14133,"id":250820,"goal":"predicate DistinctSeq_14133(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_14134","instance":14134,"id":250821,"goal":"predicate IsSubseq_14134(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_14135","instance":14135,"id":250822,"goal":"predicate IsPermutation_14135(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_14136","instance":14136,"id":250823,"goal":"predicate IsEven_14136(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_14137","instance":14137,"id":250824,"goal":"predicate InRange_14137(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_14138","instance":14138,"id":250825,"goal":"predicate SubsetOf_14138(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_14139","instance":14139,"id":250826,"goal":"predicate AllMem_14139(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_14140","instance":14140,"id":250827,"goal":"predicate DisjointSets_14140(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_14141","instance":14141,"id":250828,"goal":"predicate Sorted_14141(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_14142","instance":14142,"id":250829,"goal":"predicate AllPositive_14142(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_14143","instance":14143,"id":250830,"goal":"predicate DistinctSeq_14143(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_14144","instance":14144,"id":250831,"goal":"predicate IsSubseq_14144(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_14145","instance":14145,"id":250832,"goal":"predicate IsPermutation_14145(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_14146","instance":14146,"id":250833,"goal":"predicate IsEven_14146(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_14147","instance":14147,"id":250834,"goal":"predicate InRange_14147(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_14148","instance":14148,"id":250835,"goal":"predicate SubsetOf_14148(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_14149","instance":14149,"id":250836,"goal":"predicate AllMem_14149(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_14150","instance":14150,"id":250837,"goal":"predicate DisjointSets_14150(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_14151","instance":14151,"id":250838,"goal":"predicate Sorted_14151(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_14152","instance":14152,"id":250839,"goal":"predicate AllPositive_14152(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_14153","instance":14153,"id":250840,"goal":"predicate DistinctSeq_14153(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_14154","instance":14154,"id":250841,"goal":"predicate IsSubseq_14154(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_14155","instance":14155,"id":250842,"goal":"predicate IsPermutation_14155(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_14156","instance":14156,"id":250843,"goal":"predicate IsEven_14156(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_14157","instance":14157,"id":250844,"goal":"predicate InRange_14157(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_14158","instance":14158,"id":250845,"goal":"predicate SubsetOf_14158(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_14159","instance":14159,"id":250846,"goal":"predicate AllMem_14159(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_14160","instance":14160,"id":250847,"goal":"predicate DisjointSets_14160(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_14161","instance":14161,"id":250848,"goal":"predicate Sorted_14161(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_14162","instance":14162,"id":250849,"goal":"predicate AllPositive_14162(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_14163","instance":14163,"id":250850,"goal":"predicate DistinctSeq_14163(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_14164","instance":14164,"id":250851,"goal":"predicate IsSubseq_14164(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_14165","instance":14165,"id":250852,"goal":"predicate IsPermutation_14165(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_14166","instance":14166,"id":250853,"goal":"predicate IsEven_14166(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_14167","instance":14167,"id":250854,"goal":"predicate InRange_14167(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_14168","instance":14168,"id":250855,"goal":"predicate SubsetOf_14168(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_14169","instance":14169,"id":250856,"goal":"predicate AllMem_14169(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_14170","instance":14170,"id":250857,"goal":"predicate DisjointSets_14170(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_14171","instance":14171,"id":250858,"goal":"predicate Sorted_14171(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_14172","instance":14172,"id":250859,"goal":"predicate AllPositive_14172(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_14173","instance":14173,"id":250860,"goal":"predicate DistinctSeq_14173(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_14174","instance":14174,"id":250861,"goal":"predicate IsSubseq_14174(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_14175","instance":14175,"id":250862,"goal":"predicate IsPermutation_14175(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_14176","instance":14176,"id":250863,"goal":"predicate IsEven_14176(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_14177","instance":14177,"id":250864,"goal":"predicate InRange_14177(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_14178","instance":14178,"id":250865,"goal":"predicate SubsetOf_14178(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_14179","instance":14179,"id":250866,"goal":"predicate AllMem_14179(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_14180","instance":14180,"id":250867,"goal":"predicate DisjointSets_14180(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_14181","instance":14181,"id":250868,"goal":"predicate Sorted_14181(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_14182","instance":14182,"id":250869,"goal":"predicate AllPositive_14182(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_14183","instance":14183,"id":250870,"goal":"predicate DistinctSeq_14183(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_14184","instance":14184,"id":250871,"goal":"predicate IsSubseq_14184(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_14185","instance":14185,"id":250872,"goal":"predicate IsPermutation_14185(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_14186","instance":14186,"id":250873,"goal":"predicate IsEven_14186(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_14187","instance":14187,"id":250874,"goal":"predicate InRange_14187(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_14188","instance":14188,"id":250875,"goal":"predicate SubsetOf_14188(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_14189","instance":14189,"id":250876,"goal":"predicate AllMem_14189(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_14190","instance":14190,"id":250877,"goal":"predicate DisjointSets_14190(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_14191","instance":14191,"id":250878,"goal":"predicate Sorted_14191(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_14192","instance":14192,"id":250879,"goal":"predicate AllPositive_14192(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_14193","instance":14193,"id":250880,"goal":"predicate DistinctSeq_14193(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_14194","instance":14194,"id":250881,"goal":"predicate IsSubseq_14194(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_14195","instance":14195,"id":250882,"goal":"predicate IsPermutation_14195(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_14196","instance":14196,"id":250883,"goal":"predicate IsEven_14196(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_14197","instance":14197,"id":250884,"goal":"predicate InRange_14197(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_14198","instance":14198,"id":250885,"goal":"predicate SubsetOf_14198(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_14199","instance":14199,"id":250886,"goal":"predicate AllMem_14199(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_14200","instance":14200,"id":250887,"goal":"predicate DisjointSets_14200(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_14201","instance":14201,"id":250888,"goal":"predicate Sorted_14201(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_14202","instance":14202,"id":250889,"goal":"predicate AllPositive_14202(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_14203","instance":14203,"id":250890,"goal":"predicate DistinctSeq_14203(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_14204","instance":14204,"id":250891,"goal":"predicate IsSubseq_14204(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_14205","instance":14205,"id":250892,"goal":"predicate IsPermutation_14205(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_14206","instance":14206,"id":250893,"goal":"predicate IsEven_14206(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_14207","instance":14207,"id":250894,"goal":"predicate InRange_14207(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_14208","instance":14208,"id":250895,"goal":"predicate SubsetOf_14208(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_14209","instance":14209,"id":250896,"goal":"predicate AllMem_14209(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_14210","instance":14210,"id":250897,"goal":"predicate DisjointSets_14210(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_14211","instance":14211,"id":250898,"goal":"predicate Sorted_14211(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_14212","instance":14212,"id":250899,"goal":"predicate AllPositive_14212(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_14213","instance":14213,"id":250900,"goal":"predicate DistinctSeq_14213(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_14214","instance":14214,"id":250901,"goal":"predicate IsSubseq_14214(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_14215","instance":14215,"id":250902,"goal":"predicate IsPermutation_14215(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_14216","instance":14216,"id":250903,"goal":"predicate IsEven_14216(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_14217","instance":14217,"id":250904,"goal":"predicate InRange_14217(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_14218","instance":14218,"id":250905,"goal":"predicate SubsetOf_14218(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_14219","instance":14219,"id":250906,"goal":"predicate AllMem_14219(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_14220","instance":14220,"id":250907,"goal":"predicate DisjointSets_14220(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_14221","instance":14221,"id":250908,"goal":"predicate Sorted_14221(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_14222","instance":14222,"id":250909,"goal":"predicate AllPositive_14222(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_14223","instance":14223,"id":250910,"goal":"predicate DistinctSeq_14223(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_14224","instance":14224,"id":250911,"goal":"predicate IsSubseq_14224(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_14225","instance":14225,"id":250912,"goal":"predicate IsPermutation_14225(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_14226","instance":14226,"id":250913,"goal":"predicate IsEven_14226(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_14227","instance":14227,"id":250914,"goal":"predicate InRange_14227(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_14228","instance":14228,"id":250915,"goal":"predicate SubsetOf_14228(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_14229","instance":14229,"id":250916,"goal":"predicate AllMem_14229(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_14230","instance":14230,"id":250917,"goal":"predicate DisjointSets_14230(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_14231","instance":14231,"id":250918,"goal":"predicate Sorted_14231(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_14232","instance":14232,"id":250919,"goal":"predicate AllPositive_14232(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_14233","instance":14233,"id":250920,"goal":"predicate DistinctSeq_14233(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_14234","instance":14234,"id":250921,"goal":"predicate IsSubseq_14234(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_14235","instance":14235,"id":250922,"goal":"predicate IsPermutation_14235(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_14236","instance":14236,"id":250923,"goal":"predicate IsEven_14236(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_14237","instance":14237,"id":250924,"goal":"predicate InRange_14237(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_14238","instance":14238,"id":250925,"goal":"predicate SubsetOf_14238(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_14239","instance":14239,"id":250926,"goal":"predicate AllMem_14239(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_14240","instance":14240,"id":250927,"goal":"predicate DisjointSets_14240(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_14241","instance":14241,"id":250928,"goal":"predicate Sorted_14241(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_14242","instance":14242,"id":250929,"goal":"predicate AllPositive_14242(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_14243","instance":14243,"id":250930,"goal":"predicate DistinctSeq_14243(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_14244","instance":14244,"id":250931,"goal":"predicate IsSubseq_14244(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_14245","instance":14245,"id":250932,"goal":"predicate IsPermutation_14245(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_14246","instance":14246,"id":250933,"goal":"predicate IsEven_14246(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_14247","instance":14247,"id":250934,"goal":"predicate InRange_14247(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_14248","instance":14248,"id":250935,"goal":"predicate SubsetOf_14248(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_14249","instance":14249,"id":250936,"goal":"predicate AllMem_14249(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_14250","instance":14250,"id":250937,"goal":"predicate DisjointSets_14250(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_14251","instance":14251,"id":250938,"goal":"predicate Sorted_14251(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_14252","instance":14252,"id":250939,"goal":"predicate AllPositive_14252(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_14253","instance":14253,"id":250940,"goal":"predicate DistinctSeq_14253(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_14254","instance":14254,"id":250941,"goal":"predicate IsSubseq_14254(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_14255","instance":14255,"id":250942,"goal":"predicate IsPermutation_14255(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_14256","instance":14256,"id":250943,"goal":"predicate IsEven_14256(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_14257","instance":14257,"id":250944,"goal":"predicate InRange_14257(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_14258","instance":14258,"id":250945,"goal":"predicate SubsetOf_14258(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_14259","instance":14259,"id":250946,"goal":"predicate AllMem_14259(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_14260","instance":14260,"id":250947,"goal":"predicate DisjointSets_14260(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_14261","instance":14261,"id":250948,"goal":"predicate Sorted_14261(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_14262","instance":14262,"id":250949,"goal":"predicate AllPositive_14262(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_14263","instance":14263,"id":250950,"goal":"predicate DistinctSeq_14263(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_14264","instance":14264,"id":250951,"goal":"predicate IsSubseq_14264(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_14265","instance":14265,"id":250952,"goal":"predicate IsPermutation_14265(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_14266","instance":14266,"id":250953,"goal":"predicate IsEven_14266(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_14267","instance":14267,"id":250954,"goal":"predicate InRange_14267(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_14268","instance":14268,"id":250955,"goal":"predicate SubsetOf_14268(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_14269","instance":14269,"id":250956,"goal":"predicate AllMem_14269(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_14270","instance":14270,"id":250957,"goal":"predicate DisjointSets_14270(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_14271","instance":14271,"id":250958,"goal":"predicate Sorted_14271(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_14272","instance":14272,"id":250959,"goal":"predicate AllPositive_14272(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_14273","instance":14273,"id":250960,"goal":"predicate DistinctSeq_14273(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_14274","instance":14274,"id":250961,"goal":"predicate IsSubseq_14274(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_14275","instance":14275,"id":250962,"goal":"predicate IsPermutation_14275(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_14276","instance":14276,"id":250963,"goal":"predicate IsEven_14276(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_14277","instance":14277,"id":250964,"goal":"predicate InRange_14277(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_14278","instance":14278,"id":250965,"goal":"predicate SubsetOf_14278(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_14279","instance":14279,"id":250966,"goal":"predicate AllMem_14279(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_14280","instance":14280,"id":250967,"goal":"predicate DisjointSets_14280(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_14281","instance":14281,"id":250968,"goal":"predicate Sorted_14281(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_14282","instance":14282,"id":250969,"goal":"predicate AllPositive_14282(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_14283","instance":14283,"id":250970,"goal":"predicate DistinctSeq_14283(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_14284","instance":14284,"id":250971,"goal":"predicate IsSubseq_14284(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_14285","instance":14285,"id":250972,"goal":"predicate IsPermutation_14285(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_14286","instance":14286,"id":250973,"goal":"predicate IsEven_14286(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_14287","instance":14287,"id":250974,"goal":"predicate InRange_14287(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_14288","instance":14288,"id":250975,"goal":"predicate SubsetOf_14288(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_14289","instance":14289,"id":250976,"goal":"predicate AllMem_14289(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_14290","instance":14290,"id":250977,"goal":"predicate DisjointSets_14290(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_14291","instance":14291,"id":250978,"goal":"predicate Sorted_14291(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_14292","instance":14292,"id":250979,"goal":"predicate AllPositive_14292(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_14293","instance":14293,"id":250980,"goal":"predicate DistinctSeq_14293(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_14294","instance":14294,"id":250981,"goal":"predicate IsSubseq_14294(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_14295","instance":14295,"id":250982,"goal":"predicate IsPermutation_14295(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_14296","instance":14296,"id":250983,"goal":"predicate IsEven_14296(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_14297","instance":14297,"id":250984,"goal":"predicate InRange_14297(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_14298","instance":14298,"id":250985,"goal":"predicate SubsetOf_14298(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_14299","instance":14299,"id":250986,"goal":"predicate AllMem_14299(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_14300","instance":14300,"id":250987,"goal":"predicate DisjointSets_14300(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_14301","instance":14301,"id":250988,"goal":"predicate Sorted_14301(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_14302","instance":14302,"id":250989,"goal":"predicate AllPositive_14302(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_14303","instance":14303,"id":250990,"goal":"predicate DistinctSeq_14303(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_14304","instance":14304,"id":250991,"goal":"predicate IsSubseq_14304(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_14305","instance":14305,"id":250992,"goal":"predicate IsPermutation_14305(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_14306","instance":14306,"id":250993,"goal":"predicate IsEven_14306(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_14307","instance":14307,"id":250994,"goal":"predicate InRange_14307(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_14308","instance":14308,"id":250995,"goal":"predicate SubsetOf_14308(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_14309","instance":14309,"id":250996,"goal":"predicate AllMem_14309(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_14310","instance":14310,"id":250997,"goal":"predicate DisjointSets_14310(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_14311","instance":14311,"id":250998,"goal":"predicate Sorted_14311(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_14312","instance":14312,"id":250999,"goal":"predicate AllPositive_14312(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_14313","instance":14313,"id":251000,"goal":"predicate DistinctSeq_14313(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_14314","instance":14314,"id":251001,"goal":"predicate IsSubseq_14314(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_14315","instance":14315,"id":251002,"goal":"predicate IsPermutation_14315(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_14316","instance":14316,"id":251003,"goal":"predicate IsEven_14316(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_14317","instance":14317,"id":251004,"goal":"predicate InRange_14317(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_14318","instance":14318,"id":251005,"goal":"predicate SubsetOf_14318(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_14319","instance":14319,"id":251006,"goal":"predicate AllMem_14319(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_14320","instance":14320,"id":251007,"goal":"predicate DisjointSets_14320(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_14321","instance":14321,"id":251008,"goal":"predicate Sorted_14321(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_14322","instance":14322,"id":251009,"goal":"predicate AllPositive_14322(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_14323","instance":14323,"id":251010,"goal":"predicate DistinctSeq_14323(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_14324","instance":14324,"id":251011,"goal":"predicate IsSubseq_14324(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_14325","instance":14325,"id":251012,"goal":"predicate IsPermutation_14325(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_14326","instance":14326,"id":251013,"goal":"predicate IsEven_14326(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_14327","instance":14327,"id":251014,"goal":"predicate InRange_14327(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_14328","instance":14328,"id":251015,"goal":"predicate SubsetOf_14328(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_14329","instance":14329,"id":251016,"goal":"predicate AllMem_14329(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_14330","instance":14330,"id":251017,"goal":"predicate DisjointSets_14330(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_14331","instance":14331,"id":251018,"goal":"predicate Sorted_14331(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_14332","instance":14332,"id":251019,"goal":"predicate AllPositive_14332(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_14333","instance":14333,"id":251020,"goal":"predicate DistinctSeq_14333(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_14334","instance":14334,"id":251021,"goal":"predicate IsSubseq_14334(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_14335","instance":14335,"id":251022,"goal":"predicate IsPermutation_14335(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_14336","instance":14336,"id":251023,"goal":"predicate IsEven_14336(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_14337","instance":14337,"id":251024,"goal":"predicate InRange_14337(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_14338","instance":14338,"id":251025,"goal":"predicate SubsetOf_14338(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_14339","instance":14339,"id":251026,"goal":"predicate AllMem_14339(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_14340","instance":14340,"id":251027,"goal":"predicate DisjointSets_14340(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_14341","instance":14341,"id":251028,"goal":"predicate Sorted_14341(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_14342","instance":14342,"id":251029,"goal":"predicate AllPositive_14342(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_14343","instance":14343,"id":251030,"goal":"predicate DistinctSeq_14343(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_14344","instance":14344,"id":251031,"goal":"predicate IsSubseq_14344(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_14345","instance":14345,"id":251032,"goal":"predicate IsPermutation_14345(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_14346","instance":14346,"id":251033,"goal":"predicate IsEven_14346(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_14347","instance":14347,"id":251034,"goal":"predicate InRange_14347(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_14348","instance":14348,"id":251035,"goal":"predicate SubsetOf_14348(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_14349","instance":14349,"id":251036,"goal":"predicate AllMem_14349(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_14350","instance":14350,"id":251037,"goal":"predicate DisjointSets_14350(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_14351","instance":14351,"id":251038,"goal":"predicate Sorted_14351(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_14352","instance":14352,"id":251039,"goal":"predicate AllPositive_14352(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_14353","instance":14353,"id":251040,"goal":"predicate DistinctSeq_14353(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_14354","instance":14354,"id":251041,"goal":"predicate IsSubseq_14354(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_14355","instance":14355,"id":251042,"goal":"predicate IsPermutation_14355(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_14356","instance":14356,"id":251043,"goal":"predicate IsEven_14356(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_14357","instance":14357,"id":251044,"goal":"predicate InRange_14357(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_14358","instance":14358,"id":251045,"goal":"predicate SubsetOf_14358(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_14359","instance":14359,"id":251046,"goal":"predicate AllMem_14359(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_14360","instance":14360,"id":251047,"goal":"predicate DisjointSets_14360(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_14361","instance":14361,"id":251048,"goal":"predicate Sorted_14361(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_14362","instance":14362,"id":251049,"goal":"predicate AllPositive_14362(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_14363","instance":14363,"id":251050,"goal":"predicate DistinctSeq_14363(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_14364","instance":14364,"id":251051,"goal":"predicate IsSubseq_14364(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_14365","instance":14365,"id":251052,"goal":"predicate IsPermutation_14365(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_14366","instance":14366,"id":251053,"goal":"predicate IsEven_14366(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_14367","instance":14367,"id":251054,"goal":"predicate InRange_14367(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_14368","instance":14368,"id":251055,"goal":"predicate SubsetOf_14368(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_14369","instance":14369,"id":251056,"goal":"predicate AllMem_14369(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_14370","instance":14370,"id":251057,"goal":"predicate DisjointSets_14370(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_14371","instance":14371,"id":251058,"goal":"predicate Sorted_14371(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_14372","instance":14372,"id":251059,"goal":"predicate AllPositive_14372(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_14373","instance":14373,"id":251060,"goal":"predicate DistinctSeq_14373(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_14374","instance":14374,"id":251061,"goal":"predicate IsSubseq_14374(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_14375","instance":14375,"id":251062,"goal":"predicate IsPermutation_14375(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_14376","instance":14376,"id":251063,"goal":"predicate IsEven_14376(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_14377","instance":14377,"id":251064,"goal":"predicate InRange_14377(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_14378","instance":14378,"id":251065,"goal":"predicate SubsetOf_14378(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_14379","instance":14379,"id":251066,"goal":"predicate AllMem_14379(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_14380","instance":14380,"id":251067,"goal":"predicate DisjointSets_14380(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_14381","instance":14381,"id":251068,"goal":"predicate Sorted_14381(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_14382","instance":14382,"id":251069,"goal":"predicate AllPositive_14382(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_14383","instance":14383,"id":251070,"goal":"predicate DistinctSeq_14383(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_14384","instance":14384,"id":251071,"goal":"predicate IsSubseq_14384(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_14385","instance":14385,"id":251072,"goal":"predicate IsPermutation_14385(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_14386","instance":14386,"id":251073,"goal":"predicate IsEven_14386(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_14387","instance":14387,"id":251074,"goal":"predicate InRange_14387(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_14388","instance":14388,"id":251075,"goal":"predicate SubsetOf_14388(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_14389","instance":14389,"id":251076,"goal":"predicate AllMem_14389(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_14390","instance":14390,"id":251077,"goal":"predicate DisjointSets_14390(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_14391","instance":14391,"id":251078,"goal":"predicate Sorted_14391(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_14392","instance":14392,"id":251079,"goal":"predicate AllPositive_14392(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_14393","instance":14393,"id":251080,"goal":"predicate DistinctSeq_14393(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_14394","instance":14394,"id":251081,"goal":"predicate IsSubseq_14394(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_14395","instance":14395,"id":251082,"goal":"predicate IsPermutation_14395(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_14396","instance":14396,"id":251083,"goal":"predicate IsEven_14396(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_14397","instance":14397,"id":251084,"goal":"predicate InRange_14397(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_14398","instance":14398,"id":251085,"goal":"predicate SubsetOf_14398(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_14399","instance":14399,"id":251086,"goal":"predicate AllMem_14399(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_14400","instance":14400,"id":251087,"goal":"predicate DisjointSets_14400(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_14401","instance":14401,"id":251088,"goal":"predicate Sorted_14401(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_14402","instance":14402,"id":251089,"goal":"predicate AllPositive_14402(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_14403","instance":14403,"id":251090,"goal":"predicate DistinctSeq_14403(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_14404","instance":14404,"id":251091,"goal":"predicate IsSubseq_14404(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_14405","instance":14405,"id":251092,"goal":"predicate IsPermutation_14405(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_14406","instance":14406,"id":251093,"goal":"predicate IsEven_14406(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_14407","instance":14407,"id":251094,"goal":"predicate InRange_14407(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_14408","instance":14408,"id":251095,"goal":"predicate SubsetOf_14408(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_14409","instance":14409,"id":251096,"goal":"predicate AllMem_14409(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_14410","instance":14410,"id":251097,"goal":"predicate DisjointSets_14410(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_14411","instance":14411,"id":251098,"goal":"predicate Sorted_14411(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_14412","instance":14412,"id":251099,"goal":"predicate AllPositive_14412(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_14413","instance":14413,"id":251100,"goal":"predicate DistinctSeq_14413(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_14414","instance":14414,"id":251101,"goal":"predicate IsSubseq_14414(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_14415","instance":14415,"id":251102,"goal":"predicate IsPermutation_14415(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_14416","instance":14416,"id":251103,"goal":"predicate IsEven_14416(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_14417","instance":14417,"id":251104,"goal":"predicate InRange_14417(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_14418","instance":14418,"id":251105,"goal":"predicate SubsetOf_14418(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_14419","instance":14419,"id":251106,"goal":"predicate AllMem_14419(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_14420","instance":14420,"id":251107,"goal":"predicate DisjointSets_14420(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_14421","instance":14421,"id":251108,"goal":"predicate Sorted_14421(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_14422","instance":14422,"id":251109,"goal":"predicate AllPositive_14422(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_14423","instance":14423,"id":251110,"goal":"predicate DistinctSeq_14423(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_14424","instance":14424,"id":251111,"goal":"predicate IsSubseq_14424(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_14425","instance":14425,"id":251112,"goal":"predicate IsPermutation_14425(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_14426","instance":14426,"id":251113,"goal":"predicate IsEven_14426(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_14427","instance":14427,"id":251114,"goal":"predicate InRange_14427(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_14428","instance":14428,"id":251115,"goal":"predicate SubsetOf_14428(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_14429","instance":14429,"id":251116,"goal":"predicate AllMem_14429(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_14430","instance":14430,"id":251117,"goal":"predicate DisjointSets_14430(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_14431","instance":14431,"id":251118,"goal":"predicate Sorted_14431(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_14432","instance":14432,"id":251119,"goal":"predicate AllPositive_14432(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_14433","instance":14433,"id":251120,"goal":"predicate DistinctSeq_14433(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_14434","instance":14434,"id":251121,"goal":"predicate IsSubseq_14434(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_14435","instance":14435,"id":251122,"goal":"predicate IsPermutation_14435(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_14436","instance":14436,"id":251123,"goal":"predicate IsEven_14436(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_14437","instance":14437,"id":251124,"goal":"predicate InRange_14437(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_14438","instance":14438,"id":251125,"goal":"predicate SubsetOf_14438(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_14439","instance":14439,"id":251126,"goal":"predicate AllMem_14439(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_14440","instance":14440,"id":251127,"goal":"predicate DisjointSets_14440(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_14441","instance":14441,"id":251128,"goal":"predicate Sorted_14441(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_14442","instance":14442,"id":251129,"goal":"predicate AllPositive_14442(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_14443","instance":14443,"id":251130,"goal":"predicate DistinctSeq_14443(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_14444","instance":14444,"id":251131,"goal":"predicate IsSubseq_14444(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_14445","instance":14445,"id":251132,"goal":"predicate IsPermutation_14445(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_14446","instance":14446,"id":251133,"goal":"predicate IsEven_14446(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_14447","instance":14447,"id":251134,"goal":"predicate InRange_14447(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_14448","instance":14448,"id":251135,"goal":"predicate SubsetOf_14448(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_14449","instance":14449,"id":251136,"goal":"predicate AllMem_14449(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_14450","instance":14450,"id":251137,"goal":"predicate DisjointSets_14450(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_14451","instance":14451,"id":251138,"goal":"predicate Sorted_14451(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_14452","instance":14452,"id":251139,"goal":"predicate AllPositive_14452(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_14453","instance":14453,"id":251140,"goal":"predicate DistinctSeq_14453(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_14454","instance":14454,"id":251141,"goal":"predicate IsSubseq_14454(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_14455","instance":14455,"id":251142,"goal":"predicate IsPermutation_14455(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_14456","instance":14456,"id":251143,"goal":"predicate IsEven_14456(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_14457","instance":14457,"id":251144,"goal":"predicate InRange_14457(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_14458","instance":14458,"id":251145,"goal":"predicate SubsetOf_14458(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_14459","instance":14459,"id":251146,"goal":"predicate AllMem_14459(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_14460","instance":14460,"id":251147,"goal":"predicate DisjointSets_14460(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_14461","instance":14461,"id":251148,"goal":"predicate Sorted_14461(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_14462","instance":14462,"id":251149,"goal":"predicate AllPositive_14462(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_14463","instance":14463,"id":251150,"goal":"predicate DistinctSeq_14463(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_14464","instance":14464,"id":251151,"goal":"predicate IsSubseq_14464(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_14465","instance":14465,"id":251152,"goal":"predicate IsPermutation_14465(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_14466","instance":14466,"id":251153,"goal":"predicate IsEven_14466(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_14467","instance":14467,"id":251154,"goal":"predicate InRange_14467(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_14468","instance":14468,"id":251155,"goal":"predicate SubsetOf_14468(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_14469","instance":14469,"id":251156,"goal":"predicate AllMem_14469(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_14470","instance":14470,"id":251157,"goal":"predicate DisjointSets_14470(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_14471","instance":14471,"id":251158,"goal":"predicate Sorted_14471(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_14472","instance":14472,"id":251159,"goal":"predicate AllPositive_14472(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_14473","instance":14473,"id":251160,"goal":"predicate DistinctSeq_14473(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_14474","instance":14474,"id":251161,"goal":"predicate IsSubseq_14474(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_14475","instance":14475,"id":251162,"goal":"predicate IsPermutation_14475(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_14476","instance":14476,"id":251163,"goal":"predicate IsEven_14476(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_14477","instance":14477,"id":251164,"goal":"predicate InRange_14477(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_14478","instance":14478,"id":251165,"goal":"predicate SubsetOf_14478(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_14479","instance":14479,"id":251166,"goal":"predicate AllMem_14479(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_14480","instance":14480,"id":251167,"goal":"predicate DisjointSets_14480(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_14481","instance":14481,"id":251168,"goal":"predicate Sorted_14481(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_14482","instance":14482,"id":251169,"goal":"predicate AllPositive_14482(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_14483","instance":14483,"id":251170,"goal":"predicate DistinctSeq_14483(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_14484","instance":14484,"id":251171,"goal":"predicate IsSubseq_14484(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_14485","instance":14485,"id":251172,"goal":"predicate IsPermutation_14485(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_14486","instance":14486,"id":251173,"goal":"predicate IsEven_14486(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_14487","instance":14487,"id":251174,"goal":"predicate InRange_14487(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_14488","instance":14488,"id":251175,"goal":"predicate SubsetOf_14488(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_14489","instance":14489,"id":251176,"goal":"predicate AllMem_14489(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_14490","instance":14490,"id":251177,"goal":"predicate DisjointSets_14490(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_14491","instance":14491,"id":251178,"goal":"predicate Sorted_14491(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_14492","instance":14492,"id":251179,"goal":"predicate AllPositive_14492(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_14493","instance":14493,"id":251180,"goal":"predicate DistinctSeq_14493(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_14494","instance":14494,"id":251181,"goal":"predicate IsSubseq_14494(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_14495","instance":14495,"id":251182,"goal":"predicate IsPermutation_14495(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_14496","instance":14496,"id":251183,"goal":"predicate IsEven_14496(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_14497","instance":14497,"id":251184,"goal":"predicate InRange_14497(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_14498","instance":14498,"id":251185,"goal":"predicate SubsetOf_14498(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_14499","instance":14499,"id":251186,"goal":"predicate AllMem_14499(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_14500","instance":14500,"id":251187,"goal":"predicate DisjointSets_14500(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_14501","instance":14501,"id":251188,"goal":"predicate Sorted_14501(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_14502","instance":14502,"id":251189,"goal":"predicate AllPositive_14502(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_14503","instance":14503,"id":251190,"goal":"predicate DistinctSeq_14503(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_14504","instance":14504,"id":251191,"goal":"predicate IsSubseq_14504(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_14505","instance":14505,"id":251192,"goal":"predicate IsPermutation_14505(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_14506","instance":14506,"id":251193,"goal":"predicate IsEven_14506(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_14507","instance":14507,"id":251194,"goal":"predicate InRange_14507(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_14508","instance":14508,"id":251195,"goal":"predicate SubsetOf_14508(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_14509","instance":14509,"id":251196,"goal":"predicate AllMem_14509(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_14510","instance":14510,"id":251197,"goal":"predicate DisjointSets_14510(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_14511","instance":14511,"id":251198,"goal":"predicate Sorted_14511(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_14512","instance":14512,"id":251199,"goal":"predicate AllPositive_14512(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_14513","instance":14513,"id":251200,"goal":"predicate DistinctSeq_14513(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_14514","instance":14514,"id":251201,"goal":"predicate IsSubseq_14514(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_14515","instance":14515,"id":251202,"goal":"predicate IsPermutation_14515(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_14516","instance":14516,"id":251203,"goal":"predicate IsEven_14516(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_14517","instance":14517,"id":251204,"goal":"predicate InRange_14517(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_14518","instance":14518,"id":251205,"goal":"predicate SubsetOf_14518(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_14519","instance":14519,"id":251206,"goal":"predicate AllMem_14519(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_14520","instance":14520,"id":251207,"goal":"predicate DisjointSets_14520(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_14521","instance":14521,"id":251208,"goal":"predicate Sorted_14521(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_14522","instance":14522,"id":251209,"goal":"predicate AllPositive_14522(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_14523","instance":14523,"id":251210,"goal":"predicate DistinctSeq_14523(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_14524","instance":14524,"id":251211,"goal":"predicate IsSubseq_14524(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_14525","instance":14525,"id":251212,"goal":"predicate IsPermutation_14525(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_14526","instance":14526,"id":251213,"goal":"predicate IsEven_14526(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_14527","instance":14527,"id":251214,"goal":"predicate InRange_14527(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_14528","instance":14528,"id":251215,"goal":"predicate SubsetOf_14528(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_14529","instance":14529,"id":251216,"goal":"predicate AllMem_14529(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_14530","instance":14530,"id":251217,"goal":"predicate DisjointSets_14530(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_14531","instance":14531,"id":251218,"goal":"predicate Sorted_14531(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_14532","instance":14532,"id":251219,"goal":"predicate AllPositive_14532(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_14533","instance":14533,"id":251220,"goal":"predicate DistinctSeq_14533(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_14534","instance":14534,"id":251221,"goal":"predicate IsSubseq_14534(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_14535","instance":14535,"id":251222,"goal":"predicate IsPermutation_14535(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_14536","instance":14536,"id":251223,"goal":"predicate IsEven_14536(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_14537","instance":14537,"id":251224,"goal":"predicate InRange_14537(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_14538","instance":14538,"id":251225,"goal":"predicate SubsetOf_14538(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_14539","instance":14539,"id":251226,"goal":"predicate AllMem_14539(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_14540","instance":14540,"id":251227,"goal":"predicate DisjointSets_14540(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_14541","instance":14541,"id":251228,"goal":"predicate Sorted_14541(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_14542","instance":14542,"id":251229,"goal":"predicate AllPositive_14542(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_14543","instance":14543,"id":251230,"goal":"predicate DistinctSeq_14543(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_14544","instance":14544,"id":251231,"goal":"predicate IsSubseq_14544(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_14545","instance":14545,"id":251232,"goal":"predicate IsPermutation_14545(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_14546","instance":14546,"id":251233,"goal":"predicate IsEven_14546(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_14547","instance":14547,"id":251234,"goal":"predicate InRange_14547(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_14548","instance":14548,"id":251235,"goal":"predicate SubsetOf_14548(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_14549","instance":14549,"id":251236,"goal":"predicate AllMem_14549(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_14550","instance":14550,"id":251237,"goal":"predicate DisjointSets_14550(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_14551","instance":14551,"id":251238,"goal":"predicate Sorted_14551(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_14552","instance":14552,"id":251239,"goal":"predicate AllPositive_14552(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_14553","instance":14553,"id":251240,"goal":"predicate DistinctSeq_14553(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_14554","instance":14554,"id":251241,"goal":"predicate IsSubseq_14554(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_14555","instance":14555,"id":251242,"goal":"predicate IsPermutation_14555(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_14556","instance":14556,"id":251243,"goal":"predicate IsEven_14556(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_14557","instance":14557,"id":251244,"goal":"predicate InRange_14557(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_14558","instance":14558,"id":251245,"goal":"predicate SubsetOf_14558(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_14559","instance":14559,"id":251246,"goal":"predicate AllMem_14559(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_14560","instance":14560,"id":251247,"goal":"predicate DisjointSets_14560(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_14561","instance":14561,"id":251248,"goal":"predicate Sorted_14561(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_14562","instance":14562,"id":251249,"goal":"predicate AllPositive_14562(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_14563","instance":14563,"id":251250,"goal":"predicate DistinctSeq_14563(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_14564","instance":14564,"id":251251,"goal":"predicate IsSubseq_14564(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_14565","instance":14565,"id":251252,"goal":"predicate IsPermutation_14565(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_14566","instance":14566,"id":251253,"goal":"predicate IsEven_14566(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_14567","instance":14567,"id":251254,"goal":"predicate InRange_14567(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_14568","instance":14568,"id":251255,"goal":"predicate SubsetOf_14568(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_14569","instance":14569,"id":251256,"goal":"predicate AllMem_14569(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_14570","instance":14570,"id":251257,"goal":"predicate DisjointSets_14570(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_14571","instance":14571,"id":251258,"goal":"predicate Sorted_14571(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_14572","instance":14572,"id":251259,"goal":"predicate AllPositive_14572(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_14573","instance":14573,"id":251260,"goal":"predicate DistinctSeq_14573(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_14574","instance":14574,"id":251261,"goal":"predicate IsSubseq_14574(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_14575","instance":14575,"id":251262,"goal":"predicate IsPermutation_14575(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_14576","instance":14576,"id":251263,"goal":"predicate IsEven_14576(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_14577","instance":14577,"id":251264,"goal":"predicate InRange_14577(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_14578","instance":14578,"id":251265,"goal":"predicate SubsetOf_14578(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_14579","instance":14579,"id":251266,"goal":"predicate AllMem_14579(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_14580","instance":14580,"id":251267,"goal":"predicate DisjointSets_14580(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_14581","instance":14581,"id":251268,"goal":"predicate Sorted_14581(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_14582","instance":14582,"id":251269,"goal":"predicate AllPositive_14582(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_14583","instance":14583,"id":251270,"goal":"predicate DistinctSeq_14583(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_14584","instance":14584,"id":251271,"goal":"predicate IsSubseq_14584(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_14585","instance":14585,"id":251272,"goal":"predicate IsPermutation_14585(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_14586","instance":14586,"id":251273,"goal":"predicate IsEven_14586(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_14587","instance":14587,"id":251274,"goal":"predicate InRange_14587(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_14588","instance":14588,"id":251275,"goal":"predicate SubsetOf_14588(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_14589","instance":14589,"id":251276,"goal":"predicate AllMem_14589(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_14590","instance":14590,"id":251277,"goal":"predicate DisjointSets_14590(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_14591","instance":14591,"id":251278,"goal":"predicate Sorted_14591(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_14592","instance":14592,"id":251279,"goal":"predicate AllPositive_14592(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_14593","instance":14593,"id":251280,"goal":"predicate DistinctSeq_14593(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_14594","instance":14594,"id":251281,"goal":"predicate IsSubseq_14594(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_14595","instance":14595,"id":251282,"goal":"predicate IsPermutation_14595(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_14596","instance":14596,"id":251283,"goal":"predicate IsEven_14596(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_14597","instance":14597,"id":251284,"goal":"predicate InRange_14597(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_14598","instance":14598,"id":251285,"goal":"predicate SubsetOf_14598(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_14599","instance":14599,"id":251286,"goal":"predicate AllMem_14599(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_14600","instance":14600,"id":251287,"goal":"predicate DisjointSets_14600(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_14601","instance":14601,"id":251288,"goal":"predicate Sorted_14601(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_14602","instance":14602,"id":251289,"goal":"predicate AllPositive_14602(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_14603","instance":14603,"id":251290,"goal":"predicate DistinctSeq_14603(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_14604","instance":14604,"id":251291,"goal":"predicate IsSubseq_14604(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_14605","instance":14605,"id":251292,"goal":"predicate IsPermutation_14605(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_14606","instance":14606,"id":251293,"goal":"predicate IsEven_14606(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_14607","instance":14607,"id":251294,"goal":"predicate InRange_14607(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_14608","instance":14608,"id":251295,"goal":"predicate SubsetOf_14608(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_14609","instance":14609,"id":251296,"goal":"predicate AllMem_14609(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_14610","instance":14610,"id":251297,"goal":"predicate DisjointSets_14610(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_14611","instance":14611,"id":251298,"goal":"predicate Sorted_14611(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_14612","instance":14612,"id":251299,"goal":"predicate AllPositive_14612(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_14613","instance":14613,"id":251300,"goal":"predicate DistinctSeq_14613(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_14614","instance":14614,"id":251301,"goal":"predicate IsSubseq_14614(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_14615","instance":14615,"id":251302,"goal":"predicate IsPermutation_14615(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_14616","instance":14616,"id":251303,"goal":"predicate IsEven_14616(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_14617","instance":14617,"id":251304,"goal":"predicate InRange_14617(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_14618","instance":14618,"id":251305,"goal":"predicate SubsetOf_14618(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_14619","instance":14619,"id":251306,"goal":"predicate AllMem_14619(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_14620","instance":14620,"id":251307,"goal":"predicate DisjointSets_14620(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_14621","instance":14621,"id":251308,"goal":"predicate Sorted_14621(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_14622","instance":14622,"id":251309,"goal":"predicate AllPositive_14622(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_14623","instance":14623,"id":251310,"goal":"predicate DistinctSeq_14623(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_14624","instance":14624,"id":251311,"goal":"predicate IsSubseq_14624(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_14625","instance":14625,"id":251312,"goal":"predicate IsPermutation_14625(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_14626","instance":14626,"id":251313,"goal":"predicate IsEven_14626(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_14627","instance":14627,"id":251314,"goal":"predicate InRange_14627(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_14628","instance":14628,"id":251315,"goal":"predicate SubsetOf_14628(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_14629","instance":14629,"id":251316,"goal":"predicate AllMem_14629(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_14630","instance":14630,"id":251317,"goal":"predicate DisjointSets_14630(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_14631","instance":14631,"id":251318,"goal":"predicate Sorted_14631(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_14632","instance":14632,"id":251319,"goal":"predicate AllPositive_14632(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_14633","instance":14633,"id":251320,"goal":"predicate DistinctSeq_14633(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_14634","instance":14634,"id":251321,"goal":"predicate IsSubseq_14634(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_14635","instance":14635,"id":251322,"goal":"predicate IsPermutation_14635(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_14636","instance":14636,"id":251323,"goal":"predicate IsEven_14636(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_14637","instance":14637,"id":251324,"goal":"predicate InRange_14637(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_14638","instance":14638,"id":251325,"goal":"predicate SubsetOf_14638(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_14639","instance":14639,"id":251326,"goal":"predicate AllMem_14639(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_14640","instance":14640,"id":251327,"goal":"predicate DisjointSets_14640(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_14641","instance":14641,"id":251328,"goal":"predicate Sorted_14641(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_14642","instance":14642,"id":251329,"goal":"predicate AllPositive_14642(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_14643","instance":14643,"id":251330,"goal":"predicate DistinctSeq_14643(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_14644","instance":14644,"id":251331,"goal":"predicate IsSubseq_14644(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_14645","instance":14645,"id":251332,"goal":"predicate IsPermutation_14645(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_14646","instance":14646,"id":251333,"goal":"predicate IsEven_14646(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_14647","instance":14647,"id":251334,"goal":"predicate InRange_14647(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_14648","instance":14648,"id":251335,"goal":"predicate SubsetOf_14648(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_14649","instance":14649,"id":251336,"goal":"predicate AllMem_14649(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_14650","instance":14650,"id":251337,"goal":"predicate DisjointSets_14650(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_14651","instance":14651,"id":251338,"goal":"predicate Sorted_14651(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_14652","instance":14652,"id":251339,"goal":"predicate AllPositive_14652(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_14653","instance":14653,"id":251340,"goal":"predicate DistinctSeq_14653(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_14654","instance":14654,"id":251341,"goal":"predicate IsSubseq_14654(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_14655","instance":14655,"id":251342,"goal":"predicate IsPermutation_14655(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_14656","instance":14656,"id":251343,"goal":"predicate IsEven_14656(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_14657","instance":14657,"id":251344,"goal":"predicate InRange_14657(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_14658","instance":14658,"id":251345,"goal":"predicate SubsetOf_14658(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_14659","instance":14659,"id":251346,"goal":"predicate AllMem_14659(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_14660","instance":14660,"id":251347,"goal":"predicate DisjointSets_14660(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_14661","instance":14661,"id":251348,"goal":"predicate Sorted_14661(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_14662","instance":14662,"id":251349,"goal":"predicate AllPositive_14662(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_14663","instance":14663,"id":251350,"goal":"predicate DistinctSeq_14663(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_14664","instance":14664,"id":251351,"goal":"predicate IsSubseq_14664(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_14665","instance":14665,"id":251352,"goal":"predicate IsPermutation_14665(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_14666","instance":14666,"id":251353,"goal":"predicate IsEven_14666(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_14667","instance":14667,"id":251354,"goal":"predicate InRange_14667(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_14668","instance":14668,"id":251355,"goal":"predicate SubsetOf_14668(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_14669","instance":14669,"id":251356,"goal":"predicate AllMem_14669(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_14670","instance":14670,"id":251357,"goal":"predicate DisjointSets_14670(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_14671","instance":14671,"id":251358,"goal":"predicate Sorted_14671(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_14672","instance":14672,"id":251359,"goal":"predicate AllPositive_14672(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_14673","instance":14673,"id":251360,"goal":"predicate DistinctSeq_14673(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_14674","instance":14674,"id":251361,"goal":"predicate IsSubseq_14674(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_14675","instance":14675,"id":251362,"goal":"predicate IsPermutation_14675(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_14676","instance":14676,"id":251363,"goal":"predicate IsEven_14676(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_14677","instance":14677,"id":251364,"goal":"predicate InRange_14677(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_14678","instance":14678,"id":251365,"goal":"predicate SubsetOf_14678(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_14679","instance":14679,"id":251366,"goal":"predicate AllMem_14679(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_14680","instance":14680,"id":251367,"goal":"predicate DisjointSets_14680(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_14681","instance":14681,"id":251368,"goal":"predicate Sorted_14681(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_14682","instance":14682,"id":251369,"goal":"predicate AllPositive_14682(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_14683","instance":14683,"id":251370,"goal":"predicate DistinctSeq_14683(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_14684","instance":14684,"id":251371,"goal":"predicate IsSubseq_14684(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_14685","instance":14685,"id":251372,"goal":"predicate IsPermutation_14685(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_14686","instance":14686,"id":251373,"goal":"predicate IsEven_14686(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_14687","instance":14687,"id":251374,"goal":"predicate InRange_14687(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_14688","instance":14688,"id":251375,"goal":"predicate SubsetOf_14688(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_14689","instance":14689,"id":251376,"goal":"predicate AllMem_14689(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_14690","instance":14690,"id":251377,"goal":"predicate DisjointSets_14690(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_14691","instance":14691,"id":251378,"goal":"predicate Sorted_14691(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_14692","instance":14692,"id":251379,"goal":"predicate AllPositive_14692(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_14693","instance":14693,"id":251380,"goal":"predicate DistinctSeq_14693(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_14694","instance":14694,"id":251381,"goal":"predicate IsSubseq_14694(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_14695","instance":14695,"id":251382,"goal":"predicate IsPermutation_14695(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_14696","instance":14696,"id":251383,"goal":"predicate IsEven_14696(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_14697","instance":14697,"id":251384,"goal":"predicate InRange_14697(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_14698","instance":14698,"id":251385,"goal":"predicate SubsetOf_14698(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_14699","instance":14699,"id":251386,"goal":"predicate AllMem_14699(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_14700","instance":14700,"id":251387,"goal":"predicate DisjointSets_14700(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_14701","instance":14701,"id":251388,"goal":"predicate Sorted_14701(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_14702","instance":14702,"id":251389,"goal":"predicate AllPositive_14702(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_14703","instance":14703,"id":251390,"goal":"predicate DistinctSeq_14703(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_14704","instance":14704,"id":251391,"goal":"predicate IsSubseq_14704(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_14705","instance":14705,"id":251392,"goal":"predicate IsPermutation_14705(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_14706","instance":14706,"id":251393,"goal":"predicate IsEven_14706(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_14707","instance":14707,"id":251394,"goal":"predicate InRange_14707(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_14708","instance":14708,"id":251395,"goal":"predicate SubsetOf_14708(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_14709","instance":14709,"id":251396,"goal":"predicate AllMem_14709(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_14710","instance":14710,"id":251397,"goal":"predicate DisjointSets_14710(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_14711","instance":14711,"id":251398,"goal":"predicate Sorted_14711(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_14712","instance":14712,"id":251399,"goal":"predicate AllPositive_14712(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_14713","instance":14713,"id":251400,"goal":"predicate DistinctSeq_14713(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_14714","instance":14714,"id":251401,"goal":"predicate IsSubseq_14714(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_14715","instance":14715,"id":251402,"goal":"predicate IsPermutation_14715(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_14716","instance":14716,"id":251403,"goal":"predicate IsEven_14716(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_14717","instance":14717,"id":251404,"goal":"predicate InRange_14717(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_14718","instance":14718,"id":251405,"goal":"predicate SubsetOf_14718(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_14719","instance":14719,"id":251406,"goal":"predicate AllMem_14719(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_14720","instance":14720,"id":251407,"goal":"predicate DisjointSets_14720(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_14721","instance":14721,"id":251408,"goal":"predicate Sorted_14721(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_14722","instance":14722,"id":251409,"goal":"predicate AllPositive_14722(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_14723","instance":14723,"id":251410,"goal":"predicate DistinctSeq_14723(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_14724","instance":14724,"id":251411,"goal":"predicate IsSubseq_14724(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_14725","instance":14725,"id":251412,"goal":"predicate IsPermutation_14725(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_14726","instance":14726,"id":251413,"goal":"predicate IsEven_14726(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_14727","instance":14727,"id":251414,"goal":"predicate InRange_14727(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_14728","instance":14728,"id":251415,"goal":"predicate SubsetOf_14728(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_14729","instance":14729,"id":251416,"goal":"predicate AllMem_14729(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_14730","instance":14730,"id":251417,"goal":"predicate DisjointSets_14730(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_14731","instance":14731,"id":251418,"goal":"predicate Sorted_14731(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_14732","instance":14732,"id":251419,"goal":"predicate AllPositive_14732(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_14733","instance":14733,"id":251420,"goal":"predicate DistinctSeq_14733(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_14734","instance":14734,"id":251421,"goal":"predicate IsSubseq_14734(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_14735","instance":14735,"id":251422,"goal":"predicate IsPermutation_14735(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_14736","instance":14736,"id":251423,"goal":"predicate IsEven_14736(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_14737","instance":14737,"id":251424,"goal":"predicate InRange_14737(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_14738","instance":14738,"id":251425,"goal":"predicate SubsetOf_14738(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_14739","instance":14739,"id":251426,"goal":"predicate AllMem_14739(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_14740","instance":14740,"id":251427,"goal":"predicate DisjointSets_14740(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_14741","instance":14741,"id":251428,"goal":"predicate Sorted_14741(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_14742","instance":14742,"id":251429,"goal":"predicate AllPositive_14742(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_14743","instance":14743,"id":251430,"goal":"predicate DistinctSeq_14743(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_14744","instance":14744,"id":251431,"goal":"predicate IsSubseq_14744(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_14745","instance":14745,"id":251432,"goal":"predicate IsPermutation_14745(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_14746","instance":14746,"id":251433,"goal":"predicate IsEven_14746(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_14747","instance":14747,"id":251434,"goal":"predicate InRange_14747(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_14748","instance":14748,"id":251435,"goal":"predicate SubsetOf_14748(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_14749","instance":14749,"id":251436,"goal":"predicate AllMem_14749(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_14750","instance":14750,"id":251437,"goal":"predicate DisjointSets_14750(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_14751","instance":14751,"id":251438,"goal":"predicate Sorted_14751(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_14752","instance":14752,"id":251439,"goal":"predicate AllPositive_14752(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_14753","instance":14753,"id":251440,"goal":"predicate DistinctSeq_14753(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_14754","instance":14754,"id":251441,"goal":"predicate IsSubseq_14754(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_14755","instance":14755,"id":251442,"goal":"predicate IsPermutation_14755(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_14756","instance":14756,"id":251443,"goal":"predicate IsEven_14756(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_14757","instance":14757,"id":251444,"goal":"predicate InRange_14757(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_14758","instance":14758,"id":251445,"goal":"predicate SubsetOf_14758(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_14759","instance":14759,"id":251446,"goal":"predicate AllMem_14759(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_14760","instance":14760,"id":251447,"goal":"predicate DisjointSets_14760(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_14761","instance":14761,"id":251448,"goal":"predicate Sorted_14761(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_14762","instance":14762,"id":251449,"goal":"predicate AllPositive_14762(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_14763","instance":14763,"id":251450,"goal":"predicate DistinctSeq_14763(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_14764","instance":14764,"id":251451,"goal":"predicate IsSubseq_14764(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_14765","instance":14765,"id":251452,"goal":"predicate IsPermutation_14765(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_14766","instance":14766,"id":251453,"goal":"predicate IsEven_14766(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_14767","instance":14767,"id":251454,"goal":"predicate InRange_14767(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_14768","instance":14768,"id":251455,"goal":"predicate SubsetOf_14768(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_14769","instance":14769,"id":251456,"goal":"predicate AllMem_14769(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_14770","instance":14770,"id":251457,"goal":"predicate DisjointSets_14770(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_14771","instance":14771,"id":251458,"goal":"predicate Sorted_14771(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_14772","instance":14772,"id":251459,"goal":"predicate AllPositive_14772(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_14773","instance":14773,"id":251460,"goal":"predicate DistinctSeq_14773(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_14774","instance":14774,"id":251461,"goal":"predicate IsSubseq_14774(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_14775","instance":14775,"id":251462,"goal":"predicate IsPermutation_14775(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_14776","instance":14776,"id":251463,"goal":"predicate IsEven_14776(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_14777","instance":14777,"id":251464,"goal":"predicate InRange_14777(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_14778","instance":14778,"id":251465,"goal":"predicate SubsetOf_14778(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_14779","instance":14779,"id":251466,"goal":"predicate AllMem_14779(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_14780","instance":14780,"id":251467,"goal":"predicate DisjointSets_14780(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_14781","instance":14781,"id":251468,"goal":"predicate Sorted_14781(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_14782","instance":14782,"id":251469,"goal":"predicate AllPositive_14782(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_14783","instance":14783,"id":251470,"goal":"predicate DistinctSeq_14783(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_14784","instance":14784,"id":251471,"goal":"predicate IsSubseq_14784(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_14785","instance":14785,"id":251472,"goal":"predicate IsPermutation_14785(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_14786","instance":14786,"id":251473,"goal":"predicate IsEven_14786(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_14787","instance":14787,"id":251474,"goal":"predicate InRange_14787(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_14788","instance":14788,"id":251475,"goal":"predicate SubsetOf_14788(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_14789","instance":14789,"id":251476,"goal":"predicate AllMem_14789(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_14790","instance":14790,"id":251477,"goal":"predicate DisjointSets_14790(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_14791","instance":14791,"id":251478,"goal":"predicate Sorted_14791(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_14792","instance":14792,"id":251479,"goal":"predicate AllPositive_14792(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_14793","instance":14793,"id":251480,"goal":"predicate DistinctSeq_14793(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_14794","instance":14794,"id":251481,"goal":"predicate IsSubseq_14794(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_14795","instance":14795,"id":251482,"goal":"predicate IsPermutation_14795(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_14796","instance":14796,"id":251483,"goal":"predicate IsEven_14796(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_14797","instance":14797,"id":251484,"goal":"predicate InRange_14797(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_14798","instance":14798,"id":251485,"goal":"predicate SubsetOf_14798(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_14799","instance":14799,"id":251486,"goal":"predicate AllMem_14799(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_14800","instance":14800,"id":251487,"goal":"predicate DisjointSets_14800(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_14801","instance":14801,"id":251488,"goal":"predicate Sorted_14801(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_14802","instance":14802,"id":251489,"goal":"predicate AllPositive_14802(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_14803","instance":14803,"id":251490,"goal":"predicate DistinctSeq_14803(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_14804","instance":14804,"id":251491,"goal":"predicate IsSubseq_14804(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_14805","instance":14805,"id":251492,"goal":"predicate IsPermutation_14805(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_14806","instance":14806,"id":251493,"goal":"predicate IsEven_14806(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_14807","instance":14807,"id":251494,"goal":"predicate InRange_14807(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_14808","instance":14808,"id":251495,"goal":"predicate SubsetOf_14808(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_14809","instance":14809,"id":251496,"goal":"predicate AllMem_14809(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_14810","instance":14810,"id":251497,"goal":"predicate DisjointSets_14810(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_14811","instance":14811,"id":251498,"goal":"predicate Sorted_14811(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_14812","instance":14812,"id":251499,"goal":"predicate AllPositive_14812(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_14813","instance":14813,"id":251500,"goal":"predicate DistinctSeq_14813(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_14814","instance":14814,"id":251501,"goal":"predicate IsSubseq_14814(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_14815","instance":14815,"id":251502,"goal":"predicate IsPermutation_14815(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_14816","instance":14816,"id":251503,"goal":"predicate IsEven_14816(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_14817","instance":14817,"id":251504,"goal":"predicate InRange_14817(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_14818","instance":14818,"id":251505,"goal":"predicate SubsetOf_14818(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_14819","instance":14819,"id":251506,"goal":"predicate AllMem_14819(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_14820","instance":14820,"id":251507,"goal":"predicate DisjointSets_14820(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_14821","instance":14821,"id":251508,"goal":"predicate Sorted_14821(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_14822","instance":14822,"id":251509,"goal":"predicate AllPositive_14822(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_14823","instance":14823,"id":251510,"goal":"predicate DistinctSeq_14823(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_14824","instance":14824,"id":251511,"goal":"predicate IsSubseq_14824(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_14825","instance":14825,"id":251512,"goal":"predicate IsPermutation_14825(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_14826","instance":14826,"id":251513,"goal":"predicate IsEven_14826(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_14827","instance":14827,"id":251514,"goal":"predicate InRange_14827(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_14828","instance":14828,"id":251515,"goal":"predicate SubsetOf_14828(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_14829","instance":14829,"id":251516,"goal":"predicate AllMem_14829(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_14830","instance":14830,"id":251517,"goal":"predicate DisjointSets_14830(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_14831","instance":14831,"id":251518,"goal":"predicate Sorted_14831(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_14832","instance":14832,"id":251519,"goal":"predicate AllPositive_14832(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_14833","instance":14833,"id":251520,"goal":"predicate DistinctSeq_14833(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_14834","instance":14834,"id":251521,"goal":"predicate IsSubseq_14834(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_14835","instance":14835,"id":251522,"goal":"predicate IsPermutation_14835(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_14836","instance":14836,"id":251523,"goal":"predicate IsEven_14836(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_14837","instance":14837,"id":251524,"goal":"predicate InRange_14837(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_14838","instance":14838,"id":251525,"goal":"predicate SubsetOf_14838(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_14839","instance":14839,"id":251526,"goal":"predicate AllMem_14839(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_14840","instance":14840,"id":251527,"goal":"predicate DisjointSets_14840(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_14841","instance":14841,"id":251528,"goal":"predicate Sorted_14841(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_14842","instance":14842,"id":251529,"goal":"predicate AllPositive_14842(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_14843","instance":14843,"id":251530,"goal":"predicate DistinctSeq_14843(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_14844","instance":14844,"id":251531,"goal":"predicate IsSubseq_14844(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_14845","instance":14845,"id":251532,"goal":"predicate IsPermutation_14845(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_14846","instance":14846,"id":251533,"goal":"predicate IsEven_14846(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_14847","instance":14847,"id":251534,"goal":"predicate InRange_14847(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_14848","instance":14848,"id":251535,"goal":"predicate SubsetOf_14848(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_14849","instance":14849,"id":251536,"goal":"predicate AllMem_14849(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_14850","instance":14850,"id":251537,"goal":"predicate DisjointSets_14850(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_14851","instance":14851,"id":251538,"goal":"predicate Sorted_14851(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_14852","instance":14852,"id":251539,"goal":"predicate AllPositive_14852(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_14853","instance":14853,"id":251540,"goal":"predicate DistinctSeq_14853(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_14854","instance":14854,"id":251541,"goal":"predicate IsSubseq_14854(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_14855","instance":14855,"id":251542,"goal":"predicate IsPermutation_14855(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_14856","instance":14856,"id":251543,"goal":"predicate IsEven_14856(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_14857","instance":14857,"id":251544,"goal":"predicate InRange_14857(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_14858","instance":14858,"id":251545,"goal":"predicate SubsetOf_14858(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_14859","instance":14859,"id":251546,"goal":"predicate AllMem_14859(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_14860","instance":14860,"id":251547,"goal":"predicate DisjointSets_14860(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_14861","instance":14861,"id":251548,"goal":"predicate Sorted_14861(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_14862","instance":14862,"id":251549,"goal":"predicate AllPositive_14862(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_14863","instance":14863,"id":251550,"goal":"predicate DistinctSeq_14863(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_14864","instance":14864,"id":251551,"goal":"predicate IsSubseq_14864(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_14865","instance":14865,"id":251552,"goal":"predicate IsPermutation_14865(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_14866","instance":14866,"id":251553,"goal":"predicate IsEven_14866(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_14867","instance":14867,"id":251554,"goal":"predicate InRange_14867(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_14868","instance":14868,"id":251555,"goal":"predicate SubsetOf_14868(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_14869","instance":14869,"id":251556,"goal":"predicate AllMem_14869(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_14870","instance":14870,"id":251557,"goal":"predicate DisjointSets_14870(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_14871","instance":14871,"id":251558,"goal":"predicate Sorted_14871(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_14872","instance":14872,"id":251559,"goal":"predicate AllPositive_14872(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_14873","instance":14873,"id":251560,"goal":"predicate DistinctSeq_14873(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_14874","instance":14874,"id":251561,"goal":"predicate IsSubseq_14874(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_14875","instance":14875,"id":251562,"goal":"predicate IsPermutation_14875(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_14876","instance":14876,"id":251563,"goal":"predicate IsEven_14876(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_14877","instance":14877,"id":251564,"goal":"predicate InRange_14877(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_14878","instance":14878,"id":251565,"goal":"predicate SubsetOf_14878(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_14879","instance":14879,"id":251566,"goal":"predicate AllMem_14879(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_14880","instance":14880,"id":251567,"goal":"predicate DisjointSets_14880(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_14881","instance":14881,"id":251568,"goal":"predicate Sorted_14881(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_14882","instance":14882,"id":251569,"goal":"predicate AllPositive_14882(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_14883","instance":14883,"id":251570,"goal":"predicate DistinctSeq_14883(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_14884","instance":14884,"id":251571,"goal":"predicate IsSubseq_14884(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_14885","instance":14885,"id":251572,"goal":"predicate IsPermutation_14885(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_14886","instance":14886,"id":251573,"goal":"predicate IsEven_14886(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_14887","instance":14887,"id":251574,"goal":"predicate InRange_14887(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_14888","instance":14888,"id":251575,"goal":"predicate SubsetOf_14888(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_14889","instance":14889,"id":251576,"goal":"predicate AllMem_14889(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_14890","instance":14890,"id":251577,"goal":"predicate DisjointSets_14890(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_14891","instance":14891,"id":251578,"goal":"predicate Sorted_14891(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_14892","instance":14892,"id":251579,"goal":"predicate AllPositive_14892(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_14893","instance":14893,"id":251580,"goal":"predicate DistinctSeq_14893(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_14894","instance":14894,"id":251581,"goal":"predicate IsSubseq_14894(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_14895","instance":14895,"id":251582,"goal":"predicate IsPermutation_14895(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_14896","instance":14896,"id":251583,"goal":"predicate IsEven_14896(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_14897","instance":14897,"id":251584,"goal":"predicate InRange_14897(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_14898","instance":14898,"id":251585,"goal":"predicate SubsetOf_14898(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_14899","instance":14899,"id":251586,"goal":"predicate AllMem_14899(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_14900","instance":14900,"id":251587,"goal":"predicate DisjointSets_14900(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_14901","instance":14901,"id":251588,"goal":"predicate Sorted_14901(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_14902","instance":14902,"id":251589,"goal":"predicate AllPositive_14902(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_14903","instance":14903,"id":251590,"goal":"predicate DistinctSeq_14903(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_14904","instance":14904,"id":251591,"goal":"predicate IsSubseq_14904(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_14905","instance":14905,"id":251592,"goal":"predicate IsPermutation_14905(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_14906","instance":14906,"id":251593,"goal":"predicate IsEven_14906(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_14907","instance":14907,"id":251594,"goal":"predicate InRange_14907(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_14908","instance":14908,"id":251595,"goal":"predicate SubsetOf_14908(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_14909","instance":14909,"id":251596,"goal":"predicate AllMem_14909(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_14910","instance":14910,"id":251597,"goal":"predicate DisjointSets_14910(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_14911","instance":14911,"id":251598,"goal":"predicate Sorted_14911(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_14912","instance":14912,"id":251599,"goal":"predicate AllPositive_14912(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_14913","instance":14913,"id":251600,"goal":"predicate DistinctSeq_14913(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_14914","instance":14914,"id":251601,"goal":"predicate IsSubseq_14914(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_14915","instance":14915,"id":251602,"goal":"predicate IsPermutation_14915(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_14916","instance":14916,"id":251603,"goal":"predicate IsEven_14916(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_14917","instance":14917,"id":251604,"goal":"predicate InRange_14917(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_14918","instance":14918,"id":251605,"goal":"predicate SubsetOf_14918(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_14919","instance":14919,"id":251606,"goal":"predicate AllMem_14919(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_14920","instance":14920,"id":251607,"goal":"predicate DisjointSets_14920(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_14921","instance":14921,"id":251608,"goal":"predicate Sorted_14921(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_14922","instance":14922,"id":251609,"goal":"predicate AllPositive_14922(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_14923","instance":14923,"id":251610,"goal":"predicate DistinctSeq_14923(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_14924","instance":14924,"id":251611,"goal":"predicate IsSubseq_14924(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_14925","instance":14925,"id":251612,"goal":"predicate IsPermutation_14925(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_14926","instance":14926,"id":251613,"goal":"predicate IsEven_14926(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_14927","instance":14927,"id":251614,"goal":"predicate InRange_14927(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_14928","instance":14928,"id":251615,"goal":"predicate SubsetOf_14928(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_14929","instance":14929,"id":251616,"goal":"predicate AllMem_14929(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_14930","instance":14930,"id":251617,"goal":"predicate DisjointSets_14930(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_14931","instance":14931,"id":251618,"goal":"predicate Sorted_14931(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_14932","instance":14932,"id":251619,"goal":"predicate AllPositive_14932(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_14933","instance":14933,"id":251620,"goal":"predicate DistinctSeq_14933(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_14934","instance":14934,"id":251621,"goal":"predicate IsSubseq_14934(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_14935","instance":14935,"id":251622,"goal":"predicate IsPermutation_14935(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_14936","instance":14936,"id":251623,"goal":"predicate IsEven_14936(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_14937","instance":14937,"id":251624,"goal":"predicate InRange_14937(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_14938","instance":14938,"id":251625,"goal":"predicate SubsetOf_14938(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_14939","instance":14939,"id":251626,"goal":"predicate AllMem_14939(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_14940","instance":14940,"id":251627,"goal":"predicate DisjointSets_14940(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_14941","instance":14941,"id":251628,"goal":"predicate Sorted_14941(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_14942","instance":14942,"id":251629,"goal":"predicate AllPositive_14942(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_14943","instance":14943,"id":251630,"goal":"predicate DistinctSeq_14943(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_14944","instance":14944,"id":251631,"goal":"predicate IsSubseq_14944(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_14945","instance":14945,"id":251632,"goal":"predicate IsPermutation_14945(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_14946","instance":14946,"id":251633,"goal":"predicate IsEven_14946(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_14947","instance":14947,"id":251634,"goal":"predicate InRange_14947(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_14948","instance":14948,"id":251635,"goal":"predicate SubsetOf_14948(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_14949","instance":14949,"id":251636,"goal":"predicate AllMem_14949(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_14950","instance":14950,"id":251637,"goal":"predicate DisjointSets_14950(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_14951","instance":14951,"id":251638,"goal":"predicate Sorted_14951(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_14952","instance":14952,"id":251639,"goal":"predicate AllPositive_14952(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_14953","instance":14953,"id":251640,"goal":"predicate DistinctSeq_14953(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_14954","instance":14954,"id":251641,"goal":"predicate IsSubseq_14954(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_14955","instance":14955,"id":251642,"goal":"predicate IsPermutation_14955(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_14956","instance":14956,"id":251643,"goal":"predicate IsEven_14956(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_14957","instance":14957,"id":251644,"goal":"predicate InRange_14957(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_14958","instance":14958,"id":251645,"goal":"predicate SubsetOf_14958(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_14959","instance":14959,"id":251646,"goal":"predicate AllMem_14959(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_14960","instance":14960,"id":251647,"goal":"predicate DisjointSets_14960(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_14961","instance":14961,"id":251648,"goal":"predicate Sorted_14961(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_14962","instance":14962,"id":251649,"goal":"predicate AllPositive_14962(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_14963","instance":14963,"id":251650,"goal":"predicate DistinctSeq_14963(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_14964","instance":14964,"id":251651,"goal":"predicate IsSubseq_14964(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_14965","instance":14965,"id":251652,"goal":"predicate IsPermutation_14965(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_14966","instance":14966,"id":251653,"goal":"predicate IsEven_14966(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_14967","instance":14967,"id":251654,"goal":"predicate InRange_14967(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_14968","instance":14968,"id":251655,"goal":"predicate SubsetOf_14968(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_14969","instance":14969,"id":251656,"goal":"predicate AllMem_14969(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_14970","instance":14970,"id":251657,"goal":"predicate DisjointSets_14970(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_14971","instance":14971,"id":251658,"goal":"predicate Sorted_14971(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_14972","instance":14972,"id":251659,"goal":"predicate AllPositive_14972(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_14973","instance":14973,"id":251660,"goal":"predicate DistinctSeq_14973(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_14974","instance":14974,"id":251661,"goal":"predicate IsSubseq_14974(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_14975","instance":14975,"id":251662,"goal":"predicate IsPermutation_14975(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_14976","instance":14976,"id":251663,"goal":"predicate IsEven_14976(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_14977","instance":14977,"id":251664,"goal":"predicate InRange_14977(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_14978","instance":14978,"id":251665,"goal":"predicate SubsetOf_14978(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_14979","instance":14979,"id":251666,"goal":"predicate AllMem_14979(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_14980","instance":14980,"id":251667,"goal":"predicate DisjointSets_14980(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_14981","instance":14981,"id":251668,"goal":"predicate Sorted_14981(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_14982","instance":14982,"id":251669,"goal":"predicate AllPositive_14982(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_14983","instance":14983,"id":251670,"goal":"predicate DistinctSeq_14983(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_14984","instance":14984,"id":251671,"goal":"predicate IsSubseq_14984(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_14985","instance":14985,"id":251672,"goal":"predicate IsPermutation_14985(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_14986","instance":14986,"id":251673,"goal":"predicate IsEven_14986(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_14987","instance":14987,"id":251674,"goal":"predicate InRange_14987(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_14988","instance":14988,"id":251675,"goal":"predicate SubsetOf_14988(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_14989","instance":14989,"id":251676,"goal":"predicate AllMem_14989(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_14990","instance":14990,"id":251677,"goal":"predicate DisjointSets_14990(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_14991","instance":14991,"id":251678,"goal":"predicate Sorted_14991(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_14992","instance":14992,"id":251679,"goal":"predicate AllPositive_14992(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_14993","instance":14993,"id":251680,"goal":"predicate DistinctSeq_14993(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_14994","instance":14994,"id":251681,"goal":"predicate IsSubseq_14994(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_14995","instance":14995,"id":251682,"goal":"predicate IsPermutation_14995(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_14996","instance":14996,"id":251683,"goal":"predicate IsEven_14996(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_14997","instance":14997,"id":251684,"goal":"predicate InRange_14997(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_14998","instance":14998,"id":251685,"goal":"predicate SubsetOf_14998(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_14999","instance":14999,"id":251686,"goal":"predicate AllMem_14999(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_15000","instance":15000,"id":251687,"goal":"predicate DisjointSets_15000(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_15001","instance":15001,"id":251688,"goal":"predicate Sorted_15001(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_15002","instance":15002,"id":251689,"goal":"predicate AllPositive_15002(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_15003","instance":15003,"id":251690,"goal":"predicate DistinctSeq_15003(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_15004","instance":15004,"id":251691,"goal":"predicate IsSubseq_15004(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_15005","instance":15005,"id":251692,"goal":"predicate IsPermutation_15005(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_15006","instance":15006,"id":251693,"goal":"predicate IsEven_15006(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_15007","instance":15007,"id":251694,"goal":"predicate InRange_15007(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_15008","instance":15008,"id":251695,"goal":"predicate SubsetOf_15008(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_15009","instance":15009,"id":251696,"goal":"predicate AllMem_15009(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_15010","instance":15010,"id":251697,"goal":"predicate DisjointSets_15010(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_15011","instance":15011,"id":251698,"goal":"predicate Sorted_15011(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_15012","instance":15012,"id":251699,"goal":"predicate AllPositive_15012(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_15013","instance":15013,"id":251700,"goal":"predicate DistinctSeq_15013(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_15014","instance":15014,"id":251701,"goal":"predicate IsSubseq_15014(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_15015","instance":15015,"id":251702,"goal":"predicate IsPermutation_15015(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_15016","instance":15016,"id":251703,"goal":"predicate IsEven_15016(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_15017","instance":15017,"id":251704,"goal":"predicate InRange_15017(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_15018","instance":15018,"id":251705,"goal":"predicate SubsetOf_15018(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_15019","instance":15019,"id":251706,"goal":"predicate AllMem_15019(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_15020","instance":15020,"id":251707,"goal":"predicate DisjointSets_15020(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_15021","instance":15021,"id":251708,"goal":"predicate Sorted_15021(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_15022","instance":15022,"id":251709,"goal":"predicate AllPositive_15022(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_15023","instance":15023,"id":251710,"goal":"predicate DistinctSeq_15023(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_15024","instance":15024,"id":251711,"goal":"predicate IsSubseq_15024(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_15025","instance":15025,"id":251712,"goal":"predicate IsPermutation_15025(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_15026","instance":15026,"id":251713,"goal":"predicate IsEven_15026(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_15027","instance":15027,"id":251714,"goal":"predicate InRange_15027(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_15028","instance":15028,"id":251715,"goal":"predicate SubsetOf_15028(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_15029","instance":15029,"id":251716,"goal":"predicate AllMem_15029(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_15030","instance":15030,"id":251717,"goal":"predicate DisjointSets_15030(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_15031","instance":15031,"id":251718,"goal":"predicate Sorted_15031(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_15032","instance":15032,"id":251719,"goal":"predicate AllPositive_15032(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_15033","instance":15033,"id":251720,"goal":"predicate DistinctSeq_15033(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_15034","instance":15034,"id":251721,"goal":"predicate IsSubseq_15034(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_15035","instance":15035,"id":251722,"goal":"predicate IsPermutation_15035(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_15036","instance":15036,"id":251723,"goal":"predicate IsEven_15036(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_15037","instance":15037,"id":251724,"goal":"predicate InRange_15037(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_15038","instance":15038,"id":251725,"goal":"predicate SubsetOf_15038(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_15039","instance":15039,"id":251726,"goal":"predicate AllMem_15039(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_15040","instance":15040,"id":251727,"goal":"predicate DisjointSets_15040(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_15041","instance":15041,"id":251728,"goal":"predicate Sorted_15041(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_15042","instance":15042,"id":251729,"goal":"predicate AllPositive_15042(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_15043","instance":15043,"id":251730,"goal":"predicate DistinctSeq_15043(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_15044","instance":15044,"id":251731,"goal":"predicate IsSubseq_15044(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_15045","instance":15045,"id":251732,"goal":"predicate IsPermutation_15045(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_15046","instance":15046,"id":251733,"goal":"predicate IsEven_15046(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_15047","instance":15047,"id":251734,"goal":"predicate InRange_15047(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_15048","instance":15048,"id":251735,"goal":"predicate SubsetOf_15048(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_15049","instance":15049,"id":251736,"goal":"predicate AllMem_15049(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_15050","instance":15050,"id":251737,"goal":"predicate DisjointSets_15050(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_15051","instance":15051,"id":251738,"goal":"predicate Sorted_15051(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_15052","instance":15052,"id":251739,"goal":"predicate AllPositive_15052(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_15053","instance":15053,"id":251740,"goal":"predicate DistinctSeq_15053(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_15054","instance":15054,"id":251741,"goal":"predicate IsSubseq_15054(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_15055","instance":15055,"id":251742,"goal":"predicate IsPermutation_15055(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_15056","instance":15056,"id":251743,"goal":"predicate IsEven_15056(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_15057","instance":15057,"id":251744,"goal":"predicate InRange_15057(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_15058","instance":15058,"id":251745,"goal":"predicate SubsetOf_15058(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_15059","instance":15059,"id":251746,"goal":"predicate AllMem_15059(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_15060","instance":15060,"id":251747,"goal":"predicate DisjointSets_15060(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_15061","instance":15061,"id":251748,"goal":"predicate Sorted_15061(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_15062","instance":15062,"id":251749,"goal":"predicate AllPositive_15062(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_15063","instance":15063,"id":251750,"goal":"predicate DistinctSeq_15063(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_15064","instance":15064,"id":251751,"goal":"predicate IsSubseq_15064(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_15065","instance":15065,"id":251752,"goal":"predicate IsPermutation_15065(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_15066","instance":15066,"id":251753,"goal":"predicate IsEven_15066(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_15067","instance":15067,"id":251754,"goal":"predicate InRange_15067(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_15068","instance":15068,"id":251755,"goal":"predicate SubsetOf_15068(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_15069","instance":15069,"id":251756,"goal":"predicate AllMem_15069(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_15070","instance":15070,"id":251757,"goal":"predicate DisjointSets_15070(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_15071","instance":15071,"id":251758,"goal":"predicate Sorted_15071(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_15072","instance":15072,"id":251759,"goal":"predicate AllPositive_15072(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_15073","instance":15073,"id":251760,"goal":"predicate DistinctSeq_15073(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_15074","instance":15074,"id":251761,"goal":"predicate IsSubseq_15074(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_15075","instance":15075,"id":251762,"goal":"predicate IsPermutation_15075(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_15076","instance":15076,"id":251763,"goal":"predicate IsEven_15076(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_15077","instance":15077,"id":251764,"goal":"predicate InRange_15077(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_15078","instance":15078,"id":251765,"goal":"predicate SubsetOf_15078(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_15079","instance":15079,"id":251766,"goal":"predicate AllMem_15079(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_15080","instance":15080,"id":251767,"goal":"predicate DisjointSets_15080(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_15081","instance":15081,"id":251768,"goal":"predicate Sorted_15081(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_15082","instance":15082,"id":251769,"goal":"predicate AllPositive_15082(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_15083","instance":15083,"id":251770,"goal":"predicate DistinctSeq_15083(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_15084","instance":15084,"id":251771,"goal":"predicate IsSubseq_15084(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_15085","instance":15085,"id":251772,"goal":"predicate IsPermutation_15085(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_15086","instance":15086,"id":251773,"goal":"predicate IsEven_15086(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_15087","instance":15087,"id":251774,"goal":"predicate InRange_15087(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_15088","instance":15088,"id":251775,"goal":"predicate SubsetOf_15088(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_15089","instance":15089,"id":251776,"goal":"predicate AllMem_15089(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_15090","instance":15090,"id":251777,"goal":"predicate DisjointSets_15090(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_15091","instance":15091,"id":251778,"goal":"predicate Sorted_15091(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_15092","instance":15092,"id":251779,"goal":"predicate AllPositive_15092(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_15093","instance":15093,"id":251780,"goal":"predicate DistinctSeq_15093(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_15094","instance":15094,"id":251781,"goal":"predicate IsSubseq_15094(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_15095","instance":15095,"id":251782,"goal":"predicate IsPermutation_15095(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_15096","instance":15096,"id":251783,"goal":"predicate IsEven_15096(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_15097","instance":15097,"id":251784,"goal":"predicate InRange_15097(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_15098","instance":15098,"id":251785,"goal":"predicate SubsetOf_15098(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_15099","instance":15099,"id":251786,"goal":"predicate AllMem_15099(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_15100","instance":15100,"id":251787,"goal":"predicate DisjointSets_15100(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_15101","instance":15101,"id":251788,"goal":"predicate Sorted_15101(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_15102","instance":15102,"id":251789,"goal":"predicate AllPositive_15102(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_15103","instance":15103,"id":251790,"goal":"predicate DistinctSeq_15103(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_15104","instance":15104,"id":251791,"goal":"predicate IsSubseq_15104(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_15105","instance":15105,"id":251792,"goal":"predicate IsPermutation_15105(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_15106","instance":15106,"id":251793,"goal":"predicate IsEven_15106(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_15107","instance":15107,"id":251794,"goal":"predicate InRange_15107(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_15108","instance":15108,"id":251795,"goal":"predicate SubsetOf_15108(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_15109","instance":15109,"id":251796,"goal":"predicate AllMem_15109(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_15110","instance":15110,"id":251797,"goal":"predicate DisjointSets_15110(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_15111","instance":15111,"id":251798,"goal":"predicate Sorted_15111(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_15112","instance":15112,"id":251799,"goal":"predicate AllPositive_15112(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_15113","instance":15113,"id":251800,"goal":"predicate DistinctSeq_15113(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_15114","instance":15114,"id":251801,"goal":"predicate IsSubseq_15114(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_15115","instance":15115,"id":251802,"goal":"predicate IsPermutation_15115(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_15116","instance":15116,"id":251803,"goal":"predicate IsEven_15116(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_15117","instance":15117,"id":251804,"goal":"predicate InRange_15117(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_15118","instance":15118,"id":251805,"goal":"predicate SubsetOf_15118(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_15119","instance":15119,"id":251806,"goal":"predicate AllMem_15119(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_15120","instance":15120,"id":251807,"goal":"predicate DisjointSets_15120(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_15121","instance":15121,"id":251808,"goal":"predicate Sorted_15121(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_15122","instance":15122,"id":251809,"goal":"predicate AllPositive_15122(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_15123","instance":15123,"id":251810,"goal":"predicate DistinctSeq_15123(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_15124","instance":15124,"id":251811,"goal":"predicate IsSubseq_15124(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_15125","instance":15125,"id":251812,"goal":"predicate IsPermutation_15125(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_15126","instance":15126,"id":251813,"goal":"predicate IsEven_15126(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_15127","instance":15127,"id":251814,"goal":"predicate InRange_15127(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_15128","instance":15128,"id":251815,"goal":"predicate SubsetOf_15128(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_15129","instance":15129,"id":251816,"goal":"predicate AllMem_15129(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_15130","instance":15130,"id":251817,"goal":"predicate DisjointSets_15130(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_15131","instance":15131,"id":251818,"goal":"predicate Sorted_15131(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_15132","instance":15132,"id":251819,"goal":"predicate AllPositive_15132(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_15133","instance":15133,"id":251820,"goal":"predicate DistinctSeq_15133(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_15134","instance":15134,"id":251821,"goal":"predicate IsSubseq_15134(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_15135","instance":15135,"id":251822,"goal":"predicate IsPermutation_15135(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_15136","instance":15136,"id":251823,"goal":"predicate IsEven_15136(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_15137","instance":15137,"id":251824,"goal":"predicate InRange_15137(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_15138","instance":15138,"id":251825,"goal":"predicate SubsetOf_15138(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_15139","instance":15139,"id":251826,"goal":"predicate AllMem_15139(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_15140","instance":15140,"id":251827,"goal":"predicate DisjointSets_15140(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_15141","instance":15141,"id":251828,"goal":"predicate Sorted_15141(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_15142","instance":15142,"id":251829,"goal":"predicate AllPositive_15142(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_15143","instance":15143,"id":251830,"goal":"predicate DistinctSeq_15143(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_15144","instance":15144,"id":251831,"goal":"predicate IsSubseq_15144(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_15145","instance":15145,"id":251832,"goal":"predicate IsPermutation_15145(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_15146","instance":15146,"id":251833,"goal":"predicate IsEven_15146(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_15147","instance":15147,"id":251834,"goal":"predicate InRange_15147(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_15148","instance":15148,"id":251835,"goal":"predicate SubsetOf_15148(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_15149","instance":15149,"id":251836,"goal":"predicate AllMem_15149(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_15150","instance":15150,"id":251837,"goal":"predicate DisjointSets_15150(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_15151","instance":15151,"id":251838,"goal":"predicate Sorted_15151(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_15152","instance":15152,"id":251839,"goal":"predicate AllPositive_15152(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_15153","instance":15153,"id":251840,"goal":"predicate DistinctSeq_15153(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_15154","instance":15154,"id":251841,"goal":"predicate IsSubseq_15154(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_15155","instance":15155,"id":251842,"goal":"predicate IsPermutation_15155(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_15156","instance":15156,"id":251843,"goal":"predicate IsEven_15156(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_15157","instance":15157,"id":251844,"goal":"predicate InRange_15157(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_15158","instance":15158,"id":251845,"goal":"predicate SubsetOf_15158(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_15159","instance":15159,"id":251846,"goal":"predicate AllMem_15159(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_15160","instance":15160,"id":251847,"goal":"predicate DisjointSets_15160(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_15161","instance":15161,"id":251848,"goal":"predicate Sorted_15161(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_15162","instance":15162,"id":251849,"goal":"predicate AllPositive_15162(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_15163","instance":15163,"id":251850,"goal":"predicate DistinctSeq_15163(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_15164","instance":15164,"id":251851,"goal":"predicate IsSubseq_15164(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_15165","instance":15165,"id":251852,"goal":"predicate IsPermutation_15165(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_15166","instance":15166,"id":251853,"goal":"predicate IsEven_15166(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_15167","instance":15167,"id":251854,"goal":"predicate InRange_15167(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_15168","instance":15168,"id":251855,"goal":"predicate SubsetOf_15168(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_15169","instance":15169,"id":251856,"goal":"predicate AllMem_15169(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_15170","instance":15170,"id":251857,"goal":"predicate DisjointSets_15170(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_15171","instance":15171,"id":251858,"goal":"predicate Sorted_15171(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_15172","instance":15172,"id":251859,"goal":"predicate AllPositive_15172(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_15173","instance":15173,"id":251860,"goal":"predicate DistinctSeq_15173(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_15174","instance":15174,"id":251861,"goal":"predicate IsSubseq_15174(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_15175","instance":15175,"id":251862,"goal":"predicate IsPermutation_15175(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_15176","instance":15176,"id":251863,"goal":"predicate IsEven_15176(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_15177","instance":15177,"id":251864,"goal":"predicate InRange_15177(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_15178","instance":15178,"id":251865,"goal":"predicate SubsetOf_15178(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_15179","instance":15179,"id":251866,"goal":"predicate AllMem_15179(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_15180","instance":15180,"id":251867,"goal":"predicate DisjointSets_15180(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_15181","instance":15181,"id":251868,"goal":"predicate Sorted_15181(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_15182","instance":15182,"id":251869,"goal":"predicate AllPositive_15182(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_15183","instance":15183,"id":251870,"goal":"predicate DistinctSeq_15183(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_15184","instance":15184,"id":251871,"goal":"predicate IsSubseq_15184(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_15185","instance":15185,"id":251872,"goal":"predicate IsPermutation_15185(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_15186","instance":15186,"id":251873,"goal":"predicate IsEven_15186(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_15187","instance":15187,"id":251874,"goal":"predicate InRange_15187(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_15188","instance":15188,"id":251875,"goal":"predicate SubsetOf_15188(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_15189","instance":15189,"id":251876,"goal":"predicate AllMem_15189(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_15190","instance":15190,"id":251877,"goal":"predicate DisjointSets_15190(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_15191","instance":15191,"id":251878,"goal":"predicate Sorted_15191(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_15192","instance":15192,"id":251879,"goal":"predicate AllPositive_15192(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_15193","instance":15193,"id":251880,"goal":"predicate DistinctSeq_15193(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_15194","instance":15194,"id":251881,"goal":"predicate IsSubseq_15194(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_15195","instance":15195,"id":251882,"goal":"predicate IsPermutation_15195(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_15196","instance":15196,"id":251883,"goal":"predicate IsEven_15196(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_15197","instance":15197,"id":251884,"goal":"predicate InRange_15197(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_15198","instance":15198,"id":251885,"goal":"predicate SubsetOf_15198(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_15199","instance":15199,"id":251886,"goal":"predicate AllMem_15199(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_15200","instance":15200,"id":251887,"goal":"predicate DisjointSets_15200(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_15201","instance":15201,"id":251888,"goal":"predicate Sorted_15201(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_15202","instance":15202,"id":251889,"goal":"predicate AllPositive_15202(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_15203","instance":15203,"id":251890,"goal":"predicate DistinctSeq_15203(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_15204","instance":15204,"id":251891,"goal":"predicate IsSubseq_15204(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_15205","instance":15205,"id":251892,"goal":"predicate IsPermutation_15205(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_15206","instance":15206,"id":251893,"goal":"predicate IsEven_15206(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_15207","instance":15207,"id":251894,"goal":"predicate InRange_15207(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_15208","instance":15208,"id":251895,"goal":"predicate SubsetOf_15208(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_15209","instance":15209,"id":251896,"goal":"predicate AllMem_15209(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_15210","instance":15210,"id":251897,"goal":"predicate DisjointSets_15210(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_15211","instance":15211,"id":251898,"goal":"predicate Sorted_15211(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_15212","instance":15212,"id":251899,"goal":"predicate AllPositive_15212(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_15213","instance":15213,"id":251900,"goal":"predicate DistinctSeq_15213(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_15214","instance":15214,"id":251901,"goal":"predicate IsSubseq_15214(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_15215","instance":15215,"id":251902,"goal":"predicate IsPermutation_15215(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_15216","instance":15216,"id":251903,"goal":"predicate IsEven_15216(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_15217","instance":15217,"id":251904,"goal":"predicate InRange_15217(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_15218","instance":15218,"id":251905,"goal":"predicate SubsetOf_15218(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_15219","instance":15219,"id":251906,"goal":"predicate AllMem_15219(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_15220","instance":15220,"id":251907,"goal":"predicate DisjointSets_15220(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_15221","instance":15221,"id":251908,"goal":"predicate Sorted_15221(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_15222","instance":15222,"id":251909,"goal":"predicate AllPositive_15222(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_15223","instance":15223,"id":251910,"goal":"predicate DistinctSeq_15223(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_15224","instance":15224,"id":251911,"goal":"predicate IsSubseq_15224(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_15225","instance":15225,"id":251912,"goal":"predicate IsPermutation_15225(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_15226","instance":15226,"id":251913,"goal":"predicate IsEven_15226(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_15227","instance":15227,"id":251914,"goal":"predicate InRange_15227(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_15228","instance":15228,"id":251915,"goal":"predicate SubsetOf_15228(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_15229","instance":15229,"id":251916,"goal":"predicate AllMem_15229(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_15230","instance":15230,"id":251917,"goal":"predicate DisjointSets_15230(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_15231","instance":15231,"id":251918,"goal":"predicate Sorted_15231(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_15232","instance":15232,"id":251919,"goal":"predicate AllPositive_15232(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_15233","instance":15233,"id":251920,"goal":"predicate DistinctSeq_15233(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_15234","instance":15234,"id":251921,"goal":"predicate IsSubseq_15234(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_15235","instance":15235,"id":251922,"goal":"predicate IsPermutation_15235(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_15236","instance":15236,"id":251923,"goal":"predicate IsEven_15236(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_15237","instance":15237,"id":251924,"goal":"predicate InRange_15237(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_15238","instance":15238,"id":251925,"goal":"predicate SubsetOf_15238(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_15239","instance":15239,"id":251926,"goal":"predicate AllMem_15239(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_15240","instance":15240,"id":251927,"goal":"predicate DisjointSets_15240(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_15241","instance":15241,"id":251928,"goal":"predicate Sorted_15241(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_15242","instance":15242,"id":251929,"goal":"predicate AllPositive_15242(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_15243","instance":15243,"id":251930,"goal":"predicate DistinctSeq_15243(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_15244","instance":15244,"id":251931,"goal":"predicate IsSubseq_15244(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_15245","instance":15245,"id":251932,"goal":"predicate IsPermutation_15245(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_15246","instance":15246,"id":251933,"goal":"predicate IsEven_15246(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_15247","instance":15247,"id":251934,"goal":"predicate InRange_15247(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_15248","instance":15248,"id":251935,"goal":"predicate SubsetOf_15248(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_15249","instance":15249,"id":251936,"goal":"predicate AllMem_15249(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_15250","instance":15250,"id":251937,"goal":"predicate DisjointSets_15250(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_15251","instance":15251,"id":251938,"goal":"predicate Sorted_15251(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_15252","instance":15252,"id":251939,"goal":"predicate AllPositive_15252(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_15253","instance":15253,"id":251940,"goal":"predicate DistinctSeq_15253(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_15254","instance":15254,"id":251941,"goal":"predicate IsSubseq_15254(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_15255","instance":15255,"id":251942,"goal":"predicate IsPermutation_15255(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_15256","instance":15256,"id":251943,"goal":"predicate IsEven_15256(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_15257","instance":15257,"id":251944,"goal":"predicate InRange_15257(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_15258","instance":15258,"id":251945,"goal":"predicate SubsetOf_15258(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_15259","instance":15259,"id":251946,"goal":"predicate AllMem_15259(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_15260","instance":15260,"id":251947,"goal":"predicate DisjointSets_15260(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_15261","instance":15261,"id":251948,"goal":"predicate Sorted_15261(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_15262","instance":15262,"id":251949,"goal":"predicate AllPositive_15262(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_15263","instance":15263,"id":251950,"goal":"predicate DistinctSeq_15263(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_15264","instance":15264,"id":251951,"goal":"predicate IsSubseq_15264(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_15265","instance":15265,"id":251952,"goal":"predicate IsPermutation_15265(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_15266","instance":15266,"id":251953,"goal":"predicate IsEven_15266(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_15267","instance":15267,"id":251954,"goal":"predicate InRange_15267(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_15268","instance":15268,"id":251955,"goal":"predicate SubsetOf_15268(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_15269","instance":15269,"id":251956,"goal":"predicate AllMem_15269(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_15270","instance":15270,"id":251957,"goal":"predicate DisjointSets_15270(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_15271","instance":15271,"id":251958,"goal":"predicate Sorted_15271(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_15272","instance":15272,"id":251959,"goal":"predicate AllPositive_15272(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_15273","instance":15273,"id":251960,"goal":"predicate DistinctSeq_15273(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_15274","instance":15274,"id":251961,"goal":"predicate IsSubseq_15274(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_15275","instance":15275,"id":251962,"goal":"predicate IsPermutation_15275(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_15276","instance":15276,"id":251963,"goal":"predicate IsEven_15276(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_15277","instance":15277,"id":251964,"goal":"predicate InRange_15277(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_15278","instance":15278,"id":251965,"goal":"predicate SubsetOf_15278(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_15279","instance":15279,"id":251966,"goal":"predicate AllMem_15279(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_15280","instance":15280,"id":251967,"goal":"predicate DisjointSets_15280(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_15281","instance":15281,"id":251968,"goal":"predicate Sorted_15281(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_15282","instance":15282,"id":251969,"goal":"predicate AllPositive_15282(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_15283","instance":15283,"id":251970,"goal":"predicate DistinctSeq_15283(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_15284","instance":15284,"id":251971,"goal":"predicate IsSubseq_15284(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_15285","instance":15285,"id":251972,"goal":"predicate IsPermutation_15285(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_15286","instance":15286,"id":251973,"goal":"predicate IsEven_15286(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_15287","instance":15287,"id":251974,"goal":"predicate InRange_15287(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_15288","instance":15288,"id":251975,"goal":"predicate SubsetOf_15288(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_15289","instance":15289,"id":251976,"goal":"predicate AllMem_15289(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_15290","instance":15290,"id":251977,"goal":"predicate DisjointSets_15290(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_15291","instance":15291,"id":251978,"goal":"predicate Sorted_15291(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_15292","instance":15292,"id":251979,"goal":"predicate AllPositive_15292(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_15293","instance":15293,"id":251980,"goal":"predicate DistinctSeq_15293(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_15294","instance":15294,"id":251981,"goal":"predicate IsSubseq_15294(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_15295","instance":15295,"id":251982,"goal":"predicate IsPermutation_15295(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_15296","instance":15296,"id":251983,"goal":"predicate IsEven_15296(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_15297","instance":15297,"id":251984,"goal":"predicate InRange_15297(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_15298","instance":15298,"id":251985,"goal":"predicate SubsetOf_15298(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_15299","instance":15299,"id":251986,"goal":"predicate AllMem_15299(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_15300","instance":15300,"id":251987,"goal":"predicate DisjointSets_15300(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_15301","instance":15301,"id":251988,"goal":"predicate Sorted_15301(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_15302","instance":15302,"id":251989,"goal":"predicate AllPositive_15302(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_15303","instance":15303,"id":251990,"goal":"predicate DistinctSeq_15303(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_15304","instance":15304,"id":251991,"goal":"predicate IsSubseq_15304(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_15305","instance":15305,"id":251992,"goal":"predicate IsPermutation_15305(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_15306","instance":15306,"id":251993,"goal":"predicate IsEven_15306(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_15307","instance":15307,"id":251994,"goal":"predicate InRange_15307(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_15308","instance":15308,"id":251995,"goal":"predicate SubsetOf_15308(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_15309","instance":15309,"id":251996,"goal":"predicate AllMem_15309(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_15310","instance":15310,"id":251997,"goal":"predicate DisjointSets_15310(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_15311","instance":15311,"id":251998,"goal":"predicate Sorted_15311(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_15312","instance":15312,"id":251999,"goal":"predicate AllPositive_15312(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_15313","instance":15313,"id":252000,"goal":"predicate DistinctSeq_15313(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_15314","instance":15314,"id":252001,"goal":"predicate IsSubseq_15314(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_15315","instance":15315,"id":252002,"goal":"predicate IsPermutation_15315(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_15316","instance":15316,"id":252003,"goal":"predicate IsEven_15316(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_15317","instance":15317,"id":252004,"goal":"predicate InRange_15317(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_15318","instance":15318,"id":252005,"goal":"predicate SubsetOf_15318(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_15319","instance":15319,"id":252006,"goal":"predicate AllMem_15319(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_15320","instance":15320,"id":252007,"goal":"predicate DisjointSets_15320(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_15321","instance":15321,"id":252008,"goal":"predicate Sorted_15321(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_15322","instance":15322,"id":252009,"goal":"predicate AllPositive_15322(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_15323","instance":15323,"id":252010,"goal":"predicate DistinctSeq_15323(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_15324","instance":15324,"id":252011,"goal":"predicate IsSubseq_15324(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_15325","instance":15325,"id":252012,"goal":"predicate IsPermutation_15325(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_15326","instance":15326,"id":252013,"goal":"predicate IsEven_15326(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_15327","instance":15327,"id":252014,"goal":"predicate InRange_15327(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_15328","instance":15328,"id":252015,"goal":"predicate SubsetOf_15328(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_15329","instance":15329,"id":252016,"goal":"predicate AllMem_15329(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_15330","instance":15330,"id":252017,"goal":"predicate DisjointSets_15330(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_15331","instance":15331,"id":252018,"goal":"predicate Sorted_15331(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_15332","instance":15332,"id":252019,"goal":"predicate AllPositive_15332(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_15333","instance":15333,"id":252020,"goal":"predicate DistinctSeq_15333(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_15334","instance":15334,"id":252021,"goal":"predicate IsSubseq_15334(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_15335","instance":15335,"id":252022,"goal":"predicate IsPermutation_15335(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_15336","instance":15336,"id":252023,"goal":"predicate IsEven_15336(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_15337","instance":15337,"id":252024,"goal":"predicate InRange_15337(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_15338","instance":15338,"id":252025,"goal":"predicate SubsetOf_15338(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_15339","instance":15339,"id":252026,"goal":"predicate AllMem_15339(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_15340","instance":15340,"id":252027,"goal":"predicate DisjointSets_15340(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_15341","instance":15341,"id":252028,"goal":"predicate Sorted_15341(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_15342","instance":15342,"id":252029,"goal":"predicate AllPositive_15342(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_15343","instance":15343,"id":252030,"goal":"predicate DistinctSeq_15343(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_15344","instance":15344,"id":252031,"goal":"predicate IsSubseq_15344(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_15345","instance":15345,"id":252032,"goal":"predicate IsPermutation_15345(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_15346","instance":15346,"id":252033,"goal":"predicate IsEven_15346(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_15347","instance":15347,"id":252034,"goal":"predicate InRange_15347(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_15348","instance":15348,"id":252035,"goal":"predicate SubsetOf_15348(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_15349","instance":15349,"id":252036,"goal":"predicate AllMem_15349(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_15350","instance":15350,"id":252037,"goal":"predicate DisjointSets_15350(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_15351","instance":15351,"id":252038,"goal":"predicate Sorted_15351(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_15352","instance":15352,"id":252039,"goal":"predicate AllPositive_15352(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_15353","instance":15353,"id":252040,"goal":"predicate DistinctSeq_15353(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_15354","instance":15354,"id":252041,"goal":"predicate IsSubseq_15354(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_15355","instance":15355,"id":252042,"goal":"predicate IsPermutation_15355(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_15356","instance":15356,"id":252043,"goal":"predicate IsEven_15356(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_15357","instance":15357,"id":252044,"goal":"predicate InRange_15357(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_15358","instance":15358,"id":252045,"goal":"predicate SubsetOf_15358(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_15359","instance":15359,"id":252046,"goal":"predicate AllMem_15359(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_15360","instance":15360,"id":252047,"goal":"predicate DisjointSets_15360(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_15361","instance":15361,"id":252048,"goal":"predicate Sorted_15361(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_15362","instance":15362,"id":252049,"goal":"predicate AllPositive_15362(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_15363","instance":15363,"id":252050,"goal":"predicate DistinctSeq_15363(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_15364","instance":15364,"id":252051,"goal":"predicate IsSubseq_15364(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_15365","instance":15365,"id":252052,"goal":"predicate IsPermutation_15365(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_15366","instance":15366,"id":252053,"goal":"predicate IsEven_15366(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_15367","instance":15367,"id":252054,"goal":"predicate InRange_15367(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_15368","instance":15368,"id":252055,"goal":"predicate SubsetOf_15368(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_15369","instance":15369,"id":252056,"goal":"predicate AllMem_15369(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_15370","instance":15370,"id":252057,"goal":"predicate DisjointSets_15370(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_15371","instance":15371,"id":252058,"goal":"predicate Sorted_15371(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_15372","instance":15372,"id":252059,"goal":"predicate AllPositive_15372(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_15373","instance":15373,"id":252060,"goal":"predicate DistinctSeq_15373(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_15374","instance":15374,"id":252061,"goal":"predicate IsSubseq_15374(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_15375","instance":15375,"id":252062,"goal":"predicate IsPermutation_15375(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_15376","instance":15376,"id":252063,"goal":"predicate IsEven_15376(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_15377","instance":15377,"id":252064,"goal":"predicate InRange_15377(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_15378","instance":15378,"id":252065,"goal":"predicate SubsetOf_15378(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_15379","instance":15379,"id":252066,"goal":"predicate AllMem_15379(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_15380","instance":15380,"id":252067,"goal":"predicate DisjointSets_15380(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_15381","instance":15381,"id":252068,"goal":"predicate Sorted_15381(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_15382","instance":15382,"id":252069,"goal":"predicate AllPositive_15382(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_15383","instance":15383,"id":252070,"goal":"predicate DistinctSeq_15383(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_15384","instance":15384,"id":252071,"goal":"predicate IsSubseq_15384(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_15385","instance":15385,"id":252072,"goal":"predicate IsPermutation_15385(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_15386","instance":15386,"id":252073,"goal":"predicate IsEven_15386(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_15387","instance":15387,"id":252074,"goal":"predicate InRange_15387(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_15388","instance":15388,"id":252075,"goal":"predicate SubsetOf_15388(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_15389","instance":15389,"id":252076,"goal":"predicate AllMem_15389(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_15390","instance":15390,"id":252077,"goal":"predicate DisjointSets_15390(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_15391","instance":15391,"id":252078,"goal":"predicate Sorted_15391(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_15392","instance":15392,"id":252079,"goal":"predicate AllPositive_15392(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_15393","instance":15393,"id":252080,"goal":"predicate DistinctSeq_15393(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_15394","instance":15394,"id":252081,"goal":"predicate IsSubseq_15394(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_15395","instance":15395,"id":252082,"goal":"predicate IsPermutation_15395(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_15396","instance":15396,"id":252083,"goal":"predicate IsEven_15396(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_15397","instance":15397,"id":252084,"goal":"predicate InRange_15397(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_15398","instance":15398,"id":252085,"goal":"predicate SubsetOf_15398(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_15399","instance":15399,"id":252086,"goal":"predicate AllMem_15399(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_15400","instance":15400,"id":252087,"goal":"predicate DisjointSets_15400(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_15401","instance":15401,"id":252088,"goal":"predicate Sorted_15401(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_15402","instance":15402,"id":252089,"goal":"predicate AllPositive_15402(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_15403","instance":15403,"id":252090,"goal":"predicate DistinctSeq_15403(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_15404","instance":15404,"id":252091,"goal":"predicate IsSubseq_15404(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_15405","instance":15405,"id":252092,"goal":"predicate IsPermutation_15405(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_15406","instance":15406,"id":252093,"goal":"predicate IsEven_15406(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_15407","instance":15407,"id":252094,"goal":"predicate InRange_15407(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_15408","instance":15408,"id":252095,"goal":"predicate SubsetOf_15408(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_15409","instance":15409,"id":252096,"goal":"predicate AllMem_15409(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_15410","instance":15410,"id":252097,"goal":"predicate DisjointSets_15410(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_15411","instance":15411,"id":252098,"goal":"predicate Sorted_15411(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_15412","instance":15412,"id":252099,"goal":"predicate AllPositive_15412(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_15413","instance":15413,"id":252100,"goal":"predicate DistinctSeq_15413(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_15414","instance":15414,"id":252101,"goal":"predicate IsSubseq_15414(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_15415","instance":15415,"id":252102,"goal":"predicate IsPermutation_15415(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_15416","instance":15416,"id":252103,"goal":"predicate IsEven_15416(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_15417","instance":15417,"id":252104,"goal":"predicate InRange_15417(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_15418","instance":15418,"id":252105,"goal":"predicate SubsetOf_15418(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_15419","instance":15419,"id":252106,"goal":"predicate AllMem_15419(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_15420","instance":15420,"id":252107,"goal":"predicate DisjointSets_15420(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_15421","instance":15421,"id":252108,"goal":"predicate Sorted_15421(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_15422","instance":15422,"id":252109,"goal":"predicate AllPositive_15422(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_15423","instance":15423,"id":252110,"goal":"predicate DistinctSeq_15423(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_15424","instance":15424,"id":252111,"goal":"predicate IsSubseq_15424(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_15425","instance":15425,"id":252112,"goal":"predicate IsPermutation_15425(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_15426","instance":15426,"id":252113,"goal":"predicate IsEven_15426(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_15427","instance":15427,"id":252114,"goal":"predicate InRange_15427(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_15428","instance":15428,"id":252115,"goal":"predicate SubsetOf_15428(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_15429","instance":15429,"id":252116,"goal":"predicate AllMem_15429(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_15430","instance":15430,"id":252117,"goal":"predicate DisjointSets_15430(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_15431","instance":15431,"id":252118,"goal":"predicate Sorted_15431(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_15432","instance":15432,"id":252119,"goal":"predicate AllPositive_15432(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_15433","instance":15433,"id":252120,"goal":"predicate DistinctSeq_15433(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_15434","instance":15434,"id":252121,"goal":"predicate IsSubseq_15434(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_15435","instance":15435,"id":252122,"goal":"predicate IsPermutation_15435(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_15436","instance":15436,"id":252123,"goal":"predicate IsEven_15436(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_15437","instance":15437,"id":252124,"goal":"predicate InRange_15437(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_15438","instance":15438,"id":252125,"goal":"predicate SubsetOf_15438(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_15439","instance":15439,"id":252126,"goal":"predicate AllMem_15439(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_15440","instance":15440,"id":252127,"goal":"predicate DisjointSets_15440(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_15441","instance":15441,"id":252128,"goal":"predicate Sorted_15441(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_15442","instance":15442,"id":252129,"goal":"predicate AllPositive_15442(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_15443","instance":15443,"id":252130,"goal":"predicate DistinctSeq_15443(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_15444","instance":15444,"id":252131,"goal":"predicate IsSubseq_15444(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_15445","instance":15445,"id":252132,"goal":"predicate IsPermutation_15445(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_15446","instance":15446,"id":252133,"goal":"predicate IsEven_15446(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_15447","instance":15447,"id":252134,"goal":"predicate InRange_15447(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_15448","instance":15448,"id":252135,"goal":"predicate SubsetOf_15448(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_15449","instance":15449,"id":252136,"goal":"predicate AllMem_15449(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_15450","instance":15450,"id":252137,"goal":"predicate DisjointSets_15450(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_15451","instance":15451,"id":252138,"goal":"predicate Sorted_15451(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_15452","instance":15452,"id":252139,"goal":"predicate AllPositive_15452(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_15453","instance":15453,"id":252140,"goal":"predicate DistinctSeq_15453(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_15454","instance":15454,"id":252141,"goal":"predicate IsSubseq_15454(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_15455","instance":15455,"id":252142,"goal":"predicate IsPermutation_15455(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_15456","instance":15456,"id":252143,"goal":"predicate IsEven_15456(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_15457","instance":15457,"id":252144,"goal":"predicate InRange_15457(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_15458","instance":15458,"id":252145,"goal":"predicate SubsetOf_15458(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_15459","instance":15459,"id":252146,"goal":"predicate AllMem_15459(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_15460","instance":15460,"id":252147,"goal":"predicate DisjointSets_15460(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_15461","instance":15461,"id":252148,"goal":"predicate Sorted_15461(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_15462","instance":15462,"id":252149,"goal":"predicate AllPositive_15462(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_15463","instance":15463,"id":252150,"goal":"predicate DistinctSeq_15463(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_15464","instance":15464,"id":252151,"goal":"predicate IsSubseq_15464(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_15465","instance":15465,"id":252152,"goal":"predicate IsPermutation_15465(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_15466","instance":15466,"id":252153,"goal":"predicate IsEven_15466(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_15467","instance":15467,"id":252154,"goal":"predicate InRange_15467(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_15468","instance":15468,"id":252155,"goal":"predicate SubsetOf_15468(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_15469","instance":15469,"id":252156,"goal":"predicate AllMem_15469(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_15470","instance":15470,"id":252157,"goal":"predicate DisjointSets_15470(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_15471","instance":15471,"id":252158,"goal":"predicate Sorted_15471(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_15472","instance":15472,"id":252159,"goal":"predicate AllPositive_15472(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_15473","instance":15473,"id":252160,"goal":"predicate DistinctSeq_15473(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_15474","instance":15474,"id":252161,"goal":"predicate IsSubseq_15474(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_15475","instance":15475,"id":252162,"goal":"predicate IsPermutation_15475(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_15476","instance":15476,"id":252163,"goal":"predicate IsEven_15476(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_15477","instance":15477,"id":252164,"goal":"predicate InRange_15477(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_15478","instance":15478,"id":252165,"goal":"predicate SubsetOf_15478(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_15479","instance":15479,"id":252166,"goal":"predicate AllMem_15479(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_15480","instance":15480,"id":252167,"goal":"predicate DisjointSets_15480(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_15481","instance":15481,"id":252168,"goal":"predicate Sorted_15481(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_15482","instance":15482,"id":252169,"goal":"predicate AllPositive_15482(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_15483","instance":15483,"id":252170,"goal":"predicate DistinctSeq_15483(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_15484","instance":15484,"id":252171,"goal":"predicate IsSubseq_15484(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_15485","instance":15485,"id":252172,"goal":"predicate IsPermutation_15485(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_15486","instance":15486,"id":252173,"goal":"predicate IsEven_15486(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_15487","instance":15487,"id":252174,"goal":"predicate InRange_15487(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_15488","instance":15488,"id":252175,"goal":"predicate SubsetOf_15488(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_15489","instance":15489,"id":252176,"goal":"predicate AllMem_15489(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_15490","instance":15490,"id":252177,"goal":"predicate DisjointSets_15490(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_15491","instance":15491,"id":252178,"goal":"predicate Sorted_15491(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_15492","instance":15492,"id":252179,"goal":"predicate AllPositive_15492(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_15493","instance":15493,"id":252180,"goal":"predicate DistinctSeq_15493(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_15494","instance":15494,"id":252181,"goal":"predicate IsSubseq_15494(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_15495","instance":15495,"id":252182,"goal":"predicate IsPermutation_15495(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_15496","instance":15496,"id":252183,"goal":"predicate IsEven_15496(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_15497","instance":15497,"id":252184,"goal":"predicate InRange_15497(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_15498","instance":15498,"id":252185,"goal":"predicate SubsetOf_15498(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_15499","instance":15499,"id":252186,"goal":"predicate AllMem_15499(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_15500","instance":15500,"id":252187,"goal":"predicate DisjointSets_15500(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_15501","instance":15501,"id":252188,"goal":"predicate Sorted_15501(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_15502","instance":15502,"id":252189,"goal":"predicate AllPositive_15502(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_15503","instance":15503,"id":252190,"goal":"predicate DistinctSeq_15503(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_15504","instance":15504,"id":252191,"goal":"predicate IsSubseq_15504(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_15505","instance":15505,"id":252192,"goal":"predicate IsPermutation_15505(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_15506","instance":15506,"id":252193,"goal":"predicate IsEven_15506(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_15507","instance":15507,"id":252194,"goal":"predicate InRange_15507(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_15508","instance":15508,"id":252195,"goal":"predicate SubsetOf_15508(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_15509","instance":15509,"id":252196,"goal":"predicate AllMem_15509(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_15510","instance":15510,"id":252197,"goal":"predicate DisjointSets_15510(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_15511","instance":15511,"id":252198,"goal":"predicate Sorted_15511(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_15512","instance":15512,"id":252199,"goal":"predicate AllPositive_15512(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_15513","instance":15513,"id":252200,"goal":"predicate DistinctSeq_15513(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_15514","instance":15514,"id":252201,"goal":"predicate IsSubseq_15514(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_15515","instance":15515,"id":252202,"goal":"predicate IsPermutation_15515(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_15516","instance":15516,"id":252203,"goal":"predicate IsEven_15516(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_15517","instance":15517,"id":252204,"goal":"predicate InRange_15517(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_15518","instance":15518,"id":252205,"goal":"predicate SubsetOf_15518(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_15519","instance":15519,"id":252206,"goal":"predicate AllMem_15519(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_15520","instance":15520,"id":252207,"goal":"predicate DisjointSets_15520(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_15521","instance":15521,"id":252208,"goal":"predicate Sorted_15521(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_15522","instance":15522,"id":252209,"goal":"predicate AllPositive_15522(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_15523","instance":15523,"id":252210,"goal":"predicate DistinctSeq_15523(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_15524","instance":15524,"id":252211,"goal":"predicate IsSubseq_15524(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_15525","instance":15525,"id":252212,"goal":"predicate IsPermutation_15525(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_15526","instance":15526,"id":252213,"goal":"predicate IsEven_15526(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_15527","instance":15527,"id":252214,"goal":"predicate InRange_15527(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_15528","instance":15528,"id":252215,"goal":"predicate SubsetOf_15528(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_15529","instance":15529,"id":252216,"goal":"predicate AllMem_15529(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_15530","instance":15530,"id":252217,"goal":"predicate DisjointSets_15530(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_15531","instance":15531,"id":252218,"goal":"predicate Sorted_15531(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_15532","instance":15532,"id":252219,"goal":"predicate AllPositive_15532(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_15533","instance":15533,"id":252220,"goal":"predicate DistinctSeq_15533(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_15534","instance":15534,"id":252221,"goal":"predicate IsSubseq_15534(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_15535","instance":15535,"id":252222,"goal":"predicate IsPermutation_15535(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_15536","instance":15536,"id":252223,"goal":"predicate IsEven_15536(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_15537","instance":15537,"id":252224,"goal":"predicate InRange_15537(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_15538","instance":15538,"id":252225,"goal":"predicate SubsetOf_15538(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_15539","instance":15539,"id":252226,"goal":"predicate AllMem_15539(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_15540","instance":15540,"id":252227,"goal":"predicate DisjointSets_15540(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_15541","instance":15541,"id":252228,"goal":"predicate Sorted_15541(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_15542","instance":15542,"id":252229,"goal":"predicate AllPositive_15542(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_15543","instance":15543,"id":252230,"goal":"predicate DistinctSeq_15543(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_15544","instance":15544,"id":252231,"goal":"predicate IsSubseq_15544(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_15545","instance":15545,"id":252232,"goal":"predicate IsPermutation_15545(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_15546","instance":15546,"id":252233,"goal":"predicate IsEven_15546(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_15547","instance":15547,"id":252234,"goal":"predicate InRange_15547(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_15548","instance":15548,"id":252235,"goal":"predicate SubsetOf_15548(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_15549","instance":15549,"id":252236,"goal":"predicate AllMem_15549(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_15550","instance":15550,"id":252237,"goal":"predicate DisjointSets_15550(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_15551","instance":15551,"id":252238,"goal":"predicate Sorted_15551(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_15552","instance":15552,"id":252239,"goal":"predicate AllPositive_15552(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_15553","instance":15553,"id":252240,"goal":"predicate DistinctSeq_15553(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_15554","instance":15554,"id":252241,"goal":"predicate IsSubseq_15554(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_15555","instance":15555,"id":252242,"goal":"predicate IsPermutation_15555(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_15556","instance":15556,"id":252243,"goal":"predicate IsEven_15556(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_15557","instance":15557,"id":252244,"goal":"predicate InRange_15557(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_15558","instance":15558,"id":252245,"goal":"predicate SubsetOf_15558(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_15559","instance":15559,"id":252246,"goal":"predicate AllMem_15559(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_15560","instance":15560,"id":252247,"goal":"predicate DisjointSets_15560(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_15561","instance":15561,"id":252248,"goal":"predicate Sorted_15561(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_15562","instance":15562,"id":252249,"goal":"predicate AllPositive_15562(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_15563","instance":15563,"id":252250,"goal":"predicate DistinctSeq_15563(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_15564","instance":15564,"id":252251,"goal":"predicate IsSubseq_15564(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_15565","instance":15565,"id":252252,"goal":"predicate IsPermutation_15565(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_15566","instance":15566,"id":252253,"goal":"predicate IsEven_15566(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_15567","instance":15567,"id":252254,"goal":"predicate InRange_15567(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_15568","instance":15568,"id":252255,"goal":"predicate SubsetOf_15568(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_15569","instance":15569,"id":252256,"goal":"predicate AllMem_15569(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_15570","instance":15570,"id":252257,"goal":"predicate DisjointSets_15570(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_15571","instance":15571,"id":252258,"goal":"predicate Sorted_15571(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_15572","instance":15572,"id":252259,"goal":"predicate AllPositive_15572(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_15573","instance":15573,"id":252260,"goal":"predicate DistinctSeq_15573(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_15574","instance":15574,"id":252261,"goal":"predicate IsSubseq_15574(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_15575","instance":15575,"id":252262,"goal":"predicate IsPermutation_15575(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_15576","instance":15576,"id":252263,"goal":"predicate IsEven_15576(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_15577","instance":15577,"id":252264,"goal":"predicate InRange_15577(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_15578","instance":15578,"id":252265,"goal":"predicate SubsetOf_15578(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_15579","instance":15579,"id":252266,"goal":"predicate AllMem_15579(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_15580","instance":15580,"id":252267,"goal":"predicate DisjointSets_15580(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_15581","instance":15581,"id":252268,"goal":"predicate Sorted_15581(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_15582","instance":15582,"id":252269,"goal":"predicate AllPositive_15582(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_15583","instance":15583,"id":252270,"goal":"predicate DistinctSeq_15583(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_15584","instance":15584,"id":252271,"goal":"predicate IsSubseq_15584(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_15585","instance":15585,"id":252272,"goal":"predicate IsPermutation_15585(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_15586","instance":15586,"id":252273,"goal":"predicate IsEven_15586(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_15587","instance":15587,"id":252274,"goal":"predicate InRange_15587(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_15588","instance":15588,"id":252275,"goal":"predicate SubsetOf_15588(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_15589","instance":15589,"id":252276,"goal":"predicate AllMem_15589(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_15590","instance":15590,"id":252277,"goal":"predicate DisjointSets_15590(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_15591","instance":15591,"id":252278,"goal":"predicate Sorted_15591(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_15592","instance":15592,"id":252279,"goal":"predicate AllPositive_15592(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_15593","instance":15593,"id":252280,"goal":"predicate DistinctSeq_15593(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_15594","instance":15594,"id":252281,"goal":"predicate IsSubseq_15594(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_15595","instance":15595,"id":252282,"goal":"predicate IsPermutation_15595(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_15596","instance":15596,"id":252283,"goal":"predicate IsEven_15596(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_15597","instance":15597,"id":252284,"goal":"predicate InRange_15597(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_15598","instance":15598,"id":252285,"goal":"predicate SubsetOf_15598(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_15599","instance":15599,"id":252286,"goal":"predicate AllMem_15599(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_15600","instance":15600,"id":252287,"goal":"predicate DisjointSets_15600(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_15601","instance":15601,"id":252288,"goal":"predicate Sorted_15601(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_15602","instance":15602,"id":252289,"goal":"predicate AllPositive_15602(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_15603","instance":15603,"id":252290,"goal":"predicate DistinctSeq_15603(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_15604","instance":15604,"id":252291,"goal":"predicate IsSubseq_15604(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_15605","instance":15605,"id":252292,"goal":"predicate IsPermutation_15605(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_15606","instance":15606,"id":252293,"goal":"predicate IsEven_15606(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_15607","instance":15607,"id":252294,"goal":"predicate InRange_15607(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_15608","instance":15608,"id":252295,"goal":"predicate SubsetOf_15608(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_15609","instance":15609,"id":252296,"goal":"predicate AllMem_15609(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_15610","instance":15610,"id":252297,"goal":"predicate DisjointSets_15610(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_15611","instance":15611,"id":252298,"goal":"predicate Sorted_15611(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_15612","instance":15612,"id":252299,"goal":"predicate AllPositive_15612(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_15613","instance":15613,"id":252300,"goal":"predicate DistinctSeq_15613(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_15614","instance":15614,"id":252301,"goal":"predicate IsSubseq_15614(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_15615","instance":15615,"id":252302,"goal":"predicate IsPermutation_15615(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_15616","instance":15616,"id":252303,"goal":"predicate IsEven_15616(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_15617","instance":15617,"id":252304,"goal":"predicate InRange_15617(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_15618","instance":15618,"id":252305,"goal":"predicate SubsetOf_15618(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_15619","instance":15619,"id":252306,"goal":"predicate AllMem_15619(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_15620","instance":15620,"id":252307,"goal":"predicate DisjointSets_15620(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_15621","instance":15621,"id":252308,"goal":"predicate Sorted_15621(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_15622","instance":15622,"id":252309,"goal":"predicate AllPositive_15622(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_15623","instance":15623,"id":252310,"goal":"predicate DistinctSeq_15623(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_15624","instance":15624,"id":252311,"goal":"predicate IsSubseq_15624(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_15625","instance":15625,"id":252312,"goal":"predicate IsPermutation_15625(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_15626","instance":15626,"id":252313,"goal":"predicate IsEven_15626(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_15627","instance":15627,"id":252314,"goal":"predicate InRange_15627(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_15628","instance":15628,"id":252315,"goal":"predicate SubsetOf_15628(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_15629","instance":15629,"id":252316,"goal":"predicate AllMem_15629(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_15630","instance":15630,"id":252317,"goal":"predicate DisjointSets_15630(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_15631","instance":15631,"id":252318,"goal":"predicate Sorted_15631(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_15632","instance":15632,"id":252319,"goal":"predicate AllPositive_15632(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_15633","instance":15633,"id":252320,"goal":"predicate DistinctSeq_15633(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_15634","instance":15634,"id":252321,"goal":"predicate IsSubseq_15634(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_15635","instance":15635,"id":252322,"goal":"predicate IsPermutation_15635(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_15636","instance":15636,"id":252323,"goal":"predicate IsEven_15636(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_15637","instance":15637,"id":252324,"goal":"predicate InRange_15637(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_15638","instance":15638,"id":252325,"goal":"predicate SubsetOf_15638(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_15639","instance":15639,"id":252326,"goal":"predicate AllMem_15639(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_15640","instance":15640,"id":252327,"goal":"predicate DisjointSets_15640(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_15641","instance":15641,"id":252328,"goal":"predicate Sorted_15641(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_15642","instance":15642,"id":252329,"goal":"predicate AllPositive_15642(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_15643","instance":15643,"id":252330,"goal":"predicate DistinctSeq_15643(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_15644","instance":15644,"id":252331,"goal":"predicate IsSubseq_15644(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_15645","instance":15645,"id":252332,"goal":"predicate IsPermutation_15645(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_15646","instance":15646,"id":252333,"goal":"predicate IsEven_15646(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_15647","instance":15647,"id":252334,"goal":"predicate InRange_15647(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_15648","instance":15648,"id":252335,"goal":"predicate SubsetOf_15648(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_15649","instance":15649,"id":252336,"goal":"predicate AllMem_15649(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_15650","instance":15650,"id":252337,"goal":"predicate DisjointSets_15650(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_15651","instance":15651,"id":252338,"goal":"predicate Sorted_15651(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_15652","instance":15652,"id":252339,"goal":"predicate AllPositive_15652(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_15653","instance":15653,"id":252340,"goal":"predicate DistinctSeq_15653(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_15654","instance":15654,"id":252341,"goal":"predicate IsSubseq_15654(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_15655","instance":15655,"id":252342,"goal":"predicate IsPermutation_15655(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_15656","instance":15656,"id":252343,"goal":"predicate IsEven_15656(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_15657","instance":15657,"id":252344,"goal":"predicate InRange_15657(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_15658","instance":15658,"id":252345,"goal":"predicate SubsetOf_15658(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_15659","instance":15659,"id":252346,"goal":"predicate AllMem_15659(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_15660","instance":15660,"id":252347,"goal":"predicate DisjointSets_15660(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_15661","instance":15661,"id":252348,"goal":"predicate Sorted_15661(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_15662","instance":15662,"id":252349,"goal":"predicate AllPositive_15662(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_15663","instance":15663,"id":252350,"goal":"predicate DistinctSeq_15663(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_15664","instance":15664,"id":252351,"goal":"predicate IsSubseq_15664(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_15665","instance":15665,"id":252352,"goal":"predicate IsPermutation_15665(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_15666","instance":15666,"id":252353,"goal":"predicate IsEven_15666(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_15667","instance":15667,"id":252354,"goal":"predicate InRange_15667(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_15668","instance":15668,"id":252355,"goal":"predicate SubsetOf_15668(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_15669","instance":15669,"id":252356,"goal":"predicate AllMem_15669(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_15670","instance":15670,"id":252357,"goal":"predicate DisjointSets_15670(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_15671","instance":15671,"id":252358,"goal":"predicate Sorted_15671(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_15672","instance":15672,"id":252359,"goal":"predicate AllPositive_15672(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_15673","instance":15673,"id":252360,"goal":"predicate DistinctSeq_15673(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_15674","instance":15674,"id":252361,"goal":"predicate IsSubseq_15674(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_15675","instance":15675,"id":252362,"goal":"predicate IsPermutation_15675(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_15676","instance":15676,"id":252363,"goal":"predicate IsEven_15676(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_15677","instance":15677,"id":252364,"goal":"predicate InRange_15677(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_15678","instance":15678,"id":252365,"goal":"predicate SubsetOf_15678(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_15679","instance":15679,"id":252366,"goal":"predicate AllMem_15679(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_15680","instance":15680,"id":252367,"goal":"predicate DisjointSets_15680(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_15681","instance":15681,"id":252368,"goal":"predicate Sorted_15681(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_15682","instance":15682,"id":252369,"goal":"predicate AllPositive_15682(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_15683","instance":15683,"id":252370,"goal":"predicate DistinctSeq_15683(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_15684","instance":15684,"id":252371,"goal":"predicate IsSubseq_15684(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_15685","instance":15685,"id":252372,"goal":"predicate IsPermutation_15685(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_15686","instance":15686,"id":252373,"goal":"predicate IsEven_15686(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_15687","instance":15687,"id":252374,"goal":"predicate InRange_15687(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_15688","instance":15688,"id":252375,"goal":"predicate SubsetOf_15688(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_15689","instance":15689,"id":252376,"goal":"predicate AllMem_15689(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_15690","instance":15690,"id":252377,"goal":"predicate DisjointSets_15690(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_15691","instance":15691,"id":252378,"goal":"predicate Sorted_15691(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_15692","instance":15692,"id":252379,"goal":"predicate AllPositive_15692(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_15693","instance":15693,"id":252380,"goal":"predicate DistinctSeq_15693(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_15694","instance":15694,"id":252381,"goal":"predicate IsSubseq_15694(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_15695","instance":15695,"id":252382,"goal":"predicate IsPermutation_15695(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_15696","instance":15696,"id":252383,"goal":"predicate IsEven_15696(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_15697","instance":15697,"id":252384,"goal":"predicate InRange_15697(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_15698","instance":15698,"id":252385,"goal":"predicate SubsetOf_15698(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_15699","instance":15699,"id":252386,"goal":"predicate AllMem_15699(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_15700","instance":15700,"id":252387,"goal":"predicate DisjointSets_15700(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_15701","instance":15701,"id":252388,"goal":"predicate Sorted_15701(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_15702","instance":15702,"id":252389,"goal":"predicate AllPositive_15702(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_15703","instance":15703,"id":252390,"goal":"predicate DistinctSeq_15703(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_15704","instance":15704,"id":252391,"goal":"predicate IsSubseq_15704(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_15705","instance":15705,"id":252392,"goal":"predicate IsPermutation_15705(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_15706","instance":15706,"id":252393,"goal":"predicate IsEven_15706(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_15707","instance":15707,"id":252394,"goal":"predicate InRange_15707(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_15708","instance":15708,"id":252395,"goal":"predicate SubsetOf_15708(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_15709","instance":15709,"id":252396,"goal":"predicate AllMem_15709(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_15710","instance":15710,"id":252397,"goal":"predicate DisjointSets_15710(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_15711","instance":15711,"id":252398,"goal":"predicate Sorted_15711(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_15712","instance":15712,"id":252399,"goal":"predicate AllPositive_15712(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_15713","instance":15713,"id":252400,"goal":"predicate DistinctSeq_15713(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_15714","instance":15714,"id":252401,"goal":"predicate IsSubseq_15714(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_15715","instance":15715,"id":252402,"goal":"predicate IsPermutation_15715(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_15716","instance":15716,"id":252403,"goal":"predicate IsEven_15716(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_15717","instance":15717,"id":252404,"goal":"predicate InRange_15717(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_15718","instance":15718,"id":252405,"goal":"predicate SubsetOf_15718(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_15719","instance":15719,"id":252406,"goal":"predicate AllMem_15719(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_15720","instance":15720,"id":252407,"goal":"predicate DisjointSets_15720(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_15721","instance":15721,"id":252408,"goal":"predicate Sorted_15721(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_15722","instance":15722,"id":252409,"goal":"predicate AllPositive_15722(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_15723","instance":15723,"id":252410,"goal":"predicate DistinctSeq_15723(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_15724","instance":15724,"id":252411,"goal":"predicate IsSubseq_15724(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_15725","instance":15725,"id":252412,"goal":"predicate IsPermutation_15725(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_15726","instance":15726,"id":252413,"goal":"predicate IsEven_15726(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_15727","instance":15727,"id":252414,"goal":"predicate InRange_15727(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_15728","instance":15728,"id":252415,"goal":"predicate SubsetOf_15728(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_15729","instance":15729,"id":252416,"goal":"predicate AllMem_15729(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_15730","instance":15730,"id":252417,"goal":"predicate DisjointSets_15730(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_15731","instance":15731,"id":252418,"goal":"predicate Sorted_15731(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_15732","instance":15732,"id":252419,"goal":"predicate AllPositive_15732(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_15733","instance":15733,"id":252420,"goal":"predicate DistinctSeq_15733(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_15734","instance":15734,"id":252421,"goal":"predicate IsSubseq_15734(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_15735","instance":15735,"id":252422,"goal":"predicate IsPermutation_15735(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_15736","instance":15736,"id":252423,"goal":"predicate IsEven_15736(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_15737","instance":15737,"id":252424,"goal":"predicate InRange_15737(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_15738","instance":15738,"id":252425,"goal":"predicate SubsetOf_15738(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_15739","instance":15739,"id":252426,"goal":"predicate AllMem_15739(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_15740","instance":15740,"id":252427,"goal":"predicate DisjointSets_15740(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_15741","instance":15741,"id":252428,"goal":"predicate Sorted_15741(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_15742","instance":15742,"id":252429,"goal":"predicate AllPositive_15742(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_15743","instance":15743,"id":252430,"goal":"predicate DistinctSeq_15743(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_15744","instance":15744,"id":252431,"goal":"predicate IsSubseq_15744(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_15745","instance":15745,"id":252432,"goal":"predicate IsPermutation_15745(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_15746","instance":15746,"id":252433,"goal":"predicate IsEven_15746(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_15747","instance":15747,"id":252434,"goal":"predicate InRange_15747(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_15748","instance":15748,"id":252435,"goal":"predicate SubsetOf_15748(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_15749","instance":15749,"id":252436,"goal":"predicate AllMem_15749(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_15750","instance":15750,"id":252437,"goal":"predicate DisjointSets_15750(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_15751","instance":15751,"id":252438,"goal":"predicate Sorted_15751(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_15752","instance":15752,"id":252439,"goal":"predicate AllPositive_15752(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_15753","instance":15753,"id":252440,"goal":"predicate DistinctSeq_15753(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_15754","instance":15754,"id":252441,"goal":"predicate IsSubseq_15754(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_15755","instance":15755,"id":252442,"goal":"predicate IsPermutation_15755(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_15756","instance":15756,"id":252443,"goal":"predicate IsEven_15756(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_15757","instance":15757,"id":252444,"goal":"predicate InRange_15757(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_15758","instance":15758,"id":252445,"goal":"predicate SubsetOf_15758(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_15759","instance":15759,"id":252446,"goal":"predicate AllMem_15759(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_15760","instance":15760,"id":252447,"goal":"predicate DisjointSets_15760(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_15761","instance":15761,"id":252448,"goal":"predicate Sorted_15761(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_15762","instance":15762,"id":252449,"goal":"predicate AllPositive_15762(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_15763","instance":15763,"id":252450,"goal":"predicate DistinctSeq_15763(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_15764","instance":15764,"id":252451,"goal":"predicate IsSubseq_15764(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_15765","instance":15765,"id":252452,"goal":"predicate IsPermutation_15765(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_15766","instance":15766,"id":252453,"goal":"predicate IsEven_15766(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_15767","instance":15767,"id":252454,"goal":"predicate InRange_15767(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_15768","instance":15768,"id":252455,"goal":"predicate SubsetOf_15768(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_15769","instance":15769,"id":252456,"goal":"predicate AllMem_15769(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_15770","instance":15770,"id":252457,"goal":"predicate DisjointSets_15770(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_15771","instance":15771,"id":252458,"goal":"predicate Sorted_15771(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_15772","instance":15772,"id":252459,"goal":"predicate AllPositive_15772(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_15773","instance":15773,"id":252460,"goal":"predicate DistinctSeq_15773(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_15774","instance":15774,"id":252461,"goal":"predicate IsSubseq_15774(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_15775","instance":15775,"id":252462,"goal":"predicate IsPermutation_15775(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_15776","instance":15776,"id":252463,"goal":"predicate IsEven_15776(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_15777","instance":15777,"id":252464,"goal":"predicate InRange_15777(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_15778","instance":15778,"id":252465,"goal":"predicate SubsetOf_15778(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_15779","instance":15779,"id":252466,"goal":"predicate AllMem_15779(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_15780","instance":15780,"id":252467,"goal":"predicate DisjointSets_15780(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_15781","instance":15781,"id":252468,"goal":"predicate Sorted_15781(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_15782","instance":15782,"id":252469,"goal":"predicate AllPositive_15782(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_15783","instance":15783,"id":252470,"goal":"predicate DistinctSeq_15783(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_15784","instance":15784,"id":252471,"goal":"predicate IsSubseq_15784(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_15785","instance":15785,"id":252472,"goal":"predicate IsPermutation_15785(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_15786","instance":15786,"id":252473,"goal":"predicate IsEven_15786(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_15787","instance":15787,"id":252474,"goal":"predicate InRange_15787(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_15788","instance":15788,"id":252475,"goal":"predicate SubsetOf_15788(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_15789","instance":15789,"id":252476,"goal":"predicate AllMem_15789(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_15790","instance":15790,"id":252477,"goal":"predicate DisjointSets_15790(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_15791","instance":15791,"id":252478,"goal":"predicate Sorted_15791(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_15792","instance":15792,"id":252479,"goal":"predicate AllPositive_15792(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_15793","instance":15793,"id":252480,"goal":"predicate DistinctSeq_15793(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_15794","instance":15794,"id":252481,"goal":"predicate IsSubseq_15794(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_15795","instance":15795,"id":252482,"goal":"predicate IsPermutation_15795(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_15796","instance":15796,"id":252483,"goal":"predicate IsEven_15796(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_15797","instance":15797,"id":252484,"goal":"predicate InRange_15797(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_15798","instance":15798,"id":252485,"goal":"predicate SubsetOf_15798(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_15799","instance":15799,"id":252486,"goal":"predicate AllMem_15799(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_15800","instance":15800,"id":252487,"goal":"predicate DisjointSets_15800(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_15801","instance":15801,"id":252488,"goal":"predicate Sorted_15801(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_15802","instance":15802,"id":252489,"goal":"predicate AllPositive_15802(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_15803","instance":15803,"id":252490,"goal":"predicate DistinctSeq_15803(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_15804","instance":15804,"id":252491,"goal":"predicate IsSubseq_15804(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_15805","instance":15805,"id":252492,"goal":"predicate IsPermutation_15805(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_15806","instance":15806,"id":252493,"goal":"predicate IsEven_15806(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_15807","instance":15807,"id":252494,"goal":"predicate InRange_15807(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_15808","instance":15808,"id":252495,"goal":"predicate SubsetOf_15808(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_15809","instance":15809,"id":252496,"goal":"predicate AllMem_15809(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_15810","instance":15810,"id":252497,"goal":"predicate DisjointSets_15810(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_15811","instance":15811,"id":252498,"goal":"predicate Sorted_15811(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_15812","instance":15812,"id":252499,"goal":"predicate AllPositive_15812(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_15813","instance":15813,"id":252500,"goal":"predicate DistinctSeq_15813(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_15814","instance":15814,"id":252501,"goal":"predicate IsSubseq_15814(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_15815","instance":15815,"id":252502,"goal":"predicate IsPermutation_15815(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_15816","instance":15816,"id":252503,"goal":"predicate IsEven_15816(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_15817","instance":15817,"id":252504,"goal":"predicate InRange_15817(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_15818","instance":15818,"id":252505,"goal":"predicate SubsetOf_15818(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_15819","instance":15819,"id":252506,"goal":"predicate AllMem_15819(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_15820","instance":15820,"id":252507,"goal":"predicate DisjointSets_15820(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_15821","instance":15821,"id":252508,"goal":"predicate Sorted_15821(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_15822","instance":15822,"id":252509,"goal":"predicate AllPositive_15822(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_15823","instance":15823,"id":252510,"goal":"predicate DistinctSeq_15823(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_15824","instance":15824,"id":252511,"goal":"predicate IsSubseq_15824(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_15825","instance":15825,"id":252512,"goal":"predicate IsPermutation_15825(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_15826","instance":15826,"id":252513,"goal":"predicate IsEven_15826(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_15827","instance":15827,"id":252514,"goal":"predicate InRange_15827(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_15828","instance":15828,"id":252515,"goal":"predicate SubsetOf_15828(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_15829","instance":15829,"id":252516,"goal":"predicate AllMem_15829(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_15830","instance":15830,"id":252517,"goal":"predicate DisjointSets_15830(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_15831","instance":15831,"id":252518,"goal":"predicate Sorted_15831(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_15832","instance":15832,"id":252519,"goal":"predicate AllPositive_15832(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_15833","instance":15833,"id":252520,"goal":"predicate DistinctSeq_15833(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_15834","instance":15834,"id":252521,"goal":"predicate IsSubseq_15834(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_15835","instance":15835,"id":252522,"goal":"predicate IsPermutation_15835(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_15836","instance":15836,"id":252523,"goal":"predicate IsEven_15836(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_15837","instance":15837,"id":252524,"goal":"predicate InRange_15837(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_15838","instance":15838,"id":252525,"goal":"predicate SubsetOf_15838(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_15839","instance":15839,"id":252526,"goal":"predicate AllMem_15839(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_15840","instance":15840,"id":252527,"goal":"predicate DisjointSets_15840(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_15841","instance":15841,"id":252528,"goal":"predicate Sorted_15841(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_15842","instance":15842,"id":252529,"goal":"predicate AllPositive_15842(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_15843","instance":15843,"id":252530,"goal":"predicate DistinctSeq_15843(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_15844","instance":15844,"id":252531,"goal":"predicate IsSubseq_15844(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_15845","instance":15845,"id":252532,"goal":"predicate IsPermutation_15845(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_15846","instance":15846,"id":252533,"goal":"predicate IsEven_15846(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_15847","instance":15847,"id":252534,"goal":"predicate InRange_15847(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_15848","instance":15848,"id":252535,"goal":"predicate SubsetOf_15848(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_15849","instance":15849,"id":252536,"goal":"predicate AllMem_15849(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_15850","instance":15850,"id":252537,"goal":"predicate DisjointSets_15850(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_15851","instance":15851,"id":252538,"goal":"predicate Sorted_15851(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_15852","instance":15852,"id":252539,"goal":"predicate AllPositive_15852(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_15853","instance":15853,"id":252540,"goal":"predicate DistinctSeq_15853(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_15854","instance":15854,"id":252541,"goal":"predicate IsSubseq_15854(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_15855","instance":15855,"id":252542,"goal":"predicate IsPermutation_15855(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_15856","instance":15856,"id":252543,"goal":"predicate IsEven_15856(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_15857","instance":15857,"id":252544,"goal":"predicate InRange_15857(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_15858","instance":15858,"id":252545,"goal":"predicate SubsetOf_15858(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_15859","instance":15859,"id":252546,"goal":"predicate AllMem_15859(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_15860","instance":15860,"id":252547,"goal":"predicate DisjointSets_15860(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_15861","instance":15861,"id":252548,"goal":"predicate Sorted_15861(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_15862","instance":15862,"id":252549,"goal":"predicate AllPositive_15862(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_15863","instance":15863,"id":252550,"goal":"predicate DistinctSeq_15863(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_15864","instance":15864,"id":252551,"goal":"predicate IsSubseq_15864(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_15865","instance":15865,"id":252552,"goal":"predicate IsPermutation_15865(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_15866","instance":15866,"id":252553,"goal":"predicate IsEven_15866(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_15867","instance":15867,"id":252554,"goal":"predicate InRange_15867(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_15868","instance":15868,"id":252555,"goal":"predicate SubsetOf_15868(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_15869","instance":15869,"id":252556,"goal":"predicate AllMem_15869(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_15870","instance":15870,"id":252557,"goal":"predicate DisjointSets_15870(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_15871","instance":15871,"id":252558,"goal":"predicate Sorted_15871(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_15872","instance":15872,"id":252559,"goal":"predicate AllPositive_15872(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_15873","instance":15873,"id":252560,"goal":"predicate DistinctSeq_15873(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_15874","instance":15874,"id":252561,"goal":"predicate IsSubseq_15874(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_15875","instance":15875,"id":252562,"goal":"predicate IsPermutation_15875(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_15876","instance":15876,"id":252563,"goal":"predicate IsEven_15876(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_15877","instance":15877,"id":252564,"goal":"predicate InRange_15877(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_15878","instance":15878,"id":252565,"goal":"predicate SubsetOf_15878(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_15879","instance":15879,"id":252566,"goal":"predicate AllMem_15879(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_15880","instance":15880,"id":252567,"goal":"predicate DisjointSets_15880(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_15881","instance":15881,"id":252568,"goal":"predicate Sorted_15881(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_15882","instance":15882,"id":252569,"goal":"predicate AllPositive_15882(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_15883","instance":15883,"id":252570,"goal":"predicate DistinctSeq_15883(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_15884","instance":15884,"id":252571,"goal":"predicate IsSubseq_15884(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_15885","instance":15885,"id":252572,"goal":"predicate IsPermutation_15885(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_15886","instance":15886,"id":252573,"goal":"predicate IsEven_15886(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_15887","instance":15887,"id":252574,"goal":"predicate InRange_15887(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_15888","instance":15888,"id":252575,"goal":"predicate SubsetOf_15888(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_15889","instance":15889,"id":252576,"goal":"predicate AllMem_15889(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_15890","instance":15890,"id":252577,"goal":"predicate DisjointSets_15890(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_15891","instance":15891,"id":252578,"goal":"predicate Sorted_15891(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_15892","instance":15892,"id":252579,"goal":"predicate AllPositive_15892(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_15893","instance":15893,"id":252580,"goal":"predicate DistinctSeq_15893(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_15894","instance":15894,"id":252581,"goal":"predicate IsSubseq_15894(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_15895","instance":15895,"id":252582,"goal":"predicate IsPermutation_15895(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_15896","instance":15896,"id":252583,"goal":"predicate IsEven_15896(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_15897","instance":15897,"id":252584,"goal":"predicate InRange_15897(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_15898","instance":15898,"id":252585,"goal":"predicate SubsetOf_15898(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_15899","instance":15899,"id":252586,"goal":"predicate AllMem_15899(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_15900","instance":15900,"id":252587,"goal":"predicate DisjointSets_15900(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_15901","instance":15901,"id":252588,"goal":"predicate Sorted_15901(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_15902","instance":15902,"id":252589,"goal":"predicate AllPositive_15902(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_15903","instance":15903,"id":252590,"goal":"predicate DistinctSeq_15903(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_15904","instance":15904,"id":252591,"goal":"predicate IsSubseq_15904(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_15905","instance":15905,"id":252592,"goal":"predicate IsPermutation_15905(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_15906","instance":15906,"id":252593,"goal":"predicate IsEven_15906(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_15907","instance":15907,"id":252594,"goal":"predicate InRange_15907(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_15908","instance":15908,"id":252595,"goal":"predicate SubsetOf_15908(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_15909","instance":15909,"id":252596,"goal":"predicate AllMem_15909(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_15910","instance":15910,"id":252597,"goal":"predicate DisjointSets_15910(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_15911","instance":15911,"id":252598,"goal":"predicate Sorted_15911(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_15912","instance":15912,"id":252599,"goal":"predicate AllPositive_15912(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_15913","instance":15913,"id":252600,"goal":"predicate DistinctSeq_15913(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_15914","instance":15914,"id":252601,"goal":"predicate IsSubseq_15914(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_15915","instance":15915,"id":252602,"goal":"predicate IsPermutation_15915(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_15916","instance":15916,"id":252603,"goal":"predicate IsEven_15916(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_15917","instance":15917,"id":252604,"goal":"predicate InRange_15917(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_15918","instance":15918,"id":252605,"goal":"predicate SubsetOf_15918(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_15919","instance":15919,"id":252606,"goal":"predicate AllMem_15919(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_15920","instance":15920,"id":252607,"goal":"predicate DisjointSets_15920(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_15921","instance":15921,"id":252608,"goal":"predicate Sorted_15921(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_15922","instance":15922,"id":252609,"goal":"predicate AllPositive_15922(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_15923","instance":15923,"id":252610,"goal":"predicate DistinctSeq_15923(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_15924","instance":15924,"id":252611,"goal":"predicate IsSubseq_15924(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_15925","instance":15925,"id":252612,"goal":"predicate IsPermutation_15925(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_15926","instance":15926,"id":252613,"goal":"predicate IsEven_15926(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_15927","instance":15927,"id":252614,"goal":"predicate InRange_15927(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_15928","instance":15928,"id":252615,"goal":"predicate SubsetOf_15928(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_15929","instance":15929,"id":252616,"goal":"predicate AllMem_15929(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_15930","instance":15930,"id":252617,"goal":"predicate DisjointSets_15930(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_15931","instance":15931,"id":252618,"goal":"predicate Sorted_15931(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_15932","instance":15932,"id":252619,"goal":"predicate AllPositive_15932(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_15933","instance":15933,"id":252620,"goal":"predicate DistinctSeq_15933(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_15934","instance":15934,"id":252621,"goal":"predicate IsSubseq_15934(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_15935","instance":15935,"id":252622,"goal":"predicate IsPermutation_15935(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_15936","instance":15936,"id":252623,"goal":"predicate IsEven_15936(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_15937","instance":15937,"id":252624,"goal":"predicate InRange_15937(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_15938","instance":15938,"id":252625,"goal":"predicate SubsetOf_15938(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_15939","instance":15939,"id":252626,"goal":"predicate AllMem_15939(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_15940","instance":15940,"id":252627,"goal":"predicate DisjointSets_15940(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_15941","instance":15941,"id":252628,"goal":"predicate Sorted_15941(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_15942","instance":15942,"id":252629,"goal":"predicate AllPositive_15942(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_15943","instance":15943,"id":252630,"goal":"predicate DistinctSeq_15943(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_15944","instance":15944,"id":252631,"goal":"predicate IsSubseq_15944(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_15945","instance":15945,"id":252632,"goal":"predicate IsPermutation_15945(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_15946","instance":15946,"id":252633,"goal":"predicate IsEven_15946(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_15947","instance":15947,"id":252634,"goal":"predicate InRange_15947(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_15948","instance":15948,"id":252635,"goal":"predicate SubsetOf_15948(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_15949","instance":15949,"id":252636,"goal":"predicate AllMem_15949(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_15950","instance":15950,"id":252637,"goal":"predicate DisjointSets_15950(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_15951","instance":15951,"id":252638,"goal":"predicate Sorted_15951(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_15952","instance":15952,"id":252639,"goal":"predicate AllPositive_15952(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_15953","instance":15953,"id":252640,"goal":"predicate DistinctSeq_15953(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_15954","instance":15954,"id":252641,"goal":"predicate IsSubseq_15954(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_15955","instance":15955,"id":252642,"goal":"predicate IsPermutation_15955(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_15956","instance":15956,"id":252643,"goal":"predicate IsEven_15956(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_15957","instance":15957,"id":252644,"goal":"predicate InRange_15957(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_15958","instance":15958,"id":252645,"goal":"predicate SubsetOf_15958(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_15959","instance":15959,"id":252646,"goal":"predicate AllMem_15959(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_15960","instance":15960,"id":252647,"goal":"predicate DisjointSets_15960(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_15961","instance":15961,"id":252648,"goal":"predicate Sorted_15961(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_15962","instance":15962,"id":252649,"goal":"predicate AllPositive_15962(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_15963","instance":15963,"id":252650,"goal":"predicate DistinctSeq_15963(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_15964","instance":15964,"id":252651,"goal":"predicate IsSubseq_15964(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_15965","instance":15965,"id":252652,"goal":"predicate IsPermutation_15965(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_15966","instance":15966,"id":252653,"goal":"predicate IsEven_15966(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_15967","instance":15967,"id":252654,"goal":"predicate InRange_15967(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_15968","instance":15968,"id":252655,"goal":"predicate SubsetOf_15968(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_15969","instance":15969,"id":252656,"goal":"predicate AllMem_15969(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_15970","instance":15970,"id":252657,"goal":"predicate DisjointSets_15970(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_15971","instance":15971,"id":252658,"goal":"predicate Sorted_15971(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_15972","instance":15972,"id":252659,"goal":"predicate AllPositive_15972(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_15973","instance":15973,"id":252660,"goal":"predicate DistinctSeq_15973(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_15974","instance":15974,"id":252661,"goal":"predicate IsSubseq_15974(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_15975","instance":15975,"id":252662,"goal":"predicate IsPermutation_15975(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_15976","instance":15976,"id":252663,"goal":"predicate IsEven_15976(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_15977","instance":15977,"id":252664,"goal":"predicate InRange_15977(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_15978","instance":15978,"id":252665,"goal":"predicate SubsetOf_15978(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_15979","instance":15979,"id":252666,"goal":"predicate AllMem_15979(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_15980","instance":15980,"id":252667,"goal":"predicate DisjointSets_15980(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_15981","instance":15981,"id":252668,"goal":"predicate Sorted_15981(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_15982","instance":15982,"id":252669,"goal":"predicate AllPositive_15982(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_15983","instance":15983,"id":252670,"goal":"predicate DistinctSeq_15983(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_15984","instance":15984,"id":252671,"goal":"predicate IsSubseq_15984(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_15985","instance":15985,"id":252672,"goal":"predicate IsPermutation_15985(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_15986","instance":15986,"id":252673,"goal":"predicate IsEven_15986(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_15987","instance":15987,"id":252674,"goal":"predicate InRange_15987(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_15988","instance":15988,"id":252675,"goal":"predicate SubsetOf_15988(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_15989","instance":15989,"id":252676,"goal":"predicate AllMem_15989(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_15990","instance":15990,"id":252677,"goal":"predicate DisjointSets_15990(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_15991","instance":15991,"id":252678,"goal":"predicate Sorted_15991(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_15992","instance":15992,"id":252679,"goal":"predicate AllPositive_15992(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_15993","instance":15993,"id":252680,"goal":"predicate DistinctSeq_15993(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_15994","instance":15994,"id":252681,"goal":"predicate IsSubseq_15994(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_15995","instance":15995,"id":252682,"goal":"predicate IsPermutation_15995(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_15996","instance":15996,"id":252683,"goal":"predicate IsEven_15996(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_15997","instance":15997,"id":252684,"goal":"predicate InRange_15997(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_15998","instance":15998,"id":252685,"goal":"predicate SubsetOf_15998(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_15999","instance":15999,"id":252686,"goal":"predicate AllMem_15999(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_16000","instance":16000,"id":252687,"goal":"predicate DisjointSets_16000(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_16001","instance":16001,"id":252688,"goal":"predicate Sorted_16001(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_16002","instance":16002,"id":252689,"goal":"predicate AllPositive_16002(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_16003","instance":16003,"id":252690,"goal":"predicate DistinctSeq_16003(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_16004","instance":16004,"id":252691,"goal":"predicate IsSubseq_16004(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_16005","instance":16005,"id":252692,"goal":"predicate IsPermutation_16005(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_16006","instance":16006,"id":252693,"goal":"predicate IsEven_16006(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_16007","instance":16007,"id":252694,"goal":"predicate InRange_16007(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_16008","instance":16008,"id":252695,"goal":"predicate SubsetOf_16008(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_16009","instance":16009,"id":252696,"goal":"predicate AllMem_16009(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_16010","instance":16010,"id":252697,"goal":"predicate DisjointSets_16010(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_16011","instance":16011,"id":252698,"goal":"predicate Sorted_16011(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_16012","instance":16012,"id":252699,"goal":"predicate AllPositive_16012(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_16013","instance":16013,"id":252700,"goal":"predicate DistinctSeq_16013(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_16014","instance":16014,"id":252701,"goal":"predicate IsSubseq_16014(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_16015","instance":16015,"id":252702,"goal":"predicate IsPermutation_16015(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_16016","instance":16016,"id":252703,"goal":"predicate IsEven_16016(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_16017","instance":16017,"id":252704,"goal":"predicate InRange_16017(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_16018","instance":16018,"id":252705,"goal":"predicate SubsetOf_16018(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_16019","instance":16019,"id":252706,"goal":"predicate AllMem_16019(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_16020","instance":16020,"id":252707,"goal":"predicate DisjointSets_16020(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_16021","instance":16021,"id":252708,"goal":"predicate Sorted_16021(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_16022","instance":16022,"id":252709,"goal":"predicate AllPositive_16022(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_16023","instance":16023,"id":252710,"goal":"predicate DistinctSeq_16023(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_16024","instance":16024,"id":252711,"goal":"predicate IsSubseq_16024(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_16025","instance":16025,"id":252712,"goal":"predicate IsPermutation_16025(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_16026","instance":16026,"id":252713,"goal":"predicate IsEven_16026(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_16027","instance":16027,"id":252714,"goal":"predicate InRange_16027(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_16028","instance":16028,"id":252715,"goal":"predicate SubsetOf_16028(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_16029","instance":16029,"id":252716,"goal":"predicate AllMem_16029(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_16030","instance":16030,"id":252717,"goal":"predicate DisjointSets_16030(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_16031","instance":16031,"id":252718,"goal":"predicate Sorted_16031(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_16032","instance":16032,"id":252719,"goal":"predicate AllPositive_16032(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_16033","instance":16033,"id":252720,"goal":"predicate DistinctSeq_16033(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_16034","instance":16034,"id":252721,"goal":"predicate IsSubseq_16034(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_16035","instance":16035,"id":252722,"goal":"predicate IsPermutation_16035(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_16036","instance":16036,"id":252723,"goal":"predicate IsEven_16036(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_16037","instance":16037,"id":252724,"goal":"predicate InRange_16037(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_16038","instance":16038,"id":252725,"goal":"predicate SubsetOf_16038(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_16039","instance":16039,"id":252726,"goal":"predicate AllMem_16039(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_16040","instance":16040,"id":252727,"goal":"predicate DisjointSets_16040(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_16041","instance":16041,"id":252728,"goal":"predicate Sorted_16041(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_16042","instance":16042,"id":252729,"goal":"predicate AllPositive_16042(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_16043","instance":16043,"id":252730,"goal":"predicate DistinctSeq_16043(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_16044","instance":16044,"id":252731,"goal":"predicate IsSubseq_16044(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_16045","instance":16045,"id":252732,"goal":"predicate IsPermutation_16045(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_16046","instance":16046,"id":252733,"goal":"predicate IsEven_16046(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_16047","instance":16047,"id":252734,"goal":"predicate InRange_16047(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_16048","instance":16048,"id":252735,"goal":"predicate SubsetOf_16048(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_16049","instance":16049,"id":252736,"goal":"predicate AllMem_16049(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_16050","instance":16050,"id":252737,"goal":"predicate DisjointSets_16050(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_16051","instance":16051,"id":252738,"goal":"predicate Sorted_16051(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_16052","instance":16052,"id":252739,"goal":"predicate AllPositive_16052(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_16053","instance":16053,"id":252740,"goal":"predicate DistinctSeq_16053(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_16054","instance":16054,"id":252741,"goal":"predicate IsSubseq_16054(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_16055","instance":16055,"id":252742,"goal":"predicate IsPermutation_16055(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_16056","instance":16056,"id":252743,"goal":"predicate IsEven_16056(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_16057","instance":16057,"id":252744,"goal":"predicate InRange_16057(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_16058","instance":16058,"id":252745,"goal":"predicate SubsetOf_16058(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_16059","instance":16059,"id":252746,"goal":"predicate AllMem_16059(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_16060","instance":16060,"id":252747,"goal":"predicate DisjointSets_16060(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_16061","instance":16061,"id":252748,"goal":"predicate Sorted_16061(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_16062","instance":16062,"id":252749,"goal":"predicate AllPositive_16062(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_16063","instance":16063,"id":252750,"goal":"predicate DistinctSeq_16063(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_16064","instance":16064,"id":252751,"goal":"predicate IsSubseq_16064(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_16065","instance":16065,"id":252752,"goal":"predicate IsPermutation_16065(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_16066","instance":16066,"id":252753,"goal":"predicate IsEven_16066(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_16067","instance":16067,"id":252754,"goal":"predicate InRange_16067(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_16068","instance":16068,"id":252755,"goal":"predicate SubsetOf_16068(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_16069","instance":16069,"id":252756,"goal":"predicate AllMem_16069(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_16070","instance":16070,"id":252757,"goal":"predicate DisjointSets_16070(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_16071","instance":16071,"id":252758,"goal":"predicate Sorted_16071(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_16072","instance":16072,"id":252759,"goal":"predicate AllPositive_16072(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_16073","instance":16073,"id":252760,"goal":"predicate DistinctSeq_16073(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_16074","instance":16074,"id":252761,"goal":"predicate IsSubseq_16074(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_16075","instance":16075,"id":252762,"goal":"predicate IsPermutation_16075(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_16076","instance":16076,"id":252763,"goal":"predicate IsEven_16076(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_16077","instance":16077,"id":252764,"goal":"predicate InRange_16077(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_16078","instance":16078,"id":252765,"goal":"predicate SubsetOf_16078(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_16079","instance":16079,"id":252766,"goal":"predicate AllMem_16079(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_16080","instance":16080,"id":252767,"goal":"predicate DisjointSets_16080(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_16081","instance":16081,"id":252768,"goal":"predicate Sorted_16081(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_16082","instance":16082,"id":252769,"goal":"predicate AllPositive_16082(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_16083","instance":16083,"id":252770,"goal":"predicate DistinctSeq_16083(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_16084","instance":16084,"id":252771,"goal":"predicate IsSubseq_16084(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_16085","instance":16085,"id":252772,"goal":"predicate IsPermutation_16085(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_16086","instance":16086,"id":252773,"goal":"predicate IsEven_16086(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_16087","instance":16087,"id":252774,"goal":"predicate InRange_16087(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_16088","instance":16088,"id":252775,"goal":"predicate SubsetOf_16088(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_16089","instance":16089,"id":252776,"goal":"predicate AllMem_16089(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_16090","instance":16090,"id":252777,"goal":"predicate DisjointSets_16090(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_16091","instance":16091,"id":252778,"goal":"predicate Sorted_16091(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_16092","instance":16092,"id":252779,"goal":"predicate AllPositive_16092(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_16093","instance":16093,"id":252780,"goal":"predicate DistinctSeq_16093(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_16094","instance":16094,"id":252781,"goal":"predicate IsSubseq_16094(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_16095","instance":16095,"id":252782,"goal":"predicate IsPermutation_16095(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_16096","instance":16096,"id":252783,"goal":"predicate IsEven_16096(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_16097","instance":16097,"id":252784,"goal":"predicate InRange_16097(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_16098","instance":16098,"id":252785,"goal":"predicate SubsetOf_16098(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_16099","instance":16099,"id":252786,"goal":"predicate AllMem_16099(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_16100","instance":16100,"id":252787,"goal":"predicate DisjointSets_16100(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_16101","instance":16101,"id":252788,"goal":"predicate Sorted_16101(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_16102","instance":16102,"id":252789,"goal":"predicate AllPositive_16102(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_16103","instance":16103,"id":252790,"goal":"predicate DistinctSeq_16103(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_16104","instance":16104,"id":252791,"goal":"predicate IsSubseq_16104(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_16105","instance":16105,"id":252792,"goal":"predicate IsPermutation_16105(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_16106","instance":16106,"id":252793,"goal":"predicate IsEven_16106(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_16107","instance":16107,"id":252794,"goal":"predicate InRange_16107(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_16108","instance":16108,"id":252795,"goal":"predicate SubsetOf_16108(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_16109","instance":16109,"id":252796,"goal":"predicate AllMem_16109(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_16110","instance":16110,"id":252797,"goal":"predicate DisjointSets_16110(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_16111","instance":16111,"id":252798,"goal":"predicate Sorted_16111(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_16112","instance":16112,"id":252799,"goal":"predicate AllPositive_16112(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_16113","instance":16113,"id":252800,"goal":"predicate DistinctSeq_16113(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_16114","instance":16114,"id":252801,"goal":"predicate IsSubseq_16114(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_16115","instance":16115,"id":252802,"goal":"predicate IsPermutation_16115(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_16116","instance":16116,"id":252803,"goal":"predicate IsEven_16116(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_16117","instance":16117,"id":252804,"goal":"predicate InRange_16117(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_16118","instance":16118,"id":252805,"goal":"predicate SubsetOf_16118(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_16119","instance":16119,"id":252806,"goal":"predicate AllMem_16119(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_16120","instance":16120,"id":252807,"goal":"predicate DisjointSets_16120(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_16121","instance":16121,"id":252808,"goal":"predicate Sorted_16121(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_16122","instance":16122,"id":252809,"goal":"predicate AllPositive_16122(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_16123","instance":16123,"id":252810,"goal":"predicate DistinctSeq_16123(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_16124","instance":16124,"id":252811,"goal":"predicate IsSubseq_16124(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_16125","instance":16125,"id":252812,"goal":"predicate IsPermutation_16125(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_16126","instance":16126,"id":252813,"goal":"predicate IsEven_16126(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_16127","instance":16127,"id":252814,"goal":"predicate InRange_16127(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_16128","instance":16128,"id":252815,"goal":"predicate SubsetOf_16128(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_16129","instance":16129,"id":252816,"goal":"predicate AllMem_16129(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_16130","instance":16130,"id":252817,"goal":"predicate DisjointSets_16130(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_16131","instance":16131,"id":252818,"goal":"predicate Sorted_16131(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_16132","instance":16132,"id":252819,"goal":"predicate AllPositive_16132(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_16133","instance":16133,"id":252820,"goal":"predicate DistinctSeq_16133(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_16134","instance":16134,"id":252821,"goal":"predicate IsSubseq_16134(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_16135","instance":16135,"id":252822,"goal":"predicate IsPermutation_16135(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_16136","instance":16136,"id":252823,"goal":"predicate IsEven_16136(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_16137","instance":16137,"id":252824,"goal":"predicate InRange_16137(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_16138","instance":16138,"id":252825,"goal":"predicate SubsetOf_16138(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_16139","instance":16139,"id":252826,"goal":"predicate AllMem_16139(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_16140","instance":16140,"id":252827,"goal":"predicate DisjointSets_16140(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_16141","instance":16141,"id":252828,"goal":"predicate Sorted_16141(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_16142","instance":16142,"id":252829,"goal":"predicate AllPositive_16142(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_16143","instance":16143,"id":252830,"goal":"predicate DistinctSeq_16143(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_16144","instance":16144,"id":252831,"goal":"predicate IsSubseq_16144(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_16145","instance":16145,"id":252832,"goal":"predicate IsPermutation_16145(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_16146","instance":16146,"id":252833,"goal":"predicate IsEven_16146(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_16147","instance":16147,"id":252834,"goal":"predicate InRange_16147(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_16148","instance":16148,"id":252835,"goal":"predicate SubsetOf_16148(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_16149","instance":16149,"id":252836,"goal":"predicate AllMem_16149(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_16150","instance":16150,"id":252837,"goal":"predicate DisjointSets_16150(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_16151","instance":16151,"id":252838,"goal":"predicate Sorted_16151(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_16152","instance":16152,"id":252839,"goal":"predicate AllPositive_16152(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_16153","instance":16153,"id":252840,"goal":"predicate DistinctSeq_16153(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_16154","instance":16154,"id":252841,"goal":"predicate IsSubseq_16154(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_16155","instance":16155,"id":252842,"goal":"predicate IsPermutation_16155(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_16156","instance":16156,"id":252843,"goal":"predicate IsEven_16156(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_16157","instance":16157,"id":252844,"goal":"predicate InRange_16157(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_16158","instance":16158,"id":252845,"goal":"predicate SubsetOf_16158(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_16159","instance":16159,"id":252846,"goal":"predicate AllMem_16159(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_16160","instance":16160,"id":252847,"goal":"predicate DisjointSets_16160(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_16161","instance":16161,"id":252848,"goal":"predicate Sorted_16161(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_16162","instance":16162,"id":252849,"goal":"predicate AllPositive_16162(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_16163","instance":16163,"id":252850,"goal":"predicate DistinctSeq_16163(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_16164","instance":16164,"id":252851,"goal":"predicate IsSubseq_16164(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_16165","instance":16165,"id":252852,"goal":"predicate IsPermutation_16165(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_16166","instance":16166,"id":252853,"goal":"predicate IsEven_16166(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_16167","instance":16167,"id":252854,"goal":"predicate InRange_16167(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_16168","instance":16168,"id":252855,"goal":"predicate SubsetOf_16168(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_16169","instance":16169,"id":252856,"goal":"predicate AllMem_16169(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_16170","instance":16170,"id":252857,"goal":"predicate DisjointSets_16170(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_16171","instance":16171,"id":252858,"goal":"predicate Sorted_16171(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_16172","instance":16172,"id":252859,"goal":"predicate AllPositive_16172(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_16173","instance":16173,"id":252860,"goal":"predicate DistinctSeq_16173(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_16174","instance":16174,"id":252861,"goal":"predicate IsSubseq_16174(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_16175","instance":16175,"id":252862,"goal":"predicate IsPermutation_16175(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_16176","instance":16176,"id":252863,"goal":"predicate IsEven_16176(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_16177","instance":16177,"id":252864,"goal":"predicate InRange_16177(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_16178","instance":16178,"id":252865,"goal":"predicate SubsetOf_16178(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_16179","instance":16179,"id":252866,"goal":"predicate AllMem_16179(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_16180","instance":16180,"id":252867,"goal":"predicate DisjointSets_16180(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_16181","instance":16181,"id":252868,"goal":"predicate Sorted_16181(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_16182","instance":16182,"id":252869,"goal":"predicate AllPositive_16182(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_16183","instance":16183,"id":252870,"goal":"predicate DistinctSeq_16183(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_16184","instance":16184,"id":252871,"goal":"predicate IsSubseq_16184(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_16185","instance":16185,"id":252872,"goal":"predicate IsPermutation_16185(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_16186","instance":16186,"id":252873,"goal":"predicate IsEven_16186(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_16187","instance":16187,"id":252874,"goal":"predicate InRange_16187(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_16188","instance":16188,"id":252875,"goal":"predicate SubsetOf_16188(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_16189","instance":16189,"id":252876,"goal":"predicate AllMem_16189(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_16190","instance":16190,"id":252877,"goal":"predicate DisjointSets_16190(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_16191","instance":16191,"id":252878,"goal":"predicate Sorted_16191(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_16192","instance":16192,"id":252879,"goal":"predicate AllPositive_16192(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_16193","instance":16193,"id":252880,"goal":"predicate DistinctSeq_16193(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_16194","instance":16194,"id":252881,"goal":"predicate IsSubseq_16194(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_16195","instance":16195,"id":252882,"goal":"predicate IsPermutation_16195(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_16196","instance":16196,"id":252883,"goal":"predicate IsEven_16196(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_16197","instance":16197,"id":252884,"goal":"predicate InRange_16197(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_16198","instance":16198,"id":252885,"goal":"predicate SubsetOf_16198(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_16199","instance":16199,"id":252886,"goal":"predicate AllMem_16199(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_16200","instance":16200,"id":252887,"goal":"predicate DisjointSets_16200(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_16201","instance":16201,"id":252888,"goal":"predicate Sorted_16201(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_16202","instance":16202,"id":252889,"goal":"predicate AllPositive_16202(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_16203","instance":16203,"id":252890,"goal":"predicate DistinctSeq_16203(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_16204","instance":16204,"id":252891,"goal":"predicate IsSubseq_16204(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_16205","instance":16205,"id":252892,"goal":"predicate IsPermutation_16205(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_16206","instance":16206,"id":252893,"goal":"predicate IsEven_16206(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_16207","instance":16207,"id":252894,"goal":"predicate InRange_16207(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_16208","instance":16208,"id":252895,"goal":"predicate SubsetOf_16208(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_16209","instance":16209,"id":252896,"goal":"predicate AllMem_16209(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_16210","instance":16210,"id":252897,"goal":"predicate DisjointSets_16210(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_16211","instance":16211,"id":252898,"goal":"predicate Sorted_16211(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_16212","instance":16212,"id":252899,"goal":"predicate AllPositive_16212(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_16213","instance":16213,"id":252900,"goal":"predicate DistinctSeq_16213(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_16214","instance":16214,"id":252901,"goal":"predicate IsSubseq_16214(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_16215","instance":16215,"id":252902,"goal":"predicate IsPermutation_16215(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_16216","instance":16216,"id":252903,"goal":"predicate IsEven_16216(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_16217","instance":16217,"id":252904,"goal":"predicate InRange_16217(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_16218","instance":16218,"id":252905,"goal":"predicate SubsetOf_16218(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_16219","instance":16219,"id":252906,"goal":"predicate AllMem_16219(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_16220","instance":16220,"id":252907,"goal":"predicate DisjointSets_16220(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_16221","instance":16221,"id":252908,"goal":"predicate Sorted_16221(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_16222","instance":16222,"id":252909,"goal":"predicate AllPositive_16222(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_16223","instance":16223,"id":252910,"goal":"predicate DistinctSeq_16223(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_16224","instance":16224,"id":252911,"goal":"predicate IsSubseq_16224(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_16225","instance":16225,"id":252912,"goal":"predicate IsPermutation_16225(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_16226","instance":16226,"id":252913,"goal":"predicate IsEven_16226(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_16227","instance":16227,"id":252914,"goal":"predicate InRange_16227(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_16228","instance":16228,"id":252915,"goal":"predicate SubsetOf_16228(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_16229","instance":16229,"id":252916,"goal":"predicate AllMem_16229(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_16230","instance":16230,"id":252917,"goal":"predicate DisjointSets_16230(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_16231","instance":16231,"id":252918,"goal":"predicate Sorted_16231(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_16232","instance":16232,"id":252919,"goal":"predicate AllPositive_16232(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_16233","instance":16233,"id":252920,"goal":"predicate DistinctSeq_16233(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_16234","instance":16234,"id":252921,"goal":"predicate IsSubseq_16234(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_16235","instance":16235,"id":252922,"goal":"predicate IsPermutation_16235(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_16236","instance":16236,"id":252923,"goal":"predicate IsEven_16236(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_16237","instance":16237,"id":252924,"goal":"predicate InRange_16237(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_16238","instance":16238,"id":252925,"goal":"predicate SubsetOf_16238(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_16239","instance":16239,"id":252926,"goal":"predicate AllMem_16239(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_16240","instance":16240,"id":252927,"goal":"predicate DisjointSets_16240(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_16241","instance":16241,"id":252928,"goal":"predicate Sorted_16241(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_16242","instance":16242,"id":252929,"goal":"predicate AllPositive_16242(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_16243","instance":16243,"id":252930,"goal":"predicate DistinctSeq_16243(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_16244","instance":16244,"id":252931,"goal":"predicate IsSubseq_16244(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_16245","instance":16245,"id":252932,"goal":"predicate IsPermutation_16245(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_16246","instance":16246,"id":252933,"goal":"predicate IsEven_16246(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_16247","instance":16247,"id":252934,"goal":"predicate InRange_16247(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_16248","instance":16248,"id":252935,"goal":"predicate SubsetOf_16248(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_16249","instance":16249,"id":252936,"goal":"predicate AllMem_16249(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_16250","instance":16250,"id":252937,"goal":"predicate DisjointSets_16250(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_16251","instance":16251,"id":252938,"goal":"predicate Sorted_16251(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_16252","instance":16252,"id":252939,"goal":"predicate AllPositive_16252(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_16253","instance":16253,"id":252940,"goal":"predicate DistinctSeq_16253(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_16254","instance":16254,"id":252941,"goal":"predicate IsSubseq_16254(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_16255","instance":16255,"id":252942,"goal":"predicate IsPermutation_16255(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_16256","instance":16256,"id":252943,"goal":"predicate IsEven_16256(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_16257","instance":16257,"id":252944,"goal":"predicate InRange_16257(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_16258","instance":16258,"id":252945,"goal":"predicate SubsetOf_16258(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_16259","instance":16259,"id":252946,"goal":"predicate AllMem_16259(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_16260","instance":16260,"id":252947,"goal":"predicate DisjointSets_16260(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_16261","instance":16261,"id":252948,"goal":"predicate Sorted_16261(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_16262","instance":16262,"id":252949,"goal":"predicate AllPositive_16262(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_16263","instance":16263,"id":252950,"goal":"predicate DistinctSeq_16263(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_16264","instance":16264,"id":252951,"goal":"predicate IsSubseq_16264(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_16265","instance":16265,"id":252952,"goal":"predicate IsPermutation_16265(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_16266","instance":16266,"id":252953,"goal":"predicate IsEven_16266(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_16267","instance":16267,"id":252954,"goal":"predicate InRange_16267(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_16268","instance":16268,"id":252955,"goal":"predicate SubsetOf_16268(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_16269","instance":16269,"id":252956,"goal":"predicate AllMem_16269(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_16270","instance":16270,"id":252957,"goal":"predicate DisjointSets_16270(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_16271","instance":16271,"id":252958,"goal":"predicate Sorted_16271(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_16272","instance":16272,"id":252959,"goal":"predicate AllPositive_16272(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_16273","instance":16273,"id":252960,"goal":"predicate DistinctSeq_16273(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_16274","instance":16274,"id":252961,"goal":"predicate IsSubseq_16274(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_16275","instance":16275,"id":252962,"goal":"predicate IsPermutation_16275(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_16276","instance":16276,"id":252963,"goal":"predicate IsEven_16276(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_16277","instance":16277,"id":252964,"goal":"predicate InRange_16277(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_16278","instance":16278,"id":252965,"goal":"predicate SubsetOf_16278(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_16279","instance":16279,"id":252966,"goal":"predicate AllMem_16279(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_16280","instance":16280,"id":252967,"goal":"predicate DisjointSets_16280(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_16281","instance":16281,"id":252968,"goal":"predicate Sorted_16281(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_16282","instance":16282,"id":252969,"goal":"predicate AllPositive_16282(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_16283","instance":16283,"id":252970,"goal":"predicate DistinctSeq_16283(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_16284","instance":16284,"id":252971,"goal":"predicate IsSubseq_16284(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_16285","instance":16285,"id":252972,"goal":"predicate IsPermutation_16285(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_16286","instance":16286,"id":252973,"goal":"predicate IsEven_16286(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_16287","instance":16287,"id":252974,"goal":"predicate InRange_16287(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_16288","instance":16288,"id":252975,"goal":"predicate SubsetOf_16288(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_16289","instance":16289,"id":252976,"goal":"predicate AllMem_16289(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_16290","instance":16290,"id":252977,"goal":"predicate DisjointSets_16290(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_16291","instance":16291,"id":252978,"goal":"predicate Sorted_16291(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_16292","instance":16292,"id":252979,"goal":"predicate AllPositive_16292(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_16293","instance":16293,"id":252980,"goal":"predicate DistinctSeq_16293(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_16294","instance":16294,"id":252981,"goal":"predicate IsSubseq_16294(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_16295","instance":16295,"id":252982,"goal":"predicate IsPermutation_16295(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_16296","instance":16296,"id":252983,"goal":"predicate IsEven_16296(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_16297","instance":16297,"id":252984,"goal":"predicate InRange_16297(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_16298","instance":16298,"id":252985,"goal":"predicate SubsetOf_16298(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_16299","instance":16299,"id":252986,"goal":"predicate AllMem_16299(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_16300","instance":16300,"id":252987,"goal":"predicate DisjointSets_16300(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_16301","instance":16301,"id":252988,"goal":"predicate Sorted_16301(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_16302","instance":16302,"id":252989,"goal":"predicate AllPositive_16302(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_16303","instance":16303,"id":252990,"goal":"predicate DistinctSeq_16303(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_16304","instance":16304,"id":252991,"goal":"predicate IsSubseq_16304(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_16305","instance":16305,"id":252992,"goal":"predicate IsPermutation_16305(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_16306","instance":16306,"id":252993,"goal":"predicate IsEven_16306(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_16307","instance":16307,"id":252994,"goal":"predicate InRange_16307(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_16308","instance":16308,"id":252995,"goal":"predicate SubsetOf_16308(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_16309","instance":16309,"id":252996,"goal":"predicate AllMem_16309(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_16310","instance":16310,"id":252997,"goal":"predicate DisjointSets_16310(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_16311","instance":16311,"id":252998,"goal":"predicate Sorted_16311(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_16312","instance":16312,"id":252999,"goal":"predicate AllPositive_16312(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_16313","instance":16313,"id":253000,"goal":"predicate DistinctSeq_16313(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_16314","instance":16314,"id":253001,"goal":"predicate IsSubseq_16314(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_16315","instance":16315,"id":253002,"goal":"predicate IsPermutation_16315(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_16316","instance":16316,"id":253003,"goal":"predicate IsEven_16316(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_16317","instance":16317,"id":253004,"goal":"predicate InRange_16317(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_16318","instance":16318,"id":253005,"goal":"predicate SubsetOf_16318(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_16319","instance":16319,"id":253006,"goal":"predicate AllMem_16319(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_16320","instance":16320,"id":253007,"goal":"predicate DisjointSets_16320(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_16321","instance":16321,"id":253008,"goal":"predicate Sorted_16321(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_16322","instance":16322,"id":253009,"goal":"predicate AllPositive_16322(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_16323","instance":16323,"id":253010,"goal":"predicate DistinctSeq_16323(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_16324","instance":16324,"id":253011,"goal":"predicate IsSubseq_16324(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_16325","instance":16325,"id":253012,"goal":"predicate IsPermutation_16325(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_16326","instance":16326,"id":253013,"goal":"predicate IsEven_16326(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_16327","instance":16327,"id":253014,"goal":"predicate InRange_16327(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_16328","instance":16328,"id":253015,"goal":"predicate SubsetOf_16328(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_16329","instance":16329,"id":253016,"goal":"predicate AllMem_16329(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_16330","instance":16330,"id":253017,"goal":"predicate DisjointSets_16330(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_16331","instance":16331,"id":253018,"goal":"predicate Sorted_16331(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_16332","instance":16332,"id":253019,"goal":"predicate AllPositive_16332(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_16333","instance":16333,"id":253020,"goal":"predicate DistinctSeq_16333(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_16334","instance":16334,"id":253021,"goal":"predicate IsSubseq_16334(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_16335","instance":16335,"id":253022,"goal":"predicate IsPermutation_16335(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_16336","instance":16336,"id":253023,"goal":"predicate IsEven_16336(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_16337","instance":16337,"id":253024,"goal":"predicate InRange_16337(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_16338","instance":16338,"id":253025,"goal":"predicate SubsetOf_16338(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_16339","instance":16339,"id":253026,"goal":"predicate AllMem_16339(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_16340","instance":16340,"id":253027,"goal":"predicate DisjointSets_16340(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_16341","instance":16341,"id":253028,"goal":"predicate Sorted_16341(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_16342","instance":16342,"id":253029,"goal":"predicate AllPositive_16342(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_16343","instance":16343,"id":253030,"goal":"predicate DistinctSeq_16343(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_16344","instance":16344,"id":253031,"goal":"predicate IsSubseq_16344(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_16345","instance":16345,"id":253032,"goal":"predicate IsPermutation_16345(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_16346","instance":16346,"id":253033,"goal":"predicate IsEven_16346(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_16347","instance":16347,"id":253034,"goal":"predicate InRange_16347(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_16348","instance":16348,"id":253035,"goal":"predicate SubsetOf_16348(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_16349","instance":16349,"id":253036,"goal":"predicate AllMem_16349(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_16350","instance":16350,"id":253037,"goal":"predicate DisjointSets_16350(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_16351","instance":16351,"id":253038,"goal":"predicate Sorted_16351(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_16352","instance":16352,"id":253039,"goal":"predicate AllPositive_16352(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_16353","instance":16353,"id":253040,"goal":"predicate DistinctSeq_16353(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_16354","instance":16354,"id":253041,"goal":"predicate IsSubseq_16354(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_16355","instance":16355,"id":253042,"goal":"predicate IsPermutation_16355(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_16356","instance":16356,"id":253043,"goal":"predicate IsEven_16356(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_16357","instance":16357,"id":253044,"goal":"predicate InRange_16357(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_16358","instance":16358,"id":253045,"goal":"predicate SubsetOf_16358(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_16359","instance":16359,"id":253046,"goal":"predicate AllMem_16359(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_16360","instance":16360,"id":253047,"goal":"predicate DisjointSets_16360(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_16361","instance":16361,"id":253048,"goal":"predicate Sorted_16361(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_16362","instance":16362,"id":253049,"goal":"predicate AllPositive_16362(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_16363","instance":16363,"id":253050,"goal":"predicate DistinctSeq_16363(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_16364","instance":16364,"id":253051,"goal":"predicate IsSubseq_16364(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_16365","instance":16365,"id":253052,"goal":"predicate IsPermutation_16365(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_16366","instance":16366,"id":253053,"goal":"predicate IsEven_16366(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_16367","instance":16367,"id":253054,"goal":"predicate InRange_16367(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_16368","instance":16368,"id":253055,"goal":"predicate SubsetOf_16368(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_16369","instance":16369,"id":253056,"goal":"predicate AllMem_16369(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_16370","instance":16370,"id":253057,"goal":"predicate DisjointSets_16370(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_16371","instance":16371,"id":253058,"goal":"predicate Sorted_16371(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_16372","instance":16372,"id":253059,"goal":"predicate AllPositive_16372(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_16373","instance":16373,"id":253060,"goal":"predicate DistinctSeq_16373(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_16374","instance":16374,"id":253061,"goal":"predicate IsSubseq_16374(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_16375","instance":16375,"id":253062,"goal":"predicate IsPermutation_16375(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_16376","instance":16376,"id":253063,"goal":"predicate IsEven_16376(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_16377","instance":16377,"id":253064,"goal":"predicate InRange_16377(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_16378","instance":16378,"id":253065,"goal":"predicate SubsetOf_16378(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_16379","instance":16379,"id":253066,"goal":"predicate AllMem_16379(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_16380","instance":16380,"id":253067,"goal":"predicate DisjointSets_16380(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_16381","instance":16381,"id":253068,"goal":"predicate Sorted_16381(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_16382","instance":16382,"id":253069,"goal":"predicate AllPositive_16382(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_16383","instance":16383,"id":253070,"goal":"predicate DistinctSeq_16383(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_16384","instance":16384,"id":253071,"goal":"predicate IsSubseq_16384(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_16385","instance":16385,"id":253072,"goal":"predicate IsPermutation_16385(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_16386","instance":16386,"id":253073,"goal":"predicate IsEven_16386(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_16387","instance":16387,"id":253074,"goal":"predicate InRange_16387(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_16388","instance":16388,"id":253075,"goal":"predicate SubsetOf_16388(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_16389","instance":16389,"id":253076,"goal":"predicate AllMem_16389(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_16390","instance":16390,"id":253077,"goal":"predicate DisjointSets_16390(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_16391","instance":16391,"id":253078,"goal":"predicate Sorted_16391(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_16392","instance":16392,"id":253079,"goal":"predicate AllPositive_16392(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_16393","instance":16393,"id":253080,"goal":"predicate DistinctSeq_16393(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_16394","instance":16394,"id":253081,"goal":"predicate IsSubseq_16394(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_16395","instance":16395,"id":253082,"goal":"predicate IsPermutation_16395(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_16396","instance":16396,"id":253083,"goal":"predicate IsEven_16396(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_16397","instance":16397,"id":253084,"goal":"predicate InRange_16397(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_16398","instance":16398,"id":253085,"goal":"predicate SubsetOf_16398(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_16399","instance":16399,"id":253086,"goal":"predicate AllMem_16399(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_16400","instance":16400,"id":253087,"goal":"predicate DisjointSets_16400(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_16401","instance":16401,"id":253088,"goal":"predicate Sorted_16401(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_16402","instance":16402,"id":253089,"goal":"predicate AllPositive_16402(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_16403","instance":16403,"id":253090,"goal":"predicate DistinctSeq_16403(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_16404","instance":16404,"id":253091,"goal":"predicate IsSubseq_16404(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_16405","instance":16405,"id":253092,"goal":"predicate IsPermutation_16405(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_16406","instance":16406,"id":253093,"goal":"predicate IsEven_16406(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_16407","instance":16407,"id":253094,"goal":"predicate InRange_16407(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_16408","instance":16408,"id":253095,"goal":"predicate SubsetOf_16408(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_16409","instance":16409,"id":253096,"goal":"predicate AllMem_16409(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_16410","instance":16410,"id":253097,"goal":"predicate DisjointSets_16410(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_16411","instance":16411,"id":253098,"goal":"predicate Sorted_16411(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_16412","instance":16412,"id":253099,"goal":"predicate AllPositive_16412(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_16413","instance":16413,"id":253100,"goal":"predicate DistinctSeq_16413(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_16414","instance":16414,"id":253101,"goal":"predicate IsSubseq_16414(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_16415","instance":16415,"id":253102,"goal":"predicate IsPermutation_16415(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_16416","instance":16416,"id":253103,"goal":"predicate IsEven_16416(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_16417","instance":16417,"id":253104,"goal":"predicate InRange_16417(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_16418","instance":16418,"id":253105,"goal":"predicate SubsetOf_16418(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_16419","instance":16419,"id":253106,"goal":"predicate AllMem_16419(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_16420","instance":16420,"id":253107,"goal":"predicate DisjointSets_16420(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_16421","instance":16421,"id":253108,"goal":"predicate Sorted_16421(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_16422","instance":16422,"id":253109,"goal":"predicate AllPositive_16422(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_16423","instance":16423,"id":253110,"goal":"predicate DistinctSeq_16423(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_16424","instance":16424,"id":253111,"goal":"predicate IsSubseq_16424(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_16425","instance":16425,"id":253112,"goal":"predicate IsPermutation_16425(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_16426","instance":16426,"id":253113,"goal":"predicate IsEven_16426(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_16427","instance":16427,"id":253114,"goal":"predicate InRange_16427(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_16428","instance":16428,"id":253115,"goal":"predicate SubsetOf_16428(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_16429","instance":16429,"id":253116,"goal":"predicate AllMem_16429(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_16430","instance":16430,"id":253117,"goal":"predicate DisjointSets_16430(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_16431","instance":16431,"id":253118,"goal":"predicate Sorted_16431(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_16432","instance":16432,"id":253119,"goal":"predicate AllPositive_16432(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_16433","instance":16433,"id":253120,"goal":"predicate DistinctSeq_16433(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_16434","instance":16434,"id":253121,"goal":"predicate IsSubseq_16434(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_16435","instance":16435,"id":253122,"goal":"predicate IsPermutation_16435(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_16436","instance":16436,"id":253123,"goal":"predicate IsEven_16436(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_16437","instance":16437,"id":253124,"goal":"predicate InRange_16437(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_16438","instance":16438,"id":253125,"goal":"predicate SubsetOf_16438(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_16439","instance":16439,"id":253126,"goal":"predicate AllMem_16439(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_16440","instance":16440,"id":253127,"goal":"predicate DisjointSets_16440(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_16441","instance":16441,"id":253128,"goal":"predicate Sorted_16441(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_16442","instance":16442,"id":253129,"goal":"predicate AllPositive_16442(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_16443","instance":16443,"id":253130,"goal":"predicate DistinctSeq_16443(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_16444","instance":16444,"id":253131,"goal":"predicate IsSubseq_16444(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_16445","instance":16445,"id":253132,"goal":"predicate IsPermutation_16445(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_16446","instance":16446,"id":253133,"goal":"predicate IsEven_16446(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_16447","instance":16447,"id":253134,"goal":"predicate InRange_16447(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_16448","instance":16448,"id":253135,"goal":"predicate SubsetOf_16448(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_16449","instance":16449,"id":253136,"goal":"predicate AllMem_16449(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_16450","instance":16450,"id":253137,"goal":"predicate DisjointSets_16450(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_16451","instance":16451,"id":253138,"goal":"predicate Sorted_16451(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_16452","instance":16452,"id":253139,"goal":"predicate AllPositive_16452(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_16453","instance":16453,"id":253140,"goal":"predicate DistinctSeq_16453(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_16454","instance":16454,"id":253141,"goal":"predicate IsSubseq_16454(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_16455","instance":16455,"id":253142,"goal":"predicate IsPermutation_16455(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_16456","instance":16456,"id":253143,"goal":"predicate IsEven_16456(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_16457","instance":16457,"id":253144,"goal":"predicate InRange_16457(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_16458","instance":16458,"id":253145,"goal":"predicate SubsetOf_16458(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_16459","instance":16459,"id":253146,"goal":"predicate AllMem_16459(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_16460","instance":16460,"id":253147,"goal":"predicate DisjointSets_16460(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_16461","instance":16461,"id":253148,"goal":"predicate Sorted_16461(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_16462","instance":16462,"id":253149,"goal":"predicate AllPositive_16462(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_16463","instance":16463,"id":253150,"goal":"predicate DistinctSeq_16463(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_16464","instance":16464,"id":253151,"goal":"predicate IsSubseq_16464(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_16465","instance":16465,"id":253152,"goal":"predicate IsPermutation_16465(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_16466","instance":16466,"id":253153,"goal":"predicate IsEven_16466(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_16467","instance":16467,"id":253154,"goal":"predicate InRange_16467(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_16468","instance":16468,"id":253155,"goal":"predicate SubsetOf_16468(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_16469","instance":16469,"id":253156,"goal":"predicate AllMem_16469(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_16470","instance":16470,"id":253157,"goal":"predicate DisjointSets_16470(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_16471","instance":16471,"id":253158,"goal":"predicate Sorted_16471(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_16472","instance":16472,"id":253159,"goal":"predicate AllPositive_16472(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_16473","instance":16473,"id":253160,"goal":"predicate DistinctSeq_16473(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_16474","instance":16474,"id":253161,"goal":"predicate IsSubseq_16474(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_16475","instance":16475,"id":253162,"goal":"predicate IsPermutation_16475(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_16476","instance":16476,"id":253163,"goal":"predicate IsEven_16476(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_16477","instance":16477,"id":253164,"goal":"predicate InRange_16477(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_16478","instance":16478,"id":253165,"goal":"predicate SubsetOf_16478(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_16479","instance":16479,"id":253166,"goal":"predicate AllMem_16479(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_16480","instance":16480,"id":253167,"goal":"predicate DisjointSets_16480(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_16481","instance":16481,"id":253168,"goal":"predicate Sorted_16481(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_16482","instance":16482,"id":253169,"goal":"predicate AllPositive_16482(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_16483","instance":16483,"id":253170,"goal":"predicate DistinctSeq_16483(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_16484","instance":16484,"id":253171,"goal":"predicate IsSubseq_16484(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_16485","instance":16485,"id":253172,"goal":"predicate IsPermutation_16485(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_16486","instance":16486,"id":253173,"goal":"predicate IsEven_16486(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_16487","instance":16487,"id":253174,"goal":"predicate InRange_16487(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_16488","instance":16488,"id":253175,"goal":"predicate SubsetOf_16488(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_16489","instance":16489,"id":253176,"goal":"predicate AllMem_16489(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_16490","instance":16490,"id":253177,"goal":"predicate DisjointSets_16490(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_16491","instance":16491,"id":253178,"goal":"predicate Sorted_16491(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_16492","instance":16492,"id":253179,"goal":"predicate AllPositive_16492(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_16493","instance":16493,"id":253180,"goal":"predicate DistinctSeq_16493(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_16494","instance":16494,"id":253181,"goal":"predicate IsSubseq_16494(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_16495","instance":16495,"id":253182,"goal":"predicate IsPermutation_16495(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_16496","instance":16496,"id":253183,"goal":"predicate IsEven_16496(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_16497","instance":16497,"id":253184,"goal":"predicate InRange_16497(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_16498","instance":16498,"id":253185,"goal":"predicate SubsetOf_16498(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_16499","instance":16499,"id":253186,"goal":"predicate AllMem_16499(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_16500","instance":16500,"id":253187,"goal":"predicate DisjointSets_16500(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_16501","instance":16501,"id":253188,"goal":"predicate Sorted_16501(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_16502","instance":16502,"id":253189,"goal":"predicate AllPositive_16502(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_16503","instance":16503,"id":253190,"goal":"predicate DistinctSeq_16503(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_16504","instance":16504,"id":253191,"goal":"predicate IsSubseq_16504(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_16505","instance":16505,"id":253192,"goal":"predicate IsPermutation_16505(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_16506","instance":16506,"id":253193,"goal":"predicate IsEven_16506(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_16507","instance":16507,"id":253194,"goal":"predicate InRange_16507(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_16508","instance":16508,"id":253195,"goal":"predicate SubsetOf_16508(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_16509","instance":16509,"id":253196,"goal":"predicate AllMem_16509(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_16510","instance":16510,"id":253197,"goal":"predicate DisjointSets_16510(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_16511","instance":16511,"id":253198,"goal":"predicate Sorted_16511(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_16512","instance":16512,"id":253199,"goal":"predicate AllPositive_16512(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_16513","instance":16513,"id":253200,"goal":"predicate DistinctSeq_16513(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_16514","instance":16514,"id":253201,"goal":"predicate IsSubseq_16514(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_16515","instance":16515,"id":253202,"goal":"predicate IsPermutation_16515(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_16516","instance":16516,"id":253203,"goal":"predicate IsEven_16516(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_16517","instance":16517,"id":253204,"goal":"predicate InRange_16517(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_16518","instance":16518,"id":253205,"goal":"predicate SubsetOf_16518(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_16519","instance":16519,"id":253206,"goal":"predicate AllMem_16519(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_16520","instance":16520,"id":253207,"goal":"predicate DisjointSets_16520(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_16521","instance":16521,"id":253208,"goal":"predicate Sorted_16521(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_16522","instance":16522,"id":253209,"goal":"predicate AllPositive_16522(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_16523","instance":16523,"id":253210,"goal":"predicate DistinctSeq_16523(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_16524","instance":16524,"id":253211,"goal":"predicate IsSubseq_16524(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_16525","instance":16525,"id":253212,"goal":"predicate IsPermutation_16525(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_16526","instance":16526,"id":253213,"goal":"predicate IsEven_16526(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_16527","instance":16527,"id":253214,"goal":"predicate InRange_16527(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_16528","instance":16528,"id":253215,"goal":"predicate SubsetOf_16528(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_16529","instance":16529,"id":253216,"goal":"predicate AllMem_16529(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_16530","instance":16530,"id":253217,"goal":"predicate DisjointSets_16530(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_16531","instance":16531,"id":253218,"goal":"predicate Sorted_16531(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_16532","instance":16532,"id":253219,"goal":"predicate AllPositive_16532(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_16533","instance":16533,"id":253220,"goal":"predicate DistinctSeq_16533(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_16534","instance":16534,"id":253221,"goal":"predicate IsSubseq_16534(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_16535","instance":16535,"id":253222,"goal":"predicate IsPermutation_16535(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_16536","instance":16536,"id":253223,"goal":"predicate IsEven_16536(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_16537","instance":16537,"id":253224,"goal":"predicate InRange_16537(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_16538","instance":16538,"id":253225,"goal":"predicate SubsetOf_16538(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_16539","instance":16539,"id":253226,"goal":"predicate AllMem_16539(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_16540","instance":16540,"id":253227,"goal":"predicate DisjointSets_16540(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_16541","instance":16541,"id":253228,"goal":"predicate Sorted_16541(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_16542","instance":16542,"id":253229,"goal":"predicate AllPositive_16542(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_16543","instance":16543,"id":253230,"goal":"predicate DistinctSeq_16543(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_16544","instance":16544,"id":253231,"goal":"predicate IsSubseq_16544(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_16545","instance":16545,"id":253232,"goal":"predicate IsPermutation_16545(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_16546","instance":16546,"id":253233,"goal":"predicate IsEven_16546(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_16547","instance":16547,"id":253234,"goal":"predicate InRange_16547(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_16548","instance":16548,"id":253235,"goal":"predicate SubsetOf_16548(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_16549","instance":16549,"id":253236,"goal":"predicate AllMem_16549(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_16550","instance":16550,"id":253237,"goal":"predicate DisjointSets_16550(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_16551","instance":16551,"id":253238,"goal":"predicate Sorted_16551(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_16552","instance":16552,"id":253239,"goal":"predicate AllPositive_16552(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_16553","instance":16553,"id":253240,"goal":"predicate DistinctSeq_16553(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_16554","instance":16554,"id":253241,"goal":"predicate IsSubseq_16554(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_16555","instance":16555,"id":253242,"goal":"predicate IsPermutation_16555(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_16556","instance":16556,"id":253243,"goal":"predicate IsEven_16556(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_16557","instance":16557,"id":253244,"goal":"predicate InRange_16557(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_16558","instance":16558,"id":253245,"goal":"predicate SubsetOf_16558(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_16559","instance":16559,"id":253246,"goal":"predicate AllMem_16559(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_16560","instance":16560,"id":253247,"goal":"predicate DisjointSets_16560(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_16561","instance":16561,"id":253248,"goal":"predicate Sorted_16561(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_16562","instance":16562,"id":253249,"goal":"predicate AllPositive_16562(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_16563","instance":16563,"id":253250,"goal":"predicate DistinctSeq_16563(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_16564","instance":16564,"id":253251,"goal":"predicate IsSubseq_16564(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_16565","instance":16565,"id":253252,"goal":"predicate IsPermutation_16565(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_16566","instance":16566,"id":253253,"goal":"predicate IsEven_16566(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_16567","instance":16567,"id":253254,"goal":"predicate InRange_16567(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_16568","instance":16568,"id":253255,"goal":"predicate SubsetOf_16568(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_16569","instance":16569,"id":253256,"goal":"predicate AllMem_16569(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_16570","instance":16570,"id":253257,"goal":"predicate DisjointSets_16570(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_16571","instance":16571,"id":253258,"goal":"predicate Sorted_16571(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_16572","instance":16572,"id":253259,"goal":"predicate AllPositive_16572(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_16573","instance":16573,"id":253260,"goal":"predicate DistinctSeq_16573(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_16574","instance":16574,"id":253261,"goal":"predicate IsSubseq_16574(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_16575","instance":16575,"id":253262,"goal":"predicate IsPermutation_16575(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_16576","instance":16576,"id":253263,"goal":"predicate IsEven_16576(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_16577","instance":16577,"id":253264,"goal":"predicate InRange_16577(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_16578","instance":16578,"id":253265,"goal":"predicate SubsetOf_16578(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_16579","instance":16579,"id":253266,"goal":"predicate AllMem_16579(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_16580","instance":16580,"id":253267,"goal":"predicate DisjointSets_16580(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_16581","instance":16581,"id":253268,"goal":"predicate Sorted_16581(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_16582","instance":16582,"id":253269,"goal":"predicate AllPositive_16582(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_16583","instance":16583,"id":253270,"goal":"predicate DistinctSeq_16583(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_16584","instance":16584,"id":253271,"goal":"predicate IsSubseq_16584(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_16585","instance":16585,"id":253272,"goal":"predicate IsPermutation_16585(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_16586","instance":16586,"id":253273,"goal":"predicate IsEven_16586(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_16587","instance":16587,"id":253274,"goal":"predicate InRange_16587(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_16588","instance":16588,"id":253275,"goal":"predicate SubsetOf_16588(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_16589","instance":16589,"id":253276,"goal":"predicate AllMem_16589(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_16590","instance":16590,"id":253277,"goal":"predicate DisjointSets_16590(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_16591","instance":16591,"id":253278,"goal":"predicate Sorted_16591(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_16592","instance":16592,"id":253279,"goal":"predicate AllPositive_16592(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_16593","instance":16593,"id":253280,"goal":"predicate DistinctSeq_16593(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_16594","instance":16594,"id":253281,"goal":"predicate IsSubseq_16594(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_16595","instance":16595,"id":253282,"goal":"predicate IsPermutation_16595(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_16596","instance":16596,"id":253283,"goal":"predicate IsEven_16596(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_16597","instance":16597,"id":253284,"goal":"predicate InRange_16597(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_16598","instance":16598,"id":253285,"goal":"predicate SubsetOf_16598(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_16599","instance":16599,"id":253286,"goal":"predicate AllMem_16599(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_16600","instance":16600,"id":253287,"goal":"predicate DisjointSets_16600(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_16601","instance":16601,"id":253288,"goal":"predicate Sorted_16601(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_16602","instance":16602,"id":253289,"goal":"predicate AllPositive_16602(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_16603","instance":16603,"id":253290,"goal":"predicate DistinctSeq_16603(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_16604","instance":16604,"id":253291,"goal":"predicate IsSubseq_16604(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_16605","instance":16605,"id":253292,"goal":"predicate IsPermutation_16605(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_16606","instance":16606,"id":253293,"goal":"predicate IsEven_16606(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_16607","instance":16607,"id":253294,"goal":"predicate InRange_16607(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_16608","instance":16608,"id":253295,"goal":"predicate SubsetOf_16608(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_16609","instance":16609,"id":253296,"goal":"predicate AllMem_16609(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_16610","instance":16610,"id":253297,"goal":"predicate DisjointSets_16610(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_16611","instance":16611,"id":253298,"goal":"predicate Sorted_16611(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_16612","instance":16612,"id":253299,"goal":"predicate AllPositive_16612(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_16613","instance":16613,"id":253300,"goal":"predicate DistinctSeq_16613(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_16614","instance":16614,"id":253301,"goal":"predicate IsSubseq_16614(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_16615","instance":16615,"id":253302,"goal":"predicate IsPermutation_16615(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_16616","instance":16616,"id":253303,"goal":"predicate IsEven_16616(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_16617","instance":16617,"id":253304,"goal":"predicate InRange_16617(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_16618","instance":16618,"id":253305,"goal":"predicate SubsetOf_16618(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_16619","instance":16619,"id":253306,"goal":"predicate AllMem_16619(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_16620","instance":16620,"id":253307,"goal":"predicate DisjointSets_16620(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_16621","instance":16621,"id":253308,"goal":"predicate Sorted_16621(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_16622","instance":16622,"id":253309,"goal":"predicate AllPositive_16622(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_16623","instance":16623,"id":253310,"goal":"predicate DistinctSeq_16623(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_16624","instance":16624,"id":253311,"goal":"predicate IsSubseq_16624(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_16625","instance":16625,"id":253312,"goal":"predicate IsPermutation_16625(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_16626","instance":16626,"id":253313,"goal":"predicate IsEven_16626(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_16627","instance":16627,"id":253314,"goal":"predicate InRange_16627(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_16628","instance":16628,"id":253315,"goal":"predicate SubsetOf_16628(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_16629","instance":16629,"id":253316,"goal":"predicate AllMem_16629(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_16630","instance":16630,"id":253317,"goal":"predicate DisjointSets_16630(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_16631","instance":16631,"id":253318,"goal":"predicate Sorted_16631(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_16632","instance":16632,"id":253319,"goal":"predicate AllPositive_16632(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_16633","instance":16633,"id":253320,"goal":"predicate DistinctSeq_16633(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_16634","instance":16634,"id":253321,"goal":"predicate IsSubseq_16634(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_16635","instance":16635,"id":253322,"goal":"predicate IsPermutation_16635(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_16636","instance":16636,"id":253323,"goal":"predicate IsEven_16636(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_16637","instance":16637,"id":253324,"goal":"predicate InRange_16637(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_16638","instance":16638,"id":253325,"goal":"predicate SubsetOf_16638(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_16639","instance":16639,"id":253326,"goal":"predicate AllMem_16639(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_16640","instance":16640,"id":253327,"goal":"predicate DisjointSets_16640(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_16641","instance":16641,"id":253328,"goal":"predicate Sorted_16641(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_16642","instance":16642,"id":253329,"goal":"predicate AllPositive_16642(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_16643","instance":16643,"id":253330,"goal":"predicate DistinctSeq_16643(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_16644","instance":16644,"id":253331,"goal":"predicate IsSubseq_16644(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_16645","instance":16645,"id":253332,"goal":"predicate IsPermutation_16645(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_16646","instance":16646,"id":253333,"goal":"predicate IsEven_16646(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_16647","instance":16647,"id":253334,"goal":"predicate InRange_16647(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_16648","instance":16648,"id":253335,"goal":"predicate SubsetOf_16648(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_16649","instance":16649,"id":253336,"goal":"predicate AllMem_16649(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_16650","instance":16650,"id":253337,"goal":"predicate DisjointSets_16650(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_16651","instance":16651,"id":253338,"goal":"predicate Sorted_16651(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_16652","instance":16652,"id":253339,"goal":"predicate AllPositive_16652(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_16653","instance":16653,"id":253340,"goal":"predicate DistinctSeq_16653(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_16654","instance":16654,"id":253341,"goal":"predicate IsSubseq_16654(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_16655","instance":16655,"id":253342,"goal":"predicate IsPermutation_16655(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_16656","instance":16656,"id":253343,"goal":"predicate IsEven_16656(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_16657","instance":16657,"id":253344,"goal":"predicate InRange_16657(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_16658","instance":16658,"id":253345,"goal":"predicate SubsetOf_16658(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllMem","theorem":"AllMem_16659","instance":16659,"id":253346,"goal":"predicate AllMem_16659(s: seq, S: set)\n{ forall i :: 0 <= i < |s| ==> s[i] in S }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DisjointSets","theorem":"DisjointSets_16660","instance":16660,"id":253347,"goal":"predicate DisjointSets_16660(S: set, U: set)\n{ S * U == {} }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"Sorted","theorem":"Sorted_16661","instance":16661,"id":253348,"goal":"predicate Sorted_16661(a: array, lo: int, hi: int)\n requires 0 <= lo <= hi <= a.Length\n reads a\n{ forall i, j :: lo <= i < j < hi ==> a[i] <= a[j] }","tactics":["requires","reads"]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"AllPositive","theorem":"AllPositive_16662","instance":16662,"id":253349,"goal":"predicate AllPositive_16662(s: seq)\n{ forall i :: 0 <= i < |s| ==> s[i] > 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"DistinctSeq","theorem":"DistinctSeq_16663","instance":16663,"id":253350,"goal":"predicate DistinctSeq_16663(s: seq)\n{ forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsSubseq","theorem":"IsSubseq_16664","instance":16664,"id":253351,"goal":"predicate IsSubseq_16664(s: seq, t: seq)\n{ exists lo, hi :: 0 <= lo <= hi <= |t| && t[lo..hi] == s }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsPermutation","theorem":"IsPermutation_16665","instance":16665,"id":253352,"goal":"predicate IsPermutation_16665(s: seq, t: seq)\n{ multiset(s) == multiset(t) }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"IsEven","theorem":"IsEven_16666","instance":16666,"id":253353,"goal":"predicate IsEven_16666(n: int)\n{ n % 2 == 0 }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"InRange","theorem":"InRange_16667","instance":16667,"id":253354,"goal":"predicate InRange_16667(x: int, lo: int, hi: int)\n{ lo <= x < hi }","tactics":[]} -{"tactic_proof":"","prover":"Dafny","source":"dafny_synthetic/predicates","variant":"SubsetOf","theorem":"SubsetOf_16668","instance":16668,"id":253355,"goal":"predicate SubsetOf_16668(S: set, U: set)\n{ forall e :: e in S ==> e in U }","tactics":[]} +{"prover":"Dafny","tactic_proof":"method MapPutGet(m: map, k: K, v: V)\n ensures k in m[k := v]\n ensures m[k := v][k] == v\n{}","source":"dafny_synthetic/maps","theorem":"MapPutGet","id":112644,"goal":"ensures k in m[k := v]; ensures m[k := v][k] == v","context":["ensures"]} +{"prover":"Dafny","tactic_proof":"lemma MapRemoveAbsent(m: map, k: K)\n requires k !in m\n ensures m - {k} == m\n{}","source":"dafny_synthetic/maps","theorem":"MapRemoveAbsent","id":112645,"goal":"requires k !in m; ensures m - {k} == m","context":["requires","ensures"]} +{"prover":"Dafny","tactic_proof":"lemma MapDomainSubset(m1: map, m2: map)\n requires forall k :: k in m1 ==> k in m2 && m1[k] == m2[k]\n ensures m1.Keys <= m2.Keys\n{}","source":"dafny_synthetic/maps","theorem":"MapDomainSubset","id":112646,"goal":"requires forall k :: k in m1 ==> k in m2 && m1[k] == m2[k]; ensures m1.Keys <= m2.Keys","context":["requires","ensures"]} +{"prover":"Dafny","tactic_proof":"lemma MapDisjointMerge(m1: map, m2: map)\n requires m1.Keys !! m2.Keys\n ensures |m1 + m2| == |m1| + |m2|\n{}","source":"dafny_synthetic/maps","theorem":"MapDisjointMerge","id":112647,"goal":"requires m1.Keys !! m2.Keys; ensures |m1 + m2| == |m1| + |m2|","context":["requires","ensures"]} +{"prover":"Dafny","tactic_proof":"lemma MapKeysValues(m: map)\n ensures |m.Keys| == |m.Values|\n{}","source":"dafny_synthetic/maps","theorem":"MapKeysValues","id":112648,"goal":"ensures |m.Keys| == |m.Values|","context":["ensures"]} +{"prover":"Dafny","tactic_proof":"lemma MapContainsAfterUpdate(m: map, k: K, v: V, k': K)\n requires k' in m\n ensures k' in m[k := v]\n{}","source":"dafny_synthetic/maps","theorem":"MapContainsAfterUpdate","id":112649,"goal":"requires k' in m; ensures k' in m[k := v]","context":["requires","ensures"]} +{"prover":"Dafny","tactic_proof":"lemma MapEmptyKeys()\n ensures (map[]: map).Keys == {}\n{}","source":"dafny_synthetic/maps","theorem":"MapEmptyKeys","id":112650,"goal":"ensures (map[]: map).Keys == {}","context":["ensures"]} +{"prover":"Dafny","tactic_proof":"lemma MapUpdateIdempotent(m: map, k: K, v: V)\n ensures m[k := v][k := v] == m[k := v]\n{}","source":"dafny_synthetic/maps","theorem":"MapUpdateIdempotent","id":112651,"goal":"ensures m[k := v][k := v] == m[k := v]","context":["ensures"]} +{"prover":"Dafny","tactic_proof":"method SumArray(a: array) returns (s: int)\n ensures s == Sum(a[..], 0, a.Length)\n{\n s := 0;\n var i := 0;\n while i < a.Length\n invariant 0 <= i <= a.Length\n invariant s == Sum(a[..], 0, i)\n {\n s := s + a[i];\n i := i + 1;\n }\n}","source":"dafny_synthetic/loops","theorem":"SumArray","id":112652,"goal":"ensures s == Sum(a[..], 0, a.Length); invariant 0 <= i <= a.Length; invariant s == Sum(a[..], 0, i)","context":["ensures","invariant"]} +{"prover":"Dafny","tactic_proof":"method MaxElement(a: array) returns (m: int)\n requires a.Length > 0\n ensures forall i :: 0 <= i < a.Length ==> a[i] <= m\n ensures exists i :: 0 <= i < a.Length && a[i] == m\n{\n m := a[0];\n var i := 1;\n while i < a.Length\n invariant 1 <= i <= a.Length\n invariant forall j :: 0 <= j < i ==> a[j] <= m\n invariant exists j :: 0 <= j < i && a[j] == m\n {\n if a[i] > m { m := a[i]; }\n i := i + 1;\n }\n}","source":"dafny_synthetic/loops","theorem":"MaxElement","id":112653,"goal":"requires a.Length > 0; ensures forall i :: 0 <= i < a.Length ==> a[i] <= m; ensures exists i :: 0 <= i < a.Length && a[i] == m; invariant 1 <= i <= a.Length; invariant forall j :: 0 <= j < i ==> a[j] <= m; invariant exists j :: 0 <= j < i && a[j] == m","context":["requires","ensures","invariant"]} +{"prover":"Dafny","tactic_proof":"method CountOccurrences(a: array, key: int) returns (c: int)\n ensures c == |set i | 0 <= i < a.Length && a[i] == key|\n{\n c := 0;\n var i := 0;\n while i < a.Length\n invariant 0 <= i <= a.Length\n invariant c == |set j | 0 <= j < i && a[j] == key|\n {\n if a[i] == key { c := c + 1; }\n i := i + 1;\n }\n}","source":"dafny_synthetic/loops","theorem":"CountOccurrences","id":112654,"goal":"ensures c == |set i | 0 <= i < a.Length && a[i] == key|; invariant 0 <= i <= a.Length; invariant c == |set j | 0 <= j < i && a[j] == key|","context":["ensures","invariant"]} +{"prover":"Dafny","tactic_proof":"method CopyArray(src: array) returns (dst: array)\n ensures dst.Length == src.Length\n ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]\n ensures fresh(dst)\n{\n dst := new int[src.Length];\n var i := 0;\n while i < src.Length\n invariant 0 <= i <= src.Length\n invariant forall j :: 0 <= j < i ==> dst[j] == src[j]\n {\n dst[i] := src[i];\n i := i + 1;\n }\n}","source":"dafny_synthetic/loops","theorem":"CopyArray","id":112655,"goal":"ensures dst.Length == src.Length; ensures forall i :: 0 <= i < src.Length ==> dst[i] == src[i]; ensures fresh(dst); invariant 0 <= i <= src.Length; invariant forall j :: 0 <= j < i ==> dst[j] == src[j]","context":["ensures","invariant"]} +{"prover":"Dafny","tactic_proof":"method TwoSum(a: array, target: int) returns (i: int, j: int)\n requires Sorted(a, 0, a.Length)\n ensures 0 <= i < j < a.Length ==> a[i] + a[j] == target\n{\n i, j := 0, a.Length - 1;\n while i < j\n invariant 0 <= i && j < a.Length\n invariant forall p, q :: 0 <= p < i && i <= q < a.Length ==> a[p] + a[q] != target\n {\n if a[i] + a[j] == target { return; }\n else if a[i] + a[j] < target { i := i + 1; }\n else { j := j - 1; }\n }\n return -1, -1;\n}","source":"dafny_synthetic/loops","theorem":"TwoSum","id":112656,"goal":"requires Sorted(a, 0, a.Length); ensures 0 <= i < j < a.Length ==> a[i] + a[j] == target; invariant 0 <= i && j < a.Length; invariant forall p, q :: 0 <= p < i && i <= q < a.Length ==> a[p] + a[q] != target","context":["requires","ensures","invariant"]} +{"prover":"Dafny","tactic_proof":"lemma SumFormula(n: nat)\n ensures 2 * SumTo(n) == n * (n + 1)\n decreases n\n{\n if n == 0 { } else { SumFormula(n - 1); }\n}","source":"dafny_synthetic/induction","theorem":"SumFormula","id":112657,"goal":"ensures 2 * SumTo(n) == n * (n + 1); decreases n","context":["ensures","decreases"]} +{"prover":"Dafny","tactic_proof":"lemma PowerMonotone(b: nat, m: nat, n: nat)\n requires b >= 2 && m <= n\n ensures Pow(b, m) <= Pow(b, n)\n decreases n - m\n{\n if m == n { } else { PowerMonotone(b, m, n - 1); }\n}","source":"dafny_synthetic/induction","theorem":"PowerMonotone","id":112658,"goal":"requires b >= 2 && m <= n; ensures Pow(b, m) <= Pow(b, n); decreases n - m","context":["requires","ensures","decreases"]} +{"prover":"Dafny","tactic_proof":"lemma ListFlatten(l1: List, l2: List)\n ensures Length(Append(l1, l2)) == Length(l1) + Length(l2)\n decreases l1\n{\n match l1 { case Nil => case Cons(_, tl) => ListFlatten(tl, l2); }\n}","source":"dafny_synthetic/induction","theorem":"ListFlatten","id":112659,"goal":"ensures Length(Append(l1, l2)) == Length(l1) + Length(l2); decreases l1","context":["ensures","decreases"]} +{"prover":"Dafny","tactic_proof":"lemma TreeHeight(t: Tree)\n ensures Height(t) >= 0\n decreases t\n{\n match t {\n case Leaf => {}\n case Node(l, _, r) => { TreeHeight(l); TreeHeight(r); }\n }\n}","source":"dafny_synthetic/induction","theorem":"TreeHeight","id":112660,"goal":"ensures Height(t) >= 0; decreases t","context":["ensures","decreases"]} +{"prover":"Dafny","tactic_proof":"lemma FibMonotone(m: nat, n: nat)\n requires m <= n && m >= 1\n ensures Fib(m) <= Fib(n)\n decreases n - m\n{\n if m == n { } else { FibMonotone(m, n - 1); FibPositive(n - 2); }\n}","source":"dafny_synthetic/induction","theorem":"FibMonotone","id":112661,"goal":"requires m <= n && m >= 1; ensures Fib(m) <= Fib(n); decreases n - m","context":["requires","ensures","decreases"]} +{"prover":"Dafny","tactic_proof":"lemma StrongInduction(n: nat, P: nat -> bool)\n requires forall k: nat :: (forall j: nat :: j < k ==> P(j)) ==> P(k)\n ensures P(n)\n decreases n\n{\n forall j: nat | j < n ensures P(j) { StrongInduction(j, P); }\n}","source":"dafny_synthetic/induction","theorem":"StrongInduction","id":112662,"goal":"requires forall k: nat :: (forall j: nat :: j < k ==> P(j)) ==> P(k); ensures P(n); decreases n; forall j: nat | j < n ensures P(j) { StrongInduction(j, P); }","context":["requires","ensures","decreases"]} +{"prover":"Dafny","tactic_proof":"lemma BinomialTheorem(x: int, y: int, n: nat)\n ensures Pow(x + y, n) == Sum(k => Choose(n, k) * Pow(x, n - k) * Pow(y, k), 0, n)\n decreases n\n{}","source":"dafny_synthetic/induction","theorem":"BinomialTheorem","id":112663,"goal":"ensures Pow(x + y, n) == Sum(k => Choose(n, k) * Pow(x, n - k) * Pow(y, k), 0, n); decreases n","context":["ensures","decreases"]} +{"prover":"Dafny","tactic_proof":"method GhostCounter(n: nat) returns (r: nat)\n ensures r == n\n{\n r := 0;\n ghost var g := 0;\n while r < n\n invariant r == g && r <= n\n {\n r := r + 1;\n g := g + 1;\n }\n}","source":"dafny_synthetic/ghost","theorem":"GhostCounter","id":112664,"goal":"ensures r == n; invariant r == g && r <= n","context":["ensures","invariant"]} +{"prover":"Dafny","tactic_proof":"method FrameCondition(a: array, b: array, i: nat)\n requires a != b && i < a.Length\n modifies a\n ensures b[..] == old(b[..])\n ensures forall j :: 0 <= j < a.Length && j != i ==> a[j] == old(a[j])\n{\n a[i] := a[i] + 1;\n}","source":"dafny_synthetic/ghost","theorem":"FrameCondition","id":112665,"goal":"requires a != b && i < a.Length; modifies a; ensures b[..] == old(b[..]); ensures forall j :: 0 <= j < a.Length && j != i ==> a[j] == old(a[j])","context":["requires","modifies","ensures"]} +{"prover":"Dafny","tactic_proof":"class Node {\n var val: int\n var next: Node?\n ghost var repr: set\n predicate Valid()\n reads this, repr\n {\n this in repr &&\n (next != null ==> next in repr && next.repr < repr && next.Valid())\n }\n}","source":"dafny_synthetic/ghost","theorem":"ReprValid","id":112666,"goal":"class Node {","context":["reads"]} +{"prover":"Dafny","tactic_proof":"method AllocFresh() returns (r: array)\n ensures fresh(r)\n ensures r.Length == 10\n ensures forall i :: 0 <= i < 10 ==> r[i] == 0\n{\n r := new int[10];\n}","source":"dafny_synthetic/ghost","theorem":"AllocFresh","id":112667,"goal":"ensures fresh(r); ensures r.Length == 10; ensures forall i :: 0 <= i < 10 ==> r[i] == 0","context":["ensures"]} +{"prover":"Dafny","tactic_proof":"method GhostSequence(a: array)\n modifies a\n ensures a[..] == Reverse(old(a[..]))\n{\n ghost var original := a[..];\n ReverseInPlace(a);\n}","source":"dafny_synthetic/ghost","theorem":"GhostSequence","id":112668,"goal":"modifies a; ensures a[..] == Reverse(old(a[..]))","context":["modifies","ensures"]} +{"prover":"Dafny","tactic_proof":"type NonNullArray = a: array | a.Length > 0 witness *","source":"dafny_synthetic/types","theorem":"NonNullArray","id":112669,"goal":"type NonNullArray = a: array | a.Length > 0 witness *","context":[]} +{"prover":"Dafny","tactic_proof":"type Positive = n: int | n > 0 witness 1","source":"dafny_synthetic/types","theorem":"PositiveInt","id":112670,"goal":"type Positive = n: int | n > 0 witness 1","context":[]} +{"prover":"Dafny","tactic_proof":"type Bounded = n: int | 0 <= n < 256 witness 0","source":"dafny_synthetic/types","theorem":"BoundedInt","id":112671,"goal":"type Bounded = n: int | 0 <= n < 256 witness 0","context":[]} +{"prover":"Dafny","tactic_proof":"type SortedSeq = s: seq | forall i, j :: 0 <= i < j < |s| ==> s[i] <= s[j] witness []","source":"dafny_synthetic/types","theorem":"SortedSeq","id":112672,"goal":"type SortedSeq = s: seq | forall i, j :: 0 <= i < j < |s| ==> s[i] <= s[j] witness []","context":[]} +{"prover":"Dafny","tactic_proof":"type NonEmptySeq = s: seq | |s| > 0 witness *","source":"dafny_synthetic/types","theorem":"NonEmptySeq","id":112673,"goal":"type NonEmptySeq = s: seq | |s| > 0 witness *","context":[]} +{"prover":"Dafny","tactic_proof":"type UniqueSeq = s: seq | forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] witness []","source":"dafny_synthetic/types","theorem":"UniqueSeq","id":112674,"goal":"type UniqueSeq = s: seq | forall i, j :: 0 <= i < j < |s| ==> s[i] != s[j] witness []","context":[]} +{"prover":"Dafny","tactic_proof":"type Percentage = r: real | 0.0 <= r <= 100.0 witness 0.0","source":"dafny_synthetic/types","theorem":"Percentage","id":112675,"goal":"type Percentage = r: real | 0.0 <= r <= 100.0 witness 0.0","context":[]} +{"prover":"Dafny","tactic_proof":"class Mutex {\n ghost var locked: bool\n method Acquire()\n requires !locked\n modifies this\n ensures locked\n {\n locked := true;\n }\n method Release()\n requires locked\n modifies this\n ensures !locked\n {\n locked := false;\n }\n}","source":"dafny_synthetic/concurrency","theorem":"MutexSpec","id":112676,"goal":"requires !locked; modifies this; ensures locked; requires locked; modifies this; ensures !locked","context":["requires","modifies","ensures"]} +{"prover":"Dafny","tactic_proof":"method TokenRing(nodes: array, holder: nat)\n requires holder < nodes.Length\n requires nodes[holder] == true\n requires forall i :: 0 <= i < nodes.Length && i != holder ==> nodes[i] == false\n modifies nodes\n ensures nodes[(holder + 1) % nodes.Length] == true\n ensures forall i :: 0 <= i < nodes.Length && i != (holder + 1) % nodes.Length ==> nodes[i] == false\n{}","source":"dafny_synthetic/concurrency","theorem":"TokenRing","id":112677,"goal":"requires holder < nodes.Length; requires nodes[holder] == true; requires forall i :: 0 <= i < nodes.Length && i != holder ==> nodes[i] == false; modifies nodes; ensures nodes[(holder + 1) % nodes.Length] == true; ensures forall i :: 0 <= i < nodes.Length && i != (holder + 1) % nodes.Length ==> nodes[i] == false","context":["requires","modifies","ensures"]} +{"prover":"Dafny","tactic_proof":"method AtomicIncrement(x: int) returns (y: int)\n ensures y == x + 1\n{\n y := x + 1;\n}","source":"dafny_synthetic/concurrency","theorem":"AtomicIncrement","id":112678,"goal":"ensures y == x + 1","context":["ensures"]} +{"prover":"Dafny","tactic_proof":"method CAS(r: ref, expected: int, desired: int) returns (success: bool)\n modifies r\n ensures success ==> old(r.val) == expected && r.val == desired\n ensures !success ==> r.val == old(r.val)\n{}","source":"dafny_synthetic/concurrency","theorem":"CompareAndSwap","id":112679,"goal":"modifies r; ensures success ==> old(r.val) == expected && r.val == desired; ensures !success ==> r.val == old(r.val)","context":["modifies","ensures"]} diff --git a/training_data/proof_states_fstar.jsonl b/training_data/proof_states_fstar.jsonl index a9ed5d0..61a087b 100644 --- a/training_data/proof_states_fstar.jsonl +++ b/training_data/proof_states_fstar.jsonl @@ -10023,3 +10023,95 @@ {"prover":"FStar","tactic_proof":"let rec gcd a b = if b = 0 then a else gcd b (a % b)","source":"fstar_synthetic/termination","theorem":"gcd_termination","id":107022,"goal":"val gcd: a:nat -> b:nat{a > 0 || b > 0} -> Tot (r:pos) (decreases b)","context":["Tot","decreases"]} {"prover":"FStar","tactic_proof":"","source":"fstar_synthetic/termination","theorem":"collatz_steps","id":107023,"goal":"val collatz_steps: n:pos -> Tot nat (decreases %[n; if n = 1 then 0 else 1])","context":["Tot","decreases"]} {"prover":"FStar","tactic_proof":"let rec mutual_even n = if n = 0 then true else mutual_odd (n - 1)\nand mutual_odd n = if n = 0 then false else mutual_even (n - 1)","source":"fstar_synthetic/termination","theorem":"mutual_even","id":107024,"goal":"val mutual_even: n:nat -> Tot bool (decreases n)\nval mutual_odd: n:nat -> Tot bool (decreases n)","context":["Tot","decreases"]} +{"prover":"FStar","tactic_proof":"let seq_append_length #a s1 s2 = Seq.lemma_len_append s1 s2","source":"fstar_synthetic/sequences","theorem":"seq_append_length","id":107025,"goal":"val seq_append_length: #a:Type -> s1:Seq.seq a -> s2:Seq.seq a -> Lemma (Seq.length (Seq.append s1 s2) == Seq.length s1 + Seq.length s2)","context":["Lemma"]} +{"prover":"FStar","tactic_proof":"let seq_slice_slice #a s i j k l = Seq.lemma_slice_slice s i j k l","source":"fstar_synthetic/sequences","theorem":"seq_slice_slice","id":107026,"goal":"val seq_slice_slice: #a:Type -> s:Seq.seq a -> i:nat -> j:nat{i <= j} -> k:nat -> l:nat{k <= l /\\ l <= j - i} -> Lemma (Seq.slice (Seq.slice s i j) k l == Seq.slice s (i + k) (i + l))","context":["Lemma"]} +{"prover":"FStar","tactic_proof":"let seq_create_index #a n v i = ()","source":"fstar_synthetic/sequences","theorem":"seq_create_index","id":107027,"goal":"val seq_create_index: #a:Type -> n:nat -> v:a -> i:nat{i < n} -> Lemma (Seq.index (Seq.create n v) i == v)","context":["Lemma"]} +{"prover":"FStar","tactic_proof":"let seq_upd_index #a s i v j = ()","source":"fstar_synthetic/sequences","theorem":"seq_upd_index","id":107028,"goal":"val seq_upd_index: #a:Type -> s:Seq.seq a -> i:nat{i < Seq.length s} -> v:a -> j:nat{j < Seq.length s} -> Lemma (Seq.index (Seq.upd s i v) j == (if i = j then v else Seq.index s j))","context":["Lemma"]} +{"prover":"FStar","tactic_proof":"let seq_equal_intro #a s1 s2 = Seq.lemma_eq_intro s1 s2","source":"fstar_synthetic/sequences","theorem":"seq_equal_intro","id":107029,"goal":"val seq_equal_intro: #a:Type -> s1:Seq.seq a -> s2:Seq.seq a -> Lemma (requires Seq.length s1 == Seq.length s2 /\\ (forall (i:nat{i < Seq.length s1}). Seq.index s1 i == Seq.index s2 i)) (ensures Seq.equal s1 s2)","context":["Lemma","requires","ensures"]} +{"prover":"FStar","tactic_proof":"let seq_mem_append #a x s1 s2 = Seq.lemma_mem_append s1 s2","source":"fstar_synthetic/sequences","theorem":"seq_mem_append","id":107030,"goal":"val seq_mem_append: #a:eqtype -> x:a -> s1:Seq.seq a -> s2:Seq.seq a -> Lemma (Seq.mem x (Seq.append s1 s2) <==> Seq.mem x s1 || Seq.mem x s2)","context":["Lemma"]} +{"prover":"FStar","tactic_proof":"let seq_count_append #a x s1 s2 = Seq.lemma_count_append x s1 s2","source":"fstar_synthetic/sequences","theorem":"seq_count_append","id":107031,"goal":"val seq_count_append: #a:eqtype -> x:a -> s1:Seq.seq a -> s2:Seq.seq a -> Lemma (Seq.count x (Seq.append s1 s2) == Seq.count x s1 + Seq.count x s2)","context":["Lemma"]} +{"prover":"FStar","tactic_proof":"let seq_sort_permutation #a f s = Seq.lemma_sortWith_permutation f s","source":"fstar_synthetic/sequences","theorem":"seq_sort_permutation","id":107032,"goal":"val seq_sort_permutation: #a:eqtype -> f:(a -> a -> Tot int) -> s:Seq.seq a -> Lemma (ensures Seq.permutation a (Seq.sortWith f s) s)","context":["Tot","Lemma","ensures"]} +{"prover":"FStar","tactic_proof":"let seq_unsnoc #a s = Seq.un_snoc s","source":"fstar_synthetic/sequences","theorem":"seq_unsnoc","id":107033,"goal":"val seq_unsnoc: #a:Type -> s:Seq.seq a{Seq.length s > 0} -> Tot (Seq.seq a & a)","context":["Tot"]} +{"prover":"FStar","tactic_proof":"let seq_cons_head_tail #a s = Seq.lemma_cons_head_tail s","source":"fstar_synthetic/sequences","theorem":"seq_cons_head_tail","id":107034,"goal":"val seq_cons_head_tail: #a:Type -> s:Seq.seq a{Seq.length s > 0} -> Lemma (Seq.cons (Seq.head s) (Seq.tail s) == s)","context":["Lemma"]} +{"prover":"FStar","tactic_proof":"let seq_map_seq #a #b f s i = Seq.map_seq_index f s i","source":"fstar_synthetic/sequences","theorem":"seq_map_seq","id":107035,"goal":"val seq_map_seq: #a:Type -> #b:Type -> f:(a -> Tot b) -> s:Seq.seq a -> i:nat{i < Seq.length s} -> Lemma (Seq.index (Seq.map_seq f s) i == f (Seq.index s i))","context":["Tot","Lemma"]} +{"prover":"FStar","tactic_proof":"let seq_init_index #a n f i = Seq.init_index n f i","source":"fstar_synthetic/sequences","theorem":"seq_init_index","id":107036,"goal":"val seq_init_index: #a:Type -> n:nat -> f:(i:nat{i < n} -> Tot a) -> i:nat{i < n} -> Lemma (Seq.index (Seq.init n f) i == f i)","context":["Tot","Lemma"]} +{"prover":"FStar","tactic_proof":"let buffer_live #a h b = ()","source":"fstar_synthetic/buffers","theorem":"buffer_live","id":107037,"goal":"val buffer_live: #a:Type -> h:HS.mem -> b:B.buffer a -> Lemma (requires B.live h b) (ensures B.length b >= 0 /\\ B.live h b)","context":["Lemma","requires","ensures"]} +{"prover":"FStar","tactic_proof":"let buffer_read_write #a b i v h0 = ()","source":"fstar_synthetic/buffers","theorem":"buffer_read_write","id":107038,"goal":"val buffer_read_write: #a:Type -> b:B.buffer a -> i:UInt32.t{UInt32.v i < B.length b} -> v:a -> h0:HS.mem -> Lemma (requires B.live h0 b) (ensures (let h1 = B.g_upd b (UInt32.v i) v h0 in B.get h1 b (UInt32.v i) == v))","context":["Lemma","requires","ensures"]} +{"prover":"FStar","tactic_proof":"let buffer_modifies_only #a b h0 h1 = ()","source":"fstar_synthetic/buffers","theorem":"buffer_modifies_only","id":107039,"goal":"val buffer_modifies_only: #a:Type -> b:B.buffer a -> h0:HS.mem -> h1:HS.mem -> Lemma (requires B.modifies (B.loc_buffer b) h0 h1) (ensures B.modifies (B.loc_buffer b) h0 h1)","context":["Lemma","requires","modifies","ensures"]} +{"prover":"FStar","tactic_proof":"let buffer_disjoint #a #b b1 b2 h0 h1 v = B.modifies_buffer_elim b2 (B.loc_buffer b1) h0 h1","source":"fstar_synthetic/buffers","theorem":"buffer_disjoint","id":107040,"goal":"val buffer_disjoint: #a:Type -> #b:Type -> b1:B.buffer a -> b2:B.buffer b -> h0:HS.mem -> h1:HS.mem -> v:a -> Lemma (requires B.live h0 b1 /\\ B.live h0 b2 /\\ B.disjoint b1 b2 /\\ B.modifies (B.loc_buffer b1) h0 h1) (ensures B.as_seq h1 b2 == B.as_seq h0 b2)","context":["Lemma","requires","modifies","ensures"]} +{"prover":"FStar","tactic_proof":"let buffer_as_seq_gsub #a b i len h = ()","source":"fstar_synthetic/buffers","theorem":"buffer_as_seq_gsub","id":107041,"goal":"val buffer_as_seq_gsub: #a:Type -> b:B.buffer a -> i:UInt32.t -> len:UInt32.t{UInt32.v i + UInt32.v len <= B.length b} -> h:HS.mem -> Lemma (requires B.live h b) (ensures B.as_seq h (B.gsub b i len) == Seq.slice (B.as_seq h b) (UInt32.v i) (UInt32.v i + UInt32.v len))","context":["Lemma","requires","ensures"]} +{"prover":"FStar","tactic_proof":"let buffer_concat #a b1 b2 h = ()","source":"fstar_synthetic/buffers","theorem":"buffer_concat","id":107042,"goal":"val buffer_concat: #a:Type -> b1:B.buffer a -> b2:B.buffer a -> h:HS.mem -> Lemma (requires B.live h b1 /\\ B.live h b2 /\\ B.disjoint b1 b2) (ensures B.length b1 + B.length b2 >= 0)","context":["Lemma","requires","ensures"]} +{"prover":"FStar","tactic_proof":"let stack_alloc_free () = push_frame (); let b = B.alloca 0uy 16ul in let _ = b.(0ul) in pop_frame ()","source":"fstar_synthetic/buffers","theorem":"stack_alloc_free","id":107043,"goal":"val stack_alloc_free: unit -> ST unit (requires fun h -> True) (ensures fun h0 _ h1 -> modifies Set.empty h0 h1)","context":["ST","requires","ensures","modifies"]} +{"prover":"FStar","tactic_proof":"let buffer_frame #a #b buf other h0 h1 = B.modifies_buffer_elim buf (B.loc_buffer other) h0 h1","source":"fstar_synthetic/buffers","theorem":"buffer_frame","id":107044,"goal":"val buffer_frame: #a:Type -> #b:Type -> buf:B.buffer a -> other:B.buffer b -> h0:HS.mem -> h1:HS.mem -> Lemma (requires B.live h0 buf /\\ B.live h0 other /\\ B.disjoint buf other /\\ B.modifies (B.loc_buffer other) h0 h1) (ensures B.as_seq h0 buf == B.as_seq h1 buf /\\ B.live h1 buf)","context":["Lemma","requires","modifies","ensures"]} +{"prover":"FStar","tactic_proof":"let buffer_loc_disjoint #a #b b1 b2 = B.loc_disjoint_buffer b1 b2","source":"fstar_synthetic/buffers","theorem":"buffer_loc_disjoint","id":107045,"goal":"val buffer_loc_disjoint: #a:Type -> #b:Type -> b1:B.buffer a -> b2:B.buffer b -> Lemma (requires B.disjoint b1 b2) (ensures B.loc_disjoint (B.loc_buffer b1) (B.loc_buffer b2))","context":["Lemma","requires","ensures"]} +{"prover":"FStar","tactic_proof":"let buffer_length_gsub #a b i len = ()","source":"fstar_synthetic/buffers","theorem":"buffer_length_gsub","id":107046,"goal":"val buffer_length_gsub: #a:Type -> b:B.buffer a -> i:UInt32.t -> len:UInt32.t{UInt32.v i + UInt32.v len <= B.length b} -> Lemma (B.length (B.gsub b i len) == UInt32.v len)","context":["Lemma"]} +{"prover":"FStar","tactic_proof":"let witnessed_stable #a #rel r p h = gst_witness r p","source":"fstar_synthetic/monotonic_state","theorem":"witnessed_stable","id":107047,"goal":"val witnessed_stable: #a:Type -> #rel:Preorder.preorder a -> r:mref a rel -> p:(a -> Type0){stable p rel} -> h:HS.mem -> Lemma (requires p (HS.sel h r)) (ensures witnessed r p)","context":["Lemma","requires","ensures"]} +{"prover":"FStar","tactic_proof":"let recall_witnessed #a #rel r p = gst_recall r p","source":"fstar_synthetic/monotonic_state","theorem":"recall_witnessed","id":107048,"goal":"val recall_witnessed: #a:Type -> #rel:Preorder.preorder a -> r:mref a rel -> p:(a -> Type0){stable p rel} -> ST unit (requires fun h -> witnessed r p) (ensures fun h0 _ h1 -> h0 == h1 /\\ p (HS.sel h1 r))","context":["ST","requires","ensures"]} +{"prover":"FStar","tactic_proof":"let gst_witness #a #rel r p = witness_p r p","source":"fstar_synthetic/monotonic_state","theorem":"gst_witness","id":107049,"goal":"val gst_witness: #a:Type -> #rel:Preorder.preorder a -> r:mref a rel -> p:(a -> Type0){stable p rel} -> ST unit (requires fun h -> p (HS.sel h r)) (ensures fun h0 _ h1 -> h0 == h1 /\\ witnessed r p)","context":["ST","requires","ensures"]} +{"prover":"FStar","tactic_proof":"let stable_predicate #a #rel p = ()","source":"fstar_synthetic/monotonic_state","theorem":"stable_predicate","id":107050,"goal":"val stable_predicate: #a:Type -> #rel:Preorder.preorder a -> p:(a -> Type0) -> Lemma (requires forall (x y : a). p x /\\ rel x y ==> p y) (ensures stable p rel)","context":["Lemma","requires","ensures"]} +{"prover":"FStar","tactic_proof":"let monotonic_ref_read #a #rel r = !r","source":"fstar_synthetic/monotonic_state","theorem":"monotonic_ref_read","id":107051,"goal":"val monotonic_ref_read: #a:Type -> #rel:Preorder.preorder a -> r:mref a rel -> ST a (requires fun h -> True) (ensures fun h0 v h1 -> h0 == h1 /\\ v == HS.sel h1 r)","context":["ST","requires","ensures"]} +{"prover":"FStar","tactic_proof":"let monotonic_ref_write #a #rel r v = r := v","source":"fstar_synthetic/monotonic_state","theorem":"monotonic_ref_write","id":107052,"goal":"val monotonic_ref_write: #a:Type -> #rel:Preorder.preorder a -> r:mref a rel -> v:a -> ST unit (requires fun h -> rel (HS.sel h r) v) (ensures fun h0 _ h1 -> HS.sel h1 r == v /\\ modifies (Set.singleton (HS.frameOf r)) h0 h1)","context":["ST","requires","ensures","modifies"]} +{"prover":"FStar","tactic_proof":"let token_fresh #a #rel r h = ()","source":"fstar_synthetic/monotonic_state","theorem":"token_fresh","id":107053,"goal":"val token_fresh: #a:Type -> #rel:Preorder.preorder a -> r:mref a rel -> h:HS.mem -> Lemma (requires HS.contains h r) (ensures HS.frameOf r `HS.is_in` HS.get_hmap h)","context":["Lemma","requires","ensures"]} +{"prover":"FStar","tactic_proof":"let region_contains #a #rel r h = ()","source":"fstar_synthetic/monotonic_state","theorem":"region_contains","id":107054,"goal":"val region_contains: #a:Type -> #rel:Preorder.preorder a -> r:mref a rel -> h:HS.mem -> Lemma (requires HS.contains h r) (ensures HS.live_region h (HS.frameOf r))","context":["Lemma","requires","ensures"]} +{"prover":"FStar","tactic_proof":"let norm_spec a b = assert (normalize_term (a + 0) == a) by (let _ = norm [delta; zeta; primops] in trefl ())","source":"fstar_synthetic/tactics","theorem":"norm_spec","id":107055,"goal":"val norm_spec: a:nat -> b:nat -> Lemma (normalize_term (a + 0) == a)","context":["Lemma"]} +{"prover":"FStar","tactic_proof":"let canon_semiring a b c = assert (a * (b + c) == a * b + a * c) by (canon_semiring_int ())","source":"fstar_synthetic/tactics","theorem":"canon_semiring","id":107056,"goal":"val canon_semiring: a:int -> b:int -> c:int -> Lemma (a * (b + c) == a * b + a * c)","context":["Lemma"]} +{"prover":"FStar","tactic_proof":"let trefl_lemma a = assert (a == a) by trefl ()","source":"fstar_synthetic/tactics","theorem":"trefl_lemma","id":107057,"goal":"val trefl_lemma: a:int -> Lemma (a == a)","context":["Lemma"]} +{"prover":"FStar","tactic_proof":"let mapply_lemma a b = assert (a + 0 == b) by (mapply (`FStar.Math.Lemmas.add_zero_r); assumption ())","source":"fstar_synthetic/tactics","theorem":"mapply_lemma","id":107058,"goal":"val mapply_lemma: a:int -> b:int -> Lemma (requires a == b) (ensures a + 0 == b)","context":["Lemma","requires","ensures"]} +{"prover":"FStar","tactic_proof":"let smt_lemma a b = assert (a + b >= a) by smt ()","source":"fstar_synthetic/tactics","theorem":"smt_lemma","id":107059,"goal":"val smt_lemma: a:nat -> b:nat -> Lemma (a + b >= a)","context":["Lemma"]} +{"prover":"FStar","tactic_proof":"let pointwise_lemma a b c = assert ((a + b) + c == a + (b + c)) by (pointwise (fun () -> trefl ()); trefl ())","source":"fstar_synthetic/tactics","theorem":"pointwise_lemma","id":107060,"goal":"val pointwise_lemma: a:int -> b:int -> c:int -> Lemma ((a + b) + c == a + (b + c))","context":["Lemma"]} +{"prover":"FStar","tactic_proof":"let grewrite_lemma a b = assert (a + 1 == b + 1) by (grewrite (quote a) (quote b); assumption (); trefl ())","source":"fstar_synthetic/tactics","theorem":"grewrite_lemma","id":107061,"goal":"val grewrite_lemma: a:int -> b:int -> Lemma (requires a == b) (ensures a + 1 == b + 1)","context":["Lemma","requires","ensures"]} +{"prover":"FStar","tactic_proof":"let tadmit_placeholder a b = assert (a * b == b * a) by tadmit ()","source":"fstar_synthetic/tactics","theorem":"tadmit_placeholder","id":107062,"goal":"val tadmit_placeholder: a:int -> b:int -> Lemma (a * b == b * a)","context":["Lemma"]} +{"prover":"FStar","tactic_proof":"let vector_head #a #n v = Seq.index v 0","source":"fstar_synthetic/dependent_types","theorem":"vector_head","id":107063,"goal":"val vector_head: #a:Type -> #n:nat{n > 0} -> v:vector a (n + 1) -> Tot a","context":["Tot"]} +{"prover":"FStar","tactic_proof":"let vector_cons_snoc #a #n x v = ()","source":"fstar_synthetic/dependent_types","theorem":"vector_cons_snoc","id":107064,"goal":"val vector_cons_snoc: #a:Type -> #n:nat -> x:a -> v:vector a n -> Lemma (length (cons x v) == n + 1 /\\ head (cons x v) == x)","context":["Lemma"]} +{"prover":"FStar","tactic_proof":"","source":"fstar_synthetic/dependent_types","theorem":"matrix_mult_assoc","id":107065,"goal":"val matrix_mult_assoc: #m:nat -> #n:nat -> #p:nat -> #q:nat -> a:matrix m n -> b:matrix n p -> c:matrix p q -> Lemma (mat_mult (mat_mult a b) c == mat_mult a (mat_mult b c))","context":["Lemma"]} +{"prover":"FStar","tactic_proof":"let rec sized_list_append #a #m #n l1 l2 = match l1 with | SNil -> l2 | SCons x xs -> SCons x (sized_list_append xs l2)","source":"fstar_synthetic/dependent_types","theorem":"sized_list_append","id":107066,"goal":"val sized_list_append: #a:Type -> #m:nat -> #n:nat -> l1:sized_list a m -> l2:sized_list a n -> Tot (sized_list a (m + n))","context":["Tot"]} +{"prover":"FStar","tactic_proof":"let bounded_nat_add #bound a b = a + b","source":"fstar_synthetic/dependent_types","theorem":"bounded_nat_add","id":107067,"goal":"val bounded_nat_add: #bound:nat -> a:bounded_nat bound -> b:bounded_nat bound{a + b <= bound} -> Tot (bounded_nat bound)","context":["Tot"]} +{"prover":"FStar","tactic_proof":"let rec indexed_sum #n f = if n = 0 then 0 else f (n - 1) + indexed_sum #(n - 1) (fun i -> f i)","source":"fstar_synthetic/dependent_types","theorem":"indexed_sum","id":107068,"goal":"val indexed_sum: #n:nat -> f:(i:nat{i < n} -> Tot nat) -> Tot nat (decreases n)","context":["Tot","decreases"]} +{"prover":"FStar","tactic_proof":"let rec heterogeneous_list ts = match ts with | [] -> unit | t :: rest -> t & heterogeneous_list rest","source":"fstar_synthetic/dependent_types","theorem":"heterogeneous_list","id":107069,"goal":"val heterogeneous_list: ts:list Type -> Type","context":[]} +{"prover":"FStar","tactic_proof":"let witness_exists #a #p x pf = (| x, pf |)","source":"fstar_synthetic/dependent_types","theorem":"witness_exists","id":107070,"goal":"val witness_exists: #a:Type -> #p:(a -> Type0) -> x:a -> pf:p x -> Tot (dtuple2 a p)","context":["Tot"]} +{"prover":"FStar","tactic_proof":"let refinement_subtyping x = x","source":"fstar_synthetic/dependent_types","theorem":"refinement_subtyping","id":107071,"goal":"val refinement_subtyping: x:nat{x > 5} -> Tot (y:int{y > 0})","context":["Tot"]} +{"prover":"FStar","tactic_proof":"let coercion_lemma #a #p #q x = ()","source":"fstar_synthetic/dependent_types","theorem":"coercion_lemma","id":107072,"goal":"val coercion_lemma: #a:Type -> #p:(a -> Type0) -> #q:(a -> Type0) -> x:a{p x} -> Lemma (requires forall (y:a). p y ==> q y) (ensures q x)","context":["Lemma","requires","ensures"]} +{"prover":"FStar","tactic_proof":"let u8_add_mod a b = ()","source":"fstar_synthetic/machine_integers","theorem":"u8_add_mod","id":107073,"goal":"val u8_add_mod: a:UInt8.t -> b:UInt8.t -> Lemma (UInt8.v (UInt8.add_mod a b) == (UInt8.v a + UInt8.v b) % 256)","context":["Lemma"]} +{"prover":"FStar","tactic_proof":"","source":"fstar_synthetic/machine_integers","theorem":"u32_shift_left","id":107074,"goal":"val u32_shift_left: a:UInt32.t -> s:UInt32.t{UInt32.v s < 32} -> Lemma (UInt32.v (UInt32.shift_left a s) == (UInt32.v a * pow2 (UInt32.v s)) % pow2 32)","context":["Lemma"]} +{"prover":"FStar","tactic_proof":"let u64_logand_comm a b = UInt64.logand_commutative a b","source":"fstar_synthetic/machine_integers","theorem":"u64_logand_comm","id":107075,"goal":"val u64_logand_comm: a:UInt64.t -> b:UInt64.t -> Lemma (UInt64.logand a b == UInt64.logand b a)","context":["Lemma"]} +{"prover":"FStar","tactic_proof":"","source":"fstar_synthetic/machine_integers","theorem":"i32_add_overflow","id":107076,"goal":"val i32_add_overflow: a:Int32.t -> b:Int32.t -> Lemma (requires Int32.v a + Int32.v b < pow2 31 /\\ Int32.v a + Int32.v b >= -(pow2 31)) (ensures Int32.v (Int32.add a b) == Int32.v a + Int32.v b)","context":["Lemma","requires","ensures"]} +{"prover":"FStar","tactic_proof":"","source":"fstar_synthetic/machine_integers","theorem":"cast_u8_u32","id":107077,"goal":"val cast_u8_u32: a:UInt8.t -> Lemma (UInt32.v (FStar.Int.Cast.uint8_to_uint32 a) == UInt8.v a)","context":["Lemma"]} +{"prover":"FStar","tactic_proof":"","source":"fstar_synthetic/machine_integers","theorem":"u32_sub_mod","id":107078,"goal":"val u32_sub_mod: a:UInt32.t -> b:UInt32.t -> Lemma (UInt32.v (UInt32.sub_mod a b) == (UInt32.v a - UInt32.v b) % pow2 32)","context":["Lemma"]} +{"prover":"FStar","tactic_proof":"","source":"fstar_synthetic/machine_integers","theorem":"bytes_of_u32","id":107079,"goal":"val bytes_of_u32: n:UInt32.t -> Lemma (ensures length (uint32_to_bytes n) == 4)","context":["Lemma","ensures"]} +{"prover":"FStar","tactic_proof":"let u16_max_bound a = ()","source":"fstar_synthetic/machine_integers","theorem":"u16_max_bound","id":107080,"goal":"val u16_max_bound: a:UInt16.t -> Lemma (UInt16.v a < 65536)","context":["Lemma"]} +{"prover":"FStar","tactic_proof":"let parser_ret #a v = fun input -> Some (v, input)","source":"fstar_synthetic/parser_combinators","theorem":"parser_ret","id":107081,"goal":"val parser_ret: #a:Type -> v:a -> parser a","context":[]} +{"prover":"FStar","tactic_proof":"let parser_bind #a #b p f = fun input -> match p input with | None -> None | Some (v, rest) -> f v rest","source":"fstar_synthetic/parser_combinators","theorem":"parser_bind","id":107082,"goal":"val parser_bind: #a:Type -> #b:Type -> p:parser a -> f:(a -> parser b) -> parser b","context":[]} +{"prover":"FStar","tactic_proof":"let parser_map #a #b f p = parser_bind p (fun v -> parser_ret (f v))","source":"fstar_synthetic/parser_combinators","theorem":"parser_map","id":107083,"goal":"val parser_map: #a:Type -> #b:Type -> f:(a -> b) -> p:parser a -> parser b","context":[]} +{"prover":"FStar","tactic_proof":"let parser_alt #a p1 p2 = fun input -> match p1 input with | Some r -> Some r | None -> p2 input","source":"fstar_synthetic/parser_combinators","theorem":"parser_alt","id":107084,"goal":"val parser_alt: #a:Type -> p1:parser a -> p2:parser a -> parser a","context":[]} +{"prover":"FStar","tactic_proof":"let rec parser_many #a p = parser_alt (parser_bind p (fun v -> parser_bind (parser_many p) (fun vs -> parser_ret (v :: vs)))) (parser_ret [])","source":"fstar_synthetic/parser_combinators","theorem":"parser_many","id":107085,"goal":"val parser_many: #a:Type -> p:parser a -> parser (list a)","context":[]} +{"prover":"FStar","tactic_proof":"let parser_char c = fun input -> if Seq.length input > 0 && Seq.index input 0 = c then Some (c, Seq.slice input 1 (Seq.length input)) else None","source":"fstar_synthetic/parser_combinators","theorem":"parser_char","id":107086,"goal":"val parser_char: c:char -> parser char","context":[]} +{"prover":"FStar","tactic_proof":"let parser_digit = parser_bind (parser_satisfy is_digit) (fun c -> parser_ret (char_to_nat c))","source":"fstar_synthetic/parser_combinators","theorem":"parser_digit","id":107087,"goal":"val parser_digit: parser nat","context":[]} +{"prover":"FStar","tactic_proof":"let parser_satisfy f = fun input -> if Seq.length input > 0 && f (Seq.index input 0) then Some (Seq.index input 0, Seq.slice input 1 (Seq.length input)) else None","source":"fstar_synthetic/parser_combinators","theorem":"parser_satisfy","id":107088,"goal":"val parser_satisfy: (char -> bool) -> parser char","context":[]} +{"prover":"FStar","tactic_proof":"let sm_transition st ev = match st, ev with | Init, Start -> Running | Running, Stop -> Done | s, _ -> s","source":"fstar_synthetic/state_machine","theorem":"sm_transition","id":107089,"goal":"val sm_transition: st:state -> ev:event -> Tot state","context":["Tot"]} +{"prover":"FStar","tactic_proof":"let sm_invariant st = st <> Error","source":"fstar_synthetic/state_machine","theorem":"sm_invariant","id":107090,"goal":"val sm_invariant: st:state -> Tot bool","context":["Tot"]} +{"prover":"FStar","tactic_proof":"let sm_step_preserves st ev = ()","source":"fstar_synthetic/state_machine","theorem":"sm_step_preserves","id":107091,"goal":"val sm_step_preserves: st:state -> ev:event -> Lemma (requires sm_invariant st) (ensures sm_invariant (sm_transition st ev))","context":["Lemma","requires","ensures"]} +{"prover":"FStar","tactic_proof":"let rec sm_reachable events = match events with | [] -> Init | e :: es -> sm_transition (sm_reachable es) e","source":"fstar_synthetic/state_machine","theorem":"sm_reachable","id":107092,"goal":"val sm_reachable: events:list event -> Tot state (decreases events)","context":["Tot","decreases"]} +{"prover":"FStar","tactic_proof":"let rec sm_trace_valid events = match events with | [] -> () | e :: es -> sm_trace_valid es; sm_step_preserves (sm_reachable es) e","source":"fstar_synthetic/state_machine","theorem":"sm_trace_valid","id":107093,"goal":"val sm_trace_valid: events:list event -> Lemma (ensures sm_invariant (sm_reachable events)) (decreases events)","context":["Lemma","ensures","decreases"]} +{"prover":"FStar","tactic_proof":"","source":"fstar_synthetic/state_machine","theorem":"sm_deadlock_free","id":107094,"goal":"val sm_deadlock_free: st:state -> Lemma (requires st <> Done) (ensures exists (ev:event). sm_transition st ev <> st)","context":["Lemma","requires","ensures"]} +{"prover":"FStar","tactic_proof":"","source":"fstar_synthetic/protocol","theorem":"handshake_complete","id":107095,"goal":"val handshake_complete: c:client -> s:server -> Lemma (requires valid_hello c /\\ valid_hello s) (ensures handshake_result c s == Success)","context":["Lemma","requires","ensures"]} +{"prover":"FStar","tactic_proof":"let message_integrity k m = ()","source":"fstar_synthetic/protocol","theorem":"message_integrity","id":107096,"goal":"val message_integrity: k:key -> m:msg -> Lemma (ensures verify k m (mac k m) == true)","context":["Lemma","ensures"]} +{"prover":"FStar","tactic_proof":"let nonce_fresh n log = ()","source":"fstar_synthetic/protocol","theorem":"nonce_fresh","id":107097,"goal":"val nonce_fresh: n:nonce -> log:list nonce -> Lemma (requires not (mem n log)) (ensures fresh n log)","context":["Lemma","requires","ensures"]} +{"prover":"FStar","tactic_proof":"","source":"fstar_synthetic/protocol","theorem":"session_key_derive","id":107098,"goal":"val session_key_derive: psk:key -> c_rand:bytes -> s_rand:bytes -> Lemma (ensures length (derive psk c_rand s_rand) == 32)","context":["Lemma","ensures"]} +{"prover":"FStar","tactic_proof":"let replay_protection n log = ()","source":"fstar_synthetic/protocol","theorem":"replay_protection","id":107099,"goal":"val replay_protection: n:nonce -> log:list nonce -> Lemma (requires mem n log) (ensures reject n log)","context":["Lemma","requires","ensures"]} +{"prover":"FStar","tactic_proof":"","source":"fstar_synthetic/protocol","theorem":"forward_secrecy","id":107100,"goal":"val forward_secrecy: sk:key -> pk:key -> Lemma (requires ephemeral sk) (ensures not (recoverable sk pk))","context":["Lemma","requires","ensures"]} +{"prover":"FStar","tactic_proof":"","source":"fstar_synthetic/arrays_matrices","theorem":"array_swap","id":107101,"goal":"val array_swap: #a:Type -> b:buffer a -> i:nat -> j:nat -> ST unit (requires fun h -> live h b /\\ i < length b /\\ j < length b) (ensures fun h0 _ h1 -> modifies (loc_buffer b) h0 h1 /\\ get h1 b i == get h0 b j /\\ get h1 b j == get h0 b i)","context":["ST","requires","ensures","modifies"]} +{"prover":"FStar","tactic_proof":"","source":"fstar_synthetic/arrays_matrices","theorem":"array_fill","id":107102,"goal":"val array_fill: b:buffer UInt8.t -> v:UInt8.t -> ST unit (requires fun h -> live h b) (ensures fun h0 _ h1 -> modifies (loc_buffer b) h0 h1 /\\ (forall (i:nat). i < length b ==> get h1 b i == v))","context":["ST","requires","ensures","modifies"]} +{"prover":"FStar","tactic_proof":"let matrix_index #n #m mx i j = Seq.index (Seq.index mx i) j","source":"fstar_synthetic/arrays_matrices","theorem":"matrix_index","id":107103,"goal":"val matrix_index: #n:nat -> #m:nat -> mx:matrix n m -> i:nat{i < n} -> j:nat{j < m} -> Tot elem","context":["Tot"]} +{"prover":"FStar","tactic_proof":"","source":"fstar_synthetic/arrays_matrices","theorem":"matrix_transpose","id":107104,"goal":"val matrix_transpose: #n:nat -> #m:nat -> mx:matrix n m -> Tot (matrix m n)","context":["Tot"]} +{"prover":"FStar","tactic_proof":"let dot_product #n v1 v2 = fold_left (+) 0 (map2 ( * ) v1 v2)","source":"fstar_synthetic/arrays_matrices","theorem":"dot_product","id":107105,"goal":"val dot_product: #n:nat -> v1:vector n -> v2:vector n -> Tot int","context":["Tot"]} +{"prover":"FStar","tactic_proof":"","source":"fstar_synthetic/arrays_matrices","theorem":"array_sum_nonneg","id":107106,"goal":"val array_sum_nonneg: b:buffer nat -> Lemma (requires forall (i:nat). i < length b ==> get h b i >= 0) (ensures array_sum b >= 0)","context":["Lemma","requires","ensures"]} +{"prover":"FStar","tactic_proof":"let option_left_id #a #b x f = ()","source":"fstar_synthetic/monad_laws","theorem":"option_left_id","id":107107,"goal":"val option_left_id: #a:Type -> #b:Type -> x:a -> f:(a -> option b) -> Lemma (bind (Some x) f == f x)","context":["Lemma"]} +{"prover":"FStar","tactic_proof":"let option_right_id #a x = match x with | None -> () | Some _ -> ()","source":"fstar_synthetic/monad_laws","theorem":"option_right_id","id":107108,"goal":"val option_right_id: #a:Type -> x:option a -> Lemma (bind x Some == x)","context":["Lemma"]} +{"prover":"FStar","tactic_proof":"let option_assoc #a #b #c x f g = match x with | None -> () | Some _ -> ()","source":"fstar_synthetic/monad_laws","theorem":"option_assoc","id":107109,"goal":"val option_assoc: #a:Type -> #b:Type -> #c:Type -> x:option a -> f:(a -> option b) -> g:(b -> option c) -> Lemma (bind (bind x f) g == bind x (fun y -> bind (f y) g))","context":["Lemma"]} +{"prover":"FStar","tactic_proof":"let either_left_id #e #a #b x f = ()","source":"fstar_synthetic/monad_laws","theorem":"either_left_id","id":107110,"goal":"val either_left_id: #e:Type -> #a:Type -> #b:Type -> x:a -> f:(a -> either e b) -> Lemma (either_bind (Right x) f == f x)","context":["Lemma"]} +{"prover":"FStar","tactic_proof":"let either_right_id #e #a x = match x with | Left _ -> () | Right _ -> ()","source":"fstar_synthetic/monad_laws","theorem":"either_right_id","id":107111,"goal":"val either_right_id: #e:Type -> #a:Type -> x:either e a -> Lemma (either_bind x Right == x)","context":["Lemma"]} +{"prover":"FStar","tactic_proof":"let state_left_id #s #a #b x f = ()","source":"fstar_synthetic/monad_laws","theorem":"state_left_id","id":107112,"goal":"val state_left_id: #s:Type -> #a:Type -> #b:Type -> x:a -> f:(a -> state s b) -> Lemma (state_bind (state_return x) f == f x)","context":["Lemma"]} +{"prover":"FStar","tactic_proof":"","source":"fstar_synthetic/string_processing","theorem":"string_length_append","id":107113,"goal":"val string_length_append: s1:string -> s2:string -> Lemma (String.length (s1 ^ s2) == String.length s1 + String.length s2)","context":["Lemma"]} +{"prover":"FStar","tactic_proof":"","source":"fstar_synthetic/string_processing","theorem":"string_sub_valid","id":107114,"goal":"val string_sub_valid: s:string -> i:nat -> j:nat -> Lemma (requires i <= j /\\ j <= String.length s) (ensures String.length (String.sub s i j) == j - i)","context":["Lemma","requires","ensures"]} +{"prover":"FStar","tactic_proof":"","source":"fstar_synthetic/string_processing","theorem":"utf8_encode_decode","id":107115,"goal":"val utf8_encode_decode: s:string -> Lemma (utf8_decode (utf8_encode s) == Some s)","context":["Lemma"]} +{"prover":"FStar","tactic_proof":"","source":"fstar_synthetic/string_processing","theorem":"split_join","id":107116,"goal":"val split_join: s:string -> sep:string -> Lemma (requires String.length sep > 0) (ensures String.concat sep (String.split sep s) == s)","context":["Lemma","requires","ensures"]} diff --git a/training_data/proof_states_idris2.jsonl b/training_data/proof_states_idris2.jsonl index 253cab9..8d42c73 100644 --- a/training_data/proof_states_idris2.jsonl +++ b/training_data/proof_states_idris2.jsonl @@ -572,3 +572,82 @@ {"prover":"Idris2","tactic_proof":"","source":"idris2_synthetic/interfaces","theorem":"monadLeftId","id":98571,"goal":"monadLeftId : Monad m => (a : t) -> (f : t -> m u) -> (pure a >>= f) = f a","context":[]} {"prover":"Idris2","tactic_proof":"","source":"idris2_synthetic/interfaces","theorem":"monadRightId","id":98572,"goal":"monadRightId : Monad m => (ma : m a) -> (ma >>= pure) = ma","context":[]} {"prover":"Idris2","tactic_proof":"","source":"idris2_synthetic/interfaces","theorem":"monadAssoc","id":98573,"goal":"monadAssoc : Monad m => (ma : m a) -> (f : a -> m b) -> (g : b -> m c) -> ((ma >>= f) >>= g) = (ma >>= (\\x => f x >>= g))","context":[]} +{"prover":"Idris2","tactic_proof":"maybeMap f Nothing = Nothing\nmaybeMap f (Just x) = Just (f x)","source":"idris2_synthetic/maybe","theorem":"maybeMap","id":98574,"goal":"maybeMap : (f : a -> b) -> Maybe a -> Maybe b","context":["Maybe"]} +{"prover":"Idris2","tactic_proof":"maybeMapCompose f g Nothing = Refl\nmaybeMapCompose f g (Just x) = Refl","source":"idris2_synthetic/maybe","theorem":"maybeMapCompose","id":98575,"goal":"maybeMapCompose : (f : b -> c) -> (g : a -> b) -> (mx : Maybe a) -> maybeMap f (maybeMap g mx) = maybeMap (f . g) mx","context":["Maybe"]} +{"prover":"Idris2","tactic_proof":"maybeBind Nothing f = Nothing\nmaybeBind (Just x) f = f x","source":"idris2_synthetic/maybe","theorem":"maybeBind","id":98576,"goal":"maybeBind : Maybe a -> (a -> Maybe b) -> Maybe b","context":["Maybe"]} +{"prover":"Idris2","tactic_proof":"maybeBindAssoc Nothing f g = Refl\nmaybeBindAssoc (Just x) f g = Refl","source":"idris2_synthetic/maybe","theorem":"maybeBindAssoc","id":98577,"goal":"maybeBindAssoc : (mx : Maybe a) -> (f : a -> Maybe b) -> (g : b -> Maybe c) -> maybeBind (maybeBind mx f) g = maybeBind mx (\\x => maybeBind (f x) g)","context":["Maybe"]} +{"prover":"Idris2","tactic_proof":"isJustFromJust (Just x) Refl = (x ** Refl)\nisJustFromJust Nothing Refl impossible","source":"idris2_synthetic/maybe","theorem":"isJustFromJust","id":98578,"goal":"isJustFromJust : (mx : Maybe a) -> isJust mx = True -> DPair a (\\x => mx = Just x)","context":["Maybe","DPair"]} +{"prover":"Idris2","tactic_proof":"nothingAbsurd Refl impossible","source":"idris2_synthetic/maybe","theorem":"nothingAbsurd","id":98579,"goal":"nothingAbsurd : the (Maybe a) Nothing = Just x -> Void","context":["Maybe","Void"]} +{"prover":"Idris2","tactic_proof":"maybeToList Nothing = []\nmaybeToList (Just x) = [x]","source":"idris2_synthetic/maybe","theorem":"maybeToList","id":98580,"goal":"maybeToList : Maybe a -> List a","context":["Maybe","List"]} +{"prover":"Idris2","tactic_proof":"fromMaybeDefault def Nothing Refl = Refl\nfromMaybeDefault def (Just _) Refl impossible","source":"idris2_synthetic/maybe","theorem":"fromMaybeDefault","id":98581,"goal":"fromMaybeDefault : (def : a) -> (mx : Maybe a) -> mx = Nothing -> fromMaybe def mx = def","context":["Maybe"]} +{"prover":"Idris2","tactic_proof":"eitherMap f g (Left x) = Left (f x)\neitherMap f g (Right y) = Right (g y)","source":"idris2_synthetic/either","theorem":"eitherMap","id":98582,"goal":"eitherMap : (f : a -> c) -> (g : b -> d) -> Either a b -> Either c d","context":[]} +{"prover":"Idris2","tactic_proof":"eitherMapCompose f1 f2 g1 g2 (Left x) = Refl\neitherMapCompose f1 f2 g1 g2 (Right y) = Refl","source":"idris2_synthetic/either","theorem":"eitherMapCompose","id":98583,"goal":"eitherMapCompose : (f1 : c -> e) -> (f2 : a -> c) -> (g1 : d -> f) -> (g2 : b -> d) -> (e : Either a b) -> eitherMap f1 g1 (eitherMap f2 g2 e) = eitherMap (f1 . f2) (g1 . g2) e","context":[]} +{"prover":"Idris2","tactic_proof":"eitherBimap f g (Left x) = Left (f x)\neitherBimap f g (Right y) = Right (g y)","source":"idris2_synthetic/either","theorem":"eitherBimap","id":98584,"goal":"eitherBimap : (f : a -> c) -> (g : b -> d) -> Either a b -> Either c d","context":[]} +{"prover":"Idris2","tactic_proof":"eitherSwap (Left x) = Right x\neitherSwap (Right y) = Left y","source":"idris2_synthetic/either","theorem":"eitherSwap","id":98585,"goal":"eitherSwap : Either a b -> Either b a","context":[]} +{"prover":"Idris2","tactic_proof":"eitherAssoc (Left (Left x)) = Left x\neitherAssoc (Left (Right y)) = Right (Left y)\neitherAssoc (Right z) = Right (Right z)","source":"idris2_synthetic/either","theorem":"eitherAssoc","id":98586,"goal":"eitherAssoc : Either (Either a b) c -> Either a (Either b c)","context":[]} +{"prover":"Idris2","tactic_proof":"partitionEithers [] = ([], [])\npartitionEithers (Left x :: xs) = let (ls, rs) = partitionEithers xs in (x :: ls, rs)\npartitionEithers (Right y :: xs) = let (ls, rs) = partitionEithers xs in (ls, y :: rs)","source":"idris2_synthetic/either","theorem":"partitionEithers","id":98587,"goal":"partitionEithers : List (Either a b) -> (List a, List b)","context":["List"]} +{"prover":"Idris2","tactic_proof":"","source":"idris2_synthetic/either","theorem":"leftsAppend","id":98588,"goal":"leftsAppend : (xs, ys : List (Either a b)) -> fst (partitionEithers (xs ++ ys)) = fst (partitionEithers xs) ++ fst (partitionEithers ys)","context":["List"]} +{"prover":"Idris2","tactic_proof":"","source":"idris2_synthetic/either","theorem":"rightsAppend","id":98589,"goal":"rightsAppend : (xs, ys : List (Either a b)) -> snd (partitionEithers (xs ++ ys)) = snd (partitionEithers xs) ++ snd (partitionEithers ys)","context":["List"]} +{"prover":"Idris2","tactic_proof":"lteRefl Z = LTEZero\nlteRefl (S k) = LTESucc (lteRefl k)","source":"idris2_synthetic/nat_order","theorem":"lteRefl","id":98590,"goal":"lteRefl : (n : Nat) -> LTE n n","context":["Nat","LTE"]} +{"prover":"Idris2","tactic_proof":"lteAntisym LTEZero LTEZero = Refl\nlteAntisym (LTESucc p) (LTESucc q) = cong S (lteAntisym p q)","source":"idris2_synthetic/nat_order","theorem":"lteAntisym","id":98591,"goal":"lteAntisym : LTE m n -> LTE n m -> m = n","context":["LTE"]} +{"prover":"Idris2","tactic_proof":"lteTrans LTEZero _ = LTEZero\nlteTrans (LTESucc p) (LTESucc q) = LTESucc (lteTrans p q)","source":"idris2_synthetic/nat_order","theorem":"lteTrans","id":98592,"goal":"lteTrans : LTE l c -> LTE c r -> LTE l r","context":["LTE"]} +{"prover":"Idris2","tactic_proof":"notLteToGt {m = Z} contra = absurd (contra LTEZero)\nnotLteToGt {m = S k} {n = Z} _ = LTESucc LTEZero\nnotLteToGt {m = S k} {n = S j} contra = LTESucc (notLteToGt (\\p => contra (LTESucc p)))","source":"idris2_synthetic/nat_order","theorem":"notLteToGt","id":98593,"goal":"notLteToGt : Not (LTE m n) -> LT n m","context":["LTE"]} +{"prover":"Idris2","tactic_proof":"ltToLte (LTESucc p) = lteSuccRight p","source":"idris2_synthetic/nat_order","theorem":"ltToLte","id":98594,"goal":"ltToLte : LT m n -> LTE m n","context":["LTE"]} +{"prover":"Idris2","tactic_proof":"","source":"idris2_synthetic/nat_order","theorem":"maxComm","id":98595,"goal":"maxComm : (m, n : Nat) -> max m n = max n m","context":["Nat"]} +{"prover":"Idris2","tactic_proof":"takeLength Z s = Refl\ntakeLength (S k) (x :: xs) = cong S (takeLength k xs)","source":"idris2_synthetic/streams","theorem":"takeLength","id":98596,"goal":"takeLength : (n : Nat) -> (s : Stream a) -> length (take n s) = n","context":["Nat"]} +{"prover":"Idris2","tactic_proof":"iterateHead f x = Refl","source":"idris2_synthetic/streams","theorem":"iterateHead","id":98597,"goal":"iterateHead : (f : a -> a) -> (x : a) -> head (iterate f x) = x","context":[]} +{"prover":"Idris2","tactic_proof":"repeatHead x = Refl","source":"idris2_synthetic/streams","theorem":"repeatHead","id":98598,"goal":"repeatHead : (x : a) -> head (repeat x) = x","context":[]} +{"prover":"Idris2","tactic_proof":"cycleNonEmpty (x :: xs) IsNonEmpty = cycle (x :: xs)","source":"idris2_synthetic/streams","theorem":"cycleNonEmpty","id":98599,"goal":"cycleNonEmpty : (xs : List a) -> NonEmpty xs -> Stream a","context":["List"]} +{"prover":"Idris2","tactic_proof":"zipWithLength f Z s1 s2 = Refl\nzipWithLength f (S k) (x :: xs) (y :: ys) = cong S (zipWithLength f k xs ys)","source":"idris2_synthetic/streams","theorem":"zipWithLength","id":98600,"goal":"zipWithLength : (f : a -> b -> c) -> (n : Nat) -> (s1 : Stream a) -> (s2 : Stream b) -> length (take n (zipWith f s1 s2)) = n","context":["Nat"]} +{"prover":"Idris2","tactic_proof":"mapStream f Z s = Refl\nmapStream f (S k) (x :: xs) = cong (f x ::) (mapStream f k xs)","source":"idris2_synthetic/streams","theorem":"mapStream","id":98601,"goal":"mapStream : (f : a -> b) -> (n : Nat) -> (s : Stream a) -> take n (map f s) = map f (take n s)","context":["Nat"]} +{"prover":"Idris2","tactic_proof":"voidAbsurd v = absurd v","source":"idris2_synthetic/universe","theorem":"voidAbsurd","id":98602,"goal":"voidAbsurd : Void -> a","context":["Void"]} +{"prover":"Idris2","tactic_proof":"unitUnique () () = Refl","source":"idris2_synthetic/universe","theorem":"unitUnique","id":98603,"goal":"unitUnique : (x, y : ()) -> x = y","context":[]} +{"prover":"Idris2","tactic_proof":"boolDec True = Yes Refl\nboolDec False = No absurd","source":"idris2_synthetic/universe","theorem":"boolDec","id":98604,"goal":"boolDec : (b : Bool) -> Dec (b = True)","context":["Bool","Dec"]} +{"prover":"Idris2","tactic_proof":"notNotBool True = Refl\nnotNotBool False = Refl","source":"idris2_synthetic/universe","theorem":"notNotBool","id":98605,"goal":"notNotBool : (b : Bool) -> not (not b) = b","context":["Bool"]} +{"prover":"Idris2","tactic_proof":"decElim f g (Yes prf) = f prf\ndecElim f g (No contra) = g contra","source":"idris2_synthetic/universe","theorem":"decElim","id":98606,"goal":"decElim : (a -> b) -> (Not a -> b) -> Dec a -> b","context":["Dec"]} +{"prover":"Idris2","tactic_proof":"eitherCommIso (Left x) = Right x\neitherCommIso (Right y) = Left y","source":"idris2_synthetic/universe","theorem":"eitherCommIso","id":98607,"goal":"eitherCommIso : Either a b -> Either b a","context":[]} +{"prover":"Idris2","tactic_proof":"lengthReplicate Z x = Refl\nlengthReplicate (S k) x = cong S (lengthReplicate k x)","source":"idris2_synthetic/type_level","theorem":"lengthReplicate","id":98608,"goal":"lengthReplicate : (n : Nat) -> (x : a) -> length (replicate n x) = n","context":["Nat"]} +{"prover":"Idris2","tactic_proof":"","source":"idris2_synthetic/type_level","theorem":"transposeInvolutive","id":98609,"goal":"transposeInvolutive : (xss : Vect m (Vect n a)) -> transpose (transpose xss) = xss","context":["Vect"]} +{"prover":"Idris2","tactic_proof":"","source":"idris2_synthetic/type_level","theorem":"diagonalZip","id":98610,"goal":"diagonalZip : (xs : Vect n a) -> map (\\i => index i xs) range = xs","context":["Vect"]} +{"prover":"Idris2","tactic_proof":"tabulateIndex f FZ = Refl\ntabulateIndex f (FS k) = tabulateIndex (f . FS) k","source":"idris2_synthetic/type_level","theorem":"tabulateIndex","id":98611,"goal":"tabulateIndex : (f : Fin n -> a) -> (i : Fin n) -> index i (tabulate f) = f i","context":["Fin"]} +{"prover":"Idris2","tactic_proof":"","source":"idris2_synthetic/type_level","theorem":"generateLength","id":98612,"goal":"generateLength : (n : Nat) -> (f : Fin n -> a) -> length (toList (tabulate f)) = n","context":["Nat","Fin"]} +{"prover":"Idris2","tactic_proof":"concatMapLength f [] = Refl\nconcatMapLength f (x :: xs) = rewrite concatMapLength f xs in vectAppendLength (f x) (concat (map f xs))","source":"idris2_synthetic/type_level","theorem":"concatMapLength","id":98613,"goal":"concatMapLength : (f : a -> Vect m b) -> (xs : Vect n a) -> length (concat (map f xs)) = n * m","context":["Vect"]} +{"prover":"Idris2","tactic_proof":"intersperse sep [] = []\nintersperse sep [x] = [x]\nintersperse sep (x :: y :: ys) = x :: sep :: intersperse sep (y :: ys)","source":"idris2_synthetic/type_level","theorem":"intersperse","id":98614,"goal":"intersperse : a -> Vect n a -> Vect (n + pred n) a","context":["Vect"]} +{"prover":"Idris2","tactic_proof":"","source":"idris2_synthetic/type_level","theorem":"chunksOfLength","id":98615,"goal":"chunksOfLength : (k : Nat) -> {auto ok : NonZero k} -> (xs : Vect n a) -> length (chunksOf k xs) = divCeilNZ n k ok","context":["Nat","Vect"]} +{"prover":"Idris2","tactic_proof":"andCommutative True True = Refl\nandCommutative True False = Refl\nandCommutative False True = Refl\nandCommutative False False = Refl","source":"idris2_synthetic/bool","theorem":"andCommutative","id":98616,"goal":"andCommutative : (a, b : Bool) -> a && b = b && a","context":["Bool"]} +{"prover":"Idris2","tactic_proof":"orCommutative True True = Refl\norCommutative True False = Refl\norCommutative False True = Refl\norCommutative False False = Refl","source":"idris2_synthetic/bool","theorem":"orCommutative","id":98617,"goal":"orCommutative : (a, b : Bool) -> a || b = b || a","context":["Bool"]} +{"prover":"Idris2","tactic_proof":"andAssociative True b c = Refl\nandAssociative False b c = Refl","source":"idris2_synthetic/bool","theorem":"andAssociative","id":98618,"goal":"andAssociative : (a, b, c : Bool) -> (a && b) && c = a && (b && c)","context":["Bool"]} +{"prover":"Idris2","tactic_proof":"orAssociative True b c = Refl\norAssociative False b c = Refl","source":"idris2_synthetic/bool","theorem":"orAssociative","id":98619,"goal":"orAssociative : (a, b, c : Bool) -> (a || b) || c = a || (b || c)","context":["Bool"]} +{"prover":"Idris2","tactic_proof":"andTrueNeutral True = Refl\nandTrueNeutral False = Refl","source":"idris2_synthetic/bool","theorem":"andTrueNeutral","id":98620,"goal":"andTrueNeutral : (a : Bool) -> a && True = a","context":["Bool"]} +{"prover":"Idris2","tactic_proof":"orFalseNeutral True = Refl\norFalseNeutral False = Refl","source":"idris2_synthetic/bool","theorem":"orFalseNeutral","id":98621,"goal":"orFalseNeutral : (a : Bool) -> a || False = a","context":["Bool"]} +{"prover":"Idris2","tactic_proof":"notInvolutive True = Refl\nnotInvolutive False = Refl","source":"idris2_synthetic/bool","theorem":"notInvolutive","id":98622,"goal":"notInvolutive : (a : Bool) -> not (not a) = a","context":["Bool"]} +{"prover":"Idris2","tactic_proof":"deMorganAnd True True = Refl\ndeMorganAnd True False = Refl\ndeMorganAnd False True = Refl\ndeMorganAnd False False = Refl","source":"idris2_synthetic/bool","theorem":"deMorganAnd","id":98623,"goal":"deMorganAnd : (a, b : Bool) -> not (a && b) = not a || not b","context":["Bool"]} +{"prover":"Idris2","tactic_proof":"pairEta (x, y) = Refl","source":"idris2_synthetic/pairs","theorem":"pairEta","id":98624,"goal":"pairEta : (p : (a, b)) -> p = (fst p, snd p)","context":[]} +{"prover":"Idris2","tactic_proof":"mapFstId (x, y) = Refl","source":"idris2_synthetic/pairs","theorem":"mapFstId","id":98625,"goal":"mapFstId : (p : (a, b)) -> mapFst id p = p","context":[]} +{"prover":"Idris2","tactic_proof":"mapSndId (x, y) = Refl","source":"idris2_synthetic/pairs","theorem":"mapSndId","id":98626,"goal":"mapSndId : (p : (a, b)) -> mapSnd id p = p","context":[]} +{"prover":"Idris2","tactic_proof":"bimap_id (x, y) = Refl","source":"idris2_synthetic/pairs","theorem":"bimap_id","id":98627,"goal":"bimap_id : (p : (a, b)) -> bimap id id p = p","context":[]} +{"prover":"Idris2","tactic_proof":"swapSwap (x, y) = Refl","source":"idris2_synthetic/pairs","theorem":"swapSwap","id":98628,"goal":"swapSwap : (p : (a, b)) -> swap (swap p) = p","context":[]} +{"prover":"Idris2","tactic_proof":"mapFstCompose f g (x, y) = Refl","source":"idris2_synthetic/pairs","theorem":"mapFstCompose","id":98629,"goal":"mapFstCompose : (f : b -> c) -> (g : a -> b) -> (p : (a, d)) -> mapFst f (mapFst g p) = mapFst (f . g) p","context":[]} +{"prover":"Idris2","tactic_proof":"","source":"idris2_synthetic/snoclist","theorem":"snocListAppend","id":98630,"goal":"snocListAppend : (xs : SnocList a) -> (ys : SnocList a) -> length (xs ++ ys) = length xs + length ys","context":[]} +{"prover":"Idris2","tactic_proof":"","source":"idris2_synthetic/snoclist","theorem":"snocListReverse","id":98631,"goal":"snocListReverse : (xs : SnocList a) -> cast (reverse (reverse xs)) = xs","context":[]} +{"prover":"Idris2","tactic_proof":"","source":"idris2_synthetic/snoclist","theorem":"snocListMap","id":98632,"goal":"snocListMap : (f : a -> b) -> (xs : SnocList a) -> length (map f xs) = length xs","context":[]} +{"prover":"Idris2","tactic_proof":"","source":"idris2_synthetic/snoclist","theorem":"snocNil","id":98633,"goal":"snocNil : (xs : SnocList a) -> xs ++ [<] = xs","context":[]} +{"prover":"Idris2","tactic_proof":"","source":"idris2_synthetic/snoclist","theorem":"snocCast","id":98634,"goal":"snocCast : (xs : List a) -> cast (cast xs : SnocList a) = xs","context":["List"]} +{"prover":"Idris2","tactic_proof":"autoRefl {prf} = prf","source":"idris2_synthetic/proof_search","theorem":"autoRefl","id":98635,"goal":"autoRefl : {auto prf : x = x} -> x = x","context":[]} +{"prover":"Idris2","tactic_proof":"autoLTE {prf} = prf","source":"idris2_synthetic/proof_search","theorem":"autoLTE","id":98636,"goal":"autoLTE : {auto prf : LTE n m} -> LTE n m","context":["LTE"]} +{"prover":"Idris2","tactic_proof":"decideEq x y = case decEq x y of { Yes prf => Left prf; No contra => Right contra }","source":"idris2_synthetic/proof_search","theorem":"decideEq","id":98637,"goal":"decideEq : DecEq a => (x, y : a) -> Either (x = y) (Not (x = y))","context":[]} +{"prover":"Idris2","tactic_proof":"searchNat = (15 ** (LTESucc (LTESucc (LTESucc (LTESucc (LTESucc (LTESucc (LTESucc (LTESucc (LTESucc (LTESucc LTEZero))))))))), LTESucc (LTESucc (LTESucc (LTESucc (LTESucc LTEZero))))))","source":"idris2_synthetic/proof_search","theorem":"searchNat","id":98638,"goal":"searchNat : (n : Nat ** LTE 10 n, LTE n 20)","context":["Nat","LTE"]} +{"prover":"Idris2","tactic_proof":"autoShow x = show x","source":"idris2_synthetic/proof_search","theorem":"autoShow","id":98639,"goal":"autoShow : Show a => a -> String","context":[]} +{"prover":"Idris2","tactic_proof":"filterView p [] = []\nfilterView p (x :: xs) with (p x)\n _ | True = x :: filterView p xs\n _ | False = filterView p xs","source":"idris2_synthetic/with_views","theorem":"filterView","id":98640,"goal":"filterView : (p : a -> Bool) -> (xs : List a) -> List a","context":["Bool","List"]} +{"prover":"Idris2","tactic_proof":"lookupView key [] = Nothing\nlookupView key ((k, v) :: xs) with (decEq key k)\n _ | Yes _ = Just v\n _ | No _ = lookupView key xs","source":"idris2_synthetic/with_views","theorem":"lookupView","id":98641,"goal":"lookupView : DecEq k => k -> List (k, v) -> Maybe v","context":["List","Maybe"]} +{"prover":"Idris2","tactic_proof":"insertSorted x [] = [x]\ninsertSorted x (y :: ys) with (compare x y)\n _ | LT = x :: y :: ys\n _ | EQ = x :: y :: ys\n _ | GT = y :: insertSorted x ys","source":"idris2_synthetic/with_views","theorem":"insertSorted","id":98642,"goal":"insertSorted : Ord a => a -> List a -> List a","context":["List"]} +{"prover":"Idris2","tactic_proof":"splitAt Z xs = ([], xs)\nsplitAt (S k) (x :: xs) = let (ys, zs) = splitAt k xs in (x :: ys, zs)","source":"idris2_synthetic/with_views","theorem":"splitAt","id":98643,"goal":"splitAt : (n : Nat) -> (xs : Vect (n + m) a) -> (Vect n a, Vect m a)","context":["Nat","Vect"]} +{"prover":"Idris2","tactic_proof":"mergeView [] ys = ys\nmergeView xs [] = xs\nmergeView (x :: xs) (y :: ys) with (compare x y)\n _ | LT = x :: mergeView xs (y :: ys)\n _ | _ = y :: mergeView (x :: xs) ys","source":"idris2_synthetic/with_views","theorem":"mergeView","id":98644,"goal":"mergeView : Ord a => List a -> List a -> List a","context":["List"]} +{"prover":"Idris2","tactic_proof":"","source":"idris2_synthetic/with_views","theorem":"groupByView","id":98645,"goal":"groupByView : (a -> a -> Bool) -> List a -> List (List a)","context":["Bool","List"]} +{"prover":"Idris2","tactic_proof":"congSucc Refl = Refl","source":"idris2_synthetic/cong_rewrite","theorem":"congSucc","id":98646,"goal":"congSucc : n = m -> S n = S m","context":[]} +{"prover":"Idris2","tactic_proof":"congPlus Refl Refl = Refl","source":"idris2_synthetic/cong_rewrite","theorem":"congPlus","id":98647,"goal":"congPlus : a = b -> c = d -> a + c = b + d","context":[]} +{"prover":"Idris2","tactic_proof":"congMap f Refl = Refl","source":"idris2_synthetic/cong_rewrite","theorem":"congMap","id":98648,"goal":"congMap : (f : a -> b) -> x = y -> f x = f y","context":[]} +{"prover":"Idris2","tactic_proof":"transEq Refl Refl = Refl","source":"idris2_synthetic/cong_rewrite","theorem":"transEq","id":98649,"goal":"transEq : a = b -> b = c -> a = c","context":[]} +{"prover":"Idris2","tactic_proof":"symEq Refl = Refl","source":"idris2_synthetic/cong_rewrite","theorem":"symEq","id":98650,"goal":"symEq : a = b -> b = a","context":[]} +{"prover":"Idris2","tactic_proof":"replaceEq p Refl px = px","source":"idris2_synthetic/cong_rewrite","theorem":"replaceEq","id":98651,"goal":"replaceEq : (0 p : a -> Type) -> x = y -> p x -> p y","context":[]} +{"prover":"Idris2","tactic_proof":"voidAbsurd2 v = absurd v","source":"idris2_synthetic/cong_rewrite","theorem":"voidAbsurd2","id":98652,"goal":"voidAbsurd2 : Void -> a","context":["Void"]} diff --git a/training_data/proof_states_imandra.jsonl b/training_data/proof_states_imandra.jsonl index 404a809..1366b26 100644 --- a/training_data/proof_states_imandra.jsonl +++ b/training_data/proof_states_imandra.jsonl @@ -1,133 +1,133 @@ -{"id":89500,"prover":"Imandra","theorem":"add_comm","goal":"theorem add_comm x y = x + y = y + x","context":["auto"],"tactic_proof":"[@@auto]","source":"imandra_synthetic/arithmetic"} -{"id":89501,"prover":"Imandra","theorem":"add_assoc","goal":"theorem add_assoc x y z = (x + y) + z = x + (y + z)","context":["auto"],"tactic_proof":"[@@auto]","source":"imandra_synthetic/arithmetic"} -{"id":89502,"prover":"Imandra","theorem":"mul_comm","goal":"theorem mul_comm x y = x * y = y * x","context":["auto"],"tactic_proof":"[@@auto]","source":"imandra_synthetic/arithmetic"} -{"id":89503,"prover":"Imandra","theorem":"mul_assoc","goal":"theorem mul_assoc x y z = (x * y) * z = x * (y * z)","context":["auto"],"tactic_proof":"[@@auto]","source":"imandra_synthetic/arithmetic"} -{"id":89504,"prover":"Imandra","theorem":"distrib","goal":"theorem distrib x y z = x * (y + z) = x * y + x * z","context":["auto"],"tactic_proof":"[@@auto]","source":"imandra_synthetic/arithmetic"} -{"id":89505,"prover":"Imandra","theorem":"add_zero","goal":"theorem add_zero x = x + 0 = x","context":["auto"],"tactic_proof":"[@@auto]","source":"imandra_synthetic/arithmetic"} -{"id":89506,"prover":"Imandra","theorem":"mul_one","goal":"theorem mul_one x = x * 1 = x","context":["auto"],"tactic_proof":"[@@auto]","source":"imandra_synthetic/arithmetic"} -{"id":89507,"prover":"Imandra","theorem":"mul_zero","goal":"theorem mul_zero x = x * 0 = 0","context":["auto"],"tactic_proof":"[@@auto]","source":"imandra_synthetic/arithmetic"} -{"id":89508,"prover":"Imandra","theorem":"abs_nonneg","goal":"theorem abs_nonneg x = abs x >= 0","context":["auto"],"tactic_proof":"[@@auto]","source":"imandra_synthetic/arithmetic"} -{"id":89509,"prover":"Imandra","theorem":"abs_triangle","goal":"theorem abs_triangle x y = abs (x + y) <= abs x + abs y","context":["auto"],"tactic_proof":"[@@auto]","source":"imandra_synthetic/arithmetic"} -{"id":89510,"prover":"Imandra","theorem":"max_comm","goal":"theorem max_comm x y = max x y = max y x","context":["auto"],"tactic_proof":"[@@auto]","source":"imandra_synthetic/arithmetic"} -{"id":89511,"prover":"Imandra","theorem":"min_comm","goal":"theorem min_comm x y = min x y = min y x","context":["auto"],"tactic_proof":"[@@auto]","source":"imandra_synthetic/arithmetic"} -{"id":89512,"prover":"Imandra","theorem":"max_assoc","goal":"theorem max_assoc x y z = max x (max y z) = max (max x y) z","context":["auto"],"tactic_proof":"[@@auto]","source":"imandra_synthetic/arithmetic"} -{"id":89513,"prover":"Imandra","theorem":"min_max_absorb","goal":"theorem min_max_absorb x y = min x (max x y) = x","context":["auto"],"tactic_proof":"[@@auto]","source":"imandra_synthetic/arithmetic"} -{"id":89514,"prover":"Imandra","theorem":"div_mod_id","goal":"theorem div_mod_id a b = b > 0 ==> a = b * (a / b) + (a mod b)","context":["auto"],"tactic_proof":"[@@auto]","source":"imandra_synthetic/arithmetic"} -{"id":89515,"prover":"Imandra","theorem":"append_nil","goal":"theorem append_nil l = l @ [] = l","context":["auto"],"tactic_proof":"[@@induct l]","source":"imandra_synthetic/lists"} -{"id":89516,"prover":"Imandra","theorem":"append_assoc","goal":"theorem append_assoc l1 l2 l3 = (l1 @ l2) @ l3 = l1 @ (l2 @ l3)","context":["auto"],"tactic_proof":"[@@induct l1]","source":"imandra_synthetic/lists"} -{"id":89517,"prover":"Imandra","theorem":"length_append","goal":"theorem length_append l1 l2 = List.length (l1 @ l2) = List.length l1 + List.length l2","context":["auto"],"tactic_proof":"[@@induct l1]","source":"imandra_synthetic/lists"} -{"id":89518,"prover":"Imandra","theorem":"rev_rev","goal":"theorem rev_rev l = List.rev (List.rev l) = l","context":["auto"],"tactic_proof":"[@@induct l] [@@auto]","source":"imandra_synthetic/lists"} -{"id":89519,"prover":"Imandra","theorem":"map_id","goal":"theorem map_id l = List.map (fun x -> x) l = l","context":["auto"],"tactic_proof":"[@@induct l]","source":"imandra_synthetic/lists"} -{"id":89520,"prover":"Imandra","theorem":"map_compose","goal":"theorem map_compose f g l = List.map f (List.map g l) = List.map (fun x -> f (g x)) l","context":["auto"],"tactic_proof":"[@@induct l]","source":"imandra_synthetic/lists"} -{"id":89521,"prover":"Imandra","theorem":"length_map","goal":"theorem length_map f l = List.length (List.map f l) = List.length l","context":["auto"],"tactic_proof":"[@@induct l]","source":"imandra_synthetic/lists"} -{"id":89522,"prover":"Imandra","theorem":"length_rev","goal":"theorem length_rev l = List.length (List.rev l) = List.length l","context":["auto"],"tactic_proof":"[@@induct l] [@@auto]","source":"imandra_synthetic/lists"} -{"id":89523,"prover":"Imandra","theorem":"mem_append","goal":"theorem mem_append x l1 l2 = List.mem x (l1 @ l2) = (List.mem x l1 || List.mem x l2)","context":["auto"],"tactic_proof":"[@@induct l1]","source":"imandra_synthetic/lists"} -{"id":89524,"prover":"Imandra","theorem":"filter_append","goal":"theorem filter_append p l1 l2 = List.filter p (l1 @ l2) = List.filter p l1 @ List.filter p l2","context":["auto"],"tactic_proof":"[@@induct l1]","source":"imandra_synthetic/lists"} -{"id":89525,"prover":"Imandra","theorem":"flat_map_assoc","goal":"theorem flat_map_assoc f g l = List.concat_map g (List.concat_map f l) = List.concat_map (fun x -> List.concat_map g (f x)) l","context":["auto"],"tactic_proof":"[@@induct l]","source":"imandra_synthetic/lists"} -{"id":89526,"prover":"Imandra","theorem":"nth_map","goal":"theorem nth_map f l i = i < List.length l ==> List.nth (List.map f l) i = f (List.nth l i)","context":["auto"],"tactic_proof":"[@@induct l] [@@auto]","source":"imandra_synthetic/lists"} -{"id":89527,"prover":"Imandra","theorem":"for_all_append","goal":"theorem for_all_append p l1 l2 = List.for_all p (l1 @ l2) = (List.for_all p l1 && List.for_all p l2)","context":["auto"],"tactic_proof":"[@@induct l1]","source":"imandra_synthetic/lists"} -{"id":89528,"prover":"Imandra","theorem":"sorted_insert","goal":"theorem sorted_insert x l = sorted l ==> sorted (insert x l)","context":["auto"],"tactic_proof":"[@@induct l] [@@auto]","source":"imandra_synthetic/verification"} -{"id":89529,"prover":"Imandra","theorem":"sorted_sort","goal":"theorem sorted_sort l = sorted (sort l)","context":["auto"],"tactic_proof":"[@@induct l] [@@auto]","source":"imandra_synthetic/verification"} -{"id":89530,"prover":"Imandra","theorem":"perm_sort","goal":"theorem perm_sort l = is_perm l (sort l)","context":["auto"],"tactic_proof":"[@@induct l] [@@auto]","source":"imandra_synthetic/verification"} -{"id":89531,"prover":"Imandra","theorem":"bsearch_correct","goal":"theorem bsearch_correct a v = sorted a ==> (match bsearch a v with Some i -> a.(i) = v | None -> not (Array.exists (fun x -> x = v) a))","context":["auto"],"tactic_proof":"[@@auto]","source":"imandra_synthetic/verification"} -{"id":89532,"prover":"Imandra","theorem":"stack_push_pop","goal":"theorem stack_push_pop x s = pop (push x s) = (x, s)","context":["auto"],"tactic_proof":"[@@auto]","source":"imandra_synthetic/verification"} -{"id":89533,"prover":"Imandra","theorem":"queue_fifo","goal":"theorem queue_fifo x q = not (is_empty q) ==> fst (dequeue (enqueue x q)) = front q","context":["auto"],"tactic_proof":"[@@auto]","source":"imandra_synthetic/verification"} -{"id":89534,"prover":"Imandra","theorem":"rbt_invariant","goal":"theorem rbt_invariant x t = is_rbt t ==> is_rbt (rbt_insert x t)","context":["auto"],"tactic_proof":"[@@induct t] [@@auto]","source":"imandra_synthetic/verification"} -{"id":89535,"prover":"Imandra","theorem":"bst_invariant","goal":"theorem bst_invariant x t = is_bst t ==> is_bst (bst_insert x t)","context":["auto"],"tactic_proof":"[@@induct t] [@@auto]","source":"imandra_synthetic/verification"} -{"id":89536,"prover":"Imandra","theorem":"heap_insert_min","goal":"theorem heap_insert_min x h = is_heap h ==> find_min (heap_insert x h) <= x","context":["auto"],"tactic_proof":"[@@induct h] [@@auto]","source":"imandra_synthetic/verification"} -{"id":89537,"prover":"Imandra","theorem":"margin_nonneg","goal":"theorem margin_nonneg acct = valid_account acct ==> margin_requirement acct >= 0.0","context":["auto"],"tactic_proof":"[@@auto]","source":"imandra_synthetic/finance"} -{"id":89538,"prover":"Imandra","theorem":"order_fill_balance","goal":"theorem order_fill_balance order book = valid_order order ==> balance_after (fill order book) >= 0.0","context":["auto"],"tactic_proof":"[@@auto]","source":"imandra_synthetic/finance"} -{"id":89539,"prover":"Imandra","theorem":"matching_symmetric","goal":"theorem matching_symmetric buy sell = can_match buy sell ==> can_match sell buy","context":["auto"],"tactic_proof":"[@@auto]","source":"imandra_synthetic/finance"} -{"id":89540,"prover":"Imandra","theorem":"settlement_complete","goal":"theorem settlement_complete trades = all_valid trades ==> is_settled (settle trades)","context":["auto"],"tactic_proof":"[@@auto]","source":"imandra_synthetic/finance"} -{"id":89541,"prover":"Imandra","theorem":"risk_monotone","goal":"theorem risk_monotone p1 p2 = portfolio_subset p1 p2 ==> risk p1 <= risk p2","context":["auto"],"tactic_proof":"[@@auto]","source":"imandra_synthetic/finance"} -{"id":89542,"prover":"Imandra","theorem":"cx_list_rev_sorted","goal":"verify (fun l -> sorted l ==> sorted (List.rev l))","context":["auto"],"tactic_proof":"CX: l = [1; 3; 2] -- List.rev [1;3;2] = [2;3;1] which is not sorted","source":"imandra_synthetic/counterexamples"} -{"id":89543,"prover":"Imandra","theorem":"cx_append_comm","goal":"verify (fun l1 l2 -> l1 @ l2 = l2 @ l1)","context":["auto"],"tactic_proof":"CX: l1 = [1], l2 = [2] -- [1;2] <> [2;1]","source":"imandra_synthetic/counterexamples"} -{"id":89544,"prover":"Imandra","theorem":"cx_map_injective","goal":"verify (fun f l1 l2 -> List.map f l1 = List.map f l2 ==> l1 = l2)","context":["auto"],"tactic_proof":"CX: f = (fun _ -> 0), l1 = [1], l2 = [2]","source":"imandra_synthetic/counterexamples"} -{"id":89545,"prover":"Imandra","theorem":"cx_sort_idempotent","goal":"verify (fun l -> sort (sort l) = sort l)","context":["auto"],"tactic_proof":"Verified: true (sort is idempotent)","source":"imandra_synthetic/counterexamples"} -{"id":89546,"prover":"Imandra","theorem":"cx_filter_length","goal":"verify (fun p l -> List.length (List.filter p l) <= List.length l)","context":["auto"],"tactic_proof":"Verified: true","source":"imandra_synthetic/counterexamples"} -{"id":89547,"prover":"Imandra","theorem":"cx_subset_reflexive","goal":"verify (fun s -> subset s s)","context":["auto"],"tactic_proof":"Verified: true","source":"imandra_synthetic/counterexamples"} -{"id":89548,"prover":"Imandra","theorem":"cx_division_positive","goal":"verify (fun x y -> x > 0 && y > 0 ==> x / y >= 0)","context":["auto"],"tactic_proof":"Verified: true","source":"imandra_synthetic/counterexamples"} -{"id":89549,"prover":"Imandra","theorem":"cx_int_overflow","goal":"verify (fun (x:int) -> x + 1 > x)","context":["auto"],"tactic_proof":"CX: x = max_int -- overflow wraps to min_int","source":"imandra_synthetic/counterexamples"} -{"id":89550,"prover":"Imandra","theorem":"cx_float_assoc","goal":"verify (fun (a:float) b c -> (a +. b) +. c = a +. (b +. c))","context":["auto"],"tactic_proof":"CX: a=1e30, b= -1e30, c=1.0 -- floating point not associative","source":"imandra_synthetic/counterexamples"} -{"id":89551,"prover":"Imandra","theorem":"bst_insert_preserves","goal":"theorem bst_insert_preserves x t = is_bst t ==> is_bst (bst_insert x t)","context":["auto"],"tactic_proof":"[@@induct t] [@@auto]","source":"imandra_synthetic/trees_imandra"} -{"id":89552,"prover":"Imandra","theorem":"bst_member_after_insert","goal":"theorem bst_member_after_insert x t = bst_member x (bst_insert x t)","context":["auto"],"tactic_proof":"[@@induct t] [@@auto]","source":"imandra_synthetic/trees_imandra"} -{"id":89553,"prover":"Imandra","theorem":"tree_mirror_involutive","goal":"theorem tree_mirror_involutive t = mirror (mirror t) = t","context":["auto"],"tactic_proof":"[@@induct t]","source":"imandra_synthetic/trees_imandra"} -{"id":89554,"prover":"Imandra","theorem":"tree_size_positive","goal":"theorem tree_size_positive t = tree_size t >= 0","context":["auto"],"tactic_proof":"[@@induct t]","source":"imandra_synthetic/trees_imandra"} -{"id":89555,"prover":"Imandra","theorem":"tree_flatten_length","goal":"theorem tree_flatten_length t = List.length (flatten t) = tree_size t","context":["auto"],"tactic_proof":"[@@induct t]","source":"imandra_synthetic/trees_imandra"} -{"id":89556,"prover":"Imandra","theorem":"heap_extract_min_sorted","goal":"theorem heap_extract_min_sorted h = is_heap h ==> sorted (heapsort h)","context":["auto"],"tactic_proof":"[@@induct h] [@@auto]","source":"imandra_synthetic/trees_imandra"} -{"id":89557,"prover":"Imandra","theorem":"avl_balanced","goal":"theorem avl_balanced t = is_avl t ==> abs (height (left t) - height (right t)) <= 1","context":["auto"],"tactic_proof":"[@@induct t] [@@auto]","source":"imandra_synthetic/trees_imandra"} -{"id":89558,"prover":"Imandra","theorem":"rbt_black_height","goal":"theorem rbt_black_height t = is_rbt t ==> black_height (left t) = black_height (right t)","context":["auto"],"tactic_proof":"[@@induct t] [@@auto]","source":"imandra_synthetic/trees_imandra"} -{"id":89559,"prover":"Imandra","theorem":"abs_diff_symmetric","goal":"theorem abs_diff_symmetric x y = abs (x - y) = abs (y - x)","context":["auto"],"tactic_proof":"[@@auto]","source":"imandra_synthetic/numerics"} -{"id":89560,"prover":"Imandra","theorem":"sqr_nonneg","goal":"theorem sqr_nonneg x = x * x >= 0","context":["auto"],"tactic_proof":"[@@auto]","source":"imandra_synthetic/numerics"} -{"id":89561,"prover":"Imandra","theorem":"ge_trans","goal":"theorem ge_trans x y z = x >= y ==> y >= z ==> x >= z","context":["auto"],"tactic_proof":"[@@auto]","source":"imandra_synthetic/numerics"} -{"id":89562,"prover":"Imandra","theorem":"eq_refl_trans","goal":"theorem eq_refl_trans x y = x = y ==> y = x","context":["auto"],"tactic_proof":"[@@auto]","source":"imandra_synthetic/numerics"} -{"id":89563,"prover":"Imandra","theorem":"neg_neg","goal":"theorem neg_neg x = -(-x) = x","context":["auto"],"tactic_proof":"[@@auto]","source":"imandra_synthetic/numerics"} -{"id":89564,"prover":"Imandra","theorem":"sub_self_zero","goal":"theorem sub_self_zero x = x - x = 0","context":["auto"],"tactic_proof":"[@@auto]","source":"imandra_synthetic/numerics"} -{"id":89565,"prover":"Imandra","theorem":"mul_distrib_sub","goal":"theorem mul_distrib_sub x y z = x * (y - z) = x*y - x*z","context":["auto"],"tactic_proof":"[@@auto]","source":"imandra_synthetic/numerics"} -{"id":89566,"prover":"Imandra","theorem":"pow_zero","goal":"theorem pow_zero x = x > 0 ==> x ** 0 = 1","context":["auto"],"tactic_proof":"[@@auto]","source":"imandra_synthetic/numerics"} -{"id":89567,"prover":"Imandra","theorem":"pow_succ","goal":"theorem pow_succ x n = n >= 0 ==> x ** (n+1) = x * (x ** n)","context":["auto"],"tactic_proof":"[@@induct n] [@@auto]","source":"imandra_synthetic/numerics"} -{"id":89568,"prover":"Imandra","theorem":"gcd_self","goal":"theorem gcd_self n = n >= 0 ==> gcd n n = n","context":["auto"],"tactic_proof":"[@@auto]","source":"imandra_synthetic/numerics"} -{"id":89569,"prover":"Imandra","theorem":"gcd_zero","goal":"theorem gcd_zero n = n >= 0 ==> gcd n 0 = n","context":["auto"],"tactic_proof":"[@@auto]","source":"imandra_synthetic/numerics"} -{"id":89570,"prover":"Imandra","theorem":"divides_refl","goal":"theorem divides_refl n = n <> 0 ==> divides n n","context":["auto"],"tactic_proof":"[@@auto]","source":"imandra_synthetic/numerics"} -{"id":89571,"prover":"Imandra","theorem":"record_set_get","goal":"theorem record_set_get r v = (set_field r v).field = v","context":["auto"],"tactic_proof":"[@@auto]","source":"imandra_synthetic/records"} -{"id":89572,"prover":"Imandra","theorem":"record_get_set_idempotent","goal":"theorem record_get_set_idempotent r = set_field r (r.field) = r","context":["auto"],"tactic_proof":"[@@auto]","source":"imandra_synthetic/records"} -{"id":89573,"prover":"Imandra","theorem":"record_set_comm","goal":"theorem record_set_comm r v1 v2 = set_f2 (set_f1 r v1) v2 = set_f1 (set_f2 r v2) v1","context":["auto"],"tactic_proof":"[@@auto]","source":"imandra_synthetic/records"} -{"id":89574,"prover":"Imandra","theorem":"record_eq_fields","goal":"theorem record_eq_fields r1 r2 = r1.a = r2.a ==> r1.b = r2.b ==> r1 = r2","context":["auto"],"tactic_proof":"[@@auto]","source":"imandra_synthetic/records"} -{"id":89575,"prover":"Imandra","theorem":"option_some_inj","goal":"theorem option_some_inj x y = Some x = Some y ==> x = y","context":["auto"],"tactic_proof":"[@@auto]","source":"imandra_synthetic/records"} -{"id":89576,"prover":"Imandra","theorem":"option_none_not_some","goal":"theorem option_none_not_some x = None <> Some x","context":["auto"],"tactic_proof":"[@@auto]","source":"imandra_synthetic/records"} -{"id":89577,"prover":"Imandra","theorem":"tuple_fst_snd","goal":"theorem tuple_fst_snd p = (fst p, snd p) = p","context":["auto"],"tactic_proof":"[@@auto]","source":"imandra_synthetic/records"} -{"id":89578,"prover":"Imandra","theorem":"fsm_deterministic","goal":"theorem fsm_deterministic s e = forall s1 s2. transition s e s1 ==> transition s e s2 ==> s1 = s2","context":["auto"],"tactic_proof":"[@@auto]","source":"imandra_synthetic/state_machines"} -{"id":89579,"prover":"Imandra","theorem":"fsm_reachable_trans","goal":"theorem fsm_reachable_trans s1 s2 s3 = reachable s1 s2 ==> reachable s2 s3 ==> reachable s1 s3","context":["induct","auto"],"tactic_proof":"[@@induct] [@@auto]","source":"imandra_synthetic/state_machines"} -{"id":89580,"prover":"Imandra","theorem":"fsm_initial_reachable","goal":"theorem fsm_initial_reachable s = s = initial_state ==> reachable s s","context":["auto"],"tactic_proof":"[@@auto]","source":"imandra_synthetic/state_machines"} -{"id":89581,"prover":"Imandra","theorem":"fsm_no_deadlock","goal":"theorem fsm_no_deadlock s = reachable initial_state s ==> exists e s'. transition s e s'","context":["auto"],"tactic_proof":"[@@auto]","source":"imandra_synthetic/state_machines"} -{"id":89582,"prover":"Imandra","theorem":"fsm_invariant_preserve","goal":"theorem fsm_invariant_preserve s e s' = inv s ==> transition s e s' ==> inv s'","context":["auto"],"tactic_proof":"[@@auto]","source":"imandra_synthetic/state_machines"} -{"id":89583,"prover":"Imandra","theorem":"safety_property","goal":"theorem safety_property s = reachable initial_state s ==> not (is_error s)","context":["induct","auto"],"tactic_proof":"[@@induct] [@@auto]","source":"imandra_synthetic/state_machines"} -{"id":89584,"prover":"Imandra","theorem":"liveness_property","goal":"theorem liveness_property s = reachable initial_state s ==> eventually goal_state s","context":["auto"],"tactic_proof":"[@@auto]","source":"imandra_synthetic/state_machines"} -{"id":89585,"prover":"Imandra","theorem":"hash_deterministic","goal":"theorem hash_deterministic m1 m2 = m1 = m2 ==> hash m1 = hash m2","context":["auto"],"tactic_proof":"[@@auto]","source":"imandra_synthetic/crypto"} -{"id":89586,"prover":"Imandra","theorem":"signature_verify","goal":"theorem signature_verify sk pk m = keypair sk pk ==> verify pk m (sign sk m) = true","context":["auto"],"tactic_proof":"[@@auto]","source":"imandra_synthetic/crypto"} -{"id":89587,"prover":"Imandra","theorem":"encrypt_decrypt","goal":"theorem encrypt_decrypt k m = decrypt k (encrypt k m) = m","context":["auto"],"tactic_proof":"[@@auto]","source":"imandra_synthetic/crypto"} -{"id":89588,"prover":"Imandra","theorem":"merkle_root_unique","goal":"theorem merkle_root_unique l1 l2 = merkle_root l1 = merkle_root l2 ==> l1 = l2","context":["auto"],"tactic_proof":"[@@auto]","source":"imandra_synthetic/crypto"} -{"id":89589,"prover":"Imandra","theorem":"xor_involutive","goal":"theorem xor_involutive x y = xor (xor x y) y = x","context":["auto"],"tactic_proof":"[@@auto]","source":"imandra_synthetic/crypto"} -{"id":89590,"prover":"Imandra","theorem":"nonce_unique","goal":"theorem nonce_unique n1 n2 = generate_nonce n1 = generate_nonce n2 ==> n1 = n2","context":["auto"],"tactic_proof":"[@@auto]","source":"imandra_synthetic/crypto"} -{"id":89591,"prover":"Imandra","theorem":"block_prev_chain","goal":"theorem block_prev_chain b = valid_chain b ==> prev_hash (head b) = hash (tail b)","context":["auto"],"tactic_proof":"[@@induct b] [@@auto]","source":"imandra_synthetic/blockchain"} -{"id":89592,"prover":"Imandra","theorem":"tx_balance_conservation","goal":"theorem tx_balance_conservation tx = valid_tx tx ==> sum_inputs tx = sum_outputs tx + fee tx","context":["auto"],"tactic_proof":"[@@auto]","source":"imandra_synthetic/blockchain"} -{"id":89593,"prover":"Imandra","theorem":"utxo_no_double_spend","goal":"theorem utxo_no_double_spend tx1 tx2 utxo = valid_tx tx1 ==> valid_tx tx2 ==> disjoint (inputs tx1) (inputs tx2)","context":["auto"],"tactic_proof":"[@@auto]","source":"imandra_synthetic/blockchain"} -{"id":89594,"prover":"Imandra","theorem":"consensus_majority","goal":"theorem consensus_majority votes = count_yes votes > length votes / 2 ==> accepted votes","context":["auto"],"tactic_proof":"[@@auto]","source":"imandra_synthetic/blockchain"} -{"id":89595,"prover":"Imandra","theorem":"longest_chain","goal":"theorem longest_chain c1 c2 = valid_chain c1 ==> valid_chain c2 ==> height c1 >= height c2 ==> canonical c1","context":["auto"],"tactic_proof":"[@@auto]","source":"imandra_synthetic/blockchain"} -{"id":89596,"prover":"Imandra","theorem":"group_identity_unique","goal":"theorem group_identity_unique e1 e2 = is_identity e1 ==> is_identity e2 ==> e1 = e2","context":["auto"],"tactic_proof":"[@@auto]","source":"imandra_synthetic/algebra"} -{"id":89597,"prover":"Imandra","theorem":"group_inverse_unique","goal":"theorem group_inverse_unique a b c = op a b = identity ==> op a c = identity ==> b = c","context":["auto"],"tactic_proof":"[@@auto]","source":"imandra_synthetic/algebra"} -{"id":89598,"prover":"Imandra","theorem":"monoid_left_id","goal":"theorem monoid_left_id a = op identity a = a","context":["auto"],"tactic_proof":"[@@auto]","source":"imandra_synthetic/algebra"} -{"id":89599,"prover":"Imandra","theorem":"monoid_right_id","goal":"theorem monoid_right_id a = op a identity = a","context":["auto"],"tactic_proof":"[@@auto]","source":"imandra_synthetic/algebra"} -{"id":89600,"prover":"Imandra","theorem":"ring_distrib","goal":"theorem ring_distrib a b c = mul a (add b c) = add (mul a b) (mul a c)","context":["auto"],"tactic_proof":"[@@auto]","source":"imandra_synthetic/algebra"} -{"id":89601,"prover":"Imandra","theorem":"ring_zero_mul","goal":"theorem ring_zero_mul a = mul zero a = zero","context":["auto"],"tactic_proof":"[@@auto]","source":"imandra_synthetic/algebra"} -{"id":89602,"prover":"Imandra","theorem":"semilat_idempotent","goal":"theorem semilat_idempotent a = meet a a = a","context":["auto"],"tactic_proof":"[@@auto]","source":"imandra_synthetic/algebra"} -{"id":89603,"prover":"Imandra","theorem":"mutex_exclusive","goal":"theorem mutex_exclusive s = acquired s ==> not (available s)","context":["auto"],"tactic_proof":"[@@auto]","source":"imandra_synthetic/concurrency"} -{"id":89604,"prover":"Imandra","theorem":"lock_release","goal":"theorem lock_release s = acquire (release (acquire s)) = acquire s","context":["auto"],"tactic_proof":"[@@auto]","source":"imandra_synthetic/concurrency"} -{"id":89605,"prover":"Imandra","theorem":"queue_ordering","goal":"theorem queue_ordering q msgs = push q msgs ==> fifo_order (drain q)","context":["auto"],"tactic_proof":"[@@induct msgs] [@@auto]","source":"imandra_synthetic/concurrency"} -{"id":89606,"prover":"Imandra","theorem":"actor_isolation","goal":"theorem actor_isolation a b m = send a b m ==> state a = state a","context":["auto"],"tactic_proof":"[@@auto]","source":"imandra_synthetic/concurrency"} -{"id":89607,"prover":"Imandra","theorem":"atomic_read_write","goal":"theorem atomic_read_write x v = read (write x v) = v","context":["auto"],"tactic_proof":"[@@auto]","source":"imandra_synthetic/concurrency"} -{"id":89608,"prover":"Imandra","theorem":"cas_success","goal":"theorem cas_success x old new = read x = old ==> cas x old new = (true, write x new)","context":["auto"],"tactic_proof":"[@@auto]","source":"imandra_synthetic/concurrency"} -{"id":89609,"prover":"Imandra","theorem":"deadlock_free","goal":"theorem deadlock_free tree = acyclic tree ==> not (deadlocked tree)","context":["auto"],"tactic_proof":"[@@induct tree] [@@auto]","source":"imandra_synthetic/concurrency"} -{"id":89610,"prover":"Imandra","theorem":"acid_atomicity","goal":"theorem acid_atomicity tx db = commit tx db = Some db' \\/ commit tx db = None","context":["auto"],"tactic_proof":"[@@auto]","source":"imandra_synthetic/databases"} -{"id":89611,"prover":"Imandra","theorem":"rollback_inverse","goal":"theorem rollback_inverse tx db = rollback tx (apply tx db) = db","context":["auto"],"tactic_proof":"[@@auto]","source":"imandra_synthetic/databases"} -{"id":89612,"prover":"Imandra","theorem":"isolation_serializable","goal":"theorem isolation_serializable t1 t2 db = serializable [t1; t2] db = serializable [t2; t1] db","context":["auto"],"tactic_proof":"[@@auto]","source":"imandra_synthetic/databases"} -{"id":89613,"prover":"Imandra","theorem":"index_consistent","goal":"theorem index_consistent idx tbl = valid_index idx tbl ==> forall k. lookup idx k = table_lookup tbl k","context":["auto"],"tactic_proof":"[@@auto]","source":"imandra_synthetic/databases"} -{"id":89614,"prover":"Imandra","theorem":"foreign_key","goal":"theorem foreign_key p c = valid_db (p, c) ==> forall r in c. exists parent in p. fk_match r parent","context":["auto"],"tactic_proof":"[@@auto]","source":"imandra_synthetic/databases"} -{"id":89615,"prover":"Imandra","theorem":"normalization_bcnf","goal":"theorem normalization_bcnf r = bcnf r ==> third_nf r","context":["auto"],"tactic_proof":"[@@auto]","source":"imandra_synthetic/databases"} -{"id":89616,"prover":"Imandra","theorem":"tcp_in_order","goal":"theorem tcp_in_order conn pkts = established conn ==> tcp_deliver conn pkts = sort_by_seq pkts","context":["auto"],"tactic_proof":"[@@induct pkts] [@@auto]","source":"imandra_synthetic/networking"} -{"id":89617,"prover":"Imandra","theorem":"packet_checksum","goal":"theorem packet_checksum p = valid_packet p ==> verify_checksum p = true","context":["auto"],"tactic_proof":"[@@auto]","source":"imandra_synthetic/networking"} -{"id":89618,"prover":"Imandra","theorem":"routing_loop_free","goal":"theorem routing_loop_free graph = valid_routing graph ==> acyclic (next_hop graph)","context":["auto"],"tactic_proof":"[@@auto]","source":"imandra_synthetic/networking"} -{"id":89619,"prover":"Imandra","theorem":"tls_handshake_secrecy","goal":"theorem tls_handshake_secrecy c s = secure_handshake c s ==> secret_key_safe c s","context":["auto"],"tactic_proof":"[@@auto]","source":"imandra_synthetic/networking"} -{"id":89620,"prover":"Imandra","theorem":"retry_idempotent","goal":"theorem retry_idempotent req = idempotent req ==> retry req = send req","context":["auto"],"tactic_proof":"[@@auto]","source":"imandra_synthetic/networking"} -{"id":89621,"prover":"Imandra","theorem":"auth_token_valid","goal":"theorem auth_token_valid t = verify_token t = Some user ==> user = decode t","context":["auto"],"tactic_proof":"[@@auto]","source":"imandra_synthetic/security"} -{"id":89622,"prover":"Imandra","theorem":"rbac_permission","goal":"theorem rbac_permission u r p = has_role u r && role_has_perm r p ==> authorized u p","context":["auto"],"tactic_proof":"[@@auto]","source":"imandra_synthetic/security"} -{"id":89623,"prover":"Imandra","theorem":"password_hash_oneway","goal":"theorem password_hash_oneway p1 p2 = hash_pw p1 = hash_pw p2 ==> p1 = p2 \\/ collision p1 p2","context":["auto"],"tactic_proof":"[@@auto]","source":"imandra_synthetic/security"} -{"id":89624,"prover":"Imandra","theorem":"input_sanitize","goal":"theorem input_sanitize s = safe (sanitize s)","context":["auto"],"tactic_proof":"[@@auto]","source":"imandra_synthetic/security"} -{"id":89625,"prover":"Imandra","theorem":"session_expiry","goal":"theorem session_expiry s t = expired s t ==> not (valid_session s t)","context":["auto"],"tactic_proof":"[@@auto]","source":"imandra_synthetic/security"} -{"id":89626,"prover":"Imandra","theorem":"audit_log_append","goal":"theorem audit_log_append log e = append log e = log ++ [e]","context":["auto"],"tactic_proof":"[@@auto]","source":"imandra_synthetic/security"} -{"id":89627,"prover":"Imandra","theorem":"gradient_descent_converge","goal":"theorem gd_converge f lr x0 = convex f ==> lr > 0 ==> lr <= 1 / lipschitz f ==> converges (gd f lr x0)","context":["auto"],"tactic_proof":"[@@auto]","source":"imandra_synthetic/ml_correctness"} -{"id":89628,"prover":"Imandra","theorem":"softmax_sum_one","goal":"theorem softmax_sum_one xs = List.length xs > 0 ==> List.fold_left (+.) 0.0 (softmax xs) = 1.0","context":["auto"],"tactic_proof":"[@@auto]","source":"imandra_synthetic/ml_correctness"} -{"id":89629,"prover":"Imandra","theorem":"relu_nonneg","goal":"theorem relu_nonneg x = relu x >= 0.0","context":["auto"],"tactic_proof":"[@@auto]","source":"imandra_synthetic/ml_correctness"} -{"id":89630,"prover":"Imandra","theorem":"sigmoid_bounded","goal":"theorem sigmoid_bounded x = 0.0 <= sigmoid x && sigmoid x <= 1.0","context":["auto"],"tactic_proof":"[@@auto]","source":"imandra_synthetic/ml_correctness"} -{"id":89631,"prover":"Imandra","theorem":"loss_nonneg","goal":"theorem loss_nonneg y y_hat = mse y y_hat >= 0.0","context":["auto"],"tactic_proof":"[@@auto]","source":"imandra_synthetic/ml_correctness"} -{"id":89632,"prover":"Imandra","theorem":"backprop_chain","goal":"theorem backprop_chain f g x = gradient (compose f g) x = gradient f (g x) *. gradient g x","context":["auto"],"tactic_proof":"[@@auto]","source":"imandra_synthetic/ml_correctness"} +{"prover":"Imandra","tactic_proof":"[@@auto]","source":"imandra_synthetic/arithmetic","theorem":"add_comm","id":89500,"goal":"theorem add_comm x y = x + y = y + x","context":["auto"]} +{"prover":"Imandra","tactic_proof":"[@@auto]","source":"imandra_synthetic/arithmetic","theorem":"add_assoc","id":89501,"goal":"theorem add_assoc x y z = (x + y) + z = x + (y + z)","context":["auto"]} +{"prover":"Imandra","tactic_proof":"[@@auto]","source":"imandra_synthetic/arithmetic","theorem":"mul_comm","id":89502,"goal":"theorem mul_comm x y = x * y = y * x","context":["auto"]} +{"prover":"Imandra","tactic_proof":"[@@auto]","source":"imandra_synthetic/arithmetic","theorem":"mul_assoc","id":89503,"goal":"theorem mul_assoc x y z = (x * y) * z = x * (y * z)","context":["auto"]} +{"prover":"Imandra","tactic_proof":"[@@auto]","source":"imandra_synthetic/arithmetic","theorem":"distrib","id":89504,"goal":"theorem distrib x y z = x * (y + z) = x * y + x * z","context":["auto"]} +{"prover":"Imandra","tactic_proof":"[@@auto]","source":"imandra_synthetic/arithmetic","theorem":"add_zero","id":89505,"goal":"theorem add_zero x = x + 0 = x","context":["auto"]} +{"prover":"Imandra","tactic_proof":"[@@auto]","source":"imandra_synthetic/arithmetic","theorem":"mul_one","id":89506,"goal":"theorem mul_one x = x * 1 = x","context":["auto"]} +{"prover":"Imandra","tactic_proof":"[@@auto]","source":"imandra_synthetic/arithmetic","theorem":"mul_zero","id":89507,"goal":"theorem mul_zero x = x * 0 = 0","context":["auto"]} +{"prover":"Imandra","tactic_proof":"[@@auto]","source":"imandra_synthetic/arithmetic","theorem":"abs_nonneg","id":89508,"goal":"theorem abs_nonneg x = abs x >= 0","context":["auto"]} +{"prover":"Imandra","tactic_proof":"[@@auto]","source":"imandra_synthetic/arithmetic","theorem":"abs_triangle","id":89509,"goal":"theorem abs_triangle x y = abs (x + y) <= abs x + abs y","context":["auto"]} +{"prover":"Imandra","tactic_proof":"[@@auto]","source":"imandra_synthetic/arithmetic","theorem":"max_comm","id":89510,"goal":"theorem max_comm x y = max x y = max y x","context":["auto"]} +{"prover":"Imandra","tactic_proof":"[@@auto]","source":"imandra_synthetic/arithmetic","theorem":"min_comm","id":89511,"goal":"theorem min_comm x y = min x y = min y x","context":["auto"]} +{"prover":"Imandra","tactic_proof":"[@@auto]","source":"imandra_synthetic/arithmetic","theorem":"max_assoc","id":89512,"goal":"theorem max_assoc x y z = max x (max y z) = max (max x y) z","context":["auto"]} +{"prover":"Imandra","tactic_proof":"[@@auto]","source":"imandra_synthetic/arithmetic","theorem":"min_max_absorb","id":89513,"goal":"theorem min_max_absorb x y = min x (max x y) = x","context":["auto"]} +{"prover":"Imandra","tactic_proof":"[@@auto]","source":"imandra_synthetic/arithmetic","theorem":"div_mod_id","id":89514,"goal":"theorem div_mod_id a b = b > 0 ==> a = b * (a / b) + (a mod b)","context":["auto"]} +{"prover":"Imandra","tactic_proof":"[@@induct l]","source":"imandra_synthetic/lists","theorem":"append_nil","id":89515,"goal":"theorem append_nil l = l @ [] = l","context":["auto"]} +{"prover":"Imandra","tactic_proof":"[@@induct l1]","source":"imandra_synthetic/lists","theorem":"append_assoc","id":89516,"goal":"theorem append_assoc l1 l2 l3 = (l1 @ l2) @ l3 = l1 @ (l2 @ l3)","context":["auto"]} +{"prover":"Imandra","tactic_proof":"[@@induct l1]","source":"imandra_synthetic/lists","theorem":"length_append","id":89517,"goal":"theorem length_append l1 l2 = List.length (l1 @ l2) = List.length l1 + List.length l2","context":["auto"]} +{"prover":"Imandra","tactic_proof":"[@@induct l] [@@auto]","source":"imandra_synthetic/lists","theorem":"rev_rev","id":89518,"goal":"theorem rev_rev l = List.rev (List.rev l) = l","context":["auto"]} +{"prover":"Imandra","tactic_proof":"[@@induct l]","source":"imandra_synthetic/lists","theorem":"map_id","id":89519,"goal":"theorem map_id l = List.map (fun x -> x) l = l","context":["auto"]} +{"prover":"Imandra","tactic_proof":"[@@induct l]","source":"imandra_synthetic/lists","theorem":"map_compose","id":89520,"goal":"theorem map_compose f g l = List.map f (List.map g l) = List.map (fun x -> f (g x)) l","context":["auto"]} +{"prover":"Imandra","tactic_proof":"[@@induct l]","source":"imandra_synthetic/lists","theorem":"length_map","id":89521,"goal":"theorem length_map f l = List.length (List.map f l) = List.length l","context":["auto"]} +{"prover":"Imandra","tactic_proof":"[@@induct l] [@@auto]","source":"imandra_synthetic/lists","theorem":"length_rev","id":89522,"goal":"theorem length_rev l = List.length (List.rev l) = List.length l","context":["auto"]} +{"prover":"Imandra","tactic_proof":"[@@induct l1]","source":"imandra_synthetic/lists","theorem":"mem_append","id":89523,"goal":"theorem mem_append x l1 l2 = List.mem x (l1 @ l2) = (List.mem x l1 || List.mem x l2)","context":["auto"]} +{"prover":"Imandra","tactic_proof":"[@@induct l1]","source":"imandra_synthetic/lists","theorem":"filter_append","id":89524,"goal":"theorem filter_append p l1 l2 = List.filter p (l1 @ l2) = List.filter p l1 @ List.filter p l2","context":["auto"]} +{"prover":"Imandra","tactic_proof":"[@@induct l]","source":"imandra_synthetic/lists","theorem":"flat_map_assoc","id":89525,"goal":"theorem flat_map_assoc f g l = List.concat_map g (List.concat_map f l) = List.concat_map (fun x -> List.concat_map g (f x)) l","context":["auto"]} +{"prover":"Imandra","tactic_proof":"[@@induct l] [@@auto]","source":"imandra_synthetic/lists","theorem":"nth_map","id":89526,"goal":"theorem nth_map f l i = i < List.length l ==> List.nth (List.map f l) i = f (List.nth l i)","context":["auto"]} +{"prover":"Imandra","tactic_proof":"[@@induct l1]","source":"imandra_synthetic/lists","theorem":"for_all_append","id":89527,"goal":"theorem for_all_append p l1 l2 = List.for_all p (l1 @ l2) = (List.for_all p l1 && List.for_all p l2)","context":["auto"]} +{"prover":"Imandra","tactic_proof":"[@@induct l] [@@auto]","source":"imandra_synthetic/verification","theorem":"sorted_insert","id":89528,"goal":"theorem sorted_insert x l = sorted l ==> sorted (insert x l)","context":["auto"]} +{"prover":"Imandra","tactic_proof":"[@@induct l] [@@auto]","source":"imandra_synthetic/verification","theorem":"sorted_sort","id":89529,"goal":"theorem sorted_sort l = sorted (sort l)","context":["auto"]} +{"prover":"Imandra","tactic_proof":"[@@induct l] [@@auto]","source":"imandra_synthetic/verification","theorem":"perm_sort","id":89530,"goal":"theorem perm_sort l = is_perm l (sort l)","context":["auto"]} +{"prover":"Imandra","tactic_proof":"[@@auto]","source":"imandra_synthetic/verification","theorem":"bsearch_correct","id":89531,"goal":"theorem bsearch_correct a v = sorted a ==> (match bsearch a v with Some i -> a.(i) = v | None -> not (Array.exists (fun x -> x = v) a))","context":["auto"]} +{"prover":"Imandra","tactic_proof":"[@@auto]","source":"imandra_synthetic/verification","theorem":"stack_push_pop","id":89532,"goal":"theorem stack_push_pop x s = pop (push x s) = (x, s)","context":["auto"]} +{"prover":"Imandra","tactic_proof":"[@@auto]","source":"imandra_synthetic/verification","theorem":"queue_fifo","id":89533,"goal":"theorem queue_fifo x q = not (is_empty q) ==> fst (dequeue (enqueue x q)) = front q","context":["auto"]} +{"prover":"Imandra","tactic_proof":"[@@induct t] [@@auto]","source":"imandra_synthetic/verification","theorem":"rbt_invariant","id":89534,"goal":"theorem rbt_invariant x t = is_rbt t ==> is_rbt (rbt_insert x t)","context":["auto"]} +{"prover":"Imandra","tactic_proof":"[@@induct t] [@@auto]","source":"imandra_synthetic/verification","theorem":"bst_invariant","id":89535,"goal":"theorem bst_invariant x t = is_bst t ==> is_bst (bst_insert x t)","context":["auto"]} +{"prover":"Imandra","tactic_proof":"[@@induct h] [@@auto]","source":"imandra_synthetic/verification","theorem":"heap_insert_min","id":89536,"goal":"theorem heap_insert_min x h = is_heap h ==> find_min (heap_insert x h) <= x","context":["auto"]} +{"prover":"Imandra","tactic_proof":"[@@auto]","source":"imandra_synthetic/finance","theorem":"margin_nonneg","id":89537,"goal":"theorem margin_nonneg acct = valid_account acct ==> margin_requirement acct >= 0.0","context":["auto"]} +{"prover":"Imandra","tactic_proof":"[@@auto]","source":"imandra_synthetic/finance","theorem":"order_fill_balance","id":89538,"goal":"theorem order_fill_balance order book = valid_order order ==> balance_after (fill order book) >= 0.0","context":["auto"]} +{"prover":"Imandra","tactic_proof":"[@@auto]","source":"imandra_synthetic/finance","theorem":"matching_symmetric","id":89539,"goal":"theorem matching_symmetric buy sell = can_match buy sell ==> can_match sell buy","context":["auto"]} +{"prover":"Imandra","tactic_proof":"[@@auto]","source":"imandra_synthetic/finance","theorem":"settlement_complete","id":89540,"goal":"theorem settlement_complete trades = all_valid trades ==> is_settled (settle trades)","context":["auto"]} +{"prover":"Imandra","tactic_proof":"[@@auto]","source":"imandra_synthetic/finance","theorem":"risk_monotone","id":89541,"goal":"theorem risk_monotone p1 p2 = portfolio_subset p1 p2 ==> risk p1 <= risk p2","context":["auto"]} +{"prover":"Imandra","tactic_proof":"CX: l = [1; 3; 2] -- List.rev [1;3;2] = [2;3;1] which is not sorted","source":"imandra_synthetic/counterexamples","theorem":"cx_list_rev_sorted","id":89542,"goal":"verify (fun l -> sorted l ==> sorted (List.rev l))","context":["auto"]} +{"prover":"Imandra","tactic_proof":"CX: l1 = [1], l2 = [2] -- [1;2] <> [2;1]","source":"imandra_synthetic/counterexamples","theorem":"cx_append_comm","id":89543,"goal":"verify (fun l1 l2 -> l1 @ l2 = l2 @ l1)","context":["auto"]} +{"prover":"Imandra","tactic_proof":"CX: f = (fun _ -> 0), l1 = [1], l2 = [2]","source":"imandra_synthetic/counterexamples","theorem":"cx_map_injective","id":89544,"goal":"verify (fun f l1 l2 -> List.map f l1 = List.map f l2 ==> l1 = l2)","context":["auto"]} +{"prover":"Imandra","tactic_proof":"Verified: true (sort is idempotent)","source":"imandra_synthetic/counterexamples","theorem":"cx_sort_idempotent","id":89545,"goal":"verify (fun l -> sort (sort l) = sort l)","context":["auto"]} +{"prover":"Imandra","tactic_proof":"Verified: true","source":"imandra_synthetic/counterexamples","theorem":"cx_filter_length","id":89546,"goal":"verify (fun p l -> List.length (List.filter p l) <= List.length l)","context":["auto"]} +{"prover":"Imandra","tactic_proof":"Verified: true","source":"imandra_synthetic/counterexamples","theorem":"cx_subset_reflexive","id":89547,"goal":"verify (fun s -> subset s s)","context":["auto"]} +{"prover":"Imandra","tactic_proof":"Verified: true","source":"imandra_synthetic/counterexamples","theorem":"cx_division_positive","id":89548,"goal":"verify (fun x y -> x > 0 && y > 0 ==> x / y >= 0)","context":["auto"]} +{"prover":"Imandra","tactic_proof":"CX: x = max_int -- overflow wraps to min_int","source":"imandra_synthetic/counterexamples","theorem":"cx_int_overflow","id":89549,"goal":"verify (fun (x:int) -> x + 1 > x)","context":["auto"]} +{"prover":"Imandra","tactic_proof":"CX: a=1e30, b= -1e30, c=1.0 -- floating point not associative","source":"imandra_synthetic/counterexamples","theorem":"cx_float_assoc","id":89550,"goal":"verify (fun (a:float) b c -> (a +. b) +. c = a +. (b +. c))","context":["auto"]} +{"prover":"Imandra","tactic_proof":"[@@induct t] [@@auto]","source":"imandra_synthetic/trees","theorem":"bst_insert_preserves","id":89551,"goal":"theorem bst_insert_preserves x t = is_bst t ==> is_bst (bst_insert x t)","context":["auto"]} +{"prover":"Imandra","tactic_proof":"[@@induct t] [@@auto]","source":"imandra_synthetic/trees","theorem":"bst_member_after_insert","id":89552,"goal":"theorem bst_member_after_insert x t = bst_member x (bst_insert x t)","context":["auto"]} +{"prover":"Imandra","tactic_proof":"[@@induct t]","source":"imandra_synthetic/trees","theorem":"tree_mirror_involutive","id":89553,"goal":"theorem tree_mirror_involutive t = mirror (mirror t) = t","context":["auto"]} +{"prover":"Imandra","tactic_proof":"[@@induct t]","source":"imandra_synthetic/trees","theorem":"tree_size_positive","id":89554,"goal":"theorem tree_size_positive t = tree_size t >= 0","context":["auto"]} +{"prover":"Imandra","tactic_proof":"[@@induct t]","source":"imandra_synthetic/trees","theorem":"tree_flatten_length","id":89555,"goal":"theorem tree_flatten_length t = List.length (flatten t) = tree_size t","context":["auto"]} +{"prover":"Imandra","tactic_proof":"[@@induct h] [@@auto]","source":"imandra_synthetic/trees","theorem":"heap_extract_min_sorted","id":89556,"goal":"theorem heap_extract_min_sorted h = is_heap h ==> sorted (heapsort h)","context":["auto"]} +{"prover":"Imandra","tactic_proof":"[@@induct t] [@@auto]","source":"imandra_synthetic/trees","theorem":"avl_balanced","id":89557,"goal":"theorem avl_balanced t = is_avl t ==> abs (height (left t) - height (right t)) <= 1","context":["auto"]} +{"prover":"Imandra","tactic_proof":"[@@induct t] [@@auto]","source":"imandra_synthetic/trees","theorem":"rbt_black_height","id":89558,"goal":"theorem rbt_black_height t = is_rbt t ==> black_height (left t) = black_height (right t)","context":["auto"]} +{"prover":"Imandra","tactic_proof":"[@@auto]","source":"imandra_synthetic/numerics","theorem":"abs_diff_symmetric","id":89559,"goal":"theorem abs_diff_symmetric x y = abs (x - y) = abs (y - x)","context":["auto"]} +{"prover":"Imandra","tactic_proof":"[@@auto]","source":"imandra_synthetic/numerics","theorem":"sqr_nonneg","id":89560,"goal":"theorem sqr_nonneg x = x * x >= 0","context":["auto"]} +{"prover":"Imandra","tactic_proof":"[@@auto]","source":"imandra_synthetic/numerics","theorem":"ge_trans","id":89561,"goal":"theorem ge_trans x y z = x >= y ==> y >= z ==> x >= z","context":["auto"]} +{"prover":"Imandra","tactic_proof":"[@@auto]","source":"imandra_synthetic/numerics","theorem":"eq_refl_trans","id":89562,"goal":"theorem eq_refl_trans x y = x = y ==> y = x","context":["auto"]} +{"prover":"Imandra","tactic_proof":"[@@auto]","source":"imandra_synthetic/numerics","theorem":"neg_neg","id":89563,"goal":"theorem neg_neg x = -(-x) = x","context":["auto"]} +{"prover":"Imandra","tactic_proof":"[@@auto]","source":"imandra_synthetic/numerics","theorem":"sub_self_zero","id":89564,"goal":"theorem sub_self_zero x = x - x = 0","context":["auto"]} +{"prover":"Imandra","tactic_proof":"[@@auto]","source":"imandra_synthetic/numerics","theorem":"mul_distrib_sub","id":89565,"goal":"theorem mul_distrib_sub x y z = x * (y - z) = x*y - x*z","context":["auto"]} +{"prover":"Imandra","tactic_proof":"[@@auto]","source":"imandra_synthetic/numerics","theorem":"pow_zero","id":89566,"goal":"theorem pow_zero x = x > 0 ==> x ** 0 = 1","context":["auto"]} +{"prover":"Imandra","tactic_proof":"[@@induct n] [@@auto]","source":"imandra_synthetic/numerics","theorem":"pow_succ","id":89567,"goal":"theorem pow_succ x n = n >= 0 ==> x ** (n+1) = x * (x ** n)","context":["auto"]} +{"prover":"Imandra","tactic_proof":"[@@auto]","source":"imandra_synthetic/numerics","theorem":"gcd_self","id":89568,"goal":"theorem gcd_self n = n >= 0 ==> gcd n n = n","context":["auto"]} +{"prover":"Imandra","tactic_proof":"[@@auto]","source":"imandra_synthetic/numerics","theorem":"gcd_zero","id":89569,"goal":"theorem gcd_zero n = n >= 0 ==> gcd n 0 = n","context":["auto"]} +{"prover":"Imandra","tactic_proof":"[@@auto]","source":"imandra_synthetic/numerics","theorem":"divides_refl","id":89570,"goal":"theorem divides_refl n = n <> 0 ==> divides n n","context":["auto"]} +{"prover":"Imandra","tactic_proof":"[@@auto]","source":"imandra_synthetic/records","theorem":"record_set_get","id":89571,"goal":"theorem record_set_get r v = (set_field r v).field = v","context":["auto"]} +{"prover":"Imandra","tactic_proof":"[@@auto]","source":"imandra_synthetic/records","theorem":"record_get_set_idempotent","id":89572,"goal":"theorem record_get_set_idempotent r = set_field r (r.field) = r","context":["auto"]} +{"prover":"Imandra","tactic_proof":"[@@auto]","source":"imandra_synthetic/records","theorem":"record_set_comm","id":89573,"goal":"theorem record_set_comm r v1 v2 = set_f2 (set_f1 r v1) v2 = set_f1 (set_f2 r v2) v1","context":["auto"]} +{"prover":"Imandra","tactic_proof":"[@@auto]","source":"imandra_synthetic/records","theorem":"record_eq_fields","id":89574,"goal":"theorem record_eq_fields r1 r2 = r1.a = r2.a ==> r1.b = r2.b ==> r1 = r2","context":["auto"]} +{"prover":"Imandra","tactic_proof":"[@@auto]","source":"imandra_synthetic/records","theorem":"option_some_inj","id":89575,"goal":"theorem option_some_inj x y = Some x = Some y ==> x = y","context":["auto"]} +{"prover":"Imandra","tactic_proof":"[@@auto]","source":"imandra_synthetic/records","theorem":"option_none_not_some","id":89576,"goal":"theorem option_none_not_some x = None <> Some x","context":["auto"]} +{"prover":"Imandra","tactic_proof":"[@@auto]","source":"imandra_synthetic/records","theorem":"tuple_fst_snd","id":89577,"goal":"theorem tuple_fst_snd p = (fst p, snd p) = p","context":["auto"]} +{"prover":"Imandra","tactic_proof":"[@@auto]","source":"imandra_synthetic/state_machines","theorem":"fsm_deterministic","id":89578,"goal":"theorem fsm_deterministic s e = forall s1 s2. transition s e s1 ==> transition s e s2 ==> s1 = s2","context":["auto"]} +{"prover":"Imandra","tactic_proof":"[@@induct] [@@auto]","source":"imandra_synthetic/state_machines","theorem":"fsm_reachable_trans","id":89579,"goal":"theorem fsm_reachable_trans s1 s2 s3 = reachable s1 s2 ==> reachable s2 s3 ==> reachable s1 s3","context":["induct","auto"]} +{"prover":"Imandra","tactic_proof":"[@@auto]","source":"imandra_synthetic/state_machines","theorem":"fsm_initial_reachable","id":89580,"goal":"theorem fsm_initial_reachable s = s = initial_state ==> reachable s s","context":["auto"]} +{"prover":"Imandra","tactic_proof":"[@@auto]","source":"imandra_synthetic/state_machines","theorem":"fsm_no_deadlock","id":89581,"goal":"theorem fsm_no_deadlock s = reachable initial_state s ==> exists e s'. transition s e s'","context":["auto"]} +{"prover":"Imandra","tactic_proof":"[@@auto]","source":"imandra_synthetic/state_machines","theorem":"fsm_invariant_preserve","id":89582,"goal":"theorem fsm_invariant_preserve s e s' = inv s ==> transition s e s' ==> inv s'","context":["auto"]} +{"prover":"Imandra","tactic_proof":"[@@induct] [@@auto]","source":"imandra_synthetic/state_machines","theorem":"safety_property","id":89583,"goal":"theorem safety_property s = reachable initial_state s ==> not (is_error s)","context":["induct","auto"]} +{"prover":"Imandra","tactic_proof":"[@@auto]","source":"imandra_synthetic/state_machines","theorem":"liveness_property","id":89584,"goal":"theorem liveness_property s = reachable initial_state s ==> eventually goal_state s","context":["auto"]} +{"prover":"Imandra","tactic_proof":"[@@auto]","source":"imandra_synthetic/crypto","theorem":"hash_deterministic","id":89585,"goal":"theorem hash_deterministic m1 m2 = m1 = m2 ==> hash m1 = hash m2","context":["auto"]} +{"prover":"Imandra","tactic_proof":"[@@auto]","source":"imandra_synthetic/crypto","theorem":"signature_verify","id":89586,"goal":"theorem signature_verify sk pk m = keypair sk pk ==> verify pk m (sign sk m) = true","context":["auto"]} +{"prover":"Imandra","tactic_proof":"[@@auto]","source":"imandra_synthetic/crypto","theorem":"encrypt_decrypt","id":89587,"goal":"theorem encrypt_decrypt k m = decrypt k (encrypt k m) = m","context":["auto"]} +{"prover":"Imandra","tactic_proof":"[@@auto]","source":"imandra_synthetic/crypto","theorem":"merkle_root_unique","id":89588,"goal":"theorem merkle_root_unique l1 l2 = merkle_root l1 = merkle_root l2 ==> l1 = l2","context":["auto"]} +{"prover":"Imandra","tactic_proof":"[@@auto]","source":"imandra_synthetic/crypto","theorem":"xor_involutive","id":89589,"goal":"theorem xor_involutive x y = xor (xor x y) y = x","context":["auto"]} +{"prover":"Imandra","tactic_proof":"[@@auto]","source":"imandra_synthetic/crypto","theorem":"nonce_unique","id":89590,"goal":"theorem nonce_unique n1 n2 = generate_nonce n1 = generate_nonce n2 ==> n1 = n2","context":["auto"]} +{"prover":"Imandra","tactic_proof":"[@@induct b] [@@auto]","source":"imandra_synthetic/blockchain","theorem":"block_prev_chain","id":89591,"goal":"theorem block_prev_chain b = valid_chain b ==> prev_hash (head b) = hash (tail b)","context":["auto"]} +{"prover":"Imandra","tactic_proof":"[@@auto]","source":"imandra_synthetic/blockchain","theorem":"tx_balance_conservation","id":89592,"goal":"theorem tx_balance_conservation tx = valid_tx tx ==> sum_inputs tx = sum_outputs tx + fee tx","context":["auto"]} +{"prover":"Imandra","tactic_proof":"[@@auto]","source":"imandra_synthetic/blockchain","theorem":"utxo_no_double_spend","id":89593,"goal":"theorem utxo_no_double_spend tx1 tx2 utxo = valid_tx tx1 ==> valid_tx tx2 ==> disjoint (inputs tx1) (inputs tx2)","context":["auto"]} +{"prover":"Imandra","tactic_proof":"[@@auto]","source":"imandra_synthetic/blockchain","theorem":"consensus_majority","id":89594,"goal":"theorem consensus_majority votes = count_yes votes > length votes / 2 ==> accepted votes","context":["auto"]} +{"prover":"Imandra","tactic_proof":"[@@auto]","source":"imandra_synthetic/blockchain","theorem":"longest_chain","id":89595,"goal":"theorem longest_chain c1 c2 = valid_chain c1 ==> valid_chain c2 ==> height c1 >= height c2 ==> canonical c1","context":["auto"]} +{"prover":"Imandra","tactic_proof":"[@@auto]","source":"imandra_synthetic/algebra","theorem":"group_identity_unique","id":89596,"goal":"theorem group_identity_unique e1 e2 = is_identity e1 ==> is_identity e2 ==> e1 = e2","context":["auto"]} +{"prover":"Imandra","tactic_proof":"[@@auto]","source":"imandra_synthetic/algebra","theorem":"group_inverse_unique","id":89597,"goal":"theorem group_inverse_unique a b c = op a b = identity ==> op a c = identity ==> b = c","context":["auto"]} +{"prover":"Imandra","tactic_proof":"[@@auto]","source":"imandra_synthetic/algebra","theorem":"monoid_left_id","id":89598,"goal":"theorem monoid_left_id a = op identity a = a","context":["auto"]} +{"prover":"Imandra","tactic_proof":"[@@auto]","source":"imandra_synthetic/algebra","theorem":"monoid_right_id","id":89599,"goal":"theorem monoid_right_id a = op a identity = a","context":["auto"]} +{"prover":"Imandra","tactic_proof":"[@@auto]","source":"imandra_synthetic/algebra","theorem":"ring_distrib","id":89600,"goal":"theorem ring_distrib a b c = mul a (add b c) = add (mul a b) (mul a c)","context":["auto"]} +{"prover":"Imandra","tactic_proof":"[@@auto]","source":"imandra_synthetic/algebra","theorem":"ring_zero_mul","id":89601,"goal":"theorem ring_zero_mul a = mul zero a = zero","context":["auto"]} +{"prover":"Imandra","tactic_proof":"[@@auto]","source":"imandra_synthetic/algebra","theorem":"semilat_idempotent","id":89602,"goal":"theorem semilat_idempotent a = meet a a = a","context":["auto"]} +{"prover":"Imandra","tactic_proof":"[@@auto]","source":"imandra_synthetic/concurrency","theorem":"mutex_exclusive","id":89603,"goal":"theorem mutex_exclusive s = acquired s ==> not (available s)","context":["auto"]} +{"prover":"Imandra","tactic_proof":"[@@auto]","source":"imandra_synthetic/concurrency","theorem":"lock_release","id":89604,"goal":"theorem lock_release s = acquire (release (acquire s)) = acquire s","context":["auto"]} +{"prover":"Imandra","tactic_proof":"[@@induct msgs] [@@auto]","source":"imandra_synthetic/concurrency","theorem":"queue_ordering","id":89605,"goal":"theorem queue_ordering q msgs = push q msgs ==> fifo_order (drain q)","context":["auto"]} +{"prover":"Imandra","tactic_proof":"[@@auto]","source":"imandra_synthetic/concurrency","theorem":"actor_isolation","id":89606,"goal":"theorem actor_isolation a b m = send a b m ==> state a = state a","context":["auto"]} +{"prover":"Imandra","tactic_proof":"[@@auto]","source":"imandra_synthetic/concurrency","theorem":"atomic_read_write","id":89607,"goal":"theorem atomic_read_write x v = read (write x v) = v","context":["auto"]} +{"prover":"Imandra","tactic_proof":"[@@auto]","source":"imandra_synthetic/concurrency","theorem":"cas_success","id":89608,"goal":"theorem cas_success x old new = read x = old ==> cas x old new = (true, write x new)","context":["auto"]} +{"prover":"Imandra","tactic_proof":"[@@induct tree] [@@auto]","source":"imandra_synthetic/concurrency","theorem":"deadlock_free","id":89609,"goal":"theorem deadlock_free tree = acyclic tree ==> not (deadlocked tree)","context":["auto"]} +{"prover":"Imandra","tactic_proof":"[@@auto]","source":"imandra_synthetic/databases","theorem":"acid_atomicity","id":89610,"goal":"theorem acid_atomicity tx db = commit tx db = Some db' \\/ commit tx db = None","context":["auto"]} +{"prover":"Imandra","tactic_proof":"[@@auto]","source":"imandra_synthetic/databases","theorem":"rollback_inverse","id":89611,"goal":"theorem rollback_inverse tx db = rollback tx (apply tx db) = db","context":["auto"]} +{"prover":"Imandra","tactic_proof":"[@@auto]","source":"imandra_synthetic/databases","theorem":"isolation_serializable","id":89612,"goal":"theorem isolation_serializable t1 t2 db = serializable [t1; t2] db = serializable [t2; t1] db","context":["auto"]} +{"prover":"Imandra","tactic_proof":"[@@auto]","source":"imandra_synthetic/databases","theorem":"index_consistent","id":89613,"goal":"theorem index_consistent idx tbl = valid_index idx tbl ==> forall k. lookup idx k = table_lookup tbl k","context":["auto"]} +{"prover":"Imandra","tactic_proof":"[@@auto]","source":"imandra_synthetic/databases","theorem":"foreign_key","id":89614,"goal":"theorem foreign_key p c = valid_db (p, c) ==> forall r in c. exists parent in p. fk_match r parent","context":["auto"]} +{"prover":"Imandra","tactic_proof":"[@@auto]","source":"imandra_synthetic/databases","theorem":"normalization_bcnf","id":89615,"goal":"theorem normalization_bcnf r = bcnf r ==> third_nf r","context":["auto"]} +{"prover":"Imandra","tactic_proof":"[@@induct pkts] [@@auto]","source":"imandra_synthetic/networking","theorem":"tcp_in_order","id":89616,"goal":"theorem tcp_in_order conn pkts = established conn ==> tcp_deliver conn pkts = sort_by_seq pkts","context":["auto"]} +{"prover":"Imandra","tactic_proof":"[@@auto]","source":"imandra_synthetic/networking","theorem":"packet_checksum","id":89617,"goal":"theorem packet_checksum p = valid_packet p ==> verify_checksum p = true","context":["auto"]} +{"prover":"Imandra","tactic_proof":"[@@auto]","source":"imandra_synthetic/networking","theorem":"routing_loop_free","id":89618,"goal":"theorem routing_loop_free graph = valid_routing graph ==> acyclic (next_hop graph)","context":["auto"]} +{"prover":"Imandra","tactic_proof":"[@@auto]","source":"imandra_synthetic/networking","theorem":"tls_handshake_secrecy","id":89619,"goal":"theorem tls_handshake_secrecy c s = secure_handshake c s ==> secret_key_safe c s","context":["auto"]} +{"prover":"Imandra","tactic_proof":"[@@auto]","source":"imandra_synthetic/networking","theorem":"retry_idempotent","id":89620,"goal":"theorem retry_idempotent req = idempotent req ==> retry req = send req","context":["auto"]} +{"prover":"Imandra","tactic_proof":"[@@auto]","source":"imandra_synthetic/security","theorem":"auth_token_valid","id":89621,"goal":"theorem auth_token_valid t = verify_token t = Some user ==> user = decode t","context":["auto"]} +{"prover":"Imandra","tactic_proof":"[@@auto]","source":"imandra_synthetic/security","theorem":"rbac_permission","id":89622,"goal":"theorem rbac_permission u r p = has_role u r && role_has_perm r p ==> authorized u p","context":["auto"]} +{"prover":"Imandra","tactic_proof":"[@@auto]","source":"imandra_synthetic/security","theorem":"password_hash_oneway","id":89623,"goal":"theorem password_hash_oneway p1 p2 = hash_pw p1 = hash_pw p2 ==> p1 = p2 \\/ collision p1 p2","context":["auto"]} +{"prover":"Imandra","tactic_proof":"[@@auto]","source":"imandra_synthetic/security","theorem":"input_sanitize","id":89624,"goal":"theorem input_sanitize s = safe (sanitize s)","context":["auto"]} +{"prover":"Imandra","tactic_proof":"[@@auto]","source":"imandra_synthetic/security","theorem":"session_expiry","id":89625,"goal":"theorem session_expiry s t = expired s t ==> not (valid_session s t)","context":["auto"]} +{"prover":"Imandra","tactic_proof":"[@@auto]","source":"imandra_synthetic/security","theorem":"audit_log_append","id":89626,"goal":"theorem audit_log_append log e = append log e = log ++ [e]","context":["auto"]} +{"prover":"Imandra","tactic_proof":"[@@auto]","source":"imandra_synthetic/ml_correctness","theorem":"gradient_descent_converge","id":89627,"goal":"theorem gd_converge f lr x0 = convex f ==> lr > 0 ==> lr <= 1 / lipschitz f ==> converges (gd f lr x0)","context":["auto"]} +{"prover":"Imandra","tactic_proof":"[@@auto]","source":"imandra_synthetic/ml_correctness","theorem":"softmax_sum_one","id":89628,"goal":"theorem softmax_sum_one xs = List.length xs > 0 ==> List.fold_left (+.) 0.0 (softmax xs) = 1.0","context":["auto"]} +{"prover":"Imandra","tactic_proof":"[@@auto]","source":"imandra_synthetic/ml_correctness","theorem":"relu_nonneg","id":89629,"goal":"theorem relu_nonneg x = relu x >= 0.0","context":["auto"]} +{"prover":"Imandra","tactic_proof":"[@@auto]","source":"imandra_synthetic/ml_correctness","theorem":"sigmoid_bounded","id":89630,"goal":"theorem sigmoid_bounded x = 0.0 <= sigmoid x && sigmoid x <= 1.0","context":["auto"]} +{"prover":"Imandra","tactic_proof":"[@@auto]","source":"imandra_synthetic/ml_correctness","theorem":"loss_nonneg","id":89631,"goal":"theorem loss_nonneg y y_hat = mse y y_hat >= 0.0","context":["auto"]} +{"prover":"Imandra","tactic_proof":"[@@auto]","source":"imandra_synthetic/ml_correctness","theorem":"backprop_chain","id":89632,"goal":"theorem backprop_chain f g x = gradient (compose f g) x = gradient f (g x) *. gradient g x","context":["auto"]} diff --git a/training_data/proof_states_isabelle.jsonl b/training_data/proof_states_isabelle.jsonl index 1c8e4bf..3d0eba8 100644 --- a/training_data/proof_states_isabelle.jsonl +++ b/training_data/proof_states_isabelle.jsonl @@ -1,25 +1,214 @@ -{"prover":"Isabelle","tactic_proof":"by (rule Nat.add_commute)","source":"tropical_resource_typing/isabelle_synthetic","theorem":"nat_add_comm","id":200000,"goal":"\"(m :: nat) + n = n + m\"","context":["rule","by"]} -{"prover":"Isabelle","tactic_proof":"by simp","source":"tropical_resource_typing/isabelle_synthetic","theorem":"nat_max_idem","id":200001,"goal":"\"max (n :: nat) n = n\"","context":["simp","by"]} -{"prover":"Isabelle","tactic_proof":"by (simp add: max.commute)","source":"tropical_resource_typing/isabelle_synthetic","theorem":"nat_max_comm","id":200002,"goal":"\"max (a :: nat) b = max b a\"","context":["simp","by"]} -{"prover":"Isabelle","tactic_proof":"by (simp add: max.assoc)","source":"tropical_resource_typing/isabelle_synthetic","theorem":"nat_max_assoc","id":200003,"goal":"\"max (max (a :: nat) b) c = max a (max b c)\"","context":["simp","by"]} -{"prover":"Isabelle","tactic_proof":"by simp","source":"tropical_resource_typing/isabelle_synthetic","theorem":"nat_add_distrib_max","id":200004,"goal":"\"(k :: nat) + max m n = max (k + m) (k + n)\"","context":["simp","by"]} -{"prover":"Isabelle","tactic_proof":"by simp","source":"tropical_resource_typing/isabelle_synthetic","theorem":"comm_monoid_add_zero_left","id":200005,"goal":"\"(0 :: 'a :: comm_monoid_add) + a = a\"","context":["simp","by"]} -{"prover":"Isabelle","tactic_proof":"by (rule distrib_left)","source":"tropical_resource_typing/isabelle_synthetic","theorem":"semiring_distrib_left","id":200006,"goal":"\"a * (b + c) = a * b + a * c\" for a b c :: \"'a :: semiring\"","context":["rule","by"]} -{"prover":"Isabelle","tactic_proof":"by simp","source":"tropical_resource_typing/isabelle_synthetic","theorem":"sum_cong_eq","id":200007,"goal":"\"f = g \\ (\\ x \\ A. f x) = (\\ x \\ A. g x)\"","context":["simp","by"]} -{"prover":"Isabelle","tactic_proof":"by (simp add: sum.delta)","source":"tropical_resource_typing/isabelle_synthetic","theorem":"sum_delta_finite","id":200008,"goal":"\"finite A \\ j \\ A \\ (\\ k \\ A. if k = j then f k else 0) = f j\"","context":["simp","by","sum.delta"]} -{"prover":"Isabelle","tactic_proof":"by (rule sum.union_disjoint)","source":"tropical_resource_typing/isabelle_synthetic","theorem":"sum_union_disjoint","id":200009,"goal":"\"finite A \\ finite B \\ A \\ B = {} \\\n (\\ x \\ A \\ B. f x) = (\\ x \\ A. f x) + (\\ x \\ B. f x)\"","context":["rule","by"]} -{"prover":"Isabelle","tactic_proof":"by (rule sum.swap)","source":"tropical_resource_typing/isabelle_synthetic","theorem":"sum_swap_double","id":200010,"goal":"\"(\\ i \\ A. \\ j \\ B. f i j) = (\\ j \\ B. \\ i \\ A. f i j)\"","context":["rule","by","sum.swap"]} -{"prover":"Isabelle","tactic_proof":"by (rule sum_distrib_left)","source":"tropical_resource_typing/isabelle_synthetic","theorem":"sum_distrib_left","id":200011,"goal":"\"c * (\\ i \\ A. f i) = (\\ i \\ A. c * f i)\"","context":["rule","by"]} -{"prover":"Isabelle","tactic_proof":"by (rule sum_distrib_right)","source":"tropical_resource_typing/isabelle_synthetic","theorem":"sum_distrib_right","id":200012,"goal":"\"(\\ i \\ A. f i) * c = (\\ i \\ A. f i * c)\"","context":["rule","by"]} -{"prover":"Isabelle","tactic_proof":"by simp","source":"tropical_resource_typing/isabelle_synthetic","theorem":"list_length_nonempty","id":200013,"goal":"\"w \\ [] \\ 0 < length w\"","context":["simp","by"]} -{"prover":"Isabelle","tactic_proof":"by (simp add: hd_in_set)","source":"tropical_resource_typing/isabelle_synthetic","theorem":"hd_in_set","id":200014,"goal":"\"w \\ [] \\ hd w \\ set w\"","context":["simp","by"]} -{"prover":"Isabelle","tactic_proof":"by (simp add: last_in_set)","source":"tropical_resource_typing/isabelle_synthetic","theorem":"last_in_set","id":200015,"goal":"\"w \\ [] \\ last w \\ set w\"","context":["simp","by"]} -{"prover":"Isabelle","tactic_proof":"by (rule finite_lists_length_eq) simp","source":"tropical_resource_typing/isabelle_synthetic","theorem":"finite_lists_bounded","id":200016,"goal":"\"finite A \\ finite {w :: nat list . length w = k \\ set w \\ A}\"","context":["simp","rule","by"]} -{"prover":"Isabelle","tactic_proof":"by (rule card_mono[THEN order_trans])\n (auto simp: distinct_card)","source":"tropical_resource_typing/isabelle_synthetic","theorem":"distinct_length_le","id":200017,"goal":"\"distinct w \\ set w \\ A \\ finite A \\\n length w \\ card A\"","context":["simp","auto","rule","by"]} -{"prover":"Isabelle","tactic_proof":"by (rule order_antisym)","source":"tropical_resource_typing/isabelle_synthetic","theorem":"antisym_eq","id":200018,"goal":"\"a \\ b \\ b \\ a \\ a = b\" for a b :: \"'a :: order\"","context":["rule","by","rule order_antisym"]} -{"prover":"Isabelle","tactic_proof":"by (rule Nat.nat.induct)","source":"tropical_resource_typing/isabelle_synthetic","theorem":"induction_nat_sum","id":200019,"goal":"\"P 0 \\ (\\ k. P k \\ P (Suc k)) \\ P n\"","context":["induct","rule","by"]} -{"prover":"Isabelle","tactic_proof":"by simp","source":"tropical_resource_typing/isabelle_synthetic","theorem":"trop_fin_add_fin","id":200020,"goal":"\"trop_add (Fin m) (Fin n) = Fin (max m n)\"","context":["simp","by"]} -{"prover":"Isabelle","tactic_proof":"by simp","source":"tropical_resource_typing/isabelle_synthetic","theorem":"trop_mul_fin_fin","id":200021,"goal":"\"trop_mul (Fin m) (Fin n) = Fin (m + n)\"","context":["simp","by"]} -{"prover":"Isabelle","tactic_proof":"by (cases a) simp_all","source":"tropical_resource_typing/isabelle_synthetic","theorem":"trop_add_neginf_left","id":200022,"goal":"\"trop_add NegInf a = a\"","context":["simp","simp_all","cases","case","by"]} -{"prover":"Isabelle","tactic_proof":"by (cases a) simp_all","source":"tropical_resource_typing/isabelle_synthetic","theorem":"trop_mul_neginf_left","id":200023,"goal":"\"trop_mul NegInf a = NegInf\"","context":["simp","simp_all","cases","case","by"]} -{"prover":"Isabelle","tactic_proof":"by (cases a) simp_all","source":"tropical_resource_typing/isabelle_synthetic","theorem":"tropm_add_posinf_left","id":200024,"goal":"\"tropm_add PosInf a = a\"","context":["simp","simp_all","cases","case","by"]} +{"prover":"Isabelle","tactic_proof":" by simp","source":"tropical_resource_typing/tropical_v2","theorem":"trop_add_NegInf_left","id":200000,"goal":"\"trop_add NegInf a = a\" by (cases a) simp_all lemma trop_add_NegInf_right [simp]: \"trop_add a NegInf = a\" by (cases a) simp_all lemma trop_add_comm: \"trop_add a b = trop_add b a\" by (cases a; cases b) (simp_all add: max.commute) lemma trop_add_assoc: \"trop_add (trop_add a b) c = trop_add a (trop_add b c)\" by (cases a; cases b; cases c) (simp_all add: max.assoc) lemma trop_add_idem [simp]: \"trop_add a a = a\" by (cases a) simp_all lemma trop_add_Fin_Fin [simp]: \"trop_add (Fin m) (Fin n) = Fin (max m n)\"","context":["simp","by"]} +{"prover":"Isabelle","tactic_proof":" by simp","source":"tropical_resource_typing/tropical_v2","theorem":"trop_mul_NegInf_left","id":200001,"goal":"\"trop_mul NegInf a = NegInf\" by (cases a) simp_all lemma trop_mul_NegInf_right [simp]: \"trop_mul a NegInf = NegInf\" by (cases a) simp_all lemma trop_mul_one_left [simp]: \"trop_mul (Fin 0) a = a\" by (cases a) simp_all lemma trop_mul_one_right [simp]: \"trop_mul a (Fin 0) = a\" by (cases a) simp_all lemma trop_mul_comm: \"trop_mul a b = trop_mul b a\" by (cases a; cases b) (simp_all add: add.commute) lemma trop_mul_assoc: \"trop_mul (trop_mul a b) c = trop_mul a (trop_mul b c)\" by (cases a; cases b; cases c) (simp_all add: add.assoc) lemma trop_mul_Fin_Fin [simp]: \"trop_mul (Fin m) (Fin n) = Fin (m + n)\"","context":["simp","by"]} +{"prover":"Isabelle","tactic_proof":" by simp","source":"tropical_resource_typing/tropical_v2","theorem":"nat_add_distrib_max_left","id":200002,"goal":"\"(k :: nat) + max m n = max (k + m) (k + n)\"","context":["simp","by"]} +{"prover":"Isabelle","tactic_proof":" by simp","source":"tropical_resource_typing/tropical_v2","theorem":"nat_add_distrib_max_right","id":200003,"goal":"\"max m n + (k :: nat) = max (m + k) (n + k)\"","context":["simp","by"]} +{"prover":"Isabelle","tactic_proof":"proof\n fix a b c :: tropical\n show \"a + b + c = a + (b + c)\"\n unfolding plus_tropical_def by (simp add: trop_add_assoc)\n show \"a + b = b + a\"\n unfolding plus_tropical_def by (simp add: trop_add_comm)\n show \"(0 :: tropical) + a = a\"\n unfolding plus_tropical_def zero_tropical_def by simp\nqed","source":"tropical_resource_typing/tropical_v2","theorem":"trop_distrib_left","id":200004,"goal":"\"trop_mul a (trop_add b c) = trop_add (trop_mul a b) (trop_mul a c)\" by (cases a; cases b; cases c) simp_all lemma trop_distrib_right: \"trop_mul (trop_add a b) c = trop_add (trop_mul a c) (trop_mul b c)\" by (cases a; cases b; cases c) simp_all (* ---- order on Fin ---- *) (* ------------------------------------------------------------------ *) subsection \\4 Typeclass Instantiation — Semiring\\ (* ------------------------------------------------------------------ *) text \\ Seven-layer chain exactly as in @{file \"Tropical.thy\"}: additive monoid, multiplicative monoid, semiring, semiring_0, zero_neq_one, semiring_1, comm_semiring_1. \\ (* 4a -- additive commutative monoid --------------------------------- *) instantiation tropical :: comm_monoid_add begin definition zero_tropical :: tropical where \"(0 :: tropical) \\ NegInf\" definition plus_tropical :: \"tropical \\ tropical \\ tropical\" where \"(a :: tropical) + b \\ trop_add a b\" instance","context":["simp","by","qed","proof","unfold","unfolding","show","fix"]} +{"prover":"Isabelle","tactic_proof":" unfolding plus_tropical_def\n by (cases a; cases b) (simp_all add: less_eq_tropical_def max_def)","source":"tropical_resource_typing/tropical_v2","theorem":"NegInf_le","id":200005,"goal":"by (cases a) (simp_all add: less_eq_tropical_def) lemma not_Fin_le_NegInf [simp]: \"\\ Fin m \\ (NegInf :: tropical)\" by (simp add: less_eq_tropical_def) lemma Fin_le_Fin [simp]: \"(Fin m :: tropical) \\ Fin n \\ m \\ n\" by (simp add: less_eq_tropical_def) lemma Fin_lt_Fin [simp]: \"(Fin m :: tropical) < Fin n \\ m < n\" by (simp add: less_tropical_def less_eq_tropical_def; arith) lemma trop_add_le_iff: \"(a :: tropical) \\ b \\ a + b = b\"","context":["simp","simp_all","cases","case","by","unfold","unfolding"]} +{"prover":"Isabelle","tactic_proof":" unfolding plus_tropical_def by simp","source":"tropical_resource_typing/tropical_v2","theorem":"trop_bot_eq_zero","id":200006,"goal":"by (simp add: bot_tropical_def zero_tropical_def) (* ------------------------------------------------------------------ *) subsection \\7 Idempotency (Dioid)\\ (* ------------------------------------------------------------------ *) text \\ @{typ tropical} is a \\<^emph>\\dioid\\: an idempotent semiring. Idempotency (@{term \"a + a = a\"}) is its defining structural property and sits outside the @{class comm_semiring_1} hierarchy. \\ theorem tropical_add_idem: \"(a :: tropical) + a = a\"","context":["simp","by","unfold","unfolding"]} +{"prover":"Isabelle","tactic_proof":" by simp","source":"tropical_resource_typing/tropical_v2","theorem":"Fin_hom_mul","id":200007,"goal":"\"Fin (m + n) = Fin m * Fin n\" by (simp add: times_tropical_def) lemma Fin_hom_add: \"Fin (max m n) = Fin m + Fin n\" by (simp add: plus_tropical_def) lemma Fin_hom_zero: \"(0 :: tropical) = NegInf\" by (simp add: zero_tropical_def) lemma Fin_hom_one: \"(1 :: tropical) = Fin 0\" by (simp add: one_tropical_def) lemma Fin_hom_le: \"Fin m \\ Fin n \\ m \\ n\"","context":["simp","by"]} +{"prover":"Isabelle","tactic_proof":" by simp","source":"tropical_resource_typing/tropical_v2","theorem":"Fin_hom_strict","id":200008,"goal":"\"(Fin m :: tropical) < Fin n \\ m < n\"","context":["simp","by"]} +{"prover":"Isabelle","tactic_proof":" by simp","source":"tropical_resource_typing/tropical_v2","theorem":"Fin_hom_inject","id":200009,"goal":"\"Fin m = (Fin n :: tropical) \\ m = n\"","context":["simp","by"]} +{"prover":"Isabelle","tactic_proof":"proof (induction S rule: finite_ne_induct)\n case (singleton x)\n show ?case by simp\nnext\n case (insert x F)\n have step: \"trop_sum g (insert x F) = Fin (g x) + trop_sum g F\"\n using insert.hyps(1,3) by (simp add: trop_sum_insert)\n have ih: \"trop_sum g F = Fin (Max (g ` F))\"\n by (rule insert.IH)\n have combine: \"Fin (g x) + Fin (Max (g ` F)) = Fin (max (g x) (Max (g ` F)))\"\n by (simp add: plus_tropical_def)\n have max_eq: \"max (g x) (Max (g ` F)) = Max (g ` insert x F)\"\n using insert.hyps(1,2,3) by (simp add: Max_insert)\n show ?case\n using step ih combine max_eq by simp\nqed","source":"tropical_resource_typing/tropical_v2","theorem":"trop_sum_empty","id":200010,"goal":"\"trop_sum g {} = NegInf\" by (simp add: trop_sum_def zero_tropical_def) lemma trop_sum_singleton [simp]: \"trop_sum g {x} = Fin (g x)\" by (simp add: trop_sum_def zero_tropical_def plus_tropical_def) lemma trop_sum_insert: \"finite S \\ x \\ S \\ trop_sum g (insert x S) = Fin (g x) + trop_sum g S\" by (simp add: trop_sum_def sum.insert) text \\ @{text trop_sum_eq_Max}: the fundamental simplification lemma. For a non-empty finite set, the tropical sum collapses to the @{term Max} of the image. This is the key lemma that shortens downstream proofs from 14–18 lines to 2–7 lines. \\ lemma trop_sum_eq_Max: assumes \"finite S\" \"S \\ {}\" shows \"trop_sum g S = Fin (Max (g ` S))\" using assms","context":["simp","case","induction","induct","rule","by","qed","proof","show","have"]} +{"prover":"Isabelle","tactic_proof":"proof -\n have ne: \"S \\ {}\" using assms by auto\n have \"trop_sum g S = Fin (Max (g ` S))\"\n by (rule trop_sum_eq_Max[OF assms(1) ne])\n thus ?thesis\n by (simp add: Max_ge[OF finite_imageI[OF assms(1)] imageI[OF assms(2)]])\nqed","source":"tropical_resource_typing/tropical_v2","theorem":"trop_sum_ge_member","id":200011,"goal":"assumes \"finite S\" \"x \\ S\" shows \"Fin (g x) \\ trop_sum g S\"","context":["simp","auto","rule","by","qed","proof","have"]} +{"prover":"Isabelle","tactic_proof":"proof -\n have neT: \"T \\ {}\" using assms(2,3) by auto\n have fS: \"finite S\" by (rule finite_subset[OF assms(2) assms(1)])\n have \"trop_sum g S = Fin (Max (g ` S))\"\n by (rule trop_sum_eq_Max[OF fS assms(3)])\n moreover have \"trop_sum g T = Fin (Max (g ` T))\"\n by (rule trop_sum_eq_Max[OF assms(1) neT])\n moreover have \"Max (g ` S) \\ Max (g ` T)\"\n proof (rule Max_mono)\n show \"g ` S \\ g ` T\" using assms(2) by (rule image_mono)\n show \"g ` S \\ {}\" using assms(3) by simp\n show \"finite (g ` T)\" using assms(1) by (rule finite_imageI)\n qed\n ultimately show ?thesis by simp\nqed","source":"tropical_resource_typing/tropical_v2","theorem":"trop_sum_mono_subset","id":200012,"goal":"assumes \"finite T\" \"S \\ T\" \"S \\ {}\" shows \"trop_sum g S \\ trop_sum g T\"","context":["simp","auto","rule","by","qed","proof","show","have"]} +{"prover":"Isabelle","tactic_proof":"proof -\n have \"trop_sum g S = Fin (Max (g ` S))\"\n using assms(1,2) by (rule trop_sum_eq_Max)\n moreover have \"trop_sum h T = Fin (Max (h ` T))\"\n using assms(3,4) by (rule trop_sum_eq_Max)\n moreover have \"Max (g ` S) \\ Max (h ` T)\"\n proof (rule Max_le_iff[THEN iffD2])\n show \"finite (g ` S)\" using assms(1) by simp\n show \"g ` S \\ {}\" using assms(2) by simp\n show \"\\v \\ g ` S. v \\ Max (h ` T)\"\n proof\n fix v assume \"v \\ g ` S\"\n then obtain s where hs: \"s \\ S\" \"v = g s\" by auto\n obtain t where ht: \"t \\ T\" \"g s \\ h t\" using dominated hs(1) by auto\n have ht_in_image: \"h t \\ h ` T\" by (rule imageI[OF ht(1)])\n have fin_image: \"finite (h ` T)\" by (rule finite_imageI[OF assms(3)])\n have ht_le_Max: \"h t \\ {}\" \"finite T\" \"T \\ {}\" assumes dominated: \"\\s \\ S. \\t \\ T. g s \\ h t\" shows \"trop_sum g S \\ trop_sum h T\"","context":["simp","auto","rule","by","qed","proof","show","have","obtain","assume","fix"]} +{"prover":"Isabelle","tactic_proof":" by simp","source":"tropical_resource_typing/tropical_v2","theorem":"trop_arith_test1","id":200014,"goal":"by (simp add: plus_tropical_def) lemma trop_arith_test2: \"Fin m * Fin n = Fin (m + n)\" by (simp add: times_tropical_def) lemma trop_arith_test3: \"NegInf + a = a\" by (simp add: plus_tropical_def) lemma trop_arith_test4: \"NegInf * a = NegInf\" by (simp add: times_tropical_def) lemma trop_arith_test5: \"(0 :: tropical) = NegInf\" by (simp add: zero_tropical_def) lemma trop_arith_test6: \"(1 :: tropical) = Fin 0\" by (simp add: one_tropical_def) (* ================================================================== *) section \\Part II Min-Plus Semiring\\ (* ================================================================== *) (* ------------------------------------------------------------------ *) subsection \\1 Carrier Type\\ (* ------------------------------------------------------------------ *) text \\ The min-plus semiring has carrier @{text \"nat \\ {+\\}\"}. The constructor @{text \"Fin'\"} embeds @{typ nat}; @{text PosInf} represents @{text \"+\\\"} (the additive zero / identity of @{term min}). We use @{text \"Fin'\"} (with prime) to avoid a constructor-name clash with @{text \"Fin\"} from @{typ tropical}. \\ datatype tropical_min = Fin' nat \\ \\a finite value @{text \"n \\ \\\"}\\ | PosInf \\ \\@{text \"+\\\"}: additive zero, multiplicative absorbing\\ (* ------------------------------------------------------------------ *) subsection \\2 Primitive Operations\\ (* ------------------------------------------------------------------ *) text \\ @{text tropm_add} is @{term min} (with @{text PosInf} as identity). @{text tropm_mul} is ordinary @{term \"+\"} (with @{text \"Fin' 0\"} as identity). \\ fun tropm_add :: \"tropical_min \\ tropical_min \\ tropical_min\" where \"tropm_add PosInf b = b\" | \"tropm_add a PosInf = a\" | \"tropm_add (Fin' m) (Fin' n) = Fin' (min m n)\" fun tropm_mul :: \"tropical_min \\ tropical_min \\ tropical_min\" where \"tropm_mul PosInf _ = PosInf\" | \"tropm_mul _ PosInf = PosInf\" | \"tropm_mul (Fin' m) (Fin' n) = Fin' (m + n)\" (* ------------------------------------------------------------------ *) subsection \\3 Algebraic Lemmas\\ (* ------------------------------------------------------------------ *) (* ---- addition ---- *) lemma tropm_add_PosInf_left [simp]: \"tropm_add PosInf a = a\" by (cases a) simp_all lemma tropm_add_PosInf_right [simp]: \"tropm_add a PosInf = a\" by (cases a) simp_all lemma tropm_add_comm: \"tropm_add a b = tropm_add b a\" by (cases a; cases b) (simp_all add: min.commute) lemma tropm_add_assoc: \"tropm_add (tropm_add a b) c = tropm_add a (tropm_add b c)\" by (cases a; cases b; cases c) (simp_all add: min.assoc) lemma tropm_add_idem [simp]: \"tropm_add a a = a\" by (cases a) simp_all lemma tropm_add_Fin'_Fin' [simp]: \"tropm_add (Fin' m) (Fin' n) = Fin' (min m n)\"","context":["simp","by"]} +{"prover":"Isabelle","tactic_proof":" by simp","source":"tropical_resource_typing/tropical_v2","theorem":"tropm_mul_PosInf_left","id":200015,"goal":"\"tropm_mul PosInf a = PosInf\" by (cases a) simp_all lemma tropm_mul_PosInf_right [simp]: \"tropm_mul a PosInf = PosInf\" by (cases a) simp_all lemma tropm_mul_one_left [simp]: \"tropm_mul (Fin' 0) a = a\" by (cases a) simp_all lemma tropm_mul_one_right [simp]: \"tropm_mul a (Fin' 0) = a\" by (cases a) simp_all lemma tropm_mul_comm: \"tropm_mul a b = tropm_mul b a\" by (cases a; cases b) (simp_all add: add.commute) lemma tropm_mul_assoc: \"tropm_mul (tropm_mul a b) c = tropm_mul a (tropm_mul b c)\" by (cases a; cases b; cases c) (simp_all add: add.assoc) lemma tropm_mul_Fin'_Fin' [simp]: \"tropm_mul (Fin' m) (Fin' n) = Fin' (m + n)\"","context":["simp","by"]} +{"prover":"Isabelle","tactic_proof":" by simp","source":"tropical_resource_typing/tropical_v2","theorem":"nat_add_distrib_min_left","id":200016,"goal":"\"(k :: nat) + min m n = min (k + m) (k + n)\"","context":["simp","by"]} +{"prover":"Isabelle","tactic_proof":" by simp","source":"tropical_resource_typing/tropical_v2","theorem":"nat_add_distrib_min_right","id":200017,"goal":"\"min m n + (k :: nat) = min (m + k) (n + k)\"","context":["simp","by"]} +{"prover":"Isabelle","tactic_proof":"proof\n fix a b c :: tropical_min\n show \"a + b + c = a + (b + c)\"\n unfolding plus_tropical_min_def by (simp add: tropm_add_assoc)\n show \"a + b = b + a\"\n unfolding plus_tropical_min_def by (simp add: tropm_add_comm)\n show \"(0 :: tropical_min) + a = a\"\n unfolding plus_tropical_min_def zero_tropical_min_def by simp\nqed","source":"tropical_resource_typing/tropical_v2","theorem":"tropm_distrib_left","id":200018,"goal":"\"tropm_mul a (tropm_add b c) = tropm_add (tropm_mul a b) (tropm_mul a c)\" by (cases a; cases b; cases c) simp_all lemma tropm_distrib_right: \"tropm_mul (tropm_add a b) c = tropm_add (tropm_mul a c) (tropm_mul b c)\" by (cases a; cases b; cases c) simp_all (* ------------------------------------------------------------------ *) subsection \\4 Typeclass Instantiation — Semiring\\ (* ------------------------------------------------------------------ *) (* 4a -- additive commutative monoid --------------------------------- *) instantiation tropical_min :: comm_monoid_add begin definition zero_tropical_min :: tropical_min where \"(0 :: tropical_min) \\ PosInf\" definition plus_tropical_min :: \"tropical_min \\ tropical_min \\ tropical_min\" where \"(a :: tropical_min) + b \\ tropm_add a b\" instance","context":["simp","by","qed","proof","unfold","unfolding","show","fix"]} +{"prover":"Isabelle","tactic_proof":" unfolding plus_tropical_min_def\n by (cases a; cases b) (simp_all add: less_eq_tropical_min_def min_def)","source":"tropical_resource_typing/tropical_v2","theorem":"le_PosInf","id":200019,"goal":"by (cases a) (simp_all add: less_eq_tropical_min_def) lemma not_PosInf_le_Fin' [simp]: \"\\ (PosInf :: tropical_min) \\ Fin' n\" by (simp add: less_eq_tropical_min_def) lemma Fin'_le_Fin' [simp]: \"(Fin' m :: tropical_min) \\ Fin' n \\ m \\ n\" by (simp add: less_eq_tropical_min_def) lemma Fin'_lt_Fin' [simp]: \"(Fin' m :: tropical_min) < Fin' n \\ m < n\" by (simp add: less_tropical_min_def less_eq_tropical_min_def; arith) lemma tropm_add_le_iff: \"(a :: tropical_min) \\ b \\ a + b = a\"","context":["simp","simp_all","cases","case","by","unfold","unfolding"]} +{"prover":"Isabelle","tactic_proof":" unfolding plus_tropical_min_def by simp","source":"tropical_resource_typing/tropical_v2","theorem":"tropm_bot_eq_one","id":200020,"goal":"by (simp add: bot_tropical_min_def one_tropical_min_def) lemma tropm_top_eq_zero: \"(top :: tropical_min) = 0\" by (simp add: top_tropical_min_def zero_tropical_min_def) (* ------------------------------------------------------------------ *) subsection \\7 Idempotency (Dioid)\\ (* ------------------------------------------------------------------ *) theorem tropm_add_idem_thm: \"(a :: tropical_min) + a = a\"","context":["simp","by","unfold","unfolding"]} +{"prover":"Isabelle","tactic_proof":" by simp","source":"tropical_resource_typing/tropical_v2","theorem":"Fin'_hom_mul","id":200021,"goal":"\"Fin' (m + n) = Fin' m * Fin' n\" by (simp add: times_tropical_min_def) lemma Fin'_hom_add: \"Fin' (min m n) = Fin' m + Fin' n\" by (simp add: plus_tropical_min_def) lemma Fin'_hom_zero: \"(0 :: tropical_min) = PosInf\" by (simp add: zero_tropical_min_def) lemma Fin'_hom_one: \"(1 :: tropical_min) = Fin' 0\" by (simp add: one_tropical_min_def) lemma Fin'_hom_le: \"Fin' m \\ Fin' n \\ m \\ n\"","context":["simp","by"]} +{"prover":"Isabelle","tactic_proof":" by simp","source":"tropical_resource_typing/tropical_v2","theorem":"Fin'_hom_strict","id":200022,"goal":"\"(Fin' m :: tropical_min) < Fin' n \\ m < n\"","context":["simp","by"]} +{"prover":"Isabelle","tactic_proof":" by simp","source":"tropical_resource_typing/tropical_v2","theorem":"Fin'_hom_inject","id":200023,"goal":"\"Fin' m = (Fin' n :: tropical_min) \\ m = n\"","context":["simp","by"]} +{"prover":"Isabelle","tactic_proof":"proof (induction S rule: finite_ne_induct)\n case (singleton x)\n show ?case by simp\nnext\n case (insert x F)\n have step: \"tropm_sum g (insert x F) = Fin' (g x) + tropm_sum g F\"\n using insert.hyps(1,3) by (simp add: tropm_sum_insert)\n have ih: \"tropm_sum g F = Fin' (Min (g ` F))\"\n by (rule insert.IH)\n have combine: \"Fin' (g x) + Fin' (Min (g ` F)) = Fin' (min (g x) (Min (g ` F)))\"\n by (simp add: plus_tropical_min_def)\n have min_eq: \"min (g x) (Min (g ` F)) = Min (g ` insert x F)\"\n using insert.hyps(1,2,3) by (simp add: Min_insert)\n show ?case\n using step ih combine min_eq by simp\nqed","source":"tropical_resource_typing/tropical_v2","theorem":"tropm_sum_empty","id":200024,"goal":"\"tropm_sum g {} = PosInf\" by (simp add: tropm_sum_def zero_tropical_min_def) lemma tropm_sum_singleton [simp]: \"tropm_sum g {x} = Fin' (g x)\" by (simp add: tropm_sum_def zero_tropical_min_def plus_tropical_min_def) lemma tropm_sum_insert: \"finite S \\ x \\ S \\ tropm_sum g (insert x S) = Fin' (g x) + tropm_sum g S\" by (simp add: tropm_sum_def sum.insert) lemma tropm_sum_eq_Min: assumes \"finite S\" \"S \\ {}\" shows \"tropm_sum g S = Fin' (Min (g ` S))\" using assms","context":["simp","case","induction","induct","rule","by","qed","proof","show","have"]} +{"prover":"Isabelle","tactic_proof":"proof -\n have ne: \"S \\ {}\" using assms by auto\n have \"tropm_sum g S = Fin' (Min (g ` S))\"\n by (rule tropm_sum_eq_Min[OF assms(1) ne])\n thus ?thesis\n by (simp add: Min_le[OF finite_imageI[OF assms(1)] imageI[OF assms(2)]])\nqed","source":"tropical_resource_typing/tropical_v2","theorem":"tropm_sum_le_member","id":200025,"goal":"assumes \"finite S\" \"x \\ S\" shows \"tropm_sum g S \\ Fin' (g x)\"","context":["simp","auto","rule","by","qed","proof","have"]} +{"prover":"Isabelle","tactic_proof":"proof -\n have neT: \"T \\ {}\" using assms(2,3) by auto\n have fS: \"finite S\" by (rule finite_subset[OF assms(2) assms(1)])\n have \"tropm_sum g S = Fin' (Min (g ` S))\"\n by (rule tropm_sum_eq_Min[OF fS assms(3)])\n moreover have \"tropm_sum g T = Fin' (Min (g ` T))\"\n by (rule tropm_sum_eq_Min[OF assms(1) neT])\n moreover have \"Min (g ` T) \\ Min (g ` S)\"\n proof (rule Min_antimono)\n show \"g ` S \\ g ` T\" using assms(2) by (rule image_mono)\n show \"g ` S \\ {}\" using assms(3) by simp\n show \"finite (g ` T)\" using assms(1) by (rule finite_imageI)\n qed\n ultimately show ?thesis by simp\nqed","source":"tropical_resource_typing/tropical_v2","theorem":"tropm_sum_mono_subset","id":200026,"goal":"assumes \"finite T\" \"S \\ T\" \"S \\ {}\" shows \"tropm_sum g T \\ tropm_sum g S\"","context":["simp","auto","rule","by","qed","proof","show","have"]} +{"prover":"Isabelle","tactic_proof":" by simp","source":"tropical_resource_typing/tropical_matrices_full","theorem":"trop_mat_id_diag","id":200027,"goal":"\"trop_mat_id n i i = Fin 0\" by (simp add: trop_mat_id_def) lemma trop_mat_id_off_diag [simp]: \"i \\ j \\ trop_mat_id n i j = NegInf\" by (simp add: trop_mat_id_def) lemma tropm_mat_id_diag [simp]: \"tropm_mat_id n i i = Fin' 0\" by (simp add: tropm_mat_id_def) lemma tropm_mat_id_off_diag [simp]: \"i \\ j \\ tropm_mat_id n i j = PosInf\" by (simp add: tropm_mat_id_def) (* ------------------------------------------------------------------ *) subsection \\3 Pointwise Addition (Join)\\ (* ------------------------------------------------------------------ *) text \\ Pointwise tropical addition: entry-wise @{text max} for max-plus, @{text min} for min-plus. Also written @{text \"\\\"} in the prose. \\ definition trop_mat_add :: \"nat \\ trop_mat \\ trop_mat \\ trop_mat\" where \"trop_mat_add n A B i j \\ A i j + B i j\" definition tropm_mat_add :: \"nat \\ tropm_mat \\ tropm_mat \\ tropm_mat\" where \"tropm_mat_add n A B i j \\ A i j + B i j\" (* ------------------------------------------------------------------ *) subsection \\4 Tropical Matrix Multiplication\\ (* ------------------------------------------------------------------ *) text \\ @{text \"trop_mat_mul n A B i j = \\_{k < n} A i k * B k j\"} The sum is the tropical (= max-plus) sum, which equals @{term max} over the finite set @{text \"{..)\"} is the @{class comm_monoid_add} fold, so it implements @{text trop_add} with identity @{text NegInf}. \\ definition trop_mat_mul :: \"nat \\ trop_mat \\ trop_mat \\ trop_mat\" where \"trop_mat_mul n A B i j \\ \\ k \\ {.. tropm_mat \\ tropm_mat \\ tropm_mat\" where \"tropm_mat_mul n A B i j \\ \\ k \\ {..5 Matrix Close: I \\ A\\ (* ------------------------------------------------------------------ *) text \\ The close of @{text A} is @{text \"I \\ A\"} — entrywise max/min with the identity matrix. Adding the identity ensures there is always a weight for the zero-hop path (the empty walk staying at a node). \\ definition trop_mat_close :: \"nat \\ trop_mat \\ trop_mat\" where \"trop_mat_close n A i j \\ A i j + trop_mat_id n i j\" definition tropm_mat_close :: \"nat \\ tropm_mat \\ tropm_mat\" where \"tropm_mat_close n A i j \\ A i j + tropm_mat_id n i j\" lemma trop_mat_close_diag [simp]: \"trop_mat_close n A i i = A i i + Fin 0\" by (simp add: trop_mat_close_def) lemma trop_mat_close_off_diag [simp]: \"i \\ j \\ trop_mat_close n A i j = A i j + NegInf\" by (simp add: trop_mat_close_def trop_mat_id_def) (* ------------------------------------------------------------------ *) subsection \\6 Matrix Power\\ (* ------------------------------------------------------------------ *) text \\ Right-iterated matrix multiplication: @{text \"A^0 = I\"}, @{text \"A^{Suc k} = A^k \\ A\"}. Right multiplication is used because the walk-induction in @{text trop_mat_pow_eq_sum_walks} appends one edge at a time on the right. \\ fun trop_mat_pow :: \"nat \\ trop_mat \\ nat \\ trop_mat\" where \"trop_mat_pow n A 0 = trop_mat_id n\" | \"trop_mat_pow n A (Suc k) = trop_mat_mul n (trop_mat_pow n A k) A\" fun tropm_mat_pow :: \"nat \\ tropm_mat \\ nat \\ tropm_mat\" where \"tropm_mat_pow n A 0 = tropm_mat_id n\" | \"tropm_mat_pow n A (Suc k) = tropm_mat_mul n (tropm_mat_pow n A k) A\" (* ================================================================== *) section \\Part II Basic Matrix Algebraic Laws\\ (* ================================================================== *) (* ------------------------------------------------------------------ *) subsection \\7 Auxiliary: Tropical Sum over Unit Interval\\ (* ------------------------------------------------------------------ *) text \\ Singleton tropical sums simplify matrix identity laws. \\ lemma trop_sum_singleton_lt: \"(\\ k \\ {..<1 :: nat}. f k) = f 0\"","context":["simp","by"]} +{"prover":"Isabelle","tactic_proof":"proof -\n assume hi: \"i < n\" and hj: \"j < n\"\n have \"trop_mat_mul n A (trop_mat_id n) i j\n = (\\ k \\ {.. = (\\ k \\ {.. = (\\ k \\ {.. = A i j * Fin 0\"\n using hj by (simp add: sum.delta[OF finite_lessThan])\n also have \"\\ = A i j\"\n by (simp add: times_tropical_def)\n finally show ?thesis .\nqed","source":"tropical_resource_typing/tropical_matrices_full","theorem":"trop_mat_mul_id_right","id":200028,"goal":"\"i < n \\ j < n \\ trop_mat_mul n A (trop_mat_id n) i j = A i j\"","context":["simp","simp_all","rule","by","qed","proof","show","have","assume","sum.cong","sum.delta"]} +{"prover":"Isabelle","tactic_proof":"proof -\n assume hi: \"i < n\" and hj: \"j < n\"\n have \"trop_mat_mul n (trop_mat_id n) A i j\n = (\\ k \\ {.. = (\\ k \\ {.. = (\\ k \\ {.. = Fin 0 * A i j\"\n using hi by (simp add: sum.delta[OF finite_lessThan])\n also have \"\\ = A i j\"\n by (simp add: times_tropical_def)\n finally show ?thesis .\nqed","source":"tropical_resource_typing/tropical_matrices_full","theorem":"trop_mat_mul_id_left","id":200029,"goal":"\"i < n \\ j < n \\ trop_mat_mul n (trop_mat_id n) A i j = A i j\"","context":["simp","simp_all","rule","by","qed","proof","show","have","assume","sum.cong","sum.delta"]} +{"prover":"Isabelle","tactic_proof":"proof -\n assume hi: \"i < n\" and hj: \"j < n\"\n have \"trop_mat_mul n (trop_mat_mul n A B) C i j\n = (\\ l \\ {.. k \\ {.. = (\\ l \\ {.. k \\ {.. = (\\ k \\ {.. l \\ {.. = (\\ k \\ {.. l \\ {.. = trop_mat_mul n A (trop_mat_mul n B C) i j\"\n by (simp add: trop_mat_mul_def)\n finally show ?thesis .\nqed","source":"tropical_resource_typing/tropical_matrices_full","theorem":"trop_mat_mul_assoc","id":200030,"goal":"\"i < n \\ j < n \\ trop_mat_mul n (trop_mat_mul n A B) C i j = trop_mat_mul n A (trop_mat_mul n B C) i j\"","context":["simp","rule","by","qed","proof","show","have","assume","sum.cong","sum.swap"]} +{"prover":"Isabelle","tactic_proof":" by simp","source":"tropical_resource_typing/tropical_matrices_full","theorem":"trop_mat_pow_zero","id":200031,"goal":"\"trop_mat_pow n A 0 = trop_mat_id n\"","context":["simp","by"]} +{"prover":"Isabelle","tactic_proof":" by simp","source":"tropical_resource_typing/tropical_matrices_full","theorem":"trop_mat_pow_one","id":200032,"goal":"\"i < n \\ j < n \\ trop_mat_pow n A 1 i j = A i j\" by (simp add: trop_mat_mul_id_left) lemma trop_mat_pow_Suc_right: \"trop_mat_pow n A (Suc k) = trop_mat_mul n (trop_mat_pow n A k) A\"","context":["simp","by"]} +{"prover":"Isabelle","tactic_proof":"proof (induction q arbitrary: i j)\n case 0\n then show ?case\n by (simp add: trop_mat_mul_id_right)\nnext\n case (Suc q)\n have \"trop_mat_pow n A (p + Suc q) i j\n = trop_mat_mul n (trop_mat_pow n A (p + q)) A i j\"\n by simp\n also have \"\\ = trop_mat_mul n (trop_mat_mul n (trop_mat_pow n A p) (trop_mat_pow n A q)) A i j\"\n proof (unfold trop_mat_mul_def)\n show \"(\\k\\{..k\\{.. {.. j < n \\ trop_mat_pow n A (p + q) i j = trop_mat_mul n (trop_mat_pow n A p) (trop_mat_pow n A q) i j\"","context":["simp","case","induction","induct","rule","by","qed","proof","unfold","show","have","assume","fix","sum.cong"]} +{"prover":"Isabelle","tactic_proof":" unfolding walks_def\n by (auto simp: length_Suc_conv hd_conv_nth last_conv_nth)","source":"tropical_resource_typing/tropical_matrices_full","theorem":"walks_0","id":200034,"goal":"\"i < n \\ walks n 0 i i = {[i]}\"","context":["simp","auto","by","unfold","unfolding"]} +{"prover":"Isabelle","tactic_proof":" unfolding walks_def\n by (auto simp: length_Suc_conv)","source":"tropical_resource_typing/tropical_matrices_full","theorem":"walks_0_empty_if_neq","id":200035,"goal":"\"i \\ j \\ walks n 0 i j = {}\"","context":["simp","auto","by","unfold","unfolding"]} +{"prover":"Isabelle","tactic_proof":" unfolding walks_le_def\n by (simp add: walks_0)","source":"tropical_resource_typing/tropical_matrices_full","theorem":"walks_le_0","id":200036,"goal":"\"i < n \\ walks_le n 0 i i = {[i]}\"","context":["simp","by","unfold","unfolding"]} +{"prover":"Isabelle","tactic_proof":" unfolding walks_def\n by auto","source":"tropical_resource_typing/tropical_matrices_full","theorem":"walk_nonempty","id":200037,"goal":"\"w \\ walks n k i j \\ w \\ []\"","context":["auto","by","unfold","unfolding"]} +{"prover":"Isabelle","tactic_proof":" unfolding walks_def by simp","source":"tropical_resource_typing/tropical_matrices_full","theorem":"walk_hd","id":200038,"goal":"\"w \\ walks n k i j \\ hd w = i\"","context":["simp","by","unfold","unfolding"]} +{"prover":"Isabelle","tactic_proof":" unfolding walks_def by simp","source":"tropical_resource_typing/tropical_matrices_full","theorem":"walk_last","id":200039,"goal":"\"w \\ walks n k i j \\ last w = j\"","context":["simp","by","unfold","unfolding"]} +{"prover":"Isabelle","tactic_proof":" unfolding walks_def by simp","source":"tropical_resource_typing/tropical_matrices_full","theorem":"walk_vertices_bounded","id":200040,"goal":"\"w \\ walks n k i j \\ set w \\ {.. walks n k i j\"\n have ne: \"w \\ []\" using walk_nonempty[OF h] .\n have si: \"i \\ set w\" by (metis walk_hd[OF h] hd_in_set ne)\n have sj: \"j \\ set w\" by (metis walk_last[OF h] last_in_set ne)\n show ?thesis using walk_vertices_bounded[OF h] si sj by auto\nqed","source":"tropical_resource_typing/tropical_matrices_full","theorem":"walks_bounds","id":200041,"goal":"\"w \\ walks n k i j \\ i < n \\ j < n\"","context":["auto","by","qed","proof","show","have","assume","metis"]} +{"prover":"Isabelle","tactic_proof":"proof -\n have sub: \"walks n k i j \\ {w . length w = Suc k \\ set w \\ {.. set w \\ {.. {.. length w = Suc k}\"\n by blast\n have \"finite ({.. {.. length w = Suc k}\"\n by (rule finite_lists_length_eq)\n with set_eq have \"finite {w :: nat list . length w = Suc k \\ set w \\ {.. {w. length w = Suc (Suc k) \\ hd w = i \\ last w = j \\ set w \\ {..\n w \\ (\\ m \\ {..w. w @ [j]) ` {w. length w = Suc k \\ hd w = i \\ last w = m \\ set w \\ {.. {w. last (butlast w) = m \\ j < n})\"\n proof\n assume hw: \"w \\ {w. length w = Suc (Suc k) \\ hd w = i \\ last w = j \\ set w \\ {.. {.. []\" using hlen by auto","source":"tropical_resource_typing/tropical_matrices_full","theorem":"walks_Suc","id":200044,"goal":"\"walks n (Suc k) i j = (\\ m \\ {..w. w @ [j]) ` walks n k i m \\ {w . last (butlast w) = m \\ j < n})\"","context":["simp","simp_all","auto","rule","by","proof","unfold","unfolding","show","have","assume","fix"]} +{"prover":"Isabelle","tactic_proof":" unfolding walks_def\nproof (rule set_eqI)\n fix w :: \"nat list\"\n show \"w \\ {w. length w = Suc (Suc k) \\ hd w = i \\ last w = j \\ set w \\ {..\n w \\ {w @ [j] | w m. m < n \\ w \\ {w. length w = Suc k \\ hd w = i \\ last w = m \\ set w \\ {.. j < n}\"\n proof\n assume hw: \"w \\ {w. length w = Suc (Suc k) \\ hd w = i \\ last w = j \\ set w \\ {.. {.. []\" using hlen by auto\n have hbne: \"butlast w \\ []\"","source":"tropical_resource_typing/tropical_matrices_full","theorem":"walks_Suc_factored","id":200045,"goal":"\"walks n (Suc k) i j = { w @ [j] | w m . m < n \\ w \\ walks n k i m \\ j < n }\"","context":["simp","simp_all","auto","rule","by","proof","unfold","unfolding","show","have","assume","fix"]} +{"prover":"Isabelle","tactic_proof":" by simp","source":"tropical_resource_typing/tropical_matrices_full","theorem":"path_weight_singleton","id":200046,"goal":"\"path_weight A [v] = 1\"","context":["simp","by"]} +{"prover":"Isabelle","tactic_proof":" by simp","source":"tropical_resource_typing/tropical_matrices_full","theorem":"path_weight_cons","id":200047,"goal":"\"path_weight A (u # v # xs) = A u v * path_weight A (v # xs)\"","context":["simp","by"]} +{"prover":"Isabelle","tactic_proof":"proof (induction w1)\n case Nil then show ?case by simp\nnext\n case (Cons u rest)\n show ?case\n proof (cases rest)\n case Nil\n have \"path_weight A (u # w2) = A u (hd w2) * path_weight A w2\"\n using Cons.prems(2) by (cases w2) auto\n then show ?thesis using Nil by simp\n next\n case (Cons v t)\n have \"path_weight A ((u # v # t) @ w2)\n = A u v * path_weight A ((v # t) @ w2)\"\n by simp\n also have \"\\ = A u v * (path_weight A ((v # t) @ [hd w2]) * path_weight A w2)\"\n using Cons.IH Cons.prems(2) local.Cons by simp\n also have \"\\ = path_weight A ((u # v # t) @ [hd w2]) * path_weight A w2\"\n by (simp add: mult.assoc local.Cons)\n finally show ?thesis\n using local.Cons \\rest = v # t\\ by simp\n qed\nqed","source":"tropical_resource_typing/tropical_matrices_full","theorem":"path_weight_append","id":200048,"goal":"\"\\ w1 \\ []; w2 \\ [] \\ \\ path_weight A (w1 @ w2) = path_weight A (w1 @ [hd w2]) * path_weight A w2\"","context":["simp","auto","cases","case","induction","induct","by","qed","proof","show","have"]} +{"prover":"Isabelle","tactic_proof":"proof (induction w)\n case Nil then show ?case by simp\nnext\n case (Cons u rest)\n show ?case\n proof (cases rest)\n case Nil\n then show ?thesis by simp\n next\n case (Cons v' t)\n have \"path_weight A ((u # v' # t) @ [v])\n = A u v' * path_weight A ((v' # t) @ [v])\"\n by simp\n also have \"\\ = A u v' * (path_weight A (v' # t) * A (last (v' # t)) v)\"\n using Cons.IH local.Cons by simp\n also have \"\\ = path_weight A (u # v' # t) * A (last (u # v' # t)) v\"\n by (simp add: mult.assoc)\n finally show ?thesis by (simp add: local.Cons)\n qed\nqed","source":"tropical_resource_typing/tropical_matrices_full","theorem":"path_weight_snoc","id":200049,"goal":"\"w \\ [] \\ path_weight A (w @ [v]) = path_weight A w * A (last w) v\"","context":["simp","cases","case","induction","induct","by","qed","proof","show","have"]} +{"prover":"Isabelle","tactic_proof":"proof (induction w)\n case Nil then show ?case by simp\nnext\n case (Cons u rest)\n show ?case\n proof (cases rest)\n case Nil\n then show ?thesis by simp\n next\n case (Cons v' t)\n have \"path_weightm A ((u # v' # t) @ [v])\n = A u v' * path_weightm A ((v' # t) @ [v])\"\n by simp\n also have \"\\ = A u v' * (path_weightm A (v' # t) * A (last (v' # t)) v)\"\n using Cons.IH local.Cons by simp\n also have \"\\ = path_weightm A (u # v' # t) * A (last (u # v' # t)) v\"\n by (simp add: mult.assoc)\n finally show ?thesis by (simp add: local.Cons)\n qed\nqed","source":"tropical_resource_typing/tropical_matrices_full","theorem":"path_weightm_snoc","id":200050,"goal":"\"w \\ [] \\ path_weightm A (w @ [v]) = path_weightm A w * A (last w) v\"","context":["simp","cases","case","induction","induct","by","qed","proof","show","have"]} +{"prover":"Isabelle","tactic_proof":"proof -\n have step: \"c * a + c * b = c * b\"\n proof -\n have \"c * a + c * b = c * (a + b)\"\n by (simp add: distrib_left)\n also have \"\\ = c * b\"\n using assms by (simp add: trop_add_le_iff)\n finally show ?thesis .\n qed\n thus ?thesis by (simp add: trop_add_le_iff)\nqed","source":"tropical_resource_typing/tropical_matrices_full","theorem":"trop_mul_le_mul_right","id":200051,"goal":"assumes \"(a :: tropical) \\ b\" shows \"c * a \\ c * b\"","context":["simp","by","qed","proof","show","have"]} +{"prover":"Isabelle","tactic_proof":"proof -\n have decomp: \"trop_walks_sum A T =\n path_weight A w' + trop_walks_sum A (T - {w'})\"\n unfolding trop_walks_sum_def\n using assms by (subst sum.remove) auto\n have \"path_weight A w' \\ path_weight A w' + trop_walks_sum A (T - {w'})\"\n proof -\n have \"path_weight A w' + (path_weight A w' + trop_walks_sum A (T - {w'}))\n = path_weight A w' + trop_walks_sum A (T - {w'})\"\n by (simp add: add.assoc[symmetric] tropical_add_idem)\n thus ?thesis by (simp add: trop_add_le_iff)\n qed\n thus ?thesis using decomp by simp\nqed","source":"tropical_resource_typing/tropical_matrices_full","theorem":"trop_walks_sum_ge_member","id":200052,"goal":"assumes \"w' \\ T\" \"finite T\" shows \"path_weight A w' \\ trop_walks_sum A T\"","context":["simp","auto","by","qed","proof","subst","unfold","unfolding","have"]} +{"prover":"Isabelle","tactic_proof":"proof -\n have fS: \"finite S\" by (rule finite_subset[OF assms(2) assms(1)])\n show ?thesis\n proof (induction S rule: finite_induct[OF fS])\n case empty\n then show ?case by (simp add: trop_walks_sum_def NegInf_le)\n next\n case (insert w S')\n have hw_T: \"w \\ T\" using insert.prems assms(2) by auto\n have hS'_sub: \"S' \\ T\" using insert.prems assms(2) by auto\n have expand_S: \"trop_walks_sum A (insert w S') =\n path_weight A w + trop_walks_sum A S'\"\n unfolding trop_walks_sum_def\n using insert.hyps(1,2) by (rule sum.insert)\n have hw_le: \"path_weight A w \\ trop_walks_sum A T\"\n using trop_walks_sum_ge_member[OF hw_T assms(1)] .\n have hS'_le: \"trop_walks_sum A S' \\ trop_walks_sum A T\"\n using insert.IH[OF hS'_sub] .\n ","source":"tropical_resource_typing/tropical_matrices_full","theorem":"trop_walks_sum_mono_subset","id":200053,"goal":"assumes \"finite T\" \"S \\ T\" shows \"trop_walks_sum A S \\ trop_walks_sum A T\"","context":["simp","auto","case","induction","induct","rule","by","qed","proof","unfold","unfolding","show","have"]} +{"prover":"Isabelle","tactic_proof":"proof (induction S rule: finite_induct[OF assms(1)])\n case empty\n then show ?case by (simp add: trop_walks_sum_def NegInf_le)\nnext\n case (insert w S')\n have expand_S: \"trop_walks_sum A (insert w S') =\n path_weight A w + trop_walks_sum A S'\"\n unfolding trop_walks_sum_def\n using insert.hyps(1,2) by (rule sum.insert)\n obtain w' where hw': \"w' \\ T\" \"path_weight A w \\ path_weight A w'\"\n using dominated insert.prems by auto\n have hw_le: \"path_weight A w \\ trop_walks_sum A T\"\n using hw' trop_walks_sum_ge_member[OF hw'(1) assms(2)] le_trans by blast\n have hS'_le: \"trop_walks_sum A S' \\ trop_walks_sum A T\"\n using insert.IH dominated insert.prems by auto\n have \"path_weight A w + trop_walks_sum A S' \\\n trop_walks_sum A T + trop_walks_","source":"tropical_resource_typing/tropical_matrices_full","theorem":"trop_walks_sum_dominated","id":200054,"goal":"assumes \"finite S\" \"finite T\" assumes dominated: \"\\ w \\ S. \\ w' \\ T. path_weight A w \\ path_weight A w'\" shows \"trop_walks_sum A S \\ trop_walks_sum A T\"","context":["simp","auto","blast","case","induction","induct","rule","by","qed","proof","unfold","unfolding","show","have","obtain"]} +{"prover":"Isabelle","tactic_proof":"proof -\n (* Find indices p < q with w!p = w!q = v, p > 0 (from tl), q < length w - 1 (from butlast) *)\n have hne: \"w \\ []\" using hv1 by auto\n from hv1 obtain q where hq_bound: \"q < length (butlast w)\" and hq_val: \"(butlast w) ! q = v\"\n by (meson in_set_conv_nth)\n from hv2 obtain p0 where hp0_bound: \"p0 < length (tl w)\" and hp0_val: \"(tl w) ! p0 = v\"\n by (meson in_set_conv_nth)\n (* Convert to w-indices *)\n let ?p = \"Suc p0\"\n let ?q = \"q\"\n have hp_lt: \"?p < length w\" using hp0_bound by simp\n have hp_val: \"w ! ?p = v\" using hp0_val nth_tl[OF hp0_bound] by simp\n have hq_lt: \"?q < length w - 1\" using hq_bound by simp\n have hq_val': \"w ! ?q = v\" using hq_val nth_butlast[OF hq_bound] by simp\n (* Build two cases: either p < q (good) or q ≤ p; in either case get p' < q' *)\n","source":"tropical_resource_typing/tropical_matrices_full","theorem":"path_weight_cycle_excise","id":200055,"goal":"assumes hv1: \"v \\ set (butlast w)\" assumes hv2: \"v \\ set (tl w)\" assumes hnpc: \"no_pos_cycle n A\" assumes hw_in: \"w \\ walks n k i j\" shows \"\\ w'. path_weight A w' \\ path_weight A w \\ length w' < length w \\ w' \\ [] \\ hd w' = hd w \\ last w' = last w \\ set w' \\ {.. = 1\" by simp\n also have \"\\ = Fin 0\" by (simp add: one_tropical_def)\n finally show ?thesis .\n qed\n show ?thesis using lhs rhs by simp\n next\n case False\n then show ?thesis\n by (simp add: trop_walks_sum_def walks_0_empty_if_neq\n trop_mat_","source":"tropical_resource_typing/tropical_matrices_full","theorem":"trop_mat_pow_eq_sum_walks","id":200056,"goal":"assumes \"i < n\" \"j < n\" shows \"trop_mat_pow n A k i j = trop_walks_sum A (walks n k i j)\" using assms","context":["simp","auto","cases","case","induction","induct","rule","apply","by","qed","proof","intro","rewrite","unfold","unfolding","show","have","sum.cong","metis"]} +{"prover":"Isabelle","tactic_proof":"proof (induction k arbitrary: i j)\n case 0\n show ?case\n proof (cases \"i = j\")\n case True\n have \"j < n\" using \"0.prems\"(2) .\n hence walks_eq: \"walks n 0 j j = {[j]}\" by (rule walks_0)\n have lhs: \"tropm_mat_pow n A 0 i j = Fin' 0\"\n using True by (simp add: tropm_mat_id_def)\n have rhs: \"tropm_walks_sum A (walks n 0 i j) = Fin' 0\"\n proof -\n have \"tropm_walks_sum A (walks n 0 i j) = path_weightm A [j]\"\n using True walks_eq by (simp add: tropm_walks_sum_def)\n also have \"\\ = 1\" by simp\n also have \"\\ = Fin' 0\" by (simp add: one_tropical_min_def)\n finally show ?thesis .\n qed\n show ?thesis using lhs rhs by simp\n next\n case False\n then show ?thesis\n by (simp add: tropm_walks_sum_def walks_0_empty_if_neq\n ","source":"tropical_resource_typing/tropical_matrices_full","theorem":"tropm_mat_pow_eq_sum_walks","id":200057,"goal":"assumes \"i < n\" \"j < n\" shows \"tropm_mat_pow n A k i j = tropm_walks_sum A (walks n k i j)\" using assms","context":["simp","auto","cases","case","induction","induct","rule","by","qed","proof","intro","unfold","unfolding","show","have","sum.cong","metis"]} +{"prover":"Isabelle","tactic_proof":"proof (induction k)\n case 0\n show ?case by (simp add: trop_mat_close_def trop_mat_id_def)\nnext\n case (Suc k)\n (* Expand (I\\A)^{Suc k} as a matrix product *)\n have \"(trop_mat_pow n (trop_mat_close n A) (Suc k)) i j\n = (\\ l \\ {.. = (\\ l \\ {.. m \\ {..k}. trop_mat_pow n A m i l) *\n trop_mat_close n A l j)\"\n by (rule sum.cong, simp, simp add: Suc.IH)\n (* Unfold close: (I\\A) l j = A l j + I l j, then distribute *)\n also have \"\\ = (\\ l \\ {.. m \\ {..k}. trop_mat_pow n A m i l) * A l j) +\n ","source":"tropical_resource_typing/tropical_matrices_full","theorem":"trop_mat_close_expand","id":200058,"goal":"\"i < n \\ j < n \\ trop_mat_close n A i j = trop_mat_add n (trop_mat_id n) A i j\" by (simp add: trop_mat_close_def trop_mat_add_def add.commute) theorem trop_mat_pow_close_eq_sum_pow: assumes hi: \"i < n\" and hj: \"j < n\" shows \"trop_mat_pow n (trop_mat_close n A) k i j = (\\ m \\ {..k}. trop_mat_pow n A m i j)\"","context":["simp","simp_all","auto","case","induction","induct","rule","apply","by","qed","proof","subst","unfold","show","have","split","sum.cong","sum.swap"]} +{"prover":"Isabelle","tactic_proof":"proof -\n have \"trop_mat_pow n (trop_mat_close n A) k i j =\n (\\ m \\ {..k}. trop_mat_pow n A m i j)\"\n using assms by (rule trop_mat_pow_close_eq_sum_pow)\n also have \"\\ = (\\ m \\ {..k}. trop_walks_sum A (walks n m i j))\"\n by (rule sum.cong) (simp_all add: trop_mat_pow_eq_sum_walks assms)\n also have \"\\ = trop_walks_sum A (\\ m \\ {..k}. walks n m i j)\"\n by (rule sum.UNION_disjoint[symmetric])\n (auto simp: finite_walks walks_def)\n also have \"\\ = trop_walks_sum A (walks_le n k i j)\"\n by (simp add: walks_le_def)\n finally show ?thesis .\nqed","source":"tropical_resource_typing/tropical_matrices_full","theorem":"trop_mat_pow_close_eq_sum_walks_le","id":200059,"goal":"assumes \"i < n\" \"j < n\" shows \"trop_mat_pow n (trop_mat_close n A) k i j = trop_walks_sum A (walks_le n k i j)\" (* proof sketch: trop_mat_pow_close_eq_sum_pow + trop_mat_pow_eq_sum_walks + walks_le definition *)","context":["simp","simp_all","auto","rule","by","qed","proof","show","have","sum.cong"]} +{"prover":"Isabelle","tactic_proof":"proof -\n have \"simple_walks n i j \\ {w . set w \\ {.. distinct w}\"\n unfolding simple_walks_def walks_def by auto\n moreover have \"finite {w :: nat list . set w \\ {.. distinct w}\"\n by (rule finite_subset[OF _ finite_lists_length_le[OF finite_lessThan]])\n (auto simp: length_remdups_leq)\n ultimately show ?thesis by (rule finite_subset)\nqed","source":"tropical_resource_typing/tropical_matrices_full","theorem":"simple_walks_finite","id":200060,"goal":"\"finite (simple_walks n i j)\"","context":["simp","auto","rule","by","qed","proof","unfold","unfolding","show","have"]} +{"prover":"Isabelle","tactic_proof":"proof (induction \"length w\" arbitrary: k i j w rule: less_induct)\n case (less w)\n show ?case\n proof (cases \"distinct w\")\n case True\n have \"w \\ simple_walks n i j\"\n unfolding simple_walks_def\n using less(2) True by auto\n thus ?thesis by (intro bexI[of _ w]) simp\n next\n case False\n (* Decompose w at a repeated vertex *)\n obtain xs v ys zs where hdecomp: \"w = xs @ v # ys @ v # zs\"\n using not_distinct_decomp[OF False] by blast\n (* First occurrence of v (at position length xs) is in butlast w *)\n have hv1: \"v \\ set (butlast w)\"\n proof -\n have hpos: \"length xs < length (butlast w)\"\n by (simp add: hdecomp)\n have \"butlast w ! length xs = v\"\n by (simp add: hdecomp nth_butlast nth_append)\n thus ?thesis by (metis hpos ","source":"tropical_resource_typing/tropical_matrices_full","theorem":"cycle_shortcutting","id":200061,"goal":"assumes hnpc: \"no_pos_cycle n A\" assumes hw: \"w \\ walks n k i j\" shows \"\\ w' \\ simple_walks n i j. path_weight A w \\ path_weight A w'\"","context":["simp","simp_all","auto","blast","cases","case","induction","induct","rule","apply","by","qed","proof","intro","unfold","unfolding","show","have","obtain","metis"]} +{"prover":"Isabelle","tactic_proof":"proof (rule antisym)\n (* (\\) direction: each walk in walks_le is dominated by a simple walk *)\n show \"trop_mat_pow n (trop_mat_close n A) (n-1) i j \\\n trop_walks_sum A (simple_walks n i j)\"\n proof -\n have lhs: \"trop_mat_pow n (trop_mat_close n A) (n-1) i j =\n trop_walks_sum A (walks_le n (n-1) i j)\"\n using assms(1,2) by (rule trop_mat_pow_close_eq_sum_walks_le)\n have dominated: \"\\ w \\ walks_le n (n-1) i j.\n \\ w' \\ simple_walks n i j. path_weight A w \\ path_weight A w'\"\n proof (intro ballI)\n fix w assume hw: \"w \\ walks_le n (n-1) i j\"\n then obtain m where \"m \\ n - 1\" \"w \\ walks n m i j\"\n unfolding walks_le_def by auto\n thus \"\\ w' \\ simple_walks n i j. p","source":"tropical_resource_typing/tropical_matrices_full","theorem":"floyd_warshall","id":200062,"goal":"assumes \"i < n\" \"j < n\" assumes \"no_pos_cycle n A\" shows \"trop_mat_pow n (trop_mat_close n A) (n-1) i j = trop_walks_sum A (simple_walks n i j)\"","context":["simp","auto","blast","rule","by","qed","proof","intro","unfold","unfolding","show","have","obtain","assume","fix","rule antisym","omega"]} +{"prover":"Isabelle","tactic_proof":"proof -\n assume hi: \"i < n\" and hj: \"j < n\"\n have \"tropm_mat_mul n A (tropm_mat_id n) i j\n = (\\ k \\ {.. = (\\ k \\ {.. = A i j * Fin' 0\"\n by (simp add: sum.delta[OF finite_lessThan] hj zero_tropical_min_def\n times_tropical_min_def)\n also have \"\\ = A i j\"\n by (simp add: times_tropical_min_def one_tropical_min_def)\n finally show ?thesis .\nqed","source":"tropical_resource_typing/tropical_matrices_full","theorem":"tropm_add_le_left","id":200063,"goal":"by (simp add: tropm_add_le_iff add.assoc tropm_add_idem) (* Min-plus identity matrix: right-multiply by I leaves A unchanged. *) lemma tropm_mat_mul_id_right: \"i < n \\ j < n \\ tropm_mat_mul n A (tropm_mat_id n) i j = A i j\"","context":["simp","simp_all","rule","by","qed","proof","show","have","assume","sum.cong","sum.delta"]} +{"prover":"Isabelle","tactic_proof":"proof -\n have step: \"c * a + c * b = c * b\"\n proof -\n have \"c * a + c * b = c * (a + b)\"\n by (simp add: distrib_left)\n also have \"\\ = c * b\"\n using assms by (simp add: tropm_add_le_iff)\n finally show ?thesis .\n qed\n thus ?thesis by (simp add: tropm_add_le_iff)\nqed","source":"tropical_resource_typing/tropical_matrices_full","theorem":"tropm_mul_le_mul_right","id":200064,"goal":"assumes \"(a :: tropical_min) \\ b\" shows \"c * a \\ c * b\"","context":["simp","by","qed","proof","show","have"]} +{"prover":"Isabelle","tactic_proof":"proof -\n have \"b * 1 \\ b * a\"\n using tropm_mul_le_mul_right[OF assms] .\n thus ?thesis by simp\nqed","source":"tropical_resource_typing/tropical_matrices_full","theorem":"tropm_one_le_mul_of_ge_one","id":200065,"goal":"assumes \"(1 :: tropical_min) \\ a\" shows \"(b :: tropical_min) \\ b * a\"","context":["simp","by","qed","proof","have"]} +{"prover":"Isabelle","tactic_proof":"proof -\n have decomp: \"tropm_walks_sum A T =\n path_weightm A w' + tropm_walks_sum A (T - {w'})\"\n unfolding tropm_walks_sum_def\n using assms by (subst sum.remove) auto\n thus ?thesis using tropm_add_le_left by simp\nqed","source":"tropical_resource_typing/tropical_matrices_full","theorem":"tropm_walks_sum_le_member","id":200066,"goal":"assumes \"w' \\ T\" \"finite T\" shows \"tropm_walks_sum A T \\ path_weightm A w'\"","context":["simp","auto","by","qed","proof","subst","unfold","unfolding","have"]} +{"prover":"Isabelle","tactic_proof":"proof -\n have fS: \"finite S\" using assms(1,2) by (rule finite_subset)\n show ?thesis\n proof (induction S rule: finite_induct[OF fS])\n case empty\n then show ?case by (simp add: tropm_walks_sum_def le_PosInf)\n next\n case (insert w S')\n have hw_T: \"w \\ T\" using insert.prems assms(2) by auto\n have hS'_sub: \"S' \\ T\" using insert.prems assms(2) by auto\n have expand_S: \"tropm_walks_sum A (insert w S') =\n path_weightm A w + tropm_walks_sum A S'\"\n unfolding tropm_walks_sum_def\n using insert.hyps(1,2) by (rule sum.insert)\n have hw_ge: \"tropm_walks_sum A T \\ path_weightm A w\"\n using tropm_walks_sum_le_member[OF hw_T assms(1)] .\n have hS'_ge: \"tropm_walks_sum A T \\ tropm_walks_sum A S'\"\n using insert.IH[OF hS'_sub]","source":"tropical_resource_typing/tropical_matrices_full","theorem":"tropm_walks_sum_mono_subset","id":200067,"goal":"assumes \"finite T\" \"S \\ T\" shows \"tropm_walks_sum A T \\ tropm_walks_sum A S\"","context":["simp","auto","blast","case","induction","induct","rule","by","qed","proof","unfold","unfolding","show","have","metis"]} +{"prover":"Isabelle","tactic_proof":"proof (induction S rule: finite_induct[OF assms(1)])\n case empty\n then show ?case by (simp add: tropm_walks_sum_def le_PosInf)\nnext\n case (insert w S')\n have expand_S: \"tropm_walks_sum A (insert w S') =\n path_weightm A w + tropm_walks_sum A S'\"\n unfolding tropm_walks_sum_def\n using insert.hyps(1,2) by (rule sum.insert)\n obtain w' where hw': \"w' \\ T\" \"path_weightm A w' \\ path_weightm A w\"\n using dominated insert.prems by auto\n have hw_ge: \"tropm_walks_sum A T \\ path_weightm A w\"\n using tropm_walks_sum_le_member[OF hw'(1) assms(2)]\n le_trans hw'(2) by blast\n have hS'_ge: \"tropm_walks_sum A T \\ tropm_walks_sum A S'\"\n using insert.IH dominated insert.prems by auto\n have \"tropm_walks_sum A T \\ path_weightm A w + tropm_walks_su","source":"tropical_resource_typing/tropical_matrices_full","theorem":"tropm_walks_sum_dominated","id":200068,"goal":"assumes \"finite S\" \"finite T\" assumes dominated: \"\\ w \\ S. \\ w' \\ T. path_weightm A w' \\ path_weightm A w\" shows \"tropm_walks_sum A T \\ tropm_walks_sum A S\"","context":["simp","auto","blast","case","induction","induct","rule","by","qed","proof","unfold","unfolding","show","have","obtain","metis"]} +{"prover":"Isabelle","tactic_proof":"proof -\n (* Find indices p < q with w!p = w!q = v — identical to max-plus *)\n have hne: \"w \\ []\" using hv1 by auto\n from hv1 obtain q where hq_bound: \"q < length (butlast w)\"\n and hq_val: \"(butlast w) ! q = v\"\n by (meson in_set_conv_nth)\n from hv2 obtain p0 where hp0_bound: \"p0 < length (tl w)\"\n and hp0_val: \"(tl w) ! p0 = v\"\n by (meson in_set_conv_nth)\n let ?p = \"Suc p0\"\n let ?q = \"q\"\n have hp_lt: \"?p < length w\" using hp0_bound by simp\n have hp_val: \"w ! ?p = v\" by (simp add: hp0_val nth_tl)\n have hq_lt: \"?q < length w - 1\" using hq_bound by simp\n have hq_val': \"w ! ?q = v\" by (simp add: hq_val nth_butlast)\n obtain p' q' where hp': \"p' < length w\" \"w ! p' = v\" \"0 < p'\"\n and hq': \"q' < leng","source":"tropical_resource_typing/tropical_matrices_full","theorem":"path_weightm_cycle_excise","id":200069,"goal":"assumes hv1: \"v \\ set (butlast w)\" assumes hv2: \"v \\ set (tl w)\" assumes hnnc: \"no_neg_cycle n A\" assumes hw_in: \"w \\ walks n k i j\" shows \"\\ w'. path_weightm A w' \\ path_weightm A w \\ length w' < length w \\ w' \\ [] \\ hd w' = hd w \\ last w' = last w \\ set w' \\ {.. simple_walksm n i j\"\n unfolding simple_walksm_def\n using less(2) True by auto\n thus ?thesis by (intro bexI[of _ w]) simp\n next\n case False\n obtain xs v ys zs where hdecomp: \"w = xs @ v # ys @ v # zs\"\n using not_distinct_decomp[OF False] by blast\n have hv1: \"v \\ set (butlast w)\"\n proof -\n have hpos: \"length xs < length (butlast w)\" by (simp add: hdecomp)\n have \"butlast w ! length xs = v\"\n by (simp add: hdecomp nth_butlast nth_append)\n thus ?thesis by (metis hpos nth_mem)\n qed\n have hv2: \"v \\ set (tl w)\"\n using hdecomp by (cases xs) (auto simp: set_append)\n obtain ","source":"tropical_resource_typing/tropical_matrices_full","theorem":"cycle_shortcutting_min","id":200070,"goal":"assumes hnnc: \"no_neg_cycle n A\" assumes hw: \"w \\ walks n k i j\" shows \"\\ w' \\ simple_walksm n i j. path_weightm A w' \\ path_weightm A w\"","context":["simp","simp_all","auto","blast","cases","case","induction","induct","rule","by","qed","proof","intro","unfold","unfolding","show","have","obtain","metis"]} +{"prover":"Isabelle","tactic_proof":"proof -\n have \"simple_walksm n i j \\ {w . set w \\ {.. distinct w}\"\n unfolding simple_walksm_def walks_def by auto\n moreover have \"finite {w :: nat list . set w \\ {.. distinct w}\"\n by (rule finite_subset[OF _ finite_lists_length_le[OF finite_lessThan]])\n (auto simp: length_remdups_leq)\n ultimately show ?thesis by (rule finite_subset)\nqed","source":"tropical_resource_typing/tropical_matrices_full","theorem":"simple_walksm_finite","id":200071,"goal":"\"finite (simple_walksm n i j)\"","context":["simp","auto","rule","by","qed","proof","unfold","unfolding","show","have"]} +{"prover":"Isabelle","tactic_proof":"proof (induction k)\n case 0\n show ?case by (simp add: tropm_mat_close_def tropm_mat_id_def)\nnext\n case (Suc k)\n have \"(tropm_mat_pow n (tropm_mat_close n A) (Suc k)) i j\n = (\\ l \\ {.. = (\\ l \\ {.. m \\ {..k}. tropm_mat_pow n A m i l) *\n tropm_mat_close n A l j)\"\n by (rule sum.cong, simp, simp add: Suc.IH)\n also have \"\\ = (\\ l \\ {.. m \\ {..k}. tropm_mat_pow n A m i l) * A l j) +\n (\\ l \\ {.. m \\ {..k}. tropm_mat_pow n A m i l) *\n tropm_mat_id n","source":"tropical_resource_typing/tropical_matrices_full","theorem":"tropm_mat_pow_close_eq_sum_pow","id":200072,"goal":"assumes hi: \"i < n\" and hj: \"j < n\" shows \"tropm_mat_pow n (tropm_mat_close n A) k i j = (\\ m \\ {..k}. tropm_mat_pow n A m i j)\"","context":["simp","simp_all","auto","case","induction","induct","rule","by","qed","proof","subst","show","have","split","sum.cong","sum.swap"]} +{"prover":"Isabelle","tactic_proof":"proof -\n have \"tropm_mat_pow n (tropm_mat_close n A) k i j =\n (\\ m \\ {..k}. tropm_mat_pow n A m i j)\"\n using assms by (rule tropm_mat_pow_close_eq_sum_pow)\n also have \"\\ = (\\ m \\ {..k}. tropm_walks_sum A (walks n m i j))\"\n by (rule sum.cong) (simp_all add: tropm_mat_pow_eq_sum_walks assms)\n also have \"\\ = tropm_walks_sum A (\\ m \\ {..k}. walks n m i j)\"\n unfolding tropm_walks_sum_def\n by (rule sum.UNION_disjoint[symmetric])\n (auto simp: finite_walks walks_def)\n also have \"\\ = tropm_walks_sum A (walks_le n k i j)\"\n by (simp add: walks_le_def)\n finally show ?thesis .\nqed","source":"tropical_resource_typing/tropical_matrices_full","theorem":"tropm_mat_pow_close_eq_sum_walks_le","id":200073,"goal":"assumes \"i < n\" \"j < n\" shows \"tropm_mat_pow n (tropm_mat_close n A) k i j = tropm_walks_sum A (walks_le n k i j)\"","context":["simp","simp_all","auto","rule","by","qed","proof","unfold","unfolding","show","have","sum.cong"]} +{"prover":"Isabelle","tactic_proof":"proof (rule antisym)\n (* (\\) direction: simple_walksm \\ walks_le, so min over more = smaller *)\n show \"tropm_mat_pow n (tropm_mat_close n A) (n-1) i j \\\n tropm_walks_sum A (simple_walksm n i j)\"\n proof -\n have lhs: \"tropm_mat_pow n (tropm_mat_close n A) (n-1) i j =\n tropm_walks_sum A (walks_le n (n-1) i j)\"\n using assms(1,2) by (rule tropm_mat_pow_close_eq_sum_walks_le)\n have subset: \"simple_walksm n i j \\ walks_le n (n-1) i j\"\n proof\n fix w assume hw: \"w \\ simple_walksm n i j\"\n then have hdist: \"distinct w\"\n and hwalk: \"\\ m. w \\ walks n m i j\"\n unfolding simple_walksm_def by auto\n obtain m where hwm: \"w \\ walks n m i j\" using hwalk by auto\n have hset: \"set w \\ m \\ {..n-1}. trop_mat_pow n A m i j)\"","context":["rule","by","unfold","unfolding"]} +{"prover":"Isabelle","tactic_proof":" unfolding trop_mat_star_def\n using assms by (rule trop_mat_pow_close_eq_sum_walks_le)","source":"tropical_resource_typing/tropical_kleene","theorem":"trop_mat_star_eq_sum_walks_le","id":200076,"goal":"assumes \"i < n\" \"j < n\" shows \"trop_mat_star n A i j = trop_walks_sum A (walks_le n (n-1) i j)\"","context":["rule","by","unfold","unfolding"]} +{"prover":"Isabelle","tactic_proof":"proof -\n have star: \"trop_mat_star n A i j = (\\ k \\ {..n-1}. trop_mat_pow n A k i j)\"\n using assms(1,2) by (rule trop_mat_star_eq_sum_pow)\n have mem: \"m \\ {..n-1}\" using assms(3) by simp\n show ?thesis\n unfolding star\n by (rule member_le_sum[OF _ finite_atMost mem])\n simp\nqed","source":"tropical_resource_typing/tropical_kleene","theorem":"trop_mat_pow_le_star","id":200077,"goal":"assumes \"i < n\" \"j < n\" \"m \\ n - 1\" shows \"trop_mat_pow n A m i j \\ trop_mat_star n A i j\"","context":["simp","rule","by","qed","proof","unfold","unfolding","show","have"]} +{"prover":"Isabelle","tactic_proof":"proof -\n have \"trop_mat_id n i j = trop_mat_pow n A 0 i j\"\n by simp\n also have \"\\ \\ trop_mat_star n A i j\"\n using assms by (rule trop_mat_pow_le_star) simp\n finally show ?thesis .\nqed","source":"tropical_resource_typing/tropical_kleene","theorem":"trop_mat_star_ge_id","id":200078,"goal":"assumes \"i < n\" \"j < n\" shows \"trop_mat_id n i j \\ trop_mat_star n A i j\"","context":["simp","rule","by","qed","proof","show","have"]} +{"prover":"Isabelle","tactic_proof":"proof -\n have \"A i j = trop_mat_pow n A 1 i j\"\n using assms(1,2) by (simp add: trop_mat_pow_one)\n also have \"\\ \\ trop_mat_star n A i j\"\n using assms by (rule trop_mat_pow_le_star) simp\n finally show ?thesis .\nqed","source":"tropical_resource_typing/tropical_kleene","theorem":"trop_mat_star_ge_mat","id":200079,"goal":"assumes \"i < n\" \"j < n\" \"0 < n\" shows \"A i j \\ trop_mat_star n A i j\"","context":["simp","rule","by","qed","proof","show","have"]} +{"prover":"Isabelle","tactic_proof":"proof (rule antisym)\n (* (\\) direction: A* \\ I \\ A \\ A*\n Show each summand A^m for m \\ n-1 is dominated. *)\n show \"trop_mat_star n A i j \\\n trop_mat_add n (trop_mat_id n) (trop_mat_mul n A (trop_mat_star n A)) i j\"\n proof -\n have star_sum: \"trop_mat_star n A i j = (\\ m \\ {..n-1}. trop_mat_pow n A m i j)\"\n using assms(1,2) by (rule trop_mat_star_eq_sum_pow)\n have each_le: \"\\ m \\ {..n-1}.\n trop_mat_pow n A m i j \\\n trop_mat_add n (trop_mat_id n) (trop_mat_mul n A (trop_mat_star n A)) i j\"\n proof\n fix m assume hm: \"m \\ {..n-1}\"\n show \"trop_mat_pow n A m i j \\\n trop_mat_add n (trop_mat_id n) (trop_mat_mul n A (trop_mat_star n A)) i j\"\n proof (cases m)\n case","source":"tropical_resource_typing/tropical_kleene","theorem":"trop_mat_star_equation","id":200080,"goal":"assumes \"i < n\" \"j < n\" \"0 < n\" \"no_pos_cycle n A\" shows \"trop_mat_star n A i j = trop_mat_add n (trop_mat_id n) (trop_mat_mul n A (trop_mat_star n A)) i j\"","context":["simp","simp_all","auto","cases","case","rule","by","qed","proof","unfold","unfolding","show","have","assume","fix","sum.cong","sum.swap","rule antisym"]} +{"prover":"Isabelle","tactic_proof":" unfolding trop_mat_star_def\n using assms by (rule floyd_warshall)","source":"tropical_resource_typing/tropical_kleene","theorem":"trop_mat_star_eq_max_simple","id":200081,"goal":"assumes \"i < n\" \"j < n\" assumes \"no_pos_cycle n A\" shows \"trop_mat_star n A i j = trop_walks_sum A (simple_walks n i j)\"","context":["rule","by","unfold","unfolding"]} +{"prover":"Isabelle","tactic_proof":"proof -\n have walks_eq: \"trop_mat_pow n A n i j = trop_walks_sum A (walks n n i j)\"\n using assms(1,2) by (rule trop_mat_pow_eq_sum_walks)\n have star_eq: \"trop_mat_star n A i j = trop_walks_sum A (walks_le n (n-1) i j)\"\n using assms(1,2) by (rule trop_mat_star_eq_sum_walks_le)\n (* It suffices to show each walk w in walks n n i j is dominated by\n some walk in walks_le n (n-1) i j. *)\n have dom: \"\\ w \\ walks n n i j. \\ w' \\ walks_le n (n-1) i j.\n path_weight A w \\ path_weight A w'\"\n proof\n fix w assume hw: \"w \\ walks n n i j\"\n have len_w: \"length w = Suc n\" using hw unfolding walks_def by simp\n have set_w: \"set w \\ {.. distinct w\"\n proof\n assum","source":"tropical_resource_typing/tropical_kleene","theorem":"trop_mat_star_prefixpoint","id":200082,"goal":"assumes \"i < n\" \"j < n\" \"0 < n\" \"no_pos_cycle n A\" shows \"trop_mat_add n (trop_mat_id n) (trop_mat_mul n A (trop_mat_star n A)) i j \\ trop_mat_star n A i j\" by (simp add: trop_mat_star_equation[OF assms(1,2,3,4), symmetric]) (* ------------------------------------------------------------------ *) subsection \\10 A^n \\ A* Under No-Pos-Cycle\\ (* ------------------------------------------------------------------ *) text \\ A key lemma for both the star equation and the least-prefixpoint theorem: under no_pos_cycle, @{text \"A^n i j \\ A* i j\"}. The argument uses the pigeonhole principle: any walk of length @{text n} in an @{text n}-vertex graph must repeat a vertex (since it visits @{text \"n+1\"} vertices from a set of size @{text n}). By @{text cycle_shortcutting}, it is dominated by a simple walk of length @{text \"\\ n-1\"}, which contributes to @{text A*}. \\ lemma trop_mat_pow_n_le_star: assumes \"i < n\" \"j < n\" \"no_pos_cycle n A\" \"0 < n\" shows \"trop_mat_pow n A n i j \\ trop_mat_star n A i j\"","context":["simp","auto","blast","cases","case","rule","by","qed","proof","unfold","unfolding","show","have","obtain","assume","fix","metis"]} +{"prover":"Isabelle","tactic_proof":"proof -\n (* Step 1: X dominates every power A^k pointwise — proved by induction on k *)\n have pow_le_X_gen: \"\\ k. k \\ n - 1 \\\n (\\ i' < n. \\ j' < n. trop_mat_pow n A k i' j' \\ X i' j')\"\n proof (induction k)\n case 0\n show ?case\n proof (intro impI allI)\n fix i' j' assume \"i' < n\" \"j' < n\"\n have \"trop_mat_id n i' j' \\\n trop_mat_add n (trop_mat_id n) (trop_mat_mul n A X) i' j'\"\n by (simp add: trop_mat_add_def le_add_same_cancel1)\n also have \"\\ \\ X i' j'\" using assms(1) \\i' < n\\ \\j' < n\\ by auto\n finally show \"trop_mat_pow n A 0 i' j' \\ X i' j'\" by simp\n qed\n next\n case (Suc k)\n show ?case\n proof (intro impI allI)\n fix i' j'\n a","source":"tropical_resource_typing/tropical_kleene","theorem":"trop_mat_star_least_prefixpoint","id":200083,"goal":"assumes \"\\ i < n. \\ j < n. X i j \\ trop_mat_add n (trop_mat_id n) (trop_mat_mul n A X) i j\" assumes \"i < n\" \"j < n\" \"0 < n\" shows \"trop_mat_star n A i j \\ X i j\"","context":["simp","auto","case","induction","induct","rule","by","qed","proof","intro","show","have","assume","fix","sum.cong"]} +{"prover":"Isabelle","tactic_proof":"proof (induction S rule: finite_induct)\n case empty\n show ?case by (simp add: zero_tropical_def bot_tropical_def trop_bot_eq_zero)\nnext\n case (insert x F)\n have \"(\\ y \\ insert x F. f y) = f x + (\\ y \\ F. f y)\"\n by (simp add: insert.hyps)\n also have \"\\ \\ c + c\"\n by (rule add_mono)\n (use insert.prems insert.IH in auto)\n also have \"\\ = c\"\n by (simp add: tropical_add_idem)\n finally show ?case .\nqed","source":"tropical_resource_typing/tropical_kleene","theorem":"member_le_sum","id":200084,"goal":"fixes f :: \"nat \\ tropical\" assumes \"finite S\" \"\\ x \\ S. (0 :: tropical) \\ f x\" \"m \\ S\" shows \"f m \\ (\\ x \\ S. f x)\" using assms by (rule member_le_sum) text \\ Tropical sum bounded by constant: if every summand is @{text \"\\ c\"}, then so is the sum (since tropical sum is idempotent join, not arithmetic sum). \\ lemma sum_le_const: fixes f :: \"nat \\ tropical\" assumes \"\\ x. x \\ S \\ f x \\ c\" assumes \"finite S\" shows \"(\\ x \\ S. f x) \\ c\" using assms","context":["simp","auto","case","induction","induct","rule","by","qed","proof","show","have"]} +{"prover":"Isabelle","tactic_proof":" by auto","source":"tropical_resource_typing/tropical_cno","theorem":"trop_mat_eq_iff","id":200085,"goal":"\"A = B \\ (\\ i j. A i j = B i j)\" by (auto intro: ext) lemma trop_mat_le_iff: \"(\\ i < n. \\ j < n. A i j \\ B i j) \\ (\\ i j. i < n \\ j < n \\ A i j \\ B i j)\"","context":["auto","by"]} +{"prover":"Isabelle","tactic_proof":" unfolding is_trop_cno_def by blast","source":"tropical_resource_typing/tropical_cno","theorem":"is_trop_cno_star","id":200086,"goal":"\"is_trop_cno n f \\ i < n \\ j < n \\ trop_mat_star n (f A) i j = f A i j\"","context":["blast","by","unfold","unfolding"]} +{"prover":"Isabelle","tactic_proof":" unfolding is_trop_cno_def using assms by blast","source":"tropical_resource_typing/tropical_cno","theorem":"is_trop_cno_intro","id":200087,"goal":"assumes \"\\ A. \\ i < n. \\ j < n. trop_mat_star n (f A) i j = f A i j\" shows \"is_trop_cno n f\"","context":["blast","by","unfold","unfolding"]} +{"prover":"Isabelle","tactic_proof":" unfolding trop_mat_add_def\n by (auto intro: ext simp: tropical_add_idem)","source":"tropical_resource_typing/tropical_cno","theorem":"trop_mat_close_idem","id":200088,"goal":"\"trop_mat_add n (trop_mat_close n A) (trop_mat_close n A) = trop_mat_close n A\"","context":["simp","auto","by","intro","unfold","unfolding"]} +{"prover":"Isabelle","tactic_proof":"proof (induction w1 arbitrary: w2)\n case Nil then show ?case by simp\nnext\n case (Cons u rest)\n show ?case\n proof (cases rest)\n case Nil\n (* w1 = [u]; w1 @ tl w2 = u # tl w2 = w2 (since hd w2 = u) *)\n then have \"u # tl w2 = w2\"\n using Cons.prems(3) Cons.prems(2)\n by (metis list.collapse hd_Cons_tl)\n also have \"path_weight A [u] = 1\"\n by simp\n finally show ?thesis\n using Cons.prems(2) \\u # tl w2 = w2\\\n by simp\n next\n case (Cons v rest2)\n (* w1 = u # v # rest2 *)\n have step: \"path_weight A ((u # v # rest2) @ tl w2)\n = A u v * path_weight A ((v # rest2) @ tl w2)\"\n by simp\n have ih_prems: \"v # rest2 \\ []\" \"w2 \\ []\" \"last (v # rest2) = hd w2\"\n using Cons.prems(2,3) local.Cons by simp_all","source":"tropical_resource_typing/tropical_cno","theorem":"path_weight_join","id":200089,"goal":"\"\\ w1 \\ []; w2 \\ []; last w1 = hd w2 \\ \\ path_weight A (w1 @ tl w2) = path_weight A w1 * path_weight A w2\"","context":["simp","simp_all","cases","case","induction","induct","by","qed","proof","show","have","metis"]} +{"prover":"Isabelle","tactic_proof":"proof (induction ws)\n case Nil then show ?case by simp\nnext\n case (Cons w ws')\n show ?case\n proof (cases ws')\n case Nil\n then show ?thesis by simp\n next\n case (Cons w' ws'')\n have hws'_ne: \"ws' \\ []\" using Cons by simp\n have hw_ne: \"w \\ []\" using Cons.prems(2) by simp\n have hws'_nonempty: \"\\ v \\ set ws'. v \\ []\" using Cons.prems(2) local.Cons by simp\n have hwcat_ne: \"walk_concat ws' \\ []\"\n using walk_concat_nonempty[OF hws'_ne hws'_nonempty] .\n (* Connectivity for ws': shift index by 1 *)\n have conn_ws': \"\\ k < length ws' - 1. last (ws' ! k) = hd (ws' ! (Suc k))\"\n proof (intro allI impI)\n fix k assume hk: \"k < length ws' - 1\"\n have \"","source":"tropical_resource_typing/tropical_cno","theorem":"walk_concat_nonempty","id":200090,"goal":"\"\\ ws \\ []; \\ w \\ set ws. w \\ [] \\ \\ walk_concat ws \\ []\" by (cases ws) (auto simp: walk_concat.simps) lemma path_weight_join_list: \"\\ ws \\ []; \\ w \\ set ws. w \\ []; \\ k < length ws - 1. last (ws ! k) = hd (ws ! (Suc k)) \\ \\ path_weight A (walk_concat ws) = (\\ w \\ ws. path_weight A w)\"","context":["simp","simp_all","force","cases","case","induction","induct","apply","by","qed","proof","intro","unfold","unfolding","show","have","assume","fix"]} +{"prover":"Isabelle","tactic_proof":" unfolding trop_mat_close_def trop_mat_id_def trop_mat_add_def\n by (auto intro: ext simp: tropical_add_idem add.commute add.assoc)","source":"tropical_resource_typing/tropical_cno","theorem":"trop_mat_close_close","id":200091,"goal":"\"trop_mat_close n (trop_mat_close n A) = trop_mat_close n A\"","context":["simp","auto","by","intro","unfold","unfolding"]} +{"prover":"Isabelle","tactic_proof":" unfolding trop_mat_star_def\n by (simp add: trop_mat_close_close)","source":"tropical_resource_typing/tropical_cno","theorem":"trop_mat_star_close_eq","id":200092,"goal":"\"trop_mat_star n (trop_mat_close n A) = trop_mat_star n A\"","context":["simp","by","unfold","unfolding"]} +{"prover":"Isabelle","tactic_proof":"proof -\n have len: \"length w = Suc k\" using assms(1) unfolding walks_def by simp\n have sub: \"set w \\ {..distinct w\\ distinct_card len by metis\n also have \"\\ \\ card {.. = n\" by simp\n finally show \"k \\ n - 1\" by simp\nqed","source":"tropical_resource_typing/tropical_cno","theorem":"distinct_walk_length_le","id":200093,"goal":"assumes \"w \\ walks n k i j\" assumes \"distinct w\" shows \"k \\ n - 1\"","context":["simp","rule","by","qed","proof","unfold","unfolding","show","have","metis"]} +{"prover":"Isabelle","tactic_proof":" unfolding walks_le_def\n using distinct_walk_length_le[OF assms(1,2)] assms(1)\n by auto","source":"tropical_resource_typing/tropical_cno","theorem":"distinct_walk_in_walks_le","id":200094,"goal":"assumes \"w \\ walks n k i j\" assumes \"distinct w\" assumes \"0 < n\" shows \"w \\ walks_le n (n-1) i j\"","context":["auto","by","unfold","unfolding"]} +{"prover":"Isabelle","tactic_proof":"proof (induction S rule: finite_induct)\n case empty then show ?case by simp\nnext\n case (insert x F)\n show ?case\n proof (cases \"F = {}\")\n case True\n then show ?thesis by simp\n next\n case False\n obtain w_ih where hw_ih: \"w_ih \\ F\" \"f w_ih = (\\ y \\ F. f y)\"\n using insert.IH False by blast\n have sum_eq: \"(\\ y \\ insert x F. f y) = f x + (\\ y \\ F. f y)\"\n by (simp add: insert.hyps)\n show ?thesis\n proof (cases \"f w_ih \\ f x\")\n case True\n have \"f x + f w_ih = f x\"\n using True by (simp add: add.commute trop_add_le_iff)\n hence \"(\\ y \\ insert x F. f y) = f x\"\n using sum_eq hw_ih(2) by simp\n then show ?thesis by auto\n next\n case False\n have hle: \"f x \\ f w_ih\" using linorde","source":"tropical_resource_typing/tropical_cno","theorem":"cycle_shortcutting_gen","id":200095,"goal":"assumes \"no_pos_cycle n A\" assumes \"w \\ walks n k i j\" shows \"\\ w' \\ simple_walks n i j. path_weight A w \\ path_weight A w'\" using cycle_shortcutting[OF assms] . (* ------------------------------------------------------------------ *) subsection \\9 No Positive Cycle Implies Closed Walks \\ 1\\ (* ------------------------------------------------------------------ *) text \\ @{text no_pos_cycle_closed_walk_le}: Under @{text \"no_pos_cycle n A\"}, every closed walk (from @{text i} back to @{text i}) has weight @{text \"\\ 1\"}. \\ lemma no_pos_cycle_closed_walk_le: assumes \"no_pos_cycle n A\" assumes \"w \\ walks n k i i\" assumes \"i < n\" shows \"path_weight A w \\ (1 :: tropical)\" using assms unfolding no_pos_cycle_def by blast (* ------------------------------------------------------------------ *) subsection \\10 Star Achieves Its Maximum\\ (* ------------------------------------------------------------------ *) text \\ @{text trop_mat_star_Max_achieved}: If @{text \"A* i j \\ NegInf\"}, then the star value is achieved by some walk in @{text \"walks_le n (n-1) i j\"}. \\ (* Helper: in the tropical semiring, a finite non-empty sum is achieved at some member of the underlying set. *) lemma trop_sum_achieves_member: fixes f :: \"'a \\ tropical\" assumes \"finite S\" \"S \\ {}\" shows \"\\ w \\ S. f w = (\\ x \\ S. f x)\" using assms","context":["simp","auto","blast","cases","case","induction","induct","rule","by","qed","proof","show","have","obtain"]} +{"prover":"Isabelle","tactic_proof":"proof -\n have star_eq: \"trop_mat_star n A i j = trop_walks_sum A (walks_le n (n-1) i j)\"\n using assms(1,2) by (rule trop_mat_star_eq_sum_walks_le)\n have fin: \"finite (walks_le n (n-1) i j)\" by (rule finite_walks_le)\n have walks_nonempty: \"walks_le n (n-1) i j \\ {}\"\n proof\n assume empty: \"walks_le n (n-1) i j = {}\"\n have \"trop_walks_sum A {} = 0\"\n unfolding trop_walks_sum_def by simp\n hence \"trop_mat_star n A i j = NegInf\"\n using star_eq empty by (simp add: zero_tropical_def)\n thus False using assms(3) by contradiction\n qed\n have \"\\ w \\ walks_le n (n-1) i j.\n path_weight A w = trop_walks_sum A (walks_le n (n-1) i j)\"\n unfolding trop_walks_sum_def\n using trop_sum_achieves_member[OF fin walks_nonempty] .\n then show ?thesis usin","source":"tropical_resource_typing/tropical_cno","theorem":"trop_mat_star_Max_achieved","id":200096,"goal":"assumes \"i < n\" \"j < n\" assumes \"trop_mat_star n A i j \\ NegInf\" shows \"\\ w \\ walks_le n (n-1) i j. path_weight A w = trop_mat_star n A i j\"","context":["simp","rule","by","qed","proof","unfold","unfolding","show","have","assume","contradiction"]} +{"prover":"Isabelle","tactic_proof":"proof -\n have star_eq: \"trop_mat_star n A i j = trop_walks_sum A (walks_le n (n-1) i j)\"\n using assms(1,2) by (rule trop_mat_star_eq_sum_walks_le)\n have \"path_weight A w \\ trop_walks_sum A (walks_le n (n-1) i j)\"\n using trop_walks_sum_ge_member[OF assms(3) finite_walks_le] .\n then show ?thesis using star_eq by simp\nqed","source":"tropical_resource_typing/tropical_cno","theorem":"path_weight_star_eq_concat","id":200097,"goal":"assumes \"i < n\" \"j < n\" assumes \"w \\ walks_le n (n-1) i j\" shows \"path_weight A w \\ trop_mat_star n A i j\"","context":["simp","rule","by","qed","proof","show","have"]} +{"prover":"Isabelle","tactic_proof":"proof (cases \"trop_mat_star n A i m = NegInf\")\n case True thus ?thesis by simp\nnext\n case hne_im: False\n show ?thesis\n proof (cases \"trop_mat_star n A m j = NegInf\")\n case True thus ?thesis by simp\n next\n case hne_mj: False\n obtain w_im where hw_im: \"w_im \\ walks_le n (n-1) i m\"\n and hpw_im: \"path_weight A w_im = trop_mat_star n A i m\"\n using trop_mat_star_Max_achieved[OF hi(1) hi(2) hne_im] by blast\n obtain w_mj where hw_mj: \"w_mj \\ walks_le n (n-1) m j\"\n and hpw_mj: \"path_weight A w_mj = trop_mat_star n A m j\"\n using trop_mat_star_Max_achieved[OF hi(2) hi(3) hne_mj] by blast\n have hne_im_list: \"w_im \\ []\"\n using hw_im unfolding walks_le_def walks_def by auto\n have hne_mj_list: \"w_mj \\ []\"\n us","source":"tropical_resource_typing/tropical_cno","theorem":"trop_mat_star_triangle","id":200098,"goal":"assumes hnpc: \"no_pos_cycle n A\" assumes hi: \"i < n\" \"m < n\" \"j < n\" shows \"trop_mat_star n A i m * trop_mat_star n A m j \\ trop_mat_star n A i j\"","context":["simp","simp_all","auto","blast","cases","case","by","qed","proof","intro","unfold","unfolding","show","have","obtain"]} +{"prover":"Isabelle","tactic_proof":"proof (induction k arbitrary: i j w)\n case 0\n then have hw0: \"w \\ walks n 0 i j\" and hi0: \"i < n\" and hj0: \"j < n\" by auto\n have hlen: \"length w = 1\" using hw0 unfolding walks_def by simp\n have hhd: \"hd w = i\" using hw0 unfolding walks_def by simp\n have hlast: \"last w = j\" using hw0 unfolding walks_def by simp\n have heq: \"i = j\"\n using hlen hhd hlast by (cases w) simp_all\n have wval: \"w = [i]\"\n using hlen hhd by (cases w) simp_all\n have \"path_weight (trop_mat_star n A) w = (1 :: tropical)\"\n by (simp add: wval)\n also have \"\\ \\ trop_mat_star n A i i\"\n using trop_mat_star_ge_id[OF hi0 hi0] by simp\n finally show ?case using heq by simp\nnext\n case (Suc k')\n then have hw': \"w \\ walks n (Suc k') i j\" and hi': \"i < n\" and hj': \"j < n\" by auto\n have hlen':","source":"tropical_resource_typing/tropical_cno","theorem":"path_weight_star_le","id":200099,"goal":"assumes hnpc: \"no_pos_cycle n A\" assumes hi: \"i < n\" \"j < n\" assumes hw: \"w \\ walks n k i j\" shows \"path_weight (trop_mat_star n A) w \\ trop_mat_star n A i j\" using hw hi","context":["simp","simp_all","auto","cases","case","induction","induct","rule","by","qed","proof","unfold","unfolding","show","have","obtain"]} +{"prover":"Isabelle","tactic_proof":" unfolding no_pos_cycle_def\nproof (intro allI impI ballI)\n fix i assume hi: \"i < n\"\n fix k w assume hw: \"w \\ walks n k i i\"\n show \"path_weight (trop_mat_star n A) w \\ (1 :: tropical)\"\n proof -\n (* Step 1: path_weight (A*) w \\ A* i i,\n using path_weight_star_le on the walk w \\ walks n k i i. *)\n have step1: \"path_weight (trop_mat_star n A) w \\ trop_mat_star n A i i\"\n using path_weight_star_le[OF assms(1) hi hi hw] .\n (* Step 2: A* i i \\ 1.","source":"tropical_resource_typing/tropical_cno","theorem":"has_positive_cycle_star","id":200100,"goal":"assumes \"no_pos_cycle n A\" assumes \"0 < n\" shows \"no_pos_cycle n (trop_mat_star n A)\"","context":["proof","intro","unfold","unfolding","show","have","assume","fix"]} +{"prover":"Isabelle","tactic_proof":"proof (rule antisym)\n (* (\\) direction: (A*)* \\ A* *)\n show \"trop_mat_star n (trop_mat_star n A) i j \\ trop_mat_star n A i j\"\n proof -\n have star_star_eq:\n \"trop_mat_star n (trop_mat_star n A) i j =\n trop_walks_sum (trop_mat_star n A) (walks_le n (n-1) i j)\"\n using assms by (rule trop_mat_star_eq_sum_walks_le)\n (* Each walk in walks_le n (n-1) i j has weight \\ A* i j *)\n have bound: \"\\ w \\ walks_le n (n-1) i j.\n path_weight (trop_mat_star n A) w \\ trop_mat_star n A i j\"\n proof\n fix w assume hw: \"w \\ walks_le n (n-1) i j\"\n show \"path_weight (trop_mat_star n A) w \\ trop_mat_star n A i j\"\n using path_weight_star_eq_concat[OF assms hw] .\n qed\n (* Therefore the sum (= join) is also \\<","source":"tropical_resource_typing/tropical_cno","theorem":"trop_mat_star_idem","id":200101,"goal":"assumes \"i < n\" \"j < n\" shows \"trop_mat_star n (trop_mat_star n A) i j = trop_mat_star n A i j\"","context":["simp","blast","rule","by","qed","proof","unfold","unfolding","show","have","assume","fix","rule antisym"]} +{"prover":"Isabelle","tactic_proof":" unfolding is_trop_cno_def\n using assms by simp","source":"tropical_resource_typing/tropical_cno","theorem":"trop_cno_id_conditional","id":200102,"goal":"assumes \"\\ A. trop_mat_star n A = A\" shows \"is_trop_cno n id\"","context":["simp","by","unfold","unfolding"]} +{"prover":"Isabelle","tactic_proof":" unfolding trop_mat_add_def\n by (auto intro: ext simp: tropical_add_idem)","source":"tropical_resource_typing/tropical_cno","theorem":"trop_cno_close_conditional","id":200103,"goal":"assumes \"\\ A. trop_mat_star n A = trop_mat_close n A\" shows \"is_trop_cno n (trop_mat_close n)\" by (rule is_trop_cno_intro) (use assms in simp_all) (* ------------------------------------------------------------------ *) subsection \\15 Self-Addition is a CNO\\ (* ------------------------------------------------------------------ *) text \\ @{text trop_cno_add_self}: @{text \"\\A. trop_mat_add n A A\"} is a CNO. Since @{text \"A \\ A = A\"} pointwise, we have @{text \"(\\A. A \\ A) = id\"} on the level of matrix functions, and every CNO theorem for @{text id} transfers. \\ lemma trop_mat_add_self: \"trop_mat_add n A A = A\"","context":["simp","auto","by","intro","unfold","unfolding"]} +{"prover":"Isabelle","tactic_proof":"proof -\n have eq: \"\\ A. trop_mat_add n A A = A\"\n by (rule trop_mat_add_self)\n show ?thesis\n using assms by (simp add: eq)\nqed","source":"tropical_resource_typing/tropical_cno","theorem":"trop_cno_add_self","id":200104,"goal":"assumes \"is_trop_cno n (\\A. A)\" shows \"is_trop_cno n (\\A. trop_mat_add n A A)\"","context":["simp","rule","by","qed","proof","show","have"]} +{"prover":"Isabelle","tactic_proof":"proof (rule antisym)\n define B where \"B = trop_mat_star n A\"\n have hn: \"0 < n\" using hi by auto\n (* \\ direction: B^2 i j \\ B i j\n Every length-2 walk in B from i to j has weight \\ B i j,\n using path_weight_star_le with no_pos_cycle n B. *)\n show \"trop_mat_pow n (trop_mat_star n A) 2 i j \\ trop_mat_star n A i j\"\n proof -\n have hnpc_B: \"no_pos_cycle n B\"\n using has_positive_cycle_star[OF hnpc hn] unfolding B_def .\n have pow2_eq: \"trop_mat_pow n B 2 i j = trop_walks_sum B (walks n 2 i j)\"\n using trop_mat_pow_eq_sum_walks[OF hi hj] unfolding B_def by simp\n have dom: \"\\ w \\ walks n 2 i j.\n \\ w' \\ simple_walks n i j. path_weight B w \\ path_weight B w'\"\n proof (intro ballI)\n fix w assume hw: \"w \\","source":"tropical_resource_typing/tropical_cno","theorem":"trop_mat_star_sq","id":200105,"goal":"assumes hi: \"i < n\" and hj: \"j < n\" assumes hnpc: \"no_pos_cycle n A\" shows \"trop_mat_pow n (trop_mat_star n A) 2 i j = trop_mat_star n A i j\"","context":["simp","auto","rule","by","qed","proof","intro","unfold","unfolding","show","have","assume","fix","rule antisym"]} +{"prover":"Isabelle","tactic_proof":" unfolding is_trop_cno_def\n using trop_mat_star_idem by blast","source":"tropical_resource_typing/tropical_cno","theorem":"trop_cno_star","id":200106,"goal":"\"is_trop_cno n (\\A. trop_mat_star n A)\"","context":["blast","by","unfold","unfolding"]} +{"prover":"Isabelle","tactic_proof":" unfolding is_trop_cno_def comp_def\n using is_trop_cno_star[OF hf] by blast","source":"tropical_resource_typing/tropical_cno","theorem":"trop_cno_compose","id":200107,"goal":"assumes hf: \"is_trop_cno n f\" assumes hg: \"is_trop_cno n g\" shows \"is_trop_cno n (f \\ g)\"","context":["blast","by","unfold","unfolding"]} +{"prover":"Isabelle","tactic_proof":"proof -\n (* The CNO condition gives: \\ i < n. \\ j < n. (f A)* i j = f A i j. *)\n have hfA: \"\\ i < n. \\ j < n. trop_mat_star n (f A) i j = f A i j\"\n using is_trop_cno_star[OF hcno] by blast\n (* The fixstar condition maps star-fixpoints: since f A is a star-fixpoint,\n f maps it to itself pointwise. *)\n show ?thesis using fixstar hfA hi hj by blast\nqed","source":"tropical_resource_typing/tropical_cno","theorem":"trop_cno_delta_S_zero","id":200108,"goal":"assumes hcno: \"is_trop_cno n f\" assumes fixstar: \"\\ B. (\\ i < n. \\ j < n. trop_mat_star n B i j = B i j) \\ (\\ i < n. \\ j < n. f B i j = B i j)\" assumes hi: \"i < n\" and hj: \"j < n\" shows \"f (f A) i j = f A i j\"","context":["blast","by","qed","proof","show","have","fix"]} +{"prover":"Isabelle","tactic_proof":"by (rule Nat.add_commute)","source":"tropical_resource_typing/isabelle_synthetic","theorem":"nat_add_comm","id":200109,"goal":"\"(m :: nat) + n = n + m\"","context":["rule","by"]} +{"prover":"Isabelle","tactic_proof":"by simp","source":"tropical_resource_typing/isabelle_synthetic","theorem":"nat_max_idem","id":200110,"goal":"\"max (n :: nat) n = n\"","context":["simp","by"]} +{"prover":"Isabelle","tactic_proof":"by (simp add: max.commute)","source":"tropical_resource_typing/isabelle_synthetic","theorem":"nat_max_comm","id":200111,"goal":"\"max (a :: nat) b = max b a\"","context":["simp","by"]} +{"prover":"Isabelle","tactic_proof":"by (simp add: max.assoc)","source":"tropical_resource_typing/isabelle_synthetic","theorem":"nat_max_assoc","id":200112,"goal":"\"max (max (a :: nat) b) c = max a (max b c)\"","context":["simp","by"]} +{"prover":"Isabelle","tactic_proof":"by simp","source":"tropical_resource_typing/isabelle_synthetic","theorem":"nat_add_distrib_max","id":200113,"goal":"\"(k :: nat) + max m n = max (k + m) (k + n)\"","context":["simp","by"]} +{"prover":"Isabelle","tactic_proof":"by simp","source":"tropical_resource_typing/isabelle_synthetic","theorem":"comm_monoid_add_zero_left","id":200114,"goal":"\"(0 :: 'a :: comm_monoid_add) + a = a\"","context":["simp","by"]} +{"prover":"Isabelle","tactic_proof":"by (rule distrib_left)","source":"tropical_resource_typing/isabelle_synthetic","theorem":"semiring_distrib_left","id":200115,"goal":"\"a * (b + c) = a * b + a * c\" for a b c :: \"'a :: semiring\"","context":["rule","by"]} +{"prover":"Isabelle","tactic_proof":"by simp","source":"tropical_resource_typing/isabelle_synthetic","theorem":"sum_cong_eq","id":200116,"goal":"\"f = g \\ (\\ x \\ A. f x) = (\\ x \\ A. g x)\"","context":["simp","by"]} +{"prover":"Isabelle","tactic_proof":"by (simp add: sum.delta)","source":"tropical_resource_typing/isabelle_synthetic","theorem":"sum_delta_finite","id":200117,"goal":"\"finite A \\ j \\ A \\ (\\ k \\ A. if k = j then f k else 0) = f j\"","context":["simp","by","sum.delta"]} +{"prover":"Isabelle","tactic_proof":"by (rule sum.union_disjoint)","source":"tropical_resource_typing/isabelle_synthetic","theorem":"sum_union_disjoint","id":200118,"goal":"\"finite A \\ finite B \\ A \\ B = {} \\\n (\\ x \\ A \\ B. f x) = (\\ x \\ A. f x) + (\\ x \\ B. f x)\"","context":["rule","by"]} +{"prover":"Isabelle","tactic_proof":"by (rule sum.swap)","source":"tropical_resource_typing/isabelle_synthetic","theorem":"sum_swap_double","id":200119,"goal":"\"(\\ i \\ A. \\ j \\ B. f i j) = (\\ j \\ B. \\ i \\ A. f i j)\"","context":["rule","by","sum.swap"]} +{"prover":"Isabelle","tactic_proof":"by (rule sum_distrib_left)","source":"tropical_resource_typing/isabelle_synthetic","theorem":"sum_distrib_left","id":200120,"goal":"\"c * (\\ i \\ A. f i) = (\\ i \\ A. c * f i)\"","context":["rule","by"]} +{"prover":"Isabelle","tactic_proof":"by (rule sum_distrib_right)","source":"tropical_resource_typing/isabelle_synthetic","theorem":"sum_distrib_right","id":200121,"goal":"\"(\\ i \\ A. f i) * c = (\\ i \\ A. f i * c)\"","context":["rule","by"]} +{"prover":"Isabelle","tactic_proof":"by simp","source":"tropical_resource_typing/isabelle_synthetic","theorem":"list_length_nonempty","id":200122,"goal":"\"w \\ [] \\ 0 < length w\"","context":["simp","by"]} +{"prover":"Isabelle","tactic_proof":"by (simp add: hd_in_set)","source":"tropical_resource_typing/isabelle_synthetic","theorem":"hd_in_set","id":200123,"goal":"\"w \\ [] \\ hd w \\ set w\"","context":["simp","by"]} +{"prover":"Isabelle","tactic_proof":"by (simp add: last_in_set)","source":"tropical_resource_typing/isabelle_synthetic","theorem":"last_in_set","id":200124,"goal":"\"w \\ [] \\ last w \\ set w\"","context":["simp","by"]} +{"prover":"Isabelle","tactic_proof":"by (rule finite_lists_length_eq) simp","source":"tropical_resource_typing/isabelle_synthetic","theorem":"finite_lists_bounded","id":200125,"goal":"\"finite A \\ finite {w :: nat list . length w = k \\ set w \\ A}\"","context":["simp","rule","by"]} +{"prover":"Isabelle","tactic_proof":"by (rule card_mono[THEN order_trans])\n (auto simp: distinct_card)","source":"tropical_resource_typing/isabelle_synthetic","theorem":"distinct_length_le","id":200126,"goal":"\"distinct w \\ set w \\ A \\ finite A \\\n length w \\ card A\"","context":["simp","auto","rule","by"]} +{"prover":"Isabelle","tactic_proof":"by (rule order_antisym)","source":"tropical_resource_typing/isabelle_synthetic","theorem":"antisym_eq","id":200127,"goal":"\"a \\ b \\ b \\ a \\ a = b\" for a b :: \"'a :: order\"","context":["rule","by","rule order_antisym"]} +{"prover":"Isabelle","tactic_proof":"by (rule Nat.nat.induct)","source":"tropical_resource_typing/isabelle_synthetic","theorem":"induction_nat_sum","id":200128,"goal":"\"P 0 \\ (\\ k. P k \\ P (Suc k)) \\ P n\"","context":["induct","rule","by"]} +{"prover":"Isabelle","tactic_proof":"by simp","source":"tropical_resource_typing/isabelle_synthetic","theorem":"trop_fin_add_fin","id":200129,"goal":"\"trop_add (Fin m) (Fin n) = Fin (max m n)\"","context":["simp","by"]} +{"prover":"Isabelle","tactic_proof":"by simp","source":"tropical_resource_typing/isabelle_synthetic","theorem":"trop_mul_fin_fin","id":200130,"goal":"\"trop_mul (Fin m) (Fin n) = Fin (m + n)\"","context":["simp","by"]} +{"prover":"Isabelle","tactic_proof":"by (cases a) simp_all","source":"tropical_resource_typing/isabelle_synthetic","theorem":"trop_add_neginf_left","id":200131,"goal":"\"trop_add NegInf a = a\"","context":["simp","simp_all","cases","case","by"]} +{"prover":"Isabelle","tactic_proof":"by (cases a) simp_all","source":"tropical_resource_typing/isabelle_synthetic","theorem":"trop_mul_neginf_left","id":200132,"goal":"\"trop_mul NegInf a = NegInf\"","context":["simp","simp_all","cases","case","by"]} +{"prover":"Isabelle","tactic_proof":"by (cases a) simp_all","source":"tropical_resource_typing/isabelle_synthetic","theorem":"tropm_add_posinf_left","id":200133,"goal":"\"tropm_add PosInf a = a\"","context":["simp","simp_all","cases","case","by"]} +{"prover":"Isabelle","tactic_proof":"by (rule Un_commute)","source":"tropical_resource_typing/isabelle_synthetic","theorem":"set_union_comm","id":200134,"goal":"\"A \\ B = B \\ A\"","context":["rule","by"]} +{"prover":"Isabelle","tactic_proof":"by (rule Int_commute)","source":"tropical_resource_typing/isabelle_synthetic","theorem":"set_inter_comm","id":200135,"goal":"\"A \\ B = B \\ A\"","context":["rule","by"]} +{"prover":"Isabelle","tactic_proof":"by blast","source":"tropical_resource_typing/isabelle_synthetic","theorem":"set_diff_subset","id":200136,"goal":"\"A - B \\ A\"","context":["blast","by"]} +{"prover":"Isabelle","tactic_proof":"by (rule image_Un)","source":"tropical_resource_typing/isabelle_synthetic","theorem":"set_image_union","id":200137,"goal":"\"f ` (A \\ B) = f ` A \\ f ` B\"","context":["rule","by"]} +{"prover":"Isabelle","tactic_proof":"by auto","source":"tropical_resource_typing/isabelle_synthetic","theorem":"set_comprehension","id":200138,"goal":"\"{x \\ A. P x \\ Q x} = {x \\ A. P x} \\ {x \\ A. Q x}\"","context":["auto","by"]} +{"prover":"Isabelle","tactic_proof":"by simp","source":"tropical_resource_typing/isabelle_synthetic","theorem":"set_finite_union","id":200139,"goal":"\"finite A \\ finite B \\ finite (A \\ B)\"","context":["simp","by"]} +{"prover":"Isabelle","tactic_proof":"by (simp add: Pow_iff)","source":"tropical_resource_typing/isabelle_synthetic","theorem":"set_powerset","id":200140,"goal":"\"A \\ Pow B \\ A \\ B\"","context":["simp","by"]} +{"prover":"Isabelle","tactic_proof":"by (simp add: card_Un_disjoint)","source":"tropical_resource_typing/isabelle_synthetic","theorem":"set_disjoint_union","id":200141,"goal":"\"A \\ B = {} \\ card (A \\ B) = card A + card B\"","context":["simp","by"]} +{"prover":"Isabelle","tactic_proof":"by simp","source":"tropical_resource_typing/isabelle_synthetic","theorem":"set_insert_member","id":200142,"goal":"\"x \\ insert x A\"","context":["simp","by"]} +{"prover":"Isabelle","tactic_proof":"by simp","source":"tropical_resource_typing/isabelle_synthetic","theorem":"set_collect_mem","id":200143,"goal":"\"a \\ {x. P x} \\ P a\"","context":["simp","by"]} +{"prover":"Isabelle","tactic_proof":"by simp","source":"tropical_resource_typing/isabelle_synthetic","theorem":"abs_nonneg","id":200144,"goal":"\"(0 :: real) \\ \\x\\\"","context":["simp","by"]} +{"prover":"Isabelle","tactic_proof":"by (rule abs_triangle_ineq)","source":"tropical_resource_typing/isabelle_synthetic","theorem":"abs_triangle","id":200145,"goal":"\"\\(x :: real) + y\\ \\ \\x\\ + \\y\\\"","context":["rule","by"]} +{"prover":"Isabelle","tactic_proof":"by (rule sum_cauchy_schwarz_ineq)","source":"tropical_resource_typing/isabelle_synthetic","theorem":"cauchy_schwarz","id":200146,"goal":"\"(\\i (\\ii x \\ 0 \\ sqrt x\"","context":["simp","by"]} +{"prover":"Isabelle","tactic_proof":"by (rule exp_add)","source":"tropical_resource_typing/isabelle_synthetic","theorem":"exp_add","id":200148,"goal":"\"exp ((x :: real) + y) = exp x * exp y\"","context":["rule","by"]} +{"prover":"Isabelle","tactic_proof":"by (rule ln_mult)","source":"tropical_resource_typing/isabelle_synthetic","theorem":"log_mult","id":200149,"goal":"\"0 < x \\ 0 < y \\ ln (x * y) = ln x + ln (y :: real)\"","context":["rule","by"]} +{"prover":"Isabelle","tactic_proof":"by (rule sin_cos_squared_add [symmetric])","source":"tropical_resource_typing/isabelle_synthetic","theorem":"cos_sin_sq","id":200150,"goal":"\"(cos x)^2 + (sin x)^2 = (1 :: real)\"","context":["rule","by"]} +{"prover":"Isabelle","tactic_proof":"by (rule tendsto_add)","source":"tropical_resource_typing/isabelle_synthetic","theorem":"limit_sum","id":200151,"goal":"\"(f \\ a) F \\ (g \\ b) F \\\n ((\\x. f x + g x) \\ a + b) F\"","context":["rule","by"]} +{"prover":"Isabelle","tactic_proof":"by (rule continuous_on_compose) auto","source":"tropical_resource_typing/isabelle_synthetic","theorem":"continuous_compose","id":200152,"goal":"\"continuous_on A g \\ continuous_on B f \\ g ` A \\ B \\\n continuous_on A (f \\ g)\"","context":["auto","rule","by"]} +{"prover":"Isabelle","tactic_proof":"by (rule DERIV_chain2)","source":"tropical_resource_typing/isabelle_synthetic","theorem":"deriv_chain","id":200153,"goal":"\"(f has_real_derivative f') (at x) \\\n (g has_real_derivative g') (at (f x)) \\\n ((g \\ f) has_real_derivative g' * f') (at x)\"","context":["rule","by"]} +{"prover":"Isabelle","tactic_proof":"by (metis add.left_cancel add.right_inverse)","source":"tropical_resource_typing/isabelle_synthetic","theorem":"group_inverse_unique","id":200154,"goal":"\"(a :: 'a :: group_add) + b = 0 \\ b = - a\"","context":["by","metis"]} +{"prover":"Isabelle","tactic_proof":"by simp","source":"tropical_resource_typing/isabelle_synthetic","theorem":"ring_zero_mul","id":200155,"goal":"\"(0 :: 'a :: ring) * a = 0\"","context":["simp","by"]} +{"prover":"Isabelle","tactic_proof":"by simp","source":"tropical_resource_typing/isabelle_synthetic","theorem":"field_inv_mul","id":200156,"goal":"\"(a :: 'a :: field) \\ 0 \\ inverse a * a = 1\"","context":["simp","by"]} +{"prover":"Isabelle","tactic_proof":"by (rule mult.assoc)","source":"tropical_resource_typing/isabelle_synthetic","theorem":"monoid_assoc","id":200157,"goal":"\"(a :: 'a :: monoid_mult) * b * c = a * (b * c)\"","context":["rule","by"]} +{"prover":"Isabelle","tactic_proof":"by (auto simp: group_hom_def)","source":"tropical_resource_typing/isabelle_synthetic","theorem":"hom_compose","id":200158,"goal":"\"group_hom f \\ group_hom g \\ group_hom (f \\ g)\"","context":["simp","auto","by"]} +{"prover":"Isabelle","tactic_proof":"by (rule group_hom.kernel_normal)","source":"tropical_resource_typing/isabelle_synthetic","theorem":"kernel_normal","id":200159,"goal":"\"group_hom f \\ normal (kernel f)\"","context":["rule","by"]} +{"prover":"Isabelle","tactic_proof":"by (rule normal.quotient_group)","source":"tropical_resource_typing/isabelle_synthetic","theorem":"quotient_group","id":200160,"goal":"\"normal H \\ group (G Mod H)\"","context":["rule","by"]} +{"prover":"Isabelle","tactic_proof":"by (rule ideal_sum)","source":"tropical_resource_typing/isabelle_synthetic","theorem":"ideal_sum","id":200161,"goal":"\"ideal I \\ ideal J \\ ideal (I + J)\"","context":["rule","by"]} +{"prover":"Isabelle","tactic_proof":"by (rule degree_mult_le)","source":"tropical_resource_typing/isabelle_synthetic","theorem":"polynomial_degree","id":200162,"goal":"\"degree (p * q) \\ degree p + degree (q :: 'a :: idom poly)\"","context":["rule","by"]} +{"prover":"Isabelle","tactic_proof":"by (metis dim_eq_card_independent span_UNIV)","source":"tropical_resource_typing/isabelle_synthetic","theorem":"vector_space_basis","id":200163,"goal":"\"finite B \\ independent B \\ span B = UNIV \\\n card B = dim (UNIV :: 'a :: euclidean_space set)\"","context":["by","metis"]} +{"prover":"Isabelle","tactic_proof":"by blast","source":"tropical_resource_typing/isabelle_synthetic","theorem":"imp_trans","id":200164,"goal":"\"(P \\ Q) \\ (Q \\ R) \\ (P \\ R)\"","context":["blast","by"]} +{"prover":"Isabelle","tactic_proof":"by blast","source":"tropical_resource_typing/isabelle_synthetic","theorem":"contrapositive","id":200165,"goal":"\"(P \\ Q) \\ (\\ Q \\ \\ P)\"","context":["blast","by"]} +{"prover":"Isabelle","tactic_proof":"by blast","source":"tropical_resource_typing/isabelle_synthetic","theorem":"double_neg","id":200166,"goal":"\"\\ \\ P \\ P\"","context":["blast","by"]} +{"prover":"Isabelle","tactic_proof":"by blast","source":"tropical_resource_typing/isabelle_synthetic","theorem":"excluded_middle","id":200167,"goal":"\"P \\ \\ P\"","context":["blast","by"]} +{"prover":"Isabelle","tactic_proof":"by blast","source":"tropical_resource_typing/isabelle_synthetic","theorem":"de_morgan","id":200168,"goal":"\"\\ (P \\ Q) \\ (\\ P \\ \\ Q)\"","context":["blast","by"]} +{"prover":"Isabelle","tactic_proof":"by blast","source":"tropical_resource_typing/isabelle_synthetic","theorem":"forall_conj_distrib","id":200169,"goal":"\"(\\x. P x \\ Q x) \\ (\\x. P x) \\ (\\x. Q x)\"","context":["blast","by"]} +{"prover":"Isabelle","tactic_proof":"by blast","source":"tropical_resource_typing/isabelle_synthetic","theorem":"exists_or_distrib","id":200170,"goal":"\"(\\x. P x \\ Q x) \\ (\\x. P x) \\ (\\x. Q x)\"","context":["blast","by"]} +{"prover":"Isabelle","tactic_proof":"by blast","source":"tropical_resource_typing/isabelle_synthetic","theorem":"proof_by_cases","id":200171,"goal":"\"(P \\ R) \\ (\\ P \\ R) \\ R\"","context":["blast","by"]} +{"prover":"Isabelle","tactic_proof":"by blast","source":"tropical_resource_typing/isabelle_synthetic","theorem":"classical_reductio","id":200172,"goal":"\"(\\ P \\ False) \\ P\"","context":["blast","by"]} +{"prover":"Isabelle","tactic_proof":"by blast","source":"tropical_resource_typing/isabelle_synthetic","theorem":"iff_sym","id":200173,"goal":"\"(P \\ Q) \\ (Q \\ P)\"","context":["blast","by"]} +{"prover":"Isabelle","tactic_proof":"by (induction ys) auto","source":"tropical_resource_typing/isabelle_synthetic","theorem":"list_induct","id":200174,"goal":"\"P [] \\ (\\x xs. P xs \\ P (x # xs)) \\ P ys\"","context":["auto","induction","induct","by"]} +{"prover":"Isabelle","tactic_proof":"by simp","source":"tropical_resource_typing/isabelle_synthetic","theorem":"map_append","id":200175,"goal":"\"map f (xs @ ys) = map f xs @ map f ys\"","context":["simp","by"]} +{"prover":"Isabelle","tactic_proof":"by simp","source":"tropical_resource_typing/isabelle_synthetic","theorem":"filter_append","id":200176,"goal":"\"filter P (xs @ ys) = filter P xs @ filter P ys\"","context":["simp","by"]} +{"prover":"Isabelle","tactic_proof":"by (induction xs) simp_all","source":"tropical_resource_typing/isabelle_synthetic","theorem":"concat_map","id":200177,"goal":"\"concat (map f xs) = concatMap f xs\"","context":["simp","simp_all","induction","induct","by"]} +{"prover":"Isabelle","tactic_proof":"by (induction xs ys rule: list_induct2') auto","source":"tropical_resource_typing/isabelle_synthetic","theorem":"zip_map","id":200178,"goal":"\"map fst (zip xs ys) = take (min (length xs) (length ys)) xs\"","context":["auto","induction","induct","rule","by"]} +{"prover":"Isabelle","tactic_proof":"by simp","source":"tropical_resource_typing/isabelle_synthetic","theorem":"nth_map","id":200179,"goal":"\"i < length xs \\ (map f xs) ! i = f (xs ! i)\"","context":["simp","by"]} +{"prover":"Isabelle","tactic_proof":"by simp","source":"tropical_resource_typing/isabelle_synthetic","theorem":"take_append","id":200180,"goal":"\"take n xs @ drop n xs = xs\"","context":["simp","by"]} +{"prover":"Isabelle","tactic_proof":"by simp","source":"tropical_resource_typing/isabelle_synthetic","theorem":"drop_append","id":200181,"goal":"\"n \\ length xs \\ drop n (xs @ ys) = drop n xs @ ys\"","context":["simp","by"]} +{"prover":"Isabelle","tactic_proof":"by (simp add: sorted_insort)","source":"tropical_resource_typing/isabelle_synthetic","theorem":"sorted_insert","id":200182,"goal":"\"sorted xs \\ sorted (insort x xs)\"","context":["simp","by"]} +{"prover":"Isabelle","tactic_proof":"by (rule distinct_append)","source":"tropical_resource_typing/isabelle_synthetic","theorem":"distinct_append","id":200183,"goal":"\"distinct (xs @ ys) \\\n distinct xs \\ distinct ys \\ set xs \\ set ys = {}\"","context":["rule","by"]} +{"prover":"Isabelle","tactic_proof":"by (simp add: mat_add_comm)","source":"tropical_resource_typing/isabelle_synthetic","theorem":"matrix_add_comm","id":200184,"goal":"\"(A :: 'a :: ab_semigroup_add mat) + B = B + A\"","context":["simp","by"]} +{"prover":"Isabelle","tactic_proof":"by (rule assoc_mult_mat)","source":"tropical_resource_typing/isabelle_synthetic","theorem":"matrix_mul_assoc","id":200185,"goal":"\"dim_col A = dim_row B \\ dim_col B = dim_row C \\\n (A :: 'a :: semiring_0 mat) * B * C = A * (B * C)\"","context":["rule","by"]} +{"prover":"Isabelle","tactic_proof":"by (rule transpose_transpose)","source":"tropical_resource_typing/isabelle_synthetic","theorem":"matrix_transpose_transpose","id":200186,"goal":"\"(A\\<^sup>T)\\<^sup>T = A\"","context":["rule","by"]} +{"prover":"Isabelle","tactic_proof":"by (rule left_mult_zero_mat)","source":"tropical_resource_typing/isabelle_synthetic","theorem":"matrix_zero_left","id":200187,"goal":"\"dim_row A = n \\ dim_col A = m \\\n (0\\<^sub>m n k :: 'a :: semiring_0 mat) * A = 0\\<^sub>m n m\"","context":["rule","by"]} +{"prover":"Isabelle","tactic_proof":"by (rule right_mult_one_mat)","source":"tropical_resource_typing/isabelle_synthetic","theorem":"matrix_one_right","id":200188,"goal":"\"dim_row A = n \\ dim_col A = n \\\n (A :: 'a :: semiring_1 mat) * 1\\<^sub>m n = A\"","context":["rule","by"]} +{"prover":"Isabelle","tactic_proof":"by (rule det_transpose)","source":"tropical_resource_typing/isabelle_synthetic","theorem":"matrix_det_transpose","id":200189,"goal":"\"det (A\\<^sup>T) = det (A :: 'a :: comm_ring_1 mat)\"","context":["rule","by"]} +{"prover":"Isabelle","tactic_proof":"by (simp add: trace_add)","source":"tropical_resource_typing/isabelle_synthetic","theorem":"matrix_trace_add","id":200190,"goal":"\"dim_row A = n \\ dim_row B = n \\\n trace (A + B) = trace A + trace (B :: 'a :: comm_monoid_add mat)\"","context":["simp","by"]} +{"prover":"Isabelle","tactic_proof":"by (rule smult_smult_assoc)","source":"tropical_resource_typing/isabelle_synthetic","theorem":"matrix_scalar_mult","id":200191,"goal":"\"dim_row A = n \\ dim_col A = m \\\n c \\\\<^sub>m (d \\\\<^sub>m A) = (c * d) \\\\<^sub>m (A :: 'a :: semiring_0 mat)\"","context":["rule","by"]} +{"prover":"Isabelle","tactic_proof":"by (simp add: row_def)","source":"tropical_resource_typing/isabelle_synthetic","theorem":"matrix_row_col","id":200192,"goal":"\"i < dim_row A \\ j < dim_col A \\\n (A :: 'a mat) $$ (i, j) = row A i $ j\"","context":["simp","by"]} +{"prover":"Isabelle","tactic_proof":"by simp","source":"tropical_resource_typing/isabelle_synthetic","theorem":"matrix_dim_mult","id":200193,"goal":"\"dim_row (A * B) = dim_row A\"","context":["simp","by"]} +{"prover":"Isabelle","tactic_proof":"by (induction t) auto","source":"tropical_resource_typing/isabelle_synthetic","theorem":"tree_height_nonneg","id":200194,"goal":"\"0 \\ height (t :: 'a tree)\"","context":["auto","induction","induct","by"]} +{"prover":"Isabelle","tactic_proof":"by (induction t) auto","source":"tropical_resource_typing/isabelle_synthetic","theorem":"tree_size_mirror","id":200195,"goal":"\"size (mirror t) = size (t :: 'a tree)\"","context":["auto","induction","induct","by"]} +{"prover":"Isabelle","tactic_proof":"by (induction t) auto","source":"tropical_resource_typing/isabelle_synthetic","theorem":"bst_insert_ordered","id":200196,"goal":"\"bst t \\ bst (insert x t)\"","context":["auto","induction","induct","by"]} +{"prover":"Isabelle","tactic_proof":"by simp","source":"tropical_resource_typing/isabelle_synthetic","theorem":"list_rev_rev","id":200197,"goal":"\"rev (rev xs) = xs\"","context":["simp","by"]} +{"prover":"Isabelle","tactic_proof":"by simp","source":"tropical_resource_typing/isabelle_synthetic","theorem":"even_odd_mutual","id":200198,"goal":"\"even n \\ odd (Suc n)\"","context":["simp","by"]} +{"prover":"Isabelle","tactic_proof":"by simp","source":"tropical_resource_typing/isabelle_synthetic","theorem":"rose_tree_fold","id":200199,"goal":"\"fold_rose f (Node x ts) = f x (map (fold_rose f) ts)\"","context":["simp","by"]} +{"prover":"Isabelle","tactic_proof":"by (cases x) simp_all","source":"tropical_resource_typing/isabelle_synthetic","theorem":"option_map_compose","id":200200,"goal":"\"map_option f (map_option g x) = map_option (f \\ g) x\"","context":["simp","simp_all","cases","case","by"]} +{"prover":"Isabelle","tactic_proof":"by (cases s) simp_all","source":"tropical_resource_typing/isabelle_synthetic","theorem":"sum_type_comm","id":200201,"goal":"\"(case s of Inl a \\ Inr a | Inr b \\ Inl b) = swap_sum s\"","context":["simp","simp_all","cases","case","by"]} +{"prover":"Isabelle","tactic_proof":"by (cases p) auto","source":"tropical_resource_typing/isabelle_synthetic","theorem":"prod_type_assoc","id":200202,"goal":"\"(fst (fst p), snd (fst p), snd p) = prod_assoc p\"","context":["auto","cases","case","by"]} +{"prover":"Isabelle","tactic_proof":"by (induction t) auto","source":"tropical_resource_typing/isabelle_synthetic","theorem":"nested_induction","id":200203,"goal":"\"P Leaf \\ (\\l x r. P l \\ P r \\ P (Node l x r)) \\ P t\"","context":["auto","induction","induct","by"]} +{"prover":"Isabelle","tactic_proof":"by auto","source":"tropical_resource_typing/isabelle_synthetic","theorem":"auto_solve","id":200204,"goal":"\"A \\ B \\ B \\ C \\ A \\ C\"","context":["auto","by"]} +{"prover":"Isabelle","tactic_proof":"by (simp only: length_append)","source":"tropical_resource_typing/isabelle_synthetic","theorem":"simp_only","id":200205,"goal":"\"length (xs @ ys) = length xs + length ys\"","context":["simp","by"]} +{"prover":"Isabelle","tactic_proof":"by blast","source":"tropical_resource_typing/isabelle_synthetic","theorem":"blast_intro","id":200206,"goal":"\"\\ \\x. P x \\ Q x; P a \\ \\ Q a\"","context":["blast","by"]} +{"prover":"Isabelle","tactic_proof":"by (cases x) force+","source":"tropical_resource_typing/isabelle_synthetic","theorem":"force_cases","id":200207,"goal":"\"(x :: nat) = 0 \\ (\\n. x = Suc n)\"","context":["force","cases","case","by"]} +{"prover":"Isabelle","tactic_proof":"by fastforce","source":"tropical_resource_typing/isabelle_synthetic","theorem":"fastforce_dest","id":200208,"goal":"\"\\ x \\ A \\ B; A \\ C \\ \\ x \\ C\"","context":["force","fastforce","by"]} +{"prover":"Isabelle","tactic_proof":"by (metis mp)","source":"tropical_resource_typing/isabelle_synthetic","theorem":"metis_resolve","id":200209,"goal":"\"(P \\ Q) \\ P \\ Q\"","context":["by","metis"]} +{"prover":"Isabelle","tactic_proof":"by (smt (verit) add_pos_pos)","source":"tropical_resource_typing/isabelle_synthetic","theorem":"smt_arith","id":200210,"goal":"\"(x :: int) + y > 0 \\ x > 0 \\ y > 0\"","context":["by","smt"]} +{"prover":"Isabelle","tactic_proof":"by (metis add.right_inverse)","source":"tropical_resource_typing/isabelle_synthetic","theorem":"sledgehammer_pattern","id":200211,"goal":"\"(a :: 'a :: group_add) + (- a) = 0\"","context":["by","metis"]} +{"prover":"Isabelle","tactic_proof":"by (simp add: card_insert_le)","source":"tropical_resource_typing/isabelle_synthetic","theorem":"try_method","id":200212,"goal":"\"finite A \\ card (insert x A) \\ Suc (card A)\"","context":["simp","by"]} +{"prover":"Isabelle","tactic_proof":"by (rule order.trans)","source":"tropical_resource_typing/isabelle_synthetic","theorem":"method_combinator","id":200213,"goal":"\"(x :: nat) \\ y \\ y \\ z \\ x \\ z\"","context":["rule","by"]} diff --git a/training_data/proof_states_minizinc.jsonl b/training_data/proof_states_minizinc.jsonl index eb65f32..489928a 100644 --- a/training_data/proof_states_minizinc.jsonl +++ b/training_data/proof_states_minizinc.jsonl @@ -1533,3 +1533,58 @@ {"prover":"ORTools","tactic_proof":"{\"variables\":[\"var 0..1: assign[1..n, 1..n]\"],\"constraints\":[\"forall(i in 1..n)(sum(j in 1..n)(assign[i,j]) = 1)\",\"forall(j in 1..n)(sum(i in 1..n)(assign[i,j]) = 1)\",\"total_cost = sum(i,j in 1..n)(assign[i,j] * cost[i,j])\"]}","source":"constraint_synthetic/optimization","theorem":"assignment_problem","id":100532,"goal":"minimize total_cost","context":["forall(i in 1..n)(sum(j in 1..n)(assign[i,j]) = 1)","forall(j in 1..n)(sum(i in 1..n)(assign[i,j]) = 1)","total_cost = sum(i,j in 1..n)(assign[i,j] * cost[i,j])"]} {"prover":"SCIP","tactic_proof":"{\"variables\":[\"var 0..capacity[i,j]: flow[1..n, 1..n]\"],\"constraints\":[\"forall(v in 2..n-1)(sum(u)(flow[u,v]) = sum(w)(flow[v,w]))\",\"flow_value = sum(v)(flow[1,v])\"]}","source":"constraint_synthetic/optimization","theorem":"max_flow","id":100533,"goal":"maximize flow_value","context":["forall(v in 2..n-1)(sum(u)(flow[u,v]) = sum(w)(flow[v,w]))","flow_value = sum(v)(flow[1,v])"]} {"prover":"GLPK","tactic_proof":"{\"variables\":[\"var 0..capacity[i,j]: flow[1..n, 1..n]\"],\"constraints\":[\"forall(v in 1..n)(sum(u)(flow[u,v]) - sum(w)(flow[v,w]) = demand[v])\",\"total_cost = sum(i,j)(flow[i,j] * cost[i,j])\"]}","source":"constraint_synthetic/optimization","theorem":"min_cost_flow","id":100534,"goal":"minimize total_cost","context":["forall(v in 1..n)(sum(u)(flow[u,v]) - sum(w)(flow[v,w]) = demand[v])","total_cost = sum(i,j)(flow[i,j] * cost[i,j])"]} +{"prover":"MiniZinc","tactic_proof":"{\"variables\":[\"var 1..num_slots: schedule[1..num_courses]\"],\"constraints\":[\"forall(c in courses)(schedule[c] in available[c])\",\"forall(c1 in courses, c2 in courses where c1 < c2 /\\\\ shared_students[c1,c2] > 0)(schedule[c1] != schedule[c2])\",\"forall(r in rooms, s in slots)(sum(c in courses where schedule[c] = s /\\\\ room[c] = r)(1) <= 1)\",\"forall(t in teachers)(alldifferent([schedule[c] | c in courses where teacher[c] = t]))\"]}","source":"constraint_synthetic/timetabling","theorem":"university_timetable","id":100535,"goal":"satisfy","context":["forall(c in courses)(schedule[c] in available[c])","forall(c1 in courses, c2 in courses where c1 < c2 /\\ shared_students[c1,c2] > 0)(schedule[c1] != schedule[c2])","forall(r in rooms, s in slots)(sum(c in courses where schedule[c] = s /\\ room[c] = r)(1) <= 1)","forall(t in teachers)(alldifferent([schedule[c] | c in courses where teacher[c] = t]))"]} +{"prover":"Chuffed","tactic_proof":"{\"variables\":[\"var 1..max_slots: exam_slot[1..num_exams]\",\"var 0..1: slot_used[1..max_slots]\"],\"constraints\":[\"forall(e1,e2 in exams where conflict[e1,e2])(exam_slot[e1] != exam_slot[e2])\",\"forall(s in 1..max_slots)(slot_used[s] = (exists(e in exams)(exam_slot[e] = s)))\",\"num_slots_used = sum(s in 1..max_slots)(slot_used[s])\"]}","source":"constraint_synthetic/timetabling","theorem":"exam_scheduling","id":100536,"goal":"minimize num_slots_used","context":["forall(e1,e2 in exams where conflict[e1,e2])(exam_slot[e1] != exam_slot[e2])","forall(s in 1..max_slots)(slot_used[s] = (exists(e in exams)(exam_slot[e] = s)))","num_slots_used = sum(s in 1..max_slots)(slot_used[s])"]} +{"prover":"ORTools","tactic_proof":"{\"variables\":[\"var 1..num_rounds: round[1..num_matches]\",\"var teams: home[1..num_matches]\",\"var teams: away[1..num_matches]\"],\"constraints\":[\"forall(m in matches)(home[m] != away[m])\",\"forall(t in teams)(sum(m in matches)(home[m] = t \\\\/ away[m] = t) = num_rounds)\",\"forall(r in rounds)(alldifferent([home[m] | m in matches where round[m] = r] ++ [away[m] | m in matches where round[m] = r]))\"]}","source":"constraint_synthetic/timetabling","theorem":"sports_league","id":100537,"goal":"satisfy","context":["forall(m in matches)(home[m] != away[m])","forall(t in teams)(sum(m in matches)(home[m] = t \\/ away[m] = t) = num_rounds)","forall(r in rounds)(alldifferent([home[m] | m in matches where round[m] = r] ++ [away[m] | m in matches where round[m] = r]))"]} +{"prover":"SCIP","tactic_proof":"{\"variables\":[\"var 0..1: assign[1..num_crew, 1..num_flights]\"],\"constraints\":[\"forall(f in flights)(sum(c in crew)(assign[c,f]) >= min_crew[f])\",\"forall(c in crew)(sum(f in flights)(assign[c,f] * duration[f]) <= max_hours)\",\"total_crew_cost = sum(c in crew, f in flights)(assign[c,f] * cost[c,f])\"]}","source":"constraint_synthetic/timetabling","theorem":"crew_scheduling","id":100538,"goal":"minimize total_crew_cost","context":["forall(f in flights)(sum(c in crew)(assign[c,f]) >= min_crew[f])","forall(c in crew)(sum(f in flights)(assign[c,f] * duration[f]) <= max_hours)","total_crew_cost = sum(c in crew, f in flights)(assign[c,f] * cost[c,f])"]} +{"prover":"GLPK","tactic_proof":"{\"variables\":[\"var 1..num_rooms: assign[1..num_people]\"],\"constraints\":[\"alldifferent(assign)\",\"forall(p in people)(capacity[assign[p]] >= needs[p])\",\"max_distance = max(p1,p2 in people where collaborate[p1,p2])(distance[assign[p1], assign[p2]])\"]}","source":"constraint_synthetic/timetabling","theorem":"room_assignment","id":100539,"goal":"minimize max_distance","context":["alldifferent(assign)","forall(p in people)(capacity[assign[p]] >= needs[p])","max_distance = max(p1,p2 in people where collaborate[p1,p2])(distance[assign[p1], assign[p2]])"]} +{"prover":"MiniZinc","tactic_proof":"{\"variables\":[\"var 1..num_sessions: talk_session[1..num_talks]\",\"var 1..num_tracks: talk_track[1..num_talks]\"],\"constraints\":[\"forall(s in sessions, t in tracks)(sum(k in talks where talk_session[k] = s /\\\\ talk_track[k] = t)(1) <= 1)\",\"forall(k1,k2 in talks where same_speaker[k1,k2])(talk_session[k1] != talk_session[k2])\",\"forall(k in talks)(talk_track[k] in preferred_tracks[k])\"]}","source":"constraint_synthetic/timetabling","theorem":"conference_schedule","id":100540,"goal":"satisfy","context":["forall(s in sessions, t in tracks)(sum(k in talks where talk_session[k] = s /\\ talk_track[k] = t)(1) <= 1)","forall(k1,k2 in talks where same_speaker[k1,k2])(talk_session[k1] != talk_session[k2])","forall(k in talks)(talk_track[k] in preferred_tracks[k])"]} +{"prover":"ORTools","tactic_proof":"{\"variables\":[\"var 1..num_servers: assign[1..num_tasks]\"],\"constraints\":[\"forall(s in servers)(sum(t in tasks where assign[t] = s)(demand[t]) <= server_capacity[s])\",\"max_load = max(s in servers)(sum(t in tasks where assign[t] = s)(demand[t]))\"]}","source":"constraint_synthetic/network","theorem":"load_balancing","id":100541,"goal":"minimize max_load","context":["forall(s in servers)(sum(t in tasks where assign[t] = s)(demand[t]) <= server_capacity[s])","max_load = max(s in servers)(sum(t in tasks where assign[t] = s)(demand[t]))"]} +{"prover":"SCIP","tactic_proof":"{\"variables\":[\"var 1..max_wl: wavelength[1..num_paths]\"],\"constraints\":[\"forall(e in edges, p1,p2 in paths where p1 < p2 /\\\\ uses_edge[p1,e] /\\\\ uses_edge[p2,e])(wavelength[p1] != wavelength[p2])\",\"num_wavelengths = max(wavelength)\"]}","source":"constraint_synthetic/network","theorem":"wavelength_assignment","id":100542,"goal":"minimize num_wavelengths","context":["forall(e in edges, p1,p2 in paths where p1 < p2 /\\ uses_edge[p1,e] /\\ uses_edge[p2,e])(wavelength[p1] != wavelength[p2])","num_wavelengths = max(wavelength)"]} +{"prover":"GLPK","tactic_proof":"{\"variables\":[\"var 0.0..max_rate: rate[1..num_flows]\"],\"constraints\":[\"forall(e in edges)(sum(f in flows where uses_edge[f,e])(rate[f]) <= capacity[e])\",\"total_throughput = sum(f in flows)(rate[f])\"]}","source":"constraint_synthetic/network","theorem":"bandwidth_alloc","id":100543,"goal":"maximize total_throughput","context":["forall(e in edges)(sum(f in flows where uses_edge[f,e])(rate[f]) <= capacity[e])","total_throughput = sum(f in flows)(rate[f])"]} +{"prover":"MiniZinc","tactic_proof":"{\"variables\":[\"var 1..max_vlan: vlan[1..num_hosts]\"],\"constraints\":[\"forall(h1,h2 in hosts where must_separate[h1,h2])(vlan[h1] != vlan[h2])\",\"forall(h1,h2 in hosts where must_communicate[h1,h2])(vlan[h1] = vlan[h2])\",\"num_vlans = max(vlan)\"]}","source":"constraint_synthetic/network","theorem":"vlan_assignment","id":100544,"goal":"minimize num_vlans","context":["forall(h1,h2 in hosts where must_separate[h1,h2])(vlan[h1] != vlan[h2])","forall(h1,h2 in hosts where must_communicate[h1,h2])(vlan[h1] = vlan[h2])","num_vlans = max(vlan)"]} +{"prover":"Chuffed","tactic_proof":"{\"variables\":[\"var 0..1: open_wh[1..num_warehouses]\",\"var 0..1: serve[1..num_warehouses, 1..num_customers]\"],\"constraints\":[\"forall(c in customers)(sum(w in warehouses)(serve[w,c]) = 1)\",\"forall(w in warehouses, c in customers)(serve[w,c] <= open_wh[w])\",\"total_cost = sum(w)(open_wh[w]*fixed_cost[w]) + sum(w,c)(serve[w,c]*transport[w,c])\"]}","source":"constraint_synthetic/logistics","theorem":"warehouse_location","id":100545,"goal":"minimize total_cost","context":["forall(c in customers)(sum(w in warehouses)(serve[w,c]) = 1)","forall(w in warehouses, c in customers)(serve[w,c] <= open_wh[w])","total_cost = sum(w)(open_wh[w]*fixed_cost[w]) + sum(w,c)(serve[w,c]*transport[w,c])"]} +{"prover":"ORTools","tactic_proof":"{\"variables\":[\"var 0..num_customers: next[0..num_customers]\"],\"constraints\":[\"subcircuit(next)\",\"forall(v in vehicles)(cumulative_load[v] <= vehicle_cap)\",\"total_distance = sum(i in 0..num_customers)(dist[i, next[i]])\"]}","source":"constraint_synthetic/logistics","theorem":"fleet_routing","id":100546,"goal":"minimize total_distance","context":["subcircuit(next)","forall(v in vehicles)(cumulative_load[v] <= vehicle_cap)","total_distance = sum(i in 0..num_customers)(dist[i, next[i]])"]} +{"prover":"SCIP","tactic_proof":"{\"variables\":[\"var 0..max_order: order[1..num_periods]\",\"var 0..max_inv: inventory[1..num_periods]\"],\"constraints\":[\"forall(t in periods)(inventory[t] = inventory[t-1] + order[t] - demand[t])\",\"forall(t in periods)(inventory[t] >= safety_stock)\",\"total_holding = sum(t)(inventory[t]*hold_cost)\",\"total_ordering = sum(t)(if order[t] > 0 then setup_cost + order[t]*unit_cost else 0 endif)\"]}","source":"constraint_synthetic/logistics","theorem":"inventory_optimization","id":100547,"goal":"minimize total_holding + total_ordering","context":["forall(t in periods)(inventory[t] = inventory[t-1] + order[t] - demand[t])","forall(t in periods)(inventory[t] >= safety_stock)","total_holding = sum(t)(inventory[t]*hold_cost)","total_ordering = sum(t)(if order[t] > 0 then setup_cost + order[t]*unit_cost else 0 endif)"]} +{"prover":"GLPK","tactic_proof":"{\"variables\":[\"var 0..max_ship: ship[1..num_plants, 1..num_warehouses]\",\"var 0..max_ship: deliver[1..num_warehouses, 1..num_retailers]\"],\"constraints\":[\"forall(r in retailers)(sum(w in warehouses)(deliver[w,r]) >= demand[r])\",\"forall(w in warehouses)(sum(p in plants)(ship[p,w]) >= sum(r in retailers)(deliver[w,r]))\",\"forall(p in plants)(sum(w in warehouses)(ship[p,w]) <= capacity[p])\",\"total_supply_cost = sum(p,w)(ship[p,w]*cost_pw[p,w]) + sum(w,r)(deliver[w,r]*cost_wr[w,r])\"]}","source":"constraint_synthetic/logistics","theorem":"supply_chain","id":100548,"goal":"minimize total_supply_cost","context":["forall(r in retailers)(sum(w in warehouses)(deliver[w,r]) >= demand[r])","forall(w in warehouses)(sum(p in plants)(ship[p,w]) >= sum(r in retailers)(deliver[w,r]))","forall(p in plants)(sum(w in warehouses)(ship[p,w]) <= capacity[p])","total_supply_cost = sum(p,w)(ship[p,w]*cost_pw[p,w]) + sum(w,r)(deliver[w,r]*cost_wr[w,r])"]} +{"prover":"MiniZinc","tactic_proof":"{\"variables\":[\"var 0..max_time: depart[1..num_stops]\",\"var vehicles: truck[1..num_stops]\"],\"constraints\":[\"forall(s in stops)(depart[s] + service[s] + travel[s, next[s]] <= depart[next[s]])\",\"forall(s in stops)(depart[s] + max_cold_time >= depart[next[s]])\",\"forall(v in vehicles)(sum(s in stops where truck[s] = v)(demand[s]) <= truck_cap)\"]}","source":"constraint_synthetic/logistics","theorem":"cold_chain","id":100549,"goal":"satisfy","context":["forall(s in stops)(depart[s] + service[s] + travel[s, next[s]] <= depart[next[s]])","forall(s in stops)(depart[s] + max_cold_time >= depart[next[s]])","forall(v in vehicles)(sum(s in stops where truck[s] = v)(demand[s]) <= truck_cap)"]} +{"prover":"Chuffed","tactic_proof":"{\"variables\":[\"var 0..9: letter[1..num_letters]\"],\"constraints\":[\"alldifferent(letter)\",\"letter[leading1] > 0 /\\\\ letter[leading2] > 0\",\"sum(i in 1..len1)(letter[word1[i]] * pow10[len1-i]) + sum(i in 1..len2)(letter[word2[i]] * pow10[len2-i]) = sum(i in 1..len3)(letter[word3[i]] * pow10[len3-i])\"]}","source":"constraint_synthetic/puzzle","theorem":"cryptarithmetic","id":100550,"goal":"satisfy","context":["alldifferent(letter)","letter[leading1] > 0 /\\ letter[leading2] > 0","sum(i in 1..len1)(letter[word1[i]] * pow10[len1-i]) + sum(i in 1..len2)(letter[word2[i]] * pow10[len2-i]) = sum(i in 1..len3)(letter[word3[i]] * pow10[len3-i])"]} +{"prover":"SCIP","tactic_proof":"{\"variables\":[\"var 0..1: grid[1..rows, 1..cols]\"],\"constraints\":[\"forall(r in 1..rows)(check_runs(grid[r,..], row_clues[r]))\",\"forall(c in 1..cols)(check_runs(grid[..,c], col_clues[c]))\"]}","source":"constraint_synthetic/puzzle","theorem":"nonogram","id":100551,"goal":"satisfy","context":["forall(r in 1..rows)(check_runs(grid[r,..], row_clues[r]))","forall(c in 1..cols)(check_runs(grid[..,c], col_clues[c]))"]} +{"prover":"GLPK","tactic_proof":"{\"variables\":[\"var 1..n: grid[1..n, 1..n]\"],\"constraints\":[\"forall(r in 1..n)(alldifferent(grid[r, ..]))\",\"forall(c in 1..n)(alldifferent(grid[.., c]))\",\"forall(g in groups)(cage_constraint(grid, g, op[g], target[g]))\"]}","source":"constraint_synthetic/puzzle","theorem":"kenken","id":100552,"goal":"satisfy","context":["forall(r in 1..n)(alldifferent(grid[r, ..]))","forall(c in 1..n)(alldifferent(grid[.., c]))","forall(g in groups)(cage_constraint(grid, g, op[g], target[g]))"]} +{"prover":"MiniZinc","tactic_proof":"{\"variables\":[\"var 1..n: grid[1..n, 1..n]\"],\"constraints\":[\"forall(r in 1..n)(alldifferent(grid[r, ..]))\",\"forall(c in 1..n)(alldifferent(grid[.., c]))\",\"forall((r1,c1,r2,c2) in inequalities)(grid[r1,c1] < grid[r2,c2])\"]}","source":"constraint_synthetic/puzzle","theorem":"futoshiki","id":100553,"goal":"satisfy","context":["forall(r in 1..n)(alldifferent(grid[r, ..]))","forall(c in 1..n)(alldifferent(grid[.., c]))","forall((r1,c1,r2,c2) in inequalities)(grid[r1,c1] < grid[r2,c2])"]} +{"prover":"Chuffed","tactic_proof":"{\"variables\":[\"var 1..n*m: cell[1..n, 1..m]\"],\"constraints\":[\"alldifferent(array1d(cell))\",\"forall(v in 1..n*m-1)(exists(r1,c1,r2,c2 in positions where adjacent(r1,c1,r2,c2))(cell[r1,c1] = v /\\\\ cell[r2,c2] = v+1))\"]}","source":"constraint_synthetic/puzzle","theorem":"hidato","id":100554,"goal":"satisfy","context":["alldifferent(array1d(cell))","forall(v in 1..n*m-1)(exists(r1,c1,r2,c2 in positions where adjacent(r1,c1,r2,c2))(cell[r1,c1] = v /\\ cell[r2,c2] = v+1))"]} +{"prover":"ORTools","tactic_proof":"{\"variables\":[\"var 0..max_prod: produce[1..num_periods]\",\"var 0..1: setup[1..num_periods]\"],\"constraints\":[\"forall(t in periods)(produce[t] <= big_M * setup[t])\",\"forall(t in periods)(inventory[t] = inventory[t-1] + produce[t] - demand[t])\",\"forall(t in periods)(inventory[t] >= 0)\",\"total_production_cost = sum(t)(setup[t]*setup_cost + produce[t]*prod_cost + inventory[t]*hold_cost)\"]}","source":"constraint_synthetic/production","theorem":"lot_sizing","id":100555,"goal":"minimize total_production_cost","context":["forall(t in periods)(produce[t] <= big_M * setup[t])","forall(t in periods)(inventory[t] = inventory[t-1] + produce[t] - demand[t])","forall(t in periods)(inventory[t] >= 0)","total_production_cost = sum(t)(setup[t]*setup_cost + produce[t]*prod_cost + inventory[t]*hold_cost)"]} +{"prover":"SCIP","tactic_proof":"{\"variables\":[\"var 1..num_stations: station[1..num_tasks]\"],\"constraints\":[\"forall((i,j) in precedences)(station[i] <= station[j])\",\"forall(s in stations)(sum(t in tasks where station[t] = s)(proc_time[t]) <= cycle_time)\",\"cycle_time >= max(s in stations)(sum(t in tasks where station[t] = s)(proc_time[t]))\"]}","source":"constraint_synthetic/production","theorem":"assembly_line","id":100556,"goal":"minimize cycle_time","context":["forall((i,j) in precedences)(station[i] <= station[j])","forall(s in stations)(sum(t in tasks where station[t] = s)(proc_time[t]) <= cycle_time)","cycle_time >= max(s in stations)(sum(t in tasks where station[t] = s)(proc_time[t]))"]} +{"prover":"GLPK","tactic_proof":"{\"variables\":[\"var 0..max_workers: hire[1..num_periods]\",\"var 0..max_workers: fire[1..num_periods]\",\"var 0..max_workers: workforce[1..num_periods]\"],\"constraints\":[\"forall(t in periods)(workforce[t] = workforce[t-1] + hire[t] - fire[t])\",\"forall(t in periods)(workforce[t] >= min_demand[t])\",\"total_labor_cost = sum(t)(hire[t]*hire_cost + fire[t]*fire_cost + workforce[t]*wage)\"]}","source":"constraint_synthetic/production","theorem":"workforce_planning","id":100557,"goal":"minimize total_labor_cost","context":["forall(t in periods)(workforce[t] = workforce[t-1] + hire[t] - fire[t])","forall(t in periods)(workforce[t] >= min_demand[t])","total_labor_cost = sum(t)(hire[t]*hire_cost + fire[t]*fire_cost + workforce[t]*wage)"]} +{"prover":"MiniZinc","tactic_proof":"{\"variables\":[\"var 0..1: maintain[1..num_machines, 1..num_periods]\"],\"constraints\":[\"forall(m in machines)(sum(t in periods)(maintain[m,t]) >= min_maintenance[m])\",\"forall(t in periods)(sum(m in machines)(maintain[m,t]) <= max_simultaneous)\",\"total_downtime = sum(m,t)(maintain[m,t] * downtime[m])\"]}","source":"constraint_synthetic/production","theorem":"preventive_maintenance","id":100558,"goal":"minimize total_downtime","context":["forall(m in machines)(sum(t in periods)(maintain[m,t]) >= min_maintenance[m])","forall(t in periods)(sum(m in machines)(maintain[m,t]) <= max_simultaneous)","total_downtime = sum(m,t)(maintain[m,t] * downtime[m])"]} +{"prover":"Chuffed","tactic_proof":"{\"variables\":[\"var 0.0..1.0: mix[1..num_ingredients]\"],\"constraints\":[\"sum(mix) = 1.0\",\"forall(p in properties)(sum(i in ingredients)(mix[i] * prop_value[i,p]) >= min_prop[p])\",\"forall(p in properties)(sum(i in ingredients)(mix[i] * prop_value[i,p]) <= max_prop[p])\",\"total_yield = sum(i in ingredients)(mix[i] * yield_rate[i])\"]}","source":"constraint_synthetic/production","theorem":"yield_optimization","id":100559,"goal":"maximize total_yield","context":["sum(mix) = 1.0","forall(p in properties)(sum(i in ingredients)(mix[i] * prop_value[i,p]) >= min_prop[p])","forall(p in properties)(sum(i in ingredients)(mix[i] * prop_value[i,p]) <= max_prop[p])","total_yield = sum(i in ingredients)(mix[i] * yield_rate[i])"]} +{"prover":"ORTools","tactic_proof":"{\"variables\":[\"var 0.0..max_gen: output[1..num_generators]\"],\"constraints\":[\"sum(g in generators)(output[g]) >= total_demand\",\"forall(g in generators)(output[g] >= min_output[g] \\\\/ output[g] = 0)\",\"forall(g in generators)(output[g] <= max_output[g])\",\"total_generation_cost = sum(g)(output[g] * cost_per_mw[g])\"]}","source":"constraint_synthetic/energy","theorem":"power_grid_dispatch","id":100560,"goal":"minimize total_generation_cost","context":["sum(g in generators)(output[g]) >= total_demand","forall(g in generators)(output[g] >= min_output[g] \\/ output[g] = 0)","forall(g in generators)(output[g] <= max_output[g])","total_generation_cost = sum(g)(output[g] * cost_per_mw[g])"]} +{"prover":"SCIP","tactic_proof":"{\"variables\":[\"var -max_rate..max_rate: charge[1..num_periods]\",\"var 0.0..capacity: soc[1..num_periods]\"],\"constraints\":[\"forall(t in periods)(soc[t] = soc[t-1] + charge[t] * efficiency)\",\"forall(t in periods)(soc[t] >= min_soc /\\\\ soc[t] <= max_soc)\",\"electricity_cost = sum(t)(max(0, demand[t] + charge[t]) * price[t])\"]}","source":"constraint_synthetic/energy","theorem":"battery_scheduling","id":100561,"goal":"minimize electricity_cost","context":["forall(t in periods)(soc[t] = soc[t-1] + charge[t] * efficiency)","forall(t in periods)(soc[t] >= min_soc /\\ soc[t] <= max_soc)","electricity_cost = sum(t)(max(0, demand[t] + charge[t]) * price[t])"]} +{"prover":"GLPK","tactic_proof":"{\"variables\":[\"var 1..num_chargers: assign_charger[1..num_vehicles]\",\"var 0..horizon: start_charge[1..num_vehicles]\"],\"constraints\":[\"forall(c in chargers, t in periods)(sum(v in vehicles where assign_charger[v]=c /\\\\ start_charge[v]<=t /\\\\ t= arrival[v])\",\"total_wait = sum(v)(start_charge[v] - arrival[v])\"]}","source":"constraint_synthetic/energy","theorem":"ev_charging","id":100562,"goal":"minimize total_wait","context":["forall(c in chargers, t in periods)(sum(v in vehicles where assign_charger[v]=c /\\ start_charge[v]<=t /\\ t= arrival[v])","total_wait = sum(v)(start_charge[v] - arrival[v])"]} +{"prover":"MiniZinc","tactic_proof":"{\"variables\":[\"var 0..1: place[1..num_positions]\"],\"constraints\":[\"sum(place) <= max_panels\",\"forall(p1,p2 in positions where p1= 0)\",\"total_tardiness = sum(s)(max(0, surgery_start[s]+duration[s]-deadline[s]))\"]}","source":"constraint_synthetic/healthcare","theorem":"surgery_scheduling","id":100565,"goal":"minimize total_tardiness","context":["forall(o in ors)(disjunctive([surgery_start[s] | s where or_assign[s]=o], [duration[s] | s where or_assign[s]=o]))","forall(s in surgeries)(surgery_start[s] + duration[s] <= deadline[s] \\/ tardiness[s] >= 0)","total_tardiness = sum(s)(max(0, surgery_start[s]+duration[s]-deadline[s]))"]} +{"prover":"SCIP","tactic_proof":"{\"variables\":[\"var 1..num_wards: bed_ward[1..num_patients]\"],\"constraints\":[\"forall(w in wards)(sum(p in patients where bed_ward[p]=w)(1) <= ward_capacity[w])\",\"forall(p in patients)(bed_ward[p] in compatible_wards[p])\",\"total_transfer = sum(p)(if bed_ward[p] != preferred_ward[p] then 1 else 0 endif)\"]}","source":"constraint_synthetic/healthcare","theorem":"patient_bed_assignment","id":100566,"goal":"minimize total_transfer","context":["forall(w in wards)(sum(p in patients where bed_ward[p]=w)(1) <= ward_capacity[w])","forall(p in patients)(bed_ward[p] in compatible_wards[p])","total_transfer = sum(p)(if bed_ward[p] != preferred_ward[p] then 1 else 0 endif)"]} +{"prover":"GLPK","tactic_proof":"{\"variables\":[\"var 1..num_stations: base[1..num_ambulances]\"],\"constraints\":[\"forall(z in zones)(sum(a in ambulances where travel_time[base[a],z] <= max_allowed)(1) >= coverage_req[z])\",\"forall(s in stations)(sum(a in ambulances where base[a]=s)(1) <= station_cap[s])\",\"max_response_time = max(z in zones)(min(a in ambulances)(travel_time[base[a],z]))\"]}","source":"constraint_synthetic/healthcare","theorem":"ambulance_dispatch","id":100567,"goal":"minimize max_response_time","context":["forall(z in zones)(sum(a in ambulances where travel_time[base[a],z] <= max_allowed)(1) >= coverage_req[z])","forall(s in stations)(sum(a in ambulances where base[a]=s)(1) <= station_cap[s])","max_response_time = max(z in zones)(min(a in ambulances)(travel_time[base[a],z]))"]} +{"prover":"MiniZinc","tactic_proof":"{\"variables\":[\"var shifts: roster[1..num_nurses, 1..num_days]\"],\"constraints\":[\"forall(d in days, s in shifts)(sum(n in nurses where roster[n,d]=s)(1) >= demand[d,s])\",\"forall(n in nurses, d in 1..num_days-1)(not(roster[n,d]=night /\\\\ roster[n,d+1]=morning))\",\"forall(n in nurses)(sum(d in days where roster[n,d]!=off)(1) <= max_shifts_per_nurse)\",\"preference_violations = sum(n,d)(if roster[n,d] != preferred[n,d] then 1 else 0 endif)\"]}","source":"constraint_synthetic/healthcare","theorem":"nurse_rostering","id":100568,"goal":"minimize preference_violations","context":["forall(d in days, s in shifts)(sum(n in nurses where roster[n,d]=s)(1) >= demand[d,s])","forall(n in nurses, d in 1..num_days-1)(not(roster[n,d]=night /\\ roster[n,d+1]=morning))","forall(n in nurses)(sum(d in days where roster[n,d]!=off)(1) <= max_shifts_per_nurse)","preference_violations = sum(n,d)(if roster[n,d] != preferred[n,d] then 1 else 0 endif)"]} +{"prover":"Chuffed","tactic_proof":"{\"variables\":[\"var 1..num_slots: maintain_slot[1..num_machines]\"],\"constraints\":[\"forall(t in slots)(sum(m where maintain_slot[m]=t)(1) <= max_simultaneous)\",\"forall(m in machines)(maintain_slot[m] >= earliest_maint[m])\",\"total_downtime = sum(m)(downtime_cost[m])\"]}","source":"constraint_synthetic/healthcare","theorem":"equipment_maintenance","id":100569,"goal":"minimize total_downtime","context":["forall(t in slots)(sum(m where maintain_slot[m]=t)(1) <= max_simultaneous)","forall(m in machines)(maintain_slot[m] >= earliest_maint[m])","total_downtime = sum(m)(downtime_cost[m])"]} +{"prover":"ORTools","tactic_proof":"{\"variables\":[\"var 1..num_groups: group[1..num_students]\"],\"constraints\":[\"forall(g in groups)(sum(s where group[s]=g)(1) >= min_group_size)\",\"forall(g in groups)(sum(s where group[s]=g)(1) <= max_group_size)\",\"group_imbalance = max(g1,g2 in groups)(abs(sum(s where group[s]=g1)(1) - sum(s where group[s]=g2)(1)))\"]}","source":"constraint_synthetic/education","theorem":"student_grouping","id":100570,"goal":"minimize group_imbalance","context":["forall(g in groups)(sum(s where group[s]=g)(1) >= min_group_size)","forall(g in groups)(sum(s where group[s]=g)(1) <= max_group_size)","group_imbalance = max(g1,g2 in groups)(abs(sum(s where group[s]=g1)(1) - sum(s where group[s]=g2)(1)))"]} +{"prover":"SCIP","tactic_proof":"{\"variables\":[\"var 1..num_rooms: room[1..num_classes]\"],\"constraints\":[\"forall(c in classes)(capacity[room[c]] >= class_size[c])\",\"forall(t in timeslots)(alldifferent([room[c] | c where timeslot[c]=t]))\",\"forall(c in classes)(room[c] in compatible_rooms[c])\"]}","source":"constraint_synthetic/education","theorem":"classroom_assignment","id":100571,"goal":"satisfy","context":["forall(c in classes)(capacity[room[c]] >= class_size[c])","forall(t in timeslots)(alldifferent([room[c] | c where timeslot[c]=t]))","forall(c in classes)(room[c] in compatible_rooms[c])"]} +{"prover":"GLPK","tactic_proof":"{\"variables\":[\"var 1..num_semesters: semester[1..num_courses]\"],\"constraints\":[\"forall((c1,c2) in prerequisites)(semester[c1] < semester[c2])\",\"forall(s in semesters)(sum(c where semester[c]=s)(credits[c]) <= max_credits)\",\"total_penalty = sum(c)(abs(semester[c] - ideal_semester[c]))\"]}","source":"constraint_synthetic/education","theorem":"curriculum_sequencing","id":100572,"goal":"minimize total_penalty","context":["forall((c1,c2) in prerequisites)(semester[c1] < semester[c2])","forall(s in semesters)(sum(c where semester[c]=s)(credits[c]) <= max_credits)","total_penalty = sum(c)(abs(semester[c] - ideal_semester[c]))"]} +{"prover":"MiniZinc","tactic_proof":"{\"variables\":[\"var 1..num_labs: lab_assign[1..num_students, 1..num_rotations]\"],\"constraints\":[\"forall(s in students)(alldifferent(lab_assign[s, ..]))\",\"forall(r in rotations, l in labs)(sum(s where lab_assign[s,r]=l)(1) <= lab_capacity[l])\"]}","source":"constraint_synthetic/education","theorem":"lab_rotation","id":100573,"goal":"satisfy","context":["forall(s in students)(alldifferent(lab_assign[s, ..]))","forall(r in rotations, l in labs)(sum(s where lab_assign[s,r]=l)(1) <= lab_capacity[l])"]} +{"prover":"Chuffed","tactic_proof":"{\"variables\":[\"var 1..num_teams: team[1..num_students]\"],\"constraints\":[\"forall(t in teams)(sum(s where team[s]=t)(1) >= 3 /\\\\ sum(s where team[s]=t)(1) <= 5)\",\"forall(s1,s2 where conflict[s1,s2])(team[s1] != team[s2])\",\"team_diversity = min(t in teams)(card({skill[s] | s where team[s]=t}))\"]}","source":"constraint_synthetic/education","theorem":"project_team","id":100574,"goal":"maximize team_diversity","context":["forall(t in teams)(sum(s where team[s]=t)(1) >= 3 /\\ sum(s where team[s]=t)(1) <= 5)","forall(s1,s2 where conflict[s1,s2])(team[s1] != team[s2])","team_diversity = min(t in teams)(card({skill[s] | s where team[s]=t}))"]} +{"prover":"ORTools","tactic_proof":"{\"variables\":[\"var 0..1: build[1..num_candidate_sites]\"],\"constraints\":[\"forall(c in customers)(sum(s in sites where covers(s,c))(build[s]) >= 1)\",\"num_towers = sum(build)\"]}","source":"constraint_synthetic/telecommunications","theorem":"cell_tower_placement","id":100575,"goal":"minimize num_towers","context":["forall(c in customers)(sum(s in sites where covers(s,c))(build[s]) >= 1)","num_towers = sum(build)"]} +{"prover":"SCIP","tactic_proof":"{\"variables\":[\"var 1..max_freq: freq[1..num_towers]\"],\"constraints\":[\"forall(t1,t2 in towers where interferes(t1,t2))(abs(freq[t1]-freq[t2]) >= min_gap)\",\"max_frequency = max(freq)\"]}","source":"constraint_synthetic/telecommunications","theorem":"frequency_assignment","id":100576,"goal":"minimize max_frequency","context":["forall(t1,t2 in towers where interferes(t1,t2))(abs(freq[t1]-freq[t2]) >= min_gap)","max_frequency = max(freq)"]} +{"prover":"GLPK","tactic_proof":"{\"variables\":[\"var 0..max_bw: bandwidth[1..num_slices, 1..num_links]\"],\"constraints\":[\"forall(l in links)(sum(s in slices)(bandwidth[s,l]) <= link_capacity[l])\",\"forall(s in slices)(sum(l in paths[s])(bandwidth[s,l]) >= min_bw[s])\",\"total_throughput = sum(s)(sum(l)(bandwidth[s,l]) * priority[s])\"]}","source":"constraint_synthetic/telecommunications","theorem":"network_slicing","id":100577,"goal":"maximize total_throughput","context":["forall(l in links)(sum(s in slices)(bandwidth[s,l]) <= link_capacity[l])","forall(s in slices)(sum(l in paths[s])(bandwidth[s,l]) >= min_bw[s])","total_throughput = sum(s)(sum(l)(bandwidth[s,l]) * priority[s])"]} +{"prover":"MiniZinc","tactic_proof":"{\"variables\":[\"var 1..num_racks: server_rack[1..num_servers]\"],\"constraints\":[\"forall(r in racks)(sum(s where server_rack[s]=r)(heat[s]) <= max_heat[r])\",\"forall(r in racks)(sum(s where server_rack[s]=r)(1) <= rack_slots[r])\",\"cooling_cost = sum(r)(cooling_rate[r] * sum(s where server_rack[s]=r)(heat[s]))\"]}","source":"constraint_synthetic/telecommunications","theorem":"data_center_cooling","id":100578,"goal":"minimize cooling_cost","context":["forall(r in racks)(sum(s where server_rack[s]=r)(heat[s]) <= max_heat[r])","forall(r in racks)(sum(s where server_rack[s]=r)(1) <= rack_slots[r])","cooling_cost = sum(r)(cooling_rate[r] * sum(s where server_rack[s]=r)(heat[s]))"]} +{"prover":"Chuffed","tactic_proof":"{\"variables\":[\"var 0..1: allocate[1..num_users, 1..num_channels]\"],\"constraints\":[\"forall(c in channels)(sum(u in users)(allocate[u,c]) <= 1)\",\"forall(u1,u2 in users where u1= min_moisture[z])\",\"forall(t in periods)(sum(z)(irrigate[z,t]) <= pump_capacity)\",\"water_usage = sum(z,t)(irrigate[z,t])\"]}","source":"constraint_synthetic/agriculture","theorem":"irrigation_scheduling","id":100581,"goal":"minimize water_usage","context":["forall(z in zones, t in periods)(soil_moisture[z,t] >= min_moisture[z])","forall(t in periods)(sum(z)(irrigate[z,t]) <= pump_capacity)","water_usage = sum(z,t)(irrigate[z,t])"]} +{"prover":"GLPK","tactic_proof":"{\"variables\":[\"var 1..num_days: harvest_day[1..num_plots]\"],\"constraints\":[\"forall(d in days)(sum(p where harvest_day[p]=d)(area[p]) <= daily_capacity)\",\"total_loss = sum(p)(if harvest_day[p] > optimal_day[p] then (harvest_day[p]-optimal_day[p])*loss_rate[p] else 0 endif)\"]}","source":"constraint_synthetic/agriculture","theorem":"harvest_planning","id":100582,"goal":"minimize total_loss","context":["forall(d in days)(sum(p where harvest_day[p]=d)(area[p]) <= daily_capacity)","total_loss = sum(p)(if harvest_day[p] > optimal_day[p] then (harvest_day[p]-optimal_day[p])*loss_rate[p] else 0 endif)"]} +{"prover":"MiniZinc","tactic_proof":"{\"variables\":[\"var 0.0..max_amount: amount[1..num_fertilizers]\"],\"constraints\":[\"forall(n in nutrients)(sum(f)(amount[f]*nutrient_content[f,n]) >= min_nutrient[n])\",\"forall(n in nutrients)(sum(f)(amount[f]*nutrient_content[f,n]) <= max_nutrient[n])\",\"fertilizer_cost = sum(f)(amount[f]*price[f])\"]}","source":"constraint_synthetic/agriculture","theorem":"fertilizer_mix","id":100583,"goal":"minimize fertilizer_cost","context":["forall(n in nutrients)(sum(f)(amount[f]*nutrient_content[f,n]) >= min_nutrient[n])","forall(n in nutrients)(sum(f)(amount[f]*nutrient_content[f,n]) <= max_nutrient[n])","fertilizer_cost = sum(f)(amount[f]*price[f])"]} +{"prover":"Chuffed","tactic_proof":"{\"variables\":[\"var 0..max_heat: heating[1..num_periods]\",\"var 0..max_vent: ventilation[1..num_periods]\"],\"constraints\":[\"forall(t in periods)(temperature[t] >= min_temp /\\\\ temperature[t] <= max_temp)\",\"forall(t in periods)(humidity[t] >= min_humid /\\\\ humidity[t] <= max_humid)\",\"energy_cost = sum(t)(heating[t]*heat_price + ventilation[t]*vent_price)\"]}","source":"constraint_synthetic/agriculture","theorem":"greenhouse_climate","id":100584,"goal":"minimize energy_cost","context":["forall(t in periods)(temperature[t] >= min_temp /\\ temperature[t] <= max_temp)","forall(t in periods)(humidity[t] >= min_humid /\\ humidity[t] <= max_humid)","energy_cost = sum(t)(heating[t]*heat_price + ventilation[t]*vent_price)"]} +{"prover":"ORTools","tactic_proof":"{\"variables\":[\"var 0..1: loaded[1..num_tools, 1..num_jobs]\"],\"constraints\":[\"forall(j in jobs, t in required_tools[j])(loaded[t,j] = 1)\",\"forall(j in jobs)(sum(t in tools)(loaded[t,j]) <= magazine_capacity)\",\"tool_changes = sum(j in 2..num_jobs, t in tools)(abs(loaded[t,j]-loaded[t,j-1]))\"]}","source":"constraint_synthetic/manufacturing","theorem":"tool_magazine","id":100585,"goal":"minimize tool_changes","context":["forall(j in jobs, t in required_tools[j])(loaded[t,j] = 1)","forall(j in jobs)(sum(t in tools)(loaded[t,j]) <= magazine_capacity)","tool_changes = sum(j in 2..num_jobs, t in tools)(abs(loaded[t,j]-loaded[t,j-1]))"]} +{"prover":"SCIP","tactic_proof":"{\"variables\":[\"var 1..num_feeders: feeder[1..num_components]\",\"var 1..num_nozzles: nozzle[1..num_components]\"],\"constraints\":[\"forall(c in components)(feeder[c] in compatible_feeders[c])\",\"forall(c in components)(nozzle[c] in compatible_nozzles[c])\",\"cycle_time = max(placement_time)\"]}","source":"constraint_synthetic/manufacturing","theorem":"pcb_assembly","id":100586,"goal":"minimize cycle_time","context":["forall(c in components)(feeder[c] in compatible_feeders[c])","forall(c in components)(nozzle[c] in compatible_nozzles[c])","cycle_time = max(placement_time)"]} +{"prover":"GLPK","tactic_proof":"{\"variables\":[\"var 0..max_cuts: cut[1..num_patterns]\"],\"constraints\":[\"forall(w in widths)(sum(p)(pattern[p,w]*cut[p]) >= demand[w])\",\"waste = sum(p)(cut[p]*waste_per_pattern[p])\"]}","source":"constraint_synthetic/manufacturing","theorem":"steel_cutting","id":100587,"goal":"minimize waste","context":["forall(w in widths)(sum(p)(pattern[p,w]*cut[p]) >= demand[w])","waste = sum(p)(cut[p]*waste_per_pattern[p])"]} +{"prover":"MiniZinc","tactic_proof":"{\"variables\":[\"var 0.0..max_batch: batch_size[1..num_batches]\",\"var 0.0..1.0: proportion[1..num_batches, 1..num_ingredients]\"],\"constraints\":[\"forall(b in batches)(sum(i)(proportion[b,i]) = 1.0)\",\"forall(b in batches, p in properties)(sum(i)(proportion[b,i]*prop_val[i,p]) >= min_spec[p])\",\"forall(b in batches, p in properties)(sum(i)(proportion[b,i]*prop_val[i,p]) <= max_spec[p])\"]}","source":"constraint_synthetic/manufacturing","theorem":"batch_mixing","id":100588,"goal":"satisfy","context":["forall(b in batches)(sum(i)(proportion[b,i]) = 1.0)","forall(b in batches, p in properties)(sum(i)(proportion[b,i]*prop_val[i,p]) >= min_spec[p])","forall(b in batches, p in properties)(sum(i)(proportion[b,i]*prop_val[i,p]) <= max_spec[p])"]} +{"prover":"Chuffed","tactic_proof":"{\"variables\":[\"var 0..1: inspect[1..num_stations, 1..num_products]\"],\"constraints\":[\"forall(p in products)(sum(s)(inspect[s,p]) >= min_inspections[p])\",\"forall(s in stations)(sum(p)(inspect[s,p]*inspect_time[s]) <= station_time_budget[s])\",\"inspection_cost = sum(s,p)(inspect[s,p]*cost_per_inspection[s])\"]}","source":"constraint_synthetic/manufacturing","theorem":"quality_inspection","id":100589,"goal":"minimize inspection_cost","context":["forall(p in products)(sum(s)(inspect[s,p]) >= min_inspections[p])","forall(s in stations)(sum(p)(inspect[s,p]*inspect_time[s]) <= station_time_budget[s])","inspection_cost = sum(s,p)(inspect[s,p]*cost_per_inspection[s])"]} diff --git a/training_data/proof_states_minlog.jsonl b/training_data/proof_states_minlog.jsonl index 8e26368..2d327f0 100644 --- a/training_data/proof_states_minlog.jsonl +++ b/training_data/proof_states_minlog.jsonl @@ -1,148 +1,148 @@ -{"id":88500,"prover":"Minlog","theorem":"imp_refl","goal":"A -> A","context":["assume A","exact A"],"tactic_proof":"assume A; exact A","source":"minlog_synthetic/natural_deduction"} -{"id":88501,"prover":"Minlog","theorem":"imp_trans","goal":"(A -> B) -> (B -> C) -> A -> C","context":["assume f","assume g","assume a","exact (g (f a))"],"tactic_proof":"assume f; assume g; assume a; exact (g (f a))","source":"minlog_synthetic/natural_deduction"} -{"id":88502,"prover":"Minlog","theorem":"and_intro","goal":"A -> B -> A /\\ B","context":["assume a","assume b","split","exact a","exact b"],"tactic_proof":"assume a; assume b; split; [exact a | exact b]","source":"minlog_synthetic/natural_deduction"} -{"id":88503,"prover":"Minlog","theorem":"and_elim_l","goal":"A /\\ B -> A","context":["assume h","elim h","assume a","assume b","exact a"],"tactic_proof":"assume h; elim h; assume a; assume b; exact a","source":"minlog_synthetic/natural_deduction"} -{"id":88504,"prover":"Minlog","theorem":"and_elim_r","goal":"A /\\ B -> B","context":["assume h","elim h","assume a","assume b","exact b"],"tactic_proof":"assume h; elim h; assume a; assume b; exact b","source":"minlog_synthetic/natural_deduction"} -{"id":88505,"prover":"Minlog","theorem":"or_intro_l","goal":"A -> A \\/ B","context":["assume a","left","exact a"],"tactic_proof":"assume a; left; exact a","source":"minlog_synthetic/natural_deduction"} -{"id":88506,"prover":"Minlog","theorem":"or_intro_r","goal":"B -> A \\/ B","context":["assume b","right","exact b"],"tactic_proof":"assume b; right; exact b","source":"minlog_synthetic/natural_deduction"} -{"id":88507,"prover":"Minlog","theorem":"or_elim","goal":"(A -> C) -> (B -> C) -> A \\/ B -> C","context":["assume f","assume g","assume h","elim h","assume a","exact (f a)","assume b","exact (g b)"],"tactic_proof":"assume f; assume g; assume h; elim h; [assume a; exact (f a) | assume b; exact (g b)]","source":"minlog_synthetic/natural_deduction"} -{"id":88508,"prover":"Minlog","theorem":"false_elim","goal":"F -> A","context":["assume h","elim h"],"tactic_proof":"assume h; elim h","source":"minlog_synthetic/natural_deduction"} -{"id":88509,"prover":"Minlog","theorem":"not_intro","goal":"(A -> F) -> ~A","context":["assume f","intro","exact f"],"tactic_proof":"assume f; intro; exact f","source":"minlog_synthetic/natural_deduction"} -{"id":88510,"prover":"Minlog","theorem":"double_neg_intro","goal":"A -> ~~A","context":["assume a","assume h","exact (h a)"],"tactic_proof":"assume a; assume h; exact (h a)","source":"minlog_synthetic/natural_deduction"} -{"id":88511,"prover":"Minlog","theorem":"contrapositive","goal":"(A -> B) -> ~B -> ~A","context":["assume f","assume nb","assume a","exact (nb (f a))"],"tactic_proof":"assume f; assume nb; assume a; exact (nb (f a))","source":"minlog_synthetic/natural_deduction"} -{"id":88512,"prover":"Minlog","theorem":"and_comm","goal":"A /\\ B -> B /\\ A","context":["assume h","elim h","assume a","assume b","split","exact b","exact a"],"tactic_proof":"assume h; elim h; assume a; assume b; split; [exact b | exact a]","source":"minlog_synthetic/natural_deduction"} -{"id":88513,"prover":"Minlog","theorem":"or_comm","goal":"A \\/ B -> B \\/ A","context":["assume h","elim h","assume a","right","exact a","assume b","left","exact b"],"tactic_proof":"assume h; elim h; [assume a; right; exact a | assume b; left; exact b]","source":"minlog_synthetic/natural_deduction"} -{"id":88514,"prover":"Minlog","theorem":"curry","goal":"(A /\\ B -> C) -> A -> B -> C","context":["assume f","assume a","assume b","exact (f (a, b))"],"tactic_proof":"assume f; assume a; assume b; exact (f (a, b))","source":"minlog_synthetic/natural_deduction"} -{"id":88515,"prover":"Minlog","theorem":"add_zero","goal":"all n. n + 0 = n","context":["ind on n","refl","assume IH","simp","exact IH"],"tactic_proof":"ind on n; [refl | assume IH; simp; exact IH]","source":"minlog_synthetic/arithmetic_extraction"} -{"id":88516,"prover":"Minlog","theorem":"add_succ","goal":"all m n. m + S(n) = S(m + n)","context":["ind on m","refl","assume IH","simp","use IH"],"tactic_proof":"ind on m; [refl | assume IH; simp; use IH]","source":"minlog_synthetic/arithmetic_extraction"} -{"id":88517,"prover":"Minlog","theorem":"add_comm","goal":"all m n. m + n = n + m","context":["ind on m","use add_zero","assume IH","simp","use add_succ","use IH"],"tactic_proof":"ind on m; [use add_zero | assume IH; simp; use add_succ; use IH]","source":"minlog_synthetic/arithmetic_extraction"} -{"id":88518,"prover":"Minlog","theorem":"add_assoc","goal":"all m n k. (m + n) + k = m + (n + k)","context":["ind on m","refl","assume IH","simp","use IH"],"tactic_proof":"ind on m; [refl | assume IH; simp; use IH]","source":"minlog_synthetic/arithmetic_extraction"} -{"id":88519,"prover":"Minlog","theorem":"mul_zero","goal":"all n. n * 0 = 0","context":["ind on n","refl","assume IH","simp","use IH"],"tactic_proof":"ind on n; [refl | assume IH; simp; use IH]","source":"minlog_synthetic/arithmetic_extraction"} -{"id":88520,"prover":"Minlog","theorem":"mul_succ","goal":"all m n. m * S(n) = m + m * n","context":["ind on m","refl","assume IH","simp","use IH","use add_assoc","use add_comm"],"tactic_proof":"ind on m; [refl | assume IH; simp; use IH; use add_assoc; use add_comm]","source":"minlog_synthetic/arithmetic_extraction"} -{"id":88521,"prover":"Minlog","theorem":"mul_comm","goal":"all m n. m * n = n * m","context":["ind on m","use mul_zero","assume IH","simp","use mul_succ","use IH"],"tactic_proof":"ind on m; [use mul_zero | assume IH; simp; use mul_succ; use IH]","source":"minlog_synthetic/arithmetic_extraction"} -{"id":88522,"prover":"Minlog","theorem":"sub_self","goal":"all n. n - n = 0","context":["ind on n","refl","assume IH","simp","use IH"],"tactic_proof":"ind on n; [refl | assume IH; simp; use IH]","source":"minlog_synthetic/arithmetic_extraction"} -{"id":88523,"prover":"Minlog","theorem":"max_comm","goal":"all m n. max(m, n) = max(n, m)","context":["cases","auto"],"tactic_proof":"cases; auto","source":"minlog_synthetic/arithmetic_extraction"} -{"id":88524,"prover":"Minlog","theorem":"min_comm","goal":"all m n. min(m, n) = min(n, m)","context":["cases","auto"],"tactic_proof":"cases; auto","source":"minlog_synthetic/arithmetic_extraction"} -{"id":88525,"prover":"Minlog","theorem":"max_assoc","goal":"all l m n. max(l, max(m, n)) = max(max(l, m), n)","context":["cases","auto"],"tactic_proof":"cases; auto","source":"minlog_synthetic/arithmetic_extraction"} -{"id":88526,"prover":"Minlog","theorem":"le_refl","goal":"all n. n <= n","context":["intro","refl"],"tactic_proof":"intro; refl","source":"minlog_synthetic/arithmetic_extraction"} -{"id":88527,"prover":"Minlog","theorem":"le_trans","goal":"all l m n. l <= m -> m <= n -> l <= n","context":["assume h1","assume h2","elim h1","elim h2","auto"],"tactic_proof":"assume h1; assume h2; elim h1; elim h2; auto","source":"minlog_synthetic/arithmetic_extraction"} -{"id":88528,"prover":"Minlog","theorem":"le_antisym","goal":"all m n. m <= n -> n <= m -> m = n","context":["assume h1","assume h2","elim h1","elim h2","auto"],"tactic_proof":"assume h1; assume h2; elim h1; elim h2; auto","source":"minlog_synthetic/arithmetic_extraction"} -{"id":88529,"prover":"Minlog","theorem":"lt_succ","goal":"all n. n < S(n)","context":["intro","auto"],"tactic_proof":"intro; auto","source":"minlog_synthetic/arithmetic_extraction"} -{"id":88530,"prover":"Minlog","theorem":"sqrt_extraction","goal":"all n. ex m. m * m <= n /\\ n < (m+1) * (m+1)","context":["ind on n","ex 0","auto","assume IH","elim IH","assume m","cases","ex m","ex (S m)"],"tactic_proof":"ind on n; [ex 0; auto | assume IH; elim IH; assume m; cases; [ex m; auto | ex (S m); auto]]","source":"minlog_synthetic/program_extraction"} -{"id":88531,"prover":"Minlog","theorem":"gcd_extraction","goal":"all a b. b > 0 -> ex d. divides(d, a) /\\ divides(d, b) /\\ all c. divides(c, a) -> divides(c, b) -> divides(c, d)","context":["strong_ind on b","cases","auto"],"tactic_proof":"strong_ind on b; cases; auto","source":"minlog_synthetic/program_extraction"} -{"id":88532,"prover":"Minlog","theorem":"div_extraction","goal":"all a b. b > 0 -> ex q r. a = b * q + r /\\ r < b","context":["strong_ind on a","cases","auto"],"tactic_proof":"strong_ind on a; cases; auto","source":"minlog_synthetic/program_extraction"} -{"id":88533,"prover":"Minlog","theorem":"prime_test","goal":"all n. n >= 2 -> prime(n) \\/ ex d. 1 < d /\\ d < n /\\ divides(d, n)","context":["bounded_search","auto"],"tactic_proof":"bounded_search; auto","source":"minlog_synthetic/program_extraction"} -{"id":88534,"prover":"Minlog","theorem":"list_sort","goal":"all l:list(nat). ex l'. sorted(l') /\\ perm(l, l')","context":["ind on l","ex nil","auto","assume IH","elim IH","assume l'","insert"],"tactic_proof":"ind on l; [ex nil; auto | assume IH; elim IH; assume l'; insert; auto]","source":"minlog_synthetic/program_extraction"} -{"id":88535,"prover":"Minlog","theorem":"binary_search_extract","goal":"all a:array(nat) v. sorted(a) -> (ex i. a[i] = v) \\/ (all i. a[i] <> v)","context":["log_search","auto"],"tactic_proof":"log_search; auto","source":"minlog_synthetic/program_extraction"} -{"id":88536,"prover":"Minlog","theorem":"min_element","goal":"all l:list(nat). l <> nil -> ex m. mem(m, l) /\\ all x. mem(x, l) -> m <= x","context":["ind on l","auto"],"tactic_proof":"ind on l; auto","source":"minlog_synthetic/program_extraction"} -{"id":88537,"prover":"Minlog","theorem":"majority_element","goal":"all l:list(nat). length(l) > 0 -> ex m. count(m, l) > length(l) / 2 \\/ all x. count(x, l) <= length(l) / 2","context":["boyer_moore","auto"],"tactic_proof":"boyer_moore; auto","source":"minlog_synthetic/program_extraction"} -{"id":88538,"prover":"Minlog","theorem":"realizer_identity","goal":"[r : A -> A] = lambda x. x","context":["normalize","refl"],"tactic_proof":"normalize; refl","source":"minlog_synthetic/realizability"} -{"id":88539,"prover":"Minlog","theorem":"realizer_compose","goal":"[r : (A -> B) -> (B -> C) -> A -> C] = lambda f g x. g (f x)","context":["normalize","refl"],"tactic_proof":"normalize; refl","source":"minlog_synthetic/realizability"} -{"id":88540,"prover":"Minlog","theorem":"realizer_pair","goal":"[r : A -> B -> A /\\ B] = lambda a b. (a, b)","context":["normalize","refl"],"tactic_proof":"normalize; refl","source":"minlog_synthetic/realizability"} -{"id":88541,"prover":"Minlog","theorem":"realizer_fst","goal":"[r : A /\\ B -> A] = lambda p. fst(p)","context":["normalize","refl"],"tactic_proof":"normalize; refl","source":"minlog_synthetic/realizability"} -{"id":88542,"prover":"Minlog","theorem":"realizer_snd","goal":"[r : A /\\ B -> B] = lambda p. snd(p)","context":["normalize","refl"],"tactic_proof":"normalize; refl","source":"minlog_synthetic/realizability"} -{"id":88543,"prover":"Minlog","theorem":"realizer_inl","goal":"[r : A -> A \\/ B] = lambda a. inl(a)","context":["normalize","refl"],"tactic_proof":"normalize; refl","source":"minlog_synthetic/realizability"} -{"id":88544,"prover":"Minlog","theorem":"realizer_inr","goal":"[r : B -> A \\/ B] = lambda b. inr(b)","context":["normalize","refl"],"tactic_proof":"normalize; refl","source":"minlog_synthetic/realizability"} -{"id":88545,"prover":"Minlog","theorem":"realizer_case","goal":"[r : (A -> C) -> (B -> C) -> A \\/ B -> C] = lambda f g s. case s of inl(a) => f a | inr(b) => g b","context":["normalize","refl"],"tactic_proof":"normalize; refl","source":"minlog_synthetic/realizability"} -{"id":88546,"prover":"Minlog","theorem":"realizer_forall","goal":"[r : (all x:N. A(x))] = lambda x. r_x","context":["normalize","refl"],"tactic_proof":"normalize; refl","source":"minlog_synthetic/realizability"} -{"id":88547,"prover":"Minlog","theorem":"realizer_exists","goal":"[r : (ex x:N. A(x))] = (n, proof_of_A(n))","context":["normalize","refl"],"tactic_proof":"normalize; refl","source":"minlog_synthetic/realizability"} -{"id":88548,"prover":"Minlog","theorem":"realizer_induction","goal":"[r : nat_rec] = lambda base step n. (rec base step n)","context":["normalize","refl"],"tactic_proof":"normalize; refl","source":"minlog_synthetic/realizability"} -{"id":88549,"prover":"Minlog","theorem":"list_nil_append","goal":"all l:list. nil ++ l = l","context":["intro","refl"],"tactic_proof":"intro; refl","source":"minlog_synthetic/lists_minlog"} -{"id":88550,"prover":"Minlog","theorem":"list_append_nil","goal":"all l:list. l ++ nil = l","context":["ind on l","refl","assume IH","simp","use IH"],"tactic_proof":"ind on l; [refl | assume IH; simp; use IH]","source":"minlog_synthetic/lists_minlog"} -{"id":88551,"prover":"Minlog","theorem":"list_append_assoc","goal":"all l1 l2 l3. (l1 ++ l2) ++ l3 = l1 ++ (l2 ++ l3)","context":["ind on l1","refl","assume IH","simp","use IH"],"tactic_proof":"ind on l1; [refl | assume IH; simp; use IH]","source":"minlog_synthetic/lists_minlog"} -{"id":88552,"prover":"Minlog","theorem":"list_length_append","goal":"all l1 l2. length(l1 ++ l2) = length(l1) + length(l2)","context":["ind on l1","refl","assume IH","simp","use IH"],"tactic_proof":"ind on l1; [refl | assume IH; simp; use IH]","source":"minlog_synthetic/lists_minlog"} -{"id":88553,"prover":"Minlog","theorem":"list_rev_involutive","goal":"all l. rev(rev(l)) = l","context":["ind on l","refl","assume IH","simp","use rev_append","use IH"],"tactic_proof":"ind on l; [refl | assume IH; simp; use rev_append; use IH]","source":"minlog_synthetic/lists_minlog"} -{"id":88554,"prover":"Minlog","theorem":"list_rev_append","goal":"all l1 l2. rev(l1 ++ l2) = rev(l2) ++ rev(l1)","context":["ind on l1","simp","use list_append_nil","assume IH","use IH","use list_append_assoc"],"tactic_proof":"ind on l1; [simp; use list_append_nil | assume IH; simp; use IH; use list_append_assoc]","source":"minlog_synthetic/lists_minlog"} -{"id":88555,"prover":"Minlog","theorem":"list_map_id","goal":"all l. map(lambda x. x, l) = l","context":["ind on l","refl","assume IH","simp","use IH"],"tactic_proof":"ind on l; [refl | assume IH; simp; use IH]","source":"minlog_synthetic/lists_minlog"} -{"id":88556,"prover":"Minlog","theorem":"list_map_compose","goal":"all f g l. map(f, map(g, l)) = map(lambda x. f (g x), l)","context":["ind on l","refl","assume IH","simp","use IH"],"tactic_proof":"ind on l; [refl | assume IH; simp; use IH]","source":"minlog_synthetic/lists_minlog"} -{"id":88557,"prover":"Minlog","theorem":"list_filter_length","goal":"all p l. length(filter(p, l)) <= length(l)","context":["ind on l","auto","assume IH","cases p"],"tactic_proof":"ind on l; [auto | assume IH; cases p; auto]","source":"minlog_synthetic/lists_minlog"} -{"id":88558,"prover":"Minlog","theorem":"list_foldr_append","goal":"all f z l1 l2. foldr(f, z, l1 ++ l2) = foldr(f, foldr(f, z, l2), l1)","context":["ind on l1","refl","assume IH","simp","use IH"],"tactic_proof":"ind on l1; [refl | assume IH; simp; use IH]","source":"minlog_synthetic/lists_minlog"} -{"id":88559,"prover":"Minlog","theorem":"list_all_forall","goal":"all p l. (all x. mem(x, l) -> p(x)) -> list_all(p, l)","context":["ind on l","auto","assume IH","cases"],"tactic_proof":"ind on l; [auto | assume IH; cases; auto]","source":"minlog_synthetic/lists_minlog"} -{"id":88560,"prover":"Minlog","theorem":"tree_height_nonneg","goal":"all t. height(t) >= 0","context":["ind on t","auto"],"tactic_proof":"ind on t; auto","source":"minlog_synthetic/trees"} -{"id":88561,"prover":"Minlog","theorem":"tree_size_nonneg","goal":"all t. size(t) >= 1","context":["ind on t","auto"],"tactic_proof":"ind on t; auto","source":"minlog_synthetic/trees"} -{"id":88562,"prover":"Minlog","theorem":"tree_leaves_ge_1","goal":"all t. leaves(t) >= 1","context":["ind on t","auto"],"tactic_proof":"ind on t; auto","source":"minlog_synthetic/trees"} -{"id":88563,"prover":"Minlog","theorem":"tree_mirror_involutive","goal":"all t. mirror(mirror(t)) = t","context":["ind on t","refl","assume IH1 IH2","simp","use IH1","use IH2"],"tactic_proof":"ind on t; [refl | assume IH1 IH2; simp; use IH1; use IH2]","source":"minlog_synthetic/trees"} -{"id":88564,"prover":"Minlog","theorem":"tree_size_height","goal":"all t. size(t) <= 2^(height(t)+1) - 1","context":["ind on t","auto","assume IH1 IH2","simp","use IH1","use IH2"],"tactic_proof":"ind on t; [auto | assume IH1 IH2; simp; use IH1; use IH2]","source":"minlog_synthetic/trees"} -{"id":88565,"prover":"Minlog","theorem":"bst_inorder_sorted","goal":"all t. is_bst(t) -> sorted(inorder(t))","context":["ind on t","auto","assume IH","split"],"tactic_proof":"ind on t; [auto | assume IH; split; auto]","source":"minlog_synthetic/trees"} -{"id":88566,"prover":"Minlog","theorem":"tree_flatten_append","goal":"all t1 t2. flatten(Node(t1, x, t2)) = flatten(t1) ++ [x] ++ flatten(t2)","context":["intro","refl"],"tactic_proof":"intro; refl","source":"minlog_synthetic/trees"} -{"id":88567,"prover":"Minlog","theorem":"tree_count_sum","goal":"all x t. count(x, flatten(t)) = count_tree(x, t)","context":["ind on t","auto"],"tactic_proof":"ind on t; auto","source":"minlog_synthetic/trees"} -{"id":88568,"prover":"Minlog","theorem":"tnd","goal":"all A. A \\/ ~A","context":["use classical","auto"],"tactic_proof":"use classical; auto","source":"minlog_synthetic/classical_logic"} -{"id":88569,"prover":"Minlog","theorem":"dne","goal":"all A. ~~A -> A","context":["assume h","classical","auto"],"tactic_proof":"assume h; classical; auto","source":"minlog_synthetic/classical_logic"} -{"id":88570,"prover":"Minlog","theorem":"peirce_law","goal":"all A B. ((A -> B) -> A) -> A","context":["assume h","classical","auto"],"tactic_proof":"assume h; classical; auto","source":"minlog_synthetic/classical_logic"} -{"id":88571,"prover":"Minlog","theorem":"contrapos_classical","goal":"all A B. (~B -> ~A) -> (A -> B)","context":["assume h","classical","auto"],"tactic_proof":"assume h; classical; auto","source":"minlog_synthetic/classical_logic"} -{"id":88572,"prover":"Minlog","theorem":"or_impl","goal":"all A B. (A \\/ B) -> (~A -> B)","context":["assume h nA","elim h","assume a","absurd","assume b","exact b"],"tactic_proof":"assume h nA; elim h; [assume a; absurd | assume b; exact b]","source":"minlog_synthetic/classical_logic"} -{"id":88573,"prover":"Minlog","theorem":"impl_or","goal":"all A B. (A -> B) -> (~A \\/ B)","context":["assume h","classical","auto"],"tactic_proof":"assume h; classical; auto","source":"minlog_synthetic/classical_logic"} -{"id":88574,"prover":"Minlog","theorem":"and_not_or","goal":"all A B. ~A /\\ ~B -> ~(A \\/ B)","context":["assume h","elim h","assume nA nB","intro","elim","auto"],"tactic_proof":"assume h; elim h; assume nA nB; intro; elim; auto","source":"minlog_synthetic/classical_logic"} -{"id":88575,"prover":"Minlog","theorem":"demorgan_classical_1","goal":"all A B. ~(A /\\ B) -> (~A \\/ ~B)","context":["assume h","classical","auto"],"tactic_proof":"assume h; classical; auto","source":"minlog_synthetic/classical_logic"} -{"id":88576,"prover":"Minlog","theorem":"demorgan_classical_2","goal":"all A B. ~(A \\/ B) <-> (~A /\\ ~B)","context":["split","intros","auto"],"tactic_proof":"split; intros; split; intros; auto","source":"minlog_synthetic/classical_logic"} -{"id":88577,"prover":"Minlog","theorem":"classical_exists","goal":"all P. ~(all x. ~P(x)) -> ex x. P(x)","context":["assume h","classical","auto"],"tactic_proof":"assume h; classical; auto","source":"minlog_synthetic/classical_logic"} -{"id":88578,"prover":"Minlog","theorem":"cut_elim","goal":"all A B C. (Gamma |- A) -> (A, Gamma |- B) -> (Gamma |- B)","context":["intros","cut_admissible","auto"],"tactic_proof":"intros; cut_admissible; auto","source":"minlog_synthetic/sequent_calculus"} -{"id":88579,"prover":"Minlog","theorem":"structural_weaken","goal":"all A B. (Gamma |- B) -> (A, Gamma |- B)","context":["intros","weakening","auto"],"tactic_proof":"intros; weakening; auto","source":"minlog_synthetic/sequent_calculus"} -{"id":88580,"prover":"Minlog","theorem":"structural_contract","goal":"all A B. (A, A, Gamma |- B) -> (A, Gamma |- B)","context":["intros","contraction","auto"],"tactic_proof":"intros; contraction; auto","source":"minlog_synthetic/sequent_calculus"} -{"id":88581,"prover":"Minlog","theorem":"structural_exchange","goal":"all A B C. (A, B, Gamma |- C) -> (B, A, Gamma |- C)","context":["intros","exchange","auto"],"tactic_proof":"intros; exchange; auto","source":"minlog_synthetic/sequent_calculus"} -{"id":88582,"prover":"Minlog","theorem":"identity_axiom","goal":"all A. (A |- A)","context":["intro","axiom"],"tactic_proof":"intro; axiom","source":"minlog_synthetic/sequent_calculus"} -{"id":88583,"prover":"Minlog","theorem":"and_right","goal":"all A B. (Gamma |- A) -> (Gamma |- B) -> (Gamma |- A /\\ B)","context":["intros","andR","auto"],"tactic_proof":"intros; andR; auto","source":"minlog_synthetic/sequent_calculus"} -{"id":88584,"prover":"Minlog","theorem":"and_left_1","goal":"all A B C. (A, Gamma |- C) -> (A /\\ B, Gamma |- C)","context":["intros","andL1","auto"],"tactic_proof":"intros; andL1; auto","source":"minlog_synthetic/sequent_calculus"} -{"id":88585,"prover":"Minlog","theorem":"impl_right","goal":"all A B. (A, Gamma |- B) -> (Gamma |- A -> B)","context":["intros","implR","auto"],"tactic_proof":"intros; implR; auto","source":"minlog_synthetic/sequent_calculus"} -{"id":88586,"prover":"Minlog","theorem":"impl_left","goal":"all A B C. (Gamma |- A) -> (B, Gamma |- C) -> (A -> B, Gamma |- C)","context":["intros","implL","auto"],"tactic_proof":"intros; implL; auto","source":"minlog_synthetic/sequent_calculus"} -{"id":88587,"prover":"Minlog","theorem":"strong_ind","goal":"all P. (all n. (all m. m < n -> P(m)) -> P(n)) -> all n. P(n)","context":["assume h","strong_ind","auto"],"tactic_proof":"assume h; strong_ind; auto","source":"minlog_synthetic/induction_advanced"} -{"id":88588,"prover":"Minlog","theorem":"course_of_values","goal":"all P. P(0) -> (all n. P(n) -> P(n+1)) -> all n. P(n)","context":["assume p0 step","nat_rec","auto"],"tactic_proof":"assume p0 step; nat_rec; auto","source":"minlog_synthetic/induction_advanced"} -{"id":88589,"prover":"Minlog","theorem":"well_founded_acc","goal":"all R. well_founded(R) -> all P. (all x. (all y. R(y,x) -> P(y)) -> P(x)) -> all x. P(x)","context":["assume wf ih","wf_rec","auto"],"tactic_proof":"assume wf ih; wf_rec; auto","source":"minlog_synthetic/induction_advanced"} -{"id":88590,"prover":"Minlog","theorem":"mutual_ind_evenodd","goal":"(all n. even(n) -> P(n)) /\\ (all n. odd(n) -> Q(n))","context":["mutual_ind","auto"],"tactic_proof":"mutual_ind; auto","source":"minlog_synthetic/induction_advanced"} -{"id":88591,"prover":"Minlog","theorem":"struct_ind_list","goal":"all P. P(nil) -> (all x xs. P(xs) -> P(cons x xs)) -> all l. P(l)","context":["assume p_nil p_cons","list_rec","auto"],"tactic_proof":"assume p_nil p_cons; list_rec; auto","source":"minlog_synthetic/induction_advanced"} -{"id":88592,"prover":"Minlog","theorem":"struct_ind_tree","goal":"all P. P(leaf) -> (all t1 x t2. P(t1) -> P(t2) -> P(Node t1 x t2)) -> all t. P(t)","context":["assume p_leaf p_node","tree_rec","auto"],"tactic_proof":"assume p_leaf p_node; tree_rec; auto","source":"minlog_synthetic/induction_advanced"} -{"id":88593,"prover":"Minlog","theorem":"transfinite_ind","goal":"all P. (all beta. beta < alpha -> P(beta)) -> P(alpha)","context":["assume ih","transfinite","auto"],"tactic_proof":"assume ih; transfinite; auto","source":"minlog_synthetic/induction_advanced"} -{"id":88594,"prover":"Minlog","theorem":"higher_order_app","goal":"all f x. (lambda y. f y) x = f x","context":["beta_reduce","refl"],"tactic_proof":"beta_reduce; refl","source":"minlog_synthetic/higher_order"} -{"id":88595,"prover":"Minlog","theorem":"fun_ext_ho","goal":"all f g. (all x. f x = g x) -> f = g","context":["assume h","fun_ext","auto"],"tactic_proof":"assume h; fun_ext; auto","source":"minlog_synthetic/higher_order"} -{"id":88596,"prover":"Minlog","theorem":"curry_uncurry","goal":"all f x y. curry (uncurry f) x y = f x y","context":["intros","beta_reduce","refl"],"tactic_proof":"intros; beta_reduce; refl","source":"minlog_synthetic/higher_order"} -{"id":88597,"prover":"Minlog","theorem":"uncurry_curry","goal":"all f p. uncurry (curry f) p = f p","context":["intro","cases p","beta_reduce","refl"],"tactic_proof":"intro; cases p; beta_reduce; refl","source":"minlog_synthetic/higher_order"} -{"id":88598,"prover":"Minlog","theorem":"compose_assoc","goal":"all f g h. compose (compose f g) h = compose f (compose g h)","context":["fun_ext","beta_reduce","refl"],"tactic_proof":"fun_ext; beta_reduce; refl","source":"minlog_synthetic/higher_order"} -{"id":88599,"prover":"Minlog","theorem":"id_left","goal":"all f. compose id f = f","context":["fun_ext","beta_reduce","refl"],"tactic_proof":"fun_ext; beta_reduce; refl","source":"minlog_synthetic/higher_order"} -{"id":88600,"prover":"Minlog","theorem":"id_right","goal":"all f. compose f id = f","context":["fun_ext","beta_reduce","refl"],"tactic_proof":"fun_ext; beta_reduce; refl","source":"minlog_synthetic/higher_order"} -{"id":88601,"prover":"Minlog","theorem":"ho_induction_schema","goal":"all P. (all x. x = 0 \\/ (ex y. x = y+1 /\\ P(y))) -> P(0) -> all x. P(x)","context":["assume h p0","induct","auto"],"tactic_proof":"assume h p0; induct; auto","source":"minlog_synthetic/higher_order"} -{"id":88602,"prover":"Minlog","theorem":"factorial_correct","goal":"all n. factorial(n) >= 1","context":["ind on n","simp","auto","assume IH","use IH"],"tactic_proof":"ind on n; [simp; auto | assume IH; simp; use IH]","source":"minlog_synthetic/program_verification"} -{"id":88603,"prover":"Minlog","theorem":"fibonacci_monotone","goal":"all m n. m <= n -> fib(m) <= fib(n)","context":["assume h","ind on n","auto"],"tactic_proof":"assume h; ind on n; auto","source":"minlog_synthetic/program_verification"} -{"id":88604,"prover":"Minlog","theorem":"sum_range_formula","goal":"all n. sum(0..n, lambda i. i) = n * (n+1) / 2","context":["ind on n","auto"],"tactic_proof":"ind on n; auto","source":"minlog_synthetic/program_verification"} -{"id":88605,"prover":"Minlog","theorem":"sort_preserves_elements","goal":"all l. mset(sort l) = mset(l)","context":["ind on l","auto"],"tactic_proof":"ind on l; auto","source":"minlog_synthetic/program_verification"} -{"id":88606,"prover":"Minlog","theorem":"reverse_length","goal":"all l. length(reverse l) = length l","context":["ind on l","refl","assume IH","simp","use length_append","use IH"],"tactic_proof":"ind on l; [refl | assume IH; simp; use length_append; use IH]","source":"minlog_synthetic/program_verification"} -{"id":88607,"prover":"Minlog","theorem":"gcd_correct","goal":"all a b. b > 0 -> divides(gcd(a,b), a) /\\ divides(gcd(a,b), b)","context":["strong_ind on b","cases","auto"],"tactic_proof":"strong_ind on b; cases; auto","source":"minlog_synthetic/program_verification"} -{"id":88608,"prover":"Minlog","theorem":"is_sorted_cons","goal":"all x xs. is_sorted(cons x xs) -> is_sorted xs","context":["intros","cases","auto"],"tactic_proof":"intros; cases; auto","source":"minlog_synthetic/program_verification"} -{"id":88609,"prover":"Minlog","theorem":"search_correct","goal":"all x l. linear_search(x, l) = true <-> mem(x, l)","context":["ind on l","split","auto"],"tactic_proof":"ind on l; split; auto","source":"minlog_synthetic/program_verification"} -{"id":88610,"prover":"Minlog","theorem":"modal_k","goal":"all A B. box(A -> B) -> box(A) -> box(B)","context":["intros","box_elim","auto"],"tactic_proof":"intros; box_elim; auto","source":"minlog_synthetic/modal_logic"} -{"id":88611,"prover":"Minlog","theorem":"modal_t","goal":"all A. box(A) -> A","context":["intro","reflexive_frame","auto"],"tactic_proof":"intro; reflexive_frame; auto","source":"minlog_synthetic/modal_logic"} -{"id":88612,"prover":"Minlog","theorem":"modal_4","goal":"all A. box(A) -> box(box(A))","context":["intro","transitive_frame","auto"],"tactic_proof":"intro; transitive_frame; auto","source":"minlog_synthetic/modal_logic"} -{"id":88613,"prover":"Minlog","theorem":"modal_5","goal":"all A. dia(A) -> box(dia(A))","context":["intro","euclidean_frame","auto"],"tactic_proof":"intro; euclidean_frame; auto","source":"minlog_synthetic/modal_logic"} -{"id":88614,"prover":"Minlog","theorem":"modal_dual","goal":"all A. dia(A) <-> ~box(~A)","context":["split","intros","auto"],"tactic_proof":"split; intros; auto","source":"minlog_synthetic/modal_logic"} -{"id":88615,"prover":"Minlog","theorem":"necessitation","goal":"all A. |- A -> |- box(A)","context":["intro","necessitate","auto"],"tactic_proof":"intro; necessitate; auto","source":"minlog_synthetic/modal_logic"} -{"id":88616,"prover":"Minlog","theorem":"distribution","goal":"all A B. box(A /\\ B) <-> box(A) /\\ box(B)","context":["split","intros","box_elim","auto"],"tactic_proof":"split; intros; split; box_elim; auto","source":"minlog_synthetic/modal_logic"} -{"id":88617,"prover":"Minlog","theorem":"disjunction_property","goal":"all A B. (|- A \\/ B) -> (|- A) \\/ (|- B)","context":["assume h","intuit","auto"],"tactic_proof":"assume h; intuit; auto","source":"minlog_synthetic/intuitionistic"} -{"id":88618,"prover":"Minlog","theorem":"existence_property","goal":"all P. (|- ex x. P(x)) -> ex witness. |- P(witness)","context":["assume h","intuit","auto"],"tactic_proof":"assume h; intuit; auto","source":"minlog_synthetic/intuitionistic"} -{"id":88619,"prover":"Minlog","theorem":"double_neg_shift","goal":"all A. ~~(A \\/ ~A)","context":["intro","assume h","apply h","right","left","auto"],"tactic_proof":"intro; assume h; apply h; right; intro; apply h; left; auto","source":"minlog_synthetic/intuitionistic"} -{"id":88620,"prover":"Minlog","theorem":"glivenko","goal":"all A. (|- ~~A classically) -> (|- ~~A intuitionistically)","context":["assume h","glivenko","auto"],"tactic_proof":"assume h; glivenko; auto","source":"minlog_synthetic/intuitionistic"} -{"id":88621,"prover":"Minlog","theorem":"kripke_model","goal":"all w:World, A. forces(w, A) <-> satisfies(w, A)","context":["intro","split","kripke","auto"],"tactic_proof":"intro; split; kripke; auto","source":"minlog_synthetic/intuitionistic"} -{"id":88622,"prover":"Minlog","theorem":"negation_translation","goal":"all A. (~~A)_neg = ~~A_neg","context":["intro","neg_translation","auto"],"tactic_proof":"intro; neg_translation; auto","source":"minlog_synthetic/intuitionistic"} -{"id":88623,"prover":"Minlog","theorem":"godel_neg","goal":"all A. valid(A) <-> valid(~~A_neg)","context":["intro","split","godel_negative","auto"],"tactic_proof":"intro; split; godel_negative; auto","source":"minlog_synthetic/intuitionistic"} -{"id":88624,"prover":"Minlog","theorem":"game_det","goal":"all G:Game. open(G) -> determined(G)","context":["assume h","gale_stewart","auto"],"tactic_proof":"assume h; gale_stewart; auto","source":"minlog_synthetic/games"} -{"id":88625,"prover":"Minlog","theorem":"strategy_winning","goal":"all G:Game, sigma:Strategy. winning(sigma, G) -> all play. consistent(play, sigma) -> G_wins(play)","context":["assume w","intro con","auto"],"tactic_proof":"assume w; intro con; auto","source":"minlog_synthetic/games"} -{"id":88626,"prover":"Minlog","theorem":"zermelo","goal":"all G:FiniteGame. determined(G)","context":["intro","backward_induction","auto"],"tactic_proof":"intro; backward_induction; auto","source":"minlog_synthetic/games"} -{"id":88627,"prover":"Minlog","theorem":"minimax","goal":"all G:ZeroSum, v:Value. v = max(min(payoff))","context":["intro","minimax_theorem","auto"],"tactic_proof":"intro; minimax_theorem; auto","source":"minlog_synthetic/games"} -{"id":88628,"prover":"Minlog","theorem":"nash_existence","goal":"all G:FiniteGame. ex sigma. nash_equilibrium(sigma, G)","context":["intro","brouwer","auto"],"tactic_proof":"intro; brouwer; auto","source":"minlog_synthetic/games"} -{"id":88629,"prover":"Minlog","theorem":"realizer_nat_rec","goal":"[r : nat_rec] = lambda base step n. (fix F lambda k. if k=0 then base else step k (F (k-1))) n","context":["normalize","refl"],"tactic_proof":"normalize; refl","source":"minlog_synthetic/realizers_advanced"} -{"id":88630,"prover":"Minlog","theorem":"realizer_list_rec","goal":"[r : list_rec] = lambda nil_case cons_case l. (fix F lambda xs. match xs with nil => nil_case | x::xs' => cons_case x (F xs')) l","context":["normalize","refl"],"tactic_proof":"normalize; refl","source":"minlog_synthetic/realizers_advanced"} -{"id":88631,"prover":"Minlog","theorem":"realizer_bounded_search","goal":"[r : bounded_search_lemma] = lambda p bound. search_loop p 0 bound","context":["normalize","refl"],"tactic_proof":"normalize; refl","source":"minlog_synthetic/realizers_advanced"} -{"id":88632,"prover":"Minlog","theorem":"realizer_minimization","goal":"[r : minimization] = lambda f. mu (lambda n. f n = 0)","context":["normalize","refl"],"tactic_proof":"normalize; refl","source":"minlog_synthetic/realizers_advanced"} -{"id":88633,"prover":"Minlog","theorem":"realizer_fixpoint","goal":"[r : fix_point_thm] = lambda f. fix f","context":["normalize","refl"],"tactic_proof":"normalize; refl","source":"minlog_synthetic/realizers_advanced"} -{"id":88634,"prover":"Minlog","theorem":"realizer_choice","goal":"[r : countable_choice] = lambda R. lambda n. choose (R n)","context":["normalize","refl"],"tactic_proof":"normalize; refl","source":"minlog_synthetic/realizers_advanced"} -{"id":88635,"prover":"Minlog","theorem":"bit_length","goal":"all n. n > 0 -> bit_length(n) = floor(log2(n)) + 1","context":["strong_ind on n","auto"],"tactic_proof":"strong_ind on n; auto","source":"minlog_synthetic/bounded_arithmetic"} -{"id":88636,"prover":"Minlog","theorem":"parity","goal":"all n. parity(n) = n mod 2","context":["ind on n","auto"],"tactic_proof":"ind on n; auto","source":"minlog_synthetic/bounded_arithmetic"} -{"id":88637,"prover":"Minlog","theorem":"binary_rep","goal":"all n. binary_decode(binary_encode(n)) = n","context":["ind on n","auto"],"tactic_proof":"ind on n; auto","source":"minlog_synthetic/bounded_arithmetic"} -{"id":88638,"prover":"Minlog","theorem":"pow_two_le","goal":"all n. 2^n > n","context":["ind on n","auto"],"tactic_proof":"ind on n; auto","source":"minlog_synthetic/bounded_arithmetic"} -{"id":88639,"prover":"Minlog","theorem":"pigeon_bounded","goal":"all f:fin(n)->fin(m). n > m -> ex i j. i <> j /\\ f(i) = f(j)","context":["assume","pigeonhole","auto"],"tactic_proof":"assume; pigeonhole; auto","source":"minlog_synthetic/bounded_arithmetic"} -{"id":88640,"prover":"Minlog","theorem":"bounded_search","goal":"all p:nat->bool. (ex n. n <= N /\\ p n = true) -> ex k. k <= N /\\ p k = true /\\ (all j. j < k -> p j = false)","context":["assume","bounded_search","auto"],"tactic_proof":"assume; bounded_search; auto","source":"minlog_synthetic/bounded_arithmetic"} -{"id":88641,"prover":"Minlog","theorem":"pspace_pspace","goal":"pspace = pspace","context":["refl"],"tactic_proof":"refl","source":"minlog_synthetic/bounded_arithmetic"} -{"id":88642,"prover":"Minlog","theorem":"fin_sat_decidable","goal":"all phi:Formula. decidable(sat(phi))","context":["intro","propositional_sat","auto"],"tactic_proof":"intro; propositional_sat; auto","source":"minlog_synthetic/finite_logic"} -{"id":88643,"prover":"Minlog","theorem":"resolution_sound","goal":"all phi. res_derives(empty, phi) -> unsat(phi)","context":["assume h","resolution_soundness","auto"],"tactic_proof":"assume h; resolution_soundness; auto","source":"minlog_synthetic/finite_logic"} -{"id":88644,"prover":"Minlog","theorem":"resolution_complete","goal":"all phi. unsat(phi) -> res_derives(empty, phi)","context":["assume h","resolution_completeness","auto"],"tactic_proof":"assume h; resolution_completeness; auto","source":"minlog_synthetic/finite_logic"} -{"id":88645,"prover":"Minlog","theorem":"dpll_terminates","goal":"all phi. terminates(dpll(phi))","context":["intro","wf_induct","auto"],"tactic_proof":"intro; wf_induct; auto","source":"minlog_synthetic/finite_logic"} -{"id":88646,"prover":"Minlog","theorem":"cnf_equivalent","goal":"all phi. equivalent(phi, to_cnf(phi))","context":["intro","tseitin","auto"],"tactic_proof":"intro; tseitin; auto","source":"minlog_synthetic/finite_logic"} -{"id":88647,"prover":"Minlog","theorem":"horn_sat_poly","goal":"all phi:HornFormula. poly_time_decidable(sat(phi))","context":["intro","unit_propagation","auto"],"tactic_proof":"intro; unit_propagation; auto","source":"minlog_synthetic/finite_logic"} +{"prover":"Minlog","tactic_proof":"assume A; exact A","source":"minlog_synthetic/natural_deduction","theorem":"imp_refl","id":88500,"goal":"A -> A","context":["assume A","exact A"]} +{"prover":"Minlog","tactic_proof":"assume f; assume g; assume a; exact (g (f a))","source":"minlog_synthetic/natural_deduction","theorem":"imp_trans","id":88501,"goal":"(A -> B) -> (B -> C) -> A -> C","context":["assume f","assume g","assume a","exact (g (f a))"]} +{"prover":"Minlog","tactic_proof":"assume a; assume b; split; [exact a | exact b]","source":"minlog_synthetic/natural_deduction","theorem":"and_intro","id":88502,"goal":"A -> B -> A /\\ B","context":["assume a","assume b","split","exact a","exact b"]} +{"prover":"Minlog","tactic_proof":"assume h; elim h; assume a; assume b; exact a","source":"minlog_synthetic/natural_deduction","theorem":"and_elim_l","id":88503,"goal":"A /\\ B -> A","context":["assume h","elim h","assume a","assume b","exact a"]} +{"prover":"Minlog","tactic_proof":"assume h; elim h; assume a; assume b; exact b","source":"minlog_synthetic/natural_deduction","theorem":"and_elim_r","id":88504,"goal":"A /\\ B -> B","context":["assume h","elim h","assume a","assume b","exact b"]} +{"prover":"Minlog","tactic_proof":"assume a; left; exact a","source":"minlog_synthetic/natural_deduction","theorem":"or_intro_l","id":88505,"goal":"A -> A \\/ B","context":["assume a","left","exact a"]} +{"prover":"Minlog","tactic_proof":"assume b; right; exact b","source":"minlog_synthetic/natural_deduction","theorem":"or_intro_r","id":88506,"goal":"B -> A \\/ B","context":["assume b","right","exact b"]} +{"prover":"Minlog","tactic_proof":"assume f; assume g; assume h; elim h; [assume a; exact (f a) | assume b; exact (g b)]","source":"minlog_synthetic/natural_deduction","theorem":"or_elim","id":88507,"goal":"(A -> C) -> (B -> C) -> A \\/ B -> C","context":["assume f","assume g","assume h","elim h","assume a","exact (f a)","assume b","exact (g b)"]} +{"prover":"Minlog","tactic_proof":"assume h; elim h","source":"minlog_synthetic/natural_deduction","theorem":"false_elim","id":88508,"goal":"F -> A","context":["assume h","elim h"]} +{"prover":"Minlog","tactic_proof":"assume f; intro; exact f","source":"minlog_synthetic/natural_deduction","theorem":"not_intro","id":88509,"goal":"(A -> F) -> ~A","context":["assume f","intro","exact f"]} +{"prover":"Minlog","tactic_proof":"assume a; assume h; exact (h a)","source":"minlog_synthetic/natural_deduction","theorem":"double_neg_intro","id":88510,"goal":"A -> ~~A","context":["assume a","assume h","exact (h a)"]} +{"prover":"Minlog","tactic_proof":"assume f; assume nb; assume a; exact (nb (f a))","source":"minlog_synthetic/natural_deduction","theorem":"contrapositive","id":88511,"goal":"(A -> B) -> ~B -> ~A","context":["assume f","assume nb","assume a","exact (nb (f a))"]} +{"prover":"Minlog","tactic_proof":"assume h; elim h; assume a; assume b; split; [exact b | exact a]","source":"minlog_synthetic/natural_deduction","theorem":"and_comm","id":88512,"goal":"A /\\ B -> B /\\ A","context":["assume h","elim h","assume a","assume b","split","exact b","exact a"]} +{"prover":"Minlog","tactic_proof":"assume h; elim h; [assume a; right; exact a | assume b; left; exact b]","source":"minlog_synthetic/natural_deduction","theorem":"or_comm","id":88513,"goal":"A \\/ B -> B \\/ A","context":["assume h","elim h","assume a","right","exact a","assume b","left","exact b"]} +{"prover":"Minlog","tactic_proof":"assume f; assume a; assume b; exact (f (a, b))","source":"minlog_synthetic/natural_deduction","theorem":"curry","id":88514,"goal":"(A /\\ B -> C) -> A -> B -> C","context":["assume f","assume a","assume b","exact (f (a, b))"]} +{"prover":"Minlog","tactic_proof":"ind on n; [refl | assume IH; simp; exact IH]","source":"minlog_synthetic/arithmetic","theorem":"add_zero","id":88515,"goal":"all n. n + 0 = n","context":["ind on n","refl","assume IH","simp","exact IH"]} +{"prover":"Minlog","tactic_proof":"ind on m; [refl | assume IH; simp; use IH]","source":"minlog_synthetic/arithmetic","theorem":"add_succ","id":88516,"goal":"all m n. m + S(n) = S(m + n)","context":["ind on m","refl","assume IH","simp","use IH"]} +{"prover":"Minlog","tactic_proof":"ind on m; [use add_zero | assume IH; simp; use add_succ; use IH]","source":"minlog_synthetic/arithmetic","theorem":"add_comm","id":88517,"goal":"all m n. m + n = n + m","context":["ind on m","use add_zero","assume IH","simp","use add_succ","use IH"]} +{"prover":"Minlog","tactic_proof":"ind on m; [refl | assume IH; simp; use IH]","source":"minlog_synthetic/arithmetic","theorem":"add_assoc","id":88518,"goal":"all m n k. (m + n) + k = m + (n + k)","context":["ind on m","refl","assume IH","simp","use IH"]} +{"prover":"Minlog","tactic_proof":"ind on n; [refl | assume IH; simp; use IH]","source":"minlog_synthetic/arithmetic","theorem":"mul_zero","id":88519,"goal":"all n. n * 0 = 0","context":["ind on n","refl","assume IH","simp","use IH"]} +{"prover":"Minlog","tactic_proof":"ind on m; [refl | assume IH; simp; use IH; use add_assoc; use add_comm]","source":"minlog_synthetic/arithmetic","theorem":"mul_succ","id":88520,"goal":"all m n. m * S(n) = m + m * n","context":["ind on m","refl","assume IH","simp","use IH","use add_assoc","use add_comm"]} +{"prover":"Minlog","tactic_proof":"ind on m; [use mul_zero | assume IH; simp; use mul_succ; use IH]","source":"minlog_synthetic/arithmetic","theorem":"mul_comm","id":88521,"goal":"all m n. m * n = n * m","context":["ind on m","use mul_zero","assume IH","simp","use mul_succ","use IH"]} +{"prover":"Minlog","tactic_proof":"ind on n; [refl | assume IH; simp; use IH]","source":"minlog_synthetic/arithmetic","theorem":"sub_self","id":88522,"goal":"all n. n - n = 0","context":["ind on n","refl","assume IH","simp","use IH"]} +{"prover":"Minlog","tactic_proof":"cases; auto","source":"minlog_synthetic/arithmetic","theorem":"max_comm","id":88523,"goal":"all m n. max(m, n) = max(n, m)","context":["cases","auto"]} +{"prover":"Minlog","tactic_proof":"cases; auto","source":"minlog_synthetic/arithmetic","theorem":"min_comm","id":88524,"goal":"all m n. min(m, n) = min(n, m)","context":["cases","auto"]} +{"prover":"Minlog","tactic_proof":"cases; auto","source":"minlog_synthetic/arithmetic","theorem":"max_assoc","id":88525,"goal":"all l m n. max(l, max(m, n)) = max(max(l, m), n)","context":["cases","auto"]} +{"prover":"Minlog","tactic_proof":"intro; refl","source":"minlog_synthetic/arithmetic","theorem":"le_refl","id":88526,"goal":"all n. n <= n","context":["intro","refl"]} +{"prover":"Minlog","tactic_proof":"assume h1; assume h2; elim h1; elim h2; auto","source":"minlog_synthetic/arithmetic","theorem":"le_trans","id":88527,"goal":"all l m n. l <= m -> m <= n -> l <= n","context":["assume h1","assume h2","elim h1","elim h2","auto"]} +{"prover":"Minlog","tactic_proof":"assume h1; assume h2; elim h1; elim h2; auto","source":"minlog_synthetic/arithmetic","theorem":"le_antisym","id":88528,"goal":"all m n. m <= n -> n <= m -> m = n","context":["assume h1","assume h2","elim h1","elim h2","auto"]} +{"prover":"Minlog","tactic_proof":"intro; auto","source":"minlog_synthetic/arithmetic","theorem":"lt_succ","id":88529,"goal":"all n. n < S(n)","context":["intro","auto"]} +{"prover":"Minlog","tactic_proof":"ind on n; [ex 0; auto | assume IH; elim IH; assume m; cases; [ex m; auto | ex (S m); auto]]","source":"minlog_synthetic/extraction","theorem":"sqrt_extraction","id":88530,"goal":"all n. ex m. m * m <= n /\\ n < (m+1) * (m+1)","context":["ind on n","ex 0","auto","assume IH","elim IH","assume m","cases","ex m","ex (S m)"]} +{"prover":"Minlog","tactic_proof":"strong_ind on b; cases; auto","source":"minlog_synthetic/extraction","theorem":"gcd_extraction","id":88531,"goal":"all a b. b > 0 -> ex d. divides(d, a) /\\ divides(d, b) /\\ all c. divides(c, a) -> divides(c, b) -> divides(c, d)","context":["strong_ind on b","cases","auto"]} +{"prover":"Minlog","tactic_proof":"strong_ind on a; cases; auto","source":"minlog_synthetic/extraction","theorem":"div_extraction","id":88532,"goal":"all a b. b > 0 -> ex q r. a = b * q + r /\\ r < b","context":["strong_ind on a","cases","auto"]} +{"prover":"Minlog","tactic_proof":"bounded_search; auto","source":"minlog_synthetic/extraction","theorem":"prime_test","id":88533,"goal":"all n. n >= 2 -> prime(n) \\/ ex d. 1 < d /\\ d < n /\\ divides(d, n)","context":["bounded_search","auto"]} +{"prover":"Minlog","tactic_proof":"ind on l; [ex nil; auto | assume IH; elim IH; assume l'; insert; auto]","source":"minlog_synthetic/extraction","theorem":"list_sort","id":88534,"goal":"all l:list(nat). ex l'. sorted(l') /\\ perm(l, l')","context":["ind on l","ex nil","auto","assume IH","elim IH","assume l'","insert"]} +{"prover":"Minlog","tactic_proof":"log_search; auto","source":"minlog_synthetic/extraction","theorem":"binary_search_extract","id":88535,"goal":"all a:array(nat) v. sorted(a) -> (ex i. a[i] = v) \\/ (all i. a[i] <> v)","context":["log_search","auto"]} +{"prover":"Minlog","tactic_proof":"ind on l; auto","source":"minlog_synthetic/extraction","theorem":"min_element","id":88536,"goal":"all l:list(nat). l <> nil -> ex m. mem(m, l) /\\ all x. mem(x, l) -> m <= x","context":["ind on l","auto"]} +{"prover":"Minlog","tactic_proof":"boyer_moore; auto","source":"minlog_synthetic/extraction","theorem":"majority_element","id":88537,"goal":"all l:list(nat). length(l) > 0 -> ex m. count(m, l) > length(l) / 2 \\/ all x. count(x, l) <= length(l) / 2","context":["boyer_moore","auto"]} +{"prover":"Minlog","tactic_proof":"normalize; refl","source":"minlog_synthetic/realizability","theorem":"realizer_identity","id":88538,"goal":"[r : A -> A] = lambda x. x","context":["normalize","refl"]} +{"prover":"Minlog","tactic_proof":"normalize; refl","source":"minlog_synthetic/realizability","theorem":"realizer_compose","id":88539,"goal":"[r : (A -> B) -> (B -> C) -> A -> C] = lambda f g x. g (f x)","context":["normalize","refl"]} +{"prover":"Minlog","tactic_proof":"normalize; refl","source":"minlog_synthetic/realizability","theorem":"realizer_pair","id":88540,"goal":"[r : A -> B -> A /\\ B] = lambda a b. (a, b)","context":["normalize","refl"]} +{"prover":"Minlog","tactic_proof":"normalize; refl","source":"minlog_synthetic/realizability","theorem":"realizer_fst","id":88541,"goal":"[r : A /\\ B -> A] = lambda p. fst(p)","context":["normalize","refl"]} +{"prover":"Minlog","tactic_proof":"normalize; refl","source":"minlog_synthetic/realizability","theorem":"realizer_snd","id":88542,"goal":"[r : A /\\ B -> B] = lambda p. snd(p)","context":["normalize","refl"]} +{"prover":"Minlog","tactic_proof":"normalize; refl","source":"minlog_synthetic/realizability","theorem":"realizer_inl","id":88543,"goal":"[r : A -> A \\/ B] = lambda a. inl(a)","context":["normalize","refl"]} +{"prover":"Minlog","tactic_proof":"normalize; refl","source":"minlog_synthetic/realizability","theorem":"realizer_inr","id":88544,"goal":"[r : B -> A \\/ B] = lambda b. inr(b)","context":["normalize","refl"]} +{"prover":"Minlog","tactic_proof":"normalize; refl","source":"minlog_synthetic/realizability","theorem":"realizer_case","id":88545,"goal":"[r : (A -> C) -> (B -> C) -> A \\/ B -> C] = lambda f g s. case s of inl(a) => f a | inr(b) => g b","context":["normalize","refl"]} +{"prover":"Minlog","tactic_proof":"normalize; refl","source":"minlog_synthetic/realizability","theorem":"realizer_forall","id":88546,"goal":"[r : (all x:N. A(x))] = lambda x. r_x","context":["normalize","refl"]} +{"prover":"Minlog","tactic_proof":"normalize; refl","source":"minlog_synthetic/realizability","theorem":"realizer_exists","id":88547,"goal":"[r : (ex x:N. A(x))] = (n, proof_of_A(n))","context":["normalize","refl"]} +{"prover":"Minlog","tactic_proof":"normalize; refl","source":"minlog_synthetic/realizability","theorem":"realizer_induction","id":88548,"goal":"[r : nat_rec] = lambda base step n. (rec base step n)","context":["normalize","refl"]} +{"prover":"Minlog","tactic_proof":"intro; refl","source":"minlog_synthetic/lists","theorem":"list_nil_append","id":88549,"goal":"all l:list. nil ++ l = l","context":["intro","refl"]} +{"prover":"Minlog","tactic_proof":"ind on l; [refl | assume IH; simp; use IH]","source":"minlog_synthetic/lists","theorem":"list_append_nil","id":88550,"goal":"all l:list. l ++ nil = l","context":["ind on l","refl","assume IH","simp","use IH"]} +{"prover":"Minlog","tactic_proof":"ind on l1; [refl | assume IH; simp; use IH]","source":"minlog_synthetic/lists","theorem":"list_append_assoc","id":88551,"goal":"all l1 l2 l3. (l1 ++ l2) ++ l3 = l1 ++ (l2 ++ l3)","context":["ind on l1","refl","assume IH","simp","use IH"]} +{"prover":"Minlog","tactic_proof":"ind on l1; [refl | assume IH; simp; use IH]","source":"minlog_synthetic/lists","theorem":"list_length_append","id":88552,"goal":"all l1 l2. length(l1 ++ l2) = length(l1) + length(l2)","context":["ind on l1","refl","assume IH","simp","use IH"]} +{"prover":"Minlog","tactic_proof":"ind on l; [refl | assume IH; simp; use rev_append; use IH]","source":"minlog_synthetic/lists","theorem":"list_rev_involutive","id":88553,"goal":"all l. rev(rev(l)) = l","context":["ind on l","refl","assume IH","simp","use rev_append","use IH"]} +{"prover":"Minlog","tactic_proof":"ind on l1; [simp; use list_append_nil | assume IH; simp; use IH; use list_append_assoc]","source":"minlog_synthetic/lists","theorem":"list_rev_append","id":88554,"goal":"all l1 l2. rev(l1 ++ l2) = rev(l2) ++ rev(l1)","context":["ind on l1","simp","use list_append_nil","assume IH","use IH","use list_append_assoc"]} +{"prover":"Minlog","tactic_proof":"ind on l; [refl | assume IH; simp; use IH]","source":"minlog_synthetic/lists","theorem":"list_map_id","id":88555,"goal":"all l. map(lambda x. x, l) = l","context":["ind on l","refl","assume IH","simp","use IH"]} +{"prover":"Minlog","tactic_proof":"ind on l; [refl | assume IH; simp; use IH]","source":"minlog_synthetic/lists","theorem":"list_map_compose","id":88556,"goal":"all f g l. map(f, map(g, l)) = map(lambda x. f (g x), l)","context":["ind on l","refl","assume IH","simp","use IH"]} +{"prover":"Minlog","tactic_proof":"ind on l; [auto | assume IH; cases p; auto]","source":"minlog_synthetic/lists","theorem":"list_filter_length","id":88557,"goal":"all p l. length(filter(p, l)) <= length(l)","context":["ind on l","auto","assume IH","cases p"]} +{"prover":"Minlog","tactic_proof":"ind on l1; [refl | assume IH; simp; use IH]","source":"minlog_synthetic/lists","theorem":"list_foldr_append","id":88558,"goal":"all f z l1 l2. foldr(f, z, l1 ++ l2) = foldr(f, foldr(f, z, l2), l1)","context":["ind on l1","refl","assume IH","simp","use IH"]} +{"prover":"Minlog","tactic_proof":"ind on l; [auto | assume IH; cases; auto]","source":"minlog_synthetic/lists","theorem":"list_all_forall","id":88559,"goal":"all p l. (all x. mem(x, l) -> p(x)) -> list_all(p, l)","context":["ind on l","auto","assume IH","cases"]} +{"prover":"Minlog","tactic_proof":"ind on t; auto","source":"minlog_synthetic/trees","theorem":"tree_height_nonneg","id":88560,"goal":"all t. height(t) >= 0","context":["ind on t","auto"]} +{"prover":"Minlog","tactic_proof":"ind on t; auto","source":"minlog_synthetic/trees","theorem":"tree_size_nonneg","id":88561,"goal":"all t. size(t) >= 1","context":["ind on t","auto"]} +{"prover":"Minlog","tactic_proof":"ind on t; auto","source":"minlog_synthetic/trees","theorem":"tree_leaves_ge_1","id":88562,"goal":"all t. leaves(t) >= 1","context":["ind on t","auto"]} +{"prover":"Minlog","tactic_proof":"ind on t; [refl | assume IH1 IH2; simp; use IH1; use IH2]","source":"minlog_synthetic/trees","theorem":"tree_mirror_involutive","id":88563,"goal":"all t. mirror(mirror(t)) = t","context":["ind on t","refl","assume IH1 IH2","simp","use IH1","use IH2"]} +{"prover":"Minlog","tactic_proof":"ind on t; [auto | assume IH1 IH2; simp; use IH1; use IH2]","source":"minlog_synthetic/trees","theorem":"tree_size_height","id":88564,"goal":"all t. size(t) <= 2^(height(t)+1) - 1","context":["ind on t","auto","assume IH1 IH2","simp","use IH1","use IH2"]} +{"prover":"Minlog","tactic_proof":"ind on t; [auto | assume IH; split; auto]","source":"minlog_synthetic/trees","theorem":"bst_inorder_sorted","id":88565,"goal":"all t. is_bst(t) -> sorted(inorder(t))","context":["ind on t","auto","assume IH","split"]} +{"prover":"Minlog","tactic_proof":"intro; refl","source":"minlog_synthetic/trees","theorem":"tree_flatten_append","id":88566,"goal":"all t1 t2. flatten(Node(t1, x, t2)) = flatten(t1) ++ [x] ++ flatten(t2)","context":["intro","refl"]} +{"prover":"Minlog","tactic_proof":"ind on t; auto","source":"minlog_synthetic/trees","theorem":"tree_count_sum","id":88567,"goal":"all x t. count(x, flatten(t)) = count_tree(x, t)","context":["ind on t","auto"]} +{"prover":"Minlog","tactic_proof":"use classical; auto","source":"minlog_synthetic/classical_logic","theorem":"tnd","id":88568,"goal":"all A. A \\/ ~A","context":["use classical","auto"]} +{"prover":"Minlog","tactic_proof":"assume h; classical; auto","source":"minlog_synthetic/classical_logic","theorem":"dne","id":88569,"goal":"all A. ~~A -> A","context":["assume h","classical","auto"]} +{"prover":"Minlog","tactic_proof":"assume h; classical; auto","source":"minlog_synthetic/classical_logic","theorem":"peirce_law","id":88570,"goal":"all A B. ((A -> B) -> A) -> A","context":["assume h","classical","auto"]} +{"prover":"Minlog","tactic_proof":"assume h; classical; auto","source":"minlog_synthetic/classical_logic","theorem":"contrapos_classical","id":88571,"goal":"all A B. (~B -> ~A) -> (A -> B)","context":["assume h","classical","auto"]} +{"prover":"Minlog","tactic_proof":"assume h nA; elim h; [assume a; absurd | assume b; exact b]","source":"minlog_synthetic/classical_logic","theorem":"or_impl","id":88572,"goal":"all A B. (A \\/ B) -> (~A -> B)","context":["assume h nA","elim h","assume a","absurd","assume b","exact b"]} +{"prover":"Minlog","tactic_proof":"assume h; classical; auto","source":"minlog_synthetic/classical_logic","theorem":"impl_or","id":88573,"goal":"all A B. (A -> B) -> (~A \\/ B)","context":["assume h","classical","auto"]} +{"prover":"Minlog","tactic_proof":"assume h; elim h; assume nA nB; intro; elim; auto","source":"minlog_synthetic/classical_logic","theorem":"and_not_or","id":88574,"goal":"all A B. ~A /\\ ~B -> ~(A \\/ B)","context":["assume h","elim h","assume nA nB","intro","elim","auto"]} +{"prover":"Minlog","tactic_proof":"assume h; classical; auto","source":"minlog_synthetic/classical_logic","theorem":"demorgan_classical_1","id":88575,"goal":"all A B. ~(A /\\ B) -> (~A \\/ ~B)","context":["assume h","classical","auto"]} +{"prover":"Minlog","tactic_proof":"split; intros; split; intros; auto","source":"minlog_synthetic/classical_logic","theorem":"demorgan_classical_2","id":88576,"goal":"all A B. ~(A \\/ B) <-> (~A /\\ ~B)","context":["split","intros","auto"]} +{"prover":"Minlog","tactic_proof":"assume h; classical; auto","source":"minlog_synthetic/classical_logic","theorem":"classical_exists","id":88577,"goal":"all P. ~(all x. ~P(x)) -> ex x. P(x)","context":["assume h","classical","auto"]} +{"prover":"Minlog","tactic_proof":"intros; cut_admissible; auto","source":"minlog_synthetic/sequent_calculus","theorem":"cut_elim","id":88578,"goal":"all A B C. (Gamma |- A) -> (A, Gamma |- B) -> (Gamma |- B)","context":["intros","cut_admissible","auto"]} +{"prover":"Minlog","tactic_proof":"intros; weakening; auto","source":"minlog_synthetic/sequent_calculus","theorem":"structural_weaken","id":88579,"goal":"all A B. (Gamma |- B) -> (A, Gamma |- B)","context":["intros","weakening","auto"]} +{"prover":"Minlog","tactic_proof":"intros; contraction; auto","source":"minlog_synthetic/sequent_calculus","theorem":"structural_contract","id":88580,"goal":"all A B. (A, A, Gamma |- B) -> (A, Gamma |- B)","context":["intros","contraction","auto"]} +{"prover":"Minlog","tactic_proof":"intros; exchange; auto","source":"minlog_synthetic/sequent_calculus","theorem":"structural_exchange","id":88581,"goal":"all A B C. (A, B, Gamma |- C) -> (B, A, Gamma |- C)","context":["intros","exchange","auto"]} +{"prover":"Minlog","tactic_proof":"intro; axiom","source":"minlog_synthetic/sequent_calculus","theorem":"identity_axiom","id":88582,"goal":"all A. (A |- A)","context":["intro","axiom"]} +{"prover":"Minlog","tactic_proof":"intros; andR; auto","source":"minlog_synthetic/sequent_calculus","theorem":"and_right","id":88583,"goal":"all A B. (Gamma |- A) -> (Gamma |- B) -> (Gamma |- A /\\ B)","context":["intros","andR","auto"]} +{"prover":"Minlog","tactic_proof":"intros; andL1; auto","source":"minlog_synthetic/sequent_calculus","theorem":"and_left_1","id":88584,"goal":"all A B C. (A, Gamma |- C) -> (A /\\ B, Gamma |- C)","context":["intros","andL1","auto"]} +{"prover":"Minlog","tactic_proof":"intros; implR; auto","source":"minlog_synthetic/sequent_calculus","theorem":"impl_right","id":88585,"goal":"all A B. (A, Gamma |- B) -> (Gamma |- A -> B)","context":["intros","implR","auto"]} +{"prover":"Minlog","tactic_proof":"intros; implL; auto","source":"minlog_synthetic/sequent_calculus","theorem":"impl_left","id":88586,"goal":"all A B C. (Gamma |- A) -> (B, Gamma |- C) -> (A -> B, Gamma |- C)","context":["intros","implL","auto"]} +{"prover":"Minlog","tactic_proof":"assume h; strong_ind; auto","source":"minlog_synthetic/induction_advanced","theorem":"strong_ind","id":88587,"goal":"all P. (all n. (all m. m < n -> P(m)) -> P(n)) -> all n. P(n)","context":["assume h","strong_ind","auto"]} +{"prover":"Minlog","tactic_proof":"assume p0 step; nat_rec; auto","source":"minlog_synthetic/induction_advanced","theorem":"course_of_values","id":88588,"goal":"all P. P(0) -> (all n. P(n) -> P(n+1)) -> all n. P(n)","context":["assume p0 step","nat_rec","auto"]} +{"prover":"Minlog","tactic_proof":"assume wf ih; wf_rec; auto","source":"minlog_synthetic/induction_advanced","theorem":"well_founded_acc","id":88589,"goal":"all R. well_founded(R) -> all P. (all x. (all y. R(y,x) -> P(y)) -> P(x)) -> all x. P(x)","context":["assume wf ih","wf_rec","auto"]} +{"prover":"Minlog","tactic_proof":"mutual_ind; auto","source":"minlog_synthetic/induction_advanced","theorem":"mutual_ind_evenodd","id":88590,"goal":"(all n. even(n) -> P(n)) /\\ (all n. odd(n) -> Q(n))","context":["mutual_ind","auto"]} +{"prover":"Minlog","tactic_proof":"assume p_nil p_cons; list_rec; auto","source":"minlog_synthetic/induction_advanced","theorem":"struct_ind_list","id":88591,"goal":"all P. P(nil) -> (all x xs. P(xs) -> P(cons x xs)) -> all l. P(l)","context":["assume p_nil p_cons","list_rec","auto"]} +{"prover":"Minlog","tactic_proof":"assume p_leaf p_node; tree_rec; auto","source":"minlog_synthetic/induction_advanced","theorem":"struct_ind_tree","id":88592,"goal":"all P. P(leaf) -> (all t1 x t2. P(t1) -> P(t2) -> P(Node t1 x t2)) -> all t. P(t)","context":["assume p_leaf p_node","tree_rec","auto"]} +{"prover":"Minlog","tactic_proof":"assume ih; transfinite; auto","source":"minlog_synthetic/induction_advanced","theorem":"transfinite_ind","id":88593,"goal":"all P. (all beta. beta < alpha -> P(beta)) -> P(alpha)","context":["assume ih","transfinite","auto"]} +{"prover":"Minlog","tactic_proof":"beta_reduce; refl","source":"minlog_synthetic/higher_order","theorem":"higher_order_app","id":88594,"goal":"all f x. (lambda y. f y) x = f x","context":["beta_reduce","refl"]} +{"prover":"Minlog","tactic_proof":"assume h; fun_ext; auto","source":"minlog_synthetic/higher_order","theorem":"fun_ext_ho","id":88595,"goal":"all f g. (all x. f x = g x) -> f = g","context":["assume h","fun_ext","auto"]} +{"prover":"Minlog","tactic_proof":"intros; beta_reduce; refl","source":"minlog_synthetic/higher_order","theorem":"curry_uncurry","id":88596,"goal":"all f x y. curry (uncurry f) x y = f x y","context":["intros","beta_reduce","refl"]} +{"prover":"Minlog","tactic_proof":"intro; cases p; beta_reduce; refl","source":"minlog_synthetic/higher_order","theorem":"uncurry_curry","id":88597,"goal":"all f p. uncurry (curry f) p = f p","context":["intro","cases p","beta_reduce","refl"]} +{"prover":"Minlog","tactic_proof":"fun_ext; beta_reduce; refl","source":"minlog_synthetic/higher_order","theorem":"compose_assoc","id":88598,"goal":"all f g h. compose (compose f g) h = compose f (compose g h)","context":["fun_ext","beta_reduce","refl"]} +{"prover":"Minlog","tactic_proof":"fun_ext; beta_reduce; refl","source":"minlog_synthetic/higher_order","theorem":"id_left","id":88599,"goal":"all f. compose id f = f","context":["fun_ext","beta_reduce","refl"]} +{"prover":"Minlog","tactic_proof":"fun_ext; beta_reduce; refl","source":"minlog_synthetic/higher_order","theorem":"id_right","id":88600,"goal":"all f. compose f id = f","context":["fun_ext","beta_reduce","refl"]} +{"prover":"Minlog","tactic_proof":"assume h p0; induct; auto","source":"minlog_synthetic/higher_order","theorem":"ho_induction_schema","id":88601,"goal":"all P. (all x. x = 0 \\/ (ex y. x = y+1 /\\ P(y))) -> P(0) -> all x. P(x)","context":["assume h p0","induct","auto"]} +{"prover":"Minlog","tactic_proof":"ind on n; [simp; auto | assume IH; simp; use IH]","source":"minlog_synthetic/program_verification","theorem":"factorial_correct","id":88602,"goal":"all n. factorial(n) >= 1","context":["ind on n","simp","auto","assume IH","use IH"]} +{"prover":"Minlog","tactic_proof":"assume h; ind on n; auto","source":"minlog_synthetic/program_verification","theorem":"fibonacci_monotone","id":88603,"goal":"all m n. m <= n -> fib(m) <= fib(n)","context":["assume h","ind on n","auto"]} +{"prover":"Minlog","tactic_proof":"ind on n; auto","source":"minlog_synthetic/program_verification","theorem":"sum_range_formula","id":88604,"goal":"all n. sum(0..n, lambda i. i) = n * (n+1) / 2","context":["ind on n","auto"]} +{"prover":"Minlog","tactic_proof":"ind on l; auto","source":"minlog_synthetic/program_verification","theorem":"sort_preserves_elements","id":88605,"goal":"all l. mset(sort l) = mset(l)","context":["ind on l","auto"]} +{"prover":"Minlog","tactic_proof":"ind on l; [refl | assume IH; simp; use length_append; use IH]","source":"minlog_synthetic/program_verification","theorem":"reverse_length","id":88606,"goal":"all l. length(reverse l) = length l","context":["ind on l","refl","assume IH","simp","use length_append","use IH"]} +{"prover":"Minlog","tactic_proof":"strong_ind on b; cases; auto","source":"minlog_synthetic/program_verification","theorem":"gcd_correct","id":88607,"goal":"all a b. b > 0 -> divides(gcd(a,b), a) /\\ divides(gcd(a,b), b)","context":["strong_ind on b","cases","auto"]} +{"prover":"Minlog","tactic_proof":"intros; cases; auto","source":"minlog_synthetic/program_verification","theorem":"is_sorted_cons","id":88608,"goal":"all x xs. is_sorted(cons x xs) -> is_sorted xs","context":["intros","cases","auto"]} +{"prover":"Minlog","tactic_proof":"ind on l; split; auto","source":"minlog_synthetic/program_verification","theorem":"search_correct","id":88609,"goal":"all x l. linear_search(x, l) = true <-> mem(x, l)","context":["ind on l","split","auto"]} +{"prover":"Minlog","tactic_proof":"intros; box_elim; auto","source":"minlog_synthetic/modal_logic","theorem":"modal_k","id":88610,"goal":"all A B. box(A -> B) -> box(A) -> box(B)","context":["intros","box_elim","auto"]} +{"prover":"Minlog","tactic_proof":"intro; reflexive_frame; auto","source":"minlog_synthetic/modal_logic","theorem":"modal_t","id":88611,"goal":"all A. box(A) -> A","context":["intro","reflexive_frame","auto"]} +{"prover":"Minlog","tactic_proof":"intro; transitive_frame; auto","source":"minlog_synthetic/modal_logic","theorem":"modal_4","id":88612,"goal":"all A. box(A) -> box(box(A))","context":["intro","transitive_frame","auto"]} +{"prover":"Minlog","tactic_proof":"intro; euclidean_frame; auto","source":"minlog_synthetic/modal_logic","theorem":"modal_5","id":88613,"goal":"all A. dia(A) -> box(dia(A))","context":["intro","euclidean_frame","auto"]} +{"prover":"Minlog","tactic_proof":"split; intros; auto","source":"minlog_synthetic/modal_logic","theorem":"modal_dual","id":88614,"goal":"all A. dia(A) <-> ~box(~A)","context":["split","intros","auto"]} +{"prover":"Minlog","tactic_proof":"intro; necessitate; auto","source":"minlog_synthetic/modal_logic","theorem":"necessitation","id":88615,"goal":"all A. |- A -> |- box(A)","context":["intro","necessitate","auto"]} +{"prover":"Minlog","tactic_proof":"split; intros; split; box_elim; auto","source":"minlog_synthetic/modal_logic","theorem":"distribution","id":88616,"goal":"all A B. box(A /\\ B) <-> box(A) /\\ box(B)","context":["split","intros","box_elim","auto"]} +{"prover":"Minlog","tactic_proof":"assume h; intuit; auto","source":"minlog_synthetic/intuitionistic","theorem":"disjunction_property","id":88617,"goal":"all A B. (|- A \\/ B) -> (|- A) \\/ (|- B)","context":["assume h","intuit","auto"]} +{"prover":"Minlog","tactic_proof":"assume h; intuit; auto","source":"minlog_synthetic/intuitionistic","theorem":"existence_property","id":88618,"goal":"all P. (|- ex x. P(x)) -> ex witness. |- P(witness)","context":["assume h","intuit","auto"]} +{"prover":"Minlog","tactic_proof":"intro; assume h; apply h; right; intro; apply h; left; auto","source":"minlog_synthetic/intuitionistic","theorem":"double_neg_shift","id":88619,"goal":"all A. ~~(A \\/ ~A)","context":["intro","assume h","apply h","right","left","auto"]} +{"prover":"Minlog","tactic_proof":"assume h; glivenko; auto","source":"minlog_synthetic/intuitionistic","theorem":"glivenko","id":88620,"goal":"all A. (|- ~~A classically) -> (|- ~~A intuitionistically)","context":["assume h","glivenko","auto"]} +{"prover":"Minlog","tactic_proof":"intro; split; kripke; auto","source":"minlog_synthetic/intuitionistic","theorem":"kripke_model","id":88621,"goal":"all w:World, A. forces(w, A) <-> satisfies(w, A)","context":["intro","split","kripke","auto"]} +{"prover":"Minlog","tactic_proof":"intro; neg_translation; auto","source":"minlog_synthetic/intuitionistic","theorem":"negation_translation","id":88622,"goal":"all A. (~~A)_neg = ~~A_neg","context":["intro","neg_translation","auto"]} +{"prover":"Minlog","tactic_proof":"intro; split; godel_negative; auto","source":"minlog_synthetic/intuitionistic","theorem":"godel_neg","id":88623,"goal":"all A. valid(A) <-> valid(~~A_neg)","context":["intro","split","godel_negative","auto"]} +{"prover":"Minlog","tactic_proof":"assume h; gale_stewart; auto","source":"minlog_synthetic/games","theorem":"game_det","id":88624,"goal":"all G:Game. open(G) -> determined(G)","context":["assume h","gale_stewart","auto"]} +{"prover":"Minlog","tactic_proof":"assume w; intro con; auto","source":"minlog_synthetic/games","theorem":"strategy_winning","id":88625,"goal":"all G:Game, sigma:Strategy. winning(sigma, G) -> all play. consistent(play, sigma) -> G_wins(play)","context":["assume w","intro con","auto"]} +{"prover":"Minlog","tactic_proof":"intro; backward_induction; auto","source":"minlog_synthetic/games","theorem":"zermelo","id":88626,"goal":"all G:FiniteGame. determined(G)","context":["intro","backward_induction","auto"]} +{"prover":"Minlog","tactic_proof":"intro; minimax_theorem; auto","source":"minlog_synthetic/games","theorem":"minimax","id":88627,"goal":"all G:ZeroSum, v:Value. v = max(min(payoff))","context":["intro","minimax_theorem","auto"]} +{"prover":"Minlog","tactic_proof":"intro; brouwer; auto","source":"minlog_synthetic/games","theorem":"nash_existence","id":88628,"goal":"all G:FiniteGame. ex sigma. nash_equilibrium(sigma, G)","context":["intro","brouwer","auto"]} +{"prover":"Minlog","tactic_proof":"normalize; refl","source":"minlog_synthetic/realizers_advanced","theorem":"realizer_nat_rec","id":88629,"goal":"[r : nat_rec] = lambda base step n. (fix F lambda k. if k=0 then base else step k (F (k-1))) n","context":["normalize","refl"]} +{"prover":"Minlog","tactic_proof":"normalize; refl","source":"minlog_synthetic/realizers_advanced","theorem":"realizer_list_rec","id":88630,"goal":"[r : list_rec] = lambda nil_case cons_case l. (fix F lambda xs. match xs with nil => nil_case | x::xs' => cons_case x (F xs')) l","context":["normalize","refl"]} +{"prover":"Minlog","tactic_proof":"normalize; refl","source":"minlog_synthetic/realizers_advanced","theorem":"realizer_bounded_search","id":88631,"goal":"[r : bounded_search_lemma] = lambda p bound. search_loop p 0 bound","context":["normalize","refl"]} +{"prover":"Minlog","tactic_proof":"normalize; refl","source":"minlog_synthetic/realizers_advanced","theorem":"realizer_minimization","id":88632,"goal":"[r : minimization] = lambda f. mu (lambda n. f n = 0)","context":["normalize","refl"]} +{"prover":"Minlog","tactic_proof":"normalize; refl","source":"minlog_synthetic/realizers_advanced","theorem":"realizer_fixpoint","id":88633,"goal":"[r : fix_point_thm] = lambda f. fix f","context":["normalize","refl"]} +{"prover":"Minlog","tactic_proof":"normalize; refl","source":"minlog_synthetic/realizers_advanced","theorem":"realizer_choice","id":88634,"goal":"[r : countable_choice] = lambda R. lambda n. choose (R n)","context":["normalize","refl"]} +{"prover":"Minlog","tactic_proof":"strong_ind on n; auto","source":"minlog_synthetic/bounded_arithmetic","theorem":"bit_length","id":88635,"goal":"all n. n > 0 -> bit_length(n) = floor(log2(n)) + 1","context":["strong_ind on n","auto"]} +{"prover":"Minlog","tactic_proof":"ind on n; auto","source":"minlog_synthetic/bounded_arithmetic","theorem":"parity","id":88636,"goal":"all n. parity(n) = n mod 2","context":["ind on n","auto"]} +{"prover":"Minlog","tactic_proof":"ind on n; auto","source":"minlog_synthetic/bounded_arithmetic","theorem":"binary_rep","id":88637,"goal":"all n. binary_decode(binary_encode(n)) = n","context":["ind on n","auto"]} +{"prover":"Minlog","tactic_proof":"ind on n; auto","source":"minlog_synthetic/bounded_arithmetic","theorem":"pow_two_le","id":88638,"goal":"all n. 2^n > n","context":["ind on n","auto"]} +{"prover":"Minlog","tactic_proof":"assume; pigeonhole; auto","source":"minlog_synthetic/bounded_arithmetic","theorem":"pigeon_bounded","id":88639,"goal":"all f:fin(n)->fin(m). n > m -> ex i j. i <> j /\\ f(i) = f(j)","context":["assume","pigeonhole","auto"]} +{"prover":"Minlog","tactic_proof":"assume; bounded_search; auto","source":"minlog_synthetic/bounded_arithmetic","theorem":"bounded_search","id":88640,"goal":"all p:nat->bool. (ex n. n <= N /\\ p n = true) -> ex k. k <= N /\\ p k = true /\\ (all j. j < k -> p j = false)","context":["assume","bounded_search","auto"]} +{"prover":"Minlog","tactic_proof":"refl","source":"minlog_synthetic/bounded_arithmetic","theorem":"pspace_pspace","id":88641,"goal":"pspace = pspace","context":["refl"]} +{"prover":"Minlog","tactic_proof":"intro; propositional_sat; auto","source":"minlog_synthetic/finite_logic","theorem":"fin_sat_decidable","id":88642,"goal":"all phi:Formula. decidable(sat(phi))","context":["intro","propositional_sat","auto"]} +{"prover":"Minlog","tactic_proof":"assume h; resolution_soundness; auto","source":"minlog_synthetic/finite_logic","theorem":"resolution_sound","id":88643,"goal":"all phi. res_derives(empty, phi) -> unsat(phi)","context":["assume h","resolution_soundness","auto"]} +{"prover":"Minlog","tactic_proof":"assume h; resolution_completeness; auto","source":"minlog_synthetic/finite_logic","theorem":"resolution_complete","id":88644,"goal":"all phi. unsat(phi) -> res_derives(empty, phi)","context":["assume h","resolution_completeness","auto"]} +{"prover":"Minlog","tactic_proof":"intro; wf_induct; auto","source":"minlog_synthetic/finite_logic","theorem":"dpll_terminates","id":88645,"goal":"all phi. terminates(dpll(phi))","context":["intro","wf_induct","auto"]} +{"prover":"Minlog","tactic_proof":"intro; tseitin; auto","source":"minlog_synthetic/finite_logic","theorem":"cnf_equivalent","id":88646,"goal":"all phi. equivalent(phi, to_cnf(phi))","context":["intro","tseitin","auto"]} +{"prover":"Minlog","tactic_proof":"intro; unit_propagation; auto","source":"minlog_synthetic/finite_logic","theorem":"horn_sat_poly","id":88647,"goal":"all phi:HornFormula. poly_time_decidable(sat(phi))","context":["intro","unit_propagation","auto"]} diff --git a/training_data/proof_states_mizar.jsonl b/training_data/proof_states_mizar.jsonl index a6a9815..c399ada 100644 --- a/training_data/proof_states_mizar.jsonl +++ b/training_data/proof_states_mizar.jsonl @@ -77073,3 +77073,65 @@ {"prover":"Mizar","tactic_proof":"proof let R be Ring; let a, b be Element of R; thus a + b = b + a by RLVECT_1:2; end;","source":"mizar_synthetic/algebra","theorem":"ring_add_comm","id":171072,"goal":"theorem ring_add_comm: for R being Ring, a, b being Element of R holds a + b = b + a","context":["let","thus"]} {"prover":"Mizar","tactic_proof":"proof let R be Ring; let a, b, c be Element of R; thus (a * b) * c = a * (b * c) by GROUP_1:def 3; end;","source":"mizar_synthetic/algebra","theorem":"ring_mul_assoc","id":171073,"goal":"theorem ring_mul_assoc: for R being Ring, a, b, c being Element of R holds (a * b) * c = a * (b * c)","context":["let","thus"]} {"prover":"Mizar","tactic_proof":"proof let R be Ring; let a, b, c be Element of R; thus a * (b + c) = a * b + a * c by VECTSP_1:def 7; end;","source":"mizar_synthetic/algebra","theorem":"ring_distrib_left","id":171074,"goal":"theorem ring_distrib_left: for R being Ring, a, b, c being Element of R holds a * (b + c) = a * b + a * c","context":["let","thus"]} +{"prover":"Mizar","tactic_proof":"proof let seq be Real_Sequence; assume A1: seq is convergent; let e be Real; assume A2: e > 0; thus ex N being Nat st for n being Nat st n >= N holds |.seq.n - lim seq.| < e by A1, A2, SEQ_2:def 7; end;","source":"mizar_synthetic/sequences","theorem":"seq_convergent","id":171075,"goal":"theorem seq_convergent: for seq being Real_Sequence st seq is convergent holds for e being Real st e > 0 ex N being Nat st for n being Nat st n >= N holds |.seq.n - lim seq.| < e","context":["let","assume","thus"]} +{"prover":"Mizar","tactic_proof":"proof let seq be Real_Sequence; assume A1: seq is increasing; assume A2: seq is bounded_above; thus seq is convergent by A1, A2, SEQ_4:37; end;","source":"mizar_synthetic/sequences","theorem":"seq_monotone_incr","id":171076,"goal":"theorem seq_monotone_incr: for seq being Real_Sequence st seq is increasing & seq is bounded_above holds seq is convergent","context":["let","assume","thus"]} +{"prover":"Mizar","tactic_proof":"proof let seq be Real_Sequence; assume seq is convergent; hence seq is bounded by SEQ_2:13; end;","source":"mizar_synthetic/sequences","theorem":"seq_bounded_convergent","id":171077,"goal":"theorem seq_bounded_convergent: for seq being Real_Sequence st seq is convergent holds seq is bounded","context":["let","assume","hence"]} +{"prover":"Mizar","tactic_proof":"proof let seq be Real_Sequence; assume A1: seq is bounded; consider seq1 being subsequence of seq such that A2: seq1 is monotone by A1, SEQ_4:39; take seq1; seq1 is bounded by A1, SEQ_4:27; hence seq1 is convergent by A2, SEQ_4:37, SEQ_4:38; end;","source":"mizar_synthetic/sequences","theorem":"seq_bolzano_weierstrass","id":171078,"goal":"theorem seq_bolzano_weierstrass: for seq being Real_Sequence st seq is bounded ex seq1 being subsequence of seq st seq1 is convergent","context":["let","assume","consider","take","hence"]} +{"prover":"Mizar","tactic_proof":"proof let seq be Real_Sequence; thus seq is convergent iff seq is Cauchy by SEQ_4:25; end;","source":"mizar_synthetic/sequences","theorem":"seq_cauchy_criterion","id":171079,"goal":"theorem seq_cauchy_criterion: for seq being Real_Sequence holds seq is convergent iff seq is Cauchy","context":["let","thus"]} +{"prover":"Mizar","tactic_proof":"proof let seq1, seq2 be Real_Sequence; assume A1: seq1 is convergent; assume A2: seq2 is convergent; thus lim (seq1 + seq2) = lim seq1 + lim seq2 by A1, A2, SEQ_2:6; end;","source":"mizar_synthetic/sequences","theorem":"seq_limit_add","id":171080,"goal":"theorem seq_limit_add: for seq1, seq2 being Real_Sequence st seq1 is convergent & seq2 is convergent holds lim (seq1 + seq2) = lim seq1 + lim seq2","context":["let","assume","thus"]} +{"prover":"Mizar","tactic_proof":"proof let seq1, seq2 be Real_Sequence; assume A1: seq1 is convergent; assume A2: seq2 is convergent; thus lim (seq1 (#) seq2) = (lim seq1) * (lim seq2) by A1, A2, SEQ_2:8; end;","source":"mizar_synthetic/sequences","theorem":"seq_limit_mul","id":171081,"goal":"theorem seq_limit_mul: for seq1, seq2 being Real_Sequence st seq1 is convergent & seq2 is convergent holds lim (seq1 (#) seq2) = (lim seq1) * (lim seq2)","context":["let","assume","thus"]} +{"prover":"Mizar","tactic_proof":"proof let seq be Real_Sequence; let seq1 be subsequence of seq; assume A1: seq is convergent; thus seq1 is convergent by A1, SEQ_4:17; hence lim seq1 = lim seq by A1, SEQ_4:17; end;","source":"mizar_synthetic/sequences","theorem":"seq_subsequence_limit","id":171082,"goal":"theorem seq_subsequence_limit: for seq being Real_Sequence, seq1 being subsequence of seq st seq is convergent holds seq1 is convergent & lim seq1 = lim seq","context":["let","assume","thus","hence"]} +{"prover":"Mizar","tactic_proof":"proof let seq be Real_Sequence; assume seq is summable; hence Partial_Sums seq is convergent by SERIES_1:def 2; end;","source":"mizar_synthetic/sequences","theorem":"seq_series_convergent","id":171083,"goal":"theorem seq_series_convergent: for seq being Real_Sequence st seq is summable holds Partial_Sums seq is convergent","context":["let","assume","hence"]} +{"prover":"Mizar","tactic_proof":"proof let seq be Real_Sequence; assume ex N being Nat st for n being Nat st n >= N holds |.seq.(n+1).| / |.seq.n.| < 1; hence seq is summable by SERIES_1:24; end;","source":"mizar_synthetic/sequences","theorem":"seq_ratio_test","id":171084,"goal":"theorem seq_ratio_test: for seq being Real_Sequence st (ex N being Nat st for n being Nat st n >= N holds |.seq.(n+1).| / |.seq.n.| < 1) holds seq is summable","context":["let","assume","hence"]} +{"prover":"Mizar","tactic_proof":"proof let seq1, seq2 be Real_Sequence; assume A1: for n being Nat holds |.seq1.n.| <= seq2.n; assume A2: seq2 is summable; thus seq1 is summable by A1, A2, SERIES_1:20; end;","source":"mizar_synthetic/sequences","theorem":"seq_comparison_test","id":171085,"goal":"theorem seq_comparison_test: for seq1, seq2 being Real_Sequence st (for n being Nat holds |.seq1.n.| <= seq2.n) & seq2 is summable holds seq1 is summable","context":["let","assume","thus"]} +{"prover":"Mizar","tactic_proof":"proof let seq be Real_Sequence; assume A1: for n being Nat holds seq.n = 1 / (n + 1); set P = Partial_Sums seq; assume A2: seq is summable; then P is convergent by SERIES_1:def 2; consider M being Real such that A3: for n being Nat holds P.n <= M by RSSPACE:7; per cases; suppose M > 0; consider N being Nat such that A4: P.N > M by A1, SEQ_4:6; thus contradiction by A3, A4; end; suppose M <= 0; P.0 = seq.0 by SERIES_1:def 1 .= 1 / (0 + 1) by A1 .= 1; hence contradiction by A3; end; end;","source":"mizar_synthetic/sequences","theorem":"seq_harmonic_divergent","id":171086,"goal":"theorem seq_harmonic_divergent: for seq being Real_Sequence st for n being Nat holds seq.n = 1 / (n + 1) holds not seq is summable","context":["let","assume","set","consider","per cases","suppose","thus","hence"]} +{"prover":"Mizar","tactic_proof":"proof let L be Lattice; let a, b be Element of L; thus a \"\\/\" b = b \"\\/\" a by LATTICES:def 1; end;","source":"mizar_synthetic/lattices","theorem":"lattice_join_comm","id":171087,"goal":"theorem lattice_join_comm: for L being Lattice, a, b being Element of L holds a \"\\/\" b = b \"\\/\" a","context":["let","thus"]} +{"prover":"Mizar","tactic_proof":"proof let L be Lattice; let a, b be Element of L; thus a \"/\\\" b = b \"/\\\" a by LATTICES:def 2; end;","source":"mizar_synthetic/lattices","theorem":"lattice_meet_comm","id":171088,"goal":"theorem lattice_meet_comm: for L being Lattice, a, b being Element of L holds a \"/\\\" b = b \"/\\\" a","context":["let","thus"]} +{"prover":"Mizar","tactic_proof":"proof let L be Lattice; let a, b, c be Element of L; thus a \"\\/\" (b \"\\/\" c) = (a \"\\/\" b) \"\\/\" c by LATTICES:def 5; end;","source":"mizar_synthetic/lattices","theorem":"lattice_join_assoc","id":171089,"goal":"theorem lattice_join_assoc: for L being Lattice, a, b, c being Element of L holds a \"\\/\" (b \"\\/\" c) = (a \"\\/\" b) \"\\/\" c","context":["let","thus"]} +{"prover":"Mizar","tactic_proof":"proof let L be Lattice; let a, b, c be Element of L; thus a \"/\\\" (b \"/\\\" c) = (a \"/\\\" b) \"/\\\" c by LATTICES:def 7; end;","source":"mizar_synthetic/lattices","theorem":"lattice_meet_assoc","id":171090,"goal":"theorem lattice_meet_assoc: for L being Lattice, a, b, c being Element of L holds a \"/\\\" (b \"/\\\" c) = (a \"/\\\" b) \"/\\\" c","context":["let","thus"]} +{"prover":"Mizar","tactic_proof":"proof let L be Lattice; let a, b be Element of L; thus a \"\\/\" (a \"/\\\" b) = a by LATTICES:def 8; end;","source":"mizar_synthetic/lattices","theorem":"lattice_absorption_join","id":171091,"goal":"theorem lattice_absorption_join: for L being Lattice, a, b being Element of L holds a \"\\/\" (a \"/\\\" b) = a","context":["let","thus"]} +{"prover":"Mizar","tactic_proof":"proof let L be Lattice; let a, b be Element of L; thus a \"/\\\" (a \"\\/\" b) = a by LATTICES:def 9; end;","source":"mizar_synthetic/lattices","theorem":"lattice_absorption_meet","id":171092,"goal":"theorem lattice_absorption_meet: for L being Lattice, a, b being Element of L holds a \"/\\\" (a \"\\/\" b) = a","context":["let","thus"]} +{"prover":"Mizar","tactic_proof":"proof let L be distributive Lattice; let a, b, c be Element of L; thus a \"/\\\" (b \"\\/\" c) = (a \"/\\\" b) \"\\/\" (a \"/\\\" c) by LATTICES:def 11; end;","source":"mizar_synthetic/lattices","theorem":"lattice_distributive","id":171093,"goal":"theorem lattice_distributive: for L being distributive Lattice, a, b, c being Element of L holds a \"/\\\" (b \"\\/\" c) = (a \"/\\\" b) \"\\/\" (a \"/\\\" c)","context":["let","thus"]} +{"prover":"Mizar","tactic_proof":"proof let L be complemented bounded Lattice; let a be Element of L; thus ex b being Element of L st a \"\\/\" b = Top L & a \"/\\\" b = Bottom L by LATTICES:def 19; end;","source":"mizar_synthetic/lattices","theorem":"lattice_complemented","id":171094,"goal":"theorem lattice_complemented: for L being complemented bounded Lattice, a being Element of L ex b being Element of L st a \"\\/\" b = Top L & a \"/\\\" b = Bottom L","context":["let","thus"]} +{"prover":"Mizar","tactic_proof":"proof let L be bounded Lattice; let a be Element of L; thus a \"\\/\" (Bottom L) = a by LATTICES:39; thus a \"/\\\" (Top L) = a by LATTICES:41; end;","source":"mizar_synthetic/lattices","theorem":"lattice_bounded","id":171095,"goal":"theorem lattice_bounded: for L being bounded Lattice, a being Element of L holds a \"\\/\" (Bottom L) = a & a \"/\\\" (Top L) = a","context":["let","thus"]} +{"prover":"Mizar","tactic_proof":"proof let L be modular Lattice; let a, b, c be Element of L; assume a [= c; hence a \"\\/\" (b \"/\\\" c) = (a \"\\/\" b) \"/\\\" c by LATTICES:def 12; end;","source":"mizar_synthetic/lattices","theorem":"lattice_modular","id":171096,"goal":"theorem lattice_modular: for L being modular Lattice, a, b, c being Element of L st a [= c holds a \"\\/\" (b \"/\\\" c) = (a \"\\/\" b) \"/\\\" c","context":["let","assume","hence"]} +{"prover":"Mizar","tactic_proof":"proof let M be MetrSpace; let p, q be Point of M; thus dist(p, q) >= 0 by METRIC_1:5; end;","source":"mizar_synthetic/metric_spaces","theorem":"metric_dist_nonneg","id":171097,"goal":"theorem metric_dist_nonneg: for M being MetrSpace, p, q being Point of M holds dist(p, q) >= 0","context":["let","thus"]} +{"prover":"Mizar","tactic_proof":"proof let M be MetrSpace; let p, q be Point of M; thus dist(p, q) = dist(q, p) by METRIC_1:def 1; end;","source":"mizar_synthetic/metric_spaces","theorem":"metric_dist_sym","id":171098,"goal":"theorem metric_dist_sym: for M being MetrSpace, p, q being Point of M holds dist(p, q) = dist(q, p)","context":["let","thus"]} +{"prover":"Mizar","tactic_proof":"proof let M be MetrSpace; let p, q, r be Point of M; thus dist(p, r) <= dist(p, q) + dist(q, r) by METRIC_1:4; end;","source":"mizar_synthetic/metric_spaces","theorem":"metric_triangle_ineq","id":171099,"goal":"theorem metric_triangle_ineq: for M being MetrSpace, p, q, r being Point of M holds dist(p, r) <= dist(p, q) + dist(q, r)","context":["let","thus"]} +{"prover":"Mizar","tactic_proof":"proof let M be MetrSpace; let p, q be Point of M; thus dist(p, q) = 0 iff p = q by METRIC_1:2, METRIC_1:1; end;","source":"mizar_synthetic/metric_spaces","theorem":"metric_dist_zero","id":171100,"goal":"theorem metric_dist_zero: for M being MetrSpace, p, q being Point of M holds dist(p, q) = 0 iff p = q","context":["let","thus"]} +{"prover":"Mizar","tactic_proof":"proof let M be MetrSpace; let p be Point of M; let r be positive Real; thus Ball(p, r) is open Subset of TopSpaceMetr M by TBSP_1:16; end;","source":"mizar_synthetic/metric_spaces","theorem":"metric_open_ball_open","id":171101,"goal":"theorem metric_open_ball_open: for M being MetrSpace, p being Point of M, r being positive Real holds Ball(p, r) is open Subset of TopSpaceMetr M","context":["let","thus"]} +{"prover":"Mizar","tactic_proof":"proof let M be MetrSpace; let seq be sequence of M; assume A1: M is complete; assume A2: seq is Cauchy; thus seq is convergent by A1, A2, TBSP_1:def 6; end;","source":"mizar_synthetic/metric_spaces","theorem":"metric_cauchy_convergent","id":171102,"goal":"theorem metric_cauchy_convergent: for M being MetrSpace, seq being sequence of M st M is complete & seq is Cauchy holds seq is convergent","context":["let","assume","thus"]} +{"prover":"Mizar","tactic_proof":"proof let M be MetrSpace; let A be Subset of M; assume A1: M is complete; assume A2: A is closed; let seq be sequence of M such that A3: rng seq c= A and A4: seq is Cauchy; seq is convergent by A1, A4, TBSP_1:def 6; consider p being Point of M such that A5: seq is_convergent_in_metrspace_to p by TBSP_1:def 4; p in A by A2, A3, A5, TBSP_1:8; hence thesis; end;","source":"mizar_synthetic/metric_spaces","theorem":"metric_complete_closed","id":171103,"goal":"theorem metric_complete_closed: for M being MetrSpace, A being Subset of M st M is complete & A is closed holds A is complete","context":["let","assume","consider","hence"]} +{"prover":"Mizar","tactic_proof":"proof let M be MetrSpace; let A be Subset of M; assume A1: A is compact; let seq be sequence of M; assume rng seq c= A; thus ex seq1 being subsequence of seq st seq1 is convergent by A1, TBSP_1:def 9; end;","source":"mizar_synthetic/metric_spaces","theorem":"metric_compact_sequentially","id":171104,"goal":"theorem metric_compact_sequentially: for M being MetrSpace, A being Subset of M st A is compact holds for seq being sequence of M st rng seq c= A ex seq1 being subsequence of seq st seq1 is convergent","context":["let","assume","thus"]} +{"prover":"Mizar","tactic_proof":"proof let M1, M2 be MetrSpace; let f be Function of M1, M2; let L be positive Real; assume A1: for p, q being Point of M1 holds dist(f.p, f.q) <= L * dist(p, q); let p be Point of M1; let e be Real; assume A2: e > 0; set d = e / L; take d; thus d > 0 by A2; let q be Point of M1; assume dist(p, q) < d; dist(f.p, f.q) <= L * dist(p, q) by A1; hence dist(f.p, f.q) < e by XREAL_1:68; end;","source":"mizar_synthetic/metric_spaces","theorem":"metric_lipschitz_continuous","id":171105,"goal":"theorem metric_lipschitz_continuous: for M1, M2 being MetrSpace, f being Function of M1, M2, L being positive Real st for p, q being Point of M1 holds dist(f.p, f.q) <= L * dist(p, q) holds f is continuous","context":["let","assume","set","take","thus","hence"]} +{"prover":"Mizar","tactic_proof":"proof let M1, M2 be MetrSpace; assume A1: the TopStruct of TopSpaceMetr M1 = the TopStruct of TopSpaceMetr M2; let A be Subset of M1; thus A is open Subset of TopSpaceMetr M1 iff A is open Subset of TopSpaceMetr M2 by A1, PRE_TOPC:def 2; end;","source":"mizar_synthetic/metric_spaces","theorem":"metric_equiv_open_sets","id":171106,"goal":"theorem metric_equiv_open_sets: for M1, M2 being MetrSpace st the TopStruct of TopSpaceMetr M1 = the TopStruct of TopSpaceMetr M2 holds for A being Subset of M1 holds A is open Subset of TopSpaceMetr M1 iff A is open Subset of TopSpaceMetr M2","context":["let","assume","thus"]} +{"prover":"Mizar","tactic_proof":"proof let D be non empty set; thus <*>D is FinSequence of D; thus len (<*>D) = 0 by FINSEQ_1:def 3; end;","source":"mizar_synthetic/finite_sequences","theorem":"finseq_empty","id":171107,"goal":"theorem finseq_empty: for D being non empty set holds <*>D is FinSequence of D & len (<*>D) = 0","context":["let","set","thus"]} +{"prover":"Mizar","tactic_proof":"proof let f, g be FinSequence; thus len (f ^ g) = len f + len g by FINSEQ_1:22; end;","source":"mizar_synthetic/finite_sequences","theorem":"finseq_concat_len","id":171108,"goal":"theorem finseq_concat_len: for f, g being FinSequence holds len (f ^ g) = len f + len g","context":["let","thus"]} +{"prover":"Mizar","tactic_proof":"proof let f, g, h be FinSequence; thus (f ^ g) ^ h = f ^ (g ^ h) by FINSEQ_1:32; end;","source":"mizar_synthetic/finite_sequences","theorem":"finseq_concat_assoc","id":171109,"goal":"theorem finseq_concat_assoc: for f, g, h being FinSequence holds (f ^ g) ^ h = f ^ (g ^ h)","context":["let","thus"]} +{"prover":"Mizar","tactic_proof":"proof let f be FinSequence; thus Rev (Rev f) = f by FINSEQ_1:48; end;","source":"mizar_synthetic/finite_sequences","theorem":"finseq_rev_rev","id":171110,"goal":"theorem finseq_rev_rev: for f being FinSequence holds Rev (Rev f) = f","context":["let","thus"]} +{"prover":"Mizar","tactic_proof":"proof let f be FinSequence; thus len (Rev f) = len f by FINSEQ_1:46; end;","source":"mizar_synthetic/finite_sequences","theorem":"finseq_rev_len","id":171111,"goal":"theorem finseq_rev_len: for f being FinSequence holds len (Rev f) = len f","context":["let","thus"]} +{"prover":"Mizar","tactic_proof":"proof let x be object; thus <*x*> is FinSequence; thus len <*x*> = 1 by FINSEQ_1:39; end;","source":"mizar_synthetic/finite_sequences","theorem":"finseq_singleton","id":171112,"goal":"theorem finseq_singleton: for x being object holds <*x*> is FinSequence & len <*x*> = 1","context":["let","thus"]} +{"prover":"Mizar","tactic_proof":"proof let f be FinSequence; thus dom f = Seg len f by FINSEQ_1:def 3; end;","source":"mizar_synthetic/finite_sequences","theorem":"finseq_dom_range","id":171113,"goal":"theorem finseq_dom_range: for f being FinSequence holds dom f = Seg len f","context":["let","thus"]} +{"prover":"Mizar","tactic_proof":"proof let D be set; let f be FinSequence of D; thus rng f c= D by FINSEQ_1:def 4; end;","source":"mizar_synthetic/finite_sequences","theorem":"finseq_rng_subset","id":171114,"goal":"theorem finseq_rng_subset: for D being set, f being FinSequence of D holds rng f c= D","context":["let","set","thus"]} +{"prover":"Mizar","tactic_proof":"proof let f, g be FinSequence; assume g is Permutation of f; hence len g = len f by FINSEQ_2:32; end;","source":"mizar_synthetic/finite_sequences","theorem":"finseq_perm_len","id":171115,"goal":"theorem finseq_perm_len: for f, g being FinSequence st g is Permutation of f holds len g = len f","context":["let","assume","hence"]} +{"prover":"Mizar","tactic_proof":"proof let f be FinSequence; thus f ^ (<*> the carrier of REAL) = f by FINSEQ_1:34; end;","source":"mizar_synthetic/finite_sequences","theorem":"finseq_concat_empty","id":171116,"goal":"theorem finseq_concat_empty: for f being FinSequence holds f ^ (<*> the carrier of REAL) = f","context":["let","thus"]} +{"prover":"Mizar","tactic_proof":"proof let A be Ordinal; thus not A in A by ORDINAL1:5; end;","source":"mizar_synthetic/ordinals","theorem":"ordinal_lt_irrefl","id":171117,"goal":"theorem ordinal_lt_irrefl: for A being Ordinal holds not A in A","context":["let","thus"]} +{"prover":"Mizar","tactic_proof":"proof let A, B, C be Ordinal; assume A1: A in B; assume A2: B in C; thus A in C by A1, A2, ORDINAL1:10; end;","source":"mizar_synthetic/ordinals","theorem":"ordinal_lt_trans","id":171118,"goal":"theorem ordinal_lt_trans: for A, B, C being Ordinal st A in B & B in C holds A in C","context":["let","assume","thus"]} +{"prover":"Mizar","tactic_proof":"proof let A, B be Ordinal; thus A in B or A = B or B in A by ORDINAL1:16; end;","source":"mizar_synthetic/ordinals","theorem":"ordinal_trichotomy","id":171119,"goal":"theorem ordinal_trichotomy: for A, B being Ordinal holds A in B or A = B or B in A","context":["let","thus"]} +{"prover":"Mizar","tactic_proof":"proof let A be Ordinal; thus A in succ A by ORDINAL1:6; end;","source":"mizar_synthetic/ordinals","theorem":"ordinal_succ_gt","id":171120,"goal":"theorem ordinal_succ_gt: for A being Ordinal holds A in succ A","context":["let","thus"]} +{"prover":"Mizar","tactic_proof":"proof let A be Ordinal; thus succ A is Ordinal by ORDINAL1:def 4; end;","source":"mizar_synthetic/ordinals","theorem":"ordinal_succ_ordinal","id":171121,"goal":"theorem ordinal_succ_ordinal: for A being Ordinal holds succ A is Ordinal","context":["let","thus"]} +{"prover":"Mizar","tactic_proof":"proof let A be Ordinal; assume A1: A is limit_ordinal; assume A2: A <> {}; assume ex B being Ordinal st A = succ B; then consider B being Ordinal such that A3: A = succ B; thus contradiction by A1, A3, ORDINAL1:def 5; end;","source":"mizar_synthetic/ordinals","theorem":"ordinal_limit_not_succ","id":171122,"goal":"theorem ordinal_limit_not_succ: for A being Ordinal st A is limit_ordinal & A <> {} holds not ex B being Ordinal st A = succ B","context":["let","assume","consider","thus"]} +{"prover":"Mizar","tactic_proof":"proof let P be Ordinal-defined Function; assume A1: for A being Ordinal st (for B being Ordinal st B in A holds P.B is true) holds P.A is true; defpred Q[Ordinal] means P.$1 is true; A2: for A being Ordinal st (for B being Ordinal st B in A holds Q[B]) holds Q[A] by A1; thus for A being Ordinal holds Q[A] from ORDINAL1:sch 3(A2); end;","source":"mizar_synthetic/ordinals","theorem":"ordinal_transfinite_ind","id":171123,"goal":"theorem ordinal_transfinite_ind: for P being Ordinal-defined Function st (for A being Ordinal st (for B being Ordinal st B in A holds P.B is true) holds P.A is true) holds for A being Ordinal holds P.A is true","context":["let","assume","defpred","thus"]} +{"prover":"Mizar","tactic_proof":"proof let A be Ordinal; thus A + {} = A by ORDINAL2:27; end;","source":"mizar_synthetic/ordinals","theorem":"ordinal_add_zero","id":171124,"goal":"theorem ordinal_add_zero: for A being Ordinal holds A + {} = A","context":["let","thus"]} +{"prover":"Mizar","tactic_proof":"proof let A, B be Ordinal; thus A + succ B = succ (A + B) by ORDINAL2:28; end;","source":"mizar_synthetic/ordinals","theorem":"ordinal_add_succ","id":171125,"goal":"theorem ordinal_add_succ: for A, B being Ordinal holds A + succ B = succ (A + B)","context":["let","thus"]} +{"prover":"Mizar","tactic_proof":"proof let A be Ordinal; thus A *^ {} = {} by ORDINAL2:35; end;","source":"mizar_synthetic/ordinals","theorem":"ordinal_mul_zero","id":171126,"goal":"theorem ordinal_mul_zero: for A being Ordinal holds A *^ {} = {}","context":["let","thus"]} +{"prover":"Mizar","tactic_proof":"proof let S be SigmaField of X; thus {} in S by PROB_1:4; end;","source":"mizar_synthetic/measure_theory","theorem":"measure_sigma_algebra_empty","id":171127,"goal":"theorem measure_sigma_algebra_empty: for S being SigmaField of X holds {} in S","context":["let","thus"]} +{"prover":"Mizar","tactic_proof":"proof let S be SigmaField of X; let A be set; assume A in S; hence X \\ A in S by PROB_1:def 1; end;","source":"mizar_synthetic/measure_theory","theorem":"measure_sigma_algebra_compl","id":171128,"goal":"theorem measure_sigma_algebra_compl: for S being SigmaField of X, A being set st A in S holds X \\ A in S","context":["let","set","assume","hence"]} +{"prover":"Mizar","tactic_proof":"proof let S be SigmaField of X; let A be SetSequence of X; assume for n being Nat holds A.n in S; hence union rng A in S by PROB_1:def 1; end;","source":"mizar_synthetic/measure_theory","theorem":"measure_sigma_algebra_union","id":171129,"goal":"theorem measure_sigma_algebra_union: for S being SigmaField of X, A being SetSequence of X st (for n being Nat holds A.n in S) holds union rng A in S","context":["let","assume","hence"]} +{"prover":"Mizar","tactic_proof":"proof let S be SigmaField of X; let M be Measure of S; let A be set; assume A in S; thus M.A >= 0 by SUPINF_2:42, MEASURE1:def 2; end;","source":"mizar_synthetic/measure_theory","theorem":"measure_nonneg","id":171130,"goal":"theorem measure_nonneg: for S being SigmaField of X, M being Measure of S, A being set st A in S holds M.A >= 0","context":["let","set","assume","thus"]} +{"prover":"Mizar","tactic_proof":"proof let S be SigmaField of X; let M be Measure of S; thus M.{} = 0 by MEASURE1:def 2; end;","source":"mizar_synthetic/measure_theory","theorem":"measure_empty_zero","id":171131,"goal":"theorem measure_empty_zero: for S being SigmaField of X, M being Measure of S holds M.{} = 0","context":["let","thus"]} +{"prover":"Mizar","tactic_proof":"proof let S be SigmaField of X; let M be Measure of S; let A be SetSequence of X; assume A1: A is mutually-disjoint; assume A2: for n being Nat holds A.n in S; thus M.(union rng A) = SUM(M * A) by A1, A2, MEASURE1:def 2; end;","source":"mizar_synthetic/measure_theory","theorem":"measure_countable_additivity","id":171132,"goal":"theorem measure_countable_additivity: for S being SigmaField of X, M being Measure of S, A being SetSequence of X st A is mutually-disjoint & (for n being Nat holds A.n in S) holds M.(union rng A) = SUM(M * A)","context":["let","assume","thus"]} +{"prover":"Mizar","tactic_proof":"proof let S be SigmaField of X; let M be Measure of S; let A, B be set; assume A1: A in S; assume A2: B in S; assume A3: A c= B; reconsider C = B \\ A as Element of S by A1, A2, PROB_1:def 1; M.B = M.A + M.C by A1, A3, MEASURE1:22; hence M.A <= M.B by SUPINF_2:42, MEASURE1:def 2; end;","source":"mizar_synthetic/measure_theory","theorem":"measure_monotone","id":171133,"goal":"theorem measure_monotone: for S being SigmaField of X, M being Measure of S, A, B being set st A in S & B in S & A c= B holds M.A <= M.B","context":["let","set","assume","reconsider","hence"]} +{"prover":"Mizar","tactic_proof":"proof let S be SigmaField of X; let M be Measure of S; let A be SetSequence of X; assume for n being Nat holds A.n in S; hence M.(union rng A) <= SUM(M * A) by MEASURE1:31; end;","source":"mizar_synthetic/measure_theory","theorem":"measure_subadditivity","id":171134,"goal":"theorem measure_subadditivity: for S being SigmaField of X, M being Measure of S, A being SetSequence of X st (for n being Nat holds A.n in S) holds M.(union rng A) <= SUM(M * A)","context":["let","assume","hence"]} +{"prover":"Mizar","tactic_proof":"proof let S be SigmaField of X; let f be Function of X, REAL; let a be Real; assume f is S-measurable; hence f\"(].a, +infty.[) in S by MEASURE1:def 7; end;","source":"mizar_synthetic/measure_theory","theorem":"measurable_function_preimage","id":171135,"goal":"theorem measurable_function_preimage: for S being SigmaField of X, f being Function of X, REAL, a being Real st f is S-measurable holds f\"(].a, +infty.[) in S","context":["let","assume","hence"]} +{"prover":"Mizar","tactic_proof":"proof let S be SigmaField of X; let M be Measure of S; let A be SetSequence of X; assume A1: for n being Nat holds A.n in S; assume A2: A is non-descending; thus M.(union rng A) = lim (M * A) by A1, A2, MEASURE1:32; end;","source":"mizar_synthetic/measure_theory","theorem":"measure_continuity_below","id":171136,"goal":"theorem measure_continuity_below: for S being SigmaField of X, M being Measure of S, A being SetSequence of X st (for n being Nat holds A.n in S) & A is non-descending holds M.(union rng A) = lim (M * A)","context":["let","assume","thus"]} diff --git a/training_data/proof_states_nuprl.jsonl b/training_data/proof_states_nuprl.jsonl index 3d3e4cb..5a33a32 100644 --- a/training_data/proof_states_nuprl.jsonl +++ b/training_data/proof_states_nuprl.jsonl @@ -1,152 +1,152 @@ -{"id":88000,"prover":"Nuprl","theorem":"add_comm","goal":"all x,y:Int. (x + y) = (y + x)","context":["Auto"],"tactic_proof":"Auto","source":"nuprl_synthetic/arithmetic"} -{"id":88001,"prover":"Nuprl","theorem":"add_assoc","goal":"all x,y,z:Int. ((x + y) + z) = (x + (y + z))","context":["Auto"],"tactic_proof":"Auto","source":"nuprl_synthetic/arithmetic"} -{"id":88002,"prover":"Nuprl","theorem":"mul_comm","goal":"all x,y:Int. (x * y) = (y * x)","context":["Auto"],"tactic_proof":"Auto","source":"nuprl_synthetic/arithmetic"} -{"id":88003,"prover":"Nuprl","theorem":"mul_assoc","goal":"all x,y,z:Int. ((x * y) * z) = (x * (y * z))","context":["Auto"],"tactic_proof":"Auto","source":"nuprl_synthetic/arithmetic"} -{"id":88004,"prover":"Nuprl","theorem":"distrib_left","goal":"all x,y,z:Int. (x * (y + z)) = ((x * y) + (x * z))","context":["Auto"],"tactic_proof":"Auto","source":"nuprl_synthetic/arithmetic"} -{"id":88005,"prover":"Nuprl","theorem":"add_zero","goal":"all x:Int. (x + 0) = x","context":["Auto"],"tactic_proof":"Auto","source":"nuprl_synthetic/arithmetic"} -{"id":88006,"prover":"Nuprl","theorem":"mul_one","goal":"all x:Int. (x * 1) = x","context":["Auto"],"tactic_proof":"Auto","source":"nuprl_synthetic/arithmetic"} -{"id":88007,"prover":"Nuprl","theorem":"add_inverse","goal":"all x:Int. (x + (-x)) = 0","context":["Auto"],"tactic_proof":"Auto","source":"nuprl_synthetic/arithmetic"} -{"id":88008,"prover":"Nuprl","theorem":"nat_induction","goal":"all P:(Nat -> Prop). P(0) => (all n:Nat. P(n) => P(n+1)) => all n:Nat. P(n)","context":["Intro","NatInd","Auto"],"tactic_proof":"Intro; Intro; NatInd; Auto","source":"nuprl_synthetic/arithmetic"} -{"id":88009,"prover":"Nuprl","theorem":"div_mod","goal":"all a:Int, b:PosInt. a = (b * (a / b)) + (a mod b)","context":["Auto"],"tactic_proof":"Auto","source":"nuprl_synthetic/arithmetic"} -{"id":88010,"prover":"Nuprl","theorem":"abs_nonneg","goal":"all x:Int. 0 <= |x|","context":["CaseAnalysis `x >= 0`","Auto"],"tactic_proof":"CaseAnalysis `x >= 0`; Auto","source":"nuprl_synthetic/arithmetic"} -{"id":88011,"prover":"Nuprl","theorem":"triangle_ineq","goal":"all x,y:Int. |x + y| <= |x| + |y|","context":["CaseAnalysis `x >= 0`","CaseAnalysis `y >= 0`","Auto"],"tactic_proof":"CaseAnalysis `x >= 0`; CaseAnalysis `y >= 0`; Auto","source":"nuprl_synthetic/arithmetic"} -{"id":88012,"prover":"Nuprl","theorem":"even_or_odd","goal":"all n:Nat. (exists k:Nat. n = 2*k) or (exists k:Nat. n = 2*k + 1)","context":["NatInd","Auto","OrElim"],"tactic_proof":"NatInd; Auto; OrElim; Auto","source":"nuprl_synthetic/arithmetic"} -{"id":88013,"prover":"Nuprl","theorem":"gcd_divides","goal":"all a,b:PosInt. divides(gcd(a,b), a) & divides(gcd(a,b), b)","context":["Unfold `gcd`","NatInd","Auto"],"tactic_proof":"Unfold `gcd`; NatInd; Auto","source":"nuprl_synthetic/arithmetic"} -{"id":88014,"prover":"Nuprl","theorem":"prime_factorization","goal":"all n:Nat. n >= 2 => exists ps:List(PosInt). all p in ps. prime(p) & product(ps) = n","context":["StrongInduction","Auto"],"tactic_proof":"StrongInduction; Auto","source":"nuprl_synthetic/arithmetic"} -{"id":88015,"prover":"Nuprl","theorem":"pair_eta","goal":"all A,B:Type, p:A*B. p = ","context":["Intro","PairElim","Auto"],"tactic_proof":"Intro; PairElim; Auto","source":"nuprl_synthetic/types"} -{"id":88016,"prover":"Nuprl","theorem":"sum_elim","goal":"all A,B:Type, C:Type. (A -> C) -> (B -> C) -> (A + B) -> C","context":["Intro","DecideElim","Auto"],"tactic_proof":"Intro; Intro; Intro; DecideElim; Auto","source":"nuprl_synthetic/types"} -{"id":88017,"prover":"Nuprl","theorem":"void_elim","goal":"all A:Type. Void -> A","context":["Intro","VoidElim","Auto"],"tactic_proof":"Intro; VoidElim; Auto","source":"nuprl_synthetic/types"} -{"id":88018,"prover":"Nuprl","theorem":"unit_unique","goal":"all x,y:Unit. x = y","context":["Intro","UnitElim","Auto"],"tactic_proof":"Intro; Intro; UnitElim; Auto","source":"nuprl_synthetic/types"} -{"id":88019,"prover":"Nuprl","theorem":"func_ext","goal":"all A,B:Type, f,g:A->B. (all x:A. f(x) = g(x)) => f = g","context":["Intro","FunExt","Auto"],"tactic_proof":"Intro; FunExt; Auto","source":"nuprl_synthetic/types"} -{"id":88020,"prover":"Nuprl","theorem":"curry_uncurry","goal":"all A,B,C:Type, f:A*B->C. uncurry(curry(f)) = f","context":["Intro","FunExt","PairElim","Auto"],"tactic_proof":"Intro; FunExt; Intro; PairElim; Auto","source":"nuprl_synthetic/types"} -{"id":88021,"prover":"Nuprl","theorem":"dep_pair_eta","goal":"all A:Type, B:A->Type, p:(x:A * B(x)). p = ","context":["Intro","DPairElim","Auto"],"tactic_proof":"Intro; DPairElim; Auto","source":"nuprl_synthetic/types"} -{"id":88022,"prover":"Nuprl","theorem":"iso_nat_list_unit","goal":"all n:Nat. exists l:List(Unit). length(l) = n","context":["NatInd","Auto","Witness `cons(tt, l)`"],"tactic_proof":"NatInd; Auto; Witness `cons(tt, l)`; Auto","source":"nuprl_synthetic/types"} -{"id":88023,"prover":"Nuprl","theorem":"type_product_comm","goal":"all A,B:Type. A*B ~ B*A","context":["Intro","Iso","Lambda x. ","Lambda y. ","Auto"],"tactic_proof":"Intro; Iso; Lambda x. ; Lambda y. ; Auto","source":"nuprl_synthetic/types"} -{"id":88024,"prover":"Nuprl","theorem":"type_sum_comm","goal":"all A,B:Type. A+B ~ B+A","context":["Intro","Iso","DecideElim","Auto"],"tactic_proof":"Intro; Iso; DecideElim; Auto","source":"nuprl_synthetic/types"} -{"id":88025,"prover":"Nuprl","theorem":"append_nil","goal":"all A:Type, l:List(A). append(l, nil) = l","context":["ListInd","Auto"],"tactic_proof":"ListInd; Auto","source":"nuprl_synthetic/lists"} -{"id":88026,"prover":"Nuprl","theorem":"append_assoc","goal":"all A:Type, l1,l2,l3:List(A). append(append(l1,l2),l3) = append(l1,append(l2,l3))","context":["ListInd `l1`","Auto"],"tactic_proof":"ListInd `l1`; Auto","source":"nuprl_synthetic/lists"} -{"id":88027,"prover":"Nuprl","theorem":"length_append","goal":"all A:Type, l1,l2:List(A). length(append(l1,l2)) = length(l1) + length(l2)","context":["ListInd `l1`","Auto"],"tactic_proof":"ListInd `l1`; Auto","source":"nuprl_synthetic/lists"} -{"id":88028,"prover":"Nuprl","theorem":"map_id","goal":"all A:Type, l:List(A). map(id, l) = l","context":["ListInd","Auto"],"tactic_proof":"ListInd; Auto","source":"nuprl_synthetic/lists"} -{"id":88029,"prover":"Nuprl","theorem":"map_compose","goal":"all A,B,C:Type, f:B->C, g:A->B, l:List(A). map(f, map(g, l)) = map(compose(f,g), l)","context":["ListInd","Auto"],"tactic_proof":"ListInd; Auto","source":"nuprl_synthetic/lists"} -{"id":88030,"prover":"Nuprl","theorem":"reverse_reverse","goal":"all A:Type, l:List(A). reverse(reverse(l)) = l","context":["ListInd","Auto","Unfold `reverse`"],"tactic_proof":"ListInd; Auto; Unfold `reverse`; Auto","source":"nuprl_synthetic/lists"} -{"id":88031,"prover":"Nuprl","theorem":"length_reverse","goal":"all A:Type, l:List(A). length(reverse(l)) = length(l)","context":["ListInd","Auto"],"tactic_proof":"ListInd; Auto","source":"nuprl_synthetic/lists"} -{"id":88032,"prover":"Nuprl","theorem":"member_append","goal":"all A:Type, x:A, l1,l2:List(A). member(x, append(l1,l2)) <=> member(x,l1) or member(x,l2)","context":["ListInd `l1`","Auto","OrElim"],"tactic_proof":"ListInd `l1`; Auto; OrElim; Auto","source":"nuprl_synthetic/lists"} -{"id":88033,"prover":"Nuprl","theorem":"filter_length","goal":"all A:Type, p:A->Bool, l:List(A). length(filter(p, l)) <= length(l)","context":["ListInd","Auto","CaseAnalysis `p(hd)`"],"tactic_proof":"ListInd; Auto; CaseAnalysis `p(hd)`; Auto","source":"nuprl_synthetic/lists"} -{"id":88034,"prover":"Nuprl","theorem":"foldr_append","goal":"all A,B:Type, f:A->B->B, z:B, l1,l2:List(A). foldr(f, z, append(l1,l2)) = foldr(f, foldr(f,z,l2), l1)","context":["ListInd `l1`","Auto"],"tactic_proof":"ListInd `l1`; Auto","source":"nuprl_synthetic/lists"} -{"id":88035,"prover":"Nuprl","theorem":"modus_ponens","goal":"all P,Q:Prop. P => (P => Q) => Q","context":["Intro","Apply","Auto"],"tactic_proof":"Intro; Intro; Apply; Auto","source":"nuprl_synthetic/logic"} -{"id":88036,"prover":"Nuprl","theorem":"and_comm","goal":"all P,Q:Prop. P & Q => Q & P","context":["Intro","AndElim","Split","Auto"],"tactic_proof":"Intro; AndElim; Split; Auto","source":"nuprl_synthetic/logic"} -{"id":88037,"prover":"Nuprl","theorem":"or_comm","goal":"all P,Q:Prop. P or Q => Q or P","context":["Intro","OrElim","Right","Auto","Left"],"tactic_proof":"Intro; OrElim; [Right; Auto | Left; Auto]","source":"nuprl_synthetic/logic"} -{"id":88038,"prover":"Nuprl","theorem":"double_neg_elim","goal":"all P:Prop. ~~P => P","context":["Intro","ByContradiction","Auto"],"tactic_proof":"Intro; ByContradiction; Auto","source":"nuprl_synthetic/logic"} -{"id":88039,"prover":"Nuprl","theorem":"de_morgan_and","goal":"all P,Q:Prop. ~(P & Q) <=> (~P or ~Q)","context":["Split","Intro","ByContradiction","Auto","OrElim"],"tactic_proof":"Split; Intro; ByContradiction; Auto; Intro; OrElim; Auto","source":"nuprl_synthetic/logic"} -{"id":88040,"prover":"Nuprl","theorem":"de_morgan_or","goal":"all P,Q:Prop. ~(P or Q) <=> (~P & ~Q)","context":["Split","Intro","Apply","Left","Auto","Right","AndElim","OrElim"],"tactic_proof":"Split; Intro; Split; Intro; Apply; Left; Auto; Intro; Apply; Right; Auto; Intro; AndElim; OrElim; Auto","source":"nuprl_synthetic/logic"} -{"id":88041,"prover":"Nuprl","theorem":"contrapositive","goal":"all P,Q:Prop. (P => Q) => (~Q => ~P)","context":["Intro","Apply","Auto"],"tactic_proof":"Intro; Intro; Intro; Apply; Auto","source":"nuprl_synthetic/logic"} -{"id":88042,"prover":"Nuprl","theorem":"forall_implies_exists","goal":"all A:Type, P:A->Prop, a:A. (all x:A. P(x)) => exists x:A. P(x)","context":["Intro","Witness `a`","Apply","Auto"],"tactic_proof":"Intro; Intro; Witness `a`; Apply; Auto","source":"nuprl_synthetic/logic"} -{"id":88043,"prover":"Nuprl","theorem":"exists_not_forall_not","goal":"all A:Type, P:A->Prop. (exists x:A. P(x)) => ~(all x:A. ~P(x))","context":["Intro","ExistsElim","Apply","Auto"],"tactic_proof":"Intro; ExistsElim; Intro; Apply; Auto","source":"nuprl_synthetic/logic"} -{"id":88044,"prover":"Nuprl","theorem":"peirce","goal":"all P,Q:Prop. ((P => Q) => P) => P","context":["Intro","ByContradiction","Apply","Absurd","Auto"],"tactic_proof":"Intro; ByContradiction; Apply; Intro; Absurd; Auto","source":"nuprl_synthetic/logic"} -{"id":88045,"prover":"Nuprl","theorem":"nat_decidable_eq","goal":"all m,n:Nat. (m = n) or ~(m = n)","context":["NatInd `m`","NatInd `n`","Auto","CaseAnalysis"],"tactic_proof":"NatInd `m`; NatInd `n`; Auto; CaseAnalysis; Auto","source":"nuprl_synthetic/constructive"} -{"id":88046,"prover":"Nuprl","theorem":"markov_nat","goal":"all f:Nat->Bool. ~~(exists n:Nat. f(n) = true) => exists n:Nat. f(n) = true","context":["Intro","BoundedSearch","Auto"],"tactic_proof":"Intro; BoundedSearch; Auto","source":"nuprl_synthetic/constructive"} -{"id":88047,"prover":"Nuprl","theorem":"choice_nat","goal":"all R:Nat->Nat->Prop. (all n:Nat. exists m:Nat. R(n,m)) => exists f:Nat->Nat. all n:Nat. R(n, f(n))","context":["Intro","CountableChoice","Auto"],"tactic_proof":"Intro; CountableChoice; Auto","source":"nuprl_synthetic/constructive"} -{"id":88048,"prover":"Nuprl","theorem":"well_ordering_nat","goal":"all P:Nat->Prop. (exists n:Nat. P(n)) => exists m:Nat. P(m) & (all k:Nat. k < m => ~P(k))","context":["StrongInduction","Auto"],"tactic_proof":"StrongInduction; Auto","source":"nuprl_synthetic/constructive"} -{"id":88049,"prover":"Nuprl","theorem":"brouwer_continuity","goal":"all f:(Nat->Nat)->Nat. exists n:Nat. all a,b:Nat->Nat. (all i:Nat. i < n => a(i) = b(i)) => f(a) = f(b)","context":["Continuity","Auto"],"tactic_proof":"Continuity; Auto","source":"nuprl_synthetic/constructive"} -{"id":88050,"prover":"Nuprl","theorem":"church_rosser","goal":"all M,N,P:Term. reduces(M, N) => reduces(M, P) => exists Q:Term. reduces(N, Q) & reduces(P, Q)","context":["Induction","Diamond","Auto"],"tactic_proof":"Induction; Diamond; Auto","source":"nuprl_synthetic/constructive"} -{"id":88051,"prover":"Nuprl","theorem":"fan_theorem","goal":"all T:Tree. (all b:Branch. bar(T, b)) => exists n:Nat. uniform_bar(T, n)","context":["BarInduction","Auto"],"tactic_proof":"BarInduction; Auto","source":"nuprl_synthetic/constructive"} -{"id":88052,"prover":"Nuprl","theorem":"kripke_schema","goal":"all A:Prop. (A \\/ ~A) => decidable(A)","context":["Intro","OrElim","Auto"],"tactic_proof":"Intro; OrElim; Auto","source":"nuprl_synthetic/constructive"} -{"id":88053,"prover":"Nuprl","theorem":"set_ext","goal":"all A:Type, s1,s2:Set(A). (all x:A. x in s1 <=> x in s2) => s1 = s2","context":["Intro","SetExt","Auto"],"tactic_proof":"Intro; SetExt; Auto","source":"nuprl_synthetic/sets"} -{"id":88054,"prover":"Nuprl","theorem":"union_comm","goal":"all A:Type, s1,s2:Set(A). union(s1, s2) = union(s2, s1)","context":["SetExt","Auto"],"tactic_proof":"SetExt; Auto","source":"nuprl_synthetic/sets"} -{"id":88055,"prover":"Nuprl","theorem":"union_assoc","goal":"all A:Type, s1,s2,s3:Set(A). union(union(s1,s2),s3) = union(s1,union(s2,s3))","context":["SetExt","Auto"],"tactic_proof":"SetExt; Auto","source":"nuprl_synthetic/sets"} -{"id":88056,"prover":"Nuprl","theorem":"inter_comm","goal":"all A:Type, s1,s2:Set(A). intersect(s1, s2) = intersect(s2, s1)","context":["SetExt","Auto"],"tactic_proof":"SetExt; Auto","source":"nuprl_synthetic/sets"} -{"id":88057,"prover":"Nuprl","theorem":"distrib_union_inter","goal":"all A:Type, s1,s2,s3:Set(A). union(s1, intersect(s2, s3)) = intersect(union(s1,s2), union(s1,s3))","context":["SetExt","Auto"],"tactic_proof":"SetExt; Auto","source":"nuprl_synthetic/sets"} -{"id":88058,"prover":"Nuprl","theorem":"empty_subset","goal":"all A:Type, s:Set(A). subset(empty, s)","context":["Intro","ElimEmpty","Auto"],"tactic_proof":"Intro; ElimEmpty; Auto","source":"nuprl_synthetic/sets"} -{"id":88059,"prover":"Nuprl","theorem":"union_superset","goal":"all A:Type, s1,s2:Set(A). subset(s1, union(s1, s2))","context":["Intro","UnionElim","Auto"],"tactic_proof":"Intro; UnionElim; Auto","source":"nuprl_synthetic/sets"} -{"id":88060,"prover":"Nuprl","theorem":"power_set_monotone","goal":"all A:Type, s1,s2:Set(A). subset(s1, s2) => subset(pow(s1), pow(s2))","context":["Intro","Apply","Auto"],"tactic_proof":"Intro; Intro; Apply; Auto","source":"nuprl_synthetic/sets"} -{"id":88061,"prover":"Nuprl","theorem":"finite_union","goal":"all A:Type, s1,s2:FiniteSet(A). finite(union(s1, s2))","context":["Intro","FiniteUnion","Auto"],"tactic_proof":"Intro; FiniteUnion; Auto","source":"nuprl_synthetic/sets"} -{"id":88062,"prover":"Nuprl","theorem":"cardinal_union","goal":"all A:Type, s1,s2:FiniteSet(A). card(union(s1,s2)) = card(s1) + card(s2) - card(intersect(s1,s2))","context":["InclusionExclusion","Auto"],"tactic_proof":"InclusionExclusion; Auto","source":"nuprl_synthetic/sets"} -{"id":88063,"prover":"Nuprl","theorem":"refl_closure","goal":"all A:Type, R:A->A->Prop, x:A. refl_trans_closure(R)(x, x)","context":["Intro","RTC_Refl","Auto"],"tactic_proof":"Intro; RTC_Refl; Auto","source":"nuprl_synthetic/relations"} -{"id":88064,"prover":"Nuprl","theorem":"trans_composition","goal":"all A:Type, R:A->A->Prop, x,y,z:A. trans_closure(R)(x,y) => trans_closure(R)(y,z) => trans_closure(R)(x,z)","context":["Intro","Induction","Auto"],"tactic_proof":"Intro; Induction; Auto","source":"nuprl_synthetic/relations"} -{"id":88065,"prover":"Nuprl","theorem":"equiv_sym","goal":"all A:Type, R:A->A->Prop, x,y:A. equivalence(R) => R(x, y) => R(y, x)","context":["Intro","ApplySym","Auto"],"tactic_proof":"Intro; Intro; ApplySym; Auto","source":"nuprl_synthetic/relations"} -{"id":88066,"prover":"Nuprl","theorem":"well_founded_induction","goal":"all A:Type, R:A->A->Prop. well_founded(R) => all P:A->Prop. (all x:A. (all y:A. R(y,x) => P(y)) => P(x)) => all x:A. P(x)","context":["Intro","WFInduction","Auto"],"tactic_proof":"Intro; WFInduction; Auto","source":"nuprl_synthetic/relations"} -{"id":88067,"prover":"Nuprl","theorem":"partial_order_antisym","goal":"all A:Type, R:A->A->Prop, x,y:A. partial_order(R) => R(x,y) => R(y,x) => x = y","context":["Intro","ApplyAntisym","Auto"],"tactic_proof":"Intro; ApplyAntisym; Auto","source":"nuprl_synthetic/relations"} -{"id":88068,"prover":"Nuprl","theorem":"total_order_trichotomy","goal":"all A:Type, R:A->A->Prop, x,y:A. total_order(R) => R(x,y) \\/ x = y \\/ R(y,x)","context":["Intro","Trichotomy","Auto"],"tactic_proof":"Intro; Trichotomy; Auto","source":"nuprl_synthetic/relations"} -{"id":88069,"prover":"Nuprl","theorem":"graph_path_compose","goal":"all V:Type, E:V->V->Prop, x,y,z:V. path(E)(x,y) => path(E)(y,z) => path(E)(x,z)","context":["Induction","Auto"],"tactic_proof":"Induction; Auto","source":"nuprl_synthetic/relations"} -{"id":88070,"prover":"Nuprl","theorem":"converse_relation","goal":"all A,B:Type, R:A->B->Prop, x:A, y:B. R(x,y) <=> converse(R)(y,x)","context":["Intro","Split","Auto"],"tactic_proof":"Intro; Split; Auto","source":"nuprl_synthetic/relations"} -{"id":88071,"prover":"Nuprl","theorem":"euclid_lemma","goal":"all p:Prime, a,b:Nat. divides(p, a*b) => divides(p, a) or divides(p, b)","context":["Intro","CaseGCD","Auto"],"tactic_proof":"Intro; CaseGCD; Auto","source":"nuprl_synthetic/number_theory"} -{"id":88072,"prover":"Nuprl","theorem":"fundamental_arith","goal":"all n:Nat. n >= 2 => exists! ps:List(Prime). product(ps) = n","context":["StrongInduction","Auto"],"tactic_proof":"StrongInduction; Auto","source":"nuprl_synthetic/number_theory"} -{"id":88073,"prover":"Nuprl","theorem":"bezout","goal":"all a,b:Nat. a > 0 \\/ b > 0 => exists x,y:Int. a*x + b*y = gcd(a,b)","context":["Intro","ExtendedEuclid","Auto"],"tactic_proof":"Intro; ExtendedEuclid; Auto","source":"nuprl_synthetic/number_theory"} -{"id":88074,"prover":"Nuprl","theorem":"infinitude_primes","goal":"all n:Nat. exists p:Prime. p > n","context":["Intro","Witness `factorial(n)+1`","Auto"],"tactic_proof":"Intro; Witness `factorial(n)+1`; Auto","source":"nuprl_synthetic/number_theory"} -{"id":88075,"prover":"Nuprl","theorem":"wilson_theorem","goal":"all p:Prime. (factorial(p-1) + 1) mod p = 0","context":["Intro","ModArith","Auto"],"tactic_proof":"Intro; ModArith; Auto","source":"nuprl_synthetic/number_theory"} -{"id":88076,"prover":"Nuprl","theorem":"fermat_little","goal":"all p:Prime, a:Nat. coprime(a, p) => (a^(p-1)) mod p = 1","context":["Intro","GroupOrder","Auto"],"tactic_proof":"Intro; GroupOrder; Auto","source":"nuprl_synthetic/number_theory"} -{"id":88077,"prover":"Nuprl","theorem":"chinese_remainder","goal":"all m,n:Nat. coprime(m,n) => all a,b:Int. exists x:Int. (x mod m = a) & (x mod n = b)","context":["Intro","CRT","Auto"],"tactic_proof":"Intro; Intro; CRT; Auto","source":"nuprl_synthetic/number_theory"} -{"id":88078,"prover":"Nuprl","theorem":"sum_of_squares","goal":"all n:Nat. (exists a,b:Nat. n = a*a + b*b) <=> all p:Prime. p `divides` n & p mod 4 = 3 => even(mult(p, n))","context":["Classify","Auto"],"tactic_proof":"Classify; Auto","source":"nuprl_synthetic/number_theory"} -{"id":88079,"prover":"Nuprl","theorem":"pigeon_hole","goal":"all n,m:Nat, f:Fin(n)->Fin(m). n > m => exists i,j:Fin(n). i <> j & f(i) = f(j)","context":["Intro","PHP","Auto"],"tactic_proof":"Intro; PHP; Auto","source":"nuprl_synthetic/number_theory"} -{"id":88080,"prover":"Nuprl","theorem":"lim_sum","goal":"all f,g:Nat->Real, a,b:Real. lim(f) = a => lim(g) = b => lim(fun n. f(n)+g(n)) = a+b","context":["Intro","LimitArith","Auto"],"tactic_proof":"Intro; LimitArith; Auto","source":"nuprl_synthetic/real_analysis"} -{"id":88081,"prover":"Nuprl","theorem":"lim_prod","goal":"all f,g:Nat->Real, a,b:Real. lim(f) = a => lim(g) = b => lim(fun n. f(n)*g(n)) = a*b","context":["Intro","LimitArith","Auto"],"tactic_proof":"Intro; LimitArith; Auto","source":"nuprl_synthetic/real_analysis"} -{"id":88082,"prover":"Nuprl","theorem":"squeeze","goal":"all f,g,h:Nat->Real. (all n:Nat. f(n) <= g(n) <= h(n)) => lim(f) = lim(h) => lim(g) = lim(f)","context":["Intro","Squeeze","Auto"],"tactic_proof":"Intro; Squeeze; Auto","source":"nuprl_synthetic/real_analysis"} -{"id":88083,"prover":"Nuprl","theorem":"continuous_compose","goal":"all f,g:Real->Real. continuous(f) => continuous(g) => continuous(compose(f, g))","context":["Intro","EpsilonDelta","Auto"],"tactic_proof":"Intro; EpsilonDelta; Auto","source":"nuprl_synthetic/real_analysis"} -{"id":88084,"prover":"Nuprl","theorem":"ivt","goal":"all f:Real->Real, a,b:Real, y:Real. continuous(f) => f(a) <= y <= f(b) => exists c:Real. a <= c <= b & f(c) = y","context":["Intro","Bisection","Auto"],"tactic_proof":"Intro; Bisection; Auto","source":"nuprl_synthetic/real_analysis"} -{"id":88085,"prover":"Nuprl","theorem":"mvt","goal":"all f:Real->Real, a,b:Real. differentiable(f) => a < b => exists c:Real. a < c < b & derivative(f)(c) = (f(b)-f(a))/(b-a)","context":["Intro","Rolle","Auto"],"tactic_proof":"Intro; Rolle; Auto","source":"nuprl_synthetic/real_analysis"} -{"id":88086,"prover":"Nuprl","theorem":"cauchy_complete","goal":"all s:Nat->Real. cauchy(s) => exists L:Real. lim(s) = L","context":["Intro","CompletenessAxiom","Auto"],"tactic_proof":"Intro; CompletenessAxiom; Auto","source":"nuprl_synthetic/real_analysis"} -{"id":88087,"prover":"Nuprl","theorem":"compact_attains","goal":"all f:Real->Real, K:Set(Real). compact(K) => continuous(f) => exists m,M:Real. m in f(K) & M in f(K) & all y in f(K). m <= y <= M","context":["Intro","ExtremeValue","Auto"],"tactic_proof":"Intro; Intro; ExtremeValue; Auto","source":"nuprl_synthetic/real_analysis"} -{"id":88088,"prover":"Nuprl","theorem":"halting_undecidable","goal":"~exists H:(Prog->Input->Bool). all p:Prog, x:Input. H(p, x) = true <=> halts(p, x)","context":["Diagonalization","Auto"],"tactic_proof":"Diagonalization; Auto","source":"nuprl_synthetic/computability"} -{"id":88089,"prover":"Nuprl","theorem":"rice_theorem","goal":"all P:(Prog->Prop). nontrivial(P) => ~decidable(P)","context":["Intro","Reduction","Auto"],"tactic_proof":"Intro; Reduction; Auto","source":"nuprl_synthetic/computability"} -{"id":88090,"prover":"Nuprl","theorem":"recursion_theorem","goal":"all f:Prog->Prog. exists e:Prog. equal_programs(e, f(e))","context":["KleeneRecursion","Auto"],"tactic_proof":"KleeneRecursion; Auto","source":"nuprl_synthetic/computability"} -{"id":88091,"prover":"Nuprl","theorem":"smn_theorem","goal":"all n,m:Nat, f:Prog. exists s:Prog. all x,y:Input. run(f, pair(x,y)) = run(run(s, x), y)","context":["Intro","SMN","Auto"],"tactic_proof":"Intro; Intro; SMN; Auto","source":"nuprl_synthetic/computability"} -{"id":88092,"prover":"Nuprl","theorem":"kleene_normal","goal":"all f:PartialFn. exists e,U:Prog. all x:Input. f(x) = run(U, pair(e, x))","context":["Intro","NormalForm","Auto"],"tactic_proof":"Intro; NormalForm; Auto","source":"nuprl_synthetic/computability"} -{"id":88093,"prover":"Nuprl","theorem":"church_turing_lambda","goal":"all f:ComputableFn. exists t:Term. reduces_to_numeral(t(numeral(x)), numeral(f(x)))","context":["Intro","Encode","Auto"],"tactic_proof":"Intro; Encode; Auto","source":"nuprl_synthetic/computability"} -{"id":88094,"prover":"Nuprl","theorem":"cat_comp_assoc","goal":"all C:Cat, f:Hom(a,b), g:Hom(b,c), h:Hom(c,d). comp(comp(h,g),f) = comp(h,comp(g,f))","context":["Intro","CatAssoc","Auto"],"tactic_proof":"Intro; CatAssoc; Auto","source":"nuprl_synthetic/category_theory"} -{"id":88095,"prover":"Nuprl","theorem":"cat_id_left","goal":"all C:Cat, f:Hom(a,b). comp(id(b), f) = f","context":["Intro","CatIdLeft","Auto"],"tactic_proof":"Intro; CatIdLeft; Auto","source":"nuprl_synthetic/category_theory"} -{"id":88096,"prover":"Nuprl","theorem":"cat_id_right","goal":"all C:Cat, f:Hom(a,b). comp(f, id(a)) = f","context":["Intro","CatIdRight","Auto"],"tactic_proof":"Intro; CatIdRight; Auto","source":"nuprl_synthetic/category_theory"} -{"id":88097,"prover":"Nuprl","theorem":"functor_comp","goal":"all F:Functor, f:Hom(a,b), g:Hom(b,c). Fmap(comp(g,f)) = comp(Fmap(g), Fmap(f))","context":["Intro","FunctorLaw","Auto"],"tactic_proof":"Intro; FunctorLaw; Auto","source":"nuprl_synthetic/category_theory"} -{"id":88098,"prover":"Nuprl","theorem":"functor_id","goal":"all F:Functor, a:Obj. Fmap(id(a)) = id(Fobj(a))","context":["Intro","FunctorIdLaw","Auto"],"tactic_proof":"Intro; FunctorIdLaw; Auto","source":"nuprl_synthetic/category_theory"} -{"id":88099,"prover":"Nuprl","theorem":"natural_trans","goal":"all F,G:Functor, eta:NatTrans(F,G), f:Hom(a,b). comp(eta(b), Fmap_F(f)) = comp(Fmap_G(f), eta(a))","context":["Intro","Naturality","Auto"],"tactic_proof":"Intro; Naturality; Auto","source":"nuprl_synthetic/category_theory"} -{"id":88100,"prover":"Nuprl","theorem":"iso_compose","goal":"all C:Cat, f:Hom(a,b), g:Hom(b,a). comp(g, f) = id(a) => comp(f, g) = id(b) => isomorphism(f)","context":["Intro","Isomorphism","Auto"],"tactic_proof":"Intro; Isomorphism; Auto","source":"nuprl_synthetic/category_theory"} -{"id":88101,"prover":"Nuprl","theorem":"product_universal","goal":"all C:Cat, p:Obj, f:Hom(p,a), g:Hom(p,b). exists! h:Hom(p, prod(a,b)). comp(pi1, h) = f & comp(pi2, h) = g","context":["Intro","Universal","Auto"],"tactic_proof":"Intro; Universal; Auto","source":"nuprl_synthetic/category_theory"} -{"id":88102,"prover":"Nuprl","theorem":"open_union","goal":"all X:TopSpace, U,V:Open(X). open(union(U, V))","context":["Intro","OpenAxiom","Auto"],"tactic_proof":"Intro; OpenAxiom; Auto","source":"nuprl_synthetic/topology"} -{"id":88103,"prover":"Nuprl","theorem":"open_finite_inter","goal":"all X:TopSpace, U,V:Open(X). open(intersect(U, V))","context":["Intro","OpenAxiom","Auto"],"tactic_proof":"Intro; OpenAxiom; Auto","source":"nuprl_synthetic/topology"} -{"id":88104,"prover":"Nuprl","theorem":"continuous_compose","goal":"all X,Y,Z:TopSpace, f:X->Y, g:Y->Z. continuous(f) => continuous(g) => continuous(compose(g, f))","context":["Intro","Continuous","Auto"],"tactic_proof":"Intro; Continuous; Auto","source":"nuprl_synthetic/topology"} -{"id":88105,"prover":"Nuprl","theorem":"compact_closed","goal":"all X:TopSpace, K:Subspace(X). compact(K) => hausdorff(X) => closed(K)","context":["Intro","Compact","Auto"],"tactic_proof":"Intro; Compact; Auto","source":"nuprl_synthetic/topology"} -{"id":88106,"prover":"Nuprl","theorem":"connected_image","goal":"all X,Y:TopSpace, f:X->Y. continuous(f) => connected(X) => connected(image(f))","context":["Intro","Connected","Auto"],"tactic_proof":"Intro; Connected; Auto","source":"nuprl_synthetic/topology"} -{"id":88107,"prover":"Nuprl","theorem":"hausdorff_limit","goal":"all X:TopSpace, s:Nat->X, L1,L2:X. hausdorff(X) => lim(s) = L1 => lim(s) = L2 => L1 = L2","context":["Intro","Hausdorff","Auto"],"tactic_proof":"Intro; Hausdorff; Auto","source":"nuprl_synthetic/topology"} -{"id":88108,"prover":"Nuprl","theorem":"homeomorphism","goal":"all X,Y:TopSpace, f:X->Y. continuous(f) => continuous(inverse(f)) => homeomorphism(f)","context":["Intro","Homeomorphism","Auto"],"tactic_proof":"Intro; Homeomorphism; Auto","source":"nuprl_synthetic/topology"} -{"id":88109,"prover":"Nuprl","theorem":"group_inv_unique","goal":"all G:Group, a,b,c:G. op(a,b) = e => op(a,c) = e => b = c","context":["Intro","Cancel","Auto"],"tactic_proof":"Intro; Cancel; Auto","source":"nuprl_synthetic/algebra"} -{"id":88110,"prover":"Nuprl","theorem":"subgroup_closed","goal":"all G:Group, H:Subgroup(G), a,b:H. op(a, b) in H","context":["Intro","SubgroupAxiom","Auto"],"tactic_proof":"Intro; SubgroupAxiom; Auto","source":"nuprl_synthetic/algebra"} -{"id":88111,"prover":"Nuprl","theorem":"lagrange","goal":"all G:FinGroup, H:Subgroup(G). divides(order(H), order(G))","context":["Intro","Lagrange","Auto"],"tactic_proof":"Intro; Lagrange; Auto","source":"nuprl_synthetic/algebra"} -{"id":88112,"prover":"Nuprl","theorem":"homomorphism_kernel","goal":"all G,H:Group, f:Homomorphism(G, H). subgroup(kernel(f), G)","context":["Intro","KernelAxiom","Auto"],"tactic_proof":"Intro; KernelAxiom; Auto","source":"nuprl_synthetic/algebra"} -{"id":88113,"prover":"Nuprl","theorem":"ring_add_group","goal":"all R:Ring. group(R, +)","context":["Intro","RingAxiom","Auto"],"tactic_proof":"Intro; RingAxiom; Auto","source":"nuprl_synthetic/algebra"} -{"id":88114,"prover":"Nuprl","theorem":"ideal_closed","goal":"all R:Ring, I:Ideal(R), a:R, b:I. op(a, b) in I","context":["Intro","IdealAxiom","Auto"],"tactic_proof":"Intro; IdealAxiom; Auto","source":"nuprl_synthetic/algebra"} -{"id":88115,"prover":"Nuprl","theorem":"field_no_zero_div","goal":"all F:Field, a,b:F. a*b = 0 => a = 0 or b = 0","context":["Intro","FieldAxiom","Auto"],"tactic_proof":"Intro; FieldAxiom; Auto","source":"nuprl_synthetic/algebra"} -{"id":88116,"prover":"Nuprl","theorem":"vector_space_sum","goal":"all V:VectorSpace, v,w:V. v + w = w + v","context":["Intro","VectorAxiom","Auto"],"tactic_proof":"Intro; VectorAxiom; Auto","source":"nuprl_synthetic/algebra"} -{"id":88117,"prover":"Nuprl","theorem":"prob_nonneg","goal":"all P:ProbMeasure, A:Event. P(A) >= 0","context":["Intro","ProbAxiom","Auto"],"tactic_proof":"Intro; ProbAxiom; Auto","source":"nuprl_synthetic/probability"} -{"id":88118,"prover":"Nuprl","theorem":"prob_total","goal":"all P:ProbMeasure. P(universe) = 1","context":["Intro","ProbAxiom","Auto"],"tactic_proof":"Intro; ProbAxiom; Auto","source":"nuprl_synthetic/probability"} -{"id":88119,"prover":"Nuprl","theorem":"prob_additivity","goal":"all P:ProbMeasure, A,B:Event. disjoint(A, B) => P(union(A, B)) = P(A) + P(B)","context":["Intro","Additivity","Auto"],"tactic_proof":"Intro; Additivity; Auto","source":"nuprl_synthetic/probability"} -{"id":88120,"prover":"Nuprl","theorem":"bayes_rule","goal":"all P:ProbMeasure, A,B:Event. P(B) > 0 => P(A | B) = P(A & B) / P(B)","context":["Intro","BayesDef","Auto"],"tactic_proof":"Intro; BayesDef; Auto","source":"nuprl_synthetic/probability"} -{"id":88121,"prover":"Nuprl","theorem":"conditional_indep","goal":"all P:ProbMeasure, A,B,C:Event. indep(A, B | C) <=> P(A & B | C) = P(A | C) * P(B | C)","context":["Intro","Split","Auto"],"tactic_proof":"Intro; Split; Auto","source":"nuprl_synthetic/probability"} -{"id":88122,"prover":"Nuprl","theorem":"markov_ineq","goal":"all X:RandomVar, a:PosReal. P(X >= a) <= E(X) / a","context":["Intro","Markov","Auto"],"tactic_proof":"Intro; Markov; Auto","source":"nuprl_synthetic/probability"} -{"id":88123,"prover":"Nuprl","theorem":"expectation_linear","goal":"all X,Y:RandomVar, a,b:Real. E(a*X + b*Y) = a*E(X) + b*E(Y)","context":["Intro","Linearity","Auto"],"tactic_proof":"Intro; Linearity; Auto","source":"nuprl_synthetic/probability"} -{"id":88124,"prover":"Nuprl","theorem":"variance_nonneg","goal":"all X:RandomVar. var(X) >= 0","context":["Intro","Variance","Auto"],"tactic_proof":"Intro; Variance; Auto","source":"nuprl_synthetic/probability"} -{"id":88125,"prover":"Nuprl","theorem":"bishop_real_approx","goal":"all x:Real, n:PosInt. exists q:Rational. abs(x - q) < 1/n","context":["Intro","ConstructReal","Auto"],"tactic_proof":"Intro; ConstructReal; Auto","source":"nuprl_synthetic/bishop_analysis"} -{"id":88126,"prover":"Nuprl","theorem":"bishop_seq_modulus","goal":"all s:Nat->Real, eps:PosReal. cauchy(s) => exists M:Nat. all m,n:Nat. m >= M => n >= M => abs(s(m) - s(n)) < eps","context":["Intro","ModulusCauchy","Auto"],"tactic_proof":"Intro; Intro; ModulusCauchy; Auto","source":"nuprl_synthetic/bishop_analysis"} -{"id":88127,"prover":"Nuprl","theorem":"bishop_cont_uniform","goal":"all f:Real->Real, K:CompactInterval. continuous(f) => uniformly_continuous_on(f, K)","context":["Intro","HeineCantor","Auto"],"tactic_proof":"Intro; Intro; HeineCantor; Auto","source":"nuprl_synthetic/bishop_analysis"} -{"id":88128,"prover":"Nuprl","theorem":"bishop_rational_dense","goal":"all a,b:Real. a < b => exists q:Rational. a < q < b","context":["Intro","RationalDensity","Auto"],"tactic_proof":"Intro; RationalDensity; Auto","source":"nuprl_synthetic/bishop_analysis"} -{"id":88129,"prover":"Nuprl","theorem":"bishop_sqrt_exists","goal":"all x:NonNegReal. exists y:NonNegReal. y*y = x","context":["Intro","Newton","Auto"],"tactic_proof":"Intro; Newton; Auto","source":"nuprl_synthetic/bishop_analysis"} -{"id":88130,"prover":"Nuprl","theorem":"cut_elim_nuprl","goal":"all A,B. |- A -> (A |- B) -> |- B","context":["Intros","CutAdmissible","Auto"],"tactic_proof":"Intros; CutAdmissible; Auto","source":"nuprl_synthetic/proof_theory"} -{"id":88131,"prover":"Nuprl","theorem":"proof_identity","goal":"all A:Prop. |- A -> A","context":["Intro","Axiom","Auto"],"tactic_proof":"Intro; Axiom; Auto","source":"nuprl_synthetic/proof_theory"} -{"id":88132,"prover":"Nuprl","theorem":"proof_weakening","goal":"all A,B:Prop. |- B => (A |- B)","context":["Intros","Weakening","Auto"],"tactic_proof":"Intros; Weakening; Auto","source":"nuprl_synthetic/proof_theory"} -{"id":88133,"prover":"Nuprl","theorem":"subtype_refl","goal":"all T:Type. T subtype T","context":["Intro","SubtypeRefl","Auto"],"tactic_proof":"Intro; SubtypeRefl; Auto","source":"nuprl_synthetic/proof_theory"} -{"id":88134,"prover":"Nuprl","theorem":"subtype_trans","goal":"all T1,T2,T3:Type. T1 subtype T2 => T2 subtype T3 => T1 subtype T3","context":["Intros","SubtypeTrans","Auto"],"tactic_proof":"Intros; SubtypeTrans; Auto","source":"nuprl_synthetic/proof_theory"} -{"id":88135,"prover":"Nuprl","theorem":"equality_symmetry","goal":"all A:Type, x,y:A. x = y => y = x","context":["Intros","EqSym","Auto"],"tactic_proof":"Intros; EqSym; Auto","source":"nuprl_synthetic/proof_theory"} -{"id":88136,"prover":"Nuprl","theorem":"equality_trans","goal":"all A:Type, x,y,z:A. x = y => y = z => x = z","context":["Intros","EqTrans","Auto"],"tactic_proof":"Intros; EqTrans; Auto","source":"nuprl_synthetic/proof_theory"} -{"id":88137,"prover":"Nuprl","theorem":"entropy_nonneg","goal":"all P:ProbDist. entropy(P) >= 0","context":["Intro","EntropyDef","Auto"],"tactic_proof":"Intro; EntropyDef; Auto","source":"nuprl_synthetic/information"} -{"id":88138,"prover":"Nuprl","theorem":"entropy_uniform_max","goal":"all n:PosNat, P:ProbDist(Fin(n)). entropy(P) <= log(n)","context":["Intro","MaxEntropy","Auto"],"tactic_proof":"Intro; Intro; MaxEntropy; Auto","source":"nuprl_synthetic/information"} -{"id":88139,"prover":"Nuprl","theorem":"mutual_info_nonneg","goal":"all X,Y:RandomVar. I(X; Y) >= 0","context":["Intro","MIDef","Auto"],"tactic_proof":"Intro; MIDef; Auto","source":"nuprl_synthetic/information"} -{"id":88140,"prover":"Nuprl","theorem":"chain_rule_entropy","goal":"all X,Y:RandomVar. H(X, Y) = H(X) + H(Y | X)","context":["Intro","ChainRule","Auto"],"tactic_proof":"Intro; ChainRule; Auto","source":"nuprl_synthetic/information"} -{"id":88141,"prover":"Nuprl","theorem":"kraft_inequality","goal":"all C:PrefixCode. sum(c in C, 2^(-length(c))) <= 1","context":["Intro","Kraft","Auto"],"tactic_proof":"Intro; Kraft; Auto","source":"nuprl_synthetic/information"} -{"id":88142,"prover":"Nuprl","theorem":"source_coding","goal":"all X:RandomVar, eps:PosReal. exists n:PosNat, C:Code. expected_length(C(X^n)) / n <= H(X) + eps","context":["Intro","ShannonSource","Auto"],"tactic_proof":"Intro; ShannonSource; Auto","source":"nuprl_synthetic/information"} -{"id":88143,"prover":"Nuprl","theorem":"quotient_class","goal":"all A:Type, R:Equiv(A), x,y:A. R(x,y) => [x]_R = [y]_R","context":["Intros","QuotientEq","Auto"],"tactic_proof":"Intros; QuotientEq; Auto","source":"nuprl_synthetic/quotient_types"} -{"id":88144,"prover":"Nuprl","theorem":"quotient_lift","goal":"all A,B:Type, R:Equiv(A), f:A->B. (all x,y:A. R(x,y) => f(x) = f(y)) => A/R -> B","context":["Intros","QuotientLift","Auto"],"tactic_proof":"Intros; QuotientLift; Auto","source":"nuprl_synthetic/quotient_types"} -{"id":88145,"prover":"Nuprl","theorem":"nat_quot_modp","goal":"all p:PosNat. Nat/cong(p) ~ Fin(p)","context":["Intro","Bijection","Auto"],"tactic_proof":"Intro; Bijection; Auto","source":"nuprl_synthetic/quotient_types"} -{"id":88146,"prover":"Nuprl","theorem":"partition_quotient","goal":"all A:Type, R:Equiv(A). partition(A, R) <=> A/R","context":["Intro","Partition","Auto"],"tactic_proof":"Intro; Partition; Auto","source":"nuprl_synthetic/quotient_types"} -{"id":88147,"prover":"Nuprl","theorem":"setoid_morphism","goal":"all A,B:Setoid, f:A->B. morphism(f) <=> (all x,y:A. eq_A(x,y) => eq_B(f(x), f(y)))","context":["Intro","Morphism","Auto"],"tactic_proof":"Intro; Morphism; Auto","source":"nuprl_synthetic/quotient_types"} -{"id":88148,"prover":"Nuprl","theorem":"w_type","goal":"all A:Type, B:A->Type. W(A, B) : Type","context":["Intros","WType","Auto"],"tactic_proof":"Intros; WType; Auto","source":"nuprl_synthetic/w_types"} -{"id":88149,"prover":"Nuprl","theorem":"w_induction","goal":"all A:Type, B:A->Type, P:W(A,B)->Prop. (all a:A, f:B(a)->W(A,B). (all b:B(a). P(f(b))) => P(sup(a, f))) => all w:W(A,B). P(w)","context":["Intros","WInduction","Auto"],"tactic_proof":"Intros; WInduction; Auto","source":"nuprl_synthetic/w_types"} -{"id":88150,"prover":"Nuprl","theorem":"w_nat_iso","goal":"Nat ~ W(Bool, lambda b. if b then Unit else Empty)","context":["Intro","Bijection","Auto"],"tactic_proof":"Intro; Bijection; Auto","source":"nuprl_synthetic/w_types"} -{"id":88151,"prover":"Nuprl","theorem":"w_list_iso","goal":"all A:Type. List(A) ~ W(1 + A, lambda s. match s with inl _ => Empty | inr _ => Unit)","context":["Intro","Bijection","Auto"],"tactic_proof":"Intro; Bijection; Auto","source":"nuprl_synthetic/w_types"} +{"prover":"Nuprl","tactic_proof":"Auto","source":"nuprl_synthetic/arithmetic","theorem":"add_comm","id":88000,"goal":"all x,y:Int. (x + y) = (y + x)","context":["Auto"]} +{"prover":"Nuprl","tactic_proof":"Auto","source":"nuprl_synthetic/arithmetic","theorem":"add_assoc","id":88001,"goal":"all x,y,z:Int. ((x + y) + z) = (x + (y + z))","context":["Auto"]} +{"prover":"Nuprl","tactic_proof":"Auto","source":"nuprl_synthetic/arithmetic","theorem":"mul_comm","id":88002,"goal":"all x,y:Int. (x * y) = (y * x)","context":["Auto"]} +{"prover":"Nuprl","tactic_proof":"Auto","source":"nuprl_synthetic/arithmetic","theorem":"mul_assoc","id":88003,"goal":"all x,y,z:Int. ((x * y) * z) = (x * (y * z))","context":["Auto"]} +{"prover":"Nuprl","tactic_proof":"Auto","source":"nuprl_synthetic/arithmetic","theorem":"distrib_left","id":88004,"goal":"all x,y,z:Int. (x * (y + z)) = ((x * y) + (x * z))","context":["Auto"]} +{"prover":"Nuprl","tactic_proof":"Auto","source":"nuprl_synthetic/arithmetic","theorem":"add_zero","id":88005,"goal":"all x:Int. (x + 0) = x","context":["Auto"]} +{"prover":"Nuprl","tactic_proof":"Auto","source":"nuprl_synthetic/arithmetic","theorem":"mul_one","id":88006,"goal":"all x:Int. (x * 1) = x","context":["Auto"]} +{"prover":"Nuprl","tactic_proof":"Auto","source":"nuprl_synthetic/arithmetic","theorem":"add_inverse","id":88007,"goal":"all x:Int. (x + (-x)) = 0","context":["Auto"]} +{"prover":"Nuprl","tactic_proof":"Intro; Intro; NatInd; Auto","source":"nuprl_synthetic/arithmetic","theorem":"nat_induction","id":88008,"goal":"all P:(Nat -> Prop). P(0) => (all n:Nat. P(n) => P(n+1)) => all n:Nat. P(n)","context":["Intro","NatInd","Auto"]} +{"prover":"Nuprl","tactic_proof":"Auto","source":"nuprl_synthetic/arithmetic","theorem":"div_mod","id":88009,"goal":"all a:Int, b:PosInt. a = (b * (a / b)) + (a mod b)","context":["Auto"]} +{"prover":"Nuprl","tactic_proof":"CaseAnalysis `x >= 0`; Auto","source":"nuprl_synthetic/arithmetic","theorem":"abs_nonneg","id":88010,"goal":"all x:Int. 0 <= |x|","context":["CaseAnalysis `x >= 0`","Auto"]} +{"prover":"Nuprl","tactic_proof":"CaseAnalysis `x >= 0`; CaseAnalysis `y >= 0`; Auto","source":"nuprl_synthetic/arithmetic","theorem":"triangle_ineq","id":88011,"goal":"all x,y:Int. |x + y| <= |x| + |y|","context":["CaseAnalysis `x >= 0`","CaseAnalysis `y >= 0`","Auto"]} +{"prover":"Nuprl","tactic_proof":"NatInd; Auto; OrElim; Auto","source":"nuprl_synthetic/arithmetic","theorem":"even_or_odd","id":88012,"goal":"all n:Nat. (exists k:Nat. n = 2*k) or (exists k:Nat. n = 2*k + 1)","context":["NatInd","Auto","OrElim"]} +{"prover":"Nuprl","tactic_proof":"Unfold `gcd`; NatInd; Auto","source":"nuprl_synthetic/arithmetic","theorem":"gcd_divides","id":88013,"goal":"all a,b:PosInt. divides(gcd(a,b), a) & divides(gcd(a,b), b)","context":["Unfold `gcd`","NatInd","Auto"]} +{"prover":"Nuprl","tactic_proof":"StrongInduction; Auto","source":"nuprl_synthetic/arithmetic","theorem":"prime_factorization","id":88014,"goal":"all n:Nat. n >= 2 => exists ps:List(PosInt). all p in ps. prime(p) & product(ps) = n","context":["StrongInduction","Auto"]} +{"prover":"Nuprl","tactic_proof":"Intro; PairElim; Auto","source":"nuprl_synthetic/types","theorem":"pair_eta","id":88015,"goal":"all A,B:Type, p:A*B. p = ","context":["Intro","PairElim","Auto"]} +{"prover":"Nuprl","tactic_proof":"Intro; Intro; Intro; DecideElim; Auto","source":"nuprl_synthetic/types","theorem":"sum_elim","id":88016,"goal":"all A,B:Type, C:Type. (A -> C) -> (B -> C) -> (A + B) -> C","context":["Intro","DecideElim","Auto"]} +{"prover":"Nuprl","tactic_proof":"Intro; VoidElim; Auto","source":"nuprl_synthetic/types","theorem":"void_elim","id":88017,"goal":"all A:Type. Void -> A","context":["Intro","VoidElim","Auto"]} +{"prover":"Nuprl","tactic_proof":"Intro; Intro; UnitElim; Auto","source":"nuprl_synthetic/types","theorem":"unit_unique","id":88018,"goal":"all x,y:Unit. x = y","context":["Intro","UnitElim","Auto"]} +{"prover":"Nuprl","tactic_proof":"Intro; FunExt; Auto","source":"nuprl_synthetic/types","theorem":"func_ext","id":88019,"goal":"all A,B:Type, f,g:A->B. (all x:A. f(x) = g(x)) => f = g","context":["Intro","FunExt","Auto"]} +{"prover":"Nuprl","tactic_proof":"Intro; FunExt; Intro; PairElim; Auto","source":"nuprl_synthetic/types","theorem":"curry_uncurry","id":88020,"goal":"all A,B,C:Type, f:A*B->C. uncurry(curry(f)) = f","context":["Intro","FunExt","PairElim","Auto"]} +{"prover":"Nuprl","tactic_proof":"Intro; DPairElim; Auto","source":"nuprl_synthetic/types","theorem":"dep_pair_eta","id":88021,"goal":"all A:Type, B:A->Type, p:(x:A * B(x)). p = ","context":["Intro","DPairElim","Auto"]} +{"prover":"Nuprl","tactic_proof":"NatInd; Auto; Witness `cons(tt, l)`; Auto","source":"nuprl_synthetic/types","theorem":"iso_nat_list_unit","id":88022,"goal":"all n:Nat. exists l:List(Unit). length(l) = n","context":["NatInd","Auto","Witness `cons(tt, l)`"]} +{"prover":"Nuprl","tactic_proof":"Intro; Iso; Lambda x. ; Lambda y. ; Auto","source":"nuprl_synthetic/types","theorem":"type_product_comm","id":88023,"goal":"all A,B:Type. A*B ~ B*A","context":["Intro","Iso","Lambda x. ","Lambda y. ","Auto"]} +{"prover":"Nuprl","tactic_proof":"Intro; Iso; DecideElim; Auto","source":"nuprl_synthetic/types","theorem":"type_sum_comm","id":88024,"goal":"all A,B:Type. A+B ~ B+A","context":["Intro","Iso","DecideElim","Auto"]} +{"prover":"Nuprl","tactic_proof":"ListInd; Auto","source":"nuprl_synthetic/lists","theorem":"append_nil","id":88025,"goal":"all A:Type, l:List(A). append(l, nil) = l","context":["ListInd","Auto"]} +{"prover":"Nuprl","tactic_proof":"ListInd `l1`; Auto","source":"nuprl_synthetic/lists","theorem":"append_assoc","id":88026,"goal":"all A:Type, l1,l2,l3:List(A). append(append(l1,l2),l3) = append(l1,append(l2,l3))","context":["ListInd `l1`","Auto"]} +{"prover":"Nuprl","tactic_proof":"ListInd `l1`; Auto","source":"nuprl_synthetic/lists","theorem":"length_append","id":88027,"goal":"all A:Type, l1,l2:List(A). length(append(l1,l2)) = length(l1) + length(l2)","context":["ListInd `l1`","Auto"]} +{"prover":"Nuprl","tactic_proof":"ListInd; Auto","source":"nuprl_synthetic/lists","theorem":"map_id","id":88028,"goal":"all A:Type, l:List(A). map(id, l) = l","context":["ListInd","Auto"]} +{"prover":"Nuprl","tactic_proof":"ListInd; Auto","source":"nuprl_synthetic/lists","theorem":"map_compose","id":88029,"goal":"all A,B,C:Type, f:B->C, g:A->B, l:List(A). map(f, map(g, l)) = map(compose(f,g), l)","context":["ListInd","Auto"]} +{"prover":"Nuprl","tactic_proof":"ListInd; Auto; Unfold `reverse`; Auto","source":"nuprl_synthetic/lists","theorem":"reverse_reverse","id":88030,"goal":"all A:Type, l:List(A). reverse(reverse(l)) = l","context":["ListInd","Auto","Unfold `reverse`"]} +{"prover":"Nuprl","tactic_proof":"ListInd; Auto","source":"nuprl_synthetic/lists","theorem":"length_reverse","id":88031,"goal":"all A:Type, l:List(A). length(reverse(l)) = length(l)","context":["ListInd","Auto"]} +{"prover":"Nuprl","tactic_proof":"ListInd `l1`; Auto; OrElim; Auto","source":"nuprl_synthetic/lists","theorem":"member_append","id":88032,"goal":"all A:Type, x:A, l1,l2:List(A). member(x, append(l1,l2)) <=> member(x,l1) or member(x,l2)","context":["ListInd `l1`","Auto","OrElim"]} +{"prover":"Nuprl","tactic_proof":"ListInd; Auto; CaseAnalysis `p(hd)`; Auto","source":"nuprl_synthetic/lists","theorem":"filter_length","id":88033,"goal":"all A:Type, p:A->Bool, l:List(A). length(filter(p, l)) <= length(l)","context":["ListInd","Auto","CaseAnalysis `p(hd)`"]} +{"prover":"Nuprl","tactic_proof":"ListInd `l1`; Auto","source":"nuprl_synthetic/lists","theorem":"foldr_append","id":88034,"goal":"all A,B:Type, f:A->B->B, z:B, l1,l2:List(A). foldr(f, z, append(l1,l2)) = foldr(f, foldr(f,z,l2), l1)","context":["ListInd `l1`","Auto"]} +{"prover":"Nuprl","tactic_proof":"Intro; Intro; Apply; Auto","source":"nuprl_synthetic/logic","theorem":"modus_ponens","id":88035,"goal":"all P,Q:Prop. P => (P => Q) => Q","context":["Intro","Apply","Auto"]} +{"prover":"Nuprl","tactic_proof":"Intro; AndElim; Split; Auto","source":"nuprl_synthetic/logic","theorem":"and_comm","id":88036,"goal":"all P,Q:Prop. P & Q => Q & P","context":["Intro","AndElim","Split","Auto"]} +{"prover":"Nuprl","tactic_proof":"Intro; OrElim; [Right; Auto | Left; Auto]","source":"nuprl_synthetic/logic","theorem":"or_comm","id":88037,"goal":"all P,Q:Prop. P or Q => Q or P","context":["Intro","OrElim","Right","Auto","Left"]} +{"prover":"Nuprl","tactic_proof":"Intro; ByContradiction; Auto","source":"nuprl_synthetic/logic","theorem":"double_neg_elim","id":88038,"goal":"all P:Prop. ~~P => P","context":["Intro","ByContradiction","Auto"]} +{"prover":"Nuprl","tactic_proof":"Split; Intro; ByContradiction; Auto; Intro; OrElim; Auto","source":"nuprl_synthetic/logic","theorem":"de_morgan_and","id":88039,"goal":"all P,Q:Prop. ~(P & Q) <=> (~P or ~Q)","context":["Split","Intro","ByContradiction","Auto","OrElim"]} +{"prover":"Nuprl","tactic_proof":"Split; Intro; Split; Intro; Apply; Left; Auto; Intro; Apply; Right; Auto; Intro; AndElim; OrElim; Auto","source":"nuprl_synthetic/logic","theorem":"de_morgan_or","id":88040,"goal":"all P,Q:Prop. ~(P or Q) <=> (~P & ~Q)","context":["Split","Intro","Apply","Left","Auto","Right","AndElim","OrElim"]} +{"prover":"Nuprl","tactic_proof":"Intro; Intro; Intro; Apply; Auto","source":"nuprl_synthetic/logic","theorem":"contrapositive","id":88041,"goal":"all P,Q:Prop. (P => Q) => (~Q => ~P)","context":["Intro","Apply","Auto"]} +{"prover":"Nuprl","tactic_proof":"Intro; Intro; Witness `a`; Apply; Auto","source":"nuprl_synthetic/logic","theorem":"forall_implies_exists","id":88042,"goal":"all A:Type, P:A->Prop, a:A. (all x:A. P(x)) => exists x:A. P(x)","context":["Intro","Witness `a`","Apply","Auto"]} +{"prover":"Nuprl","tactic_proof":"Intro; ExistsElim; Intro; Apply; Auto","source":"nuprl_synthetic/logic","theorem":"exists_not_forall_not","id":88043,"goal":"all A:Type, P:A->Prop. (exists x:A. P(x)) => ~(all x:A. ~P(x))","context":["Intro","ExistsElim","Apply","Auto"]} +{"prover":"Nuprl","tactic_proof":"Intro; ByContradiction; Apply; Intro; Absurd; Auto","source":"nuprl_synthetic/logic","theorem":"peirce","id":88044,"goal":"all P,Q:Prop. ((P => Q) => P) => P","context":["Intro","ByContradiction","Apply","Absurd","Auto"]} +{"prover":"Nuprl","tactic_proof":"NatInd `m`; NatInd `n`; Auto; CaseAnalysis; Auto","source":"nuprl_synthetic/constructive","theorem":"nat_decidable_eq","id":88045,"goal":"all m,n:Nat. (m = n) or ~(m = n)","context":["NatInd `m`","NatInd `n`","Auto","CaseAnalysis"]} +{"prover":"Nuprl","tactic_proof":"Intro; BoundedSearch; Auto","source":"nuprl_synthetic/constructive","theorem":"markov_nat","id":88046,"goal":"all f:Nat->Bool. ~~(exists n:Nat. f(n) = true) => exists n:Nat. f(n) = true","context":["Intro","BoundedSearch","Auto"]} +{"prover":"Nuprl","tactic_proof":"Intro; CountableChoice; Auto","source":"nuprl_synthetic/constructive","theorem":"choice_nat","id":88047,"goal":"all R:Nat->Nat->Prop. (all n:Nat. exists m:Nat. R(n,m)) => exists f:Nat->Nat. all n:Nat. R(n, f(n))","context":["Intro","CountableChoice","Auto"]} +{"prover":"Nuprl","tactic_proof":"StrongInduction; Auto","source":"nuprl_synthetic/constructive","theorem":"well_ordering_nat","id":88048,"goal":"all P:Nat->Prop. (exists n:Nat. P(n)) => exists m:Nat. P(m) & (all k:Nat. k < m => ~P(k))","context":["StrongInduction","Auto"]} +{"prover":"Nuprl","tactic_proof":"Continuity; Auto","source":"nuprl_synthetic/constructive","theorem":"brouwer_continuity","id":88049,"goal":"all f:(Nat->Nat)->Nat. exists n:Nat. all a,b:Nat->Nat. (all i:Nat. i < n => a(i) = b(i)) => f(a) = f(b)","context":["Continuity","Auto"]} +{"prover":"Nuprl","tactic_proof":"Induction; Diamond; Auto","source":"nuprl_synthetic/constructive","theorem":"church_rosser","id":88050,"goal":"all M,N,P:Term. reduces(M, N) => reduces(M, P) => exists Q:Term. reduces(N, Q) & reduces(P, Q)","context":["Induction","Diamond","Auto"]} +{"prover":"Nuprl","tactic_proof":"BarInduction; Auto","source":"nuprl_synthetic/constructive","theorem":"fan_theorem","id":88051,"goal":"all T:Tree. (all b:Branch. bar(T, b)) => exists n:Nat. uniform_bar(T, n)","context":["BarInduction","Auto"]} +{"prover":"Nuprl","tactic_proof":"Intro; OrElim; Auto","source":"nuprl_synthetic/constructive","theorem":"kripke_schema","id":88052,"goal":"all A:Prop. (A \\/ ~A) => decidable(A)","context":["Intro","OrElim","Auto"]} +{"prover":"Nuprl","tactic_proof":"Intro; SetExt; Auto","source":"nuprl_synthetic/sets","theorem":"set_ext","id":88053,"goal":"all A:Type, s1,s2:Set(A). (all x:A. x in s1 <=> x in s2) => s1 = s2","context":["Intro","SetExt","Auto"]} +{"prover":"Nuprl","tactic_proof":"SetExt; Auto","source":"nuprl_synthetic/sets","theorem":"union_comm","id":88054,"goal":"all A:Type, s1,s2:Set(A). union(s1, s2) = union(s2, s1)","context":["SetExt","Auto"]} +{"prover":"Nuprl","tactic_proof":"SetExt; Auto","source":"nuprl_synthetic/sets","theorem":"union_assoc","id":88055,"goal":"all A:Type, s1,s2,s3:Set(A). union(union(s1,s2),s3) = union(s1,union(s2,s3))","context":["SetExt","Auto"]} +{"prover":"Nuprl","tactic_proof":"SetExt; Auto","source":"nuprl_synthetic/sets","theorem":"inter_comm","id":88056,"goal":"all A:Type, s1,s2:Set(A). intersect(s1, s2) = intersect(s2, s1)","context":["SetExt","Auto"]} +{"prover":"Nuprl","tactic_proof":"SetExt; Auto","source":"nuprl_synthetic/sets","theorem":"distrib_union_inter","id":88057,"goal":"all A:Type, s1,s2,s3:Set(A). union(s1, intersect(s2, s3)) = intersect(union(s1,s2), union(s1,s3))","context":["SetExt","Auto"]} +{"prover":"Nuprl","tactic_proof":"Intro; ElimEmpty; Auto","source":"nuprl_synthetic/sets","theorem":"empty_subset","id":88058,"goal":"all A:Type, s:Set(A). subset(empty, s)","context":["Intro","ElimEmpty","Auto"]} +{"prover":"Nuprl","tactic_proof":"Intro; UnionElim; Auto","source":"nuprl_synthetic/sets","theorem":"union_superset","id":88059,"goal":"all A:Type, s1,s2:Set(A). subset(s1, union(s1, s2))","context":["Intro","UnionElim","Auto"]} +{"prover":"Nuprl","tactic_proof":"Intro; Intro; Apply; Auto","source":"nuprl_synthetic/sets","theorem":"power_set_monotone","id":88060,"goal":"all A:Type, s1,s2:Set(A). subset(s1, s2) => subset(pow(s1), pow(s2))","context":["Intro","Apply","Auto"]} +{"prover":"Nuprl","tactic_proof":"Intro; FiniteUnion; Auto","source":"nuprl_synthetic/sets","theorem":"finite_union","id":88061,"goal":"all A:Type, s1,s2:FiniteSet(A). finite(union(s1, s2))","context":["Intro","FiniteUnion","Auto"]} +{"prover":"Nuprl","tactic_proof":"InclusionExclusion; Auto","source":"nuprl_synthetic/sets","theorem":"cardinal_union","id":88062,"goal":"all A:Type, s1,s2:FiniteSet(A). card(union(s1,s2)) = card(s1) + card(s2) - card(intersect(s1,s2))","context":["InclusionExclusion","Auto"]} +{"prover":"Nuprl","tactic_proof":"Intro; RTC_Refl; Auto","source":"nuprl_synthetic/relations","theorem":"refl_closure","id":88063,"goal":"all A:Type, R:A->A->Prop, x:A. refl_trans_closure(R)(x, x)","context":["Intro","RTC_Refl","Auto"]} +{"prover":"Nuprl","tactic_proof":"Intro; Induction; Auto","source":"nuprl_synthetic/relations","theorem":"trans_composition","id":88064,"goal":"all A:Type, R:A->A->Prop, x,y,z:A. trans_closure(R)(x,y) => trans_closure(R)(y,z) => trans_closure(R)(x,z)","context":["Intro","Induction","Auto"]} +{"prover":"Nuprl","tactic_proof":"Intro; Intro; ApplySym; Auto","source":"nuprl_synthetic/relations","theorem":"equiv_sym","id":88065,"goal":"all A:Type, R:A->A->Prop, x,y:A. equivalence(R) => R(x, y) => R(y, x)","context":["Intro","ApplySym","Auto"]} +{"prover":"Nuprl","tactic_proof":"Intro; WFInduction; Auto","source":"nuprl_synthetic/relations","theorem":"well_founded_induction","id":88066,"goal":"all A:Type, R:A->A->Prop. well_founded(R) => all P:A->Prop. (all x:A. (all y:A. R(y,x) => P(y)) => P(x)) => all x:A. P(x)","context":["Intro","WFInduction","Auto"]} +{"prover":"Nuprl","tactic_proof":"Intro; ApplyAntisym; Auto","source":"nuprl_synthetic/relations","theorem":"partial_order_antisym","id":88067,"goal":"all A:Type, R:A->A->Prop, x,y:A. partial_order(R) => R(x,y) => R(y,x) => x = y","context":["Intro","ApplyAntisym","Auto"]} +{"prover":"Nuprl","tactic_proof":"Intro; Trichotomy; Auto","source":"nuprl_synthetic/relations","theorem":"total_order_trichotomy","id":88068,"goal":"all A:Type, R:A->A->Prop, x,y:A. total_order(R) => R(x,y) \\/ x = y \\/ R(y,x)","context":["Intro","Trichotomy","Auto"]} +{"prover":"Nuprl","tactic_proof":"Induction; Auto","source":"nuprl_synthetic/relations","theorem":"graph_path_compose","id":88069,"goal":"all V:Type, E:V->V->Prop, x,y,z:V. path(E)(x,y) => path(E)(y,z) => path(E)(x,z)","context":["Induction","Auto"]} +{"prover":"Nuprl","tactic_proof":"Intro; Split; Auto","source":"nuprl_synthetic/relations","theorem":"converse_relation","id":88070,"goal":"all A,B:Type, R:A->B->Prop, x:A, y:B. R(x,y) <=> converse(R)(y,x)","context":["Intro","Split","Auto"]} +{"prover":"Nuprl","tactic_proof":"Intro; CaseGCD; Auto","source":"nuprl_synthetic/number_theory","theorem":"euclid_lemma","id":88071,"goal":"all p:Prime, a,b:Nat. divides(p, a*b) => divides(p, a) or divides(p, b)","context":["Intro","CaseGCD","Auto"]} +{"prover":"Nuprl","tactic_proof":"StrongInduction; Auto","source":"nuprl_synthetic/number_theory","theorem":"fundamental_arith","id":88072,"goal":"all n:Nat. n >= 2 => exists! ps:List(Prime). product(ps) = n","context":["StrongInduction","Auto"]} +{"prover":"Nuprl","tactic_proof":"Intro; ExtendedEuclid; Auto","source":"nuprl_synthetic/number_theory","theorem":"bezout","id":88073,"goal":"all a,b:Nat. a > 0 \\/ b > 0 => exists x,y:Int. a*x + b*y = gcd(a,b)","context":["Intro","ExtendedEuclid","Auto"]} +{"prover":"Nuprl","tactic_proof":"Intro; Witness `factorial(n)+1`; Auto","source":"nuprl_synthetic/number_theory","theorem":"infinitude_primes","id":88074,"goal":"all n:Nat. exists p:Prime. p > n","context":["Intro","Witness `factorial(n)+1`","Auto"]} +{"prover":"Nuprl","tactic_proof":"Intro; ModArith; Auto","source":"nuprl_synthetic/number_theory","theorem":"wilson_theorem","id":88075,"goal":"all p:Prime. (factorial(p-1) + 1) mod p = 0","context":["Intro","ModArith","Auto"]} +{"prover":"Nuprl","tactic_proof":"Intro; GroupOrder; Auto","source":"nuprl_synthetic/number_theory","theorem":"fermat_little","id":88076,"goal":"all p:Prime, a:Nat. coprime(a, p) => (a^(p-1)) mod p = 1","context":["Intro","GroupOrder","Auto"]} +{"prover":"Nuprl","tactic_proof":"Intro; Intro; CRT; Auto","source":"nuprl_synthetic/number_theory","theorem":"chinese_remainder","id":88077,"goal":"all m,n:Nat. coprime(m,n) => all a,b:Int. exists x:Int. (x mod m = a) & (x mod n = b)","context":["Intro","CRT","Auto"]} +{"prover":"Nuprl","tactic_proof":"Classify; Auto","source":"nuprl_synthetic/number_theory","theorem":"sum_of_squares","id":88078,"goal":"all n:Nat. (exists a,b:Nat. n = a*a + b*b) <=> all p:Prime. p `divides` n & p mod 4 = 3 => even(mult(p, n))","context":["Classify","Auto"]} +{"prover":"Nuprl","tactic_proof":"Intro; PHP; Auto","source":"nuprl_synthetic/number_theory","theorem":"pigeon_hole","id":88079,"goal":"all n,m:Nat, f:Fin(n)->Fin(m). n > m => exists i,j:Fin(n). i <> j & f(i) = f(j)","context":["Intro","PHP","Auto"]} +{"prover":"Nuprl","tactic_proof":"Intro; LimitArith; Auto","source":"nuprl_synthetic/real_analysis","theorem":"lim_sum","id":88080,"goal":"all f,g:Nat->Real, a,b:Real. lim(f) = a => lim(g) = b => lim(fun n. f(n)+g(n)) = a+b","context":["Intro","LimitArith","Auto"]} +{"prover":"Nuprl","tactic_proof":"Intro; LimitArith; Auto","source":"nuprl_synthetic/real_analysis","theorem":"lim_prod","id":88081,"goal":"all f,g:Nat->Real, a,b:Real. lim(f) = a => lim(g) = b => lim(fun n. f(n)*g(n)) = a*b","context":["Intro","LimitArith","Auto"]} +{"prover":"Nuprl","tactic_proof":"Intro; Squeeze; Auto","source":"nuprl_synthetic/real_analysis","theorem":"squeeze","id":88082,"goal":"all f,g,h:Nat->Real. (all n:Nat. f(n) <= g(n) <= h(n)) => lim(f) = lim(h) => lim(g) = lim(f)","context":["Intro","Squeeze","Auto"]} +{"prover":"Nuprl","tactic_proof":"Intro; EpsilonDelta; Auto","source":"nuprl_synthetic/real_analysis","theorem":"continuous_compose","id":88083,"goal":"all f,g:Real->Real. continuous(f) => continuous(g) => continuous(compose(f, g))","context":["Intro","EpsilonDelta","Auto"]} +{"prover":"Nuprl","tactic_proof":"Intro; Bisection; Auto","source":"nuprl_synthetic/real_analysis","theorem":"ivt","id":88084,"goal":"all f:Real->Real, a,b:Real, y:Real. continuous(f) => f(a) <= y <= f(b) => exists c:Real. a <= c <= b & f(c) = y","context":["Intro","Bisection","Auto"]} +{"prover":"Nuprl","tactic_proof":"Intro; Rolle; Auto","source":"nuprl_synthetic/real_analysis","theorem":"mvt","id":88085,"goal":"all f:Real->Real, a,b:Real. differentiable(f) => a < b => exists c:Real. a < c < b & derivative(f)(c) = (f(b)-f(a))/(b-a)","context":["Intro","Rolle","Auto"]} +{"prover":"Nuprl","tactic_proof":"Intro; CompletenessAxiom; Auto","source":"nuprl_synthetic/real_analysis","theorem":"cauchy_complete","id":88086,"goal":"all s:Nat->Real. cauchy(s) => exists L:Real. lim(s) = L","context":["Intro","CompletenessAxiom","Auto"]} +{"prover":"Nuprl","tactic_proof":"Intro; Intro; ExtremeValue; Auto","source":"nuprl_synthetic/real_analysis","theorem":"compact_attains","id":88087,"goal":"all f:Real->Real, K:Set(Real). compact(K) => continuous(f) => exists m,M:Real. m in f(K) & M in f(K) & all y in f(K). m <= y <= M","context":["Intro","ExtremeValue","Auto"]} +{"prover":"Nuprl","tactic_proof":"Diagonalization; Auto","source":"nuprl_synthetic/computability","theorem":"halting_undecidable","id":88088,"goal":"~exists H:(Prog->Input->Bool). all p:Prog, x:Input. H(p, x) = true <=> halts(p, x)","context":["Diagonalization","Auto"]} +{"prover":"Nuprl","tactic_proof":"Intro; Reduction; Auto","source":"nuprl_synthetic/computability","theorem":"rice_theorem","id":88089,"goal":"all P:(Prog->Prop). nontrivial(P) => ~decidable(P)","context":["Intro","Reduction","Auto"]} +{"prover":"Nuprl","tactic_proof":"KleeneRecursion; Auto","source":"nuprl_synthetic/computability","theorem":"recursion_theorem","id":88090,"goal":"all f:Prog->Prog. exists e:Prog. equal_programs(e, f(e))","context":["KleeneRecursion","Auto"]} +{"prover":"Nuprl","tactic_proof":"Intro; Intro; SMN; Auto","source":"nuprl_synthetic/computability","theorem":"smn_theorem","id":88091,"goal":"all n,m:Nat, f:Prog. exists s:Prog. all x,y:Input. run(f, pair(x,y)) = run(run(s, x), y)","context":["Intro","SMN","Auto"]} +{"prover":"Nuprl","tactic_proof":"Intro; NormalForm; Auto","source":"nuprl_synthetic/computability","theorem":"kleene_normal","id":88092,"goal":"all f:PartialFn. exists e,U:Prog. all x:Input. f(x) = run(U, pair(e, x))","context":["Intro","NormalForm","Auto"]} +{"prover":"Nuprl","tactic_proof":"Intro; Encode; Auto","source":"nuprl_synthetic/computability","theorem":"church_turing_lambda","id":88093,"goal":"all f:ComputableFn. exists t:Term. reduces_to_numeral(t(numeral(x)), numeral(f(x)))","context":["Intro","Encode","Auto"]} +{"prover":"Nuprl","tactic_proof":"Intro; CatAssoc; Auto","source":"nuprl_synthetic/category_theory","theorem":"cat_comp_assoc","id":88094,"goal":"all C:Cat, f:Hom(a,b), g:Hom(b,c), h:Hom(c,d). comp(comp(h,g),f) = comp(h,comp(g,f))","context":["Intro","CatAssoc","Auto"]} +{"prover":"Nuprl","tactic_proof":"Intro; CatIdLeft; Auto","source":"nuprl_synthetic/category_theory","theorem":"cat_id_left","id":88095,"goal":"all C:Cat, f:Hom(a,b). comp(id(b), f) = f","context":["Intro","CatIdLeft","Auto"]} +{"prover":"Nuprl","tactic_proof":"Intro; CatIdRight; Auto","source":"nuprl_synthetic/category_theory","theorem":"cat_id_right","id":88096,"goal":"all C:Cat, f:Hom(a,b). comp(f, id(a)) = f","context":["Intro","CatIdRight","Auto"]} +{"prover":"Nuprl","tactic_proof":"Intro; FunctorLaw; Auto","source":"nuprl_synthetic/category_theory","theorem":"functor_comp","id":88097,"goal":"all F:Functor, f:Hom(a,b), g:Hom(b,c). Fmap(comp(g,f)) = comp(Fmap(g), Fmap(f))","context":["Intro","FunctorLaw","Auto"]} +{"prover":"Nuprl","tactic_proof":"Intro; FunctorIdLaw; Auto","source":"nuprl_synthetic/category_theory","theorem":"functor_id","id":88098,"goal":"all F:Functor, a:Obj. Fmap(id(a)) = id(Fobj(a))","context":["Intro","FunctorIdLaw","Auto"]} +{"prover":"Nuprl","tactic_proof":"Intro; Naturality; Auto","source":"nuprl_synthetic/category_theory","theorem":"natural_trans","id":88099,"goal":"all F,G:Functor, eta:NatTrans(F,G), f:Hom(a,b). comp(eta(b), Fmap_F(f)) = comp(Fmap_G(f), eta(a))","context":["Intro","Naturality","Auto"]} +{"prover":"Nuprl","tactic_proof":"Intro; Isomorphism; Auto","source":"nuprl_synthetic/category_theory","theorem":"iso_compose","id":88100,"goal":"all C:Cat, f:Hom(a,b), g:Hom(b,a). comp(g, f) = id(a) => comp(f, g) = id(b) => isomorphism(f)","context":["Intro","Isomorphism","Auto"]} +{"prover":"Nuprl","tactic_proof":"Intro; Universal; Auto","source":"nuprl_synthetic/category_theory","theorem":"product_universal","id":88101,"goal":"all C:Cat, p:Obj, f:Hom(p,a), g:Hom(p,b). exists! h:Hom(p, prod(a,b)). comp(pi1, h) = f & comp(pi2, h) = g","context":["Intro","Universal","Auto"]} +{"prover":"Nuprl","tactic_proof":"Intro; OpenAxiom; Auto","source":"nuprl_synthetic/topology","theorem":"open_union","id":88102,"goal":"all X:TopSpace, U,V:Open(X). open(union(U, V))","context":["Intro","OpenAxiom","Auto"]} +{"prover":"Nuprl","tactic_proof":"Intro; OpenAxiom; Auto","source":"nuprl_synthetic/topology","theorem":"open_finite_inter","id":88103,"goal":"all X:TopSpace, U,V:Open(X). open(intersect(U, V))","context":["Intro","OpenAxiom","Auto"]} +{"prover":"Nuprl","tactic_proof":"Intro; Continuous; Auto","source":"nuprl_synthetic/topology","theorem":"continuous_compose","id":88104,"goal":"all X,Y,Z:TopSpace, f:X->Y, g:Y->Z. continuous(f) => continuous(g) => continuous(compose(g, f))","context":["Intro","Continuous","Auto"]} +{"prover":"Nuprl","tactic_proof":"Intro; Compact; Auto","source":"nuprl_synthetic/topology","theorem":"compact_closed","id":88105,"goal":"all X:TopSpace, K:Subspace(X). compact(K) => hausdorff(X) => closed(K)","context":["Intro","Compact","Auto"]} +{"prover":"Nuprl","tactic_proof":"Intro; Connected; Auto","source":"nuprl_synthetic/topology","theorem":"connected_image","id":88106,"goal":"all X,Y:TopSpace, f:X->Y. continuous(f) => connected(X) => connected(image(f))","context":["Intro","Connected","Auto"]} +{"prover":"Nuprl","tactic_proof":"Intro; Hausdorff; Auto","source":"nuprl_synthetic/topology","theorem":"hausdorff_limit","id":88107,"goal":"all X:TopSpace, s:Nat->X, L1,L2:X. hausdorff(X) => lim(s) = L1 => lim(s) = L2 => L1 = L2","context":["Intro","Hausdorff","Auto"]} +{"prover":"Nuprl","tactic_proof":"Intro; Homeomorphism; Auto","source":"nuprl_synthetic/topology","theorem":"homeomorphism","id":88108,"goal":"all X,Y:TopSpace, f:X->Y. continuous(f) => continuous(inverse(f)) => homeomorphism(f)","context":["Intro","Homeomorphism","Auto"]} +{"prover":"Nuprl","tactic_proof":"Intro; Cancel; Auto","source":"nuprl_synthetic/algebra","theorem":"group_inv_unique","id":88109,"goal":"all G:Group, a,b,c:G. op(a,b) = e => op(a,c) = e => b = c","context":["Intro","Cancel","Auto"]} +{"prover":"Nuprl","tactic_proof":"Intro; SubgroupAxiom; Auto","source":"nuprl_synthetic/algebra","theorem":"subgroup_closed","id":88110,"goal":"all G:Group, H:Subgroup(G), a,b:H. op(a, b) in H","context":["Intro","SubgroupAxiom","Auto"]} +{"prover":"Nuprl","tactic_proof":"Intro; Lagrange; Auto","source":"nuprl_synthetic/algebra","theorem":"lagrange","id":88111,"goal":"all G:FinGroup, H:Subgroup(G). divides(order(H), order(G))","context":["Intro","Lagrange","Auto"]} +{"prover":"Nuprl","tactic_proof":"Intro; KernelAxiom; Auto","source":"nuprl_synthetic/algebra","theorem":"homomorphism_kernel","id":88112,"goal":"all G,H:Group, f:Homomorphism(G, H). subgroup(kernel(f), G)","context":["Intro","KernelAxiom","Auto"]} +{"prover":"Nuprl","tactic_proof":"Intro; RingAxiom; Auto","source":"nuprl_synthetic/algebra","theorem":"ring_add_group","id":88113,"goal":"all R:Ring. group(R, +)","context":["Intro","RingAxiom","Auto"]} +{"prover":"Nuprl","tactic_proof":"Intro; IdealAxiom; Auto","source":"nuprl_synthetic/algebra","theorem":"ideal_closed","id":88114,"goal":"all R:Ring, I:Ideal(R), a:R, b:I. op(a, b) in I","context":["Intro","IdealAxiom","Auto"]} +{"prover":"Nuprl","tactic_proof":"Intro; FieldAxiom; Auto","source":"nuprl_synthetic/algebra","theorem":"field_no_zero_div","id":88115,"goal":"all F:Field, a,b:F. a*b = 0 => a = 0 or b = 0","context":["Intro","FieldAxiom","Auto"]} +{"prover":"Nuprl","tactic_proof":"Intro; VectorAxiom; Auto","source":"nuprl_synthetic/algebra","theorem":"vector_space_sum","id":88116,"goal":"all V:VectorSpace, v,w:V. v + w = w + v","context":["Intro","VectorAxiom","Auto"]} +{"prover":"Nuprl","tactic_proof":"Intro; ProbAxiom; Auto","source":"nuprl_synthetic/probability","theorem":"prob_nonneg","id":88117,"goal":"all P:ProbMeasure, A:Event. P(A) >= 0","context":["Intro","ProbAxiom","Auto"]} +{"prover":"Nuprl","tactic_proof":"Intro; ProbAxiom; Auto","source":"nuprl_synthetic/probability","theorem":"prob_total","id":88118,"goal":"all P:ProbMeasure. P(universe) = 1","context":["Intro","ProbAxiom","Auto"]} +{"prover":"Nuprl","tactic_proof":"Intro; Additivity; Auto","source":"nuprl_synthetic/probability","theorem":"prob_additivity","id":88119,"goal":"all P:ProbMeasure, A,B:Event. disjoint(A, B) => P(union(A, B)) = P(A) + P(B)","context":["Intro","Additivity","Auto"]} +{"prover":"Nuprl","tactic_proof":"Intro; BayesDef; Auto","source":"nuprl_synthetic/probability","theorem":"bayes_rule","id":88120,"goal":"all P:ProbMeasure, A,B:Event. P(B) > 0 => P(A | B) = P(A & B) / P(B)","context":["Intro","BayesDef","Auto"]} +{"prover":"Nuprl","tactic_proof":"Intro; Split; Auto","source":"nuprl_synthetic/probability","theorem":"conditional_indep","id":88121,"goal":"all P:ProbMeasure, A,B,C:Event. indep(A, B | C) <=> P(A & B | C) = P(A | C) * P(B | C)","context":["Intro","Split","Auto"]} +{"prover":"Nuprl","tactic_proof":"Intro; Markov; Auto","source":"nuprl_synthetic/probability","theorem":"markov_ineq","id":88122,"goal":"all X:RandomVar, a:PosReal. P(X >= a) <= E(X) / a","context":["Intro","Markov","Auto"]} +{"prover":"Nuprl","tactic_proof":"Intro; Linearity; Auto","source":"nuprl_synthetic/probability","theorem":"expectation_linear","id":88123,"goal":"all X,Y:RandomVar, a,b:Real. E(a*X + b*Y) = a*E(X) + b*E(Y)","context":["Intro","Linearity","Auto"]} +{"prover":"Nuprl","tactic_proof":"Intro; Variance; Auto","source":"nuprl_synthetic/probability","theorem":"variance_nonneg","id":88124,"goal":"all X:RandomVar. var(X) >= 0","context":["Intro","Variance","Auto"]} +{"prover":"Nuprl","tactic_proof":"Intro; ConstructReal; Auto","source":"nuprl_synthetic/bishop_analysis","theorem":"bishop_real_approx","id":88125,"goal":"all x:Real, n:PosInt. exists q:Rational. abs(x - q) < 1/n","context":["Intro","ConstructReal","Auto"]} +{"prover":"Nuprl","tactic_proof":"Intro; Intro; ModulusCauchy; Auto","source":"nuprl_synthetic/bishop_analysis","theorem":"bishop_seq_modulus","id":88126,"goal":"all s:Nat->Real, eps:PosReal. cauchy(s) => exists M:Nat. all m,n:Nat. m >= M => n >= M => abs(s(m) - s(n)) < eps","context":["Intro","ModulusCauchy","Auto"]} +{"prover":"Nuprl","tactic_proof":"Intro; Intro; HeineCantor; Auto","source":"nuprl_synthetic/bishop_analysis","theorem":"bishop_cont_uniform","id":88127,"goal":"all f:Real->Real, K:CompactInterval. continuous(f) => uniformly_continuous_on(f, K)","context":["Intro","HeineCantor","Auto"]} +{"prover":"Nuprl","tactic_proof":"Intro; RationalDensity; Auto","source":"nuprl_synthetic/bishop_analysis","theorem":"bishop_rational_dense","id":88128,"goal":"all a,b:Real. a < b => exists q:Rational. a < q < b","context":["Intro","RationalDensity","Auto"]} +{"prover":"Nuprl","tactic_proof":"Intro; Newton; Auto","source":"nuprl_synthetic/bishop_analysis","theorem":"bishop_sqrt_exists","id":88129,"goal":"all x:NonNegReal. exists y:NonNegReal. y*y = x","context":["Intro","Newton","Auto"]} +{"prover":"Nuprl","tactic_proof":"Intros; CutAdmissible; Auto","source":"nuprl_synthetic/proof_theory","theorem":"cut_elim_nuprl","id":88130,"goal":"all A,B. |- A -> (A |- B) -> |- B","context":["Intros","CutAdmissible","Auto"]} +{"prover":"Nuprl","tactic_proof":"Intro; Axiom; Auto","source":"nuprl_synthetic/proof_theory","theorem":"proof_identity","id":88131,"goal":"all A:Prop. |- A -> A","context":["Intro","Axiom","Auto"]} +{"prover":"Nuprl","tactic_proof":"Intros; Weakening; Auto","source":"nuprl_synthetic/proof_theory","theorem":"proof_weakening","id":88132,"goal":"all A,B:Prop. |- B => (A |- B)","context":["Intros","Weakening","Auto"]} +{"prover":"Nuprl","tactic_proof":"Intro; SubtypeRefl; Auto","source":"nuprl_synthetic/proof_theory","theorem":"subtype_refl","id":88133,"goal":"all T:Type. T subtype T","context":["Intro","SubtypeRefl","Auto"]} +{"prover":"Nuprl","tactic_proof":"Intros; SubtypeTrans; Auto","source":"nuprl_synthetic/proof_theory","theorem":"subtype_trans","id":88134,"goal":"all T1,T2,T3:Type. T1 subtype T2 => T2 subtype T3 => T1 subtype T3","context":["Intros","SubtypeTrans","Auto"]} +{"prover":"Nuprl","tactic_proof":"Intros; EqSym; Auto","source":"nuprl_synthetic/proof_theory","theorem":"equality_symmetry","id":88135,"goal":"all A:Type, x,y:A. x = y => y = x","context":["Intros","EqSym","Auto"]} +{"prover":"Nuprl","tactic_proof":"Intros; EqTrans; Auto","source":"nuprl_synthetic/proof_theory","theorem":"equality_trans","id":88136,"goal":"all A:Type, x,y,z:A. x = y => y = z => x = z","context":["Intros","EqTrans","Auto"]} +{"prover":"Nuprl","tactic_proof":"Intro; EntropyDef; Auto","source":"nuprl_synthetic/information","theorem":"entropy_nonneg","id":88137,"goal":"all P:ProbDist. entropy(P) >= 0","context":["Intro","EntropyDef","Auto"]} +{"prover":"Nuprl","tactic_proof":"Intro; Intro; MaxEntropy; Auto","source":"nuprl_synthetic/information","theorem":"entropy_uniform_max","id":88138,"goal":"all n:PosNat, P:ProbDist(Fin(n)). entropy(P) <= log(n)","context":["Intro","MaxEntropy","Auto"]} +{"prover":"Nuprl","tactic_proof":"Intro; MIDef; Auto","source":"nuprl_synthetic/information","theorem":"mutual_info_nonneg","id":88139,"goal":"all X,Y:RandomVar. I(X; Y) >= 0","context":["Intro","MIDef","Auto"]} +{"prover":"Nuprl","tactic_proof":"Intro; ChainRule; Auto","source":"nuprl_synthetic/information","theorem":"chain_rule_entropy","id":88140,"goal":"all X,Y:RandomVar. H(X, Y) = H(X) + H(Y | X)","context":["Intro","ChainRule","Auto"]} +{"prover":"Nuprl","tactic_proof":"Intro; Kraft; Auto","source":"nuprl_synthetic/information","theorem":"kraft_inequality","id":88141,"goal":"all C:PrefixCode. sum(c in C, 2^(-length(c))) <= 1","context":["Intro","Kraft","Auto"]} +{"prover":"Nuprl","tactic_proof":"Intro; ShannonSource; Auto","source":"nuprl_synthetic/information","theorem":"source_coding","id":88142,"goal":"all X:RandomVar, eps:PosReal. exists n:PosNat, C:Code. expected_length(C(X^n)) / n <= H(X) + eps","context":["Intro","ShannonSource","Auto"]} +{"prover":"Nuprl","tactic_proof":"Intros; QuotientEq; Auto","source":"nuprl_synthetic/quotient_types","theorem":"quotient_class","id":88143,"goal":"all A:Type, R:Equiv(A), x,y:A. R(x,y) => [x]_R = [y]_R","context":["Intros","QuotientEq","Auto"]} +{"prover":"Nuprl","tactic_proof":"Intros; QuotientLift; Auto","source":"nuprl_synthetic/quotient_types","theorem":"quotient_lift","id":88144,"goal":"all A,B:Type, R:Equiv(A), f:A->B. (all x,y:A. R(x,y) => f(x) = f(y)) => A/R -> B","context":["Intros","QuotientLift","Auto"]} +{"prover":"Nuprl","tactic_proof":"Intro; Bijection; Auto","source":"nuprl_synthetic/quotient_types","theorem":"nat_quot_modp","id":88145,"goal":"all p:PosNat. Nat/cong(p) ~ Fin(p)","context":["Intro","Bijection","Auto"]} +{"prover":"Nuprl","tactic_proof":"Intro; Partition; Auto","source":"nuprl_synthetic/quotient_types","theorem":"partition_quotient","id":88146,"goal":"all A:Type, R:Equiv(A). partition(A, R) <=> A/R","context":["Intro","Partition","Auto"]} +{"prover":"Nuprl","tactic_proof":"Intro; Morphism; Auto","source":"nuprl_synthetic/quotient_types","theorem":"setoid_morphism","id":88147,"goal":"all A,B:Setoid, f:A->B. morphism(f) <=> (all x,y:A. eq_A(x,y) => eq_B(f(x), f(y)))","context":["Intro","Morphism","Auto"]} +{"prover":"Nuprl","tactic_proof":"Intros; WType; Auto","source":"nuprl_synthetic/w_types","theorem":"w_type","id":88148,"goal":"all A:Type, B:A->Type. W(A, B) : Type","context":["Intros","WType","Auto"]} +{"prover":"Nuprl","tactic_proof":"Intros; WInduction; Auto","source":"nuprl_synthetic/w_types","theorem":"w_induction","id":88149,"goal":"all A:Type, B:A->Type, P:W(A,B)->Prop. (all a:A, f:B(a)->W(A,B). (all b:B(a). P(f(b))) => P(sup(a, f))) => all w:W(A,B). P(w)","context":["Intros","WInduction","Auto"]} +{"prover":"Nuprl","tactic_proof":"Intro; Bijection; Auto","source":"nuprl_synthetic/w_types","theorem":"w_nat_iso","id":88150,"goal":"Nat ~ W(Bool, lambda b. if b then Unit else Empty)","context":["Intro","Bijection","Auto"]} +{"prover":"Nuprl","tactic_proof":"Intro; Bijection; Auto","source":"nuprl_synthetic/w_types","theorem":"w_list_iso","id":88151,"goal":"all A:Type. List(A) ~ W(1 + A, lambda s. match s with inl _ => Empty | inr _ => Unit)","context":["Intro","Bijection","Auto"]} diff --git a/training_data/proof_states_twelf.jsonl b/training_data/proof_states_twelf.jsonl index 5753c85..2ca80d0 100644 --- a/training_data/proof_states_twelf.jsonl +++ b/training_data/proof_states_twelf.jsonl @@ -1,118 +1,118 @@ -{"id":89000,"prover":"Twelf","theorem":"nat","goal":"nat : type.","context":["nat"],"tactic_proof":"z : nat.\ns : nat -> nat.","source":"twelf_synthetic/natural_numbers"} -{"id":89001,"prover":"Twelf","theorem":"plus","goal":"plus : nat -> nat -> nat -> type.","context":["plus"],"tactic_proof":"plus-z : plus z N N.\nplus-s : plus (s M) N (s P) <- plus M N P.","source":"twelf_synthetic/natural_numbers"} -{"id":89002,"prover":"Twelf","theorem":"plus_comm","goal":"plus-comm : plus M N P -> plus N M P -> type.","context":["plus-comm"],"tactic_proof":"plus-comm-z : plus-comm plus-z D <- plus-zero-right D.\nplus-comm-s : plus-comm (plus-s D1) D2 <- plus-comm D1 D3 <- plus-succ-right D3 D2.","source":"twelf_synthetic/natural_numbers"} -{"id":89003,"prover":"Twelf","theorem":"plus_assoc","goal":"plus-assoc : plus A B AB -> plus AB C ABC -> plus B C BC -> plus A BC ABC -> type.","context":["plus-assoc"],"tactic_proof":"%mode plus-assoc +D1 +D2 -D3 -D4.","source":"twelf_synthetic/natural_numbers"} -{"id":89004,"prover":"Twelf","theorem":"times","goal":"times : nat -> nat -> nat -> type.","context":["times"],"tactic_proof":"times-z : times z N z.\ntimes-s : times (s M) N P <- times M N Q <- plus N Q P.","source":"twelf_synthetic/natural_numbers"} -{"id":89005,"prover":"Twelf","theorem":"leq","goal":"leq : nat -> nat -> type.","context":["leq"],"tactic_proof":"leq-z : leq z N.\nleq-s : leq (s M) (s N) <- leq M N.","source":"twelf_synthetic/natural_numbers"} -{"id":89006,"prover":"Twelf","theorem":"leq_refl","goal":"leq-refl : {N:nat} leq N N -> type.","context":["leq-refl","N"],"tactic_proof":"leq-refl-z : leq-refl z leq-z.\nleq-refl-s : leq-refl (s N) (leq-s D) <- leq-refl N D.","source":"twelf_synthetic/natural_numbers"} -{"id":89007,"prover":"Twelf","theorem":"leq_trans","goal":"leq-trans : leq A B -> leq B C -> leq A C -> type.","context":["leq-trans"],"tactic_proof":"%mode leq-trans +D1 +D2 -D3.","source":"twelf_synthetic/natural_numbers"} -{"id":89008,"prover":"Twelf","theorem":"max","goal":"max : nat -> nat -> nat -> type.","context":["max"],"tactic_proof":"max-zl : max z N N.\nmax-zr : max N z N.\nmax-ss : max (s M) (s N) (s P) <- max M N P.","source":"twelf_synthetic/natural_numbers"} -{"id":89009,"prover":"Twelf","theorem":"even_odd","goal":"even : nat -> type.\nodd : nat -> type.","context":["even","odd"],"tactic_proof":"even-z : even z.\neven-s : even (s N) <- odd N.\nodd-s : odd (s N) <- even N.","source":"twelf_synthetic/natural_numbers"} -{"id":89010,"prover":"Twelf","theorem":"tp","goal":"tp : type.","context":["tp"],"tactic_proof":"arr : tp -> tp -> tp.\nunit : tp.","source":"twelf_synthetic/lambda_calculus"} -{"id":89011,"prover":"Twelf","theorem":"tm","goal":"tm : type.","context":["tm"],"tactic_proof":"app : tm -> tm -> tm.\nlam : tp -> (tm -> tm) -> tm.\nempty : tm.","source":"twelf_synthetic/lambda_calculus"} -{"id":89012,"prover":"Twelf","theorem":"of","goal":"of : tm -> tp -> type.","context":["of"],"tactic_proof":"of-app : of (app E1 E2) T <- of E1 (arr T2 T) <- of E2 T2.\nof-lam : of (lam T1 E) (arr T1 T2) <- ({x:tm} of x T1 -> of (E x) T2).\nof-empty : of empty unit.","source":"twelf_synthetic/lambda_calculus"} -{"id":89013,"prover":"Twelf","theorem":"value","goal":"value : tm -> type.","context":["value"],"tactic_proof":"value-lam : value (lam T E).\nvalue-empty : value empty.","source":"twelf_synthetic/lambda_calculus"} -{"id":89014,"prover":"Twelf","theorem":"step","goal":"step : tm -> tm -> type.","context":["step"],"tactic_proof":"step-app1 : step (app E1 E2) (app E1' E2) <- step E1 E1'.\nstep-app2 : step (app V E2) (app V E2') <- value V <- step E2 E2'.\nstep-beta : step (app (lam T E) V) (E V) <- value V.","source":"twelf_synthetic/lambda_calculus"} -{"id":89015,"prover":"Twelf","theorem":"preservation","goal":"preservation : of E T -> step E E' -> of E' T -> type.","context":["preservation"],"tactic_proof":"%mode preservation +Dof +Dstep -Dof'.\npreservation-app1 : preservation (of-app D1 D2) (step-app1 S) (of-app D1' D2) <- preservation D1 S D1'.\npreservation-beta : preservation (of-app (of-lam D1) D2) (step-beta V) (D1 _ D2).","source":"twelf_synthetic/lambda_calculus"} -{"id":89016,"prover":"Twelf","theorem":"progress","goal":"progress : of E T -> (value E + step E E') -> type.","context":["progress"],"tactic_proof":"%mode progress +Dof -Dresult.","source":"twelf_synthetic/lambda_calculus"} -{"id":89017,"prover":"Twelf","theorem":"subst","goal":"subst : (tm -> tm) -> tm -> tm -> type.","context":["subst"],"tactic_proof":"subst-var : subst ([x] x) V V.\nsubst-const : subst ([x] C) V C.\nsubst-app : subst ([x] app (E1 x) (E2 x)) V (app E1' E2') <- subst E1 V E1' <- subst E2 V E2'.\nsubst-lam : subst ([x] lam T ([y] E x y)) V (lam T E') <- ({y:tm} subst ([x] E x y) V (E' y)).","source":"twelf_synthetic/lambda_calculus"} -{"id":89018,"prover":"Twelf","theorem":"list","goal":"list : type.","context":["list"],"tactic_proof":"nil : list.\ncons : nat -> list -> list.","source":"twelf_synthetic/lists"} -{"id":89019,"prover":"Twelf","theorem":"append","goal":"append : list -> list -> list -> type.","context":["append"],"tactic_proof":"append-nil : append nil L L.\nappend-cons : append (cons H T) L (cons H R) <- append T L R.","source":"twelf_synthetic/lists"} -{"id":89020,"prover":"Twelf","theorem":"append_assoc","goal":"append-assoc : append L1 L2 L12 -> append L12 L3 L123 -> append L2 L3 L23 -> append L1 L23 L123 -> type.","context":["append-assoc"],"tactic_proof":"%mode append-assoc +D1 +D2 -D3 -D4.","source":"twelf_synthetic/lists"} -{"id":89021,"prover":"Twelf","theorem":"reverse","goal":"reverse : list -> list -> type.","context":["reverse"],"tactic_proof":"reverse-nil : reverse nil nil.\nreverse-cons : reverse (cons H T) R <- reverse T T' <- append T' (cons H nil) R.","source":"twelf_synthetic/lists"} -{"id":89022,"prover":"Twelf","theorem":"length","goal":"length : list -> nat -> type.","context":["length"],"tactic_proof":"length-nil : length nil z.\nlength-cons : length (cons H T) (s N) <- length T N.","source":"twelf_synthetic/lists"} -{"id":89023,"prover":"Twelf","theorem":"member","goal":"member : nat -> list -> type.","context":["member"],"tactic_proof":"member-head : member X (cons X L).\nmember-tail : member X (cons Y L) <- member X L.","source":"twelf_synthetic/lists"} -{"id":89024,"prover":"Twelf","theorem":"sorted","goal":"sorted : list -> type.","context":["sorted"],"tactic_proof":"sorted-nil : sorted nil.\nsorted-one : sorted (cons X nil).\nsorted-cons : sorted (cons X (cons Y L)) <- leq X Y <- sorted (cons Y L).","source":"twelf_synthetic/lists"} -{"id":89025,"prover":"Twelf","theorem":"insert_sorted","goal":"insert : nat -> list -> list -> type.","context":["insert"],"tactic_proof":"insert-nil : insert X nil (cons X nil).\ninsert-leq : insert X (cons Y L) (cons X (cons Y L)) <- leq X Y.\ninsert-gt : insert X (cons Y L) (cons Y L') <- insert X L L'.","source":"twelf_synthetic/lists"} -{"id":89026,"prover":"Twelf","theorem":"prop","goal":"o : type.","context":["o"],"tactic_proof":"imp : o -> o -> o.\nand : o -> o -> o.\nor : o -> o -> o.\nnot : o -> o.\nforall : (i -> o) -> o.\nexists : (i -> o) -> o.","source":"twelf_synthetic/logic_framework"} -{"id":89027,"prover":"Twelf","theorem":"pf","goal":"pf : o -> type.","context":["pf"],"tactic_proof":"imp-i : ({x:pf A} pf B) -> pf (imp A B).\nimp-e : pf (imp A B) -> pf A -> pf B.\nand-i : pf A -> pf B -> pf (and A B).\nand-e1 : pf (and A B) -> pf A.\nand-e2 : pf (and A B) -> pf B.\nor-i1 : pf A -> pf (or A B).\nor-i2 : pf B -> pf (or A B).\nor-e : pf (or A B) -> ({x:pf A} pf C) -> ({x:pf B} pf C) -> pf C.\nnot-i : ({x:pf A} pf false) -> pf (not A).\nnot-e : pf (not A) -> pf A -> pf false.\nforall-i : ({x:i} pf (A x)) -> pf (forall A).\nforall-e : pf (forall A) -> {T:i} pf (A T).\nexists-i : {T:i} pf (A T) -> pf (exists A).\nexists-e : pf (exists A) -> ({x:i} {y:pf (A x)} pf C) -> pf C.","source":"twelf_synthetic/logic_framework"} -{"id":89028,"prover":"Twelf","theorem":"and_comm_pf","goal":"and-comm : pf (imp (and A B) (and B A)).","context":["and-comm"],"tactic_proof":"and-comm = imp-i ([h:pf (and A B)] and-i (and-e2 h) (and-e1 h)).","source":"twelf_synthetic/logic_framework"} -{"id":89029,"prover":"Twelf","theorem":"or_comm_pf","goal":"or-comm : pf (imp (or A B) (or B A)).","context":["or-comm"],"tactic_proof":"or-comm = imp-i ([h:pf (or A B)] or-e h ([a] or-i2 a) ([b] or-i1 b)).","source":"twelf_synthetic/logic_framework"} -{"id":89030,"prover":"Twelf","theorem":"modus_ponens_pf","goal":"mp : pf A -> pf (imp A B) -> pf B.","context":["mp"],"tactic_proof":"mp = [a:pf A] [f:pf (imp A B)] imp-e f a.","source":"twelf_synthetic/logic_framework"} -{"id":89031,"prover":"Twelf","theorem":"double_neg_intro_pf","goal":"dn-intro : pf (imp A (not (not A))).","context":["dn-intro"],"tactic_proof":"dn-intro = imp-i ([a:pf A] not-i ([h:pf (not A)] not-e h a)).","source":"twelf_synthetic/logic_framework"} -{"id":89032,"prover":"Twelf","theorem":"contra_pf","goal":"contra : pf (imp (imp A B) (imp (not B) (not A))).","context":["contra"],"tactic_proof":"contra = imp-i ([f:pf (imp A B)] imp-i ([nb:pf (not B)] not-i ([a:pf A] not-e nb (imp-e f a)))).","source":"twelf_synthetic/logic_framework"} -{"id":89033,"prover":"Twelf","theorem":"tree","goal":"tree : type.","context":["tree"],"tactic_proof":"empty : tree.\nnode : nat -> tree -> tree -> tree.","source":"twelf_synthetic/binary_trees"} -{"id":89034,"prover":"Twelf","theorem":"insert_bst","goal":"insert : nat -> tree -> tree -> type.","context":["insert"],"tactic_proof":"insert-empty : insert X empty (node X empty empty).\ninsert-lt : insert X (node Y L R) (node Y L' R) <- leq X Y <- insert X L L'.\ninsert-gt : insert X (node Y L R) (node Y L R') <- leq Y X <- insert X R R'.","source":"twelf_synthetic/binary_trees"} -{"id":89035,"prover":"Twelf","theorem":"tree_size","goal":"tree-size : tree -> nat -> type.","context":["tree-size"],"tactic_proof":"tree-size-empty : tree-size empty z.\ntree-size-node : tree-size (node X L R) (s N) <- tree-size L NL <- tree-size R NR <- plus NL NR N.","source":"twelf_synthetic/binary_trees"} -{"id":89036,"prover":"Twelf","theorem":"tree_height","goal":"tree-height : tree -> nat -> type.","context":["tree-height"],"tactic_proof":"tree-height-empty : tree-height empty z.\ntree-height-node : tree-height (node X L R) (s H) <- tree-height L HL <- tree-height R HR <- max HL HR H.","source":"twelf_synthetic/binary_trees"} -{"id":89037,"prover":"Twelf","theorem":"tree_member","goal":"tree-member : nat -> tree -> type.","context":["tree-member"],"tactic_proof":"tree-member-node : tree-member X (node X L R).\ntree-member-left : tree-member X (node Y L R) <- tree-member X L.\ntree-member-right : tree-member X (node Y L R) <- tree-member X R.","source":"twelf_synthetic/binary_trees"} -{"id":89038,"prover":"Twelf","theorem":"tree_mirror","goal":"mirror : tree -> tree -> type.","context":["mirror"],"tactic_proof":"mirror-empty : mirror empty empty.\nmirror-node : mirror (node X L R) (node X R' L') <- mirror L L' <- mirror R R'.","source":"twelf_synthetic/binary_trees"} -{"id":89039,"prover":"Twelf","theorem":"mirror_involutive","goal":"mirror-involutive : mirror T T' -> mirror T' T -> type.","context":["mirror-involutive"],"tactic_proof":"%mode mirror-involutive +D1 -D2.","source":"twelf_synthetic/binary_trees"} -{"id":89040,"prover":"Twelf","theorem":"inorder_flatten","goal":"inorder : tree -> list -> type.","context":["inorder"],"tactic_proof":"inorder-empty : inorder empty nil.\ninorder-node : inorder (node X L R) M <- inorder L ML <- inorder R MR <- append ML (cons X MR) M.","source":"twelf_synthetic/binary_trees"} -{"id":89041,"prover":"Twelf","theorem":"substitution","goal":"subst' : (tm -> tm) -> tm -> tm -> type.","context":[],"tactic_proof":"subst'-id : subst' ([x] x) V V.\nsubst'-const : subst' ([x] C) V C.","source":"twelf_synthetic/substitution"} -{"id":89042,"prover":"Twelf","theorem":"capture_avoid","goal":"fresh : tm -> (tm -> tm) -> type.","context":["fresh"],"tactic_proof":"fresh-const : fresh V ([x] C).\nfresh-app : fresh V ([x] app (E1 x) (E2 x)) <- fresh V E1 <- fresh V E2.","source":"twelf_synthetic/substitution"} -{"id":89043,"prover":"Twelf","theorem":"alpha_eq","goal":"alpha-eq : tm -> tm -> type.","context":["alpha-eq"],"tactic_proof":"alpha-eq-refl : alpha-eq E E.\nalpha-eq-lam : alpha-eq (lam T ([x] E x)) (lam T ([y] E y)) <- ({x} alpha-eq (E x) (E x)).","source":"twelf_synthetic/substitution"} -{"id":89044,"prover":"Twelf","theorem":"beta_red","goal":"beta-red : tm -> tm -> type.","context":["beta-red"],"tactic_proof":"beta-red-step : beta-red (app (lam T E) V) (E V) <- value V.","source":"twelf_synthetic/substitution"} -{"id":89045,"prover":"Twelf","theorem":"eta_red","goal":"eta-red : tm -> tm -> type.","context":["eta-red"],"tactic_proof":"eta-red-step : eta-red (lam T ([x] app E x)) E.","source":"twelf_synthetic/substitution"} -{"id":89046,"prover":"Twelf","theorem":"subst_lemma","goal":"subst-lemma : subst' E1 V1 E1' -> subst' E2 V2 E2' -> subst' ([x] E1 x) V1 E1'' -> type.","context":["subst-lemma"],"tactic_proof":"%mode subst-lemma +D1 +D2 +D3.","source":"twelf_synthetic/substitution"} -{"id":89047,"prover":"Twelf","theorem":"channel","goal":"chan : type.","context":["chan"],"tactic_proof":"new-chan : chan.","source":"twelf_synthetic/session_types"} -{"id":89048,"prover":"Twelf","theorem":"msg_type","goal":"msg : type.","context":["msg"],"tactic_proof":"unit-msg : msg.\nsum-msg : msg -> msg -> msg.","source":"twelf_synthetic/session_types"} -{"id":89049,"prover":"Twelf","theorem":"protocol","goal":"proto : type.","context":["proto"],"tactic_proof":"send-proto : msg -> proto -> proto.\nrecv-proto : msg -> proto -> proto.\nend-proto : proto.","source":"twelf_synthetic/session_types"} -{"id":89050,"prover":"Twelf","theorem":"duality","goal":"dual : proto -> proto -> type.","context":["dual"],"tactic_proof":"dual-end : dual end-proto end-proto.\ndual-send : dual (send-proto M P) (recv-proto M Q) <- dual P Q.\ndual-recv : dual (recv-proto M P) (send-proto M Q) <- dual P Q.","source":"twelf_synthetic/session_types"} -{"id":89051,"prover":"Twelf","theorem":"session_safe","goal":"session-safe : chan -> proto -> type.","context":["session-safe"],"tactic_proof":"%mode session-safe +C +P.","source":"twelf_synthetic/session_types"} -{"id":89052,"prover":"Twelf","theorem":"linear_use","goal":"linear : chan -> type.","context":["linear"],"tactic_proof":"linear-new : linear C <- new-chan.","source":"twelf_synthetic/session_types"} -{"id":89053,"prover":"Twelf","theorem":"linear_type","goal":"ltp : type.","context":["ltp"],"tactic_proof":"lolli : ltp -> ltp -> ltp.\ntensor : ltp -> ltp -> ltp.\nwith-type : ltp -> ltp -> ltp.\none-type : ltp.","source":"twelf_synthetic/linear_lf"} -{"id":89054,"prover":"Twelf","theorem":"linear_tm","goal":"ltm : type.","context":["ltm"],"tactic_proof":"lapp : ltm -> ltm -> ltm.\nllam : ltp -> (ltm -> ltm) -> ltm.\npair-ltm : ltm -> ltm -> ltm.\nunit-ltm : ltm.","source":"twelf_synthetic/linear_lf"} -{"id":89055,"prover":"Twelf","theorem":"linear_of","goal":"lof : ltm -> ltp -> type.","context":["lof"],"tactic_proof":"lof-lam : lof (llam T1 E) (lolli T1 T2) <- ({x:ltm} lof x T1 -> lof (E x) T2).\nlof-pair : lof (pair-ltm E1 E2) (tensor T1 T2) <- lof E1 T1 <- lof E2 T2.\nlof-unit : lof unit-ltm one-type.","source":"twelf_synthetic/linear_lf"} -{"id":89056,"prover":"Twelf","theorem":"linear_safety","goal":"linear-safety : lof E T -> step E E' -> lof E' T -> type.","context":["linear-safety"],"tactic_proof":"%mode linear-safety +D1 +D2 -D3.","source":"twelf_synthetic/linear_lf"} -{"id":89057,"prover":"Twelf","theorem":"linear_single","goal":"linear-single : ltm -> type.","context":["linear-single"],"tactic_proof":"linear-single-var : linear-single (var X).\nlinear-single-app : linear-single (lapp E1 E2) <- linear-single E1 <- linear-single E2.","source":"twelf_synthetic/linear_lf"} -{"id":89058,"prover":"Twelf","theorem":"weakening","goal":"weakening : of E T -> of E T -> type.","context":["weakening"],"tactic_proof":"%mode weakening +Dof -Dof'.","source":"twelf_synthetic/metatheory"} -{"id":89059,"prover":"Twelf","theorem":"type_unique","goal":"type-unique : of E T1 -> of E T2 -> eq T1 T2 -> type.","context":["type-unique"],"tactic_proof":"%mode type-unique +D1 +D2 -D3.","source":"twelf_synthetic/metatheory"} -{"id":89060,"prover":"Twelf","theorem":"canonical_forms","goal":"canonical : value V -> of V T -> type.","context":["canonical"],"tactic_proof":"%mode canonical +Dv +Dof.","source":"twelf_synthetic/metatheory"} -{"id":89061,"prover":"Twelf","theorem":"progress_lemma","goal":"progress-lemma : of E T -> (value E + step E E') -> type.","context":["progress-lemma"],"tactic_proof":"%mode progress-lemma +Dof -Dresult.","source":"twelf_synthetic/metatheory"} -{"id":89062,"prover":"Twelf","theorem":"preservation_lemma","goal":"preservation-lemma : of E T -> step E E' -> of E' T -> type.","context":["preservation-lemma"],"tactic_proof":"%mode preservation-lemma +Dof +Dstep -Dof'.","source":"twelf_synthetic/metatheory"} -{"id":89063,"prover":"Twelf","theorem":"normalization","goal":"strong-norm : of E T -> type.","context":["strong-norm"],"tactic_proof":"%mode strong-norm +Dof.","source":"twelf_synthetic/metatheory"} -{"id":89064,"prover":"Twelf","theorem":"confluence","goal":"confluence : reduces E E1 -> reduces E E2 -> (reduces E1 E' /\\ reduces E2 E') -> type.","context":["confluence"],"tactic_proof":"%mode confluence +D1 +D2 -D3.","source":"twelf_synthetic/metatheory"} -{"id":89065,"prover":"Twelf","theorem":"forall_type","goal":"forall-tp : (tp -> tp) -> tp.","context":["forall-tp"],"tactic_proof":"forall-intro : of E (forall-tp A) <- ({X:tp} of E (A X)).\nforall-elim : of (tapp E T) (A T) <- of E (forall-tp A).","source":"twelf_synthetic/polymorphism"} -{"id":89066,"prover":"Twelf","theorem":"exists_type","goal":"exists-tp : (tp -> tp) -> tp.","context":["exists-tp"],"tactic_proof":"pack : of (pack T E) (exists-tp A) <- of E (A T).\nunpack : of (open E1 [X] [x] E2) C <- of E1 (exists-tp A) <- ({X:tp} {x:tm} of x (A X) -> of (E2 X x) C).","source":"twelf_synthetic/polymorphism"} -{"id":89067,"prover":"Twelf","theorem":"type_abstraction","goal":"tabs : tp -> (tp -> tm) -> tm.","context":["tabs"],"tactic_proof":"of-tabs : of (tabs K E) (forall-tp A) <- ({X:tp} of (E X) (A X)).","source":"twelf_synthetic/polymorphism"} -{"id":89068,"prover":"Twelf","theorem":"param_poly","goal":"parametricity : of E (forall-tp A) -> type.","context":["parametricity"],"tactic_proof":"%mode parametricity +D.","source":"twelf_synthetic/polymorphism"} -{"id":89069,"prover":"Twelf","theorem":"subtype","goal":"sub : tp -> tp -> type.","context":["sub"],"tactic_proof":"sub-refl : sub T T.\nsub-trans : sub T1 T3 <- sub T1 T2 <- sub T2 T3.\nsub-arrow : sub (arr S1 T1) (arr S2 T2) <- sub S2 S1 <- sub T1 T2.","source":"twelf_synthetic/polymorphism"} -{"id":89070,"prover":"Twelf","theorem":"module_signature","goal":"module-sig : type.","context":["module-sig"],"tactic_proof":"mk-sig : list -> module-sig.","source":"twelf_synthetic/modules"} -{"id":89071,"prover":"Twelf","theorem":"module_impl","goal":"module-impl : module-sig -> type.","context":["module-impl"],"tactic_proof":"mk-impl : list -> module-impl Sig.","source":"twelf_synthetic/modules"} -{"id":89072,"prover":"Twelf","theorem":"functor","goal":"functor : module-sig -> module-sig -> type.","context":["functor"],"tactic_proof":"apply-functor : functor S1 S2 -> module-impl S1 -> module-impl S2 -> type.","source":"twelf_synthetic/modules"} -{"id":89073,"prover":"Twelf","theorem":"abstract_type","goal":"abs-tp : type.","context":["abs-tp"],"tactic_proof":"pack-abs : tp -> (tp -> tp) -> abs-tp.\nopen-abs : abs-tp -> (tp -> tp -> tp) -> tp -> type.","source":"twelf_synthetic/modules"} -{"id":89074,"prover":"Twelf","theorem":"structure_eq","goal":"struct-eq : module-impl S -> module-impl S -> type.","context":["struct-eq"],"tactic_proof":"%mode struct-eq +M1 +M2.","source":"twelf_synthetic/modules"} -{"id":89075,"prover":"Twelf","theorem":"include_module","goal":"include : module-impl S1 -> module-impl S2 -> module-impl S3 -> type.","context":["include"],"tactic_proof":"%mode include +M1 +M2 -M3.","source":"twelf_synthetic/modules"} -{"id":89076,"prover":"Twelf","theorem":"record","goal":"record : type.","context":["record"],"tactic_proof":"empty-rec : record.\ncons-rec : label -> tm -> record -> record.","source":"twelf_synthetic/records_twelf"} -{"id":89077,"prover":"Twelf","theorem":"label","goal":"label : type.","context":["label"],"tactic_proof":"lab-a : label.\nlab-b : label.\nlab-c : label.","source":"twelf_synthetic/records_twelf"} -{"id":89078,"prover":"Twelf","theorem":"rec_lookup","goal":"lookup : label -> record -> tm -> type.","context":["lookup"],"tactic_proof":"lookup-head : lookup L (cons-rec L V R) V.\nlookup-tail : lookup L (cons-rec L' V R) V' <- lookup L R V'.","source":"twelf_synthetic/records_twelf"} -{"id":89079,"prover":"Twelf","theorem":"rec_update","goal":"update : label -> tm -> record -> record -> type.","context":["update"],"tactic_proof":"update-head : update L V (cons-rec L V' R) (cons-rec L V R).\nupdate-tail : update L V (cons-rec L' V' R) (cons-rec L' V' R') <- update L V R R'.","source":"twelf_synthetic/records_twelf"} -{"id":89080,"prover":"Twelf","theorem":"rec_concat","goal":"rec-concat : record -> record -> record -> type.","context":["rec-concat"],"tactic_proof":"rec-concat-nil : rec-concat empty-rec R R.\nrec-concat-cons : rec-concat (cons-rec L V R1) R2 (cons-rec L V R3) <- rec-concat R1 R2 R3.","source":"twelf_synthetic/records_twelf"} -{"id":89081,"prover":"Twelf","theorem":"trace","goal":"trace : type.","context":["trace"],"tactic_proof":"empty-trace : trace.\nstep-trace : tm -> tm -> trace -> trace.","source":"twelf_synthetic/traces"} -{"id":89082,"prover":"Twelf","theorem":"trace_step","goal":"trace-step : trace -> tm -> tm -> type.","context":["trace-step"],"tactic_proof":"%mode trace-step +T +E -E'.","source":"twelf_synthetic/traces"} -{"id":89083,"prover":"Twelf","theorem":"trace_append","goal":"trace-append : trace -> trace -> trace -> type.","context":["trace-append"],"tactic_proof":"trace-app-nil : trace-append empty-trace T T.\ntrace-app-cons : trace-append (step-trace E1 E2 T1) T2 (step-trace E1 E2 T3) <- trace-append T1 T2 T3.","source":"twelf_synthetic/traces"} -{"id":89084,"prover":"Twelf","theorem":"evaluates","goal":"evaluates : tm -> tm -> type.","context":["evaluates"],"tactic_proof":"eval-refl : evaluates E E.\neval-step : evaluates E E'' <- step E E' <- evaluates E' E''.","source":"twelf_synthetic/traces"} -{"id":89085,"prover":"Twelf","theorem":"multistep","goal":"multistep : tm -> tm -> trace -> type.","context":["multistep"],"tactic_proof":"multistep-refl : multistep E E empty-trace.\nmultistep-step : multistep E E'' (step-trace E E' T) <- step E E' <- multistep E' E'' T.","source":"twelf_synthetic/traces"} -{"id":89086,"prover":"Twelf","theorem":"bigstep","goal":"bigstep : tm -> tm -> type.","context":["bigstep"],"tactic_proof":"bigstep-val : bigstep V V <- value V.\nbigstep-app : bigstep (app E1 E2) V <- bigstep E1 (lam T E) <- bigstep E2 V2 <- bigstep (E V2) V.","source":"twelf_synthetic/bigstep"} -{"id":89087,"prover":"Twelf","theorem":"bigstep_det","goal":"bigstep-det : bigstep E V1 -> bigstep E V2 -> eq V1 V2 -> type.","context":["bigstep-det"],"tactic_proof":"%mode bigstep-det +D1 +D2 -D3.","source":"twelf_synthetic/bigstep"} -{"id":89088,"prover":"Twelf","theorem":"bigstep_value","goal":"bigstep-value : bigstep E V -> value V -> type.","context":["bigstep-value"],"tactic_proof":"%mode bigstep-value +D -Dv.","source":"twelf_synthetic/bigstep"} -{"id":89089,"prover":"Twelf","theorem":"bigstep_of","goal":"bigstep-of : bigstep E V -> of E T -> of V T -> type.","context":["bigstep-of"],"tactic_proof":"%mode bigstep-of +D1 +D2 -D3.","source":"twelf_synthetic/bigstep"} -{"id":89090,"prover":"Twelf","theorem":"bigstep_smallstep","goal":"bigstep-smallstep : bigstep E V -> multistep E V _ -> type.","context":["bigstep-smallstep"],"tactic_proof":"%mode bigstep-smallstep +D1 -D2.","source":"twelf_synthetic/bigstep"} -{"id":89091,"prover":"Twelf","theorem":"hoas_abs","goal":"habs : (tm -> tm) -> tm.","context":["habs"],"tactic_proof":"habs-intro : of (habs E) (arr T1 T2) <- ({x:tm} of x T1 -> of (E x) T2).","source":"twelf_synthetic/hoas"} -{"id":89092,"prover":"Twelf","theorem":"hoas_app","goal":"happ : tm -> tm -> tm.","context":["happ"],"tactic_proof":"happ-intro : of (happ E1 E2) T2 <- of E1 (arr T1 T2) <- of E2 T1.","source":"twelf_synthetic/hoas"} -{"id":89093,"prover":"Twelf","theorem":"hoas_beta","goal":"hstep : tm -> tm -> type.","context":["hstep"],"tactic_proof":"hstep-beta : hstep (happ (habs E) V) (E V) <- value V.","source":"twelf_synthetic/hoas"} -{"id":89094,"prover":"Twelf","theorem":"hoas_subst","goal":"hsubst : (tm -> tm) -> tm -> tm -> type.","context":["hsubst"],"tactic_proof":"%mode hsubst +E +V -E'.","source":"twelf_synthetic/hoas"} -{"id":89095,"prover":"Twelf","theorem":"parametric_hoas","goal":"phabs : (tm -> tm) -> tm.","context":["phabs"],"tactic_proof":"%block phabs-block : block {x:tm}.","source":"twelf_synthetic/hoas"} -{"id":89096,"prover":"Twelf","theorem":"token","goal":"token : type.","context":["token"],"tactic_proof":"tok-ident : string -> token.\ntok-num : nat -> token.\ntok-lparen : token.\ntok-rparen : token.\ntok-plus : token.\ntok-times : token.","source":"twelf_synthetic/parsing"} -{"id":89097,"prover":"Twelf","theorem":"parse_expr","goal":"parse : list -> tm -> list -> type.","context":["parse"],"tactic_proof":"%mode parse +Input -Result -Rest.","source":"twelf_synthetic/parsing"} -{"id":89098,"prover":"Twelf","theorem":"lex","goal":"lex : string -> list -> type.","context":["lex"],"tactic_proof":"%mode lex +Input -Tokens.","source":"twelf_synthetic/parsing"} -{"id":89099,"prover":"Twelf","theorem":"ast","goal":"ast : type.","context":["ast"],"tactic_proof":"ast-num : nat -> ast.\nast-var : string -> ast.\nast-bin : op -> ast -> ast -> ast.","source":"twelf_synthetic/parsing"} -{"id":89100,"prover":"Twelf","theorem":"op","goal":"op : type.","context":["op"],"tactic_proof":"op-add : op.\nop-sub : op.\nop-mul : op.\nop-div : op.","source":"twelf_synthetic/parsing"} -{"id":89101,"prover":"Twelf","theorem":"grammar","goal":"grammar-rule : type.","context":["grammar-rule"],"tactic_proof":"gr-term : symbol -> grammar-rule.\ngr-alt : grammar-rule -> grammar-rule -> grammar-rule.\ngr-seq : grammar-rule -> grammar-rule -> grammar-rule.","source":"twelf_synthetic/parsing"} -{"id":89102,"prover":"Twelf","theorem":"dfa_state","goal":"state : type.","context":["state"],"tactic_proof":"init-state : state.\ntrans-state : state -> char -> state.","source":"twelf_synthetic/automata"} -{"id":89103,"prover":"Twelf","theorem":"dfa_accept","goal":"accepts : dfa -> string -> type.","context":["accepts"],"tactic_proof":"%mode accepts +D +S.","source":"twelf_synthetic/automata"} -{"id":89104,"prover":"Twelf","theorem":"nfa_run","goal":"nfa-run : nfa -> list -> state -> type.","context":["nfa-run"],"tactic_proof":"%mode nfa-run +N +S -Q.","source":"twelf_synthetic/automata"} -{"id":89105,"prover":"Twelf","theorem":"regex","goal":"regex : type.","context":["regex"],"tactic_proof":"re-char : char -> regex.\nre-concat : regex -> regex -> regex.\nre-alt : regex -> regex -> regex.\nre-star : regex -> regex.\nre-epsilon : regex.","source":"twelf_synthetic/automata"} -{"id":89106,"prover":"Twelf","theorem":"regex_match","goal":"re-match : regex -> string -> type.","context":["re-match"],"tactic_proof":"%mode re-match +R +S.","source":"twelf_synthetic/automata"} -{"id":89107,"prover":"Twelf","theorem":"pda","goal":"pda-state : type.","context":["pda-state"],"tactic_proof":"pda-init : pda-state.\npda-push : pda-state -> char -> stack -> pda-state.","source":"twelf_synthetic/automata"} -{"id":89108,"prover":"Twelf","theorem":"io_monad","goal":"io : type -> type.","context":["io"],"tactic_proof":"io-return : A -> io A.\nio-bind : io A -> (A -> io B) -> io B.","source":"twelf_synthetic/effects"} -{"id":89109,"prover":"Twelf","theorem":"state_monad","goal":"state-m : type -> type.","context":["state-m"],"tactic_proof":"state-return : A -> state-m A.\nstate-bind : state-m A -> (A -> state-m B) -> state-m B.\nstate-get : state-m state.\nstate-put : state -> state-m unit.","source":"twelf_synthetic/effects"} -{"id":89110,"prover":"Twelf","theorem":"exception","goal":"exc : type -> type.","context":["exc"],"tactic_proof":"exc-pure : A -> exc A.\nexc-raise : string -> exc A.\nexc-catch : exc A -> (string -> exc A) -> exc A.","source":"twelf_synthetic/effects"} -{"id":89111,"prover":"Twelf","theorem":"continuation","goal":"cont : type -> type -> type.","context":["cont"],"tactic_proof":"cont-pure : A -> cont A R.\ncont-callcc : ((A -> cont B R) -> cont A R) -> cont A R.","source":"twelf_synthetic/effects"} -{"id":89112,"prover":"Twelf","theorem":"free_monad","goal":"free : type -> type.","context":["free"],"tactic_proof":"free-pure : A -> free A.\nfree-op : op-sig -> (result -> free A) -> free A.","source":"twelf_synthetic/effects"} -{"id":89113,"prover":"Twelf","theorem":"add_zero_left","goal":"add-zero-left : {N:nat} plus z N N -> type.","context":["add-zero-left","N"],"tactic_proof":"%mode add-zero-left +N -D.\nadd-zero-left-z : add-zero-left z plus-z.\nadd-zero-left-s : add-zero-left (s N) plus-z <- add-zero-left N _.","source":"twelf_synthetic/numerics_twelf"} -{"id":89114,"prover":"Twelf","theorem":"add_zero_right","goal":"add-zero-right : {N:nat} plus N z N -> type.","context":["add-zero-right","N"],"tactic_proof":"%mode add-zero-right +N -D.\nadd-zero-right-z : add-zero-right z plus-z.\nadd-zero-right-s : add-zero-right (s N) (plus-s D) <- add-zero-right N D.","source":"twelf_synthetic/numerics_twelf"} -{"id":89115,"prover":"Twelf","theorem":"times_zero_right","goal":"times-zero-right : {N:nat} times N z z -> type.","context":["times-zero-right","N"],"tactic_proof":"%mode times-zero-right +N -D.","source":"twelf_synthetic/numerics_twelf"} -{"id":89116,"prover":"Twelf","theorem":"div_algorithm","goal":"div-mod : nat -> nat -> nat -> nat -> type.","context":["div-mod"],"tactic_proof":"div-mod-base : div-mod M N z M <- lt M N.\ndiv-mod-rec : div-mod M N (s Q) R <- leq N M <- sub M N M' <- div-mod M' N Q R.","source":"twelf_synthetic/numerics_twelf"} -{"id":89117,"prover":"Twelf","theorem":"gcd","goal":"gcd : nat -> nat -> nat -> type.","context":["gcd"],"tactic_proof":"gcd-zero : gcd M z M.\ngcd-rec : gcd M N G <- modulo M N R <- gcd N R G.","source":"twelf_synthetic/numerics_twelf"} +{"prover":"Twelf","tactic_proof":"z : nat.\ns : nat -> nat.","source":"twelf_synthetic/natural_numbers","theorem":"nat","id":89000,"goal":"nat : type.","context":["nat"]} +{"prover":"Twelf","tactic_proof":"plus-z : plus z N N.\nplus-s : plus (s M) N (s P) <- plus M N P.","source":"twelf_synthetic/natural_numbers","theorem":"plus","id":89001,"goal":"plus : nat -> nat -> nat -> type.","context":["plus"]} +{"prover":"Twelf","tactic_proof":"plus-comm-z : plus-comm plus-z D <- plus-zero-right D.\nplus-comm-s : plus-comm (plus-s D1) D2 <- plus-comm D1 D3 <- plus-succ-right D3 D2.","source":"twelf_synthetic/natural_numbers","theorem":"plus_comm","id":89002,"goal":"plus-comm : plus M N P -> plus N M P -> type.","context":["plus-comm"]} +{"prover":"Twelf","tactic_proof":"%mode plus-assoc +D1 +D2 -D3 -D4.","source":"twelf_synthetic/natural_numbers","theorem":"plus_assoc","id":89003,"goal":"plus-assoc : plus A B AB -> plus AB C ABC -> plus B C BC -> plus A BC ABC -> type.","context":["plus-assoc"]} +{"prover":"Twelf","tactic_proof":"times-z : times z N z.\ntimes-s : times (s M) N P <- times M N Q <- plus N Q P.","source":"twelf_synthetic/natural_numbers","theorem":"times","id":89004,"goal":"times : nat -> nat -> nat -> type.","context":["times"]} +{"prover":"Twelf","tactic_proof":"leq-z : leq z N.\nleq-s : leq (s M) (s N) <- leq M N.","source":"twelf_synthetic/natural_numbers","theorem":"leq","id":89005,"goal":"leq : nat -> nat -> type.","context":["leq"]} +{"prover":"Twelf","tactic_proof":"leq-refl-z : leq-refl z leq-z.\nleq-refl-s : leq-refl (s N) (leq-s D) <- leq-refl N D.","source":"twelf_synthetic/natural_numbers","theorem":"leq_refl","id":89006,"goal":"leq-refl : {N:nat} leq N N -> type.","context":["leq-refl","N"]} +{"prover":"Twelf","tactic_proof":"%mode leq-trans +D1 +D2 -D3.","source":"twelf_synthetic/natural_numbers","theorem":"leq_trans","id":89007,"goal":"leq-trans : leq A B -> leq B C -> leq A C -> type.","context":["leq-trans"]} +{"prover":"Twelf","tactic_proof":"max-zl : max z N N.\nmax-zr : max N z N.\nmax-ss : max (s M) (s N) (s P) <- max M N P.","source":"twelf_synthetic/natural_numbers","theorem":"max","id":89008,"goal":"max : nat -> nat -> nat -> type.","context":["max"]} +{"prover":"Twelf","tactic_proof":"even-z : even z.\neven-s : even (s N) <- odd N.\nodd-s : odd (s N) <- even N.","source":"twelf_synthetic/natural_numbers","theorem":"even_odd","id":89009,"goal":"even : nat -> type.\nodd : nat -> type.","context":["even","odd"]} +{"prover":"Twelf","tactic_proof":"arr : tp -> tp -> tp.\nunit : tp.","source":"twelf_synthetic/lambda_calculus","theorem":"tp","id":89010,"goal":"tp : type.","context":["tp"]} +{"prover":"Twelf","tactic_proof":"app : tm -> tm -> tm.\nlam : tp -> (tm -> tm) -> tm.\nempty : tm.","source":"twelf_synthetic/lambda_calculus","theorem":"tm","id":89011,"goal":"tm : type.","context":["tm"]} +{"prover":"Twelf","tactic_proof":"of-app : of (app E1 E2) T <- of E1 (arr T2 T) <- of E2 T2.\nof-lam : of (lam T1 E) (arr T1 T2) <- ({x:tm} of x T1 -> of (E x) T2).\nof-empty : of empty unit.","source":"twelf_synthetic/lambda_calculus","theorem":"of","id":89012,"goal":"of : tm -> tp -> type.","context":["of"]} +{"prover":"Twelf","tactic_proof":"value-lam : value (lam T E).\nvalue-empty : value empty.","source":"twelf_synthetic/lambda_calculus","theorem":"value","id":89013,"goal":"value : tm -> type.","context":["value"]} +{"prover":"Twelf","tactic_proof":"step-app1 : step (app E1 E2) (app E1' E2) <- step E1 E1'.\nstep-app2 : step (app V E2) (app V E2') <- value V <- step E2 E2'.\nstep-beta : step (app (lam T E) V) (E V) <- value V.","source":"twelf_synthetic/lambda_calculus","theorem":"step","id":89014,"goal":"step : tm -> tm -> type.","context":["step"]} +{"prover":"Twelf","tactic_proof":"%mode preservation +Dof +Dstep -Dof'.\npreservation-app1 : preservation (of-app D1 D2) (step-app1 S) (of-app D1' D2) <- preservation D1 S D1'.\npreservation-beta : preservation (of-app (of-lam D1) D2) (step-beta V) (D1 _ D2).","source":"twelf_synthetic/lambda_calculus","theorem":"preservation","id":89015,"goal":"preservation : of E T -> step E E' -> of E' T -> type.","context":["preservation"]} +{"prover":"Twelf","tactic_proof":"%mode progress +Dof -Dresult.","source":"twelf_synthetic/lambda_calculus","theorem":"progress","id":89016,"goal":"progress : of E T -> (value E + step E E') -> type.","context":["progress"]} +{"prover":"Twelf","tactic_proof":"subst-var : subst ([x] x) V V.\nsubst-const : subst ([x] C) V C.\nsubst-app : subst ([x] app (E1 x) (E2 x)) V (app E1' E2') <- subst E1 V E1' <- subst E2 V E2'.\nsubst-lam : subst ([x] lam T ([y] E x y)) V (lam T E') <- ({y:tm} subst ([x] E x y) V (E' y)).","source":"twelf_synthetic/lambda_calculus","theorem":"subst","id":89017,"goal":"subst : (tm -> tm) -> tm -> tm -> type.","context":["subst"]} +{"prover":"Twelf","tactic_proof":"nil : list.\ncons : nat -> list -> list.","source":"twelf_synthetic/lists","theorem":"list","id":89018,"goal":"list : type.","context":["list"]} +{"prover":"Twelf","tactic_proof":"append-nil : append nil L L.\nappend-cons : append (cons H T) L (cons H R) <- append T L R.","source":"twelf_synthetic/lists","theorem":"append","id":89019,"goal":"append : list -> list -> list -> type.","context":["append"]} +{"prover":"Twelf","tactic_proof":"%mode append-assoc +D1 +D2 -D3 -D4.","source":"twelf_synthetic/lists","theorem":"append_assoc","id":89020,"goal":"append-assoc : append L1 L2 L12 -> append L12 L3 L123 -> append L2 L3 L23 -> append L1 L23 L123 -> type.","context":["append-assoc"]} +{"prover":"Twelf","tactic_proof":"reverse-nil : reverse nil nil.\nreverse-cons : reverse (cons H T) R <- reverse T T' <- append T' (cons H nil) R.","source":"twelf_synthetic/lists","theorem":"reverse","id":89021,"goal":"reverse : list -> list -> type.","context":["reverse"]} +{"prover":"Twelf","tactic_proof":"length-nil : length nil z.\nlength-cons : length (cons H T) (s N) <- length T N.","source":"twelf_synthetic/lists","theorem":"length","id":89022,"goal":"length : list -> nat -> type.","context":["length"]} +{"prover":"Twelf","tactic_proof":"member-head : member X (cons X L).\nmember-tail : member X (cons Y L) <- member X L.","source":"twelf_synthetic/lists","theorem":"member","id":89023,"goal":"member : nat -> list -> type.","context":["member"]} +{"prover":"Twelf","tactic_proof":"sorted-nil : sorted nil.\nsorted-one : sorted (cons X nil).\nsorted-cons : sorted (cons X (cons Y L)) <- leq X Y <- sorted (cons Y L).","source":"twelf_synthetic/lists","theorem":"sorted","id":89024,"goal":"sorted : list -> type.","context":["sorted"]} +{"prover":"Twelf","tactic_proof":"insert-nil : insert X nil (cons X nil).\ninsert-leq : insert X (cons Y L) (cons X (cons Y L)) <- leq X Y.\ninsert-gt : insert X (cons Y L) (cons Y L') <- insert X L L'.","source":"twelf_synthetic/lists","theorem":"insert_sorted","id":89025,"goal":"insert : nat -> list -> list -> type.","context":["insert"]} +{"prover":"Twelf","tactic_proof":"imp : o -> o -> o.\nand : o -> o -> o.\nor : o -> o -> o.\nnot : o -> o.\nforall : (i -> o) -> o.\nexists : (i -> o) -> o.","source":"twelf_synthetic/logic_framework","theorem":"prop","id":89026,"goal":"o : type.","context":["o"]} +{"prover":"Twelf","tactic_proof":"imp-i : ({x:pf A} pf B) -> pf (imp A B).\nimp-e : pf (imp A B) -> pf A -> pf B.\nand-i : pf A -> pf B -> pf (and A B).\nand-e1 : pf (and A B) -> pf A.\nand-e2 : pf (and A B) -> pf B.\nor-i1 : pf A -> pf (or A B).\nor-i2 : pf B -> pf (or A B).\nor-e : pf (or A B) -> ({x:pf A} pf C) -> ({x:pf B} pf C) -> pf C.\nnot-i : ({x:pf A} pf false) -> pf (not A).\nnot-e : pf (not A) -> pf A -> pf false.\nforall-i : ({x:i} pf (A x)) -> pf (forall A).\nforall-e : pf (forall A) -> {T:i} pf (A T).\nexists-i : {T:i} pf (A T) -> pf (exists A).\nexists-e : pf (exists A) -> ({x:i} {y:pf (A x)} pf C) -> pf C.","source":"twelf_synthetic/logic_framework","theorem":"pf","id":89027,"goal":"pf : o -> type.","context":["pf"]} +{"prover":"Twelf","tactic_proof":"and-comm = imp-i ([h:pf (and A B)] and-i (and-e2 h) (and-e1 h)).","source":"twelf_synthetic/logic_framework","theorem":"and_comm_pf","id":89028,"goal":"and-comm : pf (imp (and A B) (and B A)).","context":["and-comm"]} +{"prover":"Twelf","tactic_proof":"or-comm = imp-i ([h:pf (or A B)] or-e h ([a] or-i2 a) ([b] or-i1 b)).","source":"twelf_synthetic/logic_framework","theorem":"or_comm_pf","id":89029,"goal":"or-comm : pf (imp (or A B) (or B A)).","context":["or-comm"]} +{"prover":"Twelf","tactic_proof":"mp = [a:pf A] [f:pf (imp A B)] imp-e f a.","source":"twelf_synthetic/logic_framework","theorem":"modus_ponens_pf","id":89030,"goal":"mp : pf A -> pf (imp A B) -> pf B.","context":["mp"]} +{"prover":"Twelf","tactic_proof":"dn-intro = imp-i ([a:pf A] not-i ([h:pf (not A)] not-e h a)).","source":"twelf_synthetic/logic_framework","theorem":"double_neg_intro_pf","id":89031,"goal":"dn-intro : pf (imp A (not (not A))).","context":["dn-intro"]} +{"prover":"Twelf","tactic_proof":"contra = imp-i ([f:pf (imp A B)] imp-i ([nb:pf (not B)] not-i ([a:pf A] not-e nb (imp-e f a)))).","source":"twelf_synthetic/logic_framework","theorem":"contra_pf","id":89032,"goal":"contra : pf (imp (imp A B) (imp (not B) (not A))).","context":["contra"]} +{"prover":"Twelf","tactic_proof":"empty : tree.\nnode : nat -> tree -> tree -> tree.","source":"twelf_synthetic/binary_trees","theorem":"tree","id":89033,"goal":"tree : type.","context":["tree"]} +{"prover":"Twelf","tactic_proof":"insert-empty : insert X empty (node X empty empty).\ninsert-lt : insert X (node Y L R) (node Y L' R) <- leq X Y <- insert X L L'.\ninsert-gt : insert X (node Y L R) (node Y L R') <- leq Y X <- insert X R R'.","source":"twelf_synthetic/binary_trees","theorem":"insert_bst","id":89034,"goal":"insert : nat -> tree -> tree -> type.","context":["insert"]} +{"prover":"Twelf","tactic_proof":"tree-size-empty : tree-size empty z.\ntree-size-node : tree-size (node X L R) (s N) <- tree-size L NL <- tree-size R NR <- plus NL NR N.","source":"twelf_synthetic/binary_trees","theorem":"tree_size","id":89035,"goal":"tree-size : tree -> nat -> type.","context":["tree-size"]} +{"prover":"Twelf","tactic_proof":"tree-height-empty : tree-height empty z.\ntree-height-node : tree-height (node X L R) (s H) <- tree-height L HL <- tree-height R HR <- max HL HR H.","source":"twelf_synthetic/binary_trees","theorem":"tree_height","id":89036,"goal":"tree-height : tree -> nat -> type.","context":["tree-height"]} +{"prover":"Twelf","tactic_proof":"tree-member-node : tree-member X (node X L R).\ntree-member-left : tree-member X (node Y L R) <- tree-member X L.\ntree-member-right : tree-member X (node Y L R) <- tree-member X R.","source":"twelf_synthetic/binary_trees","theorem":"tree_member","id":89037,"goal":"tree-member : nat -> tree -> type.","context":["tree-member"]} +{"prover":"Twelf","tactic_proof":"mirror-empty : mirror empty empty.\nmirror-node : mirror (node X L R) (node X R' L') <- mirror L L' <- mirror R R'.","source":"twelf_synthetic/binary_trees","theorem":"tree_mirror","id":89038,"goal":"mirror : tree -> tree -> type.","context":["mirror"]} +{"prover":"Twelf","tactic_proof":"%mode mirror-involutive +D1 -D2.","source":"twelf_synthetic/binary_trees","theorem":"mirror_involutive","id":89039,"goal":"mirror-involutive : mirror T T' -> mirror T' T -> type.","context":["mirror-involutive"]} +{"prover":"Twelf","tactic_proof":"inorder-empty : inorder empty nil.\ninorder-node : inorder (node X L R) M <- inorder L ML <- inorder R MR <- append ML (cons X MR) M.","source":"twelf_synthetic/binary_trees","theorem":"inorder_flatten","id":89040,"goal":"inorder : tree -> list -> type.","context":["inorder"]} +{"prover":"Twelf","tactic_proof":"subst'-id : subst' ([x] x) V V.\nsubst'-const : subst' ([x] C) V C.","source":"twelf_synthetic/substitution","theorem":"substitution","id":89041,"goal":"subst' : (tm -> tm) -> tm -> tm -> type.","context":[]} +{"prover":"Twelf","tactic_proof":"fresh-const : fresh V ([x] C).\nfresh-app : fresh V ([x] app (E1 x) (E2 x)) <- fresh V E1 <- fresh V E2.","source":"twelf_synthetic/substitution","theorem":"capture_avoid","id":89042,"goal":"fresh : tm -> (tm -> tm) -> type.","context":["fresh"]} +{"prover":"Twelf","tactic_proof":"alpha-eq-refl : alpha-eq E E.\nalpha-eq-lam : alpha-eq (lam T ([x] E x)) (lam T ([y] E y)) <- ({x} alpha-eq (E x) (E x)).","source":"twelf_synthetic/substitution","theorem":"alpha_eq","id":89043,"goal":"alpha-eq : tm -> tm -> type.","context":["alpha-eq"]} +{"prover":"Twelf","tactic_proof":"beta-red-step : beta-red (app (lam T E) V) (E V) <- value V.","source":"twelf_synthetic/substitution","theorem":"beta_red","id":89044,"goal":"beta-red : tm -> tm -> type.","context":["beta-red"]} +{"prover":"Twelf","tactic_proof":"eta-red-step : eta-red (lam T ([x] app E x)) E.","source":"twelf_synthetic/substitution","theorem":"eta_red","id":89045,"goal":"eta-red : tm -> tm -> type.","context":["eta-red"]} +{"prover":"Twelf","tactic_proof":"%mode subst-lemma +D1 +D2 +D3.","source":"twelf_synthetic/substitution","theorem":"subst_lemma","id":89046,"goal":"subst-lemma : subst' E1 V1 E1' -> subst' E2 V2 E2' -> subst' ([x] E1 x) V1 E1'' -> type.","context":["subst-lemma"]} +{"prover":"Twelf","tactic_proof":"new-chan : chan.","source":"twelf_synthetic/session_types","theorem":"channel","id":89047,"goal":"chan : type.","context":["chan"]} +{"prover":"Twelf","tactic_proof":"unit-msg : msg.\nsum-msg : msg -> msg -> msg.","source":"twelf_synthetic/session_types","theorem":"msg_type","id":89048,"goal":"msg : type.","context":["msg"]} +{"prover":"Twelf","tactic_proof":"send-proto : msg -> proto -> proto.\nrecv-proto : msg -> proto -> proto.\nend-proto : proto.","source":"twelf_synthetic/session_types","theorem":"protocol","id":89049,"goal":"proto : type.","context":["proto"]} +{"prover":"Twelf","tactic_proof":"dual-end : dual end-proto end-proto.\ndual-send : dual (send-proto M P) (recv-proto M Q) <- dual P Q.\ndual-recv : dual (recv-proto M P) (send-proto M Q) <- dual P Q.","source":"twelf_synthetic/session_types","theorem":"duality","id":89050,"goal":"dual : proto -> proto -> type.","context":["dual"]} +{"prover":"Twelf","tactic_proof":"%mode session-safe +C +P.","source":"twelf_synthetic/session_types","theorem":"session_safe","id":89051,"goal":"session-safe : chan -> proto -> type.","context":["session-safe"]} +{"prover":"Twelf","tactic_proof":"linear-new : linear C <- new-chan.","source":"twelf_synthetic/session_types","theorem":"linear_use","id":89052,"goal":"linear : chan -> type.","context":["linear"]} +{"prover":"Twelf","tactic_proof":"lolli : ltp -> ltp -> ltp.\ntensor : ltp -> ltp -> ltp.\nwith-type : ltp -> ltp -> ltp.\none-type : ltp.","source":"twelf_synthetic/linear_lf","theorem":"linear_type","id":89053,"goal":"ltp : type.","context":["ltp"]} +{"prover":"Twelf","tactic_proof":"lapp : ltm -> ltm -> ltm.\nllam : ltp -> (ltm -> ltm) -> ltm.\npair-ltm : ltm -> ltm -> ltm.\nunit-ltm : ltm.","source":"twelf_synthetic/linear_lf","theorem":"linear_tm","id":89054,"goal":"ltm : type.","context":["ltm"]} +{"prover":"Twelf","tactic_proof":"lof-lam : lof (llam T1 E) (lolli T1 T2) <- ({x:ltm} lof x T1 -> lof (E x) T2).\nlof-pair : lof (pair-ltm E1 E2) (tensor T1 T2) <- lof E1 T1 <- lof E2 T2.\nlof-unit : lof unit-ltm one-type.","source":"twelf_synthetic/linear_lf","theorem":"linear_of","id":89055,"goal":"lof : ltm -> ltp -> type.","context":["lof"]} +{"prover":"Twelf","tactic_proof":"%mode linear-safety +D1 +D2 -D3.","source":"twelf_synthetic/linear_lf","theorem":"linear_safety","id":89056,"goal":"linear-safety : lof E T -> step E E' -> lof E' T -> type.","context":["linear-safety"]} +{"prover":"Twelf","tactic_proof":"linear-single-var : linear-single (var X).\nlinear-single-app : linear-single (lapp E1 E2) <- linear-single E1 <- linear-single E2.","source":"twelf_synthetic/linear_lf","theorem":"linear_single","id":89057,"goal":"linear-single : ltm -> type.","context":["linear-single"]} +{"prover":"Twelf","tactic_proof":"%mode weakening +Dof -Dof'.","source":"twelf_synthetic/metatheory","theorem":"weakening","id":89058,"goal":"weakening : of E T -> of E T -> type.","context":["weakening"]} +{"prover":"Twelf","tactic_proof":"%mode type-unique +D1 +D2 -D3.","source":"twelf_synthetic/metatheory","theorem":"type_unique","id":89059,"goal":"type-unique : of E T1 -> of E T2 -> eq T1 T2 -> type.","context":["type-unique"]} +{"prover":"Twelf","tactic_proof":"%mode canonical +Dv +Dof.","source":"twelf_synthetic/metatheory","theorem":"canonical_forms","id":89060,"goal":"canonical : value V -> of V T -> type.","context":["canonical"]} +{"prover":"Twelf","tactic_proof":"%mode progress-lemma +Dof -Dresult.","source":"twelf_synthetic/metatheory","theorem":"progress_lemma","id":89061,"goal":"progress-lemma : of E T -> (value E + step E E') -> type.","context":["progress-lemma"]} +{"prover":"Twelf","tactic_proof":"%mode preservation-lemma +Dof +Dstep -Dof'.","source":"twelf_synthetic/metatheory","theorem":"preservation_lemma","id":89062,"goal":"preservation-lemma : of E T -> step E E' -> of E' T -> type.","context":["preservation-lemma"]} +{"prover":"Twelf","tactic_proof":"%mode strong-norm +Dof.","source":"twelf_synthetic/metatheory","theorem":"normalization","id":89063,"goal":"strong-norm : of E T -> type.","context":["strong-norm"]} +{"prover":"Twelf","tactic_proof":"%mode confluence +D1 +D2 -D3.","source":"twelf_synthetic/metatheory","theorem":"confluence","id":89064,"goal":"confluence : reduces E E1 -> reduces E E2 -> (reduces E1 E' /\\ reduces E2 E') -> type.","context":["confluence"]} +{"prover":"Twelf","tactic_proof":"forall-intro : of E (forall-tp A) <- ({X:tp} of E (A X)).\nforall-elim : of (tapp E T) (A T) <- of E (forall-tp A).","source":"twelf_synthetic/polymorphism","theorem":"forall_type","id":89065,"goal":"forall-tp : (tp -> tp) -> tp.","context":["forall-tp"]} +{"prover":"Twelf","tactic_proof":"pack : of (pack T E) (exists-tp A) <- of E (A T).\nunpack : of (open E1 [X] [x] E2) C <- of E1 (exists-tp A) <- ({X:tp} {x:tm} of x (A X) -> of (E2 X x) C).","source":"twelf_synthetic/polymorphism","theorem":"exists_type","id":89066,"goal":"exists-tp : (tp -> tp) -> tp.","context":["exists-tp"]} +{"prover":"Twelf","tactic_proof":"of-tabs : of (tabs K E) (forall-tp A) <- ({X:tp} of (E X) (A X)).","source":"twelf_synthetic/polymorphism","theorem":"type_abstraction","id":89067,"goal":"tabs : tp -> (tp -> tm) -> tm.","context":["tabs"]} +{"prover":"Twelf","tactic_proof":"%mode parametricity +D.","source":"twelf_synthetic/polymorphism","theorem":"param_poly","id":89068,"goal":"parametricity : of E (forall-tp A) -> type.","context":["parametricity"]} +{"prover":"Twelf","tactic_proof":"sub-refl : sub T T.\nsub-trans : sub T1 T3 <- sub T1 T2 <- sub T2 T3.\nsub-arrow : sub (arr S1 T1) (arr S2 T2) <- sub S2 S1 <- sub T1 T2.","source":"twelf_synthetic/polymorphism","theorem":"subtype","id":89069,"goal":"sub : tp -> tp -> type.","context":["sub"]} +{"prover":"Twelf","tactic_proof":"mk-sig : list -> module-sig.","source":"twelf_synthetic/modules","theorem":"module_signature","id":89070,"goal":"module-sig : type.","context":["module-sig"]} +{"prover":"Twelf","tactic_proof":"mk-impl : list -> module-impl Sig.","source":"twelf_synthetic/modules","theorem":"module_impl","id":89071,"goal":"module-impl : module-sig -> type.","context":["module-impl"]} +{"prover":"Twelf","tactic_proof":"apply-functor : functor S1 S2 -> module-impl S1 -> module-impl S2 -> type.","source":"twelf_synthetic/modules","theorem":"functor","id":89072,"goal":"functor : module-sig -> module-sig -> type.","context":["functor"]} +{"prover":"Twelf","tactic_proof":"pack-abs : tp -> (tp -> tp) -> abs-tp.\nopen-abs : abs-tp -> (tp -> tp -> tp) -> tp -> type.","source":"twelf_synthetic/modules","theorem":"abstract_type","id":89073,"goal":"abs-tp : type.","context":["abs-tp"]} +{"prover":"Twelf","tactic_proof":"%mode struct-eq +M1 +M2.","source":"twelf_synthetic/modules","theorem":"structure_eq","id":89074,"goal":"struct-eq : module-impl S -> module-impl S -> type.","context":["struct-eq"]} +{"prover":"Twelf","tactic_proof":"%mode include +M1 +M2 -M3.","source":"twelf_synthetic/modules","theorem":"include_module","id":89075,"goal":"include : module-impl S1 -> module-impl S2 -> module-impl S3 -> type.","context":["include"]} +{"prover":"Twelf","tactic_proof":"empty-rec : record.\ncons-rec : label -> tm -> record -> record.","source":"twelf_synthetic/records","theorem":"record","id":89076,"goal":"record : type.","context":["record"]} +{"prover":"Twelf","tactic_proof":"lab-a : label.\nlab-b : label.\nlab-c : label.","source":"twelf_synthetic/records","theorem":"label","id":89077,"goal":"label : type.","context":["label"]} +{"prover":"Twelf","tactic_proof":"lookup-head : lookup L (cons-rec L V R) V.\nlookup-tail : lookup L (cons-rec L' V R) V' <- lookup L R V'.","source":"twelf_synthetic/records","theorem":"rec_lookup","id":89078,"goal":"lookup : label -> record -> tm -> type.","context":["lookup"]} +{"prover":"Twelf","tactic_proof":"update-head : update L V (cons-rec L V' R) (cons-rec L V R).\nupdate-tail : update L V (cons-rec L' V' R) (cons-rec L' V' R') <- update L V R R'.","source":"twelf_synthetic/records","theorem":"rec_update","id":89079,"goal":"update : label -> tm -> record -> record -> type.","context":["update"]} +{"prover":"Twelf","tactic_proof":"rec-concat-nil : rec-concat empty-rec R R.\nrec-concat-cons : rec-concat (cons-rec L V R1) R2 (cons-rec L V R3) <- rec-concat R1 R2 R3.","source":"twelf_synthetic/records","theorem":"rec_concat","id":89080,"goal":"rec-concat : record -> record -> record -> type.","context":["rec-concat"]} +{"prover":"Twelf","tactic_proof":"empty-trace : trace.\nstep-trace : tm -> tm -> trace -> trace.","source":"twelf_synthetic/traces","theorem":"trace","id":89081,"goal":"trace : type.","context":["trace"]} +{"prover":"Twelf","tactic_proof":"%mode trace-step +T +E -E'.","source":"twelf_synthetic/traces","theorem":"trace_step","id":89082,"goal":"trace-step : trace -> tm -> tm -> type.","context":["trace-step"]} +{"prover":"Twelf","tactic_proof":"trace-app-nil : trace-append empty-trace T T.\ntrace-app-cons : trace-append (step-trace E1 E2 T1) T2 (step-trace E1 E2 T3) <- trace-append T1 T2 T3.","source":"twelf_synthetic/traces","theorem":"trace_append","id":89083,"goal":"trace-append : trace -> trace -> trace -> type.","context":["trace-append"]} +{"prover":"Twelf","tactic_proof":"eval-refl : evaluates E E.\neval-step : evaluates E E'' <- step E E' <- evaluates E' E''.","source":"twelf_synthetic/traces","theorem":"evaluates","id":89084,"goal":"evaluates : tm -> tm -> type.","context":["evaluates"]} +{"prover":"Twelf","tactic_proof":"multistep-refl : multistep E E empty-trace.\nmultistep-step : multistep E E'' (step-trace E E' T) <- step E E' <- multistep E' E'' T.","source":"twelf_synthetic/traces","theorem":"multistep","id":89085,"goal":"multistep : tm -> tm -> trace -> type.","context":["multistep"]} +{"prover":"Twelf","tactic_proof":"bigstep-val : bigstep V V <- value V.\nbigstep-app : bigstep (app E1 E2) V <- bigstep E1 (lam T E) <- bigstep E2 V2 <- bigstep (E V2) V.","source":"twelf_synthetic/bigstep","theorem":"bigstep","id":89086,"goal":"bigstep : tm -> tm -> type.","context":["bigstep"]} +{"prover":"Twelf","tactic_proof":"%mode bigstep-det +D1 +D2 -D3.","source":"twelf_synthetic/bigstep","theorem":"bigstep_det","id":89087,"goal":"bigstep-det : bigstep E V1 -> bigstep E V2 -> eq V1 V2 -> type.","context":["bigstep-det"]} +{"prover":"Twelf","tactic_proof":"%mode bigstep-value +D -Dv.","source":"twelf_synthetic/bigstep","theorem":"bigstep_value","id":89088,"goal":"bigstep-value : bigstep E V -> value V -> type.","context":["bigstep-value"]} +{"prover":"Twelf","tactic_proof":"%mode bigstep-of +D1 +D2 -D3.","source":"twelf_synthetic/bigstep","theorem":"bigstep_of","id":89089,"goal":"bigstep-of : bigstep E V -> of E T -> of V T -> type.","context":["bigstep-of"]} +{"prover":"Twelf","tactic_proof":"%mode bigstep-smallstep +D1 -D2.","source":"twelf_synthetic/bigstep","theorem":"bigstep_smallstep","id":89090,"goal":"bigstep-smallstep : bigstep E V -> multistep E V _ -> type.","context":["bigstep-smallstep"]} +{"prover":"Twelf","tactic_proof":"habs-intro : of (habs E) (arr T1 T2) <- ({x:tm} of x T1 -> of (E x) T2).","source":"twelf_synthetic/hoas","theorem":"hoas_abs","id":89091,"goal":"habs : (tm -> tm) -> tm.","context":["habs"]} +{"prover":"Twelf","tactic_proof":"happ-intro : of (happ E1 E2) T2 <- of E1 (arr T1 T2) <- of E2 T1.","source":"twelf_synthetic/hoas","theorem":"hoas_app","id":89092,"goal":"happ : tm -> tm -> tm.","context":["happ"]} +{"prover":"Twelf","tactic_proof":"hstep-beta : hstep (happ (habs E) V) (E V) <- value V.","source":"twelf_synthetic/hoas","theorem":"hoas_beta","id":89093,"goal":"hstep : tm -> tm -> type.","context":["hstep"]} +{"prover":"Twelf","tactic_proof":"%mode hsubst +E +V -E'.","source":"twelf_synthetic/hoas","theorem":"hoas_subst","id":89094,"goal":"hsubst : (tm -> tm) -> tm -> tm -> type.","context":["hsubst"]} +{"prover":"Twelf","tactic_proof":"%block phabs-block : block {x:tm}.","source":"twelf_synthetic/hoas","theorem":"parametric_hoas","id":89095,"goal":"phabs : (tm -> tm) -> tm.","context":["phabs"]} +{"prover":"Twelf","tactic_proof":"tok-ident : string -> token.\ntok-num : nat -> token.\ntok-lparen : token.\ntok-rparen : token.\ntok-plus : token.\ntok-times : token.","source":"twelf_synthetic/parsing","theorem":"token","id":89096,"goal":"token : type.","context":["token"]} +{"prover":"Twelf","tactic_proof":"%mode parse +Input -Result -Rest.","source":"twelf_synthetic/parsing","theorem":"parse_expr","id":89097,"goal":"parse : list -> tm -> list -> type.","context":["parse"]} +{"prover":"Twelf","tactic_proof":"%mode lex +Input -Tokens.","source":"twelf_synthetic/parsing","theorem":"lex","id":89098,"goal":"lex : string -> list -> type.","context":["lex"]} +{"prover":"Twelf","tactic_proof":"ast-num : nat -> ast.\nast-var : string -> ast.\nast-bin : op -> ast -> ast -> ast.","source":"twelf_synthetic/parsing","theorem":"ast","id":89099,"goal":"ast : type.","context":["ast"]} +{"prover":"Twelf","tactic_proof":"op-add : op.\nop-sub : op.\nop-mul : op.\nop-div : op.","source":"twelf_synthetic/parsing","theorem":"op","id":89100,"goal":"op : type.","context":["op"]} +{"prover":"Twelf","tactic_proof":"gr-term : symbol -> grammar-rule.\ngr-alt : grammar-rule -> grammar-rule -> grammar-rule.\ngr-seq : grammar-rule -> grammar-rule -> grammar-rule.","source":"twelf_synthetic/parsing","theorem":"grammar","id":89101,"goal":"grammar-rule : type.","context":["grammar-rule"]} +{"prover":"Twelf","tactic_proof":"init-state : state.\ntrans-state : state -> char -> state.","source":"twelf_synthetic/automata","theorem":"dfa_state","id":89102,"goal":"state : type.","context":["state"]} +{"prover":"Twelf","tactic_proof":"%mode accepts +D +S.","source":"twelf_synthetic/automata","theorem":"dfa_accept","id":89103,"goal":"accepts : dfa -> string -> type.","context":["accepts"]} +{"prover":"Twelf","tactic_proof":"%mode nfa-run +N +S -Q.","source":"twelf_synthetic/automata","theorem":"nfa_run","id":89104,"goal":"nfa-run : nfa -> list -> state -> type.","context":["nfa-run"]} +{"prover":"Twelf","tactic_proof":"re-char : char -> regex.\nre-concat : regex -> regex -> regex.\nre-alt : regex -> regex -> regex.\nre-star : regex -> regex.\nre-epsilon : regex.","source":"twelf_synthetic/automata","theorem":"regex","id":89105,"goal":"regex : type.","context":["regex"]} +{"prover":"Twelf","tactic_proof":"%mode re-match +R +S.","source":"twelf_synthetic/automata","theorem":"regex_match","id":89106,"goal":"re-match : regex -> string -> type.","context":["re-match"]} +{"prover":"Twelf","tactic_proof":"pda-init : pda-state.\npda-push : pda-state -> char -> stack -> pda-state.","source":"twelf_synthetic/automata","theorem":"pda","id":89107,"goal":"pda-state : type.","context":["pda-state"]} +{"prover":"Twelf","tactic_proof":"io-return : A -> io A.\nio-bind : io A -> (A -> io B) -> io B.","source":"twelf_synthetic/effects","theorem":"io_monad","id":89108,"goal":"io : type -> type.","context":["io"]} +{"prover":"Twelf","tactic_proof":"state-return : A -> state-m A.\nstate-bind : state-m A -> (A -> state-m B) -> state-m B.\nstate-get : state-m state.\nstate-put : state -> state-m unit.","source":"twelf_synthetic/effects","theorem":"state_monad","id":89109,"goal":"state-m : type -> type.","context":["state-m"]} +{"prover":"Twelf","tactic_proof":"exc-pure : A -> exc A.\nexc-raise : string -> exc A.\nexc-catch : exc A -> (string -> exc A) -> exc A.","source":"twelf_synthetic/effects","theorem":"exception","id":89110,"goal":"exc : type -> type.","context":["exc"]} +{"prover":"Twelf","tactic_proof":"cont-pure : A -> cont A R.\ncont-callcc : ((A -> cont B R) -> cont A R) -> cont A R.","source":"twelf_synthetic/effects","theorem":"continuation","id":89111,"goal":"cont : type -> type -> type.","context":["cont"]} +{"prover":"Twelf","tactic_proof":"free-pure : A -> free A.\nfree-op : op-sig -> (result -> free A) -> free A.","source":"twelf_synthetic/effects","theorem":"free_monad","id":89112,"goal":"free : type -> type.","context":["free"]} +{"prover":"Twelf","tactic_proof":"%mode add-zero-left +N -D.\nadd-zero-left-z : add-zero-left z plus-z.\nadd-zero-left-s : add-zero-left (s N) plus-z <- add-zero-left N _.","source":"twelf_synthetic/numerics","theorem":"add_zero_left","id":89113,"goal":"add-zero-left : {N:nat} plus z N N -> type.","context":["zero-left","N"]} +{"prover":"Twelf","tactic_proof":"%mode add-zero-right +N -D.\nadd-zero-right-z : add-zero-right z plus-z.\nadd-zero-right-s : add-zero-right (s N) (plus-s D) <- add-zero-right N D.","source":"twelf_synthetic/numerics","theorem":"add_zero_right","id":89114,"goal":"add-zero-right : {N:nat} plus N z N -> type.","context":["zero-right","N"]} +{"prover":"Twelf","tactic_proof":"%mode times-zero-right +N -D.","source":"twelf_synthetic/numerics","theorem":"times_zero_right","id":89115,"goal":"times-zero-right : {N:nat} times N z z -> type.","context":["zero-right","N"]} +{"prover":"Twelf","tactic_proof":"div-mod-base : div-mod M N z M <- lt M N.\ndiv-mod-rec : div-mod M N (s Q) R <- leq N M <- sub M N M' <- div-mod M' N Q R.","source":"twelf_synthetic/numerics","theorem":"div_algorithm","id":89116,"goal":"div-mod : nat -> nat -> nat -> nat -> type.","context":["div-mod"]} +{"prover":"Twelf","tactic_proof":"gcd-zero : gcd M z M.\ngcd-rec : gcd M N G <- modulo M N R <- gcd N R G.","source":"twelf_synthetic/numerics","theorem":"gcd","id":89117,"goal":"gcd : nat -> nat -> nat -> type.","context":["gcd"]} diff --git a/training_data/stats_5X.json b/training_data/stats_5X.json index 6782423..ff94264 100644 --- a/training_data/stats_5X.json +++ b/training_data/stats_5X.json @@ -1,14 +1,14 @@ { - "typechecker_research_added": 3000, - "expansion_ratio": 12.4, + "typechecker_research_added": 3004, + "expansion_ratio": 13.6, "prover_specific_added": 645, "mathematics_added": 645, "previous_comprehensive": 6555, - "date": "2026-04-17", - "total_vocabulary": 81047, + "date": "2026-04-20", + "total_vocabulary": 88963, "proof_terms_added": 122, "math_domains": 14, "version": "v2.1-5x-expansion", - "previous_unified": 79402, + "previous_unified": 87386, "provers_covered": 60 } \ No newline at end of file diff --git a/training_data/stats_UNIFIED.json b/training_data/stats_UNIFIED.json index 7028ef2..4cf4779 100644 --- a/training_data/stats_UNIFIED.json +++ b/training_data/stats_UNIFIED.json @@ -1 +1,5 @@ -{"source_files_used":{"proof_states_fstar.jsonl":76,"proof_states_hol_light.jsonl":7020,"proof_states_coqgym.jsonl":14,"proof_states_why3.jsonl":199,"proof_states_dafny.jsonl":48,"proof_states_minlog.jsonl":46,"proof_states_typechecker_ecosystem.jsonl":1972,"proof_states_twelf.jsonl":33,"proof_states_hol4.jsonl":1899,"proof_states_nuprl.jsonl":50,"proof_states_minizinc.jsonl":29,"proof_states_idris2.jsonl":87,"proof_states_agda.jsonl":9312,"proof_states_coqgym_max.jsonl":15013,"proof_states_metamath.jsonl":47165,"proof_states_mizar.jsonl":66,"proof_states_isabelle.jsonl":97,"proof_states_pvs.jsonl":231,"proof_states_smtlib.jsonl":20527,"proof_states_acl2.jsonl":277,"proof_states_mathlib4_max.jsonl":131770,"proof_states_imandra.jsonl":47,"proof_states_afp.jsonl":50137,"proof_states_2026-03-20.jsonl":108,"proof_states_mathlib4.jsonl":455,"proof_states_tptp.a2ml":16843},"total_proofs":263792,"vocabulary_size":87386,"date":"2026-04-17","balanced_per_prover_counts":{"Why3":161,"Lean":12000,"GLPK":5,"ORTools":6,"Idris2":87,"FStar":75,"Vampire":5615,"Mizar":67,"CVC5":6737,"PVS":231,"QTTTypeChecker":167,"Nuprl":50,"TropicalTypeChecker":474,"Imandra":47,"Alt-Ergo":6732,"Minlog":46,"Metamath":12000,"ChoreographicTypeChecker":111,"SessionTypeChecker":112,"HOL4":1899,"Coq":12000,"EpistemicTypeChecker":12,"RefinementTypeChecker":23,"SCIP":6,"DependentTypeChecker":124,"EchoTypeChecker":11,"EProver":5614,"KatagoriaVerifier":35,"Isabelle":12000,"Dafny":48,"SPASS":5614,"ModalTypeChecker":87,"Chuffed":6,"TypeLL":499,"Agda":5942,"Z3":6735,"HOLLight":7000,"EffectRowTypeChecker":308,"ACL2":278,"MiniZinc":6,"Twelf":33},"unique_theorems":261583,"balanced_cap_per_prover":12000,"per_source_counts_top50":{"hol_light/Multivariate_derivatives.ml":200,"hol4/arithmeticScript.sml":396,"hol4/realScript.sml":424,"typechecker_ecosystem/typell/spec/type-system/session.adoc":85,"TPTP":16843,"afp/Ordered_Resolution_Prover/Abstract_Substitution.thy":70,"typechecker_ecosystem/typell/spec/type-system/effects.adoc":118,"agda-stdlib/src/Data/List/Properties.agda":110,"typechecker_ecosystem/typell/spec/proof/proof-system.adoc":108,"hol4/pred_setScript.sml":613,"afp/Syntax_Independent_Logic/Deduction.thy":70,"hol_light/Multivariate_integration.ml":854,"hol_light/Multivariate_vectors.ml":1097,"typechecker_ecosystem/tropical-resource-typing/Tropical_Kleene.thy":76,"agda-stdlib/src/Data/Rational/Properties.agda":137,"Metamath":47162,"typechecker_ecosystem/tropical-resource-typing/Tropical_Matrices_Full.thy":199,"agda-stdlib/src/Data/Fin/Properties.agda":139,"typechecker_ecosystem/typell/spec/protocol/TYPELL-PROTOCOL.adoc":184,"unknown":319,"typechecker_ecosystem/tropical-resource-typing/Tropical_v2.thy":177,"agda-stdlib/src/Data/Fin/Subset/Properties.agda":86,"afp/Matrix_Tensor/Matrix_Tensor.thy":70,"afp/Dominance_CHK/Cfg.thy":70,"typechecker_ecosystem/tropical-resource-typing/Tropical_CNO.thy":95,"typechecker_ecosystem/typell/crates/typell-core/src/types.rs":135,"typechecker_ecosystem/typell/spec/type-system/dependent.adoc":159,"hol_light/Multivariate_measure.ml":712,"afp/Universal_Turing_Machine/Abacus.thy":70,"typechecker_ecosystem/typell/spec/type-system/linear.adoc":128,"afp/Rep_Fin_Groups/Rep_Fin_Groups.thy":70,"afp/Oneway2Hiding/Definition_O2H.thy":70,"acl2/logops-lemmas.lisp":133,"hol_light/Multivariate_topology.ml":2373,"mathlib4":99117,"afp/Huffman/Huffman.thy":70,"hol_light/Multivariate_convex.ml":898,"hol4/listScript.sml":378,"afp/Buildings/Algebra.thy":70,"agda-stdlib/src/Data/Vec/Properties.agda":164,"afp/Auto2_HOL/HOL/Arith_Thms.thy":70,"agda-stdlib/src/Data/Bool/Properties.agda":108,"agda-stdlib/src/Data/Rational/Unnormalised/Properties.agda":166,"SMT-LIB":20202,"hol_light/Multivariate_polytope.ml":352,"hol_light/Multivariate_determinants.ml":307,"agda-stdlib/src/Data/Integer/Properties.agda":183,"agda-stdlib/src/Data/Nat/Binary/Properties.agda":111,"CoqGym":13774,"agda-stdlib/src/Data/Nat/Properties.agda":317},"provers_with_data":41,"total_backends":60,"per_prover_counts":{"Why3":161,"Lean":99347,"GLPK":5,"ORTools":6,"Idris2":87,"FStar":75,"Vampire":5615,"Mizar":67,"CVC5":6737,"PVS":231,"QTTTypeChecker":167,"Nuprl":50,"TropicalTypeChecker":474,"Imandra":47,"Alt-Ergo":6732,"Minlog":46,"Metamath":47162,"ChoreographicTypeChecker":111,"SessionTypeChecker":112,"HOL4":1899,"Coq":13848,"EpistemicTypeChecker":12,"RefinementTypeChecker":23,"SCIP":6,"DependentTypeChecker":124,"EchoTypeChecker":11,"EProver":5614,"KatagoriaVerifier":35,"Isabelle":48432,"Dafny":48,"SPASS":5614,"ModalTypeChecker":87,"Chuffed":6,"TypeLL":499,"Agda":5942,"Z3":6735,"HOLLight":7000,"EffectRowTypeChecker":308,"ACL2":278,"MiniZinc":6,"Twelf":33},"balanced_output_file":"proof_states_UNIFIED_BALANCED.jsonl","version":"UNIFIED","coverage_percentage":68.3,"balanced_total_proofs":103003} \ No newline at end of file +<<<<<<< Updated upstream +{"source_files_used":{"proof_states_fstar.jsonl":10117,"proof_states_hol_light.jsonl":79300,"proof_states_coqgym.jsonl":111617,"proof_states_why3.jsonl":115600,"proof_states_dafny.jsonl":16680,"proof_states_minlog.jsonl":148,"proof_states_typechecker_ecosystem.jsonl":1972,"proof_states_twelf.jsonl":118,"proof_states_hol4.jsonl":127517,"proof_states_nuprl.jsonl":152,"proof_states_minizinc.jsonl":1590,"proof_states_idris2.jsonl":653,"proof_states_agda.jsonl":50095,"proof_states_coqgym_max.jsonl":15013,"proof_states_metamath.jsonl":70146,"proof_states_mizar.jsonl":77137,"proof_states_isabelle.jsonl":214,"proof_states_pvs.jsonl":2377,"proof_states_smtlib.jsonl":20527,"proof_states_acl2.jsonl":170455,"proof_states_mathlib4_max.jsonl":131770,"proof_states_imandra.jsonl":133,"proof_states_afp.jsonl":105858,"proof_states_2026-03-20.jsonl":108,"proof_states_mathlib4.jsonl":278,"proof_states_tptp.a2ml":0},"total_proofs":702099,"vocabulary_size":141517,"date":"2026-04-20","balanced_per_prover_counts":{"Why3":12000,"Lean":12000,"GLPK":311,"ORTools":310,"Idris2":505,"FStar":6367,"Mizar":12000,"CVC5":6737,"PVS":2189,"QTTTypeChecker":167,"Nuprl":151,"TropicalTypeChecker":474,"Imandra":133,"Alt-Ergo":6732,"Minlog":148,"Metamath":12000,"ChoreographicTypeChecker":111,"SessionTypeChecker":112,"HOL4":12000,"Coq":12000,"EpistemicTypeChecker":12,"SCIP":311,"RefinementTypeChecker":23,"DependentTypeChecker":124,"EchoTypeChecker":11,"KatagoriaVerifier":35,"Isabelle":12000,"Dafny":7551,"Chuffed":311,"ModalTypeChecker":87,"ACL2":12000,"Agda":12000,"Z3":6735,"HOLLight":12000,"TypeLL":499,"MiniZinc":312,"EffectRowTypeChecker":308,"Twelf":118},"unique_theorems":687950,"balanced_cap_per_prover":12000,"per_source_counts_top50":{"CoqGym/coq_projects/bbv/theories/Word.v":518,"CoqGym/coq_projects/math-comp/mathcomp/fingroup/fingroup.v":533,"external_corpora/mathcomp-analysis/reals/constructive_ereal.v":699,"CoqGym/coq_projects/math-comp/mathcomp/character/mxrepresentation.v":518,"hol4/pred_setScript.sml":758,"hol4/integrationScript.sml":602,"acl2/sets.lisp":540,"hol_light/Multivariate_integration.ml":815,"why3/separation_why.why":906,"acl2/MAETT-lemmas2.lisp":633,"hol_light/Multivariate_vectors.ml":1038,"hol4/separationLogicScript.sml":737,"hol_light/Library_ringtheory.ml":1675,"Metamath":53293,"hol4/vars_as_resourceScript.sml":691,"acl2/MAETT-lemmas1.lisp":574,"hol_light/jordan_curve_theorem.ml":1347,"hol_light/Multivariate_paths.ml":977,"hol_light/sets.ml":586,"hol_light/words.ml":737,"CoqGym/coq_projects/math-comp/mathcomp/algebra/ssrnum.v":810,"hol_light/transcendence.ml":966,"hol_light/Multivariate_realanalysis.ml":1291,"acl2/rules3.lisp":1041,"hol4/groupScript.sml":809,"acl2/register-readers-and-writers64.lisp":620,"hol4/wordsScript.sml":626,"hol4/data_to_word_memoryProofScript.sml":571,"hol_light/Multivariate_measure.ml":698,"hol4/rich_listScript.sml":567,"acl2/read-over-write-rules64.lisp":509,"hol_light/Library_grouptheory.ml":1161,"hol_light/Multivariate_topology.ml":2219,"hol4/real_topologyScript.sml":1525,"mathlib4":99164,"hol_light/Multivariate_convex.ml":876,"acl2/basic.lisp":759,"hol4/listScript.sml":534,"hol_light/Multivariate_transcendentals.ml":614,"acl2/read-over-write-rules32.lisp":509,"hol4/holSyntaxExtraScript.sml":601,"hol_light/Multivariate_metric.ml":2336,"SMT-LIB":20202,"why3/sort_why.why":788,"hol4/ringScript.sml":636,"hol_light/tame_list.hl":631,"pvs/prelude.pvs":977,"hol_light/hypermap.hl":540,"CoqGym":13675,"hol4/combinatoricsScript.sml":637},"provers_with_data":38,"total_backends":60,"per_prover_counts":{"Why3":15396,"Lean":99308,"GLPK":311,"ORTools":310,"Idris2":505,"FStar":6367,"Mizar":18858,"CVC5":6737,"PVS":2189,"QTTTypeChecker":167,"Nuprl":151,"TropicalTypeChecker":474,"Imandra":133,"Alt-Ergo":6732,"Minlog":148,"Metamath":53293,"ChoreographicTypeChecker":111,"SessionTypeChecker":112,"HOL4":90170,"Coq":86361,"EpistemicTypeChecker":12,"SCIP":311,"RefinementTypeChecker":23,"DependentTypeChecker":124,"EchoTypeChecker":11,"KatagoriaVerifier":35,"Isabelle":100319,"Dafny":7551,"Chuffed":311,"ModalTypeChecker":87,"ACL2":118123,"Agda":36931,"Z3":6735,"HOLLight":42456,"TypeLL":499,"MiniZinc":312,"EffectRowTypeChecker":308,"Twelf":118},"balanced_output_file":"proof_states_UNIFIED_BALANCED.jsonl","version":"UNIFIED","coverage_percentage":63.3,"balanced_total_proofs":160884} +======= +{"source_files_used":{"proof_states_fstar.jsonl":10025,"proof_states_hol_light.jsonl":79300,"proof_states_coqgym.jsonl":111617,"proof_states_why3.jsonl":115600,"proof_states_dafny.jsonl":100000,"proof_states_minlog.jsonl":2200,"proof_states_typechecker_ecosystem.jsonl":1972,"proof_states_twelf.jsonl":2200,"proof_states_hol4.jsonl":127517,"proof_states_nuprl.jsonl":2200,"proof_states_minizinc.jsonl":1535,"proof_states_idris2.jsonl":574,"proof_states_agda.jsonl":50095,"proof_states_coqgym_max.jsonl":15013,"proof_states_metamath.jsonl":70146,"proof_states_mizar.jsonl":77075,"proof_states_isabelle.jsonl":25,"proof_states_pvs.jsonl":2377,"proof_states_smtlib.jsonl":20527,"proof_states_acl2.jsonl":170455,"proof_states_mathlib4_max.jsonl":131770,"proof_states_imandra.jsonl":2200,"proof_states_afp.jsonl":105858,"proof_states_2026-03-20.jsonl":108,"proof_states_mathlib4.jsonl":278,"proof_states_tptp.a2ml":78531},"total_proofs":871731,"vocabulary_size":143392,"date":"2026-04-20","balanced_per_prover_counts":{"Why3":12000,"Lean":12000,"GLPK":300,"ORTools":300,"Idris2":426,"FStar":6275,"Vampire":12000,"Mizar":12000,"CVC5":6737,"PVS":2189,"QTTTypeChecker":167,"Nuprl":2200,"Imandra":2200,"TropicalTypeChecker":474,"Alt-Ergo":6732,"Minlog":2200,"Metamath":12000,"ChoreographicTypeChecker":111,"SessionTypeChecker":112,"HOL4":12000,"Coq":12000,"EpistemicTypeChecker":12,"SCIP":300,"RefinementTypeChecker":23,"DependentTypeChecker":124,"EchoTypeChecker":11,"EProver":12000,"KatagoriaVerifier":35,"Isabelle":12000,"Dafny":12000,"SPASS":12000,"Chuffed":300,"ModalTypeChecker":87,"ACL2":12000,"Agda":12000,"Z3":6735,"HOLLight":12000,"TypeLL":499,"EffectRowTypeChecker":308,"MiniZinc":300,"Twelf":2200},"unique_theorems":805368,"balanced_cap_per_prover":12000,"per_source_counts_top50":{"dafny_synthetic/predicates":16668,"TPTP":78531,"external_corpora/mathcomp-analysis/reals/constructive_ereal.v":699,"dafny_synthetic/sets":16682,"hol4/pred_setScript.sml":758,"hol4/integrationScript.sml":602,"hol_light/Multivariate_integration.ml":815,"why3/separation_why.why":906,"acl2/MAETT-lemmas2.lisp":633,"hol_light/Multivariate_vectors.ml":1038,"hol4/separationLogicScript.sml":737,"nuprl_synthetic/scaled":2200,"hol_light/Library_ringtheory.ml":1675,"Metamath":53293,"hol4/vars_as_resourceScript.sml":691,"acl2/MAETT-lemmas1.lisp":574,"hol_light/jordan_curve_theorem.ml":1347,"twelf_synthetic/scaled":2200,"hol_light/Multivariate_paths.ml":977,"hol_light/sets.ml":586,"minlog_synthetic/scaled":2200,"hol_light/words.ml":737,"CoqGym/coq_projects/math-comp/mathcomp/algebra/ssrnum.v":810,"hol_light/transcendence.ml":966,"hol_light/Multivariate_realanalysis.ml":1291,"acl2/rules3.lisp":1041,"dafny_synthetic/arith":16672,"hol4/groupScript.sml":809,"acl2/register-readers-and-writers64.lisp":620,"hol4/wordsScript.sml":626,"hol_light/Multivariate_measure.ml":698,"dafny_synthetic/sequences":16682,"imandra_synthetic/scaled":2200,"hol_light/Library_grouptheory.ml":1161,"hol_light/Multivariate_topology.ml":2219,"hol4/real_topologyScript.sml":1525,"mathlib4":99164,"dafny_synthetic/methods":16672,"hol_light/Multivariate_convex.ml":876,"acl2/basic.lisp":759,"hol_light/Multivariate_transcendentals.ml":614,"hol4/holSyntaxExtraScript.sml":601,"hol_light/Multivariate_metric.ml":2336,"SMT-LIB":20202,"why3/sort_why.why":788,"hol4/ringScript.sml":636,"hol_light/tame_list.hl":631,"pvs/prelude.pvs":977,"CoqGym":13675,"hol4/combinatoricsScript.sml":637},"provers_with_data":41,"total_backends":60,"per_prover_counts":{"Why3":15396,"Lean":99308,"GLPK":300,"ORTools":300,"Idris2":426,"FStar":6275,"Vampire":26177,"Mizar":18796,"CVC5":6737,"PVS":2189,"QTTTypeChecker":167,"Nuprl":2200,"Imandra":2200,"TropicalTypeChecker":474,"Alt-Ergo":6732,"Minlog":2200,"Metamath":53293,"ChoreographicTypeChecker":111,"SessionTypeChecker":112,"HOL4":90170,"Coq":86361,"EpistemicTypeChecker":12,"SCIP":300,"RefinementTypeChecker":23,"DependentTypeChecker":124,"EchoTypeChecker":11,"EProver":26177,"KatagoriaVerifier":35,"Isabelle":100138,"Dafny":90871,"SPASS":26177,"Chuffed":300,"ModalTypeChecker":87,"ACL2":118123,"Agda":36931,"Z3":6735,"HOLLight":42456,"TypeLL":499,"EffectRowTypeChecker":308,"MiniZinc":300,"Twelf":2200},"balanced_output_file":"proof_states_UNIFIED_BALANCED.jsonl","version":"UNIFIED","coverage_percentage":68.3,"balanced_total_proofs":209357} +>>>>>>> Stashed changes diff --git a/training_data/vocabulary_5X.txt b/training_data/vocabulary_5X.txt index 715d7b6..01342c6 100644 --- a/training_data/vocabulary_5X.txt +++ b/training_data/vocabulary_5X.txt @@ -15,6 +15,8 @@ aaafeecc aaan aaanv aab +aabaa +aabaabaa aabb aabc aabeaf @@ -37,6 +39,7 @@ aacfa aacjcl aacllem aacn +aact aad aadafe aadb @@ -75,13 +78,16 @@ aalias aaliou aalioulem aalt +aam aannen aannenlem aaof aaotnj aaqlhwaebond +aarden aareccl aaron +aaronson aas aasscn aasu @@ -130,10 +136,12 @@ abbidv abbii abbr abbrev +abbreve abbreviate abbreviation abbreviationdict abbreviations +abbrevs abc abca abcaf @@ -176,6 +184,7 @@ abel abelab abelian abelianaux +abeliangroup abelianimagetokernel abelianimagetokerneliskernel abelianization @@ -218,6 +227,8 @@ abidnf abii abijf abim +abind +abinds abit abkl abl @@ -275,11 +286,17 @@ abnexg abnotataxb abnotbtaxb abort +aborting abot about above +aboves +abpa abpr +abpra +abr abrahamlincoln +abrcond abrexco abrexct abrexctf @@ -290,8 +307,13 @@ abrexexd abrexexg abrexfi abrexss +abrupt abs absabv +absc +abscd +absch +abscissa abscissaofabsconv abscj abscjd @@ -323,6 +345,7 @@ absdvdsb absef absefi absefib +absence abseq absex absexp @@ -332,6 +355,7 @@ absf absfbounded absfico absfun +absg absge absgt abshicom @@ -365,6 +389,7 @@ absmuli absmulrposd absmuls absn +absnat absne absneg absnegd @@ -389,11 +414,11 @@ absolutelycontinuousoninterval absolutelyconvex absolutelyconvexsets absolutelyinfinite +absolutepath +absolutetoknownnature absolutevalue absor absorb -absorb1 -absorb2 absorbant absorbent absorbing @@ -402,6 +427,7 @@ absord absori absorp absorption +absorptive absproddvds absprodnn absrdbnd @@ -436,6 +462,9 @@ abssubne abssubrp abssubs abssval +abst +absterm +abstfn abstr abstra abstract @@ -446,17 +475,24 @@ abstractcrashawaresystemrefinement abstractfilteredclosure abstractfilteredclosurerealization abstraction +abstractiond +abstractioni abstractjournal abstractm abstractmvars abstractmvarsresult +abstractpaper abstractproof abstracts abstractsimplicialcomplex abstri abstrid abstrii +abstrlevel +abstrlevels +abstype absurd +absv absval absvalsq absvalsqd @@ -502,6 +538,7 @@ abvtri abvtriv abvtrivd abvtrivg +aby aca acaa acaaae @@ -518,6 +555,7 @@ acaf acafc acafe acaff +acap acb acba acbb @@ -540,12 +578,17 @@ accd accdadf accdbbb accdbc +accent accept acceptable +acceptd accepted +accepti accepting +acceptingrun accepts acceptsfrom +acceptsi access accessctrllistdata accessed @@ -555,7 +598,9 @@ accessibility-relation accessible accessing accf +acci accidental +accn accommodate accomplement accomplish @@ -565,8 +610,10 @@ account accountability accounting accounts +accp accpt accrediting +accs acct accu accum @@ -574,6 +621,8 @@ accumulate accumulated accumulation accumulator +accur +accuracy accurate acd acdad @@ -628,6 +677,7 @@ ackvalsuc ackvalsucsucval acl acl2 +aclasst acldata acleq aclstat @@ -636,6 +686,7 @@ aclstatpsp aclstatpss acm acm_ +acmauthor acncc acndom acnen @@ -645,6 +696,9 @@ acnlem acnnum acnrcl aco +acom +acomp +acomplete acompletelattice acongeq acongid @@ -653,6 +707,7 @@ acongrep acongsym acongtr acons +acontext acopy acopyeu acor @@ -664,6 +719,7 @@ acoscosb acosf acosneg acosrecl +acost acosval acounit acquire @@ -714,6 +770,7 @@ actionunitiso actionunitnatiso activate activated +activation active activity actk @@ -725,6 +782,7 @@ actm actmin actperm actpermm +actrans actreaders actright acts @@ -732,11 +790,15 @@ actsd actsi actsu actual +actuale +actuali actually +actuals actualtype actwriters acufl acunirnmpt +acut acute acuteangled acv @@ -748,6 +810,7 @@ acycgrsubgr acyclic acyclicgraph acyclicity +acyclicp ada adaa adabbbb @@ -784,6 +847,7 @@ adaptationnotetermelab adaptdown adapted adaption +adaptive adaptup adb adbb @@ -854,6 +918,7 @@ addb addba addbac addbaca +addbalance addbb addbc addbca @@ -877,6 +942,7 @@ addcani addcanpi addcanpr addcases +addcc addccncf addcdd addchains @@ -902,6 +968,7 @@ addcnlem addcnsr addcnsrec addco +addcol addcom addcomd addcomgi @@ -1074,6 +1141,7 @@ additivisable additivised additivity additivize +addk addkb addkr addl @@ -1178,6 +1246,7 @@ addnr addns addnsmul addnz +addo addonbday addoneform addonly @@ -1192,7 +1261,9 @@ addpointed addpolynomial addpqf addpqnq +addpre addpredefinitions +addprert addprojection addprojections addproperties @@ -1240,7 +1311,9 @@ addrnk addrof addrok addrothnumber +addrow addrs +addrset addrsub addrule addrval @@ -1275,6 +1348,7 @@ addslid addsmul addsn addsnns +addspace addspanning addsprop addsproplem @@ -1371,9 +1445,11 @@ adfc adfe adfed adff +adgr adh adherence adhesive +adhoc adhp adhs adic @@ -1395,10 +1471,12 @@ adifii adihtotgqhktl adimensionof adique +adiv adivisorof adj adjacency adjacent +adjacentto adjadd adjadj adjbd @@ -1415,12 +1493,14 @@ adjfrombun adjg adjh adjid +adjleft adjliftmap adjlnop adjls adjmatrix adjmo adjmul +adjnt adjo adjoi adjoin @@ -1467,6 +1547,7 @@ adjoinxequiv adjp adjretraction adjretractionaux +adjright adjsslnop adjsylvester adjsym @@ -1487,12 +1568,15 @@ adjunctiontoptolocalept adjunit adjust adjusted +adjuster adjusttoorientation adjustwith adjval adjvalval adm admin +admissability +admissable admissible admissibleabsvalues admissibleindex @@ -1503,12 +1587,16 @@ admits admitsfractional admitted admitting +adms +admsi adn adoc +adopt adopts ads adual adv +advance advancecommitindex advancecurrentterm advanced @@ -1599,6 +1687,7 @@ aemeasurabl aemeasurable aemeasurableof aemi +aencrypt aeq aeqb aequiv @@ -1643,6 +1732,9 @@ aeveq aevlem aex aexp +aexpr +aext +aezfun afa afaa afab @@ -1706,6 +1798,7 @@ affine affine_mode affineaddmonoid affineand +affineapprox affineba affinebasicopen affinebasis @@ -1751,13 +1844,20 @@ affinetargetmorphismproperty affinezariskisit affinezariskisite affinity +affinvertible afhandurxjsb afi afix afixedpointof +afletter +aform +aforms afp +afread afs +afsize afsval +aft after aftercdot aftercompilation @@ -1783,6 +1883,7 @@ afvvdm afvvfunressn afvvfveq afvvv +afwrite again against agatha @@ -1791,20 +1892,32 @@ age ageable agen agent +agents +agenty +agg aggregate aggregates +aggregation aggressive agm agmsequenc agmsequences +agr agree +agreedf +agreedt agreement agrees +agrk +agrkey ags agt +agtt agz ahead ahgkdwhp +ahi +ahis ahlswedezhang ahqedxuapxeywxha ahtml @@ -1822,18 +1935,26 @@ aiffbtbat aiffnbandciffatnotciffb aifftbifffaibif aifftbifffaibifff +aigr aiii aiis ails aim +aiminus aimp +aimpb +aimpl ain aina ainaiaandna +ainequalitytr ainfimumofin +ainfo ains aint ainteger +ainterval +ainv aiota aiotaex aiotaexaiotaiota @@ -1842,6 +1963,7 @@ aiotaint aiotajust aiotaval aiotavb +air airfoil airport airporthasiatacode @@ -1870,6 +1992,7 @@ ala alalbial alan alanbii +alang alanim alanimi alaoglu @@ -1886,6 +2009,7 @@ alcomexcom alcomimw alcoms alcomw +ale alem aleph alephadd @@ -1933,6 +2057,7 @@ alev alevt alex alexander +alexandroff alexandrov alexandrovdiscr alexandrovdiscrete @@ -2084,11 +2209,14 @@ alghomtower alghomunitsequiv alginst alginv +alglattice algmulr algnormfromconst algnormofalgequiv +algo algorithm algorithme +algorithmic algorithms algos algr @@ -2096,6 +2224,7 @@ algrf algrp algsc algsca +algsemilattice algstr algvsca ali @@ -2114,6 +2243,7 @@ alignment alignments alignof aligns +alignwith alim alimd alimdh @@ -2122,6 +2252,7 @@ alimex alimi alimp alinexa +aliquot alist alistp alive @@ -2129,50 +2260,81 @@ alj all all- all-pairs +alla allagree +allallocations +allallocationsequivalence +allallocationsequivalenceextended +allallocationsvarcharacterization allatoms +allblocksread allbutfi allbutfifvre allbutfiinf +allc allch allcha allchar allcoeffs +alld +alldef +alldefs alldifferent alldisjointclasses alldisjointproperties +alle allegorical allem allentries alleq allerrors +allfin allfins allfvars allgoals allgrp alli allimportedmodulenames +allinput +allinstances alllean alllinters +alllsts +alllstse allm allmodules +alln allnames allnamesbymodule allnats allnatslt +allnetsdistinct allnodes +allnotdsource alloc allocate allocated +allocatedtobuyermeanssold allocation +allocationcharacterization allocationcrashawarejournal allocationcrashawarejournalrefinement +allocationdisjoint +allocationdisjointauxiliary +allocationgoodsmonotonicity +allocationgoodsmonotonicityvariant allocationjournal allocationjournalrefinement +allocationmonotonicity +allocationsellermonotonicity +allocationsuniverse +allocationsuniversecharacterization +allocationwithoneparticipant allocator allocb alloclib allocproof +allones alloutput allow allowcompletion @@ -2186,25 +2348,40 @@ allowemptylines allowing allownaturalholes allowopaque +allowportfromto allows allowsplit allowsynthfailures allp +allpairs allperms allprojs allproofs allq +allrdblks +allreg +allrepeats allroots allrules alls allsigns +allstates allsubsets +allt alltacticdocs allunexpectederrors +alluse +alluses allvars allwaysincluded allzfsetdefinable almost +almostcancel +almostcancellative +almostcommutative +almostcommutativering +almostleftcancellative +almostrightcancellative alneu alnex alon @@ -2219,6 +2396,7 @@ alpha alpha_1 alpha_n alphabet +alphaequality alphas alq alral @@ -2251,10 +2429,14 @@ alt alta altb altbound +altc altcat altcongrhom +altdef alter +altered alternate +alternates alternating alternatingcofacemapcomplex alternatingconst @@ -2282,6 +2464,7 @@ alternatingword alternative alternativeformulas alternatively +alternativemagma alternativemonad alternativeoftactic alternatization @@ -2293,6 +2476,7 @@ altgnsg altgsumbc altgsumbcalt although +alti altinfo altitude altitudefoot @@ -2315,10 +2499,15 @@ altsinfo altv altvarnames altvd +altx altxpeq altxpexg altxpsspw +alty +alw always +alwayssfi +alwayswfi alwn alxfr alzdvds @@ -2345,14 +2534,23 @@ amgmlem amgmlemalt amgmw amgmwlem +ami +amic +amicable +amin +amintr aminus +aml amming amn +amod amone among +amor amortized amosym amount +amountf amounts amove amovek @@ -2360,7 +2558,9 @@ ampere amphibian ample ampleset +amr ams +amtx amult amwo amzqplrut @@ -2370,7 +2570,9 @@ anabsan anabsi anabss anadec +anadom anainc +analbinds analogous analogue analogues @@ -2399,6 +2601,7 @@ analyticweierstrasspexcept analyticwithinat analytiques analyze +analyzed analyzeresult analyzetraces analyzing @@ -2418,6 +2621,8 @@ anaturalnumber anb anbi anbiim +anbn +anbncn anbr anbrc anc @@ -2442,6 +2647,7 @@ ancrb ancrd ancri and +andalso andb andba andbac @@ -2451,9 +2657,15 @@ andbc andbca andbf andbt +andcc +andci +andcii +andconc +andd anddi ande anderson +andex andf andfb andfeliml @@ -2466,7 +2678,9 @@ andkind andl andleft andm +andn andnand +andncc andnotim andorxor andp @@ -2474,18 +2688,25 @@ andr andright andrzej ands +andsetseq +andsetseqaux +andsubset +andsubsetaux andtb andthen andthenfn andthenonsubgoals andvec ane +aneg ang angcan angcld +angelic angle angleapb anglebac +angles angneg angpieqvd angpieqvdlem @@ -2494,6 +2715,7 @@ angrteqvd angrtmuld angval angvald +anhil ani anibar anidm @@ -2518,7 +2740,11 @@ anjou anl anmp ann +annbin +anncall +anncomp anneaux +annexpr anni annideal annidealgenerator @@ -2531,27 +2757,44 @@ annihilates annihilating annihilation annihilator +annil +annilr annim +annir +annirr annnr +anno +annonzero +annos annot annotanannot annotate annotatecurpos annotated +annotatefvs annotategotodef annotategotosyntaxdef annotates annotateterminfo annotation +annotationfun annotations annoyance annoyances annoying annoyingly +annpar annprmidl +annrec +annul annuli annulus +annwhile +anon +anonymity anonymous +anonymousd +anonymousi anor anorm anormalformofin @@ -2567,11 +2810,16 @@ answer answered answering ant +antec +antecedent +antecedents anti antichain antichains +antichard anticollision anticomm +anticommutator anticommute antideriv antiderivative @@ -2580,6 +2828,7 @@ antidiagonal antidiagonalequivfin antidiagonals antidiagonaltuple +antidist antidistrib antidomain antihomomorphism @@ -2588,6 +2837,7 @@ antili antilipschitz antilipschitzconstant antilipschitzwith +antimon antimono antiperiodic antiperiodicity @@ -2597,6 +2847,7 @@ antiquotkinds antiquotname antiquotp antiref +antirefl antis antisym antisymm @@ -2604,6 +2855,7 @@ antisymmetric antisymmetrization antisymmetry antisymmrel +antisymp antisymrel antisymrelres antisymrelressn @@ -2613,6 +2865,8 @@ antitoneantitone antitonemonotone antitoneo antitoneon +antitonic +antitonicmonotonic antivary antivaryon antl @@ -2632,22 +2886,29 @@ anxordi any anyalgebra anyappearsintypeproof +anycast +anyd anyfield anyfieldanyalgebra anyfieldcommalgebra anyfielddivisionalgebra +anyit anym anymore +anyp anyrel +anysubset anything anyway anyways anywhere +aodv aok aold aoldn aomclem aoprssdm +aot aov aoveq aovfundmoveq @@ -2664,15 +2925,23 @@ aovvfunressn aovvoveq aowdltjs ap +apa +apac apart +apartnessrelation +apath apc apchild apchildlive apd +apdpe apeq aperm apfst api +apiid +apiidasstr +apiids apikey apiresult apis @@ -2700,27 +2969,39 @@ appendafter appendassociative appendbefore appendcontents +appendd +appende appended appendentries appendentriesreply appendequiv +appendfile appendfun appendhomeomorph +appendi appendindexafter +appending appendisometry appendisometryofeq +appendix +appendl appendlist appendnilrightneutral +appendr appends +appendstep appendstream appfn apphom +appi appio appirrel appiso appl apple +applemmas apples +applic applicability applicable applicati @@ -2729,6 +3010,7 @@ applications applicationtime applicative applicativetransformation +applicativezero applied appliedargs appliedattrs @@ -2736,13 +3018,18 @@ appliedentries applies applinearmap applinst +applist apply apply? applyaction applyaddhom +applyaffinetoline applyapplyrule applyashom +applyat applyattributes +applybackjumpeffect +applybackjumppreservedvariables applyco applycoe applycomposi @@ -2754,8 +3041,12 @@ applycongrthm applyconst applyconstrule applycontrlemma +applydownfrom applyentries applyentry +applyexplainuip +applyexplainuippreservedvariables +applyexplainuiptermination applyfinsupp applyfun applyfunhyp @@ -2765,6 +3056,8 @@ applyid applyidrule applyiff applying +applylearn +applylearnpreservedvariables applymorrules applymulaction applymulsemiringaction @@ -2788,11 +3081,14 @@ applysimpresulttotarget applysum applysymm applytheconstructor +applytoset applytransitionrules +applyupto applywitharity appname appointment appp +appparens appr appro approach @@ -2806,6 +3102,7 @@ approx approxaddorderof approxbounded approxchain +approxcore approxdepth approxgluing approxima @@ -2822,20 +3119,28 @@ approximateunit approximating approximation approximations +approxmc approxon approxorderof apprseq +apps apptop apr apre +apred apren april aprilfools +aprimedivisor apriori +aprog +aprop +apropsof aprove apsnd apsyms apt +apx arb arbitary arbiter @@ -2851,6 +3156,7 @@ arborescence arborescencemk arc arccos +arce arch archabsval archd @@ -2879,10 +3185,16 @@ architecture archive archnq arcosh +arcs arcsin arctan arctanadd arcwise +ard +arden +ardenable +ardenl +ardenr are are_dual area @@ -2901,27 +3213,35 @@ areaval arec arecomplementary areductofin +aredundant areequalizedbylocalization +arefl aren +ares areseparated arewritingsystem arg argaux +argchunk argcj argentry argequiv argid argimgt argimlt +arginfo arginv argkinds arglem argmax +argmaxequivalence +argmaxlemma argmin argminon argnames argo argpartialequiv +argpower argpriority argrege argregt @@ -2932,6 +3252,8 @@ argself argselfadjoint argsgroup argsig +argterm +argtype arguably argue argues @@ -2942,6 +3264,7 @@ arguments ari arise arises +aristo arisum arit arith @@ -2957,26 +3280,38 @@ arithnormalize arithsimplify arithufd arithufdlem +arities arity +arityanalysis +arl arlene armc aro +arof aroots around arp arr arrange array +arraycpy arrayequivlist arraylookup arraylookuplist arraylookupopt arrayofvecfinq arrays +arraysize arraysubsc arrayupdate +arrd +arre +arri arrive +arrivemsg +arrivemsgtt arrives +arrmap arrow arrowaction arrowarrowequivalence @@ -2988,6 +3323,7 @@ arrowcongrright arrowcongrsl arrowequiv arrowhomequiv +arrowi arrowiso arrowisospec arrowmap @@ -3003,7 +3339,12 @@ arrowstalkmapiso arrowstalkmapisoofeq arrowstalkmapspeciso arrowsucc +arrt +arrv +arrval +ars arsinh +arssecure artanh artefacts article @@ -3042,6 +3383,7 @@ arzela arzelaascoli as_ref as_str +asa asalgebrahom asbasis asboolalg @@ -3055,6 +3397,7 @@ ascend ascending ascfactorial ascfactorialbinary +ascii ascl asclcl asclcntr @@ -3077,6 +3420,7 @@ asclval asclzrhval ascofork ascoli +ascp ascpochhamme ascpochhammer ascprf @@ -3086,6 +3430,7 @@ asembedding asemptycocone asemptycone aseq +aseqs asequ asequiv asequivalence @@ -3094,16 +3439,25 @@ asfiber asfiberhom asfork asfun +asfunc asfunctor +asg +asgd asgn asgrouphom ash ashom ashomogeneousideal +asi +asid asidea asideal asidealopposite asiegel +asif +asiff +asig +asimp asin asinbnd asincl @@ -3123,6 +3477,7 @@ asisohomology ask asked asking +aslice aslimit aslimitaux aslimitcone @@ -3134,15 +3489,21 @@ aslower asm asm_simp_tac asmconcursem +asmnowrite asmodule asmoduleequiv +asms asmselfsim +asmtx +asn asnattrans asoc asorderhom +asound asover asoverhom asoverprop +asp aspatialthing aspect aspid @@ -3155,6 +3516,7 @@ aspssid aspsubrg aspval asq +asr ass assa assaascl @@ -3174,6 +3536,7 @@ assapropd assaring assarrginv assasca +asscss assemble assembling assert @@ -3184,26 +3547,39 @@ assertafterresult assertd assertdefeqq asserted +assertedliteralisnotunit asserting assertinstances assertinstancescommute assertion assertionproperty assertions +assertionsr assertleveldefeqq +assertliteral +assertliteralconflictflageffect +assertliteralqeffect asserts asserttt assertunreachable +asses +asset +assets +assg assig assigma assign assignable assigne assigned +assigneq +assigni assignifdefeq assigning assignment assignments +assignnihighlemma +assignnilowlemma assintop assintopass assintopasslaw @@ -3214,14 +3590,21 @@ assist assistant asslaw asslawass +asslist +assm assmall assmallfunctor assmallissifted assms +assmt assn +assni +assnle +assnot asso assoc assocaux +assocd associ associat associate @@ -3269,8 +3652,10 @@ assocquotient assocrel assocright assorted +assp assraddsubd assraddsubi +asst asstring assu assubmodule @@ -3278,16 +3663,20 @@ assubtype assum assume assumed +assumeerror assumeinstancescommute assumes assuming assump +assumps assumpt assumpti assumptio assumption assumptioncore assumptions +assumptionsi +assym ast astab astabs @@ -3296,13 +3685,18 @@ astabsu astabu astask astbstanbst +astdom astep +astg +asti astype astypeequivobjastype astypefincategory astypetoobjastype asubq asubsetof +asubst +asum asup asupper asupremumofin @@ -3314,6 +3708,7 @@ asymmetric asymmetricproperty asymmetry asymp +asympartp asympbound asympto asymptot @@ -3325,6 +3720,8 @@ asymref async asyncmode at-most-once +atab +atable atabs atabsi atan @@ -3362,7 +3759,9 @@ atbot atbtwn atbtwnex atbtwnexoldn +atc atcmp +atcs atcv atcvat atcvati @@ -3373,7 +3772,9 @@ atcvreq atcvrj atcvrlln atcvrnen +atd atdmd +ate atelch atend ateq @@ -3422,6 +3823,7 @@ atlatmstc atle atleast atleastatmost +atleastatmosti atleastlessthan atleastp atleasttwo @@ -3436,6 +3838,7 @@ atlltn atlocal atlpos atlrelat +atls atlt atltcvr atm @@ -3444,7 +3847,9 @@ atmd atmod atmost atmostonefixedpointequivsum +atmostq atms +atmss atn atnaiana atncmp @@ -3459,37 +3864,48 @@ atnle atnlej atnlt atnssm +atoi atom atomg +atomi atomic atomicf atomicfact atomicnucleus atomics +atomicsr atomise atomistic +atomize atoml atomless atomli atomm atoms +atomsimple +atomsinsequenti atomsmsg atomsofsubmodulelattice +atomspropagate +atomuni atone atord atordi atp atpointn +atprecision atprim atprime atpsubcln atpsubn atrans +ats atss atssbase atssch atsseq atssma +att attach attachboun attachbound @@ -3513,7 +3929,12 @@ atto attop attopbot attr +attracted +attractor +attracts +attractsi attrargs +attree attri attrib attribut @@ -3527,9 +3948,13 @@ attrkind attrm attrname attrs +atts atunit atunits +atv +atw atype +audioplayer audit audited auditedreveal @@ -3537,12 +3962,15 @@ aufil auflira aufnira aug +augflow augmen augment augmented augmentedcechconerve augmentedcechnerve augmentedsimplexcategory +augmenting +augmentingflow augmentofisinitial augmentofisterminal augmenttruncate @@ -3568,7 +3996,9 @@ autgalois autgaloissystem autgroup auth +authd authentication +authi author authorisation authority @@ -3576,6 +4006,7 @@ authority_ authors authorslinechecks authorslines +autht autisofibers autmap autmaphom @@ -3603,6 +4034,7 @@ automorphize autonomous autoparam autoparams +autoref autorewrite autring auttopow @@ -3615,6 +4047,7 @@ auxdeclmap auxdeclngen auxdecltofullname auxdft +auxe auxequiv auxfunname auxfunnames @@ -3622,18 +4055,24 @@ auxgluing auxgluingstruct auxgroup auxhom +auxi auxiliaire auxiliary auxiliarydefs auxinv auxisometry +auxl auxlemmas +auxm auxmat +auxr auxtomatrix availability available aval +avaldirekt avar +avars avatar ave aveal @@ -3651,12 +4090,19 @@ avk avl avoid avoided +avoidi avoiding avoids avril +avst +avstore avumguoblzdvezzwjxlqs +await +awaitrule awaits awake +awalk +awalki aware away awayequivadjoin @@ -3667,9 +4113,14 @@ awayto awaytoawayleft awaytoawayright awaytosection +awhd +awidth awkward awkwardness +awlast awn +aws +awtn axac axaci axacnd @@ -3681,6 +4132,7 @@ axaddf axaddrcl axadj axalt +axb axbnd axbtwnid axbun @@ -3749,6 +4201,7 @@ axiomh axiominfo axiomofchoice axioms +axiomsd axis axler axlowdim @@ -3756,6 +4209,7 @@ axlowdimlem axltadd axlttri axlttrn +axm axmp axmulass axmulcl @@ -3806,6 +4260,7 @@ axsepg axsepgfromrep axsn axsup +axt axtd axtg axtgbtwnid @@ -3823,6 +4278,7 @@ axunnd axunndlem axunprim ayae +azmult azwkkvlgz aᵐᵒᵖ aᵐᵒᵖᵐᵒᵖ @@ -3836,6 +4292,7 @@ baae baaf bab baba +babai babbcf babbfec babe @@ -3866,6 +4323,7 @@ background backgroundgoals backing backitup +backlinks backtrack backtracking backup @@ -3890,13 +4348,18 @@ badf badfcebc badfd badguy +badkeys badly badm badmatch badnames badnamesnum badness +badntscount +badntscountset badreduction +badtmscount +badtmscountset badvertices bae baea @@ -3941,8 +4404,13 @@ balancedhull balancedsz balancel balancer +baldl +baldr +balil +balir ball balladdsubgroup +balle balli ballinclusion ballotlem @@ -3987,6 +4455,8 @@ ballotlemsv ballotlemsval ballotth ballpackage +ballpe +ballpi balls ballss ballsubgroup @@ -4002,14 +4472,18 @@ banasiak band bands bang +bangrel +bangrelsubweakbisim bank bapp +bappend baqrn bar barbara barbari barbarialt barbarilem +barbed barcomplex bare baroco @@ -4032,17 +4506,22 @@ bascnvimaeqv basdif base base_type +basecase basechange basechangeaux basechangehom +baseclasses based basedcategory basedfunctor basednatiso basednattrans basedomain +basee baseembedding basefield +basefunctions +basei baseid baseinfo baseio @@ -4071,6 +4550,7 @@ bases baseset basestr basestruct +basetypes baseval basf basfn @@ -4081,6 +4561,7 @@ basi basic basically basicconstructiblesetdata +basicdefs basiclemmas basicopen basicopencover @@ -4091,6 +4572,7 @@ basicopensectionstoaffine basicopentospec basicproperties basicpropertiesinanytopologicalspace +basicrule basics basicsecuritytheorem basicsequentcalculus @@ -4105,6 +4587,7 @@ basisdivisor basisextension basisfreemonoid basisfun +basisi basisinde basisindep basiskaehler @@ -4196,6 +4679,7 @@ bbbdade bbbdb bbbdfa bbbeb +bbbp bbc bbca bbcb @@ -4234,6 +4718,7 @@ bbff bbi bbid bbii +bblue bbr bbuv bbw @@ -4299,6 +4784,7 @@ bceea bceeaa bceeb bceef +bces bcf bcfallfac bcfb @@ -4313,6 +4799,8 @@ bcff bcffbb bcgdwwqyafa bcgq +bch +bchoice bci bclbnd bcle @@ -4326,6 +4814,9 @@ bcneg bcnm bcnn bcnp +bcomp +bcontfun +bcontfunn bcor bcot bcount @@ -4406,6 +4897,7 @@ bddd bdddaf bdddefault bdddistlat +bddh bddibl bddiblnc bddlat @@ -4446,6 +4938,8 @@ bdophmi bdophsi bdopln bdopssadj +bdoubleton +bdt bdy bea beaa @@ -4463,6 +4957,7 @@ beattyseq beaujolais beautiful beb +bebase bebb bebc bebce @@ -4536,16 +5031,20 @@ beftqxwlsz beg begin beginning +begins begintx +beh behave behaved behaves behavior behaviour behaviours +behead behind behrend being +bel belief believe believe_me @@ -4561,11 +5060,18 @@ belong belonging belongs below +belowi +belown +belownext +bempty ben benchmark bendix bendixson benefit +benign +bennett +benv beppo beq beqeq @@ -4574,6 +5080,7 @@ beqrat bequiv ber bergelson +berlekamp berlin bernays bernehmen @@ -4588,6 +5095,7 @@ bernsteinapproximation bernsteinpolynomial berstein bertrand +bertrands besicovitch bespoke bessel @@ -4609,15 +5117,21 @@ betapd betapdf betapdfreal betarev +betas +betasd betathroughlet betathroughletaux beth betree +betseq better betti betw +betwd between betweenness +betwi +beukers beval bevalr beverage @@ -4625,12 +5139,17 @@ beware bex bexi bexp +bexpands +bexpe +bexpi +bexpr beyond bezout bezoutlem bezoutr bezouts bezoutz +bezw bfa bfaa bfab @@ -4699,7 +5218,9 @@ bfp bfplem bfs bfu +bfun bgbi +bge bgen bgfunc bgoldbachlt @@ -4707,8 +5228,11 @@ bgoldbnnsum bgoldbtbnd bgoldbtbndlem bgu +bheight bhenstock +bhle bhmafibid +bhv biadan biadani biadanialt @@ -4739,8 +5263,13 @@ biantru biantrud biantrur biantrurd +bias biass bib +bibd +bibdi +bibdii +bibdiii bibi bibiad bibibi @@ -4756,6 +5285,7 @@ bicategorycoherence bicategorylike bicategorym bicategorynf +bicc bicoloring bicom bicomd @@ -4765,6 +5295,7 @@ bicomi bicomp bicompl bicompr +biconditional bicone biconehom biconeisbilimitofcolimitcoconeofiscolimit @@ -4777,6 +5308,7 @@ bid bidirectional bidirectionalrec bidirectionalrecon +bidmaximizedby bidual bidualisometry bidx @@ -4792,6 +5324,7 @@ bifibrantobjects bifibrantresolution bifibrantresolutionmap bifibrantresolutionobj +biflows bifunctor bifunctorcomp bifunctoriality @@ -4800,13 +5333,18 @@ bifunctors big big-o biga +bigand bigc bigcity bigcup +bigd bigger biggerset +bigi biginter +bignorabimus bignum +bignumtr bigo bigolden bigopbinder @@ -4814,9 +5352,12 @@ bigopbinders bigopbinderspattern bigopbindersprod bigoperators +bigor bigoval bigprod bigstep +bigstept +bigtheta bigunion biheytingalgebra biheytinghom @@ -4862,6 +5403,7 @@ bijectiveresiduefield bijectivity bijectivitycriteria bijects +bijgroup bijinv bijon bijust @@ -4889,6 +5431,7 @@ bills biluk bimap bimod +bimodule bimodules bimon bimonobj @@ -4898,6 +5441,8 @@ bin bina binarith binarithtype +binarize +binarizent binary binarybicone binarybiconeisbilimitofcolimitcoconeofiscolimit @@ -4950,7 +5495,9 @@ binaryproducttriangleisobinarybiproducttriangle binaryrec binaryrecfromone binarysearchcorrect +binarysum binaturality +binb bincast bind bindag @@ -4965,12 +5512,14 @@ bindernamehint binderpred binderpredicates binders +bindet bindgen binding bindingbody bindingdomain bindingname bindings +bindk bindlater bindnow bindofarrows @@ -4978,9 +5527,13 @@ bindonsupport binds bindstacval bindstruct +bindt bindtobase +bindu +bindv binen binentropy +binet binf binfo binfty @@ -4996,6 +5549,7 @@ binintersectt binintersecttelcontra binintersecttercontra bininttransitive +binit bink binom binomcxp @@ -5012,23 +5566,35 @@ binomexpansion binomfallfac binomfallfaclem binomial +binomialexpansion binomialfamily +binomialheap +binomialheapstruc binomialinversetheorem binomialish binomialrandom binomialring binomialseries +binomialterm binomlem binomrisefac binomsc binop +binopelim binp binpos +binqueue binrel binrep bins +binsert +binsup +binsyncv bint binter +bintr +bintree +bintrunc binunion binunione binunionecases @@ -5041,6 +5607,8 @@ binunionte binuniontecontra binuniontilcontra binuniontircontra +binuniv +binv bio biologicalattribute biologicallyactivesubstance @@ -5053,6 +5621,7 @@ biorfri biorfriold biort biortn +bipart bipartite bipartiteabove bipartitebelow @@ -5097,13 +5666,20 @@ bisdomain bisect bisection bisector +bisemimodule bisequence bisim +bisimcoinduct +bisimcoinductaux +bisimeqvt bisimilar +bisimilarity bisimo +bisimtransitivecoinduct bisimulation bisimulations bissectrice +bist bisup bisym bit @@ -5161,9 +5737,13 @@ bjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjj bjorner bjshhmxycizrjrnlmr black +blackd +blacken blacklistinsertion +blacks blah blambda +blank blankextends blankrel blaschke @@ -5177,6 +5757,7 @@ blcntrps blcom blcomps blcvx +bld bldisj ble blelrn @@ -5185,6 +5766,7 @@ blem blen blenfzo blengt +blength blenn blennn blennnelnn @@ -5194,6 +5776,7 @@ blenpw blenre blenval blerat +bleu blex blf blfps @@ -5205,7 +5788,16 @@ blim bliminf blimsup blin +blincomp +blindable +blinded +blinding +blinfun +blinfunpow +blinfuns blist +blists +blk bln blnei blnop @@ -5219,18 +5811,29 @@ blockdiagaddmonoidhom blockdiagonal blockdiagonaladdmonoidhom blockdiagonalringhom +blocked blocker blockers +blocki blockimplicitlambda +blocking blockliftfix blockliftmap blocklist +blockmat blockmatrices blockmem +blocknum +blocknumnelemma +blockonmetas +blockp blocks blocksbool blocksfinequiv blocksfun +blocksize +blocksof +blocksread blocktriangular blocn blocni @@ -5247,8 +5850,10 @@ blow blowing blows blowup +blp blpnf blpnfctr +blptrusted blres blrn blrnps @@ -5266,11 +5871,16 @@ blssps blsub blt blue +blues blunt blur +blv blval blvalps bma +bmake +bmask +bmaski bmc bmeas bminussameexp @@ -5296,8 +5906,10 @@ bndrank bndss bndth bne +bneg bnf bnfkjfagkfobm +bnfs bnj bnlirixzwmxcpz bnlmod @@ -5318,7 +5930,9 @@ bod bodd bodddiv bodies +bodiesderivable body +bodyd bodyinfo bodymotion bodypart @@ -5336,6 +5950,8 @@ boldn bolzano bomb bond +bondy +bonk bonnet boo book @@ -5353,9 +5969,13 @@ booleangenerators booleanisation booleanring booleans +booleansemantics +booleansemiring booleansubalgebra boolequivpunitsumpunit boolesineq +boolfunc +booli boolif boolindic boolindicator @@ -5369,12 +5989,18 @@ boolresult boolring boolringcatequivboolalg bools +boolt +booltomaybe +boolv +boolval boot bootstrap bop bopen bor bordeaux +border +bordered borderson borel borelcaratheodory @@ -5393,6 +6019,7 @@ bornologies bornology bornot borsuk +boruvka bosch bot bot_add @@ -5408,10 +6035,12 @@ botel botequiv botequivofinjective botequivpunit +botf both bother bothering bothfbothsame +bothl bothom bothomclass bothtbothsame @@ -5430,6 +6059,7 @@ bottomup bottopology bouac boun +bouncing bound bound_vars boundar @@ -5446,6 +6076,7 @@ boundaryspectrum boundboundnat boundc boundconfig +boundd bounded bounded-2 bounded-m @@ -5461,13 +6092,18 @@ boundedcontinuous boundedcontinuousfunc boundedcontinuousfunction boundedcontinuousmapclass +boundedd boundeddiv +boundede boundedfiltersubalgebra boundedfiltersubmodule boundedfoo boundedformula boundedgenhdsclass +boundedgreatest +boundedi boundedinv +boundedjoinsemilattice boundedlattice boundedlatticehom boundedlatticehomclass @@ -5475,6 +6111,7 @@ boundedlemax boundedlenhdsclass boundedlimitrec boundedlimitrecon +boundedmeetsemilattice boundedmul boundednat boundedneg @@ -5496,8 +6133,12 @@ boundedsub boundedunder boundedvariation boundedvariationon +boundedvec boundedwrt +boundeffect +boundes boundfvars +boundi bounding boundingsieve boundl @@ -5509,7 +6150,10 @@ boundnormalmult boundnormnum boundofdiscbdd boundoneprecision +boundouputlengthsimp +boundoutputlengthsimp boundoutputs +boundoutputsupportderivative boundp boundr boundrcorrect @@ -5517,6 +6161,7 @@ boundrropp bounds bourbaki bourbakipkg +boustrophedon bowt bowtie box @@ -5530,9 +6175,11 @@ boxa boxadditivemap boxc boxcutc +boxe boxed boxer boxes +boxi boxicc boxintegral boxpoly @@ -5544,9 +6191,14 @@ boxprodleft boxprodright boxprodsumdistrib boxriin +boxs bozo bpar bpc +bpd +bpe +bpi +bplustree bpoly bpolycl bpolydif @@ -5561,6 +6213,12 @@ bpow bpowpsubone bpowtwop bpre +bpred +bprog +bprv +bps +bpspec +bqtran bra braadd brab @@ -5574,6 +6232,7 @@ brabidgaw brabn brabsb brabv +braces bracket bracketedbinder bracketedbinderf @@ -5611,6 +6270,7 @@ brange branmfn brapply brauer +braun braval brbigcup brbtwn @@ -5661,6 +6321,7 @@ breaks breakss breathing brecop +bredundant brel breldm breldmd @@ -5672,6 +6333,7 @@ brelrn brelrng bren breng +brent breprexp breprexplema breprexplemb @@ -5693,6 +6355,7 @@ breqtrri breqtrrid brers brerser +bres brfae brfi brfinext @@ -5713,6 +6376,7 @@ brgric brgrici brgrilci brgrlic +brickmat brid bridge bridgeedges @@ -5733,6 +6397,7 @@ brinxper brinxprnres britisch briunov +brk brl brlb brle @@ -5742,10 +6407,12 @@ brmptiunrelexpd brn brne brneqtrd +brnl brnonrel broad broadcast broadimportscheck +brocot brofs broken bropabg @@ -5821,12 +6488,16 @@ brtxp brtxpsd brub bruce +bruijn +brujin brun +brute brv brvbrvvdif brvdif brvitykt brvvdif +brw brwdom brwdomi brwdomn @@ -5835,10 +6506,17 @@ brxp brxrn brxrncnvep bsc +bsd bsearch bseq +bset bsh bshift +bsi +bsia +bsimp +bsingleton +bsinleton bsize bsle bsp @@ -5848,13 +6526,18 @@ bsquares bss bst bstinsert +bstl +bstr bstsearch +bsu +bsub bsubc bsup bsupr bsv btl btqmwppyu +btran btrans btree btrue @@ -5886,17 +6569,22 @@ bubble buch buchaux bucket +budan buddy budget +buechi buf bufal buffer bufferdisk buffered +buffermode bufferoffsets buffers bufferseq +buffon bug +bugget bui build buildclause @@ -5910,19 +6598,25 @@ building buildiscolimit buildislimit buildlimit +buildmatcher buildproof buildproofstep buildreify builds +buildtab +buildtabw buildtr buildtransitiveleproof buildtransitiveleproofdfs buildup +buildupi built built-in builtin builtineffect builtineffectpolymorphic +builupi +builupicorr bulk bullet bump @@ -5944,13 +6638,16 @@ bundling bundlings buni bunion +bunit burgundy burns burnside burnsidetransfer +busemann but butfirst butlast +butlasti buttercup butterfly buy @@ -5978,7 +6675,9 @@ bvmul bvnat bvneg bvnot +bvo bvor +bvs bvsdiv bvsge bvsgt @@ -5995,10 +6694,13 @@ bvule bvult bvurem bvxor +bvxorxor bwd bwind +bword bwt bwth +bwtn bxe bxsocsqrxvvxnp by @@ -6012,14 +6714,19 @@ bycontradiction bydefinition byex byf +byfix +byi byki bypass byte bytei byteidx +byteindex bytelist bytelistreader bytes +bytestring +bytev byzantine bzrehtvtynyxlexvfgo bᵐᵒᵖ @@ -6055,12 +6762,17 @@ cacdce cace cacea cacf +cach +cachassum cache cacheappliedentry cacheapplyentry +cachedweight cachefailure cacheocc +cachera cacheresult +cact cad cada cadan @@ -6102,7 +6814,10 @@ cafff caflisch cagamidae cai +caids caineq +cake +cakeml cal calc calcpanel @@ -6122,11 +6837,22 @@ californiawine call callc callcc +callcommand +calld +calldata +calle called +callee caller calling +calll +callprim +callprocess +callprocesswithexitcode callproof +callr callred +callrule calls cam cambridge @@ -6154,12 +6880,16 @@ canceldenominatorsat canceldenominatorsintype canceldenominatorstarget canceldenoms +canceled +canceli +canceling canceliso cancelisosimproc cancellable cancellation cancellationlemmas cancellative +cancellativecommutativesemiring cancelleads cancelling cancelmonoid @@ -6179,6 +6909,7 @@ candidatesbdist candidatesbofcandidates caneqmixin canf +canlen canlift canliftcardinalnat canliftcontinuouslinearequiv @@ -6187,6 +6918,7 @@ canliftpnat canliftset cannon cannot +cannotbe cano canomalepidae canon @@ -6202,6 +6934,7 @@ canonicalembedding canonicalequiv canonicalfactor canonicalinterpretation +canonicalizepath canonically canonicallylinearorderedaddcommmonoid canonicallylinearorderedmonoid @@ -6218,7 +6951,10 @@ canonicalpo canonicalsized canonicaltopology canonicfulp +canonize canonizer +canrepr +canrepri cantelli canth canthnum @@ -6309,6 +7045,7 @@ capital capitalization capitalize capp +capped capsourceinfo capsyntax capture @@ -6344,14 +7081,18 @@ caratheodory caratheodorydynkin caratheodorylem caratheodorymeasurable +caraudiosystem carbon card card_mono +carda cardadju cardaleph cardalephex +cardano cardcf cardcommutatorbound +cardd carddistinctfactors carddom carddomi @@ -6361,10 +7102,12 @@ cardennn cardeq cardeqv cardeqzeroequivequivempty +cardex cardf cardfactors cardfiber cardfz +cardg cardge cardhom cardi @@ -6396,6 +7139,7 @@ cardnum cardom cardon cardonle +cardord cardpowdegree cardpowdegreeisadmissible cardprc @@ -6406,6 +7150,7 @@ cards cardsdom cardsdomel cardsdomelir +cardshift cardsn cardsucinf cardsucnn @@ -6425,11 +7170,14 @@ caret carg cargs carmichael +caro carr carri carrier carrierequiv +carrierp carries +carrots carry carrying cars @@ -6449,6 +7197,7 @@ cartanmatrix cartanmatrixeq cartanmatrixin cartansubalgebra +carter cartesian cartesianclosed cartesianclosedfunctorofleftadjointpreservesbinaryproducts @@ -6468,6 +7217,7 @@ cartesianmonoidalcategorywhiskerleft cartesianmonoidalcategorywhiskerright cartesianpower cartesianproduct +cartesianproductwith cartesien cartprod cartprodfstin @@ -6485,6 +7235,7 @@ cascading case case_eq casea +caseapp caseb casebashing casec @@ -6493,6 +7244,7 @@ cases casesauxon casescons casesdan +casesi casesifp casesm casesmatcher @@ -6503,6 +7255,8 @@ casespecific casestronginductionon casestrongrecon casestype +casew +cash casing cass cast @@ -6516,6 +7270,7 @@ castback castchoose castdef castdropb +castelim castembeddi castembedding castequivalence @@ -6536,6 +7291,7 @@ castlequiv castlt castmdata castmode +castmsg castnum castorderembedding castorderiso @@ -6572,6 +7328,7 @@ catcenter catcfuccl catch catches +catchet catchnone catchom catchomcl @@ -6582,6 +7339,7 @@ catciso catcisoi catcisolem catcocl +catcod catcofval catcommsq catcommsqover @@ -6632,6 +7390,7 @@ catidd catideu catidex catlid +catmaybes catpropd catprs catprsc @@ -6641,6 +7400,7 @@ catrid cats catstr catsubcat +catt cattoreflquiver catype cau @@ -6688,6 +7448,7 @@ caussi caution cautomobile cav +cava caveat cax cayhamlem @@ -6704,8 +7465,10 @@ cbae cbaefb cbaf cball +cballe cballs cban +cbasis cbb cbba cbbc @@ -6731,6 +7494,7 @@ cbdb cbdc cbdd cbdf +cbdi cbe cbeb cbeba @@ -6742,6 +7506,7 @@ cbeed cbef cbefaa cbefb +cbelow cbetter cbf cbfbc @@ -6753,7 +7518,10 @@ cbfddb cbfebdb cbff cbffb +cbfi cbi +cbig +cbigd cbighi cbigphi cbipedidae @@ -6762,10 +7530,16 @@ cbisup cblinfun cbloc cblockz +cbmi cbn cbncms cbool +cbov +cbovi +cbox cbruce +cbs +cbsi cbursitishtm cbv cbvab @@ -6956,12 +7730,14 @@ ccaadd ccaae ccab ccabfa +ccache ccad ccadc ccaec ccafa ccafbc ccar +ccard ccase ccased ccat @@ -7033,6 +7809,7 @@ ccede ccee ccef ccefa +ccext ccf ccfbccef ccfe @@ -7052,21 +7829,32 @@ ccinftyn ccinftyssccbar cckb ccl +cclasst ccly +ccode ccoid ccold +ccollect +ccomp +ccompatible ccompinsert ccondx +cconst ccontinuous ccordylidae +ccorec +ccorrese ccos ccosh +ccpo ccring ccrocodylidae ccs +ccspan ccssccbar cctop cctx +ccw ccwfwwf ccyfbfcepmf cda @@ -7110,6 +7898,7 @@ cdddr cdde cddefb cddf +cddo cddr cde cdea @@ -7119,6 +7908,8 @@ cdec cded cdee cdef +cdens +cdep cdeqab cdeqal cdeqcv @@ -7139,7 +7930,17 @@ cdfc cdfd cdff cdffaa +cdfi +cdib +cdidi +cdifi +cdijkstra +cdim cdinngerhlvf +cdiov +cdis +cdisi +cdist cdivcncf cdj cdjreui @@ -7191,15 +7992,21 @@ cdleml cdlemm cdlemn cdlim +cdm +cdmode cdmsn cdot cdotlinter cdots cdottk cdouble +cdov +cdplayer cdr +cdrop cdrs cdsub +cdtypeid cea ceaa ceab @@ -7299,6 +8106,8 @@ celaront celess celim cell +cellcomplex +cellcomplexes cellfrontier cells cellsofrowlens @@ -7337,6 +8146,7 @@ centroidhom centroidweights centroidweightsindicator centroidweightswithcircumcenter +cenum cenv ceq ceqex @@ -7360,7 +8170,9 @@ ceqsrex ceqsrexbv ceqsrexv cequiv +cer cercle +ceros cert cert_0000 cert_0001 @@ -7372,9 +8184,13 @@ certificates certificates_ certification certified +certifier +certify +ces cesare cesaro ceuromp +cev ceval cevath cevathlem @@ -7382,6 +8198,8 @@ ceven cewfgipgjjdqr cex cexp +cexpr +cexpri cext cfa cfaa @@ -7412,6 +8230,7 @@ cfcl cfcnnrpow cfcof cfcoflem +cfcomp cfcrpow cfcsqrt cfcunits @@ -7448,15 +8267,25 @@ cffe cffed cfff cfffe +cffi cfflb cffldtocusgr cffldtocusgrold cfg +cfgexit +cfgs cfhama cfhase +cfi +cfib +cfid +cfidi cfidm cfield +cfif +cfifi cfil +cfile cfilfcls cfilfil cfilfval @@ -7470,12 +8299,17 @@ cfiluexsm cfilufbas cfilufg cfiluweak +cfim cfinfil cfinite cfinufil +cfiov cfire +cfis +cfisi cfixpoint cfkrkxh +cfl cfle cflecard cflem @@ -7483,15 +8317,24 @@ cflemold cflim cflm cflute +cfm +cfn +cfni cfoggy cfom cfon +cfov cfox cfpwsdom +cfrac +cfread +cfs +cfseq cfsetsnfsetf cfsetsnfsetfo cfsetsnfsetfv cfsetssfset +cfsize cfslb cfslbn cfsmo @@ -7501,8 +8344,16 @@ cfst cfsuc cfub cfun +cfunc cfuucbho cfval +cfwrite +cfwriteextendfilesize +cfwritenoextendpreservesfilesize +cfwritepreserves +cfwritepreserveslastblockinvariant +cfwritepreservesnextfreeblockinvariant +cfwritepreservesunallocatedblocksinvariant cgambler cge cgekkonidae @@ -7548,6 +8399,7 @@ cgrtr cgrtrand cgrtriv cgrxfr +cgs cgsex cgsexg cgusty @@ -7556,6 +8408,7 @@ cha chaar chabs chacha +chagrov chain chainbot chainbotcoeff @@ -7572,7 +8425,9 @@ chaincomplexxoneiso chaincomplexxzeroiso chainheight chaining +chainlen chainlength +chainmap chains chainsfunctor chainsiso @@ -7616,17 +8471,27 @@ changeuserr changing chanid channel +channels +chaos +chaoticnats +chapman chapp chapter chapters char chara +charac charact characte character +characterdata characterisation characterisations +characterise +characteriseax +characteriselast characterises +characteriseseq characterising characteristic characteristicfunction @@ -7637,10 +8502,12 @@ characterized characterizes characterizing charactermodule +characterp characters characterspace characterspacehomeo characterspacetospectrum +characterstic charalghom charandcard chardonnay @@ -7656,6 +8523,7 @@ charge charly charmatrix charmonoidhom +charn charone charp charpoly @@ -7663,6 +8531,7 @@ charpolyrev charrp chars charset +charsinbase chart chartat charted @@ -7682,18 +8551,21 @@ chase chases chasing chasles +chaum chaussettes chcoeffeq chcoeffeqlem chcompl chcon chcv +chd chdmj chdmm cheadache cheap cheaper cheapest +cheb chebbnd chebyshev check @@ -7706,6 +8578,7 @@ checkandsortrewritelemmas checkapp checkblocklist checkcache +checkcast checkcastallowed checkcolgt checkcomposition @@ -7717,12 +8590,17 @@ checked checkemoji checker checkers +checkert checkexistingtype checkexponent +checkfilepath checkforunusedcustomprojs checkhex +checkin checking checkinterrupted +checkislistofvariables +checkisring checknot checknotassigned checkpoint @@ -7731,12 +8609,15 @@ checkrequest checkresult checkrewrite checks +checkse checkstr checksuccess checksynthorder checksystem checktypeq +checkvarvalue checkws +cheeger cheerios chel cheli @@ -7776,6 +8657,7 @@ chi-squared chianti chicken chil +chilbert child childfailures childngen @@ -7814,6 +8696,7 @@ chjoi chjval chjvali chk +chkchop chkrange chktrack chlcsschl @@ -7867,6 +8750,8 @@ chnsubseqword chnsuslle chnub chnwrd +cho +choalgorithm chobjsc chobjscpcp chobjscpsp @@ -7880,14 +8765,18 @@ chocnul chocunii chocvali choice +choiced +choicee choicefi choicemixin choices choicetype +choinitconfig chokes chole choles chom +chonextconfig choos choose choosearg @@ -7897,12 +8786,14 @@ choosebinder choosedecomposition chooseenteringvar chooseexitingvar +choosenext choosenonempty choosepivots chooses choosex choosing chop +chopd chord chordthm chordthmalt @@ -7911,7 +8802,11 @@ chore choreographic choreographictypechecker choreography +chorun chosen +chosenallocation +chosenallocationalg +chosenallocationequivalence chosenfinitecoproducts chosenpullback chosenpullbacks @@ -7973,6 +8868,7 @@ chrval chscl chscllem chseli +chset chsh chshii chslej @@ -8024,6 +8920,7 @@ chudnovskyterm chuffed chunk chunks +chunksof chunssji church churchrosser @@ -8050,20 +8947,30 @@ cidffn cidfn cidfval cidpropd +cidr +cidrsplit cidval cif +cignorabimus cih ciinf +cil +cimage cin cinc cind +cindex +cindexp cinduction cinfi +cinfinite cinfo +cinner cintro cinv cioo cipher +ciphers cir circ circcn @@ -8081,16 +8988,19 @@ circlemap circlemeth circlemethhgt circlemethnat +circlepath circles circletransform circletransformboundingfunction circletransformderiv circlevma +circline circonscrit circonscrits circsubm circtopn circuit +circuiti circuits circulant circulantgraph @@ -8109,6 +9019,8 @@ circumstances circumvents cirreflexive cis +cisinvar +cisk cisup citing citizen @@ -8186,23 +9098,28 @@ clash clashing class classargs +classcast +classd classdef classdefre classdefreducibility classes classexpr classgroup +classi classic classica classical classicalfacts classicalrecon +classicmark classification classified classifier classify classifying classifyingspaceuniversalcover +classmain classname classnumber classp @@ -8218,11 +9135,23 @@ clatlem clatlubcl clatp clatpos +clattice +clausal clause +claused +clausefalse +clausefalseinprefixtolastassertedliteral +clausefalseremove +clauseorderirrelevant clauses clauseset +clausetautology clausetopropf +clausetrue +clausetrueremoveduplicateliterals +clausetrueremovefalseliterals clb +clc clcllaw clcnvlem cld @@ -8237,6 +9166,7 @@ cldmreon cldopn cldrcl cldregopn +clds cldss cldssbrsiga cldsubg @@ -8262,6 +9192,7 @@ clearauxdeclsinsteadofrevert clearbody clearexcept clearing +clearjunk clearly clears clel @@ -8273,6 +9204,7 @@ cleljusti clelsb clem clemb +clen cleptotyphlopidae cleq cleqf @@ -8406,6 +9338,7 @@ climxrre climxrrelem climz clinear +clinit clintop clintopcllaw clintopval @@ -8420,6 +9353,10 @@ cliqueset clist clively cljzrib +clk +clkp +clks +clkvt cllaw cllem clm @@ -8492,11 +9429,14 @@ clnbusgrfi clneighbvtx clo clock +clocked +clocks clog clogician clogzpowgi clone cloned +clop clopen clopenable clopenbasis @@ -8506,6 +9446,7 @@ clos close closecomment closed +closeda closedabsc closedabsconvexhull closedb @@ -8529,15 +9470,18 @@ closedembeddingcfc closedembeddingcontinuousfunctionalcalculus closedfield closedgraphthm +closedi closedicitop closedicitopology closedihom closediictopology +closedin closedinterior closedm closedn closedness closedofhasleftdual +closedph closedpoint closedpoints closeds @@ -8596,6 +9540,8 @@ closestroundedmodep closestsymmetric closesttotal closestulp +closesubst +closesubsteqvt closing closu closur @@ -8606,6 +9552,7 @@ closurecommutatorrepresentatives closureequivadjoinint closureequivadjoinnat closurehascore +closurei closureisclosable closurem closurenonunitalcommringofcomm @@ -8642,15 +9589,20 @@ clsneircomplex clsnsg clsocv clss +clsscomp clsslem clsss clssubg +clst clstop clsun clsval clt +cltn clublem +clubsuit clumsy +clunky cluster clustering clusterpt @@ -8738,8 +9690,11 @@ clxf cly clyle cmachine +cmap +cmax cmbr cmbri +cmc cmclsopn cmcm cmcmi @@ -8748,6 +9703,7 @@ cmcmlem cmd cmddu cmdfval +cmdi cmdiff cmdiffat cmdlan @@ -8755,6 +9711,7 @@ cmdmdi cmdpropd cmdrcl cmds +cmdspec cmeat cmem cmeoprfmhab @@ -8769,15 +9726,20 @@ cmetmeti cmetsp cmetss cmextension +cmfi cmgmalt cmh +cmib cmidi +cmim +cmin cmj cmknlmsvsqdji cmlr cmm cmmbl cmmdi +cmmi cmn cmnbascntr cmncom @@ -8792,6 +9754,9 @@ cmo cmod cmodscexp cmodscmulexp +cmono +cmov +cmovi cmp cmpcld cmpcmet @@ -8806,6 +9771,7 @@ cmphaushmeo cmphmph cmpidelt cmpkgen +cmpl cmple cmppcmp cmps @@ -8815,9 +9781,11 @@ cmpt cmptop cmpu cmpusing +cms cmscmet cmscsscms cmsg +cmsi cmslssbn cmslsschl cmsms @@ -8832,6 +9800,7 @@ cmtfvaln cmtidn cmtvaln cmul +cmult cmulxsubonecotangent cmvth cmvthold @@ -8924,6 +9893,7 @@ cnelprrecn cnelsubc cnelsubclem cnelywb +cnequal cnex cnexalt cnext @@ -8934,6 +9904,7 @@ cnextfun cnextfval cnextfvval cnextrel +cnextstate cnextucn cnextval cnf @@ -8942,6 +9913,7 @@ cnfcom cnfcomlem cnfdmsn cnfex +cnfi cnfld cnfldadd cnfldaddold @@ -9012,6 +9984,11 @@ cnims cnindis cnindmet cnioobibld +cnj +cnjct +cnjel +cnjer +cnji cnk cnlem cnlimc @@ -9074,6 +10051,7 @@ cnnvm cnnvnm cnnvs cno +cnode cnold cnonneg cnop @@ -9126,6 +10104,7 @@ cnrmnrm cnrmtop cnrnvc cnrrext +cns cnso cnsqrt cnsrexpcl @@ -9133,6 +10112,7 @@ cnsrng cnsrplycl cnss cnsscnp +cnst cnstrcvs cnsubdrglem cnsubglem @@ -9142,6 +10122,10 @@ cnsubrglem cnsubrglemold cnt cntabl +cntce +cntd +cnte +cnth cnti cntj cntmeas @@ -9158,8 +10142,10 @@ cntrnsg cntrss cntrsubgnsg cntrval +cntset cntupdatel cntx +cntxt cntz cntzcmn cntzcmnf @@ -9186,6 +10172,7 @@ cntzsubrng cntzun cntzval cnumber +cnureq cnv cnvadj cnvbrabra @@ -9277,9 +10264,12 @@ cnyq cnzh co2e coa +coaction +coactsimp coafval coahom coalesce +coalg coalgcat coalgebra coalgebraequivalence @@ -9331,10 +10321,12 @@ cochainsfunctor cochainsiso cochainsmap cocli +coclop coclosed coclosedcompact coclosedlind coclosedlindelof +coclosure cocnv cocnvcnv cocnvf @@ -9344,6 +10336,7 @@ cocompactmap cocompactmapclass cocomplex cocon +cocond cocone coconeapp coconeat @@ -9411,6 +10404,7 @@ coconetypesiscolimit coconeunop coconeunopofcone cocontinuous +cocorrect cocossss cocountable cocycle @@ -9435,11 +10429,15 @@ codd code code_ codeaction +codegen +codegree codek +codep codes codesc codescendsalong codesupp +codet codetecto codetector codewords @@ -9466,9 +10464,11 @@ codomains codomaintopologicalspace codomainuniqueuptoiso codome +codomi codrestrict codrestricteqlocuspushoutcocone codrestrictofinjective +codtotal coe coeadd coeaddhom @@ -9476,6 +10476,7 @@ coeaddlem coeaddmonoidhom coealgequiv coealghom +coec coecj coecjold coecle @@ -9503,6 +10504,7 @@ coefficient coefficients coeffintegernormalization coefflist +coeffm coeffmonoidhom coeffof coeffs @@ -9546,6 +10548,7 @@ coematrix coemllist coemonad coemonoidhom +coempty coemptyd coemul coemulc @@ -9642,8 +10645,10 @@ coexg coexist coext coextendscalars +coextensive cof cofactor +cofactorm cofan cofanhomequiv cofaninl @@ -9659,6 +10664,7 @@ cofantypes cofcut cofcutr cofcutrtime +coffax coffee coffib coffth @@ -9677,8 +10683,10 @@ cofilteredclosure cofilteredclosuresmall cofilteredinitialmodel cofilteredlimits +cofin cofinal cofinality +cofinitary cofinite cofinitetopology cofipsgn @@ -9728,6 +10736,7 @@ cognitiveagent cogrothendieck coh coheight +cohen cohere coherence coherencecomp @@ -9766,7 +10775,10 @@ coimisoim coin coinc coincide +coincidence +coincident coincides +coinciding coincs coind coindep @@ -9780,6 +10792,7 @@ coindtoind coindu coinduced coinducingcoprod +coinduct coinduction coinductiv coinductive @@ -9794,7 +10807,9 @@ coinflipspace coinflipuniv coinfnattrans coiniss +coinitial coinitslts +coins coinvariants coinvariantsadjunction coinvariantsequiv @@ -9819,6 +10834,7 @@ coinvariantstofinsupp coinvariantstprodleftregularlequiv coires coiun +cok coker cokeriscokernel cokerisoker @@ -9870,6 +10886,7 @@ cokleisli col cola colcom +cold coldn coldtemperature cole @@ -9878,6 +10895,7 @@ colexicographic colexicographical colgt colhp +coli colim colimcompflipisowhiskercolim colimconstadj @@ -9914,6 +10932,7 @@ colimitflipcompcolimisocolimitcompcolim colimitflipisocompcolim colimitgluingdata colimithomisolimityoneda +colimiti colimiting colimitinvaux colimitiscolimit @@ -9977,6 +10996,7 @@ colinearperm colineartriv colinearxfr colinrel +colist coll collage collapse @@ -9989,6 +11009,8 @@ collec collect collect_type_vars collectatoms +collectd +collecte collected collectedbasis collectedorthonormalbasis @@ -10017,15 +11039,20 @@ collectunusedinstanceidxsof collen colleq collexd +colli collideswith colline collinear collinearity +collint collision +collisioni colmez colmid +colmode cologne colon +colookup coloops colopp color @@ -10040,6 +11067,11 @@ coloringtwoofvert coloringtwoofverts colors colour +coloured +colouring +colouringi +colourings +colours colperp colperpex colperpexlem @@ -10099,6 +11131,8 @@ combb combc combi combin +combinable +combinablei combination combinations combinator @@ -10142,6 +11176,7 @@ coming comk coml comlaw +comlist comm comm_monoid_add comm_monoid_mult @@ -10176,6 +11211,7 @@ commandstart commaobj commapplicative commas +commasep commatogrothendieckprecompfunctor commbialgcat commbialgcatequivcomoncommalgcat @@ -10224,7 +11260,10 @@ commisometry commit commitifnoex commitindex +commitment committed +committee +committees committing commitwhensome commixin @@ -10256,11 +11295,14 @@ commmontypeequivalencecommmonforget commmul common common-knowledge +commonarefl commondenom commondenomoffinset +commondomain commonexttangents commonfactor commoninttangents +commonknowledge commonly commonneighbors commonretraction @@ -10315,6 +11357,7 @@ commsq commsqofhasstrongepimonofactorisation commsquarem commstrictorderedring +commte commtensorleft commtensorright commtn @@ -10329,9 +11372,15 @@ commut commutant commutation commutative +commutativemagma +commutativemonoid +commutativering +commutativesemigroup commutativesemiring +commutativesemiringwithoutone commutativesquarepresenter commutativetrianglepresenter +commutativitiy commutativity commutator commutatorelement @@ -10349,6 +11398,7 @@ commx commz commι commπ +comof comoid comon comona @@ -10390,12 +11440,14 @@ compactconvergence compactconvergenceclm compactconvergenceuniformity compactcovering +compactd compactdomain compactdvr compactexhaustion compacticcspace compactification compactifications +compactin compactly compactlycoherentspace compactlygenerated @@ -10439,6 +11491,7 @@ compalternatingmap companion compar comparable +comparables comparatively comparator compare @@ -10473,10 +11526,14 @@ comparisonresult comparisonrightadjointhomequiv comparisonrightadjointobj comparisons +compass compassmallfunctorequivalence compassmallfunctorequivalencefunctor compassmallfunctorequivalenceinverse compat +compatat +compatatm +compatch compatibilities compatibility compatibilitycounit @@ -10500,6 +11557,7 @@ compatiblesm compatiblesmul compatibleyonedafamily compbilinform +compc compcert compchangeofvariables compclm @@ -10529,6 +11587,10 @@ compcreatescolimitsofshape compcreatesfinitecolimits compcreatesfinitelimits compcreateslimitsofshape +compd +compdefinede +compdefinedi +compdefop compder compe compeex @@ -10536,7 +11598,9 @@ compensation compeq compequiv compequivalencefrommodelinverseiso +compet competes +competitive compeval compevaluation compexactvalue @@ -10546,10 +11610,13 @@ compforgetaugmented compforgetaugmentediso compformalmultilinearseries compfst +compfun +compfuncaraudiosystem compfunctor compfunctorforgetofisthin compgrothendieckproj comphahnseries +comphat comphaus comphauslike comphausliketotop @@ -10568,8 +11635,11 @@ compile-time compiled compiledecl compiledefn +compileexpr compileinductive compileinductiveonly +compileprim +compileprog compiler compiles compilesizeof @@ -10595,6 +11665,7 @@ compleftid compleftinverse compleftmonoidhom compleftringhom +complem complembedding complembeddingof complement @@ -10614,6 +11685,7 @@ complementte complementti complementtnotintersectt complementunioninpowersetcomplement +complen compleq complequiv complet @@ -10629,6 +11701,8 @@ completebooleanalgebra completecopy completed completedcoszeta +completedfrom +completedfromo completedhurwitzzetaeven completedhurwitzzetaodd completedigraph @@ -10725,6 +11799,7 @@ compliance complicated complications compliehom +complies complimitfunctoriso complinearequiv complinearmap @@ -10735,6 +11810,7 @@ complp complpl compls complss +compltete complusgraph compmap compmeasurable @@ -10762,25 +11838,32 @@ components componentsrev componentwise componentwisediagram +composable composablearrows composablearrowsfunctor compose composeandsheafify composed +composees +composei composepath +composerel composes composing composite composites composition compositional +compositionality compositionasset compositionassetequiv compositionequiv compositionfintype compositions compositionseries +compound compow +compp comppartialsumsource comppartialsumtarget comppartialsumtargetset @@ -10797,6 +11880,7 @@ compquadraticmap compquasime compquasimeasurepreserving compr +compre comprehensible comprehension comprel @@ -10804,6 +11888,7 @@ comprelationaux compresolutionnattrans compress compressed +compressedi compression compressions compright @@ -10815,6 +11900,7 @@ comprightl compringequiv compringhom comps +compsec compset compsl compsnd @@ -10855,6 +11941,7 @@ computation computational computationally computations +computatition compute computeasymptotics computed @@ -10869,6 +11956,8 @@ computer computerprogram computes computing +compv +compvalidv compwithzero compyonedacolimitisocolimitcompyoneda compyonedacompwhiskeringleftmaxright @@ -10880,12 +11969,15 @@ comraddi comring comringmixin comringtype +coms +comsectyping comt comtvd comul comulalghom comultiplication con +conat conax conc concat @@ -10896,12 +11988,19 @@ concatenates concatenation concatenations concatfn +concati +concatmap +concatmapl +concatmaps +concatmapstep concatrec concatrecaux concatsubpath +concatwith concave concaveon concavity +concd conceivedthru conceivedthruitself concept @@ -10913,11 +12012,14 @@ concern concerned concerning concerns +conci conciseness concl +concls conclude concludes conclusion +conclusioni conclusions conclusiontype concom @@ -10927,11 +12029,14 @@ concretecatego concretecategory concretecategoryhom concretely +concretenesssemantics concur concurrency concurrent concurrentcompilercorrectness concurrentcompilersafety +concurrentd +concurrenti concyclic cond condan @@ -10956,6 +12061,9 @@ condexpk condexpkernel condexpl condexpunexpander +condfalse +condhighcompositionality +condi condindep condindepfun condindepset @@ -10986,9 +12094,16 @@ condkernelcountable condkernelreal condkernelunitborel condkernelunitreal +condless condlexp condlexpunexpander +condlowcompositionality condm +condrule +conds +condsi +condtrue +conduct conductor conductorset condunexpander @@ -11064,15 +12179,19 @@ conesisocomponentinv coneunop coneunopofcocone conf +confid +confidasstr confidence confidential confidentiality +confids config configitem configs configurable configuration configured +confine confirming confl conflating @@ -11082,6 +12201,7 @@ conflictrange conflicts confluence confluent +confluentd confluentreduce conformal conformalat @@ -11092,6 +12212,9 @@ conformalintocomplexplane conformality conformalpregroupoid conformance +confs +conft +confts confun confused confuses @@ -11102,8 +12225,13 @@ conga congabseq congadd congal +congd +conge congen +congi congid +congl +congls congmul congneg congr @@ -11150,13 +12278,19 @@ congruence congruences congruencesubgroup congruencesubgroups +congruencesubsetweakbisim congruent +congruentp congruentz +congs congsub congsym congtoclass congtr +congw +coni conic +conical conimpf conimpfalt conj @@ -11167,9 +12301,12 @@ conjalgequiv conjaut conjby conjcae +conjcases conjclasses conjcle conjcontinuousalgequiv +conjd +conje conjecture conjeq conjexponent @@ -11179,6 +12316,7 @@ conjghm conjgl conji conjinvariantsubalgebra +conjl conjlie conjmap conjmul @@ -11189,8 +12327,11 @@ conjnmz conjnmzb conjnormal conjnsg +conjoin +conjr conjringequiv conjrootclass +conjs conjstaralgaut conjstaralgequiv conjsubg @@ -11199,9 +12340,12 @@ conjtranspose conjtransposeaddequiv conjtransposelinearequiv conjtransposeringequiv +conjug +conjugatable conjugate conjugatecomposition conjugateequiv +conjugatei conjugateisoequiv conjugateisomorphism conjugates @@ -11212,9 +12356,13 @@ conjugating conjugation conjugations conjugator +conjuncive conjunct conjunction conjunctions +conjunctive +conjunctived +conjunctivei conjuncts conker conlat @@ -11249,13 +12397,16 @@ connectedcomponentslift connectedcomponentsmap connectedcomponentstypetocatadj connectedcomponentsupp +connectedi connectedness connectedspace connecting connection +connectioni connections connectivity connects +connex conngr conngraph conngrumgrv @@ -11269,6 +12420,7 @@ connsuba connsubclo conntop cononrel +conorm conquer conrel cons @@ -11277,24 +12429,33 @@ consaw consbv conscases consciousness +consd +conse +consec consecutive consecutively consecutivepairs conselim consensus consensusalt +consensusfails conseq +conseqmgt consequence consequences +consequent consequently consequiv consequivl +conserv +conservation conservative conserve consfixedlengthdigits consgrbar conshdinterpok consheadcp +consi consider considerable considerably @@ -11304,12 +12465,18 @@ considered considering considerons considers +considerscontains consinduction consisnonempty consist +consistencep consistency consistent +consistentappendelement +consistenti +consistentprefix consisting +consistp consists conslinearequiv consm @@ -11323,6 +12490,7 @@ consrecon conss const constaddmonoidhom +constains constalghom constant constantbaseringequiv @@ -11354,9 +12522,12 @@ constcomp constcompevaluationobj constcompwhiskeringleftiso constcone +constelim constformalmultilinearseries +constftor constfun constg +consti constinf constinfo constinfos @@ -11385,6 +12556,7 @@ constrabscl constraddcl constrained constraining +constrains constraint constraint-generation constraint-solving @@ -11435,6 +12607,7 @@ constrsuc constrtoprop construc construct +constructcalltosolver constructcoequalizer constructed constructedlanguage @@ -11467,10 +12640,13 @@ constructrightadjoint constructrightadjointequiv constructrightadjointobj constructs +constructsoln +constructsolution consts constseq constsmul constsmuldivisionring +constt consttounfold constvadd constvaddhom @@ -11493,22 +12669,30 @@ containconstants contained container containers +containfalsum +containid containing containment contains +containsconsiders containsconst +containsex containsfvar containshead containsholeannotation containsiden containsidentities containskey +containsnotterminal containsonbranch +containspropagates +containspseq containssubstr containsth containsthenadd containsthenaddq containsthread +containstruenotunit containsunit containszero contangentequiv @@ -11532,6 +12716,7 @@ content contentdevelopment contentideal contentmtofcdafromeventfn +contentpaper contentregular contents contest @@ -11553,10 +12738,12 @@ contextual contfn contfraclegendre contfract +conthyp conti contigu contiguous contin +contingent continously continu continuants @@ -11608,6 +12795,7 @@ continuousfunctionalcalculus continuousfunctions continuousgroupoid continuoushom +continuousi continuousinf continuousinv continuousinvolutiveinv @@ -11703,7 +12891,11 @@ continuouswithin continuouswithina continuouswithinat continuum +contl contlinear +contlub +contlube +contlubi contm contmd contmdiff @@ -11728,6 +12920,7 @@ contmdiffwithinat conton contop contour +contours contr contra contract @@ -11738,6 +12931,7 @@ contractibletriangle contractibletrianglefunctor contractibletriangleiso contracting +contractingonorbits contractingw contractingwith contraction @@ -11750,13 +12944,18 @@ contractright contracts contrad contradict +contradictd contradicting contradiction contradictory contradicts +contrainjective +contrang +contrap contrapos contrapose contraposee +contraposition contrapositive contrary contrasubsetcomplement @@ -11775,6 +12974,7 @@ contributes contributing contribution contributions +contrived contro control controllable @@ -11782,6 +12982,7 @@ controlled controller controlling controlproperty +controlr controls conts contsaux @@ -11792,7 +12993,9 @@ contx contz conull conv +convcomp conve +conved convenience convenient conveniently @@ -11800,6 +13003,7 @@ convention conventional conventions conver +converg converge convergence convergenceimplieslimsupclosedle @@ -11812,11 +13016,17 @@ converges converging converse conversely +conversep +conversewf conversion +conversione +conversioni conversions convert converted converter +converterd +converteri convertible converting convertlocaldecl @@ -11836,17 +13046,22 @@ convexcombo convexcombopair convexcone convexconeclass +convexd convexes convexhul convexhull convexhulladdmonoidhom +convexi convexindependent convexity convexjoin convexon convexspace +convi convince +convinv convmul +convol convoluted convolution convolutionexists @@ -11859,6 +13074,7 @@ convolutive convone convring convs +convschema convstx conway coof @@ -11870,6 +13086,7 @@ coolerhom coolerhomclass cooling coop +cooper cooperation coord coordcha @@ -11886,21 +13103,29 @@ copair copco cope copen +coperm +copermil copi copied copieddeclarations copies +copim copisnmnd copissgrp coplanar copolarization copolarizationin +copow +coppersmith +copr copri coprim coprimality coprime coprimeprodsq +coprimereal coprimes +coprimeto coprm coprmdvds coprmdvdsb @@ -11938,6 +13163,7 @@ coprodobj coprodopencover coprodpresheafobjiso coprodpunit +coprods coprodspec coprodsubtypelequ coprodsubtypelequivofiscompl @@ -11961,24 +13187,32 @@ coproductsfromfinitefiltered coproductsofshapedisjoint coproductuniqueiso coprodzeroiso +coproj coprprop copsex copsexg copsexgw copsgndif copy +copyabletores copybase copycount +copyfile +copyfilewithmetadata copyfirst +copyi copyindep copying copyinstanceattribute copymetadata +copyn copyobj +copyp copyright copyrightauthor copyrightheaderchecks copysecond +copysign copytosubgraph coq coqlib @@ -11987,6 +13221,7 @@ corable corclrcl corclrtrcl corcltrcl +cord core coreassociator corec @@ -12000,12 +13235,14 @@ coreconstructormatcher corecshape corecstate corecursion +cored coree coreflection coreflective coreflector coreflectorad coreflectoradjunction +coreflexive coreflexivecomonadicity corefunctor corehomequiv @@ -12026,6 +13263,7 @@ corepresentablebyleft corepresentablebyright corepresentablebyuliftfunctorequiv corepresentation +coreproperties coreprw coreprx corerightunitor @@ -12045,6 +13283,7 @@ corner corneraddx corners cornerstheorembound +coro corollaries corollary coroot @@ -12057,12 +13296,19 @@ corootsubmodule corpuscularobject corr correct +correctcompositioninloc +correctcompositionks +correctdecompositionvarempty +correcti correcting correction correctly correctness +correctsheaf correlated correlation +corres +corresp correspond correspondance correspondence @@ -12070,14 +13316,20 @@ corresponding corresponds correspondwith corresptheorem +corresta +corresxf +corrstate cors +corthogonal cortrclrcl cortrclrtrcl cortrcltrcl +corule cos cosa cosacos cosadd +cosafety cosangneg cosarg cosargd @@ -12111,12 +13363,14 @@ coshalfpip coshopenpartialhomeomorph coshpartialequiv coshval +cosi cosimple cosimplicialobject cosimplicialobjectfunctor cosimplicialsimplicialequiv cosimplicialtosimplicialaugmented cosine +cosines cosk coskadj coskernel @@ -12186,6 +13440,11 @@ cossxrnres cost costar costaradjforget +costbarrier +costbarrierdecreases +costbit +costd +coste costmatadd costmataddzerol costmatid @@ -12196,6 +13455,8 @@ costmatrix costmatstar costmatstardiag costmatstarfolddiag +costrict +costring costru costructureda costructuredar @@ -12225,6 +13486,7 @@ cosupp cosval coszeta cot +cotake cotan cotangent cotangentcompawaysec @@ -12249,7 +13511,9 @@ cotcl cote cotesdor cotr +cotrace cotrans +cotransitive cotrclrcl cotrclrtrcl cotrcltrcl @@ -12316,24 +13580,36 @@ countablygenerated countablyseparated countaddmonoidh countaddmonoidhom +countdown counted counter +counterassign +counterassignmodelassign counterbalance +counterevalp counterex counterexample counterexample_ counterexamples +counterimpl +counterm +countermodel +countermodelinrepn counterpart counterparts countervaluation +countfirstcands countheartbeats countheartbeatsapprox countheartbeatslinter counting countingfunction +countinuous countmixin +countour countp countpaddmonoidhom +countquantifiers countrestricted countryacivilorganization countryafirstaidorganization @@ -12350,6 +13626,7 @@ couple couples coupling couplings +courant course cov coval @@ -12370,8 +13647,12 @@ covariantltswap covariantmul covariants covariantsequence +covb covby covbysmul +covd +covdi +covec cover coverage coverage_ @@ -12384,6 +13665,7 @@ coverentropy coverentropyentourage coverentropyinf coverentropyinfentourage +coveri covering coveringnumber coveringofpresieve @@ -12395,9 +13677,18 @@ coverofisiso coverpreserving covers coverstop +covf +covfi covhasref +covib +covim +covm covmap covolume +covov +covovi +covs +covsi cowedge coweight coweightequiv @@ -12405,6 +13696,7 @@ coweighthom coweightmap cowlnothing cowlthing +cowriter coxeter coxetermatrix coxetersystem @@ -12429,6 +13721,9 @@ coyonedapreserveslimitsofshape coyonedatype coyonedaunique cpa +cparser +cparsere +cparseri cpat cpbl cpcoll @@ -12438,6 +13733,7 @@ cpeano cpet cpeter cpfun +cpgm cph cphabscl cphass @@ -12515,6 +13811,7 @@ cpmatsubgpmat cpmf cpmfo cpmghm +cpmi cpmidg cpmidgsum cpmidgsumm @@ -12531,9 +13828,12 @@ cpnnen cpnord cpnres cpo +cpoke +cpoly cpolyn cpolynomialat cpolynomialon +cpop cpos cpow cpowlimits @@ -12542,10 +13842,13 @@ cpq cprank cprankmax cpre +cpred +cprefix cprehil cprehilold cprob cprodeq +cps cpsalgo cpsi cpt @@ -12573,6 +13876,7 @@ crates cravenous cray crazyflie +crb crcleintegrable crct crctcsh @@ -12585,9 +13889,16 @@ crctistrl crctiswlk crctprop crcts +cre create createcalc created +createdirectory +createdirectoryifmissing +createdirectorylink +createfilelink +createfriend +createfriendreq createimporteddiscrtree createimportinitresults createlimitsofsizemapcompforget @@ -12663,13 +13974,17 @@ createslimitsofsize createslimitsofsizeofcreatesequalizersandproducts creating creation +creats creature +crec +crecbuilder creduct crefdf crefeq crefi crefss creftop +crel creq creui creur @@ -12687,6 +14002,7 @@ cringcataltv cringm cringops crises +crit critere criteria criterion @@ -12715,12 +14031,17 @@ crngunit crock croix cronies +croot +croots cross cross-linked cross-panel cross-system crossemoji crossing +crossings +crossn +crossp crossproduct crown crre @@ -12732,15 +14053,19 @@ crth crtp cru crucial +crule +crumb cruniq crush crux cry crypt +cryptinverts crypto cryptographers cryptographic cryptography +crypts crystalline crystallographic csa @@ -12824,22 +14149,30 @@ csbwrecsg csbxp csbxpgvd csc +cscalar +cscale csccl cscval csdfil +csdi cse csem cseq cset +csets +csfi csgrpalt csh cshco cshf cshfn cshid +cshift cshimadifsn cshinj cshnz +csho +cshorun cshw cshwcl cshwcom @@ -12876,23 +14209,37 @@ cshwsidrepsw cshwsidrepswmod cshwsiun cshwsublen +csib +csidi +csifi +csim csimp csin csinf +csingle csinh +csiov +csis cslib cslift csliftval +csm +csmall csmaller csmdsymi csmoke csmokes csnail +csnd +csnoc +csov csp csphenodontidae +csplit csqima csqlem csqrt +csquare csr csrgbinom csring @@ -12907,8 +14254,10 @@ cssmre cssss cssup cssval +cssxs cst csta +cstack cstage cstar cstara @@ -12919,19 +14268,26 @@ cstarring cstate cstrange cstrategy +cstrong csts cstucnd csucc csunshine csup +csupport +csupportd csupr +cswitch csx +csxs csy csz +ctake ctator ctbnfien ctbssinf ctclosed +ctd cte ctex cth @@ -12941,6 +14297,7 @@ cthickening cthickenings cti ctimes +ctkn ctl ctlem ctltype @@ -12959,8 +14316,14 @@ ctorthmname ctortype ctr ctrans +ctriangle +ctrianglei +ctrl +ctrm cts +ctsd ctsf +ctsi ctvonmbl ctwo ctx @@ -12968,17 +14331,23 @@ ctx-add ctx-compat ctx-scale ctx-sub +ctxcld +ctxclds ctxdecls ctxi ctxinfo ctxname ctxt +ctxts ctxvars ctyop ctype ctypes +ctyping cube cubedos +cubei +cubeimage cubes cubeslem cubic @@ -12995,6 +14364,7 @@ cunifsp cunique cuniv cup +cupcake cur cureq curf @@ -13008,6 +14378,8 @@ curly curr currency current +currentdirectory +currentf currentgoal currently currentte @@ -13030,6 +14402,7 @@ curriedtensorpreisopost curriedyonedalemma currified currindent +currk currnamespace currocc curroccs @@ -13073,6 +14446,7 @@ curve curveintegrable curveintegral curveintegralfun +curvep curves cusconngr cusgr @@ -13117,15 +14491,18 @@ cutcuts cute cuteq cutexpand +cutfreepc cutlt cutmap cutmax cutmin cutminmax cutneg +cutoff cutp cutpos cutrewrite +cuts cutscl cutscld cutsf @@ -13134,6 +14511,7 @@ cutsun cutsval cutting cuv +cval cvat cvati cvbr @@ -13238,17 +14616,22 @@ cvsi cvslvec cvsmuleqdivd cvsunit +cvtop cvx cvxcl cvxpconn cvxsconn +cwand cwcoktgimwiiovckhvlavdtrjppovhxbugwarv cwcomplex +cweak cweight +cwf cwhfxwwojoxawqhsu cwhile cwj cwolf +cwp cwrh cwwk cwwkdifex @@ -13299,8 +14682,12 @@ cxpsqrtth cxpsub cxpsubd cxpval +cxs +cxt cyaymsonjsjsf cyc +cycc +cycci cyccom cycgrp cycl @@ -13311,6 +14698,7 @@ cycle_shortcutting cycle_shortcutting_gen cyclebypass cyclecons +cyclee cyclef cyclefactors cyclefactorsaux @@ -13319,7 +14707,9 @@ cyclefactorsfinset cyclefreep cycleg cyclegraph +cyclei cycleicc +cyclelength cycleof cycleon cyclerange @@ -13404,6 +14794,7 @@ cyggrp cygth cygzn cygznlem +cyk cylinder cylinderevent cylinderevents @@ -13418,6 +14809,7 @@ cytoskeleton cytp cytpfn cytpval +cytronminimal czadd czero cznabel @@ -13492,7 +14884,10 @@ dafny dafrika dag dag_no_pos_cycle +dagger +dagi dagimpliesnoposoycle +dags daio dalaw dalawlem @@ -13544,6 +14939,7 @@ dalemueb dalemyeb dalemyeo dalemzeo +dalist dalt daltn damaging @@ -13552,6 +14948,7 @@ dance dandysum dane danel +dang danger dangerous dangling @@ -13580,6 +14977,9 @@ database databaseurl datad datalist +dataprocessing +datarefinement +dataspace datatype datatypes datavalue @@ -13631,6 +15031,7 @@ dbce dbcf dbcfd dbcfddb +dbconj dbd dbda dbdac @@ -13660,16 +15061,30 @@ dbfe dbfef dbff dbffa +dbfm dbg dbgghugtvipfsn dbgmsg +dbind +dbl +dblo +dblock dblu dblx dblxyz dbly dblz +dbm +dbmentry +dbnxt +dboost +dbot dbpfibmceocfsmcdqgrirleycbuwdwevanhinbsu +dbspec +dbtm dbtransaction +dbvar +dbzero dca dcaa dcaab @@ -13720,6 +15135,9 @@ dcfbabf dcfca dcfdeddd dcff +dchar +dcharacter +dcharacters dchr dchrabl dchrabs @@ -13766,8 +15184,18 @@ dcokernelsequence dcomex dcomp dcompare +dcompl +dcong dcongr dcongrarg +dcont +dcontimonad +dcontimonaddcont +dcontt +dconttimonad +dconttimonaddcont +dconvfactor +dcr dcralttiscaglosrk dct dcubic @@ -13781,6 +15209,7 @@ ddada ddadc ddae ddafad +ddagger ddalt ddan ddb @@ -13804,6 +15233,7 @@ ddce ddcec ddcf ddcfd +ddcong ddd ddda dddbbd @@ -13825,6 +15255,7 @@ ddee ddef ddelta ddemeas +ddep ddeval ddf ddfab @@ -13834,6 +15265,7 @@ ddfdf ddfef ddff ddffd +ddh ddi ddif ddivp @@ -13848,10 +15280,14 @@ deab deac deacdfa deace +deactivation dead deadbce +deadend +deadends deadlock deadlock-freedom +deadlocked deaf deal dealing @@ -13870,6 +15306,7 @@ debf debug debugged debugging +debugprintfmt dec deca decadd @@ -13903,6 +15340,7 @@ deceqnat decex decfactor decfb +decfinsubset deci decid decida @@ -13930,6 +15368,7 @@ decidableeqmvpolynomial decidableeqofdecidablele decidableeqofencodable decidableeqpfun +decidableequality decidableexistsmultiset decidableexistsofdecidablessubsets decidablefield @@ -13995,8 +15434,12 @@ decider decides deciding decimal +decimals decision +decisionattime +decisiond decisions +decisive decl declaration declarations @@ -14061,12 +15504,15 @@ decodeposnum decodesigma decodesubtype decodesum +decoding decomp decompandall +decompe decompex decompexand decompid decompo +decomposable decompose decomposeaddequ decomposeaddequiv @@ -14077,6 +15523,7 @@ decomposedequiv decomposedto decomposefin decomposelinearequiv +decomposels decomposeoption decomposeperm decomposeprodadjoint @@ -14091,11 +15538,17 @@ decompositionoverargs decompositions decompositionsubgroup decomppmat +decompress +decomps +decompsn +decompv +decorate decorated decoratesigma decoratesum decoupled decp +decpartialorder decpcases decpmataa decpmatcl @@ -14108,6 +15561,7 @@ decpmatmulsumfsupp decpmatval decpmul decpmulnc +decposet decpred decr decrease @@ -14120,15 +15574,22 @@ decrement decrmac decrmanc decrn +decrpoly decrypt decryption decs +decseq +decsetoid decsmf decsmflem +decspaper decsplit +decstrictpartialorder decsubi decsuc decsucc +dect +dectotalorder decvalidfinite ded dedb @@ -14143,6 +15604,8 @@ dedekindle dedekindzeta dedf dedhb +dedicto +dedictoimpldere dedlem dedlema dedlemb @@ -14152,9 +15615,13 @@ dedths deduce deduced deduces +deducible deducing deduct deduction +deductions +deductive +deducts dedup dedupbystring dedupkeys @@ -14169,12 +15636,15 @@ deef deep deeper deepest +deepl +deepr def defa defabsstobj defat defau default +defaultactions defaultdepth defaultexpansion defaultfindargs @@ -14188,11 +15658,15 @@ defaultratcdf defaults defaultstate defaultunfoldpred +defaut defb +defbot defc defd defdd defe +defect +defender defensive defensivemaneuver defeq @@ -14216,6 +15690,7 @@ define-fun defined definedatleft definedatright +definedness defines defini definienda @@ -14232,12 +15707,15 @@ definitions definitionsafety definitionval defkind +defl deflist defmacro defn defndecl defninfo +defnode deformation +defp defprojection defprop defs @@ -14256,10 +15734,13 @@ degb degbm degbound degc +degen degeneracies degeneracy +degeneralize degenerate degenerates +degernate deghost deghosted degle @@ -14278,10 +15759,12 @@ degr degre degree degreebounds +degreei degreele degreelt degreeltequiv degreemonoidhom +degreen degreeo degreeof degrees @@ -14290,6 +15773,7 @@ degreesum degreew degreewise degreewiseepiwithinjectivekernel +degs degt degtm degᵢ @@ -14345,18 +15829,27 @@ delabvar delabvecnotation delabwithuniv delay +delayed delayreflleft delayreflright delegation delete +deleted deleteedg deleteedges deleteelem deletefar deletefile +deletefriend deleteincidenceset +deletemin +deletes +deletethat +deletethis +deletetrailing deleteuniversalverts deleteverts +deletewith deleting deletion deliberately @@ -14367,27 +15860,35 @@ delimited deliver delivered delivery +delmod delone deloneset +dels delt delta deltaexpand +deltafun +deltag deltagenerated deltageneratedspace deltageneratedtotop deltamap +deltas delusrgrpfromacl delusrgrpfromaclpcp delusrgrpfromaclpsp delusrgrpfromaclpss dem +demand demo demodulation demoivre demoivrealt +demonic demonstrate demonstrates demorgan +demorgans den dencert dene @@ -14400,9 +15901,11 @@ denominator denominators denoms denomsclearable +denormal denosuextmmhuzdnkrkisngvwk denot denota +denotation denotational denote denoted @@ -14410,10 +15913,13 @@ denotes denotesaltv denoteslem denoting +denott +denotts dens dense denseat denseatequiv +denselinearorder densely denselynormed denselynormeddomain @@ -14426,9 +15932,16 @@ denseran denserange denseseq density +densityd +densityi densityprocess densq denumerable +denvalue +deny +denyall +denyallfromto +denynmt deoi dep depend @@ -14460,6 +15973,7 @@ deprecating deprecation deprecationinfo deprecations +depressed deprewrite deprewritelocaldecl deprewritetarget @@ -14470,10 +15984,12 @@ depth deq dequeue der +derandomized derang derangement derangements derangementscongr +derangementsi derangementsoptionequivsigmaatmostonefixedpoint derangementsrecursionequiv derangen @@ -14483,14 +15999,21 @@ derangfmla deranglem derangsn derangval +dere deref dereference dereferences +dereimpldedicto +derelict +dereliction +derep derg deri derisvestar deriv +derivability derivable +derivassum derivat derivati derivation @@ -14507,6 +16030,7 @@ derivativefun derivatives derivativesdefinitions derivativeuniqueness +derivaux derivcgf derivclm derive @@ -14529,12 +16053,16 @@ derivefunctor deriveg derivegstar deriveint +derivel derivelawfulfunctor derivelawfultraversable +derivels +deriven derivenat derivenotprime deriver deriverat +derivern derives derivesimp derivestar @@ -14543,13 +16071,16 @@ derivetraversable derivf derivfamily derivg +deriviative deriving derivinghandler derivmgf derivmz +derivprop derivrclike derivrootweight derivs +derivsaux derivseries derivweierstrassp derivweierstrasspexcept @@ -14558,13 +16089,18 @@ derivwi derivwit derivwith derivwithin +ders +dersh +derun des desagaio +desargues desc desca descaddmonoidhom descale descar +descartes desccapp desccochain desccoconemorphism @@ -14582,6 +16118,8 @@ descent descentdata descentdataascoalgebra descentdataequivalence +descente +descentfrom descents descequiv descf @@ -14641,16 +16179,22 @@ despec despite dessertwine dest +destab destination +destinnetlistaux +destnet destr +destrimpl destru destruct destructor destructors destructures +dests destutter desync det +detab detail detailed details @@ -14658,8 +16202,11 @@ detailtrace detaux detdiag detect +detectability detectable +detectd detected +detecti detecting detection detectlambdatheoremargs @@ -14667,8 +16214,10 @@ detector detects deteq determ +determinacy determinant determinants +determination determine determined determinedbydefinitemethod @@ -14678,6 +16227,7 @@ determines determining determinism deterministic +deterministicd detid detidres detinidres @@ -14691,18 +16241,23 @@ detmonoidhom detnezero detp detrowalternating +dets detsem detxrnidres detzero deux dev +devbc develop developed developing development developments develops +devext +deviate device +devop devos devosmulrel devoted @@ -14887,6 +16442,7 @@ dflidl dflim dflinc dflog +dflow dflt dfma dfmembpart @@ -14962,6 +16518,7 @@ dfrp dfrtrcl dfrtrclrec dfs +dfsa dfsalgen dfsb dfsbcq @@ -14976,6 +16533,7 @@ dfss dfssf dfssr dfsstate +dfst dfsuccf dfsuccl dfsucmap @@ -15018,6 +16576,9 @@ dfz dge dgen dges +dghm +dghmi +dghms dgjbdhg dgoequivhomologicalcomplex dgoequivhomologicalcomplexcounitiso @@ -15030,11 +16591,13 @@ dgraaf dgraalem dgraaub dgraaval +dgrad dgradd dgrb dgrcl dgrco dgrcolem +dgrdatarefinement dgreq dgrid dgrlb @@ -15049,8 +16612,10 @@ dgrub dgrval dgt dgv +dhindistinguishable dhomologydata dhomologyiso +dhops dhx dhy dia @@ -15062,6 +16627,7 @@ diadic diadm diadmcln diadmlen +diae diael diaeldm diaelrnn @@ -15087,6 +16653,7 @@ diagona diagonal diagonaladdmonoidhom diagonalalghom +diagonalbind diagonalcover diagonalcoverdiagonalrange diagonalhomequiv @@ -15094,6 +16661,7 @@ diagonalinvertible diagonalinvertibleequivinvertible diagonalizable diagonalization +diagonalize diagonalized diagonallinearmap diagonalobj @@ -15136,6 +16704,7 @@ diagramwithuniqueterminal diagset diagsub diagval +diai diainn diaintcln dial @@ -15149,11 +16718,13 @@ diameters diametre diamond diamond_c +diamondop diamonds dian diaocn diaord diarnn +dias diass diassdvan diasslssn @@ -15183,11 +16754,13 @@ dibval dibvalrel dic dicdmn +dice dicelval dicelvaln dicffval dicfnn dicfval +dichotomous dichotomy dicirpyc dickson @@ -15197,8 +16770,11 @@ diclss dicn dicopelval dicssdvh +dict dictates dictating +dictator +dictatori dictionary dicvaddcl dicval @@ -15234,6 +16810,7 @@ difexi diff diffconton diffcontoncl +diffd diffe diffeologi diffeologicalspace @@ -15250,6 +16827,7 @@ difference differenceaux differencefunctor differences +differenceset different differentfrom differenti @@ -15279,6 +16857,7 @@ differentideal differently differing differs +differt difffzod diffgeo diffi @@ -15286,11 +16865,16 @@ diffib difficult difficulty diffiunisros +difflengths +difflist diffprop +diffr diffs diffsq difftoidealofquotientcompeq diffusion +diffvar +diffvec diffz difgtsumgt difi @@ -15351,6 +16935,8 @@ digitaux digitauxless digitauxmore digitchar +digitchars +digitcharsunique digitgivesboundednum digitinv digitless @@ -15363,10 +16949,16 @@ digits digitsapp digitsappend digitsaux +digittolist +digittonlist +digittotree digitvnumisprecision +digitwise dignn dignnld digraph +digraphd +digraphi digval digvalnn dih @@ -15452,6 +17044,7 @@ dilations dilatransvections dilfsetn dilsetn +dilworth dim dim-add dim-div @@ -15488,17 +17081,25 @@ dimlssid dimmul dimn dimp +dimpl dimplus dimpropd +dimq dims dimscm dimval dimvalfi dinattrans dinaturality +dindistinguishable dini dining +dinit dinv +dinvar +dinvarc +dinvarm +dio dioid dioph diophantine @@ -15531,6 +17132,7 @@ diracprobaequiv diracprobaequivsymm diracprobahomeomorph diracprobainverse +dirbd dircont dirconteq dirdm @@ -15590,6 +17192,7 @@ dirkerre dirkertrigeq dirkertrigeqlem dirkerval +dirprods dirref dirrel dirset @@ -15602,8 +17205,11 @@ dis disable disabled disabling +disagree +disagreement disallow disallowed +disambig disambiguatefailures disamis disbanding @@ -15637,11 +17243,13 @@ discontinuity discontinuous discourage discouraged +discover discoverability discovered discovered_ discovers discr +discrat discre discrepancy discret @@ -15670,6 +17278,7 @@ discriminate discrimination discriminator discrimrec +discrl discrmoore discrr discrs @@ -15678,6 +17287,7 @@ discsnterm discsntermlem discsubc discsubclem +disct discthin discthing discuss @@ -15691,6 +17301,7 @@ dishaus dishonest disintegrate disintegration +disintegrationi disj disjabrex disjabrexf @@ -15700,7 +17311,9 @@ disjaltvid disjaltvidres disjaltvinidres disjaltvxrnidres +disjcond disjcsn +disjd disjdif disjdifb disjdifprg @@ -15711,6 +17324,7 @@ disjdmqseq disjdmqseqeq disjdmqsss disjdsct +disje disjeccnvep disjecxrn disjecxrncnvep @@ -15744,10 +17358,12 @@ disjiunb disjiund disjiunel disjiunion +disjk disjl disjlem disjne disjnf +disjnt disjo disjoi disjoin @@ -15756,11 +17372,14 @@ disjointbase disjointd disjointed disjointedrec +disjointframe disjointi disjointness disjointofdiff disjointofdiffunion disjointofunion +disjointpaths +disjointschedules disjointsetsi disjointsigma disjointsum @@ -15806,6 +17425,11 @@ disjun disjunct disjunction disjunctions +disjunctive +disjunctived +disjunctivei +disjunctor +disjuncts disjuniel disjunion disjunionequiv @@ -15829,20 +17453,24 @@ diskboundaryinclusion disks dislly disllycmp +dismantle diso disoa disob disoc disoh +dispaper dispatch dispatched dispatchlemma dispcmp display +displayfib displays disposal dispose disr +dissection dissector dissimilar dissipate @@ -15853,11 +17481,15 @@ dissnref dissym dist distance +distancefunction distances +distant distapproxtree distdenseseq distel distgp +disti +distideal distin distinct distinct_card @@ -15866,12 +17498,16 @@ distinct_walk_length_le distinctconstantstheory distinctelems distinction +distinctness +distinctnets distinctpairs distincts distinguish distinguished distinguishedtriangles distinguishes +distinguishing +distint distl distlat distmult @@ -15879,6 +17515,7 @@ distnorm distop distopon distortion +distperm distps distr distri @@ -15910,9 +17547,11 @@ distribumulaction distribute distributed distributes +distributesover distribution distributions distributive +distributivelattice distributively distributivity districtsuriname @@ -15922,6 +17561,8 @@ distro distrpi distrpr distrsr +dists +distset distsingle distspace disttriang @@ -15997,8 +17638,11 @@ diveq diverg diverge divergence +divergences divergent diverges +diverging +diversity diveucl diveuclz divex @@ -16014,6 +17658,8 @@ divgcdoddaltv divgcdz divge divgt +divi +divibility divid dividd divide @@ -16021,6 +17667,7 @@ divided dividedpowers dividedpowersbot dividedpowersdefinition +dividend dividerow divides dividesdef @@ -16053,6 +17700,7 @@ divisionsemiring divisive divisor divisorchain +divisori divisors divisorsanti divisorsantidiag @@ -16091,6 +17739,7 @@ divmuls divmulsd divmulsw divmulswd +divmultassoc divmulzi divnat divnatlttwopow @@ -16178,6 +17827,7 @@ djhspss djhsumss djhunssn djhval +djn djoint djrrilceqnyeyeuhksez dju @@ -16209,6 +17859,7 @@ djuunxp djuxpdom dkctvpxpxp dkernelsequence +dkey dkj dkk dkrrsnxbxtzojqcbmkwlhpziaclsub @@ -16219,18 +17870,27 @@ dlatl dlatmjdi dle dlem +dlen +dleq +dlf +dlhpp dlim dlinearmap +dlineq dlinvh dlist dlit dlmgy dlmldaqkoyuicfsula dlo +dloc dlookup +dlp dlt +dlts dlwwlknondlwlknonen dlwwlknondlwlknonf +dma dmaddpi dmaddsr dmadjop @@ -16260,6 +17920,7 @@ dmatsgrp dmatsrng dmatsubcl dmatval +dmb dmcdm dmclimxlim dmcnvcnv @@ -16350,6 +18011,7 @@ dmnonrel dmnop dmnopgexmpl dmnrngo +dmono dmopab dmopabelb dmopabss @@ -16420,10 +18082,16 @@ dmxrn dmxrncnvep dmxrncnvepres dmxrnuncnvepres +dncl dnd dne +dnelist +dneq +dnesc dnext dnf +dnfd +dnfuni dni dnibnd dnibndlem @@ -16436,6 +18104,8 @@ dnizeq dnizphlfeqhlf dnk dnnumch +dnode +dnodes dnonempty dnrinv dns @@ -16453,6 +18123,7 @@ docavaln docblame doccomment docctx +docd doch dochcl dochdmj @@ -16513,11 +18184,16 @@ document documentation documents dodivides +dodo does +doesdirectoryexist +doesfileexist doesn doesnt +doespathexist dogenericser dogenericserver +dohelloname doing doingsomething doit @@ -16530,6 +18206,7 @@ dollarsyntax dollarsyntaxlinter dom doma +domad domaddact domaddactmk domain @@ -16537,6 +18214,7 @@ domain-specific domaine domaineq domainisoofbaseiso +domainp domainqs domainqss domains @@ -16565,6 +18243,7 @@ domfi domfin domfuncrel domg +domi dominant dominate dominated @@ -16573,6 +18252,9 @@ dominatedfinmeasadditive dominates dominf dominfac +domino +dominoes +domintros domlcongr dommulact dommulactcongrright @@ -16585,6 +18267,7 @@ domnlcanb domnlcanbold domnlcanold domnmsuppn +domnmt domnmuln domnnzr domnprodeq @@ -16613,6 +18296,7 @@ domssl domssr domt domtgt +domtotal domtr domtrfi domtrfil @@ -16635,15 +18319,32 @@ dontkeep donttranslate door dopivotoperation +dopxg dot +dotand +dotdecimal +dotdot +dotemacs +doteq +dotexists +dotforall +dotfull +dotimp +dotor +dotp +dotpos dotprod dotproduc dotproduct dotproductbilin dotproductequiv +dotpure dotranslate dotranslateattr dots +dotstar +dotwand +dotwild doub double doublecentralizer @@ -16652,29 +18353,43 @@ doublecomplementeq doublecomplementi doublecomplementsub doublecoset +doubled doubledualemb doubledualequiv doublee doublefactorial +doublei doublek +doublenegation +doublenegationelimination doublequot doubles doublesplit doubletelescope +doubleton doubleunderscore doublexiso doubling doublingconstant doublinggamma +doubly doublystochastic dout down +downclosed +downcrossing +downfrom downfunctor downgrades +downharpoonleft +downharpoonright +downif downlib downmap downmulhom +downpos downs +downset downstream downward downwards @@ -16739,6 +18454,7 @@ dprdval dprdw dprdwd dprdz +dprm dprod dprodindex dpsetconstr @@ -16748,12 +18464,16 @@ dpsetconstrera dpsetconstri dpsetconstrsub dpval +dpweak dpy dqt dquart dquartlem dra +drae +draei draft +drai dral dramatic dramaticacting @@ -16763,8 +18483,15 @@ drb drbg drbgabs drbgstate +drc +dream drec +drefine +drefines +drefinesd +drefinesi dres +drest drex drf drgext @@ -16774,12 +18501,14 @@ drgextsubrg drgextvsca drhmsubc drhmsubcaltv +drift drink drinker drive driven driving drl +drlex drn drnf drnfc @@ -16830,10 +18559,16 @@ droite drop dropab dropaux +dropd dropend dropendwhile dropfun +dropi +dropl droplast +dropm +dropmiddle +dropmiddleelement dropn dropout dropped @@ -16852,6 +18587,8 @@ drsbn drsdir drsdirfi drsprs +drsr +drtn drugbg drugi drugsu @@ -16883,6 +18620,7 @@ dsimpargs dsimpgoal dsimppercentelaborator dsimpresult +dsj dsk dsl dslope @@ -16897,6 +18635,7 @@ dsmmlss dsmmsubg dsmmval dsmooth +dsn dsndx dsndxnbasendx dsndxnmulrndx @@ -16904,6 +18643,16 @@ dsndxnn dsndxnplusgndx dsndxntsetndx dsoup +dsource +dsourceissource +dsourceofdsource +dsourceofsource +dsources +dsourcesemptysources +dsourceslevelx +dsourcesnot +dspace +dsq dssmap dssmapclsntr dssmapf @@ -16915,6 +18664,9 @@ dst dstar dstate dstatelet +dstep +dstepi +dsteps dstfrvclim dstfrvel dstfrvinc @@ -16926,15 +18678,21 @@ dstrvval dsts dsu dsub +dsubst dsum dsupport +dszi +dterm dthen dtheta dtmxbtwxjdjsmtb dto +dtokm dtop dtopology +dtor dtr +dtranshd dtree dtru dtrualt @@ -16943,6 +18701,7 @@ dtrue dtsld dtu dtype +dtypeid dua dual dual-invol @@ -16952,8 +18711,11 @@ dualannihilatorgci dualantisymmetrization dualbases dualbasis +dualboundedjoinsemilattice +dualboundedmeetsemilattice dualcoannihilator dualcopairing +duald dualdistrib dualdistribequiv dualdistribequivofbasis @@ -16962,15 +18724,22 @@ dualdual dualembedding dualequiv dualequivdual +duali dualindepmatroid +dualisboundedjoinsemilattice +dualisboundedmeetsemilattice dualise +dualisjoinsemilattice +dualismeetsemilattice dualiso duality duality_ dualize dualizing +dualjoinsemilattice duallift dualmap +dualmeetsemilattice dualnumber dualnumberequiv dualpairing @@ -16992,6 +18761,7 @@ dualtensorhomequivofbasis dualtensorisolinhom dualtensorisolinhomaux dualvector +dube dubmrjuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuhqsqjuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuhssxmosmlxuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuubjmuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuubdcstkdjuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuucfpkpqjujkdjvgajuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuubuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuu due duffin @@ -17001,8 +18771,10 @@ dumbledore dummies dummy dummylink +dump dunford dup +dupelim duple duplex duplicate @@ -17083,9 +18855,11 @@ dvcvx dvcxp dvd dvdemo +dvdi dvdivbd dvdivcncf dvdivf +dvdm dvdmsscn dvdn dvdnotunit @@ -17331,6 +19105,7 @@ dvrfval dvrid dvrunz dvrval +dvs dvsconst dvsef dvsid @@ -17338,6 +19113,7 @@ dvsin dvsinax dvsincos dvsinexp +dvsn dvsqrt dvsubcncf dvsubf @@ -17347,6 +19123,8 @@ dvtaylp dvun dvv dvxpaek +dwa +dwfc dwgs dwq dws @@ -17365,6 +19143,7 @@ dyaddisj dyaddisjlem dyadf dyadic +dyadics dyadmax dyadmaxlem dyadmbl @@ -17372,6 +19151,7 @@ dyadmbllem dyadovol dyadss dyadval +dyck dyckstep dyckword dydt @@ -17384,9 +19164,14 @@ dynamical dynamically dynamics dynamicsaturateassert +dyncom +dyncomrule +dynd dynentourage +dyni dynkin dynkinsystem +dynpdg dyp dyqidsdfm dyz @@ -17433,6 +19218,8 @@ eaceae eacf each each_le +eachothers +eachtr ead eada eadbdcf @@ -17477,10 +19264,12 @@ eapproxdiff earb earith earithmetic +earley earlier early earlyshutdown earray +eas ease eases easier @@ -17573,6 +19362,7 @@ ebool eboolv ebound ebounded +ebounds ebtwntg ebuild ebuiltin @@ -17596,8 +19386,10 @@ ecall ecan ecannotparse ecaodabylqwu +ecard ecardinal ecardleq +ecarrier ecart ecase ecased @@ -17687,12 +19479,16 @@ ecinn ecinxp eckmannhilton eckxyacfwykrkqetjerrzuq +ecl eclclwwlkn eclexia eclexia-ast eclient eclos +eclose eclosed +eclosee +eclosen ecloslang eclosprops eclossem @@ -17702,6 +19498,7 @@ ecmlparse ecmlpeg ecmlptreeconversion ecmp +ecnv ecombin ecomp ecompact @@ -17812,6 +19609,7 @@ edelete edeletefindmax edelstein eden +edenot ederef edest edestruct @@ -17830,15 +19628,21 @@ edge edged edgedensity edgedisjointtriangles +edgee edgef edgefinset +edgei edgelabeling edgemk edgepath +edgepred +edgertc edges edgeset edgesetembedding edgesfinset +edgesi +edgesl edgetransform edgfi edgfid @@ -17868,6 +19672,7 @@ edgusgrnbfin edgval edgwalks edhtqloizgwhxlz +edi ediam edible ediff @@ -17883,11 +19688,18 @@ edit editabledocument editing editor +editvar ediv +edka edlet edmond +edmonds edo +edom edownshift +edrel +edreld +edreli edring edringr edrop @@ -17961,6 +19773,7 @@ eefbf eefc eefd eefe +eefm eeg eehil eehqilxzdczjjzdicnlmvxxrgpmsmt @@ -18000,6 +19813,7 @@ eexists eexn eexp eexplode +eext eextend eextreal efa @@ -18113,6 +19927,7 @@ effectiveepistructofregularepi effectively effectivelyenough effectivepresentation +effectless effectnecessarilyfollowsfrom effectrow effects @@ -18123,6 +19938,7 @@ efficiency efficient efficiently effort +effs effstep effstepn effsumlt @@ -18179,6 +19995,7 @@ efif efifo efilter efimpi +efin efinal efinite efipi @@ -18193,6 +20010,7 @@ eflgam efloat eflog eflogeq +eflowgraph eflt efmap efmival @@ -18236,6 +20054,7 @@ efs efsep efsffi efsffiprops +efsm efst efsub efsubd @@ -18270,6 +20089,7 @@ egenlist eget egg egirth +ego egoals egood egorov @@ -18279,6 +20099,7 @@ egrsubgr egrvtxdg egspec egt +egta eguess egular egv @@ -18286,6 +20107,7 @@ eha ehalf ehandle eheap +eheight ehl ehlbase ehleudis @@ -18306,8 +20128,10 @@ ehomwhiskerright ehresmann eid eiedg +eif eify eig +eigen eigenname eigenpairs eigenrange @@ -18334,6 +20158,7 @@ eigs eigval eigvalcl eigvalfval +eigvals eigvalval eigvec eigvecval @@ -18362,6 +20187,9 @@ einsttype eint einteger einter +einterval +eintf +eintp eintro einu einv @@ -18384,6 +20212,8 @@ eitself eiw ejoin ejump +ekey +ekmeasure ela elaa elab @@ -18500,6 +20330,7 @@ elabwithoutcdot elabzeta elalt elaltxp +elam elat elatcv elaxnul @@ -18636,6 +20467,7 @@ eleldisjseldisj elelpwi elelsuc elem +elemd eleme elemen element @@ -18650,6 +20482,7 @@ elementaryembedding elementaryskolem elementarysubstructure elementarysymmetric +elementlevel elements elementsfunctor elementsmk @@ -18658,10 +20491,12 @@ elementwiseexpr elementwisethms elemexp elemexponent +elemi elemlist elemreduct elems elemsandseps +elemsd elemsrimpl elemsruniq elemtype @@ -18756,6 +20591,7 @@ elfzubelfz elfzuz elfzuzb elgab +elgamal elgch elghomlem elghomold @@ -18769,6 +20605,7 @@ elhoi elhoma elhomai eli +elias elicc eliccd eliccelico @@ -18790,6 +20627,7 @@ elide elidinxp elidinxpid elif +eligible elii eliin eliincex @@ -18823,6 +20661,7 @@ elimif elimifd eliminable eliminate +eliminatecopyable eliminated eliminates eliminating @@ -18840,6 +20679,7 @@ elimnv elimnvu elimph elimphu +elims elimstatus elimt elimtf @@ -18927,6 +20767,7 @@ ellimits ellines ellipsis elliptic +ellis ellist ellkr ellnfn @@ -19210,6 +21051,7 @@ els elsb elscottab else +elsee elsetchom elsetpreimafv elsetpreimafvb @@ -19220,6 +21062,8 @@ elsetpreimafvrab elsetpreimafvssdm elsetrecs elsetrecslem +elsevier +elsevierauthor elsewhere elsh elsif @@ -19410,6 +21254,7 @@ embequivofisalgclosed embequivpi embfintwo embfunctor +embits embmap embprodembofisalgebraic embsigma @@ -19448,19 +21293,27 @@ emoo emotionalstate emp emph +empl +empr +emprel +empt emptiness empty emptyal emptyarrowequivpunit emptycollection emptycols +emptyd emptydigraph emptydischarge emptye emptyeffect +emptyenv emptyequivalence +emptyessl emptyex emptyext +emptyfromlist emptygraph emptyhom emptyi @@ -19469,26 +21322,35 @@ emptyinunitempty emptyisinitial emptyline emptylinelinter +emptyls emptynf emptyon +emptypair +emptypost +emptyproc emptyprod emptyrelation emptyrows +emptyrs +emptys emptyset emptysetax emptysete emptysetimpfalse emptysetordinal +emptysets emptysetsubset emptystr emptystructure emptysum emptysumlex +emptytitle emptyto emptyunique emptywf emptywithcapacity emre +emsapss emtpy emulate emulti @@ -19499,7 +21361,13 @@ ena enabl enable enabled +enabledatstep enabledconfigs +enablede +enabledi +enabledprefix +enabledprefixsingle +enabledprefixsinglefinalstep enableppunivonhead enables enablesimp @@ -19509,6 +21377,7 @@ enamespace enat enatcard enatmap +enatoption enb enc enca @@ -19518,6 +21387,8 @@ encar encard encd encdec +ence +enci enclosed enclosing encod @@ -19532,6 +21403,7 @@ encodecode encoded encodeexpr encodeexprwitheta +encodegammacond encodek encodelist encodemultiset @@ -19543,8 +21415,11 @@ encodesigma encodesubtype encodesum encoding +encodingd +encodingi encodingnat encodingnatbool +encodings encodingstep encodingstepaux encodingstepwitheta @@ -19555,11 +21430,14 @@ encountered encounters encourage encouraged +encpf encrypt encryption encryptnothingoracle encryptoracle +encs encv +encyrpt end end_session endalgequiv @@ -19581,6 +21459,7 @@ endings endisfree endisj endjudisj +endless endmnd endmndlem endmonoidal @@ -19601,9 +21480,11 @@ endomorphism endomorphisms endomorphs endomtr +endormore endos endow endowment +endpc endpoint endpoint-projection endpointident @@ -19612,6 +21493,7 @@ endpos endringequiv ends endsemiringequiv +endset endswith endtensorendalghom endval @@ -19628,10 +21510,13 @@ enemult enen ener enerel +energies energy enew +enex enext enextfree +enf enfi enfialt enfii @@ -19665,6 +21550,7 @@ enmappw enmappwid enn enne +ennexp ennn ennnalt ennre @@ -19672,6 +21558,7 @@ ennrea ennreal ennrealequivnnreal ennrealequivsum +ennreali ennrealofreal ennrealprevariation ennrealratembed @@ -19699,6 +21586,7 @@ enoughinjectives enoughprojectives enp enpr +enq enqbreq enqeq enqer @@ -19771,8 +21659,12 @@ ensymfib ensymi ent entail +entailed entailment entails +entailsi +entailsliteralrelpacepartwithequivalent +entangled enter enterarg enterformat @@ -19797,6 +21689,7 @@ entri entric entries entriestomessagedata +entringer entropy entry entryaddhom @@ -19809,8 +21702,11 @@ entrypoint entrywise entrywisesupnorm enum +enumappend +enumbase enumer enumerable +enumeracionformulasnat enumeral enumerate enumeratecountable @@ -19818,8 +21714,15 @@ enumerated enumerates enumerating enumeration +enumerationformulasp enumerative +enumerator enumf +enumfrom +enumfromto +enumfromtol +enumfromtos +enumfromtostep enumlist enumlistname enumlistnodupname @@ -19831,16 +21734,23 @@ enumt enuqconstructorname env envc +envcomm +envd envelaction envelgroup enveloping envextension +envi environ environment environmental environments +envobs +envs envsubst +envval enwwlksnge +eoa eoc eof eoi @@ -19850,6 +21760,9 @@ eopalt eopenfilefs eoption eoptrel +eout +eoutknowcorrect +eoutknowsecorrect epair eparse eparsetree @@ -19875,6 +21788,7 @@ epic epicomp epidesc epigraph +epigraphi epihom epii epiiscokernelofkernel @@ -19889,6 +21803,7 @@ epini epinid epipullback epirron +epis episect epistemic epistemictypechecker @@ -19907,6 +21822,7 @@ epp epr epred eprel +epres epreslang eprim eprimsemenv @@ -19919,6 +21835,8 @@ eps epsa epsb epsc +epsclo +epsclosure epscomp epse epsil @@ -19935,6 +21853,7 @@ epuzyquvacft epvar epweon epweonalt +epxr eq eq_mp eq_pow @@ -19978,8 +21897,15 @@ eqbrtrrdi eqbrtrri eqbrtrrid eqbst +eqbutgh +eqbutuid +eqbutuidf +eqbutuidl eqc +eqcl +eqclass eqclos +eqclosure eqcocnv eqcoe eqcom @@ -19998,6 +21924,7 @@ eqde eqdec eqdif eqdist +eqdom eqdr eqdrusgr eqds @@ -20044,6 +21971,7 @@ eqfnovd eqfnun eqfosc eqfraction +eqfree eqfsecmat eqfssc eqfunfv @@ -20081,13 +22009,16 @@ eqinfd eqinunit eqitv eqitvp +eqiv eqjzobnejxghwqrmwbavufxrdsthxirdgezthbheebdaqpet eqk +eql eqle eqled eqlei eqlelt eqleltd +eqlen eqlist eqlista eqlistok @@ -20102,6 +22033,8 @@ eqlocusm eqlocuss eqltrg eqmat +eqmaximumi +eqminimumi eqmixin eqmixinx eqmod @@ -20137,7 +22070,10 @@ eqofhomeq eqofmgf eqon eqone +eqongl eqonsource +eqonuc +eqonuout eqop eqopab eqopi @@ -20149,6 +22085,7 @@ eqoriff eqp eqperm eqpf +eqpoll eqpp eqpq eqpr @@ -20157,6 +22094,7 @@ eqprincd eqprodroots eqproof eqptail +eqq eqr eqra eqrabdioph @@ -20167,6 +22105,7 @@ eqrdav eqrdv eqrec eqrel +eqrelation eqrelf eqrelrd eqrelrdv @@ -20184,6 +22123,7 @@ eqrrabd eqs eqsb eqsbc +eqsec eqseq eqsim eqslocus @@ -20243,6 +22183,10 @@ equalish equalities equality equalityconversion +equalitye +equalityi +equalitysubrelation +equalize equalizer equalizercomparison equalizercondition @@ -20263,8 +22207,14 @@ equalizersieve equalizersubobject equalizersubobjectiso equalizes +equallength equally +equalmodstrick +equalon +equalond +equaloni equals +equalsn equalto equantheuristics equat @@ -20274,6 +22224,7 @@ equati equation equational equations +equator equcom equcomd equcomi @@ -20345,12 +22296,14 @@ equivalencetrans equivalenceunitiso equivalent equivalentclass +equivalentformulae equivalently equivalentproperty equivalents equivalgend equivalghom equivapp +equivar equivariance equivariant equivariantmap @@ -20390,6 +22343,7 @@ equivcongrleft equivcontinuousmap equivcostructuredarrow equivcurry +equivd equivdfinsupp equivdiagram equivdirectsum @@ -20537,6 +22491,9 @@ equivoption equivp equivpair equivpairaux +equivparti +equivpartp +equivpartpe equivpempty equivpi equivpic @@ -20676,13 +22633,18 @@ equvinv equvinva eqv eqvd +eqvel +eqver eqvf eqvgen +eqvi eqvinc eqvincf eqvincg eqvinop eqvisset +eqvl +eqvr eqvrel eqvrelcl eqvrelcoss @@ -20708,6 +22670,10 @@ eqvrelthi eqvreltr eqvreltrd eqvreltrrel +eqvt +eqvtrescommrel +eqvttrans +eqvtweaktrans eqwordset eqwrd eqwrdeq @@ -20794,6 +22760,7 @@ erea ereal erealax erealequivreal +ereali eref ereftag ereg @@ -20816,6 +22783,8 @@ erewr erewrite erex erexb +erf +erfc ergodic ergodicsmul ergonomics @@ -20845,6 +22814,7 @@ erngring erngset ernode ernum +ero eroprf erov eroveu @@ -20876,9 +22846,12 @@ errorexample errorformat errormessage errormsg +errorpart +errorpartfmt errorref errors errorsfound +errort errorterm errsum errtosorry @@ -20901,12 +22874,14 @@ erw esa esakiahom esakiahomclass +esat escalated escap escape escapedheaders escapedtable escapes +escl esd esec esection @@ -20924,12 +22899,16 @@ eset esexp esgqdpfj eshift +esigma +esigmanotzero esimplesexp +esl esn esnd esnoc esome esop +espclosure espec especially esplit @@ -20949,6 +22928,7 @@ ess essa essence essenceinvexistence +essencescharacterizecompletely essential essentially essentiallylarge @@ -21016,6 +22996,7 @@ estype esub esubmap esubset +esuc esuccess esum esumadd @@ -21080,6 +23061,7 @@ etaexpandedstrict etaexpandn etafn etag +etai etaiso etake etale @@ -21103,6 +23085,7 @@ etctor etempvar etenv eterm +eterms eternity etextioproof eth @@ -21119,6 +23102,7 @@ etoken etokens etolist etop +etp etra etransc etransclem @@ -21135,6 +23119,7 @@ etruncltgeltselftogelt etruncltgeltselftoltge etruncltltisolt etruncltlttolt +ets ettjhleos etvelookup etyop @@ -21161,6 +23146,7 @@ eucalgf eucalginv eucalglt eucalgval +eucl euclemma euclf euclid @@ -21172,16 +23158,19 @@ euclideandomain euclideangeometry euclideanhalfspace euclideanhausdorffmeasure +euclideani euclideanquadrant euclideanreal euclideansp euclideanspace euclidiens +euclidslemma eucrct eucrctshift eudf eudis eudisval +eudoxus euelss euen euendfunc @@ -21214,6 +23203,7 @@ euler eulerchar eulercharsigns eulercrct +eulerian eulerid eulermascheroniconstant eulermascheroniseq @@ -21268,6 +23258,7 @@ euoreqb euorv euotd eup +eupdate eupick eupicka eupickb @@ -21322,6 +23313,7 @@ evalarithmeticfunctionzeta evalascfactorial evalat evalatom +evalb evalbernstein evalbesicovitchsatelliteconfigr evalbound @@ -21344,6 +23336,7 @@ evalcompnil evalconst evalconstcheck evalcosh +evalcps evald evaldeprewriteseq evaldeprwseq @@ -21354,6 +23347,8 @@ evaldistrepeat evaldiv evaldoublefactorial evaldyckwordfirstreturn +evale +evaleffect evalenatceil evalennrealofnnreal evalennrealofreal @@ -21430,6 +23425,7 @@ evalissquarerat evalite evaljacobisym evaljacobisymnat +evalk evall evallatticehom evallazyentry @@ -21443,6 +23439,7 @@ evallognatlit evallt evallucaslehmertest evalmap +evalmat evalmax evalmeasurereal evalmem @@ -21501,6 +23498,7 @@ evalnonunitalringhom evalnonunitalstaralghom evalnot evalnsmul +evalo evalodd evalofnat evalofscientific @@ -21517,6 +23515,8 @@ evalordinalmul evalordinalnpow evalordinalopow evalordinalsub +evalp +evalpcountermodel evalpnatval evalpos evalpospart @@ -21534,6 +23534,7 @@ evalprimefactorslist evalprimefactorslistaux evalprojlogheight evalprojmulheight +evalprop evalradical evalratcast evalratden @@ -21546,6 +23547,7 @@ evalrealsinarctan evalrealsqrt evalrealtoereal evalrealtonnreal +evalrecvargs evalringhom evalround evalrpow @@ -21558,16 +23560,20 @@ evalsolution evalsorryifsorry evalsqrt evalstaralghom +evalstate +evalstatet evalsto evalstointime evalsub evalsubfactor +evalt evaltactic evaltacticcapturingtrythis evaltacticseq evalterm evaltriangleremovalbound evaltrue +evalts evaltsum evaluat evaluate @@ -21590,9 +23596,11 @@ evaluationrightadjoint evaluations evaluationuncurried evaluator +evaluni evalupperhalfplanecoe evalupperhalfplaneim evalusefiniteinstance +evalv evalval evalvars evalwhiskerleft @@ -21605,6 +23613,14 @@ evar evariance evariationon evarray +evars +evcontainsall +evcontainsatom +evcontainsconj +evcontainsdisj +evcontainsex +evcontainsexsuc +evcontainsexval evcp evd eve @@ -21657,9 +23673,13 @@ evensoddinv evensumeven evensumodd event +eventd +eventi eventoneg eventprob events +eventscaraudiosystem +eventsd eventu eventua eventual @@ -21668,6 +23688,7 @@ eventually eventuallyconst eventuallye eventuallyeq +eventuallyi eventuallyle eventuallylt eventuallymeasurable @@ -21692,6 +23713,7 @@ everything everywhere everywherepossubset evidence +evil evl evladdval evlcl @@ -21738,7 +23760,9 @@ evlvarval evlvvval evlvvvallem evnp +evol evolution +evolveode evp evpm evpmid @@ -21780,6 +23804,7 @@ ewordlang ewordprops ewords ewordsem +ewp ewrite ewriteword ews @@ -21851,6 +23876,7 @@ excenterweight excenterweights excenterweightsunnorm except +exceptd exceptemoji exception exception-only @@ -21861,6 +23887,7 @@ exceptionsfile exceptt excepttoemoji excepttype +excess excessive exch exchange @@ -21869,29 +23896,44 @@ exchanging excise excl exclamation +exclamdown exclude excluded +excludedmiddle excludes excluding exclusion exclusions +exclusive exclusively excom excomim excomimw excomw excxor +exd exdifsn exdistr exdistrf exdistrv exe exec +execd +execl +execlass +execn +execonst +execs +execstate +execstatet executable execute executed executereservednameaction execution +executions +exehas +exeinst exel exelalt exellim @@ -21902,6 +23944,12 @@ exemplifies exempt exeq exercise +exereplay +exesig +exesort +exesorts +exeterm +exetyp exeu exeupre exeuv @@ -21913,8 +23961,10 @@ exfalso exfinfldd exfo exgen +exhaust exhaustive exhaustively +exhausts exhibit exhibiting exhibits @@ -21925,6 +23975,8 @@ exidres exidresid exidreslem exidu +exieql +exii exim eximal eximalt @@ -21938,6 +23990,7 @@ eximp exinst exintr exintrbi +exirule exis exist existbij @@ -21965,6 +24018,7 @@ existsisfundamentaldomain existsisoimage existsisomap existsl +existsm existsmaximalsubsetproperty existsmaxmin existsmulofle @@ -21973,6 +24027,7 @@ existsnatonedivltmeasure existsonedivlt existsonlybynecessityofownnature existspairne +existspivot existspp existspullbackadj existsseqtendstoae @@ -21981,8 +24036,15 @@ existsunique existt exisym exit +exitcode +exitfailure +exiti exitidx exitidxopt +exits +exitsuccess +exitwith +exl exlem exlim exlimd @@ -22010,6 +24072,7 @@ exlimmpbir exlimmpi exlimvmpi exlude +exmap exmid exmidd exmidne @@ -22054,10 +24117,13 @@ expandrex expandrexn expandrintropats expands +expandss expandsubterms expandsuppresscompilationnotation expanduniss expansion +expansiond +expansioni expansions expb expcan @@ -22128,6 +24194,7 @@ exphomeomorph expi expia expib +expimnt expimpd expire expiry @@ -22135,6 +24202,7 @@ expl explain explained explaining +explains explanation exple explecnv @@ -22148,16 +24216,20 @@ explicitcokerneldesc explicitcokerneliso explicitdegrees explicitdisjoint +explicitfilter +explicitid explicitly explicitmeasurearg explicitness explicits +explimp expln explode explodecore explog exploit exploration +explored exploring explosion explosivedevice @@ -22205,6 +24277,7 @@ exponentialideal exponentialidealreflective exponentialpdf exponentialpdfreal +exponentials exponentiation exponents exponenttwo @@ -22227,6 +24300,8 @@ expr exprapp exprat exprb +exprbinoptypeable +exprchannel exprd exprec exprecd @@ -22242,6 +24317,8 @@ expressing expression expressions expressive +expreval +exprevall exprhs exprhsty exprinfo @@ -22250,6 +24327,7 @@ exprmap exprmfct exprmn exprmultimap +exprnotnone exprod exprop expropbi @@ -22263,6 +24341,9 @@ exprstructeq exprt exprtomatcher exprtosyntax +exprtypable +exprtypinghigh +exprtypinglow exprunify exps expscl @@ -22283,6 +24364,7 @@ expunitarypathtoone expval expzeq expzeta +exq exradius exrecfn exrecfnlem @@ -22302,12 +24384,15 @@ exstail exsum ext extaddequivcohomologyclass +extagrk extb extbinder extbinderparenthesized extblockssrc extblockstgt extcall +extcategory +extcategorymakecat extchart extcharta extchartat @@ -22325,13 +24410,16 @@ extdgmul extdgval exten extend +extendassoc extendbyone extendbyzero extendcocone extendcofan extendcofaniscolimit +extendcommute extendcomp extendcone +extendcontain extendcoordcha extendcoordchange extendcyclesiso @@ -22340,7 +24428,9 @@ extenddomainhom extended extendedbinder extendedhom +extendempty extendequiv +extendfalsum extendfan extendfanislimit extendfrom @@ -22357,9 +24447,11 @@ extendiso extendisoequiv extendle extendleft +extendlevel extendlib extendmap extendmiddle +extendnonempty extendo extendofislattice extendofisometr @@ -22372,6 +24464,10 @@ extendprop extendrclike extendrestrictscalarsadj extendringhom +extendrule +extendruleempty +extendruleemptyrev +extendrulenonempty extends extendscalars extendscalarscomp @@ -22383,6 +24479,7 @@ extendscalarsofsurjective extendscalarsofsurjectiveequiv extendscope extendset +extendsi extendsingleiso extendsscalars extendsubtype @@ -22395,9 +24492,11 @@ extendvars extendwith extendxiso extens +extensible extension extensional extensionality +extensionalityimplicit extensionasringhom extensiondocs extensionembedding @@ -22436,16 +24535,20 @@ externalproductbifunctorcurried externalproductcompdiagiso externalproductflip externalproductswap +externals externalto externs +extf extfsim extfunctor extfunctorobj +exti extid extinction extiso extj extlemmas +extmapk extmatch extmk extmonad @@ -22459,9 +24562,12 @@ extr extra extraattrs extract +extractacc +extractapartness extractargs extractcoeff extracted +extractequality extractfactor extracting extractinstname @@ -22469,10 +24575,12 @@ extraction extractmacroscopes extractopennames extractp +extractrelto extractrewriteeq extractrewritehypeq extracts extractsolution +extractstrict extractsymbols extracttacticdata extradec @@ -22487,12 +24595,17 @@ extralib extralth extras extremal +extremald extremalepi +extremali +extremally extremallydisconnected extremalnumber extreme +extremed extremely extremepoints +extremes extremum extremump extru @@ -22560,6 +24673,7 @@ facc faccc faccl faccld +faccs facd facdiv face @@ -22589,6 +24703,7 @@ facne facnn facp facr +facs fact facte facth @@ -22608,6 +24723,8 @@ factorials factoring factoringcompinclusion factorisation +factorisationhasallprimefactors +factorisationunique factorise factorizable factorizat @@ -22618,6 +24735,7 @@ factorizationlcmleft factorizationlcmright factorizationlcright factorizations +factorize factorized factorizedrational factorltenumber @@ -22685,11 +24803,14 @@ fahrenheit fai fail failed +faili failifunchanged failing +failk failprob fails failsafe +failt failure failurecache failurelist @@ -22709,6 +24830,8 @@ faithfulsm faithfulsmul faithfulvadd fajw +fake +fakeable fakeanorass fakeimass fakeinunass @@ -22746,10 +24869,15 @@ falortru fals false false_ +falseandduplicateliteralscanberemoved falsearrowequivpunit falsed falsehood +falsei +falseif falseral +falses +falsified falsify falso falsum @@ -22762,6 +24890,7 @@ familiename families familles family +familyi familymeasure familyofbfamily familyofelements @@ -22774,12 +24903,15 @@ famunion fan fand fans +fanssubs fao faosnf faovcl fappli fapply far +farey +fareys farfromtrianglefree fargid fargshiftf @@ -22802,9 +24934,12 @@ fastjacobi fastjacobisym fastjacobisymaux fastlegendresym +fastprod fastsubsingleton fastsubsingletonelim fat +fatal +fatom fatou fault faux @@ -22812,6 +24947,8 @@ favor favors favour favourable +fax +faxcd faya fba fbaa @@ -22822,6 +24959,7 @@ fbad fbae fbaeb fbaf +fball fbas fbasfip fbasne @@ -22855,6 +24993,7 @@ fbdb fbdcda fbdcea fbdd +fbdia fbdmn fbe fbea @@ -22867,6 +25006,7 @@ fbee fbef fbeff fbelss +fbex fbf fbfa fbfaaf @@ -22882,8 +25022,10 @@ fbfinnfr fbflim fbinop fbinopelab +fbint fbncp fbnnvetfeznoktah +fbool fbot fbound fbounded @@ -22901,6 +25043,7 @@ fboundedshiftless fboundedsuc fboundedzerosameexp fboundnext +fbox fbs fbssfi fbssint @@ -22930,6 +25073,7 @@ fcanonicnnormmin fcanonicposfexprlt fcanonicppred fcanonicunique +fcard fcb fcba fcbaac @@ -22983,6 +25127,9 @@ fcfnei fcfneii fcfval fcg +fch +fci +fcia fcl fclim fcljjtucd @@ -23020,10 +25167,13 @@ fcoi fcoidinvd fcoinvbr fcoinver +fcomp fcompare +fcompose fcompt fcomptf fcomptss +fconf fconfl fconj fconst @@ -23043,11 +25193,14 @@ fcoss fcovers fcp fcrgjkjjxforyivso +fcs fct fctop fctr +fctrs fcts fctx +fctxt fczfsuppd fczpsrbag fczsupp @@ -23123,6 +25276,7 @@ fdfd fdfdcafef fdfe fdff +fdia fdiagfn fdiff fdifferential @@ -23131,6 +25285,7 @@ fdifsuppconst fdigit fdigiteq fdisj +fdisjoint fdiv fdivmpt fdivmptf @@ -23147,7 +25302,9 @@ fdmfisuppfi fdmi fdmrn fdo +fdom fdomne +fdr fdrep fds fdvnegge @@ -23234,9 +25391,12 @@ felapton feldmfvelcdm fellow female +fempty +fence fences fenn fennrourke +fenum fepair fepi feq @@ -23267,7 +25427,9 @@ fesapo festino festinoalt fet +fetch feu +feval feven fevend fevenfop @@ -23283,12 +25445,14 @@ fewnomials fex fexafv fexd +fexists fexp fexpe ffa ffaac ffab ffac +ffact ffad ffadd ffae @@ -23347,6 +25511,7 @@ fffe fffeee ffff fffffb +fffffff ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff @@ -23356,7 +25521,10 @@ ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffft ffi +ffilter +ffin ffine ffis ffn @@ -23369,6 +25537,7 @@ ffnov ffold ffoss ffp +ffpi ffrn ffrnb ffrnbd @@ -23376,14 +25545,18 @@ ffs ffsrn ffsuppbi fft +fftf ffthf ffthiso ffthoppc ffthoppf ffthres +fftt ffun +ffunas ffunctor ffund +ffunion ffunk ffval ffvbr @@ -23392,6 +25565,7 @@ ffvelcdmd ffvelcdmda ffvelcdmi ffvresb +ffx ffz ffzeq ffzo @@ -23401,12 +25575,18 @@ fgalgcat fgalgcatskeleton fgcfil fgcl +fgco +fgcontra fge fgequiv fget +fgf fgfil fginv +fgl +fglb fglmod +fglr fgmin fgmodulecat fgmodulecatcoevaluation @@ -23415,6 +25595,7 @@ fgmodulecatevaluation fgmodulerepr fgn fgpk +fgraph fgraphopab fgraphxp fgreu @@ -23470,6 +25651,7 @@ fiberwisecolimitmapcompequivalence fiberwiselinear fibl fiblem +fibm fibo fibonacci fibp @@ -23482,6 +25664,8 @@ fibrations fibrec fibrefunctor fibrewise +fibs +fibstr ficard ficardadju ficardid @@ -23494,6 +25678,7 @@ fictionaltext fid fiddly fidelity +fidl fidmfisupp fidomdm fidomncyc @@ -23516,8 +25701,10 @@ fieldeq fieldequivofalgequiv fieldequivofalgequivhom fieldf +fieldi fieldle fieldlt +fieldmap fieldname fieldnames fieldnamestail @@ -23528,6 +25715,7 @@ fieldofmodelacf fieldofmodelfield fieldofsubtypeismaximal fieldpats +fieldproj fieldrange fields fieldsimp @@ -23536,6 +25724,7 @@ fieq fifo fifth figure +fii fiidomfld fiin fiinbas @@ -23562,6 +25751,9 @@ filename filenames filepath files +filesize +filesizecorrect +filesizeincreases filestartpos filesubstring filesystem @@ -23581,6 +25773,7 @@ filled filler filling fills +fillvalue filmap filn filnet @@ -23599,7 +25792,9 @@ filterandsubtypedomain filterappend filterat filterbasis +filtercomap filtercomparisons +filterd filterdpair filtered filteredbetree @@ -23614,6 +25809,7 @@ filteredmodule filteredring filteredunfolds filtering +filterl filterlim filterlinearmap filterm @@ -23621,10 +25817,15 @@ filtermap filtermapm filtermul filterne +filterof filteroutimplementationdetails filterproofs +filterquery filterrewrites filters +filtersd +filterse +filtertests filteruniv filtop filtr @@ -23665,6 +25866,7 @@ fin_hom_mul fin_hom_one fin_hom_strict fin_hom_zero +fin_image fin_le_fin fin_lt_fin fina @@ -23672,13 +25874,23 @@ finacn finaddequivprod finaddflip final +finalallow +finalb +finaldeny +finale finalement +finalid finality finalize finalizers finally finallysmall finalmodel +finalo +finals +finalsid +finalv +finance financialtransaction financing finantidiagonal @@ -23695,6 +25907,7 @@ fincategoryulift finchoice finchoiceequiv fincmp +fincomp fincongr fincons fincssdom @@ -23738,9 +25951,17 @@ finddefeq finddollarsyntax findeq findeqpath +finder findes +findexecutable +findexecutables +findexecutablesindirectories findexistsonedivlt findfield +findfile +findfiles +findfileswith +findfilewith findfromusername findfvar findfvcl @@ -23763,6 +25984,7 @@ findimvectorspaceequiv findindex findindexaux findindexes +findindices finding findlambdasyntax findle @@ -23785,17 +26007,22 @@ findmodelresult findmodels findmodulematches findmoduleof +findmonoidnames findnonzerorow findnotpowercertificate findnotpowercertificatecore +findnth findoneargs +findorempty findpositivevector findprefix findprefixtranslation +findprehnf findproj findprojection findprojectionindices findq +findr findreccl findredundantimports finds @@ -23874,6 +26101,8 @@ fingrouptype finhrecon fini finies +fininf +fininfi fininit fininsepdegree finish @@ -23885,6 +26114,7 @@ finitary finitaryextensive finitaryextensivetopcataux finitarypreextensive +finitc finite finite-dimensional finite_atmost @@ -23926,6 +26156,7 @@ finitedimension finitedimensiona finitedimensional finitedimensionalorder +finitee finiteelement finiteexhaustion finiteexts @@ -23938,6 +26169,7 @@ finitegroup finitegrp finitegrpdiagram finiteheight +finitei finiteindex finiteindexnormalsubgroup finiteindexnormalsubroup @@ -23969,6 +26201,8 @@ finitequotientoffreeofnebot finitequotientoffreeofrankeq finiteresiduefield finiteringkrulldim +finites +finitesetinterleavinglist finitespanningsetsin finitespanningsetsincompact finitespanningsetsinioorat @@ -23981,15 +26215,21 @@ finitesubproductscone finitesupport finitet finitetype +finitev finitewidepullbacks finitewitnessedsequentcalculus +finitnpc finity finiunmbl +finix finixpnum finj finjective +finl finlifton finlocfin +finlsts +finm finmap finmeas finmeasadditive @@ -23998,6 +26238,7 @@ finmeassupp finminlem finmixin finmulantidiag +finn finngch finnisoeu finnuc @@ -24015,6 +26256,7 @@ finpartition finpartitions finpartord finpifinequiv +finpow finprod finprodfinequiv finptfin @@ -24034,6 +26276,8 @@ fins finse finsepdegree finseq +finsert +finserti finset finsetapprox finsetbasis @@ -24073,6 +26317,7 @@ finsetwalklength finsetwalklengthlt finsigmafinequiv finsschain +finst finstronglymeasurable finsu finsubgraph @@ -24080,6 +26325,7 @@ finsubgraphhom finsubgraphhomfunctor finsubgraphofadj finsubmsubg +finsubsetall finsuccaboveequiv finsuccaboveorderiso finsuccaboveorderisofinset @@ -24128,11 +26374,15 @@ finsupptotal finsuppunique fint fintail +finter fintm +fintofin +fintofun fintonat fintonatbound fintonatlast fintonatweaken +fintrace fintsupport fintwoarrow fintwoarrowequiv @@ -24234,6 +26484,7 @@ finvn finvsub finvtrlemn finvtrn +finwo finxp finxpeq finxpnom @@ -24263,10 +26514,12 @@ first-element first-order firstcountable firstcountabletopology +firstd firstdart firstdeclm firstdiff firstdiffpos +firstgamma firstindexof firstinfo firstly @@ -24280,18 +26533,25 @@ firstnormalpos firstnormalposnormal firstobj firstobjeqfamily +firstoccurrenceexists firstorder firstpart +firstpass +firstrecursivecall firstreturn firstsecond firststep +firstsym firsttokens firsttomax firsttry +firsttwo firstunitcoeff +fis fischer fisdomnn fish +fishb fisher fiskernel fislw @@ -24310,6 +26570,7 @@ fisupg fisuppfi fisuppov fit +fiter fitop fits fitting @@ -24372,8 +26633,12 @@ fixingsubgroupinsertequiv fixingsubmonoid fixme fixoint +fixp fixpoint +fixpointi fixpointpolynomial +fixpoints +fixpt fixpts fixssdm fixssrn @@ -24381,6 +26646,8 @@ fixstar fixtow fixufil fixun +fixvar +fixvarfix fjgn fji fjv @@ -24401,10 +26668,14 @@ flatcombiner flatmap flatmapm flatness +flatp +flatpoly +flats flatten flattenpair flatzinc flavor +flawlessness flb flbi flblem @@ -24464,6 +26735,7 @@ fldivndvdslt fldivnn fldivp fldpropd +flds fldsdrgfld fldsdrgfldext fldssdrng @@ -24474,6 +26746,9 @@ fleqceilz flex flexible flexiblelinter +flexiblemagma +flexray +flexrayarch flfcnp flfcntr flfelbas @@ -24485,6 +26760,7 @@ flfneii flfssfcf flftg flfval +flg flge flhalf flhalflem @@ -24536,14 +26812,19 @@ fliphom flipiscolimit flipislimit flipisocurryswapuncurry +flipl +flipld fliplinear flipmultilinear flipmultilinearequiv flipnegatedcomparison +fliporder +flipped flipping flippingequiv flippingiso flist +flists flj flk flle @@ -24562,9 +26843,12 @@ flmulnn flnn flo float +floatarith +floatariths floatdec floateq floating +floatr floats floatspec floc @@ -24573,6 +26857,8 @@ flooding floor flooraux floordiv +floored +floorlog floorring floorringtosemiring floorroot @@ -24580,6 +26866,7 @@ floors floorsemiring flow flowchart +flowd flows floyd floyd-warshall @@ -24587,6 +26874,9 @@ floyd_warshall flp flpmodeq flr +fls +flsd +flsi flsqrt flsubz flt @@ -24603,10 +26893,12 @@ fltnlta fltnltalem fltp fltr +flub fluctuates fluent fluentbit flush +flv flval flword flwordi @@ -24614,7 +26906,10 @@ flx flxn flzadd fmachine +fmadd fmap +fmapet +fmapu fmax fmaxrep fmbf @@ -24622,17 +26917,23 @@ fmcfil fmcncfil fmco fmd +fmdiff +fmdom +fmdrop fmeas fmem fmember +fmempty fmf fmfg fmfil +fmfilter fmfnfm fmfnfmlem fmid fmin fminrep +fminsert fminus fml fmla @@ -24640,9 +26941,13 @@ fmlafv fmlafvel fmlan fmlaomn +fmlas fmlasssuc fmlasuc fmlasucdisj +fmlookup +fmmap +fmmerge fmon fmono fmorph @@ -24673,7 +26978,12 @@ fmptsnxp fmptssfisupp fmpttd fmptunsnop +fmran +fmrel +fmrestrict +fmset fmss +fmsubset fmt fmtno fmtnodvds @@ -24703,6 +27013,8 @@ fmuldfeqlem fmullem fmult fmultradixinv +fmupd +fmv fmval fmvars fnafv @@ -24727,6 +27039,7 @@ fnconstg fncpn fnct fncvm +fnd fndifnfp fndm fndmd @@ -24771,6 +27084,7 @@ fnevensuc fnex fnexalt fnexd +fnext fnfco fnfi fnfocofob @@ -24788,6 +27102,7 @@ fnfz fnfzo fng fnhomeqhomf +fni fniinfv fnil fnima @@ -24801,12 +27116,14 @@ fnimatpd fninfp fniniseg fniunfv +fnle fnlimabslt fnlimcnv fnlimf fnlimfv fnlimfvre fnmap +fnmember fnmgp fnmpo fnmpoi @@ -24924,10 +27241,12 @@ fnsucpred fnsucpredeq fnsuppeq fnsuppres +fnt fntopon fntp fntpb fntpg +fntt fntype fnubwyyxmlzgabnmewpittjgapdwrqeqresc fnum @@ -24982,6 +27301,7 @@ fof fofi fofinf fofn +fofu fofun foima foimacnv @@ -24990,13 +27310,16 @@ fold fold-arithmetic fold-based foldable +foldablewithdefaults foldbody foldbodyoption foldconsts foldcurrfiledecls folddeclerrorref folddiag +folddoc folder +foldforks foldidxm foldimporteddecls foldinfo @@ -25004,26 +27327,37 @@ foldinfom folding foldl foldleqfoldr +foldli foldlidx foldlidxm foldlm foldlmfoldrm +foldlop foldlz foldm foldmap foldmodules +foldphils foldr +foldri foldridx foldridxm +foldrl foldrm +foldrop foldrrecon +foldrs foldstate +foldwithdefaults +folk follow followed follower following +followpass follows foltrans +fom fompt fonc fonctions @@ -25035,6 +27369,7 @@ fontainethetainvertp fontainethetamodppow fonum foo +foobar food foodefinition fool @@ -25046,11 +27381,13 @@ footex footexalt footexlem footne +footprint foov fop fopp foprepaux fopwdom +fopxc for fora foral @@ -25062,6 +27399,7 @@ forallb forallboundedtelescope foralle foralllteqzero +forallm forallmetaboundedtelescope forallmetatelescope forallmetatelescopereducing @@ -25072,6 +27410,7 @@ foralls foralltelescope foralltelescopereducing forallyonedaissheaf +forball forbidden forbiddencharacters forbiddenimportdirs @@ -25122,7 +27461,9 @@ forgetmapconelimitconeiso forgetmapinitial forgetmapterminal forgetqc +forgetranged forgetreflectisos +forgets forgetstalk forgetting forgettoboolalg @@ -25174,6 +27515,7 @@ format formaterror formaterrors formation +formatspec formattable formatter formed @@ -25181,15 +27523,28 @@ formedness former formerly forming +formisentailed +formofsingleliteralvaluation formperm forms +formsi +formsubst formula +formulaalfa +formulabeta formulae +formulaentailsclauseremoveentailedliteralopposites +formulaentailsliteral +formulaentailsvaluation +formulafalse formulas +formulasd +formulasi formulate formulated formulates formulation +formulatrue forn fornats forschun @@ -25198,6 +27553,7 @@ forside forster forth fortunately +fortune forward forwarded forwardext @@ -25260,12 +27616,15 @@ fouriertransform fouriertransformclm fouriertransforminv fourn +fourpow fourth +fov fovcdm fovcdmd fovcdmda fovcl fovcld +fow fowdom fowffgwlyhylubnvbjsqjzqbkqmminxnnwyv fox @@ -25278,6 +27637,7 @@ fpcmcbdzxanc fperdvper fperiodmul fperiodmullem +fperms fphpd fphpdo fpid @@ -25290,6 +27650,7 @@ fpmod fpool fpos fposd +fpost fpow fpower fpowerseries @@ -25308,6 +27669,7 @@ fpqcprecoverage fpqctopology fpr fprb +fpre fpred fpredcanonic fpreddiff @@ -25373,10 +27735,14 @@ fprodsubrecnncnv fprodsubrecnncnvlem fprodxp fprodzcl +fprop fpropnf fprresex fps fpset +fpslsts +fpsmodrel +fpsrel fpvandoorn fpwfvss fpwipodrs @@ -25387,6 +27753,8 @@ fpws fpwwe fpwwecbv fpwwelem +fpxs +fqn fqt fqtinfty fra @@ -25398,6 +27766,7 @@ fracfld fracge fracle fraclt +fracpart fract fracti fraction @@ -25420,13 +27789,20 @@ fraenkel frag fragile fragment +fragments +fragmentsl +fragmentsls fraisse frame framed framehom framehomclass frameminimalaxioms +framer +frames +frametransmission framework +fran france frange frankfurt @@ -25436,12 +27812,15 @@ frc frcl frcond frd +frds fre freaks frechet frecheturysohnspace frecinnone frecinzero +frecr +frecrelp frecs frecseq fredholm @@ -25467,6 +27846,7 @@ freecommring freecommringequivmvpolynomialint freecommringpemptyequivint freecommringpunitequivpolynomialint +freed freedesc freedfinsuppequiv freedom @@ -25484,6 +27864,8 @@ freegroupoid freegroupoidfunctor freegroupunitequivint freehomequiv +freei +freein freeing freelib freeliealgebra @@ -25512,6 +27894,7 @@ freenonunitalnonassocalgebra freeobj freeobjdesc freeon +freeord freeproduct freer freerefl @@ -25521,6 +27904,7 @@ freereflrel freering freeringpemptyequivint freeringpunitequivpolynomialint +frees freesection freesemigroup freesimplexquiver @@ -25540,6 +27924,7 @@ freiheitsstatue frel freld fremlin +fremove frenchwine freq freque @@ -25555,9 +27940,16 @@ fresf fresfo fresh fresh_id +fresha +freshboundderivative +freshen +freshenlc freshloc +freshmans freshmansdream freshname +freshs +freshstaratom fresin fresison frespects @@ -25617,15 +28009,20 @@ frgrwopregbsn frgrwopreglem frgsrc frgtgt +frgv fri friction friday +friend friendgraph +friendids friendlyoperation friendlyoperationclass +friendreq friends friendship friendshipgt +friendv frind frinfm fringe @@ -25694,6 +28091,8 @@ frmdup frmdval frmin frminex +frmls +frmuc frmx frmy frn @@ -25734,15 +28133,21 @@ fromaddgrouptodivisionmonoid fromaddmonoid fromaffine fromaffinerefinement +fromalignment +fromall +fromany fromappend fromarrowarrowfunctor frombinary frombiprod +frombits frombl fromblocks fromblockszero +frombool fromc fromcache +fromchar fromchosenterminalequiv fromcircle fromclass @@ -25750,17 +28155,25 @@ fromclm fromcocone fromcofilteredinitialmodel fromcokleisli +fromcolist fromcols fromcommleftinv +fromcommutativering +fromcommutativesemiring fromcomponents fromcoset fromcostructuredarrow +fromcowriter +fromdelay fromdescentdatafunctor fromdfinsuppequiv +fromdigits fromdirectlimit fromdirectsumequiv fromedgeset fromend +fromequal +fromequivalence fromeuclideanspace fromextendscalars fromfile @@ -25768,8 +28181,10 @@ fromfilteredfinalmodel fromfin fromfinalm fromfinalmodel +fromforeign fromfreeyoneda fromfreeyonedacoproduct +fromfunction fromfunctionfield fromgens fromglued @@ -25780,12 +28195,14 @@ frominduced frominducedcoremonoidal frominducedmonoidal frominitialmodel +frominj fromiter fromkleisli fromleft fromleftderi fromleftderivedzero fromleftinv +fromlist fromlistischain fromlocalizedmodu fromlocalizedmodule @@ -25794,8 +28211,10 @@ fromlrat fromlrataux fromltesucc frommanifold +frommap frommatrix frommatrixlinear +frommaybe frommeasurablespacestosetsofsets frommiddle frommiddlehom @@ -25817,8 +28236,10 @@ fromoverfunctorelementsequivalence fromoversubfunctor frompadicint frompath +frompermutation frompisystemstomeasurables frompisystemstomeasurablespaces +frompointwise frompreimage fromprod frompuni @@ -25826,6 +28247,7 @@ frompunit fromquotient fromrealinterval fromrel +fromrelated fromrell fromrelorderembedding fromrepresentation @@ -25836,17 +28258,21 @@ fromrows froms fromsaturateofhaspullbacks fromsaturatetosaturatehomotopy +fromsetoidendo fromsfunname fromsfunnames fromshrink fromshrinkhoms fromsigma +fromsign fromsingle fromsingleequiv fromsinglemk +fromsingleton fromskeleton fromskeletontoskeletoniso fromsnames +fromsome fromspec fromspecresiduefield fromspecstalk @@ -25854,24 +28280,34 @@ fromspecstalkofmem fromspectospec fromstalk fromstep +fromstream fromstructuredarrow fromsubtype +fromsuffix fromsum fromtangentbundle fromtangentspace fromtensor +fromthat fromthinskeleton fromthinskeletoncomptothinskeletoniso +fromthis fromtilde fromtop fromtotalspace +fromtree fromtype fromtypes fromunit fromunitlift fromunitsofalgebra fromupperhalfplane +fromvec fromvector +fromview +fromwitness +fromwitnessfalse +fromword fromzeroringhom fromzetaaut front @@ -25880,9 +28316,13 @@ frontends frontface frontier frontiers +fronts frontseat frontsegp +frop fround +frown +frp frpoind frpoins frpoinsg @@ -25906,9 +28346,11 @@ frv frvlpq frxp fs +fsafe fsb fsc fscgr +fscompose fsecmat fseq fseqdom @@ -25952,7 +28394,9 @@ fsigmaness fsim fslope fsltp +fsm fsn +fsnames fsnd fsneq fsneqrn @@ -25990,8 +28434,11 @@ fst_name fst_type fstab fstar +fstate fstcart fstclm +fstd +fste fstep fstequiv fstfunctor @@ -26003,12 +28450,14 @@ fstl fstpad fstpimap fstpimapofislimit +fsts fstsigmamap fstsigmamapofiscolimit fstsize fstsnd fstwrdne fstx +fstzero fstₗ fsu fsub @@ -26026,6 +28475,8 @@ fsubnormalunique fsubnormfabs fsubnormfopp fsubset +fsubseteq +fsuc fsucc fsucccanonic fsuccdiff @@ -26127,6 +28578,7 @@ fsumub fsumvma fsumxp fsumzcl +fsup fsupdm fsupp fsuppco @@ -26171,11 +28623,16 @@ fta ftalem ftaylorseries ftaylorserieswithin +ftb ftc ftcfilter ftdown +fterm +ftff +ftft ftgt fthcomf +fthe fthepi fthestrcsetc fthf @@ -26190,15 +28647,28 @@ fthpropd fthres fthsect fthsetcestrc +fti ftlfgicqhyuvaqck fto ftop ftor +ftorcomp +ftorcompcomp +ftorcompid +ftorcompiddef +ftorcompm +ftorcomppreftor ftoreqinv +ftorm ftorradix ftp ftpg +ftrancl +ftree +ftrs ftrue +fttf +fttt fty ftype ftz @@ -26251,7 +28721,9 @@ fuelid fufjjyjeehpn ful fulfill +fulfilled fulfills +fulkerson full full-proof fullbodiedwine @@ -26263,9 +28735,11 @@ fullfunc fullfunfnv fullfunfv fulli +fullinit fullname fullnormalize fullnormalizeiso +fullnxt fulloppc fulloppf fullp @@ -26274,6 +28748,7 @@ fullpropd fullres fullresc fullsetcestrc +fullspec fullsubc fullsubcategory fullsubcategorycongr @@ -26349,7 +28824,9 @@ funaltveqi funaltvfun funaltvss funapp +funapply funargid +funas funassert funbindertypes funbrafv @@ -26395,6 +28872,7 @@ funco funcocnv funcoeqres funcofd +funcong funcongrleft funconstss funcoppc @@ -26415,6 +28893,7 @@ funcsetc funcsetcestrc funcsetcestrclem funcsetcres +funcseti funcsn funct functermc @@ -26431,8 +28910,10 @@ functionalextensionality functionality functionalproperty functionals +functioncompletion functiondata functionfield +functionfrechet functioninverse functions functionsboundedatinfty @@ -26453,7 +28934,9 @@ functorcategoryhaslimitsofshape functorcategoryhaslimitsofsize functorcategorymonoidalclosed functorcomp +functorcompdef functorcompinverseiso +functorcompmapsto functorcompose functorcoremonoidalofcomp functorderivehandler @@ -26505,10 +28988,13 @@ functorisodiscretecomponents functorisomk functorl functorleftcomp +functorm functormap functormapreverse functormapsrc +functormapsto functormaptgt +functormfunctor functormk functormonoidalofcomp functornhds @@ -26588,6 +29074,8 @@ fundcmpsurinjlem fundcmpsurinjpreimafv fundcocircuit fundef +fundefs +fundefsi fundif funding fundmafv @@ -26637,6 +29125,7 @@ funimassov funin funinfo funinvidassoc +funion funisfsupp funiun funiunfv @@ -26666,12 +29155,14 @@ funoprab funoprabg funopsn funorigin +funp funpart funpartfun funpartfv funpartlem funpartss funpow +funpower funpr funprg funprop @@ -26701,6 +29192,7 @@ funs funsaltv funset funsig +funsignature funsn funsndifnop funsneqopb @@ -26717,10 +29209,12 @@ funssfv funssres funsssuppss funssxp +funtofin funtopon funtp funtpg funtransport +funtype funun fununfun fununi @@ -26733,11 +29227,14 @@ funvtxdmge funvtxval fup fupd +fupdate fupdkey furniture further furthermore furthest +fuse +fused fusgr fusgredgfi fusgreg @@ -26753,8 +29250,13 @@ fusgrregdegfi fusgrusgr fusgrvtxdgonume fusgrvtxfi +fusion +fut futex +futr future +futures +futz fuu fuzxrpmcn fva @@ -26772,6 +29274,7 @@ fvaridset fvaridstosimp fvaridtodecl fvars +fvarst fvarusername fvaw fvawlemn @@ -26877,8 +29380,10 @@ fvn fvneq fvnobday fvnonrel +fvo fvopab fvopabf +fvoption fvovco fvoveq fvpr @@ -26902,12 +29407,14 @@ fvrnressn fvrtrcllb fvs fvsb +fvse fvsetsid fvsingle fvsn fvsng fvsnun fvssunirn +fvt fvtp fvtransport fvtrcllb @@ -26922,6 +29429,7 @@ fvwalt fvwrd fvx fvyzuy +fwb fwciijovosxu fwd fwddiff @@ -26934,6 +29442,8 @@ fweight fweighteq fweightlt fweightzle +fwi +fwlink fwsc fwsistercitiesorgpdfsmbabanembabane fwx @@ -27092,6 +29602,7 @@ gaass gabeqd gabeqis gabima +gabow gabriel gabrielcomposition gabrielpopescu @@ -27129,6 +29640,7 @@ galactionhom galbasis galcan galcyclotomicequivunitszmod +gale galequivzmod galerkin galgeb @@ -27189,6 +29701,7 @@ gammasetdivgcdsigmaequiv gammasetequiv gamne gamp +gand gaold gaorb gaorber @@ -27210,6 +29723,10 @@ gasubg gat gate gateaux +gateway +gatewayreq +gatewaysystem +gatewaysystemreq gather gau gauche @@ -27236,6 +29753,7 @@ gausssumprod gausssumvalues gave gay +gba gbar gbarlr gbas @@ -27245,6 +29763,7 @@ gbeeven gbege gbegt gbepos +gbg gbi gbinomial gbj @@ -27264,6 +29783,7 @@ gbowgt gbowodd gbowpos gbpart +gcard gcd gcda gcdabs @@ -27315,6 +29835,8 @@ gcdx gcdy gcdz gcdzeq +gce +gceoinvrminus gcf gcfunctions gch @@ -27330,6 +29852,7 @@ gchhar gchi gchina gchinf +gchoose gchor gchpwdom gchxpidm @@ -27338,10 +29861,15 @@ gcienat gcigeneratefrom gcimapcomap gciordcard +gcls +gcm gco +gcoeff +gcollapse gcombo gcommmonoid gcommsemiring +gcomp gcon gcongr gcongrdischarger @@ -27355,7 +29883,10 @@ gcongrselectionpanel gcont gcorec gcproof +gcs +gcsort gctx +gctxt gcwsa gczxzzwkpljeuxrakxlenvgdriyotbsuzswawtunggvseysusmeiytcbeoyuckwdyjxnurrz gdelta @@ -27367,10 +29898,13 @@ gds gdt gdtverismo gear +gebub geck gecode gecxbvyyshct +ged geg +gei gelaki gelb gelfand @@ -27381,6 +29915,7 @@ gen gen-refine gen-session gen-term-eq +gena genan gencbval gencbvex @@ -27463,6 +29998,7 @@ generators generatorsofiscokernelfree generic genericdisk +genericjoin genericmonicpoly genericmonicpolyhasroot genericpoint @@ -27505,6 +30041,7 @@ genpss genpv genr gens +gensi gensizedsuchthatcorrect gensizedsuchthatsizemonoton gensizedsuchthatsizemonotonicopt @@ -27573,10 +30110,14 @@ germtofunctionfield germtopullbackstalk gerp gerpmpt +gerth get get-model get-proof get-unsat-core +getact +getacto +getactv getaddends getaliassyntax getallblists @@ -27586,6 +30127,7 @@ getallfiles getallimports getallleft getallmodulessorted +getallpaperids getallperms getallpermutations getallsimpattrs @@ -27598,6 +30140,7 @@ getappargs getappfn getappfnargs getappnumargs +getappuserdatadirectory getarg getargs getarity @@ -27607,6 +30150,9 @@ getattrnames getattrs getaux getauxdefofdeclname +getavstore +getbackjumplevel +getbase getbasis getbijectionofforallmemlist getbinarybiproductdata @@ -27619,15 +30165,20 @@ getblocksd getbooloption getbound getbracketedbinderids +getc getcalcrelation getcanonicalantiquot getchildngen +getchoices +getcl getcoefninfo getcolimitcocone getcompositeofprojections getcompositeofprojectionsaux getconfig getconfigitems +getconflictclause +getconflictflag getcongrappfnargs getcongrlemma getconst @@ -27636,9 +30187,11 @@ getconstinfoctor getconstinfodefn getconstinfoinduct getconstinforec +getcontents getcontext getcontrlemma getcurperm +getcurrentdirectory getcurrnamespace getd getdecl @@ -27650,6 +30203,7 @@ getdefaultinstances getdeprecatedinfo getdeprecatedsyntax getdiag +getdirectorycontents getdm getdocstring getdocstringtext @@ -27659,7 +30213,9 @@ getele getelem getelemasfin getelems +getelim getenv +getenvironment geteqnsfn getequiv getequivofforallcounteqone @@ -27668,17 +30224,26 @@ getexplicitlist getexpr getexprinputs getexprmvarassignment +getf getfi getfiberfunctor +getfield getfieldstoparents getfilemap getfilename +getfilesize getfirstminoridx getfnconstname getfnorigin getfoldarray getforallarity getforallbody +getfresh +getfreshapiid +getfreshconfid +getfreshpaperid +getfreshpostid +getfreshuserid getfunctiondata getfunctorpushforwardstructure getfuninfonargs @@ -27695,18 +30260,24 @@ getfvarlocaldecl getfvarsnotimplementationdetails getglobalattributesin getglobalrulesets +getgmstate +getgmusercom getgoallocations getgoals gethea gethead getheadinfo +gethheap gethints +gethomedirectory gethygieneinfo gethypotheses gethypothesisrewrites geti getid getids +getij +getijproperties getimportcandidates getimportids getimportrewrites @@ -27714,6 +30285,8 @@ getimports getindices getinfostate getinfotrees +getinput +getinputt getinst getinstanceattrkind getinstancepriority @@ -27724,6 +30297,7 @@ getjointappfns getkind getlambdatheorems getlast +getlastassertedliteralcharacterization getlastd getlasti getlastid @@ -27737,6 +30311,7 @@ getlhs getlhsrhscore getlimitcone getlin +getline getlinterglobalattributein getlinteroptions getlintervalue @@ -27762,11 +30337,15 @@ getmaxvar getmctx getmemtype getmessagelog +getmin +getmine +getmintree getmodulecandidates getmoduleidx getmoduleidxfor getmodulerewrites getmorphismtheorems +getname getnameofident getnames getnamesfrom @@ -27783,12 +30362,17 @@ getnumargs getnumheadforalls getnumheartbeats getnumparts +getobs +getobso +getobsv +getoneip getops getoptional getoptions getorelse getpackagedir getparam +getparts getpathtobasestructure getpcompset getpos @@ -27806,6 +30390,7 @@ getppoption getpptagappfns getprefix getprettyprintopt +getprogname getprojectedexpr getprojectionexprs getprojectionfninfo @@ -27814,9 +30399,12 @@ getprojfnforfield getproof getprophyps getprotocol +getq +getr getrange getrangewithtrailing getrawprojections +getreason getreducibilitystatus getref getrel @@ -27830,6 +30418,8 @@ getrightadjoint getroot gets getscopes +getsearchpath +getsec getsepargs getsetoptionmaxheartbeatscomment getsimpargs @@ -27848,6 +30438,7 @@ getstackentries getstackstag getstained getstate +getstatic getsteptype getstruct getstructurefields @@ -27857,6 +30448,7 @@ getsubexpressionmatches getsubproblem getsubstring getsupport +getsymboliclinktarget getsyntaxnodekinds getsyntheticmvardecl gettableau @@ -27865,6 +30457,7 @@ gettactics gettag gettailinfo gettailpos +gettemporarydirectory getter gettfaelist gettheoremfromconst @@ -27872,12 +30465,15 @@ gettheorems gettheoremsforfunction getthreadc getthreadr +gettime getting gettokentable gettrailing gettransitiontheorems gettransparency +gettree gettreesupport +gettrustedinput gettyp gettype getunassignedgoalmvardependencies @@ -27886,15 +30482,24 @@ getunlintedranges getunsolvedgoals getunusedforallinstancebinderidxswhere getunusedname +getuserdocumentsdirectory getusername getusingarg +getv getvalue getvalues +getvariableindices getvarstoclear getvert getvertequiv getvisited +getvstore +getwatch +getwatchlist getwithargs +getword +getxdgdirectory +getxdgdirectorylist gex gexcl gexdvds @@ -27905,6 +30510,7 @@ gexid gexlem gexnnod gexod +gexp gexval gfcomp gfcomps @@ -27914,8 +30520,11 @@ gfgroup gfgroupset gfhereditary gfi +gfind gfiso gfmod +gfold +gfoldl gfp gfpapprox gfq @@ -27934,9 +30543,13 @@ gggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggg ggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggg gggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggg gggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggg +ggreater +ggs ghas +ghc ghcb ghdist +ghg ghm ghmabl ghmac @@ -27970,6 +30583,7 @@ ghmqusnsg ghmqusnsglem ghmrn ghmsub +ghole ghomco ghomdiv ghomf @@ -27984,6 +30598,7 @@ ghostmap ghspace ghx giaux +gibbard gicabl giccyg gicen @@ -28010,6 +30625,8 @@ gimco gimf gimfn gimghm +gin +ginitial ginj gint ginv @@ -28018,6 +30635,7 @@ girard girestrict girth giry +gis gisaturation giscokernel git @@ -28032,6 +30650,7 @@ gives giving gjhrmswhmiuxrvmwovbcvftqqcvvztegonvyaiajftwsrakqtiosthpyxdmlc gkrzmdulbkimxyvpwedpv +gla glb glbcl glbconn @@ -28042,6 +30661,7 @@ glbelss glbeu glbfun glbfval +glbi glble glbpr glbprdm @@ -28052,7 +30672,11 @@ glbval gleason glem glggfufacvzlgldjlvpwisbszm +glibc glide +glit +glitofc +glitofl glob global global-type @@ -28060,6 +30684,7 @@ globalattributein globalattributeinlinter globalbranchingpreprocessor globalconformality +globald globalenv globalequiv globalequivaux @@ -28102,20 +30727,31 @@ gluemorphisms gluemorphismsoflocallydirected gluemorphismsoveroflocallydirected gluepremetric +gluer glues gluespace gluing +gmap +gmapall gmax gmcont +gmctxt +gmd +gmean gmeas +gmft gmgnlwvr gmint +gmn +gmnl +gmod gmodule gmon gmonoid gmul gmulhom gmullhom +gmult gneispa gneispace gneispaceel @@ -28125,8 +30761,12 @@ gneispacern gneispacess gneispb gnet +gnew +gnf +gni gnmac gnonunitalnonassocsemiring +gnot gnpow gnpowrec gns @@ -28156,11 +30796,20 @@ goaltype goaltypes goaltypewithmetavars goat +gobrk gobxjuj god +goddefsareequivalent godel godellob +godeximpliesnecex +godexistenceimpliesnecexistence +godexistenceisvalid +godimpliesexistence +godisessential godlike +godnecexists +goedel goel goelel goeleq @@ -28170,7 +30819,9 @@ goes goestozero goewxr gof +gogs going +goinitial gold goldbacheven goldbachodd @@ -28193,19 +30844,32 @@ gonar gonarlem gone good +goodd +goode +goodi goodproducts goodr goodreduction +goodstein +goodsteinc +goodsteino +goodsteins google +gorder gosper gospercatal gospercatalan got goto +gotoelim goursat goursatfst goursatsnd govern +gpair +gpaird +gpath +gpb gpcont gpetersengr gpg @@ -28231,10 +30895,14 @@ gpgvtxdg gpgvtxedg gpgvtxel gpint +gpop gpos +gpre gprod gprodd gprog +gpush +gpv gra grab grade @@ -28278,6 +30946,7 @@ grahamconjecture grain grained gram +gramian grammaire grammar gramschmidt @@ -28285,27 +30954,39 @@ gramschmidtbasis gramschmidtn gramschmidtnormed gramschmidtorthonormalbasis +grand grandchild grant granular graop grape graph +graphd graphequiv graphfunctor +graphi +graphical graphiso graphlociso graphon graphs grassmann grastruct +grave gravity gray grbar grcat +grd +grdlit +gre great greater greatereq +greaters +greaterthan +greaterthanatmost +greaterthanlessthan greatest greatestfib greatestofbdd @@ -28313,14 +30994,20 @@ gree greedily greedoid greedy +greek +greekmortal green greet +grel gremlocksetcode gremlocksetres grewrite grewritelocaldecl grewriteresult grewritetarget +grey +greyi +greys gri gricbri gricen @@ -28336,8 +31023,10 @@ grictr gricushgr gricuspgr grid +gridgen gridlines griedg +griggio grilcbri grimcnv grimco @@ -28387,11 +31076,13 @@ grn gro grobner grocer +groebner gromov gromovhausdorff gronwallbound gropd gropeld +grot groth grothac grothendieck @@ -28414,10 +31105,13 @@ grothshort grothshortbi grothtsk ground +grounded +grounding group groupaction groupaddgroupequivalence groupalgebra +groupcast groupcohomology groupcohomologyiso groupcohomologyisoeven @@ -28460,6 +31154,7 @@ groupoids groupop grouporder groupp +groupparts grouppower grouppowers groupprops @@ -28467,11 +31162,13 @@ groupreaders groups groupseminorm groupseminormclass +groupseqs groupset groupsmul groupstructure grouptheory grouptopology +groupwis groupwit groupwithzero groupwithzeroofcancel @@ -28497,6 +31194,7 @@ grpcld grpcominv grpd grpeq +grph grphom grpid grpidcl @@ -28648,6 +31346,7 @@ grpwithzero grrgr grrusgr grs +grsteps grstr grstructd grstructeld @@ -28699,8 +31398,12 @@ gruxp grvtx grw gsca +gselect gsemiring +gset +gsfw gsh +gsi gsmsymgreq gsmsymgreqlem gsmsymgrfix @@ -28708,17 +31411,25 @@ gsmsymgrfixlem gsmtrcl gsmul gsmulhom +gso gsoaddfp gsofp gsolockresremlock gsolockresupdlock +gsopt +gsp gspec gsqazyclfq +gsrstep +gsrsteps gss gssaddfp gssfp gsslockresremlock gsslockresupdlock +gst +gstate +gsuf gsum gsumadd gsumaddval @@ -28848,12 +31559,16 @@ gsumzsplit gsumzsubmcl gsumzunsnd gsurj +gta gtc gtdbwisghx gte +gteq gtereflectsgte +gterm gtfsumgt gthm +gti gtinf gtiso gtmnf @@ -28862,49 +31577,73 @@ gtned gtneii gtnelicc gtnelioc +gto gtot +gtotal gtr +gtrancl +gtrs +gts gtso +gtt gty +guar guarantee guaranteed guaranteeing guarantees +guaranteestrippair guard guarded +guardedseqsubst guardexceptions guardmsgscmd +guardrule guards +guarnoreadorwrite +guarnowrite gue guess guessed guesses +guessi guessing guessname guessnamedata guessreorder +guest +guha guide guides +guillemotleft +guillemotright guitarte guitartexact gunion +gunodes guntzer gurobi gusakov guv guy guz +gval gvars gvd gvxy gxjzddcuxnbaevglrxdcjejdoevfjghx gxs gyqbrvnzqzcjyjk +gyr +gyro +gyrocarrier +gyronorm gzabssqcl gzaddcl gzcjcl gzcn gzcrng +gzero gzetqlzvmwrezzxrhuaunru gzfrqqleskebvyzkjhmoakzfsbeeopui gzmulcl @@ -28962,6 +31701,7 @@ hadd haddlen hadifp hadj +hadjicostas hadnot hadp hadrot @@ -28969,6 +31709,7 @@ hae haef haefg haeval +haevents haf hafter hag @@ -28982,6 +31723,11 @@ hahnmodule hahnseries hai haim +hainitstate +hainitstatecaraudiosystem +hainitstates +hainitstatescaraudiosystem +hainitvalue hainj haint hainv @@ -28989,6 +31735,8 @@ haj hak hal hale +haleph +hales half halfaddsub halfaddsubcl @@ -29002,6 +31750,7 @@ halfge halfgt halflem halfleoddlt +halflist halflt halfnneg halfnq @@ -29024,6 +31773,7 @@ halt halted halting haltlist +halts halves halvesd halving @@ -29034,6 +31784,7 @@ hamburg hamburger hamc hameas +hamilton hammin hamming hammingdist @@ -29063,6 +31814,7 @@ handletimeout handling handover handover_v2 +handshake handthen handy hane @@ -29120,7 +31872,11 @@ harmonize harn harndom harness +haroot +harootcaraudiosystem haroots +harper +harr harry harsdom harsucnn @@ -29395,6 +32151,7 @@ hashcard hashcl hashclb hashclwwlkn +hashcode hashcommand hashcommandlinter hashdif @@ -29434,6 +32191,7 @@ hashgf hashginv hashgt hashgval +hashi hashimaf hashimarn hashimarni @@ -29507,6 +32265,7 @@ hashxp hashxpe hashxplem hashxrcl +hasi hasidealsupport hasimage hasimagem @@ -29611,6 +32370,8 @@ hasnoloop hasnonabelianatoms hasnondegenerateedges hasnondegeneratevertices +hasnontrivialdivisor +hasnontrivialdivisorlessthan hasnot hasnsmul hasofpostcompproperty @@ -29764,6 +32525,7 @@ hassupport hassups hassyntheticsorry hast +hastates hastemper hastemperategrowth hastensor @@ -29774,6 +32536,9 @@ hasterminalchangeuniverse hastotal hastrivialradical hastwooutofthreeproperty +hastype +hastypee +hastypei hasu hasuncle hasuncomparable @@ -29786,6 +32551,7 @@ hasup hasupperlowerclosure hasvalue hasvintageyear +hasw haswe hasweaksheafify haswidecoequalizers @@ -29813,6 +32579,7 @@ hatomic hatomici hatomistici hatoms +hats hattop hau haus @@ -29865,6 +32632,7 @@ haven havenewentries havenothingincommon having +havoc haw hax hay @@ -29890,6 +32658,7 @@ hbalw hban hbas hbase +hbasei hbasis hbazdsiunzrkbeqktnzxt hbb @@ -30000,6 +32769,7 @@ hcbi hcc hcccru hcd +hcderived hcdiff hcdn hcdvd @@ -30016,6 +32786,7 @@ hchain hcham hchar hchoose +hchop hci hcinf hcj @@ -30051,11 +32822,14 @@ hcol hcolamc hcolbmc hcolc +hcollect +hcollecti hcolon hcom hcomm hcomp hcompact +hcompat hcompatible hcompc hcompf @@ -30070,6 +32844,7 @@ hconcat hcond hcone hconf +hconfd hcong hcongr hconj @@ -30213,6 +32988,7 @@ hdr hds hdsd hdso +hdss hdsu hdt hdtl @@ -30236,6 +33012,7 @@ headerlinter headers headerstr headertestfiles +headg headhead headi headin @@ -30243,22 +33020,31 @@ headindex heading headless headmap +headn headnumargs +headnz +headr heads headstructureetareduce +headt +headtail healt health healthy heap +heaphelp +heapify heapim heapinsert heapprox +heaps heart heartbeats heating heavier heaviest heavily +heaviside heb hec heccl @@ -30285,6 +33071,7 @@ heibor heiborlem heicant height +heighte heightonespectrum heights heine @@ -30296,6 +33083,7 @@ held helim hell hello +helloname helloworld helly help @@ -30317,8 +33105,10 @@ hen henabled hencard hence +hendphase hene hens +hensel henselianlocalring henstock hentlen @@ -30366,6 +33156,7 @@ hereditary herein herglotz herglotzrieszkernel +herm herman hermes hermite @@ -30381,6 +33172,7 @@ hesymm het heterobasic heterogeneous +heterogenous hetx heu heuniv @@ -30409,6 +33201,8 @@ hexy hey heyting heytingalgebra +heytingcommutativering +heytingfield heytinghom heytinghomclass hez @@ -30419,6 +33213,7 @@ hfac hfact hfadj hfadp +hfail hfair hfalse hfan @@ -30444,6 +33239,7 @@ hfdeg hfderiv hfdifferential hfdisj +hfdropi hfdvd hfe hfelhf @@ -30486,6 +33282,7 @@ hfirr hfix hfj hfk +hfkeep hfku hfl hflat @@ -30494,12 +33291,14 @@ hfleoneonk hfloor hflp hflt +hflush hfm hfmax hfme hfmeas hfmgle hfmin +hfml hfmmval hfmodp hfmono @@ -30528,6 +33327,7 @@ hfrob hfrv hfs hfsa +hfset hfsi hfsmval hfsn @@ -30585,6 +33385,7 @@ hgdeg hge hgen hgeq +hgetbuffering hgexact hgexp hgf @@ -30743,6 +33544,8 @@ hico hid hidden hide +hidedups +hidedupsrec hident hideous hides @@ -30761,11 +33564,13 @@ hifu hig high high-level +highbodies higher higher-order higherfacesvanish higherorderderivehandler higherordergetparam +higherpowers highest highestweight highi @@ -30790,6 +33595,7 @@ hilbertbasis hilbertpoly hilcms hilcompl +hilf hilhhi hilhl hilid @@ -30835,10 +33641,14 @@ hinotmax hinr hins hinsep +hinsert hint +hinter hinternal hintextension hintf +hintikka +hintikkas hints hinv hinvc @@ -30861,6 +33671,8 @@ hiscompact hisds hislocal hiso +hispred +hisprev hist historical historically @@ -30872,6 +33684,7 @@ hisupp hit hite hitop +hitting hittingafter hittingbtwn hiu @@ -31002,6 +33815,7 @@ hlcompl hlcph hlcvl hld +hlde hldi hldir hle @@ -31247,6 +34061,8 @@ hmpos hmq hmr hms +hmset +hmsetmset hmsn hmsq hmsum @@ -31258,6 +34074,7 @@ hmul hmule hmulleft hmulright +hmultiset hmulvec hmvt hmvzdaaituizitgfw @@ -31297,6 +34114,7 @@ hneq hneven hnew hnext +hnextpart hnez hnezero hnf @@ -31353,6 +34171,7 @@ hnq hnqp hnr hnreach +hnri hnrp hns hnsep @@ -31428,7 +34247,9 @@ hodmval hodseqi hodsi hodval +hoeffding hoeffdinglemma +hoelder hoelderminkowski hoeq hoeqi @@ -31436,10 +34257,12 @@ hof hofcl hofcllem hofer +hoffax hofpropd hofunctor hofval hog +hohv hoi hoico hoicoto @@ -31458,6 +34281,7 @@ hoidmvval hoif hoimbl hoimbllem +hoinitconfig hoiprodcl hoiprodp hoiqssbl @@ -31481,6 +34305,7 @@ holdsat holdsduring holdsforlocalization holdsforlocalizationaway +holdsistate hole holes holley @@ -31518,6 +34343,7 @@ homastype homastypeequiv homaux homaval +homc homcartesianlift homcategory homcl @@ -31525,11 +34351,14 @@ homclass homco homcocontinuouscontravariant homcocontinuouscovariant +homcod homcomp homcomplex homcongr +homd homdiagram homdmcoa +homdom home homeo homeobot @@ -31560,6 +34389,7 @@ homeoofequivcompacttot homeoofiso homeorealmixedspacepolars homeorealmixedspacepolarspace +homeos homeotop homeowithuppersettopologyorderiso homequ @@ -31591,6 +34421,7 @@ homftor homfval homgroup homgroupoid +homi homid hominduction hominfinitesimal @@ -31697,8 +34528,11 @@ homologyι homologyπ homolr homom +homomorphic homomorphism +homomorphismi homomorphisms +homoproduct homorl homorthogonal homothetic @@ -31754,6 +34588,7 @@ homover homoverequiv hompullbackequiv homquotientzpowofhom +homr homrel homresolutioniso homrestrict @@ -31789,10 +34624,15 @@ honegsubdi honegsubi honehypercover honest +honextconfig +honorary honpcani honpncani hoo hook +hookleftarrow +hookrightarrow +hoops hop hope hopefully @@ -31804,7 +34644,9 @@ hopfalgebra hopfobj hopi hopncani +hops hor +horcvdmsgs hord horder hordered @@ -31823,6 +34665,7 @@ hornfilling horninclusion horrible horrific +horun hos hoscl hoscli @@ -31843,6 +34686,7 @@ hosubneg hosubsub hosval hot +hotel hothmname hots hottme @@ -31856,6 +34700,7 @@ hover hoverinfo hovers hovey +hovh how however hox @@ -31891,6 +34736,7 @@ hpgid hpgne hpgtr hph +hphase hphl hphqh hpi @@ -31906,6 +34752,7 @@ hpm hpmap hpmapf hpmapr +hpmhdecidable hpmk hpmn hpmo @@ -31921,6 +34768,7 @@ hpns hpo hpodd hpoint +hpoly hpop hpos hpossrc @@ -32112,6 +34960,7 @@ hset hset_im hset_mj hset_tail +hsetbuffering hsezb hsf hsfin @@ -32136,11 +34985,13 @@ hsinabc hsinf hsing hsint +hsize hsj hsjac hsk hskp hsl +hslice hslzero hsm hsmax @@ -32194,6 +35045,7 @@ hstab hstable hstablef hstar +hstartballot hstcl hstd hstel @@ -32260,6 +35112,8 @@ hsymm hsymmpart hsyz hsz +ht_in_image +ht_le_max hta htail htalem @@ -32270,6 +35124,8 @@ htbi htbjm htc htcard +htchloc +htchlocset htcl htclos htco @@ -32283,6 +35139,8 @@ htends htendsto hteq hteqv +hterm +hterms htf htfae htff @@ -32338,6 +35196,7 @@ http https htu htune +htuple htus htusum htuv @@ -32378,6 +35237,7 @@ huk hul hule hull +hulli hulls hum human @@ -32396,6 +35256,8 @@ hunique hunit huniv hunormal +huntington +huntsands huo huone huopen @@ -32539,6 +35401,7 @@ hvv hvw hvx hvy +hvzk hw_cat hw_diag hw_ih @@ -32696,10 +35559,15 @@ hypb hypcgr hypcgrlem hyper +hyperassertion hyperbolic hypercall +hyperdual +hypere hyperface hyperfilter +hypergraph +hypergraphi hyperlink hypernym hyperoperation @@ -32786,23 +35654,29 @@ i128 iaa iabcd iac +iaction +iactioni iae iaf iagree +iagreement ialls ialt +iam iamhc ian iand ianor iantwerp iapp +iapply iargs iarray iarrays iation iatom iauto +iaxiom iba ibar ibas @@ -32811,6 +35685,7 @@ ibcom ibd ibdc ibdr +ibgni ibi ibib ibibr @@ -32857,9 +35732,16 @@ iblsub iblsubnc iblulm iboi +ibounded ibrcom ibs +ibt +ibut +ibwt +ibwtn icar +icard +icat icc iccbnd icccld @@ -32977,7 +35859,9 @@ ichn ichnfb ichnfim ichnfimlem +ichng ichnreuop +ichoose ichreuopeq icht ichv @@ -32992,6 +35876,7 @@ ico icobrsiga icocncflimc icocycles +icod icodiamlt icodisj icof @@ -33009,8 +35894,11 @@ icondindep icondindepfun icondindepset icondindepsets +iconfig +icong icons iconstr +iconv icoopn icoopnst icopnf @@ -33036,10 +35924,14 @@ icossre icossxr icoub icoun +icount icoval +icp ics +icstate ictqzcwpzzazifsmic ictx +ictxt icu icvvh icycles @@ -33077,10 +35969,12 @@ ide idea ideal idealcomaporderiso +ideald idealfacto idealfactorsequivofquotequiv idealfactorsfunofquothom idealfilter +ideali idealizer ideallattice ideallatticebasis @@ -33111,6 +36005,7 @@ idealto idealx ideas ideateof +ideduct idel idem idemb @@ -33118,10 +36013,16 @@ idemcommsemiring idemfst idemp idempot +idempotence idempotency idempotent +idempotentcommutativemonoid +idempotentfun +idempotentmagma +idempotenton idempotentop idempotents +idempotentsemiring idemsemiring idemsnd iden @@ -33148,10 +36049,13 @@ ideqb ideqg ideqgalt ider +idf idffth idfn idfork idfth +idftor +idftorftor idfu idfucl idfudiag @@ -33171,7 +36075,9 @@ idhmop idi idialt ididg +idijkstra idim +idinfo idinside idinv idinxpres @@ -33236,6 +36142,7 @@ idltrn idlval idm idmatidpmat +idmcl idmgmhm idmhm idmon @@ -33266,6 +36173,7 @@ idp idpm idpn idpr +idpredicates idprodmaphomotopycategorycompinverseiso idqtop idr @@ -33290,6 +36198,7 @@ idrng idrnghm idrval ids +idsok idsr idsrngd idss @@ -33303,16 +36212,20 @@ idsymrel idt idtac idtransformation +idty iducn idunop idv idvr idx +idxd idxfun +idxi idxof idxq idxqnew idxs +idxsame idxtoatom idz idzeroequivisozero @@ -33327,10 +36240,13 @@ iedgvalsnop iedv iee ieee +ief iegf ieii ielefmnd iequiv +ievents +iexec iexpcyc iexpire iexs @@ -33338,8 +36254,11 @@ iexsunique iext if ifa +iface +ifaceany ifactm ifactme +ifail ifalse ifan ifb @@ -33349,6 +36268,7 @@ ifbieq ifboth ifbothda ifc +ifce ifchhv ifcl ifcld @@ -33365,6 +36285,7 @@ ifeqor ifex ifexd ifexg +ifexi iff iffalse iffalsed @@ -33372,13 +36293,16 @@ iffalsei iffalseprop iffd iffd2 +iffi ifflr ifflrn iffofeq iffp iffrl iffrln +iffs iffsetoid +iffuip iffv ifhvhv ifid @@ -33387,6 +36311,7 @@ ififc ifim ifin ifix +ifjump ifkg ifle ifmpt @@ -33397,6 +36322,8 @@ ifnefalse ifnetrue ifnmfalse ifnot +ifnz +ifopt ifor ifov ifp @@ -33440,6 +36367,7 @@ ifpxorxorb ifqy ifr ifred +ifrom ifs ifsb ifsc @@ -33447,33 +36375,59 @@ ifscgr ifsingleton ifssun ift +ifte +ifthenelse iftrue iftrueb iftrued iftruei iftrueorfalse iftrueprop +ifun ifval +ify +ifz +igabscongs +igabscongsstr +igabscongu +igabscongustr +igabsipresigwls +igabsipresigwlsstr +igabsren +igabsrenstr igamcl igamf igamgam igamlgam igamval igamz +igb +igba +igbg +igbgi +igconsipresigwls +igconsipresigwlsstr ige igenidl igenmin igenss igenval iget +igfreshcls +igfreshclsstr +igfreshigabs +igfreshigop +igfreshigopstr igfun ighent igid +ign ignore ignoreargsattr ignorebranch ignored ignorefunction +ignorei ignores ignorestucktc ignoretactickinds @@ -33481,7 +36435,39 @@ ignoretactickindsref ignoretcfailures ignorevariable ignoring +igopipresigwls +igopipresigwlsstr igpath +igsubstabsipresigwlsabs +igsubstabsipresigwlsabsstr +igsubstallipresigwlsall +igsubstallipresigwlsallstr +igsubstcls +igsubstclsstr +igsubstigabs +igsubstigabsstr +igsubstigop +igsubstigopstr +igsubstigvar +igsubstinpipresigwlsinp +igsubstinpipresigwlsinpstr +igsubstipresigwls +igsubstipresigwlsstr +igswapabsipresigwlsabs +igswapabsipresigwlsabsstr +igswapallipresigwlsall +igswapallipresigwlsallstr +igswapbinpipresigwlsbinp +igswapcls +igswapclsstr +igswapigabs +igswapigabsstr +igswapigop +igswapigopstr +igswapinpipresigwlsinp +igswapinpipresigwlsinpstr +igswapipresigwls +igswapipresigwlsstr igu igz ih_prems @@ -33562,8 +36548,10 @@ ihy ihys ihz ihzs +iia iic iicextend +iicf iicfinsetset iicftc iicinfhom @@ -33580,6 +36568,7 @@ iid iidm iidn iif +iiface iifcnv iifcv iifhmeo @@ -33632,6 +36621,7 @@ iinglb iinhoiicc iinhoiicclem iinin +iinit iinllyconn iinon iinopn @@ -33675,11 +36665,16 @@ ijs ikfoexmjexnv ikhoiaetwlvcaniohls ikinnock +ikkbz ikm iknows ikogfcbkxrgrquxvbffomx +ila +ilam ile ilem +ilength +ileq iless ilf ill @@ -33690,6 +36685,8 @@ illustrate illustrating illustration iload +ils +ilsm ilt iltj ilytwxzryrkdxa @@ -33737,9 +36734,11 @@ imafiold imafv imag image +image_mono imagebasicopen imagecomplement imagecomplementincl +imagee imagefactorisation imagefactorisationzero imagefactorization @@ -33765,6 +36764,8 @@ imageofinjon imageonehom imageopop imageopunop +imagep +imagepi imagepreimage imageprodlex images @@ -33794,6 +36795,7 @@ imaindm imainrect imainss imaiun +imam imambfm iman imandra @@ -33866,6 +36868,7 @@ imaundi imaundir imauni imax +imbal imbi imbibi imbitrdi @@ -33903,6 +36906,7 @@ img imi imim imimorb +imin iminvid iminvval imitates @@ -33932,6 +36936,8 @@ imnegd imnegi imnot imo +imod +imodb imor imori imorri @@ -33948,6 +36954,7 @@ impbid impbida impbidd impbii +impce impchain impcom impcombi @@ -33980,7 +36987,10 @@ impimprbi impimpsimp impintro impl +implc impldetail +imple +implem implement implementation implementationdetails @@ -33988,11 +36998,15 @@ implementations implemented implementing implements +impli implic +implicate implicated +implicates implication implicationhyp implications +implici implicit implicitbinder implicitdefeqproofs @@ -34014,6 +37028,8 @@ impliesnot impllib implmaxdepth implode +impls +implt imply implying implyp @@ -34044,12 +37060,14 @@ importtree impose imposes imposing +impossibility impossible impp imppost impproof impr impractical +imprim improper improve improved @@ -34064,8 +37082,10 @@ impto impvd imr imre +ims imsdf imsdval +imsm imsmet imsmetlem imsqrtval @@ -34075,6 +37095,7 @@ imsubd imsval imsxmet imsym +imt imtr imtrdi imtrid @@ -34091,6 +37112,7 @@ inabs inacc inaccessible inaccw +inaction inaex inaff inagflat @@ -34100,14 +37122,17 @@ inagrud inagswap inaprc inar +inarc inass inatom inatsk inawina inawinalem inb +inbetween inbinade inblocks +inbound inbounds inc incat @@ -34139,6 +37164,7 @@ inclleftfullyfaithful incllift incllifttoinitial incllifttoterminal +inclosed inclosure inclright inclrightcompopequivinverse @@ -34196,13 +37222,17 @@ incompute incongp incons inconsistency +inconsistencyautomatic +inconsistencyinteractive inconsistent inconsistentbounds +inconsistentprefix incontext inconvenience incoordinates incorrect incorrectly +incounterm incp incr incre @@ -34216,12 +37246,16 @@ increasing increasingapproximateunit increasingbystep increment +incrementaccountcontracts incremental incrementally incrementing increments +incrindexlist incrn incrst +incs +incseq incsequz incsmf incsmflem @@ -34238,7 +37272,9 @@ indcthing indd inddlem inde +indec indecomposable +indecomposabled indeed indefinite indefinitedescription @@ -34250,6 +37286,8 @@ indentd indented indentexpr indep +independant +independece independenc independence independent @@ -34267,15 +37305,22 @@ indepsetfreeon indepsets indepsetset indeqs +indet indeterminacies +indets +indetsi index index-equality indexa indexat indexcone +indexd indexdom indexed indexedpartition +indexedpreorder +indexedsetoid +indexedunion indexequiv indexequivallroots indexequivofinv @@ -34295,6 +37340,7 @@ indexofhom indexrealunits indexseq indexset +indextovertexlist indf indfsd indfsid @@ -34306,6 +37352,7 @@ indicat indicate indicates indicating +indication indicato indicator indicatorconst @@ -34319,11 +37366,15 @@ indifbi indifcom indifdi indifdir +indiff +indifference +indifferent indifundif indir indirect indirection indirectly +indiscernable indiscld indisconn indiscrete @@ -34336,6 +37387,7 @@ indislem indiso indispconn indistgp +indistinguishable indistop indistopon indistps @@ -34345,6 +37397,7 @@ indisuni individual individually individuals +individualterm indization indlcim indlem @@ -34357,11 +37410,13 @@ indn indne indobjectpresentation indomain +indomd indomisnotundef indomwhenadd indparallelpairpresentation indpi indpreima +indpt indresadjunction indreshomequiv inds @@ -34385,6 +37440,7 @@ inducedaddhom inducedbicategory inducedcategory inducedequiv +inducedequivalence inducedfamily inducedfunctor inducedfunctorcompisoself @@ -34396,10 +37452,13 @@ inducedmeasure inducedorderringhom inducedorderringiso inducedoutermeasure +inducedpreorder +inducedrelation inducedstructure inducedstructureequiv inducedtopology inducedwidecategory +inducees inducehom inducehomle inducehomofle @@ -34437,6 +37496,8 @@ inductivesteprealization inductivesystem inductiveval inductivized +inductl +inductr inductval industrious indv @@ -34472,6 +37533,7 @@ ineqs ineqtransd inequalities inequality +inequalitytr inequalties inequiv inert @@ -34485,6 +37547,7 @@ inex inexactify inexeqex inf +infcard infcl infcllem infclosed @@ -34492,6 +37555,7 @@ infclosure infcntss infconvergenceclass infcvgaux +infdecr infdegree infdesc infdif @@ -34518,6 +37582,7 @@ infercharzeroofring inferdivisionring inferdivisionsemiring inference +inferences inferi inferin inferins @@ -34562,6 +37627,10 @@ infinf infinfg infinite infiniteadelering +infinitedescendingsequence +infinitedescendingsequencefrom +infinitedescent +infinitedescentfrom infinitedimensional infinitedimensionalorder infinitegalois @@ -34584,22 +37653,33 @@ infirred infirredupperset infiso infix +infixagda infixl infixr infl inflate inflationary inflb +inflection infleinf infleinflem infleleft infleright +infliveness +inflow +inflsts +inflstse +inflstsi infltoreq influence +influenced +influences +influential infm infmap infmin infmo +infmodel infmremnf infmrgelbi infmrp @@ -34622,6 +37702,7 @@ infostate infotree infotrees infoval +infplays infpn infpnlem infpr @@ -34649,6 +37730,7 @@ infsdomnn infsep infseq infset +infsetsum infsinfhom infsn infss @@ -34657,9 +37739,12 @@ infssuni infssuzcl infssuzle infsubc +infsubsetall infsum +infsup infsupfacts infsupprpr +inft inftmrel infto inftophom @@ -34737,6 +37822,7 @@ inherently inherit inheritance inherited +inheritedprooftree inherits inhomogeneouschains inhomogeneouschainsiso @@ -34754,22 +37840,30 @@ inindif inindir inintabd inintabss +ininter inintersectimpinintersectunions inintersectimpinunion iniseg inisegn init +initavstore initc initconf initconfig +initd +initdata +initfib +initi initial initialbound initialcolimitcocone initialcomparison +initialdata initialhom initialis initialisation initialisinitial +initialisinitreachable initialiso initialisoisinitial initialisopempty @@ -34779,14 +37873,18 @@ initialized initializelazyentry initializelazyentrywitheta initializelazyentrywithetaaux +initializephase initially initiallysmall initialmodel initialmonoclass initialmul +initialnonuniformcfg initialofcorepresentableby initialofrepresentableby initialopofterminal +initialproc +initials initialseg initialsegiic initialsegiiciicofle @@ -34795,6 +37893,8 @@ initialstate initialstateissecure initialto initialunopofterminal +initk +initlast initlb initlist inito @@ -34808,9 +37908,12 @@ initoo initopropd initopropdlem initopropdlemlem +initoptions initorcl initoval +initq initr +initreachable initresults inits initscore @@ -34820,8 +37923,10 @@ initsize initsm initstails initstate +initstatus inittableau initub +initv inixp inj injarrow @@ -34834,10 +37939,13 @@ inject injecti injectintobaseio injection +injectionordering injections +injectionsuniverse injective injectiveb injectivedimension +injectively injectivep injectivepn injectivepresentation @@ -34858,6 +37966,8 @@ injfuncsetfuncin injfuncsetfuncinj injg injgauche +injh +inji injindex injl injle @@ -34879,6 +37989,8 @@ injsubmefmnd injthmname injuring injust +injval +ink inl inlalghom inlclm @@ -34920,8 +38032,10 @@ inner innercontent innercontinuous innerdual +innere innerfiveseg innerfullyfaithful +innerlex innermost innerp innerprobchar @@ -34938,26 +38052,42 @@ innersl innerslflip innodel innoder +innot +inoclosed +inon inopab inopn inopnd inorder +inorm inot inp inpart inpb inpbleaf +inplane +inplus inpolyset +inport +inports inpowerset inpr inpreima +inprod +inpt input +inputalpha inputalphabet +inputchain +inputchaininject inputhandler +inputlength +inputlengthproc inputlock inputs inputstagged inputstring +inputsupportderivative inputunlock inpw inr @@ -34975,6 +38105,7 @@ inrcompinverseassociator inrcompsum inregion inres +inrest inrhom inright inrlatticehom @@ -34989,12 +38120,17 @@ inrₗ ins inscribed inscrit +insec inseg +insensitive insep inseparable +inseparabled +inseparablei inseparablesetoid insepdegree inser +insersimp insert insertafterlevels insertandeject @@ -35026,19 +38162,26 @@ insertpiprod insertpiprodequiv insertrec inserts +insertsimp inserttop inserttrailingids inserttranslation inserttranslationaux insertwith inset +insetofcomponents +insetofcomponentslimit +insi insid inside insidepart +insideregularcone insiga insight insist inskip +insort +insorttree inspan inspect inspection @@ -35082,10 +38225,12 @@ installed instan instanc instance +instancef instanceproblem instances instancetypefilter instancewithrelationtofn +instant instanti instantiate instantiated @@ -35106,6 +38251,7 @@ instantiation instantiations instantly instapplicativecomp +instar instarchimedean instassociativemax instassociativemin @@ -35592,6 +38738,7 @@ instr instrankoneadiccompletion instratcast instrclike +instrd instreduced instrefl instregularspace @@ -35599,6 +38746,8 @@ instrelcwcomplex instrepr instring instrootcomptriple +instrs +instrsi instruction instructions instrument @@ -35747,6 +38896,7 @@ intabssd intact intadicabv intadicabvdef +intagrk intalgebramap intangentcoordinates intantiate @@ -35856,8 +39006,11 @@ interactive interactivecode interactiveunfold interacts +interative interc intercalate +intercept +interchangable interchange interchangeable interchangeably @@ -35870,15 +39023,26 @@ interesting interestingly interface interfaces +interfacet +interference +interferencewithfwb interferes +interfereswith +interfering +interfree interfst interior interiorpoint interiors +interleavable interleave interleaved +interleaves +interleaving +interleavings interlift interlude +interm intermed intermedi intermediate @@ -35899,18 +39063,26 @@ internallyprojective internalname internalrel internals +interofvar +interofvars interoperability interp +interpd interpolate interpolation +interpr interpret interpretation interpreted interpreter interpreting +interpretlow interpstrip +interq interrelate interrupt +interrupted +interruptible inters intersec intersect @@ -35924,6 +39096,8 @@ intersectionii intersectionof intersectionoflocallydirected intersections +intersectionswith +intersectionwith intersects intersnd intersperse @@ -35942,10 +39116,12 @@ intervalcasessubgoal intervaledge intervalfilters intervalgapswithin +intervali intervalinteg intervalintegrab intervalintegrable intervalintegral +intervall intervals intervention intervs @@ -35953,6 +39129,8 @@ intex intexab intexrab intf +intff +intfi intfib intfloor intfrac @@ -35961,9 +39139,12 @@ intfract intfractpair intg intgcd +intgi intgover intgring intgru +intgt +intgv inth inti intidg @@ -35974,6 +39155,7 @@ intimafv intimag intimasn intimass +intimes intirr intisscalartower intlewftc @@ -35982,6 +39164,7 @@ intlike intlinear intlist intlit +intmapk intmaps intmethods intmin @@ -36008,6 +39191,8 @@ intopsn intopval intp intpercasconstesssub +intpf +intpi intpow intpr intpreima @@ -36056,6 +39241,7 @@ intruderspeed ints intsal intsaluni +intsfrom intsmulwithzero intsn intsng @@ -36063,6 +39249,9 @@ intspanequivquotaddorderof intss intssuni intsubmodule +intt +inttf +intti inttoexpr inttrace inttraceaux @@ -36092,31 +39281,86 @@ inunissunidif inutile inv inva +invab invaccumulate invact invalid +invalidate +invalidi +invam invapp invar +invari invariance invariant invariant-preservation invariantbasisnumber invariantcardinalrank +invariantcfalse +invariantclcharacterization +invariantclcurrentlevel +invariantcllcharacterizationafterapplylearn +invariantconflictclausecharacterization +invariantconflictclausecharacterizationafterapplylearn +invariantconflictclausecharacterizationafterassertliteral +invariantconflictclausecharacterizationafternotifywatches +invariantconflictflagcharacterization +invariantconflictflagcharacterizationafterapplylearn +invariantconflictflagcharacterizationafterassertliteral +invariantconsistent +invariantconsistentafterapplybackjump +invariantd +invariantequivalentzl +invariantequivalentzlafterapplylearn invariantextension invariantform +invariantgetreasonisreason +invariantgetreasonisreasonafterapplylearn +invariantgetreasonisreasonafternotifywatches +invariantgetreasonisreasonqsubset +invarianti +invariantnodecisionswhenconflictensurescurrentlevelcl +invariantnodecisionswhenconflictnorunitafterapplylearn +invariantqcharacterization +invariantqcharacterizationafterapplylearn +invariantqcharacterizationafterassertliteral +invariantqcharacterizationafterassertliteralnotinq invariants invariantsadjunction +invariantsclafterapplyconflict +invariantsclafterapplyexplain +invariantsclafterexplainuip invariantsequivfdrephom invariantsequivintertwiningmap invariantsequivrephom invariantsfunctor +invariantsnodecisionswhenconflictnorunitafterassertliteral invariantsubfields +invariantuniq +invariantuniqafterapplybackjump +invariantuniqq +invariantuniqqafterapplylearn +invariantuniqqafterassertliteral +invariantvarsfafterapplylearn +invariantvarsqafterassertliteral +invariantwatchcharacterization +invariantwatchcharacterizationafterassertliteral +invariantwatchcharacterizationinbackjumpprefix +invariantwatchesel +invariantwatchlistscharacterization +invariantwatchlistscontainonlyclausesfromf +invariantwatchlistsuniq +invarm +invarnt +invas invasive invaux +invbk invc invco invcoisoid invcs +invd invdft invdif invdisj @@ -36131,6 +39375,7 @@ inveqinv invequiv invequivalence inver +invers inverse inverseassociator inverseaux @@ -36167,7 +39412,9 @@ invertible invertibleaddmulmul invertiblealgebracoenat invertiblealgebramapequiv +invertibled invertiblediv +invertiblee invertibleequiv invertibleequivdetinvertible invertibleequivfromblocks @@ -36176,7 +39423,9 @@ invertibleequivofleftinverse invertibleexp invertibleexpofmemball invertiblefstofinvertible +invertiblei invertiblelowerinv +invertiblemagma invertiblemul invertibleneg invertibleofcharpnotdvd @@ -36213,6 +39462,7 @@ invertibletoblock invertibletomatrix invertibletranspose invertibletwo +invertibleunitalmagma inverting inverts investigate @@ -36223,6 +39473,7 @@ invfm invfn invfuc invfun +invfunc invfunctor invfunidassoc invfunon @@ -36231,25 +39482,30 @@ invg invgamma invghm invginvrid +invh invi invid invimage invinside invinterpstrip invinv +invisible inviso invisoinvl invisoinvr invj invjacobianofhascoeffs invk +invkey invl +invlevel invlhom invlimequiv invlmhm invlt invm invme +invmeas invmemclass invmk invmonoidhom @@ -36267,6 +39523,7 @@ invofunit invoke invoked invokes +invokestatic invoking invol involute @@ -36295,6 +39552,7 @@ invpair invprop invpropd invpropdlem +invpst invqparam invr invrcl @@ -36321,11 +39579,13 @@ invsubmonoid invsym invt invterm +invtranslateval invtrootsubmodule invtsubmodule invtsubmoduletolieideal invunitssub invunitsub +invv invveblen invx invz @@ -36341,7 +39601,9 @@ inxpssidinxp inxpssres inxpxrn inz +ioa iobj +iobs ioc iocborel iocbrsiga @@ -36363,6 +39625,7 @@ iocnei iocnrect iocopn iocopnst +iocorres iocpnfordt iocprodioc iocress @@ -36446,6 +39709,7 @@ iooval ioovolcl ioovonmbl iop +ioprog ior ioran iordsmo @@ -36479,12 +39743,14 @@ ipad ipass ipassi ipasslem +ipassmt ipassr ipath ipattern ipblnfi ipc ipcau +ipcidr ipcj ipcl ipcn @@ -36507,6 +39773,7 @@ ipid ipidsq ipiiie ipipcj +ipl iple ipndx ipndxnbasendx @@ -36528,13 +39795,18 @@ ipolt ipolub ipolubdm ipolublem +ipoly ipopos iporthcom ipostr ipotset ipoval +ippart +ippartition ipr +iprange iprc +ipred iprod iprodcl iprodclim @@ -36547,8 +39819,11 @@ iprodn iprodrecl iprop iprotocol +ips ipsaddg ipsbase +ipset +ipsets ipsip ipsmulr ipssca @@ -36556,10 +39831,18 @@ ipsstr ipsubdi ipsubdir ipsvsca +ipt +iptables +ipurge +ipv ipval ipz iqn +ira +ireadert irec +irel +ires iresn iresolutionobj iri @@ -36573,6 +39856,7 @@ irngval iro ironkv ironsht +irop irq irr irra @@ -36597,6 +39881,7 @@ irrednegb irrednu irrednzr irredrmul +irreduccible irreducible irreduciblecloseds irreduciblecomponent @@ -36605,16 +39890,23 @@ irreduciblecomponentopen irreduciblecomponents irreduciblecomponentsequiv irreduciblecomponentsequivofispreirreduciblefiber +irreducibled irreduciblesetequivpoints irreduciblespac irreduciblespace +irref irrefl +irrefld irreflexive irreflexiveproperty irreflexivite irreflexivity +irrefli +irreflp irreflviaequiv irrefutable +irregular +irregularamicpair irrel irrelevance irrelevant @@ -36627,6 +39919,7 @@ irrlem irrmul iru irule +irules is_dimensionless is_empty is_err @@ -36645,6 +39938,7 @@ is_well_formed_inner isa isabelian isabeliangalois +isabeliangroup isabelle isabl isabld @@ -36702,6 +39996,8 @@ isalgclosed isalgclosure isalgeb isalgebraic +isalglattice +isalgsemilattice isall isallowedcharacter isalmostintegral @@ -36715,6 +40011,8 @@ isanmbfm isanonymous isantichain isantiquots +isapartness +isapartnessrelation isapp isappof isappofarity @@ -36728,7 +40026,9 @@ isarchiofld isarep isarithfrobat isarithmetic +isarrlenloc isarrow +isarrv isart isartin isartinian @@ -36758,7 +40058,9 @@ isatom isatomic isatomistic isatomorderivable +isaugmentingpath isausgr +isaut isauxdecl isauxrecursor isazumaya @@ -36767,8 +40069,10 @@ isba isbad isbadseq isbalanced +isband isbase isbasechange +isbaseclass isbasis isbasisg isbasisrelowl @@ -36814,6 +40118,10 @@ isbnd isbndx isbo isbool +isbooleanalgebra +isbooleanring +isbooleansemiring +isboolv isbot isbou isbound @@ -36826,7 +40134,9 @@ isboundedbilinear isboundedbilinearmap isboundeddefa isboundeddefault +isboundedjoinsemilattice isboundedlinearmap +isboundedmeetsemilattice isboundedsmul isboundedsmulseminormedaddcommgrouptopi isboundedsmulseminormedaddcommgrouptoprod @@ -36836,6 +40146,7 @@ isboundedwrt isbrauerequivalent isbridge isbvar +isbytev isc isca iscanceladd @@ -37145,6 +40456,11 @@ iscommjordan iscommmonobj iscommring iscommutative +iscommutativemonoid +iscommutativering +iscommutativesemigroup +iscommutativesemiring +iscommutativesemiringwithoutone iscomonhom iscomp iscompa @@ -37176,6 +40492,7 @@ iscompletespace iscomplex iscomplprojection iscompressed +iscomv isconcretele iscondkernel iscondkernelcdf @@ -37199,6 +40516,7 @@ isconstantfun isconstof isconstr isconstructible +iscont iscontained iscontdiffcompatible iscontextfree @@ -37221,6 +40539,7 @@ iscornerfree iscoseparating iscoseparator iscoskeletal +iscospan iscospl iscosplitpair iscountable @@ -37274,13 +40593,18 @@ iscygd iscyggen iscygodd isd +isdag isdagmatrix isde +isdecequivalence isdecidablevariant isdecidenative isdecltounfold isdecompon isdecompositionfield +isdecpartialorder +isdecstrictpartialorder +isdectotalorder isdedekind isdedekinddomain isdedekinddomaininv @@ -37299,6 +40623,7 @@ isdenseat isdenseembedding isdenseind isdenseinducing +isdenselinearorder isdensesubsite isdeprecated isdershowitzmannalt @@ -37306,6 +40631,7 @@ isdescendingcentralseries isdetecting isdetector isdiag +isdiagonal isdiamet isdiameter isdigit @@ -37317,6 +40643,7 @@ isdirectedorder isdiscrete isdiscretevaluationring isdistinguishedat +isdistributivelattice isdite isdivrngo isdivsequence @@ -37340,6 +40667,7 @@ isdual isdyncoverof isdynnetin ise +isecure isedgeconnected isedgereachable iseffective @@ -37364,6 +40692,7 @@ isemptynonempty isemptyringequi isemptyringequiv isengelian +isenumeration isepi iseq iseqlg @@ -37371,6 +40700,7 @@ iseqlgd iseqsetv iseqsetvlem isequ +isequality isequalizer isequalizercompmono isequi @@ -37436,11 +40766,13 @@ isexttangentat isf isfactorof isfailedtosynthesize +isfailure isfaithful isfalse isfbas isfcf isfcls +isfderiv isffth isfg isfi @@ -37517,6 +40849,7 @@ isfraisse isfraisselimit isfreegroup isfreegroupoid +isfresh isfrgr isfsupp isfsuppd @@ -37544,6 +40877,7 @@ isgaloisgroup isgaloistower isgaussian isgaussianprocess +isgb isgbe isgbo isgbow @@ -37575,7 +40909,10 @@ isgrim isgrlim isgrothendieckabelian isgroup +isgrouphomomorphism +isgroupisomorphism isgrouplikeelem +isgroupmonomorphism isgroupoid isgrp isgrpd @@ -37605,6 +40942,9 @@ ishenstock ishereditarilylindelof ishermitian ishexdigit +isheytingcommutativering +isheytingfield +ishift ishil ishilbertsum ishilbertsumorthogonal @@ -37624,6 +40964,7 @@ ishomogeneousidealdefs ishomogeneoussubsemiringdefs ishomogenous ishomological +ishomomorphism ishpg ishst ishtpy @@ -37638,11 +40979,13 @@ isidempo isidempot isidempoten isidempotent +isidempotentcommutativemonoid isidempotentcomplete isidempotentelem isidempotentelemequiv isidempotentelemequivclopens isidempotentelemmulzeroaddone +isidempotentsemiring isidendescape isident isidenticalsidesstr @@ -37650,6 +40993,8 @@ isidentityfun isidl isidlc isidom +isidx +isifs isignoretactickind isim isimage @@ -37660,6 +41005,7 @@ isimmersionofcomplement isimplementationdetail isimportedconst isimportsonlyfile +isin isinaccessible isinaccessibleusername isinag @@ -37667,6 +41013,9 @@ isinagd isincreasingapproximateunit isindcontained isindepset +isindexeddecequivalence +isindexedequivalence +isindexedpreorder isindobject isinduced isinducing @@ -37699,6 +41048,7 @@ isinitialzero isinito isinitoi isinitseg +isinj isinjective isinmathlib isinsimpset @@ -37728,6 +41078,8 @@ isinternallyprojective isintersectingof isintertwining isintertwiningmap +isintgv +isinto isinttangent isinttangentat isinv @@ -37767,6 +41119,7 @@ isisubgr isite isitsucc isjacobsonring +isjoinsemilattice isjointlysurjectivepreserving isjordan iskan @@ -37781,16 +41134,19 @@ iskernelsndkernelfork iskgen iskilling iskinjective +iskleenealgebra iskleinfour iskolmogorovprocess iskpair iskprojective iskrasner isl +islam islambda islan islanguage islasker +islastassertedliteralsubset islat islatercommand islattice @@ -37970,6 +41326,7 @@ islimittoover islimittounder islimitwedge islimitwhiskerequiv +islimpt islindelof islindeof islindeps @@ -38110,6 +41467,10 @@ islub islvec islvol ism +ismagma +ismagmahomomorphism +ismagmaisomorphism +ismagmamonomorphism ismanifold ismarkov ismarkovkernel @@ -38122,6 +41483,7 @@ ismaxcha ismaxchain ismaxcomp ismaxfilter +ismaxflow ismaxi ismaxidl ismaximal @@ -38145,6 +41507,7 @@ ismeasura ismeasurableratcdf ismeasurablygenerated ismeet +ismeetsemilattice ismeetu ismet ismeta @@ -38171,6 +41534,7 @@ isminbadseq ismincomp isminfilter isminimal +isminimalbackjumplevelgetbackjumplevel isminimalfor isminimalprimarydecomposition isminon @@ -38207,11 +41571,17 @@ ismon ismonhom ismonicofdegree ismono +ismonoid ismonoidal ismonoidalclosed ismonoidaldistrib ismonoidalleftdistrib ismonoidalrightdistrib +ismonoidhomomorphism +ismonoidisomorphism +ismonoidmonomorphism +ismonoidmorphism +ismonomorphism ismoore ismoored ismooredr @@ -38273,12 +41643,16 @@ isnaturalsmul isnclique isncvsngp isncvsngpd +isnearsemiring +isnearsemiringhomomorphism +isnearsemiringmonomorphism isneginvariant isnegnat isnegnnrat isnei isneip isnested +isnewarr isneweq isnewvar isnghm @@ -38301,6 +41675,7 @@ isnnrealprop isnnrealtoreal isno isnoconfusion +isnode isnoetheri isnoetherian isnoetherianobject @@ -38322,14 +41697,24 @@ isnormalclosure isnormalepicategory isnormalmonocategory isnotation +isnotdsource +isnotdsourcelevel +isnotdsourcex isnotg +isnotsource +isnotsourcelevel +isnotsourcex +isnow isnowheredense +isnpoly +isnpolyh isnrg isnrm isnsg isnsgrp isnsqf isnull +isnullv isnum isnumbasabl isnumbasgrp @@ -38353,6 +41738,7 @@ isobinarycofanmk isobinaryfanmk isobiproductembedding isobiprodzero +isobjv isobot isobs isobtainwithoutproof @@ -38428,6 +41814,7 @@ isogp isogrp isohom isohomology +isoi isoid isoimage isoindexconelift @@ -38442,6 +41829,7 @@ isoisterminal isok isoka isokernel +isol isolat isolate isolated @@ -38472,6 +41860,7 @@ isometriccontinuousfunctionalcalculus isometries isometry isometryclass +isometryd isometryequiv isometryequivbasisrepr isometryequivboundedofcompact @@ -38596,8 +41985,14 @@ isorderedring isorderedsmul isorderedsubsetof isorderedvadd +isorderhomomorphism isordering +isorderisomorphism +isordermonomorphism isorderrightadjoint +isordertheoreticjoinsemilattice +isordertheoreticlattice +isordertheoreticmeetsemilattice isordertop isordinal isorel @@ -38608,6 +42003,7 @@ isorightderivedobj isorightderivedtohomotopycategoryobj isorng isort +isortedlist isortho isorthogonal isos @@ -38635,7 +42031,9 @@ isotargetofself isoterminal isotolinearequiv isotone +isotonic isotop +isotopic isotoplus isotosubgraph isotr @@ -38679,8 +42077,10 @@ ispath ispathconnected ispathgraph ispautn +ispc ispcmp ispconn +ispec ispell isperf isperfect @@ -38775,6 +42175,7 @@ isprefixofandnotnumber ispreimmersion ispreirre ispreirreducible +ispremetric isprenex ispreorder ispreprimitive @@ -38825,11 +42226,16 @@ isprojectivemeasurefamily isproof isprop isproper +isproperinx +isproperinxy +isproperinxyz isproperlinearset ispropermap ispropers ispropersemilinearset +ispropositional isprotected +isprotometric isprrngo isprs isprsd @@ -38868,8 +42274,11 @@ isquantale isquasi isquasiaffine isquasicoherent +isquasigroup isquasipreprimitive isquasiregular +isquasiring +isquasisemimetric isquasiseparated isquoti isquotient @@ -38897,9 +42306,12 @@ isre isreal isrealclosed isrec +isreceiverof isrecord +isrecvmarker isred isreduced +isreduction isref isrefl isrefle @@ -38907,6 +42319,7 @@ isreflection isreflective isreflexive isreflexivepair +isrefv isreg isregular isregularatinfty @@ -38915,10 +42328,15 @@ isregularepicategory isregularmono isregularmonocategory isregularofdegree +isrelatedto isrelational +isrelhomomorphism isreliff +isrelisomorphism isrellowerset +isrelmonomorphism isrelprime +isrelto isrelupperset isrepresenta isrepresentable @@ -38926,11 +42344,15 @@ isrepresentation isrepresentationcore isrepresentedby isreproducing +isres isreservedname +isresponse isrestricted isrestriction isretrocompact +isrev isreversible +isrevnth isrfl isrgr isrhm @@ -38961,7 +42383,9 @@ isrim isring isringd isringfiltration +isringhomomorphism isringid +isringmonomorphism isringrng isrisc isriscg @@ -38998,6 +42422,8 @@ issal issald issalgend issalnnd +issame +issameintersection issatisfiable issc issca @@ -39011,17 +42437,30 @@ issconn isscott isscotthausdorff issdrg +issec +isseco issect issection +issecv isselectedleft isselectedright +isselectivemagma isself isselfadjoint issemiconjugacy +issemigroup +issemigroupmorphism +issemilattice issemilatticeinf issemilinearset +issemimetric issemiprimaryring issemireal +issemiring +issemiringhomomorphism +issemiringmonomorphism +issemiringwithoutannihilatingzero +issemiringwithoutone issemisimple issemisimplemod issemisimplemodule @@ -39086,7 +42525,9 @@ issheafpreserveslimitpairwiseintersections issheafprofinite issheafstonean issheafuniquegluing +isshortestpath isshortnf +isshortv issibf issifted issiftedorempty @@ -39105,6 +42546,7 @@ issimplegroup issimplemodule issimpleorde issimpleorder +issimplepath issimplering issimplicial issimplyconnected @@ -39139,6 +42581,7 @@ issmoothat issmoothembedding issmulregular issn +issnapshot isso issod issoi @@ -39153,6 +42596,7 @@ issorryax issort issource isspanning +isspath isspec isspecial isspectralmap @@ -39217,9 +42661,13 @@ isstar isstarnormal isstarprojection isstarwitharg +isstate +isstaticloc +isstop isstopping isstoppingtime isstric +isstrict isstrictlyge isstrictlyle isstrictlyposi @@ -39233,11 +42681,13 @@ isstrictorder isstrictorderconnected isstrictorderedmodule isstrictorderedring +isstrictpartialorder isstrictrestriction isstrictsegal isstricttotalorder isstrictw isstrictweakorder +isstring isstrlit isstrongantichain isstronggenerator @@ -39284,8 +42734,10 @@ issubterminal issubwalk issucc issuccarchimedean +issuccess issucclimit issucclimitrecon +issuccord issuccpr issuccprelimit issuccprelimitrecon @@ -39316,6 +42768,10 @@ istackind istactic istangent istangentat +istate +istateo +istatet +istatev istdrg istendo istendod @@ -39387,11 +42843,14 @@ istorsionelem istorsionfree istorsionquot istos +istotalfunction istotallycomplex istotallydisconnected istotallyreal istotallyseparated istotallyunimodular +istotalorder +istotalpreorder istotbnd istps istpsi @@ -39411,6 +42870,7 @@ istriangulatedclosed istrivial istrivialblock istrivialon +istrivialphi istrivialrelation istrivialtype istrkg @@ -39436,6 +42896,7 @@ istype istypecorrect isu isub +isubexpr isubgr isubgredg isubgredgss @@ -39457,8 +42918,10 @@ isufil isufl isuhgr isuhgrop +isuipapplyexplainuip isultra isultrahomogeneous +isultrametric isultrametricdist isultrauniformity isum @@ -39496,6 +42959,8 @@ isuniformofempty isuniquelycodimoneface isunit isunital +isunitclause +isunitclauseappendvaluation isunits isunitsmul isunitsubmonoid @@ -39567,6 +43032,7 @@ isweaklyeisensteinat isweaklyreg isweaklyregu isweaklyregular +isweakpushout isweakuppermodularlattice isweier isweierstrassdivision @@ -39600,6 +43066,7 @@ iswwlksnx isxmet isxmetd isxms +isyes isza iszari iszariskil @@ -39633,6 +43100,7 @@ itcovalt itd ite iteapp +itei iteinduction item items @@ -39696,8 +43164,10 @@ iterationfunctorobjsucciso iterationobjrightiso iterationobjsucciso iterations +iterative iterator itercomp +iteri iters itertosum itg @@ -39763,10 +43233,14 @@ itgvallem itgvol itgz ith +ithe +ithi +itill itions itleaf itlist ito +itop itp itr itrere @@ -39841,6 +43315,7 @@ iunionlift iunionnotconvergentseq iunionupto iuniq +iuniversal iunlub iunmapdisj iunmapsn @@ -39897,6 +43372,9 @@ iuw iuy ival ivalid +ivl +ivls +ivp ivt ivth ivthalt @@ -39911,7 +43389,13 @@ ivz iwas iwasawa iwasawastructure +iwf +iwlsfsb +iwlsfsbswtr +iwlsfsw +iwlsfswstr iwrdsplit +iwritert iwrzbb iwu iwv @@ -39980,6 +43464,7 @@ jacobisymnat jacobitheta jacobson jacobsonspace +jaction jad jahr jalfon @@ -40007,6 +43492,7 @@ jarrii jarrsc jath javascript +javatype jca jcab jcad @@ -40037,6 +43523,7 @@ jeremy jet jetjpdpvlxitiknnzhq jewell +jewett jfr jgdez jhala @@ -40052,6 +43539,11 @@ jjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjj jjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjj jjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjj jjprop +jkbpc +jkbpcn +jkbpcs +jkbpcst +jkbpsec jkqbymxesfkm jkqp jlemoldn @@ -40059,7 +43551,10 @@ jlpnlopnmgljvf jlt jmachinesem jmeq +jmp +jmpl jmybsjzo +jnf jniwyqs jnk jnv @@ -40077,6 +43572,7 @@ joinc joincl joincom joincomalt +joind joindef joindm joindmss @@ -40085,8 +43581,10 @@ joinedin joineu joinfval joinh +joini joining joiniooico +joinl joinle joinlem joinlmuladdmuld @@ -40094,7 +43592,9 @@ joinlmuladdmuli joinlmulsubmuld joinlmulsubmuli joinm +joinpaths joins +joinsemilattice joinsep joint jointembedding @@ -40109,6 +43609,7 @@ jointlysurjective jointlysurjectiveprecoverage jointlysurjectivepretopology jointlysurjectivetopology +joints joinval joldn jon @@ -40137,11 +43638,13 @@ jrkwku jrnksue json json-rpc +jss jstate jsx jth jtledkxqphtmgxng jtr +judge judgement judgmental jug @@ -40155,9 +43658,11 @@ jules julinkedlistcreateremoveall july jump +jumpfree jumpncnp jumps jun +juncts jung junk just @@ -40165,6 +43670,19 @@ justifies justify juxtaposing jvd +jview +jviewinit +jvm +jvmbig +jvmcfg +jvmd +jvmendset +jvmexec +jvminstr +jvmnaivecollectionsemantics +jvmprog +jvmsmall +jvmstep jwmabatogatuddzyjizxxlfieseugxipwafincdplloxkrqypxxukmigdpkbnlntscmteltyhkb jwmluidsqrfokamarlhoozvrbkxgeynkyppijwvfododpmsbcbaxuadezqnfnmhebvzmwnnqxri jxadijaenzzhyoskfhkdhysq @@ -40179,6 +43697,8 @@ kaba kabstract kabstractistypecorrect kabstractpositions +kad +kadane kaehlerd kaehlerdif kaehlerdiff @@ -40205,30 +43725,42 @@ karoubifunctorcategoryembedding karoubihomologicalcomplexequivalence karoubikaroubi karoubiuniversal +karp kasfmilooetdydhpbzhuwl kashiwara +kat katagoriaverifier kathzorottmuuwhpwuqkbqbdrtvcggpgwrkqdbwwdrfbwhsmqxcmjioukj katona +kauff +kauffman kaufmann kawaguchi +kaxiom kbar kbass kbfdompwygahinfrih kbfval kbimka kbmul +kbo kbop kbpj kbval kcall +kcdptr +kck +kckckck kclosed kcnktkm +kcomp kconn kdbe kdecidableeq +kdelta kdf kdiff +kdt kdtl keccak keccakf @@ -40239,6 +43771,7 @@ keepterm keepusing keg kelac +kelly kelvin kencode kept @@ -40313,6 +43846,7 @@ kerparam kerproj kerrepr kersquarelift +kert kertensorproductmapidtoalghomequiv kertotal kertotensor @@ -40330,6 +43864,7 @@ keyedconfig keyedqualifier keyexpansion keygen +keyi keylem keypred keys @@ -40362,11 +43897,14 @@ kgenval kgophqhkhjnztfkzjyhqcwyndswpzhnurglrn kgrtriex kgrtriexlem +khl kho khop khoyjd kic +kid kiel +kildall kill killcompl killcomplfun @@ -40384,6 +43922,7 @@ kinds kinetics kinsert kinv +kir kirchberger kirszbraun kiztypubacahqvtmevgsvlhm @@ -40401,6 +43940,7 @@ kleenealgebra kleinfour kleisli kleislicat +kleislistar kleitman klem klenne @@ -40409,15 +43949,24 @@ kli klift klkjpkxjdqq kmax +kmemptr kmill +kmin +kml kmlem +kmp +kmtod knapsack knaster knatar knave +knd kne +kneser knew knight +knights +kno knock knoppcld knoppcn @@ -40437,10 +43986,13 @@ knowledgeofacause knowledgeofeffect known knownkinds +knownnature knownproof knowntobefinsetnots knowntobefinsetnotset +knowpq knows +knowspq knuth koenig koenigslemma @@ -40449,6 +44001,8 @@ kolmogorovcondition kolosseum kolwgydim konig +konigdown +konigdtree konigsafe konigsberg konigsbergiedg @@ -40460,6 +44014,7 @@ konigsbergumgr konigsbergvtx konigth konigthlem +kozen kpair kpairiskpair kpairp @@ -40468,6 +44023,7 @@ kpakknkhdaiorm kpi kpirdanvmsvthrbe kpos +kpower kprop kpybwnjoghqcwhakpwbxteudnjbfd kqcld @@ -40503,6 +44059,7 @@ krippen krippenlem kritkkngytcfwvuqk krl +kron kronecker kroneckeralgequiv kroneckerbilinear @@ -40528,6 +44085,7 @@ krun kruskal kruv ksafe +ksc kseq ksl ksn @@ -40539,17 +44097,24 @@ kst kstar kstate kstep +kstoptr ksucc ksum +ksup ktcs ktcua +kth +kts kubo kudryashov +kummer kunion kur +kuratowski kuratowskiembedding kurzweil kusubmtooompwik +kvalue kvaobrojjnrqz kvimpl kvmap @@ -40560,8 +44125,10 @@ kvsa kvspec kxs kxy +kyber lab label +labelatin labele labeled labeledparams @@ -40570,21 +44137,26 @@ labeledstepfailure labeledstepordereddynamicfailure labeledsteporderedfailure labelgraph +labeling labelled labelledcopycount labelledstar labelledstars labelling +labelposs labels laborious labproof labs +lac laced lacimi lack lacks lacomp +lact lactghmga +lactive lactlmhm ladd ladder @@ -40595,6 +44167,9 @@ lagrangebarycentric lagsubg lake lakefile +lalign +laligned +lalternate lam lambda lambda-calculus @@ -40612,13 +44187,17 @@ lambdatheoremsext lambdatheoremtype lambert lamberte +lamda lame lameq +lamlemmas lamm lamp +lamparens lamport lamprop lams +lamsubst lan lanadjunction lanbasechange @@ -40629,6 +44208,7 @@ lancompisowhisker lancondensedset land landarea +landau landesc lands landvehicle @@ -40638,8 +44218,11 @@ lanfn lanfval lang langage +langi langlands langle +langpow +langs language languageequivequivringequiv languages @@ -40656,6 +44239,7 @@ lanliftunit lanlightcondset lann lanna +lannot lanpresheaf lanpresheafext lanpresheafiso @@ -40667,14 +44251,21 @@ lanunit lanup lanval laorjknalecr +lap lapadula laplace +laplaced +laplacei laplacian laplacianclm laplacianwithin lapmatrix +lapp lappend +lappfin lapply +lapprox +lappt large largea largecategory @@ -40689,21 +44280,31 @@ largeschroderseries largeschroderseriesseries largest laser +lass +lasso +lassocr last last_append lastapplied +lastbits lastblock +lastblockinvariant lastcases lastcomponentasstring lastdart lastdeclm +laste lastfun lastfunctor lastfv lastidx lastislargest +lastn +lastnode lasts +lastss laststep +lastt lasymm lat latabs @@ -40724,7 +44325,13 @@ latency latency-cost later latercommand +laterprocessdecidessamevalue latest +latestact +latestactex +latestactless +latestactnxt +latestactnxtact latestthread latexmath latin @@ -40817,6 +44424,8 @@ lavrentiev law lawcos lawcoslem +lawd +lawe lawful lawfulalternative lawfulapplicative @@ -40844,6 +44453,7 @@ lawfulordersup lawfulsingleton lawfultraversable lawfultraversablederivehandler +lawi laws lawson lawsonbasis @@ -40865,9 +44475,12 @@ layercake layercakeintegral layercakelt layered +layers layout layoutkind layoutlib +laz +lazard lazarus lazily lazy @@ -40875,27 +44488,35 @@ lazydiscrtree lazyentry lazym lba +lbasicrule lbasis lbcases lbcl +lbe +lbex lbfzo +lbi lbicc lbico lbill lbinf lbinfcl lbinfle +lbint lbioc lbioo lbl lble lblockz +lbls lbob lborel lbot lbound +lboundmin lbounds lbp +lbrace lbrak lbrakk lbrb @@ -40920,12 +44541,14 @@ lbspropd lbspss lbssp lbsss +lbutlast lbzbi lcade lcancel lcardinalityfn lcd lcdfval +lcdh lcdlkreq lcdlkreqn lcdlmod @@ -40953,19 +44576,25 @@ lcdvsub lcdvsubval lcdvsval lce +lceil lcf lcfl lcfls lcfr lcfrlem lcfrvalsnn +lcg +lchild lchris +lci lcl lclause +lcliff lclkr lclkrlem lclkrs lclkrslem +lclss lcm lcmabs lcmass @@ -41006,32 +44635,55 @@ lcmledvds lcmn lcmneg lcmval +lcn lco lcoc lcoeff lcoefun lcoel lcof +lcol lcomapdomain lcomf lcomfsupp lcomm lcomp lcompact +lcompare lcomplement +lcompletedfrom lconc +lconcat +lcond lconf lconfl +lconfluent lcongr +lconjaction +lconjby +lconjseq lcons +lconsd +lconse +lconsnlist +lconst +lconsts +lconv lcoop lcorina lcorrect +lcoset +lcosetrel +lcosi lcosn lcoss lcosslsp +lcount +lcounts lcoval +lcp lcproof +lcrec lcrow lcs lcts @@ -41049,7 +44701,11 @@ lcvnbtwn lcvntr lcvp lcvpss +lda +ldcfg +ldd ldecl +ldeep ldep ldepslinc ldepsnlinc @@ -41058,6 +44714,7 @@ ldepsnzr ldepspr ldepsprlem lder +lderiv ldg ldgdomn ldgenpisys @@ -41071,16 +44728,24 @@ ldilfset ldillaut ldilset ldilval +ldistinct +ldistr ldistrib ldiv ldl ldlem ldlf ldlfcntref +ldo +ldogen ldot ldots ldr ldrop +ldropn +ldropwhile +ldsb +ldst ldsysgenld ldt ldual @@ -41115,6 +44780,10 @@ ldualvsub ldualvsubcl ldualvsubval ldualvsval +ldub +lduba +lduh +ldummy ldwxolarsqindqrrwdsd le_add_same_cancel1 le_add_same_cancel2 @@ -41152,7 +44821,10 @@ leadingcoeffnth leadingterm leadprec leads +leadsto leaf +leafd +leafs leagne leak leakage @@ -41167,9 +44839,13 @@ leanprove leanprover leans leansearchclient +leapfrog +learn +learned learning least least-prefixpoint +leastbi leastext leastge leastofbdd @@ -41181,6 +44857,7 @@ leavemult leaves leaving leb +lebase lebesg lebesgue lebesguedecomposition @@ -41205,6 +44882,7 @@ lecture lectures led ledi +ledigits ledii lediri lediv @@ -41217,6 +44895,7 @@ ledivnn ledivp ledm ledx +leel leeq leescatghzvlnkfycuogbturbutezleiazytrsvmc leex @@ -41256,21 +44935,29 @@ leftadjointscoyonedaequiv leftadjointsquare leftadjointsquareconjugate leftadjointuniq +leftalternative leftarrow leftassoctensor +leftbol +leftbolloop leftc leftcanceladd leftcancelequiv +leftcancellative leftcancelmonoid leftcancelsemigroup leftcomm leftcommutative leftcomp leftcompreflexion +leftcongruent +leftconical leftcoset leftcosetequivalence leftcosetequivsubgroup leftderiv +leftderivation +leftderivations leftderived leftderivedlift leftderivednatiso @@ -41278,15 +44965,18 @@ leftderivednattrans leftderivedtohomotopycategory leftderivedunique leftderivedzeroisoself +leftderives leftdescent leftdistd leftdistrib leftdistribclass leftdistributor +leftdivides leftdual leftdualequiv leftdualfunctor leftdualiso +lefte leftexact leftexactfunctor leftexactfunctorequivalence @@ -41301,6 +44991,7 @@ leftfractionrel leftfullyfaithful leftfun leftfunc +leftharpoonup lefthom lefthomol lefthomologpmap @@ -41324,6 +45015,8 @@ lefthomotopyclass lefthomotopyclassequivrighthomotopyclass lefthomotopyclasstohom lefthomotopyrel +lefti +leftidentity leftinv leftinvariant leftinvariantderivation @@ -41332,6 +45025,7 @@ leftinvariantisquotientmeasureeqmeasurepreimage leftinvequiv leftinverse leftinverseunitor +leftinvertible leftinvissurj leftinvon leftinvseq @@ -41352,11 +45046,15 @@ leftlim leftlt leftmap leftmodule +leftmonotonic leftmost +leftmostlookahead +leftmostlookaheads leftmul leftmulmappregns leftmulmatrix leftmulresiduation +leftneutral leftno leftnod leftofineqproof @@ -41377,6 +45075,7 @@ leftover leftpad leftpreliealgebra leftpreliering +leftprincipal leftproperviaequiv leftquotient leftquotientequiv @@ -41392,6 +45091,7 @@ leftres leftresolution leftretraction leftright +leftrightarrow leftrighth leftrighthomologycomparison leftrigid @@ -41399,6 +45099,8 @@ leftrigidcategory leftrigidcategoryofequivalence leftrigidcategoryofrightrigidcategory leftsection +leftsemimedial +leftsemimodule leftshift leftshiftaddequiv leftshiftlinearequiv @@ -41410,6 +45112,7 @@ leftstructure lefttomax lefttoright lefttotal +lefttrans lefttransversal lefttransversals lefttriple @@ -41427,6 +45130,7 @@ leftunitornatisocat leftunop leftunshift leftval +leftzero leftzigzag leftzigzagiso lefulppos @@ -41453,11 +45157,13 @@ legtrid legval lehmann lehmer +lehmers lei leibeq leibnitz leibniz leibnizadjunction +leibnizeq leibnizproperties leibnizpullback leibnizpushout @@ -41479,6 +45185,7 @@ leisorel lejdii lejdiri lejoin +lel lele lelem lelista @@ -41500,42 +45207,150 @@ lelttri lelttric lem lema +lemaddoverscale +lemaffineapproxdomaintranslation +lemaffineapproxrangetranslation +lemaffinecontinuity +lemaffinediff +lemaffineequalatbase +lemaffineidentity +lemaffineimpliestotalfunction +lemaffineiscts +lemaffineoflineisline +lemaffineofpointonline +lemaffofaffisaff +lemapproxequalatbase lemaptop +lemaxisisline lemaxle lemb +lembijectionontwo +lembijinv lemc +lemcardoflineisbig +lemcauchyschwarz +lemcauchyschwarzequality +lemcauchyschwarzequalityinunitsphere +lemcauchyschwarzsqr +lemcausalorthogmtolightlikeimpliesparallel +lemccone +lemclassification +lemconecontainsvertex +lemconecoordinates +lemconelemma +lemconesexist +lemcphoton +lemcpos +lemcprops +lemctsofctsiscts lemd +lemdirectioncollinear +lemdirectionfromto +lemdirectionjoining +lemdirectionreverse +lemdotcommute +lemdrtnlinejoining leme lemeet +lemelementsofset lemf +lemfromtoto lemg lemi lemin +leminjectivevalueunique +leminjofinjisinj +leminsidecone +leminsideregularconeunderaffinvertible +leminverseaffine +leminversecomposition +leminverseofaffinvertibleisaffinvertible +leminvertibleonmeet +lemlinearimpliesaffine +lemlinearpartisunique +lemlinecontainsbasepoint +lemlinecontainsendpoint +lemlineendpoint +lemlineinsideregularconehasfiniteslope +lemlinejoiningunderaffine +lemlinemeetscone +lemlinevelocitynonzeroimpliesfinite +lemlinevelocityusingpoints lemm lemma +lemmaa lemmanames lemmas lemmata lemmatype +lemmdotcommute lemme +lemmovebymove lemn +lemnonparallelvectorsexist +lemnullline lemold +lemonlineunderaffine +lemonregularconeiff +lemorthogalspacevectorexists +lemorthosym +lemoutsidenotoncone +lemoutsideregularconeimplies +lemparalleljoin +lemparallelnotmeet +lemparallelreflexive +lemparallelsym +lemparalleltrans +lemplanecontainsbasepoint lempt +lempty +lemquadcoordinates +lemregularcone lemrp lems +lemscale +lemscaleinverse +lemscalelinear +lemscaleneg +lemscaleorigin +lemscaleoveradd +lemscalescale +lemslopeinfiniteimpliesoutside +lemslopelinejoining +lemsmallcardunderinvertible +lemsnorm +lemsomefunc +lemspace +lemsqrt lemsuccf lemt +lemthirdelementofset +lemtime +lemtimelikeinsidecone +lemtranslationimpliesaffine +lemtranslationpartisunique lemul lemuldiv lemuldivd lemulge lemuls lemulsd +lemvecplusassoc +lemvecpluscommute +lemvecplusminus +lemvecselfminus +lemveczerominus +lemvelocityjoiningusingpoints +lemvelocitylinejoining +lemvertexoncone +lemwherelinemeetscone +lemzeg len len_w lenb lenbuf lenbv +lenc lencl lenco leneg @@ -41547,17 +45362,25 @@ lenegsd lenegsq lenelioc leneltd +lenext length length-2 length-indexed lengthappend lengthatleastone lengthbv +lengthd +lengthe +lengthf +lengthft +lengthi +lengthia lengthone lengthparity lengths lengthy leni +lenlex lenlt lenltd lenlteq @@ -41573,6 +45396,7 @@ lenrevpfxcctswrd lens lensymd leo +leof leofhom leofstructure leonepart @@ -41593,9 +45417,14 @@ leordtval leordtvallem lep lepnf +lepoll leprd lepw leq +leqb +leqd +leqi +leqs lequiv lequivcongrleft lequivproddirectsum @@ -41620,6 +45449,7 @@ lern lersif lersifn les +lesi lesid lesloe lesloed @@ -41639,14 +45469,21 @@ less_tropical less_tropical_def less_tropical_min less_tropical_min_def +lessapprox +lessd +lesse lesseq lesser lessexpbound lessf +lessi lessis lessleaves lessmpt lessp +lesspoll +lesss +lesssim lessthan lestr lestrd @@ -41679,6 +45516,7 @@ letopuni letp letr letrd +letrec letri letric letrid @@ -41693,10 +45531,15 @@ letting lettre letvalue leub +lev leval level +levellista levelmvartoparam +leveln levelnames +levelofterm +leveloftype levelone levelpa levelparams @@ -41706,6 +45549,7 @@ levelset levelzero leverage levi +levy levyprokhor levyprokhorov levyprokhorovdist @@ -41713,18 +45557,26 @@ levyprokhorovedist leweon lex lexaccessible +lexarg +lexeq lexer +lexext lexicographic lexicographical lexicographically lexlogpow +lexmax +lexmin lexord lexorder +lexp +lexpands lexprod lez lezero lezerofnum lfa +lface lfb lfgredgge lfgriswlk @@ -41732,7 +45584,13 @@ lfgrn lfgrnloop lfgrwlknloop lfgrwlkprop +lfi +lfilled lfilter +lfiltere +lfilteri +lfiltermap +lfind lfingen lfinite lfinpfin @@ -41749,6 +45607,7 @@ lflip lflmul lflnegcl lflnegl +lfloor lflsc lflset lflsub @@ -41756,9 +45615,12 @@ lflvsass lflvscl lflvsdi lfnl +lformula lfp lfpapprox +lframe lfs +lft lfu lfuhgr lfunction @@ -41776,9 +45638,14 @@ lgamgulmlem lgamp lgamucov lgb +lgc +lgenerator lgr lgricngricex +lgrid +lgridi lground +lgroup lgs lgsabs lgscl @@ -41817,10 +45684,14 @@ lgsval lgsvalmod lgt lgteduh +lgth lhd +lhdd lhe +lhj lhlli lhllsi +lholed lhom lhomwithconstants lhomwithconstantsmap @@ -41850,19 +45721,27 @@ lhpocnel lhpocnle lhprelat lhpset +lhr +lhri lhs lhsap +lhset lhsfin lhsfun lhshead lhspf lhsraw lhss +lhssd lhsstr +lhsv lhsval lia +liar lib +liberate liberating +liberation libraries library libraryrewrite @@ -41972,6 +45851,7 @@ liftalternating liftalternatingequiv liftat liftaux +liftb liftbasechange liftbasechangeequiv liftboundedorder @@ -42009,11 +45889,13 @@ liftedlimitislimit liftedlimitmapstooriginal liftequiv liftequivofcomm +liftet liftexcept liftexpand liftexpr liftextend liftextendfarrowiso +liftfm liftfone liftfromover liftfromovercomp @@ -42036,6 +45918,7 @@ lifthomotopyzero lifthomotopyzeroone lifthomotopyzerosucc lifthomotopyzerozero +lifti liftico liftid liftidhomotopy @@ -42044,18 +45927,21 @@ lifting liftinglocalizedfunctor liftingproperties liftings +liftinitdata liftinitialseg liftioc liftiso liftisometry liftk liftkaehlerdifferential +liftl liftlatticehom liftleftadjoint liftlefthomology liftlie liftlimit liftlinear +liftlm liftm liftmacrom liftmagma @@ -42064,10 +45950,12 @@ liftmetam liftmetatactic liftmetatacticaux liftmkbindingm +liftmm liftmonoid liftmonoidhom liftmonoidwithzer liftmonoidwithzerohom +liftn liftnatiso liftnattrans liftnc @@ -42076,6 +45964,7 @@ liftncringhom liftnormal liftnormedaddgrouphom liftnormedaddgrouphomequiv +lifto liftobj liftofderivationtosquarezero liftofisrightkanextension @@ -42087,6 +45976,7 @@ liftofsurjective lifton liftonunits liftonwellorder +liftop liftopcycles liftoption liftorderbot @@ -42108,6 +45998,7 @@ liftq liftqspansingleton liftquotient liftr +liftreadert liftrel liftrelaux liftrelo @@ -42115,12 +46006,16 @@ liftrelrec liftright liftrightadjoint liftringhom +liftrreadert +liftrstatet +liftrsum lifts liftsingleton liftsourc liftsourcetargetpropertyat liftsring liftstar +liftstatet liftstocolimit liftstocolimitofcreates liftstolimit @@ -42129,10 +46024,13 @@ liftstruct liftstructequiv liftstructofhasstrongepimonofactorisation liftsubobject +liftsum liftsup liftsupquotquotmk +liftt lifttell lifttermelabm +liftti lifttodiagramlimitobjaux lifttodiscrete lifttofinset @@ -42151,7 +46049,10 @@ lifttoterminal lifttoterminalunique lifttruncle lifttrunclt +liftts +lifttti liftunique +liftwritert liftzeroatinfty lig lighneal @@ -42211,6 +46112,7 @@ limcmptdm limcnlp limcompflipisowhiskerlim limcompinclusion +limcons limcperiod limcrcl limcrecl @@ -42308,6 +46210,8 @@ limitflipcomplimisolimitcomplim limitflipisocomplim limitformula limitfunctor +limiti +limitin limiting limitiso limitisoflipcomplim @@ -42356,6 +46260,8 @@ limom limomss limon limord +limp +limpr limpt limpts limratio @@ -42445,6 +46351,7 @@ lincfsuppcl lincmb linco lincolss +lincomb lincop lincreslvec lincresunit @@ -42542,6 +46449,7 @@ lineargrowthsupbothom linearhom linearhomequiv linearhomequivcomm +lineari linearinde linearindep linearindepen @@ -42560,6 +46468,7 @@ linearisometryequivconjstaralgequiv linearisometryequivtuple linearity linearity-sound +linearityd linearizable linearization linearizationofmulactioniso @@ -42571,6 +46480,7 @@ linearizemonoidal linearizeofmulactioniso linearizetrivial linearizetrivialiso +linearl linearlmod linearlocallyfinite linearlocallyfiniteorder @@ -42630,11 +46540,14 @@ linearordertomin linearoverfield linearp linearpmap +linearpoly linearpred linearprojofclosedcompl linearprojofiscompl linearpz +linearr linearrecurrence +linears linearstrictorderedring linearsucc linearswap @@ -42645,6 +46558,8 @@ linearyonedaobj linearyonedaobjresprojectiveresolutioniso linearz linearzz +lineb +linec linecgr linecgrand linecom @@ -42667,12 +46582,15 @@ lineext lineformation lineg linegraph +linei lineid lineintmo +linejoining linem linemap linenumber linepath +linepaths linepmap linepolynomial linepsubcln @@ -42682,11 +46600,13 @@ lineqi liner linerflx lines +linesby linesd linesee lineset linesi linesl +lineslopefinite liness linest linetest @@ -42695,8 +46615,10 @@ linethrueu lineunray lineval linevalexample +linevelocity linexp linf +linfinite linflinf linfn linfty @@ -42719,6 +46641,7 @@ linindsi linindslinci linindsv link +linkable linked linkedbetree linkedbetreevars @@ -42729,13 +46652,19 @@ linkedlist linkedlistinsert linkedseq linking +linkmark links +linls linmullin linop linord linorder linorder_not_le +linordered +linorders linply +lins +linsd linsts lint linte @@ -42764,11 +46693,13 @@ lip liplem lipsc lipsch +lipschhitz lipschit lipschitz lipschitzadd lipschitzextensionconstant lipschitzgroup +lipschitzi lipschitzmul lipschitzon lipschitzonwit @@ -42776,11 +46707,14 @@ lipschitzonwith lipschitzw lipschitzwith liquid +lir lis +lischitz liso lisp list lista +listany listblank listboolmerge listbox @@ -42789,6 +46723,7 @@ listchoice listcons listd listdecode +listdirectory listed listen listencode @@ -42805,26 +46740,36 @@ listfiltermap listhybrid listi listin +listindices listlib listmap +listmem listn listnatequivnat listnil listnotations listof +listop listp listprod listrange +listrel listrep listrepeat listreplace lists +listset +listsetd +listseti listshape listsl listsp listspec listsum +listt listtake +listtofun +listtofuns listtopath listtransveccol listtransvecrow @@ -42833,6 +46778,7 @@ listuniqueequiv listval lit literal +literald literally literals literaltopropf @@ -42849,7 +46795,10 @@ lives living lja ljohn +lke +lkei lker +lkeysec lkg lkr lkrcl @@ -42870,19 +46819,24 @@ lkrssv lkrval lks lksize +lla +llangle llast llcei llci llcomp lle +lleftarrow llem llength +lless llex lli llift llim llines llist +lll llli lllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllll lllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllll @@ -42916,14 +46870,18 @@ llnnleat llnnlt llnset llp +llq llr +llrg lls llsi llsli llt lltm lltr +lltrv lltsi +llxs lly llycmpkgen llyeq @@ -42934,6 +46892,7 @@ llyrest llyss llyssnlly llytop +lma lmap lmapdomain lmarginal @@ -42946,6 +46905,7 @@ lmatfval lmatfvlem lmatval lmax +lmbd lmbr lmbrf lmcau @@ -42965,6 +46925,7 @@ lmdran lmdrcl lmdvg lmdvglim +lmember lmerge lmeri lmerk @@ -43035,6 +46996,7 @@ lmimlbs lmimlmhm lmimot lmimrwasbop +lminus lmiopp lmireu lmirro @@ -43106,6 +47068,7 @@ lmodvsneg lmodvsubadd lmodvsubcl lmodvsubval +lmove lmr lmrcl lmrel @@ -43114,10 +47077,12 @@ lms lmss lmul lmulequiv +lmult lmultower lmvr lmxrge lmyhdibnrqkgzbcllnaglazkxrxirawmhxrgdvcj +lnact lnat lnatexn lncgr @@ -43132,6 +47097,8 @@ lncvrelatn lne lneg lneq +lnever +lnexp lnext lnfn lnfnaddi @@ -43150,6 +47117,7 @@ lngen lngid lngndx lngndxnitvndx +lngth lnhl lnid lnil @@ -43214,16 +47182,23 @@ lnrfrlm lnrlnm lnrot lnrring +lns lnth lnull +lnulld lnxfr +loa load loadbytes loadconfig +loadelim +loadi loadimportedmodule loading loads loadv +loan +loans loc loca local @@ -43248,6 +47223,7 @@ localgeneratorsdataofisfinitetype localhomeomorph localhost locali +localimpglobalcons localinstances localinsts localinvariantprop @@ -43363,11 +47339,14 @@ localnormalconvergence localpredicate localpreimage localpresentationat +localr localrepresentability localring localringhom locals localsecrets +localsecretscomposition +localss localsubring localthms localtree @@ -43408,8 +47387,10 @@ locoalization locpathconnectedspace locquiver locs +locsound locus loe +loeb loewner lof log @@ -43477,6 +47458,7 @@ logemb logembedding logembeddingequiv logembeddingquot +logempty logeq logequiv logeqv @@ -43544,6 +47526,7 @@ logonunused logorc logorderiso logpowmul +logq logratio logrec logreclem @@ -43586,10 +47569,21 @@ longfile longfiledefvalue longfilelinter longhand +longleftarrow longleftrightarrow longline longlinelinter longlines +longlonglongrightarrow +longlongrightarrow +longmapsto +longr +longri +longrig +longrigh +longright +longrightar +longrightarro longrightarrow longroot longs @@ -43598,16 +47592,26 @@ looinv looinvi looinvii look +lookaheadsof looked looking lookmap looks +looksup lookup lookupall +lookupany +lookupdef +lookupdefe +lookupdefnode lookupdpair +lookupenv lookupfinsupp lookupindex +lookupkey +lookuporinsert lookups +lookupwith loolin loop loopalgebra @@ -43636,7 +47640,10 @@ loowoz lop lopclset lor +lorenz lose +loser +losers loses losing loss @@ -43644,6 +47651,8 @@ lossless lost lot lots +lotteries +lottery louis lovasz loves @@ -43652,9 +47661,15 @@ lowbit lowdim lowdistapprox lowdistapproxfromtree +loweq +lowequivalence +lowequivreflexive +lowequivsymmetric +lowequivtransitive lower loweradjoint loweradjunction +loweratom lowerbasis lowerbound lowerbounds @@ -43670,6 +47685,7 @@ lowercrossingtime lowercrossingtimeaux lowered lowerequivalence +lowerfm lowerhalfplane lowerhemicontinuo lowerhemicontinuous @@ -43680,6 +47696,8 @@ lowering lowerinv lowerloosebvars lowerpolar +lowerpoly +lowerpowers lowersemicontinuo lowersemicontinuouat lowersemicontinuous @@ -43693,6 +47711,7 @@ lowertriangular lowest lowi lowlink +lowner loyd lpa lpaddconst @@ -43702,11 +47721,15 @@ lpadlen lpadmax lpadright lpadval +lparr lpbcf lpbl lpcls lpdifsn +lpfp +lpfpc lpfval +lphil lpi lpideal lpigen @@ -43749,7 +47772,9 @@ lplnrian lplnribn lplnric lplnset +lplus lply +lpm lpmap lpmeas lpmeassubgroup @@ -43760,18 +47785,24 @@ lpmeastolptrim lpmeastolptrimlie lpni lpnorm +lpo lpolconn lpolfn +lpolies lpolpolsatn lpolsatn lpolsetn lpolvn +lpoly lpoption lpos lppairing lppilp lppthon lprefix +lprefixi +lprodr +lps lpsmul lpspace lpss @@ -43798,12 +47829,16 @@ lratstep lrb lrc lrcut +lrec lred lreg lreiner lrelat +lreplicate lres lrev +lrevt +lrh lring lringnz lringnzr @@ -43812,7 +47847,9 @@ lringuplu lrl lrmorphism lrmorphismp +lroft lrold +lrow lrr lrrecfr lrrecpo @@ -43820,7 +47857,10 @@ lrrecpred lrrecse lrrecval lrs +lrsecure +lrtp lruneq +lrv lrx lsa lsat @@ -43847,15 +47887,18 @@ lsatspn lsatssn lsatssv lsb +lsbis lsbminus lsbplus lsc lsd lseg +lseqrule lseries lserieshassum lseriessummable lset +lsetp lsettoset lsf lshpat @@ -43873,9 +47916,13 @@ lshpnelb lshpset lshpsmreu lsi +lsided lsigb lsin lsingle +lsit +lskiprule +lsl lsli lsls lsm @@ -43925,9 +47972,12 @@ lsmul lsmunss lsmval lsmvalx +lso lsp lspabs +lspace lspan +lspasl lspcl lspdisj lspdisjb @@ -43942,6 +47992,8 @@ lspid lspidm lspindp lspindpi +lsplit +lsplitremainder lsppr lspprabs lspprat @@ -43987,6 +48039,7 @@ lspvadd lspval lsq lsr +lsrc lss lssacs lssacsex @@ -44035,14 +48088,19 @@ lssvsubcl lst lstar lstarlw +lsteps lstprd +lstream +lsu lsub +lsubgroup lsubrotld lsubsp lsubswap lsubtypedomain lsue lsum +lsumr lsup lsw lswccat @@ -44056,6 +48114,7 @@ lswn lsws lt_fin lta +ltabulate ltac ltac2 ltadd @@ -44078,6 +48137,9 @@ ltaddsublt ltaddsubs ltaddsubsd ltake +ltakeuntil +ltakewhile +ltam ltanq ltapi ltapr @@ -44091,6 +48153,7 @@ ltbwe ltc ltceilhalf ltcvrntr +ltd ltdifltdiv ltdiv ltdivgt @@ -44116,6 +48179,7 @@ ltensorhomequivhomltensor ltensorhomtohomltensor ltensorkerincl ltensorone +lteq lterecall lterecallleft ltereflectslte @@ -44143,9 +48207,13 @@ lth lthalf lthm lths +lti ltideal ltimpliesnotgte ltl +ltland +ltlc +ltld ltle ltleadd ltleaddd @@ -44165,10 +48233,13 @@ ltlestrd ltletr ltletrd ltletri +ltli ltlist ltlistirrefl ltlisttrans ltln +ltlor +ltlp ltltncvr ltm ltmin @@ -44219,6 +48290,7 @@ ltofun ltonold ltonsex ltopreflectslt +ltor ltord ltordlem ltp @@ -44236,6 +48308,7 @@ ltrec ltrecd ltreci ltrecii +ltree ltrel ltrelnq ltrelpi @@ -44244,6 +48317,7 @@ ltrelre ltrelsr ltrelxr ltresr +ltrm ltrmxnn ltrmy ltrmynn @@ -44292,8 +48366,10 @@ ltrnq ltrnset ltrnu ltrnval +ltrv lts ltsasym +ltsdining ltsdiv ltseries ltsintdifex @@ -44359,10 +48435,13 @@ ltweuz ltxr ltxrlt ltxy +ltype ltz ltzero luaux lub +luba +lubb lubcl lubdm lubel @@ -44378,6 +48457,8 @@ luble lublecl lublecllem lublem +lubmap +lubmapi lubofdirected lubpr lubprdm @@ -44403,6 +48484,10 @@ luminosity luminous lunar lunion +lunit +luniv +lunstream +lunwindsdcond lup lupdate luroth @@ -44410,8 +48495,12 @@ lus luschny lution luzin +lval +lvalidfrom +lvalidfroms lvalue lvar +lvars lvec lvecdim lvecdimfi @@ -44431,6 +48520,7 @@ lvecring lvecvs lvecvscan lvecvsn +lvivl lvl lvls lvolbase @@ -44452,13 +48542,20 @@ lwhenfn lword lwordnil lwyudgprqvudhazk +lxfirst lxor +lxs lxy lyapunov lyearfn lying lyle lym +lyndon +lyndond +lyndoni +lynfac +lynsuf lywvxtx lyx lyz @@ -44480,18 +48577,21 @@ machinery machines machinesig machstep +maclaurin macobjctrlattrhavechanged macquarie macro macro_rules macroexpansion macrom +macron macroname macroscopes macsecurestate macsubctrlattrhavechanged mact madd +maddux made madebday madebdayim @@ -44525,10 +48625,15 @@ madurid madutpos maduval mae +magdalena magic +magicl +magicr magma magmacat magmacatisotomulequiv +magnitude +magq mahler mahlerequiv mahlermeasure @@ -44557,21 +48662,48 @@ mainthm mainu mainvar maj +maje major majoration majoring +majorities majority majorized make +makeabsolute +makeaf +makecarray +makecarraycorrect +makecat +makecatcod +makecatcomp +makecatcompdef +makecatdom +makecatid +makecatmapsto +makecatmor +makecatobj +makecf +makecfcorrect +makecfpreserves makecnf makecongrmstring +makedupleratoprim makeeditlink +makefacefinal +makefacefinals makefastinstance +makeftor +makeftormor +makeftorobj +makeftorpreftor makegcongrlemma makegcongrstring +makelist makennf makennfn maker +makerelative makerhs makes makescolimit @@ -44579,12 +48711,18 @@ makeslimit makesnewmvars makesoverarrow makespan +makestep makestring +makestronger making male malformed +malformedargumentlisterror +malformedforalltypeerror +malformedgoalerror mall malloc +malt maltsiniotis mammal mamuass @@ -44617,9 +48755,11 @@ manifold manifolds manip manipu +manipulable manipulate manipulation manipulations +mann manner mantissa mantop @@ -44629,6 +48769,7 @@ manufacture many manychars manyconfig +manyof manyonedegree manyoneequiv manyonereducible @@ -44651,23 +48792,29 @@ mapalgebra mapalgequiv mapalgho mapalghom +mapall mapalong mapalongaddmonoidhom mapalongmonoidhom mapalongringhom mapandcomap +mapannempty +mapannlist +mapannmap mapappend maparrow maparrowequivalence maparrowfunctor maparrowleft maparrowright +mapassoc mapasyncchunked mapaugmentedcechconerve mapaugmentedcechnerve mapaut mapaux mapaway +mapb mapbasechange mapbicone mapbifu @@ -44728,6 +48875,9 @@ mapcoconewhisker mapcocycles mapcod mapcoeffs +mapcollect +mapcollectfilter +mapcollecti mapcomap mapcommgrp mapcommgrpcompiso @@ -44742,6 +48892,7 @@ mapcommmonidiso mapcommmonnatiso mapcommmonnattrans mapcommpgrp +mapcommute mapcomon mapcomonfunctor mapcomp @@ -44777,6 +48928,7 @@ mapcontactioncomp mapcontactioncongr mapcontinuousmulequiv mapcotangent +mapcrumb mapcycles mapcyclesiso mapd @@ -44856,6 +49008,7 @@ mapexactauxdelta mapexactfunctor mapexold mapextaddhom +mapextendempty mapextendscalars mapextlinearmap mapfactorizationdata @@ -44908,6 +49061,7 @@ maphomotopycategory maphomotopycategoryfactors maphomotopycategoryprodidcompinverseiso maphomotopyequiv +mapi mapid mapidiso mapidx @@ -44917,6 +49071,7 @@ mapidxmgo mapiic mapincl mapinclisometry +mapinj mapinjectivepresentation mapintegralclosure mapinverse @@ -44959,6 +49114,8 @@ mapmatid mapmatrix mapmatrixlinear mapmatrixmodule +mapmaybe +mapmaybeisinj mapmeasure mapmon mapmoncompiso @@ -44981,6 +49138,7 @@ mapo mapobj mapobjfun mapobjiso +mapof mapofcompatiblesmul mapofeq mapofhomotopy @@ -45037,6 +49195,7 @@ mappushoutadj mappwen mapq mapqlinear +mapr mapra maprange maprangeaddequiv @@ -45067,6 +49226,7 @@ maproots maps mapscalars mapsec +mapset mapsetembedding mapsetequiv mapsetofmaximal @@ -45091,6 +49251,11 @@ mapssfset mapsspm mapsspw mapsto +mapstocompdef +mapstoe +mapstoi +mapstoop +mapstoopop mapstorestrict mapstringsm mapsubgroup @@ -45138,6 +49303,7 @@ mapwhiskerleft mapwhiskerleftisoconjpremap mapwhiskerright mapwhiskerrightassmallfunctor +mapwith mapx mapxpen mapy @@ -45145,6 +49311,7 @@ mapz mapzerocokernelcofork mapzerokernelfork mapzeroobject +mapzip marep marepvcl marepveval @@ -45157,12 +49324,19 @@ margin marginal marginals marginleft +maria +mariamagdalena mario mark marked +marker +markers +market marking markov +markovian marks +marksd marrep marrepcl marrepeval @@ -45180,57 +49354,78 @@ martingalepa martingalepart marypha marys +mascheroni mask masked +maskeddb +maski masking masklib masks mass massage masses +massf master mat +matachany matadd matassa matbas match matchable +matchall matchalt matchaltexpr +matchand matchandnorm +matchany matchapp matcharg matchbody matchclone matchconstinduct +matchd +matchdollar matchdom matched matchepsilon matcheq matcher matchername +matchers matches matcheshead matcheverything matchexpr +matchf matchfoldl matchforall matchfun matchfvar matchhyps +matchi matchindex matching matchingprefixes matchings matchkey matchlambda +matchless +matchnone +matchnot +matchor matchorder +matchp matchpattern matchpatterns matchquerystar +matchrel +matchreld matchresult matchrings matchrootstar +matchs matchscalars matchscalarsaux matchscoped @@ -45244,6 +49439,7 @@ matchvar matchvecconsprefix matchvecconsprefixq matcpmric +matd matdim mate matecl @@ -45286,12 +49482,14 @@ matinv matinvg matinvgcell matiyasevic +matl matlmod matmon matmpo matmul matmulcell matmulr +matofpoly matplusg matplusgcell matpoly @@ -45302,6 +49500,8 @@ matrcl matrepv matri matrices +matricization +matricize matrify matring matrix @@ -45328,6 +49528,7 @@ matrixu matroid matroids matrrep +mats matsc matsca matstar @@ -45355,6 +49556,7 @@ matvscacell matvscl matxmat matxvec +mau mavmul mavmulass mavmulcl @@ -45378,12 +49580,20 @@ max_le_iff max_mono maxa maxargsfor +maxbalinp maxbank +maxbid +maxbidalg +maxbidequivalence maxbinade +maxblk maxchain +maxchopper maxcommutative maxcompatible +maxd maxdefault +maxdeg maxdegree maxdepth maxdistance @@ -45405,6 +49615,7 @@ maxeq maxex maxfbounded maxfloat +maxflow maxfoelner maxgeneigenspace maxgeneigenspaceindex @@ -45421,6 +49632,7 @@ maxidx maxim maxima maximal +maximalallactionwithoutseller maximalatlas maximales maximalfor @@ -45433,10 +49645,13 @@ maximals maximalseparatedset maximalspectrum maximalspectrumtopilocalization +maximalstrictallocations +maximin maximize maximizes maximum maximumclique +maximumd maximumindepset maximumleftupperbound maximumminimum @@ -45446,6 +49661,7 @@ maxindex maxintros maxl maxle +maxlemma maxlen maxlength maxlist @@ -45464,6 +49680,7 @@ maxnac maxnaca maxnc maxnca +maxne maxnext maxnilpotentideal maxnilpotentidealisnilpotent @@ -45471,10 +49688,13 @@ maxnilpotentsubmodule maxnn maxnp maxofle +maxop +maxoperator maxoppmin maxp maxpowdividing maxpowdvddiv +maxpref maxprmfct maxproducts maxqueued @@ -45483,9 +49703,13 @@ maxrat maxroot maxroundedmodep maxs +maxsat +maxset maxsize maxslowdown maxspeed +maxsplit +maxsplitter maxsta maxsteps maxsx @@ -45494,8 +49718,11 @@ maxtail maxtensorproduct maxterm maxti +maxtilist maxtogood +maxtr maxtransitiondepth +maxtriangleinequality maxtrivequiv maxtrivhom maxtrivlinearmapequivliemodulehom @@ -45505,6 +49732,8 @@ maxtype maxunifeigenspaceindex maxuniquep maxvar +maxwidth +maxword maxy may may_ @@ -45514,6 +49743,7 @@ maybelte maybeminimal maybeproveinjective maybepseudosyntax +maybet mayclosegoal mayclosegoalfromhyp mayervietorissquare @@ -45523,7 +49753,9 @@ mayfail maypostpone mazh mba +mbal mball +mbc mbed mbedtls mbf @@ -45578,6 +49810,8 @@ mbfsup mbfulm mbgzujswqysdpsyxjdy mbim +mbind +mbinomial mbl mble mblfinlem @@ -45587,21 +49821,27 @@ mblsplit mblss mblvol mblvon +mbody mbool mboolean +mbot mbounded mbox mbpadic +mbta +mbuf mbv mbxpaxfvgsvlslmhqbrntxahalv mca mcast +mcauchy mcball mcbride mccarthy mccarthyninetyone mccl mccllem +mce mcf mclosure mcls @@ -45616,11 +49856,15 @@ mclsval mcm mcmillan mcn +mcomb mcomplete mcongr mcons mcont +mcontmn mconv +mcp +mcq mcquillan mcs mcshane @@ -45628,6 +49872,7 @@ mct mctx mctxafter mctxbefore +mctxt mcubic mdandysum mdandyv @@ -45641,6 +49886,7 @@ mdcompli mddmd mddmdin mdecl +mdef mdeg mdegaddle mdegcl @@ -45691,16 +49937,21 @@ mdifferentiable mdifferentiableat mdifferentiableon mdifferentiablewithinat +mdijkstra +mdinit mdist mdiv mdoc mdomain +mdot +mdp mds mdsl mdsldmd mdslj mdslle mdslmd +mdss mdstate mdsym mdsymi @@ -45785,6 +50036,7 @@ measurableequivrealmixedspacepolarspace measurableequivrealprod measurableequivsum measurablefunctions +measurablei measurableinf measurableinv measurableinvorder @@ -45813,6 +50065,7 @@ measured measuredense measuredsets measurefn +measurei measureof measureofnegatives measurepres @@ -45840,6 +50093,7 @@ measvunilem measvxrge measxun meaunle +meaurable meaxrcl mechanics mechanisation @@ -45849,7 +50103,9 @@ med medals media medial +medialmagma median +mediant mediate mediatrice medoc @@ -45858,19 +50114,26 @@ meetat meetcl meetcom meetcomalt +meetd meetdef meetdm meetdmss meeteu meetfval +meeti meeting meetle meetlem meets +meetsemilattice meetsspatially meetval +meh +meissel mek mel +meld +melem melems melfz mellin @@ -45884,20 +50147,25 @@ memaddsubgroup memaddsubmonoid memaeseqset memassign +memb membaseset member member_le_sum +memberd memberfamily +memberi membermima memberp members membership +memberships memberstripodcomindygalfordtriviahtm membersubfami membersubfamily membpart membpartlem membparts +memcap memcarrier memcompat memcp @@ -45909,11 +50177,13 @@ memcpauxtlok memcpconshd memcpproper memcpy +memd memdata memdecidable meme memfixedpoints memholder +memi meminj meminjmu memintegers @@ -45928,9 +50198,12 @@ memobseq memofix memofiximpl memoised +memoize +memoized memoread memory memoryproof +memoryvalue memosize memowrite mempart @@ -45939,8 +50212,11 @@ mempartitio mempartition mempartitionset mempty +memr memrecon +memrel memren +mems memt memtable memtrivializationatlas @@ -45967,6 +50243,7 @@ mention mentioned mentries meq +meqd meqn meqofsep mequiv @@ -45978,16 +50255,23 @@ mere meredith merely merge +mergeall mergec merged +mergei +mergepairs merges +mergesibling mergesort mergesortedarrays +mergethese mergewith mergewithgrind mergewithgrindallowed merging +meridian meritage +merkle merlem merlot mero @@ -46055,9 +50339,14 @@ metf metflem metge metgt +meth methaus method +methodi +methodinvk +methodmain methods +methodsi methodsref methodsrefpointed metideq @@ -46079,6 +50368,7 @@ metres metreslem metrest metric +metrice metrics metricspace metricspaceaux @@ -46116,11 +50406,17 @@ metuval metxmet meuclidean meursault +meval mevent +mexec +mexecd +mexecdt +mexect mexists mext mexval mfa +mfact mfailed mfalse mfb @@ -46135,6 +50431,9 @@ mfldsettac mfloat mfold mforall +mformula +mfot +mfotl mfourier mfourierbasis mfouriercoeff @@ -46180,6 +50479,7 @@ mgmplusgiopalt mgmpropd mgmsscl mgn +mgp mgpbas mgpds mgpf @@ -46195,6 +50495,8 @@ mgpval mgraph mgraphon mgt +mgu +mgupaapax mgv mhdrd mhlfehlf @@ -46244,12 +50546,18 @@ mhy mia michael microsoft +microstep mid +midarrow midbtwn midcgr midcl midcom middle +middlebol +middlebolloop +middlefourexchange +middlesemimedial mideu mideulem midex @@ -46264,38 +50572,46 @@ midpoi midpoint midpointaux midpoints +mids miduniq midwwlks miff might might_ mighta +mignotte migrate migrated miim +mij mil milgram milieu miller milman +milner mim mima mimalloc mimic +mimicking mimpl mimplies min min-plus min_antimono +min_def min_eq min_insert min_k min_le minal +minarc minax minbadseqofbadseq minbeta minbinade +minblock mincardfinsetofmemconvexhull mince mincoef @@ -46303,6 +50619,7 @@ mincommutative mincompatible mind mindefault +mindeg mindegree mindistance minel @@ -46311,14 +50628,17 @@ mineq mineral minex minexlist +minf minfac minfacaux minfachelper minfacprop +minfi minfp minfty minftyccb minftynrr +mingraphprops mini miniallocator minidx @@ -46328,6 +50648,7 @@ minimal minimalaxioms minimalcover minimalfor +minimally minimalper minimalperiod minimalprime @@ -46345,14 +50666,20 @@ minimportslinter minimportsref minimpscore minimum +minimumd +minimumi minimun minimunaxiomatization minimunsequentcalculus +mining +minit +minius minizinc minj minkow minkowski minkowskibound +minkowsky minl minlog minlow @@ -46370,10 +50697,13 @@ minnn minnp minnull minofle +minop +minoperator minoppmax minor minorder minoring +minorm minormax minormaxp minormaxrep @@ -46401,6 +50731,10 @@ minroot minroundedmodep mins minsc +minset +minsetofcomponents +minsetofcomponentslimit +minsky minsmoothness minsol minspeed @@ -46409,32 +50743,41 @@ minsqfacaux minsqfacprop mint mintensorproduct +minterval minti +mintilist mintl mintoleft mintoright +mintree mintru minuniquep minus minusa minuse +minusi minusltemonotone minusm minusmod minusmodnep +minusone minusp minuspf minuspp minusroundrep minussameexp +minusset minusterm minusw +minusx minutes +minv minvalue minvec minveclem minveco minvecolem +minwait mir mirabelle mirauto @@ -46488,6 +50831,7 @@ mitchell mitigate mitre mittagleffler +miv mix mixed mixedchar @@ -46524,6 +50868,7 @@ mkappm mkappn mkappoptm mkappwithcast +mkarr mkarray mkarrow mkarrowiso @@ -46542,6 +50887,7 @@ mkbvar mkcache mkcasesonmatch mkcast +mkchannels mkchild mkchole mkcident @@ -46603,12 +50949,14 @@ mkdirpcp mkdirpsp mkdirpss mkdiscrs +mkdisjoint mkdivproof mkembedding mkempty mkencodablecmds mkencodableinstance mkencodableinstancecmds +mkeps mkeq mkeqforexpectedtype mkeqheq @@ -46622,6 +50970,7 @@ mkeqsymm mkeqtrans mkeqtrue mkequiv +mkequivalence mker mkerror mkeval @@ -46659,6 +51008,7 @@ mkfinite mkfinitetype mkfintype mkfintypeenum +mkfirstmap mkfoldlmatcher mkfoldrmatcher mkforall @@ -46688,6 +51038,7 @@ mkfunctorleft mkfunctorright mkfununit mkfvar +mkgcd mkh mkhastypebutisexpectedmsg mkhcongrwitharity @@ -46705,11 +51056,15 @@ mkhomeomorph mkhomfromdouble mkhomfromsingle mkhomtosingle +mkhord +mki +mkide mkident mkidentfrom mkidentfromref mkidinitial mkidterminal +mkif mkiffforexpectedtype mkiffofinductivepropimpl mkimpl @@ -46722,6 +51077,7 @@ mkinfofromrefpos mkinitial mkinitialofleftadjoint mkinitlazyentry +mkinjection mkinjthmmatch mkinjthms mkinputcontext @@ -46743,6 +51099,7 @@ mklambda mklambdafvars mklambdaq mklawfuldayconvolutionmonoidalcategorystruct +mklcm mklet mkletfvars mklevelparam @@ -46756,6 +51113,7 @@ mklm mklocaldecl mklocalruleset mklock +mklr mkltzeroproof mkmap mkmapping @@ -46796,6 +51154,7 @@ mknullnode mknum mknumeral mknumlit +mkobj mkofaddgroupcone mkofadjoineqtop mkofadjointifycounit @@ -46860,6 +51219,7 @@ mkposreal mkpostcomp mkprecomp mkprivatename +mkproc mkprodelem mkprodeqq mkprodequiv @@ -46883,6 +51243,7 @@ mkrat mkrawintlit mkrawnatlit mkrawratlit +mkrb mkreal mkrecname mkrecnames @@ -46893,6 +51254,7 @@ mkrelhom mkrewrite mkrichhcongr mkrifycontext +mkrightinverse mkringhom mkringhomofmulselfoftwonezero mkrw @@ -46919,6 +51281,7 @@ mksol mksorry mksort mkspansingleton +mkspec mkstate mkstdgen mkstr @@ -46927,6 +51290,8 @@ mkstrlit mksubproof mksubsingleton mksumeqq +mksurjection +mkt mkterm mkterminalofrightadjoint mktfaeid @@ -46949,6 +51314,8 @@ mkunsafe mkunusedbasename mkunusedname mkusedischarger +mkvarchannel +mkvarchannelproc mkvmyptsghkuzrrtgwwyizj mkw mkwindow @@ -46961,17 +51328,26 @@ mlconvolution mldir mle mlenv +mlex mlexp mliebracket mliebracketwithin +mlist mlkem mllist mlocal +mlower mlpath +mlss +mlssmf mlt +mltl +mlup mlval +mlwe mm mmap +mmd mmem mmemo mmin @@ -46980,8 +51356,12 @@ mmkahxxsfvnetmnxwzsabihfprxkcjgiwrbqbhetybvlndjuxrdb mmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmm mmn mmnn +mmodel +mmonitorable +mmonom mmu mmul +mmult mnam mname mnat @@ -47050,8 +51430,10 @@ mndvcl mndvlid mndvrid mnet +mnew mnf mnfaddpnf +mnfinite mnfle mnfled mnflt @@ -47083,6 +51465,8 @@ mnringnmulrd mnringscad mnringvald mnringvscad +mns +mnsfinite mnt mntf mntoval @@ -47138,7 +51522,11 @@ modaddmulmod modal modalb modalbe +modalcollapse modald +modaliseempty +modalisenonempty +modality modalmode modaltypechecker modbounds @@ -47150,6 +51538,7 @@ modcl modcld modcore modcyc +modd moddi moddiffl moddifz @@ -47161,13 +51550,17 @@ mode_ model modelac modelacf +modelappendtautology +modelassigns modelaxrep modelaxreplem modelcategory modelcategoryquillen modelfield +modelfiltertautologies modelico modelled +modellibrary modelofhascoeffs modelpi modelpiinhabited @@ -47188,6 +51581,8 @@ modeq modeqmodmin modequality modes +modesd +modesi modexp modfrac modfsummod @@ -47228,6 +51623,8 @@ modifyrevarg modifyscope modifytarget modifythe +modinequalitylemma +modint modirr modlt modlteq @@ -47265,7 +51662,10 @@ modprminveq modprmn modred modremain +modrule +modrules mods +modset modssabl modsub modsubdir @@ -47286,6 +51686,7 @@ modularcyclotomiccharacter modularform modularformclass modulargroup +modularity modularlattice modulars modularscalartowers @@ -47348,6 +51749,8 @@ modulevaluedmaps moduli modulo modulus +modulusd +modulusi modus modval modvalp @@ -47421,6 +51824,7 @@ monadiccreatescolimitofpreservescolimit monadiccreatescolimitsofpreservescolimits monadiccreatescolimitsofshapeofpreservescolimitsofshape monadiccreateslimits +monadici monadicity monadicityinternal monadicleftadjoint @@ -47430,6 +51834,7 @@ monadicofhaspreservesreflectsgsplitcoequalizers monadicofhaspreservesreflexivecoequalizersofreflectsisomorphisms monadicrightadjoint monadinfotree +monadio monadiso monadj monadleftid @@ -47443,17 +51848,23 @@ monadmor monadnormalexpr monadnormalizenaturality monadoptions +monadp +monadplus monadquotation +monadreader monadref monadresolvename monadrightid monads monadstate +monadt +monadtests monadtofunctor monadtomon monadwhiskerleft monadwhiskerright monadwriter +monadzero monbicategory monc moncat @@ -47477,13 +51888,17 @@ monhom moni monic monicdegreeeq +monice monicequivdegreelt monicfactorsmod +monici monicity monicization monicpoly monics +moninv monitor +monitorable monitors monl monlift @@ -47495,18 +51910,26 @@ monmonoid monmonoidal mono monoap +monoaux monobj monobjopof +monochomatic +monochromatic monochrome monoclm +monocoinduct +monocontlub monocoprod +monod monodromy monodromyfunctor monoequivoffin +monoevilism monof monofactorisation monofactorisationisimage monofactorisationzero +monofun monographs monoi monoid @@ -47569,7 +51992,9 @@ monoidhomofmemclosurerangecoe monoidhomoftendsto monoidhomslashaction monoidhomsubgroup +monoidl monoidmonadtrans +monoidnames monoidof monoidofskeletalmonoidal monoids @@ -47578,11 +52003,14 @@ monoidwithzero monoidwithzerohom monoidwithzerohomclass monoiskernelofcokernel +monol monolem monolift monolm monolr monom +monome +monomi monomial monomialonehom monomialorder @@ -47607,9 +52035,11 @@ monopoptocomon monopoptocomonobj monopoptocomonobjcomon monopushout +monor monorl monos monot +monotheism monothetic monoto monotoddzz @@ -47621,6 +52051,7 @@ monotoneaux monotoneconvergence monotonecurry monotonedef +monotoneinphi monotoneintro monotonemax monotonemin @@ -47628,11 +52059,16 @@ monotonemonotone monotoneon monotonep monotoneuncurry +monotoni monotonic +monotonicantitonic +monotonici monotonicity monotonicsequencelimit monotonicsequencelimitindex +monotonous monotony +monotran monotuz monovary monovaryon @@ -47689,6 +52125,7 @@ morera moreuptodate morex morgan +morhpism moriotass moritaequivalence moritaequivalencematrix @@ -47704,6 +52141,7 @@ morphimesub morphimp morphimt morphism +morphismi morphismp morphismproperty morphismpropertyhommk @@ -47724,6 +52162,7 @@ morphs morphv morre morrey +mortal mortality mortheorems mortheoremsext @@ -47739,6 +52178,7 @@ mosold mosssn most mostly +mostoftenrcvd mosub mosubop mosubopt @@ -47764,6 +52204,7 @@ motrag mots motv motzkin +moufangloop moura mousing mout @@ -47799,6 +52240,7 @@ mpanl mpanlr mpanr mpartially +mpath mpbi mpbid mpbidi @@ -47808,6 +52250,7 @@ mpbiran mpbirand mpbird mpbiri +mpc mpcl mpcoe mpcom @@ -47816,6 +52259,7 @@ mpd mpdan mpdd mpdi +mpdouble mpeg mpet mpets @@ -47823,6 +52267,7 @@ mpf mpfaddcl mpfconst mpff +mpfin mpfind mpfmulcl mpfo @@ -47880,12 +52325,14 @@ mplplusg mplrcl mplring mplringd +mpls mplsca mplsubg mplsubglem mplsubrg mplsubrgcl mplsubrglem +mplus mplval mplvrpmfgalem mplvrpmga @@ -47895,6 +52342,7 @@ mplvrpmrhm mplvsca mplvscaval mply +mpmf mpmhm mpmhmlem mpnanrd @@ -47919,6 +52367,7 @@ mpoexw mpoexxg mpofrlmd mpofun +mpointer mpoly mpomatmul mpompt @@ -47932,10 +52381,12 @@ mpomulex mpomulf mpomulnzcnf mpondm +mpop mpos mposn mposnif mpov +mpow mpoxeldm mpoxneldm mpoxopn @@ -47946,12 +52397,15 @@ mpoxopx mpoxopxnop mpoxopxprcov mpoxopynvov +mpp +mppi mppspst mppspstlem mppsthm mppsval mpr mpred +mprefix mprg mprgbir mprhm @@ -48033,6 +52487,7 @@ mpwser mpxraoxjhohyxmobfevgxjcbdceytvwd mrange mrangerestrict +mrbst mrccl mrccls mrccss @@ -48059,6 +52514,7 @@ mrcuni mrcval mre mreacs +mreal mreclat mreclatbad mreclatdemobad @@ -48074,10 +52530,12 @@ mreflexive mreiincl mreincl mreintcl +mrel mrelatglb mrelatglbalt mrelatlub mrelatlubalt +mremove mremre mrepr mreriincl @@ -48090,6 +52548,8 @@ mretopd mreuni mreunirn mreuniss +mrexp +mrexps mrexval mrieqv mrieqvd @@ -48099,6 +52559,8 @@ mrissd mrissmrcd mrissmrid mrisval +mrk +mroot mrsacres mrsbarry mrscole @@ -48118,6 +52580,9 @@ mrsubrn mrsubval mrsubvr mrsubvrs +mrtrancl +mrtrancld +mru msb msbaux msbboundnotzero @@ -48126,9 +52591,17 @@ msbroundlsb msbtozero msc mscl +msd msdcn +msel mserial mset +mseta +msetd +msetext +mseti +msetprod +msets msf msg msghistory @@ -48137,18 +52610,24 @@ msglocked msglog msgref msgs +msgse msgunlock mshntpppoqgzhvajpcpwvyab mshv mshyper +msize +msk msmaller msmet msmie msn msns +msog msoggjbazwn msort +msp mspace +mspec mspropd msq msqge @@ -48158,6 +52637,7 @@ msqsqrtd msqznn msr msrf +msrfn msrfo msrfval msrid @@ -48170,6 +52650,8 @@ mstapst mstar mstate mstaval +mstep +mstfe mstopn mstps mstri @@ -48194,6 +52676,7 @@ msxms msymm msymmetric mtand +mtarray mtbi mtbid mtbii @@ -48211,7 +52694,9 @@ mthmi mthmpps mthmsta mthmval +mthr mti +mtip mtmi mto mtod @@ -48222,11 +52707,19 @@ mtowmopjcw mtpor mtpxor mtr +mtransc mtransitive +mtranst mtrue +mtrunc mtt +mttm +mtvalue mtvisible +mtx mtyf +mtype +mtypes mu-binder much mucl @@ -48398,6 +52891,7 @@ mulexpnegmulsq mulexpnegsq mulexpr mulexpz +mulextp mulf mulfsum mulfunc @@ -48647,9 +53141,12 @@ mult multa multassociative multaux +multc +multcol multcommutative multdistributesoverplusleft multe +multeqpowincurve multexpmin multexpupperbound multfraction @@ -48697,6 +53194,7 @@ multilinearmapcongrright multilinearmaptodual multilog multilogimpl +multimap multinom multinomial multipar @@ -48750,9 +53248,12 @@ multispanindexcoend multispanmapiso multispanshape multispanshapecoend +multitape +multiv multivariable multivariate multivariategaussian +multl multlm multnalsofactor multnc @@ -48760,7 +53261,11 @@ multonerightneutral multp multpf multpos +multpw +multqmodn +multr multrightsuccplus +multrow mults multsum multsupport @@ -48771,6 +53276,7 @@ multvector multw multxy multz +multzero multzerorightzero mulunop mulvaluation @@ -48800,9 +53306,15 @@ mumullem munich munichhtml munion +munitl +munitr +munits muold +mupd +mupdate muplu muplus +mupper murder mus muscadet @@ -48813,6 +53325,7 @@ muspec must must_ mustbestr +mustt mustusebounds musum musumsum @@ -48821,8 +53334,10 @@ mutable mutate mutation mutations +mutator mutes mutex +mutil mutiplicative mutual mutual_recursion @@ -48840,6 +53355,7 @@ muzzle mval mvalel mvalid +mvalue mvar mvarcounter mvarcountersaved @@ -48852,6 +53368,7 @@ mvars mvdco mvdecl mvdecls +mve mvfunctor mvhf mvhfval @@ -48910,10 +53427,13 @@ mvth mvtinf mvtss mvtval +mwb mwe +mweak mweakly mworld mxe +mxi mxidl mxidlidl mxidlirred @@ -48927,7 +53447,9 @@ mxidlnzrb mxidlprm mxidlprmalt mxidlval +mxl mxmsurtfgtzqosjhlmltp +mxs my-lang myclass mycons @@ -48936,6 +53458,8 @@ mydir myeq myequiv myfunlike +myhill +myhillnerode myhom myhomclass myindep @@ -48945,10 +53469,14 @@ mylemma mylinter mymatroid myorderedcollection +mypart myprod myprop +myreveal mystruct mysubobject +myub +mzero mzlist mzpadd mzpaddmpt @@ -48990,12 +53518,14 @@ nabbib nabctnabc nabi nabl +nabla nabled nac nacc nacsacs nacsfg nacsfix +nact nadd naddass naddasslem @@ -49025,6 +53555,7 @@ naddsuc naddunif naddword naddwordnexlem +nae naecoms naertsi naetsi @@ -49035,8 +53566,10 @@ nai naif naim naive +naivernm nalexn nalfal +nall nallowed nalset nam @@ -49045,6 +53578,7 @@ namecheck named namedarg namedict +namedof namegenerator namehashset nameless @@ -49063,6 +53597,7 @@ namespace namespaces namestem namestruct +nameterm naming nan nanan @@ -49080,6 +53615,7 @@ nannan nannot nanor nanorxor +nanoseconds napoleon napp nare @@ -49088,6 +53624,7 @@ narrow narrowed narrowing narrows +narry nary naryfval naryfvalel @@ -49096,6 +53633,7 @@ naryfvalelwrdf naryfvalixp naryrcl nas +nash nat nat+ nat-addition @@ -49108,6 +53646,7 @@ nat_mul_add_max_left nat_mul_add_max_right natabs natabshom +nataction natadd nataddemb nataddmonoid @@ -49120,9 +53659,11 @@ natcard natcast natcastle natceil +natceiling natcl natcoe natcoprime +natd natde natded natdeg @@ -49131,6 +53672,7 @@ natdegr natdegre natdegree natdiv +nate natelim natembedding natembeddingaux @@ -49168,6 +53710,7 @@ natixp natk natl natlem +natleq natlerec natlike natlinear @@ -49183,6 +53726,7 @@ natmod natmodeq natmodule natom +natoms natoppf natoppfb natp @@ -49197,6 +53741,8 @@ natr natrcl nats natsepdegree +natset +natsfrom natsize natsmulwithzero natsub @@ -49252,8 +53798,13 @@ naturaltransforms nature natureconconlybyexistence natval +natxnat +nav nax nba +nbae +nbaei +nbai nbbn nbcplgr nbedgusgr @@ -49283,9 +53834,12 @@ nbior nblem nbn nbommbcriemyhwpicyvjwslyuxvk +nbors +nbound nbovbi nbr nbrne +nbt nbuhgr nbumgr nbumgrvtx @@ -49308,20 +53862,26 @@ ncasesprod ncasessum ncatlab ncbxkfkcaweklvwhknqoqyxrfgwdxrjnxkwbchmekjeonm +ncc ncf +ncheck nchotomy +nck ncl nclasses nclauses nclem +nclinit nclique ncn ncoeff ncolcom +ncollect ncolncol ncolne ncoloee ncolrot +ncols ncoltgdim ncom ncomlem @@ -49330,6 +53890,8 @@ nconcur ncond nconnsubb nconstr +ncontents +ncontmn nconverto ncoprmgcdgt ncoprmgcdne @@ -49337,6 +53899,7 @@ ncoprmlnprm ncs nction nctx +ncut ncvr ncvs ncvsdif @@ -49356,9 +53919,11 @@ ndc ndcctbss ndcdisj ndci +ndcidcaux ndcnv ndcof ndcomap +ndcomm ndconst ndcredom ndcrest @@ -49377,11 +53942,14 @@ ndeq ndeqalt ndeqg ndeqvd +nderiv nderivable +nderivs ndf ndfatafv ndfcl ndfpropd +ndfs ndfunspec ndfval ndg @@ -49394,6 +53962,7 @@ ndinter ndir ndisj ndispatchlemma +ndist ndivides ndivl ndivr @@ -49425,6 +53994,7 @@ ndmovord ndmovordi ndmovrcl ndnpr +ndo ndop ndp ndpreima @@ -49439,6 +54009,7 @@ ndres ndresdju ndresdjuf ndrn +nds ndsubsume ndunion nduonsmixdnoff @@ -49460,17 +54031,29 @@ nearest nearestpt nearestptind nearly +nearring +nearsemiring neat neb nebg nebi +nebinsert nebot nebottophomeomorphreal +nebset +nebsingleton +nec +necddla +necddlp +necess necessarily necessary necessitation necessity necessity_ +necld +neclda +necldp necom necomd necomi @@ -49482,6 +54065,7 @@ need needed needham needing +needle needlessly needn needs @@ -49520,6 +54104,7 @@ negbk negbne negbt negbte +negchecks negcl negcld negcli @@ -49537,6 +54122,7 @@ negdi negdid negdii negdvdsb +nege negel negelrp negelrpd @@ -49577,6 +54163,7 @@ negligible neglimc neglt negmap +negmax negmemclass negmod negmullog @@ -49604,6 +54191,7 @@ negpitopi negpitopissre negpn negpolynomial +negprops negr negreal negreb @@ -49635,6 +54223,8 @@ negsubi negsubsdi negsucc negsunif +negsup +negsups negsval negsym negy @@ -49661,17 +54251,22 @@ neificl neifil neiflim neifval +neigbourhood +neighbd neighbo neighbor neighborfinset neighborhood neighborhoods +neighborhoodx +neighborhoody neighbors neighborset neighborsetfintype neighbour neighbourhood neighbourhoods +neighbours neighbvtx neii neiin @@ -49760,7 +54355,10 @@ nemnf nemnfd nemnftgtmnft nemp +nempty +nemptyi nemtbir +nend neneor neneq neneqd @@ -49775,13 +54373,18 @@ neproof nepss neq neqcomd +neqif neqmnf neqne neqned neqo +neqreturn +neqs nequiv +neqz ner nerabdioph +nerode nerror nerve nerveadjunction @@ -49807,9 +54410,14 @@ net netentropyentourage netentropyinfentourage netfilter +netflow +netgmap nethandler +netlift +netliftl netlimit netmap +netmask netmaxcard netopbotequivreal netopequiv @@ -49819,6 +54427,8 @@ netophomeomorphnnreal netopv netr netree +nets +netsdistinct netstr network networks @@ -49828,9 +54438,14 @@ neufal neukirch neumann neural +neutl neutr neutral neutralconfig +neutrald +neutrali +neutralseller +neutralsellervariant neutre neutru nev @@ -49859,9 +54474,12 @@ newdate newdepth newdoc newe +newelim newentries +newentry neweqname newer +newexit newf newfields newfree @@ -49875,6 +54493,7 @@ newhex newhs newhyps newinfo +newkey newlast newlctx newlem @@ -49888,6 +54507,7 @@ newlockmap newly newman newmctxdepth +newmeta newmvars newname newnames @@ -49897,13 +54517,16 @@ newnod newnode neword newpermmap +newpkt newpos +newquery newrhs newrw news newsize newssno newstack +newstat newstate newstr newstx @@ -49913,6 +54536,7 @@ newtacticname newtail newtailprefix newtext +newthread newthreadperm newthreadpermf newton @@ -49922,6 +54546,7 @@ newtrie newtype newval newvalue +newvar newvarname nex nexaln @@ -49931,6 +54556,7 @@ nexdt nexdv nexdvt nexfal +nexists nexmo nexntru nexple @@ -49947,13 +54573,24 @@ nextden nextdn nextdnpos nextfixed +nextfreeblock +nextfreeblockincreases +nextfreeblockinvariant nextgen nextgen-languages nextindex +nextl +nextloc +nextm +nextmax +nextmem nextnode nextnum nextor nextpattern +nexts +nextss +nextstate nextup nextuppos nezer @@ -49971,6 +54608,7 @@ nfal nfald nfale nfalh +nfall nfalsum nfalt nfaltop @@ -50099,6 +54737,7 @@ nfix nfixp nfixpw nfld +nflow nflsts nfmo nfmod @@ -50123,12 +54762,14 @@ nfnf nfnfc nfnid nfnnftemp +nfnot nfnt nfnth nfntht nfof nfofr nfoi +nfoldli nfop nfopab nfopabd @@ -50137,6 +54778,10 @@ nfopdalt nfoprab nfor nform +nforms +nformsnocontains +nformsstops +nformsterminal nfov nfovd nfp @@ -50234,9 +54879,11 @@ nfxnegd nfxp ngag ngamma +ngba nge ngen nges +nget ngfr nghm nghmcl @@ -50284,6 +54931,7 @@ nhdsadjoint nhdset nhdsge nhdsgt +nhdsin nhdsinv nhdsker nhdsle @@ -50303,11 +54951,15 @@ nhf nhg nhi nhint +nhip nhomo +nhood +nhop nhv nhw nia niabn +niagreement nic nice nicer @@ -50324,9 +54976,11 @@ nil nila nilb nilbv +nild nilelim nilfun nilgrbar +nili nilm nilpot nilpotency @@ -50341,6 +54995,8 @@ nilradical nilrank nilrankaux nilrjl +nils +niltrans nimkb nimn nimnbi @@ -50350,15 +55006,19 @@ nimport nimps nin ninba +nincr nind nindepset nine ninepointcircle +ninf nini ninj ninni ninstab +ninter ninvolution +nip nirenberg nirni nis @@ -50373,12 +55033,14 @@ njhhd njz nla nlab +nlcons nle nlelchi nlelshi nleltd nlem nlemmas +nlength nlfnval nlg nli @@ -50390,7 +55052,15 @@ nlinarith nlinarithextras nlinarithgetproductsproofs nlinarithgetsquareproofs +nlist +nlistlistlcons +nlistlistrcons +nlists +nlisttodigit +nlisttolist +nlisttotree nlit +nlj nlly nllyeq nllyi @@ -50408,6 +55078,7 @@ nlmtlm nlmvscn nlmvscnlem nlo +nlog nlook nloop nlp @@ -50423,6 +55094,7 @@ nltpnft nlyfqxysqyojs nmac nmaep +nmap nmax nmaximum nmbdfnlb @@ -50481,6 +55153,7 @@ nmlnop nmlnopgt nmlnopne nmlnoubi +nmlzd nmmtri nmmul nmmulg @@ -50559,6 +55232,7 @@ nmrpcl nmrtri nms nmsg +nmsort nmsq nmsub nmtri @@ -50685,6 +55359,7 @@ nnfext nnfi nnfim nnfimd +nnfis nnflemaa nnflemae nnflemea @@ -50773,6 +55448,7 @@ nnoeomeqom nnolog nnon nnoni +nnonzero nnord nnorm nnormmimltvnum @@ -50875,20 +55551,28 @@ noa noabt noaccidental noaccpts +noaction +noanno noarg noassn noatoms noattr +noaugpath nobdaymin nobeling nobelingproof +nobigger +noborder +nobot nobotor nobotorder nobotordersentence +nobrk noc nocollision noconfusion noconfusiontype +nocross nocvxmin nocvxminlem nod @@ -50898,19 +55582,28 @@ nodalweight nodd noddaltv node +nodeabs +noded nodei nodense nodenselem +nodeof noderep nodes nodesaux nodeset nodesetbackward nodesetforward +nodesleft +nodesright +nodetodigit +nodetolist nodewithantiquot +nodiag nodivover nodmon nodmord +nodsourcenosource nodu nodup nodupa @@ -50936,8 +55629,14 @@ noextendlt noextendseq noextract nof +nofail +nofaili +nofailt +nofailure +nofi nofnbday nofp +noftlobserver nofun nofv nogen @@ -50946,6 +55645,7 @@ nogroup nogt nohalf noimpl +noin noindex noinds noinfbday @@ -50956,6 +55656,7 @@ noinfep noinfepfnregs noinfepregs noinffv +noinfluence noinfno noinfprefixmo noinfres @@ -50965,12 +55666,15 @@ noise nolesgn nolint nolints +noloc noloops +nolowdps nolt nom nomacobjchange nomacsubchange nomatch +nomatchempty nomax nomaxmo nomaxorder @@ -50981,6 +55685,7 @@ nominally nominmo nominorder nominpos +nomsg nomv non non-contractive @@ -50991,6 +55696,9 @@ non-termination non-transactional non-trivial nonabelian +nonabort +nonaborting +nonagent nonarch nonarchabsval nonarchaddgroupnormclass @@ -51003,6 +55711,8 @@ nonarchimedeangroup nonarchimedeanhomclass nonarchimedeanring nonassoc +nonassociative +nonassociativering nonassocring nonassocsemiring nonassocstarsemiring @@ -51010,10 +55720,13 @@ nonatomic nonautonomous nonb nonbooli +nonbossy nonc noncanonically nonce noncenter +nonces +nonch nonco noncolr noncomm @@ -51024,6 +55737,7 @@ noncommpicoprod noncommpicoprodequiv noncommprod noncommutative +noncomp noncompact noncompactspace noncomputab @@ -51034,6 +55748,7 @@ noncomputably nonconfluence nonconne noncontinuous +noncoprime nondecreasing nondefaults nondeg @@ -51047,14 +55762,23 @@ nondep nondependent nondependentonly nondet +nondeterminism nondeterministic +nondeterministicd +nondett nondiag nondiff nondifferentiable none +noned nonedecidable nonee +noneg +nonegative +nonei nonelalab +nonelem +nonelement nonem nonemojis nonemp @@ -51062,6 +55786,7 @@ nonempt nonempty nonemptychain nonemptycompacts +nonemptyd nonemptydiffeomorphsphere nonemptye nonemptyfinlinord @@ -51072,8 +55797,16 @@ nonemptyimpwitness nonemptyinterval nonemptylimit nonemptyparallelpairpresentationaux +nonemptyset nonemptytheory +nonepty +nonergodic +nonevent +nonex nonexistent +nonfin +nonfinal +nonfinals nonforces nonfull nongenerating @@ -51081,7 +55814,17 @@ nonhomocentric nonhuman nonidentity nonincreasing +noninit +noninitblks +nonint +nonintdfmla noninterference +noninterferencei +noninterferenceintra +nonints +nonintsfmla +nonintsi +nonks nonlift nonlindelof nonlindelofspace @@ -51089,7 +55832,10 @@ nonlinear nonlinearrightinverse nonlinearrightinverseofsurjective nonlinearverismo +nonlocal +nonmanip nonmaximal +nonmember nonmembersubfamily nonn nonne @@ -51100,7 +55846,9 @@ nonnegativepart nonnegativity nonnegg nonneghomclass +nonnegi nonnegligible +nonnegprices nonnegs nonnegspectrumcla nonnegspectrumclass @@ -51108,12 +55856,18 @@ nonnil nonnull nonote nonoverlap +nonpart nonpos nonpositive nonpositivity nonpospart nonpower nonpreadditiveabelian +nonprime +nonprimitive +nonprincipal +nonprincipalinvertleft +nonprincipalinvertright nonprincipals nonprophaves nonreadable @@ -51121,8 +55875,11 @@ nonrec nonref nonrefl nonreflexive +nonregular nonrel nonreservedsymbol +nonsat +nonsatiation nonscopednorlocal nonsense nonseparated @@ -51135,9 +55892,14 @@ nonsingularpointequiv nonsingularpointequivsubtype nonsmall nonspanning +nonsplit +nonspray nonsq nonsquare nonstandard +nonstatic +nonstrict +nonsym nont nonterm nonterminal @@ -51166,6 +55928,7 @@ nontrivialpsumunique nontrivialsemiring nontrivialstar nontrivialtopology +nonuniform nonuniforms nonuniformwitness nonuniformwitnesses @@ -51230,6 +55993,7 @@ nonunitalsubsemiringmap nonunits nonunitsorderembedding nonvanishing +nonword nonz nonze nonzeno @@ -51242,34 +56006,49 @@ nonzerodivisorsequivunits nonzerodivisorsleft nonzerodivisorsright nonzeroequivprojectivizationprodunits +nonzeroindex +nonzeron nonzeroness nonzerop +nonzeros nonzerosemiring nonzerosmuldivisors nonzerosubmul +noop noorder +noout nop +noph noposoycle noposoycleauto noprc +nopt nor noran norass norasslem norbi norcom +nord nordeq +nordo +noread +noreadorwrite norec norecdiv noreceuw norecfn norecov norepet +noreps +noreq noresle noreson +norest norm norm_cast norm_num +norma normaddgroupnorm normaddgroupseminorm normal @@ -51291,9 +56070,11 @@ normali normalisation normalise normalised +normalisedd normalising normality normaliz +normalizability normalization normalizationcoprodiso normalizationdesc @@ -51343,6 +56124,7 @@ normalizermonoidhom normalizeunitiso normalizing normally +normalmodel normalmono normalmonocategory normalmonoidalobject @@ -51369,6 +56151,7 @@ normcl normcli normcomp normcv +normd norme normed normeda @@ -51430,6 +56213,8 @@ normgt normh normhom normhomcompsub +normi +normif normintnumeral norml normleiff @@ -51481,6 +56266,8 @@ normz normzm norn nornot +noroot +noroplus noror norp north @@ -51515,7 +56302,11 @@ noseqsuc nosgnn nosimp nosimpl +nosmallestcounterexample nospacer +nostate +nostatechange +nostatediff nosupbday nosupbnd nosupcbv @@ -51536,6 +56327,7 @@ notably notabw notafter notalbii +notaninput notation notational notationclassattr @@ -51549,46 +56341,63 @@ notbicom notbid notbii notbinot +notclass notclxf notcol notcomparable notconvergentseq notconvergentseqltindex +notd notdalle notdefeq notdexe notdividesdigit +notdsource note noted noteeexists +notelem +notempty +notemptyi noteq noteqlt +noteqs +noteqtr notequal notequali notes +notevalmodel +notevcontainsbothatoms notexists notf notfal +notfin notfollowedby notforces notgfn nothing +noti notice noticeably noticed +notimeout notin notinarraylookupnone notindomisund notindomisundef notinemptyset +notinf noting notinitial +notinjective notinself +notinset notinsingleton notint notion notions notiso +notl notleader notless notlinearindependent @@ -51598,7 +56407,9 @@ notltimpliesgte notm notme notmem +notmembership notmemrangeequiv +notnil notnilrec notnorm notnot @@ -51612,29 +56423,41 @@ notnotrd notnotri notnotrialt notnottrue +notok notone notoporder notopordersentence notornotel notpowercertificate notpresent +notprimepow +notr notrab notrecursive notreduced notrivialcomponent notrsym nots +notsource +notsqsubseteq +notstarted +notsubset notsubseti +notterminalnforms +notterminalnotsataxiom notticks nottru notval +notword notzerodivisor notzfaus notzmultzero nouvx +noval novel now nowhere +nowit nown nows noxp @@ -51642,11 +56465,13 @@ noxpordfr noxpordpo noxpordpred noxpordse +noyau noz nozero nozerodivisors nozerosmuldivisors npa +npc npcan npcand npcans @@ -51657,10 +56482,13 @@ npf npfaisrncytgfgl nphard npi +npk nplus +npn npncan npncand npnf +npolyhcn npomex npos nposznnd @@ -51673,11 +56501,14 @@ nppcan nppcand npqs npr +npre +npreflow nprm nprmdvds nprmfac nprmge nprmi +nproc nproduct nproperty nprrel @@ -51690,12 +56521,14 @@ nqerf nqerid nqerrel nqex +nqfree nqg nqpr nqt nra nrc nrcomplexplaces +nrcons nrcustomprojections nre nrefutable @@ -51707,6 +56540,8 @@ nregmodellem nrelv nremaining nres +nrest +nreturn nreu nreurex nrex @@ -51751,8 +56586,16 @@ nrs nrt nruiev nsa +nsappend nsb +nsbind +nsc nsearch +nsempty +nsend +nset +nsets +nsettr nsg nsgacs nsgbi @@ -51768,12 +56611,20 @@ nsgrplem nsgsimpgd nsgsubg nsgtrivd +nslexord +nslexordeqp +nslexordp +nslexordpe +nslexordpi +nslexordrec +nslookup nsm nsmallnq nsmndex nsmul nsmuladdmonoidhom nsmulargs +nsmulextp nsmulmemclass nsmulrec nsmulsaturated @@ -51787,6 +56638,8 @@ nspecial nsphere nsq nsr +nsrcof +nsrcoftrfrom nss nssd nssdmovg @@ -51799,7 +56652,15 @@ nsssmfmbflem nssss nsstr nst +nstart +nstep +nstepperm +nsteps nstill +nstore +nstri +nstrict +nstutinv nsub nsubkc nsuceq @@ -51808,15 +56669,23 @@ nsyl nsyld nsyli ntbase +ntc ntcatdom +ntcf ntcod +ntd nterm +nterms +ntgtof +ntgtoftrfrom nth nth_append nth_butlast nth_mem +nthb nthcdr nthconstructor +nthd nthe nthhom nthhomseq @@ -51830,8 +56699,13 @@ nthruc nthrucw nthruz nths +nthtriple +ntimes +ntm +ntmap nto ntop +ntou ntpp ntr ntrcls @@ -51891,7 +56765,11 @@ ntrtop ntrufal ntruni ntrval +nts +ntsof +ntsofgamma ntstep +ntt ntu ntzer nub @@ -51903,12 +56781,15 @@ nuleldmp nuliota nuliotaalt null +nullable +nullablesym nulladdsubgroup nullbdry nulldiff nullhomotopic nullhomotopicmap nullhomotopy +nullity nullkind nullm nullmeasur @@ -51917,11 +56798,14 @@ nullmeasurable nullmeasurablese nullmeasurableset nullmeasurablespace +nullpointer nullset nullspace nullstellensatz +nullstrict nullsubgroup nullsubmodule +nullt nullval nulmbl nulmo @@ -51939,10 +56823,12 @@ numberedmap numbererrorfiles numberfield numbering +numberofisbeschr numbers numberstream numbertheory numbertheorysymbols +numblocks numbound numcert numchars @@ -52000,6 +56886,7 @@ numnncl numnodes numofgt numonlyb +numpair numparams numrules nums @@ -52011,20 +56898,28 @@ numsucc numth numthcor numufl +numvals +numvars numvarying numwdom nun nuprl nurse +nuse nusnrpjhewtpsadetusmctyp nutitionist nuttin +nux nuz nvablo nvabs nvadd nvaddsub nval +nvalidtrans +nvalidtranse +nvalidv +nvalidve nvalue nvars nvass @@ -52052,6 +56947,8 @@ nvi nvimp nvinv nvinvfval +nvl +nvli nvlinv nvm nvmcl @@ -52099,6 +56996,7 @@ nwdopackets nwdostate nweig nweight +nwindows nwith nwnw nworkaround @@ -52109,6 +57007,9 @@ nws nwstate nxmi nxsxbhs +nxt +nxtact +nxtactive nxxuroevediokvvvzib nyou nza @@ -52154,6 +57055,7 @@ oabexg oabexgold oabove oabs +oabstfn oacan oacgr oacl @@ -52184,6 +57086,8 @@ oaordnrex oap oapp oarec +oarrivemsg +oassert oasubex oasuc oatom @@ -52215,7 +57119,9 @@ objdown obje objec object +objecte objectfoundinlocation +objecti objective objectiverow objectof @@ -52224,7 +57130,9 @@ objectprop objectproperty objects objectsc +objectscountermodel objecttosort +objecttype objectwise objeq objeqtohom @@ -52232,9 +57140,11 @@ objequiv objequivsections objext objfobjsucciso +obji objisinitial objiso objisopt +objloc objmap objmk objmkiso @@ -52247,9 +57157,11 @@ objpreimage objs objsucciso objsupisoprodeqlocus +objt objtype objtypeeq objup +objv objx obl obligation @@ -52271,19 +57183,27 @@ obs obselocv obseq observable +observables +observation observational +observations observe observed observes observing +obsf +obsfi +obsi obsip obsipid +obsl obslbs obsne obsocv obsolete obsrcl obsss +obsv obt obta obtai @@ -52314,6 +57234,7 @@ occon occqhfwoyhaaecwxnojumqyg occs occur +occurence occuring occurred occurrence @@ -52321,12 +57242,21 @@ occurrences occurring occurs occurs-check +occurssec +occurssectype ocel och oci ocid ocin ocl +ocland +oclany +oclastype +oclimplies +oclnot +oclor +oclvoid oclwwlkn oclwwlknlem ocndx @@ -52367,6 +57297,7 @@ ocsqrt ocss octahedron octb +octo octonions ocv ocval @@ -52417,8 +57348,11 @@ oddnn oddnumth oddopp oddp +oddpart oddplus oddplusinv +oddprime +oddprimedivisor oddprm oddprmaltv oddprmdvds @@ -52442,6 +57376,8 @@ oddz ode odegree odeq +oder +odes odf odfval odfvalalt @@ -52456,6 +57392,7 @@ odistinct odivide odkdonztkkxblctqfzfbqzbbuyutkxb odlem +odlist odm odmod odmodnn @@ -52471,6 +57408,7 @@ odnwpackets odnwstate odom odory +odot odpmco odrngbas odrngds @@ -52545,6 +57483,7 @@ oesuclem oev oevalc oevaln +oevents oevn oeword oeworde @@ -52552,6 +57491,7 @@ oewordi oewordri oex oexbi +oexp oexpled oexpneg oexpnegaltv @@ -52728,6 +57668,7 @@ ofcs ofcurried ofcustominfo ofcval +ofd ofdeglex ofdense ofderivation @@ -52750,12 +57691,14 @@ ofdivdiv ofdivrec ofdomain ofdual +ofe ofedistoftopology ofelement ofenat ofenathom ofencodableofinfinite ofendhom +ofentry ofepi ofepimonofactorisation ofepiofisisoofmono @@ -52788,6 +57731,8 @@ offactorizationdata offaithful offan offdiag +offedning +offending offer offered offering @@ -52835,6 +57780,7 @@ offreegroupequiv offreemonoid offres offromspecstalk +offs offset offsetby offsetmap @@ -52880,6 +57826,7 @@ ofhomotopycategory ofhoms ofhomunique ofhxf +ofi oficc ofici ofid @@ -53057,6 +58004,7 @@ ofmpteq ofmres ofmresex ofmresval +ofms ofmu ofmul ofmulaction @@ -53257,6 +58205,7 @@ ofsimplexprod ofsingleton ofsize ofsl +ofsm ofsmulle ofsnowflaking ofsnum @@ -53380,6 +58329,7 @@ ofznum ofπ oge ogetlocs +oghoare ogii ogrp ogrpaddlt @@ -53391,9 +58341,11 @@ ogrpinv ogrpinvlt ogrpsub ogrpsublt +ogs oguawlxk ohalf ohead +ohearn ohoare ohom ohomfval @@ -53404,23 +58356,29 @@ oibabs oicl oid oidb +oids oien oieq oieu oiexg oif +oiface oii oiid oiiniseg oiiso +oil oim oimage oindi +oinitial oinsert oinvd oinverse +oinvr oiold oion +oip oirrefl oismo oiso @@ -53429,6 +58387,8 @@ oiugwrq ojz oka okay +okclocks +okmaxsync okmdwd okniński olast @@ -53440,10 +58400,13 @@ olcs old oldbday oldbdayim +oldbisimbisimeq oldconfig oldcumulimps olddate +olddefs olde +older oldf oldfi oldfib @@ -53471,6 +58434,7 @@ oldssno oldsuc oldtactickind oldtacticname +olduses oldval ole olean @@ -53478,8 +58442,10 @@ oleast olecpbl olem oless +olf olgbttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttchttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttunahiphttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttqbddsfihnttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttvrtettttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttyvksqyviqasqtttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttthdeettttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttvsttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttfgltttttttttttttttttttttttttttttttttttttttttttt olim +olimit olin olist olisto @@ -53550,6 +58516,7 @@ omhf omhfb omhfbregs omhnpupbwgwaxsmdfu +omi omin omina ominf @@ -53605,6 +58572,7 @@ ompt omptsn omptsnlem omregs +omru oms omscl omsf @@ -53647,9 +58615,11 @@ oncard oncardid oncardval once +oncone oncutleft oncutlt oncyclefactors +ond ondiag ondif ondomen @@ -53662,13 +58632,17 @@ one_tropical one_tropical_def one_tropical_min one_tropical_min_def +onea onebits +onec onecoch onecochain onecochainoftwosplitting onecocycle onecohomologyrelation +onedim onedimension +oneelementsetcharacterization oneembedding oneembeddingequiv oneembeddingmap @@ -53683,6 +58657,7 @@ onehypercover onehypercoverdensedata onehypercoverfamily oneispoly +onel onele onelepart oneli @@ -53727,6 +58702,7 @@ ones oneself oneside onestep +onestepperm onesub onesuc onet @@ -53757,8 +58733,10 @@ onfun onfunction onfununi onhighestnode +oni onil onin +onindices oninfcl oninfex oninfint @@ -53786,6 +58764,10 @@ onlts onltsd only onlygoal +onlygoodsallocated +onlygoodsareallocated +onlygoodsareallocatedauxiliary +onlygoodsaresold onlyondefeqnodes onlyone onmaxnelsup @@ -53811,6 +58793,7 @@ onnoxpg onnoxpi onnseq onomeneq +onord onordi onorm onote @@ -53826,6 +58809,7 @@ onpsstopbas onpwsuc onquot onquotval +onregularcone onrelation ons onsbnd @@ -53895,6 +58879,7 @@ ontgsucval ontgval ontheory onto +ontology ontopbas ontr ontrace @@ -53918,12 +58903,14 @@ onwf onwpackets onwstate onxpdisj +onxt onzohzdbwceudtdaejnpgzpvuaroezalhdjkosuwuctxqskeniwblkgvrbaygzrfowxalhmxqwjmykncjziahqacttqvelmgblmnkvrot onzsl oocak oof ooffset oone +ooo ooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo oooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo oopb @@ -53971,6 +58958,10 @@ opargs opb opbrop opc +opcatcat +opcatcatax +opcatcatext +opcatopcat opccdqywzomvjaavidxf opco opcom @@ -54050,6 +59041,8 @@ opelxpi opelxpii open openaddsubgroup +openbya +openbyf opencell openclassic openclassical @@ -54070,6 +59063,8 @@ opendecls opened openembedding openfile +openi +openin openind openintervals openmap @@ -54114,6 +59109,7 @@ opentheory opentheorymap opentolocalization openv +openz opeo opeoaltv opepi @@ -54358,6 +59354,7 @@ opposite oppositeequivalence oppositeleftaction oppositelemmas +oppositeliterallist oppositemoduleembedding oppositequandle oppositerightaction @@ -54411,6 +59408,8 @@ opprval opptgdim oppu oppv +oppx +oppy oppz oppzk opq @@ -54443,6 +59442,7 @@ oprssdm oprssov oprswap ops +opsa opsbc opsc opsh @@ -54493,6 +59493,7 @@ opthprneg opthreg opthwiener opti +optia optid optim optimal @@ -54505,6 +59506,7 @@ optimisation optimistic optimization optimize +optimum option optional optionally @@ -54556,6 +59558,7 @@ orab orabs oracle oraclecomp +oraclei oraclekind oraclemap oran @@ -54570,6 +59573,8 @@ orbf orbi orbidi orbit +orbital +orbitali orbitcl orbitclmpt orbitequivquotientstabilizer @@ -54582,12 +59587,14 @@ orbitrelequiv orbits orbitzmultiplesequiv orbitzpowersequiv +orbs orbsta orbstafun orbstaval orbt orc orcanai +orcc orcd orci orcis @@ -54600,6 +59607,8 @@ orcomdd orcoms orcs ord +orda +ordb ordcmp ordco ordcompl @@ -54629,6 +59638,7 @@ ordequn order order_bot order_top +orderable orderaddmonoidequiv orderaddmonoidhom orderaddmonoidiso @@ -54640,8 +59650,10 @@ orderclass orderclosedtopology ordercore ordercoreimp +orderd orderdual orderdualequivalence +ordere ordered orderedaddcommgroup orderedaddcommgroupwithone @@ -54752,6 +59764,9 @@ orders orderseqlem orderstructure ordersucc +ordertheoreticjoinsemilattice +ordertheoreticlattice +ordertheoreticmeetsemilattice ordertop ordertopofhasterminal ordertopol @@ -54797,6 +59812,7 @@ ordintdif ordir ordirr ordiso +ordleq ordmonoidwithzerohom ordn ordnbtwn @@ -54823,6 +59839,8 @@ ordsssuc ordsssucb ordsssucim ordssun +ordst +ordstns ordsuc ordsucc ordsucelsuc @@ -54832,6 +59850,7 @@ ordsucsssuc ordsucun ordsucuni ordsucuniel +ordsum ordt ordtbas ordtbaslem @@ -54880,9 +59899,12 @@ ordvdsmul ordwe ordzsl ore +oreach oreal orec orecondition +orecvmsg +orecvmsgei oredenom orediv oredivaddchar @@ -54924,6 +59946,8 @@ orge orgvd ori oridm +orient +orientable orientation orientationvector oriented @@ -54973,6 +59997,7 @@ orop orordi orordir orp +orphan orphaned orr orrabdioph @@ -54985,6 +60010,7 @@ orrvccel orrvcoel orrvcval orrx +ors orsild orsird ort @@ -54998,6 +60024,8 @@ orthocenter orthocentre orthocentric orthocentricsystem +orthocompl +orthog orthogon orthogonal orthogonalbilin @@ -55035,6 +60063,7 @@ orxcslklti orxorb orzechproperty orzero +osafe osauiadtkjsem osc osceq @@ -55044,14 +60073,19 @@ oscstat oscstatpcp oscstatpsp oscstatpss +ose osemilattice osetex osetlocs +osig oskip +osl +oslash osmult osn osng osomme +ospec osqrt oss ossf @@ -55063,6 +60097,7 @@ ostth ostthlem osubseq osuc +osucc osum osumcllem osumcln @@ -55079,11 +60114,15 @@ oterm otex othe other +otherd othermap +othernats others +othersd othervertexofincident otherwise othin +othogonal otimes otiunsndisj otiunsndisjx @@ -55110,25 +60149,35 @@ ottpos ouctuitvlkowhtemrpqxucjbftmih oudbjnobkq ought +oul +oull ouminus oun ounsn oupdate +ouput our ourselves out out-of-bounds +outarc +outarcs outclm outcome +outcomes outcompetes outer outerfiveseg +outerfriendids outerfullyfaithful outermeasure outermeasureclass outermost outerplanar +outerr outerregular +outflow +outfromv outgoing outidx outidxexpr @@ -55137,12 +60186,16 @@ outline outlined outmeas outmkequiv +outof outofmemory outp outparam outpasch +outports +outportsrule output outputalphabet +outputempy outputmessage outputr outputs @@ -55151,6 +60204,11 @@ outputsintime outputting outrelembedding outs +outsetcorelated +outsetcorelatedempty +outsetcorelatednonemptyx +outsetofcomponents +outsetofcomponentslimit outside outsidele outsidene @@ -55162,6 +60220,9 @@ outsideofeu outsideofrflx outsideoftr outsidepart +outsideregularcone +outsp +ouu oval ovanraleqv ovconst @@ -55178,6 +60239,8 @@ oveqrspc over overall overapplied +overapprox +overapproximated overapproximates overarrows overclass @@ -55197,6 +60260,7 @@ overgrothendiecktopology overhead overlap overlapping +overlaps overlapstemporally overlay overlayed @@ -55237,6 +60301,7 @@ ovif ovig ovigg ovima +ovl ovmpo ovmpoa ovmpod @@ -55341,11 +60406,14 @@ owev owhile owl own +owned owner ownerclose ownerp ownership owns +ownsd +owo owp owt oxhacqxnokmewkt @@ -55363,12 +60431,14 @@ ozfuodurlgwfvamjqhs ozrpzvheidyb paa pab +pabr pac pace pacipfsvw pack package packaged +packed packet packets packing @@ -55377,6 +60447,7 @@ packingradius packkeyedpred paco pad +padboth padct padd paddass @@ -55423,6 +60494,7 @@ padicvalnat padicvalrat padicvalua padicvaluation +padleft padright padwidth paesqwwkb @@ -55445,7 +60517,10 @@ pagexiso pagexisoofeq pai paid +paidaa +paidanm painful +paint painting pair paircomp @@ -55455,6 +60530,7 @@ paireqne pairequiv pairf pairfunction +pairi pairing pairingcore pairingdual @@ -55464,10 +60540,13 @@ pairk pairmap pairreueq pairs +pairsd pairselfadjointmatricessubmodule pairsep pairset pairsetseq +pairsi +pairsof pairup pairw pairwis @@ -55476,12 +60555,14 @@ pairwisecases pairwisecoconeiso pairwisediagramiso pairwisedisjoint +pairwisedisjointallocations pairwisenode pairwisetoopenslecover pairwisetoopenslecovermap pairwisetoopenslecoverobj pal palatable +paley palindrome panel panel-access @@ -55493,7 +60574,14 @@ panelwidgetprops panic panics panll +paodv paper +paperid +paperidasstr +paperids +papid +papidsofrole +papp pappack par para @@ -55515,6 +60603,7 @@ parallelcomp parallelepiped parallelex parallelfamily +parallelise parallelised parallelism parallelogram @@ -55533,12 +60622,15 @@ parallelpairisoparallelpaircompyoneda parallelpairopiso parallelprod parallelrec +parallelruleann parallelscan parallelscanaux param param_name param_type paramcls +paramdefs +paramdefse parameter parameterised parameters @@ -55554,11 +60646,15 @@ paramodulation params paramset paramsstructure +paramuses parcs pardord pare paren +parens +parensifspace parent +parentdag parentdecl parentheses parenthesis @@ -55568,16 +60664,20 @@ parentinfo parentngen parentprojdata parentprojs +parents parenttag +pareto paretocdf paretomeasure paretopdf paretopdfreal parg pargs +parikh paris parity parl +parof parr parse parsearrows @@ -55599,12 +60699,15 @@ parseline parselrat parsenat parsenats +parseq parser parsercategory parserdescr +parsere parseresult parserextension parserfn +parseri parsers parserstate parses @@ -55614,14 +60717,17 @@ parsesuggestiontotactic parseuptohere parseval parsing +parstar part partbind partc partden partdenom partdens +partdom partenat parteq +parteval partfun partfunc parti @@ -55639,6 +60745,7 @@ partialfuntopointed partialgamma partialinv partialiso +partiality partialleftadjoint partialleftadjointhomequiv partialleftadjointmap @@ -55667,6 +60774,7 @@ partialrightadjointhomequiv partialrightadjointmap partialrightadjointobj partialrightadjointsource +partialsa partialsections partialsucc partialsum @@ -55680,23 +60788,33 @@ parties partim partimcomember partimeq +partips partiti partition partitionable partitionbytypeidx partitionfiltration partitioning +partitioningips partitionm partitionofunity partitionpoint partitions +partitionsi +partitionsums +partitionsumswith +partitition +partlist partmap +partn +partner partnum partnums partofvertex partord partordemb partpreservingequiv +partrace partrec parts partscardle @@ -55712,7 +60830,10 @@ pasch pass passed passes +passign passing +passive +passwd password past paste @@ -55747,6 +60868,7 @@ path_weight_join path_weight_join_list path_weight_star_eq_concat path_weight_star_le +pathauthorization pathcast pathcomponent pathcomponentin @@ -55758,22 +60880,29 @@ pathconnected pathconnectedspace pathdestleft pathdestright +pathe pathelength pathequivlist pathexists pathextend pathfinish pathgraph +pathissymboliclink +pathle +pathlist pathobject pathological pathologicprocess pathoperations pathp +pathree paths +pathsd pathseparator pathsequiv pathsetoid pathshomrel +pathsi pathsof pathson pathstar @@ -55781,7 +60910,10 @@ pathstart pathtofield pathtolist pathtostx +pathvertices patient +patom +patoms patproof patricide patris @@ -55794,22 +60926,32 @@ patterns patts pauillac paul +pause +pauses pautsetn +paval +pax paxos pay paying +payload payment payoff paysd pbadd pbar +pbasepoint pbb pbbuild pbc pbcode pbcompute +pbd +pbernpoly +pbeta pbfree pbgen +pbij pbind pbiso pbj @@ -55821,14 +60963,17 @@ pbo pbody pboole pbot +pbqs pbrepr pbright pbtree pbuchf +pbval pca pcabs pcadd pcaddlem +pcall pcancel pcbc pcbcctr @@ -55874,16 +61019,19 @@ pcmptdvds pcmul pcndvds pcneg +pcnf pcnt pco pcoass pcocn +pcof pcofval pcohtpy pcohtpylem pcomap pcomp pcompare +pcompose pcompset pconn pconncn @@ -55900,9 +61048,14 @@ pcoptcl pcorev pcorevcl pcorevlem +pcorres +pcorresd +pcorresi +pcounter pcoval pcovalg pcp +pcpo pcpre pcprecl pcpremul @@ -55917,6 +61070,7 @@ pcr pcrec pcross pcs +pcss pctx pctxd pcval @@ -55929,23 +61083,38 @@ pczcl pczdvds pczndvds pczpre +pda pdata +pddl pdec pdeg pdeglt pden pderiv +pderivs +pders +pdeterm +pdevs pdf pdfs +pdg +pdifference pdir pdiv pdivbound +pdivides pdivl pdivless +pdivmod pdivr +pdo pdom +pdouble +pdpe pds pdst +pdt +pdvd pdvds pdvdxy peak @@ -55954,6 +61123,7 @@ peanonat peanosinj peanuts peculiar +ped pedges peek peel @@ -55999,20 +61169,27 @@ pend pendack pending pendingactionablesynthmvar +pendingd +pendingfreqs pendingmvars pendingmvarssaved +pendingureqs +pendulum penrose penrosediagram penrosevar pentagon pentagoniso penultimate +penv people pepin pepsi peq peqb pequiv +pequivd +pequivi pequivon pequivonglue pequivonlim @@ -56072,12 +61249,15 @@ permaxsep permaxun permcongr permcongrhom +permd perme permexpr permfailures permgoal permgroup +permi perminstructions +permissible permissive permissivesuccessapps permit @@ -56111,6 +61291,7 @@ permuted permutedmv permuteexpr permutes +permutesi permutesingle permuteuniv permuting @@ -56127,6 +61308,8 @@ perpg perpln perpneq perprag +perron +pers persist persistent persistentarray @@ -56135,9 +61318,11 @@ persistfvars persists person personal +perspective pertaining perturbations pes +pessib pet peter peters @@ -56160,6 +61345,7 @@ peu peuqusdeg peval peven +pex pexmidaltn pexmidlem pexmidn @@ -56169,6 +61355,7 @@ pfb pfc pfci pfcj +pfd pfenning pff pffi @@ -56177,9 +61364,15 @@ pfg pfgh pfi pfilter +pfinpref pfj +pflat pfn pfnfhzo +pfp +pfrag +pfragment +pfresh pfs pftps pfty @@ -56206,6 +61399,7 @@ pfxid pfxlen pfxlsw pfxlswccat +pfxm pfxmpt pfxn pfxnd @@ -56222,6 +61416,7 @@ pfxtrcfvl pfxval pfxwlk pfxwrdsymb +pgc pge pgind pgindlem @@ -56232,6 +61427,7 @@ pgjsgr pgl pglem pgm +pgms pgn pgnbgreunbgr pgnbgreunbgrlem @@ -56251,8 +61447,11 @@ pgrple pgrpsubgsymg pgrpsubgsymgbi pgtable +pgte +pgwt phabet phant +phantom phase phase-access phase-context @@ -56261,21 +61460,34 @@ phases phashset phclm pheadidx +pheap phhluvsgfql phi +phiarg phibnd phibndlem phicl phicld +phidef +phidefnode +phidefnodes +phidefnodesi +phidefs +phil philo phils phimul phimullem +phiplus phiprm phiprmpw phis phisum phival +phiwhilep +phiwhilepmonotone +phiwhilepop +phl phlbase phlip phlipf @@ -56324,6 +61536,7 @@ phtpyid phy physical physics +phytagorean pi pi-elim pi-form @@ -56344,6 +61557,8 @@ picardgroup pichartedspace pick picked +pickeff +pickfreshs pickin picking pickinsetp @@ -56369,10 +61584,13 @@ picountable picture picurry pid +pidem +pidgeonhole pidiag pidiv pidlnz pidlnzb +pidn pids pidufd pie @@ -56382,6 +61600,8 @@ piecewi piecewise piecewisele piecewiseleofeq +pied +piei pientka piequiv piequivalencefunctordiscrete @@ -56412,6 +61632,7 @@ pifintwoiso pifintype pifunctor pify +pig pige pigeon pigeonhole @@ -56466,16 +61687,20 @@ pimltpnf pimltpnff pimono pimorph +pimp pimrecltneg pimrecltpos pimulopposite pimulsingle pimultiplicative pimxrneun +pin pinat pinatembed pincerrecursion +pinch pind +pinduct pine pinf pinfo @@ -56510,6 +61735,7 @@ pipiiso pipos pipremeasure piprod +piq piquotequiv piquotientequiv piquotientlift @@ -56550,6 +61776,7 @@ pitype piunique piunits pivot +pivotal pivotbetree pivotbetreerefinement pivotbranch @@ -56688,6 +61915,7 @@ pjtoi pjval pjvec pjvi +pkcs pkg pks pkt @@ -56713,6 +61941,7 @@ planetmath planned planner planning +plans plant plasmodial plat @@ -56758,10 +61987,13 @@ plift plig pliguhgr plimit +pll +plm plmhm plord plordisom plordso +plossless plot plotkin plots @@ -56772,6 +62004,7 @@ pls plt pltfval pltirr +pltl pltle pltletr pltn @@ -56780,13 +62013,17 @@ pltnle pltnlt plttr pltval +plu plucker +plucking pluennecke plug +plugged plugin plugins plumbing plump +plurality plus plus_tropical plus_tropical_def @@ -56801,6 +62038,7 @@ pluscn pluscommutative pluscomp pluscompiso +plusd pluse pluserrorbound plusexact @@ -56825,6 +62063,7 @@ plusgndx plusgndxnmulrndx plusgndxnn plusgpropd +plusi plusl pluslift plusltemonotone @@ -56832,6 +62071,7 @@ plusltemonotoneleft plusltemonotoneright plusm plusmap +plusminus plusminuslte plusmod plusobj @@ -56844,10 +62084,12 @@ plusplusisosheafify plusplussheaf plusplussheafisopresheaftosheaf plusr +pluss plussuccrightsucc plusterm plusterml plustermr +plusu plusupperbound plusvector plusw @@ -56944,6 +62186,8 @@ pmatscmxcl pmatval pmatvalel pmcopy +pmdl +pmdli pmeas pmeasadd pmeasmono @@ -57009,6 +62253,7 @@ pmtrsn pmtrsp pmtrto pmtrval +pmu pmul pmult pmvalg @@ -57047,15 +62292,18 @@ pnfnlt pnfnre pnfval pnfxr +pnil pnilradical pnncan pnncand pnncani pnonsingn +pnorm pnormal pnp pnpcan pnpcand +pnplus pnpncand pnrm pnrmcld @@ -57066,6 +62314,7 @@ pns pnt pntibnd pntibndlem +pntimes pntlem pntlema pntlemb @@ -57093,6 +62342,7 @@ pntrsumo pntrval pntsf pntsval +pnu pnum pnumargs pnunit @@ -57101,6 +62351,7 @@ po-0000 po-0001 po-nnnn pochhammer +pocket pockthg pockthi pockthlem @@ -57110,15 +62361,21 @@ pod podd poeq pofun +pohjola poimir poimirlem poinca +poincare +poincaredisc +poincaredisce +poincarediscm point pointbot pointbotfunctor pointbotpresheaffiberiso pointclass pointcount +pointd pointderivation pointed pointedcone @@ -57159,6 +62416,7 @@ pointsequivirreduciblecloseds pointsetn pointsgrothendiecktopology pointspi +pointsto pointswith pointswithcircumcenter pointswithcircumcenterindex @@ -57217,6 +62475,7 @@ polar polarbilin polarcoord polarcoordreal +polarity polarization polarizationequiv polarizationin @@ -57246,6 +62505,7 @@ poll poln polpmapn polr +polref pols polssatn polssn @@ -57255,20 +62515,31 @@ poltletr polval polvaln poly +polyadd polyap polybinomaux +polybound polyc polycharpoly polycharpolyaux polyequivtensor +polyexp +polyf +polyfun +polygamma polygon +polygonal polyhedra polyhedral polyhedron +polyi +polylog polymatroid polymorphic polymorphism polyn +polynate +polyneg polyno polynom polynomi @@ -57291,11 +62562,17 @@ polynomialz polynormablespace polyofinterest polyorb +polypoly +polypow polyrank polyrith +polys polyset +polysub +polysubst polytomatrix polytope +polyul poml pomults ponens @@ -57304,11 +62581,13 @@ poni pont pontryagindual pool +poolrunner poor pop popcycles popcyclesiso popcyclesnattrans +popelim popl poprelb populated @@ -57326,6 +62605,7 @@ porting portion portland portmanteau +ports pos posa posasymb @@ -57333,6 +62613,7 @@ posb posbezout posconfigitem posconvolution +posd posdef posdif posdifd @@ -57362,6 +62643,7 @@ positive positivecompacts positivecone positivelinearmap +positively positivemap positiveorientation positiveqtint @@ -57372,9 +62654,11 @@ positivity positivitycanon positivityext positn +posix posjidm posk poslog +poslsts poslubd poslubdg poslubmo @@ -57395,11 +62679,15 @@ posnex posnormmin posnum posnumcoe +posord +posordeq posoz posp pospart pospo pospropd +pospropertiesnecexist +posprops posprs posqsqznn posrasymb @@ -57409,10 +62697,16 @@ posref posrootform poss possemidef +posseximpliesnecex +possexistenceimpliesnecex possibilities possibility possible +possibled +possibleworld possibly +possit +possl possmu possmulmono possmulreflectle @@ -57423,6 +62717,8 @@ possubgroup possubmonoid possumd possumofencodable +possworld +possworldaux post post-commit post-fixpoint @@ -57454,15 +62750,25 @@ postcomposition postcompositions postcomppostcompiso postcompuniformconvergenceclm +postcomputation +postcond postcondition postcongr postcpos postcposalt postdefault +postdominate +postdominates +postdomination +postdominator postequiv posterior postfix +postfixpoint posti +postid +postidasstr +postids postinfo postiso postisomap @@ -57482,6 +62788,7 @@ posture posz poszd poszm +pot potableliquid potential potentially @@ -57539,9 +62846,13 @@ powersetsubset powersett powersette powersetti +powersetup powershom powersmulhom powersum +powh +powi +powind powinstances powissubgroup powlogequiv @@ -57557,12 +62868,19 @@ powquot powquotpowsuccequivmapmkpowsuccpow powquotpowsucclinearequivmapmkpowsuccpow powquotsuccinclusion +powr +powrat +powreal +powrs powsaturated +powser powsubpowfactor +powsum powzero poxp ppa ppal +ppath ppatt ppb ppc @@ -57576,8 +62894,10 @@ ppcr ppdedentifgrouped ppdomain ppescalations +ppeval ppexpr ppexprtagged +ppf ppgoal ppgroup ppi @@ -57600,8 +62920,11 @@ ppiwordi pplevel ppncan ppncand +ppoint pporigin +ppos ppow +ppp ppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppp pppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppp ppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppp @@ -57609,6 +62932,7 @@ pppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppp ppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppp ppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppp pppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppp +ppre ppred ppreda ppredb @@ -57626,14 +62950,19 @@ pprodequivprodplift pprodmap pprodprod pprodss +pprogress pproundtrip pps +ppsc +ppsd +ppsi ppspace pptactic pptbas ppttop ppty pptypes +ppv ppw ppybichc pqklijku @@ -57647,6 +62976,7 @@ pra practically practice praeclarum +pratt prb prc prcdnq @@ -57752,20 +63082,27 @@ preadditivehaszeromorphisms preadditiveyoneda preadditiveyonedamap preadditiveyonedaobj +preal prealeph +preallocated prebeth +prebicategory preboolean prebundle prec precantorset +precd precdf preceded precedence precedes +preceq precheck precheckfinsetstx preci precise +precisee +precisei precisely precisio precision @@ -57806,7 +63143,10 @@ precomposition precompr precomprelation precompuniformconvergenceclm +precond +precondi precondition +preconditions precongr preconnecte preconnected @@ -57815,6 +63155,7 @@ precov precove precoverage precpos +precprec precsex precsexlem precsexlemcbv @@ -57826,8 +63167,11 @@ predabove predaboveorderhom predacread predacwrite +predatm +predatom predb predc +predcong predconts preddif preddowncl @@ -57852,8 +63196,11 @@ predicate-subtyping predicateholds predicateresult predicates +predicational +predict predictable predictablepart +predicted predicting prediction predicts @@ -57899,26 +63246,42 @@ preergodic preex preextensive pref +prefd +prefeq prefer preferable +preference preferlhs +prefernce preferred prefers +prefi prefix +prefixclosed +prefixe prefixed prefixedequiv prefixedpoint +prefixeq prefixes +prefixi prefixlist +prefixmatch prefixpoint prefixstr +prefixtolevel prefixtoname +preflect +preflow +prefs preftype prefunctor +prefunctorfunctor preg pregaloiscategory pregmap pregns +pregraph pregroupoid prehaar prehil @@ -57952,6 +63315,7 @@ preimalegt preimaleiinlt preiman preimane +preimg preimgcodiscrete preinclusion preindspreads @@ -57971,7 +63335,9 @@ preleqalt preleqg prelift preliftalghom +prelim preliminaries +preliminariesd preliminary prelimitrecon prelocalpredicate @@ -57981,15 +63347,19 @@ prelpwi prelrrx prelspr prelude +prem premetric premetricoptimalghdist premis +premise +premises premiss premisses prems pren prenatiso prenex +prenorm prenormeds preo preomega @@ -58016,11 +63386,15 @@ prepareop prepartition prepartitions prepend +prependhlams +prependlams +prependvlams preperfect prepop preprimitive preprint preprints +preprm preprocess preprocesscopyright preprocessfacts @@ -58037,16 +63411,21 @@ preqsnd prequasiregular prequotient preradical +prered prereflecti prereflection +preregister preregular prereq +prereqs prerequisite prerequisites preright prerightiso +prerun pres presarith +presatm presburger presburgerfunc prescribed @@ -58196,6 +63575,7 @@ preservesterminalobject preserveswellordercontinuousofshape preserveszeromorphisms preserving +preservingi preservingmctx preseves presf @@ -58240,6 +63620,7 @@ presolutionobj prespectralspace presright press +prestar prestonecech prestonecechcompat prestonecechextend @@ -58249,10 +63630,13 @@ presubmersivepresentation presuc presucmap presumably +presv +pret pretend pretilt pretnar pretopology +pretr pretransitive pretransitivity pretransparency @@ -58263,13 +63647,18 @@ pretrivialization pretrivializationat pretrivializationatlas pretty +prettydef prettylemma +prettypattern +prettypatterns prettyprint prettyprinter prettyprinting prettyprintopt prettystring +prettyterm preu +preuniquee preuniqval preunitiso preuve @@ -58287,8 +63676,10 @@ preview previous previousinstname previously +prevk prevnext prevoccs +prevs prewalk prews prex @@ -58298,15 +63689,20 @@ prezerohypercover prezerohypercoverfamily prf prfcl +prferred prfi prfialt +prfof +prfp prfromadj prfval +prfx prg prhash prhl pri price +prices prid pridl pridlc @@ -58314,10 +63710,15 @@ pridlidl pridln pridlnr pridlval +priek priestley priestleyspace +prik +prikey prim primal +primald +primali primality primarily primary @@ -58330,7 +63731,10 @@ prime primecompl primecounting primed +primedivisor +primefact primefactor +primefactorisation primefactors primefactorsli primefactorslist @@ -58339,11 +63743,14 @@ primefld primefldchr primefldgen primeheight +primei primeidealof +primelist primemultiset primepair primepow primepoweqpow +primepower primes primesbelow primesequiv @@ -58375,6 +63782,7 @@ primespectrumprodhomeo primespectrumprodofsum primespectrumquotientorderisozerolocus primesprm +primevanishes primitive primitiveaddchar primitivechar @@ -58396,6 +63804,7 @@ primrec primrecbounded primrecpred primrecrel +primroot primrootlekpowne primroots primrootscoprbij @@ -58403,6 +63812,7 @@ primrootscoprf primrootscoprmpow primrootspoweq primrootsunit +prims prin princ princi @@ -58433,6 +63843,8 @@ printable printcodepointhex printed printer +printf +printfspec printing println printnamehashmap @@ -58448,13 +63860,18 @@ priorities prioritises prioritize priority +prios +prism priv +privacy private privatei privateinpublic privatemodule privateslash privatetousername +privilege +privs prj prjcrv prjcrvfval @@ -58557,9 +63974,11 @@ prneprprc prnesn prnmadd prnmax +prnt prnz prnzg pro +proact prob proba probabilistic @@ -58579,6 +63998,7 @@ probdsb probe probfinmeasb probfinmeasbaltv +probgn probinc probing problem @@ -58589,6 +64009,7 @@ probmeasb probmeasd probnul probreal +probs probsize probtot probtotrnd @@ -58610,8 +64031,11 @@ processbigopbinder processbigopbinders processbinop processed +processedd processedfacts +processedi processedmonotonic +processes processexpr processid processing @@ -58626,7 +64050,11 @@ procoyonedacovariant procoyonedacovariantunop procr procs +procsd +procsi procsn +procuniv +procvardeclname prod prodadditive prodag @@ -58655,6 +64083,7 @@ prodcongrleft prodcongrright prodcontinuouslinearequiv prodcoproddistrib +prodd proddomain prodembeddingdisjointequivsigmaembeddingrestricted prodempty @@ -58688,6 +64117,7 @@ prodfzo prodge prodgt prodhomotopy +prodi prodindf prodinlinr prodinverse @@ -58726,12 +64156,14 @@ prodmultiplicative prodmz prodnateq prodnatequiv +prodnts prodoffinsuppnat prodofsmulcommclass prodonesu prodonesubpow prodonesum prodopequiv +prodp prodpempty prodpi prodpicons @@ -58752,6 +64184,7 @@ prodrb prodrblem prodrel prodright +prods prodshear prodsn prodsnd @@ -58764,6 +64197,7 @@ prodsubtypefstequivsubtypeprod prodsum prodsumdistrib prodswap +prodtms prodtoprodtop prodtoprodtopi prodtp @@ -58780,23 +64214,29 @@ producing product productcone productconeislimit +producte productequiv productext +productf +producti production productislimit productiso productisproduct productive +productivei productleftalghom productlimitcone productmap productofmemopens +productofprimes products productsetoid productsfromfinitecofiltered productsproperties productto producttofamily +producttop producttriangle productuniqueiso produit @@ -58829,6 +64269,8 @@ profinitetocomphauseffectivepresentation profinitetocondensed proforma prog +progd +progi progmeasurable program programmer @@ -58837,6 +64279,7 @@ programming_ programs progress progression +progs proj projdata projdeclata @@ -58875,9 +64318,13 @@ projectmapaux projectmax projectmin projectobj +projector projectorp +projectquery projectquotient +projectsrcv projectsubobject +projecttable projeq projete projex @@ -58920,6 +64367,9 @@ projzeroringhom prokhorov prolog prolong +prolongation +promela +promg promise promised promises @@ -58947,19 +64397,28 @@ proofoflimitruleofproduct proofoptimalassignment proofs proofsinpublic +prooftree +prooftreebounded +prooftreedeductiond +prooftreei +prooftreeterminal proofwidgets proofwiki proofzero proot +proots prop +propag propagate propagated +propagates propagation proparrow propclass propcomplete propd propdecidable +prope propeqop propequivbool propequivpempty @@ -58967,7 +64426,11 @@ propequivpunit proper propercone properconstsmul +properd +properdiv properdivisors +properi +properl properly properlydiscontinuoussmul properness @@ -58976,6 +64439,7 @@ properspace propertie properties property +propertyb propertychainaxiom propertydisjointwith propertyislocal @@ -58983,9 +64447,12 @@ propext propf propfeq propi +proplit +propoagate proportion proportional proportionality +propos proposed proposition propositional @@ -58996,6 +64463,7 @@ propqcprecoverage propqctopology props propssopi +propto proptotagged proptypes propwff @@ -59003,10 +64471,14 @@ propx prose proset prot +protcl protect protecte protected +protectrefl +protects protein +protfw prothprm prothprmlem proththd @@ -59018,6 +64490,7 @@ protocol-safe protocols prototype prov +provability provable provably prove @@ -59077,6 +64550,7 @@ proxyequivname proxyname proxytype proxytypeequiv +prp prpair prpairs prprc @@ -59143,12 +64617,16 @@ prtex prtitle prtlem prub +prufer +prule +pruned prunesolvedgoals prunioo prv prvlem prwf psasym +pscope psd psdadd psdascl @@ -59164,7 +64642,10 @@ psdmvr psdpw psdval psdvsca +psegments +psen psep +pseq psercn psercnlem pserdv @@ -59173,10 +64654,12 @@ psergf pserulm pserval pset +pseti pseud pseudo pseudoapply pseudocore +pseudodeterministic pseudoedist pseudoelement pseudoelements @@ -59197,6 +64680,7 @@ pseudofunctors pseudofunctortopith pseudofunctortopithcompinclusionstrongisohom pseudofunctortopithcompinclusionstrongisoinv +pseudoha pseudome pseudometric pseudometricdilation @@ -59257,8 +64741,12 @@ psigmaequivsigma psigmaequivsigmaplift psigmaequivsubtype psildecval +psim +psimp psize pslem +pslice +pslicei psmeasure psmeasurelem psmet @@ -59364,6 +64852,7 @@ psssstrd psstr psstrd pssv +pst pstate pstep pstmfval @@ -59387,10 +64876,13 @@ psubn psubnormal psubq psubset +psubseteq +psubseti psubspi psubspset psubssat psubst +psuf psum psumcongr psumequivsum @@ -59398,9 +64890,12 @@ psumpart psums psumsum psup +pswap psych psychologicalattribute psyl +psym +pta ptbas ptbasfi ptbasid @@ -59420,6 +64915,7 @@ ptdefault pte ptendst ptendsto +pterm pterms ptfin ptfinfin @@ -59468,10 +64964,13 @@ ptpjopn ptpjpre ptr ptram +ptrans +ptrd ptrecube ptree ptrescn ptrest +ptrm ptrmap ptrofs ptrs @@ -59491,8 +64990,15 @@ pua pub pubblockssrc pubblockstgt +pubconst +pubconsts +pubek +pubk +pubkey +pubkeys public publication +publicv pubsrc pubsrchyp pubtgt @@ -59614,10 +65120,13 @@ pullfunctorobj pullfunctorobjhom pullhom pulling +pullout pulls pullstep pullsub pumping +punchin +punchout punctured punique punit @@ -59640,6 +65149,7 @@ pure pure_ purecauchy purecoherence +purei pureinst pureisdefeq purely @@ -59648,6 +65158,8 @@ puremulhom pureonehom purer puretransformation +purge +purgeidle purity purpose purposefully @@ -59662,6 +65174,7 @@ pushconfig pushcore pushdown pushed +pushes pushext pushf pushfo @@ -59744,7 +65257,12 @@ pushquiver pushsimpconfig pushstep put +putelim +putfield puts +putsdown +putstatic +putstr putstrln putting puv @@ -59753,9 +65271,14 @@ puz puzzle pval pvalid +pvanishes +pvanishesd +pvanishesi pvar pverismo +pverts pvjxuscvkavzccbxddgai +pvr pvs pvsca pvw @@ -59800,6 +65323,9 @@ pwidg pwin pwinfi pwinfig +pwits +pwitsd +pwitsi pwjust pwldsys pwle @@ -59820,6 +65346,7 @@ pwpwab pwpwpw pwpwssunieq pwpwuni +pwrite pwrssmgc pws pwsabl @@ -59872,6 +65399,7 @@ pwsval pwsvscafval pwsvscaval pwsxms +pwt pwtp pwtr pwtrrvd @@ -59894,6 +65422,7 @@ pwzx pxel pxkthapzwz pxs +pya pyel pyramid pyth @@ -59926,16 +65455,26 @@ qaddcl qahy qalgebra qam +qamic qaryentropy qbar qbczgzgeejkpnviosdtpgvocmmqjtgirkz +qbf +qbinomial +qbit +qbracket +qbs qbsb qbtwnre qbtwnxr +qcase qcat qccoverfamily +qcd qcn qcompequivalencefrommodelfunctoriso +qcong +qconv qcprecoverage qcqs qct @@ -59943,20 +65482,25 @@ qculift qcvs qdass qdassr +qdelta qden qdencl qdensere qdenval qdf +qdfst qdiff qdiv qdivcl +qdivide qdrng +qdsnd qed qelioo qemb qenom qepres +qeq qeqnumdivden qerclwwlknfi qex @@ -59984,10 +65528,16 @@ qf_lra qf_nia qf_nra qf_uf +qfa +qfact qfactorsthroughhomotopy qfield qfld +qfn +qfree +qft qfto +qfun qgt qhii qiaznzqqq @@ -59996,11 +65546,13 @@ qilt qinfty qinioo qinv +qinverse qirr qirropth qis qiso qisom +qiter qkg qkoq qkuyzvv @@ -60016,6 +65568,7 @@ qliftfuns qliftlem qliftrel qliftval +qlock qmap qmapeldisjs qmapeldisjsbi @@ -60026,11 +65579,14 @@ qmkaeu qml qmltpeq qmmp +qmod qmonic qmp +qmpt qmulcl qmuldeneqnum qmult +qmultiplicity qmulz qnabyeoypymn qndenserrn @@ -60041,6 +65597,7 @@ qndenserrnopnlem qneg qnegcl qnf +qnminus qnnen qnumcl qnumdenbi @@ -60058,11 +65615,13 @@ qoxqavfxeklcazdoiouktwvhx qparam qpf qplus +qpochhammer qpos qposit qpositive qpp qpr +qprod qqadgrvhtbfvfbwaoathyeuuignedq qqh qqhcn @@ -60076,6 +65635,9 @@ qqhucn qqhval qqhvq qqhvval +qqn +qqp +qqq qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq @@ -60102,6 +65664,7 @@ qrng qrngbas qrngdiv qrngneg +qroot qrre qrreccl qrrp @@ -60140,12 +65703,17 @@ qsscn qssre qsss qsssubdrg +qstar qsubcl qsubdrg qsubt qsxpid +qtable +qtimes qtj qtlwqkju +qtm +qtmset qtop qtopbas qtopbaslem @@ -60180,6 +65748,7 @@ qtt-pair qtt-var qttcontext qtttypechecker +qty qua quad quadchunks @@ -60193,16 +65762,21 @@ quadraticform quadraticmap quadraticmodulecat quadres +quadrilateral +quadroot quadruple +quadruples qualified qualifier qualifies quandle quandles +quant quantale quantdemorgan quantification quantified +quantifiedvarmap quantifier quantifiers quantifiers_ @@ -60213,13 +65787,16 @@ quantitative quantities quantity quantitychange +quants quantum quart quarter quarters quartfull +quartic quartlem quasi +quasiamicable quasicategory quasicoherentdata quasicoherentdataofisfinitepresentation @@ -60230,11 +65807,13 @@ quasicomplete quasicompletespace quasiconcaveon quasiconvexon +quasieq quasiergodic quasifi quasifinite quasifiniteat quasifinitelocus +quasigroup quasii quasiis quasiiso @@ -60244,24 +65823,35 @@ quasilinearon quasimeasurepr quasimeasurepreserving quasimorphism +quasinat +quasinorm +quasiperiod +quasired quasiregular +quasiring +quasisemimetric quasiseparated quasiseparatedspace quasisober quasispectrum quasispectrumcompact quasispectrumrestricts +quat quaternion quaternionalgebra quaternionbasis quaterniongroup quaterniongroupzeroequivdihedralgroupzero quaternions +qubit +qubits queens queries +queriesi query query-response question +questiondown questioning questionmark questions @@ -60276,6 +65866,7 @@ quickchickdebug quicker quickfix quickly +quicksort quicksortcorrect quite quiv @@ -60302,6 +65893,7 @@ quotdualcoannihilatortodual quotdualequivannihilator quote quoteddefeq +quoteexitcode quotep quotequivannihilator quotequivofeq @@ -60311,6 +65903,7 @@ quotequivofquotequiv quotequivpowquotpowsucc quotequivpowquotpowsuccequiv quotequivquotmap +quoteresult quoti quotidealmapequivtensorquot quotidealmapequivtensorquotaux @@ -60334,6 +65927,7 @@ quotientcompqhiso quotientcotan quotientcotangentideal quotientcotangentidealringequiv +quotientd quotientdiag quotientdiff quotiente @@ -60355,11 +65949,13 @@ quotientequivquotientmvpolynomial quotientequivself quotientequivsi quotientequivsigmazmod +quotientfp quotientfunc quotientfunctor quotientgroup quotientgroupcon quotientgroupmk +quotienti quotientiinfembedding quotientiinfsubgroupofembedding quotientinfequivprodnormalizerquotient @@ -60393,6 +65989,7 @@ quotientmulequivofeq quotientmulequivquotientprod quotientn quotientout +quotientp quotientpathsequiv quotientpathsto quotientpequiv @@ -60442,6 +66039,7 @@ quotinv quotkerequivofsurjective quotkerequivrange quotkertotalequiv +quotl quotlefttoquotsup quotlem quotlieofeq @@ -60461,6 +66059,8 @@ quotquotequivquotsup quotquotmk quotquottoquotsup quotquotuliftaddequiv +quotr +quotrem quotsmultop quotsmultoptensorequivquotsmultop quottensorequivquotsmul @@ -60585,6 +66185,8 @@ rabn rabnc rabon rabord +rabort +raborting rabrab rabrabi rabren @@ -60622,7 +66224,9 @@ rabxfrd rabxm rabxp rac +racc race +races rachet rack racks @@ -60647,10 +66251,13 @@ raddfmnn raddfmz raddfn raddswap +radem rademacher +radiant radiating radica radical +radicali radicalinftophom radicals radii @@ -60806,6 +66413,7 @@ ralxpf ralxpmap ralxpxfr ram +ramanujan ramcl rami ramification @@ -60835,10 +66443,12 @@ randfin randgt randnat random +randombids randomfunc randomgen randomisation randomr +randomrio randt ranfn ranfval @@ -60847,16 +66457,21 @@ range rangeaddcommgroup rangeadorthogonal rangearr +rangec rangecomap ranged +rangee rangefactorization rangefin +rangei rangeicc rangeinl rangeinr +rangeit rangekerlift rangeliftinclusion rangeofwtype +rangep rangeqtint rangerestrict rangerestrictfield @@ -60879,6 +66494,7 @@ rankcf rankcld rankcondition rankdmr +ranked rankel rankelb rankelg @@ -60898,6 +66514,8 @@ rankidb rankidn rankinfinite ranking +rankingd +rankingi rankk rankleone rankleonestruct @@ -60919,6 +66537,7 @@ rankpwg rankpwi rankr rankrelp +ranks ranksn ranksnb ranksng @@ -60950,10 +66569,12 @@ ranup ranval raph rapid +rar rarely rargs rarray rarrayexpr +ras rasb rassoc rat @@ -60968,6 +66589,7 @@ ratdi ratdistan ratdistance rate +ratfps ratfraction ratfunc ratfunca @@ -60984,6 +66606,7 @@ ratiohom rational rationalcauseqpkg rationale +rationality rationalmap rationalp rationalroottheorem @@ -60999,6 +66622,7 @@ ratnum ratofterminates ratonehalf ratr +ratreal ratrel rats ratsqrt @@ -61008,13 +66632,68 @@ rattranslation rattriangleinequality ravg raw +rawalternative +rawapplicative +rawapplicativezero +rawbimodule +rawbisemimodule rawca rawcast +rawchoice +rawcomonad rawendpos rawexpr +rawfoldable +rawfoldablewithdefaults +rawfunctor +rawgroup +rawialternative +rawiapplicative +rawiapplicativezero +rawimonad +rawimonaddcont +rawimonadplus +rawimonadreader +rawimonadstate +rawimonadt +rawimonadwriter +rawimonadzero rawintlitnatabs +rawlattice +rawleftmodule +rawleftsemimodule rawlevels +rawloop +rawmagma +rawmodule +rawmonad +rawmonadio +rawmonadplus +rawmonadrandom +rawmonadrandomr +rawmonadreader +rawmonadstate +rawmonadt +rawmonadzero +rawmonoid rawnatlit +rawnearsemiring +rawpmonad +rawpow +rawpushout +rawquasigroup +rawrightmodule +rawrightsemimodule +rawring +rawringwithoutone +rawrite +rawritecontentchanged +rawritecontentfill +rawritecontentold +rawritesizegrows +rawritesizesame +rawsemimodule +rawsemiring rawunivs ray rayleigh @@ -61029,13 +66708,18 @@ rbaibr rbc rbg rblem +rblit rbody +rborel +rbrace rbrakk rbropap rbropapd +rbst rbsyl rbt rbtree +rbtreeify rbvkmrxbqysbjw rbx rca @@ -61049,41 +66733,58 @@ rcb rcc rcd rcdk +rceil rcenter +rces rcf rcg rcharacterdata +rchild rchk rchtgt rcircle +rcis rcl rcleq rcleqf rclexi +rcliff rclike rclikeanyalgebra rclikecommalgebra rclikecomposition rclikenormed rcliketoreal +rcm rcomap rcomm rcompare rcompleq rcon rcond +rconf rcongr +rconjaction +rconjby rcons +rconsnlist rcoset rcosets rcpsp rcr +rcs +rcset +rcswitch rctx +rcurrent +rdby rdcp rddif rdefinitions rden rdeps +rderiv +rderive rdf rdfs rdg @@ -61109,20 +66810,28 @@ rdgsucuni rdgval rdgvalg rdichotomy +rdiff +rdistr rdistrib rdiv rdivmuldivd rdocum rdocument rdom +rdomp rdot rdpi +rdpsr rdpwhole rdrop rdropwhile +rdtbr +rdummy rdv rdvalt rdvr +rdwim +rdy re-applying re-indexed rea @@ -61134,20 +66843,36 @@ reabsifpos reabssgn reach reachability +reachabilityinvariant reachable +reachablee +reachablei +reachableinexecution +reachablenodes +reachableo reachablesetoid reachablestate +reachablestepfirst +reachablev reached reaches reaching +reachnt +reacho +reachv +react reaction +reactioni read read-only read_snapshot readability readable +readargs readaux +readcarray readconfigfile +readcorrect readd readdcan readdcl @@ -61168,14 +66893,19 @@ readdrid readdridaddlidd readdscl readdsub +readelse reader readerswriters readert +readertimonadreader readfile readily reading readint +readl readline +readlocs +readmaybe readme readonly readpcp @@ -61185,6 +66915,8 @@ readresponse reads readsnapshot readthe +readthen +readvariablerecursive readvcot readvrec readwriteimpread @@ -61201,12 +66933,15 @@ realcontinuousmapzeroofnnreal realdef realderivofcomplex realeqcomplex +realfun realfundsystem realfunsystem reali realimaginarypart realinnerproductspace realinterval +realise +realistic realizability realize realized @@ -61223,6 +66958,8 @@ realnormed realnormedspace realnumber realpart +realpow +realrel realringequiv realrmk reals @@ -61264,16 +67001,21 @@ reassociated reassociates reassocimplref reater +reational rebalance rebase reboot rebtwnz +rebuild rec +reca recall recan recast +recb recbotcoe recbothd +recbuilder reccl reccld reccli @@ -61292,6 +67034,7 @@ receives receiving recemptyoption recennreal +recenum receqid receu recex @@ -61301,6 +67044,8 @@ recexsr recexsrlem recextlem recf +recfn +recfun recgt recid recidd @@ -61350,7 +67095,9 @@ recognise recognised recognising recognize +recognizeotherppa recognizers +recognizing recolorofcardle recolorofembedding recolorofequiv @@ -61358,6 +67105,8 @@ recommended recomp recompile recompose +recomputable +recompute recomputing recon reconappendsingle @@ -61384,8 +67133,10 @@ reconstructing reconstruction reconsubsingleton reconswap +recontrust record record_use +recorded recording records recos @@ -61415,6 +67166,7 @@ recsfnon recsfval recsne recsov +recstruct recsval rect rectan @@ -61424,12 +67176,15 @@ rectangular rectbntr rectifiable rectopcoe +rectpath rects rectvandermonde recur recurr recurrence recurrenceaux +recurrent +recurrenti recurse recursem recurses @@ -61441,6 +67196,7 @@ recursive recursivein recursively recursor +recursorbuilder recursors recursorval recusp @@ -61448,6 +67204,10 @@ recut recv recval recvar +recvmarker +recvmsg +recvmsge +recvmsgtt recvs recxpcl recxpcld @@ -61473,6 +67233,7 @@ redin redinclp redinclr redininclq +redirect rediv redivcan redivcl @@ -61483,11 +67244,14 @@ redivd rediveud redivmuld redivvald +redl redln redn redo redoing +redr reds +redsi redstep redtablewine redu @@ -61501,6 +67265,8 @@ reducecyclically reduced reducedite reducediv +reducedly +reducedto reducedword reduceeqq reduceexpr @@ -61524,6 +67290,7 @@ reducepow reduceproj reduceprojstruct reduceprop +reducer reduces reduceskip reducestar @@ -61542,14 +67309,17 @@ reduction reductionfvarids reductiongoal reductions +reductive reducts redund +redundancy redundant redundeq redundpbi redundpim redunds redundss +reduntant redustarconfluent redvmptabs redvr @@ -61600,6 +67370,7 @@ referentially referred refers reff +refgoal refi refimssco refin @@ -61608,16 +67379,23 @@ refine-sub refinearg refined refineddiscrtree +refinei refinement refinementlib refinements refinementtypechecker refineonehypercover +refineres refines +refinesd +refinesi refining refl reflbooltrue +reflc reflcl +reflclosure +reflclp refld refldcj refldivcl @@ -61634,6 +67412,7 @@ reflectionlinearequiv reflectionobj reflectionperm reflections +reflectiontests reflective reflector reflectoradjunction @@ -61676,6 +67455,7 @@ reflectssmallestcolimits reflectssmallestfilteredcolimits reflectssmallestlimits reflectt +reflex reflexg reflexion reflexive @@ -61683,6 +67463,7 @@ reflexivecoequalizerisocoequalizer reflexivecofork reflexivecoforkequivcofork reflexivecoforkequivcoforkobjiso +reflexivei reflexivemonadicity reflexivepair reflexiveproperty @@ -61692,6 +67473,7 @@ reflexivity reflexivitytac reflext reflgen +reflp reflprefunctor reflquiv reflquiver @@ -61708,6 +67490,7 @@ refold refoldconsts refoldfun refoldfvars +reform reformulate reformulating reformulation @@ -61722,17 +67505,21 @@ refrelredund refrelressn refrels refrelsredund +refresh refressn refrigerator refs +refsd refssex refssfne refsum refsumcn refsymrel refsymrels +reft reftr refun +refusals refuses refutable refutation @@ -61754,6 +67541,7 @@ reghmph reghost region regionbetween +regions register registerbuiltinattribute registercoercion @@ -61787,6 +67575,8 @@ rego regoffamily regr regression +regressively +regret regs regsep regset @@ -61797,7 +67587,14 @@ regsumfsum regsumsupp regt regtop +regtrace +regtracelist regular +regularamicpair +regularamicpairexample +regularcard +regularcone +regularconeset regularcontents regularcoverage regularepi @@ -61863,6 +67660,7 @@ reipcl reixi reject rejected +rejective rejects rejoining rel @@ -61884,6 +67682,7 @@ relating relatio relation relation_ +relational relationmap relationofhascoeffs relationrefltransgen @@ -61903,6 +67702,8 @@ relatively relativelycompact relativelyrepresentable relativemorphism +relativepath +relativetoknownnature relativity relativization relator @@ -61928,8 +67729,10 @@ relco relcoels relcoi relcomp +relcompp relcoss relcwcomplex +reld reldesired reldif reldir @@ -61978,6 +67781,7 @@ releabs releabsd releabsi release +released releasedat releccnveq relecxrn @@ -62002,9 +67806,11 @@ releqd releqg releqi releupth +relevance relevant relevantarg relevantchildren +relevantd relevantfvars relexp relexpaddd @@ -62043,17 +67849,20 @@ relexpsucrd relexpuzrel relexpxpmin relexpxpnnidm +relf relfae relfi relfinrank relflag relfld relfldext +relfp relfsupp relfth relfull relfunc relgamcl +relh relhom relhomclass relhomcongr @@ -62083,6 +67892,7 @@ relisoofsurjective relisotrans relisseparated reliun +rell rellan rellast rellindf @@ -62150,6 +67960,8 @@ relpfr relpfrlem relpic relpmin +relpow +relpower relprcnfsupp relpreimage relprel @@ -62194,6 +68006,7 @@ relsubgr relsucmap relt reltm +reltosubrelation reltpos reltrclfv reltre @@ -62202,6 +68015,7 @@ reltsub reltsubadd relttrcl reltxrnmnf +relu relun reluni relup @@ -62215,6 +68029,8 @@ relying rem remain remainder +remainderexp +remainderexplemma remaindering remainders remaining @@ -62223,12 +68039,14 @@ remaininggoals remains remapleft remark +rembiflowdups rembl remdups remedied remember remembering remeq +remerge remet remetdval remexz @@ -62245,16 +68063,25 @@ remove removeafterindex removeall removeargrule +removeat removebot removecholes removed removedeprecations +removedirectory +removedirectorylink +removedirectoryrecursive +removeduplicateliteralsequivalentclause removeduplicates removeduplicatesby removedups removefactor +removefalseliterals +removefile removefirst removeincorrect +removelast +removeleaf removeleftop removeloops removemin @@ -62264,6 +68091,7 @@ removenegations removenone removenth removeop +removepathforcibly removepresent removeproof removequotations @@ -62274,6 +68102,9 @@ removeunop removezero removezeros removing +rempdups +rempty +remquot remsqsqrt remul remulcan @@ -62299,17 +68130,22 @@ renamebvar renamebvarhyp renamebvartarget renamed +renamedirectory renameequiv +renamefile renamefun renamefunaux renameinaccessiblefvars +renamelcs renamemetavar +renamepath renamerule renamesymmetricsubalgebra renametheorem renaming rencldnfi rencldnfilem +render renderdocument rendered rendering @@ -62346,6 +68182,8 @@ renod renpncan rentielles renting +renum +renumber reofld reofreal reopening @@ -62371,6 +68209,7 @@ repable repack repackage repackaging +repair reparam reparameterize reparametrising @@ -62379,6 +68218,10 @@ reparpht reparphti reparphtiold repart +repbaseclass +repc +repcd +repcs repe repea repeat @@ -62394,8 +68237,10 @@ reperf reperflem repetition repetitions +repfun repgen rephrase +rephrased rephrases rephrasing repinject @@ -62438,11 +68283,14 @@ replaceuniformity replacevertex replacing replax +replay +repli replica replicamessage replicate replicateaddmonoidhom replicatecol +replicatei replicaterow replicates replication @@ -62452,6 +68300,7 @@ replimd replimi replusg reply +repmc repncan repnf repnfmpt @@ -62495,6 +68344,8 @@ representatives represented representing represents +representsd +representsi represnetable reprf reprfi @@ -62526,6 +68377,10 @@ repsconst repsdf repsf repsfintype +repshare +repsharing +repsharingi +repsim repsundef repsw repswccat @@ -62539,8 +68394,11 @@ repswswrd repswsymb repswsymball repswsymballbi +rept reptile reptype +repu +repv repvcl repveval repwsmet @@ -62578,6 +68436,7 @@ rereccli rerecclzi rerecid rered +rerename rerest rerisefaccl rern @@ -62585,11 +68444,13 @@ rernegcl rernmpt rerpdivcl rerpdivcld +rerr rerrext rersubcl rerun res resabs +resample resasplit resb rescabs @@ -62598,6 +68459,7 @@ rescalealghom rescaled rescalemonoidhom rescales +rescap rescbas resccat resccatlem @@ -62614,6 +68476,9 @@ rescofuf rescoindadjunction rescoindhomequiv rescom +rescommrel +rescommrelstarres +rescommrelstarreschain rescomp rescongr resconn @@ -62636,7 +68501,9 @@ reseedres resentation reseq resequiv +reserve reserved +reserves reset reseti resetting @@ -62645,6 +68512,7 @@ resexd resexg resf resfifsupp +resflow resfnfinfin resfsupp resfunexg @@ -62655,6 +68523,7 @@ resfz resghm resgrpisgrp resgrpplusfrn +reshare resi resid residence @@ -62663,7 +68532,13 @@ residm residpr residual residualeq +residualgraph +residualinject +residuallength residuallyfinite +residuated +residuatedi +residuation residue residueclass residueclassesequiv @@ -62720,6 +68595,7 @@ resmpti resnattrans resnonrel reso +resof resofquotientiso resol resolution @@ -62727,12 +68603,14 @@ resolutioncomptolocalizationnattrans resolutionmap resolutionobj resolutions +resolvability resolve resolved resolveglobalconstnooverload resolveid resolvenamespace resolvent +resolvents resolventset resolvepushid resopab @@ -62750,6 +68628,7 @@ respe respec respect respected +respecting respective respectively respects @@ -62774,7 +68653,11 @@ responds response responses responsible +responsive +responsived +responsivei respreima +respresentation resqcl resqcld resqcli @@ -62787,6 +68670,7 @@ resqrtth resqrtthlem resqrtval resqrtvalex +resr resrcmplf resres resresdm @@ -62814,6 +68698,7 @@ resseqnbas ressffth resshom ressid +ressim ressinbas ressiocsup ressiooinf @@ -62871,6 +68756,7 @@ rest2 resta restabs restar +restart restarted restate restated @@ -62917,6 +68803,7 @@ restreq restri restric restrict +restricta restrictaddmonoidhom restrictaddsubmonoid restrictadjunction @@ -62924,10 +68811,12 @@ restrictalgebra restrictaux restrictcoextendscalarsadj restrictcomp +restrictd restrictdegree restrictdom restrictdomain restrictdvd +restricte restricted restrictedproduct restricteduliftyoneda @@ -62951,6 +68840,7 @@ restricthom restricthomequivhom restricthomequivofislocallysurjective restricthomkerequiv +restricti restrictindepmatroid restrictindex restrictindexhom @@ -62958,6 +68848,7 @@ restrictindexofsmall restricting restriction restrictioncoextensionadj +restrictionconservation restrictioncyclesiso restrictionfunctor restrictiongeiso @@ -62972,6 +68863,7 @@ restrictions restrictiontotruncge restrictionxiso restrictisospec +restrictive restrictlatticehom restrictle restrictlie @@ -63021,13 +68913,16 @@ restrictsupport restrictsupportequiv restrictsupportideal restrictsurjective +restrictto restricttopiso restricttotaldegree restrictunit restrictvar restrictvarleft +restrictwith restrm restropen +restrp restrpermmap restrreld restructure @@ -63068,10 +68963,13 @@ resubsub resubval result resultant +resultd resulting results +resultsp resum resummed +resumption resundi resundir resunimafz @@ -63106,6 +69004,7 @@ retopon retopsconn retos retps +retr retract retractarrow retractarrowapp @@ -63122,6 +69021,7 @@ retrieve retrieved retrocompact retsig +rett retu retur return @@ -63129,7 +69029,9 @@ returned returnedbits returngen returning +returnk returns +returnt retv retval reu @@ -63174,6 +69076,7 @@ reureurex reurex reurexprg reurmo +reusables reuse reused reusing @@ -63197,6 +69100,7 @@ reuzb rev reval revalmpt +revapp revappend revat revatfun @@ -63214,6 +69118,7 @@ revequivalence revers reversal reverse +reverseacc reverseappend reverseaux reversebraiding @@ -63239,13 +69144,16 @@ revfv review reviewed reviews +reviewspaper revinductionon +revision revisit revlen revlex revlexaccessible revnumber revolution +revorder revorderiso revperm revpfxsfxrev @@ -63257,6 +69165,7 @@ revwlk revwlkb revzip rew +reward rework rewr rewri @@ -63268,6 +69177,7 @@ rewritelocaldecl rewriteonefile rewriteresult rewrites +rewritesi rewritetarget rewritetype rewritevar @@ -63412,6 +69322,7 @@ rexxfrd rexxp rexxpf rexzrexnn +rez rezh rfc rfc-editor @@ -63422,8 +69333,11 @@ rfi rfind rfindopt rfindx +rfix rfl rfled +rfloor +rflow rfltac rflx rfork @@ -63437,15 +69351,20 @@ rfovfvd rfovfvfvd rfs rfull +rfunc rfv rgbi rge rgen rgenw +rgf +rgfs +rggs rgh rglcom rgmoddimold rgr +rgraph rgrb rgrprc rgrprcx @@ -63465,7 +69384,9 @@ rgv rgvd rhashead rhasleader +rhb rhcivnpdokhl +rhd rhm rhmcl rhmco @@ -63527,8 +69448,10 @@ rhsap rhsargs rhsfi rhshead +rhsl rhsmd rhspf +rhsq rhss rhsval riable @@ -63570,6 +69493,7 @@ rieszmeasure rieszmonotone rieszsubadditive rif +rifp rify rifyproof rig @@ -63600,24 +69524,31 @@ rightadjointsquare rightadjointsquareconjugate rightadjointuniq rightalgebra +rightalternative rightangle rightanglerotation rightanglerotationaux rightarrow rightassoctensor +rightbol +rightbolloop rightc rightcanceladd rightcancelequiv +rightcancellative rightcancelmonoid rightcancelsemigroup rightcomm rightcommutative rightcomp rightcompreflexion +rightcongruent +rightconical rightcont rightcoset rightcosetequivalence rightcosetequivsubgroup +rightd rightderiv rightderived rightderiveddesc @@ -63631,10 +69562,12 @@ rightdistd rightdistrib rightdistribclass rightdistributor +rightdivides rightdual rightdualequiv rightdualfunctor rightdualiso +righte rightexact rightexactfunctor rightextension @@ -63651,6 +69584,8 @@ rightfun rightfunc rightge rightgt +rightharpoondown +rightharpoonup righthom righthomolo righthomology @@ -63672,10 +69607,13 @@ righthomotopy righthomotopyclass righthomotopyclasstohom righthomotopyrel +righti +rightidentity rightinv rightinvariant rightinverse rightinverseunitor +rightinvertible rightinvon rightinvseq rightirr @@ -63686,13 +69624,17 @@ rightkanextensioncounit rightkanextensionunique rightkanextensionuniqueofiso rightle +rightleftharpoons rightlift rightliftingproperty rightlim rightlt +rightmodule +rightmonotonic rightmost rightmul rightmulresiduation +rightneutral rightno rightnod rightofmul @@ -63709,6 +69651,7 @@ rightorthogonal rightpad rightpreliealgebra rightpreliering +rightprincipal rightproperviaequiv rightquotientequiv rightregular @@ -63721,6 +69664,8 @@ rightrigidcategory rightrigidcategoryofequivalence rightrigidcategoryofleftrigidcategory rightsection +rightsemimedial +rightsemimodule rightshift rightshiftaddequiv rightshiftlinearequiv @@ -63729,9 +69674,11 @@ rightsquareispushout rightssno rightssold rightstructure +rightto righttoleft righttomax righttotal +righttrans righttriple rightuniformspace rightunique @@ -63750,6 +69697,7 @@ rightunshift rightval rightward rightwards +rightzero rightzigzag rightzigzagiso rigid @@ -63757,6 +69705,7 @@ rigidcategory rigidcategoryofequivalence rigidity rigorously +rigs riin riincld riiner @@ -63776,6 +69725,7 @@ rimrcl rimrhm rimul rin +rind rineq ring ring_nf @@ -63937,6 +69887,7 @@ ringofintegerswithvalequiv ringold ringoperations ringoperators +ringoperatorterms ringops ringopshom ringopsiso @@ -63973,13 +69924,17 @@ ringtype ringunitnzdiv ringurd ringvcl +ringwithoutone +rinit rinside +rinss rint rintn rintopn rintr rintro rinv +rinvariant rinvdouble rinvf rinvmod @@ -64012,6 +69967,7 @@ riotaund riotauni riotav riotaxfrd +rip riposte rir rirrefl @@ -64020,6 +69976,7 @@ risc riscer risci rise +risecure risefac risefaccl risefaccllem @@ -64031,13 +69988,30 @@ risefallfac risk riso risset +ritem rivs riydzq rjgn rjmnujufzhmyipznfi +rjoin rjw rka +rkaa +rkabcabc +rkabcp +rkabpa +rkabpb +rkabpc +rkb +rkbb +rkcc +rke +rkei rkhs +rkinvolved +rkra +rkrb +rkrc rks rla rlcjp @@ -64050,9 +70024,12 @@ rlefexpfabs rlem rlemaxr rleminr +rlen rleroundedlessr rleroundedr rles +rlex +rlexp rlft rlgfixed rlim @@ -64095,6 +70072,7 @@ rlimss rlimsub rlimuni rline +rlist rlit rljnqvqchsltyjwgptaxvnftqamlv rljp @@ -64134,6 +70112,7 @@ rlp rlppccmqcybarzmikblsvvsgwutxyiyrbowqmclf rlr rlreg +rlrtp rls rlt rltdouble @@ -64157,9 +70136,11 @@ rmdirpsp rmdirpss rme rmfsupp +rmge rmin rminal rminus +rmn rmo rmoan rmoanid @@ -64207,6 +70188,7 @@ rmounid rmov rmoxfrd rmp +rmpoly rmri rmspecfund rmspecnonsq @@ -64218,6 +70200,7 @@ rmsuppss rmul rmulccn rmult +rmv rmx rmxadd rmxdbl @@ -64252,6 +70235,7 @@ rmym rmyneg rmynn rmyp +rna rnascl rnasclassa rnasclg @@ -64476,6 +70460,7 @@ rnin rninxp rniun rnlem +rnm rnmpo rnmposs rnmpt @@ -64539,6 +70524,7 @@ rnxrn rnxrncnvepres rnxrnidres rnxrnres +robbins robert robjec robject @@ -64547,6 +70533,7 @@ robust rock rocq roger +roifex role roles roll @@ -64563,12 +70550,14 @@ ron rondon roo room +roomk root rootable rootableby rootablebyintofrootablebynat rootablebynatofrootablebyint rootablebyofpowleftsurj +rootd rootdiscr rooted rootedtree @@ -64577,6 +70566,7 @@ rootfo rootform rootformin rootgrp +rooti rootlength rootmultipl rootmultipli @@ -64620,6 +70610,8 @@ rootsystem roottgt rope ropp +ror +rose rosewine rosick rosicky @@ -64632,6 +70624,7 @@ rotate rotatehomotopyequiv rotatehomotopyequivcomm rotatel +rotatepolicy rotater rotaterotaterotateiso rotates @@ -64644,6 +70637,7 @@ rotationof rotations rotcompinvrot roth +rotharithmeticprogressions rothnumber rothnumbernat rotl @@ -64689,6 +70683,7 @@ rourke rout route routing +routput rover row row-inst @@ -64699,19 +70694,25 @@ row-polymorphism row-typed row_ rowcol +rowi rowlen +rowlength rowlens rows rowspace rowstart rowstochastic +rowsum rowtomessagedata rowtoswap rowvector rpabsid rpaddcl rpaddcld +rpair +rpar rparent +rparr rpath rpc rpcencodable @@ -64738,6 +70739,7 @@ rpexp rpexpcl rpexpcld rpexpmord +rpf rpgamcl rpge rpgecl @@ -64748,6 +70750,7 @@ rphalfcl rphalfcld rphalflt rphalfltd +rphil rpi rpid rplog @@ -64770,6 +70773,7 @@ rpneg rpnnen rpo rpoint +rpoly rpos rpow rpowcpow @@ -64778,9 +70782,11 @@ rpowlimits rpowmonoidhom rppwr rpr +rprd rpre rpreccl rpreccld +rprecondition rprecred rpred rpredb @@ -64789,8 +70795,10 @@ rpredm rpredn rprednr rprege +rpregraph rpregt rprene +rpri rprime rprisefaccl rprmasso @@ -64807,6 +70815,7 @@ rprmnunit rprmnz rprmval rprod +rprodl rprop rprp rprpwr @@ -64818,21 +70827,35 @@ rpsscn rpssre rpssxr rpsup +rpth +rpv rpvmasum rpvmasumlem rpxdivcld rpxr rpxrd +rqp +rqs rqt +rquicksort +rquot rra +rrangle rray rrb rrd rrdrg rre +rrec rred +rref rreg rrel +rremdups +rrep +rreq +rreqid +rreqs rrext rrextchr rrextcusp @@ -64862,6 +70885,7 @@ rrhqima rrhre rrhval rri +rrightarrow rrk rrl rrn @@ -64878,15 +70902,18 @@ rrnmbl rrnmet rrnmval rrnprjdstle +rrns rrntotbnd rrnval rrobin +rroots rrpos rrpsscn rrr rrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrr rrs rrstar +rrstep rru rrv rrvadd @@ -64941,13 +70968,21 @@ rrxunitopnfi rrxval rrxvsca rsa +rsaep rsb rsc +rsd +rsecure +rseq +rset +rsg rsh rshadowroot +rsided rslt rsp rspa +rspace rspan rspc rspccv @@ -65004,27 +71039,36 @@ rspun rspval rspw rsqr +rsquarefree +rsr +rss rst rstar rstarrplus rstarsym rstate +rstates +rstep rstx rsub rsubrotld rsubset rsuffices rsum +rsuml rsumover rsx rsy rsym rsymprop +rsystmp rtac rtacp rtake rtakewhile +rtbl rtc +rtci rtcpredn rtcredn rte @@ -65042,13 +71086,17 @@ rtensorhomequivhomrtensor rtensorhomtohomrtensor rtensorinv rtensorone +rtimeout rtkb rtl rtn +rtol rtopo rtotal rtprmirr +rtr rtrancl +rtranclp rtrans rtransp rtrclex @@ -65056,9 +71104,11 @@ rtrclexi rtrclexlem rtrclind rtrclreclem +rtree rts rttree rtxmntndreoysrggveegc +rtype rualt ruc rucalt @@ -65071,13 +71121,16 @@ ruleconfig ruled ruler rules +ruleset rulesets +rulesi ruletac rulhcs run runandfailifnoprogress runattr runcmd +runcmdtc runcore runcorem runcoremcapturinginfotree @@ -65085,20 +71138,27 @@ runcoremwithmessages rundefeqconvtactic rundefeqtactic runep +runerrort runfor +runfw rungenhandler +runi runincrement runintro +runit runlinarith runmetam runmetamcapturinginfotree runmetamwithmessages +runner running runongoals runpass runpasses +runproc runrand runrandwith +runreader runs runsimplexalgorithm runstate @@ -65110,11 +71170,14 @@ runtacticcode runtacticcodecapturinginfotree runtermelab runtermelabm +runtest runthe runtime runtreem runuse +runz ruold +rur rusbcalt rusgr rusgrnumwlkg @@ -65138,6 +71201,7 @@ russell rust rust-like rutn +ruusdbeqlen ruv ruvalt ruzsa @@ -65147,6 +71211,7 @@ ruzsaszemeredinumbernat rval rvar rvd +rvec rvecabl rveccmod rveccvec @@ -65158,10 +71223,12 @@ rvecsscvec rvecssmod rvecssvec rvecvec +rvimage rvm rvmimti rvog rvoldn +rvpeq rvr rvrmutdi rvrtsi @@ -65170,10 +71237,13 @@ rvsum rvtsi rw rwa +rwaiting rwf rwlock rwlockspec rwmerge +rwof +rword rwp rwr rwresult @@ -65186,11 +71256,14 @@ rwurgxrfce rxa rxb rxbltdxhmhdgnfxhf +rxfirst rxhfpl rxm rxn rxp +rxsys rxy +rxys rya rykdj ryvfkdzp @@ -65207,7 +71280,11 @@ rᵈᵐᵃ rᵐᵒᵖ saarbruecken sab +sabs +sabstract +saca sacgr +sact sad sadadd sadaddlem @@ -65228,8 +71305,10 @@ sadeq sadfval sadid sadval +saevents safe safedivide +safei safely safen safer @@ -65241,6 +71320,7 @@ safetcg safety saga said +sais sake sal sald @@ -65264,6 +71344,7 @@ salincl salincld saliuncl saliunclf +salli salpreimagelt salpreimagtge salpreimagtlt @@ -65284,15 +71365,26 @@ same sameas samecycle sameexpeq +samef +samefm +samefw +sameiff samekind samep +sameprod sameray samerep sameside samesideline samespace +samet sametype +samp +sample sampleableext +sampled +sampler +samples sancerre sandbox sanders @@ -65306,8 +71398,19 @@ sard sarg sargs sas +sasa +sascaraudiosystem sassign sat +sata +sataxiom +sataxiombounded +sataxiomeq +sataxiomfounded +sataxiomprooftree +sataxiomterminal +satc +satd sate satef satefv @@ -65339,22 +71442,32 @@ satfvsuc satfvsuclem satfvsucom satfvsucsuc +sati satis satisfaction satisfiable +satisfiableappendtautologicalformula +satisfiableappendtautology +satisfiablefiltertautologies satisfied +satisfiedclausecanberemoved satisfies satisfiesm satisfy satisfying satisfytokensfn +satl satom satp +satpb +sats +satterthwaite saturate saturated saturatedsubmonoid saturation satx +sauer sauivxcjpymwlbffmnioyqljncoidjbbdrrvgpiqxlispkujpjcfyznpktpnetygiqxn sauternes sauvignonblanc @@ -65368,6 +71481,7 @@ saves savestate saw say +sayhello saying says sbab @@ -65479,6 +71593,7 @@ sbcthdv sbctt sbd sbdd +sbe sbel sbelx sbeq @@ -65502,6 +71617,7 @@ sbgoldbmb sbgoldbo sbgoldbst sbgoldbwt +sbgrp sbh sbhamde sbhb @@ -65528,11 +71644,13 @@ sbimd sbimdv sbimi sbiota +sbis sbjust sblbis sblem sblim sblimt +sblit sblpnf sbmo sbn @@ -65541,6 +71659,10 @@ sbnfc sbnfold sbo sbor +sbottom +sbounded +sboundedl +sboundedr sbralie sbraliealt sbralieold @@ -65602,11 +71724,14 @@ scalarz scaldiv scale scalebymonom +scalec scaled scaled_ scaledr scalene +scaleq scaler +scalerat scaleroots scales scalew @@ -65614,24 +71739,35 @@ scaling scalingconstantof scalingscaleof scall +scalprod scan scandx scandxnbasendx scandxnmulrndx scandxnplusgndx scanl +scanr +scans scar scard scase scasrng +scast scc +sccs +scd +scdnoninterference +scdom sce scenario +scf +scfinv sch schaeffer schapira schauder schauderbasis +sched schedpeek schedule scheduler @@ -65645,6 +71781,8 @@ schlomilch schmidt schnirelmanndensity scholze +schr +schramm schroeder schroederbernstein schur @@ -65673,9 +71811,13 @@ scln sclnbgrel sclnbgrelself sclnbgrisvtx +sclose +scloseoption sclosure sclrmsm +scls scltm +scm scmap scmapiso scmat @@ -65716,14 +71858,19 @@ scmzhivnnorqikjzpycfblijgrwuduzk scn scombine scomp +scomponent +scompose +scon sconf sconfl +sconjunctive sconn sconnpconn sconnpht sconnpi sconntop scons +sconst scontinue scope scoped @@ -65760,6 +71907,7 @@ scount scov scpqggmcifemunmzkhwkvgo scqqsmgkklqvrvzjotmctakuvtlhun +scr scratc scratch scream @@ -65779,9 +71927,13 @@ sdc sdclem sde sdense +sdfun +sdg sdi sdiff +sdiv sdivr +sdlhppb sdlx sdnn sdom @@ -65793,6 +71945,7 @@ sdomel sdomen sdomentr sdomg +sdominate sdomirr sdomn sdomne @@ -65801,6 +71954,7 @@ sdomnsym sdomsdomcard sdomsdomcardi sdomtr +sdot sdp sdrgacs sdrgbas @@ -65815,6 +71969,8 @@ sdrgss sdrgsubrg sdrgunit sdrop +sds +sdsj sdtasasdt sdtasdt sdtbsmnsldt @@ -65829,16 +71985,19 @@ sdtmndtplgtdt sdtpldt sdtsldt sdtslmnbsdt +sdummy sdv sdvold seal search +searchentry searches searching searchpath searchpathref searchtree searchtreex +searchw seat sec sec-access @@ -65847,6 +72006,7 @@ secant secants seccl secclass +seccomp secmat secmateq second @@ -65864,6 +72024,8 @@ secondly secondmap secondobj secondpart +secondrecursivecalls +seconds secondstep secondtomax secrecy @@ -65873,6 +72035,7 @@ secretkey sect sectcan sectco +sectd sectepi sectffval sectfn @@ -65926,10 +72089,16 @@ sectr sectrcl sectss sectype +sectypeimpliesnoninterference secure +secureequiv +securefilli +secureforattackingcontext +securei securestate security security-level +securityinvariant secval see seed @@ -65956,10 +72125,13 @@ seglem seglemin seglerflx segletr +segm segment +segmentd segmentp segments segofs +seidel seinxp seitxzygyejqgq sel @@ -65983,8 +72155,13 @@ selection selectionpanel selectionrange selectionsortcorrect +selective selectively +selectivemagma +selectlike selector +selectord +selectors selectpivotpart selectpoly selects @@ -65993,6 +72170,7 @@ self self-access self-addition self-adjoint +selfadj selfadjoint selfadjointequiv selfadjointmatricessubmodule @@ -66003,14 +72181,17 @@ selfadjointsubmodule selfadjointunital selfapplyequiv selfbasis +selfbutter selfcaused selfcoloring selfequivorbitsquotientprod selfequivsigmaorbits selfequivsigmaorbitsquotientstabilizer +selfinverse selfiscommonfactor selfleradical selfleradicaldiagram +selfloop selfprod selfprodpermincl selfprodproj @@ -66037,12 +72218,17 @@ selvmul selvval selvvvval sem +sema semantic +semanticpossibleworldforsyntacticpossibleworlds semantics +semanticsinduct semaphore +semassignsc semax sembv semc +semclosed semi semiadditiveofbinarybiproducts semicartesianmonoidalcategory @@ -66052,17 +72238,23 @@ semicolonlinter semiconj semiconjby semiconjugate +semiconnex semicontinu semicontinuity semicontinuous semicontinuousat semicontinuouson semicontinuouswithinat +semidecisive semidefinite semidirectproduct semidirectproductmulequiv semidirectproducttogroupextensionequiv semidirectsum +semidom +semieq +semifeasib +semifeasible semifield semifields semifieldsemidivisionring @@ -66074,6 +72266,7 @@ semigroupwithzero semigrp semigrpisotomulequiv semiinnerproductspace +semijoin semila semilatinf semilatinfcat @@ -66107,9 +72300,13 @@ semilinearmapaddequiv semilinearmapclass semillon semillonorsauvignonblanc +semimedial +semimedialmagma +semimetric semimodule semimodulecat semimodules +semimultiplicative seminorm seminormaux seminormclass @@ -66135,6 +72332,7 @@ seminormfromconstringnormoffield seminorms semiopen semiquot +semired semiri semirin semiring @@ -66145,9 +72343,12 @@ semiringcatisotoringequiv semiringhom semiringoperators semirings +semiringwithoutannihilatingzero +semiringwithoutone semisimple semisimplicity semistandardyoungtableau +semitype sems semsem semsource @@ -66157,6 +72358,7 @@ sen send sender sending +sendmsg sends sense sensible @@ -66164,6 +72366,7 @@ sensitive sent sentence sentinel +sentouterfriendids senv seo sep @@ -66228,16 +72431,21 @@ seqaddgrouphom seqappendassoc seqappendlength seqappendnil +seqauto +seqcallrule seqcaopr seqcl seqclosure seqcoll seqcompact seqcompactspace +seqcompositionality +seqcondrule seqcontinuous seqcvg seqcvgd seqdistr +seqdyncomrule seqeq seqex seqexw @@ -66247,7 +72455,9 @@ seqfiltersubseq seqflattenlength seqfn seqfveq +seqguardrule seqhomo +seqi seqid seqk seqleft @@ -66264,6 +72474,7 @@ seqomeq seqomlem seqomsuc seqp +seqpar seqpo seqres seqreverselength @@ -66276,7 +72487,17 @@ seqsfn seqshft seqsp seqsplit +seqstar seqstr +seqsubs +seqsubscons +seqsubsnil +seqsubst +seqsubstcons +seqsubstermappend +seqsubstnil +seqsubstsimps +seqsubsttermappend seqsum seqsval seqtakedropidentity @@ -66288,6 +72509,8 @@ seqtl seqtlobv sequence sequenced +sequencee +sequencei sequenceiso sequenceofcofinals sequences @@ -66308,6 +72531,7 @@ sequentialtolightcondset sequentialtotal sequentialtotop seqval +seqwhilerule seqz ser seradd @@ -66337,6 +72561,9 @@ servernethandler servertype serves service +ses +sesk +seskey sesq sesqform sesquilinear @@ -66363,6 +72590,7 @@ set-option set_append set_simps set_w +seta setact setadd setaddorderofequiv @@ -66399,14 +72627,19 @@ setciso setcmon setco setcoe +setcompr setcongr setcontinuous setcsect setcsnterm setcthin +setcurrentdirectory setcval setd +setdc setdemorgan +setdi +setdiff setdist sete seteasprevious @@ -66416,6 +72649,8 @@ setencard setentropylen setenv seteq +seteqi +setequ setex setexp setexporting @@ -66426,11 +72661,15 @@ setextt setfailifunchanged setfam setfamily +setfin +setfinal setfinite setfiniteconstructors setfintype +setflags setgcd setgoals +sethi seti setici setifinbounds @@ -66443,17 +72682,22 @@ setindregs setinds setindtr setindtrs +setinit setint setinte setintegral setintercomm setinterior +setinterleaves +setinterleaving +setinterleavinglist setintersubset setinvon setis setisotypiccomponents setkey setkind +setl setlaverage setlet setlevelnames @@ -66464,6 +72708,7 @@ setlike setlikespec setlintegral setm +setmarkinv setmax setmaxperm setmctx @@ -66478,6 +72723,7 @@ setminusirneg setminuslsub setminussubset setminust +setmn setmul setn setname @@ -66489,8 +72735,10 @@ setnotation setnth seto setof +setofd setoffloorneg setoffloorpos +setofformulaswithlabeldiffactive setoffractne setofideal setofmaximalisosetofminimal @@ -66505,6 +72753,8 @@ setoidprestructure setok setoption setoptionlinter +setp +setpc setpermblock setpi setpredictionresistance @@ -66513,6 +72763,7 @@ setpreimage setprod setprodequivsigma setprotected +setr setrange setrec setrecs @@ -66524,11 +72775,13 @@ setrel setrelid setrelisseparated setreseedinterval +setrip setrp sets setsabs setsat setscom +setsd setsdm setsemiring setseq @@ -66536,10 +72789,12 @@ setseqaux setsetoid setsexstruct setsfun +setsi setsid setsidel setsidvald setsiedg +setsimp setsimptheorems setsms setsmsbas @@ -66568,9 +72823,11 @@ setsymm setsyntax sett settag +settextpost settheory setting settings +settitlepost settle settled settlement @@ -66599,6 +72856,7 @@ setup setuplctx setusername setvalue +setvar setvariation seu seulement @@ -66613,23 +72871,37 @@ sex sexg sexp sexualreproduction +sfd sfg sfi sfields +sfilter sfin sfind sfinite sfiniteseq sfirst +sfis +sfix sfn +sfoldl sfor +sfp sfprmdvdsmersenne +sfs sfsstate sft +sfun +sfunction +sfv +sfw +sfwsomed sfx sga +sgas sgcd sge +sgl sgm sgmcl sgmf @@ -66660,6 +72932,7 @@ sgnsub sgnsv sgnsval sgnval +sgnx sgnz sgoldbeven sgon @@ -66692,24 +72965,37 @@ sha256 shaddcl shadow shadowed +shadows shake +shakey shalf shall +shallow +shallower shape shapeattribute +shaped +shapei shapes +shapley share shared sharedmemory shares sharhght sharing +sharingf +sharingi +sharingr +sharings sharp sharper shatomici shatomistici +shattered shatterer shatters +shbaseclass shc shd sheaf @@ -66794,12 +73080,15 @@ sheaftotype sheaftotypes sheafvalgluedmk sheafyonedahom +sheap shear sheardivright shearing shearmulright +shearsort sheaves shel +shelah shelf shelfhom sheli @@ -66861,6 +73150,7 @@ shiftmonoidal shiftmonoidalfunctor shiftnegshift shiftout +shiftpah shiftpath shiftr shiftright @@ -66891,6 +73181,7 @@ shjshsi shjval shl shle +shleg shlej shlesb shless @@ -66911,6 +73202,8 @@ shocorth shocsh shocss shom +shomsgvectors +shonextconfig shooting shop short @@ -66938,8 +73231,12 @@ shortcut shortcutting shorten shortened +shortening shortens shorter +shorterd +shortere +shorteri shortest shortest-path shortestpath @@ -66951,24 +73248,50 @@ shorthands shortlex shortname shortroot +shortv +shorun +shos shot should shouldn shouldtranslateunsafe show +showatprecision +showbit +showbits +showcmdspec +showdefinition +showdigit showed showfoo +showhexa +showinbase showing +showints showlinter +showliteral shown shownames +shownats +showquantity +showrats +showrel +showrelevance shows +showsimple +showsp +showsx +showtests showtiming +showtrailing +showvisibility +showx shr shrb shrin shrink shrinkcompuliftfunctoriso +shrinkdisjoint shrinkequiv shrinkfoo shrinkfunctor @@ -67030,12 +73353,17 @@ shsvs shsvsi shub shuffle +shufflelr shuffling shuni shunssi shunssji +shunting +shupd shutdown shutdownhook +sia +sib sibf sibff sibfima @@ -67043,6 +73371,7 @@ sibfinima sibfmbl sibfof sibfrn +sibling sid side sided @@ -67062,8 +73391,11 @@ sieveofsubfunctor sieveofuliftsubfunctor sieves sievestruct +sift +siftdown sifted siftedsum +sifum sig sigaclci sigaclcu @@ -67100,8 +73432,12 @@ sigarperm sigarval sigasspw sigaval +sigcod +sigdom sigf sight +sigid +siginificant sigma sigma-1 sigma-2 @@ -67131,6 +73467,7 @@ sigmaconstadj sigmacurry sigmacurryequiv sigmacurrylequiv +sigmad sigmadesc sigmaequiv sigmaequivoptionofinhabited @@ -67156,6 +73493,7 @@ sigmafinsupplequivpifinsupp sigmafixedbyequivorbitsprodgroup sigmafunctor sigmahom +sigmai sigmaimp sigmaincl sigmainclincl @@ -67201,7 +73539,9 @@ sigmauliftpliftequivsubtype sigmauncurry sigmaunique sigmoid +sigmoidal sign +signabs signal signature signatures @@ -67219,6 +73559,7 @@ significant significantly significative signlem +signof signs signset signshf @@ -67262,6 +73603,7 @@ signvariations sigpos sigs sigt +sigtyid sih sii siii @@ -67274,9 +73616,17 @@ sillyfun silver silverman sim +simabs +simaction +simeq similar similarity similarly +siminit +simm +simmc +simmct +simobs simon simp simp_all @@ -67317,6 +73667,8 @@ simple-path simple_walks simple_walks_def simple_walks_finite +simpledef +simpledefs simplef simplefunc simplefuncaux @@ -67324,8 +73676,10 @@ simplefuncdenselp simplefuncintegral simplegraph simplegraphofstructure +simplei simplelog simplemma +simplepath simpler simplering simplerpartition @@ -67333,6 +73687,7 @@ simples simplescopedenvextension simplesubobject simplesubobjectarrow +simpleuse simplex simplexalgorithm simplexalgorithmdense @@ -67344,6 +73699,8 @@ simplexcategory simplexcategorygenrel simplhs simpli +simplice +simplices simplicial simplicialcategory simplicialcomplex @@ -67351,6 +73708,7 @@ simplicialcosimplicialaugmentedequiv simplicialcosimplicialequiv simplicialeval simplicialhomotopy +simpliciali simplicialinsert simplicialnerve simplicialobject @@ -67419,11 +73777,14 @@ simptheoremsofnames simpthms simptype simson +simtrans +simul simulate simulation simulink simultaneous simultaneously +simval sin sinacos sinadd @@ -67445,6 +73806,7 @@ sind sinds sine sineq +sineqs sineterm sinf sinfclosed @@ -67452,6 +73814,8 @@ sinfgen sinfhom sinfhomclass sing +singe +singelton singl single single-edge @@ -67459,11 +73823,17 @@ singleaddhom singleaddmonoidhom singlealghom singleandzipwith +singlecombinators +singlecombinatorsconc singlecompeval singlecompevalisoself singlecontinuousaddmonoidhom singlecontinuouslinearmap +singledestn singledistribmulactionhom +singledsource +singledsourceempty +singledsourceloop singleequalizercondition singlefunctor singlefunctorcomphomologyfunctoriso @@ -67474,6 +73844,7 @@ singlefunctorspostcompqhiso singlefunctorspostcompqiso singlefunctorspostcompquotientiso singlehom +singlei singlelinearmap singlemaphomologicalcomplex singleobj @@ -67492,11 +73863,14 @@ singleprod singleruletac singlesubsingle singlet +singletape singleto singleton singletonchartedspace +singletond singletonequiv singletonfinsubgraph +singletoni singletoninpowerset singletoninpowunion singletonmonoidhom @@ -67510,6 +73884,8 @@ singletonsubgra singletonsubgraph singletonsubset singletonsuniq +singletont +singletr singletriangle singletriangleiso singleunexpander @@ -67517,7 +73893,10 @@ singlezeroalghom singlezeroringhom singleδ singling +singlpart +singlton sings +singstr singular singularchaincomplexfunctor singularchaincomplexfunctorisooftotallydisconnectedspace @@ -67538,10 +73917,14 @@ sinhhomeomorph sinhorderiso sinhpcosh sinhval +sini sinit sinitcg +sink sinkernel sinkpi +sinks +sinl sinltx sinmpi sinmul @@ -67559,13 +73942,20 @@ sinpim sinpoly sinppi sinq +sinr sinsub +sint sinter sintro +sints sinv sinval +sinvar sinzeta sio +sip +sisj +siso sit site siterate @@ -67579,6 +73969,8 @@ sitgclre sitgf sitgfval sitgval +sitj +sitjsi sitm sitmcl sitmf @@ -67592,17 +73984,21 @@ sixe sixteen sixteenbyte sixth +siz size sizea sized sizedcorrect sizedmonotonic sizedproofeqs +sizedset +sizee sizel sizemonotonic sizemonotonicsuchthatopt sizemonotonictyp sizeof +sizeofobjectpos sizes sizeslib sizestx @@ -67611,7 +74007,9 @@ sizewithoutsharing sizusglecusg sizusglecusglem sjo +sjsi sjsktwshgupcwhfxtxoasfaiajrrbegtcvtfmhmofx +sjti sjx skadj skein @@ -67652,17 +74050,26 @@ skip skipconstinapp skipdef skipleft +skipmonotone skipn +skipnot +skipp skipped skippedfilesegments skipping skipprivate skiprealize +skiprule skips skipstring +skipt skk skolem skolemization +skolemize +skolems +skomod +skopre skos skp sks @@ -67686,6 +74093,7 @@ skyscrapersheafforgetadjunction skyscrapersheaffunctor skyscrapersheaffunctorcompsheafpushforwardcontinuous skyusxutkawjvzjkj +sla slaction slash slashaction @@ -67697,27 +74105,37 @@ slayer slb slbdtrb slbdtsldtrb +slc slcrc sle sledgehammer sleepatleastheartbeats slemma +slen +slength slesolex slesolinv slesolinvbi slesolvec +slg sli slice slicef sliceleft +slicer sliceright +slices slicesizes slick +slide slight slightly slime slinkedlist +slist +slit slitplane +sll sllambda slmd slmdacl @@ -67740,8 +74158,11 @@ slmodularaction slnil slo slonglpos +slookup slop slope +slopefinite +slopei slopes slot sloteq @@ -67757,13 +74178,18 @@ slotsdnscsi slotsinbpsd slotslnbpsd slotstnscsi +slotted slow slower slowly slows +slp +slpa slrmznougxlapealbvspkopuyzehglvurtf sls +slsd slsdtgt +slsided slstar slt sltmuls @@ -67811,6 +74237,8 @@ smallcomplement smallcoproductdesc smallequiv smaller +smallerd +smalleri smallest smalletalepretopology smalletaletopology @@ -67820,7 +74248,9 @@ smallgrothendiecktopologyofle smallhom smallhommap smallmodel +smallo smallobject +smallomega smalloption smallpretopology smallschroder @@ -67830,6 +74260,9 @@ smallsheafify smallshiftedhom smallshiftedhommap smallstep +smallstepi +smallsteps +smallstepsi smap smart smarter @@ -67847,6 +74280,7 @@ smattl smattr smatvscl smblfn +smc smci smcn smcnlem @@ -67924,6 +74358,7 @@ smgrpismgmold smgrpmgm smgrpssmgm smgrpssmgmel +smile smin smith smithcoeffs @@ -67934,6 +74369,7 @@ smithnormalformcoeffs smithnormalformofle smithnormalformofrankeq smithnormalformtopbasis +smj smk smn smndex @@ -67947,6 +74383,7 @@ smodeq smodm smodnat smodnattr +smods smoel smoeq smofvon @@ -67988,12 +74425,14 @@ smoothsheafring smoothtransition smores smoword +smpf smprngopr smsi smt smt-lib smth smtlib +smtoms smtpat smu smucl @@ -68009,6 +74448,7 @@ smulbasis smulbracketcommclass smulc smulcandidate +smulcc smulcommclas smulcommclass smulcon @@ -68018,6 +74458,7 @@ smuld smuldistribclass smuldivisionring smuldivisionsemiring +smulextp smulfamily smulfderiv smulfinset @@ -68081,6 +74522,9 @@ sname snap snaps snapshot +snapshoti +snapshots +snapshotted snatpsubn snaw snb @@ -68102,6 +74546,7 @@ sndkernelfork sndl sndpimap sndpimapofislimit +snds sndsigmamap sndsigmamapofiscolimit sndsize @@ -68146,6 +74591,7 @@ snglss snglsstag sngltag sngltagi +sngr snhesn sni snid @@ -68153,6 +74599,7 @@ snidb snidg sniffsupp snifpsrbag +snil sniota snjust snlbtdsvscxtbrfy @@ -68181,9 +74628,13 @@ snnzg sno snoc snoccases +snocd snocequiv +snoci snocinduction +snocl snocorderiso +snocview snoeq snolev snolt @@ -68193,6 +74644,7 @@ snopfsupp snopiswrd snopsuppss snor +snorm snormlesnormfderivofeqconst snowflaking snp @@ -68222,6 +74674,7 @@ snsymgefmndeq snth snu snuffle +snull snum snumcoe snunico @@ -68229,6 +74682,7 @@ snunioc snunioo snvonmbl snwf +soa soaienpnekgeojttampqmtdjahkpfsvb soasym sober @@ -68236,10 +74690,14 @@ sobolev socialinteraction socialrole socnv +socrates +socratesmortal soeq soex sofld sofleftinverse +softplus +softsubst soindefiniteequiv soinxp soirri @@ -68248,6 +74706,15 @@ soisores sokoban sol sold +soldallocationisallocation +soldallocationisallocationvariant +soldallocationisrestricted +soldallocationrestriction +soldallocations +soldallocationsequivalence +soldallocationsequivalencevariant +soldallocationsfinite +soldallocationvariantequivalence solely solem solid @@ -68255,7 +74722,11 @@ solidclosure solidnorm solin solitaire +solo solovay +sols +solsd +solsi solspace soltmin solution @@ -68267,26 +74738,35 @@ solvablebyrad solve solved solveeq +solvei +solvent solver solver-backed solvers +solves +solvet solving som some somebasis somecontdiffbumpbase +somed somedecidable somee someexistsonedivlt somehow somei +somemode +somenats someoctahedron someone somepath somepos somerayvector +somes something sometimes +sometrace somevec somevector somewhat @@ -68301,12 +74781,17 @@ sont soon soopen sop +sopen +sopenoption +sophomores sopo soppside +sops soptisr soptiss soptist sor +sorigin sornom sorpss sorpsscmpl @@ -68323,25 +74808,35 @@ sort sortclass sortcount sorted +sorteda sortedfrom sortedge sortedgt +sortedi sortedle sortedlist sortedlt +sortedtree sorteduniv sorteduntil sortequiv +sorter sorti sorting +sortingalgorithm +sortlemmal +sortlemmar sortlevel sortlinearorder sortok sorts +sos soseq sosn soss sossfld +sot +sota sotr sotrd sotri @@ -68350,33 +74845,53 @@ sotrieq sotrine soun sound +soundaux soundc soundness soup +sour sourc source source-highlighter sourceaffinelocally +sourceexistsdsource sourcehomeomorphbasesetprod sourceindividual sourceinfo sourcelocalclosure sourcemachinesig sourcen +sourcenode +sourcenodes sourcenone +sourceofdsource sources +sourcesabstrlevel +sourcesemptydsources +sourceslevellimit +sourcesnot +sourcesonlydsources sourcethreadpool south +sov soxp spa spac space spaced +spacei +spacem +spaceml +spacemn +spacen +spacenl spacer spaces +spadesuit spae spaev spain +spair spalt span spancl @@ -68392,13 +74907,16 @@ spanfinset spanfunctor spanfunctorisoindexfunctor spanhommk +spani spanid spanintnorm spanisomk +spannable spanned spanning spanningcoe spanningcoeequivcoeofspanning +spanningforest spanninghom spanningset spanningsets @@ -68440,13 +74958,19 @@ spanuni spanunop spanunsni spanval +sparc spark sparksmt +sparse +sparsegrid +sparsegride +sparsegridi sparsematrix sparsepairs spass spaths spathson +spatial spawn spb spc @@ -68478,7 +75002,9 @@ spec_par specbase speccapp speccl +specd specfun +speci specia special specialadjointfunctortheorem @@ -68515,6 +75041,7 @@ specifies specify specifying speciso +speckeys speckeyssecrets speclinelist specmap @@ -68527,9 +75054,12 @@ specofpoint specofsurjective specprod specpunitisinitial +specrule specs +specsecrets specsheafedspace specstalkequiv +spect spectargetimage spectargetimagefactorization spectargetimageideal @@ -68566,6 +75096,7 @@ speculative speculiftzisterminal specval speczisterminal +spedges speed speeds speedup @@ -68590,7 +75121,9 @@ sphere spheres spherical spi +spied spiegel +spies spike spilling spim @@ -68664,12 +75197,18 @@ splitepiofidempotentofiscolimitcofork spliter splitevenodd splitexact +splitextension +splitextensions +splitf +splitface +splitfilename splitfun spliti splitif splitifscore splitindpred splitinjectiveequiv +splitleaf splitlem splitlength splitlengths @@ -68689,6 +75228,7 @@ splitmonoofidempotentofislimitfork splitmpt splitmul splitne +splitnlist spliton splitonnotnumber splitonp @@ -68700,6 +75240,7 @@ splitsn splitsupport splitsurjectiveequiv splittable +splitted splitthenconstructor splitting splittingfield @@ -68716,11 +75257,15 @@ splitvector splitwrtcomposition splitwrtcompositionaux spllen +splus splval splysubrg splyval spm +spmax +spmf spminusf +spmods spn spnfw spo @@ -68731,12 +75276,17 @@ spolyp spolyq sponge spot +spp spr +spray sprbisymrel +spre spread spreads +sprei sprel sprid +spring sprmpod sprod sprop @@ -68770,6 +75320,7 @@ spthdep spthdifv spthispth spthiswlk +spthlen spthond spthonepeq spthonisspth @@ -68805,6 +75356,7 @@ sqdivd sqdivi sqdivid sqdivzi +sqdot sqe sqeq sqeqd @@ -68820,6 +75372,7 @@ sqge sqgeq sqgt sqi +sqinter sqle sqlecan sqlei @@ -68836,6 +75389,7 @@ sqn sqne sqneg sqnegd +sqnf sqnn sqnorm sqnprm @@ -68925,7 +75479,10 @@ sqsqrtd sqsqrti sqsscirc sqstruct +sqsubset +sqsubseteq sqsubswap +sqsum sqsumi sqto squ @@ -68934,6 +75491,7 @@ squarecylinders squared squarefree squarefreehelper +squarei squareleft squareright squares @@ -68950,9 +75508,11 @@ squeezed squeezedltsq squelet squelette +squnion sqval sqvald sqvali +sqweeze sqwvfoura sqwvfourb sqx @@ -68987,6 +75547,7 @@ sratopn sratset sraval sravsca +srblit src srcctxt srcdecl @@ -68995,7 +75556,11 @@ srcexpr srcexprofiso srcfield srcfields +srcfix +srcfixij srci +srcinnetlistaux +srcj srclemma srclemmas srclist @@ -69003,12 +75568,18 @@ srcm srcmap srcmpltd srcnat +srcnet srcs srcstartpos +srcsyncv srctype srcvars srec +sreg srel +sreplicate +sretr +srewrite srg srgacl srgass @@ -69047,6 +75618,7 @@ srhmsubclem sring sringcat sringcataltv +srl srng srngadd srngbase @@ -69063,7 +75635,13 @@ srngring srngstr srossspw srpr +srs +srsd +srsided +srstep +srsteps srt +srules ssa ssab ssabdv @@ -69085,6 +75663,8 @@ ssbr ssbrd ssbri ssc +sscan +sscanl sscase ssccatid ssceq @@ -69135,6 +75715,7 @@ ssdmral ssdmres ssdomfi ssdomg +sse ssel sseld sselda @@ -69189,12 +75770,15 @@ ssfzoulel ssfzunsn ssfzunsnext ssge +ssgp +ssgq sshaus sshauslem sshepw sshhococi sshjcl sshjval +ssi ssid ssidcn ssidd @@ -69202,6 +75786,7 @@ ssiin ssiinf ssimaex ssimaexg +ssimple ssin ssinc ssind @@ -69217,6 +75802,7 @@ ssipeq ssitem ssiun ssiunov +ssize ssjo sskip sslin @@ -69257,7 +75843,9 @@ ssonunii ssopab ssoprab ssorduni +ssort ssp +sspace sspadd sspba sspg @@ -69372,9 +75960,14 @@ ssttrcl ssu ssubq ssubset +ssubseti ssubsets +ssubst +ssubstoption ssubt +ssuffixes ssufl +ssum ssun ssuncl ssundif @@ -69398,15 +75991,21 @@ ssv sswf sswfaxreg sswrd +sswsts +ssx ssxnn ssxpb ssxr +ssy +ssys ssz sszcld sta stab +stabiliser stabilises stability +stabilize stabilizer stabilizerequiv stabilizerequivstabilizer @@ -69420,8 +76019,10 @@ stabilizerquotientinertiaequiv stabilizers stabilizersubmonoid stabilizes +stabl stable stablefiltration +stables stableunderbasechange stableunderco stableundercomposition @@ -69432,11 +76033,15 @@ stableundergeneralization stableunderinverse stableunderspecialization stabpeirce +stabulate stack stackargs stackentry stackexchange stackframe +stackloc +stackmark +stackoverflow stackpush stacks stackstag @@ -69445,10 +76050,12 @@ stackstagfn stackstagkind stackstagnoantiquot stackstagparser +stackvalue stact stadd staddi stadt +stae staffn staffval stafval @@ -69456,6 +76063,7 @@ stage staged stageone stagetwo +stai staindata stained stains @@ -69489,6 +76097,7 @@ stalktolocalization stalkwise stalkwiseiszariskilocalattarget stampedmap +stand standalone standard standardbasis @@ -69498,12 +76107,14 @@ standardcomplex standarddef standardetalepair standardetalepresentation +standardi standardize standardonedimisocrystal standardresolution standardsimplex standardsubspace stands +stape stappf stappp stappt @@ -69534,29 +76145,39 @@ starclosure starcomp starcontinuousmap starconvex +stard +stardestructive +stardiff starequation starequationabs starequivcostar +starexpansive stargr starhom starhomclass +stari staridem starinitial +starisessential starisoinitial starisoterminal starl starleastfixpoint starleastfixpointabs +starleftdestructive +starleftexpansive starlem starlift starlike starlinearequiv +starlr starmap starmemclass starmodule starmul starmulaut starmulequiv +starnecexists starnormal starnormedaddgrouphom starofab @@ -69567,6 +76188,10 @@ starorderedring starprojection starproperty starpullbackisostar +starr +starray +starrightdestructive +starrightexpansive starring starringaut starringend @@ -69576,6 +76201,8 @@ starringhomclass starringofcomm starringofcommcentroidhom stars +starse +starsi starski starsubal starsubalgebra @@ -69585,12 +76212,16 @@ start started starterminal starting +startingfrom +startnode +startof startpoint startpos startpsp startpss starts startswith +startsymbol starttime starvid starvndx @@ -69598,28 +76229,56 @@ starvndxnbasendx starvndxnmulrndx starvndxnplusgndx stat +stata +stataa state stated +statediff +statee stateful statehandler +stateinterpol +stateless statelp statem statemachine statement statements +stateo +stateof stateqtint statereft states states_ +statesaudioplayer +statescaraudiosystem +statescdmode +statescdplayer +statesd +statesdecls +stateselectors +statespace +statesroot +statestunermode statet +statetialternative +statetiapplicative +statetiapplicativezero +statetimonad +statetimonadplus +statetimonadstate +statetimonadzero statetransition statevars static statically +staticsecret stating stationary stationaryartifact stationarypoint +stato +statoo statpcp statpsp statpss @@ -69629,8 +76288,13 @@ statuses stay staying stays +staysenabled +staysenabledhelp +staysenabledstep stb stc +stcal +stcalwb stcclb stccn stccnp @@ -69666,6 +76330,7 @@ stdmp stdo stdorthono stdorthonormalbasis +stdout stdpart stdpc stdrefl @@ -69685,15 +76350,23 @@ stempty step step1 step2 +stepa stepanov stepasync stepaux +stepb stepback stepbound +stepc +stepd +stepe stepfailure stepfor +stepi +steplemma stepn stepnormal +stepo stepordered stepordereddyn stepordereddynamic @@ -69703,6 +76376,8 @@ stepret steps stepsa stepset +stepsl +stepss stepstar steptype stepwise @@ -69716,6 +76391,9 @@ stereographicprojection stereoinvfun stereoinvfunaux stereotofun +sterm +stermsl +stern stexists stf stfcl @@ -69742,8 +76420,10 @@ stgrnbgr stgrorder stgrusgra stgrvtx +sth sthil sticksstones +sticky sticl stieltjes stieltjesfunction @@ -69751,9 +76431,14 @@ stieltjesfunctionaux stieltjesfunctionrightlim stieltjesofm stieltjesofmeasurablerat +stileturn still stillconvex stillnz +stimcomm +stimes +stimuli +stimulus stinct stinl stinr @@ -69769,6 +76454,7 @@ stitched stj stji stk +stklength stl stldt stle @@ -69776,6 +76462,7 @@ stlei stlem stlesi stm +stmap stmbfm stmem stmt @@ -69784,8 +76471,10 @@ stmtstrec stn stnpr sto +stoch stochastic stock +stocks stoic stoig stolz @@ -69805,6 +76494,8 @@ stonecechextend stonecechobj stonecechunit stop +stopi +stopl stopped stoppedabove stoppedin @@ -69814,6 +76505,7 @@ stopper stoppers stopping stoppos +stopr stops stoptk stopws @@ -69823,28 +76515,41 @@ store_thm storebytes stored storeeffect +storeelim +storeloc +stores storev story stowei stoweid stoweidlem +stp +stpa +stpb stprc stpreima stpreimas stprincd str straddle +straight +straighten straightforward straightforwardly strand strands strange strarrowmk +strat strategies strategy strategydescr +strategyproof +stratified stratify +stratproof stratum +straus strb strbas strcat @@ -69854,6 +76559,7 @@ streamadd streaming streamline streams +streamstep street strength strengthen @@ -69882,6 +76588,8 @@ strictconcaveon strictconvex strictconvexon strictconvexspace +strictexpr +strictify strictimplicit strictindexes strictinitial @@ -69889,9 +76597,13 @@ strictlimitsclosureiter strictlimitsclosurestep strictlimitsofshape strictly +strictlycontracting +strictlycontractingonorbits +strictlyinverse strictlypositive strictlypositivecone strictlyprecedes +strictlysurjective strictlyunitarylaxfunctor strictlyunitarypseudofunctor strictmap @@ -69906,9 +76618,11 @@ strictorderedp strictorderedring strictorderedsemiri strictorderedsemiring +strictpartialorder strictperiods strictpseudofunctor strictpseudofunctorprecore +strictrelation strictsega strictsegal strictsegalcore @@ -69934,7 +76648,10 @@ stringsep strinv strip stripbv +stripextension +stripped stripping +strippis strips striptraceresultprefix strle @@ -69951,6 +76668,8 @@ strong strongconcaveon strongconvexon strongd +strongdb +strongdlhppb strongdownwardinduction strongdownwardinductionon strongdual @@ -69958,6 +76677,7 @@ strongepi strongepicategory strongepimonofactorisation strongepimonofactorisationsigmadesc +strongeq stronger strongest strongfepair @@ -69988,24 +76708,31 @@ stronglysorted strongmono strongmonocategory strongorder +strongpostdomination strongrankconditio strongrankcondition strongrec strongrecaux strongrecon +strongred strongrelease +strongsemieq +strongsemired strongsubrecursion strongtrans strop strov +strq strs strss strssd strstr strstx +strt struc struct structcnvcnv +structd structex structfield structfn @@ -70014,8 +76741,10 @@ structfung structgrssiedg structgrssvtx structgrssvtxlem +structi structid structiedg +structinduct structinstfield structn structname @@ -70064,9 +76793,11 @@ struggle struggled struggling strun +struth strval strwun strwunbndx +sts stt stub stuck @@ -70083,10 +76814,15 @@ stupidtruncfunctor stupidtruncmap stupidtruncxiso sturm +stut +stutinv +stutter +stutterd stuttering stutterpath stv stval +stvalue stvar stwhqexbd stwrite @@ -70103,6 +76839,7 @@ styleexceptions styling stylish stype +stypes sub sub-expression sub-expressions @@ -70117,7 +76854,9 @@ subaddd subaddeqd subaddi subadditive +subadditived subadditivehomclass +subadditivei subaddmulsub subaddrii subadds @@ -70139,7 +76878,9 @@ subarray subat subattribute subb +subbalance subbascn +subbase subbasis subbimodule subbox @@ -70154,10 +76895,12 @@ subcat subcategories subcategory subcategoryacyclic +subcc subccat subccatid subccocl subcfn +subchain subcid subcidcl subcl @@ -70166,6 +76909,11 @@ subclasses subclassof subcld subcli +subcls +subclsr +subclsrd +subclss +subclssd subcmn subcn subcncf @@ -70174,9 +76922,12 @@ subcollectionofwithrelationfromtypefn subcollectionofwithrelationtofn subcollections subcom +subcomm +subcomp subcomplex subcomplexofsimplex subcompnormhom +subcomponents subconst subcos subcounttype @@ -70185,20 +76936,35 @@ subcrcl subcss subcssc subd +subdag +subdecompv +subdegree +subdenest subdi subdid +subdigraph subdii subdir subdird subdiri +subdis +subdisl +subdisr +subdist +subdistl +subdistr subdivcomb +subdivface subdivision +subdivisions subdom subdome subdpideal +subdprodr subdrgint subdring subeluzsub +subemp subeq subeqrev subeqxfrd @@ -70207,6 +76973,7 @@ subex subexpr subexpression subexprpos +subexprs subexsub subextensions subf @@ -70225,9 +76992,15 @@ subfieldclass subfieldcongr subfields subfieldvalued +subfilt subfilter +subfmlas +subformula +subformulae subformulas +subfrmls subfrmlsn +subfrmlsr subfunctor subfv subfzo @@ -70308,11 +77081,14 @@ subgsubcld subgsubm subgtgp subhalfhalf +subhypergraph +subhypergraphi subi subid subidd subideal subidi +subinf subinterval subintervals subinvsmul @@ -70324,6 +77100,7 @@ subiwrd subiwrdlen subject subject-red +subjective subjectiveassessmentattribute subjects subjectsc @@ -70345,6 +77122,7 @@ sublistslen sublistslenaux sublocale sublog +subls sublt sublterm subm @@ -70352,6 +77130,7 @@ submabas submacs submaeval submafval +submap submarchi submartingale submat @@ -70359,6 +77138,7 @@ submateq submateqlem submatminr submatres +submatrices submatrix submatrixequivinvertible submatrixequivinvertibleequivinvertible @@ -70389,6 +77169,7 @@ submnd submo submod submodaddmod +submodel submodlt submodneaddmod submodu @@ -70439,6 +77220,7 @@ submuladdd submuladdmuld submultiplicative submultiplicativehomclass +submultiset subn subnac subnat @@ -70453,8 +77235,10 @@ subnegzeromonoid subneintr subneintrd subnet +subnets subnetstr subnn +subnodes subnormal subobj subobje @@ -70468,6 +77252,7 @@ subobjectorderiso subobjectrepresentableby subobjects subobjectsubobject +subobjs subocc subofld suboneintegralpowerbasis @@ -70480,8 +77265,10 @@ subordinateorthonormalbasis subordinateorthonormalbasisindex subordinateorthonormalbasisindexfiberequiv suborng +subpalindromes subpath subpathaux +subpaths subpathtranssubpath subpathtranssubpathrefl subperm @@ -70490,6 +77277,7 @@ subpowsu subpredexistsl subpresheafcontinuousprelocalisopresheaftotop subpresheaftotypes +subprob subproblem subprodxsubc subprograms @@ -70513,6 +77301,7 @@ subreluniviso subrepresentation subrepresentationsubmoduleorderiso subresre +subresultant subrfld subrfn subrfv @@ -70586,6 +77375,7 @@ subsaliuncllem subsalsal subsaluni subscan +subscc subscheme subschemecover subschemefunctor @@ -70597,11 +77387,14 @@ subscld subscript subscripts subscriptterm +subsd subsdid subsdird subsdrg subse subsection +subsegmenti +subsel subsemigroup subsemigroupcenter subsemigroupcomap @@ -70616,6 +77409,7 @@ subsemiringclosure subsemiringcongr subsemiringmap subsemirings +subsep subseq subseqb subseqs @@ -70624,13 +77418,18 @@ subsequences subsequent subsequently subset +subsetbuild +subsetd subsete subsetemptysetimpeq subseteq +subseteqi subseti subsetinfset subsetofnat subsetprodlex +subsetrecursor +subsetrecursorbuilder subsetrefl subsets subsetsify @@ -70640,6 +77439,8 @@ subsetsupset subsetti subsettrans subsf +subsfatom +subsfconj subsfn subsfo subsge @@ -70660,6 +77461,8 @@ subsingletonequivfreecommring subsingletonhelim subsingletonprodselfequiv subsingletons +subsjustified +subslist subsmonoid subsp subspace @@ -70669,60 +77472,91 @@ subsq subsqi subsquare subss +subsset subst substalghom substance substandard substantially +substassoc +substate substax +substclosed +substclosure +substcond substd +subste +substexp substfunc substi substitute substitutes substituting substitution +substitutiont +substitutionts +substitutive +substl +substmem substmonoid substok substopt substr substring +substrings substructural substructure substructureequivmap substructurereduct substructures substs +substsnt +substt +substterm +substtrans substupdate substupdateok substw +substwelldefined +substxine subsub subsubadd subsubc subsubd subsubelfzo +subsubformulae subsubg subsubm subsubmgm subsubrg subsubrng subsubs +subsum subsume subsumed +subsumee +subsumer subsumes +subsuming +subsummable subsumption +subsums subsuper subsuperset subsval subsvald +subsvals subsym subsystem subt subterm +subtermeq subterminalinclusion subterminals subterminalsequivmonooverterminal subterms +subtermsd +subtermsi subtheorymodel subthinc subtle @@ -70739,11 +77573,15 @@ subtractioncommmonoid subtractionmonoid subtractions subtractrow +subtrail subtration subtree +subtreel subtreeof +subtreer subtrees subtriangle +subts subty subtyp subtype @@ -70753,9 +77591,11 @@ subtypecoe subtypecompatiblehomequiv subtypecongr subtypecongrhom +subtyped subtypedomain subtypedomainaddmonoidhom subtypedomainlinearmap +subtypee subtypeemb subtypeeq subtypeequiv @@ -70796,6 +77636,7 @@ subtypesupporteqequiv subtypeunivequiv subtypeval subtyping +subtypings subuhgr subumgr subumgredg @@ -70804,8 +77645,11 @@ subupgr subusgr subval subvariety +subvarstatei subwalk subwiki +subword +subx suby subz suc @@ -70821,10 +77665,13 @@ succdiffbounded succeed succeeded succeeds +succeedt succemb +succeq succequiv succes success +successelem successes successful successfully @@ -70832,13 +77679,18 @@ successiffail successiffailwithmessage succession successive +successively successor successors succfn succfunctor succfunequiv +succg succi +succinct +succl succlg +succm succn succnk succnotltepred @@ -70852,10 +77704,14 @@ succpnat succpredorder succrec succs +succsi +succsr +succss succstruct succsub succy succz +sucd sucdifsn sucdom sucel @@ -70891,7 +77747,10 @@ sucon sucprc sucprcreg sucpre +sucs +sucsplit sucssel +sucsuc suctr suctralt suctraltcf @@ -70900,17 +77759,25 @@ sucunisn sucxpdom sudoku sue +suf suff +suffacc sufferterragovernment suffertown suffi suffic suffice suffices +sufficiency sufficient sufficiently suffix +suffixagda suffixed +suffixes +suffixi +suffs +sufi suggest suggested suggestion @@ -70919,6 +77786,7 @@ suggestiontext suggests suggeststeps suggstx +suicide suitable suitablen suitably @@ -70929,6 +77797,7 @@ sum_eq sum_le_const sum_mono suma +sumable sumaddhom sumaddmonoidhom sumalgequiv @@ -70941,9 +77810,11 @@ sumassoc sumaux sumbnd sumbool +sumbot sumboxproddistrib sumbyresidueclasses sumcaseson +sumcheck sumcoeffsexp sumcomm sumcompl @@ -70980,7 +77851,9 @@ sumfinsupplequivprodfinsupp sumg sumhash sumhomeomorph +sumi sumideriv +suminf suminl suminr suminv @@ -71026,10 +77899,17 @@ summableuniformlyon summand summands summap +summarizes summary summarya summation summationfilter +summatory +summedbid +summedbidvector +summedbidvectoralg +summedbidvectorequivalence +summedbidvectorrel summin summing summo @@ -71042,6 +77922,7 @@ sumno sumnodes sumnul sumodd +sumof sumofconjugates sumofconjugatesequivariant sumofmonom @@ -71064,6 +77945,8 @@ sumright sumringequiv sums sumset +sumsetdiff +sumsets sumshdig sumshdiglem sumshdiglema @@ -71089,10 +77972,13 @@ sumtoiter sumtp sumtransform sumv +sumx +sumy sumyes sumz sumzerohom sunf +sunflower suni sunio sunion @@ -71115,15 +78001,20 @@ supconvergenceclass supcvg supdegre supdegree +supdist supeq super +superadditive superchain +superclass superexponential superfactoria superfactorial superficl superfluous supergraph +supergrp +superlinear supermartingale superpolynomialdecay superpos @@ -71133,6 +78024,7 @@ superscriptterm superseded supersedes superset +superseti supersets supertype superuncl @@ -71148,6 +78040,7 @@ supfz supgtoreq suphom suphomclass +supi supicc supicclub supiccub @@ -71177,12 +78070,15 @@ supofbasis supofseq supp suppbddbelow +suppbottom suppco suppcoss +suppd suppdm suppeqfsuppbi suppfnss suppg +suppi suppimacnv suppimacnvss suppiniseg @@ -71205,6 +78101,7 @@ supporte supported supportedequivfinsupp supportedequivmvpolynomial +supporters supportgetequiv supporting supportlocallyfinitewithindomain @@ -71232,6 +78129,7 @@ suppssov suppssr suppssrg suppsssn +supptop suppun suppval suppvalbr @@ -71267,7 +78165,9 @@ suprzcl suprzub sups supseminorm +supseq supset +supseteq supsets supsn supspansingleton @@ -71277,6 +78177,10 @@ supssd supssuphom supsubc supsum +supsup +supt +supteq +supto supub supubt supval @@ -71305,6 +78209,7 @@ supxrubd supxrun supxrunb sur +surd sure surely surface @@ -71340,24 +78245,37 @@ sursubmefmnd surveys survival suslin +susp suspect suspend suspicion sussmann +sustain +sustained +svalid +svalue +svar svdcmp sverismo +svfun +svinv svrelfun svs swa swamp swap +swapalts +swapaltsp +swapar swapat swapbvararray swapbvars swapciso +swapcols swapcompinl swapcompinr swapcore +swapelim swapequiv swapf swapfactors @@ -71370,14 +78288,17 @@ swapffunca swapfid swapfida swapfiso +swapfoursyms swapfval swapindices +swapleaves swapleft swapped swapping swapright swaprows swaps +swapsyms swaptrue swaptwowf swb @@ -71385,7 +78306,10 @@ swc sweetriesling sweetwine sweirich +swf swhile +swingneg +swingpos swinnerton-dyer switch switched @@ -71503,6 +78427,12 @@ symbol symbolic symbolicstring symbols +symbs +symbss +symcl +symcli +symclosure +symclp symdif symdifass symdifcom @@ -71516,6 +78446,8 @@ symdifv symequiv symequivsym symetrique +symeval +symevalb symexe symg symgbas @@ -71569,10 +78501,14 @@ symgtrinv symgtset symgval symgvalstruct +symi syminsertequiv +syminterior symj +symk symm symmat +symmatrix symmcompofnondegenerate symmdiff symmega @@ -71588,6 +78524,7 @@ symmetricicc symmetricico symmetricioc symmetricioo +symmetrickind symmetricofhasfinitecoproducts symmetricofhasfiniteproducts symmetricp @@ -71617,6 +78554,8 @@ symmmeasurableequiv symmstruct symmsymmetry symoptionsuccequiv +symp +sympartp symplcomp symplectic symplecticgroup @@ -71631,11 +78570,21 @@ symrelcoss symreleq symrelim symrels +syms +symsystem symt +symvar +symvars syn synabs synapse sync +syncd +syncedsecs +synchdadd +synchdaddempty +syncsamehdtl +syncsingleheadadd syncstep synenc syninc @@ -71644,9 +78593,12 @@ synonymous synonyms synop synpair +syntact syntactic syntactically +syntacticpossibleworldforsemanticpossibleworlds syntax +syntaxn syntaxnodekind syntaxnodekinds syntaxp @@ -71680,14 +78632,20 @@ synthresults synthsubsingletoninst syo syp +syq syrup syrupmixer sys syscall syssubjectsc system +systemin +systemloc +systemout systems systemsl +systemtests +syth syz syzygies szazrzszezqlpdtcmdtrp @@ -71703,6 +78661,7 @@ szmod szmzazxdt szmzizndt sznzazt +szpilrajn szszuzczcdt szymanski sᵐᵒᵖ @@ -71717,6 +78676,7 @@ t_eq t_false t_plus t_true +tab table tableau tableaux @@ -71724,6 +78684,8 @@ tables tablesll tablewine tabs +tabularconfig +tabulate tac tacas taci @@ -71731,6 +78693,7 @@ tackle tacpos tacs tacseq +tact tactic tacticabel tacticadmit @@ -71764,6 +78727,7 @@ tacticsyntax tactictodischarge tactileperception tadd +taddr tag tagappfns tagcg @@ -71777,8 +78741,10 @@ taggedpartition taggedprepartit taggedprepartition tagging +tagi taginv tagk +tagmismatch tagn tagnazpudybdiwitdenpkfkpvubaxrttsro tags @@ -71791,10 +78757,14 @@ taild tailf tailfb tailfval +tailg tailini tailopt tailored +tailr +tailrec tails +tailt tailval take takeaux @@ -71803,16 +78773,20 @@ takeend takeendwhile takei taken +takenatstep takes takeuntil takewhile takewhilefn +takewhilenot taking takz talk talking talt tamarin +tameenum +tameenumfilter tan tanabsge tanadd @@ -71835,9 +78809,11 @@ tangentcoordchange tangente tangentmap tangentmapwithin +tangents tangentset tangentsfrom tangentspace +tangle tangtx tanh tanhalfpim @@ -71845,8 +78821,10 @@ tanhbnd tanhlt tanhpartialequiv tanhval +tank tanneg tannery +tannot tannpoly tanord tanorderiso @@ -71856,8 +78834,10 @@ tanrpcl tant tanval tao +tap tape tapp +taq tar target targetaffinelocally @@ -71867,6 +78847,8 @@ targetmachinesig targetname targetnames targetnew +targetnode +targetnodes targetproof targets targetthreadpool @@ -71889,15 +78871,20 @@ tas task tasks tate +tatom tatvaakfelhkjtxltqhuptgck tau +tauchaincasessym +tauchaininduct taughtby taupackage taupi taupilem taupilemrplb taur +tausupportderivative taut +tauti tauto tautocore tautological @@ -71906,7 +78893,10 @@ tautologicalrelations tautologicalrelationssolutionequiv tautologicalsolution tautologicalsolutionispresentationcore +tautologies +tautologous tautology +tautologyintotalvaluation tautotogrind tautotogrindregressions taux @@ -71931,22 +78921,27 @@ taylply taylpval taylth taylthlem +tbase tbitriarlluhdmlkejutr tbl tbled tbool tbot +tbound tbs tbsyl tbt tbtru +tbuildupi tbw tbwlem tbwsyl tca tcard +tcd tceilhalfelfzo tcel +tcf tcfr tcg tchnmfval @@ -71955,8 +78950,14 @@ tcid tcidm tclosed tcmin +tcoalg +tcodomain +tcomp tcomposite +tconj tconn +tcons +tcorres tcp tcphbas tcphcph @@ -71973,6 +78974,7 @@ tcphtopn tcphval tcphvsca tcrank +tcs tcsni tcss tct @@ -71980,15 +78982,19 @@ tctr tcu tcvalg tcwf +tdb tdc +tdconc tdd tdecs tdeglem +tdev tdisj tdiv tdivexists tdivgoodp tdnum +tdomain tdrgdrng tdrgring tdrgtmd @@ -71996,12 +79002,14 @@ tdrgtps tdrgtrg tdrgunit tdropn +tdropnd tdseen teach team tebivefdwlywibtk tech technical +technicald technically technician technique @@ -72012,6 +79020,7 @@ teichmulleraux teichmullercauchy teichmullerfun teimlyfwmhjh +tel telephonecommunication telephoning telephony @@ -72031,6 +79040,7 @@ tem temp temperate temperature +temperaturef temperaturemeasure tempereddistribution template @@ -72227,6 +79237,7 @@ tensorrightiso tensorrightmopiso tensorrighttensor tensorrightunmopiso +tensors tensorsigns tensorspanequivspan tensorsubmodulealgebraequiv @@ -72280,9 +79291,11 @@ termelabm termelabresult termequality termequivcl +termequivclgen termfucterm termg termi +termie termina terminal terminalcomparison @@ -72296,23 +79309,34 @@ terminalisopunit terminalistermi terminalisterminal terminallimitcone +terminalnformcases terminalofuniqueofreflects terminalopofinitial terminalreplacement terminalreplacementoutcome +terminals terminaltogrind terminalunopofinitial terminate terminated terminatedat terminates +terminatesd +terminatesi terminatesofrat terminatesrecon +terminatess terminating termination terminationg +terminationrule +terminations terminology +termis termlem +termlemma +termlemmas +termm termmset termo termoeu @@ -72330,9 +79354,12 @@ termoval termparser termprecandreprs termreduce +termrel terms terms_equal +termsetinset termstate +termsubst termtogrindparam termwise ternary @@ -72377,16 +79404,21 @@ test_well_formed_unbound_var testable testagainstnn testbit +testchar testcond tested testfalsehelper testfunction testing +testlist +testop testparsemodule +testpool tests testsuchthat testtacticseq testtruehelper +tetrahedral tetrahedron teven tex @@ -72395,7 +79427,9 @@ texpr text textbased textbasedlinter +textbook textbooks +texttests tfae tfaehaveiddecl tfaehaveidlhs @@ -72403,12 +79437,16 @@ tfaelist tfaetype tfalse tff +tfff +tfft tfi tfin tfindes tfinds tfindsd tfindsg +tfinite +tfinited tfis tfisg tfisi @@ -72432,6 +79470,8 @@ tfsconcatun tfslim tfsnfin tfst +tftf +tftt tfup tfyjktukrlfhsptbarvtqtgjlbvuznyoshv tgasa @@ -72469,6 +79509,7 @@ tgcolg tgdif tgdim tgdom +tge tgellng tgelrnln tgfiss @@ -72553,10 +79594,13 @@ tgtfield tgtfields tgthasloosebvars tgti +tgtj tgtlemma tgtlemmas tgtm tgtmap +tgtnodeof +tgtnodeofv tgtop tgtopon tgtrisegint @@ -72569,11 +79613,17 @@ thales thalt than thanks +thansubset that +thatd +thatm thd the +theeasyhalf theeq thegame +thehardhalf +thei their thekb thelhs @@ -72604,10 +79654,20 @@ therefore thereof therhs thermodynamics +thermostat these thesis thesisa theta +thetaatm +thetaif +thetasatm +thetasch +thetasd +thetasdone +thetaseq +thetasseqd +thetasseqi thetat they thf @@ -72663,6 +79723,7 @@ thirty this thisattr thisi +thism thlbas thlle thlleval @@ -72711,6 +79772,7 @@ threelefthole threeleftholezipwf threemiddlehole threemiddleholezipwf +threep threerighthole threerightholezipwf threes @@ -72719,7 +79781,10 @@ threeshortaddlongroot threeshortaddtwo threeshortaddtwolong threeshortaddtwolongroot +threeway +thresh threshold +thresholdi threw thrice thrmul @@ -72735,13 +79800,16 @@ throwapplyerror throwcongrex throwerror throwerrorat +throwet throwfunctionexpected +throwing throwmismatch thrown thrownogoalstobesolved thrownone throwonnomatch throwpeelerror +throwrule throws throwtacticex throwthe @@ -72750,6 +79818,7 @@ throwunknownconstant throwunknownid throwunsupported throwunsupportedsyntax +thrst thru thruster thumper @@ -72758,12 +79827,16 @@ thus thy tia tick +ticket ticks ticom +ticonc tictactoe tid tidy tie +tiebreaker +tiebreakers tiei ties tietze @@ -72771,21 +79844,30 @@ tietzeextension tietzeextensionclass tif tight +tighten tighter tightness tilde tildefinsupp tildeself +tile +tiling +till tilt tilted time +timed timedelay timedelayedby +timef timehasnoendmt +timei timeinterval +timelike timeout timeouts timepoint +timer times times_ times_tropical @@ -72793,30 +79875,57 @@ times_tropical_def times_tropical_min times_tropical_min_def timesd +timesdistributesoverpdifference timesgt timesi +timesl +timeslr +timesmod +timesr +timess timestamp +timestep timet timoio +tinit tint +tinv tion tip tips tiroirs +tisj +tisjsi tiszero +tit +titi +titj title +titlepaper +titlepost tiy tjnbpbu tjplco tjqrva +tjsi +tjti +tkd +tki +tkt tla tlaplus tlaps +tlast tlbnd +tld tleile tlektvatpmiuxtsvnjrfoipaglhcwxtmliwvqusxic tlelt +tlength +tlengthd tlh +tli +tlist tljrubkkqrjjdrpqvjpfoeqi tllist tlmlmod @@ -72827,10 +79936,12 @@ tlmtps tlmtrg tlock tlong +tlookup tls tlt tltl tltnle +tlvl tmap tmax tmc @@ -72849,16 +79960,20 @@ tmfv tmin tml tmle +tmlemmas tmmsg tmmul tmnum tmod tmp +tmps +tms tmsbas tmsds tmslem tmsms tmstopn +tmsubst tmsval tmsxms tmsxps @@ -72872,6 +79987,8 @@ tmulequivdep tmults tnat tncp +tnd +tndcomm tne tng tngbas @@ -72895,7 +80012,9 @@ tngval tngvsca tnil tnode +tnot tnp +tns to_string to_vec toabs @@ -72980,9 +80099,11 @@ toalghomequiv toalghomhom toalghommonoidhom toalist +toall toalternatingmap toalternatingmaplinear toantisymmetrization +toany toappend toappexpr toapply @@ -73002,6 +80123,7 @@ tobasicopenofglobalsections tobasis tobasisat tobcf +tobd tobdddistlat tobddlat tobialgequiv @@ -73025,6 +80147,7 @@ tobinarybiconeiscolimit tobinarybiconeislimit tobipointed tobiprod +tobits tobitvec toblock toblocks @@ -73110,6 +80233,7 @@ tocokleisli tocokleislicompfromcokleisliisoself tocolex tocolimitpresentation +tocolist tocolon tocoloring tocols @@ -73217,6 +80341,7 @@ toconv toconvexcone tocopy tocore +tocostring tocostructuredarrow tocostructuredarrowcocone tocostructuredarrowcompproj @@ -73226,8 +80351,10 @@ tocotangent tocountableinterfilter tocoverage tocoweightbasis +tocowriter tocoxetersystem tocprehil +toct tocwcomplex tocyc tocyccntz @@ -73238,13 +80365,16 @@ tocycle tocycles tocyclesnattrans tocycval +tod todecidableeq todecidablele todecidablelt +todecimalchars todeclaration todecomposition todeg todeglex +todelay todeleteedges toderivation todescentdata @@ -73258,6 +80388,8 @@ todfinsupp todiagram todiffeology todiffeomorph +todigit +todigitchar todigits todigitscore todilation @@ -73318,6 +80450,7 @@ toenumfinset toenvelgroup toeplitz toeqpf +toequal toequiv toequivalence toequivofeqtop @@ -73336,6 +80469,7 @@ toeven toeventualranges toeventualrangessectionsequiv toexistsaddofle +toexitcode toexposed toexpr toexprcore @@ -73376,12 +80510,14 @@ tofinsuppiso tofinsuppisoalg tofinsuppisolinear tofinsupplinearequiv +tofinterm tofinunsafe toflag tofloat tofloorsemiring tofmvarid tofn +toforeign toformalmultilinearseries toformalmultilinearseriesofmultilinear toformat @@ -73402,6 +80538,7 @@ tofunalghom tofunaslinearmap tofunaux tofunbilinear +tofunction tofunctor tofunctortocategoricalpullback tofunimpl @@ -73495,6 +80632,7 @@ tohonehypercover tohopfalgequiv tohopfalgiso tohspace +toi toic toicodiv toicom @@ -73517,6 +80655,7 @@ toinfinityroundedmodep toinfinitysymmetric toinfinitytotal toinfinityuniquep +toinfix toinftophom toinftophomclass toinhabited @@ -73629,6 +80768,7 @@ tokernel tokernelsubobject tokleisli tokleislicompfromkleisliisoself +toknownnature toks tol tolambda @@ -73846,6 +80986,7 @@ tonat tonatalgebra tonatalghom tonatcast +tonatdigits tonatfnname tonatfnnames tonatfunnames @@ -74037,8 +81178,11 @@ toperfpair toperm topermhom toperminj +topermutation topersistentenvextension +topf topfilter +topfloat topfne topfneec topgele @@ -74065,6 +81209,7 @@ topiso topisozero topitensorproduct topjoin +topl toplaindate toplas toplas_ @@ -74073,6 +81218,7 @@ toplatjoin toplatlub toplatmeet toplepullbackself +toplevel toplly toplots toplus @@ -74105,6 +81251,7 @@ topoffileref topographical topoi topointedcone +topointwise topointwiseconvergenceclm topol topolo @@ -74141,6 +81288,7 @@ topologicalspacemodule topologicalvectorspace topologies topology +topologyi topologyofclosureoperator topologytheory topoly @@ -74183,6 +81331,7 @@ topoufun topow topowerseries topowerseriesalg +toppos topr topreabstractsimplicialcomplex topreconnectedspace @@ -74229,11 +81378,13 @@ toprincipalseg topring toprint toprntopon +toprocess toprod toprodhom toprodl toprodmulopposite toprodmuloppositehom +toproduct toprofinite toprofiniteadjtocomphaus toprofinitefullyfaithful @@ -74244,6 +81395,7 @@ toprojective toprop toproperty tops +topseqsubst topset topseudoepimorphism topseudofunctor @@ -74263,6 +81415,7 @@ toptodeltagenerated toptolocale toptopon toptopreord +toptype topullback topullbackdiag topullbackobj @@ -74320,6 +81473,7 @@ toreflprefunctor toregular toregularspace torel +torelated torelembedding torelhom torelisogt @@ -74371,6 +81525,7 @@ torsionpolynomial torsor torsors torsubg +tortoise toruletac torus torusintegrable @@ -74408,6 +81563,7 @@ tosesqform toset tosetofisatom tosetoid +tosetoidendo tosetrel tosfunname tosfunnames @@ -74444,6 +81600,7 @@ tosingle tosingleequiv tosinglemk tosingleobjequiv +tosink toskeleton toskeletonfunctor toskeletonfunctorcompmapskeletoniso @@ -74486,6 +81643,7 @@ tosquare tosquareblock tosquareblockprop tosquarezero +toss tosset tossetfunctor tossetisoconst @@ -74503,6 +81661,7 @@ tostarorderedring tostarring tostarringequiv tostarsubalgebra +tostates tostep tostonean tostream @@ -74582,9 +81741,11 @@ totallydisconnectedspace totallyseparated totallyseparatedspace totalmass +totalorder totalorderedp totalorderp totalp +totalpreorder totalquotientpresheaf totalrig totalrightderived @@ -74593,18 +81754,22 @@ totalshift totalspace totalspacemk totalspacetopology +totalvaluationforformuladefinesitsvalue totalvariation totalweight +totatives totbnd totbndbnd totbndmet totbndss +totc totempereddistribution totempereddistributionclm totensor totensoralgebra totensorofistrivial totensorpower +toterm totheory tothinskeleton totient @@ -74646,10 +81811,12 @@ totype totypeexpr totypeorderbot totypes +touc touch touching touchpoint touchpointweights +toucop touint touliftfunctor tounder @@ -74681,9 +81848,12 @@ tovadd toval tovaluation tovalued +tovariable tovbij +tovec tovector tovectorbundle +toview tovisit tow towalk @@ -74703,6 +81873,8 @@ towerlaw towithbotnat towithtop towithtopzero +towitness +towitnessfalse towna townb toword @@ -74735,6 +81907,7 @@ tozmodsubmodule toznum toznumneg tozvceaykqiogcuixumg +tpa tpass tpb tpc @@ -74749,12 +81922,16 @@ tpfi tpfo tpid tpidm +tpmf tpnei tpnz tpnzd +tpof +tpofv tpoint tpointer tpolish +tpoly tpop tpos tposco @@ -74843,9 +82020,12 @@ tracecls traceclscast traceclsclean traceclsvisit +traced tracedata tracedual traceform +tracei +traceid traceifexists tracelinearmap tracematrix @@ -74891,12 +82071,17 @@ trajectory trajfun trajmeasure tran +trancl +trancle +tranclp tranp trans transaction transaction-scope transaction-scoped transactional +transactione +transactions transassoc transassocrepa transassocreparamaux @@ -74935,6 +82120,7 @@ transfinitecompositions transfinitecompositionsofshape transfiniteiterate transfinitely +transflip transform transformation transformations @@ -74973,8 +82159,10 @@ transislittleoislittleo transisthetaisequivalent transition transitioncocone +transitiond transitiondepth transitionfailures +transitioni transitionmap transitionmaple transitions @@ -74982,6 +82170,7 @@ transitiontheorems transitiontheoremsext transitive transitiveclosure +transitivei transitively transitivelyusedconstants transitiveproperty @@ -75000,11 +82189,16 @@ translateoverwrite translaterelevantarg translatereorder translates +translatesec +translatestate translatetoint +translatetrace +translateval translating translation translationevent translationinfo +translationinvariant translationnumber translations translator @@ -75033,6 +82227,8 @@ transportprops transportsheafificationadjunction transportstruct transportto +transportvia +transpos transpose transposeaddequiv transposealgequiv @@ -75043,9 +82239,11 @@ transposeorderiso transposepath transposeringequiv transposition +transpositionlist transprincipal transq transr +transrec transrefl transreflreparamaux transreliso @@ -75056,12 +82254,16 @@ transvections transvectionstruct transversal transversalpair +transymcl trap trapezoid trapezoidal +trascl +trasposition tratrb tratrbvd traux +trav traversable traversablederivehandler traversablelawstarter @@ -75112,9 +82314,11 @@ trclunxp trcont trcontstack trcoss +trd trdeg tre treams +treap treat treated treatment @@ -75122,17 +82326,24 @@ treats tree treearb treearray +treed +treee treefi +treehead treehom +treei treeify treelist treem treemap +treeof treerp trees treeset treesofnumnodeseq treestars +treewidth +trefoil trel trelded trelpss @@ -75147,6 +82358,7 @@ trfil trfilss trfo trfr +trg trgcgr trgcgrcom trgcgrg @@ -75161,6 +82373,7 @@ trgtmd trgtps tri tria +triagular triang triangl triangle @@ -75172,9 +82385,12 @@ trianglehmapofhomotopy trianglehofdegreewisesplit trianglehofdegreewisesplitrotaterotateiso trianglehrotateisotrianglehofdegreewisesplit +trianglei triangleindexdata triangleindices +triangleinequality triangleiso +triangleleft trianglelefteq trianglelege trianglelegeisotriangleltge @@ -75193,13 +82409,16 @@ triangleofses triangleofsesiso triangleofsesδ triangleopequivalence +triangleq triangleremovalbound +triangleright trianglerotateisotriangleofdegreewisesplit trianglerotateshortcomplex trianglerotateshortcomplexsplitting trianglerotation triangles triangular +triangulate triangulated triangulation triantru @@ -75211,11 +82430,13 @@ trick trickier tricky tricoloring +tricolour trident trie tried trieindex tries +triesd trifr trifunctors trigge @@ -75228,6 +82449,7 @@ trimasciiend trimasciistart trimleft trimmed +trimono trin trinit trinomial @@ -75241,6 +82463,7 @@ trip tripartite tripartitefromtriangles triple +tripled triples triplet triplewise @@ -75251,7 +82474,9 @@ trireciplem trirn tris trisecnconstr +trisecting trisegint +trisplit triun triv trivchange @@ -75281,6 +82506,8 @@ trivializationofsmuldisjoint trivialliemodule trivially trivialonconstants +trivialpair +trivialphi trivialrel trivialsnd trivialstar @@ -75348,13 +82575,22 @@ trlspth trlval trm trmhd +trmi +trms trn +trna trnat trnei trnfsetn +trnn +trno trnormal trnsetn trnum +trnv +trnw +tro +troeger trolley trom tron @@ -75505,8 +82741,10 @@ tropm_top_eq_zero troporderiso troprec trouble +trough trposnum trpred +trr trrel trreleq trrelind @@ -75516,6 +82754,7 @@ trrelssd trrelsuperrel trrelsuperreldg trressn +trs trsbc trsbcvd trsc @@ -75540,9 +82779,14 @@ trubitru truconj trud true +trueargs truearrowequiv +truei trueidea +trueif +trueinworldnecc truemult +trueprop trueq truerepeat truesetoid @@ -75618,6 +82862,7 @@ truortru trust trusted trustlevel +trustme trut truth truthday @@ -75685,9 +82930,11 @@ tsets tsettps tsfst tsh +tshift tsi tsim tsin +tsint tsirelson tsk tskcard @@ -75742,8 +82989,11 @@ tsmssubm tsmsval tsmsxp tsmsxplem +tsn tsna tsnd +tso +tsome tsor tsp tspec @@ -75756,6 +83006,7 @@ tssnd tst tstate tstep +tstepi tstruct tstructure tsu @@ -75773,7 +83024,11 @@ tsyntax tsyntaxarray tsz tsze +tta ttac +ttas +ttff +ttft ttgbas ttgbtwnid ttgcontlem @@ -75787,7 +83042,9 @@ ttgval ttgvsca ttijucchlwktnzwxruyhunmkdm ttl +ttm tto +ttop ttrclco ttrcleq ttrclexg @@ -75798,11 +83055,15 @@ ttrclss ttrcltr ttrue tts +ttt +tttf +tttt ttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttt tttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttt ttukey ttukeyg ttukeylem +tturnstile ttype tube tuchar @@ -75810,14 +83071,19 @@ tuesday tuihdzjzh tuint tulip +tune +tunermode tunf tunion +tup tuple tuplegraph tupleright tuples +tuplesi tuplesucc tupple +tups tur turandensity turandensityconst @@ -75830,6 +83096,8 @@ turned turni turning turns +turnst +turnstile tus tusbas tuslem @@ -75841,7 +83109,10 @@ tususs tusval tutte tuvar +tval tvar +tvarb +tvars tvclmod tvclvec tvctdrg @@ -75852,13 +83123,18 @@ tvoid tvs tvtcblmj twa +twb tweak tweet twelf twelve twice twiddle +twiddleheap +twiddleval +twinamicpair twist +twisted twistshiftdata twizzle twls @@ -75870,7 +83146,9 @@ twococycleaux twococycleof twococycleofbilinear twocriteria +twocube twocut +twod twodenominators twoembeddingequiv twogoals @@ -75883,15 +83161,18 @@ twoimpright twolefthole twoleftholezipwf twomorethanone +twonetsdistinct twonotinotbothi twop twopointing +twopow twopowsum tworighthole tworightholezipwf twoshortaddlong twoshortaddlongroot twoside +twosided twosidedideal twosqu twosquare @@ -75928,6 +83209,7 @@ txcnp txcnpi txconn txdis +txe txflf txhaus txhmeo @@ -75947,6 +83229,7 @@ txpconn txprel txpss txrest +txs txsconn txsconnlem txss @@ -75974,6 +83257,7 @@ tyargs tyazvhikqicbhcbmdhurtt tyb tybool +tych tychonoff tycontext tyde @@ -75996,7 +83280,9 @@ type-theoretic type_ type_expr type_soundness +typeablefreevars typealias +typeamic typeargs typeb typebequivso @@ -76009,6 +83295,7 @@ typeclass typeclasses typeclassesleftrightle typeclassmeasurablespace +typeconf typed typed-wasm typed-wasm-cost @@ -76016,9 +83303,13 @@ typedecidableeq typedequivso typediscipline typedwasm +typee typeequalizerofunique typeequiv typeerror +typeerrorfmt +typei +typeii typein typeinfos typeinvariant @@ -76039,6 +83330,7 @@ typenames typenew typeof typeofineqproof +typeofnew typeold typepred typepriority @@ -76046,13 +83338,16 @@ typeqtint typeresult types typesa +typesafe typesafepets typesafety typescheme +typesconf typesglue typesgrothendiecktopology typespec typespeed +typess typeswith typetags typetoboolalgop @@ -76089,13 +83384,21 @@ tzwnnkqguacaqixfiig tzzixngdumsoi u128 uabs +uabstract +uact +uarg +uargs +uarr uas uasban uasbanh uasbanhvd uba +uball ubb +ubd ubelsupr +ubex ubforcartprodlem ubfz ubicc @@ -76107,10 +83410,16 @@ ublem ubmelfzo ubmelm ubound +uboundmax +ubounds ubs ubth ubthlem ucabs +ucast +ucl +uclause +uclique ucn ucncn ucnextcn @@ -76118,17 +83427,25 @@ ucnima ucnimalem ucnprima ucnval +ucol ucompactlygeneratedspace +ucontinuous ucs ucu ucy +ucycles uczzupk udefaultspec udiv +udivcc udknahhpuldlrdffycaferimsihfutbcg +udom udp +uedge +uedges ueq uexp +uface ufd ufdidom ufdprmidl @@ -76152,6 +83469,7 @@ ufileu ufilfil ufilmax ufilss +ufilter ufinffr ufl ufldom @@ -76163,6 +83481,7 @@ ugh uglify ugly ugqjitctzd +ugraph uhgr uhgraph uhgredgiedgb @@ -76197,15 +83516,23 @@ uhgrvd uhgrvtxedgiedgb uhgrwkspth uhgrwkspthlem +uhi +uhint uhpath uhwm uicc +uid +uidl +uids uinf +uinfo uinstructions uint uinu uioc uioo +uip +uisinvar uisscdioufhiqhqlqlugmemydblovlvyfdbxemzjsuauyifnpxa uiter ukencartamsncomencyclopedia @@ -76257,6 +83584,7 @@ uliftzmultipleshom uliftzpowershom ulim ulist +uliteral ulm ulmbdd ulmcau @@ -76283,12 +83611,14 @@ ulower ulp ultimate ultimately +ultra ultrafilter ultrafilterbasis ultrafilters ultrahomogeneous ultrametric ultraproduct +umap umax umem umgr @@ -76322,33 +83652,54 @@ umgrvad umgrwlknloop umgrwwlks uminus +uminusgh +uminusi umonoid ump +umstaendlich +umul un_i +una unab unabs unabw +unaffected +unalign +unalignwith +unalive +unallocatedblocksinvariant +unambigous unambiguous +unambiguousi +unanimity unapplied unapply +unarg unary unarycast unarydecodenat +unarye unaryencodenat unaryfinencodingnat +unaryi +unaryindividualterm unaryunion unass +unat unattach unb +unbal unbdqndv unben unbenlem unbeta unblem unblimceq +unblinded unbndrank unbnn unbop +unbordered unbot unbota unbotd @@ -76358,17 +83709,23 @@ unboundedlog unboundedness unbox unboxed +unbump +unbumpterm unbundled unc +uncap uncast +uncaught unccur uncenteredcovariancebilindual unceq uncertain +uncertainty uncf uncfcl uncfcurf uncfval +unch unchangeable unchanged unchanging @@ -76379,11 +83736,14 @@ unchon unchprivsrc uncld unclear +unclocked unclosed uncmp uncom uncomment uncommitted +uncompose +unconc unconditional unconditionally unconditionalschauderbasis @@ -76394,6 +83754,7 @@ unconstrained uncou uncountable uncov +uncross uncrossing unctb uncu @@ -76407,7 +83768,9 @@ uncurrymid uncurryobjflip uncurryright uncurrysum +und undecidability +undecided undeclared undeclaredeffect undecorated @@ -76415,6 +83778,7 @@ undecs undef undefi undefined +undefinedness undefn undefne undefnel @@ -76431,6 +83795,7 @@ undermorp undermorphism underobj underpost +unders underscore underscores understand @@ -76438,6 +83803,7 @@ understanding undertoalgebra undesirable undi +undiag undif undifabs undifixp @@ -76445,6 +83811,7 @@ undifr undifrold undir undirected +undiscr undisj undisjrab undjudom @@ -76455,6 +83822,7 @@ undoes undom undual une +unedge unelcarsg unelldsys unelros @@ -76481,12 +83849,14 @@ unexpander unexpandexistsunique unexpandnil unexpected +unexplored unf unfi unfib unfid unfilem unfiltered +unfinished unfir unflip unfo @@ -76501,32 +83871,42 @@ unfoldconsts unfolddefinition unfolded unfoldentry +unfoldf unfoldfun unfoldfvars unfoldheadfvar unfolding +unfoldings unfoldingtrick unfoldinsertions +unfoldl unfoldm unfoldnamepred unfoldpartialapp unfoldprojdefaultinst unfoldprojinst unfoldprojs +unfoldr unfolds unfoldsamefun unfortunate unfortunately unfound unglue +ungluei +unground +ungroupseqs +unguarded unhandled unhe unhealthy +unhindered unhygienic uni uniabio unialeph unibrsiga +unicast unichnidl unicite unicity @@ -76569,8 +83949,10 @@ uniexd uniexg uniexr unif +unifd unifeigenvalues unifi +unifiable unification unifid unified @@ -76579,9 +83961,14 @@ unifiedcrashawarejournalrefinement unifiedtype unifiedtypeexpr unifier +unifiers +unifiert unifies unifintegra unifintegrable +unifless +uniflessi +uniflows unifndx unifndxnbasendx unifndxnn @@ -76662,6 +84049,7 @@ unifying unifymovements unifyzeroorsucc unifyzeroorsuccresult +unii uniiccdif uniiccmbl uniiccvol @@ -76686,7 +84074,9 @@ unilbeu unilbss unima unimax +unimodular unimopn +unindex unineq uninf uninit @@ -76699,6 +84089,7 @@ unio union unioncommutes unioncompltosubordinate +uniond unione unionecases unioneqsigmaofdi @@ -76713,12 +84104,16 @@ unionof unionprop unions unionsuminter +unionswith +unionwith uniop uniopel uniopn uniordint unipotentlower unipotentupper +unippc +unippv unipr unipreima uniprg @@ -76728,6 +84123,7 @@ unipwrvd uniq uniqinunit uniqnames +uniqoneelementcharacterization uniqs uniqsw uniqu @@ -76746,6 +84142,7 @@ uniqueelim uniqueembeddingequivresult uniqueequiv uniqueequivequivunique +uniqueess uniqueextensionalonguliftyoneda uniquef uniquefactorization @@ -76769,9 +84166,11 @@ uniquehom uniquehomsetofinitialisounit uniquehomsetofzero uniquehomtozero +uniquei uniqueiioone uniqueindices uniqueintmodule +uniquel uniqueleft uniquelinearequiv uniquely @@ -76800,6 +84199,7 @@ uniquepath uniqueprod uniqueprods uniqueprop +uniquer uniquerepresentative uniqueright uniqueringequiv @@ -76860,8 +84260,10 @@ unitality unitalmagma unitalshelf unitapp +unitarily unitary unitaryconjugate +unitaryd unitarygroup unitarylinearisometryequiv unitaryselfaddismul @@ -76878,6 +84280,7 @@ unitball unitballball unitballpackage unitbe +unitbecomesfalse unitbialghom unitcl unitclosed @@ -76897,8 +84300,12 @@ unitedstatesgeographypeoplemt unitequalises unitequalizerofcoreflectsequalizer unitequivunitsinteger +unitet +unitetrees unitfork unitforward +unitftor +unitfunctor unitg unitgroup unitgroupmulequiv @@ -76961,6 +84368,7 @@ unitscentralizerequiv unitscomplexconj unitscongr unitscyglem +unitsd unitsendequivaut unitsequiv unitsequivaut @@ -76974,6 +84382,7 @@ unitsequivunitstype unitsfstone unitshomeomorphnezero unitshomeomorphpos +unitsi unitsint unitsinv unitslift @@ -77011,6 +84420,8 @@ unittopushforwardobjunit unitunit unitvec unity +unityd +unityi unitz uniun uniuni @@ -77033,6 +84444,7 @@ universalfactorizationmapliftequiv universalfactorizationmappresentation universalfactorizationring universalhom +universality universall universally universallyclosed @@ -77063,30 +84475,41 @@ unizlim unjp unjps unjust +unk unkey unknown +unknowns +unl +unlabel unlabeled unlabelled unless +unlhd unlike unlikely unlimited +unlimitednatural +unlines unlink unlinkpcp unlinkpsp unlinkpss unlock unlockable +unlr unmbl unmixedembeddingsover unmop unmopequiv unmopfunctor +unmultigraph unn unnamed unnecessarily unnecessary +unnecessaryphi unneeded +unnode unnum uno unocv @@ -77098,6 +84521,7 @@ unopadj unopbd unopcomp unopcounitiso +unopelim unopequiv unopequivalence unopf @@ -77124,18 +84548,24 @@ unp unpack unpair unpaired +unparsed +unpath unpickle unpreima unprimed unproductive +unprot +unprotect unprovable unqsym unquot +unr unrab unramfiedlocus unramified unramifiedlocus unramifiedplacesover +unreachability unreachable unreachabletactic unrealistically @@ -77147,25 +84577,37 @@ unreported unresolvable unresolvd unresolved +unrest unrestricted unrev +unrhd unroll unrolling uns unsafe unsafebaseio unsafecast +unsafedisplay +unsaferuncmd +unsaferuncmdtc unsat +unsatindices +unsatisfiable +unsatisfied unscoped unseal unsealing unset +unsetenv unsetoption unsettrailing unshift unshifting unsigned +unsimp +unsimpgraph unsnen +unsnoc unsolved unsortedeigenvalues unspecified @@ -77177,6 +84619,7 @@ unssbd unssd unssi unstratify +unstream unsum unsupervised unsupported @@ -77188,11 +84631,15 @@ untangle untangtr untelirr until +untilinj +untiljust untilt +untime untint untop untopa untopd +untouched untppr untreeify untrop @@ -77222,11 +84669,22 @@ unv unvdif unveldom unveldomd +unvisited +unvisitedpath unwanted unwantedunicode unwdomg unwf +unwind +unwindcond +unwindi +unwinding +unwindsd +unwindsdcond +unwords unwrap +unwrapc +unwraph unwrapped unwrapping unxpdom @@ -77235,16 +84693,19 @@ unxpwdom unxs unzero unzip +unzipwith unzziswdg uobeq uobeqterm uobeqw uobffth +uobj uobrcl uoooxipxstchhtrb uop uopen upaco +upair upairequniteq upairinpowunion upairset @@ -77255,8 +84716,10 @@ upairsubunion upath upbdrech upcast +upchar upcic upciclem +upclose upcrossing upcrossings upcrossingsbefore @@ -77266,15 +84729,23 @@ upda update updateall updateandadddecl +updateat updatecol updateconstantval updated updatedecl +updateenv +updateenvdup +updateexp +updatefi updatefinset +updatefo +updatefocus updateforalle updatefp updategraphwithnlti updategraphwithnltinfsup +updatei updatelambda updatelambdabinderinfod updatelast @@ -77287,6 +84758,9 @@ updaterel updaterin updaterow updates +updatese +updatesi +updatesuc updatetrailing updatetype updateunexpander @@ -77297,14 +84771,19 @@ updjud updjudhcoinlf updjudhcoinrg updjudhf +updl updlockn updlocks updlockset upds +updsize +updsizeaux updt updthread updthreadc +updv upeu +upf upfunctor upfval upgr @@ -77367,19 +84846,25 @@ upgrwlkedg upgrwlkupwlk upgrwlkupwlkb upgrwlkvtxedg +upharpoonleft +upif upixp upl upleq uplex upln uplth +uplus upmap +upmost upmulhom upon +upone upos upp upper upper-triangular +upperb upperbasis upperbound upperbounds @@ -77418,15 +84903,24 @@ uppertriangular upppt uppropd uprcl +upre uprod +uprule +uprulecharacterise +uprules +ups +upset upshadow +upsilon upstream upstreamabledecl upstreamabledecllinter upstreaming upt upto +uptoe uptohere +uptoi uptoquasiiso uptpos uptposlem @@ -77448,11 +84942,15 @@ upxp uqbrj uqehc urated +urats +urelem +urelems urem urgyifyuzutmsw uri urlfn urlreferentfn +urow urpropd urruty ursh @@ -77469,8 +84967,13 @@ usages usagetracker usageviolation usb +usc uscnrripwpsjqlxkzpedysbecigd usdaudllqajjxyccxhiyllmixd +usdb +usdbeqlen +usdbsym +usdbtrans use useas useclassical @@ -77497,9 +85000,13 @@ usercongr usererror usergroup userid +useridasstr +userids username usernamepre usernames +userofa +userreq users userspace usersreaders @@ -77507,6 +85014,7 @@ userswriters uses usesgoal usesimp +uset usgr usgraph usgrausgrb @@ -77586,6 +85094,8 @@ usize usjecmngrvdadq usn usnu +usolution +uspace uspgr uspgraph uspgrbispr @@ -77618,7 +85128,9 @@ uspgrupgr uspgrupgrushgr uspgrushgr uspgrymrelen +usphere uspreg +usr uss ussid ussval @@ -77654,6 +85166,7 @@ usually usub usubs usubst +usvs uswap uswitch uswitchequiv @@ -77662,12 +85175,16 @@ utf util utilities utility +utilityd utilizing utillib utils +utilty utlast +uton utop utopbas +utopology utopreg utopsnnei utopsnneip @@ -77681,6 +85198,7 @@ utu uua uub uuc +uuisinvar uun uunit uunt @@ -77692,6 +85210,7 @@ uuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuu uux uvalid uvalidu +uvariation uvars uvccl uvcendim @@ -77706,6 +85225,7 @@ uvcvv uvcvval uvcvvcl uvd +uverts uvtx uvtxel uvtxisvtx @@ -77721,7 +85241,10 @@ uvtxusgr uvtxusgrel uvtxval uvvwfrsexscxedxfarcbndzhwhcwvrytgmecfxdgllu +uvz +uwalk uwaterloo +uwellformed uwjpehkgbrhsjw uwoaujctzybsfzattcglghemcudbiaqa uwttuhguiltt @@ -77793,12 +85316,14 @@ uzubioo uzublem uzuzi uzuzle +uzv uzval uzwo uzxr uzxrd vaa vabs +vabstr vacn vacuous vacuousdall @@ -77825,7 +85350,10 @@ vale valembedding valequiv valeurs +valf +valff valfromgraph +vali valid valid_ validate @@ -77833,27 +85361,47 @@ validated validates validatetitle validation +validd +valide validfinite +validfrom +validfroms +validi validity validlift validlist valids +validtrans validtransition validu +validvalseq +validvalseqfrom valimpl valinjmu valk +valkf +valkff +valkm +valkn +valktt vallem +valley vallist valminabs valmonoidhom +valn +valof +valofd +valofn valorderemb vals valstx valt +valtt valu valua valuat +valuate valuati valuation valuationideal @@ -77874,12 +85422,15 @@ value_ value_has_type valueaddhom valueatinfty +valuecaraudiosystem +valuechosen valued valuedadiccompletion valuedcompletion valuedcsp valuedfqtinfty valuedistribution +valuedp valuedratfunc valuegrou valuegroup @@ -77901,6 +85452,7 @@ vampire van vandalism vandermonde +vangle vanilla vanish vanishes @@ -77911,10 +85463,17 @@ vanishingideal vankampen vapp var +varb varcurr vard +vardeclnum vardecls vardesc +vardict +vardmonotoneinassertion +vardmonotoneinphi +vardq +vare varepsilon varepsilon_ varepsilon_1 @@ -77923,6 +85482,8 @@ varepsilon_f varepsilon_g varfinset varfinsetleft +varfix +varfixvar vargs vari varia @@ -77944,35 +85505,53 @@ variationon variationonfromt variationonfromto variations +varid varies varieties variety varinput various +vark +varmap +varmonotone +varmonotoneaux +varnum varout +varp varpw varpwval varq +varr vars +varsd varseq +varset +varsoppositeliterallist varspecs varsrng +varstate varstoconstants +vart +varto +vartype varuids vary varying vasconcelos vastly vative +vaxiom vayfohu vaynlxn vbb vbind +vbits vbldjgozvjavypfsoqjdjvexdgeehvqnc vbn vbool vbox vcablo +vcard vcass vccl vcdi @@ -77980,7 +85559,17 @@ vcdim vcdir vcell vcex +vcg +vcga +vcgadefiniteness +vcgadefinitenessvariant +vcgaequivalence +vcgaisallocationallocatinggoodsonly +vcgaismaximal +vcgaismaximalaux +vcgpdefiniteness vcgrp +vchop vci vcidold vciold @@ -77994,6 +85583,7 @@ vcompb vcompd vcompnaturality vconngr +vconst vcrel vcsm vct @@ -78005,14 +85595,20 @@ vdash_ vdash_c vdd vdegp +vderiv vdgfrgrgt vdgn vdif vdioph vdiscusgr vdiscusgrb +vdisjnt vdn +vdname vdoeuww +vdomain +vdp +vds vdumgr vdw vdwap @@ -78021,6 +85617,7 @@ vdwapfval vdwapid vdwapun vdwapval +vdwe vdwlem vdwmc vdwnn @@ -78038,6 +85635,7 @@ vecalt vecappend veccons vecconsunexpander +vecd vecempty vecemptyunexpander vechead @@ -78047,7 +85645,9 @@ vecmullinear vecmulsl vecmulvec vecmulvecbilin +vecnegate vecq +vecs vecsp vecspace vecssmod @@ -78061,6 +85661,7 @@ vectindexmap vectlengthmap vectmapcompose vectmapid +vectop vector vectorall vectorallp @@ -78075,6 +85676,7 @@ vectorfield vectorfouri vectorfourier vectorize +vectorjoining vectormeasure vectorprebundle vectors @@ -78082,6 +85684,7 @@ vectorspace vectorspaceuniform vectorspan vectorsprodeqone +vectortriple vectoru vectreversereverse vectsp @@ -78093,6 +85696,7 @@ velab velcomp veleaf velocity +velocityjoining velpw velpwalt velsn @@ -78106,6 +85710,8 @@ veqaeq ver verbatim verbose +verdict +verdicts verdier verif verification @@ -78130,6 +85736,7 @@ versionedidentifier versions verso versoheader +versus vert vertebrate vertex @@ -78152,9 +85759,13 @@ verticalstrip vertices verticesset verts +vertsg +vertst +verum verus very verynice +ves vex vextru vexw @@ -78163,13 +85774,16 @@ vfermltl vfermltlalt vff vffqxiupuwpjhjno +vfin vfmutdi vfq vfresh vfriendship vfriswmgr vfriswmgrlem +vfsequence vftsi +vfun vfval vge vgensym @@ -78179,17 +85793,20 @@ vhcomp vhd vhg vhmcls +vhom via viable viaembedding viaembeddinghom viaequivalence viafintypeembedding +viai vice victor vid vide videc +vidx vieta vietadeg vietalem @@ -78197,8 +85814,13 @@ vietoris view viewed viewkabstractsubexpr +viewl +viewln +viewnres viewpoint viewpoints +viewr +viewrn views viewsubexpr vii @@ -78211,11 +85833,14 @@ vin vincent vinh vinj +vinsert vint vintage vintageyear vinv vinvequiv +vio +violates violating violation violations @@ -78233,6 +85858,7 @@ visitatom visitconst visited visitedfvars +visitedstates visiting visitinner visitm @@ -78242,12 +85868,14 @@ visittoken visittracenodesm visitwithandascendm visitwithm +vispost visvalue vit vitali vitaliconvergence vitalifamily vitalilem +viterbi vjsrgxnmizfgoyvgbd vjust vksyiwhvxgyxshtzepeoxhi @@ -78262,6 +85890,7 @@ vln vload vlong vlookup +vlsrc vlt vlttop vlunc @@ -78277,11 +85906,14 @@ vmalogdivsum vmappw vmaprm vmasum +vmatch vmaval vmcn +vmin vmsa vmsaverismo vmul +vname vnat vnbpr vne @@ -78289,6 +85921,10 @@ vnex vnil vnk vnl +vnm +vnmd +vnmi +vno vnotype vnpctndjxfelzlzrsj vnuid @@ -78386,14 +86022,17 @@ vot vote votedfor voter +voters votes votesreceived voteswithlog votkcalmtojwvmx vpeolsgtmqaeqrjbf +vpeq vpikwcxzojmwsfxaomtvxwmnacf vplus vpos +vpow vpqt vpr vprc @@ -78406,10 +86045,17 @@ vpullbackconeislimitofmap vpwex vqlquerytype vqt +vquot +vra vraag vram +vrange +vrecabs vreduce +vrelated vres +vrestr +vreturn vrg vrgpf vrgpfval @@ -78421,7 +86067,10 @@ vrmdfval vrmdval vrmutdi vrnfibi +vrules +vrulesi vsa +vsagree vsca vscacn vscaid @@ -78434,11 +86083,13 @@ vscandxnscandx vscl vsd vsep +vset vsetrec vsets vsfval vsingle vsize +vsl vsn vsnex vsnid @@ -78447,10 +86098,14 @@ vss vssjxahvhjggwxi vstore vsub +vsubset vsubst +vsubsta vsubu vsum +vsv vtcheck +vtensorone vtin vtl vtocl @@ -78530,22 +86185,30 @@ vuyzfgc vva vvaln vvar +vvars vvc vvd vvdifopab vvdqhsl +vvp +vvpstar vvv vvvv vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv vvwlci +vwalk +vwb +vwf vwltsi vwmgr vww vxa vxnvxzrerjxyspwyoudyprwvukqnittrzybtpcxmdquc vxp +vxv vxxsvnayxijglxzlrjamrdskeezlnequdjxgcadfjp +vydra vymqhwgiwerhjutkpgpmybkjpdunvphtdjkqxixugkmq vythcb vyx @@ -78555,8 +86218,11 @@ w_ih w_im w_mj wab +wabs wadler +waerden wait +waiting waj wakeup walk @@ -78603,6 +86269,8 @@ wallispi wallispilem wamt wand +wandi +wands wanica want wanted @@ -78619,6 +86287,8 @@ warnings warnonnonterminal warnparametricattr warshall +wary +waryi was washing washington @@ -78626,6 +86296,8 @@ wasm wasn wasteful watch +watchinvariantsafterapplylearn +watchinvariantsafterassertliteral water waterfall waterlevel @@ -78634,14 +86306,23 @@ watfvaln watt watvaln wave +wax way waybel ways +wbal +wbalanced wbc +wbis +wbist +wbt wbtw wca wcat_eq +wcc +wcd wcdeq +wcdnoninterference wcet wclopen wclyhjuabzzlluyiaesdilebfjozm @@ -78668,26 +86349,44 @@ wds weak weak-head weakbilin +weakbisim +weakbisimbangrel +weakbisimcoinductaux +weakbisimeqvt +weakbisimtransitivecoinduct +weakbisimulation +weakbisimupto +weakbisimweakcoinductaux +weakbisimweakupto weakdual weaken +weakenbisim +weakenbisimeqweakbisim +weakenbv weakened weakening weakenlte +weakenmonocoinduct +weakentransitioncases +weakeqsubset weakequ weakequivalence weakequivalences weaker weakest weakfepair +weakinduction weakl weakly weaklyconnectedcomponent weaklycovers +weaklydecidable weaklyetale weaklylocallycompactspace weaklyqua weaklyquasifiniteat weaklyregular +weakmonocoinduct weakness weakobseq weakr @@ -78698,6 +86397,7 @@ weakuntil weapon weaponofmassdestruction wear +web webnjiteducjohnsontreebiochhtm wec wecmpep @@ -78709,6 +86409,7 @@ weeq wef wefr wefrc +wegman wei weie weierstrass @@ -78774,9 +86475,16 @@ well-typed wellapproximable wellbehaveddischarge welldef +welldefinedtowellformedset wellf wellfo +wellformed wellformedbasis +wellformedcons +wellformednil +wellformedsubst +wellformedtoset +wellformedtosetinrangeexplode wellfounded wellfoundedgt wellfoundedlt @@ -78785,12 +86493,14 @@ wellfoundedrelation wellorder wellorderedbasis wellorderextension +wellorderi wellorderinductiondata wellorderingax wellorderingrel wellpowered wellquasiordered wellquasiorderedle +welltyped wemaplem wemappo wemapso @@ -78813,11 +86523,14 @@ wesn weso wess wessf +west westof weth wetrep +wetzel wevgblacfn wexp +weyl weylgroup weylgroupcorootrep weylgrouprootrep @@ -78826,6 +86539,7 @@ wf-offer wf-rec wf-var wfac +wfactors wfaxext wfaxinf wfaxnul @@ -78835,10 +86549,15 @@ wfaxreg wfaxrep wfaxsep wfaxun +wfc +wfd wfdvdmonoid +wfe wfelirr wff +wffp wffr +wffs wfg wfgru wfi @@ -78849,28 +86568,37 @@ wfl wflem wflt wfmbz +wfp wfprd wfr wfrank wfrdmcl wfrdmss +wfrec wfrel wfrfun wfrrel wfrresex wfs +wfsf wfst wft wftac wfximgfd +wgeq +wgraph +wgreater what what_ whatever +whatwhere whe wheel when whenever whenfn +wheninj +whenjust whenlinteractivated whenlinteroption whennotlinteroption @@ -78885,8 +86613,18 @@ whi whic which while +whilea +whilefalse +whilehighcompositionality +whilei +whilelowcompositionality +whilelowstepinduct +whilerule whiles whilesr +whilestepinduct +whilet +whiletrue whisk whiske whisker @@ -78944,11 +86682,16 @@ white whiteboard whitebordeaux whiteburgundy +whited +whitee +whitei whiteloire whitenonsweetwine +whites whitespace whitespacebeforesemicolon whitespacelinter +whitespot whitetablewine whitewine whitney @@ -79001,6 +86744,7 @@ widepushoutshapeunop widepushoutshapeunopop wider widespan +widest widesubcategory widesubcategoryinclusion widesubquiver @@ -79018,9 +86762,18 @@ wifodhqtub wigcserdjjmwn wiki wikipedia +wildand wildcard wildcards +wilddot +wildexists +wildor +wildpos +wildpure +wildstar +wildwild will +williams willroundtrip wilson wilsons @@ -79049,8 +86802,14 @@ winegrape winery winesugar winetaste +winker +winkerp +winkerr winl winner +winning +winningallocationismaximal +winningallocationismaximalwithoutseller winr wins wint @@ -79064,6 +86823,7 @@ wiring wise wiso wit +witd with withabs withadd @@ -79095,6 +86855,8 @@ withbotsucc withbottop withbottoset withcollectingnewgoalsfrom +withcommand +withcommands withconfig withconstants withconstantsselfstructure @@ -79104,6 +86866,7 @@ withcontext withcontt withconv withcstarmodule +withcurrentdirectory withd withde withdeceq @@ -79117,6 +86880,7 @@ withdensity withdensitysmulli withdivisionring withdivring +withe withenableinfotree withensuringlocalinstance withexistselimalongpath @@ -79140,7 +86904,9 @@ withincdischargedepth withincreasedtransitiondepth withincrecdepth withinfo +withini withinitial +withl withlams withlawson withlctx @@ -79180,6 +86946,7 @@ withneweqs withnewlocalinstances withnewmctxdepth withnondepproplocation +withoffendingflows withone withonecongr withoptionatcurrpos @@ -79203,6 +86970,7 @@ withparam withpitopology withppoptions withpreorder +withprogname withpushmacroexpansionstack withreader withreducible @@ -79265,7 +87033,9 @@ withzerounits withzerounitsequiv witness witnesses +witnessi witnessing +wits witt wittadd wittmul @@ -79290,6 +87060,7 @@ wksonproplem wksv wktclzusdtw wlem +wli wlim wlimeq wlimss @@ -79356,38 +87127,50 @@ wlogcore wlogle wloglei wlogresult +wlp wlt wmap +wmax wmeas wmem +wmin wmk wmqwgvjqrhpan wnefimgd +wneg wnf wnfanf wnfenf wnfnf wnorm +wod +wodnoninterference wofi wofib wojrcmumresorqualmrlawfqynaxqzugurc +wolew wolf woman won wonder wonelection +wont woodbury woodin +woot wop wopprc woppside woprm wor word +wordinterval +wordn wordplay wordpress wordprod words +wordsby wordset work workaround @@ -79401,6 +87184,7 @@ workspace workspaces world world_ +worlds worry worse worst @@ -79417,7 +87201,11 @@ wpath wpathcaseson wpathdestleft wpathdestright +wpc +wpd +wpl wpmk +wpo wpos wprec wpthswwlks @@ -79427,8 +87215,11 @@ wrack wraith wrap wraparound +wrapc +wraph wrapped wrapper +wrappergenericjoin wrapping wrapsimpdischarger wrapsumaccess @@ -79476,27 +87267,45 @@ wrepr wright writable write +writeable +writecarray +writecarraycorrect +writecorrect +writed +writeextendcorrect +writefailcorrect writefile +writenoextendcorrect writepcp writepsp writepss writer writert +writertimonadwriter writes +writesucceedcorrect writing written writtenincharts writteninextchartat writteninextend +wrm +wrmrm wrong wrongly wronskian wronskianbilin wrote +wrp +wrpsr wrt +wrtbr +wrwim +wry wsameside wscmgqboniznljmcaivytrzta wseq +wset wsetoid wsh wsnd @@ -79525,6 +87334,8 @@ wspthsnwspthsnon wspthsswwlkn wspthsswwlknon wspv +wstate +wsts wsuc wsuccl wsuceq @@ -79532,10 +87343,20 @@ wsucex wsuclb wsuclem wswfuuzisbzwkz +wsx +wta wtc +wte +wtfsym wtgoldbnnsum wth +wtimes +wtl +wtn +wtpb +wtpsym wtrt +wts wtype wun wunccl @@ -79577,6 +87398,7 @@ wunsn wunss wunstr wunsuc +wuntil wuntp wuntpos wuntr @@ -79593,6 +87415,8 @@ wvx wwalks wwalksn wwalksnon +wwf +wwfusion wwlemuld wwlk wwlkbp @@ -79699,12 +87523,18 @@ xchbinxr xchnxbi xchnxbir xclass +xcp xcpt +xcpts xcs xcx xczelfhec xdd +xde xdfustzttijrspxqm +xdgdirectory +xdgdirectorylist +xdictates xdiv xdivcl xdivcld @@ -79719,7 +87549,12 @@ xee xelcsdfiuwfyrvlehweoivclg xeq xeqlelt +xffff +xffffffff +xffffffffffffffffffffffffffffffff +xfirst xfktsjrn +xfollow xfr xfrcnv xfrcnvlem @@ -79851,6 +87686,10 @@ xmettpos xmettri xmetunirn xmetutop +xml +xmldoc +xmlor +xmls xmscl xmseq xmsge @@ -79934,8 +87773,10 @@ xoror xorpif xorpifn xorrot +xors xortac xortru +xos xov xpab xpassen @@ -80028,6 +87869,7 @@ xprod xprodname xprodtype xprop +xps xpsadd xpsaddlem xpsbas @@ -80081,6 +87923,7 @@ xpundir xpv xpwdomg xpwf +xpz xqvwnx xqyycropxxstrjnl xqzgwuvsb @@ -80106,6 +87949,7 @@ xrgtso xrhaus xrhmeo xrhmph +xrhs xrhval xrightarrow xrinf @@ -80226,15 +88070,18 @@ xskijump xsmall xspecy xspgnd +xsr xss xssa xsss xssss xsty xsubge +xsv xsy xtageq xtagex +xtoy xtt xttt xtttt @@ -80242,11 +88089,13 @@ xty xtype xudfn xval +xvec xvwnqgwormuz xxiso xxisoofeq xxply xxs +xxts xxx xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx @@ -80254,25 +88103,33 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx xxy xxyz +xxz xyab xyeq xyg xyide xyideal xyinf +xyk xynmngfr xyqsol xyqsolb xyqsolr +xys xysunu +xyx +xyy xyz xyzw xzeqi +xzx +xzy yac yafull yamamoto yang yao +yates ybar ybfull ybody @@ -80312,6 +88169,7 @@ yim yins yinst yint +yjs yle ylem ymap @@ -80386,19 +88244,23 @@ your ypo ypos ypow +yps ypt yqe yqgi +yqs yqsol yqsollem yrcyyycxbuv yre +yrhs yrjdzyyuv ysa ysharifi yspecx ysrkmlcvbppabdqv yss +ysv ytwwxcznwyqcju ytype yury @@ -80409,17 +88271,23 @@ yvalue yvar yvars yvaumnplwl +yvec yvi yxcjxnunosiwuvihrbq yxinrecipf yxs yxwvp +yxx +yxy yys +yyx +yyy yyyy yyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy yzajxe yzgk yzjnzrjrwnnseolxxixrnqmrtzhogjxhttcfflixf +yzx z3 zaanen zabs @@ -80446,6 +88314,7 @@ zarcmp zarcmplem zarecki zari +zariski zariskiprecoverage zariskipretopology zariskismainproperty @@ -80462,6 +88331,7 @@ zbiuinrgysvvhsermoxfz zbtwnre zbytes zceil +zcf zcg zcgeval zcgform @@ -80473,11 +88343,13 @@ zcnd zcompare zcong zconstr +zcount zct zcuts zdef zdend zdi +zdiff zdis zdiv zdivadd @@ -80523,6 +88395,7 @@ zero_tropical zero_tropical_def zero_tropical_min zero_tropical_min_def +zeroa zeroadd zeroatfilter zeroatfilteraddsubmonoid @@ -80533,17 +88406,21 @@ zeroatinftycontinuousmap zeroatinftycontinuousmapclass zerob zerobounded +zeroc zerocochain zerocokernelcofork zerocokernelofzerocancel zeroconf zeroconst zerocoprodiso +zerod zerodefault zerodefaultsupp zeroed zeroequiv zeroes +zerofix +zerofree zerofun zerofunc zerohom @@ -80551,6 +88428,7 @@ zerohomclass zerohypercover zerohypercovers zerohypercoversmall +zeroi zeroisbounded zeroisinitial zeroisoinitial @@ -80586,12 +88464,15 @@ zerooval zerop zeropow zeroprodiso +zeror zerorank zeroringprod zeroroot zerorootsubalgebra zeros zerosection +zerosnd +zerospace zeroth zerothhomotopy zerou @@ -80619,9 +88500,11 @@ zexpscl zextle zextlt zfac +zfact zfallfaccl zfausab zfauscl +zfaxioms zfbas zfc zfcndac @@ -80631,8 +88514,13 @@ zfcndpow zfcndreg zfcndrep zfcndun +zfdata +zfdepth +zfdepthinnat +zfdepthsuc zfind zfinf +zfinj zfloo zfloor zfmisc @@ -80646,6 +88534,8 @@ zfregs zfrep zfrepclf zfset +zftfst +zftype zfun zfv zgcdsq @@ -80660,6 +88550,7 @@ zhat zhdbk zhikkvjyjbxletgebrtilxbcbx zhmnrg +zhmset zify zifyproof zigzag @@ -80667,8 +88558,11 @@ zigzagsetoid zin zindbi zindd +zinf zinfandel +zinj zip +zipall zipidx zipleft ziplocationwf @@ -80676,8 +88570,11 @@ zippel zipper zipright zipwith +zipwithl zipwithleft zipwithm +zipwiths +zipwithstep zisinitial ziuhxzuoatpykri ziv @@ -80694,6 +88591,7 @@ zlem zlemma zlength zlengthv +zless zletr zlidl zlidlring @@ -80766,6 +88664,7 @@ zmodule zmodxquotspanequivquotspan zmodxquotspanequivquotspanpair zmowhvjchdqeeegocilcwvjlrmnxnlhgfanfywhqxnixmmahegvfya +zmset zmulcl zmulcld zmulcom @@ -80777,6 +88676,7 @@ zmultiples zmultiplesaddhom zmultipleshom zmultiplesquotientstabilizerequiv +zmultiset zmx znadd znat @@ -80809,6 +88709,7 @@ znidomb znle znleval znlidl +znm znmul znn znnen @@ -80835,9 +88736,12 @@ znzrh znzrhfo znzrhval zob +zobis +zobist zodd zoey zofldiv +zone zoneddatetime zookeeper zoom @@ -80846,9 +88750,13 @@ zoomstrin zoomstring zooopst zopp +zorder zorn zorng zornn +zorns +zout +zpassign zpls zplus zplusmodne @@ -80870,6 +88778,7 @@ zpqqcrrlssda zpred zprod zprodn +zps zqssxy zquotient zquotientmonotone @@ -80965,6 +88874,7 @@ zsbday zsd zseo zsep +zset zsex zsmul zsmuladdgrouphom @@ -80975,6 +88885,7 @@ zsnkk zsodd zsoring zspan +zspot zsqcl zsqrtd zsqrtelqelz @@ -80993,6 +88904,7 @@ zsucc zsum zsupss zthrhqezai +ztpoly ztprmneprm ztrunc zulip @@ -81006,8 +88918,12 @@ zxhzrqxrxgy zxr zxrd zxwgt +zxy zxyraiwttcmngajkk +zxz +zygmund zyjbucgdbyjjr +zyz zzd zzho zzlesq diff --git a/training_data/vocabulary_UNIFIED.txt b/training_data/vocabulary_UNIFIED.txt index 9703744..6fa5e58 100644 --- a/training_data/vocabulary_UNIFIED.txt +++ b/training_data/vocabulary_UNIFIED.txt @@ -3,6 +3,7 @@ aaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaab aaab aaabe @@ -13,6 +14,7 @@ aaaec aaaf aaafeecc aaan +aaanh aaanv aab aabaa @@ -23,12 +25,14 @@ aabeaf aabeb aabefc aabf +aabflist aabs aac aaca aacadb aacadbcf aacb +aacbf aacc aacce aacd @@ -39,7 +43,14 @@ aacfa aacjcl aacllem aacn +aacq +aacquire +<<<<<<< Updated upstream +======= +aacrit +>>>>>>> Stashed changes aact +aacts aad aadafe aadb @@ -47,7 +58,10 @@ aadbc aadc aadd aadde +aaddr +aaddressing aade +aadlen aae aaea aaeb @@ -57,6 +71,7 @@ aaecc aaece aaed aaede +aaee aaef aaf aafa @@ -71,30 +86,65 @@ aafe aafef aaff aaffbdfcc +aagard +aah aais aaitgo +aaj +<<<<<<< Updated upstream +======= +aak aal +>>>>>>> Stashed changes aalias aaliou aalioulem +aalist +aalistp +aalloc +aallocempty +aallocfixed +aaload aalt +aalways aam +aamp +aand aannen aannenlem aaof aaotnj +aap +aapp aaqlhwaebond +aararry +aarary +aarch aarden aareccl +aargh +aargs aaron aaronson +aarray aas +aasm aasscn +aassign +aassoc +aastore aasu +aatom +aauhtve +aav +aaw +aax +aay aba abaa abaae abab +ababab abac abacfeef abad @@ -107,16 +157,19 @@ abafcaa abafd abafe abai +abandon abandoned abanshofy abanssl abanssr abar +abaw abb abba abbab abbaf abbb +abbbrev abbc abbcbf abbd @@ -137,29 +190,47 @@ abbii abbr abbrev abbreve +abbrevi abbreviate +abbreviated abbreviation abbreviationdict abbreviations abbrevs +abbrevt +abbrv +abbw abc abca +abcacb abcaf abcb abccbd abcce abcd +abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq abcde +abcdef +abcdefabcdef +abcdefg +abcdefgh +abcdefghijklmnopqrstuvwxyz +abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz abcdefghijklmnopqrstuvwxyzabdeghijklmnopqrtuvw +abcdefw abcdta abcdtb abcdtc abcdtd abce +abcequalscba abcfa abcfb +abcgf abciffcbatnabciffncba abciffcbatnabciffncbai +abcmiz +abcxdefxghixjkl abcyclesiso abd abdb @@ -170,6 +241,7 @@ abddec abde abdea abdf +abdirprod abdv abe abea @@ -181,35 +253,67 @@ abeee abef abel abelab +abelain +abelem +abeleme +abelemg +abelemgp +abelemj +abelemp +abelems abelian abelianaux +abeliancategory +abeliane abeliangroup abelianimagetokernel abelianimagetokerneliskernel abelianization +abelianizationabgroup +abelianizationcomparisonisomorphism abelianizationcongr +abelianizationequiv +abelianizationfun +abelianizationgroup +abelianizationhom +abelianizationidempotent abelianize abelianizeadj +abelianj +abelianm +abelianmonoid +abelianness abelianofadjunction abelianofequivalence +abelianp +abelians abeliansubcategory +abeliany abelnf abelop +abelow abelsummationproof abelth abelthlem abelv +abenriched +abeq abeqab abeqabi abeqin abeqinbi abeqv +abew abex abexd abexex +abexp abexssex +abext +abexv abf abfa +abfb abfc abfdfabe abfe @@ -219,16 +323,36 @@ abfmpel abfmpeld abfmpunirn abgp +abgr +abgroup +abgroupcat +abgroupequiv +abgrouphom +abgrouphomomorphism +abgroupiso +abgroupobjects +abgrouppath +abgroups +abgroupstr abhomologyiso abi +abian abid +abiddc abidnf abii +abiidc abijf +abil +ability +abils abim abind abinds +abir +abirs abit +abj abkl abl abladdsub @@ -252,6 +376,7 @@ ablnncan ablnnncan ablnsg ablo +ablock ablocom ablodiv ablodivdiv @@ -263,6 +388,7 @@ ablpncan ablpnpcan ablprop ablpropd +ablressid ablsimpg ablsimpgcygd ablsimpgd @@ -278,23 +404,62 @@ ablsub ablsubadd ablsubaddsub ablsubsub +abmc abmn abn abnex abnexg +abnormal abnotataxb abnotbtaxb +abo +abody abort +aborte +aborted +aborti aborting +abortinst +abortlatch +abortnonei +aborts +abortsomei abot +abou about +aboutalwaysfalsefunction +aboutalwaystruefunction +aboutchar +aboutcloseparser +aboutempty +aboutf +aboutgcd +aboutgimmieseven +aboutj +aboutlexicographicbyteseqbelow +aboutlexicographicbyteseqbelowaux +aboutlist +aboutmin +aboutnatural +aboutp +aboutpositive +abouttrystructural +abov above +abovemin +abovep +abovereflexive aboves +abovetransitive abpa abpr abpra abr +<<<<<<< Updated upstream +======= abrahamlincoln +>>>>>>> Stashed changes +abranch abrcond abrexco abrexct @@ -306,12 +471,17 @@ abrexexd abrexexg abrexfi abrexss +abrp +abrs +abrsf abrupt abs absabv +absaxiomcheck absc abscd absch +abscheck abscissa abscissaofabsconv abscj @@ -323,40 +493,64 @@ abscli abscn abscncf abscncfalt +abscomplex abscong absconv absconvex absconvexhull absconvexopensets abscosbd +absctxt abscvgcvg abscxp abscxpbnd +absd +absdbupd +absdiff absdifle absdifled absdiflt absdifltd absdiv +absdivap +absdivapd +absdivapzi absdivd absdivzi absdvdsabsb absdvdsb +abse absef absefi absefib +abselim +absem +absen absence +absent +absenv abseq +abses +absesmorphism absex absexp absexpd absexpz +absexpzap +absext absf +absfat absfbounded absfico +absfloat +absfree +absfs absfun absg absge +absgroupequiv absgt +absgtap abshicom abshom absi @@ -368,19 +562,32 @@ absidm absimle absimlere absimnre +absin +absindexed +absint +absintvupd +absirrel absisadmissible +absl absle absled abslei abslem +abslist abslogimle abslogle abslt +absltap absltd abslti abslts +absm absmax +absmaxmin +absmmio absmod +absmodzmod +absmsg absmul absmuld absmulgcd @@ -388,6 +595,7 @@ absmuli absmulrposd absmuls absn +absname absnat absne absneg @@ -412,32 +620,48 @@ absolutelycontinuous absolutelycontinuousoninterval absolutelyconvex absolutelyconvexsets -absolutelyinfinite absolutepath absolutetoknownnature absolutevalue +absoneone absor absorb absorbant +absorbed absorbent +absorbequiv +absorbi absorbing absorbs +absorbtion +absorbtive +absorbtoken absord absori absorp absorption absorptive +absort +abspath +abspos +absprimcom +absprimexpr absproddvds absprodnn +absr absrdbnd absre +absreal absred absrei absreim absreimsq absrele absresq +absring absrpcl +absrpclap +absrpclapd absrpcld abss absscl @@ -449,10 +673,12 @@ abssi abssid abssinbd abssinper +abssinx abssnid abssor abssq abssub +abssubap abssubd abssubge abssubi @@ -462,49 +688,87 @@ abssubrp abssubs abssval abst +abstatomicp absterm abstfn +abstform +abstformp +absthm abstr abstra +abstraa +abstrac +abstracci abstract abstractcofilteredclosure abstractcofilteredclosurerealization abstractcompletion abstractcrashawaresystemrefinement +abstracted +abstractedge abstractfilteredclosure abstractfilteredclosurerealization +abstracting +abstractinterface abstraction abstractiond abstractioni +abstractions abstractjournal +abstractly abstractm +abstractmap +abstractmethod abstractmvars abstractmvarsresult +abstractp abstractpaper abstractproof abstracts abstractsimplicialcomplex +abstrgba abstri abstrid abstrii abstrlevel abstrlevels +abstrx +abstrxp +abstterm +absttermp +absty abstype absurd +absurdity +absurdium +absurdum +absurdw absv absval absvalsq absvalsqd absvalsqi +absvalu +absvalue absx absz +absze +abszesg +abszesign abszm +abszmsign abszn +abszx abt +abtl abtocycles abtp +abtr +abuiltin +abul abundancyindex abundant +abuot abuse abuses abusing @@ -528,6 +792,7 @@ abvmul abvn abvne abvneg +abvor abvpropd abvrcl abvrec @@ -537,7 +802,10 @@ abvtri abvtriv abvtrivd abvtrivg +abw aby +abyte +abytes aca acaa acaaae @@ -548,6 +816,7 @@ acabs acac acacni acaddeba +academic academicpensieve acae acaf @@ -555,15 +824,18 @@ acafc acafe acaff acap +acas acb acba acbb acbbabdf acbbb acbbdaa +acbc acbda acbe acbf +acbt acc acca accaa @@ -573,56 +845,120 @@ accbf accc acccc acccf +acccommodate accd accdadf accdbbb accdbc +accdesc +acce accent accept acceptable +acceptance +acceptcm acceptd accepted accepti accepting +acceptingaarun acceptingrun +acceptm accepts +acceptsa +acceptsb acceptsfrom acceptsi +acceptsubsetandtype +acceptsubtraitintint +acceptsv +accepttype +acces +accesors access accessctrllistdata +accessdescriptor accessed +accesseffproperty +accesses +accessflags +accessi accessibility +accessibl accessible +accessiblei +accessiblestates +accessind accessing +accessistagchecked +accessmap +accessnone +accessor +accessors +accessp +accessstorage accf acci accidental +accl +accls +accm +accmodality accn +accnames +acco accommodate +accomodation accomplement accomplish +acconstraint +accordance +accordi according accordingly account accountability +accounted +accountid +accountids accounting accounts accp +accpart accpt -accrediting +accpti +accr +<<<<<<< Updated upstream +accrsu accs +accset acct +======= +accrediting +accrsu +accs +accset +>>>>>>> Stashed changes +acctrans +acctype accu accum +accums accumulate accumulated +accumulating accumulation accumulator +accumulators +accup accur accuracy accurate +accurately +accv acd acdad +acdadc acdb acdc acdd @@ -638,7 +974,17 @@ acedcdfa acee acef aceff +acefw aceq +acess +acexmid +acexmidlem +acexmidlema +acexmidlemab +acexmidlemb +acexmidlemcase +acexmidlemph +acexmidlemv acf acfa acfaf @@ -648,25 +994,39 @@ acfcb acfd acfe acffae +acfun +achain +achar achart +acheck +acheckpt +<<<<<<< Updated upstream +======= +achievable +>>>>>>> Stashed changes achieve achieved achiever achieves +achtung aci acid +acirc aciunf ack ackbij ackbijnn ackendofnn ackermann +ackermannismonotonic ackermannterminates ackfnnn ackm ackno acknowledge acknowledged +acknowledgements +ackrmn acks ackval ackvalsuc @@ -675,6 +1035,7 @@ acl aclasst acldata acleq +aclh aclstat aclstatpcp aclstatpsp @@ -682,6 +1043,7 @@ aclstatpss acm acmauthor acncc +acnccim acndom acnen acneq @@ -691,9 +1053,21 @@ acnnum acnrcl aco acom +acomf acomp +acompatibled +acompile acomplete +<<<<<<< Updated upstream +======= acompletelattice +>>>>>>> Stashed changes +acomps +acompsp +acon +acone +aconeequiv +aconf acongeq acongid acongneg @@ -701,7 +1075,12 @@ acongrep acongsym acongtr acons +aconseq +aconses +aconsp +aconst acontext +aconv acopy acopyeu acor @@ -711,16 +1090,36 @@ acoscl acoscos acoscosb acosf +acosh +acosk +acosn acosneg acosrecl acost acosval +acoth acounit +acount +acp +acpc +acpsr +acq +acqfetched +acqpc +acqsc +acquintance acquire +acquired +acr +<<<<<<< Updated upstream +======= acres +>>>>>>> Stashed changes acrfl +acrit across acs +acsch acsdomd acsdrscl acsdrsel @@ -738,9 +1137,17 @@ acsmre acsmred act acta +actar actby +actbye +actcj +actcjv +acte +actevent +actf actfunsnf actfunsnrndisj +acti acting actio action @@ -750,60 +1157,120 @@ actionasfunctor actionassociso actionassocnatiso actioncategory +actioncharacterization actionhom actionhomleft actionhomright +actioninterpret +actioninvoke +actioniso +actionm actionobj -actionof actionofmonoidalfunctortoendofunctor actionofmonoidalfunctortoendofunctormop +actionp actionpunitequivalence actionright actions +actionsequiv actionunitiso actionunitnatiso activate activated activation +activations active +activebranchkeyencryptioncont +activebranchkeyencryptioncontext +activebranchkeyitem +activep +activesubset +activetail +<<<<<<< Updated upstream +======= activity +>>>>>>> Stashed changes +actjp actk actkin actkv actkvin +actl actleft +actlstar actm +actme +actmefun actmin +actmm +actn +actnr +actof +actor +actors +actp actperm +actperme +actpermk actpermm +actr actrans actreaders actright +actrk +actrkv +actrm acts actsd +actsesd actsi +actsol +actsp +actsq +actsrs +actstep actsu +actu +actua actual actuale actuali +actualization +actualleftperimeter actually +actuallynotreading +actuallytrue +actualrightperimeter actuals actualtype +actuary actwriters +actx +actxin +actxt +actzr +acu acufl acunirnmpt acut acute acuteangled acv +acval +acw +acy acyc acycgr acycgrcycl acycgrislfgr acycgrsubgr +acycli acyclic acyclicgraph +acycliclexless acyclicp +acyclicpath +acyclicpaths ada adaa adabbbb @@ -813,6 +1280,8 @@ adaed adaef adaf adafc +adalt +adam adamek adant adantl @@ -832,6 +1301,7 @@ adantrlr adantrr adantrrl adantrrr +adap adapt adaptation adaptationnote @@ -839,6 +1309,7 @@ adaptationnotelinter adaptationnotetermelab adaptdown adapted +adaptedd adaption adaptive adaptup @@ -860,7 +1331,9 @@ adcdb adce adcecaabb adcf +adcnv adconj +adcx add adda addaction @@ -869,21 +1342,30 @@ addactionfinset addactionhom addactionset addafterimports +addagree +addainv addalgebrainstancefromringhom addallowedunusedtactic addandcompile addantidiagonal addappparen +addargs addass addassd addassi addassnni addassnq +addassnqg addassoc addassocd addasspi +addasspig addasspr +addassprg addasssr +addasssrg +addassum +addaswitnessto addatom addatomq addaut @@ -891,10 +1373,12 @@ addautadditive addautequivunits addautoboundimplicits addaux +addax addb addba addbac addbaca +addbad addbalance addbb addbc @@ -903,10 +1387,17 @@ addbday addbdaylem addbf addbi +addbirthday addbk +addbl +addblock +addbn addborelinstance addbott addbottom +addbp +addbrfcte +addbt addc addcan addcanad @@ -917,13 +1408,32 @@ addcancelmonoid addcand addcani addcanpi +addcanpig addcanpr +addcanprg +addcanprleml +addcanprlemu +addcarry addcases +addcass addcc +addccan addccncf +addccom addcdd +addcdi +addcdir +addceq +addcex +addcexg +addcexlem +addcfn +addcfnex +addchain addchains +addchange addchar +addcid addcircle addcj addcjd @@ -937,13 +1447,18 @@ addclpi addclpr addclprlem addclsr +addcmpblnq addcmpblnr addcn addcncf addcncff +addcncntop +addcncntoplem addcnlem +addcnnul addcnsr addcnsrec +addcnul addco addcol addcom @@ -972,11 +1487,16 @@ addcommsemigroup addcommute addcomnni addcomnq +addcomnqg addcompi +addcompig addcompletioninfo +addcomplex addcompq addcompr +addcomprg addcomsr +addcomsrg addcon addcongen addconst @@ -989,7 +1509,9 @@ addconsttoprediscrtree addcontent addcontentextend addcos +addcoset addcovolume +addcr addcuts addcutslem addcyclic @@ -1003,6 +1525,7 @@ adddecltounfoldcore adddelabterminfo adddi adddid +adddigits adddii adddir adddird @@ -1012,18 +1535,37 @@ adddissociated adddistribaddaction adddivflid adddmmbl +adddontoverflow adde +addea +addeac +addeaca +addec +addeca added +addedbooks addedge +addedges +addedgetogba +addedgetograph +addedp +addee addef +addek addel +addell addelr addembed addemptyconstants +adden addend addends +addendum +addentries addentry addentryfn +addenv +addeny addeq addequiv addequivbiprod @@ -1039,22 +1581,44 @@ addequivprod addequivproddirectsum addequivtuple adder +addercirc +adderoutput +adderoutputi adderpq adderpqlem +adderr +adders +adderstr addex addexactsuggestion +addexists addexprs +addext addextension +addextpr +addey addf addfa addfact addfb addfdd +addfins +addfive +addfo +addforalls +addformulasto +addformulato addfp addfraction +addfrml +addfrmltograph +addfs addfunc addfunpropdecl addfv +addfxa +addfxc +addfxn addg addgcongrlemmaentry addge @@ -1066,6 +1630,7 @@ addgroupequivquotientprodaddsubgroup addgroupextension addgroupfilterbasis addgroupfilterbasisofcomm +addgrouphom addgroupisaddtorsor addgroupliealgebra addgroupnorm @@ -1086,45 +1651,72 @@ addhom addhomclass addhommk addi +addia addib addid addignoretactickind +addimm +addimp addimportedfn addin addinalllocations +addindex addindicator addineq adding +addinmap addinstance +addinstnames addinstruction +addint +addinterval addinvariantvectorfield addinvcom addir +addiscorrect +addiso addispoly addisscalartowerinstancefromringhomcomp +addit +additi addition additional additionally +additionalwildcardtests +additionoffractions additions +additionsagree additiv additive +additivecategory +additivee +additivefactorial +additivefaf additivefunctor additively additivemultiplicative additiveobjisobiproduct additiveofmul +additivesaf +additivew additivisable additivised additivity additivize +addiu addk addkb +addkl +addkn addkr addl addlazyentrytotrie +addlc addle +addlea addlec addlecancellable +addlecncs addleft addleftcancel addleftcancelmonoid @@ -1137,37 +1729,62 @@ addleftreflectlt addleftstrictmono addlelt addlem +addlemma addlenc +addlength addlenpfx +addlettersnotin addlid addlidd addlidi addlimc +addlimm addlinear addlinearequiv addlinter +addlist addlocalrewriteentry addlocalvarinfo addlocalvarinfoforbinderident +addlocpr +addlocprlem +addlocprlemeq +addlocprlemeqgt +addlocprlemgt +addlocprlemlt +addlong +addlongalias +addloopstr +addlpd addlsub addlt addltmul addltmulalt addm +addma +addmac addmacroscope addmagma addmap +addmc +addmca addmemclass addmessagecontext +addmetricinstructions +addmetricjumps +addmetricloads +addmetricstores addmo addmodid addmodidr addmodlteq addmodlteqalt addmodne +addmods addmoduledeprecation addmon addmoncat +addmono addmonoid addmonoidal addmonoidalfunctor @@ -1195,13 +1812,24 @@ addmul addmuld addmulmodb addmulsub +addmult +addmx +addmxa +addmxc addn addna +addnabc addnac addnaca +addnam +addnames addnat addnatemb addnatorderemb +addnb +addnba +addnbac +addnbca addnc addnca addnclem @@ -1211,27 +1839,63 @@ addnegeqproofs addnegeqproofsidx addneintr addneintrd +addnewedge addni addnidpi +addnidpig addnill +addnk addnkr +addnl +addnmx addnn +addnnnq +addnode +addnoden +addnodetogba +addnq addnqf +addnqpr +addnqprl +addnqprlemfl +addnqprlemfu +addnqprlemrl +addnqprlemru +addnqprllem +addnqpru +addnqprulem addnr addns addnsmul +addnumsize +addnye addnz addo +addomega addonbday +addone addoneform addonly +addop addopposite addoppositeequiv +addopsnt addord addorderof +addout +addoverflow +addox +addp +addpairwiseequals +addpath addpenrosevar +addpfunc +addphone +addpinq addpiord addpipq +addpipqqs +addpipqqslem addpointed addpolynomial addpqf @@ -1243,26 +1907,54 @@ addprojection addprojections addproperties addprotected +addptrofs +addpz +addq +addqa +addqc addquantale +addquaternion addquotientmeasureeqmeasurepreimage addr addra addrac addraca +addraligned +addrat addrawtrace +addrbbb +addrbdb +addrbdd addrc addrca addrcom addrd +addrdbb +addrdbd +addrdesc +addre +addreal addregular addrelateddecl addrelreldata addremeq +addres addresr address +addressable +addressdescriptor +addresse +addressed addresses +addressfix addressing +addresslist +addressordered +addressp +addresspart +addressparts addrewriteentry +addrfcte addrfn addrfv addri @@ -1279,17 +1971,28 @@ addrightreflectle addrightreflectlt addrights addrightstrictmono +addrinfo addrk +addrka +addrl addrmode addrn addrnk addrof addrok addrothnumber +addroundkey addrow +addrp +addrpd +addrpred +addrr addrs addrset +addrstack addrsub +addrsymbol +addrtop addrule addrval adds @@ -1306,6 +2009,7 @@ addsdi addsdid addsdilem addsdird +addse addsemiconjby addsemigroup addsemigroupideal @@ -1314,15 +2018,31 @@ addsfn addsfo addsge addsgt +addshortalias +addsi addsimpd +addsimps addsin addsingle addsingleequiv addsingletons +addsk addslid addsmul +addsmx +addsmxa +addsmxc +addsmxe +addsmxmr +addsmxp +addsmxs +addsmxsl +addsmxsr addsn addsnns +addsnz +addsome +addsp addspace addspanning addsprop @@ -1341,6 +2061,7 @@ addsub addsubass addsubassd addsubassi +addsubcarry addsubd addsubeq addsubg @@ -1350,6 +2071,7 @@ addsubgroupclosure addsubgroupof addsubgroupofclosure addsubi +addsubimmediate addsubmonoid addsubmonoidclass addsubmonoidclosure @@ -1359,39 +2081,75 @@ addsubs addsubsassd addsubsd addsubsemigroup +addsubsetset +addsubshiftedregister addsubsub addsuccess addsuggestion addsunif addsuniflem +addsup addsupport addsval +addsymbol addsynonym +addsz +addt addtagentry +addtb addterminfo addtheorem +addtheta addthrd addthread +addtime +addtimespan +addto +addtoarrlist +addtocatlist +addtolist +addtoobjlist addtorsor +addtotree +addtotreecorrect addtrace addtranslationattr +addtree addtsupport addtype addu +addudedge addunit addunits +addunum addusrgrptoacl addusrgrptoaclpcp addusrgrptoaclpsp addusrgrptoaclpss +addv +addva addval +addvalex addvaluation addvaluationdef +addvc +addvect +addvertex +addvf +addvs +addvsl +addvsr +addvv +addw addweight addwellapproximable +addwithcarry +addwithoutrepetition +addwitnessesto addx addxyz addy +addye addz addza addzc @@ -1408,20 +2166,27 @@ adedgwlklem adedgwlkon adedgwlkonalt adef +adefb adefd +adel adelering +adelkey +adem adequacy adequate adet adf +adfa adfb adfc adfe adfed adff +adg adgr adh adherence +adherent adhesive adhoc adhp @@ -1436,6 +2201,7 @@ adiccompletionequiv adiccompletionevalone adiccompletionintegers adiccompletionintegersequiv +adicity adicmoduletopology adictopology adicvaluation @@ -1443,13 +2209,21 @@ adicvalued adifi adifii adihtotgqhktl +adim +<<<<<<< Updated upstream +======= adimensionof +>>>>>>> Stashed changes +adipiscing adique +adis adiv -adivisorof adj +adjac +adjacen adjacency adjacent +adjacentset adjacentto adjadd adjadj @@ -1458,18 +2232,29 @@ adjbdln adjbdlnb adjcl adjcoi +adjcol adjcounit adjcounitiso +adjective +adjectives +adjectivestr adjeq adjeu +adjex +adjfin adjfrombun adjg +adjgraph adjh +adji adjid +adjl adjleft adjliftmap +adjlist adjlnop adjls +adjmap adjmatrix adjmo adjmul @@ -1480,6 +2265,7 @@ adjoin adjoinalgebramap adjoinalgebramapequiv adjoinalgebramapofalgebra +adjoinc adjoincommsemiringofcomm adjoindef adjoinequivringofintegers @@ -1505,6 +2291,7 @@ adjoinsimpl adjoinsimple adjoinsimplegen adjoinsingletonequivadjoinrootminpoly +adjoinsl adjoint adjointaction adjointaux @@ -1516,11 +2303,14 @@ adjointifycounit adjointness adjointpair adjoints +adjointua adjoinxequiv adjp +adjpairs adjretraction adjretractionaux adjright +adjs adjsslnop adjsylvester adjsym @@ -1531,6 +2321,7 @@ adjugate adjunct adjunctio adjunction +adjunctionhom adjunctionnhds adjunctionofcostructuredarrowterminals adjunctionofequivleft @@ -1538,48 +2329,89 @@ adjunctionofequivright adjunctionofstructuredarrowinitials adjunctions adjunctiontoptolocalept +adjunctionunit +adjunctionwithfunctors adjunit adjust +adjustable adjusted adjuster +adjustment +adjusts adjusttoorientation adjustwith +adjv adjval adjvalval +adjx +adjy +adjz +adl +adleman adm admin admissability admissable +admissibility admissible admissibleabsvalues +admissiblee admissibleindex admissiblelists admissiblemorphism +admission admit admits admitsfractional +admitt +admittance admitted admitting +admpre adms admsi adn +ado adoc +adom adopt adopts +adoubleprime +adox +adp +adph +adr +adresses +adrs ads +adst +adt +adts +adtvar adual adv +advan advance advancecommitindex advancecurrentterm advanced +advancedfrom +advances +advancetime advantage advantages +advbuildq +advbuildqaux adversary +advertised advice advisable +advised +adviser advlog advlogexp +adw +adx aea aeaa aeaac @@ -1636,6 +2468,7 @@ aeec aeed aeeq aeeqfun +aeeqmfun aeeqofforallsetintegraleq aeeqsetoid aef @@ -1645,13 +2478,21 @@ aefe aeff aefinstronglymeasurable aehijklmnoprstuvxabcdefghijklmnopqrstuvwyz +aeigt +aekey +<<<<<<< Updated upstream +======= aelement aelementof +>>>>>>> Stashed changes aeli aelimit +aelli aellti aelmi +aels aelsi +aelts aem aemble aemeas @@ -1660,26 +2501,50 @@ aemeasurabl aemeasurable aemeasurableof aemi +aempty aencrypt +aencset +aend +aenda +aendk +aenv aeq aeqb +aeqd +aeql aequiv aer aerange aercfli aerlli +aerr aerrci +aersi +aerts aertsi aes +aesccbhack aesctx +aesdecrypt +aesdecryptensurespublicly aese +aesencrypt +aesencryptensurespublicly +aesencryptoutput aeseq aeseqlim aeseqset +aesgcm +aeskdfcountermode +aeskdfcountermodeensurespublicly +aeslightengine +aesni aesop aesoptactic aestabilizer +aestack aestrong +aestrongly aestronglym aestronglyme aestronglymea @@ -1688,6 +2553,7 @@ aestronglymeasur aestronglymeasurab aestronglymeasurabl aestronglymeasurable +aeta aetr aetsi aev @@ -1700,17 +2566,26 @@ aevalequiv aevalequivfield aevalr aevaltower +aevaluates aevdemo aeveq +aevery aevlem +aevwli +aew aex aexp +aexpeq aexpr +aexpri +aexps aext +aezdeltafun aezfun afa afaa afab +afabbly afacaacaec afacecc afad @@ -1747,6 +2622,7 @@ afddb afddea afdedba afdf +afdp afe afea afeb @@ -1758,14 +2634,22 @@ afeed afef afefc afefefa +afence +afetr aff affbda affc affe +affect +affecta +affected +affectf +affecti affecting +affects afff +afffected affi -affiliatedwith affin affine affineaddmonoid @@ -1789,12 +2673,14 @@ affinecover affineequiv affineequivne affinehomeomorph +affinei affineid affineindependent affineisometry affineisometryequiv affineisometryofstrictconvexspace affinelocally +affinely affinemap affineonehypercover affineopencover @@ -1805,6 +2691,7 @@ affineopensequiv affineopensrestrict affineproperty affinerefinement +affines affinescheme affinescript affinesegment @@ -1815,29 +2702,87 @@ affinetargetmorphismpr affinetargetmorphismproperty affinezariskisit affinezariskisite +affinie +affinite affinity +affinplane +affinspace +affinstruct affinvertible +affn +affsign +affv +affvect afhandurxjsb afi +afilter +afins +afinsq afix +afixd +<<<<<<< Updated upstream +======= afixedpointof +>>>>>>> Stashed changes +afixj +afixjg +afixm +afixmin +afixp +afixrs +afixs +afixu +afixyin +afl +aflabbiness +aflabby afletter +aflines +afmidstruct +afml +afn aform aforms afp +afplanes +afproj +afr afread +african afs afsize afsval aft +afta +afte after aftercdot aftercompilation +afterderound +afterenround +afterexternal +aftergoto +afterinvfp +afterinvlt +afterinvs +afterkeying +afternm +afterrevkeying +afterrounding +afters afterwards aftfdypfllbipgttrguby +afti +aftr +<<<<<<< Updated upstream +======= afunction +>>>>>>> Stashed changes +afunctor +afupdkey afv afvco +afvect afvelima afvelrn afvelrnb @@ -1855,62 +2800,157 @@ afvvdm afvvfunressn afvvfveq afvvv +afw afwrite +aga +agai again against +agame agatha +agb agda age +agea ageable +aged +agem agen +agenda agent +agentattimet agents +agentset agenty +agenv +agenve +agenvel +agenver +agenvm +agenvs +agenvx +agep +aget agg +aggr +aggregate +aggregateassignment +aggregateprinting aggregates aggregation +aggregator +aggresive aggressive +aggressivel +aggressively +aggressivep +aggrs +agile +agility +agl +aglobal agm agmsequenc agmsequences +agnostic +ago +agp agr agree +agreeable agreedf agreedt +agreeing agreement +agreeon +agreep agrees +agreesi +agressive +agressively agrk agrkey +agrp ags agt agtt agz +aha +ahack +ahb ahead +aheap ahgkdwhp ahi ahis +ahit +ahlfors ahlswedezhang +ahm +ahom +ahomp +ahomwin +ahp ahqedxuapxeywxha +ahs +<<<<<<< Updated upstream +======= ahtml +>>>>>>> Stashed changes +ahval ahy ahyxvzcjmljuimrfurwk +aib aibandbiaiaiffb aibandbiaiffaiffb +<<<<<<< Updated upstream +======= +aibic +>>>>>>> Stashed changes +aibjc aibnbaif aibnbna +aic aid +aidc +<<<<<<< Updated upstream +======= aideal +>>>>>>> Stashed changes aidx aiffbbtat aiffbtbat aiffnbandciffatnotciffb aifftbifffaibif aifftbifffaibifff +aifrp +aig +aigarr +aige +aigenv +aiger +aigernums +aigli +aiglist +aign +aigne +aignet +aigneta +aignetc +aignetp aigr +aigs +aigtrans aiii aiis +ail +ailid +ailrd ails aim +aimg +aimgm +aimgx aiminus aimp aimpb @@ -1918,14 +2958,29 @@ aimpl ain aina ainaiaandna +aindex ainequalitytr +ainf +<<<<<<< Updated upstream +======= ainfimumofin +>>>>>>> Stashed changes ainfo +ainj +ainjec +ainjective +ainjectives +ainjectivity +ainni +ainp ains +ainstack aint -ainteger ainterval ainv +ainvar +ainvariant +ainvm aiota aiotaex aiotaexaiotaiota @@ -1934,30 +2989,55 @@ aiotaint aiotajust aiotaval aiotavb +aipq +aipr air +aircr +aircraft +<<<<<<< Updated upstream +airplane +======= airfoil +airplane airport airporthasiatacode +>>>>>>> Stashed changes +ais aisbbisfaisf aisbnaxb aisfbistiaxb aisfina +aisincreased aistbisfiaxb aistbistaandb aistia +aistp +aitken +aits +aiv aiydyhhtcyocmuvroegadalhtpcvbcnqcpfkv +aizerman ajfun ajfuni ajfval ajk ajmoi +ajripqn ajsyxkapq ajval aka +akey +akeys +akiyama +akk akra akrabazzirecurrence aks +aksm +<<<<<<< Updated upstream +======= aktnode +>>>>>>> Stashed changes ala alalbial alan @@ -1974,13 +3054,21 @@ albidv albii albiim albitr +alcohol alcom alcomexcom alcomimw +alcomiw alcoms alcomw ale +aleafptrs +alef alem +alemma +alen +alength +aleo aleph alephadd alephcard @@ -2015,12 +3103,14 @@ alephsucdom alephsucpw alephval aleq +alequcom +alequcoms alequex alequexv -aler alert alerting alertrange +alerts alerttime alessandro alev @@ -2033,26 +3123,39 @@ alexandrovdiscr alexandrovdiscrete alexbiex alexbii +alexdc alexdisc alexdiscequivpreord +alexeq alexeqg alexim aleximi aleximialt alexn +alexnim alexsub alexsubalt alexsubaltlem alexsubb alexsublem alf +alfa alfal alg algaddg algbase +algc algcat +algcf +algcfield +algci +algclassicalsep algclosure algcoalgequiv +algcorableindir +algcorableseplog +algcreal +algcrect algcvg algcvga algcvgb @@ -2065,20 +3168,29 @@ algebraadjoin algebraadjoinadjoin algebrabase algebrabasechange +algebrac +algebracd algebracoalgebra algebracoalgebraequiv algebracommsemiring +algebraequiv algebraequivofisomonads algebraequivunder algebrafunctorofmonadhom algebrafunctorofmonadhomcomp algebrafunctorofmonadhomeq algebrafunctorofmonadhomid +algebrahom algebraic +algebraically +algebraicallyclosedfield algebraicclosure algebraicgeometry algebraicindependent algebraicindepon +algebraicity +algebraicover +algebraics algebraicstructure algebraictopology algebraideal @@ -2108,7 +3220,10 @@ algebranormclass algebraofcoalgebra algebraofliesover algebraofmodule +algebraofsetstype algebraoverbot +algebrap +algebrapath algebrapi algebraquotient algebraquotientoflecomap @@ -2116,6 +3231,7 @@ algebraquotientoframificationidxnezero algebrarat algebras algebrasemiring +algebrastr algebrastructure algebratens algebratensoralgequiv @@ -2124,6 +3240,7 @@ algebratensormodule algebratoring algebratounder algebratower +algebratype algeq algequ algequi @@ -2163,6 +3280,7 @@ algext algextdeg algextdeglem algfx +alggi algho alghom alghomadjoinintegralequiv @@ -2177,110 +3295,286 @@ alghomoflinearmaptensorproduct alghomofrightfdrepcomp alghomtower alghomunitsequiv +algid +algidl +algidp +algidr +algim +algimm +algimv +algindir alginst alginv +algl alglattice +algmixin algmulr +algn +algnatded algnormfromconst algnormofalgequiv algo +algorep +algorith algorithm algorithmic algorithms +algorithmsuite +algorithmsuiteid +algorithmsuiteidisunique +algorithmsuiteinfo +algorithmsuiteinfobybinaryid +algorithmsuiteinfobybinaryidiscomplete +algorithmsuites +algorithmwf +algorithmwfaux +algoritm algos algr +algre +algrebra +algrecindir +algrem +algrev algrf +algrflem +algrflemg algrp +algs algsc algsca algsemilattice +algsepindir +algseplog +algseprec +algseq +algseqlambdaf +algsequence +algspec algstr +algsuite +algty +algtype algvsca +algxy ali alia alias +aliasdb aliased aliases +aliasesp +aliasing +aliasnametype +aliaspairs alice +<<<<<<< Updated upstream +======= alid +>>>>>>> Stashed changes +alift align alignas aligne aligned +alignedxaddrsrange +aligning alignm alignment alignments alignof aligns alignwith +alike alim alimd alimdh alimdv alimex alimi +alimitedp alimp alinexa aliquot +alis +alisp +alispt +alisr alist +alistf +alistfix +alistfixes +alistlist +alistof alistp +alists +alistsp +alistsub alive +aliveimpl alj +alkane +alkene +alkyne all alla +allabove +allactbox +allactt allagree +allalgorithmsuites +allalgorithmsuitesiscomplete allallocations allallocationsequivalence allallocationsequivalenceextended +allallocationsinpowerset allallocationsvarcharacterization +allassociative allatoms +allatomsl +allbefore +allbelow +allberry +allblack +allblks allblocksread +allbnd +allbox allbutfi allbutfifvre allbutfiinf +allbutlastcp +allbutlastcptl allc +allcandidates +allcard +allcases allch allcha allchar +allcharcasestest +allcharstest +allcinsts allcoeffs +allconsec +allcoproductsof +allcoretr alld +alldec alldef alldefs +<<<<<<< Updated upstream +alldigits +======= alldifferent +alldigits alldisjointclasses alldisjointproperties +>>>>>>> Stashed changes +alldistinct +alldivide +alldpaths +alldtrails +alldvars +alldwalks alle +alledges +alledgesok +alleged +<<<<<<< Updated upstream +======= allegorical +>>>>>>> Stashed changes +allegro +allelse allem +allemi allentries +allepi alleq +allequalizers +allequalizersof allerrors +allex +allexistsother +allexprs +allfalse +allfieldsaredeclared +allfieldscontentsconsistentwiththeirdeclaration allfin +allfine +allfingen +allformulasof +allfreshvars +allfrom +allfun allfvars +allg allgoals +allgood allgrp +allhints +allhl +allhr alli +allid +alliff +allimmutablesareimmutable +allimp +allimpliesalwaysanother allimportedmodulenames allinput +allinputssound allinstances +allinstancesop +allinstructions +alliso +allkeysareincanonicallinearpairs +alll alllean +alllincombmod +alllincombzalllincomb alllinters +alllist alllsts alllstse allm +<<<<<<< Updated upstream +======= +allmem +>>>>>>> Stashed changes +allmodel allmodules +allmono alln allnames allnamesbymodule allnats allnatslt +allneg +allnegative +allneighbors allnetsdistinct allnodes allnotdsource +allntresolvents +allo +allobjects +allobjs alloc +alloca +allocarray +allocatable allocate +allocatearray +allocated +allocatedchar +allocatedness allocatedtobuyermeanssold +allocatematrix +allocates allocation +allocationbusiness allocationcharacterization allocationcrashawarejournal allocationcrashawarejournalrefinement @@ -2291,15 +3585,46 @@ allocationgoodsmonotonicityvariant allocationjournal allocationjournalrefinement allocationmonotonicity +allocations allocationsellermonotonicity +allocationsoundness allocationsuniverse allocationsuniversecharacterization +allocationtest allocationwithoneparticipant allocator allocb +allocbp +alloccontentsother +alloccontentsundef +allocd +allocempty +allocfield +<<<<<<< Updated upstream +allocfresh +======= +>>>>>>> Stashed changes +allocglobal alloclib +allocloc +allocmatrix +allocp +allocpool +<<<<<<< Updated upstream +======= allocproof +>>>>>>> Stashed changes +allocs +allocsize +allocthunk +allocvar +allocvariables +allocvars +allokdirgraph +allokgraph allones +allords +alloutgoingreferencesarevenice alloutput allow allowcompletion @@ -2314,55 +3639,140 @@ allowing allownaturalholes allowopaque allowportfromto +allowretry allows allowsplit allowsynthfailures allp allpairs +allpairsp +allpairxor +allpar +allparts +allpath +allpaths allperms +allpn +allpos +allpositive +allpowers +allpp +allprime +allprimeallzprime +allprimes +allprocs +allproductsof +allprojects allprojs allproofs allq +allr allrdblks allreg +allregions allrepeats +allresolvents +allretr allroots allrules +allrvars alls +allsameaction +allset +allsets +allshift allsigns +allsigs +allsigsp +allsorted +allstar allstates allsubsets +allsucs +allsymbolsof allt alltacticdocs +alltermsof +alltrails +alltrees +alltrue +alltypes allunexpectederrors alluse alluses +allvar allvars +allvertices +allwalks allwaysincluded +allwi +allwsubgraphs +allx allzfsetdefinable +allzprime +allzprimeallpos +allzprimeallprime +almos almost almostcancel almostcancellative almostcommutative almostcommutativering almostleftcancellative +almostneg +almostnegate +almostnode +almostnull +almostnullp +almostnullproof +almostoption almostrightcancellative +almostring +almostringpreserving +almostzerofunct +almostzerofunctions +almostzerolpfunct +almostzerolpfunctions alneu alnex +alo +aload +alocvars +alomst alon alone along alongid alongside +alookup +aloop +alors +alow +<<<<<<< Updated upstream +======= alowerboundofin +>>>>>>> Stashed changes alp alph alpha alphabet +alphabetcomparable +alphabetfinite +alphabetically alphaequality +alphai +alphaint +alphanum +alphanumericp +alphaprod alphas +alphat +alphavars +alphorder alq +alr alral +alre already alreadydone alreadyexists @@ -2387,19 +3797,40 @@ alscn alsconv alsi also +alsoalwaystrue +alsofine +alsonondetassignbutaccepted +alsonondetif +alsotakesadatatype +alsothis +alsotrue +alst +alsts alsyl alt alta +altasn altb altbound altc altcat +altcatex +altcatstr +altcatstrlambda +altcatuniq +altcompare altcongrhom +altcontrolflow +altd altdef +alte alter +altera altered +altern alternate alternates +alternati alternating alternatingcofacemapcomplex alternatingconst @@ -2421,30 +3852,51 @@ alternatingmap alternatingmapcongrright alternatingmaplinearequiv alternatingmaptodual +alternatingn alternatingprod alternatingsum alternatingword +alternation +alternativ +alternativa alternative +alternativeestablishinva +alternativeestablishinvb alternativeformulas +alternativehspacestructure +alternativelhss alternatively alternativemagma alternativemonad alternativeoftactic +alternatives alternatization alternatizeuncurryfin alternatizeuncurryfinclm alternatizeuncurryfinlm alternization altgnsg +altgraph +altgreater +altgreatereq altgsumbc altgsumbcalt although alti +altif altinfo altitude +altitudebisectsbase altitudefoot +altitudeofrighttriangle +altl +altless +altlesseq +altloop +altmul altn altname +altogether altopelaltxp altopeq altopex @@ -2456,9 +3908,15 @@ altopthd altopthg altopthsn altp +altprimedefinition +altr altru alts +altsignature altsinfo +altsyntax +altsyntaxp +alttest altv altvarnames altvd @@ -2467,61 +3925,150 @@ altxpeq altxpexg altxpsspw alty +alu +alua +aluawrite +alub +alubwrite +alud +aluop +aluout +alv +alval alw +alwa +alway always +alwaysanother +alwaysd +alwayse +alwaysfail +alwaysfalse +alwaysfalsefunction +alwaysi +alwayslist +alwaysmore +alwaysmoreprimes alwayssfi +alwaystrue +alwaystruefunction +alwaystrueisnotantisymmetric +alwaystt alwayswfi +alwi alwn +alwp +alwsafe +alwsf alxfr alzdvds alzip +ama +amal amalg +amalgam amalgama amalgamate +amalgamatedfreeproduct amalgamateofarrows amalgamation +amalgams amap +amatch +amax +amaze +amazing +amazon +amazondynamodbresource amb +ambi ambient ambiguity ambiguous +ambulance amc +amd ameas amem +amemory amenable +<<<<<<< Updated upstream +======= americahtml americanwine +>>>>>>> Stashed changes +amet +amethod +amethodisamethod amgm amgmlem amgmlemalt amgmw amgmwlem +amhfnxp ami amic amicable amin amintr aminus +amistd aml +amm +ammeltsil +<<<<<<< Updated upstream +======= amming +>>>>>>> Stashed changes amn +amnt +amo amod +amodb +amoe +<<<<<<< Updated upstream +======= amone +>>>>>>> Stashed changes among +amongst +amonot +amont amor amosym +amoun amount amountf amounts amove amovek +amp +ampamp +ampere +ampersand +<<<<<<< Updated upstream +======= amphibian +>>>>>>> Stashed changes ample ampleset +ampli +amplitu +amplitudes +amps +ampt amr ams +amspace +amt amtx +amul +amull +amullm +amulr amult +amulxnt +amusing amwo amzqplrut ana @@ -2531,18 +4078,30 @@ anabsi anabss anadec anadom +anafunc +anafunctor +anagrammi anainc analbinds +analmetr +analoaf +analog analogous +analogs analogue analogues analogy +analort analy +analys analyse analysed analysis +analysisresult analyti analytic +analytical +analytically analyticat analyticcgf analyticderivweierstrasspexcept @@ -2562,10 +4121,12 @@ analyticwithinat analytiques analyze analyzed +analyzelist analyzeresult analyzetraces analyzing analz +analzd anan anandi anandir @@ -2576,8 +4137,8 @@ anasplitr anass anassrs anasss +anat anatole -anaturalnumber anb anbi anbiim @@ -2587,19 +4148,25 @@ anbr anbrc anc ancestor +ancestors +ancestral +ancestrally ancestralrel anchor +anchored ancl anclb ancld anclem ancli +ancn ancom ancoma ancomb ancomd ancoms ancomsd +ancomsimp ancomst ancomstvd ancr @@ -2607,7 +4174,16 @@ ancrb ancrd ancri and +anda +andac +andaca andalso +andalsot +andap +<<<<<<< Updated upstream +andassociative +======= +>>>>>>> Stashed changes andb andba andbac @@ -2616,65 +4192,142 @@ andbb andbc andbca andbf +andbk +andbn +andbp andbt +andc +andca andcc andci andcii +andcommutative andconc +andconcend andd +anddec +anddef anddi ande +anded +andel +ander +anders anderson andex andf +andfasttoo andfb +andfdecls andfeliml andfelimr andfintro +andfp +andh andi +andid +andimm andintro andir +andkb andkind andl andleft +andlhs +andlimm andm andn andnand +andnb andncc andnotim +ando andorxor andp +andpa +andpf +andpn +andpp +andps +andpt andr +andrd +andrea +andreas +andrel +andrelpr +andrew +andrews +andrhs andright +android andrzej ands +andscheme andsetseq andsetseqaux +andso andsubset andsubsetaux +andsym +andt andtb andthen andthenfn andthenonsubgoals +andthensome +andtp +andtrue +<<<<<<< Updated upstream +andtrueneutral +======= +>>>>>>> Stashed changes +andu andvec +andw +andx ane aneg +anew +anewarray +anewarry +anframe +anframep ang +anga angcan angcld +angel angelic +angelstep angle +angleaddition +<<<<<<< Updated upstream +======= angleapb anglebac +>>>>>>> Stashed changes +anglebhalfline +anglechalfline +angledistinct +angleorderrespectscongruence +angleordertransitive +anglepart angles +anglesym +angletrichotomy +angleuuoovv angneg angpieqvd angpieqvdlem angpined angrteqvd angrtmuld +angular angval angvald +anh +anhdec anhil ani anibar @@ -2682,7 +4335,9 @@ anidm anidmdbi anidms anifp +anifpdc anil +anillo anim animal animbi @@ -2692,18 +4347,27 @@ animorr animorrl animp animpimp +aninfinitestream anior anir anisotrop anisotropic -anjou anl +anlist +anm anmp ann annbin anncall +anncom anncomp +annctx +anndefeq +anndefeqanniso annexpr +anngood +anngoodisgood +anngoodnil anni annideal annidealgenerator @@ -2711,16 +4375,23 @@ annidl annidllem annig annihil +annihilant +annihilantp annihilate annihilates annihilating annihilation annihilator +annihill +annihilr annil annilr annim +annimdc +annimim annir annirr +anniso annnr anno annonzero @@ -2738,48 +4409,107 @@ annotateterminfo annotation annotationfun annotations +annotcommenta +annotcommentt +annoti +annotrvi +annots +annotvi +annoucnes +announcements +announces annoyance annoyances +annoyed annoying annoyingly annpar annprmidl +annpropwff +annquin annrec +anns +annsig +anntoplevel +anntyping +<<<<<<< Updated upstream +annual +======= +>>>>>>> Stashed changes annul annuli annulus annwhile +anode +anodyne +anold +anomalies +anomaly anon +anonscope +anontrivial +anony +anonymise anonymity +anonymize anonymous anonymousd anonymousi anor +anorabs +anordc anorm +anormal +<<<<<<< Updated upstream +======= anormalformofin +>>>>>>> Stashed changes +anot another +anotherbadfib +anotherbrokenfunction +anotherclient +anotherexamplewithoutsplits +anothergoodrangereads +anothermethod +anothertest +anpc +anproj anpull anr anrabdioph anrev +anrness anrot ans +ansi ansmatrix +anstack answer answered +<<<<<<< Updated upstream +======= answering +>>>>>>> Stashed changes +answers ant +ante antec antecedent antecedents +antes anti antichain antichains antichard +anticipated anticollision anticomm +anticommutative +anticommutativity anticommutator anticommute +antid antideriv antiderivative antidiag @@ -2789,26 +4519,49 @@ antidiagonals antidiagonaltuple antidist antidistrib +antidom antidomain +antiendomorphism +antiepimorphism +antiframe antihomomorphism +antiisomorphism antil antili +antilinear antilipschitz antilipschitzconstant antilipschitzwith antimon antimono +antimonomorphism +antimonotonic +antimorphism +antimultiplicative antiperiodic antiperiodicity +antipodal +antipodals antipode antipodes +antiq antiquotkinds antiquotname antiquotp +antir +antirange +antird antiref antirefl +antireflexive +antires antis +antisy antisym +antisymemtric +antisymetric +antisymex +antisymlslt antisymm antisymmetric antisymmetrization @@ -2821,53 +4574,134 @@ antisymrelressn antisymressn antitone antitoneantitone +antitonel antitonemonotone antitoneo antitoneon +antitoner antitonic +antitonicity antitonicmonotonic antivary antivaryon antl +antlem antll antlr antnest antnestalt antnestlaw +antonym antr antrl antrr antrrr +ants +antsym +anub anum +anumber anv +anval anvold +anwhile anxordi any +anyaccessflag +anyacl anyalgebra +anyann anyappearsintypeproof +anyarith +anyarity +anyaux +anybranch +anybytes anycast +anycell +anycid +anycl +anyclassdecl +anycorrectlyreadbyterange +anycps anyd +anydata +anyef +anyefflag +anyenv +anyeof +anyerr +anyerror anyfield anyfieldanyalgebra anyfieldcommalgebra anyfielddivisionalgebra +anyfloat +anyframe +anyheader +anyheap +anyhow +anyhp +anyid +anyinst +anyinternal anyit +anylist +anylistp +anylocals anym +anymem +anymethod anymore +anyname +anyone +anyopstack anyp +anypc +anypredicate +anyptr +anyram anyrel +anys +anysign +anystack anysubset +anyt +anyth anything +anythread +anytid +anytt +anytype +anyval +anyvalue +anyvar anyway anyways anywhere +anyx +aob +aobd +aobe +aoc aodv +aofa +aofp aok +aokp aold aoldn aomclem +aone +aop +aopp aoprssdm +aops +aopt +aor +aord aot +aout aov aoveq aovfundmoveq @@ -2885,52 +4719,145 @@ aovvoveq aowdltjs apa apac +apadd +apand +apaphi +aparece apart +apartnes +apartness +apartnessequiv +apartnesspath apartnessrelation +apartnessstr +apartzero apath +apb +apbtwnz apc +apcharto apchild apchildlive +apchoose +apcomposefn +apcon +apcotr +apcs +apcxp apd +apdd +apdh +apdiff +apdifflemf +apdifflemr +apdivmuld apdpe +apeps apeq +aperiodic +aperiodici aperm +aperme +apex +apexists +apexp +apext +apf +apfn +apforall apfst +apgen +apha +aphi +aphipres api +apii apiid apiidasstr apiids +apimp +apintto apiresult +apirr apis apitypes +aplextoto +aplicaci +aplicaciones +aplicar +aplistoto aplus +apm +apmul +apne +apneg +apnot +apnt +apnumto +apolog +apologia apologise +apor apos aposteriori -apow app +appabs +appalength +appalist +appalling +appaload +apparenlty +apparent apparently apparg +appartient +appassoc +appastore appbasicopenisoawaymap +appbij +appbinop appbv +appc +appcas +appcheckcast +appcmpeq +appcong +appcongl +appcons +appctx +appdiv +appdivnq +appdup appe +appeal appealing +appealling +appealp +appeals appear appearance +appeared appearing appears appearsintypeproof appease +appela +appell +appen append appendafter +appendassoc appendassociative appendbefore +appendbytestofile appendcontents appendd appende appended +appendeli appendentries appendentriesreply +appendentriesrequest appendequiv appendfile appendfun @@ -2938,31 +4865,58 @@ appendhomeomorph appendi appendindexafter appending +appendisassociative appendisometry appendisometryofeq appendix appendl +appendlength +appendlenloop appendlist +appendm +appendmainloop +appendnil appendnilrightneutral +appendp appendr appends appendstep appendstream +appendtobranchsuff +appendtocorrectlyreadbyterange +appendwithoutrepetition +appendx +appendzeros +appeqvsubst +appext +appf +appfilter +appflv appfn +appfpad +appgetfield +appgetstatic apphom appi +appiadd +appiffalse +appinstanceof +appinvbij appio appirrel appiso +appk appl apple +appleft applemmas -apples applic applicability applicable +applicat applicati application +applicationp applications applicationtime applicative @@ -2972,18 +4926,25 @@ applied appliedargs appliedattrs appliedentries +appliedpairwiseto applies +appliese applinearmap +appling applinst applist +appload +applr apply applyaction applyaddhom applyaffinetoline +applyandprint applyapplyrule applyashom applyat applyattributes +applybackjump applybackjumpeffect applybackjumppreservedvariables applyco @@ -2997,12 +4958,17 @@ applycongrthm applyconst applyconstrule applycontrlemma +applydecide +applydecideeffect applydownfrom +applyedge applyentries applyentry applyexplainuip applyexplainuippreservedvariables applyexplainuiptermination +applyf +applyfalsetrue applyfinsupp applyfun applyfunhyp @@ -3011,11 +4977,15 @@ applyfuntargetfailure applyid applyidrule applyiff +applyin applying +applyk +applykont +applylambda applylearn applylearnpreservedvariables +applymatrix applymorrules -applymulaction applymulsemiringaction applynamedict applyorderedfinpartition @@ -3028,42 +4998,88 @@ applyreplacementfun applyreplacementlambda applyresult applyrfl +applyrk applys +applyselect applysimpresult applysimpresulttolocaldecl applysimpresulttolocaldeclcore applysimpresulttoprop applysimpresulttotarget +applysu +applysub +applysubstituti +applysubstitutio +applysubstitution applysum applysymm applytheconstructor applytoset +applytosetnoreferences +applytoxset +applytoyset applytransitionrules applyupto applywitharity +appmap +appmc +appmenter +appmessage +appmexit +appn +appnew +appnewarray +appnill +appnilr +appnone +<<<<<<< Updated upstream +======= appointment +>>>>>>> Stashed changes appp appparens +apppend +appplied +apppred +appps +apppush +appputfield +appputstatic appr +apprentice +appreturn +appreturns appro approach approachable approached approaches +<<<<<<< Updated upstream +======= approp +>>>>>>> Stashed changes +appropr appropriate appropriately approx +approxa approxaddorderof approxbounded approxchain approxcore approxdepth +approxe +approxenv +approxenvrefl +approxenvupdbound +approxenvupdfree approxgluing +approxi approxima approximable approximant approximants +approximat approximate approximated approximately @@ -3074,51 +5090,146 @@ approximateunit approximating approximation approximations +approxindex approxmc +approxmcl approxon approxorderof +approxprog +approxrn +approxrne +approxspheremap apprseq apps +appsize +appstar +appstore +appstr +appsyms +appt +appterm +appthm +appthrow apptop +appunit +appvar +apq +apqs apr +aprap +aprcl +aprcotr apre +apreap apred +apreim apren +aprep +aprepcor april aprilfools +aprime aprimedivisor apriori +aprirr aprog aprop +apropos +aprops apropsof aprove +aprsym +aprval +aps +apsing apsnd +apsqgt +apsr +apsscn +apsub +apsym +<<<<<<< Updated upstream +======= apsyms +>>>>>>> Stashed changes apt +aptap +apti +aptipr +aptiprleml +aptiprlemu +aptisr +apto +aptr +apunion apx +apxs +apy +apzi +<<<<<<< Updated upstream +======= +aqc +>>>>>>> Stashed changes +aqiclxa +aqiunpp +aqu +aqual +aqualv +aqui +aquire +arange arb +arbbool +arbdel +arbfalse +arbfuncomplete +arbification +arbify +arbint arbitary arbiter arbitra arbitrarily arbitrary +arbitraryofgenshrink arbitrarysized arbitrarysizedsuchthat +arbitrarysizest arbitraryst +arbitrarysuchthateql +arbitrarytypearg arbitraryuniverse +arblist +arbnat +arbnatgencorrect +arbnatmon +arbo +arbopt +<<<<<<< Updated upstream +======= arboreal +>>>>>>> Stashed changes arborescence arborescencemk +arbpair +arbst arc +arcatomicisize arccos +arccosec +arccot +arcd +arcdp arce arch archabsval +archbase archd archi archiabl archiabllem archiexdiv +archifieldtype archim archimdeanclassmk archimed @@ -3132,27 +5243,48 @@ archimedeanclassorderiso archimedeanclassorderisowithtop archimedeandiscrete archimedeanorder +archimedeanorderedfield archimedeanstrata archimedes +archinumdomaintype +archirealdomaintype +archirealfieldtype archirng archirngz +architecture +architectures archive archnq +archnqq +archpr +archrecnq +archrecpr +archsr +archversion +arclength arcosh arcs +arcsec +arcsi arcsin arctan arctanadd +arcv +arcwise ard +ardbzye arden ardenable ardenl ardenr +ardens are area areacirc areacirclem areacl +areadj +areadjfin areaf areaform areage @@ -3161,36 +5293,85 @@ areaquad arearect areas areass +areasymmetry areaval +arebij arec arecomplementary +arecoprime +<<<<<<< Updated upstream +======= areductofin +>>>>>>> Stashed changes aredundant areequalizedbylocalization +aref arefl +areg +aregn +aregs +areindepevents +areindepeventsconjunctelimination +areiso +areisos +arel +arelease +arem aren +arenatisos +arent +arep +areport +areq ares areseparated +aret +arethesame +arev +<<<<<<< Updated upstream +======= arewritingsystem +>>>>>>> Stashed changes arg argaux +argc argchunk argcj +argcontext +argcontexts +argcount argentry argequiv +arges +argexps +argfix +argh argid +argify argimgt argimlt arginfo arginv argkinds +argl arglem +arglist +arglistnt +arglistp +argma +argmasks argmax argmaxequivalence argmaxlemma +argmaxmin +argmaxproperty argmin argminon +argn argnames +argnum +argnval +argp argpartialequiv argpower argpriority @@ -3201,68 +5382,205 @@ argreorders args argself argselfadjoint +argsevlist argsgroup argsig +argsinj +argsnt +argsopt +argsp +argspat +argsv +argsvar +argsym argterm +argts argtype +argtypes +argu arguably argue argues arguing argum +argume +argumen argument arguments +argumentseq +argumenttype +argumentwellformedness +argv +argvals +argvars +argvi +argvj +argvm +argvs +argx ari +arikwrq arise arises +arising aristo +aristotle arisum arit arith +arithclass arithfrobat arithgeom +arithhack +arithi arithidom arithidomlem arithlem +arithlogicimmediate +arithm +arithmatic +arithmet arithmeti arithmetic +arithmetically arithmeticfunction +arithmeticnan +arithmetics arithnormalize +arithoptonum +arithr +arithsexp arithsimplify +arithterm +arithtm +arithtonumlist +arithtrue arithufd arithufdlem +ariti arities arity arityanalysis +arityfive +arityfour +arityone +aritythree +aritytwo +ark arl +<<<<<<< Updated upstream +======= arlene +>>>>>>> Stashed changes +arm +arma +armarch +armb armc +armconsistent +armconsistentextcomp +armconsistentglobextcomp +armed +armexpandimm +arminfo +arminstruction +armp +armpc +armpsr +arms +armstrng +armv +army +armyrepr +arn +arness +arntype aro arof aroots +arose +aroun around arp arr +arra +arralloc +arrang arrange +arranges +arrary array +arrayalloc +arrayallocation +arrayallocthen +arrayassign +arrayclass +arrayclassl +arrayclassloade +arrayclassloaded +arrayclear +arraycompare +<<<<<<< Updated upstream +======= +arraycopy +>>>>>>> Stashed changes arraycpy +arrayelementinitviolation +arrayelementlhsofcall +arrayelementtype +arrayempty arrayequivlist +arrayi +arrayidentity +arrayindexoutofboundsexception +arrayinit +arrayinitempty +arrayinitsizevalid +arrayissafebecauseitisinmemory +arraylen +arraylength arraylookup arraylookuplist arraylookupopt +arraynullcheckregression arrayofvecfinq +arrayp +arraypermut +arrayrange +arrayrangeassignments arrays arraysize +arrayslice +arraysub arraysubsc +arraytests +arraytosequencetests +arraytype arrayupdate +arrc +arrclose arrd arre arri +arrival +arrivaltime arrive +arrived +arrivedacc arrivemsg arrivemsgtt arrives +arriving +arrlen +arrlenloc +arrloc +arrls +arrlsv +arrm arrmap +arrname +arro +arropen arrow arrowaction arrowarrowequivalence @@ -3272,14 +5590,18 @@ arrowcongrequiv arrowcongrleft arrowcongrright arrowcongrsl +arrowcontraariance +arrowcovariance arrowequiv arrowhomequiv arrowi arrowiso arrowisospec +arrowm arrowmap arrowmk arrowmuldistribmulaction +arrowp arrowprodequivprodarrow arrowpunitequivpunit arrowpunitofisempty @@ -3290,18 +5612,50 @@ arrowstalkmapiso arrowstalkmapisoofeq arrowstalkmapspeciso arrowsucc +arrowt +arrowtogentzen +arrowtogentzenext +arrowtogentzenl +arrowtogentzenlp +arrowtogentzennl +arrowtogentzennlp +arrowtonatded +arrowtypes +arrp +arrpostinc +arrpredec +arrray +arrs +arrsel +arrsellhs +arrset arrt +arrupdate arrv arrval +arrvar ars +arsa +arsed arsinh arssecure +art artanh artefacts +arthan +arti +article artifact +artificial artinian artintate +artithm +artur +<<<<<<< Updated upstream +======= artwork +>>>>>>> Stashed changes +arv arwass arwcat arwcatlem @@ -3317,7 +5671,11 @@ arwrcl arwrid arwval ary +arybooledef +arybooleex +arybooleuniq arycl +arydef aryenef aryenefmnd aryf @@ -3328,23 +5686,44 @@ arymaptfo arymaptfv arympt arymptfv +arytm arzela arzelaascoli asa +asaa +asabgroup asalgebrahom +asbackandforth +asbasictypes asbasis +asbits +asbool asboolalg asboolalgasboolring +asboolb +asboole +asboolf +asboolp +asboolpn asboolring asboolringasboolalg +asboolt +asboolw asc ascal -ascalar ascend +ascendi ascending +ascendingchain +ascendingchainandpostcondition +ascendingchainandread +ascendingp +ascends +ascent ascfactorial ascfactorialbinary ascii +asciiprop ascl asclcl asclcntr @@ -3357,8 +5736,10 @@ asclfn asclfval asclghm asclinvg +asclist asclmul asclmulg +asclose asclply asclpropd asclrhm @@ -3367,12 +5748,23 @@ asclval asclzrhval ascofork ascoli +ascollectionuserdefined +ascommalgebra +ascommring ascp ascpochhamme ascpochhammer ascprf ascription ascriptions +ascsr +asd +asdafnybool +asdatatypeops +asdfaf +asdfasdfa +ase +asech asembedding asemptycocone asemptycone @@ -3382,35 +5774,58 @@ asequ asequiv asequivalence aset +asetx asfiber asfiberhom asfork asfun asfunc asfunctor +asfutbf asg asgd asgn asgrouphom ash +ashadow +ashcroft ashom ashomogeneousideal +ashr +ashu asi +asian asid +aside asidea asideal asidealopposite +asids asiegel asif asiff asig +asignature asimp +asimpconst +asimpcorrect +asimple +asimplei +asimplep +asimplinvolutive asin asinbnd asincl asindmre asinf +<<<<<<< Updated upstream +======= asing +>>>>>>> Stashed changes +asingleton +asinh +asinj +asink asinlem asinneg asinrebnd @@ -3418,12 +5833,18 @@ asinrecl asinsin asinsinb asinsinlem +asint asinval asiso asisohomology +asize ask asked asking +askip +asks +asl +asla aslice aslimit aslimitaux @@ -3432,28 +5853,57 @@ aslimitconeaux aslimitconeiso aslimitindexconeiso aslinearorder +aslist aslower +aslsctlr asm +asmallesttopick +asmc asmconcursem +asmi +asmlam +asmnoreadorwrite asmnowrite asmodule asmoduleequiv asms asmselfsim +asmsem asmtx asn asnattrans +asnewtype +asnfnhk +asnth +<<<<<<< Updated upstream +======= asoc +>>>>>>> Stashed changes +asometime asorderhom asound asover asoverhom asoverprop asp +aspace +aspacef +aspaceover +aspaceoverp +asparameterorabstract +<<<<<<< Updated upstream +======= aspatialthing +>>>>>>> Stashed changes +aspcs aspect +aspects +aspi aspid +aspl asplss +aspo +aspoopt aspowers aspowersequiv asprofinitegaloisgroupfunctor @@ -3463,6 +5913,10 @@ aspsubrg aspval asq asr +asrawring +asrc +asrealofmultiplication +asrt ass assa assaascl @@ -3482,48 +5936,127 @@ assapropd assaring assarrginv assasca +assco asscss +asse +assembl assemble +assembleerror +assembler assembling +assembly +assenv +asser assert assertafter assertafterresult +assertallstate +assertandexpect +assertby +assertbyte +assertchar assertd assertdefeqq asserted assertedliteralisnotunit +assertfalse +assertfixed +asserti asserting +assertinlemma assertinstances assertinstancescommute assertion -assertionproperty assertions +assertionsimplyannoinvariants +assertionsimplyinvariantsaux +assertionsimplymethinvariants assertionsr assertleveldefeqq assertliteral assertliteralconflictflageffect assertliteralqeffect +assertname +assertobj +assertonly +assertprop asserts +assertt +assertterm asserttt assertunreachable asses asset assets assg +assga +assgb +assgl +assgn +assgv +assi assig assigma +assigment assign assignable +assignableto +assignabletoname +assignarray +assignbackandforth +assigncall +assigncmp +assigncontext assigne assigned +assignedgroup +assignedp +assignement assigneq +assignfield +assignghost assigni +assignidx assignifdefeq assigning +assignlis +assignlist +assignloceffect +assignm assignment +assignmentcompa +assignmentcompatibl +assignmentcompatible +assignmentd +assignmentp assignments +assignmenttosupertype +assignmonotone +assignmultiarray assignnihighlemma assignnilowlemma +assignnodroptwice +assignnodroptwicenative +assignnt +assigno +assignpairs +assignpat +assignpattern +assignpatterns +assigns +assignstate +assignstmt +assignstmtlist +assignsuchmultiplevar +assignsuchsinglevar +assignsuchthat +assignsuchthatfromghost +assignt +assignte +assigntonat +assignwordop +assignwordshift +assimilation assintop assintopass assintopasslaw @@ -3539,7 +6072,11 @@ assm assmall assmallfunctor assmallissifted +assmbigand +assmctrl +assmctrlp assms +assmsp assmt assn assni @@ -3547,9 +6084,18 @@ assnle assnot asso assoc +assocalgebra +assocalgebradecision +assocation assocaux assocd +assocequiv +assocer +assochspace associ +associa +associable +associaive associat associate associated @@ -3565,7 +6111,10 @@ associatesmulequivisprincipal associatesnonzerodivisorsequiv associatesnonzerodivisorsequivisprincipal associatesnonzerodivisorsmulequivisprincipal +associati associating +association +associativ associative associativemodule associativerepresentation @@ -3573,6 +6122,7 @@ associativi associativity associativityfunctorequivnaturalityfunctoriso associativityiso +associaton associator associatorbimod associatorcorepresentingiso @@ -3588,28 +6138,53 @@ associatornatisoright associatornatisorightcat associators associnv +associso associsometry +assocl +assoclassocl assocleft assoclist +assoclmono +assocmulext +assocn assocofmapsmul +assocp assocquotient +assocr +assocrassocr assocrel assocright +assocrmono +assocrunit +assocs +assocsorted +assocv +assocwire +assort assorted +assos +assosiativity +assox assp assraddsubd assraddsubi +asss +asssoc asst asstring assu assubmodule +assubsettype assubtype assum assume assumed +assumedp +assumee assumeerror assumeinstancescommute assumes +assumin assuming assump assumps @@ -3620,40 +6195,101 @@ assumption assumptioncore assumptions assumptionsi +assums +assuper +assures +asswpow assym ast astab +astabc +astabcin +astabesd +astabidom +astabj +astabm +astabp +astabq +astabqr +astabr +astabrs astabs +astabsc astabsd +astabsesd +astabsi +astabsidom +astabsj +astabsp +astabsq +astabsr astabsu astabu +astack astask +astate +astaticmethod +astatus astbstanbst astdom astep +astest astg asti +astk +astlem +astop +astore +astosubtype +astosupertype +astrait +astring +astrm +asts +astv astype astypeequivobjastype astypefincategory astypetoobjastype +asub +asubb +<<<<<<< Updated upstream +======= asubq asubsetof +>>>>>>> Stashed changes asubst +asubunsafe +asubv asum asup asupper +<<<<<<< Updated upstream +======= asupremumofin +>>>>>>> Stashed changes +asv aswidequiver +asx asy +asyc asym +asymetric +asymetrical +asymkernel asymm asymmetric +asymmetricisantisymmetric +asymmetricisirreflexive +<<<<<<< Updated upstream +======= asymmetricproperty +>>>>>>> Stashed changes asymmetry asymp asympartp asympbound +asympt asympto asymptot asymptotic @@ -3663,10 +6299,14 @@ asymptotics asymref async asyncmode +asz +aszf +aszt atab atable atabs atabsi +atake atan atanbnd atanbndlem @@ -3678,10 +6318,13 @@ atandmcj atandmneg atandmtan atanf +atanh +atank atanlogadd atanlogaddlem atanlogsub atanlogsublem +atann atanneg atanord atanre @@ -3693,17 +6336,24 @@ atantan atantanb atantayl atanval +atapp atatop atb atbase atbiffatnnb atbiffatnnbalt +atbl +atblocksize +atblp +atbls atbot +atbp atbtwn atbtwnex atbtwnexoldn atc atcmp +atcomplex atcs atcv atcvat @@ -3719,8 +6369,15 @@ atd atdmd ate atelch +atemp +atemps atend +atendofstream +atention +ateo ateq +aterm +aternative atex atexch atexchcvrn @@ -3752,14 +6409,28 @@ atexlemutvt atexlemv atexlemw atexlemwb +atexpv +atext +atexternal +atextsrc +atexttgt +atfun athgt +athis +athm ati +atimes atiminfty +atin +atindex +atinfinity atjlej atjm +atk atkey atl atlas +atlasstr atlat atlatle atlatmstc @@ -3768,12 +6439,20 @@ atleast atleastatmost atleastatmosti atleastlessthan +atleastlessthane +atleastonce +atleastonecolor +<<<<<<< Updated upstream +======= atleastp +>>>>>>> Stashed changes atleasttwo +atleft atlelt atlem atlen atlenen +atlevel atlex atllat atlle @@ -3789,14 +6468,17 @@ atmat atmd atmod atmost +atmostonecolor atmostonefixedpointequivsum atmostq atms atmss +atmv atn atnaiana atncmp atncvrn +atnd atne atneat atnelpln @@ -3807,48 +6489,106 @@ atnle atnlej atnlt atnssm +ato +atoc +atoh atoi +atok atom +atomcom +atomd +atomdi +atomdu atomg +atomguts atomi atomic +atomicasgn +atomicbasicasgn +atomiceval atomicf atomicfact +atomicfamily +atomicformulas +atomicformulasof +atomicformulasymbolsof +atomicfunc +<<<<<<< Updated upstream +atomicincrement +atomicisize +atomicity +atomickai +======= +atomicisize +atomicity +atomickai atomicnucleus +>>>>>>> Stashed changes +atomicp +atomicprimitives atomics atomicsr +atomicstmt +atomicstmtlist +atomicstmts +atomicsubst +atomictermsof +atomify atomise atomistic atomize atoml atomless atomli +atomlist atomm +atomp +atompicp +atomrect atoms +atomsd +atomset +atomsetimpl atomsimple atomsinsequenti atomsmsg atomsofsubmodulelattice +atomsp atomspropagate +atomtoo atomuni +atomwidth atone atord atordi atp atpointn +atpointof +atposition atprecision atprim atprime atpsubcln atpsubn +atrace atrans +atransp +atranspin +atransr +atreal +atree +atreechildren +atributes +atright ats atss atssbase atssch atsseq atssma +atstlw att +attac attach attachboun attachbound @@ -3856,52 +6596,108 @@ attachcel attachcells attachcellsofsuccstructprop attached +attaches attachfin attaching +attachment +attachments attachwith attack attacker +attacking +attacks +attain +attainability +attainable attained attains attarget attempt +attemptatbinding +attemptdecryptdatakey +attempted attempting +attemptkmsoperation attempts +attemptsstat +attemptsstate +attenti +attention +attestationdocumenttype +attlst atto attop attopbot attr attracted +attractive attractor attracts attractsi attrargs +attrb +attrbutes attree +attri attrib +attribs +attribu +attribus attribut attribute +attributed +attributeder +attributederivation attributee attributekind +attributename +attributenamelist +<<<<<<< Updated upstream +======= attributeof +>>>>>>> Stashed changes +attributeonquantifier +attributep attributes +attributesbits +attributesp +attributetarget +attributevalue +attribution attrinstance attrkind attrm attrname attrs atts +attup atunit atunits atv +atval +atvar atw +aty atype +atys +<<<<<<< Updated upstream +======= +aua +aub +>>>>>>> Stashed changes +aubrey audioplayer +audit audited +aueaheh aufil aug +augassign +augchaincomplex augflow augmen augment +augmentation augmented augmentedcechconerve augmentedcechnerve @@ -3910,21 +6706,58 @@ augmenting augmentingflow augmentofisinitial augmentofisterminal +augments augmenttruncate +augmentum +august +auid +auidl +auimmersion +auip +auipc +auk +aul aun +aundef +aunit +aunitary +auniversalarrow +auniversalarrowequiv +<<<<<<< Updated upstream +aupdate +aupdateunsafe +======= +aunt auntagatha +aupdate +aupdateunsafe aupperboundofin +>>>>>>> Stashed changes +auqtzyz +aur +ausa ausgrumgri +ausgrumgrien ausgrusgrb +ausgrusgrben ausgrusgri +ausgrusgrien austin aut +autaa autact +autactk autadjoinrootxpowsubc autadjoinrootxpowsubcequiv autadjoinrootxpowsubchom +autalg +autb +autcomp autcongr +autd +aute autembedding +auteqmt autequivautwhiskerright autequivpow autequivrootsofunity @@ -3934,46 +6767,107 @@ autgaloissystem autgroup auth authd +authenticated authentication +authenticity authi author authorisation authority +authorized authors authorslinechecks authorslines autht +authtag autisofibers +autk +autm autmap autmaphom +autme +autmn +autmt autmulequivautgalois autmulequivoffullyfaithful autmulequivofiso +autmz +autn auto +autoaccumulator +autoaccumulatortests +autoadmit +autococalls +autodesc +autoembeddings +autoforall +autoforward autogenerate autogenerated +autohide +autohiding +autohyps +autoind +autoinduct +autoinit +autoinitf +autoins +<<<<<<< Updated upstream +autolte +======= +>>>>>>> Stashed changes +automap automata automate automatea automated +automates automatic automatically +automaticinduction automation +automatize automaton +automo +automorp +automorphic automorphism +automorphismd automorphismgroup +automorphismi automorphisms automorphize +autonomic +autonomy autoparam autoparams +autoprove +autoproved +autored +autoreduced autoref +autorefl autorewrite +autoscalingpolicyname +autoscalingrolearn +<<<<<<< Updated upstream +autoshow +======= +>>>>>>> Stashed changes +autostates +autostream autring auttopow +autx +auv aux +auxbottom auxbound +auxc +auxcart auxcontinuouslinearequiv auxcp +auxd auxdecl auxdeclmap auxdeclngen @@ -3981,6 +6875,7 @@ auxdecltofullname auxdft auxe auxequiv +auxf auxfunname auxfunnames auxgluing @@ -3988,30 +6883,61 @@ auxgluingstruct auxgroup auxhom auxi +auxili auxiliaire +auxiliar auxiliary auxiliarydefs +auxilliary auxinv auxisometry auxl auxlemmas +auxlillary +auxlist auxm auxmat +auxn +auxnone +auxp +auxq auxr +auxs +auxsome +auxsub +auxtheorem auxtomatrix +auxx +auxxx +auy +auz +avail availability available +availablemovep aval avaldirekt +avalplus +avalue +avalues avar avars +avclosed +avds ave aveal +avec +<<<<<<< Updated upstream +======= avector +>>>>>>> Stashed changes average averagemap averages +averse +averyveryveryveryveryverylongname avg +avgable avgle avglt avglts @@ -4020,6 +6946,7 @@ avj avk avl avoid +avoidance avoided avoidi avoiding @@ -4028,9 +6955,9 @@ avril avst avstore avumguoblzdvezzwjxlqs +avx await awaitrule -awake awalk awalki aware @@ -4039,17 +6966,34 @@ awayequivadjoin awaylift awaymap awaymapaux +aways awayto awaytoawayleft awaytoawayright awaytosection +awesome +awf +awful awhd +awhile awidth awkward awkwardness awlast +awlp awn aws +awsarnparsing +awscryptographymaterialproviderstypes +awscryptographyprimitivestypes +awsencryptionsdkconfig +awskmsidentifier +awskmskey +awskmsmrkareunique +awskmsmrkareuniquecorrect +awskmsmrkmatchfordecrypt +awskmsmrkmatchfordecryptcorrect +awskmsresource awtn axac axaci @@ -4058,15 +7002,24 @@ axacndlem axacprim axaddass axaddcl +axaddcom axaddf axaddrcl axadj axalt +axapti +axarch axb axbnd axbtwnid axbun axc +axcaucvg +axcaucvglemcau +axcaucvglemcl +axcaucvglemf +axcaucvglemres +axcaucvglemval axcc axccd axccdom @@ -4076,6 +7029,7 @@ axcgrrflx axcgrtr axcnex axcnre +axcnvprim axcont axcontlem axd @@ -4084,8 +7038,13 @@ axdclem axdd axdimuniq axdistr +axe +axempty +axemptylem +axes axeuclid axeuclidlem +axext axextb axextbdist axextdfeq @@ -4096,8 +7055,13 @@ axextmo axextnd axextndbi axextprim +axexts +axf +axfix axfrege +axgen axgroth +axh axhcompl axhfi axhfvadd @@ -4115,6 +7079,7 @@ axhvmulid axi axia axial +axialsymmetry axicn axie axin @@ -4122,23 +7087,44 @@ axinf axinfnd axinfndlem axinfprim +axins axio axiom +axiomas +axiomatic +axiomaticprooftheory +axiomatisation axiomatization +axiomatize +axiomatized axiomdecl axiomh +axiomi axiominfo +axiomk axiomofchoice axioms +axiomschema axiomsd +axiomsequivstr +axiomss +axiomsstructure +axiomsunivalentstr +axiomz axis axler axlowdim axlowdimlem axltadd +axltirr +axltl axlttri axlttrn +axltwlin axm +axmbx +axmcx +axmeredith axmp axmulass axmulcl @@ -4150,8 +7136,10 @@ axnkfaujdug axnul axnulalt axnulg +axoa axorbciffatcxorb axorbtnotaiffb +axp axpasch axpaschlem axpjcl @@ -4163,6 +7151,8 @@ axpowprim axpr axpralt axpre +axprecex +axprimlem axprlem axprold axpweq @@ -4187,8 +7177,12 @@ axsegconlem axsep axsepg axsepgfromrep +axsiprim axsn +axsof +axssetprim axsup +axsuploc axt axtd axtg @@ -4201,13 +7195,27 @@ axtglowdim axtgpasch axtgsegcon axtgupdim +axtyplowerprim +axu axum axun axunnd axunndlem axunprim +axx +axxpprim +axy ayae +aymby +ayqjtmd +ayuda +azc +azero +azim +azimeq +azims azmult +azuma azwkkvlgz baa baaabf @@ -4224,73 +7232,199 @@ babbfec babe babf babs -babu baby +babydragon babygodel babylob bac baca +bacb bacc bacca baccb baccdfebe +baccv bacd bace baceabd bacf +bach bachelor +bachmann back +backc +backch +backcha +backchai backchain +backchaining +backchains +backcontinued backdeps +backdoor backed +backedge backend +backendprops backface +backflows background backgroundgoals backing backitup backlinks +backlog +backmatches +backmatchesmatches +backn +<<<<<<< Updated upstream +backprop +======= +>>>>>>> Stashed changes +backptr +backptrs +backptrsi +backptrsp +backquote +backref +backrefp +backrefs +backslash +backtick +backtrace backtrack +backtrackfuel +backtrackfuelsizemonotonic +backtrackfuelsizemonotonicopt backtracking +backtracksizemonotonic +backtracksizemonotonicopt backup +backuparn +backupname +backupsinputlimit +backupsizebytes backw backwa backward backwards +backwardslice +bacp +bactive +bactrack bad bada +badabs badacc +badaddressviolation +badanonlambdadiv +badarrayread badb +badbit +badbitvectors badc +badcachemsg +badcast +badcasts badcf +badcfew badchar +badcharacters badchars +badclient +badcode +badcompiled badcomps +badd badda +baddiv +baddiverrormsg bade badeb baded +badend badf badfcebc badfd +badfib +badfieldaccesses +badfilename +badfunctionrhs +badge +badged +badgep badguy +badguys +badids +badinstance badkeys +badlemma +badlits +badloop badly +badlyformedspec badm badmatch +badmetabox +badmethod +badmethodrhs +badminusother +badminussets +badmode +badmonotonic +badname +badnamedlambdadiv badnames badnamesnum badness +badnewtypeliterals badntscount +badntscountnot badntscountset +badparens +badparse +badpl +badplace +badplus +badplusother +badplussets +badprepend +badrangeexists +badrangeforall +badrangereads badreduction +badref +badreg +badrpt +bads +badspec +badstart +badstate +badstringlength +badsuchthatghost +badsum +badtargetslabels +badtargetslevels +badtheorem +badtimes badtmscount +badtmscountnot badtmscountset +badtolower +badtypes +baduence +badup +badupm +baduseofghost +badvariations +badverbatim badvertices +badvoidoutcome bae baea baead baebf +baebff baec baed baef @@ -4303,13 +7437,25 @@ bafaff bafbe bafcdbb bafde +bafdw bafe baff bafval bag +bagdiff +bagint baginteger baginter +bagof +bagofsub +bagorder +bagp +bags +bah +<<<<<<< Updated upstream +======= bahn +>>>>>>> Stashed changes baib baibd baibr @@ -4319,16 +7465,28 @@ bairemeasurables bairemeasurableset bairespace bairetheorem +baisc +bak +bake bakery bal +balalaika balance balanced balancedcore balancedcoreaux balancedhull +balancedl +balancedmonoidal +balancedr balancedsz balancel +balancelb +balancelr balancer +balancerb +balancerr +balancing baldl baldr balil @@ -4338,6 +7496,13 @@ balladdsubgroup balle balli ballinclusion +balln +ballnorm +<<<<<<< Updated upstream +======= +balloonist +>>>>>>> Stashed changes +ballot ballotlem ballotleme ballotlemelo @@ -4378,48 +7543,92 @@ ballotlemsima ballotlemsup ballotlemsv ballotlemsval +ballots ballotth +ballp ballpackage ballpe ballpi balls +ballsets ballss ballsubgroup +ballt +ballxx +balr balt baltn +bam bamalip ban +bana banach +banachfixedpointtheorem +<<<<<<< Updated upstream +======= banana bananas bananaslug +>>>>>>> Stashed changes banasiak band bands +bandwidth bang +banged bangrel bangrelsubweakbisim +banjo bank +<<<<<<< Updated upstream +======= +banks +>>>>>>> Stashed changes +banning bapp bappend baqrn bar +bara +barab +barb +barbar barbara barbari barbarialt barbarilem barbed +barcaller barcomplex +bardziej bare +baredilmem +baremach +baremachine +baremachinesig +barendregt +barestep +barext baroco barocoalt +barp +barpayloadlen +barpoint +barred barrel barrelled barrelledspace +barrera barresolution +barrett +barrettparameters barrier barry +bars +barsym +bart bartle +barv bary barycenter barycentre @@ -4429,31 +7638,60 @@ bascl bascnvimaeqv basdif base +baseaddr +baseaspace +baseassign +baseb basecase basechange basechangeaux basechangehom baseclasses +basecycle based basedcategory +basedequiv +basederivesop basedfunctor +basedhomotopy +basedhtpy +basedim basednatiso basednattrans +basedness basedomain +basedpaths basee baseembedding +baseempop +baseentry basefield +basefieldsinv +basefieldsinvmonotonicity basefunctions +baseh basei baseid +baseima baseinfo +baseinv baseio baseiso +basek +baseklef basel +baselatch baselcarsg +baselegaltransitionssequence +baselists basellem baselsiga +basem +basemap +basemax +basemixin basename +basenames basendx basendxltdsndx basendxltedgfndx @@ -4467,24 +7705,69 @@ basendxnn basendxnocndx basendxnplusgndx baseof +basep +baseparams +baseparamspartialmap +baseparamstotalmap basepoint basepoints +baserefl bases +basesandcontinuity baseset +baseslid +basestarop basestr basestruct +basesuc +basesucg +baset +basetrans +basetransrefl +basetype basetypes +baseunits +baseuserfieldsinv +baseuserfieldsinvmonotonicity +baseuserinv baseval +basevspace +basewa +basewandop +basex basf basfn basfvi basgen +basgeng bash basi basic +basica +basicaesdecrypttest +basicaesencrypttest basically +basicanno +basicassign +basicc +basiccases +basicclassificationtests +basiccond basicconstructiblesetdata +basicdecrypttest basicdefs +basicderivesharedsecrettests +basicdf +basicdigesttest +basicencrypttest +basicexpandtest +basicextracttest +basicgeneratetest +basicgeneratewithoutplaintexttest +basichkdftest +basichmactest +basici +basicially basiclemmas basicopen basicopencover @@ -4493,20 +7776,29 @@ basicopenisospec basicopenisospecaway basicopensectionstoaffine basicopentospec +basicops basicproperties basicpropertiesinanytopologicalspace +basicrmw +basicrsadecrypttests +basicrsaencrypttest basicrule basics basicsecuritytheorem basicsequentcalculus +basictests basis basisat basisaux basiscoeff basiscotangent basiscotangentaway +basisd basisderiv basisdivisor +basisedim +basisefree +basises basisextension basisfreemonoid basisfun @@ -4551,6 +7843,9 @@ basisunique basisunitlattice basisvec baslem +basm +basmex +basmexd basndxelwund basold baspartn @@ -4561,20 +7856,45 @@ basresposfo basresprsfo basrestermcfo basrestermcfolem +bassetsnn +bassign +bassmodel bassn basss +basta bastg bastop basvtxval +basy +bat batch +batcher +batchgetitemensurespublicly +batchgetrequestmap +batchwriteitemensurespublicly +batchwriteitemrequestmap batteries +<<<<<<< Updated upstream +battery +======= +>>>>>>> Stashed changes +battle bauer +baut +bautomaton +baw +bax baxter +bay baydemir bayes bayesrisk bayesriskleminimaxrisk bayesth +baz +bazp +bazpayloadlen +bazz bazzi bba bbaa @@ -4586,6 +7906,8 @@ bbaf bbafab bbafb bbafbbca +bbar +bbase bbasis bbb bbba @@ -4601,12 +7923,14 @@ bbbdade bbbdb bbbdfa bbbeb +bbbozo bbbp bbc bbca bbcb bbcbcc bbcdf +bbcdff bbcefdbf bbcf bbd @@ -4628,6 +7952,7 @@ bbee bbeec bbefbd bbefdf +bbeq bbf bbfa bbfab @@ -4637,13 +7962,32 @@ bbfce bbfd bbfe bbff +bbfw +bbg bbi bbid +bbiddc bbii +bbiidc +bbind +bbindex +bbinop +bbits +bbk +bblock bblue +bbox +bbozo +bbprime bbr +bbreak +bbs bbuv +bbv bbw +bbx +bby +bbzo bca bcaa bcab @@ -4652,9 +7996,15 @@ bcad bcadce bcaee bcaf +bcall +<<<<<<< Updated upstream +======= bcapacityex bcapacityne bcapacitysn +>>>>>>> Stashed changes +bcard +bcarry bcb bcba bcbb @@ -4689,9 +8039,12 @@ bcdab bcdae bcdaf bcdb +bcdbdc bcdc bcdcf +bcde bcdee +bcdef bcdfbc bcdfd bce @@ -4707,6 +8060,7 @@ bceeaa bceeb bceef bces +bcevp bcf bcfallfac bcfb @@ -4719,29 +8073,49 @@ bcfd bcfee bcff bcffbb +bcg bcgdwwqyafa +bcglob bcgq bch +bcheck bchoice bci +bcialg +bciideal +bcinvalid +bcistr +bck +bcl bclbnd bcle bcled +bclos bclose +bclosed bcm bcmax bcmono bcn bcneg +bcnf bcnm bcnn bcnp bcomp +bcompare +bcond +bconj +bconstraint +bcontent bcontfun bcontfunn +bconv bcor bcot +bcother bcount +bcover bcp bcpasc bcpascm @@ -4751,15 +8125,22 @@ bcs bcseqi bcsialt bcsihil +bcstack bct bcth bcthlem +bctr +bctra +bcv bcval +bcw bcxmas bcxmaslem bda bdaacf +bdab bdaba +bdac bdae bdaf bday @@ -4793,64 +8174,180 @@ bdbe bdbf bdbfc bdbfeaf +bdbi +bdbl +bdbm bdc +bdcab bdcac bdcb bdcc bdccbd bdcce +bdccsb bdcd +bdcdeq +bdcdif bdce bdceec +bdceeew +bdcel +bdceq +bdceqi +bdceqir bdcf +bdcfbb +bdciin +bdcin +bdcint +bdciun +bdcnul +bdcnulalt +bdcpr +bdcpw +bdcrab +bdcriota +bdcsn +bdcsuc +bdctp +bdcun +bdcuni +bdcv +bdcvv bdd bdda bddaa bddabov bddabove bddac +bddalloc +bddallocget +bddand bddb bddba bddbelow +bddbounded bddbyspectralvalue bddc bddcf +bddcompare +bddconfig bddd bdddaf bdddefault bdddistlat +bdddummy +bddex +bddexl +bddf +bddfree bddh +bddhigh +bddi bddibl bddiblnc +bddiff +bddify +bddimpl +bddinsert +bdditer bddlat +bddlow +bddlt +bddmake +bddmu bddmulibl +bddneg +bddnegm bddnghm +bddof +bddone +bddor bddord +bddordp +bddorm +bddp +bddreplace +bddreplacel bddrp +bdds +bddshare +bddsharing +bddstate +bddsubst +bddum +bddunique +bdduniv +bddunivl +bddvar +bddzero bde bdea bdeaa bdeac bdeb bdec +bdecfa bdecs bdeda bdef +bdel +bdeli +bdelir +bdelta +bdenot +bdeq +bdeqsuc bdequal bderham bderhamplus bdf bdfa +bdfal bdfc bdfcb bdfcd bdfd bdfdef +bdfdff bdfe bdfee bdffb bdffe +bdfind +bdfindes +bdfindis +bdfindisg +bdfs +bdg +bdi +bdia +bdiaibdiai +bdiaibdiaj +bdiaidomi +bdiaidomj +bdiaifdiaj +bdiajbdiai +bdiajbdiaj +bdiajfdiai +bdif +bdind +bdinex +bdisj bdistortion +bdiv +bdivdec +bdivides +bdl +bdmet +bdmetval +bdmopn +bdne +bdnel +bdnth +bdnthalt +bdo +bdominates bdop bdopadj bdopcoi @@ -4861,22 +8358,64 @@ bdophsi bdopln bdopssadj bdoubleton +bdpeano +bdph +bdr +bdrabexg +bdreu +bdrmo +bdry +bds +bdsbc +bdsbcalt +bdsep +bdsepnf +bdsepnfalt +bdsepnft +bdsetindis +bdsnss +bdss +bdssex +bdssexd +bdssexg +bdssexi +bdst +bdstab +bdsucel bdt +bdth +bdtri +bdtrilem +bdtru +bdunexb +bdvsn +bdw +bdxkhtw +bdxmet +bdxor bdy +bdzfauscl bea beaa beaae beab beac +beacon +beaconkeyencryptioncontext +beaconkeyitem bead beada beadc beae beaf +beamtime +beat +beata +beating +beatles beats beatty beattyseq -beaujolais beautiful beb bebase @@ -4888,11 +8427,16 @@ bebd bebdbec bebf bec +beca +became +becau +becaus because becb becbbf becbf becc +beccc beccddc becd becda @@ -4913,8 +8457,12 @@ beckfork beckmonadicity becksplitcoequalizer becksplitequalizer +beco +becom become becomes +becomess +becuase bed beda bedb @@ -4929,6 +8477,8 @@ bedef bedf bedfb bedfbb +bedrock +bedrocktrace bee beea beeaae @@ -4938,82 +8488,139 @@ beec beee been beer +beeson beetween bef befa befad +befaf befb befc befde befefcea beffed befffa +befffaw +befo +befor before +befored +beforenm +beforerounding beftqxwlsz beg +bega +begb +begi begin +begink beginning begins +begint +begout +begr +begreg +begrpiv beh +beha +beharad +behav behave behaved behaves +behavi +behaving behavior +behaviors behaviour +behaviourally behaviours behead behind +behold behrend +behv +bei +bein being +beira bel +belast belief believe -believes bell +bella bellman +bellow bells belo -beloitcollege belong belonging belongs below +belowd belowi +belowisantisymmetric +belowisreflexive +belowisstronglyconnected +belowistotal +belowistransitive belown belownext +belse bempty ben +benc benchmark +benchmarking +benchmarks +bendian +bendixon bendixson +beneath benefit +benf benign bennett +bentley benv +benzene beppo beq +beqa +beqb beqeq beqinst beqrat bequiv ber +berak bergelson berlekamp +<<<<<<< Updated upstream +======= berlin +>>>>>>> Stashed changes +bern bernays -bernehmen bernneq bernoulli bernoullifouriercoeff bernoullifun bernoullipowerseries +bernoulliv bernpoly +bernpolys bernstein bernsteinapproximation bernsteinpolynomial +berr berstein bertrand bertrands +bes besicovitch +besides bespoke bessel besselsinequality @@ -5022,45 +8629,133 @@ bestfirstnode bestfirstqueue bestfirstsearch bestfirstsearchcore +bestlemmaever bestresult bet beta +betaa +betaconv +betaconversion +betacr betad +betaeta +betaformula betaintegral betaintegralreal +betal +betaloops betameasure +betamode betapar betapd betapdf betapdfreal +betareduction +betareductioninside +betarepresentable betarev betas betasd +betastar +betastarl +betatheorem betathroughlet betathroughletaux +betav +betcood +bete +betep +betg beth +betm +betr betree +bets betseq +betsp +bett +bette better +bettercopydynamiccheck +bettermovedynamiccheck +bettersized +bettersizedindeedbetter betw betwd +betwe +betwee between +betweenangleb +betweenanglebc +betweenanglec +betweenassocleft +betweenassocright +betweenclockwiseamc +betweenclockwisembc +betweencollinear +betweendistinctab +betweendistinctbc +betweendistinctca +betweene +betweenf +betweenhalfline +betweenhalflinebetween +betweenlslt betweenness +betweennesspreserved +betweennotbetween +betweennotclockwiseabc +betweennotclockwisebac +betweennotequal +betweensym +betweensymhalfline +betweentransa +betweentransc +betweentriangle +betweenuuooww +betweenwwoouu betwi +betwn beukers beval bevalr +bevaluates +<<<<<<< Updated upstream +======= beverage +>>>>>>> Stashed changes +bevery +bew bex +bexact bexi bexp +bexpand bexpands bexpe bexpi bexpr +bexpri beyond bezout +bezoutl bezoutlem +bezoutlema +bezoutlemaz +bezoutlemb +bezoutlembi +bezoutlembz +bezoutlemeu +bezoutlemex +bezoutlemle +bezoutlemmain +bezoutlemmo +bezoutlemnewy +bezoutlemstep +bezoutlemsup +bezoutlemzz +bezoutness +bezoutp bezoutr bezouts bezoutz @@ -5085,7 +8780,6 @@ bfbc bfbcf bfbd bfbdae -bfbdcf bfbec bfbf bfc @@ -5096,18 +8790,22 @@ bfcd bfceb bfcf bfcfa +bfcw bfd bfda bfdb bfdba bfdbd +bfdc bfdcb bfdcbe bfdcd bfdd bfde bfdf +bfdotadd bfe +bfead bfeaddfbd bfec bfed @@ -5121,33 +8819,87 @@ bffa bffab bffac bffae +bffaf bffcbbf bffdebcb bffe bfff bfffb +bfg +bfi +bfilter +bfinal bfix bfizxjkxysijhotj +bfl +bfloat +bfma +bfml +bfmlls +bfmllsv +bfmlv +bfmul +bfn +bfnrt +bfold +bfoot bforall +bformula bfp bfplem +bfpm +bfr +bfrcount +bfrcounts +bfrexp +bfrify +bfringe +bfringes +bfrl +bfrli +bfrlis +bfrlist +bfrmc +bfrmod +bfrmode +bfrs +bfrstate bfs +bft bfu bfun +bfund +bfuni +bfw +bfx +bgamma bgbi bge bgen +bget +bgeu +bgezal bgfunc +bgi +bgmifte bgoldbachlt bgoldbnnsum bgoldbtbnd bgoldbtbndlem +bgraph +bgt bgu +bhat +bhc bheight bhenstock +bhi +bhit bhle bhmafibid +bhsp bhv +bia biadan biadani biadanialt @@ -5161,6 +8913,7 @@ bialgequivclass bialgequivofiso bialghom bialghomclass +bialystok bian bianabs bianass @@ -5178,8 +8931,11 @@ biantru biantrud biantrur biantrurd +biao bias +biased biass +biassdc bib bibd bibdi @@ -5189,6 +8945,8 @@ bibi bibiad bibibi bibif +bibtex +bic bicartesiansq bicartsq bicategorical @@ -5200,7 +8958,10 @@ bicategorycoherence bicategorylike bicategorym bicategorynf +bicatmonad bicc +biccc +bicofinal bicoloring bicom bicomd @@ -5218,14 +8979,27 @@ biconeisbilimitoflimitconeofislimit biconemk biconemorphism bicones +bicong +biconjugation +biconnected +bicont bicontr bid +bidc +biddc +bidifferentiable +bidirect +bidirected bidirectional bidirectionalrec bidirectionalrecon bidmaximizedby bidualisometry bidx +biefjhu +bientails +bieq +biet biexal biexex bif @@ -5239,6 +9013,10 @@ bifibrantresolution bifibrantresolutionmap bifibrantresolutionobj biflows +biforcenum +bifun +bifuncex +bifunction bifunctor bifunctorcomp bifunctoriality @@ -5247,38 +9025,167 @@ bifunctors big biga bigand +bigandimp +bigandl +bigappend +bigbeta +bigbv +<<<<<<< Updated upstream +======= bigc +>>>>>>> Stashed changes +bigcap +bigcapi +bigcapid +bigcapil +bigcapir +bigcapj +bigcapl +bigcapmx +bigcapmxp +bigcapp +bigcapr +bigcapsp +bigcapt +bigcaptp +bigcapv +bigcat +<<<<<<< Updated upstream +======= bigcity +>>>>>>> Stashed changes +bigcond +bigconj +bigconst +bigcprod +bigcprodey +bigcprodw +bigcprodwy +bigcprodyp +bigcross bigcup +bigcupc +bigcupdr +bigcupid +bigcupj +bigcupl +bigcupp +bigcupr +bigcupsp +bigcupt +bigcupu +bigcupul +bigcupur +bigcupx bigd +bigdisj +bigdprod +bigdprodi +bigdprodw +bigdprodwcp +bigdprodwy +bigdprodyp +bige +bigend +bigendian +bigendianmem +bigendianreverse +bigfcup +bigfcupp +bigfcupsp +bigfs +bigg +biggcd +biggcdn +biggcdp bigger biggerset +biggertest +biggest bigi +bigid +biginf biginter +biginv +bigl +biglcm +biglcmn +biglcmp +biglist +bigmagma +bigmax +bigmaxe +bigmaxr +bigmaxre +bigmaxrp +bigmem +bigmid +bigmin +bigmul +bigneg bignorabimus bignum +bignumhalt +bignumq +bignums bignumtr bigo +bigoe bigolden +bigomega +bigomegap +bigop bigopbinder bigopbinders bigopbinderspattern bigopbindersprod +bigope bigoperators bigor +bigordinal +bigordinals bigoval bigprod +bigprodge +bigprodgegen +bigprodi +bigr +bigrange +bigrank +bigrmax +bigs +bigseti +bigsetu +bigsetui +bigsize +bigstar bigstep +bigstepsemantics bigstept +bigsup +bigtest bigtheta +bigthetae +bigthetap +bigtree +bigtrees +bigu +bigum bigunion +biguniono +bigwedge +bigx biheytingalgebra biheytinghom biheytinghomclass bihimp +biholomorphism bii biid +biidc biidd +biijust +biimdc biimp biimpa biimpac @@ -5288,6 +9195,7 @@ biimpcd biimpd biimpexp biimpi +biimplication biimpor biimpr biimprcd @@ -5298,35 +9206,67 @@ biimtrdi biimtrid biimtrrdi biimtrrid +biinduction biinf +biinjective biinter +biinv +biinvaction +biinvequiv bij bija +bijab +bijadc +bijcodom +bijdom bije biject bijecti bijection bijectioninverse +bijectioniso +bijectionisotogroupequiv bijections bijective +bijectively bijectiveresiduefield bijectivity bijectivitycriteria bijects bijgroup bijinv +bijlr +bijns bijon +bijp +bijpex +bijpinv +bijrl +bijrop +bijs +bijstate +bijtt bijust bikey bil +bilandscdl +bilateral +bile +bilexistssc +bilexistsscl +bilexistsscr +bilforallscr +bilfunc bilimit bilin +bilinea bilinear bilinearcombination bilinearcomp bilinearcompoflinear bilineariteratedfderivtwo bilineariteratedfderivwithintwo +bilinearity bilinearlinederivtwo bilinearmap bilinearmaps @@ -5335,24 +9275,55 @@ bilinform bilinleftclm bilinmap bilipschitz +<<<<<<< Updated upstream +======= bill +>>>>>>> Stashed changes +billedsizebytes billing +billion bills +bilogic +bilogicfunc +bilogicops +biloperators +bilops +bilorscdl +bilpre +bilprelogic biluk +bilukdc bimap +bimapcat +bimapid +bimapproper +bimapstr +bimg bimod +bimodhelper +bimodstr bimodule +bimodulehomomorphism bimodules bimon bimonobj bimonobjaux +bimp bimsc bin bina +binadd +binade +binar +binari +binaries +binarify binarith binarithtype binarize binarizent +binarizentrtc +binart binary binarybicone binarybiconeisbilimitofcolimitcoconeofiscolimit @@ -5380,6 +9351,9 @@ binarycoproductequiv binarycoproductiso binarycoproducts binarycoproductsdisjoint +binarydup +binaryembedding +binaryexps binaryfan binaryfanisbinaryproduct binaryfanofprop @@ -5389,7 +9363,14 @@ binaryfanzeroleft binaryfanzeroleftislimit binaryfanzeroright binaryfanzerorightislimit +binaryh +binaryid +binaryidempotent +binaryintersectionismeasurable +binaryof binaryop +binaryopiso +binaryp binaryproduct binaryproductcone binaryproductequiv @@ -5403,50 +9384,114 @@ binaryproducttriangle binaryproducttriangleisobinarybiproducttriangle binaryrec binaryrecfromone +binaryrelation +binarysearch binarysearchcorrect +binarysearchimpl +binarysearchint +binarysequence +binarysinglenan binarysum +binaryunary +binaryunionismeasurable binaturality binb bincast +bincomp +bincontinuous +bincoprod +bincrement bind +<<<<<<< Updated upstream +======= bindag +>>>>>>> Stashed changes +bindc binddef +binddelta +binde +binded +bindedprooftheory +bindequiv binder binderident binderinfo binderinfoformvars binderinfos +binderlanguage bindername bindernamehint binderpred binderpredicates binders bindet +bindex bindgen +bindgenopt +bindi +bindin binding bindingbody +bindingd bindingdomain +bindingguardtestexpr +bindingguardteststmt +bindinglis +bindinglist bindingname +bindingp bindings +bindingslist +bindingsp +bindisassociative bindk +bindl bindlater +bindmonotonic +bindmonotonicopt +bindmonotonicoptstrong +bindmonotonicstrong +bindmorphism bindnow +bindnt bindofarrows bindonsupport +bindoptmonotonic +bindoptmonotonicopt +bindoverappend +bindp +bindparams +bindpi binds +bindsp bindstacval +bindstartscope bindstruct bindt +bindtcdeflambda +bindtcdeflambdauniq +bindtconstrind +bindtconstrinddef +bindtconstrstrex +bindtconstruniqdef bindtobase bindu +bindunsized bindv +bine binen binentropy binet +binexpression binf binfo binfty +bingo +binind binint +binintdef +<<<<<<< Updated upstream +======= binintersect binintersectel binintersecter @@ -5458,8 +9503,15 @@ binintersectt binintersecttelcontra binintersecttercontra bininttransitive +>>>>>>> Stashed changes binit +binj bink +binn +binnart +binnat +binnums +bino binom binomcxp binomcxplemcvg @@ -5483,44 +9535,55 @@ binomialinversetheorem binomialish binomialrandom binomialring +binomials binomialseries binomialterm +binomialtheorem binomlem binomrisefac binomsc binop +binopc +binopdefuniq binopelim +binopexp +binopexpr +binopinstr +binopredsthrow +binopredsval +binops +binopsetgroup binp +binpack binpos +binprod +binproddaggerstr binqueue +binr binrel -binrep bins +binsequence binsert +binsn +binstructure binsup binsyncv bint binter +bintounary bintr bintree bintrunc -binunion -binunione -binunionecases -binunionil -binunionir -binunionlsub -binunionrsub -binuniont -binunionte -binuniontecontra -binuniontilcontra -binuniontircontra binuniv binv +binvert +binz +<<<<<<< Updated upstream +======= bio biologicalattribute biologicallyactivesubstance +>>>>>>> Stashed changes bior biorf biorfd @@ -5529,14 +9592,19 @@ biorfri biorfriold biort biortn +bip bipart bipartite bipartiteabove bipartitebelow +bipartition +bipequiveqequiv +bipmor bipointed bipointedtopointedfst bipointedtopointedsnd bipolar +biprefix biprod biprodaddequiv biprodcomparison @@ -5556,48 +9624,119 @@ biproducttopushoutiscokernel biproductuniqueiso biprodx biprodxiso +bipush bir bird +birds birkhoff birkhoffaverage birkhofffinset +birkhoffn birkhoffset birkhoffsum -birth birthday +birthdaybook birthdaylem bis +bisa bisaiaisb +bisb bisdomain bisect bisection bisector bisemimodule bisequence +bishop bisim bisimcoinduct bisimcoinductaux bisimeqvt +bisimi bisimilar bisimilarity +bisimimulation +bisimlemma bisimo bisimtransitivecoinduct bisimulation bisimulations +bissa +bissect bissectrice bist bisup bisym bit +bita +bitaddercirc +bitadderoutput +bitadderstr +bitadderwithoverflowcirc +bitadderwithoverflowstr +bitalignof bitand +bitarr +bitarrs +bitb +bitborrowoutput +bitbstep +bitc bitcaseson +bitcol +bitcompcirc +bitcompstr +bitcount +bitdiv +bitenv +biteval +bitfield +bitfieldmove +bitfix +bitfta +bitfunc +bitgfa +biti +bitidx +bitify +bitimmediate +bitindex bitindices bitlen bitlength +bitleni +bitlist +bitlistlist +bitlistp bitm +bitmajorityoutput +bitmap +bitmapbase +bitmapbuffer +bitmapbufferend +bitmapload +bitmaps bitmask +bitmaskp +bitmatch +bitmu +bitmux +bitn +bitnot +bito +bitofk +bitofw +bitonic +bitop +bitops +bitor bitotal bitp +bitpat +bitpos +bitpr +bitproj +bitps bitr bitraversable bitraverse @@ -5609,25 +9748,74 @@ bitrrd bitrri bitru bits +bitsasint bitscmp +bitsdc +bitsel +bitselect +bitselects bitseq bitset +bitsets bitsf bitsfi bitsfval bitsfzo bitsfzolem +bitshift +bitsi bitsinv bitsinvp +bitsize +bitsizeof +bitslice +bitslices +bitslt bitsmod +bitsof bitsp +bitspec +bitspecp bitsres bitsshft bitsss +bitstobyte +bitstobytes +bitstoints +bitstream +bitstreamsina +bitstreamswithresti +bitstreamswithrestin +bitstreamswithvaluein +bitstring +bitstrings +bitstruct +bitstructs +bitsubtractercirc +bitsubtracteroutput +bitsubtracterstr +bitsubtracterwithborrowcirc +bitsubtracterwithborrowstr +bitsum bitsuz bitsval +bitthm +bitu +bitv +bitval bitvec +bitvecto +bitvector +bitvectorcast +bitvectors +bitvectortests +bitwidth bitwise +bitwiseoperations +bitwiseoperators +bitwp +bitxnor +bitxor biun biunion biunioneqsigmaofdisjoint @@ -5636,22 +9824,51 @@ biunionprepartition biuniontagged biunique bius +bivalence +bivar bivariate +biw +biwk bixor +bizarre bja bjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjrpgqjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjfjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjlujjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjqqppjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjwvuuetaidjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjxvjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjmjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjryaboqjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjsicuvajjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjj bjshhmxycizrjrnlmr +bkbootsec +bkim +bkima +bkimb +bkleisli +bkossge +bkptr +bks +bkset +bla black blackd blacken +blacklist blacklistinsertion +blackness blacks blah +blak +blake +blakers +blalgebra blambda +blame +blamealist +blanc blank blankextends blankrel +blanks blaschke +blashthen +blast +blasted +blasting blbas blbnd blcld @@ -5662,12 +9879,21 @@ blcom blcomps blcvx bld +bldexp bldisj +bldr ble +bleb +bledsoe +bleft +bleh blelrn blelrnps blem +blemma blen +blend +blends blenfzo blengt blength @@ -5679,34 +9905,56 @@ blennnt blenpw blenre blenval +bleq blerat bleu +bleval blex blf +blfn blfps blfval blfvalps blgt blhalf +bli +blichfeldt +bliftm +bliklenet blim bliminf +blimit blimsup blin blincomp +blind blindable blinded blinding +blinds blinfun +blinfune +blinfuni blinfunpow blinfuns +blini +blininf +blink +blinkzipproperty blist blists +blit blk +blks +blkst +bll bln blnei blnop blo blob +bloc +bloch block blockadjliftmap blockcopy @@ -5716,51 +9964,92 @@ blockdiagonal blockdiagonaladdmonoidhom blockdiagonalringhom blocked +blockedp +blocker blockers blocki blockimplicitlambda blocking +blockingp +blockitem +blockitemlist +blocklen blockliftfix blockliftmap blocklist blockmat blockmatrices blockmem +blockname +blocknames +blocknil +blocknone +blocknt blocknum blocknumnelemma blockonmetas +blockop +blockorder blockp +blockquote +blockredsfinal +blockrep +blockreps blocks blocksbool +blockscope +blockseval +blocksext blocksfinequiv blocksfun +blocksi blocksize +blocksizes +blocksizesi +blocksizesp +blocksloc blocksof +blocksome blocksread +blockstart +blockstarts +blockstartsi +blockstartsp +blockstmt +blocksz +blocktag blocktriangular +blocktype blocn blocni blocnilem blof blog +blohi +blok bloln blometi -blood bloom +bloop blopn bloval blow blowing +blown blows blowup blp blpnf blpnfctr +blpo blptrusted blres blrn blrnps +bls blsconn +blsi +blsnd blss blsscls blssec @@ -5773,189 +10062,445 @@ blssp blssps blsub blt +bltb +bltr +bltu +bltzal +blub blue +bluedfs +bluedfsi +bluemaster blues +bluish blunt blur blv blval blvalps +blx +blxor bma bmake +bmap +bmarker bmask bmaski +bmatch +bmax +bmaxrf bmc bmeas +bmeasurable +bmetric +bmglue +bmi +bminus bminussameexp bminussameexpaux bminussameexpneg bmiuomdylfwoinlbhwdge +bmleft bmn bmo bmod +bmodel +bmp +bmpushout bmq +bmr +bmrecur +bmrecurstring +bmright +bmsearch +bmsearchstring +bmspan +bmult +bmux +<<<<<<< Updated upstream +======= bmw +>>>>>>> Stashed changes +bnan +bnand +bnawvnh +bnbd bncmet bncms +bncn bncssbn bnd +bndap bndatandm +bndb +bndbnd +bndc +bndcp bndlem bndlinop bndmet bndndx +bndny +bndo +bndoo bndppz +bndr bndrank +bnds bndss bndth +bndts +bndy bne +bnearbyint bneg +bneq +bnew +bnext bnf +bnfe bnfkjfagkfobm +bnfnone bnfs +bnil bnj +bnl +bnlen bnlirixzwmxcpz +bnll +bnllp bnlmod +bnlp +bnn bnngp bnnlm +bnns bnnv bnnvc bnode +bnor +bnormfr bnot bnrel bnsca bnsscmcl +bnt +bnum +boa board +boardisvalid +boardpreset +boardsofar +<<<<<<< Updated upstream +======= +boatoneast +>>>>>>> Stashed changes bob +bobby +bobe bocardo bochner bod bodd bodddiv +boddispr +bode bodies bodiesderivable +bods body +bodyaad +bodyaadbyframetype +bodyaadcontenttypestring bodyd bodyinfo +bodyless +bodylessfor +bodylessloop +<<<<<<< Updated upstream +bodys +======= bodymotion bodypart +bodys bodysubstance +>>>>>>> Stashed changes +boehm +bof +boffa +bofz +<<<<<<< Updated upstream +======= +bog +>>>>>>> Stashed changes +bogosityclient bogus +bogusly +bohl bohr bohrmollerup +boid +boidl boilerplate boiling boils +boitier bojani bojanic bold +bolden boldn bolzano +bom bomb +bond bondy +bone bonk bonnet +bonus boo +boody +boogie +boohoo book +bookdata +bookkeeping books bool boolagree boolalg +booland +boolandexpr +boolands +boolandt boolarrowequivprod +boolbool +boolbr +boolbrstr +boolcallee +boolcaller +boolcan +boolconst +boolcorrect +boolcr +booldec boole +boolea +boolealg boolean booleanalgebra booleanalgebraofbooleanring booleanalgebraofcomplemented booleangenerators booleanisation +booleanization +booleanness +booleanp booleanring +booleanringstr booleans booleansemantics booleansemiring +booleansp booleansubalgebra +boolelatt +booleposet +booleq +booleqfalse +booleqtrue boolequivpunitsumpunit boolesineq +booleventspace +boolexp +boolfix +boolfun boolfunc +boolgroup +boolhom booli boolif +boolify boolindic boolindicator +boolisosusp boolkernel +booll +boolless +boollessstate boollib +boollit +boolm +boolmark +boolmask +boolmaskp +boolmasks boolnot +boolnotexpr +booloan +boolofval +boolops +boolopt +boolor +boolorexpr +boolort boolp boolprodequivsum boolprodnatequivnat +boolprop +boolrec +boolrel boolresult boolring boolringcatequivboolalg bools +boolset +boolshavesigmaalgebra +boolsizedmonotonic +boolsizemonotonic +boolspec +boolss +boolsyntax boolt +booltest +booltheory booltomaybe +booltonat +booltree +boolunsized boolv boolval +boolvar +boolvarexpr +boolvarlist +boolvars +boolwrapper +boolxor +boolxorassoc +boolxorcomm +boolxorfacts +boom +boost boot +booth +boothmul +boothmultiply +boothmultiplyd +boothp +boothpipe +bootseq +bootsig bootstrap bop bopen +bopname +bopp +bopt bor -bordeaux border bordered +borders +<<<<<<< Updated upstream +======= borderson +>>>>>>> Stashed changes borel borelcaratheodory +boreli borelize borelmarkovfromreal borelmbl borelness borels borelschroederbernstein +borelsets borelsnd borelspa borelspace boreltorefl +borig +borigv +boring bormflebmf +borne bornologies bornology bornot +borrow +borrowcirc +borrowed +borrowicirc +borrowistr +borrowoutput +borrowstr +bors borsuk +borsukian +borsukianness +bortcb boruvka bosch +bossy bot +bota botc +botch +botcoeff botcoeisoinitial botcoeisozero +bote botel botequiv botequivofinjective botequivpunit +boteset botf both +bothassertnotproved +bothcase +bothd bother bothering bothfbothsame +bothimm bothl bothom bothomclass bothtbothsame +bothways botiso +botl botle botorderornobotorder +botp +botr +bots botset botsquareispushout +bott bottle bottleneck +bottm +botto bottom +<<<<<<< Updated upstream +======= bottomdataproperty +>>>>>>> Stashed changes +bottomfloat bottommap bottomrow +bottoms bottomup bottopology +bou bouac +boucle +boule boun +bounce bouncing +bouncy bound boundar boundaries @@ -5963,6 +10508,7 @@ boundariesofisboundary boundariestocycles boundary boundaryge +boundaryi boundaryle boundaryless boundarylessmanifold @@ -5970,13 +10516,26 @@ boundarypoint boundaryspectrum boundboundnat boundc +boundcomputation +boundcomputationispr +boundcomputationmonotone boundconfig boundd +bounde bounded boundedadd boundedatfilter boundedatiminftysubalgebra boundedby +boundedbyadd +boundedbyempty +boundedbyinclevel +boundedbyinsert +boundedbymono +boundedbysuc +boundedbyun +boundedcheck +boundedcomplexsequences boundedcontinuous boundedcontinuousfunc boundedcontinuousfunction @@ -5988,17 +10547,30 @@ boundedfiltersubalgebra boundedfiltersubmodule boundedfoo boundedformula +boundedfunctions +boundedfunctionsnorm boundedgenhdsclass boundedgreatest boundedi +<<<<<<< Updated upstream +boundedint +======= +>>>>>>> Stashed changes +boundedints boundedinv boundedjoinsemilattice +boundedl boundedlattice boundedlatticehom boundedlatticehomclass +boundedlength boundedlenhdsclass boundedlimitrec boundedlimitrecon +boundedlinearoperat +boundedlinearoperators +boundedlinearoperatorsnorm +boundedlt boundedmeetsemilattice boundedmul boundednat @@ -6008,54 +10580,94 @@ boundednormingivesexp boundedorder boundedorderhom boundedorderhomclass +boundedp boundedpartialorder boundedpath boundedpaths boundedpi boundedpreim boundedquantifiers +boundedr boundedrandom +boundedrealsequences +boundedsearch boundedsets boundedspace boundedsub boundedunder +boundedvalidutf boundedvariation boundedvariationon boundedvec boundedwrt boundeffect +bounder +bounders boundes +boundf boundfvars boundi bounding boundingsieve boundl boundlinarith +boundlr +boundmaketrace boundnames boundnat boundnatcorrect boundnormalmult boundnormnum +boundnp +boundofconvergentsequence boundofdiscbdd boundoneprecision boundouputlengthsimp +boundoutput boundoutputlengthsimp -boundoutputs boundoutputsupportderivative boundp boundr boundrcorrect boundrropp +boundrw +boundry bounds +boundscheck +boundscheckarray +boundscheckblock +boundscheckbyte +boundsearchispr +boundsi +boundsubformulahelp +boundsubterm +boundsubterms +boundsxxx +boundty +boundv +boundw +bouquet +bouquetdegree +bouquetdegreecomp +bouquetdegreecomppos +bouquetdegreeconst +bouquetdegreeid +bouquetdegreesusp +bouquetfuns +bouquetlift +bouquetsusp bourbaki bourbakipkg boustrophedon +bout +boutput +bov +bovi bowt bowtie +bowtieprod box -boxa boxadditivemap -boxc boxcutc boxe boxed @@ -6063,7 +10675,10 @@ boxer boxes boxi boxicc +boximp +boxing boxintegral +boxp boxpoly boxprod boxprodassoc @@ -6074,13 +10689,28 @@ boxprodright boxprodsumdistrib boxriin boxs +boxy +boy +boyer +boz bozo bpar +bparse +bpb bpc +bpcp bpd bpe +bpf bpi +bpk +bpl +bpll +bpllp +bplp +bplus bplustree +bpm bpoly bpolycl bpolydif @@ -6094,13 +10724,30 @@ bposlem bpow bpowpsubone bpowtwop +bpp bpre bpred +bprime +bprimedec bprog +bprop bprv bps bpspec +bpt +bptopologicaltype +bptr +bpts +bpwedge +bpwedgee +<<<<<<< Updated upstream +======= +bqc +>>>>>>> Stashed changes bqtran +bquot +bquote +bquotes bra braadd brab @@ -6114,17 +10761,25 @@ brabidgaw brabn brabsb brabv +brabvv +brace +bracelet braces bracket +bracketed bracketedbinder bracketedbinderf bracketedbindertype bracketedoption +bracketedspec +bracketedtoarray +bracketedtoobject brackets bracl bracnln bracnlnval bracnvbra +braddcfn brady brae braew @@ -6135,18 +10790,49 @@ brafval braid braided braidedcategory +braidedmonoidal +braidedmonoidalcategory braiding braidinghomcorepresenting braidinginvcorepresenting braidingnatiso braidword +brake bralgext bralnfn bramul +branc branch +branchaddr +branchconditional +branchdeg +branchdelay branched branches +branchexchange +branchfixp +branchi +branchimmediate branching +branchjoin +branchjoinkripkeintuitionisticmodel +branchkeycontext +branchkeyid +branchkeyidentifier +branchkeyidsupplier +branchkeyitem +branchkeyitemsdonotcollide +branchkeyversion +branchlinkexchangeimmediate +branchp +branchrange +branchregister +branchtaken +branchtarget +branchto +branchtype +branchv +brand brange branmfn brapply @@ -6155,6 +10841,7 @@ braun braval brbigcup brbtwn +brc brcap brcart brcgr @@ -6178,12 +10865,20 @@ brcoffn brcog brcogw brcolinear +brcomposeg brcoss brcosscnv brcosscnvcoss +brcount +brcross +brcrossg +brcsuc brcup +brcupg brdif brdifun +brdisj +brdisjg brdmqss brdmqssqs brdom @@ -6193,14 +10888,33 @@ brdomg brdomi bre brea +bread +breadth break +breakable breakage +breakcond +breakdist breakdown +breaker +breakers breaking +breaklabels +breaklast +breakloop +breakmaynotbefinehere breakonerror +breakp +breakpoint breaks +breaksandcontinues +breaksarefinehere breakss +breakst +breakstatements +breakstmt breathing +brec brecop bredundant brel @@ -6208,8 +10922,6 @@ breldm breldmd breldmg brelg -breln -brelnall brelrn brelrng bren @@ -6226,6 +10938,7 @@ breqan breqd breqdi breqi +breqr breqtrd breqtrdi breqtri @@ -6237,12 +10950,21 @@ breqtrrid brers brerser bres +bresenham +brestr +bret +breve +brewrite +brex brfae brfi brfinext brfldext +brfns brfs brfullfun +brfullfung +brfullfunop brfvid brfvidrp brfvimex @@ -6257,57 +10979,84 @@ brgric brgrici brgrilci brgrlic +brick +brickcount brickmat brid +bridg bridge bridgeedges bridges +bridgetheorem bridging +briefly briemann brif brifs +bright brimage brimageg brimg brimralrspcev brin bring +bringing +brings brintclab brinxp brinxper brinxprnres -britisch briunov brk brl brlb brle +brlec +brlecg +brlen +brlens +brlist brlmic brlmici +brltc +brm +brmax +brmc brmptiunrelexpd brn brne brneqtrd +brnft brnl +brnnft brnonrel broad broadcast +broadcastte broadimportscheck +brock brocot brofs +broke broken +brokenfunction +broots bropabg bropaex bropfvvvv bropfvvvvlem bropopvvv +brother broucube +brought broutsideof brouwer +brouwerian brovex brovmpoex brovmptimex brovpreldm +brown browning browser brp @@ -6319,15 +11068,20 @@ brpprod brprcneu brprcneualt brprop +brpw +brr brrabga brralrspcev brrange brrangeg brredunds brredundsredund +brreldmex brrelex +brrelrnex brres brresdm +brresg brresi brressn brrestrict @@ -6340,14 +11094,18 @@ brrtrclrec brs brsdom brsegle +brsi brsiga brsigarn brsigasspwrn brsingle brslts brsnop +brsnsi brssc brsset +brssetg +brssetsn brsslt brssr brssrid @@ -6355,10 +11113,13 @@ brssrres brstruct brsuccf brsucmap +brswap brsymdif +brtcfn brtp brtpid brtpos +brtposg brtr brtrclfv brtrclfvcnv @@ -6367,10 +11128,16 @@ brttrcl brtxp brtxpsd brub -bruce bruijn brujin +brules +brulesp brun +brunerie +bruneriegroupequiv +brunerieiso +brunerieisoabstract +brunn brute brv brvbrvvdif @@ -6385,44 +11152,113 @@ brwitnlem brxp brxrn brxrncnvep +brz +brzozo +brzozowski +bsalist +bsat +bsbddbounded bsc +bscalar bsd +bse bsearch +bseeds bseq +bseqi +bseqsame bset +bsf bsh bshift bsi bsia +bside +bsign +bsim bsimp +bsimpcorrect bsingleton bsinleton bsize +bsizev +bsl +bslashspecial +bslb bsle +bsm +bsmap +bsmapt +bsn +bsort bsp +bspace +bspacedef bspp +bsqrt bsquared bsquares +bsr +bsrc bss +bsskewbinomialheapstruc bst +bstack +bstate +bstdom +bstep bstinsert +bstk bstl +bstlookup +bstmap +bstok bstr +bstrm bstsearch bsu bsub +bsuba bsubc +bsubsettr +bsucc +bsum bsup bsupr bsv +bswap +bswitch +bswitchlemma +bsxaqbq +bsz +bta +btc +bte +bthen +btickt +btimes btl +btm +bto +btoa +btoc +btor +btp btqmwppyu +btr btran btrans btree +btreep +btrees btrue +btrunc +bts +btupi +btv btw btwn +btwnapz btwncolg btwncolinear btwncom @@ -6445,61 +11281,146 @@ btwntriv btwnxfr btwnz btwnzge +bty +btyping +btys +bubb bubble +bubs +<<<<<<< Updated upstream +======= +buc +>>>>>>> Stashed changes buch buchaux +buchi +buchiautomaton bucket +buckets budan buddy budget +budgetupdate buechi +buena buf bufal +bufdrop +buff +buffe buffer +buffercontents bufferdisk +buffered buffermode bufferoffsets +bufferoverrun +bufferp buffers bufferseq +buffersize +buffertest buffon +bufp +bufs +bufsize +buftype +bufv +bufx bug bugget +buggy +bugs bui +buil build +builda +buildaaux +buildbaux +buildc buildclause buildclauses +buildclemma buildcolimit buildconj +buildcontr +builddecrypttestvector +builddesc builddiagram +buildencryptioncontexttoonlyauthenticate +buildencrypttestvector +buildequiv builder builderoptions +buildgraph +buildheaderauthtag +buildheaderbody building buildiscolimit +buildisequiv buildislimit +buildkeymaterials +buildl +buildlemma buildlimit buildmatcher +buildoperations +buildp buildproof buildproofstep +buildq +buildr buildreify builds +buildstates buildtab buildtabw buildtr buildtransitiveleproof buildtransitiveleproofdfs +buildtree buildup buildupi built +builti builtin builtineffect builtineffectpolymorphic +builtininteqisequivalencerelation +builtininteqisnotirreflexiverelation +builtinintgeisantisymmetricrelation +builtinintleistotalordering +builtinintltisasymmetricrelation +builtinintltisirreflexiverelation +builtinintltisnotreflexiverelation +builtinintltisstricttotalordering +builtins builupi builupicorr +buip +bul bulk +bulkload +bulky bullet +bulleted +bulp +bummer bump +bumpa +bumpc bumpcovering +bumped +bumper +bumpfd +bumpform +bumping +bumpk +bumpmod bumps +bumpterm +bumpuniv +bumpversion bunch bundle bundled @@ -6517,110 +11438,310 @@ bundlings buni bunion bunit +bupd +bupdseplog +bur +bura +burali +burdened +<<<<<<< Updated upstream +======= burgundy +>>>>>>> Stashed changes +buried +burn +burner burns burnside burnsidetransfer +burp +burst +burstm +bury +bus +busa +busb busemann +bush +bushktolist +bushntolist +business +busreq +busvalue +busy +busym but butfirst +butfirstn +butla butlast +butlastappend +butlastd butlasti +butlastissubset +butlastn +butlastx +butler +butlst +butnot +<<<<<<< Updated upstream +======= buttercup +>>>>>>> Stashed changes butterfly +button +buu buy buyer +<<<<<<< Updated upstream +======= buying +>>>>>>> Stashed changes +buyportfolio +buyportfolioext buyprotocol +buz +buzp +bva bvadd bval +bvalidinstructions bvalue bvand bvar bvarappcase +bvarbound bvaridx +bvarr bvars bvashr +bvc +bvca +bvcat +bvcep +bvch +bvcheck +bvcho +bvchop +bvchops +bvconcat +bvconverter +bvcount +bvdiv +bve +bvec +bvecp +bvecps bvect +bvecthm bvector +bvequal +bveric +bversions +bvf +bvfs +bvfsl +bvfunc +bvfuniq bvg bvi +bvif bviproof +bvisem bvkjjmmchnevy +bvl +bvlcu +bvle +bvles +bvlproof +bvlprops +bvlsem bvlshr +bvlt +bvm +bvmin +bvminu +bvminus +bvmod bvmul +bvmult +bvn bvnat bvneg bvnot +bvnth bvo +bvone +bvop bvor +bvp +bvpl +bvplu +bvplus +bvrol +bvror +bvrs bvs +bvseq bvsge bvsgt bvshl +bvshr +bvsize bvsle bvslt bvsmod bvsub +bvsx +bvtests bvtonat +bvu bvudiv bvuge bvugt bvule bvult +bvum +bvumi +bvumin +bvuminu +bvuminus +bvumiuns bvurem +bvv +bvx bvxor bvxorxor +bvy +bvzero bwd +bwdround +bwin bwind +bwl +bwm +bwmax bword bwt bwth bwtn bxe +bxg +bxmax +bxmcx +bxnor +bxor +bxorlist +bxs bxsocsqrxvvxnp +bxy byabsurdity byassumption +bybit +byboolabsurdity bycases byclaim +byclause +bycol bycontradiction +byd bydefinition +byeq byex byf byfix +byfunc byi byki +bymay +bymcy +byp bypass +bys +bysr +byt byte +bytearr +bytearray +bytearrays +bytebits +bytebuffer +bytecode +bytecoded +bytecopy +bytecopyadd +bytecopynew +bytecopysub +bytef bytei byteidx byteindex +bytelength bytelist +bytelistpredicatesize bytelistreader +bytemask +byteor +bytep +bytereverse bytes +bytesequence +bytesi +bytesigned +bytesinword +bytesinwordb +bytesize +bytesp +bytestag +bytestobits bytestring +bytesv +bytesvalid +bytetest +bytetobits bytev +bytevector +bytspersec +byvalue +bywellformedness +bywitness +bzero +bzip +bzipblinklemma +bzipziplemma +bzo +bzqndmn bzrehtvtynyxlexvfgo +bzs +bzz caa caaa +caaaar +caaadr +caaar caab caabe caac caad +caadar caadcc +caadddadadadar +caadddr +caaddr +caadr caafd +caar +caars +caav cab caba cababe -cabbage cabc cabd cabdf cabe cabec cabef -cabernetfranc -cabernetsauvignon cabf cabs cabscong @@ -6628,6 +11749,7 @@ cac caca cacaeb cacc +caccv cacd cacdce cace @@ -6636,30 +11758,70 @@ cacf cach cachassum cache +cacheable cacheappliedentry cacheapplyentry +cached +cachedbuildstheorem cachedweight +cacheentrywithinlimits cachefailure +cacheid +cachelin +cacheline +cachelinep +cachem +cachemap +cachemapp cacheocc +cachep cachera cacheresult +caching +cacs cact +caction cad cada +cadaar +cadaddr +cadadr cadan +cadar cadbi cadc cadcoma cadcomb cadd +caddaar +caddadr +caddar +caddd +cadddar +cadddddr +caddddr +cadddr +caddedges +cadditively +caddr +caddrs cade cadf cadfaf cadifp +cadkw cadnot cador +cadr +cadralt cadrot +cadrs cadtru +cadu +caduc +caduce +caduceu +caduceus cae caea caeaef @@ -6680,65 +11842,181 @@ cafbb cafbbceba cafbca cafd +cafedcc caff cafff caflisch +<<<<<<< Updated upstream +cage +cagelist +cages +======= cagamidae +cage +cagelist +cages cai +>>>>>>> Stashed changes caids caineq cake cakeml cal +cala +calb calc +calcel +calceqbits +calcinv +calcoh calcpanel calcparams +calcprinting +calcstmtexpr +calcstmtexprfunction +calctest +calcu calcul calculate calculated +calculatedcommitmentkey calculates calculating calculation +calculational +calculationalstyleproof calculations +calculelr +calculer calculus +cale calemes calemos +calg +calgeb +calgebra calghom +cali +calib +<<<<<<< Updated upstream +======= californiawine +>>>>>>> Stashed changes +calist +calistp call +callable +callback +callbodyless callc callcc +callcl callcommand +callconv calld calldata calle +calleasy called +calledge callee +calleed +calleepost +calleepostimpliescallerpost +calleepre +callem caller +callerofempty +callerpost +callers +callert +callf +callffi +callfixed +callfoo +callframe calling +callinterp +callinterplist +callispr calll +calllemmas +callmap +callmapp +callme +callmethod +callmylemma +callnatnat +callnt +callorder +callp +callparameters +callparametersnolocali +callpartition callprim callprocess callprocesswithexitcode +<<<<<<< Updated upstream +======= callproof +>>>>>>> Stashed changes +callq callr callred +callredsfinal +callredsnull +callredsobj +callredsparams +callredsthrowobj +callredsthrowparams callrule calls +callself +callsingleparam +callsite +callstack +callstate +callstmt +calltest +calltwo +calltwostate +calltyp +callusefoo +cals +calways cam +cambiarlo cambridge came camestres camestros +caminati +caml +camlpeg +camlpegexec +camlptreeconversion +<<<<<<< Updated upstream +can +canary +canbatrenbon +======= camphisbaenidae can +canary +canbatrenbon canbeconceivedasnonexisting canbelimitedby canbeunderstoodintermsof +>>>>>>> Stashed changes canc +cancall +cancalls cance cancel +cancelabl +cancelable canceladd +cancelation cancelbas cancelbasechange cancelbasechangealg @@ -6751,34 +12029,63 @@ canceldenominatorsat canceldenominatorsintype canceldenominatorstarget canceldenoms +canceldiamond canceled canceli canceling canceliso cancelisosimproc +cancell cancellable +cancellati cancellation cancellationlemmas +cancellationreasonlist +cancellations cancellative cancellativecommutativesemiring cancelleads +cancelled +cancellem cancelling +cancellr cancelmonoid cancelmonoidwithzero +cancelmx +canceln +cancelo +cancelpt +cancelr cancelresult cancels cancelsmul +cancelt +cancelto +canceltriangle +cancelxm canchoicemixin cancountmixin +cancpl +cancpr cand +candidat candidate candidateentries +candidateentrieslowered +candidateentriesterm +candidatep +candidateproperty candidates candidatesb candidatesbdist candidatesbofcandidates +candle +cands caneqmixin +caneval canf +canfs +canhom canlen canlift canliftcardinalnat @@ -6786,25 +12093,51 @@ canliftcontinuouslinearequiv canliftcontinuouslinearmap canliftpnat canliftset +canlr +canltpw +cannc +canncb +<<<<<<< Updated upstream +======= cannon +>>>>>>> Stashed changes cannot cannotbe +cannotparse cano -canomalepidae canon +canonalicality +canondom canoni canonic canonica canonical +canonicalarith canonicalcat +canonicalcatcat +canonicalcomp +canonicalcompwelldefined canonicalcontravarianttensor canonicalcovarianttensor canonicalembedding +canonicalencryptioncontext canonicalequiv +canonicalexp canonicalfactor +canonicalfp +canonicalimmreg +<<<<<<< Updated upstream +======= canonicalinterpretation +>>>>>>> Stashed changes +canonicality +canonicalization +canonicalize +canonicalized canonicalizepath +canonicalizing canonically +canonicallyccc canonicallylinearorderedaddcommmonoid canonicallylinearorderedmonoid canonicallylinearorderedsemiring @@ -6814,17 +12147,40 @@ canonicallyorderedadd canonicallyorderedaddcommmonoid canonicallyorderedmul canonicallyoverclass +canonicalmap +canonicalmodel +canonicalmoveregs +canonicalmultregs canonicalorder canonicalp +canonicalpmap canonicalpo +canonicalptree +canonicalregs canonicalsized canonicaltopology +canonicaltree +canonicalunique canonicfulp +canonicize canonize canonizer +canontree +canonv +canoverflow +canpop +canpopcategor +canpopcategory +canpoplist canrepr canrepri +canrl +cant +cantapply +cantc +cantcb cantelli +cantest canth canthnum canthnumlem @@ -6832,6 +12188,7 @@ canthp canthwdom canthwe canthwelem +cantmove cantnf cantnfcl cantnfdm @@ -6850,10 +12207,13 @@ cantnftermord cantnfub cantnfval cantnfvalf +canto cantor cantorfunction cantorfunctionaux +cantors cantorscheme +cantorschr cantorsequence cantorset cantorsetequivnattobool @@ -6863,11 +12223,14 @@ cantorstep cantortobinary cantortohilbert cantortoternary +canunderflow canusecache +canv caofass caofcan caofcom caofdi +caofdig caofdir caofid caofidlcan @@ -6876,7 +12239,11 @@ caofref caofrss caoftrn caonncan +caopr +<<<<<<< Updated upstream +======= caorb +>>>>>>> Stashed changes caov caovass caovassd @@ -6895,9 +12262,11 @@ caovdi caovdid caovdig caovdilem +caovdilemd caovdir caovdird caovdirg +caovimo caovlem caovmo caovord @@ -6906,25 +12275,64 @@ caovordg caovordid caovordig cap +capa capability capable +capacitor capacity capacitypertask +capbytes +capconst +capfv capital capitalization capitalize +caplam +capmx +capmxa +capmxc +capmxe +capmxmr +capmxs +capmxsl +capmxsr +capmxt +capn capp +cappcong capped +cappend +cappleft +capply +cappmessage +caps capsourceinfo +capst +capsuleenvironmentbelow capsyntax +capt +captmx capture captured captureexception captures capturesubexpr +capv +capva +capvc +capvf +capvs +capvsl +capvsr +capvv caq car +cara carabinieri +carac +caracgroup +caract +caracterise caragen caragencmpl caragendifcl @@ -6944,20 +12352,30 @@ caragenuni caragenunicl caragenunidm caragenval +<<<<<<< Updated upstream +======= caramel +>>>>>>> Stashed changes +carat carath caratheodory caratheodorydynkin +caratheodoryiu caratheodorylem caratheodorymeasurable caraudiosystem +carbis +carbon card carda +cardadd cardadju cardaleph cardalephex cardano +cardc cardcf +cardcl cardcommutatorbound cardd carddistinctfactors @@ -6967,38 +12385,67 @@ carde carden cardennn cardeq +cardequiv cardeqv cardeqzeroequivequivempty cardex cardf cardfactors +cardfe cardfiber +cardfin +cardfinestpart +cardfs +cardfsd +cardfsds +cardfsi +cardfsid +cardfsu +cardfsui +cardft cardfz cardg cardge +cardgeq +cardgt cardhom cardi cardid cardidd cardidg cardidm +cardig cardin cardina cardinal +cardinalcompind cardinalgenerate cardinalgeneratesets +cardinalind cardinalinter cardinalinterfilter +cardinalit cardinalities cardinality +cardinalityonesubset +cardinalityonetheelem +cardinalityrepresentative cardinalmk cardinalo cardinals +cardinalty cardinfima +cardinj cardiun +cardjg +cardle +cardleq cardlim +cardlt cardm +cardmg cardmin +cardmono cardne cardnn cardnueq @@ -7007,46 +12454,100 @@ cardom cardon cardonle cardord +cardp cardpowdegree cardpowdegreeisadmissible cardprc cardprclem cardpred cardquot +cardreflection cards +cardsc +cardscs +cardsd cardsdom cardsdomel cardsdomelir +cardsds +cardse +cardsg cardshift +cardsi +cardsid cardsn +cardsp +cardst +cardsu +cardsuc cardsucinf cardsucnn +cardsui cardsupp cardsuppltaddsubgroup cardsuppltaddsubmonoid cardsuppltsubfield cardsuppltsubring +cardsx cardt +cardu +cardui carduni carduniima +cardv cardval +cardx +cardxr care +careful carefully +careless +caremasks +cares caret carg +cargo cargs +carl +carm carmichael +carnage +carnap caro carr carri +carriage +carrie +carried carrier +carriere carrierequiv +carrieri carrierp +carriers +carrierstermalgebra carries carrots +carrv carry +carryadd +carrycirc +carryf +carryflag +carryicirc +carryin carrying +carryistr +carryou +<<<<<<< Updated upstream +======= +carryout +>>>>>>> Stashed changes +carryoutput +carryp +carrystr cars +carseq carsgcl carsgclctun carsgclctunlem @@ -7056,6 +12557,7 @@ carsgsiga carsgsigalem carsguni carsgval +carsp cart cartan cartanequivdual @@ -7065,13 +12567,17 @@ cartanmatrixin cartansubalgebra carter cartesian +cartesiancategory cartesianclosed cartesianclosedfunctorofleftadjointpreservesbinaryproducts cartesianclosedfunctortotypes cartesianclosedofequiv cartesianclosedofreflective cartesiancomon +cartesianf +cartesianfunctor cartesianlift +cartesianmonoidal cartesianmonoidalcategory cartesianmonoidalcategorycomparison cartesianmonoidalcategoryfst @@ -7083,9 +12589,17 @@ cartesianmonoidalcategorywhiskerleft cartesianmonoidalcategorywhiskerright cartesianpower cartesianproduct +cartesianproductisuniversalproperty +cartesianproductstructuresequiv cartesianproductwith cartesien +cartfin +cartier +cartpaira +cartpairb cartprod +<<<<<<< Updated upstream +======= cartprodfstin cartprodfstpaireq cartprodmempair @@ -7096,33 +12610,87 @@ cartprodpairmemer cartprodpairsurjeq cartprodsndin cartprodsndpaireq +>>>>>>> Stashed changes +cartproduct +carx cas +casc case casea +caseable caseapp caseb casebashing casec +casedist +casedistinction +casedl +casedm caseeq +caseerror +caseexpr +caseext +caseextends +casef +casefun +caseindent +caseinduction +caseinfnat +caseinj +caseinject +caseinl +caseinr +caselis +caselist +casemaybe +casenat +casep +caseplit +caser +caserel +caserxy cases casesauxon casescons casesdan +casese casesi casesifp casesm casesmatcher casesmatching casesnil +casesofresdiv caseson +casesp casespecific +casespl +casesplit +casesplitter +casesplitting +casestmt casestronginductionon casestrongrecon casestype +casesx +caset +casetype +caseuniversal casew +casewise +casex +casez +casezx cash +casi casing +casm +casn +caso +casorati cass +casse +cassign cast castable castadd @@ -7131,13 +12699,22 @@ castaddhom castaddmonoidhom castaddorderemb castback +castblockseval +castboo +castbool +castboolean +castchar castchoose +castctlformula castdef castdropb +caste +casted castelim castembeddi castembedding castequivalence +casteval castfinsupp castfreecommring castfwd @@ -7153,31 +12730,59 @@ castleorderemb castleorderiso castlequiv castlt +castltl +castm castmdata castmode castmsg +castmx +castmxe +castmxk +castmxkv +castnat +castnode castnum castorderembedding castorderiso castposnum castpred castrec +castregressions castringho castringhom casts +castsaftertypetests +castseq castsucc castsuccemb castsuccfunctor castsuccorderemb +casttests casttransparency castznum +casues cat +cata +catac catalan catalanseries +catalg +catalgex +catalog +<<<<<<< Updated upstream +======= catalunya +>>>>>>> Stashed changes +catantiisomorphism catappsimp catass +catassoc +catassocsch +catastrophic +catastrophy catbas +catc +catca catcat catcbas catcbascl @@ -7190,12 +12795,16 @@ catccofval catcenter catcfuccl catch +catchall catches catchet +catching catchnone catchom catchomcl catchomfval +catchs +catchsteps catcid catcinv catciso @@ -7206,6 +12815,7 @@ catcod catcofval catcommsq catcommsqover +catcomp catcone catcoppccl catcospantransfo @@ -7215,23 +12825,33 @@ catcsect catcslotelcl catcval catcxpccl +catcycles +catd catdom cate catego categor +categorial categorical categories category categoryastype +categoryd categoryfamily categoryforgetenrichment categoryfree +categoryhelper +categoryi categoryisosimp +categorylambda +categorylambdauniq categorymk +categorynames categoryofelements categoryofenrichedcategorytype categoryofgradedobjects categorypaths +categoryquasilambda categorysimp categorystruct categorystructure @@ -7242,37 +12862,107 @@ categorywithcofibrations categorywithfibrations categorywithhomology categorywithweakequivalences +catenation catenrich catenriched catenrichedordinary +catequiv caterpillar +catex +catexp +catexpcat +catexpcatax +catexpcod +catexpdist +catexpdom +catexpid +catexpmornt +catexpnattranscompdef +catf +catfa +catfac +catfc +catfca +catfe +catfile +catfiles +catfis +catfsi +catfunct catg cathomfval +cati catidcl catidd catideu catidex +catidl +catidr +catie +catisequiv +catiso +catisomorphism +catl catlid +catlists +catloop catmaybes +catmonad +catn +catnotation +catobj +catom +catop +catprod catpropd catprs catprsc catprslem +catpullback catpullbacksquare +catr +catrev +catreve catrid cats +catsign +catsignature catstr +catstring +catstrong +catstrophe catsubcat catt cattoreflquiver +catuniq +catunitssch catype cau +cauappcvgpr +cauappcvgprlem +cauappcvgprlemcl +cauappcvgprlemdisj +cauappcvgprlemladd +cauappcvgprlemladdfl +cauappcvgprlemladdfu +cauappcvgprlemladdrl +cauappcvgprlemladdru +cauappcvgprlemlim +cauappcvgprlemloc +cauappcvgprlemlol +cauappcvgprlemm +cauappcvgprlemopl +cauappcvgprlemopu +cauappcvgprlemrnd +cauappcvgprlemupu caubl caublcls caubnd caucfil +cauch cauchy cauchybound +cauchycomplete cauchyconst cauchyfilter cauchymeasure @@ -7281,12 +12971,80 @@ cauchypdfreal cauchypowerseries cauchyproduct cauchyriemann +cauchyschwarz cauchyseq +cauchysequence +cauchysequenceconvergent +caucus caucvg caucvgb caucvgbf +caucvgpr +caucvgprlem +caucvgprlemcanl +caucvgprlemcl +caucvgprlemdisj +caucvgprlemk +caucvgprlemladdfu +caucvgprlemladdrl +caucvgprlemlim +caucvgprlemloc +caucvgprlemlol +caucvgprlemm +caucvgprlemnbj +caucvgprlemnkj +caucvgprlemopl +caucvgprlemopu +caucvgprlemrnd +caucvgprlemupu +caucvgprpr +caucvgprprlem +caucvgprprlemaddq +caucvgprprlemcbv +caucvgprprlemcl +caucvgprprlemclphr +caucvgprprlemdisj +caucvgprprlemell +caucvgprprlemelu +caucvgprprlemexb +caucvgprprlemexbt +caucvgprprlemk +caucvgprprlemlim +caucvgprprlemloc +caucvgprprlemloccalc +caucvgprprlemlol +caucvgprprlemm +caucvgprprlemml +caucvgprprlemmu +caucvgprprlemnbj +caucvgprprlemnjltk +caucvgprprlemnkeqj +caucvgprprlemnkj +caucvgprprlemnkltj +caucvgprprlemopl +caucvgprprlemopu +caucvgprprlemrnd +caucvgprprlemupu +caucvgprprlemval caucvgr +caucvgre +caucvgrelemcau +caucvgrelemrec caucvgrlem +caucvgsr +caucvgsrlemasr +caucvgsrlembnd +caucvgsrlembound +caucvgsrlemcau +caucvgsrlemcl +caucvgsrlemf +caucvgsrlemfv +caucvgsrlemgt +caucvgsrlemoffcau +caucvgsrlemofff +caucvgsrlemoffgt +caucvgsrlemoffres +caucvgsrlemoffval caufil caufilu caufpm @@ -7296,6 +13054,7 @@ caun caurcvg caurcvgr caures +causal cause caused causeq @@ -7309,17 +13068,25 @@ causing causs caussi caution -cautomobile cav cava caveat +caw +<<<<<<< Updated upstream +======= cax +>>>>>>> Stashed changes cayhamlem cayley +cayleydicksonspheroid cayleyhamilton cayleyhamiltonalt +cayleyiso cayleylem +cayleyr +cayleys cayleyth +cayleytr cba cbaa cbac @@ -7338,9 +13105,11 @@ cbbc cbbceb cbbdcf cbbf +cbbi cbc cbca cbcb +cbcbb cbcbfd cbcce cbccefff @@ -7370,7 +13139,11 @@ cbef cbefaa cbefb cbelow +cbeq +<<<<<<< Updated upstream +======= cbetter +>>>>>>> Stashed changes cbf cbfbc cbfc @@ -7383,27 +13156,69 @@ cbff cbffb cbfi cbi +cbib +cbibi +cbid +cbidi +cbif +cbifi cbig cbigd +<<<<<<< Updated upstream +======= cbighi cbigphi +>>>>>>> Stashed changes +cbim +cbimi +cbinopdefuniq +cbiov +cbiovi +<<<<<<< Updated upstream +======= cbipedidae cbird +>>>>>>> Stashed changes +cbis +cbisi cbisup +cbl cblinfun -cbloc +cblk +cblnil +cblock cblockz +cblprefix cbmi cbn cbncms +cbnd +cbndp +cbnf +<<<<<<< Updated upstream +======= cbool +>>>>>>> Stashed changes +cbottom +cbounded cbov cbovi cbox +cbpos +cbranch +<<<<<<< Updated upstream +======= cbruce +>>>>>>> Stashed changes cbs cbsi +cbspace +cbt +cbtr +<<<<<<< Updated upstream +======= cbursitishtm +>>>>>>> Stashed changes cbv cbvab cbvabdavw @@ -7417,6 +13232,7 @@ cbvaldva cbvaldvav cbvaldvaw cbvaldw +cbvalh cbvalim cbvalimi cbvalimt @@ -7453,6 +13269,7 @@ cbveuvw cbveuw cbvex cbvexd +cbvexdh cbvexdv cbvexdva cbvexdvav @@ -7460,6 +13277,7 @@ cbvexdvaw cbvexdw cbvexeqsetf cbvexfo +cbvexh cbvexim cbveximi cbveximt @@ -7470,6 +13288,7 @@ cbvexv cbvexvv cbvexvw cbvexw +cbvf cbvfo cbviin cbviindavw @@ -7534,6 +13353,7 @@ cbvrabw cbvrabwold cbvral cbvralcsf +cbvrald cbvraldva cbvraldvaold cbvralf @@ -7584,8 +13404,10 @@ cbvsbv cbvsbvf cbvsum cbvsumdavw +cbvsumi cbvsumv cbvsumvw +cbw cbxnbolmf cca ccaa @@ -7596,10 +13418,10 @@ ccabfa ccache ccad ccadc +ccae ccaec ccafa ccafbc -ccar ccard ccase ccased @@ -7608,13 +13430,14 @@ ccatalpha ccatass ccatcan ccatcl +ccatclab ccatco ccatdmss -ccaterpillar ccatf ccatfn ccatfv ccatfval +ccatfvalfi ccatidid ccatlcan ccatlen @@ -7633,13 +13456,21 @@ ccatval ccatvalfn ccatw ccatws +ccauchy +ccaw +ccayleyr +ccayleytr ccb ccba ccbar ccbc ccbe ccbeec +ccbeta ccbf +ccbind +ccbinds +ccbrt ccc ccca cccac @@ -7650,10 +13481,14 @@ cccce cccd cccdbdf ccce +cccebecec cccfb +ccconv +cccvianatded ccd ccdaa ccdaba +ccdb ccdcb ccdd ccde @@ -7661,6 +13496,11 @@ ccdeb ccdec ccdedeba ccdf +ccdfg +ccdfny +ccdftx +ccdfx +ccdfy cce ccea cceaa @@ -7672,65 +13512,134 @@ ccede ccee ccef ccefa +ccenvr +cceta ccext ccf ccfbccef ccfe ccffc ccffe +ccfield ccfld ccfldextdgrr ccfldextrr ccfldsrarelvec +ccfn +ccfunen cch +cchain cchat cchhllem +cchoice +cchurch cci +ccidb ccinfty ccinftydisj ccinftyn ccinftyssccbar +ccirc +ccis +<<<<<<< Updated upstream +======= cckb +>>>>>>> Stashed changes ccl cclasst +cclause +cclears +ccless +cclose +ccls +cclsv ccly +cco +ccod ccode +ccoh ccoid +ccol +<<<<<<< Updated upstream +======= ccold +>>>>>>> Stashed changes ccollect ccomp +ccompare ccompatible +ccompf +ccompfs +ccompile ccompinsert +ccon ccondx +cconf +cconj +ccons cconst ccontinuous +ccontinuousfunctions +ccontinuousfunctionsnorm +ccontr +ccontravariant +<<<<<<< Updated upstream +======= ccordylidae +>>>>>>> Stashed changes ccorec ccorrese ccos ccosh +ccoslid +ccot +ccovariant +ccp ccpo +ccr ccring +<<<<<<< Updated upstream +======= ccrocodylidae +>>>>>>> Stashed changes +ccross ccs +ccsb +ccsetp +ccsim ccspan ccssccbar +ccstep +ccstepp +ccsteps +cct cctop cctx +ccube ccw ccwfwwf ccyfbfcepmf cda +cdaaar +cdaadr +cdaar cdab cdaba +cdabs cdac cdacd cdad +cdadar +cdaddr cdadec +cdadr cdaedf cdaeed cdaf cdainflem +cdapp +cdar +cdars cdata cdb cdbb @@ -7743,24 +13652,37 @@ cdbe cdbeff cdbf cdbfd +cdbi cdbkzueneshmgasdgrtyqkhjkcqcuhpkfyefdkongnqymgfvxew +cdbnum +cdbsize cdc cdca cdcb cdcd +cdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcd cdcdeb cdce +cdcew cdcf cdcff +cdcls cdd cdda +cddaar cddab +cddadr +cddar cddb +cdddar cdddd +cddddddr +cddddr cdddr cdde cddefb cddf +cddi cddo cddr cde @@ -7768,11 +13690,15 @@ cdea cdeaa cdeabd cdec +cdecl cded cdee cdef +cdefn +cdenorm cdens cdep +cdeq cdeqab cdeqal cdeqcv @@ -7784,6 +13710,8 @@ cdeqnot cdeqri cdeqth cderiv +cdescent +cdeusdf cdf cdfac cdfae @@ -7794,19 +13722,37 @@ cdfd cdff cdffaa cdfi +cdfny +cdftx +cdfv +cdfx +cdfy +cdi cdib +cdibi +cdid cdidi +cdif cdifi cdijkstra cdim +cdimi cdinngerhlvf cdiov +cdiovi cdis cdisi +cdisj cdist +cdiv cdivcncf +cdivcncfap +cdivmodt +cdivz +cdivzz cdj cdjreui +cdlam cdlema cdlemb cdlemblem @@ -7855,21 +13801,50 @@ cdleml cdlemm cdlemn cdlim +cdll +cdllnodea +cdllnodearrp +cdllnodep +cdllp +cdlocalg +cdlocall +cdlt cdm +cdmi +cdmod cdmode cdmsn +cdo +cdobj +cdom cdot cdotlinter cdots cdottk cdouble cdov +cdovi +cdp cdplayer +cdqe cdr +cdrain +cdred +cdrline +cdrn cdrop +cdrp cdrs +cdrx +cdry +cds +cdsi cdsub +cdtetat cdtypeid +cdual +cdv +cdw cea ceaa ceab @@ -7881,9 +13856,6 @@ ceadad ceae ceaf ceafab -cearnest -ceast -ceats ceb ceba cebb @@ -7891,9 +13863,11 @@ cebd cebdded cebe cebf +cebw cec ceca cecad +cecb cecc ceccb cecda @@ -7913,6 +13887,12 @@ cechnerveequiv cechnerveterminalfrom cechnerveterminalfromiso cechnerveterminalfromisocompforget +cecl +ceclb +ceclnn +ceclr +cecond +cecondition ced ceda cedba @@ -7923,6 +13903,7 @@ cedd ceddd cedf cedfb +cedge cee ceea ceeacf @@ -7931,6 +13912,8 @@ ceec ceed ceef ceefeac +ceex +ceexlem cef cefa cefac @@ -7939,7 +13922,9 @@ cefc cefcfeeb cefdedb cefe +cei ceicl +ceids ceige ceil ceilbi @@ -7956,50 +13941,111 @@ ceilhalfgt ceilhalfnn ceilid ceilidz +ceilin ceiling ceille ceilm +ceilqcl +ceilqge +ceilqidz +ceilqle +ceilqm +ceilqval ceilroot ceils ceilval ceim +ceiqcl +ceiqge +ceiqle +ceiqm cel +celar celarent celaront +celbody +celcius +<<<<<<< Updated upstream +======= celess +>>>>>>> Stashed changes +celet celim cell +cellassignment cellcomplex cellcomplexes +cellemptypayload cellfrontier +cellhom +cellmap +cellmaps +cellnonemptypayload +cellp cells cellsofrowlens +cellu +cellular +<<<<<<< Updated upstream +celt +cempty +======= celsius +celt +cempty cemydidae +>>>>>>> Stashed changes +cen +cenc +cent +centaur +centc cente center +centerallexothbool centerandrescale +centerc centercharacteristic centercongr centered centeredmonomial centerequivrootsofunity centerisocentroid +centerk centerm centermass +centern +centerp +centerr centers centerstarembedding centertocentroid centertocentroidcenter centertomulopposite centerunitsequivunitscenter +centerv +centg +centgmx +centgmxp +centi +centizer +centj +centm +centp centra central +centralallexothbool centralbinom +centralised +centraliser +centralises +centrality centralizer centralizers centralmoment centralmul +centrals +centralsymetpoint centre centred centres @@ -8008,10 +14054,28 @@ centroidhom centroidweights centroidweightsindicator centroidweightswithcircumcenter +centry +cents +centsc +centsp +centss +centu +century +centv +centvc +centvp +centvsp +centvx +centy cenum cenv +cenvr +cenvs +ceproof ceq ceqex +ceqnat +ceqs ceqsal ceqsalalt ceqsalg @@ -8034,31 +14098,66 @@ ceqsrexv cequiv cer cercle +cereq ceros +cerr +cerror cert +certa +certai certain certainly +certainty +certcheck +certd +certific +certificat certificate +certificatechecker +certificatecheckercmd +certificatecmd +certificategeneratorcmd +certificategeneratorexp +certificateinsensitivity certificateoracle certificates certification certified certifier +certifies certify +certifying +certs ces cesare cesaro +cesound +cespace +cesz +cet +ceuclidean +<<<<<<< Updated upstream +======= ceuromp +>>>>>>> Stashed changes cev +ceva ceval cevath cevathlem ceven +cevery +cew cewfgipgjjdqr cex +cexample +cexists +cexit cexp cexpr cexpri +cexps +cexpterm cext cfa cfaa @@ -8068,28 +14167,90 @@ cfabaa cfac cfad cfae +cfaithful +cfaithfule +cfalse +cfastp +cfaut +cfautconjg +cfautdprod +cfautdprodl +cfautdprodr +cfautind +cfautisom +cfautk +cfautmod +cfautmorph +cfautquo +cfautres +cfautvk +cfautz cfb cfba cfbcdc cfbd cfbe +cfbi +cfbigdprod +cfbigdprode +cfbigdprodei +cfbigdprodi +cfbigdprodik +cfbigdprodk +cfbigdprodkabelian +cfbigdprodklin cfc +cfcaaw cfcabs +cfcauchyschwarz cfcaux +cfcb cfcc cfccbfabe cfcce cfccf cfcd cfcdd +cfcenter +cfcentere cfcf cfchom cfchomsuperset cfcl +cfclass +cfclassinorm +cfclassp cfcnnrpow +cfcod cfcof cfcoflem cfcomp +cfconjc +cfconjce +cfconjck +cfconjg +cfconjgbigdprod +cfconjgbigdprodi +cfconjgdprod +cfconjgdprodl +cfconjgdprodr +cfconjge +cfconjgein +cfconjgej +cfconjgeout +cfconjgind +cfconjgisom +cfconjgj +cfconjgk +cfconjgkv +cfconjgm +cfconjgmnorm +cfconjgmod +cfconjgmorph +cfconjgquo +cfconjgres +cfconjgsdprod +cfcont cfcrpow cfcsqrt cfcunits @@ -8097,23 +14258,66 @@ cfd cfdb cfdbbdc cfdbc +cfdbce cfdc cfdcac cfdcc cfdd cfdecb +cfdet +cfdetconjg +cfdetd +cfdetisom +cfdetmn +cfdetmorph +cfdetrepr +cfdetres +cfdi +cfdiff cfdlli +cfdot +cfdotbl +cfdotbr +cfdotc +cfdotdl +cfdotdr +cfdote +cfdotel +cfdotelr +cfdoter +cfdotl +cfdotmnl +cfdotmnr +cfdotnl +cfdotnr +cfdotr +cfdotre +cfdotzl +cfdotzr +cfdprod +cfdprodc +cfdprode +cfdprodel +cfdproder +cfdprodkl +cfdprodkr +cfdprodl +cfdprodlk +cfdprodr +cfdprodrk cfe cfea cfeaf cfeb cfece cfedd +cfeed cfeef cfef cfefab cfefdb cfeq +cfexp cff cffa cffb @@ -8123,6 +14327,7 @@ cffd cffda cffdf cffe +cffea cffed cfff cfffe @@ -8130,19 +14335,28 @@ cffi cfflb cffldtocusgr cffldtocusgrold +cffonnl cfg +cfgc +cfgd +cfge cfgexit +cfgnode cfgs cfhama cfhase cfi cfib +cfibi cfid cfidi cfidm cfield cfif cfifi +cfiirr +cfiirre +cfiirrpe cfil cfile cfilfcls @@ -8159,40 +14373,143 @@ cfilufbas cfilufg cfiluweak cfim +cfimi +cfinal +cfind +cfindbody +cfinde +cfindeout +cfindesdprod +cfindind +cfindisom +cfindleast +cfindm +cfindmorph cfinfil cfinite cfinufil +cfinve cfiov +cfiovi +<<<<<<< Updated upstream +======= cfire +>>>>>>> Stashed changes cfis cfisi +cfisom +cfisome +cfisomk +cfisomkv +<<<<<<< Updated upstream +======= cfixpoint +>>>>>>> Stashed changes +cfker +cfkere +cfkerechar +cfkereirr +cfkerml +cfkermr cfkrkxh cfl +cflag +cflambda +cflat +cflattowas cfle cflecard cflem cflemold cflim +cflip cflm +cfls +<<<<<<< Updated upstream +======= cflute +>>>>>>> Stashed changes cfm +cfmi +cfml +cfmlls +cfmllsv +cfmlv +cfmod +cfmode +cfmodk +cfmorph +cfmorphe +cfmorpheout cfn cfni +cfnorm +cfnormb +cfnormbd +cfnormd +cfnormdd +cfnorme +cfnormn +cfnormz +<<<<<<< Updated upstream +======= cfoggy +>>>>>>> Stashed changes +cfold cfom cfon +cforce +cforder +cforderp cfov +cfovi +<<<<<<< Updated upstream +======= cfox +>>>>>>> Stashed changes +cfp +cfproj cfpwsdom +cfq +cfquo +cfquoe +cfquoeker +cfquoenorm +cfquoeout +cfquoinorm +cfquok +cfr cfrac +cframe cfread +cfreal +cfreg +cfrege +cfrepr +cfreprreg +cfres +cfrese +cfreseout +cfresind +cfresisom +cfresmod +cfresmorph +cfresquo +cfresres +cfromb +cfromx cfs +cfsdprod +cfsdprode +cfsdproder +cfsdprodk +cfsdprodkey cfseq cfsetsnfsetf cfsetsnfsetfo cfsetsnfsetfv cfsetssfset +cfsi cfsize cfslb cfslbn @@ -8200,12 +14517,36 @@ cfsmo cfsmolem cfss cfst +cfstsnd cfsuc +cfu cfub +cfull cfun cfunc +cfuncdefuniq +cfuncdom +cfunct +cfunctor +cfund +cfune +cfunelock +cfungid +cfuni +cfunie +cfunig +cfunij +cfunj +cfunjgen +cfunm +cfunp +cfunspace +cfunzero cfuucbho +cfv cfval +cfvs +cfw cfwrite cfwriteextendfilesize cfwritenoextendpreservesfilesize @@ -8213,13 +14554,36 @@ cfwritepreserves cfwritepreserveslastblockinvariant cfwritepreservesnextfreeblockinvariant cfwritepreservesunallocatedblocksinvariant +cfx +cfyxfty +<<<<<<< Updated upstream +======= cgambler +>>>>>>> Stashed changes +cgames +cgamma +cganchored +cgconsistent +cgderiv cge +<<<<<<< Updated upstream +======= cgekkonidae +>>>>>>> Stashed changes +cgen +cget +cgeval cgf +cgfa +cgform +cgformsimplify cgh cgjbucpfktfkowhu +cglobals +cglue +cgn cgodsil +cgood cgr cgra cgrabtwn @@ -8228,9 +14592,9 @@ cgracol cgracom cgrahl cgraid -cgrain cgrancol cgrane +cgraph cgraswap cgraswaplr cgratr @@ -8249,8 +14613,6 @@ cgrextend cgrextendand cgrg cgrid -cgroup -cgrp cgrrflx cgrrflxd cgrsub @@ -8259,15 +14621,27 @@ cgrtrand cgrtriv cgrxfr cgs +cgsat +cgseq +cgseval cgsex cgsexg +cgsform +cgsnot +cgt +<<<<<<< Updated upstream +======= cgusty cgvb +>>>>>>> Stashed changes cha chaar chabs chacha +chacing +chaged chagrov +chai chain chainbot chainbotcoeff @@ -8282,12 +14656,24 @@ chaincomplexmap chaincomplexxiso chaincomplexxoneiso chaincomplexxzeroiso +chaind +chaine +chained +chainedpredicatetests +chainex +chaing chainheight +chainhomotopy +chaini +chainin +chainind chaining chainlen chainlength chainmap +chainp chains +chainsd chainsfunctor chainsiso chainsmap @@ -8297,19 +14683,31 @@ chaintop chaintopcoeff chaintopidx chainub +chainw +chair +<<<<<<< Updated upstream +======= chalf +>>>>>>> Stashed changes challenge +challenges +challengetruth +challenging chan chance +chandle chang changable change changed changediag +changedp +changeevathang changeform changeformaux changeformequiv changefunctor +changegen changegroupr changeinv changeinverse @@ -8318,30 +14716,62 @@ changelhs changelocaldecl changement changenumeral +changeobj +changeobjpar changeofuniverse changeorigin changeoriginindexequiv changeoriginseries changeoriginseriesterm +changep +changeperm +changephone +changepres +changeprespar changeprop +changer +changers changes +changesa +changesb +changesv changeuserr +changeval changing +<<<<<<< Updated upstream +======= chanid +>>>>>>> Stashed changes +chann +channe channel +channela +channelb +channelp channels +channelsp +chans chaos chaoticnats +chap chapman -chapp chapter char chara charac +characfinbouquetfuniso +characfunspace +characfunspacecp +characgrouphom +characinverse +characiso +characrp +characs charact characte character characterdata +characterdes characterisation characterisations characterise @@ -8352,12 +14782,16 @@ characteriseseq characterising characteristic characteristicfunction +characteristics +characteritic characterization characterizations characterize characterized characterizes characterizing +characterlist +characterlistp charactermodule characterp characters @@ -8367,49 +14801,131 @@ characterspacetospectrum characterstic charalghom charandcard +charapairdes +charasunicodescalarvalue +charaut +charbigbv +charbv +charconversions +charcter +<<<<<<< Updated upstream +======= chardonnay +>>>>>>> Stashed changes chardvd +chare chareq +chareqv +charescapes charf charfn charfp +charfromunicodescalarvalue charfu charfun +charfunbi +charfunction +charfundc +charfundcalt charfundual +charfunr charge +charged +chargedi +chargeu +<<<<<<< Updated upstream +charging +======= +>>>>>>> Stashed changes +chargreater +chari +charinbetween +charles +charless +charlist +charlisteqv +charlistna +charlistnat +charlists +charlit +<<<<<<< Updated upstream +======= charly +>>>>>>> Stashed changes +charm charmatrix charmonoidhom charn charone +charord charp +charpair charpoly charpolyrev +charpos +charprinting +charquantification +charr charrp chars +charsandarrows charset +charsetp +charsets +charsfrom +charsimple +charsimplep charsinbase +charsp +charstate +charstates +charstrconversion +charstrescaping +charstring +charstrings chart chartat +chartd +charte charted chartedspace chartedspacechartat chartedspacecore chartedspaceself +chartest charthree +charti chartindependence +charto +chartoindex +chartoindextochar +chartoint +chartoo +chartostring charts +chartsi chartwo +charv +charvalues charvector +charw +charx +charxor +chary charz charzero -chas chase chases chasing chasles +chaslesassoc +chaslesbetween +chaslescomm +chasleslslttrans +chau chaum chaussettes +chb chcoeffeq chcoeffeqlem chcompl @@ -8418,73 +14934,182 @@ chcv chd chdmj chdmm +che +<<<<<<< Updated upstream +======= cheadache +>>>>>>> Stashed changes cheap +cheapen +cheaper cheapest +cheat cheb chebbnd chebyshev +chec check checkable +checkablebool +checkabledec +checkahead checkandsortrewritelemmas checkapp +checkbar checkblocklist checkcache checkcast checkcastallowed +checkcntls checkcolgt checkcomposition checkcompositions checkcompositionstac +checkdeadprocs checkdefeq +checkdekkers +checkdeltac +checkdeltas +checkdenorm checked +checkedbypiece +checkedbyplayer +checkeddelete +checkeddeletepar +checkedfiles checkemoji +checkeqnat +checkequality +checkequalitywithdafny checker checkers checkert +checkeven checkexistingtype checkexponent +checkf +checkfalse +checkfib +checkfield checkfilepath checkforunusedcustomprojs +checkg checkhex +checkhextrunc +checkhomedir checkin +checkinemail +checkinflight checking checkinterrupted +checkis checkislistofvariables checkisring +checkit +checklast +checklength +checklist +checkmatedbyplayer +checkmem +checkminus +checkmonotoniclegaltransitionssequence +checkmypred +checknet +checknewentry checknot checknotassigned +checkobj +checkpair +checkpairs +checkpoin checkpoint +checkpoints +checkpre +checkprefixrl +checkpres +checkprf +checkprfaxm +checkprfaxmispr +checkprfcorrect +checkprfcp +checkprfcpispr +checkprfeq +checkprfeqnispr +checkprffa +checkprfgen +checkprfgenispr +checkprfhelp +checkprfhelpispr +checkprfimp +checkprfispr +checkprfmp +checkprfmpispr +checkreads +checkreadslambdageneral +checkreadslambdapartial +checkreadslambdatotal +checkreadsparens +checkreadstot checkredundant checkrequest checkresult checkrewrite +checkroutes checks checkse +checksequenceinv +checksettings +checkspalignment +checkspecial checkstr +checksubformulatrace checksuccess +checksum checksynthorder checksystem +checkt +checktemp +checkthatmessageisverifiedassumingexpectfails +checkthatverifierrunsinsidedesugaredexprs +checkthis +checktracecorrect +checktraceispr +checktransitivebaselegaltransitionssequence +checktransitiveinv +checktransitivelegaltransitionssequence checktypeq +checku checkvarvalue +checkw +checkwellfounded checkws cheeger cheerios +<<<<<<< Updated upstream +======= +chef +>>>>>>> Stashed changes +cheights chel cheli chelii -chemicalprocess chemin chemina cheminmonoid +cheney chenflurmukhopadhyay +<<<<<<< Updated upstream +======= cheninblanc +>>>>>>> Stashed changes +chentsov +cheq chernoff chernoffbound +cherry chet chevalley chevalleythm -chevy chex chfacffsupp chfacfisf @@ -8498,24 +15123,35 @@ chfacfscmulcl chfacfscmulfsupp chfacfscmulgsum chfnrn +chg +chgpl +chgs +chgsp chguniv chh chhflvd chi -chianti chicken +chicli +chief chil chilbert child childfailures +childkeyringsjson +childloopinvariant childngen children +childrenvisited childsequences childtactics childtransitions +childz +chilf chilold chincl chincli +chine chinese chineseremai chineseremainder @@ -8523,8 +15159,13 @@ chineseremaindero chineseremainderoffinset chineseremainderoflist chineseremainderofmultiset +chineseremaindertheorem +chineseremaindertheoremhelp chintcl chintcli +chints +chip +chirel chirred chirredi chirredlem @@ -8544,13 +15185,18 @@ chjoi chjval chjvali chk +chkargs chkchop chkrange +chksubs chktrack +chkv +chl chlcsschl chle chlej chlejb +chli chlimi chlub chlubi @@ -8564,6 +15210,7 @@ chmodpcp chmodpsp chmodpss chn +chnages chnccat chnccats chndss @@ -8612,36 +15259,86 @@ chocini chocnul chocunii chocvali +choi choice choiced choicee choicefi +choicefn +choicefni +choicel +choicemap choicemixin +choiceo +choicepcountable +choiceppointed choices +choiceset +choiceseti choicetype choinitconfig chokes +chol chole choles +cholesky chom chonextconfig +choo choos +choosablefrominterval choose +chooseamong +chooseamongmethod +chooseap choosearg +chooseb choosebasis choosebasisindex choosebinder +choosebo +chooseboo +choosebool choosedecomposition chooseenteringvar +chooseequivclasschoose chooseexitingvar +choosei +chooseint +choosen +choosenat choosenext +<<<<<<< Updated upstream +======= choosenonempty +>>>>>>> Stashed changes +chooseobj +chooseor +chooseord +chooseorder +chooseorderindex +chooseorderval +choosep +choosepath choosepivots +chooseprop +chooser +chooses +chooseunsized choosex +choosez choosing chop chopd +choppable +chopped +chopping +chops +chopz chord +chordal +chordless +chords chordthm chordthmalt chordthmlem @@ -8649,6 +15346,7 @@ chore choreographictypechecker choreography chorun +chose chosen chosenallocation chosenallocationalg @@ -8696,21 +15394,33 @@ chpwordi chq chr chrcl +chrclicocompl chrcong chrdvds chrelat chrelati +chrem chrid chris +<<<<<<< Updated upstream +christians +======= christian +christians christiansufferterrahumanitarianorganization +>>>>>>> Stashed changes +christophe chrnzr chromat chromatic +chromaticcsg chromaticnum chromaticnumber +chrrcovcr chrrhm +chrs chrval +chs chscl chscllem chseli @@ -8746,7 +15456,6 @@ chtfl chtge chtleppi chtlepsi -chtm chtnprm chto chtppilim @@ -8759,16 +15468,21 @@ chtval chtvalz chtwordi chub +chuch +chuck chudnovskydenom chudnovskynum chudnovskysum chudnovskyterm +chun chunk chunks chunksof +chunksoflength chunssji church churchrosser +chv chvar chvarfv chvarv @@ -8780,7 +15494,12 @@ cicer ciceralt cicfn cicfval +cichurch +cicj ciclcl +cicod +cicomp +cicomplete cicpropd cicpropdlem cicrcl @@ -8788,53 +15507,125 @@ cicref cicsym cictr cid +cidb cidffn cidfn cidfval +cidj +cidom cidpropd cidr cidrsplit +cids +cidv cidval +cied +cierto cif +cifdef +ciff +cig +cigar cignorabimus cih +cihh +cihl +cihtium +ciid ciinf +ciinterp +ciinterpretation cil +cim cimage +cimm +cimodel +cimor +cimp +cimpl cin cinc cind +cindependent cindex +cindexe cindexp +<<<<<<< Updated upstream +======= cinduction +>>>>>>> Stashed changes +cinf cinfi cinfinite cinfo +cinfsum +cinftyr +cini +cinit +cinl +cinli +cinline cinner +cinr +cinsert +cinstlist +cint +cintapp +cintappsize +cinte +cintege +cinter +cinterp +cinterval +cintesign +cintp +cintr cintro +cintsize cinv +cinvtri +ciobj cioo cipher +ciphercore +cipheredtxt ciphers +ciphersuite +ciphertext +ciphertextbytes +ciphertextgeneratedwithplaintext +ciphertexttype +ciphertxt cir circ +circa +circcmb circcn +circcomb circgrp circl circle circleaverage +circled +circledcomb circledeg circleequivcomplex circleequivgen circleexp +circlefm circleintegrable circleintegral +circleiso circlemap +circlemaps circlemeth circlemethhgt circlemethnat circlepath +circlepathi +circlepaths circles +circlesuperimposedcr circletransform circletransformboundingfunction circletransformderiv @@ -8842,33 +15633,68 @@ circlevma circline circonscrit circonscrits +circpermnconsok +circpermnconstlok +circpermncp +circpermncpok +circpermnid +circpermnidaux +circpermnidfirst +circpermperm +circresult circsubm circtopn +circtrm +circu +circui circuit +circuitcharact circuiti +circuitmodels +circuitp circuits +circuitsorts +circuitstr circulant circulantgraph circular +circularity circularizing circularorder circularpartialorder circularpreorder +circulation circum circumcenter circumcenterindex circumcenterweightswithcircumcenter +circumrad circumradius +circumscribes +circumscription circumsphere +circumstan +circumstances circumvents +<<<<<<< Updated upstream +======= cirreflexive +>>>>>>> Stashed changes +cirules cis cisinvar cisk +ciso +cispi +cissg cisup +cite citing citizen +cits city +<<<<<<< Updated upstream +======= citya citylat citylong @@ -8876,9 +15702,16 @@ cityname citynamedfn citynation cityofbostonma +>>>>>>> Stashed changes +civ +civeric +cizmrrh cjadd cjaddd cjaddi +cjap +cjbdxxn +cjci cjcj cjcjd cjcji @@ -8887,7 +15720,11 @@ cjcld cjcli cjcn cjcncf +cjdi cjdiv +cjdivap +cjdivapd +cjdivapi cjdivd cjdivi cjex @@ -8905,12 +15742,15 @@ cjmulrcli cjmulval cjmulvald cjmulvali +cjn cjne cjneg cjnegd cjnegi cjnpoly cjoin +cjoins +cjordan cjre cjreb cjrebd @@ -8921,54 +15761,132 @@ cjsub cjsubd cjth cju +cjump cjval cjylttltnagowaprewbqwh +ckb ckc +ckey +ckoff +ckq +ckqowsa ckt cla +claadd clab clabel clabt clabtv clabv +clacarr claim +claimed +claiming claims clam +clambda +clambdad clamp +clannot +clarger +clarified +clarify clarity clarsimp clas +clases clash +clashed +clashes clashing class +classa +classaccessflags classargs +classb classcast +classclass +classclassname +classconstantpool +classconstructortests classd classdef classdefre classdefreducibility +classe classes +classesp classexpr +classfile +classfilep +classfun +classg +classgidl +classgidr classgroup classi classic classica classical classicalfacts +classicallogic +classically +classicalpropositionallogic +classicalpropositionalsequentcalculus classicalrecon +classicalsep +classicloop classicmark +classicp +classict +classicw +classifi +classifica classification classified classifier +classifiers +classifies classify classifying +classifyingspace classifyingspaceuniversalcover +classimplementsinterface +classinterfaces +classisinterface +classistypesafe +classk +classlist +classm classmain +classmetricspace +classn +classnam classname +classnames classnumber +classop classp +classreify +classrep +<<<<<<< Updated upstream +classroom +======= +>>>>>>> Stashed changes +classs +classsayseight +classsupe +classsuper +classsuperclassname +classt +classtabl +classtable +classtableenv +classtableenvironment classtocong +classvg clat +clataugmentation clatglb clatglbcl clatglble @@ -8979,34 +15897,61 @@ clatlem clatlubcl clatp clatpos +clatt clattice +clau +claude +claus clausal clause claused +clauseempty clausefalse clausefalseinprefixtolastassertedliteral clausefalseremove +clauselit +clausen +clauseor clauseorderirrelevant +clausep clauses clauseset +clausesp clausetautology clausetopropf clausetrue clausetrueremoveduplicateliterals clausetrueremovefalseliterals +clausexy +clausifier +clausify +clausura clb +clbasis +clbuffer clc +clcatantiisomorphism +clcatequivalence +clcatex +clcatisomorphism +clcatuniq clcllaw clcnvlem +clcodomain +clcongruence +clcontravariantfunctorex +clcovariantfunctorex cld cldbnd cldcls cldcss clddisj +cldiese cldllycmp cldlp cldmre cldmreon +cldomain cldopn cldrcl cldregopn @@ -9021,23 +15966,45 @@ cle clea clean cleanbinders +cleanchans cleanconsts cleaned cleaner +cleaning +<<<<<<< Updated upstream +======= cleaningdevice +>>>>>>> Stashed changes +cleannumber +cleans +cleanse +cleansed +cleanses +cleanu cleanup cleanupannotations +cleanupbodyproof cleanupcasts cleanuplemmas clear clearall clearauxdeclsinsteadofrevert +clearbit clearbody +clearcache +cleared +clearer clearexcept +clearexclusivebyaddress +clearexclusivelocal clearing clearjunk +clearkey +clearloop clearly +clearn clears +cleave clel clelab cleljust @@ -9047,27 +16014,50 @@ cleljusti clelsb clem clemb +clemma clen +clength +clens +clenv +<<<<<<< Updated upstream +======= cleptotyphlopidae +>>>>>>> Stashed changes cleq cleqf cleqh +cless +clet clever clex clexab +clf +clfi +clfintop +clfv clg clhash +clhomomorphism +clhs cli click clickable +clicochrcompl +clicocomplchr +clicomplsta client clientcache clientid clientiohandler clientnethandler +clientofnewreferences +clientpass clientrequest +clientrequesttoken clientresponse clients +clientsupplier +cliff clifford cliffordalge cliffordalgebra @@ -9080,23 +16070,38 @@ cliftet clifteta cliftetb clight +clightaxioms clightconcursem clightcoresem +clightdefs +clightmachine clightmachinesem +clightnew clightselfsim clightsem clightsemanticsformachines +clightstep +<<<<<<< Updated upstream +======= clike clikely clikes +>>>>>>> Stashed changes clim climabs climadd climaddc climaddf +climagemap +<<<<<<< Updated upstream +climate +======= +>>>>>>> Stashed changes +climb climbdd climbddf climcau +climcaucn climcj climcl climcn @@ -9105,6 +16110,7 @@ climcnds climcndslem climconst climconstmpt +climcvg climd climdivf climdm @@ -9152,6 +16158,7 @@ climrecf climrecl climreclf climreclmpt +climrecvg climreeq climrel climres @@ -9164,6 +16171,7 @@ climrlim climserle climshft climshftlem +climshftlemg climsqz climsub climsubc @@ -9180,25 +16188,43 @@ climxlim climxrre climxrrelem climz +cline clinear clinit +clink clintop clintopcllaw clintopval +cliopt clique +cliquecover +cliquecsg cliquefinset cliquefree cliquefreeon cliquenum cliquenumber +cliqueon cliques cliqueset +cliquesubno +clirstacr +clisp clist +clistacompl +clit +<<<<<<< Updated upstream +======= clively +>>>>>>> Stashed changes cljzrib clk +clkassignlist +clkgates clkp clks +clkskew +clkt clkvt cllaw cllem @@ -9208,6 +16234,7 @@ clmabs clmacl clmadd clmapplyconst +clmat clmcj clmcompapply clmfgrp @@ -9231,6 +16258,7 @@ clmsub clmsubcl clmsubdir clmsubrg +clmul clmvneg clmvs clmvsass @@ -9271,21 +16299,56 @@ clnbupgreli clnbusgrfi clneighbvtx clo +clochard clock clocked +clocking clocks +clockupd +clockwise +clockwisebca +clockwisebetween +clockwisebetweenamc +clockwisebetweenclockwise +clockwisebetweenmbc +clockwisecab +clockwisecdb +clockwiseclockwisedistinct +clockwisedca +clockwisedistinctab +clockwisedistinctbc +clockwisedistinctca +clockwiseeq +clockwiseexists +clockwisenotbetweenabc +clockwisenotclockwise +clockwisenotcollinear +clockwisenothalfline +clockwisenotnullside +clockwisetrianglespec +clockwiseuuoovv +clod +clofun +clofuns clog -clogician clogzpowgi +clol clone cloned +clones +cloning +cloop clop +clopban clopen clopenable clopenbasis +clopenness clopens clopenupperset +clopers clos +closc close closecomment closed @@ -9307,11 +16370,15 @@ closedcomplemented closedconvexhull closedcounit closedd +closede closedeball closedembedding closedembeddingcfc closedembeddingcontinuousfunctionalcalculus closedfield +closedfieldaxiom +closedfieldtype +closedform closedgraphthm closedi closedicitop @@ -9320,10 +16387,18 @@ closedihom closediictopology closedin closedinterior +closedir +closedl closedm +closedmonoidal closedn +closednattoterm closedness +closednn +closednucleus closedofhasleftdual +closedp +closedpa closedph closedpoint closedpoints @@ -9334,7 +16409,10 @@ closedsgc closedsieves closedsubgroup closedsubmodule +closedsubset closedsupport +closedsystem +closedt closedunder closedundercolimits closedundercolimitsofshape @@ -9346,15 +16424,30 @@ closedunderrestriction closedunit closedv closedz +closee +closeenbhs +closeeonbhs +closefd +closefrom +closei +closein +closel +closelist closely closemaingoal closeness +closenessspace +closenv +closeout +closep closepcp closepoints closepost closepsp closepss closer +closerlistp +closertlistp closes closest closestc @@ -9377,6 +16470,7 @@ closestmineq closestminormax closestmonotone closestopp +closestp closestprophigham closestroundedmodep closestsymmetric @@ -9384,13 +16478,28 @@ closesttotal closestulp closesubst closesubsteqvt +closi closing +closlang +closnoinline +closp +clospace +closprops +closrec +clossem +clossure closu closur closure closureantitone closurecommutatorrepresentative closurecommutatorrepresentatives +closureconversion +closureconvert +closureconvertedmap +closuree +closureecluster +closureecvg closureequivadjoinint closureequivadjoinnat closurehascore @@ -9399,13 +16508,38 @@ closureisclosable closurem closurenonunitalcommringofcomm closureoperator +closureoperatorhasresidual +closurep closures +closurestr +closuresubsetoperatorunique +closuresystem +closuresystems +<<<<<<< Updated upstream +======= clothesdryer +>>>>>>> Stashed changes +cloud +cloudhsmclusteridtype +cloudwatchloggrouparn +clov +<<<<<<< Updated upstream +======= cloxocemidae +>>>>>>> Stashed changes +clp +clpart clpjq clprehaar clq +clr +clrat clrellem +clrest +clrhash +clrp +clrps +clrv cls clscld clsconn @@ -9413,8 +16547,11 @@ clsd clsdecl clsdif clselmap +clsepcl +clset clsf clsfval +clsi clsidm clsint clsk @@ -9430,25 +16567,51 @@ clsneinex clsneircomplex clsnsg clsocv +clsp +clspace clss clsscomp clsslem clsss +clsstruct clssubg clst +clstate clstop +clsubframe clsun +clsv clsval +clsys clt +cltl cltn +cltv +clu +club clublem +clubs clubsuit +clue +cluelist +clues clumsy clunky +clus +clust +cluste cluster +clusterchain +clustere +clustereonbhs +clustering clusterpt +clusters clv +clvect +clw clwalks +clweight clwlk clwlkclwwlk clwlkclwwlken @@ -9484,10 +16647,12 @@ clwwlkccatlem clwwlkclwwlkn clwwlkel clwwlken +clwwlkex clwwlkext clwwlkf clwwlkfo clwwlkfv +clwwlkg clwwlkgt clwwlkinwwlk clwwlklem @@ -9499,6 +16664,7 @@ clwwlknclwwlkdifnum clwwlkndivn clwwlkneq clwwlknfi +clwwlkng clwwlknlbonbgr clwwlknlen clwwlknnn @@ -9529,10 +16695,21 @@ clwwnrepclwwn clx clxf cly +<<<<<<< Updated upstream +======= clyle +>>>>>>> Stashed changes +clz +clzprime cmachine +cmacro +cmalt +cmant cmap +cmat +cmatch cmax +cmbi cmbr cmbri cmc @@ -9541,6 +16718,7 @@ cmcm cmcmi cmcmii cmcmlem +cmcons cmd cmddu cmdfval @@ -9549,13 +16727,14 @@ cmdiff cmdiffat cmdlan cmdmdi +cmdof cmdpropd cmdrcl cmds cmdspec -cmeat cmem cmeoprfmhab +cmeps cmessage cmet cmetcau @@ -9568,15 +16747,42 @@ cmetsp cmetss cmextension cmfi +cmgfc cmgmalt cmh +cmi cmib +cmibi +cmid cmidi +cmif +cmifi cmim +cmimi cmin +cminimise +cminle +cminor +cminorsel +cminsel +cminselstep +cminstep +cminus +cmiov +cmiovi +cmis +cmisi cmj cmknlmsvsqdji +cml +cmlg +cmlm +cmlparseexpr +cmlpeg +cmlpegexec +cmlptreeconversion cmlr +cmls cmm cmmbl cmmdi @@ -9593,59 +16799,120 @@ cmnssmndel cmntrcld cmo cmod +cmoddiv cmodscexp cmodscmulexp +cmodz +cmodzz cmono +cmonoid +cmorphisms +cmos cmov +cmova +cmovb +cmovc +cmovcc +cmove cmovi +cmovl +cmovna +cmovnb +cmovne +cmovns +cmovs +cmovznz cmp +cmpabs cmpcld cmpcmet +cmpconst cmpcov cmpcovf cmpcref +cmpdec +cmpe +cmpeo +cmpeq +cmperror +cmperrs +cmpf cmpfi cmpfii cmpfiiin cmpfiref +cmpfn +cmpfs cmphaushmeo cmphmph cmpidelt +cmpk cmpkgen cmpl cmple +cmplu +cmplxhomogeneous +cmplxhomogeneousfaf +cmpop +cmpopsnt cmppcmp +cmpr +cmpres cmps cmpsub cmpsublem cmpt cmptop +cmptun cmpu cmpusing +cmpv +cmpx +cmpxchg +cmpy +cmr +cmrecur +cmreg +cmrep cms +cmsbnn cmscmet cmscsscms +cmseparation +cmseq +<<<<<<< Updated upstream +======= cmsg +>>>>>>> Stashed changes cmsi cmslssbn cmslsschl cmsms +cmspace cmspropd cmssmscld cmsss +cmsxor +cmsym cmt cmtbr cmtcomlemn cmtcomn cmtfvaln cmtidn +cmtr +cmtrcom cmtvaln cmul cmult +cmultm cmulxsubonecotangent +cmval cmvth cmvthold cmwoywbqayok +cmx +cna cnaddabl cnaddabloold cnaddablx @@ -9656,17 +16923,22 @@ cnalt cnambfre cnambpcma cname +cnan cnapbmcpd cnat +cnateint +cnatp cnbdibl cnbebiznfrvhh cnbl cnblcld cnbn +cnc cncdrg cncf cncfcdm cncfcn +cncfcncntop cncfcnvcn cncfco cncfcompt @@ -9711,13 +16983,17 @@ cncongr cncongrcoprm cncongrprm cnconn +cncons cnconst +cncpc cncph cncrng cncrngold cncvcold cncvs cnd +cndbsuc +cndcap cndis cndivrenred cndprob @@ -9728,8 +17004,12 @@ cndprobtot cndprobval cndrng cndrngold +cndsex cne cnegex +cnegexlem +cnel +cnelphi cnelprrecn cnelsubc cnelsubclem @@ -9749,10 +17029,13 @@ cnextstate cnextucn cnextval cnf +cnfand cnfcf +cnfclause cnfcom cnfcomlem cnfdmsn +cnfempty cnfex cnfi cnfld @@ -9799,6 +17082,7 @@ cnfldtopon cnfldtps cnfldtset cnfldtsetold +cnfldui cnfldunif cnfldunifold cnflduss @@ -9806,34 +17090,46 @@ cnfldxms cnflf cnfn cnfnc +cnfp cnfrrnsmf cnfsmf +cnfst cnftopropf +cnfv cnfval cng cngen cnhaus +cnhd cnheibor cnheiborlem cni cniccbdd cniccibl cnicciblnc +cnicgsf cnidold +cnil cnima cnims cnindis cnindmet cnioobibld +cnipc cnj cnjct cnjel cnjer cnji +cnjl +cnjr cnk +cnl cnlem cnlimc cnlimci +cnlimcim +cnlist cnllycmp cnllysconn cnlmod @@ -9894,13 +17190,32 @@ cnnvs cno cnode cnold +cnom +cnone cnonneg +cnonvariant cnop cnopc cnopn +cnopnap +cnopncntop +cnopt +cnoreduct +cnorm +cnormstr +cnot +<<<<<<< Updated upstream +cnotcompf +cnotcompfs +======= cnota +cnotcompf +cnotcompfs cnothing +>>>>>>> Stashed changes +cnovex cnp +cnpair cnpart cnpcl cnpco @@ -9915,14 +17230,22 @@ cnpflfi cnpfval cnpimaex cnplimc +cnplimccntop +cnplimcim +cnplimclemle +cnplimclemr cnpnei cnpos cnprcl cnprest cnpresti cnptop +cnptopco +cnptoprest +cnptopresti cnpval cnpwstotbnd +cnr cnrbas cnre cnrecnv @@ -9931,7 +17254,9 @@ cnref cnrefiisp cnrefiisplem cnrehmeo +cnrehmeocntop cnrehmeoold +cnreim cnres cnresima cnrest @@ -9944,7 +17269,9 @@ cnrmnrm cnrmtop cnrnvc cnrrext +cnrs cns +cnsnd cnso cnsqrt cnsrexpcl @@ -9953,37 +17280,61 @@ cnsrplycl cnss cnsscnp cnst +cnstab +cnstr cnstrcvs +cnstrs +cnsub cnsubdrglem cnsubglem cnsubmlem cnsubrg cnsubrglem cnsubrglemold +cnsuc cnt cntabl +cntadd +cntaddlatest cntce +cntcontrolbase cntd cnte cnth cnti cntj +cntl +cntls +cntlunit +cntlv cntmeas cntnevol cntop +cntopex +cntoptop +cntoptopon cntotbnd +cntp cntr cntrabl cntrcmnd cntrcrng +cntre cntremovel +cntrex cntri cntrnsg cntrss cntrsubgnsg cntrval +cnts cntset +cntupdate +cntupdatec cntupdatel +cntupdater +cntw +cntwd cntx cntxt cntz @@ -10011,7 +17362,13 @@ cntzsubr cntzsubrng cntzun cntzval +cnull +cnum +<<<<<<< Updated upstream +======= cnumber +>>>>>>> Stashed changes +cnumdb cnureq cnv cnvadj @@ -10041,12 +17398,14 @@ cnveqb cnveqd cnveqi cnvex +cnvexb cnvexg cnvf cnvfi cnvfialt cnvi cnviin +cnviinm cnvimadfsn cnvimainrn cnvimamptfin @@ -10054,9 +17413,17 @@ cnvimarndm cnvimass cnvimassrndm cnvin +cnvinfex cnvintabd cnvinxp cnviun +cnvkeq +cnvkeqd +cnvkeqi +cnvkex +cnvkexg +cnvkssvvk +cnvkxpk cnvmot cnvnonrel cnvopab @@ -10064,6 +17431,9 @@ cnvopabold cnvoprab cnvordtrestixx cnvpo +cnvpom +cnvpprod +cnvpr cnvprop cnvps cnvpsb @@ -10077,15 +17447,20 @@ cnvrescnv cnvresid cnvresima cnvresrn +cnvsi cnvsn cnvsng cnvso +cnvsom cnvss cnvssb cnvssco cnvssrndm cnvssrres +cnvswap cnvsym +cnvti +cnvtr cnvtrcl cnvtrclfv cnvtrrel @@ -10094,6 +17469,7 @@ cnvtsr cnvun cnvuni cnvunop +cnvx cnvxp cnvxrn cnxmet @@ -10101,13 +17477,21 @@ cny cnynp cnyp cnyq +cnyy +cnz cnzh coa +coacc coaction coactsimp +coadjointua coafval coahom +coal coalesce +coalescecost +coalesced +coalescing coalg coalgcat coalgebra @@ -10115,29 +17499,56 @@ coalgebraequivalence coalgebraequivover coalgebraiscocomm coalgebraofalgebra +coalgebras coalgebrastruct coalgebratoover coalgequiv coalgequivclass coalghom coalghomclass +coalitiond +<<<<<<< Updated upstream +======= coantidomain +>>>>>>> Stashed changes +coap +coapex coapm coappdup +coappdupaux +coappdupperm +coapplication +coarbcomplete coarbitrary +coarble +coarblepreservesle +coarbpos coarse +coarseasm +coarsening +coarsenings +coarsepiles coarser coarserpartition +coarsest coass coassoc -coastvillage -coat coatom coatomic coatoms +coaut +coautomorphic coaval cob cobdd +cobegin +cobham +cobigstep +cobijectivesch +cobind +cobj +cobo +cobool coborder coborderrange coboundaries @@ -10145,11 +17556,19 @@ coboundariesofiscoboundary coboundariesofismulcoboundary coboundariestococycles cobounded +coboundedi +coc +cocalls cocan cocanfo cocardinal +cocartesi +cocartesian +cocartesiancategory +cocartesianfunctor coccl coccom +cocf cochain cochaincomplex cochaincomplexequivalence @@ -10159,6 +17578,8 @@ cochains cochainsfunctor cochainsiso cochainsmap +cocircular +cocl cocli coclop coclosed @@ -10169,10 +17590,13 @@ coclosure cocnv cocnvcnv cocnvf +cocnvres +cocnvss cocom cocompact cocompactmap cocompactmapclass +cocomplete cocomplex cocon cocond @@ -10237,12 +17661,15 @@ coconesequiv coconesiso coconesisocomponenthom coconesisocomponentinv +coconestwist +coconetwistf coconetypes coconetypesequiv coconetypesiscolimit coconeunop coconeunopofcone cocontinuous +coconustot cocorrect cocossss cocountable @@ -10258,51 +17685,217 @@ cocyclicite cocyclique cocycliques cocyle +cocylinder cod coda +codatatype codchart codd code codeaction +codeand +codeandcorrect +codeandispr +codeapp +codeappcorrect +codeappispr +codearitylnnfiscorrect +codearitylnnr +codearitylnnriscorrect +codearitylnnrispr +codearitylntf +codearitylntfiscorrect +codearitylntfispr +codearitylntr +codearitylntriscorrect +codearitylntrispr +codeaxmeqhelp +codeaxmeqhelpispr +codeblock +codebuffer +codebufferend +codebufferwrite +codec +codeclose +codeclosecorrect +codecloseispr +codecloselist +codecloselistcorrect +codecloselistispr +coded +codef +codeforall +codeforallcorrect +codeforallispr +codeformula +codeformulainj +codefreevarformula +codefreevarformulacorrect +codefreevarformulaispr +codefreevarlistformula +codefreevarlistformulacorrect +codefreevarlistformulaispr +codefreevarterm +codefreevartermcorrect +codefreevartermispr +codefreevarterms +codefreevartermscorrect +codefreevartermsispr +codefreevartermterms +codefreevartermtermsispr codegen codegree +codeidx +codeiff +codeiffcorrect +codeiffispr +codeimp +codeimpcorrect +codeimpispr +codein +codeincorrect +codeinductionschema +codeinductionschemacorrect +codeinductionschemaispr +codeinispr codek +codelength +codelengthcorrect +codelengthispr +codelist +codelistinj +codelistremove +codelistremovecorrect +codelistremoveispr +codelnnrelation +codelnnrelationinj +codelntfunction +codelntfunctioninj +codelntrelation +codelntrelationinj +codem +codenat +codenattoterm +codenattotermcorrectlnn +codenattotermcorrectlnt +codenattotermispr +codenewvar +codenewvarcorrect +codenewvarispr +codenodup +codenodupcorrect +codenodupispr +codenot +codenotcorrect +codenotispr +codensity +codenth +codenthcorrect +codenthispr +codenvars +codenvarscorrect +codeopen +codeopencorrect +codeopenispr +codeor +codeorcorrect +codeorispr codep +codepa +codepacorrect +codepaispr +codepoint +codeprf +codeprfinjaxm +codeptr +coder +coderived codes codesc codescendsalong +codesearch +codeseq +codeset +codeslot +codeslots +codesubformula +codesubformulacorrect +codesubformulaispr +codesubterm +codesubtermcorrect +codesubtermispr +codesubterms +codesubtermscorrect +codesubtermsispr +codesubtermterms +codesubtermtermsispr codesupp +codesyspf +codesyspfcorrect +codesysprf +codesysprfcorrect +codesysprfncorrect +codesysprfnot codet codetecto codetector +codeterm +codetermfreevar +codeterminj +codeterms +codetermsinj +codetree +codetruncs +codeunitseq +codeupd +codewalk +codewalker codewords codextend +codi codiag codiagonal codiagonalobj +codidomj +codiese +codify +codij codim codimension +codin coding codir codirected codirectedon codis +codisc codiscrete codiscreteequiv +codiscreterightadj codiscretewithin codisjoint +codji codlift codom +codoma codomain +codomainiso +codomainisodep codomainisoofbaseiso codomains codomaintopologicalspace codomainuniqueuptoiso codome +codomf +codomfp +codomfpn codomi +codomp codrestrict codrestricteqlocuspushoutcocone codrestrictofinjective +cods +codt codtotal coe coeadd @@ -10319,9 +17912,11 @@ coeclm coecomonad coecomplex coecopy +coed coedeg coedeletevertsiso coedep +coee coeemb coeembedding coeembeddingspanningcoe @@ -10330,14 +17925,25 @@ coeequiv coeeu coeeulem coef +coefb +coefc +coefcm +coefd +coefdl +coefdr +coefe coeff coeffaddequiv coeffaddmonoidhom +coeffe coeffequiv coeffexplicit +coefffunctional coefficient coefficients coeffintegernormalization +coeffl +coefflemma coefflist coeffm coeffmonoidhom @@ -10345,8 +17951,19 @@ coeffof coeffs coeffsin coeffsubmodule +coeficie +coeficiente +coeficientep coefiniteat +coefk +coefm +coefmc +coefmn +coefmnn +coefmr coefmrz +coefmx +coefmxn coefn coefnaddhom coefnaddmonoidhom @@ -10356,19 +17973,32 @@ coefninstance coefnlinearmap coefnmonoidhom coefnringhom +coefp coefromhom +coefs coefsupp +coeft +coeftp coefun coefv +coefx +coefxm +coefxn +coefxnm +coefxsubc +coefxy +coefz coehead coehom coehtc coehtct +coei coeid coeideal coeidealhom coeidlem coeidp +coeilenbergmoore coeinduceiso coelem coelemmas @@ -10396,6 +18026,7 @@ coend coendfunctor coeneighborsetequiv coennrealreal +coenumerable coeorderaddmonoidhom coeorderembedding coeorderhom @@ -10403,6 +18034,8 @@ coeout coeoutaddmonoidhom coeoutmonoidhom coep +coepath +coepathi coepibasisfun coepnat coepnatmonoidhom @@ -10412,6 +18045,7 @@ coepolynomial coepr coeq coeqhom +coeqofisomorphicdiagram coequalize coequalizer coequalizercocone @@ -10420,6 +18054,7 @@ coequalizercofork coequalizercoforkiscolimit coequalizercolimit coequalizercomparison +coequalizeri coequalizeriscoequalizer coequalizeriso coequalizerofsplit @@ -10427,9 +18062,12 @@ coequalizerregular coequalizers coequalizes coequifibered +coer coerc coerce coerced +coercedvalue +coercedvaluevalue coercee coerces coercesimple @@ -10483,6 +18121,8 @@ coextensive cof cofactor cofactorm +cofactorz +cofalse cofan cofanhomequiv cofaninl @@ -10498,11 +18138,21 @@ cofantypes cofcut cofcutr cofcutrtime +cofe +coff coffax coffee coffib coffth cofg +cofib +cofibcw +cofiber +cofibfinspherebouquetmap +cofibinl +cofibinr +cofibiso +cofibonacci cofibrantobject cofibrantobjects cofibration @@ -10522,10 +18172,13 @@ cofinal cofinality cofinitary cofinite +cofinitelycomplete cofinitetopology +cofintop cofipsgn cofix cofixa +cofixk coflat coflim coflton @@ -10540,6 +18193,8 @@ coframe coframeminimalaxioms cofree cofreeequalizer +cofreepresheaf +cofs cofslts cofsmo cofss @@ -10551,6 +18206,8 @@ cofucl cofucla cofulid cofull +cofunctional +cofunctor cofunex cofunexg cofuoppf @@ -10560,17 +18217,36 @@ cofuswapfcl cofuterm cofuval cofuve +cofv cofveqaeq cofveqaeqalt +cogap +cogen cogeneralizedbooleanalgebra +cogenlist coghm coglio +<<<<<<< Updated upstream +======= cognitiveagent +>>>>>>> Stashed changes +cogpies cogrothendieck +cogyro +cogyroaut +cogyrominus coh +cohcat +cohd +cohdom +cohe coheight cohen +coher cohere +cohered +coheren +coherenc coherence coherencecomp coherencehom @@ -10580,13 +18256,37 @@ coherences coherent coherentcoverage coherentextensiveequivalence +coherently +coherentp coherenttopology cohesive coheyting coheytingalgebra coheytinghom coheytinghomclass +cohh +cohhspace +cohi +cohidom +cohivd +cohivs +cohk +cohl +cohmsg +cohmt cohn +cohom +cohomequiv +cohomfun +cohomfunctor +cohomfunid +cohomgr +cohomgroup +cohomhom +cohomiso +cohomk +cohomktype +cohommorph cohomologicalfin cohomologicalnat cohomology @@ -10594,8 +18294,42 @@ cohomologyclass cohomologyfunctor cohomologypresheaf cohomologypresheaffunctor +cohomologyring +cohomotopic +cohomotopically +cohompointedelim +cohompointedelims +cohompointedelimt +cohompushout +cohomred +cohomredgr +cohomredgrdir +cohomredgroup +cohomredgroupdir +cohomrp +cohomsn +cohomtheory +cohomtheorygen +cohomtruncequiv +cohpred +cohq +cohr +cohs +cohsp +cohst +cohstc +cohstl +cohstp +cohun +cohunkl +cohunkr +cohvl +cohvs +cohw coi +coid coideq +coie coim coimage coimageimagecomparison @@ -10605,6 +18339,7 @@ coimageobjiso coimages coimagestrongepimonofactorisation coimisoim +coimp coin coinc coincide @@ -10612,25 +18347,29 @@ coincidence coincident coincides coinciding +coincpoint coincs coind coindep coindependence +coindexedproductof +coindexing coindfunctor coindfunctoriso coindiso coindmap coindresadjunction coindtoind -coindu coinduced coinducingcoprod coinduct coinduction coinductiv coinductive +coinductl coindv coindvequiv +coinflip coinfliplem coinflipprob coinflippv @@ -10639,12 +18378,15 @@ coinfliprv coinflipspace coinflipuniv coinfnattrans +coinhabited coiniss coinitial coinitslts coins +coinvar coinvariants coinvariantsadjunction +coinvariantsch coinvariantsequiv coinvariantsfinsupplequiv coinvariantsfunctor @@ -10666,11 +18408,18 @@ coinvariantstensorresprojectiveresolutioniso coinvariantstofinsupp coinvariantstprodleftregularlequiv coires +coiso +coisterminal +coiszero +coit coiun cok +cokeq coker +cokerco cokeriscokernel cokerisoker +cokermx cokernel cokernelbiprodinliso cokernelbiprodinriso @@ -10714,18 +18463,38 @@ cokernelunopop cokernelunopunop cokernelzeroisotarget cokertoker +cokex +cokexg cokleisli +cokrelk col +<<<<<<< Updated upstream +======= cola +>>>>>>> Stashed changes +colb colcom +colcongmid +colcount cold coldn +<<<<<<< Updated upstream +======= coldtemperature cole +>>>>>>> Stashed changes +colemma +coleq +coleqtheorem +coletsuchthat colex colexicographic colexicographical +colf +colg +colgeq colgt +colh colhp coli colim @@ -10824,26 +18593,43 @@ colinearalg colinearalglem colineardim colinearex +colinearity colinearperm colineartriv colinearxfr colinrel colist +colk +colkl +colkr coll +colla +<<<<<<< Updated upstream +======= collage +>>>>>>> Stashed changes +collap +collaps +collapsable collapse +collapsed collapsef collapses +collapsible +collapsibles collate collatz collatzstep +colle collec collect collectatoms collectd +collectdependencies collecte collected collectedbasis +collectedcommitmentkey collectedorthonormalbasis collectfacts collectfactsimp @@ -10853,13 +18639,21 @@ collectfvars collectfvarsoutsideofproofs collecti collecting +collectint +collectio collection collections +collectionvariance +collectionwise collectisdefeqchecks +collective collectively collectlevelparams collectnodesbottomup +collector collectprefixes +collectproperty +collectrestrict collects collectsorries collecttokens @@ -10870,38 +18664,97 @@ collen colleq collexd colli +collide +collides collideswith colline collinear +collinearaab +collinearaba +collinearabb +collinearacb +collinearbac +collinearbca +collinearbetween +collinearcab +collinearcba +collinearclockwisedistinct +collinearequidistantbetween +collinearhalfline collinearity +collinearitypreserved +collinearmidline +collinearnotclockwiseabc +collinearnotclockwisebac +collinearorder +collinearparallel +collinearright +collinears +collinearsuperimposed +collinearsymmetry +collineartrans +collineation +collinera collint collision collisioni +collisions +colllect +collorary +collprojectiveplane +collprojectivespace +collsp +collstr colmez colmid colmode +colno +colnum +colo +colocal +<<<<<<< Updated upstream +======= cologne +>>>>>>> Stashed changes colon +colonst +colont colookup +coloop coloops colopp color colorabl colorable +coloration +<<<<<<< Updated upstream +======= colorattribute +>>>>>>> Stashed changes colorclass colorclasses +colored +coloredpoint +coloredset coloring +colorings coloringtwo coloringtwoofvert coloringtwoofverts +colorlist +colormax +colornum +colorpool colors +colorused +colossless colour coloured colouring colouringi colourings colours +colp colperp colperpex colperpexlem @@ -10909,17 +18762,35 @@ colr colrot colrow cols +colsrx colstart colstochastic +colsum +coltok +coltpoint coltr +colu columbia column +columnd +columni columnnonzeroofiso +columnround columns columnspace columnvector +colupdate +colvec +colx +colz com coma +comact +coman +comanb +comanblem +comanbn +comanr comap comapaddmonoidhom comapcomp @@ -10956,37 +18827,75 @@ comapstructuresheaffun comapsubgroup comapsubtypeequivofle comapuniformspace +comar +comaximal comb +<<<<<<< Updated upstream +======= combb combc +>>>>>>> Stashed changes +combe +combgras combi combin +combina combinable +combinablee combinablei +combinati +combinatio combination +combinational combinations combinator combinatorial +combinatorialconnectedcwskel +combinatoric combinatorics combinators combine +combinebytes +combinec +combineclemma combinecocones combinecones combined combinediscolimit combinedislimit +combineexpandsdomain combineislimit +combinej +combinelist +combineplus combiner combines +combinesortedsplit +combinesplit +combinewith +combing +combini combining +combjoin +<<<<<<< Updated upstream +======= combk +>>>>>>> Stashed changes comblinear combo combpairhoms combpairiscolimit combpairislimit +combrows combs +<<<<<<< Updated upstream +======= combustion +>>>>>>> Stashed changes +comcmtr +comcom +comd +comdr come comember comembers @@ -11000,16 +18909,22 @@ comfffn comfffval comffn comffval +comfortable comfval +comg comi +comid coming +comisd comk coml comlaw comlist comm comma +commacat commacategory +commacomp commadd commafromover commafromunder @@ -11017,6 +18932,10 @@ commafst commalgcat commalgcatequivunder commalgebra +commalgebraequiv +commalgebrahom +commalgebrapath +commalgebrastr commalgequiv commamapequivalence commamapequivalencecounitiso @@ -11024,36 +18943,58 @@ commamapequivalencefunctor commamapequivalenceinverse commamapequivalenceunitiso commamorphism +commamorphs command commandcontextinfo commandctx commande +commanded commandelab commandelabm +commandline +commandp commandranges commandrangeslinter commands +commandsp commandstart commaobj +commaobjs commapplicative commas commasep +commasuffix +commat commatogrothendieckprecompfunctor commbialgcat commbialgcatequivcomoncommalgcat commclosure commcstaralgebra +comme commelin commenced commensurable commensurator comment +commentary commented +commenting +commentmap comments -commercialservice commf commfst +commfun +commfunctor commg +commgac +commgc +commgcv +commgel +commger +commgg +commgmj +commgmr +commgp commgroup commgroupaddcommgroupequivalence commgroupisotomulequiv @@ -11076,31 +19017,60 @@ commgrpobj commgrptypeequivalencecommgrp commgrptypeequivalencecommgrpforgetcommmon commgrptypeequivalencecommgrpforgetgrp +commgs +commgss +commgv +commgvg +commgx +commgxg +commgxvg commi +commideal commil comminl commirn commiso commisometry commit +commite +commited commitifnoex commitindex +commitm commitment +commitmentkey +commitmentkeycheck +commitmentpolicy +commitmentpolicytype +commitments +commits +committ committed +committedprocsequal committee committees +committhenvoterecent +<<<<<<< Updated upstream +======= committing +>>>>>>> Stashed changes commitwhensome commixin +commk commkl commkrn commks commliegroup commlrn commls +commlshiftupcast commm +commma commmagma commmap +commmg +commmgj +commmgr commmon commmonadj commmoncat @@ -11110,6 +19080,11 @@ commmonfunctorcategoryequivalence commmono commmonoi commmonoid +commmonoidequiv +commmonoidhom +commmonoidpath +commmonoidprod +commmonoidstr commmonoidwithz commmonoidwithzero commmontolaxbraided @@ -11117,6 +19092,9 @@ commmontolaxbraidedobj commmontypeequivalencecommmon commmontypeequivalencecommmonforget commmul +commmulext +commmutativity +commo common commonarefl commondenom @@ -11128,12 +19106,18 @@ commoninttangents commonknowledge commonly commonneighbors +commonprefix commonretraction +commons commonsection +commonsystemsconversions commontangents +commontheory +commonusecase commp commprob commr +commrd commri commright commring @@ -11142,9 +19126,23 @@ commringcat commringcatisotoringequiv commringcatstalkequivmodulestalk commringequiv +commringequivisocommringiso +commringhom +commringiso +commringisoisocatiso +commringpath commringring +commringscategory +commringstr commringyoneda +commrm +commrmn +commrmz +commrn commrns +commrv +commrx +commrxz comms commsem commsemi @@ -11160,6 +19158,7 @@ commsemiringnozerodivisors commsemiringsemilinear commsemiringsemiring commsemiringtopologicalclosure +commsg commshift commshiftcore commshiftfunctor @@ -11178,21 +19177,34 @@ commsnl commsnrn commsq commsqofhasstrongepimonofactorisation +commsquare +commsquareequiv commsquarem commstrictorderedring +commsubcomplex +commt commte commtensorleft commtensorright commtn commtrianglem commu +commuativity +communicate communicating +communicatingd communication communications +communitive +communitivity community commut +commuta commutant +commutaor +commutati commutation +commutativ commutative commutativemagma commutativemonoid @@ -11200,25 +19212,45 @@ commutativering commutativesemigroup commutativesemiring commutativesemiringwithoutone +commutativesquare commutativesquarepresenter commutativetrianglepresenter +commutativit commutativitiy commutativity +commutativy commutator commutatorelement commutatormap commutatorrepresentatives commutatorring +commutators commutatorset commute commuted +commutei +commutem commutes +commutesum +commuteunionfinestpart +commutev commutewith +commutex commuting +commutingsquare commutingsubgroups +commutitive +commutitivity +commutivity +commvg commx +commxg +commxxg commz +como +comoand comof +comofv comoid comon comona @@ -11249,12 +19281,18 @@ comonequivalence comonfunctorcategoryequivalence comonobj comonoid +comonotonic comontomonopop comontomonopopobj comontomonopopobjmon +comor +comorr comp +compa compab +compability compact +compactbelow compactconvergence compactconvergenceclm compactconvergenceuniformity @@ -11262,11 +19300,14 @@ compactcovering compactd compactdomain compactdvr +compacte compactexhaustion compacticcspace compactification compactifications compactin +compactinterval +compaction compactly compactlycoherentspace compactlygenerated @@ -11283,13 +19324,16 @@ compactness compactopen compactopens compactoperator +compactp compactrelation compacts compactset compactsets compactspace +compactsublatt compactsupport compactt +compactu compactum compactumtocomphaus compactumtocomphauscompforget @@ -11308,14 +19352,37 @@ compalongorderedfinpartitionl compalongorderfinpartition compalternatingmap companion +companionmx +companionmxk +company compar +compara +comparabl comparable +comparableleibnizeq +comparablelt +comparableltstrictorder +comparablep comparables +comparablet +comparableusualeq +comparablexx comparatively comparator compare +<<<<<<< Updated upstream +compareandswap +======= +>>>>>>> Stashed changes +compareanything +compareanythings +compareb compared +comparedisplays compareequiv +comparef +comparefloat +comparefloatinner comparehyp comparehypeq comparehyple @@ -11323,15 +19390,25 @@ comparehyplt comparelex comparelist comparelistspec +comparem +comparenth compareoflessandeq compareon +comparep comparepkg comparepointwise +comparer comparereals +compareregression compares +comparespec +comparespect comparest +comparetype +comparew compari comparing +comparision comparison comparisonadjunction comparisone @@ -11341,6 +19418,8 @@ comparisonl comparisonleftadjointhomequiv comparisonleftadjointobj comparisonn +comparisonnan +comparisonregressions comparisonresult comparisonrightadjointhomequiv comparisonrightadjointobj @@ -11352,7 +19431,14 @@ compassmallfunctorequivalenceinverse compat compatat compatatm +compatatmsyntactic +compatb compatch +compatcheckcore +compatcons +compatcurrye +compatcurryp +compati compatibilities compatibility compatibilitycounit @@ -11360,29 +19446,54 @@ compatibilityofzerosofiscolimitcokernelcofork compatibilityofzerosofislimitkernelfork compatibilityunit compatibilitywithproductassociator +compatibilty +compatibl compatible compatibleequivgeneratesievecompatible +compatiblei compatiblemaps compatiblep +compatiblepick compatiblepreserving compatiblepreservingofflat +compatibleproperty compatiblering compatibleringofmodelfield compatibleringofring +compatibles compatiblescalar compatiblesm compatiblesmul compatibleyonedafamily +compatifchsyntactic +compatmodname +compatorderadd +compatordermult +compatprchsyntactic +compatt +compattst +compattstsyntactic +compbiinv +compbiinvidl compbilinform compc compcert +compcertforwardsimulation +compcertstep +compchainmap compchangeofvariables +compcirc +compclass compclm compclmofantilipschitz compclmofcontinuouslinearequiv compclosure compcm compcolimiso +compcomm +compcommalgebraequiv +compcommringequiv +compcomplex compconstiso compcontin compcontinuous @@ -11410,28 +19521,57 @@ compdefinedi compdefop compder compe +<<<<<<< Updated upstream +======= compeex +>>>>>>> Stashed changes +compefct +compell +compembedding +compen +compensate compensation +compenv compeq compequiv compequivalencefrommodelinverseiso +compequivequivid +compequividequiv +comperator compet +compete competes +competing +competition competitive compeval compevaluation compexactvalue +compextract +compf +compfincellapprox +compfinchainmap +compfk compflipuncurryiso compfold compforgetaugmented compforgetaugmentediso compformalmultilinearseries +compfs compfst compfun compfuncaraudiosystem compfunctor compfunctorforgetofisthin +compfv +compfvk compgrothendieckproj +compgroupequiv +compgrouphom +compgrouphomassoc +compgrouphomid +compgroupiso +comph comphahnseries comphat comphaus @@ -11446,30 +19586,60 @@ comphomeomorph comphoms compi compid +compil +compilability +compilable +compilableextension compilation compile +compileandexport +compilecorrect compiled compiledecl compiledefn +compiledfunction +compiledfunctioncaller +compiledinit +compiledmethod +compiledmethodcaller +compiledordinalcellisoneormore compileexpr compileinductive compileinductiveonly +compilenv compileprim compileprog compiler +compilercorrectness +compilers compiles compilesizeof +compilestmt +compilestmtcorrect compilestruct compilestructonly compiling +compimm +compind +compindne +compint compinv compinverseiso compiso +compisoidl +compisoidr +compj +compji +compkf compl +complab complain complained complaining complains +complb +compld +compldif comple compleds compledsrec @@ -11484,26 +19654,41 @@ compleftringhom complem complembedding complembeddingof +complemen complement +complementable complementaire complementary +complementation complemented complementedlattice complementeds +<<<<<<< Updated upstream +complementp +complements +complementta +======= complementimpcomplementintersect complementinpowersetcomplementintersect complementof +complementp complements complementsubsetcomplementintersect complementt +complementta complementtcontrasubset complementte complementti complementtnotintersectt complementunioninpowersetcomplement +>>>>>>> Stashed changes complen compleq +compleqb +compleqd +compleqi complequiv +compleset complet completable completabletopfield @@ -11538,6 +19723,7 @@ completegraph completehomogeneoussymmetric completei completeintegralclosure +completel completelat completelatti completelattice @@ -11559,17 +19745,26 @@ completelypositivemapclass completelypseudometrizablemetric completelyregularspace completemultipartitegraph +completenat completeness +completenormedmodtype +completenormedmodule completeorthogonalidempotents +completep completepartialorder completepseudometrizable +completerelstr +completeresult completes completesemilatticeinf completesemilatticesup +completeset +completesgraph completespace completesublattice completesubspace completet +completeta completetheory completetype completing @@ -11577,11 +19772,20 @@ completion completionfunctor completionhom completioninfo +completionof completions completionseparationquotientequiv +completionxxx complex +complexalgebra +complexalgebrastr complexbanachalgebra +complexbanachspace complexbasis +complexblalgebra +complexboundedfu +complexboundedfunctions +complexboundedfunctionsnorm complexcomposition complexcon complexconfig @@ -11589,51 +19793,92 @@ complexconj complexconjugate complexcontinuousexpcomp complexcstaralgebra +complexd complexemb complexembedding complexes +complexfuncadd +complexfuncextmult +complexfuncmult +complexfuncunit +complexfunczero +complexg +complexhilbertspace complexification complexity complexlinearisometryequiv +complexlinearspace complexmeasure complexmgf complexnormed +complexnormspace +complexnummixin complexoffunctorstofunctortocomplex complexofreal +complexopensets complexorder complexorderlemmas +complexp complexplane +complexpredicate complexringequiv complexs complexscalars +complexsequence +complexsequences complexshape complexstarmodule +complextoo complextoreal +complexunitaryspace complexvalued +complexvectspace +complf +complfld +complgc complgraph +compli compliance +compliant complicated +complication complications compliehom complies complimitfunctoriso +complimm complinearequiv complinearmap complinearmapmultilinear +complk +complllattstr +complmap +complmx complocalizationawayalghom complorderiso complp complpl +complrelstr compls +complsp complss +complstr compltete +complu +complulattstr complusgraph +complv +complvect +comply +complying compmap compmeasurable compmeasureprese compmeasurepreserving +compmonad compmono compmonoidhom +compmonotone compmulhom compmultilinear compmultilinearmap @@ -11644,45 +19889,118 @@ compnattrans compne compneg compnonunitalalghom +compnp compo +compoare +compond +compone +componen +componenent +componenet component componentcompl componentcomplfunctor componentcomplmk +componentd componenthom +componentj +componentp components +componentset +componentsp componentsrev +componenttyp +componenttypes componentwise componentwisediagram +compoo +compopp +compos +composability composable composablearrows composablearrowsfunctor +composablei compose +composeall composeandsheafify +composeapplicative +composecellmap +composecomposefn composed +composedata +composedresidual composees +composeex +composefincellmap +composefinsequencemap +composefn +composefnassoc +composefnid +composefntype +composefun +composefunassoc +composefunctors +composefunid +composefuntype +composegraphfns composei +composememinj +composeo +composeoptn +composepartial composepath composerel composes +composesequencemap +composesigmaformula +composesigmarepresentable +composestoid +composetype +composetypedfn +composetypedfun +composevalg +composi composing +composit composite composites +compositi composition +compositiona compositional compositionality compositionasset compositionassetequiv compositionequiv compositionfintype +compositionisassociative +compositionof +compositionpreservation compositions compositionseries +compositor +compote +compoun compound +compounding +compoundstmt +compoundterm +compoutput compow +compower compp comppartialsumsource comppartialsumtarget comppartialsumtargetset +comppath +comppathl +comppathlequiv +comppathp +comppathr +comppathrefl +comppathrequiv +comppefct comppfsc comppmap comppreadditiveyonedaiso @@ -11691,22 +20009,45 @@ comppresheafmap comppro compprod compproj +<<<<<<< Updated upstream +======= compprop +>>>>>>> Stashed changes +compproprel compquadraticmap compquasime compquasimeasurepreserving +compquaternion compr +comprat compre +compreal +comprebr +compredr +comprefix comprehensible comprehension +comprehensionnoalias +comprehensions +comprehensive +comprehensivepredicatetest comprel comprelationaux +compren +comprerator +compres compresolutionnattrans compress compressed compressedi +compressedqd +compresses +compressing compression compressions +compresslength +compresspublickey +compresspublickeyensurespublicly compright comprightalghom comprightcontinuousmap @@ -11715,29 +20056,51 @@ comprightiso comprightl compringequiv compringhom +comprobar +compromise +compromises comps compsec +compseq +compseqchoice +compsequenceiso +<<<<<<< Updated upstream +======= compset +>>>>>>> Stashed changes compsl compsnd compsource +compsp compspec compspecs +compspect compss compsscnv compsscnvlem compssiso +compst compstaralgequiv compstaralghom +compstr compstruct compsubconstclm +compsubst +compsurjection +compsurjective +compsym compt +compted comptendsto comptiunov +comptr comptranspose +comptree +comptrig comptriple compts comptwosquare +compu compuliftcoyonedacompwhiskeringleft compuliftcoyonedaiso compuliftyonedacompwhiskeringleft @@ -11745,125 +20108,261 @@ compuliftyonedaisouliftyonedacomplan compuniqfunctor compuniqinverse compunit +compurge +compustate +comput computa computability computable computableaux +computablefn computableinpolytime computableintime +computableparam computablepred computably +computat computation computational computationally computations computatition compute +computeack +computeaddends computeasymptotics +computecmpconst computed computedkeys computeemptyspace +computeerror +computeevalstrongrechelp +computefactorial computehybrid +computeinc +computeisrelaxedprefix computekind +computelib +computelza computemap +computemax +computemd +computemi +computemissives +computeprod +computeq computer +computerdivision +computeres +computeresponse +computeresponses +computeresults +computeriso +<<<<<<< Updated upstream +======= computerprogram +>>>>>>> Stashed changes computes +computesettoorderedsequence +computesmissives +computestmissives +computesum +computetmissive +computetmissives +computewithfp +computi computing +computtmisives compv compvalidv +compvf +compvkf compwithzero +compwosetequiv compyonedacolimitisocolimitcompyoneda compyonedacompwhiskeringleftmaxright compyonedaiso compyonedasectionsequiv +compzringtype +compzsemiringtype comr comraddd comraddi +comreg comring comringmixin comringtype coms comsectyping +comsendpost +comsendserverreq +comseq +comsign +comsub comt comtvd comul comulalghom comultiplication +comunitringtype +comutativity con +conaffm +coname conat +conatural conax +conb conc +conca concat +concatapp +concatassociativity +concatbyte +concatbytes +concatbytevec concatcm +concatd concatenate +concatenatecorrectlyreadbyteranges concatenated concatenates +concatenateseqs +concatenating concatenation concatenations concatfn concati +concatl concatmap concatmapl +concatmaplemma +<<<<<<< Updated upstream +concatmaplength +======= +>>>>>>> Stashed changes concatmaps concatmapstep +concatmod +concatmor +concatnil +concatpartial concatrec concatrecaux +concats concatsubpath +concatt concatwith concave concaveon concavity concd +<<<<<<< Updated upstream +concend +concentric +concept +======= conceivedthru conceivedthruitself +concend +concentric concept conceptioninvolves +>>>>>>> Stashed changes +conceptlattice concepts +conceptstr +conceptua conceptual +conceptualize conceptually concern +concerned concerning concerns +concert +concf conci +concise conciseness concl concls +conclu conclude concludes +concluding +conclue +conclus +conclusi +conclusio conclusion conclusioni conclusions conclusiontype concom +concordance concours +concp +concprimcom +concprimexpr +concr +concra +concraa +concredge +concret concrete concretecatego concretecategory +concretecategoryex concretecategoryhom +concretecategorylambda +concretecategoryquasilambda +concretecategoryuniq +concretecatequivalence +concretelist concretenesssemantics +concretep +concretewf +concretization +concretize +concretized +concrgba +concrinit +concrtrans concur concurrent concurrentcompilercorrectness concurrentcompilersafety concurrentd concurrenti +concurrentmethod +concurrentprogramminglanguage +concursemantics +concy concyclic cond +condaddext condan +condandc condb +condc condcdf +condcold +condcutext condd conddis conddistrib conde +condefs condensation +condense condensed condensedmod condensedset condensedsettocompactlygenerated condensedsettotopcat condeq +condexitlast condexp condexpind condexpindl @@ -11871,17 +20370,23 @@ condexpindsmul condexpk condexpkernel condexpl +condexpr condexpunexpander +condf condfalse condhighcompositionality condi +condimm condindep condindepfun condindepset condindepsets +condinv conditi condition conditional +conditionalcompareimmediate +conditionalize conditionally conditionallycompletelattice conditionallycompletelatticeoflatticeofsinf @@ -11893,11 +20398,28 @@ conditionallycompletelinearorderbot conditionallycompletepartialorder conditionallycompletepartialorderinf conditionallycompletepartialordersup +conditionals +conditionalselect conditionaltop +conditioned +conditionholds +<<<<<<< Updated upstream +conditioning +conditionis +======= conditionhyper conditionhypo +conditioning +conditionis conditionnormo +>>>>>>> Stashed changes +conditionokl +conditionoknl +conditionoknlp +conditionpassed conditions +conditiont +condk condkernel condkernelborel condkernelcdf @@ -11905,20 +20427,38 @@ condkernelcountable condkernelreal condkernelunitborel condkernelunitreal +condl condless +condlessd condlexp condlexpunexpander +condloop condlowcompositionality condm +condn +condorcet +condoverride +condr +condreds +condredsthrow +condreg condrule +condrwt conds +condse condsi +condsp +condswap +condt +condtion condtrue conduct conductor conductorset condunexpander +condv condvar +condwp cone coneat coneatfunctor @@ -11927,6 +20467,9 @@ coneback conecomb conecompeval conecompevaluationofconecompdiagramfunctorcompevaluation +conected +conective +conectives conediscretecomp coneequiv coneequivcounitiso @@ -11936,11 +20479,14 @@ coneequivinverse coneequivinverseobj coneequivunitiso coneequivunitisoapp +conefield conefromconvex +conefs conefunctorenrichedhom conehull coneleftopofcocone conelift +conelike conemorphism coneofadj coneofcoconeleftop @@ -11966,6 +20512,7 @@ coneofsection coneofsectioncompcoyoneda coneofsectioncompyoneda coneop +conep conepoint conepoints conepointsisoofequivalence @@ -11973,6 +20520,7 @@ conepointsisoofnatiso conepointuniqueuptoiso conepost conepostiso +conepresheaf conept coneptofconeforget conerightopofcocone @@ -11984,33 +20532,60 @@ conesequivinverse conesequivinverseobj conesequivsievecompatiblefamily conesequivunitiso +coneset conesiso conesisocomponenthom conesisocomponentinv +conestwist +conesunit +conetwist +conetwistf coneunop coneunopofcocone +conexts conf +<<<<<<< Updated upstream +conference +======= +>>>>>>> Stashed changes +confexp +confi confid confidasstr +confidence confidential confids config +configerror +configgc configitem +configlist configs configuration configured confine +confined +confinedp +confirm confirming confl conflating +conflic conflict +conflictd conflicted +conflictfree +conflictin +conflicting +conflictingp conflictrange conflicts confluence confluent confluentd +confluenti confluentreduce +conform conformal conformalat conformalfactorat @@ -12020,10 +20595,14 @@ conformalintocomplexplane conformality conformalpregroupoid conformance +conforming +conforms confs conft confts confun +confuncs +confuse confused confuses confusing @@ -12032,21 +20611,54 @@ cong conga congabseq congadd +congah congal +congc congd conge congen +congequh +congequiv +congfunct +congg +congh congi congid +congidleft +congidright +congiso congl +conglist congls +congm +<<<<<<< Updated upstream +congmap +======= +>>>>>>> Stashed changes +congmaybeequiv +congmayberel congmul +congnatiso congneg +congp +congpath +congpathd +congpathequiv +congpathiso +<<<<<<< Updated upstream +congplus +======= +>>>>>>> Stashed changes +congquot congr congraddequiv congrarg congrargkind +congrcl congrcore +congrd +congrence +congrent congrep congrfullsubcategory congrfun @@ -12057,6 +20669,7 @@ congrimplies congrindexoneofeq congrindexoneofeqiso congrisometry +congrlatt congrleft congrleftfunctor congrleftringequiv @@ -12074,6 +20687,7 @@ congrright congrrightfunctor congrrightringequiv congrsimp +congrspace congrtheorem congrtheoremexpr congrtheoremexprs @@ -12082,25 +20696,88 @@ congrtheorems congrthm congrthmproof congrthmtype +congru +congruenc congruence +congruenced +congruenceflip +congruencei +congruencep +congruencequotient congruences congruencesubgroup congruencesubgroups congruencesubsetweakbisim +congruencesymmetric +congruencetransitive +congruencia +congruency congruent +congruentness +congruentopp +congruentopposedstricttriangles +congruentopposedtriangles +congruentoppparallelogramm congruentp +congruentstricttriangles +congruentstricttrianglesa +congruentstricttrianglesab +congruentstricttrianglesacb +congruentstricttrianglesasaab +congruentstricttrianglesasabc +congruentstricttrianglesasaca +congruentstricttrianglesb +congruentstricttrianglesbac +congruentstricttrianglesbc +congruentstricttrianglesbca +congruentstricttrianglesc +congruentstricttrianglesca +congruentstricttrianglescab +congruentstricttrianglescba +congruentstricttrianglessasa +congruentstricttrianglessasb +congruentstricttrianglessasc +congruentstricttrianglessym +congruenttriangles +congruenttrianglesa +congruenttrianglesab +congruenttrianglesacb +congruenttrianglesb +congruenttrianglesbac +congruenttrianglesbc +congruenttrianglesbca +congruenttrianglesc +congruenttrianglesca +congruenttrianglescab +congruenttrianglescba +congruenttrianglessasa +congruenttrianglessasb +congruenttrianglessasc +congruenttrianglessym congruentz congs +congsquare congsub +<<<<<<< Updated upstream +congsucc +======= +>>>>>>> Stashed changes +congsuspequiv +congsuspiso congsym congtoclass congtr +conguh congw coni conic conical +conidnone +conidtyped +coniduntyped conimpf conimpfalt +conistent conj conja conjact @@ -12108,73 +20785,165 @@ conjae conjalgequiv conjaut conjby +conjc conjcae conjcases +conjcg +conjci +conjck +conjcl conjclasses conjcle conjcontinuousalgequiv +conjcr conjd +conjdg conje +conject conjecture +conjectures conjeq +conjer conjexponent +conjf conjg conjga +conjgc +conjgcv +conjge conjghm +conjgi +conjgid +conjgie +conjgik +conjgim +conjgk +conjgkv conjgl +conjgm +conjgme +conjgv +conjhl +conjhr conji +conjig conjinvariantsubalgebra +conjith +conjjg +conjk conjl conjlie +<<<<<<< Updated upstream +======= +conjline +>>>>>>> Stashed changes +conjlinv +conjlist +conjm conjmap +conjmg +conjminv conjmul +conjmulap conjmuldistribmulaction +conjn conjneg conjnegringhom conjnmz conjnmzb conjnormal conjnsg +conjo +conjoi conjoin +conjoined +conjoining +conjoinresults +conjonction +conjp conjr +conjrg conjringequiv +conjrinv conjrootclass conjs +conjsg +conjsge +conjsgk +conjsgkv +conjsgm +conjsmg +conjsplit +conjsrg conjstaralgaut conjstaralgequiv conjsubg conjsubgen +conjt +conjtg conjtranspose conjtransposeaddequiv conjtransposelinearequiv conjtransposeringequiv +conju conjug +conjugacy +conjugages +conjugat conjugatable conjugate conjugatecomposition +conjugated conjugateequiv conjugatei conjugateisoequiv conjugateisomorphism +conjugatek +conjugateny +conjugatep +conjugatepathequiv conjugates conjugatesof conjugatesofset +conjugatess conjugateunits +conjugatey +conjugati conjugating conjugation conjugations conjugator +conjun conjuncive conjunct conjunction +conjunctionof +conjunctionp conjunctions +conjunctionsp conjunctive conjunctived conjunctivei +conjunctprotod conjuncts +conjunctsp +conjuntion +conjvg +conjxg +conjyg +conk conker conlat +conless +conln +conlude +conmap +conmetr +conmutative +conmutatividad +conmute conn +conna connclo conncn conncompcld @@ -12182,12 +20951,16 @@ conncompclo conncompconn conncompid conncompss +connd conndisj +conne connec connect connectable +connectcustomkeystoreensurespublicly connecte connected +connectedcoconustot connectedcomp connectedcomponen connectedcomponent @@ -12203,51 +20976,109 @@ connectedcomponentslift connectedcomponentsmap connectedcomponentstypetocatadj connectedcomponentsupp +connectedcw +connectedcwcontr +connectedcwskel +connectedd +connectede +connectedfun +connectedfunpresconnected connectedi +connectedkn connectedness +connectedp +connectedpn +connectedrp connectedspace +connectedsuspmap +connectedtruncequiv +connectedtrunciso +connectedu +connecti +connectible connecting +connectio connection +connectionboth connectioni +connectionp connections +connective +connectives connectivity +connectp connects +connelim connex +connexd +connexex +connexrd conngr conngraph conngrumgrv conngrv connhmph +conni connima +connmap +connnected +connoc connpconn connperf +conns +connsp connsub connsuba connsubclo +connsusps conntop +conoetherianinduction cononrel conorm +conp +conposet conquer conrel +conrelat +conrete +conrinvert cons consa +consalt consaw +consb consbv conscases consciousness +conscons consd +consdivs +consdless conse consec +consectetur +consecu +consecut consecutive +consecutivedelta consecutively +consecutivep consecutivepairs +consecutives +consecutiveset +consed conselim consensus consensusalt consensusfails +consensuspeirce +consentarate conseq conseqmgt consequence +consequenceofaddbirthday +consequenceofinit +consequencep consequences consequent consequently @@ -12257,11 +21088,25 @@ conserv conservation conservative conserve +conserved +conserves +conses +consesp +conset +consextend +consf +consfix consfixedlengthdigits consgrbar conshdinterpok +conshdtltlhd consheadcp +consheadcphd +consheadcpok +consheadcptl consi +consid +conside consider considerable considerably @@ -12272,38 +21117,88 @@ considering considerons considers considerscontains +consin consinduction +consing +consis +consisent +consisntent consist +consistant +consiste +consisten consistencep consistency consistent consistentappendelement +consistentcache +consistentdp +consistente +consistentextensionp +consistentfs consistenti +consistently consistentprefix +consistentsettings +consisteny +consistes consisting consistp consists +consitent +consk +consl conslinearequiv consm +consn +consname +consodd console +consolidate consorderiso consp +conspair +conspairs +conspat conspiprod conspiprodequiv +consplist +consps consr consrecon conss +conssuc const +consta constaddmonoidhom +constag +constailcp +constailcpabl +constailcplast +constailcpok +constailcptl +constailcptld +constailok +constailperm constains constalghom +constan +constance +constancy constant constantbaseringequiv constantcoeff constantcommutecompose +constantcompchar +constantes constantinfo constantkind +constantly constantmap +constantnet +constantp +constantpointed +constantpool constantpresheafadj constants constantsheaf @@ -12312,12 +21207,19 @@ constantson constantsonfunc constantsonmap constantsonselfstructure +constantsp constantspertask constantstovars constantsvarsequiv constantsvarsequivleft +constanttest constantval +constantvalue constappcase +constapply +constbit +constc +constcheck constcncf constcncfg constcocone @@ -12327,43 +21229,104 @@ constcomp constcompevaluationobj constcompwhiskeringleftiso constcone +constcons +constconst +constcube +constd +constdef +conste +constefct constelim +consteq +consterms +consteval +constexp +constexpr constformalmultilinearseries +constfree constftor constfun constg +constgeq +constgt consti +constidx +constify +constifymod constinf constinfo constinfos +<<<<<<< Updated upstream +======= constininfattributes +>>>>>>> Stashed changes +constinsts +constint +constituant constituent +constituents constitute +constituted +constk constkind constl +constlem +constleq constlevels +constlhdhdtl constlimadj constlimc constlinearequivofisempty +constlt +constm constmap +constmark +constmarks constmonoidhom constmulhom +constmult +constmultdistrib +constmulteq +constmultishomomorphism constname constnames +constnat +constneq constnonunitalringhom constofisempty constofisemptylie conston +constosa +constosset +constp +constpefct constpi +constpoly +constpolynomial +constprop constpunitfunctor constr +constra constrabscl +constrace constraddcl +constrai +constrain constrained +constrainedintermediateexpressions +constrainedness +constrainedp +constraing +constraining constrains constraint +constraintlist +constraintp constraintrow constraints +constraintt +constrargs +constratint constrcbvlem constrcccl constrcccllem @@ -12371,6 +21334,7 @@ constrcjcl constrcn constrcon constrconj +constrdecl constrdircl constrelextdg constrext @@ -12385,11 +21349,14 @@ constrl constrlccl constrlccllem constrlim +constrlits constrllcl constrllcllem constrmon constrmulcl +constrname constrnegcl +constrp constrrecl constrreinvcl constrremulcl @@ -12406,12 +21373,13 @@ constrsscn constrsslem constrsuc constrtoprop +constru construc construct +constructable constructcalltosolver constructcoequalizer constructed -constructedlanguage constructequalizer constructible constructiblesetd @@ -12421,6 +21389,8 @@ constructibletopologysubbasis constructing construction constructionalgebrarat +constructionh +constructionred constructions constructive constructleft @@ -12428,9 +21398,14 @@ constructleftadjoint constructleftadjointequiv constructleftadjointobj constructlegraph +constructo constructor +constructordb constructormatching +constructorname constructors +constructorsignature +constructortests constructproducts constructright constructrightadjoint @@ -12439,38 +21414,83 @@ constructrightadjointobj constructs constructsoln constructsolution +constrv consts constseq constsmul constsmuldivisionring +constsp +constspec +conststr +constsubstcommslice constt +consttc +constte +constterm +consttime +consttj +consttm +consttnk consttounfold +consttv +consttx +consttype +constucts +constunitishomomorphism constvadd constvaddhom +constval constvsub +constword +constx +<<<<<<< Updated upstream +======= consultant +>>>>>>> Stashed changes +consults consume +consumeborrows +consumeclassnoargs consumed +consumedcapacityunits +consumee consumemdata consumer +consumers consumes +consumeun consuming +consump consumption +consv +consvar +consvector consym cont +conta +contact contaction +contagious +contai contain containconstants +containd contained container containers containfalsum containid containing +containingmethodmodifies containment contains +containscall +containscallcases +containscalle containsconsiders containsconst +containsdom +containsduplicateedge containsex containsfvar containshead @@ -12478,20 +21498,32 @@ containsholeannotation containsiden containsidentities containskey +containslist +containsnothingbut containsnotterminal containsonbranch +containsone +containsoneok containspropagates containspseq +containss containssubstr -containsth +containstest containsthenadd containsthenaddq containsthread containstruenotunit +containstwofin +containstype +containsunacceptableduplicateedge +containsunacceptableedge +containsunacceptableedgesnd containsunit containszero contangentequiv +contant contaux +contcont contdi contdiff contdiffat @@ -12506,15 +21538,36 @@ contdiffwith contdiffwithinat contdiffwithinatprop conte +contemplated conten +contending +contens content +contentbytelength +<<<<<<< Updated upstream +contenteffproperty +contentideal +contentmap +======= contentdevelopment +contenteffproperty contentideal +contentmap contentmtofcdafromeventfn +>>>>>>> Stashed changes contentpaper contentregular contents +contentsmap +contenttype +conteqf +<<<<<<< Updated upstream +======= contest +>>>>>>> Stashed changes +contestant +contesting +contex context contexte contextfreegram @@ -12522,32 +21575,53 @@ contextfreegrammar contextfreerule contextinfo contextlist +contextp +contextpossibilities contexts +contextslist +contextslists +contextsp +contextstr contextu contextua contextual +contextualderivablefinitewitnessed contfn contfraclegendre contfract +contgtf conthyp conti +contify +contig contigu contiguous contin contingent +continous continously continu continuants continuation +continuations continuators continue +continuea +continuecond continued +continuek +continuel +continuem +continues +continuest +continuestmt continuing continuity continuityofroots continuo continuou continuous +continuousacan continuousadd continuousaddcharequiv continuousaddmonoidhom @@ -12568,12 +21642,14 @@ continuousalternatingmapcongrleftequiv continuousalternatingmapcongrright continuousalternatingmapcongrrightequiv continuousat +continuousb continuouscohomology continuouscohomologyzeroiso continuouscons continuousconstsmul continuousconstsmulop continuousconstvadd +continuousd continuousdiv continuousenor continuousenorm @@ -12584,6 +21660,7 @@ continuousfourier continuousfourierinv continuousfunctionalcalculus continuousfunctions +continuousfunctionsnorm continuousgroupoid continuoushom continuousi @@ -12625,6 +21702,8 @@ continuousmapmk continuousmapmkdiscrete continuousmapmknat continuousmapnatequiv +continuousmapnotat +continuousmapnotation continuousmapofunique continuousmappresheaf continuousmappresheafab @@ -12658,6 +21737,7 @@ continuousoninvspectrum continuousonrestrict continuousorderhom continuousorderhomclass +continuousp continuouspregroupoid continuousprelocal continuousprimitive @@ -12676,18 +21756,27 @@ continuoussubmonoid continuoussubring continuoussubsemiring continuoussup +continuoustype continuousvadd +continuousw continuouswith continuouswithin continuouswithina continuouswithinat +continuouswoo continuum +contionuos +contiuous +contk contl +contlast contlinear +contltf contlub contlube contlubi contm +contmaps contmd contmdiff contmdiffadd @@ -12712,10 +21801,21 @@ conton contop contour contours +contprop contr contra +contraassume +contraassumen +contrabijectivesch +contrac contract +contractdom +contractdomiso contractelem +contractfst +contractfstiso +contracti +contractibility contractible contractiblespace contractibletriangle @@ -12726,39 +21826,103 @@ contractingonorbits contractingw contractingwith contraction +contractionmapping +contractions contractive +contractk contractleft contractleftaux +contractn contractnth contractright contracts +contractsm +contractsnd contrad +contradi +contradic contradict +contradictary contradictd contradicting +contradictio contradiction +contradictionp +contradictions +contradictorily contradictory contradicts +contrae +contrafeq +contraff +contrafn +contrafneq +contrafnot +contraft contrainjective +contraints +contrak +contral +contralr +contraneq +contranf contrang +contranneq +contrannot +contranp contrap +contrapf +contrapn +contrapnot contrapos contrapose contraposee +contrapositi contraposition contrapositive +contrapositivenn +contrapositivenp +contrapositivepn +contrapositivepp +contrapp +contraprove +contrapt +contrar contrary +contrast +<<<<<<< Updated upstream +======= contrasubsetcomplement contrasubsett +>>>>>>> Stashed changes +contrat +contrateq +contratf +contratneq +contratnot +contratp contravar contravaria +contravariance contravariant contravariantclass +contravariantfunctorlambda contravariantle contravariantlt contravariantsequence +contravening +contrcommalgebraequiv +contrcommalgebrahom contrd +contrdunce +contrel +contrf +contrgroupequivunit +contrgroupisounit +contri +contribs contribute +contributed contributes contributing contribution @@ -12767,22 +21931,38 @@ contrived contro control controllable +controlle controlled controller controlling +controlp +controlpm controlproperty controlr controls +contrp +contrrelsingl +contrrp +contrs +contrsinglequiv +contrtotal +contrtype conts contsaux contstack contsupp contt +contv +contvt contx +contype contz +conuc +conucleus conull conv convcomp +convdersely conve conved convenience @@ -12790,35 +21970,69 @@ convenient conveniently convention conventional +conventionally conventions conver converg converge +converged +convergedir +convergen convergence convergenceimplieslimsupclosedle convergenceindistribution convergencer convergenceset +convergencespace convergent convergents converges +convergescwskelunit +convergesto converging +convers converse +conversei conversely +conversemenelaus +conversemenelausequadri conversep conversewf +conversio conversion conversione +conversionfit conversioni +conversioniff +conversionisnatural +conversionpositive conversions +conversionsatisfiesconstraints +converstion convert +convertandprint +convertbv +convertbytebits +convertclauses converted converter converterd converteri +convertfrombv +convertfromchar +convertfromint +convertfromordinal +convertfromreal +convertfromuint convertible +convertifint converting +convertint +convertl convertlocaldecl +convertmap +convertr +converts convertto convex convexaddsubmonoid @@ -12829,7 +22043,9 @@ convexbodyltfactor convexbodysum convexbodysumfactor convexbodysumfun +convexclosed convexclosedhull +convexcomb convexcombination convexcombo convexcombopair @@ -12837,19 +22053,26 @@ convexcone convexconeclass convexd convexes +convexhomotopy convexhul convexhull convexhulladdmonoidhom convexi +convexification convexindependent convexity convexjoin convexon convexspace +convextvstype +convfun convi +conviene convince +convinced convinv convmul +convn convol convoluted convolution @@ -12861,60 +22084,132 @@ convolutionunit convolutionunitapp convolutive convone +convr +convre convring convs convschema convstx +convterm conway +conwayday +conwaygame +conwaygamechain +conwaygameind +conwaygamemin +conwaygamemintot +conwayone +conwayrank +conwayzero +conx +coo +coodination coof cookie -cooking cool coolclass coolerhom coolerhomclass cooling +coolthing +coonetwist coop +coopcoresem cooper +<<<<<<< Updated upstream +======= cooperation +>>>>>>> Stashed changes +coopsem +coopstep +coopstore +coor coord coordcha coordchange coordchangehomeomorph coordchangel coordina +coordinat coordinate +coordinated +coordinatep +coordinatepoint coordinatering coordinates +coordination +coordinators coords cop copair +copartial +copath copco cope copen coperm copermil copi +copid copied copieddeclarations +copiedp copies copim copisnmnd copissgrp +copl +coplananr coplanar +coplane +copointed +copointing copolarization copolarizationin copow +copp coppersmith copr +copredtypecheck +copresh +copresheaf +copresheaves copri coprim coprimality coprime +coprimebeta +coprimegi +coprimegie +coprimegs +coprimemult +coprimen +coprimenp +coprimens +coprimenz +coprimep +coprimepl +coprimepn +coprimepp +coprimeppn +coprimepr +coprimeprime +coprimeprod coprimeprodsq +coprimepx +coprimeq coprimereal coprimes +coprimeseq +coprimeseqhelp +coprimesg +coprimesn +coprimesym coprimeto +coprimez +coprimeze +coprimezn +coprimezp coprm coprmdvds coprmdvdsb @@ -12923,9 +22218,14 @@ coprmprod coprmproddvds coprmproddvdslem copro +coproc +coprocessor +coprocessorm +coprocessors coprod coprodassoc coprodcat +coprodcatstr coprodcomm coprodcomparison coprodcomparisonnatiso @@ -12965,6 +22265,7 @@ coproductcolimitcocone coproductdisjoint coproductfrom coproductfromfamily +coproductfunctor coproductiscolimit coproductiscoproduct coproductiso @@ -12977,41 +22278,78 @@ coproductsofshapedisjoint coproductuniqueiso coprodzeroiso coproj +coprojs coprprop copsex copsexg copsexgw copsgndif +copt +copts +copullback copy copyabletores +copyarr +<<<<<<< Updated upstream +copyarray +======= +>>>>>>> Stashed changes +copyarraytostate +copyaw copybase +copybyte +copybyteadd +copybyteaw +copybytestr +copybytesub copycount +copyd +copydata +copyfaster +copyfastest copyfile copyfilewithmetadata copyfirst +copyfrom +copyglobals copyi copyindep copying copyinstanceattribute +copylist copymetadata copyn copyobj +copyofname copyp copyright copyrightauthor copyrightheaderchecks copysecond copysign +copystraw +copystrstr +copyto copytosubgraph +copytree +copyvec coq +coqarbnat coqlib +coqutil cor corable +corableindir +corableseplog +coracle corclrcl corclrtrcl corcltrcl cord +corder +cordinate core +coreadj coreassociator corec corecategory @@ -13021,11 +22359,16 @@ corecomp corecompinclusioniso corecon coreconstructormatcher +corecorrectness +corecorrectnesst corecshape corecstate corecursion cored coree +coreerasure +coref +corefl coreflection coreflective coreflector @@ -13034,14 +22377,25 @@ coreflectoradjunction coreflexive coreflexivecomonadicity corefunctor +coregroupoid corehomequiv corehomequivtooversections corehomequivunitcounit +corei coreid +coreinj +coreinjections +coreinsep +corek +corelanguage coreleftunitor +coreloop +corels corem coremonoidal coremonoidaltransport +coreorangel +corep coreplotson corepresenta corepresentable @@ -13052,29 +22406,47 @@ corepresentablebyleft corepresentablebyright corepresentablebyuliftfunctorequiv corepresentation +corepresentationd +corepresentationi coreproperties coreprw coreprx corerightunitor cores +coresafe corescoinf corescoinfoftrivia corescoinfoftrivial +coresem +coresemantics coresmallcategoryofset coresnattrans corestate corestep corestepn +corestr +corestriction +corestrictions +coret +coretraction +coretype coreunitcounit corewhiskerleft corewhiskerright +cormen corner corneraddx corners cornerstheorembound coro +corol +corolary +coroll +corolla +corollar corollaries corollary +corollaryeq coroot corootform corootspace @@ -13082,39 +22454,103 @@ corootspan corootspanin corootspanmem corootsubmodule -corpuscularobject corr +corre +correc +correcci +correccion correct +correcta +correctcompilation +correctcompks +correctcompositiondifflevels +correctcompositiondifflevelsa +correctcompositiondifflevelss +correctcompositiondifflevelssystem +correctcompositionin correctcompositioninloc +correctcompositionkeys correctcompositionks +correctcompositionout +correctcompositionsecrets +correctcompositionvarsystem correctdecompositionvarempty +correctdecompositionvarsystem +corrected +correctfinalpoint correcti correcting correction +correctl +correctloaded correctly +correctlyread +correctlyreadablebyterange +correctlyreadbyterange +correctlyreadheaderbody +correctlyreadrange +correctlyreadv +correctmu +correctn +correctne +correctnes correctness +correctnessconstructevent +correctnessfisheryates +correctnessfisheryatesuniqueelements +correctnessfisheryatesuniqueelementsgeneral +correctnessfisheryatesuniqueelementsgeneralgreater +correctnessfisheryatesuniqueelementsgeneralleq +correctnessp +correctnesspredicate +correctnesst +correctp +correctr +correctroutesp +correctroutess correctsheaf +correctsize +correctspace +correcttime +correctusage +correcty correlated +correlation +corremptyleaf +corremptyundef corres corresp +correspo correspond correspondance +correspondances +corresponde +corresponden correspondence +correspondent +correspondents +correspondi corresponding +correspondingseedtree corresponds -correspondwith corresptheorem corresta corresxf +corrnodenonempty +corrollary corrstate +corrundefempty cors +corte corthogonal +cortm cortrclrcl cortrclrtrcl cortrcltrcl corule cos cosa +cosac cosacos cosadd cosafety @@ -13124,26 +22560,47 @@ cosargd cosasin cosatan cosatanne +cosb cosbnd +cosbpihalf coscl coscld coscn cosd +cosdiff cosdivsq +cosdpi +cosdpihalf +cose +cosec +cosecant +cosech coseparator coseq coset +cosete cosetgroup +coseti +cosetl cosetmonoid cosetmul cosetofgrouptheory +cosetp +cosetpartition cosetpre +cosetprek +cosetprem +cosetpresk +cosetr cosets cosetsemigroup +cosetset cosetsubgroup cosetsubmonoid cosettocusporbit +cosetv cosf +cosg cosh coshalfpi coshalfpim @@ -13162,8 +22619,14 @@ cosines cosk coskadj coskernel +coskn cosknegpi coskpi +cosl +coslice +cosmall +cosmetic +cosmo cosmpi cosmul cosn @@ -13174,13 +22637,18 @@ cosnegpi cosni cosnop cosnopne +cosop cosord cosordlem +cosp cospan +cospancat cospancompiso +cospanequiv cospanext cospanhommk cospanisomk +cospanning cospanop cospans cospanunop @@ -13190,10 +22658,11 @@ cosper cospherical cospi cospim +cosplit +cosplitting cospoly cosppi cosq -cosqmr coss cosscnv cosscnvelrels @@ -13212,6 +22681,7 @@ cosseqi cossex cossid cossidres +cossin cossincnvepres cossinidres cossinres @@ -13228,6 +22698,12 @@ cossxrnres cost costar costaradjforget +costarray +costarrayi +costarrayp +costas +costasarray +costat costbarrier costbarrierdecreases costbit @@ -13235,6 +22711,7 @@ costd coste costmatrix costmatstar +costmtexpr costrict costring costru @@ -13262,10 +22739,17 @@ costructuredarrowyonedaequivalence costructuredarrowyonedaequivalencefunctorproj costructuredarrowyonedaequivalenceinverse costs +cosu +cosub +cosubstitutive +cosubtraction cosupp cosval +cosz coszeta cot +cotaboo +cotain cotake cotan cotangent @@ -13289,7 +22773,13 @@ cotangentspacemap cotangenttoquotientsquare cotcl cote +cotensor +<<<<<<< Updated upstream +======= cotesdor +>>>>>>> Stashed changes +cotest +coth cotr cotrace cotrans @@ -13305,11 +22795,25 @@ cotsqcscsq cotterm cottrcl cotval +cotx +cotxx +cotype +cotyping cou +coua +coualaw +cough +coughed +coul could couldn +coulfeu +coulomb +coun +counded coundi coundir +coung counit counitalghom counitapp @@ -13336,6 +22840,7 @@ counitlimitofpreservesequalizer counitnat counits counitsplitmonoofrfull +counitunitadjoint counop count counta @@ -13343,81 +22848,150 @@ countab countability countable countableab +countablebase +countablebaseg countablebasis countablecategory +countabled countablefiltration countablegenerate countablegeneratesets countablegeneratingset +countablei countableinter countableinterfilter countableorcountablygenerated +countableord +countableords +countablep countablepartition countablepartitionset +countables countableseparatingonuniv +countablet +countableunion +countableunionsplit +countablex +countablexl +countablexr countably countablygenerated countablyseparated countaddmonoidh countaddmonoidhom +countbleafct +countchars +countclosedfieldtype countdown +counte counted counter counterassign counterassignmodelassign counterbalance +counterclockwise counterevalp counterex counterexample +counterexamplep counterexamples counterimpl counterm countermodel countermodelinrepn +counterp +counterpart counterparts +counters +countersp countervaluation +counteven +countevenl +countfieldtype countfirstcands +countfollowcands +countfrom countheartbeats countheartbeatsapprox countheartbeatslinter +countin +countinduct counting countingfunction +countingnumber +countingnumbers +countings countinuous +countl +countleadingzerobits +countleadingzerosword +countmap countmixin +countn +countnullcands +<<<<<<< Updated upstream +countoccurrences +======= +>>>>>>> Stashed changes +countones countour +countourning countp countpaddmonoidhom countquantifiers countrestricted -countryacivilorganization -countryafirstaidorganization -countryahumanitarianorganization -countryamedicalorganization -countrybcivilorganization -countrybhumanitarianorganization counts countset +countsp +countspec +countsplit +countstep countt +counttrailing counttype +countvertices +countw +countzero +coup +coupd coupl couple +couplemma couples coupling couplings +cour courant course +courser +cousin +cout cov +cova coval +covalue covar covari covariance covariancebilin covariancebilindual +covariancebl +covariancebr +covariancec +covariancedl +covariancedr +covariancee +covariancenl +covariancenn +covariancenr covarianceoperator +covariancezl +covariancezr covariant covariantclass covariantclassmulle covariantderivative +covariantfunctorlambda covariantle covariantleswap covariantlt @@ -13426,26 +23000,32 @@ covariantmul covariants covariantsequence covb +covbi covby covbysmul covd covdi covec +covector cover +coverable coverage coverbyimage coverbyimagestructure coverdense +covere covered coverentro coverentropy coverentropyentourage coverentropyinf coverentropyinfentourage +coverhom coveri covering coveringnumber coveringofpresieve +coveringp coveringradius coverings covermap @@ -13454,25 +23034,47 @@ coverofisiso coverpreserving covers coverstop +covert +coverter +covex covf covfi covhasref covib +covibi +covid +covidi +covif +covifi covim +covimi +coviov +coviovi +covis +covisi covm covmap +covmi covolume covov covovi covs covsi +cow cowedge +cowedgef +cowedges coweight coweightequiv coweighthom coweightmap +cowhile +cowles +<<<<<<< Updated upstream +======= cowlnothing cowlthing +>>>>>>> Stashed changes cowriter coxeter coxetermatrix @@ -13497,19 +23099,56 @@ coyonedapairingext coyonedapreserveslimitsofshape coyonedatype coyonedaunique +cozero cpa +cpair +cpairg +cpairinj +cpairinjhelp +cpairispr +cpairle +cpairlt +cpairpi +cpairprojections +cpairprojectionshelp +cpairz cparser cparsere cparseri +cpart cpat +cpath +cpb cpbl +cpc +cpcm cpcoll cpcolld +cpcpl cpct +cpd +cpe +<<<<<<< Updated upstream +cpentries +cpentry +cpet +======= cpeano +cpentries +cpentry cpet cpeter +>>>>>>> Stashed changes +cpeu +cpf +cpfree +cpfs +<<<<<<< Updated upstream +======= cpfun +>>>>>>> Stashed changes +cpg +cpgamma cpgm cph cphabscl @@ -13522,7 +23161,11 @@ cphclm cphdi cphdir cphdivcl +cphdok +<<<<<<< Updated upstream +======= cphi +>>>>>>> Stashed changes cphip cphipcj cphipcl @@ -13556,12 +23199,25 @@ cphsubrglem cphtcphnm cpi cpicong +cpindex +cpinstruction +cpk cpkg +cpl +cpla +cplcp cplem cplgr cplgredgex cplgrop cplgruvtxb +cplhd +cplhdtlok +cplist +cplocptlok +cplok +cplrec +cplt cpltsepuniformspace cplus cply @@ -13596,14 +23252,21 @@ cpmidpmatlem cpminv cpminvid cpmmhm +cpmpm cpmrhm cpmrngiso +cpn cpncn cpnfval +cpnknxn cpnnen cpnord cpnres +cpnt cpo +cpog +cpoint +cpok cpoke cpoly cpolyn @@ -13611,10 +23274,16 @@ cpolynomialat cpolynomialon cpop cpos +cpose +cposi cpow cpowlimits cpp +<<<<<<< Updated upstream +======= cpq +>>>>>>> Stashed changes +cpr cprank cprankmax cpre @@ -13622,23 +23291,91 @@ cpred cprefix cprehil cprehilold +cprj cprob +cproc +cprod +cproda +cprodc +cprode cprodeq +cprodey +cprodg +cprodj +cprodm +cprodme +cprodmel +cprodmer +cprodml +cprodmr +cprodp +cproduct +cprodw +cprodwc +cprodwpp +cprodwy +cprog +cprologue +cproof +cprop +cpropagated +cproper +cprovable +cprv cps cpsalgo +cpsc +<<<<<<< Updated upstream +======= cpsi +>>>>>>> Stashed changes +cpsify +cpsr +cpsrf +cpsri +cpsrl +cpstate cpt +cptlok cptolist +cptolistok +cptolisttl cptoss +cptosshdtl cptossok +cptossokaux +cptr cpu +cpucycles cpuid +cpwd +cpwrite cpx cpxa cpxb cpxc +cpy +cqa +cqc +cqcdefatomic +cqcdefcorrectness +cqcdefnegative +cqcdefverum +cqcf +cqcfuncex +cqcfuncuniq +cqcind +cqcquant +cqcsub +<<<<<<< Updated upstream +======= cqdp +>>>>>>> Stashed changes +cqfunctional +cqq cqt +cra +craise cramer cramerimp cramerimplem @@ -13646,13 +23383,29 @@ cramerlem cramermap crank crans +crap crash +crashed +crashes +crat crate crates +cratp +<<<<<<< Updated upstream +======= cravenous +>>>>>>> Stashed changes +crawls cray +crazy crazyflie crb +crba +crbb +crbd +crbit +crc +crci crcleintegrable crct crctcsh @@ -13665,25 +23418,143 @@ crctistrl crctiswlk crctprop crcts +crd +crdt cre +crea +creal +creale +crealp +creat create +createaccessdescriptor +createaesdecryptexternfailure +createaesdecryptexternsuccess +createaesencryptexternfailure +createaesencryptexternsuccess +createaliasensurespublicly +createarray +createawskmsdiscoverykeyring +createawskmsdiscoverykeyringensurespublicly +createawskmsdiscoverymultikeyring +createawskmsdiscoverymultikeyringensurespublicly +createawskmsecdhkeyring +createawskmsecdhkeyringensurespublicly +createawskmshierarchicalkeyring +createawskmshierarchicalkeyringensurespublicly +createawskmskeyring +createawskmskeyringensurespublicly +createawskmsmrkdiscoverykeyring +createawskmsmrkdiscoverykeyringensurespublicly +createawskmsmrkdiscoverymultikeyring +createawskmsmrkdiscoverymultikeyringensurespublicly +createawskmsmrkkeyring +createawskmsmrkkeyringensurespublicly +createawskmsmrkmultikeyring +createawskmsmrkmultikeyringensurespublicly +createawskmsmultikeyring +createawskmsmultikeyringensurespublicly +createawskmsrsakeyring +createawskmsrsakeyringensurespublicly +createbackupensurespublicly +createbooleannone +createbooleansome +createbytesfailure +createbytessuccess createcalc +createcmmfrominput +createconstant +createcryptographicmaterialscache +createcryptographicmaterialscacheensurespublicly +createcustomkeystoreensurespublicly created +createdecodefailure +createdecodesuccess +createdefaultclientsupplier +createdefaultclientsupplierensurespublicly +createdefaultcryptographicmaterialsmanager +createdefaultcryptographicmaterialsmanagerensurespublicly +createdigestfailure +createdigestsuccess createdirectory createdirectoryifmissing createdirectorylink +createdtfortrait +createencodefailure +createencodesuccess +createexterncompresspublickeyerror +createexterncompresspublickeysuccess +createexterndecompresspublickeyerror +createexterndecompresspublickeysuccess +createexternderivesharedsecreterror +createexternderivesharedsecretsuccess +createexternecckeygenfailure +createexternecckeygensuccess +createexterngetpublickeyfromprivateerror +createexterngetpublickeyfromprivatesuccess +createexternkeygenfailure +createexternkeygensuccess +createexternparsepublickeyerror +createexternparsepublickeysuccess +createexternvalidatepublickeyerror +createexternvalidatepublickeysuccess +createfailureoferror +createfile createfilelink createfriend createfriendreq +creategeneratebytesfailure +creategeneratebytessuccess +creategetcacheentryfailure +creategetcacheentrysuccess +creategetcurrenttimestampfailure +creategetcurrenttimestampsuccess +creategetinfinitypublickeyerror +creategetinfinitypublickeysuccess +creategetoutofboundspublickeyerror +creategetoutofboundspublickeysuccess +creategetrsakeymoduluslengthexternfailure +creategetrsakeymoduluslengthexternsuccess +createglobaltableensurespublicly +creategrantensurespublicly +creategraph +createhmacfailure +createhmacsuccess +createi createimporteddiscrtree createimportinitresults +createinitframe +createiterator +createkey +createkeyensurespublicly +createkeystore +createkeystoreensurespublicly +createkeystoretable +createl +createlambdaandsequence createlimitsofsizemapcompforget createmodulediscrtree createmoduleprediscrtree createmoduletreeref +createmultikeyring +createmultikeyringensurespublicly +createnonefordryrun +createnoneforencryptioncontext +createnoneforgranttokens +createnoneforkeyspec +createnonefornumberofbytes +createpath createpcp createpsp createpss +createrawaeskeyring +createrawaeskeyringensurespublicly +createrawecdhkeyring +createrawecdhkeyringensurespublicly +createrawrsakeyring +createrawrsakeyringensurespublicly +createrequiredencryptioncontextcmm +createrequiredencryptioncontextcmmensurespublicly creates createscokernels createscolimit @@ -13725,6 +23596,8 @@ createsfiniteproducts createsfiniteproductsofnatiso createsfsplitequalizersofcomonadic createsgsplitcoequalizersofmonadic +createsignfailure +createsignsuccess createskernels createslimit createslimitfullsubcategoryinclusion @@ -13747,28 +23620,91 @@ createslimitsofshapeofinitial createslimitsofshapeofnatiso createslimitsofsize createslimitsofsizeofcreatesequalizersandproducts +createsnapshot +createstatickeystore +createstaticmaterialskeyring +createstore +createstreamfailure +createstreamsuccess +createstringfailure +createstringnone +createstringsome +createstringsuccess +createsuccessofclient +createtableensurespublicly +createtestvectorkeyring +createtestvectorkeyringensurespublicly +createtransactwriteputitem +createuint +createv +createverifyfailure +createverifysuccess +createwrappedtestvectorcmm +createwrappedtestvectorcmmensurespublicly +createwrappedtestvectorkeyring +createwrappedtestvectorkeyringensurespublicly creating creation +creative +creator +creators creats -creature crec crecbuilder +creccn +crecip +crecpr +crect +credit +<<<<<<< Updated upstream +======= creduct +>>>>>>> Stashed changes +cref crefdf crefeq crefi crefss creftop +creg crel +crelation +crelationclasses +crep +creplang +crepop +crepsem creq +crequest +crerr +cres +crest +crestr +cresul +cresult +creturn creui creur +crev +creval +crew +crewr +crewri +crewrit +crewrite +crf +crg +<<<<<<< Updated upstream +======= crheumatic +>>>>>>> Stashed changes crhmsubc crhmsubcaltv +crhs +cri +cright crim crimd -crime crimi crimpl cring @@ -13776,14 +23712,29 @@ cringcat cringcataltv cringm cringops +<<<<<<< Updated upstream +======= crises +>>>>>>> Stashed changes +crisp +crispen +crisscross crit +crite +criter critere criteria criterion +crithyps +critic critical +criticalnumber +criticals crk +crlf crlftolf +crm +crn crne crng crngbascntr @@ -13805,66 +23756,120 @@ crngringd crngunit crock croix +cronch cronies croot croots +crop +cropped +cropping +croptop cross +crossbar +crossed +crossedmodule +crossedmodulehom crossemoji +crosses +crossex +crossimpliesopposite crossing crossings +crossmod crossn +crossover crossp crossproduct +crossr +crosssplit +crossword +crou crown crre crreczi crred crrei +crs +crsp +<<<<<<< Updated upstream +======= crst +>>>>>>> Stashed changes +crt +crtfsm crth +crtmod crtp +crttxat cru crucial +cruciallemma +crucially +crud +crude +cruise crule crumb +crun +crunch +cruncher cruniq crush crux +crv +crvcf +crvcfn +<<<<<<< Updated upstream +======= cry +>>>>>>> Stashed changes crypt +cryptarithmetic cryptinverts crypto cryptographers +cryptoprimitives crypts +crysippus +crystal crystallographic csa csafe csafety csb csbab +csbabg csbafv csbaovg csbcnv +csbcnvg csbcnvgalt csbco csbcog csbcom +csbcomg csbconstg csbconstgf csbconstgi csbcow csbdif csbdm +csbdmg csbeq csbex +csbexa csbexg +csbexga csbfinxpg csbfrecsg csbfv +csbfvg csbgfi csbhypf +csbi csbid csbidm +csbidmg csbie csbieb csbiebg @@ -13874,10 +23879,13 @@ csbiedf csbief csbiegf csbif +csbifg csbima csbin +csbing csbingvd csbiota +csbiotag csbmpo csbmpt csbnegg @@ -13885,13 +23893,16 @@ csbnest csbnestg csbnestgf csbnestgfw +csbnestgold csbnestgw csbopab +csbopabg csbopabgalt csbopeq csbopg csboprabg csbov +csbovg csbprc csbpredg csbprg @@ -13899,9 +23910,12 @@ csbrdgg csbrecsg csbren csbres +csbresg csbresgvd csbriota +csbriotag csbrn +csbrng csbrngvd csbsn csbsng @@ -13910,28 +23924,53 @@ csbsnlem csbtt csbun csbuni +csbunig csbunigvd csbvarg csbvargi csbwrdg csbwrecsg csbxp +csbxpg csbxpgvd csc cscalar cscale +cscalel +cscalen +cscaler +cscc csccl +csch cscval +csd csdfil csdi cse +csearchable +cseinst +csel csem +csemap +csems +csemt +csentabort +csentcommit +csentprep cseq cset csets +csf csfi +csfin +csg +csgdef csgrpalt +csgsingle csh +csharpmin +csharpminor +csharpminstep cshco cshf cshfn @@ -13939,6 +23978,7 @@ cshid cshift cshimadifsn cshinj +cshl cshnz csho cshorun @@ -13979,53 +24019,87 @@ cshwsidrepswmod cshwsiun cshwsublen csib +csibi +csid csidi +csif csifi +csig csim +csimi csimp csin csinf csingle csinh csiov +csiovi csis +csisi +csize +cskip +csl +csli cslib cslift csliftval +cslveric csm csmall +csmalld +<<<<<<< Updated upstream +csmap +csmdsymi +csmi +======= csmaller +csmap csmdsymi +csmi csmoke csmokes csnail +>>>>>>> Stashed changes csnd csnoc +csome +csort csov +csovi csp +cspan +cspec +cspfin +<<<<<<< Updated upstream +======= csphenodontidae +>>>>>>> Stashed changes csplit +csq csqima csqlem csqrt csquare -csr csrgbinom csring css cssbn csschl csscld +csset cssi cssincl +cssl csslss cssmre +csspace cssss cssup cssval cssxs cst csta +cstab cstack cstage cstar @@ -14034,45 +24108,145 @@ cstaralgebra cstarmatrix cstarmodule cstarring +cstartoc cstate +cstatep +cstates +cstatet +cste +cstep +csteps +cstepv +cstl +cstloc +cstlocs +cstm +cstny +cstr +<<<<<<< Updated upstream +======= cstrange +>>>>>>> Stashed changes cstrategy +cstrength +cstring +cstringn cstrong +cstrsfv csts cstucnd +csty +csub +csubring +csubs +csubspace +csuc csucc +csucex +csummable +<<<<<<< Updated upstream +======= csunshine +>>>>>>> Stashed changes csup csupport csupportd csupr +csus +csv +csvdelimiter +csvheader +csvheaderlist +cswap cswitch csx csxs csy +csym +csyntax csz +cta +ctabulate +ctag ctake +ctan +ctannot +<<<<<<< Updated upstream +======= ctator +>>>>>>> Stashed changes +ctb +ctbl ctbnfien +ctbr ctbssinf +ctc +<<<<<<< Updated upstream +======= ctclosed +>>>>>>> Stashed changes +ctcol +ctconst ctd cte +cterm +ctermeq +ctermi +ctermind +ctermp +cterms +ctermsi +ctermsl ctex +ctfoex +ctfsm +ctgli +ctgzi cth cthi cthic cthickening cthickenings cti +cticamente +ctie +<<<<<<< Updated upstream +======= ctimes +>>>>>>> Stashed changes +ctinf +ctinfom +ctinfomlemom +ctiunct +ctiunctal +ctiunctlemf +ctiunctlemfo +ctiunctlemu +ctiunctlemudc +ctiunctlemuom ctkn ctl ctlem +ctlen +ctlinvariant +ctlmodel +ctlmodelstr +ctls ctltype ctm +ctmap +ctmlemr +ctn ctnlyk +cto +ctoa +ctob +ctod +ctol ctop +ctopt +ctoq +ctoqn ctor ctorargs ctorconst @@ -14083,71 +24257,192 @@ ctorname ctors ctorthmname ctortype +ctos +ctp +ctpm +ctq ctr +ctrace ctrans +ctree +ctrex +ctrexamples +ctrexes +ctri ctriangle ctrianglei +ctriple +ctripleispr +ctriplepi +ctripleproj ctrl +ctrld +ctrle ctrm +ctrp cts ctsd ctsf ctsi +ctspec +ctssdc +ctssdccl +ctssdclemn +ctssdclemr +ctssexmid +ctup +ctv ctvonmbl +ctvtaqa ctwo ctx +ctxa +ctxalist +ctxb ctxcld ctxclds ctxdecls +ctxelement +ctxexprlist +ctxexprs ctxi ctxinfo +ctxkey +ctxlen +ctxmd ctxname +ctxs +ctxsize ctxt +ctxtfv +ctxti ctxts +ctxtswap +ctxu ctxvars +cty +<<<<<<< Updated upstream +======= ctyop +>>>>>>> Stashed changes +ctyp ctype +ctypecase +ctypep ctypes ctyping +ctz +cub cube +cubeconst +cubed +cubedep +cubedepconst +cubedepconstrel +cubedeprel cubedos +cubeequiv cubei cubeimage +cubepath +cuberel +cuberelconst +cuberelpath +cuberelsuc cubes cubeslem +cubesuc cubic +cubical cubr cubrlem +cud +cude cudztblmj cuhi +cul +culled +culminates culminating +cum +cumbersome +cumdays cumul +cumula +cumulati cumulative +cun +cunfold +cunif +cunifk cunifsp +cunify +cunifyl +cunion +<<<<<<< Updated upstream +======= cunique +>>>>>>> Stashed changes +cunit +cunitstr cuniv +cunurry +cuong cup cupcake +cupd +cupex +cups +cupvalg cur cureq curf curfcl curfpropd +curframe curfuncf curfv curfval +curins +curinstr +curiosity curious +curiousity +curl curly +curm +curmax +curmin +curminpos +curms +curp curr +curre +curren current +currentcoin +currentcondition currentdirectory currentf currentgoal +currentinstrset currently +currentmethod +currentmode +currentpos +currentt currentte currentterm +currenttimestampe +<<<<<<< Updated upstream +======= currentworlddatacollectormt +>>>>>>> Stashed changes +currentwrapper +currheap +curriculum curried +curriedackermann curriedaction curriedactionactionofmonoidalfunctortoendofunctoriso curriedactionactionofmonoidalfunctortoendofunctormopiso @@ -14156,6 +24451,8 @@ curriedassociatornatiso curriedbraidingnatiso curriedcoyonedalemma curriedinverse +curriedisthesame +curriedoperation curriedtensor curriedtensorpost curriedtensorpre @@ -14168,9 +24465,11 @@ currk currnamespace currocc curroccs +currst curry curryaddequiv curryalgequiv +curryapply curryax currybi curryequiv @@ -14181,6 +24480,8 @@ currying curryingequiv curryingflipequiv curryingiso +curryiso +curryk curryleft curryleftli curryleftlinearmap @@ -14201,14 +24502,21 @@ currysetalt currysetlem currysum currysumequiv +curs +cursive +cursor +curt curunc -curval curve curveintegrable curveintegral curveintegralfun curvep curves +curvespec +curvespectypetostring +curwr +cus cusconngr cusgr cusgracyclt @@ -14240,59 +24548,196 @@ cusps cuspusp custom customdeclarations +customencryptioncontext +<<<<<<< Updated upstream +======= customer +>>>>>>> Stashed changes +customizable +customkeystoreidtype +customkeystorenametype customname customproj +<<<<<<< Updated upstream +======= customqmltpeq +>>>>>>> Stashed changes +customregion +customvalid cut +cutaux +cutauxprop +cutb cutbday cutbdaybnd cutbdaylt +cutc cutcuts +cutdeg cute cuteq cutexpand +cutfree cutfreepc +cutfreeproof +cutfreesubproof +cutfreesubproofone +cutinfo +cutinfolist +cutlastloc +cutlist cutlt cutmap cutmax cutmin cutminmax +cutminus +cutminusspec +cutname +cutnatded cutneg cutoff cutp +cutpoi +cutpoint +cutpoints cutpos cutrewrite +cutrule +cutrulesimpl cuts cutscl cutscld +cutsd +cutsdb +cutsdbp +cutset +cutsets cutsf cutsfo +cutsize +cutstock cutsun cutsval +cutterm cutting +cutvts cuv +cuvs +cuxvzoz +cuy cval +cvalid +cvalue +cvar +cvars cvat cvati cvbr cvbtrcl cvc +cvclosed cvcon +cvcons cvdmd cvec cvecold +cvector +cvectors +<<<<<<< Updated upstream +======= cveg +>>>>>>> Stashed changes +cveric cvexch cvexchi cvexchlem +cvfn +cvfsi +cvg +cvgb cvgcau cvgcaule cvgcmp cvgcmpce cvgcmpub +cvgd +cvgdle +cvgdre cvgdvgrat +cvge +cvgeny +cvgenyp +cvgenyple +cvgenypleny +cvgenypler +cvgenyplt +cvgenypltny +cvgenypltr +cvgernyp +cvgeryp +cvgey +cvgeypge +cvgeypger +cvgeypgey +cvgeypgt +cvgeypgtr +cvgeypgty +cvgi +cvgmlny +cvgmly +cvgmn +cvgmrny +cvgmry +cvgn +cvgne +cvgneny +cvgney +cvgnp +cvgnpoint +cvgnrny +cvgnry +cvgny +cvgnypge +cvgnypgey +cvgnypgt +cvgnypgty +cvgp +cvgr cvgrat +cvgratgt +cvgratnn +cvgratnnlemabsle +cvgratnnlembern +cvgratnnlemfm +cvgratnnlemmn +cvgratnnlemnexp +cvgratnnlemrate +cvgratnnlemseq +cvgratnnlemsumlt +cvgratz +cvgrny +cvgrnyp +cvgrnyple +cvgrnypleny +cvgrnypler +cvgrnyplt +cvgrnypltny +cvgrnypltr +cvgrpdist +cvgrpdistc +cvgry +cvgrypge +cvgrypger +cvgrypgey +cvgrypgt +cvgrypgtr +cvgrypgty +cvgx +cvgxx +cvgy +cvgz +cvgzr cvi cvjust cvlat @@ -14304,9 +24749,12 @@ cvlcvr cvlcvrp cvlexch cvlexchb +cvlf +cvlist cvllat cvlposn cvlsupr +cvm cvmcn cvmcov cvmd @@ -14337,13 +24785,17 @@ cvmsss cvmsuni cvmsval cvmtop +cvn cvnbtwn +cvndfn cvnref cvnsym cvntr +cvopt cvoy cvp cvpat +cvpr cvpss cvr cvrat @@ -14353,6 +24805,8 @@ cvratlt cvrcmp cvrco cvrcon +cvrel +cvrelf cvrexch cvrexchlem cvrfval @@ -14367,40 +24821,84 @@ cvrnrefn cvrntr cvrp cvrval +cvs cvsclm cvsdiv cvsdivcl cvsdiveqd +cvsfin cvsi cvslvec cvsmuleqdivd +cvsome cvsunit +cvt +cvtdq +cvterm cvtop +cvtpd +cvu +cvwalk +cvwalkr cvx cvxcl cvxpconn cvxsconn +cvzbv +cwaitackabort +cwaitackcommit +cwaitprepresponse +cwalk +cwalkstar +cwalkstarl cwand +cwc cwcoktgimwiiovckhvlavdtrjppovhxbugwarv cwcomplex +cwd +cwdef cweak cweight +cwempty +cwexplicit cwf +cwfs cwhfxwwojoxawqhsu cwhile +cwiseext cwj +cwmap +cwo +<<<<<<< Updated upstream +cwp +======= cwolf cwp cwrh +>>>>>>> Stashed changes +cws +cwskel +cwskelunit +cwsphere +cwstr +cwunit cwwk cwwkdifex +cwx +<<<<<<< Updated upstream +======= cxantusiidae +>>>>>>> Stashed changes +cxfib +cxmax +cxmdx cxnoqjbcbkyotyko cxp cxpadd cxpaddd cxpaddle cxpaddlelem +cxpap cxpcl cxpcld cxpcn @@ -14412,6 +24910,8 @@ cxpef cxpefd cxpeq cxpexp +cxpexpnn +cxpexprp cxpexpz cxpexpzd cxpge @@ -14443,6 +24943,10 @@ cxpsubd cxpval cxs cxt +cxtkey +cxts +cxy +cyan cyaymsonjsjsf cyc cycc @@ -14455,24 +24959,44 @@ cycldlenngric cycle cyclebypass cyclecons +cycledef cyclee cyclef cyclefactors cyclefactorsaux cyclefactorsfinse cyclefactorsfinset +cyclefree +<<<<<<< Updated upstream +======= cyclefreep +>>>>>>> Stashed changes cycleg cyclegraph cyclei cycleicc +cyclej cyclelength +cyclem +cyclemm +cyclemsub +<<<<<<< Updated upstream +cyclenonempty +======= +>>>>>>> Stashed changes cycleof cycleon +cyclep +cyclephase +cyclephaselis +cyclephaselist +cyclepmin cyclerange cycles +cycleset cyclesfunctor cyclesfunctoriso +cyclesi cyclesiskernel cyclesiso cyclesisoh @@ -14488,25 +25012,33 @@ cyclesopiso cyclesopnatiso cyclestx cycletype +cyclev cyclex cyclexlem cyclfrgr cyclfrgrrn cyclic +cyclically cyclicbuffer cyclicbufferlib +cyclicity +cyclicj +cyclicm +cyclicp cyclicpermutations cyclicpermute cyclicpermuteaux +cyclics +cyclicy cycliscrct cyclispth cyclispthon -cyclist cycliswlk cycllem cyclnex cyclnspth cyclnumvtx +cyclo cyclotomic cyclotomiccharacter cyclotomicfield @@ -14552,28 +25084,38 @@ cygth cygzn cygznlem cyk +cylce +cyli +cylic cylinder cylinderevent cylinderevents cylindereventscompl cylinderf +cylinderfunc cylinderhom cylinderhomotopy cylinders cylinderx +cymay +cymdy cyph -cytoskeleton cytp cytpfn cytpval cytronminimal czadd czero +czerop +czeroseq +czf cznabel cznnring cznrng cznrnglem +czop czveyp +czy daa daaa daab @@ -14593,7 +25135,11 @@ dabcb dabdb dabe dabf +dabort +dabs +dabsi dabstract +dabt dac dacab dacc @@ -14614,6 +25160,21 @@ dadce dadd daddccd dadde +daddea +daddeac +daddeaca +daddec +daddeca +daddek +daddeny +daddey +daddgt +daddiu +daddnye +daddsmx +daddu +daddv +daddye dade dadec dadf @@ -14636,15 +25197,34 @@ dafdf dafe dafeb dafed +dafny +dafnyast +dafnyuseragentsuffix +<<<<<<< Updated upstream +======= dafrika +>>>>>>> Stashed changes dag +dagcats dagger +daggercategory +daggerfunctor +daggerfunctors +daggerinvolution +daggerlaws +daggerstr dagi +dagp dags +dai +daily +dainid daio +daisy dalaw dalawlem dalem +dalembert dalemccea dalemcceb dalemccnedd @@ -14693,79 +25273,181 @@ dalemyeb dalemyeo dalemzeo dalist +dalpha dalt daltn +<<<<<<< Updated upstream +======= damaging +>>>>>>> Stashed changes +damn +damp dan dance +dancing +dand +dandy dandysum dane danel dang danger dangerous +dangles dangling danglingdot +danottl dans dansa +dapp +dappe +dappstar daptation +dar darapti daraptialt darboux +darcs +darg +dargp +dargps dargs darii dariialt +dario +dark +darkcond +darkrow darmstadt +darn +darned +daron +darr +darrow darrowiso +darrowt dart dartadj dartagnan dartofneighborset darts +dartset +dash +dashi dashv dasioslry +dast dat data +dataabt +databas database databaseurl +databuf +databuffer +databufferwrite datad +datadefinedbymatch +datae +dataelement +dataelements +dataflow +datai +datais +datakey +datakeyspec +datal +datalang datalist +dataloc +datamem +dataorforward +dataoverride +datap +datapart +datapath dataprocessing datarefinement +datas +datasem +dataset dataspace +datastate +datastring +datastructures +datat +datatree +dataty datatype +datatypedestructors +datatypeli +datatypelist +datatypeops datatypes +datatypesayseight +datatypesignature +datatypet +datatypevalues datavalue datcorrect +datcount datdepth date +dated dates +datetime dath datisi datmap datom datomi +datoms +datomsbot datrepeat +dats datum +datump +daughter +daumut dav +dave davenport +davg +davgb +davgd +davgt david davies +davis davw +daw +daxioms +daxiomsi day dayconvolution dayconvolutioninternalhom dayconvolutioninternalhomdiagramfunctor dayconvolutionunit +dayname +dayp +days +daz +dazify dba dbaac dbaadc dbab +dbabs +dbabsn +dbabsni +dbabsv +dbabsvi dbac dbacf dbad dbae dbaf +dbar dbas dbb dbba @@ -14773,6 +25455,7 @@ dbbb dbbc dbbd dbbfda +dbbound dbc dbca dbcb @@ -14784,11 +25467,14 @@ dbce dbcf dbcfd dbcfddb +dbcomb dbconj +dbconst dbd dbda dbdac dbdb +dbdc dbdcc dbdda dbde @@ -14802,6 +25488,7 @@ dbed dbee dbeec dbef +dbeta dbf dbfacefe dbfb @@ -14815,11 +25502,25 @@ dbfef dbff dbffa dbfm +dbfringe dbg dbgghugtvipfsn +dbgi dbgmsg +dbi +dbilin dbind +dbinst +dbits +dbk +dbks dbl +dblcompl +dbldl +dbldr +dblen +dbleyrouting +dblneg dblo dblock dblu @@ -14828,27 +25529,65 @@ dblxyz dbly dblz dbm +dbmask +dbmax dbmentry +dbms +dbnf +dbnum dbnxt dboost dbot +dbound +dboundv +dbp dbpfibmceocfsmcdqgrirleycbuwdwevanhinbsu +dbproj +dbr +dbrdl +dbrdr +dbs +dbsize dbspec +dbt +dbta +dbterm +dbterms dbtm dbtransaction +dbtt +dbupd dbvar +dbvars +dbvfree +dbvsubst +dbw dbzero dca dcaa dcaab dcabfd dcac +dcache dcacheocc dcad dcae dcaeecf dcaf dcafaf +dcalt +dcan +dcand +dcapnconst +dcapnconstalt +dcaret +dcas +dcat +dcate +dcatequiv +dcatie +dcatisequiv +dcaxiom dcb dcba dcbab @@ -14857,6 +25596,11 @@ dcbba dcbbccc dcbc dcbf +dcbi +dcbid +dcbii +dcbiit +dcbl dcc dccaf dccat @@ -14866,6 +25610,7 @@ dccca dccd dccf dccsoagacwumxvgxseswrkgdnryazzgo +dccw dcd dcda dcdbe @@ -14874,23 +25619,39 @@ dcdcaa dcdcf dcde dcdf +dcdifsnid +dcdw dce dcea dcebff dceca +dcecf dced dcefcbde +dceq +dceqnconst +dcex +dcextest dcf dcfacaedf dcfaf +dcfal dcfb dcfbabf dcfca +dcfd dcfdeddd dcff +dcfi +dcfromcon +dcfromnotnotr +dcfrompeirce +dchain +dchans dchar dcharacter dcharacters +dchi dchr dchrabl dchrabs @@ -14932,26 +25693,70 @@ dchrvmasumlema dchrzrh dchrzrhcl dchrzrhmul +dcim dcl +dcla +dclass +dcle +dcli +dclose +dclosed +dcls +dcmst +dcn +dcne +dcned +dcnn +dcnnold +dcocone dcokernelsequence +dcom dcomex dcomp dcompare dcompl +dcompose +dcon +dcone +dconf dcong dcongr dcongrarg +dconj +dconjf +dconjk +dconjt +dconst +dconstr +dconstructor +dconstt dcont +dcontents dcontimonad dcontimonaddcont +dcontinue dcontt dconttimonad dconttimonaddcont dconvfactor +dcor +dcpo +dcpos +dcprog dcr dcralttiscaglosrk +dcs +dcsa +dcsb +dcst +dcstab dct +dctru dcubic +dcun +dcvg +dcvgp +dcw dda ddaa ddaab @@ -14965,18 +25770,25 @@ ddafad ddagger ddalt ddan +ddata ddb ddba ddbaa ddbb ddbce +ddbcl +ddbclient ddbd ddbe ddbeb +ddbf +ddbtablename ddc ddca ddcac ddcan +ddcanap +ddcanapd ddcand ddcc ddcd @@ -14987,6 +25799,7 @@ ddcec ddcf ddcfd ddcong +ddcs ddd ddda dddbbd @@ -14999,16 +25812,24 @@ dddee dddf dddfca dde +ddea ddeb +ddecod +ddecode dded ddedb ddedbef ddede ddee ddef +ddeg ddelta ddemeas +dden +ddensity +ddenvr ddep +ddepth ddeval ddf ddfab @@ -15020,11 +25841,25 @@ ddff ddffd ddh ddi +ddiagram ddif +ddifnel +ddifss +ddifstab +ddist +ddiv ddivp +ddl +ddle ddly +ddmin ddne +ddone +ddp +ddplus +ddr dds +ddseq ddw dea deaa @@ -15032,20 +25867,34 @@ deab deac deacdfa deace +deactivate deactivation dead deadbce deadend deadends +deadlinepenalty +deadlocation deadlock deadlocked +deadlockfree +deadlockfreedom +deadlocks +deadlockstate deaf deal dealing dealloc +deallocable +deallocate +deallocp +deallocr deals dealt +deassign +deassignstmt death +deaxiom deb debb debbc @@ -15054,10 +25903,19 @@ debd debda debe debf +debile +debruijn +debrujin debug +debugdata +debuggable debugged +debugger debugging +debugmsg debugprintfmt +debuijn +debunkfermatandwiles dec deca decadd @@ -15068,31 +25926,66 @@ decaddi decaddm decadriver decaee +decap decapitalize decapitalizefirstlike decapitalizelike decapitalizeseq +decat decay decaying +decayinterval decb decbin +decbool +deccall +deccallnt deccarry deccl deccom decd decdb +decdemorgan decdiv dece deceb decee +decelem +<<<<<<< Updated upstream +decelim +======= +>>>>>>> Stashed changes +december +decenc +decencfix +decencs +decend +decent +deceptive +deceptively deceq deceqbool +deceqcong +deceqcontraisno +deceqinj deceqnat +deceqselfisyes +decequntil decex +decf decfactor decfb +decfield +decfin decfinsubset +decg +decgoodtree +decheterogeneouselem +decheterogeneouselemlist +dechomogeneouselem +dechomogeneouselemlist deci +decic decid decida decidab @@ -15137,6 +26030,7 @@ decidablelelt decidableleofstructure decidablelohi decidablelohile +decidablelrtree decidablelt decidableltle decidableltlt @@ -15155,6 +26049,7 @@ decidablenonempty decidablenonneg decidablenonnegg decidablenontrivialcoe +decidablepaths decidablepiexists decidablepifintype decidablepr @@ -15171,6 +26066,7 @@ decidablereltop decidablerightinversefintype decidables decidablesdiff +decidableset decidablesingleton decidablesorted decidablesubperm @@ -15179,26 +26075,50 @@ decidabletopbelow decidableunion decidablezero decide +decideable +decideaxioms decided +decideeq decider decides +decidi +decidin deciding +decidr decimal decimals +decipher decision decisionattime decisiond +decisione +decisionless +decisionnonnullthendecided decisions +decisionthenmajoritybeyondts decisive +decisivei +decisnode +deck decl +decla +declaim +declar +declara +declaradas declaration declarations +declarative declare declared +declarep +declarerecordiso declares declaring declassification declassified +declassifies +declassify declattempt declcache declconst @@ -15208,15 +26128,24 @@ declei declfilter declfn declid +decline +declista declmodifiers declmods declname declnames +declon declpriority +declpro declrangeext decls +declscope declsig +declsko +declstrictequiv +declstrictisotoequiv declstx +declsum declt decltc decltdi @@ -15227,32 +26156,90 @@ declunfoldsimpauxlemmas declval declvalsimple declvalue +declwithhavoc +decm decma decmac +decmat +decmp decmul decmulnc decnncl +decno decnot +decnr +decnt deco +decod decode +decodeany +decodebitmasks +decodeblock +decodeblockpos decodebool +decodecodeunitsequence +decodecodeunitsequencechecked +decoded +decodeencode +decodeencodeblock +decodeencoderecursively +decodeencodet +decodeencodeunpadded +decodeencryptioncontext +decodeimmshift decodek +decodelem decodelist +decodelogicalop +decodeminimalwellformedcodeunitsubsequence +decodeminimalwellformedcodeunitsubsequencedoublebyte +decodeminimalwellformedcodeunitsubsequencedoubleword +decodeminimalwellformedcodeunitsubsequencequadruplebyte +decodeminimalwellformedcodeunitsubsequencesinglebyte +decodeminimalwellformedcodeunitsubsequencesingleword +decodeminimalwellformedcodeunitsubsequencetriplebyte decodemultiset decodenat decodenum +decodepoint decodeposnum +decoder +decoderecursively +decoderegshift +decoderevop +decoderoundingmode +decodervc +decodes decodesigma +decodesquare decodesubtype decodesum +decodet +decodeunpadded +decodevalid +decodevalidencode +decodevalidencodeempty +decodevalidencodeunpadded +decodevalidunpaddedpartialfrom +decodeverificationkey +decodex decoding +decollapsed +decom decomp decompandall +decompd decompe decompex decompexand +decompi decompid +decompile +decompiler +decompn decompo +decompos +decomposability decomposable decompose decomposeaddequ @@ -15262,35 +26249,64 @@ decomposeaux decomposed decomposedequiv decomposedto +decomposee +decomposeeimplicationone +decomposeeimplicationtwo decomposefin +decomposek +decomposekss decomposelinearequiv decomposels +decomposelte decomposeoption decomposeperm decomposeprodadjoint decomposeprodadjointl decomposeringequiv decomposes +decomposible decomposing +decomposit +decompositi decomposition decompositionfield decompositionmonoid decompositionoverargs decompositions decompositionsubgroup +decompositition +decomposwap decomppmat decompress +decompressed +decompression +decompresspublickey +decompresspublickeyensurespublicly +decompresswindow decomps decompsn decompv +decons +deconstruct +deconstruction +decopt +decoptgoodfooprec decorate decorated +decoratedbintreeex +decoratedstring +decoratedtr +decoratedtree decoratesigma decoratesum +decordering +decos decoupled decp decpartialorder +decpaths decpcases +decph decpmataa decpmatcl decpmate @@ -15304,24 +26320,75 @@ decpmul decpmulnc decposet decpred +decprop +decq decr +decrd +decre +decrea decrease decreased decreases +decreasesyieldsaninvariant decreasing decreasinginduction +decreasinglist +decreasingontwo +decreasingp +decrec +decrece +decrecip decrel decrement +decremented +decrementing +decrements +decrlist decrmac decrmanc decrn decrpoly +decrs +decryp decrypt +decryptable +decryptcalls +decrypted +decryptedwithkey +decryptensurespublicly +decrypting +decryption +decryptionmaterials +decryptionmaterialsadddatakey +decryptionmaterialstransitionisvalid +decryptionmaterialswithoutplaintextdatakey +decryptionmaterialswithplaintextdatakey +decryptkey +decryptmanifest +decryptmaterials +decryptmaterialsensurespublicly +decryptonly +decryptonlybranchkeyencryptioncontext +decryptonlyencryptioncontext +decryptresult +decryptrnd +decryptschedule +decrypttest +decrypttestvector +decrypttestvectortojson +decryptvectortodecrypttest +decryptvectortojson +decryptwithkeyhat decs +decsd decseq decsetoid +decsexp decsmf decsmflem +decso +decsocletype +decsort decspaper decsplit decstrictpartialorder @@ -15329,8 +26396,15 @@ decsubi decsuc decsucc dect +dectheory +dectodec +dectomaybe dectotalorder +dectreeeq +decurrying +decv decvalidfinite +decy ded dedb dedd @@ -15340,10 +26414,34 @@ dedea dedec dedekind dedekinddomain +dedekindeu +dedekindeulemeu +dedekindeulemloc +dedekindeulemlu +dedekindeulemlub +dedekindeulemub +dedekindeulemuub +dedekindicc +dedekindicclemeu +dedekindicclemicc +dedekindicclemloc +dedekindicclemlu +dedekindicclemlub +dedekindicclemub +dedekindicclemuub dedekindle +dedekindreals +dedekindrealsarchimedeanorderedfield +dedekindrealsfield +dedekindrealsorderedfield dedekindzeta +dedest dedf +dedg +dedge dedhb +dedi +dedicated dedicto dedictoimpldere dedlem @@ -15357,10 +26455,23 @@ deduced deduces deducible deducing +deducir deduct +deductantisym +deducting deduction +deductionimpelim +deductionimpintro +deductionlr +deductionmp +deductionp +deductionrl deductions +deductionsubst +deductiontheorem +deductionweaken deductive +deductively deducts dedup dedupbystring @@ -15374,95 +26485,391 @@ deed deee deef deep +deepassignment +deepdowncast +deepembedded +deepembeddeddef +deepembeddeddefs deeper deepest deepl +deeply +deepmonicpresentation deepr +deeprepr def defa +defabcdef +defabsstobj +defaction +defadjacent +defadvice +defaggr +defaggregate +defalgocrt +defalgoexgcd +defalgogcd +defali +defalis +defalist +defapply +defargs +<<<<<<< Updated upstream +======= +defass +>>>>>>> Stashed changes defat +defatleast +defatmostplus +defattach defau +defaul default +defaultaction defaultactions +defaultawsencryptionsdkconfig +defaultbar +defaultcryptoconfig defaultdepth +defaultdynamodbclientconfigtype defaultexpansion +defaultexpr defaultfindargs +defaultfooarg defaulthom +defaultkeystoreconfig +defaultkeyvectorsconfig +defaultkmsclientconfigtype +defaultlabel +defaultmaterialprovidersconfig defaultmkctorproxytype defaultmkproxytype +defaultname defaultnamestounfold +defaultnewcapacity +defaultparameters +defaultpdata defaultpreprocessors defaultratc defaultratcdf +defaultrelation defaults +defaultsht +defaultsp defaultstate +defaultstorm +defaulttests defaultunfoldpred +defaultv +defaultvaluereads defaut +defaxiom defb +defbitstruct defbot +defbyind +defbyte defc +defchar +defchoose +defchosen +defclass +defcnf +defcode +defcompell +defcon +defcong +defconst +defconstant +defconsts defd +defdata defdd +defdef +defdefparse +defderiv +defdescodec +defdiv +defdr defe +defeat +defeated +defeats defect +defection +defed defender +defeninfty defensive +<<<<<<< Updated upstream +======= defensivemaneuver +>>>>>>> Stashed changes +defenum defeq defeqabuse +defeqiso defeqns +defequiv defer deferr deferred deferring defers +defeval +defevaluator +defevthm +defexample +defexpansion +deff deffe deffec +deffi +deffilt +deffilter +deffix +deffixcong +deffixequiv +deffixtype +defflexsum +deffoall +defforall +deffun +deffunc defg +defgeneric defglsq +defgt +defhash defi deficient +defid +defin definable definableset +definb +defind define +definec +defineconst +defineconstlist defined +definedat definedatleft definedatright +definedg definedness +definednessfresh +definednessold +definednessunchanged +definedp +definedvars +definep defines +definetypeop defini +definici +definiciones definienda definientia +defininetely defining +definit definite +definiteassignment +definiteassignmentlocal +definiteassignmentout +definiteassignmentviolation +<<<<<<< Updated upstream +======= definitecause +>>>>>>> Stashed changes definitely +definiteness +definiti +definitio definition definitional definitionally definitionaly +definitionp definitions definitionsafety definitionval +definiton +definj +definline +definst +definstantiate +defint +defintion +defintions +definverse +defip +defipinv +defirred +defiso +defiteration defkind defl +deflabel +deflate +deflatedecode +deflateencode +deflation +deflationary +deflike deflist +defloat +defm +defma +defmacr +defmacro +defmap +defmapping +defmergesort +defmethod +defminterm +defmul +defmultplace defn +defname defndecl +defnf +defnhom +defnid defninfo +defnn defnode +defnofscotttopology +defnorm +defnormp +defnot +defns +defntoseg +defo +defoncurve +defopdeslike +defopen +defopener +defopeners +defoption +defoptions +defor +deforest +deforestation +deform +deformation defp +defpackage +defparameter +defparser +defpdx +defperiodic +defpip +defpipinv +defpkg +defplus +defpm +defpr +defpred +defpredicate +defprefix +defprod defprojection defprop +defproxy +defpt +defptun +defptuno +defpun +defquant +defr +defratf +defrec +defrecd +defrecord +defredundant +defree +defrefinement +defreppoint +defret +defretd +defrstobj +defrule +defruled defs +defsection +defseq +defsetf +defsexp +defshift +defsor +defsort +defspec +defstobj +defstrategy +defstrictequiv +defstrictisotoequiv +defstruct +defstructure +defstub +defsubgroup +defsubst +defsurj +defsvtv +defsymbolic deft +deftagsum +deftest +defth +deftheory defthm +defthmd +defthml +defthmnameprefix +defthmr defthms +deftraj +deftrajs +defttag +deftype +defu +defuel defun +defunambiguous +defund +defundd +defunf +defung +defunhh +defunl +defunr +defuns +defunt +defuntyped +<<<<<<< Updated upstream +======= defuse defused +>>>>>>> Stashed changes +defv defval defvalue +defvar +defvars +defvisitor +defvisitors +defwarrant +defwff +defwitness +defword +defx +defxch +defxdoc +defxor +defzer +defzerrat deg degaa degb @@ -15474,7 +26881,12 @@ degeneracies degeneracy degeneralize degenerate +degenerated +degeneratedequilateral +degeneratedmiddle +degenerateexamples degenerates +degeneration degernate deghost deghosted @@ -15491,10 +26903,20 @@ degltp degmatrix degnn degr +degrat degre degree degreebounds +degreecomp +degreeconst +degreed +degreee +degreeform +degreeformula +degreefunction +degreehom degreei +degreeidfun degreele degreelt degreeltequiv @@ -15502,18 +26924,28 @@ degreemonoidhom degreen degreeo degreeof +degreeproof +degreerule degrees degreesle degreesum +degreesusp degreew degreewise degreewiseepiwithinjectivekernel degs degt degtm +degz dei deindentstring +deirvable +<<<<<<< Updated upstream +======= deja +>>>>>>> Stashed changes +dejar +dejong del delab delabadjoinnotation @@ -15562,92 +26994,229 @@ delabtoval delabvar delabvecnotation delabwithuniv +deladd +delaing +delax delay delayed +delayede +delayoreventcontrol +delayp +delayredux delayreflleft delayreflright +delays +delayspec +delayspeceq +delayspeceqequiv +delayspecmonad +delayspecmonadlaws +delayspecmonadmorph +delayspecobs +delayspecorder +delayspecorderm +delc +delcol +deld +dele +deleakaged delegation +delet delete +deleteactive +deletealiasensurespublicly +deletebackupensurespublicly +deletebranchkey +deletebwda +deletebwdp +deletecacheentry +deletecacheentryensurespublicly +deletecacheentryinput +deletecustomkeystoreensurespublicly deleted deleteedg deleteedges deleteelem deletefar +<<<<<<< Updated upstream +======= deletefile +>>>>>>> Stashed changes +deletefindmax +deletefindmin deletefriend +deletefwd +deletei +deleteimportedkeymaterialensurespublicly deleteincidenceset +deleteitemensurespublicly +deletemax deletemin +deletenode +deletenth +deleteresourcepolicyensurespublicly deletes +deletetableensurespublicly deletethat deletethis deletetrailing deleteuniversalverts +deleteversion deleteverts deletewith +deleti deleting deletion +deletions +delf +deli deliberately delicate +delift deligne delim +delimite delimited +delimiteds +delimitedsuffix +delimiter +delimiters +delimits +delims +deliniation deliver delivered +deliverte delivery +dellast +delline +delmin delmod +deln +deloc delone deloneset +delooping +delopt +delphone dels delt delta +deltac deltaexpand deltafun deltag deltagenerated deltageneratedspace deltageneratedtotop +deltai +deltaint +deltainterpreter +deltaintret +deltaintsec +deltal deltamap +deltao deltas +deltatranslation +deltatranslationcomma +deltatranslationoneform +deltav +delts delusrgrpfromacl delusrgrpfromaclpcp delusrgrpfromaclpsp delusrgrpfromaclpss dem demand +dematricize +dement +dementum demo +demod +demodalisation +demodalize +demodify +demodulate +demodulize +demoerror demoivre demoivrealt +demom +demon demonic +demonotonicity +demons demonstrate +demonstrated demonstrates +demonstrating +demonstration +demonstrative demorgan +demorganand +demorganor +demorganpropositionallogic demorgans +demostrar +demote den dencert +dencode +dencoding +dencodingp dene +denerate denest +denestfraenkel +denesting denexp +deng denial +denied +denies +deno +denodes denom denomcondition +denomin denominator denominators +denomintor denoms denomsclearable +denop +denorm denormal +denormalize +denormalized +denormalp +denormals +denormaltranslatedvalue +denormalvalue +denormp denosuextmmhuzdnkrkisngvwk denot -denota denotation denotational +denotations denote denoted +denoteeq +denoteinv +denoteperm denotes denotesaltv denoteslem denoting +denotl denott denotts +denouement +denq +denqn +denqp +denqvz dens dense denseat @@ -15669,16 +27238,39 @@ densityd densityi densityprocess densq +dentro +denude +denum +denumber denumerable +denumeration +denv denvalue +denvr +denvrs deny denyall +denyalldom denyallfromto denynmt deoi +deop dep +depalist +departing +departure +depat +depatch +depath +depconst +depd +depe +depen depend +depended +dependen dependence +dependences dependencies dependency dependent @@ -15687,9 +27279,23 @@ dependenttypechecker depending depends dependson +depens +depfinvec depforalldepth +depfunext +depgraph +depi +depinv +depmap +depolari +depolarization +depolarized +deposit +depot depprod +depr depre +deprec deprecate deprecated deprecatedattr @@ -15702,6 +27308,8 @@ deprecating deprecation deprecationinfo deprecations +deprel +deprepcated depressed deprewrite deprewritelocaldecl @@ -15709,13 +27317,32 @@ deprewritetarget deprwlocaldecl deprwtarget deps +depsd +depse +depsmap +depsmaps +depsource +dept +deptable depth +depthforall +depthimp +depthlimit +depthnot +depthp +depths +depthv +depthw deq +deql +deque dequeue +dequote der derandomized derang derangement +derangementp derangements derangementscongr derangementsi @@ -15723,28 +27350,53 @@ derangementsoptionequivsigmaatmostonefixedpoint derangementsrecursionequiv derangen derangenlem +deranges derangf derangfmla deranglem derangsn derangval +derbernstein dere +derecursified +dereef deref +derefbyte +derefbytevec dereference +dereferencing +deregwrite dereimpldedicto derelict dereliction derep +derestricts derg +dergs +dergsn deri derisvestar deriv +deriva derivability derivable +derivableassu +derivableb +derivabled +derivablefinitewitnessed +derivablem +derivablen +derivablep +derivablerefl +derivables +derivablev +derivablex +derivablez derivassum derivat derivati derivation +derivationalgorithm derivationofsectionofkersqzero derivationquotkersq derivationquotkertotal @@ -15753,15 +27405,25 @@ derivationtensorproduct derivationtosquarezeroequivlift derivationtosquarezerooflift derivative +derivatived derivativefinsupp derivativefun +derivativei derivatives derivativesdefinitions derivativeuniqueness derivaux +derivb +derivboth +derivc derivcgf derivclm +derivcutrule +derivd +derivdiff derive +deriveable +deriveb derivebool deriveboolofiff derived @@ -15772,44 +27434,89 @@ derivedfromsubfieldclass derivedinstances derivedlength derivedlengthofideal +derivedp derivedseries derivedseriesmap derivedseriesofide derivedseriesofideal derivedset +derivee +deriveejacobian +deriveencryptionkeyfrombranchkey derivefunctor deriveg derivegstar deriveint +derivekey +derivekeys +derivekeysfromintermediatematerial derivel derivelawfulfunctor derivelawfultraversable +deriveln derivels +derivem +deriveml +derivemr deriven derivenat +derivenid derivenotprime +derivepointstoarray deriver deriverat derivern derives +derivesa +derivesharedsecret +derivesharedsecretensurespublicly derivesimp +derivesop derivestar derivethms derivetraversable +derivev +derivex +derivez derivf derivfamily derivg +derivi deriviative deriving derivinghandler +derivleft +derivleftbackslash +derivleftdot +derivleftslash +derivm derivmgf +derivmn +derivmnn +derivmono +derivmxaddc derivmz +derivn +derivnc +derivnd +derivnmn +derivnmnn +derivnmxaddc +derivnn +derivns +derivnxn +derivnz +derivone derivprop derivrclike +derivright derivrootweight derivs derivsaux +derivseqext derivseries +derivsn +derivstate derivweierstrassp derivweierstrasspexcept derivweierstrasspexceptseries @@ -15817,17 +27524,32 @@ derivwi derivwit derivwith derivwithin +derivx +derivxn +derivxsubc +derivz +derj +deround ders +dersd dersh +dersi derun des +desactivaciones desagaio +desargue desargues +desarguesian desc desca descaddmonoidhom descale +descalist +<<<<<<< Updated upstream +======= descar +>>>>>>> Stashed changes descartes desccapp desccochain @@ -15837,9 +27559,15 @@ desccolimittype desccomphomotopy desccycles desce +descen descend descendalong +descendant +descendants +descendg descending +descendingp +descendmappath descends descendsalong descent @@ -15866,6 +27594,8 @@ deschomotopyzeroone deschomotopyzerosucc deschomotopyzerozero descidhomotopy +descip +descl descmap descmapobj descmonoidhom @@ -15873,63 +27603,204 @@ descmorphism descofisleftkanextension descoftruncation descopcycles +descore descpoch descpochhammer descq descr descresiduefield +descri describe +describebackupensurespublicly +describecontinuousbackupsensurespublicly +describecontributorinsightsensurespublicly +describecustomkeystoresensurespublicly described +describeendpointsensurespublicly +describeexportensurespublicly +describeglobaltableensurespublicly +describeglobaltablesettingsensurespublicly +describeimportensurespublicly +describekeyensurespublicly +describekinesisstreamingdestinationensurespublicly +describelimitsensurespublicly describes +describetable +describetableensurespublicly +describetablereplicaautoscalingensurespublicly +describetimetoliveensurespublicly describing descrighthomology description +descriptionlessthan +descriptionlessthanisreflexive +descriptionlessthanisstronglyconnected +descriptionlessthanistotal +descriptionlessthanistransitive +descriptionlist +descriptions +descriptionsp +descriptiontype descriptive +descriptor +descriptorbits +descriptorp +descriptors +<<<<<<< Updated upstream +======= descrp +>>>>>>> Stashed changes +descs descshortcomplex descsigma desctoinjective desctruncge desctruncgt descuniq +descvarnames deserial +deserializationerror +deserializationresult deserialize deserialized +deserializedintermediatewrappedmaterial +deserializedres +deserializeedkciphertext +deserializeintermediatewrappedmaterial deserializing deserve +deserves +deset +deshadow +deshadowing design +designate +designated +designator +designatorp +designators designed +designi +designwires +desir desirable desire desired +<<<<<<< Updated upstream +======= +desmoines +>>>>>>> Stashed changes +desnity despec despite +despues +desround +<<<<<<< Updated upstream +======= dessertwine +>>>>>>> Stashed changes +dessicate dest destab +destalphat +destapx +destatify +destchar +destchart +destcons +destcvopt +destffiop +destffit +destfloat +destfun +destgroup +desthfs +destident +destination +destinationencryptioncontext +destinations +destinner destinnetlistaux +destint +destintt +destiny +destl +destlet +destlexerrort +destlf +destlist +destlongidt +destm +destmk destnet +destnum +destpair +destpragma destr +destrci +destreplidt +destresult destrimpl +destrmi +destroy +destroyed +destroys destru +destruc destruct +destructed +destruction +destructo +destructor +destructores destructors +destructure destructures +destructuring dests +destsi +deststr +deststream +deststring +deststringt +destsxcons +destsxnum +destsxsym +destsymbol +destsymbolt +desttok +desttyvarpt destutter +destvar +destwo +destwordt +desugar +desugaring +desugars +desum +desusph desync det detab +detach +detachable +detached detail +detaile detailed details detailtrace detaux +detdead detdiag +dete +detec detect detectability detectable detectd +detectdead +detecte detected detecti detection @@ -15937,68 +27808,120 @@ detectlambdatheoremargs detector detects deteq +deter +detered determ +determi determinacy determinant determinants +determinate determination determine determined +<<<<<<< Updated upstream +======= determinedbydefinitemethod determinedbyfixedmethod determinedbyitselfalone +>>>>>>> Stashed changes +determinedclient +determineelection determines +determini determining +determinised determinism +determinismn deterministic +deterministically deterministicd +deterministicflatmap +deterministicflatmapwithresult +deterministicmapwithresult +deti detid detidres detinidres detinvertibleofinvertible detinvertibleofleftinverse detinvertibleofrightinverse +detl detleib detleiblem detlem +detm detmonoidhom detnezero +detour detp +detrepr +detrivial detrowalternating dets detsem +detta +dettime +dettimei +detuplify +detv detxrnidres +detz detzero +deuce deux +deuxpointdeux +deuxpointtrois +deuxpointun dev +deva +deval +devb devbc +devel develop developed developing +developme development developments develops devext +devi deviate +deviation device +devices +devil +devolution devop devos devosmulrel devoted +devreserp +devv +dew dex +dexn dexp +dexpr +dexprs dext dfa dfab dfabf +dfabsmax dfac dfacacn dfacbasgrp dfacfin dfackm +dfactor +dfactorbot dfacycgr dfad dfada +dfaddc dfadj dfadjliftmap dfaeccf @@ -16010,6 +27933,8 @@ dfafv dfaimafn dfaiota dfalse +dfan +dfandc dfantisymrel dfarea dfatafv @@ -16032,6 +27957,7 @@ dfbfa dfbi dfbigcup dfblockliftmap +dfbw dfc dfca dfcafd @@ -16062,6 +27988,7 @@ dfcomember dfconn dfconngr dfcoss +dfcw dfd dfda dfdac @@ -16069,6 +27996,7 @@ dfdae dfdb dfdddc dfdde +dfddew dfddf dfde dfdec @@ -16086,6 +28014,7 @@ dfeaf dfec dfecf dfed +dfee dfeea dfef dfefe @@ -16100,6 +28029,9 @@ dferaltv dfeu dfeumo dfeven +dfevenfin +dfex +dfexdc dfezvfdqovxvqdmiabewkvyo dff dffa @@ -16125,16 +28057,21 @@ dffun dffunaltv dffunsaltv dffv +dfg dfgaxtpfh dfgcd +dfge dfgric dfgrlic dfgrp +dfgt dfhc dfhe dfhnorm +dfi dfich dfid +dfidk dfif dfifp dfii @@ -16143,7 +28080,10 @@ dfim dfima dfimafn dfimafnf +dfimak dfin +dfineb +dfined dfinfre dfinito dfinsupp @@ -16160,24 +28100,42 @@ dfiso dfitg dfiun dfiunv +dfix dfixp +dfk +dfkcoc +dfkcocl +dfkcunifyl +dfkcwalkstarl +dfkoc +dfkunify +dfl +dflat dfle +dflec dflidl dflim dflinc +dflip dflog dflow dflt +dfltr dfma +dfmap dfmembpart dfmgc dfmo dfmoeu dfmpo dfmpoa +dfmpq dfmpt +dfmptg +dfmq dfn dfnan +dfnb dfnbgr dfnbgrss dfneg @@ -16185,6 +28143,7 @@ dfnelbr dfnf dfnfc dfnn +dfnnc dfnnf dfnns dfno @@ -16193,6 +28152,7 @@ dfnrm dfnul dfod dfodd +dfoddfin dfoi dfoldl dfom @@ -16204,20 +28164,27 @@ dfopif dfoprab dfor dford +dfordc +dfov +dfp dfpart dfpet dfpeters dfpetparts dfphi dfpjop +dfplpq +dfplq dfpo dfpprod dfpr dfpre dfpred dfprm +dfproj dfpss dfpth +dfpw dfqmap dfqs dfrab @@ -16226,11 +28193,13 @@ dfrcl dfrdg dfrecs dfree +dfreevars dfrefrel dfrefrels dfrel dfrelog dfres +dfresh dfrex dfrhm dfringc @@ -16249,27 +28218,37 @@ dfsbcq dfsclnbgr dfsdom dfse +dfsi dfsingles dfsmo dfsn dfso +dfsp dfss +dfsset dfssf dfssr dfsstate dfst +dfste dfsuccf dfsuccl dfsucmap dfsucon +dfsume +dfsuml +dfsumr dfsup +dfswap dfswapf dfsymdif dfsymrel dfsymrels dft +dftap dftermc dftermo +dftest dftp dftpos dftr @@ -16281,33 +28260,60 @@ dfttrcl dfu dfufd dfun +dfuncpo +dfunctor +dfune +dfunext dfuni dfuniv +dfunlattice dfunlike +dfunposet dfunset dfur dfuzi dfv dfvd dfvopnbgr +dfvs +dfw dfwe +dfwith +dfwithin +dfwithout +dfwithp dfwppr +dfx dfxlim dfxor dfxp dfxrn +dfy dfz +dgaxiom +dgc +dgcbl dge dgen +<<<<<<< Updated upstream +======= dges +>>>>>>> Stashed changes +dget +dgh dghm dghmi dghms +dgix dgjbdhg +dgk +dgm +dgms dgoequivhomologicalcomplex dgoequivhomologicalcomplexcounitiso dgoequivhomologicalcomplexunitiso dgotohomologicalcomplex +dgpdhom dgr dgraa dgraacl @@ -16317,6 +28323,7 @@ dgraaub dgraaval dgrad dgradd +dgraph dgrb dgrcl dgrco @@ -16336,15 +28343,35 @@ dgrub dgrval dgt dgv +dhain +dhand +dhasequivs +dhcompose +dhi +dhigh dhindistinguishable +dhnf +dhom dhomologydata dhomologyiso dhops +dhor +dhpolnomial +dhpoly +dhpolynomial +dhprop +dhreduce +dhs +dhscale +dhvfgbc dhx dhy +dhyps dia +diabled diacln diacnvcln +diad diadic diadm diadmcln @@ -16357,18 +28384,29 @@ diaelval diaf diaffval diafn +diaform diafval diag diagaddmonoidhom diagcic diagciso diagcl +diage +diagempty diagentries diagffth diagfunc +diagfz +diaggr +diagker +diagl diaglbn diaglem diaglinearmap +diagmat +diagmatrix +diagmx +diagnal diagnostics diago diagona @@ -16381,6 +28419,11 @@ diagonalcoverdiagonalrange diagonalhomequiv diagonalinvertible diagonalinvertibleequivinvertible +<<<<<<< Updated upstream +======= +diagonalise +>>>>>>> Stashed changes +diagonaliso diagonalizable diagonalization diagonalize @@ -16390,15 +28433,22 @@ diagonalobj diagonalobjpullbackfstiso diagonaloneequivleftregular diagonaloneisoleftregular +diagonalp diagonalpath diagonalrestrictisodiagonal diagonalringhom +diagonals +diagonalsbisect +diagonalsmeet diagonalstrongdualpi diagonalstrongdualprod diagonalsuccisofree diagonalsuccisotensordiagonal diagonalsuccisotensortrivial +diagonalzip diagpropd +diagr +diagra diagram diagrambuilderm diagramcomp @@ -16415,6 +28465,7 @@ diagramisowidecospan diagramisowidespan diagrammap diagramnattrans +diagramness diagramobj diagramofcocones diagramofcoconesinhabited @@ -16423,13 +28474,20 @@ diagramofconesinhabited diagrampullback diagrams diagramwithuniqueterminal +diagrer +diagrvalued diagset +diagstep diagsub diagval +diagvector diai diainn diaintcln dial +dialog +dialogue +dialogues dialss diam diame @@ -16438,9 +28496,14 @@ diameter diameters diametre diamond +diamondo diamondop +diamondp diamonds dian +diand +diandproof +diandsound diaocn diaord diarnn @@ -16480,9 +28543,14 @@ dicelvaln dicffval dicfnn dicfval +dich +dicho dichotomous dichotomy +dichotomybool +dichotomyboolsym dicirpyc +dicj dickson dicksonl diclspsn @@ -16491,18 +28559,23 @@ dicn dicopelval dicssdvh dict +dictated dictates dictating dictator dictatori +dictatorship dictionary dicvaddcl dicval dicvalreln dicvscacl did +didj didn die +diemap +diese diet dieudonne dif @@ -16515,6 +28588,7 @@ difcom difd difdif difdifdir +difdifdirss difelcarsg difelfzle difelfznle @@ -16528,10 +28602,17 @@ difexd difexg difexi diff +diffaspi +diffassign +diffb +diffcomplex +diffconst +diffconstproof diffconton diffcontoncl diffd diffe +diffedge diffeologi diffeologicalspace diffeology @@ -16540,61 +28621,108 @@ diffeomorphism diffeomorphisms diffeomorphofbijective diffeos +diffeq differ differe differen +differenc difference differenceaux differencefunctor +differencemap +differenceofparts differences differenceset different -differentfrom differenti +differentia differentiab differentiability differentiabl differentiable differentiablea differentiableat +differentiableb +differentiabled +differentiablem +differentiablen differentiableon +differentiablep +differentiablev differentiablewithi differentiablewithinat differentiablewithinatprop +differentiablex +differentiablez +differentiablezl differential differentialalgebra differentialalgebrafinitedimensional differentialfinitedimensional differentialideal +differentialo differentialobject differentials differentialsconstruction differentialsrelations differentialssolution differentiate +differentiates differentiation differentideal differently +differentstyleproof +differenttypes differing +differnce +differntials differs differt +difff difffzod diffgeo diffi diffib difficult +difficulties difficulty +diffie +diffield +diffifi +diffint +diffisn +diffitest diffiunisros +diffl difflengths +difflis difflist +diffm +diffmx +diffmxe +diffmxsl +diffn +diffp +<<<<<<< Updated upstream +======= diffprop +>>>>>>> Stashed changes +diffquaternion diffr +diffrat +diffreal diffs +diffsn diffsq +diffsup difftoidealofquotientcompeq +diffv diffvar diffvec +diffvsl +diffx diffz +diffzl difgtsumgt difi difico @@ -16603,7 +28731,11 @@ difidalt difin difindi difindir +difindiss difinf +difinfinf +difinfsn +difinfsnlem difininv difioo difjust @@ -16611,6 +28743,7 @@ difltmodne difmap difmapsn difmbl +difmf difmod difmodm difn @@ -16631,8 +28764,10 @@ difsnen difsnexi difsnid difsnpss +difsnss difsqpwdvds difss +difsscompl difssd difsssymdif difsymssdifssd @@ -16644,8 +28779,18 @@ difundir difunieq difxp dig +diga digamma +digb +digeq +digeqaxiom digest +digestalgo +digestalgorithm +digestblock +digestensurespublicly +digestlength +diget digexp digfval digit @@ -16656,34 +28801,52 @@ digitauxmore digitchar digitchars digitcharsunique +digitdc digitgivesboundednum digitinv digitless digitmore +digitmul digitnnormmin digitnotzero digito +digitp digitpredvnumisprecision digits digitsapp digitsappend digitsaux +digitsd +digitset +digitsidents +digitslabels +digitstring +digitsublow +digitsublowup +digitsubup +digitsum digittolist digittonlist digittotree digitvnumisprecision digitwise +diglow dignn dignnld +digr digraph digraphd digraphi +digraxiom +digs +digup digval digvalnn dih dihat dihatexv dihatlat +dihatn dihcl dihcnv dihcnvcl @@ -16698,7 +28861,6 @@ dihffval dihfn dihfval dihglb -dihglbb dihglbcn dihglbcpren dihglblem @@ -16744,6 +28906,7 @@ dihss dihsslss dihssxp dihsumssj +dihv dihval dihvalb dihvalc @@ -16752,19 +28915,36 @@ dihvalcqat dihvalcqpre dihvalrel dihwn +dihx +dihxb dii +diirr +diirre +diirrpe +dij +dijjointp +dijk dijkstra +dijkstraalgorithm dil +dilatation +dilate dilation dilationclass dilationequiv dilationequivclass dilations dilatransvections +dilemma dilfsetn +dilmem +diln dilsetn +dilute +dilutemem dilworth dim +dimacs dimat dimatis dimatlem @@ -16773,19 +28953,27 @@ dimb dimbaltn dimbas dimc +dimcheck dimcl dimcrng dimelbas +dimen dimens +dimensi +dimensio dimension dimensional dimensionality dimensionleone +dimensionless +dimensionlist dimensionmismatch dimensions +dimf dimh dimid dimindex +diminishing dimkerim dimlem dimlssid @@ -16794,26 +28982,54 @@ dimn dimp dimpl dimplus +dimpoly dimpropd dimq +dimr dims dimscm +dimt +dimv dimval dimvalfi +dimvec +dimvf +dimvs +dimword +dimwords +din dinattrans +dinatural dinaturality +dinaturaltransformation +dinc +dind +dindex dindistinguishable +ding dini dining dinit +dinjectiveb +dinjectivep +dinjectivepn +dinsupp +dinsuppp +dinsupppn +dint +dintensionality +dinter dinv dinvar dinvarc dinvarm +dinwords +dinwrite dio dioid dioph diophantine +diophantus diophfn diophin diophpfun @@ -16833,32 +29049,53 @@ dipfval diporthcom dipsubdi dipsubdir +dipt dir dirac diracandcount diracdelta +dirace diracproba diracprobaequiv diracprobaequivsymm diracprobahomeomorph diracprobainverse +diract +diraf dirbd +dirbits dircont dirconteq +dircst dirdm dire +direc direct +directcost directe directed directedaffinecover directedcover +directedg +directedgraph +directedlength +directedness directedon directedorders +directedset directedsystem +directification +directified +directify direction directional +directiondiff +directionlist directionofnonempty +directionp directions +directive +directives directl directlimit directlimitcocone @@ -16867,11 +29104,15 @@ directlimitiscolimit directlimitleft directlimitright directly +directo directories directory directorydependency directorydependencycheck directorydependencylinter +directoy +directp +directprod directproductofnormal directs directsum @@ -16881,7 +29122,17 @@ directsumleft directsumnezeromulequiv directsumpow directsumright +directuseofallocated +directuseofallocatedwithstarstar +directv +directve +directvegeq +directvp +diredge +diredges +dirflip dirge +dirhypcst dirichlet dirichletcharacter dirichletinverse @@ -16891,6 +29142,7 @@ dirichletsummand dirichletsummandhom dirichletunittheorem dirith +dirk dirker dirkercncf dirkercncflem @@ -16902,32 +29154,82 @@ dirkerre dirkertrigeq dirkertrigeqlem dirkerval +dirlist +dirname +dirort +dirp +dirpar +dirprod +dirprodab dirprods +dirr +dirre dirref dirrel +dirrk +dirrp +dirs +dirseg dirset +dirsum +dirsumd +dirsumi dirsupclosed dirsupinacc dirsupinaccon +dirsur dirtr dirty +dirtycache +dirtycacheconsistent +dirtycachesystem +dirtycachewrite +dirtyflush +dirtyload +dirtym +dirtysetflush dis +disa +disab +disabl disable disabled +disabledp +disablekeyensurespublicly +disablekeyrotationensurespublicly +disablekinesisstreamingdestinationensurespublicly +disabler +disables +disablestmt disabling +disablling disagree disagreement disallow disallowed +disallowedclienta +disallowedclientb +disallows disambig disambiguatefailures +disambiguation disamis +disappears +disassemble +disassembly +<<<<<<< Updated upstream +======= disbanding +>>>>>>> Stashed changes +disble disc discard discarded discarding +discards discbas +discernable +discerning disch discharge discharged @@ -16941,56 +29243,88 @@ dischargeside dischargeusingassumption dischargewrapper discharging +discheap discipline disciplines discld discmp +disco disconnect +disconnectcustomkeystoreensurespublicly disconnected discontinuities discontinuity discontinuous +discount +discounted discourage discouraged +discove discover discoverability discovered +discoveries discovers +discovery +discoveryfilter +discoverymatch +discoverymultikeyring +discpred +discprop discr discrat +discrcat discre discrepancy discret discrete +discreteb +discretebiinv discretecas discretecases discretecategory discretecontaction +discretedec +discretedeltaint discreteequiv +discretefin +discreteinfnat discreteisconnectedequivpunit +discreteleftadj +discretelist +discretemaybe discretemeasurablespace discreteness +discretepm discretepresieve discretequotient +discretesetquotients discretesieve +discretesigmaalgebra discretespace discretesupport discretetiling +discretetop +discretetopologicaltype discretetopology discreteunderlyingadj discreteuniformity discretization +discretize discrim discriminant discriminate discrimination discriminator +discriminators discrimrec discrl discrmoore discrr discrs discrtree +discrwithinfin +discsiheap discsnterm discsntermlem discsubc @@ -17000,25 +29334,35 @@ discthin discthing discuss discussed +discusses discussing discussion discussions -diseaseorsyndrome diseq +disequality +disgusting dishaus +<<<<<<< Updated upstream +======= dishonest +>>>>>>> Stashed changes +disintct disintegrate disintegration disintegrationi +disiplined disj disjabrex disjabrexf disjabso +disjall disjaltv disjaltvid disjaltvidres disjaltvinidres disjaltvxrnidres +disjc +disjcases disjcond disjcsn disjd @@ -17031,6 +29375,8 @@ disjdmqscossss disjdmqseq disjdmqseqeq disjdmqsss +disjdom +disjdomgd disjdsct disje disjeccnvep @@ -17042,6 +29388,7 @@ disjenex disjeq disjeqd disjeqi +disjeth disjex disjexc disjf @@ -17055,12 +29402,15 @@ disjimeldisjdmqs disjimi disjimin disjiminres +disjimpi disjimres disjimrmoeqec disjimxrn disjimxrnres disjin +disjineq disjinfi +disjiont disjiun disjiunb disjiund @@ -17069,37 +29419,56 @@ disjiunion disjk disjl disjlem +disjn disjne +disjneq disjnf +disjnim +disjnims disjnt disjo disjoi disjoin +disjoined +disjoins disjoint +disjointb disjointbase disjointd disjointed disjointedrec +disjointencryptioncontext +disjointencryptioncontextcorrect +disjointfam disjointframe disjointi +disjointify +disjointion +disjointl disjointness disjointofdiff disjointofdiffunion disjointofunion +disjointp disjointpaths +disjoints disjointschedules +<<<<<<< Updated upstream +======= +disjointsets disjointsetsi +>>>>>>> Stashed changes disjointsigma disjointsum +disjointu disjointunion -disjointunionof -disjointwith disjor disjord disjorf disjorimxrn disjors disjorsf +disjp disjpr disjpreima disjprg @@ -17119,6 +29488,7 @@ disjrnmpt disjs disjsn disjsnxp +disjsplit disjss disjssd disjssi @@ -17127,17 +29497,24 @@ disjssun disjsuc disjsum disjsups +disjtinct disjtp disjtpsn disjun +disjunc +disjuncive disjunct disjunction +disjunctionp disjunctions +disjunctionsp disjunctive disjunctived disjunctivei +disjunctivity disjunctor disjuncts +disjunctsp disjuniel disjunion disjunionequiv @@ -17158,26 +29535,57 @@ disjxwwlksn disk diskboundary diskboundaryinclusion +diskopfailureparams +diskopmultiparams +diskproj disks +dislike dislly disllycmp +dislodge dismantle +dismiss +disnat diso disoa disob disoc disoh +disorder +disorders +disp +dispa dispaper +disparity +dispat +dispatc dispatch dispatched +dispatches dispatchlemma +dispath +dispcatmagma dispcmp +dispense +disph +displacement display +displaybad +displaycorrected +displayed +displayedcategory +displayedprecategory +displayedprecategorynotation displayfib +displaying +displaylang displays disposal dispose +disppre +disppremagma disr +disrupt dissection dissector dissimilar @@ -17186,6 +29594,7 @@ dissneq dissneqlem dissnlocfin dissnref +dissolved dissym dist distance @@ -17193,40 +29602,119 @@ distancefunction distances distant distapproxtree +distc +distd distdenseseq +distdistinct +distdistinctnull distel +distesti +distex distgp disti +distibutive +distibutivity +distict +distid distideal +<<<<<<< Updated upstream +======= distin +>>>>>>> Stashed changes +distinc distinct distinctconstantstheory +distinctdist distinctelems +distincti +distinctimplies +distinctio distinction distinctness +distinctnesses distinctnets +distinctoovv +distinctooww +distinctp distinctpairs distincts +<<<<<<< Updated upstream +======= +distinctseq +>>>>>>> Stashed changes +distingu distinguish +distinguishable distinguished distinguishedtriangles +distinguisher distinguishes distinguishing distint +distitem +distj +distjoing distl distlat +distlattice +distlatticecategory +distlatticeequiv +distlatticehom +distlatticepath +distlatticescategory +distlatticestr +distlc +distlem +distli +distlist +distlj +distlmax +distlmin +distlr +distm +distmap +distmax +distmin distmult +distn +distnc +distndl +distndr +distnegsuclmax +distnegsuclmin +distnegsucrmax +distnegsucrmin +distnel +distner +distnn distnorm +distnq +distns +distnull +distoa +distoah +distoovv +distooww distop distopon distortion +distp distperm +distposlmax +distposlmin +distposrmax +distposrmin +distprobfins distps distr +distract +distrc distri distrib distribbasechange distribhaarchar +distribimp +distribl distribla distriblattice distriblatticebot @@ -17244,33 +29732,70 @@ distribnotat distribnotaux distribnotonceat distribnotstate +distribr distribsemigroup distribsmul distribsmulset distribsmultolinearmap +distribu distribumulaction +distribut distribute distributed +distributeplus distributes distributesover +distributi +distributing distribution +distributiond +distributioni distributions +distributiv distributive distributivelattice +distributivelaw distributively +distributivi +distributividad distributivity +distributor +<<<<<<< Updated upstream +======= districtsuriname +>>>>>>> Stashed changes +distrj +distrl distrlem +distrlemma +distrlr +distrmax +distrmin distrnq +distrnqg distro distrpi +distrpig distrpr +distrprg +distrputl +distrputlg +distrr distrsr +distrsrg dists +distsem distset distsingle +distsn distspace +disttimesn disttriang +disturbing +disturbs +distvvuu +distweighttype +distz dit dite ditg @@ -17288,72 +29813,129 @@ ditto div diva divadddiv +divadddivap +divadddivapi divadddivd divadddivi divalg divalgb divalglem +divalglemeuneg +divalglemeunn +divalglemex +divalglemnn +divalglemnqt +divalglemqt divalgmod divalgmodcl +divap divass +divassap +divassapd +divassapi +divassapzi divassd divassi divasszi +divauto +divbdiv +divbl +divboth divby +divbyhcf divbymonic divbynat +divca divcan +divcanap divcaseson divccn divccncf +divccncfap divccnold +divceilnz divcl +divclap +divclapd +divclapi +divclapzi divcld divcli divclzi divcn +divcnap divcncf +divcncfap divcncff divcnold divcnv divcnvg divcnvlin divcnvshft +divcode divcoeff divconjdvds divconst divcxp divcxpd divd +divdec divdenle divdir +divdirap +divdirapd +divdirapi +divdirapzi divdird divdiri divdirzi divdiv +divdivap divdivdiv +divdivdivap +divdivdivapi divdivdivd divdivdivi divdivs +divdivtodivmul +divdivtwopower +divdl divdm divdn +divdp dive +divede +divee divelunit diveq +diveqap +diver diverg diverge +diverged +divergel divergence divergences divergent +divergentpost +diverger diverges diverging +diverrormsg diversity +divert diveucl diveuclz divex divexact +divexp divf +divff +divfi divfl +divfnzn +divfs +divg divgcdcoprm divgcdcoprmex divgcdnn @@ -17362,29 +29944,65 @@ divgcdodd divgcdoddaltv divgcdz divge +divgi +divgik +divgikl +divgikr +divgixx +divgr +divgrm +divgrmid +divgrml +divgs divgt +divh divi divibility divid +dividabilty +dividap +dividapd +dividapi dividd divide +dividebyzero divided dividedpowers dividedpowersbot dividedpowersdefinition +divideeq +dividei +divideinterval dividend +divident +divider dividerow divides +dividesboth dividesdef +dividesidempotent +dividesl +dividesp +dividesproperty +dividesr +dividesubtraction +dividesupperbound +dividezero dividi dividing dividold +divif +divimm divint divintmap divinvmonoid divinvonemonoid divinvtopologicalgroup divir +divis +divisable +diviscorrect +divisib divisibility divisible divisibleby @@ -17394,6 +30012,11 @@ divisiblehull division divisionalgebra divisioncommmonoid +divisionerrorbounded +divisionisantimonotonic +divisionisantimonotonicstrict +divisionismonotonic +divisionismonotonicstrict divisionmonoid divisionring divisionringinverse @@ -17403,9 +30026,11 @@ divisions divisionsemir divisionsemiring divisive +divisless divisor divisorchain divisori +divisorpairs divisors divisorsanti divisorsantidiag @@ -17413,11 +30038,22 @@ divisorsantidiagonal divisorsantidiagonalfactors divisorsantidiagonallist divisorshom +divisorsum +divisorvsum +divkf +divkr +divl divle divleft divlimc +divlimm divlogrlim +divlr +divls divlt +divlu +divluimm +divm divmaxpow divminus divmo @@ -17426,54 +30062,111 @@ divmodaux divmodbymonicaux divmodequiv divmodidentity +divmodnative +divmodreal +divmods +divmodu divmonoidhom divmonoidwithzerohom divmonomial divmul +divmulap +divmulapd +divmulapi +divmulapzi divmulass +divmulassap divmulasscom +divmulasscomap divmuld divmuldiv +divmuldivap +divmuldivapd +divmuldivapi divmuldivd divmuldivi divmuldivsd divmuleq +divmuleqap +divmuleqapd divmuleqd +divmulequalsdivdiv +divmulequalsmuldiv divmuli divmuls divmulsd divmulsw divmulswd divmultassoc +divmultgcd +divmultmodm divmulzi +divn +divna +divnac divnat divnatlttwopow +divndl +divndr divne divneg +divnegap +divnegapd divnegd +divnk +divnma +divnmdl +divnml +divnmr +divnn +divnonzero +divnr divnumden +divnz divof divofhom +divop +divorder divp +divpac divpairs +divpe divpf +divpk +divpkc +divpl +divpn +divpow divpp +divpr +divprod +divq +divqp divr divrad divradical divrcnv divrec +divrecap +divrecapd +divrecapi +divrecapzi divrecd divreci +divrecursive divreczi divrelconstdata +divrem divri divright divring divringops +divringpred +divrl divrngcl divrngidl divrngpr +divrpred divrr divs divsassd @@ -17485,28 +30178,66 @@ divsclw divsclwd divsd divsdird +divse +divseq +divsequence +divset divsfval +divsfvalg +divsgcd +divshiftthm divsidd +divsimm divsmo divsnegd +divsp divsqrsum divsqrsumf +divsqrtdelta divsqrtid divsqrtsum divsqrtsumlem divsqrtsumo divsrecd +divstatus +divstep +divsteps +divstrictlymonotonic divsub divsubdir +divsubdirap +divsubdirapd divsubdird divsubdiv +divsubdivap divsubdivd divsval divterm +divtwopower +divu +divuimm divval +divvalap divx divxpoworder divxpoworderhom +divz +divza +divzac +divzdiv +divzdl +divzdr +divzero +divzerowithreq +divzk +divzma +divzmdl +divzml +divzmpl +divzmpr +divzmr +divzn +divzz dix dixit dixiymswlfcli @@ -17515,6 +30246,8 @@ djaffvaln djafvaln djajn djavaln +djci +djdi djh djhcl djhcom @@ -17532,71 +30265,130 @@ djhspss djhsumss djhunssn djhval +dji djn +djoins +<<<<<<< Updated upstream +======= djoint +>>>>>>> Stashed changes djrrilceqnyeyeuhksez dju djuassen +djucllem djucomen djudisj +djudm djudom djudoml +djudomr djuen djuenun djueq djuex djuexalt djuexb +djuf djufi +djufun djuin djuinf +djuinj +djuinr djulcl +djulclalt +djulclb +djulclr djulepw djulf +djune djunum djur djurcl +djurclalt +djurclr djurf djuss djussxp djuun +djuunr djuunxp djuxpdom +djv +djvm dkctvpxpxp dkernelsequence dkey +dkf dkj dkk +dklen +dkp dkrrsnxbxtzojqcbmkwlhpziaclsub +dks dktkyxfzdkqsgtbmilbzzjjfvykpdvj +dla +dlam +dlambda +dlaml dlat dlatjmdi dlatl dlatmjdi dle dlem +dlemma +dlemstep dlen dleq +dlet +dletc +dlete +dletrec +dlevelpacking dlf +dlgh dlhpp +dlift dlim +dlimc +dlime +dlimp +dlin dlinearmap dlineq dlinvh dlist +dlistp +dlists dlit +dll dlmgy dlmldaqkoyuicfsula +dlnorm dlo +dload dloc +dlocal +dlock +dlog +dlogic dlookup +dlow dlp +dls +dlshfdiag +dlsub +dlsubmx dlt dlts +dlwchem dlwwlknondlwlknonen dlwwlknondlwlknonf dma dmaddpi +dmaddpq +dmaddpqlem dmaddsr dmadjop dmadjrn @@ -17607,6 +30399,8 @@ dmafv dmalt dmap dmarea +dmargin +dmargine dmatalt dmataltbas dmataltbasel @@ -17625,7 +30419,11 @@ dmatsgrp dmatsrng dmatsubcl dmatval +dmax dmb +dmbld +dmbst +dmbsy dmcdm dmclimxlim dmcnvcnv @@ -17640,17 +30438,22 @@ dmcosseq dmcosseqold dmcosseqoldold dmcossold +dmcross dmct dmcuts dmdbr dmdcan +dmdcanap +dmdcanapd dmdcand dmdcompli dmdi dmdju +dmdl dmdm dmdmd dmdoc +dmdom dmdprd dmdprdd dmdprdpr @@ -17658,22 +30461,29 @@ dmdprdsplit dmdprdsplitlem dmdsl dmdsym +dme dmec dmecd dmem +dmen dmep dmeq dmeqd dmeqi +dmerge +dmesh dmex dmexd dmexg +dmfc dmfco dmfcoafv dmfex dmfexalt dmfi +dmfrec dmfun +dmg dmgmaddn dmgmaddnn dmgmdivn @@ -17685,7 +30495,9 @@ dmico dmiin dmin dminss +dminus dminxp +dmitry dmiun dmlogdmgm dmmcand @@ -17705,7 +30517,9 @@ dmmpti dmmptif dmmptss dmmptssf +dmmrnm dmmulpi +dmmulpq dmmulsr dmmzp dmn @@ -17716,7 +30530,13 @@ dmnonrel dmnop dmnopgexmpl dmnrngo +dmod +dmode +dmolad +dmone dmono +dmonobot +dmonot dmopab dmopabelb dmopabss @@ -17724,7 +30544,11 @@ dmoprab dmoprabss dmovn dmovnsal +dmp +dmpg +dmpgamma dmplp +dmpprod dmprop dmpropg dmqmap @@ -17749,15 +30573,22 @@ dmresv dmrn dmrnssfld dmrnxp +dms +dmsi dmsigagen dmsn +dmsnfn +dmsnm dmsnn dmsnop dmsnopg dmsnopss dmsnsnsn +dmsnsnsng dmss dmsucmap +dmtc +dmtest dmtopon dmtpop dmtpos @@ -17766,11 +30597,21 @@ dmtrcl dmtrclfv dmtrclfvrp dmttrcl +dmtxp +dmu dmuld +dmule +dmuledl +dmuledr dmult +dmulti +dmultu dmun dmuncnvepres dmuni +dmus +dmusi +dmusj dmuz dmv dmvlsiga @@ -17782,20 +30623,36 @@ dmwf dmxp dmxpid dmxpin +dmxpm dmxpss dmxrn dmxrncnvep dmxrncnvepres dmxrnuncnvepres +dna +dname +dnat +dnatmul +dnbhs +dnbhsn +dnbhsp +dnc dncl dnd +dndl +dndm dne +dneg dnelist +dnepeirce dneq dnesc dnext dnf dnfd +dnfe +dnfeq +dnfp dnfuni dni dnibnd @@ -17808,17 +30665,44 @@ dnival dnizeq dnizphlfeqhlf dnk +dnm +dnmpos dnnumch +dnoconcl dnode dnodes +dnom +dnomr +dnomrp dnonempty +dnoreduct +dnotation +dnotle +dnp +dnq dnrinv +dnrm dns dnsconst dnsq +dnt +dnu +dnull +dnulle dnum dnwech +doa doable +doallderound +doallenround +doaprefix +doarith +dob +dobd +dobe +dobj +doboth +dobre doc doca docacln @@ -17876,56 +30760,106 @@ dochsscl dochssv dochval dochvalr +doclemma docmap docprime docprimelinter +docref docs docstring docstringlinter docstringprefix docstrings docstx +doctor document documentation +documented documents +dodai +dodecahedron +dodefault +dodisplay +<<<<<<< Updated upstream +======= dodivides +>>>>>>> Stashed changes dodo +doe does doesdirectoryexist doesfileexist doesn +doesnot +doesnotprint +doesnotterminate doesnt doespathexist +doffi +dofocus +dog dogenericser dogenericserver +dogs +doh +dohash dohelloname +doi +doindent doing +<<<<<<< Updated upstream +======= doingsomething +>>>>>>> Stashed changes +doir doit +doitallinonego +doitviafunctionbodyresult +doitwithassignment +doitwithoptimizedlet +doitwithplainlet +dok +dokie dold doldkan doleader +dolemma +dolist +doll dollar dollarsyntax dollarsyntaxlinter +dolor dom doma domad domaddact domaddactmk +domai domain +domainagain +domaind domaine domaineq domainisoofbaseiso +domainness +domainofgraph domainp domainqs domainqss domains +domaintheory domaintype domainuniqueuptoiso +domainvar domalom domalt +domappend +domappendunion +domby +domc domchart +domcomm domcongr domcongralg domcoprod @@ -17936,29 +30870,68 @@ domdomcongr domdomcongrequiv domdomcongrlinearequiv domdomrestrict +domdt dome domen domeng domentr +domeq +domeqfun +domeqk +domeqo +domeqp +domeqpt +domeqptun +domequn +domequnf +domequnpt +domequp +domeqvun +domeqvune +domeqx domextend domf domfi +domfiexmid +domfilter domfin +domfnex domfuncrel domg domi +domianted +domiantes +domicodj +domij +domin +domina +dominance dominant +dominat dominate dominated dominatedconvergence dominatedfinmeasadditive +dominatedl +dominatedr dominates +dominatesi +dominatesp +dominating +domination +dominator +dominators +dominatros dominf dominfac domino dominoes +domintermt domintros +domiso +domk domlcongr +dommt dommulact dommulactcongrright domn @@ -17973,6 +30946,7 @@ domnmsuppn domnmt domnmuln domnnzr +domnop domnprodeq domnprodn domnpropd @@ -17982,21 +30956,52 @@ domnring domnrrg domnsym domnsymfi +domo +domok +domomsubct +domonsingletons +domoperation +domorework +domp +dompar domprobmeas domprobsiga +dompt +domptk +domptun +domptune +domptuno +domptunx +domptunxo +domptx domr +domran +domrangevarb domrefg +domrel +domrestrby domrestrict +domrestrto +domring +domrng doms domsdomtr domsdomtrfi domsecmat +domsetfamex domsmul +domsn domsrc domss domssex domssl domssr +domst +domstart +domsub +domsubsetdistr +domsubsetdistra +domsubsetdistrd domt domtgt domtotal @@ -18009,30 +31014,97 @@ domtriom domtriomlem domtriord domtsk +domu +domun domunfican +domunion +domunpt +domunpte domunsn domunsncan +domv +domval domwdom domx don +donde done +donea +doneb +donebody +donefn +donelist +donespec +donet +donne donnell +donotcall +donothing dont +dontcare +dontcares +dontdomuch +dontforgethavoc dontkeep +dontrw donttranslate +dontverifyme +doo +doob +doomsday +doone +<<<<<<< Updated upstream +======= door +>>>>>>> Stashed changes +dop +doper +dopey dopivotoperation +dopp +doppeb +dopped +doppel +doppelganger +doppelgangers dopxg +dor +dorder +dordrecht +doreduce +doreportfinal +doreportindividual +dos +dosomefloors +dosomething +dosomethingelse dot dotand +dotc +<<<<<<< Updated upstream +======= +dotdata +>>>>>>> Stashed changes dotdecimal dotdot +dotelimgeneralized dotemacs +dotempty doteq dotexists +dotfifo dotforall dotfull +dothing +dotimes dotimp +dotl +<<<<<<< Updated upstream +======= +dotlevel +>>>>>>> Stashed changes +dotmul +dotn dotor dotp dotpos @@ -18042,65 +31114,185 @@ dotproduct dotproductbilin dotproductequiv dotpure +dotr dotranslate dotranslateattr +dotrd +dotrtl dots +dotst dotstar +dotsubstt +dott +dotted dotwand dotwild +<<<<<<< Updated upstream +======= +dotwr +>>>>>>> Stashed changes +dou doub +doubl double +doubleassertoneline +doubleb +doublebin +doublecancel +doublecapacity doublecentralizer +doublechoice +doublechoicerec +doublecomp +<<<<<<< Updated upstream +======= doublecomplemente doublecomplementeq doublecomplementi doublecomplementsub +>>>>>>> Stashed changes +doublecomppath doublecoset +doublecross doubled doubledualemb doubledualequiv doublee +doubleevencell +doublef doublefactorial +doublefns +doublefuns doublei +doubleinc +doubleindexedset doublek +doublel +doublelockstatus +doubleloop +doubleloopstr +doubleminus +doubleml +doublemr +doubleneg doublenegation doublenegationelimination +doublenegationexists +doublenegationforall +doublenegationmodality +doublenotempty +doubleobject +doublep +doubleplus doublequot +doubler +doublerefl +doublereplace +doublereverse +doubleright +doubleround doubles +doublesidedquasi doublesplit +doublet doubletelescope doubleton +doubletoni +doubletons +doublets doubleunderscore +doublevar +doubleword +doublex doublexiso +doubley +doubleyrouting doubling doublingconstant doublinggamma doubly doublystochastic +doubt dout +dow +dowhile +dowker +dowm down +downarrow +downarrowe +downarrowt +downarrowunion +downcase +downcast +downcastco +downcastcontra +downcastf +downcastfunc +downcastfunction +downcastm +downcastreco +downcastrecontra +downcasts downclosed downcrossing +downdiagonal +downduct downfrom downfunctor +downgrade downgrades downharpoonleft downharpoonright +downheap +downi downif +downk +downl +downleft downlib +download downmap +downmid downmulhom +downneg +downp downpos +downr +downright downs downset +downsets +downshift downstream +<<<<<<< Updated upstream +downtime +======= +>>>>>>> Stashed changes +downto +downtop +downtot +downtruth +downupsemantics +downview downward downwards +downwardsclosed +downwardsclosedseparationalgebra +downwardsclosure +dowork +dowrapped +dpacking dpadd dpair dpairfst dpairsnd +dparam +dpath +dpb +dpc dpcl +dpd dpequalizer dperf dpexpp @@ -18120,12 +31312,21 @@ dpjlid dpjlsm dpjrid dpjval +dpll dplt dpltc dplti +dplus +dpm dpmorphism +dpms dpmul +dpn +dpo +dport +dports dpos +dpositive dpow dprd dprdcntz @@ -18157,43 +31358,114 @@ dprdval dprdw dprdwd dprdz +dprecomp +dpred +dpredu +dpref dprm dprod +dproda +dprodc +dprode +dprodecp +dprodesd +dprodey +dprodg dprodindex +dprodj +dprodl +dprodm +dprodme +dprodmel +dprodmer +dprodml +dprodmr +dprodp +dprodr +dprodw +dprodwc +dprodwcp +dprodwsd +dprodwsdc +dprodwy +dprodyp +dprop +dps +<<<<<<< Updated upstream +======= dpsetconstr dpsetconstrel dpsetconstrer dpsetconstrera dpsetconstri dpsetconstrsub +>>>>>>> Stashed changes +dpss +dpt +dptr +dpush +dput dpval dpweak +dpweakr dpy +dpzgbyf +dqst +dqstp +<<<<<<< Updated upstream +======= dqt +>>>>>>> Stashed changes dquart dquartlem +dquote +dquotes dra drae draei +draft +dragon drai +drain +draise dral dramatic +<<<<<<< Updated upstream +======= dramaticacting +>>>>>>> Stashed changes +drat draw drawn +draws drb drbg drbgabs drbgstate drc +drd +dreal dream drec +dref drefine drefines drefinesd drefinesi +dreg +drel +drep +drepp +drepr dres +dressing drest +drestr +drestrd +drestre +drestrict +drestricted +dreturn drex drf drgext @@ -18203,15 +31475,28 @@ drgextsubrg drgextvsca drhmsubc drhmsubcaltv +drhs +dribble drift drink drinker +drinkers +drinks +driv drive driven +driver +driverlist +drivers +drives +drivestrength driving +drizzle drl drlex +drm drn +drnd drnf drnfc drng @@ -18258,31 +31543,51 @@ drngunz dro droit droite +drone +drones drop dropab dropaux dropd +dropelem dropend dropendwhile +droperr +dropfirst dropfun dropi dropl droplast +droplength +droplevel +dropline dropm dropmiddle dropmiddleelement dropn +dropord dropout dropped +droppedperpendicularunique dropping dropprefix dropprefixifnotnumber +dropr +dropreject droprepeat +dropright +drops dropslice dropsuffix dropuntil +dropuntilincl dropwhile +dropwhilealways +dropwhiled +dropwhilei +dropwhilenot drorbn +drpped drs drsb drsbn @@ -18290,41 +31595,94 @@ drsdir drsdirfi drsprs drsr +drsub +drsubmx drtn +<<<<<<< Updated upstream +======= drugbg drugi drugsu +>>>>>>> Stashed changes +drule drunk +druqufe +drus +drv +drvnum dry +drycoarsemach +dryfinemach dryhybridmachine dryhybridmachinesig +<<<<<<< Updated upstream +drymachine +drymem +dryresources +dryspec +drythreadpool +======= drying +drymachine +drymem dryredwine dryresources dryriesling +dryspec +drythreadpool drywhitewine drywine +>>>>>>> Stashed changes +dsa +dsafe +dsat +dsaxiom +dscale +dscalel dscea dscmet +dscopes dscopn +dse +dsem +dsenv +dseparated +dseq +dset +<<<<<<< Updated upstream +======= dsetconstr dsetconstrel dsetconstrer dsetconstri +>>>>>>> Stashed changes +dsf dsh dshift dshortcomplex +dsi dsid dsim dsimp dsimpargs dsimpgoal +dsimple dsimppercentelaborator dsimpresult +dsin +dsize dsj +dsjassoc +dsjee +dsjl +dsjoins +dsjr dsk dsl +dsll +dsllv dslope +dsm dsmm dsmmacl dsmmbas @@ -18337,12 +31695,15 @@ dsmmsubg dsmmval dsmooth dsn +dsnd +dsnde dsndx dsndxnbasendx dsndxnmulrndx dsndxnn dsndxnplusgndx dsndxntsetndx +dso dsoup dsource dsourceissource @@ -18352,8 +31713,14 @@ dsources dsourcesemptysources dsourceslevelx dsourcesnot +dsp dspace dsq +dsra +dsrav +dsrl +dsrlv +dsslid dssmap dssmapclsntr dssmapf @@ -18362,9 +31729,12 @@ dssmapfvd dssmapntrcls dssmapnvod dst +dsta dstar dstate dstatelet +dstb +dstdata dstep dstepi dsteps @@ -18372,48 +31742,152 @@ dstfrvclim dstfrvel dstfrvinc dstfrvunirn +dstk +dstl +dstlen +dstn +dstnd +dstndd +dstoff +dstoffv +dstofs +dstore +dstp dstregt +dstrength dstrict +dstrip dstrvprob dstrvval dsts +dstuninit +dstv dsu dsub +dsube +dsubee +dsubek +dsubel +dsuber +dsubl +dsubmx +dsubr +dsubre +dsubs dsubst +dsubu +dsuc +dsucc +dsucceed dsum +dsume +dsumefin +dsumsmx +dsumx +dsupclopers dsupport +dsv +dswap +dswape +dswapk dszi +dta +dtabbrev +dtack +dtagl +dtas +dtbin +dtc +dtcheight +dtcmin +dtconmsa +dtconosa +dtconstr +dtconstrind +dtconstrinddef +dtconstrstr +dtconstrstrex +dtconstrstruniq +dtconstruniq +dtconstruniqdef +dtconua +dtcsymbols +dtcuniq +dtd dterm +dterms +dtermsl +dtf +dth +dthelper dthen dtheta dtmxbtwxjdjsmtb dto +dtob +dtoc dtokm dtop dtopology dtor +dtord +dtos +dtp dtr +dtrail dtranshd +dtransition +dtransitions +dtrapezium +dtre dtree +dtreeex +dtreefix +dtreelambda +dtreemapfix +dtreemapp +dtreep +dtrees +dtreestructex +dtreestructfinex +dtrspace dtru dtrualt +dtruarb dtrucor dtrue +dtruex +dts dtsld +dtt dtu +dtupdate +dtuple +dtv +dty dtype +dtypecons +dtypedecl +dtypedecls +dtypef dtypeid +dtypet +dtys dua dual dualann dualannihilator dualannihilatorgci dualantisymmetrization +dualapartness dualbases dualbasis dualboundedjoinsemilattice dualboundedmeetsemilattice +dualclosuresubsetoperatorunique dualcoannihilator +dualcompl +dualcompose dualcopairing duald dualdistrib @@ -18421,10 +31895,14 @@ dualdistribequiv dualdistribequivofbasis dualdistribinvofbasis dualdual +duale dualembedding dualequiv dualequivdual +dualfnot +dualhomomorphism duali +dualid dualindepmatroid dualisboundedjoinsemilattice dualisboundedmeetsemilattice @@ -18433,24 +31911,35 @@ dualisjoinsemilattice dualismeetsemilattice dualiso duality +dualization dualize +dualized dualizing dualjoinsemilattice +dualk duallift +dualloset dualmap dualmeetsemilattice +dualneg dualnumber dualnumberequiv +dualo dualpairing +dualposet dualprod dualproddualequivdual dualprodisometry dualprodprodisometry +dualproset +dualpseudolattice +dualquoset dualquotdistrib dualquotequivdualannihilator dualrestrict duals dualseminorms +dualstrictorder dualsubmodule dualsubmoduleparing dualsubmoduletodual @@ -18459,39 +31948,107 @@ dualtensorhomequiv dualtensorhomequivofbasis dualtensorisolinhom dualtensorisolinhomaux +dualtoset dualvector +duarel +dub dube dubmrjuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuhqsqjuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuhssxmosmlxuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuubjmuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuubdcstkdjuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuucfpkpqjujkdjvgajuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuubuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuu +duck due duffin dugundji +duh +dulo dum +dumb dumbledore +dumbpivot +dumm +dummett dummies +dummmy dummy +dummyarr +dummyhandler dummylink +dummym dump +dumpeq +dumps +dumptrans +dumy +dunce +duncecone +duncemap dunford +dunhill +dunhills +duni +dunion +dunit +dunsat dup dupelim +dupempseparationlogic +dupes +dupfree +dupl +duplcated duple +duplelist +duplet duplex +dupli +duplic +duplica +duplicable +duplicat duplicate duplicated +duplicateedge +<<<<<<< Updated upstream +======= duplicatefreep +>>>>>>> Stashed changes +duplicateidentifierinpattern duplicateimportscheck +duplicateit +duplicatelabels duplicates +duplicatesp +duplicateupdate +duplicatevarname duplicating duplication +duplications +duplicatsep +duplici +duplicities +duplicity +duploid +dupls +dupn dupnamespace dupnamespacelinter dupprob dups +dupsp +duptest +duptesttest duq +dur +durd during +durthenstartthenmode +dus +dussm dutch +dutchflag dutchnationalflag duty +duunhor +duy dva dvaabl dvabase @@ -18499,6 +32056,8 @@ dvacos dvadd dvaddbr dvaddf +dvaddxx +dvaddxxbr dvadian dvaf dvafmulr @@ -18513,6 +32072,7 @@ dvamulr dvaplusg dvaplusgv dvar +dvars dvasca dvaset dvasin @@ -18525,7 +32085,9 @@ dvbdfbdioo dvbdfbdioolem dvbss dvbssntr +dvbssntrcntop dvbsss +dvbsssg dvcj dvcjbr dvcl @@ -18541,26 +32103,48 @@ dvcnvlem dvcnvre dvcnvrelem dvco +dvcoapbr dvcobr dvcobrold dvcof dvconst dvconstbi +dvconstre +dvconstss dvcos dvcosax dvcosre dvcvx dvcxp dvd +dvda +dvdc +dvdcp dvdemo +dvdg +dvdgi +dvdgil +dvdgip +dvdgir +dvdgixx dvdi dvdivbd dvdivcncf dvdivf +dvdl dvdm dvdmsscn dvdn +dvdnn dvdnotunit +dvdnp +dvdp +dvdpe +dvdpl +dvdpn +dvdpp +dvdpr +dvdr dvds dvdsabsb dvdsabseq @@ -18569,12 +32153,16 @@ dvdsacongtr dvdsadd dvdsaddr dvdsaddre +dvdsbnd dvdschrmulg dvdscmul dvdscmulr +dvdsdc dvdsdec dvdsdivcl dvdseq +dvdseu +dvdseulemle dvdseven dvdsexp dvdsexpad @@ -18596,6 +32184,8 @@ dvdsle dvdsleabs dvdslegcd dvdslelem +dvdslelemd +dvdslemn dvdsm dvdsmod dvdsmodexp @@ -18621,15 +32211,21 @@ dvdsq dvdsr dvdsrabdioph dvdsrcl +dvdsrcld +dvdsrd +dvdsrex dvdsrid dvdsrmul +dvdsrmuld dvdsrneg dvdsrpropd +dvdsrpropdg dvdsrspss dvdsrtr dvdsruasso dvdsruassoi dvdsrval +dvdsrvald dvdsrzring dvdssq dvdssqf @@ -18644,6 +32240,14 @@ dvdsunit dvdsval dvdszrcl dvdszzq +dvdup +dvdx +dvdz +dvdze +dvdzl +dvdzp +dvdzr +dvdzz dve dveca dvech @@ -18654,6 +32258,7 @@ dveflem dvelim dvelimalcased dvelimalcasei +dvelimalt dvelimc dvelimdc dvelimdf @@ -18661,16 +32266,23 @@ dvelimdv dvelimexcased dvelimexcasei dvelimf +dvelimfalt +dvelimfv dvelimh dvelimhw dvelimnf +dvelimor dvelimv dveq +dverts dvexp dvf dvfcn +dvfcnpm dvferm dvfg +dvfgg +dvfpm dvfre dvfsum dvfsumabs @@ -18682,7 +32294,11 @@ dvfsumrlim dvfsumrlimf dvfsumrlimge dvfval +dvfvalap +dvg dvge +dvgn +dvgp dvgrat dvgt dvh @@ -18721,23 +32337,35 @@ dvhvsca dvhvscacbv dvhvscacl dvhvscaval +dviaddf dvid dvidlem +dvidlemap +dvidre +dvidrelem +dvidsslem +dvimulf dvip dvivth dvivthlem dvle dvlem +dvlemap dvlip dvlipcn dvlog dvloglem dvlt dvmptadd +dvmptaddx dvmptc +dvmptccn dvmptcj +dvmptcjx dvmptcl +dvmptclx dvmptcmul +dvmptcmulcn dvmptco dvmptconst dvmptdiv @@ -18746,22 +32374,28 @@ dvmptfprod dvmptfprodlem dvmptfsum dvmptid +dvmptidcn dvmptidg dvmptim dvmptmul dvmptmulf +dvmptmulx dvmptneg +dvmptnegcn dvmptntr dvmptre dvmptrecl dvmptres dvmptresicc dvmptsub +dvmptsubcn dvmul dvmulbr dvmulbrold dvmulcncf dvmulf +dvmulxx +dvmulxxbr dvn dvnadd dvnbss @@ -18781,6 +32415,7 @@ dvnres dvntaylp dvnxpaek dvply +dvprop dvr dvradcnv dvrass @@ -18791,6 +32426,7 @@ dvrdir dvreacos dvreasin dvrec +dvrecap dvrecg dvrelog dvrelogpow @@ -18800,9 +32436,11 @@ dvresioo dvreslem dvresntr dvrfval +dvrfvald dvrid dvrunz dvrval +dvrvald dvs dvsconst dvsef @@ -18822,21 +32460,42 @@ dvun dvv dvxpaek dwa +dwalk +dwardclosedetc +dwards +dwaxiom +dweight +dwfbrqy dwfc dwgs +dwim +dwires +dword +dwords dwq +dwrds +dwrite dws +dwt +dwwutkw +dxa +dxc dxdfktg dxdt dxeq dxi dxle dxlt +dxn dxp dxs +dxu +dxv dxvp dxy +dxyz dya +dyad dyaddisj dyaddisjlem dyadf @@ -18849,12 +32508,15 @@ dyadmbllem dyadovol dyadss dyadval +dyanmic +dyb dyck dyckstep dyckword dydt dyeq dyi +dyld dyn dyna dynamic @@ -18862,20 +32524,40 @@ dynamical dynamically dynamics dynamicsaturateassert +dynamodb +dynamodbclientconfigtype +dyncastreds +dyncastredsfail +dyncastredsnull +dyncastredsref +dyncastredsthrow dyncom +dyncomconseq dyncomrule +dyncopy dynd +dyne dynentourage dyni dynkin +dynkinc dynkinsystem +dynkint +dynkinu dynpdg +dynprepost +dynprepostlistref +dynprepostref +dynsys dyp dyqidsdfm dyz +dzc +dze dzero dzgtdunaxjdlfrhxbfqhda dzixc +dzp dzssp eaa eaaa @@ -18898,6 +32580,7 @@ eabdaa eabe eabfcb eabfda +eabody eabort eabs eabst @@ -18909,15 +32592,24 @@ eacc eaceae eacf each +eachother eachothers +eachp eachtr +eact ead eada eadbdcf eadd +eaddnt +eaddrof eadeb eadfcc +<<<<<<< Updated upstream +======= eadjust +>>>>>>> Stashed changes +eadw eae eaeb eaedce @@ -18932,66 +32624,120 @@ eafe eafeec eaff eafff +eafter eager +eagerly +eagerness +eagree eal +<<<<<<< Updated upstream +======= ealign +>>>>>>> Stashed changes +ealignof ealist eall -ealloc -ealookup ealt ealtn ealtv +<<<<<<< Updated upstream +======= eamap +>>>>>>> Stashed changes +eand +eandnt eap +eapgle +<<<<<<< Updated upstream +eapp +eappears +======= eapify eapp +eappears eappend +>>>>>>> Stashed changes +eappinf eappl eapply eappr eapprox eapproxdiff +ear +<<<<<<< Updated upstream +eargs +======= earb +eargs earith earithmetic +>>>>>>> Stashed changes earley earlier +earliest +earliestv early +earlyout +earlyp earlyshutdown +<<<<<<< Updated upstream +======= earray +>>>>>>> Stashed changes +earraysubsc +earrv eas +ease eases easier +easiest easily +<<<<<<< Updated upstream +======= easm easmsem +>>>>>>> Stashed changes +eassert +eassign +eassignop +eassume eassumption east easy easycases +easytwo eat +<<<<<<< Updated upstream +======= +eater +>>>>>>> Stashed changes +eating eats eau eaut eauto +eav +eaw +eax eba ebaa ebaab ebab ebabe ebac -ebackend -ebackendproof ebad ebade ebae ebafe ebag ebal -ebalanced eball eballs +ebase +ebasent +ebaseparen +ebaseparenfn +ebasis ebawtfypftqsxuxthovwampodlugzyoifidxrrh ebb ebba @@ -19008,6 +32754,7 @@ ebcb ebcd ebce ebcfdfde +ebcw ebd ebda ebdb @@ -19019,13 +32766,13 @@ ebdfad ebe ebeb ebebee +ebec ebeca ebecfc ebee ebef ebefa ebefb -ebehaviour ebf ebfa ebfab @@ -19035,33 +32782,59 @@ ebfd ebfda ebff ebffde +ebi +<<<<<<< Updated upstream +ebin +======= ebigstep ebigunion ebij +ebin ebinary +>>>>>>> Stashed changes ebind ebindalt ebindvd ebinop -ebit ebits +<<<<<<< Updated upstream +ebmde +ebnd +ebnnyddfhhuvuuablioucnhw +ebody +eboolandnt +======= ebitstring +ebmde +ebnd ebnnyddfhhuvuuablioucnhw ebnot +ebody ebool +eboolandnt eboolv +>>>>>>> Stashed changes +eboolvar ebound -ebounded ebounds +ebp +ebsb ebtwntg -ebuild ebuiltin +<<<<<<< Updated upstream +ebw +ebwnfnfarbudpxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxyjuxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxlpxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxqghjjcxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxjxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxsmdxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxoqqrsusoxomfxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxllydsdafwxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxkxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +ebx +======= ebvi ebvisem ebvl ebvlsem +ebw ebwnfnfarbudpxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxyjuxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxlpxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxqghjjcxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxjxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxsmdxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxoqqrsusoxomfxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxllydsdafwxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxkxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +ebx ebytes +>>>>>>> Stashed changes ebzvswpflpyjemsvdeckopuympqf eca ecaa @@ -19073,17 +32846,14 @@ ecaf ecafe ecaffa ecall -ecan -ecannotparse ecaodabylqwu ecard -ecardinal -ecardleq ecarrier ecart ecase ecased ecast +ecau ecb ecba ecbb @@ -19101,11 +32871,14 @@ eccb eccbc eccbfa eccc +ecccurve eccd eccdc ecce eccent +eccentricity eccfd +ecckeypair eccnvep eccnvepres ecd @@ -19123,21 +32896,33 @@ ecde ecdeafa ecdf ecdff +ecdh +ecdhkeyderivationutf ecdmn +ecds +ecdsa +ecdsasign +ecdsasignensurespublicly +ecdsaverify +ecdsaverifyensurespublicly ece ecea eceb ecebc +ececbb ececc eced eceda +ecedd ecee eceeea +ecefa eceldmqs eceldmqsxrncnvepres ecelqs ecelqsdm ecelqsdmb +ecelqsg ecelqsi ecelqsw eceq @@ -19149,86 +32934,169 @@ ecfb ecfc ecfdee ecffcd +<<<<<<< Updated upstream +======= ecfheapsbase ecfstore +>>>>>>> Stashed changes +ecfw ecgrtg +echa echar +echarlist +echarp +echarpack +echars +<<<<<<< Updated upstream +======= echeck +>>>>>>> Stashed changes echelon echidna echo +echoed echotypechecker +<<<<<<< Updated upstream +======= echr +>>>>>>> Stashed changes +eci ecid +ecidg ecidsn ecin ecinn ecinxp +eciw +eckmann eckmannhilton eckxyacfwykrkqetjerrzuq ecl +eclamp eclclwwlkn eclexia eclient +eclique +<<<<<<< Updated upstream +======= eclos +>>>>>>> Stashed changes eclose -eclosed eclosee eclosen -ecloslang -eclosprops -eclossem eclosure +ecm +<<<<<<< Updated upstream +======= ecmlg ecmlparse ecmlpeg ecmlptreeconversion +>>>>>>> Stashed changes ecmp +ecmpnt +ecmult ecnv +eco +ecod +ecoe +ecol +<<<<<<< Updated upstream +ecomma +ecomp +======= ecombin +ecomma ecomp ecompact ecompile ecompiler ecompilerproof ecomplex +>>>>>>> Stashed changes +ecompose econ +econc econcludes +<<<<<<< Updated upstream +econdition +econgr +economized +econs +======= econd +econdition econfig econgr econlang +economized econs econsem +>>>>>>> Stashed changes +econsinf econst +econsteq +econstgeq +econstgt +econstleq +econstlt +econstneq +econstruction econstructor econt +econtext +econv +<<<<<<< Updated upstream +======= econvert +>>>>>>> Stashed changes ecoop ecopoveq ecopover +ecopoverg ecopovsym +ecopovsymg ecopovtrn +ecopovtrng ecopqsi ecoptocl ecovass ecovcom ecovdi +ecoviass +ecovicom +ecovidi ecoyoneda +ecp ecqmap ecqs +ecquotient ecqusaddcl ecqusaddd ecref ecres +<<<<<<< Updated upstream +======= ecross +>>>>>>> Stashed changes +ecs +ecsevnc +ecsg ecss +ecst +ectc ectocl ectocld +ecu ecubes ecun ecuncnvepres ecunres +ecurve +ecv +ecvg +ecw +ecx ecxp ecxpid ecxrn @@ -19245,8 +33113,12 @@ edae edaf edafc edafe +<<<<<<< Updated upstream +======= edata edatasem +>>>>>>> Stashed changes +edaw edb edba edbaab @@ -19265,6 +33137,7 @@ edcced edcd edce edcf +edcls edd edda eddb @@ -19282,20 +33155,25 @@ edeab edeae edeb edebdbbe +<<<<<<< Updated upstream +======= edebruijn edec edecls +>>>>>>> Stashed changes +edecode eded ededd edee edeee -edelete -edeletefindmax edelstein +edelta +<<<<<<< Updated upstream +======= eden +>>>>>>> Stashed changes edenot ederef -edest edestruct edf edfa @@ -19304,30 +33182,68 @@ edfb edfc edfcaa edfd +edfdb edff edg edgb edgblem edge +edgearray +edgearrayi +edgearrayp +edgebag +edgec +edgecount +edgecst +<<<<<<< Updated upstream +======= edged +>>>>>>> Stashed changes +edgedecls edgedensity +edgedir +edgedirg edgedisjointtriangles edgee edgef edgefinset edgei +edgelabelaa +edgelabelgba edgelabeling +edgeless +edgelist edgemk +edgenum +edgep edgepath edgepred edgertc edges +edgesbetween +edgesd +edgeselector +edgeseq edgeset edgesetembedding edgesfinset edgesi +edgesin +edgesinout +edgesinto +edgesize edgesl +edgeslist +edgesout +edgesoutof +edgesplit +edgest +edgesynth +edgetable edgetransform +edgetype +edgev +edgex edgfi edgfid edgfiedgval @@ -19335,7 +33251,9 @@ edgfndx edgfndxid edgfndxnn edgiedgb +edgiedgbg edginwlk +edginwlkd edglem edglnl edgnbusgreu @@ -19345,23 +33263,25 @@ edgnelalt edgneu edgopval edgov +edgs edgssv edgstruct edguhgr edgumgr +edgumgren edgupgr +edgupgren edgusgr edgusgrclnbfin +edgusgren edgusgrnbfin edgval +edgvalg edgwalks edhtqloizgwhxlz edi ediam -edible ediff -edimindex -edimword edist edistance edistlegeometric @@ -19370,23 +33290,59 @@ edistlttopsetoid edistprop edit editabledocument +edited editvar ediv +edivn +edivnp +edivp +edivpp edka +edkdeserializeserialize +edks +edkserializedeserialize +edkwrapping +<<<<<<< Updated upstream +edmonds +ednatmul +ednatmule +edom +edomiff +edone +======= edlet edmond edmonds +ednatmul +ednatmule edo edom +edomiff +edone edownshift +>>>>>>> Stashed changes +edp edrel edreld edreli edring edringr +<<<<<<< Updated upstream +======= edrop +>>>>>>> Stashed changes +eds +edscr +edsger +edt +<<<<<<< Updated upstream +======= edtree +>>>>>>> Stashed changes edu +edw +edwards +edx eea eeaac eeab @@ -19399,6 +33355,7 @@ eeaffab eean eeanv eeanvw +eeaw eeb eeba eebb @@ -19459,14 +33416,13 @@ eefm eeg eehil eehqilxzdczjjzdicnlmvxxrgpmsmt +eeif eel -eelist eelt eeltt eelttt -eempty -eenc eencode +eencodingp eengbas eenglngeehlnm eenglngeehlnmlem @@ -19474,34 +33430,70 @@ eengstr eengtrkg eengtrkge eengv +eenum eenv +<<<<<<< Updated upstream +======= eenvironment eenvrel +>>>>>>> Stashed changes +eeny eeor +eep eeq +eeqa +eeqbutpid +eeqconst +eeqnt eeqon +eequal +<<<<<<< Updated upstream +eew +eewchli +eewci +======= eerror eeval eevaluate eeven eevery +eew +eewchli +eewci eexc eexecute eexh eexhlang eexhprops +>>>>>>> Stashed changes eexinst +eexist eexists -eexn eexp +<<<<<<< Updated upstream +======= eexplode +>>>>>>> Stashed changes +eexpn +eexpof +eexponent +eexpr +eexpt +eexpz eext +<<<<<<< Updated upstream +eexternal +======= eextend +eexternal eextreal +>>>>>>> Stashed changes efa efaab efaad efabl +efac +efaci efad efadd efaddlem @@ -19510,11 +33502,14 @@ efae efaf efafdd efafeba -efail -efailure efald efalse +efalsify +efap +<<<<<<< Updated upstream +======= efapply +>>>>>>> Stashed changes efb efbaecb efbbc @@ -19538,8 +33533,13 @@ efcj efcl efcld efcllem +efcllemp efcn +<<<<<<< Updated upstream +======= efcp +>>>>>>> Stashed changes +efct efcvg efcvgfsum efcvx @@ -19552,24 +33552,31 @@ efea efeb efebb efec +efective efed efee efeea efef efefbf -efempty efeq +efer +eferbits efeul +efew efexp efexple eff effac effax +effcore effd effdd effe +effec +effeciency effect effectful +effecti effective effectiveepi effectiveepiconstruction @@ -19593,24 +33600,39 @@ effectiveepistructofiscolimit effectiveepistructofisiso effectiveepistructofquotientmap effectiveepistructofregularepi +effectiveiso effectively effectivelyenough +effectiveness effectivepresentation +effectivity effectless +<<<<<<< Updated upstream +======= effectnecessarilyfollowsfrom +>>>>>>> Stashed changes +effectobs +effectobsstatet effectrow effects effectviolation +effempty efff effi efficiency efficient efficiently +effnone effort +efforts effs +effsrc effstep effstepn +effstore effsumlt +efftr +efftransl efg efgcpbl efgcpbllema @@ -19658,31 +33680,48 @@ efiargd efiasin efiatan efield -efields efieq efif efifo -efilter efimpi efin +<<<<<<< Updated upstream +efinb +efind +======= efinal +efinb +efind efinite +>>>>>>> Stashed changes +efinm +efinn +efinp efipi -efirstset -efirstsetml efival +efix efixedpoint +<<<<<<< Updated upstream +======= efixwidth +>>>>>>> Stashed changes +eflag +eflags efle eflegeo eflgam -efloat eflog eflogeq eflowgraph eflt +efltim +efltlemlt +<<<<<<< Updated upstream +======= efmap +>>>>>>> Stashed changes efmival +efml efmnd efmndbas efmndbasabf @@ -19705,24 +33744,28 @@ efn efne efneg efnnfsumcl +<<<<<<< Updated upstream +======= efnode efoldl efoldr +>>>>>>> Stashed changes +efoot efopn efopnlem +efor +eforget efper efq +efqs +efreflexive efrirr efrlim efrlimold efrn -efromalist -efromlist efrunt efs efsep -efsffi -efsffiprops efsm efst efsub @@ -19735,47 +33778,94 @@ eftlcl eftlcvg eftlub eftval +eftvalcn +<<<<<<< Updated upstream +efuns +======= efun +efuns efupdate +>>>>>>> Stashed changes +efv efval efvmacl +efw efzval egal +egalcol +egale egalg egalgim +egalite egality egalr egals +egalsymm egalv egalx +egalzero +egamma egauge egc +egcd +egcdgi +egcdgip +egcdn +egcdnp +egcdp +egcdpe +egcdpp +egcdz +egcdzp ege +egeb egen +<<<<<<< Updated upstream +egeq +egeqconst +======= egeneralise egenlist +egeq +egeqconst eget +>>>>>>> Stashed changes egg +eghnavx egirth +eglobal ego egoals -egood egorov +<<<<<<< Updated upstream +======= egram egrammar +>>>>>>> Stashed changes +egraph +egraphseq egrsubgr egrvtxdg -egspec egt egta +egtb +egtconst +<<<<<<< Updated upstream +======= eguess egular +>>>>>>> Stashed changes egv eha ehalf +ehalts +<<<<<<< Updated upstream +======= ehandle eheap +>>>>>>> Stashed changes eheight +ehi ehl ehlbase ehleudis @@ -19795,18 +33885,30 @@ ehomwhiskerrigh ehomwhiskerright ehresmann eid +eids +eidx eiedg eif +eiff +<<<<<<< Updated upstream +eig +eigen +eigenmodule +======= eify eig eigen +eigenmodule eigenname +>>>>>>> Stashed changes eigenpairs eigenrange eigenspace +eigenspacep eigenspaces eigenva eigenvalue +eigenvaluep eigenvalues eigenvec eigenvector @@ -19817,6 +33919,8 @@ eighmorth eighmre eight eighth +eights +eighty eigorth eigorthi eigposi @@ -19830,57 +33934,118 @@ eigvals eigvalval eigvec eigvecval +eij +eil +eilenberg +eilenbergmoore +eill +<<<<<<< Updated upstream +eimpl +eindex +eineventspace +einf +einfe +======= eilltyped +eimpl ein einc eindependent eindex eindexedlists +eineventspace einf +einfe einfer einferencer einfertype +>>>>>>> Stashed changes +einfn einfs einfsep +einfsn +einit +<<<<<<< Updated upstream +======= einitial einl einode +>>>>>>> Stashed changes einput eins einsert -einst -einstalled einsttype eint -einteger einter +einterp einterval eintf eintp -eintro einu einv einw eio +eip +eipp eirr +eirrap +eirraplem eirrlem eis +eisadj eisenstein eisensteinseries eisensteinseriesmf eisensteinseriessif eisoh +<<<<<<< Updated upstream +eisretr +eissect +======= eisprefix +eisretr +eissect eissomedataelement +>>>>>>> Stashed changes eissummand +eit +eith eithe either +<<<<<<< Updated upstream +eitherassoc +eitherbimap +eithercommiso +eitherl +eithermap +eithermapcompose +eithermarkedornotmarked +eithermarkedornotmarkedelement +eitherswap +eithert +eitv +ejr +ejrcfjd +ejuicy +======= +eitherl +eithermarkedornotmarked +eithermarkedornotmarkedelement +eithert eitself +eitv eiw ejoin +ejr +ejrcfjd +ejuicy ejump +>>>>>>> Stashed changes +ekc ekey +ekind ekmeasure +eks ela elaa elab @@ -19907,6 +34072,11 @@ elabdelta elabdeprewriteconfig elabdischargeconv elabdischarger +elabel +elabeled +elabeling +elabelingseq +elabelselector elabevalexpr elabf elabfastinstance @@ -19917,6 +34087,7 @@ elabforheartbeats elabfunpropconfig elabg elabgf +elabgft elabgrewriteconfig elabgt elabgtold @@ -19928,7 +34099,11 @@ elabinitializesimpsprojections elabinsertcast elabinsertcastaux elabinsertcastfun +elabkey +<<<<<<< Updated upstream +======= elablang +>>>>>>> Stashed changes elabletimpldetail elablinarithconfig elablinearcombination @@ -19938,6 +34113,7 @@ elabnontriviality elabnormnum elabnormnumconv elaboptattrarg +elabor elaborate elaborated elaboratepattern @@ -19947,10 +34123,10 @@ elaboration elaborator elaborators elabpartiallyappliedcoe +elabpath elabpattern elabpatterns elabprodassoc -elabprops elabproxyequiv elabpushconfig elabpushtree @@ -19964,7 +34140,13 @@ elabreximdv elabringnfconv elabrule elabrw +elabs +elabscope +elabscopes +<<<<<<< Updated upstream +======= elabsem +>>>>>>> Stashed changes elabsetbuilder elabsetoption elabsimpargs @@ -19986,6 +34168,7 @@ elabtermwithholes elabtermwithoutnewmvars elabtfaetype elabtranslationattr +elabtraversal elabtru elabtype elabtypeascription @@ -19995,13 +34178,18 @@ elabupdate elabvariables elabwithoutcdot elabzeta +eladdc +eladdci elalt elaltxp elam +elapsed +elarge elat elatcv elaxnul elb +elbag elbas elbasfv elbasov @@ -20015,11 +34203,13 @@ elbigolo elbl elblps elc +elcan elcarsg elcarsgss elcatchom elccinfty elcdm +elce elch elcl elclnbgrelnbgr @@ -20038,8 +34228,11 @@ elcnvintab elcnvlem elcnvrefrels elcnvrefrelsrel +elco elcoeleqvrels elcoeleqvrelsrel +elcompl +elcomplg elcpmat elcpn eld @@ -20101,7 +34294,9 @@ eldmxrncnvepres eldprd eldprdi eldv +eldvap ele +eleb elebesgue elec elecaltv @@ -20116,7 +34311,7 @@ elecreseq election elections electionsdata -electricdevice +electricity elecxrn elee eleei @@ -20124,7 +34319,10 @@ eleenn eleesub eleesubd elefmndbas +eleft +elegance elegant +elegantly eleigvec eleigveccl elelb @@ -20133,6 +34331,11 @@ eleldisjseldisj elelpwi elelsuc elem +elemappleft +elemappright +elemat +elemb +elemcount elemd eleme elemen @@ -20143,32 +34346,75 @@ elementarily elementarilyequivalent elementary elementarybasis +elementarycompdd elementarydiagram elementaryembedding +elementaryinstructions +elementaryprocess elementaryskolem elementarysubstructure elementarysymmetric +elementeq +elementi +elementlasttrailislastelementstrail elementlevel +elementlist +elementmemelements +elemento +elementofarraywilldecreasesize +elementp elements +elementsappend +elementsarenat +elementsaretan +elementsbutlasttrailisbutlastelementstrail +elementscontainedin +elementscopiedtoperformlengthcheck +elementsemptyifftrailempty elementsfunctor elementsmk +elementsofarraywilldecreasesize +elementsofbuyportfolio +elementsofportf +elementsofportfoliovalue +elementsofportfoliovaluepr +elementsofportfoliovalueprob +elementspec +elementsunsized +elementvarassignment elementwise elementwiseexpr elementwisethms elemexp elemexponent +elemf elemi +elemindex +elemins +elemlambdafun elemlist +elemmap +elemmonad +elemnum +elemp +elempp +elemprop elemreduct +elemrep elems elemsandseps elemsd +elemsize +elemsr elemsrimpl elemsruniq +elemtofin +elemtonat elemtype -elen elength eleq +eleqconst +eleqr eleqtrd eleqtrdi eleqtri @@ -20182,6 +34428,8 @@ eleqvrels eleqvrelsrel elestrchom elet +eletvar +elevated elevator eleven elex @@ -20189,25 +34437,31 @@ elexb elexd elexi elexold +elf elfg elfi elfilspd elfilss +elfin elfir elfiun elfix elflim elfm +elfp elfpw elfrlmbasn elfuns elfunsaltv elfunsaltvfunaltv elfunsg +elfunsi elfv elfvdm elfvex elfvexd +elfvfvex +elfvm elfvmptrab elfvne elfvov @@ -20260,6 +34514,7 @@ elgamal elgch elghomlem elghomold +elglobals elgrplsmsn elgrug elgz @@ -20271,6 +34526,7 @@ elhoma elhomai eli elias +elib elicc eliccd eliccelico @@ -20289,6 +34545,7 @@ elicore elicores elid elide +elided elidinxp elidinxpid elif @@ -20302,29 +34559,49 @@ elim elima elimag elimaint +elimak +elimakg +elimaksn +elimakv +elimakvg elimallvarsm elimampo elimampt eliman elimapp +elimapw elimasn elimasng elimasni elimc +elimcase +elimcomplete +elimcons +elimconslem +elimcontr elimdelov elimdhyp elimedge elimel +elimequivfun elimf +elimfin elimfn +elimfuns +elimfunt elimge elimgt elimh elimhyp elimhyps +elimi elimif elimifd +elimin +elimina eliminable +eliminaci +eliminat eliminate eliminatecopyable eliminated @@ -20334,17 +34611,26 @@ elimination eliminations eliminator eliminfo +eliminv +elimiso elimm elimmonom elimn elimne elimnf elimntf +elimnum elimnv elimnvu +elimpath elimph elimphu +elimprop +elimpropbouquet +elimproprp elims +elimset +elimsetrp elimstatus elimt elimtf @@ -20358,15 +34644,14 @@ elin elina elincfzoext elind -eline elinel -elines elini elinintab elinintrab eliniseg elinisegg elinlem +elinp elinsn elint elintab @@ -20392,15 +34677,26 @@ elioore elioored eliooshift eliooxr +eliot +eliota +eliotaeu elirng elirr elirrv elirrvalt elirrvold +elisinhost +elision elisset elissetv elist +<<<<<<< Updated upstream +======= elistprog +>>>>>>> Stashed changes +elistw +elit +eliteral eliun eliund eliuni @@ -20420,7 +34716,11 @@ elladiccohomology elladicsheaf ellcoellss ellcsrspsn +ellcur +<<<<<<< Updated upstream +======= elle +>>>>>>> Stashed changes elleft elles ellim @@ -20430,10 +34730,13 @@ ellimcdiv ellimciota ellimits ellines +ellip ellipsis +ellipsoid +elliptic ellis -ellist ellkr +elllnyz ellnfn ellnop ello @@ -20465,27 +34768,35 @@ elmapsnd elmapssres elmapssresd elmbfmvol +elment elmgpcntrd elmnc +elmo elmod elmopn elmpocl +elmpom elmpps elmpst elmptima elmptrab elmrsubrn +elms elmsta elmsubrn +elmt elmthm elmzpcl eln elnanel elnanelprv +elnc +elncs elndif elneeldif elnei elnel +elnelall elneldisj elnelne elnelneq @@ -20494,9 +34805,12 @@ elnelun elneq elnev elni +elnin +elning elnlfn elnmz elnn +elnndc elnnne elnnnn elnnrabdioph @@ -20511,21 +34825,31 @@ elnoold elnotel elnp elnpi +elnt elntg elo +eload +eloadbytent +eloadnt eloc -elocals -elocation -elocs elocv elogb +elogn elold elom +elomssom elon elong +elongatedangle +elongatedanglebetween +elongatedanglechasles +elongatedanglerec eloni elons elookup +elookupc +elookupv +eloop elop elopab elopaba @@ -20535,13 +34859,17 @@ elopabran elopabw elopaelxp elopg +elopk eloppf eloprab eloprabg eloprabga eloprabi +eloquence +eloquent elorrvc elorvc +elovex elovimad elovmpo elovmpod @@ -20605,7 +34933,10 @@ elpri elprn elprneb elprnq +elprnql +elprnqu elprob +elproductex elpt elptr elpw @@ -20638,6 +34969,7 @@ elqsg elqsi elqsn elqtop +elr elrab elrabd elrabf @@ -20646,6 +34978,7 @@ elrabrd elrabsf elre elreal +elrealeu elrefrels elrefrelsrel elrefsymrels @@ -20713,9 +35046,17 @@ elrspunsn elrtrclrec els elsb +elscan elscottab else +elsecomp elsee +elseerror +elsek +elsepart +elsepattern +elses +elset elsetchom elsetpreimafv elsetpreimafvb @@ -20737,24 +35078,33 @@ elsigass elsingles elsn elsnb +elsnc +elsncg elsnd elsng elsngl elsni elsnres elsnxp +elsof elspancl elspani elspansn elspansncl elspansni elsprel +elsprod elsros elss elssabg +elssdc +elssetk +elssetkg elssi elssuni +elssuniab elsuc +elsucexmid elsucg elsuci elsupp @@ -20762,6 +35112,7 @@ elsuppb elsuppfn elsuppfnd elsuppfng +elswap elsx elsymdif elsymdifxor @@ -20772,13 +35123,33 @@ elt eltag eltail eltayl +eltb +eltc +eltcons +eltconst +eltcount eltg +elthm +eltilist +eltilistcons +eltilistnil +eltj +<<<<<<< Updated upstream +======= eltlist +>>>>>>> Stashed changes +eltm +eltme +eltmm +eltnil +eltnk eltop eltopss eltp eltpg eltpi +eltpointed +eltpointedequiv eltpsg eltpsi eltr @@ -20787,10 +35158,13 @@ eltrclrec eltrrels eltrrelsrel elts +eltsize eltsk eltskg eltskm eltsms +elttype +eltv eltx elun elunant @@ -20799,6 +35173,7 @@ eluniab elunif elunii eluniima +eluniimadm elunirab elunirn elunirnalt @@ -20810,12 +35185,17 @@ elunitrn elunnel elunop elunsn +<<<<<<< Updated upstream +======= elupdate +>>>>>>> Stashed changes +elusingaarch elutop eluz eluzadd eluzaddi eluzd +eluzdc eluzel eluzelcn eluzelre @@ -20835,6 +35215,7 @@ eluzuzle elv elvd elvv +elvvk elvvuni elvvv elwf @@ -20846,21 +35227,25 @@ elxnn elxp elxpcbasex elxpi +elxpk elxr elxrge elz elzdif +elzf elzn elznn elznns elzrhunit elzs -emachine -emake emap +<<<<<<< Updated upstream +======= emapi emapped emapprog +>>>>>>> Stashed changes +emaps ematch emax emaxheartbeats @@ -20868,6 +35253,7 @@ emb embant embantd embark +embase embdoma embdomain embdomainalghom @@ -20875,11 +35261,14 @@ embdomainlinearmap embdomainorderaddmonoidhom embdomainorderembedding embdomainringhom +embe embed embedbox +embedcompose embeddable embedded embeddedg +embeddedsimilartriangles embeddi embedding embeddingcongr @@ -20889,10 +35278,14 @@ embeddingdownnat embeddingequivoffinite embeddingfinsucc embeddinggl +embeddingip +embeddingl embeddingliftiso embeddinglike embeddingofsubset embeddingpitangent +embeddingposet +embeddingr embeddingreal embeddingring embeddings @@ -20906,12 +35299,39 @@ embeddingupintdownint embeddingupintge embeddingupintle embeddingupnat +embedid +embedilfun +embedilfundrop +embedilfundropop +embedilfunop +embedilpre +embedilpredrop +embedilpredropop +embedilpreop +embedings +embedl +embedland +embedlandc +embedlfalse +embedlimplc +embedlor +embedltrue +embedop +embedopcompose +embedopid +embedoppropprop embedproduct +embedpropexists +embedpropexistsl +embedpropl +embedpropprop +embedpropr embedreal embedrealfun embeds embedsetcestrc embedsetcestrclem +embedwp embequivofadjoinsplits embequivofequiv embequivofisalgclosed @@ -20920,108 +35340,245 @@ embfintwo embfunctor embits embmap +embop +embp embprodembofisalgebraic embsigma embsigmaadd embsigmasingle emcl emcllem +emeasurable +emeasurablec emeasure emee emem -ememory -emerge emetric emetricdilation emetricisometry emetricspace emetrizable emex +emf +emfun emgt +emi emin +eminkowski +<<<<<<< Updated upstream +======= emisc +>>>>>>> Stashed changes +emiso +emisoinv +emission emit emits emitted +<<<<<<< Updated upstream +emlen +emloop +emm +======= emk eml +emlen emllist +emloop emlstring emlvector +emm emmlnont +>>>>>>> Stashed changes +emnguchua +emo emod +emodw +emodwire +emodwirelist +emodwirelistlist +emodwires emoji emojis +emone +<<<<<<< Updated upstream +======= emono +>>>>>>> Stashed changes emoo -emotionalstate emp +empa +empb +empbe +empbp +empbpt +empbptun +empbu +empbun +empbunpt +empc +empety emph +emphasizes +emphatically +empheap +empirical empl +employ +employee +employees +employs +empop +empp +emppt empr emprel +empsemantics +empseparationlogic +empsg +empsgamma +empsp +empspl +empstate empt +empties emptiness +emptrue empty emptyal emptyarrowequivpunit +emptyax +emptybag +emptybdd +emptybook +emptycaller +emptyci emptycollection emptycols +emptyctxt emptyd emptydigraph emptydischarge +emptydissolve emptye emptyeffect emptyenv +emptyeq emptyequivalence emptyessl emptyex emptyext +emptyfetch +emptyfinvec +emptyflw +emptyfn +emptyforall +emptyfraenkel emptyfromlist +emptyfullguards +emptyfun +emptyg +emptygrammar emptygraph +emptyhexstrings emptyhom emptyi +<<<<<<< Updated upstream +emptyins +======= emptyinpowerset +emptyins emptyinunitempty +>>>>>>> Stashed changes emptyisinitial +emptyl +emptylang +emptylefalse emptyline emptylinelinter +emptylist +emptylocal +emptylocaldatatype +emptylocalghost emptyls +emptymap +emptymetriclog +emptymi +emptymodifiesclause +emptyness emptynf +emptyoffending emptyon +emptyp emptypair +emptypass +emptypos emptypost +emptypowempty emptyproc emptyprod +emptyqueue +emptyr +emptyreadsclause emptyrelation emptyrows emptyrs emptys +emptysch +emptyseq +emptysequence emptyset -emptysetax -emptysete -emptysetimpfalse -emptysetordinal emptysets +<<<<<<< Updated upstream +======= emptysetsubset +>>>>>>> Stashed changes +emptyshare +emptystack +emptystate +emptystore emptystr +emptystring emptystructure emptysum emptysumlex emptytitle emptyto +emptytolstr +emptytree +emptytuple +emptytype emptyunique emptywf emptywithcapacity +empu +empun +empx +empy +empyt emre +emregwrite +emresult +emret emsapss +emseparation +emspace +emtensormult emtpy +emty +emul emulate +emulating +emulation +emulnt emulti emultip emultiplici emultiplicity +emv +emveque ena +enab enabl enable enabled @@ -21029,32 +35586,65 @@ enabledatstep enabledconfigs enablede enabledi +enabledp enabledprefix enabledprefixsingle enabledprefixsinglefinalstep +enableds +enablekeyensurespublicly +enablekeyrotationensurespublicly +enablekinesisstreamingdestinationensurespublicly enableppunivonhead enables enablesimp +enablestmt enabling +enadj +enadjlem ename -enamespace enat enatcard enatmap +enatmul enatoption enb +enbd enc enca encadr +encalg +encap +encaps +encapsu +encapsul +encapsula +encapsulado +encapsulat encapsulate +encapsulated +encapsulation +encapuslate encar encard +encart +encasulate +enccontent +encctx encd encdec +encdecmap +encdetall +encdoe ence +encf enci +encl +enclose enclosed enclosing +enclosingmethod +enclosure +encmapenc encod encodable encodablecountablebasis @@ -21062,157 +35652,352 @@ encodableoflist encodablequotient encodablet encode +encodearmimmediate +encodeascii +encodeasciiunique +encodebitmask +encodeblock +encodeblockpos encodebool encodecode encoded +encodedecode +encodedecodeblock +encodedecodeintruncatedgroupoid +encodedecoderecursively +encodedecodet +encodedecodeunpadded +encodedecodevalid +encodeencryptioncontext encodeexpr encodeexprwitheta encodegammacond encodek +encodelengthbound +encodelengthexact encodelist +encodelogicalop +encodemap encodemultiset encodenat encodenum +encodepair +encodepoint encodeposnum +encoder +encoderecursively encodes +encodescalarsequence +encodescalarvalue +encodescalarvaluedoublebyte +encodescalarvaluedoubleword +encodescalarvaluequadruplebyte +encodescalarvaluesinglebyte +encodescalarvaluesingleword +encodescalarvaluetriplebyte +encodeseq encodesigma encodesubtype encodesum +encodet +encodetruncs +encodeunpadded encoding encodingd +encodingform encodingi encodingnat encodingnatbool +encodingp encodings encodingstep encodingstepaux encodingstepwitheta encompass +<<<<<<< Updated upstream +======= enconstructorname +>>>>>>> Stashed changes +encount encounter encountered +encountering encounters encourage encouraged +encoutput encpf encrypt +encryptable +encrypted +encrypteddatakey +encrypteddatakeylist +encrypteddatakeystoadd +encryptedkey +encryptedwithkey +encryptensurespublicly +encryptfinalframe +encrypting encryption +encryptioncontext +encryptioncontextcomplete +encryptioncontextconstructorsarecorrect +encryptioncontextdigest +encryptioncontextkeystojson +encryptioncontexttoaad +encryptioncontexttojson +encryptioncontexttype +encryptionmaterialadddatakey +encryptionmaterialaddencrypteddatakeys +encryptionmaterials +encryptionmaterialshasplaintextdatakey +encryptionoutputencryptedwithaad +encryptionoutputfrombyteseq +encryptmanifest encryptnothingoracle encryptoracle +encryptregularframe +encryptrnd +encryptschedule +encrypttesttodecryptvector +encrypttestvector +encrypttestvectortojson +encryptvectortoencrypttest +encryptwithkeyhat encs +encshift +enct +enctlem +encumber encv encyrpt end +endalg endalgequiv endautgaloisisomorphism +endb endbase endcapitalnames endcapitalnamesoflist +endcases endcomp +endcond +endcost +endcyclenormal +endd +ende +ended endequiv endequivautgalois endequivauxequiv endequivderivation endequivsectionsfibers +endexp +endexpp +endframe +endfunc endfunctor +endh endhom +endia +endian +endianness endif ending endings +endinst +endint endisfree endisj endjudisj +endjusym +endl endless +endmeasure endmnd endmndlem +endmod +endmodule endmonoidal endmonoidalstarfunctor endmonoidalstarfunctorequivalence endmulequivautgalois endmulequivsubgroup +endmult +endnone +endnum endo +endoapplicative +endof +endofcode +endoffile +endofheap endofmnd endofsegid endofsegidand +endofu +endofun +endofunction endofunctions +endofuncto endofunctor endofunctormonoidalcategory endofunctors +endoiso endom +endomap +endomaps +endomonad +endomorph +endomorphi endomorphism +endomorphismp endomorphisms endomorphs endomtr endormore endos +endou +endout endow +<<<<<<< Updated upstream +======= endowment +>>>>>>> Stashed changes +endp endpc +endphase endpoint endpointident endpoints endpos +endps endringequiv ends endsemiringequiv endset +endsi +endswap endswith +endt +endtable endtensorendalghom +endtoend +endtok +endtrm +endv endval endvecalgequivmatrixend endvecringequivmatrixend +endvertex ene +<<<<<<< Updated upstream +======= eneadd eneapp enebase +>>>>>>> Stashed changes +enedgfi +eneg enege -enelistop -eneliteral -enemult enen +eneq +eneqconst ener +eneralize +<<<<<<< Updated upstream +======= enerel +>>>>>>> Stashed changes energies energy enew enex enext -enextfree enf enfi enfialt enfii enfin enfixsn +enfoldli enforce +enforced enforces +enforcing +<<<<<<< Updated upstream +======= enfqv +>>>>>>> Stashed changes eng +engaged engch engel engelian engine +<<<<<<< Updated upstream +englishman +======= engineer engineeringcomponent +english +englishman englishmt +>>>>>>> Stashed changes enh +enhance +enhanced eni +enif +enigma enil +eninl +eninr enl enlarge enlargement enle enlem -enletdec enlightening +enlistw enm +enmap enmappw enmappwid +enmkv +enmkvlem enn enne ennexp +enni ennn ennnalt +ennnfone +ennnfonelem +ennnfonelemdc +ennnfonelemdm +ennnfonelemen +ennnfonelemex +ennnfonelemf +ennnfonelemfun +ennnfonelemg +ennnfonelemh +ennnfonelemhdmp +ennnfonelemhf +ennnfonelemhom +ennnfonelemim +ennnfoneleminc +ennnfonelemj +ennnfonelemjn +ennnfonelemk +ennnfonelemkh +ennnfonelemnn +ennnfonelemom +ennnfonelemp +ennnfonelemr +ennnfonelemrn +ennnfonelemrnh +ennnfonelemss ennre ennrea ennreal @@ -21225,13 +36010,21 @@ ennrealratembed ennrealtomeasure ennrealvariation ennrpow +ennsqrt ennum eno +enocde enode enodes +enodeseq +enoent +enomni +enomnilem +<<<<<<< Updated upstream +======= enone +>>>>>>> Stashed changes enorm -enormal enormedaddcommmonoid enormedaddmonoid enormeddivisionring @@ -21241,18 +36034,31 @@ enormprojbound enorms enormsmulclass enosaqarchqg +enospc +enot +enotdir enough enoughinjectives enoughprojectives enp enpr +enprmap +enprmapc +enprmaplem +enpw enq enqbreq +enqdc +enqeceq enqeq enqer enqex enqgtubsoxrz +enql +enque enqueue +enquote +enr enrbreq enreceq enref @@ -21262,16 +36068,22 @@ enrefnn enrelmap enrelmapr enrer +enres enrex +enrflx +enrflxg enrich +enriche enriched enrichedcat enrichedcategory enrichedcategoryself enrichedcategorytypeequivcategory enrichedcategorytypeofcategory +enrichedcats enrichedcomp enrichedfunctor +enrichedfunctors enrichedfunctortypeequivfunctor enrichedhom enrichedid @@ -21281,27 +36093,48 @@ enrichednattransyoneda enrichednattransyonedatypeisoyonedanattrans enrichedordinarycategory enrichedordinarycategoryself +enrichedunderlying enriches enrichment +enrness +enround +enroute ens +<<<<<<< Updated upstream +======= ensall ensappend +>>>>>>> Stashed changes +enscat ensdomtr ensemble ensembles +<<<<<<< Updated upstream +======= ensempty +>>>>>>> Stashed changes +ensen ensf +ensg +enshom +<<<<<<< Updated upstream +======= enslift enslookup ensmap +>>>>>>> Stashed changes +ensmble ensn ensogeulpjdaywwgj -enspeclinelist enssdom enssdomold +ensu ensucne +ensuing +ensur ensure ensureattrdeclismeta +ensured ensurefirstisbest ensurehasnomvars ensurehastype @@ -21309,7 +36142,10 @@ ensureiff ensureisfunction ensureissort ensureproxyequiv +ensurerevealpreconditionforcomparisonwithfunction ensures +ensuresdoesnothold +ensuresfuncfoo ensuresidesdefeq ensuring ensym @@ -21320,34 +36156,62 @@ ensymi ent entail entailed +entaill entailment entails +entailsd +entailse entailsi entailsliteralrelpacepartwithequivalent +entailst entangled enter enterarg +entered enterformat +enteri enteridx enteridxopt entering enters enterstx +<<<<<<< Updated upstream +======= entertainmentprofession +>>>>>>> Stashed changes +enterx +entier entire entirely +entires +entirety +<<<<<<< Updated upstream +======= entity +>>>>>>> Stashed changes +entlen +entonces entourage +entouragee +entouragep entourageprod entourages +entp +<<<<<<< Updated upstream +======= entproperties +>>>>>>> Stashed changes entr +entrance entrfi entrfil entrfir entri entric +entrie entries +entriesi +entriesp entriestomessagedata entringer entropy @@ -21355,94 +36219,201 @@ entry entryaddhom entryaddmonoidhom entryatidx +entryd entrylib entrylinearmap entrylist +entryp entrypoint +entrypoints +entrypts +entrys +entryt entrywise entrywisesupnorm +entt +enttd +entti +enu enum enumappend enumbase +enumbasekind +enumchain +enumct +enumctlemm +enumelim enumer +enumera +enumerable enumeracionformulasnat enumeral enumerate enumeratecountable enumerated +enumerateoverinfinitecollections enumerates enumerating enumeration enumerationformulasp +enumerations +enumerationsmaybenull enumerator +enumext enumf +enumformulashall enumfrom enumfromto enumfromtol enumfromtos enumfromtostep +enuminj enumlist enumlistname enumlistnodupname enumord enumordorderiso enump +enums +enumse enumset enumt +enumv +<<<<<<< Updated upstream +======= enuqconstructorname +>>>>>>> Stashed changes env +enva +envaction +envb envc +envcoh envcomm envd +enve envelaction envelgroup +envelop enveloping +envequale +envequalt envextension envi +envid +envinit +envir +envird +envire +enviri environ +environmen environment +environmental +environmentp environments +envl +envlist +envlists +envm +envma +envmap envobs +envok envs +envsi +envsq +envst envsubst +envt +envterm +envtrans +envv envval +enwomni +enwomnilem enwwlksnge eoa +eobj eoc +eocc +eoccs +eoe eof +eofpt +eoft +eoh eoi +eol +eolp +eom +eomlem +eoncirc +<<<<<<< Updated upstream +eop +eopalt +eopdc +eopt +eoption +======= eone eop eopalt +eopdc eopenfilefs +eopt eoption eoptrel +>>>>>>> Stashed changes +eoq +eor +eornt +eos eout +eoutcirc +eoutco +eoutcome eoutknowcorrect eoutknowsecorrect +eoutm +eov +eovi +<<<<<<< Updated upstream +eparallel +eparams +epartition +======= epair +eparallel +eparams eparse eparsetree +epartition epat +>>>>>>> Stashed changes +epatch epath -epatprops -epats -epatsem -epatternmatches epb +epc epee -epeg -epegsym epel epelb +epelc +epelcres epelg epeli epelon epfrc epfrs +ephemeral +ephemerald epi epic +epicinv +epicinvisri +epicinvisrightinv epicomp +epicretract epidesc epigraph epigraphi @@ -21450,14 +36421,19 @@ epihom epii epiiscokernelofkernel epilog +epilogue +epiloguepost epimodserre epimono +epimorph epimorphic epimorphism +epimorphismp epimorphisms epin epini epinid +epip epipullback epirron epis @@ -21467,50 +36443,89 @@ epistemictypechecker epiwithinjective epiwithinjectivekernel eplus +epm +<<<<<<< Updated upstream +======= epmatch +>>>>>>> Stashed changes epn epne epnsym epnsymrel +eponymous epoo epos +epostincrdecr epow epp +epprc epr epred eprel epres +epreserved +<<<<<<< Updated upstream +======= epreslang +>>>>>>> Stashed changes +eprik +eprika +eprikf eprim +eprime +<<<<<<< Updated upstream +======= eprimsemenv +>>>>>>> Stashed changes +eprint eprintln +eprio eprod +<<<<<<< Updated upstream +======= eprog eprompt +>>>>>>> Stashed changes +eprop eps -epsa -epsb -epsc epsclo epsclosure -epscomp epse +epsi epsil epsilon +epsilong +epsilonset +epsl +<<<<<<< Updated upstream +epsoon +epsrn +ept +======= epso epsoo epsoon +epsrn +ept eptree +>>>>>>> Stashed changes +epts epttop +epubk +epubka +epubkf +<<<<<<< Updated upstream +======= epull epure epush +>>>>>>> Stashed changes epuzyquvacft -epvar epweon epweonalt epxr eqa +eqaa eqab eqabb eqabbw @@ -21521,21 +36536,60 @@ eqabcri eqabdv eqabf eqabi +eqable eqabrd eqabri +eqadd +eqaddo +eqaddoe +eqaddoex +eqaddoo +eqaddop +eqadj +eqal +eqals +eqamod +eqamodd +eqamoddl +eqamoddr +eqamodm +eqamodml +eqamodmr +eqamodn +eqand +<<<<<<< Updated upstream +======= eqangle +>>>>>>> Stashed changes eqap +eqaxiom +eqaxioms eqaz eqb eqbbvector +eqbbylbp +eqbe +eqbf eqbg eqbi eqblist eqblisteqlist +eqblock +eqblr eqbool +eqboolvar +eqbottommaingen +eqbottommaingenlem +eqbp eqbpair +eqbr eqbrb +<<<<<<< Updated upstream +======= eqbreln +>>>>>>> Stashed changes +eqbrl +eqbrr eqbrrdiv eqbrrdv eqbrrdva @@ -21551,30 +36605,65 @@ eqbrtrri eqbrtrrid eqbst eqbutgh +eqbutpid eqbutuid eqbutuidf eqbutuidl +eqbutuids +eqbylbp eqc +eqcard +eqci eqcl +eqclaop eqclass +eqclassd +eqclasses +eqclassi +eqclause +eqclauses eqclos eqclosure +eqcmod +eqcmodd +eqcmoddl +eqcmoddr +eqcmodm +eqcmodml +eqcmodmr +eqcmodn +eqco eqcocnv eqcoe eqcom eqcomd eqcomi eqcoms +eqcomx +eqcong +eqconj +eqconst eqcont +eqcover +eqctx eqcuts eqd eqda eqdata +eqdataba +eqdatabase +eqdatabasep eqdb eqdc eqdd eqde eqdec +eqdecfoo +eqdecider +eqdecstate +eqdef +eqdepth +eqdex eqdif eqdist eqdom @@ -21582,11 +36671,17 @@ eqdr eqdrusgr eqds eqe +eqecard +eqedim eqeefv eqeelen +eqefcard +eqefproper +eqefsubset eqel eqelb eqelbid +eqelr eqelssd eqelsuc eqeltr @@ -21598,23 +36693,37 @@ eqeltrrd eqeltrrdi eqeltrri eqeltrrid +eqemproper +eqemsubset eqeng +eqenv +eqeproper eqeq eqeqan +eqeqset eqer eqerlem +eqesubset +eqesubv eqeu eqeuel +eqev eqex eqexn eqexnp eqexpless eqexpmax +eqext eqf eqfacl eqfag +eqfalse +eqfalseleaf eqfam +eqfat +eqfe eqfg +eqfin eqfm eqfmd eqfnfv @@ -21627,7 +36736,10 @@ eqfraction eqfree eqfsecmat eqfssc +eqfun eqfunfv +eqfunishom +eqfunp eqfunresadj eqfunressuc eqfv @@ -21637,10 +36749,15 @@ eqgabl eqgcpbl eqgen eqger +eqgex eqgfval eqgh +eqgi eqgid +eqgip +eqgixx eqglact +eqgt eqgval eqgvscpbl eqhom @@ -21649,29 +36766,61 @@ eqid eqidd eqideal eqif +eqifdc +eqiff +eqim +eqimage +eqimg +eqimpl eqimpofiffimp -eqimpsubset eqimss eqimsscd eqimssd eqimssi eqin +eqincl eqineqd eqinf eqinfd +eqinfti +eqinftid +eqinj +<<<<<<< Updated upstream +======= eqinunit +>>>>>>> Stashed changes +eqispr +eqit +eqitc +eqite +eqitf +eqitgen +eqitree eqitv eqitvp eqiv +eqivalencerespecting +eqj eqjzobnejxghwqrmwbavufxrdsthxirdgezthbheebdaqpet eqk +eqki eql +eqla +eqlable +eqlablep +eqlam +eqlat eqle eqled +eqleftif eqlei eqlelt eqleltd eqlen +eqlenp +eqlenss +eqlfun +eqlfunp eqlist eqlista eqlistok @@ -21680,25 +36829,46 @@ eqlistsortocp eqlistsym eqlisttrans eqlkr +eqln +eqlnat eqlocus eqlocusfield eqlocusm eqlocuss +eqlogic +eqlp +eqlt +eqltrace eqltrg +eqm +eqmap eqmat eqmaximumi +eqmdelay +eqmem eqminimumi eqmixin eqmixinx eqmod eqmode +eqmodp eqmon +eqmp eqmpr +eqmts eqmvar eqmvtd +eqmx +eqmxmfree +eqmxmfull +eqmxmr +eqmxmunitp +eqmxp eqn eqnat eqnbrtrd +eqnc +eqncg eqne eqneg eqnegad @@ -21708,46 +36878,84 @@ eqneltrd eqneltri eqneltrrd eqneqall +eqner eqnetrd eqnetri eqnetrrd eqnetrri eqnetrrid +eqnoo +eqnot eqnp eqns eqnsattribute eqnum +eqny +eqnyp eqo +eqoaddo +eqoe +eqoex eqofheq eqofhomeq eqofmgf +eqolim +eqolimp +eqomega +eqomegae +eqomegao eqon eqone eqongl eqonsource eqonuc eqonuout +eqoo eqop eqopab eqopi eqopp +eqopr eqoprab +eqoprrdv +eqoprriv +eqopsnt +eqopt +eqor eqord eqoreldif eqoriff +eqox eqp +eqpair +eqpchoice +eqpcountable eqperm eqpf +eqpfp +eqpib +eqple +eqplus eqpoll +eqpolld eqpp +eqppointed eqpq eqpr +eqpreds +eqpredtype eqprf eqprincd eqprodroots eqproof +eqpt eqptail +eqpw +eqpwrelk +eqpxx eqq +eqquote +eqquotp eqr eqra eqrabdioph @@ -21757,34 +36965,60 @@ eqrd eqrdav eqrdv eqrec +eqrect +eqrefl eqrel eqrelation eqrelf +eqrelk +eqrelkrdv +eqrelkriiv +eqrellatt eqrelrd eqrelrdv eqrelrel eqrelriiv eqrelriv +eqrelset eqres eqresfnbd +eqrespects eqresr +eqresult +eqresultseq eqreu eqreznegel eqri +eqrightif eqriv +eqrnat +eqrow +eqrp eqrrabd +eqrx +eqrxp eqs eqsb eqsbc eqsec +eqsegm eqseq +eqseqe +eqseqp +eqseqvalue +eqset +eqsetp +eqsets eqsim +eqsize eqslocus eqsn eqsnbi eqsnd +eqsndc eqsndold eqsnext +eqsnm eqsnuniex eqsqrt eqsqrtd @@ -21792,6 +37026,8 @@ eqsqrtor eqss eqssd eqssi +eqssr +eqsstr eqsstrd eqsstrdi eqsstri @@ -21801,20 +37037,45 @@ eqsstrrdi eqsstrri eqsstrrid eqst +eqstateeq +eqsubst +eqsucc eqsumroots eqsup eqsupd +eqsupti +eqsuptid +eqsvneq +eqsym eqsymm eqt +eqtc eqterm +eqterms +eqtfinrelk +eqth +eqtheta +eqthetae +eqthetao +eqtimes eqtl +eqtoeq eqtoequivalence eqtoequivalencefunctoriso +eqtofun eqtohom eqtohomtransiso +eqtoid eqtoiso +eqtok eqtop +eqtopath +eqtoso eqtr +eqtrac +eqtrace +eqtracep +eqtraces eqtrans eqtransd eqtrb @@ -21824,21 +37085,65 @@ eqtri eqtrid eqtrrd eqtrri +eqtru +eqtrue +eqtrueleaf +eqtup eqtwo +eqtyp eqtype +eqtypet eqtypex +eqtypi +eqtypri equ equa equal +equalanglehalflineb +equalanglehalflinec +equalanglesflip +equalangleshelper +equalanglesnc +equalanglesreflexive +equalanglessymmetric +equalanglestransitive +equalbyump equalcharzero +equalcommit +equalconst +equalcoord +equalelementsmakeequallists +<<<<<<< Updated upstream +======= equalelemsp +>>>>>>> Stashed changes +equalexpr +equalfunction +equali +equalid +equalint +<<<<<<< Updated upstream +======= equalish +>>>>>>> Stashed changes +equalit equalities equality +equalityatleastlinear equalityconversion +equalityd equalitye +equalityextension +equalityextensionpreserveseq equalityi +equalityisreflexiveinghost +equalityofstrings +equalityp equalitysubrelation +equalitysymmetric +equalitytests +equalitytype +equaliz equalize equalizer equalizercomparison @@ -21849,35 +37154,72 @@ equalizerconeislimit equalizerfork equalizerforkislimit equalizerforktensorprodiso +equalizeri equalizerisequalize equalizerisequalizer equalizeriso equalizerlimit equalizerofsplit equalizerpullbackmapiso +equalizerrelstr equalizers equalizersieve +equalizerstructure equalizersubobject equalizersubobjectiso +equalizersuitablerel equalizes equallength +equalling equally equalmodstrick equalon equalond equaloni +equalonkey +equalp +equalrelation +equalresidual equals +equalsem +equalset +equalsets +equalsi equalsn +equalsp +equalst +equalsu +equalsubandupdate +equalsumandupdate +equalt +equaltimestamp equalto +equaltorightisright +equaltriangleanticlockwise +equaltriangleclockwise +equalual +equalvote +equalwrt +equalx +equan +<<<<<<< Updated upstream +======= equantheuristics +>>>>>>> Stashed changes equat equate +equated equates equati +equating equation equational +equationaltheory +equatione equations equator +equavalent +equaz equcom equcomd equcomi @@ -21886,6 +37228,7 @@ equcoms equequ equeucl equeuclr +equh equi equico equicontinuity @@ -21895,37 +37238,90 @@ equicontinuouson equicontinuouswithinat equid equidecomp +equidirected +equidirectedcollinear +equidirectedcollinearcollinearequidirected +equidirectedcollinearequidirected +equidirectedlineacollinear +equidirectedlinebcollinear +equidirectedpermut +equidirectedpermutcd +equidirectedrefl +equidirectedsym +<<<<<<< Updated upstream +======= +equidistant +>>>>>>> Stashed changes +equidistantdistinct +equidold equidq equidqe +equienumerable equifibered equiintegrable equiintegral +equil equilateral +equilateralclockwise +equilaterallslt +equilateralspec +equilength +equilibria equilibrium +equilibriumd +equimorphic +<<<<<<< Updated upstream +======= equinumerous +>>>>>>> Stashed changes +equiopt +equioptimal +equioriented +equiorientedcollinear +equiorientednotequioriented +equiorientednotequiorientedabc +equiorientedrev +equiorientedsym equip equipartitio equipartition equipartitions +equipment equipotent equipped equipping +equiprobable equips +equirange +equisatisfiable +equisolvable +equisort +equit equitabilise equitableon equiv equiva +equivaction equivaddcircle equivadjoin equivadjoinsimple +equivadjointequiv equival +equivalanc +equivalance +equivalen +equivalenc equivalence +equivalencecharacterization equivalencecounitiso equivalenceeffectivepresentation equivalencefrommodel equivalencefunctor equivalencefunctorequivfunctoriso +equivalenceh equivalencej +equivalencekernel +equivalencel equivalenceleftfractionrel equivalencelefttoright equivalencemodulemonoidalgebra @@ -21936,8 +37332,12 @@ equivalenceofisempty equivalenceofisinitial equivalenceofisterminal equivalenceofreindexing +equivalenceparam +equivalencepfun +equivalencer equivalencereflectsnormalepi equivalencereflectsnormalmono +equivalencerelation equivalencerighttoleft equivalences equivalenceselfofhasfinitebiproducts @@ -21945,16 +37345,29 @@ equivalenceselfofhasfinitebiproductsaux equivalencesemimodulecat equivalencesingleobj equivalencesingleobjinverse +equivalencetheorem equivalencetrans equivalenceunitiso +equivalencia +equivalency equivalent +<<<<<<< Updated upstream +======= equivalentclass +>>>>>>> Stashed changes +equivalente equivalentformulae +equivalenti +equivalentlabel +equivalentlabelseq equivalently -equivalentproperty equivalents +equivalentstates +equivalentwaysofsayingsequenceisnonempty equivalgend equivalghom +equivallent +equivance equivapp equivar equivariance @@ -21973,7 +37386,9 @@ equivaugmentedsimplicialobjectfunctorcomppointiso equivaugmentedsimplicialobjectfunctorcomptoarrowiso equivawayadjoinroot equivawayquotient +equivb equivbasechange +equivbind equivbitindices equivbnd equivbool @@ -21984,19 +37399,36 @@ equivcau equivcauchy equivcfil equivclass +equivclasschoose +equivclasseq +equivclasses +equivclassnonempty equivclopens +equivclos +equivclosidempotent +equivclosleast +equivclosmonotone +equivclossuperset equivclosureoperator +equivclp equivcmet equivcomma equivcommringcat equivcommuteconstant equivcomp +equivcompiso equivcongr equivcongrleft equivcontinuousmap +equivcontr equivcostructuredarrow +equivctr +equivctrpath equivcurry equivd +equivdec +equivdeps +equivdepsmap equivdfinsupp equivdiagram equivdirectsum @@ -22004,12 +37436,17 @@ equive equivelements equivempty equivemptyequiv +equiveq equivequiviso equivessimageofreflective equivestrcsetc equiveven +equivext equivexterior equivf +equivfe +equivfiller +equivfillersub equivfin equivfinofcardeq equivfinofcardpos @@ -22024,6 +37461,7 @@ equivfixedpoints equivfnofdiscrete equivfreealgebra equivfun +equivfuna equivfunctionfield equivfunctionfieldover equivfunctor @@ -22046,6 +37484,7 @@ equivico equivicomod equivii equivimage +equivimplicit equivinduced equivinfiniteplace equivint @@ -22058,14 +37497,19 @@ equiviocmod equivirreduciblecomponents equiviscolimitop equiviscolimitunop +equivisequiv equivislimitop equivislimitunop +equiviso equivisocolimit equivisoiso equivisolimit +equivj equivl +equivlanence equivlaxbraidedfunctorpunit equivlaxmonoidalfunctorpunit +equivlc equivlike equivlim equivlinearmapasmodule @@ -22092,10 +37536,13 @@ equivmonoover equivmultiset equivmvpolynomial equivmvpolynomialquotient +equivname equivnat equivnatsum equivnatsumoffintype equivnattrans +equivnknown +equivnode equivnonzerodivisorsnat equivnum equivnumofislocalization @@ -22137,16 +37584,22 @@ equivofsubsingletonofsubsingleton equivofsurjective equivoftensorisounit equivoftranscendencebasis +equivolr equivop equivoplax equivopposite equivoption +equivorl equivp equivpair equivpairaux equivparti equivpartp equivpartpe +equivpath +equivpathp +equivpathtoequiv +equivpathtoequivpath equivpempty equivpi equivpic @@ -22159,7 +37612,13 @@ equivpointreflection equivpolynomial equivpolynomialquotient equivpolynomialself +equivpresdec +equivpresdiscrete equivpresentedgroup +equivpreservesisnull +equivpresisfinord +equivpresisfinset +equivpresisfintype equivprezerohypercoverfamily equivprimesover equivprod @@ -22168,6 +37627,7 @@ equivprodnatfactorednumbers equivprodnatsmoothnumbers equivprodofsurjectiveofiscompl equivprojectivization +equivproprel equivpullbackobj equivpunit equivpunitofprodinjective @@ -22194,6 +37654,8 @@ equivrealprodaddhom equivrealprodclm equivrealprodlm equivreindex +equivrel +equivreplistp equivreversebraiding equivring equivs @@ -22211,6 +37673,8 @@ equivsmallfreeiso equivsmallmodel equivsmallsheafificationiso equivsmul +equivsp +equivspheresusp equivstructuredarrow equivsubgrouporbits equivsubgrouporbitsquotientgroup @@ -22222,9 +37686,14 @@ equivsubzero equivsucc equivsum equivsym +equivt equivtangentbundleprod equivtensorproduct equivtensorquot +equivthm +equivtoequiv +equivtoequivpath +equivtoiso equivtoopposite equivtooverunit equivtop @@ -22233,6 +37702,7 @@ equivtotbnd equivtounithom equivtree equivtreesofnumnodeseq +equivts equivtuple equivtype equivuliftcoyonedaiso @@ -22246,14 +37716,21 @@ equivvector equivweakdual equivwithabs equivwithval +equivx equivyoneda equivzerothhomotopy equivzmodp +equn equncom equncomi equncomivd equncomvd +equntil +<<<<<<< Updated upstream +======= equotient +>>>>>>> Stashed changes +equov equpto equs equsal @@ -22263,12 +37740,14 @@ equsaldv equsalh equsalhv equsalhw +equsalhwold equsalv equsalvw equsalvwd equsb equsex equsexalt +equsexd equsexh equsexhv equsexv @@ -22279,16 +37758,24 @@ equsv equsvt equtr equtrr +equv equvel +equveli equvelv +equvin equvini equvinv equvinva eqv +eqvalue +eqvarcon +eqvarvar eqvd eqvel +eqvenv eqver eqvf +eqvfproper eqvgen eqvi eqvinc @@ -22297,6 +37784,11 @@ eqvincg eqvinop eqvisset eqvl +eqvlt +eqvmproper +eqvneq +eqvp +eqvproper eqvr eqvrel eqvrelcl @@ -22323,10 +37815,18 @@ eqvrelthi eqvreltr eqvreltrd eqvreltrrel +eqvs eqvt +eqvti eqvtrescommrel eqvttrans eqvtweaktrans +eqvwf +eqvwfequivalence +eqvwfeqv +eqw +eqweqmap +eqweqmapid eqwordset eqwrd eqwrdeq @@ -22336,22 +37836,28 @@ eqxm eqxp eqxx eqxy +eqy +eqyp eqz eqzero eqzeroiff era -erabort eraltv eraltveq erange +erangetype +erangetypelist erank eras +erasable erase eraseaddhom eraseattr +erasechild erasecore erased erasedmachine +erasedpool erasedups erasefvarid eraseidx @@ -22372,6 +37878,7 @@ erasep eraseperm eraseproofs erases +erasesyncevent erasetheorem eraseusedtactics eraseusedtacticslist @@ -22379,6 +37886,9 @@ erasez erasing erasur erasure +erasureproof +erasures +eratosthenes erbr ercgrg ercl @@ -22397,53 +37907,93 @@ erclwwlkrel erclwwlksym erclwwlktr ercnv +ercp ercpbl ercpbllem +ercpbllemg erd erden erdisj erdm +erdmrn erdos erdsze erdszelem ere erea ereal -erealax erealequivreal +erealgencinfty +erealgenoinfty ereali +erealwithrays +erec +erectedperpendicularunique +<<<<<<< Updated upstream +erefine +erefl +======= eref +erefine +erefl ereftag +>>>>>>> Stashed changes ereg -eregexp erel -erelation ereldm +ereli +<<<<<<< Updated upstream +eremove +erenaming +======= ereln +eremove +erenaming ereplicate +>>>>>>> Stashed changes +erepp erepr ereprk ereq -ererr eres +<<<<<<< Updated upstream +======= erespects erest +>>>>>>> Stashed changes +erestrict +erestrictb +erestrictd +erestrictm +erestrictn eresult +eret +ereturn +<<<<<<< Updated upstream +======= ereverse +>>>>>>> Stashed changes erewr erewrite erex erexb erf erfc +ergo ergodic ergodicsmul ergonomics +eric +<<<<<<< Updated upstream +======= erich +>>>>>>> Stashed changes +erik erimeq eringring erinxp erk +erl erlang erlbr erlbrd @@ -22451,6 +38001,7 @@ erlcl erldi erlecpbl erler +erln erlval erng erngbase @@ -22463,22 +38014,38 @@ erngmul erngplus erngring erngset -ernode ernum ero eroprf +erosion erov eroveu erovlem +erp +<<<<<<< Updated upstream +======= erpath +>>>>>>> Stashed changes erprt err +erra errata +errb errctx +errd +erre erref errel +errflg +errintv +errinv +errive +errmap errmsg errn +errno +erro +erroneously error errorboundedmult errorboundedmultclosest @@ -22493,75 +38060,170 @@ errorboundedplusabs errorboundedplusle errorcode errorcontext +errorcount errorexample +errorflag errorformat errormessage errormsg +errorout +errorp errorpart errorpartfmt errorref errors errorsfound +errorstate errort errorterm +errortostring +errp +errr +errs errsum +errtest errtosorry +errv +errx ers ersatz +erss erssxp +<<<<<<< Updated upstream +======= erst +>>>>>>> Stashed changes +ersv ersym ersymb +ersymtr +<<<<<<< Updated upstream +======= ertc +>>>>>>> Stashed changes erth erthi -ertimeout ertr ertrd +<<<<<<< Updated upstream +erv +erw +erwischt +======= ertype +erv erval erw +erwischt esa +>>>>>>> Stashed changes esakiahom esakiahomclass esat +esc escalated escap +escapable +escapablechar escape +escaped escapedheaders +escapedstrchar escapedtable +escapep +escapequotes escapes +escapet +escapetoutf +escapeunicode +escardo +esci escl +escort +escorts +escs +escseq esd +esdk +esdkcanonicalencryptioncontext +esdkcanonicalencryptioncontextcanbesplit +esdkencrypttestvector +esdkmanifestoptions +esdktestvectors +ese +<<<<<<< Updated upstream +======= esec esection +>>>>>>> Stashed changes +eselection esem -esemanticprimitives -esemantics -esemanticsprops -esemicolont eseminormedaddcommmonoid eseminormedaddmonoid eseminormedcommmonoid eseminormedmonoid +esems +esemt +<<<<<<< Updated upstream +======= esep +>>>>>>> Stashed changes +eseq +eseqand +eseqor +eseries +eseriesd +eseriesenat +eserieseord +eseriesl +eseriesr +eseriess +eseriessb +eseriessr +eses eset +<<<<<<< Updated upstream +======= esexp +>>>>>>> Stashed changes +esg +esgc +esgnf esgqdpfj +esguard +eshapes eshift +eshiftnt +esi +esigf esigma esigmanotzero +esilon +esim +<<<<<<< Updated upstream +======= esimplesexp +>>>>>>> Stashed changes +esims +esing +esingle +esize +esizelist +esizeof esl +esmall esn esnd -esnoc -esome esop +esp espclosure espec especially +especificaci +<<<<<<< Updated upstream +======= esplit +>>>>>>> Stashed changes esplyfv esplyfval esplyfvn @@ -22572,12 +38234,25 @@ esplymhp esplympl esplysply esplyval +<<<<<<< Updated upstream +======= espt esptree +>>>>>>> Stashed changes +esqrt +esquema +esrc +esret +esrt ess +<<<<<<< Updated upstream +======= essa +>>>>>>> Stashed changes +essai +essay +essays essence -essenceinvexistence essencescharacterizecompletely essential essentially @@ -22585,8 +38260,10 @@ essentiallylarge essentiallysmall essentiallysmallofsmall essentiallysmallself +essentiallysurjective +essentials +essentiel essfinitetype -essgc essimage essimagedayconvolution essimagedayconvolutionunit @@ -22599,19 +38276,39 @@ esssurj esssurjfullfunctorgaloisinsertion esssurjinducedfunctor est +esta +establece +establis establish established establishes establishing +establishinva +establishinvauxa +establishinvauxb +establishinvb +establishrvinv +establisshing +<<<<<<< Updated upstream +======= estack estacklang estackprops estacksem +>>>>>>> Stashed changes estar estarski +estas estate +estd +este +<<<<<<< Updated upstream +======= estemp +>>>>>>> Stashed changes estep +estepstar +esti estim estimate estimated @@ -22621,9 +38318,12 @@ estimation estimator estimatordata estimators -estin esto +<<<<<<< Updated upstream +======= estore +>>>>>>> Stashed changes +estos estr estrcbas estrcbasbas @@ -22637,20 +38337,34 @@ estrchomfn estrchomfval estrcid estrcval +estream +<<<<<<< Updated upstream +estrictparallel +======= estrict +estrictparallel estring estrip +>>>>>>> Stashed changes estrres estrreslem +estructfield +estuck estype esub +esubgraph +<<<<<<< Updated upstream +======= esubmap esubset +>>>>>>> Stashed changes +esubst +esubterms esuc -esuccess esum esumadd esumaddf +esumb esumc esumcl esumcocn @@ -22658,6 +38372,7 @@ esumcst esumcvg esumcvgre esumcvgsum +esumd esumdivc esumel esumeq @@ -22691,11 +38406,25 @@ esumsnf esumsplit esumss esumsup +esumt esumval esup +esupe +esupn +esups +esupsn +esw +esws +<<<<<<< Updated upstream +esy +esym +======= esx esy +esym esymbol +>>>>>>> Stashed changes +esymk esymm esymmalgequiv esymmalghom @@ -22703,61 +38432,98 @@ esymmalghommonomial esymmpart esympoly eta +<<<<<<< Updated upstream +======= etabulate +>>>>>>> Stashed changes +etaconversion etaexpand etaexpandall etaexpanded etaexpandedstrict etaexpandn etafn -etag etai etaiso -etake etale etalelocus etaleprecoverage etalepretopology etaletopology +etap etapossibilities etareduceall +etarel +<<<<<<< Updated upstream +======= etargetsem +>>>>>>> Stashed changes etarski +etashort etaslts etastruct etastructall etat +etay etc etcd -etching etcons -etctor etempvar -etenv eterm eterms +etern +eternal +<<<<<<< Updated upstream +etext +======= eternity +etext etextioproof +>>>>>>> Stashed changes +etgt eth +ethane +ethbuf +<<<<<<< Updated upstream +======= ethe +>>>>>>> Stashed changes +etherdst +ethereum ethernet +ethersrc +ethertype +<<<<<<< Updated upstream +======= etick etid +>>>>>>> Stashed changes etingof -etip eto etocycles +etofun +<<<<<<< Updated upstream +etopat +etp +======= etok etoken etokens etolist etop +etopat etp etra +>>>>>>> Stashed changes +etrans etransc etransclem etransitivity +<<<<<<< Updated upstream +======= etrees +>>>>>>> Stashed changes +etreflexive etriangleltge etrue etruncge @@ -22770,13 +38536,24 @@ etruncltgeltselftoltge etruncltltisolt etruncltlttolt ets +etsort +ett ettjhleos +<<<<<<< Updated upstream +etyp +etype +etypecase +======= etvelookup etyop +etyp etype +etypecase etypesoundinvariants etypesystem +>>>>>>> Stashed changes etypewhnf +etys euabex euabsn euabsneu @@ -22785,6 +38562,7 @@ euan euanv eubi eubid +eubidh eubidv eubii eubrdm @@ -22799,21 +38577,36 @@ eucalgval eucl euclemma euclf +eucli euclid eucliddivs euclide euclidean +euclideandefinitions euclideandivision euclideandomain euclideangeometry euclideanhalfspace euclideanhausdorffmeasure euclideani +euclideanness euclideanquadrant euclideanreal +euclideanring euclideansp euclideanspace +euclideantest +euclides +euclidgcd +euclidgcdalt +euclidian +euclidianring +euclidlp +euclidpq +euclids euclidslemma +euclidt +euclmetr eucrct eucrctshift eudf @@ -22828,6 +38621,7 @@ eueqi euequ euequf euex +euexex euexv euf eufid @@ -22837,18 +38631,24 @@ eufsn eufsnlem eufunc eufunclem +euh euhash euim euimmo euind +euiotaex eujqpitjuocuh eujust eujustalt eujustlem +eukl +euklides +euklspace euksgxfnddgqivntvbg eulem eulemoldn euler +eulera eulerchar eulercharsigns eulercrct @@ -22885,21 +38685,39 @@ eulerpathpr eulerpaths eulerpoint eulerproduct +eulers eulersine eulerth eulerthlem +eulerthlema +eulerthlemfi +eulerthlemh +eulerthlemrprm +eulerthlemth +<<<<<<< Updated upstream +======= eulp +>>>>>>> Stashed changes eulplig eumo eumoi -euncurry eunex +<<<<<<< Updated upstream +======= eunify eunion +>>>>>>> Stashed changes +eunionfield +eunit eunitgenlawl eunitl eunitr +<<<<<<< Updated upstream +======= euniv +>>>>>>> Stashed changes +eunop +euntill euoldn euop euor @@ -22925,27 +38743,45 @@ eupthpf eupthres eupths eupthseg +eupthsg +eupthv eupthvdres +euq +euqiv +euqlity +eus eusn eusnsn +eusotyp eusv eusvnf eusvnfb eusvobj euswap +euswapdc euswapv eut eutf +eutt +euttg +euttge +euttnoret +euttvc eutv euv +euval euxfr +euxfrdc euxfrw +euy eva evad +evaddr evader evaderspeed evadertrajectory eval +evala evalabs evalabv evaladd @@ -22955,23 +38791,37 @@ evaladdnorm evaladdoverlap evalalgebramap evalalghom +evalapp +evalargs +evalargsc +evalargsclemma +evalargslemma evalarithmeticfunctionsigma evalarithmeticfunctionzeta evalascfactorial evalat +evalatix evalatom +evalator +evalaution evalb evalbernstein evalbesicovitchsatelliteconfigr +evalbexp +evalbinop +evalbl evalbound evalboundingsieveweights +evalbr evalc +evalcase evalcasesbash evalcast evalclm evalcoeff evalcollectsorries evalcomp +evalcompatcheckcore evalcompcoyonedacorepresentable evalcompcoyonedacorepresentablebydoubleid evalcompcoyonedacorepresentablebysingle @@ -22980,11 +38830,22 @@ evalcompeqtoequivalencefunctor evalcompinclisoid evalcomplexofreal evalcompnil +evalcomposefunc +evalcond evalconst evalconstcheck +evalconstfunc +evalconstt +evalcontext +evalcore +evalcoredeepen evalcosh evalcps +evalcr evald +evaldata +evalddb +evaldecs evaldeprewriteseq evaldeprwseq evaldet @@ -23019,6 +38880,7 @@ evalf evalfacprop evalfactorial evalfalse +evalfamily evalfinsetbigop evalfinsetcard evalfinsetdens @@ -23028,11 +38890,17 @@ evalfinseticcnat evalfinsetprod evalfinsetsum evalfintypecard +evalfma evalfn +evalform +evalformula evalfrom evalfun +evalfunargs evalgamma evalgrewriteseq +evalh +evalheap evalheight evalheighttotalweight evalhom @@ -23042,8 +38910,8 @@ evalhorizontalcompaux evalid evalidval evalinduction +evalinf evalinhabit -evalinitial evalinitialbound evalintcast evalintceil @@ -23079,12 +38947,17 @@ evallazyentry evallazyentryaux evalle evallegendresym +evallemma +evalli +evalling evallogheight evallogintcast evallognatcast evallognatlit +evallower evallt evallucaslehmertest +evalm evalmap evalmat evalmax @@ -23147,12 +39020,15 @@ evalnot evalnsmul evalo evalodd +evalof evalofnat evalofscientific evalone +evaloneparamlist evalop evalopcompinlisoid evalopt +evaloracle evalorderhom evalordinaldiv evalordinalle @@ -23163,6 +39039,8 @@ evalordinalnpow evalordinalopow evalordinalsub evalp +evalpatbind +evalpatrel evalpcountermodel evalpnatval evalpos @@ -23179,9 +39057,16 @@ evalprettyaux evalprettymonomial evalprimefactorslist evalprimefactorslistaux +evalprimrec +evalprimrecfunc +evalprimrecparam +evalprojfunc +evalprojfuncind evalprojlogheight evalprojmulheight +evalproof evalprop +evalpurecr evalradical evalratcast evalratden @@ -23200,34 +39085,52 @@ evalround evalrpow evalrpowzero evals +evalset +evalsignextendtrunc evalsinh evalslice evalsmul evalsolution evalsorryifsorry evalsqrt +evalst evalstaralghom evalstate evalstatet evalsto evalstointime +evalstozero +evalstrongrec +evalstrongrechelp +evalstrongrechelpparam +evalstrongrecispr evalsub evalsubfactor +evalsupercore evalt evaltactic evaltacticcapturingtrythis evaltacticseq evalterm +evaltm evaltriangleremovalbound evaltrue evalts evaltsum +evalua +evaluable +evaluablep evaluat +evaluatable evaluate +evaluateat evaluatecombinedcocones evaluatecombinedcones evaluated +evaluateprops evaluates +evaluatesin +evaluatesspace evaluatesto evaluating evaluation @@ -23239,27 +39142,44 @@ evaluationisrightadjoint evaluationjointlyreflectscolimits evaluationjointlyreflectslimits evaluationleftadjoint +evaluationp evaluationrightadjoint evaluations evaluationuncurried +evaluator +evaluators evaluni +evalunop +evalupper evalupperhalfplanecoe evalupperhalfplaneim evalusefiniteinstance evalv evalval evalvars +evalvec +evalw evalwhiskerleft evalwhiskerright evalwhiskerrightaux +evalx +evalz evalzero +evalzeroextendtrunc evalzpow evalzsmul +evans +evap +evaporates evar evariance evariationon -evarray evars +evatom +evatomlist +evatoms +evatomtype +evaulate evcontainsall evcontainsatom evcontainsconj @@ -23271,11 +39191,18 @@ evcp evd eve evecs +<<<<<<< Updated upstream +======= evector +>>>>>>> Stashed changes +evempty even evena evenaltv +evenandodd evenb +evenbin +evencharac evenclosest evenclosestcompatible evenclosestminormax @@ -23287,45 +39214,82 @@ evenclosestuniquep evend evendiv evenelz +evenennn evenequivevenneg evenexp +evenfibs +evenfinex evenfnsuccfnsuccmid evengpoap evengpop evenhom eveni -eveninteger evenkernel +evenkey +evenkeys +evenkeysched evenltle +evenly evenm +evenmore +evenmorecomplicated +evenmoretests evenmult evenmultinv +evenn +evennat evenness evennn +evennnul evennodd eveno evenodd +evenodddisj +evenodddisjlem +evenoddlemma +evenoddnnnul evenoddrec evenoddstrongrec +evenok evenopp +evenorodd evenp +evenparity +evenpathaux evenperm +evenpi evenplus evenplusinv +evenpow evenprm +evenps +evenround evens evensodd evensoddinv evensumeven evensumodd event +eventally +eventcontrol eventd +eventexpr +eventfin +eventhandler +eventhandlerdata eventi +eventless +eventlessl +eventlessr eventoneg +eventp eventprob events eventscaraudiosystem eventsd +eventsi +eventspace +eventtriggerstmt eventu eventua eventual @@ -23342,22 +39306,54 @@ eventuallymeasurableset eventuallymeasurablesingleton eventuallymeasurablespace eventuallymuldivcancel +eventuallyp eventualrange eventualy +eventup eventval evenwodadd evenx eveny evenz +evenziplemma ever +evercrypt +everinstanced +everlongerskinnytrees eversion every +everybelow +everyf everyi everything +everythinginit +everythingverifies everywhere +everywherenone everywherepossubset +evex +evexec +evf +evfn +evg +evgraph +evgraphseq +evgs +evi evidence +evidenced evil +evilshop +evinf +evisc +eviscconfig +evisce +eviscerate +evisceratedp +evisceration +eviscp +evj +evk evl evladdval evlcl @@ -23366,7 +39362,10 @@ evlf evlfcl evlfcllem evlfval +evlist +evlists evlmulval +evlop evlrhm evls evlsaddval @@ -23398,14 +39397,23 @@ evlsvarval evlsvval evlsvvval evlsvvvallem +evlt evlval evlvar evlvarval evlvvval evlvvvallem +evm +evmac +evmakelist +evmeta +evn evnp +evnt +evntp evol evolution +evolve evolveode evp evpm @@ -23418,41 +39426,62 @@ evpn evps evr evs +evsem +evsep +<<<<<<< Updated upstream +======= evsf +evso +>>>>>>> Stashed changes evss evstep +evstrip +evsubgraph evt evta evth evthf evthicc evthiccabs +evthmp evtl evtx evtxdeq evtxdeqlem evtxdp evtxel +evu +evx evzip +ewand +ewd +<<<<<<< Updated upstream +======= ewellorder ewf ewfv +>>>>>>> Stashed changes +ewhileit +ewhilet ewlk ewlkinedg ewlkle ewlkprop ewlksfval ewop +ewopdc +<<<<<<< Updated upstream +======= eword ewordlang ewordprops ewords ewordsem +>>>>>>> Stashed changes ewp -ewrite -ewriteword ews ewxzklaoxekoqqxhncs +ewybjua exa exac exact @@ -23460,42 +39489,64 @@ exactantisymmrelleft exactantisymmrelright exactat exactconts +exactd exactdegrees exactfunctor +exacti exactleoflt +exactlog exactly +exactlyoneholds exactminusinterval exactminusintervalaux exactness +exactp exactpairing exactpairingcongr exactpairingcongrleft exactpairingcongrright exactpairingunit +exactproof exactrefl +exactrp exacts exactsequence exactsequences exactsubsetofssubset +exal exalbial exalim exalimi exalims exalimsi +exall exalt exaltv +exam +examine +examined +examining +examp exampl example +exampleauth +examplefunc +examplemap examples +examplewithoutsplits +examplewithsplits exan exanali +exanaliim exancom exanres exappr exatlen +exb exbase exbaspos exbasprs +exbefore exbi exbid exbidh @@ -23506,10 +39557,19 @@ exbir exbiri exbirivd exbirvd +exbool +exbtwnz +exbtwnzlemex +exbtwnzlemshrink +exbtwnzlemstep exc +excasepairnotsimp +excasepairsimp +excdefinition exce exceed exceeded +exceeding exceeds excenter excenterexists @@ -23518,59 +39578,133 @@ excenterweights excenterweightsunnorm except exceptd +excepte +excepted exceptemoji +excepti exception exceptional exceptionally exceptions exceptionsfile +exceptionsignalled +exceptionstate +exceptiont exceptt excepttoemoji excepttype excess excessive +excesstcount exch +exchang exchange +exchangeable +exchanged +exchangeeta exchangeproperty exchanging +exchg +exchoicefcol +exchsort excise +excised +excision excl +exclaim exclamation exclamdown +exclu exclude excluded excludedmiddle excludes excluding +exclus +exclusi exclusion exclusions +exclusiv exclusive +exclusivecollinear +exclusivefourcases exclusively +exclusivem +exclusivemonitors +exclusivetwocases excom excomim +excomimold excomimw +excomold +excomplexcase +excomplexseq excomw +excp +excps +excpt +exctype +excurve +excvectorbase excxor exd +exdec +exdectrees exdifsn exdistr exdistrf +exdistrfor exdistrv +exds exe exec +execappend +execc +execcproperty execd +execelim execl execlass +execld +execldz execn +execnm +execnmz +execone +execoneproperty execonst +execp +execpost +execproperty +execption +execr execs +execst execstate execstatet +exect +exectree +execu +executa +executab +executability executable +executablei +executablep execute +executea executed +executefetchp +executeinstr executereservednameaction +executes +executestatementensurespublicly +executetransactionensurespublicly +executi +executing execution +executionally +executionfunction executions exehas exeinst @@ -23582,8 +39716,14 @@ exeltr exemplar exemplifies exempt +exensional +exentionality +exepcted exeq +exeqrel +exercice exercise +exercises exereplay exesig exesort @@ -23593,17 +39733,38 @@ exetyp exeu exeupre exeuv +exev +exeval exexbiex exexneq exexw exf exfalso +exfiltration exfinfldd exfo +exformulasof +exfreealg +exfunc +exfuncd +exfuncseq +exfunctor +exfzdc +exg +exgcd exgen +exh +exhadamard +exhash exhaust +exhausted +exhaustibility +exhausting +exhaustion exhaustive +exhaustived exhaustively +exhaustiveness exhausts exhibit exhibiting @@ -23616,6 +39777,9 @@ exidresid exidreslem exidu exieql +exiff +exiftru +exiftruold exii exim eximal @@ -23627,29 +39791,70 @@ eximdv eximi eximii eximp +exincseqofnat exinst +exint exintr exintrbi +exintro exirule exis +exisisting +exisitng exist +existance existbij -existconcfollowfromdefeternal existe +existed +existen +existenc existence +existencemodelp +existencemodels existenceonsmoothmanifolds existential +existentialfirst +existentially +existentials +existentionality +existglobal +existh +existi existing existingattributewarning +existnext +existp +existpath exists existsaddofle existsandeq +existsap +existsb existsbasis +existsbetweenequidistant +existsc existscases +existsclockwiseparallelogramm +existsclockwiseparallelogrammsym +existsclosesuffix existscomprepresentativeiso +existscongruentstricttriangle +existsdef +existsdparallelogramm +existse +existsence +existseq +existsequidistantbetween +existsf +existsfinally +existshalflineequidistant existshomhomcompeqcompaux existsi +existsimp +<<<<<<< Updated upstream +======= existsin +>>>>>>> Stashed changes existsinjective existsinv existsisaddfundamentaldomain @@ -23660,30 +39865,68 @@ existsl existsm existsmaximalsubsetproperty existsmaxmin +existsmiddle existsmulofle existsnat existsnatonedivltmeasure +existsnb +existsne +existsnot +existsnp +existso existsonedivlt +<<<<<<< Updated upstream +======= existsonlybynecessityofownnature +>>>>>>> Stashed changes +existsp existspairne +existsparallelogrammcenter existspivot +existspnp existspp existspullbackadj +existss existsseqtendstoae +existst +existstp existsuniq existsunique +existsv +existsx +existsys existt +existuntill exisym exit +exitblocknonzero +exitblockzero exitcode +exitcond +exiterator +exitexpr exitfailure exiti exitidx exitidxopt +exiting +exitkind +exitname +exitp +exitpc +exitpcs +exitpoin +exitpoint exits +exitsatwhile +exitseq +exitsteps exitsuccess +exitterm +exitv exitwith exl +exleftoperation exlem exlim exlimd @@ -23698,6 +39941,7 @@ exlimexi exlimg exlimi exlimih +exlimihold exlimii exlimiieq exlimiiv @@ -23705,72 +39949,172 @@ exlimim exlimimd exlimimdd exlimiv +exlimivold exlimivv +exlimmp exlimmpbi exlimmpbir exlimmpi exlimvmpi +exlist +exlite +exlpode exlude exmap +exmat exmid +exmidac +exmidaclem +exmidapne exmidd +exmiddc +exmidel +exmidexmid +exmidfodomr +exmidfodomrlemeldju +exmidfodomrlemim +exmidfodomrlemr +exmidfodomrlemralt +exmidfodomrlemreseldju +exmidlem +exmidlema +exmidlemwe +exmidlpo +exmidmotap +exmidmp +exmidn exmidne +exmidomni +exmidomniim +exmidonfin +exmidonfinlem +exmidontri +exmidontriim +exmidontriimlem +exmidpw +exmidpweq +exmidsbth +exmidsbthr +exmidsbthrlem +exmidsssn +exmidsssnc +exmidunben +exmidundif +exmidundifim exmo +exmodc exmoeu exmoeub +exmoeudc +exmonim exn exnal +exnalim exnalimn exnaln +exnc exnel exneq +exnet exnexn +exnorms +exnormspacecase +exns +exnstamp +exnt +exntok +exo exopprim exopxfr exor +exorcize +exoriginal +exornt exotic exp expa +expactation expadd expaddd expadds expaddsub expaddz +expaddzap +expaddzaplem expaddzlem +expan expand +expandable expandan +expandauto expanded +expandedaadsection +expandedaadsectionheaderbody +expander expandexn +expandfraction +expandgba +expandgraph expandhave expanding +expandk +expandkeymaterial +expandkeys expandlemma expandlinearcombo +expandm expandmacroimpl expandmacros expandmatchalt +expandn expandoptdeclsig expandoptlocation +expandr expandral expandrex expandrexn expandrintropats expands +expandsizes expandss +expandsub expandsubterms +expandsuc expandsuppresscompilationnotation +expandtree expanduniss +expansi +expansio expansion expansiond expansioni +expansions +expansiva +expansive +expap +expashft +expazero expb +expbase +expbiased +expbound +expbounds +expbshft +expbzero +expc expcan expcand +expcanlem expchar +expcheck expcl expcld expcli expcllem expclz +expclzap +expclzapd +expclzaplem expclzd expclzlem expcn @@ -23778,44 +40122,93 @@ expcncf expcnfg expcnold expcnv +expcnvap +expcnvre expcom expcomd expcomdg expcomparison +expcut expd +expdata expdcom expdecay +expdeficit expdegree +expdiff expdimp expdioph expdiophlem expdiv +expdivap +expdivapd expdivd expe expec expect expectation +expectationb +expectationd +expectations +expectationzl expected expectedbinders +expectedlength expectedtype expectedtypestx expecting +expectint +expectloosehexstring +expectnonserializableencryptioncontext +expectrawderivetestvector expects +expectserializableencryptioncontext +expecttestvector expectwith +expen +expend expensive expeq expeqidd expequiv +exper +experd experience experienced experiment +experimental +experimentally +experiments +experk +expermutation +expes +expev expeven expevenaltv expevenpos +expf expfac +expfb +expfo +expformal +expfs +expfv +expfz +expfzdr +expfzml +expg +expgac +expgba expgcd +expgd expge expghm +expghmap +expgk +expgm +expgmn +expgn +expgne expgrowth expgrowthi expgrowthinf @@ -23823,7 +40216,11 @@ expgrowthinftophom expgrowthsu expgrowthsup expgrowthsupbothom +expgs +expgsr expgt +expgvn +expgz exph exphom exphomeomorph @@ -23832,15 +40229,34 @@ expia expib expimnt expimpd +expin +expinc +expincf +expineg +expinj +expint +expinv expire +expired +<<<<<<< Updated upstream +expiry +======= +>>>>>>> Stashed changes +expirytime +expirytimeinsecondscanbeconvertedtomilliseconds +expk +expkm +expks expl explain explained explaining explains explanation +explanations exple explecnv +explemma explhs explhsty explicit @@ -23851,23 +40267,46 @@ explicitcokerneldesc explicitcokerneliso explicitdegrees explicitdisjoint +explicitely explicitfilter explicitid +explicitinfo explicitly explicitmeasurearg +explicitmodifies explicitness +explicitnotrigger +explicitp +explicitproof explicits +explies +expliesassociativitym +expliesshortcircuiting explimp expln explode explodecore +exploded +explodes +exploding explog +exploi exploit +exploited +exploits exploration +explore explored exploring explosion +explosions +explosive +<<<<<<< Updated upstream +======= explosivedevice +>>>>>>> Stashed changes +explosiveunion +explp explt expltfac expm @@ -23875,162 +40314,325 @@ expmap expmapb expmapbasis expmeasure +expmg expmhm +expmod expmonoidhom expmordi expmul expmuld expmulnbnd expmulz +expmulzap expn +expnac expnass expnat +expnb expnbnd +expnd expne expnear expneg +expnegap +expnegapd expnegd expnegico expneginvglue expnegz +expnegzap +expni expnilpotent expnlbnd +expnm +expnmn expnngt expnnsval expnnval expnprm +expnrz expns expnsr +expnt +expnts expo expoddaltv +expode +expofvl +expon +expone +exponen exponent exponentexists exponentiablemorphism exponential exponentialcdfreal +exponentiale +exponentiali exponentialideal exponentialidealreflective +exponentially exponentialpdf exponentialpdfreal exponentials exponentiation +exponentj +exponentp exponents +exponentsa exponenttwo expopenpartialhomeomorph +expor exporderiso export +exportarn exported exportedsrc exportedtgt +exporter +exportk +exports +exporttabletopointintimeensurespublicly expos exposant expose exposed exposedpoints exposes +exposing +expovfl expp exppartialhomeomorph expplus +expprodint +expq expr +exprac +exprad +<<<<<<< Updated upstream +======= exprapp +>>>>>>> Stashed changes exprat exprb +exprbeta exprbinoptypeable +exprbn exprchannel +exprchannelset +exprchannelsingle +exprck +exprcommas +exprcompare +exprcore +exprctxalist exprd +exprdec +exprdn +exprdotname +expre exprec +exprecap +exprecapd exprecd exprecon exprelprel exprembeds +exprerror +expresed express expressed expresses +<<<<<<< Updated upstream +======= expresseseternalessentiality expressesinfiniteessentiality +>>>>>>> Stashed changes +expressi +expressibl +expressible +expressiblealternate +expressiblehelp expressing +expressio expression +expressionp expressions +expressionsincompiledmethod +expressionsinghostmethod expressive +expresst expreval exprevall +exprevents +exprfcte +exprfix exprhs exprhsty +expri +expridentifier +exprif +exprimp exprinfo +exprinvocation +exprk +exprl +exprli +exprlis exprlist +exprlistlist +exprliteral +exprm exprmap exprmfct exprmn exprmultimap +exprmz +exprn +exprndinc +exprnn exprnotnone +exprnp exprod +exproj +exprojadd +exprojaddn +exprojdouble +exprojective exprop expropbi expropbilem expropt +exprordefn +exprp +exprpp exprpresenter exprprocessing exprs +exprsd +exprsec +exprsign +exprsize +exprsr exprstate exprstructeq +exprsz +exprszr exprt +exprtlist exprtomatcher exprtosyntax exprtypable +exprtype exprtypinghigh exprtypinglow exprunify +exprval +exprvn +exprx +exprxdymexpx +exprxmexpnx +exprz +exprzac +exprzd +exprzdr +exprzml +exprzmzl +exprzn exps expscl expscllem +expseq expseries +expsexp expsgt +expshft +expshftint +expsize expsne expsp expstx expsub +expsubap +expsubapd expsubd expsval expt +expts expubnd expunitary expunitarypathtoone +expv expval +expvd +expvm +expvs +expvsl +expvsr +expw +expwidth +expx +expy +expz +expzb expzeq expzeta +expzexp exq +exquote +exr exradius +exrealcase +exrealseq +exrealsubseq exrecfn exrecfnlem exrecfnpw +exreg exrot +exrwt exs exsb exsbim +exsbold +exsch exse +exsim exsimpl exsimpr +exsits exsnrex exsphere exss exsslsb +exst exstail exsum ext +exta extaddequivcohomologyclass extagrk +extate extb extbinder extbinderparenthesized +extblocks extblockssrc extblockstgt extcall +extcallnt +extcalls extcategory extcategorymakecat extchart extcharta extchartat extclass +extcomp +extcompat +extcond +extcylinders +extd extderiv extderivfun extderivwithin @@ -24042,8 +40644,14 @@ extdggt extdgid extdgmul extdgval +extdistsuma +extdistsumr +exte +extemely exten extend +extendable +extendablealong extendassoc extendbyone extendbyzero @@ -24056,33 +40664,48 @@ extendcone extendcontain extendcoordcha extendcoordchange +extendcycle extendcyclesiso +extendderivation +extendderivationp extenddomain extenddomainhom +extenddreltermalgebra extended extendedbinder extendedhom +extendedp +extendedprintexpr extendempty extendequiv +extenders +extendexact +extendf extendfalsum extendfan extendfanislimit extendfrom extendfun extendfunctor +extendhi extendhom extendhomologyiso extendhomotopyfunctor extendhomotopyfunctorfactors +extendible extendid extendidealto extending +extendint extendiso extendisoequiv +extendlanguage extendle extendleft extendlevel extendlib +extendlo +extendm extendmap extendmiddle extendnonempty @@ -24094,8 +40717,12 @@ extendofle extendofnorm extendopcyclesiso extendopiso +extendpathtermalgebra extendprop +extendr extendrclike +extendrel +extendreltermalgebra extendrestrictscalarsadj extendringhom extendrule @@ -24115,34 +40742,56 @@ extendscope extendset extendsi extendsingleiso +extendslimit +extendsnn extendsscalars +extendstransitive extendsubtype extendtolocalization extendtosucc extendtosuccobjiso extendtosuccobjsucciso extendtosuccrestrictionleiso +extendtype +extendvalue extendvars extendwith extendxiso extens +extensi extensible +extensibled +extensiblei extension extensional +extensionalequal +extensionali extensionality +extensionalityequiv extensionalityimplicit +extensionalityr +extensionally +extensionalong extensionasringhom +extensioncharacterfinitop +extensioncompilability +extensionconsistentep extensiondocs extensionembedding extensionembeddingofisreal extensionhom +extensioni extensionnalite extensionof extensionofmax extensionofmaxadjoin +extensionp extensionproduct extensions +extensionseq +extensionsub extensiontofun +extensionunique extensionunitleft extensionunitright extensionvaluation @@ -24151,17 +40800,35 @@ extensivecoverage extensively extensivesheaf extensivetopology +extensor extent extentionality extep exteq +extequal +extequalcompose +extequaloneparamlist +extequalprimrec +extequalrefl +extequalsym +extequaltrans +extequalvector +extequalvectorrefl extequivcohomologyclass +exter exterior exterioralgebra exteriorpower extern +externa external +externalcall externalcoveringnumber +externaldiff +externaledges +externalize +externally +externalp externalproduct externalproductbifunctor externalproductbifunctorcurried @@ -24169,44 +40836,92 @@ externalproductcompdiagiso externalproductflip externalproductswap externals +externalstate +externalt +<<<<<<< Updated upstream +======= externalto +>>>>>>> Stashed changes +externaltoint +externidents +externnone +externoppparallelogramm +externparallelogramm externs +externvars +extex +extext extf +extflags +extfmt +extfn +extfreegen extfsim +extfunct extfunctor extfunctorobj +exth exti extid +extincr extinction +extinj +extint +extinverse +extionsionality extiso extj +extm extmapk extmatch extmk extmonad extmonoid extmptsuppeq +extn +extnat +extns extoimad extorder extp +extpro +extprod extq extr extra extraattrs +extrac extract +extractable +extractablee +extractablei extractacc extractapartness extractargs extractcoeff +extractcustomencryptioncontext +extracte extracted extractequality extractfactor +extractfromand +extractfromandleft +extractfromandright +extractfromnonemptyset +extractfromsingleton +extractgbatrans extracting extractinstname extraction +extractit extractmacroscopes +extractmethod extractopennames +extractor +extractors +extractortheorem extractp +extractregister extractrelto extractrewriteeq extractrewritehypeq @@ -24215,6 +40930,7 @@ extractsolution extractstrict extractsymbols extracttacticdata +extracttrans extradec extradegeneracy extradegeneracyaugmentedcechnerve @@ -24225,51 +40941,88 @@ extragoal extragoals extralib extralth +extranatural +extraneous +extrapolate extras +extrasleep +extraspecial +extrat +extratp +extre +extreal +extrem +extrema extremal extremald extremalepi extremali extremally extremallydisconnected +extremalmono extremalnumber extreme extremed +extremelemma extremely extremepoints +extremepredicate +extremepredicatewithoutbody extremes +extremity extremum extremump +extrinsic +extrtrans extru +exts +extseparationlogic +extsgamma extsim extsimulation +extspec +extspecproperties +extsrc extssr extstate extstrcat +extt +exttgt extvfv extvfval extvfvalf extvfvcl extvfvv extvfvvcl +extvisible extvval +extw extwwlkfab extwwlkfabel extype extypei +extz exu -exue -exueu -exui exuniq +exunit +exval +exx exy +exyz eyes +eyfcxpp eyqyb +eyx +eyypqdw +<<<<<<< Updated upstream +======= ezero +>>>>>>> Stashed changes faa faaa faaad faabf +faada faadb faadibruno faae @@ -24292,8 +41045,8 @@ fabexd fabexg fabexgold fabfbdd -fabric fabs +fabsorption fac facavg facb @@ -24303,15 +41056,23 @@ facc faccc faccl faccld +faccreds +faccredsnull +faccredsthrow +faccredsval faccs facd facdiv face +facek +facelistat faceopposite faceoppositecentroid facepairiso facerepresentableby faces +facesassign +facesat facesingletoncompliso facesingletoniso facet @@ -24320,8 +41081,11 @@ facf facfff facgam facial +facilitan +facilitate facility facing +facirc facl faclbnd faclem @@ -24335,27 +41099,52 @@ facp facr facs fact +factabs +factc +factd facte facth +facti +factiter +factiterabs +factiterabscor +factiterrecthm +factiterthm +factk factlecomap factm +factme +factmod +factmode +factmodj +factmodk +factmodp +factmods +factmodsk factmp +factn facto +factoid factor +factoralpositive factored factorednumbers +factorequiv factori factoria factorial factorialbinarysplitting factorialpositive factorials +factorialtraditional factoring factoringcompinclusion +factoringi factorisation factorisationhasallprimefactors factorisationunique factorise +factorisinfactors factorizable factorizat factorization @@ -24365,15 +41154,24 @@ factorizationlcmleft factorizationlcmright factorizationlcright factorizations +factorizationsystem factorize factorized factorizedrational +factorizes +factork +factorl factorltenumber factormultiset factormultisetequiv +factorneg +factornegleft factorpow factorpowsucc +factorr factors +factorscontains +factorscontainsself factorset factorsetmem factorshelper @@ -24388,9 +41186,14 @@ factorthrucoimage factorthruimage factorthruimagesubobject factorthrukernelsubobject +factory +factoryoverlap +factorz facts factsmsg factsumint +factsys +factthm factzeroleone facubnd facwordi @@ -24400,11 +41203,14 @@ fadc fadd faddlem faddmonoidhom +faddobject +faddwithcarry fade fadf +fadjoin +fadjoinp fae faea -faeafe faeba faec faed @@ -24412,6 +41218,7 @@ faeea faeecb faefdcecaff faekzoiqkxsptamktnwdd +faeq faeval faf fafa @@ -24426,45 +41233,84 @@ fafddc fafe faff faffdb +fafkvlr fafv fafvelcdm +fafw +fafx fag +fagabgroup +fagabgroupgrouphom +<<<<<<< Updated upstream +======= fahrenheit +>>>>>>> Stashed changes fai +faig +faigenv +faigs fail +failacq +faildet +faile failed faili +failif failifunchanged failing +failingimapoperations +failingmapoperations failk +failmsgparams +failmsgparamspartialmapcongruency +failmsgparamstotalmapcongruency failprob fails failsafe failt +failunless failure failurecache +failureeof +failuref failurelist +failureparams +failureparamspartialmapcongruency +failureparamstotalmapcongruency failures +failuret +failuretoprovetermination +failwith fair +fairau fairly fairmeas fairness +fairsets faisceaux faith +faithf faithfu faithful faithfully faithfullyflat faithfulness +faithfulp +faithfulr faithfulsm faithfulsmul faithfulvadd fajw +fak fake fakeable fakeanorass +fakefree +fakefreesize fakeimass fakeinunass +fakeloc +fakename fakeoranass fakeuninass fal @@ -24473,10 +41319,14 @@ falantru falbifal falbitru fald +falgebra +falgtype +falign falim falimd falimfal falimtru +falist fall fallback fallfac @@ -24487,6 +41337,7 @@ fallfacfwd fallfacp fallfacval falling +fallou fallrisefac falls falnanfal @@ -24496,30 +41347,66 @@ falnortru falor falorfal falortru +falp fals false falseandduplicateliteralscanberemoved falsearrowequivpunit +falseb +falsebr +falsebranch falsed +falsedef +falsee +falsef +<<<<<<< Updated upstream +======= falsehood +>>>>>>> Stashed changes falsei falseif +falseinbool +falseiseven +falsek +falsel +falseleaf +falsep +falsepost +falsepre +falser falseral falses +falset +falsifiable falsified +falsifier +falsifies falsify +falsifying +falsity falso falsum +falta faltn +faltten falxorfal falxortru fam +fama +famb +fami +famil familiar +familiarity +<<<<<<< Updated upstream +======= familiename +>>>>>>> Stashed changes families familles family familyi +familyintersection familymeasure familyofbfamily familyofelements @@ -24527,57 +41414,150 @@ familyofelementsofsection familyofelementsonobjects familyofgroups familyofmonoids +familyofsetoids +familyp +familyprod +familysequence +familyunion famous -famunion fan +fanadd +fancier +fancy +fancystring +fancysubstring fand +fane +fani +fanin +fanins +fanmorphe +fanmorphn +fanmorphs +fanmorphw +fann +fano +fanodessp +fanoian +fanout +fanoutreached fans fanssubs +fanw +fanx +fany fao faosnf faovcl +fap +fapp fappli +fapplies fapply +faprx +fapx +faq far +farad +farenheit farey fareys farfromtrianglefree +farg fargid +fargn +fargp +fargs fargshiftf fargshiftfo fargshiftfv fargshiftfva farkas +<<<<<<< Updated upstream +farm +======= +>>>>>>> Stashed changes +farray +farrayp +farther fas +fascinating +fash +fashion +fashionable +fashionr +fashoda +fasi fasiwgbofikal +fasl +<<<<<<< Updated upstream +======= fass +>>>>>>> Stashed changes fassoc +fassreds +fassredsnull +fassredsthrow +fassredsval fast faster +fasteval fastfib fastfibaux +fastfood +<<<<<<< Updated upstream +fastforce +======= +>>>>>>> Stashed changes +fastforwardfd +fastg fastgrowing fastisempty fastjacobi fastjacobisym fastjacobisymaux fastlegendresym +fastlookup +fastp fastprod +fastread +fasts fastsubsingleton fastsubsingletonelim fat fatal +fatalerror +fatalp +fatals +fatalsloterror +father +fati fatom +fatoms fatou +fatp +fatsz +fattr +fatugpd fault +faults faux +fauxevva favor +favorite +favorites +<<<<<<< Updated upstream +======= favors +>>>>>>> Stashed changes favour favourable +faw fax faxcd +fay faya +faz fba fbaa fbaaa @@ -24587,8 +41567,11 @@ fbad fbae fbaeb fbaf +fbafb fball +fbar fbas +fbase fbasfip fbasne fbasrn @@ -24602,6 +41585,8 @@ fbbb fbbbbab fbbc fbbcf +fbbd +fbbeb fbbebc fbbf fbc @@ -24614,6 +41599,7 @@ fbccd fbcd fbcdb fbcf +fbcfw fbd fbda fbdaf @@ -24648,11 +41634,23 @@ fbfdf fbff fbfinnfr fbflim +fbi +fbig +fbigl +fbigr +fbigsetu +fbigunion +fbind +fbinds fbinop fbinopelab fbint +fbits +fbl +fbm fbncp fbnnvetfeznoktah +fbody fbool fbot fbound @@ -24671,13 +41669,19 @@ fboundedshiftless fboundedsuc fboundedzerosameexp fboundnext +fboundp fbox +fbr +fbracket +fbranch fbs fbssfi fbssint fbsspw +fbt fbun fbunfip +fbw fbyb fca fcaa @@ -24687,6 +41691,7 @@ fcad fcae fcaef fcafc +fcallee fcanonic fcanonicbound fcanonicfabs @@ -24702,6 +41707,16 @@ fcanonicposfexprlt fcanonicppred fcanonicunique fcard +fcarry +fcat +fcata +fcatac +fcatc +fcatca +fcatks +fcatp +fcats +fcatsk fcb fcba fcbaac @@ -24716,9 +41731,11 @@ fcca fccb fccbcfcede fccbf +fcccoverable fccd fcce fccf +fccoverable fcd fcda fcdb @@ -24731,14 +41748,18 @@ fcdfd fcdmnn fcdmssb fcdmvafv +fcdw fce fceba +fcecb fcecd fced fcee fcef fcefe fcefef +fceiling +fcell fcf fcfb fcfba @@ -24750,12 +41771,19 @@ fcfddbb fcfde fcfe fcfelbas +fcffa fcffd fcfnei fcfneii fcfval +fcfw fcg fch +fchains +fchange +fchanged +fchecks +fchkugt fci fcia fcl @@ -24781,7 +41809,12 @@ fclstopon fclsval fclus fclusf +fcm +fcmcommmonoid +fcmp +fcmpg fcnre +fcntop fcnvgreu fcnvres fco @@ -24795,20 +41828,30 @@ fcoi fcoidinvd fcoinvbr fcoinver +fcol +fcombiner +fcomm fcomp fcompare +fcompile fcompose fcompt fcomptf fcomptss +fcompute +fcond fconf fconfl fconj +fconnect +fcons fconst fconstfv +fconstfvm fconstg fconstmpo fconstmpt +fconstopab fconstructor fcont fcore @@ -24818,17 +41861,38 @@ fcoresfo fcoresfob fcoreslem fcoss +fcount fcovers fcp +fcpi +fcps +fcr +fcrb +fcrbe +fcreate +fcrf fcrgjkjjxforyivso +fcri fcs +fcsr fct +fctd +fcte +fctm +fctn fctop fctr fctrs fcts fctx fctxt +fctz +fcube +fcv +fcvg +fcvgrpdist +fcw +fcycle fczfsuppd fczpsrbag fczsupp @@ -24844,9 +41908,12 @@ fdae fdaee fdafaecf fdaffeec +fdasgn fdata +fdatum fdb fdbad +fdbang fdbc fdbe fdbfe @@ -24864,6 +41931,7 @@ fddacd fddb fddcad fdde +fddest fddf fddfe fde @@ -24874,12 +41942,20 @@ fdec fdeca fdecbc fdecd +fdecl +fdecls fdecs fdedbf fdee fdeea fdef +fdefault +fdefinition +fdel +fdelete fdelrvnpvty +fdelta +fdemodalisation fden fderi fderiv @@ -24894,6 +41970,7 @@ fderivpolarcoordsymm fderivproperties fderivwit fderivwithin +fdet fdf fdfa fdfaa @@ -24904,17 +41981,42 @@ fdfd fdfdcafef fdfe fdff +fdfl +fdi fdia fdiagfn +fdiaibdiai +fdiaibdiaj +fdiaifdiaj +fdiaii +fdiajbdiai +fdiajfdiai +fdiajfdiaj +fdif fdiff +fdifference fdifferential fdifsupp fdifsuppconst fdigit fdigiteq +fdim +fdin +fdir +fdirg +fdirgraph +fdirtyq fdisj +fdisjnt fdisjoint +fdisjointp +fdisjointu +fdisjointux +fdisjointx +fdisjointxu +fdist fdiv +fdivlane fdivmpt fdivmptf fdivmptfv @@ -24930,15 +42032,30 @@ fdmfisuppfi fdmi fdmrn fdo +fdoaprefix fdom fdomne +fdoms +fdomsub +fdot +fdouble +fdout +fdp +fdprobability +fdprobseq fdr fdrep +fdrop fds +fdsp +fdts +fdub +fdv fdvnegge fdvneggt fdvposle fdvposlt +fdw fdxeduwmvzqpcddzaspucgctwzkuspkajwbqt fea feaa @@ -24949,6 +42066,8 @@ fead feadb feaf feafe +feasi +feasibility feasible feat feature @@ -24966,6 +42085,7 @@ febed febf febfdb febfeb +february fec feca fecaadb @@ -24996,13 +42116,13 @@ feecf feed feedback feede -feeding feeeda feef feefed feefee feel feels +feet fef fefa fefafd @@ -25014,26 +42134,47 @@ fefe feff feffb fefff +feistel +fejer +fel felapton feldmfvelcdm +fele +felem +felems +felim +<<<<<<< Updated upstream +======= fellow +>>>>>>> Stashed changes +fem female fempty +fenc fence fences +feneric fenn fennrourke fenum +fenv +fenwick +fep fepair fepi +fepic feq feqmptd feqmptdf +feqp feqresmpt feqresmptf fequal +fequiv +fer ferio ferison +ferma fermat fermatlasttheorem fermatlasttheoremfor @@ -25046,17 +42187,36 @@ fermatlasttheoremwith fermatno fermatnumber fermatpsp +ferment +fermetures fermltl fermltlchr fernique +ferr +ferrers +ferti +fertiliz +fertiliza +fertilization fertilize +fertilizer fesapo +fesm festino festinoalt fet +fetc fetch +fetched +fetches +fetching +fetchinstr feu +feuerbach +feuu +feuv feval +fevalh feven fevend fevenfop @@ -25066,20 +42226,35 @@ fevenorfodd fevenpred fevensuc fevensucprop +fevery +fevu +fevv few fewer +fewh fewnomials +fewv +feww fex fexafv fexd +fexecution fexists fexp fexpe +fext ffa ffaac ffab ffac ffact +ffactd +ffacte +ffactn +ffactnn +ffactns +ffactnsr +ffactss ffad ffadd ffae @@ -25089,6 +42264,7 @@ ffalse ffb ffba ffbac +ffbba ffbbf ffbc ffbd @@ -25118,6 +42294,7 @@ ffdd ffde ffdeede ffdf +ffdhe ffdm ffdmd ffe @@ -25137,8 +42314,20 @@ fffcacc fffe fffeee ffff +fffff fffffb +ffffff +ffffffc +ffffffe fffffff +fffffffff +ffffffffffed +fffffffffff +ffffffffffff +fffffffffffffff +ffffffffffffffffbce +fffffffffffffffffffffffffffffffffffffffffffffffffffffffbfffff +fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffed ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff @@ -25148,12 +42337,43 @@ ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +fffffffffffffffw +ffffffffffffffw +fffffffffffffp +ffffffffffffw +ffffffffffw +ffffffffw +fffffffw +ffffffw +fffffw +ffffixme +ffffw +fffixme ffft +ffg +ffhmc ffi +fficall +ffidiv +ffidiverge +ffifupd ffilter ffin +ffiname +ffinames ffine +ffinsat +ffireturn ffis +ffit +ffittolist +ffiwrite +ffix +ffixe +ffixme +ffloat +ffloor +ffmap ffn ffnafv ffnaov @@ -25161,13 +42381,22 @@ ffnd ffnfv ffnfvf ffnov +ffo ffold +ffoldr +fforall +fform +fformat ffoss +ffound ffp ffpi +ffresh +ffrexp ffrn ffrnb ffrnbd +ffrule ffs ffsrn ffsuppbi @@ -25179,37 +42408,61 @@ ffthoppc ffthoppf ffthres fftt +fful ffun ffunas +ffunc ffunctor ffund +ffune ffunion ffunk +ffunmne +ffunmze +ffunp +ffuns +ffv ffval +ffvars ffvbr ffvelcdm ffvelcdmd ffvelcdmda ffvelcdmi +ffvelrn +ffvelrni ffvresb +ffw ffx ffz ffzeq ffzo ffzoeq fgabs +fgacc fgalgcat fgalgcatskeleton +fgarr +fgarra +fgarray +fgas +fgc fgcfil fgcl fgco fgcontra +fgcy fge fgequiv fget +fgetprop fgf fgfil +fgh +fghe +fgidealin fginv +fgisom fgl fglb fglmod @@ -25221,30 +42474,52 @@ fgmodulecatdual fgmodulecatevaluation fgmodulerepr fgn +fgnmpav +fgoals +fgp fgpk +fgpriso +fgr fgraph +fgraphe fgraphopab fgraphxp fgreu +fgs fgss fgsystem fgt fgtr +fgtrans +fguard fgv fgval +fgx +fhbv +fhead +fhfmkiy +fhg fhisom fhk fhn +fhol fhom +fhordering +fht fiabv +fiat fib +fiba fibas fibci +fibcontr +fibcov fibe fiber fiberbinaryproductequiv fiberbundle fiberbundlecore +fibercong fibered fiberequalizerequiv fiberequiv @@ -25260,13 +42535,21 @@ fiberinclusioncompisoconst fiberisoofbijectiveresiduefield fiberisoquotientstabilizer fiberoverspecresiduefield +fiberpath +fiberpathtofiber +fiberpathtofiberpath fiberperm fiberprebundle fiberprodlex +fiberproduct fiberpullbackequiv fibers +fiberseq +fibertofiber +fibertofiberpath fibertospecresiduefield fibertospecresiduefieldiso +fiberunitiso fiberwi fiberwise fiberwisecolim @@ -25276,9 +42559,20 @@ fiberwisecolimit fiberwisecolimitlimitiso fiberwisecolimitmapcompequivalence fiberwiselinear +fibf +fibid +fibind fibl fiblem +fiblemma fibm +fibmethod +fibmethodwithreads +fibmod +<<<<<<< Updated upstream +fibmonotone +======= +>>>>>>> Stashed changes fibo fibonacci fibp @@ -25287,23 +42581,49 @@ fibrantobject fibrantobjects fibrati fibration +fibrationip fibrations +fibrationstr +fibre fibrec +fibred fibrefunctor +fibreiso +fibreisopres +fibres fibrewise fibs +fibsequence +fibsortof +fibssn fibstr +fibsum +fibtail +fibwithextrapost +fibwithoutpost +fic ficard ficardadju ficardid ficardom +ficardon ficardun ficld fict fictb -fictionaltext fid +fidcen +fidcenum +fidcenumlemim +fidcenumlemr +fidcenumlemrk +fidcenumlemrks +fidceq +fiddle +fiddling fiddly +fidifsnen +fidifsnid fidl fidmfisupp fidomdm @@ -25311,42 +42631,106 @@ fidomncyc fidomndrng fidomndrnglem fidomtri +fidx fie fiel +fielclassname field +fieldaccess +fieldaccessflags fieldandcommring fieldandring fieldargs +fieldauto fieldaxiom +fieldb +fieldc +fieldclassname +fieldclassnamecp fieldcoe +fieldcp +fieldcptype +fieldd +fielddec +fielddecls +fielddecs +fieldendo fieldendoffinitedimensional fieldeq +fieldequiv fieldequivofalgequiv fieldequivofalgequivhom +fieldext +fieldexttype fieldf +fieldfn +fieldhigh +fieldhom +fieldhomo fieldi +fieldinfo +fieldiso fieldle +fieldlist +fieldlow fieldlt fieldmap +fieldmixin +fieldmodes +fieldn +fieldnam fieldname fieldnames fieldnamestail +fieldness fieldofchar fieldofdomain fieldoffinitedimensional fieldofmodelacf fieldofmodelfield fieldofsubtypeismaximal +fieldover +fieldp +fieldpath fieldpats fieldproj +fieldptr fieldrange +fieldreals +fieldref fields fieldsimp +fieldsize +fieldslist +fieldspecific fieldstail +fieldstm +fieldstr +fieldt +fieldtype +fieldtypecp +fientri fieq +fif +fiff fifo +fift fifth +figur figure +figured +figuring +fihashdom +fihashelne +fihashen +fihasheq +fihasheqf +fihashf +fihashfn +fihashgt +fihashneq +fihashss +fihashssdif fii fiidomfld fiin @@ -25358,6 +42742,7 @@ fiinfi fiinfnf fiinopn fiint +fiintim fiiuncl fij fik @@ -25367,12 +42752,19 @@ filconn file filecont fileconteq +fileio fileln filelss filemap +filemapp +filen +filena +filenam filename filenames +fileobj filepath +filerec files filesize filesizecorrect @@ -25380,6 +42772,7 @@ filesizeincreases filestartpos filesubstring filesystem +filesystems filewithoptionadded fileworker filfbas @@ -25392,10 +42785,15 @@ filin filinn filintn fill +fillable filled filler +fillerext +filli filling +fillomino fills +fillt fillvalue filmap filn @@ -25406,19 +42804,26 @@ filss filsspw filssufil filssufilg +filsystype +filsystypei +filsystypep filt filte filter +filterable filteraddhom filteraddmonoidhom filterandsubtypedomain filterappend filterat filterbasis +filterc filtercomap filtercomparisons filterd +filterdiff filterdpair +filtere filtered filteredbetree filteredbetreerefinement @@ -25430,35 +42835,62 @@ filteredcolimitsmodule filteredfinalmodel filteredmodule filteredring +filteredtype filteredunfolds +filtereq +filterf +filtergt +filteri filtering +filterisdistributive filterl filterlim +filterlimi filterlinearmap +filterlt filterm filtermap +filtermapi filtermapm filtermul +filtern filterne +filternew filterof filteroutimplementationdetails +filterp +filterpreservesordering filterproofs filterquery +filterr filterrewrites filters filtersd filterse +filtert filtertests filteruniv +<<<<<<< Updated upstream +filterview +======= +>>>>>>> Stashed changes +filterwithkey +filterwithresult +filti +filtinf filtop filtr filtration +filtratione +filtrationi filtrationofset filtrations +filtv filufint filuni filunibas filunirn +fim fima fimacnv fimacnvdisj @@ -25467,18 +42899,32 @@ fimact fimadmfo fimadmfoalt fimage +fimap fimaproj fimarab fimass fimassd fimax fimaxg +fimaxq fimaxre +fimfun +fimfunb +fimfund +fimfune +fimfuneord +fimfuneqp +fimfunm +fimfunn +fimfunx fimgmcyc fimgmcyclem fimin fiming fiminre +fimite +fimp +fimpl fimplies fin fina @@ -25487,66 +42933,142 @@ finaddequivprod finaddflip final finalallow +finalallowclosure +finalallows finalb +finalbodyproof +finalcdr finaldeny +finaldenyclosure +finaldenys finale finalement +finalffi +finalforms +finalframe +finalgraph finalid finality finalize finalizers +finalk +finalkh +finalkl +finall finally finallysmall +finalm +finalmch +finalmcl +finalmetrics +finalmetricsh +finalmh finalmodel +finalnode finalo +finalp +finalpost +finalregsh finals finalsid +finalst +finalstretch +finalsv +finalt +finaltests +finaltrace +finaltype +finaltypes finalv +finalw +finalwidth +finalwidths finance -financialtransaction financing +financinge finantidiagonal finarrow +finassoc finb finbasis finbasisoffinrankeq finbdddistlat finbiconehom finboolalg +finbouquet +finbouquetlift +finc +finca +fincard fincasesat fincategory fincategoryulift +fincatshape +fincatshapes +fincellapprox +fincellhom +fincellhomrel +fincellmap +finchaincomplexmap +finchaincomplexmapcomp +finchaincomplexmapid +finchainhomotopy +fincharp finchoice finchoiceequiv +fincl fincmp fincomp fincongr fincons +fincontainer +fincontainerspec fincssdom +finct fincut +fincw +fincwexplicit +fincwmap +fincwskel +fincwunit fincycle fincygsubgd fincygsubgodd fincygsubgodexd find findabrcl +findadd +findandstep findany findargs findargtype findasync +findata +findataisofin +findatasumfiniso findati findatindex findatom +findaugmenting +findaugpath findautomaticprojections findautomaticprojectionsaux +findaux findauxdecls +findax +findb findbadunicode findbadunicodeaux findbestorderinstance +findbirthday findcached findcancelfactor findcard +findcategorynames findcdot +findcelebrity +findcert +findchange findcoercionargs findcollision findcomplemma @@ -25561,14 +43083,20 @@ finddeclrevm finddeclsperhead finddefeq finddollarsyntax +finde +findectree +findelem findeq findeqpath finder +finders findes +findex findexecutable findexecutables findexecutablesindirectories findexistsonedivlt +findf findfield findfile findfiles @@ -25583,6 +43111,7 @@ findgreatest findgt findgtaux findgtindex +findi findidx findidxm findidxs @@ -25596,14 +43125,21 @@ findimvectorspaceequiv findindex findindexaux findindexes +findindexmatching +findindexmatchinglocateselem findindices finding +findis +findisg +finditeminrules +findlab findlambdasyntax findle findleaffailures findlean findleaux findlinarithcontradiction +findloc findlocaldeclwithtype findlocaldeclwithtypeq findlt @@ -25611,7 +43147,9 @@ findltaux findm findmatches findmax +findme findmin +findminimum findmodel findmodelfiber findmodelinner @@ -25620,12 +43158,21 @@ findmodels findmodulematches findmoduleof findmonoidnames +findname +findnil +findnode +findnonzero findnonzerorow findnotpowercertificate findnotpowercertificatecore findnth +findom +findomain findoneargs findorempty +findp +findphone +findpivot findpositivevector findprefix findprefixtranslation @@ -25633,14 +43180,23 @@ findprehnf findproj findprojection findprojectionindices +findpt +findptun findq findr +findrange +findrangebindingguard +findrangebindingguardalt +findrangeif findreccl findredundantimports finds findsccs findsccsimp +findsd +findset findsg +findsmatches findsome findsomelocalhyp findsomelocalinstanceof @@ -25655,13 +43211,29 @@ findtheoremconstval findtransitionfailures findtranslation findtranslationname +findtree +findu finductneg finductnegaux finductpos finductposaux +findunl +findunpt +findunr +findw +findwinner findx +findzero findzeroargs fine +fineb +finebareasm +fineconc +fined +finedilmem +finek +finelim +finem finen finencoding finencodingboolbool @@ -25670,6 +43242,7 @@ finencodingnat finencodingnatbool finencodingpair finenum +fineq finequiv finequivpowers finequivroots @@ -25687,38 +43260,86 @@ fineqvpow fineqvr fineqvrep finer +finest +finestpart +finestpartsubset +finestpartunion finesttopology finesttopologysingle finesubfamilyon +finex +finexcept +finexdc finext finextalg finextfldext finexttrb finf +finfamily finfdm +finfield +finfieldtype +finfin finfo finfree +finfs finfu finfull finfun +finfunct +finfunctfun +finfunctgenerator finfunctionfinequiv finfune +finfuneq +finfuni fingaloisgroup fingaloisgroupfunctor fingaloisgroupmap fingcdmap fingch +fingenalginvar +fingenerator +fingeneratorcomm +fingeneratorvanish +<<<<<<< Updated upstream +======= +fingers +>>>>>>> Stashed changes +fingertree +fingertreestruc +fingorb +fingraphordercompind +fingraphorderind +fingraphsizeind +<<<<<<< Updated upstream +fingroup +======= +>>>>>>> Stashed changes +fingroupstr fingrouptype finhrecon fini +finim +finiminit +finind fininf fininfi +fininfs fininit +fininitial fininsepdegree +fininte +fininter +finintersect +finis finish finished +finishes finishing finishingconstructormatcher +finiso +finispropvalued finit finitary finitaryextensive @@ -25726,8 +43347,9 @@ finitaryextensivetopcataux finitarypreextensive finitc finite +finiteabeliangroup +finiteabelianmonoid finiteadelering -finiteafteritskind finitearchimedeanclass finitearchimedeanclassmk finitearchimedeanclassorderhominvlex @@ -25740,14 +43362,18 @@ finiteatfilter finiteatnhds finiteatofsubgraph finitebiproducts +finitec finitecancelmonoid +finitecolimit finitecolimitcocone finitecolimits finitecoproduct finitecoproducts +finitecount finitecovol finitecyclicgro finitecyclicgroup +finited finitedi finitediagram finitediagramarrow @@ -25757,31 +43383,44 @@ finitedimension finitedimensiona finitedimensional finitedimensionalorder +finitedomainimpliesfinite finitee +finiteedges finiteelement finiteexhaustion finiteexts finitefield +finitefinestpart finitefpowerseries finitefree +finitefreshvar +finiteg finitegaloi finitegaloisintermediatefield +finitegame finitegroup finitegrp finitegrpdiagram finiteheight finitei +finiteimage finiteindex finiteindexnormalsubgroup finiteindexnormalsubroup +finiteintegraldomain finiteinter finiteinterclosure finiteintermediatefield finitekonig finitelimitcone finitelimits +finitelistdecompose finitely finitelyatomistic +finitelycocomplete +finitelycomplete +finitelygeneratedpresentation +finitelyrelatedpresentation finitemeasure finitemoments finitemonoid @@ -25789,7 +43428,12 @@ finitemularchimedeanclass finitemultiplicity finiteness finitenormal +finitenp +finitenumberasterm +finiteoperation finiteorderpoints +finitep +finitepairsecondrange finitepi finiteplace finitepow @@ -25797,12 +43441,19 @@ finitepresent finitepresenta finitepresentation finiteproducts +finitepslpath finitequotient finitequotientoffreeofnebot finitequotientoffreeofrankeq finiteresiduefield +finitering finiteringkrulldim finites +finitesequence +<<<<<<< Updated upstream +finiteset +======= +>>>>>>> Stashed changes finitesetinterleavinglist finitespanningsetsin finitespanningsetsincompact @@ -25813,54 +43464,92 @@ finitesubcoproductscocone finitesubcover finitesubproductscocone finitesubproductscone +finitesum finitesupport finitet +finitetransitivity finitetype +finiteunboundedtree finitev +finitevspace finitewidepullbacks finitewitnessedsequentcalculus finitnpc -finity finiunmbl finix finixpnum finj finjective +finjoin finl +finlfun finlifton +finlmodtype finlocfin finlsts finm finmap +finmatrix +finmatrixisovecmatrix finmeas finmeasadditive finmeass finmeassupp +finmeet +finmeetcl +finmem +finmeme +finmempred finminlem finmixin +finmono finmulantidiag finn +finnc finngch finnisoeu finnuc finnum finnzfsuppd finodsubmsubg +finomega +finomni finon finona finoneequiv finonex +finord +finordset finorthonormalbasis finorwe +finp finpairslt +finpairunion finpartition finpartitions finpartord +finpartst +finpartstate +finpath +finpathlemma +finpathpathexists +finpaththm finpifinequiv +finposet finpow +finpred +finprede +finpredtype +finpref +finpres finprod finprodfinequiv +finproduct +finproductiso +finprop finptfin +finpure +finpureisprop finr finra finran @@ -25869,14 +43558,45 @@ finrank finrankquotientmap finranksupport finrec +finrecex +finrecexd finrecon +finrecun +finrecund +finregularity finresfin +finrid +finring +finringtype finrotate finrusgrfusgr fins +finsat +finsatac +finscf finse +finseg +finsegrng +finsemigroupstr finsepdegree finseq +finseqcolim +finseqcolimhomotopy +finseqfam +finseqlen +finseqlevel +finseqm +finseqmin +finseqonetoone +finseqop +finseqs +finseque +finsequen +finsequenc +finsequence +finsequencemap +finsequences +finsequenceset finsert finserti finset @@ -25889,6 +43609,7 @@ finsetcard finsetclopens finsetcoe finsetcongr +finsete finsetequivset finsetfamily finsetgcd @@ -25903,7 +43624,10 @@ finsetintegermultiple finsetioc finsetioi finsetioo +finsetk finsetnonempty +finsetofcard +finsetoids finsetorderisoset finsetprod finsetrange @@ -25916,22 +43640,36 @@ finsetsum finsetsup finsetwalklength finsetwalklengthlt +finsetwithstr +finsetwithstrofcard +finsg +finsigmafields finsigmafinequiv +finskeleton +finsop +finspherebouquetmap +finsplittingfieldfor finsschain finst finstronglymeasurable finsu +finsub +finsubfuncex finsubgraph finsubgraphhom finsubgraphhomfunctor finsubgraphofadj +finsubind finsubmsubg +finsubsequence finsubsetall +finsuc finsuccaboveequiv finsuccaboveorderiso finsuccaboveorderisofinset finsuccequiv finsuccequivlast +finsucmaybeiso finsum finsumequivoffinset finsumfineq @@ -25957,6 +43695,7 @@ finsupplequivdirectsum finsupplequivfreeasmodule finsupplinearcombination finsupport +finsuppp finsupppow finsuppprod finsuppright @@ -25973,18 +43712,31 @@ finsupptocoinvariantstensorfree finsupptota finsupptotal finsuppunique +finsups +finsymgroup fint fintail +fintcell +finte +fintegral finter fintm +fintoelem fintofin fintofun fintonat fintonatbound fintonatlast fintonatweaken +fintopo fintrace +fintree +fintrees +fintrichotomy +fintrnd fintsupport +fintuples +fintuplestype fintwoarrow fintwoarrowequiv fintwoarrowiso @@ -25999,6 +43751,7 @@ fintypebasisindex fintypebind fintypebiunion fintypebot +fintypec fintypecard fintypecat fintypecatascofan @@ -26077,14 +43830,21 @@ fintypeuicc fintypeunion fintypeuniv fintypewalkingparallelpair +finunion finusgraph finv +finvars finvec +finvecisovec finvfvn finvn finvsub finvtrlemn finvtrn +finw +finweak +finweakisofindata +finweaksuc finwo finxp finxpeq @@ -26100,61 +43860,132 @@ fiphp fipjust fiprc fipreima +fiprsshashgt +fips fipwss +fipwssg fipwuni +fiq +fiqact +fiqactl +fir +firable fire fires firest +firewall +firewallworks firewire firing +<<<<<<< Updated upstream +======= firma +>>>>>>> Stashed changes +firms firr firs first +firstassertnotprovedbecauserequiresnotrevealed +firstbn +firstbyte +firstchar +firstcond firstcountable firstcountabletopology +firstcross firstd firstdart firstdeclm +firstdecompose firstdiff firstdiffpos +firstdom +firstfixedpoint firstgamma +firstholds +firsthomcorollary +firsthomtheorem +firstincompletenessa +firstincompletenessb firstindexof firstinfo +firstisotheorem +firstiter +firstkeysforprod +firstl +firstloc firstly firstm firstmap firstmomentennreal firstmomentreal firstn +firstnac +firstnc firstnonimport firstnormalpos firstnormalposnormal +firstnotin +firstnotused +firstns firstobj firstobjeqfamily firstoccurrenceexists +firstofmonth firstorder +firstout +firstp firstpart firstpass +firstpos +firstposappend +firstposappendnonmemberfirstmembersecond +firstposdomainforelements +firstposequal +firstposequalzero +firstposlast +firstposlelength +firstposprefixelement +firstpricep +firstr firstrecursivecall +firstregofarith +firstregoffp firstreturn +firsts firstsecond +firstset +firstsetlist +firstsetml +firstsets firststep firstsym firsttokens firsttomax firsttry +firstturingstate +firstturingsymbol +firstturingtran firsttwo +firsttwobits +firsttwobitsarethree firstunitcoeff +firts fis +fisbth fischer fisdomnn +fiset fish fishb +fishburn fisher +fishers fiskernel fislw fisn +fiso +fisrtn fiss fisseneq fisshasheq @@ -26162,6 +43993,10 @@ fission fissn fissorduni fissuni +fisum +fisumcom +fisumrev +fisumss fisup fisupcl fisupclrnmpt @@ -26169,13 +44004,22 @@ fisupg fisuppfi fisuppov fit +fitch fiter fitop fits +fitset +fitsetr fitting +fittingegen +fittingj +fittings fiub fiubex fiublem +fiubm +fiubnn +fiubz fiufl fiun fiuncmp @@ -26185,38 +44029,67 @@ fiuneneq fiuni fiunicl fiunlem +fiunsnnn fival five +fiveline +fivemovesorless fiveseg +fivesup +fivesuppos fivewheellikefree fix fixabbreviation fixabbreviationaux fixable fixaux +fixb fixbinderinfos fixcnv +fixd +fixdef +fixe fixed fixedby fixedbyfinite +fixedd fixeddetmatrices fixeddetmatrix fixedfield +fixedfieldp +fixedfields fixedfun fixedinrndlist fixedlengthdigits fixedlines +fixedp fixedparams fixedpoint fixedpointfree fixedpoints fixedpointsmulleftcosetsequivquotient fixedpointssubmulofnormal +fixedpoly fixedreduce +fixedset +fixedspace +fixedspacep +fixedspacesp fixedsubmodule +fixedsubtrees +fixedultrafilters fixeduniverse +fixequiv +fixer +fixers fixes +fixex +fixexg fixf +fixfst +fixh +fixhyp +fixid fixin fixinduction fixing @@ -26229,47 +44102,146 @@ fixingsubgroupequivfixingsubgroup fixingsubgroupinsert fixingsubgroupinsertequiv fixingsubmonoid +fixities +fixity +fixk +fixkn +fixl +fixlastcp +fixlastcpok +fixlen +fixlist +fixlistw +fixm fixme +fixnat +fixnonneg +fixnum +fixnump +fixnums fixoint fixp +fixpo fixpoint fixpointi +fixpointlnn +fixpointlnt +fixpointp +fixpointpath fixpointpolynomial fixpoints +fixpointsemantics fixpt fixpts +fixresult fixssdm fixssrn +<<<<<<< Updated upstream +fixstar +======= +>>>>>>> Stashed changes +fixterm fixtow +fixty +fixtype fixufil fixun +fixup +fixups fixvar fixvarfix +fixwidth +fixx +fizw fjgn fji +fjs +fjsp fjv +fker fkg fki fkj +fkmin +fkr fkykov +fla +flab +flabbiness +flabby fladdz flag flagged flagging +flagp flags flagslib +flagsp +flaky +flambdap +flang +flapcl +flast flat +flata +flatb flatcgra +flatcoh flatcombiner +flatd +flatf +flatimp +flatinj +flatinjl +flatinjr +flatlang flatmap flatmapm +flatmodalsemantics +flatmx flatness +flatno +flatnorm +flatop flatp flatpoly +flatprops +flatroster flats +flatsem +flatsemantics flatten +flattenappend +flattenbooleanexpr +flattencall +flattened +flattenedmatch +flattenelim +flattenexpr +flattenexprasboolexpr +flattenexprs +flattenh +flattening +flatteninteract +flattenk +flattenlistw +flattenmain +flattennonempties +flattenp flattenpair +flattenreverse +flattens +flattenseq +flattenstartmarker +flattenstmt +flattoriscv +flattoriscvcommon +flattoriscvdef +flatwithregs +flatwithstrvars +flatwithzvars flavor +flavored flawlessness flb flbi @@ -26288,6 +44260,7 @@ flddivrng flddmn flddrng flddrngd +fldeq fldext fldextchr fldextfld @@ -26305,6 +44278,7 @@ fldextsdrg fldextsralvec fldextsubrg fldexttr +fldf fldgen fldgencl fldgenfld @@ -26321,6 +44295,7 @@ fldgenval fldhmf fldhmsubc fldhmsubcaltv +fldi fldidom fldiv fldivexpfllog @@ -26329,21 +44304,42 @@ fldivmod fldivndvdslt fldivnn fldivp +fldp fldpropd flds fldsdrgfld fldsdrgfldext fldssdrng +fldty fldyetlifvf fle fleaf +<<<<<<< Updated upstream +fleet +======= +>>>>>>> Stashed changes +fleft +flem +flen +flength +fleq fleqceilz +flesh +fleshed +fless +flet flex +flexalst flexible flexiblelinter flexiblemagma +flexlst +flexprod flexray flexrayarch +flextranssum +flextype +flextypes flfcnp flfcntr flfelbas @@ -26352,11 +44348,17 @@ flffval flflp flfnei flfneii +flformat flfssfcf flftg flfval flg +flga +flgb flge +flgi +flgp +flgs flhalf flhalflem fli @@ -26393,14 +44395,24 @@ flimss flimtop flimtopon flimval +flinea +flineb +flinein flip flipalternating +flipcoin flipcompevaluation +flipeq flipequiv flipequivalence flipequivalencecounitiso flipequivalenceunitiso +flipextblockssrc +flipextblockstgt +flipextern flipflipiso +flipfrgnblockssrc +flipfrgnblockstgt flipfunctor flipfunctortointerchange fliphom @@ -26410,6 +44422,9 @@ flipisocurryswapuncurry flipl flipld fliplinear +fliplocal +fliplocblockssrc +fliplocblockstgt flipmultilinear flipmultilinearequiv flipnegatedcomparison @@ -26418,8 +44433,25 @@ flipped flipping flippingequiv flippingiso +flippubblockssrc +flippubblockstgt +flippy +flipr +fliprecordassoc +flips +flipsquare +flipsquareiso +fliptransport flist +flistn +flistnp +flistp flists +flit +fliter +flive +flivein +fliveout flj flk flle @@ -26437,41 +44469,111 @@ flmod flmulnn flnn flo +fload float floatarith floatariths +floatcomp +floatcompare +floatconst +floatconverter floatdec floateq floating +floatm +floatofint +floatofintu +floatoflong +floatoflongu +floatofsingle +floatofwords +floatp +floatpm floatr floats +floatsets +floatsize floatspec +floatt +floatx floc +flocks flodddiv +flog +floo +<<<<<<< Updated upstream +======= flooding +>>>>>>> Stashed changes +flookup floor flooraux +floorc +floorcd +floorck +floorcm +floorcn +floorcpk +floorcpp +floorcx +floordef floordiv floored +floorfractionalpartrelation +flooriscorrect floorlog +floorof floorring floorringtosemiring floorroot floors floorsemiring +flopped +flovermaplist +flovermaptree flow flowchart flowd +flower +flowers +flowing flows +flowseq +flowsto floyd flp flpmodeq +flpr +flqaddz +flqbi +flqcl +flqcld +flqdiv +flqeqceilz +flqge +flqidm +flqidz +flqle +flqleceil +flqlelt +flqlt +flqltnz +flqltp +flqmod +flqmulnn +flqpmodeq +flqword +flqwordi +flqzadd flr +flround fls flsd flsi +flsize flsqrt flsubz +flsz flt fltabcoprm fltabcoprmex @@ -26479,6 +44581,7 @@ fltaccoprm fltbccoprm fltdiv fltdvdsabdvdsc +fltl fltltc fltmul fltne @@ -26490,44 +44593,96 @@ flub fluctuates fluent fluentbit +fluff flush +flushed flv flval +flvnsme +flw flword flwordi +flws flx flxn +fly +flying +flyone +flyrobotarmy +flyrobots +flyspeck flzadd +fma fmachine fmadd +fmagma +fmakunbound +fmalloc +fmalpha fmap +fmapal +fmapcong +fmape fmapet +fmapi +fmapid +fmapie +fmapimage +fmapkeys +fmapmonotonic +fmapo +fmapp +fmaprose +fmapset +fmapseta +fmapsubst +fmaptree fmapu +fmapunsized +fmat +fmatp fmax +fmaxdigit fmaxrep +fmb fmbf +fmc fmcfil +fmcfv +fmcircle fmcncfil fmco fmd fmdiff +fmdip fmdom fmdrop fmeas +fmeasurable +fmelpw fmem fmember +fmemo fmempty +fmeq +fmerge fmf fmfg fmfil fmfilter +fmfinite fmfnfm fmfnfmlem +fmfv +fmi fmid +fmimage fmin +fmindigit fminrep fminsert fminus +fmis fml fmla fmlafv @@ -26538,19 +44693,48 @@ fmlas fmlasssuc fmlasuc fmlasucdisj +fmlfpr +fmlls +fmllsv +fmln fmlookup +fmlspt +fmlstr +fmlt +fmltv +fmlv fmmap fmmerge +fmo +fmod +fmode +fmodel +fmodj +fmodk +fmodkcond +fmodm +fmodp +fmodv +fmodx fmon fmono +fmonotonic +fmont +fmor fmorph fmorphv +fmorphxz +fmostlytrue +fmp +fmpfree +fmpm fmpo fmpoco fmpocos fmpod fmpodg fmpox +fmpred fmpt fmptap fmptapd @@ -26571,10 +44755,14 @@ fmptsnxp fmptssfisupp fmpttd fmptunsnop +fmr fmran fmrel fmrestrict +fms fmset +fmsm +fmsp fmss fmsubset fmt @@ -26593,7 +44781,14 @@ fmtnoprmfac fmtnorec fmtnorn fmtnosqrt +fmtpm fmtpos +fmtree +fmtreerec +fmtrem +fmtw +fmtype +fmu fmucnd fmucndlem fmufil @@ -26603,24 +44798,51 @@ fmulcl fmulclem fmuldfeq fmuldfeqlem +fmulhu fmullem +fmuls fmult +fmultiset fmultradixinv fmupd fmv fmval +fmvala +fmvalj +fmvaljcond +fmvalk +fmvaln +fmvalz fmvars +fmx +fna fnafv fnafvelrn +fnam fname +fnames +fnamev +fnapp fnasrn +fnasrng +fnat fnatdeg +fnb fnbigcup fnbr fnbrafv fnbrafvb fnbrfvb fnbrovb +fnc +fnca +fncal +fncall +fncallexp +fncallexpr +fncallp +fncalls +fnce fnchoice fncld fncnv @@ -26630,7 +44852,10 @@ fnco fncofn fnconstg fncpn +fncross +fncs fnct +fncup fncvm fnd fndifnfp @@ -26647,9 +44872,17 @@ fndmfisuppfi fndmi fndmin fndmu +fndp +fndsome +fndsomep fne fnebas +fneed fneer +fneg +fnegate +fnegn +fnegz fneint fnejoin fnelfp @@ -26657,6 +44890,8 @@ fnelnfp fnemeet fneq fneqeql +fneqghost +fneqthm fneref fnerel fness @@ -26678,10 +44913,15 @@ fnex fnexalt fnexd fnext +fnf fnfco fnfi fnfocofob +fnfrec +fnfreclem fnfuc +fnfullfun +fnfullfunlem fnfun fnfund fnfvelrn @@ -26694,6 +44934,7 @@ fnfvrnss fnfz fnfzo fng +fngsum fnhomeqhomf fni fniinfv @@ -26709,15 +44950,18 @@ fnimatpd fninfp fniniseg fniunfv +fnk fnle fnlimabslt fnlimcnv fnlimf fnlimfv fnlimfvre +fnm fnmap fnmember fnmgp +fnmpl fnmpo fnmpoi fnmpoovd @@ -26729,8 +44973,13 @@ fnmpti fnmptif fnmrc fnmre +fnmv fnn +fnname +fnnames +fnnc fnnfpeq +fnniniseg fno fnoa fnodd @@ -26741,8 +44990,11 @@ fnoddpred fnoddsuc fnode fnoe +fnoei +fnofset fnom fnon +fnone fnop fnopab fnopabco @@ -26752,6 +45004,7 @@ fnopafv fnopafvb fnopfv fnopfvb +fnopovb fnoprab fnoprabg fnormal @@ -26778,8 +45031,17 @@ fnot fnotaovb fnotovb fnov +fnovex +fnovim fnovrn +fnp +fnpair +fnpairabs +fnpairexists +fnpairforall +fnpfx fnpm +fnpprod fnpq fnpr fnprb @@ -26792,6 +45054,9 @@ fnpredsuc fnpredsuceq fnpreimac fnprg +fnpsr +fnpw +fnr fnrel fnrelpredd fnres @@ -26807,10 +45072,12 @@ fnrnafv fnrndomg fnrnfv fnrnov +fns fnse fnseqom +fnset +fnsex fnsingle -fnsingleton fnsn fnsnb fnsnbg @@ -26819,10 +45086,17 @@ fnsnfv fnsng fnsnr fnsnsplit +fnsnsplitdc +fnsnsplitss +fnsp +fnspac +fnspec +fnsr fnssintima fnssres fnssresb fnssresd +fnstack fnsucc fnsucccanonic fnsucceq @@ -26832,30 +45106,45 @@ fnsuccprop fnsucculppos fnsucpred fnsucpredeq +fnsum fnsuppeq fnsuppres +fnsv +fnsym fnt +fntcfn +fnth fntopon fntp fntpb fntpg fntt +fntxp fntype fnubwyyxmlzgabnmewpittjgapdwrqeqresc fnum +fnums fnun fnund fnunirn fnunop fnunres +fnunsn +fnv +fnval fnwe fnwelem +fnx fnxpc fnxpdmdm +fny +fnz foa -foaf foalem +foax +fob fobigcup +fobj focalsubgroup focalsubgroupof focalsubgrouptheorem @@ -26865,14 +45154,28 @@ foco fococnv focofo focofob +focons foconst focus +focused +focuses +fod fodd foddfop foddpred foddsuc +fodel +fodelta fodjrn fodjrnlem +fodju +fodjuf +fodjum +fodjumkv +fodjumkvlemres +fodjuomni +fodjuomnilemdc +fodjuomnilemres fodmrnu fodom fodomacn @@ -26891,136 +45194,280 @@ foelrnf foeq foeqcnvco fof +fofcons fofi fofinf fofn +fofnil fofu fofun +fog +foi foima foimacnv +foint fok +fol fold foldable foldablewithdefaults foldbody foldbodyoption +foldchars +foldcofib foldconsts foldcurrfiledecls +foldd folddeclerrorref folddoc folder +foldexistsp +foldf +foldfmap +foldforallp foldforks +foldfs +foldgen +foldi foldidxm foldimporteddecls foldinfo foldinfom folding +foldingincl +foldingincr foldl +foldleft foldleqfoldr foldli foldlidx foldlidxm +foldlines foldlm foldlmfoldrm +foldln foldlop foldlz foldm foldmap foldmodules +foldn +foldp foldphils foldr +foldrcons +foldrfin foldri foldridx foldridxm +foldright foldrl foldrm foldrop foldrrecon foldrs +foldrwithkey +folds +foldsetd foldstate +foldt foldwithdefaults +folgeaxiome folk +follang +folllowing +follo follow followed follower +followers +followg +followi +followin following +followkeysforprod followpass +followruleeq +followruleml follows +followset +followseteq +followsetmem +followsetml +folm +folmodel +folmodels +folproof +<<<<<<< Updated upstream +======= foltrans +>>>>>>> Stashed changes fom +fomed +fomo +fomod +fomodel fompt +fon fonc fonctions fond +fone fonex +fonil +fonk font fontainetheta fontainethetainvertp fontainethetamodppow fonum foo +fooa +foob foobar +foocaller food foodefinition +fooev +fooevl +foof +fooi fool +foolishly +foolist +foom +foomethod foomonoidhom +fooo +foop +foopoint +foos foot -footballteam footeq +footer footex footexalt footexlem footne +footpr +footprin footprint +foouse foov +foowithresult fop +fopabfv +fopabsn fopp +fopple foprepaux +fops +fopt fopwdom fopxc for fora foral forall +forallap forallb forallboundedtelescope +foralldef foralle +forallh +forallheap +foralli +foralllhsuniquearray +foralllhsuniqueobj foralllteqzero forallm forallmetaboundedtelescope forallmetatelescope forallmetatelescopereducing forallmetatelescopereducinguntildefeq +forallmonotonic +foralln +forallnb +forallne forallnot +forallnp +forallp +forallpnp +forallpostcondition forallpp +forallr foralls +forallshrink +forallsimp +forallsort +forallstmt +forallt foralltelescope foralltelescopereducing +forallty +foralltyleft +forallv +forallvars +forallwithoutbody +forallx forallyonedaissheaf forball +forbid forbidden forbiddencharacters forbiddenimportdirs forbiddennames forbidding +forbids +forc force forced forceheq +forcenum +forcep +forcerel +forcereld +forcereli forces +forcethunk forcetolist +forcibly +forcin forcing +forcingp ford +forder +forderz +fordownend +fordownexec +fordownhalt +fordowntoiteration +fore foreach +foreachc foreachcomposition foreachexpr +foreachoci +foreachstmt +foregoing foreign foreigner +foreigngetrecvfromaddr +foreignident +foreignnone +foreignunknown +<<<<<<< Updated upstream +======= forename +>>>>>>> Stashed changes fores foresf forest +forestinc forever +foreward forge +forged forget forgetadjstar forgetadjtoover @@ -27040,6 +45487,8 @@ forgetenrichmentequivinverse forgetenrichmentoppositeequivalence forgeteval forgetful +forgetfulcommring +forgetfulhom forgetfullyfaithful forgetfunctortocore forgetid @@ -27047,11 +45496,13 @@ forgetimage forgetmapconelimitconeiso forgetmapinitial forgetmapterminal +forgetpresheaf forgetqc forgetranged forgetreflectisos forgets forgetstalk +forgetsyntax forgetting forgettoboolalg forgettoboolalgfaithful @@ -27070,9 +45521,11 @@ forgettosheafedspace forgettosheafmodulecat forgettotop forgettotype +forgive forgot +forgotten +forig fork -forkee forkislimit forkmap forkof @@ -27080,14 +45533,28 @@ forkofiscolimit forkofkernelfork forks forlhs +forloops form +forma formal +formalconcept +formalconcepts +formalcontext formalcoproduct +formaldef +formalisable +formalisation formalise formalised +formalism +formaliz +formaliza formalization formalize formalized +formalizes +formallist +formally formallyetale formallysmooth formallyunr @@ -27096,23 +45563,39 @@ formallyunramified formalmul formalmulti formalmultilinearseries +formals +formalsp +formarmy +formas format formaterror formaterrors +formatmilli +formatmillidiff +formatp +formats formatspec formattable +formatted formatter +forme formed formedness +formedp former formerly +formfunctional forming formisentailed formofsingleliteralvaluation +formp +formpair formperm forms formsi formsubst +formu +formul formula formulaalfa formulabeta @@ -27121,43 +45604,89 @@ formulaentailsclauseremoveentailedliteralopposites formulaentailsliteral formulaentailsvaluation formulafalse +formulalist +formulamonotonicity +formulap +formular formulas formulasd formulasi +formulasofmaxdepth +formulastofuncs formulate formulated formulates +formulating formulation +formulations formulatrue +formule forn fornats +forp +forrangeassignable +forrangeboundsvalid +forrest forschun forschung forside forster +forstmt +fort forth +forthcoming +fortho +forthok +forti +fortoiteration fortunately fortune +forty +fortytwo +forw +forwa +forwar forward +forwardchain forwarded forwardext +forwardfd forwardimp +forwarding forwardmaxdepth forwardorbit +forwardpointer forwards +fos fosc fosetex +<<<<<<< Updated upstream +======= fossilfuel +>>>>>>> Stashed changes +foterm +fotnil fou +foulded foun found +founda foundation -foundationax founde founded +foundedness +foundex foundg +founding +foundp +foundx +foundy +foundz founiiun four +fourch +fourf +fourfix fourfold fourier fourieradd @@ -27197,46 +45726,105 @@ fourierswlem fouriertransform fouriertransformclm fouriertransforminv +fourmore +fourmovestocorrecttwo fourn +fournotinvector +fourpointsintersectionpoint +fourpointssecantline fourpow +fours +fourstepmoveab +fourstepmoveabbareach +fourteen fourth +fourths +fout fov fovcdm fovcdmd fovcdmda fovcl fovcld +foverflow +fovi +fovrn fow +foward fowdom fowffgwlyhylubnvbjsqjzqbkqmminxnnwyv fox +fpa +fpabs fpad +fpadd +fpaf +fpair fpar fparams fparlem +fpath +fpathp +fpb fpc fpcmcbdzxanc +fpcr +fpdiv +fpdom +fpdot +fpequal fperdvper fperiodmul fperiodmullem +fperm fperms +fpev +fpf +fpfma +fpfr +fpfromint +fpfromword +fpfun +fphi fphpd fphpdo +fpi fpid +fpless +fplessequal fplus fply fpm +fpmap fpmd fpmg fpmod +fpmov +fpmovfromreg +fpmovtoreg +fpmul +fpneg +fpo +fpoly fpool +fpops fpos +fposbfneg fposd +fposmin +fposn +fposnat fpost +fposz fpow fpower fpowerseries fpowerseriesbilinear +fpowerset +fpowersetce +fpowersete +fpowerseti +fpowersets fpp fppfprecoverage fppftopology @@ -27247,9 +45835,12 @@ fpprmod fpprnn fpprwppr fpprwpprb +fpq fpqcprecoverage fpqctopology fpr +fprangevalidator +fprangevalidatorcmd fprb fpre fpred @@ -27257,13 +45848,20 @@ fpredcanonic fpreddiff fpredfopfsucc fpredlt +fpredml +fpredmr fpredprop +fpreds fpredsimpl fpredsuc fpredulppos fpredzleeq +fpreg +fpres fprfung fprg +fprime +fprimitives fprlem fprmappr fprod @@ -27271,6 +45869,7 @@ fprodabs fprodadd fprodaddrecnncnv fprodaddrecnncnvlem +fprodap fprodcl fprodclf fprodcllem @@ -27282,7 +45881,10 @@ fprodcnv fprodcom fprodconst fprodcvg +fproddccvg fproddiv +fproddivap +fproddivapf fproddivf fproddvdsd fprodefsum @@ -27301,30 +45903,67 @@ fprodn fprodnn fprodnncl fprodntriv +fprodntrivap fprodp +fprodrec fprodrecl fprodreclf fprodrev fprodrpcl +fprodseq fprodser fprodshft fprodsplit +fprodsplitdc fprodsplitf fprodsplitsn fprodss +fprodssdc fprodsub fprodsubrecnncnv fprodsubrecnncnvlem +fprodunsn fprodxp fprodzcl +fprog +fproofs fprop +fproper +fproperd +fpropere +fproperecard +fpropereneq +fproperi +fproperil +fproperir +fproperiset +fproperty +fproperu +fproperul +fproperur fpropnf fprresex fps +fpscr +fpsem fpset fpslsts fpsmodrel +fpsqrt +fpsr fpsrel +fpsub +fpt +fptable +fptoint +fptonumlist +fptops +fptoword +fptr +fpu +fpulb +fpushout +fpval fpvandoorn fpwfvss fpwipodrs @@ -27339,8 +45978,12 @@ fpxs fqn fqt fqtinfty +fquotep +fqv fra frac +fraca +fracb fracbas fracerl fracf @@ -27349,105 +45992,255 @@ fracge fracle fraclt fracpart +fracq +fracqe +fracqmm +fracqp +fracrnd fract +fractan fracti +fractio fraction fractional +fractionalacc +fractionalheap fractionali fractionalideal fractionalidealbasis fractionalidealla fractionalideallatticebasis fractionaloperation +fractionalpart +fractionalpartiscorrect +fractionasfloor +fractionasone +fractionate fractionfield +fractioni +fractionofmul fractionr fractionri fractionrin fractionring fractions +fractran fractrestrict fracval +fracw +fracwidth +fraen +fraencoun +fraenk +fraenke fraenkel +fraenkela +fraenkelalt +fraenkelcard +fraenkelcomplement +fraenkeldiff +fraenkelf +fraenkelfin +fraenkelfincard +fraenkelfinim +fraenkelinvolution +fraer frag fragile fragment fragments fragmentsl fragmentsls +frags +fraig fraisse +fram frame +framecondition framed +framedereferencenonnull +framedmessage +frameflags framehom framehomclass +frameisassignab +frameisassignable +frameisomorphisms +framelength +framelocals frameminimalaxioms +frameof +frameoutlives +frameoutliveshelper +framep framer frames +framesize +framesp +framestack +frametargetfields frametransmission +framewords framework +framing fran -france frange +<<<<<<< Updated upstream +======= frankfurt +>>>>>>> Stashed changes +frankie frattini frbdd frc +frcard frcl frcond +frcp +frct frd frds fre +frea +fread +freakin freaks +frealizes +frec +frecabcl +frecabex +freccl +freccllem +freceq +frecex +frecexg +frecfcl +frecfcllem +frecfnom +frecfun +frecfzen +frecfzennn +frechashgf +freche frechet frecheturysohnspace frecinnone frecinzero frecr +frecrdg +frecrel frecrelp frecs frecseq +frecsuc +frecsuclem +frectfr +frecuzrdg +frecuzrdgdom +frecuzrdgdomlem +frecuzrdgfun +frecuzrdgfunlem +frecuzrdgg +frecuzrdglem +frecuzrdgrcl +frecuzrdgrclt +frecuzrdgrrn +frecuzrdgsuc +frecuzrdgsuct +frecuzrdgsuctlem +frecuzrdgtcl +frecuzrdgtclt +frecxp +frecxpg +fred fredholm +fredhoppercloud +fredhoppercloudservices free freeabel freeabeliangroup freeabelianmonoid +freeabgroup freeable freeaddgroup freeaddmagma freeaddmonoid +freeaddrinfo freeaddsemigroup freeadj freeadjunction freeadjunctionunit +freealg freealgebra freeasmodulebasis freebicategory freecoequalizer freecofan +freecommonoid freecommring freecommringequivmvpolynomialint freecommringpemptyequivint freecommringpunitequivpolynomialint +freecountableset freed +freedb freedesc freedfinsuppequiv freedom +freee freeeffect +freeeffectd +freeenv +freef +freefin freefinsuppequiv freeforgetadjunction +freeform freefunctor freefunctorcomppullbackiso +freeg +freegen +freegensetnsg +freegensetzao freegrou freegroup freegroupbasis freegroupcongr +freegroupd freegroupequivcoprodi +freegroupfunctor +freegroupgroup +freegroupgroupstr +freegrouphom +freegroupi +freegroupinterface +freegroupisgroup +freegroupismonoid +freegroupissemigroup +freegroupisset freegroupoid freegroupoidfunctor +freegroupon +freegrouppresinv +freegrouppresstr +freegrouptruncidempotent +freegrouptruncidempotentbiinvequiv freegroupunitequivint +freeheapatvariables +freehom freehomequiv +freehompos freei freein +freeindex freeing +freeinmodisinvar +freeinterpreter +freeinv +freeisgen +freek +freeleft +freeletter freelib freeliealgebra freelift @@ -27457,6 +46250,9 @@ freelisteffect freelmod freelock freelocus +freelower +freely +freem freemagma freemagmaassocquotientequiv freemap @@ -27470,17 +46266,37 @@ freemonoid freemonoidal freemonoidalcategory freemonoidcongr +freemsa +freen +freene freeness +freenonces freeobj freeobjdesc +freeoff freeon +freeoper +freeopnsg +freeopseqnsg +freeopseqzao +freeopzao freeord +freeosa +freeoutput +freep +freepizza +freepoint +freepresheaf freeproduct +freept +freeptun +freeptuno freer freerefl freereflmap freereflnattrans freereflrel +freeright freering freeringpemptyequivint freeringpunitequivpolynomialint @@ -27488,10 +46304,71 @@ frees freesection freesemigroup freesimplexquiver +freesin +freesize +freesl +freesort +freesortuniq +freess +freesuc freesumiso +freesyntax freetensoralgebra +freeterm +freetypedpointer +freeu +freeun +freeund +freeunivalgnsg +freeunivalgzao +freeunl +freeunpt +freeunr +freeunv +freeupper +freeval +freevar +freevaraddexists +freevaraddforalls +freevarclosed +freevarclosedlist +freevarcodesyspf +freevarcodesysprf +freevarcodesysprfn freevarfinset +freevarformula +freevarg +freevarinterpformula +freevarinterprel +freevarinterpterm +freevarlistformula +freevarlistformulaapp +freevarlistformulae +freevarlt +freevarmap +freevarnnhelp +freevarplus +freevarprimrecpiformulahelp +freevarprimrecsigmaformulahelp +freevarrept freevars +freevarsdual +freevarsf +freevarsfl +freevarsuballformula +freevarsuballterm +freevarsuballterms +freevarsubformula +freevarsubterm +freevarsubterms +freevarsucc +freevarsys +freevarterm +freevartermapply +freevarterms +freevartimes +freevarzero +freeword freeyo freeyoneda freeyonedacoproduct @@ -27499,17 +46376,39 @@ freeyonedacoproductmk freeyonedacoproductscokernelcofork freeyonedaequiv freeyonedahomequiv +freeze +freezelist +freezer +frefl +freg frege +fregepeirce +<<<<<<< Updated upstream +======= freiheitsstatue +>>>>>>> Stashed changes frel freld +frem fremlin fremove +french +<<<<<<< Updated upstream +======= frenchwine +>>>>>>> Stashed changes +frente +freplace freq +freqs +freqseq +frequa freque frequen +frequenci +frequencies frequency +frequencysizemonotonic frequent frequentl frequently @@ -27520,33 +46419,75 @@ fresf fresfo fresh fresha +freshabs +freshact +freshagain +freshargumenttype +freshbinp +freshblocks freshboundderivative +freshcursor +freshdom +freshe freshen freshenlc +freshensures +fresher +fresherd +freshere +fresheri +freshinfunction +freshinp freshloc +freshman freshmans freshmansdream +freshmax +freshmid +freshn freshname +freshnamegenstate +freshness freshs +freshsrc freshstaratom +freshsubst +fresht +freshtgt +freshun +freshv +freshvar +freshvari +freshvarname +freshvarusage fresin fresison +fresp frespects fressnfv fressupp frestrictle +fresult fresunsn +freudenthal +freudenthalequiv +freudenthaliso frexr freyd freydmitchell frfi frfnom +frfor +frforeq frg frgn frgnblockssrc frgnblockstgt +frgnpub +frgns frgnsrc frgnsrchyp +frgnt frgntgt frgntgthyp frgp @@ -27591,25 +46532,36 @@ frgtgt frgv fri friction +frid friday +frie friend friendgraph friendids +friendly friendlyoperation friendlyoperationclass friendreq friends friendship friendshipgt +friendsofuid friendv +fright +frin frind frinfm +fring fringe +fringemknd +fringes frins frinsg frinxp frirr +frirrg frknkuhzdu +frl frlm frlmbas frlmbasf @@ -27670,12 +46622,16 @@ frmdup frmdval frmin frminex +frml frmls +frmlsr +frms frmuc frmx frmy frn frnd +frne fro frob frobenius @@ -27685,6 +46641,10 @@ frobeniusalghom frobeniusequiv frobeniusfun frobeniusisboundedsmul +frobeniusj +frobeniusjcompl +frobeniusjgroup +frobeniusjker frobeniusmorphism frobeniusnormedaddcommgroup frobeniusnormedalgebra @@ -27692,6 +46652,7 @@ frobeniusnormedring frobeniusnormedspace frobeniusnormsmulclass frobeniusnumber +frobeniusp frobeniuspoly frobeniuspolyaux frobeniuspolyrat @@ -27701,8 +46662,12 @@ frobeniusrotationcoe frobeniusrotationcoeff frobeniusseminormedaddcommgroup frobeniusstrongepimonofactorisation +frobeniusw +frobeniuswcompl +frobeniuswker frobnicate frobrhm +frodo frogs from fromaddcommgroup @@ -27712,21 +46677,36 @@ fromaddgrouptodivisionmonoid fromaddmonoid fromaffine fromaffinerefinement +fromafunctor fromalignment +fromalist fromall +fromandtoanywhere +fromanothersequencetomysequence +fromanothersequencetomysequencewithcasts fromany fromappend +fromarraytomysequence fromarrowarrowfunctor +fromatob +fromatoc +frombifunctor frombinary +frombinstring frombiprod frombits frombl fromblocks fromblockszero frombool +frombyte fromc fromcache +fromch fromchar +fromchars +fromcharstoindices +fromcharstoindicestochars fromchosenterminalequiv fromcircle fromclass @@ -27740,21 +46720,36 @@ fromcommleftinv fromcommutativering fromcommutativesemiring fromcomponents +fromconcrete fromcoset fromcostructuredarrow fromcowriter +fromcube +fromdec +fromdecls +fromdecstring fromdelay fromdescentdatafunctor fromdfinsuppequiv fromdigits fromdirectlimit fromdirectsumequiv +fromdiscrete +fromdual +fromdualn +frome fromedgeset fromend +fromenum +fromenumalt +fromenumfalse +fromenumtrue fromequal fromequivalence fromeuclideanspace fromextendscalars +fromf +fromfiber fromfile fromfilteredfinalmodel fromfin @@ -27767,24 +46762,39 @@ fromfunction fromfunctionfield fromgens fromglued +fromgoal +fromgray +fromhexstring +fromhexstringroundtrip +fromi fromideal fromincl fromindeptoindep +fromindicestochars +fromindicestocharstoindices frominduced frominducedcoremonoidal frominducedmonoidal +frominf frominitialmodel frominj +fromint +fromiso fromiter +fromjust fromkleisli +fromlarge fromleft fromleftderi fromleftderivedzero fromleftinv fromlist +fromlistbyte fromlistischain +fromlistwith fromlocalizedmodu fromlocalizedmodule +fromlocalvariable fromloop fromlrat fromlrataux @@ -27794,36 +46804,62 @@ frommap frommatrix frommatrixlinear frommaybe +frommaybedefault frommeasurablespacestosetsofsets +frommethodcall frommiddle frommiddlehom +frommlnum frommodulecattomodulecatlinearequiv frommodulecattomodulecatlinearequivtomodulecatobj +frommysequencetomysequence +frommysequencetoseq +frommysequencetoseqwithcasts +fromn +fromnat fromnatfnname +fromnatso +fromnatstring +fromnatwithlen +fromnatwo +fromnew fromnext fromnormalization fromnormedspace +fromntimes +fromnum +fromnumset fromofglobalsections fromopcycles fromopcyclesnattrans fromopcyles fromopensubsetsglue +fromopop fromopposite +fromoption fromorthogonalspansingleton fromoverfunctor fromoverfunctorelementsequivalence fromoversubfunctor +fromp frompadicint +frompairs +fromparameter frompath +frompathp frompermutation frompisystemstomeasurables frompisystemstomeasurablespaces frompointwise +frompredicate frompreimage fromprod frompuni frompunit +frompuret fromquotient +fromrat +fromreal fromrealinterval fromrel fromrelated @@ -27833,10 +46869,15 @@ fromrepresentation fromresiduefield fromrestriction fromrightresolution +fromring fromrows froms fromsaturateofhaspullbacks fromsaturatetosaturatehomotopy +fromseq +fromseqtomysequence +fromseqtomysequencewithcasts +fromset fromsetoidendo fromsfunname fromsfunnames @@ -27852,28 +46893,36 @@ fromskeleton fromskeletontoskeletoniso fromsnames fromsome +fromsortedmap fromspec fromspecresiduefield fromspecstalk fromspecstalkofmem fromspectospec fromstalk +fromstate fromstep fromstream +fromstring fromstructuredarrow fromsubtype fromsuffix fromsum +fromt fromtangentbundle fromtangentspace fromtensor +fromterm fromthat fromthinskeleton fromthinskeletoncomptothinskeletoniso fromthis fromtilde +fromto +fromtoid fromtop fromtotalspace +fromtp fromtree fromtype fromtypes @@ -27881,26 +46930,37 @@ fromunit fromunitlift fromunitsofalgebra fromupperhalfplane +fromutf fromvec fromvector fromview fromwitness fromwitnessfalse fromword +fromyes fromzeroringhom fromzetaaut +fron front frontend frontends frontface frontier frontiers +frontm fronts +<<<<<<< Updated upstream +======= frontseat frontsegp +>>>>>>> Stashed changes +froot +froots frop fround frown +froz +frozen frp frpoind frpoins @@ -27914,21 +46974,58 @@ frrrel frrusgrord frs frse +frset frsn frss frsuc frsucmpt frsucmptn +frth +fruit +frun frusgrnn +frustrating +frustt +frustum frv frvlpq frxp +frz +frzl +frzr +frzrw +fsa fsafe +fsatis fsb +fsbig +fsbigd +fsbige +fsbigid +fsbigl +fsbign +fsbigr +fsbigt +fsbigte +fsbigu +fsbimorph fsc +fscale fscgr +fscirc +fsck +fscomp +fscompa +fscompe fscompose +fscons +fscoopsem +fscoresem +fsdmin +fsdmindigit fsecmat +fsedge +fselect fseq fseqdom fseqen @@ -27938,26 +47035,130 @@ fseqlem fseqsupcl fseqsupubi fsequb +fsequiv +fser fset +fseta fsetabsnop +fsetb fsetcdmex +fsetd +fsetddl +fsetddr fsetdec +fsetdelta +fsetdidpl +fsetdiff +fsetdil +fsetdir +fsetdk fsetdmprc +fsetdp +fsetdps +fsetds +fsetdss +fsetdul +fsetdur +fsetdv +fsete fsetex fsetexb fsetfcdm fsetfocdm +fseti +fsetia +fsetiac +fsetiaca +fsetic +fsetica +fsetid +fsetida +fsetidac +fsetidcond +fsetiid +fsetiidpl +fsetiidpr +fsetiil +fsetiir +fsetik +fsetikc +fsetikid +fsetikidc +fsetinter +fsetip +fsetir +fsetis +fsetiss +fsetiul +fsetiur +fsetk +fsetki +fsetkic +fsetkiid +fsetkiidc +fsetku +fsetkuc +fsetkuid +fsetkuidc +fsetm +fsetp fsetprcnex fsetprcnexalt fsets +fsetsd +fsetsi fsetsnf fsetsnfo fsetsniunop fsetsnprcnex fsetsspwxp +fsetsu +fsetsub +fsetsube +fsett +fsettoseq +fsetu +fsetua +fsetuac +fsetuaca +fsetuc +fsetuca +fsetudl +fsetudr +fsetuid +fsetuidpl +fsetuidpr +fsetuil +fsetuir +fsetuk +fsetukc +fsetukid +fsetukidc +fsetulvr +fsetunion +fsetup +fsetus +fsetuss +fsetuul +fsetuur +fsetval +fsffi fsfnn +fsfun +fsfunp fsfv +fsg +fsgaddedges +fsgaddnode +fsgaddnodes +fsgedge +fsgedges +fsgima +fsgincident +fsgraph +fsgsize fsh +fshead fshift fshiftadd fshiftcorrect @@ -27965,13 +47166,27 @@ fshiftcorrectinv fshiftcorrectsym fshiftfdigit fshifto +fsi fsig fsigma fsigmaness +fsigmas fsim +fsinfo +fsinjective +fsinjectiveb +fsinjectivebp +fsinjectivep +fsize +fsk +fsl +fsloc fslope fsltp fsm +fsmax +fsmin +fsmname fsn fsnames fsnd @@ -27979,9 +47194,12 @@ fsneq fsneqrn fsnex fsng +fsnil fsnunf fsnunfv fsnunres +fsou +fsound fsovcnvd fsovcnvfvd fsovcnvlem @@ -27991,51 +47209,84 @@ fsovfd fsovfvd fsovfvfvd fsovrfovd +fspec fsplit fsplitfpar fspoly fsq +fsqkwkk +fsqr fsqrt +fsquare +fsr fsrc fss fssc fssd fssdm fssdmd +fssm fssres fssrescdmd fssresd +fssub fssxp fst +fsta fstab +fstail fstar +fstarlang fstate +fstates +fstatus fstcart fstclm fstd fste fstep +fstepi +fsteq fstequiv fstfunctor +fstg fsthom +fsti +fstidrecordassoc fstidx fstinst fstkernelfork fstl +fstlemma +fstn +fstore fstpad fstpimap fstpimapofislimit +fstpp fsts fstsigmamap fstsigmamapofiscolimit fstsize fstsnd +fstsndi +fsttype fstwrdne fstx +fsty +fstz fstzero fsu fsub fsubbas +fsubcor +fsubd +fsubdset +fsube +fsubeproper +fsubi +fsubiset +fsubk fsubnormal fsubnormalbound fsubnormaldigit @@ -28048,8 +47299,30 @@ fsubnormalnormalltpos fsubnormalunique fsubnormfabs fsubnormfopp +fsubrep fsubset +fsubsetd +fsubsetdl +fsubsetdp fsubseteq +fsubseti +fsubsetiidl +fsubsetiidr +fsubsetil +fsubsetip +fsubsetir +fsubsetp +fsubsetpn +fsubsetu +fsubsetul +fsubsetur +fsubst +fsubt +fsubty +fsubtyping +fsubu +fsubuset +fsubusetp fsuc fsucc fsucccanonic @@ -28071,6 +47344,7 @@ fsuccsubnormnearnormmin fsuccsubnormnotnearnormmin fsucculppos fsucczleeq +fsucexc fsucfsucmid fsucpred fsum @@ -28082,6 +47356,7 @@ fsumclf fsumcllem fsumcn fsumcncf +fsumcncntop fsumcnf fsumcnsrcl fsumcnv @@ -28090,6 +47365,7 @@ fsumconst fsumcube fsumcvg fsumdifsnconst +fsumdivapc fsumdivc fsumdvds fsumdvdscom @@ -28097,9 +47373,13 @@ fsumdvdsdiag fsumdvdsdiaglem fsumdvdsmul fsumdvdsmulold +fsume +fsumee +fsumefin fsumf fsumfldivdiag fsumfldivdiaglem +fsumgcl fsumge fsumharmonic fsumim @@ -28107,10 +47387,12 @@ fsumiun fsumiunle fsumiunss fsumkthpow +fsuml fsumle fsumlesge fsumless fsumlessf +fsumlessfi fsumlt fsumm fsummmodsndifre @@ -28126,6 +47408,7 @@ fsumnncl fsumo fsump fsumparts +fsumr fsumre fsumrecl fsumreclf @@ -28137,6 +47420,7 @@ fsumrpcl fsumser fsumsermpt fsumsers +fsumsersdc fsumshft fsumshftd fsumshftm @@ -28153,6 +47437,7 @@ fsumvma fsumxp fsumzcl fsup +fsupdate fsupdm fsupp fsuppco @@ -28188,23 +47473,46 @@ fsuppxpfi fsur fsurj fsv +fsver fsvlpq +fswap +fswimorph +fswsbimorph fsx fsym fsymm +fsyms +fsymsc +fsymspb fsynzkn +fsys fta +ftacell +ftail +ftake ftalem +ftas ftaylorseries ftaylorserieswithin ftb +ftbl ftc ftcfilter +<<<<<<< Updated upstream +======= ftdown +>>>>>>> Stashed changes +fte fterm +fterms +ftest +ftf ftff ftft +ftfx +ftg ftgt +fth fthcomf fthe fthepi @@ -28222,8 +47530,18 @@ fthres fthsect fthsetcestrc fti +ftker ftlfgicqhyuvaqck +ftlt +ftm +ftn +ftnode fto +ftoc +ftoe +ftofs +ftok +ftol ftop ftor ftorcomp @@ -28236,17 +47554,40 @@ ftoreqinv ftorm ftorradix ftp +ftpd ftpg +ftr +ftrace +ftracep +ftraces +ftracesp ftrancl +ftrans ftree ftrs ftrue +ftruncate +ftry +fts +ftsc +ftsl +ftss +ftt fttf fttt +ftvs fty +ftyfv +ftyfvs +ftyp ftype ftz +fua +fub +fubar fubini +fubx +fuc fucass fucbas fuccat @@ -28261,6 +47602,7 @@ fucid fucidcl fucinv fuciso +fucking fuclid fuco fucoco @@ -28289,45 +47631,99 @@ fucrid fucsect fucterm fucval +fudge +fudges +fue +fueimov fuel fuelf fuelid +fuels +fuf fufjjyjeehpn +fui +fujisawa ful fulfill fulfilled +fulfillment fulfills fulkerson full +fulladdress +fullbodied +<<<<<<< Updated upstream +======= fullbodiedwine +>>>>>>> Stashed changes +fulldes fulldim +fullempty fullestrcsetc +fullfactory +fullfilled fullfo fullfun fullfunc +fullfunex +fullfunexg fullfunfnv fullfunfv +fullgc +fullgenerator +fullgetrue +fullgraph +fullh fulli fullinit +fulll +fulllength +fulllevi fullname +fullnode +fullnointersectp fullnormalize fullnormalizeiso fullnxt fulloppc fulloppf fullp +fullparam +fullpartial +fullpartialorder +fullpos fullprojname fullpropd +fullpseudo +fullpseudoorder +fullpseudosemiringorder +fullr fullres fullresc +fullset fullsetcestrc +fullshare +fullsize fullspec +fullstreamahead +fullsub fullsubc fullsubcategory fullsubcategorycongr +fullsubcategoryex fullsubcategoryinclusionlinear +fullsubcategoryuniq +fullsubfaithful +fullsubfull +fullsystem fulltermc fullthinc +fulltmap +fulltopology +fulltree +fulltreep +fullv +fullx fully fullyapplied fullyfaithful @@ -28374,7 +47770,6 @@ fullyfaithfululiftyoneda fullyfaithfuluncurry fullyfaithfulwhiskeringleft fullyfaithul -fullyformed fullyinvariantsubmodule fulp fulpcomp @@ -28387,6 +47782,7 @@ fulppred fulppredcan fulpsuc fulpsuccan +fumon fun funa funadj @@ -28400,39 +47796,81 @@ funapp funapply funargid funas +funasd funassert +funb +funbind funbindertypes +funbody funbrafv funbrafvb funbreq funbrfv funbrfvb func +funcadd +funcall funcalt +funcan +funcas +funcategory funccat funcco funccollision +funccomp +funccompob +funcd +funcdefuniq funcestrcsetc funcestrcsetclem +funcex +funcexcd +funcexd +funcexofminnat +<<<<<<< Updated upstream +======= funcext funcextlem +>>>>>>> Stashed changes +funcextmult funcf funcfn +funcfraenkel +funcfraenkels +funcfraenkelsl funcg funcglem +<<<<<<< Updated upstream +======= funcgraphprop +>>>>>>> Stashed changes +funchanged +funcharaciso funchomf +funci funcid +funcidxcorrectness +<<<<<<< Updated upstream +======= funcimagesingleton funcinfuncset +>>>>>>> Stashed changes funcinv funciso +funciton +funcitons funcixp funclass +funclatt funclem +funcmeth +funcmoreparams +funcmult +funcname funcnv funcnvadj funcnvcnv +funcnveq funcnvmpt funcnvpr funcnvqp @@ -28445,22 +47883,42 @@ funco funcocnv funcoeqres funcofd +funcompt +funcon funcong funcongrleft +funconsem +funconsemok funconstss +funcop funcoppc funcoressn +funcp funcpre funcpropd +funcptr +funcr funcrcl +funcrecursiveexist +funcrecursiveuniq +funcrecursiveuniqu +funcreg funcres funcringcsetc funcringcsetcaltv funcringcsetclem funcrngcsetc funcrngcsetcalt +funcrule funcs +funcsc +funcschoice +funcsdom funcsect +funcseparation +funcseq +funcseqind +funcsequence funcset funcsetc funcsetcestrc @@ -28468,7 +47926,10 @@ funcsetcestrclem funcsetcres funcseti funcsn +funcsseq +funcst funct +functchoice functermc functermceu functermclem @@ -28478,23 +47939,79 @@ functhinclem functi functio function +functiona functional +functionalchoice functionalextensionality +functionalf +functionalfaf +functionali +functionalinsert functionality +functionalization +functionalize +functionally +<<<<<<< Updated upstream +======= functionalproperty +>>>>>>> Stashed changes functionals +functionalsaf +functionb +functionbelow +functionbymethodtailrecursion functioncompletion functiondata +functiondef +functiondoublequote +functione +functionensures +functionequivaction +functionequivstr +functionextensionality functionfield functionfrechet +functionhandle +functioni +functioninquantifier functioninverse +functionmonotonic +functionnevercalled +functiononfirstequalssecond +functionp +functionparametersarenolocalsmemorylocation +functionpost +functionproperties +functionps +functionrelmatchesequiv +functionrelstr +functionrequires functions functionsboundedatinfty +functionsnorm +functionsp +functionspecification +functionstructure +functionsubsetresult +functionsuitablerel functionswap functiontheorem functiontheoremsext +functiontransportstr +functionunivalentstr +functionvalues +functionwf +functionwfaux +functionwithdefaultparametervalue +functionwithunnamedresult +functionx +functiony +functionz functo functor +functorapplicationdash +functorapplicationfunctorfunctor +functorapplicationinterpretable functorarrows functorcategory functorcategoryclosed @@ -28526,8 +48043,10 @@ functorequivfunctorcompfstiso functorequivfunctorcompsndiso functorequivinversecompwhiskeringleftinliso functorequivinversecompwhiskeringleftinriso +functorex functorext functorextension +functorfacts functorfrom functorfullofmono functorfullyfaithful @@ -28592,17 +48111,20 @@ functorofnattransid functorofnervemap functorop functorp +functorpath functorprodfunctorequiv functorprodfunctorequivcounitiso functorprodfunctorequivunitiso functorprodtoprodfunctor functorprodtoprodfunctorassociator +functorproduct functorpullback functorpushforward functorpushforwardstructure functors functorsinverting functorsoutofwalkingreflexivepair +functorstr functortoaction functortocat functortocontaction @@ -28619,9 +48141,19 @@ functortopresheaves functortopresheavesiso functortorepresentables functortotypes +functr +functrealex +functs +funcunit +funcuseopaque +funcuseordinaryopaque +funcx +funcy +funczero fund -fundam fundamenta +fundamentaci +fundamentacion fundamental fundamentalcone fundamentaldomain @@ -28633,9 +48165,11 @@ fundamentalgroupmulequivofpathconnected fundamentalgroupoid fundamentalgroupoidfunctor fundamentalinterior +fundamentallemma fundamentalse fundamentalsequence fundamentalsequenceprop +fundamentaltheoremofid fundation fundcircuit fundcmpsurbijinj @@ -28646,74 +48180,156 @@ fundcmpsurinjimaid fundcmpsurinjlem fundcmpsurinjpreimafv fundcocircuit +fundecl +fundecllist +fundeclworks fundef +fundefi fundefs +fundefsd fundefsi +fundeps +funderivesop +fundgriso fundif +<<<<<<< Updated upstream +======= funding +>>>>>>> Stashed changes +fundiscr +fundm fundmafv fundmdfat fundmen fundmeng +fundmfi fundmfibi fundmge fundmpss fundom fundsystem +fundthm +fune +funed funeldmb funeldmdif funelss +funem +funempop funen +funeneg +funenege +funenegm +funenegn +funenv +funepos +funepose +funeposm +funeposn +funeposneg funeq funeqd +funeqe funeqi +funeqp +funequiv funequivdegreelt +funerneg +funerpos funeu funex +funexpand funext +funextdep +funextdepequiv +funextension +funextensionpreserveseq +funexthapply +funextinterval +funextiso +funextnondep +funextnondepequiv +funextrefl +funexts funexw funfinfun funfn funfnd funfni funfocofob +funforget funforn +funfreemon +funfun +funfunctor funfv funfvbrb +funfvdm +funfveu +funfvex funfvima funfvop +fungenerate funi +funid funidres funiedgdm funiedgdmge funiedgval +funiedgvalg funimacnv funimaeq funimaex funimaexg +funimaexglem funimage funimass funimassd funimassov +funimplslist funin funinfo +funinsn funinvidassoc funion +funiq +funiseq funisfsupp +funit +funits funiun funiunfv +funiunfvdm +funiunfvdmf funiunfvf +funk +funkynil funleft +funlift funlike funlim funline +funlist +funlista +funm funmap +funmapcong +funmapimage funmo +funmono funmpt +funmptd funmulinvsnorm +funn funna funname +funnotation +funnt +funny funofideal +funofunionofvennregions +funok +funone funonfinite funop funopab @@ -28728,16 +48344,21 @@ funoprab funoprabg funopsn funorigin +funouyh funp funpart funpartfun funpartfv funpartlem funpartss +funpinj +funpos funpow funpower +funppinj funpr funprg +funprgold funprop funpropdecl funpropdeclsext @@ -28745,12 +48366,23 @@ funprophelpstring funpropm funpropname funproptac +funpsplitinj +funpsplitsurj funpsstri +funpsurj +funpti +funptr +funq +funquotientdistributive funray +funrdb +funrec funrel funres funresd funresdfunsn +funresdfunsndc +funresdfunsnss funresfunco funressn funressnbrafv @@ -28760,34 +48392,70 @@ funressneu funressnfv funressnmo funressnvmo +funrneg +funrnege +funrnegm +funrnegn funrnex +funrnfi +funrpos +funrposbneg +funrposdneg +funrpose +funrposm +funrposn funs funsaltv +funscope funset +funsetc +funsex +funsi funsig funsignature +funsinglevalued funsn funsndifnop funsneqopb funsnfsupp funsng +funsngold +funsnsm funspac funspace +funspaceiso +funspacesuspiso funspec +funspecoracle funspecs +funspecsoracle funsplitat +funsprog funss funsseq funssfv +funssnsm funssres funsssuppss funssxp +funstar +funstarop +funstart +funswapid +funt +funtab +funtable +funtion funtofin +funtok funtopon funtp funtpg funtransport +funts funtype +funtypetransp +funu funun fununfun fununi @@ -28795,17 +48463,34 @@ fununiq fununique fununmo fununsn +funv +funvar +funvarbind +funvarbindaux funvtxdm funvtxdmge funvtxval +funvtxvalg +funwandop +funx +funy fup fupd fupdate +<<<<<<< Updated upstream +fupdlast +fupol +======= fupdkey +fupdlast +fupol furniture +>>>>>>> Stashed changes +furstenberg further furthermore furthest +fusc fuse fused fusgr @@ -28824,36 +48509,60 @@ fusgrusgr fusgrvtxdgonume fusgrvtxfi fusion +fuss fut +futer futex +futher +<<<<<<< Updated upstream +futoshiki +======= +>>>>>>> Stashed changes futr +futsigmafields future futures futz fuu +fuv +fuwa +fuww +fuy +fuz +fuzbzgi fuzxrpmcn +fuzz +fuzzy +fuzzylattic +fuzzylattice fva fval fvala fvalcl fvalscale +fvaluat fvan fvar fvarappcase +fvarcons fvardecls fvarid fvarids fvaridset fvaridstosimp fvaridtodecl +fvarlift fvars fvarst fvarusername +fvas fvaw fvawlemn +fvb fvbigcup fvbr fvbwn +fvc fvcl fvclex fvclss @@ -28867,9 +48576,12 @@ fvconstdomi fvconstr fvconstrn fvcosymgeq +fvd fvdiagfn fvdiff fvdifsupp +fvdomfn +fve fveecn fveere fveleq @@ -28881,6 +48593,7 @@ fvelrn fvelrnb fvelrnbf fvelsetpreimafv +fvempty fveq fveqdmss fveqeq @@ -28894,16 +48607,23 @@ fveu fveval fvex fvexd +fvexg fvexi fvf fvffz fvfmla +fvfullfun +fvfullfunlem fvfundmfvn fvg +fvguard fvi +fvid fvidf fvidinvd +fview fvif +fvifdc fvifeq fvilbd fvilbdrp @@ -28919,10 +48639,13 @@ fviss fviunfun fvixp fvkoa +fvl fvlem fvlgjdixly fvline fvmap +fvmbr +fvmeas fvmpocurryd fvmpopr fvmpt @@ -28947,15 +48670,18 @@ fvmptrabdm fvmptrabfv fvmpts fvmptss +fvmptssdm fvmptt fvmptunsn fvn +fvnd fvneq fvnobday fvnonrel fvo fvopab fvopabf +fvopabg fvoption fvovco fvoveq @@ -28966,6 +48692,8 @@ fvprif fvprmselelfz fvprmselgcd fvproj +fvr +fvranfn fvray fvrcllb fvres @@ -28982,11 +48710,18 @@ fvs fvsb fvse fvsetsid +fvsi fvsingle +fvsl fvsn fvsng fvsnun +fvspm +fvss fvssunirn +fvssunirng +fvsu +fvsum fvt fvtp fvtransport @@ -28995,33 +48730,62 @@ fvtresfn fvu fvun fvunsn +fvunsng fvvolicof fvvolioof fvw fvwalt +fvwd fvwrd fvx fvyzuy fwb +fwc fwciijovosxu fwd +fwdbug +fwdbugfunction +fwdcons fwddiff fwddifn fwddifnp fwddifnval fwddifval +fwdround +fwdsrc +fwdtgt +fwdtypedef fweight fweighteq fweightlt fweightzle fwi +fwiden +fwithouttailrecursion +fwitness +fwl fwlink +<<<<<<< Updated upstream +======= +fwork +>>>>>>> Stashed changes +fwp +fwpolicy +fwpolicyconc +fwrite +fwrites +fws fwsc -fwsistercitiesorgpdfsmbabanembabane fwx fwy fxclo +fxe +fxf fxku +fxnn +fxoo +fxor +fxp fxpgaeq fxpgaval fxpsdrg @@ -29030,21 +48794,26 @@ fxpsubg fxpsubm fxpsubrg fxpval +fxr fxs fxv +fxx fxy fxz fya fyo fyqed +fyssvev fysvccpyjqzr fyxiqyxwhsl +fyy fyz fzadd fzaddel fzass fzct fzctr +fzdcel fzdif fzdiffz fzdifsuc @@ -29062,12 +48831,15 @@ fzerop fzf fzfi fzfid +fzfig +fzfigd fzfv fzfz fzgsumd fzgsumdlem fzind fzindd +fziotef fzisfzounsn fzisoeu fzm @@ -29079,20 +48851,24 @@ fznatpl fzne fzneg fzneuz +fznlem fznn fznnfl +fznotfs fznuz fzo fzoaddel fzocatel fzocongeq fzoct +fzodcel fzodif fzodisj fzodisjsn fzoend fzof fzofi +fzofig fzofzim fzofzp fzolb @@ -29136,6 +48912,7 @@ fzoun fzouzdisj fzouzsplit fzoval +fzowrddc fzp fzpr fzpred @@ -29165,11 +48942,13 @@ fzsuc fzto fztp fztpval +fztri fzunt fzuntd fzuntgd fzuuluickfshavlobjctn fzval +fzz gaass gabeqd gabeqis @@ -29183,22 +48962,38 @@ gabss gabssd gac gacan +gacc gacent +gacentc +gacentd gacente +gacentesd gacentidom gacentiim +gacentj +gacentm +gacentq gacents gacentu +gacenty gact gactj gactm +gactp gactr +gacts +gactsi +gactsm +gactsp gactv gactx +gadget gadgets +gae gaf gafo gafold +gag gagliardo gagrp gagrpid @@ -29214,13 +49009,24 @@ galcan galcyclotomicequivunitszmod gale galequivzmod +galg galgeb galgebra galgroupbasis +galgty +galk gallagher gallai +gallery +gallgen gallift galliftequiv +gallina +galm +galnorm +galnormm +galnormv +galnormx galois galoiscategory galoiscoinsertion @@ -29230,6 +49036,7 @@ galoisconnection galoiscorrespondence galoisequivalentdefinitions galoisfield +galoisi galoisinsertio galoisinsertion galoisinsertionintermediatefieldclosedsubgroup @@ -29237,24 +49044,37 @@ galoisinsertionintermediatefieldsubgroup galoisinsertionofissplitepi galoisrep galoisrepaux +galoiss +galp galrestrict galrestricthom +gals galt +galtrace galtvd +galv galxpowequivunitszmod gam +<<<<<<< Updated upstream +======= gamay +>>>>>>> Stashed changes +gamboa gamcl gamcvg game gameadd +gamej +gameoflife games gamf gamfac gamigam +gamm gamma gammaaux gammacdfreal +gammae gammafactor gammaintegral gammameasure @@ -29266,44 +49086,98 @@ gammaset gammasetdivgcdequiv gammasetdivgcdsigmaequiv gammasetequiv +gammax +gammaxb +gammay +gamme +gammma gamne gamp +gample +gan gand gaold gaorb gaorber gap +gapless gapm +gappa +gappend +gapprox +gaprx +gaps +gar +garantizar garbage +garbagecollectseparationlogic +<<<<<<< Updated upstream +======= garfield +>>>>>>> Stashed changes garg gargid gargs +gary gas +gaschutz +<<<<<<< Updated upstream +======= gaseous +>>>>>>> Stashed changes gaset -gasmixture gass +gastab +gastabs +gastabsp gastacl gastacos gasubg gat gate +gatearg +gateargs gateaux +gatebldr +gatecircstr +gatecircuit +gatedelay +gatei +gateinst +gateinstlist +gateinsts +gates +gatescircoutput +gatescircstr +gatescircuit +gatesim +gatesimp +gatestrength +gatetype gateway gatewayreq gatewaysystem gatewaysystemreq +gath gather +gathered +gatheri +gathering +gathermodifies +gathers +gattr gau gauche gauge +gauged gaugerescale gaugerescaleequiv gaugerescalehomeomorph gaugeseminorm gaugeseminormfamily +gaunt gauss +gausse gausseisenstein gaussian gaussianint @@ -29311,31 +49185,54 @@ gaussianity gaussianpdf gaussianpdfreal gaussianreal +gaussinteger gausslemma gaussm gaussnorm +gaussnormcnat +gaussnorme +gaussnormm gausssum gausssumdef gausssumprod gausssumvalues +gausswithpost gave +gaveup +gax gay +gaz gba +gbac +gbackchain +gbag +gbai +gbanodes gbar gbarlr gbas +gbase +gbav gbc gbe gbeeven gbege gbegt gbepos +gbetastar +gbewyfx gbg +gbgi gbi +gbigprod +gbigunion gbinomial +gbisim gbj gblacfnacd gbllouqoaybuyk +gbm +gbn gbo gbody gbogbow @@ -29349,8 +49246,20 @@ gbowge gbowgt gbowodd gbowpos +gbp gbpart +gbr +gbuiltins +gbycpxs +gca +gcaeq gcard +gcarrier +gcat +gcategory +gcb +gcbdb +gcc gcd gcda gcdabs @@ -29369,15 +49278,29 @@ gcdcom gcdcomd gcdcomnni gcdd +gcddecrease gcddiv gcddivides +gcddomain gcddvds gcddvdslcm gcdeq +gcdequal gcdf +gcdgi +gcdgic +gcdgie +gcdgil +gcdgir +gcdgixx gcdi gcdid +gcdidempotent +gcdisgcd +gcdl gcdle +gcdlr +gcdmndc gcdmodi gcdmonoid gcdmonoidofexistsgcd @@ -29389,23 +49312,61 @@ gcdmultipled gcdmultiplei gcdmultiplez gcdn +gcdna +gcdnac +gcdnaca +gcdnc +gcdnca +gcdndl +gcdndr +gcdne gcdneg gcdnegnni +gcdnmdl +gcdnml +gcdnmr gcdnn gcdnncl gcdnncli +gcdnz gcdold +gcdp +gcdpc +gcdpe +gcdpl +gcdpp +gcdpr +gcdr +gcdset gcdsq +gcdsupcl +gcdsupex +gcdsymmetric +gcdthm gcdval gcdw gcdx gcdy gcdz +gcdza +gcdzac +gcdzaca +gcdzc +gcdzca +gcdzdl +gcdzdr gcdzeq +gcdzl +gcdzmdl +gcdzml +gcdzmr +gcdzn +gcdzr +gcdzz gce +gcell gceoinvrminus gcf -gcfunctions gch gchac gchacg @@ -29428,15 +49389,26 @@ gcienat gcigeneratefrom gcimapcomap gciordcard +gckb +gckind +gcl +gclosure gcls gcm +gcmalloc +gcmdecryptopt +gcmencryptopt +gcmut gco +gcode gcoeff gcollapse +gcombine gcombo gcommmonoid gcommsemiring gcomp +gcompl gcon gcongr gcongrdischarger @@ -29447,64 +49419,182 @@ gcongrlemma gcongrlemmas gcongrm gcongrselectionpanel +gcons +gconsd gcont +gcontext +gcopy +gcore gcorec +gcp +<<<<<<< Updated upstream +======= gcproof +>>>>>>> Stashed changes +gcross gcs +gcsg +gcsgamma gcsort +gcstate +gctr gctx gctxt +gctxtcl +gctxtd +gctxtex +gctxti gcwsa +gcy gczxzzwkpljeuxrakxlenvgdriyotbsuzswawtunggvseysusmeiytcbeoyuckwdyjxnurrz +gdc +gdco +gdcol +gdcop +gdcopp +gdcor +gde +gdecode +gdeduction gdelta gdeltaness +gderiv +gdest gdgfybfi gdiff +gdisj gdistribmulaction +gdiv +gdlruzb +gdomain +gdpg +gdpgamma +gdpr +gdrqxlg +gdrqxlgv gds gdt +gdtr gdtverismo +gea gear +geb gebub +gec geck gecxbvyyshct ged +gedec +gee +geedl +geedr +geenric +geez +gef +<<<<<<< Updated upstream +======= geg +>>>>>>> Stashed changes gei +gej +gel gelaki gelb gelfand gelfandstartransform gelfandtransform +gelling +gem +gemcell gemini +gemmem +gemprog +gempty +gemseq +gemstate +gemva +gemval +gemvals +gemvar +gemvars gen gena +genabled +genalg +genalist +genall genan +genarray +genassign +genbase +genbases +genbegin +genblob +genblock +genblocklist +genboolsized +genby +gencase +gencaselist gencbval gencbvex gencl genclear +<<<<<<< Updated upstream +======= genclo +>>>>>>> Stashed changes +gencode +gencolor +gencom +gencomm gencontfract +gencorrect +gencorrectofcorrect +gencorrectofsized +gencp gend +gender +gendl +gendu gene +genealg +geneff geneige geneigenrange geneigenspace +geneirc +genelement +genelementlist +genelements +genelems +genequal +geneqv gener genera general generaladjointfunctortheorem generalbasis +generalcase generalfiltration generali generalisation generalise +generaliseall +generaliseallshift +generaliseconj generalised +generaliseex +generaliseimp +generaliseimpl +generaliserefl generalises +generalisetrans generalising generality generaliz +generalizaci +generalizatio generalization generalizations generalize @@ -29513,6 +49603,7 @@ generalizedbooleanalgebra generalizedcoheytingalgebra generalizedeisenstein generalizedheytingalgebra +generalizei generalizenondeplet generalizes generalizetelescope @@ -29521,99 +49612,309 @@ generalizingmap generallinearequiv generallineargroup generally +generalmaps +generalmonotonic generalschauderbasis generalsecurestate generaltheorem generaltopology generaluniverses +generarted +generat +generatd generate +generatea +generateandwrap +generateandwrapinput +generatebytes +generatebyteswrapper +generatecorrect generated +generatedatakeyensurespublicly +generatedatakeypairensurespublicly +generatedatakeypairwithoutplaintextensurespublicly +generatedatakeywithoutplaintext +generatedatakeywithoutplaintextensurespublicly generatedby generatedfrom +generatedideal +generatedmeasure generatednormal +generatedp generatedsubgroupoid +generateecckeypair +generateecckeypairensurespublicly +generateecdsasignaturekey +generateecdsasignaturekeyensurespublicly generateequivalenceopensle generatefamily generatefrom generatehas +generateinvalidencryptioncontext +generatekey +generatekeypair +generatelargevalidencryptioncontext +<<<<<<< Updated upstream +generatelength +======= +>>>>>>> Stashed changes +generatemacensurespublicly generatemeas generatemeasurable generatemeasurablerec +generatemessageid +generatemockencrypteddatakey +generatenonfinalpolygon generateopen generatepisystem +generatepolygon +generaterandombytes +generaterandombytesensurespublicly +generaterandomensurespublicly +generatersakeypair +generatersakeypairensurespublicly generates generatescript generatesetalgebra generatesets generatesimpsuggestion generatesingleton +generateunserializableencryptioncontext +generateunvisited +generatewf +generati generating generatingattrs generatingm generatingmonomorphisms generatingsections generation +generational generator generatorindex +generatorjson +generatorp generators +generatorsconnected +generatorset generatorsofiscokernelfree +generi generic +generically +genericcallee +genericcaller +genericclass +genericcompare genericdisk +genericfield +genericfloat +genericframe +genericfunction +genericgraph +genericio genericjoin +genericmap +genericmethod +genericmethodwithresult genericmonicpoly genericmonicpolyhasroot +genericnodeset genericpoint genericpoints genericpolymap genericpolymapsurjonofinjon +genericsemantics +generictest +generictester +generr +genesisblock +genetic +genfib +genfin +genfinsuc +genflags +genfloatspecfull +genfloatspecmultirounding genfoosized genfoosizednotation +genfresh genfun +genfuncex +genfunspace +gengc +gengid +gengidg +gengoodcombo gengoodfoo +gengoodmatch +gengoodnarrow +gengoodprec +gengoodrec +gengoodunif +gengraph +genh +genideal +genif +genimp +genind +gening geninjectivity geninv geninvl +genipdm +genipv +geniso +genj +genk +genke genl genlaw genlist +genlistsized genloop +genloopbvec genloopequivofunique genloopgenloopequiv genloophomeoofisempty -genls genltone +genm +genmap +genmixcolumns +genmonotonic +genmonotonicofsized +genmonotonicofsizemonotonic +genmpamcurel +genmsalg +genmx +genmxe +genmxp genn +genname +gennatsized +genno +gennsized +geno +genoc genocp genocpf +genofgensized +genoption +genosalg +genp +genpair +genpairsized genpass +genpassg +genpassl +genpassu genpcd +genpcdl genpcl genpcp genpcpf +genpcuu +genpdf +genpdflem +genpdisj genpdm genpelv +genpelvl +genpelvu +genpelxp +genpi +genplt genpm +genpml genpmlem +genpmu genpn genpnmax genpnnp +genpoly genpprecl +genpprecll +genppreclu +genprndl +genprndu +genprobseq +genprod genpss genpv genr +genrandom +genrbtree +genrbtreemonotonic gens +genset gensi +gensized +gensizedcorrect +gensizedcorrectofsizedcorrect +gensizedmonotonic +gensizedmonotonicofsizemonotonic +gensizedsizemonotonic +gensizedsizemonotonicofsizedmonotonic +gensizedsuchthat gensizedsuchthatcorrect +gensizedsuchthatcorrectoptofsizedsuchthatcorrect +gensizedsuchthateq +gensizedsuchthatmonotonic +gensizedsuchthatmonotonicopt +gensizedsuchthatmonotonicoptofsizemonotonic gensizedsuchthatsizemonoton +gensizedsuchthatsizemonotonic gensizedsuchthatsizemonotonicopt +gensizedsuchthatsizemonotonicoptofsizedmonotonic gensizeofspec +gensort +genst +genstart +genstate genstyp +gensubbytes +gensubcomplex +gensubmodel +gensubterm gensuchthat +gensuchthatcorrect +gensuchthatcorrectoptofsuchthatcorrect +gensuchthatmonotonic +gensuchthatmonotonicofsized +gensuchthatmonotonicopt +gensuchthatmonotonicoptofsized +gensuchthatmonotonicoptofsizemonotonic gensuchthatnot +gensuchthatofbounded +gensum +gensym +gensymbol +gensyms gensys +gent +gentemp +genterm +genthese +gentle +gently +gentree +gentreesized +gentype +gentzen +gentzeneqnatded +gentzensequent +gentzentoarrow +gentzentoarrowext +gentzentoderiv +gentzentonatded genuine +genunivalg +genupdate genus genv +genvar +genvhyp +genviron +genvp genvs genvsb genvsdomeq @@ -29623,19 +49924,20 @@ genweightsp genweightspace genweightspacechain genweightspaceof +genx +geny +genz +genzeta +genzsized geo geodesicarborescence geodesicsubtree -geoff -geographicalsubregions -geographicarea geoihalfsum geoisum geoisumr -geolevel geolim -geolocation geom +geomalg geomcau geome geometr @@ -29652,18 +49954,42 @@ geometricpmf geometricpmfreal geometricpmfrealsum geometry +geomga geomseries geomsum +geomtrap geomulcvg georeclim +<<<<<<< Updated upstream +======= georegion +>>>>>>> Stashed changes +george +georgeinbeatles +geoseq geoser +geoserap geoserg +geosergap +gep geq +geqconst geqf +geqo +geqt +gequiv ger +geral +gere +gerfin +gerfinseq germ +germain +german +<<<<<<< Updated upstream +======= germanwine +>>>>>>> Stashed changes germinjective germsetoid germtofunctionfield @@ -29671,11 +49997,31 @@ germtopullbackstalk gerp gerpmpt gerth +ges +geseq +geseqe +gesucsuc get +getabsolutetime +getabstract +getabstractasparent getact +getactivebranchkey +getactivebranchkeyensurespublicly +getactivebranchkeyitem +getactivecacheid +getactivehierarchicalmaterials +getactivekeyandunwrap getacto getactv getaddends +getaddr +getaddrinfo +getaeskeyring +getalgorithminfo +getalgorithmsuiteforcommitmentpolicy +getalgorithmsuiteinfo +getalias getaliassyntax getallblists getallbvectors @@ -29691,6 +50037,7 @@ getallsimpattrs getallsimpdecls getaltnumfields getantiquotterm +getapoint getappapps getappappsaux getappargs @@ -29701,35 +50048,89 @@ getappuserdatadirectory getarg getargs getarity +getarn +getarray +getarraycla +getarrayclass +getarrayobject +getarraystring getatomval getattributeimpl getattrnames getattrs +getaugpath getaux getauxdefofdeclname getavstore +getax +getb getbackjumplevel getbase getbasis +getbeaconkey +getbeaconkeyensurespublicly +getbeaconkeyitem +getbi getbijectionofforallmemlist getbinarybiproductdata getbinderinfos getbindername getbinders getbiproductdata +getbit +getbits +getblock getblocks getblocksd +getbool getbooloption getbound +getboxcorrectreads +getboxcorrectreadsspecific +getboxdefaultreads +getboxfn +getboxincorrectreads +getboxreadsstar getbracketedbinderids +getbranchkeyid +getbranchkeyidensurespublicly +getbranchkeyversion +getbranchkeyversionensurespublicly +getbyte getc +getcacheentry +getcacheentryensurespublicly +getcacheentryinput +getcacheentryoutput +getcacheentrywithtime getcalcrelation +getcand getcanonicalantiquot +getcanonicalencryptioncontext +getcanonicallinearpairs +getcanonicallinearpairsisbijective +getcell +getcert +getchar +getchild +getchildkeyrings getchildngen getchoices getcl +getclass +getclientensurespublicly +getcmd +getcmdhelp +getcnloc +getcns +getcode getcoefninfo getcolimitcocone +getcommandhelp +getcommandlen +getcommitmentpolicystring +getcommitmentpolicytype +getcompatiblecommitmentpolicy getcompositeofprojections getcompositeofprojectionsaux getconfig @@ -29747,41 +50148,81 @@ getconstinforec getcontents getcontext getcontrlemma +getcoordinates +getcount +getcrat +getcratk +getct +getctwiceplusd +getcur getcurperm +getcurrent getcurrentdirectory getcurrnamespace getd +getdata +getdatawritten +getdbesuite getdecl getdeclmodifiers getdeclname getdeclsbybody getdecltheorems +getdecryptionmaterials getdefaultinstances getdeprecatedinfo getdeprecatedsyntax +getdfunc getdiag +getdiagdiv +getdigest getdirectorycontents +getdirprefix +getdiscoveryfilter getdm getdocstring getdocstringtext +getdoubleint getdsimpargs +getdtasparent gete +getecdhpublickey +getedges +getel getele getelem getelemasfin +getelemdiv getelems getelim +getempty +getemptytuple +getencrypteddatakey +getencrypteddatakeys +getencryptioncontext +getencryptionmaterials +getencryptionmaterialsensurespublicly +getencryptivlength +getencryptkeylength +getencrypttaglength +getentry getenv getenvironment geteqnsfn getequiv getequivofforallcounteqone getequivofforallmemlist +geterrno +geterror +getesdksuite +getexp +getexpectedresult getexplicitlist getexpr getexprinputs getexprmvarassignment getf +getfe getfi getfiberfunctor getfield @@ -29795,12 +50236,16 @@ getfnorigin getfoldarray getforallarity getforallbody +getfp getfresh getfreshapiid getfreshconfid getfreshpaperid getfreshpostid getfreshuserid +getfromcache +getfromcachewithtime +getfun getfunctiondata getfunctorpushforwardstructure getfuninfonargs @@ -29815,16 +50260,25 @@ getfvaridsat getfvaridsnotimplementationdetails getfvarlocaldecl getfvarsnotimplementationdetails +getg getglobalattributesin getglobalrulesets getgmstate getgmusercom getgoallocations getgoals +getgreeting +geth +gethash +gethashcode gethea gethead getheadinfo +gethelp +gethelphelp gethheap +gethierarchicalkeyring +gethierarchicalmaterialsversion gethints gethomedirectory gethygieneinfo @@ -29835,32 +50289,66 @@ getid getids getij getijproperties +getimm getimportcandidates getimportids getimportrewrites getimports +getindex +getindexinsequence getindices getinfostate getinfotrees +getinhabitant getinput +getinputdecryptionmaterials +getinputencryptionmaterials getinputt getinst getinstanceattrkind getinstancepriority +getint +getinterface getintrossize +getintv +getinvsendtrans getirredundantimports +getisbranch getiso +getit +getitem +getitemensurespublicly +getiterator +getivfromprovinfo +getivlength +getivlengthzeros getjointappfns +getkey +getkeydescription +getkeydescriptions +getkeyid +getkeymaterial +getkeypolicyensurespublicly +getkeyrotationstatusensurespublicly +getkeys +getkeystoreinfo +getkeystoreinfoensurespublicly getkind +getkmsclient +getkmskeyring +getlabel getlambdatheorems +getlargerprime getlast getlastassertedliteralcharacterization getlastd getlasti getlastid +getlc getlctx getleft getleftadjoint +getlength getlevel getlevelnames getlevelq @@ -29872,68 +50360,136 @@ getline getlinterglobalattributein getlinteroptions getlintervalue +getlist +getlocal getlocalhyps getlocalinstances getlocalorintro getlocaltheorems +getlocalu +getlock +getlocksr +getlog +getlonghelp +getlonglen getm +getmachine getmaingoal getmainmodule getmaintag getmaintarget getmajoridx +getmanifest +getmany getmanyconfigitems getmanygoals +getmap getmatch +getmatchinbounds +getmatchlongestmatches getmatchloop +getmatchmatches +getmatchrb getmatchwithextra +getmatchworks getmathlibdir getmax getmaxperm getmaxvar getmctx +getmem +getmemtoreg getmemtype +getmemwrite getmessagelog +getmethefunction +getmetrics getmin getmine getmintree +getmk +getmkd getmodulecandidates getmoduleidx getmoduleidxfor getmodulerewrites getmorphismtheorems +getn getname getnameofident getnames getnamesfrom getnat getnatcomparisons +getnatmethod getnats getnatvalue +getneg +getnext getnextindex getnextname +getnextpc +getnextvalue getngen +getnk getnnrealcoes +getno getnondepprophyps +getnonkeyencrypteddatakey +getnulltermstr +getnum getnumargs getnumheadforalls getnumheartbeats getnumparts +getnvs +getobj +getobject +getobjs getobs getobso getobsv getoneip +getop +getopclass getops +getopt getoptional +getoptionalpositivelong +getoptionalsmallobjecttostringstringmap +getoptionalstring getoptions +getor +getordefault getorelse +getotherfactor +getoutput +getp getpackagedir +getpair +getpairs getparam +getparametersforimportensurespublicly +getparent getparts +getpath getpathtobasestructure +getpc getpcompset +getpex +getphonenumber +getplatformlong +getplatformshort +getploc +getpn getpos getposafterimports +getposao +getposgetneg +getpositionals +getpositiveinteger +getpositivelong +getposreq getppall getppanalysisskip getppbinderpredicates @@ -29946,7 +50502,13 @@ getppnumericprojprod getppoption getpptagappfns getprefix +getpreset getprettyprintopt +getprime +getprimi +getprimitiveclass +getprinterdir +getprinterspool getprogname getprojectedexpr getprojectionexprs @@ -29954,109 +50516,233 @@ getprojectionfninfo getprojfn getprojfnforfield getproof +getprop +getpropc getprophyps +getprops getprotocol +getproviderwrappedmaterial +getpubli +getpublickey +getpublickeyensurespublicly +getpublickeyfromprivate +getpublickeyfromprivatekey +getpublickeyfromprivatekeyensurespublicly +getpublickeyhelper +getpublickeyrequest +getpublickeyresponse +getpun getq getr +getrandom +getrandomnat getrange getrangewithtrailing getrawprojections +getrdba +getrdh getreason +getrecipientkeyid +getrecipientkeymaterial +getrecord getreducibilitystatus getref +getreg +getreginits +getregion +getregister +getregs +getregwrite getrel getrelevantarg +getreproducedencryptioncontext +getrequiredencryptioncontextkeys getres getresetinfotrees +getresourcepolicyensurespublicly +getresrvedecmap +getretexp +getreturnfromexception getrevarg +getreviewindex +getrevrole getrewriteinterfaces getright getrightadjoint getroot +getroots +getrsakeymoduluslength +getrsakeymoduluslengthensurespublicly +getrsakeyring +getruefull gets getscopes +getse getsearchpath getsec +getsecv +getseed +getsenderkeyid +getsenderkeymaterial getsepargs getsetoptionmaxheartbeatscomment +getshort +getshorthelp getsimpargs getsimpcongrtheorems getsimpcontext getsimpextension getsimprocs getsimptheorems +getsizeread +getsizewritten +getsockaddr +getsocketfamily +getsockport getsomes getsorrydep getsortedstackprojectdeclnames getsortedstackprojecttags +getsou +getsources getsplitcandidates +getsq getsrcsearchpath +getst +getstack getstackentries getstackstag getstained getstate +getstatelet getstatic +getstc +getstce +getste getsteptype +getstk +getstl +getstle +getstp +getstpe +getstring getstruct getstructurefields getstructurefieldsflattened getstructureinfo +getsub getsubexpressionmatches +getsubofclass getsubproblem getsubstring +getsuite +getsumauto +getsun getsupport +getsym getsymboliclinktarget getsyntaxnodekinds getsyntheticmvardecl +gett gettableau gettableauimp +gettablename gettactics gettag +gettaglength gettailinfo gettailpos +gettdba +gettdh gettemporarydirectory getter +getterm +getters +gettestmaterials gettfaelist gettheoremfromconst gettheorems gettheoremsforfunction +getthm +getthread getthreadc +getthreadcc +getthreadcode getthreadr +getthreadsr gettime getting +gettmr +gettms gettokentable +gettrace gettrailing gettransitiontheorems gettransparency gettree gettreesupport gettrustedinput +gettvars gettyp gettype +gettypedpointer +gettypeop +gettys getunassignedgoalmvardependencies getunique getunlintedranges getunsolvedgoals +getuntrustedinput getunusedforallinstancebinderidxswhere getunusedname +getuseimm getuserdocumentsdirectory getusername getusingarg getv +getval +getvalidgranttokens +getvalidmap +getvalidmapcmd getvalue getvalues +getvar getvariableindices getvarstoclear +getvec +getversionbranchkeyitem +getversioncacheid +getversiontests getvert getvertequiv getvisited +getvoid getvstore getwatch getwatchlist +getwilldecreasesize getwithargs getword +getwords +getwork +getwrappeddetectzero +getx +getxaddrs getxdgdirectory getxdgdirectorylist +getxint +getxnat +getxx +gety +getyes +geutt +geuttg +geuttge +geuttgen +gev +geva +geval +gevalfn gex gexcl gexdvds @@ -30068,31 +50754,71 @@ gexlem gexnnod gexod gexp +gexport +gexprs gexval +gez +gfa +gfacir +gfacirc +gfact +gfchar gfcomp gfcomps gfcont +gfd +gfe gff +gfg gfgroup gfgroupset gfhereditary gfi +gfid +gfield +gfilter +gfin gfind gfiso +gfisog +gfisom +gfix +gfl +gflg +gfml gfmod +gfn +gfnname +gfnorm +gfnormal +gfnorms gfold gfoldl +gfoldr +gforestinc +gform gfp gfpapprox +gfpf gfq gfr +gframe gfre gfs +gfsa +gfsb +gfst gfsub gfun gfunc +gfuncs gfunctor +gfunctori +gfunctors gfv +gfvl +gga +ggc ggdebkalepaebexxzbedaeu ggen ggg @@ -30100,13 +50826,25 @@ gggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggg ggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggg gggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggg gggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggg +ggl +ggoal ggreater +ggrlkhp ggs +ggsi +ggx +ggzwyrm +ghalf +ghalfa ghas +ghash ghc ghcb +ghd ghdist +ghe ghg +ghi ghm ghmabl ghmac @@ -30116,6 +50854,7 @@ ghmco ghmcyg ghmeqker ghmeql +ghmex ghmf ghmfghm ghmghmrn @@ -30141,19 +50880,68 @@ ghmqusnsglem ghmrn ghmsub ghole +gholes +ghom ghomco ghomdiv ghomf ghomidold ghomlinold +ghoms ghost +ghostbox ghostcomponent ghostcomponentmodppow +ghostconsts +ghostcontexts +ghostcontinueassertby +ghostcontinuelabels +ghostcontinuelevels +<<<<<<< Updated upstream +ghostcounter +======= +>>>>>>> Stashed changes +ghostdivergentloop +ghosteffectlessarrowwitness ghostequiv +ghostf +ghostforall +ghostforloop +ghostframe ghostfun +ghostfunction +ghostfunctioncaller +ghostif +ghostinit +ghostloop +ghostm +ghostmain ghostmap +ghostmethodcaller +ghostmethodwithmodifies +ghostmultiparams +ghostnew +ghostp +ghostpasstoghost +ghostpredicate +ghostpredicatetests +ghosts +<<<<<<< Updated upstream +ghostsequence +======= +>>>>>>> Stashed changes +ghostsingleton +ghostsusedincompiledcontexts +ghosttermination +ghostthings +ghosttupletest +ghosttypes +ghostused +ghostvar +ghostvariable +ghoulomb +ghr ghspace -ghx giaux gibbard gicabl @@ -30171,9 +50959,21 @@ gictr gid gidsn gidval +gidx +gie gierz +gif +gifi +gified +gify +gig +gigdsoa gigenerate gigeneratefrom +gigo +giim +gij +gilbreath gilowerclosurecoe gim gimapcomap @@ -30182,32 +50982,67 @@ gimco gimf gimfn gimghm +gimmie +gimmieachar +gimmief +gimmiemore +gimmieone +gimmieseven gin +ginc +gindex +ginguap +ginhabited +ginit ginitial +ginitiality ginj gint +ginter +gintern ginv ginzburg girard +gire girestrict girth +girthi giry gis gisaturation giscokernel +giso +gist git +gitbag github +gitlab +gitset +gittit giulio giunbotdbot giupperclosurecoe +giv givant give given +giveoption gives +giveup giving gjhrmswhmiuxrvmwovbcvftqqcvvztegonvyaiajftwsrakqtiosthpyxdmlc +gjwyyps +gkeys +gki +gkr gkrzmdulbkimxyvpwedpv gla +glaei +glam +glance +glarger +glaxiom +glaxioms glb glbcl glbconn @@ -30219,42 +51054,121 @@ glbeu glbfun glbfval glbi +glbl glble glbpr glbprdm glbprlem glbprop glbsscl +glbuffer glbval +glc +glci +glcp +gleaf gleason glem +glemi +glen +glet glggfufacvzlgldjlvpwisbszm +glib glibc +glift +glimp +glist glit glitofc glitofl +glive +<<<<<<< Updated upstream +glivenko +======= +>>>>>>> Stashed changes +gliveout +gll +glmc +glmx +glneq +gloablly glob +globa global +globala +globaladdr globalattributein globalattributeinlinter +globalbaseinv globalbranchingpreprocessor globalconformality globald +globaldec +globaldecnt globalenv +globalenvs globalequiv globalequivaux +globalfun +globalfunction +globalinv +globalise globalize globally +globallyi +globallyl +globallyr +globallytruncate globalpreprocessor globalpreprocessortoglobalbranchingpreprocessor globals +globalsecondaryindexautoscalingupdatelist globalsection globalsectionsiso +globalsequenceinv +globalsl +globalsptr +globalstate +globaltableglobalsecondaryindexsettingsupdatelist globalthms +globaltype +globalupdate +globalvar +globalvaralloc +globalvarinit +globalvarlookup +globalword +globdef +globdefs +globe +globeeq +globeequiv +globextcomp +globfield +globl +globop +globreal +globs +globular +globularobject +globularset +globvar +globvars glocksetcode glocksetres +glog +glop glpos +glproves +glr +glrepr gls +gltvhum +glu +glua +glub +gluc +glud glue glued gluedata @@ -30276,36 +51190,73 @@ gluedlift gluedliftpullbackmap gluedscheme gluedto +gluei +glueing +glueinvnu gluemetricapprox gluemorphisms gluemorphismsoflocallydirected gluemorphismsoveroflocallydirected +glueo +gluepath +gluepathext gluepremetric +gluept gluer glues gluespace +gluetriangles gluing +glv +glval +gma +gmagma gmap gmapall +gmapcong +gmapid +gmapimage +gmapo gmax +gmbeta gmcont gmctxt +gmctxtex gmd gmean gmeas +gmem +gmemo +gmethod gmft +gmftr gmgnlwvr +gmhole +gminset gmint +gmlwkpk gmn gmnl gmod gmodule gmon +gmonad gmonoid +gmonotonic +gmp +gmpn +gms +gmterm gmul gmulhom gmullhom gmult +gmx +gna +gname +gnbevvu +gnc +gnd gneispa gneispace gneispaceel @@ -30314,23 +51265,43 @@ gneispacefun gneispacern gneispacess gneispb +gneralize gnet gnew gnf +gnfa +gnfas gni +gnil gnmac +gnode +gnodes +gnome +gnontrivialbs gnonunitalnonassocsemiring +gnorm gnot gnpow gnpowrec +gnr +gnrrstep gns gnsnonunitalstaralghom gnsstaralghom +gnt +gnu +gnumb +gnumber +gnumeral +gnuo goa goal +goald goaldecl +goalenv goaleq goalfmt +goali goalmsg goaln goalpp @@ -30349,11 +51320,30 @@ goalstomessagedata goaltype goaltypes goaltypewithmetavars +<<<<<<< Updated upstream +======= goat +>>>>>>> Stashed changes +gob +gobac +goback +gobj +gobjec +gobject +gobjectp +gobjlist +gobo +goboa +goboard +gobr +gobrd gobrk gobxjuj god goddefsareequivalent +godel +godeldummett +godeldummettpropositionallogic godellob godeximpliesnecex godexistenceimpliesnecexistence @@ -30363,68 +51353,158 @@ godisessential godlike godnecexists goedel +goedelcp goel goelel goeleq goelgoanfmla goeqi goes +goesnegative goestozero goewxr gof +goflattoriscv gogs +gogsi going goinitial +gol gold +goldbach goldbacheven goldbachodd goldbachoddw goldbachth goldbachthlem +goldblatt golden goldenconj goldenratio +goleft golem golf golfable golfed +golfer +golfers golfing +golly golomb +gomaex +gon gonafv gonan gonanegoal gonar gonarlem gone +gonil +gonna +goo good +goodarrayread +goodarraywrite +goodbitvectors +goodbyte +goodchar +goodchars +goodclient +goodcmap goodd +gooddirectfib goode +goodfib +goodfoo +goodfoocombo +goodfoomatch +goodfoonarrow +goodfooprec +goodfoorec +goodfoounif +goodfunctionrhs +goodhltrace goodi +goodinstances +goodinteger +goodloop +goodmachine +goodmetabox +goodmethod +goodmethodrhs +goodmode +goodness +goodnewtypeliterals +goodorder +goodpost +goodpreandlegalchanges +goodpreandlegalchangessequence goodproducts goodr +goodrange +goodrangereads goodreduction goodstein goodsteinc goodsteino goodsteins +goodstring +goodtrace +goodtracee +goodtree +goodvariations +goofy +goofymux google +gop +gopher +gopt +gord gorder +gorgeous +goright +gorzata +gosh gosper gospercatal gospercatalan got +gotcjah +gotinparent goto gotoelim +gotos +gotrequest +gotta +gotten goursat goursatfst goursatsnd +gout +gov +govar +gove govern +governed +governin +governing +governors +govfl +govs +gpaco gpair gpaird +gpar +gpart gpath gpb gpcont +gpd +gpdhom +gperms gpetersengr +gpfp +gpfuncs gpg gpgcubic gpgedg @@ -30447,17 +51527,44 @@ gpgvtx gpgvtxdg gpgvtxedg gpgvtxel +gpi gpint +gpio +gpl +gpo gpop gpos +gposs +gpow +gpptun +gpr gpre +gpred gprod gprodd +gprode +gprodkl +gprodkr gprog +gps +gptr gpush gpv +gqd +gqdescent gra grab +grabbed +grabbing +grabline +grabpairs +grabs +grabws +grace +gracefully +grad +grada +gradaexp grade gradeboundedorder gradeby @@ -30470,6 +51577,7 @@ gradedcommaux gradedequivlike gradedfunlike gradedhomologyfunctor +gradedmonad gradedmonoid gradedmul gradednattrans @@ -30482,11 +51590,14 @@ gradedringhom gradedsmul gradedtensorproduct gradedzeroringhom +gradee grademaxorder grademinorder gradeorder grades gradesby +gradexp +gradexpinv gradezero gradient gradientwithin @@ -30494,6 +51605,8 @@ grading gradings graduate graduation +graft +grafteval grahamconjecture grain grained @@ -30501,55 +51614,154 @@ gram gramian grammaire grammar +grammars +grammarstr gramschmidt gramschmidtbasis gramschmidtn gramschmidtnormed gramschmidtorthonormalbasis grand +grandbeta +<<<<<<< Updated upstream +======= grandchild +>>>>>>> Stashed changes +grandfather +grandfathers +grandmother +grandparent +grank grant +grante +granted +grantidtype +granting +grantnametype +grants +granttokenlist +granttokens +granttokentype granular graop +grap +<<<<<<< Updated upstream +======= grape +>>>>>>> Stashed changes graph +graphap +graphbuilder +graphbuildert +graphcoloring graphd +graphdata +graphdatap graphequiv +graphfn +graphfnap +graphfnext +graphfngraph +graphfni +graphfnimagetype +graphfntype +graphfunc +graphfunction graphfunctor +graphgr +graphgraphfn +graphhom graphi +graphic graphical +graphicality +graphintersection graphiso +graphl graphlociso graphon +graphp +graphquotient +graphrel +graphrep graphs +graphselectors +graphseparation +graphseq +graphsp +graphstates +graphstateswithid +graphstruct +grassman grassmann +grassmannspace grastruct +grating grave gravity gray +grayisgray +grayson +graysonlist +graysonlists grbar grcat +grcd +grchain grd grdlit +grdof gre +grea +greachable great greater +greaterd +greaterdatetime greatereq +greaterequal +greateri +greaterp greaters +greatert greaterthan greaterthanatmost greaterthanlessthan +greaterthanorequal greatest greatestfib +greatestlemma +greatestmanualnat +greatestmanualord greatestofbdd +greatestpredicate +greatestprednat +greatestpredord +<<<<<<< Updated upstream +======= gree +>>>>>>> Stashed changes greedily greedy greek greekmortal +green +greenberg +<<<<<<< Updated upstream +greenhouse +======= +>>>>>>> Stashed changes +greenthm +greet grel gremlocksetcode gremlocksetres +grep +grepf +grepr +greq +grev +greve grewrite grewritelocaldecl grewriteresult @@ -30557,6 +51769,10 @@ grewritetarget grey greyi greys +grfunc +grfunctor +grhidfa +grhom gri gricbri gricen @@ -30572,10 +51788,14 @@ grictr gricushgr gricuspgr grid +gridcoloring gridgen +gridi gridlines +grids griedg griggio +grigory grilcbri grimcnv grimco @@ -30598,6 +51818,12 @@ grindmod grindparam grindreplacementwith gring +grinvlexorder +griso +grisopresfinitepresentation +grkibmp +grl +grlexorder grlic grlicen grlicer @@ -30607,6 +51833,7 @@ grlicrel grlicsym grlicsymb grlictr +grliftiso grlim grlimdmrel grlimedgclnbgr @@ -30622,18 +51849,32 @@ grlimprclnbgrvtx grlimpredg grlimprop grn +grnd +grnilp gro grobner +<<<<<<< Updated upstream +======= grocer +>>>>>>> Stashed changes +groeb groebner gromov gromovhausdorff gronwallbound +groot +grootx +groovy gropd gropeld +gros +gross +grosser +grossly grot groth grothac +grothendiec grothendieck grothendieckcategory grothendieckprecompfunctorequivalence @@ -30653,14 +51894,31 @@ grothpwex grothshort grothshortbi grothtsk +grou ground grounded grounding +groundness +groundp +grounds group groupaction groupaddgroupequivalence groupalgebra +groupascategory +groupasgroupoid +groupauto +groupautomorphisml +groupautomorphismr +<<<<<<< Updated upstream +groupbyview +======= +>>>>>>> Stashed changes +groupc groupcast +groupcastte +groupcat +groupcategory groupcohomology groupcohomologyiso groupcohomologyisoeven @@ -30668,31 +51926,68 @@ groupcohomologyisoext groupcohomologyisoodd groupcone groupconeclass +groupd grouped groupelement groupelts +groupendo +groupepi +groupequality +groupequiv +groupequivdirprod +groupequivfun +groupequivj +groupequivpresgen groupequivquotientprodsubgroup groupexp groupextension +groupf +groupfacility groupfg groupfilterbasis groupfilterbasisofcomm grouph +grouphom +grouphomdirprod +grouphomo grouphomology grouphomologyiso grouphomologyisoeven grouphomologyisoodd grouphomologyisotor +grouphomomorphism +grouphomomorphismpreservesinverse +grouphomomorphismpreservesunit +grouphomset +grouphomsetd +grouphomseti groupident +groupification +grouping +groupinv +groupisgroupoid +groupiso +groupisodirprod +groupisomorphism groupisotomulequiv +groupisounitgroup +groupj +groupjr groupliealgebra grouplift grouplike grouplikesubmonoid grouplikeval grouplog +groupm +groupml +groupmorphism +groupmorphismstr +groupmr +groupmul groupnorm groupnormclass +groupobjects groupoffinite groupofisunit groupoid @@ -30700,13 +51995,22 @@ groupoidhasinvolutivereverse groupoidofelements groupoidpi groupoids +groupoidtrunc +groupoidtruncidempotent +groupoidtrunctrunc +groupoidunivalentcategory groupop grouporder groupp groupparts +grouppath grouppower grouppowers +grouppresentation +groupprocessday groupprops +groupquotient +groupr groupreaders groups groupseminorm @@ -30714,15 +52018,31 @@ groupseminormclass groupseqs groupset groupsmul +groupstr groupstructure +groupstructureiso +groupsyntax +groupt grouptheory grouptopology +grouptype +groupunitisselfinverse +groupv +groupvect +groupvl +groupvr groupwis +groupwise groupwit +groupwithoperators groupwithzero groupwithzeroofcancel groupwithzeroofisunitoreqzero +groupx +groupy +grover grow +growing growkeybyone grown grows @@ -30731,10 +52051,12 @@ growth grp grpact grpaddsubass +grpall grpass grpasscan grpassd grpbase +grpbaseg grpbasex grpbn grpcat @@ -30752,9 +52074,11 @@ grpideu grpidinv grpidlcan grpidpropd +grpidpropdg grpidrcan grpidssd grpidval +grpidvalg grpinv grpinva grpinvadd @@ -30766,8 +52090,10 @@ grpinveu grpinvex grpinvf grpinvfn +grpinvfng grpinvfval grpinvfvalalt +grpinvfvalg grpinvfvi grpinvhmeo grpinvid @@ -30776,6 +52102,7 @@ grpinvinvd grpinvnz grpinvnzcl grpinvpropd +grpinvpropdg grpinvssd grpinvsub grpinvval @@ -30807,6 +52134,7 @@ grpoass grpobj grpobjobj grpocl +grpod grpodivcl grpodivdiv grpodivf @@ -30852,15 +52180,19 @@ grposnold grpplusf grpplusfo grpplusg +grpplusgg grpplusgx grppncan grppnpcan grpprop grppropd grppropstr +grppropstrg +grpq grpr grpraddf grprcan +grpressid grprid grprida grpridd @@ -30872,6 +52204,7 @@ grpss grpssmnd grpssmndel grpstr +grpstrg grpsubadd grpsubcl grpsubcld @@ -30879,9 +52212,11 @@ grpsubeq grpsubf grpsubfval grpsubfvalalt +grpsubfvalg grpsubid grpsubinv grpsubpropd +grpsubpropdg grpsubrcan grpsubsub grpsubval @@ -30892,14 +52227,23 @@ grptypeequivalencegrpforget grpvlinv grpvrinv grpwithzero +grr grrgr +grrr +grrstep grrusgr grs +grsolv +grspec +grstep grsteps grstr +grstrg grstructd grstructeld grsubgr +grsuc +grt grtri grtriangles grtriclwlk @@ -30923,9 +52267,11 @@ gruina gruiun gruixp grumap +grumble grumnud grumnudlem grumnueq +grun gruop grupr grupw @@ -30937,8 +52283,10 @@ gruscottcld grusn gruss grusucd +grutoti grutr grutsk +grutt gruun gruuni gruurn @@ -30949,10 +52297,22 @@ grw gsca gselect gsemiring +gsentence +gsep +gseq +gseqe gset +gsf gsfw gsh +gshs gsi +gsident +gsig +gsinglee +gsize +gsm +gsmp gsmsymgreq gsmsymgreqlem gsmsymgrfix @@ -30960,24 +52320,68 @@ gsmsymgrfixlem gsmtrcl gsmul gsmulhom +gsn +gsnd +gsnorm gso +gsoaddcode gsoaddfp +gsoaddlock +gsoaddlpool +gsoaddres gsofp +gsolockpool +gsolockres gsolockresremlock gsolockresupdlock +gsolockset gsopt +gsothreadc +gsothreadcc +gsothreadclock +gsothreadclpool +gsothreadcode +gsothreadlock +gsothreadlpool +gsothreadr +gsothreadres +gsothreadrlock +gsothreadrr +gsound +gsovfl gsp gspec +gsq gsqazyclfq gsrstep gsrsteps gss +gssaddcode gssaddfp +gssaddres gssfp +gsslockres gsslockresremlock gsslockresupdlock +gsslockset +gsspec +gssthreadcc +gssthreadcode +gssthreadres +gssthreadrr gst gstate +gstates +gsth +gstho +gstr +gstrength +gsub +gsubf +gsubmg +gsubt +gsucbnd +gsuccessors gsuf gsum gsumadd @@ -31004,6 +52408,19 @@ gsumfsffz gsumfsum gsumfsupp gsumfz +gsumfzcl +gsumfzconst +gsumfzconstf +gsumfzfsum +gsumfzfsumlem +gsumfzfsumlemm +gsumfzmhm +gsumfzmptfidmadd +gsumfzreidx +gsumfzsnfd +gsumfzsubmcl +gsumfzval +gsumfzz gsumge gsumhashmul gsumind @@ -31108,84 +52525,205 @@ gsumzsplit gsumzsubmcl gsumzunsnd gsurj +gsv +gsxrfwm +gsym +gsyms gta +gtactic +gtapd +gtapii +gtarget +gtb +gtbeta gtc +gtconst +gtd gtdbwisghx +gtdec gte +gtedl +gtedr +gten +gtenat +gtenv gteq gtereflectsgte gterm +gterms +gtests +gtf gtfsumgt +gtg +gth gthm +gthreadcr +gthreadrc gti gtinf gtiso +gtispr +gtk +gtl +gtlist +gtm gtmnf +gtmsize +gtn gtndiv +gtndvdp gtned gtneii gtnelicc gtnelioc +gtnndvd +gtnpi +gtnqex +gtnum +gtny gto gtot gtotal +gtp +gtpm +gtpml gtr +gtrace gtrancl +gtransfer +gtre +gtree +gtres +gtri +gtrilemstep gtrs gts gtso gtt +gttr +gttt +gtwo gty +gtyp +gtype +gtz +gtzgt +gua guar +guaranted guarantee +guaranteeasguard +guaranteeasguardswap guaranteed guaranteeing guarantees +guaranteestrip guaranteestrippair +guaranteestripswap +guaranteeswap guard +guarda +guardalwaysholdsonentry guarded guardedseqsubst guardexceptions +guardi +guardian +guardmatch guardmsgscmd +guardp guardrule guards +guardscons +guardsconsguaranteestrip +guardsi +guardsnil +guardstrip +guardstripsame +guardstripswap +guardswap +guardte guarnoreadorwrite guarnowrite +guarof +guc gue guess guessed guesses guessi guessing +guessn guessname guessnamedata guessreorder guest +gug guha +guidance guide +guider guides guillemotleft guillemotright guitarte guitartexact +gulp +gun gunion +gunit +guniv gunodes guntzer +guo +gupaco +gupd +gupta +gur +gurun +gus gusakov +gusuccessors +guts +gutsp guv guy guz +gva gval +gvar gvars gvd +gvi +gvs gvxy +gweakening +gwen +gwitness +gwreg +gxcombine +gxe gxjzddcuxnbaevglrxdcjejdoevfjghx +gxoo gxs gyqbrvnzqzcjyjk gyr +gyration gyro +gyroassoc +gyroatomorphic +gyroaut +gyroautomorphic gyrocarrier +gyrocommute +gyrodistance +gyrominus gyronorm +gyroplus +gyrovec +gysin +gysins +gyx gzabssqcl gzaddcl gzcjcl @@ -31228,15 +52766,32 @@ habx habz hac hacc +haccess +hace haci hack +hacka hackage +hackalong +hackarith +hackb +hackfun +hacking +hackish +hackk +hackkkk +hacks +hacky +hackyy +hackz +hackzz hacl hacompact haconv hacx hacyc had +hada hadamard hadamardthreelines hadass @@ -31244,7 +52799,11 @@ hadbi hadcoma hadcomb hadd +haddc haddlen +haddp +haddr +hadds hadifp hadj hadjicostas @@ -31254,14 +52813,21 @@ hadrot hae haef haefg +haequiv +haequivint +haequivover +haes haeval haevents haf +hafl +hafls hafter hag hagree hah hahn +hahnban hahncoeff hahnembedding hahnmodule @@ -31283,85 +52849,149 @@ hale haleph hales half +halfa halfaddsub halfaddsubcl +halfadjointsequenceequiv +halfatn halfbraiding +halfbump halfcl halfcld halfcn halfcut +halfd halffl halfge halfgt halflem halfleoddlt +halfline +halflineangleb +halflineanglebc +halflineanglec +halflineantisymlslt +halflinebetween +halflinebetweenbetween +halflinecollinear +halflinedistinct +halflineequidistantequal +halflineequidistantequalpoints +halflineequiorientedhalfline +halflinenotclockwiseabc +halflinenotclockwisebac +halflineparallel +halflines +halflinesym halflist halflt +halfm halfnneg halfnq +halfnqq halfnz +halfpermeq halfpire halfpm halfpos +halfprocess halfre halfspace halfspaces +halfsqrt halfthird halfway +halfword +halfwords halg +halign halimit +halist +halistp hall +hallj +hallmar hallmarriagetheorem hallmatchingsfunctor hallmatchingson +halloc +hallp +halp halt halted +haltedp +haltf halting haltlist halts +halve +halved halves halvesd halving halways ham hamax -hamburg -hamburger hamc +hame hameas hamilton +hamiltonian +hammer +<<<<<<< Updated upstream +======= hammin +>>>>>>> Stashed changes hamming +hammingd hammingdist hammingdistnorm hammingnorm hamonic han hand +handball handcraft +handl handle handleappendentries handleappendentriesreply handleclientrequest handled +handlee handleinput handleinputs +handleiostatee +handlek handlemessage +handlent handler +handleref handlerequestvote handlerequestvoter handlerequestvotereply handlers +handlersel +handlertfs +handlerv handles +handlet handletim handletimeout handling +hands handshake handthen handy hane +hang hangel +<<<<<<< Updated upstream +======= hanges +>>>>>>> Stashed changes +hanging +hangs hanoi hanti hao @@ -31373,22 +53003,38 @@ hapc hapi hapos happ +happe happen happend +happened happens happily +<<<<<<< Updated upstream +======= happiness +>>>>>>> Stashed changes +happly +happlyfunext happy +happycaseroundtrip haps haq har harcard harcl hard +hardcoded +hardened harder hardest +hardin +hardline hardness +hardp +hardstep hardware +hardwired +hardy hare harf harg @@ -31407,22 +53053,31 @@ harmoniccontoncl harmonicity harmoniclbnd harmoniconnhd +harmonicsums harmonicubnd harmonize harn harndom harness +harnesses haroot harootcaraudiosystem haroots harper harr +harrison harry harsdom +harsh +harshrc harsucnn +hart hartogs hartogslem +hartsshorne +hartsshornebis harval +harvest harwdom harword has @@ -31430,24 +53085,39 @@ hasabsleftkanextension hasabsleftkanlift hasadd hasaddfundamentaldomain +hasaddition hasadditivereduct hasadditivereduction hasaffineproperty +hasallcoproducts +hasallproducts +<<<<<<< Updated upstream +======= hasancestor +>>>>>>> Stashed changes hasantidiagonal hasantitonebasis hasanyfvar +hasarchversion +hasarrays +hasarrows hasbasis hasbesicovitchcovering +hasbetterpathat hasbinarybiproduct hasbinarybiproducts hasbinarycoproduct hasbinarycoproducts hasbinaryproduct hasbinaryproducts +hasbinprod hasbiproduct hasbiproductsofshape +<<<<<<< Updated upstream +======= hasbody +>>>>>>> Stashed changes +hasboundedheight hasboxintegral hasbracketaux hasc @@ -31458,6 +53128,8 @@ hascardinallt hascdot hascentralradical haschar +haschild +haschoice haschole hasclassifier hasco @@ -31501,7 +53173,6 @@ hascolimitsofshapeofhascolimitsofsize hascolimitsofsize hascolimitsofsizeofunivle hascolimitsofsizeshrink -hascolor hascompactmulsupport hascompactsupp hascompactsupport @@ -31514,6 +53185,7 @@ hascontdiffbump hascoprod hascoproduct hascoproducts +hascoproductsbool hascoproductsofshape hascore hascoreflexiveequalizers @@ -31522,11 +53194,15 @@ hascountablebasis hascountablecoproducts hascountableproducts hascountableseparatingon -hascousin hascsimplemma +hascurrent +hascwskel +hascwskelsphere hasd +hasdagger hasdayconvolution hasdayconvolutionunit +hasdefault hasder hasderi hasderiv @@ -31546,6 +53222,7 @@ hasdimensionle hasdimensionlt hasdistribneg hasdistribpointwiseneg +hasdrink hasdups hase haseffectiveepi @@ -31559,14 +53236,15 @@ hasend hasenoughpoints hasenoughrootsofunity hasenrichedhom +haseq hasequalizer hasequalizerofiscosplitpair hasequalizers hasequalizersofhaspullbacksandbinaryproducts hasequiv +hasequivs haserror haserrors -hasessence haseval hasevalideal hasexactcolimitsofshape @@ -31596,12 +53274,17 @@ hasfiberfunctor hasfibers hasfilteredcolimits hasfilteredcolimitsofsize +hasfincwskel +hasfincwskelsphere +hasfincwskelunit hasfinitebiproducts hasfinitecolimits hasfinitecoproducts hasfinitefpowerseri hasfinitefpowerseriesat hasfinitefpowerseriesonball +hasfiniteheight +hasfiniteheighteverywhere hasfiniteint hasfiniteintegr hasfiniteintegral @@ -31613,7 +53296,13 @@ hasfinitequotients hasfinitesupport hasfinitewidepullbacks hasfix +<<<<<<< Updated upstream +======= hasflavor +>>>>>>> Stashed changes +hasfntype +hasfntypeimage +hasfntypeimagesubset hasforget hasforgettoaddcommmoncat hasforgettobdddistlat @@ -31632,6 +53321,7 @@ hasforgettomon hasforgettomoncat hasforgettopartord hasforgettor +hasfp hasfpo hasfpowerseries hasfpowerseriesa @@ -31642,6 +53332,7 @@ hasfpowerseriesonsubball hasfpowerserieswithin hasfpowerserieswithinat hasfpowerserieswithinonball +hasfreefd hasftaylorseriesupto hasftaylorseriesuptoon hasfun @@ -31649,7 +53340,9 @@ hasfunctorenrichedhom hasfunctorialfactorization hasfunctorialsurjectiveinjectivefactorization hasfundamentaldomain +hasfuntype hasfvar +hasgame hasgaussianlaw hasgeneigenvalue hasgeneigenvector @@ -31672,8 +53365,12 @@ hashbccl hashbclem hashbcss hashbcval +hashblock +hashblocks hashbnd hashcard +hashchar +hashchars hashcl hashclb hashclwwlkn @@ -31684,6 +53381,7 @@ hashdif hashdifpr hashdifsn hashdifsnp +hashdmprop hashdmpropge hashdom hashdomi @@ -31691,17 +53389,23 @@ hashdvds hasheartfullsubcategory hashecclwwlkn hashed +hashedta +hashek hashelne hashen hasheni +hashennn +hashennnuni hasheq hasheqf +hashes hasheuni hashf hashfac hashfacen hashfingrpnn hashfinmndnn +hashfiv hashfn hashfun hashfundm @@ -31723,10 +53427,17 @@ hashimarn hashimarni hashin hashinf +hashinfom +hashinfuni hashinfxadd +hashing +hashisonto hashiun hashkf +hashl hashle +hashlen +hashm hashmap hashnbusgrnn hashnbusgrvd @@ -31739,6 +53450,7 @@ hashnfinnn hashnn hashnncl hashnnn +hashnon hashnzfz hashnzfzclim hasholeannotation @@ -31771,17 +53483,24 @@ hashss hashssdif hashssle hashsslei +hashstring +hasht +hashtable +hashtablelookup hashtpg hashtplei hashun hashuni hashunif hashunlei +hashunlem hashunsng hashunsnggt hashunsngx hashunx hashv +hashvalue +hashvalues hashvnfin hashwrdn hashwwlksnext @@ -31812,14 +53531,19 @@ hasinstancebinderof hasintegral hasintegralindicatorconst hasintegralvertices +hasinterchange hasintscalar hasinv +hasinverse hasinvolutivereverse +hasio hasisos hasiterationofshape haskell haskernel haskernels +haskey +haskeyid hasl haslaw hasle @@ -31838,6 +53562,7 @@ hasleftkanextension hasleftkanlift hasleftresolutions haslefttensor +haslengthk haslift hasliftingproperty hasliftingpropertyfixedbot @@ -31867,7 +53592,11 @@ hasloosebvar hasloosebvars haslub hasmacroscopes +hasmajority +<<<<<<< Updated upstream +======= hasmaker +>>>>>>> Stashed changes hasmap hasmapbifunctor hasmaxcutproperty @@ -31875,29 +53604,43 @@ hasmaxcutpropertyat hasmeasurableinf hasmeasurablepow hasmellin +hasmem +<<<<<<< Updated upstream +======= hasmembers +>>>>>>> Stashed changes hasmemorinvmem hasmemornegmem hasmfder hasmfderiv hasmfderivat hasmfderivwithinat +hasmorext hasmul hasmulticoequalizer hasmultiequalizer hasmultiplicativereduction +hasn hasnatpow hasnatscalar hasneg +hasnegation hasnext +hasnlbound +hasnobody +hasnoduplicates hasnoindexannotation hasnoloop hasnonabelianatoms hasnondegenerateedges hasnondegeneratevertices +hasnonequalterm hasnontrivialdivisor hasnontrivialdivisorlessthan hasnot +hasnub +hasnubound +hasochoice hasofpostcompproperty hasofprecompproperty hasone @@ -31914,6 +53657,12 @@ haspairwisepullbacks haspdf hasper hasperiod +<<<<<<< Updated upstream +======= +hasperson +haspet +>>>>>>> Stashed changes +haspn haspoints haspointwiseleft haspointwiseleftderive @@ -31927,21 +53676,29 @@ haspointwiserightderivedfunctorat haspointwiserightkanextension haspointwiserightkanextensionat haspow +haspp +hasprecondition +haspresentation hasprimitivevectorwith hasprod hasprodlocallyuniformly hasprodlocallyuniformlyon hasproduct hasproducts +hasproductsbool hasproductsofs hasproductsofshape hasproductsofshapeaux +hasproductsop hasproduniformly hasproduniformlyon hasproject hasprojectivedimensionle hasprojectivedimensionlt hasprop +haspropfibers +haspropfibersisprop +haspropfibersofimage haspullba haspullback haspullbackalong @@ -31956,10 +53713,16 @@ haspushout haspushouts haspushoutsalong haspushoutvertpaste +haspx +hasq hasquotient +hasquotientchoice hasranknullity +hasread hasreflexivecoequalizer hasreflexivecoequalizers +hasresidual +hasretract hasreverse hasri hasright @@ -31980,8 +53743,10 @@ hasringhompro hasringhomproperty hass hasse +hassection hassederiv hassedualiso +hassen hassep hasseparablecontraction hasseparatingcover @@ -31995,6 +53760,7 @@ hasshift hasshiftmk hasshiftoffullyfaithful hassingleton +hassmall hassmallestcolimitsofhascolimits hassmallestlimitsofhaslimits hassmalll @@ -32036,7 +53802,12 @@ hassubgaussianmgf hassubset hassubst hassubstideal +hassubstring +hassubstringpos +<<<<<<< Updated upstream +======= hassugar +>>>>>>> Stashed changes hassum hassumlo hassumlocall @@ -32045,6 +53816,7 @@ hassumlocallyuniformlyon hassummablegeometricseries hassummablegeomseries hassumuniformlyon +hassup hassupport hassups hassyntheticsorry @@ -32058,13 +53830,22 @@ hasterminal hasterminalchangediagram hasterminalchangeuniverse hastotal +hastrchoice hastrivialradical +hastuples hastwooutofthreeproperty hastype hastypee hastypei +<<<<<<< Updated upstream +hasui +hasuint +======= hasu +hasui +hasuint hasuncle +>>>>>>> Stashed changes hasuncomparable hasuncurry hasunifeigenvalue @@ -32073,8 +53854,8 @@ hasunitmulpowirreduciblefactorization hasunitspeedon hasup hasupperlowerclosure +hasval hasvalue -hasvintageyear hasw haswe hasweaksheafify @@ -32084,7 +53865,11 @@ haswidepullback haswidepullbacks haswidepushout haswidepushouts +<<<<<<< Updated upstream +======= haswinedescriptor +>>>>>>> Stashed changes +haswinner hasy hasymm haszero @@ -32094,6 +53879,8 @@ haszeromorphisms haszeroobject hat hatch +hatcher +hate hates hatg hatinv @@ -32104,18 +53891,22 @@ hatomistici hatoms hats hattop +hattr +hatype hau haus hauscmp hauscmplem hausdiag hausdist +hausdorf hausdorff hausdorffdist hausdorffedist hausdorffentourage hausdorffification hausdorffmeasure +hausdorrf hauseqcn hauseqlcld hausflf @@ -32141,9 +53932,14 @@ hauteur haux hav have +haveaarch +haveanyaarch +haveel +haveempamext havei haveiddecl haveidlhs +havejazelle havelebesguedecomp havelebesguedecompos havelebesguedecomposition @@ -32151,16 +53947,37 @@ havelebesguedecompositionrnderiv havelet haveletcore haveletlinter +havempamext +havemteext haven havenewentries +<<<<<<< Updated upstream +======= havenothingincommon +>>>>>>> Stashed changes +havenv +havepacext +havequorum +havesecureel +havethumbee +havevirthostext having havoc +havocflags +havocinmultiassignment +havocmultiple +havocmultiplevar +havocone haw hax hay +haystack haz +<<<<<<< Updated upstream +======= hazard +>>>>>>> Stashed changes +hazardous hazcxulqoxix hazero hba @@ -32169,27 +53986,36 @@ hbabg hbad hbae hbaeb +hbaes hbaev hbal hbald hbalg hbalgvd hball +hballe +hballi hbalt hbaltg hbalw hban +hband +hbanold +hbar hbas hbase hbasei hbasis hbazdsiunzrkbeqktnzxt hbb +hbbi +hbbid hbc hbci hbcompact hbcot hbcp +hbct hbcx hbd hbdc @@ -32197,12 +54023,17 @@ hbdd hbds hbe hbelow +hbeq hbequid hbeta hbetter +hbeu +hbeud hbex +hbexd hbexg hbexgvd +hbexi hbext hbf hbfinite @@ -32210,15 +54041,19 @@ hbfx hbg hbh hbi +hbia hbib hbij hbim hbimd +hbimdold hbimg +hbimold hbimpg hbimpgvd hbimtg hbint +hbit hbj hbja hbk @@ -32230,6 +54065,8 @@ hbm hbmax hbmc hbmin +hbmint +hbmo hbn hbnae hbnaeb @@ -32237,17 +54074,26 @@ hbnaes hbnaev hbnd hbng +hbnold hbnt hbntal hbntbi hbntg hbo +hbody +<<<<<<< Updated upstream +======= hbool +>>>>>>> Stashed changes hbopen +hboprab +hbor hbot hbotb hbound hbounded +hboundedlp +hbov hbp hbpd hbq @@ -32259,26 +54105,45 @@ hbrr hbs hbsa hbsb +hbsbd +hbsbv hbsbw hbsbwold +hbsfo +hbsh +hbsimulation +hbspec hbss hbt hbth hbtlem hbu +hbuf hbuiltin +hburst +hburstm +hbusreq hbv hbw hbx +hbxfr hbxfrbi hbxfreq +hbxfrf hby hbyfrbi hbytes hbz hca hcan +hcancel +hcancelptt +hcancelptv +hcancelt +hcancelv hcanonical +hcantor +hcar hcard hcardst hcardtu @@ -32295,19 +54160,26 @@ hcd hcderived hcdiff hcdn +hcdr hcdvd hce hcei hcell hcenter +hcenv hcf hcfg hcfk +hcflat +hcflatplus hcg hch hchain hcham +hchange hchar +hcheck +hchildren hchoose hchop hci @@ -32315,18 +54187,24 @@ hcinf hcj hck hcl +hclean +hclient hclo hclosed hclosure hcm hcmeas hcmin +hcmp hcmpt +hcn hcne hcno hcnoeth hcnonneg hcnt +hcnti +hcntj hcnz hco hcocone @@ -32339,8 +54217,11 @@ hcoe hcoedvd hcoef hcoeff +hcoeqsl +hcoeqsr hcof hcofg +hcoh hcol hcolamc hcolbmc @@ -32355,14 +54236,17 @@ hcompact hcompat hcompatible hcompc +hcompclosed +hcompetes hcompf hcompl hcomplete -hcomposite hcompvcomphcomp hcomul hcon hconcat +hconcl +hconclv hcond hcone hconf @@ -32371,17 +54255,25 @@ hcong hcongr hconj hconn +hcons hconsistent hconsm hconst hcont hcontdiff +hcontents +hcontentsf hcontra hconv hconvex hcop hcopen hcoprime +hcor +hcore +hcorestep +hcoresteps +hcorr hcos hcotangent hcounit @@ -32398,6 +54290,8 @@ hcq hcr hcrange hcs +hcsafe +hcsc hcsem hcss hcst @@ -32418,13 +54312,19 @@ hcyclex hcz hda hdab +hdack hdb hdc hdd hde +hdead +hdec hdecay hdeceqsigma hdecomp +hdecr +hdefl +hdefr hdeg hdegp hdegree @@ -32436,6 +54336,7 @@ hdenunit hdep hder hderiv +hderives hdesc hdet hdf @@ -32455,6 +54356,7 @@ hdisj hdisjoint hdisjointuv hdist +hdistinct hdiv hdiva hdivb @@ -32462,7 +54364,10 @@ hdivk hdivn hdivp hdivq +hdivstep hdj +hdl +hdlast hdlt hdm hdmap @@ -32498,23 +54403,37 @@ hdmapsub hdmapval hdmem hdn +hdnil hdom hdomain +hdomaini hdomchart +hdomp +hdoms +hdomt hdp +hdpat +hdplygy +hdpow hdprod hdq hdr +hdrel +hdry hds +hdsat hdsd hdso hdss hdsu hdt +hdtfnfz hdtl hdtu hdu hdum +hdunsat +hdvalues hdvd hdvw hdx @@ -32524,57 +54443,113 @@ head headbeta headbetabody headbetathroughlet +headcp +headcpbis headctx headd +headed header +headerauth +headerauthtag +headerbody headerfail +headeriv +headerivlength headerlinter +headerp headers +headersarethesamewhenthereisencryptioncontext headerstr +headersubset headertestfiles +headertrm +headertypes headg headhead headi headin headindex heading +headl headless +headlocation +headm headmap headn headnumargs headnz +headptr headr heads +headsi +headsp headstructureetareduce headt headtail +headtailproperties +headvar healt health healthy heap +heapassignmentdowncasts +heapd +heape +heapentryc +heapeq +heapexternalspartitionedmorestupidlike +heapexternalszeroorone +heapexternalszerooroneedges +heapexternalszerooronexxx heaphelp +heapi heapify -heapim heapinsert +heaplength +heaplet +heaplets +heapmodel +heapobjectsaremonotonic +heapp heapprox +heapquant +heapref heaps +heapse +heapsi +heapsort +heapsucc heart heartbeats +heat +<<<<<<< Updated upstream +======= heating +>>>>>>> Stashed changes +heatiseven heavier +heaviest heavily heaviside +heavy heb hec heccl +hecho heck hecl hecs hed +hedberg +hedbergs hedge +hedgeunion +hedgeunionwithkey hedis +hedman hee heei +heenum heeq hef hefin @@ -32588,69 +54563,105 @@ hei heibor heiborlem heicant +heig height +heightable heighte +heightle +heightmonotonic heightonespectrum +heightp heights +heigt heine +heirarchical hej hek hel helch held helim +helix hell +hellmann +hello +helloerr helloname helloworld helly help +helpe helper +helperf helperlemmas +helpers helpful +helpfun helping helpmsg helpnorm +helpr +helprr helps helsh helt hem hemicontinuous +hemisphere hemp hempty hemul hen henabled +henc hencard hence hendphase hene +heneric +henforce +henkin +henmodel +hennessy +henre +henry hens hensel henselianlocalring henstock +hent +henter hentlen hep +hepi hepn hepos heps +hept heq heqa +heqabs heqaer heqb heqbuf heqcontents heqd +heqentropy heqhlbs heqi heqimpofeqimp heqin heqinit +heqipadcont heqjqlcwjdihuklkvfmkitllvjitcbwxninwazswh heql heqls +heqmki +heqmu heqo heqofeq heqon +heqopadcont heqp heqr heqs @@ -32662,10 +54673,18 @@ heqz her herase herasecores +herased herasedmem +herasedpool herasemem +herasepool heraseval +herasure +herbase +herbrand here +hereby +hered hereditarily hereditarilylindelof hereditarilylindelofspace @@ -32676,19 +54695,31 @@ herglotzrieszkernel herm herman hermes +hermit +hermitan +hermitd hermite +hermitean hermitetheorem hermitian heron +<<<<<<< Updated upstream +======= heronconf +>>>>>>> Stashed changes +herron hes hess +hessenbe +hessenberg hest hesymm het heterobasic heterogeneous +heterogeneousrelations heterogenous +heterohomotopy hetx heu heuniv @@ -32702,17 +54733,31 @@ heven hevtxdg hex hexa +hexadecimal hexagon +hexagonidentity +hexchar +hexcharroundtrip +hexdigit hexec hexist hexists hexp +hexploit hexpmul +hexstr hexstring +hexstrroundtrip hext hextcall +hextend hexternal +hextest hextr +hexval +hexvalroundtrip +hexvalue +hexvalueroundtrip hexy hey heyting @@ -32730,7 +54775,10 @@ hfadj hfadp hfail hfair +hfaithful hfalse +hfalsepost +hfalsepostcond hfan hfanti hfap @@ -32752,6 +54800,7 @@ hfd hfdef hfdeg hfderiv +hfdiff hfdifferential hfdisj hfdropi @@ -32777,11 +54826,14 @@ hfgz hfh hfhascompactsupport hfi +hfiber hfibers hfield hfij +hfill hfim hfin +hfind hfinicc hfinite hfinj @@ -32793,6 +54845,8 @@ hfint hfintype hfinv hfirr +hfiu +hfiw hfix hfj hfk @@ -32802,6 +54856,8 @@ hfl hflat hfle hfleoneonk +hflo +hflocks hfloor hflp hflt @@ -32836,8 +54892,20 @@ hfpw hfq hfr hfrac +hfrc +hfree +hfreeable +hfreee +hfreelock +hfreen hfreq +hfresh +hfreshs +hfreshsm +hfresht +hfreshtm hfrob +hfrosccfg hfrv hfs hfsa @@ -32848,6 +54916,7 @@ hfsn hfsr hfst hfstab +hfstep hfsub hfsum hfsup @@ -32862,10 +54931,15 @@ hftr hfu hfucomp hfuel +hfull +hfullk hfullv hfullvs hfun hfunc +hfuncs +hfunction +hfune hfunext hfuni hfuopen @@ -32898,6 +54972,7 @@ hgdeg hge hgen hgeq +hget hgetbuffering hgexact hgexp @@ -32906,6 +54981,7 @@ hgfc hgfx hgg hgh +hghosts hgi hgij hgim @@ -32917,6 +54993,8 @@ hgk hgkl hgl hgle +hglen +hglob hglp hgm hgmap @@ -32942,13 +55020,19 @@ hgn hgnt hgo hgoal +hgood hgp hgpm hgpn hgq hgr +hgrant +hgroupoid hgrowth +hgrwopstr hgs +hgsh +hgshs hgsupp hgsurj hgt @@ -32980,6 +55064,8 @@ hhcyc hhd hhdedf hhead +hhelper +hhelperh hhen hherm hhf @@ -32989,10 +55075,15 @@ hhh hhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh hhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh hhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh +hhhjoin hhhl hhi +hhimg hhims hhip +hhist +hhists +hhit hhj hhk hhl @@ -33013,6 +55104,7 @@ hhost hhp hhph hhs +hhshrink hhshsslem hhsm hhssablo @@ -33052,39 +55144,94 @@ hicl hicli hico hid +hidato hidden +hiddenid +hiddenp +hiddensquare +hiddentree +hiddsec hide +hideandrevealhappyflow hidedups hidedupsrec +hideinfunction hident hideous hides +hideseq +hidexpr +hidindex hiding hidl +hidname +hidpiece +hids +hidtrace +hidtype hidx hie +hier +hierac +hierachy +hierarchic +hierarchical hierarchies hierarchy +hierarchykeyring +hierarcial +hierarcical +hierauto +hieuristics hif +hifa +hifat hiff hifg hifin hifs hifu hig +higgs high +higha +highbi +highbit +highbits highbodies +highbranch +highbyte +higheqt higher higherfacesvanish higherorderderivehandler higherordergetparam higherpowers +highert highest +highestel +highestelusingaarch +highestsetbit +higheststamprcvd highestweight highi +highindex highlighting +highlong +highlow +highlowrandom +highly +highmidbyte +highpn +highptun highs +highsi +highsimp +highsiz +highsize +highval higman +hih hii hiidge hiidrcl @@ -33094,13 +55241,18 @@ hiis hiisdds hij hijac +hijack +hijacking hijijk +hijqaha hik hil hilablo +hilbasis hilbert hilbertbasis hilbertpoly +hilberts hilcms hilcompl hilf @@ -33108,12 +55260,13 @@ hilhhi hilhl hilid hilims -hill hillerstr hilmet hilmetdval hilnormi +hilo hilt +hilton hilvc hilxmet him @@ -33124,14 +55277,18 @@ himg himgo himp himpi +himself hin +hinc hincl hincr hind hindep hinder +hindered hinders hindex +hindley hindman hindp hine @@ -33139,25 +55296,40 @@ hineq hinf hinfty hinh +hinhcau hinit +hinitf +hinitial +hinitm +hinitn +hinitsc hinj hinjective hinl +hinmap hinner hinotmax hinr hins hinsep hinsert +hinstr hint +hinted hinter hinternal hintextension hintf hintikka +hintikkap hintikkas +hintikkasatisfiable +hintp hints +hintv +hintx hinv +hinvalid hinvc hinvequiv hinvf @@ -33166,37 +55338,59 @@ hioc hioo hiou hip +hiperplane +hiperplanes +hiprime hiq hir hire +hireachy hiriart +<<<<<<< Updated upstream +======= hiring +>>>>>>> Stashed changes +hiroshi hirr hirstl his hiscompact hisds +hisfilter +hisindependent hislocal +hislock +hismeasurepreserving hiso hispred hisprev hist +histo +historic historical historically history +historyantichain hists +histtable hisubcomi hisup hisupp hit +hitasabeliangroup hite +hither hitop +hitp +hits +hitsp hitting hittingafter hittingbtwn hiu hiv hiw +hiword hiwu hiwx hix @@ -33218,6 +55412,7 @@ hjij hjj hjjk hjk +hjkdesr hjkijk hjl hjle @@ -33237,20 +55432,30 @@ hjx hka hkax hkb +hkbgwji hkc hkcl hkco hkcomp hkconv hkdf +hkdfensurespublicly +hkdfexpand +hkdfexpandensurespublicly +hkdfextract +hkdfextractensurespublicly +hkdfextractinput hke hker hkerf +hkeys hkf hkfin hkg hkh hki +hkinv +hkirpep hkj hkjk hkk @@ -33264,11 +55469,14 @@ hkn hkng hknty hko +hkop hkopen hkp hkpos hkq hkr +hkreach +hkrf hks hksubintv hkt @@ -33282,10 +55490,14 @@ hla hlabel hladdf hladdid +hlam hlass hlast +hlasts +hlat hlatcon hlateq +hlatest hlatexch hlatexchb hlathil @@ -33326,19 +55538,37 @@ hlead hlef hleft hleg +hlem +hlemma hlen +hleng +hlength +hlenh +hlenl hlenp hlenpos hlenq +hlens hleq hleqnid hles +hless hlet +hlev +hlevel +hlevelem +hlevels +hleveltrunc +hleveltruncmodality +hlevfiller +hlevprecode hlex hlexch hlexchb +hlexorder hlf hlg +hlgood hlh hlhgt hlhil @@ -33391,6 +55621,7 @@ hlipdir hlipf hlipgt hlist +hlit hlj hlk hll @@ -33409,17 +55640,22 @@ hln hlne hlnv hlnvi +hlo hload hloadbytes hlobn hloc hlocal +hlocation +hlock +hlocks hlog hlogx hlol hlomcmat hlomcmcv hloml +hlook hloops hlop hlp @@ -33431,6 +55667,7 @@ hlphl hlpos hlpr hlprlem +hlps hlq hlr hlrel @@ -33438,25 +55675,39 @@ hlrelat hlress hlroot hls +hlshs hlsq hlsupr hlsuprexch hlt hltc hltf +hlti +hltj hltn hltr hlu hlv hlvc hlx +hlxs hlzero hma hmac +hmacabs +hmacbodycryptoproof +hmaccore hmacdrbgfunspecs hmacdrbgvarspecs +hmacensurespublicly +hmacfinal hmacfunspecs hmachex +hmacinit +hmacsha +hmacsimple +hmacstate +hmacupdate hmacvarspecs hmain hmake @@ -33465,6 +55716,7 @@ hmaple hmaps hmapsto hmas +hmask hmatch hmatchingfree hmax @@ -33497,6 +55749,7 @@ hmeoco hmeof hmeofn hmeofval +hmeofvalg hmeoima hmeoimaf hmeontr @@ -33512,6 +55765,7 @@ hmgi hmi hmin hminmem +hminus hmj hmk hml @@ -33545,6 +55799,7 @@ hmoplin hmopm hmopre hmops +hmor hmoval hmp hmph @@ -33565,6 +55820,7 @@ hms hmset hmsetmset hmsn +hmsplit hmsq hmsum hmt @@ -33577,6 +55833,7 @@ hmulleft hmulright hmultiset hmulvec +hmval hmvt hmvzdaaituizitgfw hmw @@ -33600,6 +55857,7 @@ hncl hnd hndiv hndj +hndlr hndvd hndxep hndxp @@ -33616,6 +55874,7 @@ hnez hnezero hnf hnfd +hnfs hngac hnge hngen @@ -33636,6 +55895,8 @@ hnnc hnnextension hnng hno +hnoconcl +hnode hnodup hnoeth hnon @@ -33647,6 +55908,7 @@ hnonneg hnontriv hnontrivial hnonzero +hnorace hnorm hnormal hnot @@ -33676,11 +55938,13 @@ hnsp hnsq hnss hnsupp +hnsz hnt hnth hntq hnu hnum +hnumthreads hnuv hnv hnw @@ -33692,7 +55956,9 @@ hny hnz hnzd hnzero +hnzk hoa +hoabs hoadd hoaddass hoaddassi @@ -33710,15 +55976,24 @@ hoaddsubass hoaddsubassi hoaddsubi hoare +hoared +hoaresem +hoarest +hoarify +hoarifyi +<<<<<<< Updated upstream +hoas +======= hoasapinj hoasapnotvar hoasinduction hoaslaminj hoaslamnotap hoaslamnotvar +>>>>>>> Stashed changes hob -hobbies hobj +hobounds hobs hoc hocadddiri @@ -33728,6 +56003,8 @@ hococli hocofi hocofni hocoi +hocont +hocontractive hocsubdir hocsubdiri hod @@ -33754,9 +56031,11 @@ hofcllem hofer hoffax hofpropd +hofs hofunctor hofval hog +hogp hohv hoi hoico @@ -33779,42 +56058,70 @@ hoimbllem hoinitconfig hoiprodcl hoiprodp +hoiqjndhfgasohn hoiqssbl hoiqssbllem hoissre hoissrrn +hoist hoival hoj hok +hokey hol +holcers hold holder holderconjugate holderl holderonwith +holders holdertriple holderwith +holdf +holding +holdp holds +<<<<<<< Updated upstream +holdsatleastforzero +======= holdsat +holdsatleastforzero holdsduring +>>>>>>> Stashed changes +holdseventually holdsforlocalization holdsforlocalizationaway holdsistate +holdsp +holdt hole holes +holfoot +holkernel holley +hollight +<<<<<<< Updated upstream +======= hollywood +>>>>>>> Stashed changes holo holoatinfc -holography holomorphic holoonc holor holorindex +holsyntax +holsyntaxextra +holsyntaxextratheory +holsyntaxtheory hom homa +homabgroup +homabgroupstr homacd homaddequiv +homadjoint homadm homadmcd homaf @@ -33830,25 +56137,37 @@ homaval homc homcartesianlift homcategory +homchom +homchomop homcl homclass homco homcocontinuouscontravariant homcocontinuouscovariant homcod +homcollection +homcommsquare homcomp homcomplex +homcongequiv homcongr +homcongsquare +homcontraat +homcontramor homd homdiagram homdmcoa homdom home +homedir +homedirsafe +homelim homeo homeobot homeocompacttot homeoeval homeofnofdiscrete +homeogroup homeoiccquot homeomorp homeomorph @@ -33867,6 +56186,7 @@ homeomorphofsubsetrange homeomorphofunique homeomorphofunit homeomorphprod +homeomorphsim homeomorphsphereprod homeomorphunitsphereprod homeoofequivcompacttot @@ -33876,6 +56196,7 @@ homeorealmixedspacepolarspace homeos homeotop homeowithuppersettopologyorderiso +homeq homequ homequi homequiv @@ -33889,8 +56210,11 @@ homequivofisrightkanextension homequivorderhom homequivright homequivtoprod +homestar homeval homf +homfactor +homfactorepi homfamily homfeq homfeqbas @@ -33901,19 +56225,53 @@ homffval homfrom homfromcommaofisiso homfromequiv +homfth +<<<<<<< Updated upstream +======= homftor +>>>>>>> Stashed changes +homftorcompdef +homftorcontra +homftorcontracod +homftorcontradom +homftorcontraftor +homftorcontramapsto +homftorcontramor +homftordist +homftorftor +homftorid +homftorinmor +homftormaplemma +homftormapsto +homftormor +homftorobj +homftoropobj homfval +homg +homgl +homgp +homgr homgroup homgroupoid +homgrp homi homid +homimage +homimagesof +homimagesofclass hominduction hominfinitesimal homiso homisover +homk +homker +homkkh +homks homlem homlinearequiv hommap +hommapiso +hommappath hommk hommksucc hommodule @@ -33921,6 +56279,7 @@ hommoduleofringmorphism hommonoidhom hommulequiv hommval +homn homnatiso homnatisomaxright homndx @@ -33928,6 +56287,8 @@ homo homobj homobjequiv homobjfunctor +homocyclic +homocyclicp homoeomorphism homof homofcocone @@ -33947,28 +56308,41 @@ homofpihom homofsheafedspacehomofisiso homofvector homog +homogb homoge +homogene +homogeneo homogeneous homogeneouscochains homogeneouscomponent homogeneouscore +homogeneousd homogeneousdef homogeneouselement homogeneouselements +homogeneousfaf homogeneoushull +homogeneousi homogeneousideal homogeneouslocaliza homogeneouslocalization homogeneouslocalizationalgebra homogeneouslocalizationcommring homogeneouslocalizationtostalk +homogeneoussaf +homogeneoussquare homogeneoussubmodu homogeneoussubmodule homogeneoussubmonoid homogeneoussubsemiring homogenize homogenizelm +homogenous homogical +homographic +homographicacc +homography +homol homolog homological homologicalco @@ -33976,6 +56350,7 @@ homologicalcomplex homologicalcomplextodgo homologicalcomplexuptoquasiiso homologicalkernel +homologous homology homologyaddequiv homologydata @@ -33999,7 +56374,9 @@ homologyisopos homologyisosc homologym homologymap +homologymapcomp homologymapdata +homologymapid homologymapiso homologyop homologyopiso @@ -34008,14 +56385,24 @@ homologysequence homologysequencecomposablearrows homologyunop homolr +<<<<<<< Updated upstream +======= homom +>>>>>>> Stashed changes +homomorp +homomorphi homomorphic homomorphism homomorphismi +homomorphismp homomorphisms +homop homoproduct homorl homorthogonal +homot +homothecy +homothet homothetic homotheties homothety @@ -34026,6 +56413,7 @@ homotop homotopic homotopical homotopicalalgebra +homotopically homotopicfrom homotopicl homotopicmapsnatiso @@ -34051,7 +56439,9 @@ homotopygroupequivfundamentalgroupofunique homotopygroupequivzerothhomotopyofisempty homotopyh homotopyhominvid +homotopyintruncatedgroupoid homotopyinvhomid +homotopynatural homotopyofeq homotopyop homotopyopequiv @@ -34060,6 +56450,7 @@ homotopypinftytoid homotopyptoid homotopyqtozero homotopyrel +homotopysyminv homotopyto homotopytozeroofid homotopyunop @@ -34067,7 +56458,12 @@ homotopywith homotopyzero homover homoverequiv +homow +homp +hompres +homprof hompullbackequiv +homquot homquotientzpowofhom homr homrel @@ -34076,9 +56472,17 @@ homrestrict homs homselflin homselflinearequivendmulopposite +homseq +homseqequiv +homseqmap +homsequence +homset +homslid homsmallcategory +homsubgroup homsubtype homsuperset +homsym homtensorhom homtensorhomequiv homtensorhommap @@ -34094,6 +56498,7 @@ homul homulass homulcl homullid +homunique homval hon honda @@ -34105,56 +56510,110 @@ honegsubdi honegsubi honehypercover honest +honestly +honestverifier +honestverifierzeroknowledge honextconfig +honjoin +hononexpansive +honor honorary honpcani honpncani +hons +honsed hoo +hood +hooey hook +hooked hookleftarrow hookrightarrow +hooks +hooktest +hookz hoops +hooyah hop hope +hoped hopefully hopen hopes hopf hopfalgcat hopfalgebra +hopfinvariant +hopfinvariantequiv +hopfinvariantpush +hopfjunior +hopfmap hopfobj +hopfs hopi +hoping hopncani +hopping hops hor +hora horcvdmsgs hord horder hordered +horec horel horelse horigin horiz +horizon horizontal horizontalcomp horizontalcompm +horizontally horizontalsegment horn horner +hornerc +hornercm +hornerd +hornerk +hornerm +hornermn +hornermx +hornermxaddc hornermz +hornern +hornerx +hornerxn +hornerxsubc +hornerz hornfilling +hornformula horninclusion +horrendously horrible horrific +horse +horses horun hos hoscl hoscli hosd +hosed hosmval +hospit +hospn host +hostenvironment +<<<<<<< Updated upstream +======= hostiletoearthlife +>>>>>>> Stashed changes +hostp hosts +hostsl hosub hosubadd hosubcl @@ -34168,29 +56627,45 @@ hosubsub hosval hot hotel +hothing hothmname hots hottme hou +houjld +hour +hours house hout +houtcome +houter houtlen houv hov hover +hovera +hoverb +hovercncf +hovergt hoverinfo +hoverlt hovers hovh how +howard however +howmany hox hoxy hoy hpa hpab hpair +hpaire hpairwise hpapb +hpartdiff +hpartial hparts hpath hpb @@ -34198,14 +56673,18 @@ hpbar hpbnd hpbot hpc +hpcore hpd hpdeg hpdegc hpdf hpdvd hpe +hpeek hper hperm +hpermi +hpermj hpf hpg hpgb @@ -34221,13 +56700,17 @@ hphl hphqh hpi hpid +hpidp hpij +hpind hpirr hpj hpk +hpke hpl hpla hpljkgzsy +hplus hpm hpmap hpmapf @@ -34238,6 +56721,8 @@ hpmn hpmo hpmon hpmonic +hpmssexl +hpmsslambda hpmxertbjdzey hpn hpne @@ -34251,7 +56736,9 @@ hpoint hpoly hpop hpos +hposloop hpossrc +hpost hpostar hpostcomp hpow @@ -34263,6 +56750,8 @@ hpqf hpqi hpqr hpr +hpre +hprecise hprecomp hpres hpri @@ -34274,13 +56763,18 @@ hprod hprods hprodz hproof +hprop +hpropext +hproptype hprx hps hpsa hpt hptop hptr +hptrs hpu +hpub hpull hpunique hpure @@ -34322,16 +56816,22 @@ hqreq hqs hqt hqu +hqual hquot hqv hqw hqx hqy +hqymrtx hqz hqzero hra +hracy hrange +hrangei +hrangej hrank +hrat hrb hrc hrclopen @@ -34339,6 +56839,10 @@ hrcountable hrd hre hreach +hread +hreadable +hreadyout +hreal hrec hrecb hrecf @@ -34349,11 +56853,18 @@ hrecon hrecp hrecx hrecy +hredex +hreduce +hreduces hrefl hreg hregs +hregset hrel +hrelation hreltype +hremc +hrems hren hrep hrepk @@ -34361,13 +56872,22 @@ hrepv hres hreseed hresi +hresp +hrest +hrestri hrestrict +hrestriction +hrestrj +hresults +hresume +hret hrf hrg hrgjj hri hright hrinj +hrinv hrirred hrj hrjac @@ -34375,7 +56895,9 @@ hrk hrl hrlyfjcf hrm +hrmap hrmem +hrmn hrmop hrn hrnd @@ -34392,20 +56914,27 @@ hrq hrr hrrhpamesddujenmibnqf hrs +hrsi hrsij hrss hrsy hrt hru +hrule +hrutt hruv hrv hrvw hrw hrx +hrxefdm hry +hryniewiecki +hryp hrz hsa hsafe +hsafef hsafes hsalsa hsat @@ -34413,8 +56942,10 @@ hsb hsbt hsc hscard +hscb hsched hschedn +hscheds hsclos hsclosed hscomp @@ -34425,10 +56956,18 @@ hscount hscp hscv hsd +hsdata hse +hsearch hsec +hsel +hselv +hsem +hsentence hsep +hseparated hseq +hserv hset hsetbuffering hsezb @@ -34442,26 +56981,37 @@ hsgone hsh hsha hshc +hshi hshiftleft +hshm hshmd +hsho +hshould +hshrink +hshs hsi hsic hsig +hsigma +hsigmai hsign hsim +hsimpl +hsimres hsimweak hsin hsinabc hsinf hsing +hsingle hsint hsize hsj hsjac hsk -hskp hsl hslice +hslvsplt hslzero hsm hsmax @@ -34476,13 +57026,16 @@ hsne hsnemp hsnfg hso +hsolutions hsome hsone +hsort hsorted hsot hsource hsp hspace +hspacestructure hspan hspc hspdifhsp @@ -34494,9 +57047,12 @@ hsphoival hspl hsple hsplit +hsplitx +hsplity hspmbl hspmbllem hspsmdqbpeftkvkxukh +hspv hspval hsq hsqr @@ -34515,6 +57071,7 @@ hstab hstable hstablef hstar +hstart hstartballot hstcl hstd @@ -34544,8 +57101,12 @@ hsu hsua hsub hsubgraph +hsubmxk hsubn hsubset +hsubsetce +hsubsetd +hsubseti hsubsingleton hsubst hsubw @@ -34578,13 +57139,21 @@ hsxps hsxy hsy hsym +hsymbs hsymm hsymmpart +hsync +hsynced +hsynchronized hsyz hsz hta +htable +htables +htai htail htalem +htape htarget htaylor htb @@ -34609,16 +57178,21 @@ hteq hteqv hterm hterms +htest htf htfae htff htfin htg +htgt htgx hthic +hthis +hthread hti htid htime +htimes htj htk htl @@ -34633,10 +57207,13 @@ htn htne hto htofin +htole htone htop +htopspace htors htorsion +htotal htp htpos htpy @@ -34649,12 +57226,24 @@ htpyid htq htr htrace +htraceinj +htrans +htransfer +htransm +htransv htransvec htree +htriple htris htriv htrue +htruepost +htruepostcond hts +htset +htseti +htsim +htsiml htstep htsymm htt @@ -34679,6 +57268,7 @@ htz hua huat hub +hubandspoke hubs huc hucard @@ -34688,12 +57278,24 @@ hucover hud hue hueq +huet +huets huf +huff +<<<<<<< Updated upstream +======= huffma +>>>>>>> Stashed changes huffman hug huge hugely +hugemagma +hugeneg +hugenegscale +hugepos +hugeposscale +hugetest hughes huh hui @@ -34712,25 +57314,41 @@ human humanreadable humans hun +hunapply hunc hundef hundred +hundredths hune +hung +hungarumlaut hunif hunion huniq hunique hunit huniv +hunlift +hunmapped hunormal +hunt huntington huntsands huo huone huopen hup +hupd hupos hur +hurd +hurewiczhomab +hurewiczmap +hurewiczmapcofibequiv +hurewiczmapnat +hurewicztheorem +hurt +hurts hurwitz hurwitzevenfepair hurwitzkernelbounds @@ -34740,7 +57358,6 @@ hurwitzzetaeven hurwitzzetaodd hus husable -husband huseful husf husing @@ -34750,6 +57367,9 @@ husub husup husx hut +hutm +hutmpf +hutter hutu huu huv @@ -34776,8 +57396,12 @@ hvaddsubass hvaddsubval hval hvalid +hvalidb +hvalidt +hvalk hvals hvaluegroup +hvar hvassi hvb hvbf @@ -34794,8 +57418,10 @@ hvec hvertexoperator hveven hvf +hvg hvi hvieta +hvihvec hvij hvint hvisopen @@ -34836,6 +57462,8 @@ hvnoiso hvo hvodd hvol +hvolatile +hvold hvopen hvortho hvp @@ -34866,6 +57494,7 @@ hvun hvv hvw hvx +hvxikhw hvy hvzk hwa @@ -34884,6 +57513,7 @@ hwg hwh hwi hwin +hwindows hwit hwl hwle @@ -34895,9 +57525,11 @@ hwo hwp hwq hwr +hwritable hwritteninextend hws hwsh +hwsv hwt hwu hwun @@ -34916,6 +57548,7 @@ hxbd hxbound hxc hxclosure +hxcomp hxcq hxd hxdi @@ -34928,6 +57561,7 @@ hxf hxfg hxg hxh +hxhytij hxi hxij hxim @@ -34985,14 +57619,19 @@ hxzxy hxzy hya hyb +hybconcsem hybrid hybridcoarsemachine +hybridfinemachine hybridmachine hybridmachinesig +hybridsem hybridstep hyc hyd hydisj +hydra +hydrocarbon hye hyf hyg @@ -35011,37 +57650,85 @@ hyne hyp hypa hypb +hypbdd +hypbox +hypboxes +hypboxp hypcgr hypcgrlem hyper hyperassertion +hyperb +hyperbola hyperbolic hypercall +hypercube +hypercubes hyperdual hypere +hyperendo hyperface hyperfilter +hyperg hypergraph hypergraphi hyperlink +hyperlive +hyperliveness +hypermap +hypermaps +<<<<<<< Updated upstream +======= hypernym +>>>>>>> Stashed changes hyperoperation +hyperp hyperplane hyperplanes hyperpolymath +hyperprop +hyperprope +hyperproperties +hyperproperty +hyperpropi hyperreal +hypersafety +hypersat +hyperspec +hyperstack hyperun +hypfn +hypfrg hypfvar +hyphen hypj +hypk +hypm +hypn +hypo hypograph +hypos hypot +hypotenuse +hypotesis +hypothes +hypothese hypotheses hypothesis hypothesisgoal +hypothesizing +hypothetical +hypp +hyppair hyppriority +hyppub hypq hyprel +hypresult hyps +hypset +hypsp +hypterm hyptype hypvalue hyq @@ -35050,6 +57737,7 @@ hys hysy hyt hyu +hyuazse hyv hyw hyx @@ -35069,6 +57757,7 @@ hzdvdu hzdvdv hze hzero +hzh hzi hzim hzinj @@ -35096,46 +57785,104 @@ hzy hzz iaa iabcd +iabs iac +iacc +iaccv +iack +iacr iaction iactioni +iad +iadd +iaddf +iaddi +iaddl +iaddrsize +iadv iae iaf iagree iagreement +ialg +ialgr +ialgrlem +ialgrlemconst +ialgv +ialist ialls +iaload +ialph +ialpha ialt iam iamhc +iamvoid ian iand +iannot ianor +ianordc +ianorr +iants +<<<<<<< Updated upstream +iap +======= iantwerp +iap +iapc +>>>>>>> Stashed changes iapp +iappend iapply +iarg iargs +iarr iarray iarrays +iasmstate +iassign +iassoc +<<<<<<< Updated upstream +======= iation iatom iauto -iaxiom +>>>>>>> Stashed changes +iavg +iavgd +iawscryptographicmaterialprovidersclient +iawscryptographicprimitivesclient +iawsencryptionsdkclient iba +ibackchain ibar ibas +ibb ibc ibcom ibd ibdc ibdr +ibeq +ibeqf +ibet ibgni +ibgt +ibgtf ibi ibib ibibr ibifibrantresolutio ibifibrantresolutionobj +ibij +ibilsepand +ibind +ibinop +ibinopdefuniq ibir ibit +ibitwise ibl iblabs iblabslem @@ -35152,10 +57899,11 @@ iblcnlem iblconst iblconstmpt ible +iblef iblempty +iblen ibliccsinexp iblidicc -ibling ibliooicc iblioosinexp iblitg @@ -35174,17 +57922,43 @@ iblss iblsub iblsubnc iblulm +ibm +ibne +ibnef +ibnint +ibnn +ibody iboi +ibool ibounded +ibp +ibpcp +ibr +ibranch +ibranchf ibrcom ibs +ibsm +ibss ibt +ibuf +ibuiltin ibut +ibv ibwt ibwtn +ibzwffh +icache +icall +icanbarelyseeit +icancel +<<<<<<< Updated upstream +======= icar +>>>>>>> Stashed changes icard icat +icb icc iccbnd icccld @@ -35280,13 +58054,25 @@ iccval iccvolcl iccvonmbl iccvonmbllem +<<<<<<< Updated upstream +icecream +icenter +======= ice +icecream +icenter icewine +>>>>>>> Stashed changes icf +icfn icfp ich ichal ichan +ichar +ichareqv +icharlist +icharlisteqv ichbi ichbidv ichcircshi @@ -35307,14 +58093,24 @@ ichnreuop ichoose ichreuopeq icht +ichurch ichv ici icibot +icid iciextend icissuphom icisuphom +icjump icl +iclause +iclist +iclose +<<<<<<< Updated upstream +======= iclval +>>>>>>> Stashed changes +icnpimaex ico icobrsiga icocncflimc @@ -35327,11 +58123,15 @@ icogelb icogelbd icoicc icoiccdif +icol icoltub icoltubd icombl icomnfinre icomnfordt +icomp +icompare +icompile icon icondindep icondindepfun @@ -35339,6 +58139,12 @@ icondindepset icondindepsets iconfig icong +icongruence +iconj +icons +iconset +iconst +iconstf iconstr iconv icoopn @@ -35356,6 +58162,7 @@ icoreresf icoresmbl icoreunrn icoreval +icosahedron icoseg icoshft icoshftf @@ -35369,17 +58176,23 @@ icoun icount icoval icp +icplusconst +icrit +icritt ics icstate +icterm ictqzcwpzzazifsmic ictx ictxt icu +icut icvvh icycles icyclesiso icyclesnattrans ida +idabs idacd idadj idadm @@ -35387,13 +58200,32 @@ idaf idafval idahom idalt +idapplicative +idarr +idata +idates idaval +idbezal +idbiinv idbl +idbool +idbuddy idc +idcalgequiv +idcalghom +idcat +idcatiso +idcellmap +idchainmap +idchar +idclo idcn idcncf idcncfg idcnop +idco +idcode +idcodes idcofork idcomp idcompid @@ -35404,10 +58236,13 @@ idcomputer idcoverpreserving idd iddii +iddistlatticehom +iddiv iddvds iddvdsexp ide idea +ideafwd ideal idealcomaporderiso ideald @@ -35416,11 +58251,15 @@ idealfactorsequivofquotequiv idealfactorsfunofquothom idealfilter ideali +ideality +idealized idealizer ideallattice ideallatticebasis ideally idealmap +idealmr +idealnotation idealof idealofcofinals idealofempty @@ -35429,69 +58268,140 @@ idealofset idealofvars idealopensgi idealoperations +idealp idealpowersdiagram idealpowerstoselfleradical idealprodequiv idealquotientmk idealquotienttoringquot +idealr idealrange +idealrbe +idealrde +idealrm ideals idealset idealsetequiv idealsetequivnorm idealsetmap idealsheafdata +idealsin idealspan idealto idealx +ideaoperationa +ideaoperationb +ideaoperationc +<<<<<<< Updated upstream +======= ideateof +>>>>>>> Stashed changes +idecls +idecode ideduct +idefct idel +idelementwise idem idemb idemcommsemiring idemfst +idemi +idemnull +idemo idemp +idempo idempot +idempote idempotence idempotency idempotent idempotentcommutativemonoid +idempotentency idempotentfun +idempotentl idempotentmagma idempotenton idempotentop +idempotentr idempotents idempotentsemiring idemsemiring idemsnd iden ident +identd identdistrib +identi identical identically +identidad +identidades +identif identification +identifications identified identifier +identifierp identifiers +identifies +identifiy identify identifyiccends identifying +identit identities identity +identityfunctor +identityishomomorphism +identitykripkeintuitionisticmodel +identitylemma +identitymap identitymapofzeromoduleiszero +identitymodality +identityonobjects +identityprinciple +identitystr +identitysystem +identityt identityto +identitytoken +identives +identlower +identmixed +identmonad idents +identt +identupperlower +identy +idep idepi ideq ideqb ideqg ideqgalt +idequiv +idequivsnaturality ider +ideriv +idesc +idex +idexpr +idexprlist idf idffth +idfincellapprox +idfincellmap +idfinchainmap +idfins +idfinsequencemap idfn +idfnap +idfnaplemma +idfnpfntype +idfntype idfork +idfront idfth idftor idftorftor @@ -35500,17 +58410,24 @@ idfucl idfudiag idfullsubc idfun +idfunap idfunc +idfuntype idfurcl idfusubc idfuval idfv +idg idgfun idghm +idgroupequiv +idgrouphom +idgroupiso idgroupoid idhe idhmeo idhmop +idhom idi idialt ididg @@ -35524,12 +58441,24 @@ idinxpresid idinxpss idinxpssinxp idiom +idiomatictransform +idiomatictransformation idioms +idir +idisequiv idiso +idispathsplitequiv idispolyi +idispr +idiv idivd +idivstep +idj +idkex +idkssvvk idl idladdcl +idlatticehom idlaut idlbas idlcl @@ -35537,18 +58466,24 @@ idlcpbl idlcpblrng idldil idle +idlei idlelb idlelbas idlem +idlemarksweep idlemn idleop idlgen +idli idliftscocone idliftscone idlimc +idling idlinsubrg +idlist idllidld idllmulcl +idlmex idlmhm idlmulssprm idlnegcl @@ -35556,8 +58491,10 @@ idlnop idlnsg idlqus idlqusb +idlr idlridld idlrmulcl +idlsize idlsrg idlsrgbas idlsrgcmnd @@ -35579,7 +58516,10 @@ idlsubgsubrng idlsubrng idltrn idlval +idlvalg +idlvalid idm +idmap idmatidpmat idmcl idmgmhm @@ -35588,12 +58528,24 @@ idmon idmonad idmot idmp +idmxe idn +idnattrans +idnattranscompdefcod +idnattranscompdefdom +idnattransmapl +idnattransmapr +idnattransnattrans +idnaturality +idneg idnghm idnmhm idnsgd +ido idom idomain +idomainaxiom +idomainmixin idomaintype idomcringd idomdomd @@ -35608,17 +58560,36 @@ idomringd idomrootle idomsubgmo idomsubr +idopt +idoptv +idot idp +idpath +idpathsinunaturality +idpefct +idpl idpm idpn idpr idpredicates +idprl +idprod idprodmaphomotopycategorycompinverseiso +idproprel +idpru +idq +<<<<<<< Updated upstream +======= +idqa +idqb +>>>>>>> Stashed changes idqtop idr +idrc idref idrefalt idrel +idren idres idresefmnd idreseq @@ -35632,11 +58603,23 @@ idressubmefmnd idrestrgroupoid idrhm idris +idrl +idrnet idrng idrnghm idrval ids +idseq +idsequenceequiv +idsequencemap +idset +idsexp +idshom +idsiso +idsize +idsmap idsok +idsp idsr idsrngd idss @@ -35645,19 +58628,47 @@ idsset idssfct idssxp idstx +idsub idsubc +idsym idsymrel +idsys idt idtac +idtail +idtheta +idtm +idtoeq +idtoeqs +idtoequiv +idtofun +idtoid +idtoiso +idtoken +idtopie +idtr +idtrans idtransformation +idtrbits idty +idub iducn idunop idv +idval idvr +idwildfunctor +idwildnattrans idx +idxaddr +idxadrr idxd +idxe +idxed +idxes +idxfix idxfun +idxhash idxi idxof idxq @@ -35665,101 +58676,223 @@ idxqnew idxs idxsame idxtoatom +idyn idz idzeroequivisozero +iea +ieb iedf iedg +iedge iedgedg +iedgedgg +iedgex iedginwlk iedgval +iedgvalg iedgvalprc iedgvalsnop iedv iee ieee +ieexprin +ieexpriz +ieexprn ief iegf +ieieep ieii ielefmnd +ielim +ielts +iemap +ieme +ien +ienc +iencod +iencode +iencoding +iencodingp +ient +ienv +ienvt +ieq +iequal iequiv +iequivalent +ierror +ieval ievents +ievery iexec +iexists +iexp iexpcyc iexpire +iexpn +iexpo +iexpof +iexpr iexs iexsunique -iext ifa +ifab iface ifaceany +ifacefalse +ifaces +ifact ifactm ifactme +ifactorial ifail +<<<<<<< Updated upstream +======= ifalse +>>>>>>> Stashed changes +ifalt +ifalternative ifan +ifandc +ifazims ifb +ifbase +ifbd +ifbetwn ifbi ifbid ifbieq ifboth ifbothda +ifbothdadc +ifbothdc ifc +ifcase ifce +ifces ifchhv ifcl ifcld ifclda +ifcldadc +ifcldcd ifcli ifcomnan +ifcomp +ifcontrthenunitl ifd +ifdef +ifdmonotone ife ifel +ifelim +ifelpwun +ifelpwund +ifelpwung +ifelse +ifelsefalse +ifelsetrue ifeq ifeqda +ifeqdadc ifeqeqx ifeqor +ifetch ifex ifexd ifexg ifexi +ifexp iff iffalse iffalsed iffalsei +<<<<<<< Updated upstream +======= iffalseprop +>>>>>>> Stashed changes +iffb iffd +iffdec +iffe +iffexi +iffexist +iffh iffi +iffimp +ifflat +ifflhs ifflr ifflrn iffofeq iffp +iffps +iffrefl +iffrhs iffrl iffrln iffs iffsetoid +iffsets +iffsym +ifft +ifftrace +ifftrans iffuip iffv +iffy +ifgoto +ifgt ifhvhv +ifi ifid +ifiddc +ifidss +ifields ifif ififc ifim ifin +ifindent +ifinite ifix +ifixequiv ifjump +ifk ifkg +ifl +iflags +iflat ifle +iflgt +ifloor +ifm +ifmap +ifmdc +ifmem +ifmi +ifmode +ifmp ifmpt ifn ifnebib +ifnebibdc ifnefals ifnefalse ifnetrue +ifnetruedc ifnmfalse ifnot +ifnotdc +ifnt ifnz +ifnzp +ifo ifopt ifor +ifordc +iforest +iforestf ifov ifp ifpan @@ -35769,19 +58902,23 @@ ifpbi ifpbibib ifpbicor ifpbiidcor +ifpdc ifpdfan ifpdfbi +ifpdfbidc ifpdfnan ifpdfor ifpdfxor ifpfal ifpid +ifpiddc ifpidg ifpim ifpimim ifpimimb ifpimpda ifpimpr +ifpmonotone ifpn ifpnancor ifpnannanb @@ -35789,39 +58926,74 @@ ifpnim ifpnorcor ifpnot ifpnotnotb +ifpnst ifpor ifporcor ifpororb +ifport +ifports ifpprsnss +ifpprsnssdc ifpr ifprop ifpsnprss +ifptr ifptru ifpxorcor ifpxorxorb ifqy ifr +ifrec +<<<<<<< Updated upstream +======= ifred +>>>>>>> Stashed changes +ifresh ifrom +ifrp ifs +ifsacs ifsb +ifsbdc ifsc ifscgr +ifscope +<<<<<<< Updated upstream +======= ifsingleton +>>>>>>> Stashed changes +ifso +ifsp ifssun +ifstmt ift ifte +iftest ifthenelse +ifthenelseh iftrue iftrueb iftrued iftruei +<<<<<<< Updated upstream +======= iftrueorfalse iftrueprop +>>>>>>> Stashed changes +ifu +ifuel ifun +ifunbind +ifuncdefuniq +ifunf ifval +ifvoid +ifwhilealgebra +ifxfinsequence ify ifz +ifzero +igabs igabscongs igabscongsstr igabscongu @@ -35830,6 +59002,7 @@ igabsipresigwls igabsipresigwlsstr igabsren igabsrenstr +igalg igamcl igamf igamgam @@ -35838,45 +59011,83 @@ igamval igamz igb igba +igbai +igbav igbg igbgi +igcd igconsipresigwls igconsipresigwlsstr +igdpr ige igenidl igenmin igenss igenval iget +igfresh +igfreshabs +igfreshbinp igfreshcls igfreshclsstr igfreshigabs igfreshigop igfreshigopstr +igfreshigvar +igfreshinp igfun +<<<<<<< Updated upstream +======= ighent +>>>>>>> Stashed changes +igi igid +igleft ign +ignited +igno +ignor +ignorable +ignorables ignore ignoreargsattr ignorebranch ignored +ignoredp +ignorefuel ignorefunction ignorei +ignorel +ignoreparams +ignoreparamsispr +ignorer ignores ignorestucktc ignoretactickinds ignoretactickindsref ignoretcfailures ignorevariable +ignorezero ignoring +igop igopipresigwls igopipresigwlsstr +igors +<<<<<<< Updated upstream +======= igpath +>>>>>>> Stashed changes +igraph +igright +igsubst +igsubstabs igsubstabsipresigwlsabs igsubstabsipresigwlsabsstr igsubstallipresigwlsall igsubstallipresigwlsallstr +igsubstbinp +igsubstbinpipresigwlsbinp +igsubstbinpipresigwlsbinpstr igsubstcls igsubstclsstr igsubstigabs @@ -35884,29 +59095,58 @@ igsubstigabsstr igsubstigop igsubstigopstr igsubstigvar +igsubstinp igsubstinpipresigwlsinp igsubstinpipresigwlsinpstr igsubstipresigwls igsubstipresigwlsstr +igsumval +igsumvalx +igswap +igswapabs igswapabsipresigwlsabs igswapabsipresigwlsabsstr igswapallipresigwlsall igswapallipresigwlsallstr +igswapbinp igswapbinpipresigwlsbinp +igswapbinpipresigwlsbinpstr igswapcls igswapclsstr igswapigabs igswapigabsstr igswapigop igswapigopstr +igswapigvar +igswapinp igswapinpipresigwlsinp igswapinpipresigwlsinpstr igswapipresigwls igswapipresigwlsstr +igt +igtok +igtree igu +igual +igualdad +iguales +igvalue +igvar +igvaripresigwls +igwls +igwlsabs +igwlsabsdisj +igwlsabsisinbar +igwlsalldisj +igwlsbinp +igwlsdisj +igwlsinp igz iha +ihalf +ihalt iharr +ihaves ihb ihc ihclos @@ -35916,6 +59156,7 @@ ihdat ihds ihdsts ihe +ihead ihentries ihep ihes @@ -35962,6 +59203,9 @@ ihrefl ihrel ihrl ihs +ihse +ihsex +ihsext ihsigma ihstepn ihstepstar @@ -35983,6 +59227,9 @@ ihys ihz ihzs iia +iiae +iiai +iib iic iicextend iicf @@ -36003,23 +59250,33 @@ iidm iidn iif iiface +iifce iifcnv iifcv iifhmeo iifhom iifiso iifmhm +iig iihalf iii +iiia +iiib +iiic +iiid +<<<<<<< Updated upstream +======= iiii +>>>>>>> Stashed changes iiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiii iiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiii iiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiii iiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiii -iiioi -iiioiii iij iillysconn +iim +iimage +iimm iimp iimplies iimulcl @@ -36030,6 +59287,7 @@ iinab iinabrex iincld iinconst +iinconstm iindep iindepfun iindepset @@ -36039,17 +59297,21 @@ iine iineq iineqconst iiner +iinerm iinexd iinexg +iinexgm iinf iinfconstbas iinfconstbaslem iinfi iinfkerprojequiv +iinfmodel iinfo iinfprg iinfssc iinfssclem +iinfstruct iinfsubc iinglb iinhoiicc @@ -36062,6 +59324,7 @@ iinopn iinpreima iinpw iinrab +iinrabm iins iinss iinssd @@ -36071,8 +59334,11 @@ iinssiin iinssiun iinte iinter +iintersection +iintree iinun iinuni +iinuniss iinv iinvdif iinxp @@ -36080,43 +59346,121 @@ iinxprg iinxsng iio iiold +<<<<<<< Updated upstream +======= iiooi +>>>>>>> Stashed changes +iiord +iiordk +iiota +iip iipr iirev iirevcn +iirr +iirrc +iirre +iirrel +iirrer +iirrk +iirrkeq +iirrkv +iis iisconn +iisl iisortho iistmd +iisuc +iit iitop iitopon iiuni iix ijcount +ijeq ijh iji ijk +ijlt +ijnil +ijoin +ijoinable ijs +ijth +ijump +ijx +ikeystoreclient +ikeyvectorsclient ikfoexmjexnv ikhoiaetwlvcaniohls +ikim +<<<<<<< Updated upstream +ikkbz +ikm +ikmlen +======= ikinnock ikkbz ikm +ikmlen iknows +>>>>>>> Stashed changes ikogfcbkxrgrquxvbffomx +ikv ila ilam +ilambda +ilambdad +ilcs ile ilem +ilemma ilength ileq -iless ilf +ilfun +ilfunc +ili +iliaei +iline +ilist +ilistilistnode +ilistnode +ilk +ilks ill +illater +illaterfunops +illaternat +illaternatops +illaterpreops +illeg illegal +illegalargument +illegalbreaks +illegalreturns +illformed +illoperators +illtyped +illust +illustr illustrate +illustrated +illustrates illustrating illustration +illustrative iload +ilog +ilogic +ilogicfunc +ilogicops +ilogicvlogic +ilops +ilopsvlogic +iloption +ilpre +ilprefrm ils ilsm ilt @@ -36127,6 +59471,7 @@ imacmp imacnv imacnvcnv imaco +imacok imacosupp imacrhmcl imadd @@ -36134,6 +59479,7 @@ imaddd imaddgrouphom imaddi imadif +imadiflem imadifss imadifssran imadifxp @@ -36166,19 +59512,39 @@ imafiold imafv imag image +imageandsurjection imagebasicopen +imagecc imagecomplement imagecomplementincl +imaged imagee +imageeq +imageequivalence +imageex +imageexg +imagef imagefactorisation imagefactorisationzero imagefactorization +imagefamily imageforgetadj imagegram imagehom imagei +imageid +imageideal +imageim +imageinclusion +imageisimage imageisoimage imageisorange +imagek +imagekeq +imagekex +imagekexg +imagekrelk +imagel imagemap imagemapcomp imagemapid @@ -36188,6 +59554,8 @@ imagemonoidhom imagemonoisosource imagemonoover imagemulhom +imagen +imageo imageobjiso imageof imageofdf @@ -36195,10 +59563,12 @@ imageofinjon imageonehom imageopop imageopunop +imageord imagep imagepi imagepreimage imageprodlex +imager images imagesieve imagesset @@ -36207,39 +59577,61 @@ imagesubobject imagesubobjectcompiso imagesubobjectiso imagesubobjectmap +imaget imagetoker imagetokernel +imageu imageun imageunopop imageunopunop imageval imagezero imaginary +imaginaryce imaginarypart +imagine +imagines imagining +imagp +imagpa +imagpart +imagx imai imaid imaidfu imaiinfv imain imaindm +imainlem imainrect imainss imaiun +imakeq +imakex +imakexg imam imambfm iman +imandc +imanim imanonrel +imanst imaopab +imap +imapcommonusecase imapss +imaptest imarnf imasabl imasaddf imasaddflem +imasaddflemg imasaddfn imasaddfnlem +imasaddfnlemg imasaddval imasaddvallem +imasaddvallemg imasbas imasds imasdsf @@ -36249,12 +59641,14 @@ imasetpreimafvbij imasetpreimafvbijlemf imasetpreimafvbijlemfo imasetpreimafvbijlemfv +imasex imasf imasghm imasgim imasgrp imasgrpf imasip +imasival imasle imasless imasleval @@ -36267,6 +59661,7 @@ imasmulf imasmulfn imasmulr imasmulval +imasn imasncld imasncls imasng @@ -36289,15 +59684,19 @@ imasubc imasubclem imasval imasvalstr +imasvalstrd imasvsca imasvscaf imasvscafn imasvscaval +imat imaundi imaundir imauni imax imbal +imbalance +imbedding imbi imbibi imbitrdi @@ -36315,6 +59714,7 @@ imcli imclm imcn imcncf +imcuc imd imdf imdi @@ -36329,32 +59729,76 @@ imdistanda imdistani imdistanri imdiv +imdivap +imdivapd imdivd +imem imf +imfin +imfset +imfsete +imfsetp img +imgp +imgs +imgu imi +imid imim imimorb +imimorbdc imin +iminmodel +iminus iminvid iminvval +imiso imitates imj imk imkb iml +imlang +imlies imlm imlmhm +imlplies imm +immaterial +immdepgraph +immdeps +immed +immedia +immediat immediate immediatedeps immediately +immediates +immediatesubtrees +immedidate +immedimate immersion +immersiona immersionatprop +immersions +immidiate +immine +imminen +imminent +imml +immn +immobile +immr +immreg +imms immul immuld immuli +<<<<<<< Updated upstream +======= immunity +>>>>>>> Stashed changes +immutable imn imnan imnand @@ -36363,42 +59807,63 @@ imnani imneg imnegd imnegi +imnimnn imnot +imnothing imo imod imodb +imodular +imonlyds imor +imordc imori +imorr imorri imp impa impac impact +<<<<<<< Updated upstream +======= impacting +>>>>>>> Stashed changes +impall impancom +impap imparrow impb impbi impbid impbida impbidd +impbigstepsemantics impbii +impc impce impchain impcom impcombi impcomd impcon +impcos impd +impdec impdi impdir impdirp +impdown impe impel impelim -impelling impembedding +impendi +impending +impenv imperative +imperativeprogramminglanguage +impex +impexce impexp impexpbicom impexpbicomi @@ -36407,37 +59872,62 @@ impexpbicomvd impexpd impexpdcom impexpvd +impforall impfrom +imph impi impia impib +impidc +impies impiff impimprbi impimpsimp impintro impl +implauth +implauthset +implb implc +implconfid +implconfidset +implconstructor +impld impldetail imple implem implement +implementatio implementation implementationdetails implementations implemented implementing +implementinterface implements +implementse +implementsi +implementsp +imples impli implic +implicant +implicants implicate implicated implicates +implicati implication implicationhyp +implicationmonotonic implications +implicationunsized +implicative implici implicit implicitbinder +implicitconversions +implicitdecreases implicitdefeqproofs implicitderiv implicitfunction @@ -36446,81 +59936,162 @@ implicitfunctiondataofcomplemented implicitfunctiondataofproddomain implicitfunctionofcomplemented implicitfunctionofproddomain +implicitfunext implicitly +implicitmodifiesclause implicitreducible implicits implicittoopenpartialhomeomorph implicittoopenpartialhomeomorphofcomplemented +implicity +implict +implie implied implies +impliescollinear +impliesdef +impliesdistinct +impliesidentity +impliesimplies +impliesinequality +<<<<<<< Updated upstream +======= impliesnot +>>>>>>> Stashed changes +impliesp +impliespn +impliest +impliesvalid +implinsec +implinsecset +implis impllib implmaxdepth +implmented implode +implodes impls +implsecure +implsecureset implt imply +implyadd +implyb +implybb +implybe +implybf +implybn +implybnn +implybt +implye +implyfb implying +implynb +implynn +implynp implyp +implypn +implypp +implytb +impmapnodom impmods impnot impor import +importance important importantly +importarn importcandidates imported +importeditemcount importedrewritelemmasext importerrordata importfintypeoffinitenote importgraph importinfo importing +importkeymaterialensurespublicly +importlist importlt importm importmatches importnames +importnexttoken +importpart importpath +importresult imports importsbelow importssofar importstx +importtableensurespublicly importtree impose imposes imposing +imposs impossibility +impossibl impossible impp imppost +imppostd +impposte +imppostf +imppostv +impprog impproof impr impractical +imprecise +impredicative +impredicativity +imprefl imprim +imprinvert improper +improperly improve improved +improvedheuristicsmakethisverify +improvement +improverowstrick improves improveuntil improveuntilaux +improving imps impsingle +impsmallstepsemantics impstate impt impto +imptrans +impure impvd imr imre ims imsdf imsdval +imseparation +imset +imsete +imseti +imsetp +imsets +imsett +imsetu imsm imsmet imsmetlem +imspheremap imsqrtval imsqrtvalex imsub imsubd +imsubgroup imsval imsxmet imsym @@ -36528,6 +60099,9 @@ imt imtr imtrdi imtrid +imul +imulf +imult imv imval imvd @@ -36537,10 +60111,18 @@ imzsvxnfuwkael ina inab inabs +inac inacc inaccessible +inaccurate inaccw inaction +inactive +inaddi +inaddia +inaddib +inaend +inaendk inaex inaff inagflat @@ -36548,12 +60130,19 @@ inaghl inagne inagrud inagswap +inalist +inallp +iname +inangle +inapplicable +inappropriate inaprc inar inarc inass inatom inatsk +inauto inawina inawinalem inb @@ -36562,27 +60151,60 @@ inbinade inblocks inbound inbounds +inbox +inboxq inc +inca +incaddr incat +incb +incbv +incc incenter +inceverything incexc incexclem +incf +inch +inci +incic +incid +incida +incidb incidence incidencealgebra +incidencef incidencefi incidencefinset incidenceset incidencesetequivneighborset incidencesetfintype incident +incidentally +incidentde +incidentl +incidentlp +incidentp +incidl +incidlp +incidp +incinideal +incirc +incirccenter +incircle +incircles incistruhgr incl +inclass inclcompinclusion inclcompmap incld incldesc +inclevel inclfusubc inclhomequiv +inclined +inclist inclleft inclleftcompopequivinverse inclleftcomprightopopequivfunctor @@ -36594,24 +60216,34 @@ incllifttoinitial incllifttoterminal inclosed inclosure +inclposet +inclr inclright inclrightcompopequivinverse inclrightcomprightopopequivfunctor inclrightfaithful inclrightfull inclrightfullyfaithful +incls +inclsub +inclu +includ include included +includedi includeimplementationdetails includeleft includeleftringhom includeleftsubright +includemod includeright includes includesynth +includet including inclus inclusi +inclusio inclusion inclusionbool inclusioncompfunctortocoreiso @@ -36632,21 +60264,49 @@ inclusionspan inclusiontopiso inclusionwalkingreflexivepair inclusionwalkingreflexivepairofisreflexivepairiso +inclusive +incm incmatrix +incn +incnorm +incnr +inco +incoherentweakunivalence incom incoming +incomingedges +incomingre +incomingrequest +incomingresp +incomingresponse incomp incompact incomparability incomparable +incomparer +incompat +incompatib +incompatibility incompatible +incompatibleclasschangeerror +incompl +<<<<<<< Updated upstream +======= incomplementunionimpincomplement incomplementunionimpnotin +>>>>>>> Stashed changes incomplete +incompleteness +incomponents incomprel incompute +incon +<<<<<<< Updated upstream +======= incongp +>>>>>>> Stashed changes incons +inconsistencies inconsistency inconsistencyautomatic inconsistencyinteractive @@ -36656,13 +60316,41 @@ inconsistentprefix incontext inconvenience incoordinates +incorp +incorporate +incorporating +incorporation +incorrec incorrect +incorrectify +incorrectifye +incorrectifyi +incorrectloop incorrectly +incorrectness +incorrectrawdatakeys +incoset +incosetl incounterm +incovfl incp +incpc +incpocp +incpok +incproj +incprojectiveplane +incprojmap +incprojsp +incprojstr incr +incratseq +incrdecr incre +increa +increaing +increas increase +increaseandreturn increased increases increasesteps @@ -36671,52 +60359,103 @@ increasi increasing increasingapproximateunit increasingbystep +increasingi +increasingjoinselfseparationalgebra +increasingp +increasingsa +increasingseparationalgebra +increasingsplitsmallerseparationalgebra increment incrementaccountcontracts incremental +incrementallboxes incrementally +incrementation +incrementchar +incrementcirc +incremented +incrementing +incrementoutput +incrementp increments +incrementse +incrementsi +incrementstr +incrf +incrfrom +incrfun +incri incrindexlist incrn +incroot +incrsa incrst incs +incsalary incseq +incseqd incsequz incsmf incsmflem +incsp +incspace incssnn +incstruct +incsubset +incur +incurs +incx ind inda indalem indalt +indata +indb indcardi indcoindiso indcoindnatiso indconst +indcore +indcpa indcthing indd +inddef inddlem inde indec indecomposable indecomposabled +inded indeed +indeednothing +indef +indefaultmodule indefinite indefinitedescription indefinitediagonal indefinitely +indegree +inden indent indentation indentd indented indentexpr +indents indep independant independece +independen independenc independence independent independently +independentp +independents +independentset +independientes +indepent +indepentdent indepfun indepi indepmatroid @@ -36729,51 +60468,99 @@ indepsetfree indepsetfreeon indepsets indepsetset +indeq +<<<<<<< Updated upstream +======= indeqs +>>>>>>> Stashed changes indet indeterminacies indets indetsi +indev index indexa +indexalg indexat +indexcollection indexcone indexd indexdom +indexe indexed +indexedcoproductof +indexedfamily +indexedintersection +indexedp indexedpartition indexedpreorder +indexedproductof indexedsetoid indexedunion +indexelem indexequiv indexequivallroots indexequivofinv +indexer indexes indexesof +indexesp +indexexpr +indexf indexfi +indexfn indexfunctor +indexg +indexgg +indexgi +indexgs indexhom +indexi indexin indexing +indexingimpliesmembership indexinglib +indexjg +indexk +indexkl +indexkr +indexl +indexlist +indexmg +indexname +indexnaturalitywithelem indexneg indexof indexofboundaryge indexofboundaryle +indexofcacheentry indexofhom +indexofoption +indexp indexrealunits +indexs indexseq +indexseqtouint indexset +indexsg +indexth +indextochar +indextochartoindex indextovertexlist +indexy indf +indfinseq +indfrom indfsd indfsid indfunctor indfval +indh indi indic indicat indicate +indicated indicates indicating indication @@ -36781,10 +60568,22 @@ indicato indicator indicatorconst indicatorconstlp +indicatorp indicators indicatrix +indicc +indice indices indicescorrect +indicesd +indicese +indicesi +indicesindomain +indicesp +indici +indicies +indicp +indict indif indifbi indifcom @@ -36794,15 +60593,24 @@ indiff indifference indifferent indifundif +indind +indint indir indirect indirection +indirections indirectly +indirlist +indis +indisc indiscernable +indiscernibility +indiscernible indiscld indisconn indiscrete indiscreteadj +indiscreteness indiscretetop indiscretetopol indiscretetopology @@ -36810,47 +60618,79 @@ indishmph indislem indiso indispconn +indispr +indist indistgp +indistinct +indistinguishability indistinguishable +indistinguishabled +indistinguishablei indistop indistopon indistps indistpsalt indistpsx indisuni +indiv individual +individuall individually -individuals individualterm +indivisible indization indlcim indlem indlesm indm indmap +indmapequiv indmet indmk +indmss indn +indnamememo indne indobjectpresentation +indoc +indom indomain +indomconcat +indomconstmap indomd +indome indomisnotundef +indomrestrict +indomupd indomwhenadd +indouble +indp indparallelpairpresentation indpi indpreima +indprinciple indpt +indrelationex +indrelationuniq indresadjunction indreshomequiv inds +indsc +indsch +indseq +indseqd +indseqs indset +indsimplegraphs indsn +indstmtexpr indstr indstrd +indsuc indsum indsumin indsupp +indsv indthinc indthincalt indtocoind @@ -36858,35 +60698,55 @@ indtocoindaux indtype indu induc +induccion induce induced inducedaddhom inducedbicategory inducedcategory +inducededges inducedequiv inducedequivalence +inducedesubgraph +inducedevsubgraph inducedfamily +inducedfun inducedfunctor inducedfunctorcompisoself inducedfunctorlinear inducedfunctorofequiv +inducedgraph +inducedhom +inducedhomvar inducedlawfuldayconvolutionmonoidalcategorystructcore inducedmap inducedmeasure +inducedmonoid +inducedmonoidpath inducedorderringhom inducedorderringiso inducedoutermeasure inducedpreorder +inducedquotientstr inducedrelation +inducedsource inducedstructure inducedstructureequiv +inducedsubgraph +inducedtarget inducedtopology +inducedvsubgraph +inducedwesubgraph +inducedwevsubgraph inducedwidecategory +inducedwsubgraph +inducedwvsubgraph inducees inducehom inducehomle inducehomofle induces +inducesquotientstr induceuniviso inducing inducingfn @@ -36898,8 +60758,11 @@ inductinfo inducting inductio induction +inductiona inductionexd inductionhyp +inductionhypothesis +inductionhypothesisprecondition inductionmut inductionobj inductionon @@ -36907,37 +60770,57 @@ inductiononrank inductiononrankaux inductiononwellorder inductionprinciples +inductions +inductionschema inductionsubgoal inductionup +inductiv inductive +inductivefinsatac +inductiveinv inductivelimit inductivelimitdist inductively +inductivepredicate inductivepremetric inductives inductivestep inductivesteprealization inductivesystem inductiveval +inductivity inductivized inductl +inductor inductr +inducttermi inductval -industrious indv indval indvmk +indx +indxseq +indxxx indyonedacontravariant indyonedacontravariantrightop indyonedacovariant indyonedacovariantop ine +ineaualities ineccnvmo inecmo +inedge inedges +ineffective +ineffectual +inefficient +ineg inegd +ineie inelcarsg inelcm +inelegant +inelem ineleq inelfi inelpisys @@ -36945,20 +60828,29 @@ inelr inelros inelsiga inelsros +inem ineq ineqan ineqcom ineqcomi +ineqm ineqmvtd ineqornotineq ineqpriority ineqri ineqs ineqtransd +inequ +inequa +inequaility +inequal +inequalit inequalities inequality +inequalitysymmetric inequalitytr inequalties +inequalty inequiv inert inertia @@ -36966,19 +60858,34 @@ inertiadeg inertiadegin inertiaequiv inertiagdeg +inertiaj inertiasubgroup +inessential +inevar +inevitable +inew inex +inexact inexactify inexeqex +inexg +inexplicit inf +infa +inface +infbranchof +infbranchsuffof infcard +infchain infcl infcllem infclosed infclosure +infclti infcntss infconvergenceclass infcvgaux +infd infdecr infdegree infdesc @@ -36988,11 +60895,18 @@ infdifsn infdist infdju infdjuabs +infdom +infds infe +infeae +infeas infeasible +infected +infects infedi infedist infempty +infen infenaleph infensuc infeq @@ -37005,9 +60919,15 @@ infercharzeroofring inferdivisionring inferdivisionsemiring inference +inferencer inferences +inferequalitysupportisrequired +infererrorbound +infererrorboundcmd inferi +inferieur inferin +infering inferins inferinst inferinsta @@ -37015,25 +60935,36 @@ inferinstan inferinstanc inferinstance inferinstanceas +inferintervalbounds +inferintervalboundscmd +inferior +inferisign inferlinearorderedfield inferlinearorderedsemifield inferorderedring inferorderedsemiring +inferp +inferpsign inferrable inferred +inferredghost inferring infers infersemiring infertype infertypeq infeu +infeuti infex infexd inffien +inffiexmid +inffinp inffz infgi infglb infglbb +infglbti infh infhom infhomclass @@ -37041,89 +60972,150 @@ infi inficc inficcorderisoiccsup inficl +infidc +infiexmid infil +infilter +infiltration infima infimas infimum +infimumisunique +infimums +infin infinduced infinf infinfg infinite infiniteadelering +infinitechain infinitedescendingsequence infinitedescendingsequencefrom infinitedescent infinitedescentfrom infinitedimensional infinitedimensionalorder +infiniteeverywhere +infiniteexpansion +infinitef infinitegalois +infiniteheightsomewhere +infiniteloopfunction +infinitelooplemma infinitely infiniteneg infiniteness infinitep +infinitepath infinitepi infinitepinat infiniteplace infinitepos infiniterange +infinites infinitesimal infinitesylow infinitetheory infinitetype +infinitexrl +infinities +infinitude infinity +infinityp +infinitytoreal +infinte infiooorderisoioosup infirred infirredupperset +infirstn infiso +infisoti +infiter infix infixagda infixl infixr +infixstyle +infkn infl +infla inflate +inflatio +inflation inflationary +inflattice inflb +inflbti inflection infleinf infleinflem infleleft infleright +inflight +infline infliveness +infloop inflow inflsts inflstse inflstsi infltoreq +influenc influence influenced influences influential infm infmap +infmatrixg infmin +infminti infmo infmodel +infmoti infmremnf infmrgelbi infmrp infn +infnanzero infnattrans +infnfi infnlb +infnlbti infnndist +infnninf +infnninfold infnorm +infnoteven infnsuprnmpt +infnty +infny info +infofinfs +infoi +infolen +infop +infor infordmin inform +informa informal informally +informat +informati informatica information +informations informationtheory +informative +infos +infosp infostate infotree infotrees infoval +infp +infpath infplays infpn infpnlem @@ -37136,17 +61128,25 @@ infpssr infpssrlem infpwfidom infpwfien +infq +infr +infrared infrastructure +infrastructureserviceimpl infrecl infrefilb infregelb +infregelbex infrelb infrenegsup +infrenegsupex infres infrglb +infrise infrnmptle infrpge infrpgernmpt +infrzl infs infsdomnn infsep @@ -37155,22 +61155,32 @@ infset infsetsum infsinfhom infsn +infsnti infss infssd infssuni infssuzcl +infssuzcldc +infssuzex infssuzle +infssuzledc +infstruct infsubc infsubsetall +infsuff infsum infsup infsupfacts +infsupneg infsupprpr inft inftmrel infto +inftonninf inftophom inftophomclass +inftp +inftree infty inftyexpi inftyexpidisj @@ -37182,14 +61192,21 @@ inftyexpitaufo inftynormedalgebra inftynormedcommring inftynormedring +inftyp inftyring +inftys inftyvaluation inftyvaluationdef inftyvaluedfqt infunabs +<<<<<<< Updated upstream +======= infuncsetfunc +>>>>>>> Stashed changes +infunion infunsdom infval +infvalti infxp infxpabs infxpdom @@ -37209,27 +61226,45 @@ infxrlb infxrlbrnmpt infxrlesupxr infxrmnf +infxrnegsupex infxrpnf infxrre infxrrefi infxrrnmptcl infxrss infxrunb +infz +infzl +ing +ingba +ingerep +ingham +ingredient ingredients +ingressport +ingroup ingru inh +inha inhab +inhabbool inhabit inhabitant +inhabitants +inhabitation inhabited +inhabitedbool inhabitedcfg inhabitedcolimittype +inhabitede inhabitedencoding +inhabitedfibres inhabitedfinencoding inhabitedfinoneadd inhabitedfintm inhabitedgradedobject inhabitedleft +inhabitednat inhabitedofconstant inhabitedofempty inhabitedofvar @@ -37240,20 +61275,49 @@ inhabitedt inhabitedtm inhabiteduniformspace inhabiteduniformspacecore +inhabnum inherently +inherents inherit inheritance inherited +inheritedempty +inheritedi +inheritedinclevel +inheritedincleveleq +inheritedinsert +inheritedinserteq +inheritedjoin +inheritedjoini +inheritedoverrideandoriginal inheritedprooftree +inheritedpropagate +inheritedpropagateeq +inheritedun +inheriteduneq +inheritedviasub +inheritence +inheriting inherits +inhib +inhibit +inhibited +inhindis inhomogeneouschains inhomogeneouschainsiso inhomogeneouscochains inhomogeneouscochainsiso +inhprop +inhpropiscontr +inhr ini inidl inidm +inifinity +iniial iniin +inil +inimage inimasn inimass inin @@ -37263,62 +61327,139 @@ inindir inintabd inintabss ininter +<<<<<<< Updated upstream +======= inintersectimpinintersectunions inintersectimpinunion +>>>>>>> Stashed changes +inintspan +inir iniseg inisegn init +initaa +initandmutate +initarray +initator initavstore +initbddconfig +initbddfree +initbddneg +initbddor +initbddsharing +initbddstate +initbdduniv +initblock +initblockreds +initblockredsfinal +initblocksize +initbodyproof +initbuckets initc +initcalls +initcond initconf initconfig +initcost +initcycle initd initdata +inite +initer +initevent initfib +initforms +initfromreference +initglobals +inithalting initi +initia initial initialbound +initialbytcnt +initialcategory initialcolimitcocone +initialcomp initialcomparison initialdata +initialh initialhom +initiali initialis initialisation +initialise +initialising initialisinitial initialisinitreachable initialiso initialisoisinitial initialisopempty +initiality initialization initialize initialized +initializedecryptionmaterials +initializedecryptionmaterialsinput +initializeencryptionmaterials initializelazyentry initializelazyentrywitheta initializelazyentrywithetaaux initializephase +initializer +initializers +initializes +initialk +initialkl +initiall initially initiallysmall +initialm +initialmc +initialmch +initialmcl +initialmetrics initialmodel initialmonoclass initialmul initialnonuniformcfg +initialobject initialofcorepresentableby initialofrepresentableby initialopofterminal +initialp initialproc initials initialseg initialsegiic initialsegiiciicofle initialsegtotype +initialst initialstate initialstateissecure +initialsym +initialt initialto +initialu initialunopofterminal +initiated +initiateint +initiating +initiator +initids +initilized +initital initk +initkeys initlast initlb initlist +initm +initmem +initmissing +initn +initnext +initninit +initnodes inito initoccs initocmd @@ -37332,39 +61473,74 @@ initopropdlem initopropdlemlem initoptions initorcl +initother initoval +initphase +initpostkey +initpre initq +<<<<<<< Updated upstream +======= initr +>>>>>>> Stashed changes +initrd initreachable +initregs initresults inits initscore initseg +initsegm +<<<<<<< Updated upstream +======= initself +>>>>>>> Stashed changes initsize initsm +initss +initst initstails +initstart initstate +initstatealph +initstatep initstatus +initstp +initsts inittableau +inittests +initu initub +initunboundedstack initv +initval +initvals +initwithsideeffects inixp inj +inja injarrow +injbool +injclosed injcomp injd injdroite inje injec inject +injected injecti +injecting injectintobaseio +injectio injection injectionordering +injectionpowerset injections injectionsuniverse +injectiv injective +injectiveafterpop injectiveb injectivedimension injectively @@ -37373,48 +61549,105 @@ injectivepn injectivepresentation injectivepresentationofmap injectivepresentationofmapinjectivepresentation +injectiverel injectiveresolutio injectiveresolution injectiveresolutions injectives injectiveseminorm +injectivities injectivity +injectivitytests +injectl +injectr +injectresult +injectret +injects +injectsinto +injectstep +injectsuc injeq +injext +injextl +injextr injf +injfn injfsim +injfun +<<<<<<< Updated upstream +======= injfuncininjfuncset injfuncset injfuncsetfuncin injfuncsetfuncinj +>>>>>>> Stashed changes +injfunpex injg injgauche injh inji +injinc +injinclevel +injincr injindex +injinj +injk injl injle +injlemma injm injmatch +injmd +injmf +injmi +injmk injmp +injmsk +injn +injneg +injnegsuc injo +injoinv injon injonalt injorder +injp +injpex +injpfun +injpinv +injpos +injppfun injproducd injproducg +injr injresinj injresinjlem injrs +injsep injsimulation injstrictmono injsubmefmnd +injsuc +injsucfin +injsucfinp +injt injthmname +injuh +<<<<<<< Updated upstream +======= injuring +>>>>>>> Stashed changes injust +injv injval +injw +injwq +injz ink +inkeys inl inlalghom +inlam inlclm inlcokernelcofork inlcompassociator @@ -37423,41 +61656,84 @@ inlcompinlcompassociator inlcompinrcompinverseassociator inlcompinverseassociator inlcompsum +inlconnected +inld inleft inlhom +inli +inlinable inline +inlineab +inlineable inlinecirc inlined +inlinek +inlinemultisetformingexpr +<<<<<<< Updated upstream +======= inlineproof +>>>>>>> Stashed changes +inlines +inlinesz inlining +inlinl inlinr +inlist +inll inllatticehom +inlogic +inlr inlresf inlringhom -inlsts inlx +inlza inm +inmain +inmainterm inmap +inmapval +inmasks inmathlib inmathlibref inmbl +inmediate +inmeet +inmersi inmo inmon inmono inmonoid +inmpx +inmult +inmulta +inmultb inn +innames +innards +innaut +innautgroup inne innei +inneighbors inner +innerattrs innercontent innercontinuous +innerds innerdual innere innerfiveseg innerfullyfaithful +innerga +inneri innerlex innermost +innerold +innerouteruser innerp +innerpath +innerpo +innerpoint innerprobchar innerproduct innerproductgeometry @@ -37468,48 +61744,118 @@ innerregular innerregularcompact innerregularcompactlttop innerregularwrt +innershareable +innersize innersl innerslflip +innerspc +innerve +innervertices +innew +innl innodel innoder innot +innpoint +innr +innth +innum +innums +ino inoclosed +inode +inodeof inon inopab inopn inopnd +inord inorder +inorderprint +inorderz +inordk inorm +inoroutline inot +inout +inouts inp +inpa inpart +inpath +inpathlist inpb inpbleaf +inpcp +inpfs +inphantom +inplace inplane +inplen inplus inpolyset +inpord inport inports +inpow +<<<<<<< Updated upstream +======= inpowerset +>>>>>>> Stashed changes +inpp +inpprec inpr inpreima inprod +inprodeq +inps inpt +inptok +inpu input +inputall +inputalltokens +inputalltokensfile +inputalltokensfrom inputalpha inputalphabet +inputbytelen inputchain inputchaininject +inputcmm +inputfuncs inputhandler +inputhandlers +inputheap +inputkey +inputkeyring +inputlen inputlength inputlengthproc +inputline +inputlines +inputlinesfile +inputlinesfrom +inputlinesstdin +inputlinetokens +inputlinewith inputlock +inputmap inputs +inputsexp +inputstack inputstagged +inputstaticar +inputstaticarea inputstring inputsupportderivative +inputtype inputunlock +inputuntil +inputvalues +inputvertices inpw +inqueue inr inrab inradius @@ -37523,55 +61869,99 @@ inrcompinlcompassociator inrcompinrcompinverseassociator inrcompinverseassociator inrcompsum +inrconnected +inre +inrefl +<<<<<<< Updated upstream +======= inregion +>>>>>>> Stashed changes inres +inresflem inrest inrhom +inria inright +inrinjective inrlatticehom inrnonunitalalghom inrnonunitalstaralghom inro inrot +inrp +inrr inrrangeequiv inrresf +inrs inrx ins +insance +insb +insched +inscode +inscodes inscribed inscrit +insd insec +insece +inseci inseg +insens insensitive insep inseparable inseparabled inseparablei +inseparablep inseparablesetoid insepdegree +insepo +inseq +inseqnoautotriggers +inseqs +inseqtriggers inser insersimp insert insertafterlevels insertandeject insertat +insertbalanced insertbot insertboundaries +insertdeny inserted +insertedge insertenter insertentersyntax inserterase +insertfrom +insertfromwith +inserthelper inserti insertidx inserting +insertinmiddle +<<<<<<< Updated upstream +======= insertintomember +>>>>>>> Stashed changes insertion +insertiond insertionfuns +insertioni +insertions insertionsort insertionsortsorted +insertl +insertlist +insertll insertmany insertmax insertmetavar insertmin +insertnil insertnone insertnth insertnthequiv @@ -37579,36 +61969,68 @@ insertnthorderiso insertperm insertpiprod insertpiprodequiv +insertr insertrec inserts insertsimp +insertsort +<<<<<<< Updated upstream +insertsorted +======= +>>>>>>> Stashed changes inserttop inserttrailingids inserttranslation inserttranslationaux insertwith +insertzeros inset +insetcons +insete insetofcomponents insetofcomponentslimit insi insid inside +insidea +insideout insidepart +insidepoint +insider insideregularcone +insidetest insiga insight +insing insist +insists inskip +insklem +insloc +insn +insns +insnx +insomemodule insort +insorta +insortb insorttree +insouts +insp inspan +inspec +inspeck inspect +inspecting inspection insphere inspired +insr insrt inss +inssddif inssdif +inssun inst insta instadd @@ -37634,23 +62056,50 @@ instaddrightmono instaddsemigroup instaddtorsor instaddzeroclass +instalg instalgebra instalgebraforall instalgebrainteger instalgebralocalizationatprime instalgebrasubtypememofnat install +installcode +installdata installed +installing instan instanc instance +instanceaboutuu +instancec +instanceclass +instanced instancef +instancefdual +instancefunction +instancelist +instancemethod +instancemono +instancen +instanceof +instanceofownedobject +instancep +instancepoly instanceproblem +instancerevealworks instances +instancet +instancetbody instancetypefilter +instanceu +<<<<<<< Updated upstream +======= instancewithrelationtofn +>>>>>>> Stashed changes +instancing instant instanti +instantiat instantiate instantiated instantiateforall @@ -37665,7 +62114,9 @@ instantiaterevrange instantiates instantiatetypelevelparams instantiatevaluelevelparams +instantiati instantiating +instantiatio instantiation instantiations instantly @@ -37676,6 +62127,7 @@ instassociativemax instassociativemin instasymm instatleasttwo +instb instbeq instbeqofdecidableeq instbialgebra @@ -37816,6 +62268,7 @@ instead instenrichedcategorytransportenrichment instepiappoffunctor instequivlike +instersection insteru instexists instf @@ -37875,7 +62328,9 @@ insthpow insthpowfinnatofnezero insthsmul insthsub +insti instidemsemiring +instidx instimplicit instinf instinfinite @@ -37885,6 +62340,7 @@ instinhabited instinhabitedemb instinhabitedprod instinnerproductspace +instinp instinsert instintcast instinter @@ -37990,6 +62446,7 @@ instiswellfoundedinvimage instiszeroormarkovkernel instiszlatticecomap institute +instkey instl instlattice instlawfulalternative @@ -38054,6 +62511,8 @@ instmulzeroclass instmulzerooneclass instn instnacg +instname +instnames instnatcast instnatpowassoc instnebot @@ -38089,7 +62548,6 @@ instnonunitalring instnonunitalseminormedcommring instnonunitalseminormedring instnonunitalsemiring -instnonunitalsubringclass instnonunitalsubsemiringclass instnormal instnormalizationmonoid @@ -38107,6 +62565,9 @@ instnpow instns instnsmul insto +instof +instoff +instoffset instofnat instone instonetropical @@ -38148,22 +62609,49 @@ instpseudometricspace instquasiseparatedspace instquot instr +instrange instrankoneadiccompletion instratcast instrclike instrd +instream +instreambuffered instreduced instrefl instregularspace instrelcwcomplex +instrelimnext +instrencode instrepr instring +instrlist +instrmemsizelg +instroff +instroffset instrootcomptriple +instrp instrs +instrset instrsi +instru +instruc +instruct +instructi +instructio instruction +instructioni +instructionis +instructionistype +instructionistypesafe +instructionp instructions +instructionsatis +instructionsatisf +instructionsatisfieshandlers +instructionsf +instructs instrument +instrumented insts instsdiff instsecondcountabletopology @@ -38212,7 +62700,6 @@ inststarmodule inststarmul inststarorderedring inststarorderedringrclike -inststarquaternionalgebra inststarring inststrictconvexspace instsub @@ -38236,6 +62723,7 @@ insttietzeextension insttietzeextensionclosedball insttietzeextensiontvs insttietzeextensionunitball +insttonumlist insttop insttopologica insttopologicalspace @@ -38285,7 +62773,9 @@ instvaluationringinteger instvalued instvsub instwellfoundedisdershowitzmannalt +instwidth instxorop +instype instzero instzeroleoneclass instzerosym @@ -38294,43 +62784,94 @@ instzmodmodule instzmodsmul instzpow instzsmul +insu insub +insubd +insubdk +insubf +insubk insubm +insubn +insubp +insubstream +insubt insucid insufficient +insufficiently +insures +insuring +insx int intab intabs intabssd +intabssel intact intadicabv intadicabvdef intagrk +intail intalgebramap +intance intangentcoordinates intantiate +intapp +intappsize intarm intasym +intball +intbeg intble +intboolfunction +intboolfunctionpartial +intboolfunctionreads +intc +intcall +intcar intcast intcastaddhom intcastringhom +intcdr intceil +intchar +intck intcld intcoe +intcons +intconst +intconv +intd +<<<<<<< Updated upstream +======= +intdef +>>>>>>> Stashed changes intdegree +intdigit +intdom inte integ +integal +intege integer integercomplement +integerdivision +integerinduction integerlattice integermarshalling integermultiple integernormalizat integernormalization integerp +integerps integerqtint integers +integersareabelian +integersareadditiveabeliangroup +integersareadditivegroup +integersareassociative +integersaredistributive +integersaremonoid +integersarering integerset integersetequiv integersetequivnorm @@ -38338,7 +62879,13 @@ integersetquotequivassociates integersettoa integersettoassociates integersettorsionsmul +integersexample +integershaveadditiveinverse +integershaveunit +integerstoring integerverismo +integerxxx +integper integr integra integrab @@ -38347,37 +62894,63 @@ integrabl integrable integrableat integrableatfilter +integrableb +integrabled integrableex integrableexpset integrablehoriz +integrablem +integrableml +integrablemr +integrablen integrableofintervalintegral integrableon +integrablep integrablepower +integrables +integrablet integrableunion +integrablezl +integrablezr integral +integralb integralbas integralbasis integralclm integralclosur integralclosure +integrald integraldomain +integraldomainreals +integrale +integraleindic +integralepatch integralfixeddetmatrices +integralfuncs integrallinearmap +integrally integrallyclosed integralmodel integralmulsum integraln integralnormalization integralnormle +integralover +integralp integralpdfmul integralpositivelinearmap integralpowerbasis integralpowerbasisofprimepow +integralrange integralrep integralrepresentation integralrnderivmul integrals integralsum +integralt +integralte +integralzl +integralzr integrand integrands integrate @@ -38390,14 +62963,27 @@ integrationbypartsbilinear integrationparams integrations integrity +integrityinvariant integrityz +intel +inten intend intended +intension +intensional +intensionality +intensity +intensityf intent +intention intentional intentionally +<<<<<<< Updated upstream +======= intentionalprocess intentionalpsychologicalprocess +>>>>>>> Stashed changes +intepretation inteq inteqd inteqi @@ -38407,41 +62993,74 @@ intequivnatsumnat intequivofzmultipleseqtop intequivofzpowerseqtop inter +intera interact interaction interactions interactive interactivecode +interactivei +interactively interactiveunfold interacts +interation interative interc intercalate +intercc +interccat +intercdr intercept interchangable interchange interchangeable interchangeably +interchangecol +interchangeline interconversion +intere intered interedges +interessata interest interested +interesti +interestin interesting interestingly +interf interface +interfacei +interfacelist +interfacep +interfaceport +interfaceportlist interfaces interfacet +interfer +interfere interference +interferencewithframing interferencewithfwb interferes interfereswith interfering +interfers interfree interfst +intergerp +intergral +intergrationtheory +interi interior interiorpoint interiors +interl +interla +interlace +interlaced +interlatt +interlea interleavable interleave interleaved @@ -38454,59 +63073,124 @@ interm intermed intermedi intermediate +intermediateexpressions intermediatefi intermediatefield intermediatefieldequivclosedsubgroup intermediatefieldequivsubgroup intermediatefieldmap +intermediategenerateandwrap +intermediatekeywrapping +intermediates +intermediateunwrap +intermediatewrap intern internal +internalcall +<<<<<<< Updated upstream +======= internalchange +>>>>>>> Stashed changes +internalconsistent +internaldiff +internale internalhom internalhomadjunction +internalize internalizehom internally internallyprojective +internalmodifies internalname +internalnames +internalorexternal +internalproductfunctor +internalre internalrel +internalrels internals +internalvalidstate +interned +internedp +interns +internstep interofvar interofvars +interop interoperability interp +interpbinop interpd +interpexpr +interpexprs +interpformula +interpi +interpinstr +interplaybetweenseqcharandstring +interpmat interpolate +interpolatei interpolation +interpprog interpr +interpre +interprels interpret +interpretati interpretation +interpretations +interprete interpreted +interpreter +interpretersof interpreting interpretlow +interprets +interps +interpsign +interpsigns +interpstmt interpstrip +interpterm interq +interr interrelate interrupt interrupted interruptible inters +interse intersec intersect intersectcoef intersecting +<<<<<<< Updated upstream +======= intersectinpowersetintersectunions +>>>>>>> Stashed changes +intersectio intersection intersectiona +intersectionbottom intersectionc +intersectionclosed +intersectionh intersectionii +intersectionmap +<<<<<<< Updated upstream +======= intersectionof +>>>>>>> Stashed changes intersectionoflocallydirected +intersectionprop intersections intersectionswith intersectionwith +intersectp intersects intersnd intersperse +intertwine intertwined intertwiners intertwining @@ -38515,11 +63199,15 @@ interunionballs interunionpullbackcone interunionpullbackconelift interv +interva interval intervalaverage intervalcases intervalcasessubgoal +intervalcover +intervalcoverpts intervaledge +intervaleta intervalfilters intervalgapswithin intervali @@ -38528,31 +63216,63 @@ intervalintegrab intervalintegrable intervalintegral intervall +intervalp +intervalplt +intervalr intervals +intervalsample +intervalsamplebound +intervalsampleisindepfunction +intervalsampleisindepfunctionhelper +intervalsampleisindepfunctionhelperlifted +intervalsampleismeasurepreserving +intervalset +intervalsets +intervene +intervenes +intervening intervention intervs +intesg +intesign intex intexab +intexabim +intexg +inteximm +intexr intexrab +intexrabim intf +intfc intff intfi intfib +intflagsbits intfloor +intfnname intfrac intfracq intfract intfractpair +intfsin intg intgcd intgi intgover intgring +intgroup intgru intgt intgv inth +inthall +inthat +inthis +inthrepl inti +intial +intid intidg intidl intiin @@ -38562,22 +63282,42 @@ intimag intimasn intimass intimes +intind +intinddown +intindfull +intindup +intintervals intirr +intishom intisscalartower +intitv +intk +intker +intl +intlemma intlewftc intlidl intlike intlinear intlist +intlistlen intlit +intliteral +intloc +intloop +intm +intmap intmapk intmaps +intmax intmethods intmin intminss +intmod intmodeq intmodtotal intmodule +intmodulus intmul intn intnan @@ -38587,24 +63327,58 @@ intnanrd intnanrt intnatn intnex +intnexr +intnf +intnil +intnone intnorm intnormaux into +intoacc +intoffloat +intoflong intofnat +intofsingle +intok inton +intoo intop intopsn intopval +intord +intout intp +intpair +<<<<<<< Updated upstream +======= intpercasconstesssub +>>>>>>> Stashed changes intpf intpi +intpm +intpos intpow intpr intpreima intprg +intpro +intprog +intprogtheory +intptr +intq +intqfrac intr +intra intrabeq +intractable +intrange +intrd +intreal +intrealembeddingishomomorphism +intreeind +intref +intrel +intrepr intring intringtheory intrinsi @@ -38614,91 +63388,187 @@ intrinsicfrontier intrinsicinterior intrinsics intrinsicstar +intrm intrnfi intro +introd +introdu +introduc introduce introduced introduces introducing introduction +introductory introf introfn introl +introm intromerge intron intronf intronp introntf +introop introp intror intros introsclean introsdep +introspection +introspective introswithbinderidents introt introtf introtfn introtn +intround introv intrp +<<<<<<< Updated upstream +======= intrprp +>>>>>>> Stashed changes +intrpt intruder intruderspeed +intrv ints intsal intsaluni +intseg +intsem +intseq +intset intsfrom +intsigned +intsize intsmulwithzero intsn intsng +intsome intspanequivquotaddorderof intss intssuni +intssunim +intstack +intstance +intstart +intstobits intsubmodule +intsum +intsums +intsym +intsymlist intt +inttest inttf intti +intto +inttobytes +inttochar inttoexpr +inttoken +inttostring inttrace inttraceaux inttrailingdegree +inttransform inttsk +inttype +inttypes intu intubeu intudivtotal +intui +intuii intuitio intuition +intuitioni intuitionistic +<<<<<<< Updated upstream +intuitionistically +======= +>>>>>>> Stashed changes +intuitionisticd +intuitionistici +intuitionisticpropositionallogic +intuitionisticpropositionalsequentcalculus +intuitionisticsep +intuitionnistic intuitive intuitively intun +intunsigned intunsn +intuoffloat +intuofsingle intv intval intvaluatio intvaluation intvaluationdef +intvector +intvl +intwoplacesatonce +intwrapper intwun intxp +<<<<<<< Updated upstream +======= +inty +>>>>>>> Stashed changes +intz inu +inum inundif +inundifss inuni +inunion inunissunidif +inupair +inus inutile inv inva invab invaccumulate invact +invaction +inval invalid +invalida invalidate +invalidated +invalidatewrittenxaddrs +invalidating +invalidblock +invalide +invalidedge +invalidfd invalidi +invalidinfinity +invalidinstruction +invalido +invalidop +invalidx +invals invam invapp +invapply invar +invaraint +invarant +invarc +invard invari +invaria +invariablely +invarian invariance invariant +invariantad +invariantaod invariantbasisnumber invariantcardinalrank invariantcfalse @@ -38706,32 +63576,47 @@ invariantclcharacterization invariantclcurrentlevel invariantcllcharacterizationafterapplylearn invariantconflictclausecharacterization +invariantconflictclausecharacterizationafterapplybackjump invariantconflictclausecharacterizationafterapplylearn invariantconflictclausecharacterizationafterassertliteral invariantconflictclausecharacterizationafternotifywatches invariantconflictflagcharacterization +invariantconflictflagcharacterizationafterapplybackjump invariantconflictflagcharacterizationafterapplylearn invariantconflictflagcharacterizationafterassertliteral invariantconsistent invariantconsistentafterapplybackjump +invariantconsistentafterapplydecide invariantd +invariante invariantequivalentzl +invariantequivalentzlafterapplybackjump +invariantequivalentzlafterapplydecide invariantequivalentzlafterapplylearn invariantextension invariantform invariantgetreasonisreason +invariantgetreasonisreasonafterapplybackjump +invariantgetreasonisreasonafterapplydecide invariantgetreasonisreasonafterapplylearn invariantgetreasonisreasonafternotifywatches invariantgetreasonisreasonqsubset invarianti +invariantly invariantnodecisionswhenconflictensurescurrentlevelcl invariantnodecisionswhenconflictnorunitafterapplylearn +invariantp invariantqcharacterization +invariantqcharacterizationafterapplybackjump +invariantqcharacterizationafterapplydecide invariantqcharacterizationafterapplylearn invariantqcharacterizationafterassertliteral invariantqcharacterizationafterassertliteralnotinq invariants invariantsadjunction +invariantsafterinitialization +invariantsaftersolveloopbody +invariantsch invariantsclafterapplyconflict invariantsclafterapplyexplain invariantsclafterexplainuip @@ -38739,11 +63624,18 @@ invariantsequivfdrephom invariantsequivintertwiningmap invariantsequivrephom invariantsfunctor +invariantsnodecisionswhenconflictnorunitafterapplybackjump invariantsnodecisionswhenconflictnorunitafterassertliteral invariantsubfields +invariantsvarsafterapplybackjump +invariantsvarsafterapplydecide +invarianttd +invarianttod invariantuniq invariantuniqafterapplybackjump +invariantuniqafterapplydecide invariantuniqq +invariantuniqqafterapplybackjump invariantuniqqafterapplylearn invariantuniqqafterassertliteral invariantvarsfafterapplylearn @@ -38755,32 +63647,76 @@ invariantwatchesel invariantwatchlistscharacterization invariantwatchlistscontainonlyclausesfromf invariantwatchlistsuniq +invarient +invarl invarm invarnt +invars invas invasive +invatiant +invaut +invautk invaux +invb +invbij invbk invc +invcapsnonneg +invcg +invchainequiv +invchainmap +invci +invcipher +invciphercore +invcl invco invcoisoid +invcomp +invcomplex +invcongfunct +invcongrefl +invcourse invcs invd invdft +invdg invdif invdisj invdisjrab +invdistr invdiv inve +invec +invek invelid +invem invembedding +invemp +inven invennreal +invent +invented +inventing +<<<<<<< Updated upstream +inventory +======= +>>>>>>> Stashed changes +invents +inveny +invep inveq inveqinv +inveqs invequiv invequivalence +invequivequiv +invequividequiv +invequivsnaturality inver +inveriant invers +inversa inverse inverseassociator inverseaux @@ -38789,28 +63725,56 @@ inversecompfunctoriso inversecompiso inversecompmaphomotopycategoryfstiso inversecompmaphomotopycategorysndiso +inversed +inversediff +inversee +<<<<<<< Updated upstream +======= inversefunctionalproperty +>>>>>>> Stashed changes inversefunctor inversefunctormapiso inversefunctorobj inversefunctorobjiso +inversei inverseimage +inversekey +inversekeys inverselinear inversemonoidal inverseobj inverseof +inverseop +inversep inverses +<<<<<<< Updated upstream +======= inversesoffunctionalproperties +>>>>>>> Stashed changes +inversesp inversesystem +inversetracerelation inversi inversible inversiblez +inversio inversion inversionbot inversions inversiontop +inverso invert +invertability +invertale +invertb +invertboxr +<<<<<<< Updated upstream +======= invertebrate +>>>>>>> Stashed changes +inverted +invertedlist +inverter invertibility invertibl invertible @@ -38856,10 +63820,13 @@ invertibleofrightinverse invertibleofringcharnotdvd invertibleofsubmatrixequivinvertible invertibleone +invertiblep invertiblepb invertiblepd invertiblepow invertiblepso +invertiblerule +invertibles invertiblesucc invertiblet invertiblethree @@ -38869,13 +63836,23 @@ invertibletranspose invertibletwo invertibleunitalmagma inverting +invertinterval inverts +invese +investig investigate +investigated investigating +investigation +invexch +invey invf invffval invfm invfn +invfoldleft +invfoldright +invfp invfuc invfun invfunc @@ -38886,40 +63863,81 @@ invfval invg invgamma invghm +invgi +invgid invginvrid +invgk +invglobpointstampseq +invgm +invgroupequiv +invgroupiso invh invi invid +invidsequenceequiv +invig +invim invimage +invimpliesrefinementnext +invindexseq invinside invinterpstrip invinv +invinvolutive +invip +inviscorrect +inviseq invisible +invisinv +invislast inviso invisoinvl invisoinvr +invisoover invj invjacobianofhascoeffs invk invkey +invkeyi +invkr invl invlevel +invlexorder invlhom +invlim invlimequiv invlmhm +invlooper +invlooperdistr invlt +invltfun +invltfuninrange +invltfunval +invlttable invm +invmachineshell invme invmeas invmemclass +invmg +invmixcolumn +invmixcolumns invmk invmonoidhom invmonoidwithzerohom invmul invmulsubgroup +invmult +invmultcol +invmx +invmxk +invmxz +invn invo +invocat invocation invocations +invoe invof invofideal invofisunit @@ -38927,8 +63945,12 @@ invofmemrange invofunit invoke invoked +invokeelim +invokeinterface invokes +invokespecial invokestatic +invokevirtual invoking invol involute @@ -38938,6 +63960,7 @@ involutions involutive involutiveinv involutiveneg +involutiveness involutivepointwiseneg involutivestar involutory @@ -38945,6 +63968,7 @@ involve involved involves involving +involvling invon invonec invoneclass @@ -38953,51 +63977,110 @@ invoppggim invorderiso invp invpair +invpairfunc +invpathsinunaturality +invpostwhitening +invpres +invprewhitening +<<<<<<< Updated upstream +======= invprop +>>>>>>> Stashed changes invpropd invpropdlem +invproprel invpst +invq +invqer invqparam invr +invrat invrcl invrcn +invreal +invrecordcount +invrel invrev invrfval +invrfvald invrk invrm invrn +invrnd invrotate invrotateinvrotateinvrotateiso invrotateisorotaterotateshiftfunctornegone invrotcomprot +invrotkeys +invround +invroundfun +invrounds invrpropd +invrpropdg invrvald +invrz invs +invsblock +invsbox +invsboxval invsc invself +invsequenceequiv invseries +invsersion +<<<<<<< Updated upstream +======= invset +>>>>>>> Stashed changes +invsg +invshift +invshiftrows +invsides +invsign +invsl +invsnibble invsome +invsphere +invsquare invss +invstreamg +invstudent +invsubbytes invsubmonoid +invsucc +invsuceq +invsusp +invsuspiso invsym invt invterm invtranslateval +invtransportstr +invtri invtrootsubmodule invtsubmodule invtsubmoduletolieideal +invug invunitssub invunitsub invv invveblen +invw +invwosetequiv invx invz inw +<<<<<<< Updated upstream +======= inwait +>>>>>>> Stashed changes +inward +inwards inwords +inx inxp inxpex +inxpk inxpold inxprnres inxpss @@ -39005,9 +64088,11 @@ inxpssidinxp inxpssres inxpxrn inz +inzp ioa iobj iobs +iobuff ioc iocborel iocbrsiga @@ -39034,7 +64119,6 @@ iocpnfordt iocprodioc iocress iocrfn -iocrrnval iocssicc iocssioo iocssre @@ -39043,18 +64127,43 @@ iocucvr iocuni iocunico iocval +iod +ioda +iodas +ioe +iof +iofb +ioff +iofs +ioh +iohi ioi ioichangevariables ioiftc ioin +iok +<<<<<<< Updated upstream +======= iokaste +>>>>>>> Stashed changes +iol iold +iolo +iomacros +iomid iomnn iomnnom +<<<<<<< Updated upstream +======= ion +>>>>>>> Stashed changes +ione +ionescu +ionum ioo iooabslt iooborel +ioocosf ioodisj ioodvbdlimc iooelexlt @@ -39064,14 +64173,17 @@ ioofun ioogtlb ioogtlbd iooid +iooidg iooii iooiinicc iooiinioc iooin iooinlbub +iooinsup ioojoin iooltub iooltubd +ioom ioomax ioombl ioomidp @@ -39085,7 +64197,11 @@ ioopnfsup ioopos ioorcl ioorebas +ioorebasg +iooreen +iooref iooretop +iooretopg ioorf ioorinv ioorp @@ -39096,7 +64212,6 @@ ioorrnopnxrlem ioorval ioosconn iooshf -iooshft iooshift iooss ioosscn @@ -39112,11 +64227,20 @@ iooval ioovolcl ioovonmbl iop +iopattern +iopl +iopp ioprog +iopu ior ioran +iorder +iordinal +iordinals iordsmo iorlid +ios +iostreams iostreamwriter iota iotabi @@ -39126,29 +64250,50 @@ iotacl iotaeq iotaequ iotaex +iotaexab +iotaexel iotaexeu +iotafz iotain iotaint iotajust iotalem iotalemcor +iotam iotan iotanul +iotap iotasbc iotasbcq +iotass iotassuni iotauni iotaval iotavalb iotavalsb iotop +ioutport +iow +iox +ipa ipad +ipadcont +ipadseq +ipadshaabs +ipadx +ipasi +ipasir +ipasiri +ipasirs ipass ipassi ipasslem ipassmt ipassr +ipat ipath +ipathd +ipathi ipattern ipblnfi ipc @@ -39161,23 +64306,35 @@ ipcnd ipcni ipcnlem ipcnval +ipd ipdi ipdir ipdiri ipdirilem ipeq +iperp ipf ipfeq ipffn ipffval +ipfun ipfval +ipg +ipgamma ipge +iphi ipid ipidsq ipiiie +ipinv ipipcj ipl +<<<<<<< Updated upstream +======= iple +>>>>>>> Stashed changes +iplus +ipmlies ipndx ipndxnbasendx ipndxnmulrndx @@ -39185,7 +64342,6 @@ ipndxnplusgndx ipnm ipo ipobas -ipodhtml ipodrscl ipodrsfi ipodrsima @@ -39199,18 +64355,70 @@ ipolub ipolubdm ipolublem ipoly +ipolyi +ipop ipopos +ipops iporthcom +ipos ipostr ipotset ipoval +ipow +ipows +ipowsc +ipp ippart ippartition +ippartitioning +ippartitionunion ipr iprange iprc +ipre ipred +iprefix +iprefixp +iprep +ipresabs +iprescons +ipresfresh +ipresfreshabs +ipresfreshall +ipresigabs +ipresigcons +ipresigfresh +ipresigfreshabs +ipresigfreshall +ipresigop +ipresigsubst +ipresigsubstabs +ipresigsubstall +ipresigswap +ipresigswapabs +ipresigswapall +ipresigvar +ipresigwls +ipresigwlsabs +ipresigwlsall +ipresop +ipressubst +ipressubstabs +ipressubstall +ipresswap +ipresswapabs +ipresswapall +ipresvar +ipreswls +ipreswlsabs +ipreswlsall +ipri +iprin +iprint +iprinting iprod +iprodap +iprodcf iprodcl iprodclim iprodefisum @@ -39220,37 +64428,78 @@ iprodgam iprodmul iprodn iprodrecl +iproduct iprop iprotocol +iprover ips ipsaddg +ipsaddgd ipsbase +ipsbased +ipsc ipset ipsets ipsip +ipsipd +ipslid ipsmulr +ipsmulrd ipssca +ipsscad ipsstr +ipsstrd ipsubdi ipsubdir +ipsum ipsvsca +ipsvscad ipt +iptable iptables +iptr +iptrp ipurge +ipurged +ipush ipv ipval +ipvicgw +ipx ipz +iqm iqn +iqstar ira +iradius +irange +irbd +irc +irdy ireadert irec +ireduce +ireduces +ireducible +ireduction +irefl +ireg +iregabt +iregsp +iregval irel +irelated +irepp ires iresn iresolutionobj +ireturn +irewrite +irfb iri irinitoringc irm +irmovl irngnminplynz irngnzply irngss @@ -39260,19 +64509,32 @@ iro ironkv ironsht irop +irp +irpt irq +irqact +irqactl irr irra irradd irralt +irrap +irraplemap +irraplemexp +irraplemnn irrapx irrapxlem irrat irrational +irrationale irrationality +irrationals +irrationnal +irraut irrdiff irrdifflemf irre +irrechar irred irredcl irredlmul @@ -39283,8 +64545,11 @@ irredneg irrednegb irrednu irrednzr +irredp irredrmul irreduccible +irreducibility +irreducibl irreducible irreduciblecloseds irreduciblecomponent @@ -39294,46 +64559,92 @@ irreduciblecomponents irreduciblecomponentsequiv irreduciblecomponentsequivofispreirreduciblefiber irreducibled +irreduciblei +irreduciblep +irreducibles irreduciblesetequivpoints irreduciblespac irreduciblespace +irreducibly irref irrefl irrefld +irreflex irreflexive +irreflexivedecisionless +irreflexivelexless +<<<<<<< Updated upstream +======= irreflexiveproperty +>>>>>>> Stashed changes +irreflexividad irreflexivite irreflexivity irrefli +irreflkernel irreflp irreflviaequiv irrefutable irregular irregularamicpair irrel +irrelavant +irrele +irrelevan +irrelevanc irrelevance irrelevant irrelevantideal irrelevantlte +irrelevent +irrelevevant +irrespective +irrevocability irrexpq irrexpqalt +irrexpqap irrfl +<<<<<<< Updated upstream +irrigation +======= +>>>>>>> Stashed changes +irritant +irritate +irritating +irrk irrlem irrmul +irrmulap +irrp +irrq +irrrelevance +irrrepr +irrtype +irrw +irrwchar +irrwnorm iru irule irules +irv isa +isab isabelian isabeliangalois isabeliangroup +isabelianization isabelle +isabenriched +isabepistable +isabgroup +isabgroupequiv isabl isabld isabli isablo isabloi isaborttacticexception +isabprojective isabskan isabsoluteleftkan isabsoluteleftkanlift @@ -39342,10 +64653,18 @@ isabsolutevaluenorm isabv isabvd isacc +isacceptinggbarunfor isaccessible +isaccmodality +isaccrsu isacn +isacnm isacs +<<<<<<< Updated upstream +======= isact +>>>>>>> Stashed changes +isacut isacycgr isacyclic isaddcyclic @@ -39354,10 +64673,12 @@ isaddfreimaniso isaddfundamentaldomain isaddhaarmeasure isaddindecomposable +isadditive isaddleftinvariant isaddleftregular isaddquantale isaddquotientcoveringmap +isaddr isaddregular isaddrightinvariant isaddrightregular @@ -39367,6 +64688,7 @@ isaddunit isadic isadiccauchy isadiccomplete +isadj isadjmatrix isadjoinroot isadjoinrootmonic @@ -39379,40 +64701,73 @@ isaff isaffine isaffinehom isaffineopen +isafform +isafterm +isagform +isagterm isal +isalg isalgclosed isalgclosure isalgeb +isalgebra +isalgebraequiv +isalgebrahom isalgebraic +isalgebraicflabbytype +isalgebraicinjectivetype isalglattice isalgsemilattice +isaligned +isalimit isall +isallocated isallowedcharacter isalmostintegral +isalpha isalphanum +isalphanumorwild +isalphanumprime +isalphasym +isalphat isalt isalternating isamalgamati isamalgamation +isamonotoniceqv +isample isanisotropic isanmbfm isanonymous +isanorderpreservingeqv +isanother isantichain +isantimonotonic isantiquots +isantisym +isantitone +isapart isapartness isapartnessrelation isapp +isappend +isapplicative isappof isappofarity isapporforallofconst isapporforallofconstp isapproximatesubgroup isapproximateunit +isaprove isarchi isarchiofld isarep +isaresolvent +isarip isarithfrobat isarithmetic +isarray +isarraytype isarrlenloc isarrow isarrv @@ -39422,15 +64777,26 @@ isartinian isartinianobject isartinianring isartinianscheme +isarv isascendingcentralseries +isascii isasciialpha isasciialphanum +isasciibytesisvalidutf isasciidigit isasciilower +isasciistring isasciiupper +isaset +isasetlevel isass isassa isassad +isassig +isassigna +isassignab +isassignable +isassignableto isassigned isassintop isasslaw @@ -39439,6 +64805,8 @@ isassociat isassociated isassociatedprime isassociative +isasym +isasymasymkernel isat isatl isatom @@ -39447,9 +64815,11 @@ isatomistic isatomorderivable isaugmentingpath isausgr +isausgren isaut isauxdecl isauxrecursor +isawskmsidentifierstring isazumaya isb isba @@ -39460,6 +64830,7 @@ isband isbase isbasechange isbaseclass +isbasictypes isbasis isbasisg isbasisrelowl @@ -39467,9 +64838,14 @@ isbasisrelowllem isbetween isbetweenpos isbezout +isbiadditive +isbicomplete +isbicompleteresiduatedclosureimage +isbig isbigo isbigotvs isbigowith +isbiinv isbijective isbilimit isbilimitbinarybiconeofissplitepiofkernel @@ -39484,17 +64860,22 @@ isbilimitofpreserves isbilimitoftotal isbilinearmap isbimonhom +isbinary isbinarybilimitofiscolimit isbinarybilimitofislimit isbinarybilimitofpreserves isbinarybilimitoftotal isbinarycoproductofisinitialispushout +isbinaryel isbinaryproductofisterminalispullback isbinder +isbindigit isbinopr isbinopresulttype isbipartite isbipartitewith +isbipequiv +isbiproduct isbisimulation isblacklisted isblo @@ -39505,6 +64886,7 @@ isbnd isbndx isbo isbool +isboolean isbooleanalgebra isbooleanring isbooleansemiring @@ -39522,6 +64904,7 @@ isboundedbilinearmap isboundeddefa isboundeddefault isboundedjoinsemilattice +isboundedlattice isboundedlinearmap isboundedmeetsemilattice isboundedsmul @@ -39532,7 +64915,10 @@ isboundedunder isboundedwrt isbrauerequivalent isbridge +isbth +isbuff isbvar +isbyte isbytev isc isca @@ -39542,6 +64928,7 @@ iscancelmul iscancelmulzero iscancelsmul iscanonical +iscapsule iscaratheodory iscard iscardina @@ -39559,16 +64946,24 @@ iscartansubal iscartansubalgebra iscartesian iscartesiandistributive +iscartesianproduct +iscase +iscastr iscastresulttype iscat iscatantiquot iscatd +iscategory iscatpullbacksquare iscau iscauf iscauseq iscbn +iscc +iscd iscdot +iscdrnth +iscelebrity iscentral iscentralscalar iscentralvadd @@ -39581,8 +64976,12 @@ iscgrgd iscgrglt isch ischain +ischainequiv +ischair +ischar ischarnetwonf ischarp +ischart ischarthreejnezeronf ischarthreenf ischartwojeqzeronf @@ -39592,8 +64991,14 @@ ischn ischshtuple iscircuit iscl +iscla +isclas isclass isclassified +isclassname +isclasster +isclassterm +isclasstype isclat isclatd iscld @@ -39633,11 +65038,15 @@ isclosedunderkernels isclosedunderlimitsofshape isclosedunderquotients isclosedundersubobjects +isclosure +isclosuresubset isclwlk isclwlke isclwlkupgr isclwwlk isclwwlkn +isclwwlkng +isclwwlkni isclwwlknon isclwwlknx iscmd @@ -39652,7 +65061,9 @@ iscn iscncl iscnp iscnrm +iscntrl isco +iscoarse iscoatom iscoatomic iscoatomistic @@ -39667,6 +65078,7 @@ iscocircuit iscocircuits iscoco iscocomm +iscocommutativecomonoidobject iscocontinuous iscocycle iscodetecting @@ -39683,8 +65095,11 @@ iscofiltered iscofilteredorempty iscofinal iscofinalfor +iscoherent iscoherentwith +iscohhspace iscohomologous +iscohomtheoryz iscoinitialfor iscokernel iscokernelepicomp @@ -39832,21 +65247,33 @@ iscolimittosubtype iscolimittrans iscolimitwhiskerequiv iscolimityonedaequiv +iscollectionuserdefined iscolocal iscoloop +iscolor iscom +iscomact iscomlaw iscomm +iscomma +iscommalgebra iscommjordan iscommmonobj +iscommmonoid +iscommmonoidequiv iscommring +iscommringequiv +iscommringhom +iscommtrunc iscommutative iscommutativemonoid iscommutativering iscommutativesemigroup iscommutativesemiring iscommutativesemiringwithoutone +iscomo iscomonhom +iscomonoidobject iscomp iscompa iscompact @@ -39857,6 +65284,7 @@ iscompactlygenerated iscompactopencovered iscompactoperator iscompactsystem +iscomparisons iscompat iscompatible iscompatiblewithshift @@ -39870,19 +65298,23 @@ iscomplequivproj iscomplet iscomplete iscompletebetween +iscompletelattice +iscompletelatticeembeddingposet iscompletelymetrizablespace iscompletelypseudometrizablespace iscompletemultipartite iscompletespace iscomplex iscomplprojection +iscomposite iscompressed iscomv isconcretele iscondkernel iscondkernelcdf -isconfluent isconformalmap +iscong +iscongruence iscongruencesubgroup isconj isconjgal @@ -39890,44 +65322,123 @@ isconjroot isconn isconnect isconnected +isconnectedcofib +isconnectedcomp +isconnectedcong +isconnectedcw +isconnectedem +isconnectedfun +isconnectedfuncancel +isconnectedfunsubtr +isconnectedid +isconnectedkn +isconnectedpath +isconnectedpathkn +isconnectedpathp +isconnectedpaths +isconnectedpoint +isconnectedretract +isconnectedretractfromiso +isconnecteds +isconnectedskel +isconnectedsphere +isconnectedspherebouquet +isconnectedsubtr +isconnectedsuc +isconnectedsusp +isconnectedsuspfun +isconnectedsuspmap +isconnectedzero isconngr +isconnmap +isconnsusp +isconsdivs +isconsequence isconservative isconservativefamilyofpoints isconservativeon +isconsiste +isconsistent +isconsk isconst isconstant isconstantapplication isconstantfun +isconstanttime +isconstanttimegivenstates isconstof isconstr isconstructible +isconstructor iscont iscontained iscontdiffcompatible +iscontext iscontextfree iscontfract iscontinuous iscontmdiff iscontmdiffriemannianbundle iscontperfpair +iscontprop iscontr +iscontrboolpointedequiv +iscontrdep +iscontre +iscontrfin +iscontrgcd +iscontrh +iscontrhasretract +iscontrhassection +iscontrifinhabited +iscontrinterval +iscontrker +iscontrlehmerzero +iscontrmodulo +iscontrpartial +iscontrpath +iscontrpathp +iscontrpathsinunit +iscontrpathtoiscontr +iscontrquotrem +iscontrresidue +iscontrretractofconstfun +iscontrsettrunc +iscontrsfamgen +iscontrsingl +iscontrsinglp +iscontrspherebouquetzero +iscontrsumfin +iscontrtoiscontrpath +iscontrtotalsequence +iscontrtrunc +iscontrunit +iscontrvec iscop iscoprim iscoprime iscoprodofmono +iscoproduct iscoproductofisinitialispushout +iscored iscoreflexivepair iscoreprese iscorepresentable iscorner iscornerfree +iscorrect iscoseparating iscoseparator iscoskeletal iscospan iscospl iscosplitpair +iscoua +<<<<<<< Updated upstream +======= iscountable +>>>>>>> Stashed changes +iscountablyadditive iscountablygenerated iscountablyspanning iscovariantderivativeon @@ -39943,6 +65454,7 @@ iscplgredg iscplgrnb iscrct iscref +iscring iscringd iscrng iscrngd @@ -39953,17 +65465,32 @@ iscseq iscsgrpalt iscsrg iscss +iscubefilled +iscubefilleddep +iscubefilleddepconst +iscubefilledfiber +iscubefilledpath +iscubefilledsuc +iscurrentwrapperleft iscus iscusgr iscusgredg iscusgrvtx iscusp iscustom +iscut +iscutx +iscuty +iscv +iscvg +iscvgc +iscvgd iscvlat iscvm iscvs iscvsi iscvsp +iscw iscycl iscycle iscycleon @@ -39978,16 +65505,26 @@ iscygd iscyggen iscygodd isd +isdabort isdag isdagmatrix +isdata +isdataelement isde +isdec +isdecbiimpl isdecequivalence +isdecfield +isdecidable isdecidablevariant isdecidenative isdecltounfold isdecompon isdecompositionfield isdecpartialorder +isdecprop +isdecproprespectequiv +isdecr isdecstrictpartialorder isdectotalorder isdedekind @@ -40003,6 +65540,9 @@ isdefeqapply isdefeqguarded isdefeqq isdefeqsafe +isdefined +isdelim +isdenormal isdense isdenseat isdenseembedding @@ -40010,13 +65550,19 @@ isdenseind isdenseinducing isdenselinearorder isdensesubsite +isdepprop isdeprecated +isderiv +isderivedkey isdershowitzmannalt isdescendingcentralseries isdetecting isdetector +isdetransitivestrrel +isdgraph isdiag isdiagonal +isdiagonalempty isdiamet isdiameter isdigit @@ -40028,6 +65574,10 @@ isdirectedorder isdiscrete isdiscretevaluationring isdistinguishedat +isdistlattice +isdistlatticeequiv +isdistr +isdistributive isdistributivelattice isdite isdivrngo @@ -40039,6 +65589,8 @@ isdoma isdomain isdominant isdomn +isdonereading +isdot isdpmorphism isdrng isdrngd @@ -40049,14 +65601,23 @@ isdrngrdold isdrs isdtopologycompatible isdual +isdualclosure +isdualclosuresubset +isdummysubsettype +isdump +isdunivalent +isduplicate isdyncoverof isdynnetin ise +isect isecure isedgeconnected isedgereachable iseffective +iseg iseisensteinat +iseki iselect iselem iselementary @@ -40064,9 +65625,15 @@ iselldivsequence iselliptic isellsequence isem +isemap isemb isembeddin isembedding +isembeddingbool +isembeddingel +isembeddingfromisequivtoimage +isembeddingfst +isemigroup isempty isemptyalgequiv isemptye @@ -40076,12 +65643,20 @@ isemptyext isemptynonempty isemptyringequi isemptyringequiv +isend isengelian isenumeration +iseof isepi +isepimorphism +isepistable iseq +iseqf iseqlg iseqlgd +iseqopt +iseqovex +iseqs iseqsetv iseqsetvlem isequ @@ -40091,12 +65666,36 @@ isequalizercompmono isequi isequipartition isequiv +isequivadd isequivalence isequivalencemap isequivalencemappair isequivalencepreserveslimits isequivalent +isequivcong +isequivconst +isequivconstcube +isequivf +isequivfromiscontr +isequivfunctor +isequivid +isequivincl +isequivinvequiv +isequivpathtoequiv +isequivpostcomp +isequivprecomp +isequivpropbiimpl +isequivpunchout +isequivrel +isequivrelnegationrel +isequivrelr +isequivs +isequivswap +isequivtransp +isequivtransport iseqv +iseqvalcbv +iser iserabs iseralt iseraltlem @@ -40111,29 +65710,49 @@ iserle isermulc iserodd isershft +isesdkencrypteddatakey +isesdkencryptioncontext +isessentiallysurj +isesssurj iset isetaleat isets +isetstate +isetstatep +isetvar +isetvarf iseuclidean iseulerian iseupth iseupthf iseve iseven +isevenfalse isevengcd +iseveniseven +isevenisodd isevenlycovered +isevennegsuc +isevent +iseventrue iseventuallyconstantfrom iseventuallyconstantto iseverywherepos isewlk +isexact isexacton +isexception +isexclusiveglobal +isexclusivelocal isexid isexistential +isexpandedaadsection isexpansionon isexpcmpfilter isexplicit isexplicitbindersingular isexpliciteq +isexplicitleakagefreegivenstates isexplicitnumber isexposed isextendible @@ -40142,6 +65761,8 @@ isextensionalonguliftyoneda isextensionpair isextent isextremal +isextremalepi +isextremalmono isextreme isextremept isextrfilter @@ -40149,11 +65770,17 @@ isextron isexttangent isexttangentat isf +isfactor +isfactorgcdfirst +isfactorgcdless +isfactorgcdsecond isfactorof isfailedtosynthesize isfailure isfaithful +isfaithfulpseudoyoneda isfalse +isfault isfbas isfcf isfcls @@ -40164,16 +65791,32 @@ isfi isfib isfibaux isfibered +isfibn isfibrant isfield +isfieldequiv +isfields isfil isfild isfildlem +isfile isfilte +isfilter isfiltered isfilteredorempty isfiltration isfin +isfinal +isfinalframe +isfincw +isfincwjoin +isfincwjoinpushout +isfincwpushout +isfincwskel +isfincwsusp +isfinind +isfiniscw +isfinitary isfinite isfiniteg isfiniteke @@ -40200,22 +65843,44 @@ isfinitemeasurezero isfiniteplace isfinitepresentation isfiniterelindex +isfinitesetoid +isfinitesomewhere isfinitesplit isfinitetype +isfinord +isfinordfin +isfinordunit +isfinprop +isfinset +isfinsetbool +isfinsetfiberdisc +isfinsetfin +isfinsetfindata +isfinsetfinprop +isfinsetunit +isfinstrcard +isfintype +isfintypefinsetofcard +isfintypesuc isfirstquadrant +isfive isfivewheellike isfixedblock +isfixedpoint isfixedpt isflat isfld isfldidl isflf +isfloat isfmlasuc isfne isfoelner isforall isformaladjoint +isforward isforwardinvariant +isforwardpointer isfra isfrac isfract @@ -40232,17 +65897,26 @@ isfractionringnum isfragment isfraisse isfraisselimit +isfree +isfreeabgroup +isfreeabgroupon isfreegroup isfreegroupoid +isfreegroupon isfresh isfrgr +isfromlist isfsupp isfsuppd isfth isfull +isfullyfaithful isfullyinvariant +isfun isfunc isfuncd +isfunction +isfunctor isfundamental isfundamentaldomain isfundamentalgroup @@ -40258,21 +65932,27 @@ isg isga isgabriel isgalois +isgaloisconnection +isgaloisconnectiondual isgaloisgroup isgaloistower isgaussian isgaussianprocess isgb +isgbarunfor isgbe isgbo isgbow +isgcd isgdelta isge +isgen isgeneratedby isgeneratedbyonehypercovers isgenerating isgenerator isgenericpoint +isgenesisblock isgeometricallyreduced isgerm isgerminjective @@ -40284,21 +65964,45 @@ isgim isglb isglbd isglobal +isglobalaxiom isglobalblock isglpos isgluing +isgn +isgnf isgood +isgoodint +isgoodopt isgram +isgraph +isgreater isgreatest +isgreatestembeddingposettotal isgrim isgrlim isgrothendieckabelian isgroup +isgroupequiv +isgrouphom +isgrouphomcomp +isgrouphominv isgrouphomomorphism isgroupisomorphism isgrouplikeelem isgroupmonomorphism isgroupoid +isgroupoidalgebra +isgroupoidbinary +isgroupoidcommalgebra +isgroupoidcommring +isgroupoidfinset +isgroupoidgroup +isgroupoidgroupoidtrunc +isgroupoidhset +isgroupoidkleinbottle +isgroupoidring +isgroupoids +isgroupp isgrp isgrpd isgrpda @@ -40312,9 +66016,12 @@ isgrpoi isgrtri isgt isgte +isguard ish ishaarmeasure +ishaequiv ishahndecomposition +ishalt ishamiltonian ishamiltoniancycle ishashinf @@ -40322,11 +66029,15 @@ ishaus ishausdorff ishave isheadbetatargetfn +isheader isheap +ishelp ishenstock ishereditarilylindelof ishermitian +ishexchar ishexdigit +ishexstring isheytingcommutativering isheytingfield ishift @@ -40340,26 +66051,42 @@ ishlg ishlo ishmeo ishmo +ishom +ishomcb ishomeomorph ishomeomorphictrivialfiberbundle ishomlift ishomogeneous +ishomogeneousdiscrete ishomogeneouselem ishomogeneousidealdefs +ishomogeneouskn +ishomogeneouspath +ishomogeneouspi +ishomogeneousprod ishomogeneoussubsemiringdefs ishomogenous ishomological ishomomorphism ishpg +ishprop +ishpropmin +ishr +ishset +ishsetalgebra +ishspace ishst ishtpy ishtpyd +ishurewicz ishyperbolic isi isibl isid +isidbyump isideal isidealmorphism +isidem isidempo isidempot isidempoten @@ -40371,15 +66098,19 @@ isidempotentelemequiv isidempotentelemequivclopens isidempotentelemmulzeroaddone isidempotentsemiring +isidemring isidendescape isident isidenticalsidesstr isidentityfun +isidentitysystem isidl isidlc isidom isidx isifs +isigf +isign isignoretactickind isim isimage @@ -40395,8 +66126,12 @@ isinaccessible isinaccessibleusername isinag isinagd +isinassignedplane +isincreasing isincreasingapproximateunit isindcontained +isindepfunction +isindepfunctioncondition isindepset isindexeddecequivalence isindexedequivalence @@ -40409,18 +66144,26 @@ isinertiafield isinf isinfcard isinffi +isinfimum +isinfinf +isinfinite isinfiniteplace +isinfinity isinfix isinftm +isinhab isini +isinim isinitial isinitialbot +isinitialcategory isinitialelementsmkshrinkyonedaobjobjequivid isinitialequivunique isinitialiffobj isinitialiso isinitialmul isinitialobj +isinitialobject isinitialofcorepresentableby isinitialofisempty isinitialofobj @@ -40435,10 +66178,17 @@ isinitoi isinitseg isinj isinjective +isinjectivelower +isinjectivetransport +isinker +isinlist +isinlistbad isinmathlib +isins isinsimpset isinstance isinstimplicit +isinstruction isint isintcast isinteg @@ -40447,6 +66197,7 @@ isintegr isintegra isintegral isintegralclosure +isintegraldomain isintegralelem isintegralhom isintegrall @@ -40454,12 +66205,14 @@ isintegrallyclosed isintegrallyclosedin isintegrallyclosedoffiniteextension isintent +isinterface isinterio isinterior isinteriorpoint isinternal isinternaldetail isinternallyprojective +isinterrupt isintersectingof isintertwining isintertwiningmap @@ -40467,32 +66220,41 @@ isintgv isinto isinttangent isinttangentat +isintv isinv isinvariant isinvariantblock isinvariantsubfield isinvariantsubring +isinverse isinverted isinvertedby isinvertible isinvinvariant +isinvolution isinvolutory isipodrs isirred isirreducibl isirreducible isirrefl +isirreflirreflkernel isis isismt isismty isiso +isisoc isisod isisole isisometricsmul isisomorphic isisomorphicsetoid +isisomorphism isisos isisosigmacomparison +isisotoisequiv +isisotoiso +isisotone isisotypic isisotypicoftype isisozero @@ -40502,12 +66264,40 @@ isisozeroselfequiv isisozeroselfequivisozero isisubgr isite +isitemsmap +isitjust isitsucc +isitvalid +isityes +isize isjacobsonring +isjav +isjavaassignable +isjavaassignmen +isjavaassignment +isjavaassignmentcompatible +isjavaclassass +isjavaclassassignmentcompatible +isjavasubclass +isjavasubclasso +isjavasubclassof +isjoin +isjoincompletesemipseudolattice +isjoincompletesemipseudolatticeembeddingposet isjoinsemilattice +isjoinsemilatticeembeddingposet +isjoinsemipseudolattice +isjoinsemipseudolatticeembeddingposet isjointlysurjectivepreserving isjordan +isjust +<<<<<<< Updated upstream +isjustfromjust +======= +>>>>>>> Stashed changes +isk iskan +iskancomplex iskanofwhiskerleftadjoint iskanwhisker iskernel @@ -40519,10 +66309,10 @@ iskernelsndkernelfork iskgen iskilling iskinjective +iskips iskleenealgebra iskleinfour iskolmogorovprocess -iskpair iskprojective iskrasner isl @@ -40535,6 +66325,9 @@ islastassertedliteralsubset islat islatercommand islattice +islatticeembeddingposet +islatticeequiv +islatticehom islaut islawfultraversable islawson @@ -40543,8 +66336,10 @@ isldepslvec isldil isldsys isle +isleaf isleag isleagd +isleakagefree isleast islef isleft @@ -40558,20 +66353,33 @@ isleftcancelvadd isleftderivabilitystructure isleftderivedfunctor isleftdescent +isleftdistributive isleftexact +isleftideal +isleftinverse isleftinversion +isleftinvertible isleftkanextension isleftkanextensionalongequivalence isleftkanextensionid +isleftmodule +isleftmoduleequiv isleftregular +isleftsubmodule isleftuniformgroup +isleftunital islemma +isleq +islessthansuccesor islet +isletter +islexerrort islfl islfld islhp islhs islidl +islidlm islieabelian islietower islift @@ -40732,6 +66540,7 @@ islist islit islittleo islittleotvs +islk islln islly islmd @@ -40785,7 +66594,6 @@ islocallyartinianscheme islocallybijective islocallybounded islocallyclosed -islocallyconfluent islocallyconstant islocallyconstructible islocallydirected @@ -40801,6 +66609,7 @@ islocallyi islocallyinjective islocallynoetherian islocallypresentable +islocallysmall islocallysu islocallysurj islocallysurjective @@ -40815,13 +66624,23 @@ islocalstructomorph islocalstructomorphon islocalstructomorphwithinat islocfin +islock +islong +islongestinshortestpath +islongidt isloo isloop isloopat isloopless +isloosehexchar +isloosehexstring +isloset +islow islower +islowerbound islowermodularlattice islowerset +islowertriangular islp islpcn islpi @@ -40844,8 +66663,12 @@ islss islssd islssfg islssfgi +islssm +islssmd +islssmg islt islte +isltkey isltrn islub islvec @@ -40855,12 +66678,17 @@ ismagma ismagmahomomorphism ismagmaisomorphism ismagmamonomorphism +ismall ismanifold ismarkov ismarkovkernel +ismatch ismatcher ismatching ismatchingfree +ismatchingtype +ismatchingtypee +ismatchtype ismax ismaxantichain ismaxcha @@ -40873,6 +66701,7 @@ ismaxidl ismaximal ismaximalclique ismaximalindepset +ismaximalsubgroup ismaximumclique ismaximumindepset ismaxon @@ -40888,16 +66717,28 @@ ismeagre ismeannd ismeas ismeasura +ismeasurable ismeasurableratcdf ismeasurablygenerated +ismeasure +ismeasurepreserving ismeet +ismeetcompletesemipseudolattice +ismeetcompletesemipseudolatticeembeddingposet ismeetsemilattice +ismeetsemilatticeembeddingposet +ismeetsemipseudolattice +ismeetsemipseudolatticeembeddingposet +<<<<<<< Updated upstream +======= ismeetu +>>>>>>> Stashed changes +ismeq +ismessageregularframes +ismessageregularframescanbesplit ismet ismeta ismetaprogramming -ismethodaction -ismethodexistence ismeti ismetric ismetrizable @@ -40909,18 +66750,23 @@ ismgmhm ismgmid ismgmn ismgmold +ismgu ismhm ismhmd ismhp ismidb +ismiddle ismin isminbadseq ismincomp isminfilter isminimal +isminimalbackjumplevelcharacterization isminimalbackjumplevelgetbackjumplevel isminimalfor isminimalprimarydecomposition +isminimalwellformedcodeunitsubsequence +isminimum isminon isminor ismint @@ -40928,11 +66774,19 @@ ismintegra ismintegralcurve ismintegralcurveat ismintegralcurveon +isminusoneconnected ismir ismissing ismittagleffle ismittagleffler ismixed +ismkv +ismkvmap +ismkvnex +ismkvnn +ismkvnnlem +ismmio +ismmioaddr ismnd ismndd ismnddef @@ -40945,6 +66799,9 @@ ismnu ismnuprim ismnushort ismod +ismodality +ismodel +ismodequivalent ismodular ismodularlattice ismodule @@ -40952,27 +66809,37 @@ ismodulefiltration ismoduletopology ismoduletopologyoffinitedimensional ismon +ismonad ismonhom +ismonic ismonicofdegree ismono +ismonochrome ismonoid ismonoidal ismonoidalclosed ismonoidaldistrib ismonoidalleftdistrib ismonoidalrightdistrib +ismonoidequiv ismonoidhomomorphism ismonoidisomorphism ismonoidmonomorphism ismonoidmorphism +ismonoidpreserving ismonomorphism +ismonotone +ismonotonic ismoore ismoored ismooredr ismorapp ismorapplication +ismoreprecise ismoritaequivalent +ismorphic ismot +ismpl ismrc ismrcd ismre @@ -41004,25 +66871,37 @@ ismulleftinvariant ismulpointed ismulrightinvariant ismulspanning +ismultclosedsubset ismulticoequalizer ismultiplicative +ismultiplicativesubset ismultiplypreprimitive ismultiplypretransi ismultiplypretransitive +ismultiregionawskmsarn +ismultiregionawskmsarncorrectness +ismultiregionawskmsidentifier +ismultiregionawskmsidentifiercorrect +ismultiregionawskmsresource ismultorsionfree +ismuttag ismvar ismvarswap ismxidl isn isnacs +isnan isnat isnatcoe isnatd isnatequiv +isnathinitial +isnatinductive isnatlit isnatpowmodt isnatpowt isnatprop +isnatural isnaturalsmul isnclique isncvsngp @@ -41030,14 +66909,19 @@ isncvsngpd isnearsemiring isnearsemiringhomomorphism isnearsemiringmonomorphism +isneg +isnegative isneginvariant isnegnat isnegnnrat isnei isneip isnested +isnet +isneverendingstream isnewarr isneweq +isnewtype isnewvar isnghm isngp @@ -41067,19 +66951,24 @@ isnoetherianring isnon isnonarchimedean isnoncomputable +isnonconstant isnone isnonempty isnonemptydoc isnonloop isnonloopat isnonneg +isnonnegfun +isnonnegroot isnonstrictstrictorder +isnontmnlsym isnontrivial isnonzero isnormal isnormalclosure isnormalepicategory isnormalmonocategory +isnormalsubgroup isnotation isnotdsource isnotdsourcelevel @@ -41088,16 +66977,23 @@ isnotg isnotsource isnotsourcelevel isnotsourcex +isnotzero isnow isnowheredense isnpoly isnpolyh isnrg isnrm +isnseq isnsg isnsgrp isnsqf +isnt isnull +isnulliscontr +isnullisofhlevel +isnullp +isnulltype isnullv isnum isnumbasabl @@ -41110,12 +67006,15 @@ isnvi isnvlem isnzr iso +isoa isoadd isoapp isoas isoaslimitconelift isoaux +isob isobaseofisprincipal +isobif isobina isobinarybiproduct isobinarycofanmk @@ -41123,6 +67022,7 @@ isobinaryfanmk isobiproductembedding isobiprodzero isobjv +isobool isobot isobs isobtainwithoutproof @@ -41137,6 +67037,7 @@ isoco isococycles isocoequalizer isocoforkof +isocohom isocoinvid isocolimit isocolimitcoc @@ -41149,18 +67050,26 @@ isocongrleft isocongrright isoconstant isoconstantaux +isoconv isocoprod isocoproduct isocopyobj isocoreprx isocoskofiscoskeletal isocrystal +isoctdigit isocycle isocycles isocyclesofislimit isod isodd +isoddfalse isoddgcd +isoddiseven +isoddisodd +isoddt +isoddtrue +isodefl isodiag isodiscretepunitofisterminal isoe @@ -41178,6 +67087,32 @@ isof isoffinaddorder isoffinitecharacter isoffinorder +isofhlevel +isofhleveldep +isofhleveldepsuc +isofhlevelfun +isofhlevelfunctor +isofhlevelisconnectedstable +isofhlevellift +isofhlevellist +isofhlevellower +isofhlevelmaybe +isofhlevelmin +isofhlevelpath +isofhlevelpathp +isofhlevelplus +isofhlevelprecomposeconnected +isofhlevelprod +isofhlevelrespectequiv +isofhlevelretractfromiso +isofhlevelsuc +isofhlevelsucifinhabited +isofhlevelsucsuc +isofhleveltrunc +isofhleveltruncpath +isofhleveltypeofhlevel +isofhlevelunit +isofibertotalhopfs isofinyoneda isofinyonedacomponents isofkind @@ -41190,11 +67125,19 @@ isofrlem isofromcomma isofunctorofisoinverse isofunctortheory +isofuninjective +isofunspacejoin +isofunspaces isofval isog +isogecard +isogehom isogh isogp +isogr isogrp +isogrpp +isoh isohom isohomology isoi @@ -41202,13 +67145,16 @@ isoid isoimage isoindexconelift isoini +isoint isoinv isoinversecomp isoinverseofisofunctor +isoinvinjective isoisinitial isoispullback isoispushout isoisterminal +isojoins isok isoka isokernel @@ -41216,11 +67162,15 @@ isol isolat isolate isolated +isolatedness +isolates isolatin isolation isoleftderivedobj isoleftderivedtohomotopycategoryobj isolem +isolemiso +isolemsplit isolevar isolift isolimit @@ -41238,6 +67188,7 @@ isome isomennd isomenndlem isomet +isometr isometric isometriccontinuousfunctionalcalculus isometries @@ -41261,21 +67212,36 @@ isometryl isometryofinner isometryoforthonormal isometryrel +isomgroup +isomichi +<<<<<<< Updated upstream +======= isomidpoint +>>>>>>> Stashed changes isomin isomk isomkfunctor isomksucc isoml isomlin +isomm isomnd +isomni +isomnimap +isomninn +isomninnlem +isomo isomodserre isomor isomorp +isomorph isomorphic +isomorphicd isomorphictypes +isomorphisc isomorphism isomorphismclasses +isomorphismp isomorphisms isomp ison @@ -41319,6 +67285,8 @@ isoopensrange isoopequiv isoover isop +isopair +isopath isope isopen isopenc @@ -41335,16 +67303,21 @@ isopenposmeasure isopenquot isopenquotientmap isopenunits +isoperimetric isoperm isopn isopo +isopointedpointer isopointwiseleftkanextension isopolem isopos isopreequivalenceinversecompproj +isopres +isopresdiscrete isopresheafedspace isoprod isoproduct +isoprojective isopropd isopropdlem isoptimumsolution @@ -41370,16 +67343,22 @@ isorderedsubsetof isorderhomomorphism isordering isorderisomorphism +isordermap isordermonomorphism +isorderpreserving +isorderrecovering isorderrightadjoint isordertheoreticjoinsemilattice isordertheoreticlattice isordertheoreticmeetsemilattice isordertop isordinal +isorefl isorel +isoreplistp isoreprx isores +isoresbr isorestrict isorightderivedobj isorightderivedtohomotopycategoryobj @@ -41396,6 +67375,7 @@ isosctrlem isose isoselem isoselfleradical +isosettruncatesnd isosheafedspace isosheafify isoshift @@ -41405,22 +67385,42 @@ isoso isosolem isosourceofself isospec +isospherejoin +isospherejoinpres +isospheremap +isospheresusp +isosrefcountzeroorone isostandardcomplex isostrongepimono isosubgraphmap +isosucspheresusp isosum +isosusp +isosuspbool +isosusps isotargetofself isoterminal +isoti +isotilem +isotoequiv +isotoid +isotoisiso +isotoisopath isotolinearequiv isotone isotonic +isotonicity isotop +isotopath isotopic isotoplus +isotopy isotosubgraph +isototalspacejoin isotr isotriangleofiso isotropy +isotype isotypiccomponent isotypiccomponents isoun @@ -41428,14 +67428,21 @@ isouniqfunctor isouniquecoconemorphism isouniqueconemorphism isounopopp +isoutput isoutside isoval +isovar +isovarspar +isovarsparnotin +isovarspars +isovarspase isover isovertower isowe isowhiskerleft isowhiskerrigh isowhiskerright +isownedobject isozero isozerobiprod isozeroofepieqzero @@ -41444,9 +67451,11 @@ isozeroofmonoeqzero isozeroofmonozero isp ispa +ispair ispairselfadjoint ispairselfadjointsubmodule isparabolic +isparameterorabstract ispartfunc ispartial ispartialinv @@ -41457,7 +67466,9 @@ ispartitionsplit ispartitiontop ispath ispathconnected +ispathconnectedfinsetofcard ispathgraph +ispathsplitequiv ispautn ispc ispcmp @@ -41471,6 +67482,11 @@ isperfectcompl isperfectmatching isperfpair isperiodicpt +isperm +<<<<<<< Updated upstream +======= +ispermutation +>>>>>>> Stashed changes isperp ispfilter ispgp @@ -41483,6 +67499,7 @@ isphtpc isphtpy isphtpyd ispicardlindelof +ispie ispisys ispisystem isplig @@ -41492,6 +67509,10 @@ isploton ispnrm ispo ispod +ispointed +ispointedcat +ispointedfunctor +ispointedtarget ispointer ispointn ispointwiseleftkanextensio @@ -41531,16 +67552,24 @@ ispointwiserightkanextensionofisoofislocalization ispointwiserightkanextensionofisrightkanextension ispointwiserightkanextensionrancounit ispoly +ispordb ispos isposd +isposet +isposetequiv +isposetequivrespectsjoin +isposetequivrespectsmeet +isposetiso isposi ispositive +ispositivemultclosed isposix ispossemidef ispowmul isppw ispr ispradical +ispragma ispre isprecomplete isprecon @@ -41552,8 +67581,12 @@ ispredlimit ispredprelimit isprefibered isprefix +isprefixduplicate +isprefixelements isprefixof isprefixofandnotnumber +ispreidem +ispreidempotent ispreimmersion ispreirre ispreirreducible @@ -41569,11 +67602,13 @@ ispreservedby isprestack isprestackfor ispretransitive +isprf ispridl ispridlc isprimal isprimary isprime +isprimec isprimepow isprimitive isprimitiveclassified @@ -41585,6 +67620,8 @@ isprincipalidealring isprincipalnonzerodivisorssubmonoid isprincipalsubmonoid isprint +isprintable +ispriv isprivatename isprivatenameexport isprm @@ -41606,7 +67643,16 @@ isprojective isprojectivelimit isprojectivemeasurefamily isproof +isproofirrelevantunit isprop +ispropb +ispropbool +ispropcollapsible +ispropdec +ispropdeepmonicpresentation +ispropdep +ispropdepismonotone +ispropdiscrete isproper isproperinx isproperinxy @@ -41615,14 +67661,121 @@ isproperlinearset ispropermap ispropers ispropersemilinearset +ispropevenorodd +ispropfams +ispropfin +ispropfixpoint +ispropgcd +isprophcontr +isprophomcospancat +isprophseparated +ispropimplicit +ispropis +ispropisabgroup +ispropisalgebra +ispropisalgebrahom +ispropisamonotoniceqv +ispropisantitone +ispropisapartness +ispropiscd +ispropisclosure +ispropisclosuresubset +ispropiscommalgebra +ispropiscommmonoid +ispropiscommring +ispropiscommringhom +ispropisconsdivs +ispropiscontr +ispropisdecprop +ispropisdistlattice +ispropisdualclosure +ispropisdualclosuresubset +ispropisembedding +ispropisequiv +ispropisevent +ispropisfield +ispropisfinset +ispropisfintype +ispropisgcd +ispropisgroup +ispropisgrouphom +ispropisgroupoid +ispropishaequiv +ispropisinim +ispropisinjective +ispropisinker +ispropisiso +ispropisisotone +ispropislattice +ispropislatticehom +ispropisleftmodule +ispropisloset +ispropismono +ispropismonoid +ispropismonotone +ispropismonotonic +ispropisnonzero +ispropisnull +ispropisoddt +ispropisofhlevel +ispropisorderpreserving +ispropispathsplitequiv +ispropisposet +ispropisposetequiv +ispropisprop +ispropisproset +ispropispseudolattice +ispropisquoset +ispropisresidual +ispropisring +ispropisringhom +ispropissemigroup +ispropissemilattice +ispropisset +ispropissetel +ispropissimulation +ispropisstrictorder +ispropissurjection +ispropissurjective +ispropistoset +ispropisunivalent +ispropisweakequivalence +ispropiswoset +ispropiswosetequiv +isproplem +ispropllpo +ispropmaptounitcommring +ispropmonicpresentation +ispropmonoidaxioms ispropositional +isproppath +isproppathp +isproppathtoisprop +isproppopulated +ispropproptrunc +ispropquotrem +ispropr +isproprepfiber +ispropresidue +ispropsingl +ispropsinglp +ispropsubobjmor +isproptoisproppath +ispropunit +ispropvalued +ispropvaluedwosetequiv +ispropwlpo +ispropxs +isproset isprotected isprotometric +isprrel isprrngo isprs isprsd isps ispseudokind +ispseudolattice ispsmet ispsubcl ispsubcln @@ -41631,6 +67784,8 @@ isptfin ispth ispthson isptr +isptrd +isptrornull ispu ispublic ispull @@ -41640,6 +67795,7 @@ ispullback ispullbackequivislimitkernelfork ispullbackofisterminalisproduct ispullthm +ispunct ispure ispurelyinseparable ispushou @@ -41647,9 +67803,17 @@ ispushout ispushoutaddcommgrpfreesheaf ispushoutequiviscolimitcokernelcofork ispushoutofisinitialiscoproduct +ispushoutsquare +ispushoutsuspsphereiso +ispval +ispvals ispwo ispwosupport isqf +isqidem +isqr +isqrt +isqrtd isquadratic isquadraticextension isquantale @@ -41657,11 +67821,14 @@ isquasi isquasiaffine isquasicoherent isquasigroup +isquasiidempotent isquasipreprimitive isquasiregular isquasiring isquasisemimetric isquasiseparated +isquoset +isquote isquoti isquotient isquotientcoveringmap @@ -41685,33 +67852,44 @@ israwnatlit isrbmbhzqymhyipjmjdehc isrclikenormedfield isre +isreach +isreadonly isreal isrealclosed isrec isreceiverof -isrecord isrecvmarker isred isreduced isreduction isref +isrefblock isrefl isrefle isreflection isreflective isreflexive isreflexivepair +isreflexivestrrel +isreflreflclosure +isreflsubobjmor isrefv isreg +isregstr isregular isregularatinfty isregularepi isregularepicategory +isregularframe isregularmono isregularmonocategory isregularofdegree +isregz isrelatedto +isrelation isrelational +isrelaxedprefix +isrelaxedprefixaux isrelhomomorphism isreliff isrelisomorphism @@ -41720,21 +67898,29 @@ isrelmonomorphism isrelprime isrelto isrelupperset +isrep isrepresenta isrepresentable isrepresentation isrepresentationcore isrepresentedby isreproducing +isrepthm isres isreservedname +isresidual +isresidualofunique +isresiduatedbijection isresponse isrestricted isrestriction +isresult +isretr isretrocompact isrev isreversible isrevnth +isrezkcompletion isrfl isrgr isrhm @@ -41753,18 +67939,29 @@ isrightcancelmul isrightcancelmulzero isrightcancelsmul isrightcontinuous +isrightdeal isrightderivabilitystructure isrightderivedfunctor isrightdescent +isrightdistributive +isrightideal +isrightinverse isrightinversion +isrightinvertible isrightkanextension isrightkanextensionid +isrightmodule isrightregular +isrightsubmodule isrightuniformgroup +isrightunital +isrigid isrim isring isringd +isringequiv isringfiltration +isringhom isringhomomorphism isringid isringmonomorphism @@ -41785,6 +67982,7 @@ isrngoiso isrnmeas isrnsiga isrnsigau +isrogercool isroot isrootname isrootsystem @@ -41795,6 +67993,7 @@ isrprm isrrext isrrg isrrvv +isrttnz isrusgr isrvec isrvecd @@ -41823,6 +68022,10 @@ issec isseco issect issection +issectionof +issecure +issecurebelowel +issecureel issecv isselectedleft isselectedright @@ -41830,9 +68033,12 @@ isselectivemagma isself isselfadjoint issemiconjugacy +issemicring issemigroup issemigroupmorphism +issemigrouppreserving issemilattice +issemilatticeequiv issemilatticeinf issemilinearset issemimetric @@ -41841,6 +68047,7 @@ issemireal issemiring issemiringhomomorphism issemiringmonomorphism +issemiringpreserving issemiringwithoutannihilatingzero issemiringwithoutone issemisimple @@ -41868,24 +68075,67 @@ isserreclass isses isset issetalgebra +issetalgebraequiv +issetalgebrahom +issetalgebrastr issetbernoulli +issetbiinv +issetbool +issetcard +issetcommringequiv +issetcommringhom +issetdecprop +issetdeltaint +issetdep +issetel +issetembedding isseteq issetf +issetfin +issetfinexcept +issetfinprop issetft +issetfunctor +issetgrouphom +issetgroupstr +issethprop isseti issetid +issetim +issetimplicit +issetisfinord issetiv +issetker +issetlatticeequiv +issetlatticehom issetlem +issetm +issetmodulo +issetmonotone +issetofcompilableordinalcells issetoid issetoption +issetord +issetorder +issetpathimplicit +issetposetstructure issetri issetring +issetringequiv +issetringhom +issetringstr issetsemiring +issetsettrunc issetssr +issetsumfin issettru issettrualtv +issetunit issetw +issetwoset issetwt +issetx +issety issfinitek issfinitekernel issgon @@ -41913,7 +68163,9 @@ isshortv issibf issifted issiftedorempty +issig issiga +issigmaalgebra issigmacompact issigmafiniteset issigmasubadditive @@ -41933,16 +68185,25 @@ issimplering issimplicial issimplyconnected issimplylaced +issimulation +issimulationunique +issingleton isskeleton isskeletonof isskeletonofinhabited isskewadjoint +isskewnumber +isskewsymmetric issl isslice isslmd isslw issmall +issmallest +<<<<<<< Updated upstream +======= issmallestelement +>>>>>>> Stashed changes issmf issmfd issmfdf @@ -41958,12 +68219,16 @@ issmfled issmflelem issmflem issmgrpold +issmithnormal +issmithnormalempty issmo issmoothat issmoothembedding issmulregular issn issnapshot +issng +issnnull isso issod issoi @@ -41974,14 +68239,26 @@ issolv issolvable issolvableadd issome +issomedata +issomedataelement +issomedataorforward +issomeforwardpointer +issomesome +issomeunused issorryax issort +issorted +issortedproperty issource +isspace isspanning isspath isspec isspecial isspectralmap +isspectrummap +isspherefilled +isspherefilledtrunc issplitcoequalizer issplitepi issplitepicoequalizes @@ -41997,12 +68274,14 @@ isspthson issqf issqrt issquare +issref issrg issrgid issrgwith issrng issrngd issros +isss isssc isssp issstrmgm @@ -42034,6 +68313,9 @@ isstableundertransfinitecompositionofshape isstablyfinitering isstack isstackfor +isstackma +isstackmap +isstackmapframe isstandardetale isstandardopenimmersion isstandardsmooth @@ -42050,7 +68332,10 @@ isstopping isstoppingtime isstric isstrict +isstrictcategory +isstrictinitial isstrictlyge +isstrictlyincreasing isstrictlyle isstrictlyposi isstrictlypositive @@ -42070,9 +68355,11 @@ isstricttotalorder isstrictw isstrictweakorder isstring +isstringthere isstrlit isstrongantichain isstronggenerator +isstronginjective isstronglimit isstronglyatomic isstronglycartesian @@ -42083,37 +68370,59 @@ isstronglyseparatedfor isstronglysheaffor isstronglytranscendental isstruct +isstructim +isstructr isstructure isstructurelike issu +issub +issubalgebraof +issubalgebraofclass issubassa issubc +issubcanonical +issubcanonicalzariskicoverage +issubclass +issubclassof issubdpide issubdpideal issubdrg issubfield +issubfinset issubg issubgoilem issubgr issubgraph +issubgroup issubgrpd issubideal issublattice issubm +issubmap +issubmapby +issubmapof +issubmapofby issubmd issubmgm issubmnd issubmndb issubnormal +issubobj issubobjectfield +issubop issubordinate issubrg issubrgd +issubring issubrng +issubseq issubset issubsetaux +issubstream +issubstring issubterminal issubwalk +issuc issucc issuccarchimedean issuccess @@ -42125,42 +68434,76 @@ issuccprelimit issuccprelimitrecon issue issued +issuer issues issuffix +issuffixl +issuffixof +issummable issumsq issup +issupclass issupclosedcompact +issuperclass +issupersetinterval issupfinitecompact issupported issupportedo issupportedoutside +issupremum +issurj +issurjection +issurjectionbool +issurjective +issurjectivesuspmap +issurjinj isswap +issym +issymbol +issymbolicconstructor +issymbolt issymm issymmetric issymmetricalgebra issymmetricfractionalpolymorphismfor +issymmetricmonoidal issymmetricprojection issymmetricrel +issymmetricstrrel +issymmetricwildcat +issymmmetricmonoidal issymmop issymmsndfderivat issymmsndfderivwithinat +issymsymclosure +issymsymkernel issyntheticsorry ist +istack istackind istactic +istail istangent istangentat +istar istate istateo +istatep istatet istatev istdrg istendo istendod istensorproduct +istensorproductof +<<<<<<< Updated upstream +======= istent +>>>>>>> Stashed changes +istep istermc isterminal +isterminalcategory isterminalcommand isterminaldiscretepunit isterminalequivisopunit @@ -42172,6 +68515,7 @@ isterminaliffobj isterminalincl isterminallast isterminalobj +isterminalobject isterminalofbotcover isterminalofempty isterminalofeqempty @@ -42184,9 +68528,10 @@ isterminaltensorunit isterminaltop isterminalunit isterminalzero -isterminating istermo istermoi +istest +istests istgp istheta isthetatvs @@ -42196,14 +68541,24 @@ isthin isthinc isthincd isthm +isthree isthreecycle +isthunk +isthunkblock istightmeasu istightmeasureset +istimeof +istimeoftimeof istlm istmd +istok +istoken +istokenfactory istop istopclsd +istopfin istopg +istoplogy istopo istopologi istopologicaladdgroup @@ -42216,8 +68571,10 @@ istopologicallytransitive istopologicalring istopologicalsemiring istopologicalspace +istopology istopon istoprelowl +istore istorsion istorsionby istorsionbyset @@ -42225,6 +68582,7 @@ istorsionelem istorsionfree istorsionquot istos +istoset istotalfunction istotallycomplex istotallydisconnected @@ -42237,20 +68595,29 @@ istotbnd istps istpsi istr +istrace +istracefrom istracingenabledfor istrail +istrait istrans istranscendencebasis istransitive istransitiverel +istransitivestrrel +istranssubobjmor +istream istree +istreqv istrg istri istriangularizable istriangulated istriangulatedclosed +istriv istrivial istrivialblock +istrivialgroup istrivialon istrivialphi istrivialrelation @@ -42264,21 +68631,40 @@ istrkgl istrkgld istrl istrlson +istrm istrnn +istrpos +istrprefix +istrprefixp istrue +istrunc +istrunca istruncge istruncle +istruncmap istsr +istt +istuple isturanmaximal istutteviolator +istvals istvc istwoblockdiagonal istwosided istype istypecorrect +istypedfn +istypedfntypedgraphfn +istypedfun +istypedfunin +istypedfuntypedgraphfun +istyperep +istyvart isu +isua isub isubexpr +isubf isubgr isubgredg isubgredgss @@ -42291,6 +68677,9 @@ isubgrupgr isubgrusgr isubgrvtx isubgrvtxuhgr +isubst +isubstr +isubstrp isubtree isuc isucn @@ -42299,9 +68688,13 @@ isufd isufil isufl isuhgr +isuhgrm isuhgrop +isuhgropm isuipapplyexplainuip +isulterm isultra +isultrafilter isultrahomogeneous isultrametric isultrametricdist @@ -42310,24 +68703,33 @@ isum isumadd isumcl isumclim +isumdivapc isumdivc isumge isumgr +isumgren isumgrs isumle isumless +isumlessdc isumltss isummpt isummulc isumneg isumnn +isumodfor isumrecl isumrpcl isumshft isumsplit +isumss isumsup +isumz isun +isunboundedstack +isundef isunderscore +isuneven isuni isuniflocdoublingmeasure isuniform @@ -42338,15 +68740,23 @@ isuniformind isuniforminducing isuniformizer isuniformofempty +isuninitializedobject +isunique isuniquelycodimoneface isunit isunital isunitclause isunitclauseappendvaluation +isunitd +isunitpreserving isunits isunitsmul isunitsubmonoid isunittrinomial +isunivalent +isunivalentcommringscategory +isunivalentpresheafcategory +isunivalentset isuniversal isuniversalcolimit isuniversalequivofiso @@ -42356,66 +68766,111 @@ isuniversalofprecomp isuniversalpostcomp isuniversalprecomp isuniversalprecompequiv +isuniversalproperty isunmixed +isunopresulttype +isunpaddedbase isunramified isunramifiedat isunramifiedatinfiniteplaces isunramifiedin isunsafe +isunused isup isupgr +isupgren isupindep isuplem isuplift isupopencover +isupost isupper +isupperbound isuppermodularlattice isuppermoebius isupperset +isuppertriangular isups isupwlk isupwlkg isuserfriendly isusgr +isusgren isusgrop +isusgropen isusgrs isushgr +isushgrm isusp isuspgr +isuspgren isuspgrim isuspgrimlem isuspgrop +isuspgropen isust isuvtx +isv +isva isval isvalid +isvalidaltera +isvalidator +isvalidgba +isvalidgbarunfor +isvalidinput +isvalidkeyarn isvalidlift +isvalidnil +isvalidstring +isvalidtwo isvaluativetopology isvalue isvaluedin isvankampen isvankampencolimit +isvar +isvars isvciold isvclem +isvclosure isvcold isvec +isvenv isvertexcover isverygood +isveryweakaltera +isveryweakwithorder +isviewon +isvint isvirtuallynilpotent isvisible +isvlam +isvloc +isvnat isvo isvonmbl isvonnbounded isw +iswap iswatn +isweak isweakantichain +isweaken +isweakequiv +isweakequivalence +isweakequivalencetransportfunctor isweakfactorizationsystem +isweakkancomplex isweaklyeisensteinat +isweaklyextensional isweaklyreg isweaklyregu isweaklyregular +isweaknpoly isweakpushout isweakuppermodularlattice +isweanpoly isweier isweierstrassdivision isweierstrassdivisionat @@ -42424,20 +68879,43 @@ isweierstrassdivisorat isweierstrassfactorization isweierstrassfactorizationat isweightedhomogeneous +iswellformed +iswellformedcodeunitsequence +iswellformeddoublecodeunitsequence +iswellformedquadruplecodeunitsequence +iswellformedsinglecodeunitsequence +iswellformedstring +iswellformedtriplecodeunitsequence iswellfounded iswellorder iswellordercontinuous +isweq +isweqcontrtounit iswf iswhitespace +iswhitespacet iswide +iswitness iswlk iswlkg iswlkon +iswomni +iswomnimap +iswomninn +iswomninnlem +isword +iswordt +iswoset +iswosetequiv iswrd iswrdb iswrddm iswrdi +iswrdinn +iswrdiz +iswrdnn iswrdsymb +iswrite iswspthn iswspthsnon iswun @@ -42445,10 +68923,12 @@ iswwlks iswwlksn iswwlksnon iswwlksnx +isxaddr isxmet isxmetd isxms isyes +isz isza iszari iszariskil @@ -42461,17 +68941,35 @@ iszero iszeroat iszeroatimi iszeroatiminfty +iszerobit iszeroi +iszeromulpure iszeroo iszeroormarkovkernel iszeroorprobabilitymeasure +iszffun +iszffune iszgroup +iszigzagcomplete iszlattice +itadvance +itag +itags +itail +<<<<<<< Updated upstream +italicize +======= italianwine +italicize italienisch +>>>>>>> Stashed changes +itau itauto itautocore +itbag itc +itcase +itcb itcoval itcovalendof itcovalpc @@ -42480,12 +68978,28 @@ itcovalsuc itcovalsucov itcovalt itd +itdinput ite iteapp +iteci +iteeq itei iteinduction +itel item +itemcollectionsizeestimatebound +itemcount +itemeqrulelist +itemname +itemnames +itemp +itemprocessday +itemresponselist items +itemsize +itemsspec +itemsubsts +itep iter itera iterat @@ -42505,6 +69019,7 @@ iteratedfderivse iteratedfderivseries iteratedfderivwith iteratedfderivwithin +iteratedhornerforms iteratedlinederivop iteratedlinederivopclm iteratedmateequiv @@ -42523,12 +69038,19 @@ iterateexactly iteratefrobenius iteratefrobeniusaux iteratefrobeniusequiv +<<<<<<< Updated upstream +iteratehead +======= +>>>>>>> Stashed changes +iteratei iterateinduction +iterateispr iterateker iteratemapcomap iteratemulact iteraterange iterates +iteratetail iteratetheory iteratetr iterateuntilfailure @@ -42547,11 +69069,47 @@ iterationobjrightiso iterationobjsucciso iterations iterative +iteratively +iterativemark +iterato iterator +iterators +iteratoruser +iterc +itercodiagonal itercomp +iterconstmult +itercost +itercount +iterdinatural +itere +iteres +iterexpanding +iterf +iterfe +iterfs +iterfsr iteri +iteris +iterismonotonicf +iterismonotonicn +iterm +iternatural +iterop +iterope +iterops +iterrepr iters +iterset +itersr itertosum +iterunfold +iterval +ites +itest +itf +itfmap +itfmapr itg itgabs itgabsnc @@ -42617,15 +69175,41 @@ itgz ith ithe ithi +ithm +itid itill +<<<<<<< Updated upstream +itistime +itl +======= itions +itistime +itl itleaf +>>>>>>> Stashed changes +itlem itlist +ito itop itp +itpoint itr +itrace +itree +itreemonad +itreespec +itreespeceq +itreespecequiv +itreespecmonad +itreetau itrere +itrev +itrm +<<<<<<< Updated upstream +======= itrue +>>>>>>> Stashed changes +itruncate its itschlc itsclc @@ -42638,27 +69222,64 @@ itscp itscplem itself itset +itstate +itt ituni itunifn itunifval ituniiun itunisuc itunitc +ituple itv +itvb +itvbndbnd +itvbndy +itvbndyebigcup itvcc +itvco +itvcy +itvcyebigcap +itvcyp +itve +itvi itvid +itvl +itvn itvndx +itvny +itvnybndebigcup +itvnyc +itvnycebigcap +itvnycp +itvnyo +itvnyy +itvob +itvoc itvoo +itvoy itvp +itvr +itvscc +itvsoo +itvt +itvtheory +itvw +itvxx +itvy +itwasreal +ity itype iun iunab +iunbuig iuncld iuncom iunconn iunconnalt iunconnlem iunconst +iunconstm iunctb iundf iundif @@ -42681,7 +69302,9 @@ iunex iunexg iunfi iunfictbso +iunfidisj iunfo +iunfopab iunhoiioo iunhoiioolem iuni @@ -42696,6 +69319,7 @@ iunionlift iunionnotconvergentseq iunionupto iuniq +iunit iuniversal iunlub iunmapdisj @@ -42735,6 +69359,8 @@ iunssold iunsuc iunun iununi +iununir +iunwinding iunxdif iunxiun iunxpconst @@ -42748,20 +69374,70 @@ iunxsngf iunxun iunxunpr iunxunsn +iutf iuv iuw iuy +iva ival +<<<<<<< Updated upstream +======= ivalid +>>>>>>> Stashed changes +ivals +ivalue +ivanov +ivar +ivarbind +ivarf +ivars +ivb +ivc +ive +ivec +iveric +iverson +iverum +ivficrk +ivhi +iviews +ivir ivl +ivlco +ivlength +ivlo ivls +ivmap +<<<<<<< Updated upstream +======= +ivory +>>>>>>> Stashed changes ivp +ivs +ivseq +ivseqdistinct ivt +ivtable +ivtaglengths ivth ivthalt +ivthdec +ivthdich +ivthdichlem ivthicc +ivthinc +ivthinclemdisj +ivthinclemex +ivthinclemlm +ivthinclemloc +ivthinclemlopn +ivthinclemlr +ivthinclemum +ivthinclemuopn +ivthinclemur ivthle ivthlem +ivthreinc ivu ivw ivx @@ -42772,31 +69448,47 @@ iwasawa iwasawastructure iwf iwlsfsb +iwlsfsbsw iwlsfsbswtr iwlsfsw +iwlsfswsb iwlsfswstr +iwo +iword +iwordsize iwrdsplit iwritert iwrzbb +iwtype iwu iwv iwx iwy +ixa +ixb +ixc +ixe ixi ixmax +ixor ixp ixpconst ixpconstg ixpeq ixpexg +ixpexgg ixpf ixpfi ixpfn ixpiin +ixpiinm ixpin ixpint +ixpintm ixpiunwdom +ixpm ixpn +ixpotpa ixpprc ixpsnbasval ixpsnf @@ -42819,17 +69511,23 @@ ixxub ixxun ixxval ixy +iya iymax +iyouobf iyw iyx iyz +izero +izim izr izro +izrpose izu izw izx izy jaao +jabs jabtaib jac jacobi @@ -42845,12 +69543,27 @@ jacobisymnat jacobitheta jacobson jacobsonspace +jacque jaction jad +jadc +jaddc +<<<<<<< Updated upstream +======= +jaguar jahr +>>>>>>> Stashed changes +jal jalfon +jalr +jam +james jan +<<<<<<< Updated upstream +======= jane +>>>>>>> Stashed changes +janiszewski janne january jao @@ -42863,57 +69576,110 @@ jaodd jaoded jaoi jaoian +japanese jar +jare jared jarl jarli +jaros jarr jarri jarrii jarrsc jath +java +javahea +javalist javascript javatype +jazelle +jbased +jbdnjjb +jbe +jbit +jbody +jbool jca jcab jcad jcadalt jcai +jcajydu +jcc jccil jccir +jcd jcf jch jcn jcnd +jcomma +jcons jcs +jct jctil jctild jctir jctird jctl jctr +jcyfmrp +jde +jdes +jdhaway jdl +jdomtgt +jds +jdwaway jean jech jefe +jejtvgb +jem jens jensen jensenlem jep +jeq +jequiv +jequnbased jeremy +jeroslow +jess +jessie +jest jet jetjpdpvlxitiknnzhq jewell jewett +jfalsep +jfcol +jfmap jfr +jframe +jfrel +jfset jgdez +jgiydle +jglue +jgrap +jgraph +jgtdebu +jgxzygw jhala jhmhuaqufhyeqjwdpnpukekmlswzyttkznefyxmrsqirfippgdecgymgnrap jhpcfjwzslzj jii +<<<<<<< Updated upstream +======= jim +>>>>>>> Stashed changes +jinit jinv +jipsen jizknejvzbqumyvzvmyxxzpyrxaixpklwzsriwxfswijdcogluixr +jjj jjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjj jjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjj jjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjj @@ -42923,61 +69689,171 @@ jjprop jkbpc jkbpcn jkbpcs +jkbpcsn jkbpcst jkbpsec +jkbpt +jkbptn +jkl jkqbymxesfkm +jkqewgv jkqp +jle jlemoldn +jlocinset jlpnlopnmgljvf +jlr +jls jlt jmachinesem +jmaged +jmax +jme jmeq +jmi +jminus +jmitesh +jmono jmp +jmpboot +jmpbooti +jmpbootp +jmpif jmpl +jmrefl +jms +jmsafe +jmstep +jmsym +jmup jmybsjzo +jna +jnb +jnbe +jne +jnew jnf +jnil jniwyqs jnk +jnl +jnle +jno +jnp +jns +jnullp +jnumberp jnv +jnz job jobs jobshop +joe +joed johan john +johnson +johnstone joi join joina joinable +joinabled +joinablei +joinablep +joinac +joinaca +joinannihill +joinassocdirect +joinbi +joinbic +joinbk +joinbkc +joinbool +joinbx joinc +joinca +joincell joincl +joinclosed joincom joincomalt +joincx joind joindef joindm joindmss +joine joined joinedin +joinel +joiner +joineset joineu +joinf +joinfa +joinfc +joinfe +joinfki joinfval +joing +joinga +joingc +joinge +joingg +joingt joinh joini +joinib +joinibc +joinik +joinikc +joinil joining joiniooico +joinir +joinisassociative +joiniso +joink +joinkf +joinki +joinkic +joinkl +joinkr +joinku +joinkuc +joinkx joinl joinle joinlem +joinlist joinlmuladdmuld joinlmuladdmuli joinlmulsubmuld joinlmulsubmuli +joinls joinm +joinmap +joinmk +joinnotation +joinop joinpaths +joinpt +joinpushout +joinr +joinrecdata +joinrecpath joins joinsemilattice +joinsemilatticehom joinsep +joinsp +joinsphereequiv +joinsphereiso +joinswitch joint jointembedding +jointepi jointly jointlyfaithful jointlyreflectepimorphisms @@ -42989,14 +69865,31 @@ jointlysurjective jointlysurjectiveprecoverage jointlysurjectivepretopology jointlysurjectivetopology +jointmono +jointo joints +joinuk +joinukc joinval +joinx +joinxb +joinxc +joinxk +joinxx joldn -jon jonathan +jones +jonsson +jop +jord +jorda jordan jordandecomposition jordandecompositionoftosignedmeasuresub +jordanholder +jordanholderuniqueness +jotswix +joule journal journey jovan @@ -43009,43 +69902,132 @@ jpgqjmpbxuue jph jpi jplem +jpointedprop jpq jps +jptraces +jpxor +jpxorx jqp +jrefl jres +jrh jrkwku jrnksue +jrol +jror +jsafe +jsafen +jsem +jshl +jsize +jsm json +jsonlang +jsonobjecttostringstringmap +jsp +jspec +jspevyt jss +jst +jstar jstate +jstep +jstringp +jsub +jsum jsx +jsys +jtarget jth jtledkxqphtmgxng +jtp jtr +jtruep +jtyabs +jtype +jubju +jubjub judge +judgeme judgement +judgements +judges judgmental +judgsize jug juggle juhashmapcreatecontainskey juhashmapcreateiteratorentryloop juhashmapcreatesize +juic +juice juicy +juicylocks +juicymachine +juicymachineshell +juicymemops juicyrestrict +juicyrestrictacccoh +juicyrestrictalloccoh +juicyrestrictcontentcoh +juicyrestrictcontents +juicyrestrictcur +juicyrestrictcureq +juicyrestrictmax +juicyrestrictmaxcoh +juicyrestrictnextblock +jul +<<<<<<< Updated upstream +======= jules +>>>>>>> Stashed changes +julian +julien julinkedlistcreateremoveall july jump +jumpcmp +jumpf jumpfree +jumpifnotzero +jumpifzero +jumping +jumplist +jumplower jumpncnp +jumppart +jumpparts +jumpreg jumps +jumptable +jumptarget +jumpz jun +junct +juncta +junctb +junction +junctions +junctors +junctp juncts +june jung junk +jushr just +justchangeb +justheapexternaledges +justific +justification +justified justifies justify +justoneerrormessageaboutstarstar +justtesting +justtheisos +jutstkg juxtaposing jvd jview @@ -43057,39 +70039,78 @@ jvmd jvmendset jvmexec jvminstr +jvmnaive jvmnaivecollectionsemantics jvmprog jvmsmall +jvmsmart +jvmsmartcollectionsemantics jvmstep +jvp +jvps jwmabatogatuddzyjizxxlfieseugxipwafincdplloxkrqypxxukmigdpkbnlntscmteltyhkb jwmluidsqrfokamarlhoozvrbkxgeynkyppijwvfododpmsbcbaxuadezqnfnmhebvzmwnnqxri jxadijaenzzhyoskfhkdhysq +jxbjoab jxs jxwagid +jxxx jysjiomjnbbx jzpamrn +jzr kab -kaba kabstract kabstractistypecorrect kabstractpositions +kactioninterpret kad kadane kaehlerd kaehlerdif kaehlerdiff kaehlerdifferential +kaend +kaendf kahler kahn kahnmaltsiniotis +kahomp +kai +kakuro kakutani +kalman +kalways +kami +kamiimplmachine +kamiimplprocessor +kamilabelr +kamilabelseqr +kamimachine +kamimeminit +kamipgminitfull +kamiproc +kamiriscv +kamiriscvstep +kamistep +kamitrace +kamiword +kamixaddrs kampen kan kancomplex +kand +kanext +<<<<<<< Updated upstream +======= +kangaroo +>>>>>>> Stashed changes +kap kapl kaplansky kaplanskyset kappa +kappamd +karamel karatsuba karden kardex @@ -43097,66 +70118,139 @@ kargs karoubi karoubichaincomplexequivalence karoubicochaincomplexequivalence +karoubiembedding +karoubienvelope karoubifunctorcategoryembedding karoubihomologicalcomplexequivalence karoubikaroubi karoubiuniversal karp +kas kasfmilooetdydhpbzhuwl kashiwara kat katagoriaverifier kathzorottmuuwhpwuqkbqbdrtvcggpgwrkqdbwwdrfbwhsmqxcmjioukj katona +katsumi +kau kauff kauffman +kaufm kaufmann +kaut +kaute +kautf +kautfe +kautl +kauts kawaguchi kaxiom +kay kbar kbass kbfdompwygahinfrih kbfval kbimka +kblock +kblocked kbmul kbo kbop +kbp +kbpalg kbpj kbval +kca kcall +kcast +kcatch +kcblrqc kcdptr +kcfg +kchmamg kck kckckck +kcknows +kclkont kclosed kcnktkm +kcoc +kcockont +kcockontt +kcocl +kcocwl +kcocwlr kcomp +kcompile +kcompl kconn +kcp +kcunifyl +kcunifywl +kcunifywlr +kcwalkstar +kcwalkstarl +kcwalkstarwl +kcwalkstarwlr +kczxlle kdbe kdecidableeq kdelta +kdenotation +kdenote kdf +kdfcountermode +kdfcountermodeensurespublicly +kdfrawderivetest +kdftest kdiff +kdown kdt kdtl keccak keccakf keep +keepel +keeper keephyp +keeping +keepresult keeps keepterm keepusing keg +kel kelac kelly +kelts +kelvin +kem +kemcontext +kempty +ken kencode +<<<<<<< Updated upstream +kenken +======= +>>>>>>> Stashed changes +kens +kepler kept +keq +keqd +keqi ker keradjunction kerase kercomplementequivrange kercomppreimage +kercon +kercoset +kercosetp kercotangenttotensor kercvrlsm +kerd kere kereq kerequivrange @@ -43164,15 +70258,22 @@ kerf kerfun kerfunctor kergen +kerhab +kerhk kerhomogeneouscochainszeroequiv +keri kerideal keridl +kerincl keriskernel +kerl kerlidl kerlift kerliftalg kerlmhm kerltensorequivofsurjective +kermx +kermxp kern kernel kernelandmeasure @@ -43188,6 +70289,7 @@ kernelfactorthruimage kernelfork kernelforkbiproducttosubtype kernelforkoffork +kernelfuns kernelisisocomp kerneliskernel kernelislimit @@ -43197,6 +70299,7 @@ kernelisoofeq kernelopop kernelopunop kernelorderhom +kernelp kernelpair kernels kernelsequence @@ -43210,49 +70313,135 @@ kernelsubobject kernelsubobjectiso kernelsubobjectisocomp kernelsubobjectmap +kernelt kernelunopop kernelunopunop +kernelvals kernelzeroisosource kernimage kernm kernmap kerodon +kerp kerparam kerproj +kerquo +kerr kerrepr +kers kersquarelift kert kertensorproductmapidtoalghomequiv kertotal kertotensor +keruip kerunit +keshav kestrel ket ketbra +ketplus +keval kevin +kex +kexg +kexists +kexp kextract key +keya +keyal +keyargs +keyb +keycount keyd +keydescription +keydescriptionlisttojson +keydescriptiontocmm keyed keyedconfig keyedqualifier keyexpansion +keyexpansionloop +keyfree +keyfun keygen +keyhash +keyhat keyi +keyid +keyidtype +keying keylem +keylength +keylist +keym +keymaterial +keyn +keyp +keypair +keypart keypred +keypt +keyquiv +keyring +keyrings keys +keysareunique keysaspattern +keysched +keyscheds +keyschema +keyschemaattributename +keyset +keysetup keysfor +keysforprod +keysini +keysized +keyslices keyslookupequiv +keysp +keyss +keyssecrets keysspecific +keystore +keystoreclient +keystorepasswordtype +keystoset +keysw +keytype +keyunf +keyva +keyval +keyvallist +keyvalue +keyvalues +keyvectors +keyvectorsconfig +keyvectorstypes +keyw keyword +keywordp +keywordps keywords +keywordsp +keywordt +keyx +kfa kfbh +kfcomp +kfcompk +kfcompkindic +kff +kfg +kfilt +kfilter +kfilterp +kfp +kfpi +kfree kfsc -kfst -kfstpaireq -kfstsingleton kfum kgbhrulhawpbclp kgen @@ -43269,75 +70458,177 @@ kgentopon kgenuni kgenval kgophqhkhjnztfkzjyhqcwyndswpzhnurglrn +kgproof kgrtriex kgrtriexlem +khejkci +khg +khigh +khint khl +khms kho +khom +khomextend +khomextende +khomextendp +khomf +khomp +khoms +khomsl +khomsr khop khoyjd kic +kick +kicks kid +kidlist +kids +<<<<<<< Updated upstream +======= kiel +>>>>>>> Stashed changes +kification +kik kildall kill killcompl killcomplfun killcopies killed +killersudoku killing killingcompl killingform kills +kilo +kilogram +kilt kin kind +kinda +kindcode +kinding +kindly kinds +kinematics +kingman +kingoftown +kini +kinit kinsert kinv kir kirchberger kirszbraun +kism +kit +kite +kiumvtc kiztypubacahqvtmevgsvlhm +kjeeps +kkbnd +kkg +kkgbnd +kkk kkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkk kkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkk kkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkk kkm +kknows kks kkuumhoehnkvogbcr +klamf +klass +klbl kldiv kle kleene kleenealgebra +kleenecoalg +kleenestore +kleft +klein +kleinbottle +kleinen kleinfour +kleinfun +kleinify kleisli kleislicat kleislistar kleitman klem +klema +klemma +klen klenne +kleymann klfun kli klift +klist klkjpkxjdqq +kloop +klop +klow +klr +klt +kludge +kluwer kmax +kmc +kmd +kmem +kmemd +kmemi kmemptr +kmf +kmg +kmgamma +kmh kmill kmin +kminsm +kminus +kmk kml kmlem +kmodel kmp +kms +kmsarn +kmsc +kmsclient +kmsclientconfigtype +kmsconfiguration +kmskeyarn +kmskeystoreoperations +kmsm kmtod +kname +knapp knapsack knaster knatar +<<<<<<< Updated upstream +======= knave +>>>>>>> Stashed changes +knc knd kne +knegsuc kneser knew -knight knights +knil +knk kno knock +knone +knopp knoppcld knoppcn knoppcnlem @@ -43346,30 +70637,51 @@ knoppndv knoppndvlem knorm knot +knoteq knots know knowing +<<<<<<< Updated upstream +======= knowle +>>>>>>> Stashed changes +knowledg knowledge -knowledgefragmentd -knowledgeofacause -knowledgeofeffect known +knownadd knownkinds knownnature +knownp knownproof knowntobefinsetnots knowntobefinsetnotset knowpq knows knowspq +knpath knuth +koc +kochen +kocwl koenig +koenigsberg koenigslemma +kofs +kofz kol +kolakoski +kollec +kollect +kolmog +kolmogorov kolmogorovcondition +kolmogpf +<<<<<<< Updated upstream +======= kolosseum +>>>>>>> Stashed changes kolwgydim +komwbwc konig konigdown konigdtree @@ -43384,17 +70696,34 @@ konigsbergumgr konigsbergvtx konigth konigthlem +kont +kontinuation +koo +kop +korczy +korni +korolkiewicz +korselt +kotowicz kozen -kpair -kpairiskpair -kpairp -kpairsurjeq kpakknkhdaiorm +kpc kpi kpirdanvmsvthrbe +kplus +kpm kpos kpower +kpq +kprm +kprod +kprodkl +kprodkr +kproduct +kproof kprop +kprv +kpsm kpybwnjoghqcwhakpwbxteudnjbfd kqcld kqcldsat @@ -43415,19 +70744,38 @@ kqsat kqt kqtop kqtopon +kquo kqval kraft krasner +kraus krchnctapyhjreklcwjzg krebs krein +krelation kreplace +kresume +kreverse +krf +krh +kright kripke +kripkei +kripkeintuitionistic +kripkeintuitionisticsemantics +kripkeminimunsemantics +kripkemodalsemantics +kripkemodel +kripkemodelclass +kripkepropositionalsemantics kripkesem +kripkesemantics +kripkestr krippen krippenlem kritkkngytcfwvuqk krl +krml kron kronecker kroneckeralgequiv @@ -43441,9 +70789,11 @@ kroneckertmulalgequiv kroneckertmulbilinear kroneckertmullinearequiv kroneckertmulstaralgequiv +krp krrpuvmmoeznybzeznpwzqzklxlkleqcsymotiwyhgtjrthisc -krs kru +krueger +krug krull krulldim krulldimension @@ -43453,117 +70803,295 @@ krulltopology krun kruskal kruv +krzysztof +ksa +ksaactioninterpret +ksaair ksafe +ksap +ksapplicative +ksat +ksatis ksc kseq +kseqlist +kseries +ksigned +ksimplex +<<<<<<< Updated upstream +ksmap +ksn +======= ksl +ksmap ksn ksnd ksndpaireq ksndsingleton +>>>>>>> Stashed changes +ksoqkwl +ksound +ksoundness +kspure ksrywxurp +kss kst kstar +kstari kstate kstep +ksteps +kstop kstoptr ksucc ksum ksup +kswitch +ksym +ksyntax ktcs ktcua +kterm kth +kthy +ktox +ktree kts +ktyp kudryashov +kuhn kummer +kunify +kunifywl kunion +kunsigned +kup +kupd kur +kurat +kurato +kuratowki kuratowski kuratowskiembedding +kuratowskifunction +kurexset kurzweil kusubmtooompwik +kval +kvalid kvalue kvaobrojjnrqz +kvar +kvd kvimpl +kvl +kvlist kvmap kvpairformat kvqdxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxgsxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxfavxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxbtspfvebxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxyxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxykaxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxenxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxjxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxdvorcaxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +kvqwydl kvs -kvsa kvspec +kwan +kwargs +kwd +kwds +kword +kworda +kwork +kworlds +kwote +kws +kxa +kxb +kxc +kxeq +kxh kxs kxy kyber +kzero +laa lab +labasm +labc +labe label +labeladjacent labelatin labele labeled +labelede +labeledexpressions +labeledge +labeledmultiparams +labeledn labeledparams labeledstepasync labeledstepfailure labeledstepordereddynamicfailure labeledsteporderedfailure +labeledv labelgraph +labelidxs labeling +labelingseq +labell labelled labelledcopycount +labelledimp +labelledimptypes +labelledprint labelledstar labelledstars +labellen labelling +labeln +labelnotinscope labelposs +labelregressions labels +labelseqt +labelset +labelsi +labelsout +labelsucs +labelt +labelusedinghostcode +labelvertex +labf +labh +labl +lablang +<<<<<<< Updated upstream +labor +laborious +======= laborious labproof +>>>>>>> Stashed changes +labprops +labq labs +labsem lac +lacc +laccv laced lacimi lack +lacking lacks lacomp +laconstante lact lactghmga lactive lactlmhm +lad ladd ladder laddr laddrotrd +ladj +ladner +laei lagrange lagrangebarycentric +lagrangei +lagrangeml +lagrangemr +lagree lagsubg +lahf lake +lal +lalala +lalcii +lalg +lalgebra +lalgmixin +lalgtype lalign laligned +lall lalternate lam +lamapp +lamb +lambd lambda +lambdaab +lambdab lambdaboundedtelescope +lambdac +lambdad +lambdadefrec +lambdadefrecd +lambdadms +lambdafs +lambdafy +lambdaidx lambdalettelescope +lambdamcart lambdametatelescope +lambdamsfd +lambdamsfr +lambdanatc +lambdap +lambdapair +lambdapfd +lambdaps +lambdar +lambdarealseq +lambdarec +lambdareccorrd +lambdarecex +lambdarecexd +lambdarecun +lambdarecund lambdas +lambdasep +lambdaseqbinopdef +lambdaseqbinopex +lambdaseqbinopun +lambdasigmasseq +lambdasp +lambdastarstar lambdasyntax lambdasyntaxlinter lambdatelescope lambdatelescopereduce +lambdatest lambdatheorem lambdatheoremargs lambdatheoremsext lambdatheoremtype +lambdathy lambert lamberte +lamberti lamda +lamdbl lame lameq +lameqvsubst +lameta +lamext +lamfn +lamg +lami +laml lamlemmas -lamm lamp lamparens lamport -lamprop lams lamsubst +lamsum +lamt +lamvar +lamz lan lanadjunction lanbasechange @@ -43573,23 +71101,49 @@ lancompisoofpreserves lancompisowhisker lancondensedset land +landa +landadj +<<<<<<< Updated upstream +======= landarea +>>>>>>> Stashed changes landau +landc landesc +landexistsd +landexistsdl +landexistsdr +landforalld +landforalldl +landforalldr +landl +landmark +landr lands +landt +landtruel +landtruer +<<<<<<< Updated upstream +======= landvehicle +>>>>>>> Stashed changes +lane +lanep lanes lanevaluationisocolim lanfn lanfval lang langage +langford langi langle langpow langs +langu language languageequivequivringequiv +languagei languages laniskan lanleftextension @@ -43602,7 +71156,6 @@ lanliftleftlift lanliftunit lanlightcondset lann -lanna lannot lanpresheaf lanpresheafext @@ -43614,76 +71167,154 @@ lansheafprofinite lanunit lanup lanval +laof laorjknalecr lap laplace laplaced +laplaceexpc +laplaceexpl laplacei laplacian laplacianclm laplacianwithin lapmatrix +lapmech lapp lappend lappfin +lapping lapply lapprox lappt +lapq +laprepsp +lar +lard +larg large largea largecategory +largecumulative largecurriedcoyonedalemma largecurriedyonedalemma largei +largeislarge +largelist largely larger +largerp largersubobject +larges largeschroder largeschroderseries largeschroderseriesseries largest +largestelementexists +larget +largs +<<<<<<< Updated upstream +======= +lark +>>>>>>> Stashed changes +larm +larrow +larrowt +lars +las +lasc +<<<<<<< Updated upstream +======= laser +>>>>>>> Stashed changes +laspm lass +lassertrule lasso +lassoc lassocr +lassreds +lassredsthrow +lassredsval last lastapplied +lastatom +lastb +lastbit lastbits +lastbl lastblock lastblockinvariant +lastcaseisdisjunctive lastcases +lastchartonat lastcomponentasstring +lastcp +lastcpin +lastcptl lastdart lastdeclm laste +lastent lastfun lastfunctor lastfv +lasti lastidx +lastinitblock lastislargest +lastkey +lastkeye +lastkeyfun +lastkeypt +lastkeyptun +lastkeyun +lastkeyunf +lastkeyxx +lastlistinlist +lastloc +lastm lastn lastnode +lastnthgray +lastp +lastpass +lastprecedesnoelement +lastprune +lastr +lastrng lasts lastss laststep lastt +lasttailok +lasttheorem +lastval +lastvalpt +lastvalun lasymm lat latabs latasym latasymb latasymd +lataugmentation latch +latchbody +latches +latchlits latcl latcost latdisd latdisdlem late -lateharvest latency later latercommand +laterinprefixretainsprecedes +laterm laterprocessdecidessamevalue +laterr latest latestact latestactex @@ -43691,8 +71322,8 @@ latestactless latestactnxt latestactnxtact latestthread +latex latin -latitude latj latjass latjcl @@ -43703,12 +71334,12 @@ latjjdir latjle latjlej latjrot +latlaws latledi latleeqj latleeqm latlej latlem -latlong latm latmass latmassold @@ -43724,6 +71355,7 @@ latmrot latnle latnlej latnlemlt +latom latpos latref latsn @@ -43731,8 +71363,11 @@ latsubgr latsum latt latter +latti +lattic lattice latticebasis +latticecategory latticeclosure latticecon latticeequiv @@ -43740,19 +71375,34 @@ latticeequivprod latticehom latticehomclass latticeisos +latticelaws latticeops latticeorderedaddcommgroup latticeorderedcommgroup +latticepath lattices +latticescategory +latticestr latticestructure +latticetype +lattind lattobddlat lattobddlatcompdualisodualcomplattobddlat lattobddlatforgetadjunction lattposet lattr lattrd +lattrel +lattrelstr +lattstr +laub +<<<<<<< Updated upstream +======= laughing +>>>>>>> Stashed changes launch +launches +launder laurent laurentaux laurentpolynomial @@ -43812,26 +71462,37 @@ lawson lawsonbasis lawsonclosed lawsonopen +lawve +lawvere +lawveretheories +lawveretheory lax laxbraided laxbraidedfunctor laxbraidedtocommmon laxfunctor +laxl laxmonoidal laxmonoidalequivoplaxmonoidal laxmonoidalfunctor laxmonoidaltomon laxpq +laxr +laxslice laxtrans +lay layer layercake layercakeintegral layercakelt layered layers +layoff +layoffunique layout layoutkind layoutlib +layouts laz lazard lazarus @@ -43840,39 +71501,81 @@ lazy lazydiscrtree lazyentry lazym +lazyrace lba +lbalance +lbang +lbare lbasicrule lbasis lbcases lbcl +lbda +lbdt lbe lbex +lbfr lbfzo +lbg lbi +lbiased lbicc lbico +lbignum +<<<<<<< Updated upstream +======= lbill +>>>>>>> Stashed changes +lbind +lbindtrule lbinf lbinfcl lbinfle lbint lbioc lbioo +lbioog +lbit +lbits lbl lble +lblock lblockz +lblot lbls +lblstmt +lblstmts +lbn +<<<<<<< Updated upstream +======= lbob +>>>>>>> Stashed changes +lbody +lbopt lborel lbot +lbou lbound lboundmin +lboundp lbounds +lboundt lbp +lbpc +lbpn +lbr lbrace +lbracet +lbrack +lbracket +lbrackt lbrak lbrakk +lbranch +<<<<<<< Updated upstream +======= lbrb +>>>>>>> Stashed changes lbreu lbs lbsacsbs @@ -43894,14 +71597,40 @@ lbspropd lbspss lbssp lbsss +lbt +lbtr +lbtree +lbtupi +lbu +lbuffe +lbuffer +lbuiltin lbutlast +lbv +lbytes lbzbi +lca +lcadd +<<<<<<< Updated upstream +======= lcade +>>>>>>> Stashed changes +lcall lcancel +lcancelaction +lcancelp +<<<<<<< Updated upstream +======= lcardinalityfn +>>>>>>> Stashed changes +lcase +lcases +lcc +lccc lcd lcdfval lcdh +lcdiv lcdlkreq lcdlkreqn lcdlmod @@ -43910,6 +71639,7 @@ lcdlss lcdlssvscl lcdlvec lcdneg +lcdom lcdsadd lcdsbase lcdsca @@ -43930,23 +71660,40 @@ lcdvsubval lcdvsval lce lceil +lcell lcf lcfl lcfls lcfr lcfrlem lcfrvalsnn +lcfun +lcfunp lcg +lch lchild +<<<<<<< Updated upstream +======= lchris +>>>>>>> Stashed changes +lchro lci +lcinner +lcinv +lcirc +lck lcl lclause +lclicovno lcliff +lclique +lcliqueno +lcliquewise lclkr lclkrlem lclkrs lclkrslem +lclosed lclss lcm lcmabs @@ -43982,51 +71729,104 @@ lcmgcd lcmgcdeq lcmgcdlem lcmgcdnn +lcmgi lcmid lcmineqlem +lcml +lcmlat +lcmlatplus lcmledvds +lcmmndc lcmn +lcmna +lcmnac +lcmnaca +lcmnc +lcmnca lcmneg +lcmnml +lcmnmr +lcmo +lcmp +lcmr +lcmult lcmval lcn +lcne +lcnj +lcnp +lcns +lcnsn +lcnsns +lcntl lco lcoc lcoeff lcoefun lcoel lcof +lcoh lcol lcomapdomain lcomf lcomfsupp lcomm +lcomma +lcommuting lcomp lcompact lcompare +lcompat lcomplement lcompletedfrom +lcompri lconc lconcat +lconcatmap lcond +lcone lconf -lconfl lconfluent +lcong lcongr +lcongruence +lconj lconjaction lconjby +lconjs lconjseq lcons lconsd lconse +lconset +lconsi +lconsilist lconsnlist lconst lconsts +lconstt +lcontinuous lconv lcoop +lcop +<<<<<<< Updated upstream +======= lcorina +>>>>>>> Stashed changes lcorrect +lcos +lcose +lcoselt lcoset +lcosete +lcosetk +lcosetkv +lcosetm +lcosetp lcosetrel +lcosets +lcosetsp +lcosetv lcosi lcosn lcoss @@ -44036,6 +71836,7 @@ lcounts lcoval lcp lcproof +lcr lcrec lcrow lcs @@ -44044,6 +71845,8 @@ lctx lctxisdefeq lctxnames lcurry +lcurt +lcut lcv lcvat lcvbr @@ -44054,26 +71857,42 @@ lcvnbtwn lcvntr lcvp lcvpss +lcx +lcy lda +ldb +ldc ldcfg ldd +ldec +ldecidable ldecl +ldecs ldeep +ldefseq ldep +ldependent ldepslinc ldepsnlinc ldepsnlinclem ldepsnzr ldepspr ldepsprlem +ldepth lder lderiv +lderivs ldg ldgdomn ldgenpisys ldgenpisyslem ldgn +ldi +ldiagram +ldiese ldiff +ldih +ldihatn ldil ldilcnv ldilco @@ -44081,26 +71900,50 @@ ldilfset ldillaut ldilset ldilval +ldir +ldist ldistinct ldistr ldistrib ldiv +ldivj +ldivp +ldivt ldl ldlem ldlf ldlfcntref +ldm +ldmfd ldo ldogen +ldom +ldomk +ldomp +ldomun +ldone ldot ldots +ldp +ldpu ldr +ldrb +ldrh ldrop ldropn +ldropt +ldropuntil ldropwhile +ldrsb +ldrsh +lds ldsb +ldsj +ldsk ldst ldsysgenld ldt +ldtr ldual ldualelvbase ldualfvadd @@ -44137,6 +71980,9 @@ ldub lduba lduh ldummy +ldurdpn +ldw +ldwk ldwxolarsqindqrrwdsd lea leabs @@ -44145,12 +71991,14 @@ leabsi leabss lead leadd +leaddc leaddle leadds leaddsub leaddsubgroup leaddsuble leader +leadercommit leaderid leaderlog leaderlogs @@ -44165,68 +72013,140 @@ leadingcoeffc leadingcoeffhom leadingcoeffnth leadingterm +leadingzeroinsignificant leadprec leads leadsto +leadz leaf +leafcount leafd +leafdomain +leaffn +leafn +leafp +leafptrs leafs +leafw leagne +league leak leakage +leakageevent +leakagesemantics +leakageweakestprecondition leaked +leakevent leaking leaks leaky lean +leange leanprove leanprover leans leansearchclient +leao +leap leapfrog +leaq +lear learn learned learning +learnl +learnlessstate +leas least leastbi +leastbit leastext +leastfielddecl leastge +leasti +leastlemma +leastmethoddef leastofbdd +leastp +leastpredicate +leastsignificantdigitisalmostmod +leastsort +leastsorts leat leatb leattop +leav leave leavemult leaves +leavesi +leavesp +leavex +leavi leaving leb lebase +lebc +<<<<<<< Updated upstream +======= lebesg +>>>>>>> Stashed changes lebesgue +lebesgued lebesguedecomposition +lebesguei lebesguenumberlemma +lebf lebi lebilem lebint +lebku +lebl +leblr +lebmma lebnum lebnumii lebnumlem +lebool +lebr +lebrl +lebsesgue +lebuk +lebx lec +lecadd +lecard lecasei leceifl +lecex +lecidg lecl lecldbas lecm lecmi lecmii lecmtn +lecncvg +lecom lecomap +lecon +leconnnc +lecponc +lectr lecture lectures +lecx led +ledec +ledgeless +ledger +ledges ledi ledigits ledii +ledio +ledior +ledir lediri lediv ledivdiv @@ -44238,24 +72158,52 @@ ledivnn ledivp ledm ledx +lee +leeb +leebig +leebldl +leebldr +leebrdl +leebrdr +leed +leedl +leedr +leeereal +leejoin leel +leemeet +leen +leenat +leenl +leenr +leeny leeq leescatghzvlnkfycuogbturbutezleiazytrsvmc leex leexp +leey lef +lefalseempty +leff lefi lefimpt +lefinaddc +lefinlteq +lefinrflx lefld lefldiveq lefnum lefnumzero +lefp left +leftabsorb leftact +leftaction leftactionofmonoidaloppositerightaction leftactionofoppositeleftaction leftadd leftaddresiduation +leftadj leftadjoi leftadjoint leftadjointcommshift @@ -44278,12 +72226,18 @@ leftadjointsquareconjugate leftadjointuniq leftalternative leftarrow +leftassoc +leftassociativity leftassoctensor +leftbackslash +leftbackslashsimpl leftbol leftbolloop leftc leftcanceladd leftcancelequiv +leftcancellable +leftcancellation leftcancellative leftcancelmonoid leftcancelsemigroup @@ -44293,11 +72247,20 @@ leftcomp leftcompreflexion leftcongruent leftconical +leftcontext +leftcontextlist leftcoset leftcosetequivalence leftcosetequivsubgroup +leftcountguess +leftctxt leftderiv leftderivation +leftderivationfix +leftderivationfixorintro +leftderivationintro +leftderivationintrosat +leftderivationladder leftderivations leftderived leftderivedlift @@ -44309,15 +72272,22 @@ leftderivedzeroisoself leftderives leftdescent leftdistd +leftdistr leftdistrib leftdistribclass +leftdistribute +leftdistributive leftdistributor leftdivides +leftdot +leftdotgeneralized +leftdotsimpl leftdual leftdualequiv leftdualfunctor leftdualiso lefte +lefter leftexact leftexactfunctor leftexactfunctorequivalence @@ -44325,10 +72295,13 @@ leftexactfunctorforgetequivalence leftextension leftextensionequivalenceofiso leftf +leftfactorlteproduct +leftfactorsurjective leftfixedpoint leftfixedpoints leftfraction leftfractionrel +leftfull leftfullyfaithful leftfun leftfunc @@ -44356,7 +72329,10 @@ lefthomotopyclassequivrighthomotopyclass lefthomotopyclasstohom lefthomotopyrel lefti +leftid +leftideal leftidentity +leftinreversed leftinv leftinvariant leftinvariantderivation @@ -44366,11 +72342,16 @@ leftinvequiv leftinverse leftinverseunitor leftinvertible +leftinvhspace +<<<<<<< Updated upstream +======= leftinvissurj +>>>>>>> Stashed changes leftinvon leftinvseq leftirr leftiso +leftist leftkan leftkanextension leftkanextensioncompisoofpreserves @@ -44379,24 +72360,42 @@ leftkanextensionobjisocolimit leftkanextensionunique leftkanextensionuniqueofiso leftkanextensionunit +leftkanfam +leftker +leftlang leftle leftlift leftliftingproperty leftlim +leftlinearcombination +leftloc leftlt leftmap +leftmod leftmodule +leftmoduleequiv +leftmodulehom +leftmodulehomomorphism +leftmodulepath +leftmodulestr leftmonotonic leftmost +leftmostcmd leftmostlookahead leftmostlookaheads +leftmostrell +leftmostrelr leftmul leftmulmappregns leftmulmatrix leftmulresiduation +leftn leftneutral leftno leftnod +leftnode +leftnp +leftof leftofineqproof leftofmul leftofpartition @@ -44404,17 +72403,25 @@ leftold leftoldd leftop leftopcomp +leftoperation leftopid leftoprightopequiv leftoprightopiso +leftoptions leftopwhiskerright leftordcontinuous leftorrightcancelsemigroup leftorthogonal leftover +leftp leftpad +leftperi +leftperimeter +leftperimeterguess +leftprefixlang leftprincipal leftproperviaequiv +leftquasi leftquotient leftquotientequiv leftregular @@ -44436,17 +72443,30 @@ leftrigid leftrigidcategory leftrigidcategoryofequivalence leftrigidcategoryofrightrigidcategory +leftro +leftrotate +leftrotation +lefts +<<<<<<< Updated upstream +leftsappend +======= +>>>>>>> Stashed changes leftsection leftsemimedial leftsemimodule +leftshft leftshift leftshiftaddequiv leftshiftlinearequiv leftside +leftslash +leftslashsimpl leftsquareispullback leftssno leftssold leftstructure +leftsubmodule +leftsuspensioniso lefttomax lefttoright lefttotal @@ -44456,6 +72476,7 @@ lefttransversals lefttriple leftuniformspace leftunique +leftunit leftunitor leftunitorbimod leftunitorcorepresentingiso @@ -44468,25 +72489,44 @@ leftunitornatisocat leftunop leftunshift leftval +leftwrapper +lefty leftzero leftzigzag leftzigzagiso lefulppos leg +legac legacy +legacytypesystemcannotinfertypes legal +<<<<<<< Updated upstream +======= legalagent legalconviction +>>>>>>> Stashed changes +legalhistoryantichain +legalinvariants +legaltransition +legaltransitionssequence +legaltransitionssequenceanythread +legato legbtwn +lege +legend legendre legendresym legendresymbol legeometric legeq +legesgue legible +legibly legid +legit legov legs +legsmallerhypotenuse legso legtbcpfztdmzhry legtrd @@ -44495,9 +72535,12 @@ legtrid legval lehmann lehmer +lehmercode +lehmerequiv +lehmerfinequiv lehmers +lehmersucequiv lei -leibeq leibnitz leibniz leibnizadjunction @@ -44512,26 +72555,40 @@ leid leidd leideal leidi +leifp +leiidl +leiidr leijen +leil leinductionon leinf leinfcone leinfty +leir leisclosable leiso leisorel +leispr +leix lejdii lejdiri lejoin lel +lelan lele lelem lelista leloe leloed leloei +lelor +lelr leltadd leltaddd +leltap +leltapd +leltctr +leltfintr leltletr leltne leltned @@ -44545,6 +72602,12 @@ lelttri lelttric lem lema +lemaa +lemab +lemabsisrootofsquare +lemabsneg +lemabsnegneg +lemabsrange lemaddoverscale lemaffineapproxdomaintranslation lemaffineapproxrangetranslation @@ -44557,11 +72620,25 @@ lemaffineiscts lemaffineoflineisline lemaffineofpointonline lemaffofaffisaff +lemana +lemanb +lemanno +lemannonoabrupt +lemap lemapproxequalatbase lemaptop +lemasfunctofunc +lemax lemaxisisline lemaxle lemb +lemballcontainscentre +lemballinball +lemballpopulated +lembb +lembedand +lembedimpl +lembi lembijectionontwo lembijinv lemc @@ -44572,101 +72649,582 @@ lemcauchyschwarzequalityinunitsphere lemcauchyschwarzsqr lemcausalorthogmtolightlikeimpliesparallel lemccone +lemcl lemclassification lemconecontainsvertex lemconecoordinates lemconelemma +lemconeofobserved lemconesexist lemcphoton lemcpos lemcprops lemctsofctsiscts lemd +lemdiffdiffadd +lemdiffsumcancelmiddle lemdirectioncollinear lemdirectionfromto lemdirectionjoining lemdirectionreverse +lemdistancesadd +lemdistancesaddstrictr lemdotcommute +lemdrtn lemdrtnlinejoining leme lemeet lemelementsofset +lemequalsquares lemf lemfromtoto lemg +lemgenzgt +lemh lemi +lemidislinear lemin +lemininf leminjectivevalueunique leminjofinjisinj leminsidecone +leminsideregularconeimplies leminsideregularconeunderaffinvertible leminverseaffine leminversecomposition +leminverselinear leminverseofaffinvertibleisaffinvertible leminvertibleonmeet +lemj +lemk +leml +lemle +lemlenzlt +lemleplus +lemlineandpoints +lemlineariffmatrix lemlinearimpliesaffine +lemlinearisbounded +lemlineariscts +lemlinearismatrixapplication lemlinearpartisunique +lemlinearprops lemlinecontainsbasepoint lemlinecontainsendpoint +lemlinedefinedbypair +lemlinedeterminedbypointanddrtn lemlineendpoint lemlineinsideregularconehasfiniteslope +lemlinejoiningcontainsendpoints lemlinejoiningunderaffine lemlinemeetscone lemlinevelocitynonzeroimpliesfinite lemlinevelocityusingpoints +lemlinoflinislin lemm lemma lemmaa +lemmaaddingnextregularframe +lemmaaddmodnoop +lemmaaddmodnoopauto +lemmaaddmodnoopright +lemmaaddmodnooprightauto +lemmaalgorithmsuiteidimpliesequality +lemmaall +lemmaappendlast +lemmaassignedcodepoints +lemmabasicdiv +lemmabasicdivauto +lemmabinaryidisunique +lemmabishkqw +lemmaboundedsetsize +lemmabreakdown +lemmabreakdownauto +lemmacardinality +lemmacardinalityofemptysetis +lemmacardinalityofset +lemmacardinalityofsetnoduplicates +lemmaconcatisassociative +lemmaconcatwellformedcodeunitsubsequences +lemmad +lemmadbealgorithmsuiteidimpliesequality +lemmadeserializeserialize +lemmadisjointunionsize +lemmadivadddenominator +lemmadivauto +lemmadivbasics +lemmadivbasicsauto +lemmadivbymultiple +lemmadivbymultipleauto +lemmadivbymultipleisstronglyordered +lemmadivbymultipleisstronglyorderedauto +lemmadivbyself +lemmadivdecreases +lemmadivdecreasesauto +lemmadivdenominator +lemmadivdenominatorauto +lemmadividingsums +lemmadividingsumsauto +lemmadivinductionauto +lemmadivinductionautoforall +lemmadivisdivrecursive +lemmadivisdivrecursiveauto +lemmadivisordered +lemmadivisorderedauto +lemmadivisorderedbydenominator +lemmadivisorderedbydenominatorauto +lemmadivisstrictlyorderedbydenominator +lemmadivisstrictlyorderedbydenominatorauto +lemmadivminusone +lemmadivminusoneauto +lemmadivmultiplesvanish +lemmadivmultiplesvanishauto +lemmadivmultiplesvanishfancy +lemmadivmultiplesvanishfancyauto +lemmadivmultiplesvanishquotient +lemmadivmultiplesvanishquotientauto +lemmadivnonincreasing +lemmadivnonincreasingauto +lemmadivnonzero +lemmadivnonzeroauto +lemmadivof +lemmadivplusone +lemmadivplusoneauto +lemmadivposispos +lemmadivposisposauto +lemmadivsubdenominator +lemmaelementfromslice +lemmaempty +lemmaesdkalgorithmsuiteidimpliesequality +lemmaf +lemmafilterdistributesoverconcat +lemmafiltersize +lemmafinduniquemaximal +lemmafinduniqueminimal +lemmaflattenandflattenreverseareequivalent +lemmaflattenconcat +lemmaflattenlengthgesingleelementlength +lemmaflattenlengthlemul +lemmaflattenmembership +lemmaflattenminimalwellformedcodeunitsubsequences +lemmaflattenreverseconcat +lemmafoaglpa +lemmafoldleftdistributesoverconcat +lemmafoldrightdistributesoverconcat +lemmafromnatlen +lemmafundamentaldivmod +lemmafundamentaldivmodauto +lemmagreatestimpliesmaximal +lemmagreatestisunique +lemmahoistoverdenominator +lemmahoistoverdenominatorauto +lemmahqymrtx +lemmaicjhaoq +lemmailtxrqd +lemmaindistinguishablequotients +lemmaindistinguishablequotientsauto +lemmainductionhelper +lemmainlemma +lemmainlemmabasic +lemmainlemmaorigin +lemmainters +lemmainvertisinjective +lemmainvfoldleft +lemmainvfoldright +lemmaissingleton +lemmak +lemmal +lemmalargesmalllarge +lemmalast +lemmaleastimpliesminimal +lemmaleastisunique +lemmalipytui +lemmaloopseparation +lemmamapdistributesoverconcat +lemmamapsize +lemmamaximalequivalentgreatest +lemmamaximalisunique +lemmamaxofconcat +lemmaminimalequivalentleast +lemmaminimalisunique +lemmaminimalwellformedcodeunitsubsequenceiswellformedsequence +lemmaminofconcat +lemmamodadddenominator +lemmamodaddmultiplesvanish +lemmamodaddmultiplesvanishauto +lemmamodadds +lemmamodaddsauto +lemmamodauto +lemmamodbasics +lemmamodbasicsauto +lemmamodbelowdenominator +lemmamodbreakdown +lemmamodbreakdownauto +lemmamoddecreases +lemmamoddecreasesauto +lemmamodequivalence +lemmamodequivalenceauto +lemmamodinductionauto +lemmamodinductionautoforall +lemmamodinductionforall +lemmamodismodrecursive +lemmamodismodrecursiveauto +lemmamodiszero +lemmamodiszeroauto +lemmamodmod +lemmamodmodauto +lemmamodmulequivalent +lemmamodmulequivalentauto +lemmamodmultiplesbasic +lemmamodmultiplesbasicauto +lemmamodmultiplesvanish +lemmamodmultiplesvanishauto +lemmamodofzeroiszero +lemmamodordering +lemmamodorderingauto +lemmamodposbound +lemmamodposboundauto +lemmamodpropertiesauto +lemmamodrange +lemmamodsubdenominator +lemmamodsubmultiplesvanish +lemmamodsubmultiplesvanishauto +lemmamodsubtraction +lemmamodsubtractionauto +lemmamoreparams +lemmamulauto +lemmamulbasics +lemmamulbasicsauto +lemmamulbyzeroiszeroauto +lemmamulcancelsnegatives +lemmamulcancelsnegativesauto +lemmamulcommutes +lemmamuldistributes +lemmamulequality +lemmamulequalityauto +lemmamulequalityconverse +lemmamulequalityconverseauto +lemmamulhoistinequality +lemmamulhoistinequalityauto +lemmamulincreases +lemmamulincreasesauto +lemmamulinduction +lemmamulinductionauto +lemmamulinductionautoforall +lemmamulinequality +lemmamulinequalityauto +lemmamulinequalityconverse +lemmamulinequalityconverseauto +lemmamulisassociative +lemmamulisassociativeauto +lemmamuliscommutative +lemmamuliscommutativeauto +lemmamulisdistributive +lemmamulisdistributiveadd +lemmamulisdistributiveaddauto +lemmamulisdistributiveaddotherway +lemmamulisdistributiveaddotherwayauto +lemmamulisdistributiveauto +lemmamulisdistributivesub +lemmamulisdistributivesubauto +lemmamulismulpos +lemmamulismulrecursive +lemmamulismulrecursiveauto +lemmamulleftinequality +lemmamulleftinequalityauto +lemmamulmodnoop +lemmamulmodnoopauto +lemmamulmodnoopgeneral +lemmamulmodnoopgeneralauto +lemmamulmodnoopleft +lemmamulmodnoopleftauto +lemmamulmodnoopright +lemmamulmodnooprightauto +lemmamulnonnegative +lemmamulnonnegativeauto +lemmamulnonzero +lemmamulnonzeroauto +lemmamulordering +lemmamulorderingauto +lemmamulproperties +lemmamulstrictinequality +lemmamulstrictinequalityauto +lemmamulstrictinequalityconverse +lemmamulstrictinequalityconverseauto +lemmamulstrictlyincreases +lemmamulstrictlyincreasesauto +lemmamulstrictlypositive +lemmamulstrictlypositiveauto +lemmamulstrictupperbound +lemmamulstrictupperboundauto +lemmamulsuccessor +lemmamultiplydividele +lemmamultiplydivideleauto +lemmamultiplydividelt +lemmamultiplydivideltauto +lemmamultiset +lemmamultisethasnoduplicates +lemmamultisetsubmembership +lemmamulunarynegation +lemmamulunarynegationauto +lemmamulupperbound +lemmamulupperboundauto +lemmamutablemapcontainspreservesinjectivity +lemmaname lemmanames +lemmanatseqnat +lemmanewfirstelementstillsortedby +lemmanoduplicatescardinalityofset +lemmaone +lemmaonewithdecreases +lemmaonly +lemmaoutsideofscaffolding +lemmaparameters +lemmapartbound +lemmapartitionminimalwellformedcodeunitsubsequence +lemmapostcondition +lemmapow +lemmapowadds +lemmapowaddsauto +lemmapowauto +lemmapowdistributes +lemmapowdistributesauto +lemmapowdivisioninequality +lemmapowdivisioninequalityauto +lemmapowincreases +lemmapowincreasesauto +lemmapowincreasesconverse +lemmapowincreasesconverseauto +lemmapowmod +lemmapowmodauto +lemmapowmodnoop +lemmapowmodnoopauto +lemmapowmultiplies +lemmapowmultipliesauto +lemmapowpositive +lemmapowpositiveauto +lemmapowstrictlyincreases +lemmapowstrictlyincreasesauto +lemmapowstrictlyincreasesconverse +lemmapowstrictlyincreasesconverseauto +lemmapowsubaddcancel +lemmapowsubaddcancelauto +lemmapowsubtracts +lemmapowsubtractsauto +lemmaprependminimalwellformedcodeunitsubsequence +lemmapulloutpows +lemmapulloutpowsauto +lemmaqf +lemmaquotientface +lemmaqztpgjv +lemmar +lemmarealdivgt +lemmaregularorfinalframehasuint +lemmaremainder +lemmaremainderauto +lemmaremainderlower +lemmaremainderlowerauto +lemmaremainderupper +lemmaremainderupperauto +lemmarounddown +lemmarounddownauto lemmas +lemmaseq +lemmaseqappendzero +lemmaseqeq +lemmaseqlen +lemmaseqlswmodequivalence +lemmaseqmswinequality +lemmaseqnatbound +lemmaseqnatseq +lemmaseqneq +lemmaseqprefixneq +lemmaseqzero +lemmaserializecorrectvalue +lemmaserializedeserialize +lemmaset +lemmasgcosxk +lemmasingletonequality +lemmasingletonsize +lemmasliceofslice +lemmasmalldiv +lemmasmalldivconverseauto +lemmasmalllargesmall +lemmasmallmod +lemmasplitat +lemmasplitatinclusive +lemmasquareispow +lemmastkbeph +lemmasubmodnoop +lemmasubmodnoopauto +lemmasubmodnoopright +lemmasubmodnooprightauto +lemmasubseqmax +lemmasubseqmin +lemmasubset +lemmasubsetequality +lemmasubsetsize +lemmasupporteddbealgorithmsuitesiscomplete +lemmasupportedesdkalgorithmsuitesiscomplete lemmata +lemmatgjisok +lemmatolarge +lemmatolargeisinjective +lemmatonatlefteqtonatrightauto +lemmatosmall +lemmatosmallisinjective +lemmatrixapplicationislinear +lemmatruncatemiddle +lemmatruncatemiddleauto +lemmatta lemmatype +lemmau +lemmaunionsize +lemmauniqueminimum +lemmauniqueprefixminimalwellformedcodeunitseq +lemmav +lemmawithouttriggeronforallstatement +lemmawithscaffolding +lemmax +lemmazhqczlx +lemmazipofunzip lemmdotcommute lemme +lemmes +lemmktrans +lemmma +lemmmamama +lemmnorm lemmovebymove +lemms +lemmultnonnegle +lemmultposle +lemmultposlt lemn +lemnaa +lemnab +lemnana +lemnanb +lemnoa +lemnob +lemnoftlgr +lemnona +lemnonb +lemnonneglt lemnonparallelvectorsexist +lemnorm +lemnormalisetimelike +lemnormnonnegative +lemnormofscaled +lemnormsqrisnorm +lemnormsymmetry +lemnotequalimpliessep +lemnotoriginimpliespositivenorm +lemnotoriginimpliesposnorm +lemnullimpliesorigin lemnullline +lemo +lemoa +lemob lemold +lemona +lemonb lemonlineunderaffine lemonregularconeiff lemorthogalspacevectorexists +lemorthogmtotimelike lemorthosym lemoutsidenotoncone lemoutsideregularconeimplies +lemp lemparalleljoin lemparallelnotmeet lemparallelreflexive lemparallelsym lemparalleltrans +lempathand lemplanecontainsbasepoint +lempointdecomposition +lempointlimit +lempresentation +lemproposition +lemps lempt lempty +lemqcase lemquadcoordinates +lemquadraticcasescomplete +lemquadraticgezero +lemquadraticrootcount +lemquadrootcondition +lemreducedbound lemregularcone +lemreversecauchyschwarz lemrp lems +lemsameline lemscale +lemscaleassoc +lemscaleball +lemscaleballandboundary +lemscalecommute +lemscaledistribdiff +lemscaledistribsum lemscaleinverse +lemscaleleftdiffdistrib +lemscaleleftsumdistrib lemscalelinear lemscaleneg lemscaleorigin lemscaleoveradd lemscalescale +lemscalesep +lemselftangentistimeaxis +lemsep lemslopeinfiniteimpliesoutside lemslopelinejoining lemsmallcardunderinvertible +lemsmallpoints +lemsmallsquares lemsnorm lemsomefunc lemspace +lemspatialnullimpliesspatialorigin +lemsqrdiffsymmetrical +lemsqrlt +lemsqrmono +lemsqrmonostrict +lemsqrmult +lemsqrordered +lemsqrorderedstrict +lemsqrsum lemsqrt +lemsqrtofsquare +lemsquarednegative +lemsquareexistsabove +lemsquareofsqrt +lemsquarespositive +lemsscaleassoc +lemssep lemsuccf +lemsumdiffcancelmiddle +lemsumofnonnegandpos +lemsumoftwohalves lemt +lemtangentlinea +lemtangentlinee +lemtangentlines +lemtangentlinetranslation +lemtangentlineunique lemthirdelementofset lemtime +lemtimeaxisisline lemtimelikeinsidecone +lemtimelikenotzerotime +lemtofuncasfunc lemtranslationimpliesaffine lemtranslationpartisunique +lemuc lemul lemuldiv lemuldivd @@ -44682,7 +73240,14 @@ lemvelocityjoiningusingpoints lemvelocitylinejoining lemvertexoncone lemwherelinemeetscone +lemwvtcts +lemwvtimpliesfunction +lemwvtinjective +lemwvtinverse +lemwvtinversects lemzeg +lemzeronorm +lemzeroroot len lenb lenbuf @@ -44690,6 +73255,10 @@ lenbv lenc lencl lenco +lenconsev +lend +lendian +lendist leneg lenegcon lenegd @@ -44699,38 +73268,94 @@ lenegsd lenegsq lenelioc leneltd +leneq lenext +lenf +leng +lenght +lengt length +lengtha lengthappend lengthatleastone +lengthb +lengthbits +lengthblock lengthbv +lengthbyte +lengthbytevec lengthd lengthe +lengthen lengthf lengthft +lengthgtonetwodistinctelements lengthi lengthia +lengthk +lengthn +lengthnilok +lengthofcommonprefix +lengthofcptolist lengthone +lengthonecharacterisation +lengthoneimpliesonlyelement +lengthout +lengthp lengthparity +lengthpatheven +<<<<<<< Updated upstream +lengthreplicate +======= +>>>>>>> Stashed changes lengths +lengthsp +lengthsplit +lengthterms +lengthv +lengthviolation lengthy leni +lenit +lenkeyw +lenkinbyt lenlex +lenlist lenlt lenltd lenlteq +lenltfin lenlti lenlts lenm +lenmoves lenn lennncl leno +lenoteq lenp lenpfxcctswrd +lenprefix +lenps +lenr +lenreg lenrevpfxcctswrd +lenrw lens +lenset lensymd +lentails +lenths +lenv +lenw +lenwaa +lenwinbyt +lenwn +leny +lenye +lenz leo +leoa leof leofhom leofstructure @@ -44747,42 +73372,95 @@ leoprf leopsq leoptr leoptri +leor leord leordtval leordtvallem lep +lepi lepnf lepoll +lepolld +lepolli leprd +lepreds +leps +lepsza lepw leq leqb +leqconst leqd +leqf leqi +leqif +leqifp +leqlat +leqleft +leqm +leqn +leqngt +leqnn +leqnsn +leqp +leqr leqs +leqspred +leqt +leqtheorem lequiv lequivcongrleft +lequivequivalence lequivproddirectsum lequivprodofleftsplitexact lequivprodofrightsplitexact -leqv leqw ler lera lerabdioph +leran lerat +lerb +lerbldl +lerbldr +lerbrdl +lerbrdr +lerd +lerdl +lerdr lere lerec lerecd lereci lerecon +lerefl lerel lerelxr +lerhs +lerif +lerifp +lerl lermxnn lermy lern +lerngt +lernl +lernw +leror +lerp +lerq +lerr lersif +lersiff lersifn +lersifnf +lersifr +lersifs +lersift +lersifw +lersifxx +lerw +lerz les lesi lesid @@ -44796,22 +73474,58 @@ lesnltd lesrec lesrecd less +lessa +lessalive +lessalivei +lessalloc +lessaloc lessapprox +lessconstsmall lessd +lessdef lesse lesseq +lesseqa +lessequal +<<<<<<< Updated upstream +======= +lessequals +>>>>>>> Stashed changes lesser +lessers lessexpbound -lessf lessi +<<<<<<< Updated upstream +======= lessis +>>>>>>> Stashed changes +lessistrichotomoustransitive lessleaves lessmpt +lessmult +lessn +lesson +lessons lessp lesspoll lesss lesssim +lesssmallconst +lesssucsuc +lesst lessthan +lessthanadditive +lessthanbetween +lessthancongruence +lessthanfour +lessthannotequal +lessthanoreq +lessthanorequal +lessthanorequalto +lessthantransitive +lessx +lest +lesthan lestr lestrd lestri @@ -44823,27 +73537,61 @@ lesubaddi lesubaddsd lesubd lesubmodule +lesubs lesubsd +lesubstep lesubsubs lesubsubsbd +lesuc lesupleft lesupr lesupright +lesvars lesymb let +letabs +letbinding +letbindings letbody +letc letcase +letdec +letdecs letdepth lete +letenv +leterror +letexn +letexpr +letexpressions +letexps +letf +letfrompat leti letidbinder +letified +letincalc +letinit +letinitk +letinline +letlemma +letlet letop letopon letopuni +letorfailexpressions letp +letpattern +letpreinit letr +letrans letrd letrec +letrecbinding +letrecbindings +letrecs +letrecstar +letreturn letri letric letrid @@ -44851,64 +73599,157 @@ letrii letrp lets letsr +letssimplify +letstar +letstmt +letsuchthat +letsuchthatexpression +lett lettelescope letter letters +lettersof +lettest letting lettre letvalue +letvar +letvardecls +letvars +leu leub +leuidl +leuidr +leul +leur +leux lev leval +leve level +levela +levelab +levelb +levelisfin +levellist levellista +levelmap levelmvartoparam leveln levelnames levelofterm leveloftype levelone +levelp levelpa levelparams levelparamstomessagedata levels levelset +levelsets levelzero leverage +levge levi +levrd levy levyprokhor levyprokhorov levyprokhorovdist levyprokhorovedist +lew leweon +lewfbnd lex lexaccessible lexarg +lexbfs +lexc +lexeme lexeq lexer +lexerprog +lexerresult +lexerrort lexext +lexfg +lexi +lexical +lexico +lexicographi lexicographic lexicographical lexicographically +lexicographicbyteseqbelow +lexicographicbyteseqbelowaux +lexicographiclessorequal +lexicographiclessorequalaux +lexicographictuples +lexicon +lexicorder +lexil +lexing +lexir +lexisantisymmetric +lexisreflexive +lexistotal +lexistransitive +lexists +lexistsl +lexistsr +lexless +lexlessappend +lexlessbackjump +lexlessbacktrack +lexlessrestricted +lexlessstate lexlogpow lexmax lexmin +lexn lexord lexorder +lexordp lexp +lexpand lexpands +lexpinc lexprod +lexprodx +lexpshftint +lexs +lexstate +lextendslp +lextensionsimpl +lextensionsimpldot +lexto +lextoto +lextra +lexu +lexul +lexur +lexx +ley +leye lez lezero lezerofnum +lezle +lezn lfa lface +lfalse lfb +lfc +lfd +lfelem +lfeval +lfgredg lfgredgge lfgriswlk lfgrn lfgrnloop +lfgrnloopen lfgrwlknloop lfgrwlkprop lfi @@ -44920,13 +73761,18 @@ lfiltermap lfind lfingen lfinite +lfinited +lfinitei lfinpfin lfinun +lfix +lfjcixp lfl lfladd lfladdass lfladdcl lfladdcom +lflatten lflcl lflf lfli @@ -44942,17 +73788,48 @@ lflvsass lflvscl lflvsdi lfnl +lfns +lfoo +lforall +lforallr lformula +lforwardl lfp lfpapprox +lfpf +lfpt +lfptree +lfrac lframe +lfrep +lfresh lfs +lfset lft lfu lfuhgr +lfun +lfuna lfunction lfunctionresidueclassaux lfunctiontrivchar +lfundl +lfundr +lfune +lfuneqp +lfunk +lfunnl +lfunnr +lfunp +lfunpn +lfuntype +lfunvk +lfunzl +lfunzr +lfuzzy +lfv +lfvs +lfx lga lgam lgambdd @@ -44962,12 +73839,26 @@ lgamcvglem lgamf lgamgulm lgamgulmlem +lgamma lgamp lgamucov lgb lgc +lge +lgen +lgenerate lgenerator +lgenk +lgenlist +lgentzeneqnatded +lgentzentoarrow +lgeom +lget +lgetstack +lgk +lgood lgr +lgrd lgricngricex lgrid lgridi @@ -44990,6 +73881,7 @@ lgseisenlem lgsfcl lgsfle lgsfval +lgsfvalg lgsle lgslem lgsmod @@ -45006,24 +73898,36 @@ lgsqrmod lgsqrmodndvds lgsquad lgsquadlem +lgsquadlemofi +lgsquadlemsfi lgssq lgsval lgsvalmod lgt lgteduh lgth +lgv +lhat +lhato +lhatom +lhbit +lhcut lhd lhdd +lhdtl lhe +lhi lhj lhlli lhllsi +lhmap lholed lhom lhomwithconstants lhomwithconstantsmap lhop lhopital +lhospital lhp lhpat lhpbase @@ -45047,38 +73951,69 @@ lhpocat lhpocnel lhpocnle lhprelat +lhprob +lhprobe lhpset lhr +lhrange lhri lhs lhsap +lhsarr +lhsarrp +lhses lhset lhsfin lhsfun lhshead +lhsid +lhslist +lhslst +lhsm +lhsp +lhspairs lhspf lhsraw +lhsrewrite lhss lhssd lhsstr +lhssvex lhsv lhsval +lhu +lhv lia liar +liars +liat lib +libc +liberal +liberale +liberalparadox liberate liberating liberation +libniz libraries library libraryrewrite libraryrewritecomponent +libre libres +<<<<<<< Updated upstream +======= lice +>>>>>>> Stashed changes +licen +licence license lics lid lideal +lidequiv +lidiso lidisometry lidl lidlabl @@ -45088,23 +74023,28 @@ lidlbas lidldomn lidldomnnring lidldvgen +lidlex lidlincl lidlmcl lidlmcld +lidlmex lidlnegcl lidlnsg lidlnz lidlrng lidlrsppropd +lidlrsppropdg lidlss lidlssbas lidlsubcl lidlsubg lidlunitel lidlval +lidlvalg lidofcompatiblesmul lidrideqd lidrididd +lids lidx lie liealgebr @@ -45155,8 +74095,15 @@ liesubmodul liesubmodule liesubmoduleinvariant liesubmodulemapandcomap +lieu lif +life lifecycle +lifespan +lifetime +lifetimeoutlives +liff +lifix liflcq lifo lifoumx @@ -45169,6 +74116,7 @@ liftaddgrouphom liftaddhom liftadiccompletionaux liftalgebra +liftalgebras liftalgequiv liftalghom liftalternating @@ -45178,9 +74126,18 @@ liftaux liftb liftbasechange liftbasechangeequiv +liftbin +liftbool liftboundedorder +liftbrtobr +liftbrtocr +liftbupdseplog +liftc +liftclassicalsep liftclm +liftclosefrom liftcm +liftcoalgebras liftcoborder liftcochain liftcocone @@ -45192,13 +74149,19 @@ liftcomphomotopy liftcompletelattice liftcone liftconemorphism +liftconstant +liftconstanttobr liftcontinuousaddmonoidhom liftcontinuouscommmonoidhom liftcontinuousmonoidhom +liftcorableindir +liftcorableseplog liftcorem liftcover +liftcursorerror liftcycl liftcycles +liftdecprop liftdeg lifte lifted @@ -45211,14 +74174,22 @@ liftedconeelement liftedconeislimit liftedlimitislimit liftedlimitmapstooriginal +liftedsetoid +liftembedding +liftenv +liftenviron liftequiv liftequivofcomm +lifter +lifters liftet liftexcept liftexpand liftexpr +liftext liftextend liftextendfarrowiso +liftf liftfm liftfone liftfromover @@ -45232,7 +74203,9 @@ liftfunctor liftfunctorcompiso liftfzero liftgen +liftgenmonotonic liftgenn +liftgenunsized lifth lifthom lifthomology @@ -45247,15 +74220,20 @@ liftico liftid liftidhomotopy liftinclusion +liftindir lifting liftinglocalizedfunctor liftingproperties liftings liftinitdata +liftinitial liftinitialseg +liftinjective +liftintuitionisticsep liftioc liftiso liftisometry +liftjoin liftk liftkaehlerdifferential liftl @@ -45263,6 +74241,8 @@ liftlatticehom liftleftadjoint liftlefthomology liftlie +liftlift +liftliftfuse liftlimit liftlinear liftlm @@ -45280,6 +74260,7 @@ liftmonoidhom liftmonoidwithzer liftmonoidwithzerohom liftn +liftnatded liftnatiso liftnattrans liftnc @@ -45308,6 +74289,7 @@ liftorderhom liftordertop liftp liftpath +liftpj liftpoly liftppreservation liftprecomp @@ -45318,11 +74300,13 @@ liftpropat liftpropon liftpropwi liftpropwithinat +liftpushoutiso liftq liftqspansingleton liftquotient liftr liftreadert +liftreco liftrel liftrelaux liftrelo @@ -45330,10 +74314,17 @@ liftrelrec liftright liftrightadjoint liftringhom +liftrp liftrreadert +liftrs liftrstatet liftrsum +liftrt lifts +liftsepindir +liftseplog +liftsequence +liftsetoids liftsingleton liftsourc liftsourcetargetpropertyat @@ -45348,11 +74339,14 @@ liftstruct liftstructequiv liftstructofhasstrongepimonofactorisation liftsubobject +liftsubst liftsum liftsupquotquotmk liftt +lifttc lifttell lifttermelabm +liftterminal liftti lifttodiagramlimitobjaux lifttodiscrete @@ -45365,22 +74359,31 @@ lifttofinsetlimitcone lifttofinsetobj lifttoinitial lifttoinitialunique +lifttomap lifttomultiset lifttopathcategory lifttoplusobjlimitobj lifttoterminal lifttoterminalunique +lifttp +lifttrue lifttruncle lifttrunclt liftts lifttti +lifttwo liftunique +liftvar liftwritert +liftx +liftzero liftzeroatinfty lig lighneal lighneallem light +lightbulb +lightbulbtrace lightcondensed lightcondmod lightcondset @@ -45389,6 +74392,7 @@ lightcondsettotopcat lightdiagram lightdiagramtolightprofinite lightdiagramtoprofinite +lighter lightprofinite lightprofiniteaslimit lightprofinitet @@ -45400,8 +74404,10 @@ lightprofinitetolightdiagram lighttoprofinite lighttoprofinitefullyfaithful lightweight +ligt lih lij +lik like liked likelihood @@ -45410,20 +74416,31 @@ likes likesbetree likesjournal likesjournalrefinement +liketogether +likewise +lil lim limaux +limb +limbo +limbs limcc limccl limccnp +limccnpcntop limcco +limccoap limccog limcdif +limcdifap limcdm limcflf limcflflem limcfval limciccioolb limcicciooub +limcimo +limcimolemlt limciun limcleqr limclner @@ -45431,9 +74448,11 @@ limclr limcmo limcmpt limcmptdm +limcmpted limcnlp limcompflipisowhiskerlim limcompinclusion +limconef limcons limcperiod limcrcl @@ -45445,17 +74464,25 @@ limcresiooub limcun limcvallem limd +limdomrel +lime limelon limenpsi limensuc limensuci limeq +limes limexissup limexissupab +limf +limfunc limfunctor limg +limgf +limgs limi limin +liminally liminf liminfcl liminfcld @@ -45505,6 +74532,7 @@ limitauxiliarycone limitbicone limitbiconeofunique limitborelimplieslimsupclosedle +limitbuild limitclm limitcompcoyonedaisocone limitcompwhiskeringleftisocomplimit @@ -45541,15 +74569,22 @@ limitisolimitcurrycomplim limitisoofisrightkanextension limitisopi limitisoswapcomplim +limitisunique +limitisuniversalproperty limitleftopisounopcolimit +limitlimit limitmodule +limitms limitobjisolimitcompevaluation limitofdiagraminitial limitofdiagramterminal +limitofequalsisequal limitofshape limitofsurjectionssurject limitofsurjectionssurjective limitopisoopcolimit +limitp +limitpart limitpresentation limitpresheafofmodules limitprocess @@ -45561,32 +74596,52 @@ limitsclo limitsclosure limitsemiring limitsequence +limitsetoid limitsheafcondition limitsofderivatives limitsofshape +limitsp limitssson limitsubobjectproduct limittoalgequiv +limittype limituncurryisolimitcomplim limitunopisounopcolimit limiun limlem +limlift +limm limmap +limn limnatisosectionsfunctor limnsuc limnthhom limom limomss limon +limopt limord limp +limpl +limpladj +limplexistse +limplforaller +limpll +limpllandc +limpltrue +limplvalid +limpoints limpr limpt limpts +limr limratio limratiomeas +lims limseq +limshift limsinf +limsplit limsssuc limssup limsuc @@ -45642,14 +74697,19 @@ limsupval limsupvald limsupvaluz limsupvaluzmpt +limted limunder limuni +limuniq limwun +limx limy limyoneda limzero lin lina +linaer +linapprox linar linarith linarithargsrest @@ -45666,10 +74726,14 @@ lincdifsn lincellss lincext lincfsuppcl +lincl lincmb linco +lincoh lincolss lincomb +lincombmod +lincombmodzlincombmod lincop lincreslvec lincresunit @@ -45685,11 +74749,18 @@ lincvalsc lincvalsn lincvalsng lind +lindeberg lindel lindelof lindelofspace +lindenbaum +lindenbaumchain +lindenbaumconstruction +lindep +lindependent lindeps lindepsnlininds +lindex lindf lindff lindfind @@ -45698,6 +74769,8 @@ lindfmm lindfpropd lindfres lindfrn +lindih +lindihpi lindley linds lindsadd @@ -45718,6 +74791,7 @@ lindsunlem lindszr line linea +lineab linear linearadjoints linearalgebra @@ -45728,6 +74802,7 @@ linearcombi linearcombination linearcombinationequiv linearcombinationon +linearcombinations linearcoyoneda lineard lineardependent @@ -45759,6 +74834,7 @@ linearfold linearformofatom linearformofexpr linearformsandmaxvar +linearfunc lineargrowthinf lineargrowthinftophom lineargrowthsup @@ -45769,6 +74845,7 @@ linearhomequivcomm lineari linearinde linearindep +linearindepbasis linearindepen linearindepend linearindependen @@ -45777,6 +74854,7 @@ linearindependentaux linearindependentempty linearindependentsingleton linearindepon +lineario linearisometry linearisometryboundedofcompact linearisometryeq @@ -45787,6 +74865,7 @@ linearity linearityd linearizable linearization +linearizationd linearizationofmulactioniso linearizationtrivialiso linearize @@ -45797,10 +74876,13 @@ linearizeofmulactioniso linearizetrivial linearizetrivialiso linearl +linearlength +linearlengthisdistributive linearlmod linearlocallyfinite linearlocallyfiniteorder linearly +linearlyindependentsubsets linearm linearma linearmap @@ -45824,6 +74906,8 @@ linearmn linearmnn linearn linearo +linearoperator +linearoperators linearord linearorder linearorderedaddcommgroup @@ -45864,10 +74948,13 @@ linearpz linearr linearrecurrence linears +linearsearch linearstrictorderedring linearsucc linearswap lineartopology +lineartopspace +lineartopspacenorm linearweights linearyoneda linearyonedaobj @@ -45878,6 +74965,7 @@ lineb linec linecgr linecgrand +linecol linecom linecount linedegen @@ -45892,10 +74980,16 @@ linediffe linedifferent linedifferentiableat linedifferentiablewithinat +linee lineelsb lineex lineext +linefd +<<<<<<< Updated upstream +======= lineformation +>>>>>>> Stashed changes +lineforwardfd lineg linegraph linei @@ -45905,6 +74999,8 @@ linejoining linem linemap linenumber +linenumbertable +linep linepath linepaths linepmap @@ -45914,27 +75010,38 @@ linepsubn lineq lineqi liner +linereflectionisometry linerflx lines linesby linesd linesee lineset +linesfd linesi +linesintersectionpoint linesl lineslopefinite +linesp +linespace +linesparallelity liness linest +linesum +linesuperimposedab +linesv linetest linethru linethrueu lineunray lineval linevalexample +linevec linevelocity linexp linf linfinite +linfix linflinf linfn linfty @@ -45949,8 +75056,10 @@ linftyopnormedspace linftyopnormsmulclass linftyopseminormedaddcommgroup linftyopseminormedring +linfun +linfunp +ling linhom -linie lininds linindscl linindsi @@ -45958,6 +75067,7 @@ linindslinci linindsv link linkable +linkage linked linkedbetree linkedbetreevars @@ -45967,9 +75077,18 @@ linkedjournalrefinement linkedlist linkedlistinsert linkedseq +linker linking linkmark +linkorder +linkp +linkrel links +linksg +linksp +linktable +linktf +linl linls linmullin linop @@ -45977,11 +75096,17 @@ linord linorder linordered linorders +linpats linply +linpreorders lins linsd +linseg +linsert +linstr linsts lint +lintconfig linte linted linteg @@ -45996,16 +75121,27 @@ linteroptions lintfile linting lintmodules +lintrace +lintresult lints +linum linux linv +linverse linvh +linvi +<<<<<<< Updated upstream +======= lion +>>>>>>> Stashed changes +lior liouville liouvillenumber liouvillewith +lioville lip liplem +lips lipsc lipsch lipschhitz @@ -46015,30 +75151,62 @@ lipschitzadd lipschitzextensionconstant lipschitzgroup lipschitzi +lipschitzian lipschitzmul lipschitzon lipschitzonwit lipschitzonwith lipschitzw lipschitzwith +lipton liquid lir lis lischitz +lise +liset +lisfun liso lisp +lispworks +liss list lista +listaassign +listaconseq +listaif +listaliasesensurespublicly listany +listappend +listappneq +listaskip +listb +listbackupsensurespublicly +listbin listblank listboolmerge listbox listboxrep +listbyte +listcase listchoice +listcmp +listcmpeq listcons +listconstr +listcontributorinsightsensurespublicly +listcontributorinsightslimit listd +listdas +listdata listdecode +listdiff +listdiffdoubleremoveall +listdiffiff +listdiffmap +listdiffremoveallnonmember listdirectory +liste listed listen listencode @@ -46047,73 +75215,249 @@ listeners listening listensocks listeq +listequalsbutlastappendlast +listequiv listequivdlist listequivofequiv listequivselfofequivnat +listeralsp +listes +listexportsensurespublicly +listexportsmaxlimit listfilter listfiltermap +listfix +<<<<<<< Updated upstream +listflatten +======= +>>>>>>> Stashed changes +listge +listglobaltablesensurespublicly +listgrantsensurespublicly listhybrid listi +listify +listimp +listimportsensurespublicly +listimportsmaxlimit +<<<<<<< Updated upstream +======= listin +>>>>>>> Stashed changes +listind listindices +listing +listinsteq +listinstgreatereq +listinstr +listintr +listiso +listk +listkeypoliciesensurespublicly +listkeyrotationsensurespublicly +listkeysensurespublicly +listl +listlemma +listlen +listlength +listless listlib +listlist +listlive +listlookup +listlr +listm listmap +listmapid +listmax +listmaxz listmem listn listnatequivnat listnil +listnmt +listnodes +listnth listof +listofmonotonic +listofn +listoo listop +listopcodes +listoption +listord +listorder +listoto listp +listpairs +listpars +listpath +listpm +listpos +listposts +listpr +listproc listprod +listprog +listps +listq +listr listrange +listrangeinc +listrangelhi +listrecd +listreds +listredsval listrel listrep listrepeat listreplace +listresourcetagsensurespublicly +<<<<<<< Updated upstream +======= +listreverse +>>>>>>> Stashed changes +listrl lists +listsegment listset +listseta listsetd +listsetequiv +listsetfix +listsetfixes listseti +listsetp +listsexp listshape +listsize listsl +listslr +<<<<<<< Updated upstream +======= listsp +>>>>>>> Stashed changes listspec +listsr +listsubset listsum +listsupp +listsym listt +listtablesensurespublicly +listtablesinputlimit +listtagsofresourceensurespublicly listtake +listtocp +listtocptl +listtoevenkeys listtofun listtofuns +listtooddkeys listtopath listtransveccol listtransvecrow listtype +listtypegen listuniqueequiv +listupdate +listupdatee +listv listval +listvar +listvars +listw +listweaki +listx +listxformer +listy lit +litarr +litarrofpaths +litarrofstrings +litbool +litci +litclas +litclass +litclasses +lite +liteq +litera literal +literalalp literald literally +literalp literals +literalsp +literaltest literaltopropf literature +litfix litmat +litnull +litnum +litp +litprim lits +litsexp +litsi +litsim +litstring +littl little +littlearray littleendian +littleendianlist +littleevallemma +littleo +littleoe +littleop littlewedderburn litv +litvars +liv live +lived +livefs +livein +livelist +livelock liveness +livenesse +livenessi +liveout lives +liveset +livesets +liveval +<<<<<<< Updated upstream +lize +lja +======= living +lize lja ljohn +>>>>>>> Stashed changes +ljoin +ljslist +lkat lke lkei lker +lkere +lkeys lkeysec +lkeysini +lkeyssup +<<<<<<< Updated upstream +======= lkg +>>>>>>> Stashed changes +lkgrqui +lkj +lknew lkr lkrcl lkreqn @@ -46133,23 +75477,39 @@ lkrssv lkrval lks lksize +lkspec +lkup lla +llabel llangle +llargregs llast +llb +llbit +llbound +llbrackt +llcases llcei llci llcomp +llcons lle lleftarrow llem +llen llength +lleq lless llex lli llift llim +llimit llines +llis llist +llisti +llists lll llli lllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllll @@ -46158,7 +75518,12 @@ llllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllll lllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllll lllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllll lllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllll +lllmi +<<<<<<< Updated upstream +======= lllsts +>>>>>>> Stashed changes +lln llnbase llncmp llncvrlpln @@ -46183,11 +75548,22 @@ llnnen llnnleat llnnlt llnset +lload +llongdiv +llongmul +llookup +llookups +lloyxrk llp +llpi +llpo llq llr llrg +llrr lls +llsb +llseq llsi llsli llt @@ -46195,6 +75571,7 @@ lltm lltr lltrv lltsi +llvwli llxs lly llycmpkgen @@ -46209,10 +75586,9 @@ llytop lma lmap lmapdomain +lmapiter lmarginal lmarginalpartialtraj -lmariapaola -lmary lmat lmatcl lmatfval @@ -46222,6 +75598,7 @@ lmax lmbd lmbr lmbrf +lmbv lmcau lmcl lmcld @@ -46230,17 +75607,26 @@ lmclimf lmcls lmcn lmcnp +lmcoghgrab lmconst lmcvg lmddu lmdfval +lmdih lmdpropd lmdran lmdrcl lmdvg lmdvglim +lmeasurable +lmeasure lmember +lmemloc +lmer +<<<<<<< Updated upstream +======= lmerge +>>>>>>> Stashed changes lmeri lmerk lmerl @@ -46310,29 +75696,40 @@ lmimlbs lmimlmhm lmimot lmimrwasbop +lmin lminus lmiopp lmireu -lmirro lmisfree lmiso lmk +lml lmle lmlim lmlimxrge +lmlmth +lmln +lmlt +lmm lmmbr lmmbrf lmmcvg +lmmmth lmmo +lmnat lmnn +lmo lmod lmodabl lmodacl lmodass lmodbase +lmodbased lmodbn +lmodcat lmodcmn lmodcom +lmodel lmodfgrp lmodfopne lmodfopnelem @@ -46342,17 +75739,23 @@ lmodindp lmodlcan lmodlema lmodmcl +lmodmorphism +lmodmorphismstr lmodn lmodnegadd +lmodobjects lmodplusg +lmodplusgd lmodprop lmodpropd lmodring lmodsca +lmodscad lmodscaf lmodslmd lmodsn lmodstr +lmodstrd lmodsubdi lmodsubdir lmodsubeq @@ -46369,6 +75772,7 @@ lmodvpncan lmodvs lmodvsass lmodvsca +lmodvscad lmodvscl lmodvscld lmodvsdi @@ -46382,24 +75786,41 @@ lmodvsneg lmodvsubadd lmodvsubcl lmodvsubval +lmoneone +lmov lmove +lmp +lmplus lmr lmrcl lmrel lmres lms +lmsa +lmsb +lmseg lmss +lmth +lmtopcnp lmul lmulequiv lmult +lmultcoset lmultower lmvr lmxrge +lmxth +lmycielskianseq lmyhdibnrqkgzbcllnaglazkxrxirawmhxrgdvcj +lmz +lna lnact +lname lnat lnatexn +lnatmost lncgr +lnchain lncmp lncnbd lncnopbd @@ -46407,12 +75828,21 @@ lncom lnconi lncvrat lncvrelatn +lndiv lne lneg +lnegate +lnek +lneny +lneps lneq +lneutral +lnev lnever +lnexn lnexp lnext +lnfix lnfn lnfnaddi lnfnaddmuli @@ -46426,6 +75856,7 @@ lnfnli lnfnmul lnfnmuli lnfnsubi +lng lngen lngid lngndx @@ -46434,18 +75865,26 @@ lngth lnhl lnid lnil +lnililist lnjatn +lnk +lnm lnmepi lnmfg lnmlmic lnmlmod lnmlssfg lnmlsslnm +lnmt +lnn lnnat +lnnrelation +lnny lno lnoadd lnocni lnocoi +lnode lnoem lnoer lnof @@ -46453,6 +75892,7 @@ lnolin lnomul lnon lnonneg +lnonnull lnop lnopaddi lnopaddmuli @@ -46484,10 +75924,16 @@ lnopsubmuli lnopunii lnopunilem lnorm +lnormd +lnormr +lnormrn +lnormz lnosub lnot +lnov lnoval lnperpex +lnpm lnr lnrfg lnrfgtr @@ -46495,50 +75941,118 @@ lnrfrlm lnrlnm lnrot lnrring +lnrx lns +lnsvex +lnt +lntfunction lnth +lnths lnull lnulld +lnum +lnv lnxfr +lnxn loa load +loadarr +loadbalancerserviceimpl +loadbignum +loadbufbers +loadbuffers +loadbyte loadbytes +loadcheck +loadclass +loadconfig +loadconstant +loaddm +loaddouble +loade +loaded +loadedalist +loadedp loadelim +loader +loadglob +loadhalf loadi +loadimm loadimportedmodule +loadind loading +loadliteral +loadmem +loadmembyte +loadorder +loadptr +loadr +loadregs +loadresult loads +loadst +loadstate +loadstore +loadstoreimmediate +loadsymbol +loadupperconstant loadv +loadword loan loans +lob +lobe +lobops +lobrule loc loca local localalghom +localap localattarget localcandidates +localclcatex +localcoh localcohomology localcohomologyequiv localcontext locald localdecl localdeclkind +localdef localdefinitiondependencies +localdefs +localdeps localdiffeomorphon locale localepointofspacepoint +localequiv +locales +localextension +localfixedpoint localframe +localfree +localfunext localfvars +localgenerators localgeneratorsdata localgeneratorsdataofisfinitetype localhomeomorph localhost +<<<<<<< Updated upstream +======= locali +>>>>>>> Stashed changes +localidx localimpglobalcons localinstances localinsts +localinv localinvariantprop localinverse +localise +localised locality localiz localizat @@ -46583,8 +76097,13 @@ localizedquotientequiv localizermorphism localizermorphisminv localizermorphismresolution +localizing locall +locallan +localleftkan locallistd +locallized +localloc locally locallyboundedmap locallyboundedmapclass @@ -46635,6 +76154,7 @@ locallylipschitz locallylipschitzon locallyoffinitepresentation locallyoffinitetype +locallyp locallyquasifinite locallyringedspace locallyringedspaceadjunction @@ -46644,37 +76164,76 @@ locallysmall locallysurjective locallyuniformly locallyuniformlyon +locallyx +locallyxc +locallyxp localmax localmin localnormalconvergence +localnum +localop +localp localpredicate localpreimage localpresentationat localr +localran +localrefl localrepresentability +localrightkan localring localringhom locals localsecrets localsecretscomposition +localsh +localsl +localsmap +localsok +localsp localss +localstate +localstuple localsubring +localt localthms +localtok localtree localtriv localtrivaspartialequiv localtrivat localuniformconvergence +localuserinv +localv +localvariablesandassignments +localvariabletable +localvars localx +locat locate located +<<<<<<< Updated upstream +======= locatedin +>>>>>>> Stashed changes +locatedness +locates +locati location locations +locationtest +locator +locators +locb +locblocks locblockssrc locblockstgt locbsrc +loccn locdecls +loce +loceq +locf locfin locfinbas locfincf @@ -46684,33 +76243,85 @@ locfinnei locfinref locfinreflem locfintop +loci locindex +locinjectivity +locinv lock +lockcoh locked +lockedcohom +lockedp +lockguts locking +lockinv +lockinvsandresources +locklt +lockpool lockres locks +locksandresources lockserv lockset +locksp +lockstep +lockt +locl +loclength +loclist loclly +locmap locn +locncol +locnle +locnrow +locnsexp +locnum +loco locoalization +locopt locpathconnectedspace +locprojl +locprojr locquiver locs +locset +locsize +locsle +locsopt locsound +locsrc +locss +locssexp +loct +loctgt +locu locus +locv +locvalue +locvisible loe loeb loewner lof +lofa +lofat +loff log +loga +logan logand +logandc +logands +logap logapp +logappr +logapps logarithm logarithmic logarithms logb +logbase logbchbase logbcl logbf @@ -46718,9 +76329,12 @@ logbfval logbgcd logbge logbgt +logbi logbid +logbinr logbit logbitp +logbits logbleb logblebd logblog @@ -46732,19 +76346,27 @@ logbrec logbrege logbval logbzge +logc logcar +logcars logccne logccv logcdr +logcdrs logcj logcl logcld logcn logcnlem +logco +logcollap +logcollapse logcons +logcount logcounting logcxp logcxpd +logd logde logderiv logdifbnd @@ -46763,6 +76385,7 @@ logdmnrp logdmopn logdmss loge +logead logef logeftb logemb @@ -46770,15 +76393,21 @@ logembedding logembeddingequiv logembeddingquot logempty +logend +logendp logeq logequiv logeqv logerror logerrorat +logex logexception logexp logexprlim logext +logexted +logexting +logexts logextu logf logfac @@ -46787,36 +76416,62 @@ logfaclbnd logfacrlim logfacubnd logfib +logfilename loggammaseq logge logged logger +loggi +loggie +loggim logging +loggix loggt +logh +loghe +loghea loghead +logheads logheight loghomeomorph logi logic logical +logicalimm +logicalimmediate +logicalkeystorename logically +logicalop +logicalshiftedregister +logicerr +logicians +logicknot +logicman +logicmanp +logicp +logics logimcl logimclad logimcld logimpl logimportfailure logimul +login logindex loginfo loginfoat logior logite +logitem +logl logle logleb logled loglesqrt loglint loglintif +loglist +loglistr loglt logltb logm @@ -46824,175 +76479,411 @@ logmahlermeasure logmap logmask logmaskp +logmaskpr logmul logn +lognand lognat logne logneg lognegb +lognm logno +lognor lognot +lognotr lognotu +lognsg +lognx logonunused +logop +logops +logor logorc logorderiso +logount +logp +logplus logpowmul logq +logr logratio logrec logreclem +logrepeat +logrev logrn logrnaddcl logrncl logrncn +logrpap logrpl logs +logsat +logsexp +logsize logsizeballseq logsizeballstruct logsizeradius logspace logsqrt +logsquash logsqvma +logsuplew +logt +logta logtail +logtails logtayl logtayllem logtaylo logtaylor logtaylsum +logtest logtr logunusedinstancesintheoremswhere +logvar logvariation logwarning logwarningat +logx logxor +logzeta +lohi +loi +<<<<<<< Updated upstream +lokan +lol +lolem +lon +lone +======= loire +lojo lokan +lol +lolem +lome lon +lone lonely +>>>>>>> Stashed changes +loneseomep +lonesomep +lonesomes long +longalias +longcircuit +longconst +longdiv +longenough longer longes longest +longestmatches longestof longestprefix longfile longfiledefvalue longfilelinter longhand +longidt +longkey +longleft longleftarrow +longleftrightar longleftrightarrow longline longlinelinter longlines longlonglongrightarrow longlongrightarrow +longmap longmapsto +longmul +longoffloat +longofint +longofintu +longofsingle +longofwords +longop longr longri longrig longrigh longright +longrighta longrightar +longrightarr longrightarro longrightarrow longroot longs +longu +longuoffloat +longuofsingle +longv +lonp loo +loob looinv +looinvdc looinvi looinvii look +lookahead +lookaheads lookaheadsof +lookaheadsofgamma looked +lookf +lookfield looking +lookingat lookmap +lookp +lookptun +lookptuno +lookr looks +looksize looksup +looku +lookunl +lookunr lookup lookupall +lookupalways lookupany +lookuparr +lookupbetween +lookupcat lookupdef lookupdefe lookupdefnode lookupdpair lookupenv +lookupfie +lookupfield lookupfinsupp lookupindex lookupkey +lookupmethod +lookupnoneappend +lookupnotin +lookupobj lookuporinsert +lookupp +lookupprecise +lookuprname lookups +lookupsl +lookupsomeappend +lookupstaticfield +<<<<<<< Updated upstream +lookupview +======= +>>>>>>> Stashed changes lookupwith loolin +loolinalt +looop loop loopalgebra loopalgebraequivlaurent +loopalternatives loopb loopback loopbody +loopcheck loopclwwlkn +loopcombinators +<<<<<<< Updated upstream +======= loopcounter +>>>>>>> Stashed changes +loope +looped +looper +loopexec +loopexit +loopexp +loopframe +loopfree +loopfreelist loopgredg loopgrnb loopgruspgr loopgrvd +loopguard loophomeo +loopi looping +loopingp +loopingt loopinv +loopinvariant +loopinvariants +looplang loopless +loopm +loopmodifies +loopne +loopnum +loopo loopofhom +loopp +looppath loops +loopsd +loopsem loopset +loopspec +loopspecs +loopsusppushoutsquare +loopsuspsquare +loopt +looptool +looptp +loopvariant +loopvariantbr +loopvariantcr +loopvariantfn +loopvariantpurecr +loopwithbody +loopwithoutbody +loopy +loopyforever +loopyfunction +loopyimap +loopyint +loopyiset loopyon +loopyopaquetype +loopyroger +loopysubsettype +loopytypeparam loor +loos loose loosebvarrange +loosesubterms +looukp +looup loowoz lop +lopb +lopba +lopban lopclset +lopp +loprime +lopsided +lopt +loptp +loptrel +lopu +loq lor +lora +lorc +lord +lorder +lorem lorenz +<<<<<<< Updated upstream +======= +lorenzo +>>>>>>> Stashed changes +lorexistsd +lorexistsdl +lorexistsdr +lorforalldl +lorna +lorsqu +lort +los lose loser +loserp losers +losersi loses +loset +losetequiv +losetpath +losetstr losing loss +losses lossless +lossy lost lot +lotp lots +lotschnittaxiom +lotsofobjects lotteries lottery louis +lousy +lout lovasz +love +lover +<<<<<<< Updated upstream +======= loves +>>>>>>> Stashed changes low +lowa lowbit +lowbits +lowbyte +lowcodes +lowconcat +lowd +lowdigit lowdim lowdistapprox lowdistapproxfromtree +lowe loweq +loweqe +loweqk +loweqp +loweqt lowequivalence lowequivreflexive lowequivsymmetric lowequivtransitive lower +lowera +loweradj loweradjoint loweradjunction +lowerallcoproductsof +lowerallproductsof loweratom lowerbasis +lowerbits lowerbound lowerbounds +lowerc +lowercase lowercentralseri lowercentralseries lowercentralserieslast lowerclosed lowerclosure +lowercompoundersof lowercomprepresentativeiso lowercone lowercross lowercrossingtime lowercrossingtimeaux +lowercut lowered lowerequivalence lowerfm @@ -47004,10 +76895,18 @@ lowerhemicontinuouson lowerhemicontinuouswithinat lowering lowerinv +lowerl +lowerleftunittriangle lowerloosebvars +lowerm +lowermap +lowermetrics +lowerpipeline lowerpolar lowerpoly lowerpowers +lowerrightunittriangle +lowers lowersemicontinuo lowersemicontinuouat lowersemicontinuous @@ -47015,48 +76914,107 @@ lowersemicontinuousat lowersemicontinuouson lowersemicontinuouswithinat lowerset +lowersets lowersetsupirred +lowert +lowerthan lowertopology lowertriangular +lowerupper +lowery lowest +lowestsetbit lowi +lowidx +lowin +lowinde +lowindex +lowli +lowlin lowlink +lowlong +lowmidbyte +lowmod lowner +loword +lowp +lowpn +lowptun +lowrandom +lows +lowsimp +lowsiz +lowsize +lowstar +lowstring +lowsub +lowsublowup +lowun +lowup +lowupconcat +lowval +lowview +lowviewe +lowviewi +lox +loy loyd +lozenge lpa +lpadchars lpaddconst lpadleft lpadlem lpadlen lpadmax lpadright +lpadstr lpadval +lpar +lparen lparr +lpart +lpartfun +lpath lpbcf lpbl +lpc lpcls +lpd +lpdi lpdifsn +lpds +lpeak +lpermutative +lpextendsl +lpextendsnlp lpfp lpfpc +lpfunct lpfval +lpgentzentoarrow lphil +lphogli +lpholli lpi lpideal lpigen lpinftysubalgebra lpinftysubring -lpintcm lpir lpirlidllpi lpirlnr lpirring lpiss lpival +<<<<<<< Updated upstream +======= lpkeycm +>>>>>>> Stashed changes +lplace lplem lplig lpligalt -lplist lplnbase lplncmp lplncvrlvol @@ -47085,7 +77043,12 @@ lplnset lplus lply lpm +<<<<<<< Updated upstream +======= lpmap +>>>>>>> Stashed changes +lpmcompact +lpmcomplete lpmeas lpmeassubgroup lpmeassubgrouptolpmeasiso @@ -47093,6 +77056,8 @@ lpmeassubgrouptolptrim lpmeassubgrouptolptrimiso lpmeastolptrim lpmeastolptrimlie +lpmtopology +lpn lpni lpnorm lpo @@ -47104,15 +77069,47 @@ lpolsatn lpolsetn lpolvn lpoly -lpoption lpos +lposfix +lposinf +lpow +lpowlpo +lpp lppairing lppilp lppthon +lpq +lpr +lpre +lprecomp +lpred lprefix +lprefixes lprefixi +lpreim +lpreimk +lpreims +lpresproof +lprime +lprob +lprod lprodr +lprog +lproject +lpropandac +lpropandal +lpropandar +lpropandfalse +lpropandl +lpropandr +lpropandtrue +lpropimplal +lpropimplar +lpropimpll +lpropimplr +lprstep lps +lpsat lpsmul lpspace lpss @@ -47121,45 +77118,104 @@ lpsscls lpsubmodule lpt lptioo +lptolp lptolprestrictclm +lptransfo lptre +lptree lptrimtolpmeas lptrimtolpmeassubgroup +lptrs lpuiss lpval lpvd -lpvertexcm lpvtx +lqa lqaqzi +lqbracet +lqbrackt +lqform +<<<<<<< Updated upstream +======= lqt +>>>>>>> Stashed changes lqu +lqueue +lquot +lquots lra +lrabt +lran lrat lratstep +lraxiom +lraxioms +lray lrb +lrbe lrc +lrcc +lrcons +lrcontinuous lrcut +lrd +lrdt +lre +lreal lrec lred lreg +lregm +lregn +lregp +lregs +lregx +<<<<<<< Updated upstream +======= lreiner +>>>>>>> Stashed changes +lrel lrelat +lrem +lrep +lrepeat +lreplace lreplicate lres +lresproof +lrest +lresult +lret lrev +lrevert lrevt +lrf +lrfiq +lrg lrh +lri lring lringnz lringnzr lringring lringuplu +lrinv +lrirq +lrke lrl +lrlemma +lrm +lrmon lrmorphism lrmorphismp +lrmul +lrn +lrnext lroft lrold lrow +lrpow +lrproves lrr lrrecfr lrrecpo @@ -47167,12 +77223,23 @@ lrrecpred lrrecse lrrecval lrs +lrsd +lrse lrsecure +lrsvc +lrt +lrtc lrtp +lrtree +lrule +lrulel +lrund lruneq +lrusr lrv lrx lsa +lsame lsat lsatcmp lsatcv @@ -47197,20 +77264,44 @@ lsatspn lsatssn lsatssv lsb +lsbf lsbis +lsbit +lsbits lsbminus +lsbnd lsbplus +lsbs lsc +lscalar +lscat +lscategory +lscdf +lscons lsd +lse +lseek lseg +lsegrec +lsemi +lsend +lseq lseqrule lseries lserieshassum lseriessummable lset +lsetd +lseti lsetp +lsetstack lsettoset lsf +lsglike +lsgofx +lsh +lshift +lshiftamt lshpat lshpcmp lshpdisj @@ -47225,17 +77316,38 @@ lshpnel lshpnelb lshpset lshpsmreu +lshrunk +lshs +lshu lsi +lside lsided +lsig lsigb lsin lsingle +lsingleton +lsisyndrome lsit +lsize lskiprule lsl +lslack lsli +<<<<<<< Updated upstream +======= lsls +>>>>>>> Stashed changes +lslt +lsltbetween +lsltdistinct +lsltlsplus +lsltnoteq +lsltnotrefl +lsltnull +lslttrans lsm +lsmaller lsmass lsmcl lsmcntz @@ -47282,7 +77394,14 @@ lsmul lsmunss lsmval lsmvalx +lsn +lsnds +lsnil +lsnv lso +lsolve +lsort +lsosets lsp lspabs lspace @@ -47291,7 +77410,9 @@ lspasl lspcl lspdisj lspdisjb +lspec lspeqlco +lspex lspexch lspexchn lspextmo @@ -47304,6 +77425,9 @@ lspindp lspindpi lsplit lsplitremainder +lsplus +lsplusass +lspluscomm lsppr lspprabs lspprat @@ -47320,7 +77444,9 @@ lspsnat lspsncl lspsncmp lspsncv +lspsnel lspsneleq +lspsneli lspsneq lspsneu lspsnid @@ -47348,8 +77474,12 @@ lspuni lspvadd lspval lsq +lsqr +lsqrt lsr lsrc +lsrm +lsrt lss lssacs lssacsex @@ -47359,10 +77489,14 @@ lssatomic lssats lssbn lsscl +lssclg lssdimle lssel +lsselg +lssex lssincl lssintcl +lssintclm lssle lsslindf lsslinds @@ -47371,6 +77505,7 @@ lsslsp lsslspold lsslss lsslvec +lssmex lssmre lssn lssne @@ -47379,13 +77514,19 @@ lssnle lssnlm lssnvc lsspropd +lsspropdg lssset +lsssetm lsssn lsssra lssss +lssssg lssssr lsssssubg lsssubg +lsst +lsstp +lsstpd lssum lssuni lssvacl @@ -47396,33 +77537,80 @@ lssvs lssvscl lssvsubcl lst +lstable +lstablesetwise +lstabno +lstackloc lstar lstarlw +lstart +lstat +lstate +lstatep +lstates +lstep lsteps +lstgrpid +lstk +lstore +lstoreloc +lstp lstprd lstream +lstrfix +lsts +lstseqp +lsttoo +lstval lsu lsub lsubgroup +lsublist +lsubmx lsubrotld +lsubset lsubsp +lsubst +lsubstitution +lsubstitutive lsubswap lsubtypedomain +lsuc +lsucc +<<<<<<< Updated upstream +======= lsue +>>>>>>> Stashed changes +lsuffix +lsulu lsum lsumr lsup +lsupd +lsv lsw +lswap +lswapstr +lswapstrl lswccat lswccatn lswccats lswcl lswco lswcshw +lswex lswlgt lswn lsws +lswwrd +lsx +lsym +lsymbol +lsymbols +lsyms +lsz lta +ltabs ltabulate ltac ltadd @@ -47444,24 +77632,50 @@ ltaddsubi ltaddsublt ltaddsubs ltaddsubsd +ltailcall ltake +ltakei +ltakes ltakeuntil ltakewhile ltam ltanq +ltanqg +ltanqi +ltap +ltapd ltapi +ltapig +ltapii ltapr +ltaprg ltaprlem ltasr +ltasrg ltat ltb +ltbl +ltbool +ltboolfalse +ltbooltrue ltbtwnnq +ltbtwnnqq ltbval ltbwe ltc ltceilhalf +ltcex +ltcirr +ltcolor +ltconst +ltcpw +ltctban ltcvrntr ltd +ltdcnq +ltdcpi +ltdec +ltdfpr ltdifltdiv ltdiv ltdivgt @@ -47471,12 +77685,36 @@ ltdivmuls ltdivmulsd ltdivmulswd ltdivp +ltdr lte lteaddright +ltealttolte +<<<<<<< Updated upstream +lteantisym +======= +>>>>>>> Stashed changes +ltebldl +ltebldr +ltebrdl +ltebrdr +lted +ltedl +ltedr +ltee +lteereal +lteey lteh +lteifs lteimpliesnotgt +lteislte +lteisplus +ltelpow ltembedding lten +ltenat +ltenl +ltenotlteq +ltenr ltens ltensor ltensoralghom @@ -47487,46 +77725,118 @@ ltensorhomequivhomltensor ltensorhomtohomltensor ltensorkerincl ltensorone +ltenye +ltepow lteq lterecall lterecallleft +<<<<<<< Updated upstream +lterefl +======= +>>>>>>> Stashed changes +ltereflection ltereflectslte lterm lterpq +ltes +ltesr ltesubnnd +ltesuccabsurd +ltesuccinjective +ltesuccinjectivemonotone ltesuccleft ltesuccright +<<<<<<< Updated upstream +ltetrans +======= ltet +>>>>>>> Stashed changes +lteupri +ltewf +ltewflte +ltewfpreorder ltex ltexnq +ltexnqi +ltexnqq ltexp ltexpi ltexpri ltexprlem +ltexprlemdisj +ltexprlemell +ltexprlemelu +ltexprlemfl +ltexprlemfu +ltexprlemloc +ltexprlemlol +ltexprlemm +ltexprlemopl +ltexprlemopu +ltexprlempr +ltexprlemrl +ltexprlemrnd +ltexprlemru +ltexprlemupu +ltey +ltezeroiszero +ltezerosuccabsurd +ltf +ltfinasym +ltfinex +ltfinirr +ltfinp +ltfintr +ltfintri +ltfintrilem ltfirp ltfirpmpt ltflcei ltfnum ltfnumzero +ltformula ltfsubnormal +ltfun +ltfuninrange +ltfunval ltgov ltgseg +ltgt +ltgte +ltgtp lth lthalf +lthen +<<<<<<< Updated upstream +======= lthm +>>>>>>> Stashed changes lths lti ltideal +ltimes ltimpliesnotgte +ltinrange +ltirr +ltispr +ltk +ltkeys +ltkfreeze +ltksimp ltl ltland +ltlaxio +ltlb ltlc +ltlcompind ltld ltle ltleadd ltleaddd +ltleap ltlecasei ltled +ltlefin ltlei ltleii ltleletr @@ -47534,6 +77844,8 @@ ltlem ltlen ltlend ltleni +ltlenlec +ltlenmkv ltlesd ltlesnd ltlestr @@ -47542,18 +77854,38 @@ ltletr ltletrd ltletri ltli +ltlind ltlist ltlistirrefl ltlisttrans +ltll +ltlmodel +ltlmodelstr ltln +ltlnew +ltlnext +ltlnode +ltlnodes +ltlo +ltlold ltlor ltlp +ltlr +ltls +ltlsta +ltlstates +ltlt ltltncvr ltm ltmin +ltmininf ltmnq +ltmnqg +ltmnqi ltmod ltmpi +ltmpig +ltmprr ltmul ltmuldiv ltmuldivd @@ -47566,6 +77898,12 @@ ltmulneg ltmulnegs ltmuls ltmulsd +ltmx +ltmxe +ltmxeneq +ltmxerank +ltmxw +ltn ltnatbool ltne ltned @@ -47580,43 +77918,85 @@ ltnei ltneii ltnelicc ltneverrefl +ltnge +ltngtp +ltninfty ltnle ltnled ltnlei ltnles ltnltne +ltnn +ltnnge +ltnnnq +ltnp +ltnqex +ltnqpr +ltnqpri ltnr ltnrd ltnri +ltnrw +ltns +ltnsn ltnsym ltnsymd ltnsymi +ltntri +ltnumeral ltnw +ltny +ltnye +ltnyr +ltnz +ltoc ltoddhalfle ltof ltofun +ltol ltonold ltonsex +ltonum +ltonumrange +ltoo ltopreflectslt +ltopt ltor ltord ltordlem +ltouched +ltow ltp +ltpi +ltpinfty ltpiord +ltpm ltpnf ltpnfd ltpo +ltpopr +ltposr ltprord +ltprordil +ltps ltpsrpr +ltpsrprg +ltqr ltr ltrabdioph ltrans ltransp +ltrbdl +ltrbldl +ltrbldr +ltrdl +ltrdr ltrec ltrecd ltreci ltrecii ltree +ltreflection ltrel ltrelnq ltrelpi @@ -47624,7 +78004,13 @@ ltrelpr ltrelre ltrelsr ltrelxr +ltrenn +ltrennb +ltres ltresr +ltrgt +ltrgtp +ltrl ltrm ltrmxnn ltrmy @@ -47635,6 +78021,7 @@ ltrnatb ltrnateq ltrnatlw ltrnatneq +ltrnbound ltrncl ltrncnv ltrncnvat @@ -47652,6 +78039,7 @@ ltrncvr ltrnel ltrneq ltrnfset +ltrnge ltrnid ltrnideq ltrniotacl @@ -47662,6 +78050,7 @@ ltrniotaidvaln ltrniotaval ltrniotavalbn ltrnj +ltrnl ltrnlaut ltrnldil ltrnle @@ -47671,10 +78060,22 @@ ltrnmw ltrnnid ltrnnidn ltrnq +ltrnqg +ltrnqi +ltrnr ltrnset ltrnu ltrnval +ltrnw +ltrp +ltrq +ltrr +ltrue ltrv +ltrw +ltrx +ltry +ltrz lts ltsasym ltsdining @@ -47692,12 +78093,14 @@ ltso ltsonq ltsopi ltsopr +ltsort ltsosr ltsp ltsrec ltsrecd ltsres ltsrpr +ltsrprg ltsso ltssolem ltst @@ -47727,7 +78130,9 @@ ltsubsubsbd ltsuc ltsval ltt +lttable lttl +lttolte lttophomeomorphnnreal lttr lttrans @@ -47736,29 +78141,46 @@ lttri lttrid lttrii lttrn +lttrsr +ltu ltw ltwefz ltwenn ltweuz +ltwlin +ltwo +ltwritable +ltx +ltxq ltxr ltxrlt +ltxx ltxy +lty +ltyp ltype +ltyx ltz ltzero +ltzlt +ltzn +lua luaux lub luba lubb lubcl +lubdd lubdm lubel lubeldm lubell lubelss lubeu +lubfraenkeldistr lubfun lubfval +lubi lubid lubl luble @@ -47783,30 +78205,69 @@ lucas lucaslehmer lucaslehmerresidue lucaslehmertest +lucid +luckily +lucky +luentries +lui luieavma luk +lukasi +lukasslemma luklem lukshef lukshefth +lumen lunar +lunation +lune +lunfold +luni lunion lunit +lunitg +lunitgroupequiv +lunitgroupiso +lunitiso +lunitk +lunitnatiso +lunitp luniv lunstream lunwindsdcond +lunzip lup +lupd lupdate +lurch +lurches luroth lus luschny +lusternik +<<<<<<< Updated upstream +======= lution +>>>>>>> Stashed changes +lutra +lux +luxury luzin lval +lvalexprs lvalidfrom lvalidfroms +lvals lvalue +lvaluep +lvaluesp +lvaluet lvar +lvardesc lvars +lvdescendants +lvducxu +lve lvec lvecdim lvecdimfi @@ -47823,12 +78284,15 @@ lvecprop lvecpropd lvecpsslmod lvecring +lvector lvecvs lvecvscan lvecvsn +lvinf lvivl lvl lvls +lvoid lvolbase lvolcmp lvolex @@ -47843,56 +78307,123 @@ lvolnlelln lvolnlelpln lvolnltn lvolset +lvprefixes +lvs +lvsize lvsum +lwfclicov +lwfcno +lwfstab +<<<<<<< Updated upstream +======= lwhenfn +>>>>>>> Stashed changes lword lwordnil +lws +lwsd +lwse +lwu lwyudgprqvudhazk lxfirst +lxfollow lxor +lxort lxs +lxsx +lxsxe +lxx lxy +lyapunov +<<<<<<< Updated upstream +======= lyearfn +>>>>>>> Stashed changes lying -lyle lym +lynch lyndon lyndond lyndoni lynfac lynsuf +lys lywvxtx -lyx lyz +lza +lzaguts +lzap +lzcnt +lzcomp +lzcomprb +lzcompress +lzdecompress lzenom lzero +lzinit lzip +lzipwith lziskksnrtgjqovoirudpmqrtvgrg +lzlist +lzmatch +lzmatchrb +lznum lzozvkn +lzs +lzss +lzssrb lzunuz +lzvalue maa maafxqqbnojafsshcoxomnkmuluaacntdatiapsxqugjunsfmowdd mab +mabc +mabnanbkeyk mabs mac +macarthy +macaulay +mach machine +machinecoresemantics +machineepsilon +machinep machinery machines machinesig +machinewidth +macho +machstate machstep +mack +macl maclaurin +macneille macobjctrlattrhavechanged macquarie macro +macrocycle +macroequivstr +macroexpand +macroexpands macroexpansion +macroinstruction +macrolet macrom macron macroname +macros macroscopes +macrostructure +macrounivalentstr macsecurestate macsubctrlattrhavechanged mact +macte madd +maddm +maddr +maddrsize maddux made madebday @@ -47902,9 +78433,6 @@ madebdaylemold madecut madef madefi -madefromfruit -madefromgrape -madeintowine madeno madenod madeoldsuc @@ -47917,6 +78445,7 @@ madeun madeval madjusmdet madjusmdetlem +madras maducoeval maducoevalmin maduf @@ -47927,52 +78456,123 @@ madurid madutpos maduval mae +maett +maewnpu +mafter +mag +<<<<<<< Updated upstream +magazine +======= +>>>>>>> Stashed changes magdalena magic +magically magicl magicr +magicseq magma magmacat +magmacategory magmacatisotomulequiv +magmaf +magmaprecategory +magmatotalpre +magmawildcategory +magmoid +magn +magni +magnitud magnitude magq +magree mahler mahlerequiv mahlermeasure mahlerseries mahlerterm +mahlo +mai +mail main +mainadatatype mainargs +mainbdatatype +maincall +maincdatatype maindelete mainer mainerim +maingeach maingoal maingoaldischarger maingoalname mainly mainmodule mainpart +mainresult +mainresultbits +mainresultsign +mainresultzero +mainret +mainreturn mainstatements mainsubgoals mainsum maintain maintained +maintainedd +maintainedi +maintainers +maintaining maintains +maintenance maintenant mainthm mainu mainvar maj maje +majo major +majorant +majorants +majorate +majorated majoration +majori majoring majorities majority +majoritycirc +majorityicirc +majorityistr +majorityoutput +majorityset +majoritystr majorized +majorizes +majp +majs +majsi +mak +makarios make +makea makeabsolute +makeaddr makeaf +makeapair +makearesult +makearg +makeargs +makeassign +makeauxiliarydef +makeaxiomatization +makeb +makeblack +makebool +makebytes +makec makecarray makecarraycorrect makecat @@ -47988,44 +78588,141 @@ makecf makecfcorrect makecfpreserves makecnf +makeco +makecommmonoid +makecommring makecongrmstring +makeconnectedcw +makeconst +makeconstuniq +makecube +makecurmax +makedel +makedistlattice makedupleratoprim makeeditlink +makeenkeys +makeenvironment makefacefinal +makefacefinalfacelist makefacefinals makefastinstance +makefield +makefile +makeformp makeftor makeftormor makeftorobj makeftorpreftor makegcongrlemma makegcongrstring +makeget +makegetoutput +makegradedring +makegradedringself +makegroup +makeif +makeint +makeiscommmonoid +makeiscommring +makeisdistlattice +makeisfield +makeisgradedring +makeisgroup +makeisiso +makeislattice +makeismonoid +makeispseudolattice +makeisrezkcompletion +makeissemilattice +makeissemiring +makekey +makekeyhat +makekeyhatlength +makekeylength +makekeys +makel +makelattice makelist +makelock +makelong +makem +makemat +makemonoid +makemultiarr +makemultiarray +makename +makenatfailure +makenatsuccess +makenicefincw +makenicefincwelim +makenicefincwskel makennf makennfn +makent +makentapp +makeopaque +makeput maker +makerefl makerelative +makerevprekey +makerevprekeylength +makerevsubkey +makerevsubkeylength makerhs +makeroundkey makes makescolimit +makesemilattice +makeseq +makesequentcalculus makeslimit makesnewmvars makesoverarrow +makespace makespan +makestackmap makestep makestring makestronger +makesubkey +makesubkeybitslice +makesubkeybitslicelength +makesubkeyhat +makesubkeylength +makesureboundsarediscoveredwithoutfirstsimplifyingtheexpression +makesuredefaultvaluesarenotusedinupdate +makesym +maketemps +maketl +maketotal +maketrace +maketracecorrect +maketraceforall +maketraceforallnice +maketraceimp +maketraceimpnice +maketracenot +maketracenotnice +maketrans +maketycontext +makevoidfailure +makevoidsuccess making +makunbound +mal male malformed malformedargumentlisterror malformedforalltypeerror malformedgoalerror +malicious mall malloc +mallocn malt maltsiniotis -mammal mamuass mamucl mamudi @@ -48042,15 +78739,31 @@ mamutpos mamuval mamuvs man +mana +manage managed management manager +managing +manb +manbkabcacb mand mandatory +<<<<<<< Updated upstream +======= mandela +>>>>>>> Stashed changes +manep +manf +mangler mangoldt manhattan manifest +manifestdata +manifested +manifestoptions +manifestpath +manifests manifol manifold manifolds @@ -48061,18 +78774,47 @@ manipulation manipulations mann manner +mannot +manoli +manolios +mans +mant mantissa mantop +mants manual +manualexplicitnotrigger manually +manualproof +manualtriggerthatdoesnotwork +manualtriggerthatworks +<<<<<<< Updated upstream +======= manufacture +>>>>>>> Stashed changes many manychars manyconfig +manyindices manyof manyonedegree manyoneequiv manyonereducible +manysor +manysort +manysorte +manysorted +manysortedcategory +manysortedf +manysortedfunction +manysortedfunctor +manysortedoperation +manysortedrelation +manysortedset +manysortedsigmafield +manysortedsign +manysortedsubset +manywiththis map mapa mapaccumlm @@ -48083,6 +78825,7 @@ mapactioncomp mapactioncongr mapaddh mapaddhom +mapaddleft mapaddmonoidhom mapaffineopencover mapalg @@ -48099,6 +78842,7 @@ mapandcomap mapannempty mapannlist mapannmap +mapapp mapappend maparrow maparrowequivalence @@ -48107,6 +78851,7 @@ maparrowleft maparrowright mapassoc mapasyncchunked +mapat mapaugmentedcechconerve mapaugmentedcechnerve mapaut @@ -48148,6 +78893,14 @@ mapbinarybicone mapbiprod mapbiproduct mapbot +mapbox +mapbyte +mapc +mapcan +mapcanon +mapcanonicalize +mapcar +mapcard mapcechconerve mapcechnerve mapclm @@ -48201,6 +78954,7 @@ mapcomposablearrows mapcomposablearrowsobjmk mapcomposablearrowsopiso mapcompose +mapcomprehension mapcompright mapcon mapcone @@ -48223,9 +78977,11 @@ mapconstructor mapcontaction mapcontactioncomp mapcontactioncongr +mapcontainsafterupdate mapcontinuousmulequiv mapcotangent mapcrumb +mapcs mapcycles mapcyclesiso mapd @@ -48239,6 +78995,8 @@ mapdcnvid mapdcnvordn mapdcv mapddlssn +mapdec +mapdelta mapderivedcategor mapderivedcategory mapderivedcategoryfactors @@ -48257,6 +79015,11 @@ mapdifferentialobject mapdin mapdincl mapdindp +mapdisjoint +<<<<<<< Updated upstream +mapdisjointmerge +======= +>>>>>>> Stashed changes mapdjuen mapdlsm mapdlsmcl @@ -48275,6 +79038,14 @@ mapdomainnonunitalalghom mapdomainnonunitalringhom mapdomainringequiv mapdomainringhom +<<<<<<< Updated upstream +mapdomainsubset +======= +>>>>>>> Stashed changes +mapdomrestr +mapdomrestrby +mapdomrestrbyapp +mapdomrestrto mapdord mapdordlem mapdpg @@ -48288,12 +79059,19 @@ mapdspex mapdunirnn mapdval mapdvalc +mape mapedgeset mapelements mapembedding mapemnbmvrohppjpibvdnlbewsqximqh +<<<<<<< Updated upstream +mapemptykeys +======= +>>>>>>> Stashed changes +mapemptyp mapen mapend +mapenv mapeq mapequ mapequiv @@ -48303,16 +79081,20 @@ mapex mapexactaux mapexactauxdelta mapexactfunctor +mapexi mapexold mapextaddhom mapextendempty mapextendscalars mapextlinearmap +mapf mapfactorizationdata +mapfailure mapfi mapfield mapfien mapfienlem +mapflag mapfold mapforallbindernames mapforalltelescope @@ -48320,17 +79102,23 @@ mapforget mapfoss mapfour mapfr +mapfra +mapframe mapframehom mapfree mapfset mapfst +mapfstcompose +mapfstid mapfun mapfunctor mapfunctorarrows +mapfunctorial mapfvd mapfzcons mapgen mapgenerators +mapget mapgl mapglint mapgluedata @@ -48341,6 +79129,7 @@ mapgrpfunctor mapgrpidiso mapgrpnatiso mapgrpnattrans +maphash maphom maphomologicalco maphomologicalcomplex @@ -48365,12 +79154,18 @@ mapidx mapidxm mapidxmaux mapidxmgo +mapii mapiic +mapimp +mapin mapincl mapinclisometry mapinj mapinjectivepresentation +mapino +mapintbool mapintegralclosure +mapintint mapinverse mapiscolimit mapiscolimitofpreservesofiscolimit @@ -48384,8 +79179,13 @@ mapisoofislimit mapisotoorderiso mapisowhiskerleft mapisowhiskerright +mapissafebecauseitisinmemory +mapit +mapk mapker +mapkeysvalues mapl +maplaws maple mapleft mapleftcomp @@ -48399,6 +79199,8 @@ maplincl maplinearequiv maplinearisometryequiv maplinearmap +maplist +maplistlemma maplmhm maplmonoidhom maplmultilinear @@ -48414,6 +79216,7 @@ mapmatrixmodule mapmaybe mapmaybeisinj mapmeasure +mapmerge mapmon mapmoncompiso mapmonfunctor @@ -48423,14 +79226,19 @@ mapmonnattrans mapmono mapmonoidhom mapmulhom +mapmult +mapmulti mapmulticospan mapmultifork mapmultiforkofislimit mapmultilinear +mapn mapnatbool mapnatiso mapnattrans mapneighborset +mapnil +mapnth mapo mapobj mapobjfun @@ -48438,15 +79246,23 @@ mapobjiso mapof mapofcompatiblesmul mapofeq +mapoffset mapofhomotopy mapofiscolimit mapofislimit mapofle mapofmeasurable +mapofseqof mapofsurjective +mapok mapopcyclesiso +mapops +mapoption maporderembedding +mapoveridfun +mapoverspan mapp +mappable mappair mappaircomp mappairequiv @@ -48456,14 +79272,21 @@ mappairleft mappairright mappartial mappath +mappcm mapped mappedd mappedi +mappedread +mappedwrite +mappend +mapper mappi +mappick mappievalringhom mappilocaliza mappilocalization mapping +mappingable mappingcocone mappingcone mappingconecomphomoto @@ -48472,7 +79295,9 @@ mappingconecomptriangle mappingconecomptriangleh mappingconehomofdegreewisesplitiso mappingconehomofdegreewisesplitxiso +mappinge mappings +mapply mappossubmonoid mappower mappowexpcharpowofisseparable @@ -48486,9 +79311,15 @@ mapprojectiveresolution mapproof mapprop mappsrpr +mappsrprg mappullback mappullbackadj mappushoutadj +mapput +<<<<<<< Updated upstream +mapputget +======= +>>>>>>> Stashed changes mappwen mapq mapqlinear @@ -48505,6 +79336,12 @@ maprangeringequiv maprangeringhom maprel maprelations +mapremove +<<<<<<< Updated upstream +mapremoveabsent +======= +>>>>>>> Stashed changes +mapresult mapreverse mapreversecomp mapreverseid @@ -48520,33 +79357,46 @@ mapringhom maprnin maprnss maproots +maprop +maprule +maprulei maps +mapsc mapscalars mapsec +mapsequal +mapserializefailure mapset mapsetembedding mapsetequiv mapsetofmaximal mapsetofminimal +mapsettoset mapshortcomplex mapshortcomplexh +mapsi +mapsingleton mapskeleton mapsn mapsnakeinput mapsncnv mapsnconst mapsnd +mapsndid mapsnen mapsnend mapsnf mapsnop mapspecmap +mapsplit mapsquare mapss mapssbi +mapsset mapssfset mapsspm mapsspw +mapst mapsto mapstocompdef mapstoe @@ -48554,20 +79404,36 @@ mapstoi mapstoop mapstoopop mapstorestrict +mapstream mapstringsm +mapstub mapsubgroup mapsubmodule +mapsubset mapsubtype mapsucc +mapsuffixedsequence mapsurjective +mapsweep +mapt maptermrel maptermrelequiv +maptest +maptimes +mapto maptocomposablearrows maptoequalizer maptofractionring +maptoint maptokens +maptolower maptop +maptoseq maptosubgraph +maptot +maptotalresult +maptounitcommring +maptree maptriangle maptrianglecommshiftiso maptrianglecompiso @@ -48591,16 +79457,28 @@ maptrifunctorobj maptwosidedideal mapu mapunen +mapupd +<<<<<<< Updated upstream +mapupdateidempotent +======= +>>>>>>> Stashed changes mapval mapvalg mapvaluegroupwithzero +mapvalues +mapvec mapvertexgroup +mapvint +mapvintz mapwhisker mapwhiskerleft mapwhiskerleftisoconjpremap mapwhiskerright mapwhiskerrightassmallfunctor mapwith +mapwithelemextensional +mapwithindex +mapwithkey mapx mapxpen mapy @@ -48609,6 +79487,11 @@ mapzerocokernelcofork mapzerokernelfork mapzeroobject mapzip +mar +march +marchal +marches +marco marep marepvcl marepveval @@ -48616,58 +79499,142 @@ marepvfval marepvmarrepid marepvsma marepvval +marg +<<<<<<< Updated upstream +======= margaux +>>>>>>> Stashed changes margin marginal marginals marginleft +margr +margrel maria mariamagdalena mario mark +markchange +marke marked +markedandmemberimpliesismarkedelement +markedd +markedelementismarkedtrue +markedelements +markedelementsappend +markedelementsareelements +markedp marker markers +markertype market +markexclusiveglobal +markexclusivelocal marking +markinglambda +markings markov markovian +markovs marks marksd +marksi +marksin +marksindex +marksp +markstein +marksum +marksumempty +marksumfootprint +marksumnonempty +marktree +marp +marqu +marr +marray marrep marrepcl marrepeval marrepfval marrepval marriage +<<<<<<< Updated upstream +======= marriagelicensedocument +>>>>>>> Stashed changes +married +mars +marsdecrypt +marsdenlem +marsencrypt marshal marshall marshalling martin martingale +martingaleae martingalepa martingalepart +marvelous +mary +maryinvector marypha +<<<<<<< Updated upstream +======= marys +>>>>>>> Stashed changes +marzipan +mas mascheroni +maschke +maserial +mashed mask +maskarray +maskarrayi +maskarrayp +maskbits +maskdiv masked +maskedcommlshiftupcast maskeddb +maskedvals +maskedword +maskf +maskfree maski masking +masklen masklib +masklist +maskn masks +masksp +maskzero +masm +masr mass massage +<<<<<<< Updated upstream +======= +masserati +>>>>>>> Stashed changes +massert masses +massey massf +massively +massoc master +masters +mastr mat matachany matadd +matan matassa matbas +matc match matchable matchall @@ -48677,45 +79644,78 @@ matchand matchandnorm matchany matchapp +matchappfield matcharg matchbody +matchcase +matchcaseparsing matchclone matchconstinduct +matchcriterion matchd matchdollar matchdom matched +matchedp matchepsilon matcheq matcher matchername matchers matches +matchesf matcheshead +matchesi matcheverything matchexpr +matchexpressionscope matchf +matchfailure +matchfn matchfoldl matchforall matchfun +matchfunspecs matchfvar +matchgenv +matchhyp matchhyps matchi +matchincalc matchindex matching +matchingdestructor matchingprefixes matchings +matchinj +matchint +matchiscorrect +matchisi +matchit matchkey +matchl matchlambda +matchlength +matchlengthinbounds +matchlengthrb +matchlengthworks matchless +matchlet +matchlocal +matchmu +matchn matchnone matchnot +matchnotand +matchopte matchor matchorder matchp matchpattern matchpatterns +matchpx matchquerystar +matchquote matchrel matchreld matchresult @@ -48725,17 +79725,29 @@ matchs matchscalars matchscalarsaux matchscoped +matchsetfield matchstate +matchstatelis +matchstatelist +matchstatementscope +matchstmt +matchsuccess matchtreerootstar matchtreestars matchty matchtype matchtypeof +matchv +matchval +matchvaluerulep matchvar matchvecconsprefix matchvecconsprefixq +matchwith +matchworld matcpmric matd +matdch matdim mate matecl @@ -48748,7 +79760,12 @@ mateequivvcomp matepm matepmcl material +materialisation +materialproviders +materialprovidersclient +materialprovidersconfig materials +materialsmanager mates matfsupp matgrp @@ -48756,21 +79773,28 @@ matgsum matgsumcl math mathbb +mathbbbc +mathbbbr mathbox +mathcomp mathematical mathematically mathematicians mathematics mathematik +mathfunctionsnan +mathit mathl mathlib mathlibtest mathmain +mathmorp mathoverflow mathrm maths mathsf matid +matinsert matinv matinvg matinvgcell @@ -48788,10 +79812,12 @@ matplusgcell matpoly matpolyequiv matpow +matpower matr matrcl matrepv matri +matric matrices matricization matricize @@ -48800,26 +79826,42 @@ matring matrix matrixadjoints matrixalgequivendvecmulopposite +matrixc +matrixcat matrixdecomposition matrixdecompositionaddequiv matrixdecompositionlinearequiv +matrixequal matrixequiv matrixequivalence matrixequivtensor +matrixex matrixgroups +matrixj +matrixlambda matrixmodcat matrixofpo matrixorder +matrixp matrixpreinnerproductspace matrixprodaction +matrixr matrixringequivendvecmulopposite matrixspace matrixtolin +matrixtosequence matrixtostdbasis +<<<<<<< Updated upstream +======= matrixu +>>>>>>> Stashed changes +matrlin matroid matroids +matrprob matrrep +matrtop +matrx mats matsc matsca @@ -48831,23 +79873,28 @@ matt matte matter matters +matthews +mattk mattopolymat mattpos mattposcl mattposm mattpostpos mattposvs +mattr mattype matunit matunitlindf matunitlindflem matval +matvec matvsca matvscacell matvscl matxmat matxvec mau +mauxa mavmul mavmulass mavmulcl @@ -48858,22 +79905,51 @@ mavmulval mavmumamul max maxa +maxabs +maxabsle +maxabslemab +maxabslemlub +maxabslemval +maxabsorblmin +maxadset +maxadsf +maxadsspace +maxainv +maxainvm +maxainvs +maxapp +maxar maxargsfor +maxassoc +maxassociates +maxaux maxbalinp maxbank +maxbeta +maxbetale maxbid maxbidalg maxbidequivalence maxbinade maxblk +maxbound +maxc maxchain +maxchar maxchopper +maxcl +maxclpr +maxcncf +maxcom +maxcomm maxcompatible +maxconstrsign maxd maxdefault maxdeg maxdegree maxdepth +maxdist maxdistance maxdiv maxdivcorrect @@ -48888,18 +79964,45 @@ maxdivunique maxdivuniquedigit maxdivuniqueinverse maxdivuniqueinversedigit +maxe +maxed +maxel +maxelem +<<<<<<< Updated upstream +maxelement +======= +>>>>>>> Stashed changes +maxencrypteddatakeys maxentry +maxeny maxeq +maxerr +maxes maxex +maxexists +maxexponent +maxext +maxey +maxf maxfbounded +maxfd +maxfindomelem +maxfinseqex +maxfinsetelem maxfloat maxflow maxfoelner +maxfuncreal maxgeneigenspace maxgeneigenspaceindex +maxgon +maxgroup +maxgroupp maxheartbeats maxi +maxid maxideal +maxidem maxidl maxidlidl maxidlmax @@ -48907,92 +80010,177 @@ maxidln maxidlnr maxidlval maxidx +maxilst maxim maxima maximal maximalallactionwithoutseller +maximalallocationbridgingtheorem maximalatlas maximales +maximalfilters maximalfor +maximalhintikkap maximalideal +maximalinf maximality +maximalj maximally maximalofprime +maximalp maximalrealsubfield maximals maximalseparatedset maximalspectrum maximalspectrumtopilocalization maximalstrictallocations +maximalsubgroup +maximalt maximin +maximisation +maximization maximize maximizes +maximizing maximum maximumclique maximumd maximumindepset +maximumisunique maximumleftupperbound maximumminimum maximumprinciple maximumrightupperbound maxindex +maxinst +maxint maxintros +maxismax +maxisort +maxispr +maxj +maxkn maxl maxle +maxleast +maxleastb +maxleastlt +maxleb +maxleim maxlemma maxlen maxlength maxlist maxlists +maxlit +maxlo +maxlocals maxlp maxlt +maxlte +maxltsup +maxlub maxm maxmax maxmaxbis +maxmimum maxmin maxmininductionvalue +maxminset +maxmt maxmvars maxn maxna maxnac maxnaca +maxnat +maxnatl +maxnatr maxnc maxnca maxne -maxnext maxnilpotentideal maxnilpotentidealisnilpotent maxnilpotentsubmodule +maxnk maxnn +maxnode +maxnormal +maxnormalm maxnp +maxnr +maxnss +maxnum +maxnye +maxo +maxoffset maxofle maxop maxoperator maxoppmin +maxout maxp +maxpacketsize +maxpair +maxpat +maxperm +maxpermorder maxpowdividing maxpowdvddiv +maxpredl +maxpredr maxpref +maxprefix maxprmfct maxproducts +maxproperty maxqueued maxr +maxra +maxrac +maxrank maxrat +maxrc +maxrca +maxreal +maxrn +<<<<<<< Updated upstream +======= maxroot +>>>>>>> Stashed changes maxroundedmodep +maxrp +maxrr maxs maxsat +maxsegsum +maxsemilatticestr maxset +maxsetp +maxsetsup maxsize maxslowdown +maxsmall +maxsort maxspeed maxsplit maxsplitter maxsta +maxstack +maxstackenvironment maxsteps +maxsub +maxsublo +maxsubterm +maxsubterms +maxsuc +maxsucl +maxsucr +maxsum maxsx maxt maxtail +maxtau maxtensorproduct maxterm maxti @@ -49007,34 +80195,89 @@ maxtrivlinearmapequivliemodulehom maxtrivsubmodule maxtru maxtype +maxulp maxunifeigenspaceindex maxuniquep +maxv +maxval +maxvalue maxvar +maxvarfreevar +maxvarv +maxvnamelen +maxw maxwidth maxword +maxx maxy +maxye may +mayb maybe +<<<<<<< Updated upstream +maybebind +maybebindassoc +======= +>>>>>>> Stashed changes +maybeeq +maybeequivaction +maybeequivstr maybefunctiondata +maybeint +maybeintermed +maybeintermediatewrappedmat maybelte +maybemap +maybemapcompose maybeminimal +maybenew +maybeormaybenot +maybeparts +maybeprefix maybeproveinjective maybepseudosyntax +mayberel +mayberelmatchesequiv +mayberelmatchestransp +mayberelstr +maybesomething +maybestructure +maybesuitablerel maybet +maybetolist +maybetransportstr +maybeunivalentstr +maybevs mayclosegoal mayclosegoalfromhyp +mayer mayervietorissquare mayete mayetes mayfail maypostpone +mayprint +mayret +maze +<<<<<<< Updated upstream +======= mazh +>>>>>>> Stashed changes +mazurkiewicz +mazurulm mba +mback +mbad mbal mball +mbar +mbasis mbc +mbe mbed mbedtls +mbefore +mbeq mbf mbfadd mbfaddlem @@ -49086,8 +80329,15 @@ mbfsub mbfsup mbfulm mbgzujswqysdpsyxjdy +mbhd +mbi +mbig mbim +mbinary mbind +mbindfpurge +mbindfsave +mbindfstop mbinomial mbl mble @@ -49098,27 +80348,61 @@ mblsplit mblss mblvol mblvon +mbmybag +mbnakab +mbo mbody +mbooks mbool mboolean mbot mbounded -mbox mbpadic +mbr +mbreak +mbreqdomain +mbreqtypes +mbs +mbt mbta mbuf -mbv mbxpaxfvgsvlslmhqbrntxahalv +mbytes mca +mcachelen +mcachep +mcalc +mcall +mcaller +mcand +mcar +mcardinal +mcart +mcase mcast +mcatch mcauchy mcball mccarthy mccarthyninetyone +mccis mccl mccllem +mccune +mcdr mce +mcell +mcertify mcf +mch +mcheck +mchoice +mchoose +mcis +mcl +mclassic +mclaurin +mclique mclosure mcls mclsax @@ -49132,37 +80416,77 @@ mclsval mcm mcmillan mcn +mcodewalker +mcol mcomb +mcombined +mcomp +mcompact +mcompat +mcompile mcomplete +mcompose +mcompute +mcon +mconfig +mcong mcongr +mconj +mconjugate +mconn mcons +mconst +mconstraint mcont mcontmn +mcontra +mcontrak mconv +mcopyv +mcount +mcounters +mcountp mcp +mcpuid mcq mcquillan +mcr +mcrun mcs mcshane +mcsn +mcsr mct +mctm mctx mctxafter mctxbefore mctxt +mctxti +mctxts mcubic +mcurrents +mcurve mdandysum mdandyv mdandyvr mdandyvrx +mdash mdata mdataexpr mdatalhs mdbr +mdc mdcompli mddmd mddmdin +mde mdecl +mdecode mdef +mdefthm +mdefun +mdefund mdeg mdegaddle mdegcl @@ -49180,6 +80504,13 @@ mdegvsca mdegvscale mdegxrcl mdegxrf +mdel +mdense +mdep +mdeposit +mdepth +mderivation +mdests mdet mdetcl mdetdiag @@ -49202,7 +80533,6 @@ mdetunilem mdexchi mdfyufrqcovlwbpq mdi -mdia mdiameter mdiff mdiffat @@ -49214,24 +80544,35 @@ mdifferentiableat mdifferentiableon mdifferentiablewithinat mdijkstra +mdilate mdinit mdist +mdiste +mdistp +mdistxx mdiv +mdl +mdo mdoc +mdom mdomain mdot mdp +mdref mds mdsl mdsldmd mdslj mdslle mdslmd +mdsmul mdss mdstate mdsym mdsymi mdsymlem +mdups +mdupsp mdvval mea meacl @@ -49252,7 +80593,9 @@ meaiuninclem meaiunle meaiunlelem meale +mealy mean +meanin meaning meaningful meaningless @@ -49279,11 +80622,14 @@ measiuns measle measm measmg +measpart measres meassle meassre measssd +meassure measu +measubable measun measunl measur @@ -49295,9 +80641,12 @@ measurable measurableadd measurableatom measurableatoms +measurablec measurableconstsmul measurablecylinders +measurabled measurablediv +measurablee measurableembe measurableembedding measurableeq @@ -49311,8 +80660,10 @@ measurableequivpiioc measurableequivrealmixedspacepolarspace measurableequivrealprod measurableequivsum +measurablefunction measurablefunctions measurablei +measurableid measurableinf measurableinv measurableinvorder @@ -49322,6 +80673,7 @@ measurablemempartition measurablemul measurableneg measurablepow +measurabler measurables measurablese measurableset @@ -49330,20 +80682,34 @@ measurablesingletonclass measurablesmul measurablesp measurablespace +measurablesubset measurablesup +measurablet +measurabletype +measurabletypee +measurabletyper +measurableu measurablevadd +measurablex measurably measurablyseparable measure +measureacc measureaux measurecaratheodory measured measuredense +measuredi measuredsets -measurefn measurei +measureic +measureil +measureir +measurement +measuren measureof measureofnegatives +measurep measurepres measurepreservin measurepreserving @@ -49357,11 +80723,13 @@ measurespace measuresupport measuret measuretheory +measureu +measureufinl +measureufinr measureunivnnreal measurezero measuring measval -measvars measvnul measvun measvuni @@ -49370,45 +80738,120 @@ measvxrge measxun meaunle meaurable +meaures +meausrable meaxrcl +meber +mechani +mechanichally +mechanics mechanisation mechanised mechanism med +<<<<<<< Updated upstream +======= medals +>>>>>>> Stashed changes +medi media medial medialmagma median +medians mediant mediate +mediati +mediating +mediation +mediator mediatrice +medium +<<<<<<< Updated upstream +======= medoc +>>>>>>> Stashed changes +medw +meeixjo +meeny meet +meeta +meetac +meetaca meetat +meetbi +meetbx +meetc +meetca meetcl +meetclosed meetcom meetcomalt +meetcx meetd meetdef +meetdistljoin meetdm meetdmss +meete +meeteset meeteu +meetf +meetfa +meetfc +meetfe +meetfku meetfval +meetg meeti +meetib +meetik +meetikc meeting +meetki +meetkic +meetkl +meetkr +meetku +meetkuc +meetl meetle meetlem +meetr meets +meetsbgex +meetsbgwopex +meetsc +meetsections meetsemilattice +meetsemilatticehom +meetsp +meetssl +<<<<<<< Updated upstream +======= meetsspatially +>>>>>>> Stashed changes +meetssr +meetsxx +meetuk +meetukc +meetul +meetur meetval +meetx +meetxb +meetxc +meetxx +megs meh +mehta meissel +meister mek -mel meld +melduniq melem +melements melems melfz mellin @@ -49416,32 +80859,60 @@ mellinconvergent mellindiff mellininv mellinioc +melo +melseq mem mema +memacc +memaddrdesc +memaddrs memaddsubgroup memaddsubmonoid memaeseqset +memafter +memarg memassign +memattrs memb membaseset +membe member memberd +membere +membered +memberequal memberfamily +memberfunc memberi membermima memberp +memberps members +membersh membership +membershipimpliesindexing memberships +membersimpl +membersp +membersspec +<<<<<<< Updated upstream +======= memberstripodcomindygalfordtriviahtm +>>>>>>> Stashed changes membersubfami membersubfamily +membertoint +memberx membpart membpartlem membparts +membytes +memc memcap memcarrier memcompat +memconst +memcopy memcp memcpaux memcpauxhdtl @@ -49450,61 +80921,147 @@ memcpauxproperok memcpauxtlok memcpconshd memcpproper +memcptossok memcpy memd memdata memdecidable +memdome meme +memelem +memeqlist +memequal +memf memfixedpoints +memgstate memholder memi +meminij +meminit meminj +meminjd +meminji meminjmu +meminjnu memintegers memisadmissible +memj +memk meml +memload +memloadbyte memlp memmap memmemcpauxok memmemcpok +memmove +memmx +memne +memnfinsupp +memnset memo memobseq memofix memofiximpl +memoi +memoiz +memoizable +memoizat +memoization +memoizationp memoize memoized +memoizep +memoizing +memop +memoptonum +memor memoread +memorie +memories +memorizing memory +memoryi +memorylayout +memorylayoutok +memorymappedextcalls +memorymappedextcallsok +memoryp +<<<<<<< Updated upstream +======= memoryproof +>>>>>>> Stashed changes memoryvalue +memorywd memosize +memotable memowrite +memoy +memp mempart mempartiti mempartitio mempartition mempartitionset +mempn +mempnc +mempos mempty +mempx memr +memread memrecon memrel memren +memrstate mems +memsem +memset +memsingle +memsizelg +memst +memstate +memstep +memstr +memswap memt memtable +memtaint +memte +memtre +memtree memtrivializationatlas +memtype memu +memupdate +memv memval memvalunchonr +memvb +memvd +memve memverismo +memvf +memvm +memvn +memvv +memvz memw +memwd +memwrite +memzero +men menc +mencapsulate +mencode +mend mendassa mendbas mendlmod mendmulr mendmulrfval mendo +mendp mendplusg mendplusgfval mendring @@ -49512,13 +81069,29 @@ mendsca mendval mendvsca mendvscafval +menelaus +menelausquadri +mensemble +ment +menter mention mentioned +mentioning +mentions +mentionsany +mentionsanyok mentries +mentry +ments +menv +meor +mep +meps meq meqd meqn meqofsep +mequal mequiv mer meran @@ -49526,27 +81099,73 @@ merco mercolem mere meredith +mereequiv merely +mereot +merg merge +mergeable mergeall +mergebinds +<<<<<<< Updated upstream +======= mergec +>>>>>>> Stashed changes +mergecode +mergecodeistypesafe merged +mergedc +mergedco +mergedcode +mergedcodeistype +mergedcodeistypesafe +mergedomain +mergedstackmapandcode +mergeevenodd +mergeforalls mergei +mergeleft +mergelist +mergelshift mergepairs +mergerec +mergereq merges +mergesequence mergesibling mergesort +mergesortby mergesortedarrays +mergesortn +mergestackmapandco +mergestackmapandcode +mergestate +mergestatessimpl +mergetail mergethese +mergetoken +mergevalue +<<<<<<< Updated upstream +mergeview +======= +>>>>>>> Stashed changes mergewith mergewithgrind mergewithgrindallowed merging +merid meridian +merids +<<<<<<< Updated upstream +merkle +merlem +======= meritage merkle merlem merlot +>>>>>>> Stashed changes +mermber mero meromo meromor @@ -49559,34 +81178,74 @@ meromorphicnfon meromorphicon meromorphicorderat meromorphictrailingcoeffat +merr mersenne mersenneprimes mertens +mertensabs mertenslem +mertenslemi +mertenslemub mes +mesf +mesfun +mesfunc mesh meshalkin +meshmessagedeliveriescap +meshmessagedeliveriesthreshold mess +messa message +messageblock messagedata +messagede +messageen +messageframesareforthesamemessage +messageframesaremonotonic +messagei +messageid messages +messageschedule +messagetest +messagetype +messageversion messing +messrs +messy +mesurable met meta +metacategory metacontext +metacyclic +metacyclicp +metacyclics metadata +metafn +metafuncti +metafunction +metafunctions metam +metamathematics +metaoperationcall +metap +metaprogram metaprogramming +metastate +metatheorems metatheory metavarcontext metavardecl metavariable metavariables metavarkind +metcall metcl metcld metcn metcnp +metcnpd metcnpi metdcn metdcnlem @@ -49609,46 +81268,108 @@ metflem metge metgt meth +methane methaus +metho method +methoda +methodaccessflags +methodb +methodc +methodchar +methodcodeattribute +methodcp +methodd +methoddefs +methode +methodensures +methodensuresarehidden +methoderror +methoderrorok +methoderrorwrong +methodf +methodg methodi methodinvk +methodm methodmain +methodn +methodname +methodonly +methodparameterpredicates +methodparameters +methodrequires +methodreturntype methods methodsi +methodspecification methodsref methodsrefpointed +methodx metideq metider metidss metidv metidval metis +metlist metn metnrm metnrmlem metopen metpsmet metr +metre metreg +metrel metres metreslem metrest +metri metric +metrical +metriccosts metrice +metrici +metricleakage +metricleakagesemantics +metriclit +metriclog +metriclogging +metricprimitives +metricprimitivessane +metricriscvmachine metrics +metricsadd +metricsemantics +metricsh +metricsl +metricsleq metricspace metricspaceaux metricspaceemetricball metricspacemax metricspacenatnat +metricspacenorm metricspaceofdiscreteuniformity metricspaceofnormedaddcommgroupofaddtorsor +metricspaces metricspacesum +metrictopology +metricweakestprecondition +metrifiable metrizable metrizablespace metrizablespacemetric +metrization +metrizes +metrizts +metro +metrspace +metrspacecart +metrstruct metrtri +mets metsp metss metsscmetcld @@ -49657,6 +81378,7 @@ mettri mettrifi metucn metuel +metuex metunif metust metustbl @@ -49671,32 +81393,70 @@ metustto metuust metuval metxmet +<<<<<<< Updated upstream +======= meuclidean meursault +>>>>>>> Stashed changes +mev meval mevent +mevery +mevl +mex mexec mexecd mexecdt mexect mexists +mexit +mexp +mexpected +mexpm +mexpr mext +mextends +mextension +mextra +mextrac +mextract mexval +meyer +<<<<<<< Updated upstream +======= mfa +>>>>>>> Stashed changes mfact +mfail mfailed +mfair mfalse -mfb mfc mfderiv mfderivfderiv mfderivtocontinuouslinearequiv mfderivwithin +mffc +mffcs mfg +mfhi +mfi +mfinal +mfind +mfirst +mfittoanything +mfittolist +mfix +mfixity +mfklvdk mfld mfldsettac +mflip +mflo mfloat +mfn mfold +mfoo mforall mformula mfot @@ -49706,10 +81466,30 @@ mfourierbasis mfouriercoeff mfourierlp mfouriersubalgebra +mfr +mframe mfrgpoyne mfs mfsdisj +mfsr +mfull +mfun +mfunb +mfuncs +mfunction +<<<<<<< Updated upstream +======= mfunctional +>>>>>>> Stashed changes +mfund +mfuneqp +mfuni +mfunm +mfunmn +mfunn +mfunp +mfunx +mfupd mfval mgalconn mgbkfqiyu @@ -49720,9 +81500,16 @@ mgcmnt mgcmntco mgcoval mgcval +mget mgf +mgflen +mgfseed mgfun mgfunc +mgg +mgive +mglobal +mglobals mgm mgmalt mgmb @@ -49746,26 +81533,50 @@ mgmplusgiopalt mgmpropd mgmsscl mgn +mgood mgp mgpbas +mgpbasg mgpds +mgpdsg +mgpex mgpf mgpplusg +mgpplusgg mgpress mgpsca +mgpscag mgpsumn mgpsumunsn mgpsumz mgptopn +mgptopng mgptset +mgptsetg mgpval +mgpvalg +mgr mgraph mgraphon +mgreq +mgrp +mgs mgt mgu +mguarded mgupaapax mgv +mgvoid +mgx +mhaeyjn +mhcor mhdrd +mheap +mhfttzn +mhint +mhk +mhlem +mhlemlem mhlfehlf mhm mhmco @@ -49775,6 +81586,7 @@ mhmcompl mhmcoply mhmcopsr mhmeql +mhmex mhmf mhmfmhm mhmhmeotmd @@ -49790,7 +81602,14 @@ mhmmulg mhmpropd mhmrcl mhmvlin +mho +mhoe +mhoeabelian +mhoj +mhole +mholee mhomp +mhos mhp mhpaddcl mhpdeg @@ -49809,11 +81628,26 @@ mhpsubg mhpval mhpvarcl mhpvscacl +mhsmall mhy +mhz mia +miaei +mibind +mic michael +micro +microcode +microcycles +microp +micropr +microrom +<<<<<<< Updated upstream +======= microsoft +>>>>>>> Stashed changes microstep +microsteps mid midarrow midbtwn @@ -49825,95 +81659,214 @@ middlebol middlebolloop middlefourexchange middlesemimedial +middlevertex +midend +mident mideu mideulem midex midexlem +midextr midf midg +midhom midid +midl +midline +midlinedef +midlinenotclockwise +midmultiset midofsegid +midopgroupcat +midopgroupobjects +midordtrapspace midp -midpnt midpoi midpoint +<<<<<<< Updated upstream +======= midpointaux +>>>>>>> Stashed changes +midpointbetween +midpointbetweencd midpoints +midpointunique +midr mids +midsp +midstr +midtape miduniq +midval midwwlks +mif +mifactor +<<<<<<< Updated upstream +might +======= miff might mighta +>>>>>>> Stashed changes +mightpointfrom +mightpointto mignotte migrate migrated +mihir +mii +miifailt miim mij +mijr +mike mil +milawa +milawaaxiom +milawatrue +milawatruefun +milawavalid +mile +miles +milestone milgram +mili milieu +milk +mill miller +milli +million +milliseconds +mills milman milner mim mima mimalloc +mimc +mimcspo +mimcsponge mimic mimicking -mimpl mimplies min +minab +minabs +minabsfun +minabsive +minabsorblmax +<<<<<<< Updated upstream +======= minal +>>>>>>> Stashed changes +minalg minarc +minassoc +minassociates minax minbadseqofbadseq +minbasis minbeta +minbigprod minbinade minblock +minbound +minbug +minbytes +minc mincardfinsetofmemconvexhull mince +minchar +mincharlemma +mincl +minclpr +mincncf mincoef +mincol +mincom +mincomm mincompatible +minconsistent +minconstrsign +mincost +mincover +mincpoly +mincpolyp mind +minded mindefault mindeg mindegree +mindel +mindelv +mindepth +mindex +mindic +mindice mindistance +mine minel +minelem +minelement minentry +mineny mineq -mineral minex minexlist +minexponentpos +miney minf minfac minfacaux minfachelper minfacprop minfi -minfp minfty minftyccb minftynrr +minfuncreal +mingbigprod +mingeb +minglb mingraphprops +mingroup +mingroupp +minh mini miniallocator +minid +minidem minidx +minifreudenthal minim minima minimal minimalaxioms minimalcover +minimalelement +minimalelementwrtincl +minimalface +minimalfiniteset minimalfor +minimality +minimalize minimally +minimalmethoddefs +minimalmmio minimalper minimalperiod minimalprime minimalprimes minimals +minimalvertex +minimalwellformedcodeunitseq +minimalz +minimax minimaxrisk minimise +minimised +minimization minimize minimizer minimizes @@ -49926,44 +81879,100 @@ minimpscore minimum minimumd minimumi +minimumisunique +minimumlogic +minimums +minimumspanningtree minimun minimunaxiomatization +minimunlanguage +minimunlogic +minimunpropositionallogic minimunsequentcalculus +minindex mining +mininst +minint +miniopt +minis +minisc +ministry minit minius +miniv +minivalence +minizinc minj +minjection +minkn +<<<<<<< Updated upstream +======= minkow +>>>>>>> Stashed changes minkowski +minkowskian minkowskibound minkowsky +minkr minl +minlemma +minlen +minlength +minlist +minloc +<<<<<<< Updated upstream +======= minlow +>>>>>>> Stashed changes +minlte +minmaj minmar minmatr minmax +minmaxn minmaxrec +minmaxset +minmodel minn minna minnac minnaca minnc minnca +minne +minnie +minnk minnn +minnormal minnp +minnr +minnrulli +minnss minnull +minnulli +minnum +minnye +mino +minoffset minofle +minone minop minoperator minoppmax minor +minorate +minorated minorder +minori minoring minorm minormax minormaxp minormaxrep +minorp +minors minp +minpair minply minplyann minplycl @@ -49979,63 +81988,132 @@ minpoly minpolyaa minpolydiv minpolygen +minpolyover +minpolys minpolyx +minpolyxx +minpos +minpred +minpredl +minpredr minr +minra +minrac minrat +minrc +minrca +minreal minregex +minrk +minrn +<<<<<<< Updated upstream +======= minroot +>>>>>>> Stashed changes minroundedmodep +minrp +minrr mins minsc minset +minsetinf minsetofcomponents minsetofcomponentslimit +minsetp minsky minsmoothness -minsol minspeed minsqfac minsqfacaux minsqfacprop +minstd +minstrn +minsub +minsuc +minsucl +minsucr mint mintensorproduct +minter +minterm +minterms +minterp minterval minti mintilist +mintime +minting mintl mintoleft mintoright mintree mintru +mintypmax +minu +minues minuniquep minus minusa +minusbv +minuscolon +minusd minuse +minuses +minusft minusi +minusindispr +minusinf +minusispr +minuslte minusltemonotone minusm +minusminus minusmod minusmodnep +minusn +minusnum minusone minusp minuspf +minusplus +minuspoint +minusposlt minuspp +minusr minusroundrep +minuss minussameexp minusset +minust minusterm +minustwo +minusul minusw minusx +minusxxx +minusy minutes +minux minv +minval minvalue minvec minveclem minveco minvecolem +minw minwait +minweightbasis +minweightbasisd +minweightbasisg +minweightbasisi +minx +miny +minye +mip +mips +miqmcsn mir -mirabelle mirauto mirbtwn mirbtwnb @@ -50062,34 +82140,70 @@ mirne mirrag mirreu mirror +mirrored mirrorimage mirrors +mirrs mirtrcgr mirval +mis +misaligned misc +miscelanea miscellaneous miscomputeddegree misctheorems misdeclarations +misellaneous +miser +miset misi mismatch +mismatched +mismatcheddomaintypes +mismatchedrangetypes mismatches +mismo +misnamed +misom +misomp +misplac +misprediction +misra miss misses +missin missing +missingcase missingend missingendlinter +missingp +missingresource +missive +missivep +missives +missivesp +missivespx +missivesy +missp +misspelled mistake mistakes +misterious mit mitchell +miter mitigate mittagleffler miv +miw mix +mixcolumn +mixcolumns mixed mixedchar mixedcharzero +mixedcomposition mixedem mixedembe mixedembedding @@ -50098,19 +82212,30 @@ mixedspace mixedspaceofrealspace mixedspacetorealmixedspace mixes -mixfix mixhash mixin mixing +mixinp mixins +mixmax mixture +mixvariantfunctor miz mizar +mizara +mjrty mka +mkaccessmap +mkadd mkaddgrouphom +mkadditive mkaddmonoidhom mkaddproof +mkae mkaftertobefore +mkageable +mkalg +mkalgauto mkalghom mkalts mkandlist @@ -50122,31 +82247,44 @@ mkappm mkappn mkappoptm mkappwithcast +mkarg +mkargz mkarr -mkarray mkarrow mkarrowiso +mkast mkatom mkatomfrom mkatomicinfo +mkautoec +mkautosim mkaux mkauxdeclname mkauxmvartype mkbank mkbeforetoafter +mkbigo mkbinop +mkblock +mkblocklist mkbot +mkbr +mkbsl mkbvar mkcache +mkcan +mkcanon mkcasesonmatch mkcast mkchannels +mkchars mkchild mkchole mkcident mkclasses mkclm mkclmtonormedspace +mkclos mkclosedsemiring mkcmdstr mkcocone @@ -50160,8 +82298,13 @@ mkcommaobject mkcommdiag mkcomp mkcomplex +mkcompspecs +mkcond +mkcondl +mkcondr mkcone mkconemorphism +mkconfig mkconfigitemviews mkcongrof mkcongrofapp @@ -50183,6 +82326,7 @@ mkcountableinstance mkcountableinstancecmds mkctorproxytype mkctype +mkcvopt mkd mkdecideproof mkdecideproofq @@ -50202,12 +82346,22 @@ mkdirpsp mkdirpss mkdiscrs mkdisjoint +mkdistr +mkdistre mkdivproof +mkdom +mkea +mkeep +mkeff +mkeithert mkembedding mkempty mkencodablecmds mkencodableinstance mkencodableinstancecmds +mkentry +mkenv +mkenviron mkeps mkeq mkeqforexpectedtype @@ -50224,6 +82378,8 @@ mkeqtrue mkequiv mkequivalence mker +mkerl +mkerr mkerror mkeval mkevalcompcons @@ -50245,11 +82401,14 @@ mkevalwhiskerrightauxcons mkevalwhiskerrightauxof mkevalwhiskerrightconsofof mkevalwhiskerrightnil +mkexists mkexistslist mkexpectedtypehint mkexprinfo mkexprmatcher +mkey mkfactororderisooffactordvdequiv +mkfactors mkfanlimit mkfilepath mkfin @@ -50258,17 +82417,21 @@ mkfinconsofle mkfinfun mkfinite mkfinitetype +mkfinpredtype mkfintype mkfintypeenum mkfirstmap mkfoldlmatcher mkfoldrmatcher +mkfollowmap mkforall mkforallfvars mkformaterror mkforwardext +mkfour mkfract mkfre +mkfresh mkfreshbindername mkfreshbindernamefortactic mkfreshexprmvar @@ -50285,12 +82448,20 @@ mkfreshtypemvar mkfreshusername mkfromsfuns mkfromsmatch +mkfset +mkfull +mkfun +mkfunction mkfunctor mkfunctorleft mkfunctorright mkfununit mkfvar mkgcd +mkgfix +mkgix +mkglobals +mkgroup mkh mkhastypebutisexpectedmsg mkhcongrwitharity @@ -50298,6 +82469,7 @@ mkheader mkheqforexpectedtype mkheqrefl mkheqtrans +mkhfs mkhigherordertype mkhole mkholeannotation @@ -50310,6 +82482,7 @@ mkhomfromsingle mkhomtosingle mkhord mki +mkid mkide mkident mkidentfrom @@ -50319,6 +82492,7 @@ mkidterminal mkif mkiffforexpectedtype mkiffofinductivepropimpl +mkilprefrm mkimpl mkimplicitbinders mkinductargnames @@ -50330,6 +82504,8 @@ mkinitial mkinitialofleftadjoint mkinitlazyentry mkinjection +mkinjections +mkinjectionsn mkinjthmmatch mkinjthms mkinputcontext @@ -50337,14 +82513,20 @@ mkinsertterm mkinst mkinstancenamefortypeexpr mkinstimplicitbinders +mkint mkinternal +mkinterp mkintlit mkintlitq mkinv mkiso mkisoself mkisoselfishomlift +mkix +mkj +mkkey mkkind +mkkripke mklabel mklabelledstar mklambda @@ -50352,6 +82534,7 @@ mklambdafvars mklambdaq mklawfuldayconvolutionmonoidalcategorystruct mklcm +mkleaf mklet mkletfvars mklevelparam @@ -50360,29 +82543,38 @@ mkliftmap mklinarithdata mkline mklinearmap +mklistset mkliteralq +mklittleo mklm +mklocal mklocaldecl mklocalruleset mklock mklr mkltzeroproof +mkm mkmap mkmapping +mkmem mkmetric +mkmetriclog mkmmem mkmonoid mkmonoidalcategorystruct mkmonoidhom mkmor +mkmsg mkmulaction mkmulhom mkmulproof mkmvar mkn mknamemap +mknapsack mknat mknatbelow +mknatded mknatiso mknatlit mknatlitq @@ -50390,6 +82582,7 @@ mknattrans mknattranscomp mknaturalityassociator mknaturalityleftunitor +mknd mknegnat mknegnnrat mknegoneltzeroproof @@ -50402,6 +82595,8 @@ mknonstrictintproof mknormedaddgrouphom mknormnumext mknot +mknt +mknullableset mknullnode mknum mknumeral @@ -50451,21 +82646,28 @@ mkofterminal mkofunitcounit mkoneinstance mkoplist +mkops mkoptconfig mkoptionalnode +mkoptiont mkor +mkord mkorderembedding +mkordinal mkorlist mkp mkpacket mkparsedprojectiondata mkparserstate +mkparsetable +mkpat mkpath mkpialgebra mkpialgebrafin mkpiring mkpoint mkpool +mkports mkpositivityext mkposreal mkpostcomp @@ -50480,23 +82682,32 @@ mkprodprf mkprodproj mkprodsplitelem mkprodtree +mkproduct +mkprogram mkprojection mkprojectmapexpr mkproof +mkprop mkproperties mkproxytype mkps mkpseudofunctor mkptrmap mkpullback +mkpureclause +mkpx mkq +mkqpos mkr mkrat mkrawintlit mkrawnatlit mkrawratlit mkrb +mkreader +mkreadert mkreal +mkrec mkrecname mkrecnames mkreconname @@ -50509,9 +82720,13 @@ mkrifycontext mkrightinverse mkringhom mkringhomofmulselfoftwonezero +mkrtest mkrw mks +mksafe mkscopedmatcher +mkseedtree +mkseedtreehelper mkselectinsertparamsinstance mkselectinsertparamsinstancehandler mkselectionpanelrpc @@ -50520,9 +82735,14 @@ mkselfiscolimit mkselfislimit mkselfprodfib mkseq +mkset +mksetcon +mksete mksetliteralq +mksetp mksfs mkshiftcoreop +mksignature mksimpcontext mksimpcontextresult mksimple @@ -50535,28 +82755,40 @@ mksort mkspansingleton mkspec mkstate +mkstatet mkstdgen mkstr +mkstream mkstringdiagram mkstrlit +mkstructural mksubproof mksubsingleton +mksubtree +mksuffixedsequence mksumeqq mksurjection +mksym +mksynlr mkt mkterm mkterminalofrightadjoint mktfaeid mkthmorunsafedef +mkti mktimet +mktoklf mktonatfuns mktonatmatch mktop mktosfuns mktosmatch mktotype +mktranslation mktraverse mktree +mktuple +mktwo mkuncurryfun mkunder mkunexpectederror @@ -50566,55 +82798,169 @@ mkunsafe mkunusedbasename mkunusedname mkusedischarger +mkv mkvarchannel mkvarchannelproc mkvmyptsghkuzrrtgwwyizj +mkvprop mkw mkwindow +mkwires +mkwo mkworld +mkwritert mkxiso mkzeromonoidhom mkzifycontext mkzmodaux +mla +mlab +mlabel +mlac +mlaconj +mlaconjo +mlaconjolem +mladd +mlalem +mlamapp +mlamz +mlang +mlaoml +mlarge +mlattice +mlb mlconvolution +mld mldir +mldr +mldual +mlduali mle +mlem +mlen mlenv +mleq +mlet mlex mlexp +mlfn +mli mliebracket mliebracketwithin +mliftm +mlim +mlinear +mlint mlist mlkem mllist +mlmap +mloa +<<<<<<< Updated upstream +======= mlocal +>>>>>>> Stashed changes +mlock +mlogically +mlok +mlookup +mloop mlower +mlp mlpath +mlprettyprinter +mlprim +mlptree +mlsexp +mlsl +mlsr mlss mlssmf +mlstring mlt +mltail mltl +mltlt +mltt +mlub mlup +mlv mlval +mlvector +mlvs mlwe +mmac mmap +mmask +mmaskdigit +mmatch +mmax +mmaxdigit +mmbe +mmc +mmchainhomotopy mmd +mmdc +mmdt +mmeet mmem +mmember mmemo +mmen +mmeta +mmethod mmin +mmindex +mmindigit +mminput +mmio +mmioextcalls +mmioextcallsok +mmioloadevent +mmiomacros +mmioread +mmiostoreevent +mmiowrite +mmk mmkahxxsfvnetmnxwzsabihfprxkcjgiwrbqbhetybvlndjuxrdb +mmlnont +mmlquery +mmm +mmmaps mmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmm mmn mmnn +mmod mmodel +mmodified +mmoeu +mmon +mmonic mmonitorable +mmono mmonom +mmore +mmoutput +mmov +mmoved +mmr +mmrp +mms +mmsnoopdatavalid +mmsnopdatavalid mmu mmul +mmulm mmult +mmultiple +mmv +mmx +mmy mnam mname +mnamep mnat +mnats mnccoe mncn mncply @@ -50679,8 +83025,12 @@ mndvass mndvcl mndvlid mndvrid +mneg +mnemonic mnet mnew +mnewe +mnext mnf mnfaddpnf mnfinite @@ -50695,11 +83045,22 @@ mnfnepnf mnfnre mnfxr mnfxrd +mnic +mnil +mnils mnj +mnm mnmn mnnnnn mno +mnop +mnorm +mnormalize +<<<<<<< Updated upstream +======= mnot +>>>>>>> Stashed changes +mnothing mnring mnringaddgd mnringbased @@ -50719,9 +83080,13 @@ mns mnsfinite mnt mntf +mnth +mnthcdr mntoval mnu mnugrud +mnull +mnum mnuop mnuprd mnuprdlem @@ -50753,14 +83118,22 @@ moantr mob mobi mobid +mobidh mobidv mobidvalt mobii +mobile +mobius +mobscure +mocc +moccf mod moda modabs modabsdifz modact +modacte +modactecond modadd modaddabs modaddb @@ -50770,30 +83143,50 @@ modaddmodlo modaddmodup modaddmulmod modal +modalabsorbstable modalb +modalbasics modalbe +modalbisjoin modalcollapse modald modaliseempty modalisenonempty +modalist modality +modallanguage modalmode +modalstable modaltypechecker +modanything +modarith +modauto +modax +modbb +modbit +modbits modbounds modbymonic modbymonichom modc modcases +modcat modcl modcld modcore modcyc modd +moddb +moddbp +moddec moddi moddiffl moddifz moddiv moddivaux +moddivmin +moddl +moddr moddvds mode model @@ -50803,21 +83196,41 @@ modelappendtautology modelassigns modelaxrep modelaxreplem +modelc modelcategory modelcategoryquillen +modelcheck +modelcheckalways +modelcheckalwayscor +modelconsistent +modele +modeled +modelement +modelementlist modelfield modelfiltertautologies modelico +modeling +modelisation modelled modellibrary +modelling modelofhascoeffs +modelohintikkap +modelohintikkapa +modelp modelpi modelpiinhabited modelprod modelprodinhabited models +modelsanity modelsboundedformula +modelsd modelsforlocalcohomology +modelsi +modelsnonemptyi +modelsp modelspace modeltheory modeltype @@ -50826,62 +83239,133 @@ modelwithcornerseuclideanhalfspace modelwithcornerseuclideanquadrant modelwithcornersprod modelwithcornersself +modem +modep modeq modeqmodmin modequality +modern modes modesd modesi +modetrans +modev +modex modexp +modexpa +modexpr +modf modfrac modfsummod +modfsummodlem +modfsummodlemstep modfsummods modfsummodslem modfzo +modg +modgacte modgcd modge +modgi +modgikl +modgikr +modgin +modgixx +modhat +modhier modi +modication modid +modidx modif modifeq +modifi +modificat modification +modificationd +modificationi +modifid +modifie modified +modifiedvars modifier modifiers modifiersstx modifies +modifiesargumenttype +modifiesclauses +modifiesconst +modifiesfresh +modifiesinternalconfig +modifiestoomuch modify modifyappargm modifyarg modifyargm +modifyarray +modifyarrays modifyat modifybase +modifybody +modifyclassfield modifyenv modifyget modifygetthe modifyhead +modifyi modifyinfostate modifying modifylast modifylocalcontext modifylocaldecl +modifylocalvariable modifymctx modifymetavardecl +modifymultidimarray +modifynothing modifynth +modifyobject +modifyobjects modifyrevarg modifyscope +modifystatement +modifystmt +modifystuff +modifysub modifytarget +modifyterm modifythe +modifythis +modind +modindbase +modindstep modinequalitylemma +modinst +modinstlist +modinstname +modinsts +modinsttable +modinsttablei +modinsttablep modint modirr +moditem +modits +modk +modl +modlem +modlist +modls modlt modlteq modltm +modlu +modluimm modm modmknepk modmkpkne modmmod +modmodidx modmonomial modmul modmuladd @@ -50891,30 +83375,109 @@ modmulconst modmulmod modmulmodr modmulnn +modmult modn modname +modnamelist +modnames +modnamespace modnat modnataddinverse +modndl +modndm +modndml +modndmr +modndr modne +modneg modnegd modnep +modnmdl +modnml +modnmm +modnmml +modnmmr +modnmr +modnn modnnsub +modnoop +modnp +modns +modnxm +modnz modobj modof modom modone modp modpart +modpath +modpc +modpe +modpl +modpn +modpon +modports +modpow +modpp +modpq +modpr modprm modprminv modprminveq modprmn +modproperty +modq +modqabs +modqadd +modqaddabs +modqaddmod +modqaddmulmod +modqcl +modqcld +modqcyc +modqdi +modqdiffl +modqdifz +modqelico +modqeqmodmin +modqexp +modqfrac +modqge +modqid +modqlt +modqltm +modqm +modqmul +modqmuladd +modqmuladdim +modqmuladdnn +modqmulmod +modqmulmodr +modqmulnn +modqnegd +modqsub +modqsubdir +modqsubmod +modqsubmodmod +modqval +modqvalp +modqvalr +modr +modrecursive modred modremain +modrm modrule modrules mods +modsc +modscope +modseq modset +modsi +modsimm +modsp modssabl modsub modsubdir @@ -50924,21 +83487,30 @@ modsubmodmod modsumcongr modsumfzodifsn modswap +modt +modth modtorsion +modty +modtype +modtypename +modtypepath modu +moduf +moduimm modul -modula modular modularcharacter modularcharacterfun modularcyclotomiccharacter modularform modularformclass +modularfunc modulargroup modularity modularlattice modulars modularscalartowers +modulated module moduleandalgebra moduleaux @@ -50967,45 +83539,88 @@ modulefilterbasis modulefinite moduleid moduleistorsionfree +moduleitem +moduleitems moduleleft +modulelevelsayseight modulelid modulelinter +modulelist modulematches +modulename modulenameoffilename modulenames +moduleof moduleofalgebramodule moduleofislocalization moduleorig +moduleover moduleovercontinuousfunctions +modulep +modulepath modulepresheafstalkiso modulepullback moduleref modules modulesnotuppercamelcase modulesosforbidden +modulespace modulespec modulesspectosheaf modulesspectosheafiso +modulestruct modulestructure modulestructurepresheaf modulesubmodule modulesuppercamelcase +modulet moduletensorequiv moduletopology moduletreeref +moduletype modulevaluedmaps +moduli modulo modulus modulusd modulusi +moduplus modus +modusponens +moduspones +moduv +modv modval modvalp modvalr +modvars +modvarssound +modvf +modw +modwrap +modx modxai modxp +modxxx modz +modzdl +modzdm +modzdml +modzdmr +modzdr modzero +modzmdl +modzml +modzmm +modzmml +modzmmr +modzmod +modzmr +modzn +modznm +modzp +modzxm +modzz moeb moebius moel @@ -51015,6 +83630,7 @@ moeub moeuex moex moexex +moexexdc moexexlem moexexv moexexvw @@ -51034,14 +83650,20 @@ moi moim moimdv moimi +moimv +moivre +mojmir mojust +molad mold +moldo mollerup mom moment momentarily momentestimates momentgeneratingfunction +momentp moments momguluhprq mon @@ -51049,17 +83671,19 @@ mona monad monadassoc monadbacktrack -monadbase monadcache monadcoherehncehom monadcont monadcontrolt +monaddelay monadenv monaderror +monadexc monadexcept monadfail monadfilemap monadfinally +monadfix monadhom monadhorizontalcomp monadic @@ -51077,22 +83701,32 @@ monadicofhaspreservesgsplitcoequalizersofreflectsisomorphisms monadicofhaspreservesreflectsgsplitcoequalizers monadicofhaspreservesreflexivecoequalizersofreflectsisomorphisms monadicrightadjoint +monadify monadinfotree monadio monadiso +monaditer +monaditerdelay monadj +monadlaws +monadlawse monadleftid monadlift monadliftoptionmetam monadliftt monadlog +monadm monadmctx monadmonequiv monadmor +monadmorphimstatet +monadmorphism monadnormalexpr monadnormalizenaturality monadoptions monadp +monadpd +monadpi monadplus monadquotation monadreader @@ -51105,6 +83739,7 @@ monadt monadtests monadtofunctor monadtomon +monadtransformer monadwhiskerleft monadwhiskerright monadwriter @@ -51114,12 +83749,19 @@ monc moncat moncatisotomulequiv moncl +mondaic +monday mone moneq monexistsl +<<<<<<< Updated upstream +======= money +>>>>>>> Stashed changes +monfuncs monfunctorcategoryequivalence monfval +mong mongeplane mongepoint mongepointvsubfacecentroidweightswithcircumcenter @@ -51127,6 +83769,7 @@ mongepointweightswithcircumcenter mongoodr mongrbar mongrbaraux +monheap monhom moni monic @@ -51135,22 +83778,43 @@ monice monicequivdegreelt monicfactorsmod monici +monicinv +monicinvisleftinv monicity monicization +monicm +monicml +monicmr +monicp monicpoly +monicpresentation monics +monicsection +monicx +monicxn +monicxsubc +monicz moninv monitor monitorable +monitored +monitorenter +monitorexit +monitoring monitors +monkey monl monlift +monlyds +monmap +monmaps monmat monmatcollpw monmoduleequivalencealgebra monmoduleequivalencealgebraforget monmonoid monmonoidal +monmor mono monoap monoaux @@ -51158,14 +83822,21 @@ monobj monobjopof monochomatic monochromatic +monochromaticfunction +monochromaticmethod +monochromaticmethodloop monochrome monoclm monocoinduct +monocoloured monocontlub monocoprod monod +monodistributive monodromy monodromyfunctor +monoe +monoensemble monoequivoffin monoevilism monof @@ -51188,13 +83859,16 @@ monoidalclosedhomequiv monoidalclosedofleftrigidcategory monoidalcoherence monoidalcomp +monoidalextension monoidalfunctor monoidalfunctorcomp monoidalgebra monoidalgebraadj +monoidalhelper monoidalisocomp monoidalleftaction monoidallinear +monoidally monoidalm monoidalnf monoidalofhasdayconvolutions @@ -51211,9 +83885,19 @@ monoidaloppositeleftaction monoidaloppositelemmas monoidaloppositerightaction monoidalpreadditive +monoidalproduct monoidalrightaction monoidalsingleobj +monoidalsubstr +monoidalsubstrex +monoidascategory +monoidauto +monoidaxioms +monoidcategory +monoidendo monoidendtoadditive +monoidequiv +monoidequivstr monoidexponent monoidhom monoidhomclass @@ -51231,22 +83915,38 @@ monoidhomo monoidhomofforallmemzpowers monoidhomofmemclosurerangecoe monoidhomoftendsto +monoidhomomorphism monoidhomslashaction monoidhomsubgroup +monoidinverseisunique +monoidiso +monoidisomorphism monoidl +monoidlistdef +monoidm monoidmonadtrans +monoidn monoidnames +monoidobject monoidof monoidofskeletalmonoidal +monoidow +monoidpath monoids monoidsmul +monoidstr +monoidstructure +monoidunivalentstr monoidwithzero monoidwithzerohom monoidwithzerohomclass +monoimal monoiskernelofcokernel monol monolem monolift +monolist +monolithic monolm monolr monom @@ -51255,11 +83955,20 @@ monomi monomial monomialonehom monomialorder +monomialp +monomialrepresentation monomials monomialsymmetric +monomio +monomiop +monomios +<<<<<<< Updated upstream +======= monomo +>>>>>>> Stashed changes monomodserre monomorp +monomorph monomorphic monomorphism monomorphisms @@ -51272,16 +83981,24 @@ monoordxr monoordxrv monoover monooverequivalenceset +monop +monopexp +monopexpr +monopoly monopoptocomon monopoptocomonobj monopoptocomonobjcomon +monopred monopushout monor monorl monos +monosub monot monotheism monothetic +monotic +monoticity monoto monotoddzz monotoddzzfi @@ -51289,6 +84006,7 @@ monoton monotone monotoneantitone monotoneaux +monotoneclass monotoneconvergence monotonecurry monotonedef @@ -51302,41 +84020,74 @@ monotonep monotoneuncurry monotoni monotonic +monotonically monotonicantitonic +monotonicchecker monotonici +monotonicities monotonicity +monotonicityh +monotonicityq +monotonicm +monotonicn +monotonicopt +monotonicp monotonicsequencelimit monotonicsequencelimitindex +monotonicty +monotonicw +monotonify monotonous monotony +monotproblem monotran monotuz +monotype monovary monovaryon monovaryorder monow +monp monply monpropd +monr mons monsect +monset +monsiheap +mont montauto +montel montelspace +montgomery +month +monthl +monthlymolad +monthsinyear montolaxmonoidal montolaxmonoidalobj montomonad montypeequivalencemon montypeequivalencemonforget montypeinhabited +monunit +moo moop moor mooran moore +moorepath +moorereachable +moorereachablecor mooreset +mooretrans +mooretranseq mop mopalgequivop mopequiv mopequivcompforgetiso mopfunctor +mophism mopick mopickr mopmatrix @@ -51347,44 +84098,116 @@ mopnfss mopni mopnin mopnm +mopnrel +mopnset mopnss mopntop mopntopon mopnuni mopnval +mopp mopre mopringequivop +mopt mor +moral morally morapplication +mord +morda +morder more +morearrays +morebadclient +morebadliterals +morebvtests +morecomplexthannecessary +moredegenerateexamples +<<<<<<< Updated upstream +moregeneral +morei +======= moref +moregeneral +morei moreis +>>>>>>> Stashed changes +morelet +moreneeded +moreops +moreov moreover +morep +moreprecise +<<<<<<< Updated upstream +======= moreq +>>>>>>> Stashed changes +morera +morereads +morerunning +morescopethings +moresingletontests +moreterms +moretests moreuptodate +morever +morewithdefaults morex +morf morgan +morgans +morgenstern morhpism +mori +morimv moriotass moritaequivalence moritaequivalencematrix +morley mormo morp morph +morphantom +morphc morphcomponents +morphi morphic morphicp morphim +morphimd +morphimdg +morphime morphimedom morphimesub +morphimf +morphimgi +morphimgk +morphimi +morphimidom +morphimig +morphimiim +morphimj +morphimk +morphimml +morphimmr morphimp +morphimr +morphims +morphimsgk +morphimsk morphimt +morphimu +morphimv +morphimy morphism +morphismclass morphismi +morphisml morphismp morphismproperty morphismpropertyhommk +morphismr morphismrestrict morphismrestricteq morphismrestrictopensrange @@ -51392,37 +84215,58 @@ morphismrestrictrestrict morphismrestrictrestrictbasicopen morphismrestrictstalkmap morphisms +morphismsi morphj +morphl morphm +morphmap +morphme morphpre +morphpred +morphpree +morphprei +morphpreidom +morphpreiim +morphprej +morphprek +morphpreml +morphpremr morphprep +morphpres +morphpresk morphpret +morphpreu +morphprev morphr morphs morphv +morphx +morr morre morrey +morse +morsetail +morsetoid +mort mortal -mortality mortheorems mortheoremsext mos -moscow -moscowlat -moscowlong -moscowname -moscownation mosn mosneq mosold mosssn most +mostek mostly +mostlyvalid mostoftenrcvd mosub mosubop mosubopt +mosubt moswap +moswapdc moswapv mot motae @@ -51434,32 +84278,83 @@ moteq motf motgrp mother +<<<<<<< Updated upstream +motions +======= motion +motions motionupward +>>>>>>> Stashed changes +motivating motivation +motivations motive motives motplusg motrag mots motv +moufang +moufangian moufangloop +mountain +mouse mousing mout mov +movbe +movdqu move +moveable moveadd +moveb moved movedby moveexcl +movei +moveinvariant +movel +moveleft +<<<<<<< Updated upstream +======= movelist +>>>>>>> Stashed changes +movement +movenext +movenexts moveopersimpctx +movep mover +moveright +<<<<<<< Updated upstream +======= movers +>>>>>>> Stashed changes moves +movestart +movesymmetry +movetoi +movewide +movewideop +movf +movi moving +<<<<<<< Updated upstream +======= movingresidence +>>>>>>> Stashed changes +movl +movq +movrelx +movrely +movsd +movzbl +movzx +mow moxfr +mozna +moznweh +mpaa mpaacl mpaadgr mpaaeu @@ -51467,8 +84362,12 @@ mpaalem mpaamn mpaaroot mpaaval +mpadd mpair +mpairp mpalt +mpam +mpaminfo mpan mpancom mpand @@ -51476,8 +84375,14 @@ mpani mpanl mpanlr mpanr +mparadox +mpartial +<<<<<<< Updated upstream +======= mpartially +>>>>>>> Stashed changes mpath +mpbeta mpbi mpbid mpbidi @@ -51487,17 +84392,23 @@ mpbiran mpbirand mpbird mpbiri +mpbirx mpc mpcl mpcoe mpcom +mpcp mpct +mpcunit mpd mpdan mpdd mpdi +mpdiff mpdouble mpeg +mpeq +mperm mpet mpets mpf @@ -51512,19 +84423,27 @@ mpfpf mpfproj mpfrcl mpfsubrg +mpfuncex +mpfuncs mpfval mpg +mpgamma mpgbi mpgbir +mpgcd mpghm mpghmlem mpgrpiso mpgs +mph mpi mpid mpidan mpie mpii +mpind +mpinterp +mpinv mpisyl mpjao mpjaod @@ -51535,16 +84454,19 @@ mplascl mplasclf mplassa mplbas +mplbascoe mplbaspropd mplbasss mplcoe mplcrng mplcrngd mplelbas +mplelbascoe mplelf mplelsfi mplem mplgrp +mplgrpfi mplind mpllmod mpllmodd @@ -51558,19 +84480,29 @@ mplmul mplmulmvr mplmulr mplneg +mplnegfi mplplusg +mplplusgg +mplprinterr mplrcl mplring mplringd mpls mplsca mplsubg +mplsubgfi +mplsubgfilemcl +mplsubgfileminv +mplsubgfilemm mplsubglem mplsubrg mplsubrgcl mplsubrglem +mpltypes mplus mplval +mplvalcoe +mplvectorprinterr mplvrpmfgalem mplvrpmga mplvrpmlem @@ -51582,7 +84514,9 @@ mply mpmf mpmhm mpmhmlem +mpmul mpnanrd +mpnump mpo mpoaddex mpoaddf @@ -51604,6 +84538,8 @@ mpoexw mpoexxg mpofrlmd mpofun +mpofvex +mpofvexi mpointer mpoly mpomatmul @@ -51618,7 +84554,10 @@ mpomulex mpomulf mpomulnzcnf mpondm +mpool mpop +mpopp +mpopscope mpos mposn mposnif @@ -51636,18 +84575,30 @@ mpoxopxprcov mpoxopynvov mpp mppi +mppm mppspst mppspstlem mppsthm mppsval +mpql mpr +mprecisely mpred +mpreds mprefix +mprev mprg mprgbir mprhm +mprimitivefun mprngiso +mpro +mproblem mprod +mprop +mproper +mpropere +mpropereneq mps mpsder mpst @@ -51675,12 +84626,14 @@ mptexd mptexf mptexg mptexgf +mptexlem mptexw mptfcl mptfi mptfnd mptfnf mptfng +mptfvex mptfvmpt mptfzshft mptiffisupp @@ -51692,8 +84645,10 @@ mptmpoopabbrdold mptmpoopabovd mptnan mptnn +mpto mptpreima mptprop +mptr mptrabex mptrcl mptrcllem @@ -51713,18 +84668,33 @@ mptsuppdifd mptun mptv mptval +mptx mptxor +<<<<<<< Updated upstream +======= mpty +>>>>>>> Stashed changes +mpu mpull mpullback mpullbackwithin +mpush +mpushpc mpv mpval +mpvlu mpwser +mpx mpxraoxjhohyxmobfevgxjcbdceytvwd +mpz +mpzero +mqueens mrange mrangerestrict +mrat +mratio mrbst +mrc mrccl mrccls mrccss @@ -51737,6 +84707,9 @@ mrcidm mrcidmd mrcls mrclsp +mrconc +mrconcnone +mrcpsp mrcrsp mrcsncl mrcss @@ -51748,13 +84721,24 @@ mrcssv mrcssvd mrcun mrcuni +mrcv mrcval +mrd +mrdeps +mrdepsmap +mrdepsource +mrdepsourcemap mre mreacs +mread mreal +mrec +mreceive mreclat mreclatbad mreclatdemobad +mrecursive +mreducible mreexd mreexdomd mreexexd @@ -51762,48 +84746,87 @@ mreexexlem mreexexlemd mreexfidimd mreexmrid +mref mrefg +<<<<<<< Updated upstream +======= mreflexive +>>>>>>> Stashed changes +mrefresh +mreg +mregex +mregs mreiincl mreincl mreintcl mrel +mrelates mrelatglb mrelatglbalt +mrelation mrelatlub mrelatlubalt +mremark +mrembind mremove mremre +mrep mrepr +mreq mreriincl mrerintcl +mreset +mresolution mress mressmrcd mresspw mrestr +mrestrict +mresult mretopd +mreturn mreuni mreunirn mreuniss +mrev +mrevappend +mrewrite mrexp mrexps mrexval +mrg mrieqv mrieqvd mrieqvlemd +mrinst mriss mrissd mrissmrcd mrissmrid mrisval mrk +mrkawarediscoverymultikeyring +mrkmatch +mrmovl +mrnonemt mroot +mror +mrq +mrr +mrris +mrs +<<<<<<< Updated upstream +mrsb +======= mrsacres +mrsb mrsbarry mrscole mrsdix mrseden mrshall +>>>>>>> Stashed changes +mrst mrsub mrsubccat mrsubcn @@ -51817,47 +84840,221 @@ mrsubrn mrsubval mrsubvr mrsubvrs +mrtabulate mrtrancl mrtrancld mru +mrule +mrun +mry +msa +msaaut +msaautcomp +msaautgroup +msaend +msaendcomp +msaendmonoid +msafree +msalg +msalgcat +msalgebra +msalimit +msaterm msb +msba msbaux msbboundnotzero +msbi msbismin +msbit +msbits msbroundlsb +msbs msbtozero msc +mscal +mscale +mscharact mscl +msclosureoperator +msclosurestr +msclosuresystem +mscng +mscongruence msd msdcn +mse +msecret msel +msem +mseq +msequivalence +<<<<<<< Updated upstream +======= mserial +>>>>>>> Stashed changes +mseries mset mseta +msetb +msetbbk +msetbd +msetbda +msetbdk +msetbdkc +msetbdl +msetbdr +msetblr +msetbs +msetbskl +msetbss +msetbxx msetd +msetda +msetdac +msetdaca +msetdba +msetdc +msetdca +msetdil +msetdir +msetdkb +msetdkbc +msetdki +msetdkic +msetdlvr +msetdp +msetds +msetdss +msetdu +msete msetext +msetfix mseti +msetia +msetiac +msetiaca +msetic +msetica +msetiid +msetiidpl +msetiidpr +msetiil +msetiir +msetik +msetikc +msetikid +msetikidc +msetin +msetip +msetis +msetiss +msetiul +msetiur +msetkdi +msetkdic +msetki +msetkic +msetkiid +msetkiidc +msetku +msetkuc +msetkuid +msetkuidc +msetm +msetme +msetn +msetne +msetnp +msetnxx +msetp msetprod +msetq msets +msetsb +msetsd +msetsi +msetsu +msetu +msetua +msetuac +msetuaca +msetuc +msetuca +msetue +msetuid +msetuidpl +msetuidpr +msetuil +msetuir +msetuk +msetukc +msetukid +msetukidc +msetulvr +msetup +msetus +msetuss +msetuul +msetuur msf +msfe +msfexfunc +msfixpoints +msfull +msfuncex +msfuncs +msfunctionset msg +msgbytes +msgcs +msgf +msgghostmultiparams +msghash msghistory +msgi +msgid +msgl +msglen msglock msglocked msglog +msgp +msgpeer +msgrcvd msgref +msgrel msgs msgse msgunlock +mshift +mshiftd mshntpppoqgzhvajpcpwvyab +mshomquot mshv mshyper +msi +msig +msign +msignature +msing +msinst msize +msj msk +mska +mskb +mskip +msmall +<<<<<<< Updated upstream +======= msmaller +>>>>>>> Stashed changes msmet msmie msn +msnat +msnorder msns msog msoggjbazwn @@ -51866,52 +85063,127 @@ msp mspace mspec mspropd +mspsp msq +msqd msqge msqgt msqi +msqm msqsqrtd msqznn msr +msrelcl +msrexistence msrf msrfn msrfo msrfval +msri msrid +msrlambdau +msrp msrrcl msrtri msrval mss +msscyc +mssetop +mssex +mssexd +mssign +msslambda +msslambdaweak +mssorts +mssub +mssubalgebra +mssuballattice +mssubfa +mssubfam +mssublat +mssubset +mssubsetfamily +mssubsort mst +mstable +mstack mstapst mstar +mstat mstate +mstatep +mstates +mstatus mstaval mstep +msteps mstfe +mstk +mstn mstopn +mstp mstps +mstr mstri +mstring msu msualg msub msubco +msubd +msubeproper msubf msubff msubffval msubfval +msubgoal +msubiset +msubm msubrn msubrsub +msubset +msubsetdl +msubseti +msubsetiidl +msubsetiidr +msubsetil +msubsetip +msubsetir +msubsetp +msubsetu +msubsetul +msubsetur msubst +msubtab msubty +msubuset +msubusetp msubval msubvrs +msuc +msucc +msuccmod +msuchthat +msucp +msuhom +msum +msunion +msuntrans +msuppe msur msurable +msv +msvars msx msxms +msym msymm +<<<<<<< Updated upstream +======= msymmetric +>>>>>>> Stashed changes +mtab +mtable mtand mtarray mtbi @@ -51921,10 +85193,16 @@ mtbir mtbird mtbiri mtch +mte mteqand +mterm mtest mtestbdd +mtf mth +mthd +mtheorem +mtheory mthmb mthmblem mthmi @@ -51933,39 +85211,81 @@ mthmsta mthmval mthr mti +mtimeout +mtimes +mtimesl +mtimesr +mtimpnotmt mtip +mtl mtmi mto mtod mtoi +mtop mtopology mtord mtowmopjcw +mtp +mtpe mtpor mtpxor mtr +mtrace +mtraded +mtrans +mtransaction mtransc -mtransitive mtranst +mtreat +mtree +mtreq +mtriple mtrue mtrunc +mtry +mtsr mtt mttm +mtv mtvalue +<<<<<<< Updated upstream +======= mtvisible +>>>>>>> Stashed changes +mtwo mtx +mty mtyf mtype mtypes +mtypetor +mua +mub +muc +mucass +muccl +muccom +mucex much +mucid mucl +mucnc mud +muddle mudivsum +mudls +muevaleqset muf +muffle mufun +mui muinv +muj +muks mul mula +mulac mulaction mulactionbasechange mulactionfilter @@ -51988,6 +85308,7 @@ muladdmodid mulalgebranorm mulandradical mulantidiagonal +mulap mularchimedean mularchimedeanclass mularchimedeanorder @@ -51996,24 +85317,38 @@ mulassd mulassi mulassnni mulassnq +mulassnqg mulassoc mulassocd mulasspi +mulasspig mulasspr +mulassprg mulasssr +mulasssrg mulaut mulautarrow mulautmulequiv mulautmultiplicative +mulauto mulauxmatblock +mulb mulbinom mulc +mulca mulcan mulcanad +mulcanap +mulcanapad +mulcanapd +mulcanapi mulcand mulcanenq +mulcanenqec mulcani mulcanpi +mulcanpig +mulcat mulchar mulcharequiv mulcl @@ -52026,12 +85361,16 @@ mulclpi mulclpr mulclprlem mulclsr +mulcmpblnq mulcmpblnr mulcmpblnrlem +mulcmpblnrlemg mulcn mulcncf mulcncff +mulcncflem mulcncfold +mulcncntop mulcnsr mulcnsrec mulcom @@ -52041,12 +85380,17 @@ mulcomli mulcomm mulcomnni mulcomnq +mulcomnqg mulcompi +mulcompig mulcompq mulcompr +mulcomprg mulcomsr +mulcomsrg mulconst mulconstreldata +mulcrfn mulcut mulcutlem mulcxp @@ -52060,10 +85404,13 @@ muldistribmu muldistribmulaction muldistribmulactionfilter muldistribmulactionset +muldiv muldivbinom muldivcancelclass muldivdid muldivdir +muldivdirap +muldivmod muldivrem muldl muldmmbl @@ -52071,7 +85418,21 @@ muldr muldvds muldysonetransform mule +mulea +muleac +muleaca +mulebl +mulebr +mulec +muleca +muledl +muledr +muleindic +mulemu +mulen mulenergy +mulenn +muleny muleqadd mulequi mulequiv @@ -52103,26 +85464,43 @@ mulequivtounithom mulequivunitssubmodulequotrange mulerpq mulerpqlem +mules muletransform muletransformleft muletransformright mulex mulexact +mulexcps mulexp mulexpd mulexpnegmulsq mulexpnegsq mulexpr mulexpz +mulexpzap +mulext mulextp +mulextsr +muley mulf +mulfi +mulfimm +mulfk +mulfs +mulfsimm mulfsum mulfunc +mulfvk +mulfx +mulfxa +mulfxc mulg +mulga mulgaddcom mulgaddcomlem mulgass mulgassr +mulgc mulgcd mulgcddvds mulgcdr @@ -52134,16 +85512,27 @@ mulgdirlem mulge mulgenerator mulgeometric +mulgex mulgfn +mulgfng mulgfval mulgfvalalt +mulgfvalg mulgfvi mulgghm +mulgi +mulgid +mulgidpl +mulgidpr mulginvcom mulginvinv +mulgir +mulgk +mulgkv mulgm mulgmhm mulgmodid +mulgmp mulgneg mulgnegneg mulgnegnn @@ -52156,14 +85545,22 @@ mulgnnp mulgnnsubcl mulgp mulgpropd +mulgpropdg mulgrhm mulgrp +mulgs +mulgsgid +mulgsid +mulgss mulgsubcl mulgsubdi mulgsubdir +mulgsubp mulgsum mulgsumlem mulgt +mulgu +mulgv mulgval mulgz mulhead @@ -52173,10 +85570,21 @@ mulhom mulhomclass mulhomofmemclosurerangecoe mulhomoftendsto +mulhs +mulhss +mulhsu +mulhu +mulhuu muli +muliap mulicn +mulid mulidnq mulidpi +mulif +mulig +mulil +mulimm mulindicator mulindicatorhom muline @@ -52187,10 +85595,22 @@ mulinvariantmeasure mulinvariantvector mulinvariantvectorfield mulinvclosurenhd +mulinverse +muliply mulir +muliscorrect mulisinitial +mulismonotonic mulispoly +mulkf +mulkg +mulkmx +mulkn +mulkp mulkr +mulkvg +mulkvmx +mulkz mull mulle mulleaddhomclass @@ -52208,34 +85628,61 @@ mulleftreflectlt mulleftright mulleftrightmatrix mulleftstrictmono +mullhs +mullhu mullid mullidd mullidi mullimc mullimcf +mullimm +mullin mullinearmap mullinearmaptomatrix +mullocpr +mullocprlem mullong mullt mulltgt mulm +mulma mulmac mulmaca mulmap mulmapleftofsupeqtop mulmarep +mulmc mulmca mulmemclass +mulminv mulmod mulmoddvds mulmonoidhom mulmonoidwithzerohom +mulmonotonic +mulmonotonicstrict +mulmr mulmulhom +mulmx +mulmxa +mulmxbl +mulmxbr +mulmxdl +mulmxdr +mulmxe +mulmxk +mulmxkpv +mulmxkv +mulmxn +mulmxne +mulmxr +mulmxv muln mulna mulnac mulnaca mulnat +mulnb mulnbl mulnbr mulnc @@ -52245,48 +85692,93 @@ mulndr mulne mulneg mulnegs +mulnk +mulnl +mulnmx +mulnn +mulnnnq +mulnq mulnqf +mulnqpr +mulnqprl +mulnqprlemfl +mulnqprlemfu +mulnqprlemrl +mulnqprlemru +mulnqpru +mulnr +mulnrn +mulnrnz +mulnrz mulns +mulnsr mulnumerator +mulnye +mulnyny +mulnyr +mulnyy +mulnz mulnzcnf mulo mulofcoalgebra mulog mulogsum mulogsumlem +mulomega mulone muloneclass mulop mulopposite +mulopsnt +mulovfl mulp mulpf +mulpg mulpiord mulpipq +mulpipqqs +mulpk mulpos mulposmono mulposreflectle mulposreflectlt mulposstric mulposstrictmono +mulpow mulpqf mulpqnq mulprm mulprod +mulproperty +mulpt +mulpz mulq +mulqa +mulqaddmodid +mulqc +mulqmod mulquot mulr mulra mulrac mulraca +mulrb +mulrbl +mulrbr +mulrbz mulrc mulrca mulrcn mulrdl mulrdr mulre +mulreap +mulrecursive +mulreim mulrelconstdata mulrephom mulresr +mulrfcte mulri mulrid mulridd @@ -52302,18 +85794,50 @@ mulrightorderiso mulrightreflectle mulrightreflectlt mulrightstrictmono +mulrin mulringnorm mulringnormclass mulringnormequivabsolutevalue mulringseminorm +mulriz mulrk +mulrl mulrn +mulrna +mulrnac +mulrnal +mulrnar +mulrnbl +mulrnbr +mulrndl +mulrndr mulrndx +mulrnn +mulrny +mulrnz mulrothnumber +mulrr +mulrrv +mulrs +mulrslid +mulrsr mulrtss mulrv mulrvk +mulrvr +mulry mulrz +mulrza +mulrzac +mulrzal +mulrzar +mulrzbl +mulrzbr +mulrzdl +mulrzdr +mulrzl +mulrzr +mulrzz muls mulsass mulsassd @@ -52330,14 +85854,25 @@ mulsemiringactionhom mulsemiringactionhomclass mulsemiringactionsemihomclass mulsemiringactiontoalgequiv +mulsepclause +mulsepclausetype mulsfn +mulsg mulsge +mulsggid +mulsgid +mulsgp mulsgt mulshift +mulsign mulsimpd mulsingle mulslid mulslidd +mulsmx +mulsmxa +mulsmxp +mulsmxs mulsn mulsne mulsnr @@ -52349,6 +85884,7 @@ mulsrid mulsridd mulsrmo mulsrpr +mulstk mulsub mulsubaddmulsub mulsubd @@ -52362,25 +85898,58 @@ mulsupport mulsval mult multa +multaa +multabs +multabscor multassociative multaux +multb +multbig +multby multc multcol multcommutative +multcomplex +multd multdistributesoverplusleft +multdiv +multdrop +multdropzmultdrop multe multeqpowincurve +multequivsnaturality +multex multexpmin multexpupperbound +multextreal +multf +multfield multfraction +multgroup +multh +multheta multi +multiapp +multiappaux +multiappend +multiarray +multiassignment +multibits +multiblock +multibucket +multibuf +multicat multichoose multicoequalizer multicoequalizerdiagram multicofork multicoforkequivsigmacofork multicoforkequivsigmacoforkofiscolimit +multicoloured multicombinations +multiconcat +multicons +multicorelicspaper multicosp multicospan multicospancomp @@ -52390,12 +85959,19 @@ multicospanmap multicospanmapiso multicospanshape multicospanshapeend +multicount multidim +multidimarray +multidimensional +multidimentional +multidrive multidual +multienv multiequalizer multiequalizerconditions multiequalizerequiv multiequalizerequivaux +multifactor multifork multiforkequivpifork multiforkequivpiforkofislimit @@ -52404,7 +85980,9 @@ multiforklift multiforkofparallelhomsequivfork multigoal multigoallinter +multigraphstruct multiind +multilast multilinea multilinear multilinearcurryleftequiv @@ -52414,21 +85992,44 @@ multilinearmap multilinearmapcongrleft multilinearmapcongrright multilinearmaptodual +multilingual multilog multilogimpl multimap +multime +multimux +multindispr multinom multinomial +multint +multinterval multipar multiparams +multiparamsmsgpartialmap +multiparamsmsgtotalmap +multiparamsnametotalmap +multiparamsnametotalmapbijective +multiparamspartialmapcongruency +multiparamstotalmapcongruency +multiparcode multipart multipartite multiparty +multiper +multipl multiple +multipleassignment +multipledimensions +multipledivides +multipleguardconjuncts +multiplelegaltransitions +multiplenestedmatch multiples multiplesaddhom multipleshom multipletopologies +multipleupdates +multiplexing multipli multipliable multipliablelocallyuniformly @@ -52436,15 +86037,23 @@ multipliablelocallyuniformlyon multipliableuniformly multipliableuniformlyon multiplica +multiplicand +multiplicar multiplicat multiplicati multiplication +multiplicationcancelmonotonic +multiplicationerrorbounded +multiplicationinvariance +multiplicationismonotonic +multiplicationlemma multiplicationlinear multiplications multiplicativ multiplicative multiplicativeadditive multiplicativeclosure +multiplicatively multiplicativeofadd multiplicities multiplicity @@ -52453,67 +86062,186 @@ multiplier multipliers multiplies multiply +multiplyaddsub +multiplyhigh multiplying +multiplylong +multiprocess +multiprocessing +multire multired +multiref +multirefp +multirefs +multirhs +multis multise +multiseq multiseries multiseriesexpansion multiset multisetadd +multisetandsequencecardinality +multisetcardinalitya +multisetcardinalityb +multisetcardinalityc +multisetcardinalityfromsequencelength +multisetemptylei +multisetforming multisetinfiniteplace +multisetlelistdiff +multisetletrans +multisetofmerge +multisetofsequence +multisetpick multisetprod +multisetproperty +multisetrank multisets +multisetsd +multisetsst multisetsum +multisettoset +multisetunion +multisetunionlemono +multisetunionlessmono +multisetupdate multispan multispanindex multispanindexcoend multispanmapiso multispanshape multispanshapecoend +multisplit +multisplitaux +multispr +multistate +multistep +multisubse +multisubset multitape +multiter +multiterabs +multiterabscor +multiterrecthm +multiterthm +multithreading +multitude multiv +multivalue +multivalues +multivar multivariable multivariate multivariategaussian +multivec +multiveclist +multivect +multivector +multivectorga +multivectorlist +multivectors +multiway +multiword +multiwordtheory +multiwrapper +multizip +multk +multkl +multkr multl +multless +multlesslistdiff +multlessremdups +multlessresolve +multlessstate multlm +multloop +multloopstr +multltemonotoneleft +multltemonotoneright +multm +multmagma multnalsofactor +multnat +multnaturality multnc +multnonzero +multo +multoneminus multonerightneutral +multop +multops multp +multpathsinunaturality multpf +multpfunc +multplace +multpliy multpos +multpred +multprog multpw multqmodn +multquaternion multr +multreal +multrealpfunc multrightsuccplus +multriple multrow +multrun mults +multsubmagma multsum multsupport +multsys multterm multterml multtermr +multthm +multtwoaux +multtwoequivaux +multtwopowerlength +multtwotildeaux multvector multw multxy multz multzero multzerorightzero +mulua +mulug mulunop +mulv mulvaluation +mulve mulvec mulvecbilin mulveclin mulvecsl +mulvf mulvfn mulvfv +mulvg +mulvkf mulvkr mulvl +mulvmx +mulvp mulvpow +mulvq mulvr +mulvu mulvval mulvz +mulx +mulxx +mulye +mulyny +mulyr +mulysys +mulyy mulz mulza mulzc @@ -52522,47 +86250,107 @@ mulzeroaddoneequivclopens mulzeroc mulzeroclass mulzerooneclass +mulzk +mulzn +mulzs +mulzv +mum +mumble mumford mumul mumullem +mun +mundane +munge +munged +mungenil +<<<<<<< Updated upstream +======= munich munichhtml +>>>>>>> Stashed changes +muniformity +munify munion +munit munitl munitr munits +munspel +<<<<<<< Updated upstream +======= muold +>>>>>>> Stashed changes mupd mupdate muplu muplus mupper +mur +mura murder mus +<<<<<<< Updated upstream +muse +muspec +must +======= muscadet +muse musicalinstrument musician muslimcountrybhumanitarianorganization muspec must +mustard +>>>>>>> Stashed changes +mustbe +mustbeautoinit +mustbenonempty mustbestr +mustsupportequality mustt +mustterminate mustusebounds musum musumsum mut +muta +mutab mutable +mutablemapcontains +mutablemapdafny +mutablemapisinjective +mutablemaptrait +mutablerepr +mutant mutate +mutateable +mutateablelist +mutating +mutatinginsert mutation mutations mutator +mutators +mute mutes mutex +mutexspec mutil mutiplicative +mutrec +mutrecaux +muts +mutspointintosameregionorimmoriso +mutspointonlyinsameregion +muttag +mutu mutual mutualdefndecl +mutuall mutually +mutuallyrecursivewithaliastype mutuallysi mutuallysingular mutuallysingularset @@ -52570,31 +86358,48 @@ mutuallysingularsetslice mutualrectermination muval mux +muxed +muxes +muxp +muxtest +muxtests +muy muzeta muzzle +mva mval mvalel -mvalid mvalue mvar mvarcounter mvarcountersaved +mvare mvari mvarid mvarids mvaridsnew mvarnew mvars +mvbar +mvbasis mvdco mvdecl mvdecls mve +mvectorp +mvfn mvfunctor mvhf mvhfval mvhval +mview +mvinverse +mvinvertible +mvjar +mvl mvlladdd mvlladdi +mvllmulapd mvllmuld mvllmuli mvlraddd @@ -52605,6 +86410,8 @@ mvmulfv mvmulfval mvmulval mvmumamul +mvn +mvnth mvp mvpf mvpfunctor @@ -52647,12 +86454,56 @@ mvth mvtinf mvtss mvtval +mvv +mwa mwb +mwd +mwdest +mwdmem +mwds mwe mweak +<<<<<<< Updated upstream +======= mweakly +>>>>>>> Stashed changes +mwhile +mwi +mwith +mwithdraw +<<<<<<< Updated upstream +======= mworld +>>>>>>> Stashed changes +mwpc +mwregwrite +mwrite +mwval +mxa +mxaddc +mxc +mxch +mxcs +mxcsr +mxcsrbit +mxcsrbits +mxd +mxdirect +mxdirecte +mxdirectegeq +mxdirectp mxe +mxed +mxedl +mxedr +mxeh +mxel +mxer +mxeu +mxeul +mxeur +mxev +mxf mxi mxidl mxidlidl @@ -52667,36 +86518,216 @@ mxidlnzrb mxidlprm mxidlprmalt mxidlval +mxj +mxjoin +mxk +mxkd +mxkdl +mxkdr +mxkl +mxkr +mxku +mxkul +mxkur +mxkv mxl +mxm +mxminpoly +mxml +mxmodule +mxmodulep +mxmr mxmsurtfgtzqosjhlmltp +mxmx +mxmxy +mxn +mxnn +mxnonsimple +mxnonsimplep +mxon +mxox +mxoxy +mxp +mxpj +mxr +mxrank +mxranke +mxrankm +mxrankmfree +mxranks +mxring mxs +mxsemisimple +mxsemisimples +mxsimple +mxsimplep +mxsk +mxsum +mxtrace +mxtraced +mxtracez +mxu +mxv +mxval +mxvald +mxvalm +mxvaln +mxvalv +mxvec +mxvece +mxveck +mxvr +mxx +mxxm +mxxmy +mxxo +mxxoy +mxxym +mxxyo +mxy +mxymx +mxyox +mxz +myall +myassignsuchthat +myassoc +myax +myb +mybag +mybool +myboolsynonym +mybutlastn +myc +mycalcfunction +mycase +mycdrn +mycielsk +mycielskian +mycielskianseq myclass +myclassp mycons +myconstructor +mycth +mydatatype mydestr mydir +myduplicate +myelem +myempty myeq +myequals myequiv +myex +myf +myfile +myfirstn +myfunc +myfunction myfunlike +mygraph +mygraphp myhill myhillnerode myhom myhomclass +myid +myif +myifs +myin +myind myindep myindepmatroid +myindex +myinstance +myinstancep +myint +myinter myinv mylemma +mylet +myli +mylift mylinter +mylist +mylval +mymapfold +mymapproperty mymatroid +mymax +mymethod +mymethodselect +mymvnth +mynames +mynat +myneighbors +mynot +<<<<<<< Updated upstream +======= myorderedcollection +>>>>>>> Stashed changes +myotherprop +myp mypart +mypath +mypkg +myplus +mypred +mypredicate +mypredicateclean myprod +myprog myprop +mypuhs +mypush +myqif +myquote +myquotep +myquotp +myreadsbad +myreadsok +myrecord +myrepeat +myrequiresbad +myrequiresok +myresultmethod +myrev myreveal +myrexp +myroute +mys +myse +myself +myset +mysing +myspec +myst +mystate +mystrec +mystring mystruct +mystud +mysublisvarandeval mysubobject +mysubset +myt +mytake +mytest +myticket +mytips +mytrait +mytt +mytype myub +myunion +myvabs +myvalid +myvoid +myvvar mzero mzlist +mznc +mznchallenge mzpadd mzpaddmpt mzpcl @@ -52731,13 +86762,20 @@ nabctnabc nabi nabl nabla +<<<<<<< Updated upstream +======= nabled +>>>>>>> Stashed changes +nabs nac nacc +nacpr +nacr nacsacs nacsfg nacsfix nact +nactuals nadd naddass naddasslem @@ -52751,36 +86789,57 @@ naddcnffn naddcnffo naddcnfid naddcom +nadde naddel naddelim naddf naddfn naddgeoa +naddi +naddia +naddib +naddl naddlid naddoa naddonnn +naddop +naddops naddov +naddr naddrid +nadds naddss naddssim naddsuc naddunif naddword naddwordnexlem +nadezhin +nadr nae naecoms naertsi naetsi naev +naeval +naevaluates naevhba +nagata nai naif naim naive +naivelyorderedbags +naivenondepfunext naivernm +nakamura +naked +nalequcoms nalexn nalfal +nalist nall +nalloc nallowed nalset nam @@ -52788,14 +86847,35 @@ name namecheck named namedarg +namedarglist +namedargs +namedb namedict namedof +namedp +namedparamvalue +namedparamvaluelist +namedscope +namedv +namefactory +namegen namegenerator namehashset +namei +namel nameless +namelist namely +namemangle namemap namemapextension +namemods +nameo +nameonly +nameoverlayparams +nameoverlayparamstotalmapcongruency +namep +namepair nameprefix nameprefixrel names @@ -52805,10 +86885,15 @@ namesp namespa namespac namespace +namespaceandname namespaces namestem +namestring namestruct +nametab +nametarget nameterm +namev naming nan nanan @@ -52817,6 +86902,10 @@ nanbi nancom nand nandalt +nandb +nandbool +nandfdecls +nandop nandp nandsym nanevski @@ -52827,24 +86916,43 @@ nannot nanor nanorxor nanoseconds +nanp +nans napoleon napp nare +narg nargs narrow narrowed +narrower narrowing narrows narry nary +naryclosure +naryfns +naryfun +naryfunc +naryfunext +naryfunextequiv +naryfuns naryfval naryfvalel naryfvalelfv naryfvalelwrdf naryfvalixp +narylevel +naryop naryrcl +naryrecclosure +naryrel +naryrest nas nash +nassignop +nastiness +nasty nat natabs natabshom @@ -52853,33 +86961,62 @@ natadd nataddemb nataddmonoid nataddorderemb +nataddsub +natage +natalgebra +natarith +nataxiomgeneralized natbelow +natbezout natbitwise natc natca natcard +natcases +natcasesaux natcast natcastle natceil natceiling +natchars +natck natcl natcoe +natcomparable +natcond natcoprime natd natde +natdecl +natdecls natded +natdedcomposition +natdedtoarrow +natdedtogentzen natdeg natdegle natdegr natdegre natdegree +natdistance natdiv +natdivides +natdivisors nate +nateff natelim natembedding natembeddingaux +natembseq natend +natepi +nateq +natequiv +natequivalencelambda natequivnatsumpunit +nateventspace +natext +natextsimpl natf natfactorization natffn @@ -52887,14 +87024,24 @@ natfib natfind natfloor natfn +natfun natfval +natgen natgeneratingsequence natgenerator natglobalincr natgt nati +natimpl +natimplbin +natind +natinf natint +<<<<<<< Updated upstream +======= nation +>>>>>>> Stashed changes +natisnatural natiso natisocomp natisofunctor @@ -52905,57 +87052,116 @@ natisoofrightadjointnatiso natisoofwhiskerleftinlinr natisosc native +nativebug +nativebv nativedecide +nativefoo +natively +nativep natives +nativetypetest natixp natk natl +natle natlem natleq natlerec +natlevel +natlib natlike natlinear natlist +natlistp natlit natlitmatcher natlocalincr natlog natlt +natmap natmaybezero natmethods +natminor natmod natmodeq natmodule +natmonoid +natmul +natmulfcte +natmulpt +natn +natnat +natnateqdec +natne +natnotation +natnseq natom natoms +natop natoppf natoppfb +natoption +natord +natoutcome natp natpair +natpart +natplus +natplusbis natpow natpowassoc +natpp natpred natprimefactors natprod natpropd +natps +natq natr +natrb natrcl +natrd +natrec +natrels +natrelstr +natrg +natrm +natrulei +natrx nats natsepdegree natset natsfrom +natshavesigmaalgebra +natshift +natsinv natsize +natslength natsmulwithzero +natsort +natsp +natstateis +natstr natsub natsubmodule +natsubset natsucc +natsum natsumnatequivnat natsumpunitequivnat +nattan +nattermtoform nattid +nattimes nattoarithmeticfunction nattobv nattoint nattoposnat +nattostring +nattoterm +nattotermlnn +nattotermlnt +nattoword nattr nattra nattrailin @@ -52964,50 +87170,99 @@ nattrans nattransapp nattranscofaninj nattranscommshift +nattranscomp +nattranscompassoc +nattranscompcompdef +nattranscompdefcod +nattranscompdefdom +nattranscompdefined +nattranscompnattrans nattransequiv +nattransext nattransextension nattransh nattranshomology nattransincostructuredarrow nattransintoforgetcompfiberwisecolimit nattransismonoidal +nattranslambda nattranslift +nattransmapsto nattransofle nattransofwhiskerleftinlinr nattransopcyclestocycles nattransp nattranspinfty +nattransplem nattransq nattranstriangleltgeofle nattranstruncgeofle nattranstruncleofle nattranstruncltofle +natty +nattypeinferencetype +natunion natunioninftyembedding +natunlifted natur natural +naturalbijection +naturalisnat +naturalisomorphism naturality naturalityproperty +naturalityt +naturalitytransformation +<<<<<<< Updated upstream +======= naturallanguage +>>>>>>> Stashed changes +naturallemma naturally +naturalp naturalparameterization naturalqtint naturals +naturalsp +naturalstosemiring naturaltransf +naturaltransfor +naturaltransformation +naturaltransformations naturaltransforms nature -natureconconlybyexistence natval +natvecmonoid natxnat +natz nav nax nba +nbads nbae nbaei +nbag nbai +nbal +nbali +nbalist +nbalistp +nball +nbar nbbn +nbbndc nbcplgr +nbcrossings +nbd +nbdc +nbdi +nbdl +nbds +nbe nbedgusgr nbeq +nbet +nbex nbfal nbfiusgrfi nbfusgrlevtxm @@ -53027,17 +87282,62 @@ nbgrval nbgrvtx nbh nbhd +nbhs +nbhsb +nbhsc +nbhsdl +nbhsdr +nbhse +nbhsl +nbhsn +nbhsne +nbhsnimage +nbhsnke +nbhsp +nbhsr +nbhst +nbhstype +nbhsx +nbhsxp +nbhsz nbi nbij +nbinopdefuniq nbior +nbisim +nbit +nbits +nbitsfix +nbl +nblbar +nblconcat nblem +nblfst +nblft +nblocks +nblpair +nblsnd +nblsr +nbltpow +nbm nbn +nbody +nbodyp nbommbcriemyhwpicyvjwslyuxvk +nboolvar nbors nbound +nbounded +nboundedc +nboundedp +nbourdist nbovbi +nbp nbr +nbrk nbrne +nbrr +nbs nbt nbuhgr nbumgr @@ -53054,51 +87354,165 @@ nbusgrfi nbusgrvtx nbusgrvtxm nbut +nbutlast +nbw +nbx +nbytes +ncaddccl +ncakemlpragma +ncaller ncanth ncar ncard ncasesprod ncasessum +ncat ncatlab +ncatop ncbxkfkcaweklvwhknqoqyxrfgwdxrjnxkwbchmekjeonm ncc +ncdisjeq +ncdisjun +ncdistinct +ncdive +ncdr +nceleq +ncelncs +ncelncsi +ncenter +nceq +nceqd +nceqi +ncex ncf +ncfcont +ncfin +ncfindi +ncfineleq +ncfineq +ncfinex +ncfinlower +ncfinlowerlem +ncfinprop +ncfinraise +ncfinraiselem +ncfinsn +ncfintfin ncheck +nchelper +nchild +nchoice +nchoicelem nchotomy +ncid +ncidg nck +nckcomp +nckeq ncl nclasses nclauses +nclec +nclecid nclem +nclen +nclenc +nclenn +nclennlem nclinit nclique +nclock +ncls ncn +ncnstrs +ncnt +ncntr +ncode ncoeff +ncol +ncolb ncolcom +ncolh +ncolim +ncoll ncollect ncolncol ncolne ncoloee +ncoloreq ncolrot ncols ncoltgdim ncom ncomlem +ncomparableleibnizeq +ncomparableusualeq ncompare +ncompile +ncompleteness +ncompops +nconc nconcur ncond nconnsubb +ncons +nconsk +nconst nconstr +nconstrargs +nconstrdecl +nconstrname +nconstructor +nconstructorname +nconstwlpo +nconstwlpolem +nconstwlpolemgt +ncont ncontents ncontmn nconverto +ncop +ncoplanar ncoprmgcdgt ncoprmgcdne ncoprmlnprm +ncorder +ncount +ncpi +ncprc +ncprod +ncprods +ncpw +ncpwpw +ncrb +ncring +ncrit +ncritt ncs +ncseqnc +ncsex +ncslemuc +ncslesuc +ncspw +ncssfin +nct +<<<<<<< Updated upstream +======= nction +>>>>>>> Stashed changes nctx +nctxt ncut +ncv +ncvg +ncvgb +ncvgc +ncvgd +ncvgm +ncvgml +ncvgmr +ncvgn +ncvgz ncvr ncvs ncvsdif @@ -53106,11 +87520,18 @@ ncvsge ncvsi ncvsm ncvspds +ncvspfin ncvspi ncvsprp +ncvsq +ncx +ncycle +ncycles ncznoslj nda +ndadde ndalt +ndat ndata ndb ndbr @@ -53123,7 +87544,10 @@ ndcnv ndcof ndcomap ndcomm +ndcompose ndconst +ndconstructor +ndcount ndcredom ndcrest ndcsb @@ -53131,10 +87555,20 @@ ndcsep ndctop ndd nddcongrarg +nde +ndecl +ndecls +ndecode +ndecr +ndecrny +ndecry ndef ndefb ndeffv +ndefinition +ndefitem ndeg +ndel ndenominators ndep ndeq @@ -53143,30 +87577,61 @@ ndeqg ndeqvd nderiv nderivable +nderivn +nderivnb +nderivnc +nderivnd +nderivnmn +nderivnmnn +nderivnmxaddc +nderivnn +nderivnxn +nderivnz nderivs +ndet +ndex +ndexg ndf ndfatafv ndfcl +ndfo ndfpropd ndfs +ndfun ndfunspec ndfval ndg +ndhc ndi +ndiff +ndiffcol ndimaxp ndinl ndinr ndinsert ndinter ndir +ndirr +ndirre +ndirrk ndisj +ndisjrelk ndispatchlemma ndist +ndistp +ndiv +ndivide ndivides ndivl +ndivlml +ndivlmr ndivr +ndivrml +ndivrmr ndj +ndk ndl +ndline ndm ndmafv ndmaov @@ -53178,6 +87643,7 @@ ndmaovg ndmaovrcl ndmbfm ndmfv +ndmfvg ndmfvrcl ndmico ndmima @@ -53192,9 +87658,15 @@ ndmovg ndmovord ndmovordi ndmovrcl +ndn +ndnotused ndnpr +ndnrm ndo +ndom +ndomain ndop +ndouble ndp ndpreima ndprf @@ -53204,15 +87676,27 @@ ndrec ndrecitermodbyregular ndrecitermodbyregularwithring ndrecwithring +ndrep ndres ndresdju ndresdjuf +ndresm ndrn +ndrop +ndrwnotin nds +ndseq ndsubsume +ndtrans +ndtype +ndtypecons +ndtypedecl +ndtypedecls +ndu ndunion nduonsmixdnoff ndval +ndvalg ndvd ndvds ndvdsadd @@ -53223,43 +87707,91 @@ ndvdssub ndx ndxarg ndxid +ndxs +ndxslid +ndz +nea +neadd neanior +neap +neapmkv +neapmkvlem +neapp near nearby +nearbyint +neare +neares nearest nearestpt nearestptind +nearesttiestoaway +nearesttiestoeven +neari nearly +nearn +nearnewman +nearp nearring nearsemiring +neart +neartop +nearw +nearzero +nearzeta neat +neatest neb +nebase +nebefore nebg nebi +nebidc nebinsert nebot nebottophomeomorphreal nebset nebsingleton nec +necc +neccesary necddla necddlp +nece +necesario necess +necessa +necessar necessarily necessary +necessitates necessitation +necessitive necessity +neck +neckla +necklace necld neclda necldp necom necomd necomi +necomp +necompl necon +necr necula +ned nedg nedgb +nedgbfi +nedge +nedgeflop +nee need +needbytes +neede needed needham needing @@ -53267,7 +87799,12 @@ needle needlessly needn needs +needsarg needsgroup +needsnonghost +needsp +needspandreturns +needspandreturnsnone neeq neeqtrd neeqtri @@ -53275,23 +87812,63 @@ neeqtrrd neeqtrri nef nefail +nefinseqlambda +nefor nefq +nefun +nefunction neg nega +negacycl negadd negaddcancel negaddy negand +negant +negantlem +negap +negapd negat negate negated +negatedbool +negatedcoletsuchthat +negatedec +negatedleqlhs +negatedletsuchthat +negatedp +negateeq +negateequiv +negatef +negatei +negateinterval +negatepath +negatepred +negates +negatesuc +negating negatio negation +negationext +negationnormalform +negationrel negations +negationsp negative +negativeencryptkeyringvector +negativel +negativelabels +negatively +negativep +<<<<<<< Updated upstream +======= negativepropertyassertion negativerealnumber +>>>>>>> Stashed changes negatives +negativetests +negativevaluetests +negativexxx negativity negb negbday @@ -53299,9 +87876,13 @@ negbdaylem negbf negbfe negbk +negblr negbne +negbranch +negbrl negbt negbte +negcase negchecks negcl negcld @@ -53321,24 +87902,31 @@ negdid negdii negdvdsb nege +negedge negel negelrp negelrpd +negempty negeq negeqd negeqi +negequiv negeu negex +negexp negexpidd negexsr negf +negfac negfcncf negfi +negfs negfunc negg neggcd neggcdnni neggoal +neggrouphom neghalfpire neghalfpirx neghygname @@ -53350,17 +87938,29 @@ negidi neginduction neginf neginfinity +negint +negiscorrect negismul negiso negl neglcm negleft negleid +neglemma negligible +negligiblei +negligiblep +negligibles +negligibleu neglimc +neglit +neglr neglt +negm negmap negmax +negmaxf +negmaxs negmemclass negmod negmullog @@ -53370,9 +87970,12 @@ negne negned negneg negnegd +negnege negnegi negnegs +negnk nego +negoffset negofnat negone negonepow @@ -53388,8 +87991,13 @@ negpitopi negpitopissre negpn negpolynomial +negpos +negpp negprops +negq +negqmod negr +negre negreal negreb negrebd @@ -53409,6 +88017,7 @@ negsfo negsid negsidd negslem +negspaceclause negsprop negsproplem negsub @@ -53418,18 +88027,41 @@ negsubdid negsubdii negsubi negsubsdi +negsuc negsucc +negsucctopred +negsucdistl +negsucdistr +negsuclnegsucmax +negsuclnegsucmin +negsuclposmax +negsuclposmin +negsucmax +negsucmin +negsucneg +negsucnegsuc +negsucnotpos +negsucrnegsucmax +negsucrnegsucmin +negsucrposmax +negsucrposmin negsunif negsup negsups negsval negsym +negtotal +negtrans +negv negy negz negze negzeroclass negzi +negzp +nehandle nehash +nehxmwh nei neibastop neibl @@ -53442,29 +88074,40 @@ neicvgnex neicvgnvo neicvgnvor neicvgrcomplex +neid neif neifg neificl neifil neiflim neifval +neig neigbourhood +neigh neighbd neighbo neighbor neighborfinset +neighborh neighborhood neighborhoods +neighborhoodsystem neighborhoodx neighborhoody +neighbori +neighboring neighbors neighborset neighborsetfintype +neighborsi +neighborsorted neighbour +neighbourhoo neighbourhood neighbourhoods neighbours neighbvtx +neighsp neii neiin neiint @@ -53474,6 +88117,7 @@ neindisj neipcfilu neipeltop neips +neipsm neiptopnei neiptopreu neiptoptop @@ -53485,7 +88129,11 @@ neiss neissex neisspw neither +neitherherenorthere neitr +neitv +neitve +neitvp neitx neiuni neival @@ -53505,9 +88153,16 @@ neldifsn neldifsnd nelelne nelelxp +nelem +nelemi +nelemp +nelems neleq neleqtrd neleqtrrd +nelesen +nelet +neletrec nelfb nelfil nelfun @@ -53518,12 +88173,17 @@ neli nelin nelini nelir +nelist +nelistop +neliteral nellinds nelmpt nelne nelneq nelocus nelocusandmaps +nelogicand +nelogicor nelop nelopab nelpr @@ -53538,16 +88198,20 @@ nelrnres nelsetpreimafv nelsn nelsngl -nelson nelss nelsubc nelsubclem nelsubgcld nelsubginvcld nelsubgsubcld +nelsuc +nelsucpw nelun +nelwr nelxp nem +nematch +nembed nemnf nemnfd nemnftgtmnft @@ -53555,33 +88219,69 @@ nemp nempty nemptyi nemtbir +nemull +nemulr +nemult +nen +nenc +nencode +nencoding +nencodingp nend neneor neneq +neneqad neneqd nenppefhhjvcpiuofucwxg +nenpw +nenv +neof neor neorian nep nepnf nepnfd nepnfltpnf +nepost +nepre neproof nepss neq +neqale +neqb +neqc neqcomd +neqconst +neqd +neqe +neqend +neqf neqif +neqispr +neqkey neqmnf +neqn neqne neqned +neqny neqo +neqopab +neqp +neqr neqreturn +neqrhs neqs +neqt +nequ +nequality nequiv neqz ner nerabdioph +nerel +neret nerode +nerr nerror nerve nerveadjunction @@ -53590,29 +88290,65 @@ nervefunctor nervefunctorcomphofunctoriso nervehomequiv nervemap +nes +neseq ness nest +neste nested +nestedalpharenaming nestedimp nestedmap +nestedmatch nestedsubalgebras nestedtraverse +nestedv +nestedvariabletest nestedwith +nester +nesterov nesting +nestings +nestingtest +nestoppers +nestp nests nesym nesymi nesymir net +neta +netap +netassign +netc +netcomp +netdecls +netdecltype +nete netentropyentourage netentropyinfentourage +neteva +neteval +netevalcomp +netevalcopm netfilter netflow +netfraenkels +netglobal netgmap +neth nethandler +netherlands +netl +netli netlift netliftl netlimit +netlimits +netlis +netlist +netlistp +netlists netmap netmask netmaxcard @@ -53622,106 +88358,220 @@ netopequivnnreal netophomeomorph netophomeomorphnnreal netopv +netord netr netree +netry nets netsdistinct netstr +nettype +nettypename +netuniv +netuple +netv +netw +netwo +networ network +networkd networks nety +netyped +netys +neu neuc +neuewhile neufal neukirch neumann +neunclosed +neural +neuralnet +neurons +neut neutl neutr neutral neutralconfig neutrald neutrali +neutrality +neutralizes +neutralleft +neutralprocess +neutralright neutralseller neutralsellervariant neutre +neutro neutru nev neval +nevaluates neven nevenaltv +nevent +nevents never +<<<<<<< Updated upstream +======= nevera +>>>>>>> Stashed changes +nevercalled +nevergethere nevermatched +neverthe nevertheless +nevervalid +neville new +newa +newacc +newactive +newaid +newalist newargs +newarray +newarrayinit +newatt +newaxiom +newb newbasic newbasis newbday newbdayim newbinding +newbit +newblocks +newboard newbody +newbooks newc +newclause newcocone +newcode newcone +newconst +newcontents newctxdecls +newdata newdate +newde newdepth newdoc +newdomain +newdstofs newe newelim newentries newentry +newenv neweqname newer newexit newf +newfan +newfcb +newfd newfields +newfn +newforalltest newfree +newfunc newfvars newgoal newgoalrel newgoals +newgraph newhead newheartbeats newhex +newhile newhs newhyps +newi +newidx newinfo +newinst +newitl +newk newkey +newl +newlabel newlast newlctx newlem +newlemma +newlength +newless newlevel newlhs newline newlines +newlinesp newlist newlit +newlits +newloc +newlocals newlockmap newly +newmain newman +newmans +newmap +newmatrix newmctxdepth +newmeasu +newmeasure +newmem newmeta +newmod +newmore +newmsgparams +newmsgparamspartialmapcongruency +newmsgparamstotalmapcongruency newmvars +newn newname newnames newnm +newnmods newno newnod newnode +newntkstate +newo +newoid +newold neword +newp +newpat +newpathcost +newpaths +newpc newpermmap +newpid newpkt +newpn newpos +newq newquery +newr newrhs newrw news +newsem newsize +newsrcofs +newss newssno newstack newstat newstate +newstatestk +newstk newstr newstx newt @@ -53729,62 +88579,161 @@ newtactic newtacticname newtail newtailprefix +newterm newtext +newtheoryname +newthmname newthread newthreadperm newthreadpermf +newtimespan newton newtonidentities newtonmap +newtravels newtrie +newtrlst newtype +newtypetest +newused +newv newval +newvals newvalue +newvalues newvar newvarname +newvars +newversionfromactivebranchkeyencryptioncontext +newvertex +newvertexlist +newvs +newword +newwords +newx +newy +newz nex nexaln +nexcdefinition +nexctype nexd nexdh nexdt nexdv nexdvt nexfal +nexist nexists +nexits nexmo nexntru +nexp +nexpirz nexple +nexpn +nexpr +nexpritem +nexpritems +nexpz nexr nexrt next nextb +nextbestedge +nextbestedges +nextbhat +nextbit nextblock +nextbpstate +nextcard nextcoeff nextcoeffup nextconts +nextd +nextdelta nextden +nextdigit +nextdmem nextdn nextdnpos +nextelem +nexteven +nextfd +nextfetch nextfixed +nextfn +nextfree nextfreeblock nextfreeblockincreases nextfreeblockinvariant +nextgate nextgen +nexti nextindex +nextinstr +nextintrp nextl +nextlemma nextloc nextm nextmax nextmem +nextminimizer +nextmpc nextnode nextnum +nexto nextor +nextp nextpattern +nextpc +nextperformopd +nextpropagate +nextpropagated +nextr +nextreachessame +nextrecvcapd +nextrecvupd +nextrecvupdd +nextreg +nextregularframe +nextrem +nextriscv nexts +nextsendupdd +nextset +nextsi +nextsp nextss +nextst +nextsta +nextstat nextstate +nextstatearm +nextstatecheri +nextstatem +nextstatemips +nextstates +nextstatex +nextstep +nextstring +nextsts +nextt +<<<<<<< Updated upstream +======= +nextto +>>>>>>> Stashed changes nextup nextuppos +nextv +nextvar +nextvertex +nextvertices +nextweekday +nextx +nexxxt +nexxxtistransitive nezer nezero nezerov @@ -53798,25 +88747,33 @@ nfae nfafv nfal nfald +nfaldold nfale nfalh nfall +nfalse nfalsum nfalt nfaltop nfalv nfan nfand +nfanold nfaov +nfas +nfb nfbelow nfbi nfbid nfbidf +nfbidold nfbidv nfbii nfbiit +nfbiold nfbr nfbrd +nfc nfccdeq nfcd nfcdeq @@ -53830,6 +88787,9 @@ nfcjust nfcnv nfco nfcoll +nfcompl +nfcon +nfcont nfcprod nfcr nfcralt @@ -53848,51 +88808,70 @@ nfcxfr nfcxfrd nfcxfrdf nfd +nfdc +nfdecl nfded nfdfat +nfdh nfdif nfdifold nfdisj +nfdisjv nfdisjw nfdju nfdm nfdt +nfdv nfe nfeel nfel nfeld +nfelim nfeq nfeqd nfeqf nfeqfb nfequid +nfequiv nfermltl nfermltlrev nfesum nfeu nfeud +nfeudv nfeudw +nfeuv nfeuw nfex nfexa nfexd nfexhe +nfexold nfext nff nffal +nffi nffn nffo nffr +nffrec nffrecs +nffrfor nffun nffv nffvd nffvmpt nfg nfgr +nfgtrans +nfgtransk nfi nfia +nfib nfich +nfielddec +nfielddecs +nfieldname nfields nfielex nfif @@ -53900,16 +88879,22 @@ nfifd nfii nfiin nfiing +nfiinxy +nfiinya nfile +nfiles nfim nfima nfimad nfimd nfimdetndef +nfimdold nfimexal nfimf +nfimold nfimt nfin +nfincst nfinf nfinold nfint @@ -53918,6 +88903,7 @@ nfiota nfiotad nfiotadw nfiotaw +nfiq nfiso nfitg nfiu @@ -53925,12 +88911,27 @@ nfiun nfiund nfiundg nfiung +nfiunxy +nfiunya nfix +nfixequiv +nfixes nfixp nfixpw +nfixpxy +nflat nfld +nfloor nflow +<<<<<<< Updated upstream +======= nflsts +>>>>>>> Stashed changes +nfm +nfmbst +nfmeq +nfmfoo +nfml nfmo nfmod nfmodv @@ -53944,6 +88945,7 @@ nfnaew nfnan nfnbi nfnd +nfndold nfne nfned nfneg @@ -53952,7 +88954,9 @@ nfnel nfneld nfnf nfnfc +nfnfold nfnid +nfnin nfnnftemp nfnot nfnt @@ -53967,9 +88971,13 @@ nfopab nfopabd nfopd nfopdalt +nfopk nfoprab nfor +nforall +nford nform +nformals nforms nformsnocontains nformsstops @@ -53983,39 +88991,56 @@ nfpo nfpr nfpred nfpw +nfq nfqkucfiholu +nfqv +nfr nfra nfrab nfrabw nfral nfrald nfraldw +nfraldxy +nfraldya nfralw +nfralxy +nfralya +nframe +nframes nfrd nfrdg nfre nfrecs +nfree nfrel nfrelp nfres nfreu nfreud +nfreudxy nfreuw nfrex nfrexd nfrexdw +nfrexdxy +nfrexdya nfrexw +nfrexya nfrgr nfri +nfrimi nfriota nfriotad nfriotadw +nfriotadxy nfrmo nfrmod nfrmow nfrn nfrom nfromc +nfront nfs nfsab nfsabg @@ -54025,8 +89050,11 @@ nfsbcd nfsbcdw nfsbcw nfsbd +nfsbt nfsbtv nfsbv +nfsbxy +nfsbxyt nfscott nfse nfseq @@ -54035,7 +89063,7 @@ nfsetrecs nfsn nfso nfss -nfssd +nfst nfsuc nfsum nfsup @@ -54047,10 +89075,12 @@ nftru nfttrcl nfttrcld nfun +nfuncdefuniq nfuni nfunid nfunidalt nfunold +nfuns nfunsn nfunsnafv nfunsnaov @@ -54058,6 +89088,7 @@ nfunv nfv nfvd nfvres +nfwd nfwe nfwlim nfwrd @@ -54071,10 +89102,10 @@ nfxnegd nfxp ngag ngamma +ngates ngba nge ngen -nges nget ngfr nghm @@ -54090,6 +89121,7 @@ nglmle ngn ngnmcncn ngnpos +ngoto ngpafjuyutfndgfuvse ngpds ngpdsr @@ -54108,14 +89140,22 @@ ngptps ngpxms ngric ngrlic +ngroups ngrp +ngs +ngstate ngt +ngtk ngtmnft ngxkhawqnxwzcovnneyo +ngy +nhalf +nhalted nhas nhaszero nhbd nhc +nhcxlrv nhd nhds nhdsadjo @@ -54144,36 +89184,71 @@ nhg nhi nhint nhip +nhm +nholinfixop nhomo nhood nhop +nhreverse +nhsr nhv nhw +nhyp +nhyps nia niabn niagreement +nibble +nibblep nic nice +nicefincwskel +nicely +nicep nicer +nicetry +nicknames nicomachus nid +nidem +nident +nie +nieco +nielim +niemytzki niex +niexpz +niff nifg nightly +nightmare nih +nihelper nii nikodym +nikodyme nikshych nil nila nilb nilbv +nilc +nilcount nild +nile nilelim +nilfamily nilfun nilgrbar +nilhs nili +nill +nills nilm +nilnil +nilnone +nilp +nilpat nilpot nilpotency nilpotencyclass @@ -54183,60 +89258,153 @@ nilpotent nilpotentalgebras nilpotentmodules nilpotentofnilpotentquotient +nilpotents +nilr nilradical nilrank nilrankaux +nilregression nilrjl nils +nilsome +nilt +niltag +nilterms niltrans +nilvector +nilvs nimkb nimn nimnbi nimni nimp +nimpl nimport nimps +nimull +nimulr nin ninba +ninc +nincludemod +nincom +nincompl nincr +nincrny +nincry +nincs nind nindepset +ninds +nindsv nine ninepointcircle +nineq +ninequarters +ninetyone +ninex +ninexg ninf +ninfinity +ninfty +ninftyn +ninftyp +ninfw nini +ninit ninj +ninjust ninni +nins ninstab +ninstr +ninstrmemsizelg +ninsts +nintegerp ninter +nintergerp +nintersection +ninth +nintp +ninv ninvolution nip +nipkow +niq nirenberg nirni +nirq +nirr +nirre nis nisfzerocomp nisi +nispr +nist +niter niters -nitetr niven nix +niz njhhd +njoin njz +nkeep +nkezbfc +nkim nla nlab +nlabel +nlabelfun +nlabels +nlambda +nlambdad +nlast +nlatches +nlbruijn +nlc nlcons +nlcvar nle +nlea +nleb nlelchi nlelshi nleltd nlem +nlemabs +nlemcau +nlemcxze +nlemf nlemmas +nlemres +nlen +nleng nlength +nleq +nleqconst +nless +nletbindings +nletdec +nletdecs +nletrecbindings +nlex +nlextendsall nlfnval +nlfree +nlfvar nlg +nlgentzeneqnatded +nlgentzentoarrow nli nlim +nlimb +nlimc +nlimd +nlime nlimon +nlimp +nlimpl nlimsuc nlimsucg nlinarith @@ -54246,12 +89414,23 @@ nlinarithgetsquareproofs nlist nlistlistlcons nlistlistrcons +nlistops +nlistp +nlistr +nlistrec nlists +nlistse nlisttodigit nlisttolist nlisttotree nlit +nliteral +nlive +nlivein +nliveset nlj +nll +nlll nlly nllyeq nllyi @@ -54265,29 +89444,53 @@ nlmlmod nlmmul nlmngp nlmnrg +nlmodel nlmtlm nlmvscn nlmvscnlem +nlna nlo +nloc +nlock nlog nlook nloop nlp +nlpextendslp +nlpextensionsimpl +nlpextensionsimpldot nlpfvineqsn +nlpgentzeneqnatded +nlpgentzentoarrow nlpineqsn nlpq +nlptonlp +nlr +nlrepr +nlsize +nlsubst nlt +nlta +nltb nltfacts nltle nltled nltmnf +nltonl nltpnft +nltpower +nltqx +nltxr +nlub +nlvwbbw nlyfqxysqyojs nmac nmaep +nmake nmap nmax nmaximum +nmb nmbdfnlb nmbdfnlbi nmbdoplb @@ -54303,6 +89506,7 @@ nmcfnlbi nmcl nmcn nmcnc +nmco nmcopex nmcopexi nmcoplb @@ -54310,8 +89514,14 @@ nmcoplbi nmcvcn nmcvfval nmdvr +nme +nmem +nmembers nmeq +nmerge nmf +nmfi +nmfilte nmfn nmfnge nmfnlb @@ -54336,14 +89546,19 @@ nmhmrcl nmhom nmin nminimal +nminus nminv nminvr +nmissing +nml +nmlg nmlno nmlnogt nmlnop nmlnopgt nmlnopne nmlnoubi +nmlz nmlzd nmmtri nmmul @@ -54351,13 +89566,27 @@ nmmulg nmnd nmndlem nmne +nmnfgt +nmns nmo nmobndi nmobndseqi nmobndseqialt nmocl nmoco +nmod +nmodexpr nmods +nmodtype +nmodtypename +nmodtypepath +nmoduledef +nmoduleitem +nmoduleitems +nmodulename +nmodulepath +nmoduletype +nmoduletypedef nmoeq nmof nmoffn @@ -54416,22 +89645,53 @@ nmounbseqi nmounbseqialt nmoval nmoxr +nmp nmpar nmparlem +nmpcharn +nmprm nmpropd +nmr +nmrdnm +nmreq +nmrgt +nmrlt nmrpcl +nmrq nmrtri nms +nmseparation +nmseq +<<<<<<< Updated upstream +======= nmsg +>>>>>>> Stashed changes nmsort nmsq nmsub +nmt +nmtcharn +nmteqset nmtri +nmttail nmul +nmule +nmull +nmuln +nmulr +nmulrn +nmulrz nmult +nmulta +nmultb +nmultop +nmultops +nmulz nmust +nmv nmval nmvs +nmx nmzbi nmznsg nmzsubg @@ -54451,14 +89711,21 @@ nnaddcomli nnadddir nnaddm nnaddscl +nnadjoin +nnadjoinlem +nnadjoinpw nnadju nnadjualt +nnal nnalt nnamecl +nnan +nnanq nnaord nnaordex nnaordi nnaordr +nnap nnarcl nnasmo nnasuc @@ -54469,23 +89736,38 @@ nnawordexg nnawordi nnb nnbi +nnbidc +nnbist nnbound nnc +nncaddccl nncan nncand nncansd +nncdiv +nnceleq +nncex nnclav nnclavc nnclavci nnclavi +nnclavius nncn nncnd nncni nncomi +nncs nnct nnd +nndc +nndcalt +nndcel +nndceq nndi nndiffz +nndifsnid +nndir +nndisjeq nndist nndiv nndivcl @@ -54503,10 +89785,18 @@ nndvdslegcd nne nnecke nnecl +nnedc nneg +nnegd +nnegi +nnegre +nnegreal nnehalf nnei nnel +nnelirr +nnelon +nnen nneneq nnennex nnennexaltv @@ -54517,14 +89807,19 @@ nneob nneoi nneoialtv nneom +nneoor nneop nneq nner +nneseries +nneseriesd +nneserieszl nnesq nnesuc nneven nnex nnexalt +nnexmid nnexpcl nnexpcld nnexpscl @@ -54540,6 +89835,7 @@ nnfbi nnfbid nnfbii nnfbit +nnfc nnfe nnfea nnfead @@ -54547,6 +89843,7 @@ nnfeai nnfed nnfei nnfext +nnffalse nnfi nnfim nnfimd @@ -54555,6 +89852,7 @@ nnflemaa nnflemae nnflemea nnflemee +nnflit nnfnftemp nnfnt nnfnth @@ -54563,22 +89861,75 @@ nnfoctbdj nnfoctbdjlem nnfor nnford +nnfp nnfth nnftht nnftopropf +nnftrue +nnfun nnfv +nng nnge +nngnum nngt +nnhelp nnholdernorm nnhsotevnoopikqshcwuf nni +nnid nnil +nnim nnind nnindalt nnindd nnindf +nnindnn nninf +nninfall +nninfalllem +nninfct +nninfctlemfo +nninfdc +nninfdcex +nninfdcinf +nninfdclemcl +nninfdclemf +nninfdclemlt +nninfdclemp +nninfex +nninff +nninffeq +nninfinf +nninfinfwlpo +nninfinfwlpolem +nninfisol +nninfisollem +nninfisollemeq +nninfisollemne +nninfnfiinf +nninfninc nninfnub +nninfomni +nninfomnilem +nninfsel +nninfself +nninfsellemcl +nninfsellemdc +nninfsellemeq +nninfsellemeqinf +nninfsellemqall +nninfsellemsuc +nninfwlpo +nninfwlpoim +nninfwlpoimlemdc +nninfwlpoimlemg +nninfwlpoimlemginf +nninfwlpor +nninfwlporlem +nninfwlporlemd +nnintegral +nnip +nniq nnl nnle nnledivrp @@ -54596,6 +89947,8 @@ nnmcan nnmcl nnmcli nnmcom +nnmindc +nnminle nnmord nnmordi nnmsuc @@ -54613,6 +89966,7 @@ nnmwordi nnmwordri nnn nnnalt +nnnc nnncan nnncand nnne @@ -54623,6 +89977,10 @@ nnnfi nnnle nnnlt nnnn +nnnninf +nnnninfen +nnnninfeq +nnnninfex nnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnn nnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnn nnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnn @@ -54631,29 +89989,48 @@ nnnod nnnorm nnnormhom nnnormprojbound +nnnotnotr +nnnq nno nnoaltv nnoddm nnoddn +nnode +nnodes nnoeomeqom nnolog nnon +nnone +nnonetopleveldecs nnoni nnonzero +nnor nnord nnorm +nnorml nnormmimltvnum nnormmin nnormpos +nnormr +nnot nnp nnpcan +nnplusnotneeded nnpos nnpp +nnppipi +nnpredcl +nnpredlt +nnprlu nnproddivdvdsd +nnpt nnpw +nnpweq +nnpweqlem nnq nnqsmul nnr +nnral nnrat nnratarm nnratcast @@ -54672,6 +90049,7 @@ nnrecre nnrecred nnrecrp nnred +nnregexmid nnrei nnrisefaccl nnrmmimlevnum @@ -54683,7 +90061,13 @@ nnsdom nnsdomel nnsdomg nnsdomo +nnseries nnsex +nnsf +nnsfun +nnsfune +nnsfunl +nnsfunr nnsge nnsgrp nnsgrpmgm @@ -54691,33 +90075,60 @@ nnsgrpnmnd nnsgt nnsind nnsinds +nnsn nnsplit nnsqcl nnsqcld nnsrecgt nnsscn +nnsseleq nnssi nnssn +nnssnc nnssnn nnssno nnssq nnssre +nnsssuc nnssz +nnst nnsub nnsubi nnsuc +nnsucelr +nnsucelrlem +nnsucelsuc +nnsucpred +nnsucsssuc +nnsucuniel nnsum +nntccl +nnti +nntopi nntr +nntrans +nntranslate +nntri nnubfi +nnul +nnulb +nnuli +nnull nnullss nnunb nnuni nnunifi nnuz nnuzdisj +nnv +nnw +nnwetri nnwo +nnwodc nnwof +nnwofdc nnwos +nnwosdc nnx nnxr nnxrd @@ -54732,30 +90143,74 @@ nnzsd nnzsubs noa noabt +noacc +noaccess noaccidental noaccpts +noacssideeffects noaction +noaertsi +noaetli +noaetsi +noalias +noaliasr +noalloc +noand noanno noarg noassn +noat noatoms noattr +noatts noaugpath nobdaymin nobeling nobelingproof +nobias nobigger +nobinover +nobjf +noblk +nobody noborder +noboru nobot +noboth nobotor nobotorder nobotordersentence +nobound +nobounddown +nobounds +noboundup +nobranch +nobranchkripkeintuitionisticmodel nobrk noc +nocall +nocallsp +nocarry +nocc +noccon +nochange +nochangeandcorrect +nochangewhazzoeva +nocheck +nocoder nocollision +nocomment +nocomments +noconcl noconfusion noconfusiontype +noconstants +nocontinue +nocontr +nocp +nocrb nocross +nocut nocvxmin nocvxminlem nod @@ -54766,26 +90221,72 @@ nodd noddaltv node nodeabs +nodearr +nodecay +nodecount +nodecut +nodecuts noded +nodeg +nodeguard +nodeh +nodehd nodei +nodeid +nodeinfo +nodelabel +nodelabelaa +nodelabelgba +nodelis +nodelist +nodelistguard +noden nodense nodenselem +nodent +nodenu +nodenum +nodenump +nodenums +nodenumsp nodeof +nodep noderep nodes nodesaux +nodesdb nodeset nodesetbackward nodesetforward +nodesetgen +nodesetgene +nodesetgenerator +nodesetp +nodesi +nodesl nodesleft +nodeslist +nodesp nodesright +nodet +nodetable +nodetl nodetodigit nodetolist +nodetop +nodevalid nodewithantiquot nodiag +nodic +nodisj nodivover +nodivzero nodmon nodmord +nodoubles +nodowncast +nodowncastfun +nodq nodsourcenosource nodu nodup @@ -54793,41 +90294,96 @@ nodupa nodupdecidable nodupk nodupkeys +nodupl +noduplicates +nodupok +nodups +noe noeacs +noedge noel +noelementsprecedesfirstelement +<<<<<<< Updated upstream +======= noeltsimpempty +>>>>>>> Stashed changes +noempty +noends +noensuresplease +noeq +noerrors noerrorsfound +noet noeta noetainflem noetalem noetasuplem noether +noetherhomunique noetherian +noetherianity +noetherianness noetherianspace +noetherisomorphism +noetherisounique noethernormalization +noexception +noexec +noexn +noexpectedfailure noextend noextenddif noextendgt noextendlt noextendseq +noextract nof nofail nofaili nofailt nofailure +nofal +noff nofi +nofinitesetcontainsallprimes +nofinz +nofix +nofixes +nofixpoints nofnbday -nofp noftlobserver nofun +nofunc +nofunext +nofunp nofv +nogap nogen nogesgn +nogets +nogetsf +noghost nogroup +nogrow nogt nohalf +nohash +nohead +nohintproof +noids +noifs +noimp +noimpand +noimpfalse noimpl +noimplit +noimpnot +noimpor +noimptrue noin +noincr +noincrease +noindent noindex noinds noinfbday @@ -54842,38 +90398,73 @@ noinfluence noinfno noinfprefixmo noinfres +noinit +noinline +noinlinet noinnerproduct +noinst +nointerrupt noinvtick +<<<<<<< Updated upstream +======= noise +>>>>>>> Stashed changes +nok +nolabel +nolater +nolb +noleft nolesgn +nolhs nolint nolints +noll +noload noloc +nolocals +noloop +noloopinitp noloops nolowdps nolt +nolub nom nomacobjchange nomacsubchange +nomasks nomatch +nomatchd nomatchempty nomax nomaxmo nomaxorder +nomb +nombres +nombrezerodroite +nomcon nome +nomem nomember +nomenclature +nomiddle nominal nominally +nominimal nominmo nominorder nominpos +nomove nomsg +nomunify nomv non nonabelian nonabort nonaborting +nonabs +nonadaptive nonagent +nonaliasing nonarch nonarchabsval nonarchaddgroupnormclass @@ -54891,18 +90482,42 @@ nonassociativering nonassocring nonassocsemiring nonassocstarsemiring +nonat +nonato +nonatom nonatomic +nonautoinit +nonautoinitf nonb +nonbeta +nonblack +nonblk +nonblkst +nonblocking +nonboolean nonbooli nonbossy +nonbot +nonbranching +nonbuiltin +nonbv +nonbvg nonc +noncall noncanonically +noncases nonce +noncef noncenter nonces nonch +nonclass +nonclassical nonco +noncoherent +noncollinear noncolr +noncomb noncomm noncommcoprod noncommfold @@ -54914,15 +90529,34 @@ noncommutative noncomp noncompact noncompactspace +noncompilablefunction noncomputab noncomputability noncomputable noncomputabledefs noncomputably nonconfluence +nonconform +nonconformin nonconne +nonconsecutive +nonconsp +nonconst +nonconstant noncontinuous +noncontractibility +noncontractible +nonconvex +noncoplanar noncoprime +noncopymatches +noncovar +noncycle +nond +nondata +nondec +nondecr +nondecrease nondecreasing nondefaults nondeg @@ -54932,22 +90566,40 @@ nondegeneracy nondegenerate nondegenerateequiv nondegenerateequivofiso +nondelay +nondelayed +nondense nondep nondependent +nondependentbind nondependentonly nondet +nondetassign nondeterminism +nondeterministic nondeterministicd +nondetif +nondets nondett nondiag nondiff nondifferentiable +nondigit +nondirtycache +nondiv +nondivisible +nondivisor +nondl +nondr none noned nonedecidable +nonedge nonee +noneedforexists noneg nonegative +noneholds nonei nonelalab nonelem @@ -54956,136 +90608,312 @@ nonem nonemojis nonemp nonempt +nonemptiness nonempty +nonemptycell nonemptychain nonemptycompacts nonemptyd nonemptydiffeomorphsphere nonemptye +nonemptyfinite +nonemptyfinitex nonemptyfinlinord nonemptyfinlinorddualcompforgettofinpartord nonemptygcdmonoid nonemptyi -nonemptyimpwitness nonemptyinterval nonemptylimit +nonemptymap +nonemptyn nonemptyparallelpairpresentationaux +nonemptypn +<<<<<<< Updated upstream +nonemptyseq +======= +>>>>>>> Stashed changes nonemptyset +nonemptystack nonemptytheory +nonemptytree +nonemptyy +nonep nonepty +noneq +nonequal +nonequalitysetofsets +noner +nonerasing nonergodic +nones +nonetheles +nonetopleveldecs +noneuclidean nonevent +nonew nonex +nonexample +nonexec +nonexist +nonexistant nonexistent +nonexpanding +nonexpansive +nonextendedprintexpr +nonf nonfin nonfinal nonfinals +nonfinitely +nonfix nonforces +nonfree nonfull +nonfulltree +nonfunctional +nonfv +nongen nongenerating +nonghost +nonghostf +nonghostmethod +nonghostpredicate +nonheader +<<<<<<< Updated upstream +======= nonhomocentric nonhuman +>>>>>>> Stashed changes +nonhypergraph +nonhyps +nonid nonidentity +nonidentityfactory +nonidentitytoken +nonil +nonim +noninc +nonincreases nonincreasing +noninf +noninferredtype noninit noninitblks +noninits +noninitstate +noninitstatealph +noninjective +noninput nonint nonintdfmla +noninteger +nonintegertoint noninterference noninterferencei noninterferenceintra nonints nonintsfmla nonintsi +noninvertible +nonkeyattributename +nonkeyattributenamelist +nonkeys nonks +nonlambda +nonleaf +nonlem +nonless nonlift +nonlimit +nonlimitp nonlindelof nonlindelofspace nonlinear +nonlinearp nonlinearrightinverse nonlinearrightinverseofsurjective nonlinearverismo +nonlnil nonlocal +nonlock +nonlockat +nonlooplabels nonmanip nonmaximal +nonmem nonmember +nonmembers nonmembersubfamily +nonmonadic +nonmonomorphism +nonmonotonic nonn +nonnbr nonne nonneg nonnegat +nonnegati +nonnegativ nonnegative +nonnegativelongobject nonnegativepart +nonnegatives +nonnegativexxx nonnegativity +nonnegd +nonnege +nonnegelements +nonnegep +nonnegfirstprices nonnegg nonneghomclass nonnegi nonnegligible +nonnegp nonnegprices +nonnegreal nonnegs nonnegspectrumcla nonnegspectrumclass nonnil +nonnils +nonnt nonnull +<<<<<<< Updated upstream +nonnullarray +nonnumeric +nonodeprocessedtwice +nonogram +======= +nonnumeric +nonodeprocessedtwice +>>>>>>> Stashed changes +nonorigin nonote +nonov nonoverlap +nonoverlapping +nonoverride +nonownedobj +nonownedobject +nonpair +nonparallel +nonparam nonpart +nonperfect +nonplanar nonpos +nonposclause nonpositive +nonpositivexxx nonpositivity nonpospart nonpower nonpreadditiveabelian +nonpresheaf +nonpresheafcategory nonprime nonprimitive nonprincipal nonprincipalinvertleft nonprincipalinvertright nonprincipals +nonproductive nonprophaves +nonproptype +nonrandom +nonreachable nonreadable +nonrealci nonrec +nonrecstmt +nonrect +nonrecursive +nonredexe +nonreduced nonref +nonreferenceequality nonrefl +nonreflex nonreflexive nonregular nonrel +nonrep nonreservedsymbol +nonresidue +nonrootp +nonrootstep +nonrootstepeq +nons nonsat nonsatiation nonscopednorlocal nonsense +nonsensical nonseparated +nonseparation +nonsetedge +nonshareable +nonsimple nonsin nonsing nonsinginvunit +nonsingle nonsingular nonsingularlift nonsingularpointequiv nonsingularpointequivsubtype nonsmall nonspanning +nonsparse nonsplit +nonsplitempseparationlogic nonspray nonsq nonsquare +nonstack +nonstan nonstandard nonstatic +nonstd +nonstobj +nonstop nonstrict +nonsubandupdate +nonsubset +nonsumandupdate +nonsurjective nonsym +nonsymbol +nonsymmetricmetricspace nont +nontag +nontagi +nontagidx +nontagidxlist +nontaut +nontautologous nonterm nonterminal +nonterminalalph +nonterminals +nonterminating nontermination +nontest +nontip +nontolerance nontop nontorsionweight nontr nontri nontriv +nontrival nontrivia nontrivial +nontrivialbs nontrivialcommring nontrivialdecomposition +nontrivialfinite nontriviality nontrivialitybyassumption nontrivialitybyelim @@ -55098,6 +90926,7 @@ nontriviallynormedfield nontriviallynormedspace nontriviallyseminormed nontrivialpsumunique +nontrivialring nontrivialsemiring nontrivialstar nontrivialtopology @@ -55105,6 +90934,14 @@ nonuniform nonuniforms nonuniformwitness nonuniformwitnesses +nonuniqboundfuncex +nonuniqexd +nonuniqfuncdex +nonuniqfuncex +nonuniqmsfunctionex +nonuniqpifinrecexd +nonuniqseqex +nonunique nonunit nonunital nonunitalalg @@ -55166,36 +91003,81 @@ nonunitalsubsemiringmap nonunits nonunitsorderembedding nonvanishing +nonvariant +nonvoid +nonvoidty +nonvolatile +nonvolatileversion +nonwf +nonwff +nonwitness nonword nonz +nonzcrb nonze nonzeno nonzer nonzero nonzerod +nonzerodiv nonzerodivisor nonzerodivisors nonzerodivisorsequivunits nonzerodivisorsleft nonzerodivisorsright nonzeroequivprojectivizationprodunits +nonzeroi nonzeroindex +nonzeroinv +nonzerolist +nonzeromult nonzeron nonzeroness +nonzeroornot nonzerop +nonzerorealsaremultiplicativeabeliangroup +nonzerorealsaremultiplicativegroup nonzeros nonzerosemiring nonzerosmuldivisors nonzerosubmul +noonelivesforever noop +nooperation noorder noout +nooutput +nooverflow nop +noparam +noparame +noparse +nopath +nopc +nope +nopen +nopenmod +noperatorname +noperm noph +nophysicalequalityonsequences +nopid +noplen +nopoint +noposn noposoycle +nopower noprc +nopred +noprivate +noproof nopt +noptionalsignatureascription +nopttypeqn +noqif nor +norace +noramlize noran norass norasslem @@ -55211,40 +91093,80 @@ norecdiv noreceuw norecfn norecov +noreduct +noreferences +noreferencesplease +norep +norepeat +norepeats norepet +norepetion +norepetition +noreplace noreps noreq noresle noreson norest +noret +noreturn +norevealnotok +norformulasof +norfunctor +norho +noright +noriterator norm norma normaddgroupnorm normaddgroupseminorm normal +normalaction normalandsubnormalnoteq normalautequivquotient +normalaxiomatization normalbasis +normalbinderlanguage normalclosur normalclosure normalclosureoperator normalcore +normald normalepi normalepicategory normalepiofepi normalepiofnormalmonounop +normales normalexpr +normalfield +normalfieldf +normalfieldp +normalfields +normalfilter +normalfilters normalform +normalformcofibfun normalformsp +normalg +normalgi normali +normalis +normalisatio normalisation normalise normalised normalisedd +normaliser +normalises normalising normality normaliz normalizability +normalizable +normalizaci +normalizacion +normalizado +normalizados normalization normalizationcoprodiso normalizationdesc @@ -55276,6 +91198,7 @@ normalizedgcdmonoidofgcd normalizedgcdmonoidoflcm normalizedhom normalizedmoorecomplex +normalizedp normalizedtrace normalizedtraceaux normalizeequiv @@ -55286,14 +91209,19 @@ normalizeisoaux normalizeisocomp normalizemapaux normalizeobj +normalizep normalizepretty normalizer normalizercondition normalizering normalizermonoidhom +normalizes normalizeunitiso normalizing +normalj +normallanguage normally +normalm normalmodel normalmono normalmonocategory @@ -55305,20 +91233,38 @@ normalofispullbackfstofnormal normalofispullbacksndofnormal normalofispushoutfstofnormal normalofispushoutsndofnormal +normalorzero +normalp +normalprooftheory +normals normalsequentcalculus +normalsg normalspace +normalsubgroup +normalsubgroupprop normaltower +normaltranslatedvalue +normalvalue normalword +normaly +normalyl +normalyr normatallplaces normatcomplexplaces normatplace +normball normbarenumeral normbound +normc normcan normcast +normci +normckc normcl normcli normcomp +normconv +normcs normcv normd norme @@ -55355,7 +91301,12 @@ normedlatticeaddcommgroup normedlatticefield normedlinearorderedfield normedmk +normedmodtype +normedmodule +normedmoduleaux normedorderedgroup +normedp +normedr normedring normeds normedsp @@ -55371,11 +91322,21 @@ normedspacestructure normedspacetangentspacevectorspace normedsrec normedstargroup +normedti +normedzmodtype normf normfn +normform +normforms normfrombounded normfromconst +normfv +normg normge +normgi +normgie +normgim +normgix normgroupnorm normgroupseminorm normgt @@ -55385,12 +91346,22 @@ normhomcompsub normi normif normintnumeral +normize +normj +normk norml +normlaize normleiff normlem normleone +normlize +normlp +normm +normmal +normmn normmonoidhom normmulclass +normn normnattrans normne normneg @@ -55405,43 +91376,93 @@ normoneclas normoneclass normop normopold +normorde +normorder +normordered +normorderedp +normp normpar normpari +normpolynomial normpow normpyc normpyth normpythi normq normr +normratf +normratio +normrationalfunction +normre +normresg +normresign normringnorm normringseminorm +normrm +normrmn +normrmsign +normrmz normrn +normrv +normrx norms +normsd normseminorm +normsequence +normsg +normsgi +normsi +normsig +normsis +normsl +normsm normsmulclass normsmulclassseminormedaddcommgrouptopi normsmulclassseminormedaddcommgrouptoprod +normsp +normspace normsq normsqf normsqi +normsr +normsrl +normsrr +normstar +normstr +normstrchar +normstrcharnil normstx +normsu normsub normsubi +normsy +normt normthreshold normun normunit +normv normval +normwhnf normz normzm norn +nornal nornot noroot +norop noroplus noror norp +nort north northcott +norths +norun +norwegian +nos nose +noseasonal +nosec nosep nosepdm nosepdmlem @@ -55459,6 +91480,7 @@ noseqind noseqinds noseqiso noseqlt +noseqm noseqno noseqoi noseqp @@ -55469,13 +91491,27 @@ noseqrdgsuc noseqssno noseqsuc nosgnn +nosignedover nosimp nosimpl +noskip +nosl nosmallestcounterexample +nosolution +nosp nospacer +nospec +nospoofing +nosquare +nostack nostate nostatechange nostatediff +nostep +nostore +nostutter +nosucc +nosuggestion nosupbday nosupbnd nosupcbv @@ -55485,6 +91521,7 @@ nosupinfsep nosupno nosupprefixmo nosupres +nosyntaxp not nota notab @@ -55493,55 +91530,149 @@ notably notabw notafter notalbii +notallloops notaninput +notany +notap +notareader +notassoc +notatheorem +notati notation notational notationclassattr notationextra notations notatnand +notazero +notb +notbased notbdd notbefore +notbelow notbi notbicom notbid notbii notbinot +notbnf +notbool +notboolsize +notbot +notboundedforall +notc +notci notclass +notclockwiseaab +notclockwiseaba +notclockwisebaa +notclockwisetwocases notclxf notcol +notcollinear +notcollinearbetweendistinct +notcollinearbetweennotcollinear +notcollineardistinctab +notcollineardistinctbc +notcollineardistinctca +notcolnotegal notcomparable +notcon notconvergentseq notconvergentseqltindex +notcoplanar +notcutfree notd +<<<<<<< Updated upstream +notdec +notdef +notdefeq +======= notdalle +notdec +notdef notdefeq notdexe +>>>>>>> Stashed changes +notdftk +notdisjoint +notdiv +notdivides notdividesdigit +notdom notdsource note noted noteeexists notelem +notemp notempty +notemptye +notemptyfinestpart notemptyi +notemptypopulated +notenough +notenoughspace noteq +noteqa noteqlt +noteqnotzero +noteqr noteqs noteqtr notequal +<<<<<<< Updated upstream +======= notequali +>>>>>>> Stashed changes +notequidirecteddistinctab +notequidirecteddistinctcd +notequiv notes +notevald notevalmodel +notevaluated notevcontainsbothatoms +noteven +notevenbin +notevery +notex notexists +notexotic +notextremal notf +notfail notfal +notfe notfin +notfinished notfollowedby +notforall notforces +notfound +notfounderror +notfourbetween +notfree +notg notgfn +notghostvariantdiscriminator +notghostvariantequality +notgt +noth +nothere +notherian +notherianity +nothin nothing +<<<<<<< Updated upstream +nothingabsurd +======= +>>>>>>> Stashed changes +nothingchanged +nothinghere +nothingtotal +nothingtotriggeron +nothrow noti notice noticeably @@ -55549,134 +91680,341 @@ noticed notimeout notin notinarraylookupnone +notindom notindomisund notindomisundef -notinemptyset notinf +notinfreevarsys noting notinitial notinjective +notinkeys +notinline +notinnode notinself notinset +notinsete +<<<<<<< Updated upstream +notinsupp +notint +notinvars +notinvolutive +======= notinsingleton +notinsupp notint +notinvars +>>>>>>> Stashed changes +notinxs +notinzero notion +notionofstructure notions +notionsofdecidability +notisequiv notiso +notk +notkeep notl +notlast +notle notleader notless +notlesseq +notlessp +notlexless notlinearindependent +notloaded notlookup +notlower +notlr +notlsltnullnull notlteimpliesgt +notlteisnotlte +notlteq +<<<<<<< Updated upstream +notltetogt +======= +>>>>>>> Stashed changes notltimpliesgte +notltisgte +notltz notm +notmain notme notmem notmembership notmemrangeequiv +notmove +notms +notmt +notmtnmt +notn +notnegpi notnil notnilrec +notnodep +notnodupdup +<<<<<<< Updated upstream +notnot +notnotb +notnotbdc +notnotbool +======= notnorm notnot notnotb +notnotbdc +>>>>>>> Stashed changes notnotd +notnotef +notnotexists notnoti +notnotnot notnotr notnotralt notnotraltvd notnotrd +notnotrdc notnotri notnotrialt +notnotsnex notnottrue +notnt +noto notok -notone notoporder notopordersentence +notoptimized notornotel +notouch +notp +notparallelnotegal +notpath +notperp +notpi +notpickft +notpos +notposible +notposneg +notpower notpowercertificate +notpq notpresent notprimepow +notproofunf +notquiteswap notr notrab +notrailingsuffix +notreach notrecursive notreduced +notrel +notrelpr +notriggers +notriv notrivialcomponent +notrl notrsym nots +notsame +notsdom +notsdominate +notshw +notsodeep notsource +notspeckeyssecretsexpr notsqsubseteq notstarted +notstep notsubset +<<<<<<< Updated upstream +======= notsubseti +>>>>>>> Stashed changes +notsuc +notswap +nott +nottailrec +notte notterminalnforms notterminalnotsataxiom +nottest +nottheone +notthere +notthesame +notthunk +<<<<<<< Updated upstream +======= notticks +>>>>>>> Stashed changes nottru +nottrue +nottrusted +notunicast +notunicastte +notunique +notused +notv notval +notw notword +notwordvalue +notwordvaluecond +notwtft +notx +notxin +notyping +notzero +notzerodenom notzerodivisor +notzeroispr notzfaus notzmultzero +notztest +noupperbound +nout +noutc +noutcs +nouts nouvx +nov +nova noval +novars +novbind novel +november now +nowarn +nowarnings nowhere +nowhile +nowildcard +nowinner nowit nown +nowrap +nowrite nows +nox noxp noxpordfr noxpordpo noxpordpred noxpordse +noy noyau +noyes noz nozero nozerodivisors nozerosmuldivisors npa +npair +npairs +npany +npapp +npar +nparredn +npars +nparsing +npartly +npas +npass +npath +npatliteral +npattern +npatternlist +npatterns +npbase +npbaselist +npbc +npbf npc npcan npcand npcans +npconapp +npcons +npe npeano +npeg +npes +npeseries +npesfx npex npf npfaisrncytgfgl +nphases +nphi npi +npinf npk +nplist +nplu nplus npn npncan npncand npnf +npnflt +npns npolyhcn npomex +npops npos +nposreal nposznnd npow npowbinrec npowbinrecauto npowrec npowrecauto +npp +nppar nppcan nppcand npqs npr npre +nprec +nprecfields +npred +nprefixop npreflow +npresproof +nprimcom +nprime +nprimegi nprm nprmdvds nprmfac nprmge nprmi nproc +nprod nproduct +nprog +nprogc +nprop nproperty +npropp +nprovcontain +nprovrulecharacterise +nprovrules nprrel +nprv npss +npsspw +nptbase +nptuple +nptype +npw +npx +npy +npz nqenq nqercl nqereq @@ -55687,27 +92025,73 @@ nqerrel nqex nqfree nqg +nqm +nqnq +nqp +nqpi +nqpnq nqpr +nqprdisj +nqprl +nqprloc +nqprlu +nqprm +nqprrnd +nqpru +nqprxx +<<<<<<< Updated upstream +======= nqt +>>>>>>> Stashed changes +nqthm +nqtri +nqtric +nqueens nra +nradius +nrange +nrat nrc nrcomplexplaces nrcons nrcustomprojections +nrdl +nrdvdp nre +nreadable +nreadv +nreal +nrec +nreconc +nrecord +nrecs +nrefs nrefutable nreg nregmodel nregmodelaxext nregmodelf nregmodellem +nrel +nrelabel +nrelated +nrelop +nrelops nrelv +nrem nremaining +nrepp +nreq nres +nreset nrest +nret nreturn nreu nreurex +nrev +nreverse +nrewt nrex nrexdv nrexralim @@ -55724,6 +92108,8 @@ nrgtdrg nrgtgp nrgtrg nrhmzr +nri +nright nrm nrmcvec nrmgrp @@ -55742,24 +92128,50 @@ nrmtngnrm nrmtop nrmvec nrn +nrofobjects +nroot nroundn +nrounds nrows nrp nrrealplaces nrs nrt nruiev +nrv +nrw nsa +nsacr +nsall +nsams +nsapays nsappend +nsatz +nsave nsb nsbind +nsbindlist nsc +nscontents +nsdom +nsdommod nsearch +nsects +nseg +nselfapp +nsemis nsempty nsend +nsep +nseq +nseqb +nseqp +nseries nset nsets nsettr +nsexpr +nsfa nsg nsgacs nsgbi @@ -55775,15 +92187,30 @@ nsgrplem nsgsimpgd nsgsubg nsgtrivd +nsh +nshift +nshiftop +nships +nsign +nsignaturevalue +nsigspec +nsingl +nsize +nski nslexord nslexordeqp nslexordp nslexordpe nslexordpi nslexordrec +nslices +nslift nslookup +nslookupmod nsm nsmallnq +nsmallnqq +nsmap nsmndex nsmul nsmuladdmonoidhom @@ -55793,82 +92220,199 @@ nsmulmemclass nsmulrec nsmulsaturated nsn +nsnd nsnel nsnid nsnlplig nsnlpligalt +nsnoc +nso +nsoptbind nsound +nsp nspecial +nspecline +nspeclinelist nsphere +nsplittree +nspp nsq +nsqn +nsqnr +nsqrt nsr nsrcof nsrcoftrfrom +nsrsteps nss +nsscontents nssd nssdmovg +nssgamma +nssing nssinpss nssne nsspssun +nssr nssrex +nsss nsssmfmbf nsssmfmbflem nssss +nssssr +nsssucpw nsstr +nssub nst +nstack +nstar nstart +nstates +nstatus +nstb nstep nstepperm nsteps +nstfnname nstill +nstl nstore nstri nstrict +nstring +nstructname +nstructure +nstrv +nstrvs +nsts +nstubs nstutinv nsub nsubkc +nsublis +nsubset +nsubst +nsubstitute +nsuc nsuceq nsum +nsurj +nsv +nsx nsyl nsyld nsyli +nsym +nsz +nta +ntag +ntalgo ntbase +ntbaselist ntc +ntcatcod ntcatdom ntcf ntcod +ntcompdefinede +ntcompdefinedi +ntcomposet +ntconstr +ntcs ntd +ntdom +nte +ntemp +nter nterm nterms +ntermval +ntfun ntgtof ntgtoftrfrom nth +nthappenda +nthappendb nthb +nthbinary +nthbyte +nthc +nthcd nthcdr +nthcdrs +nthcdrx +nthcircperm +nthcircpermnany nthconstructor +nthcp +nthcptlok nthd nthe +nthelper +ntheqok +nthfirst +nthgray nthhom nthhomseq +nthi +nthkey +nthlast +nthm +nthmeta +nthnats +nthnatsworker +nthnodeby ntho +nthp +nthprime nthremainder +nthrev nthroo nthroot +nthrootp nthroots nthrootsfinset nthruc nthrucw nthruz nths +nthsp +nthss nthtriple +nthword +nthworker +nthxtr +ntica +ntid ntimes +ntinv +ntk +ntks +ntkstate +ntl ntm ntmap +ntmp +ntnm nto ntop +ntoplet +ntopletrec +ntopleveldecs +ntorus +ntoseg +ntosn ntou +ntoword +<<<<<<< Updated upstream +======= ntpp +>>>>>>> Stashed changes +ntprod ntr +ntrans +ntransitive +ntransitivei ntrcls ntrclsbex ntrclscls @@ -55886,19 +92430,27 @@ ntrclsnvobr ntrclsrcomplex ntrclsss ntrdif +ntree ntrelmap ntreq ntrf ntrfval ntridm +ntrie +<<<<<<< Updated upstream +======= ntries +>>>>>>> Stashed changes ntrin +ntriv ntrivcvg +ntrivcvgap ntrivcvgfvn ntrivcvgmul ntrivcvgmullem ntrivcvgn ntrivcvgtail +ntrivg ntrivial ntrk ntrkbimka @@ -55920,86 +92472,218 @@ ntrneix ntrneixb ntrootsfinset ntropn +ntrp ntrrn +ntrs ntrss ntrtop +ntrue ntrufal ntruni ntrval nts ntsof ntsofgamma +ntsp ntstep +ntsym ntt ntu +ntunify +ntup +ntv +ntvar +ntvs +ntwhiskerr +nty +ntyop +ntyoplist +ntype +ntypeabbrevdec +ntypeconstr +ntypeconstrname +ntypedec +ntypedef +ntypedefinition +ntypedefs +ntypeinfo +ntypelist +ntypelists +ntypename +ntypeparams +ntyperepr +ntypereprs +ntyvarlist +ntyvarn ntzer +nua +nuanced nub +nubs +nuc +nuclei nucleus nucleusisosublocale +nuevos +nufrac +nuhyp +nuisance nul nulchn +nuldirseg +nulel nuleldmp +nulform +nulge nuliota nuliotaalt null nullable +nullablegamma +nullableml +nullablent +nullablepass nullablesym +nullablew nulladdsubgroup +nullangle +nullanglehalfline +nullary +nullaryh nullbdry +nullcheck nulldiff +nulldist +nulle +nullextension +nullgenerators nullhomotopic nullhomotopicmap nullhomotopy +nullification +nullifies +nullify +nullifying +nullimpliesnocycles +nullisterminal nullity nullkind +nullloop +nulllslt nullm +nullmap nullmeasur nullmeasurab nullmeasurable nullmeasurablese nullmeasurableset nullmeasurablespace +nullmodality +nullmodhilbert +nullo +nullp nullpointer +nullpointerexception +nullpreservescontr +nullpreservesequiv +nullpreservesiso +nullpreservesprop +nullptr +nullrecequiv +nullrecisequiv +nullrecispathsplitequiv +nullref +nullrefp +nullregression +nullsegment nullset nullspace nullstellensatz +nullstmt +nullstr nullstrict nullsubgroup nullsubmodule nullt +nulltuple +nulltype +nullv nullval nulmbl nulmo +nulnc +nulnnc +nulnnn +nulo +nulop nulsgts nulsgtsd nulslts nulsltsd num +numabs numacn numadd numaddc numargs +numb +numbe number +numbera +numberd +numbered +numberedalphabet numberedmap numbererrorfiles +numberfied numberfield numbering +numberlistp +numberofbooks +numberofbytes +numberofbytestype +numberoffingroups +numberoffinsemigroups numberofisbeschr +numberonlevel +numberp +numberps numbers +numberstr numberstream +numbersudoku numbertheory numbertheorysymbols +numbit +numbits numblocks +numbool +numboolexp +numboolextended +numboolrange +numboolranges +numbools numbound +numbytes +numc +numcdrs numcert numchars numcl +numclosedfieldtype +numcls numclwlk numclwwlk numclwwlkovh numclwwlkovq numclwwlkqhash +numcodes +numcols +numcomponents numctors +numd +numdb +numden numdencaseson numdenexp numdenneg @@ -56009,67 +92693,185 @@ numdensq numderangements numdesc numdom +numdomaintype nume +numed numedglnl +numelems +numelt +numen +numentries +numeq numeqs numer +numera numeral +numeralord numerals +numerate +numeration +numerato numerator numeratorhom numerators numeratorunit numeric +numerical +numerically +numericp numericproj +numerics +numericslice +numesg +numesign numexp numexpp +numextended numextraargs +numfats numfields +numfieldtype numfvars +numgates +numgoals +numheads +numholes numhyps +numi numindices +numinf numinfctb +numinfset numiunnum +numl numleaves +numleft +numlis +numlist numlit +numlowstring numlt numltc numlti +numm numma nummac +nummap +nummaps nummin nummodules nummotives nummul +numn +numnat numnatcoe +numnesign numnn numnncl numnodes +numnum +numocc +numof +numofbit +numofd +numofdummy numofgt +numofzero +<<<<<<< Updated upstream +======= numonlyb +>>>>>>> Stashed changes +numopt +numord +nump numpair numparams +numplt +numpn +numpreimages +numq +numqe +numqk +numqn +numr +numrange +numresults +numright +numroots +numrows numrules nums numseg +numset numsq numsteps numsuc numsucc +numsucnotempty +numsum +numsyntax +numtag numth numthcor +numthreads +numto +numtoo +numtorevword +numtype +numu numufl +numupdatec +numuplowstring +numupstring +numv +numva numvals +numvar +numvarassignment +numvarlist +numvarmap numvars numvarying +numw numwdom +numwhic +numwhich +numwor +numwords +numx +numz +numzeros nun +nunber +nunify +nunion +nunivariatepolyfun +nunivariatepolyhit +nunivariatepolylist +nunrrds +nupn +nupper +<<<<<<< Updated upstream +nuprl +======= +>>>>>>> Stashed changes +nuqconstructor +nuqconstructorname +nuqn +nuqtyop nurse +nus nuse nusnrpjhewtpsadetusmctyp +nust +nuthin +<<<<<<< Updated upstream +======= nutitionist +>>>>>>> Stashed changes nux nuz +nva nvablo nvabs nvadd @@ -56079,9 +92881,17 @@ nvalidtrans nvalidtranse nvalidv nvalidve +nvals +nvaltype nvalue +nvaluename +nvaluepath +nvar +nvarb +nvariablep nvars nvass +nvc nvcl nvcli nvclmod @@ -56092,9 +92902,12 @@ nvctvc nvdi nvdif nvdir +nvec +nvecs nvejbtceex nvel nvelim +nveric nvex nvf nvgcl @@ -56106,6 +92919,7 @@ nvi nvimp nvinv nvinvfval +nvk nvl nvli nvlinv @@ -56128,8 +92942,10 @@ nvocnv nvocnvb nvof nvop +nvpb nvpi nvpncan +nvr nvrcan nvrel nvrinv @@ -56142,39 +92958,82 @@ nvsge nvsid nvss nvsz +nvt nvtri nvvc nvvcop nvvop +nvwalk nvz nvzcl nwa +nwalk +nwalkstar nwas +nways +nwdgkxh nwdodisk nwdopackets nwdostate nweig nweight +nwfs +nwidth nwindows +nwires +nwiresp nwith +nwitness +nwlpo +nwm nwnw nworkaround nwpackets nwpf -nwpnt nws nwstate +nwv +nwvrfmf +nxe nxmi +nxn +nxor +nxs +nxst +nxsts +nxstvals nxsxbhs nxt nxtact nxtactive +nxtbdd +nxtbyte +nxtdin +nxtic +nxtis +nxtn +nxtprime +nxtreg +nxv nxxuroevediokvvvzib +nxy +nxyp +nybnd +nyconjugate +nyielded +nyo nyou +nyper +nys +nyx +nyy nza nzadd nzb nzc +nzchare +nzcount +nzcv nzd nzdiv nzero @@ -56182,17 +93041,23 @@ nzerooringczr nzerop nzeropl nzeropr +nzg nzi nzia nzib nzin +nzl nzm nzn nznngen +nzo nzp +nzpcount nzppab nzprmdif +nzreal nzring +nzringtype nzrneg nzrnz nzrpropd @@ -56201,6 +93066,7 @@ nzrringold nzrunit nzsnum nzss +nzx nzy oaabs oaabsb @@ -56210,28 +93076,76 @@ oaass oab oabexg oabexgold -oabove oabs oabstfn oacan +oacc +<<<<<<< Updated upstream +======= +oaccp +>>>>>>> Stashed changes oacgr oacl +oacom oacomf +oacqpc +oacqsc oadd +<<<<<<< Updated upstream +======= +oaddr +>>>>>>> Stashed changes +oaddrstack +oaddrsymbol oadif +oadist +oadistb +oadistc +oadistd +oadp +oaeqv +oaexg oaf +oaffinplane +oaffinspace +oafnex +oagen +<<<<<<< Updated upstream +======= +oagent +>>>>>>> Stashed changes +oago +oah oai +oaidlem +oaii +oaiii +oal +oale oalem +oalii +oaliii oalim oalimcl +oalist +oaliv oall +oalp +oalph +oalphf +<<<<<<< Updated upstream +======= oalt +>>>>>>> Stashed changes oaltom oaltublim oaltv oan +oanalz oancom +oand oangle +oantisym oaomeqom oaomoecl oaomoencom @@ -56240,67 +93154,141 @@ oaordex oaordi oaordnr oaordnrex -oap oapp +oappe +oappemap +oappend +oappv +oapvion oarec +oareg +oarg oarrivemsg +oas +oaspace +oasr oassert oasubex oasuc +oat +oath +<<<<<<< Updated upstream +======= +oatleastlessthan oatom +>>>>>>> Stashed changes +oatr +oattr +oau oaun +oaur oav oaword oawordeu oawordeulem oawordex oawordexr +oawordi oawordri +oawordriexmid oawxghulnyykbuheewun +<<<<<<< Updated upstream +oba +======= oax oay +oba +obad +>>>>>>> Stashed changes +obag obas +obaselatch obasis +obcat +obdd +obeh +<<<<<<< Updated upstream +======= obelow +obeta +>>>>>>> Stashed changes obeys obfuscate obg +obin +obind +obindeapp +obindv +<<<<<<< Updated upstream +======= +obinop +>>>>>>> Stashed changes obit obj objappend objastype objastypeequiv objastypetoastype +objc +objclose objd objdown obje objec object +objectclassifier +objectclasskind +objectderivation objecte +objectfields +<<<<<<< Updated upstream +======= objectfoundinlocation +>>>>>>> Stashed changes +objectglobalbaseinv +objectglobalinv objecti objective objectiverow +objectives +objectkind +objectkinds +objectlist +objectmap +<<<<<<< Updated upstream +======= objectof +>>>>>>> Stashed changes +objectp objectpro objectprop objectproperty +objectref +objectrestriction objects +objectsarevalid objectsc objectscountermodel +objectset +objectsnonempty +objectsp +objectstogc objecttosort objecttype +objectuserfields objectwise objeq objeqtohom objequiv objequivsections objext +objf objfobjsucciso obji objisinitial objiso objisopt +objlist objloc objmap objmk @@ -56308,37 +93296,75 @@ objmkiso objname objnameeq objobjpreimageiso +objopen objopop +objp objpairwiseoffamily objpreimage +objref +objrefs objs +objsi +objsp objsucciso objsupisoprodeqlocus objt +objtv objtype objtypeeq +obju objup objv objx obl +oblig +obliga +obligat +obligatio obligation obligationcollector obligationorigin obligations obligationstatus +obliged +obligs +oblique +obliviation +<<<<<<< Updated upstream +obmit +obnd +obody +======= +oblock +oblocks +obmit +obnd obody obool +oboolean obot +>>>>>>> Stashed changes +obounds +obox +oboxopt obs +obsc +obscure +obsd +obse obselocv obseq +obseration +observability observable +observablee observables +observati observation -observational observations observe observed +observer observes observing obsf @@ -56348,65 +93374,128 @@ obsip obsipid obsl obslbs +obsm obsne obsocv obsolete obsrcl obsss +obstr obsv obt obta obtai obtain +obtainable obtained obtaining obtains +obtuse obuch obuchpincl obuchpred obuchqred +obuf +obv +obvio obvious obviousfunext obvioushfunext obviously +obvs oca +<<<<<<< Updated upstream +======= +ocall +>>>>>>> Stashed changes +ocaller +ocaml ocan ocancel +ocar ocard +ocase +<<<<<<< Updated upstream +======= +ocast +>>>>>>> Stashed changes +ocat +ocbicby occ occasion occasionally +occform occl occllem +<<<<<<< Updated upstream +======= occm +>>>>>>> Stashed changes +occmap +occname +occnames occon +occp occqhfwoyhaaecwxnojumqyg occs +occsp +occupied +occupy occur +occurance occurence occuring +occurlist +occurre occurred occurrence +occurrencecount +occurrencep occurrences +occurrencesp occurring occurs occurssec occurssectype +ocdr +<<<<<<< Updated upstream +ocel +och +======= +ocean ocel och +ochain +ochar +>>>>>>> Stashed changes +ochoice oci ocid ocin +<<<<<<< Updated upstream +======= +ocis +>>>>>>> Stashed changes +ocitv +ocitvd +ocitvi +ockont +ockontt ocl ocland oclany +oclass oclastype +oclif oclimplies oclnot oclor +oclosed +oclsuper oclvoid oclwwlkn oclwwlknlem +ocmp ocndx ocnel ocnt @@ -56423,30 +93512,89 @@ ococi ococin ococnv ococss +ococurrence +<<<<<<< Updated upstream +ocof +ocofval +ocoima +ocomp +ocompare +ocompile +ocon +oconcl +======= ocoeff ocof ocofval ocoima ocollect +ocoloured ocom +ocomb ocomp +ocompare +ocompile +ocompletelattice ocomplex +ocon oconcl +ocond +>>>>>>> Stashed changes +oconf ocons +oconsp oconst +<<<<<<< Updated upstream +ocontmaps +ocorth +======= +oconstant +ocontmaps +ocontract oconverse +oconversep ocorth +ocos +>>>>>>> Stashed changes +ocosts ocp +ocpalengthok +ocpaux ocpbl ocpbllem +ocpperm +ocpsortedaux ocpsortedtl +ocptlok +ocr +ocrit +ocritt +<<<<<<< Updated upstream +======= +ocrypt +>>>>>>> Stashed changes +ocs ocsh -ocsqrt ocss +oct +octagon +octagonnodesetgenerator +octagonnodesetp +octagonrouting +octagonvalidparamsp octahedron +octal +octant octb +octet +octets octo +october +octonion octonions +ocu +ocurrences +ocuurs ocv ocval ocvcss @@ -56461,44 +93609,65 @@ ocvss ocvsscon ocvval ocvz +ocwl odadd +odb odbezout +odc odcau odcl odcld +odclem odcong odd odda oddaltv oddb +oddbin +oddbinnat +oddcharac oddcomabszz oddcommuteequiv oddcomponents +odddegree odddistincts odde +oddennn +oddeven oddevendec +oddevenlemma oddexp +oddf +oddfibs +oddfinex oddfl oddflaltv oddge oddiadd oddibas oddinmgm -oddinteger oddkernel +oddkey +oddkeys +oddkeysched +oddloop oddly oddm oddmult oddmultinv oddn +oddnat oddneven oddnn +oddnnul oddnumth oddopp oddp +oddparity oddpart oddplus oddplusinv +oddpn oddprime oddprimedivisor oddprm @@ -56509,12 +93678,21 @@ oddprmgt oddprmne oddprmuzge oddpwdc +oddpwdclemdc +oddpwdclemdvds +oddpwdclemndvds +oddpwdclemodd +oddpwdclemxy oddpwdcv oddpwp +oddr +oddround odds oddseven oddseveninv +oddsg oddsumodd +oddtfin oddvds oddvdsi oddvdsnn @@ -56522,26 +93700,58 @@ oddvdssubg oddy oddz ode +<<<<<<< Updated upstream +======= odegree +>>>>>>> Stashed changes +odei +odelete +odeo odeq oder +oderiv odes +odestsexstr +odestsxnum +odestsxstr +odestsxsym odf +odflt +<<<<<<< Updated upstream +======= +odft +>>>>>>> Stashed changes odfval odfvalalt odhash odi +odia +odiaopt +<<<<<<< Updated upstream +======= odictator +>>>>>>> Stashed changes odid +odiff +odifies +odigpxu odinf odinv odisj +<<<<<<< Updated upstream +odiv +======= odistinct +odiv odivide +>>>>>>> Stashed changes odkdonztkkxblctqfzfbqzbbuyutkxb odlem odlist odm +odmbld +odmbst +odmbsy odmod odmodnn odmulg @@ -56554,7 +93764,11 @@ odnncl odnwnodes odnwpackets odnwstate +odo +<<<<<<< Updated upstream +======= odom +>>>>>>> Stashed changes odory odot odpmco @@ -56565,7 +93779,10 @@ odrngmulr odrngplusg odrngstr odrngtset +odsn +odst odsubdvds +odual odubas oduclatb odudlatb @@ -56585,7 +93802,6 @@ oduprs odutos oduval odval -odvd odz odzcl odzcllem @@ -56594,15 +93810,18 @@ odzid odzphi odzval oecan -oecdmembereconomiesclass oecl oedg oeeu oeeui oeeulem oef -oeffs oege +oehdben +oei +oeicl +oeiexg +oeiv oel oelim oelimcl @@ -56610,13 +93829,19 @@ oemapso oemapval oemapvali oemapwe +oemname +oemnamei +oemnamep +oempty oen oenass oenassex +oenc oenfi oenfirn oeng oenord +oenv oeoa oeoalem oeoe @@ -56624,21 +93849,31 @@ oeoelem oeord oeordi oeordsuc +oep oeq oequni oesuc oesuclem oev +<<<<<<< Updated upstream +======= +oeval oevalc oevaln +>>>>>>> Stashed changes +oevent oevents +oevery oevn oeword oeworde oewordi oewordri oex +oexactlyone oexbi +oexists +oexmid oexp oexpled oexpneg @@ -56646,10 +93881,14 @@ oexpnegaltv oexpnegnz oexpreposd oexrnex +oextension +oextract +oextracte ofa ofab ofabelian ofabs +ofacc ofadd ofaddequiv ofaddmndmap @@ -56663,6 +93902,7 @@ ofalgebraautonunits ofalgebraic ofalgequiv ofalghom +ofalse ofantisymmetrization ofar ofarchimedean @@ -56673,9 +93913,12 @@ ofarrowiso ofarrows ofasclist ofasclistaux +ofass ofassociative ofassociativemodule +ofat ofatom +ofatomicformula ofatomm ofbase ofbasechange @@ -56706,6 +93949,8 @@ ofboxprodleft ofboxprodright ofbraided ofbraidedobj +ofbs +ofbytes ofc ofcard ofcardinalgenerate @@ -56723,6 +93968,7 @@ ofcf ofcfeqd ofcfn ofcfval +ofchar ofcharzero ofchosenfiniteproducts ofclass @@ -56854,12 +94100,14 @@ ofepiofiszero ofeq ofeqd ofeqsubtypes +ofeqtrans ofequiv ofequivalence ofequivfun ofequivfunctor oferase ofesssurj +ofet ofeven ofexact ofexactofretraction @@ -56880,10 +94128,11 @@ offan offdiag offedning offending +offeq offer -offering offers offiberequiv +official offield offilter offin @@ -56910,6 +94159,7 @@ offintype offixingsubgroup offixingsubgroupempty offixingsubgroupunion +offloat offloor offn offnrec @@ -56926,11 +94176,17 @@ offreemonoid offres offromspecstalk offs +offse offset offsetby +offseth +offsetl offsetmap +offsetp +offsets offsetting offsplitfpar +offt offullyfaithful offullyfaithfultogroupoid offun @@ -56939,6 +94195,7 @@ offunctionfield offunctor offunofcountable offunofhasbasis +offv offval offvalfv offvaraliasinfo @@ -56982,8 +94239,10 @@ ofidx ofield ofiff ofiic +ofinal ofinduced ofinfsuple +ofinite ofinitials ofinj ofinjec @@ -56994,6 +94253,7 @@ ofinjectiveoffinrankeq ofinnerproductspace ofint ofinteger +ofintonlyascii ofintrinsicclosure ofintseq ofinv @@ -57050,11 +94310,15 @@ ofisunitdet ofiszero ofiszeroofisiso ofiterate +ofix +ofixd +ofixi ofj ofjne ofk ofkernel ofl +oflags oflawfulfunctor oflawson oflaxfunctortolocallygroupoid @@ -57097,6 +94361,7 @@ oflinearwellfoundedgt oflinearwellfoundedlt oflipschitz oflist +oflistword ofloca oflocalizationfinitespan oflocalizationfinitespantarget @@ -57104,6 +94369,7 @@ oflocalizationmaximal oflocalizationprime oflocalizationspan oflocalizationspantarget +oflog oflower oflowerset oflowersetorderiso @@ -57204,6 +94470,12 @@ ofoaid ofobj ofobjectproperty ofobjects +ofoldfs +<<<<<<< Updated upstream +======= +ofoldl +ofoldr +>>>>>>> Stashed changes ofopensubsets ofoplaxfromunit ofoplaxfunctortolocallygroupoid @@ -57214,7 +94486,9 @@ ofoption oforder oforderiso ofordinaryenrichedcategoryequiv +oformals oforthogonalfamily +ofp ofpairinginthree ofparallelhoms ofpermhom @@ -57258,6 +94532,7 @@ ofquivhom ofquotient ofquotientstabilizer ofr +oframe ofrange ofrankeq ofrankeqzero @@ -57277,11 +94552,13 @@ ofrealam ofrealclm ofrealhom ofrealli +ofree ofreflectscoconeinitial ofreflectsconeterminal ofrel ofrelisolt ofrepeat +ofreplace ofreplacerange ofrepr ofrepresentableby @@ -57292,6 +94569,7 @@ ofrestrict ofrestrictscalars ofretract ofretraction +ofreverse ofrfval ofrfvalg ofriemannianmetric @@ -57300,6 +94578,7 @@ ofrightexact ofrightfdrep ofrightinverseofcardle ofrightliftingproperty +ofringe ofringequiv ofringhom ofringmorphism @@ -57313,9 +94592,11 @@ ofscalar ofscalars ofscalarssubmodule ofscalarssum +ofscaled ofscientific ofscom ofscott +ofsd ofsection ofselfiso ofselfleradical @@ -57358,6 +94639,7 @@ ofspansingleton ofsplitepi ofsplitexact ofsquarezero +ofss ofstabilizer ofstalkiso ofstar @@ -57414,6 +94696,7 @@ oftensorproductbil oftensorproductequivoffinitenoetherian oftensorproductequivofpifintype oftensorproductinvofpifintype +oftentimes ofterminals oftextedit oftop @@ -57452,17 +94735,20 @@ ofupperset ofuppersetorderiso ofv ofval +ofvalg ofvaluation ofvalues ofvector ofvectorspace ofvectorspaceindex ofveu +ofview ofvswap ofwhisker ofwhiskerequivalence ofwidget ofwithbot +ofwords ofwtype ofzeroringhom ofzeros @@ -57470,9 +94756,21 @@ ofzlatticebasis ofzlatticecomap ofznum oge +<<<<<<< Updated upstream +oghoare +ogii +oglem +ogolnym +======= ogetlocs +ogets oghoare ogii +oglb +oglem +ogolnym +ogreaterthanlessthan +>>>>>>> Stashed changes ogrp ogrpaddlt ogrpaddltbi @@ -57484,20 +94782,46 @@ ogrpinvlt ogrpsub ogrpsublt ogs +ogt oguawlxk ohalf +<<<<<<< Updated upstream +======= +ohconf +>>>>>>> Stashed changes +ohd ohead ohearn +ohh +ohm +ohme +ohmeabelian +ohmj +ohmpredp +ohms +ohno +<<<<<<< Updated upstream +======= ohoare +>>>>>>> Stashed changes ohom ohomfval +ohones +ohonestail +<<<<<<< Updated upstream +======= +ohp +>>>>>>> Stashed changes ohpprsr ohsnz +ohyperun +ohyps oiai oibabs oicl oid oidb +oidft oids oien oieq @@ -57505,58 +94829,166 @@ oieu oiexg oif oiface +oifce +oiff +<<<<<<< Updated upstream +======= +oifft +>>>>>>> Stashed changes oii oiid oiiniseg oiiso oil -oim oimage +oimpl +oin +<<<<<<< Updated upstream +======= oindi +oinduced +oinf +>>>>>>> Stashed changes oinitial +oinj oinsert +<<<<<<< Updated upstream +======= +oint +ointerval +>>>>>>> Stashed changes +ointoflong +ointstart +ointsub +oinv oinvd +<<<<<<< Updated upstream +oinvfun +oinvk +======= oinverse +oinvfun +oinvk +oinvkey +>>>>>>> Stashed changes +oinvp oinvr +oinvs +oinvt +oinvv oiold oion oip +oir +<<<<<<< Updated upstream +oisb +oismo +oiso +======= oirrefl +ois +oisb oismo oiso +oissues oisub +oit +>>>>>>> Stashed changes oiugwrq +ojekojf +ojoin +ojoina +ojoinc +ojoint ojz oka +okamoto okay +okayp +okb okclocks +okcomposite +okd +okdef +okeq +<<<<<<< Updated upstream +okeya +======= +okey +okeya +okeysfor +>>>>>>> Stashed changes +okfordecrypt +oki +okie +okm okmaxsync okmdwd +<<<<<<< Updated upstream +======= +oknows +>>>>>>> Stashed changes +okp +okpath +okplus +okpm +okr +okretty +okvar +olam +olamb +olambdac +olamg +olamt +olamz +<<<<<<< Updated upstream +======= +olass +>>>>>>> Stashed changes olast olc +olcc olcd olci +olcl olcnd +olconf olcs old +olda +oldaseq +oldb oldbday oldbdayim oldbisimbisimeq +oldcell +oldcohom oldconfig +oldcontents oldcumulimps olddate olddefs +olddstdata +olddx olde older +oldest +oldeval oldf +oldfd oldfi oldfib +oldfn oldfvars oldgoals +oldheap oldheartbeats oldhex oldhyps +oldi +oldidx oldirr +oldl oldlim oldmade oldmaded @@ -57565,64 +94997,162 @@ oldmj oldmm oldmvdecls oldn +oldname +oldnet +oldnew oldno oldnod oldobtain oldobtainlinter +oldp +oldpat +oldq +olds +oldsetbits +oldsize oldss oldssmade oldssno oldsuc +oldsucpairs +oldsucs +oldsym oldtactickind oldtacticname +oldtext +oldthread olduses +oldv oldval +oldvalue +oldvalues +oldvars +oldvertex +oldwidth +oldwords +oldx ole +olea +<<<<<<< Updated upstream +======= +oleadsto +>>>>>>> Stashed changes olean oleast +oleastone olecpbl olem +olemab +oleme +olemfvp +olemjpcl +olemkle +olemklt +oleml +olemmo +olemnab +olemnanb +olemp +olemqcl +olemqf +olemqk +olemqpcl +olemqsum +olemqsumk +olemqsumkj +olemqval +olemr +olemstep +olen +oleq oless +olessp olf olgbttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttchttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttunahiphttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttqbddsfihnttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttvrtettttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttyvksqyviqasqtttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttthdeettttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttvsttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttfgltttttttttttttttttttttttttttttttttttttttttttt +olift +olifts olim olimit +olimitd +olimite +olimiti +<<<<<<< Updated upstream +olist +olisto +olistone +======= +olimseq olin olist olisto olistone +olistsp +>>>>>>> Stashed changes +olit olj ollat ollpti olm +<<<<<<< Updated upstream +======= oloc olocal +>>>>>>> Stashed changes +olog olop +olower olposn olpti olt +<<<<<<< Updated upstream +olv +======= +olub +olv olymul +>>>>>>> Stashed changes omabs omabslem +omall omalt omap +omapeapp +omapebind +omapen +omapk +omapl +omapv +omar omass +omavailable +omax +<<<<<<< Updated upstream +======= +omaxchain +>>>>>>> Stashed changes +ombg ombregs omcan omcl +omct +omctfn ome omecl omedm omef +omeg omega +omegacat omegacompletepartialorder omegacompletepartialorderequalizer +omegad +omegaind +<<<<<<< Updated upstream +======= omegaindax +>>>>>>> Stashed changes omegalimit omegas -omegasax -omegasclos -omegasp omegatolia omegatoliaregressions omege @@ -57632,10 +95162,12 @@ omeiunltfirp omelaxinf omelesplit omelon +omem omenps omensuc omeo omeoaltv +omerge omess omessle omessre @@ -57645,12 +95177,14 @@ omeulem omeunile omeunle omex +omexg omexrcl omf omfi +omfnex omfv +omgadd omge -omgt omh omhf omhfb @@ -57659,6 +95193,7 @@ omhnpupbwgwaxsmdfu omi omin omina +omind ominf ominus omiscard @@ -57666,16 +95201,26 @@ omit omits omitseq omitted +omittedrange omitting +omiunct +<<<<<<< Updated upstream +======= omkbot omktop +>>>>>>> Stashed changes +omkynlt oml +omla +omlan +omlem omlfh omlim omlimcl omllat omllaw omlmod +omln omlol omlop omlsi @@ -57683,7 +95228,6 @@ omlsii omlsilem omlspjn omltoe -ommute omnaddcl omnd omndadd @@ -57691,14 +95235,18 @@ omndaddr omndmnd omndmul omndtos +omni +omnimkv +omniscient +omniwomnimkv omnord omo omoalt +omod omoe omoealtv omomeqom omon -omonom omoold omopth omopthi @@ -57706,7 +95254,19 @@ omopthlem omord omordi omordlim +omostone +omotap +omotaplemap +omotaplemst +omove +omp +<<<<<<< Updated upstream +ompc +======= +ompair +ompc omplex +>>>>>>> Stashed changes omprcomonb ompt omptsn @@ -57717,14 +95277,19 @@ oms omscl omsf omsfval +omsg omsinds +omsk +omsmall omsmeas omsmo omsmolem omsmon omssaxinf +omssind omssnlim omsson +omssonalt omssrncard omssubadd omssubaddlem @@ -57732,8 +95297,10 @@ omsuc omsucelsucb omsucne omsval +omtrans omtsk omul +omult omun omv omvdcnv @@ -57748,32 +95315,60 @@ omxpenlem omzoudasmtfjdgrbbxxdoxyogrlfnqqjswvzwddjy onaddscl onadju +onallpaths onasuc onat +onatenc onboundedformula +onc oncard oncardid oncardval once +oncirc +oncircle +oncommondenomsym oncone oncutleft oncutlt oncyclefactors ond +onde +ondecrypt +ondecryptensurespublicly ondiag +ondiameter ondif ondomen ondomon one onea +onealt +onearg +oneb +onebit onebits +onebl onec +onecase +oneclass onecochain onecochainoftwosplitting onecocycle onecohomologyrelation +onecount +oned onedim onedimension +onedividesanything +onedsqr +onedsqrv +onee +oneedge +oneedgeg +oneedgeplg +oneel +oneelement oneelementsetcharacterization oneembedding oneembeddingequiv @@ -57781,18 +95376,34 @@ oneembeddingmap oneequiv oneexp onef +onefiber +onefile +oneform +oneformsub +oneformsubeq onefunc +onegate +onegcd +onegenfreeabgroup onego +onehalf +onehelp onehom onehomclass +onehot onehypercover onehypercoverdensedata onehypercoverfamily +onei +oneindex +oneinvector oneispoly onel onele onelepart +oneless oneli +oneline onelini onelist onelon @@ -57806,17 +95417,37 @@ oneltm oneltr oneltri oneluni +onem +onemax +onemd onememclass onememu onememv oneminus +oneminusmultplus +onemk +onemm +onemmr +onemore onemul +onemv +onemx +onemxn +onemxnmr +onen +onencryptensurespublicly +onenodeparams onenon onenotinotbothi oneo oneof +oneoff +oneofmonotonic +oneone oneoneequiv oneonereducible +oneop +oneovernplus onep onepo onepoint @@ -57827,29 +95458,49 @@ onepoly onepsuc oneptr oneptri +oneq oneqmin oneqmini +onequarter oner +oneresult +oneround ones oneself +oneshot oneside +onesp onestep onestepperm +onestr onesub onesuc onet onetangentspaceicc onetansqsecsq +onetap +onethread +onetoone onetozero +onetree onetruncation oneunique +onevar onevariable onevector +oneway +onewinst +onewiththis +oneword +onex onexgt onexlimgt +onexmm onexoegt onexomgt onexponent +onexxx +oney onezplus onfailure onfin @@ -57857,6 +95508,7 @@ onfinset onfinsupp onfisupcl onformula +onfq onfr onfralt onfraltlem @@ -57864,9 +95516,15 @@ onfraltvd onfun onfunction onfununi +ong onhighestnode +onho oni +onid +<<<<<<< Updated upstream +======= onil +>>>>>>> Stashed changes onin onindices oninfcl @@ -57874,34 +95532,68 @@ oninfex oninfint oninfunirab oninhaus +oninit onint +onintexmid oninton +onintonm onintopssconn onintrab onintss onintunirab onioc oniocaux +oniq onirri oniso onk onl +onld onleft +onlem +onlemaccex +onlembacc +onlembex +onlembfn +onlembxssdm +onlemex +onlemres +onlemssrecs +onlemsucaccv +onlemsucfn +onlemubacc onles onlesd +onli online +onll +onlld +onlli +onllil onlssdwdcgkrbiiwhcfptpfguvvoox onltn onlts onltsd only +onlyds +onlydstotal onlygoal onlygoodsallocated onlygoodsareallocated onlygoodsareallocatedauxiliary onlygoodsaresold +onlyif +onlyimmsokoutofimms +onlylowers +onlyoddnegs onlyondefeqnodes onlyone +onlyp +onlyprinttypes +onlyspecreads +onlystackmemorylocations +onlyuppers +onm onmaxnelsup onmcl onmindif @@ -57924,23 +95616,31 @@ onnoxp onnoxpg onnoxpi onnseq +onntri +onoff onomeneq +ononce +onone onord onordi onorm +onot +onotbool onote +onotes onov onoviun onovuni onp +onpi onprc onpresheaf -onproperty onpsssuc onpsstopbas onpwsuc onquot onquotval +onr onregularcone onrelation ons @@ -57949,9 +95649,11 @@ onscalar onsdom onsdominel onsentence +onset onsetrec onsetreclem onsfi +onsingletons onsis onss onsse @@ -57975,12 +95677,17 @@ onsucb onsucconn onsucconni onsucelab +onsucelsucexmid +onsucelsucexmidlem +onsucelsucr onsucf onsuci onsucmin onsucrn onsucss onsucssi +onsucsssucexmid +onsucsssucr onsucsuccmp onsucsuccmpi onsuct @@ -58009,25 +95716,37 @@ ont onterm ontgsucval ontgval +onth ontheory onto ontology ontopbas +ontot ontr ontrace +ontrci ontri ontric +ontriexmidim +<<<<<<< Updated upstream +======= +onull +onullpointer onumber +>>>>>>> Stashed changes onun onunel onuni onuniintrab onuninsuci onuniorsuc +onuniss onunisuc onunisuci +onunsnss onunusedinstanceswhere onv +onverrides onvf onw onwards @@ -58036,20 +95755,67 @@ onwpackets onwstate onxpdisj onxt +onyy onzohzdbwceudtdaejnpgzpvuaroezalhdjkosuwuctxqskeniwblkgvrbaygzrfowxalhmxqwjmykncjziahqacttqvelmgblmnkvrot onzsl +oob oocak +oocard +<<<<<<< Updated upstream +oocsp +ooextendable +ooextendablealong +======= +ooconf +oocsp +ooextendable +ooextendablealong oof ooffset +>>>>>>> Stashed changes +oogroup +oogrouphom +ool +oom +<<<<<<< Updated upstream +======= oone +>>>>>>> Stashed changes +oonfq +ooniq ooo +ooonfq +oooniq ooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo oooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo +oooospooky +ooops +<<<<<<< Updated upstream +======= +oop +>>>>>>> Stashed changes +oopathsplit oopb +oops +oopsie +<<<<<<< Updated upstream +oor +oord +oorderaxiom +======= ooption +oor oord oorder +oorderaxiom +oordered +>>>>>>> Stashed changes +oori +oorp +oorst oosijhwtsierhcwgtwvu +oosn +opa opab opabbi opabbid @@ -58062,11 +95828,13 @@ opabco opabdm opabex opabf +opabfi opabid opabidw opabiota opabiotadm opabiotafun +opabm opabn opabresex opabresexd @@ -58077,35 +95845,93 @@ opabssi opabssvv opabssxp opabssxpd +opacity opad +opadcont +opadd opaddequiv +opadloop +opadseq +opadx +opainf opair +opalgebra opalgequiv +opanan +opaodv +opap +opapp +opaq +opaqnan opaque opaquedecl +opaqueerror +opaquefunc opaqueinfo opaqueprop +opaqueuser +<<<<<<< Updated upstream +oparg +opargs +======= +oparcontract +oparg opargs +opartialorder +oparts +>>>>>>> Stashed changes +opasnan +opassign +opaw +opax +opaz +opazero opb +opbgeopa +opbhi +opbinargs +opbinf +opblong +opbnan +opbqnan +opbr opbrop +opbsnan +opbw +opbz +opbzero opc +opcall +opcalls +opcar opcatcat opcatcatax opcatcatext opcatopcat opccdqywzomvjaavidxf +opcd +opcdr +opclass opco +opcod +opcode +opcoded +opcodes opcom opcomm opcomp +opcompatible opcompshrinkyonedaobj opcompyonedasectionsequiv opcon opcons +opconsp opcontinuouslinearequiv opcoproductisoproduct opcospan opcounitiso +opcurrheap +opcurrheaptonumlist opcycles opcyclesfunctor opcyclesfunctoriso @@ -58124,10 +95950,11 @@ opcyclesopiso opcyclesopnatiso opcyclestocycles opcyclestoe +opd +opderef opdontchangestpsp opdontchangestpss ope -opeek opelcn opelcnv opelcnvg @@ -58135,6 +95962,7 @@ opelco opeldifid opeldm opeldmd +opeldmg opelf opelid opelidb @@ -58154,14 +95982,19 @@ opelopabga opelopabgf opelopabid opelopabsb +opelopabsbalt opelopabt opelreal opelrelex opelres opelresdm +opelresg opelresi opelrn +opelrng +opelssetsn opelstrbas +opelstrsl opeluu opelvv opelvvdif @@ -58172,12 +96005,20 @@ opelxpi opelxpii open openaddsubgroup +openai +openauth +openauthpsk +openball +openbase openbya openbyf opencell openclassic openclassical openclassicallinter +openclosed +openclosedset +openclosedsetlatt opencomment opencover opencoverbasicopentop @@ -58191,20 +96032,41 @@ opencoverofmapirrelevanteqtop opencoverofright opendecl opendecls +opendir +opene opened openembedding +openequivalence +opener +openers +openfile +openfilefs +openhypercube +openhypercubes openi openin openind +opening +openinsetbuffersize openintervals +openk +openlatt +openly openmap +openmcl +openmod +openn +openneighborhoods openness opennhds opennhdsof +openning opennormaladdsubgroup opennormalsubgroup +opennucleus openofelementhom openorm +openp openpart openpartialhome openpartialhomeomorph @@ -58212,6 +96074,7 @@ openpartialhomeomorphcoe openpartialhomeomorphsubtypecoe openpcp openpos +openpsk openpsp openpss opens @@ -58222,6 +96085,7 @@ opensegment opensequiv opensfunctor opensgi +openshop opensimagepreimagemap openslecover openslecovercocone @@ -58233,47 +96097,83 @@ opensofcompl opensofideal opensrange opensrestrict +openssl +openstdin +openstdinsetbuffersize opensubgroup opent opentheory opentheorymap opentolocalization +opentouids +openup openv +openvalue openz opeo opeoaltv opepi opeq opeqex +opeqexb opeqpr opeqsn opeqsng +opequal opequiv opequivalence opequivopover opequivopunder oper +opera +operaci +operaciones operand +operandi +operandinfo operands +operandstack +operandstackis +operant operat operate operated +operateonempty +operateonnewempty operates +operati operating +operatio operation +operationa operational +operationally +operationb +operationp operationproperties operations operationsandinfty operationsandorder +operationscoveredbymatch operative operator operatorname +operatorp operators +opername +opernames +opers +opersymbol opex +opexb +opexg opexmid opf +opfequiv opfi +opfiso +opflagscf +opflagsof opfp opfunctor opfunctorcompfst @@ -58282,7 +96182,9 @@ opfunctorcompsnd opfunctorinvolutive opfusgr opfv +opg opgpgvtx +ophi ophom ophomcompwhiskeringlimyonedaisococones ophomeomorph @@ -58298,10 +96200,40 @@ opiedgfvi opiedgov opiedgval opifismgm +opifismgmdc +opimm +opinfo opinv opinverse opiota +opipebll opiso +opj +opkabssvvk +opkabssvvki +opkelcnvk +opkelcnvkg +opkelcok +opkelcokg +opkelidkg +opkelimagek +opkelimagekg +opkelins +opkelopkab +opkelopkabg +opkelsikg +opkelssetkg +opkelxpk +opkelxpkg +opkeq +opkex +opkey +opklefing +opkltfing +opksnelsik +opkth +opkthg +opl opla oplax oplaxfunctor @@ -58311,27 +96243,37 @@ oplaxmonoidalfunctor oplaxtrans ople oplecon +opleftif oplem +opless oplinea oplinearequiv oplinearisometryequiv +oplist +<<<<<<< Updated upstream +======= opls +>>>>>>> Stashed changes opltcon opltn oplus opm opmap opmaptrianglecomptriangleopequivalenceinverse +opmask opmetricspace opmpoismgm opmulequiv opn opname +opnatp opnbnd opncld opncldeqv opncldf +opnd opndisj +opnet opnfbas opnlen opnmbl @@ -58377,16 +96319,22 @@ opoccl opococ opoe opoealtv +opoint +<<<<<<< Updated upstream +======= opoly +>>>>>>> Stashed changes opop opopcommshift opopequivalence oporderiso opos +oposet +oposite oposlem +opotype opow opowaux -opower opp opparallelpairiso oppbounded @@ -58434,11 +96382,16 @@ oppcuprcl oppcval oppcyon oppczeroo +oppe +oppeb +opped +oppek oppf oppfdiag oppff oppffn oppffunc +oppfo oppfoppc oppfrcl oppfrcllem @@ -58475,11 +96428,25 @@ oppgtset oppgval opphl opphllem +oppi +oppk +oppkl +oppl +opplr +opplrp +oppmx +oppn oppne oppnid +oppo +opponent +opportunities opportunity +oppose opposed +opposedatvertex opposet +opposing opposite oppositeequivalence oppositeleftaction @@ -58492,20 +96459,32 @@ opposites oppositeshift oppositeshiftfunctoradd oppositeshiftfunctorzero +oppositesideflip +oppositesidesymmetric opposition +oppox +oppp oppperpex +opppt +oppq oppr opprablb opprabs oppradd +oppraddg opprb opprbas +opprbasg opprc opprd opprdomn opprdomnb +opprdomnbg opprdrng oppreqg +oppreserving +opprex +opprfcte opprgrpb opprirred opprk @@ -58514,13 +96493,19 @@ opprlidlabs opprmndb opprmul opprmulfval +opprmulfvalg +opprmulg opprmxidlabs opprneg +opprnegg opprnsg opprnzr opprnzrb +opprnzrbg +opprod opprodisocoprod opproductisocoproduct +opprpred opprqus opprqusbas opprqusdrng @@ -58528,13 +96513,23 @@ opprqusmulr opprqusplusg opprring opprringb +opprringbg opprrng opprrngb +opprrngbg +opprsllem opprsubg +opprsubgg opprsubrg opprsubrng +opprsubrngg opprunit +opprunitd opprval +opprvalg +opps +oppsign +oppt opptgdim oppu oppv @@ -58553,34 +96548,59 @@ oprabco oprabex oprabexd oprabid +oprabidlem oprabidw oprabrexex oprabss oprabv +oprc oprcl +oprec +opred +opref +oprefix +opreg opres opreu opreuopreu +oprewrite oprg +oprightif opringequiv +oprm oprod +<<<<<<< Updated upstream +======= oprof +oprogram +>>>>>>> Stashed changes +oproj +oprojective opropabco oprpiece oprres +oprs oprssdm +oprssdmm oprssov oprswap ops opsa opsbc opsc +opscompatible +opset +opsexp opsh opshiftfunctorequivale opshiftfunctorequivalence opshiftfunctorequivalencesymmhomequiv +opsignature opsize +opsk opsmul +opsnelsi +opso opspan opsqrlem opsr @@ -58599,18 +96619,38 @@ opsrtos opsrtoslem opsrval opsrvsca +opstack opstrgric +opsub opswap +opswapg +opsym +opsymbol +opsymbolp +opsymbolsof opsymm opt +opta +optact +optaddedge optattr optattrarg +optb +optbind optbinderident +optbool +optc +optcase +optci optconfig optconfigof +optcutset optdeclsig +opte +opteqn optge opth +opthd opthg opthhausdorff opthi @@ -58627,20 +96667,38 @@ optia optid optim optimal +optimald optimalghcoupling optimalghdist optimalghinjl optimalghinjr +optimali optimality optimisation +optimise +optimised optimistic +optimizaiton optimization optimize +optimized +optimizep +optimizing optimum +optio option optional +optionalbytes +optionalcountingnumber +optionalcountingnumbercorrect +optionalletlet optionally +optionalmapissafebecauseitisinmemory +optionalsequenceissafebecauseitisinmemory +optioncomparable +optioncomparableusualeq optioncongr +optionefct optionelim optionembeddingequiv optionequiv @@ -58648,30 +96706,71 @@ optionequivalence optionequivleft optionequivright optionequivsumpunit +optionfinite optionfintype optionissomeequiv +optionlift optionmap +optionmonad optionname +optionoverride +optionp optionprodequiv options +optionsp optionsperpos optionsubtype optionsubtypene optiont +optionterror optionval optk +optl +optlannot +optlemma +optlift +optlist +optlx +optly +optmap +optmapcong +optmapimage +optmax +optmemc +optmin +optmmap +optns optocl optoclold optofnat +optout optparam +optpm +optrange +optreg +optrel +optry opts +optset +optsexp optswap +opttemp +optty +opttyp opttype +opttypeqn +optv +optval +optvalue +optvar +optype opuniformequivleft opuniformequivright opunitiso opunopequiv opunopiso +opv +opval opvtxfv opvtxfvi opvtxov @@ -58681,61 +96780,112 @@ opwf opwfi opwo opx +opxmm +opyon +opyoneda +opz +opzero +oqelins +oquality +ora orab orabs +orac +oraca oracle +oraclearbitrary oraclecomp +oraclecompmonad oraclei oraclekind oraclemap +oracleproperty +oracles +oraclewf +oralce oran oranabs +orandc +orange +<<<<<<< Updated upstream +======= oranges +>>>>>>> Stashed changes +oranim +orap orass +orassociative orb orba +orbac +orbaca orbb orbc +orbca orbf orbi orbidi +orbididc +orbile orbit orbital orbitali orbitcl orbitclmpt +orbite orbitequivquotientstabilizer orbitex +orbiti orbitinit +orbitj +orbitjs +orbitp orbitprods orbitprodstabilizerequivgroup +orbitr orbitrel orbitrelequiv +orbitrs orbits orbitzmultiplesequiv orbitzpowersequiv +orbk +orbn orbs orbsta +orbstab orbstafun orbstaval orbt orc +orca orcanai orcc orcd orci +<<<<<<< Updated upstream +======= orcis +>>>>>>> Stashed changes +orcl orcnd orcom orcoma orcomb orcomd orcomdd +orcommutative orcoms orcs ord orda +ordadd +ordav +ordaxiomcheck ordb +ordbasis +ordbool +ordcheck ordcmp ordco ordcompl @@ -58747,7 +96897,12 @@ ordconnectedsection orddi orddif orddisj +orddiv +orddivision +orddivmod orde +ordec +ordef ordeldif ordeldifsucon ordeleqon @@ -58760,6 +96915,9 @@ ordelpss ordelss ordelssne ordelsuc +orden +ordenado +ordenadop ordeq ordequn order @@ -58767,6 +96925,8 @@ orderable orderaddmonoidequiv orderaddmonoidhom orderaddmonoidiso +orderaxiom +orderbool orderbornology orderbot orderbotofhasinitial @@ -58776,6 +96936,7 @@ orderclosedtopology ordercore ordercoreimp orderd +orderdec orderdual orderdualequivalence ordere @@ -58784,6 +96945,7 @@ orderedaddcommgroup orderedaddcommgroupwithone orderedaddcommmonoid orderedaddcommsemigroup +orderedalgfam orderedcanceladdcommmonoid orderedcancelcommmonoid orderedcomm @@ -58792,18 +96954,26 @@ orderedcommmonoid orderedcommring orderedcommsemiring ordereddiv +orderedequation orderedfinpartition orderedgroup orderedinsert +orderedmonad orderedmonoid +orderednat +orderedness orderedp orderedpartition orderedring orderedsemifield orderedsemiring +orderedset orderedstructure orderedsub orderedsubtype +orderedtest +orderedtype +orderedunitarycommutativering orderedweight orderedzero orderembedding @@ -58822,8 +96992,10 @@ orderhom orderhomclass orderhomofsimplex orderi +orderin ordering orderings +orderinvolutive orderiso orderisobool orderisoclass @@ -58868,8 +97040,13 @@ orderisosubtype orderisosumlexpunit orderisotriple orderisounitintervalbirational +orderj orderlemmas orderlhom +orderlt +orderly +orderm +ordermap ordermonoidequiv ordermonoidhom ordermonoidhomclass @@ -58878,8 +97055,13 @@ ordermonoidisoclass ordermonoidwithzeroequiv ordermonoidwithzerohom ordermonoidwithzerohomclass +ordernbhstype orderof +orderp orderpred +orderpreserving +orderred +orderreflecting orderrel orderringhom orderringhomclass @@ -58887,6 +97069,14 @@ orderringiso orderringisoclass orders orderseqlem +ordersortedrelation +ordersortedrelations +ordersortedset +ordersortedsets +ordersortedsign +ordersortedsubse +ordersortedsubset +orderspred orderstructure ordersucc ordertheoreticjoinsemilattice @@ -58895,69 +97085,134 @@ ordertheoreticmeetsemilattice ordertop ordertopofhasterminal ordertopol +ordertopologicaltype ordertopology ordertopsubonepos ordertoptotypesucc ordertype +orderunivalentstr +orderv +orderxdiv +orderxdvd +orderxexp +orderxgcd +orderxpfactor +orderxpnat +orderxprime orderzeroneone +ordexp +ordf +ordfeminine ordfin ordfr ordfrac +ordfresh ordg ordge +ordgi ordgt ordi +ordii ordin +ordina ordinal ordinalapprox ordinaldiv +ordinales +ordinalgi +ordinali +ordinalind +<<<<<<< Updated upstream +======= ordinalirrefl +>>>>>>> Stashed changes ordinalle +ordinallemma ordinallt +ordinalmin +<<<<<<< Updated upstream +======= ordinalminlem +>>>>>>> Stashed changes ordinalmod ordinalmul -ordinalnocycle ordinalnpow +ordinalofordinals ordinalopow +ordinalp ordinalpool ordinalpred +ordinalps ordinals +ordinalstructure ordinalsub -ordinalthreadpo +ordinalsubtractionisnatural +ordinalsubtractionunderflow +ordinaltests ordinalthreadpool -ordinaltransset ordinar +ordinarily ordinary ordinaryhypergeometric ordinaryhypergeometriccoefficient ordinaryhypergeometricseries +ordinarymethod +ordinaryobjectspossiblyconcrete +ordinaryp ordinate ordintdif ordir ordirr ordiso +ordk +ordkv +ordle ordleq +ordlessp +ordlet +ordlist +ordlistns +ordlog +ordlt +ordlte +ordmap +ordmasculine +ordmod +ordmodel ordmonoidwithzerohom +ordmul +ordmult ordn +ordnat ordnbtwn ordne ordnexbtwnsuc ordno ordnode +ordof ordom ordon +ordp ordpinq ordpipq +ordpipqqs +ordpr ordproj ordpss ordpwser ordpwsuc +ordpwsucexmid +ordpwsucss +ordr ordre +ordrel ords ordseparatingset +ordseqofunivex ordset ordsmul +ordsoexmid +ordsort ordsseleq ordsson ordsssuc @@ -58966,15 +97221,18 @@ ordsssucim ordssun ordst ordstns +ordsub ordsuc -ordsucc ordsucelsuc +ordsucg ordsuci +ordsucim ordsucss ordsucsssuc ordsucun ordsucuni ordsucuniel +ordsucunielexmid ordsum ordt ordtbas @@ -58996,11 +97254,14 @@ ordtopt ordtprsuni ordtprsval ordtr +ordtrapspace ordtrest ordtresticc ordtrestixx ordtrestnew ordtri +ordtriexmid +ordtriexmidlem ordtt ordttop ordttopon @@ -59009,6 +97270,7 @@ ordtval ordtype ordtypecbv ordtypelem +ordu ordun ordunel orduni @@ -59020,22 +97282,34 @@ orduniss ordunisssuc ordunisuc ordunpr +ordv ordvdsmul ordwe +ordz +ordzero +ordzm ordzsl ore oreach +<<<<<<< Updated upstream +======= oreal orec +>>>>>>> Stashed changes +oreceived orecondition orecvmsg orecvmsgei +ored oredenom orediv oredivaddchar oredivmulchar oredivsmulchar oreeqv +orefl +oreg +oregs orel orelim orelocalization @@ -59043,7 +97317,10 @@ orelocalizationinstalgebra orelocalizationinstcommring orelocalizationinstmonoid orelse +orelsec +orelset orenum +oreq ores orescnv oreset @@ -59051,57 +97328,105 @@ oresetcomm oresetofiscancelmulzero oresetofnozerodivisors oresf +oresp oresrab +oresvar +oreturn +<<<<<<< Updated upstream +======= +orev +>>>>>>> Stashed changes +orexmid +orexmidim orf orfa +orfalseneutral orfb orfelim orfintrol orfintror orfl +orfp orfr org -organisation organised -organism organization +<<<<<<< Updated upstream +======= organizationalprocess organizations +>>>>>>> Stashed changes +organize +organized orge +orginal +orgm +orgs +orgtm +orgv orgvd +orh ori oridm orient orientable orientation -orientationvector oriented orientedcmp +orientedcycle +orientedly orientedord +orientedpath +orientedpaths orig +origaliases +origexprs +origfn +origi origin +origina original originally originals originaltop originalty +originate +originates origination +originator origins +origlongmap +origname +orignames +origshortmap +origsign origspan origsubstring +origtype +origwidth +origx +oril orim orimdi +orimdidc +orimm orimpl orimpr +orinally oring orinl orinr +orir orit +orkb orl +orlem +orlimm orm ormkglobd ormklocald orn +ornb orneg orng ornglmulle @@ -59113,21 +97438,41 @@ orngring orngrmulle orngrmullt orngsqr +orni ornld ornlem ornot +ornp orodd orold +oroot orop orordi orordir orp +orpa +orpd +orpf orphan orphaned +orpn +orpp +orps +orpt orr +orra +orrab orrabdioph +orrac +orrc +orrca orrd +<<<<<<< Updated upstream +======= orrect +>>>>>>> Stashed changes +orrel +orrelpr orri orrnlheiaykqopa orrot @@ -59138,11 +97483,21 @@ orrx ors orsild orsird +orso +orst +orsym +orsys ort +ortafpl +ortafsp ortb +orte orth +ortha +orthagonal orthant orthcom +orthgoonal orthin ortho orthocenter @@ -59150,29 +97505,56 @@ orthocentre orthocentric orthocentricsystem orthocompl +orthocomplement +orthocomplemented orthog +orthogo orthogon orthogonal orthogonalbilin orthogonalcomplement +orthogonald orthogonaldecomposition orthogonalfamily orthogonalgroup orthogonalidempotents orthogonality orthogonalmap +orthogonalp orthogonalproj orthogonalprojection orthogonalprojectionfn orthogonalprojectionspan orthogonalreflection +orthogornal +orthojoin +ortholattice +ortholattrelstr +ortholattstr +orthomodular orthonormal orthonormalbasis orthonormalbasisonei +orthonormale +orthonormalfamily orthonormalframe +orthonormalp orthonormalsets +orthop +orthopl +orthoposet +orthopr +orthorelstr orthradius +ortm +ortp +<<<<<<< Updated upstream +======= +ortrancl +>>>>>>> Stashed changes +ortsp orv +orval orvalt orvc orvccel @@ -59183,154 +97565,447 @@ orvclteel orvclteinc orvcoel orvcval +orw +orwl orxcslklti orxorb orzechproperty orzero osafe +osafree +osalg +osalgebra +osalgebras +<<<<<<< Updated upstream osauiadtkjsem +======= +osat +osauiadtkjsem +osays +>>>>>>> Stashed changes +osbool osc osceq +oscillate oscillation oscillationwithin +oscl +oscla +osclass +oscng +<<<<<<< Updated upstream +======= +osconf +>>>>>>> Stashed changes +oscongruence +osconstants oscstat oscstatpcp oscstatpsp oscstatpss +osdef ose +osel +<<<<<<< Updated upstream +oset +osetex +osets +======= osemilattice +osemiring +oseq +oserver +oset osetex osetlocs +osets +osetsum +>>>>>>> Stashed changes +osexist +osf +osfree +osfreegen +osfxsr +osgeneratorset +oshift +oshl +oshomquot +oshr +<<<<<<< Updated upstream +osi +osig +osing +osingleton +osize +======= +oshrk +osi osig +osin +osing +osingleton +osize oskip +>>>>>>> Stashed changes osl +oslambda oslash +oslib +osmall +osmpl +osmsubsort +<<<<<<< Updated upstream +======= osmult +>>>>>>> Stashed changes osn +osnat osng +osome osomme +osp ospec +ospecd +<<<<<<< Updated upstream +======= +ospy osqrt +>>>>>>> Stashed changes +osquotcharact +osquotres +osrc +osrel +osresult +osresultl +osresults oss ossf ossgoevmijzrklthcmgnllqatskectn +ossign +ossort +ossr +ossub +ossubalgebra +ossuballattice +ossubset +ossubsets +ossubsort +ossym +ost +ostack +ostart ostate +ostates +ostensibly +ostream +<<<<<<< Updated upstream +======= +ostrict +>>>>>>> Stashed changes +ostrictlimit +ostrictlimitd ostrik +ostring ostrowski ostth ostthlem +osub +<<<<<<< Updated upstream +osubset +======= osubseq +osubset +osubst +>>>>>>> Stashed changes osuc osucc +osuce osum osumcllem osumcln osumcor osumcori osumi +<<<<<<< Updated upstream +======= osup +>>>>>>> Stashed changes +osv +osxsave +osym +osyntax +<<<<<<< Updated upstream +otag +======= +osynth +otag +otakewhile +>>>>>>> Stashed changes otel +otelins +oteltxp otelxp oteq oteqex oteqimp oterm +otest otex +otexg +otf +<<<<<<< Updated upstream +======= +otfin +>>>>>>> Stashed changes +oth othe other +otherassignments +otherbot +othercases otherd +othereq +otherheap +otherlast othermap othernats +otherparam others othersd +otherstate +otherunresolvedfunction +otherval othervertexofincident +otherw otherwise +otherwith othin +<<<<<<< Updated upstream +======= +othis +othms +>>>>>>> Stashed changes +otho othogonal +othor +othorgonal +<<<<<<< Updated upstream +======= +othrow +otiling +>>>>>>> Stashed changes otimes otiunsndisj otiunsndisjx +otkelins +otmtotj +<<<<<<< Updated upstream +======= otop ototal +ototalize +>>>>>>> Stashed changes otp otpsbas otpsle otpsstr otpstset +otr otrans otrg otrgds otrge otrgitv -otriple otrspeq +otrue +<<<<<<< Updated upstream +======= +otrycatch +>>>>>>> Stashed changes +ots otsciaf otsndisj +otsnelsi +ott +otter otth otthg otthne ottpos +ottposg +otvars +oty +<<<<<<< Updated upstream +======= +otype +otypeof +otyping +otypings +>>>>>>> Stashed changes +ouch ouctuitvlkowhtemrpqxucjbftmih oudbjnobkq +ouex ought oul oull -ouminus oun +ounion +ounit +ounitl +<<<<<<< Updated upstream ounsn +ouo +oup +oupex +======= +ounity +ounsn +ouo +oup oupdate +oupex +oupper +>>>>>>> Stashed changes ouput our +ours ourselves +<<<<<<< Updated upstream +======= +oused +>>>>>>> Stashed changes +ouside out +outa +outalist outarc outarcs +outarr +outb +outbds +outbound +outbox +outbuf +outc +outcirc +outcircle +outcircles outclm outcome +outcomeresult outcomes +<<<<<<< Updated upstream +======= outcompetes +>>>>>>> Stashed changes +outcont +outcounts +outcs +outdata +outdegree +outedges +outelement +outentry +outentrylist outer +outerattrs +outerconnectivity outerfiveseg outerfriendids outerfullyfaithful +outerga +outerloop outermeasure outermeasureclass +outermorphism +outermos outermost +outerold outerr outerregular +outershareable +outersize +outervx +outexpr +outexprs outflow +outfnname +outfromchcorrect +outfromchcorrectsystem outfromv +outfromvcorrect outgoing +outgoingreferencesareinthisheap +outgroup +outgrow +outh outidx outidxexpr outidxq +outkeys +outl outline outlined +outlink +outlits +outlives +outlivesimpliesalive +outlivesimpliesalivehelper outmeas outmkequiv +outneighbors +outnum outof +outofbounds outofmemory +outofreach +outok outp outparam +outparametersinletbodies +outparamsunderlambdas outpasch +outport outports outportsrule +outps +outpt +outpu +outpurge output outputalphabet +outputbyt +outputbytelen outputempy +outputheap +outputlin +outputline +outputmatch outputmessage +outputparameters +<<<<<<< Updated upstream +======= outputr +>>>>>>> Stashed changes outputs outputsfun outputsintime outputting +outputv +outq +outr outrelembedding +outrem +outright +outruns outs outsetcorelated outsetcorelatedempty outsetcorelatednonemptyx outsetofcomponents outsetofcomponentslimit +outsi outside outsidele outsidene @@ -59341,14 +98016,37 @@ outsideofeq outsideofeu outsideofrflx outsideoftr +outsideoutside outsidepart outsideregularcone +outsiders +outsideunion outsp +outst +outstanding +outstc +outstr +outstream +outthat +outthis +outtypes +outvars +outward +outwards ouu oval ovanraleqv +ovar +ovbi +ovce +ovcelem +ovcongruen +ovcongruent ovconst +ovcross ovd +ovdi +ove ovelimab ovelrn oveq @@ -59359,13 +98057,16 @@ oveqi oveqprc oveqrspc over +overaggressive overall overapplied overapprox +overapproximate overapproximated overapproximates overarrows overclass +overedges overengineering overequi overequiv @@ -59373,20 +98074,43 @@ overequivalence overequividealsheafdata overequivofisinitial overequivpresheafcostructuredarrow +overf overfin overfiniso +overflo overflow +overflowed +overflowflag +overflowintosurrogaterange +overflows +overflowsp overforget overgrothendiecktopology +overhangs overhead +overkill overlap +overlapi +overlapn overlapping +overlappingi overlaps +overlapsi +<<<<<<< Updated upstream +======= overlapstemporally +>>>>>>> Stashed changes overlay overlayed overline +overload +overloadable +overloaded +overloadedmssign +overloadedrssign overloading +overloads +overly overmapcomppresheafhomiso overmappullback overmappullbackcomp @@ -59395,34 +98119,75 @@ overmappullbackid overmkhom overmorphism overobj +overpathfunct overpost +overpower overpretopology overprime overpullback overpushforwardoveradj +overr +overri +overrid override overrideallowedimportdirs +overrideconds +overridek +overrideke +overridekey +overridekeys +overrideline +overridemux overridepost +overrider +overridermethoddefs overrides +overridet +overridetr +overridetriples +overridetype +overridetypelist overriding +overshft +oversize +overspill +overt overtocoalgebra overtosort +overture overview overwhelmingly overwrite +overwrites +overwriting +overwritten ovex ovexd +ovexg ovexi +ovf +ovfi +ovfl ovg ovi ovid ovidi ovidig +oviec ovif ovig ovigg ovima +ovious ovl +ovlcon +ovlldiff +ovlp +ovlpart +ovlrdiff +ovmi +ovmonot +ovmonotonic ovmpo ovmpoa ovmpod @@ -59441,8 +98206,8 @@ ovmpot ovmpox ovmpt ovmptss +ovmuc ovn -ovname ovncl ovncvr ovncvrrp @@ -59465,6 +98230,7 @@ ovnsubaddlem ovnsupge ovnval ovnxrcl +ovoid ovol ovolcl ovolctb @@ -59508,82 +98274,168 @@ ovolunlem ovolunnul ovolval ovprc +ovr ovrcl ovres ovresd ovrspc +ovs ovscd ovscpbl +ovshftex +ovsi +ovsimilar ovsn ovsng ovssunirn +ovssunirng +ovtestequiv +ovtests +ovtestsimilar ovtpos +ovtposg +ovu ovv +ovy owa owaqgmcs owe owealt +owed owev +owf owhile +owicz +<<<<<<< Updated upstream +======= +owiden +>>>>>>> Stashed changes owl own owned +ownedby +ownedobject owner ownerclose +ownerhip ownerp ownership +ownershipd +ownershipi +ownershipregionsaredisjoint owns ownsd +ownsymbolsof owo owp +owrt +<<<<<<< Updated upstream +======= owt +owtrt +owtrts +>>>>>>> Stashed changes +owzlkvy oxhacqxnokmewkt oxlr +oxlzlez oxmet oxms +oxor oxpnn -oxygen oyfwimyhelvuxibskw oyon oyoncl oywdtfknhillmmqlhye +oyy +ozef ozero ozfuodurlgwfvamjqhs +ozqvsff ozrpzvheidyb paa +paabf pab +pabort +paborted +paboundedlt pabr +pabs +pabsi pac pacipfsvw pack package packaged +packagelist +packagep +packages +packbv +packbvs +packe packed +packeddimension +packeddimensionlist +packedp +packer packet +packetp packets packing packingnumber packingradius packkeyedpred +packlittle +packn +packpq +packsocle +packsoclek +packsyms +packtuplewithstringwrapped paco +pacoacc +pacobot +pacofold +pacomult +paconsistent +pacounfold pad padboth +padbyte padct padd paddass paddasslem paddatcln +paddb paddcln paddcom +paddd +padde padded paddeddeps paddedheaders paddedlines +paddedparsed +paddedpartialfrom +paddedseq paddedtable paddedthms paddfval +paddi paddidm padding +paddingalgorithmstring +paddingbits +paddinghelper +paddingiscomplete +paddingpropertieshelper +paddingscheme +paddis +paddl +paddr +paddress +paddrs paddss paddssat paddssw @@ -59591,6 +98443,8 @@ paddunn paddunssn paddval paddvaln +paddze +padec padic padicabv padicabvcxp @@ -59605,6 +98459,7 @@ padicint padicintequiv padicnorm padicnorme +padics padicseq padicv padicval @@ -59614,12 +98469,18 @@ padicvalnat padicvalrat padicvalua padicvaluation +padl padleft +padlen padright +pads padwidth paesqwwkb +paf +pafunctor pagano page +pagebits paged pagedbetree pagedbetreerefinement @@ -59630,99 +98491,244 @@ pagehomologynatiso pagelib pagemap pageorg +pagep pages +pagesi +pagesp pagetable pagex pagexiso pagexisoofeq +pagi +pagin +paging pai paid paidaa paidanm +pain +paincomplete +painf painful +painlessly paint -painting pair +pairagentset +pairalg +pairarg +pairbound +pairc paircomp +paircomparable +paircomparableleibnizeq +paircomparableusualeq +pairconstconst +paird +pairdifference paire paired +pairedfntype +paireq +paireqlemma paireqne pairequiv +paireta pairf +pairfn +pairfree +pairfst +pairfunc pairfunction +pairg pairi +pairin pairing pairingcore pairingdual +pairingfun pairingin +pairings +pairints +pairintsfirstzero pairinv pairk +pairl +pairlength +pairli +pairlis +pairlist +pairlistp pairmap +pairmapcong +pairmapid +pairmapimage +pairmapk +pairmapo +pairp +pairpm +pairprod +pairq pairreueq pairs pairsd +pairself pairselfadjointmatricessubmodule pairsep pairset +pairseta +pairsetb +pairsetfamily pairsetseq pairsi +pairsnd pairsof +pairsp +pairsup +pairsx +pairt +pairtie +pairtrue +pairu +pairuniversal pairup pairw pairwis pairwise pairwisecases pairwisecoconeiso +pairwised pairwisediagramiso pairwisedisjoint pairwisedisjointallocations +pairwiseeq +pairwiseequal +pairwisen pairwisenode pairwisetoopenslecover pairwisetoopenslecovermap pairwisetoopenslecoverobj +pairxcy +pairxcyf +pairz pal palatable paley +palin palindrome +pall +pallmall +palt +palways +pam +pan +pancake +pancakent +pand +pandc +pandi +pandis +pandora panel panels panelwidgetprops +panexps panic panics +panlang panll +panop +panops +panptreeconversion +pansem +pany paodv +pap +papdesaf paper paperid paperidasstr paperids papid papidsofrole +paplussym papp pappack +pappian +papplicative +papply +pappus +papt par para paraboliceigenvalue parabolicfixedpoint +paraclosed +<<<<<<< Updated upstream +======= paraco +>>>>>>> Stashed changes paracomp paracompact paracompactspace +paradigm paradox paradoxes paragraph +paragraphp +parahalting paral +paralell parall parallel +parallelbetween +parallelbuildstheorem +parallelclockwise +parallelcollinear +parallelcollinearabc +parallelcollinearabd +parallelcollinearcda +parallelcollinearcdb parallelcom parallelcomp +parallelconseqrule +paralleldef parallelepiped parallelex parallelfamily +parallelflip +parallelgcd +parallelhalfline parallelise parallelism +parallelity +parallellines +parallellogram +parallelnc +parallelnotclockwiseabc +parallelnotclockwiseabd parallelogram +parallelogramm +parallelogrammcenter +parallelogrammcenterbetweenbid +parallelogrammcenterclockwiseabi +parallelogrammcenterclockwiseaid +parallelogrammcenterclockwiseibc +parallelogrammcenterclockwiseicd +parallelogrammcentercongruenttriangles +parallelogrammcentermidpointbd +parallelogrammclockwisebcd +parallelogrammclockwisebda +parallelogrammcongruenttrianglesac +parallelogrammcongruenttrianglesbd +parallelogrammdistinctab +parallelogrammdistinctac +parallelogrammdistinctcd +parallelogrammextern +parallelogrammparallelogrammbetween +parallelogrammpermut +parallelogrammsuperimposed +parallelogrammsym parallelograms -parallelopiped parallelpair parallelpairdiagram parallelpairdiagramofiscolimit @@ -59734,81 +98740,182 @@ parallelpairisomk parallelpairisoparallelpaircompindyoneda parallelpairisoparallelpaircompyoneda parallelpairopiso +parallelpasch parallelprod parallelrec +parallelrule parallelruleann +parallels parallelscan parallelscanaux +parallelshape +parallelstatement +parallelsymmetric param paramcls +paramd +paramdecl +paramdecllist +paramdecls paramdefs paramdefse +parame parameter +parameterborrows parameterised +parameterize +parameterized +parameterizedstatements parameters +parametre parametric +parametrically parametricattribute +parametriccompleteness parametricintegral +parametricity +parametricseparationlogic parametrize parametrized parametrizedadjunction +parametrizednno +parametrizes +parami paraminfo +paramispr +paramlistnt +paramm paramnames +paramnum +paramod +paramodulant +paramodulating params paramset +paramsettings +paramsnodup +paramsp paramsstructure +paramsv +paramtype paramuses +paramvalue +paramvaluelist +paraphrase +parching +parciales +parcode +<<<<<<< Updated upstream +======= +parcontract +>>>>>>> Stashed changes parcs +pardepap +pardir +pardon pardord pare +paremetrized paren parens parensifspace parent +parentchild parentdag parentdecl parentheses parenthesis parenthesizer +parenthesizing parentinfo parentngen parentprojdata parentprojs parents +parentsofar +parentsp parenttag pareto paretocdf +paretod +paretoi paretomeasure paretopdf paretopdfreal +parfoo parg pargs +parhom +parial parikh paris +parition parity +paritygame +paritym +park parl +parler +parlis +parmove +parms +parnotmeet parof +parortstr +parp parr +pars parse +parseamazondyna +parseamazondynamodbresources +parseamazondynamodbtablear +parseamazondynamodbtablearn +parseamazondynamodbtablename +parseandprettyprinttests parsearrows parseastacticseq +parseawskmsarn +parseawskmsarncorrect +parseawskmsidentifier +parseawskmsrawresources +parseawskmsresources +parseawskmsresourcescorrect +parsebar parsebinderident parsebound parsec parsechoosearg +parsecnj +parsecode +parsecommandlineoptions parsecompandexpr parsed +parsedecryptcmd parsedimacs parsedischarger parsedprojectiondata +parsedsj +parsedterms +parsedtermsosa +parseencryptcmd +parseencryptmanifestcmd +parseerror +parsefgx +parsegamma parseheader +parseimp parseimports parseint parseints +parseipv +parsekeynamespaceandname parseline parselrat +parsem parsenat parsenats +parsepublickey +parsepublickeyensurespublicly parseq parser parsercategory @@ -59822,33 +98929,67 @@ parsers parserstate parses parsesetoption +parsestate parsestyleexceptions parsesuggestiontotactic +parsesymbol +parsetree +parseu parseuptohere parseval +parsi parsing +parsingactualbindings +parsingsuccessors +parsp parstar +parstep +parstr part partbind partc +partcirclepath +partd partden partdenom partdens +partdiff +partdiffseq partdom +parte partenat parteq parteval +partf +partfu partfun partfunc +partfuncex +partfuncexcd +partfuncexcs +partfuncexd +partfuncexs +partg parti partia partial partialapp +partialariant +partialbool partialboundedorder +partialconverse partialdiffeomorph partialequiv partialequivlimit +partialex +<<<<<<< Updated upstream +partialfn +======= +>>>>>>> Stashed changes +partialfnwitness partialfun +partialfunctional +partialfunctions partialfunequivpointed partialfuntopointed partialgamma @@ -59860,8 +99001,8 @@ partialleftadjointhomequiv partialleftadjointmap partialleftadjointobj partialleftadjointsource +partiallinearspace partially -partiallytangible partiallyw partiallywellorderedon partialma @@ -59869,78 +99010,156 @@ partialmap partialmatch partialorder partialorderbot +partialordered partialorderedring +partialordering partialorderofmodels partialorderofso partialorderpreorder partialordertheory +partialp partialpred partialprod +partialproducts partialrefinement partialrightadjoint partialrightadjointhomequiv partialrightadjointmap partialrightadjointobj partialrightadjointsource +partials partialsa partialsections partialsucc partialsum +partialsums partialsups +partialt +partialtothediagonal partialtraj +participant +participate +particles +particu +particul particular particularly +partid partie parties partim partimcomember partimeq +partinst +partion partips +partiqlbatchrequest +partiqlnexttoken +partiqlstatement +partir +partit +partitable +partite partiti partition partitionable partitionbytypeidx +partitioncodeunitsequence +partitioncodeunitsequencechecked +partitione +partitioned +<<<<<<< Updated upstream +partitioneithers +======= +>>>>>>> Stashed changes partitionfiltration +partitioni partitioning partitioningips +partitionintoregions +partitionl +partitionlp +partitionlr partitionm +partitionofjustheapregions partitionofunity +partitionp partitionpoint +partitionr +partitionrp partitions partitionsi partitionsums partitionsumswith +partitiont +partitionxx partitition +partititon +partlambda partlist +partly partmap partn +partnc partner +partners +partni +partnm +partnnk +partnotequalwhole +partnt partnum partnums +partnx partofvertex partord partordemb +partp partpreservingequiv partrace partrec parts partscardle partscopyequiv +partsd +partsel +partselect partseq partsequiv partsize +partsr +partstate +partstotaspi partsuc +partsum +partsums +partunion +partunionnat +partway party +partyp +parx +pary pas +pascal pascalian pasch +paschabc +pascht pass +passare +passchecks passed passes +passesprotectedfieldcheck passign passing passive +passn +passtocompiled +passtoghost passwd +passwdsafe password past paste @@ -59952,6 +99171,7 @@ pastehorizispullbackequiv pastehorizispushout pastehorizispushoutequiv pastelemma +pastend pastepullbackhoriz pastepullbackvert pastepushouthoriz @@ -59965,116 +99185,287 @@ pastevertispushoutequiv pastewise pasting pat +patalist +pataraia +patatero +patbind +patch +patchc +patchcomplementation +patchconstruction +patche +patched patches +patchinstance +patchn +patchstone +patcht +patd path +pathagreesonsubtree pathauthorization +pathbeginsleft +pathbetween +pathc +pathcard +pathcards pathcast +pathcat +pathcategory +pathcatenation +pathchange +pathcoll +pathcollapsible pathcomponent pathcomponentin pathcomponentone pathcomposition pathcompositionnaturality +pathcompression +pathcon +pathconc +pathcond +pathcondp pathconn pathconnected pathconnectedspace +pathcube +pathcycles +pathd pathdestleft pathdestright pathe +pathel pathelength pathequivlist +pather +pathetic pathexists pathextend +pathfactorization +pathfiber pathfinish pathgraph +pathi +pathidtrunc +pathidtrunciso +pathidtruncisofunct +pathidtruncs +pathind +pathintegral +pathiso +pathisoeq pathissymboliclink +pathk +pathl pathle +pathlen +pathless +pathlessp pathlist +pathmap +pathmatch +pathname +pathnamep +pathnames pathobject pathological -pathologicprocess pathoperations +pathover +pathp +pathpart +pathpatheq +pathpidtrunciso +pathpisopath +pathpprop +pathproperty +pathq +pathr pathree +pathreplistp paths +pathsat +pathscard pathsd pathseparator pathsequiv +pathset pathsetoid +pathshift pathshomrel pathsi +pathsinu pathsof pathson +pathsplit +pathsplitequiv +pathsquare pathstar pathstart +pathto +pathtoeq +pathtoequiv +pathtoequivrefl pathtofield +pathtoiso pathtolist +pathtopos +pathtoposaux pathtostx +pathtov +pathtransport +pathtransportpath pathvertices +pathwise +pathy +patience patient +patl +patmatch patom patoms +<<<<<<< Updated upstream +patpt +patricia +======= patproof +patpt +patricia patricide +>>>>>>> Stashed changes patris pats +patsexp patt +pattab pattern +<<<<<<< Updated upstream +======= patterndetectormt +>>>>>>> Stashed changes +patterned patternignore +patternkey +patternmatch +patternmatches +patternp +patternproof patterns +patternsp patts +patv +<<<<<<< Updated upstream +======= pauillac +>>>>>>> Stashed changes paul +paulix +paulixx +pauliz +paulizz pause pauses pautsetn paval +paving +paws pax +paxiom pay +payer +paying payload +payloadlen payment payoff -paysd +pays +pazeroorsucc +pbactive pbadd pbar +pbase +pbaselist pbasepoint +pbaut pbb pbbuild pbc pbcode pbcompute +pbctr +pbctrl pbd +pbefore +pbeqw pbernpoly pbeta +pbetween +pbf +pbfr pbfree pbgen +pbias +pbiginter +pbigunion pbij +pbijtt pbind pbiso +pbit +pbits pbj +pbkdf +pbl pbleaf pbleaves pbleft +pblock +pblockk +pbloop +pblr +pbn +pbnew pbnode pbo pbody +pboo +pbool pboole +pbop pbot +pbp pbqs pbrepr pbright +pbs +pbt pbtree pbuchf pbval +pbx +pbyte pca pcabs pcadd pcaddlem +pcahdtl pcall +pcaller +pcan pcancel +pcanchoicemixin +pcard +pcat +pcauchy +pcb pcbc pcbcctr +pcbus +pcc +pcchange pccl pccld +pcd pcdiv pcdvds pcdvdsb @@ -60084,22 +99475,34 @@ pceq pceu pceulem pcexp +pcf pcfac pcfaclem +pcfg pcgcd pcge +pchoice +pchoose pcid pcidlem +pcinit pcl +pclass +pclassifyingspace pclbtwnn pclcln pclcmpatn pclem +pclemdc +pclemub pclfincln pclfinn pclfvaln pclidn +pclmulqdq pclogsum +pclose +pclosed pclss pclssidn pclssn @@ -60107,12 +99510,22 @@ pclun pclunn pclvaln pcm +pcmp +pcmpeqd +pcmpeqq +pcmpj pcmplfin pcmplfinf +pcmplw +pcmplwi pcmpt pcmptcl pcmptdvds +pcmpv +pcmpw +pcmpwi pcmul +pcn pcndvds pcneg pcnf @@ -60120,15 +99533,25 @@ pcnt pco pcoass pcocn +pcode +pcoef pcof pcofval pcohtpy pcohtpylem +pcom pcomap +pcommitted pcomp pcompare pcompose +pcomps pcompset +pcon +pconcat +pcond +pconflict +pconj pconn pconncn pconnconn @@ -60139,49 +99562,89 @@ pconst pcontinuous pconts pcophtb +pcoprime +pcoprimei pcopt pcoptcl +pcore +pcorec +pcorei +pcorej +pcorenk +pcorep +pcores pcorev pcorevcl pcorevlem +pcorr +pcorrect pcorres pcorresd pcorresi +pcou +pcount +pcountable pcounter pcoval pcovalg pcp +pcpart pcpo +pcpp pcpre pcprecl pcpremul pcprendvds pcprmpw pcprod +pcpt pcqadtwgomictj pcqcl pcqdiv pcqmul pcr pcrec +pcror pcross +pcrttid pcs +pcsr pcss +pcst +pcstate +pcstorevalue +pcthat +pctr pctx pctxd +pcurve +pcv pcval pcw +pcwa +pcx pcxcl pcxnn +pcxqcl pcyc +pcycle +pcyclee +pcycles pcz pczcl pczdvds pczndvds pczpre pda +pdadde +pdaddl +pdaddr pdata +pdataspace +pdatavalue +pdb pddl +pde pdec pdeg pdeglt @@ -60192,52 +99655,124 @@ pders pdeterm pdevs pdf +pdfe pdfs +pdfsume +pdft +pdfx pdg +pdgbackwardslicecorrect +pdgclr +pdiff pdifference +pdigraph +pdilate +pdimindex +pdims pdir +pdisjoint +pdist pdiv pdivbound +pdivgi pdivides +pdividesz pdivl pdivless +pdivlml +pdivlmr pdivmod +pdivp pdivr +pdivrml +pdivrmr +pdivw +pdivwu +pdk +pdl +pdmem +pdmemhist pdo pdom pdouble +pdp pdpe +pdpfquk +pdpt +pdpte +pdrop pds pdst +pdstofs pdt +pdts pdvd pdvds pdvdxy +pea peak peano peanonat +<<<<<<< Updated upstream +======= peanosinj peanuts +>>>>>>> Stashed changes +pece peculiar ped +pedersen +pedge +<<<<<<< Updated upstream +======= pedges +>>>>>>> Stashed changes +pedslgv +pee peek +peekchar +peeks +peekw peel peelargs peelargsiff peelcore peeled +peeler peeliffaux peeloffargdecomposition peelunbounded +peephole +peer +peerp pef +pefct +pefect peg +pegexec +pegf +pegfail +peggt +pegp +pegparse +pegresult +pegsym +peiffer peirce peircecurry +peircedc peircei +peircelaw peirceroll +peirceslaw peircestab pejxvkn +pel +pelem +pelemi +pelemj +pelemp +pelems pelimvar pell pellex @@ -60254,15 +99789,35 @@ pellfundrp pellfundval pellqrex pellqrexplicit +pelly pellzd +pelse +pelt +pelts +pem +pema pemb +pempeirce pempty pemptyarrowequivpunit pemptyprod pemptyunique +pemull +pemulr +pemute +pen +penable penalty +pencil +pencils +pencilspace +pencz pend +<<<<<<< Updated upstream +======= pendack +>>>>>>> Stashed changes +pendi pending pendingactionablesynthmvar pendingd @@ -60270,19 +99825,36 @@ pendingfreqs pendingmvars pendingmvarssaved pendingureqs +pendingwindowindaystype pendulum penrose penrosediagram penrosevar +pent pentagon +pentagonidentity pentagoniso +pentail +pentails +pentominoes +penult penultimate penv people +pep pepin +peps +<<<<<<< Updated upstream +======= pepsi +>>>>>>> Stashed changes peq peqb +pequal +pequality +pequalityd +pequalityi +pequals pequiv pequivd pequivi @@ -60290,9 +99862,20 @@ pequivon pequivonglue pequivonlim pequivonsucc +pequivs +peqv per +percent +<<<<<<< Updated upstream +percentage +percentp +======= +percentp perception +>>>>>>> Stashed changes percpu +pereira +peremeter perf perfcls perfdvf @@ -60306,32 +99889,49 @@ perfectlem perfectly perfectlynormalspace perfectoid +perfectp perfectring perfectspace +perfecttp perfi perflp +perfo perfopn perform performance performant performed performing +performop +performopd performs perftop perhaps +peri +perimet +perimeter +perimeterlength perio period periodic +periodically periodicity +periodicn periodicon periodicorbit periodicpts +periodics periodizedbernoulli periodpair periods +peripherals +perlabel perm permac +permalg +permanece permanent +permanently permarray permaxext permaxinf @@ -60341,60 +99941,111 @@ permaxpr permaxrep permaxsep permaxun +permc +permcoh +permcoincok permcongr permcongrhom permd +permdisjoint +permdisjointlt perme +permeq permexpr +permextnotnonempty permfailures +permfun permgoal permgroup permi +perminjnotnonempty perminstructions permissible +permission +permissions permissive +permissiveness permissivesuccessapps permit +permitir +permitloadviolation permits +permitstorecapviolation +permitstorelocalcapviolation +permitstoreviolation permitted +permj +permjoin +permk +permkv +perml +permlr +permm permmapcoherence permmapjoin permmaplt permmapsdisjoint permmatrix permmatrixhom +permmod permmsgs permnn +permof permofdisjoint +permok +permokaux +permorder +permorm +permp +permr perms +permseq permsoffinset permsoflist permsorted permsuccesses +permt permtgt +permu +permueval permunique permut permuta permutat permutated permutation +permutationa +permutational +permutationp permutations permutationsaux +permutationspreservecardinality +permutationss +permutative +permutator permute permuted permutedmv permuteexpr +permuter +permuters permutes permutesi permutesingle permuteuniv permuting +permv +permwdok +permx +pero +peropp perp -perpat perpbisector perpcom +perpdir perpdrag perpdragalt +perpencular perpendiculaire perpendicular perpendicularity @@ -60402,9 +100053,14 @@ perpg perpln perpneq perprag +perr perron pers +perserve +perserved +perserves persist +persistence persistent persistentarray persistentenvextension @@ -60412,67 +100068,186 @@ persistfvars persists person personal +personalization +personally perspective +pertain pertaining +pertains +pertenece +perturb +perturbation perturbations +perzeta pes +pesfx pessib +pesudo pet +peta +pete +petenotinvector peter peters peterson +petersons petersson petid petidres petincnvepres petinidres petit -petitesyrah petlem petlemi petparts +petri petridis +petruchio pets petseq petxrnidres peu peuqusdeg +pev peval peven +peventual pex +pexactlyone +pexists pexmidaltn pexmidlem pexmidn +pexp +pexpirn +pexpirz +pexpl +pexpn pexpr +pexprn +pexprz +pexpz +pext +pextsb +pextsh pfa +pfabs +pfactor +pfactorgik +pfactork +pfactorkpdiv +pfactors +pfadd +pfalse +pfam +pfamily +pfamilyp +pfammap +pfart pfb +pfbrt pfc +pfcard +pfchop pfci pfcj +pfcmpu +pfcmult +pfcoeff +pfcpoly +pfcrt +pfcti pfd +pfdeg +pfdiv +pfdrt +pfelem pfenning +pfeq +pfexp pff pffi pffj +pffun pfg pfgh pfi +pfib +pfiber +pfibration +pfie +pfield +pfij pfilter +pfilteredtype +pfind pfinpref +pfix pfj +pfl pflat +pflead +pfmadd +pfmap +pfmonic +pfmr +pfmsub +pfmul +pfmult pfn +pfneg pfnfhzo +pfo +pforall pfp +pfpoly +pfppideal +pfr pfrag pfragment +pfree +pfreee +pfreen pfresh +pfroots +pfrsp pfs +pfsearch +pfseparation +pfshift +pfsr +pfsrv +pfst +pfstr +pfstv +pfsub +pfsubst +pfsume +pfsumr +pfsv +pft +pftoe pftps pfty +pfu +pfull +pfullshare pfun +pfunc +pfuncfinsequence +pfuncs +pfuncsdomh +pfuncsdomhqn +pfunct +pfuncta pfunctor +pfunctx pfunfinenum +pfunle +pfunsepalg +pfunsepalgops +pfv +pfw pfx pfxccat pfxccatid @@ -60481,6 +100256,8 @@ pfxccatpfx pfxcctswrd pfxchn pfxcl +pfxclg +pfxclz pfxco pfxeq pfxeqbi @@ -60507,11 +100284,22 @@ pfxsuffeqwrdeq pfxswrd pfxtrcfv pfxtrcfvl +pfxv pfxval pfxwlk pfxwrdsymb +pfxwrdsymbg +pfzerop pgc +pgcd pge +pgen +pgenerate +pgenerator +pgeneric +pgenstr +pget +pgflip pgind pgindlem pgindnf @@ -60520,12 +100308,20 @@ pgivesdigit pgjsgr pgl pglem +pglob +pglue pgm +pgmfull +pgminit +pgminitend +pgminitnotmmio pgms pgn pgnbgreunbgr pgnbgreunbgrlem pgnioedg +pgoal +pgotrequest pgp pgpfac pgpfaclem @@ -60534,51 +100330,128 @@ pgpgrp pgphash pgpprm pgpssslw +pgraph +pgrectangle +pgrotate pgroup +pgroupe +pgroupj +pgroupm +pgroupnk +pgroupp +pgroups pgrp pgrpgt pgrple pgrpsubgsymg pgrpsubgsymgbi +pgsqvbl +pgsymmetric +pgt pgtable pgte pgwt +pha +<<<<<<< Updated upstream +phabs +======= phabet +>>>>>>> Stashed changes +phall +phalle +phallj +phalljnorm +phallnk +phallp phant phantom phase +phased +phaselist phasename +phaseone +phaseonee +phaseonereceive +phaseoneresponded +phaseonerespondede +phaseonesend phases +phasetwo +phasetwoabort +phasetwoaborte +phasetwocommit +phasetwocommite +phasetworeceiveaborts +phasetworeceivecommits +phasetworesponded +phasetworespondede +phasetwosendaborts +phasetwosendcommits +phasewise phashset +phaze phclm +phd +phe +phead pheadidx pheap +phf +phh phhluvsgfql phi +phia +phiaged +phiall +phialllem phiarg +phib phibnd phibndlem +phic phicl phicld +phicone phidef phidefnode phidefnodes phidefnodesi phidefs +phidisjnn +phieq +phiex +phiexg +phii +phiii +phij phil +philm philo phils +phim phimul phimullem +phin +phinodes +phinone phiplus phiprm phiprmpw phis +phisome phisum +phiua +phiun phival +phivalfi +phiwhile +phiwhilemonotone +phiwhileop phiwhilep phiwhilepmonotone phiwhilepop +phiy +phiz phl phlbase phlip @@ -60595,24 +100468,43 @@ phlstr phlvsca phnv phnvi +<<<<<<< Updated upstream +======= phoare +>>>>>>> Stashed changes +phoas phoeqi +pholds +phomotopic +phomotopy +phone +phonebook +phonebookp +phonenums +phony phop +photo php phpar phpd +phpelm phpeqd phphashd phphashrd phplem +phpm phpreu phragmen phragmenlindelof phrase +phrased phrases +phrasing phrel +phsae phssip phssipval +pht phtpc phtpcco phtpcer @@ -60626,7 +100518,12 @@ phtpyhtpy phtpyi phtpyid phy +phyphyregs +phyregs +phys +physi physical +phystack phytagorean piaddequiv piadditive @@ -60640,16 +100537,37 @@ picard picardgroup pichartedspace pick +pickallghostvalue +pickanat +pickany +pickanye +pickdrop +picke picked +pickedat pickeff +pickenumvalue pickfreshs +pickfreshsa +pickfrompair +pickfromsingleton +pickft pickin picking pickinsetp +picklargest pickle picklek +pickone pickp +pickpetal +pickr picks +picksomething +picksp +pickt +pickunnumbered +pickup picn picomm picomparison @@ -60665,19 +100583,26 @@ piconst piconstadj picontent picountable +pictf picture picurry pid +pida pidem +pidgeon pidgeonhole +pidi pidiag pidiv pidlnz pidlnzb pidn +pidness +pidp pids pidufd pie +piec piece pieces piecewi @@ -60697,12 +100622,18 @@ piequivpisubtypeprod piequivsubtypesigma piequivsucc piequivtprod +pietofun +pietoid pievalalghom pievalringhom +piexpz +pif +pifactor pifamily pifan pifanislimit pifantensorproductislimit +piff pifi pifieldequiv pifin @@ -60715,7 +100646,6 @@ pifintwoequiv pifintwoiso pifintype pifunctor -pify pig pige pigeon @@ -60724,14 +100654,23 @@ pigeonholes pigeons piggy pigt +pih +pihalf +pihalfe pihomotopy +pii piicc +piijbjk piinfprincipalpi piinters piiota piiso piisopi piiunioninter +pij +pikblk +pike +pilambdad pilattice pile pileft @@ -60742,6 +100681,7 @@ pilimitfan pilimitfanislimit pilinearequiv pilinearmap +piln pilocalization pilocalizationtomaximal pilocalizationtomaximalequiv @@ -60759,6 +100699,7 @@ pimconstlt pimdecfgtioc pimdecfgtioo pimeasurableequivtprod +pimem pimg pimgtmnf pimgtmnff @@ -60772,9 +100713,13 @@ pimltpnff pimono pimorph pimp +pimpl pimrecltneg pimrecltpos +pimul +pimull pimulopposite +pimulr pimulsingle pimultiplicative pimxrneun @@ -60783,48 +100728,96 @@ pinat pinatembed pincerrecursion pinch +pinching +pincl +pinclass pind +pinds +pindsv pinduct +pinductive pine pinf +pinfinity pinfo pinfty pinftyccb pinftynminfty pinftynrr +pinftyp pinftytonormalizedmoorecomplex +pinfw ping pingponglemma pingroup +pinit +pinj pinn pinotation +<<<<<<< Updated upstream +======= pinotblanc pinotnoir +>>>>>>> Stashed changes +pinp pinq +pinst +pinstlist +pint +pintl +pintp pinv +pinverse +pinvk +pinvkv +pinvmx piobj piobjiso +piohm pion +piont piopens pioptionequivprod piord piorderiso piotr +pip pipartialorder pipcfe pipe +pipea +pipeaabt +pipeall +pipeaval +pipeawrite +pipeb +pipebabt +pipebll +pipebval +pipebwrite +pipec +pipecval +pipecwrite +pipeli pipeline pipes +pipestatawrite +pipestatbwrite +pipestatiregwrite pipiiso +pipinv +piport pipos pipremeasure piprod piq +piquarter piquotequiv piquotientequiv piquotientlift piquotientlinearequiv pir +pirat pire piright pirighthom @@ -60835,38 +100828,69 @@ piringequiv piringhom pirp pirr +pirreducible +pis +pisano piscalarright piscalarrighthom piscalarrighthombil piscalarrightinv pisetcoe pisetoid +pisg pisingle pisingleton +piso +pisou pisounopopp +pisow pisplitat pisplitle pisubtype pisurdeux pisystem +pit +pitag pitensorhommap pitensorhommapfun pitensorproduct pith +pithago +pithagor pitomodule +pitonn +pitonnlem pitopitop pitoptopicone +pitore +pitoregt +pitri +pitric +pity pitype +piu +piuctf piunique piunits +piv +pivar +pivars pivot pivotal +pivotandupdate pivotbetree pivotbetreerefinement pivotbranch pivotbranchrefinement +pivotornot +pivotreduced +pivots pivottable +piwe +piweek pixel +piz +pizza pjaddi pjaddii pjadj @@ -60953,6 +100977,9 @@ pjocini pjococi pjocvec pjoi +pjoin +pjoinable +pjoins pjoml pjomli pjop @@ -60990,6 +101017,7 @@ pjssmi pjssmii pjssposi pjssumi +pjsub pjsubi pjsubii pjsumi @@ -61000,56 +101028,123 @@ pjval pjvec pjvi pkcs +pkey pkg +pkgp +pkgs +pkhash +pkheap +pki +pkp +pkr pks pkt +pkts +pkttraveling pla +plab +plabel place +placebo placed placedtile +placehold placeholder placeholders placement -placename places +placesof placesover +placing plain +plainarg +plainarglist +plainarglistlist +plainarglists +plainargs +plainisloosechar +plainisloosestring +plainlen +plainlim +plainliterals +plainly plaintext +plaintextdatakey +plaintextdecryptedwithaad +plaintextkey +plaintexttype +plaintoken +plaintokentype +plaintxt +plainvar plan planar +planarity plancherel plane -planeanglemeasure planeconformalmatrix +planegraph +planegraphp +planegraphs +planep +planes +planeseparation +planesparallelity planetmath planned -planner planning +planp plans +<<<<<<< Updated upstream +plas +======= plant +plas plasmodial +>>>>>>> Stashed changes plat platform +platforms +platformserviceimpl +platonic plausible plausibly plausiblyequaltypes play played player +<<<<<<< Updated upstream +======= playerpos +>>>>>>> Stashed changes +playfair +playfairhelper +playing plays plb +plbz +plbzx plc +plceti +plcm plcofph +pld +pldc pldg pldofph +pldw ple please +pleastone +pleb pledm plef +pleft +pleftright pleid plelttr plem +plemma plen plendx plendxnbasendx @@ -61060,19 +101155,53 @@ plendxnplusgndx plendxnscandx plendxnvscandx plength +plenty +pleq +pleqv +pleslid pleval +plex +plf +plfd +plfdx +plfs +plfsx plg +plgaabb +plgequivdef +plgex +plgexabc plgf +plgleft plgs +plh +plha +plhalf +plhax +plhz +plhzx pli -pliable plift +pliftu +pliftw plig pliguhgr plimit +plink +plisp +plist +plistpt +plistvars +plit pll +pllsi plm +plmach plmhm +plnnew +plog +plook +plop plord plordisom plordso @@ -61080,12 +101209,19 @@ plossless plot plotkin plots +plp +<<<<<<< Updated upstream +======= plpl +>>>>>>> Stashed changes plpv +plpvlu plr pls +plse plt pltfval +plti pltirr pltl pltle @@ -61094,10 +101230,14 @@ pltn pltne pltnle pltnlt +pltp plttr pltval plu +plub +pluck plucker +pluckerrors plucking pluennecke plug @@ -61109,30 +101249,40 @@ plurality plus plusa plusassociative +plusb +plusbis +plusch plusclosestlowerbound plusclosestlowerboundaux pluscn +pluscolon pluscommutative pluscomp pluscompiso plusd pluse pluserrorbound +pluses plusexact plusexactexp plusexactexpcanonic plusexactr +plusexample plusexpbound plusexpmin plusexpupperbound plusfeq +plusfeqg plusffn +plusffng plusffval +plusffvalg plusfreseq plusfunctor plusfunctorwhiskerleftiso plusfunctorwhiskerrightiso plusfval +plusfvalg plusg plusgfvi plusgid @@ -61140,18 +101290,30 @@ plusgndx plusgndxnmulrndx plusgndxnn plusgpropd +plusgslid plusi +plusindispr +plusinf +plusispr plusl pluslift +pluslteleft plusltemonotone plusltemonotoneleft plusltemonotoneright +pluslteright plusm plusmap plusminus plusminuslte plusmod +plusnb +pluso plusobj +plusone +plusoneminus +plusoneminusmod +plusop plusp pluspart pluspf @@ -61161,8 +101323,11 @@ plusplusisosheafify plusplussheaf plusplussheafisopresheaftosheaf plusr +plusrrnever pluss +plusses plussuccrightsucc +plust plusterm plusterml plustermr @@ -61171,10 +101336,13 @@ plusupperbound plusvector plusw plusxeqvd +plusxxx pluszerorightneutral plvcofph plvcofphax plvofpos +plwz +plwzx ply plyadd plyaddcl @@ -61182,10 +101350,13 @@ plyaddlem plybss plycj plycjlem +plycjlemc plycjold plycn plycnold plyco +plycoeid +plycolemc plyconst plycpn plydivalg @@ -61213,6 +101384,10 @@ plysub plysubcl plyun plyval +pmact +pmain +pmakespace +pmant pmap pmapat pmapc @@ -61233,6 +101408,7 @@ pmapocjn pmapojoinn pmapr pmaprf +pmaps pmapssat pmapssban pmapsub @@ -61243,6 +101419,10 @@ pmatassa pmatbas pmatch pmatches +pmatchfailure +pmatchp +pmatchresult +pmatchsuccess pmatcoe pmatcollpw pmatcollpwfi @@ -61262,27 +101442,46 @@ pmatscmul pmatscmxcl pmatval pmatvalel +pmax +pmaxelem +pmaxelemj +pmaxelemp +pmaxelems +pmaximal +pmc +pmcm pmcopy +pmd pmdl +pmdld pmdli pmeas pmeasadd pmeasmono +pmeasure pmem pmemfile pmemlog +pmemory pmemspec pmeq +pmet pmeven pmex pmf +pmfcrbit +pmfi +pmflr pmfun pmfzgsumcl pmfzmap +pmg +pmgamma pmin pmindeg pminpos pminus +pml pmltpc pmltpclem pmmpric @@ -61291,13 +101490,28 @@ pmodl pmodlem pmodn pmon +pmonad pmonauto pmonic +pmor +pmore +pmorph +pmorphim pmorphimf +pmostone +pmov +pmp +pmpo +pmpt +pmr pmresg +pms +pmsg pmsgn pmss pmsspw +pmtctr +pmtlr pmtr pmtrcnel pmtrcnelor @@ -61331,25 +101545,59 @@ pmtrto pmtrval pmu pmul +pmule +pmull +pmulli +pmullw +pmuln +pmulr +pmulrn +pmulrni +pmulrz pmult +pmultiplicity +pmultl +pmulz +pmulzl pmvalg pna +pnaa pnadditional pname +pnand pnat pnatcast pnatden +pnate pnatequivnat +pnati pnatisonat pnatmethods +pnatnk +pnatoms +pnatp pnatpowassoc +pnatppi +pnatr +pnbhstype pncan pncand pncans +pnderiv pnecoorneor pnedifcoorneor pnedifcoorneorr pneg +pnelem +pneleme +pnelemi +pnelemj +pnelemp +pnelempcard +pnelems +pneq +pnet +pnext pnf pnfaddmnf pnfel @@ -61370,23 +101618,38 @@ pnfval pnfxr pnil pnilradical +pnm +pnn pnncan pnncand pnncani +pnno +pnnp +pnodup +pnomsl +pnone pnonsingn +pnor pnorm pnormal +pnormalize +pnot +pnots pnp pnpcan pnpcand pnplus pnpncand +pnproc +pnprop +pnq pnrm pnrmcld pnrmnrm pnrmopn pnrmtop pns +pnsucc pnt pntibnd pntibndlem @@ -61421,10 +101684,16 @@ pntsval pnu pnum pnumargs +pnump pnunit pnz +poact +pobj +poc +pocase pochhammer pocket +pocklington pockthg pockthi pockthlem @@ -61432,29 +101701,58 @@ pocl pocnv pod podd +podescent +podr +poe poeq +poffset +pofs pofun pohjola +pohjolasem +poi poimir poimirlem +poin +<<<<<<< Updated upstream +======= poinca +>>>>>>> Stashed changes poincare poincaredisc poincaredisce poincarediscm +poincarify point pointbot pointbotfunctor pointbotpresheaffiberiso pointclass +pointcltop pointcount pointd pointderivation +pointe pointed +pointedcat pointedcone pointedcontmdiffmap +pointedequivaction +pointedequivstr +pointedeqvto +pointedeqvtoequivstr pointedgaloisobject pointedmap +pointedopred +pointedpositiverel +pointedrelaction +pointedrelmatchesequiv +pointedrelstr +pointedseciso +pointedsets +pointedsip +pointedstructure +pointedsuitablerel pointedtobipointed pointedtobipointedcompbipointedtopointedfst pointedtobipointedcompbipointedtopointedsnd @@ -61467,32 +101765,58 @@ pointedtotwopfst pointedtotwopfstforgetcompbipointedtopointedfstadjunction pointedtotwopsnd pointedtotwopsndforgetcompbipointedtopointedsndadjunction +pointedtransportstr +pointedtype +pointedunivalentstr +pointequal pointequiv pointequivclosedpoint pointequivsubtype pointer +pointerfun +pointerloop +pointermap +pointermapieq pointerqtint pointers +pointersp pointerx +pointfree pointgrothendiecktopology pointgrothendiecktopologyhomequiv +pointi +pointify +pointimages pointindex pointindexembedding pointing +pointinterval +pointiv pointless +pointmodel +pointnegate pointofclosedpoint +pointp pointpsubn pointreflection +pointreflectionisometry points pointsbot pointsequivirreduciblecloseds pointsetn pointsgrothendiecktopology pointspi +pointstamps pointsto +pointstoarray +pointstobytepredicate +pointstopredicate +pointstoscalarpredicate +pointsurjective pointswith pointswithcircumcenter pointswithcircumcenterindex +pointt pointtopoint pointweightswithcircumcenter pointwise @@ -61510,6 +101834,7 @@ pointwiseconvergenceclm pointwisedistribmulaction pointwisedivision pointwisehassmul +pointwisei pointwiseiscolimit pointwiseleftkanextension pointwiseleftkanextensioncompisoofpreserves @@ -61528,53 +101853,82 @@ pointwiserightkanextensioncompisoofpreserves pointwiserightkanextensioncounit pointwiserightkanextensionispointwiserightkanextension pointwiserightkanextensionisuniversal +pointwisering pointwisesetdistribmulaction pointwisesetmulaction pointwisesetsmul pointwisesmul pointwisevadd pointwisezero +poinv +poinvp +poinvprel poinxp +poioj poirr +poised +poisson poissonkernel poissonmeasure poissonpmf poissonpmfreal poissonpmfrealsum +pojeciem +poke pol pola +poland polar polarbilin polarcoord polarcoordreal +polarit +polarities polarity polarization polarizationequiv polarizationin +polarized polarsets polarspace polarspacecoord polarsubmodule polarsym polatn +polc polcon poldmj pole poleloe poles polf +polflzy polfvaln +police policemen +policies policy +policyd +policyi +policynametype +policyrevisionid +policytype polid polidi +polies +polinomial +polinomio +polinomiop +polinomios polish +polished polishpp polishsource polishspace -politicalprocess poll poln +polnomial +poloc polpmapn polr polref @@ -61587,29 +101941,62 @@ poltletr polval polvaln poly +polya polyadd +polyal +polyalg polyap +polyb polybinomaux polybound polyc polycharpoly polycharpolyaux +polyck +polycoef +polycommring +polycr +polyd +polydiff +polydl +polydr +polye +polyedge +polyeq polyequivtensor polyexp polyf +polyform polyfun polygamma polygon polygonal +polygreater polyhedra polyhedral polyhedron +polyhedronstr polyi +polyinterval +polyintervalp +polyk +polyl +polyless polylog +polym +polymax +polymc +polymodal +polymodconst +polymodring +polymonial polymorphic +polymorphically polymorphism +polymul polyn polynate +polynbomial polyneg polyno polynom @@ -61621,8 +102008,10 @@ polynomialattop polynomialc polynomialequiv polynomialfunctions +polynomiallambdaf polynomiallaw polynomialmodule +polynomialp polynomialquotientequivquotientpolynomial polynomials polynomialtensorproductlequivpolynomialmodule @@ -61633,54 +102022,175 @@ polynomialz polynormablespace polyofinterest polyorb +polyover +polyoverc +polyovernr +polyoverp +polyovers +polyoversv +polyoverx +polyoverxsubc +polyoverz +polyp polypoly polypow +polyr polyrank +polyred +polyredrel +polyrelation +polyrelationp +polyring polys +polysd +polyseq +polyseqc +polyseqk +polyseqmx +polyseqmxn +polyseqx +polyseqxn +polyseqxsubc polyset +polysi +polysort +polyspred polysub polysubst +polysymb +polytime polytomatrix polytope +polytopes +polytopsf polyul +polyvalue +polyx +polyxaddc +polyxn +polyxr +polyxsubc +polyxsubcp +polyxy +polyz +pomega poml pomults +pone ponens pong poni +ponits +pons pont pontryagindual +poo pool +poolp poolrunner +pools +poopsmith poor +poorly +poorlydefined pop +popad +popair +popc +popcategory +popcount popcycles popcyclesiso popcyclesnattrans popelim +popfast +popframe +pophandler +popinstrloc popl +poplist +poplistval +popmatchinglist +popmatchingtype +popmiddle +popn +popns +popop +popoperandstack +popopstack +popped +popping poprelb +pops +popstack +popstackn +popt +popular +popularity +populate populated +populatedby population +popus popwithbound popwithpriority por +porc +pord porder +pordertype +pore +pori +poris +<<<<<<< Updated upstream +porpss +porque +pors +======= porkchops porpss +porque +pors +porsche +>>>>>>> Stashed changes port +porta +portable +portargs +portcullis +portdecl +portdecllist +portdecls ported +portemanteau +portexpr portfolio +portfoliovaluefut +portfoliovaluefutext +portinfo porting portion +portions +<<<<<<< Updated upstream +======= portland +>>>>>>> Stashed changes +portlist portmanteau +portp ports +portsp pos posa +posaltcat +posao posasymb posb posbezout +posbranch +poscat +poschecks +posclause posconfigitem posconvolution posd @@ -61689,36 +102199,89 @@ posdif posdifd posdifi posdifsd +posdistl +posdistr pose +posedge +poselements poseq poseqtype +poses poset +posetaxioms +posetequiv +posetmax +posetmin +posetnotation +posetpath +posetreasoning posetrel +posets +posetscategory +posetstr +posetstructure +posetunivalentstr posf posfitting posfittingcomp posfittingcompof +posfix posform +posfree +posg posglbdg posglbmo posi +posibilities +posible +posid +posidmeth +posidonius +posind posinf posinfinity +posinfty +posing +posinrg posint +posispositive posit +positedbool +positi +positio position +positional +positioned +positionp positions positiv positive positivecompacts positivecone +positivediagvalued +positiveencryptnegativedecrypttestvector +positiveencrypttestvector +positiveimplies +<<<<<<< Updated upstream +positiveint +======= +>>>>>>> Stashed changes +positiveinteger +positiveintegerobject +positiveispos positivelinearmap +positivelong +positivelongobject positively positivemap +positiveness positiveorientation +positivep positiveqtint positives positivesemidefinite +positivestrrel +positivexxx positivit positivity positivitycanon @@ -61727,14 +102290,28 @@ positn posix posjidm posk +poslemma +poslength +poslit +posliveness +poslivenesse +poslivenessi +poslnegsucmax +poslnegsucmin poslog +poslposmax +poslposmin poslsts +posltinrange poslubd poslubdg poslubmo posm +posmap +posmax posmeas posmidm +posmin posmul posmulmono posmulreflectle @@ -61745,36 +102322,79 @@ posnat posnateq posnatmult posnattonat +posneg posnex +posng posnormmin +posnotnegsuc +posnp +posns posnum posnumcoe +posnume +posnumep +posnump +posofnat posord posordeq +posout posoz posp pospart +pospathinj pospo +pospos pospropd pospropertiesnecexist posprops posprs +posps posqsqznn +posr posrasymb +posre posreal posrealaction posref +posreldesc +posrelmacromatchesequiv +posrelmacropositiverel +posrelmacrorelstr +posrelmacrostructure +posrelmacrosuitablerel +posrelreflexive +posreq +posresolution +posresproof +posrnegsucmax +posrnegsucmin posrootform +posrposmax +posrposmin poss +possafety +possafetyd +possafetye +possafetyi possemidef +posset posseximpliesnecex possexistenceimpliesnecex +posship +possi +possib +possibiliti possibilities possibility possible possibled +possiblegba possibleworld possibly +possiblycontingentobjectexists +possiblycontingentobjectexistscheck +possiblynocontingentobjectexists +possiblynocontingentobjectexistscheck possit possl possmu @@ -61783,13 +102403,17 @@ possmulreflectle possmulreflectlt possmulstrictmono possort +posspaceclause +possq possubgroup possubmonoid +possuc possumd possumofencodable possworld possworldaux post +posta postadjunctionleft postadjunctionright postangentconeat @@ -61821,72 +102445,170 @@ postcompuniformconvergenceclm postcomputation postcond postcondition +postconditions postcongr postcpos postcposalt +postd postdefault postdominate postdominates postdomination postdominator +poste +posted postequiv posterior +postest +postf +postfinal postfix +postfixes postfixpoint +posth posti postid postidasstr postids +postie +postinc postinfo +postint postiso postisomap +postlist +postlistpostset +postlude postmap +postname +postof postolsppos +postopath +postopathaux +postopathprefixfree +postopathprefixfreeaux +postorder postoshiftedpos +postoword +postp postpone postponed +postposing +postposition +postprelist +postproc postprocess postprocessappmvars postprocessing +postprocessor +postq +postqz postr +postrecording +postrel +postset +postsetpostlist +postspill +postt +postterm +posttest +posttotalhopf postulate postulated +postulateh postulates +postv +postvd +postve +postweak +postwhisker +postwhitening +posty +posxp +posynomial posz poszd +poszero poszm pot +<<<<<<< Updated upstream +======= potableliquid +>>>>>>> Stashed changes +potentia potential potentially potr +potrzebny +pottier +<<<<<<< Updated upstream +======= poundmass +>>>>>>> Stashed changes pour pouring +pout +poutput +pov pow +powa powaddexpansion +powauto powbound powcardsubgroup powcoprime +powdiff powe +powempty +powemptyeq powequiv power +powerac poweralgebra poweralgebraequivfreetensoralgebra +powerb powerbasis powerbasisaux powerbasisoffiniteofseparable powerbifunctor +powercategory +powerd +powere +powerendo powerfan powerful +powerfully powerfunctor +powergreater +poweri +powerinfsinheriting +powering +powerl +powerlemma +powerlist +powerlists powerlt +powerm powermap +<<<<<<< Updated upstream +powermonotone +======= +>>>>>>> Stashed changes +powern +powernyr +powerof poweroftwo +poweroftwolemma +powerp +powerplus +powerprod powerr +powerrm powerrz powers +powerse powersequivpowers +powerserie powerseries powerseriesalgebra powerseriesalgequiv @@ -61897,24 +102619,34 @@ powerseriespart powerseriesringequiv powerset powersetaux -powersetax powersetcard powersetcardaux +powersetce powersete powersetequiv powerseti +powersets +<<<<<<< Updated upstream +======= powersetsubset +>>>>>>> Stashed changes powersett -powersette -powersetti powersetup powershom powersmulhom +powerstar powersum +powersums +powersupsinheriting +powertotal +powery +poweryr +powfix powh powi powind powinstances +powinv powissubgroup powlogequiv powlt @@ -61923,37 +102655,62 @@ powmonoidhom powmonoidwithzerohom powmul powmulequiv +pown pownat poworderiso +powpos +powpowempty powquot powquotpowsuccequivmapmkpowsuccpow powquotpowsucclinearequivmapmkpowsuccpow powquotsuccinclusion powr +powrac powrat +powrb +powrd powreal +powrev +powrm +powrn +powrr +powrrm powrs +powrz powsaturated powser powsubpowfactor powsum +powu +powx powzero poxp ppa +ppair ppal +ppap +ppat ppath +ppatop ppatt +ppattern +ppatternlist ppb +ppbij ppc +ppcard ppcategory +ppchist ppcl ppcm ppcont ppconts ppcp ppcr +ppd ppdedentifgrouped ppdomain +pperm ppescalations ppeval ppexpr @@ -61961,14 +102718,20 @@ ppexprtagged ppf ppgoal ppgroup +ppheufg +pphii ppi +ppickfreshs ppicl ppidif +ppidx ppieq ppif ppifi ppifl ppiltx +ppimage +ppinj ppinncl ppinprm ppip @@ -61976,15 +102739,31 @@ ppiprm ppisval ppiub ppiublem +ppiv ppival ppiwordi +ppl pplevel +pplhulj +pplus +pplusl +ppm +ppmap +ppmm +ppn +ppname ppncan ppncand +ppnnp +ppo ppoint +ppointed pporigin ppos +pposresproof +ppost ppow +ppower ppp ppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppp pppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppp @@ -61993,6 +102772,10 @@ pppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppp ppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppp ppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppp pppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppp +pppre +ppq +ppqq +ppr ppre ppred ppreda @@ -62000,51 +102783,124 @@ ppredb ppredconts ppredmorethanone ppredmorethanradix +pprefix +ppresproof pprev pprime +pprint +pprintrenderer +pprobability +pproc pprod pprodcnveq pprodcongr pprode +pprodeq pprodequivprod pprodequivprodplift +pprodex +pprodexg +pprodey +pprodg +pprodj +pprodm pprodmap +pprodme +pprodmel +pprodmer +pprodml +pprodmm +pprodmr +pprodp pprodprod pprodss +pproduct +pprodw +pprodwc +pprodwy +pprog +pprogn pprogress +pproj +pprop pproundtrip pps ppsc ppsd ppsi ppspace +ppsssi +ppst +ppsubst +ppsum +ppt pptactic pptbas +pptrofs ppttop ppty pptypes +ppure ppv ppw +ppx ppybichc +pqcsxwg +pqif pqklijku +pqok +<<<<<<< Updated upstream +======= pqp +>>>>>>> Stashed changes +pqpq pqprim pqr pqs +pqsub pqt +pqtoc +pqu +pqueue +pqueued +pquotient pquslmic pra +practical practically practice +pradic praeclarum +pragma +pragmas +pragmat +pralg +prappend +prarloc +prarloclem +prarloclemarch +prarloclemcalc +prarloclemlo +prarloclemlt +prarloclemn +prarloclemup +prat +prational pratt +prawda prb prc +prcdf prcdnq +prcdnql +prch +prchar prcinf +prcl prclaxpr prclisacycgr prcliscplgr +prcn prcnel prcof prcofdiag @@ -62058,10 +102914,15 @@ prcofval prcofvala prcofvalg prcom +prcond prcssprc prct +prcunqu prd +prdata +prdbnf prde +prdisj prdom prds prdsabld @@ -62070,6 +102931,7 @@ prdsbascl prdsbasex prdsbasfn prdsbaslem +prdsbaslemss prdsbasmpt prdsbasprj prdsbl @@ -62081,6 +102943,7 @@ prdsds prdsdsf prdsdsfn prdsdsval +prdsex prdsgrpd prdsgsum prdshom @@ -62121,6 +102984,7 @@ prdstset prdsval prdsvallem prdsvalstr +prdsvalstrd prdsvsca prdsvscacl prdsvscafval @@ -62132,6 +102996,9 @@ prdsxmslem pre prea preabstractsimplicialcomplex +pread +preadd +preaddccan preadditive preadditivecoyoneda preadditivecoyonedaiso @@ -62142,23 +103009,60 @@ preadditiveyonedamap preadditiveyonedaobj preal prealeph +prealloc preallocated +preallocatedd +preallocatede +preamble +prearm +preb +prebasis +prebatch prebeth prebicategory preboolean +prebreak +prebtc prebundle prec +preca precantorset +precat +precate +precateg +precatego +precategor +precategory +precategorynotation +precategoryofstructures +precatnotation +precatobj precd precdf +precede preceded precedence precedes +precedesantisymmetry +precedesappend +precedesfilter +precedesmap +precedesmemberheadmembertail +precedesorder +precedesreflexivity +precedestotalorder +precedestransitivity +preceding +preceeding preceq +precfields +prechain +prechainhomotopy precheck precheckfinsetstx preci precise +precised precisee precisei precisely @@ -62168,21 +103072,28 @@ precisiongreaterthanone precisionnotzero precmax preco +precode +precoeff precofcl precoffunc precofval precofvalalt precofvallem precoherent +precom precomp +precompact +precompacte precompcompactconvergenceclm precompenrichedhom precompequiv precompequivoffinal precompfork precomphomeomorph +precompiled precompl precomplement +precomplen precompnattrans precompoffinal precompose @@ -62194,6 +103105,7 @@ precomposeinvequiv precomposeobjcomp precomposeobjid precomposeobjtransformobjsquare +precomposestoid precomposewhiskerleftmapcocone precomposing precomposingcat @@ -62201,22 +103113,39 @@ precomposition precompr precomprelation precompuniformconvergenceclm +precomputations +precompute +precomputed +preconcat +preconcatr precond precondi +precondit +preconditi precondition preconditions +preconditionviolation +preconds precongr +precongruence preconnecte preconnected preconnectedspace +precontext precov precove precoverage +precparse +precparser precpos precprec +precs precsex precsexlem precsexlemcbv +precursor +precursors +precv pred preda predab @@ -62224,15 +103153,22 @@ predabove predaboveorderhom predacread predacwrite +predat predatm predatom predb predc +predck predcong predconts +predd preddif +preddistmax +preddistmin preddowncl prede +predec +predecesor predecessor predecessors predeclare @@ -62242,53 +103178,108 @@ predefinition predel predep predeq +predeqe +predeqminus +predeqp predexg +predext +predextensionalequal +predf +predfin +predfinfamily +predfinpure +predfn predfrirr predfz predgclnbgrel predi +predic +predicat predicate predicateholds +predicateinassertions +predicatep predicates +predicatesize +predicatetypeinference +predicatewithvariables predicational +predicatively predict +predictability predictable predictablepart +predictably +predictdirection predicted -predicting prediction +predictor +predicts +predicttarget predidm +predimage predin +predint prediscrtree predisj +predispr +predist predistance +prediv +predk +predkn +predl predlast predm +predminus predn +prednk prednn +predomain predon predorder +predp +predpath predpo predpoirr predprc predpredss predpredtype +predr predrelss predres preds +predset predso predss predsuborder +predsuc +predsucc +<<<<<<< Updated upstream +======= predsum +>>>>>>> Stashed changes predt +predta +predtas +predtrans predtrss predtype +predu +predui predun +preduploid preduz +predx +<<<<<<< Updated upstream +======= predy +>>>>>>> Stashed changes predz +pree preel preempting +preemption preenv preenvelgroup preenvelgrouprel @@ -62296,36 +103287,77 @@ preequivalence preequivalencefunctor preequivalenceinverse preergodic +prees +preeuclid +preevaluation preex +preexisting preextensive pref prefd prefeq prefer preferable +prefered preference +preferences preferlhs prefernce preferred prefers +prefetch +prefetchnta +preff prefi +prefinall prefix +prefixclass prefixclosed +<<<<<<< Updated upstream +prefixcode +======= +>>>>>>> Stashed changes +prefixd prefixe prefixed prefixedequiv prefixedpoint +prefixelementsaretrailelements prefixeq +prefixequalitylimit prefixes +prefixf +prefixfree +prefixfreecommutative +prefixfreeempty +prefixfreesingleton +prefixfreetail +prefixfreewithnil +prefixgroup prefixi +prefixing +prefixissubset +prefixlength +<<<<<<< Updated upstream +======= prefixlist +>>>>>>> Stashed changes +prefixmap prefixmatch +prefixof +prefixp prefixpoint +prefixs prefixstr +prefixsuffixlength prefixtolevel prefixtoname +prefixword +prefl preflect +preflexive preflow +prefreeze prefs preftype prefunctor @@ -62335,32 +103367,48 @@ pregaloiscategory pregmap pregns pregraph +pregroup pregroupoid +pregstot +pregterm prehaar +prehashed prehil prehilbertpoly prei +preid +preidem +preidempotent +preifwhilealgebra preim preima +preimaf preimafvelsetpreimafv preimafvn preimafvsnel preimafvsspwdm preimage preimagediagram +preimagee +preimageeinv +preimageeoinv preimageequivfiber preimagehomeomorph preimagehomeomorphfiber +preimageidentity preimageiingt preimageimagerestrict preimageiso preimagelt preimagemkequivsubgroupprodset +preimageofimage preimageofmemintegerset preimageorderisofiber preimages +preimagesequal preimagesingletonhomeomorph preimagestruct +preimageu preimaicomnf preimaiocmnf preimaioomnf @@ -62370,15 +103418,30 @@ preiman preimane preimg preimgcodiscrete +preimp +preimpeval +preimset +preimsetc +preimsetd +preimseti +preimsets +preimsett +preimsetu preinclusion +preincr preindspreads preinfo +preinit +preinitnull preinnerproductspace preinv preirreducible preirreduciblespace preisomap +prej prel +prelamb +prelated prelaxfunctor prelaxfunctorstruct preleft @@ -62386,13 +103449,22 @@ preleftiso preleq preleqalt preleqg +preli prelift preliftalghom prelim +prelimin +preliminaires +preliminar +preliminari preliminaries preliminariesd preliminary prelimitrecon +prelist +prelistpreset +preload +prelocalic prelocalpredicate prelp prelpw @@ -62401,6 +103473,12 @@ prelrrx prelspr prelude prem +premainterm +premanifold +premature +premaximal +premeasurable +premeasure premetric premetricoptimalghdist premis @@ -62408,13 +103486,24 @@ premise premises premiss premisses +premove prems +premulth pren prenatiso +prenet prenex +prenexl +prenexr prenorm prenormeds +prenorms +prenuclei +prenucleus +prenum preo +preoduced +preof preomega preonehypercover preopposite @@ -62422,6 +103511,10 @@ preor preord preorde preorder +preordere +preordered +preordering +preorderoflattice preorderofmodels preorderpartialorder preorders @@ -62431,25 +103524,55 @@ preordtocat preordtopartord preordtopartordcomptodualisotodualcomppreordtopartord preordtopartordforgetadjunction +preorer +preortholattice +preorthoposet prep preparation +preparations prepare prepared +preparedstatementparameters +preparenet prepareop +preparestring +preparing prepartition prepartitions +prepath +prepeano prepend +prepended prependhlams +prepending prependlams +prependprefix +prependthenflattennonempties +prependthenflattenstartmarker prependvlams preperfect +prepolytope prepop +preposing +preposition +prepost +prepostlist +prepostlistref +prepostpair +prepostpairref +prepostref +prepower +prepped +prepr preprimitive preprint preprints preprm +preproc preprocess preprocesscopyright +preprocessed +preprocesses preprocessfacts preprocessfactslinear preprocessfactspartial @@ -62457,33 +103580,58 @@ preprocessfactspreorder preprocessing preprocessor preprocessortoglobalbranchingpreprocessor +preprogram +preprojective +preproof +prepwo +prepwork preq +preqc +preqlu +preqq preqr preqsn preqsnd prequasiregular +prequoted prequotient preradical +prerecording prered prereflecti prereflection +prereflects preregister preregular +prerel prereq prereqs +prerequ prerequisite prerequisites preright prerightiso +prerr prerun pres -presarith presatm +presatmsyntactic presburger presburgerfunc +presc +prescale +prescr +prescri prescribed prescribes +prescrip +prescrips +prescript +prescripti +prescriptio prescription +prescriptions +presd prese presemiadditive presence @@ -62497,14 +103645,27 @@ presentationtilde presented presentedgroup presentedmonoid +presenting +presentp preser +preserable +preserevd preserv +preserva +preservance +preservati preservation preservationcolimits preservationlimits preserve +preserveanyterminal preserved +preservedp +preserveflags preserveorder +preservep +preservers +preservervinv preserves preservesbinarybiproduct preservesbinarybiproducts @@ -62546,6 +103707,8 @@ preservesepimorph preservesepimorphis preservesepimorphisms preservesepis +preserveseq +preserveseqclosure preservesequalizer preservesequalizers preservesfilteredcolimits @@ -62596,6 +103759,7 @@ preserveslocalization preservesmono preservesmonomorphisms preservesmonos +preservesn preservesonehypercovers preservespairwisepullbacks preservespointwiseleftkanextension @@ -62605,16 +103769,19 @@ preservespointwiserightkanextensionat preservesproduct preservesproductsofshape preservesprojectiveobjects +preservespropsstrrel preservespullback preservespullbackinl preservespullbacks preservespullbacksofinclusions preservespushout preservespushouts +preservesreflexivecoequalizers preservesrighthomology preservesrighthomologyof preservesrightkanextension preservesrightkanextensions +preservessetsstr preservesshape preservessheafification preservessmallestcofilteredlimits @@ -62624,15 +103791,22 @@ preservessmallestlimits preservesterminal preservesterminaliso preservesterminalobject +preservesterminals preserveswellordercontinuousofshape preserveszeromorphisms +preservevalue preserving +preservinge preservingi preservingmctx +preservingp +preset +presetprelist preseves presf preshea presheaf +presheafcategory presheafe presheafedspace presheafequivofiso @@ -62667,24 +103841,46 @@ presieveofcovering presieveofcoveringaux presieveofsections presieves +presim +presinv +preslang presleft +presolution presolutionobj +presopt prespectralspace +prespectru +prespectrum +prespill +prespondedno +prespondedyes +presproof +presrefl presright press +presstr +prest prestar prestonecech prestonecechcompat prestonecechextend prestonecechunit +prestrength prestructure +prestv +presub presubmersivepresentation presuc presucmap presumably +presume presv pret pretend +pretendingnottoread +pretendingnottoreadbutspooky +preterm +preti pretilt pretnar pretopology @@ -62699,42 +103895,80 @@ pretrivialization pretrivializationat pretrivializationatlas pretty +prettybasicbetareduction prettydef +prettyify prettylemma prettypattern prettypatterns prettyprint prettyprinter prettyprinting +prettyprintinstr +prettyprintnum prettyprintopt -prettystring prettyterm +pretz preu preuniquee preuniqval preunitiso +preunivalence +preunivalent preuve prev +prevails preval prevaluationring prevariation prevariationfun +prevcont prevd prevent +prevented preventing +prevention +<<<<<<< Updated upstream +preventive +======= +>>>>>>> Stashed changes prevents +preverves prevfixed +prevh +prevheap +previ +previndex +previo previous +previouscoin previousinstname previously +previouslydidnotwork prevk +prevl +prevlen +prevlog +prevlogindex +prevlogterm prevnext +prevnumberingseq prevoccs +prevp prevs +prevserved +prevt +prevterm prewalk +prewhisker +prewhitening prews prex prexg +prexprojdouble +prexprojdoublen +prey +preyoneda prezerohy prezerohypercover prezerohypercoverfamily @@ -62743,16 +103977,25 @@ prfcl prferred prfi prfialt +prfidceq +prfidisj +prflag +prfmod prfof prfp prfromadj prfval prfx prg +prgcor +prgr +prhalf prhash prhl pri +priak price +pricefunction prices prid pridl @@ -62764,25 +104007,41 @@ pridlval priek priestley priestleyspace +pright prik prikey prim +primafact primal primald primali primality primarily primary +primarybackupparams primarycomponent primarygrp +primarynethandler +primaryp primc +primcharequality +primchartonat primcod primcodable +primcom +primcomerasure +primcomsafety +primcreatepath prime +primebprime +primechar primecompl primecounting primed +primedec +primediv primedivisor +primedivmult primefact primefactor primefactorisation @@ -62790,24 +104049,46 @@ primefactors primefactorsli primefactorslist primefactorspibij +primefacts primefld primefldchr primefldgen +primegi +primegip +primegipn primeheight primei primeidealof +primeits +primel primelist primemultiset +primeness +primenumber +primep primepair +primepn +primepns primepow primepoweqpow primepower +primepowerfield +primepows +primeprimes +primepropdiv +primer +primera +primeraseequality +primerecip +primero primes primesbelow primesequiv +primeset primeseven primesevenaltv primesgbe +primesgi primesle primeso primesodd @@ -62833,28 +104114,82 @@ primespectrumprodhomeo primespectrumprodofsum primespectrumquotientorderisozerolocus primesprm +primestream primevanishes +primewitness +primexec +primexpr +primexprerasure +primexprsafety +primezprime +primfloatequality +primfloatinequality +primfloatisinfinite +primfloatisnan +primfloatisnegativezero +primfloatissafeinteger +primfloatless +primfloatround +primfloattoword +primfn +primfun +primfuns +primglue +primify +priminttofloat +primio +primit +primite +primitiv primitive primitiveaddchar primitivechar primitivecharacter +primitived primitiveedge +primitivefun +primitivei primitively +primitivep primitiveroot primitiveroots primitiverootspowequiv primitiverootspowequivofcoprime primitives +primitivesparams +primitivessane primitivetriangle primitivetype +primitivetypes primitivezmodchar +primitivie +primitves +primivefun +primnattochar +primnattofloat +primop +primops primorial +primp primpart +primqnameequality +primqnamefixity +primqnameless +primqnametoword primr primrec primrecbounded +primrecformula +primrecop +primrecpiformulahelp primrecpred primrecrel +primrecrepresentable +primrecsigmaformula +primrecsigmaformulahelp +primrecsigmarepresentable +primrecstep +primreplace primroot primrootlekpowne primroots @@ -62864,15 +104199,30 @@ primrootscoprmpow primrootspoweq primrootsunit prims +primshowchar +primshownat +primshowqname +primshowstring +primstringappend +primstringequality +primstringfromlist +primstringtolist +primstringuncons +primtives +primtypes +primword prin princ +prince princi princip principal +principalfromcontext principalideal principalidealdomain principalidealring principalideals +principalidtype principalofprime principalopen principals @@ -62885,43 +104235,110 @@ principalsumreliso principalunitgroup principalunitgroupequiv principalunitgrouporderembedding +principalupset principle principles prinfzo +pring print printable +printarray +printarrayarray +printboard +printcenter printcodepointhex +printcollectionemptiness +printconfig printed +printedlist +printedtree +printelem +printem printer +printerr +printerspool +printexpected printf printfspec +printgsix printing +printjson +printlist println +printloop +printmany +printmap +printmatrix +printmaybe +printme +printmultiset printnamehashmap +printone +printonesx +printonlynonghosts +printoption +printordinalinfo +printpairs +printreal +printreals +printrotates prints +printseq +printsequence +printset +printshifts +printstream +printstring +printsum +printtest +printtestcase +printtime +printtimelong +printtimeshort +printtimesince +printtimesincelong +printtimesinceshort +printtimesinceshortchained +printtree +printtweaks +printtwice printverismo prinv prio priole prior -priorg priori priorities prioritises prioritize +prioritizing priority +prioritysort +prioritysorting +priormonths +priorty prios +priq +prisk prism priv privacy +privat private privatei privateinpublic +privatekey privatemodule privateslash privatetousername +privchar +priviledged privilege +privileged +privileges +privkey privs +prize prj prjcrv prjcrvfval @@ -62947,13 +104364,19 @@ prjsprellsp prjspreln prjspval prjspvs +prk +prklen prl prle prlem +prloc +prltlu +prlwinm prm prmalt prmb prmcyg +prmdc prmdiv prmdivdiv prmdiveq @@ -62972,6 +104395,7 @@ prmex prmexpb prmfac prmfmtno +prmg prmgap prmgaplcm prmgaplcmlem @@ -62991,12 +104415,14 @@ prmind prminf prmirred prmirredlem +prml prmlem prmm prmndvdsfaclt prmnn prmo prmocl +prmod prmodvdslcmf prmolefac prmolelcmf @@ -63012,18 +104438,26 @@ prmreclem prmrp prmsimpcyc prmssnn +prmu +prmuloc +prmuloclemcalc prmunb prmuz prmz prn prnc +prnd prnebg prneimg prneli prneprprc prnesn prnmadd +prnmaddl prnmax +prnmaxl +prnminu +prnsub prnt prnz prnzg @@ -63031,41 +104465,71 @@ pro proact prob proba +probab probabilistic probabilities probability probabilitymeasure probabilitymeasurehomeomorph +probabilityofe +probabilityofeasrealofmult +probabilityofesimplifyfractions +probabilityspace probabilitythe probabilitytheory +probable probableprime probably +probaremos +probassign probchar probchardual probcun probdif +probdist probdsb probe +probealist +probes probfinmeasb probfinmeasbaltv +probfins probgn probinc probing +probl problem problematic +problemetic +problemholder +problemlist +problemp problems -problen probmeasb probmeasd +probmeasure probnul +probpart +probprobassign probreal probs +<<<<<<< Updated upstream +======= probsize +>>>>>>> Stashed changes +probt +probtheory probtot probtotrnd +probtv probun +probv probvalrnd proc +procal +proccall +proce +procedural procedure procedures proceed @@ -63074,7 +104538,6 @@ proceedfieldsaux proceeding proceedings proceeds -proces process processantiquot processbigopbinder @@ -63084,37 +104547,65 @@ processed processedd processedfacts processedi +processeditemcount processedmonotonic processes processexpr processid +processident processing processinputs processleaf +processo +processor +processors +processp processpackets +processpair processprevious processsyntax +procg +proci +procid +procinit +proclaim +proclus +proco procoyonedacontravariant procoyonedacontravariantleftop procoyonedacovariant procoyonedacovariantunop procr procs +procsbeyondts procsd procsi procsn +procstate procuniv procvardeclname prod +proda prodadditive +<<<<<<< Updated upstream +======= prodag +>>>>>>> Stashed changes +prodak prodandsum +prodar +prodark prodassoc prodaux +prodb +prodbig prodbinaryfan prodbinaryfanislimit +prodc +prodcan prodcart prodcategoryinstance +prodcatstr prodchartedspace prodcodomain prodcomm @@ -63131,10 +104622,15 @@ prodcone prodcongr prodcongrleft prodcongrright +prodconst prodcontinuouslinearequiv prodcoproddistrib prodd proddomain +prode +prodefct +prodefin +prodelim prodembeddingdisjointequivsigmaembeddingrestricted prodempty prodeq @@ -63146,29 +104642,40 @@ prodequivofequivnat prodequivofiscompl prodequivpi prodequivpifintwo +prodequivtoiso prodex prodextendrig prodextendright prodf prodfan prodfanislimit +prodfap prodfc prodfclim +prodfct prodfdiv +prodfdivap +prodfinfamily prodfmul prodfn prodfrec +prodfrecap prodfst prodfun prodfunctor prodfunctortofunctorprod prodfunctortofunctorprodassociator +prodfv prodfzo +prodg prodge +prodgp prodgt +prodhom prodhomotopy prodi prodindf +prodinfzero prodinlinr prodinverse prodislocalization @@ -63196,14 +104703,18 @@ prodmapalghom prodmapl prodmaplinear prodmapringhom +prodmatroid prodmk prodmkleft prodmkright prodmo +prodmodc +prodmodclem prodmolem prodmonoidal prodmultiplicative prodmz +prodn prodnateq prodnatequiv prodnts @@ -63212,8 +104723,12 @@ prodofsmulcommclass prodonesu prodonesubpow prodonesum +prodop prodopequiv +prodopseq prodp +prodpcm +prodpefct prodpempty prodpi prodpicons @@ -63229,12 +104744,24 @@ prodpseudoemetricaux prodpunit prodquotientequiv prodquotientofisidempotentelem +prodr prodrange prodrb +prodrbdc +prodrbdclem prodrblem +prodrec +prodreim prodrel +prodrfcte prodright +prodrmn +prodrn +prodrxl +prodrxr prods +prodsetoid +prodsgp prodshear prodsn prodsnd @@ -63242,65 +104769,100 @@ prodsnf prodsns prodspacefun prodss +prodssdc prodsub prodsubtypefstequivsubtypeprod prodsum prodsumdistrib prodswap +prodt prodtms prodtoprodtop prodtoprodtopi prodtp prodtree +prodtuples +produ produc produce producecertificate produced producer -producers produces -produceswine producing product +productcategory productcone productconeislimit +productdivides producte productequiv productext productf +productfunctor +productga producti +productinfsinheriting production +productionalph +productions productislimit productiso productisproduct productive productivei +productlaw productleftalghom productlimitcone productmap +productnorm +producto productofmemopens productofprimes +productplusoneisprime products productsetoid productsfromfinitecofiltered productsproperties +productstructure +productsupsinheriting productto producttofamily producttop +producttopology producttriangle productuniqueiso +productzproduct produit produnique produnits +produnivalg +prodv +prodva +prodvac +prodvc +prodvca +prodvdl +prodvdr +prodvp +prodvs +prodvsl +prodvsr +prodw +prodwr +prodx prodxsubsmul prodzeroiso prodzeroring +prodzz +proerties proet proetaleprecoverage proetaletopology prof profi profile +profilei profileitm profiler profinite @@ -63317,37 +104879,82 @@ profinitesolidispointwiserightkanextension profinitetocomphaus profinitetocomphauseffectivepresentation profinitetocondensed +profit proforma +profunctor prog +progc progd +proge progi +progl progmeasurable +progn +prognt +progr +progra program +programcounter +programi +programkeytype +programlist +programlogic programmer programming +programminglanguage +programp programs +programtrait progress +progressing progression +progressive +progressived progs +progv +prohibited +prohibition +prohibits +proid proj +proja +projc +projco +projd projdata projdeclata +projdes +projdouble +proje projec project projectangel projected +projectee +projectg projecti +projecting +projectio +projectiocell projection projectiondata +projectionequiv +projectionlist +projectionlistapplyparam +projectionlistid +projectionlistind projectionname projectionrule projections projectionsinfo projective +projectivecollinearity projectivedimension projectivefamily projectivefamilycontent projectivefamilyfun +projectivelines +projectivepoints projectivepresentation projectivepresentationofmapprojectivepresentation projectiveresolution @@ -63357,11 +104964,13 @@ projectiveseminormaux projectiveseminormfun projectiveseparator projectiveshortcomplex +projectivespace projectivespectrum projectivity projectivization projectivizationsetoid projectivize +projectl projectmap projectmapaux projectmax @@ -63369,8 +104978,13 @@ projectmin projectobj projector projectorp +projectors +projectplannertest projectquery projectquotient +projectr +projects +projectse projectsrcv projectsubobject projecttable @@ -63379,139 +104993,286 @@ projete projex projexpr projf +projfi +projfinseq +projfl projfn +projformula projgenlingroup +projgroup projh +projhorizon projicc projicccm projici projiic +projim +projin projinfo +projis projisospec projisospectopcomp projisospectopcomponent +projk projkerofrightinverse projl projle projleft projmap +projn projname projnrs +projns projord +projp +projpl +projplan projq projquotient projr +projre +projred +projrepresentable projres projrest projrestrict projrestricts projright projs +projset projsup projt projun +projv projval projvandermonde projzeroringhom prokhorov +prolaag +prolem prolog +prologue prolong prolongation promela +promelaltl +promelastatistics promg promise promised promises +promot promote +promoted promotes +promotevariant +promotion +<<<<<<< Updated upstream +======= prompt +>>>>>>> Stashed changes prone +proo proof proofcertificate +proofed +proofgoal proofinuse +proofirrelevancecontr proofirrelheq +prooflst proofobligation proofoflimitruleofproduct proofoptimalassignment +proofp +proofrule proofs proofsinpublic +proofsp +proofstate +proofstep +prooftheories +prooftheory prooftree prooftreebounded prooftreedeductiond prooftreei prooftreeterminal +proofv proofwidgets proofwiki proofzero +proooobably proot proots prop +propa propag +propagatable +propagatated propagate propagated +propagatefailure +propagateleft propagates +propagation proparrow +propb +propbiimpl +propboolp +propcan +propcat +propcatfunc propclass propcomplete propd propdecidable +propdouble +propdoublebin prope +propeqe propeqop +propeqp +propequiv propequivbool propequivpempty propequivpunit proper +properangle +properbodywhile +propercat propercone properconstsmul properd properdiv properdivisors +propere +properecard +propereneq +propereset +properfactor +properfilter +properfilters +properforupbody +properg properi +properies +properil +properir +properiset +properj properl properly properlydiscontinuoussmul +propernegatedforallbody properness +properp +properply +properprefixes +properproxy +properpset +properr +properror propersmul properspace +propert propertie properties +propertiesalgebraic +propertiess +propertimesbody +propertiy property propertyb +<<<<<<< Updated upstream +======= propertychainaxiom propertydisjointwith +>>>>>>> Stashed changes +propertyi propertyislocal +propertyp +properu +properul +properur +properviaequiv +properw +properwitnessedtype +properxx +propery +propexpr propext propf propfeq +propflip +propform +propholds propi +propiedad +propiedades proplit +proplog propoagate +propord proportion proportional proportionality propos +proposal +propose proposed +proposi +proposit +propositi proposition propositional +propositionalbinderlanguage propositionalequality +propositionallanguage propositionally +propositionalstable +propositionaltransparentmodality +propositionalvariables propositions +propp propqcprecoverage propqctopology +proprel +propresizing +propriety +proprulecharacterise props +propset propssopi +propt +propties propto proptotagged +proptrunc +proptruncidempotent +proptrunctrunc proptypes +propvalidator +propvalued propwff propx +pros +<<<<<<< Updated upstream prose +======= +>>>>>>> Stashed changes proset +prosetequiv +prosetpath +prosetstr +prostu prot protcl protect protecte protected +protectimp +protection protectrefl protects protfw @@ -63520,18 +105281,31 @@ prothprmlem proththd proththdlem proto +protoany protocol protocols +protocolwithindinv +protoreflex +protosymm +prototrans prototype +proudct prov provability provable +provablep provably prove +proveable +proveably +proveall proveascfactorial +provebool provechain +provechecker proved provedexternally +provedp provedresult proveemptyorcons proveemptyorconsresult @@ -63539,7 +105313,11 @@ proveeq proveeqzerousing provefalsebylinarith provefinsetnonempty +provefun +provefunctionalpostcondition +provegenprop provegetlastdimpl +provehyp proveimpl proveintgcd proveintiscoprime @@ -63552,6 +105330,7 @@ provejacobisymodd provele provelt proven +provenance provenatclog provenatfib provenatfibaux @@ -63563,18 +105342,41 @@ provenilorcons provenilorconsresult provenonneg proveonmodcases +provep +provepolyfun +provepolyfunset +proveqprop prover +proverefle +provereflexivebaselegaltransitionssequence +provereflexivelegaltransitionssequence +provereflexivetransitiveinv +proveresult provers proves provetfae +provetransitiveinv +proveunchangednonvolatilefields +proveunchangednonvolatileuserfiel +proveunchangednonvolatileuserfields +proveunit provezeroorcons provezeroorconsresult provi provide provided +provider +providerwrappedikm provides providing proving +provision +provisional +proviso +provrulecharacterise +provrules +prow +prox proximity proxy proxyequivconfig @@ -63585,10 +105387,13 @@ proxytypeequiv prp prpair prpairs +prplnqu prprc +prpred prprelb prprelprb prproe +prproj prproropen prproropf prproropreud @@ -63602,20 +105407,29 @@ prpssnq prpw prpwlem prr +prrep +prreq prring prrngorngo +prs prsal prsdm prsiga +prsimm prslem prslk prsnex prsp prsprel +prsradd +prsrcl prsrcmpltd prsref prsrlem +prsrlt prsrn +prsrpos +prsrriota prss prssad prssbd @@ -63623,12 +105437,16 @@ prssd prssg prsshashgt prssi +prssnql +prssnqu prsspw prsspwg prsss prsssdm prssspr prsssprel +prsstep +prsstp prstcbas prstchom prstchomval @@ -63643,21 +105461,47 @@ prstcthin prstcval prsthinc prstr +prsymbol +prsymbols prt prter +prtermrec prtex +prth prtitle prtlem +pru prub +prubl prufer prule +prulei +prules +prune pruned +pruneinflight prunesolvedgoals +pruning prunioo prv +prvect +prveqlpt prvlem prwf +pry +prz +przeplot +przez +psa +psaa psasym +psatisfiable +psatisfies +psb +psbefore +pscal +pscalar +pscomp pscope psd psdadd @@ -63674,22 +105518,47 @@ psdmvr psdpw psdval psdvsca +pse +psect +psedu +pseduo +psegment psegments +psel +pselect +pselectt +psemresproof psen +psend psep +psepalg +pseparation pseq +pseqv +pser psercn psercnlem pserdv pserdvlem psergf +pseries +pseriesj +pseriess pserulm pserval pset +psetf pseti +psetq +pseu pseud pseudo pseudoapply +pseudobool +pseudocloseness +pseudoclosenessspace +pseudocompact +pseudocontinuous pseudocore pseudodeterministic pseudoedist @@ -63703,6 +105572,7 @@ pseudoemetricisometry pseudoemetricspace pseudoepimorphism pseudoequal +pseudoeventform pseudofunctor pseudofunctorleft pseudofunctorofislocallydiscrete @@ -63713,24 +105583,46 @@ pseudofunctortopith pseudofunctortopithcompinclusionstrongisohom pseudofunctortopithcompinclusionstrongisoinv pseudoha +pseudolattice +pseudolatticeequiv +pseudolatticepath +pseudolatticestr +pseudom pseudome +pseudometr +pseudometri pseudometric pseudometricdilation pseudometricisometry +pseudometricnormedzmodtype pseudometricspace pseudometricspacemax pseudometricspaceofnormedaddcommgroupofaddtorsor pseudometricspacetopi pseudometricspacetoprod +pseudometrictype pseudometrizablespace pseudometrizablespacepseudometric pseudometrizablespaceuniformity +pseudomonic pseudonatural +pseudoorder +pseudop pseudoperfect +pseudopmetrictype pseudoprime pseudoprimes +pseudopro +pseudoproj +pseudorandom pseudorandomgenerator +pseudorefs +pseudosemiringorder +pseudoterm +pseudoyoneda pseudozero +psfis +psfs psgn psgnco psgndif @@ -63757,6 +105649,7 @@ psgnodpmr psgnpmtr psgnprfval psgnran +psgns psgnsn psgnuni psgnunilem @@ -63765,6 +105658,14 @@ psgnvalfi psgnvali psgnvalii psh +psha +pshare +pshareval +pshb +pshcat +pshift +pshiso +pshufb psi psigma psigmaassoc @@ -63772,13 +105673,30 @@ psigmacongrright psigmaequivsigma psigmaequivsigmaplift psigmaequivsubtype +psign +psiinv +<<<<<<< Updated upstream +======= psildecval +>>>>>>> Stashed changes psim psimp +psing +psingle +psint +psiua psize +psized +psk +pskip +psl pslem pslice pslicei +pslla +pslldq +psllq +pslw psmeasure psmeasurelem psmet @@ -63787,16 +105705,37 @@ psmetdmdm psmetf psmetge psmetlecl +psmetrel psmetres psmetsym psmettri psmetutop psmetxrge psmf +psmon psn +psnd +psnext +psnoc pso +psoccur +psome +psorder +psort +psorted psp +pspace +pspec +psphere +psplit +psplitinj +psplitinjt +psplitsurjt +psplla +pspv +psqrt psr +psra psradd psraddcl psraddclold @@ -63804,6 +105743,8 @@ psrascl psrasclcl psrass psrassa +psraw +psrawi psrbag psrbagaddcl psrbagcon @@ -63811,29 +105752,45 @@ psrbagconcl psrbagconf psrbagev psrbagf +psrbagfi psrbagfsupp psrbagleadd psrbaglecl psrbaglefi psrbaglesupp +psrbaglesuppg psrbagres psrbagsn psrbas psrbasfsupp +psrbasg psrbaspropd psrc +psrcofs psrcom psrcrng +psrd +psrdat psrdi psrdir +psre psref psrel psrelbas +psrelbasfi psrelbasfun +psresproof +psrf +psrfb +psrfbwrite psrgrp +psri +psrj +psrldq psrlidm psrlinv psrlmod +psrlq psrmnd psrmulcl psrmulcllem @@ -63841,21 +105798,33 @@ psrmulfval psrmulr psrmulval psrn +psrname psrneg psrnegcl psropprmul psrplusg +psrplusgg psrplusgpropd psrpr +psrprg +psrq +psrrd psrridm psrring +psrs psrsca +psrt +psrv psrval psrvalstr +psrvalstrd psrvsca psrvscacl psrvscafval psrvscaval +psrw +psrwa +psrz pss pssdif pssdifcom @@ -63873,6 +105842,7 @@ pssned pssnel pssnn pssnssi +pssp psspwb psss psssdm @@ -63882,17 +105852,42 @@ psssstr psssstrd psstr psstrd +pssubst pssv pst +pstable +pstar pstate +pstateequiv +pstatep +pstates +pstatesepalgops +pstatet +pstatetype +pstatus +pstb +pstbx pstep +psterm +pstermp +pstfd +pstfdx +pstfs +pstfsx +psth +psthx pstmfval pstmval pstmxmet pstomet pstr pstring +pstrip psttkabxg +pstuple +pstv +pstw +pstwx psub psubatn psubcli @@ -63902,6 +105897,12 @@ psubcln psubclsetn psubclssatn psubclsubn +psubfc +psubfe +psubfic +psubgroup +psubgroupj +psubj psubm psubn psubnormal @@ -63913,24 +105914,58 @@ psubspi psubspset psubssat psubst +psubterm +psubtrees +psuc +psuedo +psueod psuf psum +psumb psumcongr +psumd +psume psumequivsum +psumid +psummable +psumn psumpart +psumr psums psumsum +psumz +psumzr +psuntil psup +psuperset +psurj +psusp pswap +pswhile +<<<<<<< Updated upstream +======= psych psychologicalattribute +>>>>>>> Stashed changes psyl +psylow psym +psymmetric +psz pta +ptag +ptail +ptannot +ptaut +ptb ptbas +ptbase ptbasfi ptbasid ptbasin +ptbounded +ptc +ptclasses ptcld ptcldmpt ptcls @@ -63942,31 +105977,52 @@ ptcmplem ptcn ptcnp ptcnplem +ptcon +ptcongruence +ptd ptdefault +ptdenop +ptdfunctor +ptdiso +ptdmapseqequiv +ptdmapseqmap +ptdmapsequence +ptdmapsequenceequiv pte +ptem +ptempty ptendst ptendsto pterm +ptermination +ptermp pterms +ptest +ptex +ptfam ptfin ptfinfin ptgt pth pthacycspth pthaus +pthc pthd pthdadjvtx pthdepisspth pthdifv pthdivtx pthdlem +pthen pthfrgr pthfrgrrn pthhashvtx +pthi pthisspthorcycl pthistrl pthiswlk pthlem +pthm pthnloop pthnlp pthon @@ -63977,65 +106033,143 @@ pthontrlon pthonv pthroot pthrootmonoidhom +pths pthsfval pthsonfval pthsonprop pthspth pthspthcyc +<<<<<<< Updated upstream +======= ptions +>>>>>>> Stashed changes +ptl +ptlist +ptltl +ptlz +ptm +ptmin +ptn ptolemy ptonat ptop +ptoper ptopn +ptopologicaltype ptorsion ptos +ptpapply ptpconn ptpjcn ptpjopn ptpjpre +ptpm +ptpml ptr +ptra ptram ptrans +ptransitive +ptrbits ptrd +ptre ptrecube ptree +ptrees +ptreew +ptreq ptrescn ptrest +ptrivial +ptrk ptrm ptrmap ptrofs +ptrofsconst +ptrp ptrs ptrset +ptrt +ptrue +ptrx pts +ptse +ptsn +ptsnonempty ptsofperiod +ptsto +ptstosize +ptsu +ptsum +pttctrs pttop pttopon pttoponconst +pttype ptuncnv ptunhmeo ptuni ptuniconst ptunimpt ptval +ptvars +ptwo +ptws +ptx +pty +ptype +ptypefailure +ptyping +ptz pua pub +pubak +pubblockslocalsrc pubblockssrc pubblockstgt +pubchar pubconst pubconsts +pubconstvalue pubek pubk pubkey pubkeys +publ public +<<<<<<< Updated upstream +======= publication +>>>>>>> Stashed changes +publickey +publickeybytes +publickeytype +publicmatrixbytes publicv +published +publishers +pubpriv +pubs +pubsk pubsrc +pubsrccontra pubsrchyp +pubt pubtgt +pubtgtcontra +pubtgthyp +pubval +pubvals puc pucanonic +puede +puesto +puff +puimmersion +puiseux +puiss pul +pulb pull pullb pullbac @@ -64046,6 +106180,7 @@ pullbackassocispullback pullbackassocsymmispullback pullbackaway pullbackbiprodinlbiprodinr +pullbackcommringscategory pullbackcomp pullbackcomparison pullbackcompatible @@ -64084,6 +106219,7 @@ pullbackgluediso pullbackhom pullbackhomeopreimage pullbackhomisopushforwardinv +pullbacki pullbackid pullbackinvisopushforwardhom pullbackiso @@ -64154,10 +106290,24 @@ pullout pulls pullstep pullsub +pullup +pullw +pulse +pump pumping +pumpinglemma +pun +punch punchin punchout +punchoutequiv +punct +punctuation punctured +pung +puniform +puniformtype +puniq punique punit punitalgequiv @@ -64174,35 +106324,99 @@ punitiso punitisterminal punitofnonemptyofsubsingleton punitprod +punpun +punstn +puntag +puntil pup +pupdate +purchaseloc pure +purea +pureandsc +pureandscd +pureat +purebilfun +purebilfunop +purebilpre +purebilpreop +purebool +purebr purecauchy +pureclause purecoherence +purecr +purecrrec +purecrs purei +pureimplsi pureinst pureisdefeq +pureitreeeffectobs +pureitreemorph +pureitreeorder +pureitreeorderm +pureitreespec +pureitreespeceq +pureitreespeclaws +pureitreespecmonad +purel +pureloop purely puremonoidhom puremulhom +pureneg pureonehom +pureop +pureorthorelstr +pureout +purep +purepos +pureposp +pureprodcr +pureq purer +pures +purescand +puresiimpl +puresumcr puretransformation +pureu +purex purge +purged purgeidle +purification +purify +purifysep purity +purported purpose purposefully purposely purposes +purpouses +purse +pus push +pushad pushattr +pushc pushcastext +pushcat +pushcatego +pushcategory +pushcell pushconfig pushcore +pushcs +pushdown pushed pushes pushext pushf +pushfast +pushflow pushfo pushfold pushformaterror @@ -64228,16 +106442,30 @@ pushforwardpushforwardequivalence pushforwardsections pushforwardtoofiso pushforwarduncurry +pushframe pushfvaraliasinfo +pushh +pushhandler pushin pushinfoleaf pushing +<<<<<<< Updated upstream +======= pushingababycarriage pushingwithfingers pushingwithopenhand +>>>>>>> Stashed changes +pushinitframe +pushl pushn pushnegbuiltin +pushnew pushnewgoal +pusho +pushoperand +pushoperandstac +pushoperandstack +pushopstack pushou pushout pushoutassoc @@ -64255,9 +106483,13 @@ pushoutcoconeofrightiso pushoutcoconeofrightisoislimit pushoutcomp pushoutcomparison +pushoutcompequiviso pushoutdesc +pushoutemptydomainiso +pushoutemptyfam pushouti pushoutid +pushoutidfunequiv pushoutinl pushoutisleftadjoint pushoutisooppullback @@ -64270,45 +106502,94 @@ pushoutmap pushoutobjiso pushoutobjobj pushoutofhasexactlimitsofshape +pushoutpath pushoutpushoutleftispushout pushoutpushoutrightispushout +pushoutreplacebase pushoutrightiso pushoutrightpushoutinliso pushouts pushoutsection +pushoutsquare +pushoutsusp +pushoutsuspisosusp +pushoutswitchequiv pushoutsymmetry +pushouttosquare +pushoutunit pushoutzerozeroiso +pushprod +<<<<<<< Updated upstream +======= pushprop +>>>>>>> Stashed changes +pushq pushquiver +pushr +pushs +pushsi pushsimpconfig +pushstack pushstep +pushupcastintolshift +pushus +pushv put +putative +putback +putbit +putbits +putbyte +putcacheentry +putcacheentryensurespublicly +putcacheentryinput +putchar putelim putfield +putitemensurespublicly +putkeypolicyensurespublicly +putlist +putlistgd +putm +putmany +putresourcepolicyensurespublicly puts putsdown putstatic putstr putstrln putting +putword +putwordinsidehyperlink +putwordinsidetag puv pux puz puzzle pval -pvalid +pvale +pvalr +pvals pvanishes pvanishesd pvanishesi pvar +pvars pverismo pverts +pvh +pvi pvjxuscvkavzccbxddgai +pvl +pvp pvr pvs pvsca +pvsub +pvv pvw pvzrwtcjfd +pwadjoin pwalt pwcfsdom pwcl @@ -64322,6 +106603,7 @@ pwdjuen pwdjuidm pwdjundom pwdom +pweiwbz pwel pwelg pwen @@ -64329,12 +106611,16 @@ pweq pweqalt pweqb pweqd +pweqeq pweqi pwex pwexb pwexd pwexg pwexr +pwf +pwff +pwffs pwfi pwfilem pwfilter @@ -64342,10 +106628,12 @@ pwfin pwfir pwfseq pwfseqlem +pwg pwhile pwid pwidb pwidg +pwild pwin pwinfi pwinfig @@ -64353,8 +106641,10 @@ pwits pwitsd pwitsi pwjust +pwl pwldsys pwle +pwlem pwm pwmnd pwmndgplus @@ -64362,16 +106652,21 @@ pwmndid pwmul pwmulfv pwne +pwneg pwnex pwnss +pwntru pwo pwp pwpr +pwprss pwpw pwpwab pwpwpw pwpwssunieq pwpwuni +pwr +pwrit pwrite pwrssmgc pws @@ -64408,6 +106703,8 @@ pwsms pwsmulg pwsmulrval pwsn +pwsnalt +pwsnss pwspjmhm pwspjmhmmgpd pwsplusgval @@ -64420,25 +106717,33 @@ pwssnf pwssplit pwssub pwssun +pwssunim pwstps pwsval pwsvscafval pwsvscaval pwsxms pwt +pwti pwtp +pwtpss pwtr pwtrrvd +pwtrufal pwtrvd pwu pwun pwuncl pwundif +pwundifss pwuni +pwunim pwuninel +pwuninelg pwunss pwv pwvabrel +pwviiol pwvrel pwvrelb pwwf @@ -64446,12 +106751,28 @@ pwxpndom pwz pwzx pxel +pxguard pxkthapzwz +pxm +pxmqx +pxor +pxori +pxoris +pxp +pxqx pxs +pxy pya pyel +pym +pymqy +<<<<<<< Updated upstream +======= pyramid +>>>>>>> Stashed changes +pys pyth +pytha pythag pythagoras pythagorean @@ -64462,73 +106783,160 @@ pythagtriplem pythf pythfok pythi +pythok python pythrel pythreloo +pythtrip +pzero +pzfmisc +pzl +pzm pzr +pzringtype pzriprng pzriprngalt pzriprnglem +pztoc +pztoq pzuz pzx qaa +qabs qabsab qabsabv +qabsor +qabsord qabvexp qabvle qact +qacte +qactecond +qactj +qacts +qactuals +qadd qaddcl +qaddinv +qadic +qafhjnm qahy qalgebra +qall qam qamic +qand +qapne +qappend +qapprox +qar qaryentropy +qas +qassoc +qattr +qavgle qbar qbczgzgeejkpnviosdtpgvocmmqjtgirkz qbf qbinomial qbit +qbr qbracket qbs qbsb qbtwnre +qbtwnrelemcalc qbtwnxr +qbtwnz +qbytes +qcaller +qcanon +qcar qcase qcat qccoverfamily qcd +qcdefconjunctive +qcdefd +qcdefuniversal +qcdr +qcdresult +qcfuncex +qcfuncexn +qcfunctional +qcfuncuniq +qcind +qclass +qclose qcn +qcoh qcompequivalencefrommodelfunctoriso +qcomplete +qcomponent +qcond qcong +qcons qconv +qcor +qcp qcprecoverage qcqs +qcs qct qculift qcvs qdass qdassr +qdceq +qdcle +qdclt qdelta qden qdencl +qdencn +qdenre qdensere qdenval +qdeps +qdequeue qdf qdfst +qdiag qdiff qdiv qdivcl qdivide +qdivivide qdrng +qds qdsnd +qec qed +qef +qelem +qelemb +qelement +qelim qelioo +qels +qelvs qemb +qempty qenom +qenqueue +<<<<<<< Updated upstream +======= qepres +>>>>>>> Stashed changes qeq qeqnumdivden +qequiv +qer qerclwwlknfi +qerdescends +qerror +qes +qev qex qexalt qexjarijxqwnpfmxrfmhywfvvhwnfgcizskc @@ -64547,36 +106955,87 @@ qextlt qextltlem qfa qfact +qfactor qfactorsthroughhomotopy +qfalse +qfe qfield +qfier qfld qfn +qform +qfracge +qfraclt +qframe qfree qft qfto qfun +qfunctional +qfx +qgamma +qglob +qglue qgt +qhead qhii +qhmap +qhom +qhomographic qiaznzqqq +qic +qidem +qif +qiff qify +qigen +qill +<<<<<<< Updated upstream +======= qilt +>>>>>>> Stashed changes +qimp +qimpl +qin +qinc qinfty qinioo +qinj +qint +qinter +qinterp +qintp qinv +qinveq qinverse +qinvs qirr qirropth qis qiso qisom +qisome qiter +qiterg +qiterl +qjoin qkg +qknvmlb qkoq qkuyzvv +qlast qlax qlaxr qle +qlelttric +qlem +qlemma +qlen qlength +qletric +qlhoml +qli +qlift qliftel qliftf qliftfun @@ -64585,27 +107044,53 @@ qliftfuns qliftlem qliftrel qliftval +qlist +qlit qlock +qlt +qltlen +qltnle +qlttri +qma qmap qmapeldisjs qmapeldisjsbi qmapeldisjsim qmapex +qmark +qmax +qmaxsize +qmc +qmconv +qmean +qmeet +qmin qminus qmkaeu qml -qmltpeq qmmp qmod qmonic +qmont +qmorphism qmp qmpt +qmsg +qmul qmulcl qmuldeneqnum qmult +qmultinv qmultiplicity qmulz +qmx qnabyeoypymn +qnan +qnanize +qnanp +qnat +qnatp +qnc qndenserrn qndenserrnbl qndenserrnbllem @@ -64613,9 +107098,17 @@ qndenserrnopn qndenserrnopnlem qneg qnegcl +qnegmod +qneq +qnew qnf +qnlimb qnminus qnnen +qnodes +qnorm +qnot +qnum qnumcl qnumdenbi qnumdencl @@ -64626,19 +107119,38 @@ qnvetgiaohqtuymezmbgqhbt qommcah qone qookjckqoxiqncilyguabahmqhpyuu +qop qopp +qopt +qor +qoset qoutmapequivtensorqout +qov +qovr qoxqavfxeklcazdoiouktwvhx qparam +qpd qpf qplus +qpm qpochhammer +qpoly qpos qposit qpositive +qpost +<<<<<<< Updated upstream +======= qpp qpr +>>>>>>> Stashed changes +qpre +qpref +qprefix +qprefixes qprod +qprop +qpunsized qqadgrvhtbfvfbwaoathyeuuignedq qqh qqhcn @@ -64659,14 +107171,21 @@ qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq qqtopn +qquadratic +qqzktxu qrdich qrdivcl +qrdyxyj qre qreccl qred qredeq qredeu +qrem +qreprk qrevaddcl +qreverse +qreverseiscorrect qrexpcl qrexpclnn qrgap @@ -64676,12 +107195,15 @@ qrge qrgt qright qrmulcl +qrnd qrne qrng qrngbas qrngdiv qrngneg qroot +qroots +qrpprod qrre qrreccl qrrp @@ -64690,6 +107212,8 @@ qrss qrval qsalrel qsbugshzznkyqetadj +qsc +qscope qsdisj qsdisjaltv qsdrng @@ -64698,9 +107222,12 @@ qsdrngilem qsdrnglem qsel qseq +qset qsex qsexg qsfld +qsgn +qsh qshash qsid qsidom @@ -64708,11 +107235,17 @@ qsidomlem qsiedprmkzq qsinxp qsize +qslist qsmul qsnuj qsnzr qsort +qsq qsqcl +qsqeqor +qsqr +qsqrt +qsquare qsqueeze qsresid qssaa @@ -64721,19 +107254,36 @@ qssre qsss qsssubdrg qstar +qstate +qstor +qstorp +qstring +qsub qsubcl qsubdrg +qsubst qsubt +qsuff +qsuffix qsxpid +qsym +qsymm qtable +qtablee +qtablei +qtemp +qth qtimes qtj qtlwqkju qtm qtmset +qtoc +qtol qtop qtopbas qtopbaslem +qtopbasss qtopcld qtopcmap qtopcmp @@ -64756,16 +107306,32 @@ qtoptop qtoptopon qtopuni qtopval +qtrap +qtri +qtrichotomy +qtrue +qtrunc +qts qtt qttcontext qtttypechecker qty qua quad +quadbyte +quadbytebytelist +quadbytevallist +quadchoicerec +quadchunk quadchunks +quadr +quadrangle quadrant quadrants +quadrartic +quadrat quadratic +quadraticacc quadraticalgebra quadraticchar quadraticcharfun @@ -64774,21 +107340,58 @@ quadraticmap quadraticmodulecat quadres quadrilateral +quadrilaterals +quadrileral +quadrisection +quadro quadroot +quadrot +quadrseq quadruple quadruples +quads +quadword +quadwordrep +quadwordrepi +quadwr +quady +quake +qual +qualife qualified +qualifiednames qualifier +qualifiers qualifies +qualify +quality +quals quandle quandles quant +quantal quantale +quantalestr +<<<<<<< Updated upstream +======= quantdemorgan +>>>>>>> Stashed changes +quanthoare +quanti +quantif +quantifer +quantifiable quantification quantified quantifiedvarmap quantifier +quantifierexists +quantifierforall +quantifierlanguage +quantifierlogic +quantifieronly +quantifierp +quantifierrange quantifiers quantifies quantify @@ -64796,27 +107399,53 @@ quantifying quantitative quantities quantity +<<<<<<< Updated upstream +======= quantitychange +>>>>>>> Stashed changes +quantnbr quants +quantt +quantum +quaop +quaopeq +quaopex +quaoplambda +quard +quarity +quark quart quarter +quarternaryp +quarterround quarters +quartet +quartets quartfull quartic quartlem quasi +quasiadjs quasiamicable quasicategory +quasicoher +quasicoherence quasicoherentdata quasicoherentdataofisfinitepresentation +quasicoherently quasicom +quasicomm quasicompact quasicompactcover quasicomplete quasicompletespace quasiconcaveon +quasiconvex quasiconvexon +quasidecidability +quasidecidable quasieq +quasiequivrel quasiergodic quasifi quasifinite @@ -64824,17 +107453,29 @@ quasifiniteat quasifinitelocus quasigroup quasii +quasiidempotence +quasiidempotent quasiis quasiiso quasiisoat quasiisole quasilinearon +quasiloci quasimeasurepr quasimeasurepreserving quasimorphism quasinat +quasinet +quasinetstr quasinorm +quasiordered +quasiorthocomplement +quasiorthocomplemented +quasiorthoposet quasiperiod +quasiperiodic +quasipure +quasipureorthorelstr quasired quasiregular quasiring @@ -64845,7 +107486,15 @@ quasisober quasispectrum quasispectrumcompact quasispectrumrestricts +quasiterm +quasiterms +quasitree +quasitypes quat +quate +quater +quatern +quaterni quaternion quaternionalgebra quaternionbasis @@ -64854,17 +107503,26 @@ quaterniongroupzeroequivdihedralgroupzero quaternions qubit qubits +que queens +quelques queries queriesi query +queryensurespublicly +queryparams +queryprotocol question +questionable questiondown -questioning -questionmark questions +questiont +questo +queu queue queueenqueue +queuepm +queueprog queues quick quickcheck @@ -64873,25 +107531,48 @@ quickchick quickchickdebug quicker quickfix +quickflow quickly quicksort quicksortcorrect +quiet +quin +quindi +quintuple +quit +quitc quite +quitop quiv quive quiver +quivercategory +quiverhomomorphism +quiverhomomorphismequivalence +quivers quo quodlibet +quofiel +quofield +quoitient +quore quoremnn quoremz quorum +quoset +quosetequiv +quosetpath +quosetstr quot +quotadd +quotaddinv quotadjoinequivquotmap quotadjoinrootequivquotpolynomialquot quotannihilatorequiv quotation quotations quotcan +quotcharact quotcl quotconjequiv quotcontext @@ -64900,9 +107581,12 @@ quotdgr quotdualcoannihilatortodual quotdualequivannihilator quote +quoted quoteddefeq quoteexitcode quotep +quotepi +quoteps quotequivannihilator quotequivofeq quotequivofeqbot @@ -64912,12 +107596,19 @@ quotequivpowquotpowsucc quotequivpowquotpowsuccequiv quotequivquotmap quoteresult +quotes +quotesp +quoteterm +quotetest +quotf +quotge quoti quotidealmapequivtensorquot quotidealmapequivtensorquotaux quotie quotien quotient +quotientabgroup quotientaction quotientaddequivofeq quotientaddgroup @@ -64931,14 +107622,18 @@ quotientbyautterminalequivuniquequotient quotientcenter quotientcenterembedding quotientcentralizerembedding +quotientchoice quotientcompqhiso quotientcotan quotientcotangentideal quotientcotangentidealringequiv quotientd +quotientdg quotientdiag quotientdiff +quotientdistributive quotiente +quotientequalitylemma quotientequiv quotientequivalg quotientequivalgofeq @@ -64960,10 +107655,14 @@ quotientequivsigmazmod quotientfp quotientfunc quotientfunctor +quotientgi +quotientgk quotientgroup quotientgroupcon quotientgroupmk +quotienthom quotienti +quotientig quotientiinfembedding quotientiinfsubgroupofembedding quotientinfequivprodnormalizerquotient @@ -64974,7 +107673,10 @@ quotientinfringequivpiquotient quotientinftopiquotien quotientinftopiquotient quotientinftosupquotient +quotientinorm quotientisometryequivofeq +quotientj +quotientk quotientkeralgequivofrightinverse quotientkeralgequivofsurjective quotientkerequivofrightinverse @@ -64990,12 +107692,17 @@ quotientmapofle quotientmapsubgroupofofle quotientmeasure quotientmeasureeqmeasurepreimage +quotientmidl +quotientmidr quotientmk +quotientml quotientmodule +quotientmr quotientmulequiv quotientmulequivofeq quotientmulequivquotientprod quotientn +quotientnode quotientout quotientp quotientpathsequiv @@ -65003,6 +107710,7 @@ quotientpathsto quotientpequiv quotientpi quotientpilift +quotientproprel quotientqpf quotientquotientequivquotient quotientquotientequivquotientaux @@ -65010,17 +107718,22 @@ quotientquotientequivquotientsup quotientquotientisometryequivquotient quotientquotientliequotient quotientquotientliequotientsup +quotientr quotientrangeinlequivright quotientrangepowquotsuccinclusionequiv quotientrel quotientrightrelequivquotientleftrel quotientring +quotientrule quotients +quotientsgk +quotientsk quotientspancxsubcalgequiv quotientspancxsubcxsubcalgequiv quotientspanequivzmod quotientspannatequivzmod quotientspanxsubcalgequiv +quotientsub quotientsubgroupofembeddingofle quotientsubgroupofmapofle quotientt @@ -65038,10 +107751,17 @@ quotienttoquotientrangepowqu quotienttoquotientrangepowquotsucc quotienttoquotientrangepowquotsuccaux quotienttorsion +quotientu +quotientv quotientxyidealequiv +quotienty +quotientyidl +quotientyidr +quotientyk quotientzmultiplesequivzmod quotientzmultiplesnatequivzmod quotinfo +quoting quotintnorm quotinv quotkerequivofsurjective @@ -65055,11 +107775,21 @@ quotm quotmapcmapspanmkequivquotmapcquotmapmk quotmapequivquotquotmap quotmapofequivquotmapcmapmk +quotme quotmk +quotmsal +quotmsalg +quotmult +quotmultinv quotnilradicalequivpi quotoflistconssmultopequivquotsmultopinner quotoflistconssmultopequivquotsmultopouter quotofmul +quotop +quotopseq +quotosa +quotosalg +quotp quotprecheck quotquotequivcomm quotquotequivquotofle @@ -65069,6 +107799,11 @@ quotquottoquotsup quotquotuliftaddequiv quotr quotrem +quotremneg +quotremnegpos +quotrempos +quotrempospos +quotres quotsmultop quotsmultoptensorequivquotsmultop quottensorequivquotsmul @@ -65077,20 +107812,30 @@ quottodoublecoset quottoquotulift quottorsionofequivspansingleton quotulifttoquot +quotunivalg quotval +quotw +quqx +quqy +quqya +quqyb qus qusabl qusadd qusaddf qusaddflem +qusaddflemg qusaddval qusaddvallem +qusaddvallemg qusbas quscrng qusdimsum quseccl qusecsub quselbas +quselbasg +qusex qusghm qusgrp qusima @@ -65113,10 +107858,13 @@ qusrn qusrng quss qussub +qustate +qustatep qustgp qustgphaus qustgplem qustgpopn +qustion qustps qustriv qustrivr @@ -65124,13 +107872,30 @@ qusval qusvscpbl qusvsval qusxpid +quternion +quux +qux +qvar +qvars +qvs +qwertyuiop +qword +qwords qwztcfotlbazcavtra +qxd qxeuoi qxs +qxskiit +qxy +qyi +qzecfic qztyfb qzu +raa raaan +raaanlem raaanv +raabe rab rabab rababg @@ -65168,6 +107933,7 @@ rabeqdv rabeqel rabeqf rabeqi +rabeqif rabeqsn rabeqsnd rabex @@ -65200,7 +107966,9 @@ rabren rabrenfdioph rabrexfi rabrsn +rabrsndc rabs +rabse rabsn rabsnel rabsneq @@ -65219,6 +107987,7 @@ rabsspr rabssrabd rabsssn rabsstp +rabstrx rabsubmgmd rabswap rabtr @@ -65229,18 +107998,23 @@ rabun rabxfr rabxfrd rabxm +rabxmdc rabxp rac racc +raccv race races rachet +raci rack racks +raconv ract racte raction ractperme +racy rad radcnv radcnvcl @@ -65254,14 +108028,25 @@ raddf raddfb raddfd raddfmn +raddfmnat raddfmnn +raddfmsign raddfmz raddfn +raddfz +raddfznat +raddfzsign raddswap radem rademacher +radi +radial radiant +<<<<<<< Updated upstream +======= radiating +>>>>>>> Stashed changes +radiation radica radical radicali @@ -65269,31 +108054,49 @@ radicalinftophom radicals radii radius +radiuspart radix radixmorethanone radixrangeboundexp +radjoint rado radon +radv raft raftnethandler +raftparams raftstate rag ragcgr ragcol ragcom +rager ragflat +ragged ragmir ragncol ragperp ragtriva ragtrivb +rah +rai +railway +rain +rainbow rais raise raisecone raised +raisei +raisek +raiselast +raisemetrics +raisent raises +raiset raising raisonnable +rakn ral ralab ralabso @@ -65339,9 +108142,12 @@ raleqi raleqold raleqtrdv raleqtrrdv +ralexim ralf ralfal ralfj +ralg +ralgebra ralidm ralidmw ralim @@ -65361,6 +108167,7 @@ ralimralim ralin ralinexa raliunxp +ralm ralmo raln ralndv @@ -65398,6 +108205,7 @@ ralrp ralsn ralsng ralsngf +ralsns ralsnsg ralss ralssiun @@ -65411,6 +108219,7 @@ ralunsn raluz ralv ralvw +ralwaysholds ralxfr ralxfralt ralxfrd @@ -65420,26 +108229,33 @@ ralxpf ralxpmap ralxpxfr ram +ramana ramanujan ramcl rami +ramif ramification ramificationidx ramificationidxin ramifiedp ramifiedplacesover +ramify ramlb +ramp ramsey ramtcl ramtlecl ramtub ramub ramubcl +ramulxnt ramval ramxrcl ramz ran ranadjunction +ranalysis +ranan rancompisoofpreserves rancomplimiso rancounit @@ -65449,15 +108265,50 @@ randbound randfin randgt randnat +randoffset random randombids +randombytes +randomcoins +randomfree randomfunc randomgen +randomhistory +randomi randomisation +randomize +randomly +randomness +randomoracle +randomqa +randomqc randomr +randomrbool +randomrboolcorrect +randomrcorrect +randomrint +randomrintcorrect randomrio +randomrn +randomrnat +randomrnatcorrect +randomrncorrect +randomseed +randomseedtree +randomsplit +randomsplitassumption +<<<<<<< Updated upstream +randomvar +======= +>>>>>>> Stashed changes +randomvardomain +randomvardomainstream +randomvariable +randomvarmap +randp randt ranfn +ranfnex ranfval rang range @@ -65468,6 +108319,7 @@ rangec rangecomap ranged rangee +rangeempty rangefactorization rangefin rangei @@ -65477,17 +108329,34 @@ rangeinr rangeit rangekerlift rangeliftinclusion +rangelist +rangelistvariable +rangelte +rangem +rangemap +rangemask +rangenat +rangenatlt rangeofwtype rangep +rangepos +rangeposprefixfree rangeqtint +rangerepl rangerestrict rangerestrictfield rangerestrictfieldequiv ranges +rangesetofpairs rangesingleton +rangesort +rangespec rangesplitting rangesplittingimageequiv rangesrestrict +rangevarb +rangevars +rangl rangle ranissheafofiscocontinuous rank @@ -65502,6 +108371,7 @@ rankdmr ranked rankel rankelb +rankelem rankelg rankelop rankelpr @@ -65521,11 +108391,13 @@ rankinfinite ranking rankingd rankingi +rankj rankk rankleone rankleonestruct ranklim rankmapu +ranknull rankofdiscrbdd rankon rankone @@ -65569,16 +108441,34 @@ rankzero ranobjobjisolimit ranpropd ranrcl +ranres +rans ransecmat +ranspace +ransref ranup ranval +rao +rap raph +<<<<<<< Updated upstream +======= rapid +>>>>>>> Stashed changes +rapp rar +rara +rarchimedean +rare rarely +rarg +rargp rargs +raro rarray rarrayexpr +rarrow +rarrowt ras rasb rassoc @@ -65587,70 +108477,124 @@ ratadd ratalgebra ratapprox ratarm +ratbitp ratcast ratcd +ratck +ratd ratden ratdi ratdistan ratdistance rate +rateinbytes +ratform ratfps +ratfrac ratfraction ratfunc ratfunca ratfuncadiccompl ratfuncadiccomplpkg ratfuncadiccomplringequiv +ratfuncnf +rath rathalf +rathead rather +rati ratidentityindiscernables ratintro ratinverse ratio ratiohom +ration +rationa rational rationalcauseqpkg rationale +rationaleqimpliesrealeq +rationalism rationality +rationalizable +rationalize +rationalizes +rationalleqimpliesrealleq rationalmap rationalp rationalroottheorem rationals +rationaltoo +rationn +rationr +ratiop +ratiorn ratios +ratiovv +ratk ratl ratlinear +ratlist ratlt ratmax +ratmsb ratmult +ratn +ratnd ratnorm ratnum ratofterminates ratonehalf +rator +ratp +ratpair +ratplus ratr ratreal ratrel rats +ratshift +ratslice +ratsplice ratsqrt ratsubtract rattac +rattail rattranslation rattriangleinequality +ratx +ratz +ratzd +ratze +ratzm +ratzn +rauto +rautosubgoals +raux ravg raw +rawalgebra +rawall +rawalll rawalternative rawapplicative rawapplicativezero rawbimodule rawbisemimodule rawca +rawcall rawcast -rawchoice rawcomonad +rawderive +rawdtree +rawdtrees rawendpos rawexpr rawfoldable rawfoldablewithdefaults +rawfpm rawfunctor +rawfv rawgroup rawialternative rawiapplicative @@ -65664,6 +108608,8 @@ rawimonadt rawimonadwriter rawimonadzero rawintlitnatabs +rawinttypes +rawiso rawlattice rawleftmodule rawleftsemimodule @@ -65681,12 +108627,22 @@ rawmonadstate rawmonadt rawmonadzero rawmonoid +rawmonoidequivstr +rawmonoidstructure +rawmonoidunivalentstr rawnatlit rawnearsemiring +rawnext +rawp +rawpm +rawpml rawpmonad +rawpms rawpow +rawpsubst rawpushout rawquasigroup +rawreadinst rawrightmodule rawrightsemimodule rawring @@ -65700,36 +108656,98 @@ rawritesizesame rawsemimodule rawsemiring rawunivs +rawxor +rawzdib +rax +raxiom ray +rayimpliescollinear rayleigh rayleighquotient rayofnezero rays +raystrict +raytracer rayvector +raz +razie rba +<<<<<<< Updated upstream +rbac +======= +>>>>>>> Stashed changes +rbag rbaib rbaibd rbaibr +rbalance +rbankselect +rbappend +rbar +rbasis +rbb +rbbr rbc +rbcons +rbd +rbdecomp +rbdt +rbeg +rbel rbg +rbhd +rbi +rbilinear +rbinopdefuniq +rbinv +rbit +rbits +rbk +rbl rblem rblit +rblot +rbnil +rbnode rbody +rboolvar rborel +rbp +rbprepend +rbr +rbra rbrace +rbracet +rbracket +rbrackt rbrakk +rbreak rbropap rbropapd +rbs +rbsh +rbsnoc rbst rbsyl rbt +rbtl rbtree rbtreeify +rbu +rbuf +rbupdate +rbupdatel +rbvalue rbvkmrxbqysbjw rbx rca +rcai rcancel +rcancelaction +rcancelp +rcancels rcaninv +rcars rcas rcase rcases @@ -65737,17 +108755,35 @@ rcasespat rcb rcc rcd +rcdfn +rcdiamond rcdk +rcdp +rcds +rcdt rceil +rceile +rcent rcenter rces rcf +rcfn +rcftype rcg +rch +<<<<<<< Updated upstream +======= rcharacterdata +>>>>>>> Stashed changes +rchars rchild rchk rchtgt +rcinner +<<<<<<< Updated upstream +======= rcircle +>>>>>>> Stashed changes rcis rcl rcleq @@ -65760,51 +108796,146 @@ rclikecommalgebra rclikecomposition rclikenormed rcliketoreal +rclo +rclock rcm +rcmos +rcmsp +rcmultiple +rcn +rcnst +rco +rcoh +rcol +rcolxs +rcolxscalar rcomap rcomm +rcomma +rcomonad +rcomp rcompare +rcompat +rcompatibility +rcompl +rcomplements rcompleq +rcompose rcon +rconc rcond +rcondcomplete +rcone +rconege rconf +rconfig +rcong rcongr +rconj rconjaction rconjby rcons +rconset rconsnlist +rconst +rconsteq +rconstgeq +rconstgt +rconstleq +rconstlt +rconstneq +rcont +rcontinuous +rcop +rcoprimep rcoset +rcosete +rcosetk +rcosetkv +rcosetm +rcosetp rcosets +rcosetsp +rcosetv +rcount +rcover +rcp rcpsp rcr +rcross rcs rcset +rcst +rcstl +rcstr +rcstruct rcswitch +rct rctx +rctxt +rcu rcurrent +rcurt +rcut +rcv +rcx +rcz +rdata +rdb +rdba +rdbah +rdbal rdby +rdc +rdchs rdcp +rdd rddif +rdec +rdecompose rdefinitions +rdelta rden rdeps +rdepth +rdeq rderiv rderive +rderivs +rdestruct +rdet rdf +rdfn +<<<<<<< Updated upstream +======= rdfs +>>>>>>> Stashed changes rdg rdgdmlim rdgellim rdgeq rdgeqoa +rdgexg +rdgexgg +rdgexggg rdgfnon rdgfun +rdgg +rdgifnon +rdgisuc +rdgisucinc +rdgival +rdgivallem rdglem rdglim rdglimg rdglimss +rdgon rdgprc +rdgruledefg +rdgruledefgg rdgseg +rdgss rdgssun rdgsuc rdgsucg @@ -65812,66 +108943,188 @@ rdgsucmpt rdgsucmptf rdgsucmptnf rdgsucuni +rdgtfr rdgval rdgvalg +rdh +rdhi +rdi +rdiagram rdichotomy rdiff +rdisk +rdist +rdiste +rdistl rdistr rdistrib rdiv +rdive +rdivides rdivmuldivd +rdivp +rdivpk +rdivpp +rdlen +rdlo +rdn +rdnel +rdner +rdnotused +rdo +<<<<<<< Updated upstream +======= rdocum rdocument +>>>>>>> Stashed changes rdom rdomp +rdonly rdot rdpi rdpsr rdpwhole +rdrand rdrop rdropwhile +rdrwnotin +rds +rdsts +rdt rdtbr rdummy +rduong rdv rdvalt +rdvd +rdvdp +rdvdpn +rdvdpp rdvr rdwim +rdx +rdxy rdy rea +reaal reabeq reabsifneg reabsifnneg reabsifnpos reabsifpos reabssgn +reac reach +reacha +reachab reachability reachabilityinvariant +reachabl reachable +reachablebddone +reachablebddzero +reachablechain +reachablechainunion +reachabled +reachabledfrom reachablee +reachablefinpath +reachablefrom +reachablefromgba +reachablefromsetgba reachablei +reachableimpliesnonneg reachableinexecution +reachableinvariant +reachablelem +reachablen reachablenodes +reachablensymmetry reachableo +reachablepath +reachablerec +reachables reachablesetoid +reachablesplit +reachablestable +reachablestablesubset +<<<<<<< Updated upstream +======= reachablestate +>>>>>>> Stashed changes reachablestepfirst +reachablet +reachabletotalise reachablev +reachablevia +reachableviaensures +reacharrlen +reacharrloc +reachback +reachby +reachd +reache reached reaches +reachescycle +reachfrom +reachfromchain +reachfromchainunion +reachfromlem +reachfromrec +reachfromstable +reachfromstablesubset +reachin +reachinfinpath reaching +reachinpath +reachlemma +reachnext reachnt reacho +reachobjloc +reachrel +reachrelfromset +reachto +reachtochain +reachtochainunion +reachtolem +reachtorec +reachtostable +reachtostablesubset reachv react +reacti reaction reactioni +reactive +reacts read +reada +readaad +readaadpair +readaadpairiscomplete +readab readability readable +readablebuffer +readably readargs +readarrayelement readaux +readb +readbuffers +readbyapply +readbycall +readbyfunctioncall +readbyreadscall +readbyseqinit +readbyte +readbytes +readbytesfromfile +readbyunchanged readcarray +readcontenttype readcorrect readd readdcan @@ -65880,6 +109133,7 @@ readdcld readdcli readdcnnred readdd +readdefinition readdgrouphom readdi readdir @@ -65887,58 +109141,173 @@ readdirpcp readdirpsp readdirpss readdlid +readdmem readdoc readdrcl readdrid readdridaddlidd readdscl readdsub +reade +readelements readelse +readencrypteddatakey +readencrypteddatakeyiscomplete reader +readers readerswriters readert readertimonadreader +readesdksuiteid +readexact +readfield readfile +readfirstelement +readheaderauthtagv readily +reading +readingandwritingfreshstateallowed +readingfunction +readingmethod +readinput +readiscomplete readl +readline +readlines readlocs +readm readmaybe readme +readmessageformatversion +readmessageidv +readmode +readmultidimarrayelement +readnbytes +readneither +readnextstring +readnonframe +readnum readonly +readonlyblocks +readonlyld +readp readpcp +readperms +readproblems readpsp readpss +readr +readrange +readrangeofarrayelements readresponse +readrf reads +readsargumenttype +readscheck +readsclause +readsclauses +readsconst +readsconsts +readsecondelement +readshortlengthseq +readshortlengthseqiscomplete readsnapshot +readsnothing +readspsr +readssomething +readsthis +readt +readtable +readtablep +readtest readthe readthen +readthroughterminator +readtime +readu +readuint +readv readvariablerecursive readvcot +readvectorsfile readvrec +readword readwriteimpread readwriteimpwrite +readx ready +readye +readyfordeparture +readyprocsequal real +realabs realaddaction realaffine realax +realb +realbanachspace +realbc +realcalc realcomposition +realcontinuity realcontinuousexpcomp realcontinuousmapofnnreal realcontinuousmapzeroofnnreal +reald +realde +realded +<<<<<<< Updated upstream +======= realdef +>>>>>>> Stashed changes realderivofcomplex +realdomaintype +reale realeqcomplex +realeqimpliesrationaleq +realesg +realesign +realesqr +realexplicit +realfieldtype +realfile +realfix +realfloor realfun +realfunc +realfuncadd +realfuncextmult +realfuncmult +realfuncunit +realfunczero realfundsystem realfunsystem +realhilbertspace +realhomotopy reali +realidad realimaginarypart realinnerproductspace realinterval +realinv +realisation realise +realisecellmap +realisecompsequencemap +realisefin +realisefinseq +realiseidsequencemap +realisemm +realisemmmap +realiser +realises +realiseseq +realisesequencemap +realisesubcomplex realistic +reality +realizable +realizations realize realized realizedtypes @@ -65946,113 +109315,297 @@ realizeglobalconst realizeglobalconstnooverloadwithinfo realizeglobalconstwithinfos realizer +realleqimpliesrationalleq +reallim reallinearisometryequiv +reallinearmetrspace +reallinearspace +realloc +reallocate +reallocdefault really reallypersist +reallyunsafepromote +realm +realmap +realme realmixedspace +realmr +realn +realnesign +realnice realnormed realnormedspace +realnormspace +<<<<<<< Updated upstream +======= realnumber +>>>>>>> Stashed changes +realord +realp +realpa +realpar realpart +realpath +realpfuncunit +realpfunczero +realpos +realposet realpow realrel realringequiv +realrm realrmk +realrmn +realrow reals +realsareabelian +realsareadditiveabeliangroup +realsareadditivegroup +realsareassociative +realsaredistributive +realsarefield +realsaremonoid +realsarering +realse +realsequen +realsequence +realsequences realset +realsexample +realshaveadditiveinverse +realshaveunit realsize realspace +realspacecart realspacetologspace realsqrt +realsub +realsublatt realt +realtest +realtheory +realtime realtonnreal realtopologicalvectorspace +realtransitions realtvs +realtype +<<<<<<< Updated upstream +======= realu +>>>>>>> Stashed changes +realunitaryspace realunits +realv realvalued +<<<<<<< Updated upstream +======= realvector +>>>>>>> Stashed changes +realvectspace +realvs +realx +realz rean +reap +reapadd +reapcotr +reapef +reapirr +reaplt +reapltxor +reapmul +reapneg +reappears reapplyinnerself +reapti +reapval rearchi +rearr +rearran rearrange rearrangecomparison rearranged rearrangedata rearrangement +rearranging +rearrangmentgen +<<<<<<< Updated upstream +======= rearsegp +>>>>>>> Stashed changes +reas reasinsin reason reasonable reasonably +reasoned +reasoni +reasonig +reasonin reasoning -reasoningaboutpossibleantecedentsmt reasons +reassemble +reassign +reassignin reassoc reassoced reassocexpr reassocexprhom reassocexpriso +reassociate reassociated reassociates reassocimplref -reater reational rebalance rebase +rebias +rebiasing +rebindexist +rebindforall reboot +rebtwn rebtwnz rebuild +rebuilt rec reca +recalc recall +recallable +recallelem +recallelemspec recan +recap +recapb recast recb +recbnf recbotcoe recbothd recbuilder +recc reccl +recclap +recclapd +recclapi +recclapzi reccld reccli recclnq +recclosure recclzi reccn +reccnminimise reccot reccsc +recd +recde +recdef recdiv +recdivap +recdivapd recdivd +recdproj +rece receipt receive +receivecreateofriend received +receivedeleteofriend +receiveexportauth +receiveexportauthpsk +receiveexportbase +receiveexportpsk +receiveinv receiver receives +receivete receiving recemptyoption recennreal +recent +recently recenum +receptive receqid receu +receuap recex +recexap +recexaplem +recexd +recexgt +recexnq +<<<<<<< Updated upstream +======= recexp +>>>>>>> Stashed changes recexpr +recexprlem +recexprlemdisj +recexprlemell +recexprlemelu +recexprlemex +recexprlemloc +recexprlemlol +recexprlemm +recexprlemopl +recexprlemopu +recexprlempr +recexprlemrnd +recexprlemss +recexprlemupu +recexre recexsr recexsrlem recextlem recf +recfin recfn +recfns recfun +recfunc +recfuns recgt +rechar +recharacterize +recharacterizes +recheck +rechprop +rechset +reci recid +recidap +recidapd +recidapi +recidapzi recidd +recidgen recidi recidnq +recidpipr +recidpirq +recidpirqlemcalc recidzi +recindir recinfo +recinter recip +recipe +reciperse +recipical +recipientpublickey +reciporical +reciporicals +recipr reciprocal reciprocalfactors +reciprocals reciprocity +reciprocls reciproque recislang reciter @@ -66067,12 +109620,16 @@ recld reclem recli reclimc +reclimit reclm +reclos reclt recm recmet +recmin recms recmulnq +recmulnqg recn recname recncf @@ -66082,56 +109639,107 @@ recnenil recni recnmulnred recnnltrp +recnnpr +recnnre +recnoteq recnperf recnprss recnz +reco recoflist +recog +recoginized +recoglangd +recoglangn +recogni recognis +recognisable recognise recognised +recogniser +recognises recognising +recognition +recognizable recognize +recognized +recognizeid recognizeotherppa +recognizer recognizers +recognizes +recognizezero +recognizi recognizing +recognzier +recollapse +recollect +recollectable recolorofcardle recolorofembedding recolorofequiv +recombine +recommend +recommendation +recommendationp recommended recomp recompile recompose +recomposition recomputable recompute recomputing recon reconappendsingle +reconc reconcile reconciler reconecoe +recongizer reconhorner reconmul reconn +reconnaissance reconnait reconnaita reconnlem +reconoce +reconocedor reconposprimeposcoprime reconprimecop reconprimecoprime reconprimepow reconpure recons +reconsi +reconsid +reconside +reconsider reconsingleappend +reconstitute +<<<<<<< Updated upstream +======= reconstituted +>>>>>>> Stashed changes +reconstitution reconstruct +reconstructed reconstructing reconstruction +reconstructs +reconstuction reconsubsingleton reconswap recontrust +recop record +recordassoc recorded recording +recordmapops +recordof +recordp records recos recoscl @@ -66141,13 +109749,30 @@ recoshcl recosval recotcl recover +recoverable recovered +recovers +recovertype recp +recpair +recphi +recpr +recpt +recr +recreate +recreates recrec +recrecap +recrecapd +recrecapi recrecd recreci recreclt recrecnq +recres +recresult +recriota +recrusion recs recsccl recsec @@ -66159,49 +109784,95 @@ recsfnon recsfval recsne recsov +recspace recstruct recsval rect +rectagon +rectagonal rectan rectangle +rectangleparallelogram +rectanglereverse +rectanglerotate rectangles rectangular rectbntr rectifiable +rectify rectopcoe +rectp rectpath rects rectvandermonde +recu +recun +recund +recuniq recur +recurcr recurr recurrence recurrenceaux recurrent recurrenti +recurring +recurs recurse recursem recurses +recursi recursing recursion recursionbase recursionmain +recursions +recursionxxx +recursiv recursive +recursivebs +recursivei recursivein recursively +recursivemark +recursivemarkworker +recursivep +recursivezero +recursivo recursor recursorbuilder recursors recursorval +recurx +recusive recusp recut recv recval +recvalap +recvall +recvallbytes +recvallrec recvar +recvbytes +recvcap +recvcapd +recvd +recvethernet +recvfrom +recvfromstructptr +recvguniq +recvguniqlem recvmarker recvmsg recvmsge recvmsgtt +recvofriend +recvouterfriendids +recvouterfriends recvs +recvupd +recvupdd recxpcl recxpcld recxpf @@ -66209,119 +109880,206 @@ recz reczerocoe red redacc +redapp redblack +redblackp +<<<<<<< Updated upstream +redbuch +======= redbordeaux redbuch redburgundy +>>>>>>> Stashed changes +redc +redcwlpo +redcwlpolemeq +redd +rede +redec redeclaration redeclare redeclared +redeclarevar redeclaring +redeemed +redef +redefin redefine redefined +redefinicje +redefining +redefinition +redefp +redefs redesigned redex +redexe redexes +redid redin redinclp redinclr +redind redininclq redirect +rediscover rediv +redivap +redivapd redivcan redivcl +redivclap +redivclapd +redivclapi +redivclapzi redivcld redivcli redivclzi redivd rediveud redivmuld +redivp +redivpp +redivpt +redivptp redivvald redl redln redn redo redoing +redpos redr reds +redsequence redsi redstep +redt +<<<<<<< Updated upstream +======= redtablewine +>>>>>>> Stashed changes +redts redu reduc reduce reduceabs reduceadd +reduceaddexists +reduceaddexistsoneway +reduceaddforalls +reduceand +reducebig +reducecloselist reducecoefficientwise reducectoreq reducecyclically reduced +reducedd reducedite reducediv reducedly reducedto reducedword +reducedwordp reduceeqq +reduceexist reduceexpr reduceexprq reducef reducefinmk +reduceforall reducehead +reduceiff reduceifsat +reduceifthenelse +reduceimp reduceite +reducel reducelast reducelem reduceleq reduceltq +reducemask reducemodideal reducemodidealaux +reducen reduceneg +reducenode +reducenot reduceoption +reduceor reducep +reducepivot reduceplus reducepow +reducepq reduceproj reduceprojstruct reduceprop reducer +reducerecundermatch reduces reduceskip reducestar reducestep +reducesub +reducesuball reducesubdiff reducetop reducetopo +reducetosuccess +reducetranssimpl reducibility reducibilityhints reducible +reducibles reducibly reducing reduct +reductible +reductio reduction reductionfvarids reductiongoal reductions reductive +reducton reducts +redun redund redundancy redundant +redundante +redundantly +redundd redundeq redundpbi redundpim redunds redundss +redundu reduntant +reduse redustarconfluent +redux redvmptabs redvr +<<<<<<< Updated upstream +======= redwine +>>>>>>> Stashed changes +redwithmaxsize +redwithmaxsizel +redwithmaxsizes redwlk redwlklem +redx ree reean reeanlem reeanv +reeber reecriture reef reefcl @@ -66336,12 +110094,20 @@ reeftlcl reelprrecn reelznn reenableeta +reencryptensurespublicly +reencryptkey +reep reesalgebra +reescritu +reestablish reex reexalt +reexamination reexpcl reexpcld reexpclz +reexpclzap +reexpclzapd reexpclzd reexplog ref @@ -66350,49 +110116,97 @@ refactored refactoring refactors refallfaccl +refalloc +refarray +refb refbas +refbase +refbasefield +refblock +refbyte +refcl +refcou +refcoun +refcount +refcountedges +refcounts +refd refdivmptf refdivmptfv refdivpm +refeq refer +refere +refered reference referenced +referencedfunctionsareused +referenceequality references +referencing +refernces referred +referrer +referring refers +refertomembers +refex reff refgoal +refh refi +refillbuffer +refilter refimssco refin refine refinearg +refinecorrect refined refineddiscrtree +refinefuncorrect +refinefunction refinei +refineint +refinelist refinement refinementlib +refinementp +refinementregressions refinements refinementtypechecker refineonehypercover +refinepreservesprefixfree refineres refines refinesd refinesi refining +refint refl +refla +reflaf +reflai +reflb +reflbf +reflbi reflbooltrue reflc +reflcf +reflci reflcl reflclosure reflclp refld refldcj refldivcl +refle +reflec reflect reflectcore reflected reflectf +reflecti reflecting reflectio reflection @@ -66403,6 +110217,8 @@ reflectionperm reflections reflectiontests reflective +reflectivesubuniverse +reflectl reflector reflectoradjunction reflectroot @@ -66416,6 +110232,7 @@ reflectscolimitsofcreatescolimits reflectscolimitsofshape reflectscolimitsofshapeofcreatescolimitsofshape reflectscolimitsofsize +reflectsd reflectse reflectseffectiveepifamilies reflectseffectiveepis @@ -66445,45 +110262,75 @@ reflectssmallestfilteredcolimits reflectssmallestlimits reflectt reflex +reflexes reflexg reflexion +reflexiv reflexive reflexivecoequalizerisocoequalizer reflexivecofork reflexivecoforkequivcofork reflexivecoforkequivcoforkobjiso +reflexiveequal +reflexiveh reflexivei reflexivemonadicity reflexivepair +<<<<<<< Updated upstream +======= reflexiveproperty +>>>>>>> Stashed changes +reflexiveproxy +reflexivi reflexivit reflexivite reflexivity +reflexivityh +reflexivitylemma reflexivitytac reflext +reflexve +reflexvie reflgen +refli +reflist +reflo reflp +reflpath reflprefunctor reflquiv reflquiver +reflrefl reflsymmtrans +reflt refltr refltrans refltransgen refltranssymm refltranssymmaux +<<<<<<< Updated upstream +======= reflwellordering +>>>>>>> Stashed changes +reflwosetequiv reflx +refmention refn +refocus refold refoldconsts refoldfun refoldfvars reform reformulate +reformulated reformulating reformulation reformulations +refp +refptr +refrain +refrd refref refrel refrelcoss @@ -66495,10 +110342,12 @@ refrelressn refrels refrelsredund refresh +refreshment refressn -refrigerator refs refsd +refset +refsfupd refssex refssfne refsum @@ -66506,31 +110355,71 @@ refsumcn refsymrel refsymrels reft +reftag reftr +reftype refun +refunc +refupdate +refusal refusals +refuse refuses refutable refutation +refutationp refute refuted +refuter +refution +refv +refvar +refvars +refy reg +rega +regalg +regalloc regamcl regard regarded +regardelss regarding regardless +regards +regarr +regb +regc +regcard +regcol rege regex +regexmid +regexmidlem +regexmidlemm regexp +regexps +regfile reggraph reghaus reghmph reghost +regi +regid +regimmtonumlist +regin +regio region regionbetween +regioni +regionp regions +regionsp +regiontype +regis +regist register +registerbits registerbuiltinattribute registercoercion registerderivinghandler @@ -66539,6 +110428,7 @@ registerenvextension registergeneratingattr registering registernamemapattribute +registernames registernamespace registerreassocexpr registers @@ -66546,9 +110436,18 @@ registersimplepersistentenvextension registersyntheticmvarwithcurrref registertraceclass registerunfoldboundaryext +registra +registrat +registrati +registratio +registration +registrations registres +regl +regla regle regles +reglist reglog reglogbas reglogcl @@ -66558,23 +110457,52 @@ reglogleb reglogltb reglogmul regmap +regmasks +regmon +regnot +regnum +regnums rego +regof regoffamily +regoffset +regp +regpair +regpart regr +regress +regressed +regression +regressionclient +regressions +regressiontest +regressiontests regressively +regressor regret +regroup +regrwithout regs regsep regset regsfromregtr regsfromsetind regsfromunir +regsi +regslookup +regsp +regstate regsumfsum regsumsupp +regsupdate regt +regtaint regtop regtrace regtracelist +regtype +regu +regul regular regularamicpair regularamicpairexample @@ -66583,6 +110511,7 @@ regularcone regularconeset regularcontents regularcoverage +regulard regularepi regularepicategory regularepicategoryofnormalepicategory @@ -66595,8 +110524,10 @@ regularepioffaithfullyflat regularepiofkernelpair regularexpression regularextensive +regularframes regularity regularityreduced +regularlanguage regularmono regularmonocategory regularmonocategoryofnormalmonocategory @@ -66608,29 +110539,47 @@ regularofispullbackfstofregular regularofispullbacksndofregular regularofispushoutfstofregular regularofispushoutsndofregular +regularport +regularportlist regularspace +regularstate regulartopology regularwreathproduct +regulated regulator -regulatoryprocess regulier regusgraph +regv +regva +regval +regvals +regvars rehalfcl rehalfcld rehalfcli rehalfge +rehash rehaus reheibor rei reif +reifer +reification +reifier reify +reifyexpr reifyfmla +reifyobj +reifyterm reim reimplement reimplemented +reincarnation +reind reindex reindexalgequiv reindexcelltypes +reindexed reindexequiv reindexfinsetrange reindexgroupequiv @@ -66639,20 +110588,37 @@ reindexislimitequiv reindexlieequiv reindexlinearequiv reindexrange +reinit +reinitialize +reinsert reinterpret +reinterpretation reinventing +reiota +reiotacl reipcl reixi reject +rejectable +rejectd rejected +rejection +rejectionables rejective rejects +rejestracja +rejigger +rejoin rejoining rel rela +relab relabel relabelaux +relabeled relabelequiv +relabeling +relable reladdrsub relae relapp @@ -66661,14 +110627,22 @@ relate related relatedly relates +relatesd +relatesi relatex relati +relatiion relating relatio relation relational +relationally +relationclasses +relationh +relationi relationmap relationofhascoeffs +relationp relationrefltransgen relations relationship @@ -66676,7 +110650,10 @@ relationships relationsofiscokernelfree relationsset relationssolutionequiv +relationuniq +relativ relative +relativeadjoint relativecellcomplex relativedifferentials relativedimension @@ -66687,22 +110664,40 @@ relativelycompact relativelyrepresentable relativemorphism relativepath +relativetime relativetoknownnature +relativity +relativization +relativize relator +relatord +relatori +relators +relaugmentation relax +relaxation relaxed +relaxing +relaxp +relb relbigcup +relbiimpl +relboundary relbrcnv relbrcnvg relbrcoss relbrtpos relcat +relchain relcic +relclass +relclassequiv relcmd relcmpcmet relcnv relcnveq relcnvexb +relcnvfi relcnvfld relcnvtr relcnvtrg @@ -66710,11 +110705,18 @@ relco relcoels relcoi relcomp +relcompd +relcompi relcompp relcoss relcwcomplex +relcycle reld +reldec +reldeccorrect +reldesc reldesired +reldexist reldif reldir reldisj @@ -66729,6 +110731,7 @@ reldmghm reldmlan reldmlmd reldmlmhm +reldmm reldmmap reldmmdeg reldmmhp @@ -66757,15 +110760,20 @@ reldom reldv reldvds reldvdsr +reldvdsrsrg +reldvg rele releabs releabsd releabsi +releas release +releaseable released -releasedat releccnveq relecxrn +relee +relelbasov releldm releldmb releldmdifi @@ -66774,25 +110782,33 @@ releldmqs releldmqscoss relelec releleccnv +relelfvdm relelrn relelrnb relelrni relem relembedding relembeddingclass -relement relen releq releqd +releqel releqg +releqgg releqi +releqmpt releupth relevance +relevancemonoidal relevant relevantarg +relevantargs relevantchildren relevantd relevantfvars +relexed +relexist +relexistence relexp relexpaddd relexpaddg @@ -66803,7 +110819,6 @@ relexpcnvd relexpdm relexpdmd relexpdmg -relexpempty relexpfld relexpfldd relexpiidm @@ -66830,41 +110845,57 @@ relexpsucrd relexpuzrel relexpxpmin relexpxpnnidm +relextension +relextensionpreserveseq relf relfae +relfdia relfi relfinrank relflag relfld relfldext relfp +relfreeeven relfsupp relfth relfull relfunc +relfvssunirn relgamcl +relgraph relh +relhoare relhom relhomclass relhomcongr reli reliability reliably +reliance +relics relid relies +relieve +relieved +relieving reliin reliindex +relim relimage relimasn relimpreldata relimprellemma relin +relincl relindex +relink relint relintab relintabex relinv relinxp +relisequiv reliso relisoofbij relisoofbijective @@ -66873,15 +110904,23 @@ relisoofsurjective relisotrans relisseparated reliun +reljump +relk rell rellan rellast +relleftif rellindf rellininds rellmd +rellsl rellycmp rellysconn relm +relmacromatchesequiv +relmacrorelstr +relmacrostructure +relmacrosuitablerel relmap relmntop relmpoopab @@ -66890,14 +110929,25 @@ reln relname relnonrel relnorm +relo +reload +reloc +relocability +relocable +relocatability +relocatable +relocate +relocation relog relogbcl relogbcld relogbcxp relogbcxpb +relogbcxpbap relogbdiv relogbdivb relogbexp +relogbexpap relogbexpd relogbf relogbmul @@ -66924,6 +110974,8 @@ relogmul relogmuld relogoprlem relogrn +relondomex +relonsetex relop relopab relopabi @@ -66935,6 +110987,7 @@ reloprab relowlpssretop relowlssretop relp +relpath relpeq relpf relpfr @@ -66943,36 +110996,49 @@ relpic relpmin relpow relpower +relpowp relprcnfsupp relpreimage relprel relpres relprime +relprod relpths relqmap relquot +relquotientdistributive +relr relran relrank +relrec relrelss relres relresdm relresfld +relrightif relrn +relrnfvex relrngo relrpss rels +relsdagger relsdom +relse relseries relset +relshasdagger relsidesifrefl relsidesifsymm relsl relslstar relsn relsnb +relsndd relsng relsnop relsnopg +relsortedsign +relspace relss relssdmrn relssdv @@ -66982,13 +111048,17 @@ relssinxpdmrn relssr relssres relstr +relstreq +relstrex relstx relsubgr relsucmap +relsupp +relsymbolsof relt -reltm reltosubrelation reltpos +reltr reltrclfv reltre reltrls @@ -66999,6 +111069,7 @@ reltxrnmnf relu relun reluni +relunit relup relwdom relwf @@ -67006,47 +111077,101 @@ relwlk relxp relxpchom rely +relyguaranteesrc +relyguaranteetgt +relyguaranteetgtperm relying +relyof rem +remai remain +remaind +remainde remainder remainderexp remainderexplemma remaindering remainders +remained +remaini remaining remainingbytes +remainingchars remaininggoals +remainng remains +remake +remap remapleft remark +remarking +remarks +remarque +remars +remassoc +remassocs rembiflowdups +rembind +rembits rembl +remc +remclock +remcode +remcomp +remcomps +remdomain remdups +remdupsappend +remdupsappendmultiset +remdupsappendset +remdupslistdiff +remdupsremoveallcommute +reme +remeber remedied +remedy remember -remembering remeq remerge remet remetdval remexz +remf +remff +remfl +remgr +remgrm +remgrmid +remgrml +remgrp +remhash remim remimd +remind +reminder +reminiscent +reml remlem +remlock remlockn +remlockres remlockset remmert remo +remov removable removal remove removeafterindex removeall +removealllistdiff +removeallparams removeargrule removeat +removeb removebot removecholes +removecombinable removed removedeprecations removedirectory @@ -67056,37 +111181,75 @@ removeduplicateliteralsequivalentclause removeduplicates removeduplicatesby removedups +removeedge +removeedges +removeelem +removeelement removefactor removefalseliterals removefile removefirst +removeimplied removeincorrect +removekey +removekeys removelast removeleaf removeleftop removeloops +removelsz +removeme removemin +removemonitorwait removen removene removenegations +removenode +removenodes removenone +removenonfirst removenth removeop +removeopt +removeparams removepathforcibly removepresent +removeprocs removeproof removequotations removeranges +removeredundant removerightop removes +removeshadowrules +removestatessimpl +removesuperfluous +removetop +removeundefs removeunop +removevalue +removevertex +removevertices +removew +removex +removexaddr removezero removezeros removing +remp rempdups +rempl +remprop rempty +remq remquot +remr +remremove +remreq +rems +remsi remsqsqrt +remu remul remulcan remulcand @@ -67094,6 +111257,7 @@ remulcl remulcld remulcli remuld +remulext remulg remuli remulinvcom @@ -67103,8 +111267,13 @@ remulneg remulr remulscl remulscllem +remv +remvalue +remzero ren +rena renam +renamable rename renamebindernames renamebvar @@ -67113,7 +111282,9 @@ renamebvartarget renamed renamedirectory renameequiv +renamef renamefile +renamefs renamefun renamefunaux renameinaccessiblefvars @@ -67121,13 +111292,29 @@ renamelcs renamemetavar renamepath renamerule +renames renamesymmetricsubalgebra renametheorem +renamevar +renamevarp +renami +renamin renaming +renamingd +renamingi +renamingp +renamings +renamingsp +renc rencldnfi rencldnfilem +rend render +renderdoc rendered +renderer +rendering +rendermsg renderrewrites renders rendersection @@ -67152,21 +111339,35 @@ renemnf renemnfd renepnf renepnfd +renexp +renf renfdisj +renfnad renicax +renn rennim rennncan reno renod renpncan +rensem rentielles -renting renum renumber +renumberi +renumbering +renumberingi +renumberingp +renv +renvar +renvp +reoccurs +reoder reofld reofreal reopening reopn +reopnap reord reorder reorderandsimp @@ -67182,138 +111383,281 @@ reorders reorderusing reordt reorelicc +reorg +<<<<<<< Updated upstream +======= reorganization +>>>>>>> Stashed changes +reorganizing +reorient rep +repa repable +repabs repack repackage repackaging repair +repar reparam +reparameter reparameterize reparametrising reparametrization +reparametrize reparpht reparphti reparphtiold repart +repb repbaseclass +repbits repc repcd repcs +repcsi +repd repe repea repeat +repeatable +repeatarrayvalue +repeataux +repeatb +repeatbit repeatcore repeated repeatedly repeateq +<<<<<<< Updated upstream +repeathead +======= +>>>>>>> Stashed changes +repeati repeating +repeatlemma +repeatmapvalue repeatmax repeatp repeats +repeatvalue +repeatz +repec +repeg +repeq +reper +reperalgebra +reperalgebrastr +reperentation reperf reperflem +repet +repetido repetition repetitions +repetitiontype +repfiber +repfn repfun repgen rephrase rephrased rephrases rephrasing +repinj repinject +repizf repl +repla replac replace replaceable +replaceacctrans +replaceall replacebornology replacebottop +replaceby +replacebyelem +replacecol +replacecommadot +replacecompose replaceconst replaceconsts replaced +replacediff replacedisallowed replacedist replacedtopology replaceedist +replaceelem +<<<<<<< Updated upstream +replaceeq +======= +>>>>>>> Stashed changes replaceequiv +replacefacesat +replaceformulaterm +replaceformulatermispr +replaceformulatermmonotone +replaceformulatermsub replacefun replacefvar replacefvars +replacegentzen +replacehd replacehead replaceif +replaceinmultiset +replaceinseq +replacel +replaceline replacelocaldecl replacem replacemaingoal +replaceme +replacemen replacement replacementm replacements replacementstring +replacemono +replacemonoright +replacenatded +replacenull +replaceonecomma +replaceother replacepinotation replacerange replacerec +replaceregion +replaceremove replaceresult replaces +replacesamep +replacesingletrans +replacestate +replacestateset replacesubexpr +replacesuffix +replacetarget replacetargetdefeq replacetargeteq +replacetermsterm +replacetermstermispr +replacetermstermmonotone +replacetermstermsub +replacetermterm +replacetermtermispr +replacetermtermmonotone +replacetermtermsterm +replacetermtermstermispr +replacetermtermstermmonotone +replacetermtermsub replacetopology +replacetrans +replacetransitive +replacetranslation replaceuniformity +replacevalue replacevertex replacing +replacment +replacments +<<<<<<< Updated upstream +======= replax +>>>>>>> Stashed changes replay +replcommand +replete repli +replic replica +replicaautoscalingupdatelist +replicaglobalsecondaryindexlist +replicaglobalsecondaryindexsettingsupdatelist replicamessage +replicasettingsupdatelist replicate replicateaddmonoidhom replicatecol +replicated +replicatee +replicatefinvec replicatei +replicatekeyensurespublicly replicaterow replicates replication +replicationgroupupdatelist +replid +replidt replies replim replimd replimi +replimit +replist +replistd +replistp replusg reply +repm repmc +repname repncan repnf repnfmpt +repnodes repnpcan repo repoftprodiso report reportadaptationnote +reportcard +reportcardkey +reportcardkeylist reportdefeqabuse reported reportedplusunreported reportfailure +reporting reports reportslowdown reportsuccess repos reposdif repository +repostype +repp reppncan repr reprarg +reprc reprdifc +repre repred reprequiv represent representa representability representable +representablealternate representableby representablebycompyonedaobjofislimit representablebyequiv representablebyuliftfunctorequiv +representablehalf +representablehalfhelp +representablehelp +representables +representableshelp representablycoflat +representablyconcrete representablyflat +representant +representants +representati representation representations representationtheory @@ -67321,39 +111665,63 @@ representative representativeiso representatives represented +representi representing represents representsd representsi +representsinself represnetable reprf +reprfamily reprfi reprfield reprfz +reprg +reprglm +reprglmm reprgt reprinfz reprinrn +reprj reprk reprle reprlt +reprm repro reprodim +reproducedencryptioncontext +reproduces +<<<<<<< Updated upstream +======= reproducibility +>>>>>>> Stashed changes reproducing +reproduction +reproj reprove reproved +reprp reprpmtf reprprec +reprs reprss +reprsubset reprsuc reprsum reprval +reprvalid reprw reprx reps repsco repsconst repsdf +repset +repsetfun +repsetin +repsetprod +repsetthm repsf repsfintype repshare @@ -67374,7 +111742,13 @@ repswsymb repswsymball repswsymballbi rept +<<<<<<< Updated upstream +======= reptile +>>>>>>> Stashed changes +repty +reptye +reptyp reptype repu repv @@ -67383,38 +111757,76 @@ repveval repwsmet req reqabi +reqconst reqgiveseqwithsameexp +reqinfo +reqmt +reqp +reqr reqs +reqsp +requ requad +requal +<<<<<<< Updated upstream +======= requalityona +>>>>>>> Stashed changes +requations +reque request +requested +requesting requestm +requestp +requestq requestresponse requests requesttask requestvote requestvotereply +requestvotes +requi +requir require required +requiredencryptioncontext +requiregoodkeylengths +requirem +requiremen requirement requirements requires +requiresfail +requiresfixed requirin requiring +requisite +requiv +requsets reqv rer +reraise rere rereb rerebd rerebi +rerecapb rereccl +rerecclap +rerecclapd +rerecclapi +rerecclapzi rereccld rereccli rerecclzi +rereceu rerecid rered +rereim rerename rerest +rerestcntop rerisefaccl rern rernegcl @@ -67422,14 +111834,25 @@ rernmpt rerpdivcl rerpdivcld rerr +rerrange rerrext +rerror +rersqreu +rersqrtthlem rersubcl rerun res +resa resabs +resacc +resack resample +resand resasplit +resasplitss resb +resbreak +resc rescabs rescale rescalealghom @@ -67457,53 +111880,89 @@ rescommrel rescommrelstarres rescommrelstarreschain rescomp +rescond rescongr +resconj resconn +rescont +rescontinue +rescued rescval +resd resdif resdifcom resdifdi resdifdir resdisj +resdiv resdm resdmdfsn resdmres resdmss resdomq resdvopclptsd +rese research reseccl reseed +reseedpost reseedres resentation reseq resequiv +reser +reserr +reserror +reserrp +reserv +reservation reserve reserved +reservedalgorithmsuiteid +reservedbytes +reservedi +reservedinstr +reservedp reserves reset reseti +resetlatch +resets +resetstart resetting resex resexd resexg +resexp resf resfifsupp +resflem resflow +resfn resfnfinfin +resfnfinfinss resfsupp resfunexg resfunexgalt resfval resfvresima resfz +resg resghm resgrpisgrp resgrpplusfrn +reshape +reshapekl +reshapekr reshare +reshi resi resid +reside +<<<<<<< Updated upstream +======= residence +>>>>>>> Stashed changes residfi residm residpr @@ -67513,6 +111972,9 @@ residualgraph residualinject residuallength residuallyfinite +residuals +residualsa +residualseparationalgebra residuated residuatedi residuation @@ -67535,6 +111997,7 @@ resiima resilient resima resimass +resimpossible resin resincl resincld @@ -67545,22 +112008,37 @@ resindir resindm resinf resinhcl +resinj resinsn resinsnalt resinsnlem resinval +resinvs resipos resiposbas resisoeq resistance +resistor resiun resixp resixpfo +resiz +resizable resizableuniformsizedseq +resize +resized +resizes +resizing +resizingenqueue resl resle +reslen reslestalkmap +resli reslmhm +reslo +resm +resmant resmgmhm resmhm resmndismnd @@ -67569,43 +112047,90 @@ resmpt resmptd resmptf resmpti +resmult +resnames resnattrans +resnone resnonrel reso resof resofquotientiso resol +resolute +resolutely resolution resolutioncomptolocalizationnattrans +resolutiond +resolutionerrors +resolutioni +resolutionissues resolutionmap resolutionobj resolutions +resolv resolvability +resolvable resolve +resolvecalssreference +resolvecl +resolveclas +resolveclass +resolveclassname +resolveclassrefer +resolveclassreferen +resolveclassreferenc +resolveclassreference +resolveclassrefernece resolved +resolvefieldreference resolveglobalconstnooverload resolveid +resolvelendist +resolvelendistbackmatch +resolvelendistlength resolvenamespace resolvent resolvents resolventset resolvepushid +resolver +resolving +resolvingbidbridginglemma +resolvingbidbridginglemmavariant +resolvingbidequivalence +resonable resopab resoprab resopunitintvd +resor resort resorting +resourc resource +resourcearnstring +resourcecoh +resourced +resourcei +resourcelist resources +resourcetype +resourcetypes resp respe respec respect respected +respectful respecting respective respectively +respecto respects +respectsequiv +respectsequivalencel +respectsequivalencer +respectsequivl +respectsequivr respectsis respectsiso respectsleft @@ -67622,7 +112147,11 @@ respecttranspare respecttransparen respecttransparenc respecttransparency +respill resplit +respond +responded +responder responds response responses @@ -67632,11 +112161,30 @@ responsived responsivei respreima respresentation +resproof resqcl resqcld resqcli resqreu resqrex +resqrexlem +resqrexlemcalc +resqrexlemcvg +resqrexlemdec +resqrexlemdecn +resqrexlemex +resqrexlemf +resqrexlemfp +resqrexlemga +resqrexlemglsq +resqrexlemgt +resqrexlemlo +resqrexlemnm +resqrexlemnmsq +resqrexlemover +resqrexlemoverl +resqrexlemp +resqrexlemsqa resqrtcl resqrtcld resqrtcn @@ -67648,17 +112196,25 @@ resr resrcmplf resres resresdm +resreturn resrhm +resri resrn +resrnd resrng resrnlem ress +ressa ressabs +ressabsg ressascl ressasclcl ressatans ressbas +ressbasd +ressbasid ressbasss +ressbasssd ressbasssg ressbasssold resscat @@ -67669,15 +112225,20 @@ ressco ressdeg ressds resseqnbas +resseqnbasd +ressex ressffth resshom ressid +ressign ressim ressinbas +ressinbasd ressiocsup ressiooinf ressioosup ressip +ressipg ressle ressmpladd ressmplbas @@ -67687,11 +112248,13 @@ ressms ressmulgnn ressmulgnnd ressmulr +ressmulrg ressn ressnm ressnop ressplusf ressplusg +ressplusgd ressply resspos ressprdsds @@ -67702,8 +112265,10 @@ resspsrmul resspsrvsca resspwsds ressress +ressressg resss resssca +ressscag resssetc resssra ressstarv @@ -67722,7 +112287,9 @@ ressusp ressuss ressust ressval +ressvalsets ressvsca +ressvscag ressxms ressxr rest @@ -67731,13 +112298,15 @@ restabs restar restart restarted +restarting +restarts restate restated restatement restating -restaurant restb restbas +restbasg restcld restcldi restcldr @@ -67746,11 +112315,17 @@ restclssep restclsseplem restcnrm restco +restd +restdays restdis +restemb +resterm restfn restfpw +restfunc resthaus resthauslem +resti restid restidsing restin @@ -67759,20 +112334,33 @@ restlp restmetu restn restnlly +restnodes restntr +resto +restofgraph restopn restopnb restopnssd restore restored +restoreeo +restores restorestate +restoretablefrombackupensurespublicly +restoretabletopointintimeensurespublicly +restoring +restp restperf restpw restr +restrain +restrby restrcl restrcontdiff +restre restreg restreq +restrfunctor restri restric restrict @@ -67786,18 +112374,24 @@ restrictcoextendscalarsadj restrictcomp restrictd restrictdegree +restrictdisequality restrictdom restrictdomain restrictdvd restricte restricted +restrictedp restrictedproduct +restrictedstate restricteduliftyoneda restricteduliftyonedahomequiv restrictedyoneda restrictedyonedaobj restrictedyonedaobjmap +restrictequality +restrictf restrictfreevar +restrictft restrictfullyfaithful restrictfun restrictfunctor @@ -67823,6 +112417,7 @@ restriction restrictioncoextensionadj restrictionconservation restrictioncyclesiso +restrictionf restrictionfunctor restrictiongeiso restrictionhomologyiso @@ -67832,15 +112427,19 @@ restrictionlt restrictionltofcoconeiso restrictionmap restrictionopcyclesiso +restrictionresult restrictions restrictiontotruncge restrictionxiso restrictisospec restrictive +restrictl +restrictlanguage restrictlatticehom restrictle restrictlie restrictmonoidhom +restrictmonotonicity restrictnonneg restrictnonposseq restrictnorma @@ -67850,6 +112449,7 @@ restrictnormalhom restricton restrictopencommringcat restrictp +restrictpm restrictpreimage restrictpreimagefinset restrictprod @@ -67880,24 +112480,37 @@ restrictscalarsobj restrictscalarsrange restrictstalkiso restrictstalknatiso +restrictsub restrictsubtype restrictsupport restrictsupportequiv restrictsupportideal restrictsurjective +restrictt restrictto +restricttoimage restricttopiso restricttotaldegree restrictunit restrictvar restrictvarleft +restrictvis restrictwith +restringimos restrm +restrmesub +restrmp restropen restrp +restrperm restrpermmap +restrr restrreld +restrto restructure +restructuring +rests +restsatisfies restsn restsnid restsnss @@ -67911,6 +112524,8 @@ restutop restutopopn restv restval +restxp +resu resub resubadd resubaddd @@ -67931,15 +112546,42 @@ resubid resubidaddlid resubidaddlidlem resubmet +resubmit +resubst resubsub resubval +resul result +resultado +resultan resultant +resultarray +resultarrayi +resultarrayp resultd +resulted +resulteventspace resulting +resultisunused +resultj +resultmap +resultp results +resultsamectx +resultsamestate +resultseqsamex +resultsindependent +resultsort resultsp +resultsuccessful +resultswithrestin +resultswithvaluein +resulttype +resultunsized resum +resume +resumestep +resumethread resummed resumption resundi @@ -67949,6 +112591,10 @@ resup resupmax resuppsinopn resv +resvals +resvar +resvars +resvarslength resvbas resvcmn resveqaeq @@ -67960,52 +112606,145 @@ resvsca resvval resvvsca ret +reta +retaddr retain +retainer +retains retancl +retanclap +retanclapd retancld retanhcl retbwax +retcallnt +retconst +retelim +retelling +reteq reterr +retf +retfin +retfn rether +rethink +reti +retic +retinfo +retinit +retir retire +retired +retiregrantensurespublicly +retires +retiseq +retk +retlast +retn +retname +retnames +retnt retop retopbas retopconn retopn retopon retopsconn +retore retos +retp +retpi retps +retptr retr +retra +retrac retract retractarrow retractarrowapp retractc retractclosure +retracti retraction retractioncantorset retractionkercotangenttotensorequivsection retractionkertotensorequivsection +retractionof retractionofsectionofkersqzero retractions +retractisequiv +retractive +retractof retracts +retreive +retrie retrieve retrieved +retrieves +retrieving +retroactive retrocompact +retrospect +retrs +retrt +retry +retrybody +retrypolicy +rets +retsel retsig +retsp rett +rettfs +retty +rettyp +rettype retu +retuns retur return +returnanonnullarray +returnanullarray +returncond +returnd returned returnedbits +returnelim +returnelimaux +returnfalse returngen +returngensizemonotonic +returngensizemonotonicopt +returnin +returninfo returning returnk +returnm +returnnat +returnnone +returnnt +returnrose returns +returnsome +returnsomething +returnsoneifcompilableordinalcell +returnspec +returnst +returnstate +returnstmt returnt +returnthis +returnto +returntuple +returntype +returnu +returnvalue +returnwhatwasgiven retv retval +retvals +retvs +retype reu reuabaiotaiota reuaiotaiota @@ -68029,6 +112768,7 @@ reueqdv reueqi reueubd reuf +reuhady reuhyp reuhypd reuimp @@ -68048,10 +112788,12 @@ reureurex reurex reurexprg reurmo +reusable reusables reuse reused reusing +reuslt reusn reusng reusngf @@ -68060,6 +112802,7 @@ reuss reust reusv reuswap +reuswapdc reutru reutrualt reuun @@ -68070,20 +112813,42 @@ reuxfrdf reuz reuzb rev +reva +revacc reval +revall revalmpt +revalue +revap revapp +revappen revappend +revappends +revappendx revat revatfun +revbreak revcaseson +revcatcommute revccat revcl revco revcompreviso revdjkrfxukhzc +revdroprev +reve reveal +revealed +revealer +revealexpressionscope +revealinfunctionnotmethodok +revealing +revealonlyinmethodnotok +reveals +<<<<<<< Updated upstream +======= revenge +>>>>>>> Stashed changes revequivalence revers reversal @@ -68093,16 +112858,27 @@ reverseappend reverseaux reversebraiding reversed +reversedoubleisidentity reverseequiv +reversefields reverseinduction +reverseinplace reverseiso +reversek +reversekeys +reverselist reverseop reverseopequiv reversepath reverserec reverserecon +reverses +reverseseq reversibility +reversible reversing +reversion +reversionga revert reverted revertedfvars @@ -68110,47 +112886,110 @@ reverting revertlognetwork revertnetwork revertpacket +revf +revflatten +revfn revfv +revgr +revgraph +revi review reviewed reviews reviewspaper +revimp revinductionon +revised revision +revisions revisit +revisited +revisiting +revive +revk +revkeyhat +revkeys +revl revlen +revlength revlex revlexaccessible +revlist +revlookuprname +revnil +revokegrantensurespublicly +<<<<<<< Updated upstream +======= revolution +>>>>>>> Stashed changes +revop revorder revorderiso +revp revperm revpfxsfxrev +revph +revpoly +revprekey +revr +revrec +revref revrev +revrot +revrx revs +revsubkeyhat +revt +revtakerev revval revwlk revwlkb +revword revzip rew reward +rewind +rewire +rewite rework rewr +rewrap rewri rewrit +rewritable +rewritables rewrite +rewritec +rewritei rewriteinterface rewritelemma +rewritelist rewritelocaldecl +rewritemap +rewritemultiset rewriteonefile +rewritep +rewriter +rewriterelation rewriteresult rewrites +rewriteseq +rewriteset rewritesi +rewritesp rewritetarget rewritetype rewritevar +rewriti +rewritin rewriting +rewritt rewritten +rewrote +rewrs +rewt +rewttrans +rewuirement rex rexab rexabsle @@ -68160,7 +112999,9 @@ rexabsobidv rexabsod rexadd rexaddd +rexalim rexanali +rexanaliim rexanid rexanre rexanuz @@ -68181,6 +113022,7 @@ rexdifi rexdifpr rexdifsn rexdiv +rexec rexeq rexeqbi rexeqbid @@ -68217,6 +113059,7 @@ reximi reximia reximssdv rexin +rexists rexiunxp rexlim rexlimd @@ -68236,19 +113079,25 @@ rexlimiv rexlimiva rexlimivv rexlimivw +rexm rexmet rexmul rexn rexnal +rexnalim rexneg rexnegd rexopabb rexor rexp +rexpe rexpen +rexpinc rexpr rexprg rexprgf +rexpseq +rexpshftint rexpssxrxp rexr rexrab @@ -68256,6 +113105,7 @@ rexrabdioph rexralbidv rexraleqim rexrd +rexreg rexreu rexreusng rexri @@ -68276,6 +113126,7 @@ rexssold rexsub rexsupp rext +rextension rextp rextpg rextru @@ -68292,21 +113143,64 @@ rexxpf rexzrexnn rez rezh +rezo +rfa +rfail +rfalse +rfb rfc rfcnnnub rfcnpre +rfcx +rfd +rfdp +rfe +rfed +rfee +rfeh +rfermwf +rff +rffi +rfg +rfgi rfi +rfid +rfidx +rfie +rfilter +rfin +rfinal rfind rfindopt rfindx +rfinit +rfinse +rfinseq +rfiqbankselect +rfirmwf +rfirst +rfirstset +rfisw rfix rfl +rfla +rflag +rflags +rflagsb +rflagsbi +rflagsbits rfled rfloor +rfloore rflow rfltac rflx +rfml +rfoldl +rforall rfork +rform +rformp rformula rfovcnvd rfovcnvf @@ -68315,22 +113209,68 @@ rfovd rfovf rfovfvd rfovfvfvd +rfr +rfrac +rframe +rfresh +rfringe +rfrmwd +rfrmwe +rfrmwf +rfrmwl +rfs +rfst +rft +rfu +rfue +rfui rfull +rfun rfunc +rfuncdefuniq +rfunct +rfunctional rfv +rga +rgac +rgb rgbi +rgcd +rgcdp +rgcdpe +rgcdpt +rgcdptp +rgcdpts +rgcdptsp +rgd +rgdco +rgdcop +rgdcopt +rgdcoptp +rgdp rge rgen +rgenoinfty rgenw +rgenz +rgeq +rgeqconst +rget rgf +rgfi +rgfp rgfs rggs rgh rglcom rgmoddimold +rgns +rgopher rgr rgraph +rgraphk rgrb +rgrd rgrprc rgrprcx rgrprop @@ -68342,16 +113282,35 @@ rgspnid rgspnmin rgspnssid rgspnval +rgsrc rgstart rgstop rgt +rgtb +rgtconst +rgtgt +rguard +rguards rgv rgvd +rha +rhabs +rhapp +<<<<<<< Updated upstream +======= rhashead rhasleader +>>>>>>> Stashed changes +rhausdorff +rhazim +rhazimatn rhb rhcivnpdokhl +rhconst rhd +rhdl +rhead +rhg rhm rhmcl rhmco @@ -68361,6 +113320,7 @@ rhmdvd rhmdvdsr rhmelval rhmeql +rhmex rhmf rhmfn rhmghm @@ -68405,39 +113365,85 @@ rhmunitinv rhmval rhmzrhval rho +rhoare +rhob rhocheck +rhoh +rhoi +rhom +rhombus +rhombusex +rhombusexabc +rhombusunicity +rhond +rhonode +<<<<<<< Updated upstream +======= rhoold +>>>>>>> Stashed changes +rhos +rhox +rhpm rhreajlm rhs rhsap rhsargs +rhses +rhsexpr rhsfi rhshead +rhsid rhsl +rhsm rhsmd rhspf rhsq rhss +rhssvex +rhsv rhsval +rht +rhufiib +rhull +rhvar +rhyps +ria +<<<<<<< Updated upstream +======= riable +>>>>>>> Stashed changes +riap +ribbon +ribcyxu ric +riccardi riccrng ricdrng rice +rices ricfld ricgic rich +richard richer +richmem rico +ricochetnat +ricochetord ricqusker ricsym rictr rid +ride ridge ridiculous ridl +rids rie riehl +riem +riema +rieman riemann riemannhypothesis riemannian @@ -68446,10 +113452,15 @@ riemannianedist riemannianmetric riemannianmetricvectorspace riemannint +riemannr riemannzeta riemannzetasummand riemannzetasummandhom +riesel +<<<<<<< Updated upstream +======= riesling +>>>>>>> Stashed changes riesz rieszcontent rieszcontentaux @@ -68457,14 +113468,20 @@ rieszextension rieszmeasure rieszmonotone rieszsubadditive +rieur rif +riff +riffle +rifn rifp +rifx rify rifyproof rig righ right righta +rightabsorb rightact rightactionofmonoidaloppositeleftaction rightactionofoppositerightaction @@ -68488,16 +113505,27 @@ rightadjointsquareconjugate rightadjointuniq rightalgebra rightalternative +<<<<<<< Updated upstream +======= rightangle +>>>>>>> Stashed changes +rightanglenc rightanglerotation rightanglerotationaux +rightar rightarrow +rightas +rightassociativity rightassoctensor +rightbackslash +rightbackslashdot rightbol rightbolloop rightc rightcanceladd rightcancelequiv +rightcancellable +rightcancellation rightcancellative rightcancelmonoid rightcancelsemigroup @@ -68511,6 +113539,8 @@ rightcont rightcoset rightcosetequivalence rightcosetequivsubgroup +rightcountguess +rightctxt rightd rightderiv rightderived @@ -68522,10 +113552,13 @@ rightderivedtohomotopycategory rightderivedzeroisoself rightdescent rightdistd +rightdistr rightdistrib rightdistribclass +rightdistribute rightdistributor rightdivides +rightdot rightdual rightdualequiv rightdualfunctor @@ -68537,6 +113570,7 @@ rightextension rightextensionequivalenceofiso rightextensioninclusion rightf +rightfactorlteproduct rightfdrep rightfixedpoint rightfixedpoints @@ -68570,7 +113604,10 @@ righthomotopyclass righthomotopyclasstohom righthomotopyrel righti +rightid +rightideal rightidentity +rightinreversed rightinv rightinvariant rightinverse @@ -68580,25 +113617,39 @@ rightinvon rightinvseq rightirr rightiso +rightkan rightkanextension rightkanextensioncompisoofpreserves rightkanextensioncounit rightkanextensionunique rightkanextensionuniqueofiso +rightkanfam +rightker rightle rightleftharpoons rightlift rightliftingproperty rightlim +rightlinearcombination +rightloc rightlt +rightmask +rightmod +rightmodstr rightmodule rightmonotonic rightmost +rightmostmax +rightmostrell +rightmostrelr rightmul rightmulresiduation +rightn rightneutral rightno rightnod +rightnp +rightof rightofmul rightold rightoldd @@ -68606,36 +113657,56 @@ rightop rightopcomp rightopid rightopleftopiso +rightoptions rightopwhiskerright rightordcontinuous rightorecondition rightorthogonal +rightp rightpad +rightperimeter +rightperimeterguess rightpreliering rightprincipal rightproperviaequiv +rightquasi rightquotientequiv rightregular rightrel rightres rightresolution rightretraction +rightreverse rightrigid rightrigidcategory rightrigidcategoryofequivalence rightrigidcategoryofleftrigidcategory +rightrotate +rights +<<<<<<< Updated upstream +rightsappend +======= +>>>>>>> Stashed changes rightsection rightsemimedial rightsemimodule +rightshft rightshift rightshiftaddequiv rightshiftlinearequiv rightside +rightslash +rightslashdot rightsquareispushout rightssno rightssold +rightstrength +rightstrongmonad rightstructure +rightsubmodule +rightsubst rightto +righttogether righttoleft righttomax righttotal @@ -68643,6 +113714,8 @@ righttrans righttriple rightuniformspace rightunique +rightuniquetrivialcartes +rightunit rightunito rightunitor rightunitorbimod @@ -68658,6 +113731,8 @@ rightunshift rightval rightward rightwards +rightwrapper +rightxxx rightzero rightzigzag rightzigzagiso @@ -68667,27 +113742,50 @@ rigidcategoryofequivalence rigidity rigorously rigs +rigth riin riincld riiner +riinerm riinint +riinm riinn riinopn riinrab rij +rijried +ril +rilassare +rilassato +rile +rili rim +rimage rimcnv rimco +rime rimf rimg rimgim rimisrngim +riml +rimm +rimp +rimpl rimrcl rimrhm rimul rin +rinc +rincl +rinconsistentcache rind +rindex +rinds rineq +rinfix +rinfsup +rinfty ring ringabl ringabld @@ -68697,8 +113795,10 @@ ringalgebra ringass ringassd ringaut +ringauto ringbas ringbasis +ringbuffer ringcat ringcataltv ringcatisotoringequiv @@ -68753,6 +113853,8 @@ ringed ringedspace ringelnzr ringen +ringendo +ringepimorphism ringequ ringequiv ringequivcauchy @@ -68788,8 +113890,12 @@ ringhomequivmoduleisscalartower ringhomflat ringhomid ringhominvpair +ringhomisequiv ringhomisom ringhomisometric +ringhomo +ringhomomorphism +ringhompathp ringhomproperty ringhoms ringhomsurjective @@ -68801,6 +113907,7 @@ ringidl ringidmlem ringidss ringidval +ringidvalg ringinvcl ringinvdv ringinverse @@ -68812,6 +113919,8 @@ ringinvoclass ringinvval ringirng ringiso +ringisomorph +ringisomorphism ringjacobson ringkrulld ringkrulldim @@ -68832,6 +113941,9 @@ ringmneg ringmodideals ringmoduleof ringmon +ringmonomorphism +ringmorphism +ringmorphismstr ringn ringnegl ringnegr @@ -68840,10 +113952,12 @@ ringnnzr ringnorm ringnormclass ringo +ringobjects ringofintegers ringofintegerscomplexconj ringofintegersequiv ringofintegerswithvalequiv +ringofsetstype ringold ringoperations ringoperators @@ -68851,6 +113965,8 @@ ringoperatorterms ringops ringopshom ringopsiso +ringosc +ringpath ringpreordering ringprmidl ringprop @@ -68858,6 +113974,9 @@ ringpropd ringquot ringquotequividealquotient ringquottoidealquotient +ringrbd +ringreals +ringressid ringrghm ringridm ringridmd @@ -68867,10 +113986,12 @@ ringrngd ringrz ringrzd rings +ringscategory ringseminorm ringseminormclass ringsrg ringssrng +ringstr ringstructure ringsubdi ringsubdir @@ -68886,19 +114007,39 @@ ringurd ringvcl ringwithoutone rinit +rinprod +rinsert +<<<<<<< Updated upstream +======= rinside +>>>>>>> Stashed changes rinss +rinst rint +rintc +rintegral +rintegralb +rintegrald +rintegralzl +rintegralzr +rintegration +rinter +rinterp +rintm rintn rintopn +rintp rintr rintro rinv rinvariant rinvdouble +rinve rinvf rinvmod rinvn +rinvrmult +rio riota riotabidv riotabidva @@ -68914,6 +114055,7 @@ riotaeqdv riotaeqi riotaeqimp riotaex +riotaexg riotaneg riotaocn riotaprop @@ -68928,13 +114070,30 @@ riotauni riotav riotaxfrd rip +ripc +ripemd riposte +ripple +ripq rir rirrefl ris risc riscer risci +riscv +riscvlang +riscvmachine +riscvmachinel +riscvmeminit +riscvphase +riscvregsinit +riscvwordproperties +riscvxaddrssafe +riscvzdivs +riscvzdivu +riscvzmods +riscvzmodu rise risecure risefac @@ -68945,12 +114104,20 @@ risefacp risefacval risefall risefallfac +rising risk riso risset +ristcylinders ritem +rivest +<<<<<<< Updated upstream +======= rivs +>>>>>>> Stashed changes +rix riydzq +rize rjgn rjmnujufzhmyipznfi rjoin @@ -68964,34 +114131,65 @@ rkabpb rkabpc rkb rkbb +rkc rkcc rke rkei +rker +rkerp +rkey +rkeyquiv +rkeys +rkeysub rkhs +rkid rkinvolved rkra rkrb rkrc rks +rkt +rkx rla +rlaf +rlaffin +rlambda +rlambdad +rland +rlbrackt rlcjp +rlcoset rle +rleaf +<<<<<<< Updated upstream +======= rleave +>>>>>>> Stashed changes +rleb rleboundroundl rleboundroundr +rlebp rledouble rlefexpfabs rlem rlemaxr rleminr +rlemma rlen +rlength +rlep +rleq +rleqconst rleroundedlessr rleroundedr rles rlex rlexp +rlfn rlft rlgfixed +rlh +rli rlim rlimabs rlimadd @@ -69032,7 +114230,15 @@ rlimss rlimsub rlimuni rline +rlinear +rlinexs +rlinexscalar +rlis rlist +rlistn +rlistnp +rlistp +rlists rlit rljnqvqchsltyjwgptaxvnftqamlv rljp @@ -69040,26 +114246,39 @@ rll rlm rlmassa rlmbas +rlmbasg rlmbn rlmdim rlmds +rlmdsg rlmfn rlmli rlmlmod rlmlsm rlmlvec rlmmulr +rlmmulrg rlmnlm rlmnm rlmnvc rlmplusg +rlmplusgg rlmsca +rlmscabas rlmscaf +rlmspace rlmsub +rlmsubg rlmtopn +rlmtopng rlmval +rlmvalg rlmvneg +rlmvnegg rlmvsca +rlmvscag +rln +rlne rloc rlocaddval rlocal @@ -69068,39 +114287,92 @@ rloccring rlocf rlocmulval rlocval +rlookup +rlor rlp rlppccmqcybarzmikblsvvsgwutxyiyrbowqmclf rlr rlreg rlrtp rls +rlsb +rlsmetrstruct +rlsp +rlspace +rlsstruct +rlst +rlsu +rlsub rlt +rltb +rltbp +rltconst rltdouble +rltl +rltopsp +rltopstruct rltp rltrlepred rltrlesucc +rlv +rlve +rlvec rlvect rlx +rlxwstk +rma rmap rmapf +rmapi +rmapj +rmapprimexpr +rmaps +rmat rmatch +rmatp +rmatrix rmax rmaxabs +rmaxe rmaxless rmaxrmult rmaxsym +rmb rmbaserp +rmcorr +rmcxt +rmd rmdir rmdirpcp rmdirpsp rmdirpss rme +rmem +rmembership +rmemd +rmetric rmfsupp rmge +rmh +rmi +rmigeq +rmigif +rmigneq +rmii rmin +<<<<<<< Updated upstream +======= rminal +>>>>>>> Stashed changes +rmine +rmino rminus +rminuse +rml +rmleft +rmmovl rmn +rmnmt rmo rmoan rmoanid @@ -69114,8 +114386,14 @@ rmobii rmobiia rmod rmode +rmodes rmodislmod rmodislmodlem +rmodp +rmodpc +rmodpn +rmodpp +rmodz rmoeq rmoeqbidv rmoeqbii @@ -69126,6 +114404,9 @@ rmoi rmoim rmoimi rmoimia +rmonad +rmono +rmonotonicity rmorabex rmorex rmorph @@ -69137,30 +114418,53 @@ rmorphismp rmorphm rmorphmn rmorphmnn +rmorphmsign rmorphmz rmorphn rmorphv +rmorphx +rmorphxz +rmorphz +rmorphzp rmosn rmoswap rmotru rmoun rmounid rmov +rmove rmoxfrd rmp rmpoly rmri +rms +rmseparation +rmshadow rmspecfund rmspecnonsq rmspecpos rmspecsqrtnq +rmst rmsupp rmsuppfi rmsuppss +rmt +rmu +rmue rmul rmulccn +rmulpt rmult +rmulta +rmulte +rmultrinv rmv +rmw +rmwd +rmwe +rmwf +rmwi +rmwl rmx rmxadd rmxdbl @@ -69196,11 +114500,16 @@ rmyneg rmynn rmyp rna +rnaa +rnaf +rname +rnames rnascl rnasclassa rnasclg rnasclmulcl rnasclsubrg +rnatiso rnb rnblopn rnbnd @@ -69219,6 +114528,7 @@ rnct rnd rndb rndbool +rndc rndd rnddup rnderi @@ -69228,6 +114538,8 @@ rnderivfinite rndg rndgrpelem rndinadaptive +rndinc +rndinfo rndinlist rndk rndkey @@ -69237,22 +114549,29 @@ rndnat rndperm rndr rndrhmcl +rnds rndt rndu rne rneg +rnegate rnelfm rnelfmlem rnelshi rnen rnep rneq +rneqconst rneqd rneqdmfinf rneqi +rnet +rneutral +rnews rnex rnexd rnexg +rnf rnfdmpr rnffi rnfi @@ -69264,6 +114583,8 @@ rngacl rngansg rngass rngbase +rngbaseg +rngc rngcat rngcataltv rngcbas @@ -69317,6 +114638,7 @@ rnghmsubcsetclem rnghmval rnghom rngidpropd +rngidpropdg rngimcnv rngimf rngimrcl @@ -69337,6 +114659,7 @@ rngmgp rngmgpf rngmneg rngmulr +rngmulrg rngo rngoa rngoaass @@ -69391,6 +114714,7 @@ rngosubdi rngosubdir rngoueqz rngplusg +rngplusgg rngpropd rngqipbas rngqipring @@ -69408,17 +114732,22 @@ rngqiprngimfv rngqiprnglin rngqiprnglinlem rngqiprngu +rngressid rngridlmcl rngringbd rngringbdlem rngrz +rngs rngstr +rngstrg rngsubdi rngsubdir rngunsnply +rngv rnin rninxp rniun +rnk rnlem rnm rnmpo @@ -69443,13 +114772,22 @@ rnmptssf rnmptssff rnmptssrn rnn +rnneg rnnonrel rnode rnold +rnon +rnone +rnonnull rnopab rnopabss rnoprab +rnorm +rnormas +rnormm +rnorms rnot +rnpprod rnpropg rnqmap rnqmapeleldisjsim @@ -69461,80 +114799,149 @@ rnresss rnresun rnresv rnrhmsubrg +rns +rnsi rnsnf +rnsnm rnsnn rnsnop rnsnopg rnss rnssi +rnth rntpos rntrcl rntrclfv rntrclfvoai rntrclfvrp rnttrcl +rnu rnum rnun rnuni rnwf +rnx rnxp rnxpid +rnxpm rnxpss rnxrn rnxrncnvepres rnxrnidres rnxrnres +rny +rnz +road +rob robbins +robdd +robdds +robe robert +robi +robin +robinson +<<<<<<< Updated upstream +======= robjec +>>>>>>> Stashed changes robject robot robust +robustness rock +rockwell +rod +rof +roff +rogers +rogerthat +rogue +rogueness +roi roifex +rok +rol role roles roll +rollback rolle rolled rollelem +rolles rolling +rolllen +rollover rolls +rolm +rolml rom +romatch +romem +romp +<<<<<<< Updated upstream +======= ron +>>>>>>> Stashed changes rondon +rone roo +roofhom room roomk +roopartial root rootable rootableby rootablebyintofrootablebynat rootablebynatofrootablebyint rootablebyofpowleftsurj +rootbound +rootc +rootck +rootcl +rootclus +rootcml +rootcmr +rootcpx +rootcv +rootcx rootd rootdiscr +roote rooted rootedtree +rootencryptioncontext +rootentcnt rootexpr +rootf rootfo rootform rootformin rootgrp rooti +rootlast rootlength +rootm rootmultipl rootmultipli rootmultiplicity +rootn +rootname rootnamespace rootnumber rootofsplit rootofsplits rootofsplitsxpowsubc +rootp rootpairing +rootpf rootpositiveform +rootpt roots rootsaction +rootse rootsequivroots rootset rootsetfintype @@ -69561,26 +114968,69 @@ rootspan rootspanin rootspanmem rootsrc +rootsrefs +rootstep +rootstepeq rootsystem +rootsz roottgt +rootx +rootz +rop rope ropp +roppe +ropt +roption +roptlist +roptn ror +rorl +rorr +rort +ros rose +rosen +roses +<<<<<<< Updated upstream +======= rosewine +>>>>>>> Stashed changes +roshhashanah rosick rosicky +rosolini ross rosser rossros rossspw +roster +<<<<<<< Updated upstream +rostering +======= +>>>>>>> Stashed changes +rosters rot rotate +rotatea +rotateany +rotateb +rotatec +rotatecircle +rotated +rotateevenkeys +rotatef rotatehomotopyequiv rotatehomotopyequivcomm +rotatekeyondemandensurespublicly rotatel +rotateleft +rotateoddkeys +rotatep rotatepolicy rotater +rotateright +rotaterightadds rotaterotaterotateiso rotates rotatetrianglehiso @@ -69588,26 +115038,62 @@ rotatetriangleiso rotatetriangleopequivalenceinverseobjrotateunopiso rotation rotationaux +rotationlemma rotationof +rotationp +rotationperiodindaystype rotations +rotc rotcompinvrot +rotd roth rotharithmeticprogressions +rothe rothnumber rothnumbernat +rotinv +rotisequiv +rotk +rotkeys rotl +rotloop +rotloopequiv +rotloopinv +rotn rotoinversion rotr +rotrk +rots +<<<<<<< Updated upstream +======= rotten +>>>>>>> Stashed changes +rotval +rotword +rou +rouge rough +rougher roughly roughnumbersupto +roughs +roughset +roughsets +roun +rounb round +roundablel +roundableleft +roundabler +roundableright roundabsmonotonel roundabsmonotoner roundbound +roundde +rounddesg rounddown rounddownif +rounded roundedmodeabsmult roundedmodebounded roundedmodeerrorexpstrict @@ -69621,70 +115107,165 @@ roundedmodeprojectoridem roundedmodeprojectoridemeq roundedmoderep roundedmodeulp +roundednes +roundedness roundedprojector +rounden +roundensg +roundfloat +roundfun +roundfunction rounding +roundingdirection +roundingmode +roundings +roundk +roundkey +roundl roundlessthanismax roundlsbmax +roundmode roundmsbmax roundmsbmin +roundness +roundop +roundp +roundr rounds +roundsingle +roundtiestoeven +roundtointegral +roundtowardnegative +roundtowardpositive +roundtowardzero +roundtri roundtrip +roundtripn roundtrippable roundup rourke rout route +routed +routelengths +routep +routes +routesv +routine +routinely +routinep +routines routing routput rover +rovr row rowcol +rowcount +rowe +rowg +rowgd +rowgi +rowgj +rowgk +rowgs rowi +rowk +rowkd +rowku rowlen rowlength rowlens +rownomierny +rownum +rowny +rowp +rowround rows +rowsimprovedtrick +rowsize rowspace rowstart rowstochastic rowsum rowtomessagedata rowtoswap +rowupdate +rowv +rowval rowvector +rowz +royal +royaldomain +royalp +rpabscxpbnd rpabsid +rpadchars rpaddcl rpaddcld +rpadstr rpair +rpairs +rpap rpar +rparams +rparen +<<<<<<< Updated upstream +======= rparent +>>>>>>> Stashed changes rparr +rpart +rpartition rpath +rpb rpc rpcencodable rpcencode rpcn +rpcnap +rpcncxpcl +rpcncxpcld rpcnd rpcndif rpcnne rpcoshcl rpcpnf +rpcxp +rpcxpadd rpcxpcl rpcxpcld +rpcxpef +rpcxple +rpcxplogb +rpcxplt +rpcxpmul +rpcxpneg +rpcxpp +rpcxproot +rpcxpsqrt +rpcxpsqrtth +rpcxpsub rpd +rpdi rpdivcl rpdivcld +rpdivcxp rpdmgm rpdp rpdpcl +rpds rpdvds rpefcl rpefcld +rpelogb rpex rpexp rpexpcl rpexpcld rpexpmord rpf +rpg rpgamcl rpge rpgecl @@ -69695,10 +115276,26 @@ rphalfcl rphalfcld rphalflt rphalfltd +rphih rphil rpi +rpickle +rpicklek rpid +rpiv +rpl +rplaca +rplacd +rplacv rplog +rplogb +rplogbchbase +rplogbcl +rplogbcxp +rplogbid +rplogbreexp +rplogbval +rplogbzexp rplogcl rplogcld rplogsum @@ -69706,43 +115303,83 @@ rplogsumlem rplpwr rpltrp rplus +rplusa +rpluse +rpm +rpmaxcl +rpmincl rpmsubg rpmtmip rpmul rpmulcl rpmulcld +rpmulcxp rpmulgcd rpn rpne rpneg +rpnegap rpnnen rpo -rpoint rpoly rpos +rposinf +rpost +rpostinv rpow rpowcpow +rpowe +rpower rpowintegrand rpowlimits rpowmonoidhom rppwr +rpq rpr rprd rpre +rpreap rpreccl rpreccld rprecondition rprecred rpred rpredb +rpredbl +rpredbr rpredd +rpreddl +rpreddr rpredm +rpredml +rpredmn +rpredmnn +rpredmr +rpredmsign +rpredmz rpredn rprednr +rpredv +rpredvr +rpredx +rpredxn +rpredxsign +rpredxz +rpredz +rpredzeq +rpredzint +rpredznat +rpredzsign +rprefix rprege rpregraph rpregt +rpreinv +rprelogbdiv +rprelogbmul +rprelogbmulexp rprene +rpreserved rpri rprime rprisefaccl @@ -69761,46 +115398,82 @@ rprmnz rprmval rprod rprodl +rproofs rprop -rprp rprpwr -rprs rpsqrtcl rpsqrtcld rpsqrtcn rpsscn rpssre rpssxr +rpstate rpsup +rpt +rpterm +rptfree rpth +rptr +rptsym +rput rpv rpvmasum rpvmasumlem +rpx rpxdivcld rpxr rpxrd +rqbracet +rqbrackt +rqform rqp +rqrm rqs rqt rquicksort rquot rra +rradix +rraise +rrange rrangle +rrax rray rrb +rrba +rrbb +rrbi +rrbrackt +rrbx +rrcwns +rrcx rrd rrdrg +rrdx rre +rreal rrec rred rref +rrefl +rrefp +rreftothread rreg +rregm +rregn +rregp +rregx rrel +rrem rremdups rrep +rreplace rreq rreqid rreqs +rrestr +rrestrict +rret rrext rrextchr rrextcusp @@ -69810,9 +115483,11 @@ rrextnlm rrextnrg rrexttps rrextust +rrf rrfld rrg rrgeq +rrgmex rrgnz rrgss rrgsubm @@ -69831,8 +115506,10 @@ rrhre rrhval rri rrightarrow +rring rrk rrl +rrmovl rrn rrncms rrncmslem @@ -69855,11 +115532,21 @@ rroots rrpos rrpsscn rrr +rrrr rrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrr rrs +rrsp rrstar rrstep +rrsteps +rrt +rrta +rrtb +rrti +rrts rru +rrule +rruniv rrv rrvadd rrvdm @@ -69912,19 +115599,69 @@ rrxtps rrxunitopnfi rrxval rrxvsca +rrz rsa +rsadecrypt +rsadecryptensurespublicly +rsadecryptinput +rsaencrypt +rsaencryptensurespublicly rsaep +rsame +rsamoduluslengthbits +rsamoduluslengthbitstogenerate +rsapss rsb +rsbreak rsc +rscalar +rscalp +rscopes +rscrash rsd +rsduong rsecure +rsel +rsemi +rsense +rseparation rseq +rsequence rset +rseteq +rsf rsg +rsgc rsh +rshadow +<<<<<<< Updated upstream +======= rshadowroot +>>>>>>> Stashed changes +rshare +rshift +rsi +rside rsided +rsig +rsign +rsim +rsimp +rsiwamp +rsize +rskel +rslattice rslt +rslts +rsm +rsmul +rsn +rsnd +rsnon +rsnormal +rsolve +rsome +rsort rsp rspa rspace @@ -69968,7 +115705,11 @@ rspectset rspecval rspesbca rspesbcd +rspex +rspg +rspgt rspidlid +rsplits rspn rsprprmprmidl rsprprmprmidlb @@ -69982,38 +115723,91 @@ rspssid rspssp rspun rspval +rspvalg rspw +rsq rsqr +rsqrmo +rsqrt +rsqrte rsquarefree rsr +rsrcs +rsreturn rss +rssp +rsspa +rsspac +rsspace rst +rsta +rstab +rstabc +rstabs +rstack rstar rstarrplus rstarsym +rstat rstate rstates +rstc rstep +rstepi +rsteps +rstk +rstkfma +rstnode +rstobj +rstop +rstrst rstx +rsu rsub +rsubimm +rsubmx rsubrotld +rsubs rsubset +rsubst +rsubsv rsuffices rsum rsuml rsumover +rsumpt +rsup +rsupremums +rsv +rsvdbyt +rsvdbyts +rsvdseccn +rsvdseccnt +rswap rsx rsy rsym +rsymok +<<<<<<< Updated upstream +======= rsymprop +>>>>>>> Stashed changes rsystmp +rsz +rta rtac rtacp +rtag +rtail rtake rtakewhile +rtarai +rtb rtbl rtc rtci +rtcongruence +rtcp rtcpredn rtcredn rte @@ -70031,18 +115825,58 @@ rtensorhomequivhomrtensor rtensorhomtohomrtensor rtensorinv rtensorone +rterm +rtest +rtests +rtf +rtfsm +rtg +rth +rti +rtime rtimeout +rtimes +rtin rtkb rtl +rtlarr +rtm +rtmi +rtmintvars +rtmm +rtmmem +rtmmemafter +rtmprog +rtmseq +rtmstate +rtmstatehood +rtmval +rtmvar +rtmvars +rtmvarsres +rtmvarsseq +rtmvarsseqs rtn +rto +rtoc +rtoint +rtointk +rtointn +rtointz +rtok rtol +rtop rtopo rtotal +rtp rtprmirr rtr +rtran rtrancl +rtrancli rtranclp rtrans +rtranscl rtransp rtrclex rtrclexi @@ -70050,61 +115884,154 @@ rtrclexlem rtrclind rtrclreclem rtree +rtrichotomy +rtrigo +rtrue rts +rtscl +rtsf +rtsi +rtsx +rtsymmetric +rtt +<<<<<<< Updated upstream +======= rttree +>>>>>>> Stashed changes rtxmntndreoysrggveegc +rty +rtyp rtype +rtypeok +rtyping +rtypm +rtz rualt +ruben +rubout ruc rucalt ruclem +rudimentary rudin +rudnicki +rue +ruid ruin +ruins +rul rule +ruleaaa +ruleclass ruleconfig ruled +rulei +rulelhs +rulelist +rulemap +rulemapp +rulename +rulenec +rulep ruler +rulerhs +rulers rules +rulesconc +rulesd +rulese ruleset rulesets rulesi +rulesinpcs +rulesp +rulet +ruletable ruletac +ruletype +rulev rulhcs +ruls +rumi +rumibl run runandfailifnoprogress runattr +runc runcmd runcmdtc +runco +runcont runcore runcorem runcoremcapturinginfotree runcoremwithmessages rundefeqconvtactic rundefeqtactic +rune runep +runerror runerrort +runes +runfmap runfor +runforaa runfw rungenhandler +rungfix runi +runic +runing runintro +runion +runiq +runique runit +runitcohomiso +runitg +runitgroupequiv +runitgroupiso +runitiso +runitk +runitlunit +runitmul +runitp +runitreal +runits +runiv +runjp +runlength runlinarith +runloopbody +runmachine runmetam runmetamcapturinginfotree runmetamwithmessages +runn +runnable runner +runnerdotcom running runongoals +runoqpq +runp runpass runpasses +runpickle runproc +runpromote runrand runrandwith runreader +runreadert runs runsimplexalgorithm runstate +runstatet +runsto +runstogood +runstonondet +runt runtac runtacforheartbeats runtactic @@ -70116,11 +116043,17 @@ runtermelabm runtest runthe runtime +runto +runtool runtreem runuse +runwritert runz ruold +rup +rupadd rur +rus rusbcalt rusgr rusgrnumwlkg @@ -70141,8 +116074,14 @@ rusgrrgr rusgrusgr rushhour russell +russinoff rust +ruststring +rusu +rusub rutn +rutt +ruttf ruusdbeqlen ruv ruvalt @@ -70150,8 +116089,23 @@ ruzsa ruzsaszemeredi ruzsaszemeredinumber ruzsaszemeredinumbernat +rva +rvabelem +rvabelemd +rvabelemj +rvabelemk +rvabelemn +rvabelems +rvabelemz rval +rvalidity +rvalinjnu +rvalof +rvalue rvar +rvarcons +rvarlift +rvars rvd rvec rvecabl @@ -70164,50 +116118,85 @@ rvecsscmod rvecsscvec rvecssmod rvecssvec +rvector rvecvec +rveric rvimage +rvinv rvm rvmimti +rvn +rvneg rvog rvoldn +rvp rvpeq +rvpoly +rvpolyk rvr rvrmutdi rvrtsi rvs +rvscript +rvsu rvsum rvtsi +rvval rwa rwaiting +rwc rwf +rwhile +rwitness +rwl +rwlib rwlock rwlockspec rwmerge +rwn +rwnotin rwof rword rwp rwr +rwra rwresult rwrule rwruleseq rwrulesseqstx rws rwt +rwts +rwtype rwurgxrfce +rwx +rwxuyzz rxa rxb rxbltdxhmhdgnfxhf +rxcap rxfirst +rxfollow rxhfpl rxm rxn rxp -rxsys +rxq +rxr +rxs +rxsz +rxv +rxx rxy rxys +rxz rya +ryan rykdj +rypdixt ryvfkdzp +ryx +ryz rzal rzalalt rzalf @@ -70215,15 +116204,42 @@ rzero rzf rzgrp rzmdldowpzsqgtrdmprzt +rzs rzv rzvold +saa +<<<<<<< Updated upstream +======= +saab +>>>>>>> Stashed changes +saabs +saabsa +saabsb +saabsorbstable +saactioninterpret +<<<<<<< Updated upstream +======= saarbruecken +>>>>>>> Stashed changes sab +sabilogic +sabiops +sabis +sabisa +sabisb +sabp sabs sabstract +sac saca +sacc +saccheri +saccheris sacgr +sachain +saclay sact +saction sad sadadd sadaddlem @@ -70240,30 +116256,63 @@ sadd saddisj saddisjlem saddlepoint +saddr sadeq sadfval sadid +sadly +sadm +sadness sadval +saead saevents +saf safe +safeaccessese +safec +safecopyslice +safediv +safedivide +safee +safeequal safei +safelookup safely +safemod safen +safenonee +safenonei +safep +safepath safer safesnsupfidom safesnsupfilb safesnsupfiss safesnsupfiub +safesomealti +safesomee +safesomei safetcg safety +safetyd +safetye +safetyi +safetyn +safevar +sag saga +sai +saibiops said +sail sais sake +sakurai sal sald saldifcl saldifcld +salem salexct salg salgen @@ -70282,7 +116331,9 @@ salincl salincld saliuncl saliunclf +sall salli +salloc salpreimagelt salpreimagtge salpreimagtlt @@ -70294,57 +116345,127 @@ salsa salsafunspecs salsavarspecs salt +saltlen +saltp saluncl saluncld saluni salunicl salunid +salvaged +salways +sam same +<<<<<<< Updated upstream +======= sameas +>>>>>>> Stashed changes +samebase +sameblock +samecarda +samecardb +samecc +samecdiffab +sameclass samecycle sameexpeq samef samefm +samefringe samefw +samei sameiff +<<<<<<< Updated upstream +======= samekind +>>>>>>> Stashed changes +samel +samelength +sameline +sameln +samelocation +samenotopposite samep +sameperms sameprod +sameproof +samept +samer sameray samerep +samerepr +samesequence sameside +samesidecollinear +samesideflip +<<<<<<< Updated upstream +======= samesideline +>>>>>>> Stashed changes +samesidereflexive +samesidesymmetric +samesidetransitive samespace samet +sametest sametype +samevar samp sample sampleableext +samplebound sampled +sampleequals +sampleisindepfunction +sampleismeasurepreserving +samplepeg sampler samples +samplespace +samplet +sams +samsara +san +<<<<<<< Updated upstream +======= sancerre +>>>>>>> Stashed changes sandbox sanders sandwich sandwiching sane +sanei +sanitize sanitizenames sanity +saops sap +sapace +sappend +sappendisassociative +sar sard sarg sargs +sarkovskii +sarx sas sasa sascaraudiosystem +sasequalbd +sasequalcd +sasp +sassert sassign sat sata +satac sataxiom sataxiombounded sataxiomeq sataxiomfounded +sataxiomi sataxiomprooftree sataxiomterminal satc @@ -70368,6 +116489,8 @@ satfdmlem satff satffun satffunlem +satflagaftersolveloop +satflaglessstate satfn satfrel satfrnmapom @@ -70381,46 +116504,78 @@ satfvsuclem satfvsucom satfvsucsuc sati +satifies satis +satisf satisfaction +satisfactory +satisfi +satisfia +satisfiability satisfiable satisfiableappendtautologicalformula satisfiableappendtautology satisfiablefiltertautologies +satisfiableunion satisfied satisfiedclausecanberemoved satisfies satisfiesm satisfy +satisfyin satisfying satisfytokensfn +satisifies +satistfies satl +satlink +satlits satom satp satpb +satposetax +satprod +satriani sats satterthwaite +sattrprod +satur saturate saturated +saturatedaddu saturatedsubmonoid +saturates +saturating saturation +saturday sauer sauivxcjpymwlbffmnioyqljncoidjbbdrrvgpiqxlispkujpjcfyznpktpnetygiqxn +<<<<<<< Updated upstream +======= sauternes sauvignonblanc +>>>>>>> Stashed changes +saux save +saved savedmessages savedmsgs savedstate savedtrees +saveic savepanelwidgetinfo +saveregs saves savestate +saving saw +sawada +sawp say sayhello saying says +sba sbab sbabel sbal @@ -70430,12 +116585,17 @@ sbalexold sbali sbalnae sbalv +sbalyz sban sbaniota +sbanv +sbase +sbb sbbi sbbib sbbibvv sbbid +sbbidh sbbidv sbbii sbbiiev @@ -70444,16 +116604,20 @@ sbcabel sbcal sbcalf sbcalfi +sbcalg sbcaltop sbcan +sbcang sbcani sbcbi sbcbid sbcbidv sbcbig sbcbii +sbcbiiold sbcbivd sbcbr +sbcbrg sbcco sbccom sbccomieg @@ -70461,6 +116625,7 @@ sbccomlem sbccomlemold sbccow sbccsb +sbccsbg sbcel sbceq sbceqal @@ -70473,6 +116638,7 @@ sbceqi sbcex sbcexf sbcexfi +sbcexg sbcfg sbcfng sbcfung @@ -70493,6 +116659,7 @@ sbcim sbcimdv sbcimg sbcimi +sbcl sbcn sbcne sbcnel @@ -70503,12 +116670,17 @@ sbcnestgw sbcng sbcni sbco +sbcocom +sbcof sbcom +sbcomv +sbcomxyyz sbcop sbcopeq sbcor sbcoreleleq sbcoreleleqvd +sbcorg sbcori sbcoteq sbcov @@ -70518,11 +116690,15 @@ sbcralg sbcralt sbcrel sbcreu +sbcreug sbcrex +sbcrexg sbcrexgold sbcrexold sbcrext sbcrot +sbcsng +sbcss sbcssg sbcssgvd sbcth @@ -70531,6 +116707,7 @@ sbctt sbd sbdd sbe +sbefore sbel sbelx sbeq @@ -70541,8 +116718,10 @@ sbeqi sbequ sbequbidv sbequi +sbequilem sbex sbexi +sbexyz sbf sbfal sbft @@ -70567,53 +116746,82 @@ sbidm sbidmold sbie sbied +sbiedh sbiedv sbiedvw sbiedw +sbieh sbiev sbievold sbievv sbievw sbievwd sbievwold +sbif sbim sbimd sbimdv +sbime +sbimedh +sbimeh sbimi +sbimv +sbin sbiota sbis +sbiset +sbisimulation +sbit +sbits +sbitse +sbitset +sbitsetp sbjust +sblank sblbis sblem sblim sblimt +sblimv sblit +sblk +sblkp +sblock sblpnf +sbm +sbml sbmo sbn sbnf sbnfc sbnfold +sbnv sbo +sbool sbor +sborv sbottom sbounded sboundedl sboundedr +sbox +sboxval +sbp +sbps sbralie sbraliealt sbralieold sbrbif sbrbis -sbrdtbr sbreak sbrim sbrimt sbrimvw +sbs sbsb sbsbc -sbsmnsldt sbss +sbst sbt sbtalt sbtd @@ -70623,27 +116831,58 @@ sbthcl sbthfi sbthfilem sbthlem +sbthlemi +sbthom +sbthomlem sbtlem sbtr sbtrt sbtru sbtt sbtw +sbuild +sbuiltin +sbuiltinarg +sbuiltinres sbv +sbvdiv +sbvdivdown +sbvl +sbvle +sbvlt +sbvmoddown +sbvplus +sbvrem +sbyte +sbz sca scad scafeq +scafeqg scaffn +scaffng scaffval +scaffvalg scafv scafval +scafvalg scaid scal +scala scalable scalableroundedmodep scalar scalaralghom +scalaredp scalarfield +scalarform +scalargenericsize +scalarif +scalarinner +scalarize +scalarmult +scalarof +scalarofif scalarp scalarproperties scalarrestriction @@ -70653,88 +116892,218 @@ scalars scalarsemiring scalarsl scalarsmulcle +scalarsum scalartensorequiv scalartower scalartowerinst +scalarvalue +scalarxcol +scalarxline scalarz scaldiv scale +scalea +scaleal +scalear +scaleb +scaleby scalebymonom scalec scaled +scaledl scaledr +scalee +scalel +scaleloopvariantfn +scalemx +scalemxa +scalemxal +scalemxar +scalemxdl +scalemxdr +scalen scalene +scalenr +scaleo +scaleolx +scaleop +scaleox +scalep +scaleps scaleq scaler +scalera +scaleral +scalerar scalerat +scalerbl +scalerbr +scalerca +scalerdl +scalerdr +scaleri +scalerk +scalerkv +scalermnl +scalermnr +scalermzl +scalermzr +scalern scaleroots scales scalew +scalezre scaling scalingconstantof scalingscaleof +scalk scall +scalp +scalpe scalprod +scalq +scalqe +scalr +scalrfcte scan +scancan +scand scandx scandxnbasendx scandxnmulrndx scandxnplusgndx +scane +scanensurespublicly scanl +scanlk +scanned +scannedalist +scanner +scanning scanr scans +scansegment +scantotalsegments +scaob scar scard +scardgen +scary scase +scaslid scasrng +scassign scast +scat +scategory +scaterring +scatter +scattered +scattering +scb scc +scchain +scci +sccompactification +scconc +scconca +scconcend sccs +sccx +sccy scd scdnoninterference scdom +scdr sce +scembed +scembeddedcopy scenario +scenarios +scene +scevaluation +scex +scextend +scextension scf +scfgew +scfi scfinv sch schaeffer +schange schapira +schar schauder schauderbasis +schaux +sche sched +schedfail schedpeek +schedskip +schedu +schedul schedule +scheduled +schedulekeydeletionensurespublicly scheduler scheduling +scheffe schema +schemalg schemas +schemat +schematic scheme schemeisotohomeo schemes +schems +scherungssatz schlomilch schmidt +schnirelman +schnirelmann schnirelmanndensity +schnorr +schoenflies +schoenhage scholze +school +schorr +schorrwaite +schottky schr schramm +schreier schroeder schroederbernstein +schstep schur schurcomplement +schurzassenhaus schurzassenhausabelian schurzassenhausinduction schwartz schwartzmap schwartzseminormfamily schwarz +sci science scimplyle +scion +scions +scirc +scissors +sck +sckey scl +sclaim sclcl scleq sclf sclid +sclimit sclle sclm sclmul @@ -70753,6 +117122,7 @@ scltm scm scmap scmapiso +scmaps scmat scmataddcl scmatcrng @@ -70783,19 +117153,49 @@ scmatsrng scmatstrbas scmatsubcl scmatval +scmbsort +scme +scmf +scmfs +scmfsa +scmfsaex scmfsupp +scmisort +scmm +scmminv +scmp +scmpds +scmpdsex +scmrin +scmring +scmringi scmsuppfi scmsuppss scmult +scmyciel scmzhivnnorqikjzpycfblijgrwuduzk scn +scnat +scnj +scnotconc +sco +scollect scombine scomp +scompile +scomplement scomponent scompose scon +sconcat +scond +sconds sconf +<<<<<<< Updated upstream +======= sconfl +>>>>>>> Stashed changes +scong sconjunctive sconn sconnpconn @@ -70803,20 +117203,53 @@ sconnpht sconnpi sconntop scons +sconsp sconst +sconsts +scont scontinue +scontra +scop scope +scopecontext scoped +scopedef +scopedeflist scopedterm +scopeerr +scopeexpr +scopehead scopeht scopeid +scopeinfo +scopeite +scopeitem +scopeitemlist +scopelist +scopename +scopenamelist scopes +scopestack scopestate +scopesubst +scopesv +scopetests +scopetext +scopetree +scopetype scoping +scopt score scorec +scorelist +scorelistp +scorelists scores +scorestep scoretoconfig +scost +scostopt +scother scott scottab scottabes @@ -70832,43 +117265,155 @@ scottex scottexf scottexs scotthausdorff +scottish +scottlocale scottn scottopen scottrankd scottss scount scov +scp +scpfs +scpinvar +scpisort +scpn +scpnv +scpog +scpogsem scpqggmcifemunmzkhwkvgo +scpqsort +scproduct +scproject +scprojection +scprojections +scprovable +scpstep +scpsteps +scpstepv +scpv scqqsmgkklqvrvzjotmctakuvtlhun scr +scra +scrat +<<<<<<< Updated upstream +======= scratc +>>>>>>> Stashed changes scratch +scratchi +scratchlist +scratcho +scratchobj +scratchobjs +scratchp +scraw +scrd +screa +<<<<<<< Updated upstream +======= scream +>>>>>>> Stashed changes +screen +screw +screwed +screwy +scrfiq +scrfw +scrid script scripted scriptfnnoantiquot +scriptl scriptparser +scripts +scrirq +scrnet +scrns +scroll +scrub +scrubbing +scrublist +scrut +scs +scsafe +scsc scshwfzeqfzo +scskip +scstep +scsubset scsym sct +sctlc +sctlr +sctlra +sctlree +sctlrnmfi +sctlrte +sctlrtype +sctlru +sctlrv +sctn +sctp +sctrl +sctrlreg +sctrlregwrite +sctx +<<<<<<< Updated upstream +======= sculpture +>>>>>>> Stashed changes +scure +scut +scv +scvalar scvarpw scvarpwval scvg scvxcvx +sdag +sdagp +sdata +sdb +sdbase sdc sdclem +sdcons +sdd +sddec sde +sdebug +sdec +sdefinition sdense +sdepth +sdest +sdet +sdf +sdfi sdfun sdg +sdh sdi +sdia +sdiagram sdiff +sdihjzk sdiv +sdiverge sdivr +sdk +sdl sdlhppb sdlx +sdm +sdmax +sdmaxdigit +sdmem +sdmin +sdmindigit sdnn +sdo sdom sdomdif sdomdom @@ -70879,6 +117424,7 @@ sdomen sdomentr sdomg sdominate +sdominfo sdomirr sdomn sdomne @@ -70888,7 +117434,30 @@ sdomsdomcard sdomsdomcardi sdomtr sdot +sdouble +sdowhile sdp +sdpair +sdpaire +sdprod +sdprode +sdprodey +sdprodg +sdprodj +sdprodk +sdprodm +sdprodme +sdprodmel +sdprodmer +sdprodml +sdprodmr +sdprodp +sdprodr +sdprodw +sdprodwc +sdprodwpp +sdprodwy +sdr sdrgacs sdrgbas sdrgdrng @@ -70902,8 +117471,17 @@ sdrgss sdrgsubrg sdrgunit sdrop +sdropd sds sdsj +sdstar +sdsub +sdsubadddigit +sdsubdigit +sdsubdigits +sdt +<<<<<<< Updated upstream +======= sdtasasdt sdtasdt sdtbsmnsldt @@ -70918,30 +117496,86 @@ sdtmndtplgtdt sdtpldt sdtsldt sdtslmnbsdt +>>>>>>> Stashed changes sdummy sdv sdvold +sea +seact seal +sealauth +sealauthpsk +sealbase +sealed +sealpsk +sealt +sear search +searchability +searchable +searchandprint +searchandreplace +searchandreplaceall +searchandreplaceallwhole +searchandreplacepos +searchandreplaceposwhole +searchandreplacewhole +searchaux +searchco +searched searchentry searches +searchfield +searchfields +searchforwinner searching +searchmethod +<<<<<<< Updated upstream +searchnat +======= +>>>>>>> Stashed changes searchpath searchpathref +searchproof +searchs +searchstack +searchstackfra +searchstackframe +searchstackframefounnd +searchstackmap searchtree searchtreex searchw +searchxy +searchxyispr seat +seats sec secadmgrp secant +secantlines +secantparallelogrammsecant secants seccl secclass seccomp +seccongdep +secconst +seceq +secfin +sech +seciseq secmat secmateq +secn +seco +secon second +secondaril +secondary +secondarygeach +secondaryp +secondassertnotprovedbecauseassertnotrevealed secondcountable secondcountableaestronglymeasurable secondcountablestronglymeasurable @@ -70949,21 +117583,45 @@ secondcountabletopology secondcountabletopologyeither secondderiv secondderivativeapi +secondes +secondfixedpoint +secondincompletness secondinter -secondinupair secondly secondmap secondobj secondpart secondrecursivecalls seconds +secondsfromdawn +secondstack +secondstage secondstep secondtomax +secondturingstate +secondturingsymbol +secondturingtran +secp +secpe +secper +secperclu +secperclus +secpertrk secrecy secret +secretbox +<<<<<<< Updated upstream +======= secretfile +>>>>>>> Stashed changes secretkey +secretkeybytes +secretmatri +secretmatrixbytes +secrets +secs sect +sectan sectcan sectco sectd @@ -70977,11 +117635,16 @@ sectio section sectioncotangent sectioninbasicopen +sectionisequiv sectionmap +sectionof sectionofcone +sectionoffunctor sectionofretractionkertotensor sectionofretractionkertotensoraux +sectionp sectionpairwise +sectionretraction sections sectionsaddsubgroup sectionsaddsubmonoid @@ -71011,6 +117674,7 @@ sectionuncurry sectl sectlsectr sectmon +sectname sector sectpropd sectpropdlem @@ -71020,32 +117684,52 @@ sectss sectype sectypeimpliesnoninterference secure +securec secureequiv securefilli secureforattackingcontext securei securestate +securett security securityinvariant secval +sedge +sedges see seed +seedlen +seeds +seedtree +seedtreeleaf +seedtreenode +seedtreeundef seeing +seek +seekm seem seemed seemingly seems seen seenlevels +seenlist seeq sees seex sef +sefa +sefb seff +sefl +sefvex seg segcon segconeq segconeu +segements +seger +segi segleantisym seglecgr seglelin @@ -71054,12 +117738,30 @@ seglemin seglerflx segletr segm +segme +segmen segment +segmental +segmentation segmentd +segmente +segmentlength +segmentmidpoint segmentp segments +segmentsh +segmentsubset +segname segofs +segp +segpath +segpathxy +segre +segs +segslist +segundo seidel +seids seinxp seitxzygyejqgq sel @@ -71070,9 +117772,14 @@ selbergr selbergs selbergsb selbergsieve +selconcat selconj +selconst +sele +selec select selectable +selectd selected selectedlocation selectedlocations @@ -71080,20 +117787,34 @@ selecting selectinsertparams selectinsertparamsclass selection +selectiond +selectioni selectionpanel selectionrange +selections selectionsortcorrect selective selectively selectivemagma +selectl selectlike +selectlist +selectliteral +selectmanyconstraint +selectoneconstraint +selectop selector +selectorbits selectord selectors +selectp selectpivotpart selectpoly +selectr selects +selecttargetpc selectvars +selexpr self selfadj selfadjoint @@ -71104,62 +117825,184 @@ selfadjointpart selfadjointpartl selfadjointsubmodule selfadjointunital +selfapp selfapplyequiv +selfassigns selfbasis +selfbound selfbutter +<<<<<<< Updated upstream +======= selfcaused +>>>>>>> Stashed changes +selfcollide selfcoloring selfequivorbitsquotientprod selfequivsigmaorbits selfequivsigmaorbitsquotientstabilizer +selfinduct selfinverse selfiscommonfactor +selfjoins selfleradical selfleradicaldiagram +selflock selfloop +selfloops +selfmaps +selfmembers selfprod selfprodpermincl selfprodproj selfprodtermincl +selfrep selfreplacements +selfsi +selfsimilar +selfsimilarcorrected +selfsimilarforclass +selfsimilarforclasshash +selfsize selfskewadjoint +selftype +selfwork selfz selfzpow -sell seller -selling sellprotocol +selmapval selmer selmergroup +selparity +selparityappend +selresolve +selrestrict sels selsalt +selsort +selstep +seltrace +selupd selvadd selvcl selvcllem selvcllemh +selves selvffval selvfval selvmul selvval selvvvval +selwidth sem sema +seman +semant semantic +semantically semanticpossibleworldforsyntacticpossibleworlds +semanticprimitives semantics semanticsinduct +semanticsmono +semanticstable +semantocs semaphore semassignsc semax +semaxarg +semaxioms +sembacktrack +sembacktrackfuel +sembacktrackfueldef +sembacktracksize +sembindgensize +sembindgensizemonotonic +sembindgenusinzed +sembindoptsizemonotonicincl +sembindoptsizeopt +sembindsize +sembindsizemonotonic +sembindsizemonotonicincl +sembindsizeopt +sembindunsized sembv semc +semcallback +semcheckable +semcheckablebool +semcheckableboolsize +semcheckablefunsize +semcheckablegensize +semcheckablepolyfunsetsize +semcheckablepolyfunsize +semcheckableqprop +semcheckableqpropsize +semcheckableresult +semcheckableresultsize +semcheckablesize +semcheckableunit +semcheckableunitsize +semchecker +semcheckersize +semchoose +semchoosesize +semclassify semclosed +semcollect +semcolor +semcomplete +semcover +semd +semdet +semdeterm +semdivop +seme +semelements +semelementssize +semelems +semelemssize +semenv +semexp +semfind +semfmap +semfmapbind +semfmapsize +semfoldgen +semforallshrinkmonotonic +semforallshrinksize +semforallshrinkunsized +semforallsize +semforallsizemonotonic +semforallunsized +semfreq +semfreqsize +semfrequency +semfrequencysize +semg +semgen +semgenopt +semgenrbtreeheight +semgensize +semgensizeinhabited +semgensizeopt semi semiadditiveofbinarybiproducts +semialgebraic +semiassociativity +semiattractive +semiautomaton +semicartesianmonoidal semicartesianmonoidalcategory +semicircle semiclosed +semicohidncone semicolon semicolonlinter +semicolons +semicolont +semicommutative +semicong semiconj semiconjby semiconjugate @@ -71169,29 +118012,52 @@ semicontinuity semicontinuous semicontinuousat semicontinuouson +semicontinuousp semicontinuouswithinat +semicontract +semidecidability +semidecidable semidecisive +semidecisivei semidefinite +semidihedral +semidir +semidirect +semidirected semidirectproduct semidirectproductmulequiv semidirectproducttogroupextensionequiv semidirectsum semidom +semidp semieq semifeasib semifeasible semifield semifields +semifin +semifinite +semigr +semigro +semigrou semigroup semigroupaction +semigroupbin +semigroupequiv semigroupideal +semigrouppath semigroups +semigroupstr semigroupwithzero semigrp semigrpisotomulequiv semiinnerproductspace +semiiso semijoin +semik +semil semila +semilat semilatinf semilatinfcat semilatsup @@ -71199,11 +118065,16 @@ semilatsupcat semilatsupcatequivsemilatinfcat semilatt semilattice +semilatticeequiv +semilatticehom semilatticeinf semilatticeinfbot semilatticeinfofhasbinaryproducts semilatticeinfofislimitbinaryfan semilatticeinftop +semilatticepath +semilattices +semilatticestr semilatticesup semilatticesupbot semilatticesupdirected @@ -71211,6 +118082,7 @@ semilatticesupofhasbinarycoproducts semilatticesupofiscolimitbinarycofan semilatticesuporderbot semilatticesuptop +semilattrelstr semilattstr semilength semilinear @@ -71222,13 +118094,14 @@ semilinearities semilinearmap semilinearmapaddequiv semilinearmapclass -semillon -semillonorsauvignonblanc semimedial semimedialmagma semimetric +semimetricspace semimodule semimodulecat +semimplication +semimplicationsize semimultiplicative seminorm seminormaux @@ -71254,62 +118127,161 @@ seminormfromconst seminormfromconstringnormoffield seminorms semiopen +semipolar +semiprime +semiprimej +semiprimes +semipseudolattice semiquot +semirecursive semired +semireflect +semiregular +semiregularj +semiregularp +semiregulars semiri semirin semiring semiringcat semiringcatisotoringequiv semiringhom +semiringl +semiringofsetstype semiringoperators +semiringorder +semiringpred semirings semiringwithoutannihilatingzero semiringwithoutone +semis +semisensible semisimple semisimplicity +semist semistandardyoungtableau +semit +semitok semitype +semiwkey +semlabel +semliftgen +semliftgensize +semlistofsize +semlistofunsized +semndeterm +semoneof +semoneofsize +sempredqprop +sempredqpropsize +semprinttestcase +sempromote +sempromotesize +semrbtree +semresize +semresolution +semresproof +semreturn +semreturngen +semreturngensize +semreturnsize sems semsem +semsequencegensize +semsequencegensizemonotonic +semshrinking +semsize +semsized +semsizedsize +semsizeopt +semsizeresize semsource semt semtarget +semthunkgen +semthunkgensize +semty +semvar +semvectorofsize +semvectorofunsized +semwhenfail sen send +sendbytes +sende sender +senderpublickey +sendexportauth +sendexportauthpsk +sendexportbase +sendexportpsk sending +sendinv sendmsg +sendofriend +sendpost sends +sendserverreq +sendte +sendto +sendupd +sendupdd +senior +seniors +sens sense sensible +sensical sensitive +sensitivity +sensitvity sent +sentabort +sentails +sentcommit sentence +sentences +sentinel sentouterfriendids +sentouterfriends senv seo sep +sepa sepalg +sepalgops +sepapp +sepapps +sepappspayloadlen separ +separa separability separable separableassumption separablecl separableclosure separableclosureoperator +separablep +separablepn separables +separablesl separablespace separablespaceinductivelimit +separablesr +separado separat separate separated +separatedbool +separatedc separatedfinset separatedness separatednhds +separatedp separately separatelycontinuousadd separatelycontinuousmul +separateness separates separatespoints separatespointsstrongly @@ -71319,121 +118291,322 @@ separatingdual separatingfamily separatingleft separatingright +separatingsemantics separatio separation +separationabsorbstable +separationalgebra +separationalgebraabsorbstable +separationalgebrabisstable +separationemplanguage +separationlanguage +separationlogic separationqu separationquotient separationquotientcompletion +separationstable +separationtransparentmodality separator +separatorp separators +separatorw sepby +sepc +sepclause sepcon +sepcona +sepcons +sepconx sepcsepo sepdegree sepdisj +seperatable +seperate +seperation sepex sepexi sepexlem sepfsepc +sepfunc +sepindir +<<<<<<< Updated upstream +======= sepinpowerset +>>>>>>> Stashed changes +sepint +seplog sepnsepo sepnsepolem +sepo seposep seppcld seppsepf +sepquadruples sepquothomeomorphringquot sepquotringequivringquot +seprec +sepref +sepregression +seprop +seps +sepseq +sepsf +sepsp +sepspa +sepspadj +sepspc +<<<<<<< Updated upstream +======= sepsubset +>>>>>>> Stashed changes +sepsym +sept +september +septraction +septrue +sepvar sepx +sepxseq seq seqabs +seqabstformp seqaddgrouphom +seqanno seqappendassoc +seqappendlen seqappendlength seqappendnil seqauto +seqaxiom +seqaxiomgeneralized +seqb +seqbinopdef +seqbinopex +seqbinopun +seqbool +seqc seqcallrule seqcaopr +seqcaoprg +seqcasesareexclusive +seqcheck seqcl +seqclg seqclosure +seqcolim +seqcolimiso +seqcolimlift +seqcolimshift +seqcolimsuc seqcoll seqcompact seqcompactspace seqcompositionality seqcondrule +seqconst +seqconstp seqcontinuous +seqcterm +seqctermp seqcvg seqcvgd +seqd +seqdeserializeserialize +seqdex seqdistr +seqdu +seqdue +seqduie seqdyncomrule +seqe +seqempty seqeq seqex +seqexd +seqext +seqextsimpl seqexw seqf seqfeq +seqfilterle seqfiltersubseq +seqfirst seqflattenlength seqfn +seqform +seqformp +seqfunc seqfveq +seqfveqg +seqgrabws seqguardrule +seqhaddp seqhomo +seqhomog +seqhr +seqhrp seqi seqid +seqidentity +seqify +seqindex +seqintersection +seqintoarray +seqiscomplete +seqiterate seqk +seql +seqlambda +seqlambdad seqleft +seqlemmas +seqlen seqlib seqm +seqmaplen seqmaplength seqmarshalling seqmemberappend +seqmodel seqn +<<<<<<< Updated upstream +======= +seqnilappend +>>>>>>> Stashed changes +seqnum seqof seqofforallfinsetexistsaux +seqofseqlambdad seqom seqomeq seqomlem seqomsuc +seqovcd seqp seqpar +seqpartsmakewhole +seqpattern +seqpe +seqpick seqpo +seqpostouint +seqprefix +seqr +seqrank +seqreds +seqredsthrow +seqrepeat +seqrepr seqres +seqret +<<<<<<< Updated upstream +======= +seqreverseidem +seqreverselen +>>>>>>> Stashed changes seqreverselength seqreversereverse seqright seqs +seqsame +seqsecond +seqsem seqseq +seqserialize +seqserializedeserialize seqsex seqsfn seqshft +seqsize +seqsl seqsp seqsplit +seqsplitg +seqsr +seqstackfree seqstar +seqstep +seqsteps seqstr +seqsttermp +seqsub seqsubs seqsubscons seqsubsnil seqsubst seqsubstcons seqsubstermappend +seqsubstformp seqsubstnil seqsubstsimps seqsubsttermappend seqsum seqsval +seqswap +seqt +seqtakeappend +<<<<<<< Updated upstream +======= +seqtakedrop +>>>>>>> Stashed changes seqtakedropidentity +seqtemp +seqtempimm +seqtempimmnot seqtendsto seqtendstoae seqtendstoaeseq seqtendstoaeseqaux +seqterm +seqtermp +seqtermtoform +seqtheory seqtl seqtlobv +seqtoarray +seqtok +seqtokeq +seqtoknil +seqtokp +seqtolist +seqtonat +seqtonatzeroprefix +seqtoset +seqtostring +seqtouint +seqtrans +seqts +sequ +seque +sequen +sequenc sequence +sequenceadmissibility +sequenceconstructionwithnamedfunction +sequenceconversion sequenced sequencee +sequenceequal +sequenceequalnat +sequenceequiv +sequenceequivj +sequenceequivjrefl +sequencegen sequencei +sequenceinv sequenceiso +sequenceissafebecauseitisinmemory +sequencelci +sequencemap +sequencenumber sequenceofcofinals +sequencep sequences +sequencespec +sequencet +sequencetest +sequenceupdateoutofbounds +sequencevector sequencing sequent sequentcalculus @@ -71442,45 +118615,115 @@ sequentialadjunction sequentialadjunctioncounitiso sequentialadjunctionhomeo sequentialfunctor +sequentialgcd +sequentialisation +sequentialize sequentially sequentiallycomplete +sequentialp sequentialproduct sequentialspace sequentialtolightcondset sequentialtotal sequentialtotop +sequents +sequenttol +sequenttolp +sequenttonl +sequenttonlp +sequpdate +seqv seqval +seqvalcd seqwhilerule +seqwithuint +seqwrp seqz ser seradd serclim serde +sere +seres serf serfre serge +seri serial +seriali serialisation serialised +<<<<<<< Updated upstream +serializable +======= +>>>>>>> Stashed changes +serializabletypes serialization +serializationerror serialize +serializealloc serialized +serializedcommitmentkey +serializedec +serializedp +serializeedkciphertext +serializefixedinfo +serializefunctions +serializeinto +serializekeydescription +serializekeydescriptioninput +serializekeydescriptionoutput +serializemessagewithoutsignature +serializemessagewithsignature +serializeproviderinfo +serializer +serializeto serializing +serialpartialfunctional +serie series +seriesb +seriesd +seriese +seriesenat +serieseord +seriesk +seriesn +seriesp +seriesrbd +seriess +seriessb +seriessr +seriesz +serious +serita serle sermono +serpent +serpentblockdecrypt +serpentblockencrypt +serr serre serreclasslocalization serrederivative +serror sersub +<<<<<<< Updated upstream +======= sert +>>>>>>> Stashed changes +serv serve +served server servernethandler servertype serves service +servicecenter +serving ses +sesamath sesk seskey sesq @@ -71497,9 +118740,16 @@ sessiontypechecker sessionviolation set seta +setaassign +setaconseq setact +setacte +setactj +setactvin setadd setaddorderofequiv +<<<<<<< Updated upstream +======= setadjoin setadjoinax setadjoine @@ -71507,46 +118757,140 @@ setadjoinil setadjoinir setadjoinor setadjoinsub +>>>>>>> Stashed changes +setaf +setaif +setalgebra +setalias +setapp +setappint setarg +setasint +setaskip setaverage +setb setbasisoflinearindependentofcardeqfinrank setbasisoftoplespanofcardeqfinrank +setbelow setber setbernoulli +<<<<<<< Updated upstream +======= setbeta +>>>>>>> Stashed changes +setbf +setbit +setbitn +setbits setbool +setbox +setboxspecific +<<<<<<< Updated upstream +setc +setcan +setcardinality +======= setbreln setc +setcan +setcardinality +setcardsubset +>>>>>>> Stashed changes setcarduniondisjoint setcat +setcategory setcbas +setcc setccat setccatid setcco setccofval +setcd +setceilmax setcepi +setchild setchom setchomfval +setci setcid setcinv setciso +setcitv +setcitvl +setcitvr +setck setcmon setco +setcod +setcode setcoe +setcoeq +setcoeqisoupair +setcoequalizer +setcoequalizerpair +setcolor +setcolorbox +setcomp +setcompat +setcompe setcompr +setcomprehension +setcomprehensionboxantecedents +setcomprehensionparsingregression +setcon +setcone +setcong setcongr +setcongruence +setcons +setconslem +setconstruction setcontinuous +setcp +setcs setcsect setcsnterm +setct setcthin +setcu setcurrentdirectory setcval +setcyt setd +setdata setdc +setdccitv +setdd +setddl +setddr +setde setdemorgan setdi +setdidl +setdidpl setdiff +setdifference +setdik +setdil +setdir setdist +setditv +setditvnyo +setditvoo +setditvoy +setdki +setdku +setdom +setdp +setds +setdss +setdt +setdu +setdud +setduk +setdul +setdur +setdv sete seteasprevious setelem @@ -71555,91 +118899,179 @@ setencard setentropylen setenv seteq +seteqfun seteqi +seteqp setequ +setequality +setequiv setex setexp setexporting +<<<<<<< Updated upstream +======= setext setextax setextsub setextt +>>>>>>> Stashed changes +setf +setfa setfailifunchanged setfam setfamily +setfc setfin setfinal setfinite setfiniteconstructors setfintype +setfix +setfixed +setfk setflags +setfnk +setfst +setfun +setfundomappcod +setg setgcd +setglobal +setglobals +setglobalsptr setgoals sethi +sethood seti +setia +setiac +setiaca +setic +setica setici +setick +seticl +seticr +setid +setida +setidac +setiddep +setide +setidp setifinbounds +setify +setig +setiid +setiidl +setiidpl +setiidpr +setiidr +setiil +setiir +setik +setikc +setil +setim setimage +setimp +setimpint setin -setinc setind +setindel +setindf +setindft +setindis setindnd setindregs setinds setindtr setindtrs setinit +setinsert setint setinte setintegral setintercomm +setinterempty setinterior setinterleaves setinterleaving setinterleavinglist +setintersection setintersubset +<<<<<<< Updated upstream +======= +setinterval +>>>>>>> Stashed changes +setinv setinvon +setip +setipre +setir setis setisotypiccomponents +setiss +setissafebecauseitisinmemory +setisseq +setit +setitv +setiul +setiur +setiyl +setiyr +setj +setk setkey +setkeys +setki setkind +setku setl +setlatt setlaverage setlet +setlevel setlevelnames setli setlib setlik setlike setlikespec +setlim setlintegral +setlist +setlistissetbutlastandlast +setlr +setlsinstructionsyndrome setm +setmajorant +setmapsto setmarkinv setmax setmaxperm setmctx +setmem +setminorant setminus -setminusel -setminuselneg -setminuser -setminuserneg -setminusi -setminusilneg -setminusirneg -setminuslsub -setminussubset -setminust setmn +setmonotone +setmor setmul setn setname setnat setncard +setneg +setnewtrigger setngen +setnk +setnonsingleton setnormalizer setnotation setnth +setnzcv seto +setobj setof setofd setoffloorneg @@ -71649,50 +119081,103 @@ setoffractne setofideal setofmaximalisosetofminimal setofminimalisosetofmaximal +setofpairs +setofpairsequality +<<<<<<< Updated upstream +======= setofpairsisbreln +>>>>>>> Stashed changes +setofpairsofpositiveorderedtype setofpatternmatchunexpander +setofseqof +setofsets +setofsimplegraphs setoftop -setoftrueeq setoid +setoidlist +setoidmorphism +setoidobject setoidofdisjointunion setoidprestructure +setoids +setoidsmodels setok +setop +setopfunc +setops setoption setoptionlinter +setorder setp +setpair +setpaireq +setpath setpc +setpcl +setpcr +setperm setpermblock +setpermblockfunc setpi +setpick +setplr +setpm +setpn +setpost +setprecategory setpredictionresistance setpreimafvex setpreimage +setprev +setprimenumber +setprimes +setprl setprod setprodequivsigma +setprojco setprotected +setps +setq +setquotbinop +setquotsymmbinop +setquotunaryop +setquotuniversal +setquotuniversaliso setr setrange +setrank setrec setrecs setrecseq setrecsres setrecsss setreducibilitystatus +setref +setreg +setregister setrel setrelid setrelisseparated +setres setreseedinterval +setring +setringd +setringu setrip -setrp sets setsabs +setsabsd setsat setscom +setscomd setsd setsdm setsemiring setseq setseqaux +setsequence setsetoid +setsex setsexstruct setsfun setsi @@ -71700,112 +119185,372 @@ setsid setsidel setsidvald setsiedg +setsigmaiso setsimp setsimptheorems setsms setsmsbas +setsmsbasg setsmsds +setsmsdsg setsmstopn setsmstset +setsmstsetg setsn +setsnd setsnid setsnidel +setsp +setspan +setspand +setspani setspec setsplusg setsres +setsresg +setsslid +setsslnid +setsst setsstrset setsstruct +setst +setstack setstring +setsu +setsubgroup setsubsetrefl setsubsettrans setsubtypecomm setsum setsv setsval +setsvala setsvalg setsvtx +setswith +setswithex +setsx setsxms setsymm setsyntax +setsystem sett settag +settd +setter settextpost +settfor +settheflags settheory +setti +settin setting settings settitlepost +settl settle settled +<<<<<<< Updated upstream settlement +======= +>>>>>>> Stashed changes +settles settofun settol +settoorderedsequence +settoseq settoset settosimplefunc +settpn +settr +settraitfield settrie +settrunc +settruncidempotent +settruncidempotentiso +settrunciso +settruncofprodiso +settrunctrunc +settruncuniversal +settsub +settt +settu +settx +settyc settype +setu +setua +setuac +setuaca +setuc +setuca +setuck +setucl +setucr +setudk +setudl +setudr +setue +setuid +setuidk +setuidl +setuidpl +setuidpr +setuidr +setuil +setuir +setuitv +setuk +setukc +setukd +<<<<<<< Updated upstream +setul +setull +setulr +setunionassoc +======= setukpairil setukpairinjl setukpairinjr setukpairir +setul +setull +setulr setunion setunionassoc setunionax +setunioncard +>>>>>>> Stashed changes setunioncomm -setunione setunionempty -setunioni -setunionordinallem -setunionsingleton -setuniontransitive setuniv setup +setupauthpskr +setupauthpsks +setupauthr +setupauths +setupbaser +setupbases +setupesdkclient +setupfailingkeyring setuplctx +setuppskr +setuppsks +setuprawaeskeyring +setupstatickeyring +setuptestkeyring +setur +seturl +seturr +setus setusername +setuss +setut +setuul +setuur +setuv +setv +setval +setvaluation setvalue setvar setvariation +setvect +setvsetc +setvslist +setvu +setw +setwildcategory +setwise +setwiseo +setwithcompoundterm +setwop +setwrapper +setx +setxi +setxk +setxl +setxp +setxr +setxs +setxt +setxtt +sety +setya +setyc +setyct +setyd +setye +setyi +setyk +setytc +setyu +setzffun +<<<<<<< Updated upstream +======= seu +>>>>>>> Stashed changes +seubset seulement sev seval +seve seven +seventeenisnoteven +seventh +seventuallyeq seventy several +severe +severely severity +sewgf sex +sexec sexg +sexists +sexit +sexn sexp +sexparith +sexpcode +sexpdec +sexpdigit +sexpexp +sexpfun +sexpfuns +sexpid +sexplist +sexplit +sexplocn +sexplocpt +sexplog +sexpnt +sexpnum +sexpop +sexpopt +sexppair +sexppat +sexppatexp +sexppeg +sexppes +sexpprim +sexpprint +sexpr +sexpression +sexprp +sexprs +sexps +sexpseq +sexpspec +sexpstr +sexpsym +sexptest +sexptoset +sexptype +sexstr +sext +sextend +<<<<<<< Updated upstream +======= sexualreproduction +>>>>>>> Stashed changes +sfa +sfaig +sfaiglist +sfalse +sfam +sfamcontr +sfamgen +sfamgentopelement +sfamtopelement +sfb +sfbs +sfc sfd +sfe sfg sfi +sfieldlist sfields sfilter sfin sfind +sfindbl +sfineq sfinite sfiniteseq +sfinltfin +sfintfin +sfintfinlem sfirst sfis sfix +sfker +sfkernel +sfl +sflag +sfm +sfmastr sfn +sfnearbyint +sfo sfoldl +sfoldr sfor +sformal sfp sfprmdvdsmersenne +sfracw +sfram +sframe +sfrc +sfrm sfs +sfsetrel +sfsm +sfsmf sfsstate sft sfun +sfunb +sfuncs sfunction +sfunctions +sfund +sfune +sfuneqp +sfunm +sfunn +sfunpow +sfunx sfv sfw sfwsomed sfx +sfxx +sfy +sfz sga +sgamma sgas +sgbcross +sgbinter +sgc +sgclique +sgd +sgdpr sge +sgen +sgetprop +sgf +sgfcdzo +sgfs +sgin +sgissmallest +sgissub sgl +sglobals sgm sgmcl sgmf @@ -71814,9 +119559,13 @@ sgmnncl sgmppw sgmprm sgmval +sgmx sgn sgncl sgnclre +sgnd +sgndintval +sgnf sgnmnf sgnmul sgnmulrp @@ -71825,6 +119574,7 @@ sgnmulsgp sgnn sgnnbi sgnneg +sgnnot sgnp sgnpbi sgnpnf @@ -71835,70 +119585,164 @@ sgnsgn sgnsub sgnsv sgnsval +sgnt sgnval sgnx +sgny sgnz sgoldbeven sgon +sgop sgoto +sgp +sgpe sgprmdvdsmersenne sgr +sgraph +sgrez sgrim sgrimval +sgrm +sgrmn +sgrmz +sgrn sgroup sgrp sgrpalt sgrpass sgrpcl sgrpidmnd +sgrpidmndm sgrpmgm sgrpnmndex sgrpplusgaopalt sgrppropd sgrpssmgm +sgrv +sgrx +sgrz +sgs sgsiga sgsummulcl sgt +sgtrnaf +sguard sgval +sgvalk +sgvalm +sgvalmk +sgx +sgy sgz sgze +sgzm sgzn +sgzp +sgzx sha +shack shaddcl shadow shadowed +shadowedp +shadowers +shadowing +shadowrootclass +shadowrow shadows +shaext +shah +shaiv shake shakey shalf shall shallow shallower +shallowly +shalt +shalted +shameful +shamt +shamtz +shandler +shankar +shanks +shannon +shap +shapadded +shapadding shape +<<<<<<< Updated upstream +======= shapeattribute +>>>>>>> Stashed changes +shapecombnt shaped +shapeerr +shapehelper shapei +shapelist +shapent shapes shapley +shar share +shareable +sharealike +shareat shared +sharedguard +sharedload +sharedloadbytent +sharedloadnt +sharedmem sharedmemory +sharedp +sharedprivate +sharedsrc +sharedstore +sharedstorebytent +sharedstorent +sharedtgt +sharedunknown +shareinst +sharemap +sharemem +sharer shares +sharetree +sharetreeeq +sharetreeord sharhght sharing sharingf sharingi sharingr sharings +sharingt +shark sharp +sharper +shasplitandpad shatomici shatomistici +shatter shattered shatterer shatters +<<<<<<< Updated upstream +======= +shaved +>>>>>>> Stashed changes +shb shbaseclass shc +shconf +shcout shd +shdr +shead sheaf sheafadjunctioncocontinuous sheafadjunctioncontinuous @@ -71984,28 +119828,44 @@ sheafyonedahom sheap shear sheardivright +sheargroup shearing shearmulright shearsort sheaves +shebang +sheduler +sheet +sheets +sheffer +shefferlattstr +shefferortholattstr +shefferstr shel shelah shelf shelfhom +shelfid sheli shelii shell +shelley shelllemmas shelves shenanigans shex +shf +shfadd +shfp shft shftcan shftdm shftf shftfib +shftfibg shftfn shftfval +shftfvalg shfti shftidt shftlem @@ -72013,19 +119873,28 @@ shftmbl shftuz shftval shftvalg +shg shi +shidama +shields shif shift +shiftable shiftadd shiftaddhom +shiftar +shiftb shiftclosure shiftcomm +shiftcons shifted shiftedgenweightspace shiftedhom shiftedlegendre shiftequiv +shifter shifteval +shiftf shiftfun shiftfunc shiftfuncto @@ -72037,40 +119906,75 @@ shiftfunctoriso shiftfunctorobjxiso shiftfunctoropiso shiftfunctorzero +shifti +shiftimmediate +shiftin shifting shiftintro shiftiso +shiftk shiftl shiftleft +shiftlefta +shiftleftb +shiftleftc shiftleftfill +shiftlift shiftlinearmap +shiftll shiftlocalizermorphism +shiftlowerbound +shiftlr shiftmap shiftmkcore shiftmonoidal shiftmonoidalfunctor +shiftn shiftnegshift +shiftop +shiftopsnt shiftout shiftpah shiftpath +shiftpos shiftr +shiftreg +shiftregister shiftright shiftrightfill +shiftror +shiftrows shifts +shiftseq shiftsequence +shiftsequenceiso shiftshiftneg shiftshortcomplexfunctor shiftshortcomplexfunctoriso shiftstable shiftstableeq +shiftt +shifttonum shifttrianglehiso shifttriangleiso +shifttype +shiftup +shiftupperbound +shiftval +shiftvar +shiftxor +shifty shiftzero +shilpi +shim shincl shincli shintcl shintcli ship +shipsails +shistorically +shit shjcl shjcli shjcom @@ -72079,21 +119983,35 @@ shjshcli shjshseli shjshsi shjval +shk shl +shladd +shld shle shleg shlej shlesb shless shlessi +shlimm +shll +shllimm shlub shlubi +shlx +shm shmd +shmem +shmemload +shmemop +shmemstore shmodi shmodsi shmulcl shn shne +shnfp +shnfs sho shoccl shocel @@ -72101,14 +120019,25 @@ shococss shocorth shocsh shocss +shogybs +shold shom +shoms shomsgvectors shonextconfig +shoot +<<<<<<< Updated upstream +======= shooting +>>>>>>> Stashed changes shop +shor +shore short shortaddlong shortaddlongroot +shortalias +shortcircuit shortco shortcomp shortcompl @@ -72127,15 +120056,19 @@ shortcomplexopcyclesthree shortcomplextruncle shortcomplextrunclex shortcut +shortcuts shortcutting +shorte shorten shortened shortening +shortenp shortens shorter shorterd shortere shorteri +shorterp shortest shortestpath shortestprefixdiff @@ -72144,66 +120077,115 @@ shorth shorthand shorthands shortlex +shortly +shortmap shortname +shortp +shortproof shortroot shortv shorun shos shot +shou should +shouldcancelout +shoulddecryptedk shouldn +shouldnotwork shouldtranslateunsafe +shouldwork show showatprecision showbit showbits +showbool showcmdspec +showcollectstatistics showdefinition showdigit +showdups showed +showex +showexists showfoo +showhelp showhexa showinbase showing +showint showints +showl showlinter +showlist showliteral +showm shown shownames +shownat shownats +showo +showopt +showpair showquantity showrats showrel showrelevance +showresult shows +showscheme showsimple showsp +showstring showsx +showterm showtests showtiming showtrailing +showtree +showtype +showuint +showunit showvisibility showx +showz +shp +shq shr shrb +shrd +shrimm shrin shrink +shrinkbool shrinkcompuliftfunctoriso shrinkdisjoint +shrinked shrinkequiv +shrinker shrinkfoo shrinkfunctor shrinkfunctorhomequiv shrinkfunctorisofunctor shrinkfunctormap shrinkfunctoruliftfunctoriso +shrinkfunnil shrinkhoms shrinkhomsequiv shrinking shrinkinglemma +shrinklist +shrinklistaux +shrinkm shrinkmap +shrinkn +shrinknat +shrinknataux +shrinkoption +shrinkpair shrinkperm shrinks +shrinktree shrinkyone shrinkyoneda shrinkyonedacompevaluationcompuliftfunctorisouliftfunctor @@ -72221,10 +120203,22 @@ shrinkyonedaobjobjequ shrinkyonedaobjobjequiv shrinkyonedarepresentableby shrinkyonedauliftfunctoriso +shrinkz +shrinkzaux shrk +shrl +shrlimm +shrlu +shrluimm +shrtree shru shrug +shruimm shrunk +shrx +shrximm +shrxl +shrxlimm shs shscl shscli @@ -72249,17 +120243,30 @@ shsvai shsval shsvs shsvsi +sht shub +shud shuffle +shufflecurried +shuffleelseclause +shufflef +shuffleinvariancepredicatepointwise shufflelr +shuffler shuffling +shufrows +shulman +shulmans shuni shunssi shunssji +shunt shunting shupd +shut shutdown shutdownhook +shv sia sib sibf @@ -72270,15 +120277,28 @@ sibfmbl sibfof sibfrn sibling +siblings +sibs +sic sid side +sidecase +sidecond sided +sideeffect +sideeffecting sideexpr sidegoaldischarger -sident sides +sids +<<<<<<< Updated upstream +======= sidual +>>>>>>> Stashed changes sidx +sie +siec +siemens sierpinski sierpinskispace sieve @@ -72287,14 +120307,22 @@ sieveextend sieveofsection sieveofsubfunctor sieveofuliftsubfunctor +sievert sieves sievestruct +siex +siexg +siexistse +sif sift siftdown sifted siftedsum +sifthenelse +siftup sifum sig +siga sigaclci sigaclcu sigaclcuni @@ -72312,6 +120340,7 @@ sigalgebra sigapildsys sigapildsyslem sigapisys +sigaprime sigarac sigaradd sigaraf @@ -72330,13 +120359,39 @@ sigarperm sigarval sigasspw sigaval +sigb +sigbprime sigcod sigdom +sigelt +sigeltopts +sigelts +sigequivrel sigf +sigfaxtau +sigfoaxtau +sigh +sighomomorphism sight sigid siginificant +sigisomorphic +sigits +sigkey +sigkeypair +sigki +sigl +sigle +siglfun +siglfunp +siglk +siglp +siglr +siglrfun +sigm sigma +sigmaalgebra +sigmaalgebras sigmaall sigmaantidiagonalequivprod sigmaantidiagonaltupleequivtuple @@ -72360,12 +120415,14 @@ sigmacurryequiv sigmacurrylequiv sigmad sigmadesc +sigmaelim sigmaequiv sigmaequivoptionofinhabited sigmaequivprod sigmaequivprodofequiv sigmaequivsigmapi sigmafiberequiv +sigmafield sigmafin sigmafinite sigmafinitefiltration @@ -72395,24 +120452,36 @@ sigmalcurry sigmalcurryequiv sigmalex sigmalift +sigmalower sigmaluncurry sigmamap sigmamk +sigmamset sigmanatsucc sigmaobj sigmaobjiso sigmaofiscolimit +sigmaoftruemean +<<<<<<< Updated upstream +======= sigmaold +>>>>>>> Stashed changes sigmaopencover sigmaopens sigmaoptionequivofsome sigmaorthonormalbasisindexequiv +sigmap sigmapi sigmapliftequivsubtype sigmapreimageequiv sigmaproddistrib +sigmaprodelim sigmapunit sigmaquotientequivofle +sigmar +sigmaringtype +sigmas +sigmasection sigmaset sigmasigmaiso sigmasigmasubtype @@ -72424,33 +120493,81 @@ sigmasubtypeequivofsubset sigmasubtypefiberequiv sigmasubtypefiberequivsubtype sigmasumdistrib +sigmat +sigmatable sigmatoiunion sigmatopi sigmauliftpliftequivsubtype sigmauncurry sigmaunique +sigmaupper sigmoid sigmoidal sign +signa signabs signal +signala +signaladdressexception +signaling +signalling +signalp +signals +signam +signame +signat +signaturate signature +signaturebysequence +signaturekeypair +signaturelength signatures +signaturet +signaturevalue signaux +signb signbijaux signdet +signe signed +signedbyte signedd signeddist +signede +signedhalfword signedinfdist signedmeasure +signedness +signedp +signedpair +signedshiftright signeg +signensurespublicly +signeq +signext +signextend signhom +signif +significan +significand significant significantly significative +signify +signing +signlarger signlem +signm +signmagnitude +signnorm signof +signok +signp +signr +signre +signrmk +signrn +signrzk signs signset signshf @@ -72490,30 +120607,90 @@ signswn signswplusg signswrid signtype +signum signvariations +signx +signzero +sigof +sigorder +sigorderin +sigordering sigpos +sigr +sigrk sigs +sigshft +sigsig +sigspec +sigstep +sigsub sigt +sigtable +sigtk +sigtok sigtyid +siguiente +sigun +sigw +sigx +sigy +sigz sih +siheap sii siii siilem +sikeq +sikeqd +sikeqi +sikex +sikexg +sikexlem +sikss +sikssvvk +sil silence silent +silentffi silently +silghtly +silhouette +sillier +silliness +sillllly silly sillyfun +sils silver silverman +sily sim simabs simaction +simaltaneous +simapply +simb +simcl +simd +simdefs +simdiag +simdiagstep +simem simeq +simext +simf +simi +simila similar +similard +similari +similarinequalities similarity similarly +similiar siminit +siminj +simllar simm simmc simmct @@ -72529,7 +120706,9 @@ simpattrs simpb simpc simpcntrab +simpcode simpcomm +simpconfig simpcontfract simpdecl simpeq @@ -72546,6 +120725,7 @@ simpgntrivd simpgoal simpgrp simpintrocore +simpivotreduced simpkind simpl simplbda @@ -72553,27 +120733,55 @@ simplbi simplbiim simpld simple +simpleassert +simpleassume +simplebadjumps +simplecontinuedfraction simpledef simpledefs +simpleelem simplef +simpleflatten simplefunc simplefuncaux simplefuncdenselp simplefuncintegral simplegraph simplegraphofstructure +simplegraphs +simplegraphstruct simplei +simpleib +simpleinduction +simpleio +simplelevi +simplelist simplelog simplemma +simplenet +simplenew +simplep +simplepartition simplepath simpler +simplereality +simplereg +simplereglist simplering simplerpartition +simplerule simples simplescopedenvextension +simplesmallstepsemantics +simplesss +simplest simplesubobject simplesubobjectarrow +simpletest +simpletruthforgettablename +simpletype simpleuse +simplevar simplex simplexalgorithm simplexalgorithmdense @@ -72583,6 +120791,7 @@ simplexalgorithmsparse simplexcateg simplexcategory simplexcategorygenrel +simplfied simplhs simpli simplice @@ -72590,6 +120799,7 @@ simplices simplicial simplicialcategory simplicialcomplex +simplicialcomplexstr simplicialcosimplicialaugmentedequiv simplicialcosimplicialequiv simplicialeval @@ -72598,26 +120808,50 @@ simpliciali simplicialinsert simplicialnerve simplicialobject +simplicialset simplicialthickening simplicialtocosimplicialaugmented simplicity +simplif +simplifed +simplifi +simplific +simplifica +simplificat +simplificati +simplificatio simplification simplificationp simplifications simplified simplifier +simplifiers simplifies simplify +simplifybwda +simplifybwdp +simplifyexpr +simplifyfractions +simplifyfractionsmultiplication +simplifyfwd simplifying +simplifystmt simplifytarget +simplifyvalid +simplifywasm simplim +simplimdc +simplize +simplized simpll simplld simplll simpllr simplocation +simplpred simplr simplrd +simplring simplrl simplrr simply @@ -72626,6 +120860,7 @@ simplyprofiled simpm simpnames simpnf +simpobs simponly simponlybuiltins simponlynames @@ -72636,6 +120871,7 @@ simprd simprhs simpri simprim +simprimdc simprimi simprl simprld @@ -72649,12 +120885,15 @@ simprrd simprrl simprrr simps +simpseq simpsides +simpson simpsrule simpstac simpstacfromsyntax simpstar simpsunusedcustomdeclarations +simpt simptarget simptargetcore simpterm @@ -72662,22 +120901,41 @@ simptheorems simptheoremsofnames simpthms simptype +simsmith simson +simt simtrans +simu simul +simular simulate +simulated +simulates simulation +simulations +simulator +simulatorcorrectness +simulatormap +simulatormapinverse +simulators simulink +simult +simultane simultaneous simultaneously +simuprod simval +simvar sin sinacos sinadd sinaover sinasin +sinb sinbnd +sinbpihalf sinc +sinca sinccvg sinccvglem since @@ -72685,14 +120943,21 @@ sincerely sincl sincld sincn +sincompleteness sincos sincosq sincossq +sincr +sincreasing sind +sindpi +sindpihalf sinds +sindustries sine sineq sineqs +sines sineterm sinf sinfclosed @@ -72700,26 +120965,41 @@ sinfgen sinfhom sinfhomclass sing +singa +singb +singc +singd +singdoubleeq singe singelton +singeq singl single singleaddhom singleaddmonoidhom +singlealg singlealghom singleandzipwith +singleclique singlecombinators +singlecombinatorsappend singlecombinatorsconc +singlecombinatorsstart singlecompeval singlecompevalisoself +singleconst singlecontinuousaddmonoidhom singlecontinuouslinearmap +singled singledestn singledistribmulactionhom singledsource singledsourceempty singledsourceloop singleequalizercondition +singlefield +singleflow +singlefraenkel singlefunctor singlefunctorcomphomologyfunctoriso singlefunctorisocompq @@ -72730,8 +121010,13 @@ singlefunctorspostcompqiso singlefunctorspostcompquotientiso singlehom singlei +singleiff +singlel singlelinearmap +singlelinefunction singlemaphomologicalcomplex +singlemsa +singlemss singleobj singleobjapplyiso singleobjapplyisoofeq @@ -72740,44 +121025,74 @@ singleobjhomologyselfiso singleobjopcyclesselfiso singleobjxisoofeq singleobjxself +singleofdouble +singleoffloat +singleofint +singleofintu +singleoflong +singleoflongu singleonealghom singleoneringhom +singlep +singleparam singlepass singleprocess singleprod +singler singleruletac +singles +singlestons +singlesub singlesubsingle +singlesymp singlet singletape singleto +singletok singleton singletonchartedspace singletond singletonequiv singletonfinsubgraph singletoni +<<<<<<< Updated upstream +======= singletoninpowerset singletoninpowunion +>>>>>>> Stashed changes +singletonlist singletonmonoidhom singletonmulhom singletononehom -singletonp -singletonprop singletons +singletonseq +<<<<<<< Updated upstream +======= singletonsswitch +>>>>>>> Stashed changes singletonsubgra singletonsubgraph -singletonsubset -singletonsuniq singletont +singletonthm +singletontype +singletontypesaresingletons singletr singletriangle singletriangleiso singleunexpander +singlevalued +singlevertex +singlevertices singlezeroalghom +singlification singling +singlp singlpart +singlrel singlton +singly +singnotempty +singp sings singstr singular @@ -72787,8 +121102,10 @@ singularhomologyfunctor singularhomologyfunctorzerooftotallydisconnectedspace singularity singularmanifold +singularp singularpar singularpart +singulars sinh sinhalfpi sinhalfpilem @@ -72803,15 +121120,18 @@ sinhval sini sinit sinitcg +sinjective sink sinkernel sinkpi sinks sinl sinltx +sinltxirr sinmpi sinmul sinmulcos +sinn sinneg sinnpoly sinord @@ -72826,21 +121146,40 @@ sinpoly sinppi sinq sinr +sins +sinst sinsub sint +sintegral +sintegrald +sintegrale +sintegralennsfun +sintegralet +sintegralrm sinter +sinteract +sintp sintro sints +sintv +sinus sinv sinval sinvar +sinvariant +sinx sinzeta sio sip +sipo +sipser +sis sisj siso +sister sit site +siter siterate sites sitg @@ -72852,6 +121191,7 @@ sitgclre sitgf sitgfval sitgval +sitio sitj sitjsi sitm @@ -72860,52 +121200,122 @@ sitmf sitmfval sitmval sits +situ situation situations +siv +siveric six +sixa +sixb sixe +sixt sixteen sixteenbyte +sixteenwordrep +sixteenwordrepi +sixteenwr +sixterm sixth +sixtyfour siz +sizable size sizea +sizeantimonotonicnone +sizearray +sizearrayisassociative +sizebins +sizebound +sizec sized sizedcorrect sizedmonotonic +sizedmonotonicopt +sizedp sizedproofeqs sizedset +sizedsizemonotonic +sizedsizemonotonicopt +sizedsuchthatcorrect sizee +sizef +sizeh +sizehe +sizek sizel +sizelemmas +sizeleq +sizelt +sizem +sizeminus sizemonotonic +sizemonotonicchecker +sizemonotonicopt +sizemonotonicoptofbounded +sizemonotonicoptofsizemonotonic sizemonotonicsuchthatopt sizemonotonictyp +sizeo +sizeobject +sizeobjectisassociative sizeof sizeofobjectpos +sizep +sizeplusone +sizer sizes +sizesa +sizesb sizeslib +sizest sizestx +sizesx +sizet +sizetp sizeupto +sizev +sizew sizewithoutsharing +sizey +sizeye +sizez +<<<<<<< Updated upstream +sizing +======= +>>>>>>> Stashed changes sizusglecusg sizusglecusglem +sji sjo +sjoins sjsi sjsktwshgupcwhfxtxoasfaiajrrbegtcvtfmhmofx sjti sjx +ska skadj +<<<<<<< Updated upstream +======= +skc +>>>>>>> Stashed changes +ske skein skel skele +skelet skeletal skeletalequivalence skeletalfunctor +skeleto skeleton skeletonequiv skeletonequivalence skeletonlt skeletonofmono +skeletonp +skeletonseq +skels sketch sketched skew @@ -72921,38 +121331,85 @@ skewadjointmatricessubmodule skewadjointpart skewadjointpartl skewadjointsubmodule +skewbinomialheap +skewbinomialheapstruc skewed +skewlink skewmonoidalge skewmonoidalgebra skewpolynomial skewprod skewswap +skewsym +skey +skeys +skeyst +skf +skg +ski skind +skinnyfinitetree +skinnytree skip +skipblock +skipbyte +skipc +skipcall skipconstinapp +skipd skipdef +skipe +skiphead +skipif +skipk +skipleadingplus skipleft +skiplist skipmonotone skipn skipnot skipp skipped +skippedd skippedfilesegments +skipper skipping skipprivate skiprealize skiprule skips +skipseq +skipst skipstring skipt +skipwhile +skipwhilelexer +skkk +skl +sklem +skmp +sknew +sknlift +sko +skol skolem +skolemizable +skolemization skolemize +skolemized skolems skomod skopre +<<<<<<< Updated upstream +======= skos +>>>>>>> Stashed changes +skosimp +skov skp +skr sks +sktree skyscraper skyscraperp skyscraperpresheaf @@ -72973,50 +121430,98 @@ skyscrapersheafforgetadjunction skyscrapersheaffunctor skyscrapersheaffunctorcompsheafpushforwardcontinuous skyusxutkawjvzjkj +skzl sla +slabel +slack slaction +slaney slash slashaction +slashes slashinvariantform slashinvariantformclass slashinvariantforms slashj +slau +slave +slaves slayer -slb -slbdtrb -slbdtsldtrb slc +<<<<<<< Updated upstream +======= slcrc +>>>>>>> Stashed changes +slcst sle sledgehammer +sleep sleepatleastheartbeats +slem slemma slen slength +slengthe slesolex slesolinv slesolinvbi slesolvec +sless +slew +slex +slexer slg sli +slic slice +sliceable +slicecat +slicee slicef +slicefunctor +slicehom +sliceiselementsofrep +sliceiso sliceleft +slicelt +sliceob +sliceofsequences +sliceofsequencesgeneral +sliceofsequencesvariation slicer sliceright slices +slicesize slicesizes +slicev +slicew +slicing slick +slidable slide +sliding +slidt +slift slight slightly +<<<<<<< Updated upstream +======= slime +>>>>>>> Stashed changes +slincop +slinear slinkedlist +slinky +slipped slist +slistmem slit slitplane +slitv sll sllambda +slli +slln slmd slmdacl slmdass @@ -73035,19 +121540,32 @@ slmdvsdi slmdvsdir slmod slmodularaction +sln slnil slo +sload +sloc +slocs +slokp +slong slonglpos slookup +sloop slop slope slopefinite slopei slopes +sloppy slot +slotable sloteq +slotex slotfn +slotname +slotnum slotresfo +slots slotsbhcdif slotsdifdsndx slotsdifipndx @@ -73056,22 +121574,34 @@ slotsdifplendx slotsdifunifndx slotsdnscsi slotsinbpsd +slotslfn slotslnbpsd slotstnscsi slotted slow +slowdown +slowed slower +slowing +slowish slowly slows slp slpa +slplit slrmznougxlapealbvspkopuyzehglvurtf sls slsd +<<<<<<< Updated upstream +======= slsdtgt +>>>>>>> Stashed changes +slse slsided slstar slt +slti +sltiu sltmuls sltp sltsbday @@ -73088,6 +121618,11 @@ sltssnb sltsss sltstr sltsun +sltu +slu +sluggish +slurp +slvsplt slwhash slwispgp slwn @@ -73102,9 +121637,12 @@ smadiadetg smadiadetglem smadiadetlem smadiadetr +smake smal small smallball +smallbv +smallcat smallcategories smallcategory smallcategorycardinallt @@ -73115,11 +121653,23 @@ smallcategorysmallmodel smallcofilteredintermediate smallcomplement smallcoproductdesc +smalle +smallencryptioncontext +smallencryptioncontextkeys smallequiv smaller smallerd smalleri +smallerplusl +smallerplusr +smalles smallest +smallestexists +smallestmissing +smallestmissingnumber +smallestpartition +smallestvalnovotercvd +smallestvalrcvd smalletalepretopology smalletaletopology smallfilteredintermediate @@ -73127,30 +121677,80 @@ smallgrothendiecktopology smallgrothendiecktopologyofle smallhom smallhommap +smalli +smallish +smallissmall +smallissorted +smalllist +smalllsr +smallmismatchedencryptioncontex smallmodel +smallneg +smallness +smallnum +smallnums smallo smallobject +smallobjecttostringstringmap smallomega smalloption +smallp +smallpatchconstru +smallpi smallpretopology +smallprime +smallrange +smalls smallschroder smallsets smallsheafificationadjunction smallsheafify smallshiftedhom smallshiftedhommap +smallsiz +smallsize +smallspecializedcategory smallstep smallstepi +smallstepp smallsteps +smallstepsemantics smallstepsi +smallstepsp +smallstepstar +smallstepsv +smallstepv +smallt +smalltree +smalltrees +smalltype smap +smapo +smaps smart +smartappend +smartcons smarter smarthcongr +smartif +smartlet +smartmat +smartop +smartp +smartpivot +smartseq smash +smashadjiso +smashassocequiv +smashassociso +smashed +smashes +smashpt +smashptproj smat smatbl smatbr +smatch smatcher smatcl smatfval @@ -73159,14 +121759,23 @@ smatrcl smattl smattr smatvscl +smax +smb +smbinter smblfn smc smci smcn smcnlem smcorr +smd smeas +smelt +smem smemnhds +smep +smerge +smethods smeval smf smfadd @@ -73238,10 +121847,18 @@ smgrpismgmold smgrpmgm smgrpssmgm smgrpssmgmel +smi +smid smile smin +sminj +sminjsep +sminus +smirnov smith smithcoeffs +smithempty +smithmat smithnormal smithnormalform smithnormalformbotbasis @@ -73249,21 +121866,34 @@ smithnormalformcoeffs smithnormalformofle smithnormalformofrankeq smithnormalformtopbasis +smithstep smj smk +sml +smlal +smm +smmap +smme +smml smn smndex smndlsmidm +<<<<<<< Updated upstream +======= smndt +>>>>>>> Stashed changes +smnew smo smobeth smocdmdom smod +smodel smodeq smodm smodnat smodnattr smods +smoebius smoel smoeq smofvon @@ -73271,7 +121901,12 @@ smogt smoiso smoiun smoke +smokes +smoketesthavoc +smoketesttransitiveinv +smono smonoord +smonotone smoord smooth smoothbumpcovering @@ -73303,14 +121938,29 @@ smoothsheafgroup smoothsheafring smoothtransition smores +smoves smoword +smp smpf +smpl +smpla smprngopr +smrecur +sms +smset +smsetp smsi smt +smtcp +smtencoding smth +smtlib +smtlink smtoms +smtopt smtpat +smtpator +smtpats smu smucl smueq @@ -73336,6 +121986,7 @@ smuldistribclass smuldivisionring smuldivisionsemiring smulextp +smulf smulfamily smulfderiv smulfinset @@ -73344,6 +121995,7 @@ smulhaarmeasure smulhomclass smulinvariant smulinvariantmeasure +smull smulleft smulleftclm smullinear @@ -73370,6 +122022,7 @@ smulright smulrightclm smulrightdual smulrightl +smulrpred smulset smulshortcomplex smult @@ -73389,18 +122042,36 @@ smupval smupvallem smuval smv +smval +smvalid +smvalmu +smvalnu +smwdnu +smx +smycl +snaddl +snaddr +<<<<<<< Updated upstream +======= snail +snails +>>>>>>> Stashed changes snake snakeinput snakelemma snalt +snam sname +snan +snanp snap snaps snapshot snapshoti +snapshotlist snapshots snapshotted +snat snatpsubn snaw snb @@ -73412,26 +122083,37 @@ snct snd sndcart sndclm +snde +sndeq sndequiv sndfunctor sndhom +sndi sndisj sndisomorphismthm sndkernelfork sndl +sndlemma sndpimap sndpimapofislimit +sndpp +sndprop snds sndsigmamap sndsigmamapofiscolimit sndsize +sndtype sndx +sndy sne sneak sneakily +sneaking +sneaky snec snecg sneg +snel snelmap snelpw snelpwg @@ -73441,17 +122123,23 @@ snelsingles snemp snen sneq +sneqb sneqbg sneqd sneqi sneqr sneqrg +snew snex snexalt snexg +snexprc +snext +snexxph snf snfbas snfi +snfig snfil snfromadj sng @@ -73469,6 +122157,7 @@ sngltagi sngr snhesn sni +snibble snid snidb snidg @@ -73476,6 +122165,8 @@ sniffsupp snifpsrbag snil sniota +snip +snippet snjust snlbtdsvscxtbrfy snlem @@ -73483,7 +122174,9 @@ snlindsntor snlindsntorlem snm snmapen +snmb snmbl +snmg snmgmhm snmhm snmlff @@ -73500,44 +122193,74 @@ snnex snnz snnzb snnzg -sno snoc snoccases +snoccast snocd snocequiv snoci snocinduction snocl +snoclist +<<<<<<< Updated upstream +snoclistappend +snoclistmap +snoclistreverse +snocm +snocnil +======= +snocm +>>>>>>> Stashed changes snocorderiso +snocs snocview +snode +<<<<<<< Updated upstream +======= snoeq snolev snolt +>>>>>>> Stashed changes +snon +snone snopeqop snopeqopsnid snopfsupp snopiswrd snopsuppss snor +snorkel +snorkeler +snorkeling snorm snormlesnormfderivofeqconst +snotz +snotzp snowflaking snp snpmulticore snprc +snprss +snpt snres snriota +snrname +sns +snsaddl +snsaddr snsetex snsn snss snssb snssd snssg +snssgold snssi snssialt snssialtvd snssl snsslvd +snssold snsspr snsspw snsssn @@ -73549,30 +122272,79 @@ snsymgefmndeq snth snu snuffle +snuffleres +snuffleround +snuffles snull snum snumcoe snunico snunioc snunioo +snv +snva +snvc +snvl snvonmbl +snvpb +snvu snwf +snyp soa soaienpnekgeojttampqmtdjahkpfsvb +soand soasym +sob sober sobolev +sobra +sobre +soc +<<<<<<< Updated upstream +======= socialinteraction socialrole +>>>>>>> Stashed changes +sock +sockaddr +sockaddrptr +sockdes +socket +socketaddress +socketdescriptor +socketerror +socketfamily +sockfd +socks +socle +soclek +soclep +socletype socnv +soconf socrates socratesmortal +socu +socufromzero +sod soeq soex +sofar +soff sofld sofleftinverse +sofromnat +soft +soften +<<<<<<< Updated upstream +softmax +======= +>>>>>>> Stashed changes softplus +softstep softsubst +software +soimm soindefiniteequiv soinxp soirri @@ -73580,6 +122352,11 @@ soisoi soisores sokoban sol +<<<<<<< Updated upstream +solar +======= +>>>>>>> Stashed changes +solc sold soldallocationisallocation soldallocationisallocationvariant @@ -73592,77 +122369,141 @@ soldallocationsfinite soldallocationvariantequivalence solely solem +solf +soli solid solidclosure solidnorm +solids solin solitaire +solitairefinal +solitaireinit +solitairetrans solo solovay +solp sols solsd solsi solspace +solt soltmin +solu +soluble +solucion solution solutionfinsupp +solutionp solutions +solutionset solutionsetcondition +solutionsi +solv solvable solvablebyrad +solvables solve +solveable solved solveeq solvei +solvelooptermination solvent +solvepolygreater +solvepolyless solver +solvers solves solvet +solving +solx som some +someany +somebad somebasis +somec somecontdiffbumpbase somed +someday somedecidable somee someexistsonedivlt +somefields somehow somei +someinv +somel +somelemma +someletvarsareghost +somemethod +somemethods +somemm somemode somenats +somenpair someoctahedron someone +somep somepath +someplus +somepointer somepos +someprop +someproperty +somer somerayvector somes something +somethingcaller +somethinghere +sometim +sometime sometimes +someting sometrace +sometype +somevar somevec somevector +somew somewhat somewhere +somex somin somincom somme somo +sompething son +sonone +sonottonotso sonr +sons sont soon soopen +soor sop +sopc sopen sopenoption +sophie +sophisticated sophomores sopo +sopp soppside sops +sopt soptisr soptiss soptist sor +sorder +sorgenfrey +sorial sorigin sornom sorpss @@ -73677,58 +122518,150 @@ sorry sorryax sorrymsgs sort +sorta +sortable +sortb +sortby sortclass +sortcmp +sortcombineproperty sortcount +sorte sorted sorteda +sortedb +sortedby +sortedbylessthanorequalto +sortedbyweight +sortedcar +sortedconcend +sortedconcstart +sortedd +sorteddmap +<<<<<<< Updated upstream +======= sortedfrom +>>>>>>> Stashed changes sortedge sortedgt sortedi +sortedinv sortedle sortedlist +sortedliststring +sortedlistword +sortedlistz sortedlt +sortedmap +sortedness +sortedp +sortedq +sortedrange +<<<<<<< Updated upstream +sortedseq +======= +>>>>>>> Stashed changes +sortedset +sortedsets +sortedsplit sortedtree sorteduniv +<<<<<<< Updated upstream +======= sorteduntil +>>>>>>> Stashed changes +sortelt +sorteltlist sortequiv sorter +sortfn +sorthyp +<<<<<<< Updated upstream +======= sorti +>>>>>>> Stashed changes sorting sortingalgorithm +sortingsameset sortlemmal sortlemmar sortlevel sortlinearorder +sortmap sortok +sortp +sortpx +sortq sorts +sortset +sortswithconstants +sortsymb +sortsymbol +sortu +sortwith sos +sosact +sosactsavings soseq sosn +sosng soss sossfld sot sota +sothm +sotoeq +sotonotsonot sotr sotrd sotri sotric +sotricim sotrieq sotrine +sotritric +sotritrieq +sou +soudness soun sound soundaux soundc +soundcall +soundcomplete +soundd +soundess +soundi +soundk +soundn soundness +soundnessfall +soundnessfcut +soundnessfex +soundnessforunsat +sounds +soundwhile +soundwhileaux +soundwhileprop soup +soupcoh +soupe sour sourc source sourceaffinelocally +sourcebit +sourceencryptioncontext sourceexistsdsource sourcehomeomorphbasesetprod +sourcei +<<<<<<< Updated upstream +======= sourceindividual +>>>>>>> Stashed changes sourceinfo +sourcelabel +sourceloc sourcelocalclosure sourcemachinesig sourcen @@ -73736,57 +122669,98 @@ sourcenode sourcenodes sourcenone sourceofdsource +sourcep +sourcepos sources sourcesabstrlevel +sourceselector sourcesemptydsources sourceslevellimit sourcesnot sourcesonlydsources +sourcesp sourcethreadpool +sourcevertexarray +sourcevertexarrayi +sourcevertexarrayp +sousa +soustraction +sout +soutcome south +souths sov +sove +sovfl +sovi +sow +sowlin soxp spa +spabt spac +spaccl space +spacebs spaced +spaceeq spacei +spacelike spacem +spacemetr spaceml spacemn spacen spacenl +spacep spacer spaces +spacid +spacind +spacing +spacis +spacssnc +spacval +spacvallem +spadder +spaddl +spaddr +spaddre spadesuit spae spaev -spain spair spalt span +spanarr spancl spancoeffs spancompiso spancone spand +spanequiv spanext spanfin spanfinbasis spanfinrank spanfinset +spanfromf spanfunctor spanfunctorisoindexfunctor spanhommk spani +spaniard spanid spanintnorm spanisomk +spanm +spanmap spannable spanned spanning spanningcoe spanningcoeequivcoeofspanning +spanninge spanningforest spanninghom spanningset @@ -73796,11 +122770,16 @@ spanningtree spannonneg spannorm spanop +spanp spanpoints spanpr +spanpushout spanrange spanrank spans +spansequiv +spansequivf +spanshape spansingleton spansn spansna @@ -73821,23 +122800,38 @@ spansnpji spansnscl spansnsh spansnss +spanspace spanss spanssoc +spanstart spansubset +spantof spanun spanuni spanunop spanunsni spanval +spanz +spar +sparallel sparc spark sparksmt +spars sparse sparsegrid sparsegride sparsegridi +sparsei +sparseint sparsematrix sparsepairs +sparsity +spartfun +spartitions +spase +spass +spath spaths spathson spatial @@ -73849,6 +122843,7 @@ spcdvw spce spcedv spcegf +spcegft spcegv spcev spcgf @@ -73858,23 +122853,36 @@ spcimdv spcimdvv spcimedv spcimegf +spcimegft spcimgf spcimgfi spcimgft +spcol spcv spd +spdadder +spdaddre spe +speach +speak speaking +speano spec +specanno +specannonoabrupt specbase speccapp speccl +specconverter specd +spece specfun speci specia special +speciala specialadjointfunctortheorem +specialcase specialcases specialfunctions specialise @@ -73886,44 +122894,71 @@ specializationpreorder specializations specialize specialized +specializel +specializer specializes specializing specializingmap speciallinear speciallineargroup +specially specialorthogonalgroup +specialp +specials specialshapes +specialsoundness specialunitarygroup specialvalues specialversions species specif +specifi specific specifically +specificati specification +specificationofcompiledfunction +specificationofcompiledmethod +specificationofcompiledmethodwithoutbody +specificationofghostfunction +specificationofghostfunctionwithoutbody +specificationofghostmethod specifications specificbilinearmaps +specifie specified +specifier +specifiers specifies specify specifying +specious +specisincreasing speciso +specker speckeys speckeyssecrets +specline speclinelist specmap specmapbasicopen specmaprestrictbasicopeniso specmodulestosheaffullyfaithful +specname specofisaff specofisaffine specofpoint specofsurjective +speconly +specp +specparam specprod +specproof specpunitisinitial specrule specs specsecrets +specserialize specsheafedspace specstalkequiv spect @@ -73938,6 +122973,7 @@ spectr spectra spectral spectralalgnorm +spectrality spectralmap spectralmulalgnorm spectralnorm @@ -73948,6 +122984,7 @@ spectralorder spectralorderedring spectralradi spectralradius +spectralscottlocaleconstruction spectralsequence spectralsequencedatacore spectralsequencefin @@ -73955,18 +122992,31 @@ spectralsequencenat spectralspace spectralvalue spectralvalueterms +spectru spectrum spectrumcompact spectrumdiagonal spectrumrestricts +spectt +specu +specul +speculatio +speculation speculative speculiftzisterminal +specultv specval +specvec +specview +specviewclose speczisterminal spedges +speech speed speeds +speedu speedup +speficy spei speimfw speimfwalt @@ -73975,34 +123025,80 @@ speivw spell spelled spelling +spells +<<<<<<< Updated upstream +spend +======= +>>>>>>> Stashed changes spent speqv sperner spesbc spesbcd spesbcdi +spf spfalw +spfalwold +spfc +spfinex +spfininduct +spfinsfincl +spfiq spfw +spglue +sph sphere +spherebouquet +spherebouquetsuspfun +spherebouquetsuspinvfun +spherebouquetsuspiso +sphereconnected +sphereconnectedspeccase +sphereelim +spherefill +spherefun +spherefuniso +spheremap +spheremapid +spheremaps +spheremapsplit spheres +spheresmashiso +spheresuspgriso +spheresuspiso +spheretopropelim +spheretotrunc spherical +sphyp spi +spice spied spiegel spies spike +spill +spillcost +spillcosts +spilled spilling +spills +spilt spim +spimd spime spimed spimedv spimefv +spimeh +spimehold spimev spimevw spimew spimfv spimfw +spimh spimt +spimth spimtv spimv spimvalt @@ -74011,7 +123107,6 @@ spimvwt spimw spin spincell -spindlecollectormt spine spineequiv spineid @@ -74019,16 +123114,37 @@ spineinjective spinetodiagonal spinetosimplex spinetosimplexaux +spinevalid +spinevalidcombine +spinevalidsplit spingroup +spinlock +spinlocks +spinloop spinner +<<<<<<< Updated upstream +======= spinning +>>>>>>> Stashed changes +spinoff +spint +spirit +spirq +spite +spk +spker spl +splat +splau splay splcl +splem +splesssurj splfv spli splice splid +splim splinterdb split splita @@ -74039,6 +123155,7 @@ splitataux splitatd splitatpki splitatpred +splitbij splitby splitbyloop splitc @@ -74050,6 +123167,10 @@ splitcenterbox splitcenterboxemb splitcomp splitconjunctions +splitd +splitdigit +splitdot +splite splitepi splitepibiprodcomparison splitepibiproductcomparison @@ -74062,22 +123183,45 @@ splitepiofidempotentofiscolimitcofork spliter splitevenodd splitexact +splitexp +splitexpand splitextension splitextensions splitf splitface splitfilename +splitfrom splitfun +splitg +splithigh spliti +splitid +splitidempotent splitif splitifscore splitindpred +spliting +splitinj splitinjectiveequiv +splitinjfun +splitis +splitk +splitl splitleaf +splitleft splitlem splitlength splitlengths +splitlimit +splitlines +splitlist +splitll +splitlong +splitlookup +splitlow splitlower +splitlr +splitmain splitmany splitmax splitmin @@ -74092,68 +123236,153 @@ splitmonoofidempotentequalizer splitmonoofidempotentofislimitfork splitmpt splitmul +splitn splitne splitnlist +splitoff spliton +splitonce splitonnotnumber splitonp +splitonto +splitp +splitpath +splitpathcompleteness +splitpl splitposition +splitpr +splitprefixminimalwellformedcodeunitsubsequence +splitr splitrequest +splitres +splitright +splitrl +splitrr splits +splitsa +splitselect +splitset splitsetbyvarsign splitsn +splitsp splitsupport +splitsurj splitsurjectiveequiv +splitsurjfun +splittab splittable +splittablex splitted +splitten +splitter +splitters splitthenconstructor +splitti +splittin splitting +splittingaxiom splittingfield splittingfieldaux splittingfieldauxaux +splittingfieldfor +splittingfieldfors +splittingfieldp +splittingfieldtype splittingoffinsuppsurjective splittingoffunonfintypesur splittingoffunonfintypesurjective splittingofinjective splittingofprojective +splittingpoly splittolist +splittree +splitu +splitup splitupper +splitv splitvector +splitwords splitwrtcomposition splitwrtcompositionaux +splitxf +splityf +splitz +splla spllen +splo +splr splus splval splysubrg splyval spm +spmap spmax +spmep spmf +spmfd +spmfi +spmi spminusf spmods +spmon spn spnfw +spnfwold +spnoh spo +spoiled +spoils +spold spoly spolyf spolynomial spolyp spolyq sponge +spontaneous +spoofing +spooky +spool +spor +sporadically +sport +sports +spos spot +spotted +spov +spow spp +sppm +sppol spr spray sprbisymrel +sprc spre spread spreads +sprec +sprect +spred +spredicates +spref sprei sprel +spresproof sprid +sprim +sprimcom +sprime spring sprmpod +sprob sprod +sproduct +sproductl +sproductr +sproofs sprop sproperty sprssspr @@ -74168,6 +123397,8 @@ sprvalpw sprvalpwle sprvalpwn sps +spsaddl +spsaddr spsbbi spsbc spsbcd @@ -74176,8 +123407,15 @@ spsbce spsbe spsbim spsd +spsel +spsr spst +spstseq spsv +spsvc +spt +spta +sptfun spth spthcycl spthd @@ -74193,11 +123431,22 @@ spthonprop spthonpthon spthsfval spthson +sptr +sptree sptruw +spts +spund +spurious +spush +spushout +spushouts +spusr spv spvv spvw +spvwold spw +spx spy sqabs sqabsadd @@ -74205,6 +123454,7 @@ sqabsaddi sqabssub sqabssubi sqaddmonoidhom +sqap sqb sqblem sqc @@ -74217,9 +123467,13 @@ sqd sqdeccom sqdefd sqdiv +sqdivap +sqdivapd +sqdivapi sqdivd sqdivi sqdivid +sqdividap sqdivzi sqdot sqe @@ -74227,6 +123481,7 @@ sqeq sqeqd sqeqor sqeqori +sqexercise sqf sqff sqfpc @@ -74238,12 +123493,18 @@ sqgeq sqgt sqi sqinter +sqintmod sqle sqlecan sqlei sqlem +sqlemafi +sqlemffi +sqleminfi +sqlemsdc sqlt sqlti +sqm sqmid sqmo sqmod @@ -74251,6 +123512,7 @@ sqmul sqmuld sqmuli sqn +sqnats sqne sqneg sqnegd @@ -74261,11 +123523,23 @@ sqnprm sqoddm sqorgt sqpartialhomeomorph +sqpweven +sqpwodd sqr +sqrbound +sqrci +sqrck +sqrcomplex sqrd +sqrdb +sqrdivbound sqrdsn +sqre +sqrecapd sqrecd sqrecii +sqred +sqredd sqreu sqreulem sqreult @@ -74287,31 +123561,58 @@ sqreuopnnlt sqreuopnnltb sqrex sqrexlem +sqrf sqrlearg sqrmo sqrn +sqrnd sqrp +sqrr +sqrrb +sqrrd +sqrreal +sqrrn +sqrs sqrt +sqrtable sqrtaux +<<<<<<< Updated upstream +======= sqrtb +>>>>>>> Stashed changes +sqrtc +sqrtck sqrtcl sqrtcld sqrtcli +sqrtcm sqrtcn sqrtcval sqrtcvallem sqrtd +sqrtdelta sqrtdeprecated sqrtdiv sqrtdivd +sqrte +sqrtelqelz +sqrtem sqrtf +sqrtfinhi +sqrtfiniv +sqrtfinlo sqrtge sqrtgt +sqrthi sqrthom +sqrtinterval +sqrtk +sqrtl sqrtle sqrtled sqrtlei sqrtlim +sqrtlo sqrtlt sqrtltd sqrtlti @@ -74329,9 +123630,20 @@ sqrtnegd sqrtneglem sqrtnegnre sqrtpclii +sqrtpow +sqrtprime sqrtpwpw +sqrtr +sqrtrealhi +sqrtrealiv +sqrtreallo sqrtrege +sqrtrem +sqrtrm +sqrtrp +sqrtrval sqrts +sqrtsd sqrtsq sqrtsqd sqrtsqi @@ -74339,7 +123651,11 @@ sqrtth sqrtthi sqrtthlem sqrttwoaddseries +sqrtu sqrtval +sqrtx +sqrtxx +sqrwitness sqsqrtd sqsqrti sqsscirc @@ -74349,30 +123665,56 @@ sqsubseteq sqsubswap sqsum sqsumi +sqsupset +sqtlsqtl sqto squ +squa +squanderface +squandertarget +squandervertex +squar square squarecylinders squared +squaredagain +squareflip squarefree squarefreehelper +squarefunc squarei squareleft +squaremod +squarenonneg +squareover +squarep +squareparallelogram +squarer +squarerectangle squareright squares +squaresequal +squareset squaretosnd +squareunique squaring squash squashed squashgcf squashseq +squats squb +squc +squee squeeze squeezed squeezedltsq squelet squelette +squn squnion +squote +squotes sqval sqvald sqvali @@ -74380,70 +123722,128 @@ sqweeze sqwvfoura sqwvfourb sqx +sqxpeq sqxpeqd sqxpexg sqy +sqz sqzero sra sraaddg +sraaddgg sraassa sraassab sraassaold srabase +srabaseg srabn sradrng srads +sradsg +sraex srafldlvec +srai sraidom +sraightfoward sraip +sraipg sralem +sralemg sralmod sralvec +sram sramulr +sramulrg +sran +srand srange srangerestrict +srani sranlm srapwov sraring srasca +srascag srasubrg sratopn +sratopng sratset +sratsetg +sraux sraval sravsca +sravscag srblit src srcctxt +srcdata srcdecl srcendpos +srcenv srcexpr srcexprofiso srcfield srcfields srcfix srcfixij +srchyp srci srcinnetlistaux srcj +srcl +srclang srclemma srclemmas +srclen srclist srcm srcmap srcmpltd srcnat srcnet +srcof +srcoff +srcoffv +srcofs +srcoftr +srcoftrfrom +srconf +srcperm srcs srcstartpos srcsyncv +srctgt +srctgtext +srctgtloc srctype +srcv srcvars +sre srec +srefl +srefs sreg +sregs srel +srelated +srelk +srelkex +srelpair +srem +srep sreplicate +sres +sresource +sresproof +srest +srestep +sresteps +sret sretr +sreturn +srev srewrite +srf srg srgacl srgass @@ -74475,6 +123875,7 @@ srgridm srgrmhm srgrz srgsummulcr +srh srhmsubc srhmsubcaltv srhmsubcaltvlem @@ -74482,30 +123883,60 @@ srhmsubclem sring sringcat sringcataltv +srj srl +srli +srlnks +srm +srnam +srname srng srngadd srngbase +srngbased srngcl srngcnv srngf srnginvl +srnginvld srngmul srngmulr +srngmulrd srngnvl srngplusg +srngplusgd srngrhm srngring srngstr +srngstrd +srorder +sros +sross srossspw +srpospr srpr +srprnpl +srrstep +srrstepd srs srsd srsided +srst srstep +srstepd +srstepi srsteps +srstepsd +srstepsi srt +srtype +srtypep +sru +srule +srulei srules +srveric +srw ssa ssab ssabdv @@ -74514,10 +123945,16 @@ ssabral ssabso ssafe ssafen +ssal +ssalel ssameside +ssar +ssau ssb +ssbcross ssbeq ssbid +ssbk ssbl ssblem ssblex @@ -74527,6 +123964,7 @@ ssbr ssbrd ssbri ssc +sscaleby sscan sscanl sscase @@ -74542,6 +123980,7 @@ sscmp sscn sscntz sscoid +sscoll sscon ssconb sscond @@ -74555,6 +123994,7 @@ sscstatpss ssct ssctr ssd +ssddif ssdec ssdf ssdif @@ -74577,20 +124017,25 @@ ssdmd ssdmfun ssdmral ssdmres +ssdmrn ssdomfi ssdomg sse +ssekmskeyid ssel sseld sselda sseldd +sseldi sseli sselialt sselid sselii sselpwd sselpwuni +ssem ssenen +ssep sseq sseqf sseqfn @@ -74599,6 +124044,8 @@ sseqfv sseqin sseqmw sseqp +sseqr +sseqtr sseqtrd sseqtrdi sseqtri @@ -74611,6 +124058,15 @@ ssequence ssequn sseqval sset +ssetd +ssete +ssetex +sseti +ssetkex +ssetkssvvk +ssetpm +ssetpov +ssets ssettopadj ssex ssexd @@ -74620,19 +124076,26 @@ ssexnelpss ssext ssextss ssf +ssfam ssfg ssfi ssfialt ssficl ssfid +ssfidc +ssfiexmid ssfii +ssfilem ssfin +ssfirab ssfiunibd +ssforall ssfz ssfzo ssfzoulel ssfzunsn ssfzunsnext +ssgc ssge ssgp ssgq @@ -74640,14 +124103,18 @@ sshaus sshauslem sshepw sshhococi +sshiftr sshjcl sshjval ssi ssid ssidcn ssidd +ssig +ssii ssiin ssiinf +ssik ssimaex ssimaexg ssimple @@ -74655,7 +124122,6 @@ ssin ssinc ssind ssindif -ssinf ssini ssinss ssint @@ -74663,34 +124129,38 @@ ssintab ssintrab ssintub ssipeq -ssitem ssiun ssiunov ssize ssjo sskip +ssl +sslash sslin -sslist sslm +ssm ssmapsn ssmcls ssmclslem ssmd ssmin -ssmueller ssmxidl ssmxidllem ssn ssnct +ssnder ssnei ssnel ssneld ssneldd ssnelpss ssnelpssd +ssnew ssnlim ssnmz ssnn +ssnnct +ssnnctlemct ssnnf ssnnfi ssnnssfz @@ -74698,25 +124168,37 @@ ssno ssnpss ssntr ssnum +ssofeq +ssofss ssold ssoldg +ssom +ssomct +ssome ssoninhaus ssonprc ssonuni ssonunii ssopab +ssopr ssoprab ssorduni ssort +ssorted +ssortfn ssp sspace sspadd sspba +sspe +sspec +sspecs sspg sspgval sspid sspims sspimsval +ssplusconclusion sspm sspmaplubn sspmlem @@ -74727,6 +124209,7 @@ sspnval sspr sspred sspreima +ssprr ssprss ssprsseq ssps @@ -74735,6 +124218,7 @@ sspsstr sspsstrd sspsstri sspsval +sspv sspval sspw sspwb @@ -74750,6 +124234,7 @@ sspwtralt sspwuni sspz ssq +ssqrt ssr ssrab ssrabdf @@ -74761,6 +124246,7 @@ ssralv ssralvold ssrankr ssrbool +ssrclasses ssrd ssrdv ssre @@ -74769,35 +124255,51 @@ ssref ssreflect ssrel ssrelf +ssrelk ssrelrel ssrelrn ssrempt -ssrequisition -ssrequisitioncreated ssres +ssreseq ssrest ssrexf ssrexr ssrexv ssrexvold ssrfun +ssri ssrin ssrind ssriv ssrmof ssrnat ssrnres +ssrp +<<<<<<< Updated upstream +======= +ssrr +>>>>>>> Stashed changes ssrsyntax +sss sssalgen ssscongptld +sssequalbd +sssequalcd sssigagen +ssskc +ssskp ssslts sssmf sssmfmpt sssn +sssneq +sssnm +sssnr +sssp ssss sssseq ssssev +ssssn sssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssss ssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssss sssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssss @@ -74806,35 +124308,53 @@ sssucd sssucid sssymdifcl sst +sstable +sstack sstar +sstart sstate +sstato +sstemp sstep ssteplem +<<<<<<< Updated upstream +======= ssthan +>>>>>>> Stashed changes +sstore sstotbnd sstp +sstpr sstr sstralt sstrd sstrdi +sstrength sstri sstrid +sstrip +sstrm sstskm ssttrcl ssu +ssub ssubq ssubset ssubseti ssubsets +ssubsetuniq ssubst ssubstoption +ssubstr ssubt +ssubw ssuffixes ssufl ssum ssun ssuncl ssundif +ssundifim ssuni ssunib ssunieq @@ -74852,13 +124372,18 @@ ssupnormim ssusgr ssuzfz ssv +ssvar sswf sswfaxreg +sswitch +sswords sswrd sswsts ssx ssxnn +ssxp ssxpb +ssxpbm ssxr ssy ssys @@ -74866,14 +124391,20 @@ ssz sszcld sta stab +stabbrev +stabcl +stabcoh +stabhx stabiliser stabilises stability +stabilization stabilize stabilizer stabilizerequiv stabilizerequivstabilizer stabilizerequivstabilizeroforbitrel +stabilizergroup stabilizerhom stabilizerhomsurjectiveauxfunctor stabilizerisoend @@ -74883,10 +124414,19 @@ stabilizerquotientinertiaequiv stabilizers stabilizersubmonoid stabilizes +stabilizing stabl stable +stabled stablefiltration +stablei +stablejames +stabler stables +stableset +stablesm +stablesu +stablesubgroup stableunderbasechange stableunderco stableundercomposition @@ -74896,44 +124436,98 @@ stableundercompositionwithlocalizationawaytarget stableundergeneralization stableunderinverse stableunderspecialization +stablish +stabnot stabpeirce +stabspheres stabulate +stac stack +stackaddr +stackalgebra +stackalloc stackargs +stackd +stackdisj +stackedneighbors +stackend stackentry stackexchange stackframe +stackframes +stackfree +stackgetsize +stackhandlerargs +stackindex +stackinline +stackit +stacklang +stacklist +stackload +stackloadany stackloc +stackmachine +stackmap +stackmaps stackmark +stackn +stacknodes +stacknondet +stacknum +stackoffset stackoverflow +stackp +stackphyregs +stackprog +stackprops stackpush stacks +stacksem +stackset +stacksetsize +stacksize +stackspace stackstag stackstagantiquot stackstagfn stackstagkind stackstagnoantiquot stackstagparser +stackstore +stackstoreany +stackswap +stacksyms +stacksystem +stacktraces +stacktrivial stackvalue +stackwords +staclicompl +stacomplcli stact +stadard stadd staddi -stadt stae staffn staffval stafval +stag stage staged stageone +stages stagetwo stai +stail staindata stained stains stainstx +stair stake stakmap +stal stale stalem stalk @@ -74960,30 +124554,50 @@ stalktofiberringhom stalktolocalization stalkwise stalkwiseiszariskilocalattarget +stall +stalld +stalldd +stalled +stamo +stamp stampedmap +stamps +stan stand +standa standalone +standalonecall +standar standard standardbasis standardborel standardborelspace standardcomplex +standardcon standarddef +standarddefinition standardetalepair standardetalepresentation standardi +standardisation +standardization standardize +standardized +standardly standardonedimisocrystal +standardp standardresolution +standards standardsimplex +standardstacksystem standardsubspace +standing stands +stanford stape -stappf -stappp -stappt star stara +starac staraddequiv staraddmonoid staraddmonoidsemiring @@ -74992,8 +124606,9 @@ staralgebra staralgequiv staralghom staralghomclass -starb starc +starca +starcaller starcenterisocentroid starcentertocentroid starcentertocentroidcenter @@ -75008,7 +124623,10 @@ stardiff starequation starequivcostar starexpansive +starfunction stargr +starh +starheight starhom starhomclass stari @@ -75023,6 +124641,7 @@ starlem starlift starlike starlinearequiv +starloops starlr starmap starmemclass @@ -75030,19 +124649,24 @@ starmodule starmul starmulaut starmulequiv +starn starnecexists starnormal starnormedaddgrouphom starofab starofsize +starop starorderedfield starorderedri starorderedring +starp +starpost starprojection starproperty starpullbackisostar starr starray +starred starrightdestructive starrightexpansive starring @@ -75057,58 +124681,131 @@ stars starse starsi starski +starstarcaller +starstarfunction +starstaruseinsidefunction +starstaruseinsidemethod starsubal starsubalgebra starsubalgebraa +starsubalgebrab starsubsemiring start +startballot +startbody +startd +startdecrypt +startdecryptvectors started +startencrypt +starter starterminal +startes +startexp +startg +startin +startindex starting startingfrom +startl +startlive +startloop +startmarker +startmodule +startmult startnode +startnum startof startpoint startpos startpsp startpss +startptr starts +startspec +startstep startswith +startsym startsymbol starttime +startup +startv +startypes +starver starvid starvndx starvndxnbasendx starvndxnmulrndx starvndxnplusgndx +starvslid stat stata stataa state +statea +statealph +stateasseq +statec +statecorrespondence stated +statedelay +statedelayspec statediff statee +statef stateful +statefully +stategenerator +stategeneratorlocal +statei stateinterpol +stateis +stateiter +statel stateless +statelist statelp statem statemachine +stateman +stateme statement +statementp statements +statementsincompiledmethod +statementsinghostmethod +statementswithvariables +statemonad +statemove +statename +statenext stateo stateof +statep +stateparamsp +statepcs stateqtint +staterec statereft states +statesat statesaudioplayer statescaraudiosystem statescdmode statescdplayer statesd statesdecls +statese stateselectors +statesi +statesinj +statesnames statespace +statespect +statespecteq +statespectmonadlaws +statespectorder +statespectorderedlaws statesroot statestunermode statet @@ -75119,22 +124816,74 @@ statetimonad statetimonadplus statetimonadstate statetimonadzero +statetm statetransition statevars static +staticaboutuu statically +staticaly +staticc +staticcallredsfinal +staticcastreds +staticcastredsfail +staticcastredsnull +staticcastredsthrow +staticcopyasg +staticd +staticdowncastreds +staticdowndyncastreds +staticerror +staticfact +staticfunction +statichelper +statici +staticinsert +statick +statickeymaterial +statickeystoreinformation +staticlemmawithoutprecondition +staticloc +staticm +staticmethodsayseight +staticminus +staticmoveasg +staticn +staticp +staticpoly +staticprivatekeyfromgeneratersakeypair +staticprivatekeyfromtestvectors +staticpublickeyfromgeneratersakeypair +staticpublickeyfromtestvectors +staticqinclass +staticrecursivezero +staticrevealworks staticsecret +statict +statictest +staticupcastreds +staticupdyncastreds +staticwithgenerics +staticwithgenericsfn stating +station stationary -stationaryartifact stationarypoint +stations +statistics stato statoo statpcp statpsp statpss stats +statsp +statu status +statusaccess +statusbits +statusindex +statusp stay staying stays @@ -75142,6 +124891,11 @@ staysenabled staysenabledhelp staysenabledstep stb +stbg +stbid +stbits +stbp +stbs stc stcal stcalwb @@ -75158,12 +124912,17 @@ stcltrlem stcltrthi stcnv stcof +stcombined +stcombinedc +stcompose stconst stcorrect stcrest stcrestlem stctop +stcwlpo std +stda stdaddchar stdbasis stdbdbl @@ -75171,12 +124930,27 @@ stdbdmet stdbdmetval stdbdmopn stdbdxmet +stdc +stdcall +stdcn +stdcndc +stdcndcold stddev +stderr +stdfun +stdfunspec stdgaussian stdgen stdgenref +stdgraph +stdin +stdio +stdivineq +stdivineqgcd +stdlib stdm stdmp +stdmvbasis stdo stdorthono stdorthonormalbasis @@ -75184,21 +124958,48 @@ stdout stdpart stdpc stdrefl +stdrel stdsimplex stdsimplexequivicc stdsimplexhomeomorphunitinterval +stdsym stdtext +stdworlds +stdx ste +steady +steal +stealable +stealcolor +stealend +stealreg +steam +steel +steelmillslab +steen +<<<<<<< Updated upstream +======= stehen +>>>>>>> Stashed changes steiner steinhaus steinhauslike +steinhauss +steinitz +stellar stelt stem +<<<<<<< Updated upstream +======= stemilion +>>>>>>> Stashed changes +stemp +stemps stempty +stengthen step stepa +stepact stepanov stepasync stepaux @@ -75206,11 +125007,29 @@ stepb stepback stepbound stepc +stepcd +stepcount stepd +stepdown stepe +stepeq +stepexec stepfailure +stepfns stepfor +stepforup +stepfun +stepfunction +stepgba +stepgcd +stephen stepi +stepid +stepincinc +stepindex +stepinject +stepkind +stepl steplemma stepn stepnormal @@ -75220,15 +125039,39 @@ stepordereddyn stepordereddynamic stepordereddynamicfailure steporderedfailure +stepover +stepp +stepper +stepping +stepplus +stepr +steprefl stepret steps +<<<<<<< Updated upstream +======= stepsa +>>>>>>> Stashed changes +stepsd +stepseq stepset +stepsex stepsl +stepsof stepss stepstar +stepsv +steptd +steptimes +steptrans +steptransrefl steptype +stepunfin +stepv +stepw +stepwhile stepwise +stepwithinv steq steqg sterbenz @@ -75240,15 +125083,28 @@ stereoinvfun stereoinvfunaux stereotofun sterm +stermi +sterminate +sterms stermsl stern +sternary +stest +stetps +stex +stexg stexists stf +stfal stfcl +stffi stflem +stfo stfpropd +stfrm stfv stfval +stfx stg stge stglobal @@ -75268,10 +125124,20 @@ stgrnbgr stgrorder stgrusgra stgrvtx +stgs sth +sthead +stheta sthil +sthout +sti +stic +stick +sticks sticksstones sticky +stickyp +stickypart sticl stieltjes stieltjesfunction @@ -75279,19 +125145,34 @@ stieltjesfunctionaux stieltjesfunctionrightlim stieltjesofm stieltjesofmeasurablerat +stil stileturn still stillconvex stillnz +stillsurj +stillvalidaftervalchanges +stim stimcomm stimes +stimesteps +stimu stimuli +stimulu stimulus +stin +<<<<<<< Updated upstream +======= stinct +>>>>>>> Stashed changes +stinks stinl stinr stinvn +stipulate stipulates +stiring +stirl stirling stirlingfirst stirlinglem @@ -75302,27 +125183,66 @@ stitched stj stji stk +stka +stkfma +stki stklength +stknodearr +stknodearrp +stkp +stkprec +stks +stksize +stkss +stksz +stktok stl +stld +<<<<<<< Updated upstream +======= stldt +>>>>>>> Stashed changes stle stlei stlem stlesi +stli +stloc +stlocs stm stmap +stmarker stmbfm stmem +stmfd +stml +stmp stmt +stmte +stmtexpr +stmtlist +stmtnt +stmtreturn stmts stmtstrec +stmtvariable stn +stnm +stnotused stnpr sto +stob +stobig +stobj +stobjname +stobjp +stobjpred +stobjs stoch stochastic stock stocks +stoff stoic stoig stolz @@ -75335,18 +125255,27 @@ stoneancomphaus stoneantocomphauseffectivepresentation stoneantocondensed stoneantoprofiniteeffectivepresentation +stoneblattice stonecech stonecechadjunction stonecechequivalence stonecechextend stonecechobj stonecechunit +stoneh +stonelatt +stoner +stones +stonespace stop +stopat +stopcode stopi stopl +stopp +stoppe stopped stoppedabove -stoppedin stoppedprocess stoppedvalue stopper @@ -75356,99 +125285,229 @@ stoppos stopr stops stoptk +stoptype stopws +stor storage store +storeanyconsts +storebyte +storebytent storebytes +storecat +storeconsts stored +storedata +storedm +storedouble +storeeach storeeffect +storeeffectd storeelim +storef +storeglob +storehalf +storeim +storeind +storelo storeloc +storelocalvar +storemem +storemembyte +storememory +storent +storeorder +storeorderpar +storeptr +storeref stores +storestate storev +storeword +storig +storigc +storing +stormtrackingcache story +stout +stowarzyszenie stowei stoweid stoweidlem stp stpa stpb +stpclkb stprc stpreima stpreimas stprincd str +strace straddle straight straighten +straightfibonacci +straightforwar straightforward straightforwardly +straightline strand strands strange +strangezero +strap +strapping strarrowmk +strash +strassen strat +strata +strateg +strategic strategies strategy strategydescr +strategyj strategyproof stratified +stratifiedsemantics +stratifiedsemanticswithseparation +stratifies stratify stratproof +stratsem +stratsemsep stratum +stratumsuc straus strb strbas +strbasg +strc +strcar strcat +strcdr +strchar +strchr +strcmp +strcmpsymmetric +strcoll +strcollnf +strcollnfalt +strcollnft +strcontents +strcopy +strcpy +strct +strdec strdecl +strdecode +strdiff stream streamadd +streamarn +streamexpr +streamexprlist +streamg +streaming streamline +streamofnonempties +streamp streams streamstep +streamvalue +strech +stree +strees street +streicher +stren +strencode +streng +strenghtened +strenghthened +strengt strength +strengthe strengthen strengthened strengthening strengthenstrictint +strengthentocore strengthenweaken +streq +strequiv +streqv stres +stresm +stress +stressor stretch strexpr +strext strfv strfvd strfvi strfvn strfvnd strfvss +strfvssn +strh stri +striaghten stric +striclty +stricly strict strictanti strictantion +strictcat +strictcats strictcolimitsofshape strictcomono +strictcompspec strictconcave strictconcaveon +strictcontrfibers strictconvex strictconvexon strictconvexspace +stricteq +strictequivclauses +strictequivmacro +strictequivterm +stricter +strictex strictexpr +strictgroupoids +stricti strictify strictimplicit +strictincr +strictinctriangle strictindexes strictinitial +strictisotoequivmacro strictlimitsclosureiter strictlimitsclosurestep strictlimitsofshape strictly +strictlyadvancedfrom strictlycontracting strictlycontractingonorbits +strictlyincreasing strictlyinverse +strictlyorderpreserving +strictlyorderreflecting +strictlyparallel strictlypositive strictlypositivecone +<<<<<<< Updated upstream +======= strictlyprecedes +>>>>>>> Stashed changes +strictlysplitfrom strictlysurjective strictlyunitarylaxfunctor strictlyunitarypseudofunctor @@ -75458,22 +125517,36 @@ strictmono strictmonoon strictmsgs strictness +strictorder +strictordered strictorderedcommring strictorderedcommsemiring -strictorderedp strictorderedring strictorderedsemiri strictorderedsemiring +strictorderembedding +strictorderequiv +strictorderpath +strictorderstr +strictp strictpartialorder +strictpartialordered strictperiods +strictpos strictpseudofunctor strictpseudofunctorprecore strictrelation +stricts strictsega strictsegal strictsegalcore +strictsemiringorder +strictsub +strictsubmap +strictsuffixof strictterminal stricttotalorder +stricttotalordering stricttotalorderviaequiv strictunivers strictuniversalpropertyfixedtarget @@ -75482,37 +125555,86 @@ strictuniversalpropertyfixedtargetq strictuniversalpropertyfixedtargetquotient strictuniversalpropertyfixedtargettohocat strictwidthinfty +strin string +stringafterterminator +stringbeforeterminator +stringbody +stringbodylexerstate +stringcmp +stringcmploop +stringcmpmin stringdiagram +stringe stringeqm +stringi +stringify +stringifyencryptioncontext +stringifyencryptioncontextpair +stringis stringlength +stringlexerstate +stringlist stringm +stringmd stringmororeqm +stringnamegen +stringp +stringpm stringpresenter +stringprinting +stringprog strings stringsep +stringset +stringt +stringtest +stringto +stringtobytearray +stringtoo +stringtuple +stringwrap strinv strip stripbv stripextension +stripimp stripped stripping strippis strips striptraceresultprefix +strjoin +strl strle strlem strlen strleun +strleund +strline +strlines +strlist strlit +strm strname +strnat strndxid +strnfvn +strnfvnd +strng +strnthcdr +stro +strobe stroeder +stroes strojnowski +stroke stron strong +strongbinaryextensionality strongconcaveon strongconvexon +strongctxt strongd strongdb strongdlhppb @@ -75524,17 +125646,28 @@ strongepicategory strongepimonofactorisation strongepimonofactorisationsigmadesc strongeq +strongequivalence stronger strongest +strongextensionality strongfepair +strongfunctor +strongg +stronggamma +strongheqmki stronghomclass stronghomclassempty stronghomclassofisalgebraic +strongind strongindefinitedescription stronginduction stronginductionon +strongjordanholderuniqueness stronglawaereal stronglawnonneg +strongleftcancellation +stronglinearorder +stronglinearorderexists stronglt strongly stronglyadapted @@ -75544,6 +125677,7 @@ stronglycoatomic stronglyconnected stronglyconnectedcomponent stronglyconnectedsetoid +stronglyconnex stronglylocallycontractiblespace stronglymea stronglymeasura @@ -75551,10 +125685,16 @@ stronglymeasurable stronglymeasurableat stronglymeasurableatfilter stronglysorted +strongmonad strongmono strongmonocategory +strongnorm +strongof +strongord strongorder strongpostdomination +strongproper +strongpropositionaltransparentmodality strongrankconditio strongrankcondition strongrec @@ -75562,48 +125702,99 @@ strongrecaux strongrecon strongred strongrelease +strongrightcancellation strongsemieq strongsemired +strongseparationalgebraabsorbstable strongsubrecursion +strongtopology strongtrans +strongwellorderexists +strongx strop +stropg +strord +strorder +strother strov +strp +strpos +strprefixp strq +strr +strrel +strrelaction +strrelmatchesequiv +strrelquotientcomparison +strressid +strrpos strs +strsetsid +strsl +strslfv +strslfvd +strslss +strslssd +strsplit strss strssd strstr +strstrg +strstrndx strstx +strsub +strsubst +strsubsts +strsuffixp strt +strterm +strtok +stru struc struct +structb structcnvcnv structd +structdef structex structfield structfn structfun structfung +structgr structgrssiedg structgrssvtx structgrssvtxlem structi structid structiedg +structind structinduct structinstfield +structlist +structmember +structmemberlist +structmembers structn structname +structnt structomorph structomorphisms +structt structtocusgr structtousgr +structu +structur structural structuralatom +structurali structuraliso structuralisoofexpr structurally structuralofexpr +structuralresourceaccess +structuralview +structuralviewens structure structured structuredarrow @@ -75618,6 +125809,10 @@ structuredarrowopequivalence structuredarrowrightwards structuredarrowrightwardsopequivalence structuredarrowtostructuredarrowpre +structuredcommandsif +structuredcommandswhile +structuredequiv +structuredqer structureext structuregroupoid structureintype @@ -75625,6 +125820,7 @@ structuremap structuremapclm structuremaplm structurename +structurep structurepresheafcompforget structurepresheafincommring structurepresheafincommringcat @@ -75633,30 +125829,65 @@ structurepresheafinmodulecat structures structuresheaf structuresheafintype +structuret +structuring structvtxval structvtxvallem +strue struggle struggled strun +struni +strunsafe struth +strv strval +strwnotin strwun strwunbndx +strx +strxor sts +stsc +stsepe +stsi +stsij +stsj +stst +stsv stt +sttru +<<<<<<< Updated upstream +======= +stts +sttt +>>>>>>> Stashed changes +stu stub +stubbed +stubp +stubs stuck +stuckinthepast stuckred stuckstate +student +<<<<<<< Updated upstream +======= students +>>>>>>> Stashed changes +studied study stuff stuffagree +stuffwithar stump +stupid stupidtrunc stupidtruncfunctor stupidtruncmap stupidtruncxiso +stuple sturm stut stutinv @@ -75664,44 +125895,69 @@ stutter stutterd stuttering stutterpath +stutters stv stval +stvalg stvalue stvar +stvi +stvl +stvp +stw stwhqexbd +stwk stwrite stx stxn stxnodes +stxor stxs stxstack stxtrav sty +styargs style styleerror styleexceptions +styles styling stylish +styp stype +stypep stypes sub suba subact +subaction +<<<<<<< Updated upstream +======= subactivity +>>>>>>> Stashed changes subadd subaddaction subaddd subaddeqd +subaddexistsnice +subaddforallsnice subaddi subadditive subadditived subadditivehomclass subadditivei +subadditivity subaddmulsub +subaddprog +subaddproj +subaddress +subaddresses subaddrii subadds subaddsd +subadv subalg +subalgcl subalgebra subalgebraalgebraicclosure subalgebracenter @@ -75709,111 +125965,248 @@ subalgebraclass subalgebraequivintermediatefield subalgebramap subalgebranontrivial +subalgebraofclass subalgebraofroot subalgebraofsubring subalgebraofsubsemiring subalgebrarank subalgebras +subalgs +subalistp +suballclosefrom +suballformula +suballformulaid +suballnvars +suballsuballformula +suballsuballterm +suballsuballterms +suballsubformula +suballterm +suballtermid +suballterms +suballtermsid +subalpha +subantidist +subap +subapd +subapprox +subarc +subarguments subarray +subarrays subat -subattribute subb +subba +subbackslash +subbag +subbagp +subbagps +subbags subbalance subbascn subbase subbasis +subbdt subbimodule +subbody +subborrow subbox subboxes +<<<<<<< Updated upstream +======= subbreln +>>>>>>> Stashed changes +subbx +subbytes +subc subcan subcanad subcand subcani subcanonical +subcase +subcases subcat +subcate +subcatego subcategories subcategory subcategoryacyclic +subcategoryex +subcategoryuniq +subcatstr subcc subccat subccatid subccocl +subcent +subcentp subcfn subchain +subchainiso +subchainisogen +subchro subcid subcidcl +subckt subcl subclass subclasses -subclassof subcld subcli +subclosed subcls subclsr subclsrd +subclsrp subclss subclssd +subclssp +subcmd subcmn +subcmnd subcn subcncf subcncff +subcncntop +subcocycle +subcode +subcoll +subcollection +<<<<<<< Updated upstream +======= subcollectionofwithrelationfromtypefn subcollectionofwithrelationtofn +>>>>>>> Stashed changes subcollections subcom subcomm +subcommutative subcomp +subcompletion subcomplex +subcomplexcard +subcomplexcharac +subcomplexcw +subcomplexfam +subcomplexgen +subcomplexhomology +subcomplexhomologyequiv +subcomplexmapgen subcomplexofsimplex subcompnormhom +subcomponent subcomponents +subconcept +subcondensed +subconnected +subconsset subconst +subconstant +subcontent +subcontour +subcopy +subcor subcos +subcount subcounttype subcover +subcovering +subcqcind subcrcl +subcrit +subcritical +subcrock +subcross +subcset subcss subcssc +subctctexmid +subctx +subctxt +subcw +subcwexplicit subd subdag +subdags +subdcpo subdecompv +subdef +subdefa +subdefc subdegree +subdegrees subdenest +subdeps +subdepsmap subdi subdid +subdigit subdigraph subdii subdir subdird subdiri +subdirs subdis subdisl subdisr subdist subdistl subdistr +subdiv subdivcomb subdivface +subdivfacefinal +subdivide subdivision subdivisions +subdivisionstr +subdoc subdom +subdomain +subdomd subdome +subdomp +subdompe +subdomq +subdomue +subdot subdpideal +subdprodl subdprodr subdrgint subdring +subdset +subdsetl +subdsetr +sube +subed +subedbitofw +subee +subefproper +subek +subel +subelem subeluzsub subemp +subeproper subeq subeqrev subeqxfrd +suber +subeset subeu +subevent subex +subexp subexpr subexpression +subexpressions +subexprlist subexprpos subexprs +subexps subexsub subextensions subf @@ -75825,8 +126218,15 @@ subfaclefac subfaclim subfacp subfacval +subfaithful +subfam subfamilies subfamily +subfapplies +subfdual +subfext +subfextend +subfi subfield subfieldclass subfieldcongr @@ -75834,15 +126234,61 @@ subfields subfieldvalued subfilt subfilter +subfinbouquet +subfinite +subfinitely +subfiniteness subfmlas +subfms +subfmset +subfn +subfnot +subfoo +subform +subforms +subformterm subformula +subformulaand +subformuladepth subformulae +subformulaequal +subformulaexch +subformulaexist +subformulaforall +subformulaid +subformulaiff +subformulaifthenelse +subformulaimp +subformulaminimize +subformulanil +subformulanot +subformulante +subformulantehelp +subformulaor +subformulaproperty +subformulapropertyone +subformularelation subformulas +subformulatrans +subframe subfrmls subfrmlsn subfrmlsr +subfrom +subfs +subfset +subfun +subfuncex +subfuncs +<<<<<<< Updated upstream +======= +subfunction +>>>>>>> Stashed changes subfunctor subfv +subfx +subfxe +subfxeroot subfzo subg subgabl @@ -75850,8 +126296,11 @@ subgacent subgacente subgacs subgadd +subgalg subgalt +subgame subgbas +subgcfker subgcl subgcld subgdisj @@ -75860,26 +126309,42 @@ subgdmdprd subgdprd subge subgecsn +subgex subgga subggim subggrp subgid subgint +subgintm subginv subginvcl +subgk +subglobals subglsm +subgm +subgmk subgmulg subgmulgcl subgmulgcld subgngp subgnm subgntr +subgo +subgoa subgoal +subgoalp subgoals subgod +subgp subgpgp subgr +subgra +subgradient subgraph +subgraphd +subgraphe +subgraphi +subgraphinducedby subgraphofadj subgraphs subgraphverts @@ -75887,12 +126352,15 @@ subgrcl subgrcycl subgreldmiedg subgrfun +subgro subgroup subgroupclass subgroupclosure subgroupcomap subgroupcongr +subgroupd subgroupequivalgequiv +subgroupi subgroupmap subgroupnormal subgroupof @@ -75904,10 +126372,14 @@ subgroupoid subgroupop subgrouporderisosubgroupmonoidhom subgrouporderisosubgroupmulchar +subgroupp +subgroupprop subgroups +subgroupvti subgrp subgrprop subgrpth +subgrsep subgrtrl subgruhgredgd subgruhgrfun @@ -75919,59 +126391,121 @@ subgsub subgsubcl subgsubcld subgsubm +subgt subgtgp subhalfhalf +subhalfnqq +subhall +subheap +subheape +subheaps +subheapt +subheapun +subheapunl +subheapunr subhypergraph subhypergraphi +subhyps subi subid subidd subideal +subidem subidi +subik +subimagek +subimm +subindex subinf +subint +subinterpformula +subinterprel +subinterpterm subinterval subintervals subinvsmul subir +subiscorrect +subiset +subisetl +subisetr subislly +subisomgrouprel subitv subitvp +subitvpl +subitvpr subiwrd subiwrdlen +subix +subj +subje subject +subjected subjective -subjectiveassessmentattribute subjects subjectsc +subjoin +subk subker +subkey +subkeyhat +subkeyquiv +subkeyquivp +subkeys +subki +subkimage +subkn +subkr +subku subl +sublang +sublanguage sublattice sublattices suble +subleaf subled subleft +sublemma +sublens sublevolico +sublhs +subli sublimc sublinear +sublis sublist sublistforall +sublisti +sublistp sublists sublistsaux sublistslen sublistslenaux sublocale +sublocals sublog +subloverflow +sublr subls +sublst sublt sublterm subm submabas +submachine submacs submaeval submafval +submagma +submanifold submap +submapp +submaps submarchi submartingale +submaskp submat submateq submateqlem @@ -75987,6 +126521,7 @@ submbas submcl submcld submcmn +submeet submefmnd submersivepresentation submetric @@ -75999,7 +126534,12 @@ submgmmgm submgmrcl submgmss submid +submission +submissives submit +submits +submitted +submitting submmnd submmulg submmulgcl @@ -76007,9 +126547,16 @@ submnd submo submod submodaddmod +submode submodel +submodj +submodk submodlt +submodnames submodneaddmod +submodp +submodpred +submods submodu submodul submodularity @@ -76047,9 +126594,11 @@ submonoidpowers submonoidpresheaf submonoidpresheafofstalk submonoids +submonotone submrc submrcl submre +submset submss submtmd submul @@ -76059,11 +126608,24 @@ submuladdmuld submultiplicative submultiplicativehomclass submultiset +submultisetp +submx +submxe +submxelt +submxk +submxmfree +submxml +submxmr +submxp subn subnac subnat subnatnat +subnba +subnda +subndiv subndl +subndr subne subneg subnegd @@ -76075,10 +126637,27 @@ subneintrd subnet subnets subnetstr +subnilset +subnk +subnkc subnn +subnnhelp +subnode subnodes +subnorm subnormal +subnormalel +subnormaler +subnormalesupport +subnormalp +subnormals +subnormg +subnr +subns +subnsk +subo subobj +subobjcat subobje subobject subobjectequiv @@ -76090,9 +126669,17 @@ subobjectorderiso subobjectrepresentableby subobjects subobjectsubobject +subobjmorismonic subobjs +subobjsr +<<<<<<< Updated upstream +======= subocc +>>>>>>> Stashed changes subofld +subon +subonacci +subone suboneintegralpowerbasis suboneintegralpowerbasisofprimepow subonepowerbasis @@ -76102,7 +126689,12 @@ subordinate subordinateorthonormalbasis subordinateorthonormalbasisindex subordinateorthonormalbasisindexfiberequiv +subordination suborng +suboset +suboverflow +subp +subpair subpalindromes subpath subpathaux @@ -76110,36 +126702,100 @@ subpaths subpathtranssubpath subpathtranssubpathrefl subperm +subpermission +subph +subpn +<<<<<<< Updated upstream +subpos +subposet +subpowerset +======= subpopulations +subpos +subposet +subpowerset subpowsu +>>>>>>> Stashed changes +subpr +subprecat +subprecateg +subprecategor +subprecategory +subpred subpredexistsl +subpredtype +subpreorder +subpreordered subpresheafcontinuousprelocalisopresheaftotop subpresheaftotypes subprob +subprobability subproblem +subproblems +subprobs +subprod subprodxsubc subprograms +subprogs +subprojection +subproo subproof +subproofone +subproofs +subprop +<<<<<<< Updated upstream +======= subpropertyof +>>>>>>> Stashed changes +subprops +subpt +subpure subq +subqcfuncuniq +subqcind +subquasiordered subquotient subr +subra +subran +subrang subrange +subrangecheck +subrangep +subranges subrdom +subre +subreal subrec +subrecap +subrecapd +subrecapi subrecd subreci +subrectagon +subreflexive +subregion subrel subrelation +subrelationh subrelgoodr subrelgrbar +subrelh subreliso +subrelmonotonicity +subrelst subrelstr +subrelstreq +subrelstrex +subrelul subreluniviso +subrelur +subreplace subrepresentation subrepresentationsubmoduleorderiso subresre subresultant +subreversible subrfld subrfn subrfv @@ -76156,6 +126812,7 @@ subrgdvds subrgid subrgin subrgint +subrgintm subrginv subrgmcl subrgmcld @@ -76187,12 +126844,18 @@ subringcenter subringclass subringcongr subringmap +subringpred +subrings +subrka +subrkc +subrl subrng subrngacl subrngbas subrngid subrngin subrngint +subrngintm subrngmcl subrngmre subrngpropd @@ -76202,15 +126865,25 @@ subrngrng subrngss subrngsubg subrootedtree +subroute +subroutes +subroutine subrow +subrr +subrules +subrun subrval +subrx +subrxx subs subsaliuncl subsaliuncllem subsalsal subsaluni +subsc subscan subscc +subscene subscheme subschemecover subschemefunctor @@ -76219,8 +126892,10 @@ subschememap subschemeobjiso subscl subscld +subscr subscript subscripts +subscripttarget subscriptterm subsd subsdid @@ -76228,14 +126903,23 @@ subsdird subsdrg subse subsection +subseedtree +subseg +subsegment subsegmenti +subsegments subsel +subsem +subsemi +subsemig subsemigroup subsemigroupcenter subsemigroupcomap subsemigroupcongr subsemigroupmap subsemigroups +subsemilat +subsemilattice subsemiring subsemiringalgebra subsemiringcenter @@ -76243,35 +126927,91 @@ subsemiringclass subsemiringclosure subsemiringcongr subsemiringmap +subsentence subsep subseq subseqb +subseqchoice +subseqp subseqs +subseqsd subsequence +subsequencefromarray +subsequencefromseq +subsequencep subsequences subsequent subsequently +subseqx +subseries subset +subseta +subsetbdd subsetbuild +subsetc +subsetci +subsetcl +subsetconstraints +subsetconstraintsarrays +subsetcp +subsetcpl +subsetcpr +subsetcr +subsetcw subsetd +subsetdl +subsetdp +subsetdr subsete -subsetemptysetimpeq subseteq subseteqi +subseteset +subsetex +subsetfamily +subsetfamilystr +subsetfd subseti +subsetiidl +subsetiidr +subsetil subsetinfset +subsetip +subsetir +subsetof subsetofnat +subsetorder +subsetp +subsetpairi +subsetpn subsetprodlex +subsetps +subsetpset +subsetpvids +subsetpx +subsetq subsetrecursor subsetrecursorbuilder -subsetrefl subsets +subsetseq +subsetsi subsetsify subsetssubset subsetsum subsetsupset +subsett +<<<<<<< Updated upstream +======= subsetti subsettrans +>>>>>>> Stashed changes +subsettype +subsettypes +subsetu +subsetul +subsetuntop +subsetur +subsetw +subsetx subsf subsfatom subsfconj @@ -76283,6 +127023,8 @@ subsheaftotypes subsi subsid subsieve +subsignature +subsimplicialcomplex subsin subsing subsingl @@ -76295,69 +127037,180 @@ subsingletonequivfreecommring subsingletonhelim subsingletonprodselfequiv subsingletons +subsitution subsjustified +subskn +subslash subslist subsmonoid +subsn +subsnn +subsocle +subsort subsp subspace +subspaceip +subspaceit +subspacep subspaces +subspaceset +subspacet +subspaceti +subspacetopology +subspacew +subspec subspopn +subspt subsq subsqi subsquare subss subsset +subssigd +subssigi subst +substa +substabs substalghom +substall substance substandard substantially +substar +substarispr substassoc substate +substatep +substatomicp substax +substbind +substbinp +substc substclosed substclosure +substco +substcommslice +substcomposite substcond +substconf +substconfig +substconnect +substconst substd subste +substep +substeps +substeq +substequiv substexp +substf +substfn +substform +substformp substfunc +substfunctions substi +substin +substinp +substinpaths +substiso +substit +substitu +substitue +substituion +substitut +substitutable substitute +substituted +substituteformula +substituteformulaforall +substituteformulaforallnice +substituteformulaimp +substituteformulaimpnice +substituteformulanot +substituteformulanotnice substitutes +substituteterm +substituteterms +substituti +substitutible +substitutiblep substituting +substitutio substitution +substitutionny +substitutions +substitutionset substitutiont substitutionts +substitutiony substitutive substl +substlat +substlatt +substlaw +substlift +substlist substmem +<<<<<<< Updated upstream +======= substmonoid +>>>>>>> Stashed changes +substnext substok substopt +substore +substp +substpath +substpathsr +substpb +substposet substr +substracted +substraction +substrefl +substrel +substrex substring substrings +substrp +substrs +substrt +substrtt +substruct substructural substructure substructureequivmap substructurereduct substructures substs +substseq substsnt +substsubst substt substterm +substtermp substtrans substupdate substupdateok +substut +substv +substvar +substvars substw substwelldefined +substwith +substwk substxine subsub subsubadd +subsuballformula +subsuballterm +subsuballterms subsubc subsubd subsubelfzo +subsubformula subsubformulae subsubg subsubm @@ -76365,56 +127218,115 @@ subsubmgm subsubrg subsubrng subsubs +subsubsection +subsubterm +subsubterms subsum subsume subsumed subsumee +subsumees subsumer +subsumers subsumes +subsumeseq subsuming subsummable subsumption subsums subsuper subsuperset +subsupersets +subsupertrait +subsuplattice subsval subsvald subsvals subsym +subsymmetric subsystem +subsz subt +subtag +subtc +subte +subtensor +subter subterm subtermeq +subtermeqi +subtermeqset +subtermexch +subtermfunction +subtermid +subterminal subterminalinclusion subterminals subterminalsequivmonooverterminal +subtermnil +subtermp subterms subtermsd +subtermsexch subtermsi +subtermsid +subtermsnil +subtermsof +subtermsrp +subtermstrans +subtermtrans +subtermvar +subtest +subtheory subtheorymodel subthinc +subtie +subtle subtlety subtoker +subtopics +subtopologies subtopology +subtosuball subtosupquotient subtr +subtrace +subtraces subtract subtracted +subtractequals +subtracter +subtracti subtracting +subtractinterval subtraction subtractioncommmonoid subtractionmonoid +subtractionoffractions subtractions +subtractive +subtractlteleft +subtractlteright subtractrow +subtracts +subtrahend subtrail subtration subtree +subtreei subtreel +subtreemap subtreeof +subtreep subtreer subtrees +subtreeseq +subtrgrouphom subtriangle +subtrie subts +subtset +subtuple subty subtyp subtype @@ -76424,6 +127336,7 @@ subtypecoe subtypecompatiblehomequiv subtypecongr subtypecongrhom +subtypeconstraint subtyped subtypedomain subtypedomainaddmonoidhom @@ -76448,14 +127361,17 @@ subtypeopequiv subtypeorderiso subtypeorequiv subtypeorleftembedding +subtypep subtypeperm subtypepermoffintype subtypepermofsupport subtypepiequivpi +subtypepredicate subtypepreimage subtypeprod subtypeprodequivprod subtypeprodequivsigmasubtype +subtypeprop subtypequotientequivquotientsubtype subtyper subtyperestr @@ -76470,22 +127386,73 @@ subtypeunivequiv subtypeval subtyping subtypings +subu subuhgr +subuk subumgr subumgredg subunit +subuniv +subunivalg +subuniver +subunivers +subuniverse +subuniverses +subunsafe subupgr +subuset +subusetp subusgr +subux +subv subval +subvals +subvar subvariety subvarstatei +subvec +subver +subversively +subverts +subvf +subview +subvml +subvmr +subvp +subvpn +subvs +subvsp +subvv subwalk +subwffsof +subwhile subwiki +subwire +subwires +subwithequals +subwithequalsterm +subwithequalsterms subword +subwords +subwoset subx +subxb +subxfins +subxi +subxu +subxx suby subz +subzeta +subzn +subznat +subzss suc +suca +sucalt +sucb +sucbin +sucbnd succ succabove succabovecases @@ -76494,20 +127461,29 @@ succaboveorderemb succaboveorderiso succaddorder succchain +succclassic succdiffbounded +succe +succee succeed succeeded +succeeding succeeds succeedt succemb succeq succequiv succes +succeseor +succesful +succesfully success successelem successes +successfu successful successfully +successible successiffail successiffailwithmessage succession @@ -76515,17 +127491,22 @@ successive successively successor successors +successp +succf succfn +succformula succfunctor succfunequiv succg succi succinct +succispr succl succlg succm succn succnk +succnode succnotltepred succnotltezero succnthdefiningpoly @@ -76534,52 +127515,102 @@ succnthvalunits succorder succorderemb succpnat +succpred +succpredeq succpredorder succrec +succrelstr +succrepresentable succs succsi +succsized succsr succss +succstr succstruct succsub +succturing +succvars +<<<<<<< Updated upstream +======= succy +>>>>>>> Stashed changes succz sucd sucdifsn +sucdistmax +sucdistmin sucdom +suceed +suceeds sucel suceldisj +sucelements suceq suceqd suceqsneq +sucequiv +sucess +sucessive +sucevenodd sucex sucexb sucexeloni sucexg +<<<<<<< Updated upstream +======= sucf +>>>>>>> Stashed changes +sucfbd +sucfin +sucfindataormax +sucfinormax +sucfree sucg such +suchthat suchthatcorrect +suchthatcorrectofbounded suchthatmaybe +suchthatmaybeopt +suchthatmultiple suchthatnotcorrect +suchthatone +suci sucid sucidalt sucidaltvd sucidg +sucids sucidvd +sucinc +sucint +suciso +suck suclem suclim +suclistbin +suclistbindistrl +sucm sucmap sucmapleftuniq sucmapsuc +sucn sucneqond sucneqoni +sucnotzero +sucoddeven sucom sucomisnotcard sucon +sucp +sucpath +sucpos sucprc sucprcreg sucpre +sucpred +sucpw sucs sucsplit sucssel @@ -76588,15 +127619,22 @@ suctr suctralt suctraltcf suctraltcfvd +sucunielr sucunisn sucxpdom +suddenly +suddenyl +sudivision +sudo sudoku +sudokuset +<<<<<<< Updated upstream +======= sue +>>>>>>> Stashed changes suf suff suffacc -sufferterragovernment -suffertown suffi suffic suffice @@ -76606,29 +127644,60 @@ sufficient sufficiently suffix suffixagda +suffixarray +suffixat +suffixconvergestosame suffixed +suffixedelementspec +suffixedelementsspec suffixes suffixi +suffixing +suffixisclose +suffixlength +suffixof +suffixp +suffixsort +suffixstartindex suffs +suffwfg sufi +sufix +sugar suggest suggested +suggesting suggestion suggestions suggestiontext suggests suggeststeps suggstx +sugiyama suicide +suit +suita suitable suitablen +suitablestrrel suitably +suite +suites +suiv +suivant +sulfa sum suma sumable sumaddhom sumaddmonoidhom +sumagain +sumalg sumalgequiv +sumall +sumanglescorollary +sumanglesrec +sumarr sumarray sumarrowequivprodarrow sumarrowhomeomorphprodarrow @@ -76636,13 +127705,19 @@ sumarrowisometryequivprodarrow sumarrowlequivprodarrow sumassoc sumaux +sumbad +sumbit +sumbits sumbnd sumbool +sumboolp sumbot sumboxproddistrib sumbyresidueclasses +sumc sumcaseson sumcheck +sumcoefficients sumcoeffsexp sumcomm sumcompl @@ -76651,48 +127726,91 @@ sumcongrhom sumconst sumcoords sumcubes +sumcurry +sumdc sumdchr +sumdecryptcalls +sumdegrees +sumdiff sumdiffsubset +sumdigit +sumdigs sumdmdi sumdmdii sumdmdlem sumdualdistrib +sume +sumee +sumefct +sumefin +sumel sumelim sumelimcategory sumembeddingequivprodembeddingdisjoint sumembeddingequivsigmaembeddingrestricted +sumemdown sumempty +sumemup +sumen sumeq sumequiv sumequivoffintype sumequivsigmabool +sumer sumeval sumeven +sumevengt +sumevenle sumex +sumexp sumextend sumextendindex +sumey +sumf sumfc +sumfct sumfin +sumfindec +sumfing +sumfingen +sumfingenid +sumfingroup +sumfink +sumfinkcomm +sumfinsub sumfinsuppaddequivprodfinsupp sumfinsuppequivprodfinsupp sumfinsupplequivprodfinsupp +sumformula +sumfromto +sumfv sumg sumhash +sumhashdc sumhomeomorph sumi +sumid sumideriv +sumimage +sumin suminf suminl suminr suminv +suminvalg suminvpow +sumisgtetoparts sumisleft sumisoext sumisright sumk +sumkx suml sumleft +sumleftpos +sumleftpossuc sumlem +sumlemma sumlexassoc sumlexcomplleft sumlexcomplright @@ -76711,6 +127829,7 @@ sumliftrelinl sumliftrelinr sumliftrelmap sumlist +sumlistlength sumlocc sumltlt summ @@ -76719,103 +127838,190 @@ summab summability summabl summable +summableb +summablebdl +summablebdr +summablebn +summabled +summablee summablefamily summablelegeometric summablelocallyuniformlyon +summablem +summableml +summablemr +summablen summablenormicc +summablep summableuniformlyon +summablez +summablezr summand summands summap +summapid +summapimage +summaries +summarize +summarized summarizes summary -summarya summation summationfilter summatory +summed summedbid summedbidvector summedbidvectoralg summedbidvectorequivalence summedbidvectorrel -summin summing +summit summo +summodc +summodclem summodnegmod summolem +summotests +summx +summxe summz sumn +sumners sumnnodd sumno sumnodes +sumnorm sumnul +sumo sumodd sumof +sumofattempt +sumofattempts sumofconjugates sumofconjugatesequivariant +sumofcubes sumofmonom +sumor +sumoutside sumover +sumovfl sump sumpair +sumpairsinverse +sumpalg +sumpefct sumpiequivprodpi sumpilpequivprodlppilp +sumpm +sumpp sumpr sumprod sumproddistrib sumprodsum sumpsum +sumpt sumq sumquot sumr sumrb +sumrbdc +sumrbdclem sumrblem +sumrepl +sumresolvingbidequivalence +sumrestrictedonfunction +sumrestrictedtodomaininvariant +sumrfcte sumright +sumrightpos +sumrightpossuc sumringequiv +sumrmnl +sumrmnr +sumrn sums +sumse sumset +sumseta +sumsetb sumsetdiff sumsets sumshdig sumshdiglem sumshdiglema sumshdiglemb +sumshft sumsigmadistrib sumsmul sumsmulinv sumsmulx sumsmulxsmuly +sumsmx +sumsmxmr +sumsmxp +sumsmxs sumsn sumsnd sumsnf sumsns +sumsp sumspansn sumsplit +sumsplitdc +sumsplitl sumsq sumsqeq +sumsquaresnot sumss +sumstar +sumsto sumstructure sumsumsumcomm +sumsupanddown sumswap +sumto +sumtofin sumtoiter +sumton +sumtonispr sumtp sumtransform +sumturing +sumtype +sumunit sumv +sumval sumx sumy sumyes sumz +sumzero sumzerohom +sun +sunday sunf sunflower +sunfold suni +sunify sunio sunion sunionpowersetgi +sunique +<<<<<<< Updated upstream +======= sunsetpoint +>>>>>>> Stashed changes +suntil +sunzip suo sup +supa supadd supaddc +supb +supbelow supbothom supbothomclass supcl @@ -76823,39 +128029,105 @@ supclosed supclosure supclosurefun supclt +supclti supcnvlimsup supcnvlimsupmpt +supcommutativity +supcomplete supconvergenceclass supcvg +supd +supdate supdegre supdegree supdist +supdistributivity +supdom +supdomequh +supdomuh +supe +supeae +supelti +supemu +supen supeq super superadditive +superadmissible +superalgebraset +superbag superchain superclass +superclasses +superclassname +superclassnames +superclassp +supercompact +superconcept +supercondensed +supercore +supercrit +supere superexponential superfactoria superfactorial superficl superfluous +superformula +supergame +supergate +supergates +superglobular supergraph +supergroup supergrp +superi +superideal +superimposed +superimposedhalflines +superimposedrefl +superimposedsym +superimposedtrans +superint +superinterface +superinterfaces +superior superlinear +supermap supermartingale superpolynomialdecay superpos +superpose +superposing superposition +superprecise +superpseudorefs +superrange +superreln +superring +supers superscript +superscripts superscriptterm +supersede superseded superset superseti supersets +superst +superstep +supersteps +supersubtrait +supertrait supertype superuncl +superv +supervi +superviso +supervisor +superxor supeu +supeuti supex supexd supexpr @@ -76863,6 +128135,7 @@ supextensionofmaxsingleton supfil supfirege supfz +supgroup supgtoreq suphom suphomclass @@ -76872,36 +128145,77 @@ supicclub supiccub supindep supinf +supinfneg supirred supirredlowerset supiso supisoex supisolem +supisoti +supl +supla +suplat +suplats +suplatt +suplattice suple suplem suplesup +suploc +suplocexpr +suplocexprlem +suplocexprlemdisj +suplocexprlemell +suplocexprlemex +suplocexprlemloc +suplocexprlemlub +suplocexprlemml +suplocexprlemmu +suplocexprlemrl +suplocexprlemru +suplocexprlemss +suplocexprlemub +suplociccex +suplociccreex +suploclemres +suplocsr +suplocsrlem +suplocsrlemb +suplocsrlempr suplub +suplubti +supm +supmap supmax +supmaxti supminf +supminfex supminfrnmpt supminfxr supminfxrrnmpt supmo +supmoti supmul supmullem +supn supnfcls supnorm supnub supofbasis supofseq +supofsups supp +suppa suppbddbelow suppbottom suppco suppcoss suppd suppdm +suppe suppeqfsuppbi +supper +suppf suppfnss suppg suppi @@ -76909,40 +128223,75 @@ suppimacnv suppimacnvss suppiniseg supplement +supplementary +supplementarycommut +supplementaryeq +supplementaryrec +supplementation +supplementbc +supplementinequality +supplementofright +supplements +supplementsymmetric supplied +suppliedp supplier +supplies supply supplying suppmptcfin +suppn suppo suppofss suppofssd suppor support +supportab +supportable supportaddsubgroup supportbasic +supportd supportdim supportdiscretewithin supporte supported +supporteddbealgorithmsuites +supporteddecryptversion +supportedencryptversion supportedequivfinsupp supportedequivmvpolynomial +supportedesdkalgorithmsuites +supportel +supporter supporters supportgetequiv +supportgidl +supportgidr supporting supportlocallyfinitewithindomain +supportm +supportne +supportp supports +supportsadd supportset supportsstmt +supportssubtract supportwithindomain suppose supposed +supposedly suppovss +suppp supppreima supppreservation suppr suppress +suppressed +suppresses +suppressnotriggerwarning supprime +supps suppsnop suppss suppssdm @@ -76956,6 +128305,7 @@ suppssr suppssrg suppsssn supptop +supptpm suppun suppval suppvalbr @@ -76966,36 +128316,50 @@ suprcl suprcld suprclii suprclrnmpt +suprd supre suprema supremum +supremumisunique +supremums +supremumst +supremumt suprfinzcl suprleub +suprleubex suprleubii suprleubrd suprleubrnmpt suprlift suprltrp suprlub +suprlubex suprlubii suprlubrd suprnmpt suprnub +suprnubex suprnubii suproof suprub suprubd +suprubex suprubii suprubrnmpt suprzcl +suprzclex +suprzl suprzub +suprzubdc sups supseminorm supseq +supserset supset supseteq supsets supsn +supsnti supspansingleton supsr supsrlem @@ -77009,7 +128373,10 @@ supteq supto supub supubt +supubti +supunion supval +supx supxr supxrbnd supxrcl @@ -77034,65 +128401,214 @@ supxrub supxrubd supxrun supxrunb +supy +supzl sur +sura surd sure surely +surf surface +<<<<<<< Updated upstream +surft +surg +======= surfacechange +surft +surg surgeon +>>>>>>> Stashed changes surgery surj -surjcantorthm surje surjec surject surjecti +surjectio surjection surjections surjectiv surjective +surjectivecantor surjectiveinjective surjectiveonstalks surjectiveonwith +surjectivi surjectivity +surjetive +surjfns +surjfun +<<<<<<< Updated upstream +======= surjfuncset surjfuncsetfuncin surjfuncsetfuncsurj +>>>>>>> Stashed changes +surjfunpex +surjinj surjinv surjinvrighthom +surjmaps +surjoinv surjon +surjp +surjpex +surjpfun +surjpinv +surjpk +surp +surplus surprise surprised +surprises surprising +surprisingly +surrogate +surrogates +surround +surrounded +surroundedfan surrounding sursubmefmnd surveys survival +survived +survives +sus +susbet +susbsumes suslin susp +suspbool +suspboolchar +suspbouquet +suspcohomelim suspect suspend +suspendstep +suspension +suspensionax +suspensionprespectrum +suspfrompush +suspfun +suspfuncharac +suspfuncomp +suspfunconst +suspfunidfun +suspfuns suspicion +suspicious +suspiciously +suspmap +suspmappathp +suspmaps +susppushout +susppushoutsquare +susps +suspsmash +suspsmashcommiso +suspspan +suspsphere +suspsquare +suspsusps +susptopropelim +suspunit +suspunitchar sussmann +sust sustain sustained +sutt +suttf +suv +suzuki +sva +sval +svale svalid +svalist +svalp +svals svalue svar +svarli +svarlis +svarlist +svarm +svarma +svarmap +svars +svas +svassocs +svb +svblt +svc +svcall svdcmp +svdecomp +sve +sven +sveric sverismo +svex +svexarr +svexarrp +svexes +svexl +svexli +svexlis +svexlist +svexlistlist +svexlists +svexllist +svexp +svf +svfn svfun svinv +svjum +svjumpstate +svjumpstates +svl +svlc +svmask +svmods +svn +svp +svr +svref svrelfun svs +svset +svstack +svstacks +svstat +svstate +svstates +svstmt +svstmtlist +svstmts +svt +svtv +svtvname +svtvp +svtvpipe +svtvs +svwalk swa +swalk swamp swap +swapa +swapabs swapalts swapaltsp swapar +swapassocl +swapassocr swapat +swapbinp swapbvararray swapbvars swapciso @@ -77100,8 +128616,13 @@ swapcols swapcompinl swapcompinr swapcore +swapdiagonal +swapdouble swapelim +swapem +swapeq swapequiv +swapex swapf swapfactors swapfactorsaux @@ -77113,36 +128634,89 @@ swapffunca swapfid swapfida swapfiso +swapfn swapfoursyms swapfval +swapi swapindices +swapinner +swapinp +swapinvolutive +swapispr +swapk +swapl swapleaves swapleft +swapop +swappa swapped swapping +swapr +swapres swapright swaprows swaps +swapseq +swapset +swapspec +swapstr +<<<<<<< Updated upstream +swapswap +======= +>>>>>>> Stashed changes swapsyms +swaptree swaptrue swaptwowf +swapunitl +swapxy +swapxyk swb +<<<<<<< Updated upstream +======= swc +>>>>>>> Stashed changes +swca +swcase +swede +sweep +sweeping +sweet +sweeten +<<<<<<< Updated upstream +======= sweetriesling sweetwine +>>>>>>> Stashed changes sweirich swf +swfs +swhen swhile +swi +swich +swidg +swidgp +swing swingneg +swingoutsister swingpos +swit switch +switchcons switched +switcheroo +switching +switchispr +switchnil +switchpr +switness +swizzle +swl swoer swoord swopo swopolem -sword -sworst swoso swot swp @@ -77151,6 +128725,7 @@ swrdccat swrdccatfn swrdccatin swrdcl +swrdclg swrdco swrdf swrdfv @@ -77175,13 +128750,26 @@ swrdval swrdvalfn swrdwlk swrdwrdsymb +swrdwrdsymbg +sws +swtch +<<<<<<< Updated upstream +======= swv sww swx sxa +>>>>>>> Stashed changes sxbrsiga sxbrsigalem +sxcol sxcons +sxfrom +sxhash +sxline +sxmem +sxnt +sxs sxsiga sxsigon sxspecsy @@ -77232,12 +128820,15 @@ sylib sylibd sylibr sylibrd +syllepsis syllsimp sylnbi sylnbir sylnib sylnibr sylow +sylowj +sylowp syls sylsimp sylsyld @@ -77245,39 +128836,90 @@ sylvesermap sylvester sylvesterderiv sylvestermap +sylvesters sym +syma symalg +symb +symbl +symbo symbol +symbolalph +symbolenv symbolic +symbolically +symbolicstate +<<<<<<< Updated upstream +======= symbolicstring +>>>>>>> Stashed changes +symbolp +symbolps symbols +symbolsof +symbolsp +symbolsubstin +symbolt +symboltoo +symboltype +symbool symbs +symbsq symbss +symbt +symcd +symchar +symcharlist +symchars symcl symcli symclosure symclp +symcomp +symconst +symd symdif symdifass symdifcom symdifeq +symdifex +symdifexg symdiff +<<<<<<< Updated upstream +symdifference +======= symdiffe +symdifference symdiffi symdiffineg +>>>>>>> Stashed changes symdifid symdifv +symdifxor +symdistr +symentric +symenv +<<<<<<< Updated upstream +symeq +======= +>>>>>>> Stashed changes symequiv symequivsym +symerr +symetric symetrique +symetry symeval symevalb +symex symexe +symfun symg symgbas symgbasf symgbasfi symgbasmap +symgcd symgcl symgcntz symgcom @@ -77313,6 +128955,8 @@ symgov symgplusg symgpssefmnd symgressbas +symgroup +symgroupsiso symgrp symgsssg symgsubg @@ -77328,32 +128972,55 @@ symgvalstruct symi syminsertequiv syminterior +syminvo +syminvop +symiso symj symk +symkernel +symkey +symkeys +syml +symlemma +symlist +symlp symm symmat symmatrix symmcompofnondegenerate symmdiff +symme symmega symmequiv symmequivfunctor symmequivinverse symmetr symmetric +symmetrical symmetricalgebra symmetrically +symmetricbraiding symmetriccategory +symmetrich +symmetrichelper symmetricicc symmetricico symmetricioc symmetricioo +symmetrickeylength symmetrickind +symmetricmonoidal +symmetricmonoidalcategory +symmetricmonoidalwildcat symmetricofhasfinitecoproducts symmetricofhasfiniteproducts symmetricp symmetricpower +<<<<<<< Updated upstream +======= symmetricproperty +>>>>>>> Stashed changes +symmetricsigningkeystoadd symmetricsubalgebra symmetries symmetrify @@ -77361,6 +129028,7 @@ symmetrifycosta symmetrifycostar symmetrifyquiver symmetrifystar +symmetrix symmetrization symmetrize symmetrized @@ -77375,8 +129043,11 @@ symmhomeomorph symml symmm symmmeasurableequiv +symmonoidal symmstruct symmsymmetry +symmteric +symn symoptionsuccequiv symp sympartp @@ -77384,21 +129055,41 @@ symplcomp symplectic symplecticgroup symplecticj +symplex +symplexes sympoly +symprod +<<<<<<< Updated upstream +======= symptomcoma +>>>>>>> Stashed changes +sympushout symquadlem symr +symrefl symrefref symrel +symrelation symrelcoss symreleq symrelim symrels +symrelstr syms +symsim +symsp +symstr symsystem symt +symtable +symtrans +symunion +symunit symvar symvars +symwildeq +symx +symy syn synabs synapse @@ -77407,28 +129098,52 @@ syncd syncedsecs synchdadd synchdaddempty +synchronised +synchronization +synchronized +synco +syncr syncsamehdtl syncsingleheadadd syncstep +syncstepe +syncstepf +syncv +syncvi +syndef synenc syninc +synlr +synlri synonym synonymous synonyms +synonymtype synop +synp synpair +synps +synqiwn +synt +synta syntact syntactic syntactically syntacticpossibleworldforsemanticpossibleworlds +syntap syntax +syntaxcheck +syntaxkind syntaxn syntaxnodekind syntaxnodekinds syntaxp +syntaxps +syntaxversion synth synthappinstances synthassignedinstances +synthd synthesis synthesise synthesises @@ -77448,59 +129163,150 @@ synthesizeusingtactic synthesizing synthetic syntheticopaque +syntheto synthinst synthinstance synthinstanceq synthmonoidalerror synthresults synthsubsingletoninst +syntypes +<<<<<<< Updated upstream +syq +syr +======= syo syp syq +syr syrup syrupmixer +>>>>>>> Stashed changes sys syscall +syscalliomacros +syscls +sysextend +sysfile +sysi +sysii +sysprf +sysrel +sysret syssubjectsc +syst +syste system +systematic +systematically +systemce +systemcefml +systemcesubstok +systemconcl +systemd +systemdesubst +systemdicut +systemdicutcorrect +systemdisubst +systemi systemin +systemk systemloc systemout +systemp +systemproof systems systemsl +systemsound +systemt systemtests +systemu +systemverilog +systen +sysvars +sysweaken +sytanxp syth +sytnax +syym syz syzygies +szal +<<<<<<< Updated upstream +szbmgujtvujxjflxzopgsqgja +======= szazrzszezqlpdtcmdtrp szbmgujtvujxjflxzopgsqgja szdzizrdt szdzozmdt +>>>>>>> Stashed changes +szekeres szemer szemeredi szemerediregularity +szero szip +szipe +szipoas +<<<<<<< Updated upstream +======= sziznziztdt +>>>>>>> Stashed changes +szkey +szmielew szmod -szmzazxdt -szmzizndt -sznzazt szpilrajn -szszuzczcdt szymanski +taa tab +tabbrev +tabel +tabl table +tablearn tableau +tableaur +tableaux +tablebits +tableconstmult +tabledinvmultcol +tabledmultcol +tablei +tablelayout +tablename +tablep tables +tablesb +tablesbit +tablesbits tablesll +tablev +<<<<<<< Updated upstream +======= tablewine +>>>>>>> Stashed changes +tabm +taboo tabs +tabsize +tabular tabularconfig tabulate +<<<<<<< Updated upstream +tabulateindex +======= +>>>>>>> Stashed changes +tabulateoverlookup +tabulates +tabulation +tabulations tac +tacc taci tackle +tacname tacpos +tacro tacs tacseq tact @@ -77523,6 +129329,7 @@ tacticm tacticmodule tacticname tacticnode +tacticp tacticpastestring tacticrepeat tacticrfl @@ -77535,87 +129342,185 @@ tacticstr tacticswap tacticsyntax tactictodischarge -tactileperception tadd +taddc taddr +tadmit +tae +taf tag tagappfns +tagb +tagbody tagcg tagci +tage +tagenv tageq tagex tagext +tagfromcoordinator +tagfromparticipant tagged taggedk +taggedp taggedpartition taggedprepartit taggedprepartition +tagger tagging tagi taginv tagk +tagkeystring +tagkeytype +tagl +taglen +tagleneq +taglength tagmismatch tagn tagnazpudybdiwitdenpkfkpvubaxrttsro +tagp +tagresourceensurespublicly tags +tagset tagss +tagstate tagsuffix +tagsums +tagv +tagval +tagvaluestring +tagvaluetype +tagviolation tai +taifoi +taifol +taifoli tail +tailadmissible +tailcall tailcp +tailcpbis taild +taildefaultcp tailf tailfb +tailfn tailfval tailg +taili +tailing tailini +tailisnotsound +taillast +taille +tailm +tailofiteratetail tailopt tailored +tailp tailr tailrec +tailrecursive tails +tailsigmafield +tailsubstreamk tailt tailval +taint +taints +tak +takahashi take +takeassignnodrop +takeassignnodropnative takeaux +takeaway +takebranch taked takeend takeendwhile +takefill +takefirstfinord +takeghostparameter takei +takel +takelength +takeline +takemem taken takenatstep +takeord +takeparameter +takeright +takerows takes +takesadatatype +takesanat +takesparam +takestep +takesucn +takethis +takeunitlincl takeuntil +takeuntilincl +takeuti +takew takewhile +takewhilealways +takewhiled takewhilefn takewhilenot taking +takingtomissivesout takz +tal +talent talk talking +talks +tall +taller +talst talt +tamarack +tambi +tame tameenum tameenumfilter +tamep tan tanabsge tanadd +tanaddap +tanaddaplem tanaddlem tanarg tanatan tanbank tancl +tanclap +tanclapd tancld tand +tandpi tange +tangency tangent +tangentat tangentbundle tangentbundlecore tangentbundlemodelspacediffeomorph tangentbundlemodelspacehomeomorph +tangentcc tangentcone tangentconeat tangentcoordchange tangente +tangentline +tangentlinea tangentmap tangentmapwithin tangents @@ -77630,44 +129535,94 @@ tanhbnd tanhlt tanhpartialequiv tanhval +tanigawa tank +tann tanneg +tannegap tannery tannot tannpoly +tannumber tanord tanorderiso tanpartialhomeomorph +tanpi +tanpoly tanregt tanrpcl +tans +<<<<<<< Updated upstream +======= tant +>>>>>>> Stashed changes +tantamount tanval +tanvalap +tanx +tany tao tap +tapart tape +tapen +tapep +tapeq tapp +tappears taq tar +tarai +<<<<<<< Updated upstream +tardiness +======= +>>>>>>> Stashed changes +targ target +targetaddress targetaffinelocally +targetcat +targetconfig targeted +<<<<<<< Updated upstream +======= targetindividual +>>>>>>> Stashed changes +targetinstrset +targetissafe +targetistypesafe +targetlabel targetmachinesig targetname targetnames targetnew targetnode targetnodes +targetp +<<<<<<< Updated upstream +======= targetproof +>>>>>>> Stashed changes targets +targetselector +targetsem targetthreadpool +targetting targettype +targo targs +tarj +tarjan tarjandfs tarjanstate +tarjjuw tarlist +tarr tarray +tarraytuchar tarrow +tars +tarsk tarski tarskig tarskigb @@ -77676,26 +129631,55 @@ tarskigcb tarskigdim tarskige tarskimap +tarskiparallelflip +tarskiuniverse tas task +taskdecl +taskdecllist tasks +taspi +taspip +tat +<<<<<<< Updated upstream +======= tate +>>>>>>> Stashed changes tatom +tatulogy tatvaakfelhkjtxltqhuptgck tau tauchaincasessym tauchaininduct +taud +tauf +<<<<<<< Updated upstream +======= taughtby +>>>>>>> Stashed changes +taul +taulr +taulvisr +taum +taup taupackage taupi taupilem taupilemrplb +tauq taur +taurvisl +taus +taustar tausupportderivative taut +tautci tauti tauto tautocore +tautolo +tautolog +tautologi tautological tautologicalcocone tautologicalrelations @@ -77706,18 +129690,30 @@ tautologies tautologous tautology tautologyintotalvaluation +tautologyp tautotogrind tautotogrindregressions +tautp +tauvef taux +tax +taxa +taxi +taxicab +taxon +taxonom +tay tayl taylf taylfval taylfvallem +taylo taylor tayloralghom taylorcoeffwithin taylorcomp taylorequiv +taylorish taylorlinearequiv taylorseries taylorseriesrec @@ -77730,42 +129726,124 @@ taylply taylpval taylth taylthlem +tball tbase +tbaselist +tbc +tbform +tbh +tbi +tbig +tbin +tbindings +tbindt +tbinop +tbinter tbitriarlluhdmlkejutr +tbits tbl +tble tbled +tblemma +tblp +tbnd +tbnew +tbo +tbody +tbold tbool +tbordertype tbot tbound +tbr +tbranch +tbrmxrz +tbro tbs +tbsp tbsyl tbt +tbtheore +tbtheorem tbtru +tbuffer tbuildupi tbw tbwlem tbwsyl tca +tcall +tcallish +tcar tcard +tcase +tcast +tcaste +tcastk +tcastkv +tcb +tcbv +tcc +tccl +tccnf +tccs tcd +tcdecltime +tcdi +tcdr +tce tceilhalfelfzo tcel +tcenv +tceq +tcex tcf +tcfn +tcfnex tcfr tcg +tcgc +tchar tchnmfval tchplusg +tci tcid tcidm +tcinstance +tcirc +tcircle +tcl tclosed +tcm +tcmethod tcmin +tcn +tcnc +tcncg +tcncv +tcnd +tcnorm +tco tcoalg +tcocwl tcodomain +tcol tcomp +tcomparable +tcompare +<<<<<<< Updated upstream +======= tcomposite +>>>>>>> Stashed changes +tcon +tcona +tcong tconj tconn tcons +tconst +tcontext +tcorestep tcorres tcp tcphbas @@ -77782,58 +129860,131 @@ tcphsub tcphtopn tcphval tcphvsca +tcr tcrank +tcrc +tcreflexive +tcresolve +tcret tcs tcsni tcss +tcst tct +tctie +tctor tctr +tctrs tcu +tcunify tcvalg +tcvwalk +tcwalk +tcwalkstar +tcwalkstarwl tcwf +tdata tdb +tdba +tdbah +tdbal tdc tdconc tdd +tdec +tdecls +tdecode tdecs +tdef +tdefs tdeglem +tdelay +tdeletemimi +tdep +tdepth +tderef +tderiv +tdes +tdet tdev +tdgroup +tdh +tdhufhcyvhybcc tdisj +tdisk tdiv tdivexists tdivgoodp +tdla +tdlat +tdlen +tdnf tdnum tdomain +tdouble tdrgdrng tdrgring tdrgtmd tdrgtps tdrgtrg tdrgunit +tdrop tdropn tdropnd +tds tdseen +tdtsp +tea teach +<<<<<<< Updated upstream +======= +teacher +>>>>>>> Stashed changes +teadecrypt +teaencrypt team +teams tebivefdwlywibtk tech +techlemma +technially technical technicald technically -technician technique techniques +tecnico +tecoxbm +tecoxbmv tedious +tedium +tee +teehbr +teen +teeny +teeth +teh teichmuller teichmulleraux teichmullercauchy teichmullerfun teimlyfwmhjh tel +tele +teleo +telephone +<<<<<<< Updated upstream +======= telephonecommunication telephoning +>>>>>>> Stashed changes telephony +teleport +teleportation +teles +telesc telescope +telescopek telescopes telescoping telfsum @@ -77844,23 +129995,51 @@ telgsumfzs telgsumfzslem telgsums tell +telling tells tem temp +tempabs +tempd +tempdnf +tempenv temperate temperature temperaturef -temperaturemeasure tempereddistribution +tempest +tempfile +tempin +templat template +templatep templates +templong +tempmap +tempname temporal +<<<<<<< Updated upstream +======= temporalpart +>>>>>>> Stashed changes +temporaries temporarily temporary +tempout +temproal temps +tempsubf +tempsubfcl +tempsubforms +temptation +tempted +temptemp tempting +tempty +tempvar ten +tenagain +tenc tend tending tendo @@ -77925,6 +130104,8 @@ tendstouniforml tendstouniformly tendstouniformlyon tendstouniformlyonfilter +tenerlo +tenoncemore tens tenso tensor @@ -77959,6 +130140,7 @@ tensorequivend tensorequivmul tensorequivspan tensorequivsum +tensorfun tensorfunc tensorh tensorhom @@ -77998,11 +130180,13 @@ tensorleftunmopiso tensorlid tensorlift tensorlinederivtwo +tensorlist tensormap tensormodelofhascoeffsequiv tensormodelofhascoeffshom tensormodelofhascoeffsinv tensormonoidal +tensormulthom tensoro tensorobj tensorobjcomp @@ -78059,15 +130243,28 @@ tensorunitconvolutionunit tensorunitimpl tensorunitiso tensorunitright -tent tenth +tents tenv tenvc tenve +tenvlift +tenvm +tenvs tenvt +tenvv +teorema +teoremas +teps teq +teqmon +tequiv ter +terd term +termal +termalg +termalgebra termc termcarweu termcat @@ -78090,22 +130287,43 @@ termcterm termcthin termcthind termctx +termd termdefinable +termdep +termdiff termelab termelabm termelabresult +termeq termequality termequivcl termequivclgen +termeval +termfsbimorph +termfswimorph +termfswsbimorph termfucterm termg +termhint termi +termiantes termie +termify +termimage +termimageissub +termimagey +termin termina terminal +terminalabeliancategory +terminaladditivecategory +terminalalph +terminalcategory terminalcomparison +terminald terminalequiv terminalhom +terminali terminaliffunique terminaliso terminalisoisterminal @@ -78113,36 +130331,66 @@ terminalisoofuniqueofisdiscrete terminalisopunit terminalistermi terminalisterminal +terminallanguage terminallimitcone terminalnformcases +terminalobj +terminalobject terminalofuniqueofreflects terminalopofinitial +terminalp terminalreplacement terminalreplacementoutcome terminals +terminalset +terminalstring terminaltogrind terminalunopofinitial +terminat terminate terminated terminatedat +terminatedp terminates terminatesd terminatesi terminatesofrat +terminateson terminatesrecon terminatess +terminati terminating +terminatingprograms +terminatingreduction +terminatio termination terminationg +terminationlessafterexhaustiveunitpropagate +terminationlessstate terminationrule terminations +terminator +terminators +termind +termini +terminination +termino terminology +terminop termis termlem termlemma termlemmas +termlist +termlistp termm +termmeas +termmeasure +termmod +<<<<<<< Updated upstream +======= termmset +>>>>>>> Stashed changes termo termoeu termoffreecommring @@ -78154,77 +130402,648 @@ termoo termopropd termopropdlem termorcl +termord +termorder termoval +termp termparser termprecandreprs +termps +termrec +termrecsubs termreduce termrel terms +termsem +termset termsetinset +termsi +termsize +termsmap +termsofmaxdepth +termsofs +termsp termstate termsubst +termsymbolsof termtogrindparam +termval termwise +tern +terna ternary +ternaryfalse +ternaryfieldex +ternaryfieldstr +ternaryp +ternaryreal +ternarytrue +ternaryunknown +ternop +terpri +terr terrible +<<<<<<< Updated upstream +terrrrrrible +tertiaryp +tes +======= terrorist terroristgroup +terrrrrrible +tertiaryp +tes tesl +>>>>>>> Stashed changes +tesla +tesq +tesst test +testa +testab testable +testabstract +testactualrotate +testactualshifting +testadd +testaeq testagainstnn +testaggregatearrayupdate +testaggregatefieldupdate +testaggregatemultiarrayupdate +testall +testallcases +testallchar +testallocatednessaxioms +testaneq +testany +testaok +testapply +testapproximatefp +testapproximateliteralsyntaxrules +testarithmeticoperations +testarithmeticsignedzeros +testarray +testarrayelements +testarrayf +testarraylambda +testassignmentstatements +testassignorhalt +testat +testattributes +testattributesvardecls +testautoconversions +testautoinit +testb +testbasicliteralassignment +testbb +testbernoulli +testbernoulliexpneg +testbernoulliexpnegle +testbernoulliiswithin testbit +testbitwisewithpreconditions +testbok +testbool +testboolbool +testboundaryvalues +testboxassignment +testbv +testbyrequires +testbyreveal +testbyte +testc +testcalc +testcaller +testcallopaqueassert +testcalls +testcallswithfancylhss +testcases +testchaining testchar +testcharnewtype +testcharsubset +testchecker +testclass +testclasswcx +testclasswcy +testco +testcodatatype +testcok +testcokb +testcokc +testcollectionemptiness +testcollectionsghost +testcomparefloat +testcompareimmediate +testcompareregister +testcomparisonoperations +testcompilationtruncations +testcompile +testcompiled +testcompiledequalityfull +testcompiledequalitynocheck +testcompiledequalitypreconditions +testcompiledequalitywithnancheck +testcomprehensions +testconcat testcond +testconditionalequality +testconditionalexpressions +testconflictingnames +testconst +testconstraintssimple +testconstructor +testcontents +testcontrolflow +testcontrolflowcase +testconversions +testcovariance +testcovariancez +testd +testdafnyvsieee +testdatatype +testdatatypeghost +testdec +testdecodeillformedsequence +testdecryptmanifest +testdecryptmaterials +testdecrypts +testdefaultarrayvalues +testdefaultvalue +testdefaultvalues +testdenormalizednumbers +testderivedvaluepreconditions +testdestructor +testdestructors +testdigest +testdigit +testdiscretegaussian +testdiscretelaplace +testdiscriminators +testdisequality +testdisjointtypeargument +testdisplayinit +testdiv +testdivmodint +testdivmoduint +testdom +testdriver +teste tested +testef +testelim +testempiricaliswithin +testencodescalarvalue +testencryptmanifest +testencrypts +testepsilonvalue +testeq +testequality +testequalityinspecifications +testequalityofsomenonarraystoo +tester +testexactfp +testexception +testexpect +testexplicitassignmenterror +testexplicitconversions +testexplosiveunion +testexpressionparsing +testexternclass +testextract +testextremeprecisioncases +testextremevalues +testf +testfagain testfalsehelper +testfields +testfilterpredicate +testfinaleqn +testfinancialcalculations +testfisheryates +testfn +testforallstatement +testform +testfp +testframeaxiom +testframeaxiomnew +testfrom +testfromseq +testfromset +testfromtraits +testfun +testfuncmoreparams testfunction +testfunctioninit +testg +testgeneralarrow +testgenerateencryptmanifest +testgeneric +testgenericdefault +testgenprop +testgetencryptionmaterials +testghost +testghostables +testghostdestructors +testghostequality +testghostfunction +testghostreflexiveequality +testghostsetequality +testhardcodedliterals +testharness +testi +testieeeequality +testieeeequalitymethod +testieeespecialcases +testimappropertymembership +testimappropertynonempty +testimapsubtraction +testimapunion +testin +testindefof +testindependence +testindexof +testinequality +testinequalityerror +testinexactliteralsasarguments +testinexactliteralsinarrays +testinexactliteralsinexpressions +testinexactliteralsrequiretilde +testinexactrealtofp +testinfinitybehavior testing +testinitializationmethods +testinitialize +testinjective +testinmultiset +testinstance +testinstar +testint +testinter +testinttofp +testinvaliddatakeyfailurecase +testis +testisdigit +testiso +testitall +testitera +testiterb +testiterc +testk +testl +testlargeinttofp +testle +testleast +testleastzero +testlemmamoreparams +testlemmas +testlength +testlesseq +testlib +testlibrary testlist +testliteralarithmetic +testliteralprecisionboundaries +testloop +testloopexpressions +testlt +testm +testmain +testmainbitwise +testmany +testmap +testmapmerge +testmapmergesubtraction +testmapmultioccurrences +testmappropertycardinality +testmappropertymembership +testmappropertynonempty +testmapsubtraction +testmapunion +testmatchdestructions +testmatchexpr +testmatchstmt +testmatrix +testmatrixautoinit +testmatrixelements +testmatrixtypeparameter +testme +testmembers +testmethod +testmethodparameterpredicates +testmethodparameters +testmethods +testmissingmethods +testmissingvoidmethods +testmixedarithmetic +testmixedcontexts +testmod +testmodule +testmore +testmpost +testmul +testmulti +testmultiset +testmutualexclusivity +testmyclass +testmyconstrainedint +testmyfilesystem +testmyint +testmymap +testmynewtypeint +testmytest +testn +testnameresolution +testnanbehavior +testnanequality +testnegationwithapproximateprefix +testnesteddatatype +testnestedexpressions +testnestedlet +testnesting +testnew +testnewtypereal +testnonassociativity +testnonautoinit +testnotnot +testnotreported +testnullis +testnullsamongkeys +testnullsamongvalues +testnumericdestructornames +testo +testobj +testone +testonly +testonlyafter +testonlyafterbefore +testonlybefore +testonlybeforeafter +testonlybeforeonlybefore +testonlyonlybefore testop +testopaque +testopt +testordinal +testother +testothers +testoverflowunderflow +testoverridesnoprint +testoverriding +testp +testparent testparsemodule +testpartialarrow +testphone +testplus +testpolyfun +testpolyfunset testpool +testpositionals +testpost +testpower +testpre +testprecaller +testprecisionlimits +testpredicateswithstaticmethods +testprefixpredicatesp +testprefixpredicatesq +testprefixpredicatesr +testprefixpredicatesv +testprod +testprog +testprop +testprovedinaltergo +testq +testr +testrange +testreal +testrealisint +testreals +testrealvsfp +testreferenceequality +testreplace +testresourcecleanup +testresourcecleanuploop +testresourcecleanuploopcomplex +testresourcecleanuploopnative +testresourcecleanupnative +testresult +testreveal +testrevealed +testrhsisinherited +testroundingerrors +testroundtrip tests +testsandconversions +testscientificcomputations +testscopingofattribute +testsearch +testselect +testseq +testseqf +testseqlambda +testseqofclass +testsequenceequality +testsequences +testset +testsetequality +testsets +testsexp +testshadowassign +testshadowassignsuchthat +testshadowelephant +testshadowfunctioncall +testshadowmethodcall +testsiblings +testsignedzerobehavior +testsignedzeropreconditionpattern +testsingletons +testsmallestvalues +testsnoreads +testspecial +testspecialcase +testspecialoperations +testspecialvaluecomparisons +testspecialvalueproperties +testspecialvalues +testspecificationwf +teststandardlibrarylesspredicate +teststarstar +teststart +teststatementparsing +teststatic +teststaticarithmeticmethods +teststaticequalmethod +teststdin +teststring +teststrings +testsubstring testsuchthat +testswheretriggersmatter +testt +testtacmod testtacticseq +testtargettypesandconstructors +testterm +testtest +testthenl +testthm +testtildenotallowedonreal +testtildeonexactfp +testtildeonexactliterals +testtildeonnonfloatingpointtypes +testtildeonnonliterals +testtildetypeinferenceambiguity +testto +testtoreinre +testtotalarrow +testtraits +testtriggerwithlambdaexpression testtruehelper +testtype +testtypeawarevalidation +testtypecheckingindesugaredterm +testtypeinference +testtypeinteractions +testtypeparameter +testtypeparameters +testtypesthemselves +testu +testulpandmachineepsilon +testuniform +testuniforminterval +testuniformmean +testuniformpoweroftwo +testuniformpoweroftwomean +testunion +testunit +testupdate +testusefulderivedconstants +testv +testval +testvar +testvariabledeclarations +testvariabledeclarationsoundness +testvariousflavorsofindices +testvars +testw +testwraparound +testwrapper +testx +testxon +testy +testzerovalues +teta tetrahedral tetrahedron teven +teventend +teventresponse +tew +tewnscj tex +<<<<<<< Updated upstream +======= texaswine +>>>>>>> Stashed changes +texists +texn +texp texpr text textbased textbasedlinter textbook textbooks +textio +textpost texttests +tfact tfae tfaehaveiddecl tfaehaveidlhs tfaelist tfaetype +tfall tfalse +tfalsum +tfd +tfe +tff tfff tfft tfi tfin +tfincl tfindes +tfindi tfinds tfindsd tfindsg +tfineq +tfinex tfinite tfinited +tfinlefin +tfinltfin +tfinltfinlem +tfinnn +tfinnnlem +tfinnnul +tfinnul +tfinprop +tfinpw +tfinrelkex +tfinsuc +tfirst +tfirstn tfis tfisg tfisi +tfix tfklxsvztcopclbtit +tfl +tflg tfloat +tfn +tfof +tforall tfovinbvqwbpwcwqt +tfp tfr +tfrcl +tfrcldm +tfrcllemaccex +tfrcllembacc +tfrcllembex +tfrcllembfn +tfrcllembxssdm +tfrcllemex +tfrcllemres +tfrcllemssrecs +tfrcllemsucaccv +tfrcllemsucfn +tfrcllemubacc tfrdnepvurkbwtlxfw +tfresh +tfrex +tfrexlem +tfrfun +tfri tfrlem +tfrlemi +tfrlemibacc +tfrlemibex +tfrlemibfn +tfrlemibxssdm +tfrlemiex +tfrlemisucaccv +tfrlemisucfn +tfrlemiubacc +tfrom +tfs tfsconcat tfsconcatb tfsconcatfn @@ -78236,12 +131055,24 @@ tfsconcatrn tfsconcatrnss tfsconcatrnsson tfsconcatun +tfsl tfslim +tfsm +tfsmf tfsnfin +tfsr tfst +tfsuc +tft tftf tftt +tfu +tfull +tfun +tfunc +tfunction tfup +tfv tfyjktukrlfhsptbarvtqtgjlbvuznyoshv tgasa tgblthelfgott @@ -78282,6 +131113,7 @@ tge tgellng tgelrnln tgfiss +tgflip tgfscgr tghilberti tgidinside @@ -78290,6 +131122,7 @@ tgifscgr tgioo tgisline tgiun +tgjisok tgjustc tgjustf tgjustr @@ -78314,6 +131147,7 @@ tglnne tglnpt tglnssp tglnunirn +tglobals tglowdim tgoldbach tgoldbachgnn @@ -78355,13 +131189,17 @@ tgsas tgsegconeq tgss tgsss +tgsymmetric tgt +tgtapi tgtdecl +tgtexp tgtexpr tgtexprofiso tgtfield tgtfields tgthasloosebvars +tgthyp tgti tgtj tgtlemma @@ -78370,75 +131208,220 @@ tgtm tgtmap tgtnodeof tgtnodeofv +tgtnt +tgtof +tgtoftr +tgtoftrfrom tgtop tgtopon +tgtpf tgtrisegint tgts +tgtty tgtvars tgtwyrs tgval +tgvalex tha +thaddelleq thales thalt +thalted +tham than +thank thanks +thanp +thans thansubset that thatd thatm +thats +thatset +thb +thcohere +thcompell thd +thdesdiv +thdobelleq the +thead +theade +theap +thearray +thearrayi +thearrayp +thebreaker +theceq +thecset +thedriver theeasyhalf theeq +theeqi +theeqsymbof +theft +theftone +<<<<<<< Updated upstream +======= thegame +>>>>>>> Stashed changes +theghostcantotallyseeyou thehardhalf thei their +theirs +theitem +<<<<<<< Updated upstream +======= thekb +>>>>>>> Stashed changes +thel thelhs them +themain +<<<<<<< Updated upstream +======= theme +>>>>>>> Stashed changes +themethod themselves then +thenc +thenerror +thenft +thenftboth +thenl +thenordering +thenorsymbof thenp +thenpart +thens +thent theo theor theore theorem +theoreme +theoremes theoremform +theoremhood +theoremj theoremname +theoremouter +theoremp theorems +theoremseq +theoremsp theoretic theoretically +theorie theories +theormes +theorms theory theorydelta +theoryname +theoryp +theother +<<<<<<< Updated upstream +theqcomp +thequiv +ther +======= theprop theprototypicalfurpelt theprototypicalshavingrazor +theqcomp +thequiv ther therapeuticprocess +>>>>>>> Stashed changes +therapy there +thereby therefore +therein +thereis +thereisaminimum +thereisasmallest +thereisasmallestinmultiset +thereisasmallestint +thereisnobodyintheclub thereof +thereom therhs +therm thermostat +theroem +thes these +theshelf +thesi thesis +<<<<<<< Updated upstream +======= thesisa +>>>>>>> Stashed changes +thests theta thetaatm +thetafdw thetaif +thetaiftt +thetaifw +thetaifwt +thetaifzo +thetaifzot +thetal +thetals +thetapar +thetapartt +thetaparw +thetaparwl +thetaparwt +thetaparzo +thetaparzol +thetaparzot +thetas thetasatm thetasch thetasd thetasdone thetaseq +thetaseqtt +thetaseqw +thetaseqwd +thetaseqwt +thetaseqzo +thetaseqzod +thetaseqzot +thetaspar thetasseqd thetasseqi thetat +thetawhile +thetawhilew +thetawhilezot +thetazoch +thetazopart +thetazoseqd +thetazoseqi +thetype +theword they +thf +<<<<<<< Updated upstream +======= thftype +>>>>>>> Stashed changes +thg +thgdiff +thgf +thgfa +thgfx +thhe +thhm thi thicke thicken @@ -78472,66 +131455,120 @@ thincpropd thincsect thincssc thing +thingp things thingy think thinking thinkn thinks +thinly +thinmx thinning +thinnings thinskeleton thinskeletonorderiso thinskeletonpartialorder +thir third thirdisothm +thirdpoint thirds thirdtomax +thirteen thirty +thirtytwobyte this +thisaintgoinnowhere thisattr thisi +thisinstr thism +thither +thl thlbas thlle thlleval thloc thlval thm +thmain +thmaingen thmargs thmdecl +thmhints thmid thminfo +thmk thmname +thmon thmorigin thmproof thms thmty +thmv +thmz +thn +thne +thnonsingular +thnotused +tholds thomas +thompson +thoncurve +thopf thoprpmjppw +thos those though thought +thousand thpi thpiminply thpiminplylem thpinconstr thpinconstrlem thpiold +thpq +thproperty thr thrashing thrcost +thre +threa thread +threade +threaded +threadedp +threadevent +threadf +threadgroup +threadhalt threadhalted +threadk +threadlocal threadperm threadpermf threadpool +threadres threads threadstep +threadstepe +threadstepf +threadwff three +threea threeapfree +threearrows +threeb +threecases +threeembeddedtriangles +threef +threefix threefold threegpfree threehalves +threeidem threelefthole threeleftholezipwf threemiddlehole @@ -78546,23 +131583,28 @@ threeshortaddtwo threeshortaddtwolong threeshortaddtwolongroot threeway +threppoint thresh threshold thresholdi +thresholds threw thrice thro +throug through throughout -throughoutmovement throughput throw +throwable throwaborttactic throwapplyerror +throwaway throwcongrex throwerror throwerrorat throwet +throwexc throwfunctionexpected throwing throwmismatch @@ -78570,7 +131612,11 @@ thrown thrownogoalstobesolved thrownone throwonnomatch +throwp throwpeelerror +throwreds +throwredsnull +throwredsthrow throwrule throws throwtacticex @@ -78582,126 +131628,288 @@ throwunsupported throwunsupportedsyntax thrst thru +<<<<<<< Updated upstream +======= thruster +>>>>>>> Stashed changes +thrwnotin +ths +thu +thue +thumb +thumbee thumper +thunder thunk +thunkable +thunkblock +thunkgen +thunkgensizeantimonotonicnone +thunkgensizemonotonic +thunkgensizemonotonicopt +thunkgenunsized +thunking +thunkop +thunkp +thunks +thunktag +thursday thus +thvalid +thw +thwf +thx thy +thyh +thyof tia +tic tick +tickc ticket +tickets ticks +tickt +ticl ticom ticonc tictactoe tid +tidi +tidn +tids +tidx tidy tie +tiebids +tiebidsalg +tiebidsbridginglemma tiebreaker tiebreakers +tiebreakinggivessingleton tiei +tierney ties +tiestoeven tietze tietzeextension tietzeextensionclass tif +tiff +tig +tigh +tigher tight +tighte tighten +tightened +tightening +tightens tighter +tightly tightness +tightneutralequiv +tightprefix +tighttrueempty +tigthen +tik tilde tildefinsupp tildeself +tildet tile +tiles tiling till tilt tilted +tim time +timeaxis +timebs timed +<<<<<<< Updated upstream +======= timedelay timedelayedby +>>>>>>> Stashed changes +timediff +timedo +timedout +timedoutp timef -timehasnoendmt timei +<<<<<<< Updated upstream +======= timeinterval +>>>>>>> Stashed changes +timeless timelike +timelimit +timeof +timeofcycle timeout timeouts -timepoint timer times timesd timesdistributesoverpdifference timesgt timesi +timesince timesl timeslr timesmod +timeso +timesout +timespan timesr timess timestamp +timestamps +timestampsrcvdfinite timestep +timestwo +timesubst timet +<<<<<<< Updated upstream +timetable +======= +>>>>>>> Stashed changes +timetoliveattributename +timez +timid +timing +timingstmt timoio +timplies +timpls +timulg +tin +tinc tinit +tinsert +tinst +tinstr +tinstt tint tinv +tiny +tio +<<<<<<< Updated upstream +======= tion +>>>>>>> Stashed changes tip tips +tired tiroirs +tis tisj tisjsi tiszero tit +titable titi titj title titlepaper titlepost +tive +tiwwfyq tiy +tjena tjnbpbu tjplco tjqrva +tjs tjsi tjti +tjvm tkd +tkf tki +tksym tkt +tktlock tla +tlam tlaplus tlast +tlb tlbnd +tlbp +tlc +tlcons tld +tldr +tle +tleaf +tleast +tlecg +tleft tleile tlektvatpmiuxtsvnjrfoipaglhcwxtmliwvqusxic tlelt +tlen +tlenc tlength tlengthd +tlet +tlevel +tlfix +tlg +<<<<<<< Updated upstream +======= tlh +>>>>>>> Stashed changes tli +tlilist +tlilistcons +tlilistnil +tline tlist +tlistda tljrubkkqrjjdrpqvjpfoeqi +tll +<<<<<<< Updated upstream +======= tllist +>>>>>>> Stashed changes tlmlmod tlmscatps tlmtgp tlmtmd tlmtps tlmtrg +tlnil +tlo +tloc +tlocal +tlocals tlock +tlocs tlong tlookup +tlp +tlpats +tlpcdr +tlpm tls tlt tltl tltnle tlvl +tmaof tmap +tmask +tmass tmax +tmbody tmc +tmcarrier tmcl +tmconst tmd tmdalt tmdcn @@ -78712,22 +131920,61 @@ tmdmulg tmdtopon tmdtps tmeas +tmem +tmenv +tmequiv +tmf +tmfrag tmfv +tmi +tmid +tmids +tmif tmin +tminsm +tminus +tmissive +tmissives +tmissivesp +tmissivespx +tmissivesy +tmissves tml tmle tmlemmas tmmsg tmmul +tmn tmnum tmod +tmodel +tmop +tmovabs tmp +tmpair +tmpalloc +tmpl +tmplen +tmplsu +tmplsubsts +tmpmem tmps +tmpval +tmr +tmrec +tmrules tms tmsbas +tmscfv +tmsd tmsds +tmsg +tmsig tmslem tmsms +tmsof +tmsr +tmstepf tmstopn tmsubst tmsval @@ -78735,17 +131982,27 @@ tmsxms tmsxps tmsxpsmopn tmsxpsval +tmt +tmterminates tmu tmul tmulb tmulequiv tmulequivdep tmults +tmval +tmvar +tmvof +tmvs +tmwhile tnat tncp +tncveqnc tnd tndcomm tne +tneqd +tnext tng tngbas tngdim @@ -78767,10 +132024,17 @@ tngtset tngval tngvsca tnil +tno tnode tnot tnp tns +tnt +tnth +tnthp +tnum +tnv +tnz toabs toabsolutevalue toabstractsimplicialcomplex @@ -78813,6 +132077,7 @@ toaddmonoidhomclass toaddmonoidhomequiv toaddmonoidmom toaddmonoidwithone +toaddr toaddsubgroup toaddsubmonoid toaddsubsemigroup @@ -78835,6 +132100,7 @@ toaffinel toaffinelift toaffinemap toaffinesubspace +toafunctor toalexandrovdiscrete toalg toalgaut @@ -78862,12 +132128,22 @@ toappend toappexpr toapply toarithmeticfunction +toarm +toarnstring toarray toarrow toarrowarrowfunctor +toarrowext +toasclist +toattributemap +toattributemapandtobranchkeycontextareinverse +toattributemapiscorrect toaut toauthomeo toautmulequiv +toawskmsecdh +toawskmsmrkawarediscovery +toawskmsrsa tob tobase tobasechange @@ -78880,6 +132156,7 @@ tobcf tobd tobdddistlat tobddlat +tobeaconkeymaterials tobialgequiv tobialghom tobialgiso @@ -78888,6 +132165,8 @@ tobiconefunctor tobiconeisbilimit tobiconeiscolimit tobiconeislimit +tobifunctor +tobig tobiheytingalgebra tobiheytinghomclass tobilin @@ -78903,8 +132182,12 @@ tobipointed tobiprod tobits tobitvec +tobitvector +tobl +toblack toblock toblocks +tobody toboolalg tobooleanalgebra toboolring @@ -78918,10 +132201,18 @@ toboundedcontinuousfunctionlm toboundedlatticehom toboundedorderhom toboxadditive +tobr tobracket tobraidedcategory +tobranchkeycontext +tobranchkeycontextiscorrect +tobranchkeymaterials +tobuffer tobumpcovering +tobyte +tobytes toc +tocan tocarasiga tocardinalinterfilter tocases @@ -78930,9 +132221,11 @@ tocatcenter tocatcommsqover tocatexpr tocathom +toccata tocentralizer tocentroidhom tochainhomotopy +tochannel tochar tocharacterspace tocharnetwonf @@ -78959,6 +132252,7 @@ tocloseds toclosedsubmodule toclosureoperator tocls +tocmm toco tocoalgebra tocoalgebraof @@ -79043,6 +132337,7 @@ toconfigwithkey toconj toconjact toconnectedcomponents +toconst toconstantval toconstmulname toconstprodcontinuouslinearmap @@ -79092,6 +132387,7 @@ tocontmdiffmap tocontperfpair toconv toconvexcone +tocoprime tocopy tocore tocostring @@ -79108,7 +132404,9 @@ tocowriter tocoxetersystem tocprehil toct +tocube tocwcomplex +tocwl tocyc tocyccntz tocycf @@ -79119,12 +132417,16 @@ tocycles tocyclesnattrans tocycval tod +today todecidableeq todecidablele todecidablelt todecimalchars todeclaration todecomposition +todecrypttests +todecrypttestvector +todecrypttestvectors todeg todeglex todelay @@ -79149,6 +132451,8 @@ todilation todilationequiv todirectlimit todirectsum +todirre +todiscoveryfilter todist todistriblattice todistribmulaction @@ -79188,6 +132492,10 @@ toenat toenataux toencodable toencoding +toencrypteddatakey +toencrypttest +toencrypttests +toencrypttestvector toend toendhom toendo @@ -79199,9 +132507,12 @@ toennrealorderembedding toennrealringhom toennrealvectormeasure toenrichedcategory +toenum +toenumalt toenumfinset toenvelgroup toeplitz +toeq toeqpf toequal toequiv @@ -79223,6 +132534,7 @@ toeventualranges toeventualrangessectionsequiv toexistsaddofle toexitcode +toexp toexposed toexpr toexprcore @@ -79247,6 +132559,7 @@ tofilterdistortion tofilterdistortioniunion tofilteriunion tofin +tofinexc tofinite tofiniteaux tofiniteindexnormalsubgroup @@ -79268,6 +132581,7 @@ tofinunsafe toflag tofloat tofloorsemiring +tofmset tofmvarid tofn toforeign @@ -79275,9 +132589,18 @@ toformalmultilinearseries toformalmultilinearseriesofmultilinear toformat toformula +tofp +tofrac +tofracb +tofracd +tofracm +tofracmn +tofracmnn +tofracn tofractionring tofractionringalgequiv tofractionringringequiv +tofracx toframe tofreeabeliangroup tofreecommring @@ -79285,12 +132608,16 @@ tofreegroup tofreerefl tofreesemigroup tofreeyonedacoproduct +tofrom +tofromid +tofromterm tofu tofun tofunalghom tofunaslinearmap tofunaux tofunbilinear +tofunc tofunction tofunctor tofunctortocategoricalpullback @@ -79300,6 +132627,7 @@ tofunlike tofunline tofunlinear tofunnames +tog togaloiscoinsertion togaloisinsertion togcddomain @@ -79313,7 +132641,12 @@ togenerators togerm togermmonoidhom together +togethera +togg +toggl toggle +toggles +togglesign toggling toghspace togl @@ -79331,6 +132664,7 @@ togradedobjectfunctor togradedobjectmap togradedringhom tograph +togray togrindaddrightcancel togrindcommring togrindfield @@ -79344,6 +132678,7 @@ togroupextension togroupseminorm togrp togrpiso +toh tohamming tohasbasis tohasdistribneg @@ -79355,6 +132690,8 @@ tohaswellfounded toheadindex toheqpf tohereditarilylindelof +tohex +tohexstring toheytingalgebra tohilbertbasis tohocat @@ -79386,16 +132723,20 @@ tohopfalgequiv tohopfalgiso tohspace toi +toiaddr toic toicodiv toicom toicomod toideal toidpunitequiv +toiled toimage toimageaux toin toinc +toindexseq +toindexseqtouint toinductive toinductivelimit toinfhom @@ -79502,6 +132843,7 @@ toixxmod tojacobian tojordandecomposition tojordandecompositionequiv +tojson tok tokaehler tokaroubi @@ -79510,21 +132852,49 @@ tokaroubiequivalence tokaroubiiso tokaroubinondegcomplexfunctorison tokaroubinondegcomplexison +tokcheck +tokcheckl token +tokenfactory +tokenise tokenize +tokenlist +<<<<<<< Updated upstream +tokenring +======= +>>>>>>> Stashed changes tokens +tokentype +tokeof +tokeq toker tokerislocalization tokerislocalized tokerlocalized tokernel tokernelsubobject +tokeydescription +tokeymaterial +tokeyring +tokfalse +tokfn +tokidp tokleisli tokleislicompfromkleisliisoself +toknil toknownnature +tokpragma +tokprec +tokrest toks +tokss +tokstr +tokstream +toksymp +tokvs tol tolambda +tolarge tolargerspace tolat tolattice @@ -79536,11 +132906,21 @@ tolawson tolax tolaxmonoidal tolaxmonoidalfunctor +tolcat +tolclass +told tole toleft toleftcancelmonoid toleftcancelsemigroup toleftfun +toler +tolerance +toleranceex +tolerancerel +tolerancerels +tolerate +tolerates tolevel tolex tolexaddequiv @@ -79597,7 +132977,9 @@ tolinhomflip tolinofinv tolipschitzwith tolist +tolista tolistappend +tolistbyte tolistorstream tollens toloc @@ -79625,10 +133007,15 @@ tolphom tolplin tolplinalgequiv tolrshom +tolset +tolsets +tolstr tolt +tolv tom tomagmacatiso tomap +tomasulo tomat tomatrix tomatrixalgequiv @@ -79641,6 +133028,7 @@ tomatrixorthonormal tomatrixright tomatrixseminormedaddcommgroup tomax +tomaybe tome tomeasurable tomeasurableequiv @@ -79653,6 +133041,7 @@ tomeasureequiv tomeasureoflezero tomeasureofzerole tomeasurepreserving +tomem tomeromorphicnfat tomeromorphicnfon tomessagedata @@ -79661,6 +133050,8 @@ tometricspace tomiddle tomiddlehom tomin +tominuspred +tomissives tomixed tomllist tomllistwithpriority @@ -79697,6 +133088,7 @@ tomonoidhomzmodofiscyclic tomonoidwithzerohom tomonoisimage tomorphismproperty +tomsg tomu tomul tomulaction @@ -79718,6 +133110,8 @@ tomulrightreflectlt tomulringnorm tomulsemiringactionhom tomultiequalizer +tomultikeydescription +tomultikeyring tomultilinearaddhom tomultilinearmap tomultilinearmaplinear @@ -79742,19 +133136,25 @@ tonatfnname tonatfnnames tonatfunnames tonathom +tonatinjective tonatiso +tonative +tonatleft tonatlinearequiv tonatlinearmap tonatlit tonatmultiset +tonatright tonatsubmodule tonattrans tonattransexpr +toneg tonelli tonezero tonf tonfa tonn +tonninf tonnnorm tonnrat tonnratalgebra @@ -79764,6 +133164,7 @@ tonnrealhom tonnreallinear tonomaxorder tononarchaddgroupseminorm +tonone tononempty tononemptycompacts tononlinearrightinverse @@ -79773,7 +133174,6 @@ tonontrivial tonontriviallynormedfield tononunitalalghom tononunitalalgsemihom -tononunitalcommring tononunitalcommsemiring tononunitalcontinuousfunctionalcalculus tononunitalnonassocring @@ -79815,12 +133215,24 @@ tonozerodivisors tonozerosmuldivisors tonrmgrp tonucleus +tonum +tonumber +tonumset too +toobig +toobigdiv +toobject +toocomplicatedtobetrue +tooeagerresolution +toofast toofnat toofscientific took +tooks tool +toolkit tools +toom toomeas toomit toone @@ -79828,6 +133240,7 @@ toonebyone toonecochain toonehom toonehypercover +toop toopen toopenpartialhomeomorph toopenpartialhomeomorphofimageeq @@ -79836,6 +133249,7 @@ toopensfunctor toopensubgroup tooplax tooplaxmonoidal +toopop toopposite tooption tooptions @@ -79858,6 +133272,7 @@ toordertop toordertopsubonepos toorthonormalbasis toosmall +tooutcome tooutermeasure toover toovercompcoyoneda @@ -79874,8 +133289,11 @@ tooverunitpullback tooveryonedacomprestrictedyoneda top topa +topaddr +topaddrl topadicint topair +topalg topartialdiffeomorph topartialeq topartialequiv @@ -79886,9 +133304,13 @@ topartit topartition topartitionofunity topath +topathf +topathp +topaugmentation topbas topbases topbelow +topbit topbnd topc topcat @@ -79903,13 +133325,28 @@ topcattosheafcomphauslike topcharacteristic topclat topcld +topcoeff topcommringcat +topcompl +topconf +topcontinuous +<<<<<<< Updated upstream +======= topdataproperty +>>>>>>> Stashed changes +topdec +topdeclist +topdeclistnt +topdecs +topdefbyclosedpred +topdefbyclosureop +topdefbyinteriorop topdifinf topdifinfeq topdifinffin topdifinffinlem topdifinfindis +topdim topdlat topdown topdring @@ -79928,23 +133365,35 @@ topermhom toperminj topermutation topersistentenvextension +topeset +topexpr +topextension topf topfilter +topflip topfloat topfne topfneec +topframe topgele topgen topgr +topgroup topgrp topgrpbas +topgrpbasd topgrpplusg +topgrpplusgd topgrpstr +topgrpstrd topgrptset +topgrptsetd +topgrstr tophom tophomclass topi topic +topicp topics topifork topiforkfunctor @@ -79953,10 +133402,15 @@ topilocalizationequiv topinat topinatequiv topinathomeo +topincl +topind +topinter topiso topisozero topitensorproduct +topitl topjoin +topk topl toplaindate toplas @@ -79964,9 +133418,13 @@ toplatglb toplatjoin toplatlub toplatmeet +toplattice toplepullbackself toplevel +topleveldecs +toplevelnametarget toplly +toplogical toplots toplus toplusnattrans @@ -79975,27 +133433,35 @@ topmap topmatcl topmatcllem topmatval +topme topmeet +topmet +topmetr topmf topmnd topmod topmodulecat +topmost topmtcl topn topnat topnatmultiset +topneg topnex topnfbey topnfn topnid +topnidg topnlly topnodes topnpropd +topnpropgd +topnt topnval +topnvalg topo topobj topoffileref -topographical topoi topointedcone topointwise @@ -80032,11 +133498,14 @@ topologicalspacecoconeptofcoconeforget topologicalspaceconeptofconeforget topologicalspacefiber topologicalspacemodule +topologicaltype topologicalvectorspace +topologicalzmodtype topologies topology topologyi topologyofclosureoperator +topologyon topologytheory topoly topolygon @@ -80051,12 +133520,14 @@ toponmre toponrestid toponss toponsspwpw +toponsspwpwg topontop topontopi topontopn topontopon toponuni toponunii +topop topopen topopn topordermonoidiso @@ -80069,6 +133540,7 @@ toposmulmono toposmulreflectle toposmulreflectlt toposmulstrictmono +toposort topossmulmono topossmulreflectle topossmulreflectlt @@ -80078,9 +133550,17 @@ topoufun topow topowerseries topowerseriesalg +topped toppos +topposet topr +topre +toprea topreabstractsimplicialcomplex +topreal +topreala +toprealb +toprealc topreconnectedspace toprecoverage toprecylinder @@ -80095,6 +133575,7 @@ topreinner toprelaxfunctor toprelaxfunctorstruct toprelocalpredicate +toprelstr toprenex topreneximp topreneximpright @@ -80124,10 +133605,12 @@ toprincipalideal toprincipalseg topring toprint +toprns toprntopon toprocess toprod toprodhom +toprodiso toprodl toprodmulopposite toprodmuloppositehom @@ -80140,6 +133623,7 @@ toprofiniteobj toprojectiondata toprojective toprop +topropelim toproperty tops topseqsubst @@ -80154,14 +133638,28 @@ topsn topsort topsp topspace +topspacemetr +topspacenorm topsquareispullback topssnei +topsta +topstac +topstack +topstackguard +<<<<<<< Updated upstream +======= topstr +>>>>>>> Stashed changes +topstruc +topstruct +topsubset +topt toptocomphaus toptodeltagenerated toptolocale toptopon toptopreord +toptr toptype topullback topullbackdiag @@ -80169,11 +133667,14 @@ topullbackobj topullbackterminal topunit topunitidequiv +topunitspace topure +topush topushforwardofiso topushforwardstalk topushforwardstalkalghom topvec +topx toq toquad toquadraticform @@ -80200,9 +133701,13 @@ torationalmap toratlinearmap toratnz toratvec +torawaes +torawecdh toraweq torawinteq +torawrsa torawsubstring +torcmd torea toreal torealaffineisometryequiv @@ -80217,6 +133722,7 @@ torefineddiscrtree toreflectscolimit toreflectslimit toreflprefunctor +toreg toregular toregularspace torel @@ -80225,6 +133731,7 @@ torelembedding torelhom torelisogt torelisolt +torenv toreorder torepresentation torespectsright @@ -80232,8 +133739,14 @@ torestriction torestrictionnattrans torestrictscalars torestricttop +toresult +toreval +torevalcmd torevert torevlist +torexp +torexpmap +torhorst toriemannianmetric toright torightcancelmonoid @@ -80253,6 +133766,7 @@ toringinvo toringnorm toringseminorm toriso +tormap torootsofunity torows tors @@ -80268,8 +133782,11 @@ torsionmulequiv torsionof torsionorder torsionpolynomial -torsors +torsor +torsoria +torsorial torsubg +tortmap tortoise toruletac torus @@ -80304,12 +133821,20 @@ tosemiring tosemiringcatiso tosentence toseq +toseqtouint tosesqform toset +tosetelim +tosetequiv +tosetisdistributivepseudolattice +tosetispseudolattice tosetofisatom tosetoid tosetoidendo +tosetpath +tosetreal tosetrel +tosetstr tosfunname tosfunnames tosglb @@ -80367,6 +133892,9 @@ tosmulposreflectle tosmulposstrictmono tosnowflaking tosolution +tosome +tosortedalist +tosortedmap tosp tospannonzerosingleton tospansingl @@ -80395,6 +133923,7 @@ tossetisoconst tossetobjequiv tosso tossuphom +tost tostained tostalk tostar @@ -80406,12 +133935,17 @@ tostarorderedring tostarring tostarringequiv tostarsubalgebra +tostate tostates +tostaticbranchkey +tostaticmaterial +tostdstring tostep tostonean tostream tostrictlyunitarylaxfunctor tostring +tostringforregion tostrongdual tostrongfepair tostructomorph @@ -80455,25 +133989,47 @@ tosup tosupbothom tosupbothomclass tosuphom +tosusp +tosusppointed +tosusppresinvs tosylow tosymmetriccategory tosyn tosyntax tot +tota totag total totalandtransitive totalaux +totalcategory totalcomplexshape totalcomplexshapesymmetry totalcomplexshapesymmetrysymmetry +totalcov totaldegree totaldesc +totale +totalerror +totalerrorexpanded +totalerrorfullyexpanded totalflipiso totalflipisox +totalfun totalfunction totalfunctor +totalgrammar +totalhopf +totali +totalimptotalise +totalimptotaliselemma +totalinsts +totalise +totalisereachby totality +totalization +totalized +totallang totalleftderived totalleftderivedcounit totallengthfilter @@ -80484,29 +134040,53 @@ totallydisconnected totallydisconnectedspace totallyseparated totallyseparatedspace +totalmap totalmass +totalmooretrans +totalnum totalorder +<<<<<<< Updated upstream +totalordering +======= totalorderedp +totalordering totalorderp +>>>>>>> Stashed changes totalp +totalpath +totalpathexists +totalprecategory totalpreorder +totalprod +totalpushoutpath totalquotientpresheaf +totalr +totalrec +totalrelation totalrig totalrightderived totalrightderivedunit totalshift +totalsize totalspace +totalspacehopfpush totalspacemk totalspacetopology +totalsum +totalsumconst +totaltotalise totalvaluationforformuladefinesitsvalue totalvariation totalweight +totalwires totatives totbnd totbndbnd totbndmet totbndss totc +totcatmagma +totdegree totempereddistribution totempereddistributionclm totensor @@ -80514,12 +134094,23 @@ totensoralgebra totensorofistrivial totensorpower toterm +totfuncs totheory tothinskeleton totient +totiente totilde +totlen totm +totmissives toto +totoeetrans +totoeltrans +totoggtrans +totogltrans +totoletrans +totolgtrans +totolltrans totop totopcat totopcatmap @@ -80530,6 +134121,8 @@ totopolo totopologicalspace totopsimplex totopsp +totord +totorder tototallyseparatedspace tototalquotientpresheaf totprob @@ -80547,6 +134140,8 @@ totrunc totruncate totruncated totruncge +totse +totsec totuplemvpolynomial totwopointing totwosided @@ -80555,8 +134150,11 @@ totype totypeexpr totypeorderbot totypes +tou touc touch +touchable +touched touching touchpoint touchpointweights @@ -80585,13 +134183,21 @@ toupperset touppersetmularchimedeanclass touppersetorderiso tour +touraloc +tourbloc +<<<<<<< Updated upstream +======= tours +>>>>>>> Stashed changes +tous tout +toutf tov tovadd toval tovaluation tovalued +tovar tovariable tovbij tovec @@ -80600,6 +134206,7 @@ tovectorbundle toview tovisit tow +towa towalk toward towards @@ -80614,16 +134221,24 @@ towellfoundedrelation towellorderextension tower towerlaw +towers towithbotnat towithtop towithtopzero towitness towitnessfalse +town +<<<<<<< Updated upstream +======= towna townb +>>>>>>> Stashed changes toword +towordenv towot towotclm +towp +toy toycom toz tozero @@ -80652,20 +134267,43 @@ toznum toznumneg tozvceaykqiogcuixumg tpa +tpair +tpairs tpass tpb tpc +tpcases +tpccoh tpcoma tpcomb +tpdb tpde tpeq +tperm +tpermc +tpermd +tpermj +tpermk +tpermkg +tperml +tpermp +tpermr +tpermv tpex tpexb +tpexg tpf tpfi +tpfidceq +tpfidisj tpfo +tpg +tpi tpid tpidm +tpj +tplane +tpm tpmf tpnei tpnz @@ -80676,6 +134314,7 @@ tpoint tpointer tpolish tpoly +tpool tpop tpos tposco @@ -80706,22 +134345,32 @@ tposss tposssxp tpossym tpostpos +tpow +tpp tpprceq tppreq tppreqb +tpq tpr tprec tpred tpres +tprf tpri tpro tprod tprodcoef tprodcoeff +tprode tprodl tprodmonoidhom +tprog tprot tps +tpsc +tpsize +tpsl +tpsm tpsprop tpspropd tpss @@ -80733,26 +134382,14 @@ tpssg tpssi tpstop tpsuni -tpt -tptp -tptpartsupplies -tptpcol -tptpexecutionbyfiringsquad -tptpgeo -tptpnavypersonnel -tptpnsubcollectionofwithrelationfromtypefnunitvectorintervaldirectionoftranslation -tptpnsubcollectionofwithrelationtofnshipobjectfoundinlocationcityofbostonma -tptpnsubcollectionofwithrelationtotypefnissuingaprescriptionproductscorrectivelensprescription -tptpofobject -tptpquantityfn -tptpridgeline -tptprunningshorts -tptptptpcol -tptptypes tptr tpwfeswurayqrqp tpxmktw tqli +tqo +tqq +tquant +tqueue tra trac trace @@ -80766,35 +134403,67 @@ traceclsvisit traced tracedata tracedual +tracef traceform tracei traceid traceifexists +traceinf tracelinearmap tracematrix +traceof +tracep +tracepoint tracepositivelinearmap +tracepred +tracepredicate traceproof +traceprop +tracereachin +tracerelation traceresult traceresultof traces +tracese +tracesemantics +tracesi +tracespec +tracespecinput +tracespecmonad +tracespecmonadlaws +tracespecmorph +tracespecobs +tracespecorder +tracespecorderlaws +tracespecs tracestackstags tracestate tracing +tracingp track tracked trackedcore tracker tracking tracks +tracl trad tradd +trade +traded +tradeoffs +<<<<<<< Updated upstream trades +======= +>>>>>>> Stashed changes traditional +tradmrec traduction traffic trafo trai trail +trailer trailing trailingcoeff trailingdegree @@ -80805,49 +134474,98 @@ trailingwhitespacelinter trails trailson train +training +trait +traitclass traits +traitsynonym traj trajcontent +traject trajectories trajectory +trajectp +trajects +trajectsr trajfun trajmeasure +tram +trampoline tran trancl +trancld trancle +trancli tranclp +trand +tranf +tranfer +trangle tranp +tranparent +tranpose trans +transable +transactgetitemlist +transactgetitemsensurespublicly transaction transactione transactions +transactionsp +transactwriteitem +transactwriteitemlist +transactwriteitems +transactwriteitemsensurespublicly transassoc transassocrepa transassocreparamaux transat +transboolless transcende transcendence transcendental +transcl transclosure transcmp +transcompose transcontinuouslinearequiv transcribed +transcript +transcripts +transd +transdb +transdecisionless +transdeps +transdleu +transe +transeg +<<<<<<< Updated upstream +transeq +======= +>>>>>>> Stashed changes transequiv +transeu transeventuallyeqisbigo transeventuallyeqisequivalent transeventuallyeqislittleo +transex transf +transfcshmgenlink transfer +transferaxioms transfercenterpow transferfocal transferfunction +transferm transferred transferring transfers transferset transfersylow +transfert transfertransversal transfiberhomeomorph +transfiflink transfinite transfinitecomposition transfinitecompositionofshape @@ -80857,31 +134575,58 @@ transfinitecompositionofshapereflection transfinitecompositionofshapesuccstructprop transfinitecompositions transfinitecompositionsofshape +transfiniteind transfiniteiterate transfinitely +transflink transflip +transfor transform +transformable +transformado +transformar +transformatio transformation transformations transformatlocaldecl transformatlocation transformatnondepproplocation transformattarget +transformcomposebit +transformcomposelemma +transformcomposeword transformdeclrec transformed transformer +transformers +transformeval transforming +transformlabel +transformlist transformobjcomp transformobjid transformobjprecomposeobjsquare transformprecomposeobjsquare transforms transformstep +transformw +transfpartialcontextuallink +transfpartiallink +transfselectionlink +transfsimplexprlink +transfsimpllocalslink +transftotallcontextuallink +transftotallink +transfun transfunc transgen +transgeo transhomeomorph transi +transient transinitial +transinrange +transirreflexiveorderingisacyclic transisbigoeventuallyeq transisbigoisbigo transisbigoisequivalent @@ -80896,35 +134641,63 @@ transislittleoisbigo transislittleoisequivalent transislittleoislittleo transisthetaisequivalent +transit +transiti transition transitioncocone transitiond transitiondepth transitionfailures transitioni +transitionimplyvaliddecryptionmaterials +transitionimplyvalidencryptionmaterials transitionmap transitionmaple transitions +transitionsp transitiontheorems transitiontheoremsext +transitiv transitive transitiveclosure +transitiveh transitivei +transitiveinv transitively transitivelyusedconstants +transitivep +transitivepin +<<<<<<< Updated upstream +======= transitiveproperty transitiveset transitivesetop +>>>>>>> Stashed changes transitivity +transitivityt +transits +transitstarttimeslot +transitve +transktoxf transl +transla +translac +translat translate +translateaddr +translateaddress translated translatedata translatedname translateexisting +translatef translatelemmas +translatelt translatenamespace +translateo translateoverwrite +translateprf +translateproof translaterelevantarg translatereorder translates @@ -80932,18 +134705,42 @@ translatesec translatestate translatetoint translatetrace +translatev translateval +translati +translatible translating +translatio translation +translational +<<<<<<< Updated upstream +======= translationevent +>>>>>>> Stashed changes +translationi +translationind translationinfo translationinvariant translationnumber +translationregime +translationrel translations translator +translatortheory +translexless +translexlessrestricted +translist +translleu +<<<<<<< Updated upstream +======= translocation +>>>>>>> Stashed changes +transm +transmit transn +transnt transnumauxseq +transof transopenpartialhomeomorph transord transp @@ -80951,20 +134748,47 @@ transparency transparencymode transparent transpartialequiv +transpd +transpdesc +transpequiv +transpfill +transpmacroaction +transpmacrostructure +transpmacrotransportstr +transpo +transpor transport transportandsheafify transportation transportcl +transportcohomiso +transportcomposite +transportd transported transportedfunctorcompinversebraided transportedfunctorcompinverselaxbraided transportenrichment +transportexact +transportf +transportfill +transportfunctor transportiso transportisosheaftopresheaf +transportisotopath +transportnot +transportpath +transportpathtoeq transportprops +transportrefl +transports transportsheafificationadjunction +transportstr transportstruct transportto +transporttransport +transporttrunc +transportuainv +transportuaop transportvia transpos transpose @@ -80972,36 +134796,69 @@ transposeaddequiv transposealgequiv transposed transposeinvertibleequivinvertible +transposeinvolutive transposelinearequiv transposeorderiso transposepath transposeringequiv +transposewxw transposition +transpositional transpositionlist +transpositionpeirce +transpositions +transprecedesorder transprincipal transq transr transrec transrefl transreflreparamaux +transrel transreliso +transrs +transs transset +transter +transterminationlessstate +transtive +transu +transupdate transvec transvection transvections transvectionstruct transversal +transversalp transversalpair +transversals +transxtokf transymcl trap +trapc trapezoid trapezoidal +trapezoiddiagonals +trapg +trapp +trapped +trapping +traps +trapspace +trarr +trasable trascl +trasform trasposition +trat tratrb tratrbvd traux trav +trave +travel +traveling +travels traversable traversablederivehandler traversablelawstarter @@ -81010,8 +134867,18 @@ traverse traverseaux traversechildren traverseconstructor +traversed traversefield +traversefunctorial +traverseidentifiesvar +traverserelative +traverses +traversevarinjective +traversevarisidentity +traversevector +traversew traversing +travg traxext trb trc @@ -81028,66 +134895,119 @@ trclfvcotrg trclfvdecoml trclfvdecomr trclfvg -trclfvimadecom trclfvlb -trclfvres -trclfvresub trclfvss trclfvub trclidm trclimalb -trclimaub trclrelexplem trclsslem trclub trclubg trclubgi trclubgnew -trclubgres trclubi trclublem trclubnew trclun -trclunxp +trcmap trcont trcontstack trcoss trd +trdc trdeg +trdy tre +treach +treactive +tread +treal +<<<<<<< Updated upstream +======= treams +>>>>>>> Stashed changes treap +treastise treat treated +treating +treatment treats +treble +trec +trectangle +tred tree treearb treearray +treebox +treecopy treed +treedata +treedb +treedecomposition treee +treeequation +<<<<<<< Updated upstream +======= treefi +>>>>>>> Stashed changes +treefn treehead +treeheight treehom treei treeify +treeind +treel treelist +treelookup treem treemap +treemapy +treemaxindex treeof +treep +treer +treerep +<<<<<<< Updated upstream +======= treerp +>>>>>>> Stashed changes trees treeset +treesize treesofnumnodeseq +treess treestars +treestructind +treetest treewidth +treezise +tref +trefl trefoil +trefs +treg +tregs trel trelded trelpss +tremendously +trenaming +trepeat +treplicate treq trequest trer +tres +tresp +trestn +tret +trexscantseeit trf +trfact trfbas trfg trficl @@ -81105,6 +135025,7 @@ trgcopyeulem trggrp trglobal trgring +trgt trgtgp trgtmd trgtps @@ -81114,15 +135035,20 @@ triagular triang triangl triangle +triangleamn +trianglebnm +trianglecnm trianglefree trianglefunctor trianglefunctornattransofle +trianglegraph triangleh trianglehmapofhomotopy trianglehofdegreewisesplit trianglehofdegreewisesplitrotaterotateiso trianglehrotateisotrianglehofdegreewisesplit trianglei +triangleidentity triangleindexdata triangleindices triangleinequality @@ -81138,6 +135064,7 @@ triangleltltgelt trianglemap trianglemapofhomotopy trianglemapofle +trianglemnp trianglemorphism trianglemorphismid triangleofdegreewisesplit @@ -81153,84 +135080,182 @@ trianglerotateshortcomplex trianglerotateshortcomplexsplitting trianglerotation triangles +triangleshape +trianglespec +trianglespeccomm +trianglespecperm +triangletoparallelogram +triangstr triangular +triangularizable triangulate triangulated triangulation +triangulize +triangulized +triangulizes triantru +triap +trich tricho +trichot +trichotomic trichotomou trichotomous trichotomy trick +trickery trickier tricky tricoloring tricolour +tricord +tridc +tridceq trident trie tried trieindex +trieq tries triesd +triesp trifr trifunctors +trig +trigg trigge trigger +triggeraxioms +triggered +triggergc +triggering triggers +tright +trigizable +trigonometric +trigonometry triin +trijoin +trijoinrecdata +trijoinrecpath +trilpo +trilpolemcl +trilpolemclim +trilpolemeq +trilpolemgt +trilpolemisumle +trilpolemlt +trilpolemres trim trimascii trimasciiend trimasciistart trimleft +trimmable trimmed +trimming trimono +trimonod +trimonoi +trimpreservesvalue +trimproperty +trimresult trin +trinary trinit +trinity trinomial trint trintalt trintaltvd trintss +trintssm trinxp +trio +triop +triopeq +triopex +trioplambda triorthogonal trip tripartite tripartitefromtriangles +tripl triple +triplecheck tripled +triplee +triplef +tripleg +triplei +triplelength +triplelist +triplema +triplemap +triplemaplist +triplemaps +triplep triples triplet triplewise +triplex tripling tripolar +tripp +tripped +trips +trirec trirecip trireciplem trirn tris +trise trisecnconstr +trisect trisecting +trisection trisegint trisplit +trisuma triun triv +trivail +trivasymorthorelstr trivchange +trivclassical +trivclrelstr trivcof +trivcompllat +trivdecomp +trivelim +trivext trivfib trivg trivgfun trivgp +trivgpn +trivgrouphom +trivgvpdiv +trivi trivia trivial +trivialabgroup trivialaction trivialalgo +trivialapart +trivialarity trivialcofibrations +trivialcoloredpetrinet +trivialctlmodel trivialfibrations trivialfiltration trivialfunctor +triviali +trivialinfinitetree trivialisation trivialisnilpotent +trivialities triviality trivializable trivialization @@ -81240,28 +135265,67 @@ trivializationdiscrete trivializationofmempretrivializationatlas trivializationofsmuldisjoint trivialliemodule +triviallmod +trivialltlmodel trivially +trivialminimunsemantics +trivialmssign trivialonconstants +trivialop +trivialops +trivialosa trivialpair +trivialpetrinet trivialphi +trivialpropositionalsemantics trivialrel +trivialsemantics trivialsnd trivialstar +trivialstr trivialstructure +trivialt trivialto trivialvectorbundlecore +triviimset +trivindir +trivintuitionistic +triviset +triviseti +trivisetp +trivisets +trivisett +trivisetu +trivival +trivlattrelstr +trivlet +trivm +trivmg +trivnatded trivnsgd trivnsimpgd +trivorthorelstr +trivortlat +trivp +trivposet +trivpost +trivpostnoabr +trivrecindir +trivseplog +trivshefferortholattstr trivsqzeroext trivsubgd trivsubgsnd +trivthm trivvecsp +trkey trkgbas trkgdist trkgitv trkgstr trkrate trl +trlam trlat trlatn trlator @@ -81299,38 +135363,59 @@ trlontrl trlord trlres trlreslem +trls trlsegvdeg trlsegvdeglem trlset +trlsex trlsfval +trlsfvalg trlsonfval trlsonistrl trlsonprop trlsonwlkon trlspth +trlst +trlstp +trlstpx +trlsty +trlsv trlval trm +trmap trmhd trmi trms +trmx +trmxk +trmxv trn trna trnat +trnb trnei trnfsetn +trnl trnn trno trnormal +trnr +trns trnsetn trnum trnv trnw tro troeger +troelstra +<<<<<<< Updated upstream +======= trolley +>>>>>>> Stashed changes trom tron trop +trope tropequiv tropical tropicalbudget @@ -81343,10 +135428,18 @@ tropm troporderiso troprec trouble +troubleklef +troubling trough +trow +trowb +trowbe +trp trposnum trpred +trprod trr +trrd trrel trreleq trrelind @@ -81360,17 +135453,24 @@ trs trsbc trsbcvd trsc +trsl +trslt trsp trss trssfir trssord trsspwalt +trst trstact trstmts +trsubsetex +trsubsetuniq trsuc trsucss trsupp +trsym trtape +trtxp tru truae truan @@ -81378,45 +135478,91 @@ truanfal truantru trubifal trubitru +trucking truconj trud true trueargs truearrowequiv +trueb +truebr +truebranch +truecount +trued +truedef +truee +truef +truefalse +trueforall +trueforsome truei -trueidea trueif +trueinbool +trueint trueinworldnecc +trueiseven +truek +truelabels +trueleaf +truelist +truelistp truemult +truename +truep trueprop trueq truerepeat +trues truesetoid truesingle +truet +trueterms trufil truimfal truimtru trujust +trul +trule +truly +trun trunanfal trunantru trunc +truncadd +truncadj +truncatablep truncate truncateaugment truncated +truncatedencodedecode +truncatedfamilies +truncatedfamiliesequiv +truncatedfamiliesiso truncatedfundamentaldomain truncatedinf +truncatedpathequality +truncatedright truncatedsup truncatedwitt truncatedwittvector truncatefun truncateofle +truncates truncateto truncatetoreal truncation truncationcomptrunc +truncations truncaux truncbv +truncc +trunccd +truncck +trunccm +trunccwiso +trunccx trunccyclefactors +truncelim truncencodable truncequivfin truncequivfinofcardeq @@ -81434,8 +135580,12 @@ truncgelttoltge truncgemap truncgexiso truncgexisoopcycles +truncgroupiso truncgt truncgtisotruncge +truncidempotent +truncidempotentiso +trunciso truncle trunclefunctor trunclege @@ -81447,33 +135597,66 @@ trunclexisocycles trunclt truncltge truncltlinearmap +truncn +truncns +truncof truncofcardle truncofcardpos truncofmultisetexistsmem truncofnonemptyfintype +truncofprodiso +truncoftrunceq +truncoftrunciso +truncpathelim truncrecemptyoption +truncrel +truncrelequiv +truncreliso +truncreverse truncsigmaofexists truncswapfactors +truncswitch +trunctype truni trunialt trunialtvd +trunk trunorfal trunortru +truong +truongg truorfal truortru trust +trustanchorcertificatetype trusted trustlevel trustme +trusts trut truth +<<<<<<< Updated upstream +======= truthday +>>>>>>> Stashed changes +truthenv +trutheval truthisregularmono +truthmap +truthp +truths +truthsp +<<<<<<< Updated upstream +======= +truthteller +>>>>>>> Stashed changes +truthvalue truxorfal truxortru trv trw trwf +trx try tryateachstep tryateachstepaesop @@ -81492,17 +135675,26 @@ tryclear tryclearmany tryclearzero tryclose +trydecrypt +tryencrypt tryfinally +tryfind +tryig trying trym trynormnum +tryp +trypick trypostpone trypostponeifhasmvars trypostponeifnoneormvar tryprovenonneg tryprovenonzero tryprovepositive +tryrecv +tryremove trystrategy +trystructural trysynthinstance trysynthinstanceq trytactic @@ -81513,12 +135705,21 @@ trytheoremwithextraargs trytheoremwithhint trythis trytobecomeleader +tryurl trywhnfr +trzeba tsa +tsaconv tsan tsbi +tsc +tscd +tschar +tscheme +tsdef +tsee +tsep tseparray -tseq tset tsetid tsetndx @@ -81528,16 +135729,25 @@ tsetndxnn tsetndxnplusgndx tsetndxnstarvndx tsets +tsetslid tsettps +tsexist +tsf tsfst +tsg tsh +tshell tshift +tshifts tsi +tsilent tsim tsin +tsingle tsint tsirelson tsk +tskajxy tskcard tsken tskin @@ -81567,6 +135777,8 @@ tskwe tskwun tskxp tskxpss +tsl +tslambda tsms tsmsadd tsmsbi @@ -81596,29 +135808,55 @@ tsnd tso tsome tsor +tsort +tsorted +tsortedp tsp +tspace tspec +tsplit +tspmf +tsr +tsra tsrdir +tsresult +tsresultl +tsresults tsrlemax tsrlin tsrps tsrss +tss tssnd +tssubst tst +tstack +tstamps tstate +tstatus tstep tstepi +tsteps +tstore +tstr +tstring tstruct tstructure +tstsec tsu tsub +tsubq tsubs +tsubst +tsubstt tsucc tsum tsumnormrpowbound tsums +tsuniq tsupp tsupport +tswap tsxo tsy tsyntax @@ -81627,8 +135865,15 @@ tsz tsze tta ttac +ttag +ttags +ttake ttas +ttc +tterm +ttf ttff +ttflip ttft ttgbas ttgbtwnid @@ -81641,11 +135886,20 @@ ttgplusg ttgsub ttgval ttgvsca +tth +tthlp ttijucchlwktnzwxruyhunmkdm +ttime +ttimp ttl +ttlm ttm tto +ttodo ttop +ttorder +ttppv +ttr ttrclco ttrcleq ttrclexg @@ -81654,35 +135908,72 @@ ttrclse ttrclselem ttrclss ttrcltr +ttree ttrue +ttrule +ttry tts +ttsindexedproduct ttt tttf +tttransitive tttt ttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttt tttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttt ttukey ttukeyg ttukeylem +ttup tturnstile +tty +ttyp ttype +tuapyyu +tuart tube +tubes +tuc tuchar +tue tuesday +tuf tuihdzjzh tuint +tukey +tulcea tulip +tundef tune tunermode tunf +tunify +tunifywl tunion +tunit +tunitsphere +tunnel +tuong tup +tupersable +tupl tuple +tupled +tuplee tuplegraph +tuplel +tuplelist +tuplematch +tuplep +tupler +tupleresolution tupleright tuples +tuplesd tuplesi +tuplesorder tuplesucc +tuplify +tupnone tupple tups tur @@ -81692,10 +135983,13 @@ turangraph turing turingequivalent turingreducible +turingstr +turk turn turned turni turning +turnm turns turnst turnstile @@ -81708,86 +136002,200 @@ tusunif tususp tususs tusval +tutorial tutte +tutu +tuv tuvar +tvaddr tval +tvalk +tvals +tvalue tvar tvarb +tvargs +tvarn tvars tvclmod tvclvec +tvcompare tvctdrg tvctlm +tve tvec +tvector +tvelookup +tverum +tvf tvfpuxv +tvl tvoid +tvparams +tvres +tvrhs tvs +tvset +tvst +tvsymbol tvtcblmj +tvwalk twa +twalk twb +twdrs tweak +tweaked tweet twelve +twenty +twentyone twice +twicei +twicem +twicemaxulp +twicepret twiddle twiddleheap twiddleval +twin twinamicpair +twinfree +twinprimes +twinprimesm +twins +twise twist +twistbaseloop twisted +twistedarrow +twistedarrowcategory +twistedcod +twisteddom +twistedends twistshiftdata twizzle twls two +twoc +twoch +twochain twocochain twocochainofbilinear twococycle twococycleaux twococycleof twococycleofbilinear +twocomp twocriteria twocube +twocubeimg twocut twod +twodb twodenominators +twodhom +twodx +twody +twoe +twoelementsets +twoembeddedsymtriangles +twoembeddedtriangles twoembeddingequiv +twoexp +twof +twofer +twofish +twofishdecrypt +twofishencrypt +twofunction +twofuncuseopaque twogoals twoh twoheadrightarrow twoheadsargs twohole +twohom twoimpleft twoimpright +twol twolefthole twoleftholezipwf +twolemma +twolines +twolong +twom +twomethod +twomidpointsnotclockwise twomorethanone +twomultdiv +twomultp +twon twonetsdistinct twonotinotbothi +twooutof twop +twoperpsparallel +twoph +twoplustwonotfive twopointing +twopointssecantlines twopow twopowsum +twopredicate +tworays +tword +tworedneighbors +tworesults tworighthole tworightholezipwf +twos +twosa +twoscomp +twosemicategory +twosemifunctor twoshortaddlong twoshortaddlongroot twoside twosided twosidedideal +twosphere +<<<<<<< Updated upstream +======= twosqu +>>>>>>> Stashed changes twosquare +twostate +twostatelemma +twostatesmooresm twostepinduction +twosum +twothirds +twothree twotorsionpolynomial +twotri twotypes twouniquemul twouniqueprods +twovalued twovariables +twovars +twoways +twoword twoworlds +twox +twoxdiv +twoxxx +twoy +twp +twpm +twpp tws txbalance txbas txbasex txbasval +txcap txcld txcls txcmp @@ -81800,11 +136208,13 @@ txcnpi txconn txdis txe +txfbalb txflf txhaus txhmeo txindis txindislem +txiwyhi txkgen txlly txlm @@ -81815,9 +136225,16 @@ txmxeqx txnlly txomap txopn +txpacket +txpcofun txpconn +txpeq +txpex +txpexg txprel txpss +txq +txqtpvc txrest txs txsconn @@ -81833,32 +136250,87 @@ txtube txuni txunii txval +txvalex txyc tya +tyacc +tyaof +tyapp +tyapps +tyarg tyargs +tyarr +tyarrow +tyass tyazvhikqicbhcbmdhurtt tyb +tybij +tybit tybool +tyc +tycast tych tychonoff +tychonoffproducttheorem +tycon tycontext tyde +tydec +tydef +tydepth +tyelt +tyenv +tyerr +tyf +tyfam +tyforall +tyfrag +tyfrees +tyfun +tyi +tyin +tyint +tyit tykhonov +tykn tyl +tylist +tylr +tyls +tylxs +tymatch +tympred +tyn +tyname +tynames tynat +tynm tyop tyoption typ typable +typair +typal +typd type +typeabbrevdec +typeable typeablefreevars +typealg typealias +typealign typeamic +typearg typeargs typeb +typebase typebequivso +typec +typecan +typecase typecat typecheck +typechecked typechecker typechecking typechecks @@ -81866,52 +136338,117 @@ typeclass typeclasses typeclassesleftrightle typeclassmeasurablespace +typecode +typecodep typeconf +typeconstr +typeconstrname +typeconv +typeconversions typed +typedec typedecidableeq +typedecide +typedef +typedefinition +typedeflist +typedefn +typedefs typedequivso +typedfun +typedgraphfn +typedgraphfun typediscipline typedwasm typee typeequalizerofunique typeequiv +typeeqvto typeerror typeerrorfmt +typeexn +typef +typefail +typeflag +typegr +typegraph typei +typeid +typeidx typeii typein +typeinfer +typeinference +typeinfo typeinfos +typeinj typeinvariant +typel +typelist +typelistassignabl +typelistassignable typell typellcmd typellmodel typellservice typelt +typemap typemax typemd +typen typename typenames typenew +typenp +typeo typeof +typeofhlevel typeofineqproof typeofnew +typeok typeold +typeop +typep +typeparametersareparametric +typeparameterviamember +typeparamlist +typeparams +typeparamviolation typepriority typeqtint +typequotsettrunciso +typer +<<<<<<< Updated upstream +======= +typerel +>>>>>>> Stashed changes +typerepr typeresult +typerr types -typesa typesafe typesafepets typesafety typescheme typesconf +typesem +typeset +typesetting +typesexp typesglue typesgrothendiecktopology +typesi +typesize +typesp typespec typespeed typess +typest +typestamp +typestr typeswith +typesystem +typet typetags typetoboolalgop typetocat @@ -81922,94 +136459,266 @@ typetocatobjectsadjhomequiv typetocharp typetocharpresult typetofacts +typetok typetopartialfun typetopartialfunisopartialfuntopointed typetopointed typetopointedforgetadjunction typetostonean +typetransiti +typetransition typetree typevalued typevar typevec typeveccasescons typeveccasesnil +typewithstr +typex typical typically typing +typingaxiom typings +typlist +typo +typopt typos typrop +typs +typset typtree +typx +tyr +tyreps +tyres +tyrest +tyret tys +tysfv +tyshare +tysig +tysof +tyspm +tysubst +tysymbol +tytmdepth +tytok +tytups +tyunit +tyv +tyval +tyvar +tyvarlist +tyvarn +tyvars +tyvart +tyvl +tyvn +tyvnms +tyvof +tzcnt tzero +tzp +tzq tzviyweip tzwnnkqguacaqixfiig tzzixngdumsoi +uaalgebra +uaaut +uaautcomp +uaautgroup +uab +uabcd uabs +uabsirrel uabstract +uacc +uacommalgebra +uacommring +uacompequiv +uacompgroupequiv uact +uaction +uad +uadd +uaend +uaendcomp +uaendmonoid +uafield +uaghhbm +uagroup +uagroupid +uaid +uaidequiv +uainvequiv +uaiso +ualaw +uam +uand +uap +uarel +uarelhom uarg uargs +uaring uarr +uarray +uart uas uasban uasbanh uasbanhvd +uasequence +uasequenceidequiv +uastr +uatransport +uav +uavi +uavj +uavl +uavr +uavs uba uball ubb ubd +ubdd +ubddarr +ubddp +ubdds +ube ubelsupr +ubertrait ubex -ubforcartprodlem ubfz +ubg +ubhdeuu +ubi ubicc ubico ubioc ubioo +ubioog +ubit ublbneg ublem +ublemc +ublock ubmelfzo ubmelm +ubn +ubopt ubound uboundmax +uboundp ubounds +uboundt +ubp +ubpn +ubq ubs +ubsqrt +ubsup +ubt ubth ubthlem +ubv +ubx +ubyte ucabs +ucaret ucast +uchar +uchoice +ucinf +ucirc ucl uclause uclique +uclose +ucmpdec ucn ucncn +ucne ucnextcn ucnima ucnimalem +ucnp ucnprima +ucnsn +ucnsnr ucnval +ucode ucol +ucomi ucompactlygeneratedspace +ucon +ucond +uconnected +uconnectedempty +uconnectedv +ucons +ucont ucontinuous +ucord +ucp ucs +uct +uctr +ucts ucu ucy +ucycle ucycles uczzupk +udbl +ude +udedge +udedges udefaultspec +udenodes +udf +udfilter +udfl +udgraph +udi +udims udiv udivcc +udivide udknahhpuldlrdffycaferimsihfutbcg udom +udot +udouble udp +udpate +udpedge +udpentry +udplist +udpsymbol +udr +udta +udul +udulgraph uedge uedges +uem +ueo ueq +uequiv +uesm +uexecute +uexists uexp +uext +uextend uface +ufastp +ufc ufd ufdidom +ufdness ufdprmidl ufds ufe @@ -82019,8 +136728,8 @@ uffinfix uffix uffixfr uffixsn -uffman ufg +ufieldlist ufil ufilb ufilcmp @@ -82033,25 +136742,36 @@ ufilmax ufilss ufilter ufinffr +ufixed ufl ufldom ufli +ufloat ufm ufnia +ufo ufprim +ufunc +uge ugh uglify ugly ugqjitctzd ugraph +ugrouphom +ugrouphomi +ugt +uguard uhgr uhgraph uhgredgiedgb +uhgredgm uhgredgn uhgredgrnv uhgredgss uhgreq uhgrf +uhgrfm uhgrfun uhgriedg uhgrimedg @@ -82061,6 +136781,7 @@ uhgrimisgrgric uhgrimisgrgriclem uhgrimprop uhgrissubgr +uhgrm uhgrn uhgrnbgr uhgrrusgr @@ -82080,25 +136801,67 @@ uhgrwkspth uhgrwkspthlem uhi uhint +uhoh uhpath +uhuge uhwm +uhyp uicc uid uidl uids +uii +uil +uimm +uimmersion +uin uinf uinfo +uinit +uinstruction uinstructions uint +uintmaxw +uintptr +uints +uintv uinu uioc uioo uip +uiptype uisinvar +uiso uisscdioufhiqhqlqlugmemydblovlvyfdbxemzjsuauyifnpxa uiter +uivnnrr +ujoin +ujoina +ujoinc +ukbrpfe +ukc +ukccompkol +ukcfkmin +ukckol +<<<<<<< Updated upstream +ukmm +======= ukencartamsncomencyclopedia +ukmm +ukranian +>>>>>>> Stashed changes +ulabgraph +ulam +ulambda +ularge +ulc +ule +ulead +ulekuub ulemma +ulet +ulevel +ulgraph uli ulib ulif @@ -82145,8 +136908,11 @@ uliftyonedareprxiso uliftzmultipleshom uliftzpowershom ulim +ulincop +ulinear ulist uliteral +ull ulm ulmbdd ulmcau @@ -82169,34 +136935,76 @@ ulmss ulmuni ulmval ulneabrunmqphqatxftlrzvgrfqxgg +ulog +ulogm +ulong ulower ulp +ulps +uls +ulsub +ulsubmx +ult +ultimaltively ultimate ultimately +ultimatively +ultime ultra ultrafilter ultrafilterbasis +ultrafilterlemma ultrafilters ultrahomogeneous ultrametric +ultrametricspace +ultrapower ultraproduct +ultraset +ultyped +umall +umallpt +umallpte +umallptun +umallptune +umallun +umallunl +umallunr umap +umape umax +umean umem +umerge +umf +umfilt +umfilte +umfiltf +umfiltpt +umfiltptun +umfiltu +umfiltun +umfiltunk umgr umgracycusgr umgraph umgrbi +umgrbien umgrclwwlkge umgredg umgredgne umgredgnlp umgredgprv umgredgss +umgredgssen umgrf +umgrfen umgrfn +umgrfnen umgrhashecclwwlk umgrislfupgr +umgrislfupgrdom +umgrislfupgrenlem umgrislfupgrlem umgrn umgrnloop @@ -82213,51 +137021,117 @@ umgrupgr umgrvad umgrwlknloop umgrwwlks +umin +uminnus uminus uminusgh uminusi +umlal +umod +umon umonoid ump +umpl +umpleq +umpt +umptpte +umptptue +umptue +umptundefe +umptupt +umptupte +umsk umstaendlich umul +umull +umult +umundef +umundefpte +umupte +umuptpte una unab +unable unabs unabw +unac +unaccounted +unackedlists +unackedmessages +unackedmessagesfordst +unacquired +unadj +unadorned unaffected +unage +unagen unalign +unaligned +unalignedallowed unalignwith unalive +unallocated unallocatedblocksinvariant +unalt unambigous +unambiguity unambiguous unambiguousi unanimity +unapp unapplied unapply +unapprox +unaray unarg unary +unaryadd +unarybinary unarycast unarydecodenat +unarydiff unarye unaryencodenat unaryfinencodingnat +unaryh unaryi unaryindividualterm +unaryminus +unaryop +unaryrecop +<<<<<<< Updated upstream +======= unaryunion +>>>>>>> Stashed changes +unascribe unass +unassign +unassigned +unassume unat unattach +unavail +unavoidable unb unbal +unbalanced +unbar +unbb unbdqndv unben +unbendc unbenlem unbeta +unbiased +unbind unblem unblimceq unblinded +unblock +unblocked +unblok unbndrank +unbndts unbnn unbop unbordered @@ -82266,164 +137140,341 @@ unbota unbotd unbound unbounded +unboundedd unboundedlog unboundedness +unbounds unbox unboxed +unboxedboundvariables +unboxtest unbump +unbumpform +unbumpk +unbumpkcond +unbumpmod +unbumps unbumpterm unbundled unc +unca +uncache uncap uncast uncaught unccur +uncellularize uncenteredcovariancebilindual unceq uncertain uncertainty +uncertified uncf uncfcl uncfcurf uncfval unch +unchange unchangeable unchanged +unchangedargumenttype +unchangednonvolatilefields +unchangednonvolatileuserfields unchanging +uncharset +uncheck unchecked uncheckedcast +uncheckeddelete +unchloob unchloor +unchloorj +unchluj unchon +unchoose +unchopped unchprivsrc uncld unclear unclocked +unclockedsemanticsscript unclosed +unclosure +uncm uncmp uncom uncomment +uncommit +uncommitted +uncompl +uncomposable uncompose +uncompressed unconc +unconcat +uncond unconditional unconditionally unconditionalschauderbasis +unconjugate unconn +unconnected uncons +<<<<<<< Updated upstream +======= unconscious +>>>>>>> Stashed changes +unconse +unconst unconstrained +uncontinuous +uncontrolled +unconvert +unconvertible +uncore +uncorrelated uncou uncountable uncov +uncover +uncps uncross uncrossing +unct unctb uncu uncurried uncurry uncurrybilinear uncurryf +uncurryi uncurrying +uncurryk uncurryleft uncurrymid uncurryobjflip uncurryright uncurrysum +uncurryusized und +unde +undec +undecidable undecided +undecidedpart undeclared undeclaredeffect undecorated undecs undef +undefb +undefbe +undefbp +undefe +undeff +undefg +<<<<<<< Updated upstream +======= undefi +>>>>>>> Stashed changes undefined undefinedness +undefl undefn undefne undefnel +undefo +undefp +undefr +undefs +undeft undefval undefwhenrem +undefx +undel under underapplied +underapprox +underbart underequivofisterminal +underflow +underflowintosurrogaterange +underflows +underflowsp undergo +underlaid +underlay +underline +underlyi underlying +underlyingcmm underlyingiso undermk undermorp undermorphism +underneath underobj underpost unders underscore underscores +underscoresandpatterns +underspec +underspecification +underspecified +underspecify +understa understand +understandable understanding +understood +undertaking undertoalgebra undesirable +undetermined +undex +undf undi +undia +undiabox undiag undif undifabs +undifdc +undifdcss +undifexmid +undiffi undifixp undifr undifrold +undifss +undifv undir +undirec +undirect undirected +undirectedg +undiredge undiscr undisj undisjrab +undispatched +undistribute +undiv +undivert undjudom +undl undm undmrnresiss undo undoes undom +undone +undop +undostack +undouble +undr undual +unductive +undup +unduplicate une +unecessary unedge +unefined +uneithert unelcarsg +unelem unelldsys unelros +unelse unelsiga +unembed +<<<<<<< Updated upstream +======= unemployed +>>>>>>> Stashed changes unen +unenc +unennn +unenum uneq uneqdifeq +uneqdifeqim uneqin uneqri uneqsn unequal +<<<<<<< Updated upstream +======= unequally +>>>>>>> Stashed changes +unequiv +unequivocalp +unescape +unescaped +unescapeerror +unescapequotes +unevolve unex +unexamined unexb unexbold +unexceptional unexd +unexec unexg unexgold unexold +unexpand unexpandchole unexpandcons unexpander unexpandexistsunique unexpandnil unexpected +unexpectedduplicatename +unexpectederror +unexpectederrorinfunction +unexpectedly +unexplicit +unexplode unexplored +unexport +unext unf +unfa +unfact +unfair +unfamiliar +unfash unfi unfib unfid +unfidisj +unfiexmid +unfiin unfilem unfiltered +unfin unfinished unfir +unfix +unfixed +unflatten +unflattenp +unfld unflip +unfloat +unfn unfo unfol unfold +unfoldable unfoldboundaries unfoldboundary unfoldboundaryext +unfoldc unfoldcases unfoldcomponent unfoldconsts @@ -82440,6 +137491,7 @@ unfoldingtrick unfoldinsertions unfoldl unfoldm +unfoldn unfoldnamepred unfoldpartialapp unfoldprojdefaultinst @@ -82448,37 +137500,89 @@ unfoldprojs unfoldr unfolds unfoldsamefun +unfoldvaluearray +unfoldvaluenumber +unfoldvalueobject +unfolfed +unforced +unfork unfortunate unfortunately unfound +unfreeze +unfun +unfunc +unfunctor +ungeneral +ungeneralize unglue +unglueequiv ungluei +unglueisequiv +ungluepathext +unglues unground +ungroup ungroupseqs +ungua unguarded +unh +unhandled +unhappy unhe +<<<<<<< Updated upstream +======= unhealthy +>>>>>>> Stashed changes +unhelpful +unhex +unhidden +unhide unhindered +unhkl +unhkr unhygienic +unhyperg uni uniabio unialeph +unialg +unialgsetclosed +unibag unibrsiga +unic +unica unicast +unicastte unichnidl unicite unicity +unicl uniclaxun unicld unicls unicntop +unicntopcntop +unicocone unicode unicodelinter +unicodescalarvalueischar unicodesymbol unicodevariant +unicoherence +unicoherent +unicone +<<<<<<< Updated upstream +======= unicorn +>>>>>>> Stashed changes +unicorns unictb +unid +unide unidec +unident +unidentified unidif unidifsnel unidifsnne @@ -82507,9 +137611,11 @@ uniexd uniexg uniexr unif +unifcont unifd unifeigenvalues unifi +unifia unifiable unification unifid @@ -82519,10 +137625,12 @@ unifiedcrashawarejournalrefinement unifiedtype unifier unifiers +unifiersi unifiert unifies unifintegra unifintegrable +unifkont unifless uniflessi uniflows @@ -82562,12 +137670,15 @@ uniformequivprod uniformequivprodarrow uniformequivuniformfun uniformextension +uniformfullcorrectness +uniformfullintervalcorrectness uniformfun uniformfunoffun uniformfunon uniformi uniformintegrabl uniformintegrable +uniformintervalsample uniformiser uniformit uniformities @@ -82575,6 +137686,7 @@ uniformity uniformitypath uniformize uniformizer +uniformizertc uniformizingpolynomial uniformly uniformlyon @@ -82582,8 +137694,11 @@ uniformoffinset uniformoffintype uniformon uniformonfun +uniformp uniformpdf +uniformpoweroftwosample uniforms +uniformsample uniformsizedseq uniformsp uniformspace @@ -82593,6 +137708,9 @@ uniformspaceofedist uniformspaceofedistofhasbasis uniformspaceseqcompact uniformstruct +uniformtopology +uniformtype +uniformu unifpw unifset unifsp @@ -82604,6 +137722,7 @@ unifyeqs unifyi unifying unifymovements +unifywl unifyzeroorsucc unifyzeroorsuccresult unii @@ -82619,54 +137738,104 @@ uniin uniinn uniinqs uniintab +uniintabim uniintsn +uniintsnr uniioombl uniioombllem uniioovol uniiun uniiunlem uniixp +unilateral +<<<<<<< Updated upstream +======= unilateralgiving +>>>>>>> Stashed changes unilbeu unilbss unima +unimage unimax +unimin unimodular unimopn +unimplied +unimplies +unimportant unindex +uninduced unineq uninf +uninhabequiv +uninhabited uninit uninitialized +uninitializedthis +uninitialziedthis uninject +uninjected +uninst +uninstantiate unint unintentional uninteresting +unintern +uninterpreted +unintialize +unintialized +unintuitive unio union +unionc +<<<<<<< Updated upstream +======= unioncommutes +>>>>>>> Stashed changes unioncompltosubordinate uniond unione -unionecases unioneqsigmaofdi unioneqsigmaofdisjoint unionfield +unionfind +unionfinestpart unioni +<<<<<<< Updated upstream +======= unionil +>>>>>>> Stashed changes +unionimage unioninter -unionir unionixx +unionkers +unionl +unionlist +unionmap +<<<<<<< Updated upstream +======= unionof +>>>>>>> Stashed changes +unionofvar +unionofvars +unionofvennregions +unionplus +<<<<<<< Updated upstream +======= unionprop +>>>>>>> Stashed changes unions +unionst unionsuminter unionswith +uniontran unionwith +unionwithkey uniop uniopel uniopn uniordint +unip unipotentlower unipotentupper unippc @@ -82678,27 +137847,52 @@ unipw unipwr unipwrvd uniq +uniqappend +uniqappendelement +uniqappendiff +uniqbutlastnotuniqlistimplieslastmembutlast +uniqdistinct +uniqelementstrailimpliesuniqelementsprefix +uniqheadtailset +uniqify +uniqimpliesexclusivetrueorfalse +uniqimpliesnotlastmembutlast +<<<<<<< Updated upstream +======= uniqinunit +>>>>>>> Stashed changes +uniqkrun +uniql +uniqlengtheqcardset +uniqlistimpliesuniqprefix uniqnames uniqoneelementcharacterization +uniqp +uniqpn +uniqremdups uniqs +uniqsch uniqsw uniqu unique uniqueaddequiv uniquealgequiv uniquebaseon +uniqueconclusion uniquecongr +uniqued uniquedif uniquediff uniquedifferentialalgebrafinitedimensional uniquediffon uniquediffwithinat +uniqueelems uniqueelim uniqueembeddingequivresult uniqueequiv uniqueequivequivunique uniqueess +uniqueexists uniqueextensionalonguliftyoneda uniquef uniquefactorization @@ -82718,6 +137912,7 @@ uniquegalx uniquegalxpow uniquegalxsubc uniquegalzero +uniqueguard uniquehom uniquehomsetofinitialisounit uniquehomsetofzero @@ -82725,6 +137920,7 @@ uniquehomtozero uniquei uniqueiioone uniqueindices +uniqueintersectionlines uniqueintmodule uniquel uniqueleft @@ -82734,9 +137930,18 @@ uniquelydecodable uniquemdiff uniquemdiffon uniquemdiffwithinat +uniquemidpoint uniquemul uniquenatmodule +uniquene uniqueness +uniquenessa +uniquenessb +uniquenessh +uniquenesst +uniquenode +uniquenodeidp +uniquenss uniqueofepizero uniqueofisempty uniqueofleft @@ -82756,11 +137961,19 @@ uniqueprod uniqueprods uniqueprop uniquer +uniquerem +uniquerepresentation uniquerepresentative uniqueright uniqueringequiv +uniques +<<<<<<< Updated upstream +uniqueseq +======= +>>>>>>> Stashed changes uniquesigma uniquesingleton +uniquet uniqueto uniquetoterminal uniquetotop @@ -82785,14 +137998,17 @@ unirnffid unirnioo unirnmap unirnmapsn +uniroots unisalgen unisg +unisgned unisn unisnalt unisng unisngl unisnif unisnv +unisorted uniss unissb unissd @@ -82804,23 +138020,35 @@ unisucg unisucs unisym unit +unita +unitabgroup unitabl +unitable unitadd unitaddcircl unitaddcircle unitaddtor unitaddtorus +unitail unital unitalcstaralgebra unitality +unitalitybindreturn +unitalityjoinreturn unitalmagma +unitalnon +unitalsa +unitalseparationalgebra unitalshelf unitapp unitarily unitary +unitarycommutativering +unitarycommutativeringdecision unitaryconjugate unitaryd unitarygroup +unitaryi unitarylinearisometryequiv unitaryselfaddismul unitaryspectrum @@ -82830,49 +138058,68 @@ unitasisoofiso unitaux unitauxaux unitauxauxaux +unitay unitb unitbackward +unitbag unitball unitballball unitballpackage unitbe unitbecomesfalse unitbialghom +unitbind +unitbp +unitc unitcl +unitcld unitclosed unitclosedball unitcoeff unitcofork unitcolimitofpreservescoequalizer +unitcommring unitcomppartialbijective unitcomppartialbijectiveaux +unitconjunct unitdesc unitdisc +unitdisjunct unitdivcld unitdvcl unite -united -unitedstatesgeographypeoplemt unitequalises unitequalizerofcoreflectsequalizer unitequivunitsinteger unitet unitetrees +unitext +unitf +unitfe +unitfn unitfork unitforward +unitfpe +unitfs unitftor unitfunctor unitg +unitgi +unitgie +unitgip unitgroup unitgroupmulequiv unitgrouporderembedding unitgrouptoresiduefieldunits unitgrp unitgrpbas +unitgrpbasd unitgrpid +unithom unithomequiv uniti unities +unitinf unitinterval unitintervalsubmonoid unitinv @@ -82882,20 +138129,32 @@ unitiso unitisoaddequiv unitisoaux unitisoself +unitisosuspunit +unitisunique unitiz unitizati unitization unitizationalgequiv unitizationstaralgequiv +unitize unitk unitl unitlattice +unitlepi unitlike unitlinv +unitliso +unitlmono +unitlnatural +unitm +unitmm unitmul unitmulcl unitmulclb unitmulrprm +unitmx +unitmxe +unitmxz unitnatiso unitnegcl unitnmn @@ -82908,17 +138167,33 @@ unitofiscoprime unitoftensorisounit unitor unitors +unitp unitpartition unitpidl unitprodclb unitpropd +unitpropdg unitr +unitre unitrecon +unitrepi unitring +unitringtype unitrinv +unitriso +unitrm +unitrml +unitrmono +unitrmr unitrn +unitrp +unitrpr unitrrg +unitrv +unitrx +unitrxz units +unitsa unitscentertocenterunits unitscentralizerequiv unitscomplexconj @@ -82958,6 +138233,7 @@ unitsquotequivrelpic unitss unitsscalar unitsscn +unitssd unitssmul unitssmulcommclass unitssmulequiv @@ -82967,30 +138243,67 @@ unitssre unitssxrge unitstopic unitstopicequiv +unitstr unitstypeequivisunitsubmonoid +unitsubinterval +unitsubintervalp unitsubm unitswithzero unitswithzeroequiv unitt unittopushforwardobjunit +unittotypepath +<<<<<<< Updated upstream +unitunique +======= +>>>>>>> Stashed changes unitunit +unitunsized +unitv unitvec +unitvector +unitx unity unityd unityi +unityz unitz +unitzpe +unitzpl uniun uniuni univ +<<<<<<< Updated upstream +======= unival +>>>>>>> Stashed changes +univalence +univalenceiso +univalencepath +univalencestatement +univalenceuah univalent +univalentd +univalenti +univalentstr +univalentwildcategory +univar univariate univball +univboundede +univboundedi +univd unive univeigenvalues +univer univers +universa universal +universalarrowisuniversalproperty +universalcocone +universalcone universalcoprimefactorizationring +universald universalenvelopingalgebra universalenvelopingequivfreealgebra universalfactorizat @@ -82998,6 +138311,7 @@ universalfactorizationmap universalfactorizationmapliftequiv universalfactorizationmappresentation universalfactorizationring +universalfirst universalhom universality universall @@ -83007,17 +138321,31 @@ universallyinjective universallyopen universallyspecializing universalmulhom +universalp universalproperty +universals universalverts universe +universeind universes university +universums +univf univftc +univi +univinf +univl univle +univm univnames +univnodes +univnum +univpf univpi +univr univs univsubsets +univtrunc univunitball univvtx uniwf @@ -83025,47 +138353,105 @@ uniwun unix unixp unixpid +unixpm unixpss unizlim +unj unjp unjps unjust unk unkey +unkeyed +unkhl +unkhr unknown +unknownc +unknownnone +unknownpt unknowns unl unlabel unlabeled unlabelled +unlast +unle unless +unlessl +unlessp +unlessr unlhd +unlickly +unlift +unlifted +unliftf +unliftp unlike unlikely +unlimited unlimitednatural unlines unlink unlinkpcp unlinkpsp unlinkpss +unlist +unload +unloadorder +unlocalize +unlocalized +unlocalizeq +unlocalizing unlock unlockable +unlocked +unlookup unlr +unlucky +unm +unmake +unmanaged +unmap +unmapped +unmark +unmarked +unmasked +unmasking +unmatched +unmatching unmbl +unmerge +unmeta unmixedembeddingsover +unmodeled +unmodifiablelist +unmodified +unmodus unmop unmopequiv unmopfunctor unmultigraph unn unnamed +unnatural +unnder +unne +unnece unnecessarily unnecessary unnecessaryphi unneeded +unnest +unnlist unnode +unnorm +unnormalised +unnormalized +unnormorderedp +unnot unnum uno +unobtainable unocv unon unone @@ -83076,8 +138462,11 @@ unopbd unopcomp unopcounitiso unopelim +unopen +unopeq unopequiv unopequivalence +unopex unopf unopfunctor unopfunctorcompfst @@ -83091,115 +138480,307 @@ unopmap unopn unopnorm unopopiso +unops unopsymm +unopt +unoptiont +unopunique unopunitiso unopunop unopunopcommshift +unor +<<<<<<< Updated upstream +======= unord +>>>>>>> Stashed changes unordered +unorderedpair +unorderedset +unort +<<<<<<< Updated upstream +======= unorthogonal +>>>>>>> Stashed changes +unowned unp unpack +unpackbv +unpacked +unpacking unpair unpaired +unpar +unparam +unparameterize unparsed +unpart +unpartfuncd unpath +unpermute unpickle +unplusm +unpoint +unpointed +unpointiso +unpredictable unpreima +unprime unprimed +unprintable +unprioritized +unpriv +unproc +unproduct unproductive unprot unprotect +unprotected +unprovable +unproved +unproven +unpsatisfiable +unpublished +unq +unqiue unqsym +unqualified unquot +unquote +unquoted +unquotes +unquotesimple +unquotesimpleelem +unquotesimplenonempty +unquoting unr unrab unramfiedlocus unramified unramifiedlocus unramifiedplacesover +unre +unreac +unreach unreachability unreachable +unreachables unreachabletactic +unreached +unreachstatic +unreachstatice +unread +unreadable unrealistically unreasonable +unrecognisable +unrecognised unrecognized unreduced +unref +unrefine +unrefining +unrel unrelated +unrelatedbool +unrenamed +unrendered unreported +unres +unresolv unresolvable +unresolved +unresolvedrhs unrest +unrestrict +unrestricte unrestricted +unrestrictn unrev +unreversed unrhd +unro unroll +unrolled +unroller unrolling +unroot +unrotated +unround uns unsafe unsafebaseio unsafecast unsafedisplay -unsaferuncmd +unsafedivide +unsafen unsaferuncmdtc unsat unsatindices +unsatisfiability unsatisfiable +unsatisfiableatom +unsatisfiableff +unsatisfiableffa unsatisfied +unsatisfying +unscale +unscheduled unscoped unseal unsealing +unsec +unseen +unselect +unselected +unseparate unset unsetenv unsetoption unsettrailing +unsgined +unshackeled +unshared +unshelve unshift unshifting +unsi +unsig +unsiged +unsign +unsigne unsigned +unsignedbyte +unsignedhalfword +unsigneds +unsignedword unsimp unsimpgraph +unsize +unsized +unsizedchecker +unsizedmonotonic +unsizedmonotonicchecker +unsizedresize +unsizedreturn +unskip unsnen +unsneqsn +unsnfi +unsnfidcel +unsnfidcex unsnoc +unsolvable +unsolvables unsolved +unsort +unsorted unsortedeigenvalues +unsound +unsoundness +unspecial unspecified +unspill +unsplit +unsplitk +unsplitting unsquash +unsquashk unsqueezed unss +unssa unssad unssbd unssd +unssdif unssi +unssin +unstable +unstables +unstrat unstratify unstream +unstuck +unsual +unsuballattice +unsubm +unsuccesful unsum +unsumbool +unsup +unsupp unsupported +unsupportedescape +unsupportedsubtract unsuppress unsurprising +unsurprisingly +unswapped +unsweeten unsym +unsynlr unt +untag +untagged +untagresourceensurespublicly +untail +untainted +untaintedp +untame untangle untangtr +untau untelirr +unterminated +unthree +unthunk +unti +untie until +untili untilinj untiljust +untiln untilt untime +untimes untint +untion untop untopa untopd +untouch +untouchable +untouchables untouched +untouchedv +untouching untppr +untrace +untrack +untrans +untransla +untranslate +untranslated untreeify untrop +untrucated +untrue +untrunc +untruncated +untrust untsucf untuni +untypeable untyped +unum unundi unundir +ununifiable +ununion +unuse unused unusedarguments +unusedassignment unuseddecidableintype unusedeverywhereinstances unusedfintypeintype @@ -83207,15 +138788,20 @@ unusedhavessuffices unusedinstancebinders unusedinstances unusedinstancesmsg +unusedlabel unusedparams unuseds unusedsectionvars unusedsimpargs unusedtactic unusedtacticlinter +unusedtypeparameterforfunctionbymethod unusedvariables +unusedvx unusual +unusually unv +unvar unvdif unveldom unveldomd @@ -83223,26 +138809,42 @@ unvisited unvisitedpath unwanted unwantedunicode +unwarranted +unwarranteds unwdomg unwf +unwhile +unwhisker +unwieldy unwind unwindcond unwindi unwinding +unwindintocond +unwinds unwindsd unwindsdcond unwords unwrap unwrapc +unwrapedkmaterial unwraph +unwrapinput +unwrapor unwrapped unwrapping +unwritable +unx unxpdom unxpdomlem unxpwdom unxs +unxx +unz unzero +unzi unzip +unzips unzipwith unzziswdg uobeq @@ -83251,101 +138853,226 @@ uobeqw uobffth uobj uobrcl +uon +uone uoooxipxstchhtrb uop uopen +uopt +uor +uosexist +uoslambda upaco upair +<<<<<<< Updated upstream +upairsingleton +======= upairequniteq upairinpowunion upairset upairsete upairsetil upairsetir +upairsingleton upairsubunion +>>>>>>> Stashed changes +upaperc +uparrow +uparrowunion +upate upath +upb upbdrech +upbnd +upcase upcast +upcastlshiftmasking +upcastrshiftmasking upchar upcic upciclem upclose +upclosed +upcodes +upcoming +upconcat upcrossing upcrossings upcrossingsbefore upcrossingstrat upd upda +updat +updatable +updatd update +updatea +updatealiasensurespublicly updateall updateandadddecl +updatearray updateat +updatebodyproof +updatebyte +updatec +updatecases +updatecat +updateclemma updatecol updateconstantval +updatecontinuousbackupsensurespublicly +updatecontributorinsightsensurespublicly +updatecustomkeystoreensurespublicly updated updatedecl +updatedistinct +updatee updateenv updateenvdup +updateenvoption +updateexisting updateexp updatefi +updatefield updatefinset +updatefns updatefo updatefocus updateforalle updatefp +updategamma +updateglobaltableensurespublicly +updateglobaltablesettingsensurespublicly updategraphwithnlti updategraphwithnltinfsup updatei +updateitemensurespublicly +updatekeydescriptionensurespublicly +updatekinesisstreamingdestinationensurespublicly updatelambda updatelambdabinderinfod updatelast updatelevelparams +updatemap +updatemetrics +updatemetricsforliteral +updatemulti updatename +updatenode updatenth +updatenumnam +updateout +updatepaths updateprefix +updateprimaryregionensurespublicly +updater updatereducibility +updateregression updaterel +updateresize updaterin updaterow +updaters updates updatese updatesi +updatesingleofdouble +updatestate updatesuc +updatesxarray +updatet +updatetableensurespublicly +updatetablereplicaautoscalingensurespublicly +updatethunk +updatetimetoliveensurespublicly updatetrailing updatetype updateunexpander +updateunsafe +updateusagemetadata +updateusagemetadataensurespublicly +updatevaliditymap +updatevaliditymapnull +updatevaliditymultiset +updatevaliditymultisetnull +updatevalidityseq +updatevalidityseqnull updatevalue +updatewf updatewith +updati updating +updatingcostarray +updatingcostarrayi +updatingcostarrayp +upddate +upddefvars +upddes +upddom +upddomain +upde +updenv +updf +updflenv +updi +updid +updidx +updim +updimv +updip +updis +updivm updjud updjudhcoinlf updjudhcoinrg updjudhf updl +updlemmas +updlock updlockn updlocks updlockset +updmap +updmin +updn +updown +updowni +updpt +updptun +updptuno upds updsize updsizeaux updt updthread updthreadc +updthreadr +updthreadrc +updu +updunl +updunpt +updunr updv +upe upeu upf +upfi +upfrom +upfunction upfunctor upfval upgr upgracycumgr upgracycusgr upgrade +upgraded upgradediscompletelymetrizablespace upgradediscompletelypseudometrizablespace upgradedstandardborel upgradeiscompletelymetrizable upgradeiscompletelypseudometrizable upgradestandardborel +upgrading upgraph upgrbi upgrclwlkcompim @@ -83353,14 +139080,17 @@ upgredg upgredginwlk upgredgpr upgredgss +upgredgssen upgredgssspr upgreupthi upgreupthseg upgrewlkle upgrex upgrf +upgrfen upgrfi upgrfn +upgrfnen upgrimcycls upgrimpths upgrimpthslem @@ -83374,7 +139104,9 @@ upgriseupth upgristrl upgrisupwlkalt upgriswlk +upgriswlkdc upgrle +upgrm upgrn upgrop upgrpredgv @@ -83396,27 +139128,57 @@ upgrwlkedg upgrwlkupwlk upgrwlkupwlkb upgrwlkvtxedg +uphalf +uphar upharpoonleft +upi upif +upilist upixp +upjo upl +upleft +uplemma upleq +uplet uplex upln +upload +uploadcode +uploadseg +uplog +upls uplth uplus +upm upmap +upme upmost upmulhom +upnode +upoffset +upoly upon upone upos +upost +upow upp +uppaal +uppe upper +uppera +upperadj upperb upperbasis +upperbd +upperboun upperbound +upperbounde +upperboundinve +upperboundonoccurrencecount upperbounds +upperc uppercamelcase uppercamelname uppercase @@ -83424,8 +139186,11 @@ uppercentralseries uppercentralseriesaux uppercentralseriesstep upperclosure +uppercone uppercrossingti uppercrossingtime +uppercut +upperhalf upperhalfpl upperhalfplane upperhalfplanemk @@ -83436,9 +139201,13 @@ upperhemicontinuous upperhemicontinuousat upperhemicontinuouson upperhemicontinuouswithinat +upperize uppermoebius +uppern +upperp upperpolar upperrighthom +uppers uppersemico uppersemicontinuous uppersemicontinuousat @@ -83449,24 +139218,41 @@ uppersetisolowerset uppersublower uppertopology uppertriangular +upperunittriangle +uppery +uppos upppt uppropd +upr uprcl upre +upred +upright uprod +uproo +uproots +uprop uprule uprulecharacterise uprules ups upset +upsets upshadow +upshift upsilon +upsr upstream upstreamabledecl upstreamabledecllinter upstreaming +upstring +upsub +upsublowup +upsweep upt upto +uptoc uptoe uptohere uptoi @@ -83475,37 +139261,82 @@ uptpos uptposlem uptr uptra +uptrace uptrai uptrar uptri uptrlem +uptruth uptx +upvar +upw upwa upwalks upward +upwardby upwards +upwardsclosed +upwardsclosedorderedkripkemodel +upwardsclosedseparationalgebra +upwardsclosure upwlkbprop upwlksfval upwlkwlk upxp uqbrj +uqconstructorname uqehc +uqi +uqtyop +uquant +uquery +urange +<<<<<<< Updated upstream +======= urated +>>>>>>> Stashed changes urats +ure +urec +uref +uregs +urel urelem urelems urem +urewrite +urf +urg +urgency urgyifyuzutmsw +<<<<<<< Updated upstream +url +======= uri +url urlfn urlreferentfn +>>>>>>> Stashed changes +uroots +uround urow urpropd urruty ursh +ursub +ursubmx +<<<<<<< Updated upstream +======= ursyms +>>>>>>> Stashed changes +urun +urunp +urw +urwn +ury urysohn urysohns +urysohnslemma usa usable usableinsimplexalgorithm @@ -83513,8 +139344,12 @@ usage usagequantifier usages usagetracker +usappconst usb +usbp +usbwidth usc +uscb uscnrripwpsjqlxkzpedysbecigd usdaudllqajjxyccxhiyllmixd usdb @@ -83522,30 +139357,58 @@ usdbeqlen usdbsym usdbtrans use +useafterfree useas +usebetter +usec +usecache useclassical usecongrsimp used +usedbyghost usedec usedefaultsimpset +usedefaultvalues +usedint +usedintloc usedletonly usedlevelnames usednltfacts usedonly usedtheorems +usedvars +usedvx +useensuresfuncfoo +usefoo useful usefulcompression +usefull +useimmediate +useitertocopy +usel useless useloop +usenodes useonce +useopaque +useoption +useordinaryopaque useq user usercongr usererror +userfieldsownedby +userfieldsunchanged +userfn usergroup userid useridasstr userids +userinv +userkey +userlist +userlistcheck +userlistp username usernamepre usernames @@ -83555,16 +139418,33 @@ users userspace usersreaders userswriters +usersyms +usertype +usertypes +uservinv uses +usesfield usesgoal usesimp +usesmaybeint +usesof +usesstatic +usestream +usestreamghost +usesvalid uset +usetc +usethevars +usex usgr usgraph usgrausgrb +usgrausgrben usgrausgri +usgrausgrien usgrcyclgt usgredg +usgredgdomord usgredgedg usgredgffibi usgredgleord @@ -83572,11 +139452,13 @@ usgredgleordalt usgredgne usgredgop usgredgppr +usgredgppren usgredgprv usgredgprvalt usgredgreu usgredgss usgredgsscusgredg +usgredgssen usgreqdrusgr usgrexi usgrexilem @@ -83587,13 +139469,16 @@ usgrexmplef usgrexmpllem usgrexmplvtx usgrf +usgrfen usgrfilem usgrfs usgrfun usgrgrtrirex usgrgt +usgriedgdomord usgriedgleord usgrislfuspgr +usgrislfuspgrdom usgrlimprop usgrn usgrnbcnvfv @@ -83606,11 +139491,13 @@ usgrprc usgrpredgv usgrres usgrsizedg +usgrsizedgen usgrspan usgrspanop usgrss usgrsscusgr usgrstrrepe +usgrstrrepeen usgruhgr usgrumgr usgrumgruspgr @@ -83619,6 +139506,7 @@ usgrunop usgrupgr usgruspgr usgruspgrb +usgruspgrben usgruvtxvdb usgrvd usgrwwlks @@ -83627,18 +139515,32 @@ ushgraph ushgredgedg ushgredgedgloop ushgrf +ushgrfm ushgruhgr ushgrun ushgrunop +ushift +ushr usi +usigma +usimd usin using +usingaarch usingarg +usingeq +usingeqp +usingle usize usjecmngrvdadq +usleep +<<<<<<< Updated upstream +======= usn +>>>>>>> Stashed changes usnu usolution +usolves uspace uspgr uspgraph @@ -83646,10 +139548,12 @@ uspgrbispr uspgrbisymrel uspgrbisymrelalt uspgredg +uspgredgdomord uspgredgiedg uspgredgleord uspgrex uspgrf +uspgrfen uspgriedgedg uspgrlim uspgrlimlem @@ -83673,16 +139577,22 @@ uspgrupgrushgr uspgrushgr uspgrymrelen usphere +usplit uspreg +usqrt usr uss ussid ussval ust +ustar +ustarstar +ustate ustbas ustbasel ustdiag ustelimasn +ustep ustex ustexhalf ustexsym @@ -83694,8 +139604,12 @@ ustinvel ustn ustne ustneism +ustream +ustreams ustref ustrel +ustring +ustructure ustssco ustssel ustssxp @@ -83706,25 +139620,44 @@ ustuqtoplem ustval usu usual +usuall usually usub +usubmx usubs usubst +usubstappt +usubstitution +usum +usumx usvs +usw uswap uswitch uswitchequiv uswitchequivalence +ute +uterm +uterms +utexas +utextpost utf util +utilises +utilitie utilities utility utilityd +utilize utilizing utillib utils utilty +<<<<<<< Updated upstream +======= utlast +>>>>>>> Stashed changes +uto uton utop utopbas @@ -83737,23 +139670,45 @@ utoptop utoptopon utopval utoreorder +utos +utp +utrans utrhny +utt +uttp utu +utw +utwo +utx +<<<<<<< Updated upstream +utxo +uty +utyop +======= +uty +utyop uua +>>>>>>> Stashed changes uub +uubp uuc uuisinvar uun uunit +uunitl uunt uuntt +uusepalg +uuu uuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuu uuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuu uuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuu uuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuu uux uvalid +uvalidl uvalidu +uvar uvariation uvars uvccl @@ -83770,6 +139725,14 @@ uvcvval uvcvvcl uvd uverts +uvf +uvk +uvn +uvns +uvoid +uvp +uvs +uvt uvtx uvtxel uvtxisvtx @@ -83791,11 +139754,22 @@ uwaterloo uwellformed uwjpehkgbrhsjw uwoaujctzybsfzattcglghemcudbiaqa +uwordtoz uwttuhguiltt +uxaaaa +uxckfpe +uxffff +uxtw +uxtx +uxxxx uxyrpehkjnzxkkvdofuv +uych +uyouixg uzaddcl uzct +uzdcinzz uzdisj +uzennn uzenom uzero uzf @@ -83812,10 +139786,14 @@ uzindi uzinf uzinfi uzinico +uzisod uzisoi +uzl +uzled uzlem uzlidlring uzlt +uzltd uzlti uzm uzmptshftfval @@ -83828,6 +139806,7 @@ uzoi uzp uzpow uzr +uzrand uzrani uzrdg uzrdgfni @@ -83848,6 +139827,7 @@ uzssre uzssz uzsubfz uzsubsubfz +uzsucd uzsuci uzsup uzsupss @@ -83858,19 +139838,31 @@ uzub uzubico uzubioo uzublem +uzuzd uzuzi uzuzle uzv uzval uzwo +uzwodc uzxr uzxrd +uzyc +uzytkownikow +uzzd +<<<<<<< Updated upstream +======= vaa +>>>>>>> Stashed changes vabs vabstr +vac +vacant +vacc +vaccv vacn +vacuity vacuous -vacuousdall vacuously vad vadd @@ -83881,74 +139873,273 @@ vaddconst vaddfinset vaddinvariantmeasure vaddr +vaesni vafval vagree val vala +valal valaux valb +valbindv valc valconfigitem +valcount vald +vale +valef valembedding valequiv +valerasure +valeur +valexpr valf valff +valfn valfromgraph +valg +valgm +valh vali valid +validaarunfor +validaddop +validaddsym +validal +validalgorithmsuiteinfo +validamazondynamodbarn +validamazondynamodbresource +validar +validarg +validargs +validargsc +validarmy +validascii validate +validateaction +validatecommitmentpolicyondecrypt +validatecommitmentpolicyonencrypt validated +validateddbtablearn +validatediscoveryfilter +validateencryptioncontext +validatekmskeyid +validatemaxencrypteddatakeys +validatepublickey +validatepublickeyensurespublicly +validatepublickeyinput validates +validatesuitedata validatetitle validation +validator +validawskmsarn +validawskmsresource +validblack +validblock +validblocks +validbuffer +validcatop +validce +validci +validcompressedpublickeylength +validcoord +validcoreopchar validd +validdecryptionmaterials +validdecryptionmaterialstransition +validdown +validdtate valide +valideb +validedge +validempty +validencryptionmaterials +validencryptionmaterialstransition +validenv +validerrorbound +validerrorboundcmd +validerrorboundcorrectaddition +validerrorboundcorrectconstant +validerrorboundcorrectdiv +validerrorboundcorrectfma +validerrorboundcorrectmult +validerrorboundcorrectrounding +validerrorboundcorrectsqrt +validerrorboundcorrectsubtraction +validerrorboundcorrectvariable +validf +validfd +validfie +validfield +validfieldm +validfields +validfilefd validfinite +validfloatvalue validfrom validfroms +validfun +validglobal +validglobalstateopaque validi +validinfixsym +validinput +validinternalconfig +validintervaladd +validintervalbounds +validintervalboundscmd +validintervaldiv +validintervalmult +validintervalsub validity +validk +validkmsarn +validl validlift validlist +validlistsym +validly +validm +validmap +validmultop +validmultsym +validn +valido +validopchar +validp +validpa +validparamsp +validpath +validpointinterval +validpositional +validprefixsym +validprinterdir +validprooftree +validproviderinfo +validproviderinfolength +validpt +validptree +validptun +validptund +validptunv +validpublickeylength +validr +validranges +validrangescmd +validregs +validregstate +validrelop +validrelsym +validroute +validroutep +validrsakeylength valids +validset +validshiftop +validsmallencryptioncontext +validssa +validstate +validstateparamsp +validstates +validsuffixindex +validsym validtrans validtransition +validtransv +validtypes +validtypescmd +validtypetransition validu +validun +validuneb +validunf +validunpt +validunptd +validunptv +validunu +validup +validuser +validutf +validuun +validv validvalseq validvalseqfrom +validvalue +validvars +validx +validxx valimpl +valingrammar +valinject valinjmu +valj valk +valkd valkf valkff valkm valkn valktt +vall vallem valley +vallfun +vallfunk +vallfunp vallist +vallk +vallr +vallre +vallrfun +vallrfune +vallrk valminabs +valmod valmonoidhom valn +valnum +valnums valof valofd valofn +valonpair +valonsingletons +valor valorderemb +valp +valpred +valq +valqk +valr +valrk +valrp vals +valsinj +valsp +valspec +valsseqs +valstamp valstx valt +valtok valtt +valtype +valtypes valu valua valuat valuate +valuated +valuates valuati +valuatio valuation valuationideal valuationofnezero valuationofnezeromod valuationofnezerotofun +valuationp valuationring valuations valuationsubring @@ -83956,9 +140147,13 @@ valuativecommsq valuativecriterion valuativeextension valuativerel +valuatring value +valuea valueaddhom +valuearray valueatinfty +valueb valuecaraudiosystem valuechosen valued @@ -83967,8 +140162,10 @@ valuedcompletion valuedcsp valuedfqtinfty valuedistribution +valuedness valuedp valuedratfunc +valueequality valuegrou valuegroup valuegroupequiv @@ -83976,17 +140173,44 @@ valuegrouporderiso valuegroupwith valuegroupwithzero valuegroupwithzeroisoint +valueh valueknown +valuelist valuemonoid valuemulhom +valuename +valuenotsuc +valueof +valueofl valueorderringhom +valuep +valueparservalid +valuepath +valuerange +valuerangelist valueringhom values valuesa valuesetoid +valuesf +valuesp +valuestate +valuetype valunsafe +valval +valvalid +valvar +valvars +valve +valvote +valword +valzpk van +vanalyze +<<<<<<< Updated upstream +======= vandalism +>>>>>>> Stashed changes vandermonde vangle vanilla @@ -83997,90 +140221,248 @@ vanishing vanishingdiam vanishingideal vankampen +vap vapp +vapprox var +varacom +varapp +varappstar +varargs +varasn varb +varbind +varbindaux +varbl +varbool +varbound +varcan +varcheck +varcl +varcompat +varcount +<<<<<<< Updated upstream +======= varcurr +>>>>>>> Stashed changes vard +varde +vardecl +vardeclassign +vardeclassignlist +vardecllist vardeclnum vardecls +vardef vardesc +vardhandler vardict +vardicts +vardisjoint vardmonotoneinassertion vardmonotoneinphi +vardom vardq vare varepsilon +vareq +vareqlist +varexp +varexpr varfinset varfinsetleft varfix varfixvar +varformula +varfree +varfromcorrectsystem +varg vargs +varhead vari varia variab +variabile +variability variabl variable +variablebou +variablebound variablechange +variableequality +variablegreater +variablei +variableinequality +variableinterval +variableless variablenames +variablep +variablerelation variables +variablesp +variablest +variabletest +variales +varian variance +varianceb +varianced +variancee +variancen variances +variancez variant +variantresolve variants varianttext variation +variationd +variationl +variationn variationon variationonfromt variationonfromto +variationp +variationr variations +variationsn +variationsxx +variationxx +varible varid varies varieties variety +varify +varignon +varinfo +varinit varinput various vark +varkind +varl +varlhs +varlhss +varlist +varlists +varls varmap +varmask +varmasks +varmax +varmem varmonotone varmonotoneaux +varn +varnam +varname +varnamelist +varnames +varnamlist +varnat +varnewacom +varnonoccform +varnotin varnum +varok varout varp +varpairs +varpattern +varposet +varposs varpw varpwval varq varr +varray +varreflind +varrenaming vars +varsa +varsandvaluestocontext +varsc varsd varseq varset +varshift +varsl +varsmodes +varsofs +varsok varsoppositeliterallist +varsp +varspb varspecs varsrng +varsseqs varstate varstoconstants +varsubst vart +vartab +varterm +vartime varto +vartocorrectsystem vartype +vartyper +vartypes varuids +varunchanged +varusefulsystem +varv +varword +varx vary varying +varyseed +varyseedaux +vas vastly +vasyyau +<<<<<<< Updated upstream +======= vative +>>>>>>> Stashed changes vaxiom vayfohu vaynlxn +vbar +vbase +vbasis +vbasisp +<<<<<<< Updated upstream +======= vbb +>>>>>>> Stashed changes +vbgc vbind vbits +vbj +vbk +vbl +vblcase +vblcasei vbldjgozvjavypfsoqjdjvexdgeehvqnc vbn +vbool vbox +vbp +vbs +vbtiklp +vbvyggt +vbyte vcablo vcard +vcases vcass vccl +vcd +vcdarr +vcdarri +vcdarrp vcdi vcdim vcdir @@ -84088,6 +140470,7 @@ vcell vcex vcg vcga +vcgaalgdefinedness vcgadefiniteness vcgadefinitenessvariant vcgaequivalence @@ -84096,42 +140479,73 @@ vcgaismaximal vcgaismaximalaux vcgpdefiniteness vcgrp +vchar +vcharaut +vcharp vchop vci vcidold +vcinjection vciold vcl vclcan +vclo +vcloa +vclosed vcls vcm +vcmp +vcom vcomp vcompapp vcompb vcompd vcompnaturality +vcond +vconfig vconngr +vcons vconst +vcont +vcossa +vcount vcrel +vcross +vcs vcsm vct +vctxt +vctype +vcvt vcwo vcz vczcl vdash +vdbl +vdc +<<<<<<< Updated upstream +======= vdd +>>>>>>> Stashed changes +vded vdegp vderiv vdgfrgrgt vdgn vdif +vdiff vdioph vdiscusgr vdiscusgrb vdisjnt +vdiv +vdm +vdmwhile vdn vdname vdoeuww vdomain +vdot vdp vds vdumgr @@ -84149,8 +140563,12 @@ vdwnn vdwnnlem vdwpc vea +<<<<<<< Updated upstream +======= veabs veb +>>>>>>> Stashed changes +vebleian veblen veblenwith vebt @@ -84158,41 +140576,73 @@ vebti vec vecalt vecappend +vecc veccons vecconsunexpander vecd vecempty vecemptyunexpander +vecfun vechead +veci +vecimem +vecimemp +vecinmem +vecinst +vecinstp +vecisa +veclemmas +vecli +veclist +veclistlist +vecmat +vecmatrix +vecmats vecmul vecmulbilin vecmullinear vecmulsl vecmulvec vecmulvecbilin +vecnatx vecnegate +vecopcode +vecp vecq vecs +vecset +vecsi +vecsim vecsp vecspace +vecsplitreplicate vecssmod vecssmodel +vecsum vect vectail vectappendlength vectappendnilrightneutral +vectaxiom vecteur +vectfinmixin +vectgroup vectindexmap vectlengthmap vectmapcompose vectmapid +vectmetr +vectmixin +vecto vectop vector vectorall vectorallp +vectorbase vectorbundle vectorbundlecore vectordef +vectoredp vectorequiv vectorequivarray vectorequivfin @@ -84201,75 +140651,166 @@ vectorfield vectorfouri vectorfourier vectorize +vectorized vectorjoining +vectorlist vectormeasure +vectorof +vectorofmonotonic +vectorofunsized +vectorp vectorprebundle vectors vectorspace vectorspaceuniform vectorspan vectorsprodeqone +vectorsum +vectortolist vectortriple +<<<<<<< Updated upstream +======= vectoru +>>>>>>> Stashed changes +vectorupdate +vectorv +vectq +vectquot vectreversereverse +vects vectsp +vectspstr +vecttype vectzipwithcomm +vecv +vecx vee veffqpolz vehicle +vein velab velcomp -veleaf velocityjoining velpw velpwalt velsn vempty +vend vending +venice +venicedeclarationok +venicereferenceok +venn +vennregion +venue +<<<<<<< Updated upstream +venv +venviron +======= +venus venv +venviron veout +>>>>>>> Stashed changes veq veqab veqaeq ver verbatim verbose +verbosep +verbosity +verbp verdict verdicts verdier +verhoog +veri +veric verif +verifiation +verificatiion verification +verificationissues +verificationkey +verificationtask verified +verifiedmid +verifiedtail verifier +verifiers verifies verify +verifyall +verifyensurespublicly verifygrind verifygrindsuggestions verifying +verifymacensurespublicly +verifyme +verifymessage +verifysignature +verifythis +verifythisonly verifytrythissuggestions +verilog +verilogify verisimdb veristar +veronesespace +verr +verrion +verror +versa verschie verschiebung verschiebungfun verschiebungpoly +versi +versio version +versionactivebranchkey +versionbranchkeyitem versionedidentifier +versionkey +versionkeyensurespublicly versions verso versoheader +versor versus vert -vertebrate vertex +vertexarray +vertexarrayi +vertexarrayp +vertexat vertexc +vertexcolorassignment +vertexcolorassognment +vertexcount vertexcovernum vertexgroup vertexgroupisomofmap vertexgroupisomofpath +vertexhascolor +vertexi +vertexinfo +vertexlist vertexoperator +vertexp +<<<<<<< Updated upstream +======= vertexrp +>>>>>>> Stashed changes +vertexscheme +vertexselector +vertexseparator +vertexseq vertexsubgroup +vertextype +vertextypes +vertica vertical verticalclosedstrip verticalcomposition @@ -84279,7 +140820,11 @@ verticalsegment verticalstri verticalstrip vertices +verticescount +verticesfrom verticesset +verticies +verties verts vertsg vertst @@ -84287,46 +140832,109 @@ verum verus very verynice +verystrict +veryweakunivalence ves +vev +veval +veventually vex vextru vexw vexwt +vfaat +vfalse vfermltl vfermltlalt vff vffqxiupuwpjhjno +vfh vfin +vfinnc +vfinncsp +vfinncvntnn +vfinncvntsp +vfinspclt +vfinspeqtncv +vfinspnn +vfinspss +vfinspsslem +vfintle +vfloat +vfma +vfms vfmutdi +vfn +vfp +vfpexpandimm +vfpextension +vfpv vfq +vfree +vfrees +<<<<<<< Updated upstream +======= vfresh +>>>>>>> Stashed changes vfriendship vfriswmgr vfriswmgrlem +vfrom +vfromlist vfsequence +vfst +vft vftsi vfun +vfunc +vfuncdiff +vfunct vfval vge +vgen +<<<<<<< Updated upstream +======= vgensym +>>>>>>> Stashed changes +vgh +vgraph +vgraphseq vgrex vgt vhcomp vhd +vhdl +vhe +vhead vhg +vhi +vhimg vhmcls vhom +vhs via viable +viae viaembedding viaembeddinghom viaequivalence viafintypeembedding +viafp viai +viamapcomprehension +viasetcomprehension +vib +vic +vice +<<<<<<< Updated upstream +======= victor +>>>>>>> Stashed changes +victory vid vide videc +vids vidx vieta vietadeg @@ -84334,6 +140942,7 @@ vietalem vietoris view viewed +viewing viewkabstractsubexpr viewl viewln @@ -84341,78 +140950,169 @@ viewnres viewpoint viewpoints viewr +viewres viewrn views viewsubexpr +vif vii +viia +viib +viic +viii +viiia +viiib +viiic viin vim vimage +vimagei +vimap +vimaplsv +vimapn +vimapv vimp vin +<<<<<<< Updated upstream +======= vincent +>>>>>>> Stashed changes +vincident +vincl +vinf vinh vinj vinsert +vinserti +vinst vint -vintage -vintageyear vinv vinvequiv vio +violate +violated violates violation violations +<<<<<<< Updated upstream +======= violentcontest +>>>>>>> Stashed changes +vip +vipr +viprs +virt +virtual +virtualization virtue +virtuelp virtuethread vis +visb visclopen +visf +<<<<<<< Updated upstream +======= visfreevar +>>>>>>> Stashed changes +visib visibility visible +visiblei visit visitandcast visitatom visitconst visited visitedfvars +visitedp visitedstates visiting visitinner visitm +visitor visits visitstep visittoken visittracenodesm visitwithandascendm visitwithm +visl +vislr +visor +visow vispost +visr +vistgt +visv +<<<<<<< Updated upstream +======= visvalue +>>>>>>> Stashed changes vit vitali vitaliconvergence vitalifamily +vitalik vitalilem +viter viterbi +viterff vjsrgxnmizfgoyvgbd vjust +vkey vksyiwhvxgyxshtzepeoxhi +vla +vlabel +vlabeled +vlabeling +vlabelingseq +vlabelselector +vlam +vlambda +<<<<<<< Updated upstream +vlan +vlanid +vlanpriority +vlans +======= +vlanid +vlanpriority +>>>>>>> Stashed changes vlcm +vlcti +vld +vldp vle vlem +vlength +vlg +vlhs +vlhses vlib vlid +vlift +vliftw +vline +vlinep vlinest vlist +vlla vln +vlo vload +vloc +vlogic vlong vlookup +vls vlsrc vlt vlttop +vlub vlunc +vlv +vlx vma vmacl vmadivsum @@ -84422,32 +141122,62 @@ vmaf vmage vmalelog vmalogdivsum +vmap +vmaplist vmappw vmaprm +vmask +vmasklist vmasum vmatch vmaval +vmax +vmbug +vmc vmcn +vmem +vmfoo vmin +vmm +vmov +vmrs +vms vmsa vmsaverismo +vmsg vmul vname vnat vnbpr +vncan vne +vneg +vneulem +vneulemexp +vneverholds vnex vnil vnk vnl +vnlem vnm vnmd vnmi vno +vnode +vnormalize +<<<<<<< Updated upstream +======= vnotype +>>>>>>> Stashed changes vnpctndjxfelzlzrsj +vnregular +vnregularity +vnsub vnuid +vnullptr vnum +vnumberingseq vnumbmorethanone vnuminus vnumprecision @@ -84456,11 +141186,27 @@ vnunb vnunum vnuplus vnz +<<<<<<< Updated upstream +voffset +voice +void +voidabsurd +======= vocalizing +voffset voice void +>>>>>>> Stashed changes +voidcontainer +voidge +voidgv +voidk +voidoutcome +voidp +voidsuccess vol volatile +volatileowns volcn vold volf @@ -84477,6 +141223,7 @@ volicore volicorecl volicorege volicorescl +volid volinun volioc volioo @@ -84491,6 +141238,9 @@ voliunlem voliunnfl voliunsge volivth +vollab +vollabi +vollabp volmea volmeas voln @@ -84500,6 +141250,9 @@ volss volsup volsuplem volsupnfl +volt +voltage +voltages volume volumeform volumeioipow @@ -84507,10 +141260,14 @@ volumepreserving volumepreservingsymmmeasurableequivtolpprodaux volumes volun +vomap +vomapv von +vonce voncl voncmpl vonct +vone vonf vonhoi vonhoire @@ -84526,6 +141283,7 @@ vonnbornology vonneumann vonneumannalgebra vonsn +vonstaudt vonval vonvol vonvolmbl @@ -84536,6 +141294,11 @@ vopelopabsb vopen vopnbgrel vopnbgrelself +vopt +voraciousadd +voraciousreader +voronoi +vos vot vote votedfor @@ -84544,51 +141307,96 @@ voters votes votesreceived voteswithlog +voting votkcalmtojwvmx +vout +vpa +vpaddd +vpair +vparams +vpast +vpeak vpeolsgtmqaeqrjbf vpeq +vpg +vpi +vpick vpikwcxzojmwsfxaomtvxwmnacf +vpincl +vplub +<<<<<<< Updated upstream +======= vplus +>>>>>>> Stashed changes +vpm +vpn vpos +vposn vpow +vpowmul +vpq vpqt vpr +vpra vprc +vpro +vprod vprog +vprojection +vps +vpshufb vptr vptrofs vpullbackcone vpullbackconeislimit vpullbackconeislimitofmap vpwex +vpwshto +vpxor +vqfymzy vqlquerytype -vqt vquot +vqv vra vraag vram vrange vrecabs +<<<<<<< Updated upstream +======= vreduce +>>>>>>> Stashed changes +vrefl +vrel vrelated +vrep vres vrestr +vret vreturn +vrf vrg vrgpf vrgpfval vrgpinv vrgpval +vrhs +vrhses vrid vrmdf vrmdfval vrmdval vrmutdi vrnfibi +vroa +vroom +vrp +vrs vrules vrulesi vsa vsagree +vsbrowns vsca vscacn vscaid @@ -84598,33 +141406,105 @@ vscandxnbasendx vscandxnmulrndx vscandxnplusgndx vscandxnscandx +vscaslid vscl vsd +vse vsep +vsequality +vsequalityblocks +vsequalityblockslimited vset vsetrec vsets +vsf vsfval +vsgc +vsgeneral +vsgeneralblocks +vsgeneralblockslimited +vsh +vshape +vshapes +vshp +vshs +vsi +vsig +vsigma +vsigmai +vsince vsingle +vsingleton vsize +vsk vsl +vslegblocks +vsluckiest +vsluckiestblocks +vslucky +vsluckyblocks +vsm vsn +vsnd vsnex vsnid +vsolve +<<<<<<< Updated upstream +======= vsomeexp +>>>>>>> Stashed changes +vsopt +vsp +vspace +vspacef +vspaceover +vspaceoverp +vspacep +vspec +vsplit +vsproj +vsprojk +vsqrt +vsr vss vssjxahvhjggwxi +vssub +vssubw +vst +vstk vstore +vsu vsub +vsubgraph +vsubmxk vsubset vsubst vsubsta vsubu +vsubunsafe +vsuc +vsuccs vsum vsv +vsval +vsvalk +vsymbol +vtable +vtables +<<<<<<< Updated upstream +======= vtcheck +>>>>>>> Stashed changes vtensorone +vterm +vth +vtimeout +vtimes +vtimesi +<<<<<<< Updated upstream +======= vtin +>>>>>>> Stashed changes vtl vtocl vtoclb @@ -84647,20 +141527,31 @@ vtoclgft vtoclold vtoclr vtoclri +vtop +vtr +vtrans vtrue vts vtscl +vtspec vtsprod vtsval +vtt +vttree vttwfk +vtw vtx vtxd vtxdeg vtxdeqd +vtxdfifiun vtxdfiun vtxdg vtxdgelxnn vtxdgf +vtxdgfi +vtxdgfif +vtxdgfifival vtxdgfisf vtxdgfisnn vtxdgfival @@ -84677,71 +141568,124 @@ vtxduhgr vtxduhgrfiun vtxduhgrun vtxdumgr +vtxdumgrfival vtxdumgrval vtxdun vtxdusgr vtxdusgradjvtx vtxdusgrfvedg +vtxdusgrfvedgfi vtxdusgrval vtxdushgrfvedg vtxdushgrfvedglem +vtxduspgrfvedgfi +vtxduspgrfvedgfilem +vtxedgfi vtxeu vtxeualt +vtxex vtxlem +vtxlpfi vtxnbuvtx vtxrgr vtxrusgr vtxval +vtxvalg vtxvalprc vtxvalsnop +vty +vtype vubyte vund vundef vuniex +vunion +vuntil vusgr +vuy vuyzfgc vva vvaln vvar vvars vvc +vvci vvd vvdifopab vvdqhsl +vves +vvex +vvfunext +vvnv +vvoid vvp vvpstar +vvs +vvsqenvv +vvsubsta +vvsv vvv vvvv vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv vvwlci +vwaa vwalk vwb +vwelldefined vwf +vwl +vwlsi vwltsi vwmgr +vwomlem +vwomr +vwsim vww +vwx vxa +vxe vxnvxzrerjxyspwyoudyprwvukqnittrzybtpcxmdquc vxp +vxs vxv vxxsvnayxijglxzlrjamrdskeezlnequdjxgcadfjp +vxy vydra +vying vymqhwgiwerhjutkpgpmybkjpdunvphtdjkqxixugkmq +vys vythcb vyx +vzero vzsblwlktqcz +waa wab wabs +wacc +waction wadler waerden +wag +wahjr wait +waitabort +waitcommit +waite waiting +waitingfor +waitprep +waits waj wakeup +wal +waldemar +walist walk walkdecomp walkdir +walkdom +walke walker walking walkingcospan @@ -84759,77 +141703,224 @@ walkingparallelpairopequiv walkingreflexivepair walkingspan walkingspanopequiv +walklen walklengthtwoequivcommonneighbors +walkof walks walksm walkson walkstar +walkstarr +walkup wall +wallace wallen wallis wallispi wallispilem +walras +walter +<<<<<<< Updated upstream +======= wamt +>>>>>>> Stashed changes +wan +wanass +wancom wand +wanda wandi +wandop +wandq wands +wandsp +wandspadj +wandspe +wandspi +wandspl +<<<<<<< Updated upstream +======= wanica +>>>>>>> Stashed changes want wanted wanting wants war +<<<<<<< Updated upstream +warehouse +======= +>>>>>>> Stashed changes +warg +warm warn +warnable warnattr warnattrcore +warni warning warningaserror +warningerr +warninglist warnings +warningsa +warningsb +warningtree +warningtriggertest warnonnonterminal +warnp warnparametricattr +warnreach +warns +warrant +warranted +warrants +warren warshall wary waryi was +wasaki +wash +<<<<<<< Updated upstream +======= washing washington +>>>>>>> Stashed changes wasm wasn +waste +wasted wasteful +wasting +wasunsized +wat watch +watchinvariantsafterapplybackjump watchinvariantsafterapplylearn watchinvariantsafterassertliteral +wate water +waterfall +<<<<<<< Updated upstream +waters +waterstep +waterstepp +======= waterlevel +waters +waterstep +waterstepp watervehicle +>>>>>>> Stashed changes watfvaln +watt watvaln +waufche +waux +<<<<<<< Updated upstream +wavelength +wavelengths +======= +>>>>>>> Stashed changes wax way +wayabove +wayb +waybe waybel +waybelow +waydown ways +wback wbal wbalanced +wbase wbc +wbctr +wbile +wbinopdefuniq wbis +wbisim wbist +wbit +wblarhh +wbltr +wbreg +wbsm wbt wbtw +wbu +wbuf wca +wcantor +wcar +wcbtr wcc +wcclause wcd +wcdecl wcdeq wcdnoninterference wcet +wcfg +wch +wchar +wchoice +wck +wclause wclopen wclyhjuabzzlluyiaesdilebfjozm +wcmap +wcml +wcnf wco +wcode +wcom +wcoman +wcomcom +wcomd +wcomdr +wcomlem +wcomorr +wcompact +wcompat +wcompatible +wcon +wconf +wconnected +wcons +wconsistent +wconst +wconstant +wconti +wcopyspec wcovby +wcp +wcprovable wcr +wcsb +wcsp +wct +wctl +wctr +wcu +wcurve +wdart +wdbl +wdcom +wddi +wdec wdef wdemo wdest +wdf +wdi +wdid +wdka +wdm wdmu +wdn wdnu wdom wdomac @@ -84843,7 +141934,11 @@ wdompwdom wdomref wdomtr wds +wdvdlen +wdwom weak +weakaffsegm +weakaffvect weakbilin weakbisim weakbisimbangrel @@ -84854,27 +141949,45 @@ weakbisimulation weakbisimupto weakbisimweakcoinductaux weakbisimweakupto +weakct weakdual +weake weaken weakenbisim weakenbisimeqweakbisim weakenbv weakened +weakenfin +weakeni +weakenin weakening +weakeningfindata weakenlte weakenmonocoinduct +weakenrespto weakentransitioncases weakeqsubset weakequ weakequivalence weakequivalences +weakequivlance weaker weakest +weakestprecondition weakfepair +weakfunext +weakhomo +weaki weakinduction +weakinverse +weakiso +weakk +weakkancomplex weakl +weaklinearorder weakly weaklyconnectedcomponent +weaklyconstant weaklycovers weaklydecidable weaklyetale @@ -84882,31 +141995,81 @@ weaklylocallycompactspace weaklyqua weaklyquasifiniteat weaklyregular +weakm weakmonocoinduct weakness +weaknesses weakobseq +weakord +weakorder +weakpdgbackwardslicecorrect +weakpost weakr weakrankfunction weakrankfunctionequiv +weaks +weaksemantics +weaksemanticsmono weakspace +weaktopology +weakunivalence weakuntil +weakz +wealth +<<<<<<< Updated upstream +======= weapon weaponofmassdestruction +>>>>>>> Stashed changes wear +wears +weave web +weber +webi +<<<<<<< Updated upstream +======= webnjiteducjohnsontreebiochhtm wec +>>>>>>> Stashed changes wecmpep +wed +wedderburn +weddwitt wedge +wedgeconfun +wedgeconfuns +wedgeconhlev +wedgeconhlevpath +wedgeconleft +wedgeconright +wedgeconsn +wedgef wedgeintegral +wedgemaps +wedges +wedgete +wednesday +weds +wee +weed +week +weekday ween weeq +weex +weexpn +weexpz wef wefr wefrc +wegdamit wegman +wegraph +wegraphseq wei weie +weierstr weierstrass weierstrasscurve weierstrassdistinguished @@ -84919,7 +142082,12 @@ weierstrasspexceptsummand weierstrasspseries weierstrasspsummand weierstrassunit +weigh +weighing weight +weightarray +weightarrayi +weightarrayp weighted weighteddecomposition weighteddegree @@ -84941,12 +142109,21 @@ weightm weightmap weightofeps weights +weightselector +weightseq weightspace weightspaceofislietower +weigth weinvf weinxp weird +weirdalways +weirdchars +weirdidentity +weirdint weirdly +weirdo +weirdstrings weisoeq weiunfr weiunfrlem @@ -84959,65 +142136,128 @@ weiunwe wel welb welcome +welfare well wellapproximable wellbehaveddischarge +wellchained +wellconstrained welldef +welldefined welldefinedtowellformedset +welldefl +welldefr wellf +wellfnd wellfo wellformed wellformedbasis +wellformedcodeunitseq wellformedcons +wellformedformula +wellformedformulacorrect +wellformedformulaispr +wellformedness wellformednil wellformedsubst +wellformedterm +wellformedtermcorrect +wellformedtermispr +wellformedterms +wellformedtermscorrect +wellformedtermsispr +wellformedtermterms +wellformedtermtermscorrect +wellformedtermtermsispr wellformedtoset wellformedtosetinrangeexplode wellfounded wellfoundedgt +wellfoundedlexlessstate wellfoundedlt wellfoundedon +wellfoundedprecedesorder wellfoundedrelation +wellfoundedsatflaglessstate +wellfoundedterminationlessstate +wello +wellor +wellord wellorder +wellorderable +wellorderarithmetic wellorderedbasis wellorderextension wellorderi wellorderinductiondata -wellorderingax wellorderingrel +wellorders wellpowered wellquasiordered wellquasiorderedle +wellset +wellspace +welltype welltyped +<<<<<<< Updated upstream +======= +welltypert +>>>>>>> Stashed changes +wem wemaplem wemappo wemapso wemapsolem wemapwe +wemma wemoiso +wen weniso went weon +wepo wepwso wepwsolem weq +weqb +weqi +weqprojco wequalslocallybijective wequiv were weren wereu +wersja wesbunbfqah wesn weso wess +wessep wessf west +<<<<<<< Updated upstream +======= westof +>>>>>>> Stashed changes +wesubgraph +wet weth +wether wetrep +wetriext wetzel +weu +wev wevgblacfn +wevgraph +wevgraphseq +wevsubgraph +wex wexp +wexpand +wexpansion +wexps +wextension weyl weylgroup weylgroupcorootrep @@ -85025,6 +142265,16 @@ weylgrouprootrep weylgrouptoperm wfac wfactors +wfadjacency +wfadjpair +<<<<<<< Updated upstream +======= +wfair +>>>>>>> Stashed changes +wfal +wfall +wfand +wfatomtop wfaxext wfaxinf wfaxnul @@ -85034,53 +142284,136 @@ wfaxreg wfaxrep wfaxsep wfaxun +wfboolless +wfboollessstate +wfbst wfc +wfcfep +wfcl +wfctxt wfd wfdvdmonoid wfe wfelirr +wfenv +wfescort wff +wffa +wffm +wffo wffp wffr wffs +wffso +wffstate +wfftype wfg +wfgraph wfgru +wfh wfi wfii +wfinduction wfis wfisg +wfixedlist +wfixlist +wfixn +wfixw +wfjust +wfkey +wfkeyed +wfks wfl +wflearnlessstate wflem +wflexlessrestricted +wfloor wflt +wfm wfmbz +wfmin +wfml +wfmultless +wfmultlessstate +wfn +wfnfa +wfor wfp +wfpath +wfpeg +wfpf +wfpfun wfprd +wfproof +wfquant wfr wfrank +wfrb wfrdmcl wfrdmss wfrec wfrel wfrfun +wfrm wfrrel wfrresex wfs wfsf +wfsk wfst +wfstk +wfstructure +wfsubst wft wftac +wftlist +wftrans +wfun +wfuncdefuniq +wfv wfximgfd +wgdhppi +wge wgeq +wgframe wgraph +wgraphselectors +wgraphseq wgreater +wgs +wgt +wgtd +wgvwske +wha +whamo +whandler what +whataboutthis whatever +whatevz +whatischaracterfive +whatisseq +whatisthis +whats +whatsinthebox whatwhere +whd whe +whead wheel +wheeler +wheels +wheher when +whence +whenev whenever +whenfail +<<<<<<< Updated upstream +======= whenfn +>>>>>>> Stashed changes wheninj whenjust whenlinteractivated @@ -85092,23 +142425,60 @@ whenppoption wher where whereas +whereeq +wherein +wheret whether whi whic which +whichever +whichnum +whichtype +whil while whilea +whilealt +whileanno +whileannog +whilebody +whilecaseregression +whilecond +whiledmonotone whilefalse +whilefreds +whilegend +whilegexec +whileghalt whilehighcompositionality whilei +whileit +whilek +whilelend +whilelexec +whilelhalt +whileloop +whileloops whilelowcompositionality whilelowstepinduct +whilemerge +whilenend +whilenexec +whilenhalt +whilenot +whilent +whileprogram +whileredsthrow whilerule whiles whilesr +whilestar whilestepinduct whilet +whiletreds +whiletredsthrow whiletrue +whis whisk whiske whisker @@ -85140,6 +142510,7 @@ whiskerings whiskerisbilimitiff whiskeriso whiskerisomapgeneratecocone +whiskerl whiskerlef whiskerleft whiskerleftfunctor @@ -85151,6 +142522,7 @@ whiskerlist whiskerofcommute whiskerofcompidisoself whiskerofidcompisoself +whiskerr whiskerri whiskerrigh whiskerright @@ -85164,20 +142536,26 @@ whiskervertical whistles white whiteboard -whitebordeaux -whiteburgundy whited whitee +whitehead +whiteheadslemma whitei +<<<<<<< Updated upstream +whiten +whitening +======= whiteloire +whiten +whitening whitenonsweetwine +>>>>>>> Stashed changes whites whitespace whitespacebeforesemicolon whitespacelinter +whitespacet whitespot -whitetablewine -whitewine whitney whnf whnfcore @@ -85189,19 +142567,39 @@ whnfpred whnfquantifier whnfr who +whoa +whoever +whoknows whole +wholeenchilada +wholeenchiladanew +wholerange +whom +whoops whose +whs +whstar +whther why +whyml +whynot wibble +wic +wid wide widecoequalizer widecoequalizeriswidecoequalizer widecospan wideequalizer wideequalizeriswideequalizer +widefelem +wideh wideinducedfunctor +widely widen widening +wideninterval +widens widepullback widepullbackcone widepullbackdiagramofdiagramover @@ -85226,6 +142624,7 @@ widepushoutshapeunop widepushoutshapeunopop wider widespan +widespread widest widesubcategory widesubcategoryinclusion @@ -85233,35 +142632,88 @@ widesubquiver widesubquiverequivsettotal widesubquiverhascoetosort widesubquiversymmetrify +widg widget +widgp +widgs +widt width +widtha +widthb widthinfty +widthlist +widthm widths +widthsfixed +widthslist wielandt wiener +wierd +wiexpn +<<<<<<< Updated upstream +======= wife +>>>>>>> Stashed changes wifodhqtub +wig wigcserdjjmwn +wiggle +wihou +wihout +wihtout +wij +wik wiki wikipedia +wikipedii +wild wildand +wildca wildcard wildcards +wildcat +wildcatcompnotation +wildcatego +wildcategory +wildcategorynotation +wildcathomnotation +wildcatidnotation +wildcatiso +wildcatnotation +wildcatobj wilddot +wildelim +wildeq +wilder wildexists +wildforall +wildfunctor +wilding +wildisiso +wildmonad +wildnatiso +wildnattrans +wildneq wildor wildpos wildpure wildstar wildwild +wilfred will williams +willing +willnotsplitwithoutdelim willroundtrip +willsplit +wilson wilsons wilth wilthimp wilthlem wim +wime +wiml win winacard winafp @@ -85269,11 +142721,22 @@ winafpi winainf winainflem winalim +winalt winaon +winconsistent +wind +winden winding +windinghom +windingklein +windingt +windingtorus +windmill window windows windowslineending +<<<<<<< Updated upstream +======= wine winebody winecolor @@ -85283,23 +142746,50 @@ winegrape winery winesugar winetaste +>>>>>>> Stashed changes +wings winker winkerp winkerr winl winner +winners winning winningallocationismaximal winningallocationismaximalwithoutseller winr +wins +winst wint +wintlist +wintn +wintnlist winv wip +wir wire +wirealist wired +wiredecl +wireidx +wireinfo +wirelist +wiremap +wirena +wirename +wireoff +wireoffset wires +wiresearch +wiretablei +wiretablep +wirevals wiring +wirtinger +wis wise +wish +wishes wiso wit witd @@ -85323,6 +142813,7 @@ withauxdecl withbindingbody withbindingbodyunusedname withbindingdomain +withbody withbooloption withbot withbotcoe @@ -85358,6 +142849,7 @@ withdensity withdensitysmulli withdivisionring withdivring +withdraw withe withenableinfotree withensuringlocalinstance @@ -85379,17 +142871,35 @@ withidealfilter withimportmodules within withincdischargedepth +withincomplex withincreasedtransitiondepth withincrecdepth +withind +withine +withinet withinfo withini withinitial +withinn +withinp +withinreal +withint +withinu +withinv +withinvret +withinvstep +withinw +withk +withkeyword withl withlams withlawson withlctx +withleakageevent +withleakageevents withlength withletdecl +withlive withlocaldecl withlocaldecld withlocaldeclq @@ -85412,6 +142922,9 @@ withlpuniqueprod withmacroexpansion withmaincontext withmctx +withmem +withmethods +withmetrics withmoduletopology withmoduletopologyadj withnamingcontext @@ -85423,12 +142936,16 @@ withnestedexistsintro withneweqs withnewlocalinstances withnewmctxdepth +withnextpc withnondepproplocation +withnull withoffendingflows withone withonecongr +withopaquestr withoptionatcurrpos withoptions +withou without withoutcdot withoutcdotcontents @@ -85443,8 +142960,11 @@ withoutmodifyingstate withoutmodifyingstatewithinfoandmessages withoutposition withoutrecover +withouttermination withoverapp +withp withparam +withpc withpitopology withppoptions withpreorder @@ -85454,6 +142974,7 @@ withreader withreducible withreducibleandinstances withref +withregs withresetcache withresetserverinfo withreverted @@ -85472,6 +142993,7 @@ withstrictness withsubsingletonasfast withsynthesize withsynthesizelight +witht withtacticinfocontext withterminal withterminfocontext @@ -85490,6 +143012,7 @@ withtracenodebefore withtransparency withtreectx withtype +withtypet withupper withupperhomeomorph withupperset @@ -85502,14 +143025,22 @@ withvalintegersuniformequiv withvalringequiv withvaluniformequiv withvar +withvariantwhile withweaknamespace +withwitnessesfrom +withxaddrs withzero withzeromul withzeromulint withzerotopology withzerounits withzerounitsequiv +witn +witne +witnes witness +witnessed +witnessedtype witnesses witnessi witnessing @@ -85532,28 +143063,68 @@ wittsub wittvector wittzero wittzsmul +wjscpro +wkey +wkeys +wkj +wklist +wkr wksfval wkslem wksonproplem +wksplit wksv wktclzusdtw +wkzzeeh +wlab +wlambda +wlambdad +wlan +wlbtr +wle +wlea +wleao +wleast +wlebi +wlecom +wlecon +wledi +wledio +wlel wlem +wlength +wleo +wleoa +wler +wleran +wleror +wletr wli wlim wlimeq wlimss +wline +wlist +wlistj +wlive wlk wlkcl +wlkclg wlkcomp wlkcompim wlkcpr +wlkcprim wlkd +wlkdc wlkdlem +wlkelvv wlkelwrd wlkepvtx wlkeq wlkeqi +wlkex wlkf +wlkfg wlkiswwlks wlkiswwlksupgr wlkiswwlkupgr @@ -85566,6 +143137,8 @@ wlklnwwlkln wlklnwwlklnupgr wlklnwwlkn wlklnwwlknupgr +wlkm +wlkmex wlkn wlkneq wlknewwlksn @@ -85582,9 +143155,12 @@ wlkons wlkonwlk wlkop wlkp +wlkpg wlkprop +wlkpropg wlkpvtx wlkpwrd +wlkpwrdg wlkres wlkreslem wlksnfi @@ -85596,108 +143172,346 @@ wlkspthlem wlkswwlksen wlkswwlksf wlkv +wlkvg wlkvtxedg wlkvtxeledg +wlkvtxeledgg wlkvtxiedg +wlkvtxiedgg +wlkvtxm wlkvv +wlln +wloc wlog wlogcore wlogle wloglei wlogresult +wlor wlp +wlpo +wls +wlsabs +wlsbinp +wlshift +wlsinp wlt +wlvc wmap +wmar +wmask wmax +wmb +wme wmeas wmem wmin +wminus +wminusn +wminusz wmk +wml +wmod +wmon +wmonotonic +wmove +wmoveaux +wmovesingle +wmp +wmpn +wmpz wmqwgvjqrhpan +wms +wmsb +wmseparation +wmul +wmulls +wmuln +wmult +wmultn +wmultz +wmv +wname +wnat +wnbdi +wneexpz wnefimgd wneg +wnegn +wneq +wnexpz wnf wnfanf wnfenf wnfnf +wniexpz +wnmul +wnmuln +wnmulz +wnocomment wnorm +wnot +wnotcon +wnwshjt +wobound +wobounds +woclass wod +wodbackwardslicecorrect wodnoninterference +woff wofi wofib +wog wojrcmumresorqualmrlawfqynaxqzugurc +wold wolew +<<<<<<< Updated upstream +wom +womaa +womaan +======= wolf +wom +womaa +womaan woman +>>>>>>> Stashed changes +womao +womaon +woml +womle +womni won wonder +wonderful +wone wonelection +wones +wonky wont +woo woodbury +woody woot wop +wopen +wopi wopprc woppside woprm +wopt +woptv wor word +worda +wordb +wordbinn +wordbit +wordconvs +wordcount +wordcountprogscript +wordempty +wordfix +wordfreq +wordfromint +wordfromword +wordhigher wordinterval +wordintervalt +wordlang +wordlen +wordlength +wordlisti +wordlistp +wordloc wordn +wordnat +wordnotnot +wordok +wordop +wordopw +wordp wordplay +wordplus wordpress wordprod +wordq +wordrot words wordsby +wordsem +wordseqtobytes wordset +wordshift +wordshiftw +wordsize +wordt +wordtest +wordtheory +wordtoint +wordton +wordtonat +wordtonum +wordtoz +wordtree +wordw +wordwok +wordxor +worht work workaround +workbag +workd worked worker +workers +<<<<<<< Updated upstream +workforce +======= +>>>>>>> Stashed changes workhorse working +workit worklist +worklists works +workset +workshops workspace +worl world +worldlater +worldnec +worldp worlds +worldsd +wormhole +worne +worried worry +worrying worse +worseguy worst worth +worthwhile +woseg woset +wosetequiv +wosetpath +wosetstr wot +wou would wouldn wound +wov +wow +<<<<<<< Updated upstream +======= woz +>>>>>>> Stashed changes wpa +wpapplyf +wparam +wpassert wpath wpathcaseson wpathdestleft wpathdestright +wpb +wpbind wpc +wpcasenat wpd +wpdenvalue +wpdr +wpeexpz +wpexpn +wpexpz +wpget +wpiexpz +wpif wpl +wpltype +wplus +wplusn +wplusz wpmk +wpmodify +wpmtypes +wpmul +wpmuln +wpmulz wpo +wpoption wpos +wpow +wpp +wpprod +wpput +wpre wprec +wpred +wpref +wprefix +wprefixes +wpreturn +wprimrec +wprog +wprop +wpropp +wps +wpsome +wpstackvalue +wpstypes +wpt +wpthrow wpthswwlks +wptostate +wptr +wptype +wptypes wqivdvddkuuebsnmeslnztpqkubl +wql wqo +wqoset +wqprrdy +wqzisri +wra wrack wraith +wran +wrank +wrankrel wrap wraparound wrapc +wrapedkmaterial wraph +wraponlyedkmaterialoutput +wrapp wrapped +wrappedawsencryptionsdkconfig +wrappedawsencryptionsdkconfigwithsuppliedcommitment +wrappedawsencryptionsdkconfigwithsuppliedcommitmentretrypolicy +wrappeddefaultawsencryptionsdkconfig +wrappeddefaultmaterialprovidersconfig +wrappedmaterial +wrappedsap wrapper wrappergenericjoin +wrappers wrapping +wrappper +wraps wrapsimpdischarger +wrapstringtoerror wrapsumaccess wrb +wrc +wrchs wrd wrdco wrddm @@ -85731,61 +143545,162 @@ wrdsymb wrdsymbcl wrdt wrdumgr +wrdumgren wrdupgr +wrdupgren wrdv wrdval wrec wrecs wrecseq +wreg +wregimm +wregwrite +wrep wrepr +wrest +wretr +wretrt +wrgcvdr +wri +wriggle +wright +writ +writabl writable +writablepagesintable write +writea +writeaad +writeaadpair +writeaadpairs +writeaadsection writeable +writeback +writebyte +writebytes +writebytestofile writecarray writecarraycorrect +writecode +writecontenttype writecorrect writed +writedecryptmanifest +writedmem +writee +writeelements +writeemptyecorwriteaad +writeemptyecorwriteaadiscorrect +writeencrypteddatakey +writeencrypteddatakeys +writeencrypteddatakeysisdistributive +writeencrypteddatakeyssection +writeesdksuiteid +writeexpandedaadsection writeextendcorrect writefailcorrect writefile +writefinalframe +writeframedmessagebody +writeheaderauthtag +writeheaderauthtagv +writeheaderbody +writei +writel +writelastbyte +writelastbytes +writeline +writelist +writemessageformatversion +writemessageid +writemessageregularframes +writemode +writen +writenewbranchkeyversiontokeystore +writenewkeytostore writenoextendcorrect +writenonframed +writenonframedmessagebody +writep writepcp +writeperm writepsp writepss writer +writeregularframe +writerequests +writerf +writers writert writertimonadwriter writes +writeshortlengthseq +writespsr +writestuff writesucceedcorrect +writet +writeuint +writev +writevectorsfile +writeword +writin writing written writtenincharts writteninextchartat writteninextend +wrl +wrld wrm wrmrm +wrnd wrong +wrongindex wrongly +wrongtok +wronski wronskian wronskianbilin +wront +wrote wrp wrpsr +wrshift +wrshifta wrt wrtbr +wrti +wrtl wrwim wry +wsac wsameside +wsat wscmgqboniznljmcaivytrzta wseq wset wsetoid +wsewpch wsh +wshareinst +wsi +wsierp +wsize +wsk +wskel +wslist +wslt +wsn wsnd wsort +wsorted wsp +wspace wspathsn wspathsnon wspdisj +wspi wspiundisj wsplem wspmdisj @@ -85806,30 +143721,68 @@ wspthsnwspthsnon wspthsswwlkn wspthsswwlknon wspv +wsqrtr +wss +wssexp +wssq +wstack +wstackload +wstackstore +wstar +wstarcont wstate +wstd +wstring wsts +wsubgraph wsuc wsuccl wsuceq wsucex wsuclb wsuclem +wsuff +wsuffix wswfuuzisbzwkz wsx +wsz wta +wtbinop wtc +wtcount +wtdyncast wte +wterm +wtext +wtextlist +wtf wtfsym +wtft wtgoldbnnsum wth wtimes wtl wtn +wto wtpb wtpsym +wtrans +<<<<<<< Updated upstream +======= wtrt +>>>>>>> Stashed changes +wtru wts +wtsb +wtstaticcast +wttdgs +wtte +wtw +wty +wtycon wtype +wtypep +wug wun wunccl wuncid @@ -85877,17 +143830,35 @@ wuntr wunun wununi wunxp +wus wusdgawgzozkbmsmnpoxrlirpirxevhokmfufsuojcqzonicitqfeym wustl +wuv wux +wvalue +wvc wvfvlgxrring +wvgraph +wvgraphseq +wvlc +wvm wvomhjbatb +wvp +wvsubgraph +wvtfunc wvx wwalks wwalksn wwalksnon +wwbmp +wwbmpr +wwcom +wwcomd wwf +wwfh wwfusion +wwi +wwires wwlemuld wwlk wwlkbp @@ -85930,29 +143901,44 @@ wwlksubclwwlk wwlkswwlksn wwlktovf wwlktovfo +wwoml +wwtpp wwu www -wwwahwatukeecomafnentertainmentarticles -wwwarthritis -wwwfuntriviacomplayquizcfmqid -wwwinformationblastcomtechnical -wwwpoweripodsearchinfobrown -wwwsurgerydoorcoukmedconsprintasprecno -wwwthedailybulletincompostcardsmar wwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwww wwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwww wwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwww wwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwww wwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwww wwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwww +wxor wxybaomouhjiswagh +wystarczy wzel +wzero wzm wzmhpcoicvkadv wzzct xaa +xaauy +xaaw +xab +xababa +xabb +xabuy +xabw +xac +xacc +xaccea +xaccv +xacf +xacuy +xacw +xad +xadc xadd xaddass +xaddc xaddcl xaddcld xaddcom @@ -85963,6 +143949,7 @@ xadddir xaddeq xaddf xaddge +xaddid xaddlem xaddlid xaddlidd @@ -85972,90 +143959,412 @@ xaddnepnf xaddpnf xaddrid xaddridd +xaddrs xaddval +xaduy +xadw +xae +xaeee +xaeuy +xaew +xaf +xafc +xafuy +xafw +<<<<<<< Updated upstream +======= xan +>>>>>>> Stashed changes +xand +xaoo +xarg xargs +xargsp +xarray +xas +xassoc +xaw +xax +xay +xba xbar +xbasq +xbauy +xbaw xbb +xbba +xbbuy +xbbw +xbc +xbcf +xbcuy +xbcw +xbd +xbduy +xbdw +xbe +xbebfbc +xbef +xbefa +xbeuy +xbew +xbf +xbfc +xbffcd +xbfuy +xbfw xbi +xbinding +xbinop +xbit xblcntr xblcntrps +xblm xbln +xblock xblpnf xblpnfps xblss +xbo xbody +xboo +xbool xboole +xboolean +xbound +xbp +xbranch xbrvjfntgznhlkivlqzmfwfofuwbblfodebhd +xbuild +xbw xbwhafosca +xbyte +xbytes +xca +xcall +xcanon +xcausey +xcauseyf +xcauseyfkey +xcauseyfp +xcauseyp +xcauy +xcaw +xcb +xcbbb +xcbfa +xcbuy +xcbw xcc +xccd +xccuy +xccw +xcd +xcduy +xcdw +xce +xceda +xceuy +xcew +xcf +xcfa +xcfun +xcfung +xcfunzl +xcfunzr +xcfuy +xcfw +xch +xchange xchbinx xchbinxr +xchg xchnxbi xchnxbir +xchoose +xchoosep xclass +xclear +xcmp +xcmpl +xcmplx +xcmpxchg +xcode +xcol +xcole +xcombine +xcond +xconn +xcons +xconst +xcontupdate +xcoord +xcost xcp +xcprod +xcprodm +xcprodme +xcprodmel +xcprodmer +xcprodmi +xcprodml +xcprodmr +xcprodp xcpt xcpts +xcr xcs +xcut +xcw +<<<<<<< Updated upstream +======= xcx +>>>>>>> Stashed changes xczelfhec +xda +xdab +xdaf +xdata +xdauy +xdaw +xdb +xdbeb +xdbl +xdbuy +xdbw +xdc +xdcd +xdcuy +xdcw xdd +xddfbcc +xdduy +xddw xde +xdec +xdef +xdel +xdepth +xdest +xdet +xdeuy +xdew +xdf +xdfea xdfustzttijrspxqm +xdfuy +xdfw xdgdirectory xdgdirectorylist +xdi xdictates xdiv xdivcl xdivcld xdivid +xdivided xdivmul xdivpnfrp xdivrec xdivval +xdo +xdoc +xdot +xdp xdr +xdw +xdx xdyhnrspbnavfwq +xea +xeaa +xeafc +xeauy +xeaw +xeb +xebc +xebuy +xebw +xec +xecuy +xecw +xed +xedb +xedge +xedni +xeduy +xedw xee +xeeuy +xeew +xef +xefac +xefb +xefbe +xefcdab +xefuy +xefw +xeh +xeip xelcsdfiuwfyrvlehweoivclg +xelements +xelet +xenc +xenv xeq +xeqi xeqlelt +xequ +xequiv +xer +xes +xeval +xew +xexecute +xexp +xexpr +xfa +xfacabf +xfactorthru +xfae +xfan +xfauy +xfaw +xfb +xfbuy +xfbw +xfc +xfcd +xfcefa +xfcuy +xfcw +xfd +xfdd +xfde +xfduy +xfdw +xfe +xfee +xfefefefefefefefew +xfer +xfers +xfeuy +xfew +xff +xffa +xffb +xffc +xffcw +xffeff +xfff +xfffa xffff +xffffc +xffffefffffc +xfffff +xffffff +xfffffff +xfffffffcw +xfffffffdw +xfffffffew xffffffff +xffffffffff +xffffffffffff +xfffffffffffff +xffffffffffffff +xffffffffffffffed +xfffffffffffffffc +xfffffffffffffffdw +xfffffffffffffffew +xffffffffffffffff +xfffffffffffffffffffffffffffffffe xffffffffffffffffffffffffffffffff +xfffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc +xffffffffffffffffw +xfffffffffffffw +xfffffffful +xffffffffw +xffffw +xfffw +xffuy +xffw +xfind +xfinsequence +xfinsequences xfirst +xfirstn xfktsjrn +xfml +xfmlls +xfmllsv +xfmlv +xfold xfollow +xfoo +xfoof +xfoom +xforestinc +xformer xfr +xframe xfrcnv xfrcnvlem xfree xfrf xfrgim +xfromc xfrval +xfs +xfw xgcd xgcdaux xgcdtype +xgcombine xgepnf +xget +xgetbv +xgetempty +xgeti +xgetp +xgetpex +xgetpn +xgmap +xgo xgp +xha +xhat xhatmin +xheex xhex +<<<<<<< Updated upstream +======= xhh +>>>>>>> Stashed changes +xhi +xhyp +xicm xid xideal +xident xihopellsmn xii +xiii xij xim +ximm +ximpnx xin xinc +xincrement +xinf xinh xini xinit xinst xintermsofw +xints xinun xinv +xio xis xiso xisobiprod @@ -86063,10 +144372,19 @@ xisocycles xisoofeq xisoopcycles xistential +xists +xit +xiv +xivphks xix +xjcc xjg +xjit +xjmp xjvgkpipvyifqslhjwyru xjytfwlozjf +xkey +xkeys xkobval xkoccn xkocnv @@ -86086,14 +144404,30 @@ xkotop xkotopon xkouni xkoval +xkskeyidtype +xksproxyauthenticationaccesskeyidtype +xksproxyauthenticationrawsecretaccesskeytype +xksproxyuriendpointtype +xksproxyuripathtype +xksproxyvpcendpointservicenametype +xla +xlat +xlate +xlati +xlation xle +xlea xleadd +xleaddadd +xleaf xlebnum xledec +xleex xlem xlemmas xlemnf xlemul +xlen xleneg xlenegcon xlesubadd @@ -86125,17 +144459,39 @@ xlimres xlimresdm xlimuni xlimxrre +xlisp +xlist +xlo +xlock +xloop +xlr +xlrup +xlrups +xlrupv xlt xltadd xltmul xltneg xltnegi +xmac +xmap +xmas +xmask +xmasnetwork +xmasnetworkp +xmatch +xmax +xmaxq +xmaxqexists xmem xmemcell xmemd xmemi xmeml +xmemo +xmemory xmemu +xmerge xmet xmetcl xmetdcn @@ -86149,18 +144505,37 @@ xmetge xmetgt xmetlecl xmetpsmet +xmetrel xmetres xmetresbl xmetrtri xmetsym xmettpos xmettri +xmettx +xmettxlem xmetunirn xmetutop +xmetxp +xmetxpbl +xmin +xminf +xminq +xminqexists xml xmldoc xmlor xmls +xmm +xmms +xmonemx +xmonemxc +xmonemxm +xmonemxn +xmonop +xmov +xmovzx +xmsb xmscl xmseq xmsge @@ -86175,6 +144550,7 @@ xmsxmet xmul xmulass xmulasslem +xmulc xmulcand xmulcl xmulclb @@ -86217,41 +144593,90 @@ xnext xnextiso xnextisoself xney +xnhpwab +xnil +xnk xnl +xnlist xnn +xnode xnor +xnorm +xnot xnpcan +xnum +xnx xnz +xobj +xoccurrences xode +xoftimestampbeyonddecision +xohled +xoo xop xopiso xor +<<<<<<< Updated upstream +======= xora +>>>>>>> Stashed changes +xoranor xorass +xoraw xorb xorbi +xorbin +xorbyte xorcom xorcoma xorcomb +xordc xordi +xordidc +xored xorexmid xorfal +xori +xorig +xorigv +xorimm +xorl +xorlimm +xorloop xornan +xornbi +xornbidc xorneg xornot +xorold xoromon xoror +xorp xorpif xorpifn +xorr xorrot xors +xorsf +xorsfs +xorsl +xorsls +xort xortac xortru xos +xout xov +xox xpab +xpad +xpair +xpairf xpassen +xpassenlem +xpc xpcan +xpcanm xpcbas xpccat xpccatid @@ -86270,11 +144695,13 @@ xpco xpcogend xpcoid xpcoidgend +xpcom xpcomco xpcomen xpcomeng xpcomf xpcossxp +xpcp xpcpropd xpct xpcval @@ -86297,11 +144724,11 @@ xpfi xpfir xpg xphe -xphi xpid xpider xpidtr xpiindi +xpiindim xpima xpimasn xpindi @@ -86312,30 +144739,54 @@ xpintrreld xpiun xpiundi xpiundir +xpkeq +xpkex +xpkexg +xpkssvvk +xpkvexg +<<<<<<< Updated upstream +======= xpl +>>>>>>> Stashed changes +xpm xpmapen xpmapenlem +xpmlem xpncan +xpnedisj xpnnen xpnum xpnz xpnzex xpnzexb +xpoly xpomen +xpop +xpopad xpopth xpord xporderlem xpos xposdif +xposition +xpow xppreima xpprsng xppss +xpr +xpre +xpred +xpredp +xpredt xpreen xpref +xprefix xprev xpreviso xprevisoself xpriindi +xpriindim +xprime xprod xprodname xprodtype @@ -86354,7 +144805,6 @@ xpsfrnel xpsfval xpsgrp xpsgrpsub -xpsi xpsinv xpsle xpsless @@ -86391,25 +144841,47 @@ xptrrel xpun xpundi xpundir +xpush +xpushad xpv +xpvv xpwdomg xpwf xpz +xqltnle +xqp +xqq xqvwnx xqyycropxxstrjnl +xqz xqzgwuvsb xraddge xralrple +xrbdtri xrcl xrclmpt xrcmp xrconn xrdifh +xrea +xread +xreal xreceu xrecex +xrecqns +xref +xreg +xregs +xregsp +xregul +xregular +xremove +xrep xreqle xreqled xreqnltd +xres +xret xrex xrf xrge @@ -86428,6 +144900,7 @@ xrinfm xrinfmexpnf xrinfmss xrinfmsslem +xrl xrleid xrleidd xrleloe @@ -86436,6 +144909,7 @@ xrlelttr xrlelttrd xrlelttric xrlemin +xrlemininf xrleneltd xrlenlt xrlenltd @@ -86450,7 +144924,9 @@ xrltled xrltlen xrltletr xrltletrd +xrltmaxsup xrltmin +xrltmininf xrltne xrltned xrltnle @@ -86461,15 +144937,41 @@ xrltso xrlttr xrlttrd xrlttri +xrm xrmax +xrmaxadd +xrmaxaddlem +xrmaxcl xrmaxeq +xrmaxif +xrmaxifle +xrmaxiflemab +xrmaxiflemcl +xrmaxiflemcom +xrmaxiflemlub +xrmaxiflemval xrmaxle +xrmaxleastlt +xrmaxleim +xrmaxlesup xrmaxlt +xrmaxltsup +xrmaxrecl xrmin +xrminadd +xrmincl xrmineq +xrmineqinf +xrminltinf +xrminmax +xrminrecl +xrminrpcl +xrmnfdc xrmulc xrnarchi xrncnvepresex +xrnegcon +xrnegiso xrnemnf xrnepnf xrneq @@ -86484,8 +144986,15 @@ xrnres xrnresex xrnss xrofsup +xround +xroundp +xroundval +xrow +xrowe xrpnf +xrpnfdc xrpxdivcld +xrr xrralrecnnge xrralrecnnle xrre @@ -86493,6 +145002,7 @@ xrrebnd xrred xrrege xrrest +xrrr xrs xrsadd xrsbas @@ -86533,47 +145043,149 @@ xrtgioo xrub xrv xsa +xsalsa +xsar +xsb +xsbb +<<<<<<< Updated upstream +======= xsd +>>>>>>> Stashed changes +xsdprodm +xsec +xsection +xsectiond +xsectione +xsectioni +xsectionp +xsectionx xsep +xseq +xseqex +xseqlambda +xseqlambdad xset +xsgn +xshl +xshr xsi +xsize +xsk +<<<<<<< Updated upstream +======= xskijump +>>>>>>> Stashed changes xsmall +xsn +xso +xsound +xsp +xspace xspecy xspgnd +xsq xsr +xsrc xss +<<<<<<< Updated upstream +xssorted +xsss +======= xssa +xssorted xsss xssss +>>>>>>> Stashed changes +xstack +xstackp +xstatus +xsteq +xstickyp +xstring xsty +xsub +xsubc +xsubcl +xsubcp xsubge +xsum xsv xsy +xsym +xsyn +xsys +xtable xtageq xtagex +xte +xterm +xtermp +xtesq +xtest +xth +xtime xtoy +xtr +xtract +xtree +xtrlength +xts +<<<<<<< Updated upstream +======= xtt xttt xtttt +>>>>>>> Stashed changes +xtu +xtupl +xtuple xty xtype xudfn +xuljepr +xun +xunit +xuns +xunstn +xuntag +xunwrap xval +xvar xvec +xvl +xvoid +xvs xvwnqgwormuz +xwid +xwidth +xwitccn +xwnhlmd +xwrite +xxa +xxadd +xxchg +xxdp +xxinclude xxiso xxisoofeq +xxor xxply +xxr +xxre +xxrea +xxreal xxs xxts xxx +xxxjoin +xxxx +xxxxx +xxxxxx xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx xxy -xxyz xxz xyab xyeq @@ -86582,78 +145194,186 @@ xyide xyideal xyinf xyk +xyl xynmngfr +xyofcgx xyqsol xyqsolb xyqsolr +xyrouting xys +xyseq xysunu xyx xyy xyz +<<<<<<< Updated upstream +======= xyzw +>>>>>>> Stashed changes +xyzzy +xzdiffadd +xzdouble xzeqi xzx xzy +xzyz yac +yada yafull +yahya +yak +yall yamamoto +yamazaki yang +yanking +yasunari +yasushi yates +yatsuka +yay ybar ybfull +ybit +ybnd ybody +ybound +ybs +ybt +ybtascz +ybxrvts ybylpejmoqkxgubdnrbjphuuldexbeovcuizrmsoafdbffmpnoyllyysleshgqgdqghppt +ybzfupo +ycalc ycc yclass ycngftys ycngstys +ycomb +ycompression +ycoord +ycost ycs +ycut +ydbl ydlt +yea +yeah +yeahcontains +yeahitistrue +year +yearlength +years yebuvjtwresltogiju +yebwjng yedaryw +yeet +yeilds +yel +yell +yello yellow yelv +yenv yeobfyqzw +yep yeq +yequiv yes +yesat yesmv +yesno +<<<<<<< Updated upstream +======= yesterday +>>>>>>> Stashed changes +yestoaddbutnotsubtract yet +yeu yezoytgx +yfan +yfanadd +yffyf +yfoo +yfoof +yfoom yfpnqgvri yfs +<<<<<<< Updated upstream +======= yftor yftornt +>>>>>>> Stashed changes +yfunctor +yfunctornt yfuptjzqs ygwbhyhfhkzvagiskrfjwowfox +yhi +yhigh yhmubhecabqcqgnookwqyeloygycdzfuxzspqrrvxeucchhsbbczrqoptnoup yhtn +yhyp yid yideal yield +yielded yielding yields +yieldscombinatorialconnectedcwskel +yieldsconnectedcwskel +yieldscwskel +yieldsfincwskel +yifvqdv +yikes yikrunqtoyuqxng yim +yin yins yinst yint +yinv +yissub yjs yle +yleaf ylem +ylist +ylo +ylow +ylphi +ylpsi ymap +ymapimage ymapinv +ymapinvimage +ymapyoneda +ymask +ymax +ymaxq +ymaxqexists ymem ymemi +ymin +yminq +yminqexists +<<<<<<< Updated upstream +======= ymul +>>>>>>> Stashed changes yname ync yne ynn +ynode +ynorm ynotmem ynwjymcgsghqmmgl ynz +yobimpp +yofaithful +yofull +yofullyfaithful yokouchi yon yoncl @@ -86670,11 +145390,14 @@ yonedacommgrpgrpobj yonedacompinclusion yonedacomplimisococones yonedacompsheaftopresheaf +yonedaembedding yonedaequiv yonedaequivfst yonedaevaluation +yonedafaithful yonedafamily yonedafamilyofelements +yonedafull yonedafullyfaithful yonedagluedtosheaf yonedagrp @@ -86682,6 +145405,7 @@ yonedagrpfullyfaithful yonedagrpobj yonedagrpobjisoofrepresentableby yonedagrpobjrepresentableby +yonedainjobj yonedainv yonedaisosheaf yonedajointlyreflectslimits @@ -86706,14 +145430,24 @@ yonffthlem yoniso yonpropd yonval +<<<<<<< Updated upstream +======= york +>>>>>>> Stashed changes +yoshinori you young youngdiagram +younger your +yourself +yout +ype ypo +ypoly ypos ypow +yprod yps ypt yqe @@ -86723,16 +145457,54 @@ yqsol yqsollem yrcyyycxbuv yre +yrecovery +yres yrhs yrjdzyyuv +yround +yroundp +yrs +<<<<<<< Updated upstream +======= ysa +>>>>>>> Stashed changes +ysec +ysection +ysectiond +ysectione +ysectioni +ysectionp +ysectionx +yseq ysharifi +ysi +ysize yspecx +ysr ysrkmlcvbppabdqv yss +yssk +ysskqoy +ystickyp +ysum ysv +ysyn +yth +ytpme +ytran +ytrans +ytree ytwwxcznwyqcju +yty ytype +yuck +yucko +yucky +yug +yuk +yun +yunit +yup yury yval yvaleq @@ -86743,12 +145515,20 @@ yvars yvaumnplwl yvec yvi +yvrejis +yvs yxcjxnunosiwuvihrbq yxinrecipf +yxionxl +yxorz +yxrouting yxs yxwvp yxx +yxxx yxy +yxyx +yyf yys yyx yyy @@ -86759,21 +145539,35 @@ yzgk yzjnzrjrwnnseolxxixrnqmrtzhogjxhttcfflixf yzx zaanen +zab zabs zabscl zabsle +zadc zadd zaddablx zaddcl zaddcld +zaddcllemneg +zaddcllempos zaddcom zaddcomlem zaddscl zaddscld zag +zagier zajszxspkbmsalb +zall +zalllincombmod zamuiol +zand +zap +zapart +zapd +zapne +zapply zar +zarb zarcls zarclsiin zarclsint @@ -86784,6 +145578,7 @@ zarcmplem zarecki zari zariski +zariskicoverage zariskiprecoverage zariskipretopology zariskismainproperty @@ -86796,32 +145591,97 @@ zartop zartopn zartopon zassenhaus +zastapic +zasuvor +zaway +zaz +zbignums +zbinop +zbiory +zbit +zbits zbiuinrgysvvhsermoxfz +zblah +zbot +zbp +zbranch zbtwnre +zbyexpm +zbyte zbytes +zcall +zcash +zcast +zcdive zceil zcf zcg zcgeval zcgform zcgtranslate +zchaff +zchar +zchard +zcharw +zchinese +zchop +zcin +zcint +zcinttests zcld +zclear zclmncvs +zcmc +zcmp +zcmpxchg +zcmult zcn +zcnativetypetests zcnd +zcode +zcoe +zcoef zcompare +zcomplements +zcond +<<<<<<< Updated upstream +======= zcong +>>>>>>> Stashed changes +zcons +zconst zconstr +zcont +zcontents +zcontentsm +zcontentsz +zconts zcount +zcpuid +zcs zct +zcuint zcuts +zdata +zdbl +zdceq +zdcle +zdclt +zdec +zdecomp zdef zdend +zdest zdi zdiff +zdigit +zdigits zdis zdiv zdivadd +zdivdec +zdivdiv +zdivdivdiv zdivgd zdivide zdivides @@ -86835,23 +145695,52 @@ zdivideszquotient zdivideszquotientinv zdivmod zdivmul +zdrivers +zdrop zdsu +zdvdsdc +zdynamic +zea +<<<<<<< Updated upstream +======= +zebra +>>>>>>> Stashed changes zeckendorf zeckendorfequiv +zed +zeda +zeff zefldiv +zeip +zencode zeneo +zenith zenom zeo zeoaltv +zeoxor +zephyrus zeq +zeqb +zeqdec +zeqmod zequiv zeqzmulgcd zer +zerase +zerbl zerdivemp +<<<<<<< Updated upstream +zerg +zermelo +======= zerf +zerg +>>>>>>> Stashed changes zero zeroa zeroadd +zeroalwayssmaller zeroatfilter zeroatfilteraddsubmonoid zeroatfiltersubmodule @@ -86860,29 +145749,56 @@ zeroatinfty zeroatinftycontinuousmap zeroatinftycontinuousmapclass zerob +zerobitofeven zeroc +zeroclc zerocochain zerocokernelcofork zerocokernelofzerocancel +zerocomparisontests +zerocomputation zeroconf zeroconst zerocoprodiso +zerocopy +zerocoset zerod zerodefault zerodefaultsupp +zerodimensional +zerodiv +zerodivisor +zerodivisors zeroed +zeroegal +zeroeqc zeroequiv zeroes +zeroevenkey +zeroevenkeys +zeroext +zeroextend +zerof zerofix +zeroflag +zeroformula zerofree zerofun zerofunc +zerogcd +zerogpd +zeroheightmultielim +zeroheightmultielimaux +zeroheightreachableelim +zeroheightreachableelimaux +zerohk zerohom zerohomclass zerohypercover zerohypercovers zerohypercoversmall zeroi +zeroimpossible zeroisinitial zeroisoinitial zeroisoisinitial @@ -86894,71 +145810,121 @@ zeroize zerokernelfork zerokernelofcancelzero zerol +zerolc zerole zeroleone zeroleoneclass +zerolessone zerolocus zerolocusequivirreduciblecloseds zerolt +zerom +zeromap zeromemclass +zeromodality zeromorphisms zeromorphismsofzeroobject zeromul +zeromult +zeromultiplicity +zeron +zeronevergreater +zeronotinimagesuc +zeronotsuc +zeronotsucc zeroo zeroobject +zerooddkey +zerooddkeys zerooffactmem zeroofn zeroone +zeroonestr +zeroop zeroopropd zeroopropdlem zeroorcl zeroorderbot zerooval zerop +zeropad +zeropos zeropow zeroprodiso +zeroproduct +zeroq zeror +zerorange +zerorangek zerorank +zerorc +zerorepresentable zeroringprod zeroroot zerorootsubalgebra zeros +zerosandones zerosection +zeroseq +zeroset +zerosign +zerosized zerosnd zerospace +zerostr +zerosum +zerosv +zerot zeroth zerothhomotopy +zeroturing zerou zerounique zerovec +zerovect zerovector +zerox +zeroxxx +zerp +zerror zesq +zestandaryzowanych zesxpvzbamueh zeta zetaasymptotics zetacvg zetadelta +zetadiff zetamul zetareduce zetas +zetaterm zetaunit zeven zex zexalt +zexecute +zexp zexpcl zexpcld zexpgcd zexpscl +zext zextle zextlt +zextract zfac zfact zfallfaccl +zfast zfausab zfauscl +zfax zfaxioms zfbas +zfbij zfc +zfcartprod zfcndac zfcndext zfcndinf @@ -86966,18 +145932,42 @@ zfcndpow zfcndreg zfcndrep zfcndun +zfcompind zfdata zfdepth zfdepthinnat zfdepthsuc +zfel +zffun +zffunapp +zffuncod +zffuncomp +zffuncompapp +zffuncompappdomcod +zffuncompappzffun +zffuncompassoc +zffundom +zffundomainopair +zffundomappcod +zffunext +zffunidleft +zffunidright +zffuntolambda zfind +zfinduction zfinf zfinj +zfirstn zfloo zfloor +zfmi +zfmis zfmisc +zfmodel +zfnuleu zfpair zfpow +zfrefle zfreg zfregcl zfregclold @@ -86985,77 +145975,156 @@ zfregfr zfregs zfrep zfrepclf +zfschex +zfschproperty +zfschresult +zfschuniq zfset zftfst zftype +zfull zfun zfv +zfz +zgcd +zgcdn zgcdsq zge +zgeb zgeltp +zggcd +zggcdn +zghost +zgroup +zgroups zgt zgtp zgx zgy zgz +zhang +<<<<<<< Updated upstream +======= zhat +>>>>>>> Stashed changes zhdbk zhikkvjyjbxletgebrtilxbcbx zhmnrg zhmset +zhops +zie +zif zify zifyproof +zig zigzag +zigzagrel zigzagsetoid +zimm zin +zinc +zind zindbi zindd +zindexed zinf +<<<<<<< Updated upstream +======= zinfandel +>>>>>>> Stashed changes +zinfmin zinj +zinsert +zint +zinv +zio zip +zipa zipall +zipc +zipconcat +zipd +zipi zipidx +zipinfo zipleft +ziplists ziplocationwf +zipped zippel zipper +zippers +zipping +zipr zipright +ziprt zipwith zipwithl zipwithleft +zipwithlength zipwithm zipwiths zipwithstep +zipxor +zipzip +zis zisinitial +zisometry +ziter +zithlqn ziuhxzuoatpykri ziv +zjcc +zjewpap +zjmp +zksemaphore zkytedwczslhvfbvtnabqdjperf zla +zlabs +zland zlattice zlc zlcms zle +zlea zleabs +zleb zlele +zleloe zleltp +zlelttric zlem zlemma +zlemshrink +zlemstep +zlen zlength +zlengthblocks zlengthv zless zletr +zletric +zlf +zlfw +zli zlidl zlidlring +zlikeops +zlincombmod +zlincombmodlincombmod +zlisp zlist zlm zlmassa zlmbas +zlmbasg zlmclm zlmds zlmlem +zlmlemg zlmlmod zlmmulr +zlmmulrg zlmnm zlmodzxz zlmodzxzadd @@ -87070,25 +146139,46 @@ zlmodzxzscm zlmodzxzsub zlmodzxzsubm zlmplusg +zlmplusgg zlmsca zlmtset zlmval zlmvsca +zlmvscag +zlo +zlock +zlocs zlog +zlookup +zloop +zlor zlt zltaddlt zltlem +zltlen zltlesub +zltnle zltnormminvnum zltp +zlxor +zlz +zlzthic zmap zmax +zmaxcl zmaxle +zmaxss zmaxsym +zmem +zmemory +zmf +zmieniona zmin zminus +zmm zmo zmod +zmoda zmodaddcyclicaddequiv zmodaddequiv zmodaddequivofgenerator @@ -87097,6 +146187,8 @@ zmodchardef zmodcl zmodcld zmodcyclicmulequiv +zmoddec +zmoddivmin zmodeq zmodequivtrunc zmodequivzpowers @@ -87107,22 +146199,34 @@ zmodhom zmodid zmodidfzo zmodidfzoimp +zmodmge +zmodmod zmodmodule zmodmulequivofgenerator zmodp +zmodpq +zmodpred zmodrepr zmodtype +zmodul zmodule +zmodvge +zmodxge zmodxquotspanequivquotspan zmodxquotspanequivquotspanpair +zmonop +zmov +zmovzx zmowhvjchdqeeegocilcwvjlrmnxnlhgfanfywhqxnixmmahegvfya zmset +zmul zmulcl zmulcld zmulcom zmulcomlem zmulscld zmult +zmultdrop zmulti zmultiples zmultiplesaddhom @@ -87131,9 +146235,13 @@ zmultiplesquotientstabilizerequiv zmultiset zmx znadd +znamegen znat +znatlike +znatp znbas znbaslem +znbaslemnn znchr zncrng znctgqlfbtumcd @@ -87142,25 +146250,30 @@ zndvdchrrhm zndvds zne znearest +znearesta zneareste zneg znegcl znegclb znegcld +znege znegscl znegscld zneo zneoaltv +zneq znf znfermltl znfi znfld zngdl znhash +znidom znidomb znle znleval znlidl +znllldl znm znmul znn @@ -87170,12 +146283,16 @@ znnnlt znnsub zno znod +znop znot +znots +znotsp znq znrrg zns znsqcld znth +znthv zntos zntoslem znum @@ -87191,32 +146308,74 @@ zob zobis zobist zodd +zodiv +<<<<<<< Updated upstream +======= zoey +>>>>>>> Stashed changes +zofb +zofbofz +zoff +zoffloat zofldiv +zofsingle +zoi +zoid +zolatarev +zolatarevu +zolotarev +zolotarevu +zomod zone zoneddatetime +zones +zoo zookeeper +zoola zoom zooms zoomstrin zoomstring zooopst +zoperand zopp +zor zorder +zoretr +zoretrt zorn zorng +zornmax +zornmin zornn zorns +zornslemma +zornslemmaforpreorders zout +zoutreduction +zow +zozo zpassign +zpc +zpgpxnn zpls zplus zplusmodne +zpm +zpmm +zpmod +zpmult zpnn zpo +zpocklington +zpoint +zpolyeprim +zpop +zpopad zpos zpow zpower +zpowering zpowers zpowersequivsupport zpowersequivzpowers @@ -87227,28 +146386,55 @@ zpowgrouphom zpowloggi zpowrec zpqqcrrlssda +zpre zpred +zprefix +zprefixes +zprime +zprimeprime +zprimitive +zprimitivem +zprimitivez zprod +zprodap +zproddc zprodn +zproduct +zproductproduct zps +zpure +zpush +zpushad +zpx zqssxy +zqt +zquot zquotient zquotientmonotone zquotientpos zquotientprop zquotientunique zquotientzopp +zqx +zqy zrab +zrange zrdivrng zre +zread +zreal zrec +zrecspace zred +zreg zrei +zret zrevaddcl zrh zrhchr zrhcntr zrhcopsgnelbas +zrhex zrhf zrhker zrhmulg @@ -87266,6 +146452,7 @@ zrhrhm zrhrhmb zrhunitpreima zrhval +zrhvalg zring zringabl zringbas @@ -87293,7 +146480,10 @@ zringsubgval zringunit zrinitorngc zriotaneg +zrip +zripbase zrisefaccl +zrm zrnd zrng zrngaabl @@ -87313,6 +146503,8 @@ zrngnmrid zrngnring zrninitoringc zrnlvec +zroot +zror zround zroundz zrrnghm @@ -87322,12 +146514,28 @@ zrtermoringc zrtermorngc zrv zrzeroorngc +zsame +zsar +zsbb zsbday +zscale zsd zseo zsep zset zsex +zsgn +zshiftin +zshiftl +zshiftr +zshl +zshr +zsign +zsimpl +zsize +zskipn +zsl +zslice zsmul zsmuladdgrouphom zsmulargs @@ -87335,52 +146543,103 @@ zsmulmemclass zsmulrec zsnkk zsodd +zsop zsoring zspan zspot zsqcl zsqrtd zsqrtelqelz +zsr +zsrc +zss zsscn +zssinfcl zssno zssq zssre zsssubrg zssxr +zstack +zstar +zstatus zstspark +zsub zsubcl zsubcld zsubrg zsubscld zsucc zsum +zsumdc +zsupcl +zsupcllemex +zsupcllemstep +zsupmax zsupss +zsupssdc +zsziuqe +ztep +ztest +ztestbit +ztg zthrhqezai +ztoc +ztonat +ztoreg +ztoword ztpoly ztprmneprm +ztran +ztrans +ztri ztrunc zulip zulipchat +zunit zususgkeqpbuvagt zuzacfk zva +zval +zvec +zvecp +zwadd +zweak zwei +zwf +zwords +zwordsize +zwrite +zwvcbmn +zxadd +zxchg zxene zxhzrqxrxgy +zxor zxr zxrd zxwgt zxy zxyraiwttcmngajkk zxz +zyfunctor +zyfunctorembedding +zyfunctorinjobj zygmund zyjbucgdbyjjr zyz +zzchk zzd +zzed +zzero zzho zzlesq +zzlikeops zzngim zzring zzsnm +zzv +zzz +zzzz zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz